diff --git a/.astylerc b/.astylerc
deleted file mode 100755
index 450a57322f0..00000000000
--- a/.astylerc
+++ /dev/null
@@ -1,20 +0,0 @@
-##############################################################
-# Documentation is available from                            #
-# http://astyle.sourceforge.net/astyle.html          	     #
-##############################################################
-
-### Options ###
---pad-header
---unpad-paren
---suffix=none
---convert-tabs
---attach-inlines
---attach-classes
---attach-namespaces
-
-### Settings ###
---style=kr 
---indent=spaces=4
---indent-namespaces
---lineend=linux
---min-conditional-indent=0
diff --git a/.clang-tidy b/.clang-tidy
new file mode 100644
index 00000000000..b83436861bd
--- /dev/null
+++ b/.clang-tidy
@@ -0,0 +1,94 @@
+---
+Checks: >
+        *,
+        -abseil-*,
+        -altera-*,
+        -android-*,
+        -boost-*,
+        -cert-*,
+        -cppcoreguidelines-*,
+        -darwin-*,
+        -fuchsia-*,
+        -google-*,
+        -hicpp-*,
+        -linuxkernel-*,
+        -llvm-*,
+        -llvmlibc-*,
+        -mpi-*,
+        -objc-*,
+        -openmp-*,
+        -zircon-*,
+        cppcoreguidelines-pro-type-static-cast-downcast,
+        cppcoreguidelines-rvalue-reference-param-not-moved,
+        google-explicit-constructor,
+        -bugprone-assignment-in-if-condition,
+        -bugprone-branch-clone,
+        -bugprone-command-processor,
+        -bugprone-easily-swappable-parameters,
+        -bugprone-empty-catch,
+        -bugprone-macro-parentheses,
+        -bugprone-narrowing-conversions,
+        -bugprone-signed-char-misuse,
+        -bugprone-switch-missing-default-case,
+        -bugprone-throwing-static-initialization,
+        -bugprone-unchecked-optional-access,
+        -clang-analyzer-*,
+        -concurrency-mt-unsafe,
+        -misc-const-correctness,
+        -misc-no-recursion,
+        -misc-non-private-member-variables-in-classes,
+        -misc-throw-by-value-catch-by-reference,
+        -misc-use-anonymous-namespace,
+        -modernize-avoid-c-arrays,
+        -modernize-deprecated-ios-base-aliases,
+        -misc-include-cleaner,
+        -misc-multiple-inheritance,
+        -misc-unused-using-decls,
+        -modernize-avoid-c-style-cast,
+        -modernize-loop-convert,
+        -modernize-macro-to-enum,
+        -modernize-raw-string-literal,
+        -modernize-replace-auto-ptr,
+        -modernize-return-braced-init-list,
+        -modernize-type-traits,
+        -modernize-use-designated-initializers,
+        -modernize-use-nodiscard,
+        -modernize-use-scoped-lock,
+        -modernize-use-trailing-return-type,
+        -performance-avoid-endl,
+        -performance-inefficient-string-concatenation,
+        -performance-no-automatic-move,
+        -portability-avoid-pragma-once,
+        -portability-simd-intrinsics,
+        -portability-std-allocator-const,
+        -readability-avoid-nested-conditional-operator,
+        -readability-braces-around-statements,
+        -readability-container-data-pointer,
+        -readability-enum-initial-value,
+        -readability-function-cognitive-complexity,
+        -readability-function-size,
+        -readability-identifier-length,
+        -readability-identifier-naming,
+        -readability-implicit-bool-conversion,
+        -readability-inconsistent-ifelse-braces,
+        -readability-isolate-declaration,
+        -readability-magic-numbers,
+        -readability-redundant-parentheses,
+        -readability-suspicious-call-argument,
+        -readability-uppercase-literal-suffix,
+        -readability-use-concise-preprocessor-directives,
+        -misc-unconventional-assign-operator
+WarningsAsErrors: '*'
+HeaderFilterRegex: '(cli|gui|frontend|lib|oss-fuzz|test|triage)\/[a-z_]+\.h'
+ExcludeHeaderFilterRegex: 'ui_.*.h'
+CheckOptions:
+  - key:             misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic
+    value:           '1'
+  - key:             readability-simplify-boolean-expr.SimplifyDeMorgan
+    value:           '0'
+  - key:             modernize-use-trailing-return-type.TransformFunctions
+    value:           false
+  - key:             misc-override-with-different-visibility.DisallowedVisibilityChange
+    value:           widening
+  - key:             misc-use-internal-linkage.AnalyzeTypes
+    value:           false
diff --git a/.codacy.yml b/.codacy.yml
index 855f04b6e54..dcfec8e5c10 100644
--- a/.codacy.yml
+++ b/.codacy.yml
@@ -4,7 +4,5 @@ exclude_paths:
   - htmlreport/example.cc
   - samples/**/bad.c
   - samples/**/bad.cpp
-  - test/test.cxx
   - test/cfg/*.c
   - test/cfg/*.cpp
-  - test/synthetic/*.c
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 00000000000..ed782473718
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,19 @@
+## standard default enconding
+* text=auto
+
+## UNIX specific files
+*.sh    text eol=lf
+
+## Windows specific files
+*.bat               text eol=crlf
+*.cmd               text eol=crlf
+*.ps1               text eol=crlf
+*.vcxproj           text eol=crlf
+*.vcxproj.filters   text eol=crlf
+*.sln               text eol=crlf
+*.wixproj           text eol=crlf
+*.wxi               text eol=crlf
+*.wxs               text eol=crlf
+
+## Binary resources
+*.pdf binary
\ No newline at end of file
diff --git a/.github/workflows/CI-cygwin.yml b/.github/workflows/CI-cygwin.yml
new file mode 100644
index 00000000000..0eee9446869
--- /dev/null
+++ b/.github/workflows/CI-cygwin.yml
@@ -0,0 +1,62 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: CI-cygwin
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'releases/**'
+      - '2.*'
+    tags:
+      - '2.*'
+  pull_request:
+
+permissions:
+  contents: read
+
+defaults:
+  run:
+    shell: cmd
+
+jobs:
+  # TODO: add CMake build
+  build_cygwin:
+    strategy:
+      matrix:
+        # only use the latest windows-* as the installed toolchain is identical
+        os: [windows-2025]
+        platform: [x86_64]
+        include:
+          - platform: 'x86_64'
+            packages: |
+              gcc-g++
+              python3
+      fail-fast: false
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Set up Cygwin
+        uses: cygwin/cygwin-install-action@master
+        with:
+          site: https://mirrors.cicku.me/cygwin/
+          platform: ${{ matrix.platform }}
+          packages: ${{ matrix.packages }}
+
+      # Cygwin will always link the binaries even if they already exist. The linking is also extremely slow. So just run the "check" target which includes all the binaries.
+      - name: Build all and run test
+        run: |
+          C:\cygwin\bin\bash.exe -l -c cd %GITHUB_WORKSPACE% && make VERBOSE=1 -j%NUMBER_OF_PROCESSORS% CXXOPTS="-Werror" test
+
+      - name: Extra test for misra
+        run: |
+          cd %GITHUB_WORKSPACE%\addons\test
+          ..\..\cppcheck.exe --dump -DDUMMY --suppress=uninitvar --inline-suppr misra\misra-test.c --std=c89 --platform=unix64
+          python3 ..\misra.py -verify misra\misra-test.c.dump
+          ..\..\cppcheck.exe --addon=misra --enable=style --inline-suppr --enable=information --error-exitcode=1 misra\misra-ctu-1-test.c misra\misra-ctu-2-test.c
+
diff --git a/.github/workflows/CI-mingw.yml b/.github/workflows/CI-mingw.yml
new file mode 100644
index 00000000000..1b0cf3e5672
--- /dev/null
+++ b/.github/workflows/CI-mingw.yml
@@ -0,0 +1,75 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: CI-mingw
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'releases/**'
+      - '2.*'
+    tags:
+      - '2.*'
+  pull_request:
+
+permissions:
+  contents: read
+
+defaults:
+  run:
+    shell: msys2 {0}
+
+jobs:
+  # TODO: add CMake build
+  build_mingw:
+    strategy:
+      matrix:
+        # only use the latest windows-* as the installed toolchain is identical
+        os: [windows-2025]
+      fail-fast: false
+
+    runs-on: ${{ matrix.os }}
+
+    timeout-minutes: 19 # max + 3*std of the last 7K runs
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Set up MSYS2
+        uses: msys2/setup-msys2@v2
+        with:
+          release: false # use pre-installed
+          # TODO: install mingw-w64-x86_64-make and use mingw32.make instead - currently fails with "Windows Subsystem for Linux has no installed distributions."
+          install: >-
+            mingw-w64-x86_64-lld
+            mingw-w64-x86_64-ccache
+            make
+            mingw-w64-x86_64-gcc
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.workflow }}-${{ github.job }}-${{ matrix.os }}
+
+      - name: Build cppcheck
+        run: |
+          export PATH="/mingw64/lib/ccache/bin:$PATH"
+          # set RDYNAMIC to work around broken MinGW detection
+          # use lld for faster linking
+          make VERBOSE=1 RDYNAMIC=-lshlwapi LDOPTS=-fuse-ld=lld -j$(nproc) CXXOPTS="-Werror" cppcheck
+
+      - name: Build test
+        run: |
+          export PATH="/mingw64/lib/ccache/bin:$PATH"
+          # set RDYNAMIC to work around broken MinGW detection
+          # use lld for faster linking
+          make VERBOSE=1 RDYNAMIC=-lshlwapi LDOPTS=-fuse-ld=lld -j$(nproc) CXXOPTS="-Werror" testrunner
+
+      - name: Run test
+        run: |
+          export PATH="/mingw64/lib/ccache/bin:$PATH"
+          # set RDYNAMIC to work around broken MinGW detection
+          # use lld for faster linking
+          make VERBOSE=1 RDYNAMIC=-lshlwapi LDOPTS=-fuse-ld=lld -j$(nproc) CXXOPTS="-Werror" test
diff --git a/.github/workflows/CI-unixish-docker.yml b/.github/workflows/CI-unixish-docker.yml
new file mode 100644
index 00000000000..a38feb452f0
--- /dev/null
+++ b/.github/workflows/CI-unixish-docker.yml
@@ -0,0 +1,150 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: CI-unixish-docker
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'releases/**'
+      - '2.*'
+    tags:
+      - '2.*'
+  pull_request:
+
+permissions:
+  contents: read
+  
+jobs:
+  build_cmake:
+
+    strategy:
+      matrix:
+        include:
+          - image: "ubuntu:24.04"
+            with_gui: true
+            full_build: true
+          - image: "ubuntu:25.10"
+            with_gui: true
+            full_build: true
+          - image: "alpine:3.23"
+            with_gui: false  # it appears FindQt6.cmake is not provided by any package
+            full_build: false  # FIXME: test-signalhandler.cpp fails to build since feenableexcept() is missing
+      fail-fast: false # Prefer quick result
+
+    runs-on: ubuntu-22.04
+
+    # TODO: is this actually applied to the guest?
+    env:
+      # TODO: figure out why there are cache misses with PCH enabled
+      CCACHE_SLOPPINESS: pch_defines,time_macros
+
+    container:
+      image: ${{ matrix.image }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Install missing software on ubuntu
+        if: contains(matrix.image, 'ubuntu')
+        run: |
+          apt-get update
+          apt-get install -y cmake g++ make libxml2-utils libpcre3-dev
+
+      - name: Install missing software (gui) on latest ubuntu
+        if: contains(matrix.image, 'ubuntu')
+        run: |
+          apt-get install -y qt6-base-dev qt6-charts-dev qt6-tools-dev
+
+      - name: Install missing software on Alpine
+        if: contains(matrix.image, 'alpine')
+        run: |
+          apk add cmake make g++ pcre-dev
+
+      # needs to be called after the package installation since
+      # - it doesn't call "apt-get update"
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.workflow }}-${{ matrix.image }}
+
+      - name: Run CMake
+        run: |
+          cmake -S . -B cmake.output -Werror=dev -DHAVE_RULES=On -DBUILD_TESTING=On -DBUILD_GUI=${{ matrix.with_gui }} -DWITH_QCHART=On -DBUILD_TRIAGE=${{ matrix.with_gui }} -DCMAKE_COMPILE_WARNING_AS_ERROR=On -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
+
+      - name: CMake build
+        if: matrix.full_build
+        run: |
+          cmake --build cmake.output -- -j$(nproc)
+
+      - name: Run CMake test
+        run: |
+          cmake --build cmake.output --target check -- -j$(nproc)
+
+  build_make:
+
+    strategy:
+      matrix:
+        image: ["ubuntu:24.04", "ubuntu:25.10", "alpine:3.23"]
+      fail-fast: false # Prefer quick result
+
+    runs-on: ubuntu-22.04
+
+    container:
+      image: ${{ matrix.image }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Install missing software on ubuntu
+        if: contains(matrix.image, 'ubuntu')
+        run: |
+          apt-get update
+          apt-get install -y g++ make python3 libxml2-utils libpcre3-dev
+
+      - name: Install missing software on Alpine
+        if: contains(matrix.image, 'alpine')
+        run: |
+          apk add make g++ pcre-dev bash python3 libxml2-utils
+
+      # needs to be called after the package installation since
+      # - it doesn't call "apt-get update"
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.workflow }}-${{ matrix.image }}
+
+      # /usr/lib/ccache/bin - Alpine Linux
+
+      - name: Build cppcheck
+        run: |
+          export PATH="/usr/lib/ccache/bin:/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH"
+          make -j$(nproc) HAVE_RULES=yes CXXOPTS="-Werror"
+
+      - name: Build test
+        run: |
+          export PATH="/usr/lib/ccache/bin:/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH"
+          make -j$(nproc) HAVE_RULES=yes CXXOPTS="-Werror" testrunner
+
+      - name: Run test
+        run: |
+          make -j$(nproc) HAVE_RULES=yes test
+
+      # requires python3
+      - name: Run extra tests
+        run: |
+          test/scripts/generate_and_run_more_tests.sh
+
+      # requires which
+      - name: Validate
+        run: |
+          make -j$(nproc) checkCWEEntries validateXML
+
+      - name: Test addons
+        run: |
+          ./cppcheck --addon=threadsafety addons/test/threadsafety
+          ./cppcheck --addon=threadsafety --std=c++03 addons/test/threadsafety
diff --git a/.github/workflows/CI-unixish.yml b/.github/workflows/CI-unixish.yml
new file mode 100644
index 00000000000..8f355644bc2
--- /dev/null
+++ b/.github/workflows/CI-unixish.yml
@@ -0,0 +1,734 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: CI-unixish
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'releases/**'
+      - '2.*'
+    tags:
+      - '2.*'
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  build_cmake_tinyxml2:
+
+    strategy:
+      matrix:
+        os: [ubuntu-22.04, macos-15]
+      fail-fast: false # Prefer quick result
+
+    runs-on: ${{ matrix.os }}
+
+    env:
+      # TODO: figure out why there are cache misses with PCH enabled
+      CCACHE_SLOPPINESS: pch_defines,time_macros
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.workflow }}-${{ github.job }}-${{ matrix.os }}
+
+      - name: Install missing software on ubuntu
+        if: contains(matrix.os, 'ubuntu')
+        run: |
+          sudo apt-get update
+          sudo apt-get install libxml2-utils libtinyxml2-dev
+          # qt6-tools-dev-tools for lprodump
+          # qt6-l10n-tools for lupdate
+          sudo apt-get install qt6-base-dev libqt6charts6-dev qt6-tools-dev qt6-tools-dev-tools qt6-l10n-tools libglx-dev libgl1-mesa-dev
+
+      # coreutils contains "nproc"
+      - name: Install missing software on macos
+        if: contains(matrix.os, 'macos')
+        run: |
+          # pcre was removed from runner images in November 2022
+          brew install coreutils qt@6 tinyxml2 pcre
+
+      - name: CMake build on ubuntu (with GUI / system tinyxml2)
+        if: contains(matrix.os, 'ubuntu')
+        run: |
+          cmake -S . -B cmake.output.tinyxml2 -Werror=dev -DHAVE_RULES=On -DBUILD_TESTING=On -DBUILD_GUI=On -DWITH_QCHART=On -DBUILD_TRIAGE=On -DUSE_BUNDLED_TINYXML2=Off -DCMAKE_DISABLE_PRECOMPILE_HEADERS=On -DCMAKE_COMPILE_WARNING_AS_ERROR=On -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
+          cmake --build cmake.output.tinyxml2 -- -j$(nproc)
+
+      - name: CMake build on macos (with GUI / system tinyxml2)
+        if: contains(matrix.os, 'macos')
+        run: |
+          cmake -S . -B cmake.output.tinyxml2 -Werror=dev -DHAVE_RULES=On -DBUILD_TESTING=On -DBUILD_GUI=On -DWITH_QCHART=On -DBUILD_TRIAGE=On -DUSE_BUNDLED_TINYXML2=Off -DCMAKE_DISABLE_PRECOMPILE_HEADERS=On -DCMAKE_COMPILE_WARNING_AS_ERROR=On -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache -DQt6_DIR=$(brew --prefix qt@6)/lib/cmake/Qt6
+          cmake --build cmake.output.tinyxml2 -- -j$(nproc)
+
+      - name: Run CMake test (system tinyxml2)
+        run: |
+          cmake --build cmake.output.tinyxml2 --target check -- -j$(nproc)
+
+  build_cmake:
+
+    strategy:
+      matrix:
+        os: [ubuntu-22.04, macos-15]
+      fail-fast: false # Prefer quick result
+
+    runs-on: ${{ matrix.os }}
+
+    env:
+      # TODO: figure out why there are cache misses with PCH enabled
+      CCACHE_SLOPPINESS: pch_defines,time_macros
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.workflow }}-${{ github.job }}-${{ matrix.os }}
+
+      # TODO: move latest compiler to separate step
+      # TODO: bail out on warnings with latest GCC
+      - name: Set up GCC
+        uses: egor-tensin/setup-gcc@v1
+        if: false  # matrix.os == 'ubuntu-22.04'
+        with:
+          version: 13
+          platform: x64
+
+      - name: Select compiler
+        if: false  # matrix.os == 'ubuntu-22.04'
+        run: |
+          echo "CXX=g++-13" >> $GITHUB_ENV
+
+      - name: Install missing software on ubuntu
+        if: contains(matrix.os, 'ubuntu')
+        run: |
+          sudo apt-get update
+          sudo apt-get install libxml2-utils
+          # qt6-tools-dev-tools for lprodump
+          # qt6-l10n-tools for lupdate
+          sudo apt-get install qt6-base-dev libqt6charts6-dev qt6-tools-dev qt6-tools-dev-tools qt6-l10n-tools libglx-dev libgl1-mesa-dev
+
+      # coreutils contains "nproc"
+      - name: Install missing software on macos
+        if: contains(matrix.os, 'macos')
+        run: |
+          # pcre was removed from runner images in November 2022
+          brew install coreutils qt@6 pcre
+
+      - name: Run CMake on ubuntu (with GUI)
+        if: contains(matrix.os, 'ubuntu')
+        run: |
+          cmake -S . -B cmake.output -Werror=dev -DHAVE_RULES=On -DBUILD_TESTING=On -DBUILD_GUI=On -DWITH_QCHART=On -DBUILD_TRIAGE=On -DCMAKE_DISABLE_PRECOMPILE_HEADERS=On -DCMAKE_COMPILE_WARNING_AS_ERROR=On -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache -DCMAKE_INSTALL_PREFIX=cppcheck-cmake-install
+
+      - name: Run CMake on macos (with GUI)
+        if: contains(matrix.os, 'macos')
+        run: |
+          cmake -S . -B cmake.output -Werror=dev -DHAVE_RULES=On -DBUILD_TESTING=On -DBUILD_GUI=On -DWITH_QCHART=On -DBUILD_TRIAGE=On -DCMAKE_DISABLE_PRECOMPILE_HEADERS=On -DCMAKE_COMPILE_WARNING_AS_ERROR=On -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache -DCMAKE_INSTALL_PREFIX=cppcheck-cmake-install -DQt6_DIR=$(brew --prefix qt@6)/lib/cmake/Qt6
+
+      - name: Run CMake build
+        run: |
+          cmake --build cmake.output -- -j$(nproc)
+
+      - name: Run CMake test
+        run: |
+          cmake --build cmake.output --target check -- -j$(nproc)
+
+      - name: Run CTest
+        run: |
+          pushd cmake.output
+          ctest --output-on-failure -j$(nproc)
+
+      - name: Run CMake install
+        run: |
+          cmake --build cmake.output --target install
+
+      - name: Run CMake on ubuntu (no CLI)
+        if: matrix.os == 'ubuntu-22.04'
+        run: |
+          cmake -S . -B cmake.output_nocli -Werror=dev -DBUILD_TESTING=Off -DBUILD_CLI=Off
+
+      - name: Run CMake on ubuntu (no CLI / with tests)
+        if: matrix.os == 'ubuntu-22.04'
+        run: |
+          # the test and CLI code are too intertwined so for now we need to reject that
+          if cmake -S . -B cmake.output_nocli_tests -Werror=dev -DBUILD_TESTING=On -DBUILD_CLI=Off; then
+            exit 1
+          else
+            exit 0
+          fi
+
+      - name: Run CMake on ubuntu (no CLI / with GUI)
+        if: matrix.os == 'ubuntu-22.04'
+        run: |
+          cmake -S . -B cmake.output_nocli_gui -Werror=dev -DBUILD_TESTING=Off -DBUILD_CLI=Off -DBUILD_GUI=On
+
+      - name: Run CMake on ubuntu (no GUI)
+        if: matrix.os == 'ubuntu-22.04'
+        run: |
+          cmake -S . -B cmake.output_nogui -Werror=dev -DBUILD_TESTING=Off -DBUILD_GUI=Off
+
+      - name: Run CMake on ubuntu (no GUI / with triage)
+        if: matrix.os == 'ubuntu-22.04'
+        run: |
+          # cannot build triage without GUI
+          if cmake -S . -B cmake.output_nogui_triage -Werror=dev -DBUILD_TESTING=Off -DBUILD_GUI=Off -DBUILD_TRIAGE=On; then
+            exit 1
+          else
+            exit 0
+          fi
+
+      - name: Run CMake on ubuntu (no CLI / no GUI)
+        if: matrix.os == 'ubuntu-22.04'
+        run: |
+          cmake -S . -B cmake.output_nocli_nogui -Werror=dev -DBUILD_TESTING=Off -DBUILD_GUI=Off
+
+  build_cmake_cxxstd:
+
+    strategy:
+      matrix:
+        os: [ubuntu-22.04, macos-15]
+        cxxstd: [14, 17, 20]
+        # FIXME: macos-15 fails to compile with C++20
+        #
+        # /Users/runner/work/cppcheck/cppcheck/cmake.output/gui/test/projectfile/moc_testprojectfile.cpp:84:1: error: 'constinit' specifier is incompatible with C++ standards before C++20 [-Werror,-Wc++20-compat]
+        #    84 | Q_CONSTINIT const QMetaObject TestProjectFile::staticMetaObject = { {
+        #       | ^
+        # /opt/homebrew/opt/qt/lib/QtCore.framework/Headers/qcompilerdetection.h:1409:23: note: expanded from macro 'Q_CONSTINIT'
+        exclude:
+          - os: macos-15
+            cxxstd: 20
+      fail-fast: false # Prefer quick result
+
+    runs-on: ${{ matrix.os }}
+
+    env:
+      # TODO: figure out why there are cache misses with PCH enabled
+      CCACHE_SLOPPINESS: pch_defines,time_macros
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.workflow }}-${{ github.job }}-${{ matrix.os }}-${{ matrix.cxxstd }}
+
+      - name: Install missing software on ubuntu
+        if: contains(matrix.os, 'ubuntu')
+        run: |
+          sudo apt-get update
+          sudo apt-get install libxml2-utils
+          # qt6-tools-dev-tools for lprodump
+          # qt6-l10n-tools for lupdate
+          sudo apt-get install qt6-base-dev libqt6charts6-dev qt6-tools-dev qt6-tools-dev-tools qt6-l10n-tools libglx-dev libgl1-mesa-dev
+
+      # coreutils contains "nproc"
+      - name: Install missing software on macos
+        if: contains(matrix.os, 'macos')
+        run: |
+          # pcre was removed from runner images in November 2022
+          brew install coreutils qt@6 pcre
+
+      - name: Run CMake on ubuntu (with GUI)
+        if: contains(matrix.os, 'ubuntu')
+        run: |
+          cmake -S . -B cmake.output -Werror=dev -DCMAKE_CXX_STANDARD=${{ matrix.cxxstd }} -DHAVE_RULES=On -DBUILD_TESTING=On -DBUILD_GUI=On -DWITH_QCHART=On -DBUILD_TRIAGE=On -DCMAKE_DISABLE_PRECOMPILE_HEADERS=On -DCMAKE_COMPILE_WARNING_AS_ERROR=On -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
+
+      - name: Run CMake on macos (with GUI)
+        if: contains(matrix.os, 'macos')
+        run: |
+          cmake -S . -B cmake.output -Werror=dev -DCMAKE_CXX_STANDARD=${{ matrix.cxxstd }} -DHAVE_RULES=On -DBUILD_TESTING=On -DBUILD_GUI=On -DWITH_QCHART=On -DBUILD_TRIAGE=On -DCMAKE_DISABLE_PRECOMPILE_HEADERS=On -DCMAKE_COMPILE_WARNING_AS_ERROR=On -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache -DQt6_DIR=$(brew --prefix qt@6)/lib/cmake/Qt6
+
+      - name: Run CMake build
+        run: |
+          cmake --build cmake.output -- -j$(nproc)
+
+  build_uchar:
+
+    strategy:
+      matrix:
+        os: [ubuntu-22.04, macos-15]
+      fail-fast: false # Prefer quick result
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.workflow }}-${{ github.job }}-${{ matrix.os }}
+
+      # coreutils contains "nproc"
+      - name: Install missing software on macos
+        if: contains(matrix.os, 'macos')
+        run: |
+          brew install coreutils
+
+      - name: Build with Unsigned char
+        run: |
+          export PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH"
+          make -j$(nproc) CXXOPTS="-Werror -funsigned-char" testrunner
+
+      - name: Test with Unsigned char
+        run: |
+          ./testrunner
+
+  build_mathlib:
+
+    strategy:
+      matrix:
+        os: [ubuntu-22.04, macos-15]
+      fail-fast: false # Prefer quick result
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.workflow }}-${{ github.job }}-${{ matrix.os }}
+
+      # coreutils contains "nproc"
+      - name: Install missing software on macos
+        if: contains(matrix.os, 'macos')
+        run: |
+          brew install coreutils
+
+      - name: Build with TEST_MATHLIB_VALUE
+        run: |
+          export PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH"
+          make -j$(nproc) CXXOPTS="-Werror" CPPOPTS=-DTEST_MATHLIB_VALUE all
+
+      - name: Test with TEST_MATHLIB_VALUE
+        run: |
+          make -j$(nproc) test
+
+  check_nonneg:
+
+    strategy:
+      matrix:
+        os: [ubuntu-22.04, macos-15]
+      fail-fast: false # Prefer quick result
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      # coreutils contains "g++" (default is "c++") and "nproc"
+      - name: Install missing software on macos
+        if: contains(matrix.os, 'macos')
+        run: |
+          brew install coreutils
+
+      - name: Check syntax with NONNEG
+        run: |
+          make check-nonneg CXXOPTS="-Werror"
+
+  build_cmake_boost:
+
+    strategy:
+      matrix:
+        os: [macos-15]  # non-macos platforms are already built with Boost in other contexts
+      fail-fast: false # Prefer quick result
+
+    runs-on: ${{ matrix.os }}
+
+    env:
+      # TODO: figure out why there are cache misses with PCH enabled
+      CCACHE_SLOPPINESS: pch_defines,time_macros
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.workflow }}-${{ github.job }}-${{ matrix.os }}
+
+      - name: Run CMake on macOS (force Boost)
+        run: |
+          # make sure we fail when Boost is requested and not available.
+          # will fail because no package configuration is available.
+          if cmake -S . -B cmake.output.boost-force-noavail -Werror=dev -DBUILD_TESTING=Off -DUSE_BOOST=On; then
+            exit 1
+          else
+            exit 0
+          fi
+
+      # coreutils contains "nproc"
+      - name: Install missing software on macOS
+        run: |
+          brew install coreutils boost
+
+      - name: Run CMake on macOS (force Boost)
+        run: |
+          cmake -S . -B cmake.output.boost-force -Werror=dev -DBUILD_TESTING=Off -DUSE_BOOST=On
+
+      - name: Run CMake on macOS (no Boost)
+        run: |
+          # make sure Boost is not used when disabled even though it is available
+          cmake -S . -B cmake.output.boost-no -Werror=dev -DBUILD_TESTING=Off -DUSE_BOOST=Off
+          if grep -q '\-DHAVE_BOOST' ./cmake.output.boost-no/compile_commands.json; then
+            exit 1
+          else
+            exit 0
+          fi
+
+      - name: Run CMake on macOS (with Boost)
+        run: |
+          cmake -S . -B cmake.output.boost -Werror=dev -DBUILD_TESTING=On -DCMAKE_DISABLE_PRECOMPILE_HEADERS=On -DCMAKE_COMPILE_WARNING_AS_ERROR=On -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
+          grep -q '\-DHAVE_BOOST' ./cmake.output.boost/compile_commands.json
+
+      - name: Build with CMake on macOS (with Boost)
+        run: |
+          cmake --build cmake.output.boost -- -j$(nproc)
+
+  build_cmake_minimum:  # TODO: move to docker workflow?
+
+    runs-on: ubuntu-22.04  # use the oldest available runner
+
+    env:
+      CMAKE_VERSION: 3.22
+      CMAKE_VERSION_FULL: 3.22.6
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Install missing software
+        run: |
+          sudo apt-get update
+          sudo apt-get install libxml2-utils
+          # qt6-tools-dev-tools for lprodump
+          # qt6-l10n-tools for lupdate
+          sudo apt-get install qt6-base-dev libqt6charts6-dev qt6-tools-dev qt6-tools-dev-tools qt6-l10n-tools libglx-dev libgl1-mesa-dev
+
+      - name: Install CMake
+        run: |
+          wget https://cmake.org/files/v${{ env.CMAKE_VERSION }}/cmake-${{ env.CMAKE_VERSION_FULL }}-linux-x86_64.tar.gz
+          tar xf cmake-${{ env.CMAKE_VERSION_FULL }}-linux-x86_64.tar.gz
+
+      - name: Run CMake (without GUI)
+        run: |
+          export PATH=cmake-${{ env.CMAKE_VERSION_FULL }}-linux-x86_64/bin:$PATH
+          cmake -S . -B cmake.output -Werror=dev -DHAVE_RULES=On -DBUILD_TESTING=On
+
+      - name: Run CMake (with GUI)
+        run: |
+          export PATH=cmake-${{ env.CMAKE_VERSION_FULL }}-linux-x86_64/bin:$PATH
+          cmake -S . -B cmake.output.gui -Werror=dev -DHAVE_RULES=On -DBUILD_TESTING=On -DBUILD_GUI=On -DWITH_QCHART=On -DBUILD_TRIAGE=On
+
+  build:
+
+    strategy:
+      matrix:
+        os: [ubuntu-22.04, macos-15]
+        include:
+          - xdist_n: auto
+          # FIXME: test_color_tty fails with xdist - see #13278
+          - os: macos-15
+            xdist_n: '1'
+      fail-fast: false # Prefer quick result
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.workflow }}-${{ github.job }}-${{ matrix.os }}
+
+      - name: Install missing software on ubuntu
+        if: contains(matrix.os, 'ubuntu')
+        run: |
+          sudo apt-get update
+          sudo apt-get install libxml2-utils
+
+      # packages for strict cfg checks
+      - name: Install missing software on ubuntu 22.04 (cfg)
+        if: matrix.os == 'ubuntu-22.04'
+        run: |
+          sudo apt-get install libcairo2-dev libcurl4-openssl-dev liblua5.3-dev libssl-dev libsqlite3-dev libcppunit-dev libsigc++-2.0-dev libgtk-3-dev libboost-all-dev libselinux-dev libwxgtk3.0-gtk3-dev xmlstarlet qtbase5-dev
+
+      # coreutils contains "nproc"
+      - name: Install missing software on macos
+        if: contains(matrix.os, 'macos')
+        run: |
+          # pcre was removed from runner images in November 2022
+          brew install coreutils pcre gnu-sed
+
+      - name: Install missing Python packages on ubuntu
+        if: contains(matrix.os, 'ubuntu')
+        run: |
+          python3 -m pip install pip --upgrade
+          python3 -m pip install pytest
+          python3 -m pip install pytest-timeout
+          python3 -m pip install pytest-xdist
+          python3 -m pip install psutil
+
+      # we need to use -break-system-packages --user because the common approaches do not work.
+      # using pip works but it appears to install the packages into a different Python installation so they are not found later on.
+      # using python3 -m pip without the additional flags fails since the packages are being managed by a different tool (brew) and that lacks some of the packages.
+      # using pipx also does not work.
+      - name: Install missing Python packages on macos
+        if: contains(matrix.os, 'macos')
+        run: |
+          python3 -m pip install --break-system-packages --user pip --upgrade
+          python3 -m pip install --break-system-packages --user pytest
+          python3 -m pip install --break-system-packages --user pytest-timeout
+          python3 -m pip install --break-system-packages --user pytest-xdist
+          python3 -m pip install --break-system-packages --user psutil
+
+      - name: Build cppcheck
+        run: |
+          export PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH"
+          make -j$(nproc) CXXOPTS="-Werror" HAVE_RULES=yes
+
+      - name: Build test
+        run: |
+          export PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH"
+          make -j$(nproc) CXXOPTS="-Werror" HAVE_RULES=yes testrunner
+
+      - name: Run test
+        run: |
+          make -j$(nproc) HAVE_RULES=yes test
+
+      # requires "gnu-sed" installed on macos
+      - name: Run extra tests
+        run: |
+          test/scripts/generate_and_run_more_tests.sh
+
+      - name: Run test/cli
+        run: |
+          python3 -m pytest -Werror --strict-markers -vv -n ${{ matrix.xdist_n }} test/cli
+
+      # TODO: use the step below instead
+      # do not use pushd in this step since we go below the working directory
+      - name: Run test/cli (symlink)
+        run: |
+          cd ..
+          ln -s cppcheck 'cpp check'
+          cd 'cpp check/test/cli'
+          python3 -m pytest -Werror --strict-markers -vv -n ${{ matrix.xdist_n }}
+
+      # FIXME: proj2_test.py fails because of the relative path cleanups in ImportProject::setRelativePaths()
+      # It fails because the application path used as base path has its symlink resolved by getcwd().
+      - name: Run test/cli (symlink)
+        if: false
+        run: |
+          ln -s . 'cpp check'
+          python3 -m pytest -Werror --strict-markers -vv -n ${{ matrix.xdist_n }} 'cpp check/test/cli'
+
+      - name: Run test/cli (-j2)
+        run: |
+          python3 -m pytest -Werror --strict-markers -vv -n ${{ matrix.xdist_n }} test/cli
+        env:
+          TEST_CPPCHECK_INJECT_J: 2
+
+      - name: Run test/cli (--clang)
+        if: false
+        run: |
+          python3 -m pytest -Werror --strict-markers -vv -n ${{ matrix.xdist_n }} test/cli
+        env:
+          TEST_CPPCHECK_INJECT_CLANG: clang
+
+      - name: Run test/cli (--cppcheck-build-dir)
+        run: |
+          python3 -m pytest -Werror --strict-markers -vv -n ${{ matrix.xdist_n }} test/cli
+        env:
+          TEST_CPPCHECK_INJECT_BUILDDIR: injected
+
+      - name: Run cfg tests
+        if: matrix.os != 'ubuntu-22.04'
+        run: |
+          make -j$(nproc) checkcfg
+
+      - name: Run cfg tests (strict)
+        if: matrix.os == 'ubuntu-22.04'
+        run: |
+          make -j$(nproc) checkcfg
+        env:
+          STRICT: 1
+
+      - name: Run --dump test
+        run: |
+          ./cppcheck test/testpreprocessor.cpp --dump
+          xmllint --noout test/testpreprocessor.cpp.dump
+
+      - name: Validate
+        run: |
+          make -j$(nproc) checkCWEEntries validateXML
+
+      - name: Test install
+        run: |
+          # this is only to test the "install" target - since we did not build with FILESDIR it would not work as intended
+          make DESTDIR=cppcheck-make-install FILESDIR=/share/Cppcheck install
+          rm -rf cppcheck-make-install
+
+      - name: Test Signalhandler
+        run: |
+          cmake -S . -B build.cmake.signal -Werror=dev -DBUILD_TESTING=On -DCMAKE_COMPILE_WARNING_AS_ERROR=On
+          cmake --build build.cmake.signal --target test-signalhandler -- -j$(nproc)
+          # TODO: how to run this without copying the file?
+          cp build.cmake.signal/bin/test-s* .
+          python3 -m pytest -Werror --strict-markers -vv test/signal/test-signalhandler.py
+          rm test-signalhandler
+
+      # no unix backtrace support on MacOs
+      - name: Test Stacktrace
+        if: contains(matrix.os, 'ubuntu')
+        run: |
+          cmake -S . -B build.cmake.stack -Werror=dev -DBUILD_TESTING=On -DCMAKE_COMPILE_WARNING_AS_ERROR=On
+          cmake --build build.cmake.stack --target test-stacktrace -- -j$(nproc)
+          # TODO: how to run this without copying the file?
+          cp build.cmake.stack/bin/test-s* .
+          python3 -m pytest -Werror --strict-markers -vv test/signal/test-stacktrace.py
+          rm test-stacktrace
+
+      # TODO: move to scriptcheck.yml so these are tested with all Python versions?
+      - name: Test addons
+        run: |
+          set -x
+          ./cppcheck --error-exitcode=1 --inline-suppr --addon=threadsafety addons/test/threadsafety
+          ./cppcheck --error-exitcode=1 --inline-suppr --addon=threadsafety --std=c++03 addons/test/threadsafety
+          ./cppcheck --error-exitcode=1 --inline-suppr --addon=misra addons/test/misra/crash*.c
+          ./cppcheck --error-exitcode=1 --inline-suppr --addon=misra --enable=information addons/test/misra/config*.c
+
+          ./cppcheck --addon=misra --enable=style --inline-suppr --enable=information --error-exitcode=1 addons/test/misra/misra-ctu-*-test.c
+          pushd addons/test
+          # We'll force C89 standard to enable an additional verification for
+          # rules 5.4 and 5.5 which have standard-dependent options.
+          ../../cppcheck --dump -DDUMMY --suppress=uninitvar --inline-suppr misra/misra-test.c --std=c89 --platform=unix64 
+          python3 ../misra.py -verify misra/misra-test.c.dump
+          # Test slight MISRA differences in C11 standard
+          ../../cppcheck --dump -DDUMMY --suppress=uninitvar --inline-suppr misra/misra-test-c11.c --std=c11 --platform=unix64
+          python3 ../misra.py -verify misra/misra-test-c11.c.dump
+          # TODO: do we need to verify something here?
+          ../../cppcheck --dump -DDUMMY --suppress=uninitvar --suppress=uninitStructMember --std=c89 misra/misra-test.h
+          ../../cppcheck --dump misra/misra-test.cpp 
+          python3 ../misra.py -verify misra/misra-test.cpp.dump
+          python3 ../misra.py --rule-texts=misra/misra2012_rules_dummy_ascii.txt -verify misra/misra-test.cpp.dump
+          python3 ../misra.py --rule-texts=misra/misra2012_rules_dummy_utf8.txt -verify misra/misra-test.cpp.dump
+          python3 ../misra.py --rule-texts=misra/misra2012_rules_dummy_windows1250.txt -verify misra/misra-test.cpp.dump
+          ../../cppcheck --addon=misra --enable=style --platform=avr8 --error-exitcode=1 misra/misra-test-avr8.c
+          ../../cppcheck --dump misc-test.cpp 
+          python3 ../misc.py -verify misc-test.cpp.dump
+          ../../cppcheck --dump naming_test.c 
+          python3 ../naming.py --var='[a-z].*' --function='[a-z].*' naming_test.c.dump
+          ../../cppcheck --dump naming_test.cpp 
+          python3 ../naming.py --var='[a-z].*' --function='[a-z].*' naming_test.cpp.dump
+
+      # TODO: run with "-n auto" when misra_test.py can be run in parallel
+      - name: test addons (Python)
+        if: matrix.os != 'ubuntu-22.04'
+        run: |
+          python3 -m pytest -Werror --strict-markers -vv -n 1 addons/test
+        env:
+          PYTHONPATH: ./addons
+
+      # TODO: run with "-n auto" when misra_test.py can be run in parallel
+      # we cannot specify -Werror since xml/etree/ElementTree.py in Python 3.10 contains an unclosed file
+      - name: test addons (Python)
+        if: matrix.os == 'ubuntu-22.04'
+        run: |
+          python3 -m pytest --strict-markers -vv -n 1 addons/test
+        env:
+          PYTHONPATH: ./addons
+
+      - name: Build democlient
+        if: matrix.os == 'ubuntu-22.04'
+        run: |
+          warnings="-pedantic -Wall -Wextra -Wcast-qual -Wno-deprecated-declarations -Wfloat-equal -Wmissing-declarations -Wmissing-format-attribute -Wno-long-long -Wpacked -Wredundant-decls -Wundef -Wno-shadow -Wno-missing-field-initializers -Wno-missing-braces -Wno-sign-compare -Wno-multichar"
+          g++ $warnings -c -Ilib -Iexternals/tinyxml2 democlient/democlient.cpp
+
+      - name: Test disabled executors
+        if: matrix.os == 'ubuntu-22.04'
+        run: |
+          g++ -Ilib -c cli/threadexecutor.cpp -DDISALLOW_THREAD_EXECUTOR
+          test -z "$(nm threadexecutor.o)"
+          g++ -Ilib -c cli/processexecutor.cpp -DDISALLOW_PROCESS_EXECUTOR
+          test -z "$(nm processexecutor.o)"
+          # TODO: test NO_* defines
+
+      - name: Show all ignored files
+        if: false  # TODO: currently lists all the contents of ignored folders - we only need what actually matched
+        run: |
+          git ls-files --others --ignored --exclude-standard
+
+      - name: Check for changed and unversioned files
+        run: |
+          # TODO: how to do this with a single command?
+          git status --ignored=no
+          git status --ignored=no | grep -q 'working tree clean'
+
+  selfcheck:
+    needs: build # wait for all tests to be successful first
+
+    runs-on: ubuntu-22.04 # run on the latest image only
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.workflow }}-${{ github.job }}-${{ matrix.os }}
+
+      - name: Install missing software on ubuntu
+        run: |
+          sudo apt-get update
+          # qt6-tools-dev-tools for lprodump
+          # qt6-l10n-tools for lupdate
+          sudo apt-get install qt6-base-dev libqt6charts6-dev qt6-tools-dev qt6-tools-dev-tools qt6-l10n-tools libglx-dev libgl1-mesa-dev
+          sudo apt-get install libboost-container-dev
+
+      - name: Self check (build)
+        run: |
+          export PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH"
+          # compile with verification and ast matchers
+          make -j$(nproc) CXXOPTS="-Werror -g -O2" CPPOPTS="-DCHECK_INTERNAL -DHAVE_BOOST" MATCHCOMPILER=yes VERIFY=1
+
+      - name: CMake
+        run: |
+          cmake -S . -B cmake.output -Werror=dev -DHAVE_RULES=On -DBUILD_TESTING=On -DBUILD_GUI=On -DWITH_QCHART=On -DBUILD_TRIAGE=On -DUSE_MATCHCOMPILER=Verify -DENABLE_CHECK_INTERNAL=On -DCPPCHK_GLIBCXX_DEBUG=Off -DCMAKE_DISABLE_PRECOMPILE_HEADERS=On -DCMAKE_GLOBAL_AUTOGEN_TARGET=On -DDISABLE_DMAKE=On
+
+      - name: Generate dependencies
+        run: |
+          # make sure auto-generated GUI files exist
+          make -C cmake.output autogen
+          make -C cmake.output gui-build-deps triage-build-ui-deps
+
+      - name: Self check
+        run: |
+          ./selfcheck.sh
diff --git a/.github/workflows/CI-windows.yml b/.github/workflows/CI-windows.yml
new file mode 100644
index 00000000000..c993c57753a
--- /dev/null
+++ b/.github/workflows/CI-windows.yml
@@ -0,0 +1,338 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: CI-windows
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'releases/**'
+      - '2.*'
+    tags:
+      - '2.*'
+  pull_request:
+
+permissions:
+  contents: read
+
+defaults:
+  run:
+    shell: cmd
+
+jobs:
+
+  build_qt:
+    strategy:
+      matrix:
+        os: [windows-2022, windows-2025]
+        qt_ver: [6.10.0]
+      fail-fast: false
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Set up Visual Studio environment
+        uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: x64
+
+      - name: Install Qt ${{ matrix.qt_ver }}
+        uses: jurplel/install-qt-action@v4
+        with:
+          version: ${{ matrix.qt_ver }}
+          modules: 'qtcharts'
+          setup-python: 'false'
+          cache: true
+          aqtversion: '==3.1.*'  # TODO: remove when aqtinstall 3.2.2 is available
+
+      - name: Run CMake
+        run: |
+          rem TODO: enable rules?
+          rem specify Release build so matchcompiler is used
+          cmake -S . -B build -Werror=dev -DCMAKE_BUILD_TYPE=Release -DCMAKE_COMPILE_WARNING_AS_ERROR=On -DBUILD_TESTING=Off -DBUILD_GUI=On -DWITH_QCHART=On -DBUILD_TRIAGE=On -DBUILD_ONLINE_HELP=On -DCMAKE_INSTALL_PREFIX=cppcheck-cmake-install -DCMAKE_COMPILE_WARNING_AS_ERROR=On || exit /b !errorlevel!
+
+      - name: Build GUI release
+        run: |
+          cmake --build build --target cppcheck-gui --config Release || exit /b !errorlevel!
+
+      - name: Deploy GUI
+        run: |
+          windeployqt build\bin\Release || exit /b !errorlevel!
+          del build\bin\Release\cppcheck-gui.ilk || exit /b !errorlevel!
+          del build\bin\Release\cppcheck-gui.pdb || exit /b !errorlevel!
+
+      # TODO: run GUI tests
+
+      - name: Run CMake install
+        run: |
+          cmake --build build --target install
+
+  build_cmake_cxxstd:
+    strategy:
+      matrix:
+        os: [windows-2022, windows-2025]
+        cxxstd: [14, 17, 20]
+      fail-fast: false
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Set up Visual Studio environment
+        uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: x64
+
+      - name: Run CMake
+        run: |
+          cmake -S . -B build.cxxstd -Werror=dev -G "Visual Studio 17 2022" -A x64 -DCMAKE_CXX_STANDARD=${{ matrix.cxxstd }} -DCMAKE_BUILD_TYPE=Debug -DBUILD_TESTING=On -DCMAKE_COMPILE_WARNING_AS_ERROR=On || exit /b !errorlevel!
+
+      - name: Build
+        run: |
+          cmake --build build.cxxstd --config Debug || exit /b !errorlevel!
+
+  build_cmake_minimum:
+
+    runs-on: windows-2022  # use the oldest available runner
+
+    env:
+      CMAKE_VERSION: 3.22
+      CMAKE_VERSION_FULL: 3.22.6
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Install CMake
+        run: |
+          curl -fsSL https://cmake.org/files/v${{ env.CMAKE_VERSION }}/cmake-${{ env.CMAKE_VERSION_FULL }}-windows-x86_64.zip -o cmake.zip || exit /b !errorlevel!
+          7z x cmake.zip || exit /b !errorlevel!
+
+      - name: Set up Visual Studio environment
+        uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: x64
+
+      - name: Install Qt
+        uses: jurplel/install-qt-action@v4
+        with:
+          version: 6.10.0
+          modules: 'qtcharts'
+          setup-python: 'false'
+          cache: true
+          aqtversion: '==3.1.*'  # TODO: remove when aqtinstall 3.2.2 is available
+
+      - name: Run CMake (without GUI)
+        run: |
+          :: TODO: enable DHAVE_RULES?
+          cmake-${{ env.CMAKE_VERSION_FULL }}-windows-x86_64\bin\cmake.exe -S . -B cmake.output -G "Visual Studio 17 2022" -A x64 -DHAVE_RULES=Off -DBUILD_TESTING=On
+
+      - name: Run CMake (with GUI)
+        run: |
+          :: TODO: enable DHAVE_RULES?
+          cmake-${{ env.CMAKE_VERSION_FULL }}-windows-x86_64\bin\cmake.exe -S . -B cmake.output.gui -G "Visual Studio 17 2022" -A x64 -DHAVE_RULES=Off -DBUILD_TESTING=On -DBUILD_GUI=On -DWITH_QCHART=On -DBUILD_TRIAGE=On
+
+  build:
+    strategy:
+      matrix:
+        os: [windows-2022, windows-2025]
+        config: [debug, release]
+      fail-fast: false
+
+    runs-on: ${{ matrix.os }}
+
+    env:
+      # see https://www.pcre.org/original/changelog.txt
+      PCRE_VERSION: 8.45
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Set up Python
+        if: matrix.config == 'release'
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.14'
+          check-latest: true
+
+      - name: Set up Visual Studio environment
+        uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: x64
+
+      - name: Cache PCRE
+        id: cache-pcre
+        uses: actions/cache@v4
+        with:
+          path: |
+            externals\pcre.h
+            externals\pcre.lib
+            externals\pcre64.lib
+          key: pcre-${{ env.PCRE_VERSION }}-x64-bin-win
+
+      - name: Download PCRE
+        if: steps.cache-pcre.outputs.cache-hit != 'true'
+        run: |
+          curl -fsSL https://github.com/pfultz2/pcre/archive/refs/tags/%PCRE_VERSION%.zip -o pcre-%PCRE_VERSION%.zip || exit /b !errorlevel!
+
+      - name: Install PCRE
+        if: steps.cache-pcre.outputs.cache-hit != 'true'
+        run: |
+          @echo on
+          7z x pcre-%PCRE_VERSION%.zip || exit /b !errorlevel!
+          cd pcre-%PCRE_VERSION% || exit /b !errorlevel!
+          git apply --ignore-space-change ..\externals\pcre.patch || exit /b !errorlevel!
+          cmake . -G "NMake Makefiles" -DCMAKE_BUILD_TYPE=Release -DPCRE_BUILD_PCRECPP=Off -DPCRE_BUILD_TESTS=Off -DPCRE_BUILD_PCREGREP=Off -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DCMAKE_COMPILE_WARNING_AS_ERROR=On || exit /b !errorlevel!
+          nmake || exit /b !errorlevel!
+          copy pcre.h ..\externals || exit /b !errorlevel!
+          copy pcre.lib ..\externals\pcre64.lib || exit /b !errorlevel!
+        env:
+          CL: /MP
+
+      - name: Install missing Python packages
+        if: matrix.config == 'release'
+        run: |
+          python -m pip install pip --upgrade || exit /b !errorlevel!
+          python -m pip install pytest || exit /b !errorlevel!
+          python -m pip install pytest-custom_exit_code || exit /b !errorlevel!
+          python -m pip install pytest-timeout || exit /b !errorlevel!
+          python -m pip install pytest-xdist || exit /b !errorlevel!
+          python -m pip install psutil || exit /b !errorlevel!
+
+      - name: Build CLI debug configuration using MSBuild
+        if: matrix.config == 'debug'
+        run: |
+          :: cmake --build build --target check --config Debug || exit /b !errorlevel!
+          msbuild -m cppcheck.sln /p:Configuration=Debug-PCRE;Platform=x64 -maxcpucount || exit /b !errorlevel!
+        env:
+          _CL_: /WX
+
+      - name: Run Debug test
+        if: matrix.config == 'debug'
+        run: .\bin\debug\testrunner.exe || exit /b !errorlevel!
+
+      - name: Build CLI release configuration using MSBuild
+        if: matrix.config == 'release'
+        run: |
+          :: cmake --build build --target check --config Release || exit /b !errorlevel!
+          msbuild -m cppcheck.sln /p:Configuration=Release-PCRE;Platform=x64 -maxcpucount || exit /b !errorlevel!
+        env:
+          _CL_: /WX
+
+      - name: Run Release test
+        if: matrix.config == 'release'
+        run: .\bin\testrunner.exe || exit /b !errorlevel!
+
+      - name: Prepare test/cli
+        if: matrix.config == 'release'
+        run: |
+          :: since FILESDIR is not set copy the binary to the root so the addons are found
+          :: copy .\build\bin\Release\cppcheck.exe .\cppcheck.exe || exit /b !errorlevel!
+          copy .\bin\cppcheck.exe .\cppcheck.exe || exit /b !errorlevel!
+          copy .\bin\cppcheck-core.dll .\cppcheck-core.dll || exit /b !errorlevel!
+
+      - name: Run test/cli
+        if: matrix.config == 'release'
+        run: |
+          python -m pytest -Werror --strict-markers -vv -n auto test/cli || exit /b !errorlevel!
+
+      - name: Run test/cli (-j2)
+        if: matrix.config == 'release'
+        run: |
+          python -m pytest -Werror --strict-markers -vv -n auto test/cli || exit /b !errorlevel!
+        env:
+          TEST_CPPCHECK_INJECT_J: 2
+
+      # TODO: install clang
+      - name: Run test/cli (--clang)
+        if: false # matrix.config == 'release'
+        run: |
+          python -m pytest -Werror --strict-markers -vv -n auto test/cli || exit /b !errorlevel!
+        env:
+          TEST_CPPCHECK_INJECT_CLANG: clang
+
+      - name: Run test/cli (--cppcheck-build-dir)
+        if: matrix.config == 'release'
+        run: |
+          python -m pytest -Werror --strict-markers -vv -n auto test/cli || exit /b !errorlevel!
+        env:
+          TEST_CPPCHECK_INJECT_BUILDDIR: injected
+
+      # TODO: test with Release configuration?
+      - name: Test SEH wrapper
+        if: matrix.config == 'release'
+        run: |
+          cmake -S . -B build.cmake.seh -Werror=dev -DBUILD_TESTING=On -DCMAKE_COMPILE_WARNING_AS_ERROR=On || exit /b !errorlevel!
+          cmake --build build.cmake.seh --target test-sehwrapper || exit /b !errorlevel!
+          :: TODO: how to run this without copying the file?
+          copy build.cmake.seh\bin\Debug\test-sehwrapper.exe . || exit /b !errorlevel!
+          python3 -m pytest -Werror --strict-markers -vv test/seh/test-sehwrapper.py || exit /b !errorlevel!
+          del test-sehwrapper.exe || exit /b !errorlevel!
+
+      - name: Test addons
+        if: matrix.config == 'release'
+        run: |
+          echo on
+          .\cppcheck --addon=threadsafety addons\test\threadsafety || exit /b !errorlevel!
+          .\cppcheck --addon=threadsafety --std=c++03 addons\test\threadsafety || exit /b !errorlevel!
+          .\cppcheck --addon=misra --enable=style --inline-suppr --enable=information --error-exitcode=1 addons\test\misra\misra-ctu-*-test.c || exit /b !errorlevel!
+          cd addons\test
+          rem We'll force C89 standard to enable an additional verification for
+          rem rules 5.4 and 5.5 which have standard-dependent options.
+          ..\..\cppcheck --dump -DDUMMY --suppress=uninitvar --inline-suppr misra\misra-test.c --std=c89 --platform=unix64 || exit /b !errorlevel!
+          python3 ..\misra.py -verify misra\misra-test.c.dump || exit /b !errorlevel!
+          rem Test slight MISRA differences in C11 standard
+          ..\..\cppcheck --dump -DDUMMY --suppress=uninitvar --inline-suppr misra\misra-test-c11.c --std=c11 --platform=unix64 || exit /b !errorlevel!
+          python3 ..\misra.py -verify misra\misra-test-c11.c.dump || exit /b !errorlevel!
+          rem TODO: do we need to verify something here?
+          ..\..\cppcheck --dump -DDUMMY --suppress=uninitvar --suppress=uninitStructMember --std=c89 misra\misra-test.h || exit /b !errorlevel!
+          ..\..\cppcheck --dump misra\misra-test.cpp || exit /b !errorlevel!
+          python3 ..\misra.py -verify misra\misra-test.cpp.dump || exit /b !errorlevel!
+          python3 ..\misra.py --rule-texts=misra\misra2012_rules_dummy_ascii.txt -verify misra\misra-test.cpp.dump || exit /b !errorlevel!
+          python3 ..\misra.py --rule-texts=misra\misra2012_rules_dummy_utf8.txt -verify misra\misra-test.cpp.dump || exit /b !errorlevel!
+          python3 ..\misra.py --rule-texts=misra\misra2012_rules_dummy_windows1250.txt -verify misra\misra-test.cpp.dump || exit /b !errorlevel!
+          ..\..\cppcheck --addon=misra --enable=style --platform=avr8 --error-exitcode=1 misra\misra-test-avr8.c || exit /b !errorlevel!
+          ..\..\cppcheck --dump misc-test.cpp || exit /b !errorlevel!
+          python3 ..\misc.py -verify misc-test.cpp.dump || exit /b !errorlevel!
+          ..\..\cppcheck --dump naming_test.c || exit /b !errorlevel!
+          rem TODO: fix this - does not fail on Linux
+          rem python3 ..\naming.py --var='[a-z].*' --function='[a-z].*' naming_test.c.dump || exit /b !errorlevel!
+          ..\..\cppcheck --dump naming_test.cpp || exit /b !errorlevel!
+          python3 ..\naming.py --var='[a-z].*' --function='[a-z].*' naming_test.cpp.dump || exit /b !errorlevel!
+
+      # TODO: run with "-n auto" when misra_test.py can be run in parallel
+      - name: test addons (Python)
+        if: matrix.config == 'release'
+        run: |
+          python -m pytest -Werror --strict-markers -vv -n 1 addons/test || exit /b !errorlevel!
+        env:
+          PYTHONPATH: ./addons
+
+      - name: Check Windows test syntax
+        if: matrix.config == 'debug'
+        run: |
+          cd test\cfg
+          cl.exe windows.cpp -DUNICODE=1 -D_UNICODE=1 /Zs || exit /b !errorlevel!
+          cl.exe mfc.cpp /EHsc /Zs || exit /b !errorlevel!
+
+      - name: Show all ignored files
+        if: false  # TODO: currently lists all the contents of ignored folders - we only need what actually matched
+        run: |
+          git ls-files --others --ignored --exclude-standard || exit /b !errorlevel!
+
+      - name: Check for changed and unversioned files
+        run: |
+          :: TODO: how to do this with a single command?
+          git status --ignored=no
+          :: TODO: make this work
+          :: git status --ignored=no | grep -q 'working tree clean'
diff --git a/.github/workflows/asan.yml b/.github/workflows/asan.yml
new file mode 100644
index 00000000000..38e90cb760a
--- /dev/null
+++ b/.github/workflows/asan.yml
@@ -0,0 +1,145 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: address sanitizer
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'releases/**'
+      - '2.*'
+    tags:
+      - '2.*'
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-22.04
+
+    env:
+      QT_VERSION: 6.10.0
+      ASAN_OPTIONS: detect_stack_use_after_return=1
+      LSAN_OPTIONS: suppressions=lsan-suppr.txt:print_suppressions=0
+      # TODO: figure out why there are cache misses with PCH enabled
+      CCACHE_SLOPPINESS: pch_defines,time_macros
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.workflow }}-${{ github.job }}-${{ matrix.os }}
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.14'
+          check-latest: true
+
+      - name: Install missing software on ubuntu
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake make libpcre3-dev libboost-container-dev libxml2-utils
+          sudo apt-get install -y libcups2-dev  # required for Qt6PrintSupport in CMake since Qt 6.7.3
+
+      - name: Install clang
+        run: |
+          sudo apt-get purge --auto-remove llvm python3-lldb-14 llvm-14
+          wget https://apt.llvm.org/llvm.sh
+          chmod +x llvm.sh
+          sudo ./llvm.sh 22
+
+      - name: Install Qt ${{ env.QT_VERSION }}
+        uses: jurplel/install-qt-action@v4
+        with:
+          version: ${{ env.QT_VERSION }}
+          modules: 'qtcharts'
+          setup-python: 'false'
+          cache: true
+
+      - name: Install missing Python packages
+        run: |
+          python3 -m pip install pip --upgrade
+          python3 -m pip install pytest
+          python3 -m pip install pytest-timeout
+          python3 -m pip install pytest-xdist
+          python3 -m pip install psutil
+
+      - name: CMake
+        run: |
+          cmake -S . -B cmake.output -Werror=dev -DCMAKE_BUILD_TYPE=RelWithDebInfo -DHAVE_RULES=On -DBUILD_TESTING=On -DBUILD_GUI=On -DWITH_QCHART=On -DBUILD_TRIAGE=On -DUSE_MATCHCOMPILER=Verify -DANALYZE_ADDRESS=On -DENABLE_CHECK_INTERNAL=On -DUSE_BOOST=On -DCPPCHK_GLIBCXX_DEBUG=Off -DCMAKE_DISABLE_PRECOMPILE_HEADERS=On -DCMAKE_GLOBAL_AUTOGEN_TARGET=On -DDISABLE_DMAKE=On -DFILESDIR= -DCMAKE_COMPILE_WARNING_AS_ERROR=On -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
+        env:
+          CC: clang-22
+          CXX: clang++-22
+
+      - name: Build cppcheck
+        run: |
+          cmake --build cmake.output --target cppcheck -- -j $(nproc)
+
+      - name: Build test
+        run: |
+          cmake --build cmake.output --target testrunner -- -j $(nproc)
+
+      - name: Build GUI tests
+        run: |
+          cmake --build cmake.output --target gui-tests -- -j $(nproc)
+
+      - name: Run tests
+        run: ./cmake.output/bin/testrunner
+
+      - name: Run cfg tests
+        run: |
+          cmake --build cmake.output --target checkcfg -- -j $(nproc)
+
+      - name: Run CTest
+        run: |
+          cp lsan-suppr.txt cmake.output/bin
+          ctest --test-dir cmake.output --output-on-failure -j$(nproc)
+
+      - name: Run test/cli
+        run: |
+          pwd=$(pwd)
+          TEST_CPPCHECK_EXE_LOOKUP_PATH="$pwd/cmake.output" python3 -m pytest -Werror --strict-markers -vv -n auto test/cli
+
+      - name: Run test/cli (-j2)
+        run: |
+          pwd=$(pwd)
+          TEST_CPPCHECK_EXE_LOOKUP_PATH="$pwd/cmake.output" python3 -m pytest -Werror --strict-markers -vv -n auto test/cli
+        env:
+          TEST_CPPCHECK_INJECT_J: 2
+
+      - name: Run test/cli (--clang)
+        if: false
+        run: |
+          pwd=$(pwd)
+          TEST_CPPCHECK_EXE_LOOKUP_PATH="$pwd/cmake.output" python3 -m pytest -Werror --strict-markers -vv -n auto test/cli
+        env:
+          TEST_CPPCHECK_INJECT_CLANG: clang
+
+      - name: Run test/cli (--cppcheck-build-dir)
+        run: |
+          pwd=$(pwd)
+          TEST_CPPCHECK_EXE_LOOKUP_PATH="$pwd/cmake.output" python3 -m pytest -Werror --strict-markers -vv -n auto test/cli
+        env:
+          TEST_CPPCHECK_INJECT_BUILDDIR: injected
+
+      - name: Generate dependencies
+        if: false
+        run: |
+          # make sure auto-generated GUI files exist
+          make -C cmake.output autogen
+          make -C cmake.output gui-build-deps triage-build-ui-deps
+
+      # TODO: this is currently way too slow (~60 minutes) to enable it
+      # TODO: only fail the step on sanitizer issues - since we use processes it will only fail the underlying process which will result in an cppcheckError
+      - name: Self check
+        if: false
+        run: |
+          ./selfcheck_san.sh ./cmake.output
diff --git a/.github/workflows/buildman.yml b/.github/workflows/buildman.yml
new file mode 100644
index 00000000000..b0b399dd851
--- /dev/null
+++ b/.github/workflows/buildman.yml
@@ -0,0 +1,65 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: Build manual
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'releases/**'
+      - '2.*'
+    tags:
+      - '2.*'
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  convert_via_pandoc:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - run: |
+          mkdir output
+
+      - uses: docker://pandoc/latex:3.6.3
+        with:
+          args: --output=output/manual.html man/manual.md
+
+      - uses: docker://pandoc/latex:3.6.3
+        with:
+          args: --output=output/manual.pdf man/manual.md
+
+      - uses: docker://pandoc/latex:3.6.3
+        with:
+          args: --output=output/manual-premium.pdf man/manual-premium.md
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: output
+          path: output
+
+  manpage:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Install missing software on ubuntu
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y xsltproc docbook-xsl
+
+      - name: build manpage
+        run: |
+          make man
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: cppcheck.1
+          path: cppcheck.1
diff --git a/.github/workflows/cifuzz.yml b/.github/workflows/cifuzz.yml
new file mode 100644
index 00000000000..7b462c688f0
--- /dev/null
+++ b/.github/workflows/cifuzz.yml
@@ -0,0 +1,34 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: CIFuzz
+
+on: [pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  Fuzzing:
+    runs-on: ubuntu-latest
+    if: ${{ github.repository_owner == 'danmar' }}
+    steps:
+    - name: Build Fuzzers
+      id: build
+      uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'cppcheck'
+        dry-run: false
+        language: c++
+    - name: Run Fuzzers
+      uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'cppcheck'
+        fuzz-seconds: 300
+        dry-run: false
+        language: c++
+    - name: Upload Crash
+      uses: actions/upload-artifact@v4
+      if: failure() && steps.build.outcome == 'success'
+      with:
+        name: artifacts
+        path: ./out/artifacts
diff --git a/.github/workflows/clang-tidy.yml b/.github/workflows/clang-tidy.yml
new file mode 100644
index 00000000000..c4f8cc0cf6b
--- /dev/null
+++ b/.github/workflows/clang-tidy.yml
@@ -0,0 +1,93 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: clang-tidy
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'releases/**'
+      - '2.*'
+    tags:
+      - '2.*'
+  pull_request:
+  schedule:
+    - cron: '0 0 * * 0'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-22.04
+
+    env:
+      QT_VERSION: 6.10.0
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Install missing software
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake make
+          sudo apt-get install -y libpcre3-dev
+          sudo apt-get install -y libgl-dev  # fixes missing dependency for Qt in CMake
+
+      - name: Install clang
+        run: |
+          sudo apt-get purge --auto-remove llvm python3-lldb-14 llvm-14
+          wget https://apt.llvm.org/llvm.sh
+          chmod +x llvm.sh
+          sudo ./llvm.sh 22
+          sudo apt-get install -y clang-tidy-22
+
+      - name: Install Qt ${{ env.QT_VERSION }}
+        uses: jurplel/install-qt-action@v4
+        with:
+          version: ${{ env.QT_VERSION }}
+          modules: 'qtcharts'
+          setup-python: 'false'
+          install-deps: false
+          cache: true
+
+      - name: Verify clang-tidy configuration
+        run: |
+          clang-tidy-22 --verify-config
+
+      - name: Prepare CMake
+        run: |
+          cmake -S . -B cmake.output -Werror=dev -DHAVE_RULES=On -DBUILD_TESTING=On -DBUILD_GUI=On -DWITH_QCHART=On -DBUILD_TRIAGE=On -DENABLE_CHECK_INTERNAL=On -DCMAKE_GLOBAL_AUTOGEN_TARGET=On -DDISABLE_DMAKE=On -DCPPCHK_GLIBCXX_DEBUG=Off -DCMAKE_COMPILE_WARNING_AS_ERROR=On
+        env:
+          CC: clang-22
+          CXX: clang++-22
+
+      - name: Prepare CMake dependencies
+        run: |
+          # make sure the auto-generated GUI sources exist
+          make -C cmake.output autogen
+          # make sure the precompiled headers exist
+          make -C cmake.output/cli cmake_pch.hxx.pch
+          make -C cmake.output/gui cmake_pch.hxx.pch
+          make -C cmake.output/lib cmake_pch.hxx.pch
+          make -C cmake.output/test cmake_pch.hxx.pch
+
+      - name: Clang-Tidy
+        if: ${{ github.event.schedule == '' && github.event_name != 'workflow_dispatch' }}
+        run: |
+          cmake --build cmake.output --target run-clang-tidy 2> /dev/null
+
+      - name: Clang Static Analyzer
+        if: ${{ github.event.schedule != '' || github.event_name == 'workflow_dispatch' }}
+        run: |
+          cmake --build cmake.output --target run-clang-tidy-csa 2> /dev/null
+
+      - uses: actions/upload-artifact@v4
+        if: success() || failure()
+        with:
+          name: Compilation Database
+          path: ./cmake.output/compile_commands.json
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
new file mode 100644
index 00000000000..12e758d2c9e
--- /dev/null
+++ b/.github/workflows/codeql-analysis.yml
@@ -0,0 +1,52 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: "CodeQL"
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'releases/**'
+      - '2.*'
+    tags:
+      - '2.*'
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-22.04
+    permissions:
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        # Override automatic language detection by changing the below list
+        # Supported options are ['csharp', 'cpp', 'go', 'java', 'javascript', 'python']
+        language: ['cpp', 'python']
+        # Learn more...
+        # https://docs.github.com/en/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#overriding-automatic-language-detection
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+      with:
+        persist-credentials: false
+      
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        languages: ${{ matrix.language }}
+
+    - name: Build cppcheck
+      if: matrix.language == 'cpp'
+      run: |
+         make -j$(nproc) CXXOPTS="-Werror" HAVE_RULES=yes CPPCHK_GLIBCXX_DEBUG= cppcheck
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3
diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml
new file mode 100644
index 00000000000..13f56172a80
--- /dev/null
+++ b/.github/workflows/coverage.yml
@@ -0,0 +1,71 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: Coverage
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'releases/**'
+      - '2.*'
+    tags:
+      - '2.*'
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-22.04
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.workflow }}-${{ runner.os }}
+
+      - name: Install missing software on ubuntu
+        run: |
+          sudo apt-get update
+          sudo apt-get install libxml2-utils lcov
+
+      - name: Install missing Python packages on ubuntu
+        run: |
+          python -m pip install pip --upgrade
+          python -m pip install lcov_cobertura
+
+      - name: Compile instrumented
+        run: |
+          export PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH"
+          make -j$(nproc) CXXOPTS="-Werror -g -fprofile-arcs -ftest-coverage" HAVE_RULES=yes CPPCHK_GLIBCXX_DEBUG= all
+
+      - name: Run instrumented tests
+        run: |
+          ./testrunner
+          test/cfg/runtests.sh
+
+      - name: Generate coverage report
+        run: |
+          gcov lib/*.cpp -o lib/
+          lcov --directory ./ --capture --output-file lcov_tmp.info -b ./
+          lcov --extract lcov_tmp.info "$(pwd)/*" --output-file lcov.info
+          genhtml lcov.info -o coverage_report --frame --legend --demangle-cpp
+          
+      - uses: actions/upload-artifact@v4
+        with:
+         name: Coverage results
+         path: coverage_report
+         
+      - uses: codecov/codecov-action@v4
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          # file: ./coverage.xml # optional
+          flags: unittests # optional
+          name: ${{ github.repository }} # optional
+          fail_ci_if_error: true # optional (default = false):  
diff --git a/.github/workflows/coverity.yml b/.github/workflows/coverity.yml
new file mode 100644
index 00000000000..3c07b61d7c7
--- /dev/null
+++ b/.github/workflows/coverity.yml
@@ -0,0 +1,41 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: Coverity
+
+on:
+  schedule:
+  - cron: "0 0 * * *"
+
+permissions:
+  contents: read
+
+jobs:
+  scan:
+    runs-on: ubuntu-latest
+    if: ${{ github.repository_owner == 'danmar' }}
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        persist-credentials: false
+    - name: Install missing software on ubuntu
+      run: |
+        sudo apt-get update
+        sudo apt-get install qtbase5-dev qttools5-dev libqt5charts5-dev libboost-container-dev
+    - name: Download Coverity build tool
+      run: |
+        wget -c -N https://scan.coverity.com/download/linux64 --post-data "token=${{ secrets.COVERITY_SCAN_TOKEN }}&project=cppcheck" -O coverity_tool.tar.gz
+        mkdir coverity_tool
+        tar xzf coverity_tool.tar.gz --strip 1 -C coverity_tool
+    - name: Build with Coverity build tool
+      run: |
+        export PATH=`pwd`/coverity_tool/bin:$PATH
+        cov-build --dir cov-int make CPPCHK_GLIBCXX_DEBUG=
+    - name: Submit build result to Coverity Scan
+      run: |
+        tar czvf cov.tar.gz cov-int
+        curl --form token=${{ secrets.COVERITY_SCAN_TOKEN }} \
+          --form email=daniel.marjamaki@gmail.com \
+          --form file=@cov.tar.gz \
+          --form version="Commit $GITHUB_SHA" \
+          --form description="Development" \
+          https://scan.coverity.com/builds?project=cppcheck
diff --git a/.github/workflows/cppcheck-premium.yml b/.github/workflows/cppcheck-premium.yml
new file mode 100644
index 00000000000..5cb63ca4d5e
--- /dev/null
+++ b/.github/workflows/cppcheck-premium.yml
@@ -0,0 +1,72 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: cppcheck-premium
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'releases/**'
+      - '2.*'
+    tags:
+      - '2.*'
+  pull_request:
+  workflow_dispatch:
+    inputs:
+      premium_version:
+        description: 'Cppcheck Premium version'
+
+permissions:
+  contents: read
+  security-events: write
+
+jobs:
+
+  build:
+    runs-on: ubuntu-24.04 # run on the latest image only
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Download cppcheckpremium release
+        run: |
+          premium_version=${{ inputs.premium_version }}
+          if [ -z $premium_version ]; then
+            premium_version=25.8.3
+            #wget https://files.cppchecksolutions.com/devdrop/cppcheckpremium-$premium_version-amd64.tar.gz -O cppcheckpremium.tar.gz
+            wget https://files.cppchecksolutions.com/$premium_version/ubuntu-24.04/cppcheckpremium-$premium_version-amd64.tar.gz -O cppcheckpremium.tar.gz
+          else
+            wget https://files.cppchecksolutions.com/$premium_version/ubuntu-24.04/cppcheckpremium-$premium_version-amd64.tar.gz -O cppcheckpremium.tar.gz
+          fi
+          tar xzf cppcheckpremium.tar.gz
+          mv cppcheckpremium-$premium_version cppcheckpremium
+
+      - name: Generate a license file
+        run: |
+          echo cppcheck > cppcheck.lic
+          echo 261231 >> cppcheck.lic
+          echo 80000 >> cppcheck.lic
+          echo 4b64673f03fb6230 >> cppcheck.lic
+          echo path:lib >> cppcheck.lic
+
+      - name: Check
+        run: |
+          cppcheckpremium/premiumaddon --check-loc-license cppcheck.lic > cppcheck-premium-loc
+          cppcheckpremium/cppcheck --premium=safety-off -j$(nproc) -D__GNUC__ -D__CPPCHECK__ --suppressions-list=cppcheckpremium-suppressions --platform=unix64 --enable=style --premium=misra-c++-2023 --premium=cert-c++-2016 --inline-suppr lib --error-exitcode=0 --output-format=sarif 2> results.sarif
+
+      - name: Cat results
+        run: |
+          #sed -i 's|"security-severity":.*||' results.sarif
+          cat results.sarif
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: results
+          path: results.sarif
+
+      - name: Upload report
+        uses: github/codeql-action/upload-sarif@v3
+        with:
+          sarif_file: results.sarif
+          category: cppcheckpremium
diff --git a/.github/workflows/format.yml b/.github/workflows/format.yml
new file mode 100644
index 00000000000..fd491c0ec0e
--- /dev/null
+++ b/.github/workflows/format.yml
@@ -0,0 +1,55 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: format
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'releases/**'
+      - '2.*'
+    tags:
+      - '2.*'
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-22.04
+
+    env:
+      UNCRUSTIFY_VERSION: 0.80.1
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Cache uncrustify
+        uses: actions/cache@v4
+        id: cache-uncrustify
+        with:
+          path: |
+            ~/uncrustify
+          key: ${{ runner.os }}-uncrustify-${{ env.UNCRUSTIFY_VERSION }}
+
+      - name: build uncrustify
+        if: steps.cache-uncrustify.outputs.cache-hit != 'true'
+        run: |
+          set -x
+          wget https://github.com/uncrustify/uncrustify/archive/refs/tags/uncrustify-${{ env.UNCRUSTIFY_VERSION }}.tar.gz
+          tar xzvf uncrustify-${{ env.UNCRUSTIFY_VERSION }}.tar.gz
+          cd uncrustify-uncrustify-${{ env.UNCRUSTIFY_VERSION }}
+          cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+          cmake --build build -- -j$(nproc) -s
+          mkdir ~/uncrustify 
+          cp build/uncrustify ~/uncrustify/
+
+      - name: Uncrustify check
+        run: |
+          UNCRUSTIFY=~/uncrustify/uncrustify ./runformat
+          git diff
+          git diff | diff - /dev/null &> /dev/null
diff --git a/.github/workflows/iwyu.yml b/.github/workflows/iwyu.yml
new file mode 100644
index 00000000000..fa9be0cbba8
--- /dev/null
+++ b/.github/workflows/iwyu.yml
@@ -0,0 +1,271 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: include-what-you-use
+
+on:
+  schedule:
+    - cron: '0 0 * * 0'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  iwyu:
+
+    strategy:
+      matrix:
+        # "opensuse/tumbleweed:latest" / "fedora:latest" / "debian:unstable" / "archlinux:latest"
+        include:
+          - os: ubuntu-22.04
+            image: "fedora:latest"
+            stdlib: libstdc++
+            clang_inc: '-isystem/usr/lib/clang/20/include'
+          # TODO: disable because it currently fails with "error: <cstddef> tried including <stddef.h> but didn't find libc++'s <stddef.h> header."
+          #- os: ubuntu-22.04
+          #  image: "fedora:latest"
+          #  stdlib: libc++
+          #  clang_inc: '-isystem/usr/lib/clang/20/include'
+          - os: macos-26
+            image: ""
+            stdlib: libc++  # no libstdc++ on macOS
+            mapping_file_opt: '-Xiwyu --mapping_file=$(realpath ./macos.imp)'
+      fail-fast: false
+
+    runs-on: ${{ matrix.os }}
+    if: ${{ github.repository_owner == 'danmar' }}
+
+    container:
+      image: ${{ matrix.image }}
+
+    env:
+      QT_VERSION: 6.10.0
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Install missing software on debian/ubuntu
+        if: contains(matrix.image, 'debian')
+        run: |
+          apt-get update
+          apt-get install -y cmake clang make libpcre3-dev
+          apt-get install -y libgl-dev  # fixes missing dependency for Qt in CMake
+          apt-get install -y iwyu
+
+      - name: Install missing software on archlinux
+        if: contains(matrix.image, 'archlinux')
+        run: |
+          set -x
+          pacman -Sy
+          pacman -S cmake make clang pcre --noconfirm
+          pacman -S libglvnd --noconfirm  # fixes missing dependency for Qt in CMake
+          pacman-key --init
+          pacman-key --recv-key 3056513887B78AEB --keyserver keyserver.ubuntu.com
+          pacman-key --lsign-key 3056513887B78AEB 
+          pacman -U 'https://cdn-mirror.chaotic.cx/chaotic-aur/chaotic-keyring.pkg.tar.zst' 'https://cdn-mirror.chaotic.cx/chaotic-aur/chaotic-mirrorlist.pkg.tar.zst' --noconfirm
+          echo "[chaotic-aur]" >> /etc/pacman.conf
+          echo "Include = /etc/pacman.d/chaotic-mirrorlist" >> /etc/pacman.conf
+          pacman -Sy
+          pacman -S include-what-you-use --noconfirm
+          ln -s iwyu-tool /usr/sbin/iwyu_tool
+
+      - name: Install missing software on Fedora
+        if: contains(matrix.image, 'fedora')
+        run: |
+          dnf install -y cmake clang pcre-devel
+          dnf install -y libglvnd-devel  # fixes missing dependency for Qt in CMake
+          dnf install -y p7zip-plugins  # required as fallback for py7zr in Qt installation
+          dnf install -y python3-pip  # fixes missing pip module in jurplel/install-qt-action
+          dnf install -y python3-devel  # fixes building of wheels for jurplel/install-qt-action
+          dnf install -y cairo-devel gtk3-devel libcurl-devel lua-devel openssl-devel python3-devel sqlite-devel boost-devel cppunit-devel libsigc++20-devel  # for strict cfg checks
+          dnf install -y iwyu
+          ln -s iwyu_tool.py /usr/bin/iwyu_tool
+
+      - name: Install missing software on Fedora (libc++)
+        if: contains(matrix.image, 'fedora') && matrix.stdlib == 'libc++'
+        run: |
+          dnf install -y libcxx-devel
+
+      - name: Install missing software on OpenSUSE
+        if: contains(matrix.image, 'opensuse')
+        run: |
+          zypper install -y cmake clang pcre-devel
+          zypper install -y include-what-you-use-tools
+          ln -s iwyu_tool.py /usr/bin/iwyu_tool
+
+      # coreutils contains "nproc"
+      - name: Install missing software on macOS
+        if: contains(matrix.os, 'macos')
+        run: |
+          brew install include-what-you-use pcre coreutils
+          # on Apple Silicon files are symlinked under /opt/homebrew/bin
+          ln -s /opt/homebrew/bin/iwyu_tool.py /usr/local/bin/iwyu_tool
+
+      # Fails on OpenSUSE:
+      # Warning: Failed to restore: Tar failed with error: Unable to locate executable file: tar. Please verify either the file path exists or the file can be found within a directory specified by the PATH environment variable. Also check the file mode to verify the file is executable.
+      # Also the shell is broken afterwards:
+      # OCI runtime exec failed: exec failed: unable to start container process: exec: "sh": executable file not found in $PATH: unknown
+      #
+      # On macos-26 we need to perform the Python setup because the default installation is managed externally managed
+      - name: Install Qt ${{ env.QT_VERSION }}
+        uses: jurplel/install-qt-action@v4
+        with:
+          version: ${{ env.QT_VERSION }}
+          modules: 'qtcharts'
+          setup-python: ${{ contains(matrix.os, 'macos') }}
+          install-deps: false
+          cache: true
+
+      - name: Generate macOS mappings
+        if: contains(matrix.os, 'macos')
+        run: |
+          set -x
+
+          wget https://raw.githubusercontent.com/include-what-you-use/include-what-you-use/master/mapgen/iwyu-mapgen-apple-libc.py
+          python3 iwyu-mapgen-apple-libc.py $(xcrun --show-sdk-path)/usr/include > macos.imp
+
+      - name: Prepare CMake
+        run: |
+          cmake -S . -B cmake.output -Werror=dev -DCMAKE_BUILD_TYPE=Release -DHAVE_RULES=On -DBUILD_TESTING=On -DBUILD_GUI=On -DWITH_QCHART=On -DBUILD_TRIAGE=On -DENABLE_CHECK_INTERNAL=On -DCMAKE_GLOBAL_AUTOGEN_TARGET=On -DDISABLE_DMAKE=On -DCMAKE_DISABLE_PRECOMPILE_HEADERS=On -DCPPCHK_GLIBCXX_DEBUG=Off -DUSE_MATCHCOMPILER=Off -DEXTERNALS_AS_SYSTEM=On -DUSE_LIBCXX=${{ matrix.stdlib == 'libc++' }}
+        env:
+          CC: clang
+          CXX: clang++
+
+      # Fails on Debian:
+      # /__w/cppcheck/Qt/6.7.0/gcc_64/libexec/rcc: error while loading shared libraries: libglib-2.0.so.0: cannot open shared object file: No such file or directory
+      - name: Prepare CMake dependencies
+        run: |
+          # make sure the auto-generated GUI sources exist
+          make -C cmake.output autogen
+          # make sure the precompiled headers exist
+          #make -C cmake.output/cli cmake_pch.hxx.pch
+          #make -C cmake.output/gui cmake_pch.hxx.pch
+          #make -C cmake.output/lib cmake_pch.hxx.pch
+          #make -C cmake.output/test cmake_pch.hxx.pch
+          # make sure the auto-generated GUI dependencies exist
+          make -C cmake.output gui-build-deps
+          make -C cmake.output triage-build-ui-deps
+
+      - name: iwyu_tool
+        run: |
+          # TODO: remove -stdlib= - it should have been taken from the compilation database
+          iwyu_tool -p cmake.output -j $(nproc) -- -w -Xiwyu --max_line_length=1024 -Xiwyu --comment_style=long -Xiwyu --quoted_includes_first -Xiwyu --update_comments -stdlib=${{ matrix.stdlib }} ${{ matrix.mapping_file_opt }} ${{ matrix.clang_inc }} > iwyu.log
+
+      # TODO: run with all configurations
+      - name: test/cfg
+        if: matrix.stdlib == 'libstdc++'
+        run: |
+          # TODO: redirect to log
+          ./test/cfg/runtests.sh
+        env:
+          IWYU: include-what-you-use
+          IWYU_CLANG_INC: ${{ matrix.clang_inc }}
+
+      - uses: actions/upload-artifact@v4
+        if: success() || failure()
+        with:
+          name: Compilation Database (include-what-you-use - ${{ matrix.os }} ${{ matrix.stdlib }})
+          path: ./cmake.output/compile_commands.json
+
+      - uses: actions/upload-artifact@v4
+        if: ${{ contains(matrix.os, 'macos') && (success() || failure()) }}
+        with:
+          name: macOS Mappings
+          path: |
+            ./iwyu-mapgen-apple-libc.py
+            ./macos.imp
+
+      - uses: actions/upload-artifact@v4
+        if: success() || failure()
+        with:
+          name: Logs (include-what-you-use - ${{ matrix.os }} ${{ matrix.stdlib }})
+          path: ./*.log
+
+  clang-include-cleaner:
+
+    strategy:
+      matrix:
+        stdlib: [libstdc++, libc++]
+        include:
+          - stdlib: libstdc++
+            use_libcxx: Off
+          - stdlib: libc++
+            use_libcxx: On
+      fail-fast: false
+
+    runs-on: ubuntu-22.04
+    if: ${{ github.repository_owner == 'danmar' }}
+
+    env:
+      QT_VERSION: 6.10.0
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Install missing software
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake make libpcre3-dev
+          sudo apt-get install -y libgl-dev  # missing dependency for using Qt in CMake
+
+      - name: Install clang
+        run: |
+          sudo apt-get purge --auto-remove llvm python3-lldb-14 llvm-14
+          wget https://apt.llvm.org/llvm.sh
+          chmod +x llvm.sh
+          sudo ./llvm.sh 22
+          sudo apt-get install -y clang-tools-22
+
+      - name: Install libc++
+        if: matrix.stdlib == 'libc++'
+        run: |
+          sudo apt-get install -y libc++-22-dev
+
+      - name: Install Qt ${{ env.QT_VERSION }}
+        uses: jurplel/install-qt-action@v4
+        with:
+          version: ${{ env.QT_VERSION }}
+          modules: 'qtcharts'
+          setup-python: 'false'
+          install-deps: false
+          cache: true
+
+      - name: Prepare CMake
+        run: |
+          cmake -S . -B cmake.output -Werror=dev -DCMAKE_BUILD_TYPE=Release -DHAVE_RULES=On -DBUILD_TESTING=On -DBUILD_GUI=On -DWITH_QCHART=On -DBUILD_TRIAGE=On -DENABLE_CHECK_INTERNAL=On -DCMAKE_GLOBAL_AUTOGEN_TARGET=On -DDISABLE_DMAKE=On -DCMAKE_DISABLE_PRECOMPILE_HEADERS=On -DCPPCHK_GLIBCXX_DEBUG=Off -DUSE_MATCHCOMPILER=Off -DEXTERNALS_AS_SYSTEM=On -DUSE_LIBCXX=${{ matrix.use_libcxx }}
+        env:
+          CC: clang-22
+          CXX: clang++-22
+
+      - name: Prepare CMake dependencies
+        run: |
+          # make sure the auto-generated GUI sources exist
+          make -C cmake.output autogen
+          # make sure the precompiled headers exist
+          #make -C cmake.output/cli cmake_pch.hxx.pch
+          #make -C cmake.output/gui cmake_pch.hxx.pch
+          #make -C cmake.output/lib cmake_pch.hxx.pch
+          #make -C cmake.output/test cmake_pch.hxx.pch
+          # make sure the auto-generated GUI dependencies exist
+          make -C cmake.output gui-build-deps
+
+      - name: clang-include-cleaner
+        run: |
+          # TODO: run multi-threaded
+          find $PWD/cli $PWD/lib $PWD/test $PWD/gui -maxdepth 1 -name "*.cpp" | xargs -t -n 1 clang-include-cleaner-22 --print=changes --extra-arg=-w --extra-arg=-stdlib=${{ matrix.stdlib }} -p cmake.output > clang-include-cleaner.log 2>&1
+
+      - uses: actions/upload-artifact@v4
+        if: success() || failure()
+        with:
+          name: Compilation Database (clang-include-cleaner - ${{ matrix.stdlib }})
+          path: ./cmake.output/compile_commands.json
+
+      - uses: actions/upload-artifact@v4
+        if: success() || failure()
+        with:
+          name: Logs (clang-include-cleaner - ${{ matrix.stdlib }})
+          path: ./*.log
diff --git a/.github/workflows/release-windows-mingw.yml b/.github/workflows/release-windows-mingw.yml
new file mode 100644
index 00000000000..3b9b836347f
--- /dev/null
+++ b/.github/workflows/release-windows-mingw.yml
@@ -0,0 +1,69 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: release-windows-mingw
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'releases/**'
+      - '2.*'
+    tags:
+      - '2.*'
+  pull_request:
+
+permissions:
+  contents: read
+
+defaults:
+  run:
+    shell: msys2 {0}
+
+jobs:
+  # TODO: add CMake build
+  build_mingw:
+    strategy:
+      matrix:
+        # only use the latest windows-* as the installed toolchain is identical
+        os: [windows-2025]
+      fail-fast: false
+
+    runs-on: ${{ matrix.os }}
+
+    timeout-minutes: 19 # max + 3*std of the last 7K runs
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Set up MSYS2
+        uses: msys2/setup-msys2@v2
+        with:
+          release: false # use pre-installed
+          # TODO: install mingw-w64-x86_64-make and use mingw32.make instead - currently fails with "Windows Subsystem for Linux has no installed distributions."
+          install: >-
+            mingw-w64-x86_64-lld
+            make
+            mingw-w64-x86_64-gcc
+            python
+
+      - name: Build cppcheck
+        run: |
+          export PATH="/mingw64/lib/ccache/bin:$PATH"
+          # set RDYNAMIC to work around broken MinGW detection
+          make VERBOSE=1 RDYNAMIC=-lshlwapi -j$(nproc) CXXFLAGS=-O2 MATCHCOMPILER=yes cppcheck
+
+      - name: Package
+        run: |
+          mkdir cppcheck-mingw
+          cp cppcheck.exe cppcheck-mingw/
+          cp -R cfg platforms cppcheck-mingw/
+          cp /mingw64/bin/libgcc_s_seh-1.dll cppcheck-mingw/
+          cp /mingw64/bin/libstdc*.dll cppcheck-mingw/
+          cp /mingw64/bin/libwinpthread-1.dll cppcheck-mingw/
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: cppcheck-mingw
+          path: cppcheck-mingw
diff --git a/.github/workflows/release-windows.yml b/.github/workflows/release-windows.yml
new file mode 100644
index 00000000000..607c8434baa
--- /dev/null
+++ b/.github/workflows/release-windows.yml
@@ -0,0 +1,215 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: release-windows
+
+on:
+  push:
+    tags:
+      - '2.*'
+  schedule:
+    - cron:  '0 0 * * *'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+defaults:
+  run:
+    shell: cmd
+
+jobs:
+
+  build:
+
+    runs-on: windows-2025
+    if: ${{ github.repository_owner == 'danmar' }}
+
+    env:
+      PYTHON_VERSION: 3.14
+      # see https://www.pcre.org/original/changelog.txt
+      PCRE_VERSION: 8.45
+      QT_VERSION: 6.10.0
+      BOOST_MINOR_VERSION: 89
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+          check-latest: true
+
+      - name: Set up Visual Studio environment
+        uses: ilammy/msvc-dev-cmd@v1
+
+      - name: Download PCRE
+        run: |
+          curl -fsSL https://github.com/pfultz2/pcre/archive/refs/tags/%PCRE_VERSION%.zip -o pcre-%PCRE_VERSION%.zip || exit /b !errorlevel!
+
+      - name: Install PCRE
+        run: |
+          @echo on
+          7z x pcre-%PCRE_VERSION%.zip || exit /b !errorlevel!
+          cd pcre-%PCRE_VERSION% || exit /b !errorlevel!
+          git apply --ignore-space-change ..\externals\pcre.patch || exit /b !errorlevel!
+          cmake . -G "Visual Studio 17 2022" -A x64 -DPCRE_BUILD_PCRECPP=OFF -DPCRE_BUILD_PCREGREP=OFF -DPCRE_BUILD_TESTS=OFF -DCMAKE_POLICY_VERSION_MINIMUM=3.5 -DCMAKE_COMPILE_WARNING_AS_ERROR=On || exit /b !errorlevel!
+          msbuild -m PCRE.sln -p:Configuration=Release -p:Platform=x64 || exit /b !errorlevel!
+          copy pcre.h ..\externals || exit /b !errorlevel!
+          copy Release\pcre.lib ..\externals\pcre64.lib || exit /b !errorlevel!
+
+      - name: Download Boost
+        run: |
+          curl -fsSL https://archives.boost.io/release/1.%BOOST_MINOR_VERSION%.0/source/boost_1_%BOOST_MINOR_VERSION%_0.7z -o boost.zip || exit /b !errorlevel!
+
+      - name: Install Boost
+        run: |
+          @echo on
+          7z x boost.zip boost_1_%BOOST_MINOR_VERSION%_0/boost || exit /b !errorlevel!
+          ren boost_1_%BOOST_MINOR_VERSION%_0 boost || exit /b !errorlevel!
+
+      # available modules: https://github.com/miurahr/aqtinstall/blob/master/docs/getting_started.rst#installing-modules
+      # available tools:   https://github.com/miurahr/aqtinstall/blob/master/docs/getting_started.rst#installing-tools
+      - name: Install Qt
+        uses: jurplel/install-qt-action@v4
+        with:
+          version: ${{ env.QT_VERSION }}
+          modules: 'qtcharts'
+          setup-python: 'false'
+          tools: 'tools_opensslv3_x64'
+
+      # TODO: build with multiple threads
+      - name: Build x64 release GUI
+        run: |
+          :: TODO: enable rules?
+          :: specify Release build so matchcompiler is used
+          cmake -S . -B build -Werror=dev -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTING=Off -DBUILD_GUI=On -DWITH_QCHART=On -DBUILD_ONLINE_HELP=On -DUSE_BOOST=ON -DBOOST_INCLUDEDIR=%GITHUB_WORKSPACE%\boost -DCMAKE_COMPILE_WARNING_AS_ERROR=On || exit /b !errorlevel!
+          cmake --build build --target cppcheck-gui --config Release || exit /b !errorlevel!
+
+      # TODO: package PDBs
+      - name: Deploy app
+        run: |
+          windeployqt build\bin\Release || exit /b !errorlevel!
+          del build\bin\Release\cppcheck-gui.ilk || exit /b !errorlevel!
+          del build\bin\Release\cppcheck-gui.pdb || exit /b !errorlevel!
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: deploy
+          path: build\bin\Release
+
+      - name: Matchcompiler
+        run: python tools\matchcompiler.py --write-dir lib || exit /b !errorlevel!
+
+      # TODO: build with multiple threads
+      - name: Build CLI x64 release configuration using MSBuild
+        run: msbuild -m cppcheck.sln -t:cli -p:Configuration=Release-PCRE -p:Platform=x64 -p:HaveBoost=HAVE_BOOST -p:BoostInclude=%GITHUB_WORKSPACE%\boost || exit /b !errorlevel!
+        env:
+          _CL_: /WX
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: bin
+          path: bin
+
+      - name: Install missing Python packages
+        run: |
+          pip install -U pyinstaller || exit /b !errorlevel!
+
+      # TODO: include in installer?
+      - name: Compile misra.py executable
+        run: |
+          cd addons || exit /b !errorlevel!
+          pyinstaller --hidden-import xml --hidden-import xml.etree --hidden-import xml.etree.ElementTree misra.py || exit /b !errorlevel!
+          del *.spec || exit /b !errorlevel!
+
+      # TODO: include in installer?
+      - name: Compile cppcheck-htmlreport executable
+        run: |
+          cd htmlreport || exit /b !errorlevel!
+          pyinstaller cppcheck-htmlreport || exit /b !errorlevel!
+          del *.spec || exit /b !errorlevel!
+
+      # TODO: test the compiled Python files
+
+      - name: Collect files
+        run: |
+          @echo on
+          move build\bin\Release win_installer\files || exit /b !errorlevel!
+          copy AUTHORS win_installer\files\authors.txt || exit /b !errorlevel!
+          copy win_installer\GPLv3.txt win_installer\files\ || exit /b !errorlevel!
+          copy externals\picojson\LICENSE win_installer\files\picojson-license.txt || exit /b !errorlevel!
+          copy externals\simplecpp\LICENSE win_installer\files\simplecpp-license.txt || exit /b !errorlevel!
+          copy externals\tinyxml2\LICENSE win_installer\files\tinyxml2-license.txt || exit /b !errorlevel!
+          copy addons\dist\misra\*.* win_installer\files\addons || exit /b !errorlevel!
+          copy bin\cppcheck.exe win_installer\files || exit /b !errorlevel!
+          copy bin\cppcheck-core.dll win_installer\files || exit /b !errorlevel!
+          :: mkdir win_installer\files\help || exit /b !errorlevel!
+          xcopy /s gui\help win_installer\files\help || exit /b !errorlevel!
+          copy gui\help\online-help.qhc win_installer\files\ || exit /b !errorlevel!
+          copy gui\help\online-help.qch win_installer\files\ || exit /b !errorlevel!
+          del win_installer\files\cfg\*.rng || exit /b !errorlevel!
+          del win_installer\files\platforms\*.rng || exit /b !errorlevel!
+          del win_installer\files\translations\*.qm || exit /b !errorlevel!
+          move build\gui\*.qm win_installer\files\translations || exit /b !errorlevel!
+          copy htmlreport\dist\cppcheck-htmlreport\*.* win_installer\files || exit /b !errorlevel!
+          :: copy libcrypto-3-x64.dll and libssl-3-x64.dll
+          copy %RUNNER_WORKSPACE%\Qt\Tools\OpenSSLv3\Win_x64\bin\lib*.dll win_installer\files || exit /b !errorlevel!
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: collect
+          path: win_installer\files
+
+      - name: Build Installer
+        run: |
+          cd win_installer || exit /b !errorlevel!
+          :: Read ProductVersion
+          for /f "tokens=4 delims= " %%a in ('find "ProductVersion" productInfo.wxi') do set PRODUCTVER=%%a
+          :: Remove double quotes
+          set PRODUCTVER=%PRODUCTVER:"=%
+          @echo ProductVersion="%PRODUCTVER%" || exit /b !errorlevel!
+          msbuild -m cppcheck.wixproj -p:Platform=x64,ProductVersion=%PRODUCTVER%.${{ github.run_number }} || exit /b !errorlevel!
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: installer
+          path: win_installer/Build/
+
+      - name: Clean up deploy
+        run: |
+          @echo on
+          :: del win_installer\files\addons\*.dll || exit /b !errorlevel!
+          del win_installer\files\addons\*.doxyfile || exit /b !errorlevel!
+          del win_installer\files\addons\*.md || exit /b !errorlevel!
+          :: del win_installer\files\addons\*.pyd || exit /b !errorlevel!
+          :: del win_installer\files\addons\base_library.zip || exit /b !errorlevel!
+          rmdir /s /q win_installer\files\addons\test || exit /b !errorlevel!
+          rmdir /s /q win_installer\files\addons\doc || exit /b !errorlevel!
+          :: rmdir /s /q win_installer\files\bearer || exit /b !errorlevel!
+          rmdir /s /q win_installer\files\generic || exit /b !errorlevel!
+          rmdir /s /q win_installer\files\help || exit /b !errorlevel!
+          rmdir /s /q win_installer\files\iconengines || exit /b !errorlevel!
+          rmdir /s /q win_installer\files\imageformats || exit /b !errorlevel!
+          rmdir /s /q win_installer\files\networkinformation || exit /b !errorlevel!
+          :: rmdir /s /q win_installer\files\printsupport || exit /b !errorlevel!
+          rmdir /s /q win_installer\files\sqldrivers || exit /b !errorlevel!      
+          rmdir /s /q win_installer\files\tls || exit /b !errorlevel!
+          ren win_installer\files\translations lang || exit /b !errorlevel!
+          del win_installer\files\d3dcompiler_47.dll || exit /b !errorlevel!
+          del win_installer\files\dxcompiler.dll || exit /b !errorlevel!
+          del win_installer\files\dxil.dll || exit /b !errorlevel!
+          del win_installer\files\dmake.exe || exit /b !errorlevel!
+          del win_installer\files\dmake.pdb || exit /b !errorlevel!
+          :: del win_installer\files\libEGL.dll || exit /b !errorlevel!
+          :: del win_installer\files\libGLESv2.dll || exit /b !errorlevel!
+          del win_installer\files\opengl32sw.dll || exit /b !errorlevel!
+          del win_installer\files\Qt6Svg.dll || exit /b !errorlevel!
+          del win_installer\files\vc_redist.x64.exe || exit /b !errorlevel!
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: portable
+          path: win_installer\files
diff --git a/.github/workflows/scriptcheck.yml b/.github/workflows/scriptcheck.yml
new file mode 100644
index 00000000000..844b1d5c2f3
--- /dev/null
+++ b/.github/workflows/scriptcheck.yml
@@ -0,0 +1,222 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: scriptcheck
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'releases/**'
+      - '2.*'
+    tags:
+      - '2.*'
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-22.04
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.workflow }}-${{ runner.os }}
+
+      - name: Cache Cppcheck
+        uses: actions/cache@v4
+        with:
+          path: cppcheck
+          key: ${{ runner.os }}-scriptcheck-cppcheck-${{ github.sha }}
+
+      - name: build cppcheck
+        run: |
+          export PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH"
+          make -j$(nproc) CXXOPTS="-Werror"
+          strip -s ./cppcheck
+
+  scriptcheck:
+
+    needs: build
+    runs-on: ubuntu-22.04
+    strategy:
+      matrix:
+        python-version: [3.7, 3.8, 3.9, '3.10', '3.11', '3.12', '3.13', '3.14']
+        include:
+          - python-version: '3.14'
+            python-latest: true
+
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      # TODO: bailout on error
+      - name: Restore Cppcheck
+        uses: actions/cache@v4
+        with:
+          path: cppcheck
+          key: ${{ runner.os }}-scriptcheck-cppcheck-${{ github.sha }}
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          check-latest: true
+
+      - name: Install missing software on ubuntu
+        run: |
+          sudo apt-get update
+          sudo apt-get install tidy libxml2-utils
+
+      - name: Install missing software on ubuntu (Python 3)
+        run: |
+          # shellcheck cannot be installed via pip
+          # ERROR: Could not find a version that satisfies the requirement shellcheck (from versions: none)
+          # ERROR: No matching distribution found for shellcheck
+          sudo apt-get install shellcheck
+          python -m pip install pip --upgrade
+          python -m pip install natsort
+          python -m pip install pexpect
+          python -m pip install 'pylint<4.1.0'
+          python -m pip install unittest2
+          python -m pip install pytest
+          python -m pip install pytest-xdist
+          python -m pip install pygments
+          python -m pip install requests
+          python -m pip install psutil
+          python -m pip install setuptools
+
+      - name: run Shellcheck
+        if: matrix.python-latest
+        run: |
+          find . -name "*.sh" | xargs shellcheck --exclude SC2002,SC2013,SC2034,SC2035,SC2043,SC2046,SC2086,SC2089,SC2090,SC2129,SC2211,SC2231
+
+      - name: run pylint
+        if: matrix.python-latest
+        run: |
+          shopt -s globstar
+          pylint --jobs $(nproc) --py-version 3.7 addons/**/*.py htmlreport/cppcheck-htmlreport htmlreport/**/*.py test/**/*.py tools/**/*.py
+
+      - name: check .json files
+        if: matrix.python-latest
+        run: |
+          find . -name '*.json' | xargs -n 1 python -m json.tool > /dev/null
+
+      - name: Validate
+        if: matrix.python-latest
+        run: |
+          make -j$(nproc) validateCFG validatePlatforms validateRules
+
+      - name: check python syntax
+        run: |
+          shopt -s globstar
+          python -m py_compile addons/**/*.py
+          python -m py_compile htmlreport/cppcheck-htmlreport
+          python -m py_compile htmlreport/**/*.py
+          python -m py_compile test/**/*.py
+          python -m py_compile tools/**/*.py
+
+      - name: compile addons
+        run: |
+          python -m compileall ./addons
+
+      - name: test matchcompiler
+        run: |
+          python test/tools/test_matchcompiler.py
+        env:
+          PYTHONPATH: ./tools
+
+      # TODO: run with "-n auto" when misra_test.py can be run in parallel
+      # we cannot specify -Werror since xml/etree/ElementTree.py in Python 3.9/3.10 contains an unclosed file
+      - name: test addons
+        if: matrix.python-version == '3.9' || matrix.python-version == '3.10'
+        run: |
+          python -m pytest --strict-markers -vv -n 1 addons/test
+        env:
+          PYTHONPATH: ./addons
+
+      # TODO: run with "-n auto" when misra_test.py can be run in parallel
+      - name: test addons
+        if: matrix.python-version != '3.9' && matrix.python-version != '3.10'
+        run: |
+          python -m pytest -Werror --strict-markers -vv -n 1 addons/test
+        env:
+          PYTHONPATH: ./addons
+
+      - name: test htmlreport (standalone)
+        run: |
+          test/tools/htmlreport/test_htmlreport.py
+          test/tools/htmlreport/check.sh
+
+      - name: test htmlreport (pip)
+        run: |
+          python -m venv venv
+          source venv/bin/activate
+          python -m pip install -U pip
+          pip install ./htmlreport/
+          which cppcheck-htmlreport
+          PIP_PACKAGE_TEST=1 test/tools/htmlreport/test_htmlreport.py
+          # TODO: does not test the pip binary
+          test/tools/htmlreport/check.sh
+
+      - name: test reduce
+        run: |
+          python -m pytest -Werror --strict-markers -vv test/tools/reduce_test.py
+        env:
+          PYTHONPATH: ./tools
+
+      - name: test donate_cpu_lib
+        run: |
+          python -m pytest -Werror --strict-markers -vv test/tools/donate_cpu_lib_test.py
+        env:
+          PYTHONPATH: ./tools
+
+      - name: test donate_cpu_server
+        run: |
+          python -m pytest -Werror --strict-markers -vv test/tools/donate_cpu_server_test.py
+          # TODO: why is this file generated? also should be in a temporary folder if possible
+          rm -f test/tools/donate-cpu-server.log
+        env:
+          PYTHONPATH: ./tools
+
+      - name: Show all ignored files
+        if: false  # TODO: currently lists all the contents of ignored folders - we only need what actually matched
+        run: |
+          git ls-files --others --ignored --exclude-standard
+
+      - name: Check for changed and unversioned files
+        run: |
+          # TODO: how to do this with a single command?
+          git status --ignored=no
+          git status --ignored=no | grep -q 'working tree clean'
+
+  dmake:
+    strategy:
+      matrix:
+        os: [ubuntu-22.04, macos-15, windows-2025]
+      fail-fast: false
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: run dmake
+        run: |
+          make -j3 CXXOPTS="-Werror" run-dmake
+
+      - name: check diff
+        run: |
+          git diff --exit-code
diff --git a/.github/workflows/selfcheck.yml b/.github/workflows/selfcheck.yml
new file mode 100644
index 00000000000..ec52b15f939
--- /dev/null
+++ b/.github/workflows/selfcheck.yml
@@ -0,0 +1,204 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: selfcheck
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'releases/**'
+      - '2.*'
+    tags:
+      - '2.*'
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-22.04
+
+    env:
+      QT_VERSION: 6.10.0
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.workflow }}-${{ runner.os }}
+
+      - name: Install missing software
+        run: |
+          sudo apt-get update
+          sudo apt-get install clang-14
+          sudo apt-get install libboost-container-dev
+          sudo apt-get install valgrind
+          sudo apt-get install -y libgl-dev  # fixes missing dependency for Qt in CMake
+
+      - name: Install Qt ${{ env.QT_VERSION }}
+        uses: jurplel/install-qt-action@v4
+        with:
+          version: ${{ env.QT_VERSION }}
+          modules: 'qtcharts'
+          setup-python: 'false'
+          install-deps: false
+          cache: true
+
+      # TODO: cache this - perform same build as for the other self check
+      - name: Self check (build)
+        run: |
+          export PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH"
+          # valgrind cannot handle DWARF 5 yet so force version 4
+          # work around performance regression with -inline-deferral
+          make -j$(nproc) CXXOPTS="-Werror -O2 -gdwarf-4" CPPOPTS="-DHAVE_BOOST -mllvm -inline-deferral" MATCHCOMPILER=yes CPPCHK_GLIBCXX_DEBUG=
+        env:
+          CC: clang-14
+          CXX: clang++-14
+
+      # unusedFunction - start
+      - name: CMake
+        run: |
+          cmake -S . -B cmake.output -Werror=dev -DHAVE_RULES=On -DBUILD_TESTING=On -DBUILD_GUI=ON -DWITH_QCHART=ON -DBUILD_TRIAGE=On -DENABLE_CHECK_INTERNAL=On -DCMAKE_GLOBAL_AUTOGEN_TARGET=On -DDISABLE_DMAKE=On -DCPPCHK_GLIBCXX_DEBUG=Off
+
+      - name: Generate dependencies
+        run: |
+          # make sure auto-generated GUI files exist
+          make -C cmake.output autogen
+          # make sure the precompiled headers exist
+          make -C cmake.output lib/CMakeFiles/cppcheck-core.dir/cmake_pch.hxx.cxx
+          make -C cmake.output test/CMakeFiles/testrunner.dir/cmake_pch.hxx.cxx
+          # make sure the auto-generated GUI dependencies exist
+          make -C cmake.output gui-build-deps
+
+      - name: Self check (unusedFunction)
+        if: false # TODO: fails with preprocessorErrorDirective - see #10667
+        run: |
+          ./cppcheck -q --template=selfcheck --error-exitcode=1 --library=cppcheck-lib --library=qt -D__CPPCHECK__ -D__GNUC__ -DQT_VERSION=0x060000 -DQ_MOC_OUTPUT_REVISION=69 -DQT_CHARTS_LIB -DQT_MOC_HAS_STRINGDATA --enable=unusedFunction,information --exception-handling -rp=. --project=cmake.output/compile_commands.json --suppressions-list=.selfcheck_unused_suppressions --inline-suppr
+        env:
+          DISABLE_VALUEFLOW: 1
+          UNUSEDFUNCTION_ONLY: 1
+      # unusedFunction - end
+
+      # the following steps are duplicated from above since setting up the build node in a parallel step takes longer than the actual steps
+
+      # unusedFunction notest - start
+      - name: CMake (no test)
+        run: |
+          cmake -S . -B cmake.output.notest -Werror=dev -DHAVE_RULES=On -DBUILD_TESTING=Off -DBUILD_GUI=ON -DBUILD_TRIAGE=On -DWITH_QCHART=ON -DENABLE_CHECK_INTERNAL=On -DCMAKE_GLOBAL_AUTOGEN_TARGET=On -DDISABLE_DMAKE=On -DCPPCHK_GLIBCXX_DEBUG=Off
+
+      - name: Generate dependencies (no test)
+        run: |
+          # make sure auto-generated GUI files exist
+          make -C cmake.output.notest autogen
+          # make sure the precompiled headers exist
+          make -C cmake.output.notest lib/CMakeFiles/cppcheck-core.dir/cmake_pch.hxx.cxx
+          # make sure the auto-generated GUI dependencies exist
+          make -C cmake.output.notest gui-build-deps
+
+      - name: Self check (unusedFunction / no test)
+        run: |
+          ./cppcheck -q --template=selfcheck --error-exitcode=1 --library=cppcheck-lib --library=qt -D__CPPCHECK__ -D__GNUC__ -DQT_VERSION=0x060000 -DQ_MOC_OUTPUT_REVISION=69 -DQT_CHARTS_LIB -DQT_MOC_HAS_STRINGDATA --enable=unusedFunction,information --exception-handling -rp=. --project=cmake.output.notest/compile_commands.json --suppressions-list=.selfcheck_unused_suppressions --inline-suppr
+        env:
+          DISABLE_VALUEFLOW: 1
+          UNUSEDFUNCTION_ONLY: 1
+      # unusedFunction notest - end
+
+      # unusedFunction notest nogui - start
+      - name: CMake (no test / no gui)
+        run: |
+          cmake -S . -B cmake.output.notest_nogui -Werror=dev -DHAVE_RULES=On -DBUILD_TESTING=Off -DENABLE_CHECK_INTERNAL=On -DCPPCHK_GLIBCXX_DEBUG=Off
+
+      - name: Generate dependencies (no test / no gui)
+        run: |
+          # make sure the precompiled headers exist
+          make -C cmake.output.notest_nogui lib/CMakeFiles/cppcheck-core.dir/cmake_pch.hxx.cxx
+
+      - name: Self check (unusedFunction / no test / no gui)
+        run: |
+          supprs="--suppress=unusedFunction:lib/errorlogger.h:197 --suppress=unusedFunction:lib/importproject.cpp:1531 --suppress=unusedFunction:lib/importproject.cpp:1555"
+          ./cppcheck -q --template=selfcheck --error-exitcode=1 --library=cppcheck-lib -D__CPPCHECK__ -D__GNUC__ --enable=unusedFunction,information --exception-handling -rp=. --project=cmake.output.notest_nogui/compile_commands.json --suppressions-list=.selfcheck_unused_suppressions --inline-suppr $supprs
+        env:
+          DISABLE_VALUEFLOW: 1
+          UNUSEDFUNCTION_ONLY: 1
+      # unusedFunction notest nogui - end
+
+      # unusedFunction notest nocli - start
+      - name: CMake (no test / no cli)
+        run: |
+          cmake -S . -B cmake.output.notest_nocli -Werror=dev -DHAVE_RULES=On -DBUILD_TESTING=Off -DBUILD_CLI=Off -DBUILD_GUI=ON -DWITH_QCHART=ON -DBUILD_TRIAGE=On -DENABLE_CHECK_INTERNAL=On -DCMAKE_GLOBAL_AUTOGEN_TARGET=On -DDISABLE_DMAKE=On -DCPPCHK_GLIBCXX_DEBUG=Off
+
+      - name: Generate dependencies (no test / no cli)
+        run: |
+          # make sure auto-generated GUI files exist
+          make -C cmake.output.notest_nocli autogen
+          # make sure the precompiled headers exist
+          make -C cmake.output.notest_nocli lib/CMakeFiles/cppcheck-core.dir/cmake_pch.hxx.cxx
+          # make sure the auto-generated GUI dependencies exist
+          make -C cmake.output.notest_nocli gui-build-deps
+
+      - name: Self check (unusedFunction / no test / no cli)
+        if: false  # TODO: the findings are currently too intrusive
+        run: |
+          ./cppcheck -q --template=selfcheck --error-exitcode=1 --library=cppcheck-lib --library=qt -D__CPPCHECK__ -D__GNUC__ -DQT_VERSION=0x060000 -DQ_MOC_OUTPUT_REVISION=69 -DQT_CHARTS_LIB -DQT_MOC_HAS_STRINGDATA --enable=unusedFunction,information --exception-handling -rp=. --project=cmake.output.notest_nocli/compile_commands.json --suppressions-list=.selfcheck_unused_suppressions --inline-suppr
+        env:
+          DISABLE_VALUEFLOW: 1
+          UNUSEDFUNCTION_ONLY: 1
+      # unusedFunction notest nocli - end
+
+      # unusedFunction notest nocli nogui - start
+      - name: CMake (no test / no cli / no gui)
+        run: |
+          cmake -S . -B cmake.output.notest_nocli_nogui -Werror=dev -DHAVE_RULES=On -DBUILD_TESTING=Off -DBUILD_CLI=Off -DBUILD_GUI=Off -DENABLE_CHECK_INTERNAL=On -DCPPCHK_GLIBCXX_DEBUG=Off
+
+      - name: Generate dependencies (no test / no cli / no gui)
+        run: |
+          # make sure the precompiled headers exist
+          make -C cmake.output.notest_nocli_nogui lib/CMakeFiles/cppcheck-core.dir/cmake_pch.hxx.cxx
+
+      - name: Self check (unusedFunction / no test / no cli / no gui)
+        if: false  # TODO: the findings are currently too intrusive
+        run: |
+          ./cppcheck -q --template=selfcheck --error-exitcode=1 --library=cppcheck-lib --library=qt -D__CPPCHECK__ -D__GNUC__ --enable=unusedFunction,information --exception-handling -rp=. --project=cmake.output.notest_nocli_nogui/compile_commands.json --suppressions-list=.selfcheck_unused_suppressions --inline-suppr
+        env:
+          DISABLE_VALUEFLOW: 1
+          UNUSEDFUNCTION_ONLY: 1
+      # unusedFunction notest nocli nogui - end
+
+      - name: Fetch corpus
+        run: |
+          wget https://github.com/danmar/cppcheck/archive/refs/tags/2.8.tar.gz
+          tar xvf 2.8.tar.gz
+
+      - name: CMake (corpus / no test)
+        run: |
+          cmake -S cppcheck-2.8 -B cmake.output.corpus -DHAVE_RULES=On -DBUILD_TESTING=Off -DBUILD_GUI=ON -DUSE_QT6=On -DWITH_QCHART=ON -DENABLE_CHECK_INTERNAL=On -DCMAKE_GLOBAL_AUTOGEN_TARGET=On -DDISABLE_DMAKE=On -DCPPCHK_GLIBCXX_DEBUG=Off -DCMAKE_POLICY_VERSION_MINIMUM=3.5
+
+      - name: Generate dependencies (corpus)
+        run: |
+          # make sure auto-generated GUI files exist
+          make -C cmake.output.corpus autogen
+          # make sure the precompiled headers exist
+          make -C cmake.output.corpus lib/CMakeFiles/lib_objs.dir/cmake_pch.hxx.cxx
+          # make sure the auto-generated GUI dependencies exist
+          make -C cmake.output.corpus gui-build-deps
+
+      - name: Self check (unusedFunction / corpus / no test / callgrind)
+        run: |
+          # TODO: fix -rp so the suppressions actually work
+          valgrind --tool=callgrind ./cppcheck --template=selfcheck --error-exitcode=0 --library=cppcheck-lib --library=qt -D__GNUC__ -DQT_VERSION=0x060000 -DQ_MOC_OUTPUT_REVISION=69 -DQT_CHARTS_LIB -DQT_MOC_HAS_STRINGDATA --enable=unusedFunction,information --exception-handling -rp=. --project=cmake.output.corpus/compile_commands.json --suppressions-list=.selfcheck_unused_suppressions --inline-suppr 2>callgrind.log || (cat callgrind.log && false)
+          cat callgrind.log
+          callgrind_annotate --auto=no > callgrind.annotated.log
+          head -50 callgrind.annotated.log
+        env:
+          DISABLE_VALUEFLOW: 1
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: Callgrind Output
+          path: ./callgrind.*
diff --git a/.github/workflows/tsan.yml b/.github/workflows/tsan.yml
new file mode 100644
index 00000000000..72b1764d11d
--- /dev/null
+++ b/.github/workflows/tsan.yml
@@ -0,0 +1,146 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: thread sanitizer
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'releases/**'
+      - '2.*'
+    tags:
+      - '2.*'
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-22.04
+
+    env:
+      QT_VERSION: 6.10.0
+      TSAN_OPTIONS: halt_on_error=1
+      # TODO: figure out why there are cache misses with PCH enabled
+      CCACHE_SLOPPINESS: pch_defines,time_macros
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.workflow }}-${{ github.job }}-${{ matrix.os }}
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.14'
+          check-latest: true
+
+      - name: Install missing software on ubuntu
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake make libpcre3-dev libboost-container-dev libxml2-utils
+          sudo apt-get install -y libcups2-dev  # required for Qt6PrintSupport in CMake since Qt 6.7.3
+
+      - name: Install clang
+        run: |
+          sudo apt-get purge --auto-remove llvm python3-lldb-14 llvm-14
+          wget https://apt.llvm.org/llvm.sh
+          chmod +x llvm.sh
+          sudo ./llvm.sh 22
+
+      - name: Install Qt ${{ env.QT_VERSION }}
+        uses: jurplel/install-qt-action@v4
+        with:
+          version: ${{ env.QT_VERSION }}
+          modules: 'qtcharts'
+          setup-python: 'false'
+          cache: true
+
+      - name: Install missing Python packages
+        run: |
+          python3 -m pip install pip --upgrade
+          python3 -m pip install pytest
+          python3 -m pip install pytest-timeout
+          python3 -m pip install pytest-xdist
+          python3 -m pip install psutil
+
+      - name: CMake
+        run: |
+          cmake -S . -B cmake.output -Werror=dev -DCMAKE_BUILD_TYPE=RelWithDebInfo -DHAVE_RULES=On -DBUILD_TESTING=On -DBUILD_GUI=On -DWITH_QCHART=On -DBUILD_TRIAGE=On -DUSE_MATCHCOMPILER=Verify -DANALYZE_THREAD=On -DENABLE_CHECK_INTERNAL=On -DUSE_BOOST=On -DCPPCHK_GLIBCXX_DEBUG=Off -DCMAKE_DISABLE_PRECOMPILE_HEADERS=On -DCMAKE_GLOBAL_AUTOGEN_TARGET=Off -DDISABLE_DMAKE=On -DFILESDIR= -DCMAKE_COMPILE_WARNING_AS_ERROR=On -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
+        env:
+          CC: clang-22
+          CXX: clang++-22
+
+      - name: Build cppcheck
+        run: |
+          cmake --build cmake.output --target cppcheck -- -j $(nproc)
+
+      - name: Build test
+        run: |
+          cmake --build cmake.output --target testrunner -- -j $(nproc)
+
+      - name: Build GUI tests
+        run: |
+          cmake --build cmake.output --target gui-tests -- -j $(nproc)
+
+      - name: Run tests
+        run: ./cmake.output/bin/testrunner
+
+      - name: Run cfg tests
+        run: |
+          cmake --build cmake.output --target checkcfg -- -j $(nproc)
+
+      - name: Run CTest
+        if: false # TODO: test-filelist fails with data race in pthread_cond_destroy
+        run: |
+          ctest --test-dir cmake.output --output-on-failure -j$(nproc)
+
+      - name: Run test/cli
+        run: |
+          pwd=$(pwd)
+          TEST_CPPCHECK_EXE_LOOKUP_PATH="$pwd/cmake.output" python3 -m pytest -Werror --strict-markers -vv -n auto test/cli
+        env:
+          TEST_CPPCHECK_INJECT_EXECUTOR: thread
+
+      - name: Run test/cli (-j2)
+        run: |
+          pwd=$(pwd)
+          TEST_CPPCHECK_EXE_LOOKUP_PATH="$pwd/cmake.output" python3 -m pytest -Werror --strict-markers -vv -n auto test/cli
+        env:
+          TEST_CPPCHECK_INJECT_J: 2
+
+      - name: Run test/cli (--clang)
+        if: false
+        run: |
+          pwd=$(pwd)
+          TEST_CPPCHECK_EXE_LOOKUP_PATH="$pwd/cmake.output" python3 -m pytest -Werror --strict-markers -vv -n auto test/cli
+        env:
+          TEST_CPPCHECK_INJECT_CLANG: clang
+
+      - name: Run test/cli (--cppcheck-build-dir)
+        run: |
+          pwd=$(pwd)
+          TEST_CPPCHECK_EXE_LOOKUP_PATH="$pwd/cmake.output" python3 -m pytest -Werror --strict-markers -vv -n auto test/cli
+        env:
+          TEST_CPPCHECK_INJECT_BUILDDIR: injected
+
+      - name: Generate dependencies
+        if: false
+        run: |
+          # make sure auto-generated GUI files exist
+          make -C cmake.output autogen
+          make -C cmake.output gui-build-deps triage-build-ui-deps
+
+      # TODO: disabled for now as it takes around 40 minutes to finish
+      # set --error-exitcode=0 so we only fail on sanitizer issues - since it uses threads for execution it will exit the whole process on the first issue
+      - name: Self check
+        if: false
+        run: |
+          ./selfcheck_san.sh ./cmake.output "--executor=thread --error-exitcode=0"
diff --git a/.github/workflows/ubsan.yml b/.github/workflows/ubsan.yml
new file mode 100644
index 00000000000..5afc5feb1f9
--- /dev/null
+++ b/.github/workflows/ubsan.yml
@@ -0,0 +1,140 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: undefined behaviour sanitizers
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'releases/**'
+      - '2.*'
+    tags:
+      - '2.*'
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-22.04
+
+    env:
+      QT_VERSION: 6.10.0
+      UBSAN_OPTIONS: print_stacktrace=1:halt_on_error=1:report_error_type=1
+      # TODO: figure out why there are cache misses with PCH enabled
+      CCACHE_SLOPPINESS: pch_defines,time_macros
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.workflow }}-${{ github.job }}-${{ matrix.os }}
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.14'
+          check-latest: true
+
+      - name: Install missing software on ubuntu
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y cmake make libpcre3-dev libboost-container-dev libxml2-utils
+          sudo apt-get install -y libcups2-dev  # required for Qt6PrintSupport in CMake since Qt 6.7.3
+
+      - name: Install clang
+        run: |
+          sudo apt-get purge --auto-remove llvm python3-lldb-14 llvm-14
+          wget https://apt.llvm.org/llvm.sh
+          chmod +x llvm.sh
+          sudo ./llvm.sh 22
+
+      - name: Install Qt ${{ env.QT_VERSION }}
+        uses: jurplel/install-qt-action@v4
+        with:
+          version: ${{ env.QT_VERSION }}
+          modules: 'qtcharts'
+          setup-python: 'false'
+          cache: true
+
+      - name: Install missing Python packages
+        run: |
+          python3 -m pip install pip --upgrade
+          python3 -m pip install pytest
+          python3 -m pip install pytest-timeout
+          python3 -m pip install pytest-xdist
+          python3 -m pip install psutil
+
+      - name: CMake
+        run: |
+          cmake -S . -B cmake.output -Werror=dev -DCMAKE_BUILD_TYPE=RelWithDebInfo -DHAVE_RULES=On -DBUILD_TESTING=On -DBUILD_GUI=On -DWITH_QCHART=On -DBUILD_TRIAGE=On -DUSE_MATCHCOMPILER=Verify -DANALYZE_UNDEFINED=On -DENABLE_CHECK_INTERNAL=On -DUSE_BOOST=On -DCPPCHK_GLIBCXX_DEBUG=Off -DCMAKE_DISABLE_PRECOMPILE_HEADERS=On -DCMAKE_GLOBAL_AUTOGEN_TARGET=On -DDISABLE_DMAKE=On -DFILESDIR= -DCMAKE_COMPILE_WARNING_AS_ERROR=On -DCMAKE_C_COMPILER_LAUNCHER=ccache -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
+        env:
+          CC: clang-22
+          CXX: clang++-22
+
+      - name: Build cppcheck
+        run: |
+          cmake --build cmake.output --target cppcheck -- -j $(nproc)
+
+      - name: Build test
+        run: |
+          cmake --build cmake.output --target testrunner -- -j $(nproc)
+
+      - name: Build GUI tests
+        run: |
+          cmake --build cmake.output --target gui-tests -- -j $(nproc)
+
+      - name: Run tests
+        run: ./cmake.output/bin/testrunner
+
+      - name: Run cfg tests
+        run: |
+          cmake --build cmake.output --target checkcfg -- -j $(nproc)
+
+      - name: Run CTest
+        run: |
+          ctest --test-dir cmake.output --output-on-failure -j$(nproc)
+
+      - name: Run test/cli
+        run: |
+          pwd=$(pwd)
+          TEST_CPPCHECK_EXE_LOOKUP_PATH="$pwd/cmake.output" python3 -m pytest -Werror --strict-markers -vv -n auto test/cli
+
+      - name: Run test/cli (-j2)
+        run: |
+          pwd=$(pwd)
+          TEST_CPPCHECK_EXE_LOOKUP_PATH="$pwd/cmake.output" python3 -m pytest -Werror --strict-markers -vv -n auto test/cli
+        env:
+          TEST_CPPCHECK_INJECT_J: 2
+
+      - name: Run test/cli (--clang)
+        if: false
+        run: |
+          pwd=$(pwd)
+          TEST_CPPCHECK_EXE_LOOKUP_PATH="$pwd/cmake.output" python3 -m pytest -Werror --strict-markers -vv -n auto test/cli
+        env:
+          TEST_CPPCHECK_INJECT_CLANG: clang
+
+      - name: Run test/cli (--cppcheck-build-dir)
+        run: |
+          pwd=$(pwd)
+          TEST_CPPCHECK_EXE_LOOKUP_PATH="$pwd/cmake.output" python3 -m pytest -Werror --strict-markers -vv -n auto test/cli
+        env:
+          TEST_CPPCHECK_INJECT_BUILDDIR: injected
+
+      - name: Generate dependencies
+        run: |
+          # make sure auto-generated GUI files exist
+          make -C cmake.output autogen
+          make -C cmake.output gui-build-deps triage-build-ui-deps
+
+      # TODO: only fail the step on sanitizer issues - since we use processes it will only fail the underlying process which will result in an cppcheckError
+      - name: Self check
+        run: |
+          ./selfcheck_san.sh ./cmake.output
diff --git a/.github/workflows/valgrind.yml b/.github/workflows/valgrind.yml
new file mode 100644
index 00000000000..9a6026aa25b
--- /dev/null
+++ b/.github/workflows/valgrind.yml
@@ -0,0 +1,65 @@
+# Syntax reference https://help.github.com/en/actions/reference/workflow-syntax-for-github-actions
+# Environment reference https://help.github.com/en/actions/reference/virtual-environments-for-github-hosted-runners
+name: valgrind
+
+on:
+  push:
+    branches:
+      - 'main'
+      - 'releases/**'
+      - '2.*'
+    tags:
+      - '2.*'
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-22.04
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+
+      - name: ccache
+        uses: hendrikmuhs/ccache-action@v1.2
+        with:
+          key: ${{ github.workflow }}-${{ runner.os }}
+
+      - name: Install missing software
+        run: |
+          sudo apt-get update
+          sudo apt-get install libxml2-utils
+          sudo apt-get install valgrind
+          sudo apt-get install libboost-container-dev
+          sudo apt-get install debuginfod
+
+      - name: Build cppcheck
+        run: |
+          export PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH"
+          make -j$(nproc) CXXOPTS="-Werror -O1 -g" CPPOPTS="-DHAVE_BOOST" HAVE_RULES=yes MATCHCOMPILER=yes CPPCHK_GLIBCXX_DEBUG=
+
+      - name: Build test
+        run: |
+          export PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH"
+          make -j$(nproc) CXXOPTS="-Werror -O1 -g" CPPOPTS="-DHAVE_BOOST" HAVE_RULES=yes MATCHCOMPILER=yes CPPCHK_GLIBCXX_DEBUG= testrunner
+
+      - name: Run valgrind
+        run: |
+          ec=0
+          valgrind --error-limit=yes --leak-check=full --num-callers=50 --show-reachable=yes --track-origins=yes --suppressions=valgrind/testrunner.supp --gen-suppressions=all --log-fd=9 --error-exitcode=42 ./testrunner TestGarbage TestOther TestSimplifyTemplate 9>memcheck.log || ec=1
+          cat memcheck.log
+          exit $ec
+        # TODO: debuginfod.ubuntu.com is currently not responding to any requests causing it to run into a 40(!) minute timeout
+        #env:
+        #  DEBUGINFOD_URLS: https://debuginfod.ubuntu.com
+          
+      - uses: actions/upload-artifact@v4
+        if: success() || failure()
+        with:
+          name: Logs
+          path: ./*.log
diff --git a/.gitignore b/.gitignore
index 35b86ff828d..434203fe2a9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,24 +1,29 @@
 *.bak
 *.gcno
+*.gch
 *.o
 *.pyc
-cppcheck
-cppcheck.exe
-dmake
-dmake.exe
+/cppcheck
+/cppcheck.exe
+cppcheck-core.dll
+/dmake
+/dmake.exe
 reduce
 reduce.exe
 tags
-testrunner
-testrunner.exe
+/testrunner
+/testrunner.exe
 tools/daca2*.html
-tools/dmake
 tools/errmsg
 tools/extracttests
+.DS_Store
 
 # dump files generated by Cppcheck
 *.*.dump
 
+# CTU info files generated by Cppcheck
+*.*.ctu-info
+
 # VS generated files
 *.aps
 *.idb
@@ -30,57 +35,31 @@ tools/extracttests
 *.sdf
 *.suo
 *.user
-.vs/
+/.vs/
+UpgradeLog*.htm
 
 # VS build folders
 bin/
 Build/
 BuildTmp/
-cli/temp/
+/cli/temp/
 ipch/
-lib/temp/
-test/temp/
+/lib/temp/
+/test/temp/
 
 # XCode build folders and files
 *.mode[0-9]v[0-9]
 *.pbxuser
 build/
 
-# GUI build folders
-gui/debug/
-gui/release/
-gui/temp/
-
 # Other (generated) GUI files
-gui/*.qm
-gui/cppcheck-gui
-gui/cppcheck-gui.exe
-gui/gui.sln
-gui/gui.vcproj
-gui/Makefile
-gui/Makefile.debug
-gui/Makefile.release
-gui/qrc_gui.cpp
-gui/test/Makefile
-gui/test/*/Makefile
-gui/test/*/*/Makefile
-gui/test/benchmark/simple/benchmark-simple
-gui/test/filelist/test-filelist
-gui/test/projectfile/test-projectfile
-gui/test/translationhandler/test-translationhandler
-gui/test/xmlreport/test-xmlreport
-gui/test/xmlreportv1/test-xmlreportv1
-gui/test/xmlreportv2/test-xmlreportv2
+/gui/help/online-help.qch
+/gui/help/online-help.qhc
 
 # Doxygen output folder
 doxyoutput/
 
-# qmake generated
-htmlreport/.tox/
-htmlreport/MANIFEST
-
 # Backup files and stuff from patches
-*.orig
 *.rej
 *~
 
@@ -88,7 +67,7 @@ htmlreport/MANIFEST
 *.kdev4
 
 # Common cmake build directories
-build*
+build**/
 
 # Temporal files
 *.swp
@@ -99,12 +78,53 @@ prime
 parts
 stage
 *.snap
-snap/.snapcraft
+/snap/.snapcraft
 
 # Manual folder
-man/manual.log
-man/manual.tex
+/man/manual.log
+/man/manual.tex
+/man/*.pdf
+/man/*.html
 
 # CLion
-.idea
+/.idea
 /.metadata/
+/cmake-build-*
+/.run
+
+# clang tooling temporary files
+/.clangd/
+/.cache/
+/compile_commands.json
+
+#vs code
+/.vscode
+
+# fuzzing output
+/oss-fuzz/corpus
+/oss-fuzz/corpus_
+/oss-fuzz/samples
+
+# Python
+/.venv/
+/venv/
+**/*.egg-info/
+
+# cppcheck-htmlreport auto files
+/htmlreport/cppcheck_htmlreport/run.py
+
+# GDB configuration
+.gdbinit
+
+# pyinstaller output
+/addons/dist
+/addons/misra.spec
+/htmlreport/cppcheck-htmlreport.spec
+/htmlreport/dist
+
+# ccache folder in CI
+/.ccache
+
+# PCRE Windows files
+/externals/pcre.h
+/externals/pcre64.lib
diff --git a/.pylintrc b/.pylintrc
new file mode 100644
index 00000000000..0ca3480c06f
--- /dev/null
+++ b/.pylintrc
@@ -0,0 +1,65 @@
+[MESSAGES CONTROL]
+disable=
+        # W start
+        redefined-builtin,
+        broad-exception-caught,
+        fixme,
+        bare-except,
+        redefined-outer-name,
+        attribute-defined-outside-init,
+        unspecified-encoding,
+        global-statement,
+        protected-access,
+        broad-exception-raised,
+        subprocess-popen-preexec-fn,
+        logging-not-lazy,
+        unknown-option-value,
+        unused-wildcard-import,
+        wildcard-import,
+        unused-argument,
+        pointless-string-statement,
+        arguments-renamed,
+        duplicate-string-formatting-argument,
+        # C start
+        consider-using-f-string,
+        invalid-name,
+        line-too-long,
+        missing-module-docstring,
+        missing-function-docstring,
+        import-outside-toplevel,
+        missing-class-docstring,
+        superfluous-parens,
+        too-many-lines,
+        trailing-newlines,
+        missing-final-newline,
+        use-implicit-booleaness-not-len,
+        wrong-import-order,
+        use-implicit-booleaness-not-comparison,
+        consider-using-enumerate,
+        unnecessary-lambda-assignment,
+        consider-using-dict-items,
+        consider-iterating-dictionary,
+        # R start
+        duplicate-code,
+        consider-using-with,
+        too-many-statements,
+        too-many-branches,
+        too-many-locals,
+        too-many-arguments,
+        too-few-public-methods,
+        too-many-return-statements,
+        consider-using-in,
+        too-many-nested-blocks,
+        too-many-public-methods,
+        chained-comparison,
+        too-many-instance-attributes,
+        too-many-boolean-expressions,
+        use-a-generator,
+        too-many-positional-arguments
+[REPORTS]
+reports=no
+[TYPECHECK]
+# See https://stackoverflow.com/questions/10300082/how-to-prevent-python-pylint-complaining-about-socket-class-sendall-method
+ignored-classes=SQLObject,_socketobject
+[MASTER]
+init-hook='import sys; sys.path.append("./addons")'
diff --git a/.selfcheck_suppressions b/.selfcheck_suppressions
new file mode 100644
index 00000000000..171a5a997d7
--- /dev/null
+++ b/.selfcheck_suppressions
@@ -0,0 +1,43 @@
+missingIncludeSystem
+# should not be reported - see #13387
+checkersReport
+
+# warnings in Qt generated code we cannot fix
+funcArgNamesDifferent:*/moc_checkthread.cpp
+funcArgNamesDifferent:*/moc_codeeditstylecontrols.cpp
+funcArgNamesDifferent:*/moc_resultstree.cpp
+funcArgNamesDifferent:*/moc_resultsview.cpp
+funcArgNamesDifferent:*/moc_threadhandler.cpp
+funcArgNamesDifferent:*/moc_threadresult.cpp
+naming-varname:*/gui/ui_*.h
+functionStatic:*/gui/ui_*.h
+
+# --debug-warnings suppressions
+valueFlowBailout
+valueFlowBailoutIncompleteVar
+valueFlowMaxIterations:gui/resultstree.cpp
+autoNoType:externals/simplecpp/simplecpp.cpp
+autoNoType:cli/*.cpp
+autoNoType:lib/*.cpp
+autoNoType:lib/library.h
+autoNoType:gui/*.cpp
+autoNoType:test/*.cpp
+autoNoType:tools/triage/mainwindow.cpp
+# ticket 11631
+templateInstantiation:test/testutils.cpp
+
+naming-varname:externals/simplecpp/simplecpp.h
+naming-privateMemberVariable:externals/simplecpp/simplecpp.h
+
+# TODO: these warnings need to be addressed upstream
+uninitMemberVar:externals/tinyxml2/tinyxml2.h
+noExplicitConstructor:externals/tinyxml2/tinyxml2.h
+missingOverride:externals/tinyxml2/tinyxml2.h
+invalidPrintfArgType_sint:externals/tinyxml2/tinyxml2.h
+naming-privateMemberVariable:externals/tinyxml2/tinyxml2.h
+functionStatic:externals/tinyxml2/tinyxml2.cpp
+funcArgNamesDifferent:externals/tinyxml2/tinyxml2.cpp
+nullPointerRedundantCheck:externals/tinyxml2/tinyxml2.cpp
+knownConditionTrueFalse:externals/tinyxml2/tinyxml2.cpp
+useStlAlgorithm:externals/simplecpp/simplecpp.cpp
+missingMemberCopy:externals/simplecpp/simplecpp.h
diff --git a/.selfcheck_unused_suppressions b/.selfcheck_unused_suppressions
new file mode 100644
index 00000000000..5da7c225dfa
--- /dev/null
+++ b/.selfcheck_unused_suppressions
@@ -0,0 +1,8 @@
+# should not be reported - see #13387
+checkersReport
+
+# we are not using all methods of their interfaces
+unusedFunction:externals/*/*
+
+# Q_OBJECT functions which are not called in our code
+unusedFunction:cmake.output.notest/gui/cppcheck-gui_autogen/*/moc_aboutdialog.cpp
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index cd642bcc4b0..00000000000
--- a/.travis.yml
+++ /dev/null
@@ -1,241 +0,0 @@
-language: cpp
-dist: xenial
-
-compiler:
-  - gcc
-  - clang
-
-env:
-  global:
-    - ORIGINAL_CXXFLAGS="-pedantic -Wall -Wextra -Wabi -Wcast-qual -Wfloat-equal -Wmissing-declarations -Wmissing-format-attribute -Wno-long-long -Wpacked -Wredundant-decls -Wno-shadow -Wno-missing-field-initializers -Wno-missing-braces -Wno-sign-compare -Wno-multichar -D_GLIBCXX_DEBUG -g "
-#   unfortunately we need this to stay within 50min timelimit given by travis.
-    - CXXFLAGS="${ORIGINAL_CXXFLAGS} -O2 -march=native -Wstrict-aliasing=2 -Werror=strict-aliasing"
-    - CPPCHECK=${TRAVIS_BUILD_DIR}/cppcheck
-  matrix:
-    - CXXFLAGS="${CXXFLAGS} -DCHECK_INTERNAL"
-    - CXXFLAGS="${CXXFLAGS} -DCHECK_INTERNAL" MAKEFLAGS="HAVE_RULES=yes" MATCHCOMPILER=yes VERIFY=1
-
-before_install:
-# install needed deps
- - travis_retry sudo apt-get update -qq
- - travis_retry sudo apt-get install -qq python-pygments python3-pip qt5-default qt5-qmake qtbase5-dev qtcreator libxml2-utils libpcre3 gdb unzip wx-common xmlstarlet python3-dev liblua5.3-dev libcurl3 libcairo2-dev
-# Python 2 modules 
- - travis_retry python2 -m pip install --user pytest==4.6.4
- - travis_retry python2 -m pip install --user pylint
- - travis_retry python2 -m pip install --user unittest2
- - travis_retry python2 -m pip install --user pexpect
-# Python 3 modules
- - travis_retry python3 -m pip install --user pytest
-
-matrix:
-# do notify immediately about it when a job of a build fails.
-  fast_finish: true
-  allow_failures:
-    - name: "rerun dmake?"
-      compiler: clang
-# defined extra jobs that run besides what is configured in the build matrix
-  include:
-# -fsanitize=undefined
-    - name: "undefined behaviour sanitizers"
-      compiler: gcc
-      script:
-        - CXXFLAGS="-fsanitize=undefined -fno-sanitize-recover=all -Og -g3" make cppcheck test checkcfg -j 2
-# -fsanitize=address
-    - name: "address sanitizers"
-      compiler: gcc
-      script:
-         - CXXFLAGS="-fsanitize=address -Og -g3" make cppcheck test checkcfg -j 2
-# check a lot of stuff that only needs to be checked in a single configuration
-    - name: "misc"
-      compiler: clang
-      script:
-        - make -j 2
-# run extra tests
-        - tools/generate_and_run_more_tests.sh
-# check for missing CWE entries
-        - make checkCWEEntries
-# check cfg files
-        - make checkcfg
-# check platform files
-        - make validatePlatforms
-# Validate Result XML
-        - make validateXML
-# Validate rule files
-        - make validateRules
-# note: trusty on travis has python pygments disabled so disable these tests on travis
-## check htmlreport stuff
-#  - ./htmlreport/test_htmlreport.py
-#  - cd htmlreport
-#  - ./check.sh
-#  - cd ../
-# check if DESTDIR works  TODO: actually execute this
-        - mkdir install_test
-        - echo $CXXFLAGS
-        - make -s DESTDIR=install_test FILESDIR=/usr/share/cppcheck install
-# rm everything
-        - git clean -dfx
-# check what happens if we want to install it to some other dir,
-        - echo $CXXFLAGS
-        - make -s MATCHCOMPILER=yes FILESDIR=/usr/share/cppcheck -j 2
-        - sudo make MATCHCOMPILER=yes FILESDIR=/usr/share/cppcheck install
-# check if it actually works:
-        - /usr/bin/cppcheck ./cli
-# check if showtime=top5 works
-        - ./tools/test_showtimetop5.sh
-# check matchcompiler
-        - ./tools/test_matchcompiler.py
-# check --dump
-        - ${CPPCHECK} test/testpreprocessor.cpp --dump
-        - xmllint --noout test/testpreprocessor.cpp.dump
-# check python syntax by compiling all addon scripts
-        - python -m compileall ./addons
-        - python3 -m compileall ./addons
-# run pylint
-        - pylint --rcfile=pylintrc_travis addons/*.py
-        - pylint --rcfile=pylintrc_travis htmlreport/*.py
-        - pylint --rcfile=pylintrc_travis tools/*.py
-# check python syntax by compiling some selected scripts
-        - python -m py_compile ./tools/donate-cpu.py
-        - python3 -m py_compile ./tools/donate-cpu.py
-        - python -m py_compile ./tools/donate-cpu-server.py
-        - python3 -m py_compile ./tools/donate-cpu-server.py
-# check addons/misc.py
-        - cd addons/test
-        - ${CPPCHECK} --dump misc-test.cpp
-        - python3 ../misc.py -verify misc-test.cpp.dump
-        - cd ../../
-# check addons/cert.py
-        - cd addons/test
-        - ${CPPCHECK} --dump cert-test.c
-        - python3 ../cert.py -verify cert-test.c.dump
-        - ${CPPCHECK} --dump cert-test.cpp
-        - python3 ../cert.py -verify cert-test.cpp.dump
-        - cd ../../
-# check addons/misra.py
-        - cd addons/test
-        - ${CPPCHECK} --dump misra/misra-test.c
-        - python3 ../misra.py -verify misra/misra-test.c.dump
-        - ${CPPCHECK} --dump misra/misra-test.cpp
-        - python3 ../misra.py -verify misra/misra-test.cpp.dump
-        - python ../misra.py --rule-texts=misra/misra2012_rules_dummy_ascii.txt -verify misra/misra-test.cpp.dump
-        - python3 ../misra.py --rule-texts=misra/misra2012_rules_dummy_ascii.txt -verify misra/misra-test.cpp.dump
-        - python ../misra.py --rule-texts=misra/misra2012_rules_dummy_utf8.txt -verify misra/misra-test.cpp.dump
-        - python3 ../misra.py --rule-texts=misra/misra2012_rules_dummy_utf8.txt -verify misra/misra-test.cpp.dump
-        - python ../misra.py --rule-texts=misra/misra2012_rules_dummy_windows1250.txt -verify misra/misra-test.cpp.dump
-        - python3 ../misra.py --rule-texts=misra/misra2012_rules_dummy_windows1250.txt -verify misra/misra-test.cpp.dump
-        - cd ../../
-# check addons/naming.py
-        - cd addons/test
-        - ${CPPCHECK} --dump naming_test.c
-        - python3 ../naming.py --var='[a-z].*' --function='[a-z].*' naming_test.c.dump
-        - cd ../..
-# check addons/namingng.py
-        - cd addons/test
-        - ${CPPCHECK} --dump namingng_test.c
-        - python3 ../namingng.py --configfile ../naming.json --verify namingng_test.c.dump
-        - cd ../..
-# try CMake
-        - mkdir cmake.output
-        - cd cmake.output
-        - cmake -G "Unix Makefiles" -DBUILD_TESTS=On ..
-        - make -j2 check
-        - cd ..
-
-# check if dmake needs to be rerun (this job may fail)
-    - name: "rerun dmake?"
-      compiler: clang
-# we don't need to install any deps for dmake so skip it explicitly
-      before_install:
-      - true
-      script:
-        - echo "If the following command fails, run 'make dmake; make run-dmake' and commit the resulting change."
-        - make -s dmake -j2
-        - make -s run-dmake
-        - git diff --exit-code
-# check if cppcheck builds on trusty
-    - name: "make ubuntu 14.04 trusty"
-      compiler: gcc
-      dist: trusty
-      before_install:
-        - travis_retry sudo apt-get update -qq
-        - travis_retry sudo apt-get install libxml2-utils libpcre3
-      script:
-        - CXX=g++ CXXFLAGS="${ORIGINAL_CXXFLAGS}" make cppcheck testrunner -j 2
-        - make clean
-        - CXX=clang++ CXXFLAGS="${ORIGINAL_CXXFLAGS}" make cppcheck testrunner -j 2
-# check if cppcheck builds on osx
-    - name: "make osx"
-      os: osx
-      before_install:
-        - true
-      script:
-        - CXX=g++ CXXFLAGS="${ORIGINAL_CXXFLAGS}"  make cppcheck testrunner -j 2
-        - make clean
-        - CXX=clang++ CXXFLAGS="${ORIGINAL_CXXFLAGS}" make cppcheck testrunner -j 2
-
-script:
-# fail the entire job as soon as one of the subcommands exits non-zero to save time and resources
-  - set -e
-# Determine CPU count. As of January 2019 it seems to be 2 - so use this for job count in suitable calls to make or cppcheck
-  - cat /proc/cpuinfo
-# check with TEST_MATHLIB_VALUE enabled
-  - touch lib/mathlib.cpp test/testmathlib.cpp
-  - echo $CXXFLAGS
-  - make -s test -j2 CPPFLAGS=-DTEST_MATHLIB_VALUE
-  - touch lib/mathlib.cpp test/testmathlib.cpp
-# syntax checking of cppcheck source code with -DNONNEG
-  - ls lib/*.cpp | xargs -n 1 -P 2 g++ -fsyntax-only -std=c++0x -Ilib -Iexternals -Iexternals/simplecpp -Iexternals/tinyxml -DNONNEG
-# compile cppcheck, default build
-  - echo $CXXFLAGS
-  - make -s test -j2
-# compile gui
-  - cd gui
-  - qmake
-  - echo $CXXFLAGS
-  - make -s -j2
-# building gui generates some more files that cppcheck can check, so check the repo *after* building gui
-  - cd ../
-# self check lib/cli
-  - mkdir b1
-  - ${CPPCHECK} -j2 --template=gcc --cppcheck-build-dir=b1 -D__CPPCHECK__ --error-exitcode=1 --inline-suppr --suppressions-list=.travis_suppressions --library=cppcheck-lib --addon=naming.json -Ilib -Iexternals/simplecpp/ -Iexternals/tinyxml/ -Icli --inconclusive --enable=style,performance,portability,warning,internal --exception-handling cli lib
-# check gui with qt settings
-  - mkdir b2
-  - ${CPPCHECK} -j2 --template=gcc --cppcheck-build-dir=b2 -D__CPPCHECK__ -DQT_VERSION=0x050000 --error-exitcode=1 --inline-suppr --suppressions-list=.travis_suppressions --library=qt --addon=naming.json -Ilib -Iexternals/simplecpp/ -Iexternals/tinyxml/ --enable=style,performance,portability,warning,internal --exception-handling gui/*.cpp
-# self check test and tools
-  - ${CPPCHECK} -j2 --template=gcc -D__CPPCHECK__ --error-exitcode=1 --inline-suppr --suppressions-list=.travis_suppressions --library=cppcheck-lib -Ilib -Iexternals/simplecpp/ -Iexternals/tinyxml/ -Icli --inconclusive --enable=style,performance,portability,warning,internal --exception-handling test/*.cpp tools
-# Build gui
-  - cd ./gui
-# clean rebuild
-  - git clean -dfx .
-# can't set this as env flags, so try again with HAVE_RULES=yes
-  - qmake HAVE_RULES=yes
-  - echo $CXXFLAGS
-  - make -s -j2
-  - cd ../
-# Build gui/test
-  - cd gui/test/projectfile
-  - qmake && make && ./test-projectfile
-  - cd -
-# Build triage
-  - cd ./tools/triage
-  - git clean -dfx .
-  - qmake
-  - make -s -j2
-  - cd ../../
-# Testing cli
-  - cp -R . ../cppcheck\ 2
-  - cd ../cppcheck\ 2/test/cli # path with space
-  - python -m pytest test-*.py
-  - cd -
-# Testing addons
-  - python -m pytest addons/test/test-*.py
-  - PYTHONPATH=./addons python3 -m pytest addons/test/test-*.py
-
-notifications:
-  irc:
-    channels:
-      - "irc.freenode.org#cppcheck"
-    template:
-      - "[%{commit} : %{author}] %{message}"
-      - "%{build_url}"
-    skip_join: true
diff --git a/.travis_llvmcheck_suppressions b/.travis_llvmcheck_suppressions
deleted file mode 100644
index f95909b7d27..00000000000
--- a/.travis_llvmcheck_suppressions
+++ /dev/null
@@ -1,8 +0,0 @@
-unreadVariable
-shadowVar
-shadowFunction
-unusedStructMember
-nullPointer
-uninitvar
-noExplicitConstructor
-
diff --git a/.travis_suppressions b/.travis_suppressions
deleted file mode 100644
index 65d307bd32d..00000000000
--- a/.travis_suppressions
+++ /dev/null
@@ -1,25 +0,0 @@
-unusedPrivateFunction:test/testbufferoverrun.cpp
-unusedPrivateFunction:test/testcmdlineparser.cpp
-redundantNextPrevious:test/testtoken.cpp
-simplePatternError:test/testtoken.cpp
-noValidConfiguration
-shadowFunction
-functionConst
-functionStatic
-
-# temporary suppressions - fix the warnings!
-duplicateBranch:lib/checkunusedvar.cpp
-duplicateBranch:lib/tokenize.cpp
-missingOverride
-redundantAssignment:lib/tokenlist.cpp
-unreachableCode:lib/checkbufferoverrun.cpp
-unreachableCode:lib/checkclass.cpp
-unreachableCode:test/testother.cpp
-unusedPrivateFunction:lib/checkbufferoverrun.h
-unusedPrivateFunction:test/test*.cpp
-useStlAlgorithm
-
-*:gui/test/*
-*:test/test.cxx
-*:test/cfg/*
-*:externals/*/*
diff --git a/.uncrustify.cfg b/.uncrustify.cfg
new file mode 100644
index 00000000000..81722ff7249
--- /dev/null
+++ b/.uncrustify.cfg
@@ -0,0 +1,170 @@
+# Uncrustify-0.80.1_f
+
+# The original size of tabs in the input.
+#
+# Default: 8
+input_tab_size                  = 4        # unsigned number
+
+# The size of tabs in the output (only used if align_with_tabs=true).
+#
+# Default: 8
+output_tab_size                 = 4        # unsigned number
+
+# Add or remove space between 'while' and '('.
+sp_while_paren_open             = add   # ignore/add/remove/force
+
+# Add or remove space around boolean operators '&&' and '||'.
+sp_bool                         = force    # ignore/add/remove/force
+
+# Add or remove space inside '(' and ')'.
+sp_inside_paren                 = remove   # ignore/add/remove/force
+
+# Add or remove space between nested parentheses, i.e. '((' vs. ') )'.
+sp_paren_paren                  = remove   # ignore/add/remove/force
+
+# Add or remove space between ')' and '{'.
+sp_paren_brace                  = force    # ignore/add/remove/force
+
+# Add or remove space between pointer stars '*'.
+sp_between_ptr_star             = remove   # ignore/add/remove/force
+
+# Add or remove space before '<'.
+sp_before_angle                 = remove   # ignore/add/remove/force
+
+# Add or remove space inside '<' and '>'.
+sp_inside_angle                 = remove   # ignore/add/remove/force
+
+# Add or remove space after '>'.
+sp_after_angle                  = add   # ignore/add/remove/force
+
+# Add or remove space between '>' and '(' as found in 'new List<byte>(foo);'.
+sp_angle_paren                  = remove   # ignore/add/remove/force
+
+# Add or remove space between '>' and a word as in 'List<byte> m;' or
+# 'template <typename T> static ...'.
+sp_angle_word                   = add   # ignore/add/remove/force
+
+# Add or remove space between '>' and '>' in '>>' (template stuff).
+#
+# Default: add
+sp_angle_shift                  = ignore      # ignore/add/remove/force
+
+# (C++11) Permit removal of the space between '>>' in 'foo<bar<int> >'. Note
+# that sp_angle_shift cannot remove the space without this option.
+sp_permit_cpp11_shift           = true    # true/false
+
+# Add or remove space before '(' of control statements ('if', 'for', 'switch',
+# 'while', etc.).
+sp_before_sparen                = force    # ignore/add/remove/force
+
+# Add or remove space inside '(' and ')' of control statements.
+sp_inside_sparen                = remove   # ignore/add/remove/force
+
+# Add or remove space after ')' of control statements.
+sp_after_sparen                 = force    # ignore/add/remove/force
+
+# Add or remove space between ')' and '{' of of control statements.
+sp_sparen_brace                 = force    # ignore/add/remove/force
+
+# Add or remove space before ';' in non-empty 'for' statements.
+sp_before_semi_for              = remove   # ignore/add/remove/force
+
+# Add or remove space after the final semicolon of an empty part of a for
+# statement, as in 'for ( ; ; <here> )'.
+sp_after_semi_for_empty         = remove   # ignore/add/remove/force
+
+# Add or remove space before '[]'.
+sp_before_squares               = remove   # ignore/add/remove/force
+
+# Add or remove space before C++17 structured bindings.
+sp_cpp_before_struct_binding    = ignore   # ignore/add/remove/force
+
+# Add or remove space inside a non-empty '[' and ']'.
+sp_inside_square                = remove   # ignore/add/remove/force
+
+# Add or remove space after class ':'.
+sp_after_class_colon            = force    # ignore/add/remove/force
+
+# Add or remove space before class ':'.
+sp_before_class_colon           = force    # ignore/add/remove/force
+
+# Add or remove space inside '{}'.
+sp_inside_braces_empty          = remove   # ignore/add/remove/force
+
+# Add or remove space between 'else' and '{' if on the same line.
+sp_else_brace                   = force    # ignore/add/remove/force
+
+# Add or remove space between '}' and 'else' if on the same line.
+sp_brace_else                   = force    # ignore/add/remove/force
+
+# Add or remove space before the '{' of a 'catch' statement, if the '{' and
+# 'catch' are on the same line, as in 'catch (decl) <here> {'.
+sp_catch_brace                  = force    # ignore/add/remove/force
+
+# Add or remove space between '}' and 'catch' if on the same line.
+sp_brace_catch                  = force    # ignore/add/remove/force
+
+# The number of columns to indent per level. Usually 2, 3, 4, or 8.
+#
+# Default: 8
+indent_columns                  = 4        # unsigned number
+
+# How to use tabs when indenting code.
+#
+# 0: Spaces only
+# 1: Indent with tabs to brace level, align with spaces (default)
+# 2: Indent and align with tabs, using spaces when not on a tabstop
+#
+# Default: 1
+indent_with_tabs                = 0        # unsigned number
+
+# Whether to indent the body of a 'namespace'.
+indent_namespace                = true    # true/false
+
+# Whether the 'class' body is indented.
+indent_class                    = true    # true/false
+
+# How to indent access specifiers that are followed by a
+# colon.
+#
+#  >0: Absolute column where 1 is the leftmost column
+# <=0: Subtract from brace indent
+#
+# Default: 1
+indent_access_spec              = -4        # number
+
+# Whether to collapse empty blocks between '{' and '}' except for functions.
+# Use nl_collapse_empty_body_functions to specify how empty function braces
+# should be formatted.
+nl_collapse_empty_body          = true    # true/false
+
+# Whether to collapse empty blocks between '{' and '}' for functions only.
+# If true, overrides nl_inside_empty_func.
+nl_collapse_empty_body_functions = true    # true/false
+
+# Whether to convert all tabs to spaces in comments. If false, tabs in
+# comments are left alone, unless used for indenting.
+cmt_convert_tab_to_spaces       = true    # true/false
+
+# An offset value that controls the indentation of the body of a multiline #define.
+# 'body' refers to all the lines of a multiline #define except the first line.
+# Requires 'pp_ignore_define_body = false'.
+#
+#  <0: Absolute column: the body indentation starts off at the specified column
+#      (ex. -3 ==> the body is indented starting from column 3)
+# >=0: Relative to the column of the '#' of '#define'
+#      (ex.  3 ==> the body is indented starting 3 columns at the right of '#')
+#
+# Default: 8
+pp_multiline_define_body_indent = 4        # number
+
+# The value might be used twice:
+# - at the assignment
+# - at the opening brace
+#
+# To prevent the double use of the indentation value, use this option with the
+# value 'true'.
+#
+# true:  indentation will be used only once
+# false: indentation will be used every time (default)
+indent_cpp_lambda_only_once     = true    # true/false
diff --git a/AUTHORS b/AUTHORS
index 9b56ad000ce..0d9ea7d27d6 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -1,8 +1,11 @@
 The cppcheck team, in alphabetical order:
 
+0x41head
+Abhijit Sawant
 Abhishek Bharadwaj
 Abigail Buccaneer
 Adam J Richter
+Adrien Chardon
 Ahti Legonkov
 Akhilesh Nema
 Akio Idehara
@@ -10,31 +13,47 @@ Albert Aribaud
 Aleksandr Pikalev
 Aleksey Palazhchenko
 Alexander Alekseev
+Alexander Festini
 Alexander Gushchin
 Alexander Mai
 Alexander Tkachev
+Alexandre Chouvellon
 Alexey Eryomenko
 Alexey Zhikhartsev
+Alfi Maulana
 Ali Can Demiralp
+Allen Winter
+Alon Alexander
+Alon Liberman
 Ameen Ali
 Andreas Bacher
 Andreas Bießmann
+Andreas Grob
+Andreas Lutsch
 Andreas Pokorny
 Andreas Rönnquist
 Andreas Vollenweider
 Andrei Karas
+Andrew C Aitchison
 Andrew C. Martin
+Andrew D. Bancroft
+Andy Holmes
 Andy Maloney
+Andy Mac Gregor
 Aneesh Azhakesan S
 Ankita Gupta
+anoymouserver
+Anton Lindqvist
 Antti Tuppurainen
 Anurag Garg
 Armin Müller
 Arpit Chaudhary
+Artemis Meursault Gerrard
 August Sodora
 Ayaz Salikhov
 Balázs Tóth
 Baris Demiray
+Bart vdr. Meulen
 Bartlomiej Grzeskowiak
 bbennetts
 Benjamin Bannier
@@ -44,141 +63,230 @@ Benjamin Kramer
 Benjamin Woester
 Benjamin Wolsey
 Ben T
+Bernd Buschinski
 Bill Egert
 Björge Dijkstra
-Bo Rydberg
+Björn Blissing
 booga
 Boris Barbulovski
 Boris Egorov
+Boussaffa Walid
+Bo Rydberg
+bzgec
+Carl Michael Grüner Monzón
+Carl Morgan
 Carlo Marcelo Arenas Belón
 Carlos Gomes Martinho
+Carl-Oskar Larsson
+Cary Converse
 Cary R
+Caspar Kielwein
 Changkyoon Kim
+Chris Lalancette
 Christian Ehrlicher
 Christian Franke
+Christian Göttsche
+Christoph Grüninger
 Christoph Schmidt
 Christoph Strehle
 Chuck Larson
+Cilyan Olowen
+Claus Jensby Madsen
 Colomban Wendling
 Conrado Gouvea
 daisuke-chiba
+Daniel Friedrich
+David Korczynski
 Daniel Marjamäki
 David Hallas
 David Korth
+Dávid Slivka
 Debrard Sebastien
 Deepak Gupta
+Degen's Regens
 dencat
 Diego de las Heras
 Dirk Jagdmann
+Dirk Mueller
 Dmitriy
 Dmitry Marakasov
 Dmitry-Me
+dsamo
 Duraffort
 Edoardo Prezioso
 Eivind Tagseth
 Elbert Pol
 Emmanuel Blot
+Eric Lemanissier
+Eric Malenfant
 Eric Sesterhenn
 Erik Hovland
 Erik Lax
 Ettl Martin
+Even Rouault
 Evgeny Mandrikov
+feelamee
 Felipe Pena
+Felix Faber
 Felix Geyer
+Felix Passenberg
+Felix Wolff
+Florian Mueller
 Florin Iucha
+flovent
+Francesc Elies
+François Berder
+Frank Winklmeier
 Frank Zingsheim
+Frederik Schwarzer
 fu7mu4
 Galimov Albert
 Garrett Bodily
 Gary Leutheuser
 gaurav kaushik
 Gennady Feldman
+Georgi D. Sotirov
 Georgy Komarov
+Gerbo Engels
 Gerhard Zlabinger
+Gerik Rhoden
 Gianfranco Costamagna
 Gianluca Scacco
 Gleydson Soares
+Goncalo Mao-Cheia
 Goran Džaferi
 Graham Whitted
 Greg Hewgill
+Guillaume A.
+Guillaume Chauvel
 Guillaume Miossec
 Gustav Palmqvist
 Günther Makulik
+Haowei Hsu
 Harald Scheidl
+Heiko Bauke
 Heiko Eißfeldt
 Heinrich Schuchardt
 Henrik Nilsson
 He Yuqi
 Hoang Tuan Su
+Igor Rondarev
 Igor Zhukov
+Ilya Shipitsin
 Ivan Maidanski
 Iván Matellanes
 Ivan Ryabov
+Ivar Bonsaksen
 Jakub Melka
+Jan Egil Ruud
 Jan Hellwig
 János Maros
 Jay Sigbrandt
+Jedrzej Klocek
 Jens Bäckman
+Jens Yllman
 Jérémy Lefaure
 Jes Ramsing
+Jesse Boswell
+Jim Kuhn
 Jim Zhou
+jlguardi
+Joel Johnson
+Johan Bertrand
+Johan Crone
 Johan Samuelson
+John Marshall
 John-Paul Ore
 John Smits
 Jonathan Clohessy
+Jonathan Haehne
 Jonathan Neuschäfer
 Jonathan Thackray
+José Martins
 Jose Roquette
 Joshua Beck
 Joshua Rogers
 Julian Santander
+Julien Marrec
+Julien Peyregne
 Jure Menart
 Jussi Lehtola
 Jørgen Kvalsvik
 Kamil Dudka
 Kartik Bajaj
+Kefu Chai
+keinflue
 Ken-Patrick Lehrmann
+Ketil Skjerve
 Kevin Christian
 Kevin Kendzia
 Kimmo Varis
+Kitsios Konstantinos
+Kleber Tarcísio
 Konrad Grochowski
 Konrad Windszus
-Kyle Chisholm
 Kumar Ashwani
+Kushal Chandar
+Kyle Chisholm
+Lars Even Almaas
 larudwer
 Lau bakman
 Lauri Nurmi
+Leander Schulten
 Leandro Lisboa Penz
+Leila F. Rahman
 Lena Herscheid
+Leon De Andrade
 Lieven de Cock
 lioncash
+Lionel Gimbert
 Lucas Manuel Rodriguez
+Ludvig Gunne Lindström
 Luis Díaz Más
+Luís Pereira
+Lukas Grützmacher
+Lukas Hiesmayr
+Lukasz Czajczyk
+Łukasz Jankowski
 Luxon Jean-Pierre
+Maarten van der Schrieck
+Maksim Derbasov
 Malcolm Parsons
 Marc-Antoine Perennou
 Marcel Raad
+Marco Trevisan
 Marek Zmysłowski
 Marian Klymov
 Mark de Wever
+Mark Hermeling
 Markus Elfring
+Martin Delille
 Martin Ettl
 Martin Exner
 Martin Güthle
 Martin Herren
 Márton Csordás
+Masafumi Koba
 Massimo Paladin
+Mateusz Michalak
+Mateusz Patyk
 Mateusz Pusz
 Mathias De Maré
+Mathias Schmid
 Matthias Krüger
+Matthias Kuhn
 Matthias Schmieder
-Mathias Schmid
 Matt Johnson
+Maurice Gilden
 Mavik
+Melroy van den Berg
+Michael Drake
+Michael Løiten
 Miika-Petteri Matikainen
 Mika Attila
 Mike Tzou
 Milhan Kim
+Mil Tolstoy
 Mischa Aster Alff
 Mohit Mate
 Monika Lukow
@@ -194,24 +302,40 @@ Nicolás Alvarez
 Nicolas Le Cam
 Nilesh Kumar
 Ogawa KenIchi
+Ola Söder
+Oleksandr Labetskyi
 Oleksandr Redko
 Oliver Schode
 Oliver Stöneberg
 Olivier Croquette
+Patrick Oppenlander
+Paul Aitken
+Paul Bersee
 Paul Fultz II
 Pavel Bibergal
 Pavel Pimenov
 Pavel Roschin
+Pavel Skipenes
+Pavel Šimovec
 Pavol Misik
 Pete Johns
 Peter Pentchev
+Peter Schops
+Philip Chimento
 Philipp Kloke
 Pierre Schweitzer
+Pieter Duchi
 Pino Toscano
 Pranav Khanna
+Radek Jarecki
+Rainer Wiesenfarth
 Ramzan Bekbulatov
 Raphael Geissert
+Razvan Ioan Alexe
 Reijo Tomperi
+Reshma V Kumar
+Rainer Wiesenfarth
+Riccardo Ghetta
 Richard A. Smith
 Richard Quirk
 Rick van der Sluijs
@@ -221,66 +345,102 @@ Robert Habrich
 Robert Morin
 Roberto Martelloni
 Robert Reif
+Robin Getz
 rofl0r
 Roman Zaytsev Borisovich
+Ronald Hiemstra
 root
 Rosen Penev
+Rudi Danner
 Rudolf Grauberger
+Ryan M. Lederman
 Ryan Pavlik
 Samir Aguiar
 Sam Truscott
 Samuel Degrande
+Samuel Poláček
 Sandeep Dutta
+Savvas Etairidis
+Scott Ehlert
 Scott Furry
+Seafarix Ltd.
 Sebastian Held
 Sebastian Matuschka
 Sébastien Debrard
+Sergei Chernykh
+Sergei Trofimovich
+Sergey Burgsdorf
+Shane Tapp
+Shohei YOSHIDA
+Simon Cornell
 Simon Kagstrom
+Simon Large
 Simon Martin
 Simon Shanks
 Slava Semushin
 Stas Cymbalov
 Stefan Beller
+Stefan Hagen
 Stefan Naewe
+Stefan van Kessel
 Stefan Weil
 Stéphane Michel
 Steve Browne
 Steve Duan
+Steve Mokris
 Steven Cook
 Steven Myint
+Sune Stolborg Vuorela
 Susi Lehtola
+Sven Wienand
 Swasti Shrivastava
 Sylvain Joubert
 Tam Do Thanh
 Teddy Didé
+Temuri Doghonadze
 Thomas Arnhold
+Tomasz Edward Posluszny
 Thomas Jarosch
 Thomas Niederberger
 Thomas Otto
+Thomas P. K. Healy
 Thomas Sondergaard
 Thorsten Sick
+Tim Blume
 Tim Gerundt
 tititiou36
+Tobias Weber
 Tobias Weibel
+Tomasz Kłoczko
 Tom Pollok
+Tomo Dote
+Tommy Bergman
 Toralf Förster
 Troshin V.S.
+Tyson Nottingham
+Usman Majid
+Valentin Batz
 Valerii Lashmanov
 Vasily Maslyukov
 Veli-Matti Visuri
-WenChung Chiu
 Vesa Pikki
 Ville-Pekka Vahteala
 Ville Skyttä
 Vincent Le Garrec
+Vladimir Petrigo
+Wang Haoyu
+Wang Yang
+WenChung Chiu
 Wolfgang Stöggl
 x29a
 XhmikosR
 Xuecheng Zhang
+Yichen Yan
 Yurii Putin
 Zachary Blair
 Zhao Qifa
 Zhiyuan Zhang
+Zhu Lei
 Дмитрий Старцев
 
 GUI graphics courtesy of Tango Desktop Project:
diff --git a/CMakeLists.txt b/CMakeLists.txt
index d3d279c706c..3c037a10b36 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,32 +1,119 @@
-project(Cppcheck)
-cmake_minimum_required(VERSION 2.8.11)
+cmake_minimum_required(VERSION 3.22)
+project(Cppcheck VERSION 2.20.99 LANGUAGES CXX)
+
+include(cmake/options.cmake)
+
+include(cmake/cxx11.cmake)
+use_cxx11()
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 include(GNUInstallDirs)
+include(CTest)
 
-include(cmake/versions.cmake REQUIRED)
-include(cmake/options.cmake REQUIRED)
-include(cmake/findDependencies.cmake REQUIRED)
-include(cmake/compileroptions.cmake REQUIRED)
-include(cmake/compilerDefinitions.cmake REQUIRED)
-include(cmake/buildFiles.cmake REQUIRED)
-include(cmake/cxx11.cmake REQUIRED)
+include(cmake/compilerCheck.cmake)
+include(cmake/versions.cmake)
+include(cmake/findDependencies.cmake)
+include(cmake/compileroptions.cmake)
+include(cmake/includechecks.cmake)
+include(cmake/compilerDefinitions.cmake)
+include(cmake/buildFiles.cmake)
+if(BUILD_GUI)
+    include(cmake/qtCompat.cmake)
+endif()
+include(cmake/printInfo.cmake)
 
-use_cxx11()
 
-file(GLOB addons "addons/*.py")
+file(GLOB addons_py "addons/*.py")
+file(GLOB addons_json "addons/*.json")
 file(GLOB cfgs "cfg/*.cfg")
 file(GLOB platforms "platforms/*.xml")
 
-if (BUILD_TESTS)
-    enable_testing()
+if(LIBXML2_XMLLINT_EXECUTABLE)
+    add_custom_target(validateCFG DEPENDS validateCFG-cmd)
+    add_custom_command(OUTPUT validateCFG-cmd
+            COMMAND ${LIBXML2_XMLLINT_EXECUTABLE} --noout ${CMAKE_SOURCE_DIR}/cfg/cppcheck-cfg.rng)
+    foreach(cfg ${cfgs})
+        add_custom_command(OUTPUT validateCFG-cmd APPEND
+                COMMAND ${LIBXML2_XMLLINT_EXECUTABLE} --noout --relaxng ${CMAKE_SOURCE_DIR}/cfg/cppcheck-cfg.rng ${cfg})
+    endforeach()
+    # this is a symbolic name for a build rule and not an output file
+    set_source_files_properties(validateCFG-cmd PROPERTIES SYMBOLIC "true")
+
+    add_custom_target(validatePlatforms ${LIBXML2_XMLLINT_EXECUTABLE} --noout ${CMAKE_SOURCE_DIR}/platforms/cppcheck-platforms.rng)
+    foreach(platform ${platforms})
+        get_filename_component(platformname ${platform} NAME_WE)
+        add_custom_target(validatePlatforms-${platformname} ${LIBXML2_XMLLINT_EXECUTABLE} --noout --relaxng ${CMAKE_SOURCE_DIR}/platforms/cppcheck-platforms.rng ${platform})
+        add_dependencies(validatePlatforms validatePlatforms-${platformname})
+    endforeach()
+
+    if(TARGET cppcheck)
+        add_custom_target(errorlist-xml $<TARGET_FILE:cppcheck> --errorlist > ${CMAKE_BINARY_DIR}/errorlist.xml
+                DEPENDS cppcheck)
+
+        add_custom_target(example-xml $<TARGET_FILE:cppcheck> --xml --enable=all --inconclusive --max-configs=1 ${CMAKE_SOURCE_DIR}/samples 2> ${CMAKE_BINARY_DIR}/example.xml
+                DEPENDS cppcheck)
+    endif()
+
+    add_custom_target(createXMLExamples DEPENDS errorlist-xml example-xml)
+
+    if(Python_EXECUTABLE)
+        add_custom_target(checkCWEEntries ${Python_EXECUTABLE} ${CMAKE_SOURCE_DIR}/tools/listErrorsWithoutCWE.py -F ${CMAKE_BINARY_DIR}/errorlist.xml
+                DEPENDS errorlist-xml)
+    endif()
+
+    add_custom_target(validateXML ${LIBXML2_XMLLINT_EXECUTABLE} --noout ${CMAKE_SOURCE_DIR}/cppcheck-errors.rng
+            COMMAND ${LIBXML2_XMLLINT_EXECUTABLE} --noout --relaxng ${CMAKE_SOURCE_DIR}/cppcheck-errors.rng ${CMAKE_BINARY_DIR}/errorlist.xml
+            COMMAND ${LIBXML2_XMLLINT_EXECUTABLE} --noout --relaxng ${CMAKE_SOURCE_DIR}/cppcheck-errors.rng ${CMAKE_BINARY_DIR}/example.xml
+            DEPENDS createXMLExamples
+            )
+
+    add_custom_target(validateRules ${LIBXML2_XMLLINT_EXECUTABLE} --noout ${CMAKE_SOURCE_DIR}/rules/*.xml)
 endif()
 
-add_subdirectory(externals/tinyxml)
+# TODO: add the following Makefile features:
+# - "man/cppcheck.1" target
+# - "tags" target
+# - Cygwin handling
+# - MinGW handling
+
+add_custom_target(copy_cfg ALL
+    ${CMAKE_COMMAND} -E copy_directory "${PROJECT_SOURCE_DIR}/cfg"
+        "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}/cfg"
+    COMMENT "Copying cfg files to ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}")
+
+# TODO: copy *.py and *.json only
+add_custom_target(copy_addons ALL
+    ${CMAKE_COMMAND} -E copy_directory "${PROJECT_SOURCE_DIR}/addons"
+        "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}/addons"
+    COMMENT "Copying addons files to ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}")
+
+add_custom_target(remove_unsigned_platforms ALL
+        ${CMAKE_COMMAND} -E remove -f
+        "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}/platforms/unix32-unsigned.xml"
+        "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}/platforms/unix64-unsigned.xml"
+        COMMENT "Removing unsigned platforms files from ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}")
+
+add_custom_target(copy_platforms ALL
+    ${CMAKE_COMMAND} -E copy_directory "${PROJECT_SOURCE_DIR}/platforms"
+    "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}/platforms"
+    DEPENDS remove_unsigned_platforms
+    COMMENT "Copying platforms files to ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}")
+
+if(USE_BUNDLED_TINYXML2)
+    message(STATUS "Using bundled version of tinyxml2")
+    add_subdirectory(externals/tinyxml2)
+endif()
 add_subdirectory(externals/simplecpp)
-add_subdirectory(lib)   # CppCheck Library 
+add_subdirectory(externals/picojson)
+add_subdirectory(lib)   # CppCheck Library
+add_subdirectory(frontend)
 add_subdirectory(cli)   # Client application
 add_subdirectory(test)  # Tests
-ADD_SUBDIRECTORY(gui)   # Graphical application
-ADD_SUBDIRECTORY(tools/triage)   # Triage tool
+add_subdirectory(gui)   # Graphical application
+add_subdirectory(tools)
+add_subdirectory(man)
 
-include(cmake/printInfo.cmake REQUIRED)
+include(cmake/clang_tidy.cmake)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 00000000000..715a913b6fc
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,67 @@
+# Contributing To Cppcheck
+
+These are some guidelines *any* contributor should follow. They will help to make for better contributions which will most likely allow for them to be processed.
+
+(TODO: move daca@home section here?)
+
+## Code Changes
+
+Code contributions are handled via GitHub pull requests: https://github.com/danmar/cppcheck/pulls.
+
+If you file a pull request you might not get a reply immediately. We are a very small team and it might not fit in the current scope or time.
+
+Any kind of contribution is welcome but we might reject it. In that case we usually provide an explanation for the reasons but everything is always open to discussion.
+
+Changes in the `externals` folder need to be submitted to the respective upstream projects and will be pulled downstream with their next stable release (`picojson` is an exception because it is no longer maintained - the handling of such changes is not yet determined - see also https://trac.cppcheck.net/ticket/12233).
+
+Also after you filed a pull request please be ready to reply to questions and feedback. If you just "dump and leave" it might lower the chances of your change being accepted. This also applies after the PR was successfully merged as it might cause issues which were not exposed by the CI.
+
+Please do not be discouraged if your change was rejected or if the review process might not have been as smooth as it could have been.
+
+Each change should be accompanied with a unit ([C++](https://github.com/danmar/cppcheck/tree/main/test)) or integration ([Python](https://github.com/danmar/cppcheck/tree/main/test/cli)) test to ensure that it doesn't regress with future changes. Negative tests (testing the opposite behavior) would be favorable but might not be required or might already exist depending on the change. Tests which introduce `TODO_ASSERT_` or `@pytest.mark.skip`/`@pytest.mark.xfail` should have tickets filed.
+
+If the change is modifying existing behavior (i.e. adding a feature or fixing a bug) it should be accompanied by an issue in the [tracker](https://trac.cppcheck.net) (if you do not have access we can assist with that). Depending on the change it might also warrant an entry in `releasenotes.txt`.
+
+The CI is already doing a lot of work but there are certain parts it cannot ensure.
+
+(TODO: mention test_pr.py)
+
+The CI has an "always green" approach which means that failing tests are not allowed. Flakey tests might be acceptable depending on the frequency of their failures but they should be accompanied by ticket so they are being tracked. If introduce a test which is expected to fail you should use the `TODO_*` macros (C++) or `@pytest.mark.xfail(strict=False)` annotations.
+
+Note: Usually you can run the CI on your own fork to verify that it passes before even open an PR. Unfortunately some changes to avoid duplicated builds in our CI disabled this (TODO: file a ticket about this).
+
+### Targets
+
+Cppcheck is tracking its issues at https://trac.cppcheck.net.
+
+The tickets are not really prioritized (except for non-synthetic crashing issues) but of most interest are the following types of tickets.
+
+[False Positives](https://trac.cppcheck.net/query?status=accepted&status=assigned&status=new&status=reopened&component=False+positive&col=id&col=summary&col=status&col=component&col=type&col=priority&col=milestone&order=priority)
+
+Since Cppcheck aims to be low on false positives, these kind of issues are obviously of the highest priority.
+
+[Detection Regressions](https://trac.cppcheck.net/query?status=accepted&status=assigned&status=new&status=reopened&keywords=~regression&component=Improve+check&col=id&col=summary&col=status&col=type&col=priority&col=milestone&col=component&order=priority)
+
+Changes might lead to fewer findings being reported. In very few cases this might be intentional but we should not regress in what findings are being reported. 
+
+[Other Defects](https://trac.cppcheck.net/query?status=accepted&status=assigned&status=new&status=reopened&type=defect&component=!False+positive&col=id&col=summary&col=type&col=status&col=component&col=priority&col=milestone&order=priority)
+
+Note: If you start working on ticket, please assign yourself or request to be.
+
+## Source TODOs
+
+There are also various source-level TODOs. These might be related to already tracked issues (even if not explicitly noted) but may also be just exist exploratively, have even been added overzealously or might even be outdated.
+
+So if you start spending a lot of time on these, you might want to get into touch before proceeding further. 
+
+## simplecpp
+
+At its core Cppcheck is relying on the `simplecpp` library which is a preprocessor implementation which was spun off into its [separate project](https://github.com/danmar/simplecpp) with its own [bug tracker](https://github.com/danmar/simplecpp/issues). This is also maintained by the Cppcheck developers and contributions to it are also welcome.
+
+## Translations
+
+We are also maintaining various translations for `cppcheck-gui`.
+
+Several of these are not complete or might be out-of-date so contributions are welcome. We will also accept additional languages but such contributions should be complete.
+
+(TODO: provide more details)
diff --git a/Cppcheck.xcodeproj/project.pbxproj b/Cppcheck.xcodeproj/project.pbxproj
deleted file mode 100644
index 3152bcbcc3d..00000000000
--- a/Cppcheck.xcodeproj/project.pbxproj
+++ /dev/null
@@ -1,960 +0,0 @@
-// !$*UTF8*$!
-{
-	archiveVersion = 1;
-	classes = {
-	};
-	objectVersion = 46;
-	objects = {
-
-/* Begin PBXBuildFile section */
-		2D190F271C03A7A600C18478 /* astutils.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2D190F251C03A7A600C18478 /* astutils.cpp */; };
-		39E60EB91270DE3A00AC0D02 /* checkautovariables.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60E8D1270DE3A00AC0D02 /* checkautovariables.cpp */; };
-		39E60EBA1270DE3A00AC0D02 /* checkbufferoverrun.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60E8F1270DE3A00AC0D02 /* checkbufferoverrun.cpp */; };
-		39E60EBB1270DE3A00AC0D02 /* checkclass.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60E911270DE3A00AC0D02 /* checkclass.cpp */; };
-		39E60EBC1270DE3A00AC0D02 /* checkexceptionsafety.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60E931270DE3A00AC0D02 /* checkexceptionsafety.cpp */; };
-		39E60EBD1270DE3A00AC0D02 /* checkmemoryleak.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60E951270DE3A00AC0D02 /* checkmemoryleak.cpp */; };
-		39E60EBF1270DE3A00AC0D02 /* checkother.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60E991270DE3A00AC0D02 /* checkother.cpp */; };
-		39E60EC01270DE3A00AC0D02 /* checkpostfixoperator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60E9B1270DE3A00AC0D02 /* checkpostfixoperator.cpp */; };
-		39E60EC11270DE3A00AC0D02 /* checkstl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60E9D1270DE3A00AC0D02 /* checkstl.cpp */; };
-		39E60EC21270DE3A00AC0D02 /* checkunusedfunctions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60E9F1270DE3A00AC0D02 /* checkunusedfunctions.cpp */; };
-		39E60EC31270DE3A00AC0D02 /* cppcheck.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60EA11270DE3A00AC0D02 /* cppcheck.cpp */; };
-		39E60EC41270DE3A00AC0D02 /* errorlogger.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60EA31270DE3A00AC0D02 /* errorlogger.cpp */; };
-		39E60EC81270DE3A00AC0D02 /* mathlib.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60EAB1270DE3A00AC0D02 /* mathlib.cpp */; };
-		39E60EC91270DE3A00AC0D02 /* path.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60EAD1270DE3A00AC0D02 /* path.cpp */; };
-		39E60ECA1270DE3A00AC0D02 /* preprocessor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60EAF1270DE3A00AC0D02 /* preprocessor.cpp */; };
-		39E60ECB1270DE3A00AC0D02 /* settings.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60EB11270DE3A00AC0D02 /* settings.cpp */; };
-		39E60ECC1270DE3A00AC0D02 /* timer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60EB31270DE3A00AC0D02 /* timer.cpp */; };
-		39E60ECD1270DE3A00AC0D02 /* token.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60EB51270DE3A00AC0D02 /* token.cpp */; };
-		39E60ECE1270DE3A00AC0D02 /* tokenize.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60EB71270DE3A00AC0D02 /* tokenize.cpp */; };
-		39E60ED61270DE5000AC0D02 /* cmdlineparser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60ECF1270DE5000AC0D02 /* cmdlineparser.cpp */; };
-		39E60ED71270DE5000AC0D02 /* cppcheckexecutor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60ED11270DE5000AC0D02 /* cppcheckexecutor.cpp */; };
-		39E60ED81270DE5000AC0D02 /* main.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60ED31270DE5000AC0D02 /* main.cpp */; };
-		39E60ED91270DE5000AC0D02 /* threadexecutor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60ED41270DE5000AC0D02 /* threadexecutor.cpp */; };
-		F4043DB1177F08A800CD5A40 /* filelister.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DAD177F08A800CD5A40 /* filelister.cpp */; };
-		F4043DB2177F08A800CD5A40 /* pathmatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DAF177F08A800CD5A40 /* pathmatch.cpp */; };
-		F4043DD7177F093300CD5A40 /* check64bit.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DB3177F093300CD5A40 /* check64bit.cpp */; };
-		F4043DD8177F093300CD5A40 /* checkassert.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DB5177F093300CD5A40 /* checkassert.cpp */; };
-		F4043DDA177F093300CD5A40 /* checkbool.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DB9177F093300CD5A40 /* checkbool.cpp */; };
-		F4043DDB177F093300CD5A40 /* checkboost.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DBB177F093300CD5A40 /* checkboost.cpp */; };
-		F4043DDC177F093300CD5A40 /* checkinternal.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DBD177F093300CD5A40 /* checkinternal.cpp */; };
-		F4043DDD177F093300CD5A40 /* checkio.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DBF177F093300CD5A40 /* checkio.cpp */; };
-		F4043DDE177F093300CD5A40 /* checkleakautovar.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DC1177F093300CD5A40 /* checkleakautovar.cpp */; };
-		F4043DE0177F093300CD5A40 /* checknullpointer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DC5177F093300CD5A40 /* checknullpointer.cpp */; };
-		F4043DE1177F093300CD5A40 /* checksizeof.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DC7177F093300CD5A40 /* checksizeof.cpp */; };
-		F4043DE2177F093300CD5A40 /* checkuninitvar.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DC9177F093300CD5A40 /* checkuninitvar.cpp */; };
-		F4043DE3177F093300CD5A40 /* checkunusedvar.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DCB177F093300CD5A40 /* checkunusedvar.cpp */; };
-		F4043DE4177F093300CD5A40 /* suppressions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DCE177F093300CD5A40 /* suppressions.cpp */; };
-		F4043DE5177F093300CD5A40 /* symboldatabase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DD0177F093300CD5A40 /* symboldatabase.cpp */; };
-		F4043DE6177F093300CD5A40 /* templatesimplifier.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DD2177F093300CD5A40 /* templatesimplifier.cpp */; };
-		F4043DE7177F093300CD5A40 /* tokenlist.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DD4177F093300CD5A40 /* tokenlist.cpp */; };
-		F47E508317896AEB00C684DC /* tinyxml2.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F47E508117896AEB00C684DC /* tinyxml2.cpp */; };
-		F497C28C1AB41D5C003B96CF /* check.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F497C2831AB41D5C003B96CF /* check.cpp */; };
-		F497C28D1AB41D5C003B96CF /* checkcondition.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F497C2841AB41D5C003B96CF /* checkcondition.cpp */; };
-		F497C28E1AB41D5C003B96CF /* checkstring.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F497C2861AB41D5C003B96CF /* checkstring.cpp */; };
-		F497C28F1AB41D5C003B96CF /* checktype.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F497C2881AB41D5C003B96CF /* checktype.cpp */; };
-		F497C2901AB41D5C003B96CF /* checkvaarg.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F497C2891AB41D5C003B96CF /* checkvaarg.cpp */; };
-		F4C348661825679E00521683 /* cmdlineparser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60ECF1270DE5000AC0D02 /* cmdlineparser.cpp */; };
-		F4C348671825679F00521683 /* cppcheckexecutor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60ED11270DE5000AC0D02 /* cppcheckexecutor.cpp */; };
-		F4C348681825679F00521683 /* filelister.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DAD177F08A800CD5A40 /* filelister.cpp */; };
-		F4C348691825679F00521683 /* pathmatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DAF177F08A800CD5A40 /* pathmatch.cpp */; };
-		F4C3486A1825679F00521683 /* threadexecutor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60ED41270DE5000AC0D02 /* threadexecutor.cpp */; };
-		F4C3486C1825692B00521683 /* options.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD8717AB8511006C06AF /* options.cpp */; };
-		F4C3486D1825692B00521683 /* test64bit.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD8917AB8511006C06AF /* test64bit.cpp */; };
-		F4C3486E1825692B00521683 /* testassert.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD8A17AB8511006C06AF /* testassert.cpp */; };
-		F4C3486F1825692B00521683 /* testassignif.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD8B17AB8511006C06AF /* testassignif.cpp */; };
-		F4C348701825692B00521683 /* testautovariables.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD8C17AB8511006C06AF /* testautovariables.cpp */; };
-		F4C348711825692B00521683 /* testbool.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD8D17AB8511006C06AF /* testbool.cpp */; };
-		F4C348721825692B00521683 /* testboost.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD8E17AB8511006C06AF /* testboost.cpp */; };
-		F4C348731825692B00521683 /* testbufferoverrun.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD8F17AB8511006C06AF /* testbufferoverrun.cpp */; };
-		F4C348741825692B00521683 /* testcharvar.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD9017AB8511006C06AF /* testcharvar.cpp */; };
-		F4C348751825692B00521683 /* testclass.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD9117AB8511006C06AF /* testclass.cpp */; };
-		F4C348761825692B00521683 /* testcmdlineparser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD9217AB8511006C06AF /* testcmdlineparser.cpp */; };
-		F4C348771825692B00521683 /* testconstructors.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD9317AB8511006C06AF /* testconstructors.cpp */; };
-		F4C348781825692B00521683 /* testcppcheck.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD9417AB8511006C06AF /* testcppcheck.cpp */; };
-		F4C348791825692B00521683 /* testdivision.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD9517AB8511006C06AF /* testdivision.cpp */; };
-		F4C3487A1825692B00521683 /* testerrorlogger.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD9617AB8511006C06AF /* testerrorlogger.cpp */; };
-		F4C3487B1825692B00521683 /* testexceptionsafety.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD9717AB8511006C06AF /* testexceptionsafety.cpp */; };
-		F4C3487C1825692B00521683 /* testfilelister.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD9817AB8511006C06AF /* testfilelister.cpp */; };
-		F4C3487D1825692B00521683 /* testincompletestatement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD9917AB8511006C06AF /* testincompletestatement.cpp */; };
-		F4C3487E1825692B00521683 /* testinternal.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD9A17AB8511006C06AF /* testinternal.cpp */; };
-		F4C3487F1825692B00521683 /* testio.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD9B17AB8511006C06AF /* testio.cpp */; };
-		F4C348801825692B00521683 /* testleakautovar.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD9C17AB8511006C06AF /* testleakautovar.cpp */; };
-		F4C348811825692B00521683 /* testmathlib.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD9D17AB8511006C06AF /* testmathlib.cpp */; };
-		F4C348821825692B00521683 /* testmemleak.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD9E17AB8511006C06AF /* testmemleak.cpp */; };
-		F4C348831825692B00521683 /* testnonreentrantfunctions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDD9F17AB8511006C06AF /* testnonreentrantfunctions.cpp */; };
-		F4C348841825692B00521683 /* testnullpointer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDA017AB8511006C06AF /* testnullpointer.cpp */; };
-		F4C348851825692B00521683 /* testobsolescentfunctions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDA117AB8511006C06AF /* testobsolescentfunctions.cpp */; };
-		F4C348861825692B00521683 /* testoptions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDA217AB8511006C06AF /* testoptions.cpp */; };
-		F4C348871825692B00521683 /* testother.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDA317AB8511006C06AF /* testother.cpp */; };
-		F4C348881825692B00521683 /* testpath.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDA417AB8511006C06AF /* testpath.cpp */; };
-		F4C348891825692B00521683 /* testpathmatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDA517AB8511006C06AF /* testpathmatch.cpp */; };
-		F4C3488A1825692B00521683 /* testpostfixoperator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDA617AB8511006C06AF /* testpostfixoperator.cpp */; };
-		F4C3488B1825692B00521683 /* testpreprocessor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDA717AB8511006C06AF /* testpreprocessor.cpp */; };
-		F4C3488C1825692B00521683 /* testrunner.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDA817AB8511006C06AF /* testrunner.cpp */; };
-		F4C3488D1825692B00521683 /* testsimplifytokens.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDA917AB8511006C06AF /* testsimplifytokens.cpp */; };
-		F4C3488E1825692B00521683 /* testsizeof.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDAA17AB8511006C06AF /* testsizeof.cpp */; };
-		F4C3488F1825692B00521683 /* teststl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDAB17AB8511006C06AF /* teststl.cpp */; };
-		F4C348901825692B00521683 /* testsuite.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDAC17AB8511006C06AF /* testsuite.cpp */; };
-		F4C348911825692B00521683 /* testsuppressions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDAD17AB8511006C06AF /* testsuppressions.cpp */; };
-		F4C348921825692B00521683 /* testsymboldatabase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDAE17AB8511006C06AF /* testsymboldatabase.cpp */; };
-		F4C348931825692B00521683 /* testthreadexecutor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDAF17AB8511006C06AF /* testthreadexecutor.cpp */; };
-		F4C348941825692B00521683 /* testtimer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDB017AB8511006C06AF /* testtimer.cpp */; };
-		F4C348951825692B00521683 /* testtoken.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDB117AB8511006C06AF /* testtoken.cpp */; };
-		F4C348961825692B00521683 /* testtokenize.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDB217AB8511006C06AF /* testtokenize.cpp */; };
-		F4C348971825692B00521683 /* testuninitvar.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDB317AB8511006C06AF /* testuninitvar.cpp */; };
-		F4C348981825692B00521683 /* testunusedfunctions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDB417AB8511006C06AF /* testunusedfunctions.cpp */; };
-		F4C348991825692B00521683 /* testunusedprivfunc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDB517AB8511006C06AF /* testunusedprivfunc.cpp */; };
-		F4C3489A1825692B00521683 /* testunusedvar.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F45BDDB617AB8511006C06AF /* testunusedvar.cpp */; };
-		F4C3489B18256A4500521683 /* check64bit.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DB3177F093300CD5A40 /* check64bit.cpp */; };
-		F4C3489C18256A4500521683 /* checkassert.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DB5177F093300CD5A40 /* checkassert.cpp */; };
-		F4C3489E18256A4500521683 /* checkautovariables.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60E8D1270DE3A00AC0D02 /* checkautovariables.cpp */; };
-		F4C3489F18256A4500521683 /* checkbool.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DB9177F093300CD5A40 /* checkbool.cpp */; };
-		F4C348A018256A4500521683 /* checkboost.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DBB177F093300CD5A40 /* checkboost.cpp */; };
-		F4C348A118256A4500521683 /* checkbufferoverrun.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60E8F1270DE3A00AC0D02 /* checkbufferoverrun.cpp */; };
-		F4C348A218256A4500521683 /* checkclass.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60E911270DE3A00AC0D02 /* checkclass.cpp */; };
-		F4C348A318256A4500521683 /* checkexceptionsafety.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60E931270DE3A00AC0D02 /* checkexceptionsafety.cpp */; };
-		F4C348A418256A4500521683 /* checkinternal.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DBD177F093300CD5A40 /* checkinternal.cpp */; };
-		F4C348A518256A4500521683 /* checkio.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DBF177F093300CD5A40 /* checkio.cpp */; };
-		F4C348A618256A4500521683 /* checkleakautovar.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DC1177F093300CD5A40 /* checkleakautovar.cpp */; };
-		F4C348A718256A4500521683 /* checkmemoryleak.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60E951270DE3A00AC0D02 /* checkmemoryleak.cpp */; };
-		F4C348A918256A4500521683 /* checknullpointer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DC5177F093300CD5A40 /* checknullpointer.cpp */; };
-		F4C348AB18256A4500521683 /* checkother.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60E991270DE3A00AC0D02 /* checkother.cpp */; };
-		F4C348AC18256A4500521683 /* checkpostfixoperator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60E9B1270DE3A00AC0D02 /* checkpostfixoperator.cpp */; };
-		F4C348AD18256A4500521683 /* checksizeof.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DC7177F093300CD5A40 /* checksizeof.cpp */; };
-		F4C348AE18256A4500521683 /* checkstl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60E9D1270DE3A00AC0D02 /* checkstl.cpp */; };
-		F4C348AF18256A4500521683 /* checkuninitvar.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DC9177F093300CD5A40 /* checkuninitvar.cpp */; };
-		F4C348B018256A4500521683 /* checkunusedfunctions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60E9F1270DE3A00AC0D02 /* checkunusedfunctions.cpp */; };
-		F4C348B118256A4500521683 /* checkunusedvar.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DCB177F093300CD5A40 /* checkunusedvar.cpp */; };
-		F4C348B218256A4500521683 /* errorlogger.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60EA31270DE3A00AC0D02 /* errorlogger.cpp */; };
-		F4C348B418256A4500521683 /* mathlib.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60EAB1270DE3A00AC0D02 /* mathlib.cpp */; };
-		F4C348B518256A4500521683 /* path.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60EAD1270DE3A00AC0D02 /* path.cpp */; };
-		F4C348B618256A4500521683 /* preprocessor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60EAF1270DE3A00AC0D02 /* preprocessor.cpp */; };
-		F4C348B718256A4500521683 /* settings.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60EB11270DE3A00AC0D02 /* settings.cpp */; };
-		F4C348B818256A4500521683 /* suppressions.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DCE177F093300CD5A40 /* suppressions.cpp */; };
-		F4C348B918256A4500521683 /* symboldatabase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DD0177F093300CD5A40 /* symboldatabase.cpp */; };
-		F4C348BA18256A4500521683 /* templatesimplifier.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DD2177F093300CD5A40 /* templatesimplifier.cpp */; };
-		F4C348BB18256A4500521683 /* timer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60EB31270DE3A00AC0D02 /* timer.cpp */; };
-		F4C348BC18256A4500521683 /* token.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60EB51270DE3A00AC0D02 /* token.cpp */; };
-		F4C348BD18256A4500521683 /* tokenize.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60EB71270DE3A00AC0D02 /* tokenize.cpp */; };
-		F4C348BE18256A4500521683 /* tokenlist.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4043DD4177F093300CD5A40 /* tokenlist.cpp */; };
-		F4C348BF18256A8700521683 /* tinyxml2.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F47E508117896AEB00C684DC /* tinyxml2.cpp */; };
-		F4C348C018256A8700521683 /* library.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4CF847C17B6504100522F24 /* library.cpp */; };
-		F4C348C118256A9900521683 /* cppcheck.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 39E60EA11270DE3A00AC0D02 /* cppcheck.cpp */; };
-		F4CDD6981880888F006CF685 /* valueflow.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4CDD6961880888F006CF685 /* valueflow.cpp */; };
-		F4CDD69918808927006CF685 /* valueflow.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4CDD6961880888F006CF685 /* valueflow.cpp */; };
-		F4CF847D17B6504100522F24 /* library.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F4CF847C17B6504100522F24 /* library.cpp */; };
-/* End PBXBuildFile section */
-
-/* Begin PBXCopyFilesBuildPhase section */
-		8DD76F690486A84900D96B5E /* CopyFiles */ = {
-			isa = PBXCopyFilesBuildPhase;
-			buildActionMask = 8;
-			dstPath = /usr/share/man/man1/;
-			dstSubfolderSpec = 0;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 1;
-		};
-		F4C3485E182566E800521683 /* CopyFiles */ = {
-			isa = PBXCopyFilesBuildPhase;
-			buildActionMask = 2147483647;
-			dstPath = /usr/share/man/man1/;
-			dstSubfolderSpec = 0;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 1;
-		};
-/* End PBXCopyFilesBuildPhase section */
-
-/* Begin PBXFileReference section */
-		2D190F241C03A67A00C18478 /* utils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = utils.h; path = lib/utils.h; sourceTree = "<group>"; };
-		2D190F251C03A7A600C18478 /* astutils.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = astutils.cpp; path = lib/astutils.cpp; sourceTree = "<group>"; };
-		2D190F261C03A7A600C18478 /* astutils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = astutils.h; path = lib/astutils.h; sourceTree = "<group>"; };
-		39E60E8C1270DE3A00AC0D02 /* check.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = check.h; path = lib/check.h; sourceTree = "<group>"; };
-		39E60E8D1270DE3A00AC0D02 /* checkautovariables.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checkautovariables.cpp; path = lib/checkautovariables.cpp; sourceTree = "<group>"; };
-		39E60E8E1270DE3A00AC0D02 /* checkautovariables.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checkautovariables.h; path = lib/checkautovariables.h; sourceTree = "<group>"; };
-		39E60E8F1270DE3A00AC0D02 /* checkbufferoverrun.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checkbufferoverrun.cpp; path = lib/checkbufferoverrun.cpp; sourceTree = "<group>"; };
-		39E60E901270DE3A00AC0D02 /* checkbufferoverrun.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checkbufferoverrun.h; path = lib/checkbufferoverrun.h; sourceTree = "<group>"; };
-		39E60E911270DE3A00AC0D02 /* checkclass.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checkclass.cpp; path = lib/checkclass.cpp; sourceTree = "<group>"; };
-		39E60E921270DE3A00AC0D02 /* checkclass.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checkclass.h; path = lib/checkclass.h; sourceTree = "<group>"; };
-		39E60E931270DE3A00AC0D02 /* checkexceptionsafety.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checkexceptionsafety.cpp; path = lib/checkexceptionsafety.cpp; sourceTree = "<group>"; };
-		39E60E941270DE3A00AC0D02 /* checkexceptionsafety.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checkexceptionsafety.h; path = lib/checkexceptionsafety.h; sourceTree = "<group>"; };
-		39E60E951270DE3A00AC0D02 /* checkmemoryleak.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checkmemoryleak.cpp; path = lib/checkmemoryleak.cpp; sourceTree = "<group>"; };
-		39E60E961270DE3A00AC0D02 /* checkmemoryleak.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checkmemoryleak.h; path = lib/checkmemoryleak.h; sourceTree = "<group>"; };
-		39E60E991270DE3A00AC0D02 /* checkother.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checkother.cpp; path = lib/checkother.cpp; sourceTree = "<group>"; };
-		39E60E9A1270DE3A00AC0D02 /* checkother.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checkother.h; path = lib/checkother.h; sourceTree = "<group>"; };
-		39E60E9B1270DE3A00AC0D02 /* checkpostfixoperator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checkpostfixoperator.cpp; path = lib/checkpostfixoperator.cpp; sourceTree = "<group>"; };
-		39E60E9C1270DE3A00AC0D02 /* checkpostfixoperator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checkpostfixoperator.h; path = lib/checkpostfixoperator.h; sourceTree = "<group>"; };
-		39E60E9D1270DE3A00AC0D02 /* checkstl.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checkstl.cpp; path = lib/checkstl.cpp; sourceTree = "<group>"; };
-		39E60E9E1270DE3A00AC0D02 /* checkstl.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checkstl.h; path = lib/checkstl.h; sourceTree = "<group>"; };
-		39E60E9F1270DE3A00AC0D02 /* checkunusedfunctions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checkunusedfunctions.cpp; path = lib/checkunusedfunctions.cpp; sourceTree = "<group>"; };
-		39E60EA01270DE3A00AC0D02 /* checkunusedfunctions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checkunusedfunctions.h; path = lib/checkunusedfunctions.h; sourceTree = "<group>"; };
-		39E60EA11270DE3A00AC0D02 /* cppcheck.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = cppcheck.cpp; path = lib/cppcheck.cpp; sourceTree = "<group>"; };
-		39E60EA21270DE3A00AC0D02 /* cppcheck.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = cppcheck.h; path = lib/cppcheck.h; sourceTree = "<group>"; };
-		39E60EA31270DE3A00AC0D02 /* errorlogger.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = errorlogger.cpp; path = lib/errorlogger.cpp; sourceTree = "<group>"; };
-		39E60EA41270DE3A00AC0D02 /* errorlogger.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = errorlogger.h; path = lib/errorlogger.h; sourceTree = "<group>"; };
-		39E60EAB1270DE3A00AC0D02 /* mathlib.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = mathlib.cpp; path = lib/mathlib.cpp; sourceTree = "<group>"; };
-		39E60EAC1270DE3A00AC0D02 /* mathlib.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = mathlib.h; path = lib/mathlib.h; sourceTree = "<group>"; };
-		39E60EAD1270DE3A00AC0D02 /* path.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = path.cpp; path = lib/path.cpp; sourceTree = "<group>"; };
-		39E60EAE1270DE3A00AC0D02 /* path.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = path.h; path = lib/path.h; sourceTree = "<group>"; };
-		39E60EAF1270DE3A00AC0D02 /* preprocessor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = preprocessor.cpp; path = lib/preprocessor.cpp; sourceTree = "<group>"; };
-		39E60EB01270DE3A00AC0D02 /* preprocessor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = preprocessor.h; path = lib/preprocessor.h; sourceTree = "<group>"; };
-		39E60EB11270DE3A00AC0D02 /* settings.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = settings.cpp; path = lib/settings.cpp; sourceTree = "<group>"; };
-		39E60EB21270DE3A00AC0D02 /* settings.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = settings.h; path = lib/settings.h; sourceTree = "<group>"; };
-		39E60EB31270DE3A00AC0D02 /* timer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = timer.cpp; path = lib/timer.cpp; sourceTree = "<group>"; };
-		39E60EB41270DE3A00AC0D02 /* timer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = timer.h; path = lib/timer.h; sourceTree = "<group>"; };
-		39E60EB51270DE3A00AC0D02 /* token.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = token.cpp; path = lib/token.cpp; sourceTree = "<group>"; };
-		39E60EB61270DE3A00AC0D02 /* token.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = token.h; path = lib/token.h; sourceTree = "<group>"; };
-		39E60EB71270DE3A00AC0D02 /* tokenize.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = tokenize.cpp; path = lib/tokenize.cpp; sourceTree = "<group>"; };
-		39E60EB81270DE3A00AC0D02 /* tokenize.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = tokenize.h; path = lib/tokenize.h; sourceTree = "<group>"; };
-		39E60ECF1270DE5000AC0D02 /* cmdlineparser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = cmdlineparser.cpp; path = cli/cmdlineparser.cpp; sourceTree = "<group>"; };
-		39E60ED01270DE5000AC0D02 /* cmdlineparser.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = cmdlineparser.h; path = cli/cmdlineparser.h; sourceTree = "<group>"; };
-		39E60ED11270DE5000AC0D02 /* cppcheckexecutor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = cppcheckexecutor.cpp; path = cli/cppcheckexecutor.cpp; sourceTree = "<group>"; };
-		39E60ED21270DE5000AC0D02 /* cppcheckexecutor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = cppcheckexecutor.h; path = cli/cppcheckexecutor.h; sourceTree = "<group>"; };
-		39E60ED31270DE5000AC0D02 /* main.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = main.cpp; path = cli/main.cpp; sourceTree = "<group>"; };
-		39E60ED41270DE5000AC0D02 /* threadexecutor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = threadexecutor.cpp; path = cli/threadexecutor.cpp; sourceTree = "<group>"; };
-		39E60ED51270DE5000AC0D02 /* threadexecutor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = threadexecutor.h; path = cli/threadexecutor.h; sourceTree = "<group>"; };
-		39E60EDE1270DEB100AC0D02 /* cppcheck */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = cppcheck; sourceTree = BUILT_PRODUCTS_DIR; };
-		F4043DAD177F08A800CD5A40 /* filelister.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = filelister.cpp; path = cli/filelister.cpp; sourceTree = "<group>"; };
-		F4043DAE177F08A800CD5A40 /* filelister.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = filelister.h; path = cli/filelister.h; sourceTree = "<group>"; };
-		F4043DAF177F08A800CD5A40 /* pathmatch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = pathmatch.cpp; path = cli/pathmatch.cpp; sourceTree = "<group>"; };
-		F4043DB0177F08A800CD5A40 /* pathmatch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = pathmatch.h; path = cli/pathmatch.h; sourceTree = "<group>"; };
-		F4043DB3177F093300CD5A40 /* check64bit.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = check64bit.cpp; path = lib/check64bit.cpp; sourceTree = "<group>"; };
-		F4043DB4177F093300CD5A40 /* check64bit.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = check64bit.h; path = lib/check64bit.h; sourceTree = "<group>"; };
-		F4043DB5177F093300CD5A40 /* checkassert.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checkassert.cpp; path = lib/checkassert.cpp; sourceTree = "<group>"; };
-		F4043DB6177F093300CD5A40 /* checkassert.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checkassert.h; path = lib/checkassert.h; sourceTree = "<group>"; };
-		F4043DB9177F093300CD5A40 /* checkbool.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checkbool.cpp; path = lib/checkbool.cpp; sourceTree = "<group>"; };
-		F4043DBA177F093300CD5A40 /* checkbool.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checkbool.h; path = lib/checkbool.h; sourceTree = "<group>"; };
-		F4043DBB177F093300CD5A40 /* checkboost.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checkboost.cpp; path = lib/checkboost.cpp; sourceTree = "<group>"; };
-		F4043DBC177F093300CD5A40 /* checkboost.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checkboost.h; path = lib/checkboost.h; sourceTree = "<group>"; };
-		F4043DBD177F093300CD5A40 /* checkinternal.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checkinternal.cpp; path = lib/checkinternal.cpp; sourceTree = "<group>"; };
-		F4043DBE177F093300CD5A40 /* checkinternal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checkinternal.h; path = lib/checkinternal.h; sourceTree = "<group>"; };
-		F4043DBF177F093300CD5A40 /* checkio.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checkio.cpp; path = lib/checkio.cpp; sourceTree = "<group>"; };
-		F4043DC0177F093300CD5A40 /* checkio.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checkio.h; path = lib/checkio.h; sourceTree = "<group>"; };
-		F4043DC1177F093300CD5A40 /* checkleakautovar.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checkleakautovar.cpp; path = lib/checkleakautovar.cpp; sourceTree = "<group>"; };
-		F4043DC2177F093300CD5A40 /* checkleakautovar.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checkleakautovar.h; path = lib/checkleakautovar.h; sourceTree = "<group>"; };
-		F4043DC5177F093300CD5A40 /* checknullpointer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checknullpointer.cpp; path = lib/checknullpointer.cpp; sourceTree = "<group>"; };
-		F4043DC6177F093300CD5A40 /* checknullpointer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checknullpointer.h; path = lib/checknullpointer.h; sourceTree = "<group>"; };
-		F4043DC7177F093300CD5A40 /* checksizeof.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checksizeof.cpp; path = lib/checksizeof.cpp; sourceTree = "<group>"; };
-		F4043DC8177F093300CD5A40 /* checksizeof.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checksizeof.h; path = lib/checksizeof.h; sourceTree = "<group>"; };
-		F4043DC9177F093300CD5A40 /* checkuninitvar.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checkuninitvar.cpp; path = lib/checkuninitvar.cpp; sourceTree = "<group>"; };
-		F4043DCA177F093300CD5A40 /* checkuninitvar.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checkuninitvar.h; path = lib/checkuninitvar.h; sourceTree = "<group>"; };
-		F4043DCB177F093300CD5A40 /* checkunusedvar.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checkunusedvar.cpp; path = lib/checkunusedvar.cpp; sourceTree = "<group>"; };
-		F4043DCC177F093300CD5A40 /* checkunusedvar.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checkunusedvar.h; path = lib/checkunusedvar.h; sourceTree = "<group>"; };
-		F4043DCD177F093300CD5A40 /* standards.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = standards.h; path = lib/standards.h; sourceTree = "<group>"; };
-		F4043DCE177F093300CD5A40 /* suppressions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = suppressions.cpp; path = lib/suppressions.cpp; sourceTree = "<group>"; };
-		F4043DCF177F093300CD5A40 /* suppressions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = suppressions.h; path = lib/suppressions.h; sourceTree = "<group>"; };
-		F4043DD0177F093300CD5A40 /* symboldatabase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = symboldatabase.cpp; path = lib/symboldatabase.cpp; sourceTree = "<group>"; };
-		F4043DD1177F093300CD5A40 /* symboldatabase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = symboldatabase.h; path = lib/symboldatabase.h; sourceTree = "<group>"; };
-		F4043DD2177F093300CD5A40 /* templatesimplifier.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = templatesimplifier.cpp; path = lib/templatesimplifier.cpp; sourceTree = "<group>"; };
-		F4043DD3177F093300CD5A40 /* templatesimplifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = templatesimplifier.h; path = lib/templatesimplifier.h; sourceTree = "<group>"; };
-		F4043DD4177F093300CD5A40 /* tokenlist.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = tokenlist.cpp; path = lib/tokenlist.cpp; sourceTree = "<group>"; };
-		F4043DD5177F093300CD5A40 /* tokenlist.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = tokenlist.h; path = lib/tokenlist.h; sourceTree = "<group>"; };
-		F4043DD6177F093300CD5A40 /* version.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = version.h; path = lib/version.h; sourceTree = "<group>"; };
-		F45BDD8317AB8511006C06AF /* options.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = options.h; path = test/options.h; sourceTree = "<group>"; };
-		F45BDD8417AB8511006C06AF /* redirect.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = redirect.h; path = test/redirect.h; sourceTree = "<group>"; };
-		F45BDD8517AB8511006C06AF /* testsuite.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = testsuite.h; path = test/testsuite.h; sourceTree = "<group>"; };
-		F45BDD8617AB8511006C06AF /* testutils.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = testutils.h; path = test/testutils.h; sourceTree = "<group>"; };
-		F45BDD8717AB8511006C06AF /* options.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = options.cpp; path = test/options.cpp; sourceTree = "<group>"; };
-		F45BDD8917AB8511006C06AF /* test64bit.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = test64bit.cpp; path = test/test64bit.cpp; sourceTree = "<group>"; };
-		F45BDD8A17AB8511006C06AF /* testassert.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testassert.cpp; path = test/testassert.cpp; sourceTree = "<group>"; };
-		F45BDD8B17AB8511006C06AF /* testassignif.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testassignif.cpp; path = test/testassignif.cpp; sourceTree = "<group>"; };
-		F45BDD8C17AB8511006C06AF /* testautovariables.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testautovariables.cpp; path = test/testautovariables.cpp; sourceTree = "<group>"; };
-		F45BDD8D17AB8511006C06AF /* testbool.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testbool.cpp; path = test/testbool.cpp; sourceTree = "<group>"; };
-		F45BDD8E17AB8511006C06AF /* testboost.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testboost.cpp; path = test/testboost.cpp; sourceTree = "<group>"; };
-		F45BDD8F17AB8511006C06AF /* testbufferoverrun.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testbufferoverrun.cpp; path = test/testbufferoverrun.cpp; sourceTree = "<group>"; };
-		F45BDD9017AB8511006C06AF /* testcharvar.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testcharvar.cpp; path = test/testcharvar.cpp; sourceTree = "<group>"; };
-		F45BDD9117AB8511006C06AF /* testclass.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testclass.cpp; path = test/testclass.cpp; sourceTree = "<group>"; };
-		F45BDD9217AB8511006C06AF /* testcmdlineparser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testcmdlineparser.cpp; path = test/testcmdlineparser.cpp; sourceTree = "<group>"; };
-		F45BDD9317AB8511006C06AF /* testconstructors.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testconstructors.cpp; path = test/testconstructors.cpp; sourceTree = "<group>"; };
-		F45BDD9417AB8511006C06AF /* testcppcheck.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testcppcheck.cpp; path = test/testcppcheck.cpp; sourceTree = "<group>"; };
-		F45BDD9517AB8511006C06AF /* testdivision.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testdivision.cpp; path = test/testdivision.cpp; sourceTree = "<group>"; };
-		F45BDD9617AB8511006C06AF /* testerrorlogger.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testerrorlogger.cpp; path = test/testerrorlogger.cpp; sourceTree = "<group>"; };
-		F45BDD9717AB8511006C06AF /* testexceptionsafety.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testexceptionsafety.cpp; path = test/testexceptionsafety.cpp; sourceTree = "<group>"; };
-		F45BDD9817AB8511006C06AF /* testfilelister.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testfilelister.cpp; path = test/testfilelister.cpp; sourceTree = "<group>"; };
-		F45BDD9917AB8511006C06AF /* testincompletestatement.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testincompletestatement.cpp; path = test/testincompletestatement.cpp; sourceTree = "<group>"; };
-		F45BDD9A17AB8511006C06AF /* testinternal.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testinternal.cpp; path = test/testinternal.cpp; sourceTree = "<group>"; };
-		F45BDD9B17AB8511006C06AF /* testio.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testio.cpp; path = test/testio.cpp; sourceTree = "<group>"; };
-		F45BDD9C17AB8511006C06AF /* testleakautovar.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testleakautovar.cpp; path = test/testleakautovar.cpp; sourceTree = "<group>"; };
-		F45BDD9D17AB8511006C06AF /* testmathlib.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testmathlib.cpp; path = test/testmathlib.cpp; sourceTree = "<group>"; };
-		F45BDD9E17AB8511006C06AF /* testmemleak.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testmemleak.cpp; path = test/testmemleak.cpp; sourceTree = "<group>"; };
-		F45BDD9F17AB8511006C06AF /* testnonreentrantfunctions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testnonreentrantfunctions.cpp; path = test/testnonreentrantfunctions.cpp; sourceTree = "<group>"; };
-		F45BDDA017AB8511006C06AF /* testnullpointer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testnullpointer.cpp; path = test/testnullpointer.cpp; sourceTree = "<group>"; };
-		F45BDDA117AB8511006C06AF /* testobsolescentfunctions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testobsolescentfunctions.cpp; path = test/testobsolescentfunctions.cpp; sourceTree = "<group>"; };
-		F45BDDA217AB8511006C06AF /* testoptions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testoptions.cpp; path = test/testoptions.cpp; sourceTree = "<group>"; };
-		F45BDDA317AB8511006C06AF /* testother.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testother.cpp; path = test/testother.cpp; sourceTree = "<group>"; };
-		F45BDDA417AB8511006C06AF /* testpath.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testpath.cpp; path = test/testpath.cpp; sourceTree = "<group>"; };
-		F45BDDA517AB8511006C06AF /* testpathmatch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testpathmatch.cpp; path = test/testpathmatch.cpp; sourceTree = "<group>"; };
-		F45BDDA617AB8511006C06AF /* testpostfixoperator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testpostfixoperator.cpp; path = test/testpostfixoperator.cpp; sourceTree = "<group>"; };
-		F45BDDA717AB8511006C06AF /* testpreprocessor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testpreprocessor.cpp; path = test/testpreprocessor.cpp; sourceTree = "<group>"; };
-		F45BDDA817AB8511006C06AF /* testrunner.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testrunner.cpp; path = test/testrunner.cpp; sourceTree = "<group>"; };
-		F45BDDA917AB8511006C06AF /* testsimplifytokens.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testsimplifytokens.cpp; path = test/testsimplifytokens.cpp; sourceTree = "<group>"; };
-		F45BDDAA17AB8511006C06AF /* testsizeof.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testsizeof.cpp; path = test/testsizeof.cpp; sourceTree = "<group>"; };
-		F45BDDAB17AB8511006C06AF /* teststl.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = teststl.cpp; path = test/teststl.cpp; sourceTree = "<group>"; };
-		F45BDDAC17AB8511006C06AF /* testsuite.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testsuite.cpp; path = test/testsuite.cpp; sourceTree = "<group>"; };
-		F45BDDAD17AB8511006C06AF /* testsuppressions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testsuppressions.cpp; path = test/testsuppressions.cpp; sourceTree = "<group>"; };
-		F45BDDAE17AB8511006C06AF /* testsymboldatabase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testsymboldatabase.cpp; path = test/testsymboldatabase.cpp; sourceTree = "<group>"; };
-		F45BDDAF17AB8511006C06AF /* testthreadexecutor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testthreadexecutor.cpp; path = test/testthreadexecutor.cpp; sourceTree = "<group>"; };
-		F45BDDB017AB8511006C06AF /* testtimer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testtimer.cpp; path = test/testtimer.cpp; sourceTree = "<group>"; };
-		F45BDDB117AB8511006C06AF /* testtoken.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testtoken.cpp; path = test/testtoken.cpp; sourceTree = "<group>"; };
-		F45BDDB217AB8511006C06AF /* testtokenize.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testtokenize.cpp; path = test/testtokenize.cpp; sourceTree = "<group>"; };
-		F45BDDB317AB8511006C06AF /* testuninitvar.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testuninitvar.cpp; path = test/testuninitvar.cpp; sourceTree = "<group>"; };
-		F45BDDB417AB8511006C06AF /* testunusedfunctions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testunusedfunctions.cpp; path = test/testunusedfunctions.cpp; sourceTree = "<group>"; };
-		F45BDDB517AB8511006C06AF /* testunusedprivfunc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testunusedprivfunc.cpp; path = test/testunusedprivfunc.cpp; sourceTree = "<group>"; };
-		F45BDDB617AB8511006C06AF /* testunusedvar.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = testunusedvar.cpp; path = test/testunusedvar.cpp; sourceTree = "<group>"; };
-		F47E508117896AEB00C684DC /* tinyxml2.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = tinyxml2.cpp; path = externals/tinyxml/tinyxml2.cpp; sourceTree = "<group>"; };
-		F47E508217896AEB00C684DC /* tinyxml2.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = tinyxml2.h; path = externals/tinyxml/tinyxml2.h; sourceTree = "<group>"; };
-		F497C2831AB41D5C003B96CF /* check.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = check.cpp; path = lib/check.cpp; sourceTree = "<group>"; };
-		F497C2841AB41D5C003B96CF /* checkcondition.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checkcondition.cpp; path = lib/checkcondition.cpp; sourceTree = "<group>"; };
-		F497C2851AB41D5C003B96CF /* checkcondition.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checkcondition.h; path = lib/checkcondition.h; sourceTree = "<group>"; };
-		F497C2861AB41D5C003B96CF /* checkstring.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checkstring.cpp; path = lib/checkstring.cpp; sourceTree = "<group>"; };
-		F497C2871AB41D5C003B96CF /* checkstring.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checkstring.h; path = lib/checkstring.h; sourceTree = "<group>"; };
-		F497C2881AB41D5C003B96CF /* checktype.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checktype.cpp; path = lib/checktype.cpp; sourceTree = "<group>"; };
-		F497C2891AB41D5C003B96CF /* checkvaarg.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = checkvaarg.cpp; path = lib/checkvaarg.cpp; sourceTree = "<group>"; };
-		F497C28A1AB41D5C003B96CF /* checkvaarg.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = checkvaarg.h; path = lib/checkvaarg.h; sourceTree = "<group>"; };
-		F497C28B1AB41D5C003B96CF /* cxx11emu.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = cxx11emu.h; path = lib/cxx11emu.h; sourceTree = "<group>"; };
-		F4C34860182566E800521683 /* testrunner */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = testrunner; sourceTree = BUILT_PRODUCTS_DIR; };
-		F4CDD6961880888F006CF685 /* valueflow.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = valueflow.cpp; path = lib/valueflow.cpp; sourceTree = "<group>"; };
-		F4CDD6971880888F006CF685 /* valueflow.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = valueflow.h; path = lib/valueflow.h; sourceTree = "<group>"; };
-		F4CF847A17B6504000522F24 /* config.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = config.h; path = lib/config.h; sourceTree = "<group>"; };
-		F4CF847B17B6504100522F24 /* library.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = library.h; path = lib/library.h; sourceTree = "<group>"; };
-		F4CF847C17B6504100522F24 /* library.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = library.cpp; path = lib/library.cpp; sourceTree = "<group>"; };
-/* End PBXFileReference section */
-
-/* Begin PBXFrameworksBuildPhase section */
-		8DD76F660486A84900D96B5E /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		F4C3485D182566E800521683 /* Frameworks */ = {
-			isa = PBXFrameworksBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXFrameworksBuildPhase section */
-
-/* Begin PBXGroup section */
-		08FB7794FE84155DC02AAC07 /* cppcheck */ = {
-			isa = PBXGroup;
-			children = (
-				08FB7795FE84155DC02AAC07 /* Source */,
-				C6859E8C029090F304C91782 /* Documentation */,
-				F4C34861182566E800521683 /* testrunner */,
-				1AB674ADFE9D54B511CA2CBB /* Products */,
-			);
-			name = cppcheck;
-			sourceTree = "<group>";
-		};
-		08FB7795FE84155DC02AAC07 /* Source */ = {
-			isa = PBXGroup;
-			children = (
-				F4C348651825673B00521683 /* Client */,
-				F45BDD8217AB84D0006C06AF /* Tests */,
-				F47E507F17896AC700C684DC /* Externals */,
-				2C21A45D1178BB0B00D35009 /* Library */,
-				2C21A45C1178BB0400D35009 /* Command */,
-			);
-			name = Source;
-			sourceTree = "<group>";
-		};
-		1AB674ADFE9D54B511CA2CBB /* Products */ = {
-			isa = PBXGroup;
-			children = (
-				39E60EDE1270DEB100AC0D02 /* cppcheck */,
-				F4C34860182566E800521683 /* testrunner */,
-			);
-			name = Products;
-			sourceTree = "<group>";
-		};
-		2C21A45C1178BB0400D35009 /* Command */ = {
-			isa = PBXGroup;
-			children = (
-				39E60ECF1270DE5000AC0D02 /* cmdlineparser.cpp */,
-				39E60ED01270DE5000AC0D02 /* cmdlineparser.h */,
-				39E60ED11270DE5000AC0D02 /* cppcheckexecutor.cpp */,
-				2D190F241C03A67A00C18478 /* utils.h */,
-				39E60ED21270DE5000AC0D02 /* cppcheckexecutor.h */,
-				F4043DAD177F08A800CD5A40 /* filelister.cpp */,
-				F4043DAE177F08A800CD5A40 /* filelister.h */,
-				39E60ED31270DE5000AC0D02 /* main.cpp */,
-				F4043DAF177F08A800CD5A40 /* pathmatch.cpp */,
-				F4043DB0177F08A800CD5A40 /* pathmatch.h */,
-				39E60ED41270DE5000AC0D02 /* threadexecutor.cpp */,
-				39E60ED51270DE5000AC0D02 /* threadexecutor.h */,
-			);
-			name = Command;
-			sourceTree = "<group>";
-		};
-		2C21A45D1178BB0B00D35009 /* Library */ = {
-			isa = PBXGroup;
-			children = (
-				2D190F251C03A7A600C18478 /* astutils.cpp */,
-				2D190F261C03A7A600C18478 /* astutils.h */,
-				F497C2831AB41D5C003B96CF /* check.cpp */,
-				F497C2841AB41D5C003B96CF /* checkcondition.cpp */,
-				F497C2851AB41D5C003B96CF /* checkcondition.h */,
-				F497C2861AB41D5C003B96CF /* checkstring.cpp */,
-				F497C2871AB41D5C003B96CF /* checkstring.h */,
-				F497C2881AB41D5C003B96CF /* checktype.cpp */,
-				F497C2891AB41D5C003B96CF /* checkvaarg.cpp */,
-				F497C28A1AB41D5C003B96CF /* checkvaarg.h */,
-				F497C28B1AB41D5C003B96CF /* cxx11emu.h */,
-				F4CDD6961880888F006CF685 /* valueflow.cpp */,
-				F4CDD6971880888F006CF685 /* valueflow.h */,
-				F4CF847A17B6504000522F24 /* config.h */,
-				F4CF847B17B6504100522F24 /* library.h */,
-				F4CF847C17B6504100522F24 /* library.cpp */,
-				39E60E8C1270DE3A00AC0D02 /* check.h */,
-				F4043DB3177F093300CD5A40 /* check64bit.cpp */,
-				F4043DB4177F093300CD5A40 /* check64bit.h */,
-				F4043DB5177F093300CD5A40 /* checkassert.cpp */,
-				F4043DB6177F093300CD5A40 /* checkassert.h */,
-				39E60E8D1270DE3A00AC0D02 /* checkautovariables.cpp */,
-				39E60E8E1270DE3A00AC0D02 /* checkautovariables.h */,
-				F4043DB9177F093300CD5A40 /* checkbool.cpp */,
-				F4043DBA177F093300CD5A40 /* checkbool.h */,
-				F4043DBB177F093300CD5A40 /* checkboost.cpp */,
-				F4043DBC177F093300CD5A40 /* checkboost.h */,
-				39E60E8F1270DE3A00AC0D02 /* checkbufferoverrun.cpp */,
-				39E60E901270DE3A00AC0D02 /* checkbufferoverrun.h */,
-				39E60E911270DE3A00AC0D02 /* checkclass.cpp */,
-				39E60E921270DE3A00AC0D02 /* checkclass.h */,
-				39E60E931270DE3A00AC0D02 /* checkexceptionsafety.cpp */,
-				39E60E941270DE3A00AC0D02 /* checkexceptionsafety.h */,
-				F4043DBD177F093300CD5A40 /* checkinternal.cpp */,
-				F4043DBE177F093300CD5A40 /* checkinternal.h */,
-				F4043DBF177F093300CD5A40 /* checkio.cpp */,
-				F4043DC0177F093300CD5A40 /* checkio.h */,
-				F4043DC1177F093300CD5A40 /* checkleakautovar.cpp */,
-				F4043DC2177F093300CD5A40 /* checkleakautovar.h */,
-				39E60E951270DE3A00AC0D02 /* checkmemoryleak.cpp */,
-				39E60E961270DE3A00AC0D02 /* checkmemoryleak.h */,
-				F4043DC5177F093300CD5A40 /* checknullpointer.cpp */,
-				F4043DC6177F093300CD5A40 /* checknullpointer.h */,
-				39E60E991270DE3A00AC0D02 /* checkother.cpp */,
-				39E60E9A1270DE3A00AC0D02 /* checkother.h */,
-				39E60E9B1270DE3A00AC0D02 /* checkpostfixoperator.cpp */,
-				39E60E9C1270DE3A00AC0D02 /* checkpostfixoperator.h */,
-				F4043DC7177F093300CD5A40 /* checksizeof.cpp */,
-				F4043DC8177F093300CD5A40 /* checksizeof.h */,
-				39E60E9D1270DE3A00AC0D02 /* checkstl.cpp */,
-				39E60E9E1270DE3A00AC0D02 /* checkstl.h */,
-				F4043DC9177F093300CD5A40 /* checkuninitvar.cpp */,
-				F4043DCA177F093300CD5A40 /* checkuninitvar.h */,
-				39E60E9F1270DE3A00AC0D02 /* checkunusedfunctions.cpp */,
-				39E60EA01270DE3A00AC0D02 /* checkunusedfunctions.h */,
-				F4043DCB177F093300CD5A40 /* checkunusedvar.cpp */,
-				F4043DCC177F093300CD5A40 /* checkunusedvar.h */,
-				39E60EA11270DE3A00AC0D02 /* cppcheck.cpp */,
-				39E60EA21270DE3A00AC0D02 /* cppcheck.h */,
-				39E60EA31270DE3A00AC0D02 /* errorlogger.cpp */,
-				39E60EA41270DE3A00AC0D02 /* errorlogger.h */,
-				39E60EAB1270DE3A00AC0D02 /* mathlib.cpp */,
-				39E60EAC1270DE3A00AC0D02 /* mathlib.h */,
-				39E60EAD1270DE3A00AC0D02 /* path.cpp */,
-				39E60EAE1270DE3A00AC0D02 /* path.h */,
-				39E60EAF1270DE3A00AC0D02 /* preprocessor.cpp */,
-				39E60EB01270DE3A00AC0D02 /* preprocessor.h */,
-				39E60EB11270DE3A00AC0D02 /* settings.cpp */,
-				39E60EB21270DE3A00AC0D02 /* settings.h */,
-				F4043DCD177F093300CD5A40 /* standards.h */,
-				F4043DCE177F093300CD5A40 /* suppressions.cpp */,
-				F4043DCF177F093300CD5A40 /* suppressions.h */,
-				F4043DD0177F093300CD5A40 /* symboldatabase.cpp */,
-				F4043DD1177F093300CD5A40 /* symboldatabase.h */,
-				F4043DD2177F093300CD5A40 /* templatesimplifier.cpp */,
-				F4043DD3177F093300CD5A40 /* templatesimplifier.h */,
-				39E60EB31270DE3A00AC0D02 /* timer.cpp */,
-				39E60EB41270DE3A00AC0D02 /* timer.h */,
-				39E60EB51270DE3A00AC0D02 /* token.cpp */,
-				39E60EB61270DE3A00AC0D02 /* token.h */,
-				39E60EB71270DE3A00AC0D02 /* tokenize.cpp */,
-				39E60EB81270DE3A00AC0D02 /* tokenize.h */,
-				F4043DD4177F093300CD5A40 /* tokenlist.cpp */,
-				F4043DD5177F093300CD5A40 /* tokenlist.h */,
-				F4043DD6177F093300CD5A40 /* version.h */,
-			);
-			name = Library;
-			sourceTree = "<group>";
-		};
-		C6859E8C029090F304C91782 /* Documentation */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			name = Documentation;
-			sourceTree = "<group>";
-		};
-		F45BDD8217AB84D0006C06AF /* Tests */ = {
-			isa = PBXGroup;
-			children = (
-				F45BDD8317AB8511006C06AF /* options.h */,
-				F45BDD8417AB8511006C06AF /* redirect.h */,
-				F45BDD8517AB8511006C06AF /* testsuite.h */,
-				F45BDD8617AB8511006C06AF /* testutils.h */,
-				F45BDD8717AB8511006C06AF /* options.cpp */,
-				F45BDD8917AB8511006C06AF /* test64bit.cpp */,
-				F45BDD8A17AB8511006C06AF /* testassert.cpp */,
-				F45BDD8B17AB8511006C06AF /* testassignif.cpp */,
-				F45BDD8C17AB8511006C06AF /* testautovariables.cpp */,
-				F45BDD8D17AB8511006C06AF /* testbool.cpp */,
-				F45BDD8E17AB8511006C06AF /* testboost.cpp */,
-				F45BDD8F17AB8511006C06AF /* testbufferoverrun.cpp */,
-				F45BDD9017AB8511006C06AF /* testcharvar.cpp */,
-				F45BDD9117AB8511006C06AF /* testclass.cpp */,
-				F45BDD9217AB8511006C06AF /* testcmdlineparser.cpp */,
-				F45BDD9317AB8511006C06AF /* testconstructors.cpp */,
-				F45BDD9417AB8511006C06AF /* testcppcheck.cpp */,
-				F45BDD9517AB8511006C06AF /* testdivision.cpp */,
-				F45BDD9617AB8511006C06AF /* testerrorlogger.cpp */,
-				F45BDD9717AB8511006C06AF /* testexceptionsafety.cpp */,
-				F45BDD9817AB8511006C06AF /* testfilelister.cpp */,
-				F45BDD9917AB8511006C06AF /* testincompletestatement.cpp */,
-				F45BDD9A17AB8511006C06AF /* testinternal.cpp */,
-				F45BDD9B17AB8511006C06AF /* testio.cpp */,
-				F45BDD9C17AB8511006C06AF /* testleakautovar.cpp */,
-				F45BDD9D17AB8511006C06AF /* testmathlib.cpp */,
-				F45BDD9E17AB8511006C06AF /* testmemleak.cpp */,
-				F45BDD9F17AB8511006C06AF /* testnonreentrantfunctions.cpp */,
-				F45BDDA017AB8511006C06AF /* testnullpointer.cpp */,
-				F45BDDA117AB8511006C06AF /* testobsolescentfunctions.cpp */,
-				F45BDDA217AB8511006C06AF /* testoptions.cpp */,
-				F45BDDA317AB8511006C06AF /* testother.cpp */,
-				F45BDDA417AB8511006C06AF /* testpath.cpp */,
-				F45BDDA517AB8511006C06AF /* testpathmatch.cpp */,
-				F45BDDA617AB8511006C06AF /* testpostfixoperator.cpp */,
-				F45BDDA717AB8511006C06AF /* testpreprocessor.cpp */,
-				F45BDDA817AB8511006C06AF /* testrunner.cpp */,
-				F45BDDA917AB8511006C06AF /* testsimplifytokens.cpp */,
-				F45BDDAA17AB8511006C06AF /* testsizeof.cpp */,
-				F45BDDAB17AB8511006C06AF /* teststl.cpp */,
-				F45BDDAC17AB8511006C06AF /* testsuite.cpp */,
-				F45BDDAD17AB8511006C06AF /* testsuppressions.cpp */,
-				F45BDDAE17AB8511006C06AF /* testsymboldatabase.cpp */,
-				F45BDDAF17AB8511006C06AF /* testthreadexecutor.cpp */,
-				F45BDDB017AB8511006C06AF /* testtimer.cpp */,
-				F45BDDB117AB8511006C06AF /* testtoken.cpp */,
-				F45BDDB217AB8511006C06AF /* testtokenize.cpp */,
-				F45BDDB317AB8511006C06AF /* testuninitvar.cpp */,
-				F45BDDB417AB8511006C06AF /* testunusedfunctions.cpp */,
-				F45BDDB517AB8511006C06AF /* testunusedprivfunc.cpp */,
-				F45BDDB617AB8511006C06AF /* testunusedvar.cpp */,
-			);
-			name = Tests;
-			sourceTree = "<group>";
-		};
-		F47E507F17896AC700C684DC /* Externals */ = {
-			isa = PBXGroup;
-			children = (
-				F47E508017896AD200C684DC /* tinyxml */,
-			);
-			name = Externals;
-			sourceTree = "<group>";
-		};
-		F47E508017896AD200C684DC /* tinyxml */ = {
-			isa = PBXGroup;
-			children = (
-				F47E508117896AEB00C684DC /* tinyxml2.cpp */,
-				F47E508217896AEB00C684DC /* tinyxml2.h */,
-			);
-			name = tinyxml;
-			sourceTree = "<group>";
-		};
-		F4C34861182566E800521683 /* testrunner */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			path = testrunner;
-			sourceTree = "<group>";
-		};
-		F4C348651825673B00521683 /* Client */ = {
-			isa = PBXGroup;
-			children = (
-			);
-			name = Client;
-			sourceTree = "<group>";
-		};
-/* End PBXGroup section */
-
-/* Begin PBXNativeTarget section */
-		8DD76F620486A84900D96B5E /* cppcheck */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = 1DEB923108733DC60010E9CD /* Build configuration list for PBXNativeTarget "cppcheck" */;
-			buildPhases = (
-				8DD76F640486A84900D96B5E /* Sources */,
-				8DD76F660486A84900D96B5E /* Frameworks */,
-				8DD76F690486A84900D96B5E /* CopyFiles */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = cppcheck;
-			productInstallPath = "$(HOME)/bin";
-			productName = cppcheck;
-			productReference = 39E60EDE1270DEB100AC0D02 /* cppcheck */;
-			productType = "com.apple.product-type.tool";
-		};
-		F4C3485F182566E800521683 /* testrunner */ = {
-			isa = PBXNativeTarget;
-			buildConfigurationList = F4C34864182566E800521683 /* Build configuration list for PBXNativeTarget "testrunner" */;
-			buildPhases = (
-				F4C3485C182566E800521683 /* Sources */,
-				F4C3485D182566E800521683 /* Frameworks */,
-				F4C3485E182566E800521683 /* CopyFiles */,
-			);
-			buildRules = (
-			);
-			dependencies = (
-			);
-			name = testrunner;
-			productName = testrunner;
-			productReference = F4C34860182566E800521683 /* testrunner */;
-			productType = "com.apple.product-type.tool";
-		};
-/* End PBXNativeTarget section */
-
-/* Begin PBXProject section */
-		08FB7793FE84155DC02AAC07 /* Project object */ = {
-			isa = PBXProject;
-			attributes = {
-				LastUpgradeCheck = 0620;
-			};
-			buildConfigurationList = 1DEB923508733DC60010E9CD /* Build configuration list for PBXProject "Cppcheck" */;
-			compatibilityVersion = "Xcode 3.2";
-			developmentRegion = English;
-			hasScannedForEncodings = 1;
-			knownRegions = (
-				English,
-				Japanese,
-				French,
-				German,
-			);
-			mainGroup = 08FB7794FE84155DC02AAC07 /* cppcheck */;
-			projectDirPath = "";
-			projectRoot = "";
-			targets = (
-				8DD76F620486A84900D96B5E /* cppcheck */,
-				F4C3485F182566E800521683 /* testrunner */,
-			);
-		};
-/* End PBXProject section */
-
-/* Begin PBXSourcesBuildPhase section */
-		8DD76F640486A84900D96B5E /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				39E60EB91270DE3A00AC0D02 /* checkautovariables.cpp in Sources */,
-				39E60EBA1270DE3A00AC0D02 /* checkbufferoverrun.cpp in Sources */,
-				39E60EBB1270DE3A00AC0D02 /* checkclass.cpp in Sources */,
-				F4CDD6981880888F006CF685 /* valueflow.cpp in Sources */,
-				39E60EBC1270DE3A00AC0D02 /* checkexceptionsafety.cpp in Sources */,
-				F497C28E1AB41D5C003B96CF /* checkstring.cpp in Sources */,
-				2D190F271C03A7A600C18478 /* astutils.cpp in Sources */,
-				39E60EBD1270DE3A00AC0D02 /* checkmemoryleak.cpp in Sources */,
-				39E60EBF1270DE3A00AC0D02 /* checkother.cpp in Sources */,
-				39E60EC01270DE3A00AC0D02 /* checkpostfixoperator.cpp in Sources */,
-				39E60EC11270DE3A00AC0D02 /* checkstl.cpp in Sources */,
-				39E60EC21270DE3A00AC0D02 /* checkunusedfunctions.cpp in Sources */,
-				39E60EC31270DE3A00AC0D02 /* cppcheck.cpp in Sources */,
-				39E60EC41270DE3A00AC0D02 /* errorlogger.cpp in Sources */,
-				F497C28C1AB41D5C003B96CF /* check.cpp in Sources */,
-				F497C28D1AB41D5C003B96CF /* checkcondition.cpp in Sources */,
-				39E60EC81270DE3A00AC0D02 /* mathlib.cpp in Sources */,
-				39E60EC91270DE3A00AC0D02 /* path.cpp in Sources */,
-				39E60ECA1270DE3A00AC0D02 /* preprocessor.cpp in Sources */,
-				39E60ECB1270DE3A00AC0D02 /* settings.cpp in Sources */,
-				39E60ECC1270DE3A00AC0D02 /* timer.cpp in Sources */,
-				39E60ECD1270DE3A00AC0D02 /* token.cpp in Sources */,
-				39E60ECE1270DE3A00AC0D02 /* tokenize.cpp in Sources */,
-				39E60ED61270DE5000AC0D02 /* cmdlineparser.cpp in Sources */,
-				39E60ED71270DE5000AC0D02 /* cppcheckexecutor.cpp in Sources */,
-				39E60ED81270DE5000AC0D02 /* main.cpp in Sources */,
-				39E60ED91270DE5000AC0D02 /* threadexecutor.cpp in Sources */,
-				F4043DB1177F08A800CD5A40 /* filelister.cpp in Sources */,
-				F4043DB2177F08A800CD5A40 /* pathmatch.cpp in Sources */,
-				F4043DD7177F093300CD5A40 /* check64bit.cpp in Sources */,
-				F4043DD8177F093300CD5A40 /* checkassert.cpp in Sources */,
-				F497C2901AB41D5C003B96CF /* checkvaarg.cpp in Sources */,
-				F4043DDA177F093300CD5A40 /* checkbool.cpp in Sources */,
-				F4043DDB177F093300CD5A40 /* checkboost.cpp in Sources */,
-				F4043DDC177F093300CD5A40 /* checkinternal.cpp in Sources */,
-				F4043DDD177F093300CD5A40 /* checkio.cpp in Sources */,
-				F4043DDE177F093300CD5A40 /* checkleakautovar.cpp in Sources */,
-				F4043DE0177F093300CD5A40 /* checknullpointer.cpp in Sources */,
-				F4043DE1177F093300CD5A40 /* checksizeof.cpp in Sources */,
-				F4043DE2177F093300CD5A40 /* checkuninitvar.cpp in Sources */,
-				F4043DE3177F093300CD5A40 /* checkunusedvar.cpp in Sources */,
-				F4043DE4177F093300CD5A40 /* suppressions.cpp in Sources */,
-				F4043DE5177F093300CD5A40 /* symboldatabase.cpp in Sources */,
-				F497C28F1AB41D5C003B96CF /* checktype.cpp in Sources */,
-				F4043DE6177F093300CD5A40 /* templatesimplifier.cpp in Sources */,
-				F4043DE7177F093300CD5A40 /* tokenlist.cpp in Sources */,
-				F47E508317896AEB00C684DC /* tinyxml2.cpp in Sources */,
-				F4CF847D17B6504100522F24 /* library.cpp in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-		F4C3485C182566E800521683 /* Sources */ = {
-			isa = PBXSourcesBuildPhase;
-			buildActionMask = 2147483647;
-			files = (
-				F4CDD69918808927006CF685 /* valueflow.cpp in Sources */,
-				F4C348C118256A9900521683 /* cppcheck.cpp in Sources */,
-				F4C348BF18256A8700521683 /* tinyxml2.cpp in Sources */,
-				F4C348C018256A8700521683 /* library.cpp in Sources */,
-				F4C3489B18256A4500521683 /* check64bit.cpp in Sources */,
-				F4C3489C18256A4500521683 /* checkassert.cpp in Sources */,
-				F4C3489E18256A4500521683 /* checkautovariables.cpp in Sources */,
-				F4C3489F18256A4500521683 /* checkbool.cpp in Sources */,
-				F4C348A018256A4500521683 /* checkboost.cpp in Sources */,
-				F4C348A118256A4500521683 /* checkbufferoverrun.cpp in Sources */,
-				F4C348A218256A4500521683 /* checkclass.cpp in Sources */,
-				F4C348A318256A4500521683 /* checkexceptionsafety.cpp in Sources */,
-				F4C348A418256A4500521683 /* checkinternal.cpp in Sources */,
-				F4C348A518256A4500521683 /* checkio.cpp in Sources */,
-				F4C348A618256A4500521683 /* checkleakautovar.cpp in Sources */,
-				F4C348A718256A4500521683 /* checkmemoryleak.cpp in Sources */,
-				F4C348A918256A4500521683 /* checknullpointer.cpp in Sources */,
-				F4C348AB18256A4500521683 /* checkother.cpp in Sources */,
-				F4C348AC18256A4500521683 /* checkpostfixoperator.cpp in Sources */,
-				F4C348AD18256A4500521683 /* checksizeof.cpp in Sources */,
-				F4C348AE18256A4500521683 /* checkstl.cpp in Sources */,
-				F4C348AF18256A4500521683 /* checkuninitvar.cpp in Sources */,
-				F4C348B018256A4500521683 /* checkunusedfunctions.cpp in Sources */,
-				F4C348B118256A4500521683 /* checkunusedvar.cpp in Sources */,
-				F4C348B218256A4500521683 /* errorlogger.cpp in Sources */,
-				F4C348B418256A4500521683 /* mathlib.cpp in Sources */,
-				F4C348B518256A4500521683 /* path.cpp in Sources */,
-				F4C348B618256A4500521683 /* preprocessor.cpp in Sources */,
-				F4C348B718256A4500521683 /* settings.cpp in Sources */,
-				F4C348B818256A4500521683 /* suppressions.cpp in Sources */,
-				F4C348B918256A4500521683 /* symboldatabase.cpp in Sources */,
-				F4C348BA18256A4500521683 /* templatesimplifier.cpp in Sources */,
-				F4C348BB18256A4500521683 /* timer.cpp in Sources */,
-				F4C348BC18256A4500521683 /* token.cpp in Sources */,
-				F4C348BD18256A4500521683 /* tokenize.cpp in Sources */,
-				F4C348BE18256A4500521683 /* tokenlist.cpp in Sources */,
-				F4C3486C1825692B00521683 /* options.cpp in Sources */,
-				F4C3486D1825692B00521683 /* test64bit.cpp in Sources */,
-				F4C3486E1825692B00521683 /* testassert.cpp in Sources */,
-				F4C3486F1825692B00521683 /* testassignif.cpp in Sources */,
-				F4C348701825692B00521683 /* testautovariables.cpp in Sources */,
-				F4C348711825692B00521683 /* testbool.cpp in Sources */,
-				F4C348721825692B00521683 /* testboost.cpp in Sources */,
-				F4C348731825692B00521683 /* testbufferoverrun.cpp in Sources */,
-				F4C348741825692B00521683 /* testcharvar.cpp in Sources */,
-				F4C348751825692B00521683 /* testclass.cpp in Sources */,
-				F4C348761825692B00521683 /* testcmdlineparser.cpp in Sources */,
-				F4C348771825692B00521683 /* testconstructors.cpp in Sources */,
-				F4C348781825692B00521683 /* testcppcheck.cpp in Sources */,
-				F4C348791825692B00521683 /* testdivision.cpp in Sources */,
-				F4C3487A1825692B00521683 /* testerrorlogger.cpp in Sources */,
-				F4C3487B1825692B00521683 /* testexceptionsafety.cpp in Sources */,
-				F4C3487C1825692B00521683 /* testfilelister.cpp in Sources */,
-				F4C3487D1825692B00521683 /* testincompletestatement.cpp in Sources */,
-				F4C3487E1825692B00521683 /* testinternal.cpp in Sources */,
-				F4C3487F1825692B00521683 /* testio.cpp in Sources */,
-				F4C348801825692B00521683 /* testleakautovar.cpp in Sources */,
-				F4C348811825692B00521683 /* testmathlib.cpp in Sources */,
-				F4C348821825692B00521683 /* testmemleak.cpp in Sources */,
-				F4C348831825692B00521683 /* testnonreentrantfunctions.cpp in Sources */,
-				F4C348841825692B00521683 /* testnullpointer.cpp in Sources */,
-				F4C348851825692B00521683 /* testobsolescentfunctions.cpp in Sources */,
-				F4C348861825692B00521683 /* testoptions.cpp in Sources */,
-				F4C348871825692B00521683 /* testother.cpp in Sources */,
-				F4C348881825692B00521683 /* testpath.cpp in Sources */,
-				F4C348891825692B00521683 /* testpathmatch.cpp in Sources */,
-				F4C3488A1825692B00521683 /* testpostfixoperator.cpp in Sources */,
-				F4C3488B1825692B00521683 /* testpreprocessor.cpp in Sources */,
-				F4C3488C1825692B00521683 /* testrunner.cpp in Sources */,
-				F4C3488D1825692B00521683 /* testsimplifytokens.cpp in Sources */,
-				F4C3488E1825692B00521683 /* testsizeof.cpp in Sources */,
-				F4C3488F1825692B00521683 /* teststl.cpp in Sources */,
-				F4C348901825692B00521683 /* testsuite.cpp in Sources */,
-				F4C348911825692B00521683 /* testsuppressions.cpp in Sources */,
-				F4C348921825692B00521683 /* testsymboldatabase.cpp in Sources */,
-				F4C348931825692B00521683 /* testthreadexecutor.cpp in Sources */,
-				F4C348941825692B00521683 /* testtimer.cpp in Sources */,
-				F4C348951825692B00521683 /* testtoken.cpp in Sources */,
-				F4C348961825692B00521683 /* testtokenize.cpp in Sources */,
-				F4C348971825692B00521683 /* testuninitvar.cpp in Sources */,
-				F4C348981825692B00521683 /* testunusedfunctions.cpp in Sources */,
-				F4C348991825692B00521683 /* testunusedprivfunc.cpp in Sources */,
-				F4C3489A1825692B00521683 /* testunusedvar.cpp in Sources */,
-				F4C348661825679E00521683 /* cmdlineparser.cpp in Sources */,
-				F4C348671825679F00521683 /* cppcheckexecutor.cpp in Sources */,
-				F4C348681825679F00521683 /* filelister.cpp in Sources */,
-				F4C348691825679F00521683 /* pathmatch.cpp in Sources */,
-				F4C3486A1825679F00521683 /* threadexecutor.cpp in Sources */,
-			);
-			runOnlyForDeploymentPostprocessing = 0;
-		};
-/* End PBXSourcesBuildPhase section */
-
-/* Begin XCBuildConfiguration section */
-		1DEB923208733DC60010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_MODEL_TUNING = "";
-				GCC_OPTIMIZATION_LEVEL = 0;
-				"GCC_PREPROCESSOR_DEFINITIONS[arch=*]" = "CFGDIR=\\\"$SRCROOT/cfg/\\\"";
-				GCC_VERSION = "";
-				HEADER_SEARCH_PATHS = externals/tinyxml;
-				INSTALL_PATH = /usr/local/bin;
-				PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR = NO;
-				PRODUCT_NAME = cppcheck;
-			};
-			name = Debug;
-		};
-		1DEB923308733DC60010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				DEBUG_INFORMATION_FORMAT = dwarf;
-				GCC_MODEL_TUNING = "";
-				"GCC_PREPROCESSOR_DEFINITIONS[arch=*]" = "CFGDIR=\\\"$SRCROOT/cfg/\\\"";
-				HEADER_SEARCH_PATHS = externals/tinyxml;
-				INSTALL_PATH = /usr/local/bin;
-				PRODUCT_NAME = cppcheck;
-			};
-			name = Release;
-		};
-		1DEB923608733DC60010E9CD /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				CLANG_CXX_LANGUAGE_STANDARD = "c++0x";
-				GCC_C_LANGUAGE_STANDARD = gnu99;
-				GCC_OPTIMIZATION_LEVEL = 0;
-				GCC_VERSION = "";
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				ONLY_ACTIVE_ARCH = YES;
-				SDKROOT = macosx;
-			};
-			name = Debug;
-		};
-		1DEB923708733DC60010E9CD /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				CLANG_CXX_LANGUAGE_STANDARD = "c++0x";
-				GCC_C_LANGUAGE_STANDARD = gnu99;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES;
-				GCC_WARN_UNUSED_VARIABLE = YES;
-				SDKROOT = macosx;
-			};
-			name = Release;
-		};
-		F4C34862182566E800521683 /* Debug */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
-				CLANG_CXX_LIBRARY = "libstdc++";
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_WARN_BOOL_CONVERSION = YES;
-				CLANG_WARN_CONSTANT_CONVERSION = YES;
-				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
-				CLANG_WARN_EMPTY_BODY = YES;
-				CLANG_WARN_ENUM_CONVERSION = YES;
-				CLANG_WARN_INT_CONVERSION = YES;
-				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
-				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
-				COPY_PHASE_STRIP = NO;
-				GCC_DYNAMIC_NO_PIC = NO;
-				GCC_ENABLE_OBJC_EXCEPTIONS = YES;
-				GCC_PREPROCESSOR_DEFINITIONS = (
-					"DEBUG=1",
-					"$(inherited)",
-				);
-				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
-				GCC_VERSION = "";
-				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
-				GCC_WARN_UNDECLARED_SELECTOR = YES;
-				GCC_WARN_UNINITIALIZED_AUTOS = YES;
-				GCC_WARN_UNUSED_FUNCTION = YES;
-				HEADER_SEARCH_PATHS = (
-					externals/tinyxml,
-					lib,
-				);
-				MACOSX_DEPLOYMENT_TARGET = 10.9;
-				PRODUCT_NAME = "$(TARGET_NAME)";
-			};
-			name = Debug;
-		};
-		F4C34863182566E800521683 /* Release */ = {
-			isa = XCBuildConfiguration;
-			buildSettings = {
-				ALWAYS_SEARCH_USER_PATHS = NO;
-				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
-				CLANG_CXX_LIBRARY = "libstdc++";
-				CLANG_ENABLE_OBJC_ARC = YES;
-				CLANG_WARN_BOOL_CONVERSION = YES;
-				CLANG_WARN_CONSTANT_CONVERSION = YES;
-				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
-				CLANG_WARN_EMPTY_BODY = YES;
-				CLANG_WARN_ENUM_CONVERSION = YES;
-				CLANG_WARN_INT_CONVERSION = YES;
-				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
-				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
-				COPY_PHASE_STRIP = YES;
-				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
-				ENABLE_NS_ASSERTIONS = NO;
-				GCC_ENABLE_OBJC_EXCEPTIONS = YES;
-				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
-				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
-				GCC_WARN_UNDECLARED_SELECTOR = YES;
-				GCC_WARN_UNINITIALIZED_AUTOS = YES;
-				GCC_WARN_UNUSED_FUNCTION = YES;
-				HEADER_SEARCH_PATHS = (
-					externals/tinyxml,
-					lib,
-				);
-				MACOSX_DEPLOYMENT_TARGET = 10.9;
-				PRODUCT_NAME = "$(TARGET_NAME)";
-			};
-			name = Release;
-		};
-/* End XCBuildConfiguration section */
-
-/* Begin XCConfigurationList section */
-		1DEB923108733DC60010E9CD /* Build configuration list for PBXNativeTarget "cppcheck" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB923208733DC60010E9CD /* Debug */,
-				1DEB923308733DC60010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		1DEB923508733DC60010E9CD /* Build configuration list for PBXProject "Cppcheck" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				1DEB923608733DC60010E9CD /* Debug */,
-				1DEB923708733DC60010E9CD /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-		F4C34864182566E800521683 /* Build configuration list for PBXNativeTarget "testrunner" */ = {
-			isa = XCConfigurationList;
-			buildConfigurations = (
-				F4C34862182566E800521683 /* Debug */,
-				F4C34863182566E800521683 /* Release */,
-			);
-			defaultConfigurationIsVisible = 0;
-			defaultConfigurationName = Release;
-		};
-/* End XCConfigurationList section */
-	};
-	rootObject = 08FB7793FE84155DC02AAC07 /* Project object */;
-}
diff --git a/Makefile b/Makefile
index a83dc89f5c9..bb07f42c208 100644
--- a/Makefile
+++ b/Makefile
@@ -1,64 +1,104 @@
-# This file is generated by tools/dmake, do not edit.
+# This file is generated by dmake, do not edit.
 
+ifndef VERBOSE
+    VERBOSE=
+endif
 # To compile with rules, use 'make HAVE_RULES=yes'
 ifndef HAVE_RULES
-    HAVE_RULES=no
-endif
-
-ifndef USE_Z3
-    USE_Z3=no
+    HAVE_RULES=
 endif
 
-ifeq ($(USE_Z3),yes)
-    CPPFLAGS += -DUSE_Z3
-    LIBS += -lz3
+ifndef MATCHCOMPILER
+    MATCHCOMPILER=
 endif
 # use match compiler
-ifeq ($(SRCDIR),build)
-    $(warning Usage of SRCDIR to activate match compiler is deprecated. Use MATCHCOMPILER=yes instead.)
-    MATCHCOMPILER:=yes
-endif
 ifeq ($(MATCHCOMPILER),yes)
+    # Find available Python interpreter
+    ifeq ($(PYTHON_INTERPRETER),)
+        PYTHON_INTERPRETER := $(shell which python3)
+    endif
+    ifeq ($(PYTHON_INTERPRETER),)
+        PYTHON_INTERPRETER := $(shell which python)
+    endif
+    ifeq ($(PYTHON_INTERPRETER),)
+        $(error Did not find a Python interpreter)
+    endif
     ifdef VERIFY
-        matchcompiler_S := $(shell python tools/matchcompiler.py --verify)
+        matchcompiler_S := $(shell $(PYTHON_INTERPRETER) tools/matchcompiler.py --verify)
     else
-        matchcompiler_S := $(shell python tools/matchcompiler.py)
+        matchcompiler_S := $(shell $(PYTHON_INTERPRETER) tools/matchcompiler.py)
     endif
     libcppdir:=build
-else
+else ifeq ($(MATCHCOMPILER),)
     libcppdir:=lib
+else
+    $(error invalid MATCHCOMPILER value '$(MATCHCOMPILER)')
+endif
+
+ifndef CPPFLAGS
+    CPPFLAGS=
 endif
 
 ifdef FILESDIR
-    CPPFILESDIR=-DFILESDIR=\"$(FILESDIR)\"
-else
-    CPPFILESDIR=
+    override CPPFLAGS+=-DFILESDIR=\"$(FILESDIR)\"
 endif
 
-RDYNAMIC=-rdynamic
+RDYNAMIC?=-rdynamic
 # Set the CPPCHK_GLIBCXX_DEBUG flag. This flag is not used in release Makefiles.
 # The _GLIBCXX_DEBUG define doesn't work in Cygwin or other Win32 systems.
 ifndef COMSPEC
+    ifeq ($(VERBOSE),1)
+        $(info COMSPEC not found)
+    endif
     ifdef ComSpec
+        ifeq ($(VERBOSE),1)
+            $(info ComSpec found)
+        endif
         #### ComSpec is defined on some WIN32's.
-        COMSPEC=$(ComSpec)
+        WINNT=1
+
+        ifeq ($(VERBOSE),1)
+            $(info PATH=$(PATH))
+        endif
+
+        ifneq (,$(findstring /cygdrive/,$(PATH)))
+            ifeq ($(VERBOSE),1)
+                $(info /cygdrive/ found in PATH)
+            endif
+            CYGWIN=1
+        endif # CYGWIN
     endif # ComSpec
 endif # COMSPEC
 
-ifdef COMSPEC
+ifdef WINNT
+    ifeq ($(VERBOSE),1)
+        $(info WINNT found)
+    endif
     #### Maybe Windows
     ifndef CPPCHK_GLIBCXX_DEBUG
         CPPCHK_GLIBCXX_DEBUG=
     endif # !CPPCHK_GLIBCXX_DEBUG
 
-    ifeq ($(MSYSTEM),MINGW32 MINGW64)
-        LDFLAGS=-lshlwapi
-    else
-        RDYNAMIC=-lshlwapi
+    ifeq ($(VERBOSE),1)
+        $(info MSYSTEM=$(MSYSTEM))
     endif
-else # !COMSPEC
+
+    ifneq ($(MSYSTEM),MINGW32 MINGW64)
+        RDYNAMIC=
+    endif
+
+    LDFLAGS+=-lshlwapi
+else # !WINNT
+    ifeq ($(VERBOSE),1)
+        $(info WINNT not found)
+    endif
+
     uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')
 
+    ifeq ($(VERBOSE),1)
+        $(info uname_S=$(uname_S))
+    endif
+
     ifeq ($(uname_S),Linux)
         ifndef CPPCHK_GLIBCXX_DEBUG
             CPPCHK_GLIBCXX_DEBUG=-D_GLIBCXX_DEBUG
@@ -71,17 +111,18 @@ else # !COMSPEC
         endif # !CPPCHK_GLIBCXX_DEBUG
     endif # GNU/kFreeBSD
 
-endif # COMSPEC
+    LDFLAGS+=-pthread
 
-# Set the UNDEF_STRICT_ANSI flag to address compile time warnings
-# with tinyxml2 and Cygwin.
-ifdef COMSPEC
-    uname_S := $(shell uname -s)
+endif # WINNT
 
-    ifneq (,$(findstring CYGWIN,$(uname_S)))
-        UNDEF_STRICT_ANSI=-U__STRICT_ANSI__
-    endif # CYGWIN
-endif # COMSPEC
+ifdef CYGWIN
+    ifeq ($(VERBOSE),1)
+        $(info CYGWIN found)
+    endif
+
+    # Increase stack size for Cygwin builds to avoid segmentation fault in limited recursive tests.
+    CXXFLAGS+=-Wl,--stack,8388608
+endif # CYGWIN
 
 ifndef CXX
     CXX=g++
@@ -91,51 +132,58 @@ ifeq (clang++, $(findstring clang++,$(CXX)))
     CPPCHK_GLIBCXX_DEBUG=
 endif
 ifndef CXXFLAGS
-    CXXFLAGS=-pedantic -Wall -Wextra -Wcast-qual -Wno-deprecated-declarations -Wfloat-equal -Wmissing-declarations -Wmissing-format-attribute -Wno-long-long -Wpacked -Wredundant-decls -Wundef -Wno-shadow -Wno-missing-field-initializers -Wno-missing-braces -Wno-sign-compare -Wno-multichar $(CPPCHK_GLIBCXX_DEBUG) -g
+    CXXFLAGS=-pedantic -Wall -Wextra -Wcast-qual -Wfloat-equal -Wmissing-declarations -Wmissing-format-attribute -Wno-long-long -Wpacked -Wredundant-decls -Wundef -Wno-sign-compare -Wno-multichar -Woverloaded-virtual -g
 endif
 
-# Increase stack size for Cygwin builds to avoid segmentation fault in limited recursive tests.
-ifdef COMSPEC
-    uname_S := $(shell uname -s)
-
-    ifneq (,$(findstring CYGWIN,$(uname_S)))
-        CXXFLAGS+=-Wl,--stack,8388608
-    endif # CYGWIN
-endif # COMSPEC
-
 ifeq (g++, $(findstring g++,$(CXX)))
-    override CXXFLAGS += -std=c++0x
-else ifeq (clang++, $(findstring clang++,$(CXX)))
-    override CXXFLAGS += -std=c++0x
-else ifeq ($(CXX), c++)
-    ifeq ($(shell uname -s), Darwin)
-        override CXXFLAGS += -std=c++0x
-    endif
+    override CXXFLAGS += -pipe
 endif
-
+override CXXFLAGS += -std=c++11
 ifeq ($(HAVE_RULES),yes)
-    override CXXFLAGS += -DHAVE_RULES -DTIXML_USE_STL $(shell pcre-config --cflags)
+    PCRE_CONFIG = $(shell which pcre-config)
+    ifeq ($(PCRE_CONFIG),)
+        $(error Did not find pcre-config)
+    endif
+    override CXXFLAGS += $(shell $(PCRE_CONFIG) --cflags)
+    override CPPFLAGS += -DHAVE_RULES
     ifdef LIBS
-        LIBS += $(shell pcre-config --libs)
+        LIBS += $(shell $(PCRE_CONFIG) --libs)
     else
-        LIBS=$(shell pcre-config --libs)
+        LIBS=$(shell $(PCRE_CONFIG) --libs)
     endif
+else ifneq ($(HAVE_RULES),)
+    $(error invalid HAVE_RULES value '$(HAVE_RULES)')
 endif
 
+HAVE_EXECINFO_H=$(shell echo "\#include <execinfo.h>" | $(CXX) -c -xc - 2> /dev/null && echo "1" || echo "0")
+override CPPFLAGS += -DHAVE_EXECINFO_H=$(HAVE_EXECINFO_H)
+
+override CXXFLAGS += $(CXXOPTS)
+override CPPFLAGS += $(CPPOPTS)
+override LDFLAGS += $(LDOPTS)
+
 ifndef PREFIX
     PREFIX=/usr
 endif
 
 ifndef INCLUDE_FOR_LIB
-    INCLUDE_FOR_LIB=-Ilib -isystem externals -isystem externals/simplecpp -isystem externals/tinyxml
+    INCLUDE_FOR_LIB=-Ilib -isystem externals -isystem externals/picojson -isystem externals/simplecpp -isystem externals/tinyxml2
+endif
+
+ifndef INCLUDE_FOR_FE
+    INCLUDE_FOR_FE=-Ilib
 endif
 
 ifndef INCLUDE_FOR_CLI
-    INCLUDE_FOR_CLI=-Ilib -isystem externals/simplecpp -isystem externals/tinyxml
+    INCLUDE_FOR_CLI=-Ilib -Ifrontend -isystem externals/picojson -isystem externals/simplecpp -isystem externals/tinyxml2
 endif
 
 ifndef INCLUDE_FOR_TEST
-    INCLUDE_FOR_TEST=-Ilib -Icli -isystem externals/simplecpp -isystem externals/tinyxml
+    INCLUDE_FOR_TEST=-Ilib -Ifrontend -Icli -isystem externals/picojson -isystem externals/simplecpp -isystem externals/tinyxml2
+endif
+
+ifndef CFLAGS_FOR_TEST
+    CFLAGS_FOR_TEST=-Wno-dollar-in-identifier-extension
 endif
 
 BIN=$(DESTDIR)$(PREFIX)/bin
@@ -148,17 +196,23 @@ MAN_SOURCE=man/cppcheck.1.xml
 
 ###### Object Files
 
-LIBOBJ =      $(libcppdir)/analyzerinfo.o \
+LIBOBJ =      $(libcppdir)/valueflow.o \
+              $(libcppdir)/tokenize.o \
+              $(libcppdir)/symboldatabase.o \
+              $(libcppdir)/addoninfo.o \
+              $(libcppdir)/analyzerinfo.o \
               $(libcppdir)/astutils.o \
               $(libcppdir)/check.o \
               $(libcppdir)/check64bit.o \
               $(libcppdir)/checkassert.o \
               $(libcppdir)/checkautovariables.o \
               $(libcppdir)/checkbool.o \
-              $(libcppdir)/checkboost.o \
               $(libcppdir)/checkbufferoverrun.o \
               $(libcppdir)/checkclass.o \
               $(libcppdir)/checkcondition.o \
+              $(libcppdir)/checkers.o \
+              $(libcppdir)/checkersidmapping.o \
+              $(libcppdir)/checkersreport.o \
               $(libcppdir)/checkexceptionsafety.o \
               $(libcppdir)/checkfunctions.o \
               $(libcppdir)/checkinternal.o \
@@ -176,54 +230,87 @@ LIBOBJ =      $(libcppdir)/analyzerinfo.o \
               $(libcppdir)/checkunusedfunctions.o \
               $(libcppdir)/checkunusedvar.o \
               $(libcppdir)/checkvaarg.o \
+              $(libcppdir)/clangimport.o \
+              $(libcppdir)/color.o \
               $(libcppdir)/cppcheck.o \
               $(libcppdir)/ctu.o \
               $(libcppdir)/errorlogger.o \
-              $(libcppdir)/exprengine.o \
+              $(libcppdir)/errortypes.o \
+              $(libcppdir)/findtoken.o \
+              $(libcppdir)/forwardanalyzer.o \
+              $(libcppdir)/fwdanalysis.o \
               $(libcppdir)/importproject.o \
+              $(libcppdir)/infer.o \
+              $(libcppdir)/keywords.o \
               $(libcppdir)/library.o \
               $(libcppdir)/mathlib.o \
               $(libcppdir)/path.o \
+              $(libcppdir)/pathanalysis.o \
               $(libcppdir)/pathmatch.o \
               $(libcppdir)/platform.o \
               $(libcppdir)/preprocessor.o \
+              $(libcppdir)/programmemory.o \
+              $(libcppdir)/regex.o \
+              $(libcppdir)/reverseanalyzer.o \
+              $(libcppdir)/sarifreport.o \
               $(libcppdir)/settings.o \
+              $(libcppdir)/standards.o \
+              $(libcppdir)/summaries.o \
               $(libcppdir)/suppressions.o \
-              $(libcppdir)/symboldatabase.o \
               $(libcppdir)/templatesimplifier.o \
               $(libcppdir)/timer.o \
               $(libcppdir)/token.o \
-              $(libcppdir)/tokenize.o \
               $(libcppdir)/tokenlist.o \
-              $(libcppdir)/valueflow.o
+              $(libcppdir)/utils.o \
+              $(libcppdir)/vf_analyzers.o \
+              $(libcppdir)/vf_common.o \
+              $(libcppdir)/vf_settokenvalue.o \
+              $(libcppdir)/vfvalue.o
 
 EXTOBJ =      externals/simplecpp/simplecpp.o \
-              externals/tinyxml/tinyxml2.o
+              externals/tinyxml2/tinyxml2.o
+
+FEOBJ =       frontend/frontend.o
 
 CLIOBJ =      cli/cmdlineparser.o \
               cli/cppcheckexecutor.o \
+              cli/executor.o \
               cli/filelister.o \
               cli/main.o \
+              cli/processexecutor.o \
+              cli/sehwrapper.o \
+              cli/signalhandler.o \
+              cli/singleexecutor.o \
+              cli/stacktrace.o \
               cli/threadexecutor.o
 
-TESTOBJ =     test/options.o \
+TESTOBJ =     test/fixture.o \
+              test/helpers.o \
+              test/main.o \
+              test/options.o \
               test/test64bit.o \
+              test/testanalyzerinformation.o \
               test/testassert.o \
               test/testastutils.o \
               test/testautovariables.o \
               test/testbool.o \
-              test/testboost.o \
               test/testbufferoverrun.o \
               test/testcharvar.o \
+              test/testcheck.o \
+              test/testcheckersreport.o \
+              test/testclangimport.o \
               test/testclass.o \
               test/testcmdlineparser.o \
+              test/testcolor.o \
               test/testcondition.o \
               test/testconstructors.o \
               test/testcppcheck.o \
               test/testerrorlogger.o \
               test/testexceptionsafety.o \
-              test/testexprengine.o \
+              test/testexecutor.o \
               test/testfilelister.o \
+              test/testfilesettings.o \
+              test/testfrontend.o \
               test/testfunctions.o \
               test/testgarbage.o \
               test/testimportproject.o \
@@ -242,16 +329,21 @@ TESTOBJ =     test/options.o \
               test/testplatform.o \
               test/testpostfixoperator.o \
               test/testpreprocessor.o \
-              test/testrunner.o \
-              test/testsamples.o \
+              test/testprocessexecutor.o \
+              test/testprogrammemory.o \
+              test/testregex.o \
+              test/testsarifreport.o \
+              test/testsettings.o \
               test/testsimplifytemplate.o \
               test/testsimplifytokens.o \
               test/testsimplifytypedef.o \
               test/testsimplifyusing.o \
+              test/testsingleexecutor.o \
               test/testsizeof.o \
+              test/teststandards.o \
               test/teststl.o \
               test/teststring.o \
-              test/testsuite.o \
+              test/testsummaries.o \
               test/testsuppressions.o \
               test/testsymboldatabase.o \
               test/testthreadexecutor.o \
@@ -259,27 +351,30 @@ TESTOBJ =     test/options.o \
               test/testtoken.o \
               test/testtokenize.o \
               test/testtokenlist.o \
+              test/testtokenrange.o \
               test/testtype.o \
               test/testuninitvar.o \
               test/testunusedfunctions.o \
               test/testunusedprivfunc.o \
               test/testunusedvar.o \
+              test/testutils.o \
               test/testvaarg.o \
               test/testvalueflow.o \
-              test/testvarid.o
+              test/testvarid.o \
+              test/testvfvalue.o
 
 .PHONY: run-dmake tags
 
 
 ###### Targets
 
-cppcheck: $(LIBOBJ) $(CLIOBJ) $(EXTOBJ)
-	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -o $@ $^ $(LIBS) $(LDFLAGS) $(RDYNAMIC)
+cppcheck: $(EXTOBJ) $(LIBOBJ) $(FEOBJ) $(CLIOBJ)
+	$(CXX) $(CXXFLAGS) -o $@ $^ $(LIBS) $(LDFLAGS) $(RDYNAMIC)
 
 all:	cppcheck testrunner
 
-testrunner: $(TESTOBJ) $(LIBOBJ) $(EXTOBJ) cli/threadexecutor.o cli/cmdlineparser.o cli/cppcheckexecutor.o cli/filelister.o
-	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -o $@ $^ $(LIBS) $(LDFLAGS) $(RDYNAMIC)
+testrunner: $(EXTOBJ) $(TESTOBJ) $(LIBOBJ) $(FEOBJ) cli/cmdlineparser.o cli/cppcheckexecutor.o cli/executor.o cli/filelister.o cli/processexecutor.o cli/sehwrapper.o cli/signalhandler.o cli/singleexecutor.o cli/stacktrace.o cli/threadexecutor.o
+	$(CXX) $(CXXFLAGS) -o $@ $^ $(LIBS) $(LDFLAGS) $(RDYNAMIC)
 
 test:	all
 	./testrunner
@@ -290,16 +385,14 @@ check:	all
 checkcfg:	cppcheck validateCFG
 	./test/cfg/runtests.sh
 
-dmake:	tools/dmake.o cli/filelister.o $(libcppdir)/pathmatch.o $(libcppdir)/path.o externals/simplecpp/simplecpp.o
+dmake:	tools/dmake/dmake.o cli/filelister.o $(libcppdir)/pathmatch.o $(libcppdir)/path.o $(libcppdir)/utils.o externals/simplecpp/simplecpp.o
 	$(CXX) $(CXXFLAGS) -o $@ $^ $(LDFLAGS)
 
 run-dmake: dmake
 	./dmake
 
-generate_cfg_tests: tools/generate_cfg_tests.o $(EXTOBJ)
-	g++ -isystem externals/tinyxml -o generate_cfg_tests tools/generate_cfg_tests.o $(EXTOBJ)
 clean:
-	rm -f build/*.o lib/*.o cli/*.o test/*.o tools/*.o externals/*/*.o testrunner dmake cppcheck cppcheck.exe cppcheck.1
+	rm -f build/*.cpp build/*.o lib/*.o cli/*.o frontend/*.o test/*.o tools/dmake/*.o externals/*/*.o testrunner dmake cppcheck cppcheck.exe cppcheck.1
 
 man:	man/cppcheck.1
 
@@ -308,7 +401,7 @@ man/cppcheck.1:	$(MAN_SOURCE)
 	$(XP) $(DB2MAN) $(MAN_SOURCE)
 
 tags:
-	ctags -R --exclude=doxyoutput --exclude=test/cfg --exclude=test/synthetic cli externals gui lib test
+	ctags -R --exclude=doxyoutput --exclude=test/cfg cli externals gui lib test
 
 install: cppcheck
 	install -d ${BIN}
@@ -317,6 +410,7 @@ install: cppcheck
 ifdef FILESDIR
 	install -d ${DESTDIR}${FILESDIR}
 	install -d ${DESTDIR}${FILESDIR}/addons
+	install -m 644 addons/*.json ${DESTDIR}${FILESDIR}/addons
 	install -m 644 addons/*.py ${DESTDIR}${FILESDIR}/addons
 	install -d ${DESTDIR}${FILESDIR}/cfg
 	install -m 644 cfg/*.cfg ${DESTDIR}${FILESDIR}/cfg
@@ -338,16 +432,6 @@ ifdef FILESDIR
 	  rm -rf ${DESTDIR}${FILESDIR}; \
 	fi
 endif
-ifdef CFGDIR 
-	@if test -d ${DESTDIR}${CFGDIR}; then \
-	  files="`cd cfg 2>/dev/null && ls`"; \
-	  if test -n "$$files"; then \
-	    echo '(' cd ${DESTDIR}${CFGDIR} '&&' rm -f $$files ')'; \
-	    ( cd ${DESTDIR}${CFGDIR} && rm -f $$files ); \
-	  fi; \
-	fi
-endif
-
 # Validation of library files:
 ConfigFiles := $(wildcard cfg/*.cfg)
 ConfigFilesCHECKED := $(patsubst %.cfg,%.checked,$(ConfigFiles))
@@ -355,6 +439,7 @@ ConfigFilesCHECKED := $(patsubst %.cfg,%.checked,$(ConfigFiles))
 %.checked:%.cfg
 	xmllint --noout --relaxng cfg/cppcheck-cfg.rng $<
 validateCFG: ${ConfigFilesCHECKED}
+	xmllint --noout cfg/cppcheck-cfg.rng
 
 # Validation of platforms files:
 PlatformFiles := $(wildcard platforms/*.xml)
@@ -363,380 +448,520 @@ PlatformFilesCHECKED := $(patsubst %.xml,%.checked,$(PlatformFiles))
 %.checked:%.xml
 	xmllint --noout --relaxng platforms/cppcheck-platforms.rng $<
 validatePlatforms: ${PlatformFilesCHECKED}
+	xmllint --noout platforms/cppcheck-platforms.rng
 
 # Validate XML output (to detect regressions)
 /tmp/errorlist.xml: cppcheck
 	./cppcheck --errorlist >$@
 /tmp/example.xml: cppcheck
-	./cppcheck --xml --enable=all --inconclusive --suppress=operatorEqVarError:*check.h -j 4 cli externals gui lib test 2>/tmp/example.xml
+	./cppcheck --xml --enable=all --inconclusive --max-configs=1 samples 2>/tmp/example.xml
 createXMLExamples:/tmp/errorlist.xml /tmp/example.xml
 .PHONY: validateXML
 validateXML: createXMLExamples
+	xmllint --noout cppcheck-errors.rng
 	xmllint --noout --relaxng cppcheck-errors.rng /tmp/errorlist.xml
 	xmllint --noout --relaxng cppcheck-errors.rng /tmp/example.xml
 
 checkCWEEntries: /tmp/errorlist.xml
-	./tools/listErrorsWithoutCWE.py -F /tmp/errorlist.xml
+	$(eval PYTHON_INTERPRETER := $(if $(PYTHON_INTERPRETER),$(PYTHON_INTERPRETER),$(shell which python3)))
+	$(eval PYTHON_INTERPRETER := $(if $(PYTHON_INTERPRETER),$(PYTHON_INTERPRETER),$(shell which python)))
+	$(eval PYTHON_INTERPRETER := $(if $(PYTHON_INTERPRETER),$(PYTHON_INTERPRETER),$(error Did not find a Python interpreter)))
+	$(PYTHON_INTERPRETER) tools/listErrorsWithoutCWE.py -F /tmp/errorlist.xml
 .PHONY: validateRules
 validateRules:
 	xmllint --noout rules/*.xml
+.PHONY: check-nonneg
+check-nonneg:
+	ls lib/*.cpp | xargs -n 1 -P $$(nproc) g++ -fsyntax-only -DNONNEG $(CXXFLAGS) $(INCLUDE_FOR_LIB)
 
 ###### Build
 
-$(libcppdir)/analyzerinfo.o: lib/analyzerinfo.cpp externals/tinyxml/tinyxml2.h lib/analyzerinfo.h lib/config.h lib/errorlogger.h lib/importproject.h lib/path.h lib/platform.h lib/suppressions.h lib/utils.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/analyzerinfo.o $(libcppdir)/analyzerinfo.cpp
+$(libcppdir)/valueflow.o: lib/valueflow.cpp lib/addoninfo.h lib/analyzer.h lib/astutils.h lib/calculate.h lib/check.h lib/checkers.h lib/checkuninitvar.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/findtoken.h lib/forwardanalyzer.h lib/infer.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/programmemory.h lib/reverseanalyzer.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenlist.h lib/utils.h lib/valueflow.h lib/valueptr.h lib/vf_analyzers.h lib/vf_common.h lib/vf_settokenvalue.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/valueflow.cpp
 
-$(libcppdir)/astutils.o: lib/astutils.cpp lib/astutils.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/astutils.o $(libcppdir)/astutils.cpp
+$(libcppdir)/tokenize.o: lib/tokenize.cpp externals/simplecpp/simplecpp.h lib/addoninfo.h lib/astutils.h lib/checkers.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/preprocessor.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/summaries.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/tokenize.cpp
 
-$(libcppdir)/check.o: lib/check.cpp lib/check.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/check.o $(libcppdir)/check.cpp
+$(libcppdir)/symboldatabase.o: lib/symboldatabase.cpp lib/addoninfo.h lib/astutils.h lib/checkers.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/keywords.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/symboldatabase.cpp
 
-$(libcppdir)/check64bit.o: lib/check64bit.cpp lib/check.h lib/check64bit.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/check64bit.o $(libcppdir)/check64bit.cpp
+$(libcppdir)/addoninfo.o: lib/addoninfo.cpp externals/picojson/picojson.h lib/addoninfo.h lib/config.h lib/json.h lib/path.h lib/standards.h lib/utils.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/addoninfo.cpp
 
-$(libcppdir)/checkassert.o: lib/checkassert.cpp lib/check.h lib/checkassert.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkassert.o $(libcppdir)/checkassert.cpp
+$(libcppdir)/analyzerinfo.o: lib/analyzerinfo.cpp externals/tinyxml2/tinyxml2.h lib/analyzerinfo.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/filesettings.h lib/mathlib.h lib/path.h lib/platform.h lib/standards.h lib/utils.h lib/xml.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/analyzerinfo.cpp
 
-$(libcppdir)/checkautovariables.o: lib/checkautovariables.cpp lib/astutils.h lib/check.h lib/checkautovariables.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkautovariables.o $(libcppdir)/checkautovariables.cpp
+$(libcppdir)/astutils.o: lib/astutils.cpp lib/addoninfo.h lib/astutils.h lib/check.h lib/checkclass.h lib/checkers.h lib/config.h lib/errortypes.h lib/findtoken.h lib/infer.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/utils.h lib/valueflow.h lib/valueptr.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/astutils.cpp
 
-$(libcppdir)/checkbool.o: lib/checkbool.cpp lib/astutils.h lib/check.h lib/checkbool.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkbool.o $(libcppdir)/checkbool.cpp
+$(libcppdir)/check.o: lib/check.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/standards.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/check.cpp
 
-$(libcppdir)/checkboost.o: lib/checkboost.cpp lib/check.h lib/checkboost.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkboost.o $(libcppdir)/checkboost.cpp
+$(libcppdir)/check64bit.o: lib/check64bit.cpp lib/addoninfo.h lib/check.h lib/check64bit.h lib/checkers.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/check64bit.cpp
 
-$(libcppdir)/checkbufferoverrun.o: lib/checkbufferoverrun.cpp externals/tinyxml/tinyxml2.h lib/astutils.h lib/check.h lib/checkbufferoverrun.h lib/config.h lib/ctu.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkbufferoverrun.o $(libcppdir)/checkbufferoverrun.cpp
+$(libcppdir)/checkassert.o: lib/checkassert.cpp lib/addoninfo.h lib/astutils.h lib/check.h lib/checkassert.h lib/checkers.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkassert.cpp
 
-$(libcppdir)/checkclass.o: lib/checkclass.cpp lib/astutils.h lib/check.h lib/checkclass.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkclass.o $(libcppdir)/checkclass.cpp
+$(libcppdir)/checkautovariables.o: lib/checkautovariables.cpp lib/addoninfo.h lib/astutils.h lib/check.h lib/checkautovariables.h lib/checkers.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkautovariables.cpp
 
-$(libcppdir)/checkcondition.o: lib/checkcondition.cpp lib/astutils.h lib/check.h lib/checkcondition.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkcondition.o $(libcppdir)/checkcondition.cpp
+$(libcppdir)/checkbool.o: lib/checkbool.cpp lib/addoninfo.h lib/astutils.h lib/check.h lib/checkbool.h lib/checkers.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkbool.cpp
 
-$(libcppdir)/checkexceptionsafety.o: lib/checkexceptionsafety.cpp lib/check.h lib/checkexceptionsafety.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkexceptionsafety.o $(libcppdir)/checkexceptionsafety.cpp
+$(libcppdir)/checkbufferoverrun.o: lib/checkbufferoverrun.cpp externals/tinyxml2/tinyxml2.h lib/addoninfo.h lib/astutils.h lib/check.h lib/checkbufferoverrun.h lib/checkers.h lib/config.h lib/ctu.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h lib/vfvalue.h lib/xml.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkbufferoverrun.cpp
 
-$(libcppdir)/checkfunctions.o: lib/checkfunctions.cpp lib/astutils.h lib/check.h lib/checkfunctions.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkfunctions.o $(libcppdir)/checkfunctions.cpp
+$(libcppdir)/checkclass.o: lib/checkclass.cpp externals/tinyxml2/tinyxml2.h lib/addoninfo.h lib/astutils.h lib/check.h lib/checkclass.h lib/checkers.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h lib/xml.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkclass.cpp
 
-$(libcppdir)/checkinternal.o: lib/checkinternal.cpp lib/astutils.h lib/check.h lib/checkinternal.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkinternal.o $(libcppdir)/checkinternal.cpp
+$(libcppdir)/checkcondition.o: lib/checkcondition.cpp lib/addoninfo.h lib/astutils.h lib/check.h lib/checkcondition.h lib/checkers.h lib/checkother.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkcondition.cpp
 
-$(libcppdir)/checkio.o: lib/checkio.cpp lib/check.h lib/checkio.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkio.o $(libcppdir)/checkio.cpp
+$(libcppdir)/checkers.o: lib/checkers.cpp lib/checkers.h lib/config.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkers.cpp
 
-$(libcppdir)/checkleakautovar.o: lib/checkleakautovar.cpp lib/astutils.h lib/check.h lib/checkleakautovar.h lib/checkmemoryleak.h lib/checknullpointer.h lib/config.h lib/ctu.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkleakautovar.o $(libcppdir)/checkleakautovar.cpp
+$(libcppdir)/checkersidmapping.o: lib/checkersidmapping.cpp lib/checkers.h lib/config.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkersidmapping.cpp
 
-$(libcppdir)/checkmemoryleak.o: lib/checkmemoryleak.cpp lib/astutils.h lib/check.h lib/checkmemoryleak.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkmemoryleak.o $(libcppdir)/checkmemoryleak.cpp
+$(libcppdir)/checkersreport.o: lib/checkersreport.cpp lib/addoninfo.h lib/checkers.h lib/checkersreport.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/utils.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkersreport.cpp
 
-$(libcppdir)/checknullpointer.o: lib/checknullpointer.cpp lib/astutils.h lib/check.h lib/checknullpointer.h lib/config.h lib/ctu.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checknullpointer.o $(libcppdir)/checknullpointer.cpp
+$(libcppdir)/checkexceptionsafety.o: lib/checkexceptionsafety.cpp lib/addoninfo.h lib/astutils.h lib/check.h lib/checkers.h lib/checkexceptionsafety.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkexceptionsafety.cpp
 
-$(libcppdir)/checkother.o: lib/checkother.cpp lib/astutils.h lib/check.h lib/checkother.h lib/checkuninitvar.h lib/config.h lib/ctu.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkother.o $(libcppdir)/checkother.cpp
+$(libcppdir)/checkfunctions.o: lib/checkfunctions.cpp lib/addoninfo.h lib/astutils.h lib/check.h lib/checkers.h lib/checkfunctions.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkfunctions.cpp
 
-$(libcppdir)/checkpostfixoperator.o: lib/checkpostfixoperator.cpp lib/check.h lib/checkpostfixoperator.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkpostfixoperator.o $(libcppdir)/checkpostfixoperator.cpp
+$(libcppdir)/checkinternal.o: lib/checkinternal.cpp lib/addoninfo.h lib/astutils.h lib/check.h lib/checkers.h lib/checkinternal.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkinternal.cpp
 
-$(libcppdir)/checksizeof.o: lib/checksizeof.cpp lib/check.h lib/checksizeof.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checksizeof.o $(libcppdir)/checksizeof.cpp
+$(libcppdir)/checkio.o: lib/checkio.cpp lib/addoninfo.h lib/astutils.h lib/check.h lib/checkers.h lib/checkio.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkio.cpp
 
-$(libcppdir)/checkstl.o: lib/checkstl.cpp lib/astutils.h lib/check.h lib/checknullpointer.h lib/checkstl.h lib/config.h lib/ctu.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkstl.o $(libcppdir)/checkstl.cpp
+$(libcppdir)/checkleakautovar.o: lib/checkleakautovar.cpp lib/addoninfo.h lib/astutils.h lib/check.h lib/checkers.h lib/checkleakautovar.h lib/checkmemoryleak.h lib/checknullpointer.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkleakautovar.cpp
 
-$(libcppdir)/checkstring.o: lib/checkstring.cpp lib/astutils.h lib/check.h lib/checkstring.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkstring.o $(libcppdir)/checkstring.cpp
+$(libcppdir)/checkmemoryleak.o: lib/checkmemoryleak.cpp lib/addoninfo.h lib/astutils.h lib/check.h lib/checkers.h lib/checkmemoryleak.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkmemoryleak.cpp
 
-$(libcppdir)/checktype.o: lib/checktype.cpp lib/check.h lib/checktype.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checktype.o $(libcppdir)/checktype.cpp
+$(libcppdir)/checknullpointer.o: lib/checknullpointer.cpp lib/addoninfo.h lib/astutils.h lib/check.h lib/checkers.h lib/checknullpointer.h lib/config.h lib/ctu.h lib/errorlogger.h lib/errortypes.h lib/findtoken.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checknullpointer.cpp
 
-$(libcppdir)/checkuninitvar.o: lib/checkuninitvar.cpp externals/tinyxml/tinyxml2.h lib/astutils.h lib/check.h lib/checknullpointer.h lib/checkuninitvar.h lib/config.h lib/ctu.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkuninitvar.o $(libcppdir)/checkuninitvar.cpp
+$(libcppdir)/checkother.o: lib/checkother.cpp lib/addoninfo.h lib/astutils.h lib/check.h lib/checkers.h lib/checkother.h lib/config.h lib/errortypes.h lib/fwdanalysis.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkother.cpp
 
-$(libcppdir)/checkunusedfunctions.o: lib/checkunusedfunctions.cpp externals/tinyxml/tinyxml2.h lib/astutils.h lib/check.h lib/checkunusedfunctions.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkunusedfunctions.o $(libcppdir)/checkunusedfunctions.cpp
+$(libcppdir)/checkpostfixoperator.o: lib/checkpostfixoperator.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checkpostfixoperator.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkpostfixoperator.cpp
 
-$(libcppdir)/checkunusedvar.o: lib/checkunusedvar.cpp lib/astutils.h lib/check.h lib/checkunusedvar.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkunusedvar.o $(libcppdir)/checkunusedvar.cpp
+$(libcppdir)/checksizeof.o: lib/checksizeof.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checksizeof.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checksizeof.cpp
 
-$(libcppdir)/checkvaarg.o: lib/checkvaarg.cpp lib/astutils.h lib/check.h lib/checkvaarg.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/checkvaarg.o $(libcppdir)/checkvaarg.cpp
+$(libcppdir)/checkstl.o: lib/checkstl.cpp lib/addoninfo.h lib/astutils.h lib/check.h lib/checkers.h lib/checknullpointer.h lib/checkstl.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/pathanalysis.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkstl.cpp
 
-$(libcppdir)/cppcheck.o: lib/cppcheck.cpp externals/picojson.h externals/simplecpp/simplecpp.h externals/tinyxml/tinyxml2.h lib/analyzerinfo.h lib/check.h lib/checkunusedfunctions.h lib/config.h lib/cppcheck.h lib/ctu.h lib/errorlogger.h lib/exprengine.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/preprocessor.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h lib/version.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/cppcheck.o $(libcppdir)/cppcheck.cpp
+$(libcppdir)/checkstring.o: lib/checkstring.cpp lib/addoninfo.h lib/astutils.h lib/check.h lib/checkers.h lib/checkstring.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkstring.cpp
 
-$(libcppdir)/ctu.o: lib/ctu.cpp externals/tinyxml/tinyxml2.h lib/astutils.h lib/check.h lib/config.h lib/ctu.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/ctu.o $(libcppdir)/ctu.cpp
+$(libcppdir)/checktype.o: lib/checktype.cpp lib/addoninfo.h lib/astutils.h lib/check.h lib/checkers.h lib/checktype.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checktype.cpp
 
-$(libcppdir)/errorlogger.o: lib/errorlogger.cpp externals/tinyxml/tinyxml2.h lib/analyzerinfo.h lib/check.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/errorlogger.o $(libcppdir)/errorlogger.cpp
+$(libcppdir)/checkuninitvar.o: lib/checkuninitvar.cpp lib/addoninfo.h lib/astutils.h lib/check.h lib/checkers.h lib/checknullpointer.h lib/checkuninitvar.h lib/config.h lib/ctu.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkuninitvar.cpp
 
-$(libcppdir)/exprengine.o: lib/exprengine.cpp lib/astutils.h lib/config.h lib/errorlogger.h lib/exprengine.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/exprengine.o $(libcppdir)/exprengine.cpp
+$(libcppdir)/checkunusedfunctions.o: lib/checkunusedfunctions.cpp externals/tinyxml2/tinyxml2.h lib/addoninfo.h lib/analyzerinfo.h lib/astutils.h lib/checkers.h lib/checkunusedfunctions.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h lib/xml.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkunusedfunctions.cpp
 
-$(libcppdir)/importproject.o: lib/importproject.cpp externals/picojson.h externals/tinyxml/tinyxml2.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/importproject.o $(libcppdir)/importproject.cpp
+$(libcppdir)/checkunusedvar.o: lib/checkunusedvar.cpp lib/addoninfo.h lib/astutils.h lib/check.h lib/checkers.h lib/checkunusedvar.h lib/config.h lib/errortypes.h lib/fwdanalysis.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkunusedvar.cpp
 
-$(libcppdir)/library.o: lib/library.cpp externals/tinyxml/tinyxml2.h lib/astutils.h lib/config.h lib/errorlogger.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/library.o $(libcppdir)/library.cpp
+$(libcppdir)/checkvaarg.o: lib/checkvaarg.cpp lib/addoninfo.h lib/astutils.h lib/check.h lib/checkers.h lib/checkvaarg.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkvaarg.cpp
 
-$(libcppdir)/mathlib.o: lib/mathlib.cpp lib/config.h lib/errorlogger.h lib/mathlib.h lib/suppressions.h lib/utils.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/mathlib.o $(libcppdir)/mathlib.cpp
+$(libcppdir)/clangimport.o: lib/clangimport.cpp lib/clangimport.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/clangimport.cpp
 
-$(libcppdir)/path.o: lib/path.cpp externals/simplecpp/simplecpp.h lib/config.h lib/path.h lib/utils.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/path.o $(libcppdir)/path.cpp
+$(libcppdir)/color.o: lib/color.cpp lib/color.h lib/config.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/color.cpp
 
-$(libcppdir)/pathmatch.o: lib/pathmatch.cpp lib/config.h lib/path.h lib/pathmatch.h lib/utils.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/pathmatch.o $(libcppdir)/pathmatch.cpp
+$(libcppdir)/cppcheck.o: lib/cppcheck.cpp externals/picojson/picojson.h externals/simplecpp/simplecpp.h lib/addoninfo.h lib/analyzerinfo.h lib/check.h lib/checkers.h lib/checkunusedfunctions.h lib/clangimport.h lib/color.h lib/config.h lib/cppcheck.h lib/ctu.h lib/errorlogger.h lib/errortypes.h lib/filesettings.h lib/json.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/preprocessor.h lib/regex.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h lib/version.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/cppcheck.cpp
 
-$(libcppdir)/platform.o: lib/platform.cpp externals/tinyxml/tinyxml2.h lib/config.h lib/path.h lib/platform.h lib/utils.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/platform.o $(libcppdir)/platform.cpp
+$(libcppdir)/ctu.o: lib/ctu.cpp externals/tinyxml2/tinyxml2.h lib/astutils.h lib/check.h lib/config.h lib/ctu.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h lib/xml.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/ctu.cpp
 
-$(libcppdir)/preprocessor.o: lib/preprocessor.cpp externals/simplecpp/simplecpp.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/preprocessor.h lib/settings.h lib/standards.h lib/suppressions.h lib/timer.h lib/utils.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/preprocessor.o $(libcppdir)/preprocessor.cpp
+$(libcppdir)/errorlogger.o: lib/errorlogger.cpp externals/tinyxml2/tinyxml2.h lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/token.h lib/tokenlist.h lib/utils.h lib/vfvalue.h lib/xml.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/errorlogger.cpp
 
-$(libcppdir)/settings.o: lib/settings.cpp lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/timer.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/settings.o $(libcppdir)/settings.cpp
+$(libcppdir)/errortypes.o: lib/errortypes.cpp lib/config.h lib/errortypes.h lib/utils.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/errortypes.cpp
 
-$(libcppdir)/suppressions.o: lib/suppressions.cpp externals/tinyxml/tinyxml2.h lib/config.h lib/errorlogger.h lib/mathlib.h lib/path.h lib/suppressions.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/suppressions.o $(libcppdir)/suppressions.cpp
+$(libcppdir)/findtoken.o: lib/findtoken.cpp lib/astutils.h lib/config.h lib/errortypes.h lib/findtoken.h lib/library.h lib/mathlib.h lib/smallvector.h lib/standards.h lib/templatesimplifier.h lib/token.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/findtoken.cpp
 
-$(libcppdir)/symboldatabase.o: lib/symboldatabase.cpp lib/astutils.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/symboldatabase.o $(libcppdir)/symboldatabase.cpp
+$(libcppdir)/forwardanalyzer.o: lib/forwardanalyzer.cpp lib/addoninfo.h lib/analyzer.h lib/astutils.h lib/checkers.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/forwardanalyzer.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenlist.h lib/utils.h lib/valueptr.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/forwardanalyzer.cpp
 
-$(libcppdir)/templatesimplifier.o: lib/templatesimplifier.cpp lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/templatesimplifier.o $(libcppdir)/templatesimplifier.cpp
+$(libcppdir)/fwdanalysis.o: lib/fwdanalysis.cpp lib/addoninfo.h lib/astutils.h lib/checkers.h lib/config.h lib/errortypes.h lib/fwdanalysis.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/fwdanalysis.cpp
+
+$(libcppdir)/importproject.o: lib/importproject.cpp externals/picojson/picojson.h externals/tinyxml2/tinyxml2.h lib/addoninfo.h lib/checkers.h lib/config.h lib/errortypes.h lib/filesettings.h lib/importproject.h lib/json.h lib/library.h lib/mathlib.h lib/path.h lib/pathmatch.h lib/platform.h lib/settings.h lib/smallvector.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/token.h lib/tokenlist.h lib/utils.h lib/vfvalue.h lib/xml.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/importproject.cpp
+
+$(libcppdir)/infer.o: lib/infer.cpp lib/calculate.h lib/config.h lib/errortypes.h lib/infer.h lib/mathlib.h lib/smallvector.h lib/templatesimplifier.h lib/token.h lib/utils.h lib/valueptr.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/infer.cpp
+
+$(libcppdir)/keywords.o: lib/keywords.cpp lib/config.h lib/keywords.h lib/standards.h lib/utils.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/keywords.cpp
+
+$(libcppdir)/library.o: lib/library.cpp externals/tinyxml2/tinyxml2.h lib/astutils.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenlist.h lib/utils.h lib/vfvalue.h lib/xml.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/library.cpp
+
+$(libcppdir)/mathlib.o: lib/mathlib.cpp externals/simplecpp/simplecpp.h lib/config.h lib/errortypes.h lib/mathlib.h lib/smallvector.h lib/templatesimplifier.h lib/token.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/mathlib.cpp
+
+$(libcppdir)/path.o: lib/path.cpp externals/simplecpp/simplecpp.h lib/config.h lib/path.h lib/standards.h lib/utils.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/path.cpp
+
+$(libcppdir)/pathanalysis.o: lib/pathanalysis.cpp lib/astutils.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/pathanalysis.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/pathanalysis.cpp
+
+$(libcppdir)/pathmatch.o: lib/pathmatch.cpp lib/config.h lib/path.h lib/pathmatch.h lib/standards.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/pathmatch.cpp
+
+$(libcppdir)/platform.o: lib/platform.cpp externals/tinyxml2/tinyxml2.h lib/config.h lib/mathlib.h lib/path.h lib/platform.h lib/standards.h lib/utils.h lib/xml.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/platform.cpp
+
+$(libcppdir)/preprocessor.o: lib/preprocessor.cpp externals/simplecpp/simplecpp.h lib/addoninfo.h lib/checkers.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/preprocessor.h lib/settings.h lib/standards.h lib/suppressions.h lib/utils.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/preprocessor.cpp
+
+$(libcppdir)/programmemory.o: lib/programmemory.cpp lib/addoninfo.h lib/astutils.h lib/calculate.h lib/checkers.h lib/config.h lib/errortypes.h lib/infer.h lib/library.h lib/mathlib.h lib/platform.h lib/programmemory.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenlist.h lib/utils.h lib/valueflow.h lib/valueptr.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/programmemory.cpp
+
+$(libcppdir)/regex.o: lib/regex.cpp lib/config.h lib/regex.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/regex.cpp
+
+$(libcppdir)/reverseanalyzer.o: lib/reverseanalyzer.cpp lib/addoninfo.h lib/analyzer.h lib/astutils.h lib/checkers.h lib/config.h lib/errortypes.h lib/forwardanalyzer.h lib/library.h lib/mathlib.h lib/platform.h lib/reverseanalyzer.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/utils.h lib/valueptr.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/reverseanalyzer.cpp
+
+$(libcppdir)/sarifreport.o: lib/sarifreport.cpp externals/picojson/picojson.h lib/addoninfo.h lib/check.h lib/checkers.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/errortypes.h lib/json.h lib/library.h lib/mathlib.h lib/platform.h lib/sarifreport.h lib/settings.h lib/standards.h lib/utils.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/sarifreport.cpp
+
+$(libcppdir)/settings.o: lib/settings.cpp externals/picojson/picojson.h lib/addoninfo.h lib/checkers.h lib/config.h lib/errortypes.h lib/json.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/summaries.h lib/suppressions.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/settings.cpp
+
+$(libcppdir)/standards.o: lib/standards.cpp externals/simplecpp/simplecpp.h lib/config.h lib/standards.h lib/utils.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/standards.cpp
+
+$(libcppdir)/summaries.o: lib/summaries.cpp lib/addoninfo.h lib/analyzerinfo.h lib/checkers.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/summaries.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/summaries.cpp
+
+$(libcppdir)/suppressions.o: lib/suppressions.cpp externals/tinyxml2/tinyxml2.h lib/addoninfo.h lib/checkers.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/filesettings.h lib/library.h lib/mathlib.h lib/path.h lib/pathmatch.h lib/platform.h lib/settings.h lib/smallvector.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h lib/xml.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/suppressions.cpp
+
+$(libcppdir)/templatesimplifier.o: lib/templatesimplifier.cpp lib/addoninfo.h lib/checkers.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/standards.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/templatesimplifier.cpp
 
 $(libcppdir)/timer.o: lib/timer.cpp lib/config.h lib/timer.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/timer.o $(libcppdir)/timer.cpp
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/timer.cpp
+
+$(libcppdir)/token.o: lib/token.cpp externals/simplecpp/simplecpp.h lib/addoninfo.h lib/astutils.h lib/checkers.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenlist.h lib/tokenrange.h lib/utils.h lib/valueflow.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/token.cpp
+
+$(libcppdir)/tokenlist.o: lib/tokenlist.cpp externals/simplecpp/simplecpp.h lib/addoninfo.h lib/astutils.h lib/checkers.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/keywords.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/standards.h lib/templatesimplifier.h lib/token.h lib/tokenlist.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/tokenlist.cpp
+
+$(libcppdir)/utils.o: lib/utils.cpp lib/config.h lib/utils.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/utils.cpp
+
+$(libcppdir)/vf_analyzers.o: lib/vf_analyzers.cpp lib/addoninfo.h lib/analyzer.h lib/astutils.h lib/calculate.h lib/checkers.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/programmemory.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/utils.h lib/valueflow.h lib/valueptr.h lib/vf_analyzers.h lib/vf_common.h lib/vf_settokenvalue.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/vf_analyzers.cpp
 
-$(libcppdir)/token.o: lib/token.cpp lib/astutils.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/token.o $(libcppdir)/token.cpp
+$(libcppdir)/vf_common.o: lib/vf_common.cpp lib/addoninfo.h lib/astutils.h lib/checkers.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/utils.h lib/vf_common.h lib/vf_settokenvalue.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/vf_common.cpp
 
-$(libcppdir)/tokenize.o: lib/tokenize.cpp lib/check.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/tokenize.o $(libcppdir)/tokenize.cpp
+$(libcppdir)/vf_settokenvalue.o: lib/vf_settokenvalue.cpp lib/addoninfo.h lib/astutils.h lib/calculate.h lib/checkers.h lib/config.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/utils.h lib/valueflow.h lib/vf_common.h lib/vf_settokenvalue.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/vf_settokenvalue.cpp
 
-$(libcppdir)/tokenlist.o: lib/tokenlist.cpp externals/simplecpp/simplecpp.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/tokenlist.o $(libcppdir)/tokenlist.cpp
+$(libcppdir)/vfvalue.o: lib/vfvalue.cpp lib/config.h lib/errortypes.h lib/mathlib.h lib/smallvector.h lib/templatesimplifier.h lib/token.h lib/utils.h lib/vfvalue.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/vfvalue.cpp
 
-$(libcppdir)/valueflow.o: lib/valueflow.cpp lib/astutils.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o $(libcppdir)/valueflow.o $(libcppdir)/valueflow.cpp
+frontend/frontend.o: frontend/frontend.cpp frontend/frontend.h lib/addoninfo.h lib/checkers.h lib/config.h lib/errortypes.h lib/filesettings.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/utils.h
+	$(CXX) ${INCLUDE_FOR_FE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ frontend/frontend.cpp
 
-cli/cmdlineparser.o: cli/cmdlineparser.cpp cli/cmdlineparser.h cli/cppcheckexecutor.h cli/filelister.h cli/threadexecutor.h externals/tinyxml/tinyxml2.h lib/check.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_CLI} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o cli/cmdlineparser.o cli/cmdlineparser.cpp
+cli/cmdlineparser.o: cli/cmdlineparser.cpp cli/cmdlinelogger.h cli/cmdlineparser.h cli/filelister.h externals/tinyxml2/tinyxml2.h lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/errortypes.h lib/filesettings.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/pathmatch.h lib/platform.h lib/regex.h lib/settings.h lib/standards.h lib/suppressions.h lib/timer.h lib/utils.h lib/xml.h
+	$(CXX) ${INCLUDE_FOR_CLI} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ cli/cmdlineparser.cpp
 
-cli/cppcheckexecutor.o: cli/cppcheckexecutor.cpp cli/cmdlineparser.h cli/cppcheckexecutor.h cli/filelister.h cli/threadexecutor.h externals/simplecpp/simplecpp.h lib/analyzerinfo.h lib/check.h lib/checkunusedfunctions.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/pathmatch.h lib/platform.h lib/preprocessor.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_CLI} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o cli/cppcheckexecutor.o cli/cppcheckexecutor.cpp
+cli/cppcheckexecutor.o: cli/cppcheckexecutor.cpp cli/cmdlinelogger.h cli/cmdlineparser.h cli/cppcheckexecutor.h cli/executor.h cli/processexecutor.h cli/sehwrapper.h cli/signalhandler.h cli/singleexecutor.h cli/threadexecutor.h externals/picojson/picojson.h lib/addoninfo.h lib/analyzerinfo.h lib/check.h lib/checkers.h lib/checkersreport.h lib/color.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/errortypes.h lib/filesettings.h lib/json.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/sarifreport.h lib/settings.h lib/standards.h lib/suppressions.h lib/timer.h lib/utils.h
+	$(CXX) ${INCLUDE_FOR_CLI} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ cli/cppcheckexecutor.cpp
 
-cli/filelister.o: cli/filelister.cpp cli/filelister.h lib/config.h lib/path.h lib/pathmatch.h lib/utils.h
-	$(CXX) ${INCLUDE_FOR_CLI} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o cli/filelister.o cli/filelister.cpp
+cli/executor.o: cli/executor.cpp cli/executor.h lib/addoninfo.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/utils.h
+	$(CXX) ${INCLUDE_FOR_CLI} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ cli/executor.cpp
 
-cli/main.o: cli/main.cpp cli/cppcheckexecutor.h lib/config.h lib/errorlogger.h lib/suppressions.h
-	$(CXX) ${INCLUDE_FOR_CLI} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o cli/main.o cli/main.cpp
+cli/filelister.o: cli/filelister.cpp cli/filelister.h lib/config.h lib/filesettings.h lib/mathlib.h lib/path.h lib/pathmatch.h lib/platform.h lib/standards.h lib/utils.h
+	$(CXX) ${INCLUDE_FOR_CLI} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ cli/filelister.cpp
 
-cli/threadexecutor.o: cli/threadexecutor.cpp cli/cppcheckexecutor.h cli/threadexecutor.h lib/analyzerinfo.h lib/check.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h
-	$(CXX) ${INCLUDE_FOR_CLI} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o cli/threadexecutor.o cli/threadexecutor.cpp
+cli/main.o: cli/main.cpp cli/cppcheckexecutor.h lib/config.h lib/filesettings.h lib/mathlib.h lib/path.h lib/platform.h lib/standards.h lib/utils.h
+	$(CXX) ${INCLUDE_FOR_CLI} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ cli/main.cpp
+
+cli/processexecutor.o: cli/processexecutor.cpp cli/executor.h cli/processexecutor.h lib/addoninfo.h lib/check.h lib/checkers.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/errortypes.h lib/filesettings.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/timer.h lib/utils.h
+	$(CXX) ${INCLUDE_FOR_CLI} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ cli/processexecutor.cpp
+
+cli/sehwrapper.o: cli/sehwrapper.cpp cli/sehwrapper.h lib/config.h lib/utils.h
+	$(CXX) ${INCLUDE_FOR_CLI} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ cli/sehwrapper.cpp
+
+cli/signalhandler.o: cli/signalhandler.cpp cli/signalhandler.h cli/stacktrace.h lib/config.h
+	$(CXX) ${INCLUDE_FOR_CLI} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ cli/signalhandler.cpp
+
+cli/singleexecutor.o: cli/singleexecutor.cpp cli/executor.h cli/singleexecutor.h lib/addoninfo.h lib/check.h lib/checkers.h lib/config.h lib/cppcheck.h lib/errortypes.h lib/filesettings.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/timer.h lib/utils.h
+	$(CXX) ${INCLUDE_FOR_CLI} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ cli/singleexecutor.cpp
+
+cli/stacktrace.o: cli/stacktrace.cpp cli/stacktrace.h lib/config.h lib/utils.h
+	$(CXX) ${INCLUDE_FOR_CLI} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ cli/stacktrace.cpp
+
+cli/threadexecutor.o: cli/threadexecutor.cpp cli/executor.h cli/threadexecutor.h lib/addoninfo.h lib/check.h lib/checkers.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/errortypes.h lib/filesettings.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/timer.h lib/utils.h
+	$(CXX) ${INCLUDE_FOR_CLI} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ cli/threadexecutor.cpp
+
+test/fixture.o: test/fixture.cpp externals/tinyxml2/tinyxml2.h lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/xml.h test/fixture.h test/helpers.h test/options.h test/redirect.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/fixture.cpp
+
+test/helpers.o: test/helpers.cpp cli/filelister.h externals/simplecpp/simplecpp.h externals/tinyxml2/tinyxml2.h lib/addoninfo.h lib/checkers.h lib/config.h lib/errortypes.h lib/filesettings.h lib/library.h lib/mathlib.h lib/path.h lib/pathmatch.h lib/platform.h lib/preprocessor.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/xml.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/helpers.cpp
+
+test/main.o: test/main.cpp externals/simplecpp/simplecpp.h lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/preprocessor.h lib/settings.h lib/standards.h lib/utils.h test/fixture.h test/options.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/main.cpp
 
 test/options.o: test/options.cpp test/options.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/options.o test/options.cpp
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/options.cpp
 
-test/test64bit.o: test/test64bit.cpp lib/check.h lib/check64bit.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/test64bit.o test/test64bit.cpp
+test/test64bit.o: test/test64bit.cpp lib/addoninfo.h lib/check.h lib/check64bit.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/test64bit.cpp
 
-test/testassert.o: test/testassert.cpp lib/check.h lib/checkassert.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testassert.o test/testassert.cpp
+test/testanalyzerinformation.o: test/testanalyzerinformation.cpp externals/tinyxml2/tinyxml2.h lib/addoninfo.h lib/analyzerinfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/filesettings.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/utils.h lib/xml.h test/fixture.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testanalyzerinformation.cpp
 
-test/testastutils.o: test/testastutils.cpp lib/astutils.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testastutils.o test/testastutils.cpp
+test/testassert.o: test/testassert.cpp lib/addoninfo.h lib/check.h lib/checkassert.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testassert.cpp
 
-test/testautovariables.o: test/testautovariables.cpp lib/check.h lib/checkautovariables.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testautovariables.o test/testautovariables.cpp
+test/testastutils.o: test/testastutils.cpp lib/addoninfo.h lib/astutils.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testastutils.cpp
 
-test/testbool.o: test/testbool.cpp lib/check.h lib/checkbool.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testbool.o test/testbool.cpp
+test/testautovariables.o: test/testautovariables.cpp lib/addoninfo.h lib/check.h lib/checkautovariables.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testautovariables.cpp
 
-test/testboost.o: test/testboost.cpp lib/check.h lib/checkboost.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testboost.o test/testboost.cpp
+test/testbool.o: test/testbool.cpp lib/addoninfo.h lib/check.h lib/checkbool.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testbool.cpp
 
-test/testbufferoverrun.o: test/testbufferoverrun.cpp externals/tinyxml/tinyxml2.h lib/check.h lib/checkbufferoverrun.h lib/config.h lib/ctu.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testbufferoverrun.o test/testbufferoverrun.cpp
+test/testbufferoverrun.o: test/testbufferoverrun.cpp lib/addoninfo.h lib/check.h lib/checkbufferoverrun.h lib/checkers.h lib/color.h lib/config.h lib/ctu.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testbufferoverrun.cpp
 
-test/testcharvar.o: test/testcharvar.cpp lib/check.h lib/checkother.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testcharvar.o test/testcharvar.cpp
+test/testcharvar.o: test/testcharvar.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checkother.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testcharvar.cpp
 
-test/testclass.o: test/testclass.cpp externals/tinyxml/tinyxml2.h lib/check.h lib/checkclass.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testclass.o test/testclass.cpp
+test/testcheck.o: test/testcheck.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/utils.h test/fixture.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testcheck.cpp
 
-test/testcmdlineparser.o: test/testcmdlineparser.cpp cli/cmdlineparser.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/timer.h lib/utils.h test/redirect.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testcmdlineparser.o test/testcmdlineparser.cpp
+test/testcheckersreport.o: test/testcheckersreport.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checkersreport.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/utils.h test/fixture.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testcheckersreport.cpp
 
-test/testcondition.o: test/testcondition.cpp externals/simplecpp/simplecpp.h externals/tinyxml/tinyxml2.h lib/check.h lib/checkcondition.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testcondition.o test/testcondition.cpp
+test/testclangimport.o: test/testclangimport.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/clangimport.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testclangimport.cpp
 
-test/testconstructors.o: test/testconstructors.cpp lib/check.h lib/checkclass.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testconstructors.o test/testconstructors.cpp
+test/testclass.o: test/testclass.cpp lib/addoninfo.h lib/check.h lib/checkclass.h lib/checkers.h lib/color.h lib/config.h lib/ctu.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testclass.cpp
 
-test/testcppcheck.o: test/testcppcheck.cpp lib/analyzerinfo.h lib/check.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testcppcheck.o test/testcppcheck.cpp
+test/testcmdlineparser.o: test/testcmdlineparser.cpp cli/cmdlinelogger.h cli/cmdlineparser.h lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/filesettings.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/timer.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h test/redirect.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testcmdlineparser.cpp
 
-test/testerrorlogger.o: test/testerrorlogger.cpp lib/analyzerinfo.h lib/check.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testerrorlogger.o test/testerrorlogger.cpp
+test/testcolor.o: test/testcolor.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/utils.h test/fixture.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testcolor.cpp
 
-test/testexceptionsafety.o: test/testexceptionsafety.cpp lib/check.h lib/checkexceptionsafety.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testexceptionsafety.o test/testexceptionsafety.cpp
+test/testcondition.o: test/testcondition.cpp lib/addoninfo.h lib/check.h lib/checkcondition.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testcondition.cpp
 
-test/testexprengine.o: test/testexprengine.cpp lib/config.h lib/errorlogger.h lib/exprengine.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testexprengine.o test/testexprengine.cpp
+test/testconstructors.o: test/testconstructors.cpp lib/addoninfo.h lib/check.h lib/checkclass.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testconstructors.cpp
 
-test/testfilelister.o: test/testfilelister.cpp cli/filelister.h lib/config.h lib/errorlogger.h lib/pathmatch.h lib/suppressions.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testfilelister.o test/testfilelister.cpp
+test/testcppcheck.o: test/testcppcheck.cpp externals/simplecpp/simplecpp.h lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/errortypes.h lib/filesettings.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/preprocessor.h lib/settings.h lib/standards.h lib/suppressions.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h test/redirect.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testcppcheck.cpp
 
-test/testfunctions.o: test/testfunctions.cpp externals/tinyxml/tinyxml2.h lib/check.h lib/checkfunctions.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testfunctions.o test/testfunctions.cpp
+test/testerrorlogger.o: test/testerrorlogger.cpp externals/tinyxml2/tinyxml2.h lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/xml.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testerrorlogger.cpp
 
-test/testgarbage.o: test/testgarbage.cpp lib/check.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testgarbage.o test/testgarbage.cpp
+test/testexceptionsafety.o: test/testexceptionsafety.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checkexceptionsafety.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testexceptionsafety.cpp
 
-test/testimportproject.o: test/testimportproject.cpp lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/timer.h lib/utils.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testimportproject.o test/testimportproject.cpp
+test/testexecutor.o: test/testexecutor.cpp cli/executor.h lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/filesettings.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testexecutor.cpp
 
-test/testincompletestatement.o: test/testincompletestatement.cpp externals/simplecpp/simplecpp.h lib/check.h lib/checkother.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testincompletestatement.o test/testincompletestatement.cpp
+test/testfilelister.o: test/testfilelister.cpp cli/filelister.h lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/filesettings.h lib/library.h lib/mathlib.h lib/path.h lib/pathmatch.h lib/platform.h lib/settings.h lib/standards.h lib/utils.h test/fixture.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testfilelister.cpp
 
-test/testinternal.o: test/testinternal.cpp lib/check.h lib/checkinternal.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testinternal.o test/testinternal.cpp
+test/testfilesettings.o: test/testfilesettings.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/filesettings.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/utils.h test/fixture.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testfilesettings.cpp
 
-test/testio.o: test/testio.cpp lib/check.h lib/checkio.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testio.o test/testio.cpp
+test/testfrontend.o: test/testfrontend.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/filesettings.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/utils.h test/fixture.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testfrontend.cpp
 
-test/testleakautovar.o: test/testleakautovar.cpp externals/simplecpp/simplecpp.h externals/tinyxml/tinyxml2.h lib/check.h lib/checkleakautovar.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testleakautovar.o test/testleakautovar.cpp
+test/testfunctions.o: test/testfunctions.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checkfunctions.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testfunctions.cpp
 
-test/testlibrary.o: test/testlibrary.cpp externals/tinyxml/tinyxml2.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testlibrary.o test/testlibrary.cpp
+test/testgarbage.o: test/testgarbage.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/standards.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testgarbage.cpp
 
-test/testmathlib.o: test/testmathlib.cpp lib/config.h lib/errorlogger.h lib/mathlib.h lib/suppressions.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testmathlib.o test/testmathlib.cpp
+test/testimportproject.o: test/testimportproject.cpp externals/tinyxml2/tinyxml2.h lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/filesettings.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/utils.h lib/xml.h test/fixture.h test/redirect.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testimportproject.cpp
 
-test/testmemleak.o: test/testmemleak.cpp externals/simplecpp/simplecpp.h lib/check.h lib/checkmemoryleak.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/preprocessor.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testmemleak.o test/testmemleak.cpp
+test/testincompletestatement.o: test/testincompletestatement.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checkother.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testincompletestatement.cpp
 
-test/testnullpointer.o: test/testnullpointer.cpp externals/simplecpp/simplecpp.h externals/tinyxml/tinyxml2.h lib/check.h lib/checknullpointer.h lib/checkuninitvar.h lib/config.h lib/ctu.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testnullpointer.o test/testnullpointer.cpp
+test/testinternal.o: test/testinternal.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checkinternal.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testinternal.cpp
 
-test/testoptions.o: test/testoptions.cpp lib/config.h lib/errorlogger.h lib/suppressions.h test/options.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testoptions.o test/testoptions.cpp
+test/testio.o: test/testio.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checkio.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testio.cpp
 
-test/testother.o: test/testother.cpp externals/simplecpp/simplecpp.h externals/tinyxml/tinyxml2.h lib/check.h lib/checkother.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testother.o test/testother.cpp
+test/testleakautovar.o: test/testleakautovar.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checkleakautovar.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testleakautovar.cpp
 
-test/testpath.o: test/testpath.cpp lib/config.h lib/errorlogger.h lib/path.h lib/suppressions.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testpath.o test/testpath.cpp
+test/testlibrary.o: test/testlibrary.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/standards.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testlibrary.cpp
 
-test/testpathmatch.o: test/testpathmatch.cpp lib/config.h lib/errorlogger.h lib/pathmatch.h lib/suppressions.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testpathmatch.o test/testpathmatch.cpp
+test/testmathlib.o: test/testmathlib.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/smallvector.h lib/standards.h lib/templatesimplifier.h lib/token.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testmathlib.cpp
 
-test/testplatform.o: test/testplatform.cpp externals/tinyxml/tinyxml2.h lib/config.h lib/errorlogger.h lib/platform.h lib/suppressions.h lib/utils.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testplatform.o test/testplatform.cpp
+test/testmemleak.o: test/testmemleak.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checkmemoryleak.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testmemleak.cpp
 
-test/testpostfixoperator.o: test/testpostfixoperator.cpp lib/check.h lib/checkpostfixoperator.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testpostfixoperator.o test/testpostfixoperator.cpp
+test/testnullpointer.o: test/testnullpointer.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checknullpointer.h lib/color.h lib/config.h lib/ctu.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/standards.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testnullpointer.cpp
 
-test/testpreprocessor.o: test/testpreprocessor.cpp externals/simplecpp/simplecpp.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/preprocessor.h lib/settings.h lib/standards.h lib/suppressions.h lib/timer.h lib/utils.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testpreprocessor.o test/testpreprocessor.cpp
+test/testoptions.o: test/testoptions.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/utils.h test/fixture.h test/options.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testoptions.cpp
 
-test/testrunner.o: test/testrunner.cpp externals/simplecpp/simplecpp.h lib/config.h lib/errorlogger.h lib/preprocessor.h lib/suppressions.h test/options.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testrunner.o test/testrunner.cpp
+test/testother.o: test/testother.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checkother.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testother.cpp
 
-test/testsamples.o: test/testsamples.cpp cli/cppcheckexecutor.h cli/filelister.h lib/analyzerinfo.h lib/check.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/pathmatch.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/redirect.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testsamples.o test/testsamples.cpp
+test/testpath.o: test/testpath.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testpath.cpp
 
-test/testsimplifytemplate.o: test/testsimplifytemplate.cpp lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testsimplifytemplate.o test/testsimplifytemplate.cpp
+test/testpathmatch.o: test/testpathmatch.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/pathmatch.h lib/platform.h lib/settings.h lib/standards.h lib/utils.h test/fixture.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testpathmatch.cpp
 
-test/testsimplifytokens.o: test/testsimplifytokens.cpp lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testsimplifytokens.o test/testsimplifytokens.cpp
+test/testplatform.o: test/testplatform.cpp externals/tinyxml2/tinyxml2.h lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/utils.h lib/xml.h test/fixture.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testplatform.cpp
 
-test/testsimplifytypedef.o: test/testsimplifytypedef.cpp lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testsimplifytypedef.o test/testsimplifytypedef.cpp
+test/testpostfixoperator.o: test/testpostfixoperator.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checkpostfixoperator.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testpostfixoperator.cpp
 
-test/testsimplifyusing.o: test/testsimplifyusing.cpp lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testsimplifyusing.o test/testsimplifyusing.cpp
+test/testpreprocessor.o: test/testpreprocessor.cpp externals/simplecpp/simplecpp.h lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/preprocessor.h lib/settings.h lib/standards.h lib/suppressions.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testpreprocessor.cpp
 
-test/testsizeof.o: test/testsizeof.cpp externals/simplecpp/simplecpp.h lib/check.h lib/checksizeof.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testsizeof.o test/testsizeof.cpp
+test/testprocessexecutor.o: test/testprocessexecutor.cpp cli/executor.h cli/processexecutor.h lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/errortypes.h lib/filesettings.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/timer.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h test/redirect.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testprocessexecutor.cpp
 
-test/teststl.o: test/teststl.cpp lib/check.h lib/checkstl.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/teststl.o test/teststl.cpp
+test/testprogrammemory.o: test/testprogrammemory.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/programmemory.h lib/settings.h lib/smallvector.h lib/standards.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testprogrammemory.cpp
 
-test/teststring.o: test/teststring.cpp lib/check.h lib/checkstring.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/teststring.o test/teststring.cpp
+test/testregex.o: test/testregex.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/regex.h lib/settings.h lib/standards.h lib/utils.h test/fixture.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testregex.cpp
 
-test/testsuite.o: test/testsuite.cpp lib/config.h lib/errorlogger.h lib/suppressions.h test/options.h test/redirect.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testsuite.o test/testsuite.cpp
+test/testsarifreport.o: test/testsarifreport.cpp externals/picojson/picojson.h lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/json.h lib/library.h lib/mathlib.h lib/platform.h lib/sarifreport.h lib/settings.h lib/standards.h lib/utils.h test/fixture.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testsarifreport.cpp
 
-test/testsuppressions.o: test/testsuppressions.cpp cli/threadexecutor.h lib/analyzerinfo.h lib/check.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testsuppressions.o test/testsuppressions.cpp
+test/testsettings.o: test/testsettings.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testsettings.cpp
 
-test/testsymboldatabase.o: test/testsymboldatabase.cpp lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/symboldatabase.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h test/testutils.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testsymboldatabase.o test/testsymboldatabase.cpp
+test/testsimplifytemplate.o: test/testsimplifytemplate.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/standards.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testsimplifytemplate.cpp
 
-test/testthreadexecutor.o: test/testthreadexecutor.cpp cli/threadexecutor.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/timer.h lib/utils.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testthreadexecutor.o test/testthreadexecutor.cpp
+test/testsimplifytokens.o: test/testsimplifytokens.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/standards.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testsimplifytokens.cpp
 
-test/testtimer.o: test/testtimer.cpp lib/config.h lib/errorlogger.h lib/suppressions.h lib/timer.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testtimer.o test/testtimer.cpp
+test/testsimplifytypedef.o: test/testsimplifytypedef.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/standards.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testsimplifytypedef.cpp
 
-test/testtoken.o: test/testtoken.cpp lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h test/testutils.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testtoken.o test/testtoken.cpp
+test/testsimplifyusing.o: test/testsimplifyusing.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/standards.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testsimplifyusing.cpp
 
-test/testtokenize.o: test/testtokenize.cpp externals/simplecpp/simplecpp.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/preprocessor.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testtokenize.o test/testtokenize.cpp
+test/testsingleexecutor.o: test/testsingleexecutor.cpp cli/executor.h cli/singleexecutor.h lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/errortypes.h lib/filesettings.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/timer.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h test/redirect.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testsingleexecutor.cpp
 
-test/testtokenlist.o: test/testtokenlist.cpp lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testtokenlist.o test/testtokenlist.cpp
+test/testsizeof.o: test/testsizeof.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checksizeof.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testsizeof.cpp
 
-test/testtype.o: test/testtype.cpp lib/check.h lib/checktype.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testtype.o test/testtype.cpp
+test/teststandards.o: test/teststandards.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/utils.h test/fixture.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/teststandards.cpp
 
-test/testuninitvar.o: test/testuninitvar.cpp lib/check.h lib/checkuninitvar.h lib/config.h lib/ctu.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testuninitvar.o test/testuninitvar.cpp
+test/teststl.o: test/teststl.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checkstl.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/teststl.cpp
 
-test/testunusedfunctions.o: test/testunusedfunctions.cpp lib/check.h lib/checkunusedfunctions.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testunusedfunctions.o test/testunusedfunctions.cpp
+test/teststring.o: test/teststring.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checkstring.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/teststring.cpp
 
-test/testunusedprivfunc.o: test/testunusedprivfunc.cpp externals/simplecpp/simplecpp.h lib/check.h lib/checkclass.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testunusedprivfunc.o test/testunusedprivfunc.cpp
+test/testsummaries.o: test/testsummaries.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/summaries.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testsummaries.cpp
 
-test/testunusedvar.o: test/testunusedvar.cpp lib/check.h lib/checkunusedvar.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testunusedvar.o test/testunusedvar.cpp
+test/testsuppressions.o: test/testsuppressions.cpp cli/cppcheckexecutor.h cli/executor.h cli/processexecutor.h cli/singleexecutor.h cli/threadexecutor.h lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/errortypes.h lib/filesettings.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testsuppressions.cpp
 
-test/testvaarg.o: test/testvaarg.cpp lib/check.h lib/checkvaarg.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testvaarg.o test/testvaarg.cpp
+test/testsymboldatabase.o: test/testsymboldatabase.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testsymboldatabase.cpp
 
-test/testvalueflow.o: test/testvalueflow.cpp externals/simplecpp/simplecpp.h lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testvalueflow.o test/testvalueflow.cpp
+test/testthreadexecutor.o: test/testthreadexecutor.cpp cli/executor.h cli/threadexecutor.h lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/cppcheck.h lib/errorlogger.h lib/errortypes.h lib/filesettings.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/timer.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h test/redirect.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testthreadexecutor.cpp
 
-test/testvarid.o: test/testvarid.cpp lib/config.h lib/errorlogger.h lib/importproject.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/suppressions.h lib/templatesimplifier.h lib/timer.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/valueflow.h test/testsuite.h
-	$(CXX) ${INCLUDE_FOR_TEST} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o test/testvarid.o test/testvarid.cpp
+test/testtimer.o: test/testtimer.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/timer.h lib/utils.h test/fixture.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testtimer.cpp
 
-externals/simplecpp/simplecpp.o: externals/simplecpp/simplecpp.cpp externals/simplecpp/simplecpp.h
-	$(CXX)  $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) -w $(UNDEF_STRICT_ANSI) -c -o externals/simplecpp/simplecpp.o externals/simplecpp/simplecpp.cpp
+test/testtoken.o: test/testtoken.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/standards.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testtoken.cpp
+
+test/testtokenize.o: test/testtokenize.cpp externals/simplecpp/simplecpp.h lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/preprocessor.h lib/settings.h lib/smallvector.h lib/standards.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testtokenize.cpp
+
+test/testtokenlist.o: test/testtokenlist.cpp externals/simplecpp/simplecpp.h lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/preprocessor.h lib/settings.h lib/smallvector.h lib/standards.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testtokenlist.cpp
 
-externals/tinyxml/tinyxml2.o: externals/tinyxml/tinyxml2.cpp externals/tinyxml/tinyxml2.h
-	$(CXX)  $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) -w $(UNDEF_STRICT_ANSI) -c -o externals/tinyxml/tinyxml2.o externals/tinyxml/tinyxml2.cpp
+test/testtokenrange.o: test/testtokenrange.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/sourcelocation.h lib/standards.h lib/symboldatabase.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/tokenrange.h lib/utils.h lib/vfvalue.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testtokenrange.cpp
 
-tools/clang-ast.o: tools/clang-ast.cpp
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o tools/clang-ast.o tools/clang-ast.cpp
+test/testtype.o: test/testtype.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checktype.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testtype.cpp
+
+test/testuninitvar.o: test/testuninitvar.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checkuninitvar.h lib/color.h lib/config.h lib/ctu.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testuninitvar.cpp
+
+test/testunusedfunctions.o: test/testunusedfunctions.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checkunusedfunctions.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testunusedfunctions.cpp
+
+test/testunusedprivfunc.o: test/testunusedprivfunc.cpp lib/addoninfo.h lib/check.h lib/checkclass.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testunusedprivfunc.cpp
+
+test/testunusedvar.o: test/testunusedvar.cpp externals/simplecpp/simplecpp.h lib/addoninfo.h lib/check.h lib/checkers.h lib/checkunusedvar.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/preprocessor.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testunusedvar.cpp
+
+test/testutils.o: test/testutils.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/utils.h test/fixture.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testutils.cpp
+
+test/testvaarg.o: test/testvaarg.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/checkvaarg.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/standards.h lib/tokenize.h lib/tokenlist.h lib/utils.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testvaarg.cpp
+
+test/testvalueflow.o: test/testvalueflow.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/standards.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testvalueflow.cpp
+
+test/testvarid.o: test/testvarid.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/path.h lib/platform.h lib/settings.h lib/smallvector.h lib/standards.h lib/templatesimplifier.h lib/token.h lib/tokenize.h lib/tokenlist.h lib/utils.h lib/vfvalue.h test/fixture.h test/helpers.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testvarid.cpp
+
+test/testvfvalue.o: test/testvfvalue.cpp lib/addoninfo.h lib/check.h lib/checkers.h lib/color.h lib/config.h lib/errorlogger.h lib/errortypes.h lib/library.h lib/mathlib.h lib/platform.h lib/settings.h lib/standards.h lib/utils.h lib/vfvalue.h test/fixture.h
+	$(CXX) ${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ test/testvfvalue.cpp
+
+externals/simplecpp/simplecpp.o: externals/simplecpp/simplecpp.cpp externals/simplecpp/simplecpp.h
+	$(CXX)  $(CPPFLAGS) $(CXXFLAGS) -w -c -o $@ externals/simplecpp/simplecpp.cpp
 
-tools/dmake.o: tools/dmake.cpp cli/filelister.h lib/config.h lib/pathmatch.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o tools/dmake.o tools/dmake.cpp
+externals/tinyxml2/tinyxml2.o: externals/tinyxml2/tinyxml2.cpp externals/tinyxml2/tinyxml2.h
+	$(CXX)  $(CPPFLAGS) $(CXXFLAGS) -w -D_LARGEFILE_SOURCE -c -o $@ externals/tinyxml2/tinyxml2.cpp
 
-tools/generate_cfg_tests.o: tools/generate_cfg_tests.cpp externals/tinyxml/tinyxml2.h
-	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS) $(UNDEF_STRICT_ANSI) -c -o tools/generate_cfg_tests.o tools/generate_cfg_tests.cpp
+tools/dmake/dmake.o: tools/dmake/dmake.cpp cli/filelister.h lib/config.h lib/filesettings.h lib/mathlib.h lib/path.h lib/pathmatch.h lib/platform.h lib/standards.h lib/utils.h
+	$(CXX) ${INCLUDE_FOR_LIB} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ tools/dmake/dmake.cpp
 
diff --git a/TUNING.md b/TUNING.md
new file mode 100644
index 00000000000..4643e7d506a
--- /dev/null
+++ b/TUNING.md
@@ -0,0 +1,171 @@
+# Tuning Cppcheck Analysis
+
+There are several ways you can potentially improve the runtime of a Cppcheck analysis.
+
+Note: Most of these suggestions highly depend on your code base so they need to be evaluated before being applied. They might also depend the code of Cppcheck itself and your environment. So you might want to evaluate these on a regular basis.
+
+## Collecting Information
+
+To see the time each file took to analyze just specify the `--showtime=file-total` CLI option.
+
+## Tuning At Build-Level
+
+It is most likely that a pre-built binary is being used - either an official one or one provided by the packaging manager of my operating system.
+
+But if you build your own binary it is possible to apply several steps to potentially improve the performance.
+
+Note: Recently more distribution have opted to use more advanced optimization for their packages so several of the following suggestions might have already been applied.
+Please refer to the documentation of your distribution for more insight on this.
+
+### Use Matchcompiler
+
+(TODO: document how to use it when using the in-tree Visual Studio project)
+(TODO: check with a CMake generated Visual Studio project)
+
+### Use Boost
+
+Boost.Container (https://www.boost.org/doc/libs/release/libs/container) is being used for some containers which have a smaller overhead.
+
+As the used library is header-only implementation you only need to install the package on the system you build the binary on but not on the system you run the analysis on.
+
+The official Windows binary is always using this.
+
+This will be used by default if Boost is detected in CMake. If you want to enforce the usage, you can use the CMake option `-DUSE_BOOST=On` which will cause the build to fail if no Boost was detected.
+
+Using Visual Studio you need to provide a full Boost release (i.e. including binaries) for it to be detected by CMake. If you are not able to do this you can specify the CMake option `-DBOOST_INCLUDEDIR=<in>` (pointing to the directory which *contains* the `boost` include directory) to work around this (this is a Cppcheck specific hack) - see https://trac.cppcheck.net/ticket/13822 for more details.
+
+If you are using `make` instead you need to specify `-DHAVE_BOOST` in the flags.
+
+If you are using the Visual Studio project you need to specify the properties `HaveBoost` (always needs to be set to `HAVE_BOOST`) and `BoostInclude` (set to the Boost folder). On the command-line you would need to add `-p:HaveBoost=HAVE_BOOST -p:BoostInclude=<boostdir>`.
+
+### Use A Different Compiler
+
+Analyzing our own code base has shown that using a different compiler might lead to slightly better performance.
+
+In our case Clang is mostly faster than GCC. See https://trac.cppcheck.net/ticket/10778 for some details.
+
+### Use More Advanced Optimizations
+
+By default we enforce the `-O2` optimization level. Even when using the `Release` build type in CMake which defaults to `-O3`. It might be possible that building with `-O3` might yield a perfomance increase.
+
+There are also no additional code generation flags provided so the resulting binary can run on any system. You might be able to tune this and apply more optimization which is tailored to the system you will be running the binary on.
+
+Needs to be evaluated. (TODO: file tickets)
+
+### Use LTO
+
+Needs to be evaluated. See https://trac.cppcheck.net/ticket/11671.
+
+### Use profile-guided optimizations (PGO/BOLT/AutoFDO/Propeller)
+
+Needs to be evaluated. See https://trac.cppcheck.net/ticket/11672.
+
+## Tuning At Analysis-Level
+
+### Use A More Performant Platform
+
+It seems people assume that you need to run the analysis on the same system you build your code on/for. That is not necessary as the analysis is system-agnostic.
+As system headers are not required for analyzing your code you only need to specify the configuration which matches the system you run your code on.
+
+In case you are using a project as input which can only be generated on the build/target system you can just transfer that to a different system and still run the analysis.
+
+### Specify A Build Dir
+
+Using the `--cppcheck-build-dir` allows you to perform incremental runs which omit files which have not been changed.
+
+Important: As this is currently seriously lacking in testing coverage it might have shortcomings and need to be used with care. (TODO: file ticket)
+
+### Exclude Static/Generated Files
+
+If your code base contains files which rarely change (e.g. local copies of external dependencies) or you have generated files (e.g. `moc_*.cpp` for Qt projects) you might consider excluding these from the analysis.
+This can be done by using the `-i` option on the CLI, `<ignore>` in GUI projects or by including them to begin with into the files passed to the analysis.
+
+Depending on your setup you might also consider to scan these files in a less frequent run (e.g. only when the files have changed or Cppcheck was updated).
+
+This could also be handled using `--cppcheck-build-dir` (see above).
+
+### Exclude System Headers
+
+System headers are not necessary to perform the analysis. So you might consider not providing those to the analysis and specify a library configuration via `--library` instead.
+
+`pkg-config` for instance will always provide non-system includes.
+
+(TODO: file ticket about ignoring all braced includes)
+
+### Limit The Configuration
+
+By default configuration to analyze will be determined automatically for each file based on the code. The maximum amount is limited and can be controlled by CLI options.
+
+Depending on your setup you might want to limit it to specific configuration by using `-D` (CLI) or `--project-configuration=` (Visual Studio project).
+When you are using a compilation database generated by CMake it is already using a fixed configuration.
+
+### Use Multiple Jobs
+
+By default only a single process/thread is being used. You might to scale this up using the `-j` CLI option. Please note that specifying a value that will max out your systems resources might have a detrimental effect.
+
+### Use A Different Threading Model
+
+When using multiple job for the analysis (see above) on Linux it will default to using processes. This is done so the analysis is not aborted prematurely aborted in case of a crash. 
+Unfortunately it has overhead because of a suboptimal implementation and the fact that data needs to be transferred from the child processes to the main process.
+So if you do not require the additional safety you might want to switch to the usage of thread instead using `--executor=thread`.
+
+Note: For Windows binaries we currently do not provide the possibility of using processes so this does not apply.
+
+### Disable Analyzing Of Unused Templated Functions
+
+Currently all templated functions (either locally or in headers) will be analyzed regardless if they are instantiated or not. If you have template-heavy includes that might lead to unnecessary work and findings, and might slow down the analysis. This behavior can be disabled with `--no-check-unused-templates`.
+
+Note: This might lead to "false negatives" in such functions if they are never instantiated. You should make sure that you have proper coverage of the affected functions in your code before enabling this.
+
+### Limit Analysis Of Projects 
+
+If you specify a project all files will be analyzed by default. But in some cases you might only be interested in the results in a subset of those (e.g. in IDE integrations).
+
+Using the `--file-filter=<pattern>` CLI option you can select files using a globbing syntax. Using `--file-filter=-` you can provide the filters directly on the CLI.
+
+## Advanced Tuning
+
+### Re-order The Files
+
+Files which take longer to analyze should be processed at first so they might not extended the run time. As the order how the files provided on the CLI or via the project are being honored it is as simple as that.
+
+### Adjust Thresholds
+
+There are lots of internal thresholds which limit the work which is put into parts of the analysis. The defaults were chosen as a compromise of time being spent vs. issues being detected but not might not be a good fit in all cases.
+
+These thresholds are currently neither exposed nor documented so they cannot be changed without the modifying the source which is *highly discouraged*.
+
+They are being utilized internally by `-check-level` though (see below).
+
+(TODO: file ticket about providing all bailouts)
+(TODO: file ticket about expose these)
+(TODO: file ticket about specifying these per file)
+
+Note: As these will lead to less data being collected for the analysis it might lead to false negatives *and* false positives.
+
+### Adjust Check Level
+
+There are several check levels which are basically a collection of different threshold values (see above). This can be adjusted by the CLI option `--check-level`.
+
+Note: The current default is the lowest available check level.
+
+Note: As these will lead to less data being collected for the analysis it might lead to false negatives *and* false positives.
+
+## Reporting Issues
+
+If you encounter a file which has an unreasonable slow analysis please consider reporting this as an issue.
+
+Also consider reporting major upticks in the runtime of the analysis after updating to a newer version. Some of these might be expected as the analysis is constantly improved but out-of-the-box we still need aim for reasonable times.
+
+In all cases please try to provide a small reproducer if possible.
+
+Note: There might even be cases the analysis will never finish because it is stuck in a cycle. This is quite uncommon but there are still several unresolved known cases so it is possible to encounter this.
+
+### Known Issues
+
+https://trac.cppcheck.net/ticket/10663
+https://trac.cppcheck.net/ticket/10765
+https://trac.cppcheck.net/ticket/10778
+https://trac.cppcheck.net/ticket/11262
+https://trac.cppcheck.net/ticket/12528
+https://trac.cppcheck.net/ticket/13698
\ No newline at end of file
diff --git a/addons/README.md b/addons/README.md
index 839d0962003..8df8229b970 100644
--- a/addons/README.md
+++ b/addons/README.md
@@ -4,34 +4,69 @@ Addons are scripts that analyses Cppcheck dump files to check compatibility with
 
 ## Supported addons
 
-+ [cert.py](https://github.com/danmar/cppcheck/blob/master/addons/cert.py) 
-  Checks for compliance with the safe programming standard [CERT](http://www.cert.org/secure-coding/).
-+ [misra.py](https://github.com/danmar/cppcheck/blob/master/addons/misra.py) 
-  Used to verify compliance with MISRA C 2012 - a proprietary set of guidelines to avoid such questionable code, developed for embedded systems. Since this standard is proprietary, cppcheck does not display error text by specifying only the number of violated rules (for example, [c2012-21.3]). If you want to display full texts for violated rules, you will need to create a text file containing MISRA rules, which you will have to pass when calling the script with `--rule-texts` key. Some examples of rule texts files available in [tests directory](https://github.com/danmar/cppcheck/blob/master/addons/test/misra/).
-+ [y2038.py](https://github.com/danmar/cppcheck/blob/master/addons/y2038.py) 
-  Checks Linux system for [year 2038 problem](https://en.wikipedia.org/wiki/Year_2038_problem) safety. This required [modified environment](https://github.com/3adev/y2038). See complete description [here](https://github.com/danmar/cppcheck/blob/master/addons/doc/y2038.txt).
-+ [threadsafety.py](https://github.com/danmar/cppcheck/blob/master/addons/threadsafety.py) 
++ [misra.py](https://github.com/danmar/cppcheck/blob/main/addons/misra.py) 
+  Used to verify compliance with MISRA C 2012 - a proprietary set of guidelines to avoid such questionable code, developed for embedded systems. Since this standard is proprietary, cppcheck does not display error text by specifying only the number of violated rules (for example, [c2012-21.3]). If you want to display full texts for violated rules, you will need to create a text file containing MISRA rules, which you will have to pass when calling the script with `--rule-texts` key. Some examples of rule texts files available in [tests directory](https://github.com/danmar/cppcheck/blob/main/addons/test/misra/).
++ [y2038.py](https://github.com/danmar/cppcheck/blob/main/addons/y2038.py) 
+  Checks code for [year 2038 problem](https://en.wikipedia.org/wiki/Year_2038_problem) safety. See complete description [here](https://github.com/danmar/cppcheck/blob/main/addons/doc/y2038.md).
++ [threadsafety.py](https://github.com/danmar/cppcheck/blob/main/addons/threadsafety.py) 
   Analyse Cppcheck dump files to locate threadsafety issues like static local objects used by multiple threads.
++ [naming.py](https://github.com/danmar/cppcheck/blob/main/addons/naming.py)
+  Enforces naming conventions across the code.
++ [namingng.py](https://github.com/danmar/cppcheck/blob/main/addons/namingng.py)
+  Enforces naming conventions across the code. Enhanced version with support for type prefixes in variable and function names.
++ [findcasts.py](https://github.com/danmar/cppcheck/blob/main/addons/findcasts.py)
+  Locates casts in the code.
++ [misc.py](https://github.com/danmar/cppcheck/blob/main/addons/misc.py)
+  Performs miscellaneous checks.
+
+### Other files
+
+- doc
+  Additional files for documentation generation.
+- tests
+  Contains various unit tests for the addons.
+- cppcheck.py
+  Internal helper used by Cppcheck binary to run the addons.
+- cppcheckdata.doxyfile
+  Configuration file for documentation generation.
+- cppcheckdata.py
+  Helper class for reading Cppcheck dump files within an addon.
+- misra_9.py
+  Implementation of the MISRA 9.x rules used by `misra` addon. 
+- namingng.config.json
+  Example configuration for `namingng` addon. 
+- namingng.json
+  Example JSON file that can be used using --addon=namingng.json, referring to namingng.py and namingng.config.json
+- ROS_naming.json
+  Example configuration for the `namingng` addon enforcing the [ROS naming convention for C++ ](http://wiki.ros.org/CppStyleGuide#Files).
+- runaddon.py
+  Internal helper used by Cppcheck binary to run the addons.
 
 ## Usage
 
 ### Command line interface
 
 ```bash
-cppcheck --addon=cert --addon=y2038 src/test.c
+cppcheck --addon=misc src/test.c
+```
+
+For project-wide analysis with compile_commands.json:
+```bash
+cppcheck --project=build/compile_commands.json --addon=y2038
 ```
 
 It is also possible to call scripts as follows:
 ```bash
 cppcheck --dump --quiet src/test.c
-python cert.py src/test.c.dump
-python misra.py --rules-texts=~/misra_rules.txt src/test.c.dump
+python misc.py src/test.c.dump
+python misra.py --rule-texts=~/misra_rules.txt src/test.c.dump
 ```
 
-This allows you to add additional parameters when calling the script (for example, `--rule-tests` for `misra.py`). The full list of available parameters can be found by calling any script with the `--help` flag.
+This allows you to add additional parameters when calling the script (for example, `--rule-texts` for `misra.py`). The full list of available parameters can be found by calling any script with the `--help` flag.
 
 ### GUI
 
 When using the graphical interface `cppcheck-gui`, the selection and configuration of addons is carried out on the tab `Addons and tools` in the project settings (`Edit Project File`):
 
-[](https://raw.githubusercontent.com/danmar/cppcheck/master/addons/doc/img/cppcheck-gui-addons.png)
+![Screenshot](https://raw.githubusercontent.com/danmar/cppcheck/main/addons/doc/img/cppcheck-gui-addons.png)
+
diff --git a/addons/ROS_naming.json b/addons/ROS_naming.json
index 82c0131cf0a..0262d69c09b 100644
--- a/addons/ROS_naming.json
+++ b/addons/ROS_naming.json
@@ -1,5 +1,5 @@
 {
-    "RE_FILE": {".*[A-Z]": [true, "under_scored"]},
+    "RE_FILE": [".*[A-Z]"],
     "RE_NAMESPACE": {".*[A-Z]": [true, "under_scored"],
     				 ".*\\_$": [true, "under_scored"]},
     "RE_FUNCTIONNAME": {".*\\_": [true, "camelCase"],
diff --git a/addons/cert.py b/addons/cert.py
deleted file mode 100755
index d3573afa334..00000000000
--- a/addons/cert.py
+++ /dev/null
@@ -1,413 +0,0 @@
-#!/usr/bin/env python
-#
-# Cert: Some extra CERT checkers
-#
-# Cppcheck itself handles many CERT rules. Cppcheck warns when there is undefined behaviour.
-# CERT Homepage: https://www.cert.org/secure-coding/
-#
-# Example usage of this addon (scan a sourcefile main.cpp)
-# cppcheck --dump main.cpp
-# python cert.py main.cpp.dump
-
-import argparse
-import cppcheckdata
-import sys
-import re
-
-VERIFY = ('-verify' in sys.argv)
-VERIFY_EXPECTED = []
-VERIFY_ACTUAL = []
-
-def reportError(token, severity, msg, id):
-    if VERIFY:
-        VERIFY_ACTUAL.append(str(token.linenr) + ':cert-' + id)
-    else:
-        cppcheckdata.reportError(token, severity, msg, 'cert', id)
-
-def simpleMatch(token, pattern):
-    for p in pattern.split(' '):
-        if not token or token.str != p:
-            return False
-        token = token.next
-    return True
-
-def isUnpackedStruct(token):
-    if token.valueType is None:
-        return False
-    if token.valueType.typeScope is None:
-        return False
-    if token.valueType.typeScope.type != "Struct":
-        return False
-    startToken = token.valueType.typeScope.bodyStart
-
-    linenr = int(startToken.linenr)
-    for line in open(startToken.file):
-        linenr -= 1
-        if linenr == 0:
-            return True
-        if linenr < 3 and re.match(r'#pragma\s+pack\s*\(', line):
-            return False
-    return True
-
-
-def isLocalUnpackedStruct(arg):
-    if arg and arg.str == '&' and not arg.astOperand2:
-        arg = arg.astOperand1
-    return arg and arg.variable and (arg.variable.isLocal or arg.variable.isArgument) and isUnpackedStruct(arg)
-
-
-def isBitwiseOp(token):
-    return token and (token.str in {'&', '|', '^'})
-
-
-def isComparisonOp(token):
-    return token and (token.str in {'==', '!=', '>', '>=', '<', '<='})
-
-def isCast(expr):
-    if not expr or expr.str != '(' or not expr.astOperand1 or expr.astOperand2:
-        return False
-    if simpleMatch(expr, '( )'):
-        return False
-    return True
-
-def isStandardFunction(token):
-    if token.function:
-        return False
-    prev = token.previous
-    if prev:
-        if prev.str == '.':
-            return False
-        if prev.str == '::':
-            prevprev = prev.previous
-            if prevprev and not prevprev.str == 'std':
-                return False
-    return True
-
-# Is this a function call
-def isFunctionCall(token, function_names, number_of_arguments=None):
-    if not token.isName:
-        return False
-    if token.str not in function_names:
-        return False
-    if (token.next is None) or token.next.str != '(' or token.next != token.astParent:
-        return False
-    if number_of_arguments is None:
-        return True
-    return len(cppcheckdata.getArguments(token)) == number_of_arguments
-
-
-# EXP05-C
-# do not attempt to cast away const
-def exp05(data):
-    # TODO Reuse code in misra rule 11.8
-    for token in data.tokenlist:
-        if isCast(token):
-            # C-style cast
-            if not token.valueType:
-                continue
-            if not token.astOperand1.valueType:
-                continue
-            if token.valueType.pointer == 0:
-                continue
-            if token.astOperand1.valueType.pointer == 0:
-                continue
-            const1 = token.valueType.constness
-            const2 = token.astOperand1.valueType.constness
-            if (const1 % 2) < (const2 % 2):
-                reportError(token, 'style', "Attempt to cast away const", 'EXP05-C')
-
-        elif token.str == '(' and token.astOperand1 and token.astOperand2 and token.astOperand1.function:
-            function = token.astOperand1.function
-            arguments = cppcheckdata.getArguments(token.previous)
-            for argnr, argvar in function.argument.items():
-                if argnr < 1 or argnr > len(arguments):
-                    continue
-                if not argvar.isPointer:
-                    continue
-                if (argvar.constness % 2) == 1: # data is const
-                    continue
-                argtok = arguments[argnr - 1]
-                if not argtok.valueType:
-                    continue
-                if argtok.valueType.pointer == 0:
-                    continue
-                const2 = arguments[argnr - 1].valueType.constness
-                if (const2 % 2) == 1:
-                    reportError(token, 'style', "Attempt to cast away const", 'EXP05-C')
-
-
-# EXP42-C
-# do not compare padding data
-def exp42(data):
-    for token in data.tokenlist:
-        if token.str != '(' or not token.astOperand1 or token.astOperand1.str != 'memcmp':
-            continue
-
-        arg1 = None
-        arg2 = None
-        if token.astOperand2 and token.astOperand2.str == ',':
-            if token.astOperand2.astOperand1 and token.astOperand2.astOperand1.str == ',':
-                arg1 = token.astOperand2.astOperand1.astOperand1
-                arg2 = token.astOperand2.astOperand1.astOperand2
-
-        if isLocalUnpackedStruct(arg1) or isLocalUnpackedStruct(arg2):
-            reportError(
-                token, 'style', "Comparison of struct padding data " +
-                "(fix either by packing the struct using '#pragma pack' or by rewriting the comparison)", 'EXP42-C')
-
-# EXP15-C
-# Do not place a semicolon on the same line as an if, for or while statement
-def exp15(data):
-    for scope in data.scopes:
-        if scope.type in ('If', 'For', 'While'):
-            token = scope.bodyStart.next 
-            if token.str==';' and token.linenr==scope.bodyStart.linenr:
-                reportError(token, 'style', 'Do not place a semicolon on the same line as an IF, FOR or WHILE', 'EXP15-C')
-
-
-# EXP46-C
-# Do not use a bitwise operator with a Boolean-like operand
-#   int x = (a == b) & c;
-def exp46(data):
-    for token in data.tokenlist:
-        if isBitwiseOp(token) and (isComparisonOp(token.astOperand1) or isComparisonOp(token.astOperand2)):
-            reportError(
-                token, 'style', 'Bitwise operator is used with a Boolean-like operand', 'EXP46-c')
-
-# INT31-C
-# Ensure that integer conversions do not result in lost or misinterpreted data
-def int31(data, platform):
-    if not platform:
-        return
-    for token in data.tokenlist:
-        if not isCast(token):
-            continue
-        if not token.valueType or not token.astOperand1.values:
-            continue
-        bits = None
-        if token.valueType.type == 'char':
-            bits = platform.char_bit
-        elif token.valueType.type == 'short':
-            bits = platform.short_bit
-        elif token.valueType.type == 'int':
-            bits = platform.int_bit
-        elif token.valueType.type == 'long':
-            bits = platform.long_bit
-        elif token.valueType.type == 'long long':
-            bits = platform.long_long_bit
-        else:
-            continue
-        if token.valueType.sign == 'unsigned':
-            found = False
-            for value in token.astOperand1.values:
-                if value.intvalue and value.intvalue < 0:
-                    found = True
-                    reportError(
-                        token,
-                        'style',
-                        'Ensure that integer conversions do not result in lost or misinterpreted data (casting ' + str(value.intvalue) + ' to unsigned ' + token.valueType.type + ')',
-                        'INT31-c')
-                break
-            if found:
-                continue
-        if bits >= 64:
-            continue
-        minval = 0
-        maxval = 1
-        if token.valueType.sign == 'signed':
-            minval = -(1 << (bits - 1))
-            maxval = ((1 << (bits - 1)) - 1)
-        else:
-            minval = 0
-            maxval = ((1 << bits) - 1)
-        for value in token.astOperand1.values:
-            if value.intvalue and (value.intvalue < minval or value.intvalue > maxval):
-                destType = ''
-                if token.valueType.sign:
-                    destType = token.valueType.sign + ' ' + token.valueType.type
-                else:
-                    destType = token.valueType.type
-                reportError(
-                    token,
-                    'style',
-                    'Ensure that integer conversions do not result in lost or misinterpreted data (casting ' + str(value.intvalue) + ' to ' + destType + ')',
-                    'INT31-c')
-                break                
-# MSC24-C
-# Do not use deprecated or obsolescent functions
-def msc24(data):
-    for token in data.tokenlist:
-        if isFunctionCall(token, ('asctime',), 1):
-            reportError(token,'style','Do not use asctime() better use asctime_s()', 'MSC24-C')
-        elif isFunctionCall(token, ('atof',), 1):
-            reportError(token,'style','Do not use atof() better use strtod()', 'MSC24-C')
-        elif isFunctionCall(token, ('atoi',), 1):
-            reportError(token,'style','Do not use atoi() better use strtol()', 'MSC24-C')
-        elif isFunctionCall(token, ('atol',), 1):
-            reportError(token,'style','Do not use atol() better use strtol()', 'MSC24-C')
-        elif isFunctionCall(token, ('atoll',), 1):
-            reportError(token,'style','Do not use atoll() better use strtoll()', 'MSC24-C')
-        elif isFunctionCall(token, ('ctime',), 1):
-            reportError(token,'style','Do not use ctime() better use ctime_s()', 'MSC24-C')
-        elif isFunctionCall(token, ('fopen',), 2):
-            reportError(token,'style','Do not use fopen() better use fopen_s()', 'MSC24-C')
-        elif isFunctionCall(token, ('freopen',), 3):
-            reportError(token,'style','Do not use freopen() better use freopen_s()', 'MSC24-C')
-        elif isFunctionCall(token, ('rewind',), 1):
-            reportError(token,'style','Do not use rewind() better use fseek()', 'MSC24-C')
-        elif isFunctionCall(token, ('setbuf',), 2):
-            reportError(token,'style','Do not use setbuf() better use setvbuf()', 'MSC24-C')
-
-# MSC30-C
-# Do not use the rand() function for generating pseudorandom numbers
-def msc30(data):
-    for token in data.tokenlist:
-        if simpleMatch(token, "rand ( )") and isStandardFunction(token):
-            reportError(token, 'style', 'Do not use the rand() function for generating pseudorandom numbers', 'MSC30-c')
-
-# STR03-C
-# Do not inadvertently truncate a string
-def str03(data):
-    for token in data.tokenlist:
-        if not isFunctionCall(token, 'strncpy'):
-            continue
-        arguments = cppcheckdata.getArguments(token)
-        if len(arguments)!=3:
-            continue
-        if arguments[2].str=='(' and arguments[2].astOperand1.str=='sizeof':
-            reportError(token, 'style', 'Do not inadvertently truncate a string', 'STR03-C')
-
-# STR05-C
-# Use pointers to const when referring to string literals
-def str05(data):
-    for token in data.tokenlist:
-        if token.isString:
-            parent = token.astParent
-            if parent is None:
-                continue
-            parentOp1 = parent.astOperand1
-            if parent.isAssignmentOp and parentOp1.valueType:
-                if (parentOp1.valueType.type in ('char', 'wchar_t')) and parentOp1.valueType.pointer and not parentOp1.valueType.constness:
-                    reportError(parentOp1, 'style', 'Use pointers to const when referring to string literals', 'STR05-C')
-
-# STR07-C
-# Use the bounds-checking interfaces for string manipulation
-def str07(data):
-    for token in data.tokenlist:
-        if not isFunctionCall(token, ('strcpy', 'strcat')):
-            continue
-        args = cppcheckdata.getArguments(token)
-        if len(args)!=2:
-            continue
-        if args[1].isString:
-            continue
-        reportError(token, 'style', 'Use the bounds-checking interfaces %s_s()' % (token.str), 'STR07-C')
-
-# STR11-C
-# Do not specify the bound of a character array initialized with a string literal
-def str11(data):
-    for token in data.tokenlist:
-        if not token.isString:
-            continue
-
-        strlen = token.strlen
-        parent = token.astParent
-
-        if parent is None:
-            continue
-        parentOp1 = parent.astOperand1
-        if parentOp1 is None or parentOp1.str!='[':
-            continue
-
-        if not parent.isAssignmentOp:
-            continue
-            
-        varToken = parentOp1.astOperand1
-        if varToken is None or not varToken.isName:
-            continue
-        if varToken.variable is None:
-            continue
-        if varToken != varToken.variable.nameToken:
-            continue
-        valueToken = parentOp1.astOperand2
-        if valueToken is None:
-            continue
-            
-        if valueToken.isNumber and int(valueToken.str)==strlen:
-            reportError(valueToken, 'style', 'Do not specify the bound of a character array initialized with a string literal', 'STR11-C')
-
-# API01-C
-# Avoid laying out strings in memory directly before sensitive data
-def api01(data):
-    for scope in data.scopes:
-        if scope.type!='Struct':
-            continue
-        token = scope.bodyStart
-        arrayFound=False
-        # loop through the complete struct
-        while token != scope.bodyEnd:
-            if token.isName and token.variable:
-                if token.variable.isArray:
-                    arrayFound=True
-                elif arrayFound and not token.variable.isArray and not token.variable.isConst:
-                    reportError(token, 'style', 'Avoid laying out strings in memory directly before sensitive data', 'API01-C')
-                    # reset flags to report other positions in the same struct
-                    arrayFound=False
-            token = token.next
-
-
-def get_args():
-    parser = cppcheckdata.ArgumentParser()
-    parser.add_argument("dumpfile", nargs='*', help="Path of dump files from cppcheck")
-    parser.add_argument('-q', '--quiet', action='store_true',
-                        help='do not print "Checking ..." lines')
-    parser.add_argument('--cli', help='Addon is executed from Cppcheck', action='store_true')
-    parser.add_argument("-verify", help=argparse.SUPPRESS, action="store_true")
-    return parser.parse_args()
-
-if __name__ == '__main__':
-    args = get_args()
-
-    if args.verify:
-        VERIFY = True
-
-    for dumpfile in args.dumpfile:
-        if not args.quiet:
-            print('Checking %s...' % dumpfile)
-
-        data = cppcheckdata.parsedump(dumpfile)
-
-        if VERIFY:
-            VERIFY_ACTUAL = []
-            VERIFY_EXPECTED = []
-            for tok in data.rawTokens:
-                if tok.str.startswith('//') and 'TODO' not in tok.str:
-                    for word in tok.str[2:].split(' '):
-                        if re.match(r'cert-[A-Z][A-Z][A-Z][0-9][0-9].*',word):
-                            VERIFY_EXPECTED.append(str(tok.linenr) + ':' + word)
-
-        for cfg in data.configurations:
-            if (len(data.configurations) > 1) and (not args.quiet):
-                print('Checking %s, config %s...' % (dumpfile, cfg.name))
-            exp05(cfg)
-            exp42(cfg)
-            exp46(cfg)
-            exp15(cfg)
-            int31(cfg, data.platform)
-            str03(cfg)
-            str05(cfg)
-            str07(cfg)
-            str11(cfg)
-            msc24(cfg)
-            msc30(cfg)
-            api01(cfg)
-
-        if VERIFY:
-            for expected in VERIFY_EXPECTED:
-                if expected not in VERIFY_ACTUAL:
-                    print('Expected but not seen: ' + expected)
-                    sys.exit(1)
-            for actual in VERIFY_ACTUAL:
-                if actual not in VERIFY_EXPECTED:
-                    print('Not expected: ' + actual)
-                    sys.exit(1)
diff --git a/addons/cppcheck.py b/addons/cppcheck.py
new file mode 100644
index 00000000000..735269d32c5
--- /dev/null
+++ b/addons/cppcheck.py
@@ -0,0 +1,41 @@
+
+import cppcheckdata
+import sys
+import os
+
+__checkers__ = []
+
+def checker(f):
+    __checkers__.append(f)
+    return f
+
+
+__errorid__ = ''
+__addon_name__ = ''
+def reportError(location, severity, message, errorId=None):
+    cppcheckdata.reportError(location, severity, message, __addon_name__, errorId or __errorid__)
+
+def runcheckers():
+    # If there are no checkers then don't run
+    if len(__checkers__) == 0:
+        return
+    global __addon_name__
+    global __errorid__
+    addon = sys.argv[0]
+    parser = cppcheckdata.ArgumentParser()
+    args = parser.parse_args()
+
+    __addon_name__ = os.path.splitext(os.path.basename(addon))[0]
+
+    for dumpfile in args.dumpfile:
+        if not args.quiet:
+            print('Checking %s...' % dumpfile)
+
+        data = cppcheckdata.CppcheckData(dumpfile)
+
+        for cfg in data.iterconfigurations():
+            if not args.quiet:
+                print('Checking %s, config %s...' % (dumpfile, cfg.name))
+            for c in __checkers__:
+                __errorid__ = c.__name__
+                c(cfg, data)
diff --git a/addons/cppcheckdata.py b/addons/cppcheckdata.py
index 0258b18fb28..dbe36d56a57 100755
--- a/addons/cppcheckdata.py
+++ b/addons/cppcheckdata.py
@@ -6,11 +6,57 @@
 License: No restrictions, use this as you need.
 """
 
-import xml.etree.ElementTree as ET
 import argparse
-from fnmatch import fnmatch
 import json
+import os
 import sys
+import subprocess
+
+try:
+    import pathlib
+except ImportError:
+    message = "Failed to load pathlib. Upgrade Python to 3.x or install pathlib with 'pip install pathlib'."
+    error_id = 'pythonError'
+    if '--cli' in sys.argv:
+        msg = { 'file': '',
+                'linenr': 0,
+                'column': 0,
+                'severity': 'error',
+                'message': message,
+                'addon': 'cppcheckdata',
+                'errorId': error_id,
+                'extra': ''}
+        sys.stdout.write(json.dumps(msg) + '\n')
+    else:
+        sys.stderr.write('%s [%s]\n' % (message, error_id))
+    sys.exit(1)
+
+from xml.etree import ElementTree
+from fnmatch import fnmatch
+
+EXIT_CODE = 0
+
+current_dumpfile_suppressions = []
+
+def _load_location(location, element):
+    """Load location from element/dict"""
+    location.file = element.get('file')
+    line = element.get('line')
+    if line is None:
+        line = element.get('linenr')
+    if line is None:
+        line = '0'
+    location.linenr = int(line)
+    location.column = int(element.get('column', '0'))
+
+
+class Location:
+    """Utility location class"""
+    file = None
+    linenr = None
+    column = None
+    def __init__(self, element):
+        _load_location(self, element)
 
 
 class Directive:
@@ -30,26 +76,109 @@ class Directive:
         print(directive.str)
     @endcode
     """
+    #preprocessor.cpp/Preprocessor::dump
 
     str = None
     file = None
     linenr = None
-    column = 0
+    column = None
 
     def __init__(self, element):
         self.str = element.get('str')
-        self.file = element.get('file')
-        self.linenr = int(element.get('linenr'))
+        _load_location(self, element)
+
+    def __repr__(self):
+        attrs = ["str", "file", "linenr"]
+        return "{}({})".format(
+            "Directive",
+            ", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
+        )
 
+class MacroUsage:
+    """
+    Tracks preprocessor macro usage
+
+    Attributes:
+        name         Name of the macro
+        usefile
+        useline
+        usecolumn
+        isKnownValue
+    """
+    #preprocessor.cpp/Preprocessor::dump
+
+    name = None  # Macro name
+    file = None
+    linenr = None
+    column = None
+    usefile = None
+    uselinenr = None
+    usecolumn = None
+
+    def __init__(self, element):
+        self.name = element.get('name')
+        _load_location(self, element)
+        self.usefile = element.get('usefile')
+        self.useline = element.get('useline')
+        self.usecolumn = element.get('usecolumn')
+        self.isKnownValue = element.get('is-known-value', 'false') == 'true'
+
+    def __repr__(self):
+        attrs = ["name", "file", "linenr", "column", "usefile", "useline", "usecolumn", "isKnownValue"]
+        return "{}({})".format(
+            "MacroUsage",
+            ", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
+        )
+
+
+class PreprocessorIfCondition:
+    """
+    Information about #if/#elif conditions
+
+    Attributes:
+        E
+        result
+    """
+    #preprocessor.cpp/Preprocessor::dump
+
+    file = None
+    linenr = None
+    column = None
+    E = None
+    result = None
+
+    def __init__(self, element):
+        _load_location(self, element)
+        self.E = element.get('E')
+        self.result = int(element.get('result'))
+
+    def __repr__(self):
+        attrs = ["file", "linenr", "column", "E", "result"]
+        return "{}({})".format(
+            "PreprocessorIfCondition",
+            ", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
+        )
 
 class ValueType:
     """
     ValueType class. Contains (promoted) type information for each node in the AST.
+
+    Attributes:
+        type             nonstd/pod/record/smart-pointer/container/iterator/void/bool/char/short/wchar_t/int/long/long long/unknown int/float/double/long double
+        sign             signed/unsigned
+        bits             bit count for bit-fields, otherwise None
+        pointer
+        constness
+        reference
+        typeScopeId
+        originalTypeName bool/const char */long/char */size_t/int/double/std::string/..
+
     """
+    #symboldatabase.cpp/ValueType::dump
 
     type = None
     sign = None
-    bits = 0
+    bits = None
     constness = 0
     pointer = 0
     typeScopeId = None
@@ -59,21 +188,24 @@ class ValueType:
     def __init__(self, element):
         self.type = element.get('valueType-type')
         self.sign = element.get('valueType-sign')
-        bits = element.get('valueType-bits')
-        if bits:
-            self.bits = int(bits)
+        self.bits = element.get('valueType-bits', None)
+        self.bits = int(self.bits) if self.bits else None
+        self.pointer = int(element.get('valueType-pointer', 0))
+        self.constness = int(element.get('valueType-constness', 0))
+        self.reference = element.get('valueType-reference')
         self.typeScopeId = element.get('valueType-typeScope')
         self.originalTypeName = element.get('valueType-originalTypeName')
-        constness = element.get('valueType-constness')
-        if constness:
-            self.constness = int(constness)
-        else:
-            self.constness = 0
-        pointer = element.get('valueType-pointer')
-        if pointer:
-            self.pointer = int(pointer)
-        else:
-            self.pointer = 0
+        #valueType-containerId TODO add
+
+
+    def __repr__(self):
+        attrs = ["type", "sign", "bits", "typeScopeId", "originalTypeName",
+                  "constness", "pointer"]
+        return "{}({})".format(
+            "ValueType",
+            ", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
+        )
+
 
     def setId(self, IdMap):
         self.typeScope = IdMap[self.typeScopeId]
@@ -94,7 +226,7 @@ class Token:
 
     The CppcheckData.tokenlist is a list of Token items
 
-    C++ class: http://cppcheck.net/devinfo/doxyoutput/classToken.html
+    C++ class: https://cppcheck.sourceforge.io/devinfo/doxyoutput/classToken.html
 
     Attributes:
         str                Token string
@@ -104,31 +236,46 @@ class Token:
                            corresponding '}', ']' and ')'. For templates, the '<' is linked to
                            the corresponding '>'.
         scope              Scope information for this token. See the Scope class.
+        type               Type information: name/op/number/string/..
         isName             Is this token a symbol name
+        isUnsigned         Is this token a unsigned type
+        isSigned           Is this token a signed type
         isNumber           Is this token a number, for example 123, 12.34
         isInt              Is this token a int value such as 1234
-        isFloat            Is this token a int value such as 12.34
+        isFloat            Is this token a float value such as 12.34
         isString           Is this token a string literal such as "hello"
         strlen             string length for string literal
         isChar             Is this token a char literal such as 'x'
+        isBoolean          Is this token a boolean
         isOp               Is this token a operator
         isArithmeticalOp   Is this token a arithmetic operator
         isAssignmentOp     Is this token a assignment operator
         isComparisonOp     Is this token a comparison operator
         isLogicalOp        Is this token a logical operator: && ||
-        isUnsigned         Is this token a unsigned type
-        isSigned           Is this token a signed type
+        isCast
+        externLang
         isExpandedMacro    Is this token a expanded macro token
+        macroName          Macro name that this token is expanded from
+        isRemovedVoidParameter  Has void parameter been removed?
+        isSplittedVarDeclComma  Is this a comma changed to semicolon in a split variable declaration ('int a,b;' => 'int a; int b;')
+        isSplittedVarDeclEq     Is this a '=' changed to semicolon in a split variable declaration ('int a=5;' => 'int a; a=5;')
+        isImplicitInt      Is this token an implicit "int"?
+        isComplex
+        isRestrict
+        isAttributeExport
+        isAnonymous
         varId              varId for token, each variable has a unique non-zero id
+        exprId             exprId for token, each expression has a unique non-zero id
         variable           Variable information for this token. See the Variable class.
         function           If this token points at a function call, this attribute has the Function
                            information. See the Function class.
-        values             Possible values of token
-        valueType          type information
+        values             Possible/Known values of token
         typeScope          type scope (token->type()->classScope)
         astParent          ast parent
         astOperand1        ast operand1
         astOperand2        ast operand2
+        orriginalName      orriginal name of the token
+        valueType          type information: container/..
         file               file name
         linenr             line number
         column             column
@@ -143,6 +290,7 @@ class Token:
       print(code)
     @endcode
     """
+    #tokenize.cpp/Tokenizer::dump
 
     Id = None
     str = None
@@ -159,14 +307,26 @@ class Token:
     isString = False
     strlen = None
     isChar = False
+    isBoolean = False
     isOp = False
     isArithmeticalOp = False
     isAssignmentOp = False
     isComparisonOp = False
     isLogicalOp = False
+    isCast = False
     isUnsigned = False
     isSigned = False
+    macroName = None
     isExpandedMacro = False
+    isRemovedVoidParameter = False
+    isSplittedVarDeclComma = False
+    isSplittedVarDeclEq = False
+    isImplicitInt = False
+    isComplex = False
+    isRestrict = False
+    isAttributeExport = False
+    isAnonymous = False
+    exprId = None
     varId = None
     variableId = None
     variable = None
@@ -174,10 +334,12 @@ class Token:
     function = None
     valuesId = None
     values = None
+    impossible_values = None
     valueType = None
 
     typeScopeId = None
     typeScope = None
+    type = None
 
     astParentId = None
     astParent = None
@@ -197,25 +359,27 @@ def __init__(self, element):
         self.previous = None
         self.scopeId = element.get('scope')
         self.scope = None
-        type = element.get('type')
-        if type == 'name':
+        self.type = element.get('type')
+        if self.type == 'name':
             self.isName = True
             if element.get('isUnsigned'):
                 self.isUnsigned = True
             if element.get('isSigned'):
                 self.isSigned = True
-        elif type == 'number':
+        elif self.type == 'number':
             self.isNumber = True
             if element.get('isInt'):
                 self.isInt = True
             elif element.get('isFloat'):
                 self.isFloat = True
-        elif type == 'string':
+        elif self.type == 'string':
             self.isString = True
             self.strlen = int(element.get('strlen'))
-        elif type == 'char':
+        elif self.type == 'char':
             self.isChar = True
-        elif type == 'op':
+        elif self.type == 'boolean':
+            self.isBoolean = True
+        elif self.type == 'op':
             self.isOp = True
             if element.get('isArithmeticalOp'):
                 self.isArithmeticalOp = True
@@ -225,22 +389,40 @@ def __init__(self, element):
                 self.isComparisonOp = True
             elif element.get('isLogicalOp'):
                 self.isLogicalOp = True
-        if element.get('isExpandedMacro'):
+        if element.get('isCast'):
+            self.isCast = True
+        self.externLang = element.get('externLang')
+        self.macroName = element.get('macroName')
+        if self.macroName or element.get('isExpandedMacro'):
             self.isExpandedMacro = True
+        if element.get('isRemovedVoidParameter'):
+            self.isRemovedVoidParameter = True
+        if element.get('isSplittedVarDeclComma'):
+            self.isSplittedVarDeclComma = True
+        if element.get('isSplittedVarDeclEq'):
+            self.isSplittedVarDeclEq = True
+        if element.get('isImplicitInt'):
+            self.isImplicitInt = True
+        if element.get('isComplex'):
+            self.isComplex = True
+        if element.get('isRestrict'):
+            self.isRestrict = True
+        if element.get('isAttributeExport'):
+            self.isAttributeExport = True
+        if element.get('isAnonymous'):
+            self.isAnonymous = True
         self.linkId = element.get('link')
         self.link = None
         if element.get('varId'):
             self.varId = int(element.get('varId'))
+        if element.get('exprId'):
+            self.exprId = int(element.get('exprId'))
         self.variableId = element.get('variable')
         self.variable = None
         self.functionId = element.get('function')
         self.function = None
         self.valuesId = element.get('values')
         self.values = None
-        if element.get('valueType-type'):
-            self.valueType = ValueType(element)
-        else:
-            self.valueType = None
         self.typeScopeId = element.get('type-scope')
         self.typeScope = None
         self.astParentId = element.get('astParent')
@@ -249,16 +431,42 @@ def __init__(self, element):
         self.astOperand1 = None
         self.astOperand2Id = element.get('astOperand2')
         self.astOperand2 = None
-        self.file = element.get('file')
-        self.linenr = int(element.get('linenr'))
-        self.column = int(element.get('column'))
+        self.originalName = element.get('originalName')
+        if element.get('valueType-type'):
+            self.valueType = ValueType(element)
+        else:
+            self.valueType = None
+        _load_location(self, element)
+
+    def __repr__(self):
+        attrs = ["Id", "str", "scopeId", "isName", "isUnsigned", "isSigned",
+                "isNumber", "isInt", "isFloat", "isString", "strlen",
+                "isChar", "isBoolean", "isOp", "isArithmeticalOp", "isAssignmentOp", 
+                "isComparisonOp", "isLogicalOp", "isCast", "externLang", "isExpandedMacro", 
+                "isRemovedVoidParameter", "isSplittedVarDeclComma", "isSplittedVarDeclEq", 
+                "isImplicitInt", "isComplex", "isRestrict", "isAttributeExport", "isAnonymous", "linkId",
+                "varId", "variableId", "functionId", "valuesId", "valueType",
+                "typeScopeId", "astParentId", "astOperand1Id", "file",
+                "linenr", "column"]
+        return "{}({})".format(
+            "Token",
+            ", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
+        )
 
     def setId(self, IdMap):
         self.scope = IdMap[self.scopeId]
         self.link = IdMap[self.linkId]
         self.variable = IdMap[self.variableId]
         self.function = IdMap[self.functionId]
-        self.values = IdMap[self.valuesId]
+        self.values = []
+        self.impossible_values = []
+        if IdMap[self.valuesId]:
+            for v in IdMap[self.valuesId]:
+                if v.isImpossible():
+                    self.impossible_values.append(v)
+                else:
+                    self.values.append(v)
+                v.setId(IdMap)
         self.typeScope = IdMap[self.typeScopeId]
         self.astParent = IdMap[self.astParentId]
         self.astOperand1 = IdMap[self.astOperand1Id]
@@ -279,11 +487,68 @@ def getValue(self, v):
                 return value
         return None
 
+    def getKnownIntValue(self):
+        """
+        If token has a known int value then return that.
+        Otherwise returns None
+        """
+        if not self.values:
+            return None
+        for value in self.values:
+            if value.valueKind == 'known':
+                return value.intvalue
+        return None
+
+    def isUnaryOp(self, op):
+        return self.astOperand1 and (self.astOperand2 is None) and self.str == op
+
+    def isBinaryOp(self):
+        return self.astOperand1 and self.astOperand2
+
+    def forward(self, end=None):
+        token = self
+        while token and token != end:
+            yield token
+            token = token.next
+
+    def backward(self, start=None):
+        token = self
+        while token and token != start:
+            yield token
+            token = token.previous
+
+    def astParents(self):
+        token = self
+        while token and token.astParent:
+            token = token.astParent
+            yield token
+
+    def astTop(self):
+        top = None
+        for parent in self.astParents():
+            top = parent
+        return top
+
+    def tokAt(self, n):
+        tl = self.forward()
+        if n < 0:
+            tl = self.backward()
+            n = -n
+        for i, t in enumerate(tl):
+            if i == n:
+                return t
+        return None
+
+    def linkAt(self, n):
+        token = self.tokAt(n)
+        if token:
+            return token.link
+        return None
 
 class Scope:
     """
     Scope. Information about global scope, function scopes, class scopes, inner scopes, etc.
-    C++ class: http://cppcheck.net/devinfo/doxyoutput/classScope.html
+    C++ class: https://cppcheck.sourceforge.io/devinfo/doxyoutput/classScope.html
 
     Attributes
         bodyStart      The { Token for this scope
@@ -293,8 +558,13 @@ class Scope:
                        For a class scope, this is the class name.
         function       If this scope belongs at a function call, this attribute
                        has the Function information. See the Function class.
-        type           Type of scope: Global, Function, Class, If, While
+        functions      if this is a Class type, it may have functions defined
+        nestedIn
+        type           Type of scope: Function, If/Else/For/While/Switch/Global/Enum/Struct/Namespace/Class/Constructor/Destructor
+        isExecutable   True when the type is: Function/If/Else/For/While/Do/Switch/Try/Catch/Unconditional/Lambda
+        definedType
     """
+    #symboldatabase.cpp/SymbolDatabase::printXml
 
     Id = None
     bodyStartId = None
@@ -306,98 +576,158 @@ class Scope:
     function = None
     nestedInId = None
     nestedIn = None
+    nestedList = None
     type = None
     isExecutable = None
+    varlistId = None
+    varlist = None
 
     def __init__(self, element):
         self.Id = element.get('id')
         self.className = element.get('className')
         self.functionId = element.get('function')
         self.function = None
+        self.functions = []
         self.bodyStartId = element.get('bodyStart')
         self.bodyStart = None
         self.bodyEndId = element.get('bodyEnd')
         self.bodyEnd = None
         self.nestedInId = element.get('nestedIn')
         self.nestedIn = None
+        self.nestedList = []
         self.type = element.get('type')
-        self.isExecutable = (self.type in ('Function', 'If', 'Else', 'For', 'While', 'Do', 'Switch', 'Try', 'Catch', 'Unconditional', 'Lambda'))
+        self.definedType = element.get('definedType')
+        self.isExecutable = (self.type in ('Function', 'If', 'Else', 'For', 'While', 'Do',
+                                           'Switch', 'Try', 'Catch', 'Unconditional', 'Lambda'))
+
+        self.varlistId = []
+        self.varlist = []
+
+    def __repr__(self):
+        attrs = ["Id", "className", "functionId", "bodyStartId", "bodyEndId",
+                 "nestedInId", "nestedIn", "type", "definedType", "isExecutable", "functions"]
+        return "{}({})".format(
+            "Scope",
+            ", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
+        )
 
     def setId(self, IdMap):
         self.bodyStart = IdMap[self.bodyStartId]
         self.bodyEnd = IdMap[self.bodyEndId]
         self.nestedIn = IdMap[self.nestedInId]
+        if self.nestedIn:
+            self.nestedIn.nestedList.append(self)
         self.function = IdMap[self.functionId]
+        for v in self.varlistId:
+            value = IdMap.get(v)
+            if value:
+                self.varlist.append(value)
 
 
 class Function:
     """
     Information about a function
     C++ class:
-    http://cppcheck.net/devinfo/doxyoutput/classFunction.html
+    https://cppcheck.sourceforge.io/devinfo/doxyoutput/classFunction.html
 
     Attributes
-        argument                Argument list
+        argument                Argument list (dict of argument number and variable)
+        token                   Token in function implementation
         tokenDef                Token in function definition
-        isVirtual               Is this function is virtual
+        name
+        type                    Constructor/CopyConstructor/MoveConstructor/OperatorEqual/Destructor/Function/Lambda/Unknown
+        hasVirtualSpecifier     Is this function is virtual
         isImplicitlyVirtual     Is this function is virtual this in the base classes
+        access                  Public/Protected/Private
+        isInlineKeyword         Is inline keyword used
+        isStatic                Is this function static
+        isAttributeNoreturn
+        overriddenFunction
     """
+    #symboldatabase.cpp/SymbolDatabase::printXml
 
     Id = None
     argument = None
     argumentId = None
+    token = None
+    tokenId = None
     tokenDef = None
     tokenDefId = None
     name = None
     type = None
-    isVirtual = None
+    access = None
     isImplicitlyVirtual = None
+    hasVirtualSpecifier = None
+    isInlineKeyword = None
+    isStatic = None
+    isAttributeNoreturn = None
+    overriddenFunction = None
+    nestedIn = None
 
-    def __init__(self, element):
+    def __init__(self, element, nestedIn):
         self.Id = element.get('id')
+        self.tokenId = element.get('token')
         self.tokenDefId = element.get('tokenDef')
         self.name = element.get('name')
         self.type = element.get('type')
-        isVirtual = element.get('isVirtual')
-        self.isVirtual = (isVirtual and isVirtual == 'true')
-        isImplicitlyVirtual = element.get('isImplicitlyVirtual')
-        self.isImplicitlyVirtual = (isImplicitlyVirtual and isImplicitlyVirtual == 'true')
+        self.hasVirtualSpecifier = element.get('hasVirtualSpecifier', 'false') == 'true'
+        self.isImplicitlyVirtual = element.get('isImplicitlyVirtual', 'false') == 'true'
+        self.access = element.get('access')
+        self.isInlineKeyword = element.get('isInlineKeyword', 'false') == 'true'
+        self.isStatic = element.get('isStatic', 'false') == 'true'
+        self.isAttributeNoreturn = element.get('isAttributeNoreturn', 'false') == 'true'
+        self.overriddenFunction = element.get('overriddenFunction', 'false') == 'true'
+        self.nestedIn = nestedIn
 
         self.argument = {}
         self.argumentId = {}
-        for arg in element:
-            self.argumentId[int(arg.get('nr'))] = arg.get('variable')
+
+    def __repr__(self):
+        attrs = ["Id", "tokenId", "tokenDefId", "name", "type", "hasVirtualSpecifier",
+                 "isImplicitlyVirtual", "access", "isInlineKeyword", "isStatic", 
+                 "isAttributeNoreturn", "overriddenFunction", "nestedIn", "argumentId"]
+        return "{}({})".format(
+            "Function",
+            ", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
+        )
 
     def setId(self, IdMap):
         for argnr, argid in self.argumentId.items():
             self.argument[argnr] = IdMap[argid]
+        self.token = IdMap.get(self.tokenId, None)
         self.tokenDef = IdMap[self.tokenDefId]
 
 
+#todo add class Types:
+    #symboldatabase.cpp/SymbolDatabase::printXml
+
+
 class Variable:
     """
     Information about a variable
     C++ class:
-    http://cppcheck.net/devinfo/doxyoutput/classVariable.html
+    https://cppcheck.sourceforge.io/devinfo/doxyoutput/classVariable.html
 
     Attributes:
         nameToken       Name token in variable declaration
         typeStartToken  Start token of variable declaration
         typeEndToken    End token of variable declaration
-        access          Global/Local/Namespace/Public/Protected/Public/Throw/Argument
+        access          Global/Local/Namespace/Public/Protected/Public/Throw/Argument/Unknown
         scope           Variable scope
+        constness       Variable constness (same encoding as ValueType::constness)
         isArgument      Is this variable a function argument?
+        isGlobal        Is this variable a global variable?
+        isLocal         Is this variable a local variable?
         isArray         Is this variable an array?
         isClass         Is this variable a class or struct?
         isConst         Is this variable a const variable?
-        isGlobal        Is this variable a global variable?
         isExtern        Is this variable an extern variable?
-        isLocal         Is this variable a local variable?
         isPointer       Is this variable a pointer
         isReference     Is this variable a reference
         isStatic        Is this variable static?
-        constness       Variable constness (same encoding as ValueType::constness)
+        isVolatile      Is this variable volatile?
     """
+    #symboldatabase.cpp/SymbolDatabase::printXml
 
     Id = None
     nameTokenId = None
@@ -419,6 +749,7 @@ class Variable:
     isPointer = False
     isReference = False
     isStatic = False
+    isVolatile = False
     constness = 0
 
     def __init__(self, element):
@@ -430,21 +761,30 @@ def __init__(self, element):
         self.typeEndTokenId = element.get('typeEndToken')
         self.typeEndToken = None
         self.access = element.get('access')
+        self.isArgument = (self.access and self.access == 'Argument')
+        self.isGlobal = (self.access and self.access == 'Global')
+        self.isLocal = (self.access and self.access == 'Local')
         self.scopeId = element.get('scope')
         self.scope = None
-        self.isArgument = element.get('isArgument') == 'true'
+        self.constness = int(element.get('constness',0))
         self.isArray = element.get('isArray') == 'true'
         self.isClass = element.get('isClass') == 'true'
         self.isConst = element.get('isConst') == 'true'
-        self.isGlobal = element.get('access') == 'Global'
         self.isExtern = element.get('isExtern') == 'true'
-        self.isLocal = element.get('isLocal') == 'true'
         self.isPointer = element.get('isPointer') == 'true'
         self.isReference = element.get('isReference') == 'true'
         self.isStatic = element.get('isStatic') == 'true'
-        self.constness = element.get('constness')
-        if self.constness:
-            self.constness = int(self.constness)
+        self.isVolatile = element.get('isVolatile') == 'true'
+
+    def __repr__(self):
+        attrs = ["Id", "nameTokenId", "typeStartTokenId", "typeEndTokenId",
+                 "access", "scopeId", "isArgument", "isArray", "isClass",
+                 "isConst", "isGlobal", "isExtern", "isLocal", "isPointer",
+                 "isReference", "isStatic", "isVolatile", "constness"]
+        return "{}({})".format(
+            "Variable",
+            ", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
+        )
 
     def setId(self, IdMap):
         self.nameToken = IdMap[self.nameTokenId]
@@ -452,6 +792,128 @@ def setId(self, IdMap):
         self.typeEndToken = IdMap[self.typeEndTokenId]
         self.scope = IdMap[self.scopeId]
 
+class Container:
+    """
+    Container class -- information about containers
+
+    Attributes:
+        array-like-index-op true/false
+        stdStringLike       true/false
+    """
+    #tokenizer.cpp/tokenizer::dump
+    Id = None
+
+    def __init__(self, element):
+        self.Id = element.get('id')
+        self.arrayLikeIndexOp = element.get('array-like-index-op') == 'true'
+        self.stdStringLike = element.get('std-string-like') == 'true'
+
+class TypedefInfo:
+    """
+    TypedefInfo class -- information about typedefs
+
+    Attributes:
+        name   name of the typedef
+        used   0/1
+    """
+    #tokenizer.cpp/tokenizer::dump
+
+    name = None
+    used = None
+    file = None
+    linenr = None
+    column = None
+
+    def __init__(self, element):
+        self.name = element.get('name')
+        _load_location(self, element)
+        self.used = (element.get('used') == '1')
+
+class Value:
+    """
+    Value class
+
+    Attributes:
+        intvalue         integer value
+        tokvalue         token value
+        floatvalue       float value
+        movedvalue
+        uninit
+        containerSize    container size
+        bufferSize       buffer size
+        lifetimeScope    Local/Argument/SubFunction/ThisPointer/ThisValue
+        lifetimeKind     Object/SubObject/Lambda/Iterator/Address
+        symbolicDelta
+        condition        condition where this Value comes from
+        bound            Upper/Lower/Point
+        valueKind        known/possible/impossible/inconclusive
+        path             0/1/2/3/..
+    """
+    #token.cpp/token::printValueFlow
+
+    intvalue = None
+    tokvalue = None
+    floatvalue = None
+    containerSize = None
+    condition = None
+    valueKind = None
+
+    def isKnown(self):
+        return self.valueKind and self.valueKind == 'known'
+
+    def isPossible(self):
+        return self.valueKind and self.valueKind == 'possible'
+
+    def isImpossible(self):
+        return self.valueKind and self.valueKind == 'impossible'
+
+    def isInconclusive(self):
+        return self.valueKind and self.valueKind == 'inconclusive'
+
+    def __init__(self, element):
+        self.intvalue = element.get('intvalue')
+        if self.intvalue:
+            self.intvalue = int(self.intvalue)
+        self._tokvalueId = element.get('tokvalue')
+        self.floatvalue = element.get('floatvalue')
+        self.movedvalue = element.get('movedvalue')
+        self.uninit = element.get('uninit')
+        self.bufferSize = element.get('buffer-size')
+        self.containerSize = element.get('container-size')
+        self.iteratorStart = element.get('iterator-start')
+        self.iteratorEnd = element.get('iterator-end')
+        self._lifetimeId = element.get('lifetime')
+        self.lifetimeScope = element.get('lifetime-scope')
+        self.lifetimeKind = element.get('lifetime-kind')
+        self._symbolicId = element.get('symbolic')
+        self.symbolicDelta = element.get('symbolic-delta')
+        self.bound = element.get('bound')
+        self.condition = element.get('condition-line')
+        if self.condition:
+            self.condition = int(self.condition)
+        if element.get('known'):
+            self.valueKind = 'known'
+        elif element.get('possible'):
+            self.valueKind = 'possible'
+        elif element.get('impossible'):
+            self.valueKind = 'impossible'
+        elif element.get('inconclusive'):
+            self.valueKind = 'inconclusive'
+        self.path = element.get('path')
+
+    def setId(self, IdMap):
+        self.tokvalue = IdMap.get(self._tokvalueId)
+        self.lifetime = IdMap.get(self._lifetimeId)
+        self.symbolic = IdMap.get(self._symbolicId)
+
+    def __repr__(self):
+        attrs = ["intvalue", "tokvalue", "floatvalue", "movedvalue", "uninit",
+                 "bufferSize", "containerSize", "condition", "valueKind"]
+        return "{}({})".format(
+            "Value",
+            ", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
+        )
+
 
 class ValueFlow:
     """
@@ -459,7 +921,7 @@ class ValueFlow:
     Each possible value has a ValueFlow::Value item.
     Each ValueFlow::Value either has a intvalue or tokvalue
     C++ class:
-    http://cppcheck.net/devinfo/doxyoutput/classValueFlow_1_1Value.html
+    https://cppcheck.sourceforge.io/devinfo/doxyoutput/classValueFlow_1_1Value.html
 
     Attributes:
         values    Possible values
@@ -468,56 +930,17 @@ class ValueFlow:
     Id = None
     values = None
 
-    class Value:
-        """
-        Value class
-
-        Attributes:
-            intvalue         integer value
-            tokvalue         token value
-            floatvalue       float value
-            containerSize    container size
-            condition        condition where this Value comes from
-            valueKind        'known' or 'possible'
-            inconclusive     Is value inconclusive?
-        """
-
-        intvalue = None
-        tokvalue = None
-        floatvalue = None
-        containerSize = None
-        condition = None
-        valueKind = None
-        inconclusive = False
-
-        def isKnown(self):
-            return self.valueKind and self.valueKind == 'known'
-
-        def isPossible(self):
-            return self.valueKind and self.valueKind == 'possible'
-
-        def __init__(self, element):
-            self.intvalue = element.get('intvalue')
-            if self.intvalue:
-                self.intvalue = int(self.intvalue)
-            self.tokvalue = element.get('tokvalue')
-            self.floatvalue = element.get('floatvalue')
-            self.containerSize = element.get('container-size')
-            self.condition = element.get('condition-line')
-            if self.condition:
-                self.condition = int(self.condition)
-            if element.get('known'):
-                self.valueKind = 'known'
-            elif element.get('possible'):
-                self.valueKind = 'possible'
-            if element.get('inconclusive'):
-                self.inconclusive = True
-
     def __init__(self, element):
         self.Id = element.get('id')
         self.values = []
-        for value in element:
-            self.values.append(ValueFlow.Value(value))
+
+    def __repr__(self):
+        attrs = ["Id", "values"]
+        return "{}({})".format(
+            "ValueFlow",
+            ", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
+        )
+
 
 class Suppression:
     """
@@ -529,27 +952,65 @@ class Suppression:
       fileName    The name of the file to suppress warnings for, can include wildcards
       lineNumber  The number of the line to suppress warnings from, can be 0 to represent any line
       symbolName  The name of the symbol to match warnings for, can include wildcards
+      lineBegin   The first line to suppress warnings from
+      lineEnd     The last line to suppress warnings from
+      suppressionType   The type of suppression which is applied (unique = None (default), file, block, blockBegin, blockEnd, macro)
     """
 
     errorId = None
     fileName = None
     lineNumber = None
     symbolName = None
+    lineBegin = None
+    lineEnd = None
+    suppressionType = None
 
     def __init__(self, element):
         self.errorId = element.get('errorId')
         self.fileName = element.get('fileName')
         self.lineNumber = element.get('lineNumber')
         self.symbolName = element.get('symbolName')
+        self.lineBegin = element.get('lineBegin')
+        self.lineEnd = element.get('lineEnd')
+        self.suppressionType = element.get('type')
+
+    def __repr__(self):
+        attrs = ["errorId", "fileName", "lineNumber", "symbolName", "lineBegin", "lineEnd","suppressionType"]
+        return "{}({})".format(
+            "Suppression",
+            ", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
+        )
 
     def isMatch(self, file, line, message, errorId):
+        # Line Suppression
         if ((self.fileName is None or fnmatch(file, self.fileName))
-            and (self.lineNumber is None or line == self.lineNumber)
-            and (self.symbolName is None or fnmatch(message, '*'+self.symbolName+'*'))
-            and fnmatch(errorId, self.errorId)):
+                and (self.suppressionType is None) # Verify use of default suppression type (None = unique)
+                and (self.lineNumber is not None and int(line) == int(self.lineNumber))
+                and (self.symbolName is None or fnmatch(message, '*'+self.symbolName+'*'))
+                and fnmatch(errorId, self.errorId)):
             return True
-        else:
-            return False
+        # File Suppression
+        if ((self.fileName is None or fnmatch(file, self.fileName))
+                and (self.suppressionType is not None and self.suppressionType == "file") # Verify use of file (global) suppression type
+                and (self.symbolName is None or fnmatch(message, '*'+self.symbolName+'*'))
+                and fnmatch(errorId, self.errorId)):
+            return True
+        # Block Suppression Mode
+        if ((self.fileName is None or fnmatch(file, self.fileName))
+                and (self.suppressionType is not None and self.suppressionType == "block") # Type for Block suppression
+                and (self.lineBegin is not None and int(line) > int(self.lineBegin)) # Code Match is between the Block suppression
+                and (self.lineEnd is not None and int(line) < int(self.lineEnd)) # Code Match is between the Block suppression
+                and (self.symbolName is None or fnmatch(message, '*'+self.symbolName+'*'))
+                and fnmatch(errorId, self.errorId)):
+            return True
+        # Other Suppression (Globaly set via suppression file or cli command)
+        if ((self.fileName is None or fnmatch(file, self.fileName))
+                and (self.suppressionType is None)
+                and (self.symbolName is None or fnmatch(message, '*'+self.symbolName+'*'))
+                and fnmatch(errorId, self.errorId)):
+            return True
+        return False
+
 
 class Configuration:
     """
@@ -560,73 +1021,63 @@ class Configuration:
     Attributes:
         name          Name of the configuration, "" for default
         directives    List of Directive items
+        macro_usage   List of used macros
+        preprocessor_if_conditions  List of preprocessor if conditions that was evaluated during preprocessing
         tokenlist     List of Token items
         scopes        List of Scope items
+        containers    List of Container items
         functions     List of Function items
         variables     List of Variable items
         valueflow     List of ValueFlow values
+        standards     List of Standards values
     """
 
     name = ''
     directives = []
+    macro_usage = []
+    preprocessor_if_conditions = []
     tokenlist = []
     scopes = []
+    containers = []
     functions = []
     variables = []
+    typedefInfo = []
     valueflow = []
+    standards = None
+    clang_warnings = []
 
-    def __init__(self, confignode):
-        self.name = confignode.get('cfg')
+    def __init__(self, name):
+        self.name = name
         self.directives = []
+        self.macro_usage = []
+        self.preprocessor_if_conditions = []
         self.tokenlist = []
         self.scopes = []
+        self.containers = []
         self.functions = []
         self.variables = []
+        self.typedefInfo = []
         self.valueflow = []
-        arguments = []
-
-        for element in confignode:
-            if element.tag == "standards":
-                self.standards = Standards(element)
-
-            if element.tag == 'directivelist':
-                for directive in element:
-                    self.directives.append(Directive(directive))
-
-            if element.tag == 'tokenlist':
-                for token in element:
-                    self.tokenlist.append(Token(token))
-
-                # set next/previous..
-                prev = None
-                for token in self.tokenlist:
-                    token.previous = prev
-                    if prev:
-                        prev.next = token
-                    prev = token
-            if element.tag == 'scopes':
-                for scope in element:
-                    self.scopes.append(Scope(scope))
-                    for functionList in scope:
-                        if functionList.tag == 'functionList':
-                            for function in functionList:
-                                self.functions.append(Function(function))
-            if element.tag == 'variables':
-                for variable in element:
-                    var = Variable(variable)
-                    if var.nameTokenId:
-                        self.variables.append(var)
-                    else:
-                        arguments.append(var)
-            if element.tag == 'valueflow':
-                for values in element:
-                    self.valueflow.append(ValueFlow(values))
+        self.standards = Standards()
+        self.clang_warnings = []
+
+    def set_tokens_links(self):
+        """Set next/previous links between tokens."""
+        prev = None
+        for token in self.tokenlist:
+            token.previous = prev
+            if prev:
+                prev.next = token
+            prev = token
 
-        IdMap = {None: None, '0': None, '00000000': None, '0000000000000000': None}
+    def set_id_map(self, arguments):
+        IdMap = {None: None, '0': None, '00000000': None, '0000000000000000': None, '0x0': None}
         for token in self.tokenlist:
             IdMap[token.Id] = token
         for scope in self.scopes:
             IdMap[scope.Id] = scope
+        for container in self.containers:
+            IdMap[container.Id] = container
         for function in self.functions:
             IdMap[function.Id] = function
         for variable in self.variables:
@@ -635,11 +1086,12 @@ def __init__(self, confignode):
             IdMap[variable.Id] = variable
         for values in self.valueflow:
             IdMap[values.Id] = values.values
-
         for token in self.tokenlist:
             token.setId(IdMap)
         for scope in self.scopes:
             scope.setId(IdMap)
+        #for container in self.containers:
+        #    container.setId(IdMap)
         for function in self.functions:
             function.setId(IdMap)
         for variable in self.variables:
@@ -647,6 +1099,13 @@ def __init__(self, confignode):
         for variable in arguments:
             variable.setId(IdMap)
 
+    def setIdMap(self, functions_arguments):
+        """Set relationships between objects stored in this configuration.
+        :param functions_arguments: List of Variable objects which are function arguments
+        """
+        self.set_tokens_links()
+        self.set_id_map(functions_arguments)
+
 
 class Platform:
     """
@@ -654,7 +1113,7 @@ class Platform:
     This class contains type sizes
 
     Attributes:
-        name          Name of the platform
+        name          Name of the platform: unspecified/native/win32A/win32W/win64/unix32/unix64/platformFile
         char_bit      CHAR_BIT value
         short_bit     SHORT_BIT value
         int_bit       INT_BIT value
@@ -680,6 +1139,15 @@ def __init__(self, platformnode):
         self.long_long_bit = int(platformnode.get('long_long_bit'))
         self.pointer_bit = int(platformnode.get('pointer_bit'))
 
+    def __repr__(self):
+        attrs = ["name", "char_bit", "short_bit", "int_bit",
+                 "long_bit", "long_long_bit", "pointer_bit"]
+        return "{}({})".format(
+            "Platform",
+            ", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
+        )
+
+
 class Standards:
     """
     Standards class
@@ -691,10 +1159,26 @@ class Standards:
         posix        If Posix was used
     """
 
-    def __init__(self, standardsnode):
-        self.c = standardsnode.find("c").get("version")
-        self.cpp = standardsnode.find("cpp").get("version")
-        self.posix = standardsnode.find("posix") != None
+    c = ""
+    cpp = ""
+    posix = False
+
+    def set_c(self, node):
+        self.c = node.get("version")
+
+    def set_cpp(self, node):
+        self.cpp = node.get("version")
+
+    def set_posix(self, node):
+        self.posix = node.get("posix") is not None
+
+    def __repr__(self):
+        attrs = ["c", "cpp", "posix"]
+        return "{}({})".format(
+            "Standards",
+            ", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
+        )
+
 
 class CppcheckData:
     """
@@ -702,7 +1186,10 @@ class CppcheckData:
     Contains a list of Configuration instances
 
     Attributes:
-        configurations    List of Configurations
+        filename          Path to Cppcheck dump file
+        rawTokens         List of rawToken elements
+        suppressions      List of Suppressions
+        files             Source files for elements occurred in this configuration
 
     To iterate through all configurations use such code:
     @code
@@ -732,46 +1219,210 @@ class CppcheckData:
     @endcode
     """
 
-    rawTokens = []
-    platform = None
-    configurations = []
-    suppressions = []
-
     def __init__(self, filename):
-        self.configurations = []
+        """
+        :param filename: Path to Cppcheck dump file
+        """
+        self.language = None
+        self.filename = filename
+        self.rawTokens = []
+        self.platform = None
+        self.suppressions = []
+        self.files = [] # source files for elements occurred in this configuration
+
+        platform_done = False
+        rawtokens_done = False
+        suppressions_done = False
+
+        # Parse general configuration options from <dumps> node
+        # We intentionally don't clean node resources here because we
+        # want to serialize in memory only small part of the XML tree.
+        for event, node in ElementTree.iterparse(self.filename, events=('start', 'end')):
+            if platform_done and rawtokens_done and suppressions_done:
+                break
+            if node.tag == 'dumps':
+                self.language = node.get('language')
+            if node.tag == 'platform' and event == 'start':
+                self.platform = Platform(node)
+                platform_done = True
+            elif node.tag == 'rawtokens' and event == 'end':
+                for rawtokens_node in node:
+                    if rawtokens_node.tag == 'file':
+                        self.files.append(rawtokens_node.get('name'))
+                    elif rawtokens_node.tag == 'tok':
+                        tok = Token(rawtokens_node)
+                        tok.file = self.files[int(rawtokens_node.get('fileIndex'))]
+                        self.rawTokens.append(tok)
+                rawtokens_done = True
+            elif node.tag == 'suppressions' and event == 'end':
+                for suppressions_node in node:
+                    self.suppressions.append(Suppression(suppressions_node))
+                suppressions_done = True
+
+        global current_dumpfile_suppressions
+        current_dumpfile_suppressions = self.suppressions
+
+        # Set links between rawTokens.
+        for i in range(len(self.rawTokens)-1):
+            self.rawTokens[i+1].previous = self.rawTokens[i]
+            self.rawTokens[i].next = self.rawTokens[i+1]
+
+    @property
+    def configurations(self):
+        """
+        Return the list of all available Configuration objects.
+        """
+        return list(self.iterconfigurations())
 
-        data = ET.parse(filename)
+    def iterconfigurations(self):
+        """
+        Create and return iterator for the available Configuration objects.
+        The iterator loops over all Configurations in the dump file tree, in document order.
+        """
+        cfg = None
+        cfg_arguments = []  # function arguments for Configuration node initialization
+        cfg_function = None
+        cfg_valueflow = None
+
+        # Iterating <varlist> in a <scope>.
+        iter_scope_varlist = False
+
+        # Iterating <typedef-info>
+        iter_typedef_info = False
+
+        # Iterating <directive>
+        iter_directive = False
+
+        # Use iterable objects to traverse XML tree for dump files incrementally.
+        # Iterative approach is required to avoid large memory consumption.
+        # Calling .clear() is necessary to let the element be garbage collected.
+        for event, node in ElementTree.iterparse(self.filename, events=('start', 'end')):
+            # Serialize new configuration node
+            if node.tag == 'dump':
+                if event == 'start':
+                    cfg = Configuration(node.get('cfg'))
+                    continue
+                if event == 'end':
+                    cfg.setIdMap(cfg_arguments)
+                    yield cfg
+                    cfg = None
+                    cfg_arguments = []
+
+            elif node.tag == 'clang-warning' and event == 'start':
+                cfg.clang_warnings.append({'file': node.get('file'),
+                                           'line': int(node.get('line')),
+                                           'column': int(node.get('column')),
+                                           'message': node.get('message')})
+            # Parse standards
+            elif node.tag == "standards" and event == 'start':
+                continue
+            elif node.tag == 'c' and event == 'start':
+                cfg.standards.set_c(node)
+            elif node.tag == 'cpp' and event == 'start':
+                cfg.standards.set_cpp(node)
+            elif node.tag == 'posix' and event == 'start':
+                cfg.standards.set_posix(node)
+
+            # Parse directives list
+            elif node.tag == 'directive':
+                if event == 'start':
+                    cfg.directives.append(Directive(node))
+                    iter_directive = True
+                elif event == 'end':
+                    iter_directive = False
+            # Parse macro usage
+            elif node.tag == 'macro' and event == 'start':
+                cfg.macro_usage.append(MacroUsage(node))
+
+            # Preprocessor #if/#elif condition
+            elif node.tag == "if-cond" and event == 'start':
+                cfg.preprocessor_if_conditions.append(PreprocessorIfCondition(node))
+
+            # Parse tokens
+            elif node.tag == 'tokenlist' and event == 'start':
+                continue
+            elif node.tag == 'token' and event == 'start' and not iter_directive and not iter_typedef_info:
+                cfg.tokenlist.append(Token(node))
 
-        for platformNode in data.getroot():
-            if platformNode.tag == 'platform':
-                self.platform = Platform(platformNode)
+            # Parse scopes
+            elif node.tag == 'scopes' and event == 'start':
+                continue
+            elif node.tag == 'scope' and event == 'start':
+                cfg.scopes.append(Scope(node))
+            elif node.tag == 'varlist':
+                if event == 'start':
+                    iter_scope_varlist = True
+                elif event == 'end':
+                    iter_scope_varlist = False
+
+            # Parse functions
+            elif node.tag == 'functionList' and event == 'start':
+                continue
+            elif node.tag == 'function':
+                if event == 'start':
+                    cfg_function = Function(node, cfg.scopes[-1])
+                    continue
+                if event == 'end':
+                    cfg.functions.append(cfg_function)
+                    cfg_function = None
+
+            # Parse function arguments
+            elif node.tag == 'arg' and event == 'start':
+                arg_nr = int(node.get('nr'))
+                arg_variable_id = node.get('variable')
+                cfg_function.argumentId[arg_nr] = arg_variable_id
+
+            # Parse variables
+            elif node.tag == 'var' and event == 'start':
+                if iter_scope_varlist:
+                    cfg.scopes[-1].varlistId.append(node.get('id'))
+                else:
+                    var = Variable(node)
+                    if var.nameTokenId:
+                        cfg.variables.append(var)
+                    else:
+                        cfg_arguments.append(var)
 
-        for rawTokensNode in data.getroot():
-            if rawTokensNode.tag != 'rawtokens':
+            # Parse containers
+            elif node.tag == 'containers' and event == 'start':
                 continue
-            files = []
-            for node in rawTokensNode:
-                if node.tag == 'file':
-                    files.append(node.get('name'))
-                elif node.tag == 'tok':
-                    tok = Token(node)
-                    tok.file = files[int(node.get('fileIndex'))]
-                    self.rawTokens.append(tok)
-            for i in range(len(self.rawTokens) - 1):
-                self.rawTokens[i + 1].previous = self.rawTokens[i]
-                self.rawTokens[i].next = self.rawTokens[i + 1]
+            elif node.tag == 'container' and event == 'start':
+                cfg.containers.append(Container(node))
+
+            # Parse typedef info
+            elif node.tag == 'typedef-info':
+                iter_typedef_info = (event == 'start')
+            elif iter_typedef_info and node.tag == 'info' and event == 'start':
+                cfg.typedefInfo.append(TypedefInfo(node))
 
+            # Parse template-token
+            #elif node.tag == 'TokenAndName' and event == 'start': #todo add processing of containers
+            #    cfg.containers.append(Container(node))
 
-        for suppressionsNode in data.getroot():
-            if suppressionsNode.tag == "suppressions":
-                for suppression in suppressionsNode:
-                    self.suppressions.append(Suppression(suppression))
+            # Parse valueflows (list of values)
+            elif node.tag == 'valueflow' and event == 'start':
+                continue
+            elif node.tag == 'values':
+                if event == 'start':
+                    cfg_valueflow = ValueFlow(node)
+                    continue
+                if event == 'end':
+                    cfg.valueflow.append(cfg_valueflow)
+                    cfg_valueflow = None
+
+            # Parse values
+            elif node.tag == 'value' and event == 'start':
+                cfg_valueflow.values.append(Value(node))
 
+            # Remove links to the sibling nodes
+            node.clear()
 
-        # root is 'dumps' node, each config has its own 'dump' subnode.
-        for cfgnode in data.getroot():
-            if cfgnode.tag == 'dump':
-                self.configurations.append(Configuration(cfgnode))
+    def __repr__(self):
+        attrs = ["configurations", "platform"]
+        return "{}({})".format(
+            "CppcheckData",
+            ", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
+        )
 
 
 # Get function arguments
@@ -842,8 +1493,8 @@ def _split_lines(self, text, width):
 
 def ArgumentParser():
     """
-        Returns an argparse argument parser with an already-added
-        argument definition for -t/--template
+    Returns an argparse argument parser with an already-added
+    argument definition for -t/--template
     """
     parser = argparse.ArgumentParser(formatter_class=CppCheckFormatter)
     parser.add_argument('-t', '--template', metavar='<text>',
@@ -853,9 +1504,36 @@ def ArgumentParser():
                         "'{file}({line}):({severity}) {message}' or\n"
                         "'{callstack} {message}'\n"
                         "Pre-defined templates: gcc, vs, edit")
+    parser.add_argument("dumpfile", nargs='*',
+                        help="Path of dump files from cppcheck.")
+    parser.add_argument("--cli",
+                        help="Addon is executed from Cppcheck",
+                        action="store_true")
+    parser.add_argument("--file-list", metavar='<text>',
+                        default=None,
+                        help="file list in a text file")
+    parser.add_argument("-q", "--quiet",
+                        help='do not print "Checking ..." lines',
+                        action="store_true")
     return parser
 
 
+def get_files(args):
+    """Return dump_files, ctu_info_files"""
+    all_files = args.dumpfile
+    if args.file_list:
+        with open(args.file_list, 'rt') as f:
+            for line in f.readlines():
+                all_files.append(line.rstrip())
+    dump_files = []
+    ctu_info_files = []
+    for f in all_files:
+        if f.endswith('.ctu-info'):
+            ctu_info_files.append(f)
+        else:
+            dump_files.append(f)
+    return dump_files, ctu_info_files
+
 def simpleMatch(token, pattern):
     for p in pattern.split(' '):
         if not token or token.str != p:
@@ -863,12 +1541,144 @@ def simpleMatch(token, pattern):
         token = token.next
     return True
 
+patterns = {
+    '%any%': lambda tok: tok,
+    '%assign%': lambda tok: tok if tok.isAssignmentOp else None,
+    '%comp%': lambda tok: tok if tok.isComparisonOp else None,
+    '%name%': lambda tok: tok if tok.isName else None,
+    '%op%': lambda tok: tok if tok.isOp else None,
+    '%or%': lambda tok: tok if tok.str == '|' else None,
+    '%oror%': lambda tok: tok if tok.str == '||' else None,
+    '%var%': lambda tok: tok if tok.variable else None,
+    '(*)': lambda tok: tok.link if tok.str == '(' else None,
+    '[*]': lambda tok: tok.link if tok.str == '[' else None,
+    '{*}': lambda tok: tok.link if tok.str == '{' else None,
+    '<*>': lambda tok: tok.link if tok.str == '<' and tok.link else None,
+}
+
+def match_atom(token, p):
+    if not token:
+        return None
+    if not p:
+        return None
+    if token.str == p:
+        return token
+    if p in ['!', '|', '||', '%', '!=', '*']:
+        return None
+    if p in patterns:
+        return patterns[p](token)
+    if '|' in p:
+        for x in p.split('|'):
+            t = match_atom(token, x)
+            if t:
+                return t
+    elif p.startswith('!!'):
+        t = match_atom(token, p[2:])
+        if not t:
+            return token
+    elif p.startswith('**'):
+        a = p[2:]
+        t = token
+        while t:
+            if match_atom(t, a):
+                return t
+            if t.link and t.str in ['(', '[', '<', '{']:
+                t = t.link
+            t = t.next
+    return None
+
+class MatchResult:
+    def __init__(self, matches, bindings=None, keys=None):
+        self.__dict__.update(bindings or {})
+        self._matches = matches
+        self._keys = keys or []
+
+    def __bool__(self):
+        return self._matches
+
+    def __nonzero__(self):
+        return self._matches
+
+    def __getattr__(self, k):
+        if k in self._keys:
+            return None
+        raise AttributeError
+
+def bind_split(s):
+    if '@' in s:
+        p = s.partition('@')
+        return (p[0], p[2])
+    return (s, None)
+
+def match(token, pattern):
+    if not pattern:
+        return MatchResult(False)
+    end = None
+    bindings = {}
+    words = [bind_split(word) for word in pattern.split()]
+    for p, b in words:
+        t = match_atom(token, p)
+        if b:
+            bindings[b] = token
+        if not t:
+            return MatchResult(False, keys=[xx for pp, xx in words]+['end'])
+        end = t
+        token = t.next
+    bindings['end'] = end
+    return MatchResult(True, bindings=bindings)
+
+def get_function_call_name_args(token):
+    """Get function name and arguments for function call
+    name, args = get_function_call_name_args(tok)
+    """
+    if token is None:
+        return None, None
+    if not token.isName or not token.scope.isExecutable:
+        return None, None
+    if not simpleMatch(token.next, '('):
+        return None, None
+    if token.function:
+        nametok = token.function.token
+        if nametok is None:
+            nametok = token.function.tokenDef
+        if token in (token.function.token, token.function.tokenDef):
+            return None, None
+        name = nametok.str
+        while nametok.previous and nametok.previous.previous and nametok.previous.str == '::' and nametok.previous.previous.isName:
+            name = nametok.previous.previous.str + '::' + name
+            nametok = nametok.previous.previous
+        scope = token.function.nestedIn
+        while scope:
+            if scope.className:
+                name = scope.className + '::' + name
+            scope = scope.nestedIn
+    else:
+        nametok = token
+        name = nametok.str
+        while nametok.previous and nametok.previous.previous and nametok.previous.str == '::' and nametok.previous.previous.isName:
+            name = nametok.previous.previous.str + '::' + name
+            nametok = nametok.previous.previous
+    return name, getArguments(token)
+
+def is_suppressed(location, message, errorId):
+    for suppression in current_dumpfile_suppressions:
+        if suppression.isMatch(location.file, location.linenr, message, errorId):
+            return True
+    return False
+
+def log_checker(message, addon):
+    if '--cli' in sys.argv:
+        msg = { 'addon': addon,
+                'severity': 'none',
+                'message': message,
+                'errorId': 'logChecker'}
+        sys.stdout.write(json.dumps(msg) + '\n')
 
-def reportError(location, severity, message, addon, errorId, extra=''):
+def reportError(location, severity, message, addon, errorId, extra='', columnOverride=None):
     if '--cli' in sys.argv:
         msg = { 'file': location.file,
                 'linenr': location.linenr,
-                'column': location.column,
+                'column': location.column if columnOverride is None else columnOverride,
                 'severity': severity,
                 'message': message,
                 'addon': addon,
@@ -876,7 +1686,42 @@ def reportError(location, severity, message, addon, errorId, extra=''):
                 'extra': extra}
         sys.stdout.write(json.dumps(msg) + '\n')
     else:
+        if is_suppressed(location, message, '%s-%s' % (addon, errorId)):
+            return
         loc = '[%s:%i]' % (location.file, location.linenr)
         if len(extra) > 0:
             message += ' (' + extra + ')'
         sys.stderr.write('%s (%s) %s [%s-%s]\n' % (loc, severity, message, addon, errorId))
+        global EXIT_CODE
+        EXIT_CODE = 1
+
+def reportSummary(dumpfile, summary_type, summary_data):
+    msg = {'summary': summary_type, 'data': summary_data}
+    if '--cli' in sys.argv:
+        sys.stdout.write(json.dumps(msg) + '\n')
+    else:
+        # dumpfile ends with ".dump"
+        ctu_info_file = dumpfile[:-4] + "ctu-info"
+        with open(ctu_info_file, 'at') as f:
+            f.write(json.dumps(msg) + '\n')
+
+
+def get_path_premium_addon():
+    p = pathlib.Path(sys.argv[0]).parent.parent
+
+    for ext in ('.exe', ''):
+        p1 = os.path.join(p, 'premiumaddon' + ext)
+        p2 = os.path.join(p, 'cppcheck' + ext)
+        if os.path.isfile(p1) and os.path.isfile(p2):
+            return p1
+    return None
+
+
+def cmd_output(cmd):
+    with subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) as p:
+        stdout, stderr = p.communicate()
+        rc = p.returncode
+    out = stdout
+    if rc == 1 and len(stderr) > 2:
+        out = stderr
+    return out.decode(encoding='utf-8', errors='ignore')
diff --git a/addons/doc/y2038.md b/addons/doc/y2038.md
new file mode 100644
index 00000000000..5566c3936ba
--- /dev/null
+++ b/addons/doc/y2038.md
@@ -0,0 +1,166 @@
+# README of the Y2038 cppcheck addon
+
+## Contents
+
+- [README of the Y2038 cppcheck addon](#readme-of-the-y2038-cppcheck-addon)
+  - [Contents](#contents)
+  - [What is Y2038?](#what-is-y2038)
+  - [What is the Y2038 cppcheck addon?](#what-is-the-y2038-cppcheck-addon)
+  - [How does the Y2038 cppcheck addon work?](#how-does-the-y2038-cppcheck-addon-work)
+    - [Primary Usage: Cppcheck Addon Integration (`y2038.py`)](#primary-usage-cppcheck-addon-integration-y2038py)
+      - [Implementation Details](#implementation-details)
+  - [Requirements](#requirements)
+  - [How to use the Y2038 cppcheck addon](#how-to-use-the-y2038-cppcheck-addon)
+    - [**Auditing Your Project for Y2038 Compliance**](#auditing-your-project-for-y2038-compliance)
+    - [**CI/CD Integration**](#cicd-integration)
+  - [Testing](#testing)
+    - [Running Y2038 Addon Tests](#running-y2038-addon-tests)
+    - [Test Coverage](#test-coverage)
+    - [Test Structure](#test-structure)
+
+---
+
+## What is Y2038?
+
+In a few words:
+
+Most operating systems and programming environments represent the current time as the number of seconds since the Unix epoch. In C and C++ this is exposed by time() and std::time(), with the Unix epoch defined as 00:00:00 UTC on 1 January 1970.
+
+Typically this representation is stored as a 64-bit signed quantity.
+Some systems, mainly embedded systems and older systems, still use a 32-bit signed
+time_t representation.
+
+On January 19th, 2038 at 03:14:07 GMT, such 32-bit representations will reach
+their maximum positive value.
+
+What happens then is unpredictable: system time might roll back to December
+13th, 1901 at 19:55:13, or it might keep running on until February 7th, 2106
+at 06:28:15 GMT, or the computer may freeze, or just about anything you can
+think of, plus a few ones you can't.
+
+The workaround for this is to switch to a 64-bit signed representation of time
+as seconds from the Unix epoch. This representation will work for more than 250
+billion years.
+
+Working around Y2038 requires fixing the Linux kernel, the C libraries, and
+any user code around which uses 32-bit epoch representations.
+
+There is Y2038-proofing work in progress on the Linux and GNU glibc front.
+
+## What is the Y2038 cppcheck addon?
+
+The Y2038 cppcheck addon is a tool to help detect code which might need fixing
+because it is Y2038-unsafe. This may be because it uses types or functions from
+GNU libc or from the Linux kernel which are known not to be Y2038-proof.
+
+## How does the Y2038 cppcheck addon work?
+
+The Y2038 addon is a comprehensive tool designed to audit your project for Y2038 compliance. It provides a streamlined, intelligent approach to Y2038 analysis.
+
+### Primary Usage: Cppcheck Integration with Project Files
+
+The Y2038 addon integrates seamlessly with cppcheck's core project parsing infrastructure. For optimal analysis, use the addon with project files:
+
+```bash
+cppcheck --project=build/compile_commands.json --addon=y2038
+```
+
+For single files, you can also use:
+```bash
+cppcheck --addon=y2038 source_file.c
+```
+
+#### Implementation Details
+
+The addon leverages cppcheck's built-in project parsing capabilities:
+
+- **Core Integration**: Y2038-related compiler flags are extracted by cppcheck core during project parsing and passed through dump file configuration
+- **Automatic Flag Detection**: Cppcheck automatically detects Y2038-relevant flags (`-D_TIME_BITS=64`, `-D_FILE_OFFSET_BITS=64`, `-D_USE_TIME_BITS64`) from compilation commands
+- **Clean Architecture**: No redundant file parsing - cppcheck handles project files once, addon focuses on analysis
+- **Priority Logic**: Dump file configuration (from cppcheck's project parsing) takes precedence over source code `#define` statements
+- **Source Fallback**: When no project configuration is available, the addon analyzes source code `#define` statements
+
+This architecture ensures optimal performance and maintains clean separation of concerns between cppcheck core (project parsing) and addon (analysis logic).
+
+The output is the standard Cppcheck analysis report, focused on Y2038-related issues.
+
+## Requirements
+
+The Y2038 addon works with any cppcheck installation and requires no additional dependencies beyond cppcheck itself.
+
+For optimal Y2038 analysis, ensure your project uses a supported build system that generates `compile_commands.json`:
+
+- **CMake**: Use `-DCMAKE_EXPORT_COMPILE_COMMANDS=ON`
+- **Bear**: For Make/Autotools projects, use `bear` to generate compile commands
+- **Ninja**: Use `ninja -t compdb` to generate compile commands
+- **Bazel**: Use `bazel aquery` with appropriate flags
+
+If using `bear` for Make-based projects, install it via your package manager:
+
+```bash
+# On Debian/Ubuntu
+sudo apt-get install bear
+
+# On Fedora
+sudo dnf install bear
+
+# On macOS (using Homebrew)
+brew install bear
+```
+
+## How to use the Y2038 cppcheck addon
+
+### **Auditing Your Project for Y2038 Compliance**
+
+The Y2038 addon seamlessly integrates with your existing cppcheck workflow.
+
+**For projects with compile_commands.json (recommended):**
+
+```bash
+cppcheck --project=build/compile_commands.json --addon=y2038
+```
+
+**For single file analysis:**
+
+```bash
+cppcheck --addon=y2038 source_file.c
+```
+
+**For project-wide analysis without compile_commands.json:**
+
+```bash
+cppcheck --addon=y2038 src/
+```
+
+The integration automatically:
+
+1.  **Extracts Y2038 flags** from your project's compilation commands via cppcheck's project parsing
+2.  **Passes flag information** through dump file configuration to the addon
+3.  **Analyzes source code** with proper Y2038 context from both build system and source directives
+4.  **Reports Y2038 issues** using cppcheck's standard error reporting format
+
+### **CI/CD Integration**
+
+For CI/CD integration, use the Y2038 addon with your project's build configuration:
+
+```sh
+# Example CI script with compile_commands.json
+#!/bin/bash
+# Generate compile_commands.json (if not already available)
+cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -B build
+# or: bear -- make
+
+# Run Y2038 analysis
+cppcheck --project=build/compile_commands.json --addon=y2038 --error-exitcode=1
+
+# The addon will return a non-zero exit code if Y2038 issues are found.
+# The output is the standard Cppcheck report.
+```
+
+**For projects without compile_commands.json:**
+
+```sh
+# Example CI script for source-only analysis
+#!/bin/bash
+cppcheck --addon=y2038 --error-exitcode=1 src/
+```
diff --git a/addons/doc/y2038.txt b/addons/doc/y2038.txt
deleted file mode 100644
index 990b24bd483..00000000000
--- a/addons/doc/y2038.txt
+++ /dev/null
@@ -1,151 +0,0 @@
-README of the Y2038 cppcheck addon
-==================================
-
-Contents
-
-1. What is Y2038?
-2. What is the Y2038 cppcheck addon?
-3. How does the Y2038 cppcheck addon work?
-4. How to use the Y2038 cppcheck addon
-
----
-
-1. What is Y2038?
-
-In a few words:
-
-In Linux, the current date and time is kept as the number of seconds elapsed
-since the Unix epoch, that is, since January 1st, 1970 at 00:00:00 GMT.
-
-Most of the time, this representation is stored as a 32-bit signed quantity.
-
-On January 19th, 2038 at 03:14:07 GMT, such 32-bit representations will reach
-their maximum positive value.
-
-What happens then is unpredictable: system time might roll back to December
-13th, 1901 at 19:55:13, or it might keep running on until February 7th, 2106
-at 06:28:15 GMT, or the computer may freeze, or just about anything you can
-think of, plus a few ones you can't.
-
-The workaround for this is to switch to a 64-bit signed representation of time
-as seconds from the Unix epoch. This representation will work for more than 250
-billion years.
-
-Working around Y2038 requires fixing the Linux kernel, the C libraries, and
-any user code around which uses 32-bit epoch representations.
-
-There is Y2038-proofing work in progress on the Linux and GNU glibc front.
-
-2. What is the Y2038 cppcheck addon?
-
-The Y2038 cppcheck addon is a tool to help detect code which might need fixing
-because it is Y2038-unsafe. This may be because it uses types or functions from
-GNU libc or from the Linux kernel which are known not to be Y2038-proof.
-
-3. How does the Y2038 cppcheck addon work?
-
-The Y2038 cppcheck addon takes XML dumps produced by cppcheck from source code
-files and looks for the names of types or functions which are known to be Y2038-
-unsafe, and emits diagnostics whenever it finds one.
-
-Of course, this is of little use if your code uses a Y2038-proof glibc and
-correctly configured Y2038-proof time support.
-
-This is why y2038.py takes into account two preprocessor directives:
-_TIME_BITS and __USE_TIME_BITS64.
-
-_TIME_BITS is defined equal to 64 by user code when it wants 64-bit time
-support from the GNU glibc. Code which does not define _TIME_BITS equal to 64
-(or defines it to something else than 64) runs a risk of not being Y2038-proof.
-
-__USE_TIME_BITS64 is defined by the GNU glibc when it actually provides 64-bit
-time support. When this is defined, then all glibc symbols, barring bugs, are
-Y2038-proof (but your code might have its own Y2038 bugs, if it handles signed
-32-bit Unix epoch values).
-
-The Y2038 cppcheck performs the following checks:
-
-  1. Upon meeting a definition for _TIME_BITS, if that definition does not
-     set it equal to 64, this error diagnostic is emitted:
-
-	Error: _TIME_BITS must be defined equal to 64
-
-     This case is very unlikely but might result from a typo, so pointing
-     it out is quite useful. Note that definitions of _TIME_BITS as an
-     expression evaluating to 64 will be flagged too.
-
-  2. Upon meeting a definition for _USE_TIME_BITS64, if _TIME_BITS is not
-     defined equal to 64, this information diagnostic is emitted:
-
-	Warning: _USE_TIME_BITS64 is defined but _TIME_BITS was not
-
-     This reflects the fact that even though the glibc checked default to
-     64-bit time support, this was not requested by the user code, and
-     therefore the user code might fail Y2038 if built against a glibc
-     which defaults to 32-bit time support.
-
-  3. Upon meeting a symbol (type or function) which is known to be Y2038-
-     unsafe, if _USE_TIME_BITS64 is undefined or _TIME_BITS not properly
-     defined, this warning diagnostic is emitted:
-
-	Warning: <symbol> is Y2038-unsafe
-
-     This reflects the fact that the user code is referring to a symbol
-     which, when glibc defaults to 32-bit time support, might fail Y2038.
-
-General note: y2038.py will handle multiple configurations, and will
-emit diagnostics for each configuration in turn.
-
-4. How to use the Y2038 cppcheck addon
-
-The Y2038 cppcheck addon is used like any other cppcheck addon:
-
-	cppcheck --dump file1.c [ file2.c [...]]]
-	y2038.py file1.c [ file2.c [...]]]
-
-Sample test C file is provided:
-
-	test/y2038-test-1-bad-time-bits.c
-	test/y2038-test-2-no-time-bits.c
-	test/y2038-test-3-no-use-time-bits.c
-	test/y2038-test-4-good.c
-
-These cover the cases described above. You can run them through cppcheck
-and y2038.py to see for yourself how the addon diagnostics look like. If
-this README is not outdated (and if it is, feel free to submit a patch),
-you can run cppcheck on these files as on any others:
-
-	cppcheck --dump addons/y2038/test/y2038-*.c
-	y2038.py addons/y2038/test/y2038-*.dump
-
-If you have not installed cppcheck yet, you will have to run these
-commands from the root of the cppcheck repository:
-
-    make
-    sudo make install
-	./cppcheck --dump addons/y2038/test/y2038-*.c
-    PYTHONPATH=addons python addons/y2038/y2038.py addons/y2038/test/y2038-*.c.dump
-
-In both cases, y2038.py execution should result in the following:
-
-Checking addons/y2038/test/y2038-test-1-bad-time-bits.c.dump...
-Checking addons/y2038/test/y2038-test-1-bad-time-bits.c.dump, config ""...
-Checking addons/y2038/test/y2038-test-2-no-time-bits.c.dump...
-Checking addons/y2038/test/y2038-test-2-no-time-bits.c.dump, config ""...
-Checking addons/y2038/test/y2038-test-3-no-use-time-bits.c.dump...
-Checking addons/y2038/test/y2038-test-3-no-use-time-bits.c.dump, config ""...
-Checking addons/y2038/test/y2038-test-4-good.c.dump...
-Checking addons/y2038/test/y2038-test-4-good.c.dump, config ""...
-# Configuration "":
-# Configuration "":
-[addons/y2038/test/y2038-test-1-bad-time-bits.c:8]: (error) _TIME_BITS must be defined equal to 64
-[addons/y2038/test/y2038-inc.h:9]: (warning) _USE_TIME_BITS64 is defined but _TIME_BITS was not
-[addons/y2038/test/y2038-test-1-bad-time-bits.c:10]: (information) addons/y2038/test/y2038-inc.h was included from here
-[addons/y2038/test/y2038-inc.h:9]: (warning) _USE_TIME_BITS64 is defined but _TIME_BITS was not
-[addons/y2038/test/y2038-test-2-no-time-bits.c:8]: (information) addons/y2038/test/y2038-inc.h was included from here
-[addons/y2038/test/y2038-test-3-no-use-time-bits.c:13]: (warning) timespec is Y2038-unsafe
-[addons/y2038/test/y2038-test-3-no-use-time-bits.c:15]: (warning) clock_gettime is Y2038-unsafe
-
-Note: y2038.py recognizes option --template as cppcheck does, including
-pre-defined templates 'gcc', 'vs' and 'edit'. The short form -t is also
-recognized.
diff --git a/addons/findcasts.py b/addons/findcasts.py
index e44c94482cf..d4842b229a6 100755
--- a/addons/findcasts.py
+++ b/addons/findcasts.py
@@ -1,41 +1,32 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Locate casts in the code
 #
 
-import cppcheckdata
-import sys
+import cppcheck
 
-for arg in sys.argv[1:]:
-    if arg.startswith('-'):
-        continue
+@cppcheck.checker
+def cast(cfg, data):
+    for token in cfg.tokenlist:
+        if token.str != '(' or not token.astOperand1 or token.astOperand2:
+            continue
 
-    print('Checking ' + arg + '...')
-    data = cppcheckdata.parsedump(arg)
+        # Is it a lambda?
+        if token.astOperand1.str == '{':
+            continue
 
-    for cfg in data.configurations:
-        if len(data.configurations) > 1:
-            print('Checking ' + arg + ', config "' + cfg.name + '"...')
-        for token in cfg.tokenlist:
-            if token.str != '(' or not token.astOperand1 or token.astOperand2:
-                continue
+        # we probably have a cast.. if there is something inside the parentheses
+        # there is a cast. Otherwise this is a function call.
+        typetok = token.next
+        if not typetok.isName:
+            continue
 
-            # Is it a lambda?
-            if token.astOperand1.str == '{':
-                continue
+        # cast number => skip output
+        if token.astOperand1.isNumber:
+            continue
 
-            # we probably have a cast.. if there is something inside the parentheses
-            # there is a cast. Otherwise this is a function call.
-            typetok = token.next
-            if not typetok.isName:
-                continue
+        # void cast => often used to suppress compiler warnings
+        if typetok.str == 'void':
+            continue
 
-            # cast number => skip output
-            if token.astOperand1.isNumber:
-                continue
-
-            # void cast => often used to suppress compiler warnings
-            if typetok.str == 'void':
-                continue
-
-            cppcheckdata.reportError(token, 'information', 'found a cast', 'findcasts', 'cast')
+        cppcheck.reportError(token, 'information', 'found a cast')
diff --git a/addons/misc.py b/addons/misc.py
index 84cb6c2389c..670d6152ff5 100644
--- a/addons/misc.py
+++ b/addons/misc.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Misc: Uncategorized checks that might be moved to some better addon later
 #
@@ -16,7 +16,7 @@
 VERIFY_ACTUAL = []
 
 def reportError(token, severity, msg, id):
-    if id == 'debug' and DEBUG == False:
+    if id == 'debug' and not DEBUG:
         return
     if VERIFY:
         VERIFY_ACTUAL.append(str(token.linenr) + ':' + id)
@@ -24,11 +24,7 @@ def reportError(token, severity, msg, id):
         cppcheckdata.reportError(token, severity, msg, 'misc', id)
 
 def simpleMatch(token, pattern):
-    for p in pattern.split(' '):
-        if not token or token.str != p:
-            return False
-        token = token.next
-    return True
+    return cppcheckdata.simpleMatch(token, pattern)
 
 # Get function arguments
 def getArgumentsRecursive(tok, arguments):
@@ -49,10 +45,10 @@ def isStringLiteral(tokenString):
     return tokenString.startswith('"')
 
 # check data
-def stringConcatInArrayInit(configurations, rawTokens):
+def stringConcatInArrayInit(data):
     # Get all string macros
     stringMacros = []
-    for cfg in configurations:
+    for cfg in data.iterconfigurations():
         for directive in cfg.directives:
             res = re.match(r'#define[ ]+([A-Za-z0-9_]+)[ ]+".*', directive.str)
             if res:
@@ -62,12 +58,12 @@ def stringConcatInArrayInit(configurations, rawTokens):
 
     # Check code
     arrayInit = False
-    for i in range(len(rawTokens)):
+    for i in range(len(data.rawTokens)):
         if i < 2:
             continue
-        tok1 = rawTokens[i-2].str
-        tok2 = rawTokens[i-1].str
-        tok3 = rawTokens[i-0].str
+        tok1 = data.rawTokens[i-2].str
+        tok2 = data.rawTokens[i-1].str
+        tok3 = data.rawTokens[i-0].str
         if tok3 == '}':
             arrayInit = False
         elif tok1 == ']' and tok2 == '=' and tok3 == '{':
@@ -76,11 +72,11 @@ def stringConcatInArrayInit(configurations, rawTokens):
             isString2 = (isStringLiteral(tok2) or (tok2 in stringMacros))
             isString3 = (isStringLiteral(tok3) or (tok3 in stringMacros))
             if isString2 and isString3:
-                reportError(rawTokens[i], 'style', 'String concatenation in array initialization, missing comma?', 'stringConcatInArrayInit')
+                reportError(data.rawTokens[i], 'style', 'String concatenation in array initialization, missing comma?', 'stringConcatInArrayInit')
 
 
 def implicitlyVirtual(data):
-    for cfg in data.configurations:
+    for cfg in data.iterconfigurations():
         for function in cfg.functions:
             if function.isImplicitlyVirtual is None:
                 continue
@@ -89,7 +85,7 @@ def implicitlyVirtual(data):
             reportError(function.tokenDef, 'style', 'Function \'' + function.name + '\' overrides base class function but is not marked with \'virtual\' keyword.', 'implicitlyVirtual')
 
 def ellipsisStructArg(data):
-    for cfg in data.configurations:
+    for cfg in data.iterconfigurations():
         for tok in cfg.tokenlist:
             if tok.str != '(':
                 continue
@@ -137,8 +133,9 @@ def ellipsisStructArg(data):
 for arg in sys.argv[1:]:
     if arg in ['-debug', '-verify', '--cli']:
         continue
-    print('Checking ' + arg + '...')
-    data = cppcheckdata.parsedump(arg)
+
+    print("Checking %s..." % arg)
+    data = cppcheckdata.CppcheckData(arg)
 
     if VERIFY:
         VERIFY_ACTUAL = []
@@ -149,7 +146,7 @@ def ellipsisStructArg(data):
                     if word in ['stringConcatInArrayInit', 'implicitlyVirtual', 'ellipsisStructArg']:
                         VERIFY_EXPECTED.append(str(tok.linenr) + ':' + word)
 
-    stringConcatInArrayInit(data.configurations, data.rawTokens)
+    stringConcatInArrayInit(data)
     implicitlyVirtual(data)
     ellipsisStructArg(data)
 
@@ -162,3 +159,5 @@ def ellipsisStructArg(data):
             if actual not in VERIFY_EXPECTED:
                 print('Not expected: ' + actual)
                 sys.exit(1)
+
+sys.exit(cppcheckdata.EXIT_CODE)
diff --git a/addons/misra.py b/addons/misra.py
index 9d85924f800..cea5596d47d 100755
--- a/addons/misra.py
+++ b/addons/misra.py
@@ -1,13 +1,13 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
-# MISRA C 2012 checkers
+# MISRA C 2012 checkers (including amendment 1 and 2)
 #
 # Example usage of this addon (scan a sourcefile main.cpp)
 # cppcheck --dump main.cpp
 # python misra.py --rule-texts=<path-to-rule-texts> main.cpp.dump
 #
-# Limitations: This addon is released as open source. Rule texts can't be freely
-# distributed. https://www.misra.org.uk/forum/viewtopic.php?f=56&t=1189
+# Limitations: This addon is released as open source. We are not allowed by
+# MISRA to distribute rule texts openly.
 #
 # The MISRA standard documents may be obtained from https://www.misra.org.uk
 #
@@ -16,24 +16,56 @@
 from __future__ import print_function
 
 import cppcheckdata
+import itertools
+import json
 import sys
 import re
 import os
 import argparse
-import codecs
 import string
+import copy
 
 try:
     from itertools import izip as zip
 except ImportError:
     pass
 
+import misra_9
 
 def grouped(iterable, n):
-    "s -> (s0,s1,s2,...sn-1), (sn,sn+1,sn+2,...s2n-1), (s2n,s2n+1,s2n+2,...s3n-1), ..."
-    return zip(*[iter(iterable)]*n)
+    """s -> (s0,s1,s2,...sn-1), (sn,sn+1,sn+2,...s2n-1), (s2n,s2n+1,s2n+2,...s3n-1), ..."""
+    return zip(*[iter(iterable)] * n)
 
 
+INT_TYPES = ['bool', 'char', 'short', 'int', 'long', 'long long']
+
+
+STDINT_TYPES = ['%s%d_t' % (n, v) for n, v in itertools.product(
+        ['int', 'uint', 'int_least', 'uint_least', 'int_fast', 'uint_fast'],
+        [8, 16, 32, 64])]
+
+STDINT_H_DEFINES_MIN = ['%s%d_MIN' % (n, v) for n, v in itertools.product(
+        ['INT', 'INT_LEAST', 'INT_FAST',],
+        [8, 16, 32, 64])]
+
+STDINT_H_DEFINES_MAX = ['%s%d_MAX' % (n, v) for n, v in itertools.product(
+        ['INT', 'UINT','INT_LEAST','UINT_LEAST', 'INT_FAST', 'UINT_FAST',],
+        [8, 16, 32, 64])]
+
+STDINT_H_DEFINES_C = ['%s%d_C' % (n, v) for n, v in itertools.product(
+        ['INT', 'UINT'],
+        [8, 16, 32, 64])]
+
+
+INTTYPES_H_DEFINES = ['%s%d' % (n, v) for n, v in itertools.product(
+        ['PRId', 'PRIi', 'PRIo', 'PRIu', 'PRIx', 'PRIX', 'SCNd',
+         'SCNi', 'SCNo', 'SCNu', 'SCNx', 'PRIdLEAST', 'PRIiLEAST',
+         'PRIoLEAST', 'PRIuLEAST', 'PRIxLEAST', 'PRIXLEAST',
+         'SCNdLEAST', 'SCNiLEAST', 'SCNoLEAST', 'SCNuLEAST', 
+         'SCNxLEAST', 'PRIdFAST', 'PRIiFAST', 'PRIoFAST', 'PRIuFAST', 
+         'PRIxFAST', 'PRIXFAST', 'SCNdFAST', 'SCNiFAST', 'SCNoFAST', 
+         'SCNuFAST', 'SCNxFAST', ],
+        [8, 16, 32, 64])]
 typeBits = {
     'CHAR': None,
     'SHORT': None,
@@ -44,12 +76,12 @@ def grouped(iterable, n):
 }
 
 
+def isUnsignedType(ty):
+    return ty == 'unsigned' or ty.startswith('uint')
+
+
 def simpleMatch(token, pattern):
-    for p in pattern.split(' '):
-        if not token or token.str != p:
-            return False
-        token = token.next
-    return True
+    return cppcheckdata.simpleMatch(token, pattern)
 
 
 def rawlink(rawtoken):
@@ -68,41 +100,508 @@ def rawlink(rawtoken):
     return rawtoken
 
 
-KEYWORDS = {
-    'auto',
-    'break',
-    'case',
-    'char',
-    'const',
-    'continue',
-    'default',
-    'do',
-    'double',
-    'else',
-    'enum',
-    'extern',
-    'float',
-    'for',
-    'goto',
-    'if',
-    'int',
-    'long',
-    'register',
-    'return',
-    'short',
-    'signed',
-    'sizeof',
-    'static',
-    'struct',
-    'switch',
-    'typedef',
-    'union',
-    'unsigned',
-    'void',
-    'volatile',
-    'while'
+# Identifiers described in Section 7 "Library" of C90 Standard
+# Based on ISO/IEC9899:1990 Annex D -- Library summary and
+# Annex E -- Implementation limits.
+C90_STDLIB_IDENTIFIERS = {
+    # D.1 Errors
+    'errno.h': ['EDOM', 'ERANGE', 'errno'],
+    # D.2 Common definitions
+    'stddef.h': ['NULL', 'offsetof', 'ptrdiff_t', 'size_t', 'wchar_t'],
+    # D.3 Diagnostics
+    'assert.h': ['NDEBUG', 'assert'],
+    # D.4 Character handling
+    'ctype.h': [
+        'isalnum', 'isalpha', 'isblank', 'iscntrl', 'isdigit',
+        'isgraph', 'islower', 'isprint', 'ispunct', 'isspace',
+        'isupper', 'isxdigit', 'tolower', 'toupper',
+    ],
+    # D.5 Localization
+    'locale.h': [
+        'LC_ALL', 'LC_COLLATE', 'LC_CTYPE', 'LC_MONETARY',
+        'LC_NUMERIC', 'LC_TIME', 'NULL', 'lconv',
+        'setlocale', 'localeconv',
+    ],
+    # D.6 Mathematics
+    'math.h': [
+        'HUGE_VAL', 'acos', 'asin' , 'atan2', 'cos', 'sin', 'tan', 'cosh',
+        'sinh', 'tanh', 'exp', 'frexp', 'ldexp', 'log', 'loglO', 'modf',
+        'pow', 'sqrt', 'ceil', 'fabs', 'floor', 'fmod',
+    ],
+    # D.7 Nonlocal jumps
+    'setjmp.h': ['jmp_buf', 'setjmp', 'longjmp'],
+    # D.8 Signal handling
+    'signal.h': [
+        'sig_atomic_t', 'SIG_DFL', 'SIG_ERR', 'SIG_IGN', 'SIGABRT', 'SIGFPE',
+        'SIGILL', 'SIGINT', 'SIGSEGV', 'SIGTERM', 'signal', 'raise',
+    ],
+    # D.9 Variable arguments
+    'stdarg.h': ['va_list', 'va_start', 'va_arg', 'va_end'],
+    # D.10 Input/output
+    'stdio.h': [
+        '_IOFBF', '_IOLBF', '_IONBF', 'BUFSIZ', 'EOF', 'FILE', 'FILENAME_MAX',
+        'FOPEN_MAX', 'fpos_t', 'L_tmpnam', 'NULL', 'SEEK_CUR', 'SEEK_END',
+        'SEEK_SET', 'size_t', 'stderr', 'stdin', 'stdout', 'TMP_MAX',
+        'remove', 'rename', 'tmpfile', 'tmpnam', 'fclose', 'fflush', 'fopen',
+        'freopen', 'setbuf', 'setvbuf', 'fprintf', 'fscanf', 'printf',
+        'scanf', 'sprintf', 'sscanf', 'vfprintf', 'vprintf', 'vsprintf',
+        'fgetc', 'fgets', 'fputc', 'fputs', 'getc', 'getchar', 'gets', 'putc',
+        'putchar', 'puts', 'ungetc', 'fread', 'fwrite', 'fgetpos', 'fseek',
+        'fsetpos', 'rewind', 'clearerr', 'feof', 'ferror', 'perror',
+    ],
+    # D.11 General utilities
+    'stdlib.h': [
+        'EXIT_FAILURE', 'EXIT_SUCCESS', 'MB_CUR_MAX', 'NULL', 'RAND_MAX',
+        'div_t', 'ldiv_t', 'wchar_t', 'atof', 'atoi', 'strtod', 'rand',
+        'srand', 'calloc', 'free', 'malloc', 'realloc', 'abort', 'atexit',
+        'exit', 'getenv', 'system', 'bsearch', 'qsort', 'abs', 'div', 'ldiv',
+        'mblen', 'mbtowc', 'wctomb', 'mbstowcs', 'wcstombs',
+    ],
+    # D.12 String handling
+    'string.h': [
+        'NULL', 'size_t', 'memcpy', 'memmove', 'strcpy', 'strncpy', 'strcat',
+        'strncat', 'memcmp', 'strcmp', 'strcoll', 'strncmp', 'strxfrm',
+        'memchr', 'strchr', 'strcspn', 'strpbrk', 'strrchr', 'strspn',
+        'strstr', 'strtok', 'memset', 'strerror', 'strlen',
+    ],
+    # D.13 Date and time
+    'time.h': [
+        'CLK_TCK', 'NULL', 'clock_t', 'time_t', 'size_t', 'tm', 'clock',
+        'difftime', 'mktime', 'time', 'asctime', 'ctime', 'gmtime',
+        'localtime', 'strftime',
+    ],
+    # Annex E: Implementation limits
+    'limits.h': [
+        'CHAR_BIT', 'SCHAR_MIN', 'SCHAR_MAX', 'UCHAR_MAX', 'CHAR_MIN',
+        'CHAR_MAX', 'MB_LEN_MAX', 'SHRT_MIN', 'SHRT_MAX', 'USHRT_MAX',
+        'INT_MIN', 'INT_MAX', 'UINT_MAX', 'LONG_MIN', 'LONG_MAX', 'ULONG_MAX',
+        ],
+    'float.h': [
+        'FLT_ROUNDS', 'FLT_RADIX', 'FLT_MANT_DIG', 'DBL_MANT_DIG',
+        'LDBL_MANT_DIG', 'DECIMAL_DIG', 'FLT_DIG', 'DBL_DIG', 'LDBL_DIG',
+        'DBL_MIN_EXP', 'LDBL_MIN_EXP', 'FLT_MIN_10_EXP', 'DBL_MIN_10_EXP',
+        'LDBL_MIN_10_EXP', 'FLT_MAX_EXP', 'DBL_MAX_EXP', 'LDBL_MAX_EXP',
+        'FLT_MAX_10_EXP', 'DBL_MAX_10_EXP', 'LDBL_MAX_10_EXP', 'FLT_MAX',
+        'DBL_MAX', 'LDBL_MAX', 'FLT_MIN', 'DBL_MIN', 'LDBL_MIN',
+        'FLT_EPSILON', 'DBL_EPSILON', 'LDBL_EPSILON'
+    ],
+}
+
+
+# Identifiers described in Section 7 "Library" of C99 Standard
+# Based on ISO/IEC 9899:1999 (E) Annex B -- Library summary
+# (https://www.dii.uchile.cl/~daespino/files/Iso_C_1999_definition.pdf)
+C99_STDLIB_IDENTIFIERS = {
+    # B.1 Diagnostics
+    'assert.h': C90_STDLIB_IDENTIFIERS['assert.h'],
+    # B.2 Complex
+    'complex.h': [
+        'complex', 'imaginary', 'I', '_Complex_I', '_Imaginary_I',
+        'CX_LIMITED_RANGE',
+        'cacos', 'cacosf', 'cacosl',
+        'casin', 'casinf', 'casinl',
+        'catan', 'catanf', 'catanl',
+        'ccos', 'ccosf', 'ccosl',
+        'csin', 'csinf', 'csinl',
+        'ctan', 'ctanf', 'ctanl',
+        'cacosh', 'cacoshf', 'cacoshl',
+        'casinh', 'casinhf', 'casinhl',
+        'catanh', 'catanhf', 'catanhl',
+        'ccosh', 'ccoshf', 'ccoshl',
+        'csinh', 'csinhf', 'csinhl',
+        'ctanh', 'ctanhf', 'ctanhl',
+        'cexp', 'cexpf', 'cexpl',
+        'clog', 'clogf', 'clogl',
+        'cabs', 'cabsf', 'cabsl',
+        'cpow', 'cpowf', 'cpowl',
+        'csqrt', 'csqrtf', 'csqrtl',
+        'carg', 'cargf', 'cargl',
+        'cimag', 'cimagf', 'cimagl',
+        'conj', 'conjf', 'conjl',
+        'cproj', 'cprojf', 'cprojl',
+        'creal', 'crealf', 'creall',
+    ],
+    # B.3 Character handling
+    'ctype.h': C90_STDLIB_IDENTIFIERS['ctype.h'],
+    # B.4 Errors
+    'errno.h': C90_STDLIB_IDENTIFIERS['errno.h'] + ['EILSEQ'],
+    # B.5 Floating-point environment
+    'fenv.h': [
+        'fenv_t', 'FE_OVERFLOW', 'FE_TOWARDZERO',
+        'fexcept_t', 'FE_UNDERFLOW', 'FE_UPWARD',
+        'FE_DIVBYZERO', 'FE_ALL_EXCEPT', 'FE_DFL_ENV',
+        'FE_INEXACT', 'FE_DOWNWARD',
+        'FE_INVALID', 'FE_TONEAREST',
+        'FENV_ACCESS',
+        'feclearexcept', 'fegetexceptflag', 'fegetround',
+        'fesetround', 'fegetenv', 'feholdexcept',
+        'fesetenv', 'feupdateenv',
+    ],
+    # B.6 Characteristics of floating types
+    'float.h': C90_STDLIB_IDENTIFIERS['float.h'] + ['FLT_EVAL_METHOD'],
+    # B.7 Format conversion of integer types
+    'inttypes.h': [
+        'PRIdMAX', 'PRIiMAX', 'PRIoMAX', 'PRIuMAX', 'PRIxMAX', 'PRIXMAX',
+        'SCNdMAX', 'SCNiMAX', 'SCNoMAX', 'SCNuMAX', 'SCNxMAX', 'PRIdPTR', 
+        'PRIiPTR', 'PRIoPTR', 'PRIuPTR', 'PRIxPTR', 'PRIXPTR', 'SCNdPTR', 
+        'SCNiPTR', 'SCNoPTR', 'SCNuPTR', 'SCNxPTR', 
+        'imaxdiv_t', 'imaxabs', 'imaxdiv', 'strtoimax',
+        'strtoumax', 'wcstoimax', 'wcstoumax',
+    ] + INTTYPES_H_DEFINES,
+    # B.8 Alternative spellings
+    'iso646.h': [
+        'and', 'and_eq', 'bitand', 'bitor', 'compl', 'not', 'not_eq',
+        'or', 'or_eq', 'xor', 'xor_eq',
+    ],
+    # B.9 Size of integer types
+    'limits.h': C90_STDLIB_IDENTIFIERS['limits.h'] +
+    ['LLONG_MIN', 'LLONG_MAX', 'ULLONG_MAX'],
+    # B.10 Localization
+    'locale.h': C90_STDLIB_IDENTIFIERS['locale.h'],
+    # B.11 Mathematics
+    'math.h': C90_STDLIB_IDENTIFIERS['math.h'] + [
+        'float_t', 'double_t', 'HUGE_VAL', 'HUGE_VALF', 'HUGE_VALL',
+        'INFINITY', 'NAN', 'FP_INFINITE', 'FP_NAN', 'FP_NORMAL',
+        'FP_SUBNORMAL', 'FP_ZERO', 'FP_FAST_FMA', 'FP_FAST_FMAF',
+        'FP_FAST_FMAL', 'FP_ILOGB0', 'FP_ILOGBNAN', 'MATH_ERRNO',
+        'MATH_ERREXCEPT', 'math_errhandling', 'FP_CONTRACT', 'fpclassify',
+        'isfinite', 'isinf', 'isnan', 'isnormal', 'signbit', 'acosf', 'acosl',
+        'asinf', 'asinl', 'atanf', 'atanl', 'atan2', 'atan2f', 'atan2l',
+        'cosf', 'cosl', 'sinf', 'sinl', 'tanf', 'tanl', 'acosh', 'acoshf',
+        'acoshl', 'asinh', 'asinhf', 'asinhl', 'atanh', 'atanhf', 'atanhl',
+        'cosh', 'coshf', 'coshl', 'sinh', 'sinhf', 'sinhl', 'tanh', 'tanhf',
+        'tanhl', 'expf', 'expl', 'exp2', 'exp2f', 'exp2l', 'expm1', 'expm1f',
+        'expm1l', 'frexpf', 'frexpl', 'ilogb', 'ilogbf', 'ilogbl', 'ldexpf',
+        'ldexpl', 'logf', 'logl', 'log10f', 'log10l', 'log1p', 'log1pf',
+        'log1pl', 'log2', 'log2f', 'log2l', 'logb', 'logbf', 'logbl', 'modff',
+        'modfl', 'scalbn', 'scalbnf', 'scalbnl', 'scalbln', 'scalblnf',
+        'scalblnl','cbrt', 'cbrtf','cbrtl', 'fabs', 'fabsf', 'fabsl',
+        'hypotl', 'hypotf', 'powf', 'powl', 'sqrtf', 'sqrtl', 'erf', 'erff',
+        'erfl', 'erfc', 'erfcf', 'erfcl', 'lgamma', 'lgammaf', 'lgammal',
+        'tgamma', 'tgammaf', 'tgammal', 'ceilf', 'ceill', 'floorf', 'floorl',
+        'nearbyint', 'nearbyintf', 'nearbyintl', 'rint', 'rintf', 'rintl',
+        'lrint', 'lrintf', 'lrintl', 'llrint', 'llrintf', 'llrintl', 'round',
+        'roundf', 'roundl', 'lround', 'lroundf', 'lroundl', 'llround',
+        'llroundf', 'llroundl', 'trunc', 'truncf', 'truncl', 'fmodf', 'fmodl',
+        'remainder', 'remainderf', 'remainderl', 'remquo', 'remquof',
+        'remquol', 'copysign', 'copysignf', 'copysignl', 'nan', 'nanf',
+        'nanl', 'nextafter', 'nextafterf', 'nextafterl', 'nexttoward',
+        'nexttowardf', 'nexttowardl', 'fdim', 'fdimf', 'fdiml', 'fmax',
+        'fmaxf', 'fmaxl', 'fmin', 'fminf', 'fminl', 'fmaf','fmal', 'isgreater',
+        'isgreaterequal', 'isless', 'islessequal', 'islessgreater',
+        'isunordered',
+    ],
+    # B.12 Nonlocal jumps
+    'setjmp.h': C90_STDLIB_IDENTIFIERS['setjmp.h'],
+    # B.13 Signal handling
+    'signal.h': C90_STDLIB_IDENTIFIERS['signal.h'],
+    # B.14 Variable arguments
+    'stdarg.h': C90_STDLIB_IDENTIFIERS['stdarg.h'] + ['va_copy'],
+    # B.15 Boolean type and values
+    'stdbool.h': ['bool', 'true', 'false', '__bool_true_false_are_defined'],
+    # B.16 Common definitions
+    'stddef.h': C90_STDLIB_IDENTIFIERS['stddef.h'],
+    # B.17 Integer types
+    'stdint.h': [
+        'intptr_t', 'uintptr_t', 'intmax_t', 'uintmax_t', 'INTN_MIN',
+        'INTN_MAX', 'UINTN_MAX', 'INT_LEASTN_MIN', 'INT_LEASTN_MAX',
+        'UINT_LEASTN_MAX', 'INT_FASTN_MIN', 'INT_FASTN_MAX', 'UINT_FASTN_MAX',
+        'INTPTR_MIN', 'INTPTR_MAX', 'UINTPTR_MAX', 'INTMAX_MIN', 'INTMAX_MAX',
+        'UINTMAX_MAX', 'PTRDIFF_MIN', 'PTRDIFF_MAX', 'SIG_ATOMIC_MIN',
+        'SIG_ATOMIC_MAX', 'SIZE_MAX', 'WCHAR_MIN', 'WCHAR_MAX', 'WINT_MIN',
+        'WINT_MAX', 'INTN_C', 'UINTN_C', 'INTMAX_C', 'UINTMAX_C',
+    ] + STDINT_TYPES + STDINT_H_DEFINES_MIN + STDINT_H_DEFINES_MAX + STDINT_H_DEFINES_C,
+    # B.18 Input/output
+    'stdio.h': C90_STDLIB_IDENTIFIERS['stdio.h'] + [
+        'mode', 'restrict', 'snprintf', 'vfscanf', 'vscanf',
+        'vsnprintf', 'vsscanf','ftell'
+    ],
+    # B.19 General utilities
+    'stdlib.h': C90_STDLIB_IDENTIFIERS['stdlib.h'] + [
+        '_Exit', 'labs', 'llabs', 'lldiv', 'lldiv_t', 'strtof', 'strtol',
+        'strtold', 'strtoll', 'strtoul', 'strtoull'
+    ],
+    # B.20 String handling
+    'string.h': C90_STDLIB_IDENTIFIERS['string.h'],
+    # B.21 Type-generic math
+    'tgmath.h': [
+        'acos', 'asin', 'atan', 'acosh', 'asinh', 'atanh', 'cos', 'sin', 'tan',
+        'cosh', 'sinh', 'tanh', 'exp', 'log', 'pow', 'sqrt', 'fabs', 'atan2',
+        'cbrt', 'ceil', 'copysign', 'erf', 'erfc', 'exp2', 'expm1', 'fdim',
+        'floor', 'fma', 'fmax', 'fmin', 'fmod', 'frexp', 'hypot', 'ilogb',
+        'ldexp', 'lgamma', 'llrint', 'llround', 'log10', 'log1p', 'log2',
+        'logb', 'lrint', 'lround', 'nearbyint', 'nextafter', 'nexttoward',
+        'remainder', 'remquo', 'rint', 'round', 'scalbn', 'scalbln', 'tgamma',
+        'trunc', 'carg', 'cimag', 'conj', 'cproj', 'creal',
+    ],
+    # B.22 Date and time
+    'time.h': C90_STDLIB_IDENTIFIERS['time.h'] + ['CLOCKS_PER_SEC'],
+    # B.23 Extended multibyte/wide character utilities
+    'wchar.h': [
+        'wchar_t', 'size_t', 'mbstate_t', 'wint_t', 'tm', 'NULL', 'WCHAR_MAX',
+        'WCHAR_MIN', 'WEOF', 'fwprintf', 'fwscanf', 'swprintf', 'swscanf',
+        'vfwprintf', 'vfwscanf', 'vswprintf', 'vswscanf', 'vwprintf',
+        'vwscanf', 'wprintf', 'wscanf', 'fgetwc', 'fgetws', 'fputwc', 'fputws',
+        'fwide', 'getwc', 'getwchar', 'putwc', 'putwchar', 'ungetwc', 'wcstod',
+        'wcstof', 'wcstold', 'wcstol', 'wcstoll', 'wcstoul', 'wcstoull', 'wcscpy', 
+        'wcsncpy', 'wmemcpy', 'wmemmove', 'wcscat', 'wcsncat', 'wcscmp', 'wcscoll',
+        'wcsncmp', 'wcsxfrm', 'wmemcmp', 'wcschr', 'wcscspn', 'wcspbrk',
+        'wcsrchr', 'wcsspn', 'wcsstr', 'wcstok', 'wmemchr', 'wcslen',
+        'wmemset', 'wcsftime', 'btowc', 'wctob', 'mbsinit', 'mbrlen',
+        'mbrtowc', 'wcrtomb', 'mbsrtowcs', 'wcsrtombs',
+    ],
+    # B.24 Wide character classification and mapping utilities
+    'wctype.h': ['wint_t', 'wctrans_t', 'wctype_t', 'WEOF',
+        'iswalnum', 'iswalpha', 'iswblank', 'iswcntrl', 'iswdigit',
+        'iswgraph', 'iswlower', 'iswprint', 'iswpunct', 'iswspace', 'iswupper',
+        'iswxdigit', 'iswctype', 'wctype', 'towlower', 'towupper', 'towctrans',
+        'wctrans'],
+}
+
+# Identifiers described in Section 7 "Library" of C11 Standard
+# Based on ISO/IEC 9899:201x N1570 (Draft 12.04.2011) Annex B -- Library summary
+# (https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf)
+C11_STDLIB_IDENTIFIERS = {
+    # B.1 Diagnostics
+    'assert.h': C99_STDLIB_IDENTIFIERS['assert.h']+ ['static_assert'],
+    # B.2 Complex
+    'complex.h': C99_STDLIB_IDENTIFIERS['complex.h']+['__STDC_NO_COMPLEX__','CMPLX','CMPLXF','CMPLXL'],
+    # B.3 Character handling
+    'ctype.h': C99_STDLIB_IDENTIFIERS['ctype.h'],
+    # B.4 Errors
+    'errno.h': C99_STDLIB_IDENTIFIERS['errno.h']+['__STDC_WANT_LIB_EXT1__', 'errno_t'],
+    # B.5 Floating-point environment
+    'fenv.h': C99_STDLIB_IDENTIFIERS['fenv.h'],
+    # B.6 Characteristics of floating types
+    'float.h': C99_STDLIB_IDENTIFIERS['float.h']+[
+        'FLT_HAS_SUBNORM','DBL_HAS_SUBNORM','LDBL_HAS_SUBNORM',
+        'FLT_DECIMAL_DIG','DBL_DECIMAL_DIG','LDBL_DECIMAL_DIG',
+        'FLT_TRUE_MIN','DBL_TRUE_MIN','LDBL_TRUE_MIN'],
+    # B.7 Format conversion of integer types
+    'inttypes.h': C99_STDLIB_IDENTIFIERS["inttypes.h"],
+    # B.8 Alternative spellings
+    'iso646.h': C99_STDLIB_IDENTIFIERS["iso646.h"],
+    # B.9 Size of integer types
+    'limits.h': C99_STDLIB_IDENTIFIERS['limits.h'],
+    # B.10 Localization
+    'locale.h': C99_STDLIB_IDENTIFIERS['locale.h'],
+    # B.11 Mathematics
+    'math.h': C99_STDLIB_IDENTIFIERS['math.h'],
+    # B.12 Nonlocal jumps
+    'setjmp.h': C99_STDLIB_IDENTIFIERS['setjmp.h'],
+    # B.13 Signal handling
+    'signal.h': C99_STDLIB_IDENTIFIERS['signal.h'],
+    # B.14 Alignment
+    'stdalign.h': ['alignas','__alignas_is_defined'],
+    # B.15 Variable arguments
+    'stdarg.h': C99_STDLIB_IDENTIFIERS['stdarg.h'],
+    # B.16 Atomics
+    'stdatomic.h': ['ATOMIC_BOOL_LOCK_FREE', 'ATOMIC_CHAR_LOCK_FREE',
+        'ATOMIC_CHAR16_T_LOCK_FREE', 'ATOMIC_CHAR32_T_LOCK_FREE', 'ATOMIC_WCHAR_T_LOCK_FREE', 
+        'ATOMIC_SHORT_LOCK_FREE', 'ATOMIC_INT_LOCK_FREE', 'ATOMIC_LONG_LOCK_FREE', 
+        'ATOMIC_LLONG_LOCK_FREE', 'ATOMIC_POINTER_LOCK_FREE', 'ATOMIC_FLAG_INIT', 
+        'memory_order', 'atomic_flag', 'memory_order_relaxed', 'memory_order_consume', 
+        'memory_order_acquire', 'memory_order_release', 'memory_order_acq_rel', 'memory_order_seq_cst',
+        'atomic_bool', 'atomic_char', 'atomic_schar', 'atomic_uchar', 'atomic_short', 'atomic_ushort', 
+        'atomic_int', 'atomic_uint', 'atomic_long', 'atomic_ulong', 'atomic_llong', 'atomic_ullong', 
+        'atomic_char16_t', 'atomic_char32_t', 'atomic_wchar_t', 'atomic_int_least8_t',
+        'atomic_uint_least8_t', 'atomic_int_least16_t', 'atomic_uint_least16_t', 
+        'atomic_int_least32_t', 'atomic_uint_least32_t', 'atomic_int_least64_t', 
+        'atomic_uint_least64_t', 'atomic_int_fast8_t', 'atomic_uint_fast8_t', 
+        'atomic_int_fast16_t', 'atomic_uint_fast16_t', 'atomic_int_fast32_t', 
+        'atomic_uint_fast32_t', 'atomic_int_fast64_t', 'atomic_uint_fast64_t', 
+        'atomic_intptr_t', 'atomic_uintptr_t', 'atomic_size_t', 'atomic_ptrdiff_t', 
+        'atomic_intmax_t', 'atomic_uintmax_t', 'ATOMIC_VAR_INIT', 'type kill_dependency',
+        'atomic_thread_fence', 'atomic_signal_fence', 'atomic_is_lock_free', 
+        'atomic_store', 'atomic_store_explicit', 'atomic_load', 'atomic_load_explicit',
+        'atomic_exchange', 'atomic_exchange_explicit', 'atomic_compare_exchange_strong',
+        'atomic_compare_exchange_strong_explicit', 'atomic_compare_exchange_weak',
+        'atomic_compare_exchange_weak_explicit', 'atomic_fetch_key', 'atomic_fetch_key_explicit', 
+        'atomic_flag_test_and_set', 'atomic_flag_test_and_set_explicit',
+        'atomic_flag_clear', 'atomic_flag_clear_explicit', ],
+    # B.17 Boolean type and values
+    'stdbool.h': C99_STDLIB_IDENTIFIERS['stdbool.h'],
+    # B.18 Common definitions
+    'stddef.h': C99_STDLIB_IDENTIFIERS['stddef.h'] +
+        ['max_align_t','__STDC_WANT_LIB_EXT1__', 'rsize_t'],
+    # B.19 Integer types
+    'stdint.h': C99_STDLIB_IDENTIFIERS['stdint.h']+
+        ['__STDC_WANT_LIB_EXT1__', 'RSIZE_MAX'],
+    # B.20 Input/output
+    'stdio.h': C99_STDLIB_IDENTIFIERS['stdio.h'] + 
+        ['__STDC_WANT_LIB_EXT1__', 'L_tmpnam_s', 'TMP_MAX_S', 'errno_t', 'rsize_t',
+        'tmpfile_s', 'tmpnam_s', 'fopen_s', 'freopen_s', 'fprintf_s', 'fscanf_s',
+        'printf_s','scanf_s','snprintf_s','sprintf_s','sscanf_s','vfprintf_s',
+        'vfscanf_s', 'vsprintf_s', 'vsscanf_s', 'gets_s'
+        ],
+    # B.21 General utilities
+    'stdlib.h': C99_STDLIB_IDENTIFIERS['stdlib.h'] + 
+    ['constraint_handler_t', 'set_constraint_handler_s', 'abort_handler_s',
+     'ignore_handler_s', 'getenv_s', 'bsearch_s', 'qsort_s', 'wctomb_s',
+     'mbstowcs_s', 'wcstombs_s'],
+    # B.22 Noretrun
+    'stdnoreturn.h': ['noreturn'],
+    # B.23 String handling
+    'string.h': C99_STDLIB_IDENTIFIERS['string.h'] + 
+    ['memcpy_s', 'memmoce_s', 'strcpy_s', 'strncpy_s','strcat_s',
+     'strtok_s', 'memset_s', 'strerror_s', 'strerrorlen_s', 'strnlen_s'],
+    # B.24 Type-generic math
+    'tgmath.h': C99_STDLIB_IDENTIFIERS['tgmath.h'],
+    # B.25 Threads
+    'threads.h': ['thread_local', 'ONCE_FLAG_INIT', 'TSS_DTOR_ITERATIONS',
+        'cnd_t', 'thrd_t', 'tss_t', 'mtx_t', 'tss_dtor_t', 'thrd_start_t', 
+        'once_flag', 'mtx_plain', 'mtx_recursive', 'mtx_timed', 'thrd_timedout',
+        'thrd_success', 'thrd_busy', 'thrd_error', 'thrd_nomem', 'call_once',
+        'cnd_broadcast', 'cnd_destroy','cnd_init', 'cnd_signal', 'cnd_timedwait',
+        'cnd_wait','mtx_destroy', 'mtx_init', 'mtx_lock', 'mtx_timedlock',
+        'mtx_trylock', 'mtx_unlock', 'thrd_create', 'thrd_current',
+        'thrd_detach', 'thrd_equal', 'thrd_exit', 'thrd_join', 'thrd_sleep',
+        'thrd_yield', 'tss_create', 'tss_delete', 'tss_get', 'tss_set' ],
+    # B.26 Date and time
+    'time.h': C99_STDLIB_IDENTIFIERS['time.h'] + [
+        'asctime_s', 'ctime_s', 'gmtime_s', 'localtime_s'
+        ],
+    # B.27 Unicode utilities
+    'uchar.h': ['mbstate_t', 'size_t', 'char16_t', 'char32_t',
+        'mbrtoc16', 'c16rtomb', 'mbrtoc32', 'c32rtomb'
+        ],
+    # B.28 Extended multibyte/wide character utilities
+    'wchar.h': C99_STDLIB_IDENTIFIERS["wchar.h"]+[
+        'fwprintf_s', 'fwscanf_s', 'snwprintf_s', 'swprintf_s', 'swscanf_s', 
+        'vfwprintf_s', 'vfwscanf_s', 'vsnwprintf_s', 'vswprintf_s', 'vswscanf_s', 
+        'vwprintf_s', 'vwscanf_s', 'wprintf_s', 'wscanf_s', 'wcscpy_s', 'wcsncpy_s', 
+        'wmemcpy_s', 'wmemmove_s', 'wcscat_s', 'wcsncat_s', 'wcstok_s', 'wcsnlen_s', 
+        'wcrtomb_s', 'mbsrtowcs_s', 'wcsrtombs_s', 
+    ],
+    # B.29 Wide character classification and mapping utilities
+    'wctype.h': C99_STDLIB_IDENTIFIERS['wctype.h'],
+}
+
+def getStdLib(standard):
+    if standard == 'c89':
+        return C90_STDLIB_IDENTIFIERS
+    if standard == 'c99':
+        return C99_STDLIB_IDENTIFIERS
+    return C11_STDLIB_IDENTIFIERS
+
+def isStdLibId(id_, standard='c99'):
+    id_lists = getStdLib(standard).values()
+    for l in id_lists:
+        if id_ in l:
+            return True
+    return False
+
+# Reserved keywords defined in ISO/IEC9899:1990 -- ch 6.1.1
+C90_KEYWORDS = {
+    'auto', 'break', 'case', 'char', 'const', 'continue', 'default', 'do',
+    'double', 'else', 'enum', 'extern', 'float', 'for', 'goto', 'if',
+    'int', 'long', 'register', 'return', 'short', 'signed',
+    'sizeof', 'static', 'struct', 'switch', 'typedef', 'union', 'unsigned',
+    'void', 'volatile', 'while'
+}
+
+
+# Reserved keywords defined in Section 6.4.1 "Language" of C99 Standard
+# Based on ISO/IEC 9899:1999 (E) 6.4.1 Keywords
+# Adding the expanding macros from Section 7 too
+# (https://www.dii.uchile.cl/~daespino/files/Iso_C_1999_definition.pdf)
+C99_ADDED_KEYWORDS = {
+    'inline', 'restrict', '_Bool', '_Complex', '_Imaginary',
+    'bool', 'complex', 'imaginary'
 }
 
+# Reserved keywords defined in Section 6.4.1 "Language" of C11 Standard
+# Based on ISO/IEC 9899:201x N1570 (Draft 12.04.2011) 6.4.1 Keywords
+# Adding the expanding macros from Section 7 too
+# (https://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf)
+C11_ADDED_KEYWORDS = {
+    '_Alignas', '_Alignof', '_Atomic', '_Generic', '_Noreturn',
+    '_Static_assert', '_Thread_local' ,
+    'alignas', 'alignof', 'noreturn', 'static_assert','thread_local'
+}
+
+def isKeyword(keyword, standard='c99'):
+    kw_set = {}
+    if standard == 'c89':
+        kw_set = C90_KEYWORDS
+    elif standard == 'c99':
+        kw_set = copy.copy(C90_KEYWORDS)
+        kw_set.update(C99_ADDED_KEYWORDS)
+    else:
+        kw_set = copy.copy(C90_KEYWORDS)
+        kw_set.update(C99_ADDED_KEYWORDS)
+        kw_set.update(C11_ADDED_KEYWORDS)
+    return keyword in kw_set
+
+
+def is_source_file(file):
+    return file.endswith('.c')
+
+
+def is_header(file):
+    return file.endswith('.h')
+
+
+def is_errno_setting_function(function_name):
+    return function_name and \
+           function_name in ('ftell', 'fgetpos', 'fsetpos', 'fgetwc', 'fputwc'
+                             'strtoimax', 'strtoumax', 'strtol', 'strtoul',
+                             'strtoll', 'strtoull', 'strtof', 'strtod', 'strtold'
+                             'wcstoimax', 'wcstoumax', 'wcstol', 'wcstoul',
+                             'wcstoll', 'wcstoull', 'wcstof', 'wcstod', 'wcstold'
+                             'wcrtomb', 'wcsrtombs', 'mbrtowc')
+
+
+def get_type_conversion_to_from(token):
+    def get_vartok(expr):
+        while expr:
+            if isCast(expr):
+                if expr.astOperand2 is None:
+                    expr = expr.astOperand1
+                else:
+                    expr = expr.astOperand2
+            elif expr.str in ('.', '::'):
+                expr = expr.astOperand2
+            elif expr.str == '[':
+                expr = expr.astOperand1
+            else:
+                break
+        return expr if (expr and expr.variable) else None
+
+    if isCast(token):
+        vartok = get_vartok(token)
+        if vartok:
+            return (token.next, vartok.variable.typeStartToken)
+
+    elif token.str == '=':
+        lhs = get_vartok(token.astOperand1)
+        rhs = get_vartok(token.astOperand2)
+        if lhs and rhs:
+            return (lhs.variable.typeStartToken, rhs.variable.typeStartToken)
+
+    return None
+
+
+def is_composite_expr(expr, composite_operator=False):
+    """MISRA C 2012, section 8.10.3"""
+    if expr is None:
+        return False
+
+    if not composite_operator:
+        if expr.str == '?' and simpleMatch(expr.astOperand2, ':'):
+            colon = expr.astOperand2
+            return is_composite_expr(colon.astOperand1,True) or is_composite_expr(colon.astOperand2, True)
+        if (expr.str in ('+', '-', '*', '/', '%', '&', '|', '^', '>>', "<<", "?", ":", '~')):
+            return is_composite_expr(expr.astOperand1,True) or is_composite_expr(expr.astOperand2, True)
+        return False
+
+    # non constant expression?
+    if expr.isNumber:
+        return False
+    if expr.astOperand1 or expr.astOperand2:
+        return is_composite_expr(expr.astOperand1,True) or is_composite_expr(expr.astOperand2, True)
+    return True
+
 
 def getEssentialTypeCategory(expr):
     if not expr:
@@ -118,16 +617,27 @@ def getEssentialTypeCategory(expr):
         # TODO this is incomplete
         e1 = getEssentialTypeCategory(expr.astOperand1)
         e2 = getEssentialTypeCategory(expr.astOperand2)
-        #print('{0}: {1} {2}'.format(expr.str, e1, e2))
+        # print('{0}: {1} {2}'.format(expr.str, e1, e2))
         if e1 and e2 and e1 == e2:
             return e1
         if expr.valueType:
             return expr.valueType.sign
-    if expr.valueType and expr.valueType.typeScope:
+    if expr.valueType and expr.valueType.typeScope and expr.valueType.typeScope.className:
         return "enum<" + expr.valueType.typeScope.className + ">"
-    if expr.variable:
-        typeToken = expr.variable.typeStartToken
-        while typeToken:
+    # Unwrap membership, dereferences and array indexing
+    vartok = expr
+    while True:
+        if simpleMatch(vartok, '[') or (vartok and vartok.str == '*' and vartok.astOperand2 is None):
+            vartok = vartok.astOperand1
+        elif simpleMatch(vartok, '.'):
+            vartok = vartok.astOperand2
+        else:
+            break
+    if vartok and vartok.variable:
+        typeToken = vartok.variable.typeStartToken
+        while typeToken and typeToken.isName:
+            if typeToken.str == 'char' and not typeToken.isSigned and not typeToken.isUnsigned:
+                return 'char'
             if typeToken.valueType:
                 if typeToken.valueType.type == 'bool':
                     return typeToken.valueType.type
@@ -136,6 +646,20 @@ def getEssentialTypeCategory(expr):
                 if typeToken.valueType.sign:
                     return typeToken.valueType.sign
             typeToken = typeToken.next
+
+    # See Appendix D, section D.6, Character constants
+    if expr.str[0] == "'" and expr.str[-1] == "'":
+        if len(expr.str) == 3 or (len(expr.str) == 4 and expr.str[1] == '\\'):
+            return 'char'
+        return expr.valueType.sign
+
+    if (expr.isCast and expr.str == "("):
+        castTok = expr.next
+        while castTok.isName or castTok.str == "*":
+            if castTok.str == 'char' and not castTok.isSigned and not castTok.isUnsigned:
+                return 'char'
+            castTok = castTok.next
+
     if expr.valueType:
         return expr.valueType.sign
     return None
@@ -155,34 +679,88 @@ def getEssentialCategorylist(operand1, operand2):
     return e1, e2
 
 
+def get_essential_type_from_value(value, is_signed):
+    if value is None:
+        return None
+    for t in ('char', 'short', 'int', 'long', 'long long'):
+        bits = bitsOfEssentialType(t)
+        if bits >= 64:
+            continue
+        if is_signed:
+            range_min = -(1 << (bits - 1))
+            range_max = (1 << (bits - 1)) - 1
+        else:
+            range_min = 0
+            range_max = (1 << bits) - 1
+        sign = 'signed' if is_signed else 'unsigned'
+        if is_signed and value < 0 and value >= range_min:
+            return '%s %s' % (sign, t)
+        if value >= 0 and value <= range_max:
+            return '%s %s' % (sign, t)
+    return None
+
 def getEssentialType(expr):
     if not expr:
         return None
-    if expr.variable:
-        typeToken = expr.variable.typeStartToken
+
+    # See Appendix D, section D.6, Character constants
+    if expr.str[0] == "'" and expr.str[-1] == "'":
+        if len(expr.str) == 3 or (len(expr.str) == 4 and expr.str[1] == '\\'):
+            return 'char'
+        return '%s %s' % (expr.valueType.sign, expr.valueType.type)
+
+    if expr.variable or isCast(expr):
+        typeToken = expr.variable.typeStartToken if expr.variable else expr.next
         while typeToken and typeToken.isName:
-            if typeToken.str in ('char', 'short', 'int', 'long', 'float', 'double'):
-                return typeToken.str
+            if typeToken.str == 'char' and not typeToken.isSigned and not typeToken.isUnsigned:
+                return 'char'
             typeToken = typeToken.next
+        if expr.valueType:
+            if expr.valueType.type == 'bool':
+                return 'bool'
+            if expr.valueType.isFloat():
+                return expr.valueType.type
+            if expr.valueType.isIntegral():
+                if (expr.valueType.sign is None) and expr.valueType.type == 'char':
+                    return 'char'
+                return '%s %s' % (expr.valueType.sign, expr.valueType.type)
+
+    elif expr.isNumber:
+        # Appendix D, D.6 The essential type of literal constants
+        # Integer constants
+        if expr.valueType.type == 'bool':
+            return 'bool'
+        if expr.valueType.isFloat():
+            return expr.valueType.type
+        if expr.valueType.isIntegral():
+            if expr.valueType.type != 'int':
+                return '%s %s' % (expr.valueType.sign, expr.valueType.type)
+            return get_essential_type_from_value(expr.getKnownIntValue(), expr.valueType.sign == 'signed')
+
+    elif expr.str in ('<', '<=', '>=', '>', '==', '!=', '&&', '||', '!'):
+        return 'bool'
 
-    elif expr.astOperand1 and expr.astOperand2 and expr.str in ('+', '-', '*', '/', '%', '&', '|', '^', '>>', "<<", "?", ":"):
+    elif expr.astOperand1 and expr.astOperand2 and expr.str in (
+    '+', '-', '*', '/', '%', '&', '|', '^', '>>', "<<", "?", ":"):
         if expr.astOperand1.valueType and expr.astOperand1.valueType.pointer > 0:
             return None
         if expr.astOperand2.valueType and expr.astOperand2.valueType.pointer > 0:
             return None
         e1 = getEssentialType(expr.astOperand1)
         e2 = getEssentialType(expr.astOperand2)
-        if not e1 or not e2:
-            return None
-        types = ['bool', 'char', 'short', 'int', 'long', 'long long']
-        try:
-            i1 = types.index(e1)
-            i2 = types.index(e2)
-            if i2 >= i1:
-                return types[i2]
-            return types[i1]
-        except ValueError:
+        if e1 is None or e2 is None:
             return None
+        if is_constant_integer_expression(expr):
+            sign1 = e1.split(' ')[0]
+            sign2 = e2.split(' ')[0]
+            if sign1 == sign2 and sign1 in ('signed', 'unsigned'):
+                e = get_essential_type_from_value(expr.getKnownIntValue(), sign1 == 'signed')
+                if e:
+                    return e
+        if bitsOfEssentialType(e2) >= bitsOfEssentialType(e1):
+            return e2
+        return e1
+
     elif expr.str == "~":
         e1 = getEssentialType(expr.astOperand1)
         return e1
@@ -190,23 +768,48 @@ def getEssentialType(expr):
     return None
 
 
-def bitsOfEssentialType(expr):
-    type = getEssentialType(expr)
-    if type is None:
+def bitsOfEssentialType(ty):
+    if ty is None:
         return 0
-    if type == 'char':
+    last_type = ty.split(' ')[-1]
+    if last_type == 'Boolean':
+        return 1
+    if last_type == 'char':
         return typeBits['CHAR']
-    if type == 'short':
+    if last_type == 'short':
         return typeBits['SHORT']
-    if type == 'int':
+    if last_type == 'int':
         return typeBits['INT']
-    if type == 'long':
-        return typeBits['LONG']
-    if type == 'long long':
+    if ty.endswith('long long'):
         return typeBits['LONG_LONG']
+    if last_type == 'long':
+        return typeBits['LONG']
+    for sty in STDINT_TYPES:
+        if ty == sty:
+            return int(''.join(filter(str.isdigit, sty)))
     return 0
 
 
+def get_function_pointer_type(tok):
+    ret = ''
+    while tok and (tok.isName or tok.str == '*'):
+        ret += ' ' + tok.str
+        tok = tok.next
+    if tok is None or tok.str != '(':
+        return None
+    tok = tok.link
+    if not simpleMatch(tok, ') ('):
+        return None
+    ret += '('
+    tok = tok.next.next
+    while tok and (tok.str not in '()'):
+        if tok.varId is None:
+            ret += ' ' + tok.str
+        tok = tok.next
+    if (tok is None) or tok.str != ')':
+        return None
+    return ret[1:] + ')'
+
 def isCast(expr):
     if not expr or expr.str != '(' or not expr.astOperand1 or expr.astOperand2:
         return False
@@ -214,15 +817,27 @@ def isCast(expr):
         return False
     return True
 
+def is_constant_integer_expression(expr):
+    if expr is None:
+        return False
+    if expr.isInt:
+        return True
+    if not expr.isArithmeticalOp:
+        return False
+    if expr.astOperand1 and not is_constant_integer_expression(expr.astOperand1):
+        return False
+    if expr.astOperand2 and not is_constant_integer_expression(expr.astOperand2):
+        return False
+    return True
 
-def isFunctionCall(expr):
+def isFunctionCall(expr, std='c99'):
     if not expr:
         return False
     if expr.str != '(' or not expr.astOperand1:
         return False
     if expr.astOperand1 != expr.previous:
         return False
-    if expr.astOperand1.str in KEYWORDS:
+    if isKeyword(expr.astOperand1.str, std):
         return False
     return True
 
@@ -255,6 +870,96 @@ def getForLoopExpressions(forToken):
             lpar.astOperand2.astOperand2.astOperand2]
 
 
+def get_function_scope(cfg, func):
+    if func:
+        for scope in cfg.scopes:
+            if scope.function == func:
+                return scope
+    return None
+
+
+def is_variable_changed(start_token, end_token, var):
+    """Check if variable is updated between body_start and body_end"""
+    tok = start_token
+    while tok != end_token:
+        if tok.isAssignmentOp:
+            vartok = tok.astOperand1
+            while vartok.astOperand1:
+                vartok = vartok.astOperand1
+            if vartok and vartok.variable == var:
+                return True
+        tok = tok.next
+    return False
+
+def getForLoopCounterVariables(forToken, cfg):
+    """ Return a set of Variable objects defined in ``for`` statement and
+    satisfy requirements to loop counter term from section 8.14 of MISRA
+    document.
+    """
+    if not forToken or forToken.str != 'for':
+        return None
+    tn = forToken.next
+    if not tn or tn.str != '(':
+        return None
+    vars_defined = set()
+    vars_initialized = set()
+    vars_exit = set()
+    vars_modified = set()
+    cur_clause = 1
+    te = tn.link
+    while tn and tn != te:
+        if tn.variable:
+            if cur_clause == 1 and tn.variable.nameToken == tn:
+                vars_defined.add(tn.variable)
+            elif cur_clause == 2:
+                vars_exit.add(tn.variable)
+            elif cur_clause == 3:
+                if tn.next and countSideEffectsRecursive(tn.next) > 0:
+                    vars_modified.add(tn.variable)
+                elif tn.previous and tn.previous.str in ('++', '--'):
+                    tn_ast = tn.astParent
+                    if tn_ast and tn_ast == tn.previous:
+                        vars_modified.add(tn.variable)
+                    elif tn_ast and tn_ast.str == '.' and tn_ast.astOperand2 and tn_ast.astOperand2.variable:
+                        vars_modified.add(tn_ast.astOperand2.variable)
+        if cur_clause == 1 and tn.isAssignmentOp:
+            var_token = tn.astOperand1
+            while var_token and var_token.str == '.':
+                var_token = var_token.astOperand2
+            if var_token and var_token.variable:
+                vars_initialized.add(var_token.variable)
+        if cur_clause == 1 and tn.isName and tn.next.str == '(':
+            function_args_in_init = getArguments(tn.next)
+            function_scope = get_function_scope(cfg, tn.function)
+            for arg_nr in range(len(function_args_in_init)):
+                init_arg = function_args_in_init[arg_nr]
+                if init_arg is None or not init_arg.isUnaryOp('&'):
+                    continue
+                var_token = init_arg.astOperand1
+                while var_token and var_token.str == '.':
+                    var_token = var_token.astOperand2
+                if var_token is None or var_token.variable is None:
+                    continue
+                changed = False
+                if function_scope is None:
+                    changed = True
+                elif tn.function is None:
+                    changed = True
+                else:
+                    function_body_start = function_scope.bodyStart
+                    function_body_end = function_scope.bodyEnd
+                    args = tn.function.argument[arg_nr + 1]
+                    if function_scope is None or is_variable_changed(function_body_start, function_body_end, args):
+                        changed = True
+                if changed:
+                    vars_initialized.add(var_token.variable)
+
+        if tn.str == ';':
+            cur_clause += 1
+        tn = tn.next
+    return vars_defined | vars_initialized, vars_exit & vars_modified
+
+
 def findCounterTokens(cond):
     if not cond:
         return []
@@ -282,6 +987,7 @@ def isFloatCounterInWhileLoop(whileToken):
     lpar = whileToken.next
     rpar = lpar.link
     counterTokens = findCounterTokens(lpar.astOperand2)
+    tok_varid = tuple(tok.varId for tok in counterTokens if tok.varId)
     whileBodyStart = None
     if simpleMatch(rpar, ') {'):
         whileBodyStart = rpar.next
@@ -292,33 +998,41 @@ def isFloatCounterInWhileLoop(whileToken):
     token = whileBodyStart
     while token != whileBodyStart.link:
         token = token.next
-        for counterToken in counterTokens:
-            if not counterToken.valueType or not counterToken.valueType.isFloat():
-                continue
-            if token.isAssignmentOp and token.astOperand1.str == counterToken.str:
+        if not token.varId:
+            continue
+        if token.varId not in tok_varid:
+            continue
+        if not token.astParent or not token.valueType or not token.valueType.isFloat():
+            continue
+        parent = token.astParent
+        if parent.str in ('++', '--'):
+            return True
+        while parent:
+            if parent.isAssignmentOp and parent.str != "=" and parent.astOperand1 == token:
                 return True
-            if token.str == counterToken.str and token.astParent and token.astParent.str in ('++', '--'):
+            if parent.str == "=" and parent.astOperand1.str == token.str and parent.astOperand1 != token:
                 return True
+            parent = parent.astParent
     return False
 
 
-def hasSideEffectsRecursive(expr):
-    if not expr:
-        return False
+def countSideEffectsRecursive(expr):
+    if not expr or expr.str == ';':
+        return 0
     if expr.str == '=' and expr.astOperand1 and expr.astOperand1.str == '[':
         prev = expr.astOperand1.previous
         if prev and (prev.str == '{' or prev.str == '{'):
-            return hasSideEffectsRecursive(expr.astOperand2)
+            return countSideEffectsRecursive(expr.astOperand2)
     if expr.str == '=' and expr.astOperand1 and expr.astOperand1.str == '.':
         e = expr.astOperand1
         while e and e.str == '.' and e.astOperand2:
             e = e.astOperand1
         if e and e.str == '.':
-            return False
-    if expr.str in ('++', '--', '='):
-        return True
+            return 0
+    if expr.isAssignmentOp or expr.str in {'++', '--'}:
+        return 1
     # Todo: Check function calls
-    return hasSideEffectsRecursive(expr.astOperand1) or hasSideEffectsRecursive(expr.astOperand2)
+    return countSideEffectsRecursive(expr.astOperand1) + countSideEffectsRecursive(expr.astOperand2)
 
 
 def isBoolExpression(expr):
@@ -329,10 +1043,17 @@ def isBoolExpression(expr):
     return expr.str in ['!', '==', '!=', '<', '<=', '>', '>=', '&&', '||', '0', '1', 'true', 'false']
 
 
+def isEnumConstant(expr):
+    if not expr or not expr.values:
+        return False
+    values = expr.values
+    return len(values) == 1 and values[0].valueKind == 'known'
+
+
 def isConstantExpression(expr):
     if expr.isNumber:
         return True
-    if expr.isName:
+    if expr.isName and not isEnumConstant(expr):
         return False
     if simpleMatch(expr.previous, 'sizeof ('):
         return True
@@ -342,16 +1063,17 @@ def isConstantExpression(expr):
         return False
     return True
 
+def isUnknownConstantExpression(expr):
+    if expr.isName and not isEnumConstant(expr) and expr.variable is None:
+        return True
+    if expr.astOperand1 and isUnknownConstantExpression(expr.astOperand1):
+        return True
+    if expr.astOperand2 and isUnknownConstantExpression(expr.astOperand2):
+        return True
+    return False
 
 def isUnsignedInt(expr):
-    # TODO this function is very incomplete. use ValueType?
-    if not expr:
-        return False
-    if expr.isNumber:
-        return 'u' in expr.str or 'U' in expr.str
-    if expr.str in ('+', '-', '*', '/', '%'):
-        return isUnsignedInt(expr.astOperand1) or isUnsignedInt(expr.astOperand2)
-    return False
+    return expr and expr.valueType and expr.valueType.type in ('short', 'int') and expr.valueType.sign == 'unsigned'
 
 
 def getPrecedence(expr):
@@ -484,7 +1206,7 @@ def isHexEscapeSequence(symbols):
 
 
 def isOctalEscapeSequence(symbols):
-    """Checks that given symbols are valid octal escape sequence:
+    r"""Checks that given symbols are valid octal escape sequence:
 
      octal-escape-sequence:
              \ octal-digit
@@ -505,6 +1227,28 @@ def isSimpleEscapeSequence(symbols):
     return symbols[1] in ("'", '"', '?', '\\', 'a', 'b', 'f', 'n', 'r', 't', 'v')
 
 
+def isTernaryOperator(token):
+    if not token:
+        return False
+    if not token.astOperand2:
+        return False
+    return token.str == '?' and token.astOperand2.str == ':'
+
+
+def getTernaryOperandsRecursive(token):
+    """Returns list of ternary operands including nested ones."""
+    if not isTernaryOperator(token):
+        return []
+    result = []
+    result += getTernaryOperandsRecursive(token.astOperand2.astOperand1)
+    if token.astOperand2.astOperand1 and not isTernaryOperator(token.astOperand2.astOperand1):
+        result += [token.astOperand2.astOperand1]
+    result += getTernaryOperandsRecursive(token.astOperand2.astOperand2)
+    if token.astOperand2.astOperand2 and not isTernaryOperator(token.astOperand2.astOperand2):
+        result += [token.astOperand2.astOperand2]
+    return result
+
+
 def hasNumericEscapeSequence(symbols):
     """Check that given string contains octal or hexadecimal escape sequences."""
     if '\\' not in symbols:
@@ -532,36 +1276,111 @@ def isNoReturnScope(tok):
     return False
 
 
+# Return the token which the value is assigned to
+def getAssignedVariableToken(vartok):
+    if not vartok:
+        return None
+    parent = vartok.astParent
+    while parent and parent.isArithmeticalOp:
+        parent = parent.astParent
+    if parent and parent.isAssignmentOp:
+        return parent.astOperand1
+    return None
+
+# If the value is used as a return value, return the function definition
+def getFunctionUsingReturnValue(valueToken):
+    if not valueToken:
+        return None
+    if not valueToken.astParent:
+        return None
+    operator = valueToken.astParent
+    if operator.str == 'return':
+        return operator.scope.function
+    if operator.isArithmeticalOp:
+        return getFunctionUsingReturnValue(operator)
+    return None
+
+# Return true if the token follows a specific sequence of token str values
+def tokenFollowsSequence(token, sequence):
+    if not token:
+        return False
+    for i in reversed(sequence):
+        prev = token.previous
+        if not prev:
+            return False
+        if prev.str != i:
+            return False
+        token = prev
+    return True
+
 class Define:
     def __init__(self, directive):
+        self.name = ''
         self.args = []
         self.expansionList = ''
 
-        res = re.match(r'#define [A-Za-z0-9_]+\(([A-Za-z0-9_,]+)\)[ ]+(.*)', directive.str)
-        if res is None:
-            return
+        res = re.match(r'#define ([A-Za-z0-9_]+)\(([A-Za-z0-9_, ]+)\)[ ]+(.*)', directive.str)
+        if res:
+            self.name = res.group(1)
+            self.args = res.group(2).strip().split(',')
+            self.expansionList = res.group(3)
+        else:
+            res = re.match(r'#define ([A-Za-z0-9_]+)[ ]+(.*)', directive.str)
+            if res:
+                self.name = res.group(1)
+                self.expansionList = res.group(2)
 
-        self.args = res.group(1).split(',')
-        self.expansionList = res.group(2)
+    def __repr__(self):
+        attrs = ["name", "args", "expansionList"]
+        return "{}({})".format(
+            "Define",
+            ", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
+        )
 
 
 def getAddonRules():
     """Returns dict of MISRA rules handled by this addon."""
     addon_rules = []
     compiled = re.compile(r'.*def[ ]+misra_([0-9]+)_([0-9]+)[(].*')
-    for line in open(__file__):
-        res = compiled.match(line)
-        if res is None:
-            continue
-        addon_rules.append(res.group(1) + '.' + res.group(2))
+    with open(__file__) as f:
+        for line in f:
+            res = compiled.match(line)
+            if res is None:
+                continue
+            addon_rules.append(res.group(1) + '.' + res.group(2))
     return addon_rules
 
 
 def getCppcheckRules():
     """Returns list of rules handled by cppcheck."""
-    return ['1.3', '2.1', '2.2', '2.4', '2.6', '8.3', '12.2', '13.2', '13.6',
-            '14.3', '17.5', '18.1', '18.2', '18.3', '18.6', '20.6',
-            '22.1', '22.2', '22.4', '22.6']
+    return ['1.3', # <most "error">
+            '2.1', # alwaysFalse, duplicateBreak
+            '2.2', # alwaysTrue, redundantCondition, redundantAssignment, redundantAssignInSwitch, unreadVariable
+            '2.6', # unusedLabel
+            '5.3', # shadowVariable
+            '8.3', # funcArgNamesDifferent
+            '8.13', # constPointer
+            '9.1', # uninitvar
+            '14.3', # alwaysTrue, alwaysFalse, compareValueOutOfTypeRangeError
+            '13.2', # unknownEvaluationOrder
+            '13.6', # sizeofCalculation
+            '17.4', # missingReturn
+            '17.5', # argumentSize
+            '18.1', # pointerOutOfBounds
+            '18.2', # comparePointers
+            '18.3', # comparePointers
+            '18.6', # danglingLifetime
+            '19.1', # overlappingWriteUnion, overlappingWriteFunction
+            '20.6', # preprocessorErrorDirective
+            '21.13', # invalidFunctionArg
+            '21.17', # bufferAccessOutOfBounds
+            '21.18', # bufferAccessOutOfBounds
+            '22.1', # memleak, resourceLeak, memleakOnRealloc, leakReturnValNotUsed, leakNoVarFunctionCall
+            '22.2', # autovarInvalidDeallocation
+            '22.3', # incompatibleFileOpen
+            '22.4', # writeReadOnlyFile
+            '22.6' # useClosedFile
+           ]
 
 
 def generateTable():
@@ -587,8 +1406,8 @@ def generateTable():
     numberOfRules[18] = 8
     numberOfRules[19] = 2
     numberOfRules[20] = 14
-    numberOfRules[21] = 12
-    numberOfRules[22] = 6
+    numberOfRules[21] = 21
+    numberOfRules[22] = 10
 
     # Rules that can be checked with compilers:
     # compiler = ['1.1', '1.2']
@@ -631,10 +1450,10 @@ def remove_file_prefix(file_path, prefix):
     return result
 
 
-class Rule(object):
+class Rule():
     """Class to keep rule text and metadata"""
 
-    MISRA_SEVERIY_LEVELS = ['Required', 'Mandatory', 'Advisory']
+    MISRA_SEVERITY_LEVELS = ['Required', 'Mandatory', 'Advisory']
 
     def __init__(self, num1, num2):
         self.num1 = num1
@@ -652,7 +1471,7 @@ def misra_severity(self):
 
     @misra_severity.setter
     def misra_severity(self, val):
-        if val in self.MISRA_SEVERIY_LEVELS:
+        if val in self.MISRA_SEVERITY_LEVELS:
             self._misra_severity = val
         else:
             self._misra_severity = ''
@@ -665,7 +1484,7 @@ def __repr__(self):
         return "%d.%d (%s)" % (self.num1, self.num2, self.misra_severity)
 
 
-class MisraSettings(object):
+class MisraSettings():
     """Hold settings for misra.py script."""
 
     __slots__ = ["verify", "quiet", "show_summary"]
@@ -688,10 +1507,17 @@ def __init__(self, args):
         if args.no_summary:
             self.show_summary = False
 
+    def __repr__(self):
+        attrs = ["verify", "quiet", "show_summary", "verify"]
+        return "{}({})".format(
+            "MisraSettings",
+            ", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
+        )
+
 
 class MisraChecker:
 
-    def __init__(self, settings, stdversion="c90"):
+    def __init__(self, settings, stdversion="c89"):
         """
         :param settings: misra.py script settings.
         """
@@ -699,52 +1525,302 @@ def __init__(self, settings, stdversion="c90"):
         self.settings = settings
 
         # Test validation rules lists
-        self.verify_expected    = list()
-        self.verify_actual      = list()
+        self.verify_expected = []
+        self.verify_actual = []
 
         # List of formatted violation messages
-        self.violations         = dict()
+        self.violations = {}
 
         # if --rule-texts is specified this dictionary
         # is loaded with descriptions of each rule
         # by rule number (in hundreds).
         # ie rule 1.2 becomes 102
-        self.ruleTexts          = dict()
+        self.ruleTexts = {}
+        self.ruleText_filename = None
 
         # Dictionary of dictionaries for rules to suppress
         # Dict1 is keyed by rule number in the hundreds format of
         # Major *  100 + minor. ie Rule 5.2 = (5*100) + 2
         # Dict 2 is keyed by filename.  An entry of None means suppress globally.
-        # Each file name entry contails a list of tuples of (lineNumber, symbolName)
+        # Each file name entry contains a list of tuples of (lineNumber, symbolName)
         # or an item of None which indicates suppress rule for the entire file.
         # The line and symbol name tuple may have None as either of its elements but
         # should not be None for both.
-        self.suppressedRules    = dict()
-
-        # List of suppression extracted from the dumpfile
-        self.dumpfileSuppressions = None
+        self.suppressedRules = {}
 
         # Prefix to ignore when matching suppression files.
         self.filePrefix = None
 
-        # Statistics of all violations suppressed per rule
-        self.suppressionStats   = dict()
+        # Number of all violations suppressed per rule
+        self.suppressionStats = {}
 
         self.stdversion = stdversion
 
+        self.severity = None
+
+        self.existing_violations = set()
+
+        self._ctu_summary_typedefs = False
+        self._ctu_summary_tagnames = False
+        self._ctu_summary_identifiers = False
+        self._ctu_summary_usage = False
+
+        self.path_premium_addon = None
+
+    def __repr__(self):
+        attrs = ["settings", "verify_expected", "verify_actual", "violations",
+                 "ruleTexts", "suppressedRules", "filePrefix",
+                 "suppressionStats", "stdversion", "severity"]
+        return "{}({})".format(
+            "MisraChecker",
+            ", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
+        )
+
     def get_num_significant_naming_chars(self, cfg):
-        if cfg.standards and cfg.standards.c == "c99":
-            return 63
-        else:
+        if cfg.standards and cfg.standards.c == "c89":
             return 31
+        return 63
+
+    def _save_ctu_summary_typedefs(self, dumpfile, typedef_info):
+        if self._ctu_summary_typedefs:
+            return
+
+        self._ctu_summary_typedefs = True
+
+        summary = []
+        for ti in typedef_info:
+            summary.append({ 'name': ti.name, 'file': ti.file, 'line': ti.linenr, 'column': ti.column, 'used': ti.used })
+        if len(summary) > 0:
+            cppcheckdata.reportSummary(dumpfile, 'MisraTypedefInfo', summary)
+
+    def _save_ctu_summary_tagnames(self, dumpfile, cfg):
+        if self._ctu_summary_tagnames:
+            return
+
+        self._ctu_summary_tagnames = True
+
+        summary = []
+        # structs/enums
+        for scope in cfg.scopes:
+            if scope.className is None:
+                continue
+            if scope.className.startswith('Anonymous'):
+                continue
+            if scope.type not in ('Struct', 'Enum'):
+                continue
+            used = False
+            tok = scope.bodyEnd
+            while tok:
+                if tok.str == scope.className:
+                    used = True
+                    break
+                tok = tok.next
+            summary.append({'name': scope.className, 'used':used, 'file': scope.bodyStart.file, 'line': scope.bodyStart.linenr, 'column': scope.bodyStart.column})
+        if len(summary) > 0:
+            cppcheckdata.reportSummary(dumpfile, 'MisraTagName', summary)
+
+    def _save_ctu_summary_identifiers(self, dumpfile, cfg):
+        if self._ctu_summary_identifiers:
+            return
+        self._ctu_summary_identifiers = True
+
+        external_identifiers = []
+        internal_identifiers = []
+        local_identifiers = []
+
+        def identifier(nameToken):
+            return {'name':nameToken.str, 'file':nameToken.file, 'line':nameToken.linenr, 'column':nameToken.column}
+
+        names = []
+
+        for var in cfg.variables:
+            if var.nameToken is None:
+                continue
+            if var.access != 'Global':
+                if var.nameToken.str in names:
+                    continue
+                names.append(var.nameToken.str)
+                local_identifiers.append(identifier(var.nameToken))
+            elif var.isStatic:
+                names.append(var.nameToken.str)
+                i = identifier(var.nameToken)
+                i['inlinefunc'] = False
+                internal_identifiers.append(i)
+            else:
+                names.append(var.nameToken.str)
+                i = identifier(var.nameToken)
+                i['decl'] = var.isExtern
+                external_identifiers.append(i)
+
+        for func in cfg.functions:
+            if func.tokenDef is None:
+                continue
+            if func.isStatic:
+                i = identifier(func.tokenDef)
+                i['inlinefunc'] = func.isInlineKeyword
+                internal_identifiers.append(i)
+            else:
+                if func.token is None:
+                    i = identifier(func.tokenDef)
+                else:
+                    i = identifier(func.token)
+                i['decl'] = func.token is None
+                external_identifiers.append(i)
+
+        cppcheckdata.reportSummary(dumpfile, 'MisraExternalIdentifiers', external_identifiers)
+        cppcheckdata.reportSummary(dumpfile, 'MisraInternalIdentifiers', internal_identifiers)
+        cppcheckdata.reportSummary(dumpfile, 'MisraLocalIdentifiers', local_identifiers)
+
+    def _save_ctu_summary_usage(self, dumpfile, cfg):
+        if self._ctu_summary_usage:
+            return
+        self._ctu_summary_usage = True
+
+        names = []
+        for token in cfg.tokenlist:
+            if not token.isName:
+                continue
+            if token.function and token != token.function.tokenDef:
+                if (not token.function.isStatic) and (token.str not in names):
+                    names.append({'name': token.str, 'file': token.file})
+            elif token.variable:
+                if token == token.variable.nameToken:
+                    continue
+                if token.variable.access == 'Global' and (not token.variable.isStatic) and (token.str not in names):
+                    names.append({'name': token.str, 'file': token.file})
+
+        if len(names) > 0:
+            cppcheckdata.reportSummary(dumpfile, 'MisraUsage', names)
+
+
+    def misra_1_2(self, cfg):
+        # gcc language extensions: https://gcc.gnu.org/onlinedocs/gcc/C-Extensions.html
+        for token in cfg.tokenlist:
+            if simpleMatch(token, '? :'):
+                self.reportError(token, 1, 2)
+            elif simpleMatch(token, '( {') and simpleMatch(token.next.link.previous, '; } )'):
+                self.reportError(token, 1, 2)
+
+
+    def misra_1_4(self, cfg):
+        for token in cfg.tokenlist:
+            if token.str in ('_Atomic', '_Noreturn', '_Generic', '_Thread_local', '_Alignas', '_Alignof'):
+                self.reportError(token, 1, 4)
+            if token.str.endswith('_s') and isFunctionCall(token.next, cfg.standards.c):
+                # See C specification C11 - Annex K, page 578
+                if token.str in ('tmpfile_s', 'tmpnam_s', 'fopen_s', 'freopen_s', 'fprintf_s', 'fscanf_s', 'printf_s', 'scanf_s',
+                                 'snprintf_s', 'sprintf_s', 'sscanf_s', 'vfprintf_s', 'vfscanf_s', 'vprintf_s', 'vscanf_s',
+                                 'vsnprintf_s', 'vsprintf_s', 'vsscanf_s', 'gets_s', 'set_constraint_handler_s', 'abort_handler_s',
+                                 'ignore_handler_s', 'getenv_s', 'bsearch_s', 'qsort_s', 'wctomb_s', 'mbstowcs_s', 'wcstombs_s',
+                                 'memcpy_s', 'memmove_s', 'strcpy_s', 'strncpy_s', 'strcat_s', 'strncat_s', 'strtok_s', 'memset_s',
+                                 'strerror_s', 'strerrorlen_s', 'strnlen_s', 'asctime_s', 'ctime_s', 'gmtime_s', 'localtime_s',
+                                 'fwprintf_s', 'fwscanf_s', 'snwprintf_s', 'swprintf_s', 'swscanf_s', 'vfwprintf_s', 'vfwscanf_s',
+                                 'vsnwprintf_s', 'vswprintf_s', 'vswscanf_s', 'vwprintf_s', 'vwscanf_s', 'wprintf_s', 'wscanf_s',
+                                 'wcscpy_s', 'wcsncpy_s', 'wmemcpy_s', 'wmemmove_s', 'wcscat_s', 'wcsncat_s', 'wcstok_s', 'wcsnlen_s',
+                                 'wcrtomb_s', 'mbsrtowcs_s', 'wcsrtombs_s'):
+                    self.reportError(token, 1, 4)
+
+    def misra_2_2(self, cfg):
+        for token in cfg.tokenlist:
+            if token.isExpandedMacro:
+                continue
+            if (token.str in '+-') and token.astOperand2:
+                if simpleMatch(token.astOperand1, '0'):
+                    self.reportError(token.astOperand1, 2, 2)
+                elif simpleMatch(token.astOperand2, '0'):
+                    self.reportError(token.astOperand2, 2, 2)
+            if token.str == '*' and token.astOperand2:
+                if simpleMatch(token.astOperand2, '0'):
+                    self.reportError(token.astOperand1, 2, 2)
+                elif simpleMatch(token.astOperand1, '0'):
+                    self.reportError(token.astOperand2, 2, 2)
+                elif simpleMatch(token.astOperand1, '1'):
+                    self.reportError(token.astOperand1, 2, 2)
+                elif simpleMatch(token.astOperand2, '1'):
+                    self.reportError(token.astOperand2, 2, 2)
+
+    def misra_2_3(self, dumpfile, typedefInfo):
+        self._save_ctu_summary_typedefs(dumpfile, typedefInfo)
+
+    def misra_2_4(self, dumpfile, cfg):
+        self._save_ctu_summary_tagnames(dumpfile, cfg)
+
+    def misra_2_5(self, dumpfile, cfg):
+        used_macros = []
+        unused_macro = {}
+        for m in cfg.macro_usage:
+            used_macros.append(m.name)
+        for directive in cfg.directives:
+            res_define = re.match(r'#define[ \t]+([a-zA-Z_][a-zA-Z_0-9]*).*', directive.str)
+            res_undef = re.match(r'#undef[ \t]+([a-zA-Z_][a-zA-Z_0-9]*).*', directive.str)
+            if res_define:
+                macro_name = res_define.group(1)
+                unused_macro[macro_name] = {'name': macro_name, 'used': (macro_name in used_macros),
+                                            'file': directive.file, 'line': directive.linenr, 'column': directive.column}
+            elif res_undef:
+                macro_name = res_undef.group(1)
+                # assuming that if we have #undef, we also have #define somewhere
+                if macro_name in unused_macro:
+                    unused_macro[macro_name]['used'] = True
+                else:
+                    unused_macro[macro_name] = {'name': macro_name, 'used': True, 'file': directive.file,
+                                                'line': directive.linenr, 'column': directive.column}
+                    used_macros.append(macro_name)
+
+        if unused_macro:
+            cppcheckdata.reportSummary(dumpfile, 'MisraMacro', list(unused_macro.values()))
+
+    def misra_2_7(self, data):
+        for func in data.functions:
+            # Skip function with no parameter
+            if len(func.argument) == 0:
+                continue
+            # Setup list of function parameters
+            func_param_list = []
+            for arg in func.argument:
+                func_arg = func.argument[arg]
+                if func_arg.typeStartToken and func_arg.typeStartToken.str == '...':
+                    continue
+                func_param_list.append(func_arg)
+            # Search for scope of current function
+            for scope in data.scopes:
+                if (scope.type == "Function") and (scope.function == func):
+                    # Search function body: remove referenced function parameter from list
+                    token = scope.bodyStart
+                    while token.next is not None and token != scope.bodyEnd and len(func_param_list) > 0:
+                        if token.variable is not None and token.variable in func_param_list:
+                            func_param_list.remove(token.variable)
+                        token = token.next
+                    # Emit a warning for each unused variable, but no more that one warning per line
+                    reported_linenrs = set()
+                    for func_param in func_param_list:
+                        if func_param.nameToken:
+                            linenr = func_param.nameToken
+                            if linenr not in reported_linenrs:
+                                self.reportError(func_param.nameToken, 2, 7)
+                                reported_linenrs.add(linenr)
+                        else:
+                            linenr = func.tokenDef.linenr
+                            if linenr not in reported_linenrs:
+                                self.reportError(func.tokenDef, 2, 7)
+                                reported_linenrs.add(linenr)
 
     def misra_3_1(self, rawTokens):
         for token in rawTokens:
-            if token.str.startswith('/*') or token.str.startswith('//'):
-                s = token.str.lstrip('/')
-                if '//' in s or '/*' in s:
-                    self.reportError(token, 3, 1)
-
+            starts_with_double_slash = token.str.startswith('//')
+            starts_with_block_comment = token.str.startswith("/*")
+            s = token.str.lstrip('/')
+            if (starts_with_double_slash or starts_with_block_comment) and "/*" in s:
+                # Block comment inside of regular comment, violation
+                self.reportError(token, 3, 1)
+            elif starts_with_block_comment and "//" in s:
+                # "//" in block comment, check if it's a uri
+                while "//" in s:
+                    possible_uri, s = s.split("//", 1)
+                    if not re.search(r"\w+:$", possible_uri):
+                        # Violation if no uri was found
+                        self.reportError(token, 3, 1)
+                        break
 
     def misra_4_1(self, rawTokens):
         for token in rawTokens:
@@ -770,22 +1846,32 @@ def misra_4_1(self, rawTokens):
             # terminated.
             for sequence in ['\\' + t for t in symbols.split('\\')][1:]:
                 if (isHexEscapeSequence(sequence) or isOctalEscapeSequence(sequence) or
-                    isSimpleEscapeSequence(sequence)):
+                        isSimpleEscapeSequence(sequence)):
                     continue
-                else:
-                    self.reportError(token, 4, 1)
+                self.reportError(token, 4, 1)
 
+    def misra_4_2(self, rawTokens):
+        for token in rawTokens:
+            if (token.str[0] != '"') or (token.str[-1] != '"'):
+                continue
+            # Check for trigraph sequence as defined by ISO/IEC 9899:1999
+            for sequence in ['??=', '??(', '??/', '??)', '??\'', '??<', '??!', '??>', '??-']:
+                if sequence in token.str[1:-1]:
+                    # First trigraph sequence match, report error and leave loop.
+                    self.reportError(token, 4, 2)
+                    break
 
     def misra_5_1(self, data):
         long_vars = {}
+        num_sign_chars = self.get_num_significant_naming_chars(data)
         for var in data.variables:
             if var.nameToken is None:
                 continue
-            if len(var.nameToken.str) <= 31:
+            if len(var.nameToken.str) <= num_sign_chars:
                 continue
             if not hasExternalLinkage(var):
                 continue
-            long_vars.setdefault(var.nameToken.str[:31], []).append(var.nameToken)
+            long_vars.setdefault(var.nameToken.str[:num_sign_chars], []).append(var.nameToken)
         for name_prefix in long_vars:
             tokens = long_vars[name_prefix]
             if len(tokens) < 2:
@@ -795,10 +1881,11 @@ def misra_5_1(self, data):
 
     def misra_5_2(self, data):
         scopeVars = {}
+        num_sign_chars = self.get_num_significant_naming_chars(data)
         for var in data.variables:
             if var.nameToken is None:
                 continue
-            if len(var.nameToken.str) <= 31:
+            if len(var.nameToken.str) <= num_sign_chars:
                 continue
             if var.nameToken.scope not in scopeVars:
                 scopeVars.setdefault(var.nameToken.scope, {})["varlist"] = []
@@ -819,14 +1906,14 @@ def misra_5_2(self, data):
                         continue
                     if hasExternalLinkage(variable1) or hasExternalLinkage(variable2):
                         continue
-                    if (variable1.nameToken.str[:31] == variable2.nameToken.str[:31] and
-                            variable1.Id != variable2.Id):
+                    if (variable1.nameToken.str[:num_sign_chars] == variable2.nameToken.str[:num_sign_chars] and
+                            variable1 is not variable2):
                         if int(variable1.nameToken.linenr) > int(variable2.nameToken.linenr):
                             self.reportError(variable1.nameToken, 5, 2)
                         else:
                             self.reportError(variable2.nameToken, 5, 2)
                 for innerscope in scopeVars[scope]["scopelist"]:
-                    if variable1.nameToken.str[:31] == innerscope.className[:31]:
+                    if variable1.nameToken.str[:num_sign_chars] == innerscope.className[:num_sign_chars]:
                         if int(variable1.nameToken.linenr) > int(innerscope.bodyStart.linenr):
                             self.reportError(variable1.nameToken, 5, 2)
                         else:
@@ -835,126 +1922,129 @@ def misra_5_2(self, data):
                 continue
             for i, scopename1 in enumerate(scopeVars[scope]["scopelist"]):
                 for scopename2 in scopeVars[scope]["scopelist"][i + 1:]:
-                    if scopename1.className[:31] == scopename2.className[:31]:
+                    if scopename1.className[:num_sign_chars] == scopename2.className[:num_sign_chars]:
                         if int(scopename1.bodyStart.linenr) > int(scopename2.bodyStart.linenr):
                             self.reportError(scopename1.bodyStart, 5, 2)
                         else:
                             self.reportError(scopename2.bodyStart, 5, 2)
 
-
-    def misra_5_3(self, data):
-        num_sign_chars = self.get_num_significant_naming_chars(data)
-        enum = []
-        scopeVars = {}
-        for var in data.variables:
-            if var.nameToken is not None:
-                if var.nameToken.scope not in scopeVars:
-                    scopeVars[var.nameToken.scope] = []
-                scopeVars[var.nameToken.scope].append(var)
-        for innerScope in data.scopes:
-            if innerScope.type == "Enum":
-                enum_token = innerScope.bodyStart.next
-                while enum_token != innerScope.bodyEnd:
-                    if enum_token.values and enum_token.isName:
-                        enum.append(enum_token.str)
-                    enum_token = enum_token.next
-                continue
-            if innerScope not in scopeVars:
-                continue
-            if innerScope.type == "Global":
-                continue
-            for innerVar in scopeVars[innerScope]:
-                outerScope = innerScope.nestedIn
-                while outerScope:
-                    if outerScope not in scopeVars:
-                        outerScope = outerScope.nestedIn
-                        continue
-                    for outerVar in scopeVars[outerScope]:
-                        if innerVar.nameToken.str[:num_sign_chars] == outerVar.nameToken.str[:num_sign_chars]:
-                            if outerVar.isArgument and outerScope.type == "Global" and not innerVar.isArgument:
-                                continue
-                            if int(innerVar.nameToken.linenr) > int(outerVar.nameToken.linenr):
-                                self.reportError(innerVar.nameToken, 5, 3)
-                            else:
-                                self.reportError(outerVar.nameToken, 5, 3)
-                    outerScope = outerScope.nestedIn
-                for scope in data.scopes:
-                    if scope.className and innerVar.nameToken.str[:num_sign_chars] == scope.className[:num_sign_chars]:
-                        if int(innerVar.nameToken.linenr) > int(scope.bodyStart.linenr):
-                            self.reportError(innerVar.nameToken, 5, 3)
-                        else:
-                            self.reportError(scope.bodyStart, 5, 3)
-
-                for e in enum:
-                    for scope in data.scopes:
-                        if scope.className and innerVar.nameToken.str[:num_sign_chars] == e[:num_sign_chars]:
-                            if int(innerVar.nameToken.linenr) > int(innerScope.bodyStart.linenr):
-                                self.reportError(innerVar.nameToken, 5, 3)
-                            else:
-                                self.reportError(innerScope.bodyStart, 5, 3)
-        for e in enum:
-            for scope in data.scopes:
-                if scope.className and scope.className[:num_sign_chars] == e[:num_sign_chars]:
-                    self.reportError(scope.bodyStart, 5, 3)
-
-
     def misra_5_4(self, data):
         num_sign_chars = self.get_num_significant_naming_chars(data)
         macro = {}
         compile_name = re.compile(r'#define ([a-zA-Z0-9_]+)')
         compile_param = re.compile(r'#define ([a-zA-Z0-9_]+)[(]([a-zA-Z0-9_, ]+)[)]')
+        short_names = {}
+        macro_w_arg = []
         for dir in data.directives:
             res1 = compile_name.match(dir.str)
             if res1:
                 if dir not in macro:
                     macro.setdefault(dir, {})["name"] = []
                     macro.setdefault(dir, {})["params"] = []
-                macro[dir]["name"] = res1.group(1)
+                full_name = res1.group(1)
+                macro[dir]["name"] = full_name
+                short_name = full_name[:num_sign_chars]
+                if short_name in short_names:
+                    _dir = short_names[short_name]
+                    if full_name != macro[_dir]["name"]:
+                        self.reportError(dir, 5, 4)
+                else:
+                    short_names[short_name] = dir
             res2 = compile_param.match(dir.str)
             if res2:
                 res_gp2 = res2.group(2).split(",")
                 res_gp2 = [macroname.replace(" ", "") for macroname in res_gp2]
                 macro[dir]["params"].extend(res_gp2)
-        for mvar in macro:
-            if len(macro[mvar]["params"]) > 0:
-                for i, macroparam1 in enumerate(macro[mvar]["params"]):
-                    for j, macroparam2 in enumerate(macro[mvar]["params"]):
-                        if j > i and macroparam1[:num_sign_chars] == macroparam2[:num_sign_chars]:
-                            self.reportError(mvar, 5, 4)
-
-        for x, m_var1 in enumerate(macro):
-            for y, m_var2 in enumerate(macro):
-                if x < y and macro[m_var1]["name"] != macro[m_var2]["name"] and \
-                    macro[m_var1]["name"][:num_sign_chars] == macro[m_var2]["name"][:num_sign_chars]:
-                    if m_var1.linenr > m_var2.linenr:
+                macro_w_arg.append(dir)
+        for mvar in macro_w_arg:
+            for i, macroparam1 in enumerate(macro[mvar]["params"]):
+                for j, macroparam2 in enumerate(macro[mvar]["params"]):
+                    if j > i and macroparam1[:num_sign_chars] == macroparam2[:num_sign_chars]:
+                        self.reportError(mvar, 5, 4)
+                param = macroparam1
+                if param[:num_sign_chars] in short_names:
+                    m_var1 = short_names[param[:num_sign_chars]]
+                    if m_var1.linenr > mvar.linenr:
                         self.reportError(m_var1, 5, 4)
                     else:
-                        self.reportError(m_var2, 5, 4)
-                for param in macro[m_var2]["params"]:
-                    if macro[m_var1]["name"][:num_sign_chars] == param[:num_sign_chars]:
-                        if m_var1.linenr > m_var2.linenr:
-                            self.reportError(m_var1, 5, 4)
-                        else:
-                            self.reportError(m_var2, 5, 4)
-
+                        self.reportError(mvar, 5, 4)
 
     def misra_5_5(self, data):
         num_sign_chars = self.get_num_significant_naming_chars(data)
-        macroNames = []
+        macroNames = {}
         compiled = re.compile(r'#define ([A-Za-z0-9_]+)')
         for dir in data.directives:
             res = compiled.match(dir.str)
             if res:
-                macroNames.append(res.group(1))
+                macroNames[res.group(1)[:num_sign_chars]] = dir
         for var in data.variables:
-            for macro in macroNames:
-                if var.nameToken is not None:
-                    if var.nameToken.str[:num_sign_chars] == macro[:num_sign_chars]:
-                        self.reportError(var.nameToken, 5, 5)
+            if var.nameToken and var.nameToken.str[:num_sign_chars] in macroNames:
+                self.reportError(var.nameToken, 5, 5)
         for scope in data.scopes:
-            for macro in macroNames:
-                if scope.className and scope.className[:num_sign_chars] == macro[:num_sign_chars]:
-                    self.reportError(scope.bodyStart, 5, 5)
+            if scope.className and scope.className[:num_sign_chars] in macroNames:
+                self.reportError(scope.bodyStart, 5, 5)
+
+
+    def misra_5_6(self, dumpfile, typedefInfo):
+        self._save_ctu_summary_typedefs(dumpfile, typedefInfo)
+
+    def misra_5_7(self, dumpfile, cfg):
+        self._save_ctu_summary_tagnames(dumpfile, cfg)
+
+    def misra_5_8(self, dumpfile, cfg):
+        self._save_ctu_summary_identifiers(dumpfile, cfg)
+
+    def misra_5_9(self, dumpfile, cfg):
+        self._save_ctu_summary_identifiers(dumpfile, cfg)
+
+    def misra_6_1(self, data):
+        # Bitfield type must be bool or explicitly signed/unsigned int
+        for token in data.tokenlist:
+            if not token.valueType:
+                continue
+            if token.valueType.bits is None:
+                continue
+            if not token.variable:
+                continue
+            if not token.scope:
+                continue
+            if token.scope.type not in 'Struct':
+                continue
+
+            if data.standards.c == 'c89':
+                if token.valueType.type != 'int' and  not isUnsignedType(token.variable.typeStartToken.str):
+                    self.reportError(token, 6, 1)
+            elif data.standards.c in ('c99', 'c11', 'c17', 'c18'):
+                if token.valueType.type == 'bool':
+                    continue
+
+            isExplicitlySignedOrUnsigned = False
+            typeToken = token.variable.typeStartToken
+            while typeToken:
+                if typeToken.isUnsigned or typeToken.isSigned or isUnsignedType(typeToken.str):
+                    isExplicitlySignedOrUnsigned = True
+                    break
+
+                if typeToken is token.variable.typeEndToken:
+                    break
+
+                typeToken = typeToken.next
+
+            if not isExplicitlySignedOrUnsigned:
+                self.reportError(token, 6, 1)
+
+
+    def misra_6_2(self, data):
+        # Bitfields of size 1 can not be signed
+        for token in data.tokenlist:
+            if not token.valueType:
+                continue
+            if not token.scope:
+                continue
+            if token.scope.type not in 'Struct':
+                continue
+            if token.valueType.bits == 1 and token.valueType.sign == 'signed':
+                self.reportError(token, 6, 2)
 
 
     def misra_7_1(self, rawTokens):
@@ -963,20 +2053,303 @@ def misra_7_1(self, rawTokens):
             if compiled.match(tok.str):
                 self.reportError(tok, 7, 1)
 
+    def misra_7_2(self, data):
+        for token in data.tokenlist:
+            if token.isInt and ('U' not in token.str.upper()) and token.valueType and token.valueType.sign == 'unsigned':
+                self.reportError(token, 7, 2)
 
     def misra_7_3(self, rawTokens):
-        compiled = re.compile(r'^[0-9.uU]+l')
+        # Match decimal digits, hex digits, decimal point, and e/E p/P floating
+        # point constant exponent separators.
+        compiled = re.compile(r'^(0[xX])?[0-9a-fA-FpP.]+[Uu]*l+[Uu]*$')
         for tok in rawTokens:
             if compiled.match(tok.str):
                 self.reportError(tok, 7, 3)
 
+    def misra_7_4(self, data):
+        # A string literal shall not be assigned to an object unless the object's type
+        # is constant.
+        def reportErrorIfVariableIsNotConst(variable, stringLiteral):
+            if variable.valueType:
+                if (variable.valueType.constness % 2) != 1:
+                    self.reportError(stringLiteral, 7, 4)
+
+        for token in data.tokenlist:
+            if token.isString:
+                # Check normal variable assignment
+                variable = getAssignedVariableToken(token)
+                if variable:
+                    reportErrorIfVariableIsNotConst(variable, token)
+
+                # Check use as return value
+                function = getFunctionUsingReturnValue(token)
+                if function:
+                    # "Primitive" test since there is no info available on return value type
+                    if not tokenFollowsSequence(function.tokenDef, ['const', 'char', '*']):
+                        self.reportError(token, 7, 4)
+
+            # Check use as function parameter
+            if isFunctionCall(token, data.standards.c) and token.astOperand1 and token.astOperand1.function:
+                functionDeclaration = token.astOperand1.function
+
+                if functionDeclaration.tokenDef:
+                    if functionDeclaration.tokenDef is token.astOperand1:
+                        # Token is not a function call, but it is the definition of the function
+                        continue
+
+                    parametersUsed = getArguments(token)
+                    for i in range(len(parametersUsed)):
+                        usedParameter = parametersUsed[i]
+                        parameterDefinition = functionDeclaration.argument.get(i+1)
+
+                        if usedParameter.isString and parameterDefinition and parameterDefinition.nameToken:
+                            reportErrorIfVariableIsNotConst(parameterDefinition.nameToken, usedParameter)
+
+    def misra_8_1(self, cfg):
+        for token in cfg.tokenlist:
+            if token.isImplicitInt and not token.isUnsigned and not token.isSigned:
+                self.reportError(token, 8, 1)
+
+    def misra_8_2(self, data, rawTokens):
+        def getFollowingRawTokens(rawTokens, token, count):
+            following =[]
+            for rawToken in rawTokens:
+                if (rawToken.file == token.file and
+                        rawToken.linenr == token.linenr and
+                        rawToken.column == token.column):
+                    for _ in range(count):
+                        rawToken = rawToken.next
+                        # Skip comments
+                        while rawToken and (rawToken.str.startswith('/*') or rawToken.str.startswith('//')):
+                            rawToken = rawToken.next
+                        if rawToken is None:
+                            break
+                        following.append(rawToken)
+            return following
+
+        # Zero arguments should be in form ( void )
+        def checkZeroArguments(func, startCall, endCall):
+            if not startCall.isRemovedVoidParameter and len(func.argument) == 0:
+                if func.tokenDef.next:
+                    self.reportError(func.tokenDef.next, 8, 2)
+                else:
+                    self.reportError(func.tokenDef, 8, 2)
+
+        def checkDeclarationArgumentsViolations(func, startCall, endCall):
+            # Collect the tokens for the arguments in function definition
+            argNameTokens = set()
+            for arg in func.argument:
+                argument = func.argument[arg]
+                typeStartToken = argument.typeStartToken
+                if typeStartToken is None:
+                    continue
+                nameToken = argument.nameToken
+                if nameToken is None:
+                    continue
+                argNameTokens.add(nameToken)
+
+            # Check if we have the same number of variables in both the
+            # declaration and the definition.
+            #
+            # TODO: We actually need to check if the names of the arguments are
+            # the same. But we can't do this because we have no links to
+            # variables in the arguments in function definition in the dump file.
+            foundVariables = 0
+            while startCall and startCall != endCall:
+                if startCall.varId:
+                    foundVariables += 1
+                startCall = startCall.next
+
+            if len(argNameTokens) != foundVariables:
+                if func.tokenDef.next:
+                    self.reportError(func.tokenDef.next, 8, 2)
+                else:
+                    self.reportError(func.tokenDef, 8, 2)
+
+        def checkDefinitionArgumentsViolations(func, startCall, endCall):
+            for arg in func.argument:
+                argument = func.argument[arg]
+                typeStartToken = argument.typeStartToken
+                if typeStartToken is None:
+                    continue
+
+                # Arguments should have a name unless variable length arg
+                nameToken = argument.nameToken
+                if nameToken is None and typeStartToken.str != '...':
+                    self.reportError(typeStartToken, 8, 2)
+
+                # Type declaration on next line (old style declaration list) is not allowed
+                if typeStartToken.linenr > endCall.linenr:
+                    self.reportError(typeStartToken, 8, 2)
+
+        # Check arguments in function declaration
+        for func in data.functions:
+
+            # Check arguments in function definition
+            tokenImpl = func.token
+            if tokenImpl:
+                startCall = tokenImpl.next
+                if startCall is None or startCall.str != '(':
+                    continue
+                endCall = startCall.link
+                if endCall is None or endCall.str != ')':
+                    continue
+                checkZeroArguments(func, startCall, endCall)
+                checkDefinitionArgumentsViolations(func, startCall, endCall)
+
+            # Check arguments in function declaration
+            tokenDef = func.tokenDef
+            if tokenDef:
+                startCall = func.tokenDef.next
+                if startCall is None or startCall.str != '(':
+                    continue
+                endCall = startCall.link
+                if endCall is None or endCall.str != ')':
+                    continue
+                checkZeroArguments(func, startCall, endCall)
+                if tokenImpl:
+                    checkDeclarationArgumentsViolations(func, startCall, endCall)
+                else:
+                    # When there is no function definition, we should execute
+                    # its checks for the declaration token. The point is that without
+                    # a known definition we have no Function.argument list required
+                    # for declaration check.
+                    checkDefinitionArgumentsViolations(func, startCall, endCall)
+
+        # Check arguments in pointer declarations
+        for var in data.variables:
+            if not var.isPointer:
+                continue
+
+            if var.nameToken is None:
+                continue
+
+            rawTokensFollowingPtr = getFollowingRawTokens(rawTokens, var.nameToken, 3)
+            if len(rawTokensFollowingPtr) != 3:
+                continue
+
+            # Compliant:           returnType (*ptrName) ( ArgType )
+            # Non-compliant:       returnType (*ptrName) ( )
+            if (rawTokensFollowingPtr[0].str == ')' and
+                    rawTokensFollowingPtr[1].str == '(' and
+                    rawTokensFollowingPtr[2].str == ')'):
+                self.reportError(var.nameToken, 8, 2)
+
+    def insert_in_dict(self, dict_name,key, value):
+        if key not in dict_name:
+            dict_name[key] = []
+        dict_name[key].append(value)
+    def misra_8_4(self, cfg):
+        for func in cfg.functions:
+            if func.isStatic:
+                continue
+            if func.token is None:
+                continue
+            if not is_source_file(func.token.file):
+                continue
+            if func.token != func.tokenDef:
+                continue
+            if func.tokenDef.str == 'main':
+                continue
+            self.reportError(func.tokenDef, 8, 4)
+        extern_var_with_def = {}
+        extern_var_without_def = {}
+        for var in cfg.variables:
+            if not var.isGlobal:
+                continue
+            if var.isStatic:
+                continue
+            if var.nameToken is None:
+                continue
+            tok = var.nameToken
+            if tok.next.str == ";":
+                if tok.next.isSplittedVarDeclEq:
+                    self.insert_in_dict(extern_var_with_def, tok.str, tok)
+                else:
+                    self.insert_in_dict(extern_var_without_def, tok.str, tok)
+            else:
+                self.insert_in_dict(extern_var_without_def, var.nameToken.str, var.nameToken)
+
+        for var in extern_var_with_def:
+            if var not in extern_var_without_def:
+                for t in extern_var_with_def[var]:
+                    self.reportError(t, 8, 4)
+
+        for var_str, var_tok in extern_var_without_def.items():
+            warn = True
+            if var_str not in extern_var_with_def:
+                for t in var_tok:
+                    if t.variable.isExtern:
+                        warn = False
+                        break
+                if warn:
+                    for t in var_tok:
+                        self.reportError(t, 8, 4)
+
+    def misra_8_5(self, dumpfile, cfg):
+        self._save_ctu_summary_identifiers(dumpfile, cfg)
+
+    def misra_8_6(self, dumpfile, cfg):
+        self._save_ctu_summary_identifiers(dumpfile, cfg)
+
+    def misra_8_7(self, dumpfile, cfg):
+        self._save_ctu_summary_usage(dumpfile, cfg)
+
+    def misra_8_8(self, cfg):
+        vars = {}
+        for var in cfg.variables:
+            if var.access != 'Global':
+                continue
+            if var.nameToken is None:
+                continue
+            varname = var.nameToken.str
+            if varname in vars:
+                vars[varname].append(var)
+            else:
+                vars[varname] = [var]
+        for varname, varlist in vars.items():
+            static_var = None
+            extern_var = None
+            for var in varlist:
+                if var.isStatic:
+                    static_var = var
+                elif var.isExtern:
+                    extern_var = var
+            if static_var and extern_var:
+                self.reportError(extern_var.nameToken, 8, 8)
+
+    def misra_8_9(self, cfg):
+        variables = {}
+        for scope in cfg.scopes:
+            if scope.type != 'Function':
+                continue
+            variables_used_in_scope = []
+            tok = scope.bodyStart
+            while tok != scope.bodyEnd:
+                if tok.variable and tok.variable.access == 'Global' and tok.variable.isStatic:
+                    if tok.variable not in variables_used_in_scope:
+                        variables_used_in_scope.append(tok.variable)
+                tok = tok.next
+            for var in variables_used_in_scope:
+                if var in variables:
+                    variables[var] += 1
+                else:
+                    variables[var] = 1
+        for var, count in variables.items():
+            if count == 1:
+                self.reportError(var.nameToken, 8, 9)
+
+
+    def misra_8_10(self, cfg):
+        for func in cfg.functions:
+            if func.isInlineKeyword and not func.isStatic:
+                self.reportError(func.tokenDef, 8, 10)
 
     def misra_8_11(self, data):
         for var in data.variables:
             if var.isExtern and simpleMatch(var.nameToken.next, '[ ]') and var.nameToken.scope.type == 'Global':
                 self.reportError(var.nameToken, 8, 11)
 
-
     def misra_8_12(self, data):
         for scope in data.scopes:
             if scope.type != 'Enum':
@@ -988,7 +2361,7 @@ def misra_8_12(self, data):
                 if e_token.str == '(':
                     e_token = e_token.link
                     continue
-                if not e_token.previous.str in ',{':
+                if e_token.previous.str not in ',{':
                     e_token = e_token.next
                     continue
                 if e_token.isName and e_token.values and e_token.valueType and e_token.valueType.typeScope == scope:
@@ -1001,32 +2374,106 @@ def misra_8_12(self, data):
                 if enum_values.count(implicit_enum_value) != 1:
                     self.reportError(scope.bodyStart, 8, 12)
 
-
     def misra_8_14(self, rawTokens):
         for token in rawTokens:
             if token.str == 'restrict':
                 self.reportError(token, 8, 14)
 
+    def misra_9_2(self, data):
+        misra_9.misra_9_x(self, data, 902)
 
-    def misra_9_5(self, rawTokens):
-        for token in rawTokens:
-            if simpleMatch(token, '[ ] = { ['):
-                self.reportError(token, 9, 5)
+    def misra_9_3(self, data):
+        misra_9.misra_9_x(self, data, 903)
+
+    def misra_9_4(self, data):
+        misra_9.misra_9_x(self, data, 904)
 
+    def misra_9_5(self, data, rawTokens):
+        misra_9.misra_9_x(self, data, 905, rawTokens)
+        #for token in rawTokens:
+        #    if simpleMatch(token, '[ ] = { ['):
+        #        self.reportError(token, 9, 5)
 
     def misra_10_1(self, data):
         for token in data.tokenlist:
             if not token.isOp:
                 continue
-            e1 = getEssentialTypeCategory(token.astOperand1)
-            e2 = getEssentialTypeCategory(token.astOperand2)
-            if not e1 or not e2:
+
+            for t1, t2 in itertools.product(
+                    list(getTernaryOperandsRecursive(token.astOperand1) or [token.astOperand1]),
+                    list(getTernaryOperandsRecursive(token.astOperand2) or [token.astOperand2]),
+            ):
+                e1 = getEssentialTypeCategory(t1)
+                e2 = getEssentialTypeCategory(t2)
+                if not e1 or not e2:
+                    continue
+                if token.str in ('<<', '>>'):
+                    if not isUnsignedType(e1):
+                        self.reportError(token, 10, 1)
+                    elif not isUnsignedType(e2) and not token.astOperand2.isNumber:
+                        self.reportError(token, 10, 1)
+                elif token.str in ('~', '&', '|', '^'):
+                    e1_et = getEssentialType(token.astOperand1)
+                    e2_et = getEssentialType(token.astOperand2)
+                    if e1_et == 'char' or e2_et == 'char':
+                        self.reportError(token, 10, 1)
+
+    def misra_10_2(self, data):
+        def isEssentiallySignedOrUnsigned(op):
+            e = getEssentialType(op)
+            return e and (e.split(' ')[0] in ('unsigned', 'signed'))
+
+        def isEssentiallyChar(op):
+            if op is None:
+                return False
+            if op.str == '+':
+                return isEssentiallyChar(op.astOperand1) or isEssentiallyChar(op.astOperand2)
+            return op.isChar
+
+        for token in data.tokenlist:
+            if token.str not in ('+', '-'):
+                continue
+
+            if (not isEssentiallyChar(token.astOperand1)) and (not isEssentiallyChar(token.astOperand2)):
                 continue
-            if token.str in ['<<', '>>']:
-                if e1 != 'unsigned':
-                    self.reportError(token, 10, 1)
-                elif e2 != 'unsigned' and not token.astOperand2.isNumber:
-                    self.reportError(token, 10, 1)
+
+            if token.str == '+':
+                if isEssentiallyChar(token.astOperand1) and not isEssentiallySignedOrUnsigned(token.astOperand2):
+                    self.reportError(token, 10, 2)
+                if isEssentiallyChar(token.astOperand2) and not isEssentiallySignedOrUnsigned(token.astOperand1):
+                    self.reportError(token, 10, 2)
+
+            if token.str == '-':
+                e1 = getEssentialType(token.astOperand1)
+                if e1 and e1.split(' ')[-1] != 'char':
+                    self.reportError(token, 10, 2)
+                if not isEssentiallyChar(token.astOperand2) and not isEssentiallySignedOrUnsigned(token.astOperand2):
+                    self.reportError(token, 10, 2)
+
+    def misra_10_3(self, cfg):
+        def get_category(essential_type):
+            if essential_type:
+                if essential_type in ('bool', 'char'):
+                    return essential_type
+                if essential_type.split(' ')[-1] in ('float', 'double'):
+                    return 'floating'
+                if essential_type.split(' ')[0] in ('unsigned', 'signed'):
+                    return essential_type.split(' ')[0]
+            return None
+        for tok in cfg.tokenlist:
+            if tok.isAssignmentOp:
+                lhs = getEssentialType(tok.astOperand1)
+                rhs = getEssentialType(tok.astOperand2)
+                #print(lhs)
+                #print(rhs)
+                if lhs is None or rhs is None:
+                    continue
+                lhs_category = get_category(lhs)
+                rhs_category = get_category(rhs)
+                if lhs_category and rhs_category and lhs_category != rhs_category and rhs_category not in ('signed','unsigned'):
+                    self.reportError(tok, 10, 3)
+                if bitsOfEssentialType(lhs) < bitsOfEssentialType(rhs) and (lhs != "bool" or tok.astOperand2.str not in ('0','1')):
+                    self.reportError(tok, 10, 3)
 
     def misra_10_4(self, data):
         op = {'+', '-', '*', '/', '%', '&', '|', '^', '+=', '-=', ':'}
@@ -1038,7 +2485,7 @@ def misra_10_4(self, data):
             if not token.astOperand1.valueType or not token.astOperand2.valueType:
                 continue
             if ((token.astOperand1.str in op or token.astOperand1.isComparisonOp) and
-                    (token.astOperand2.str in op or token.astOperand1.isComparisonOp)):
+                (token.astOperand2.str in op or token.astOperand2.isComparisonOp)):
                 e1, e2 = getEssentialCategorylist(token.astOperand1.astOperand2, token.astOperand2.astOperand1)
             elif token.astOperand1.str in op or token.astOperand1.isComparisonOp:
                 e1, e2 = getEssentialCategorylist(token.astOperand1.astOperand2, token.astOperand2)
@@ -1061,13 +2508,52 @@ def misra_10_4(self, data):
             if e1 and e2 and e1 != e2:
                 self.reportError(token, 10, 4)
 
+    def misra_10_5(self, cfg):
+        def _get_essential_category(token):
+            essential_type = getEssentialType(token)
+            #print(essential_type)
+            if essential_type:
+                if essential_type in ('bool', 'char'):
+                    return essential_type
+                if essential_type.split(' ')[-1] in ('float', 'double'):
+                    return 'floating'
+                if essential_type.split(' ')[0] in ('unsigned', 'signed'):
+                    return essential_type.split(' ')[0]
+            return None
+        for token in cfg.tokenlist:
+            if not isCast(token):
+                continue
+            to_type = _get_essential_category(token)
+            #print(to_type)
+            if to_type is None:
+                continue
+            from_type = _get_essential_category(token.astOperand1)
+            #print(from_type)
+            if from_type is None:
+                continue
+            if to_type == from_type:
+                continue
+            if to_type == 'bool' or from_type == 'bool':
+                if token.astOperand1.isInt and token.astOperand1.getKnownIntValue() == 1:
+                    # Exception
+                    continue
+                self.reportError(token, 10, 5)
+                continue
+            if to_type == 'enum':
+                self.reportError(token, 10, 5)
+                continue
+            if from_type == 'float' and to_type == 'char':
+                self.reportError(token, 10, 5)
+                continue
+            if from_type == 'char' and to_type == 'float':
+                self.reportError(token, 10, 5)
+                continue
 
     def misra_10_6(self, data):
         for token in data.tokenlist:
             if token.str != '=' or not token.astOperand1 or not token.astOperand2:
                 continue
-            if (token.astOperand2.str not in ('+', '-', '*', '/', '%', '&', '|', '^', '>>', "<<", "?", ":", '~') and
-                    not isCast(token.astOperand2)):
+            if not is_composite_expr(token.astOperand2):
                 continue
             vt1 = token.astOperand1.valueType
             vt2 = token.astOperand2.valueType
@@ -1076,20 +2562,49 @@ def misra_10_6(self, data):
             if not vt2 or vt2.pointer > 0:
                 continue
             try:
-                intTypes = ['char', 'short', 'int', 'long', 'long long']
-                index1 = intTypes.index(vt1.type)
                 if isCast(token.astOperand2):
                     e = vt2.type
                 else:
                     e = getEssentialType(token.astOperand2)
                 if not e:
                     continue
-                index2 = intTypes.index(e)
-                if index1 > index2:
+                if e == "char" and vt1.type == "int":
+                    # When arithmetic operations are performed on char values, they are usually promoted to int
+                    continue
+                lhsbits = vt1.bits if vt1.bits else bitsOfEssentialType(vt1.type)
+                if lhsbits > bitsOfEssentialType(e):
                     self.reportError(token, 10, 6)
             except ValueError:
                 pass
 
+    def misra_10_7(self, cfg):
+        for token in cfg.tokenlist:
+            if token.astOperand1 is None or token.astOperand2 is None:
+                continue
+            if not token.isArithmeticalOp:
+                continue
+            if not is_composite_expr(token):
+                continue
+            parent = token.astParent
+            if parent is None:
+                continue
+            if not parent.isArithmeticalOp:
+                if not parent.isAssignmentOp:
+                    continue
+                if parent.str == '=':
+                    continue
+            token_type = getEssentialType(token)
+            if token_type is None:
+                continue
+            sibling = parent.astOperand1 if (token == parent.astOperand2) else parent.astOperand2
+            sibling_type = getEssentialType(sibling)
+            if sibling_type is None:
+                continue
+            b1 = bitsOfEssentialType(token_type)
+            b2 = bitsOfEssentialType(sibling_type)
+            if b1 > 0 and b1 < b2:
+                self.reportError(token, 10, 7)
+
     def misra_10_8(self, data):
         for token in data.tokenlist:
             if not isCast(token):
@@ -1115,17 +2630,56 @@ def misra_10_8(self, data):
                 self.reportError(token, 10, 8)
             else:
                 try:
-                    intTypes = ['char', 'short', 'int', 'long', 'long long']
-                    index1 = intTypes.index(token.valueType.type)
                     e = getEssentialType(token.astOperand1)
                     if not e:
                         continue
-                    index2 = intTypes.index(e)
-                    if index1 > index2:
+                    if bitsOfEssentialType(token.valueType.type) > bitsOfEssentialType(e):
                         self.reportError(token, 10, 8)
                 except ValueError:
                     pass
 
+    def misra_11_1(self, data):
+        for token in data.tokenlist:
+            to_from = get_type_conversion_to_from(token)
+            if to_from is None:
+                continue
+            from_type = get_function_pointer_type(to_from[1])
+            if from_type is None:
+                continue
+            to_type = get_function_pointer_type(to_from[0])
+            if to_type is None or to_type != from_type:
+                self.reportError(token, 11, 1)
+
+    def misra_11_2(self, data):
+        def get_pointer_type(type_token):
+            while type_token and (type_token.str in ('const', 'struct')):
+                type_token = type_token.next
+            if type_token is None:
+                return None
+            if not type_token.isName:
+                return None
+            return type_token if (type_token.next and type_token.next.str == '*') else None
+
+        incomplete_types = []
+
+        for token in data.tokenlist:
+            if token.str == 'struct' and token.next and token.next.next and token.next.isName and token.next.next.str == ';':
+                incomplete_types.append(token.next.str)
+            to_from = get_type_conversion_to_from(token)
+            if to_from is None:
+                continue
+            to_pointer_type_token = get_pointer_type(to_from[0])
+            if to_pointer_type_token is None:
+                continue
+            from_pointer_type_token = get_pointer_type(to_from[1])
+            if from_pointer_type_token is None:
+                continue
+            if to_pointer_type_token.str == from_pointer_type_token.str:
+                continue
+            if from_pointer_type_token.typeScope is None and (from_pointer_type_token.str in incomplete_types):
+                self.reportError(token, 11, 2)
+            elif to_pointer_type_token.typeScope is None and (to_pointer_type_token.str in incomplete_types):
+                self.reportError(token, 11, 2)
 
     def misra_11_3(self, data):
         for token in data.tokenlist:
@@ -1138,15 +2692,28 @@ def misra_11_3(self, data):
             if vt1.type == 'void' or vt2.type == 'void':
                 continue
             if (vt1.pointer > 0 and vt1.type == 'record' and
-                vt2.pointer > 0 and vt2.type == 'record' and
+                    vt2.pointer > 0 and vt2.type == 'record' and
                     vt1.typeScopeId != vt2.typeScopeId):
                 self.reportError(token, 11, 3)
             elif (vt1.pointer == vt2.pointer and vt1.pointer > 0 and
-                    vt1.type != vt2.type and vt1.type != 'char'):
+                  vt1.type != vt2.type and vt1.type != 'char'):
                 self.reportError(token, 11, 3)
 
-
     def misra_11_4(self, data):
+        # Get list of macro definitions
+        macros = {}
+        for directive in data.directives:
+            #define X ((peripheral_t *)0x40000U)
+            res = re.match(r'#define ([A-Za-z0-9_]+).*', directive.str)
+            if res:
+                if res.group(1) in macros:
+                    macros[res.group(1)].append(directive)
+                else:
+                    macros[res.group(1)] = [directive]
+
+        # If macro definition is non-compliant then warn about the macro definition instead of
+        # the macro usages. To reduce diagnostics for a non-compliant macro.
+        bad_macros = []
         for token in data.tokenlist:
             if not isCast(token):
                 continue
@@ -1156,10 +2723,20 @@ def misra_11_4(self, data):
                 continue
             if vt2.pointer > 0 and vt1.pointer == 0 and (vt1.isIntegral() or vt1.isEnum()) and vt2.type != 'void':
                 self.reportError(token, 11, 4)
-            elif vt1.pointer > 0 and vt2.pointer == 0 and (vt2.isIntegral() or vt2.isEnum())and vt1.type != 'void':
+            elif vt1.pointer > 0 and vt2.pointer == 0 and (vt2.isIntegral() or vt2.isEnum()) and vt1.type != 'void':
+                if token.macroName is not None and \
+                   token.macroName == token.astOperand1.macroName and \
+                   token.astOperand1.isInt and \
+                   token.link.previous.str == '*' and \
+                   token.macroName == token.link.previous.macroName and \
+                   token.macroName in macros and \
+                   len(macros[token.macroName]) == 1:
+                    if token.macroName not in bad_macros:
+                        bad_macros.append(token.macroName)
+                        self.reportError(macros[token.macroName][0], 11, 4)
+                    continue
                 self.reportError(token, 11, 4)
 
-
     def misra_11_5(self, data):
         for token in data.tokenlist:
             if not isCast(token):
@@ -1171,7 +2748,8 @@ def misra_11_5(self, data):
                     if vt1.pointer > 0 and vt1.type != 'void' and vt2.pointer == vt1.pointer and vt2.type == 'void':
                         self.reportError(token, 11, 5)
                 continue
-            if token.astOperand1.astOperand1 and token.astOperand1.astOperand1.str in ('malloc', 'calloc', 'realloc', 'free'):
+            if token.astOperand1.astOperand1 and token.astOperand1.astOperand1.str in (
+            'malloc', 'calloc', 'realloc', 'free'):
                 continue
             vt1 = token.valueType
             vt2 = token.astOperand1.valueType
@@ -1180,23 +2758,19 @@ def misra_11_5(self, data):
             if vt1.pointer > 0 and vt1.type != 'void' and vt2.pointer == vt1.pointer and vt2.type == 'void':
                 self.reportError(token, 11, 5)
 
-
     def misra_11_6(self, data):
         for token in data.tokenlist:
             if not isCast(token):
                 continue
-            if token.astOperand1.astOperand1:
-                continue
             vt1 = token.valueType
             vt2 = token.astOperand1.valueType
             if not vt1 or not vt2:
                 continue
-            if vt1.pointer == 1 and vt1.type == 'void' and vt2.pointer == 0 and token.astOperand1.str != "0":
+            if vt1.pointer == 1 and vt1.type == 'void' and vt2.pointer == 0 and token.astOperand1.getKnownIntValue() != 0:
                 self.reportError(token, 11, 6)
             elif vt1.pointer == 0 and vt1.type != 'void' and vt2.pointer == 1 and vt2.type == 'void':
                 self.reportError(token, 11, 6)
 
-
     def misra_11_7(self, data):
         for token in data.tokenlist:
             if not isCast(token):
@@ -1212,11 +2786,10 @@ def misra_11_7(self, data):
                     vt1.type != 'void'):
                 self.reportError(token, 11, 7)
             elif (vt1.pointer > 0 and vt2.pointer == 0 and
-                    not vt2.isIntegral() and not vt2.isEnum() and
-                    vt1.type != 'void'):
+                  not vt2.isIntegral() and not vt2.isEnum() and
+                  vt1.type != 'void'):
                 self.reportError(token, 11, 7)
 
-
     def misra_11_8(self, data):
         # TODO: reuse code in CERT-EXP05
         for token in data.tokenlist:
@@ -1254,7 +2827,6 @@ def misra_11_8(self, data):
                     if (const1 % 2) < (const2 % 2):
                         self.reportError(token, 11, 8)
 
-
     def misra_11_9(self, data):
         for token in data.tokenlist:
             if token.astOperand1 and token.astOperand2 and token.str in ["=", "==", "!=", "?", ":"]:
@@ -1266,9 +2838,8 @@ def misra_11_9(self, data):
                     continue
                 if (token.astOperand2.values and vt1.pointer > 0 and
                         vt2.pointer == 0 and token.astOperand2.values):
-                    for val in token.astOperand2.values:
-                        if val.intvalue == 0:
-                            self.reportError(token, 11, 9)
+                    if token.astOperand2.getValue(0):
+                        self.reportError(token, 11, 9)
 
     def misra_12_1_sizeof(self, rawTokens):
         state = 0
@@ -1289,7 +2860,6 @@ def misra_12_1_sizeof(self, rawTokens):
                 else:
                     state = 0
 
-
     def misra_12_1(self, data):
         for token in data.tokenlist:
             p = getPrecedence(token)
@@ -1304,7 +2874,6 @@ def misra_12_1(self, data):
                 self.reportError(token, 12, 1)
                 continue
 
-
     def misra_12_2(self, data):
         for token in data.tokenlist:
             if not (token.str in ('<<', '>>')):
@@ -1317,50 +2886,118 @@ def misra_12_2(self, data):
                     maxval = val.intvalue
             if maxval == 0:
                 continue
-            sz = bitsOfEssentialType(token.astOperand1)
+            sz = bitsOfEssentialType(getEssentialType(token.astOperand1))
             if sz <= 0:
                 continue
             if maxval >= sz:
                 self.reportError(token, 12, 2)
 
-
     def misra_12_3(self, data):
         for token in data.tokenlist:
-            if token.str != ',' or token.scope.type == 'Enum' or \
-            token.scope.type == 'Class' or token.scope.type == 'Global':
-                continue
-            if token.astParent and token.astParent.str in ['(', ',', '{']:
-                continue
-            self.reportError(token, 12, 3)
-
+            if token.str == ';' and (token.isSplittedVarDeclComma is True):
+                self.reportError(token, 12, 3)
+            if token.str == ',' and token.astParent and token.astParent.str == ';':
+                self.reportError(token, 12, 3)
+            if token.str == ',' and token.astParent is None:
+                if token.scope.type in ('Class', 'Struct'):
+                    # Is this initlist..
+                    tok = token
+                    while tok and tok.str == ',':
+                        tok = tok.next
+                        if tok and tok.next and tok.isName and tok.next.str == '(':
+                            tok = tok.next.link.next
+                    if tok.str == '{':
+                        # This comma is used in initlist, do not warn
+                        continue
+                prev = token.previous
+                while prev:
+                    if prev.str == ';':
+                        self.reportError(token, 12, 3)
+                        break
+                    if prev.str in '({[':
+                        break
+                    if prev.str in ')}]':
+                        prev = prev.link
+                    prev = prev.previous
 
-    def misra_12_4(self, data):
-        if typeBits['INT'] == 16:
-            max_uint = 0xffff
-        elif typeBits['INT'] == 32:
-            max_uint = 0xffffffff
-        else:
+    def misra_12_4_check_expr(self, expr):
+        if not expr.astOperand2 or not expr.astOperand1:
             return
-
-        for token in data.tokenlist:
-            if (not isConstantExpression(token)) or (not isUnsignedInt(token)):
-                continue
-            if not token.values:
-                continue
-            for value in token.values:
-                if value.intvalue < 0 or value.intvalue > max_uint:
-                    self.reportError(token, 12, 4)
-                    break
+        if expr.valueType is None:
+            return
+        if expr.valueType.sign is None or expr.valueType.sign != 'unsigned':
+            return
+        if expr.valueType.pointer > 0:
+            return
+        if not expr.valueType.isIntegral():
+            return
+        op1 = expr.astOperand1.getKnownIntValue()
+        if op1 is None:
+            return
+        op2 = expr.astOperand2.getKnownIntValue()
+        if op2 is None:
+            return
+        bits = bitsOfEssentialType('unsigned ' + expr.valueType.type)
+        if bits <= 0 or bits >= 64:
+            return
+        max_value = (1 << bits) - 1
+        if not is_constant_integer_expression(expr):
+            return
+        if expr.str == '+' and op1 + op2 > max_value:
+            self.reportError(expr, 12, 4)
+        elif expr.str == '-' and op1 - op2 < 0:
+            self.reportError(expr, 12, 4)
+        elif expr.str == '*' and op1 * op2 > max_value:
+            self.reportError(expr, 12, 4)
+    def misra_12_4(self, cfg):
+        if not cfg.tokenlist:
+            return
+        expr = cfg.tokenlist[0]
+        while expr.next:
+            expr = expr.next
+            if expr.str == "?" and expr.astOperand2.str == ":":
+                known_value = expr.astOperand1.getKnownIntValue()
+                if known_value == 1:
+                    tok = expr
+                    while tok != expr.astOperand2:
+                        self.misra_12_4_check_expr(tok)
+                        tok = tok.next
+                    expr = tok
+                    while expr.str not in (";", "{", "}"):
+                        expr = expr.next
+                    continue
+                if known_value == 0:
+                    expr = expr.astOperand2
+            self.misra_12_4_check_expr(expr)
 
 
     def misra_13_1(self, data):
         for token in data.tokenlist:
-            if not simpleMatch(token, '= {'):
+            if simpleMatch(token, ") {") and token.next.astParent == token.link:
+                pass
+            elif not simpleMatch(token, '= {'):
                 continue
             init = token.next
-            if hasSideEffectsRecursive(init):
-                self.reportError(init, 13, 1)
-
+            end = init.link
+            if not end:
+                continue  # syntax is broken
+
+            tn = init
+            while tn and tn != end:
+                if tn.str == '[' and tn.link:
+                    tn = tn.link
+                    if tn and tn.next and tn.next.str == '=':
+                        tn = tn.next.next
+                        continue
+                    break
+                if tn.str == '.' and tn.next and tn.next.isName:
+                    tn = tn.next
+                    if tn.next and tn.next.str == '=':
+                        tn = tn.next.next
+                    continue
+                if tn.str in {'++', '--'} or tn.isAssignmentOp:
+                    self.reportError(init, 13, 1)
+                tn = tn.next
 
     def misra_13_3(self, data):
         for token in data.tokenlist:
@@ -1372,31 +3009,29 @@ def misra_13_3(self, data):
             if countSideEffects(astTop) >= 2:
                 self.reportError(astTop, 13, 3)
 
-
     def misra_13_4(self, data):
         for token in data.tokenlist:
             if token.str != '=':
                 continue
             if not token.astParent:
                 continue
+            if (token.astOperand1 is None) or (token.astOperand2 is None):
+                continue
             if token.astOperand1.str == '[' and token.astOperand1.previous.str in ('{', ','):
                 continue
             if not (token.astParent.str in [',', ';', '{']):
                 self.reportError(token, 13, 4)
 
-
     def misra_13_5(self, data):
         for token in data.tokenlist:
-            if token.isLogicalOp and hasSideEffectsRecursive(token.astOperand2):
+            if token.isLogicalOp and countSideEffectsRecursive(token.astOperand2) > 0:
                 self.reportError(token, 13, 5)
 
-
     def misra_13_6(self, data):
         for token in data.tokenlist:
-            if token.str == 'sizeof' and hasSideEffectsRecursive(token.next):
+            if token.str == 'sizeof' and countSideEffectsRecursive(token.next) > 0:
                 self.reportError(token, 13, 6)
 
-
     def misra_14_1(self, data):
         for token in data.tokenlist:
             if token.str == 'for':
@@ -1410,17 +3045,48 @@ def misra_14_1(self, data):
                 if isFloatCounterInWhileLoop(token):
                     self.reportError(token, 14, 1)
 
-
     def misra_14_2(self, data):
         for token in data.tokenlist:
-            expressions = getForLoopExpressions(token)
-            if not expressions:
-                continue
-            if expressions[0] and not expressions[0].isAssignmentOp:
-                self.reportError(token, 14, 2)
-            elif hasSideEffectsRecursive(expressions[1]):
-                self.reportError(token, 14, 2)
-
+            if token.str == 'for':
+                expressions = getForLoopExpressions(token)
+                if not expressions:
+                    continue
+                if expressions[0] and not expressions[0].isAssignmentOp:
+                    if expressions[0].str != "(" or not expressions[0].previous.isName:
+                        self.reportError(token, 14, 2)
+                if countSideEffectsRecursive(expressions[1]) > 0:
+                    self.reportError(token, 14, 2)
+                if countSideEffectsRecursive(expressions[2]) > 1:
+                    self.reportError(token, 14, 2)
+
+                counter_vars_first_clause, counter_vars_exit_modified = getForLoopCounterVariables(token, data)
+                if len(counter_vars_exit_modified) == 0:
+                    # if it's not possible to identify a loop counter, all 3 clauses must be empty
+                    for idx in range(len(expressions)):
+                        if expressions[idx]:
+                            self.reportError(token, 14, 2)
+                            break
+                elif len(counter_vars_exit_modified) > 1:
+                    # there shall be a single loop counter
+                    self.reportError(token, 14, 2)
+                else: # len(counter_vars_exit_modified) == 1:
+                    loop_counter = counter_vars_exit_modified.pop()
+                    # if the first clause is not empty, then it shall (declare and) initialize the loop counter
+                    if expressions[0] is not None and loop_counter not in counter_vars_first_clause:
+                        self.reportError(token, 14, 2)
+
+                    # Inspect modification of loop counter in loop body
+                    body_scope = token.next.link.next.scope
+                    if not body_scope:
+                        continue
+                    tn = body_scope.bodyStart
+                    while tn and tn != body_scope.bodyEnd:
+                        if tn.variable == loop_counter:
+                            if tn.next:
+                                # TODO: Check modifications in function calls
+                                if countSideEffectsRecursive(tn.next) > 0:
+                                    self.reportError(tn, 14, 2)
+                        tn = tn.next
 
     def misra_14_4(self, data):
         for token in data.tokenlist:
@@ -1428,16 +3094,16 @@ def misra_14_4(self, data):
                 continue
             if not token.astOperand1 or not (token.astOperand1.str in ['if', 'while']):
                 continue
-            if not isBoolExpression(token.astOperand2):
+            if isBoolExpression(token.astOperand2):
+                continue
+            if token.astOperand2.valueType:
                 self.reportError(token, 14, 4)
 
-
     def misra_15_1(self, data):
         for token in data.tokenlist:
             if token.str == "goto":
                 self.reportError(token, 15, 1)
 
-
     def misra_15_2(self, data):
         for token in data.tokenlist:
             if token.str != 'goto':
@@ -1447,7 +3113,6 @@ def misra_15_2(self, data):
             if not findGotoLabel(token):
                 self.reportError(token, 15, 2)
 
-
     def misra_15_3(self, data):
         for token in data.tokenlist:
             if token.str != 'goto':
@@ -1462,26 +3127,100 @@ def misra_15_3(self, data):
                 scope = scope.nestedIn
             if not scope:
                 self.reportError(token, 15, 3)
+            # Jump crosses from one switch-clause to another is non-compliant
+            elif scope.type == 'Switch':
+                # Search for start of a current case block
+                tcase_start = token
+                while tcase_start and tcase_start.str not in ('case', 'default'):
+                    tcase_start = tcase_start.previous
+                # Make sure that goto label doesn't occurs in the other
+                # switch-clauses
+                if tcase_start:
+                    t = scope.bodyStart
+                    in_this_case = False
+                    while t and t != scope.bodyEnd:
+                        if t == tcase_start:
+                            in_this_case = True
+                        if in_this_case and t.str not in ('case', 'default'):
+                            in_this_case = False
+                        if t == tok and not in_this_case:
+                            self.reportError(token, 15, 3)
+                            break
+                        t = t.next
+
+    def misra_15_4(self, data):
+        # Return a list of scopes affected by a break or goto
+        def getLoopsAffectedByBreak(knownLoops, scope, isGoto):
+            if scope and scope.type and scope.type not in ['Global', 'Function']:
+                if not isGoto and scope.type == 'Switch':
+                    return
+                if scope.type in ['For', 'While', 'Do']:
+                    knownLoops.append(scope)
+                    if not isGoto:
+                        return
+                getLoopsAffectedByBreak(knownLoops, scope.nestedIn, isGoto)
+
+        loopWithBreaks = {}
+        for token in data.tokenlist:
+            if token.str not in ['break', 'goto']:
+                continue
 
+            affectedLoopScopes = []
+            getLoopsAffectedByBreak(affectedLoopScopes, token.scope, token.str == 'goto')
+            for scope in affectedLoopScopes:
+                if scope in loopWithBreaks:
+                    loopWithBreaks[scope] += 1
+                else:
+                    loopWithBreaks[scope] = 1
+
+        for scope, breakCount in loopWithBreaks.items():
+            if breakCount > 1:
+                self.reportError(scope.bodyStart, 15, 4)
 
     def misra_15_5(self, data):
         for token in data.tokenlist:
             if token.str == 'return' and token.scope.type != 'Function':
                 self.reportError(token, 15, 5)
 
+    def misra_15_6(self, rawTokens):
+        state = 0
+        indent = 0
+        tok1 = None
+        def tokAt(tok,i):
+            while i < 0 and tok:
+                tok = tok.previous
+                if tok.str.startswith('//') or tok.str.startswith('/*'):
+                    continue
+                i += 1
+            while i > 0 and tok:
+                tok = tok.next
+                if tok.str.startswith('//') or tok.str.startswith('/*'):
+                    continue
+                i -= 1
+            return tok
+
+        def strtokens(tok, i1, i2):
+            tok1 = tokAt(tok, i1)
+            tok2 = tokAt(tok, i2)
+            tok = tok1
+            s = ''
+            while tok != tok2:
+                if tok.str.startswith('//') or tok.str.startswith('/*'):
+                    tok = tok.next
+                    continue
+                s += ' ' + tok.str
+                tok = tok.next
+            s += ' ' + tok.str
+            return s[1:]
 
-    def misra_15_6(self, rawTokens):
-        state = 0
-        indent = 0
-        tok1 = None
         for token in rawTokens:
             if token.str in ['if', 'for', 'while']:
-                if simpleMatch(token.previous, '# if'):
+                if strtokens(token,-1,0) == '# if':
                     continue
-                if simpleMatch(token.previous, "} while"):
+                if strtokens(token,-1,0) == "} while":
                     # is there a 'do { .. } while'?
-                    start = rawlink(token.previous)
-                    if start and simpleMatch(start.previous, 'do {'):
+                    start = rawlink(tokAt(token,-1))
+                    if start and strtokens(start, -1, 0) == 'do {':
                         continue
                 if state == 2:
                     self.reportError(tok1, 15, 6)
@@ -1489,9 +3228,9 @@ def misra_15_6(self, rawTokens):
                 indent = 0
                 tok1 = token
             elif token.str == 'else':
-                if simpleMatch(token.previous, '# else'):
+                if strtokens(token,-1,0) == '# else':
                     continue
-                if simpleMatch(token, 'else if'):
+                if strtokens(token,0,1) == 'else if':
                     continue
                 if state == 2:
                     self.reportError(tok1, 15, 6)
@@ -1514,10 +3253,9 @@ def misra_15_6(self, rawTokens):
                 if token.str.startswith('//') or token.str.startswith('/*'):
                     continue
                 state = 0
-                if token.str != '{':
+                if token.str not in ('{', '#'):
                     self.reportError(tok1, 15, 6)
 
-
     def misra_15_7(self, data):
         for scope in data.scopes:
             if scope.type != 'Else':
@@ -1533,26 +3271,67 @@ def misra_15_7(self, data):
             if not simpleMatch(tok, '} else'):
                 self.reportError(tok, 15, 7)
 
-    # TODO add 16.1 rule
-
+    def misra_16_1(self, cfg):
+        for scope in cfg.scopes:
+            if scope.type != 'Switch':
+                continue
+            in_case_or_default = False
+            tok = scope.bodyStart.next
+            while tok != scope.bodyEnd:
+                if not in_case_or_default:
+                    if tok.str not in ('case', 'default'):
+                        self.reportError(tok, 16, 1)
+                    else:
+                        in_case_or_default = True
+                else:
+                    if simpleMatch(tok, 'break ;'):
+                        in_case_or_default = False
+                        tok = tok.next
+                if tok.str == '{':
+                    tok = tok.link
+                    if tok.scope.type == 'Unconditional' and simpleMatch(tok.previous.previous, 'break ;'):
+                        in_case_or_default = False
+                tok = tok.next
 
     def misra_16_2(self, data):
         for token in data.tokenlist:
             if token.str == 'case' and token.scope.type != 'Switch':
                 self.reportError(token, 16, 2)
 
-
     def misra_16_3(self, rawTokens):
-        STATE_NONE = 0   # default state, not in switch case/default block
+        STATE_NONE = 0  # default state, not in switch case/default block
         STATE_BREAK = 1  # break/comment is seen but not its ';'
-        STATE_OK = 2     # a case/default is allowed (we have seen 'break;'/'comment'/'{'/attribute)
+        STATE_OK = 2  # a case/default is allowed (we have seen 'break;'/'comment'/'{'/attribute)
+        STATE_SWITCH = 3  # walking through switch statement scope
+
+        directive = None
         state = STATE_NONE
+        end_switch_token = None  # end '}' for the switch scope
         for token in rawTokens:
+            if simpleMatch(token, '# define') or simpleMatch(token, '# pragma'):
+                directive = token
+            if directive:
+                if token.linenr != directive.linenr:
+                    directive = None
+                else:
+                    continue
+
+            # Find switch scope borders
+            if token.str == 'switch':
+                state = STATE_SWITCH
+            if state == STATE_SWITCH:
+                if token.str == '{':
+                    end_switch_token = findRawLink(token)
+                else:
+                    continue
+
             if token.str == 'break' or token.str == 'return' or token.str == 'throw':
                 state = STATE_BREAK
             elif token.str == ';':
                 if state == STATE_BREAK:
                     state = STATE_OK
+                elif token.next and token.next == end_switch_token:
+                    self.reportError(token.next, 16, 3)
                 else:
                     state = STATE_NONE
             elif token.str.startswith('/*') or token.str.startswith('//'):
@@ -1576,7 +3355,6 @@ def misra_16_3(self, rawTokens):
                     self.reportError(token, 16, 3)
                 state = STATE_OK
 
-
     def misra_16_4(self, data):
         for token in data.tokenlist:
             if token.str != 'switch':
@@ -1596,12 +3374,11 @@ def misra_16_4(self, data):
             if tok and tok.str != 'default':
                 self.reportError(token, 16, 4)
 
-
     def misra_16_5(self, data):
         for token in data.tokenlist:
             if token.str != 'default':
                 continue
-            if token.previous and token.previous.str == '{':
+            if token.previous and (token.previous.str == '{'):
                 continue
             tok2 = token
             while tok2:
@@ -1613,7 +3390,6 @@ def misra_16_5(self, data):
             if tok2 and tok2.str == 'case':
                 self.reportError(token, 16, 5)
 
-
     def misra_16_6(self, data):
         for token in data.tokenlist:
             if not (simpleMatch(token, 'switch (') and simpleMatch(token.next.link, ') {')):
@@ -1633,23 +3409,24 @@ def misra_16_6(self, data):
             if count < 2:
                 self.reportError(token, 16, 6)
 
-
     def misra_16_7(self, data):
         for token in data.tokenlist:
             if simpleMatch(token, 'switch (') and isBoolExpression(token.next.astOperand2):
                 self.reportError(token, 16, 7)
 
-
     def misra_17_1(self, data):
         for token in data.tokenlist:
-            if isFunctionCall(token) and token.astOperand1.str in ('va_list', 'va_arg', 'va_start', 'va_end', 'va_copy'):
+            if isFunctionCall(token, data.standards.c) and token.astOperand1.str in (
+            'va_list', 'va_arg', 'va_start', 'va_end', 'va_copy'):
                 self.reportError(token, 17, 1)
             elif token.str == 'va_list':
                 self.reportError(token, 17, 1)
 
     def misra_17_2(self, data):
         # find recursions..
-        def find_recursive_call(search_for_function, direct_call, calls_map, visited=set()):
+        def find_recursive_call(search_for_function, direct_call, calls_map, visited=None):
+            if visited is None:
+                visited = set()
             if direct_call == search_for_function:
                 return True
             for indirect_call in calls_map.get(direct_call, []):
@@ -1672,7 +3449,7 @@ def find_recursive_call(search_for_function, direct_call, calls_map, visited=set
             tok = scope.bodyStart
             while tok != scope.bodyEnd:
                 tok = tok.next
-                if not isFunctionCall(tok):
+                if not isFunctionCall(tok, data.standards.c):
                     continue
                 f = tok.astOperand1.function
                 if f is not None and f not in calls:
@@ -1695,20 +3472,95 @@ def find_recursive_call(search_for_function, direct_call, calls_map, visited=set
                             self.reportError(tok, 17, 2)
                         tok = tok.next
 
+    def misra_17_3(self, cfg):
+        # Check for Clang warnings related to implicit function declarations
+        for w in cfg.clang_warnings:
+            if w['message'].endswith('[-Wimplicit-function-declaration]'):
+                self.reportError(cppcheckdata.Location(w), 17, 3)
+
+        # Additional check for implicit function calls in expressions
+        for token in cfg.tokenlist:
+            if token.isName and token.function is None and token.valueType is None:
+                if token.next and token.next.str == "(" and token.next.valueType is None:
+                    if token.next.next.str == "*" and \
+                        token.next.next.next.isName and token.next.next.next.valueType is not None and \
+                        token.next.next.next.valueType.pointer > 0 :
+                        # this is a function pointer definition the tokens look like this int16_t ( * misra_8_2_p_a ) ()
+                        # and the int16_t causes the detection as the '(' follows
+                        continue
+                    if not isKeyword(token.str,cfg.standards.c) and not isStdLibId(token.str,cfg.standards.c):
+                        self.reportError(token, 17, 3)
+
+    def misra_config(self, data):
+        for var in data.variables:
+            if not var.isArray or var.nameToken is None or not cppcheckdata.simpleMatch(var.nameToken.next, '['):
+                continue
+            tok = var.nameToken.next
+            while tok.str == '[':
+                sz = tok.astOperand2
+                if sz and sz.getKnownIntValue() is None:
+                    has_var = False
+                    unknown_constant = False
+                    tokens = [sz]
+                    while len(tokens) > 0:
+                        t = tokens[-1]
+                        tokens = tokens[:-1]
+                        if t:
+                            if t.isName and t.getKnownIntValue() is None:
+                                if t.varId or t.variable:
+                                    has_var = True
+                                    continue
+                                unknown_constant = True
+                                self.report_config_error(tok, 'Unknown constant {}, please review configuration'.format(t.str))
+                            if t.isArithmeticalOp:
+                                tokens += [t.astOperand1, t.astOperand2]
+                    if not unknown_constant and not has_var:
+                        self.report_config_error(tok, 'Unknown array size, please review configuration')
+                tok = tok.link.next
+
+        for token in data.tokenlist:
+            if token.str not in ("while", "if"):
+                continue
+            tok = token.next
+            if token is None or tok.str != "(":
+                continue
+            end_token = tok.link
+            while tok != end_token:
+                tok = tok.next
+                if tok.str == 'sizeof' and tok.next.str == '(':
+                    tok = tok.next.link
+                    continue
+                if tok.str == "(" and tok.isCast:
+                    tok = tok.link
+                    continue
+                if not tok.isName:
+                    continue
+                if tok.function or tok.variable or tok.varId or tok.valueType or tok.typeScope:
+                    continue
+                if tok.next.str == "(" or tok.str in ["EOF"]:
+                    continue
+                if isKeyword(tok.str, data.standards.c) or isStdLibId(tok.str, data.standards.c):
+                    continue
+                if tok.astParent is None:
+                    continue
+                if tok.astParent.str == "." and tok.astParent.valueType:
+                    continue
+                self.report_config_error(tok, "Variable '%s' is unknown" % tok.str)
 
     def misra_17_6(self, rawTokens):
         for token in rawTokens:
             if simpleMatch(token, '[ static'):
                 self.reportError(token, 17, 6)
 
-
     def misra_17_7(self, data):
         for token in data.tokenlist:
             if not token.scope.isExecutable:
                 continue
             if token.str != '(' or token.astParent:
                 continue
-            if not token.previous.isName or token.previous.varId:
+            if token.astOperand1 is None or not token.astOperand1.isName:
+                continue
+            if token.astOperand1.varId and (token.astOperand1.variable is None or get_function_pointer_type(token.astOperand1.variable.typeStartToken) is None):
                 continue
             if token.valueType is None:
                 continue
@@ -1716,7 +3568,6 @@ def misra_17_7(self, data):
                 continue
             self.reportError(token, 17, 7)
 
-
     def misra_17_8(self, data):
         for token in data.tokenlist:
             if not (token.isAssignmentOp or (token.str in ('++', '--'))):
@@ -1729,7 +3580,7 @@ def misra_17_8(self, data):
 
     def misra_18_4(self, data):
         for token in data.tokenlist:
-            if not token.str in ('+', '-', '+=', '-='):
+            if token.str not in ('+', '-', '+=', '-='):
                 continue
             if token.astOperand1 is None or token.astOperand2 is None:
                 continue
@@ -1755,7 +3606,6 @@ def misra_18_5(self, data):
             if count > 2:
                 self.reportError(var.nameToken, 18, 5)
 
-
     def misra_18_7(self, data):
         for scope in data.scopes:
             if scope.type != 'Struct':
@@ -1767,13 +3617,14 @@ def misra_18_7(self, data):
                 if token.str == '{':
                     token = token.link
 
-                if cppcheckdata.simpleMatch(token, "[ ]"):
+                # skip function pointer parameter types
+                if token.astOperand1 is None:
+                    pass
+                elif cppcheckdata.simpleMatch(token, "[ ]"):
                     self.reportError(token, 18, 7)
                     break
                 token = token.next
 
-
-
     def misra_18_8(self, data):
         for var in data.variables:
             if not var.isArray or not var.isLocal:
@@ -1782,97 +3633,182 @@ def misra_18_8(self, data):
             typetok = var.nameToken.next
             if not typetok or typetok.str != '[':
                 continue
-            if not isConstantExpression(typetok.astOperand2):
+            # Unknown define or syntax error
+            if not typetok.astOperand2:
+                continue
+            if not isConstantExpression(typetok.astOperand2) and not isUnknownConstantExpression(typetok.astOperand2):
                 self.reportError(var.nameToken, 18, 8)
 
-
     def misra_19_2(self, data):
         for token in data.tokenlist:
             if token.str == 'union':
                 self.reportError(token, 19, 2)
 
-
     def misra_20_1(self, data):
+        token_in_file = {}
+        for token in data.tokenlist:
+            if token.file not in token_in_file:
+                token_in_file[token.file] = int(token.linenr)
+            else:
+                token_in_file[token.file] = min(token_in_file[token.file], int(token.linenr))
+
         for directive in data.directives:
             if not directive.str.startswith('#include'):
                 continue
-            for token in data.tokenlist:
-                if token.file != directive.file:
-                    continue
-                if int(token.linenr) < int(directive.linenr):
-                    self.reportError(directive, 20, 1)
-                    break
-
+            if directive.file not in token_in_file:
+                continue
+            if token_in_file[directive.file] < int(directive.linenr):
+                self.reportError(directive, 20, 1)
 
     def misra_20_2(self, data):
         for directive in data.directives:
             if not directive.str.startswith('#include '):
                 continue
-            for pattern in ('\\', '//', '/*', "'"):
+            for pattern in ('\\', '//', '/*', ',', "'"):
                 if pattern in directive.str:
                     self.reportError(directive, 20, 2)
                     break
 
-
-    def misra_20_3(self, rawTokens):
-        linenr = -1
-        for token in rawTokens:
-            if token.str.startswith('/') or token.linenr == linenr:
-                continue
-            linenr = token.linenr
-            if not simpleMatch(token, '# include'):
+    def misra_20_3(self, data):
+        for directive in data.directives:
+            if not directive.str.startswith('#include '):
                 continue
-            headerToken = token.next.next
-            num = 0
-            while headerToken and headerToken.linenr == linenr:
-                if not headerToken.str.startswith('/*') and not headerToken.str.startswith('//'):
-                    num += 1
-                headerToken = headerToken.next
-            if num != 1:
-                self.reportError(token, 20, 3)
 
+            words = directive.str.split(' ')
+
+            # If include directive contains more than two words, here would be
+            # violation anyway.
+            if len(words) > 2:
+                self.reportError(directive, 20, 3)
+
+            # Handle include directives with not quoted argument
+            elif len(words) > 1:
+                filename = words[1]
+                if not ((filename.startswith('"') and
+                         filename.endswith('"')) or
+                        (filename.startswith('<') and
+                         filename.endswith('>'))):
+                    # We are handle only directly included files in the
+                    # following format: #include file.h
+                    # Cases with macro expansion provided by MISRA document are
+                    # skipped because we don't always have access to directive
+                    # definition.
+                    if '.' in filename:
+                        self.reportError(directive, 20, 3)
 
     def misra_20_4(self, data):
         for directive in data.directives:
             res = re.search(r'#define ([a-z][a-z0-9_]+)', directive.str)
-            if res and (res.group(1) in KEYWORDS):
+            if res and isKeyword(res.group(1), data.standards.c):
                 self.reportError(directive, 20, 4)
 
-
     def misra_20_5(self, data):
         for directive in data.directives:
             if directive.str.startswith('#undef '):
                 self.reportError(directive, 20, 5)
 
-
     def misra_20_7(self, data):
+        def find_string_concat(exp, arg, directive_args):
+            # Handle concatenation of string literals, e.g.:
+            # #define MACRO(A, B) (A " " B)
+            # Addon should not report errors for both macro arguments.
+            arg_pos = exp.find(arg, 0)
+            need_check = False
+            skip_next = False
+            state_in_string = False
+            pos_search = arg_pos + 1
+            directive_args = [a.strip() for a in directive_args if a != arg]
+            arg = arg.strip()
+            while pos_search < len(exp):
+                if exp[pos_search] == '"':
+                    if state_in_string:
+                        state_in_string = False
+                    else:
+                        state_in_string = True
+                    pos_search += 1
+                elif exp[pos_search].isalnum():
+                    word = ""
+                    while pos_search < len(exp) and exp[pos_search].isalnum():
+                        word += exp[pos_search]
+                        pos_search += 1
+                    if word == arg:
+                        pos_search += 1
+                    elif word in directive_args:
+                        skip_next = True
+                        break
+                elif exp[pos_search] == ' ':
+                    pos_search += 1
+                elif state_in_string:
+                    pos_search += 1
+                else:
+                    need_check = True
+                    break
+            return need_check, skip_next
+
         for directive in data.directives:
             d = Define(directive)
             exp = '(' + d.expansionList + ')'
+            skip_next = False
             for arg in d.args:
+                if skip_next:
+                    _, skip_next = find_string_concat(exp, arg, d.args)
+                    continue
+                need_check, skip_next = find_string_concat(exp, arg, d.args)
+                if not need_check:
+                    continue
+
                 pos = 0
                 while pos < len(exp):
                     pos = exp.find(arg, pos)
                     if pos < 0:
                         break
+                    # is 'arg' used at position pos
                     pos1 = pos - 1
                     pos2 = pos + len(arg)
                     pos = pos2
-                    if isalnum(exp[pos1]) or exp[pos1]=='_':
+                    if pos1 >= 0 and (isalnum(exp[pos1]) or exp[pos1] == '_'):
                         continue
-                    if isalnum(exp[pos2]) or exp[pos2]=='_':
+                    if pos2 < len(exp) and (isalnum(exp[pos2]) or exp[pos2] == '_'):
                         continue
-                    while exp[pos1] == ' ':
+
+                    while pos1 >= 0 and exp[pos1] == ' ':
                         pos1 -= 1
-                    if exp[pos1] != '(' and exp[pos1] != '[':
+                    if exp[pos1] == '#':
+                        continue
+                    if exp[pos1] not in '([,.':
                         self.reportError(directive, 20, 7)
                         break
-                    while exp[pos2] == ' ':
+                    while pos2 < len(exp) and exp[pos2] == ' ':
                         pos2 += 1
-                    if exp[pos2] != ')' and exp[pos2] != ']':
+                    if pos2 < len(exp) and exp[pos2] not in ')]#,':
                         self.reportError(directive, 20, 7)
                         break
 
+    def misra_20_8(self, cfg):
+        for cond in cfg.preprocessor_if_conditions:
+            #print(cond)
+            if cond.result and cond.result not in (0,1):
+                self.reportError(cond, 20, 8)
+
+    def misra_20_9(self, cfg):
+        for cond in cfg.preprocessor_if_conditions:
+            if cond.E is None:
+                continue
+            defined = []
+            for directive in cfg.directives:
+                if directive.file == cond.file and directive.linenr == cond.linenr:
+                    for name in re.findall(r'[^_a-zA-Z0-9]defined[ ]*\([ ]*([_a-zA-Z0-9]+)[ ]*\)', directive.str):
+                        defined.append(name)
+                    for name in re.findall(r'[^_a-zA-Z0-9]defined[ ]*([_a-zA-Z0-9]+)', directive.str):
+                        defined.append(name)
+                    break
+            for s in cond.E.split(' '):
+                if (s[0] >= 'A' and s[0] <= 'Z') or (s[0] >= 'a' and s[0] <= 'z'):
+                    if isKeyword(s, cfg.standards.c):
+                        continue
+                    if s in defined:
+                        continue
+                    self.reportError(cond, 20, 9)
 
     def misra_20_10(self, data):
         for directive in data.directives:
@@ -1880,6 +3816,65 @@ def misra_20_10(self, data):
             if d.expansionList.find('#') >= 0:
                 self.reportError(directive, 20, 10)
 
+    def misra_20_11(self, cfg):
+        for directive in cfg.directives:
+            d = Define(directive)
+            for arg in d.args:
+                res = re.search(r'[^#]#[ ]*%s[ ]*##' % arg, ' ' + d.expansionList)
+                if res:
+                    self.reportError(directive, 20, 11)
+
+    def misra_20_12(self, cfg):
+        def _is_hash_hash_op(expansion_list, arg):
+            return re.search(r'##[ ]*%s[^a-zA-Z0-9_]' % arg, expansion_list) or \
+                   re.search(r'[^a-zA-Z0-9_]%s[ ]*##' % arg, expansion_list)
+
+        def _is_other_op(expansion_list, arg):
+            pos = expansion_list.find(arg)
+            while pos >= 0:
+                pos1 = pos - 1
+                pos2 = pos + len(arg)
+                pos = expansion_list.find(arg, pos2)
+                if isalnum(expansion_list[pos1]) or expansion_list[pos1] == '_':
+                    continue
+                if isalnum(expansion_list[pos2]) or expansion_list[pos2] == '_':
+                    continue
+                while expansion_list[pos1] == ' ':
+                    pos1 = pos1 - 1
+                if expansion_list[pos1] == '#':
+                    continue
+                while expansion_list[pos2] == ' ':
+                    pos2 = pos2 + 1
+                if expansion_list[pos2] == '#':
+                    continue
+                return True
+            return False
+
+        def _is_arg_macro_usage(directive, arg):
+            for macro_usage in cfg.macro_usage:
+                if macro_usage.file == directive.file and macro_usage.linenr == directive.linenr:
+                    for macro_usage_arg in cfg.macro_usage:
+                        if macro_usage_arg == macro_usage:
+                            continue
+                        if (macro_usage.usefile == macro_usage_arg.usefile and
+                            macro_usage.uselinenr == macro_usage_arg.uselinenr and
+                            macro_usage.usecolumn == macro_usage_arg.usecolumn):
+                            # TODO: check arg better
+                            return True
+            return False
+
+        for directive in cfg.directives:
+            define = Define(directive)
+            expansion_list = '(%s)' % define.expansionList
+            for arg in define.args:
+                if not _is_hash_hash_op(expansion_list, arg):
+                    continue
+                if not _is_other_op(expansion_list, arg):
+                    continue
+                if _is_arg_macro_usage(directive, arg):
+                    self.reportError(directive, 20, 12)
+                    break
+
     def misra_20_13(self, data):
         dir_pattern = re.compile(r'#[ ]*([^ (<]*)')
         for directive in data.directives:
@@ -1888,16 +3883,16 @@ def misra_20_13(self, data):
             if mo:
                 dir = mo.group(1)
             if dir not in ['define', 'elif', 'else', 'endif', 'error', 'if', 'ifdef', 'ifndef', 'include',
-                        'pragma', 'undef', 'warning']:
+                           'pragma', 'undef', 'warning']:
                 self.reportError(directive, 20, 13)
 
-
     def misra_20_14(self, data):
         # stack for #if blocks. contains the #if directive until the corresponding #endif is seen.
         # the size increases when there are inner #if directives.
         ifStack = []
         for directive in data.directives:
-            if directive.str.startswith('#if ') or directive.str.startswith('#ifdef ') or directive.str.startswith('#ifndef '):
+            if directive.str.startswith('#if ') or directive.str.startswith('#ifdef ') or directive.str.startswith(
+                    '#ifndef '):
                 ifStack.append(directive)
             elif directive.str == '#else' or directive.str.startswith('#elif '):
                 if len(ifStack) == 0:
@@ -1912,52 +3907,74 @@ def misra_20_14(self, data):
                     self.reportError(directive, 20, 14)
                     ifStack.pop()
 
+    def misra_21_1(self, data):
+        re_forbidden_macro = re.compile(r'#(?:define|undef) _[_A-Z]+')
+        re_macro_name = re.compile(r'#(?:define|undef) (.+)[ $]')
+
+        for d in data.directives:
+            # Search for forbidden identifiers
+            m = re.search(re_forbidden_macro, d.str)
+            if m:
+                self.reportError(d, 21, 1)
+                continue
+
+            # Search standard library identifiers in macro names
+            m = re.search(re_macro_name, d.str)
+            if not m:
+                continue
+            name = m.group(1)
+            if isStdLibId(name, data.standards.c):
+                self.reportError(d, 21, 1)
+
+    def misra_21_2(self, cfg):
+        for directive in cfg.directives:
+            define = Define(directive)
+            if re.match(r'_+BUILTIN_.*', define.name.upper()):
+                self.reportError(directive, 21, 2)
+        for func in cfg.functions:
+            if isStdLibId(func.name, cfg.standards.c):
+                tok = func.tokenDef if func.tokenDef else func.token
+                self.reportError(tok, 21, 2)
 
     def misra_21_3(self, data):
         for token in data.tokenlist:
-            if isFunctionCall(token) and (token.astOperand1.str in ('malloc', 'calloc', 'realloc', 'free')):
+            if isFunctionCall(token, data.standards.c) and (token.astOperand1.str in ('malloc', 'calloc', 'realloc', 'free')):
                 self.reportError(token, 21, 3)
 
-
     def misra_21_4(self, data):
         directive = findInclude(data.directives, '<setjmp.h>')
         if directive:
             self.reportError(directive, 21, 4)
 
-
     def misra_21_5(self, data):
         directive = findInclude(data.directives, '<signal.h>')
         if directive:
             self.reportError(directive, 21, 5)
 
-
     def misra_21_6(self, data):
-        dir_stdio = findInclude(data.directives, '<stdio.h>')
-        dir_wchar = findInclude(data.directives, '<wchar.h>')
-        if dir_stdio:
-            self.reportError(dir_stdio, 21, 6)
-        if dir_wchar:
-            self.reportError(dir_wchar, 21, 6)
-
+        for token in data.tokenlist:
+            if not isFunctionCall(token) or token.previous.function:
+                continue
+            standard_id = getStdLib(data.standards.c)
+            funcname = token.previous.str
+            if funcname in standard_id.get("stdio.h", []) or funcname in standard_id.get("wchar.h", []):
+                self.reportError(token, 21, 6)
 
     def misra_21_7(self, data):
         for token in data.tokenlist:
-            if isFunctionCall(token) and (token.astOperand1.str in ('atof', 'atoi', 'atol', 'atoll')):
+            if isFunctionCall(token, data.standards.c) and (token.astOperand1.str in ('atof', 'atoi', 'atol', 'atoll')):
                 self.reportError(token, 21, 7)
 
-
     def misra_21_8(self, data):
         for token in data.tokenlist:
-            if isFunctionCall(token) and (token.astOperand1.str in ('abort', 'exit', 'getenv', 'system')):
+            if isFunctionCall(token, data.standards.c) and (token.astOperand1.str in ('abort', 'exit', 'getenv')):
                 self.reportError(token, 21, 8)
 
-
     def misra_21_9(self, data):
         for token in data.tokenlist:
             if (token.str in ('bsearch', 'qsort')) and token.next and token.next.str == '(':
                 self.reportError(token, 21, 9)
 
-
     def misra_21_10(self, data):
         directive = findInclude(data.directives, '<time.h>')
         if directive:
@@ -1967,39 +3984,276 @@ def misra_21_10(self, data):
             if (token.str == 'wcsftime') and token.next and token.next.str == '(':
                 self.reportError(token, 21, 10)
 
-
     def misra_21_11(self, data):
         directive = findInclude(data.directives, '<tgmath.h>')
         if directive:
             self.reportError(directive, 21, 11)
 
+    def misra_21_12(self, data):
+        if findInclude(data.directives, '<fenv.h>'):
+            for token in data.tokenlist:
+                if token.str == 'fexcept_t' and token.isName:
+                    self.reportError(token, 21, 12)
+                if isFunctionCall(token, data.standards.c) and (token.astOperand1.str in (
+                        'feclearexcept',
+                        'fegetexceptflag',
+                        'feraiseexcept',
+                        'fesetexceptflag',
+                        'fetestexcept')):
+                    self.reportError(token, 21, 12)
+
+    def misra_21_14(self, data):
+        # buffers used in strcpy/strlen/etc function calls
+        string_buffers = []
+        for token in data.tokenlist:
+            if token.str[0] == 's' and isFunctionCall(token.next, data.standards.c):
+                name, args = cppcheckdata.get_function_call_name_args(token)
+                if name is None:
+                    continue
+                def _get_string_buffers(match, args, argnum):
+                    if not match:
+                        return []
+                    ret = []
+                    for a in argnum:
+                        if a < len(args):
+                            arg = args[a]
+                            while arg and arg.str in ('.', '::'):
+                                arg = arg.astOperand2
+                            if arg and arg.varId != 0 and arg.varId not in ret:
+                                ret.append(arg.varId)
+                    return ret
+                string_buffers += _get_string_buffers(name == 'strcpy', args, [0, 1])
+                string_buffers += _get_string_buffers(name == 'strncpy', args, [0, 1])
+                string_buffers += _get_string_buffers(name == 'strlen', args, [0])
+                string_buffers += _get_string_buffers(name == 'strcmp', args, [0, 1])
+                string_buffers += _get_string_buffers(name == 'sprintf', args, [0])
+                string_buffers += _get_string_buffers(name == 'snprintf', args, [0, 3])
+
+        for token in data.tokenlist:
+            if token.str != 'memcmp':
+                continue
+            name, args = cppcheckdata.get_function_call_name_args(token)
+            if name is None:
+                continue
+            if len(args) != 3:
+                continue
+            for arg in args[:2]:
+                if arg.str[-1] == '\"':
+                    self.reportError(arg, 21, 14)
+                    continue
+                while arg and arg.str in ('.', '::'):
+                    arg = arg.astOperand2
+                if arg and arg.varId and arg.varId in string_buffers:
+                    self.reportError(arg, 21, 14)
+
+    def misra_21_15(self, data):
+        for token in data.tokenlist:
+            if token.str not in ('memcpy', 'memmove', 'memcmp'):
+                continue
+            name, args = cppcheckdata.get_function_call_name_args(token)
+            if name is None:
+                continue
+            if len(args) != 3:
+                continue
+            if args[0].valueType is None or args[1].valueType is None:
+                continue
+            if args[0].valueType.type == args[1].valueType.type:
+                continue
+            if args[0].valueType.type == 'void' or args[1].valueType.type == 'void':
+                continue
+            self.reportError(token, 21, 15)
+
+    def misra_21_16(self, cfg):
+        for token in cfg.tokenlist:
+            if token.str != 'memcmp':
+                continue
+            name, args = cppcheckdata.get_function_call_name_args(token)
+            if name is None:
+                continue
+            if len(args) != 3:
+                continue
+            for arg in args[:2]:
+                if arg.valueType is None:
+                    continue
+                if arg.valueType.pointer > 1:
+                    continue
+                if getEssentialTypeCategory(arg) in ('unsigned', 'signed', 'bool'):
+                    continue
+                if arg.valueType.isEnum():
+                    continue
+                self.reportError(token, 21, 16)
+
+    def misra_21_19(self, cfg):
+        for token in cfg.tokenlist:
+            if token.str in ('localeconv', 'getenv', 'setlocale', 'strerror') and simpleMatch(token.next, '('):
+                name, _ = cppcheckdata.get_function_call_name_args(token)
+                if name is None or name != token.str:
+                    continue
+                parent = token.next
+                while simpleMatch(parent.astParent, '+'):
+                    parent = parent.astParent
+                # x = f()
+                if simpleMatch(parent.astParent, '=') and parent == parent.astParent.astOperand2:
+                    lhs = parent.astParent.astOperand1
+                    if lhs and lhs.valueType and lhs.valueType.pointer > 0 and lhs.valueType.constness == 0:
+                        self.reportError(token, 21, 19)
+            if token.str == '=':
+                lhs = token.astOperand1
+                while simpleMatch(lhs, '*') and lhs.astOperand2 is None:
+                    lhs = lhs.astOperand1
+                if not simpleMatch(lhs, '.'):
+                    continue
+                while simpleMatch(lhs, '.'):
+                    lhs = lhs.astOperand1
+                if lhs and lhs.variable and simpleMatch(lhs.variable.typeStartToken, 'lconv'):
+                    self.reportError(token, 21, 19)
+
+    def misra_21_20(self, cfg):
+        assigned = {}
+        invalid = []
+        for token in cfg.tokenlist:
+            # No sophisticated data flow analysis, bail out if control flow is "interrupted"
+            if token.str in ('{', '}', 'break', 'continue', 'return'):
+                assigned = {}
+                invalid = []
+                continue
+
+            # When pointer is assigned, remove it from 'assigned' and 'invalid'
+            if token.varId and token.varId > 0 and simpleMatch(token.next, '='):
+                for name in assigned.keys():
+                    while token.varId in assigned[name]:
+                        assigned[name].remove(token.varId)
+                while token.varId in invalid:
+                    invalid.remove(token.varId)
+                continue
+
+            # Calling dangerous function
+            if token.str in ('asctime', 'ctime', 'gmtime', 'localtime', 'localeconv', 'getenv', 'setlocale', 'strerror'):
+                name, _ = cppcheckdata.get_function_call_name_args(token)
+                if name and name == token.str:
+                    # make assigned pointers invalid
+                    for varId in assigned.get(name, ()):
+                        if varId not in invalid:
+                            invalid.append(varId)
+
+                    # assign pointer
+                    parent = token.next
+                    while parent.astParent and (parent.astParent.str == '+' or isCast(parent.astParent)):
+                        parent = parent.astParent
+                    if simpleMatch(parent.astParent, '='):
+                        eq = parent.astParent
+                        vartok = eq.previous
+                        if vartok and vartok.varId and vartok.varId > 0:
+                            if name not in assigned:
+                                assigned[name] = [vartok.varId]
+                            elif vartok.varId not in assigned[name]:
+                                assigned[name].append(vartok.varId)
+                continue
+
+            # taking value of invalid pointer..
+            if token.astParent and token.varId:
+                if token.varId in invalid:
+                    self.reportError(token, 21, 20)
+
+    def misra_21_21(self, cfg):
+        for token in cfg.tokenlist:
+            if token.str == 'system':
+                name, args = cppcheckdata.get_function_call_name_args(token)
+                if name == 'system' and len(args) == 1:
+                    self.reportError(token, 21, 21)
+
+    def misra_22_5(self, cfg):
+        for token in cfg.tokenlist:
+            if token.isUnaryOp("*") or (token.isBinaryOp() and token.str == '.'):
+                fileptr = token.astOperand1
+                if fileptr.variable and cppcheckdata.simpleMatch(fileptr.variable.typeStartToken, 'FILE *'):
+                    self.reportError(token, 22, 5)
+
+    def misra_22_7(self, cfg):
+        for eofToken in cfg.tokenlist:
+            if eofToken.str != 'EOF':
+                continue
+            if eofToken.astParent is None or not eofToken.astParent.isComparisonOp:
+                continue
+            if eofToken.astParent.astOperand1 == eofToken:
+                eofTokenSibling = eofToken.astParent.astOperand2
+            else:
+                eofTokenSibling = eofToken.astParent.astOperand1
+            while isCast(eofTokenSibling) and eofTokenSibling.valueType and eofTokenSibling.valueType.type and eofTokenSibling.valueType.type == 'int':
+                eofTokenSibling = eofTokenSibling.astOperand2 if eofTokenSibling.astOperand2 else eofTokenSibling.astOperand1
+            if eofTokenSibling is not None and eofTokenSibling.valueType and eofTokenSibling.valueType and eofTokenSibling.valueType.type in ('bool', 'char', 'short'):
+                self.reportError(eofToken, 22, 7)
+
+    def misra_22_8(self, cfg):
+        is_zero = False
+        for token in cfg.tokenlist:
+            if simpleMatch(token, 'errno = 0'):
+                is_zero = True
+            if token.str == '(' and not simpleMatch(token.link, ') {'):
+                name, _ = cppcheckdata.get_function_call_name_args(token.previous)
+                if name is None:
+                    continue
+                if is_errno_setting_function(name):
+                    if not is_zero:
+                        self.reportError(token, 22, 8)
+                else:
+                    is_zero = False
+
+    def misra_22_9(self, cfg):
+        errno_is_set = False
+        for token in cfg.tokenlist:
+            if token.str == '(' and not simpleMatch(token.link, ') {'):
+                name, _ = cppcheckdata.get_function_call_name_args(token.previous)
+                if name is None:
+                    continue
+                errno_is_set = is_errno_setting_function(name)
+            if errno_is_set and token.str in '{};':
+                errno_is_set = False
+                tok = token.next
+                while tok and tok.str not in ('{','}',';','errno'):
+                    tok = tok.next
+                if tok is None or tok.str != 'errno':
+                    self.reportError(token, 22, 9)
+                elif (tok.astParent is None) or (not tok.astParent.isComparisonOp):
+                    self.reportError(token, 22, 9)
+
+    def misra_22_10(self, cfg):
+        last_function_call = None
+        for token in cfg.tokenlist:
+            if token.isName and token.next and token.next.str == '(' and not simpleMatch(token.next.link, ') {'):
+                name, _ = cppcheckdata.get_function_call_name_args(token)
+                last_function_call = name
+            if token.str == '}':
+                last_function_call = None
+            if token.str == 'errno' and token.astParent and token.astParent.isComparisonOp:
+                if last_function_call is None:
+                    self.reportError(token, 22, 10)
+                elif not is_errno_setting_function(last_function_call):
+                    self.reportError(token, 22, 10)
+
 
     def get_verify_expected(self):
         """Return the list of expected violations in the verify test"""
         return self.verify_expected
 
-
     def get_verify_actual(self):
         """Return the list of actual violations in for the verify test"""
         return self.verify_actual
 
-
-    def get_violations(self, violation_type = None):
+    def get_violations(self, violation_type=None):
         """Return the list of violations for a normal checker run"""
-        if violation_type == None:
+        if violation_type is None:
             return self.violations.items()
-        else:
-            return self.violations[violation_type]
+        return self.violations[violation_type]
 
     def get_violation_types(self):
         """Return the list of violations for a normal checker run"""
         return self.violations.keys()
 
-
     def addSuppressedRule(self, ruleNum,
-                          fileName   = None,
-                          lineNumber = None,
-                          symbolName = None):
+                          fileName=None,
+                          lineNumber=None,
+                          symbolName=None):
         """
         Add a suppression to the suppressions data structure
 
@@ -2012,7 +4266,7 @@ def addSuppressedRule(self, ruleNum,
         all files.
         If the filename exists then the value of that dictionary contains a list
         with the scope of the suppression.  If the list contains an item of None
-        then the rule is assumed to be suppresed for the entire file. Otherwise
+        then the rule is assumed to be suppressed for the entire file. Otherwise
         the list contains line number, symbol name tuples.
         For each tuple either line number or symbol name can can be none.
 
@@ -2029,11 +4283,11 @@ def addSuppressedRule(self, ruleNum,
             line_symbol = None
 
         # If the rule is not in the dict already then add it
-        if not ruleNum in self.suppressedRules:
-            ruleItemList = list()
+        if ruleNum not in self.suppressedRules:
+            ruleItemList = []
             ruleItemList.append(line_symbol)
 
-            fileDict = dict()
+            fileDict = {}
             fileDict[normalized_filename] = ruleItemList
 
             self.suppressedRules[ruleNum] = fileDict
@@ -2048,8 +4302,8 @@ def addSuppressedRule(self, ruleNum,
         fileDict = self.suppressedRules[ruleNum]
 
         # If the filename is not in the dict already add it
-        if not normalized_filename in fileDict:
-            ruleItemList = list()
+        if normalized_filename not in fileDict:
+            ruleItemList = []
             ruleItemList.append(line_symbol)
 
             fileDict[normalized_filename] = ruleItemList
@@ -2060,13 +4314,13 @@ def addSuppressedRule(self, ruleNum,
         # Rule has a matching filename. Get the rule item list.
 
         # Check the lists of rule items
-        # to see if this (lineNumber, symbonName) combination
+        # to see if this (lineNumber, symbolName) combination
         # or None already exists.
         ruleItemList = fileDict[normalized_filename]
 
         if line_symbol is None:
             # is it already in the list?
-            if not line_symbol in ruleItemList:
+            if line_symbol not in ruleItemList:
                 ruleItemList.append(line_symbol)
         else:
             # Check the list looking for matches
@@ -2080,11 +4334,13 @@ def addSuppressedRule(self, ruleNum,
             if not matched:
                 ruleItemList.append(line_symbol)
 
-
-    def isRuleSuppressed(self, location, ruleNum):
+    def isRuleSuppressed(self, file_path, linenr, ruleNum):
         """
         Check to see if a rule is suppressed.
-        ruleNum is the rule number in hundreds format
+
+        :param ruleNum: is the rule number in hundreds format
+        :param file_path: File path of checked location
+        :param linenr: Line number of checked location
 
         If the rule exists in the dict then check for a filename
         If the filename is None then rule is suppressed globally
@@ -2099,15 +4355,14 @@ def isRuleSuppressed(self, location, ruleNum):
 
         """
         ruleIsSuppressed = False
-        linenr = location.linenr
 
         # Remove any prefix listed in command arguments from the filename.
         filename = None
-        if location.file is not None:
+        if file_path is not None:
             if self.filePrefix is not None:
-                filename = remove_file_prefix(location.file, self.filePrefix)
+                filename = remove_file_prefix(file_path, self.filePrefix)
             else:
-                filename = os.path.basename(location.file)
+                filename = os.path.basename(file_path)
 
         if ruleNum in self.suppressedRules:
             fileDict = self.suppressedRules[ruleNum]
@@ -2138,62 +4393,53 @@ def isRuleSuppressed(self, location, ruleNum):
 
         return ruleIsSuppressed
 
-
-    def parseSuppressions(self):
+    def isRuleGloballySuppressed(self, rule_num):
         """
-        Parse the suppression list provided by cppcheck looking for
-        rules that start with 'misra' or MISRA.  The MISRA rule number
-        follows using either '_' or '.' to separate the numbers.
-        Examples:
-            misra_6.0
-            misra_7_0
-            misra.21.11
+        Check to see if a rule is globally suppressed.
+        :param rule_num: is the rule number in hundreds format
         """
-        rule_pattern = re.compile(r'^(misra|MISRA)[_.]([0-9]+)[_.]([0-9]+)')
-
-        for each in self.dumpfileSuppressions:
-            res = rule_pattern.match(each.errorId)
-
-            if res:
-                num1 = int(res.group(2)) * 100
-                ruleNum = num1 + int(res.group(3))
-                linenr = None
-                if each.lineNumber:
-                    linenr = int(each.lineNumber)
-                self.addSuppressedRule(ruleNum, each.fileName, linenr, each.symbolName)
-
+        if rule_num not in self.suppressedRules:
+            return False
+        return None in self.suppressedRules[rule_num]
 
     def showSuppressedRules(self):
-            """
-            Print out rules in suppression list sorted by Rule Number
-            """
-            print("Suppressed Rules List:")
-            outlist = list()
+        """
+        Print out rules in suppression list sorted by Rule Number
+        """
+        print("Suppressed Rules List:")
+        outlist = []
 
-            for ruleNum in self.suppressedRules:
-                fileDict = self.suppressedRules[ruleNum]
+        for ruleNum in self.suppressedRules:
+            fileDict = self.suppressedRules[ruleNum]
 
-                for fname in fileDict:
-                    ruleItemList = fileDict[fname]
+            for fname in fileDict:
+                ruleItemList = fileDict[fname]
 
-                    for item in ruleItemList:
-                        if item is None:
-                            item_str = "None"
-                        else:
-                            item_str = str(item[0])
+                for item in ruleItemList:
+                    if item is None:
+                        item_str = "None"
+                    else:
+                        item_str = str(item[0])
 
-                        outlist.append("%s: %s: %s (%d locations suppressed)" % (float(ruleNum)/100,fname,item_str, len(self.suppressionStats.get(ruleNum, []))))
+                    outlist.append("%s: %s: %s (%d locations suppressed)" % (
+                    float(ruleNum) / 100, fname, item_str, self.suppressionStats.get(ruleNum, 0)))
 
-            for line in sorted(outlist, reverse=True):
-                print("  %s" % line)
+        for line in sorted(outlist, reverse=True):
+            print("  %s" % line)
 
     def setFilePrefix(self, prefix):
         """
-        Set the file prefix to ignnore from files when matching
+        Set the file prefix to ignore from files when matching
         suppression files
         """
         self.filePrefix = prefix
 
+    def setSeverity(self, severity):
+        """
+        Set the severity for all errors.
+        """
+        self.severity = severity
+
     def setSuppressionList(self, suppressionlist):
         num1 = 0
         num2 = 0
@@ -2206,21 +4452,31 @@ def setSuppressionList(self, suppressionlist):
             if res:
                 num1 = int(res.group(1))
                 num2 = int(res.group(2))
-                ruleNum = (num1*100)+num2
+                ruleNum = (num1 * 100) + num2
 
                 self.addSuppressedRule(ruleNum)
 
+    def report_config_error(self, location, errmsg):
+        errmsg = 'Because of missing configuration, misra checking is incomplete. There can be false negatives! ' + errmsg
+        cppcheck_severity = 'error'
+        error_id = 'config'
+        if self.settings.verify:
+            self.verify_actual.append('%s:%d %s' % (location.file, location.linenr, error_id))
+        else:
+            cppcheckdata.reportError(location, cppcheck_severity, errmsg, 'misra', error_id)
 
     def reportError(self, location, num1, num2):
         ruleNum = num1 * 100 + num2
 
+        if self.isRuleGloballySuppressed(ruleNum):
+            return
+
         if self.settings.verify:
-            self.verify_actual.append(str(location.linenr) + ':' + str(num1) + '.' + str(num2))
-        elif self.isRuleSuppressed(location, ruleNum):
+            self.verify_actual.append('%s:%d %d.%d' % (location.file, location.linenr, num1, num2))
+        elif self.isRuleSuppressed(location.file, location.linenr, ruleNum):
             # Error is suppressed. Ignore
-            if not ruleNum in self.suppressionStats:
-                self.suppressionStats[ruleNum] = []
-            self.suppressionStats[ruleNum].append(location)
+            self.suppressionStats.setdefault(ruleNum, 0)
+            self.suppressionStats[ruleNum] += 1
             return
         else:
             errorId = 'c2012-' + str(num1) + '.' + str(num2)
@@ -2232,23 +4488,34 @@ def reportError(self, location, num1, num2):
                     misra_severity = self.ruleTexts[ruleNum].misra_severity
                 cppcheck_severity = self.ruleTexts[ruleNum].cppcheck_severity
             elif len(self.ruleTexts) == 0:
-                errmsg = 'misra violation (use --rule-texts=<file> to get proper output)'
+                if self.ruleText_filename is None:
+                    errmsg = 'misra violation (use --rule-texts=<file> to get proper output)'
+                else:
+                    errmsg = 'misra violation (rule-texts-file not found: ' + self.ruleText_filename + ')'
             else:
-                return
-            cppcheckdata.reportError(location, cppcheck_severity, errmsg, 'misra', errorId, misra_severity)
+                errmsg = 'misra violation %s with no text in the supplied rule-texts-file' % (ruleNum)
+
+            if self.severity:
+                cppcheck_severity = self.severity
 
-            if not misra_severity in self.violations:
-                self.violations[misra_severity] = []
-            self.violations[misra_severity].append('misra-' + errorId)
+            this_violation = '{}-{}-{}-{}'.format(location.file, location.linenr, location.column, ruleNum)
+
+            # If this is new violation then record it and show it. If not then
+            # skip it since it has already been displayed.
+            if this_violation not in self.existing_violations:
+                self.existing_violations.add(this_violation)
+                cppcheckdata.reportError(location, cppcheck_severity, errmsg, 'misra', errorId, misra_severity)
+
+                if misra_severity not in self.violations:
+                    self.violations[misra_severity] = []
+                self.violations[misra_severity].append('misra-' + errorId)
 
     def loadRuleTexts(self, filename):
         num1 = 0
         num2 = 0
         appendixA = False
-        ruleText = False
-        expect_more = False
 
-        Rule_pattern = re.compile(r'^Rule ([0-9]+).([0-9]+)')
+        Rule_pattern = re.compile(r'^Rule ([0-9]+)\.([0-9]+)')
         severity_pattern = re.compile(r'.*[ ]*(Advisory|Required|Mandatory)$')
         xA_Z_pattern = re.compile(r'^[#A-Z].*')
         a_z_pattern = re.compile(r'^[a-z].*')
@@ -2257,10 +4524,11 @@ def loadRuleTexts(self, filename):
         encodings = ['ascii', 'utf-8', 'windows-1250', 'windows-1252']
         for e in encodings:
             try:
-                file_stream = codecs.open(filename, 'r', encoding=e)
+                file_stream = open(filename, 'r', encoding=e)
                 file_stream.readlines()
                 file_stream.seek(0)
             except UnicodeDecodeError:
+                file_stream.close()
                 file_stream = None
             else:
                 break
@@ -2275,12 +4543,13 @@ def loadRuleTexts(self, filename):
                 file_stream = open(filename, 'rt')
 
         rule = None
-        have_severity = False
-        severity_loc  = 0
+        rule_line_number = 0
 
         for line in file_stream:
 
-            line = line.replace('\r', '').replace('\n', '')
+            line = line.strip()
+            if len(line) == 0:
+                continue
 
             if not appendixA:
                 if line.find('Appendix A') >= 0 and line.find('Summary of guidelines') >= 10:
@@ -2288,57 +4557,50 @@ def loadRuleTexts(self, filename):
                 continue
             if line.find('Appendix B') >= 0:
                 break
-            if len(line) == 0:
-                continue
 
             # Parse rule declaration.
             res = Rule_pattern.match(line)
 
             if res:
-                have_severity = False
-                expect_more = False
-                severity_loc = 0
+                rule_line_number = 0
                 num1 = int(res.group(1))
                 num2 = int(res.group(2))
                 rule = Rule(num1, num2)
 
-            if not have_severity and rule is not None:
                 res = severity_pattern.match(line)
-
                 if res:
                     rule.misra_severity = res.group(1)
-                    have_severity = True
-                else:
-                    severity_loc += 1;
-
-                # Only look for severity on the Rule line
-                # or the next non-blank line after
-                # If it's not in either of those locations then
-                # assume a severity was not provided.
-
-                if severity_loc < 2:
-                    continue
-                else:
-                    rule.misra_severity = ''
-                    have_severity = True
+                    rule_line_number = 1
+                continue
 
             if rule is None:
                 continue
 
-            # Parse continuing of rule text.
-            if expect_more:
-                if a_z_pattern.match(line):
-                    self.ruleTexts[rule.num].text += ' ' + line
+            rule_line_number += 1
+
+            if rule_line_number == 1:
+                res = severity_pattern.match(line)
+
+                if res:
+                    rule.misra_severity = res.group(1)
                     continue
 
-                expect_more = False
-                continue
+                rule_line_number = 2
 
             # Parse beginning of rule text.
-            if xA_Z_pattern.match(line):
-                rule.text = line
+            if not rule.text and xA_Z_pattern.match(line):
+                rule.text = line.strip()
                 self.ruleTexts[rule.num] = rule
-                expect_more = True
+                continue
+
+            # Parse continuing of rule text.
+            if a_z_pattern.match(line):
+                self.ruleTexts[rule.num].text += ' ' + line.strip()
+                continue
+
+            rule = None
+
+        file_stream.close()
 
     def verifyRuleTexts(self):
         """Prints rule numbers without rule text."""
@@ -2355,18 +4617,47 @@ def verifyRuleTexts(self):
         else:
             print("Missing rule texts: " + ', '.join(missing_rules))
 
-
     def printStatus(self, *args, **kwargs):
         if not self.settings.quiet:
             print(*args, **kwargs)
 
-    def parseDump(self, dumpfile):
-
-        data = cppcheckdata.parsedump(dumpfile)
+    def executeCheck(self, rule_num, check_function, *args):
+        """Execute check function for a single MISRA rule.
 
-        self.dumpfileSuppressions = data.suppressions
-        self.parseSuppressions()
+        :param rule_num: Number of rule in hundreds format
+        :param check_function: Check function to execute
+        :param args: Check function arguments
+        """
+        if not self.isRuleGloballySuppressed(rule_num):
+            misra_cpp = (
+                202, # misra-c2012-2.3 : misra c++2008 0-1-9
+                203, # misra-c2012-2.3 : misra c++2008 0-1-5
+                402, # misra-c2012-4.2 : misra c++2008 2-3-1
+                701, # misra-c2012-7.1 : misra c++2008 2-3-1
+                702, # misra-c2012-7.2 : misra c++2008 2-13-2
+                1203, # misra-c2012-12.3 : misra c++2008 5-14-1
+                1204, # misra-c2012-12.4 : misra c++2008 5-18-1
+                1305, # misra-c2012-13.5 : misra c++2008 5-19-1
+                1702, # misra-c2012-17.2 : misra c++2008 7-5-4
+                1901) # misra-c2012-19.1 : misra c++2008 2-13-3
+
+            if (not self.is_cpp) or rule_num in misra_cpp:
+                # log checker
+                errmsg = 'Misra C: %i.%i' % (rule_num // 100, rule_num % 100)
+                cppcheckdata.log_checker(errmsg, 'misra')
+
+                check_function(*args)
+
+    def parseDump(self, dumpfile, path_premium_addon=None):
+        def fillVerifyExpected(verify_expected, tok):
+            """Add expected suppressions to verify_expected list."""
+            rule_re = re.compile(r'[0-9]+\.[0-9]+')
+            if tok.str.startswith('//') and 'TODO' not in tok.str:
+                for word in tok.str[2:].split(' '):
+                    if rule_re.match(word) or word == "config":
+                        verify_expected.append('%s:%d %s' % (tok.file, tok.linenr, word))
 
+        data = cppcheckdata.parsedump(dumpfile)
         typeBits['CHAR'] = data.platform.char_bit
         typeBits['SHORT'] = data.platform.short_bit
         typeBits['INT'] = data.platform.int_bit
@@ -2375,112 +4666,329 @@ def parseDump(self, dumpfile):
         typeBits['POINTER'] = data.platform.pointer_bit
 
         if self.settings.verify:
+            # Add suppressions from the current file
             for tok in data.rawTokens:
-                if tok.str.startswith('//') and 'TODO' not in tok.str:
-                    compiled = re.compile(r'[0-9]+\.[0-9]+')
-                    for word in tok.str[2:].split(' '):
-                        if compiled.match(word):
-                            self.verify_expected.append(str(tok.linenr) + ':' + word)
+                fillVerifyExpected(self.verify_expected, tok)
+            # Add suppressions from the included headers
+            include_re = re.compile(r'^#include [<"]([a-zA-Z0-9]+[a-zA-Z\-_./\\0-9]*)[">]$')
+            dump_dir = os.path.dirname(data.filename)
+            for conf in data.configurations:
+                for directive in conf.directives:
+                    m = re.match(include_re, directive.str)
+                    if not m:
+                        continue
+                    header_dump_path = os.path.join(dump_dir, m.group(1) + '.dump')
+                    if not os.path.exists(header_dump_path):
+                        continue
+                    header_data = cppcheckdata.parsedump(header_dump_path)
+                    for tok in header_data.rawTokens:
+                        fillVerifyExpected(self.verify_expected, tok)
         else:
             self.printStatus('Checking ' + dumpfile + '...')
 
-        cfgNumber = 0
-
-        for cfg in data.configurations:
-            cfgNumber = cfgNumber + 1
-            if len(data.configurations) > 1:
-                self.printStatus('Checking ' + dumpfile + ', config "' + cfg.name + '"...')
-
-            if cfgNumber == 1:
-                self.misra_3_1(data.rawTokens)
-                self.misra_4_1(data.rawTokens)
-            self.misra_5_1(cfg)
-            self.misra_5_2(cfg)
-            self.misra_5_3(cfg)
-            self.misra_5_4(cfg)
-            self.misra_5_5(cfg)
-            # 6.1 require updates in Cppcheck (type info for bitfields are lost)
-            # 6.2 require updates in Cppcheck (type info for bitfields are lost)
-            if cfgNumber == 1:
-                self.misra_7_1(data.rawTokens)
-                self.misra_7_3(data.rawTokens)
-            self.misra_8_11(cfg)
-            self.misra_8_12(cfg)
-            if cfgNumber == 1:
-                self.misra_8_14(data.rawTokens)
-                self.misra_9_5(data.rawTokens)
-            self.misra_10_1(cfg)
-            self.misra_10_4(cfg)
-            self.misra_10_6(cfg)
-            self.misra_10_8(cfg)
-            self.misra_11_3(cfg)
-            self.misra_11_4(cfg)
-            self.misra_11_5(cfg)
-            self.misra_11_6(cfg)
-            self.misra_11_7(cfg)
-            self.misra_11_8(cfg)
-            self.misra_11_9(cfg)
-            if cfgNumber == 1:
-                self.misra_12_1_sizeof(data.rawTokens)
-            self.misra_12_1(cfg)
-            self.misra_12_2(cfg)
-            self.misra_12_3(cfg)
-            self.misra_12_4(cfg)
-            self.misra_13_1(cfg)
-            self.misra_13_3(cfg)
-            self.misra_13_4(cfg)
-            self.misra_13_5(cfg)
-            self.misra_13_6(cfg)
-            self.misra_14_1(cfg)
-            self.misra_14_2(cfg)
-            self.misra_14_4(cfg)
-            self.misra_15_1(cfg)
-            self.misra_15_2(cfg)
-            self.misra_15_3(cfg)
-            self.misra_15_5(cfg)
-            if cfgNumber == 1:
-                self.misra_15_6(data.rawTokens)
-            self.misra_15_7(cfg)
-            self.misra_16_2(cfg)
-            if cfgNumber == 1:
-                self.misra_16_3(data.rawTokens)
-            self.misra_16_4(cfg)
-            self.misra_16_5(cfg)
-            self.misra_16_6(cfg)
-            self.misra_16_7(cfg)
-            self.misra_17_1(cfg)
-            self.misra_17_2(cfg)
-            if cfgNumber == 1:
-                self.misra_17_6(data.rawTokens)
-            self.misra_17_7(cfg)
-            self.misra_17_8(cfg)
-            self.misra_18_4(cfg)
-            self.misra_18_5(cfg)
-            self.misra_18_7(cfg)
-            self.misra_18_8(cfg)
-            self.misra_19_2(cfg)
-            self.misra_20_1(cfg)
-            self.misra_20_2(cfg)
-            if cfgNumber == 1:
-                self.misra_20_3(data.rawTokens)
-            self.misra_20_4(cfg)
-            self.misra_20_5(cfg)
-            self.misra_20_7(cfg)
-            self.misra_20_10(cfg)
-            self.misra_20_13(cfg)
-            self.misra_20_14(cfg)
-            self.misra_21_3(cfg)
-            self.misra_21_4(cfg)
-            self.misra_21_5(cfg)
-            self.misra_21_6(cfg)
-            self.misra_21_7(cfg)
-            self.misra_21_8(cfg)
-            self.misra_21_9(cfg)
-            self.misra_21_10(cfg)
-            self.misra_21_11(cfg)
+        self.is_cpp = data.language == 'cpp'
+
+        for cfgNumber, cfg in enumerate(data.iterconfigurations()):
+            if not self.settings.quiet:
+                self.printStatus('Checking %s, config %s...' % (dumpfile, cfg.name))
+
+            self.executeCheck(102, self.misra_1_2, cfg)
+            if not path_premium_addon:
+                self.executeCheck(104, self.misra_1_4, cfg)
+            self.executeCheck(202, self.misra_2_2, cfg)
+            self.executeCheck(203, self.misra_2_3, dumpfile, cfg.typedefInfo)
+            self.executeCheck(204, self.misra_2_4, dumpfile, cfg)
+            self.executeCheck(205, self.misra_2_5, dumpfile, cfg)
+            self.executeCheck(207, self.misra_2_7, cfg)
+            # data.rawTokens is same for all configurations
+            if cfgNumber == 0:
+                self.executeCheck(301, self.misra_3_1, data.rawTokens)
+                #self.executeCheck(302, self.misra_3_2, data.rawTokens)
+                self.executeCheck(401, self.misra_4_1, data.rawTokens)
+                self.executeCheck(402, self.misra_4_2, data.rawTokens)
+            self.executeCheck(501, self.misra_5_1, cfg)
+            self.executeCheck(502, self.misra_5_2, cfg)
+            self.executeCheck(504, self.misra_5_4, cfg)
+            self.executeCheck(505, self.misra_5_5, cfg)
+            self.executeCheck(506, self.misra_5_6, dumpfile, cfg.typedefInfo)
+            self.executeCheck(507, self.misra_5_7, dumpfile, cfg)
+            self.executeCheck(508, self.misra_5_8, dumpfile, cfg)
+            self.executeCheck(509, self.misra_5_9, dumpfile, cfg)
+            self.executeCheck(601, self.misra_6_1, cfg)
+            self.executeCheck(602, self.misra_6_2, cfg)
+            if cfgNumber == 0:
+                self.executeCheck(701, self.misra_7_1, data.rawTokens)
+            self.executeCheck(702, self.misra_7_2, cfg)
+            if cfgNumber == 0:
+                self.executeCheck(703, self.misra_7_3, data.rawTokens)
+            self.executeCheck(704, self.misra_7_4, cfg)
+            self.executeCheck(801, self.misra_8_1, cfg)
+            if cfgNumber == 0:
+                self.executeCheck(802, self.misra_8_2, cfg, data.rawTokens)
+            self.executeCheck(804, self.misra_8_4, cfg)
+            self.executeCheck(805, self.misra_8_5, dumpfile, cfg)
+            self.executeCheck(806, self.misra_8_6, dumpfile, cfg)
+            self.executeCheck(807, self.misra_8_7, dumpfile, cfg)
+            self.executeCheck(808, self.misra_8_8, cfg)
+            self.executeCheck(809, self.misra_8_9, cfg)
+            self.executeCheck(810, self.misra_8_10, cfg)
+            self.executeCheck(811, self.misra_8_11, cfg)
+            self.executeCheck(812, self.misra_8_12, cfg)
+            if cfgNumber == 0:
+                self.executeCheck(814, self.misra_8_14, data.rawTokens)
+            self.executeCheck(902, self.misra_9_2, cfg)
+            self.executeCheck(903, self.misra_9_3, cfg)
+            self.executeCheck(904, self.misra_9_4, cfg)
+            if cfgNumber == 0:
+                self.executeCheck(905, self.misra_9_5, cfg, data.rawTokens)
+            if not path_premium_addon:
+                self.executeCheck(1001, self.misra_10_1, cfg)
+                self.executeCheck(1002, self.misra_10_2, cfg)
+                self.executeCheck(1003, self.misra_10_3, cfg)
+                self.executeCheck(1004, self.misra_10_4, cfg)
+                self.executeCheck(1005, self.misra_10_5, cfg)
+                self.executeCheck(1006, self.misra_10_6, cfg)
+                self.executeCheck(1007, self.misra_10_7, cfg)
+                self.executeCheck(1008, self.misra_10_8, cfg)
+            self.executeCheck(1101, self.misra_11_1, cfg)
+            self.executeCheck(1102, self.misra_11_2, cfg)
+            self.executeCheck(1103, self.misra_11_3, cfg)
+            self.executeCheck(1104, self.misra_11_4, cfg)
+            self.executeCheck(1105, self.misra_11_5, cfg)
+            self.executeCheck(1106, self.misra_11_6, cfg)
+            self.executeCheck(1107, self.misra_11_7, cfg)
+            self.executeCheck(1108, self.misra_11_8, cfg)
+            self.executeCheck(1109, self.misra_11_9, cfg)
+            if cfgNumber == 0:
+                self.executeCheck(1201, self.misra_12_1_sizeof, data.rawTokens)
+            self.executeCheck(1201, self.misra_12_1, cfg)
+            self.executeCheck(1202, self.misra_12_2, cfg)
+            self.executeCheck(1203, self.misra_12_3, cfg)
+            self.executeCheck(1204, self.misra_12_4, cfg)
+            self.executeCheck(1301, self.misra_13_1, cfg)
+            self.executeCheck(1303, self.misra_13_3, cfg)
+            self.executeCheck(1304, self.misra_13_4, cfg)
+            self.executeCheck(1305, self.misra_13_5, cfg)
+            self.executeCheck(1306, self.misra_13_6, cfg)
+            self.executeCheck(1401, self.misra_14_1, cfg)
+            self.executeCheck(1402, self.misra_14_2, cfg)
+            self.executeCheck(1404, self.misra_14_4, cfg)
+            self.executeCheck(1501, self.misra_15_1, cfg)
+            self.executeCheck(1502, self.misra_15_2, cfg)
+            self.executeCheck(1503, self.misra_15_3, cfg)
+            self.executeCheck(1504, self.misra_15_4, cfg)
+            self.executeCheck(1505, self.misra_15_5, cfg)
+            if cfgNumber == 0:
+                self.executeCheck(1506, self.misra_15_6, data.rawTokens)
+            self.executeCheck(1507, self.misra_15_7, cfg)
+            self.executeCheck(1601, self.misra_16_1, cfg)
+            self.executeCheck(1602, self.misra_16_2, cfg)
+            if cfgNumber == 0:
+                self.executeCheck(1603, self.misra_16_3, data.rawTokens)
+            self.executeCheck(1604, self.misra_16_4, cfg)
+            self.executeCheck(1605, self.misra_16_5, cfg)
+            self.executeCheck(1606, self.misra_16_6, cfg)
+            self.executeCheck(1607, self.misra_16_7, cfg)
+            self.executeCheck(1701, self.misra_17_1, cfg)
+            self.executeCheck(1702, self.misra_17_2, cfg)
+            self.executeCheck(1703, self.misra_17_3, cfg)
+            self.misra_config(cfg)
+            if cfgNumber == 0:
+                self.executeCheck(1706, self.misra_17_6, data.rawTokens)
+            self.executeCheck(1707, self.misra_17_7, cfg)
+            self.executeCheck(1708, self.misra_17_8, cfg)
+            self.executeCheck(1804, self.misra_18_4, cfg)
+            self.executeCheck(1805, self.misra_18_5, cfg)
+            self.executeCheck(1807, self.misra_18_7, cfg)
+            self.executeCheck(1808, self.misra_18_8, cfg)
+            self.executeCheck(1902, self.misra_19_2, cfg)
+            self.executeCheck(2001, self.misra_20_1, cfg)
+            self.executeCheck(2002, self.misra_20_2, cfg)
+            self.executeCheck(2003, self.misra_20_3, cfg)
+            self.executeCheck(2004, self.misra_20_4, cfg)
+            self.executeCheck(2005, self.misra_20_5, cfg)
+            self.executeCheck(2007, self.misra_20_7, cfg)
+            self.executeCheck(2008, self.misra_20_8, cfg)
+            self.executeCheck(2009, self.misra_20_9, cfg)
+            self.executeCheck(2010, self.misra_20_10, cfg)
+            self.executeCheck(2011, self.misra_20_11, cfg)
+            self.executeCheck(2012, self.misra_20_12, cfg)
+            self.executeCheck(2013, self.misra_20_13, cfg)
+            self.executeCheck(2014, self.misra_20_14, cfg)
+            self.executeCheck(2101, self.misra_21_1, cfg)
+            self.executeCheck(2102, self.misra_21_2, cfg)
+            self.executeCheck(2103, self.misra_21_3, cfg)
+            self.executeCheck(2104, self.misra_21_4, cfg)
+            self.executeCheck(2105, self.misra_21_5, cfg)
+            self.executeCheck(2106, self.misra_21_6, cfg)
+            self.executeCheck(2107, self.misra_21_7, cfg)
+            self.executeCheck(2108, self.misra_21_8, cfg)
+            self.executeCheck(2109, self.misra_21_9, cfg)
+            self.executeCheck(2110, self.misra_21_10, cfg)
+            self.executeCheck(2111, self.misra_21_11, cfg)
+            self.executeCheck(2112, self.misra_21_12, cfg)
+            self.executeCheck(2114, self.misra_21_14, cfg)
+            self.executeCheck(2115, self.misra_21_15, cfg)
+            self.executeCheck(2116, self.misra_21_16, cfg)
+            self.executeCheck(2119, self.misra_21_19, cfg)
+            self.executeCheck(2120, self.misra_21_20, cfg)
+            self.executeCheck(2121, self.misra_21_21, cfg)
             # 22.4 is already covered by Cppcheck writeReadOnlyFile
+            self.executeCheck(2205, self.misra_22_5, cfg)
+            self.executeCheck(2207, self.misra_22_7, cfg)
+            self.executeCheck(2208, self.misra_22_8, cfg)
+            self.executeCheck(2209, self.misra_22_9, cfg)
+            self.executeCheck(2210, self.misra_22_10, cfg)
+
+    def read_ctu_info_line(self, line):
+        if not line.startswith('{'):
+            return None
+        try:
+            ctu_info = json.loads(line)
+        except json.decoder.JSONDecodeError:
+            return None
+        if 'summary' not in ctu_info:
+            return None
+        if 'data' not in ctu_info:
+            return None
+        return ctu_info
+
+    def analyse_ctu_info(self, ctu_info_files):
+        all_typedef_info = {}
+        all_tagname_info = {}
+        all_macro_info = {}
+        all_external_identifiers_decl = {}
+        all_external_identifiers_def = {}
+        all_internal_identifiers = {}
+        all_local_identifiers = {}
+        all_usage_files = {}
+
+        from cppcheckdata import Location
 
+        def is_different_location(loc1, loc2):
+            return loc1['file'] != loc2['file'] or loc1['line'] != loc2['line']
 
+        def is_different_file(loc1, loc2):
+            return loc1['file'] != loc2['file']
+
+        try:
+            for filename in ctu_info_files:
+                for line in open(filename, 'rt'):
+                    s = self.read_ctu_info_line(line)
+                    if s is None:
+                        continue
+                    summary_type = s.get('summary', '')
+                    summary_data = s.get('data', None)
+
+                    if summary_type == 'MisraTypedefInfo':
+                        for new_typedef_info in summary_data:
+                            key = new_typedef_info['name']
+                            existing_typedef_info = all_typedef_info.get(key, None)
+                            if existing_typedef_info:
+                                if is_different_location(existing_typedef_info, new_typedef_info):
+                                    self.reportError(Location(existing_typedef_info), 5, 6)
+                                    self.reportError(Location(new_typedef_info), 5, 6)
+                                else:
+                                    existing_typedef_info['used'] = existing_typedef_info['used'] or new_typedef_info['used']
+                            else:
+                                all_typedef_info[key] = new_typedef_info
+
+                    if summary_type == 'MisraTagName':
+                        for new_tagname_info in summary_data:
+                            key = new_tagname_info['name']
+                            existing_tagname_info = all_tagname_info.get(key, None)
+                            if existing_tagname_info:
+                                if is_different_location(existing_tagname_info, new_tagname_info):
+                                    self.reportError(Location(existing_tagname_info), 5, 7)
+                                    self.reportError(Location(new_tagname_info), 5, 7)
+                                else:
+                                    existing_tagname_info['used'] = existing_tagname_info['used'] or new_tagname_info['used']
+                            else:
+                                all_tagname_info[key] = new_tagname_info
+
+                    if summary_type == 'MisraMacro':
+                        for new_macro in summary_data:
+                            key = new_macro['name']
+                            existing_macro = all_macro_info.get(key, None)
+                            if existing_macro:
+                                existing_macro['used'] = existing_macro['used'] or new_macro['used']
+                            else:
+                                all_macro_info[key] = new_macro
+
+                    if summary_type == 'MisraExternalIdentifiers':
+                        for s in sorted(summary_data, key=lambda d: "%s %s %s" %(d['file'],d['line'], d['column'] )):
+                            is_declaration = s['decl']
+                            if is_declaration:
+                                all_external_identifiers = all_external_identifiers_decl
+                            else:
+                                all_external_identifiers = all_external_identifiers_def
+
+                            name = s['name']
+                            if name in all_external_identifiers:
+                                if is_declaration and is_different_location(s, all_external_identifiers[name]):
+                                    self.reportError(Location(s), 8, 5)
+                                    self.reportError(Location(all_external_identifiers[name]), 8, 5)
+                                elif is_different_file(s, all_external_identifiers[name]):
+                                    self.reportError(Location(s), 8, 6)
+                                    self.reportError(Location(all_external_identifiers[name]), 8, 6)
+                            all_external_identifiers[name] = s
+
+                    if summary_type == 'MisraInternalIdentifiers':
+                        for s in summary_data:
+                            if s['name'] in all_internal_identifiers:
+                                if not s['inlinefunc'] or s['file'] != all_internal_identifiers[s['name']]['file']:
+                                    self.reportError(Location(s), 5, 9)
+                                    self.reportError(Location(all_internal_identifiers[s['name']]), 5, 9)
+                            all_internal_identifiers[s['name']] = s
+
+                    if summary_type == 'MisraLocalIdentifiers':
+                        for s in summary_data:
+                            all_local_identifiers[s['name']] = s
+
+                    if summary_type == 'MisraUsage':
+                        for s in summary_data:
+                            if s['name'] in all_usage_files:
+                                all_usage_files[s['name']].append(s['file'])
+                            else:
+                                all_usage_files[s['name']] = [s['file']]
+
+        except FileNotFoundError:
+            return
+
+        unused_typedefs = [tdi for tdi in all_typedef_info.values() if not tdi['used']]
+        for tdi in unused_typedefs:
+            self.reportError(Location(tdi), 2, 3)
+
+        unused_tags = [tag for tag in all_tagname_info.values() if not tag['used']]
+        for tag in unused_tags:
+            self.reportError(Location(tag), 2, 4)
+
+        unused_macros = [m for m in all_macro_info.values() if not m['used']]
+        for m in unused_macros:
+            self.reportError(Location(m), 2, 5)
+
+        all_external_identifiers = all_external_identifiers_decl
+        all_external_identifiers.update(all_external_identifiers_def)
+        for name, external_identifier in all_external_identifiers.items():
+            internal_identifier = all_internal_identifiers.get(name)
+            if internal_identifier:
+                self.reportError(Location(internal_identifier), 5, 8)
+                self.reportError(Location(external_identifier), 5, 8)
+
+            local_identifier = all_local_identifiers.get(name)
+            if local_identifier:
+                self.reportError(Location(local_identifier), 5, 8)
+                self.reportError(Location(external_identifier), 5, 8)
+
+        for name, files in all_usage_files.items():
+            #print('%s:%i' % (name, count))
+            count = len(files)
+            if count != 1 or name not in all_external_identifiers_def:
+                continue
+            if files[0] != Location(all_external_identifiers_def[name]).file:
+                continue
+            if name in all_external_identifiers:
+                self.reportError(Location(all_external_identifiers[name]), 8, 7)
 
 RULE_TEXTS_HELP = '''Path to text file of MISRA rules
 
@@ -2498,10 +5006,12 @@ def parseDump(self, dumpfile):
 
 <..arbitrary text..>
 Appendix A Summary of guidelines
-Rule 1.1
+Rule 1.1 Required
 Rule text for 1.1
-Rule 1.2
+continuation of rule text for 1.1
+Rule 1.2 Mandatory
 Rule text for 1.2
+continuation of rule text for 1.2
 <...>
 
 '''
@@ -2516,28 +5026,31 @@ def parseDump(self, dumpfile):
 '''
 
 
-def get_args():
+def get_args_parser():
     """Generates list of command-line arguments acceptable by misra.py script."""
     parser = cppcheckdata.ArgumentParser()
     parser.add_argument("--rule-texts", type=str, help=RULE_TEXTS_HELP)
-    parser.add_argument("--verify-rule-texts", help="Verify that all supported rules texts are present in given file and exit.", action="store_true")
+    parser.add_argument("--verify-rule-texts",
+                        help="Verify that all supported rules texts are present in given file and exit.",
+                        action="store_true")
     parser.add_argument("--suppress-rules", type=str, help=SUPPRESS_RULES_HELP)
-    parser.add_argument("--quiet", help="Only print something when there is an error", action="store_true")
     parser.add_argument("--no-summary", help="Hide summary of violations", action="store_true")
-    parser.add_argument("-verify", help=argparse.SUPPRESS, action="store_true")
-    parser.add_argument("-generate-table", help=argparse.SUPPRESS, action="store_true")
-    parser.add_argument("dumpfile", nargs='*', help="Path of dump file from cppcheck")
     parser.add_argument("--show-suppressed-rules", help="Print rule suppression list", action="store_true")
     parser.add_argument("-P", "--file-prefix", type=str, help="Prefix to strip when matching suppression file rules")
-    parser.add_argument("--cli", help="Addon is executed from Cppcheck", action="store_true")
-    return parser.parse_args()
+    parser.add_argument("-generate-table", help=argparse.SUPPRESS, action="store_true")
+    parser.add_argument("-verify", help=argparse.SUPPRESS, action="store_true")
+    parser.add_argument("--severity", type=str, help="Set a custom severity string, for example 'error' or 'warning'. ")
+    return parser
 
 
 def main():
-    args = get_args()
+    parser = get_args_parser()
+    args = parser.parse_args()
     settings = MisraSettings(args)
     checker = MisraChecker(settings)
 
+    checker.path_premium_addon = cppcheckdata.get_path_premium_addon()
+
     if args.generate_table:
         generateTable()
         sys.exit(0)
@@ -2545,13 +5058,17 @@ def main():
     if args.rule_texts:
         filename = os.path.expanduser(args.rule_texts)
         filename = os.path.normpath(filename)
-        if not os.path.isfile(filename):
-            print('Fatal error: file is not found: ' + filename)
-            sys.exit(1)
-        checker.loadRuleTexts(filename)
-        if args.verify_rule_texts:
-            checker.verifyRuleTexts()
-            sys.exit(0)
+        checker.ruleText_filename = filename
+        if os.path.isfile(filename):
+            checker.loadRuleTexts(filename)
+            if args.verify_rule_texts:
+                checker.verifyRuleTexts()
+                sys.exit(0)
+        else:
+            if args.verify_rule_texts:
+                print('Fatal error: file is not found: ' + filename)
+                sys.exit(1)
+
 
     if args.verify_rule_texts and not args.rule_texts:
         print("Error: Please specify rule texts file with --rule-texts=<file>")
@@ -2563,64 +5080,74 @@ def main():
     if args.file_prefix:
         checker.setFilePrefix(args.file_prefix)
 
-    if args.dumpfile:
-        exitCode = 0
-        for item in args.dumpfile:
-            checker.parseDump(item)
-
-            if settings.verify:
-                verify_expected = checker.get_verify_expected()
-                verify_actual   = checker.get_verify_actual()
-
-                for expected in verify_expected:
-                    if expected not in verify_actual:
-                        print('Expected but not seen: ' + expected)
-                        exitCode = 1
-                for actual in verify_actual:
-                    if actual not in verify_expected:
-                        print('Not expected: ' + actual)
-                        exitCode = 1
-
-                # Existing behavior of verify mode is to exit
-                # on the first un-expected output.
-                # TODO: Is this required? or can it be moved to after
-                # all input files have been processed
-                if exitCode != 0:
-                    sys.exit(exitCode)
-
-        # Under normal operation exit with a non-zero exit code
-        # if there were any violations.
-        if not settings.verify:
-            number_of_violations = len(checker.get_violations())
-            if number_of_violations > 0:
-                exitCode = 1
-
-                if settings.show_summary:
-                    print("\nMISRA rules violations found:\n\t%s\n" % ("\n\t".join([ "%s: %d" % (viol, len(checker.get_violations(viol))) for viol in checker.get_violation_types()])))
-
-                    rules_violated = {}
-                    for severity, ids in checker.get_violations():
-                        for misra_id in ids:
-                            rules_violated[misra_id] = rules_violated.get(misra_id, 0) + 1
-                    print("MISRA rules violated:")
-                    convert = lambda text: int(text) if text.isdigit() else text
-                    misra_sort = lambda key: [ convert(c) for c in re.split('[\.-]([0-9]*)', key) ]
-                    for misra_id in sorted(rules_violated.keys(), key=misra_sort):
-                        res = re.match(r'misra-c2012-([0-9]+)\\.([0-9]+)', misra_id)
-                        if res is None:
-                            num = 0
-                        else:
-                            num = int(res.group(1)) * 100 + int(res.group(2))
-                        severity = '-'
-                        if num in checker.ruleTexts:
-                            severity = checker.ruleTexts[num].cppcheck_severity
-                        print("\t%15s (%s): %d" % (misra_id, severity, rules_violated[misra_id]))
+    dump_files, ctu_info_files = cppcheckdata.get_files(args)
+
+    if (not dump_files) and (not ctu_info_files):
+        if not args.quiet:
+            print("No input files.")
+        sys.exit(0)
 
-        if args.show_suppressed_rules:
-            checker.showSuppressedRules()
+    if args.severity:
+        checker.setSeverity(args.severity)
 
+    for item in dump_files:
+        checker.parseDump(item,checker.path_premium_addon)
+
+        if settings.verify:
+            verify_expected = checker.get_verify_expected()
+            verify_actual = checker.get_verify_actual()
+
+            exitCode = 0
+            for expected in verify_expected:
+                if expected not in verify_actual:
+                    print('Expected but not seen: ' + expected)
+                    exitCode = 1
+            for actual in verify_actual:
+                if actual not in verify_expected:
+                    print('Not expected: ' + actual)
+                    exitCode = 1
+
+            # Existing behavior of verify mode is to exit
+            # on the first un-expected output.
+            # TODO: Is this required? or can it be moved to after
+            # all input files have been processed
+            if exitCode != 0:
+                sys.exit(exitCode)
+
+    checker.analyse_ctu_info(ctu_info_files)
+
+    if settings.verify:
         sys.exit(exitCode)
 
+    number_of_violations = len(checker.get_violations())
+    if number_of_violations > 0:
+        if settings.show_summary:
+            print("\nMISRA rules violations found:\n\t%s\n" % (
+                "\n\t".join(["%s: %d" % (viol, len(checker.get_violations(viol))) for viol in
+                             checker.get_violation_types()])))
+
+            rules_violated = {}
+            for severity, ids in checker.get_violations():
+                for misra_id in ids:
+                    rules_violated[misra_id] = rules_violated.get(misra_id, 0) + 1
+            print("MISRA rules violated:")
+            convert = lambda text: int(text) if text.isdigit() else 0
+            misra_sort = lambda key: [convert(c) for c in re.split(r'[\.-]([0-9]*)', key)]
+            for misra_id in sorted(rules_violated.keys(), key=misra_sort):
+                res = re.match(r'misra-c2012-([0-9]+)\\.([0-9]+)', misra_id)
+                if res is None:
+                    num = 0
+                else:
+                    num = int(res.group(1)) * 100 + int(res.group(2))
+                severity = '-'
+                if num in checker.ruleTexts:
+                    severity = checker.ruleTexts[num].cppcheck_severity
+                print("\t%15s (%s): %d" % (misra_id, severity, rules_violated[misra_id]))
+
+    if args.show_suppressed_rules:
+        checker.showSuppressedRules()
+
 
 if __name__ == '__main__':
     main()
+    sys.exit(cppcheckdata.EXIT_CODE)
diff --git a/addons/misra_9.py b/addons/misra_9.py
new file mode 100644
index 00000000000..1ca1b7ce3e0
--- /dev/null
+++ b/addons/misra_9.py
@@ -0,0 +1,559 @@
+# Holds information about an array, struct or union's element definition.
+class ElementDef:
+    def __init__(self, elementType, name, valueType, dimensions = None):
+        self.elementType = elementType      # 'array', 'record' or 'value'
+        self.name = str(name)
+        self.valueType = valueType
+        self.children = []
+        self.dimensions = dimensions
+        self.parent = None
+
+        self.isDesignated = False
+        self.isPositional = False
+        self.numInits = 0
+        self.childIndex = -1
+
+        self.flexibleToken = None
+        self.isFlexible = False
+        self.structureViolationToken = None
+
+    def __repr__(self):
+        inits = ""
+        if self.isPositional:
+            inits += 'P'
+        if self.isDesignated:
+            inits += 'D'
+        if not (self.isPositional or self.isDesignated) and self.numInits == 0:
+            inits += '_'
+        if self.numInits > 1:
+            inits += str(self.numInits)
+
+        attrs = ["childIndex", "elementType", "valueType"]
+        return "{}({}, {}, {})".format(
+            "ElementDef",
+            self.getLongName(),
+            inits,
+            ", ".join(("{}={}".format(a, repr(getattr(self, a))) for a in attrs))
+        )
+
+    @property
+    def isArray(self):
+        return self.elementType == 'array'
+
+    @property
+    def isRecord(self):
+        return self.elementType == 'record'
+
+    @property
+    def isValue(self):
+        return self.elementType == 'value'
+
+
+    def getLongName(self):
+        return self.parent.getLongName() + "." + self.name if self.parent else self.name
+
+    def getInitDump(self):
+        t = []
+        if self.isPositional:
+            t.append('P')
+        if self.isDesignated:
+            t.append('D')
+        if self.numInits == 0:
+            t.append('_')
+        if self.numInits > 1:
+            t.append(str(self.numInits))
+
+        myDump = "".join(t)
+
+        if len(self.children):
+            childDumps = []
+            for c in self.children:
+                childDumps.append(c.getInitDump())
+            if self.structureViolationToken is not None:
+                myDump += "!"
+            myDump += "{ " + ", ".join(childDumps) + " }"
+
+        return myDump
+
+    def addChild(self, child):
+        self.children.append(child)
+        child.parent = self
+
+    def getNextChild(self):
+        self.childIndex += 1
+        return self.getChildByIndex(self.childIndex)
+
+    def getChildByIndex(self, index):
+        if self.isFlexible:
+            while len(self.children) <= index:
+                createChild(self, self.flexibleToken, len(self.children), None)
+        return self.children[index] if 0 <= index < len(self.children) else None
+
+    def getChildByName(self, name):
+        for c in self.children:
+            if c.name == name:
+                return c
+        return None
+
+    def getNextValueElement(self, root):
+        current = self
+        while current != root:
+            if not current.parent:
+                return None
+            # Get next index of parent
+            i = current.parent.children.index(current) + 1
+            # Next index of parent exists
+            if i < len(current.parent.children):
+                current = current.parent.children[i]
+                return current.getFirstValueElement()
+
+            # Next index of parent doesn't exist. Move up
+            current = current.parent
+        return None
+
+    def getFirstValueElement(self):
+        current = self
+
+        # Move to first child as long as children exists
+        next_child = current.getChildByIndex(0)
+        while next_child:
+            current = next_child
+            next_child = current.getChildByIndex(0)
+        return current
+
+    def getLastValueElement(self):
+        current = self
+        # Move to last child as long as children exists
+        while len(current.children) > 0:
+            current = current.children[-1]
+        return current
+
+    def getChildByValueElement(self, ed):
+        potentialChild = ed
+        while potentialChild and potentialChild not in self.children:
+            potentialChild = potentialChild.parent
+
+        return self.children[self.children.index(potentialChild)] if potentialChild else None
+
+    def getEffectiveLevel(self):
+        if self.parent and self.parent.elementType == "array":
+            return self.parent.getEffectiveLevel() + 1
+        return 0
+
+    def setInitialized(self, designated=False, positional=False):
+        if designated:
+            self.isDesignated = True
+        if positional or not designated:
+            self.isPositional = True
+        self.numInits += 1
+
+    def initializeChildren(self):
+        for child in self.children:
+            child.setInitialized(positional=True)
+            child.initializeChildren()
+
+    def unset(self):
+        self.isDesignated = False
+        self.isPositional = False
+
+        # Unset is always recursive
+        for child in self.children:
+            child.unset()
+
+    def markStuctureViolation(self, token):
+        if self.name == '->':
+            self.children[0].markStuctureViolation(token)
+        elif not self.structureViolationToken:
+            self.structureViolationToken = token
+
+    def markAsFlexibleArray(self, token):
+        self.flexibleToken = token
+        self.isFlexible = True
+
+    def markAsCurrent(self):
+        if self.parent:
+            if self.name == '<-':
+                self.parent.childIndex = self.parent.children.index(self.children[0])
+            else:
+                self.parent.childIndex = self.parent.children.index(self)
+
+            self.parent.markAsCurrent()
+
+    def isAllChildrenSet(self):
+        myself = len(self.children) == 0 and (self.isDesignated or self.isPositional)
+        mychildren = len(self.children) > 0 and all([child.isAllChildrenSet() for child in self.children])
+        return myself or mychildren
+
+    def isAllSet(self):
+        return all([child.isPositional or child.isDesignated for child in self.children])
+
+    def isOnlyDesignated(self):
+        return all([not child.isPositional for child in self.children])
+
+    def isMisra92Compliant(self):
+        return self.structureViolationToken is None and all([child.isMisra92Compliant() for child in self.children])
+
+    def isMisra93Compliant(self):
+        if self.elementType == 'array':
+            result = self.isAllChildrenSet() or \
+                ((self.isAllSet() or
+                  self.isOnlyDesignated()) and
+                 all([not (child.isDesignated or child.isPositional) or child.isMisra93Compliant() for child in self.children]))
+            return result
+        if self.elementType == 'record':
+            result = all([child.isMisra93Compliant() for child in self.children])
+            return result
+        return True
+
+    def isMisra94Compliant(self):
+        return self.numInits <= 1 and all([child.isMisra94Compliant() for child in self.children])
+
+    def isMisra95Compliant(self):
+        return not self.isFlexible or all([not child.isDesignated for child in self.children])
+
+# Parses the initializers and update the ElementDefs status accordingly
+class InitializerParser:
+    def __init__(self):
+        self.token = None
+        self.root = None
+        self.ed = None
+        self.rootStack = []
+
+    def parseInitializer(self, root, token):
+        self.root = root
+        self.token = token
+        dummyRoot = ElementDef('array', '->', self.root.valueType)
+        dummyRoot.children = [self.root]
+
+        self.rootStack = []
+        self.root = dummyRoot
+        self.ed = self.root.getFirstValueElement()
+        isFirstElement = False
+        isDesignated = False
+
+        while self.token:
+            if self.token.str == ',':
+                self.token = self.token.astOperand1
+                isFirstElement = False
+
+            # Designated initializer ( [2]=...  or .name=... )
+            elif self.token.isAssignmentOp and not self.token.valueType:
+                self.popFromStackIfExitElement()
+
+                self.ed = getElementByDesignator(self.root, self.token.astOperand1)
+                if self.ed:
+                    # Update root
+                    self.pushToRootStackAndMarkAsDesignated()
+                    # Make sure ed points to valueElement
+                    self.ed = self.ed.getFirstValueElement()
+
+                self.token = self.token.astOperand2
+                isFirstElement = False
+                isDesignated = True
+
+            elif self.token.isString and self.ed and self.ed.isArray:
+                self.ed.setInitialized(isDesignated)
+                if self.token == self.token.astParent.astOperand1 and self.token.astParent.astOperand2:
+                    self.token = self.token.astParent.astOperand2
+                    self.ed.markAsCurrent()
+                    self.ed = self.root.getNextChild()
+                else:
+                    self.unwindAndContinue()
+                continue
+
+            elif self.token.str == '{':
+                nextChild = self.root.getNextChild() if self.root is not None else None
+
+                if nextChild:
+                    if nextChild.isArray or nextChild.isRecord:
+                        nextChild.unset()
+                        nextChild.setInitialized(isDesignated)
+                        self.ed = nextChild.getFirstValueElement()
+                        isDesignated = False
+                    elif nextChild.valueType is None:
+                        # No type information available - unable to check structure - assume correct initialization
+                        nextChild.setInitialized(isDesignated)
+                        self.unwindAndContinue()
+                        continue
+
+                    elif self.token.astOperand1:
+                        # Create dummy nextChild to represent excess levels in initializer
+                        dummyRoot = ElementDef('array', '<-', self.root.valueType)
+                        dummyRoot.parent = self.root
+                        dummyRoot.childIndex = 0
+                        dummyRoot.children = [nextChild]
+                        nextChild.parent = dummyRoot
+
+                        self.root.markStuctureViolation(self.token)
+
+                        # Fake dummy as nextChild (of current root)
+                        nextChild = dummyRoot
+
+                if nextChild and self.token.astOperand1:
+                    self.root = nextChild
+                    self.token = self.token.astOperand1
+                    isFirstElement = True
+                else:
+                    if self.root:
+                        # {}
+                        if self.root.name == '<-':
+                            self.root.parent.markStuctureViolation(self.token)
+                        else:
+                            self.root.markStuctureViolation(self.token)
+                    self.ed = None
+                    self.unwindAndContinue()
+
+            else:
+                if self.ed and self.ed.isValue:
+                    if not isDesignated and len(self.rootStack) > 0 and self.rootStack[-1][1] == self.root:
+                        self.rootStack[-1][0].markStuctureViolation(self.token)
+                    if isFirstElement and self.token.str == '0' and self.token.next.str == '}':
+                        # Zero initializer causes recursive initialization
+                        self.root.initializeChildren()
+                    elif self.token.isString and self.ed.valueType and self.ed.valueType.pointer > 0:
+                        if self.ed.valueType.pointer - self.ed.getEffectiveLevel() == 1:
+                            if self.ed.parent != self.root:
+                                self.root.markStuctureViolation(self.token)
+                            self.ed.setInitialized(isDesignated)
+                        elif self.ed.valueType.pointer == self.ed.getEffectiveLevel():
+                            if(self.root.name != '->' and self.ed.parent.parent != self.root) or (self.root.name == '->' and self.root.children[0] != self.ed.parent):
+                                self.root.markStuctureViolation(self.token)
+                            else:
+                                self.ed.parent.setInitialized(isDesignated)
+                            self.ed.parent.initializeChildren()
+
+                    else:
+                        if self.root is not None and self.ed.parent != self.root:
+                            # Check if token is correct value type for self.root.children[?]
+                            child = self.root.getChildByValueElement(self.ed)
+                            if self.token.valueType:
+                                if child.elementType != 'record' or self.token.valueType.type != 'record' or child.valueType.typeScope != self.token.valueType.typeScope:
+                                    self.root.markStuctureViolation(self.token)
+
+                        self.ed.setInitialized(isDesignated)
+
+                    # Mark all elements up to root with positional or designated
+                    # (for complex designators, or missing structure)
+                    parent = self.ed.parent
+                    while parent and parent != self.root:
+                        parent.isDesignated = isDesignated if isDesignated and not parent.isPositional else parent.isDesignated
+                        parent.isPositional = not isDesignated if not isDesignated and not parent.isDesignated else parent.isPositional
+                        parent = parent.parent
+                    isDesignated = False
+
+                    if self.token.isString and self.ed.parent.isArray:
+                        self.ed = self.ed.parent
+                self.unwindAndContinue()
+
+    def pushToRootStackAndMarkAsDesignated(self):
+        new = self.ed.parent
+        if new != self.root:
+            # Mark all elements up to self.root root as designated
+            parent = new
+            while parent and parent != self.root:
+                parent.isDesignated = True
+                parent = parent.parent
+            self.rootStack.append((self.root, new))
+            new.markAsCurrent()
+        new.childIndex = new.children.index(self.ed) - 1
+        self.root = new
+
+    def popFromStackIfExitElement(self):
+        if len(self.rootStack) > 0 and self.rootStack[-1][1] == self.root:
+            old = self.rootStack.pop()[0]
+            old.markAsCurrent()
+            self.root = old
+
+    def unwindAndContinue(self):
+        while self.token:
+            if self.token.astParent.astOperand1 == self.token and self.token.astParent.astOperand2:
+                if self.ed:
+                    if self.token.astParent.astOperand2.str == "{" and self.ed.isDesignated:
+                        self.popFromStackIfExitElement()
+                    else:
+                        self.ed.markAsCurrent()
+                        self.ed = self.ed.getNextValueElement(self.root)
+
+                self.token = self.token.astParent.astOperand2
+                break
+
+            self.token = self.token.astParent
+            if self.token.str == '{':
+                if self.root:
+                    self.ed = self.root.getLastValueElement()
+                    self.ed.markAsCurrent()
+
+                    # Cleanup if root is dummy node representing excess levels in initializer
+                    if self.root.name == '<-':
+                        self.root.children[0].parent = self.root.parent
+
+                    self.root = self.root.parent
+
+            if self.token.astParent is None:
+                self.token = None
+                break
+
+def misra_9_x(self, data, rule, rawTokens = None):
+
+    parser = InitializerParser()
+
+    for variable in data.variables:
+        if variable.nameToken is None:
+            continue
+
+        nameToken = variable.nameToken
+
+        # Check if declaration and initialization is
+        # split into two separate statements in ast.
+        if nameToken.next and nameToken.next.isSplittedVarDeclEq:
+            nameToken = nameToken.next.next
+
+        # Find declarations with initializer assignment
+        eq = nameToken
+        while not eq.isAssignmentOp and eq.astParent:
+            eq = eq.astParent
+
+        # We are only looking for initializers
+        if not eq.isAssignmentOp or eq.astOperand2.isName:
+            continue
+
+        if variable.isArray or variable.isClass:
+            ed = getElementDef(nameToken, rawTokens)
+            # No need to check non-arrays if valueType is missing,
+            # since we can't say anything useful about the structure
+            # without it.
+            if ed.valueType is None and not variable.isArray:
+                continue
+            parser.parseInitializer(ed, eq.astOperand2)
+            # print(rule, nameToken.str + '=', ed.getInitDump())
+            if rule == 902 and not ed.isMisra92Compliant():
+                self.reportError(nameToken, 9, 2)
+            if rule == 903 and not ed.isMisra93Compliant():
+                # Do not check when variable is pointer type
+                type_token = variable.nameToken
+                while type_token and type_token.isName:
+                    type_token = type_token.previous
+                if type_token and type_token.str == '*':
+                    continue
+
+                self.reportError(nameToken, 9, 3)
+            if rule == 904 and not ed.isMisra94Compliant():
+                self.reportError(nameToken, 9, 4)
+            if rule == 905 and not ed.isMisra95Compliant():
+                self.reportError(nameToken, 9, 5)
+
+def getElementDef(nameToken, rawTokens = None):
+    if nameToken.variable.isArray:
+        ed = ElementDef("array", nameToken.str, nameToken.valueType)
+        createArrayChildrenDefs(ed, nameToken.astParent, nameToken.variable, rawTokens)
+    elif nameToken.variable.isClass:
+        ed = ElementDef("record", nameToken.str, nameToken.valueType)
+        createRecordChildrenDefs(ed, nameToken.variable)
+    else:
+        ed = ElementDef("value", nameToken.str, nameToken.valueType)
+    return ed
+
+def createArrayChildrenDefs(ed, token, var, rawTokens = None):
+    if token and token.str == '[':
+        if rawTokens is not None:
+            foundToken = next((rawToken for rawToken in rawTokens
+                               if rawToken.file == token.file
+                               and rawToken.linenr == token.linenr
+                               and rawToken.column == token.column
+                               ), None)
+
+            if foundToken and foundToken.next and foundToken.next.str == ']':
+                ed.markAsFlexibleArray(token)
+
+        if (token.astOperand2 is not None) and (token.astOperand2.getKnownIntValue() is not None):
+            for i in range(token.astOperand2.getKnownIntValue()):
+                createChild(ed, token, i, var)
+        else:
+            ed.markAsFlexibleArray(token)
+
+
+def createChild(ed, token, name, var):
+    if token.astParent and token.astParent.str == '[':
+        child = ElementDef("array", name, ed.valueType)
+        createArrayChildrenDefs(child, token.astParent, var)
+    else:
+        if ed.valueType and ed.valueType.type == "record":
+            child = ElementDef("record", name, ed.valueType)
+            createRecordChildrenDefs(child, var)
+        else:
+            child = ElementDef("value", name, ed.valueType)
+
+    ed.addChild(child)
+
+def createRecordChildrenDefs(ed, var):
+    valueType = ed.valueType
+    if not valueType or not valueType.typeScope:
+        return
+    if var is None:
+        return
+    typeToken = var.typeEndToken
+    while typeToken and typeToken.isName:
+        typeToken = typeToken.previous
+    if typeToken and typeToken.str == '*':
+        child = ElementDef("pointer", var.nameToken, var.nameToken.valueType)
+        ed.addChild(child)
+        return
+    child_dict = {}
+    for variable in valueType.typeScope.varlist:
+        if variable is var:
+            continue
+        child = getElementDef(variable.nameToken)
+        child_dict[variable.nameToken] = child
+    for scopes in valueType.typeScope.nestedList:
+        varscope = False
+        if scopes.nestedIn == valueType.typeScope:
+            for variable in valueType.typeScope.varlist:
+                if variable.nameToken and variable.nameToken.valueType and variable.nameToken.valueType.typeScope == scopes:
+                    varscope = True
+                    break
+            if not varscope:
+                ed1 = ElementDef("record", scopes.Id, valueType)
+                for variable in scopes.varlist:
+                    child = getElementDef(variable.nameToken)
+                    ed1.addChild(child)
+                child_dict[scopes.bodyStart] = ed1
+    sorted_keys = sorted(list(child_dict.keys()), key=lambda k: (k.file, k.linenr, k.column))
+    for _key in sorted_keys:
+        ed.addChild(child_dict[_key])
+
+
+def getElementByDesignator(ed, token):
+    if not token.str in [ '.', '[' ]:
+        return None
+
+    while token.str in [ '.', '[' ]:
+        token = token.astOperand1
+
+    while ed and not token.isAssignmentOp:
+        token = token.astParent
+
+        if token.str == '[':
+            if not ed.isArray:
+                ed.markStuctureViolation(token)
+
+            chIndex = -1
+            if token.astOperand2 is not None:
+                chIndex = token.astOperand2.getKnownIntValue()
+            elif token.astOperand1 is not None:
+                chIndex = token.astOperand1.getKnownIntValue()
+
+            ed = ed.getChildByIndex(chIndex) if chIndex is not None else None
+
+        elif token.str == '.':
+            if not ed.isRecord:
+                ed.markStuctureViolation(token)
+
+            name = ""
+            if token.astOperand2 is not None:
+                name = token.astOperand2.str
+            elif token.astOperand1 is not None:
+                name = token.astOperand1.str
+
+            ed = ed.getChildByName(name)
+
+    return ed
diff --git a/addons/naming.py b/addons/naming.py
index ca59f57b937..2893779f2e0 100755
--- a/addons/naming.py
+++ b/addons/naming.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # cppcheck addon for naming conventions
 #
@@ -17,41 +17,59 @@ def validate_regex(expr):
         re.compile(expr)
     except re.error:
         print('Error: "{}" is not a valid regular expression.'.format(expr))
-        exit(1)
+        sys.exit(1)
 
 
 RE_VARNAME = None
+RE_CONSTNAME = None
 RE_PRIVATE_MEMBER_VARIABLE = None
 RE_FUNCTIONNAME = None
 for arg in sys.argv[1:]:
     if arg[:6] == '--var=':
         RE_VARNAME = arg[6:]
         validate_regex(RE_VARNAME)
+    elif arg.startswith('--const='):
+        RE_CONSTNAME = arg[arg.find('=')+1:]
+        validate_regex(RE_CONSTNAME)
     elif arg.startswith('--private-member-variable='):
         RE_PRIVATE_MEMBER_VARIABLE = arg[arg.find('=')+1:]
         validate_regex(RE_PRIVATE_MEMBER_VARIABLE)
     elif arg[:11] == '--function=':
         RE_FUNCTIONNAME = arg[11:]
         validate_regex(RE_FUNCTIONNAME)
+    # TODO: bail out on unknown parameter
+
 
 def reportError(token, severity, msg, errorId):
     cppcheckdata.reportError(token, severity, msg, 'naming', errorId)
 
+
 for arg in sys.argv[1:]:
     if not arg.endswith('.dump'):
         continue
     print('Checking ' + arg + '...')
-    data = cppcheckdata.parsedump(arg)
-    for cfg in data.configurations:
-        if len(data.configurations) > 1:
-            print('Checking ' + arg + ', config "' + cfg.name + '"...')
+    data = cppcheckdata.CppcheckData(arg)
+
+    for cfg in data.iterconfigurations():
+        print('Checking %s, config %s...' % (arg, cfg.name))
         if RE_VARNAME:
             for var in cfg.variables:
-                if var.nameToken:
+                if var.access == 'Private':
+                    continue
+                if var.nameToken and not var.isConst:
                     res = re.match(RE_VARNAME, var.nameToken.str)
                     if not res:
                         reportError(var.typeStartToken, 'style', 'Variable ' +
                                     var.nameToken.str + ' violates naming convention', 'varname')
+        if RE_CONSTNAME:
+            for var in cfg.variables:
+                if var.access == 'Private':
+                    continue
+                if var.nameToken and var.isConst:
+                    res = re.match(RE_CONSTNAME, var.nameToken.str)
+                    if not res:
+                        reportError(var.typeStartToken, 'style', 'Constant ' +
+                                    var.nameToken.str + ' violates naming convention', 'constname')
         if RE_PRIVATE_MEMBER_VARIABLE:
             for var in cfg.variables:
                 if (var.access is None) or var.access != 'Private':
@@ -63,8 +81,12 @@ def reportError(token, severity, msg, errorId):
         if RE_FUNCTIONNAME:
             for scope in cfg.scopes:
                 if scope.type == 'Function':
+                    function = scope.function
+                    if function is not None and function.type in ('Constructor', 'Destructor', 'CopyConstructor', 'MoveConstructor'):
+                        continue
                     res = re.match(RE_FUNCTIONNAME, scope.className)
                     if not res:
                         reportError(
                             scope.bodyStart, 'style', 'Function ' + scope.className + ' violates naming convention', 'functionName')
 
+sys.exit(cppcheckdata.EXIT_CODE)
diff --git a/addons/naming.json b/addons/namingng.config.json
similarity index 61%
rename from addons/naming.json
rename to addons/namingng.config.json
index 26cb4bbce7a..0abba4f15ac 100644
--- a/addons/naming.json
+++ b/addons/namingng.config.json
@@ -2,6 +2,15 @@
     "RE_VARNAME": ["[a-z]*[a-zA-Z0-9_]*\\Z"],
     "RE_PRIVATE_MEMBER_VARIABLE": null,
     "RE_FUNCTIONNAME": ["[a-z0-9A-Z]*\\Z"],
+    "include_guard": {
+        "input": "path",
+        "prefix": "",
+        "suffix": "",
+        "case": "upper",
+        "max_linenr": 5,
+        "RE_HEADERFILE": "[^/].*\\.h\\Z",
+        "required": true
+    },
     "var_prefixes": {"uint32_t": "ui32",
                      "int*": "intp"},
     "function_prefixes": {"uint16_t": "ui16",
diff --git a/addons/namingng.json b/addons/namingng.json
new file mode 100644
index 00000000000..83f9a5a55d8
--- /dev/null
+++ b/addons/namingng.json
@@ -0,0 +1,6 @@
+{
+    "script":"namingng.py",
+    "args":[
+        "--configfile=namingng.config.json"
+    ]
+}
diff --git a/addons/namingng.py b/addons/namingng.py
index 17e3b307acb..9da177321ef 100755
--- a/addons/namingng.py
+++ b/addons/namingng.py
@@ -3,6 +3,7 @@
 # cppcheck addon for naming conventions
 # An enhanced version. Configuration is taken from a json file
 # It supports to check for type-based prefixes in function or variable names.
+# Aside from include guard naming, include guard presence can also be tested.
 #
 # Example usage (variable name must start with lowercase, function name must start with uppercase):
 # $ cppcheck --dump path-to-src/
@@ -11,9 +12,18 @@
 # JSON format:
 #
 # {
-#    "RE_VARNAME": "[a-z]*[a-zA-Z0-9_]*\\Z",
+#    "RE_VARNAME": ["[a-z]*[a-zA-Z0-9_]*\\Z"],
 #    "RE_PRIVATE_MEMBER_VARIABLE": null,
-#    "RE_FUNCTIONNAME": "[a-z0-9A-Z]*\\Z",
+#    "RE_FUNCTIONNAME": ["[a-z0-9A-Z]*\\Z"],
+#    "_comment": "comments can be added to the config with underscore-prefixed keys",
+#    "include_guard": {
+#        "input": "path",
+#        "prefix": "GUARD_",
+#        "case": "upper",
+#        "max_linenr": 5,
+#        "RE_HEADERFILE": "[^/].*\\.h\\Z",
+#        "required": true
+#    },
 #    "var_prefixes": {"uint32_t": "ui32"},
 #    "function_prefixes": {"uint16_t": "ui16",
 #                          "uint32_t": "ui32"}
@@ -24,222 +34,387 @@
 
 import cppcheckdata
 import sys
+import os
 import re
-import argparse
 import json
 
-## Auxiliary class
-class dataStruct:
-    def __init__(self, file, linenr, string):
+# Auxiliary class
+class DataStruct:
+    def __init__(self, file, linenr, string, column=0):
         self.file = file
         self.linenr = linenr
         self.str = string
+        self.column = column
 
-def reportError(filename, linenr, severity, msg):
-    message = "[{filename}:{linenr}] ( {severity} ) naming.py: {msg}\n".format(
-        filename=filename,
-        linenr=linenr,
-        severity=severity,
-        msg=msg
-    )
-    sys.stderr.write(message)
-    return message
+def reportNamingError(location,message,errorId='namingConvention',severity='style',extra='',column=None):
+    cppcheckdata.reportError(location,severity,message,'namingng',errorId,extra,columnOverride=column)
+
+def configError(error,fatal=True):
+    print('config error: %s'%error)
+    if fatal:
+        sys.exit(1)
+
+def validateConfigREs(list_or_dict,json_key):
+    have_error = False
+    for item in list_or_dict:
+        try:
+            re.compile(item)
+        except re.error as err:
+            configError("item '%s' of '%s' is not a valid regular expression: %s"%(item,json_key,err),fatal=False)
+            have_error = True
+            continue
+        if not isinstance(list_or_dict,dict):
+            continue
+        # item is actually a dict key; check value
+        value = list_or_dict[item]
+        if (not isinstance(value,list) or len(value) != 2
+                or not isinstance(value[0],bool) or not isinstance(value[1],str)):
+            configError("item '%s' of '%s' must be an array [bool,string]"%(item,json_key),fatal=False)
+            have_error = True
+
+    return have_error
 
 def loadConfig(configfile):
-    with open(configfile) as fh:
-        data = json.load(fh)
-    return data
+    if not os.path.exists(configfile):
+        configError("cannot find config file '%s'"%configfile)
+
+    try:
+        with open(configfile) as fh:
+            data = json.load(fh)
+    except json.JSONDecodeError as e:
+        configError("error parsing config file as JSON at line %d: %s"%(e.lineno,e.msg))
+    except Exception as e:
+        configError("error opening config file '%s': %s"%(configfile,e))
+
+    if not isinstance(data, dict):
+        configError('config file must contain a JSON object at the top level')
 
-def checkTrueRegex(data, expr, msg, errors):
-    res = re.match(expr, data.str)
-    if res:
-        errors.append(reportError(data.file, data.linenr, 'style', msg))
+    # All errors are emitted before bailing out, to make the unit test more
+    # effective.
+    have_error = False
 
-def checkFalseRegex(data, expr, msg, errors):
-    res = re.match(expr, data.str)
-    if not res:
-        errors.append(reportError(data.file, data.linenr, 'style', msg))
+    # Put config items in a class, so that settings can be accessed using
+    # config.feature
+    class Config:
+        pass
+    config = Config()
+
+    mapping = {
+        'file':                     ('RE_FILE', (list,)),
+        'namespace':                ('RE_NAMESPACE', (list,dict)),
+        'include_guard':            ('include_guard', (dict,)),
+        'variable':                 ('RE_VARNAME', (list,dict)),
+        'variable_prefixes':        ('var_prefixes', (dict,), {}),
+        'private_member':           ('RE_PRIVATE_MEMBER_VARIABLE', (list,dict)),
+        'public_member':            ('RE_PUBLIC_MEMBER_VARIABLE', (list,dict)),
+        'global_variable':          ('RE_GLOBAL_VARNAME', (list,dict)),
+        'function_name':            ('RE_FUNCTIONNAME', (list,dict)),
+        'function_prefixes':        ('function_prefixes', (dict,), {}),
+        'class_name':               ('RE_CLASS_NAME', (list,dict)),
+        'skip_one_char_variables':  ('skip_one_char_variables', (bool,)),
+    }
+
+    # parse defined keys and store as members of config object
+    for key,opts in mapping.items():
+        json_key = opts[0]
+        req_type = opts[1]
+        default = None if len(opts)<3 else opts[2]
+
+        value = data.pop(json_key,default)
+        if value is not None and type(value) not in req_type:
+            req_typename = ' or '.join([tp.__name__ for tp in req_type])
+            got_typename = type(value).__name__
+            configError('%s must be %s (not %s), or not set'%(json_key,req_typename,got_typename),fatal=False)
+            have_error = True
+            continue
+
+        # type list implies that this is either a list of REs or a dict with RE keys
+        if list in req_type and value is not None:
+            re_error = validateConfigREs(value,json_key)
+            if re_error:
+                have_error = True
+
+        setattr(config,key,value)
+
+    # check remaining keys, only accept underscore-prefixed comments
+    for key,value in data.items():
+        if key == '' or key[0] != '_':
+            configError("unknown config key '%s'"%key,fatal=False)
+            have_error = True
+
+    if have_error:
+        sys.exit(1)
+
+    # pylint: disable-next=no-member - TODO: fix this
+    if config.include_guard:
+        # pylint: disable-next=no-member - TODO: fix this
+        config.include_guard_header_re = config.include_guard.get('RE_HEADERFILE',"[^/].*\\.h\\Z")
+
+    return config
+
+
+def evalExpr(conf, exp, mockToken, msgType):
+    report_as_error = False
+    msg = msgType + ' ' + mockToken.str + ' violates naming convention'
 
-def evalExpr(conf, exp, mockToken, msgType, errors):
     if isinstance(conf, dict):
-        if (conf[exp][0]):
-            msg = msgType + ' ' + mockToken.str + ' violates naming convention : ' + conf[exp][1]
-            checkTrueRegex(mockToken, exp, msg, errors)
-        elif (~conf[exp][0]):
-            msg = msgType + ' ' + mockToken.str + ' violates naming convention : ' + conf[exp][1]
-            checkFalseRegex(mockToken, exp, msg, errors)
-        else:
-            msg = msgType + ' ' + mockToken.str + ' violates naming convention : ' + conf[exp][0]
-            checkFalseRegex(mockToken, exp, msg, errors)
+        report_as_error = conf[exp][0]
+        msg += ': ' + conf[exp][1]
+
+    res = re.match(exp,mockToken.str)
+    if bool(res) == report_as_error:
+        reportNamingError(mockToken,msg)
+
+def check_include_guard_name(conf,directive):
+    parts = directive.str.split()
+    if len(parts) != 2:
+        msg = 'syntax error'
+        reportNamingError(directive,msg,'syntax')
+        return None,None
+    guard_name = parts[1]
+    guard_column = 1+directive.str.find(guard_name)
+
+    filename = directive.file
+    if conf.include_guard.get('input','path') == 'basename':
+        filename = os.path.basename(filename)
+    use_case = conf.include_guard.get('case','upper')
+    if use_case == 'upper':
+        filename = filename.upper()
+    elif use_case == 'lower':
+        filename = filename.lower()
+    elif use_case == 'keep':
+        pass # keep filename case as-is
     else:
-        msg = msgType + ' ' + mockToken.str + ' violates naming convention'
-        checkFalseRegex(mockToken, exp, msg, errors)
+        print("invalid config value for 'case': '%s'"%use_case,file=sys.stderr)
+        sys.exit(1)
+
+    barename = re.sub('[^A-Za-z0-9]','_',filename).strip('_')
+    expect_guard_name = conf.include_guard.get('prefix','') + barename + conf.include_guard.get('suffix','')
+    if expect_guard_name != guard_name:
+        msg = 'include guard naming violation; %s != %s'%(guard_name,expect_guard_name)
+        reportNamingError(directive,msg,'includeGuardName',column=guard_column)
+
+    return guard_name,guard_column
+
+def check_include_guards(conf,cfg,unguarded_include_files):
+    # Scan for '#ifndef FILE_H' as the first directive, in the first N lines.
+    # Then test whether the next directive #defines the found name.
+    # Various tests are done:
+    # - check include guards for their naming and consistency
+    # - test whether include guards are in place
+    max_linenr = conf.include_guard.get('max_linenr', 5)
 
-def process(dumpfiles, configfile, debugprint=False):
+    def report(directive,msg,errorId,severity='style',column=0):
+        reportNamingError(directive,msg,errorId,severity=severity,column=column)
 
-    errors = []
+    def report_pending_ifndef(directive,column):
+        report(directive,'include guard #ifndef is not followed by #define','includeGuardIncomplete',column=column)
+
+    last_fn = None
+    pending_ifndef = None
+    guard_column = None
+    phase = 0
+    for directive in cfg.directives:
+        if last_fn != directive.file:
+            if pending_ifndef:
+                report_pending_ifndef(pending_ifndef,guard_column)
+                pending_ifndef = None
+            last_fn = directive.file
+            phase = 0
+        if phase == -1:
+            # ignore (the remainder of) this file
+            continue
+        if not re.match(conf.include_guard_header_re,directive.file):
+            phase = -1
+            continue
 
+        if directive.linenr > max_linenr:
+            if phase == 0 and conf.include_guard.get('required',1):
+                report(directive,'include guard not found before line %d'%max_linenr,'includeGuardMissing')
+            phase = -1
+            continue
+
+        if phase == 0:
+            # looking for '#ifndef FILE_H'
+            if not directive.str.startswith('#ifndef'):
+                if conf.include_guard.get('required',1):
+                    report(directive,'first preprocessor directive should be include guard #ifndef','includeGuardMissing')
+                phase = -1
+                continue
+            guard_name,guard_column = check_include_guard_name(conf,directive)
+            if guard_name is None:
+                phase = -1
+                continue
+            pending_ifndef = directive
+            phase = 1
+        elif phase == 1:
+            pending_ifndef = None
+            # looking for '#define FILE_H'
+            if not directive.str.startswith('#define'):
+                report(directive,'second preprocessor directive should be include guard #define','includeGuardIncomplete')
+                phase = -1
+                continue
+            parts = directive.str.split()
+            if len(parts) == 1:
+                report(directive,'syntax error','syntax')
+                phase = -1
+                continue
+            if guard_name != parts[1]:
+                report(directive,'include guard does not guard; %s != %s'%(guard_name,parts[1]),'includeGuardAwayFromDuty',severity='warning',column=guard_column)
+
+            unguarded_include_files.remove(directive.file)
+
+            phase = -1
+    if pending_ifndef:
+        report_pending_ifndef(pending_ifndef,guard_column)
+
+def process(dumpfiles, configfile, cli, debugprint):
     conf = loadConfig(configfile)
 
     for afile in dumpfiles:
         if not afile[-5:] == '.dump':
             continue
-        print('Checking ' + afile + '...')
-        data = cppcheckdata.parsedump(afile)
-
-        ## Check File naming
-        if "RE_FILE" in conf and conf["RE_FILE"]:
-            mockToken = dataStruct(afile[:-5], "0", afile[afile.rfind('/')+1:-5])
-            msgType = 'File name'
-            for exp in conf["RE_FILE"]:
-                evalExpr(conf["RE_FILE"], exp, mockToken, msgType, errors)
-
-        ## Check Namespace naming
-        if "RE_NAMESPACE" in conf and conf["RE_NAMESPACE"]:
-            for tk in data.rawTokens:
-                if (tk.str == 'namespace'):
-                    mockToken = dataStruct(tk.next.file, tk.next.linenr, tk.next.str)
-                    msgType = 'Namespace'
-                    for exp in conf["RE_NAMESPACE"]:
-                        evalExpr(conf["RE_NAMESPACE"], exp, mockToken, msgType, errors)
-
-        for cfg in data.configurations:
-            if len(data.configurations) > 1:
-                print('Checking ' + afile + ', config "' + cfg.name + '"...')
-            if "RE_VARNAME" in conf and conf["RE_VARNAME"]:
-                for var in cfg.variables:
-                    if var.nameToken and var.access != 'Global' and var.access != 'Public' and var.access != 'Private':
-                        prev = var.nameToken.previous
-                        varType = prev.str
-                        while "*" in varType and len(varType.replace("*", "")) == 0:
-                            prev = prev.previous
-                            varType = prev.str + varType
-
-                        if debugprint:
-                            print("Variable Name: " + str(var.nameToken.str))
-                            print("original Type Name: " + str(var.nameToken.valueType.originalTypeName))
-                            print("Type Name: " + var.nameToken.valueType.type)
-                            print("Sign: " + str(var.nameToken.valueType.sign))
-                            print("variable type: " + varType)
-                            print("\n")
-                            print("\t-- {} {}".format(varType, str(var.nameToken.str)))
-
-                        if conf["skip_one_char_variables"] and len(var.nameToken.str) == 1:
-                            continue
-                        if varType in conf["var_prefixes"]:
-                            if not var.nameToken.str.startswith(conf["var_prefixes"][varType]):
-                                errors.append(reportError(
-                                                    var.typeStartToken.file,
-                                                    var.typeStartToken.linenr,
-                                                    'style',
-                                                    'Variable ' +
-                                                    var.nameToken.str +
-                                                    ' violates naming convention'))
-
-                        mockToken = dataStruct(var.typeStartToken.file, var.typeStartToken.linenr, var.nameToken.str)
-                        msgType = 'Variable'
-                        for exp in conf["RE_VARNAME"]:
-                            evalExpr(conf["RE_VARNAME"], exp, mockToken, msgType, errors)
-
-            ## Check Private Variable naming
-            if "RE_PRIVATE_MEMBER_VARIABLE" in conf and conf["RE_PRIVATE_MEMBER_VARIABLE"]:
-                # TODO: Not converted yet
-                for var in cfg.variables:
-                    if (var.access is None) or var.access != 'Private':
-                        continue
-                    mockToken = dataStruct(var.typeStartToken.file, var.typeStartToken.linenr, var.nameToken.str)
-                    msgType = 'Private member variable'
-                    for exp in conf["RE_PRIVATE_MEMBER_VARIABLE"]:
-                        evalExpr(conf["RE_PRIVATE_MEMBER_VARIABLE"], exp, mockToken, msgType, errors)
-
-            ## Check Public Member Variable naming
-            if "RE_PUBLIC_MEMBER_VARIABLE" in conf and conf["RE_PUBLIC_MEMBER_VARIABLE"]:
-                for var in cfg.variables:
-                    if (var.access is None) or var.access != 'Public':
-                        continue
-                    mockToken = dataStruct(var.typeStartToken.file, var.typeStartToken.linenr, var.nameToken.str)
-                    msgType = 'Public member variable'
-                    for exp in conf["RE_PUBLIC_MEMBER_VARIABLE"]:
-                        evalExpr(conf["RE_PUBLIC_MEMBER_VARIABLE"], exp, mockToken, msgType, errors)
-
-            ## Check Global Variable naming
-            if "RE_GLOBAL_VARNAME" in conf and conf["RE_GLOBAL_VARNAME"]:
-                for var in cfg.variables:
-                    if (var.access is None) or var.access != 'Global':
-                        continue
-                    mockToken = dataStruct(var.typeStartToken.file, var.typeStartToken.linenr, var.nameToken.str)
-                    msgType = 'Public member variable'
-                    for exp in conf["RE_GLOBAL_VARNAME"]:
-                        evalExpr(conf["RE_GLOBAL_VARNAME"], exp, mockToken, msgType, errors)
-
-            ## Check Functions naming
-            if "RE_FUNCTIONNAME" in conf and conf["RE_FUNCTIONNAME"]:
-                for token in cfg.tokenlist:
-                    if token.function:
-                        if token.function.type == 'Constructor' or token.function.type == 'Destructor':
-                            continue
-                        retval = token.previous.str
-                        prev = token.previous
-                        while "*" in retval and len(retval.replace("*", "")) == 0:
-                            prev = prev.previous
-                            retval = prev.str + retval
-                        if debugprint:
-                            print("\t:: {} {}".format(retval, token.function.name))
-
-                        if retval and retval in conf["function_prefixes"]:
-                            if not token.function.name.startswith(conf["function_prefixes"][retval]):
-                                errors.append(reportError(
-                                    token.file, token.linenr, 'style', 'Function ' + token.function.name + ' violates naming convention'))
-                        mockToken = dataStruct(token.file, token.linenr, token.function.name)
-                        msgType = 'Function'
-                        for exp in conf["RE_FUNCTIONNAME"]:
-                            evalExpr(conf["RE_FUNCTIONNAME"], exp, mockToken, msgType, errors)
-
-            ## Check Class naming
-            if "RE_CLASS_NAME" in conf and conf["RE_CLASS_NAME"]:
-                for fnc in cfg.functions:
-                    #Check if it is Constructor/Destructor
-                    if (fnc.type == 'Constructor' or fnc.type == 'Destructor'):
-                        mockToken = dataStruct(fnc.tokenDef.file, fnc.tokenDef.linenr, fnc.name)
-                        msgType = 'Class ' + fnc.type
-                        for exp in conf["RE_CLASS_NAME"]:
-                            evalExpr(conf["RE_CLASS_NAME"], exp, mockToken, msgType, errors)
-    return errors
+        if not cli:
+            print('Checking ' + afile + '...')
+        data = cppcheckdata.CppcheckData(afile)
+        process_data(conf,data,cli,debugprint)
+
+def check_file_naming(conf,data):
+    for source_file in data.files:
+        basename = os.path.basename(source_file)
+        good = False
+        for exp in conf.file:
+            good |= bool(re.match(exp, source_file))
+            good |= bool(re.match(exp, basename))
+        if not good:
+            mockToken = DataStruct(source_file, 0, basename)
+            reportNamingError(mockToken, 'File name ' + basename + ' violates naming convention')
+
+def check_namespace_naming(conf,data):
+    for tk in data.rawTokens:
+        if tk.str != 'namespace':
+            continue
+        mockToken = DataStruct(tk.next.file, tk.next.linenr, tk.next.str, tk.next.column)
+        for exp in conf.namespace:
+            evalExpr(conf.namespace, exp, mockToken, 'Namespace')
+
+def check_variable_naming(conf,cfg,debugprint):
+    for var in cfg.variables:
+        if not var.nameToken:
+            continue
+        if var.access in ('Global','Public','Private'):
+            continue
+        prev = var.nameToken.previous
+        varType = prev.str
+        while "*" in varType and len(varType.replace("*", "")) == 0:
+            prev = prev.previous
+            varType = prev.str + varType
+
+        if debugprint:
+            print("Variable Name: " + str(var.nameToken.str))
+            print("original Type Name: " + str(var.nameToken.valueType.originalTypeName))
+            print("Type Name: " + var.nameToken.valueType.type)
+            print("Sign: " + str(var.nameToken.valueType.sign))
+            print("variable type: " + varType)
+            print("\n")
+            print("\t-- {} {}".format(varType, str(var.nameToken.str)))
+
+        if conf.skip_one_char_variables and len(var.nameToken.str) == 1:
+            continue
+        if varType in conf.variable_prefixes:
+            prefix = conf.variable_prefixes[varType]
+            if not var.nameToken.str.startswith(prefix):
+                reportNamingError(var.typeStartToken,
+                                    'Variable ' +
+                                    var.nameToken.str +
+                                    ' violates naming convention',
+                                    column=var.nameToken.column)
+
+        mockToken = DataStruct(var.typeStartToken.file, var.typeStartToken.linenr, var.nameToken.str, var.nameToken.column)
+        for exp in conf.variable:
+            evalExpr(conf.variable, exp, mockToken, 'Variable')
+
+# Naming check for Global, Private and Public member variables
+def check_gpp_naming(conf_list,cfg,access,message):
+    for var in cfg.variables:
+        if var.access != access:
+            continue
+        mockToken = DataStruct(var.typeStartToken.file, var.typeStartToken.linenr, var.nameToken.str, var.nameToken.column)
+        for exp in conf_list:
+            evalExpr(conf_list, exp, mockToken, message)
+
+def check_function_naming(conf,cfg,debugprint):
+    for token in cfg.tokenlist:
+        if not token.function:
+            continue
+        if token.function.type in ('Constructor', 'Destructor', 'CopyConstructor', 'MoveConstructor'):
+            continue
+        retval = token.previous.str
+        prev = token.previous
+        while "*" in retval and len(retval.replace("*", "")) == 0:
+            prev = prev.previous
+            retval = prev.str + retval
+        if debugprint:
+            print("\t:: {} {}".format(retval, token.function.name))
+
+        if retval and retval in conf.function_prefixes:
+            if not token.function.name.startswith(conf.function_prefixes[retval]):
+                reportNamingError(token, 'Function ' + token.function.name + ' violates naming convention', column=token.column)
+        mockToken = DataStruct(token.file, token.linenr, token.function.name, token.column)
+        msgType = 'Function'
+        for exp in conf.function_name:
+            evalExpr(conf.function_name, exp, mockToken, msgType)
+
+def check_class_naming(conf,cfg):
+    for fnc in cfg.functions:
+        if fnc.type not in ('Constructor','Destructor'):
+            continue
+        mockToken = DataStruct(fnc.tokenDef.file, fnc.tokenDef.linenr, fnc.name, fnc.tokenDef.column)
+        msgType = 'Class ' + fnc.type
+        for exp in conf.class_name:
+            evalExpr(conf.class_name, exp, mockToken, msgType)
+
+def process_data(conf,data,cli,debugprint):
+    if conf.file:
+        check_file_naming(conf,data)
+
+    if conf.namespace:
+        check_namespace_naming(conf,data)
+
+    unguarded_include_files = []
+    if conf.include_guard and conf.include_guard.get('required',1):
+        unguarded_include_files = [fn for fn in data.files if re.match(conf.include_guard_header_re,fn)]
+
+    for cfg in data.configurations:
+        if not cli:
+            print('Checking config %s...' % cfg.name)
+        if conf.variable:
+            check_variable_naming(conf,cfg,debugprint)
+        if conf.private_member:
+            check_gpp_naming(conf.private_member,cfg,'Private','Private member variable')
+        if conf.public_member:
+            check_gpp_naming(conf.public_member,cfg,'Public','Public member variable')
+        if conf.global_variable:
+            check_gpp_naming(conf.global_variable,cfg,'Global','Global variable')
+        if conf.function_name:
+            check_function_naming(conf,cfg,debugprint)
+        if conf.class_name:
+            check_class_naming(conf,cfg)
+        if conf.include_guard:
+            check_include_guards(conf,cfg,unguarded_include_files)
+
+    for fn in unguarded_include_files:
+        mockToken = DataStruct(fn,0,os.path.basename(fn))
+        reportNamingError(mockToken,'Missing include guard','includeGuardMissing')
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description='Naming verification')
-    parser.add_argument('dumpfiles', type=str, nargs='+',
-                        help='A set of dumpfiles to process')
+    parser = cppcheckdata.ArgumentParser()
     parser.add_argument("--debugprint", action="store_true", default=False,
                         help="Add debug prints")
-    parser.add_argument("--configfile", type=str, default="naming.json",
+    parser.add_argument("--configfile", type=str, default="namingng.config.json",
                         help="Naming check config file")
-    parser.add_argument("--verify", action="store_true", default=False,
-                        help="verify this script. Must be executed in test folder !")
 
     args = parser.parse_args()
-    errors = process(args.dumpfiles, args.configfile, args.debugprint)
-
-    if args.verify:
-        print(errors)
-        if len(errors) < 6:
-            print("Not enough errors found")
-            sys.exit(1)
-        target = [
-         '[namingng_test.c:8] ( style ) naming.py: Variable badui32 violates naming convention\n',
-         '[namingng_test.c:11] ( style ) naming.py: Variable a violates naming convention\n',
-         '[namingng_test.c:29] ( style ) naming.py: Variable badui32 violates naming convention\n',
-         '[namingng_test.c:20] ( style ) naming.py: Function ui16bad_underscore violates naming convention\n',
-         '[namingng_test.c:25] ( style ) naming.py: Function u32Bad violates naming convention\n',
-         '[namingng_test.c:37] ( style ) naming.py: Function Badui16 violates naming convention\n']
-        diff = set(errors) - set(target)
-        if len(diff):
-            print("Not the right errors found {}".format(str(diff)))
-            sys.exit(1)
-        print("Verification done\n")
-        sys.exit(0)
-
-    if len(errors):
-        print('Found errors: {}'.format(len(errors)))
-        sys.exit(1)
+    process(args.dumpfile, args.configfile, args.cli, args.debugprint)
+
     sys.exit(0)
diff --git a/addons/runaddon.py b/addons/runaddon.py
new file mode 100644
index 00000000000..26ad7e9fa73
--- /dev/null
+++ b/addons/runaddon.py
@@ -0,0 +1,16 @@
+import cppcheckdata
+import cppcheck
+import runpy
+import sys
+import os
+
+if __name__ == '__main__':
+    addon = sys.argv[1]
+    __addon_name__ = os.path.splitext(os.path.basename(addon))[0]
+    sys.argv.pop(0)
+
+    runpy.run_path(addon, run_name='__main__')
+
+    # Run registered checkers
+    cppcheck.runcheckers()
+    sys.exit(cppcheckdata.EXIT_CODE)
\ No newline at end of file
diff --git a/addons/test/cert-test.c b/addons/test/cert-test.c
deleted file mode 100644
index dd850c17928..00000000000
--- a/addons/test/cert-test.c
+++ /dev/null
@@ -1,176 +0,0 @@
-// To test:
-// ~/cppcheck/cppcheck --dump cert-test.c && python ../cert.py -verify cert-test.c.dump
-struct S {
-    short a;
-    short b;
-};
-
-#pragma pack()
-struct PackedStruct {
-    short a;
-    short b;
-};
-
-void api01()
-{
-    const size_t String_Size = 20;
-    struct bad_node_s
-    {
-        char name[String_Size];
-        struct bad_node_s* next;      // cert-API01-C
-    }
-    struct good_node_s
-    {
-        struct good_node_s* next;      
-        char name[String_Size];
-    }
-    struct also_good_node_s
-    {
-        struct also_good_node_s* next;      
-        char *name;
-    }
-}
-
-void dostuff(int *data);
-
-void exp05()
-{
-    const int x = 42;
-    int y = (int)x;
-
-    int *p;
-    p = (int *)&x; // cert-EXP05-C
-
-    const int data[] = {1,2,3,4};
-    dostuff(data); // cert-EXP05-C
-}
-
-void print(const char *p);
-void exp05_fp() {
-    print("hello");
-}
-
-void exp42()
-{
-    struct S s1 = {1,2};
-    struct S s2 = {1,2};
-    memcmp(&s1, &s2, sizeof(struct S)); // cert-EXP42-C
-
-    struct PackedStruct s3 = {1,2};
-    struct PackedStruct s4 = {1,2};
-    memcmp(&s3, &s4, sizeof(struct S));
-}
-
-void exp46()
-{
-    if ((x == y) & z) {} // cert-EXP46-c
-}
-
-unsigned char int31(int x)
-{
-    x = (unsigned char)1000; // cert-INT31-c
-    x = (signed char)0xff; // cert-INT31-c
-    x = (unsigned char)-1; // cert-INT31-c
-    x = (unsigned long long)-1; // cert-INT31-c
-}
-
-void msc24()
-{
-    struct S {
-    int x; int fopen;
-    };
-    
-    struct S s;
-    time_t rawtime;
-    struct tm *timeinfo;
-    char buffer[256];
-    int i;
-    long int li;
-    long long int lli;
-    FILE *f;
-
-    s.fopen = 123;
-
-    f = fopen ("myfile.txt","w+");  //cert-MSC24-C
-    setbuf ( f , buffer )   //cert-MSC24-C
-    for ( i='A' ; i<='Z' ; i++)
-        fputc ( n, f);
-    rewind (f);             //cert-MSC24-C
-    fclose (f);
-
-    time ( &rawtime );
-    timeinfo = localtime ( &rawtime );
-    printf ( "The current date/time is: %s", asctime (timeinfo) ); //cert-MSC24-C
-
-    n = atof (buffer);              //cert-MSC24-C
-    m = sin (n*pi/180);
-
-    i = atoi (buffer);      //cert-MSC24-C
-
-    li = atol(buffer);      //cert-MSC24-C
-
-    lli = atoll(buffer);    //cert-MSC24-C
-
-    time (&rawtime);
-    printf ("The current local time is: %s", ctime (&rawtime)); //cert-MSC24-C
-
-    freopen ("myfile.txt","w",stdout);                  //cert-MSC24-C
-    printf ("This sentence is redirected to a file.");
-    fclose (stdout);
-}
-
-void msc30()
-{
-    unsigned int num = rand(); // cert-MSC30-c
-    int rand = 5;
-    int a = rand;
-}
-
-void exp15()
-{
-    int x=5, y=7;
-
-    if(x==y);                            //cert-EXP15-C
-    {
-        printf("not working\n");
-    }
-    if(x)
-        ;
-}
-
-void str03()
-{
-    char *string_data=(char*)malloc(16);
-    char a[16];
-    int d;
-    strncpy(a, string_data, sizeof(a));     //cert-STR03-C
-    strncpy(a, string_data, 5); d=sizeof(int);
-}
-
-void str05()
-{
-    int x=5, y=7;
-
-    if(x==y);                            //cert-EXP15-C
-    {
-        printf("not working\n");
-    }
-    if(x)
-        ;
-}
-
-void str07(char *buf, const char *newBuf)
-{
-    const char *str="test";
-    strcat(buf,"bla");
-    strcat(buf, str);    //cert-STR07-C
-    strcat(buf, newBuf); //cert-STR07-C
-    strcpy(str, newBuf); //cert-STR07-C
-}
-
-void str11()
-{
-    const char str[3]="abc";    //cert-STR11-C
-    const char *x[10]; x[3]="def";
-}
-
diff --git a/addons/test/cert-test.cpp b/addons/test/cert-test.cpp
deleted file mode 100644
index 21fe684f770..00000000000
--- a/addons/test/cert-test.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-// To test:
-// ~/cppcheck/cppcheck --dump cert-test.cpp && python ../cert.py -verify cert-test.cpp.dump
-
-#include <cstdlib>
-
-class msc30TestClass {
-public:
-    static int rand();
-};
-
-void msc30(msc30TestClass & testClass)
-{
-    unsigned int num = rand(); // cert-MSC30-c
-    num = std::rand(); // cert-MSC30-c
-    num = msc30TestClass::rand();
-    num = unknownClass::rand();
-    num = testClass.rand();
-    num = unknownClass.rand();
-    int rand = 5;
-    int a = rand;
-}
diff --git a/addons/test/misc-test.cpp b/addons/test/misc-test.cpp
index 3ea89bbd1e1..df1f8352cde 100644
--- a/addons/test/misc-test.cpp
+++ b/addons/test/misc-test.cpp
@@ -1,6 +1,9 @@
 // To test:
 // ~/cppcheck/cppcheck --dump misc-test.cpp && python ../misc.py -verify misc-test.cpp.dump
 
+#include <string>
+#include <vector>
+
 // Warn about string concatenation in array initializers..
 const char *a[] = {"a" "b"}; // stringConcatInArrayInit
 const char *b[] = {"a","b" "c"}; // stringConcatInArrayInit
diff --git a/addons/test/misra/config1.c b/addons/test/misra/config1.c
new file mode 100644
index 00000000000..31aa2a4d6b5
--- /dev/null
+++ b/addons/test/misra/config1.c
@@ -0,0 +1,10 @@
+
+struct S {
+    uint32_t some[100];
+};
+
+void foo( void )
+{
+    if (((S *)0x8000)->some[0] != 0U) { }
+}
+
diff --git a/addons/test/misra/crash1.c b/addons/test/misra/crash1.c
new file mode 100644
index 00000000000..d00a72c3aaa
--- /dev/null
+++ b/addons/test/misra/crash1.c
@@ -0,0 +1,8 @@
+
+struct expression {
+    int nargs;
+    struct expression *args[3];
+};
+
+struct expression plvar = {0};
+
diff --git a/addons/test/misra/crash10.c b/addons/test/misra/crash10.c
new file mode 100644
index 00000000000..455d86e57ec
--- /dev/null
+++ b/addons/test/misra/crash10.c
@@ -0,0 +1,12 @@
+//#12267
+
+extern uint32_t end;
+
+//#define KEEP // if uncomment this then wont crash
+
+KEEP static const int32_t ptr_to_end = &end;
+
+void foo(void)
+{
+    (void)ptr_to_end;
+}
diff --git a/addons/test/misra/crash11.c b/addons/test/misra/crash11.c
new file mode 100644
index 00000000000..b758e69f31e
--- /dev/null
+++ b/addons/test/misra/crash11.c
@@ -0,0 +1,2 @@
+// #12651
+__arm__
diff --git a/addons/test/misra/crash12.c b/addons/test/misra/crash12.c
new file mode 100644
index 00000000000..b16198ea2e7
--- /dev/null
+++ b/addons/test/misra/crash12.c
@@ -0,0 +1,33 @@
+// 13140
+#line 78 "tmp.h"
+typedef struct
+{
+int vara [30] ;
+int varb [5] ;
+} S0 ;
+
+
+
+typedef struct
+{
+bool var1 ;
+S2 var2 ;
+S2 var3 ;
+S2 var4 ;
+short var5 ;
+short var6 ;
+S1 var7 ;
+S1 var8 ;
+S1 var9 ;
+S1 var10 ;
+S1 var11 ;
+float var12 ;
+short var13 [ 3 ] ;
+} S3 ;
+
+#line 33 "tmp.c"
+static const S3 s3 =
+{
+0 ,
+{ 0, 0 } ,
+} ;
\ No newline at end of file
diff --git a/addons/test/misra/crash2.c b/addons/test/misra/crash2.c
new file mode 100644
index 00000000000..c736a265d15
--- /dev/null
+++ b/addons/test/misra/crash2.c
@@ -0,0 +1,9 @@
+
+// #11793
+
+typedef struct pfmlib_pmu {
+    int flags ;
+    int (*get_event_encoding[10])(void* this, pfmlib_event_desc_t* e);
+} pfmlib_pmu_t ;
+
+pfmlib_pmu_t sparc_ultra3_support = { .flags = 0 };
diff --git a/addons/test/misra/crash3.c b/addons/test/misra/crash3.c
new file mode 100644
index 00000000000..19583f009a5
--- /dev/null
+++ b/addons/test/misra/crash3.c
@@ -0,0 +1,30 @@
+
+
+
+
+/* This is the representation of the expressions to determine the
+   plural form.  */
+struct expression
+{
+  int nargs;			/* Number of arguments.  */
+  union
+  {
+    unsigned long int num;	/* Number value for `num'.  */
+    struct expression *args[3];	/* Up to three arguments.  */
+  } val;
+};
+
+
+struct expression GERMANIC_PLURAL =
+{
+  .nargs = 2,
+  .val =
+  {
+    .args =
+    {
+      [0] = (struct expression *) &plvar,
+      [1] = (struct expression *) &plone
+    }
+  }
+};
+
diff --git a/addons/test/misra/crash4.c b/addons/test/misra/crash4.c
new file mode 100644
index 00000000000..7862581849f
--- /dev/null
+++ b/addons/test/misra/crash4.c
@@ -0,0 +1,11 @@
+
+struct ConDesDesc {
+    unsigned   Order;
+    unsigned   Import;
+};
+
+// cppcheck-suppress misra-config
+static ConDesDesc ConDes[CD_TYPE_COUNT] = {
+    { 0, 0 },
+    { 0, 0 },
+};
diff --git a/addons/test/misra/crash5.c b/addons/test/misra/crash5.c
new file mode 100644
index 00000000000..860101539da
--- /dev/null
+++ b/addons/test/misra/crash5.c
@@ -0,0 +1,23 @@
+
+struct _boardcnf_ch {
+    // cppcheck-suppress misra-config
+    uint8_t ddr_density[CS_CNT];
+    uint64_t ca_swap;
+};
+
+struct _boardcnf {
+
+    uint16_t dqdm_dly_r;
+    // cppcheck-suppress misra-config
+    struct _boardcnf_ch ch[DRAM_CH_CNT];
+};
+
+static const struct _boardcnf boardcnfs[1] = {
+    {
+        0x0a0,
+        {
+            { {0x02, 0x02}, 0x00345201 },
+            { {0x02, 0x02}, 0x00302154 }
+        }
+    },
+};
diff --git a/addons/test/misra/crash6.c b/addons/test/misra/crash6.c
new file mode 100644
index 00000000000..bf77e5f650b
--- /dev/null
+++ b/addons/test/misra/crash6.c
@@ -0,0 +1,17 @@
+
+
+typedef	struct _tGames
+{
+    char magicdirname[10];
+    unsigned int expectedmask;
+    unsigned char pictureorder[3];
+} tGames;
+
+static const tGames games[1]={
+    {"Pawn", 1, {0,1,2}}
+};
+
+
+
+
+
diff --git a/addons/test/misra/crash7.c b/addons/test/misra/crash7.c
new file mode 100644
index 00000000000..210cfeb4df8
--- /dev/null
+++ b/addons/test/misra/crash7.c
@@ -0,0 +1,8 @@
+
+
+static const struct id3_frametype wordlist[] =
+{
+  {0, "Encryption method registration"},
+  {1, "Popularimeter"},
+};
+
diff --git a/addons/test/misra/crash8.c b/addons/test/misra/crash8.c
new file mode 100644
index 00000000000..970d72540f0
--- /dev/null
+++ b/addons/test/misra/crash8.c
@@ -0,0 +1,10 @@
+
+struct three_d_filter_t {
+  char   name[16];
+  double elem[2];
+};
+
+static three_d_filter_t base_filters[] = {
+  {"Identity", { 1.0, 0.0 } },
+  {"Echo", { 0.4, 0.0 } }
+};
diff --git a/addons/test/misra/crash9.c b/addons/test/misra/crash9.c
new file mode 100644
index 00000000000..5abf2b8ad02
--- /dev/null
+++ b/addons/test/misra/crash9.c
@@ -0,0 +1,3 @@
+
+#line 3 "<stdout>"
+typedef int8_t flex_int8_t;
diff --git a/addons/test/misra/crash_misra9_parseInitializer.c b/addons/test/misra/crash_misra9_parseInitializer.c
new file mode 100644
index 00000000000..8e3dcfd5757
--- /dev/null
+++ b/addons/test/misra/crash_misra9_parseInitializer.c
@@ -0,0 +1,18 @@
+union {
+	struct {
+		uint8_t a;
+		uint8_t b;
+	} a;
+} bar;
+
+struct foo {
+	uint8_t a;
+	union bar w;
+	uint8_t b;
+};
+
+struct foo asdf = {
+	0,
+	{{0,0}},
+	1
+};
diff --git a/addons/test/misra/misra-ctu-1-test.c b/addons/test/misra/misra-ctu-1-test.c
new file mode 100644
index 00000000000..a003e66ae01
--- /dev/null
+++ b/addons/test/misra/misra-ctu-1-test.c
@@ -0,0 +1,55 @@
+// Test with command:
+// ./cppcheck --enable=information --enable=style --addon=misra --inline-suppr addons/test/misra/misra-ctu-*-test.c
+
+#include "misra-ctu-test.h"
+
+extern MISRA_2_3_A  misra_2_3_a;
+
+x = MISRA_2_5_OK_1;
+
+// cppcheck-suppress misra-c2012-20.5
+#undef MISRA_2_5_OK_3
+
+// cppcheck-suppress misra-c2012-2.3
+// cppcheck-suppress misra-c2012-5.6
+typedef int MISRA_5_6_VIOLATION;
+
+// cppcheck-suppress misra-c2012-5.7
+struct misra_5_7_violation_t {
+    int x;  // cppcheck-suppress unusedStructMember
+};
+static misra_5_7_violation_t misra_5_7_use_type_1;
+
+// #11443 - FP
+static struct
+{ // no warning
+    uint16_t x;  // cppcheck-suppress unusedStructMember
+} misra_5_7_false_positive_1;
+
+// cppcheck-suppress misra-c2012-8.4
+// cppcheck-suppress misra-c2012-5.8
+int misra_5_8_var1;
+// cppcheck-suppress misra-c2012-8.4
+// cppcheck-suppress misra-c2012-5.8
+int misra_5_8_var2;
+// cppcheck-suppress misra-c2012-5.8
+static void misra_5_8_f(void) {}
+
+
+// cppcheck-suppress misra-c2012-5.9
+static int misra_5_9_count;
+// cppcheck-suppress misra-c2012-5.9
+static void misra_5_8_foo(void) {}
+
+// cppcheck-suppress misra-c2012-8.5
+extern int misra_8_5;
+
+// cppcheck-suppress misra-c2012-8.4
+// cppcheck-suppress misra-c2012-8.6
+int32_t misra_8_6 = 1;
+
+void misra_8_7_external(void) {}
+
+// #12362
+void misra_8_7_compliant( void ){}
+static void misra_8_7_call(void) { misra_8_7_compliant(); }
\ No newline at end of file
diff --git a/addons/test/misra/misra-ctu-2-test.c b/addons/test/misra/misra-ctu-2-test.c
new file mode 100644
index 00000000000..e08bd6d04a7
--- /dev/null
+++ b/addons/test/misra/misra-ctu-2-test.c
@@ -0,0 +1,59 @@
+// Test with command:
+// ./cppcheck --enable=information --enable=style --addon=misra --inline-suppr addons/test/misra/misra-ctu-*-test.c
+
+#include "misra-ctu-test.h"
+
+extern MISRA_2_3_B  misra_2_3_b;
+
+x = MISRA_2_5_OK_2;
+
+// cppcheck-suppress misra-c2012-5.6
+typedef int MISRA_5_6_VIOLATION;
+static MISRA_5_6_VIOLATION misra_5_6_x;
+
+// cppcheck-suppress misra-c2012-5.7
+struct misra_5_7_violation_t {
+    int x;  // cppcheck-suppress unusedStructMember
+};
+static misra_5_7_violation_t misra_5_7_use_type_2;
+
+// #11443 - FP
+static struct
+{ // no warning
+    uint16_t x;  // cppcheck-suppress unusedStructMember
+} misra_5_7_false_positive_2;
+
+// cppcheck-suppress misra-c2012-5.8
+static int misra_5_8_var1;
+// cppcheck-suppress misra-c2012-8.4
+// cppcheck-suppress misra-c2012-5.8
+void misra_5_8_f(void) {
+    // cppcheck-suppress [misra-c2012-5.8, unusedVariable]
+    char misra_5_8_var2;
+}
+
+// cppcheck-suppress misra-c2012-5.9
+static int misra_5_9_count;
+// cppcheck-suppress misra-c2012-5.9
+static void misra_5_8_foo(void) {}
+
+// cppcheck-suppress misra-c2012-8.5
+extern int misra_8_5;
+
+// cppcheck-suppress misra-c2012-8.4
+// cppcheck-suppress misra-c2012-8.6
+int32_t misra_8_6 = 2;
+int32_t misra_8_6_1;
+// cppcheck-suppress misra-c2012-8.7
+int32_t misra_8_6_1 = 2;
+// cppcheck-suppress misra-c2012-8.4
+// cppcheck-suppress misra-c2012-8.7
+void misra_8_7(void) {}
+static void misra_8_7_caller(void) { 
+    misra_8_7(); 
+    misra_8_7_external();
+}
+
+// #12362
+typedef void(*misra_8_7_func_ptr)( void );
+static const misra_8_7_func_ptr ptrs[] = { misra_8_7_compliant, NULL };
\ No newline at end of file
diff --git a/addons/test/misra/misra-ctu-test.h b/addons/test/misra/misra-ctu-test.h
new file mode 100644
index 00000000000..803e850b1f2
--- /dev/null
+++ b/addons/test/misra/misra-ctu-test.h
@@ -0,0 +1,24 @@
+
+
+typedef int MISRA_2_3_A;
+typedef int MISRA_2_3_B;
+typedef int MISRA_2_3_VIOLATION; // cppcheck-suppress misra-c2012-2.3
+
+// cppcheck-suppress misra-c2012-2.4
+struct misra_2_4_violation_t {
+    int x;
+};
+
+static inline void misra_5_9_exception(void) {}
+
+void misra_8_7_external(void);
+
+#define MISRA_2_5_OK_1 1
+#define MISRA_2_5_OK_2 2
+// cppcheck-suppress misra-c2012-2.5
+#define MISRA_2_5_VIOLATION 0
+
+// #12362
+extern void misra_8_7_compliant( void );
+
+#define MISRA_2_5_OK_3 This
\ No newline at end of file
diff --git a/addons/test/misra/misra-suppressions1-test.c b/addons/test/misra/misra-suppressions1-test.c
index 59c77598e8f..403d71f73ea 100644
--- a/addons/test/misra/misra-suppressions1-test.c
+++ b/addons/test/misra/misra-suppressions1-test.c
@@ -4,15 +4,18 @@
 
 // This needs to stay at line number 7 to make the test pass
 // If it is changed update suppressions.txt with the new line number
+// cppcheck-suppress-file misra-c2012-5.2
 #include <stdio.h> //21.6
 
-extern int misra_5_2_var_hides_var______31x;
+extern int misra_5_2_var_hides_var______31x;//8.4
 static int misra_5_2_var_hides_var______31y;//5.2
 static int misra_5_2_function_hides_var_31x;
-void misra_5_2_function_hides_var_31y(void) {}//5.2
-void foo(void)
+static void misra_5_2_function_hides_var_31y(void) {}//5.2
+static void foo(void)
 {
   int i;
+  // cppcheck-suppress-begin misra-c2012-16.4
+  // cppcheck-suppress misra-c2012-16.6
   switch(misra_5_2_func1()) //16.4 16.6
   {
     case 1:
@@ -21,13 +24,14 @@ void foo(void)
       {
         for(i = 0; i < 10; i++)
         {
-          if(misra_5_2_func3()) //14.4
+          if(misra_5_2_func3()) //17.3
           {
             int misra_5_2_var_hides_var_1____31x;
             int misra_5_2_var_hides_var_1____31y;//5.2
           }
         }
-      } while(misra_5_2_func2()); //14.4
+      } while(misra_5_2_func2()); //17.3
     }
   }
+  // cppcheck-suppress-end misra-c2012-16.4
 }
diff --git a/addons/test/misra/misra-suppressions2-test.c b/addons/test/misra/misra-suppressions2-test.c
index 7fadf186959..79d3f68191e 100644
--- a/addons/test/misra/misra-suppressions2-test.c
+++ b/addons/test/misra/misra-suppressions2-test.c
@@ -2,6 +2,7 @@
 // ../../cppcheck --suppressions-list=suppressions.txt --dump misra-suppressions*-test.c && python ../misra.py misra-suppressions*-test.c.dump
 // There should be no violations reported
 
+// cppcheck-suppress-file misra-c2012-5.2
 union misra_5_2_field_hides_field__63x { //19.2
 int misra_5_2_field_hides_field__31x;
 int misra_5_2_field_hides_field__31y;//5.2
@@ -10,5 +11,10 @@ struct misra_5_2_field_hides_field__63y { //5.2
 int misra_5_2_field_hides_field1_31x;
 int misra_5_2_field_hides_field1_31y;//5.2
 };
-const char *s41_1 = "\x41g"; // 4.1
-const char *s41_2 = "\x41\x42";
+const char *s41_1 = "\x41g"; // 4.1 8.4
+const char *s41_2 = "\x41\x42"; // 8.4
+
+// cppcheck-suppress misra-c2012-5.7
+struct misra_5_7_violation_t {
+    int x;
+};
diff --git a/addons/test/misra/misra-test-avr8.c b/addons/test/misra/misra-test-avr8.c
new file mode 100644
index 00000000000..faa6eb6b615
--- /dev/null
+++ b/addons/test/misra/misra-test-avr8.c
@@ -0,0 +1,29 @@
+// To test:
+// ~/cppcheck/cppcheck--dump -DDUMMY --suppress=uninitvar misra/misra-test-avr8.c --std=c89 --platform=avr8 && python3 ../misra.py -verify misra/misra-test-avr8.c.dump
+
+static void misra_10_4(void)
+{
+    // #10480
+    const char buf1[1] = {a};
+    const char c = '0';
+    x = buf1[0] - c;
+
+    const char buf2[2] = {x,y};
+    x = 'a' == buf2[0]; // no-warning
+
+    typedef struct  {
+      int t;
+      char buf[2];
+    } foo_t;
+    const foo_t cmd = {0};
+    x = 'b' == cmd.buf[0]; // no-warning
+
+    const foo_t * pcmd = &cmd;
+    x='c' == pcmd->buf[0]; // no-warning
+    (void)cmd.t;
+}
+
+static void misra_12_2(void) {
+  a = (((uint64_t)0xFF) << 32);
+}
+
diff --git a/addons/test/misra/misra-test-c11.c b/addons/test/misra/misra-test-c11.c
new file mode 100644
index 00000000000..031bc361e5f
--- /dev/null
+++ b/addons/test/misra/misra-test-c11.c
@@ -0,0 +1,25 @@
+// To test:
+// ~/cppcheck/cppcheck --dump misra/misra-test-c11.c --std=c11
+// ~/cppcheck/cppcheck --dump -DDUMMY --suppress=uninitvar --inline-suppr misra/misra-test-c11.c --std=c11 --platform=unix64 && python3 ../misra.py -verify misra/misra-test-c11.c.dump
+
+#include <stdint.h>
+
+typedef unsigned int UINT_TYPEDEF;
+struct struct_with_bitfields
+{
+  unsigned int a:2; // Compliant
+  signed int   b:2; // Compliant
+  UINT_TYPEDEF c:2; // Compliant
+  int          d:2; // 6.1 - plain int not compliant
+  signed long  f:2; // Compliant in c99 or later - explicitly signed integer type
+  unsigned int g:1; // Compliant
+  signed int   h:1; // 6.2 - signed int with size 1 is not compliant
+  uint16_t     i:1; // Compliant
+  bool         j:1; // Compliant in C99 or later
+};
+
+static void misra6_1_fn(void) {
+    // "Use" occurrence should not generate warnings
+    struct_with_bitfields s;
+    s.h = 61;
+}
diff --git a/addons/test/misra/misra-test.c b/addons/test/misra/misra-test.c
index a257592ae69..743637117a5 100644
--- a/addons/test/misra/misra-test.c
+++ b/addons/test/misra/misra-test.c
@@ -1,17 +1,58 @@
 // To test:
-// ~/cppcheck/cppcheck --dump misra-test.c && python ../../misra.py -verify misra-test.c.dump
+// ~/cppcheck/cppcheck --dump misra/misra-test.h --std=c89
+// ~/cppcheck/cppcheck --dump -DDUMMY --suppress=uninitvar --inline-suppr misra/misra-test.c --std=c89 --platform=unix64 && python3 ../misra.py -verify misra/misra-test.c.dump
+
+#pragma ghs section rodata=default // no warning
 
 #include "path\file.h" // 20.2
+#include "file//.h" // 20.2
+#include "file/*.h" // 20.2
+#include "file'.h" // 20.2
+#include <file,.h> // 20.2
+#include "file,.h" // 20.2
+
+#include "misra-test.h"
+
 #include /*abc*/ "file.h" // no warning
+/*foo*/#include "file.h" // no warning
+#include "./file.h" // no warning
+#include \
+    "file.h"
+#include /*abc*/ \
+    "file.h"
+#include "fi" "le.h" // 20.3 (strings are concatenated after preprocessing)
+#include "fi" <le.h> // 20.3
+#include <fi> <le.h> // 20.3
 #include PATH "file.h" // 20.3
+#define H_20_3_ok "file.h"
+#include H_20_3_ok
+#include file.h // 20.3
+#define H_20_3_bad file.h
+#include H_20_3_bad // TODO: 20.3 Trac #9606
+#include "//file.h" // 20.2
+#include "//file.h" H_20_3_bad // 20.2 20.3
+//#include H_20_3_bad // no warning
+#include H_20_3_ok H_20_3_ok // 20.3
 #include<file.h> // no warning
+
 #include <setjmp.h> // 21.4
 #include <signal.h> // 21.5
-#include <stdio.h> //21.6
-#include <wchar.h> //21.6
+#include <stdio.h>
+#include <wchar.h>
 #include <time.h> // 21.10
 #include <tgmath.h> // 21.11
+#include <fenv.h>
 
+// Check that the addon doesn't crash
+typedef struct {
+  union { // 19.2
+    struct {
+      unsigned a : 2;
+      unsigned : 14;
+    };
+    uint16_t value;
+  };
+} STRUCT_BITS;
 
 typedef unsigned char      u8;
 typedef unsigned short     u16;
@@ -19,42 +60,101 @@ typedef unsigned int       u32;
 typedef signed int         s32;
 typedef unsigned long long u64;
 
-//   // 3.1
+static void misra_1_2(bool expr)
+{
+    (void)(condition ? : 0); // 1.2
+    a = 1 + ({if (!expr) {code;} 1;}); // 1.2
+}
+
+static _Atomic int misra_1_4_var; // 1.4
+static _Noreturn void misra_1_4_func(void) // 1.4
+{
+    if (0 != _Generic(misra_1_4_var)) {} // 1.4 17.3
+    printf_s("hello"); // 1.4 17.3
+}
+
+#define MISRA_2_2 (1*60)
+
+static void misra_2_2(int x) {
+    int a;
+    a = x + 0; // 2.2
+    a = 0 + x; // 2.2
+    a = x * 0; // 2.2
+    a = 0 * x; // 2.2
+    a = x * 1; // 2.2
+    a = 1 * x; // 2.2
+    a = MISRA_2_2;
+    (void)a;
+}
+
+/* // */   // 3.1
+/* /* */   // 3.1
 ////
+/* https://cppcheck.net */
+
+// http://example.com // no warning
+
+static void misra_2_7_unused_param (int *param1, int unused_param)  // 2.7
+{
+    *param1 = 42U;
+}
+
+static void misra_2_7_used_params (int *param1, int param2, int param3)
+{
+    (void)param3;
+    *param1 = param2;
+}
+
+static void misra_2_7_a(int a,
+                        int b, // 2.7
+                        int c,
+                        int d) // 2.7
+{
+    (void)a;
+    (void)c;
+}
+static void misra_2_7_b(int a, int b, int c, // 2.7
+                        int d)               // 2.7
+{
+    (void)a;
+}
+static void misra_2_7_c(int a, ...) { (void)a; }
+static void misra_2_7_d(int) { } // 2.7 8.2
 
 extern int misra_5_1_extern_var_hides_var_x;
 extern int misra_5_1_extern_var_hides_var_y; //5.1
-int misra_5_1_var_hides_var________a;
-int misra_5_1_var_hides_var________b; int misra_5_1_var_hides_var________b1; int misra_5_1_var_hides_var________b2; //5.1
-int misra_5_1_var_hides_var________c; //5.1
-int misra_5_1_var_hides_var________d; //5.1
-int misra_5_1_var_hides_var________e; //5.1
+int misra_5_1_var_hides_var________a; // 8.4
+int misra_5_1_var_hides_var________b; int misra_5_1_var_hides_var________b1; int misra_5_1_var_hides_var________b2; //5.1 8.4
+int misra_5_1_var_hides_var________c; //5.1 8.4
+int misra_5_1_var_hides_var________d; //5.1 8.4
+int misra_5_1_var_hides_var________e; //5.1 8.4
 
 extern const uint8_t misra_5_2_var1;
-const uint8_t        misra_5_2_var1 = 3; // no warning
+const uint8_t        misra_5_2_var1 = 3;
 static int misra_5_2_var_hides_var______31x;
 static int misra_5_2_var_hides_var______31y;//5.2
 static int misra_5_2_function_hides_var_31x;
-void misra_5_2_function_hides_var_31y(void) {}//5.2
-void foo(void) 
+static void misra_5_2_function_hides_var_31y(void) {}//5.2
+static void foo(void)
 {
   int i;
-  switch(misra_5_2_func1()) //16.4 16.6
+  switch(misra_5_2_func1()) //16.4 16.6 17.3
   {
-    case 1: 
+    case 1:
     {
       do
       {
-        for(i = 0; i < 10; i++) 
+        for(i = 0; i < 10; i++)
         {
-          if(misra_5_2_func3()) //14.4
+          if(misra_5_2_func3()) //17.3
           {
             int misra_5_2_var_hides_var_1____31x;
             int misra_5_2_var_hides_var_1____31y;//5.2
           }
         }
-      } while(misra_5_2_func2()); //14.4
-    } 
+      } while(misra_5_2_func2()); //17.3
+    }
+    break;
   }
 }
 
@@ -66,65 +166,47 @@ struct misra_5_2_field_hides_field__63y { //5.2
 int misra_5_2_field_hides_field1_31x;
 int misra_5_2_field_hides_field1_31y;//5.2
 };
-const char *s41_1 = "\x41g"; // 4.1
-const char *s41_2 = "\x41\x42";
-const char *s41_3 = "\x41" "\x42";
-const char *s41_4 = "\x41" "g";
-const char *s41_5 = "\x41\xA";
-const char *s41_6 = "\xA\x41";
-const char *s41_7 = "\xAA\xg\x41"; // 4.1
-const char *s41_8 = "\xAA\x\x41"; // 4.1
-const char *s41_9 = "unknown\gsequence";
-const char *s41_10 = "simple\nsequence";
-const char *s41_11 = "string";
-int c41_3         = '\141t'; // 4.1
-int c41_4         = '\141\t';
-int c41_5         = '\0';
-int c41_6         = '\0\t';
-int c41_7         = '\12\t';
-int c41_8         = '\0t';   // 4.1
-int c41_9         = '\12';
-int c41_10        = '\12\n';
-int c41_11        = '\12n';  // 4.1
-int c41_12         = '\12323'; // 4.1
-int c41_13         = '\123\3';
-int c41_14         = '\777\777';
-int c41_15         = 'a';
-
-void misra_4_1()
+const char *s41_1 = "\x41g"; // 4.1 8.4
+const char *s41_2 = "\x41\x42"; // 8.4
+const char *s41_3 = "\x41" "\x42"; // 8.4
+const char *s41_4 = "\x41" "g"; // 8.4
+const char *s41_5 = "\x41\xA"; // 8.4
+const char *s41_6 = "\xA\x41"; // 8.4
+const char *s41_7 = "\xAA\xg\x41"; // 4.1 8.4
+const char *s41_8 = "\xAA\x\x41"; // 4.1 8.4
+const char *s41_9 = "unknown\gsequence"; // 8.4
+const char *s41_10 = "simple\nsequence"; // 8.4
+const char *s41_11 = "string"; // 8.4
+int c41_3         = '\141t'; // 4.1 8.4
+int c41_4         = '\141\t'; // 8.4
+int c41_5         = '\0'; // 10.3 8.4
+int c41_6         = '\0\t'; // 8.4
+int c41_7         = '\12\t'; // 8.4
+int c41_8         = '\0t';   // 4.1 8.4
+int c41_9         = '\12'; // 8.4
+int c41_10        = '\12\n'; // 8.4
+int c41_11        = '\12n';  // 4.1 8.4
+int c41_12         = '\12323'; // 4.1 8.4
+int c41_13         = '\123\3'; // 8.4
+// TODO int c41_14         = '\777\777';
+int c41_15         = 'a'; // 10.3 8.4
+
+static void misra_4_1(void)
 {
-    (void)printf("\x41g"); // 4.1
-    (void)printf("\x41\x42");
-    (void)printf("\x41" "g");
+    (void)printf("\x41g"); // 4.1 21.6
+    (void)printf("\x41\x42"); //21.6
+    (void)printf("\x41" "g"); //21.6
 }
 
-extern int misra_5_3_var_hides_var______31x;
-void misra_5_3_var_hides_function_31x (void) {}
-enum misra_5_3_Enum {
-misra_5_3_var_hidesenumconst_31x = 2,misra_5_3_enum_hidesfunction_31x = 5
-};
-void misra_5_3_func1(void)
+const char *s42_1 = "String containing trigraphs ??-??-??";   // 4.2 8.4
+const char *s42_2 = "String containing trigraph???=preceded by question mark";   // 4.2 8.4
+const char *s42_3 = "No trigraph?(?'?)"; // 8.4
+
+static void misra_4_2(void)
 {
-  int misra_5_3_var_hides_var______31y; //5.3
-  int misra_5_3_var_hides_function_31y; //5.3
-  int misra_5_3_var_hidesenumconst_31y; //5.3
-  switch(misra_5_3_func2()) //16.4 16.6
-  {
-    case 1:
-    {
-      do 
-      {
-        int misra_5_3_var_hides_var_1____31x;
-        if(misra_5_3_func3()) //14.4
-        {
-          int misra_5_3_var_hides_var_1____31y = 1; //5.3
-        }
-      } while(misra_5_3_func2()); //14.4
-    }
-  }
+    (void)printf("??=Trigraph\n");   // 4.2 21.6
+    (void)printf("No?/Trigraph\n"); //21.6
 }
-void misra_5_3_enum_hidesfunction_31y(void) {} //5.3
-
 
 #define misra_5_4_macro_hides_macro__31x 1
 #define misra_5_4_param_hides_macro__31x 1
@@ -143,41 +225,192 @@ void misra_5_3_enum_hidesfunction_31y(void) {} //5.3
 #define misra_5_5_tag_hides_macro____31x 1
 #define misra_5_5_hides_macro________31x 1
 
-int misra_5_5_var_hides_macro____31y; //5.5
-void misra_5_5_functionhides_macro31y(int misra_5_5_param_hides_macro__31y){} //5.5
+int misra_5_5_var_hides_macro____31y; //5.5 8.4
+static void misra_5_5_functionhides_macro31y(int misra_5_5_param_hides_macro__31y){(void)misra_5_5_param_hides_macro__31y;} //5.5
 struct misra_5_5_tag_hides_macro____31y { //5.5
 int x;
 };
-void misra_5_5_func1() 
+static void misra_5_5_func1(void)
 {
-  switch(misra_5_5_func2()) //16.4 16.6
+  switch(misra_5_5_func2()) //16.4 16.6 17.3
   {
     case 1:
     {
-      do 
+      do
       {
-        if(misra_5_5_func3()) //14.4
+        if(misra_5_5_func3()) //17.3
         {
           int misra_5_5_hides_macro________31y; //5.5
         }
-      } while(misra_5_5_func2()); //14.4
+      } while(misra_5_5_func2()); //17.3
     }
+    break;
   }
 }
 
+typedef unsigned int UINT_TYPEDEF;
+struct struct_with_bitfields
+{
+  unsigned int a:2; // Compliant
+  signed int   b:2; // Compliant
+  UINT_TYPEDEF c:2; // Compliant
+  int          d:2; // 6.1 - plain int not compliant
+  signed long  f:2; // 6.1 - signed long not compliant
+  unsigned int g:1; // Compliant
+  signed int   h:1; // 6.2 - signed int with size 1 is not compliant
+  uint16_t     i:1; // Compliant
+  bool         j:1; // 6.1 - bool not legal until c99
+};
+
+static void misra6_1_fn(void) {
+    // "Use" occurrence should not generate warnings
+    struct_with_bitfields s;
+    s.h = 61;
+}
 
-void misra_7_1() {
+static void misra_7_1(void) {
   int x = 066; // 7.1
 }
 
-void misra_7_3() {
-  long misra_7_3_a = 0l; //7.3       
-  long misra_7_3_b = 0lU; //7.3     
-  long long misra_7_3_c = 0Ull; //7.3     
-  long long misra_7_3_d = 0ll; //7.3     
-  long double misra_7_3_e = 7.3l; //7.3  
-  }
+static void misra_7_2(void) {
+    uint32_t a = 0x7fffffff;
+    uint32_t b = 0x80000000; // 7.2
+    uint32_t c = 0x80000000U;
+    uint32_t d = 2147483647;
+    uint64_t e = 2147483648;
+    uint32_t f = 2147483648U;
+}
 
+// The addon should not generate false positives for the identifiers.
+struct misra_7_3_s
+{
+  uint32_t ul_clka;
+  uint32_t test123l;
+  float t = 6.02E23l; // 7.3
+  float t1 = 6.02E23L;
+  float u = 0xa1B2.p12l; // 7.3
+  float u1 = 0xa1B2.p12L;
+  float v = 0xa1B2.P12l; // 7.3
+  float v1 = 0xa1B2.P12L;
+  float w = 6.02e23l; // 7.3
+  float w1 = 6.02e23L;
+  unsigned long  x = 0xabcul; // 7.3
+  unsigned long x1 = 0xabcuL;
+  unsigned long y = 0xABCUl; // 7.3
+  unsigned long y1 = 0xABCUL;
+  unsigned long z = 0XdeadBeEfUl; // 7.3
+  unsigned long z1 = 0XdeadBeEfUL;
+};
+
+static void misra_7_3(void) {
+  long misra_7_3_a = 0l; //7.3
+  long misra_7_3_b = 0lU; //7.3
+  long long misra_7_3_c = 0Ull; //7.3
+  long long misra_7_3_d = 0ll; //7.3
+  long double misra_7_3_e = 7.3l; //7.3
+  struct misra_7_3_s misra_7_3_f =
+  {
+    .ul_clka = 19U,
+    .test123l = 23U
+  };
+}
+
+typedef const char* MISRA_7_4_CHAR_CONST;
+static MISRA_7_4_CHAR_CONST misra_7_4_return_const_type_def (void) { return "return_typedef_const"; }
+static char *misra_7_4_return_non_const (void) { return 1 + "return_non_const"; } // 7.4 18.4
+static const char *misra_7_4_return_const (void) { return 1 + "return_const"; } // 18.4
+
+static void misra_7_4_const_call(int a, const char* b) { } // 2.7
+static void misra_7_4_const_ptr_call(int a, const char const* b) { } // 2.7
+static void misra_7_4_call(int a, char* b) { } // 2.7
+static void misra_7_4_call_2(int a, ...) { } // 2.7
+
+static void misra_7_4(void)
+{
+   const char *a = "text a";
+   char* const b = "text_b"; // 7.4
+   char *c = "text c";  // 7.4
+   char *d = 1 + "text d"; // 7.4 18.4
+   char *e = "text e" + 1 + 2; // 7.4 18.4
+   char *f = 1 + "text f" + 2; // 7.4 18.4
+   const wchar_t *g = "text_g";
+   wchar_t *h = "text_h"; // 7.4
+
+   misra_7_4_const_call(1, ("text_const_call"));
+   misra_7_4_const_ptr_call(1, ("text_const_call"));
+   misra_7_4_call(1, "text_call"); // 7.4 11.8
+   misra_7_4_call_2(1, "a", "b");
+}
+
+const misra_8_1_a; // 8.1 8.4
+
+static int misra_8_2_a (int n, ...);
+extern int misra_8_2_b (int n);
+extern int misra_8_2_c (int); // 8.2
+static int misra_8_2_d (); // 8.2
+static int misra_8_2_e (void);
+static int misra_8_2_f (vec, n )
+int *vec; // 8.2
+int n; // 8.2
+{
+    return vec[ n - 1 ];
+}
+static int misra_8_2_g ( /* comment */ ); // 8.2
+static int misra_8_2_h ( /* comment 1 */ /* comment 2 */ ); // 8.2
+static int misra_8_2_i ( /* comment */ void);
+static int misra_8_2_j ( /* comment */ void /* comment */);
+static int misra_8_2_k ( //
+ void);
+static int misra_8_2_l ( // 8.2
+);
+static void misra_8_2_m(uint8_t * const x);
+static void misra_8_2_m(uint8_t * const x)
+{
+(void)x;
+}
+int16_t ( *misra_8_2_p_a ) (); // 8.2 8.4
+int16_t ( *misra_8_2_p_b ) (void); // 8.4
+int16_t ( *misra_8_2_p_c ) (int); // 8.4
+static int misra_8_2_n(int a)
+{ return a + 42; }
+static int misra_8_2_o(
+    const uint32_t a1,
+    const uint8_t *const a2
+)
+{ return *a2 + a1; }
+static int misra_8_2_p(
+    const uint32_t a1,
+    const uint8_t *const a2
+);
+static int misra_8_2_q
+(); // 8.2
+
+void misra_8_4_foo(void) {} // 8.4
+extern void misra_8_4_func(void);
+void misra_8_4_func(void) {}
+static void misra_8_4_bar(void) {} // Declared in header
+extern int16_t misra_8_4_count; // no-warning
+int16_t misra_8_4_count = 0; // Compliant
+extern uint8_t misra_8_4_buf1[13]; // no-warning
+uint8_t misra_8_4_buf2[24]; // 8.4
+typedef struct { uint16_t a; uint16_t b; } misra_8_4_struct;
+extern misra_8_4_struct bar[42];
+misra_8_4_struct bar[42]; // compliant
+extern uint16_t misra_8_4_speed = 6000u; //8.4
+uint8_t misra_8_4_pressure = 101u; //8.4
+int32_t misra_8_4_ext_val2;
+int32_t misra_8_4_ext_val2 = 3; // compliant
+int32_t misra_8_4_ext_val4; //8.4
+// #12978
+const stError_t * m8_4_pubTestPointer; //compliant
+
+static int32_t misra_8_8 = 123;
+extern int32_t misra_8_8; // 8.8
+
+static int32_t misra_8_9_i; // 8.9
+static int32_t misra_8_9_foo(void) { return misra_8_9_i++; }
+
+inline int32_t misra_8_10_value(void) { return 123; } // 8.10 8.4
 
 extern int a811[]; // 8.11
 
@@ -187,84 +420,462 @@ enum misra_8_12_c { misra_c1 = misra_a1, misra_c2 = 1 }; // no-warning
 enum misra_8_12_d { misra_d1 = 1, misra_d2 = 2, misra_d3 = misra_d1 }; // no-warning
 enum misra_8_12_e { misra_e1 = sizeof(int), misra_e2}; // no-crash
 
-void misra_8_14(char * restrict str) {} // 8.14
+static void misra_8_14(char * restrict str) {(void)str;} // 8.14
+
+// #11707 -- false positive
+struct S_9_3 { struct S_9_3* p; int x; };
+struct S_9_3* s_9_3_array[] = { x, NULL }; // 8.4
+
+// #10854
+struct Entry_9_2{
+    union{ // 19.2
+        const int *p;
+        int x;
+    };
+    int y;
+};
+
+static void misra_9_2_10854(void){
+    struct Entry_9_2 e1[] =
+    {
+        {{ .x = 1 }, .y = 2 }
+    };
+}
+static void misra_9_empty_or_zero_initializers(void) {
+    int a[2]    = {};                          // 9.2
+    int b[2][2] = {};                          // 9.2
+    int c[2][2] = { {} };                      // 9.2 9.3
+    int d[2][2] = { {}, {} };                  // 9.2
+    int e[2][2] = { { 1 , 2 }, {} };           // 9.2
+
+    int f[5]    = { 0 };
+    int f1[5]   = { 0u };                     // 9.3
+    unsigned int f1[ 3 ][ 2 ] = { 0U };       // 9.3 9.2
+    unsigned int f2[ 3 ] = { 0U };            // 9.3
+    float f3[ 3 ][ 2 ]  = { 0.0F };           // 9.3 9.2
+    int g[5][2] = { 0 };
+    int h[2][2] = { { 0 } };                   // 9.3
+    int i[2][2] = { { 0 }, { 0 } };
+    int j[2][2] = { { 1, 2 }, { 0 } };
+    int k[2][2] = { [0] = { 1 , 2 }, { 0 } };
+    int l[1][2] = { { 0 }, [0] = { 1 } };      // 9.3 9.4
+
+    typedef struct {
+        int a;
+        int b;
+    } struct1;
+
+    struct1 m   = { };                         // 9.2
+    struct1 n   = { 0 };
+}
+
+static void misra_9_string_initializers(void) {
+    const char a[12]    = { "Hello world" };           // 9.2
+    const char b[2][20] = "Hello world";               // 9.2 9.3
+    const char c[]      = "Hello world";
+    const char d[15]    = "Hello world";
+    const char e[1][12] = { "Hello world" };
+    const char *f[2]    = { "Hello", [1] = "world" };
+    const char *g[1]    = "Hello world";               // 9.2
+
+    const char h[2][15] = { { 0 }, "Hello world" };
+
+    char **str_p = &f[0];
+
+    char **i[1]         = { str_p };
+    char **j[1]         = { { str_p } };               // 9.2
+}
+
+static void misra_9_array_initializers(void) {
+    char    a[4]        = { 1, 2, 3, 4 };
+    char    b[2][2]     = { {1, 2}, {3, 4} };
+    char    c[2][2]     = { 1, 2, 3, 4 };                                   // 9.2
+    char    d[6]        = { { 1, 2 }, { 3, 4 }, { 5, 6 } };                 // 9.2 9.3
+
+    char    e[2][2]     = { {1, 2}, {4} };                                  // 9.3
+    char    f[2][2]     = { 1, 2, 3 };                                      // 9.2 9.3
+    char    g[2][2]     = { {1, 2, 3, 4} };                                 // 9.3
+
+    char    h[2][2]     = { { 1, { 2 } }, { 3, { 5 } } };                   // 9.2
+    char    i[2][2]     = { { 1, { 2 } }, { 3 } };                          // 9.2 9.3
+    char    j[2][3]     = { { 1, { 2 }, 3 }, { 4, { 5 }, 6 } };             // 9.2
+    char    k[2][3]     = { { 1, { 2 }, 3 }, { 4, { 5 } } };                // 9.2 9.3
+    char    l[3]        = { 1, { 2, 3 } };                                  // 9.2 9.3
+}
+
+static void misra_9_array_initializers_with_designators(void) {
+    char    a[1]        = { [0][1] = 1 };                                   // 9.2
+    char    b[1]        = { [0] = { 1, 2 } };                               // 9.2
+    char    c[2][2]     = { [0] = {1, 2, 3} };
+    char    d[1][2]     = { [0] = 1 };                                      // 9.2
+    char    e[2][2]     = { { 1, 2 }, [1][0] = {3, 4} };                    // 9.2
+    int     e1[2][2]    = { [ 0 ][ 1 ] = 0, { 5, 6 } };                     // no warning #12419
+    char    f[2]        = { [0] = 1, 2 };
+    char    g[2]        = { [1] = 2, [0] = 1 };
+    char    h[2][2]     = { { 1, 2 }, [1] = { 3 } };                        // 9.3
+    char    i[2][2]     = { { 1, 2 }, [1] = { 3, 4 } };
+    char    j[2][2]     = { { 1, 2 }, [1] = { [0] = 3 } };
+    char    k[2][2]     = { { 1, 2 }, [1][0] = 3 };
+    char    l[2][2]     = { { 1, 2 }, [1][0] = 3, 4};                       // 9.2
+    char    m[2][2]     = { [0] = { [2] = 2 }, [1][5] = 4 };
+    char    n[2][2]     = { [0] = { 1 } };                                  // 9.3
+    char    o[2][2]     = { { 1 }, [1][0] = 3 };                            // 9.3
+    char    p[2][2]     = { { 1, 2 }, { 3, 4 }, [1] = { 3 } };              // 9.3 9.4
+    // cppcheck-suppress unknownEvaluationOrder
+    char    q[2][2]     = { { 1, 2 }, { 1 }, [1] = { [1] = 3 } };           // 9.4
+    char    r[2][2][2]  = { [0][0] = { 1, 2 }, [1] = { [0] = {5, 6} } };
+    char    s[2][2][2]  = { [0][0] = { 1, 2 }, [1] = {5, 6, 7, 8}};         // 9.2
+    char    t[2][2][2]  = { [0][0] = { 1, 2 }, {3, 4}, [1] = {5, 6}};       // 9.2 9.3
+    char    u[2][2][2]  = { [0] = { 1, 2, {3, 4} } };                       // 9.2
+    char    v[2][2][2]  = { [0] = { 1, 2, [1] = {3, 4} }};                  // 9.2
+}
+
+static void misra_9_struct_initializers(void) {
+    typedef struct {
+        int i1;
+        int i2;
+    } struct1;
+
+    typedef struct {
+        char c1;
+        struct1 is1;
+        char c2[4];
+    } struct2;
+
+    typedef struct {
+        struct1 s[2][2];
+    } struct3;
+
+    typedef struct {
+        unknown_field_type f1;
+        unknown_field_type f2[2];
+        int f3[2];
+    } struct_with_unknown_fields;
+
+    struct3 sa[2]  = { [1].s[1][0].i1 = 3, 4 };         // 9.2
+
+    struct1 sa          = 1;                            // 9.2
+
+    struct1 sb     = { 1, 2 };
+    struct2 sc     = { 1, { 2 }, {4, 5, 6, 7} };
+    struct2 sd     = { 1, { 2, 3 }, {4, 5, 6} };        // 9.3
+    struct2 se     = { 1, 2, 3, 4, 5, 6, 7  };          // 9.2
+    struct2 sf     = { 1, { 2, 3 }, 4, 5, 6, 7 };       // 9.2
+    struct2 sg     = { 1, { 2 }, 4, 5, 6, 7 };          // 9.2
+    struct2 sh     = { 1, { 2, 3 }, 4, 5, 6 };          // 9.2 9.3
+    struct2 si     = { 1, 2, 3, {4,5,6,7} };            // 9.2
+
+    int a;
+    struct1 sj     = { a = 1, 2 };                      // 13.1
+
+    // Struct types
+    struct2 sta      = { .is1 = sc }; // 9.2
+    struct2 stb      = { .is1 = sb };
+    struct1 stc[1]   = { sc };        // 9.2
+    struct1 std[1]   = { sb };
+
+    // Struct designators
+    struct1 sda    = { 1, .i2 = 2 };
+    struct2 sdb    = { 1, { 2, .i2=3 }, .c2[1]=5 };
+    struct2 sdc    = { 1, { 2, .i2=3 }, .c2 = { 5 } };        // 9.3
+    struct2 sdd    = { 1, { 2, .i2=3 }, .c2 = 5 };            // 9.2
+    struct2 sde    = { .is1 = { 2, 3 }, { 4, 5, 6, 7 } };
+
+    // Struct arrays
+    struct1 asa[2] = { {1,2}, {3,4} };
+    struct1 asb[2] = { {1}, {3,4} };
+    struct1 asc[2] = { {1,2} };                               // 9.3
+    struct1 asd[2] = { 1,2, 3,4 };                            // 9.2
+    struct1 ase[2] = { 1,2, 3 };                              // 9.2
+    struct1 asf[2] = { 1,2 };                                 // 9.2 9.3
+    struct1 asg[2] = { [1].i1 = 3 };
+    struct3 ash[2] = { [1].s[1][0].i1 = 3 };
+    struct3 asi[2] = { [0] = { .s[0] = { { 1, 2 } }}};        // 9.3
+    struct3 asj[2] = { [0] = { .s[0] = { 1, 2 }}};            // 9.2 9.3
+
+    // Missing type information
+    dummy_struct dsa       = { 1, .a = 2 };
+    dummy_struct dsb[2]    = { {1,2}, {3,4} };
+    dummy_struct dsc[2][2] = { {1,2}, {3,4} };
+    dummy_struct dsd[2][2] = { 1, 2, 3, 4 };                  // 9.2
+    dummy_struct dse[3]    = { {1,2}, {3,4}, [1] = {5,6} };   // 9.3 9.4
+    dummy_struct dsf[]     = { [0] = 1 };                     // 9.5
+    dummy_struct dsg       = { .a = {0}, .b = {0} };
+    dummy_struct dsh[2][2] = { { {.a = 0, .b = {0}}, { 0 } }, { { 0 }, {.a = 0, .b = {0}}} };
+
+    // Struct with fields of unknown type
+    struct_with_unknown_fields ufa       = { 1, { 1, 2 }, { 1, 2 } };
+    struct_with_unknown_fields ufb       = { 1, 1, 2 };                     // 9.2
+    struct_with_unknown_fields ufc[2]    = { {1, { 1, 2 }, { 1, 2 } },
+                                             { 2, { 1, 2 }, { 1, 2 } } };
+    struct_with_unknown_fields ufd[2][2] = { {1, { 1, 2 }, { 1, 2 } },      // 9.2 9.3
+                                             { 2, { 1, 2 }, { 1, 2 } } };
+    struct_with_unknown_fields ufe[2]    = { 1, { 1, 2 }, { 1, 2 },         // 9.2 9.3
+                                             2, { 1, 2 }, { 1, 2 } };
+    struct_with_unknown_fields uff[3]    = { { 1, { 1, 2 }, { 1, 2 }},      // 9.3 9.4
+                                             {2, { 1, 2 }, { 1, 2 }},
+                                             [1] = { 2, { 1, 2 }, { 1, 2 }} };
+
+    // Obsolete initialization syntax for GCC
+    struct1 os1 = { i1: 1, i2: 2 }; // 10.4 13.4
+}
+
+static void misra_9_2(void) {
+    union misra_9_2_union {     // 19.2
+        char c;
+        struct1 i;
+    } u = { 3 };                // 19.2
+}
+
+static void misra_9_5(void) {
+    char a[]    = { 1, 2, 3 };
+    char b[]    = { [2] = 5 };                          // 9.5
+    char c[]    = { 1, [1] = 5 };                       // 9.5
+    char d[]    = { [1] = 2, [0] = 1 };                 // 9.5
 
-void misra_9_5() {
-  int x[] = {[0]=23}; // 9.5
+    char e[][2] = { { 1, 2 }, { 3, 4 } };
+    char f[][2] = { [1] = { 3, 4 } };                   // 9.5
+    char g[][2] = { { 1, 2 }, [1] = { 3, 4 } };         // 9.5
+    char h[][2] = { [1] = { 1, 2 }, [0] = { 3, 4 } };   // 9.5
 }
 
-void misra_10_1(uint8_t u) {
+typedef char misra_10_1_char_t;
+#define MISRA_10_1_CHAR char
+static void misra_10_1(uint32_t u, char c1, char c2, uint8_t u8) {
   int32_t i;
+  char c;
+  enum { E1 = 1 };
   i = 3 << 1; // 10.1
   i = (u & u) << 4; // no-warning
+  c = c1 & c2; // 10.1
+  c = c1 << 1; // 10.1
+  i = c1 > c2; // 10.3
+  i = E1 + i; // no-warning
+
+  char ch1 = 'a';
+  char ch2 = 'b';
+  char ch3;
+  ch3 = ch1 & ch2; // 10.1
+
+  misra_10_1_char_t ct1 = 'a';
+  misra_10_1_char_t ct2 = 'b';
+  misra_10_1_char_t ct3;
+  ct3 = ct1 & ct2; // 10.1
+
+  MISRA_10_1_CHAR cd1 = 'a';
+  MISRA_10_1_CHAR cd2 = 'b';
+  MISRA_10_1_CHAR cd3;
+  cd3 = cd1 & cd2; // 10.1
+
+  uint8_t temp1 = u8 & 0x42U; // no-warning
+}
+static void misra_10_1_ternary(void)
+{
+    int a;
+    uint8_t ui8;
+    uint16_t ui16;
+    int8_t i8;
+    int16_t i16;
+
+    a = ui16 << ui16; // 10.6
+    a = ui16 << (get_bool(42) ? ui16 : ui16); // 17.3
+    a = ui16 << (get_bool(42) ? ui16 : (get_bool(34) ? ui16 : ui16)); // 17.3
+    a = ui16 << (get_bool(42) ? (get_bool(34) ? ui16 : ui16) : ui16); // 17.3
+    a = ui16 << (get_bool(42) ? i16 : (get_bool(34) ? ui16 : ui16)); // 10.1 10.4 17.3
+    a = ui16 << (get_bool(42) ? (get_bool(34) ? ui16 : i16) : ui16); // 10.1 10.4 17.3
+    a = ui16 << (get_bool(42) ? (get_bool(34) ? ui16 : ui16) : i16); // 10.1 10.4 17.3
+    a = ui16 << (get_bool(42) ? (get_bool(34) ? ui16 : ui8) : ui8); // 10.4 17.3
+    a = ui16 << (get_bool(42) ? (get_bool(34) ? i16 : ui8) : ui8); // 10.1 10.4 17.3
+    a = (get_bool(42) ? (get_bool(34) ? ui16 : ui8) : ui8) << ui16; // 10.4 17.3
+    a = (get_bool(42) ? (get_bool(34) ? i16 : ui8) : ui8) << ui16; // 10.1 10.4 17.3
+    a = (get_bool(42) ? (get_bool(34) ? ui16 : i8) : ui8) << ui16; // 10.1 10.4 17.3
+    a = (get_bool(42) ? (get_bool(34) ? ui16 : ui8) : i8) << ui16; // 10.1 17.3
+    a = (get_bool(42) ? (get_bool(34) ? ui16 : ui8) : ui8) << (get_bool(19) ? ui16 : ui8); // 10.4 17.3
+    a = (get_bool(42) ? (get_bool(34) ? i16 : ui8) : ui8) << (get_bool(19) ? ui16 : ui8); // 10.1 10.4 17.3
+    a = (get_bool(42) ? (get_bool(34) ? ui16 : ui8) : ui8) << (get_bool(19) ? i16 : ui8); // 10.1 10.4 17.3
 }
 
-void misra_10_4(u32 x, s32 y) {
+static void misra_10_2(void) {
+    uint8_t u8a = 0;
+    char cha = 0;
+    int8_t s8a = 0;
+    int16_t s16a = 0;
+    float f32a = 0.0;
+    char res;
+
+    res = '0' + u8a; // Convert u8a to digit
+    res = s8a + '0';
+    res = cha - '0';
+    res = '0' - s8a;
+    res = cha + ':'; // 10.2
+
+    res = s16a - 'a'; // 10.2 10.3 10.4
+    res = '0' + f32a; // 10.2 10.4
+
+    // 10481 - crash
+    char buf[1] = {'f'};
+    x = buf[0] - '0';
+}
+
+static void misra_10_3(uint32_t u32a, uint32_t u32b) {
+    uint8_t res;
+    res = u32a + u32b; // 10.3
+    res = (uint16_t)(2U + 3U); // 10.3 10.8
+    res = 2U + 3U; // no warning, utlr=unsigned char
+    res = 0.1f; // 10.3
+    const char c = '0'; // no-warning
+    bool b = true; // no-warning
+    uint32_t u = UINT32_C(10); // no-warning
+}
+
+static void misra_10_4(u32 x, s32 y) {
   z = x + 3; // 10.4
   enum misra_10_4_enuma { misra_10_4_A1, misra_10_4_A2, misra_10_4_A3 } a;
   enum misra_10_4_enumb { misra_10_4_B1, misra_10_4_B2, misra_10_4_B3 };
   if ( misra_10_4_B1 > misra_10_4_A1 ) //10.4
    {
-      ; 
+      ;
    }
   z = x + y; //10.4
   z = (a == misra_10_4_A3) ? x : y; //10.4
   z = (a == misra_10_4_A3) ? y : y; // no-warning
+
+  // #10499
+  const char buf[10] = {0};
+  if ('0' == buf[x]) // no-warning
+  {
+  }
+
+  const struct foo_s{
+    int t;
+    char buf[2];
+  } cmd = {0};
+  if ('\0' == cmd.buf[0]) //no-warning
+  {
+  }
+
+  // #10652
+  char c;
+  if ((char)'1' == c) {}            // no warning
+  if ((unsigned char)'1' == c) {}   //10.4
+  if ((signed char)'1' == c) {}     //10.4
 }
 
-void misra_10_6(u8 x, u32 a, u32 b) {
-  u16 y = x+x; // 10.6
+static void misra_10_5(uint16_t x) {
+    // bool
+    res = (uint16_t) (x > 10u); // 10.5
+    res = (bool) 1u; // no-warning
+
+    // char <=> float
+    res = (char) 0.1f;
+    res = (float) 'x';
+}
+
+struct misra_10_6_s {
+    unsigned int a:4;
+};
+static void misra_10_6(u8 x, char c1, char c2) {
+  u16 y1 = x+x; // 10.6
+  u16 y2 = (0x100u - 0x80u); // rhs is not a composite expression because it's a constant expression
+  int b = (y2 == y2) ? 0 : 1; // no-warning
   u16 z = ~u8 x ;//10.6
-  u32 c = ( u16) ( u32 a + u32 b ); //10.6
+  s32 i = c1 - c2; // 10.3
+  struct misra_10_6_s s;
+  s.a = x & 1U; // no-warning (#10487)
+}
+static void misra_10_6_1(uint32_t *a, uint16_t b, uint16_t c)
+{
+    *a = b + c ; // 10.6
 }
 
-void misra_10_8(u8 x, s32 a, s32 b) {
+static void misra_10_7_f1(struct Timer *pSelf, uint32_t interval_ms);
+static void misra_10_7(uint16_t u16a, uint16_t u16b) {
+    uint32_t u32a = 100u;
+    res = u32a * u16a + u16b; // 12.1 no-warning
+    res = (u32a * u16a) + u16b; // no-warning
+    res = u32a * ( ( uint32_t ) u16a + u16b ); // no-warning
+    res = u32a * (u16a + u16b); // 10.7
+    u32a *= u16a + u16b; // 10.7
+    u32a = ((uint32_t)4 * (uint32_t)2 * (uint32_t)4 ); // no-warning (#10488)
+    dostuff(&t, (2*60*1000)); // 17.3 no-warning
+}
+
+static void misra_10_8(u8 x, s32 a, s32 b) {
   y = (u16)x;
   y = (u16)(x+x); // 10.8
   y = (u16) (a + b) //10.8
 }
 
+int (*misra_11_1_p)(void); // 8.4
+void *misra_11_1_bad1 = (void*)misra_11_1_p; // 11.1 8.4
+
+// #12172
+typedef void (*pfFunc_11_1)(uint32_t some);
+extern pfFunc_11_1 data_11_1[10];
+void func_11_1(pfFunc_11_1 ptr){ //8.4
+    data_11_1[index] = ptr; // no-warning
+}
+
+struct misra_11_2_s;
+struct misra_11_2_t;
+
+static struct misra_11_2_s * sp;
+static struct misra_11_2_t * tp = sp; // 11.2
+
 struct Fred {}; struct Wilma {};
-void misra_11_3(u8* p, struct Fred *fred) {
+static void misra_11_3(u8* p, struct Fred *fred) {
   x = (u64*)p; // 11.3
   struct Wilma *wilma = (struct Wilma *)fred; // 11.3
 }
 
-void misra_11_4(u8*p) {
+typedef struct { uint32_t something; } struct_11_4;
+#define A_11_4 ((struct_11_4 *)0x40000U)  // 11.4
+
+static void misra_11_4(u8*p) {
   u64 y = (u64)p; // 11.4
   u8 *misra_11_4_A = ( u8 * ) 0x0005;// 11.4
   s32 misra_11_4_B;
   u8 *q = ( u8 * ) misra_11_4_B; // 11.4
-
+  dummy = A_11_4->something; // no-warning
 }
 
-void misra_11_5(void *p) {
+static void misra_11_5(void *p) {
   u16 *p16;
   x = (u8 *)p; // 11.5
   p16 = p;     // 11.5
 }
 
-void misra_11_6() {
+static intptr_t get_intptr_constant(void) { return 456; }
+static void misra_11_6(void) {
   void *p;
+  struct {
+    int i;
+  } s = { .i = 7 };
   p = (void*)123;  // 11.6
   x = (u64)p;      // 11.6
+  p = (void*)(1+1);// 11.6
+  p = (void*)get_intptr_constant(); // 11.6
+  p = (void*)s.i;  // 11.6
   p = ( void * )0; // no-warning
   (void)p;         // no-warning
+  // # 12184
+  p = (void*)0U;   // no-warning
 }
 
 
-void misra_11_7(int *p, float f) {
+static void misra_11_7(int *p, float f) {
   x = ( float ) p; //11.7
   y = ( int * ) f; //11.7
 }
 
-void misra_11_7_extra(int *p, float f, bool b) {
+static void misra_11_7_extra(int *p, float f, bool b) {
   (void) p; // no-warning
   (void) f; // no-warning
+  (void) b; // no-warning
 }
 
-char * misra_11_8_const(const char *str) {  }
-char * misra_11_8(const char *str) {
+static void misra_11_8_const(const char *str) {(void)str;}
+static char * misra_11_8(const char *str) {
   (void)misra_11_8_const(str); // no-warning
   return (char *)str; // 11.8
 }
@@ -272,7 +883,7 @@ char * misra_11_8(const char *str) {
 #define MISRA_11_9_NULL_1 (1-1)
 #define MISRA_11_9_NULL_2 ( void * ) 0
 #define MISRA_11_9_NULL_3 NULL
-void misra_11_9(){
+static void misra_11_9(void) {
   int *p1 = (5-5); //11.9
   int *p2 = MISRA_11_9_NULL_2 ; // no-warning
   int *p3 = MISRA_11_9_NULL_3 ; // no-warning
@@ -284,34 +895,291 @@ void misra_11_9(){
 }
 
 
-void misra_12_1() {
+static void misra_12_1(void) {
   sz = sizeof x + y; // 12.1
   a = (b * c) + d;
   a = b << c + d; // 12.1
 }
 
-void misra_12_2(u8 x) {
+static void misra_12_2(u8 x) {
   a = x << 8;  // 12.2
 }
 
-void misra_12_3() {
-  f((1,2),3); // TODO
-  for (i=0;i<10;i++,j++){} // 12.3
+static int misra_12_3_v1 = 0, misra_12_3_v2; // 12.3
+static int misra_12_3_v3, misra_12_3_v4; // 12.3
+enum misra_12_3_e1 { M123A1, M123B1, M123C1 };
+enum misra_12_3_e2 { M123A2 = 3, M123B2 = 4, M123C2 };
+typedef enum misra_12_3_e3 { M123A3 , M123B3, M123C3 } misra_12_3_e3_t;
+typedef enum { M123A4 , M123B4, M123C4 } misra_12_3_e4_t;
+struct misra_12_3_s1 { int a; int b; int c, d; }; // 12.3
+static struct misra_12_3_s1 misra_12_3_s1_inst = {
+  3,
+  4, 5,
+  6, // no warning
+};
+typedef struct misra_12_3_s2 { int a; int b; int c, d; } misra_12_3_s2_t; // 12.3
+typedef struct { int a; int b; int c, d; } misra_12_3_s3_t; // 12.3
+static void misra_12_3_fn1(int, int); static int misra_12_3_v5, misra_12_4_v6; // 12.3 8.2
+static void misra_12_3_fn2(int a, int b) // 2.7
+{ int d, e; } // 12.3
+static int misra_12_3_fn3(int a, int b) { return a+b;} static int misra_12_3_v5, misra_12_4_v6; // 12.3
+static void misra_12_3_fn4(const uint32_t value, uint8_t * const y) {} // 2.7
+static void misra_12_3_fn5(const uint32_t * const, const uint8_t) {} // 2.7 8.2
+extern void misra_12_3_fn6(const uint32_t value, uint8_t * const y);
+extern uint32_t misra_12_3_fn7(const uint32_t * const, const uint8_t); // 8.2
+#define MISRA_12_3_FN3_1(A, B) (misra_12_3_fn3(A, B))
+#define MISRA_12_3_FN3_2(A, B) (misra_12_3_fn3(A, \
+                                B))
+#define MISRA_12_3_FN3_2_MSG(x) x, fflush(stderr)
+static void misra_12_3(int, int, int); // 8.2
+void misra_12_3(int a, int b, int c) {
+  int a1, a2; // 12.3
+  int a3; int a4; // no warning
+  int a5 = 9, a6; // 12.3
+  int a7, a8 = 11; // 12.3
+  int a9 = foo(), a10; // 12.3
+  int a11 = a = b = c; // 17.8
+
+  struct s1 {int a, b;}; int a12, a13; // 12.3
+  int a14, a15; misra_12_3_fn3(a14, a15); // 12.3 17.7
+  ; int a16, a17; // 12.3
+  int a18; int a19, a20; // 12.3
+  int a21, a22; int a23; // 12.3
+  int a24, // 12.3
+      a25;
+  int a26
+      , a27; // 12.3
+  int a28
+      , // 12.3
+      a29;
+
+  struct misra_12_3_s2 a30 = {1, 2}, a31; // 12.3
+  struct misra_12_3_s2 a32, a33; // 12.3
+  struct misra_12_3_s2 a34, a35 = {1, 2}, a36; // 12.3
+
+  // cppcheck-suppress uninitStructMember
+  int a37 = MISRA_12_3_FN3_1(a34, a35), a38; // 12.3
+  int a39, a40 = MISRA_12_3_FN3_1(a34, a35); // 12.3
+  int a41 = MISRA_12_3_FN3_2(a34, a35), a42; // 12.3
+  int a43, a44 = MISRA_12_3_FN3_2(a34, a35); // 12.3
+
+  MISRA_12_3_FN3_2_MSG(fprintf(stderr, "test\n")); // 12.3 21.6
+  // TODO
+  f((1,2),3);  // 17.3
+
+  // third clause: 2 persistent side effects instead of 1 (14.2)
+  for (i=0; i<10; i++, j++){} // 12.3 14.2
+  for (int i = 0, p = &a1;  // 12.3 14.2
+          i < 42;
+          ++i, ++p ) // 12.3
+  {}
+
+  // No false positives in local and extern function calls
+  misra_12_3_fn4(misra_12_3_fn5(&a1, 32), &a1);
+  misra_12_3_fn4(misra_12_3_fn7(&a1, 32), &a1);
+  misra_12_3_fn6(misra_12_3_fn5(&a1, 32), &a1);
+  misra_12_3_fn6(misra_12_3_fn7(&a1, 32), &a1);
+  misra_12_3_fn7(maxlen, fn(va, unsigned long), false); // 17.3 
+  misra_12_3_fn8(maxlen, (unsigned long)((uintptr_t)fn(va, void*)), false); // 17.3
+
+  const struct fun_t
+  {
+    int64_t x;
+    uint32_t y;
+  } moreFun[2U] =
+  {
+    { 900000000000000LL, 0x20000UL },
+    { 450000000000000LL, 0x10000UL }
+  };
 }
 
-void misra_12_4() {
+#define MISRA12_4a 2000000000u
+#define MISRA12_4b 4000000000u
+static void misra_12_4(uint8_t t) {
   x = 123456u * 123456u; // 12.4
+  x = MISRA12_4a + MISRA12_4b; // 12.4
+  x = 0u - 1u; // 12.4
+  x = t ? 0u : (0u-1u); // 12.4
+  x = (0u==0u) ? 0u : (0u-1u);
+  x = (0u!=0u) ? 0u : (0u-1u); // 12.4
+  x = (0u==0u) ? 0u : (2*(0u-1u)); // 10.4
 }
 
 struct misra_13_1_t { int a; int b; };
-void misra_13_1(int *p) {
+uint8_t misra_13_1_x = 0; // 8.4
+static void misra_13_1_bar(uint8_t a[2]);
+static void misra_13_1(int *p) {
   volatile int v;
-  int a[3] = {0, (*p)++, 2}; // 13.1
+  int a1[3] = {0, (*p)++, 2}; // 13.1
+  int a2[3] = {0, ((*p) += 1), 2}; // 13.1
+  int a3[3] = {0, ((*p) = 19), 2}; // 13.1
+  misra_13_1_bar((uint8_t[2]){ misra_13_1_x++, misra_13_1_x++ } ); // 13.1
   int b[2] = {v,1};
   struct misra_13_1_t c = { .a=4, .b=5 }; // no fp
+  volatile int vv;
+  int v = 42;
+
+  int a1[3] = { 0, (*p)++, 2 }; // 13.1
+  int a2[2] = { [0]=19, [1]=42 };
+  int a3[2] = { [0]=v, [1]=42 };
+  int a4[2] = { [0]=0, [1]=(v+=1) }; // 13.1
+  int a5[2] = { [0]=0, [1]=(v+1) };
+  int a6[2] = { v, 1 };
+  int a6[2] = { v >>= 3 }; // 13.1 9.3
+  int a7[2] = { v, ++v }; // 13.1
+  int a8[1] = { vv }; // TODO: 13.1 Trac #9504
+
+  struct misra_13_1_t c01 = { 4, 5 };
+  struct misra_13_1_t c02 = { 16 == 1, 5+1 };
+  struct misra_13_1_t c03 = { (v += 1), 5+1 }; // 13.1
+  struct misra_13_1_t c04 = { v <<= 1, 5+1 }; // 13.1
+  struct misra_13_1_t c05 = { v += 1, 5+1 }; // 13.1
+  struct misra_13_1_t c06 = { (4.5 + 0.5), 1 };
+  struct misra_13_1_t c07 = { (4.5 + 0.5), ++v }; // 13.1
+  struct misra_13_1_t c08 = { (int)4.5, 5 };
+  struct misra_13_1_t c09 = { (int)4.5+(*p)++, 5 }; // 13.1
+  struct misra_13_1_t c10 = { (int)4.5, (*p)++ }; // 13.1
+  struct misra_13_1_t c11 = { .a=4+1, .b=3/3 };
+  struct misra_13_1_t c12 = { .a=4, .b=5 };
+  struct misra_13_1_t c13 = { (*v)<<=(int)(4.5), .b=5 }; // 13.1
+  struct misra_13_1_t c14 = { (*p)/=(int)(4.5) }; // 13.1
 }
 
-void misra_13_3() {
+// Large arrays for R13.1. Size exceeds default Python's max recursion depth.
+static uint8_t misra_13_1_large_ok[1024] = {
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
+};
+static uint8_t misra_13_1_large_bad[1024] = { // 13.1
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, i++, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
+};
+
+static void misra_13_3(void) {
   x = y++; // 13.3
 }
 
@@ -327,21 +1195,29 @@ static s13_4_t s13_4 =
     .string = STRING_DEF_13_4 // no-warning
 };
 
-void misra_13_4() {
+static void misra_13_4(int x, int z) {
+  int y;
   if (x != (y = z)) {} // 13.4
   else {}
 }
 
-void misra_13_5() {
+static void misra_13_5(void) {
+  int x = 0;
+  int y = 0;
   if (x && (y++ < 123)){} // 13.5
+  if (x || ((y += 19) > 33)){} // 13.5
+  if (x || ((y = 25) > 33)){} // 13.5 13.4
+  if (x || ((--y) > 33)){} // 13.5
   else {}
 }
 
-void misra_13_6() {
+static void misra_13_6(void) {
+  int a = sizeof(x|=42); // 13.6
+  a = sizeof(--x); // 13.6 13.3
   return sizeof(x++); // 13.6
 }
 
-void misra_14_1() {
+static void misra_14_1(void) {
   for (float f=0.1f; f<1.0f; f += 0.1f){} // 14.1
   float a = 0.0f;
   int b = 10;
@@ -355,66 +1231,359 @@ void misra_14_1() {
   } while ( a < 10.0f );  // no-warning
 
 }
+//13143
+static bool misra_14_1_is_increasing (const double* const x, const size_t n)
+{
+    double last = -INFINITY;
+    size_t i = ((size_t) 0);
+    while ((i < n) && isfinite(x[i]) && (x[i] > last)) { //no-warning for 14_1
+       last = x[i];
+       i++;
+    }
+    return i == n;
+}
+
+static void misra_14_1_compliant1_foo(float x){
+    int i = 0;
+    while(i < x){ // 10.4
+        i += x + x; // 10.3 10.4 no-warning for 14_1
+    }
+}
 
-void misra_14_2() {
-  for (dostuff();a<10;a++) {} // 14.2
+static void misra_14_1_compliant2_foo(void){
+    int i = 0;
+    float f = 0f;
+    while (f < 10 && i < 10) { //10.4 12.1
+        float f = 0f;
+        f = f + i; // 10.3 10.4 no warning for 14_1
+        i++;
+    }
+}
+static void misra_14_2_init_value(int32_t *var) {
+    *var = 0;
+}
+static void misra_14_2_init_value_1(int32_t *var);
+
+static void misra_14_2_fn1(bool b) {
   for (;i++<10;) {} // 14.2
-  for (;i<10;dostuff()) {} // TODO
-  // TODO check more variants
+  for (;i<10;dostuff()) {} // 14.2 17.3
+  int32_t g = 0;
+  int g_arr[42];
+  g += 2; // no-warning
+  for (int32_t i2 = 0; i2 < 8; ++i2) {
+    i2 += 2; // 14.2
+    i2 |= 2; // 14.2
+    g += 2;
+    i2 ^= 2; // 14.2
+    if (i2 == 2) {
+      g += g_arr[i2]; // cppcheck-suppress legacyUninitvar
+    }
+    misra_14_2_init_value(&i2); // TODO: Fix false negative in function call
+  }
+  int i1;
+  int i2;
+  for (misra_14_2_init_value(&i1); i1 < 10; ++i1) {} // no-warning
+  for (misra_14_2_init_value_1(&i2); i2 < 10; ++i2) {} // no-warning
+  for (misra_14_2_init_value_2(&i2); i2 < 10; ++i2) {} // 17.3 no-warning
+
+  bool abort = false;
+  for (i = 0; (i < 10) && !abort; ++i) { // 14.2 as 'i' is not a variable
+      if (b) {
+        abort = true;
+      }
+  }
+  for (int i = 0; (i < 10) && !abort; ++i) { // no warning
+      if (b) {
+        abort = true;
+      }
+  }
+  for (;;) {} // no-warning
+
+  int x = 10;
+  for (int i = x; i < 42; i++) {
+      x++; // no warning
+  }
+  // 1st clause item 2 + loop counter modification
+  for(x = 0; x < 10; x++) {
+    x++; // 14.2
+  }
+  // third clause: 2 persistent side effects instead of 1 (14.2)
+  for (int i = 0; i < 10; i++, x++) { // 12.3 14.2
+  }
+
+  // 2 loop counters, there shall be only 1
+  for(int i=0, j=0; (i<10) && (j<10); i++, j++) { // 12.3 14.2
+  }
+
+  for (int i = (x - 3); i < 42; i++) {
+      x ^= 3; // no warning
+  }
+
+  for (int i = 0, j = 19; i < 42; i++) { // 12.3 14.2
+      i += 12; // 14.2
+      j /= 3; // TODO: 14.2
+  }
+
+  for (int i = 0; i < 19; i++) {
+      for (int j = 0; j < 42; j++) {
+          i--; // 14.2
+          for (int k = j; k > 5; k--) {
+              i++; // 14.2
+              for (int h = 35; h > 5; k++) // 14.2
+              {}
+          }
+      }
+  }
+
+  static struct
+  {
+    uint16_t block;
+    bool readSuccessful;
+    int32_t i;
+  }
+  opState;
+  for (opState.block = 0U; opState.block < 10U; opState.block++) {;} //no-warning
+
+  for (misra_14_2_init_value(&opState.i); opState.i < 10; ++opState.i) {} //no-warning
+}
+static void misra_14_2_fn2(void)
+{
+    int y = 0;
+
+    // Handle cases when i is not treated as loop counter according MISRA
+    // definition.
+    for (int i = 0, j = 19; y < 10, --j > 10; y++, j--) { // 14.2 12.3
+        i++; // no warning
+    }
+    for (int i = 0, j = 19; y < 10, --j > 10; y++, j--) { // 14.2 12.3
+        i++; // no warning
+    }
+    // 1st clause is not empty, but is not used in 2nd and 3rd clause
+    for (int i = 0; y < 10; y++) { // 14.2
+        i++; // no warning
+    }
+    for (; y < 10; y++) {} // without 1st clause, no error
+    for (int i = 0; i < 10; y++) { // 14.2
+        i++; // no warning
+    }
+    for (int i = 0; y < 10; i++) { // 14.2
+        i++; // no warning
+    }
+    for (int i = 0; i < 10; (y+=i)) { // 14.2
+        i++; // no warning
+    }
+
+    // i is a loop counter according MISRA definition
+    for (int i = 0; i < 10; i++) {
+        i++; // 14.2
+        if (++i > 5) { // 14.2
+            break;
+        }
+    }
+    for (int i = 0; i < 10; (i+=42)) {
+        i++; // 14.2
+    }
+    for (int i = 0; i < 10; (i|=y)) {
+        i++; // 14.2
+    }
+
+    return 0;
 }
 
 struct {
   unsigned int x:1;
   unsigned int y:1;
-} _14_4_struct;
-void misra_14_4(bool b) {
-  if (x+4){} // 14.4
+} r14_4_struct; // 8.4
+static void misra_14_4(bool b) {
+  if (x+4){} //config
   else {}
 
   if (b) {}
   else {}
 
-  if (_14_4_struct.x) {}
+  if (r14_4_struct.x) {}
+
+  // #12079
+  if (z) {} //config
+}
+
+// #12417
+struct bar_12417{ int a; };
+static int foo_12417(void){
+    int ret = 1;
+    if (sizeof(struct bar_12417) == 0U){ // no warning for misra-config
+        ret = 0;
+    }
+    return ret;
 }
 
-void misra_15_1() {
+static void misra_15_1(void) {
   goto a1; // 15.1
 a1:
 }
 
-void misra_15_2() {
+static void misra_15_2(void) {
 label:
   goto label; // 15.2 15.1
 }
 
-void misra_15_3() {
+static void misra_15_3(int a) {
+  int x = 0;
+  int y;
   if (x!=0) {
     goto L1; // 15.3 15.1
     if (y!=0) {
       L1:
     } else {}
   } else {}
+
+  switch (x) {
+  case 0:
+      if (x == y) {
+          goto L2; // 15.3 15.1
+      }
+      goto L2; // 15.3 15.1
+    L3:
+      foo();
+      if (a == 0x42) {
+          // Compliant:
+          goto L3; // 15.1 15.2
+      }
+      break;
+  case 1:
+      y = x;
+  L2:
+      ++x;
+      break;
+  default:
+      break;
+  }
 }
 
-int misra_15_5() {
+static void misra_15_4(void) {
+  misra_15_4_label:
+    return;
+
+  int x = 0;
+  int y = 0;
+  int z = 0;
+
+  // Break on different loop scopes
+  for (x = 0; x < 42; ++x) {
+    if (x==1) {
+      break;
+    }
+    for (y = 0; y < 42; ++y) { // 15.4
+      if (y==1) {
+        break;
+      }
+      if (y==2) {
+        break;
+      }
+      for (z = 0; y < 42; ++z) { // 14.2
+        if (z==1) {
+          break;
+        }
+      }
+    }
+  }
+
+  // Break in while loop
+  do { // 15.4
+    if(x == 1) {
+        break;
+    }
+    if(x == 2) {
+        break
+    }
+    x++;
+  } while(x != 42);
+
+  // Break and goto in same loop
+  for (int x = 0; x < 10; ++x) { // 15.4
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        goto misra_15_4_label; // 15.1 15.2
+    }
+  }
+
+  // Inner loop uses goto
+  for (x = 0; x < 42; ++x) { // 15.4
+    if (x==1) {
+      break;
+    }
+    for (y = 0; y < 42; ++y) {
+      if (y == 1) {
+        goto misra_15_4_label; // 15.1 15.2
+      }
+    }
+  }
+
+  // Allow switch with multiple breaks inside loop
+  for (x = 0; x < 42; ++x) {
+    switch (x) {
+      case 1:
+        break;
+      default:
+        break;
+    }
+  }
+
+  // Do not allow switch with multiple gotos inside loop
+  for (x = 0; x < 42; ++x) { // 15.4
+    switch (x) {
+      case 1:
+        goto misra_15_4_label; // 15.1 15.2
+        break;
+      default:
+        goto misra_15_4_label; // 15.1 15.2
+        break;
+    }
+  }
+}
+
+static int misra_15_5(int x) {
   if (x!=0) {
     return 1; // 15.5
   } else {}
   return 2;
 }
 
-void misra_15_6() {
+static void misra_15_6(int x) {
   if (x!=0); // 15.6
   else{}
 
-#if A>1  // no-warning
+#if A>1  // 20.9
   (void)0;
 #endif
 
+#if A > 0x42 // 20.9
+  if (true) {
+    (void)0;
+  }
+  if (true)
+#endif
+  { (void)0; } // no-warning
+
   do {} while (x<0); // no-warning
 }
 
-void misra_15_7() {
+static void misra_15_6_fp(void)
+{
+    uint8_t value = 0U;
+    do // Test
+    {
+        value++;
+    }
+    while (value < 2U);
+}
+
+#if defined(M_20_9) && M_20_9 > 1 // no-warning (#10380)
+#endif
+
+static void misra_15_7(int x, int a, int b) {
   uint32_t var = 0;
   uint32_t var2 = 0;
 
@@ -439,7 +1608,18 @@ void misra_15_7() {
   if (a==2) {} else { if (b==4) {} } // no-warning
 }
 
-void misra_16_2() {
+static void misra_16_1(int32_t i) {
+  switch (i) {
+    int8_t x; // 16.1
+    default: // 16.3 16.5
+      break;
+    if (i != 18) {} // 16.1
+    case 1: // 16.3
+      break;
+  }
+}
+
+static void misra_16_2(int y) {
   switch (x) {
     default:
       break;
@@ -451,7 +1631,8 @@ void misra_16_2() {
   }
 }
 
-void misra_16_3() {
+static void misra_16_3(int b) {
+  int a;
   switch (x) {
     case 1:
     case 2:
@@ -494,10 +1675,51 @@ void misra_16_3() {
     {
         break;
     }
+  }
+
+  switch (x) {
+    case 1:
+        break;
+    default: // 16.5
+        x++;
+    case 19: // 16.3
+        break;
+    case 20:
+        x + 2;
+        x + 3;
+        break;
     }
+    switch (x) { // 16.6
+    default:;
+    } // 16.3
+
+    switch (x) { default:; } // 16.3 16.6
+
+    switch (x) {
+    case 20:
+        x + 2;
+        x + 3;
+        break;
+    case 21:
+        x + 2;
+        x + 3;
+        break;
+    default:
+        ;
+    } // 16.3
+
+    switch (x) { // 16.4 16.6
+    case 1:
+        x++;
+        break;
+    case 2:
+        x++;
+  } // 16.3
+
+  #define M_16_3(a,b,default) { (a), (b), (default) },
 }
 
-void misra_16_4() {
+static void misra_16_4(void) {
   switch (x) { // 16.4
     case 1:
       break;
@@ -506,7 +1728,7 @@ void misra_16_4() {
   }
 }
 
-void misra_16_5() {
+static void misra_16_5(void) {
   switch (x) {
     case 1:
       break;
@@ -517,7 +1739,7 @@ void misra_16_5() {
   }
 }
 
-void misra_16_6() {
+static void misra_16_6(void) {
   switch (x) { // 16.6
     default:
       break;
@@ -538,7 +1760,7 @@ void misra_16_6() {
   }
 }
 
-void misra_16_7() {
+static void misra_16_7(void) {
   switch (x != 123) { // 16.7
     case 1:
       break;
@@ -547,53 +1769,73 @@ void misra_16_7() {
   }
 }
 
-void misra_17_1() {
-  va_list(); // 17.1
+static void misra_17_1(void) {
+  va_list(); // 17.1 17.7
   va_arg(); // 17.1
   va_start(); // 17.1
   va_end(); // 17.1
-  va_copy(); // 17.1
+  va_copy(); // 17.1 17.3
 }
 
-void misra_17_2_ok_1(void) { ; }
-void misra_17_2_ok_2(void) {
+static void misra_17_2_ok_1(void) { ; }
+static void misra_17_2_ok_2(void) {
     misra_17_2_ok_1(); // no-warning
 }
-void misra_17_2_1(void) {
+static void misra_17_2_1(void) {
   misra_17_2_ok_1(); // no-warning
   misra_17_2_1(); // 17.2
   misra_17_2_ok_2(); // no-warning
   misra_17_2_1(); // 17.2
 }
-void misra_17_2_2(void) {
+static void misra_17_2_2(void) {
   misra_17_2_3(); // 17.2
 }
-void misra_17_2_3(void) {
+static void misra_17_2_3(void) {
   misra_17_2_4(); // 17.2
 }
-void misra_17_2_4(void) {
+static void misra_17_2_4(void) {
   misra_17_2_2(); // 17.2
   misra_17_2_3(); // 17.2
 }
 
-void misra_17_2_5(void) {
+static void misra_17_2_5(void) {
   misra_17_2_ok_1(); // no-warning
   misra_17_2_5(); // 17.2
   misra_17_2_1(); // no-warning
 }
 
-void misra_17_6(int x[static 20]) {} // 17.6
+bool (*dostuff)(); //8.2 8.4
+struct s173{
+  int a;
+  int b;
+}
+static void misra_17_3(void) {
+  if (dostuff()) {} // no-warning
+  bool a = dostuff(); // no-warning
+  dostuff2(); // 17.3
+  s173 ( *misra_8_2_p_a ) (void); // no-warning
+}
+
+static void misra_config(const char* str) {
+    if (strlen(str) > 3){} //10.4
+    if (sizeof(int) > 1){} //10.4
+}
 
-int calculation(int x) { return x + 1; }
-void misra_17_7(void) {
+static void misra_17_6(int x[static 20]) {(void)x;} // 17.6
+
+static int calculation(int x) { return x + 1; }
+static void misra_17_7(void) {
   calculation(123); // 17.7
+  int (*calc_ptr)(int) = &calculation;
+  calc_ptr(123); // 17.7
+  int y = calc_ptr(123);
 }
 
-void misra_17_8(int x) {
+static void misra_17_8(int x) {
   x = 3; // 17.8
 }
 
-void misra_18_4()
+static void misra_18_4(void)
 {
   int b = 42;
   int *bp = &b;
@@ -607,7 +1849,7 @@ void misra_18_4()
   b = b + 9; // no-warning
 }
 
-void misra_18_5() {
+static void misra_18_5(void) {
   int *** p;  // 18.5
 }
 
@@ -623,17 +1865,27 @@ struct {
     } nested_2;
     uint8_t data_3[]; // 18.7
   } nested_3;
-} _18_7_struct;
+} r18_7_struct; // 8.4
 struct {
   uint16_t len;
+  int (*array_param_func_ptr)(char const *argv[], int argc); // no-warning
   uint8_t data_1[ 19 ];
   uint8_t data_2[   ]; // 18.7
-} _18_7_struct;
+} r18_7_struct; // 8.4
+
+typedef enum {
+    R18_8_ENUM_CONSTANT_0,
+    R18_8_ENUM_CONSTANT_1,
+} r18_8_enum;
 
-void misra_18_8(int x) {
+static void misra_18_8(int x) {
   int buf1[10];
   int buf2[sizeof(int)];
   int vla[x]; // 18.8
+  // #9498
+  int vlb[y]; // config
+  static const unsigned char arr18_8_1[] = UNDEFINED_ID;
+  static uint32_t enum_test_0[R18_8_ENUM_CONSTANT_0] = {0};
 }
 
 union misra_19_2 { }; // 19.2
@@ -641,17 +1893,54 @@ union misra_19_2 { }; // 19.2
 #include "notfound.h" // 20.1
 
 #define int short // 20.4
+#define inline "foo" // no warning in C90 standard
 #undef X  // 20.5
 
 #define M_20_7_1(A)  (A+1) // 20.7
 #define M_20_7_2(A,B)  (1+AB+2) // no warning
 #define M_20_7_3(A)  ((A)+A) // 20.7
+#define M_20_7_4(A)  x##A // 20.10 this test was written to see there are not FPs
+#define M_20_7_5(A,B)  f(A, B) // no warning
+#define M_20_7_6(x) a ## x = ( x ) // 20.10
+#define M_20_7_7(x) a  = # x // 20.10
+#define M_20_7_8(x, fn) a = fn ( # x ) // 20.7 20.10
+#define M_20_7_9(x, fn) a = (fn) ( # x ) // 20.10
+#define M_20_7_10(A, B) (A " " B)
+#define M_20_7_11(A, B, C) (A " " B " " C)
+#define M_20_7_12(A, B, C) (A " " B + C) // 20.7
+#define M_20_7_13(A, B, C) (A + B " " C) // 20.7
+#define M_20_7_14(STRING1, STRING2) (STRING1 " " STRING2)
+#define M_20_7_15(STRING1, STRING2, STRING3) (STRING1 " " STRING2 " " STRING3)
+#define M_20_7_16(STRING1, STRING2, STRING3) (STRING1 " " STRING2 + STRING3) // 20.7
+#define M_20_7_17(STRING1, STRING2, STRING3) (STRING1 + STRING2 " " STRING3) // 20.7
+
+// Compliant: M is a structure member name, not an expression
+struct { int a; } struct_20_7_s; // 8.4
+#define M_20_7_6(M) struct_20_7.M
+#define M_20_7_7(M) (struct_20_7).M
+
+#define MUL(a  ,b ) ( a * b ) // 20.7
+
+#if __LINE__  // 20.8
+#elif 2+5  // 20.8
+#elif 2-2
+#endif
+
+#if A // 20.9
+#elif B || C // 20.9
+#endif
+
+#define M_20_10(a) (#a) // 20.10
 
-#define STRINGIFY(a) (#a) // 20.7 20.10
+#define M_20_11(a)  # a ## 1 // 20.11 20.10
+
+#define M_20_12_AA       0xffff
+#define M_20_12_BB(x)    (x) + wow ## x // 20.12 20.10
+misra_20_12 = M_20_12_BB(M_20_12_AA);
 
 #else1 // 20.13
 
-#ifdef A>1
+#ifdef A
 # define somethingis 5 // no warning
 # define func_20_13(v) (v) // no warning
 #else
@@ -659,28 +1948,164 @@ union misra_19_2 { }; // 19.2
 # def fun_2013(v) () // 20.13
 #endif
 
-void misra_21_3() {
+#define _Incompatible 0xdeadbeef // 21.1
+#define __Incompatible 0xdeadbeef // 21.1
+#define __starts_with_lower 0xdeadbeef // 21.1
+#define __MY_HEADER_ // 21.1
+#define _macro_starts_with_lower 1 // no warning
+static int _file_scope_id_21_1 = 42; // no warning
+static int _file_scope_id_21_1_fn(void) { return 42; } // no warning
+static int misra_21_1(void) {
+    int _a = 42; // no warning: only directives affected
+    errno = EINVAL; // no warning
+    _a ++; // no warning
+    _exit(1); // 17.3 no warning
+    return _a; // no warning
+}
+static int _misra_21_1_2(void); // no warning
+#define errno 11 // 21.1
+#undef errno // 20.5
+
+#define __BUILTIN_SOMETHING 123 // 21.2 21.1
+extern void *memcpy ( void *restrict s1, const void *restrict s2, size_t n ); // 21.2 8.14
+
+static void misra_21_3(void) {
   p1=malloc(10); // 21.3
   p2=calloc(10); // 21.3
   realloc(10); // 21.3
   free(p1); // 21.3
 }
 
-void misra_21_7() {
+static void misra_21_7(void) {
   (void)atof(str); // 21.7
   (void)atoi(str); // 21.7
   (void)atol(str); // 21.7
   (void)atoll(str); // 21.7
 }
 
-void misra_21_8() {
+static void misra_21_8(void) {
   abort(); // 21.8
   (void)getenv("foo"); // 21.8
-  (void)system(""); // 21.8
   exit(-1); // 21.8
 }
 
-void misra_21_9() {
+static void misra_21_9(void) {
   (void)bsearch(key,base,num,size,cmp); // 21.9
   qsort(base,num,size,cmp); // 21.9
 }
+
+static void misra_21_12(void) {
+    int rc;
+    fexcept_t f; // 21.12
+    rc = feclearexcept(1); // 21.12
+    rc = fegetexceptflag(&f, 1); // 21.12
+    rc = feraiseexcept(1); // 21.12
+    rc = fesetexceptflag(&f, 1); // 21.12
+    rc = fetestexcept(1); // 21.12
+}
+
+static void misra_21_14(uint8_t *x) {
+    (void)strcpy(x, "123");
+    (void)memcmp(x, y, 100); // 21.14
+    (void)memcmp("abc", y, 100); // 21.14 21.16
+}
+
+static void misra_21_15(uint8_t *x, uint16_t *y) {
+    (void)memcpy(x, y, 10); // 21.15
+    (void)memmove(x, y, 10); // 21.15
+    (void)memcmp(x, y, 10); // 21.15
+}
+
+struct misra_21_16_S { int a; int b; };
+static void misra_21_16_f1(struct misra_21_16_S *s1, struct misra_21_16_S *s2) {
+    (void)memcmp(s1, s2, 10); // 21.16
+}
+static void misra_21_16_f2(char *x, char *y) {
+    (void)memcmp(x, y, 10); // 21.16
+}
+typedef enum { R21_16_A, R21_16_B} r21_16_enum;
+static void misra_21_16_f3(void) {
+    int const a[2] = {0};
+    int const b[2] = {0};
+    (void)memcmp(a, b, 2); // no-warning
+    uint8_t const c[2] = {0};
+    uint8_t const d[2] = {0};
+    (void)memcmp(c, d, 2); // no-warning
+    bool const e[2] = {0};
+    bool const f[2] = {0};
+    (void)memcmp(e, f, 2); // no-warning
+    r21_16_enum const g[2] = {0};
+    r21_16_enum const h[2] = {0};
+    (void)memcmp(g, h, 2); // no-warning
+    char const i[2] = {0};
+    char const j[2] = {0};
+    (void)memcmp(i, j, 2); // 21.16
+}
+
+static void misra_21_19(void) {
+    char *s = setlocale(LC_ALL,0); // 21.19
+    const struct lconv *conv = localeconv ();
+    conv->decimal_point = "^"; // 21.19
+}
+
+static void misra_21_20(void) {
+    const char *res1 = setlocale ( LC_ALL, 0 );
+    (void) setlocale ( LC_MONETARY, "French" );
+    if (res1) {} // 21.20 14.4
+}
+
+static void misra_21_21(void) {
+    (void)system("ls"); // 21.21
+}
+
+static void misra_22_5(FILE *f) {
+    int x = *f; // 22.5
+    int y = f->pos; // 22.5
+}
+
+static void misra_22_7(char ch)
+{
+    if (EOF == ch) {} // 22.7
+}
+
+static void misra_22_8(void)
+{
+    (void)strtoll("123", NULL, 10); // 22.8
+    if (errno == 0) {}
+}
+
+static void misra_22_9(void)
+{
+    errno = 0;
+    (void)strtoll("123", NULL, 10); // 22.9
+}
+
+static void misra_22_10(void)
+{
+  errno = 0;
+  f = atof ( "A.12" ); // 21.7
+  if ( 0 == errno ) {} // 22.10
+
+  errno = 0;
+  f = strtod ( "A.12", NULL );
+  if ( 0 == errno ) {}
+
+  // #10855
+  f = strtol(numbuf, 0, (formatHex == 0U) ? 0 : 16);
+  if (errno != 0) {}
+
+  // #11752
+  #define NULL_PTR  ((void*)0)
+  f = strtod(inStr, NULL_PTR);
+  if(errno != 0) {}
+}
+
+// #12448
+static void check_misra_config(void)
+{
+    if (sizeof(struct bar) == 0U) {} //no warning
+    if (sizeof(int abc) == 0U) {} //no warning
+    if (sizeof(xyz) == 0U) {} //no warning
+    if (sizeof(const pqr) == 0U) {} //no warning
+    if (sizeof(const int* const pqrs) == 0U) {} //no-warning
+}
diff --git a/addons/test/misra/misra-test.cpp b/addons/test/misra/misra-test.cpp
index ebf1905aa7c..0aa9a0b9d1c 100644
--- a/addons/test/misra/misra-test.cpp
+++ b/addons/test/misra/misra-test.cpp
@@ -1,8 +1,25 @@
-
 // #8441
 class C {
     int a;
     int b;
-    C() : a(1), b(1) { c; }
+    C(void) : a(1), b(1) { c; }
+};
+
+class misra_21_1_C {
+    public:
+       misra_21_1_C operator=(const misra_21_1_C &);
+};
+
+class C2 {
+public:
+	C2(void);
+private:
+	void* f;
 };
+C2::C2(void) : f(NULL) {}
 
+static void test_misra_21_1_crash(void)
+{
+    auto misra_21_1_C a, b; // 12.3
+    a = b;
+}
diff --git a/addons/test/misra/misra-test.h b/addons/test/misra/misra-test.h
index 7f2db128a55..b455134893c 100644
--- a/addons/test/misra/misra-test.h
+++ b/addons/test/misra/misra-test.h
@@ -1,4 +1,13 @@
 #ifndef MISRA_TEST_H
 #define MISRA_TEST_H
 struct misra_h_s { int foo; };
+bool test(char *a); // OK
+int misra_8_2_no_fp(int a);
+void misra_8_4_bar(void);
+// #12978
+typedef struct m8_4_stErrorDef
+{
+    uint8_t ubReturnVal;
+} m8_4_stErrorDef;
+extern const m8_4_stErrorDef * m8_4_pubTestPointer;
 #endif // MISRA_TEST_H
diff --git a/addons/test/misra/misra_rules_structure.txt b/addons/test/misra/misra_rules_structure.txt
index 41d2d456f85..a8223fde948 100644
--- a/addons/test/misra/misra_rules_structure.txt
+++ b/addons/test/misra/misra_rules_structure.txt
@@ -11,7 +11,10 @@ Here we go:
 Appendix A Summary of guidelines
 
 Rule 1.2
-Rule text.
+ Rule text.
+
+Rule 2.1
+Rule text for 2.1.
 
 Stop parsing after this line:
 Appendix B
diff --git a/addons/test/misra/suppressions.txt b/addons/test/misra/suppressions.txt
index acac96847e7..139e088552e 100644
--- a/addons/test/misra/suppressions.txt
+++ b/addons/test/misra/suppressions.txt
@@ -1,7 +1,6 @@
-misra_21.6:misra-suppressions1-test.c:7
-misra_14_4
-misra.5.2
-MISRA_16_4:misra-suppressions1-test.c
-MISRA.16.6:misra-suppressions1-test.c
-MISRA_4_1:misra-suppressions2-test.c
-MISRA.19_2:misra-suppressions2-test.c
+misra-c2012-21.6:*/misra-suppressions1-test.c:7
+misra-c2012-17.3
+misra-c2012-8.4:*/misra-suppressions1-test.c
+misra-c2012-4.1:*/misra-suppressions2-test.c
+misra-c2012-8.4:*/misra-suppressions2-test.c
+misra-c2012-19.2:*/misra-suppressions2-test.c
diff --git a/addons/test/misra_test.py b/addons/test/misra_test.py
new file mode 100644
index 00000000000..55a24cb4b27
--- /dev/null
+++ b/addons/test/misra_test.py
@@ -0,0 +1,244 @@
+# Running the test with Python 3:
+# Command in cppcheck directory:
+# PYTHONPATH=./addons python3 -m pytest addons/test/misra_test.py
+
+import pytest
+import re
+import sys
+import os
+
+from .util import dump_create, dump_remove, convert_json_output
+from addons.misra import C11_STDLIB_IDENTIFIERS, C99_STDLIB_IDENTIFIERS,C90_STDLIB_IDENTIFIERS, isStdLibId, isKeyword
+
+TEST_SOURCE_FILES = [os.path.join('addons','test','misra','misra-test.c')]
+
+
+def remove_misra_config(s:str):
+    ret = ''
+    for line in s.splitlines():
+        if '[misra-config]' not in line:
+            ret += line + '\n'
+    return ret
+
+
+@pytest.fixture(scope="function")
+def checker():
+    from addons.misra import MisraChecker, MisraSettings, get_args_parser
+    parser = get_args_parser()
+    args = parser.parse_args([])
+    settings = MisraSettings(args)
+    return MisraChecker(settings)
+
+
+# FIXME: files are generates in the source tree so it will cause issues if tests are run with xdist.
+@pytest.fixture
+def test_files():
+    for f in TEST_SOURCE_FILES:
+        dump_create(f)
+    yield
+    for f in TEST_SOURCE_FILES:
+        dump_remove(f)
+
+
+def test_loadRuleTexts_structure(checker):
+    checker.loadRuleTexts("./addons/test/misra/misra_rules_structure.txt")
+    assert(checker.ruleTexts.get(101, None) is None)
+    assert(checker.ruleTexts[102].text == "Rule text.")
+    assert(checker.ruleTexts.get(103, None) is None)
+    assert(checker.ruleTexts[201].text == "Rule text for 2.1.")
+    assert(checker.ruleTexts.get(202, None) is None)
+
+
+def test_loadRuleTexts_empty_lines(checker):
+    checker.loadRuleTexts("./addons/test/misra/misra_rules_empty_lines.txt")
+    assert(len(checker.ruleTexts) == 3)
+    assert(len(checker.ruleTexts[102].text) == len("Rule text."))
+
+
+def test_loadRuleTexts_mutiple_lines(checker):
+    checker.loadRuleTexts("./addons/test/misra/misra_rules_multiple_lines.txt")
+    assert(checker.ruleTexts[101].text == "Multiple lines text.")
+    assert(checker.ruleTexts[102].text == "Multiple lines text.")
+    assert(checker.ruleTexts[103].text == "Multiple lines text.")
+    assert(checker.ruleTexts[104].text == "Should")
+    assert(checker.ruleTexts[105].text == "Should starts from lowercase letter.")
+    assert(checker.ruleTexts[106].text == "Can contain empty lines.")
+
+
+def test_verifyRuleTexts(checker, capsys):
+    checker.loadRuleTexts("./addons/test/misra/misra_rules_dummy.txt")
+    checker.verifyRuleTexts()
+    captured = capsys.readouterr().out
+    assert("21.3" not in captured)
+    assert("1.3" in captured)
+
+
+def test_rules_misra_severity(checker):
+    checker.loadRuleTexts("./addons/test/misra/misra_rules_dummy.txt")
+    assert(checker.ruleTexts[1004].misra_severity == 'Mandatory')
+    assert(checker.ruleTexts[401].misra_severity == 'Required')
+    assert(checker.ruleTexts[1505].misra_severity == 'Advisory')
+    assert(checker.ruleTexts[2104].misra_severity == '')
+
+
+def test_json_out(checker, capsys, test_files):
+    sys.argv.append("--cli")
+    checker.loadRuleTexts("./addons/test/misra/misra_rules_dummy.txt")
+    checker.parseDump("./addons/test/misra/misra-test.c.dump")
+    captured = capsys.readouterr()
+    captured = captured.out.splitlines()
+    sys.argv.remove("--cli")
+    json_output = convert_json_output(captured)
+    assert("Mandatory" in json_output['c2012-10.4'][0]['extra'])
+    assert("Required" in json_output['c2012-21.3'][0]['extra'])
+    assert("Advisory" in json_output['c2012-20.1'][0]['extra'])
+
+
+def test_rules_cppcheck_severity(checker, capsys, test_files):
+    checker.loadRuleTexts("./addons/test/misra/misra_rules_dummy.txt")
+    checker.parseDump("./addons/test/misra/misra-test.c.dump")
+    captured = capsys.readouterr().err
+    assert("(error)" not in remove_misra_config(captured))
+    assert("(warning)" not in captured)
+    assert("(style)" in captured)
+
+def test_rules_cppcheck_severity_custom(checker, capsys, test_files):
+    checker.loadRuleTexts("./addons/test/misra/misra_rules_dummy.txt")
+    checker.setSeverity("custom-severity")
+    checker.parseDump("./addons/test/misra/misra-test.c.dump")
+    captured = capsys.readouterr().err
+    assert("(error)" not in remove_misra_config(captured))
+    assert("(warning)" not in captured)
+    assert("(style)" not in captured)
+    assert("(custom-severity)" in captured)
+
+def test_rules_suppression(checker, capsys):
+    test_sources = ["addons/test/misra/misra-suppressions1-test.c",
+                    "addons/test/misra/misra-suppressions2-test.c"]
+
+    for src in test_sources:
+        re_suppressed= r"\[%s\:[0-9]+\]" % src
+        dump_create(src, "--suppressions-list=addons/test/misra/suppressions.txt","--inline-suppr")
+        checker.parseDump(src + ".dump")
+        captured = capsys.readouterr().err
+        found = re.search(re_suppressed, captured)
+        assert found is None, 'Unexptected output:\n' + captured
+        dump_remove(src)
+
+def test_arguments_regression():
+    args_ok = ["-generate-table",
+               "--rule-texts=./addons/test/assets/misra_rules_multiple_lines.txt",
+               "--verify-rule-texts",
+               "-t=foo", "--template=foo",
+               "--suppress-rules=15.1",
+               "--quiet",
+               "--cli",
+               "--no-summary",
+               "--show-suppressed-rules",
+               "-P=src/", "--file-prefix=src/",
+               "--severity=misra-warning"]
+    # Arguments with expected SystemExit
+    args_exit = ["--non-exists", "--non-exists-param=42", "-h", "--help"]
+
+    from addons.misra import get_args_parser
+
+    # sys.argv contains all pytest arguments - so clear all existing arguments first and restore afterwards
+    sys_argv_old = sys.argv
+    sys.argv = [sys.argv[0]]
+
+    try:
+        for arg in args_exit:
+            sys.argv.append(arg)
+            with pytest.raises(SystemExit):
+                parser = get_args_parser()
+                parser.parse_args()
+            sys.argv.remove(arg)
+
+        for arg in args_ok:
+            sys.argv.append(arg)
+            try:
+                parser = get_args_parser()
+                parser.parse_args()
+            except SystemExit:
+                pytest.fail("Unexpected SystemExit with '%s'" % arg)
+            sys.argv.remove(arg)
+    finally:
+        sys.argv = sys_argv_old
+
+
+def test_read_ctu_info_line(checker):
+    assert checker.read_ctu_info_line('{') is None
+    assert checker.read_ctu_info_line('{"summary":"123"}') is None
+    assert checker.read_ctu_info_line('{"data":123}') is None
+    assert checker.read_ctu_info_line('{"summary":"123","data":123}') is not None
+
+def test_platform(checker):
+    test_file = os.path.join('addons','test','misra','misra-test.c')
+    dump_create(test_file, "--language=c++")
+    checker.parseDump(test_file + ".dump")
+    assert checker.is_cpp is True
+
+    dump_create(test_file, "--language=c")
+    checker.parseDump(test_file + ".dump")
+    assert checker.is_cpp is False
+
+def test_std99_identifiers():
+    for headerfile in C90_STDLIB_IDENTIFIERS:
+        for identifier in C90_STDLIB_IDENTIFIERS[headerfile]:
+            assert identifier in C99_STDLIB_IDENTIFIERS[headerfile], f"{identifier} of C90 not found in C99_STDLIB_IDENTIFIERS"
+
+def test_stdC11_identifiers():
+    for headerfile in C90_STDLIB_IDENTIFIERS:
+        for identifier in C90_STDLIB_IDENTIFIERS[headerfile]:
+            assert identifier in C99_STDLIB_IDENTIFIERS[headerfile], f"{identifier} of C90 not found in C11_STDLIB_IDENTIFIERS"
+    for headerfile in C99_STDLIB_IDENTIFIERS:
+        for identifier in C99_STDLIB_IDENTIFIERS[headerfile]:
+            assert identifier in C11_STDLIB_IDENTIFIERS[headerfile], f"{identifier} of C99 not found in C11_STDLIB_IDENTIFIERS"
+
+def test_isStdLibId():
+    # Check that Identifiers from C90 are correctly classified
+    assert isStdLibId("assert", 'c89') is True
+    assert isStdLibId("assert", 'c99') is True
+    assert isStdLibId("assert", 'c11') is True
+    assert isStdLibId("assert", 'c23') is True
+
+    # Check that Identifiers from C99 are correctly classified
+    assert isStdLibId("UINT32_C", 'c89') is False
+    assert isStdLibId("UINT32_C", 'c99') is True
+    assert isStdLibId("UINT32_C", 'c11') is True
+    assert isStdLibId("UINT32_C", 'c23') is True
+
+    # Check that Identifiers from C11 are correctly classified
+    assert isStdLibId("sprintf_s", 'c89') is False
+    assert isStdLibId("sprintf_s", 'c99') is False
+    assert isStdLibId("sprintf_s", 'c11') is True
+    assert isStdLibId("sprintf_s", 'c23') is True
+
+    # Function Defaulting to C99
+    assert isStdLibId("assert") is True
+    assert isStdLibId("UINT32_C") is True
+    assert isStdLibId("sprintf_s") is False
+
+def test_isKeyword():
+    # Check that Keywords from C90 are correctly classified
+    assert isKeyword("if", 'c89') is True
+    assert isKeyword("if", 'c99') is True
+    assert isKeyword("if", 'c11') is True
+    assert isKeyword("if", 'c23') is True
+
+    # Check that Keywords from C99 are correctly classified
+    assert isKeyword("inline", 'c89') is False
+    assert isKeyword("inline", 'c99') is True
+    assert isKeyword("inline", 'c11') is True
+    assert isKeyword("inline", 'c23') is True
+
+    # Check that Keywords from C11 are correctly classified
+    assert isKeyword("static_assert", 'c89') is False
+    assert isKeyword("static_assert", 'c99') is False
+    assert isKeyword("static_assert", 'c11') is True
+    assert isKeyword("static_assert", 'c23') is True
+
+    # Function Defaulting to C99
+    assert isKeyword("if") is True
+    assert isKeyword("inline") is True
+    assert isKeyword("static_assert") is False
diff --git a/addons/test/naming_test.c b/addons/test/naming_test.c
index e3155e6224d..bf021b87125 100644
--- a/addons/test/naming_test.c
+++ b/addons/test/naming_test.c
@@ -1,5 +1,5 @@
-// To test:
-// ~/cppcheck/cppcheck --dump naming_test.c && python ../naming.py --var='[a-z].*' --function='[a-z].*' naming_test.c.dump
-
-// Should not crash when there is no name
-void func(int number, bool);
+// To test:
+// ~/cppcheck/cppcheck --dump naming_test.c && python ../naming.py --var='[a-z].*' --function='[a-z].*' naming_test.c.dump
+
+// Should not crash when there is no name
+void func(int number, int);
diff --git a/addons/test/naming_test.cpp b/addons/test/naming_test.cpp
new file mode 100644
index 00000000000..07297dbbf27
--- /dev/null
+++ b/addons/test/naming_test.cpp
@@ -0,0 +1,11 @@
+// To test:
+// ~/cppcheck/cppcheck --dump naming_test.cpp && python ../naming.py --var='[a-z].*' --function='[a-z].*' naming_test.cpp.dump
+
+// No error for mismatching Constructor/Destructor names should be issued, they can not be changed.
+class TestClass1
+{
+    TestClass1() {}
+    ~TestClass1() {}
+    TestClass1(const TestClass1 &) {}
+    TestClass1(TestClass1 &&) {}
+};
diff --git a/addons/test/namingng_test.c b/addons/test/namingng_test.c
deleted file mode 100644
index e5915b91a37..00000000000
--- a/addons/test/namingng_test.c
+++ /dev/null
@@ -1,50 +0,0 @@
-#include <stddef.h>
-#include <inttypes.h>
-
-uint32_t ui32Good (int a)
-{
-    uint32_t ui32good;
-    int32_t i32good;
-    uint32_t badui32;
-    int32_t badi32;
-
-    uint32_t a;  // Short
-    return 5;
-}
-
-uint16_t ui16Good (int a)
-{
-    return 5;
-}
-
-uint16_t ui16bad_underscore (int a)
-{
-    return 5;
-}
-
-uint32_t u32Bad (int a)
-{
-    uint32_t ui32good;
-    int32_t i32good;
-    uint32_t badui32;
-    int32_t badi32;
-    int * intpointer=NULL;
-    int ** intppointer=NULL;
-    int *** intpppointer=NULL;
-    return 5;
-}
-
-uint16_t Badui16 (int a)
-{
-    return 5;
-}
-
-void * Pointer()
-{
-    return NULL;
-}
-
-void ** PPointer()
-{
-    return NULL;
-}
diff --git a/addons/test/test-cert.py b/addons/test/test-cert.py
deleted file mode 100644
index 8475e8b79a0..00000000000
--- a/addons/test/test-cert.py
+++ /dev/null
@@ -1,35 +0,0 @@
-# Running the test with Python 2:
-# Be sure to install pytest version 4.6.4 (newer should also work)
-# Command in cppcheck directory:
-# python -m pytest addons/test/test-cert.py
-#
-# Running the test with Python 3:
-# Command in cppcheck directory:
-# PYTHONPATH=./addons python3 -m pytest addons/test/test-cert.py
-
-import sys
-import pytest
-
-
-def test_arguments_regression():
-    args_ok = ["-q", "--quiet",
-               "-verify",
-               "--cli"]
-    # Arguments with expected SystemExit
-    args_exit = ["--non-exists", "--non-exists-param=42", "-h", "--help"]
-
-    from addons.cert import get_args
-
-    for arg in args_exit:
-        sys.argv.append(arg)
-        with pytest.raises(SystemExit):
-            get_args()
-        sys.argv.remove(arg)
-
-    for arg in args_ok:
-        sys.argv.append(arg)
-        try:
-            get_args()
-        except SystemExit:
-            pytest.fail("Unexpected SystemExit with '%s'" % arg)
-        sys.argv.remove(arg)
diff --git a/addons/test/test-misra.py b/addons/test/test-misra.py
deleted file mode 100644
index a6b242cb3d1..00000000000
--- a/addons/test/test-misra.py
+++ /dev/null
@@ -1,143 +0,0 @@
-# Running the test with Python 2:
-# Be sure to install pytest version 4.6.4 (newer should also work)
-# Command in cppcheck directory:
-# python -m pytest addons/test/test-misra.py
-#
-# Running the test with Python 3:
-# Command in cppcheck directory:
-# PYTHONPATH=./addons python3 -m pytest addons/test/test-misra.py
-
-import pytest
-import re
-import sys
-import subprocess
-
-from .util import dump_create, dump_remove, convert_json_output
-
-
-TEST_SOURCE_FILES = ['./addons/test/misra/misra-test.c']
-
-
-def setup_module(module):
-    for f in TEST_SOURCE_FILES:
-        dump_create(f)
-
-
-def teardown_module(module):
-    for f in TEST_SOURCE_FILES:
-        dump_remove(f)
-
-
-@pytest.fixture(scope="function")
-def checker():
-    from addons.misra import MisraChecker, MisraSettings, get_args
-    args = get_args()
-    settings = MisraSettings(args)
-    return MisraChecker(settings)
-
-
-def test_loadRuleTexts_structure(checker):
-    checker.loadRuleTexts("./addons/test/misra/misra_rules_structure.txt")
-    assert(checker.ruleTexts.get(101, None) is None)
-    assert(checker.ruleTexts[102].text == "Rule text.")
-    assert(checker.ruleTexts.get(103, None) is None)
-
-
-def test_loadRuleTexts_empty_lines(checker):
-    checker.loadRuleTexts("./addons/test/misra/misra_rules_empty_lines.txt")
-    assert(len(checker.ruleTexts) == 3)
-    assert(len(checker.ruleTexts[102].text) == len("Rule text."))
-
-
-def test_loadRuleTexts_mutiple_lines(checker):
-    checker.loadRuleTexts("./addons/test/misra/misra_rules_multiple_lines.txt")
-    assert(checker.ruleTexts[101].text == "Multiple lines text.")
-    assert(checker.ruleTexts[102].text == "Multiple lines text.")
-    assert(checker.ruleTexts[103].text == "Multiple lines text.")
-    assert(checker.ruleTexts[104].text == "Should")
-    assert(checker.ruleTexts[105].text == "Should")
-    assert(checker.ruleTexts[106].text == "Can contain empty lines.")
-
-
-def test_verifyRuleTexts(checker, capsys):
-    checker.loadRuleTexts("./addons/test/misra/misra_rules_dummy.txt")
-    checker.verifyRuleTexts()
-    captured = capsys.readouterr().out
-    assert("21.3" not in captured)
-    assert("1.3" in captured)
-
-
-def test_rules_misra_severity(checker):
-    checker.loadRuleTexts("./addons/test/misra/misra_rules_dummy.txt")
-    assert(checker.ruleTexts[1004].misra_severity == 'Mandatory')
-    assert(checker.ruleTexts[401].misra_severity == 'Required')
-    assert(checker.ruleTexts[1505].misra_severity == 'Advisory')
-    assert(checker.ruleTexts[2104].misra_severity == '')
-
-
-def test_json_out(checker, capsys):
-    sys.argv.append("--cli")
-    checker.loadRuleTexts("./addons/test/misra/misra_rules_dummy.txt")
-    checker.parseDump("./addons/test/misra/misra-test.c.dump")
-    captured = capsys.readouterr()
-    captured = captured.out.splitlines()
-    sys.argv.remove("--cli")
-    json_output = convert_json_output(captured)
-    assert("Mandatory" in json_output['c2012-10.4'][0]['extra'])
-    assert("Required" in json_output['c2012-21.3'][0]['extra'])
-    assert("Advisory" in json_output['c2012-20.1'][0]['extra'])
-
-
-def test_rules_cppcheck_severity(checker, capsys):
-    checker.loadRuleTexts("./addons/test/misra/misra_rules_dummy.txt")
-    checker.parseDump("./addons/test/misra/misra-test.c.dump")
-    captured = capsys.readouterr().err
-    assert("(error)" not in captured)
-    assert("(warning)" not in captured)
-    assert("(style)" in captured)
-
-
-def test_rules_suppression(checker, capsys):
-    test_sources = ["addons/test/misra/misra-suppressions1-test.c",
-                    "addons/test/misra/misra-suppressions2-test.c"]
-
-    for src in test_sources:
-        re_suppressed= r"\[%s\:[0-9]+\]" % src
-        dump_remove(src)
-        dump_create(src, "--suppressions-list=addons/test/misra/suppressions.txt")
-        checker.parseDump(src + ".dump")
-        captured = capsys.readouterr().err
-        found = re.search(re_suppressed, captured)
-        assert(found is None)
-        dump_remove(src)
-
-
-def test_arguments_regression():
-    args_ok = ["-generate-table",
-               "--rule-texts=./addons/test/assets/misra_rules_multiple_lines.txt",
-               "--verify-rule-texts",
-               "-t=foo", "--template=foo",
-               "--suppress-rules=15.1",
-               "--quiet",
-               "--cli",
-               "--no-summary",
-               "--show-suppressed-rules",
-               "-P=src/", "--file-prefix=src/"]
-    # Arguments with expected SystemExit
-    args_exit = ["--non-exists", "--non-exists-param=42", "-h", "--help"]
-
-    from addons.misra import get_args
-
-    for arg in args_exit:
-        sys.argv.append(arg)
-        with pytest.raises(SystemExit):
-            get_args()
-        sys.argv.remove(arg)
-
-    for arg in args_ok:
-        sys.argv.append(arg)
-        try:
-            get_args()
-        except SystemExit:
-            pytest.fail("Unexpected SystemExit with '%s'" % arg)
-        sys.argv.remove(arg)
diff --git a/addons/test/test-y2038.py b/addons/test/test-y2038.py
deleted file mode 100644
index caf009bbf66..00000000000
--- a/addons/test/test-y2038.py
+++ /dev/null
@@ -1,112 +0,0 @@
-# Running the test with Python 2:
-# Be sure to install pytest version 4.6.4 (newer should also work)
-# Command in cppcheck directory:
-# python -m pytest addons/test/test-y2038.py
-#
-# Running the test with Python 3:
-# Command in cppcheck directory:
-# PYTHONPATH=./addons python3 -m pytest addons/test/test-y2038.py
-
-import sys
-import pytest
-
-from addons.y2038 import check_y2038_safe
-
-from .util import dump_create, dump_remove, convert_json_output
-
-
-TEST_SOURCE_FILES = ['./addons/test/y2038/y2038-test-1-bad-time-bits.c',
-                     './addons/test/y2038/y2038-test-2-no-time-bits.c',
-                     './addons/test/y2038/y2038-test-3-no-use-time-bits.c',
-                     './addons/test/y2038/y2038-test-4-good.c']
-
-
-def setup_module(module):
-    sys.argv.append("--cli")
-    for f in TEST_SOURCE_FILES:
-        dump_create(f)
-
-
-def teardown_module(module):
-    sys.argv.remove("--cli")
-    for f in TEST_SOURCE_FILES:
-        dump_remove(f)
-
-
-def test_1_bad_time_bits(capsys):
-    check_y2038_safe('./addons/test/y2038/y2038-test-1-bad-time-bits.c.dump', quiet=True)
-    captured = capsys.readouterr()
-    captured = captured.out.splitlines()
-    json_output = convert_json_output(captured)
-
-    # Has exactly one warnings of _TIME_BITS and _USE_TIME_BITS64 kind.
-    assert(len(json_output['type-bits-undef']) == 1)
-    assert(len(json_output['type-bits-not-64']) == 1)
-
-    # There are 2 unsafe calls in test source and 3 in y2038-in.h
-    unsafe_calls = json_output['unsafe-call']
-    assert(len([c for c in unsafe_calls if c['file'].endswith('h')]) == 3)
-    assert(len([c for c in unsafe_calls if c['file'].endswith('c')]) == 0)
-
-
-def test_2_no_time_bits(capsys):
-    check_y2038_safe('./addons/test/y2038/y2038-test-2-no-time-bits.c.dump', quiet=True)
-    captured = capsys.readouterr()
-    captured = captured.out.splitlines()
-    json_output = convert_json_output(captured)
-
-    # _USE_TIME_BITS64 defined in y2038-inc.h header, but there is not
-    # _TIME_BITS definition. Here must be appropriate warning.
-    assert(len(json_output['type-bits-undef']) == 1)
-    assert(json_output.get('type-bits-not-64') is None)
-
-    # y2038-in.h still has y2038-unsafe calls.
-    unsafe_calls = json_output['unsafe-call']
-    assert(len([c for c in unsafe_calls if c['file'].endswith('h')]) == 3)
-
-
-def test_3_no_use_time_bits(capsys):
-    check_y2038_safe('./addons/test/y2038/y2038-test-3-no-use-time-bits.c.dump', quiet=True)
-    captured = capsys.readouterr()
-    captured = captured.out.splitlines()
-    json_output = convert_json_output(captured)
-
-    # Included bad _USE_TIME_BITS64 definition must trigger the errors.
-    unsafe_calls = json_output['unsafe-call']
-    assert(len(unsafe_calls) == 2)
-
-
-def test_4_good(capsys):
-    check_y2038_safe('./addons/test/y2038/y2038-test-4-good.c.dump', quiet=True)
-    captured = capsys.readouterr()
-    captured = captured.out.splitlines()
-    json_output = convert_json_output(captured)
-
-    # Defined _TIME_BITS equal to 64 so that glibc knows we want Y2038 support.
-    # There are no warnings from C sources.
-    unsafe_calls = json_output['unsafe-call']
-    assert(len([c for c in unsafe_calls if c['file'].endswith('.c')]) == 0)
-
-
-def test_arguments_regression():
-    args_ok = ["-t=foo", "--template=foo",
-               "-q", "--quiet",
-               "--cli"]
-    # Arguments with expected SystemExit
-    args_exit = ["--non-exists", "--non-exists-param=42", "-h", "--help"]
-
-    from addons.y2038 import get_args
-
-    for arg in args_exit:
-        sys.argv.append(arg)
-        with pytest.raises(SystemExit):
-            get_args()
-        sys.argv.remove(arg)
-
-    for arg in args_ok:
-        sys.argv.append(arg)
-        try:
-            get_args()
-        except SystemExit:
-            pytest.fail("Unexpected SystemExit with '%s'" % arg)
-        sys.argv.remove(arg)
diff --git a/addons/test/threadsafety/MT-Unsafe.cpp b/addons/test/threadsafety/MT-Unsafe.cpp
new file mode 100644
index 00000000000..5b23cefe87d
--- /dev/null
+++ b/addons/test/threadsafety/MT-Unsafe.cpp
@@ -0,0 +1,67 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2023 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * This does not match the standard cppchek test code,
+ * because I haven't figured that out yet.
+ * This code does compile and run, and does demonstrate
+ * the issues that the threadsafety.py addon is supposed to find.
+ * It does not use threads !
+ */
+
+#include <stdio.h>
+#include <time.h>
+#include <string.h>
+
+void threadsafety_static()
+{
+    // cppcheck-suppress threadsafety-threadsafety
+    static unsigned int nCount = 0;
+
+    nCount++;
+    printf("%d\n", nCount);
+}
+
+void threadsafety_call()
+{
+    time_t now = time(nullptr);
+    // cppcheck-suppress threadsafety-unsafe-call
+    printf("%s\n", ctime(&now));
+}
+
+// cppcheck --addon=threadsafety
+// should *not* find any problems with this function.
+void threadsafety_safecall()
+{
+    char haystack[] = "alphabet";
+    char needle[] = "Alph";
+    char* found = strcasestr(haystack, needle);
+    printf("%s %sin %s\n", needle, found ? "" : "not ", haystack);
+}
+
+int main() {
+    threadsafety_static();
+    
+    threadsafety_call();
+
+    threadsafety_safecall();
+
+    threadsafety_static();
+
+    return 0;
+}
diff --git a/addons/test/threadsafety/local_static.cpp b/addons/test/threadsafety/local_static.cpp
new file mode 100644
index 00000000000..b41a0571ba8
--- /dev/null
+++ b/addons/test/threadsafety/local_static.cpp
@@ -0,0 +1,7 @@
+struct Dummy {
+ int x;
+};
+void func() {
+    // cppcheck-suppress threadsafety-threadsafety
+    static Dummy dummy;
+}
diff --git a/addons/test/threadsafety/local_static_const.cpp b/addons/test/threadsafety/local_static_const.cpp
new file mode 100644
index 00000000000..eaed48be949
--- /dev/null
+++ b/addons/test/threadsafety/local_static_const.cpp
@@ -0,0 +1,7 @@
+struct Dummy {
+ int x;
+};
+void func() {
+  // cppcheck-suppress threadsafety-threadsafety-const
+  static const Dummy dummy;
+}
diff --git a/addons/test/util.py b/addons/test/util.py
index c027d74b3ae..0f99534edc6 100644
--- a/addons/test/util.py
+++ b/addons/test/util.py
@@ -1,24 +1,42 @@
 # Helpers for pytest tests
 import subprocess
 import json
+import os
+
+
+def find_cppcheck_binary():
+    possible_locations = [
+        "./cppcheck",
+        "./build/bin/cppcheck",
+        r".\bin\cppcheck.exe",
+    ]
+    for location in possible_locations:
+        if os.path.exists(location):
+            break
+    else:
+        raise RuntimeError("Could not find cppcheck binary")
+
+    return location
 
 def dump_create(fpath, *argv):
-    cmd = ["./cppcheck", "--dump", "--quiet", fpath] + list(argv)
-    p = subprocess.Popen(cmd)
-    p.communicate()
-    if p.returncode != 0:
-        raise OSError("cppcheck returns error code: %d" % p.returncode)
-    subprocess.Popen(["sync"])
+    cppcheck_binary = find_cppcheck_binary()
+    cmd = [cppcheck_binary, "--dump", "-DDUMMY", "--quiet", fpath] + list(argv)
+    with subprocess.Popen(cmd) as p:
+        p.communicate()
+        if p.returncode != 0:
+            raise OSError("cppcheck returns error code: %d" % p.returncode)
 
 
 def dump_remove(fpath):
-    subprocess.Popen(["rm", "-f", fpath + ".dump"])
+    os.remove(fpath + ".dump")
 
 
 def convert_json_output(raw_json_strings):
     """Convert raw stdout/stderr cppcheck JSON output to python dict."""
     json_output = {}
     for line in raw_json_strings:
+        if line.startswith('{"summary":'):
+            continue
         try:
             json_line = json.loads(line)
             #  json_output[json_line['errorId']] = json_line
diff --git a/addons/test/y2038/y2038-test-5-good-no-time-used.c b/addons/test/y2038/y2038-test-5-good-no-time-used.c
new file mode 100644
index 00000000000..4aedfcc25db
--- /dev/null
+++ b/addons/test/y2038/y2038-test-5-good-no-time-used.c
@@ -0,0 +1,14 @@
+/*
+ * C file that does not use any time functionality -> no errors should
+ * be reported.
+ */
+
+#include <stdio.h>
+
+int main(int argc, char **argv)
+{
+    if (argc > 1) {
+        printf("Hello");
+    }
+    return 0;
+}
diff --git a/addons/test/y2038/y2038-test-compiler-flags.c b/addons/test/y2038/y2038-test-compiler-flags.c
new file mode 100644
index 00000000000..99baa0e1582
--- /dev/null
+++ b/addons/test/y2038/y2038-test-compiler-flags.c
@@ -0,0 +1,25 @@
+/*
+ * Shared test case for Y2038 addon compiler flag testing
+ *
+ * This file tests various compiler flag scenarios:
+ * - Proper Y2038 configuration: -D_TIME_BITS=64 -D_FILE_OFFSET_BITS=64 -D_USE_TIME_BITS64
+ * - Incorrect _TIME_BITS value: -D_TIME_BITS=32
+ * - Incomplete configuration: -D_USE_TIME_BITS64 (without _TIME_BITS)
+ *
+ * The same source code is used for all scenarios - differentiation happens
+ * through the compiler flags passed to cppcheck during dump creation.
+ */
+
+#include <time.h>
+
+int main(int argc, char **argv)
+{
+    time_t current_time;
+    struct timespec ts;
+
+    current_time = time(NULL);
+    clock_gettime(CLOCK_REALTIME, &ts);
+
+    return 0;
+}
+
diff --git a/addons/test/y2038_test.py b/addons/test/y2038_test.py
new file mode 100644
index 00000000000..861b006d8bf
--- /dev/null
+++ b/addons/test/y2038_test.py
@@ -0,0 +1,206 @@
+# Running the test with Python 2:
+# Be sure to install pytest version 4.6.4 (newer should also work)
+# Command in cppcheck directory:
+# python -m pytest addons/test/test-y2038.py
+#
+# Running the test with Python 3:
+# Command in cppcheck directory:
+# PYTHONPATH=./addons python3 -m pytest addons/test/test-y2038.py
+
+import sys
+import pytest
+
+from addons.y2038 import check_y2038_safe
+
+from .util import dump_create, dump_remove, convert_json_output
+
+
+TEST_SOURCE_FILES = ['./addons/test/y2038/y2038-test-1-bad-time-bits.c',
+                     './addons/test/y2038/y2038-test-2-no-time-bits.c',
+                     './addons/test/y2038/y2038-test-3-no-use-time-bits.c',
+                     './addons/test/y2038/y2038-test-4-good.c',
+                     './addons/test/y2038/y2038-test-5-good-no-time-used.c']
+
+# Build system test file (for testing build system integration)
+BUILD_SYSTEM_TEST_FILE = './addons/test/y2038/y2038-test-buildsystem.c'
+
+
+def setup_module(module):
+    sys.argv.append("--cli")
+
+    # Create dumps for regular test files
+    for f in TEST_SOURCE_FILES:
+        dump_create(f)
+
+    # For build system tests, we'll create dumps on-demand in each test
+    # to avoid conflicts from multiple dump_create calls on the same file
+
+
+def teardown_module(module):
+    sys.argv.remove("--cli")
+    for f in TEST_SOURCE_FILES:
+        dump_remove(f)
+
+    # Build system test dumps are cleaned up individually in each test method
+
+
+def test_1_bad_time_bits(capsys):
+    is_safe = check_y2038_safe('./addons/test/y2038/y2038-test-1-bad-time-bits.c.dump', quiet=True)
+    assert(is_safe is False)
+    captured = capsys.readouterr()
+    captured = captured.out.splitlines()
+    json_output = convert_json_output(captured)
+
+    # Has exactly one warnings of _TIME_BITS and _USE_TIME_BITS64 kind.
+    assert(len(json_output['type-bits-undef']) == 1)
+    assert(len(json_output['type-bits-not-64']) == 1)
+
+    # There are 2 unsafe calls in test source and 3 in y2038-in.h
+    unsafe_calls = json_output['unsafe-call']
+    assert(len([c for c in unsafe_calls if c['file'].endswith('h')]) == 3)
+    assert(len([c for c in unsafe_calls if c['file'].endswith('c')]) == 0)
+
+
+def test_2_no_time_bits(capsys):
+    is_safe = check_y2038_safe('./addons/test/y2038/y2038-test-2-no-time-bits.c.dump', quiet=True)
+    assert(is_safe is False)
+    captured = capsys.readouterr()
+    captured = captured.out.splitlines()
+    json_output = convert_json_output(captured)
+
+    # _USE_TIME_BITS64 defined in y2038-inc.h header, but there is not
+    # _TIME_BITS definition. Here must be appropriate warning.
+    assert(len(json_output['type-bits-undef']) == 1)
+    assert(json_output.get('type-bits-not-64') is None)
+
+    # y2038-in.h still has y2038-unsafe calls.
+    unsafe_calls = json_output['unsafe-call']
+    assert(len([c for c in unsafe_calls if c['file'].endswith('h')]) == 3)
+
+
+def test_3_no_use_time_bits(capsys):
+    is_safe = check_y2038_safe('./addons/test/y2038/y2038-test-3-no-use-time-bits.c.dump', quiet=True)
+    assert(is_safe is False)
+    captured = capsys.readouterr()
+    captured = captured.out.splitlines()
+    json_output = convert_json_output(captured)
+
+    # Included bad _USE_TIME_BITS64 definition must trigger the errors.
+    unsafe_calls = json_output['unsafe-call']
+    assert(len(unsafe_calls) == 2)
+
+
+def test_4_good(capsys):
+    # pylint: disable-next=unused-variable - FIXME
+    is_safe = check_y2038_safe('./addons/test/y2038/y2038-test-4-good.c.dump', quiet=True)
+    # assert(is_safe is True) # FIXME: This should be a "good" example returning "True" instead of "False"
+    captured = capsys.readouterr()
+    captured = captured.out.splitlines()
+    json_output = convert_json_output(captured)
+
+    # Defined _TIME_BITS equal to 64 so that glibc knows we want Y2038 support.
+    # There are no warnings from C sources.
+    unsafe_calls = json_output['unsafe-call']
+    assert(len([c for c in unsafe_calls if c['file'].endswith('.c')]) == 0)
+
+
+def test_5_good(capsys):
+    is_safe = check_y2038_safe('./addons/test/y2038/y2038-test-5-good-no-time-used.c.dump', quiet=True)
+    assert(is_safe is True)
+    captured = capsys.readouterr()
+    captured = captured.out.splitlines()
+    json_output = convert_json_output(captured)
+
+    # There are no warnings from C sources.
+    if 'unsafe-call' in json_output:
+        unsafe_calls = json_output['unsafe-call']
+        assert(len([c for c in unsafe_calls if c['file'].endswith('.c')]) == 0)
+
+
+def test_build_system_integration():
+    """Test that Y2038 flags are properly parsed from cppcheck dump file configuration"""
+    from addons.y2038 import parse_dump_config
+
+    # Test Y2038-safe configuration string (as cppcheck would generate it)
+    config_string = "_TIME_BITS=64;_FILE_OFFSET_BITS=64;_USE_TIME_BITS64"
+    result = parse_dump_config(config_string)
+    # Y2038-safe flags should be detected
+    assert result['time_bits_defined'] is True
+    assert result['time_bits_value'] == 64
+    assert result['use_time_bits64_defined'] is True
+    assert result['file_offset_bits_defined'] is True
+    assert result['file_offset_bits_value'] == 64
+
+    # Test partial Y2038 configuration
+    partial_config = "_TIME_BITS=32;_FILE_OFFSET_BITS=64"
+    result = parse_dump_config(partial_config)
+    # Should detect the flags with their actual values
+    assert result['time_bits_defined'] is True
+    assert result['time_bits_value'] == 32  # Not Y2038-safe value
+    assert result['use_time_bits64_defined'] is False
+    assert result['file_offset_bits_defined'] is True
+    assert result['file_offset_bits_value'] == 64
+
+
+def test_arguments_regression():
+    args_ok = ["-t=foo", "--template=foo",
+               "-q", "--quiet",
+               "--cli"]
+    # Arguments with expected SystemExit
+    args_exit = ["--non-exists", "--non-exists-param=42", "-h", "--help"]
+
+    from addons.y2038 import get_args_parser
+
+    # sys.argv contains all pytest arguments - so clear all existing arguments first and restore afterwards
+    sys_argv_old = sys.argv
+    sys.argv = [sys.argv[0]]
+
+    try:
+        for arg in args_exit:
+            sys.argv.append(arg)
+            with pytest.raises(SystemExit):
+                parser = get_args_parser()
+                parser.parse_args()
+            sys.argv.remove(arg)
+
+        for arg in args_ok:
+            sys.argv.append(arg)
+            try:
+                parser = get_args_parser()
+                parser.parse_args()
+            except SystemExit:
+                pytest.fail("Unexpected SystemExit with '%s'" % arg)
+            sys.argv.remove(arg)
+    finally:
+        sys.argv = sys_argv_old
+
+
+def test_parse_dump_config():
+    """Test the parse_dump_config function for cppcheck dump file integration"""
+    from addons.y2038 import parse_dump_config
+
+    # Test comprehensive Y2038 configuration
+    full_config = "_TIME_BITS=64;_FILE_OFFSET_BITS=64;_USE_TIME_BITS64;OTHER_FLAG=1"
+    result = parse_dump_config(full_config)
+
+    assert result['time_bits_defined'] is True
+    assert result['time_bits_value'] == 64
+    assert result['use_time_bits64_defined'] is True
+    assert result['file_offset_bits_defined'] is True
+    assert result['file_offset_bits_value'] == 64
+
+    # Test empty configuration
+    result = parse_dump_config("")
+    assert result['time_bits_defined'] is False
+    assert result['time_bits_value'] is None
+    assert result['use_time_bits64_defined'] is False
+    assert result['file_offset_bits_defined'] is False
+    assert result['file_offset_bits_value'] is None
+    # Test Y2038-unsafe configuration
+    unsafe_config = "_TIME_BITS=32;_FILE_OFFSET_BITS=32"
+    result = parse_dump_config(unsafe_config)
+    assert result['time_bits_defined'] is True
+    assert result['time_bits_value'] == 32
+    assert result['use_time_bits64_defined'] is False
+    assert result['file_offset_bits_defined'] is True
+    assert result['file_offset_bits_value'] == 32
\ No newline at end of file
diff --git a/addons/threadsafety.py b/addons/threadsafety.py
index bbcd4bc00b0..9475e1a5b0d 100755
--- a/addons/threadsafety.py
+++ b/addons/threadsafety.py
@@ -1,35 +1,350 @@
-#!/usr/bin/env python
-#
-# This script analyses Cppcheck dump files to locate threadsafety issues
-# - warn about static local objects
-#
+#!/usr/bin/env python3
+"""
+cppcheck addon for threadsafety detection.
 
-import cppcheckdata
+ This script analyses Cppcheck dump files to locate threadsafety issues.
+ It warns about
+ - static local objects
+ - MT-Unsafe symbols listed in the "Attributes" sections of man pages.
+
+"""
+
+import re
 import sys
 
-def reportError(token, severity, msg, id):
-    cppcheckdata.reportError(token, severity, msg, 'threadsafety', id)
+import cppcheckdata
+
+# --------------------------------
+# List of MT-Unsafe identifiers
+# --------------------------------
+
+# This is Work In Progress.
+# Eventually it should contain all identifiers (types
+# and functions) which are MT-Unsafe.
+
+# The script tools/MT-Unsafe.py can help to re-generate this list.
+# It reads a man-page tree and report identifiers marked as "MT-Unsafe"
+# (see man 7 attributes for what this means), eg
+#   MT-Unsafe.py /usr/share/man/man3
+
+id_MTunsafe_full = {
+    # MT-Unsafe types by definition
+    # 'pthread_t',
+    # Types marked MT-Unsafe
+    'const:env',
+    'const:hostid',
+    'const:mallopt',
+    'const:sigintr',
+    'race:LogMask',
+    'race:asctime',
+    'race:crypt',
+    'race:crypt_gensalt',
+    'race:cuserid/!string',
+    'race:dirstream',
+    'race:drand48',
+    'race:ecvt',
+    'race:exit',
+    'race:fcvt',
+    'race:fgetgrent',
+    'race:fgetpwent',
+    'race:fgetspent',
+    'race:fsent',
+    'race:getdate',
+    'race:getlogin',
+    'race:getopt',
+    'race:getspent',
+    'race:getspnam',
+    'race:grent',
+    'race:grgid',
+    'race:grnam',
+    'race:hostbyaddr',
+    'race:hostbyname',
+    'race:hostbyname2',
+    'race:hostent',
+    'race:hsearch',
+    'race:l64a',
+    'race:localeconv',
+    'race:mbrlen/!ps',
+    'race:mbrtowc/!ps',
+    'race:mbsnrtowcs/!ps',
+    'race:mbsrtowcs/!ps',
+    'race:mcheck',
+    'race:mntentbuf',
+    'race:netbyaddr',
+    'race:netbyname',
+    'race:netent',
+    'race:netgrent',
+    'race:protobyname',
+    'race:protobynumber',
+    'race:protoent',
+    'race:ptsname',
+    'race:pwent',
+    'race:pwnam',
+    'race:pwuid',
+    'race:qecvt',
+    'race:qfcvt',
+    'race:servbyname',
+    'race:servbyport',
+    'race:servent',
+    'race:sgetspent',
+    'race:signgam',
+    'race:stdin',
+    'race:stdout',
+    'race:streams',
+    'race:strerror',
+    'race:strsignal',
+    'race:strtok',
+    'race:tmbuf',
+    'race:tmpnam/!s',
+    'race:ttyent',
+    'race:ttyname',
+    'race:utent',
+    'race:wcrtomb/!ps',
+    'race:wcsnrtombs/!ps',
+    'race:wcsrtombs/!ps',
+    'sig:ALRM',
+    'sig:SIGCHLD/linux',
+    # APIs marked MT-Unsafe
+    'asctime',
+    'clearenv',
+    'ctime',
+    'cuserid',
+    'drand48',
+    'ecvt',
+    'encrypt',
+    'endfsent',
+    'endgrent',
+    'endhostent',
+    'endnetent',
+    'endnetgrent',
+    'endprotoent',
+    'endpwent',
+    'endservent',
+    'endspent',
+    'endttyent',
+    'endusershell',
+    'endutent',
+    'erand48',
+    'error_at_line',
+    'ether_aton',
+    'ether_ntoa',
+    'exit',
+    'fcloseall',
+    'fcvt',
+    'fgetgrent',
+    'fgetpwent',
+    'fgetspent',
+    'fts_children',
+    'fts_read',
+    'gamma',
+    'gammaf',
+    'gammal',
+    'getaliasbyname',
+    'getaliasent',
+    'getchar_unlocked',
+    'getdate',
+    'getfsent',
+    'getfsfile',
+    'getfsspec',
+    'getgrent',
+    'getgrent_r',
+    'getgrgid',
+    'getgrnam',
+    'gethostbyaddr',
+    'gethostbyname',
+    'gethostbyname2',
+    'gethostent',
+    'gethostent_r',
+    'getlogin',
+    'getlogin_r',
+    'getmntent',
+    'getnetbyaddr',
+    'getnetbyname',
+    'getnetent',
+    'getnetgrent',
+    'getnetgrent_r',
+    'getopt',
+    'getopt_long',
+    'getopt_long_only',
+    'getpass',
+    'getprotobyname',
+    'getprotobynumber',
+    'getprotoent',
+    'getpwent',
+    'getpwent_r',
+    'getpwnam',
+    'getpwuid',
+    'getrpcbyname',
+    'getrpcbynumber',
+    'getrpcent',
+    'getservbyname',
+    'getservbyport',
+    'getservent',
+    'getspent',
+    'getspent_r',
+    'getspnam',
+    'getttyent',
+    'getttynam',
+    'getusershell',
+    'getutent',
+    'getutid',
+    'getutline',
+    'getwchar_unlocked',
+    'glob',
+    'gmtime',
+    'hcreate',
+    'hdestroy',
+    'hsearch',
+    'innetgr',
+    'jrand48',
+    'l64a',
+    'lcong48',
+    'localeconv',
+    'localtime',
+    'login',
+    'login_tty',
+    'logout',
+    'logwtmp',
+    'lrand48',
+    'mallinfo',
+    'mallinfo2',
+    'mblen',
+    'mbrlen',
+    'mbrtowc',
+    'mbsnrtowcs',
+    'mbsrtowcs',
+    'mbtowc',
+    'mcheck',
+    'mcheck_check_all',
+    'mcheck_pedantic',
+    'mprobe',
+    'mrand48',
+    'mtrace',
+    'muntrace',
+    'nrand48',
+    'profil',
+    'ptsname',
+    'putchar_unlocked',
+    'putenv',
+    'pututline',
+    'putwchar_unlocked',
+    'pvalloc',
+    'qecvt',
+    'qfcvt',
+    'rcmd',
+    'rcmd_af',
+    're_comp',
+    're_exec',
+    'readdir',
+    'rexec',
+    'rexec_af',
+    'seed48',
+    'setenv',
+    'setfsent',
+    'setgrent',
+    'sethostent',
+    'sethostid',
+    'setkey',
+    'setlogmask',
+    'setnetent',
+    'setnetgrent',
+    'setprotoent',
+    'setpwent',
+    'setservent',
+    'setspent',
+    'setttyent',
+    'setusershell',
+    'setutent',
+    'sgetspent',
+    'siginterrupt',
+    'sleep',
+    'srand48',
+    'strerror',
+    'strsignal',
+    'strtok',
+    'tmpnam',
+    'ttyname',
+    'ttyslot',
+    'unsetenv',
+    'updwtmp',
+    'utmpname',
+    'valloc',
+    'wcrtomb',
+    'wcsnrtombs',
+    'wcsrtombs',
+    'wctomb',
+    'wordexp'
+}
+
+# From man 7 attributes
+# the full token could be feature:function/condition - we just want function.
+id_MTunsafe = [re.sub('^.*:', '', re.sub('/.*$', '', x))
+               for x in id_MTunsafe_full
+               ]
+
+
+def reportError(token, severity, msg, errid):    # noqa: D103
+    cppcheckdata.reportError(token, severity, msg, 'threadsafety', errid)
 
 
-def checkstatic(data):
+def checkstatic(data):    # noqa: D103
     for var in data.variables:
         if var.isStatic and var.isLocal:
-            type = None
+            vartype = None
             if var.isClass:
-                type = 'object'
+                vartype = 'object'
             else:
-                type = 'variable'
+                vartype = 'variable'
             if var.isConst:
-                reportError(var.typeStartToken, 'warning', 'Local constant static ' + type + ' \'' + var.nameToken.str + '\', dangerous if it is initialized in parallel threads', 'threadsafety')
+                if data.standards.cpp == 'c++03':
+                    reportError(
+                        var.typeStartToken,
+                        'warning',
+                        'Local constant static '
+                        + vartype + "'" + var.nameToken.str
+                        + "', dangerous if it is initialized"
+                        + ' in parallel threads',
+                        'threadsafety-const')
             else:
-                reportError(var.typeStartToken, 'warning', 'Local static ' + type + ': ' + var.nameToken.str, 'threadsafety')
-
-for arg in sys.argv[1:]:
-    if arg.startswith('-'):
-        continue
-    print('Checking ' + arg + '...')
-    data = cppcheckdata.parsedump(arg)
-    for cfg in data.configurations:
-        if len(data.configurations) > 1:
-            print('Checking ' + arg + ', config "' + cfg.name + '"...')
-        checkstatic(cfg)
+                reportError(var.typeStartToken, 'warning',
+                            'Local static ' + vartype + ': '
+                            + var.nameToken.str,
+                            'threadsafety')
+
+
+def check_MTunsafe(cfg):
+    """
+    Look for functions marked MT-unsafe in their man pages.
+
+    The MT-unsafe functions are listed in id_MTunsafe (and id_MTunsafe_full).
+    That section of code can be regenerated by the external script MT-Unsafe.py
+    """
+    for token in cfg.tokenlist:
+        if token.str in id_MTunsafe:
+            reportError(token, 'warning', token.str + ' is MT-unsafe',
+                        'unsafe-call')
+
+
+if __name__ == '__main__':
+    parser = cppcheckdata.ArgumentParser()
+    args = parser.parse_args()
+
+    quiet = args.quiet or args.cli
+
+    if not args.dumpfile:
+        if not args.quiet:
+            print('no input files.')
+        sys.exit(0)
+
+    for dumpfile in args.dumpfile:
+        # load XML from .dump file
+        data = cppcheckdata.CppcheckData(dumpfile)
+
+        for cfg in data.iterconfigurations():
+            if not args.quiet:
+                srcfile = data.files[0]
+                print('Checking %s, config %s...' % (srcfile, cfg.name))
+            check_MTunsafe(cfg)
+            checkstatic(cfg)
+
+    sys.exit(cppcheckdata.EXIT_CODE)
diff --git a/addons/y2038.py b/addons/y2038.py
index 211631a6d33..b17d41dd330 100755
--- a/addons/y2038.py
+++ b/addons/y2038.py
@@ -1,32 +1,59 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # cppcheck addon for Y2038 safeness detection
 #
+# This addon provides comprehensive Y2038 (Year 2038 Problem) detection for C/C++ code.
+# It extracts compiler flags from cppcheck dump file configuration to determine
+# Y2038 safety, suppressing warnings when proper configuration is detected.
+#
+# Key Features:
+# - Extraction of Y2038-related flags from cppcheck dump file configuration
+# - Compiler flag parsing and validation from cppcheck's project parsing
+# - Warning suppression when proper Y2038 configuration is found
+# - Support for both _TIME_BITS=64 and _FILE_OFFSET_BITS=64 requirements
+# - Priority-based flag resolution (dump file configuration > source code directives)
+#
 # Detects:
 #
 # 1. _TIME_BITS being defined to something else than 64 bits
-# 2. _USE_TIME_BITS64 being defined when _TIME_BITS is not
-# 3. Any Y2038-unsafe symbol when _USE_TIME_BITS64 is not defined.
+# 2. _FILE_OFFSET_BITS being defined to something else than 64 bits
+# 3. _USE_TIME_BITS64 being defined when _TIME_BITS is not
+# 4. Any Y2038-unsafe symbol when proper Y2038 configuration is not present
+# 5. Dump file configurations that affect Y2038 safety
+#
+# Warning Suppression:
+# When both _TIME_BITS=64 AND _FILE_OFFSET_BITS=64 are detected (prioritizing dump file
+# configuration over source code directives), Y2038 warnings are suppressed and an
+# informational message is displayed instead.
 #
 # Example usage:
-# $ cppcheck --dump path-to-src/test.c
-# $ y2038.py path-to-src/test.c.dump
+# $ cppcheck --addon=y2038 path-to-src/test.c
+# $ cppcheck --dump file.c && python3 y2038.py file.c.dump
 #
-# y2038.py will walk the source tree for .dump files.
+
 from __future__ import print_function
 
 import cppcheckdata
 import sys
-import os
 import re
 
+# Y2038 flags are extracted by cppcheck core during project parsing
+# and passed through dump file configuration - no redundant parsing needed
+
+# --------------------------------
+# Y2038 safety constants
+# --------------------------------
+
+# Y2038-safe bit values
+Y2038_SAFE_TIME_BITS = 64
+Y2038_SAFE_FILE_OFFSET_BITS = 64
 
 # --------------------------------------------
 # #define/#undef detection regular expressions
 # --------------------------------------------
 
 # test for '#define _TIME_BITS 64'
-re_define_time_bits_64 = re.compile(r'^\s*#\s*define\s+_TIME_BITS\s+64\s*$')
+re_define_time_bits_64 = re.compile(rf'^\s*#\s*define\s+_TIME_BITS\s+{Y2038_SAFE_TIME_BITS}\s*$')
 
 # test for '#define _TIME_BITS ...' (combine w/ above to test for 'not 64')
 re_define_time_bits = re.compile(r'^\s*#\s*define\s+_TIME_BITS\s+.*$')
@@ -40,6 +67,34 @@
 # test for '#undef _USE_TIME_BITS64' (if it ever happens)
 re_undef_use_time_bits64 = re.compile(r'^\s*#\s*undef\s+_USE_TIME_BITS64\s*$')
 
+# test for '#define _FILE_OFFSET_BITS 64'
+re_define_file_offset_bits_64 = re.compile(rf'^\s*#\s*define\s+_FILE_OFFSET_BITS\s+{Y2038_SAFE_FILE_OFFSET_BITS}\s*$')
+
+# test for '#define _FILE_OFFSET_BITS ...' (combine w/ above to test for 'not 64')
+re_define_file_offset_bits = re.compile(r'^\s*#\s*define\s+_FILE_OFFSET_BITS\s+.*$')
+
+# test for '#undef _FILE_OFFSET_BITS' (if it ever happens)
+re_undef_file_offset_bits = re.compile(r'^\s*#\s*undef\s+_FILE_OFFSET_BITS\s*$')
+
+# --------------------------------------------
+# Compiler flag parsing regular expressions
+# --------------------------------------------
+
+# test for '_TIME_BITS=64' in compiler flags
+re_flag_time_bits_64 = re.compile(rf'_TIME_BITS={Y2038_SAFE_TIME_BITS}(?:\s|$|;)')
+
+# test for '_TIME_BITS=...' in compiler flags (combine w/ above to test for 'not 64')
+re_flag_time_bits = re.compile(r'_TIME_BITS=(\d+)')
+
+# test for '_USE_TIME_BITS64' in compiler flags
+re_flag_use_time_bits64 = re.compile(r'_USE_TIME_BITS64(?:\s|$|=|;)')
+
+# test for '_FILE_OFFSET_BITS=64' in compiler flags
+re_flag_file_offset_bits_64 = re.compile(rf'_FILE_OFFSET_BITS={Y2038_SAFE_FILE_OFFSET_BITS}(?:\s|$|;)')
+
+# test for '_FILE_OFFSET_BITS=...' in compiler flags
+re_flag_file_offset_bits = re.compile(r'_FILE_OFFSET_BITS=(\d+)')
+
 # --------------------------------
 # List of Y2038-unsafe identifiers
 # --------------------------------
@@ -59,7 +114,6 @@
     'timeval',
     'utimbuf',
     'itimerspec',
-    'stat',
     'clnt_ops',
     'elf_prstatus',
     'itimerval',
@@ -150,110 +204,399 @@
 }
 
 
+
+
+
+
+
+
+
+def parse_dump_config(config_name):
+    """
+    Parse Y2038-related flags from cppcheck dump file configuration name.
+    
+    This function analyzes the cppcheck dump file configuration name (which contains 
+    preprocessor definitions extracted by cppcheck from project files like compile_commands.json)
+    to extract Y2038-related definitions. It looks for _TIME_BITS, _USE_TIME_BITS64, and 
+    _FILE_OFFSET_BITS definitions and validates their values.
+
+    Args:
+        config_name (str): The cppcheck configuration name from dump file
+                          (e.g., "_TIME_BITS=64;_FILE_OFFSET_BITS=64")
+
+    Returns:
+        dict: Dictionary containing Y2038-related flag information with keys:
+            - 'time_bits_defined' (bool): Whether _TIME_BITS is defined
+            - 'time_bits_value' (int|None): Value of _TIME_BITS (None if not defined)
+            - 'use_time_bits64_defined' (bool): Whether _USE_TIME_BITS64 is defined
+            - 'file_offset_bits_defined' (bool): Whether _FILE_OFFSET_BITS is defined
+            - 'file_offset_bits_value' (int|None): Value of _FILE_OFFSET_BITS (None if not defined)
+
+    Example:
+        >>> parse_dump_config("_TIME_BITS=64;_FILE_OFFSET_BITS=64")
+        {
+            'time_bits_defined': True,
+            'time_bits_value': 64,
+            'use_time_bits64_defined': False,
+            'file_offset_bits_defined': True,
+            'file_offset_bits_value': 64
+        }
+    """
+    result = {
+        'time_bits_defined': False,
+        'time_bits_value': None,
+        'use_time_bits64_defined': False,
+        'file_offset_bits_defined': False,
+        'file_offset_bits_value': None
+    }
+
+    if not config_name:
+        return result
+
+    try:
+        # Check for _TIME_BITS=64 (correct value)
+        if re_flag_time_bits_64.search(config_name):
+            result['time_bits_defined'] = True
+            result['time_bits_value'] = Y2038_SAFE_TIME_BITS
+        else:
+            # Check for _TIME_BITS=other_value
+            match = re_flag_time_bits.search(config_name)
+            if match:
+                result['time_bits_defined'] = True
+                try:
+                    result['time_bits_value'] = int(match.group(1))
+                except (ValueError, IndexError):
+                    # Malformed _TIME_BITS value, treat as undefined
+                    result['time_bits_defined'] = False
+                    result['time_bits_value'] = None
+
+        # Check for _USE_TIME_BITS64
+        if re_flag_use_time_bits64.search(config_name):
+            result['use_time_bits64_defined'] = True
+
+        # Check for _FILE_OFFSET_BITS=64 (correct value)
+        if re_flag_file_offset_bits_64.search(config_name):
+            result['file_offset_bits_defined'] = True
+            result['file_offset_bits_value'] = Y2038_SAFE_FILE_OFFSET_BITS
+        else:
+            # Check for _FILE_OFFSET_BITS=other_value
+            match = re_flag_file_offset_bits.search(config_name)
+            if match:
+                result['file_offset_bits_defined'] = True
+                try:
+                    result['file_offset_bits_value'] = int(match.group(1))
+                except (ValueError, IndexError):
+                    # Malformed _FILE_OFFSET_BITS value, treat as undefined
+                    result['file_offset_bits_defined'] = False
+                    result['file_offset_bits_value'] = None
+
+    except (AttributeError, TypeError, ValueError):
+        # If any unexpected error occurs during parsing, return empty result
+        # This ensures the addon continues to work even with malformed configurations
+        # Note: We catch specific exceptions rather than broad Exception for better debugging
+        pass
+
+    return result
+
+
 def check_y2038_safe(dumpfile, quiet=False):
-    # at the start of the check, we don't know if code is Y2038 safe
-    y2038safe = False
+    """
+    Main function to check Y2038 safety of C/C++ code from cppcheck dump files.
+
+    This function performs comprehensive Y2038 analysis including:
+    1. Extraction of Y2038-related compiler flags from cppcheck dump file configuration
+    2. Analysis of source code preprocessor directives
+    3. Warning suppression when proper Y2038 configuration is detected
+    4. Reporting of Y2038-unsafe symbols and configurations
+
+    The function implements a priority-based approach for Y2038 flag detection:
+    - Dump file configuration (from cppcheck's project parsing - highest priority)
+    - Source code #define directives (fallback)
+
+    Warning suppression occurs when both _TIME_BITS=64 AND _FILE_OFFSET_BITS=64
+    are detected from any source. When warnings are suppressed, an informational
+    message is displayed indicating the configuration source and suppression count.
+
+    Args:
+        dumpfile (str): Path to the cppcheck XML dump file (.dump extension)
+        quiet (bool, optional): If True, suppress informational messages. Defaults to False.
+
+    Returns:
+        bool: True if code is Y2038-safe, False if Y2038 issues were detected
+
+    Raises:
+        Exception: May raise exceptions from cppcheckdata parsing or file I/O operations
+
+    Example:
+        >>> check_y2038_safe("test.c.dump")  # Normal operation
+        True
+        >>> check_y2038_safe("test.c.dump", quiet=True)  # Suppress info messages
+        False
+    """
+    # Assume that the code is Y2038 safe until proven otherwise
+    y2038safe = True
     # load XML from .dump file
-    data = cppcheckdata.parsedump(dumpfile)
-
-    # Convert dump file path to source file in format generated by cppcheck.
-    # For example after the following call:
-    # cppcheck ./src/my-src.c --dump
-    # We got 'src/my-src.c' value for 'file' field in cppcheckdata.
-    srcfile = dumpfile.rstrip('.dump')
-    srcfile = os.path.expanduser(srcfile)
-    srcfile = os.path.normpath(srcfile)
-
-    # go through each configuration
-    for cfg in data.configurations:
+    data = cppcheckdata.CppcheckData(dumpfile)
+
+    srcfile = data.files[0]
+
+    for cfg in data.iterconfigurations():
         if not quiet:
-            print('Checking ' + srcfile + ', config "' + cfg.name + '"...')
+            print('Checking %s, config %s...' % (srcfile, cfg.name))
         safe_ranges = []
         safe = -1
         time_bits_defined = False
-        srclinenr = '0'
+        srclinenr = 0
+
+        # Priority-based flag detection: dump file configuration > source code directives
+        # 1. Check dump file configuration (from cppcheck's project parsing - highest priority)
+        dump_config_flags = parse_dump_config(cfg.name)
+        # Initialize effective flags with dump file configuration
+        effective_flags = {
+            'time_bits_defined': dump_config_flags['time_bits_defined'],
+            'time_bits_value': dump_config_flags['time_bits_value'],
+            'use_time_bits64_defined': dump_config_flags['use_time_bits64_defined'],
+            'file_offset_bits_defined': dump_config_flags['file_offset_bits_defined'],
+            'file_offset_bits_value': dump_config_flags['file_offset_bits_value']
+        }
 
+        # Determine configuration source for reporting
+        config_source = None
+        has_dump_config = (dump_config_flags['time_bits_defined'] or
+                          dump_config_flags['file_offset_bits_defined'] or
+                          dump_config_flags['use_time_bits64_defined'])
+        if has_dump_config:
+            config_source = "cppcheck configuration"
+
+        # Track time_bits_defined for _USE_TIME_BITS64 validation
+        time_bits_defined = effective_flags['time_bits_defined']
+
+        # Check effective _TIME_BITS value (from dump file configuration)
+        if effective_flags['time_bits_defined']:
+            if effective_flags['time_bits_value'] != Y2038_SAFE_TIME_BITS:
+                fake_directive = type('FakeDirective', (), {
+                    'file': srcfile, 'linenr': 0, 'column': 0,
+                    'str': 'cppcheck configuration: _TIME_BITS=%s' % effective_flags['time_bits_value']
+                })()
+                cppcheckdata.reportError(fake_directive, 'error',
+                                         '_TIME_BITS must be defined equal to 64 (found in cppcheck configuration: _TIME_BITS=%s)' % effective_flags['time_bits_value'],
+                                         'y2038',
+                                         'type-bits-not-64')
+                y2038safe = False
+
+        # Check effective _FILE_OFFSET_BITS value (from dump file configuration)
+        if effective_flags['file_offset_bits_defined']:
+            if effective_flags['file_offset_bits_value'] != Y2038_SAFE_FILE_OFFSET_BITS:
+                fake_directive = type('FakeDirective', (), {
+                    'file': srcfile, 'linenr': 0, 'column': 0,
+                    'str': 'cppcheck configuration: _FILE_OFFSET_BITS=%s' % effective_flags['file_offset_bits_value']
+                })()
+                cppcheckdata.reportError(fake_directive, 'error',
+                                         '_FILE_OFFSET_BITS must be defined equal to 64 (found in cppcheck configuration: _FILE_OFFSET_BITS=%s)' % effective_flags['file_offset_bits_value'],
+                                         'y2038',
+                                         'file-offset-bits-not-64')
+                y2038safe = False
+
+        # Check effective _USE_TIME_BITS64 (from dump file configuration)
+        if effective_flags['use_time_bits64_defined']:
+            if not time_bits_defined:
+                # _USE_TIME_BITS64 defined without _TIME_BITS is problematic
+                fake_directive = type('FakeDirective', (), {
+                    'file': srcfile, 'linenr': 0, 'column': 0,
+                    'str': 'cppcheck configuration: _USE_TIME_BITS64'
+                })()
+                cppcheckdata.reportError(fake_directive, 'warning',
+                                         '_USE_TIME_BITS64 is defined in cppcheck configuration but _TIME_BITS was not',
+                                         'y2038',
+                                         'type-bits-undef')
+                y2038safe = False
+            else:
+                # _USE_TIME_BITS64 defined WITH _TIME_BITS - this is correct
+                safe = 0  # Start of file is safe
+
+        # 2. Fallback to source code directives when dump file configuration is not available
+        source_time_bits_defined = False  # pylint: disable=unused-variable
+        source_file_offset_bits_defined = False  # pylint: disable=unused-variable
+        source_file_offset_bits_value = None  # pylint: disable=unused-variable
+        source_use_time_bits64_defined = False  # pylint: disable=unused-variable
+
+        # Track which flags came from source code for mixed scenario reporting
+        source_flags_used = {
+            'time_bits': False,
+            'file_offset_bits': False,
+            'use_time_bits64': False
+        }
         for directive in cfg.directives:
             # track source line number
             if directive.file == srcfile:
                 srclinenr = directive.linenr
+
+            # Process source code directives as fallback when dump config is not available
             # check for correct _TIME_BITS if present
             if re_define_time_bits_64.match(directive.str):
-                time_bits_defined = True
+                source_time_bits_defined = True
+                # Only use source directive if dump config doesn't define _TIME_BITS
+                if not effective_flags['time_bits_defined']:
+                    effective_flags['time_bits_defined'] = True
+                    effective_flags['time_bits_value'] = Y2038_SAFE_TIME_BITS
+                    time_bits_defined = True
+                    source_flags_used['time_bits'] = True
             elif re_define_time_bits.match(directive.str):
-                cppcheckdata.reportError(directive, 'error',
-                                         '_TIME_BITS must be defined equal to 64',
-                                         'y2038',
-                                         'type-bits-not-64')
-                time_bits_defined = False
-                y2038safe = False
+                source_time_bits_defined = False
+                # Only use source directive if dump config doesn't define _TIME_BITS
+                if not effective_flags['time_bits_defined']:
+                    source_flags_used['time_bits'] = True
+                    cppcheckdata.reportError(directive, 'error',
+                                             '_TIME_BITS must be defined equal to 64',
+                                             'y2038',
+                                             'type-bits-not-64')
+                    y2038safe = False
             elif re_undef_time_bits.match(directive.str):
-                time_bits_defined = False
+                source_time_bits_defined = False
+                # Only use source directive if dump config doesn't define _TIME_BITS
+                if not effective_flags['time_bits_defined']:
+                    time_bits_defined = False
+                    source_flags_used['time_bits'] = True
+            # check for correct _FILE_OFFSET_BITS if present
+            if re_define_file_offset_bits_64.match(directive.str):
+                source_file_offset_bits_defined = True
+                source_file_offset_bits_value = Y2038_SAFE_FILE_OFFSET_BITS
+                # Only use source directive if dump config doesn't define _FILE_OFFSET_BITS
+                if not effective_flags['file_offset_bits_defined']:
+                    effective_flags['file_offset_bits_defined'] = True
+                    effective_flags['file_offset_bits_value'] = Y2038_SAFE_FILE_OFFSET_BITS
+                    source_flags_used['file_offset_bits'] = True
+            elif re_define_file_offset_bits.match(directive.str):
+                source_file_offset_bits_defined = False
+                # Only use source directive if dump config doesn't define _FILE_OFFSET_BITS
+                if not effective_flags['file_offset_bits_defined']:
+                    source_flags_used['file_offset_bits'] = True
+                    cppcheckdata.reportError(directive, 'error',
+                                             '_FILE_OFFSET_BITS must be defined equal to 64',
+                                             'y2038',
+                                             'file-offset-bits-not-64')
+                    y2038safe = False
+            elif re_undef_file_offset_bits.match(directive.str):
+                source_file_offset_bits_defined = False
+                source_file_offset_bits_value = None
+                # Only use source directive if dump config doesn't define _FILE_OFFSET_BITS
+                if not effective_flags['file_offset_bits_defined']:
+                    effective_flags['file_offset_bits_defined'] = False
+                    effective_flags['file_offset_bits_value'] = None
+                    source_flags_used['file_offset_bits'] = True
+
             # check for _USE_TIME_BITS64 (un)definition
             if re_define_use_time_bits64.match(directive.str):
                 safe = int(srclinenr)
-                # warn about _TIME_BITS not being defined
-                if not time_bits_defined:
-                    cppcheckdata.reportError(directive, 'warning',
-                                             '_USE_TIME_BITS64 is defined but _TIME_BITS was not',
-                                             'y2038',
-                                             'type-bits-undef')
+                source_use_time_bits64_defined = True
+                # Only use source directive if dump config doesn't define _USE_TIME_BITS64
+                if not effective_flags['use_time_bits64_defined']:
+                    effective_flags['use_time_bits64_defined'] = True
+                    source_flags_used['use_time_bits64'] = True
+                    # warn about _TIME_BITS not being defined (check effective flags)
+                    if not time_bits_defined:
+                        cppcheckdata.reportError(directive, 'warning',
+                                                 '_USE_TIME_BITS64 is defined but _TIME_BITS was not',
+                                                 'y2038',
+                                                 'type-bits-undef')
             elif re_undef_use_time_bits64.match(directive.str):
                 unsafe = int(srclinenr)
+                source_use_time_bits64_defined = False
+                # Only use source directive if dump config doesn't define _USE_TIME_BITS64
+                if not effective_flags['use_time_bits64_defined']:
+                    source_flags_used['use_time_bits64'] = True
                 # do we have a safe..unsafe area?
-                if unsafe > safe > 0:
+                if unsafe > safe >= 0:
                     safe_ranges.append((safe, unsafe))
                     safe = -1
 
         # check end of source beyond last directive
         if len(cfg.tokenlist) > 0:
             unsafe = int(cfg.tokenlist[-1].linenr)
-            if unsafe > safe > 0:
+            if unsafe > safe >= 0:
                 safe_ranges.append((safe, unsafe))
 
+        # Determine if Y2038 warnings should be suppressed
+        # Require BOTH _TIME_BITS=64 AND _FILE_OFFSET_BITS=64 for complete Y2038 safety
+        y2038_safe_config = (
+            effective_flags['time_bits_defined'] and
+            effective_flags['time_bits_value'] == Y2038_SAFE_TIME_BITS and
+            effective_flags['file_offset_bits_defined'] and
+            effective_flags['file_offset_bits_value'] == Y2038_SAFE_FILE_OFFSET_BITS
+        )
+
+        # Update config_source for suppression reporting based on mixed scenarios
+        if y2038_safe_config:
+            # Determine configuration source for mixed scenarios
+            dump_flags_count = sum([
+                dump_config_flags['time_bits_defined'],
+                dump_config_flags['file_offset_bits_defined'],
+                dump_config_flags['use_time_bits64_defined']
+            ])
+            source_flags_count = sum(source_flags_used.values())
+
+            if dump_flags_count > 0 and source_flags_count > 0:
+                # Mixed scenario: both dump config and source directives used
+                config_source = "mixed configuration (cppcheck configuration and source code directives)"
+            elif dump_flags_count > 0:
+                # Only dump config used
+                config_source = "cppcheck configuration"
+            elif source_flags_count > 0:
+                # Only source directives used
+                config_source = "source code directives"
+            else:
+                # Fallback (shouldn't happen if y2038_safe_config is True)
+                config_source = "configuration"
+
         # go through all tokens
+        warnings_suppressed = 0
         for token in cfg.tokenlist:
             if token.str in id_Y2038:
-                if not any(lower <= int(token.linenr) <= upper
-                           for (lower, upper) in safe_ranges):
-                    cppcheckdata.reportError(token, 'warning',
-                                             token.str + ' is Y2038-unsafe',
-                                             'y2038',
-                                             'unsafe-call')
-                    y2038safe = False
+                is_in_safe_range = any(lower <= int(token.linenr) <= upper
+                                     for (lower, upper) in safe_ranges)
+
+                if not is_in_safe_range:
+                    if y2038_safe_config:
+                        # Count suppressed warnings but don't report them
+                        warnings_suppressed += 1
+                    else:
+                        # Report the warning as before
+                        cppcheckdata.reportError(token, 'warning',
+                                                 token.str + ' is Y2038-unsafe',
+                                                 'y2038',
+                                                 'unsafe-call')
+                        y2038safe = False
             token = token.next
 
+        # Print suppression message if warnings were suppressed
+        if warnings_suppressed > 0 and config_source and not quiet:
+            print('Y2038 warnings suppressed: Found proper Y2038 configuration in %s (_TIME_BITS=%d and _FILE_OFFSET_BITS=%d)' % (config_source, Y2038_SAFE_TIME_BITS, Y2038_SAFE_FILE_OFFSET_BITS))
+            print('Suppressed %d Y2038-unsafe function warning(s)' % warnings_suppressed)
+
     return y2038safe
 
 
-def get_args():
+def get_args_parser():
     parser = cppcheckdata.ArgumentParser()
-    parser.add_argument("dumpfile", nargs='*', help="Path of dump file from cppcheck")
-    parser.add_argument('-q', '--quiet', action='store_true',
-                        help='do not print "Checking ..." lines')
-    parser.add_argument('--cli', help='Addon is executed from Cppcheck', action='store_true')
-    return parser.parse_args()
+    return parser
 
 
 if __name__ == '__main__':
-    args = get_args()
+    parser = get_args_parser()
+    args = parser.parse_args()
 
     exit_code = 0
-    quiet = not any((args.quiet, args.cli))
-
-    if args.dumpfile:
-        for dumpfile in args.dumpfile:
-            if not os.path.isfile(dumpfile):
-                print("Error: File not found: %s" % dumpfile)
-                sys.exit(127)
-            if not os.access(dumpfile, os.R_OK):
-                print("Error: Permission denied: %s" % dumpfile)
-                sys.exit(13)
-            if not args.quiet:
-                print('Checking ' + dumpfile + '...')
-
-            y2038safe = check_y2038_safe(dumpfile, quiet)
-            if not y2038safe and exit_code == 0:
-                exit_code = 1
-
-    sys.exit(exit_code)
+    quiet = args.quiet or args.cli
+
+    if not args.dumpfile:
+        if not args.quiet:
+            print("no input files.")
+        sys.exit(0)
+
+    for dumpfile in args.dumpfile:
+        if not quiet:
+            print('Checking ' + dumpfile + '...')
+
+        check_y2038_safe(dumpfile, quiet)
+
+    sys.exit(cppcheckdata.EXIT_CODE)
diff --git a/appveyor.yml b/appveyor.yml
deleted file mode 100644
index 0b36d91d7cc..00000000000
--- a/appveyor.yml
+++ /dev/null
@@ -1,97 +0,0 @@
-version: '{build}'
-
-clone_depth: 10
-
-matrix:
-  fast_finish: true
-
-environment:
-  matrix:
-    - VisualStudioVersion: 12.0
-      platform: Win32
-      configuration: Debug
-      vcvarsall_platform: x86
-      PlatformToolset: v120
-    - VisualStudioVersion: 12.0
-      platform: Win32
-      configuration: Release
-      vcvarsall_platform: x86
-      PlatformToolset: v120
-      MYQTDIR: C:\Qt\5.6\msvc2013
-    - VisualStudioVersion: 12.0
-      platform: x64
-      configuration: Debug
-      vcvarsall_platform: x64
-      PlatformToolset: v120
-      cygwin_build: yes
-    - VisualStudioVersion: 12.0
-      platform: x64
-      configuration: Release
-      vcvarsall_platform: x64
-      PlatformToolset: v120
-      MYQTDIR: C:\Qt\5.6\msvc2013_64
-# FIXME: These are disabled for now. They were broken by ae8653612802b41b70424ec9a5eefe8a1178f6d1
-#    - VisualStudioVersion: 14.0
-#      platform: Win32
-#      configuration: Debug
-#      vcvarsall_platform: x86
-#      PlatformToolset: v140
-#    - VisualStudioVersion: 14.0
-#      platform: Win32
-#      configuration: Release
-#      vcvarsall_platform: x86
-#      PlatformToolset: v140
-#      MYQTDIR: C:\Qt\5.11\msvc2015
-#    - VisualStudioVersion: 14.0
-#      platform: x64
-#      configuration: Debug
-#      vcvarsall_platform: x64
-#      PlatformToolset: v140
-# That platform causes frequent errors on appveyor due to an unknown infrastructure failure
-#    - VisualStudioVersion: 14.0
-#      platform: x64
-#      configuration: Release
-#      vcvarsall_platform: x64
-#      PlatformToolset: v140
-#      MYQTDIR: C:\Qt\5.11\msvc2015_64
-
-install:
-  - pip install pytest
-
-build_script:
-  - ECHO Building %configuration% %platform% with MSVC %VisualStudioVersion% using %PlatformToolset% PlatformToolset
-  - 'CALL "C:\Program Files (x86)\Microsoft Visual Studio %VisualStudioVersion%\VC\vcvarsall.bat" %vcvarsall_platform%'
-  # Visual studio project..
-  - msbuild "cppcheck.sln" /consoleloggerparameters:Verbosity=minimal /target:Build /property:Configuration="%configuration%";Platform=%platform% /p:PlatformToolset=%PlatformToolset% /maxcpucount /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
-  # cmake..
-  - mkdir build
-  - cd build
-  - cmake -DBUILD_TESTS=ON -G"NMake Makefiles" ..
-  - nmake
-  - copy bin\cppcheck.exe ..
-  - cd ..
-  # build gui..
-  - ECHO MYQTDIR=%MYQTDIR%
-  - 'IF defined MYQTDIR cd gui'
-  - 'IF defined MYQTDIR set QTDIR=%MYQTDIR%'
-  - 'IF defined MYQTDIR %QTDIR%\bin\qmake'
-  - 'IF defined MYQTDIR nmake'
-  - 'IF defined MYQTDIR cd ..'
-
-test_script:
-  - build\bin\testrunner.exe -q
-  - IF EXIST bin\debug\testrunner.exe bin\debug\testrunner.exe
-  - IF EXIST bin\testrunner.exe bin\testrunner.exe
-  - cd test\cli
-  - python -m pytest test-helloworld.py
-  - python -m pytest test-inline-suppress.py
-  - python -m pytest test-suppress-syntaxError.py
-  - 'IF defined cygwin_build C:\cygwin64\bin\bash -e -l -c "cd /cygdrive/c/projects/cppcheck && make clean && make -j 2 && make test && make checkcfg"'
-
-artifacts:
-  - path: bin
-    name: CLI binaries
-    type: zip
-  - path: Build\gui
-    name: GUI binaries
-    type: zip
diff --git a/benchmarks.txt b/benchmarks.txt
deleted file mode 100644
index d902aa12996..00000000000
--- a/benchmarks.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-
-==========
-Benchmarks
-==========
-
-In this file we can document some good code repos / code samples to use when working on optimisations.
-
-Trac tickets
-------------
-
-http://trac.cppcheck.net/ticket/2435 -- Tokenizer::simplifyTypedef
-http://trac.cppcheck.net/ticket/8355 -- TokenList::createAst
-http://trac.cppcheck.net/ticket/9007 -- Unused types
-
-
-Repos
------
-
-Small C++ library with lots of templates:
-https://framagit.org/dtschump/CImg
-Just check the file examples/use_tinymatwriter.cpp
-
diff --git a/build-pcre.txt b/build-pcre.txt
index dfb80f0eb03..9f4e8e06e29 100644
--- a/build-pcre.txt
+++ b/build-pcre.txt
@@ -1,68 +1,63 @@
-PCRE is a library that is used by the optional "rules" feature for the command
-line version of cppcheck. It is readily available on Linux and Mac OS X, but
-must be obtained separately for Windows.
-
-If you're using qmake to generate makefiles, the following behavior applies:
-
-- If you're not on Windows, it assumes by default that you have PCRE and want
-  to enable rules support. You can disable rules support (removing the PCRE
-  dependency) by passing HAVE_RULES=no to qmake.
-
-- If you are on Windows, but have PCRE available, you can enable rules support
-  by passing HAVE_RULES=yes to qmake.
-
-  - Note: This includes using build.bat since it calls qmake - to use PCRE and
-    build.bat, you need to run set HAVE_RULES=yes before each run of build.bat
-
-
-Build instructions
-------------------
-
-Windows
--------
-
-Visual Studio
-
-To build PCRE, download the source code from www.pcre.org and
-CMake (https://cmake.org/download/). We assume you use Visual Studio 2015 -
-otherwise adapt the commands for your version.
-
-VS Solution file
-  cmake . -G "Visual Studio 14 2015"
-  Open PCRE.sln with VS IDE or via cmd:
-    call "%VS140COMNTOOLS%..\..\VC\vcvarsall.bat" x86
-    MSBuild PCRE.sln /target:Build /property:Configuration="Release"
-
-  For 64-bit target: cmake . -G "Visual Studio 14 2015 Win64"
-
-or using NMake
-  call "%VS140COMNTOOLS%..\..\VC\vcvarsall.bat" x86
-  cmake . -G "NMake Makefiles"
-  nmake
-
-or using MSYS
-  cmake . -G "MSYS Makefiles"
-  make
-
-
-Linux
------
-
-The normal Makefile should work.
-
-Install PCRE on Ubuntu might be needed:
-  sudo apt-get install libpcre3 libpcre3-dev
-
-
-Mac OSX
--------
-
-Install PCRE:
-
-  sudo port install pcre
-
-Ensure /path/to/pcre.h is in CXXFLAGS, e.g:
-
-  export CXXFLAGS=${CXXFLAGS}:/opt/local/include
-
-Or for MSVC copy pcre.lib and pcre.h in /externals directory.
+PCRE is a library that is used by the optional "rules" feature for the command
+line version of cppcheck. It is readily available on Linux and Mac OS X, but
+must be obtained separately for Windows.
+
+Build instructions
+------------------
+
+Windows
+-------
+
+Visual Studio
+
+To build PCRE, download the source code from www.pcre.org and
+CMake (https://cmake.org/download/). We assume you use Visual Studio 2015 -
+otherwise adapt the commands for your version.
+
+VS Solution file
+  cmake . -G "Visual Studio 14 2015"
+  Open PCRE.sln with VS IDE or via cmd:
+    call "%VS140COMNTOOLS%..\..\VC\vcvarsall.bat" x86
+    MSBuild PCRE.sln /target:Build /property:Configuration="Release"
+
+  For 64-bit target: cmake . -G "Visual Studio 14 2015 Win64"
+
+or using NMake
+  call "%VS140COMNTOOLS%..\..\VC\vcvarsall.bat" x86
+  cmake . -G "NMake Makefiles"
+  nmake
+
+or using MSYS
+  cmake . -G "MSYS Makefiles"
+  make
+
+
+Linux
+-----
+
+The normal Makefile should work.
+
+Install PCRE on Ubuntu might be needed:
+  sudo apt-get install libpcre3 libpcre3-dev
+
+
+Mac OSX
+-------
+
+Install PCRE:
+
+homebre
+  brew install pcre
+
+or macport
+  sudo port install pcre
+
+Ensure /path/to/pcre.h is in CXXFLAGS, e.g:
+
+for homebrew
+  export CXXFLAGS=${CXXFLAGS}:/usr/local/include
+
+or macport
+  export CXXFLAGS=${CXXFLAGS}:/opt/local/include
+
+Or for MSVC copy pcre.lib and pcre.h in /externals directory.
diff --git a/build.bat b/build.bat
deleted file mode 100644
index 9c075594e44..00000000000
--- a/build.bat
+++ /dev/null
@@ -1,72 +0,0 @@
-@echo off
-REM A simple script to build different cppcheck targets from project root
-REM folder. This script can be run from VS prompt or Qt prompt.
-REM
-REM Usage: build <target> [release|debug]
-REM  where <target> is any of cppcheck/gui/tests/all
-REM        release or debug is the configuration
-REM  all-target builds both cppcheck and gui.
-REM
-REM Run the command before build.bat to enable rules using pcre:
-REM   set HAVE_RULES=yes
-REM
-REM TODO:
-REM  - run tests too
-
-pushd %~dp0
-
-if "%1" == "" goto help
-
-REM Qt prompt sets QMAKESPEC
-if "%QMAKESPEC%" == "" (
-REM parse qmakespec to see if it's some msvc
-  if "%QMAKESPEC:~6,4%" == "msvc" (
-    set MAKE=nmake
-  ) else (
-    set MAKE=mingw32-make
-  )
-) else (
-  set MAKE=nmake
-)
-
-if "%2" == ""        set TARGET=release
-if "%2" == "debug"   set TARGET=debug
-if "%2" == "release" set TARGET=release
-
-if "%1" == "all"      goto cppcheck
-if "%1" == "cppcheck" goto cppcheck
-if "%1" == "gui"      goto gui
-if "%1" == "tests"    goto tests
-goto help
-
-:cppcheck
-pushd cli
-qmake -config %TARGET% HAVE_RULES=%HAVE_RULES%
-%MAKE%
-popd
-if "%1" == "all" goto gui
-goto end
-
-:gui
-pushd gui
-qmake -config %TARGET% HAVE_RULES=%HAVE_RULES%
-%MAKE%
-lupdate -no-obsolete gui.pro
-lrelease gui.pro
-popd
-goto end
-
-:tests
-pushd test
-qmake -config %TARGET% HAVE_RULES=%HAVE_RULES%
-%MAKE%
-popd
-goto end
-
-:help
-echo Syntax: build ^<target^> [debug^|release]
-echo   where ^<target^> is any of cppcheck/gui/tests/all
-echo         debug or release define used configuration
-echo   all- target builds both cppcheck and gui.
-
-:end
diff --git a/cfg/avr.cfg b/cfg/avr.cfg
index 0efb2d5c75b..bb21afac352 100644
--- a/cfg/avr.cfg
+++ b/cfg/avr.cfg
@@ -3,8 +3,6 @@
 <def format="2">
   <!-- stdint.h -->
   <define name="__USING_MINT8" value="0"/>
-  <define name="__CONCATenate(left, right)" value="left ## right"/>
-  <define name="__CONCAT(left, right)" value="__CONCATenate(left, right)"/>
   <!-- Integer types capable of holding object pointers -->
   <podtype name="intptr_t" sign="s" size="2"/>
   <podtype name="uintptr_t" sign="u" size="2"/>
@@ -86,32 +84,8 @@
   <define name="SIG_ATOMIC_MAX" value="INT8_MAX"/>
   <define name="SIG_ATOMIC_MIN" value="INT8_MIN"/>
   <define name="SIZE_MAX" value="(__CONCAT(INT16_MAX, U))"/>
-  <!-- Macros for integer constants -->
-  <define name="INT8_C(value)" value="((int8_t) value)"/>
-  <define name="UINT8_C(value)" value="((uint8_t) __CONCAT(value, U))"/>
-  <define name="INT16_C(value)" value="value"/>
-  <define name="UINT16_C(value)" value="__CONCAT(value, U)"/>
-  <define name="INT32_C(value)" value="__CONCAT(value, L)"/>
-  <define name="UINT32_C(value)" value="__CONCAT(value, UL)"/>
-  <define name="INT64_C(value)" value="__CONCAT(value, LL)"/>
-  <define name="UINT64_C(value)" value="__CONCAT(value, ULL)"/>
-  <define name="INTMAX_C(value)" value="__CONCAT(value, LL)"/>
-  <define name="UINTMAX_C(value)" value="__CONCAT(value, ULL)"/>
   <!-- FIXME: add macros for printf and scanf format specifiers,e.g. PRId8 -->
   <!-- math.h -->
-  <define name="M_E" value="2.7182818284590452354"/>
-  <define name="M_LOG2E" value="1.4426950408889634074"/>
-  <define name="M_LOG10E" value="0.43429448190325182765"/>
-  <define name="M_LN2" value="0.69314718055994530942"/>
-  <define name="M_LN10" value="2.30258509299404568402"/>
-  <define name="M_PI" value="3.14159265358979323846"/>
-  <define name="M_PI_2" value="1.57079632679489661923"/>
-  <define name="M_PI_4" value="0.78539816339744830962"/>
-  <define name="M_1_PI" value="0.31830988618379067154"/>
-  <define name="M_2_PI" value="0.63661977236758134308"/>
-  <define name="M_2_SQRTPI" value="1.12837916709551257390"/>
-  <define name="M_SQRT2" value="1.41421356237309504880"/>
-  <define name="M_SQRT1_2" value="0.70710678118654752440"/>
   <define name="powf" value="pow"/>
   <define name="roundf" value="round"/>
   <define name="signbitf" value="signbit"/>
@@ -137,9 +111,6 @@
   <define name="putchar(__c)" value="fputc(__c, stdout)"/>
   <define name="getc(__stream)" value="fgetc(__stream)"/>
   <define name="getchar()" value="fgetc(stdin)"/>
-  <define name="SEEK_SET" value="0"/>
-  <define name="SEEK_CUR" value="1"/>
-  <define name="SEEK_END" value="2"/>
   <function name="vfprintf_P">
     <noreturn>false</noreturn>
     <leak-ignore/>
diff --git a/cfg/bento4.cfg b/cfg/bento4.cfg
new file mode 100644
index 00000000000..50f3cac00c9
--- /dev/null
+++ b/cfg/bento4.cfg
@@ -0,0 +1,142 @@
+<?xml version="1.0"?>
+<def format="2">
+  <define name="AP4_DEFINE_DYNAMIC_CAST_ANCHOR" value=""/>
+  <define name="AP4_IMPLEMENT_DYNAMIC_CAST_D" value=""/>
+  <define name="AP4_FAILED(C)" value="C"/>
+  <define name="AP4_ATOM_HEADER_SIZE_64" value="16"/>
+  <define name="AP4_ATOM_HEADER_SIZE" value="8"/>
+  <define name="AP4_ATOM_MAX_NAME_SIZE" value="256"/>
+  <define name="AP4_ATOM_MAX_URI_SIZE" value="512"/>
+  <define name="AP4_AVC_PROFILE_BASELINE" value="66"/>
+  <define name="AP4_AVC_PROFILE_EXTENDED" value="88"/>
+  <define name="AP4_AVC_PROFILE_HIGH_10" value="110"/>
+  <define name="AP4_AVC_PROFILE_HIGH_422" value="122"/>
+  <define name="AP4_AVC_PROFILE_HIGH_444" value="144"/>
+  <define name="AP4_AVC_PROFILE_HIGH" value="100"/>
+  <define name="AP4_AVC_PROFILE_MAIN" value="77"/>
+  <define name="AP4_CENC_CIPHER_AES_128_CBC" value="2"/>
+  <define name="AP4_CENC_CIPHER_AES_128_CTR" value="1"/>
+  <define name="AP4_CENC_CIPHER_NONE" value="0"/>
+  <define name="AP4_CENC_SAMPLE_ENCRYPTION_FLAG_OVERRIDE_TRACK_ENCRYPTION_DEFAULTS" value="1"/>
+  <define name="AP4_CENC_SAMPLE_ENCRYPTION_FLAG_USE_SUB_SAMPLE_ENCRYPTION" value="2"/>
+  <define name="AP4_COMMAND_TAG_ES_DESCRIPTOR_REMOVE_REF" value="0x07"/>
+  <define name="AP4_COMMAND_TAG_ES_DESCRIPTOR_REMOVE" value="0x04"/>
+  <define name="AP4_COMMAND_TAG_ES_DESCRIPTOR_UPDATE" value="0x03"/>
+  <define name="AP4_COMMAND_TAG_IPMP_DESCRIPTOR_REMOVE" value="0x06"/>
+  <define name="AP4_COMMAND_TAG_IPMP_DESCRIPTOR_UPDATE" value="0x05"/>
+  <define name="AP4_COMMAND_TAG_OBJECT_DESCRIPTOR_EXECUTE" value="0x08"/>
+  <define name="AP4_COMMAND_TAG_OBJECT_DESCRIPTOR_REMOVE" value="0x02"/>
+  <define name="AP4_COMMAND_TAG_OBJECT_DESCRIPTOR_UPDATE" value="0x01"/>
+  <define name="AP4_DESCRIPTOR_TAG_DECODER_CONFIG" value="0x04"/>
+  <define name="AP4_DESCRIPTOR_TAG_DECODER_SPECIFIC_INFO" value="0x05"/>
+  <define name="AP4_DESCRIPTOR_TAG_ES" value="0x03"/>
+  <define name="AP4_DESCRIPTOR_TAG_IOD" value="0x02"/>
+  <define name="AP4_DESCRIPTOR_TAG_MP4_IOD" value="0x10"/>
+  <define name="AP4_DESCRIPTOR_TAG_MP4_OD" value="0x11"/>
+  <define name="AP4_DESCRIPTOR_TAG_OD" value="0x01"/>
+  <define name="AP4_DESCRIPTOR_TAG_SL_CONFIG" value="0x06"/>
+  <define name="AP4_DV_PROFILE_DVAV_PEN" value="1"/>
+  <define name="AP4_DV_PROFILE_DVAV_PER" value="0"/>
+  <define name="AP4_DV_PROFILE_DVHE_DEN" value="3"/>
+  <define name="AP4_DV_PROFILE_DVHE_DER" value="2"/>
+  <define name="AP4_DV_PROFILE_DVHE_DTB" value="7"/>
+  <define name="AP4_DV_PROFILE_DVHE_DTH" value="6"/>
+  <define name="AP4_DV_PROFILE_DVHE_DTR" value="4"/>
+  <define name="AP4_DV_PROFILE_DVHE_STN" value="5"/>
+  <define name="AP4_FRAG_FLAG_SAMPLE_IS_DIFFERENCE" value="0x00010000"/>
+  <define name="AP4_FULL_ATOM_HEADER_SIZE_64" value="20"/>
+  <define name="AP4_FULL_ATOM_HEADER_SIZE" value="12"/>
+  <define name="AP4_HEVC_CHROMA_FORMAT_420" value="1"/>
+  <define name="AP4_HEVC_CHROMA_FORMAT_422" value="2"/>
+  <define name="AP4_HEVC_CHROMA_FORMAT_444" value="3"/>
+  <define name="AP4_HEVC_CHROMA_FORMAT_MONOCHROME" value="0"/>
+  <define name="AP4_HEVC_PROFILE_MAIN_10" value="2"/>
+  <define name="AP4_HEVC_PROFILE_MAIN_STILL_PICTURE" value="3"/>
+  <define name="AP4_HEVC_PROFILE_MAIN" value="1"/>
+  <define name="AP4_HEVC_PROFILE_REXT" value="4"/>
+  <define name="AP4_MDHD_DEFAULT_GENERIC_TIMESCALE" value="1000"/>
+  <define name="AP4_MDHD_DEFAULT_VIDEO_TIMESCALE" value="90000"/>
+  <define name="AP4_MPEG2_STREAM_TYPE_ATSC_AC3" value="0x81"/>
+  <define name="AP4_MPEG2_STREAM_TYPE_ATSC_EAC3" value="0x81"/>
+  <define name="AP4_MPEG2_STREAM_TYPE_HEVC" value="0x24"/>
+  <define name="AP4_MPEG2_STREAM_TYPE_ISO_IEC_13818_1_PES" value="0x06"/>
+  <define name="AP4_MPEG2_TS_DEFAULT_PID_AUDIO" value="0x101"/>
+  <define name="AP4_MPEG2_TS_DEFAULT_PID_PMT" value="0x100"/>
+  <define name="AP4_MPEG2_TS_DEFAULT_PID_VIDEO" value="0x102"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_AAC_LC" value="2"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_AAC_LTP" value="4"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_AAC_MAIN" value="1"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_AAC_SCALABLE" value="6"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_AAC_SSR" value="3"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_ALGORITHMIC_SYNTHESIS" value="16"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_ALS" value="36"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_CELP" value="8"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_DST" value="35"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_ER_AAC_ELD" value="39"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_ER_AAC_LC" value="17"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_ER_AAC_LD" value="23"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_ER_AAC_LTP" value="19"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_ER_AAC_SCALABLE" value="20"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_ER_BSAC" value="22"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_ER_CELP" value="24"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_ER_HILN" value="26"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_ER_HVXC" value="25"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_ER_PARAMETRIC" value="27"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_ER_TWINVQ" value="21"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_GENERAL_MIDI" value="15"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_HVXC" value="9"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_LAYER_1" value="32"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_LAYER_2" value="33"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_LAYER_3" value="34"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_MAIN_SYNTHETIC" value="13"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_MPEG_SURROUND" value="30"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_PS" value="29"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_SBR" value="5"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_SLS_NON_CORE" value="38"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_SLS" value="37"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_SMR_MAIN" value="41"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_SMR_SIMPLE" value="40"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_SSC" value="28"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_TTSI" value="12"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_TWINVQ" value="7"/>
+  <define name="AP4_MPEG4_AUDIO_OBJECT_TYPE_WAVETABLE_SYNTHESIS" value="14"/>
+  <define name="AP4_OMA_DCF_ENCRYPTION_METHOD_AES_CBC" value="1"/>
+  <define name="AP4_OMA_DCF_ENCRYPTION_METHOD_AES_CTR" value="2"/>
+  <define name="AP4_OMA_DCF_ENCRYPTION_METHOD_NULL" value="0"/>
+  <define name="AP4_OMA_DCF_PADDING_SCHEME_NONE" value="0"/>
+  <define name="AP4_OMA_DCF_PADDING_SCHEME_RFC_2630" value="1"/>
+  <define name="AP4_PROTECTION_SCHEME_VERSION_CENC_10" value="0x00010000"/>
+  <define name="AP4_PROTECTION_SCHEME_VERSION_OMA_20" value="0x00000200"/>
+  <define name="AP4_PROTECTION_SCHEME_VERSION_PIFF_10" value="0x00010000"/>
+  <define name="AP4_PROTECTION_SCHEME_VERSION_PIFF_11" value="0x00010001"/>
+  <define name="AP4_TFHD_FLAG_BASE_DATA_OFFSET_PRESENT" value="0x00001"/>
+  <define name="AP4_TFHD_FLAG_DEFAULT_BASE_IS_MOOF" value="0x20000"/>
+  <define name="AP4_TFHD_FLAG_DEFAULT_SAMPLE_DURATION_PRESENT" value="0x00008"/>
+  <define name="AP4_TFHD_FLAG_DEFAULT_SAMPLE_FLAGS_PRESENT" value="0x00020"/>
+  <define name="AP4_TFHD_FLAG_DEFAULT_SAMPLE_SIZE_PRESENT" value="0x00010"/>
+  <define name="AP4_TFHD_FLAG_DURATION_IS_EMPTY" value="0x10000"/>
+  <define name="AP4_TFHD_FLAG_SAMPLE_DESCRIPTION_INDEX_PRESENT" value="0x00002"/>
+  <define name="AP4_TRACK_DEFAULT_MOVIE_TIMESCALE" value="1000"/>
+  <define name="AP4_TRACK_FLAG_ENABLED" value="0x0001"/>
+  <define name="AP4_TRACK_FLAG_IN_MOVIE" value="0x0002"/>
+  <define name="AP4_TRACK_FLAG_IN_PREVIEW" value="0x0004"/>
+  <define name="AP4_TRUN_FLAG_DATA_OFFSET_PRESENT" value="0x0001"/>
+  <define name="AP4_TRUN_FLAG_FIRST_SAMPLE_FLAGS_PRESENT" value="0x0004"/>
+  <define name="AP4_TRUN_FLAG_SAMPLE_COMPOSITION_TIME_OFFSET_PRESENT" value="0x0800"/>
+  <define name="AP4_TRUN_FLAG_SAMPLE_DURATION_PRESENT" value="0x0100"/>
+  <define name="AP4_TRUN_FLAG_SAMPLE_FLAGS_PRESENT" value="0x0400"/>
+  <define name="AP4_TRUN_FLAG_SAMPLE_SIZE_PRESENT" value="0x0200"/>
+  <podtype name="AP4_UI08" sign="u" size="1"/>
+  <podtype name="AP4_UI16" sign="u" size="2"/>
+  <podtype name="AP4_UI32" sign="u" size="4"/>
+  <podtype name="AP4_Result" sign="s" size="4"/>
+  <function name="BitWriter::Write">
+    <noreturn>false</noreturn>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+  </function>
+</def>
diff --git a/cfg/boost.cfg b/cfg/boost.cfg
index d5ca13684c1..d181860f0bc 100644
--- a/cfg/boost.cfg
+++ b/cfg/boost.cfg
@@ -11,27 +11,55 @@
   <define name="BOOST_CLASS_VERSION(class,version)" value=""/>
   <define name="BOOST_TYPEOF_REGISTER_TYPE(x)" value=""/>
   <define name="BOOST_TYPEOF_REGISTER_TEMPLATE(x, params)" value=""/>
+  <define name="BOOST_PP_LIST_FOR_EACH(macro, data, list)" value=""/>
+  <define name="BOOST_PP_SEQ_FOR_EACH(macro, data, list)" value=""/>
+  <define name="BOOST_PP_SEQ_TRANSFORM(macro, data, list)" value=""/>
+  <define name="BOOST_PP_CAT(a, b)" value=""/>
+  <define name="BOOST_PP_REPEAT(a,b,c)" value=""/>
+  <define name="BOOST_PP_STRINGIZE(t)" value=""/>
+  <!-- https://www.boost.org/doc/libs/master/doc/html/foreach.html -->
+  <define name="BOOST_FOREACH(A,B)" value="for (A: B)"/>
   <!-- https://www.boost.org/doc/libs/master/libs/config/doc/html/boost_config/boost_macro_reference.html -->
   <define name="BOOST_FORCEINLINE" value="inline"/>
   <define name="BOOST_NOINLINE" value=""/>
   <define name="BOOST_NORETURN" value="[[noreturn]]"/>
+  <define name="BOOST_THROW_EXCEPTION(X)" value="boost::throw_exception(X)"/>
   <define name="BOOST_LIKELY(X)" value="(X)"/>
   <define name="BOOST_UNLIKELY(X)" value="(X)"/>
-  <define name="BOOST_FIXTURE_TEST_SUITE(...)" value=""/>
-  <define name="BOOST_FIXTURE_TEST_SUITE_END()" value=""/>
-  <define name="BOOST_TEST_GLOBAL_FIXTURE(name)" value=""/>
+  <define name="BOOST_FIXTURE_TEST_SUITE(name, fixture, ...)" value="struct name : fixture {" />
+  <define name="BOOST_FIXTURE_TEST_SUITE_END()" value="};"/>
   <define name="BOOST_PYTHON_FUNCTION_OVERLOADS(foo_overloads, foo, x, y)" value=""/>
-  <define name="BOOST_AUTO_TEST_SUITE(...)" value=""/>
-  <define name="BOOST_AUTO_TEST_SUITE_END()" value=""/>
+  <define name="BOOST_AUTO_TEST_SUITE(name, ...)" value="namespace name {" />
+  <define name="BOOST_AUTO_TEST_SUITE_END()" value="}" />
   <define name="BOOST_ASSERT(condition)" value="assert(condition)"/>
-  <define name="BOOST_TEST(condition)" value="assert(condition)"/>
-  <define name="BOOST_WARN(condition)" value="assert(condition)"/>
-  <define name="BOOST_CHECK(condition)" value="assert(condition)"/>
-  <define name="BOOST_REQUIRE(condition)" value="assert(condition)"/>
-  <define name="BOOST_CHECK_EQUAL(a,b)" value="assert((a) == (b))"/>
-  <define name="BOOST_WARN_EQUAL(a,b)" value="assert((a) == (b))"/>
-  <define name="BOOST_REQUIRE_EQUAL(a,b)" value="assert((a) == (b))"/>
+  <define name="BOOST_TEST(condition, ...)" value="static_cast&lt;void&gt;(static_cast&lt;bool&gt;(condition))" />
+  <define name="BOOST_TEST_REQUIRE(condition, ...)" value='do { if (!(condition)) { throw false; }} while(0)' />
+  <define name="BOOST_WARN(condition)" value="static_cast&lt;void&gt;(static_cast&lt;bool&gt;(condition))" />
+  <define name="BOOST_WARN_MESSAGE(condition, msg)" value="static_cast&lt;void&gt;(static_cast&lt;bool&gt;(condition)); static_cast&lt;void&gt;(msg)" />
+  <define name="BOOST_WARN_EQUAL(a, b)" value="static_cast&lt;void&gt;((a) == (b))" />
+  <define name="BOOST_WARN_NE(a, b)" value="static_cast&lt;void&gt;((a) != (b))" />
+  <define name="BOOST_WARN_GT(a, b)" value="static_cast&lt;void&gt;((a) &gt; (b))" />
+  <define name="BOOST_WARN_GE(a, b)" value="static_cast&lt;void&gt;((a) &gt;= (b))" />
+  <define name="BOOST_WARN_LT(a, b)" value="static_cast&lt;void&gt;((a) &lt; (b))" />
+  <define name="BOOST_WARN_LE(a, b)" value="static_cast&lt;void&gt;((a) &lt;= (b))" />
+  <define name="BOOST_CHECK(condition)" value="static_cast&lt;void&gt;(static_cast&lt;bool&gt;(condition))" />
+  <define name="BOOST_CHECK_MESSAGE(condition, msg)" value="static_cast&lt;void&gt;(static_cast&lt;bool&gt;(condition)); static_cast&lt;void&gt;(msg)" />
+  <define name="BOOST_CHECK_EQUAL(a, b)" value="static_cast&lt;void&gt;((a) == (b))" />
+  <define name="BOOST_CHECK_NE(a, b)" value="static_cast&lt;void&gt;((a) != (b))" />
+  <define name="BOOST_CHECK_GT(a, b)" value="static_cast&lt;void&gt;((a) &gt; (b))" />
+  <define name="BOOST_CHECK_GE(a, b)" value="static_cast&lt;void&gt;((a) &gt;= (b))" />
+  <define name="BOOST_CHECK_LT(a, b)" value="static_cast&lt;void&gt;((a) &lt; (b))" />
+  <define name="BOOST_CHECK_LE(a, b)" value="static_cast&lt;void&gt;((a) &lt;= (b))" />
+  <define name="BOOST_REQUIRE(condition)" value='do { if (!(condition)) { throw false; }} while(0)' />
+  <define name="BOOST_REQUIRE_MESSAGE(condition, msg)" value='do { if (!(condition)) { throw false; }} while(0); static_cast&lt;void&gt;(msg)' />
+  <define name="BOOST_REQUIRE_EQUAL(a, b)" value="static_cast&lt;void&gt;(static_cast&lt;bool&gt;((a) == (b)))" />
+  <define name="BOOST_REQUIRE_NE(a, b)" value="static_cast&lt;void&gt;((a) != (b))" />
+  <define name="BOOST_REQUIRE_GT(a, b)" value="static_cast&lt;void&gt;((a) &gt; (b))" />
+  <define name="BOOST_REQUIRE_GE(a, b)" value="static_cast&lt;void&gt;((a) &gt;= (b))" />
+  <define name="BOOST_REQUIRE_LT(a, b)" value="static_cast&lt;void&gt;((a) &lt; (b))" />
+  <define name="BOOST_REQUIRE_LE(a, b)" value="static_cast&lt;void&gt;((a) &lt;= (b))" />
   <define name="BOOST_LOG_ATTRIBUTE_KEYWORD(keyword, name_, value_type_)" value="value_type_ keyword;"/>
+  <define name="BOOST_TEST_DONT_PRINT_LOG_VALUE(the_type)" value="" />
   <!--Boost.Math Macros -->
   <define name="BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS" value=""/>
   <define name="BOOST_MATH_USE_FLOAT128" value=""/>
@@ -56,31 +84,47 @@
   <define name="BOOST_MATH_INT_VALUE_SUFFIX" value=""/>
   <!-- Tell cppcheck to interpret BOOST_AUTO_TEST_CASE as a function definition -->
   <define name="BOOST_AUTO_TEST_CASE(...)" value="void BOOST_AUTO_TEST_CASE_run(__VA_ARGS__)"/>
-  <define name="BOOST_FIXTURE_TEST_CASE(...)" value="void BOOST_FIXTURE_TEST_CASE_run(__VA_ARGS__)"/>
+  <define name="BOOST_AUTO_TEST_CASE_TEMPLATE(test_name, type_name, TL)" value="template&lt;typename type_name&gt;void test_name()"/>
+  <define name="BOOST_FIXTURE_TEST_CASE(name, fixture, ...)" value="struct name : fixture { void test_method(); }; void name::test_method()" />
+  <define name="BOOST_FIXTURE_TEST_CASE_TEMPLATE(test_name, type_name, TL, F)" value="template&lt;typename type_name&gt; struct test_name : public F { void test_method(); }; template&lt;typename type_name&gt; void test_name&lt;type_name&gt;::test_method()" />
+  <define name="BOOST_DATA_TEST_CASE(...)" value="void BOOST_DATA_TEST_CASE_run(__VA_ARGS__)"/>
+  <define name="BOOST_DATA_TEST_CASE_F(...)" value="void BOOST_DATA_TEST_CASE_F_run(__VA_ARGS__)"/>
   <define name="BOOST_PYTHON_MODULE(str)" value="void BOOST_PYTHON_MODULE_definition(str)"/>
+  <define name="BOOST_SCOPED_ENUM_DECLARE_BEGIN(x)" value=""/>
+  <define name="BOOST_SCOPED_ENUM_DECLARE_END(x)" value=""/>
+  <define name="BOOST_TTI_HAS_TYPE(x)" value=""/>
+  <define name="BOOST_TTI_MEMBER_TYPE(x)" value=""/>
+  <define name="BOOST_TTI_HAS_STATIC_MEMBER_FUNCTION(x)" value=""/>
   <!-- ########## Boost containers ########## -->
   <!-- boost containers that are similar to std containers -->
-  <container id="boostArray" startPattern="boost :: array|scoped_array &lt;" inherits="stdArray"/>
+  <container id="boostArray" startPattern="boost :: array &lt;" inherits="stdArray"/>
   <container id="boostCircularBuffer" startPattern="boost :: circular_buffer &lt;" inherits="stdContainer"/>
   <container id="boostList" startPattern="boost :: list|slist &lt;" inherits="stdList"/>
   <container id="boostMultiMap" startPattern="boost :: flat_multimap|multimap|unordered_multimap &lt;" inherits="stdMultiMap"/>
   <container id="boostMultiSet" startPattern="boost :: flat_multiset|multiset &lt;" inherits="stdMultiSet"/>
   <container id="boostMap" startPattern="boost :: map|flat_map|unordered_map &lt;" inherits="stdMap"/>
   <container id="boostSet" startPattern="boost :: set|flat_set|unordered_set &lt;" inherits="stdSet"/>
-  <container id="boostVectorDeque" startPattern="boost :: deque|vector|small_vector|stable_vector|static_vector &lt;" inherits="stdVectorDeque"/>
+  <container id="boostVector" startPattern="boost :: vector|small_vector &lt;" inherits="stdVector"/>
+  <container id="boostStableVector" startPattern="boost :: stable_vector|static_vector &lt;" inherits="stdVectorDeque"/>
+  <container id="boostDeque" startPattern="boost :: deque &lt;" inherits="stdDeque"/>
+  <container id="boostStringView" startPattern="boost :: string_view" inherits="stdStringView"/>
   <!-- ########## Boost smart pointers ########## -->
   <!-- https://www.boost.org/doc/libs/1_70_0/libs/smart_ptr/doc/html/smart_ptr.html -->
-  <smart-pointer class-name="boost::scoped_ptr"/>
-  <!-- <smart-pointer class-name="boost::scoped_array"/> Already configured as container -->
+  <smart-pointer class-name="boost::scoped_ptr">
+    <unique/>
+  </smart-pointer>
+  <smart-pointer class-name="boost::scoped_array"/>
   <smart-pointer class-name="boost::shared_ptr"/>
   <smart-pointer class-name="boost::weak_ptr"/>
   <smart-pointer class-name="boost::intrusive_ptr"/>
   <smart-pointer class-name="boost::local_shared_ptr"/>
   <!-- https://www.boost.org/doc/libs/1_70_0/doc/html/boost/movelib/unique_ptr.html -->
-  <smart-pointer class-name="boost::movelib::unique_ptr"/>
+  <smart-pointer class-name="boost::movelib::unique_ptr">
+    <unique/>
+  </smart-pointer>
   <!-- ########## Boost functions ########## -->
   <!-- https://www.boost.org/doc/libs/1_69_0/doc/html/boost/algorithm/join.html -->
-  <!-- template<typename SequenceSequenceT, typename Range1T> 
+  <!-- template<typename SequenceSequenceT, typename Range1T>
        range_value< SequenceSequenceT >::type join(const SequenceSequenceT & Input, const Range1T & Separator); -->
   <function name="boost::algorithm::join">
     <noreturn>false</noreturn>
@@ -756,6 +800,63 @@
       <not-bool/>
     </arg>
   </function>
+  <!-- std::time_t last_write_time(const path& p); -->
+  <!-- std::time_t last_write_time(const path& p, system::error_code& ec); -->
+  <function name="boost::filesystem::last_write_time">
+    <noreturn>false</noreturn>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="time_t"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" default="0" direction="out">
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void permissions(const path& p, perms prms); -->
+  <!-- void permissions(const path& p, perms prms, system::error_code& ec); -->
+  <function name="boost::filesystem::permissions">
+    <noreturn>false</noreturn>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" default="0" direction="out">
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- path read_symlink(const path& p); -->
+  <!-- path read_symlink(const path& p, system::error_code& ec); -->
+  <function name="boost::filesystem::read_symlink">
+    <noreturn>false</noreturn>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="path"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" default="0" direction="out">
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- path relative(const path& p, system::error_code& ec); -->
+  <!-- path relative(const path& p, const path& base=current_path());          -->
+  <!-- path relative(const path& p, const path& base, system::error_code& ec); -->
+  <function name="boost::filesystem::relative">
+    <noreturn>false</noreturn>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="path"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- bool equivalent(const path& p1, const path& p2); -->
   <!-- bool equivalent(const path& p1, const path& p2, system::error_code& ec); -->
   <function name="boost::filesystem::equivalent">
@@ -775,6 +876,35 @@
       <not-bool/>
     </arg>
   </function>
+  <!-- uintmax_t file_size(const path& p); -->
+  <!-- uintmax_t file_size(const path& p, system::error_code& ec); -->
+  <!-- uintmax_t hard_link_count(const path& p); -->
+  <!-- uintmax_t hard_link_count(const path& p, system::error_code& ec); -->
+  <function name="boost::filesystem::file_size,boost::filesystem::hard_link_count">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="uintmax_t"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" default="0" direction="out">
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const path& initial_path(); -->
+  <!-- const path& initial_path(system::error_code& ec); -->
+  <function name="boost::filesystem::initial_path">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="const path &amp;"/>
+    <arg nr="1" default="0" direction="out">
+      <not-bool/>
+    </arg>
+  </function>
   <!-- boost::filesystem actions -->
   <!-- bool remove(const path& p); -->
   <!-- bool remove(const path& p, system::error_code& ec); -->
@@ -806,6 +936,174 @@
       <not-bool/>
     </arg>
   </function>
+  <!-- void rename(const path& old_p, const path& new_p); -->
+  <!-- void rename(const path& old_p, const path& new_p, system::error_code& ec); -->
+  <function name="boost::filesystem::rename">
+    <noreturn>false</noreturn>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" default="0" direction="out">
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void resize_file(const path& p, uintmax_t new_size); -->
+  <!-- void resize_file(const path& p, uintmax_t new_size, system::error_code& ec); -->
+  <function name="boost::filesystem::resize_file">
+    <noreturn>false</noreturn>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" default="0" direction="out">
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- space_info space(const path& p); -->
+  <!-- space_info space(const path& p, system::error_code& ec); -->
+  <function name="boost::filesystem::space">
+    <noreturn>false</noreturn>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="space_info"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" default="0" direction="out">
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- file_status status(const path& p); -->
+  <!-- file_status status(const path& p, system::error_code& ec) noexcept; -->
+  <function name="boost::filesystem::status">
+    <noreturn>false</noreturn>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="file_status"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" default="0" direction="out">
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool status_known(file_status s) noexcept; -->
+  <function name="boost::filesystem::status_known">
+    <noreturn>false</noreturn>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- file_status symlink_status(const path& p); -->
+  <!-- file_status symlink_status(const path& p, system::error_code& ec) noexcept; -->
+  <function name="boost::filesystem::symlink_status">
+    <noreturn>false</noreturn>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="file_status"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" default="0" direction="out">
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- path system_complete(const path& p); -->
+  <!-- path system_complete(const path& p, system::error_code& ec); -->
+  <function name="boost::filesystem::system_complete">
+    <noreturn>false</noreturn>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="path"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" default="0" direction="out">
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- path temp_directory_path(); -->
+  <!-- path temp_directory_path(system::error_code& ec); -->
+  <function name="boost::filesystem::temp_directory_path">
+    <noreturn>false</noreturn>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="path"/>
+    <arg nr="1" default="0" direction="out">
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- path unique_path(const path& model="%%%%-%%%%-%%%%-%%%%"); -->
+  <!-- path unique_path(const path& model, system::error_code& ec); -->
+  <function name="boost::filesystem::unique_path">
+    <noreturn>false</noreturn>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="path"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" default="0" direction="out">
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- path weakly_canonical(const path& p); -->
+  <!-- path weakly_canonical(const path& p, system::error_code& ec); -->
+  <function name="boost::filesystem::weakly_canonical">
+    <noreturn>false</noreturn>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="path"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" default="0" direction="out">
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- path absolute(const path& p, const path& base=current_path()); -->
+  <function name="boost::filesystem::absolute">
+    <noreturn>false</noreturn>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="path"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" default="current_path()" direction="in">
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- path canonical(const path& p, const path& base = current_path()); -->
+  <!-- path canonical(const path& p, system::error_code& ec); -->
+  <!-- path canonical(const path& p, const path& base, system::error_code& ec); -->
+  <function name="boost::filesystem::canonical">
+    <noreturn>false</noreturn>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="path"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- void copy(const path& from, const path& to); -->
   <!-- void copy(const path& from, const path& to, system::error_code& ec); -->
   <!-- void copy_directory(const path& from, const path& to); -->
@@ -964,4 +1262,23 @@
       <not-bool/>
     </arg>
   </function>
+  <function name="boost::throw_exception">
+    <noreturn>true</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <type-checks>
+    <unusedvar>
+      <checkFiniteLifetime>boost::lock_guard</checkFiniteLifetime>
+      <checkFiniteLifetime>boost::mutex::scoped_lock</checkFiniteLifetime>
+      <checkFiniteLifetime>boost::recursive_mutex::scoped_lock</checkFiniteLifetime>
+      <checkFiniteLifetime>boost::unique_lock</checkFiniteLifetime>
+      <checkFiniteLifetime>boost::shared_lock</checkFiniteLifetime>
+    </unusedvar>
+    <operatorEqVarError>
+      <suppress>boost::mutex</suppress>
+      <suppress>boost::recursive_mutex</suppress>
+    </operatorEqVarError>
+  </type-checks>
 </def>
diff --git a/cfg/bsd.cfg b/cfg/bsd.cfg
index f4502f2cc65..158d7a8a885 100644
--- a/cfg/bsd.cfg
+++ b/cfg/bsd.cfg
@@ -181,6 +181,7 @@
     <returnValue type="size_t"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="3"/>
     <arg nr="1">
       <not-null/>
       <not-uninit/>
@@ -203,6 +204,7 @@
     <returnValue type="size_t"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="3"/>
     <arg nr="1">
       <minsize type="argvalue" arg="3"/>
     </arg>
@@ -216,6 +218,176 @@
       <valid>0:</valid>
     </arg>
   </function>
+  <!-- https://linux.die.net/man/3/setbuffer -->
+  <!-- void setbuffer(FILE *stream, char *buf, size_t size); -->
+  <function name="setbuffer">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- https://linux.die.net/man/3/setbuffer -->
+  <!-- void setlinebuf(FILE *stream); -->
+  <function name="setlinebuf">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- https://linux.die.net/man/2/writev -->
+  <!-- ssize_t readv(int fd, const struct iovec *iov, int iovcnt); -->
+  <function name="readv">
+    <leak-ignore/>
+    <returnValue type="ssize_t"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- https://linux.die.net/man/2/writev -->
+  <!-- ssize_t writev(int fd, const struct iovec *iov, int iovcnt); -->
+  <function name="writev">
+    <leak-ignore/>
+    <returnValue type="ssize_t"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- https://linux.die.net/man/2/writev -->
+  <!-- ssize_t preadv(int fd, const struct iovec *iov, int iovcnt, off_t offset); -->
+  <function name="preadv">
+    <leak-ignore/>
+    <returnValue type="ssize_t"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- https://linux.die.net/man/2/writev -->
+  <!-- ssize_t preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags); -->
+  <function name="preadv2">
+    <leak-ignore/>
+    <returnValue type="ssize_t"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- https://linux.die.net/man/2/writev -->
+  <!-- ssize_t pwritev(int fd, const struct iovec *iov, int iovcnt, off_t offset); -->
+  <function name="pwritev">
+    <leak-ignore/>
+    <returnValue type="ssize_t"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- https://linux.die.net/man/2/writev -->
+  <!-- ssize_t pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags); -->
+  <function name="pwritev2">
+    <leak-ignore/>
+    <returnValue type="ssize_t"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- https://www.freebsd.org/cgi/man.cgi?query=arc4random -->
   <!-- uint32_t arc4random(void); -->
   <function name="arc4random">
@@ -228,7 +400,7 @@
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
-    <arg nr="1">
+    <arg nr="1" direction="out">
       <not-null/>
       <minsize type="argvalue" arg="2"/>
     </arg>
@@ -263,6 +435,133 @@
       <valid>0:</valid>
     </arg>
   </function>
+  <!-- https://www.freebsd.org/cgi/man.cgi?query=mmap -->
+  <!-- void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset); -->
+  <!-- In contrast to POSIX, the BSD mmap requires fd to be -1 if MAP_ANONYMOUS or MAP_ANON is specified -->
+  <function name="mmap">
+    <use-retval/>
+    <returnValue type="void *"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <valid>1:</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <valid>-1:</valid>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <function name="err,errx">
+    <noreturn>true</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <formatstr/>
+    <arg nr="2" direction="in">
+      <formatstr/>
+      <strz/>
+      <not-uninit/>
+    </arg>
+  </function>
+  <function name="errc">
+    <noreturn>true</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <formatstr/>
+    <arg nr="3" direction="in">
+      <formatstr/>
+      <strz/>
+      <not-uninit/>
+    </arg>
+  </function>
+  <function name="verr,verrx">
+    <noreturn>true</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <strz/>
+      <not-uninit/>
+    </arg>
+    <arg nr="3"/>
+  </function>
+  <function name="verrc">
+    <noreturn>true</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <formatstr/>
+    <arg nr="3" direction="in">
+      <strz/>
+      <not-uninit/>
+    </arg>
+    <arg nr="4"/>
+  </function>
+  <!-- void *reallocarray(void *ptr, size_t nmemb, size_t size); -->
+  <function name="reallocarray">
+    <returnValue type="void *"/>
+    <use-retval/>
+    <noreturn>false</noreturn>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <memory>
+    <realloc init="false" buffer-size="calloc:2,3">reallocarray</realloc>
+    <dealloc>free</dealloc>
+  </memory>
   <podtype name="FTS"/>
   <podtype name="FTSENT"/>
+  <!-- This type definitions refer to https://mandoc.bsd.lv/includes/sys/types.h.html -->
+  <podtype name="u_char" sign="u" stdtype="char"/>
+  <podtype name="u_short" sign="u" stdtype="short"/>
+  <podtype name="u_int" sign="u" stdtype="int"/>
+  <podtype name="u_long" sign="u" stdtype="long"/>
+  <!-- Sys V compatibility types -->
+  <podtype name="unchar" sign="u" stdtype="char"/>
+  <podtype name="ushort" sign="u" stdtype="short"/>
+  <podtype name="uint" sign="u" stdtype="int"/>
+  <podtype name="ulong" sign="u" stdtype="long"/>
+  <!-- https://linux.die.net/man/3/tailq_head -->
+  <define name="TAILQ_HEAD(name,type)" value="struct name { type *first; type *last; }"/>
+  <!-- https://man7.org/linux/man-pages/man2/lseek.2.html :
+       Conforming to:
+       SEEK_DATA and SEEK_HOLE are nonstandard extensions also present
+       in Solaris, FreeBSD, and DragonFly BSD; they are proposed for
+       inclusion in the next POSIX revision (Issue 8).-->
+  <define name="SEEK_DATA" value="3"/>
+  <define name="SEEK_HOLE" value="4"/>
+  <!-- Old BSD names for the same constants; just for compatibility. -->
+  <define name="L_INCR" value="SEEK_CUR"/>
+  <define name="L_SET" value="SEEK_SET"/>
+  <define name="L_XTND" value="SEEK_END"/>
 </def>
diff --git a/cfg/cairo.cfg b/cfg/cairo.cfg
index 85c2a8e0946..d766abffc2e 100644
--- a/cfg/cairo.cfg
+++ b/cfg/cairo.cfg
@@ -6,6 +6,7 @@
   <define name="cairo_bool_t" value="int"/>
   <!-- TODO: Configure cairo_status_t as an enum when this is implemented in Cppcheck -->
   <podtype name="cairo_status_t"/>
+  <define name="CAIRO_STATUS_READ_ERROR" value="10"/>
   <!-- ########## cairo Macros / Defines ########## -->
   <define name="CAIRO_HAS_MIME_SURFACE" value="1"/>
   <define name="CAIRO_MIME_TYPE_CCITT_FAX" value="&quot;image/g3fax&quot;"/>
@@ -20,6 +21,7 @@
   <define name="CAIRO_MIME_TYPE_PNG" value="&quot;image/png&quot;"/>
   <define name="CAIRO_MIME_TYPE_URI" value="&quot;text/x-uri&quot;"/>
   <define name="CAIRO_MIME_TYPE_UNIQUE_ID" value="&quot;application/x-cairo.uuid&quot;"/>
+  <define name="CAIRO_VERSION_ENCODE(major, minor, micro)" value="(((major) * 10000) + ((minor) * 100) + ((micro) * 1))"/>
   <!-- ########## cairo Allocation / Deallocation ########## -->
   <!-- ########## cairo Functions ########## -->
   <!-- cairo_t * cairo_create (cairo_surface_t *target); -->
diff --git a/cfg/cppcheck-cfg.rng b/cfg/cppcheck-cfg.rng
index fd269c63e20..a54c967aaac 100644
--- a/cfg/cppcheck-cfg.rng
+++ b/cfg/cppcheck-cfg.rng
@@ -1,576 +1,751 @@
-<?xml version="1.0"?>
-<grammar xmlns="http://relaxng.org/ns/structure/1.0" datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes">
-<start>
-<element name="def">
-  <optional>
-    <attribute name="format">
-      <value>2</value>
-    </attribute>
-  </optional>
-  <zeroOrMore>
-    <choice>
-      <element name="define">
-        <attribute name="name"><text/></attribute>
-        <attribute name="value"><text/></attribute>
-      </element>
-
-      <element name="memory">
-        <zeroOrMore>
-          <choice>
-            <element name="dealloc">
-              <optional>
-                <attribute name="arg">
-                  <ref name="ARGNO"/>
-                </attribute>
-              </optional>
-              <ref name="DATA-EXTNAME"/>
-            </element>
-            <element name="alloc">
-              <optional>
-                <attribute name="init"><ref name="DATA-BOOL"/></attribute>
-              </optional>
-              <optional>
-                <attribute name="arg"><ref name="ARGNO"/></attribute>
-              </optional>
-              <optional>
-                <attribute name="buffer-size"><ref name="DATA-BUFFER-SIZE"/></attribute>
-              </optional>
-              <ref name="DATA-NAME"/>
-            </element>
-            <element name="realloc">
-              <optional>
-                <attribute name="init"><ref name="DATA-BOOL"/></attribute>
-              </optional>
-              <optional>
-                <attribute name="arg"><ref name="ARGNO"/></attribute>
-              </optional>
-              <optional>
-                <attribute name="buffer-size"><ref name="DATA-BUFFER-SIZE"/></attribute>
-              </optional>
-              <optional>
-                <attribute name="realloc-arg"><ref name="ARGNO"/></attribute>
-              </optional>
-              <ref name="DATA-NAME"/>
-            </element>
-            <element name="use"><ref name="DATA-EXTNAME"/></element>
-          </choice>
-        </zeroOrMore>
-      </element>
-
-      <element name="resource">
-        <zeroOrMore>
-          <choice>
-            <element name="dealloc">
-              <optional>
-                <attribute name="arg">
-                  <ref name="ARGNO"/>
-                </attribute>
-              </optional>
-              <ref name="DATA-EXTNAME"/>
-            </element>
-            <element name="alloc">
-              <optional>
-                <attribute name="init"><ref name="DATA-BOOL"/></attribute>
-              </optional>
-              <optional>
-                <attribute name="arg"><ref name="ARGNO"/></attribute>
-              </optional>
-              <ref name="DATA-NAME"/>
-            </element>
-            <element name="realloc">
-              <optional>
-                <attribute name="init"><ref name="DATA-BOOL"/></attribute>
-              </optional>
-              <optional>
-                <attribute name="arg"><ref name="ARGNO"/></attribute>
-              </optional>
-              <optional>
-                <attribute name="realloc-arg"><ref name="ARGNO"/></attribute>
-              </optional>
-              <ref name="DATA-NAME"/>
-            </element>
-            <element name="use"><ref name="DATA-EXTNAME"/></element>
-          </choice>
-        </zeroOrMore>
-      </element>
-
-      <element name="function">
-        <attribute name="name">
-          <ref name="DATA-EXTNAME"/>
-        </attribute>
-
-        <interleave>
-          <optional>
-            <element name="noreturn"><ref name="DATA-BOOL"/></element>
-          </optional>
-          <optional>
-            <element name="pure"><empty/></element>
-          </optional>
-          <optional>
-            <element name="const"><empty/></element>
-          </optional>
-          <optional>
-            <element name="ignorefunction"><ref name="DATA-BOOL"/></element>
-          </optional>
-          <optional>
-            <element name="leak-ignore"><empty/></element>
-          </optional>
-          <optional>
-            <element name="use-retval"><empty/></element>
-          </optional>
-          <optional>
-            <element name="returnValue">
-              <optional>
-                <attribute name="type">
-                  <data type="string">
-                    <param name="pattern">([a-zA-Z_][a-zA-Z_0-9]*[ ])*([a-zA-Z_][a-zA-Z_0-9]*::)*[a-zA-Z_][a-zA-Z_0-9]*([ ]?[*&amp;])*</param>
-                  </data>
-                </attribute>
-              </optional>
-              <optional>
-                <attribute name="container">
-                  <data type="positiveInteger"/>
-                </attribute>
-              </optional>
-              <optional>
-                <attribute name="unknownValues">
-                  <data type="string">
-                    <param name="pattern">all|([0-9]*:[0-9]*)</param>
-                  </data>
-                </attribute>
-              </optional>
-              <text/>
-            </element>
-          </optional>
-          <optional>
-            <element name="formatstr">
-              <optional>
-                <attribute name="scan"><ref name="DATA-BOOL"/></attribute>
-              </optional>
-              <optional>
-                <attribute name="secure"><ref name="DATA-BOOL"/></attribute>
-              </optional>
-              <empty/>
-            </element>
-          </optional>
-          <optional>
-            <element name="warn">
-              <attribute name="severity">
-                <choice>
-                  <value>error</value>
-                  <value>warning</value>
-                  <value>style</value>
-                  <value>performance</value>
-                  <value>portability</value>
-                  <value>information</value>
-                </choice>
-              </attribute>
-              <optional>
-                <attribute name="reason">
-                  <choice>
-                    <value>Obsolescent</value>
-                    <value>Obsolete</value>
-                  </choice>
-                </attribute>
-              </optional>
-              <optional>
-                <attribute name="alternatives">
-                  <ref name="DATA-EXTNAME"/>
-                </attribute>
-              </optional>
-              <optional>
-                <attribute name="cstd">
-                  <value>c99</value>
-                </attribute>
-              </optional>
-              <text/>
-            </element>
-          </optional>
-          <zeroOrMore>
-            <element name="arg">
-              <attribute name="nr">
-                <choice>
-                  <ref name="ARGNO"/>
-                  <value>any</value>
-                  <value>variadic</value>
-                </choice>
-              </attribute>
-              <optional>
-                <attribute name="default">
-                  <text/>
-                </attribute>
-              </optional>
-              <optional>
-                <attribute name="direction">
-                  <ref name="ARG-DIRECTION"/>
-                </attribute>
-              </optional>
-
-              <interleave>
-                <optional>
-                  <element name="formatstr"><empty/></element>
-                </optional>
-                <optional>
-                  <element name="strz"><empty/></element>
-                </optional>
-                <optional>
-                  <element name="not-bool"><empty/></element>
-                </optional>
-                <optional>
-                  <element name="not-null"><empty/></element>
-                </optional>
-                <optional>
-                  <element name="not-uninit"><empty/></element>
-                </optional>
-                <optional>
-                  <element name="valid">
-                    <data type="string">
-                      <param name="pattern">(-?[0-9]*(\.[0-9]+)?[,:])*([-]?[0-9]+(\.[0-9]+)?)?</param>
-                    </data>
-                  </element>
-                </optional>
-                <zeroOrMore>
-                  <choice>
-                    <element name="minsize">
-                      <attribute name="type">
-                        <choice>
-                          <value>strlen</value>
-                          <value>argvalue</value>
-                          <value>sizeof</value>
-                          <value>mul</value>
-                        </choice>
-                      </attribute>
-                      <attribute name="arg">
-                        <ref name="ARGNO"/>
-                      </attribute>
-                      <optional>
-                        <attribute name="arg2">
-                          <ref name="ARGNO"/>
-                        </attribute>
-                      </optional>
-                    </element>
-                    <element name="minsize">
-                      <attribute name="type">
-                        <choice>
-                          <value>value</value>
-                        </choice>
-                      </attribute>
-                      <attribute name="value">
-                        <ref name="MINSIZE-VALUE"/>
-                      </attribute>
-                    </element>
-                  </choice>
-                </zeroOrMore>
-                <optional>
-                  <element name="iterator">
-                    <attribute name="container">
-                      <data type="positiveInteger"/>
-                    </attribute>
-                    <attribute name="type">
-                      <choice>
-                        <value>first</value>
-                        <value>middle</value>
-                        <value>last</value>
-                      </choice>
-                    </attribute>
-                  </element>
-                </optional>
-              </interleave>
-            </element>
-          </zeroOrMore>
-        </interleave>
-      </element>
-
-      <element name="markup">
-        <attribute name="ext">
-          <data type="string">
-            <param name="pattern">[.][a-z]+</param>
-          </data>
-        </attribute>
-        <attribute name="aftercode"><ref name="DATA-BOOL"/></attribute>
-        <attribute name="reporterrors"><ref name="DATA-BOOL"/></attribute>
-
-        <optional>
-          <element name="keywords">
-            <zeroOrMore>
-              <element name="keyword">
-                <attribute name="name"><ref name="DATA-NAME"/></attribute>
-              </element>
-            </zeroOrMore>
-          </element>
-        </optional>
-
-        <zeroOrMore>
-          <element name="codeblocks">
-            <zeroOrMore>
-              <element name="block">
-                <attribute name="name"><ref name="DATA-NAME"/></attribute>
-              </element>
-            </zeroOrMore>
-            <optional>
-              <element name="structure">
-                <attribute name="offset"><data type="integer"/></attribute>
-                <attribute name="start"><text/></attribute>
-                <attribute name="end"><text/></attribute>
-              </element>
-            </optional>
-          </element>
-        </zeroOrMore>
-
-        <optional>
-          <element name="exported">
-            <zeroOrMore>
-              <element name="exporter">
-                <attribute name="prefix"><ref name="DATA-NAME"/></attribute>
-                <zeroOrMore>
-                  <choice>
-                    <element name="prefix"><ref name="DATA-NAME"/></element>
-                    <element name="suffix"><ref name="DATA-NAME"/></element>
-                  </choice>
-                </zeroOrMore>
-              </element>
-            </zeroOrMore>
-          </element>
-        </optional>
-
-        <optional>
-          <element name="imported">
-            <zeroOrMore>
-              <element name="importer"><ref name="DATA-NAME"/></element>
-            </zeroOrMore>
-          </element>
-        </optional>
-      </element>
-
-      <element name="reflection">
-        <zeroOrMore>
-          <element name="call">
-            <attribute name="arg"><ref name="ARGNO"/></attribute>
-            <ref name="DATA-NAME"/>
-          </element>
-        </zeroOrMore>
-      </element>
-
-      <element name="container">
-        <attribute name="id"><text/></attribute>
-        <optional>
-          <attribute name="endPattern"><text/></attribute>
-        </optional>
-        <optional>
-          <attribute name="startPattern"><text/></attribute>
-        </optional>
-        <optional>
-          <attribute name="inherits"><text/></attribute>
-        </optional>
-        <optional>
-          <attribute name="opLessAllowed"><ref name="DATA-BOOL"/></attribute>
-        </optional>
-        <optional>
-          <attribute name="itEndPattern"><text/></attribute>
-        </optional>
-        <zeroOrMore>
-          <choice>
-            <element name="type">
-              <optional>
-                <attribute name="templateParameter"><data type="integer"/></attribute>
-              </optional>
-              <optional>
-                <attribute name="string">
-                  <value>std-like</value>
-                </attribute>
-              </optional>
-              <optional>
-                <attribute name="associative">
-                  <value>std-like</value>
-                </attribute>
-              </optional>
-              <empty/>
-            </element>
-            <element name="size">
-              <optional>
-                <attribute name="templateParameter"><data type="integer"/></attribute>
-              </optional>
-              <zeroOrMore>
-                <element name="function">
-                  <attribute name="name"><ref name="DATA-NAME"/></attribute>
-                  <optional>
-                    <attribute name="action">
-                      <ref name="CONTAINER-ACTION"/>
-                    </attribute>
-                  </optional>
-                  <optional>
-                    <attribute name="yields">
-                      <ref name="CONTAINER-YIELDS"/>
-                    </attribute>
-                  </optional>
-                  <empty/>
-                </element>
-              </zeroOrMore>
-            </element>
-            <element name="access">
-              <optional>
-                <attribute name="indexOperator">
-                  <value>array-like</value>
-                </attribute>
-              </optional>
-              <zeroOrMore>
-                <element name="function">
-                  <attribute name="name">
-                    <ref name="DATA-EXTNAME"/>
-                  </attribute>
-                  <optional>
-                    <attribute name="action">
-                      <ref name="CONTAINER-ACTION"/>
-                    </attribute>
-                  </optional>
-                  <optional>
-                    <attribute name="yields">
-                      <ref name="CONTAINER-YIELDS"/>
-                    </attribute>
-                  </optional>
-                  <empty/>
-                </element>
-              </zeroOrMore>
-            </element>
-          </choice>
-        </zeroOrMore>
-      </element>
-
-      <element name="smart-pointer">
-        <attribute name="class-name"><ref name="DATA-EXTNAME"/></attribute>
-      </element>
-
-      <element name="podtype">
-        <attribute name="name"><ref name="DATA-EXTNAME"/></attribute>
-        <optional>
-          <attribute name="stdtype">
-            <choice>
-              <value>bool</value>
-              <value>char</value>
-              <value>short</value>
-              <value>int</value>
-              <value>long</value>
-              <value>long long</value>
-            </choice>
-          </attribute>
-        </optional>
-        <optional>
-          <attribute name="size">
-            <choice>
-              <value>1</value>
-              <value>2</value>
-              <value>4</value>
-              <value>8</value>
-            </choice>
-          </attribute>
-        </optional>
-        <optional>
-          <attribute name="sign">
-            <choice>
-              <value>s</value>
-              <value>u</value>
-            </choice>
-          </attribute>
-        </optional>
-        <empty/>
-      </element>
-
-      <element name="platformtype">
-        <attribute name="name"><ref name="DATA-EXTNAME"/></attribute>
-        <attribute name="value"><ref name="DATA-NAME"/></attribute>
-        <oneOrMore>
-          <choice>
-            <element name="unsigned"><empty/></element>
-            <element name="long"><empty/></element>
-            <element name="pointer"><empty/></element>
-            <element name="const_ptr"><empty/></element>
-            <element name="ptr_ptr"><empty/></element>
-            <element name="platform">
-              <attribute name="type"><ref name="DATA-NAME"/></attribute>
-              <empty/>
-            </element>
-          </choice>
-        </oneOrMore>
-      </element>
-
-    </choice>
-  </zeroOrMore>
-</element>
-</start>
-
-  <define name="ARGNO">
-    <data type="integer">
-      <param name="minInclusive">1</param>
-      <param name="maxInclusive">20</param>
-    </data>
-  </define>
-  
-  <define name="ARG-DIRECTION">
-    <choice>
-      <value>in</value>
-      <value>out</value>
-      <value>inout</value>
-    </choice>
-  </define>
-
-  <define name="DATA-BOOL">
-    <choice>
-      <value>true</value>
-      <value>false</value>
-    </choice>
-  </define>
-
-  <define name="DATA-NAME">
-    <data type="string">
-      <param name="pattern">[a-zA-Z_][a-zA-Z_0-9]*</param>
-    </data>
-  </define>
-
-  <define name="DATA-EXTNAME">
-    <data type="string">
-      <param name="pattern">[a-zA-Z_][a-zA-Z_0-9:,]*</param>
-    </data>
-  </define>
-
-  <define name="DATA-BUFFER-SIZE">
-    <data type="string">
-      <param name="pattern">malloc(:[1-5])?|calloc(:[1-5],[1-5])?|strdup(:[1-5])?</param>
-    </data>
-  </define>
-
-  <define name="CONTAINER-ACTION">
-    <choice>
-      <value>resize</value>
-      <value>clear</value>
-      <value>push</value>
-      <value>pop</value>
-      <value>find</value>
-      <value>insert</value>
-      <value>erase</value>
-      <value>change-content</value>
-      <value>change-internal</value>
-      <value>change</value>
-    </choice>
-  </define>
-
-  <define name="CONTAINER-YIELDS">
-    <choice>
-      <value>at_index</value>
-      <value>item</value>
-      <value>buffer</value>
-      <value>buffer-nt</value>
-      <value>start-iterator</value>
-      <value>end-iterator</value>
-      <value>iterator</value>
-      <value>size</value>
-      <value>empty</value>
-    </choice>
-  </define>
-  
-  <define name="MINSIZE-VALUE">
-    <data type="unsignedLong">
-      <param name="minInclusive">1</param>
-      <param name="maxInclusive">9223372036854775807</param>
-    </data>
-  </define>
-</grammar>
+<?xml version="1.0"?>
+<grammar xmlns="http://relaxng.org/ns/structure/1.0" datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes">
+<start>
+<element name="def">
+  <optional>
+    <attribute name="format">
+      <value>2</value>
+    </attribute>
+  </optional>
+  <zeroOrMore>
+    <choice>
+      <element name="define">
+        <attribute name="name"><text/></attribute>
+        <attribute name="value"><text/></attribute>
+      </element>
+
+      <element name="memory">
+        <zeroOrMore>
+          <choice>
+            <element name="dealloc">
+              <optional>
+                <attribute name="arg">
+                  <ref name="ARGNO"/>
+                </attribute>
+              </optional>
+              <ref name="DATA-EXTNAME"/>
+            </element>
+            <element name="alloc">
+              <optional>
+                <attribute name="no-fail"><ref name="DATA-BOOL"/></attribute>
+              </optional>
+              <optional>
+                <attribute name="init"><ref name="DATA-BOOL"/></attribute>
+              </optional>
+              <optional>
+                <attribute name="arg"><ref name="ARGNO"/></attribute>
+              </optional>
+              <optional>
+                <attribute name="buffer-size"><ref name="DATA-BUFFER-SIZE"/></attribute>
+              </optional>
+              <ref name="DATA-EXTNAME"/>
+            </element>
+            <element name="realloc">
+              <optional>
+                <attribute name="no-fail"><ref name="DATA-BOOL"/></attribute>
+              </optional>
+              <optional>
+                <attribute name="init"><ref name="DATA-BOOL"/></attribute>
+              </optional>
+              <optional>
+                <attribute name="arg"><ref name="ARGNO"/></attribute>
+              </optional>
+              <optional>
+                <attribute name="buffer-size"><ref name="DATA-BUFFER-SIZE"/></attribute>
+              </optional>
+              <optional>
+                <attribute name="realloc-arg"><ref name="ARGNO"/></attribute>
+              </optional>
+              <ref name="DATA-EXTNAME"/>
+            </element>
+            <element name="use"><ref name="DATA-EXTNAME"/></element>
+          </choice>
+        </zeroOrMore>
+      </element>
+
+      <element name="resource">
+        <zeroOrMore>
+          <choice>
+            <element name="dealloc">
+              <optional>
+                <attribute name="arg">
+                  <ref name="ARGNO"/>
+                </attribute>
+              </optional>
+              <ref name="DATA-EXTNAME"/>
+            </element>
+            <element name="alloc">
+              <optional>
+                <attribute name="no-fail"><ref name="DATA-BOOL"/></attribute>
+              </optional>
+              <optional>
+                <attribute name="init"><ref name="DATA-BOOL"/></attribute>
+              </optional>
+              <optional>
+                <attribute name="arg"><ref name="ARGNO"/></attribute>
+              </optional>
+              <ref name="DATA-EXTNAME"/>
+            </element>
+            <element name="realloc">
+              <optional>
+                <attribute name="no-fail"><ref name="DATA-BOOL"/></attribute>
+              </optional>
+              <optional>
+                <attribute name="init"><ref name="DATA-BOOL"/></attribute>
+              </optional>
+              <optional>
+                <attribute name="arg"><ref name="ARGNO"/></attribute>
+              </optional>
+              <optional>
+                <attribute name="realloc-arg"><ref name="ARGNO"/></attribute>
+              </optional>
+              <ref name="DATA-EXTNAME"/>
+            </element>
+            <element name="use"><ref name="DATA-EXTNAME"/></element>
+          </choice>
+        </zeroOrMore>
+      </element>
+
+      <element name="function">
+        <attribute name="name">
+          <ref name="DATA-EXTNAME"/>
+        </attribute>
+
+        <interleave>
+          <optional>
+            <element name="noreturn">
+              <choice>
+                <value>true</value>
+                <value>false</value>
+                <value>maybe</value>
+              </choice>
+            </element>
+          </optional>
+          <optional>
+            <element name="container">
+              <optional>
+                <attribute name="action">
+                  <ref name="CONTAINER-ACTION"/>
+                </attribute>
+              </optional>
+              <optional>
+                <attribute name="yields">
+                  <ref name="CONTAINER-YIELDS"/>
+                </attribute>
+              </optional>
+              <empty/>
+            </element>
+          </optional>
+          <optional>
+            <element name="pure"><empty/></element>
+          </optional>
+          <optional>
+            <element name="const"><empty/></element>
+          </optional>
+          <optional>
+            <element name="ignorefunction"><ref name="DATA-BOOL"/></element>
+          </optional>
+          <optional>
+            <element name="leak-ignore"><empty/></element>
+          </optional>
+          <optional>
+            <element name="use-retval"><empty/>
+              <optional>
+                <attribute name="type">
+                    <value>error-code</value>
+                </attribute>
+              </optional>
+            </element>
+          </optional>
+          <optional>
+            <element name="returnValue">
+              <optional>
+                <attribute name="type">
+                  <data type="string">
+                    <param name="pattern">(::)?([a-zA-Z_:][a-zA-Z_0-9:]*[ ])*([a-zA-Z_][a-zA-Z_0-9]*::)*([a-zA-Z_][a-zA-Z_0-9]*([ ]?[*&amp; ])*)+</param>
+                  </data>
+                </attribute>
+              </optional>
+              <optional>
+                <attribute name="container">
+                  <data type="positiveInteger"/>
+                </attribute>
+              </optional>
+              <optional>
+                <attribute name="unknownValues">
+                  <data type="string">
+                    <param name="pattern">all|([0-9]*:[0-9]*)</param>
+                  </data>
+                </attribute>
+              </optional>
+              <text/>
+            </element>
+          </optional>
+          <optional>
+            <element name="formatstr">
+              <optional>
+                <attribute name="scan"><ref name="DATA-BOOL"/></attribute>
+              </optional>
+              <optional>
+                <attribute name="secure"><ref name="DATA-BOOL"/></attribute>
+              </optional>
+              <empty/>
+            </element>
+          </optional>
+          <optional>
+            <element name="not-overlapping-data">
+              <optional>
+                <attribute name="ptr1-arg"><data type="positiveInteger"/></attribute>
+              </optional>
+              <optional>
+                <attribute name="ptr2-arg"><data type="positiveInteger"/></attribute>
+              </optional>
+              <optional>
+                <attribute name="size-arg"><data type="positiveInteger"/></attribute>
+              </optional>
+              <optional>
+                <attribute name="strlen-arg"><data type="positiveInteger"/></attribute>
+              </optional>
+              <optional>
+                <attribute name="count-arg"><data type="positiveInteger"/></attribute>
+              </optional>
+              <empty/>
+            </element>
+          </optional>
+          <optional>
+            <element name="warn">
+              <attribute name="severity">
+                <choice>
+                  <value>error</value>
+                  <value>warning</value>
+                  <value>style</value>
+                  <value>performance</value>
+                  <value>portability</value>
+                  <value>information</value>
+                </choice>
+              </attribute>
+              <optional>
+                <attribute name="reason">
+                  <choice>
+                    <value>Obsolescent</value>
+                    <value>Obsolete</value>
+                  </choice>
+                </attribute>
+              </optional>
+              <optional>
+                <attribute name="alternatives">
+                  <ref name="DATA-EXTNAME"/>
+                </attribute>
+              </optional>
+              <optional>
+                <attribute name="cstd">
+                  <value>c99</value>
+                </attribute>
+              </optional>
+              <text/>
+            </element>
+          </optional>
+          <zeroOrMore>
+            <element name="arg">
+              <attribute name="nr">
+                <choice>
+                  <ref name="ARGNO"/>
+                  <value>any</value>
+                  <value>variadic</value>
+                </choice>
+              </attribute>
+              <optional>
+                <attribute name="default">
+                  <text/>
+                </attribute>
+              </optional>
+              <optional>
+                <attribute name="direction">
+                  <ref name="ARG-DIRECTION"/>
+                </attribute>
+              </optional>
+              <optional>
+                <attribute name="indirect">
+                  <ref name="INDIRECT"/>
+                </attribute>
+              </optional>
+
+              <interleave>
+                <optional>
+                  <element name="formatstr"><empty/></element>
+                </optional>
+                <optional>
+                  <element name="strz"><empty/></element>
+                </optional>
+                <optional>
+                  <element name="not-bool"><empty/></element>
+                </optional>
+                <optional>
+                  <element name="not-null"><empty/></element>
+                </optional>
+                <optional>
+                  <element name="not-uninit">
+                    <optional>
+                      <attribute name="indirect"><ref name="INDIRECT"/></attribute>
+                    </optional>
+                  </element>
+                </optional>
+                <optional>
+                  <element name="valid">
+                    <data type="string"> <!-- regex test: https://regex101.com/r/LoRGVj/2/ -->
+                      <param name="pattern">([-!]?[0-9]*(\.[0-9]+)?([eE][-+]?[0-9]+)?[,:])*([-!]?[0-9]+(\.[0-9]+)?([eE][-+]?[0-9]+)?)?</param>
+                    </data>
+                  </element>
+                </optional>
+                <zeroOrMore>
+                  <choice>
+                    <element name="minsize">
+                      <attribute name="type">
+                        <choice>
+                          <value>strlen</value>
+                          <value>sizeof</value>
+                          <value>mul</value>
+                        </choice>
+                      </attribute>
+                      <attribute name="arg">
+                        <ref name="ARGNO"/>
+                      </attribute>
+                      <optional>
+                        <attribute name="arg2">
+                          <ref name="ARGNO"/>
+                        </attribute>
+                      </optional>
+                    </element>
+                    <element name="minsize">
+                      <attribute name="type">
+                        <choice>
+                          <value>value</value>
+                        </choice>
+                      </attribute>
+                      <attribute name="value">
+                        <ref name="MINSIZE-VALUE"/>
+                      </attribute>
+                      <optional>
+                        <attribute name="baseType"><text/></attribute>
+                      </optional>
+                    </element>
+                    <element name="minsize">
+                      <attribute name="type">
+                        <choice>
+                          <value>argvalue</value>
+                        </choice>
+                      </attribute>
+                      <attribute name="arg">
+                        <ref name="ARGNO"/>
+                      </attribute>
+                      <optional>
+                        <attribute name="arg2">
+                          <ref name="ARGNO"/>
+                        </attribute>
+                      </optional>
+                      <optional>
+                        <attribute name="baseType"><text/></attribute>
+                      </optional>
+                    </element>
+                  </choice>
+                </zeroOrMore>
+                <optional>
+                  <element name="iterator">
+                    <attribute name="container">
+                      <data type="positiveInteger"/>
+                    </attribute>
+                    <attribute name="type">
+                      <choice>
+                        <value>first</value>
+                        <value>middle</value>
+                        <value>last</value>
+                      </choice>
+                    </attribute>
+                  </element>
+                </optional>
+              </interleave>
+            </element>
+          </zeroOrMore>
+        </interleave>
+      </element>
+
+      <element name="markup">
+        <attribute name="ext">
+          <data type="string">
+            <param name="pattern">[.][a-z]+</param>
+          </data>
+        </attribute>
+        <attribute name="aftercode"><ref name="DATA-BOOL"/></attribute>
+        <attribute name="reporterrors"><ref name="DATA-BOOL"/></attribute>
+
+        <optional>
+          <element name="keywords">
+            <zeroOrMore>
+              <element name="keyword">
+                <attribute name="name"><ref name="DATA-NAME"/></attribute>
+              </element>
+            </zeroOrMore>
+          </element>
+        </optional>
+
+        <zeroOrMore>
+          <element name="codeblocks">
+            <zeroOrMore>
+              <element name="block">
+                <attribute name="name"><ref name="DATA-NAME"/></attribute>
+              </element>
+            </zeroOrMore>
+            <optional>
+              <element name="structure">
+                <attribute name="offset"><data type="integer"/></attribute>
+                <attribute name="start"><text/></attribute>
+                <attribute name="end"><text/></attribute>
+              </element>
+            </optional>
+          </element>
+        </zeroOrMore>
+
+        <optional>
+          <element name="exported">
+            <zeroOrMore>
+              <element name="exporter">
+                <attribute name="prefix"><ref name="DATA-NAME"/></attribute>
+                <zeroOrMore>
+                  <choice>
+                    <element name="prefix"><ref name="DATA-NAME"/></element>
+                    <element name="suffix"><ref name="DATA-NAME"/></element>
+                  </choice>
+                </zeroOrMore>
+              </element>
+            </zeroOrMore>
+          </element>
+        </optional>
+
+        <optional>
+          <element name="imported">
+            <zeroOrMore>
+              <element name="importer"><ref name="DATA-NAME"/></element>
+            </zeroOrMore>
+          </element>
+        </optional>
+      </element>
+
+      <element name="reflection">
+        <zeroOrMore>
+          <element name="call">
+            <attribute name="arg"><ref name="ARGNO"/></attribute>
+            <ref name="DATA-NAME"/>
+          </element>
+        </zeroOrMore>
+      </element>
+
+      <element name="container">
+        <attribute name="id"><text/></attribute>
+        <optional>
+          <attribute name="endPattern"><text/></attribute>
+        </optional>
+        <optional>
+          <attribute name="startPattern"><text/></attribute>
+        </optional>
+        <optional>
+          <attribute name="inherits"><text/></attribute>
+        </optional>
+        <optional>
+          <attribute name="opLessAllowed"><ref name="DATA-BOOL"/></attribute>
+        </optional>
+        <optional>
+          <attribute name="hasInitializerListConstructor"><ref name="DATA-BOOL"/></attribute>
+        </optional>
+        <optional>
+          <attribute name="view"><ref name="DATA-BOOL"/></attribute>
+        </optional>
+        <optional>
+          <attribute name="itEndPattern"><text/></attribute>
+        </optional>
+        <zeroOrMore>
+          <choice>
+            <element name="type">
+              <optional>
+                <attribute name="templateParameter"><data type="integer"/></attribute>
+              </optional>
+              <optional>
+                <attribute name="string">
+                  <value>std-like</value>
+                </attribute>
+              </optional>
+              <optional>
+                <attribute name="associative">
+                  <value>std-like</value>
+                </attribute>
+              </optional>
+              <optional>
+                <attribute name="unstable">
+                  <list>
+                    <oneOrMore>
+                      <data type="string"/>
+                      <choice>
+                        <value>erase</value>
+                        <value>insert</value>
+                      </choice>
+                    </oneOrMore>
+                  </list>
+                </attribute>
+              </optional>
+              <empty/>
+            </element>
+            <element name="rangeItemRecordType">
+              <oneOrMore>
+                <element name="member">
+                  <attribute name="name"><ref name="DATA-NAME"/></attribute>
+                  <attribute name="templateParameter"><data type="integer"/></attribute>
+                </element>
+              </oneOrMore>
+            </element>
+            <element name="size">
+              <optional>
+                <attribute name="templateParameter"><data type="integer"/></attribute>
+              </optional>
+              <zeroOrMore>
+                <element name="function">
+                  <attribute name="name"><ref name="DATA-NAME"/></attribute>
+                  <optional>
+                    <attribute name="action">
+                      <ref name="CONTAINER-ACTION"/>
+                    </attribute>
+                  </optional>
+                  <optional>
+                    <attribute name="yields">
+                      <ref name="CONTAINER-YIELDS"/>
+                    </attribute>
+                  </optional>
+                  <optional>
+                    <attribute name="returnType">
+                      <data type="string"/>
+                    </attribute>
+                  </optional>
+                  <empty/>
+                </element>
+              </zeroOrMore>
+            </element>
+            <element name="access">
+              <optional>
+                <attribute name="indexOperator">
+                  <value>array-like</value>
+                </attribute>
+              </optional>
+              <zeroOrMore>
+                <element name="function">
+                  <attribute name="name">
+                    <ref name="DATA-EXTNAME"/>
+                  </attribute>
+                  <optional>
+                    <attribute name="action">
+                      <ref name="CONTAINER-ACTION"/>
+                    </attribute>
+                  </optional>
+                  <optional>
+                    <attribute name="yields">
+                      <ref name="CONTAINER-YIELDS"/>
+                    </attribute>
+                  </optional>
+                  <empty/>
+                </element>
+              </zeroOrMore>
+            </element>
+          </choice>
+        </zeroOrMore>
+      </element>
+
+      <element name="smart-pointer">
+        <attribute name="class-name"><ref name="DATA-EXTNAME"/></attribute>
+        <optional>
+          <element name="unique">
+            <empty/>
+          </element>
+        </optional>
+      </element>
+
+      <element name="type-checks">
+        <optional>
+          <element name="unusedvar">
+            <zeroOrMore>
+              <choice>
+                <element name="check">
+                  <ref name="DATA-EXTNAME"/>
+                </element>
+                <element name="suppress">
+                  <ref name="DATA-EXTNAME"/>
+                </element>
+                <element name="checkFiniteLifetime">
+                  <ref name="DATA-EXTNAME"/>
+                </element>
+              </choice>
+            </zeroOrMore>
+          </element>
+          <element name="operatorEqVarError">
+            <zeroOrMore>
+              <choice>
+                <element name="check">
+                  <ref name="DATA-EXTNAME"/>
+                </element>
+                <element name="suppress">
+                  <ref name="DATA-EXTNAME"/>
+                </element>
+              </choice>
+            </zeroOrMore>
+          </element>
+        </optional>
+      </element>
+
+      <element name="podtype">
+        <attribute name="name"><ref name="DATA-EXTNAME"/></attribute>
+        <optional>
+          <attribute name="stdtype">
+            <choice>
+              <value>bool</value>
+              <value>char</value>
+              <value>short</value>
+              <value>int</value>
+              <value>long</value>
+              <value>long long</value>
+            </choice>
+          </attribute>
+        </optional>
+        <optional>
+          <attribute name="size">
+            <choice>
+              <value>1</value>
+              <value>2</value>
+              <value>4</value>
+              <value>8</value>
+            </choice>
+          </attribute>
+        </optional>
+        <optional>
+          <attribute name="sign">
+            <choice>
+              <value>s</value>
+              <value>u</value>
+            </choice>
+          </attribute>
+        </optional>
+        <empty/>
+      </element>
+
+      <element name="platformtype">
+        <attribute name="name"><ref name="DATA-EXTNAME"/></attribute>
+        <attribute name="value"><ref name="DATA-NAME"/></attribute>
+        <oneOrMore>
+          <choice>
+            <element name="unsigned"><empty/></element>
+            <element name="long"><empty/></element>
+            <element name="pointer"><empty/></element>
+            <element name="const_ptr"><empty/></element>
+            <element name="ptr_ptr"><empty/></element>
+            <element name="platform">
+              <attribute name="type"><ref name="DATA-NAME"/></attribute>
+              <empty/>
+            </element>
+          </choice>
+        </oneOrMore>
+      </element>
+
+      <element name="entrypoint">
+        <attribute name="name"><text/></attribute>
+      </element>
+    </choice>
+  </zeroOrMore>
+</element>
+</start>
+
+  <define name="ARGNO">
+    <data type="integer">
+      <param name="minInclusive">1</param>
+      <param name="maxInclusive">40</param>
+    </data>
+  </define>
+
+  <define name="INDIRECT">
+    <data type="integer">
+      <param name="minInclusive">0</param>
+      <param name="maxInclusive">2</param>
+    </data>
+  </define>
+
+  <define name="ARG-DIRECTION">
+    <choice>
+      <value>in</value>
+      <value>out</value>
+      <value>inout</value>
+    </choice>
+  </define>
+
+  <define name="DATA-BOOL">
+    <choice>
+      <value>true</value>
+      <value>false</value>
+    </choice>
+  </define>
+
+  <define name="DATA-NAME">
+    <data type="string">
+      <param name="pattern">[a-zA-Z_][a-zA-Z_0-9]*</param>
+    </data>
+  </define>
+
+  <define name="DATA-EXTNAME-SINGLE">
+    <data type="string">
+      <param name="pattern">[a-zA-Z_][a-zA-Z_0-9:]*</param>
+    </data>
+  </define>
+
+  <define name="DATA-EXTNAME">
+    <data type="string">
+      <param name="pattern">[a-zA-Z_][a-zA-Z_0-9:,]*</param>
+    </data>
+  </define>
+
+  <define name="DATA-BUFFER-SIZE">
+    <data type="string">
+      <param name="pattern">malloc(:[1-5])?|calloc(:[1-5],[1-5])?|strdup(:[1-5])?</param>
+    </data>
+  </define>
+
+  <define name="CONTAINER-ACTION">
+    <choice>
+      <value>resize</value>
+      <value>clear</value>
+      <value>push</value>
+      <value>pop</value>
+      <value>find</value>
+      <value>find-const</value>
+      <value>insert</value>
+      <value>erase</value>
+      <value>append</value>
+      <value>change-content</value>
+      <value>change-internal</value>
+      <value>change</value>
+    </choice>
+  </define>
+
+  <define name="CONTAINER-YIELDS">
+    <choice>
+      <value>at_index</value>
+      <value>item</value>
+      <value>buffer</value>
+      <value>buffer-nt</value>
+      <value>start-iterator</value>
+      <value>end-iterator</value>
+      <value>iterator</value>
+      <value>size</value>
+      <value>empty</value>
+    </choice>
+  </define>
+
+  <define name="MINSIZE-VALUE">
+    <data type="unsignedLong">
+      <param name="minInclusive">1</param>
+      <param name="maxInclusive">9223372036854775807</param>
+    </data>
+  </define>
+</grammar>
diff --git a/cfg/cppunit.cfg b/cfg/cppunit.cfg
index 8db767f2048..1caf400db19 100644
--- a/cfg/cppunit.cfg
+++ b/cfg/cppunit.cfg
@@ -5,13 +5,13 @@
   <define name="CPPUNIT_TEST(test)" value=""/>
   <define name="CPPUNIT_TEST_SUITE_END()" value=""/>
   <!-- Macros see http://cppunit.sourceforge.net/doc/cvs/group___assertions.html  -->
-  <define name="CPPUNIT_ASSERT(condition)" value=""/>
-  <define name="CPPUNIT_ASSERT_MESSAGE(message, condition)" value=""/>
-  <define name="CPPUNIT_FAIL(message)" value=""/>
-  <define name="CPPUNIT_ASSERT_EQUAL(expected, actual)" value=""/>
-  <define name="CPPUNIT_ASSERT_EQUAL_MESSAGE(message, expected, actual)" value=""/>
-  <define name="CPPUNIT_ASSERT_DOUBLES_EQUAL(expected, actual, delta)" value=""/>
-  <define name="CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE(message, expected, actual, delta)" value=""/>
+  <define name="CPPUNIT_ASSERT(condition)" value="{if (!(condition)) throw false;}"/>
+  <define name="CPPUNIT_ASSERT_MESSAGE(message, condition)" value="{if (!(condition)) throw message;}"/>
+  <define name="CPPUNIT_FAIL(message)" value="throw message;"/>
+  <define name="CPPUNIT_ASSERT_EQUAL(expected, actual)" value="{if ((expected) != (actual)) throw false;}"/>
+  <define name="CPPUNIT_ASSERT_EQUAL_MESSAGE(message, expected, actual)" value="{if ((expected) != (actual)) throw message;}"/>
+  <define name="CPPUNIT_ASSERT_DOUBLES_EQUAL(expected, actual, delta)" value="{if (std::abs((expected) - (actual)) &gt; delta) throw false;}"/>
+  <define name="CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE(message, expected, actual, delta)" value="{if (std::abs((expected) - (actual)) &gt; delta) throw message;}"/>
   <define name="CPPUNIT_ASSERT_THROW(expression, ExceptionType)" value=""/>
   <define name="CPPUNIT_ASSERT_THROW_MESSAGE(message, expression, ExceptionType)" value=""/>
   <define name="CPPUNIT_ASSERT_NO_THROW(expression)" value=""/>
diff --git a/cfg/daca.cfg b/cfg/daca.cfg
deleted file mode 100644
index b2c21d66494..00000000000
--- a/cfg/daca.cfg
+++ /dev/null
@@ -1,31 +0,0 @@
-<?xml version="1.0"?>
-<def format="2">
-  <!-- This configuration is used in daca@home and contains some common practice macros and functions which are helpful for daca analysis. -->
-  <!-- see gnu.cfg -->
-  <define name="ASSERT(expr)" value="assert (expr)"/>
-  <define name="BE(expr, val)" value="__builtin_expect (expr, val)"/>
-  <function name="MIN">
-    <use-retval/>
-    <noreturn>false</noreturn>
-    <leak-ignore/>
-    <returnValue>arg1&lt;arg2?arg1:arg2</returnValue>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
-    </arg>
-  </function>
-  <function name="MAX">
-    <use-retval/>
-    <noreturn>false</noreturn>
-    <leak-ignore/>
-    <returnValue>arg1&gt;arg2?arg1:arg2</returnValue>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
-    </arg>
-  </function>
-</def>
diff --git a/cfg/dpdk.cfg b/cfg/dpdk.cfg
new file mode 100644
index 00000000000..32ef8bcad4b
--- /dev/null
+++ b/cfg/dpdk.cfg
@@ -0,0 +1,11 @@
+<?xml version="1.0"?>
+<def format="2">
+  <function name="rte_panic">
+    <noreturn>true</noreturn>
+    <formatstr/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <formatstr/>
+    </arg>
+  </function>
+</def>
diff --git a/cfg/emscripten.cfg b/cfg/emscripten.cfg
new file mode 100644
index 00000000000..7a5c5903cf5
--- /dev/null
+++ b/cfg/emscripten.cfg
@@ -0,0 +1,108 @@
+<?xml version="1.0"?>
+<def format="2">
+  <function name="emscripten_asm_const_int">
+    <arg nr="1" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="variadic" direction="in" />
+    <use-retval/>
+    <returnValue type="int" unknownValues="all"/>
+    <noreturn>false</noreturn>
+  </function>
+  <function name="emscripten_asm_const_double">
+    <arg nr="1" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="variadic" direction="in" />
+    <use-retval/>
+    <returnValue type="double" unknownValues="all"/>
+    <noreturn>false</noreturn>
+  </function>
+  <function name="emscripten_asm_const_ptr">
+    <arg nr="1" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="variadic" direction="in" />
+    <use-retval/>
+    <returnValue type="void*" unknownValues="all"/>
+    <noreturn>false</noreturn>
+  </function>
+  <function name="emscripten_asm_const_async_on_main_thread">
+    <arg nr="1" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="variadic" direction="in" />
+    <returnValue type="void" unknownValues="all"/>
+    <noreturn>false</noreturn>
+  </function>
+  <function name="emscripten_asm_const_int_sync_on_main_thread">
+    <arg nr="1" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="variadic" direction="in" />
+    <use-retval/>
+    <returnValue type="int" unknownValues="all"/>
+    <noreturn>false</noreturn>
+  </function>
+  <function name="emscripten_asm_const_double_sync_on_main_thread">
+    <arg nr="1" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="variadic" direction="in" />
+    <use-retval/>
+    <returnValue type="int" unknownValues="all"/>
+    <noreturn>false</noreturn>
+  </function>
+  <function name="emscripten_asm_const_ptr_sync_on_main_thread">
+    <arg nr="1" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="variadic" direction="in" />
+    <use-retval/>
+    <returnValue type="void*" unknownValues="all"/>
+    <noreturn>false</noreturn>
+  </function>
+  <resource>
+    <alloc init="true">emscripten_asm_const_ptr</alloc>
+    <alloc init="true">emscripten_asm_const_ptr_sync_on_main_thread</alloc>
+    <dealloc>free</dealloc>
+  </resource>
+
+  <!-- macros from em_asm.h -->
+  <define name="EM_ASM(code, ...)" value="((void)emscripten_asm_const_int(#code, __VA_ARGS__))"/>
+  <define name="EM_ASM_DOUBLE(code, ...)" value="emscripten_asm_const_double(#code, __VA_ARGS__)"/>
+  <define name="EM_ASM_INT(code, ...)" value="emscripten_asm_const_int(#code, __VA_ARGS__)"/>
+  <define name="EM_ASM_PTR(code, ...)" value="emscripten_asm_const_ptr(#code, __VA_ARGS__)"/>
+  <define name="MAIN_THREAD_ASYNC_EM_ASM(code, ...)" value="emscripten_asm_const_async_on_main_thread(#code, __VA_ARGS__)"/>
+  <define name="MAIN_THREAD_EM_ASM(code, ...)" value="((void)emscripten_asm_const_int_sync_on_main_thread(#code, __VA_ARGS__))"/>
+  <define name="MAIN_THREAD_EM_ASM_DOUBLE(code, ...)" value="emscripten_asm_const_double_sync_on_main_thread(#code, __VA_ARGS__)"/>
+  <define name="MAIN_THREAD_EM_ASM_INT(code, ...)" value="emscripten_asm_const_int_sync_on_main_thread(#code, __VA_ARGS__)"/>
+  <define name="MAIN_THREAD_EM_ASM_PTR(code, ...)" value="emscripten_asm_const_ptr_sync_on_main_thread(#code, __VA_ARGS__)"/>
+
+  <!-- macros from bind.h -->
+  <define name="EMSCRIPTEN_BINDINGS(name)" value=""/>
+
+  <!-- macros from em_js.h -->
+  <define name="EM_JS(return_type, function_name, arguments, code)" value="return_type function_name(arguments)"/>
+</def>
diff --git a/cfg/ginac.cfg b/cfg/ginac.cfg
new file mode 100644
index 00000000000..c40d5c92510
--- /dev/null
+++ b/cfg/ginac.cfg
@@ -0,0 +1,12848 @@
+<?xml version="1.0"?>
+<def format="2">
+  <!-- ex GiNaC::mul::algebraic_subs_mul( const exmap & m, unsigned options ) const -->
+  <function name="GiNaC::mul::algebraic_subs_mul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool GiNaC::mul::can_be_further_expanded( const ex & e ) -->
+  <function name="GiNaC::mul::can_be_further_expanded">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::mul::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::mul::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::mul::do_print_csrc( const print_csrc & c, unsigned level ) const -->
+  <function name="GiNaC::mul::do_print_csrc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::mul::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::mul::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::mul::do_print_python_repr( const print_python_repr & c, unsigned level ) const -->
+  <function name="GiNaC::mul::do_print_python_repr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- epvector GiNaC::mul::expandchildren( unsigned options ) const -->
+  <function name="GiNaC::mul::expandchildren">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="epvector"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::mul::find_real_imag( ex & , ex &  ) const -->
+  <function name="GiNaC::mul::find_real_imag">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void GiNaC::mul::print_overall_coeff( const print_context & c, const char * mul_sym ) const -->
+  <function name="GiNaC::mul::print_overall_coeff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::integral::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::integral::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::integral::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::integral::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const paramset & GiNaC::fderivative::derivatives( void ) const -->
+  <function name="GiNaC::fderivative::derivatives">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const paramset &amp;"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void GiNaC::fderivative::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::fderivative::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::fderivative::do_print_csrc( const print_csrc & c, unsigned level ) const -->
+  <function name="GiNaC::fderivative::do_print_csrc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::fderivative::do_print_latex( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::fderivative::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::fderivative::do_print_tree( const print_tree & c, unsigned level ) const -->
+  <function name="GiNaC::fderivative::do_print_tree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const symmetry & GiNaC::antisymmetric2( void ) -->
+  <function name="GiNaC::antisymmetric2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const symmetry &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const symmetry & GiNaC::antisymmetric3( void ) -->
+  <function name="GiNaC::antisymmetric3">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const symmetry &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const symmetry & GiNaC::antisymmetric4( void ) -->
+  <function name="GiNaC::antisymmetric4">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const symmetry &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- int GiNaC::canonicalize( exvector::iterator v, const symmetry & symm ) -->
+  <function name="GiNaC::canonicalize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- const symmetry & GiNaC::not_symmetric( void ) -->
+  <function name="GiNaC::not_symmetric">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const symmetry &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const symmetry & GiNaC::symmetric2( void ) -->
+  <function name="GiNaC::symmetric2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const symmetry &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const symmetry & GiNaC::symmetric3( void ) -->
+  <function name="GiNaC::symmetric3">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const symmetry &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const symmetry & GiNaC::symmetric4( void ) -->
+  <function name="GiNaC::symmetric4">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const symmetry &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- symmetry & GiNaC::symmetry::add( const symmetry & c ) -->
+  <function name="GiNaC::symmetry::add">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="symmetry &amp;"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int GiNaC::symmetry::canonicalize( exvector::iterator v, const symmetry & symm ) -->
+  <function name="GiNaC::symmetry::canonicalize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::symmetry::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::symmetry::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::symmetry::do_print_tree( const print_tree & c, unsigned level ) const -->
+  <function name="GiNaC::symmetry::do_print_tree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- symmetry_type GiNaC::symmetry::get_type( void ) -->
+  <function name="GiNaC::symmetry::get_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="symmetry_type"/>
+    <use-retval/>
+  </function>
+  <!-- bool GiNaC::symmetry::has_cyclic( void ) const -->
+  <function name="GiNaC::symmetry::has_cyclic">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::symmetry::has_nonsymmetric( void ) const -->
+  <function name="GiNaC::symmetry::has_nonsymmetric">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::symmetry::has_symmetry( void ) -->
+  <function name="GiNaC::symmetry::has_symmetry">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void GiNaC::symmetry::set_type( symmetry_type t ) -->
+  <function name="GiNaC::symmetry::set_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::symmetry::validate( unsigned n ) -->
+  <function name="GiNaC::symmetry::validate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int GiNaC::compare_all_equal::struct_compare( const T * t1, const T * t2 ) -->
+  <function name="GiNaC::compare_all_equal::struct_compare">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- bool GiNaC::compare_all_equal::struct_is_equal( const T * t1, const T * t2 ) -->
+  <function name="GiNaC::compare_all_equal::struct_is_equal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- int GiNaC::compare_bitwise::struct_compare( const T * t1, const T * t2 ) -->
+  <function name="GiNaC::compare_bitwise::struct_compare">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- bool GiNaC::compare_bitwise::struct_is_equal( const T * t1, const T * t2 ) -->
+  <function name="GiNaC::compare_bitwise::struct_is_equal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- int GiNaC::compare_std_less::struct_compare( const T * t1, const T * t2 ) -->
+  <function name="GiNaC::compare_std_less::struct_compare">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- bool GiNaC::compare_std_less::struct_is_equal( const T * t1, const T * t2 ) -->
+  <function name="GiNaC::compare_std_less::struct_is_equal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- const char * GiNaC::structure::get_class_name( void ) -->
+  <function name="GiNaC::structure::get_class_name">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const char *"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- cln::cl_I GiNaC::to_cl_I( const ex & e ) -->
+  <function name="GiNaC::to_cl_I">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_I"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- exvector GiNaC::gcd_optimal_variables_order( const ex & A, const ex & B ) -->
+  <function name="GiNaC::gcd_optimal_variables_order">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="exvector"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool GiNaC::primes_factory::has_primes( void ) -->
+  <function name="GiNaC::primes_factory::has_primes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void GiNaC::mod_gcd( upoly & result, upoly A, upoly B ) -->
+  <function name="GiNaC::mod_gcd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- exp_vector_t GiNaC::degree_vector( ex e, const exvector & vars ) -->
+  <function name="GiNaC::degree_vector">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="exp_vector_t"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- cln::cl_I GiNaC::integer_lcoeff( const ex & e, const exvector & vars ) -->
+  <function name="GiNaC::integer_lcoeff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_I"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::lcoeff_wrt( ex e, const exvector & x ) -->
+  <function name="GiNaC::lcoeff_wrt">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool GiNaC::zerop( const exp_vector_t & v ) -->
+  <function name="GiNaC::zerop">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::normalize_in_field( umodpoly & a, cln::cl_MI * content_ = nullptr ) -->
+  <function name="GiNaC::normalize_in_field">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" default="nullptr" direction="inout"/>
+  </function>
+  <!-- T cln::the_one( const T & sample ) -->
+  <function name="cln::the_one">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="T"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::euclid_gcd( ex A, ex B, const ex & var, const long p ) -->
+  <function name="GiNaC::euclid_gcd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::ex2upoly( umodpoly & u, ex e, const ex & var, const long p ) -->
+  <function name="GiNaC::ex2upoly">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::umodpoly2ex( const umodpoly & a, const ex & var, const long p ) -->
+  <function name="GiNaC::umodpoly2ex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- cln::cl_I cln::smod( const cln::cl_I & x, const cln::cl_I y ) -->
+  <function name="cln::smod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_I"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool GiNaC::remainder_in_field( umodpoly & r, const umodpoly & a, const umodpoly & b ) -->
+  <function name="GiNaC::remainder_in_field">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- bool GiNaC::remainder_in_ring( T & r, const T & a, const T & b ) -->
+  <function name="GiNaC::remainder_in_ring">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void GiNaC::power::do_print_csrc( const print_csrc & c, unsigned level ) const -->
+  <function name="GiNaC::power::do_print_csrc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::power::do_print_csrc_cl_N( const print_csrc_cl_N & c, unsigned level ) const -->
+  <function name="GiNaC::power::do_print_csrc_cl_N">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::power::do_print_dflt( const print_dflt & c, unsigned level ) const -->
+  <function name="GiNaC::power::do_print_dflt">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::power::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::power::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::power::do_print_python( const print_python & c, unsigned level ) const -->
+  <function name="GiNaC::power::do_print_python">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::power::do_print_python_repr( const print_python_repr & c, unsigned level ) const -->
+  <function name="GiNaC::power::do_print_python_repr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::power::expand_add( const add & a, long n, unsigned options ) -->
+  <function name="GiNaC::power::expand_add">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::power::expand_add_2( const add & a, unsigned options ) -->
+  <function name="GiNaC::power::expand_add_2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::power::expand_mul( const mul & m, const numeric & n, unsigned options, bool from_expand = false ) -->
+  <function name="GiNaC::power::expand_mul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void GiNaC::power::print_power( const print_context & c, const char * powersymbol, const char * openbrace, const char * closebrace, unsigned level ) const -->
+  <function name="GiNaC::power::print_power">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::ptr::makewritable( void ) -->
+  <function name="GiNaC::ptr::makewritable">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- int GiNaC::lexer::gettok( void ) -->
+  <function name="GiNaC::lexer::gettok">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- void GiNaC::lexer::switch_input( std::istream * in ) -->
+  <function name="GiNaC::lexer::switch_input">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- std::string GiNaC::lexer::tok2str( const int tok ) const -->
+  <function name="GiNaC::lexer::tok2str">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="std::string"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const prototype_table & GiNaC::get_builtin_reader( void ) -->
+  <function name="GiNaC::get_builtin_reader">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const prototype_table &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const prototype_table & GiNaC::get_default_reader( void ) -->
+  <function name="GiNaC::get_default_reader">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const prototype_table &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- int GiNaC::parser::get_next_tok( void ) -->
+  <function name="GiNaC::parser::get_next_tok">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- symtab GiNaC::parser::get_syms( void ) -->
+  <function name="GiNaC::parser::get_syms">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="symtab"/>
+    <use-retval/>
+  </function>
+  <!-- symtab & GiNaC::parser::get_syms( void ) -->
+  <function name="GiNaC::parser::get_syms">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="symtab &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::parser::parse_expression( void ) -->
+  <function name="GiNaC::parser::parse_expression">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::parser::parse_identifier_expr( void ) -->
+  <function name="GiNaC::parser::parse_identifier_expr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::parser::parse_literal_expr( void ) -->
+  <function name="GiNaC::parser::parse_literal_expr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::parser::parse_lst_expr( void ) -->
+  <function name="GiNaC::parser::parse_lst_expr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::parser::parse_number_expr( void ) -->
+  <function name="GiNaC::parser::parse_number_expr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::parser::parse_paren_expr( void ) -->
+  <function name="GiNaC::parser::parse_paren_expr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::parser::parse_primary( void ) -->
+  <function name="GiNaC::parser::parse_primary">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::parser::parse_unary_expr( void ) -->
+  <function name="GiNaC::parser::parse_unary_expr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::collect_common_factors( const ex & e ) -->
+  <function name="GiNaC::collect_common_factors">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::decomp_rational( const ex & a, const ex & x ) -->
+  <function name="GiNaC::decomp_rational">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool GiNaC::divide( const ex & a, const ex & b, ex & q, bool check_args = true ) -->
+  <function name="GiNaC::divide">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+    <arg nr="4" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::prem( const ex & a, const ex & b, const ex & x, bool check_args = true ) -->
+  <function name="GiNaC::prem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::quo( const ex & a, const ex & b, const ex & x, bool check_args = true ) -->
+  <function name="GiNaC::quo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::rem( const ex & a, const ex & b, const ex & x, bool check_args = true ) -->
+  <function name="GiNaC::rem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::resultant( const ex & e1, const ex & e2, const ex & s ) -->
+  <function name="GiNaC::resultant">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- ex GiNaC::sprem( const ex & a, const ex & b, const ex & x, bool check_args = true ) -->
+  <function name="GiNaC::sprem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::sqrfree_parfrac( const ex & a, const symbol & x ) -->
+  <function name="GiNaC::sqrfree_parfrac">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::delta_tensor( const ex & i1, const ex & i2 ) -->
+  <function name="GiNaC::delta_tensor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::lorentz_eps( const ex & i1, const ex & i2, const ex & i3, const ex & i4, bool pos_sig = false ) -->
+  <function name="GiNaC::lorentz_eps">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+    <arg nr="5" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::lorentz_g( const ex & i1, const ex & i2, bool pos_sig = false ) -->
+  <function name="GiNaC::lorentz_g">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::metric_tensor( const ex & i1, const ex & i2 ) -->
+  <function name="GiNaC::metric_tensor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::minkmetric::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::minkmetric::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::minkmetric::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::minkmetric::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::spinmetric::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::spinmetric::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::spinmetric::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::spinmetric::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::spinor_metric( const ex & i1, const ex & i2 ) -->
+  <function name="GiNaC::spinor_metric">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::tensdelta::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::tensdelta::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::tensdelta::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::tensdelta::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::tensepsilon::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::tensepsilon::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::tensepsilon::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::tensepsilon::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::tensmetric::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::tensmetric::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool GiNaC::tensor::replace_contr_index( exvector::iterator self, exvector::iterator other ) const -->
+  <function name="GiNaC::tensor::replace_contr_index">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- unsigned char GiNaC::color::get_representation_label( void ) -->
+  <function name="GiNaC::color::get_representation_label">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned char"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::color_ONE( unsigned char rl = 0 ) -->
+  <function name="GiNaC::color_ONE">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::color_T( const ex & a, unsigned char rl = 0 ) -->
+  <function name="GiNaC::color_T">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::color_d( const ex & a, const ex & b, const ex & c ) -->
+  <function name="GiNaC::color_d">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- ex GiNaC::color_f( const ex & a, const ex & b, const ex & c ) -->
+  <function name="GiNaC::color_f">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- ex GiNaC::color_h( const ex & a, const ex & b, const ex & c ) -->
+  <function name="GiNaC::color_h">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void GiNaC::su3d::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::su3d::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::su3d::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::su3d::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::su3f::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::su3f::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::su3f::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::su3f::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::su3one::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::su3one::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::su3one::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::su3one::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::su3t::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::su3t::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::su3t::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::su3t::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::basic::accept( GiNaC::visitor & v ) -->
+  <function name="GiNaC::basic::accept">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::basic::add_indexed( const ex & self, const ex & other ) const -->
+  <function name="GiNaC::basic::add_indexed">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::basic::archive( archive_node & n ) const -->
+  <function name="GiNaC::basic::archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- unsigned GiNaC::basic::calchash( void ) const -->
+  <function name="GiNaC::basic::calchash">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const basic & GiNaC::basic::clearflag( unsigned f ) -->
+  <function name="GiNaC::basic::clearflag">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const basic &amp;"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::basic::coeff( const ex & s, int n = 1 ) const -->
+  <function name="GiNaC::basic::coeff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::basic::collect( const ex & s, bool distributed = false ) const -->
+  <function name="GiNaC::basic::collect">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int GiNaC::basic::compare( const basic & other ) const -->
+  <function name="GiNaC::basic::compare">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int GiNaC::basic::compare_same_type( const basic & other ) const -->
+  <function name="GiNaC::basic::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::basic::conjugate( void ) const -->
+  <function name="GiNaC::basic::conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::basic::contract_with( exvector::iterator self, exvector::iterator other, exvector & v ) const -->
+  <function name="GiNaC::basic::contract_with">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void GiNaC::basic::dbgprint( void ) const -->
+  <function name="GiNaC::basic::dbgprint">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+  </function>
+  <!-- void GiNaC::basic::dbgprinttree( void ) const -->
+  <function name="GiNaC::basic::dbgprinttree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+  </function>
+  <!-- int GiNaC::basic::degree( const ex & s ) const -->
+  <function name="GiNaC::basic::degree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::basic::derivative( const symbol & s ) const -->
+  <function name="GiNaC::basic::derivative">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::basic::diff( const symbol & s, unsigned nth = 1 ) const -->
+  <function name="GiNaC::basic::diff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::basic::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::basic::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::basic::do_print_python_repr( const print_python_repr & c, unsigned level ) const -->
+  <function name="GiNaC::basic::do_print_python_repr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::basic::do_print_tree( const print_tree & c, unsigned level ) const -->
+  <function name="GiNaC::basic::do_print_tree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- basic * GiNaC::basic::duplicate( void ) -->
+  <function name="GiNaC::basic::duplicate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="basic *"/>
+    <use-retval/>
+  </function>
+  <!-- void GiNaC::basic::ensure_if_modifiable( void ) const -->
+  <function name="GiNaC::basic::ensure_if_modifiable">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::basic::eval( void ) const -->
+  <function name="GiNaC::basic::eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::basic::eval_indexed( const basic & i ) const -->
+  <function name="GiNaC::basic::eval_indexed">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::basic::eval_integ( void ) const -->
+  <function name="GiNaC::basic::eval_integ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::basic::eval_ncmul( const exvector & v ) const -->
+  <function name="GiNaC::basic::eval_ncmul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::basic::evalf( void ) const -->
+  <function name="GiNaC::basic::evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::basic::evalm( void ) const -->
+  <function name="GiNaC::basic::evalm">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::basic::expand( unsigned options = 0 ) const -->
+  <function name="GiNaC::basic::expand">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- exvector GiNaC::basic::get_free_indices( void ) const -->
+  <function name="GiNaC::basic::get_free_indices">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="exvector"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- unsigned GiNaC::basic::gethash( void ) -->
+  <function name="GiNaC::basic::gethash">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- bool GiNaC::basic::has( const ex & other, unsigned options = 0 ) const -->
+  <function name="GiNaC::basic::has">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const basic & GiNaC::basic::hold( void ) const -->
+  <function name="GiNaC::basic::hold">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const basic &amp;"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::basic::imag_part( void ) const -->
+  <function name="GiNaC::basic::imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::basic::info( unsigned inf ) const -->
+  <function name="GiNaC::basic::info">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- numeric GiNaC::basic::integer_content( void ) const -->
+  <function name="GiNaC::basic::integer_content">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="numeric"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::basic::is_equal( const basic & other ) const -->
+  <function name="GiNaC::basic::is_equal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::basic::is_equal_same_type( const basic & other ) const -->
+  <function name="GiNaC::basic::is_equal_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::basic::is_polynomial( const ex & var ) const -->
+  <function name="GiNaC::basic::is_polynomial">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int GiNaC::basic::ldegree( const ex & s ) const -->
+  <function name="GiNaC::basic::ldegree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex & GiNaC::basic::let_op( size_t i ) -->
+  <function name="GiNaC::basic::let_op">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex &amp;"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::basic::map( map_function & f ) const -->
+  <function name="GiNaC::basic::map">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool GiNaC::basic::match( const ex & pattern, exmap & repls ) const -->
+  <function name="GiNaC::basic::match">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- bool GiNaC::basic::match_same_type( const basic & other ) const -->
+  <function name="GiNaC::basic::match_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- numeric GiNaC::basic::max_coefficient( void ) const -->
+  <function name="GiNaC::basic::max_coefficient">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="numeric"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- size_t GiNaC::basic::nops( void ) const -->
+  <function name="GiNaC::basic::nops">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::basic::normal( exmap & repl, exmap & rev_lookup, lst & modifier ) const -->
+  <function name="GiNaC::basic::normal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::basic::op( size_t i ) const -->
+  <function name="GiNaC::basic::op">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- unsigned GiNaC::basic::precedence( void ) const -->
+  <function name="GiNaC::basic::precedence">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void GiNaC::basic::print( const print_context & c, unsigned level = 0 ) const -->
+  <function name="GiNaC::basic::print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::basic::read_archive( const archive_node & n, lst & syms ) -->
+  <function name="GiNaC::basic::read_archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::basic::real_part( void ) const -->
+  <function name="GiNaC::basic::real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- unsigned GiNaC::basic::return_type( void ) const -->
+  <function name="GiNaC::basic::return_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- return_type_t GiNaC::basic::return_type_tinfo( void ) const -->
+  <function name="GiNaC::basic::return_type_tinfo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="return_type_t"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::basic::scalar_mul_indexed( const ex & self, const numeric & other ) const -->
+  <function name="GiNaC::basic::scalar_mul_indexed">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::basic::series( const relational & r, int order, unsigned options = 0 ) const -->
+  <function name="GiNaC::basic::series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const basic & GiNaC::basic::setflag( unsigned f ) -->
+  <function name="GiNaC::basic::setflag">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const basic &amp;"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::basic::smod( const numeric & xi ) const -->
+  <function name="GiNaC::basic::smod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::basic::subs( const exmap & m, unsigned options = 0 ) const -->
+  <function name="GiNaC::basic::subs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::basic::subs_one_level( const exmap & m, unsigned options ) const -->
+  <function name="GiNaC::basic::subs_one_level">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::basic::to_polynomial( exmap & repl ) const -->
+  <function name="GiNaC::basic::to_polynomial">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::basic::to_rational( exmap & repl ) const -->
+  <function name="GiNaC::basic::to_rational">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- std::ostream & GiNaC::csrc( std::ostream & os ) -->
+  <function name="GiNaC::csrc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="std::ostream &amp;"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- std::ostream & GiNaC::csrc_cl_N( std::ostream & os ) -->
+  <function name="GiNaC::csrc_cl_N">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="std::ostream &amp;"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- std::ostream & GiNaC::csrc_double( std::ostream & os ) -->
+  <function name="GiNaC::csrc_double">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="std::ostream &amp;"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- std::ostream & GiNaC::csrc_float( std::ostream & os ) -->
+  <function name="GiNaC::csrc_float">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="std::ostream &amp;"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- std::ostream & GiNaC::dflt( std::ostream & os ) -->
+  <function name="GiNaC::dflt">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="std::ostream &amp;"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- std::ostream & GiNaC::index_dimensions( std::ostream & os ) -->
+  <function name="GiNaC::index_dimensions">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="std::ostream &amp;"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- std::ostream & GiNaC::latex( std::ostream & os ) -->
+  <function name="GiNaC::latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="std::ostream &amp;"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- std::ostream & GiNaC::no_index_dimensions( std::ostream & os ) -->
+  <function name="GiNaC::no_index_dimensions">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="std::ostream &amp;"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- std::ostream & GiNaC::python( std::ostream & os ) -->
+  <function name="GiNaC::python">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="std::ostream &amp;"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- std::ostream & GiNaC::python_repr( std::ostream & os ) -->
+  <function name="GiNaC::python_repr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="std::ostream &amp;"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- std::ostream & GiNaC::tree( std::ostream & os ) -->
+  <function name="GiNaC::tree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="std::ostream &amp;"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void GiNaC::relational::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::relational::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::relational::do_print_python_repr( const print_python_repr & c, unsigned level ) const -->
+  <function name="GiNaC::relational::do_print_python_repr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::relational::lhs( void ) -->
+  <function name="GiNaC::relational::lhs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::relational::rhs( void ) -->
+  <function name="GiNaC::relational::rhs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- void GiNaC::relational::safe_bool_helper::nonnull( void ) -->
+  <function name="GiNaC::relational::safe_bool_helper::nonnull">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- ex GiNaC::CatalanEvalf( void ) -->
+  <function name="GiNaC::CatalanEvalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::EulerEvalf( void ) -->
+  <function name="GiNaC::EulerEvalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- const numeric GiNaC::Li2( const numeric & x ) -->
+  <function name="GiNaC::Li2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::PiEvalf( void ) -->
+  <function name="GiNaC::PiEvalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- void GiNaC::_numeric_digits::add_callback( digits_changed_callback callback ) -->
+  <function name="GiNaC::_numeric_digits::add_callback">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::_numeric_digits::print( std::ostream & os ) const -->
+  <function name="GiNaC::_numeric_digits::print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- const numeric GiNaC::abs( const numeric & x ) -->
+  <function name="GiNaC::abs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::acos( const numeric & x ) -->
+  <function name="GiNaC::acos">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::acosh( const numeric & x ) -->
+  <function name="GiNaC::acosh">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::asin( const numeric & x ) -->
+  <function name="GiNaC::asin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::asinh( const numeric & x ) -->
+  <function name="GiNaC::asinh">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::atanh( const numeric & x ) -->
+  <function name="GiNaC::atanh">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::bernoulli( const numeric & n ) -->
+  <function name="GiNaC::bernoulli">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::binomial( const numeric & n, const numeric & k ) -->
+  <function name="GiNaC::binomial">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::cos( const numeric & x ) -->
+  <function name="GiNaC::cos">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::cosh( const numeric & x ) -->
+  <function name="GiNaC::cosh">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int GiNaC::csgn( const numeric & x ) -->
+  <function name="GiNaC::csgn">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::doublefactorial( const numeric & n ) -->
+  <function name="GiNaC::doublefactorial">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::exp( const numeric & x ) -->
+  <function name="GiNaC::exp">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::factorial( const numeric & n ) -->
+  <function name="GiNaC::factorial">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::fibonacci( const numeric & n ) -->
+  <function name="GiNaC::fibonacci">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::imag( const numeric & x ) -->
+  <function name="GiNaC::imag">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::is_cinteger( const numeric & x ) -->
+  <function name="GiNaC::is_cinteger">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::is_crational( const numeric & x ) -->
+  <function name="GiNaC::is_crational">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::is_even( const numeric & x ) -->
+  <function name="GiNaC::is_even">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::is_integer( const numeric & x ) -->
+  <function name="GiNaC::is_integer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::is_negative( const numeric & x ) -->
+  <function name="GiNaC::is_negative">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::is_nonneg_integer( const numeric & x ) -->
+  <function name="GiNaC::is_nonneg_integer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::is_odd( const numeric & x ) -->
+  <function name="GiNaC::is_odd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::is_pos_integer( const numeric & x ) -->
+  <function name="GiNaC::is_pos_integer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::is_positive( const numeric & x ) -->
+  <function name="GiNaC::is_positive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::is_prime( const numeric & x ) -->
+  <function name="GiNaC::is_prime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::is_rational( const numeric & x ) -->
+  <function name="GiNaC::is_rational">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::is_real( const numeric & x ) -->
+  <function name="GiNaC::is_real">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::isqrt( const numeric & x ) -->
+  <function name="GiNaC::isqrt">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::log( const numeric & x ) -->
+  <function name="GiNaC::log">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::mod( const numeric & a, const numeric & b ) -->
+  <function name="GiNaC::mod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::numeric::add( const numeric & other ) const -->
+  <function name="GiNaC::numeric::add">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric & GiNaC::numeric::add_dyn( const numeric & other ) const -->
+  <function name="GiNaC::numeric::add_dyn">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric &amp;"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int GiNaC::numeric::compare( const numeric & other ) const -->
+  <function name="GiNaC::numeric::compare">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int GiNaC::numeric::csgn( void ) const -->
+  <function name="GiNaC::numeric::csgn">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const numeric GiNaC::numeric::denom( void ) const -->
+  <function name="GiNaC::numeric::denom">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const numeric GiNaC::numeric::div( const numeric & other ) const -->
+  <function name="GiNaC::numeric::div">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric & GiNaC::numeric::div_dyn( const numeric & other ) const -->
+  <function name="GiNaC::numeric::div_dyn">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric &amp;"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::numeric::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::numeric::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::numeric::do_print_csrc( const print_csrc & c, unsigned level ) const -->
+  <function name="GiNaC::numeric::do_print_csrc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::numeric::do_print_csrc_cl_N( const print_csrc_cl_N & c, unsigned level ) const -->
+  <function name="GiNaC::numeric::do_print_csrc_cl_N">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::numeric::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::numeric::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::numeric::do_print_python_repr( const print_python_repr & c, unsigned level ) const -->
+  <function name="GiNaC::numeric::do_print_python_repr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::numeric::do_print_tree( const print_tree & c, unsigned level ) const -->
+  <function name="GiNaC::numeric::do_print_tree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const numeric GiNaC::numeric::imag( void ) const -->
+  <function name="GiNaC::numeric::imag">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- int GiNaC::numeric::int_length( void ) const -->
+  <function name="GiNaC::numeric::int_length">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const numeric GiNaC::numeric::inverse( void ) const -->
+  <function name="GiNaC::numeric::inverse">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::numeric::is_cinteger( void ) const -->
+  <function name="GiNaC::numeric::is_cinteger">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::numeric::is_crational( void ) const -->
+  <function name="GiNaC::numeric::is_crational">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::numeric::is_equal( const numeric & other ) const -->
+  <function name="GiNaC::numeric::is_equal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::numeric::is_even( void ) const -->
+  <function name="GiNaC::numeric::is_even">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::numeric::is_integer( void ) const -->
+  <function name="GiNaC::numeric::is_integer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::numeric::is_negative( void ) const -->
+  <function name="GiNaC::numeric::is_negative">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::numeric::is_nonneg_integer( void ) const -->
+  <function name="GiNaC::numeric::is_nonneg_integer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::numeric::is_odd( void ) const -->
+  <function name="GiNaC::numeric::is_odd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::numeric::is_pos_integer( void ) const -->
+  <function name="GiNaC::numeric::is_pos_integer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::numeric::is_positive( void ) const -->
+  <function name="GiNaC::numeric::is_positive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::numeric::is_prime( void ) const -->
+  <function name="GiNaC::numeric::is_prime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::numeric::is_rational( void ) const -->
+  <function name="GiNaC::numeric::is_rational">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::numeric::is_real( void ) const -->
+  <function name="GiNaC::numeric::is_real">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::numeric::is_zero( void ) const -->
+  <function name="GiNaC::numeric::is_zero">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const numeric GiNaC::numeric::mul( const numeric & other ) const -->
+  <function name="GiNaC::numeric::mul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric & GiNaC::numeric::mul_dyn( const numeric & other ) const -->
+  <function name="GiNaC::numeric::mul_dyn">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric &amp;"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::numeric::numer( void ) const -->
+  <function name="GiNaC::numeric::numer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const numeric GiNaC::numeric::power( const numeric & other ) const -->
+  <function name="GiNaC::numeric::power">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric & GiNaC::numeric::power_dyn( const numeric & other ) const -->
+  <function name="GiNaC::numeric::power_dyn">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric &amp;"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::numeric::print_numeric( const print_context & c, const char * par_open, const char * par_close, const char * imag_sym, const char * mul_sym, unsigned level ) const -->
+  <function name="GiNaC::numeric::print_numeric">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const numeric GiNaC::numeric::real( void ) const -->
+  <function name="GiNaC::numeric::real">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- numeric GiNaC::numeric::step( void ) const -->
+  <function name="GiNaC::numeric::step">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="numeric"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const numeric GiNaC::numeric::sub( const numeric & other ) const -->
+  <function name="GiNaC::numeric::sub">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric & GiNaC::numeric::sub_dyn( const numeric & other ) const -->
+  <function name="GiNaC::numeric::sub_dyn">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric &amp;"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- cln::cl_N GiNaC::numeric::to_cl_N( void ) const -->
+  <function name="GiNaC::numeric::to_cl_N">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- double GiNaC::numeric::to_double( void ) const -->
+  <function name="GiNaC::numeric::to_double">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- int GiNaC::numeric::to_int( void ) const -->
+  <function name="GiNaC::numeric::to_int">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- long GiNaC::numeric::to_long( void ) const -->
+  <function name="GiNaC::numeric::to_long">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- int GiNaC::pole_error::degree( void ) const -->
+  <function name="GiNaC::pole_error::degree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const numeric GiNaC::real( const numeric & x ) -->
+  <function name="GiNaC::real">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::sin( const numeric & x ) -->
+  <function name="GiNaC::sin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::sinh( const numeric & x ) -->
+  <function name="GiNaC::sinh">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- numeric GiNaC::step( const numeric & x ) -->
+  <function name="GiNaC::step">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::tan( const numeric & x ) -->
+  <function name="GiNaC::tan">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const numeric GiNaC::tanh( const numeric & x ) -->
+  <function name="GiNaC::tanh">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- double GiNaC::to_double( const numeric & x ) -->
+  <function name="GiNaC::to_double">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int GiNaC::to_int( const numeric & x ) -->
+  <function name="GiNaC::to_int">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long GiNaC::to_long( const numeric & x ) -->
+  <function name="GiNaC::to_long">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- unsigned GiNaC::make_hash_seed( const std::type_info & tinfo ) -->
+  <function name="GiNaC::make_hash_seed">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int GiNaC::expair::compare( const expair & other ) -->
+  <function name="GiNaC::expair::compare">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const expair GiNaC::expair::conjugate( void ) const -->
+  <function name="GiNaC::expair::conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const expair"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::expair::is_canonical_numeric( void ) -->
+  <function name="GiNaC::expair::is_canonical_numeric">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool GiNaC::expair::is_equal( const expair & other ) -->
+  <function name="GiNaC::expair::is_equal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::expair::is_less( const expair & other ) -->
+  <function name="GiNaC::expair::is_less">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::expair::print( std::ostream & os ) const -->
+  <function name="GiNaC::expair::print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void GiNaC::expair::swap( expair & other ) -->
+  <function name="GiNaC::expair::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool GiNaC::is_terminating( const pseries & s ) -->
+  <function name="GiNaC::is_terminating">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::pseries::add_series( const pseries & other ) const -->
+  <function name="GiNaC::pseries::add_series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::pseries::coeffop( size_t i ) const -->
+  <function name="GiNaC::pseries::coeffop">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::pseries::convert_to_poly( bool no_order = false ) const -->
+  <function name="GiNaC::pseries::convert_to_poly">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void GiNaC::pseries::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::pseries::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::pseries::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::pseries::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::pseries::do_print_python( const print_python & c, unsigned level ) const -->
+  <function name="GiNaC::pseries::do_print_python">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::pseries::do_print_python_repr( const print_python_repr & c, unsigned level ) const -->
+  <function name="GiNaC::pseries::do_print_python_repr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::pseries::do_print_tree( const print_tree & c, unsigned level ) const -->
+  <function name="GiNaC::pseries::do_print_tree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::pseries::exponop( size_t i ) const -->
+  <function name="GiNaC::pseries::exponop">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::pseries::get_point( void ) -->
+  <function name="GiNaC::pseries::get_point">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::pseries::get_var( void ) -->
+  <function name="GiNaC::pseries::get_var">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- bool GiNaC::pseries::is_compatible_to( const pseries & other ) -->
+  <function name="GiNaC::pseries::is_compatible_to">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::pseries::is_terminating( void ) const -->
+  <function name="GiNaC::pseries::is_terminating">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::pseries::is_zero( void ) -->
+  <function name="GiNaC::pseries::is_zero">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::pseries::mul_const( const numeric & other ) const -->
+  <function name="GiNaC::pseries::mul_const">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::pseries::mul_series( const pseries & other ) const -->
+  <function name="GiNaC::pseries::mul_series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::pseries::power_const( const numeric & p, int deg ) const -->
+  <function name="GiNaC::pseries::power_const">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::pseries::print_series( const print_context & c, const char * openbrace, const char * closebrace, const char * mul_sym, const char * pow_sym, unsigned level ) const -->
+  <function name="GiNaC::pseries::print_series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- pseries GiNaC::pseries::shift_exponents( int deg ) const -->
+  <function name="GiNaC::pseries::shift_exponents">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="pseries"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::series_to_poly( const ex & e ) -->
+  <function name="GiNaC::series_to_poly">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::hold_ncmul( const exvector & v ) -->
+  <function name="GiNaC::hold_ncmul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::ncmul::append_factors( exvector & v, const ex & e ) const -->
+  <function name="GiNaC::ncmul::append_factors">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- size_t GiNaC::ncmul::count_factors( const ex & e ) const -->
+  <function name="GiNaC::ncmul::count_factors">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::ncmul::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::ncmul::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::ncmul::do_print_csrc( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::ncmul::do_print_csrc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- exvector GiNaC::ncmul::expandchildren( unsigned options ) const -->
+  <function name="GiNaC::ncmul::expandchildren">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="exvector"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const exvector & GiNaC::ncmul::get_factors( void ) const -->
+  <function name="GiNaC::ncmul::get_factors">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const exvector &amp;"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::ncmul::hold_ncmul( const exvector & v ) -->
+  <function name="GiNaC::ncmul::hold_ncmul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::ncmul::reeval_ncmul( const exvector & v ) -->
+  <function name="GiNaC::ncmul::reeval_ncmul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::reeval_ncmul( const exvector & v ) -->
+  <function name="GiNaC::reeval_ncmul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- container & GiNaC::container::append( const ex & b ) -->
+  <function name="GiNaC::container::append">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="container &amp;"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const_iterator GiNaC::container::begin( void ) -->
+  <function name="GiNaC::container::begin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const_iterator"/>
+    <use-retval/>
+  </function>
+  <!-- void GiNaC::container::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::container::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::container::do_print_python( const print_python & c, unsigned level ) const -->
+  <function name="GiNaC::container::do_print_python">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::container::do_print_python_repr( const print_python_repr & c, unsigned level ) const -->
+  <function name="GiNaC::container::do_print_python_repr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::container::do_print_tree( const print_tree & c, unsigned level ) const -->
+  <function name="GiNaC::container::do_print_tree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const_iterator GiNaC::container::end( void ) -->
+  <function name="GiNaC::container::end">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const_iterator"/>
+    <use-retval/>
+  </function>
+  <!-- char GiNaC::container::get_close_delim( void ) -->
+  <function name="GiNaC::container::get_close_delim">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="char"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- unsigned GiNaC::container::get_default_flags( void ) -->
+  <function name="GiNaC::container::get_default_flags">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- char GiNaC::container::get_open_delim( void ) -->
+  <function name="GiNaC::container::get_open_delim">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="char"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- container & GiNaC::container::prepend( const ex & b ) -->
+  <function name="GiNaC::container::prepend">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="container &amp;"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const_reverse_iterator GiNaC::container::rbegin( void ) -->
+  <function name="GiNaC::container::rbegin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const_reverse_iterator"/>
+    <use-retval/>
+  </function>
+  <!-- container & GiNaC::container::remove_all( void ) -->
+  <function name="GiNaC::container::remove_all">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="container &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- container & GiNaC::container::remove_first( void ) -->
+  <function name="GiNaC::container::remove_first">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="container &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- container & GiNaC::container::remove_last( void ) -->
+  <function name="GiNaC::container::remove_last">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="container &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const_reverse_iterator GiNaC::container::rend( void ) -->
+  <function name="GiNaC::container::rend">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const_reverse_iterator"/>
+    <use-retval/>
+  </function>
+  <!-- container & GiNaC::container::sort( void ) -->
+  <function name="GiNaC::container::sort">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="container &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- STLT GiNaC::container::subschildren( const exmap & m, unsigned options = 0 ) const -->
+  <function name="GiNaC::container::subschildren">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="STLT"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::container::thiscontainer( const STLT & v ) -->
+  <function name="GiNaC::container::thiscontainer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- container & GiNaC::container::unique( void ) -->
+  <function name="GiNaC::container::unique">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="container &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- void GiNaC::container::unique_( void ) -->
+  <function name="GiNaC::container::unique_">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- epvector * GiNaC::conjugateepvector( const epvector &  ) -->
+  <function name="GiNaC::conjugateepvector">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="epvector *"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::expairseq::can_make_flat( const expair & p ) const -->
+  <function name="GiNaC::expairseq::can_make_flat">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::expairseq::canonicalize( void ) -->
+  <function name="GiNaC::expairseq::canonicalize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GiNaC::expairseq::combine_same_terms_sorted_seq( void ) -->
+  <function name="GiNaC::expairseq::combine_same_terms_sorted_seq">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GiNaC::expairseq::construct_from_2_ex( const ex & lh, const ex & rh ) -->
+  <function name="GiNaC::expairseq::construct_from_2_ex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::expairseq::construct_from_epvector( const epvector & v, bool do_index_renaming = false ) -->
+  <function name="GiNaC::expairseq::construct_from_epvector">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void GiNaC::expairseq::construct_from_exvector( const exvector & v ) -->
+  <function name="GiNaC::expairseq::construct_from_exvector">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::expairseq::default_overall_coeff( void ) const -->
+  <function name="GiNaC::expairseq::default_overall_coeff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void GiNaC::expairseq::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::expairseq::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::expairseq::do_print_tree( const print_tree & c, unsigned level ) const -->
+  <function name="GiNaC::expairseq::do_print_tree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- epvector GiNaC::expairseq::evalchildren( void ) const -->
+  <function name="GiNaC::expairseq::evalchildren">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="epvector"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::expairseq::expair_needs_further_processing( epp it ) -->
+  <function name="GiNaC::expairseq::expair_needs_further_processing">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- epvector GiNaC::expairseq::expandchildren( unsigned options ) const -->
+  <function name="GiNaC::expairseq::expandchildren">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="epvector"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool GiNaC::expairseq::is_canonical( void ) const -->
+  <function name="GiNaC::expairseq::is_canonical">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::expairseq::recombine_pair_to_ex( const expair & p ) const -->
+  <function name="GiNaC::expairseq::recombine_pair_to_ex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- expair GiNaC::expairseq::split_ex_to_pair( const ex & e ) const -->
+  <function name="GiNaC::expairseq::split_ex_to_pair">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="expair"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- epvector GiNaC::expairseq::subschildren( const exmap & m, unsigned options = 0 ) const -->
+  <function name="GiNaC::expairseq::subschildren">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="epvector"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::expairseq::thisexpairseq( const epvector & v, const ex & oc, bool do_index_renaming = false ) const -->
+  <function name="GiNaC::expairseq::thisexpairseq">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void GiNaC::make_flat_inserter::combine_indices( const exvector & dummies_of_factor ) -->
+  <function name="GiNaC::make_flat_inserter::combine_indices">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::make_flat_inserter::handle_factor( const ex & x, const ex & coeff ) -->
+  <function name="GiNaC::make_flat_inserter::handle_factor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- return_type_t GiNaC::make_return_type_t( const unsigned rl = 0 ) -->
+  <function name="GiNaC::make_return_type_t">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="return_type_t"/>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const char * GiNaC::registered_class_options::get_name( void ) -->
+  <function name="GiNaC::registered_class_options::get_name">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const char *"/>
+    <use-retval/>
+  </function>
+  <!-- const char * GiNaC::registered_class_options::get_parent_name( void ) -->
+  <function name="GiNaC::registered_class_options::get_parent_name">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const char *"/>
+    <use-retval/>
+  </function>
+  <!-- const std::vector<print_functor> & GiNaC::registered_class_options::get_print_dispatch_table( void ) -->
+  <function name="GiNaC::registered_class_options::get_print_dispatch_table">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+  </function>
+  <!-- void GiNaC::registered_class_options::set_print_func( unsigned id, const print_functor & f ) -->
+  <function name="GiNaC::registered_class_options::set_print_func">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- std::type_info const * GiNaC::registered_class_options::std::get_id( void ) -->
+  <function name="GiNaC::registered_class_options::std::get_id">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="std::type_info const *"/>
+    <use-retval/>
+  </function>
+  <!-- unsigned GiNaC::print_context_options::get_id( void ) -->
+  <function name="GiNaC::print_context_options::get_id">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- const char * GiNaC::print_context_options::get_name( void ) -->
+  <function name="GiNaC::print_context_options::get_name">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const char *"/>
+    <use-retval/>
+  </function>
+  <!-- const char * GiNaC::print_context_options::get_parent_name( void ) -->
+  <function name="GiNaC::print_context_options::get_parent_name">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const char *"/>
+    <use-retval/>
+  </function>
+  <!-- bool GiNaC::print_functor::is_valid( void ) -->
+  <function name="GiNaC::print_functor::is_valid">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- unsigned GiNaC::crc32( const char * c, const unsigned len, const unsigned crcinit ) -->
+  <function name="GiNaC::crc32">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <pure/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool GiNaC::basic_partition_generator::mpartition2::next_partition( void ) -->
+  <function name="GiNaC::basic_partition_generator::mpartition2::next_partition">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- int GiNaC::compare_pointers( const T * a, const T * b ) -->
+  <function name="GiNaC::compare_pointers">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- bool GiNaC::composition_generator::coolmulti::finished( void ) -->
+  <function name="GiNaC::composition_generator::coolmulti::finished">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void GiNaC::composition_generator::coolmulti::next_permutation( void ) -->
+  <function name="GiNaC::composition_generator::coolmulti::next_permutation">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- const std::vector<unsigned> & GiNaC::composition_generator::get( void ) -->
+  <function name="GiNaC::composition_generator::get">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+  </function>
+  <!-- bool GiNaC::composition_generator::next( void ) -->
+  <function name="GiNaC::composition_generator::next">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void GiNaC::cyclic_permutation( It first, It last, It new_first, Swap swapit ) -->
+  <function name="GiNaC::cyclic_permutation">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- unsigned GiNaC::golden_ratio_hash( uintptr_t n ) -->
+  <function name="GiNaC::golden_ratio_hash">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- unsigned GiNaC::log2( unsigned n ) -->
+  <function name="GiNaC::log2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const std::vector<unsigned> & GiNaC::partition_generator::get( void ) -->
+  <function name="GiNaC::partition_generator::get">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+  </function>
+  <!-- bool GiNaC::partition_generator::next( void ) -->
+  <function name="GiNaC::partition_generator::next">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- const std::vector<unsigned> & GiNaC::partition_with_zero_parts_generator::get( void ) -->
+  <function name="GiNaC::partition_with_zero_parts_generator::get">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+  </function>
+  <!-- bool GiNaC::partition_with_zero_parts_generator::next( void ) -->
+  <function name="GiNaC::partition_with_zero_parts_generator::next">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- unsigned GiNaC::rotate_left( unsigned n ) -->
+  <function name="GiNaC::rotate_left">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::shaker_sort( It first, It last, Cmp comp, Swap swapit ) -->
+  <function name="GiNaC::shaker_sort">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- void GiNaC::symbol::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::symbol::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::symbol::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::symbol::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::symbol::do_print_python_repr( const print_python_repr & c, unsigned level ) const -->
+  <function name="GiNaC::symbol::do_print_python_repr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::symbol::do_print_tree( const print_tree & c, unsigned level ) const -->
+  <function name="GiNaC::symbol::do_print_tree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- std::string GiNaC::symbol::get_TeX_name( void ) const -->
+  <function name="GiNaC::symbol::get_TeX_name">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="std::string"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- unsigned GiNaC::symbol::get_domain( void ) -->
+  <function name="GiNaC::symbol::get_domain">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- std::string GiNaC::symbol::get_name( void ) const -->
+  <function name="GiNaC::symbol::get_name">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="std::string"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void GiNaC::symbol::set_TeX_name( const std::string & n ) -->
+  <function name="GiNaC::symbol::set_TeX_name">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::symbol::set_name( const std::string & n ) -->
+  <function name="GiNaC::symbol::set_name">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::unlink_ex( const std::string filename ) -->
+  <function name="GiNaC::unlink_ex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::class_info::dump_hierarchy( bool verbose = false ) -->
+  <function name="GiNaC::class_info::dump_hierarchy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void GiNaC::class_info::dump_tree( tree_node * n, const std::string & prefix, bool verbose ) -->
+  <function name="GiNaC::class_info::dump_tree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- const class_info * GiNaC::class_info::find( const std::string & class_name ) -->
+  <function name="GiNaC::class_info::find">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const class_info *"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::class_info::identify_parents( void ) -->
+  <function name="GiNaC::class_info::identify_parents">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+  </function>
+  <!-- void GiNaC::class_info::tree_node::add_child( tree_node * n ) -->
+  <function name="GiNaC::class_info::tree_node::add_child">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::factor( const ex & poly, unsigned options = 0 ) -->
+  <function name="GiNaC::factor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::add::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::add::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::add::do_print_csrc( const print_csrc & c, unsigned level ) const -->
+  <function name="GiNaC::add::do_print_csrc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::add::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::add::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::add::do_print_python_repr( const print_python_repr & c, unsigned level ) const -->
+  <function name="GiNaC::add::do_print_python_repr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::add::print_add( const print_context & c, const char * openbrace, const char * closebrace, const char * mul_sym, unsigned level ) const -->
+  <function name="GiNaC::add::print_add">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::canonicalize_clifford( const ex & e ) -->
+  <function name="GiNaC::canonicalize_clifford">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::clifford::do_print_dflt( const print_dflt & c, unsigned level ) const -->
+  <function name="GiNaC::clifford::do_print_dflt">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::clifford::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::clifford::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::clifford::do_print_tree( const print_tree & c, unsigned level ) const -->
+  <function name="GiNaC::clifford::do_print_tree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int GiNaC::clifford::get_commutator_sign( void ) -->
+  <function name="GiNaC::clifford::get_commutator_sign">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- unsigned char GiNaC::clifford::get_representation_label( void ) -->
+  <function name="GiNaC::clifford::get_representation_label">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned char"/>
+    <use-retval/>
+  </function>
+  <!-- bool GiNaC::clifford::same_metric( const ex & other ) const -->
+  <function name="GiNaC::clifford::same_metric">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::clifford_bar( const ex & e ) -->
+  <function name="GiNaC::clifford_bar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::clifford_inverse( const ex & e ) -->
+  <function name="GiNaC::clifford_inverse">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int GiNaC::clifford_max_label( const ex & e, bool ignore_ONE = false ) -->
+  <function name="GiNaC::clifford_max_label">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::clifford_norm( const ex & e ) -->
+  <function name="GiNaC::clifford_norm">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::clifford_prime( const ex & e ) -->
+  <function name="GiNaC::clifford_prime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::clifford_star( const ex & e ) -->
+  <function name="GiNaC::clifford_star">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::clifford_star_bar( const ex & e, bool do_bar, unsigned options ) -->
+  <function name="GiNaC::clifford_star_bar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- lst GiNaC::clifford_to_lst( const ex & e, const ex & c, bool algebraic = true ) -->
+  <function name="GiNaC::clifford_to_lst">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="lst"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::clifford_unit( const ex & mu, const ex & metr, unsigned char rl = 0 ) -->
+  <function name="GiNaC::clifford_unit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::cliffordunit::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::cliffordunit::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::cliffordunit::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::cliffordunit::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::dirac_ONE( unsigned char rl = 0 ) -->
+  <function name="GiNaC::dirac_ONE">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::dirac_gamma( const ex & mu, unsigned char rl = 0 ) -->
+  <function name="GiNaC::dirac_gamma">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::dirac_gamma5( unsigned char rl = 0 ) -->
+  <function name="GiNaC::dirac_gamma5">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::dirac_gammaL( unsigned char rl = 0 ) -->
+  <function name="GiNaC::dirac_gammaL">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::dirac_gammaR( unsigned char rl = 0 ) -->
+  <function name="GiNaC::dirac_gammaR">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::dirac_slash( const ex & e, const ex & dim, unsigned char rl = 0 ) -->
+  <function name="GiNaC::dirac_slash">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::diracgamma5::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::diracgamma5::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::diracgamma5::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::diracgamma5::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::diracgamma::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::diracgamma::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::diracgamma::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::diracgamma::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::diracgammaL::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::diracgammaL::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::diracgammaL::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::diracgammaL::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::diracgammaR::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::diracgammaR::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::diracgammaR::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::diracgammaR::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::diracone::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::diracone::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::diracone::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::diracone::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool GiNaC::is_clifford_tinfo( const return_type_t & ti ) -->
+  <function name="GiNaC::is_clifford_tinfo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::remove_dirac_ONE( const ex & e, unsigned char rl = 0, unsigned options = 0 ) -->
+  <function name="GiNaC::remove_dirac_ONE">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const numeric GiNaC::fsolve( const ex & f, const symbol & x, const numeric & x1, const numeric & x2 ) -->
+  <function name="GiNaC::fsolve">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const numeric"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- bool GiNaC::is_order_function( const ex & e ) -->
+  <function name="GiNaC::is_order_function">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::lsolve( const ex & eqns, const ex & symbols, unsigned options = solve_algo::automatic ) -->
+  <function name="GiNaC::lsolve">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" default="solve_algo::automatic" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::remember_table::clear_all_entries( void ) -->
+  <function name="GiNaC::remember_table::clear_all_entries">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GiNaC::remember_table::init_table( void ) -->
+  <function name="GiNaC::remember_table::init_table">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GiNaC::remember_table::show_statistics( std::ostream & os, unsigned level ) const -->
+  <function name="GiNaC::remember_table::show_statistics">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- unsigned long GiNaC::remember_table_entry::get_last_access( void ) -->
+  <function name="GiNaC::remember_table_entry::get_last_access">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned long"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::remember_table_entry::get_result( void ) -->
+  <function name="GiNaC::remember_table_entry::get_result">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- unsigned long GiNaC::remember_table_entry::get_successful_hits( void ) -->
+  <function name="GiNaC::remember_table_entry::get_successful_hits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned long"/>
+    <use-retval/>
+  </function>
+  <!-- void GiNaC::fail::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::fail::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::constant::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::constant::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::constant::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::constant::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::constant::do_print_python_repr( const print_python_repr & c, unsigned level ) const -->
+  <function name="GiNaC::constant::do_print_python_repr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::constant::do_print_tree( const print_tree & c, unsigned level ) const -->
+  <function name="GiNaC::constant::do_print_tree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool GiNaC::basic_multi_iterator::overflow( void ) const -->
+  <function name="GiNaC::basic_multi_iterator::overflow">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- size_t GiNaC::basic_multi_iterator::size( void ) const -->
+  <function name="GiNaC::basic_multi_iterator::size">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- int GiNaC::multi_iterator_permutation::get_sign( void ) const -->
+  <function name="GiNaC::multi_iterator_permutation::get_sign">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::are_ex_trivially_equal( const ex & e1, const ex & e2 ) -->
+  <function name="GiNaC::are_ex_trivially_equal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::coeff( const ex & thisex, const ex & s, int n = 1 ) -->
+  <function name="GiNaC::coeff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" default="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::collect( const ex & thisex, const ex & s, bool distributed = false ) -->
+  <function name="GiNaC::collect">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::conjugate( const ex & thisex ) -->
+  <function name="GiNaC::conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::const_postorder_iterator::descend( void ) -->
+  <function name="GiNaC::const_postorder_iterator::descend">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GiNaC::const_postorder_iterator::increment( void ) -->
+  <function name="GiNaC::const_postorder_iterator::increment">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GiNaC::const_preorder_iterator::increment( void ) -->
+  <function name="GiNaC::const_preorder_iterator::increment">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- ex GiNaC::diff( const ex & thisex, const symbol & s, unsigned nth = 1 ) -->
+  <function name="GiNaC::diff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" default="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::eval( const ex & thisex ) -->
+  <function name="GiNaC::eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::eval_integ( const ex & thisex ) -->
+  <function name="GiNaC::eval_integ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::evalm( const ex & thisex ) -->
+  <function name="GiNaC::evalm">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::ex::accept( visitor & v ) -->
+  <function name="GiNaC::ex::accept">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool GiNaC::ex::are_ex_trivially_equal( const ex & , const ex &  ) -->
+  <function name="GiNaC::ex::are_ex_trivially_equal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::ex::coeff( const ex & s, int n = 1 ) -->
+  <function name="GiNaC::ex::coeff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::ex::collect( const ex & s, bool distributed = false ) -->
+  <function name="GiNaC::ex::collect">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int GiNaC::ex::compare( const ex & other ) const -->
+  <function name="GiNaC::ex::compare">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::ex::conjugate( void ) -->
+  <function name="GiNaC::ex::conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- basic & GiNaC::ex::construct_from_double( double d ) -->
+  <function name="GiNaC::ex::construct_from_double">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="basic &amp;"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- basic & GiNaC::ex::construct_from_int( int i ) -->
+  <function name="GiNaC::ex::construct_from_int">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="basic &amp;"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- basic & GiNaC::ex::construct_from_long( long i ) -->
+  <function name="GiNaC::ex::construct_from_long">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="basic &amp;"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- basic & GiNaC::ex::construct_from_longlong( long long i ) -->
+  <function name="GiNaC::ex::construct_from_longlong">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="basic &amp;"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- basic & GiNaC::ex::construct_from_uint( unsigned int i ) -->
+  <function name="GiNaC::ex::construct_from_uint">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="basic &amp;"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- basic & GiNaC::ex::construct_from_ulong( unsigned long i ) -->
+  <function name="GiNaC::ex::construct_from_ulong">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="basic &amp;"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- basic & GiNaC::ex::construct_from_ulonglong( unsigned long long i ) -->
+  <function name="GiNaC::ex::construct_from_ulonglong">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="basic &amp;"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::ex::content( const ex & x ) const -->
+  <function name="GiNaC::ex::content">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::ex::dbgprint( void ) const -->
+  <function name="GiNaC::ex::dbgprint">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+  </function>
+  <!-- void GiNaC::ex::dbgprinttree( void ) const -->
+  <function name="GiNaC::ex::dbgprinttree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+  </function>
+  <!-- int GiNaC::ex::degree( const ex & s ) -->
+  <function name="GiNaC::ex::degree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::ex::denom( void ) const -->
+  <function name="GiNaC::ex::denom">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::ex::diff( const symbol & s, unsigned nth = 1 ) const -->
+  <function name="GiNaC::ex::diff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::ex::eval( void ) -->
+  <function name="GiNaC::ex::eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::ex::eval_integ( void ) -->
+  <function name="GiNaC::ex::eval_integ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::ex::eval_ncmul( const exvector & v ) -->
+  <function name="GiNaC::ex::eval_ncmul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::ex::evalf( void ) -->
+  <function name="GiNaC::ex::evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::ex::evalm( void ) -->
+  <function name="GiNaC::ex::evalm">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::ex::expand( unsigned options = 0 ) const -->
+  <function name="GiNaC::ex::expand">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool GiNaC::ex::find( const ex & pattern, exset & found ) const -->
+  <function name="GiNaC::ex::find">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- exvector GiNaC::ex::get_free_indices( void ) -->
+  <function name="GiNaC::ex::get_free_indices">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="exvector"/>
+    <use-retval/>
+  </function>
+  <!-- unsigned GiNaC::ex::gethash( void ) -->
+  <function name="GiNaC::ex::gethash">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- bool GiNaC::ex::has( const ex & pattern, unsigned options = 0 ) -->
+  <function name="GiNaC::ex::has">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::ex::imag_part( void ) -->
+  <function name="GiNaC::ex::imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- bool GiNaC::ex::info( unsigned inf ) -->
+  <function name="GiNaC::ex::info">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- numeric GiNaC::ex::integer_content( void ) const -->
+  <function name="GiNaC::ex::integer_content">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="numeric"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::ex::is_a( const ex &  ) -->
+  <function name="GiNaC::ex::is_a">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::ex::is_equal( const ex & other ) const -->
+  <function name="GiNaC::ex::is_equal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::ex::is_exactly_a( const ex &  ) -->
+  <function name="GiNaC::ex::is_exactly_a">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::ex::is_polynomial( const ex & vars ) const -->
+  <function name="GiNaC::ex::is_polynomial">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::ex::is_zero( void ) -->
+  <function name="GiNaC::ex::is_zero">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool GiNaC::ex::is_zero_matrix( void ) const -->
+  <function name="GiNaC::ex::is_zero_matrix">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::ex::lcoeff( const ex & s ) -->
+  <function name="GiNaC::ex::lcoeff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int GiNaC::ex::ldegree( const ex & s ) -->
+  <function name="GiNaC::ex::ldegree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex & GiNaC::ex::let_op( size_t i ) -->
+  <function name="GiNaC::ex::let_op">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex &amp;"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::ex::lhs( void ) const -->
+  <function name="GiNaC::ex::lhs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void GiNaC::ex::makewriteable( void ) -->
+  <function name="GiNaC::ex::makewriteable">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- ex GiNaC::ex::map( map_function & f ) -->
+  <function name="GiNaC::ex::map">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- numeric GiNaC::ex::max_coefficient( void ) const -->
+  <function name="GiNaC::ex::max_coefficient">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="numeric"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- size_t GiNaC::ex::nops( void ) -->
+  <function name="GiNaC::ex::nops">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::ex::normal( void ) const -->
+  <function name="GiNaC::ex::normal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::ex::numer( void ) const -->
+  <function name="GiNaC::ex::numer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::ex::numer_denom( void ) const -->
+  <function name="GiNaC::ex::numer_denom">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::ex::op( size_t i ) -->
+  <function name="GiNaC::ex::op">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const_postorder_iterator GiNaC::ex::postorder_begin( void ) const -->
+  <function name="GiNaC::ex::postorder_begin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const_postorder_iterator"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const_preorder_iterator GiNaC::ex::preorder_begin( void ) const -->
+  <function name="GiNaC::ex::preorder_begin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const_preorder_iterator"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void GiNaC::ex::print( const print_context & c, unsigned level = 0 ) const -->
+  <function name="GiNaC::ex::print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::ex::real_part( void ) -->
+  <function name="GiNaC::ex::real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- unsigned GiNaC::ex::return_type( void ) -->
+  <function name="GiNaC::ex::return_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- return_type_t GiNaC::ex::return_type_tinfo( void ) -->
+  <function name="GiNaC::ex::return_type_tinfo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="return_type_t"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::ex::rhs( void ) const -->
+  <function name="GiNaC::ex::rhs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::ex::series( const ex & r, int order, unsigned options = 0 ) const -->
+  <function name="GiNaC::ex::series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::ex::share( const ex & other ) const -->
+  <function name="GiNaC::ex::share">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::ex::smod( const numeric & xi ) -->
+  <function name="GiNaC::ex::smod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::ex::tcoeff( const ex & s ) -->
+  <function name="GiNaC::ex::tcoeff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::ex::to_polynomial( exmap & repl ) const -->
+  <function name="GiNaC::ex::to_polynomial">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::ex::to_rational( exmap & repl ) const -->
+  <function name="GiNaC::ex::to_rational">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void GiNaC::ex::traverse( visitor & v ) -->
+  <function name="GiNaC::ex::traverse">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void GiNaC::ex::traverse_postorder( visitor & v ) const -->
+  <function name="GiNaC::ex::traverse_postorder">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void GiNaC::ex::traverse_preorder( visitor & v ) const -->
+  <function name="GiNaC::ex::traverse_preorder">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::ex::unit( const ex & x ) const -->
+  <function name="GiNaC::ex::unit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::ex::unitcontprim( const ex & x, ex & u, ex & c, ex & p ) const -->
+  <function name="GiNaC::ex::unitcontprim">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+    <arg nr="4" direction="inout"/>
+  </function>
+  <!-- bool GiNaC::find( const ex & thisex, const ex & pattern, exset & found ) -->
+  <function name="GiNaC::find">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- bool GiNaC::has( const ex & thisex, const ex & pattern, unsigned options = 0 ) -->
+  <function name="GiNaC::has">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::imag_part( const ex & thisex ) -->
+  <function name="GiNaC::imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::is_polynomial( const ex & thisex, const ex & vars ) -->
+  <function name="GiNaC::is_polynomial">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- int GiNaC::ldegree( const ex & thisex, const ex & s ) -->
+  <function name="GiNaC::ldegree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::lhs( const ex & thisex ) -->
+  <function name="GiNaC::lhs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::library_init::init_unarchivers( void ) -->
+  <function name="GiNaC::library_init::init_unarchivers">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+  </function>
+  <!-- bool GiNaC::match( const ex & thisex, const ex & pattern, exmap & repl_lst ) -->
+  <function name="GiNaC::match">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::normal( const ex & thisex ) -->
+  <function name="GiNaC::normal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::numer_denom( const ex & thisex ) -->
+  <function name="GiNaC::numer_denom">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::op( const ex & thisex, size_t i ) -->
+  <function name="GiNaC::op">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::real_part( const ex & thisex ) -->
+  <function name="GiNaC::real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::rhs( const ex & thisex ) -->
+  <function name="GiNaC::rhs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::series( const ex & thisex, const ex & r, int order, unsigned options = 0 ) -->
+  <function name="GiNaC::series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::to_polynomial( const ex & thisex, exmap & repl ) -->
+  <function name="GiNaC::to_polynomial">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::to_rational( const ex & thisex, exmap & repl ) -->
+  <function name="GiNaC::to_rational">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- int ex::compare( const ex & other ) -->
+  <function name="ex::compare">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool ex::is_equal( const ex & other ) -->
+  <function name="ex::is_equal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const_postorder_iterator ex::postorder_begin( void ) -->
+  <function name="ex::postorder_begin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const_postorder_iterator"/>
+    <use-retval/>
+  </function>
+  <!-- const_preorder_iterator ex::preorder_begin( void ) -->
+  <function name="ex::preorder_begin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const_preorder_iterator"/>
+    <use-retval/>
+  </function>
+  <!-- void std::swap( GiNaC::ex & a, GiNaC::ex & b ) -->
+  <function name="std::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- ex ex::subs( const exmap & m, unsigned options ) -->
+  <function name="ex::subs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::Bernoulli_polynomial( const numeric & k, const ex & x ) -->
+  <function name="GiNaC::Bernoulli_polynomial">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::ELi_kernel::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::ELi_kernel::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::Ebar_kernel::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::Ebar_kernel::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::Eisenstein_h_kernel::coefficient_a0( const numeric & k, const numeric & r, const numeric & s, const numeric & N ) const -->
+  <function name="GiNaC::Eisenstein_h_kernel::coefficient_a0">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- ex GiNaC::Eisenstein_h_kernel::coefficient_an( const numeric & n, const numeric & k, const numeric & r, const numeric & s, const numeric & N ) const -->
+  <function name="GiNaC::Eisenstein_h_kernel::coefficient_an">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+    <arg nr="5" direction="in"/>
+  </function>
+  <!-- void GiNaC::Eisenstein_h_kernel::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::Eisenstein_h_kernel::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::Eisenstein_h_kernel::q_expansion_modular_form( const ex & q, int order ) const -->
+  <function name="GiNaC::Eisenstein_h_kernel::q_expansion_modular_form">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::Eisenstein_kernel::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::Eisenstein_kernel::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::Eisenstein_kernel::q_expansion_modular_form( const ex & q, int order ) const -->
+  <function name="GiNaC::Eisenstein_kernel::q_expansion_modular_form">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::Kronecker_dtau_kernel::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::Kronecker_dtau_kernel::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::Kronecker_dz_kernel::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::Kronecker_dz_kernel::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::basic_log_kernel::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::basic_log_kernel::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- numeric GiNaC::dirichlet_character( const numeric & n, const numeric & a, const numeric & N ) -->
+  <function name="GiNaC::dirichlet_character">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="numeric"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- numeric GiNaC::generalised_Bernoulli_number( const numeric & k, const numeric & b ) -->
+  <function name="GiNaC::generalised_Bernoulli_number">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="numeric"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::ifactor( const numeric & n ) -->
+  <function name="GiNaC::ifactor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::integration_kernel::Laurent_series( const ex & x, int order ) const -->
+  <function name="GiNaC::integration_kernel::Laurent_series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::integration_kernel::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::integration_kernel::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- size_t GiNaC::integration_kernel::get_cache_size( void ) const -->
+  <function name="GiNaC::integration_kernel::get_cache_size">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::integration_kernel::get_numerical_value( const ex & lambda, int N_trunc = 0 ) const -->
+  <function name="GiNaC::integration_kernel::get_numerical_value">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::integration_kernel::get_numerical_value_impl( const ex & lambda, const ex & pre, int shift, int N_trunc ) const -->
+  <function name="GiNaC::integration_kernel::get_numerical_value_impl">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::integration_kernel::get_series_coeff( int i ) const -->
+  <function name="GiNaC::integration_kernel::get_series_coeff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool GiNaC::integration_kernel::has_trailing_zero( void ) const -->
+  <function name="GiNaC::integration_kernel::has_trailing_zero">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::integration_kernel::is_numeric( void ) const -->
+  <function name="GiNaC::integration_kernel::is_numeric">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- cln::cl_N GiNaC::integration_kernel::series_coeff( int i ) const -->
+  <function name="GiNaC::integration_kernel::series_coeff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- cln::cl_N GiNaC::integration_kernel::series_coeff_impl( int i ) const -->
+  <function name="GiNaC::integration_kernel::series_coeff_impl">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::integration_kernel::set_cache_step( int cache_steps ) const -->
+  <function name="GiNaC::integration_kernel::set_cache_step">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool GiNaC::integration_kernel::uses_Laurent_series( void ) const -->
+  <function name="GiNaC::integration_kernel::uses_Laurent_series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::is_discriminant_of_quadratic_number_field( const numeric & n ) -->
+  <function name="GiNaC::is_discriminant_of_quadratic_number_field">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- numeric GiNaC::kronecker_symbol( const numeric & a, const numeric & n ) -->
+  <function name="GiNaC::kronecker_symbol">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="numeric"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::modular_form_kernel::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::modular_form_kernel::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::modular_form_kernel::q_expansion_modular_form( const ex & q, int order ) const -->
+  <function name="GiNaC::modular_form_kernel::q_expansion_modular_form">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::multiple_polylog_kernel::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::multiple_polylog_kernel::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- numeric GiNaC::primitive_dirichlet_character( const numeric & n, const numeric & a ) -->
+  <function name="GiNaC::primitive_dirichlet_character">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="numeric"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::user_defined_kernel::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::user_defined_kernel::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::expand_dummy_sum( const ex & e, bool subs_idx = false ) -->
+  <function name="GiNaC::expand_dummy_sum">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- exvector GiNaC::get_all_dummy_indices( const ex & e ) -->
+  <function name="GiNaC::get_all_dummy_indices">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="exvector"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- exvector GiNaC::get_all_dummy_indices_safely( const ex & e ) -->
+  <function name="GiNaC::get_all_dummy_indices_safely">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="exvector"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::indexed::all_index_values_are( unsigned inf ) const -->
+  <function name="GiNaC::indexed::all_index_values_are">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::indexed::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::indexed::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::indexed::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::indexed::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::indexed::do_print_tree( const print_tree & c, unsigned level ) const -->
+  <function name="GiNaC::indexed::do_print_tree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- exvector GiNaC::indexed::get_indices( void ) const -->
+  <function name="GiNaC::indexed::get_indices">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="exvector"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::indexed::get_symmetry( void ) -->
+  <function name="GiNaC::indexed::get_symmetry">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- bool GiNaC::indexed::has_dummy_index_for( const ex & i ) const -->
+  <function name="GiNaC::indexed::has_dummy_index_for">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::indexed::print_indexed( const print_context & c, const char * openbrace, const char * closebrace, unsigned level ) const -->
+  <function name="GiNaC::indexed::print_indexed">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::indexed::printindices( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::indexed::printindices">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool GiNaC::indexed::reposition_dummy_indices( ex & e, exvector & variant_dummy_indices, exvector & moved_indices ) -->
+  <function name="GiNaC::indexed::reposition_dummy_indices">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::indexed::simplify_indexed( const ex & e, exvector & free_indices, exvector & dummy_indices, const scalar_products & sp ) -->
+  <function name="GiNaC::indexed::simplify_indexed">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- ex GiNaC::indexed::simplify_indexed_product( const ex & e, exvector & free_indices, exvector & dummy_indices, const scalar_products & sp ) -->
+  <function name="GiNaC::indexed::simplify_indexed_product">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- void GiNaC::indexed::validate( void ) const -->
+  <function name="GiNaC::indexed::validate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+  </function>
+  <!-- void GiNaC::scalar_products::clear( void ) -->
+  <function name="GiNaC::scalar_products::clear">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GiNaC::scalar_products::debugprint( void ) const -->
+  <function name="GiNaC::scalar_products::debugprint">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::scalar_products::evaluate( const ex & v1, const ex & v2, const ex & dim ) const -->
+  <function name="GiNaC::scalar_products::evaluate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- bool GiNaC::scalar_products::is_defined( const ex & v1, const ex & v2, const ex & dim ) const -->
+  <function name="GiNaC::scalar_products::is_defined">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void GiNaC::spmapkey::debugprint( void ) const -->
+  <function name="GiNaC::spmapkey::debugprint">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+  </function>
+  <!-- archive_node_id GiNaC::archive::add_node( const archive_node & n ) -->
+  <function name="GiNaC::archive::add_node">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="archive_node_id"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::archive::archive_ex( const ex & e, const char * name ) -->
+  <function name="GiNaC::archive::archive_ex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- archive_atom GiNaC::archive::atomize( const std::string & s ) const -->
+  <function name="GiNaC::archive::atomize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="archive_atom"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::archive::clear( void ) -->
+  <function name="GiNaC::archive::clear">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GiNaC::archive::forget( void ) -->
+  <function name="GiNaC::archive::forget">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- archive_node & GiNaC::archive::get_node( archive_node_id id ) -->
+  <function name="GiNaC::archive::get_node">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="archive_node &amp;"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const archive_node & GiNaC::archive::get_top_node( unsigned index = 0 ) const -->
+  <function name="GiNaC::archive::get_top_node">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const archive_node &amp;"/>
+    <const/>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- unsigned GiNaC::archive::num_expressions( void ) const -->
+  <function name="GiNaC::archive::num_expressions">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void GiNaC::archive::printraw( std::ostream & os ) const -->
+  <function name="GiNaC::archive::printraw">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- const std::string & GiNaC::archive::unatomize( archive_atom id ) const -->
+  <function name="GiNaC::archive::unatomize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const std::string &amp;"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::archive_node::add_bool( const std::string & name, bool value ) -->
+  <function name="GiNaC::archive_node::add_bool">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void GiNaC::archive_node::add_ex( const std::string & name, const ex & value ) -->
+  <function name="GiNaC::archive_node::add_ex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::archive_node::add_string( const std::string & name, const std::string & value ) -->
+  <function name="GiNaC::archive_node::add_string">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::archive_node::add_unsigned( const std::string & name, unsigned value ) -->
+  <function name="GiNaC::archive_node::add_unsigned">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool GiNaC::archive_node::find_bool( const std::string & name, bool & ret, unsigned index = 0 ) const -->
+  <function name="GiNaC::archive_node::find_bool">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool GiNaC::archive_node::find_ex( const std::string & name, ex & ret, lst & sym_lst, unsigned index = 0 ) const -->
+  <function name="GiNaC::archive_node::find_ex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+    <arg nr="4" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::archive_node::find_ex_by_loc( archive_node_cit loc, ex & ret, lst & sym_lst ) const -->
+  <function name="GiNaC::archive_node::find_ex_by_loc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- const archive_node & GiNaC::archive_node::find_ex_node( const std::string & name, unsigned index = 0 ) const -->
+  <function name="GiNaC::archive_node::find_ex_node">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const archive_node &amp;"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- archive_node_cit GiNaC::archive_node::find_first( const std::string & name ) const -->
+  <function name="GiNaC::archive_node::find_first">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="archive_node_cit"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- archive_node_cit GiNaC::archive_node::find_last( const std::string & name ) const -->
+  <function name="GiNaC::archive_node::find_last">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="archive_node_cit"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- archive_node_cit_range GiNaC::archive_node::find_property_range( const std::string & name1, const std::string & name2 ) const -->
+  <function name="GiNaC::archive_node::find_property_range">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="archive_node_cit_range"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool GiNaC::archive_node::find_string( const std::string & name, std::string & ret, unsigned index = 0 ) const -->
+  <function name="GiNaC::archive_node::find_string">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool GiNaC::archive_node::find_unsigned( const std::string & name, unsigned & ret, unsigned index = 0 ) const -->
+  <function name="GiNaC::archive_node::find_unsigned">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::archive_node::forget( void ) -->
+  <function name="GiNaC::archive_node::forget">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- ex GiNaC::archive_node::get_ex( void ) -->
+  <function name="GiNaC::archive_node::get_ex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- void GiNaC::archive_node::get_properties( propinfovector & v ) const -->
+  <function name="GiNaC::archive_node::get_properties">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool GiNaC::archive_node::has_ex( void ) -->
+  <function name="GiNaC::archive_node::has_ex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool GiNaC::archive_node::has_same_ex_as( const archive_node & other ) const -->
+  <function name="GiNaC::archive_node::has_same_ex_as">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::archive_node::printraw( std::ostream & os ) const -->
+  <function name="GiNaC::archive_node::printraw">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::archive_node::unarchive( lst & sym_lst ) const -->
+  <function name="GiNaC::archive_node::unarchive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- synthesize_func GiNaC::unarchive_table_t::find( const std::string & classname ) const -->
+  <function name="GiNaC::unarchive_table_t::find">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="synthesize_func"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::unarchive_table_t::insert( const std::string & classname, synthesize_func f ) -->
+  <function name="GiNaC::unarchive_table_t::insert">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- size_t GiNaC::count_dummy_indices( const exvector & v ) -->
+  <function name="GiNaC::count_dummy_indices">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- size_t GiNaC::count_free_indices( const exvector & v ) -->
+  <function name="GiNaC::count_free_indices">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::find_dummy_indices( const exvector & v, exvector & out_dummy ) -->
+  <function name="GiNaC::find_dummy_indices">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void GiNaC::idx::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::idx::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::idx::do_print_csrc( const print_csrc & c, unsigned level ) const -->
+  <function name="GiNaC::idx::do_print_csrc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::idx::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::idx::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::idx::do_print_tree( const print_tree & c, unsigned level ) const -->
+  <function name="GiNaC::idx::do_print_tree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::idx::get_dim( void ) -->
+  <function name="GiNaC::idx::get_dim">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::idx::get_value( void ) -->
+  <function name="GiNaC::idx::get_value">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- bool GiNaC::idx::is_dim_numeric( void ) -->
+  <function name="GiNaC::idx::is_dim_numeric">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool GiNaC::idx::is_dim_symbolic( void ) -->
+  <function name="GiNaC::idx::is_dim_symbolic">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool GiNaC::idx::is_dummy_pair_same_type( const basic & other ) const -->
+  <function name="GiNaC::idx::is_dummy_pair_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::idx::is_numeric( void ) -->
+  <function name="GiNaC::idx::is_numeric">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool GiNaC::idx::is_symbolic( void ) -->
+  <function name="GiNaC::idx::is_symbolic">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::idx::minimal_dim( const idx & other ) const -->
+  <function name="GiNaC::idx::minimal_dim">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::idx::print_index( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::idx::print_index">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::idx::replace_dim( const ex & new_dim ) const -->
+  <function name="GiNaC::idx::replace_dim">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::minimal_dim( const ex & dim1, const ex & dim2 ) -->
+  <function name="GiNaC::minimal_dim">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::spinidx::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::spinidx::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::spinidx::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::spinidx::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::spinidx::do_print_tree( const print_tree & c, unsigned level ) const -->
+  <function name="GiNaC::spinidx::do_print_tree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool GiNaC::spinidx::is_dotted( void ) -->
+  <function name="GiNaC::spinidx::is_dotted">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool GiNaC::spinidx::is_undotted( void ) -->
+  <function name="GiNaC::spinidx::is_undotted">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::spinidx::toggle_dot( void ) const -->
+  <function name="GiNaC::spinidx::toggle_dot">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::spinidx::toggle_variance_dot( void ) const -->
+  <function name="GiNaC::spinidx::toggle_variance_dot">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void GiNaC::varidx::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::varidx::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::varidx::do_print_tree( const print_tree & c, unsigned level ) const -->
+  <function name="GiNaC::varidx::do_print_tree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool GiNaC::varidx::is_contravariant( void ) -->
+  <function name="GiNaC::varidx::is_contravariant">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool GiNaC::varidx::is_covariant( void ) -->
+  <function name="GiNaC::varidx::is_covariant">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::varidx::toggle_variance( void ) const -->
+  <function name="GiNaC::varidx::toggle_variance">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool GiNaC::haswild( const ex & x ) -->
+  <function name="GiNaC::haswild">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::wild( unsigned label = 0 ) -->
+  <function name="GiNaC::wild">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::wildcard::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::wildcard::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::wildcard::do_print_python_repr( const print_python_repr & c, unsigned level ) const -->
+  <function name="GiNaC::wildcard::do_print_python_repr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::wildcard::do_print_tree( const print_tree & c, unsigned level ) const -->
+  <function name="GiNaC::wildcard::do_print_tree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- unsigned GiNaC::wildcard::get_label( void ) -->
+  <function name="GiNaC::wildcard::get_label">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::charpoly( const matrix & m, const ex & lambda ) -->
+  <function name="GiNaC::charpoly">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- unsigned GiNaC::cols( const matrix & m ) -->
+  <function name="GiNaC::cols">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::determinant( const matrix & m, unsigned options = determinant_algo::automatic ) -->
+  <function name="GiNaC::determinant">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="determinant_algo::automatic" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::lst_to_matrix( const lst & l ) -->
+  <function name="GiNaC::lst_to_matrix">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- matrix GiNaC::matrix::add( const matrix & other ) const -->
+  <function name="GiNaC::matrix::add">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="matrix"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::matrix::charpoly( const ex & lambda ) const -->
+  <function name="GiNaC::matrix::charpoly">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- unsigned GiNaC::matrix::cols( void ) -->
+  <function name="GiNaC::matrix::cols">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::matrix::determinant( unsigned algo = determinant_algo::automatic ) const -->
+  <function name="GiNaC::matrix::determinant">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <const/>
+    <arg nr="1" default="determinant_algo::automatic" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::matrix::determinant_minor( void ) const -->
+  <function name="GiNaC::matrix::determinant_minor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- int GiNaC::matrix::division_free_elimination( const bool det = false ) -->
+  <function name="GiNaC::matrix::division_free_elimination">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void GiNaC::matrix::do_print( const print_context & c, unsigned level ) const -->
+  <function name="GiNaC::matrix::do_print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::matrix::do_print_latex( const print_latex & c, unsigned level ) const -->
+  <function name="GiNaC::matrix::do_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GiNaC::matrix::do_print_python_repr( const print_python_repr & c, unsigned level ) const -->
+  <function name="GiNaC::matrix::do_print_python_repr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int GiNaC::matrix::fraction_free_elimination( const bool det = false ) -->
+  <function name="GiNaC::matrix::fraction_free_elimination">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int GiNaC::matrix::gauss_elimination( const bool det = false ) -->
+  <function name="GiNaC::matrix::gauss_elimination">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool GiNaC::matrix::is_zero_matrix( void ) const -->
+  <function name="GiNaC::matrix::is_zero_matrix">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- matrix GiNaC::matrix::mul_scalar( const ex & other ) const -->
+  <function name="GiNaC::matrix::mul_scalar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="matrix"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int GiNaC::matrix::pivot( unsigned ro, unsigned co, bool symbolic = true ) -->
+  <function name="GiNaC::matrix::pivot">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- matrix GiNaC::matrix::pow( const ex & expn ) const -->
+  <function name="GiNaC::matrix::pow">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="matrix"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::matrix::print_elements( const print_context & c, const char * row_start, const char * row_end, const char * row_sep, const char * col_sep ) const -->
+  <function name="GiNaC::matrix::print_elements">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- unsigned GiNaC::matrix::rows( void ) -->
+  <function name="GiNaC::matrix::rows">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- matrix & GiNaC::matrix::set( unsigned ro, unsigned co, const ex & value ) -->
+  <function name="GiNaC::matrix::set">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="matrix &amp;"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- matrix GiNaC::matrix::sub( const matrix & other ) const -->
+  <function name="GiNaC::matrix::sub">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="matrix"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::matrix::trace( void ) const -->
+  <function name="GiNaC::matrix::trace">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- matrix GiNaC::matrix::transpose( void ) const -->
+  <function name="GiNaC::matrix::transpose">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="matrix"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- ex GiNaC::reduced_matrix( const matrix & m, unsigned r, unsigned c ) -->
+  <function name="GiNaC::reduced_matrix">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- unsigned GiNaC::rows( const matrix & m ) -->
+  <function name="GiNaC::rows">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::sub_matrix( const matrix & m, unsigned r, unsigned nr, unsigned c, unsigned nc ) -->
+  <function name="GiNaC::sub_matrix">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::trace( const matrix & m ) -->
+  <function name="GiNaC::trace">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- matrix GiNaC::transpose( const matrix & m ) -->
+  <function name="GiNaC::transpose">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="matrix"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wildcard::archive( archive_node & n ) -->
+  <function name="wildcard::archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- unsigned wildcard::calchash( void ) -->
+  <function name="wildcard::calchash">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- int wildcard::compare_same_type( const basic & other ) -->
+  <function name="wildcard::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wildcard::match( const ex & pattern, exmap & repl_lst ) -->
+  <function name="wildcard::match">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void wildcard::read_archive( const archive_node & n, lst & sym_lst ) -->
+  <function name="wildcard::read_archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- int pole_error::degree( void ) -->
+  <function name="pole_error::degree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- void library_init::init_unarchivers( void ) -->
+  <function name="library_init::init_unarchivers">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GiNaC::base_and_index( const ex & c, ex & b, ex & i ) -->
+  <function name="GiNaC::base_and_index">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::get_clifford_comp( const ex & e, const ex & c, bool root = true ) -->
+  <function name="GiNaC::get_clifford_comp">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- unsigned GiNaC::get_dim_uint( const ex & e ) -->
+  <function name="GiNaC::get_dim_uint">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::is_dirac_slash( const ex & seq0 ) -->
+  <function name="GiNaC::is_dirac_slash">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::trace_string( exvector::const_iterator ix, size_t num ) -->
+  <function name="GiNaC::trace_string">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void clifford::archive( archive_node & n ) -->
+  <function name="clifford::archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- int clifford::compare_same_type( const basic & other ) -->
+  <function name="clifford::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex diracgamma5::conjugate( void ) -->
+  <function name="diracgamma5::conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- bool diracgamma::contract_with( exvector::iterator self, exvector::iterator other, exvector & v ) -->
+  <function name="diracgamma::contract_with">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- ex clifford::eval_ncmul( const exvector & v ) -->
+  <function name="clifford::eval_ncmul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex & clifford::let_op( size_t i ) -->
+  <function name="clifford::let_op">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex &amp;"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool clifford::match_same_type( const basic & other ) -->
+  <function name="clifford::match_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex clifford::op( size_t i ) -->
+  <function name="clifford::op">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void clifford::read_archive( const archive_node & n, lst & sym_lst ) -->
+  <function name="clifford::read_archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- return_type_t clifford::return_type_tinfo( void ) -->
+  <function name="clifford::return_type_tinfo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="return_type_t"/>
+    <use-retval/>
+  </function>
+  <!-- ex clifford::subs( const exmap & m, unsigned options ) -->
+  <function name="clifford::subs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex clifford::thiscontainer( const exvector & v ) -->
+  <function name="clifford::thiscontainer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::divide_in_z_p( const ex & a, const ex & b, ex & q, const exvector & vars, const long p ) -->
+  <function name="GiNaC::divide_in_z_p">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+    <arg nr="4" direction="in"/>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::pgcd( const ex & A, const ex & B, const exvector & vars, const long p ) -->
+  <function name="GiNaC::pgcd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool GiNaC::heur_gcd_z( upoly & g, const upoly & a, const upoly & b ) -->
+  <function name="GiNaC::heur_gcd_z">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void GiNaC::collect_vargs( ex_collect_t & ec, const ex & e, const exvector & vars ) -->
+  <function name="GiNaC::collect_vargs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void GiNaC::wipe_out_zeros( ex_collect_priv_t & m ) -->
+  <function name="GiNaC::wipe_out_zeros">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void GiNaC::find_next_prime( cln::cl_I & p, const cln::cl_I & g ) -->
+  <function name="GiNaC::find_next_prime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::remove_content( upoly & A, upoly & B, upoly::value_type & c ) -->
+  <function name="GiNaC::remove_content">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void GiNaC::__anon1::add_symbol( const ex & s, sym_desc_vec & v ) -->
+  <function name="GiNaC::__anon1::add_symbol">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void GiNaC::__anon1::collect_symbols( const ex & e, sym_desc_vec & v ) -->
+  <function name="GiNaC::__anon1::collect_symbols">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void GiNaC::__anon1::get_symbol_stats( const ex & a, const ex & b, sym_desc_vec & v ) -->
+  <function name="GiNaC::__anon1::get_symbol_stats">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- cln::cl_I GiNaC::extract_integer_content( ex & Apr, const ex & A ) -->
+  <function name="GiNaC::extract_integer_content">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_I"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void expairseq::archive( archive_node & n ) -->
+  <function name="expairseq::archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- unsigned expairseq::calchash( void ) -->
+  <function name="expairseq::calchash">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- int expairseq::compare_same_type( const basic & other ) -->
+  <function name="expairseq::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex expairseq::conjugate( void ) -->
+  <function name="expairseq::conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex expairseq::eval( void ) -->
+  <function name="expairseq::eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex expairseq::expand( unsigned options ) -->
+  <function name="expairseq::expand">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool expairseq::info( unsigned inf ) -->
+  <function name="expairseq::info">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool expairseq::is_equal_same_type( const basic & other ) -->
+  <function name="expairseq::is_equal_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex expairseq::map( map_function & f ) -->
+  <function name="expairseq::map">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool expairseq::match( const ex & pattern, exmap & repl_lst ) -->
+  <function name="expairseq::match">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- size_t expairseq::nops( void ) -->
+  <function name="expairseq::nops">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <use-retval/>
+  </function>
+  <!-- ex expairseq::op( size_t i ) -->
+  <function name="expairseq::op">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void expairseq::printpair( const print_context & c, const expair & p, unsigned upper_precedence ) -->
+  <function name="expairseq::printpair">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void expairseq::read_archive( const archive_node & n, lst & sym_lst ) -->
+  <function name="expairseq::read_archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- unsigned expairseq::return_type( void ) -->
+  <function name="expairseq::return_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- ex expairseq::subs( const exmap & m, unsigned options ) -->
+  <function name="expairseq::subs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::acos_conjugate( const ex & x ) -->
+  <function name="GiNaC::acos_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::acos_deriv( const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::acos_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::acos_eval( const ex & x ) -->
+  <function name="GiNaC::acos_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::acos_evalf( const ex & x ) -->
+  <function name="GiNaC::acos_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::acosh_conjugate( const ex & x ) -->
+  <function name="GiNaC::acosh_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::acosh_deriv( const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::acosh_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::acosh_eval( const ex & x ) -->
+  <function name="GiNaC::acosh_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::acosh_evalf( const ex & x ) -->
+  <function name="GiNaC::acosh_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::asin_conjugate( const ex & x ) -->
+  <function name="GiNaC::asin_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::asin_deriv( const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::asin_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::asin_eval( const ex & x ) -->
+  <function name="GiNaC::asin_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::asin_evalf( const ex & x ) -->
+  <function name="GiNaC::asin_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::asinh_conjugate( const ex & x ) -->
+  <function name="GiNaC::asinh_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::asinh_deriv( const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::asinh_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::asinh_eval( const ex & x ) -->
+  <function name="GiNaC::asinh_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::asinh_evalf( const ex & x ) -->
+  <function name="GiNaC::asinh_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::atan2_deriv( const ex & y, const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::atan2_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::atan2_eval( const ex & y, const ex & x ) -->
+  <function name="GiNaC::atan2_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::atan2_evalf( const ex & y, const ex & x ) -->
+  <function name="GiNaC::atan2_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::atan_conjugate( const ex & x ) -->
+  <function name="GiNaC::atan_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::atan_deriv( const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::atan_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::atan_eval( const ex & x ) -->
+  <function name="GiNaC::atan_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::atan_evalf( const ex & x ) -->
+  <function name="GiNaC::atan_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::atanh_conjugate( const ex & x ) -->
+  <function name="GiNaC::atanh_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::atanh_deriv( const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::atanh_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::atanh_eval( const ex & x ) -->
+  <function name="GiNaC::atanh_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::atanh_evalf( const ex & x ) -->
+  <function name="GiNaC::atanh_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::cos_conjugate( const ex & x ) -->
+  <function name="GiNaC::cos_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::cos_deriv( const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::cos_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::cos_eval( const ex & x ) -->
+  <function name="GiNaC::cos_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::cos_evalf( const ex & x ) -->
+  <function name="GiNaC::cos_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::cos_imag_part( const ex & x ) -->
+  <function name="GiNaC::cos_imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::cos_real_part( const ex & x ) -->
+  <function name="GiNaC::cos_real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::cosh_conjugate( const ex & x ) -->
+  <function name="GiNaC::cosh_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::cosh_deriv( const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::cosh_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::cosh_eval( const ex & x ) -->
+  <function name="GiNaC::cosh_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::cosh_evalf( const ex & x ) -->
+  <function name="GiNaC::cosh_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::cosh_imag_part( const ex & x ) -->
+  <function name="GiNaC::cosh_imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::cosh_real_part( const ex & x ) -->
+  <function name="GiNaC::cosh_real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::exp_conjugate( const ex & x ) -->
+  <function name="GiNaC::exp_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::exp_deriv( const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::exp_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::exp_eval( const ex & x ) -->
+  <function name="GiNaC::exp_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::exp_evalf( const ex & x ) -->
+  <function name="GiNaC::exp_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::exp_expand( const ex & arg, unsigned options ) -->
+  <function name="GiNaC::exp_expand">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::exp_imag_part( const ex & x ) -->
+  <function name="GiNaC::exp_imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::exp_power( const ex & x, const ex & a ) -->
+  <function name="GiNaC::exp_power">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::exp_real_part( const ex & x ) -->
+  <function name="GiNaC::exp_real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::log_conjugate( const ex & x ) -->
+  <function name="GiNaC::log_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::log_deriv( const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::log_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::log_eval( const ex & x ) -->
+  <function name="GiNaC::log_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::log_evalf( const ex & x ) -->
+  <function name="GiNaC::log_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::log_expand( const ex & arg, unsigned options ) -->
+  <function name="GiNaC::log_expand">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::log_imag_part( const ex & x ) -->
+  <function name="GiNaC::log_imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::log_real_part( const ex & x ) -->
+  <function name="GiNaC::log_real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::sin_conjugate( const ex & x ) -->
+  <function name="GiNaC::sin_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::sin_deriv( const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::sin_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::sin_eval( const ex & x ) -->
+  <function name="GiNaC::sin_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::sin_evalf( const ex & x ) -->
+  <function name="GiNaC::sin_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::sin_imag_part( const ex & x ) -->
+  <function name="GiNaC::sin_imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::sin_real_part( const ex & x ) -->
+  <function name="GiNaC::sin_real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::sinh_conjugate( const ex & x ) -->
+  <function name="GiNaC::sinh_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::sinh_deriv( const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::sinh_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::sinh_eval( const ex & x ) -->
+  <function name="GiNaC::sinh_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::sinh_evalf( const ex & x ) -->
+  <function name="GiNaC::sinh_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::sinh_imag_part( const ex & x ) -->
+  <function name="GiNaC::sinh_imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::sinh_real_part( const ex & x ) -->
+  <function name="GiNaC::sinh_real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::tan_conjugate( const ex & x ) -->
+  <function name="GiNaC::tan_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::tan_deriv( const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::tan_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::tan_eval( const ex & x ) -->
+  <function name="GiNaC::tan_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::tan_evalf( const ex & x ) -->
+  <function name="GiNaC::tan_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::tan_imag_part( const ex & x ) -->
+  <function name="GiNaC::tan_imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::tan_real_part( const ex & x ) -->
+  <function name="GiNaC::tan_real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::tanh_conjugate( const ex & x ) -->
+  <function name="GiNaC::tanh_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::tanh_deriv( const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::tanh_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::tanh_eval( const ex & x ) -->
+  <function name="GiNaC::tanh_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::tanh_evalf( const ex & x ) -->
+  <function name="GiNaC::tanh_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::tanh_imag_part( const ex & x ) -->
+  <function name="GiNaC::tanh_imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::tanh_real_part( const ex & x ) -->
+  <function name="GiNaC::tanh_real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int GiNaC::get_tok_prec( const int c ) -->
+  <function name="GiNaC::get_tok_prec">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool GiNaC::is_binop( const int c ) -->
+  <function name="GiNaC::is_binop">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::make_binop_expr( const int binop, const exvector & args ) -->
+  <function name="GiNaC::make_binop_expr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::make_divide_expr( const exvector & args ) -->
+  <function name="GiNaC::make_divide_expr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::make_minus_expr( const exvector & args ) -->
+  <function name="GiNaC::make_minus_expr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex parser::parse_binop_rhs( int expr_prec, ex & lhs ) -->
+  <function name="parser::parse_binop_rhs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- bool GiNaC::decode_serial( unsigned & serial, const reader_func ptr ) -->
+  <function name="GiNaC::decode_serial">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::dispatch_reader_fcn( const reader_func ptr, const exvector & args ) -->
+  <function name="GiNaC::dispatch_reader_fcn">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- reader_func GiNaC::encode_serial_as_reader_func( unsigned serial ) -->
+  <function name="GiNaC::encode_serial_as_reader_func">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="reader_func"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- const prototype_table & GiNaC::get_builtin_reader( void ) -->
+  <function name="GiNaC::get_builtin_reader">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const prototype_table &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const prototype_table & GiNaC::get_default_reader( void ) -->
+  <function name="GiNaC::get_default_reader">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const prototype_table &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- ex GiNaC::lst_reader( const exvector & ev ) -->
+  <function name="GiNaC::lst_reader">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::pow_reader( const exvector & ev ) -->
+  <function name="GiNaC::pow_reader">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::power_reader( const exvector & ev ) -->
+  <function name="GiNaC::power_reader">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const std::vector<function_options> & GiNaC::registered_functions_hack::get_registered_functions( void ) -->
+  <function name="GiNaC::registered_functions_hack::get_registered_functions">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <pure/>
+  </function>
+  <!-- ex GiNaC::sqrt_reader( const exvector & ev ) -->
+  <function name="GiNaC::sqrt_reader">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- std::string GiNaC::get_symbol_name( const ex & s ) -->
+  <function name="GiNaC::get_symbol_name">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="std::string"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- symtab GiNaC::make_symtab( const ex & l ) -->
+  <function name="GiNaC::make_symtab">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="symtab"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::literal_p( const std::string & name ) -->
+  <function name="GiNaC::literal_p">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int GiNaC::skipline( std::istream * s ) -->
+  <function name="GiNaC::skipline">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- int GiNaC::skipspace( std::istream * s, int c, std::size_t & line ) -->
+  <function name="GiNaC::skipspace">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::Li2_conjugate( const ex & x ) -->
+  <function name="GiNaC::Li2_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::Li2_deriv( const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::Li2_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::Li2_eval( const ex & x ) -->
+  <function name="GiNaC::Li2_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::Li2_evalf( const ex & x ) -->
+  <function name="GiNaC::Li2_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::Li2_series( const ex & x, const relational & rel, int order, unsigned options ) -->
+  <function name="GiNaC::Li2_series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::Li3_eval( const ex & x ) -->
+  <function name="GiNaC::Li3_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::Order_conjugate( const ex & x ) -->
+  <function name="GiNaC::Order_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::Order_eval( const ex & x ) -->
+  <function name="GiNaC::Order_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::Order_expl_derivative( const ex & arg, const symbol & s ) -->
+  <function name="GiNaC::Order_expl_derivative">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::Order_imag_part( const ex & x ) -->
+  <function name="GiNaC::Order_imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::Order_real_part( const ex & x ) -->
+  <function name="GiNaC::Order_real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::Order_series( const ex & x, const relational & r, int order, unsigned options ) -->
+  <function name="GiNaC::Order_series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::abs_conjugate( const ex & arg ) -->
+  <function name="GiNaC::abs_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::abs_eval( const ex & arg ) -->
+  <function name="GiNaC::abs_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::abs_evalf( const ex & arg ) -->
+  <function name="GiNaC::abs_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::abs_expand( const ex & arg, unsigned options ) -->
+  <function name="GiNaC::abs_expand">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::abs_expl_derivative( const ex & arg, const symbol & s ) -->
+  <function name="GiNaC::abs_expl_derivative">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::abs_imag_part( const ex & arg ) -->
+  <function name="GiNaC::abs_imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::abs_info( const ex & arg, unsigned inf ) -->
+  <function name="GiNaC::abs_info">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::abs_power( const ex & arg, const ex & exp ) -->
+  <function name="GiNaC::abs_power">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::abs_print_csrc_float( const ex & arg, const print_context & c ) -->
+  <function name="GiNaC::abs_print_csrc_float">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::abs_print_latex( const ex & arg, const print_context & c ) -->
+  <function name="GiNaC::abs_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::abs_real_part( const ex & arg ) -->
+  <function name="GiNaC::abs_real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::binomial_conjugate( const ex & x, const ex & y ) -->
+  <function name="GiNaC::binomial_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::binomial_eval( const ex & x, const ex & y ) -->
+  <function name="GiNaC::binomial_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::binomial_evalf( const ex & x, const ex & y ) -->
+  <function name="GiNaC::binomial_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::binomial_imag_part( const ex & x, const ex & y ) -->
+  <function name="GiNaC::binomial_imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::binomial_real_part( const ex & x, const ex & y ) -->
+  <function name="GiNaC::binomial_real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::binomial_sym( const ex & x, const numeric & y ) -->
+  <function name="GiNaC::binomial_sym">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::conjugate_conjugate( const ex & arg ) -->
+  <function name="GiNaC::conjugate_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::conjugate_eval( const ex & arg ) -->
+  <function name="GiNaC::conjugate_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::conjugate_evalf( const ex & arg ) -->
+  <function name="GiNaC::conjugate_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::conjugate_expl_derivative( const ex & arg, const symbol & s ) -->
+  <function name="GiNaC::conjugate_expl_derivative">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::conjugate_imag_part( const ex & arg ) -->
+  <function name="GiNaC::conjugate_imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::conjugate_info( const ex & arg, unsigned inf ) -->
+  <function name="GiNaC::conjugate_info">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void GiNaC::conjugate_print_latex( const ex & arg, const print_context & c ) -->
+  <function name="GiNaC::conjugate_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::conjugate_real_part( const ex & arg ) -->
+  <function name="GiNaC::conjugate_real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::csgn_conjugate( const ex & arg ) -->
+  <function name="GiNaC::csgn_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::csgn_eval( const ex & arg ) -->
+  <function name="GiNaC::csgn_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::csgn_evalf( const ex & arg ) -->
+  <function name="GiNaC::csgn_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::csgn_imag_part( const ex & arg ) -->
+  <function name="GiNaC::csgn_imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::csgn_power( const ex & arg, const ex & exp ) -->
+  <function name="GiNaC::csgn_power">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::csgn_real_part( const ex & arg ) -->
+  <function name="GiNaC::csgn_real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::eta_conjugate( const ex & x, const ex & y ) -->
+  <function name="GiNaC::eta_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::eta_eval( const ex & x, const ex & y ) -->
+  <function name="GiNaC::eta_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::eta_evalf( const ex & x, const ex & y ) -->
+  <function name="GiNaC::eta_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::eta_imag_part( const ex & x, const ex & y ) -->
+  <function name="GiNaC::eta_imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::eta_real_part( const ex & x, const ex & y ) -->
+  <function name="GiNaC::eta_real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::factorial_conjugate( const ex & x ) -->
+  <function name="GiNaC::factorial_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::factorial_eval( const ex & x ) -->
+  <function name="GiNaC::factorial_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::factorial_evalf( const ex & x ) -->
+  <function name="GiNaC::factorial_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::factorial_imag_part( const ex & x ) -->
+  <function name="GiNaC::factorial_imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::factorial_print_dflt_latex( const ex & x, const print_context & c ) -->
+  <function name="GiNaC::factorial_print_dflt_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::factorial_real_part( const ex & x ) -->
+  <function name="GiNaC::factorial_real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::func_arg_info( const ex & arg, unsigned inf ) -->
+  <function name="GiNaC::func_arg_info">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::imag_part_conjugate( const ex & arg ) -->
+  <function name="GiNaC::imag_part_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::imag_part_eval( const ex & arg ) -->
+  <function name="GiNaC::imag_part_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::imag_part_evalf( const ex & arg ) -->
+  <function name="GiNaC::imag_part_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::imag_part_expl_derivative( const ex & arg, const symbol & s ) -->
+  <function name="GiNaC::imag_part_expl_derivative">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::imag_part_imag_part( const ex & arg ) -->
+  <function name="GiNaC::imag_part_imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::imag_part_print_latex( const ex & arg, const print_context & c ) -->
+  <function name="GiNaC::imag_part_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::imag_part_real_part( const ex & arg ) -->
+  <function name="GiNaC::imag_part_real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::real_part_conjugate( const ex & arg ) -->
+  <function name="GiNaC::real_part_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::real_part_eval( const ex & arg ) -->
+  <function name="GiNaC::real_part_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::real_part_evalf( const ex & arg ) -->
+  <function name="GiNaC::real_part_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::real_part_expl_derivative( const ex & arg, const symbol & s ) -->
+  <function name="GiNaC::real_part_expl_derivative">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::real_part_imag_part( const ex & arg ) -->
+  <function name="GiNaC::real_part_imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::real_part_print_latex( const ex & arg, const print_context & c ) -->
+  <function name="GiNaC::real_part_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::real_part_real_part( const ex & arg ) -->
+  <function name="GiNaC::real_part_real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::step_conjugate( const ex & arg ) -->
+  <function name="GiNaC::step_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::step_eval( const ex & arg ) -->
+  <function name="GiNaC::step_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::step_evalf( const ex & arg ) -->
+  <function name="GiNaC::step_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::step_imag_part( const ex & arg ) -->
+  <function name="GiNaC::step_imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::step_real_part( const ex & arg ) -->
+  <function name="GiNaC::step_real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::symbolset::has( const ex & e ) -->
+  <function name="GiNaC::symbolset::has">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::symbolset::insert_symbols( const ex & e ) -->
+  <function name="GiNaC::symbolset::insert_symbols">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::zetaderiv_deriv( const ex & n, const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::zetaderiv_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::zetaderiv_eval( const ex & n, const ex & x ) -->
+  <function name="GiNaC::zetaderiv_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::print_sym_pow( const print_context & c, const symbol & x, int exp ) -->
+  <function name="GiNaC::print_sym_pow">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void power::archive( archive_node & n ) -->
+  <function name="power::archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- ex power::coeff( const ex & s, int n ) -->
+  <function name="power::coeff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int power::compare_same_type( const basic & other ) -->
+  <function name="power::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex power::conjugate( void ) -->
+  <function name="power::conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- int power::degree( const ex & s ) -->
+  <function name="power::degree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex power::derivative( const symbol & s ) -->
+  <function name="power::derivative">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex power::eval( void ) -->
+  <function name="power::eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex power::eval_ncmul( const exvector & v ) -->
+  <function name="power::eval_ncmul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex power::evalf( void ) -->
+  <function name="power::evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex power::evalm( void ) -->
+  <function name="power::evalm">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex power::expand( unsigned options ) -->
+  <function name="power::expand">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool power::has( const ex & other, unsigned options ) -->
+  <function name="power::has">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex power::imag_part( void ) -->
+  <function name="power::imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- bool power::info( unsigned inf ) -->
+  <function name="power::info">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool power::is_polynomial( const ex & var ) -->
+  <function name="power::is_polynomial">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int power::ldegree( const ex & s ) -->
+  <function name="power::ldegree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex power::map( map_function & f ) -->
+  <function name="power::map">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- size_t power::nops( void ) -->
+  <function name="power::nops">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <use-retval/>
+  </function>
+  <!-- ex power::op( size_t i ) -->
+  <function name="power::op">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void power::read_archive( const archive_node & n, lst & sym_lst ) -->
+  <function name="power::read_archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- ex power::real_part( void ) -->
+  <function name="power::real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- unsigned power::return_type( void ) -->
+  <function name="power::return_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- return_type_t power::return_type_tinfo( void ) -->
+  <function name="power::return_type_tinfo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="return_type_t"/>
+    <use-retval/>
+  </function>
+  <!-- ex power::subs( const exmap & m, unsigned options ) -->
+  <function name="power::subs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::beta_deriv( const ex & x, const ex & y, unsigned deriv_param ) -->
+  <function name="GiNaC::beta_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::beta_eval( const ex & x, const ex & y ) -->
+  <function name="GiNaC::beta_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::beta_evalf( const ex & x, const ex & y ) -->
+  <function name="GiNaC::beta_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::lgamma_conjugate( const ex & x ) -->
+  <function name="GiNaC::lgamma_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::lgamma_deriv( const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::lgamma_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::lgamma_eval( const ex & x ) -->
+  <function name="GiNaC::lgamma_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::lgamma_evalf( const ex & x ) -->
+  <function name="GiNaC::lgamma_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::psi1_deriv( const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::psi1_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::psi1_eval( const ex & x ) -->
+  <function name="GiNaC::psi1_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::psi1_evalf( const ex & x ) -->
+  <function name="GiNaC::psi1_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::psi2_deriv( const ex & n, const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::psi2_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::psi2_eval( const ex & n, const ex & x ) -->
+  <function name="GiNaC::psi2_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::psi2_evalf( const ex & n, const ex & x ) -->
+  <function name="GiNaC::psi2_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::tgamma_conjugate( const ex & x ) -->
+  <function name="GiNaC::tgamma_conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::tgamma_deriv( const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::tgamma_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::tgamma_eval( const ex & x ) -->
+  <function name="GiNaC::tgamma_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::tgamma_evalf( const ex & x ) -->
+  <function name="GiNaC::tgamma_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- synthesize_func GiNaC::find_factory_fcn( const std::string & name ) -->
+  <function name="GiNaC::find_factory_fcn">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="synthesize_func"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- unsigned GiNaC::read_unsigned( std::istream & is ) -->
+  <function name="GiNaC::read_unsigned">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void GiNaC::write_unsigned( std::ostream & os, unsigned val ) -->
+  <function name="GiNaC::write_unsigned">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void fderivative::archive( archive_node & n ) -->
+  <function name="fderivative::archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- int fderivative::compare_same_type( const basic & other ) -->
+  <function name="fderivative::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex fderivative::derivative( const symbol & s ) -->
+  <function name="fderivative::derivative">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex fderivative::eval( void ) -->
+  <function name="fderivative::eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- bool fderivative::is_equal_same_type( const basic & other ) -->
+  <function name="fderivative::is_equal_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool fderivative::match_same_type( const basic & other ) -->
+  <function name="fderivative::match_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void fderivative::print( const print_context & c, unsigned level ) -->
+  <function name="fderivative::print">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void fderivative::read_archive( const archive_node & n, lst & sym_lst ) -->
+  <function name="fderivative::read_archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- ex fderivative::series( const relational & r, int order, unsigned options ) -->
+  <function name="fderivative::series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex fderivative::thiscontainer( const exvector & v ) -->
+  <function name="fderivative::thiscontainer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::EllipticE_deriv( const ex & k, unsigned deriv_param ) -->
+  <function name="GiNaC::EllipticE_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::EllipticE_eval( const ex & k ) -->
+  <function name="GiNaC::EllipticE_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::EllipticE_evalf( const ex & k ) -->
+  <function name="GiNaC::EllipticE_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::EllipticE_print_latex( const ex & k, const print_context & c ) -->
+  <function name="GiNaC::EllipticE_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::EllipticE_series( const ex & k, const relational & rel, int order, unsigned options ) -->
+  <function name="GiNaC::EllipticE_series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::EllipticK_deriv( const ex & k, unsigned deriv_param ) -->
+  <function name="GiNaC::EllipticK_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::EllipticK_eval( const ex & k ) -->
+  <function name="GiNaC::EllipticK_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::EllipticK_evalf( const ex & k ) -->
+  <function name="GiNaC::EllipticK_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::EllipticK_print_latex( const ex & k, const print_context & c ) -->
+  <function name="GiNaC::EllipticK_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::EllipticK_series( const ex & k, const relational & rel, int order, unsigned options ) -->
+  <function name="GiNaC::EllipticK_series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- cln::cl_N GiNaC::__anon1::agm_helper_second_kind( const cln::cl_N & a_0, const cln::cl_N & b_0, const cln::cl_N & c_0 ) -->
+  <function name="GiNaC::__anon1::agm_helper_second_kind">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- cln::cl_N GiNaC::__anon1::arithmetic_geometric_mean( const cln::cl_N & a_0, const cln::cl_N & b_0 ) -->
+  <function name="GiNaC::__anon1::arithmetic_geometric_mean">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::iterated_integral2_eval( const ex & kernel_lst, const ex & lambda ) -->
+  <function name="GiNaC::iterated_integral2_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::iterated_integral2_evalf( const ex & kernel_lst, const ex & lambda ) -->
+  <function name="GiNaC::iterated_integral2_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::iterated_integral3_eval( const ex & kernel_lst, const ex & lambda, const ex & N_trunc ) -->
+  <function name="GiNaC::iterated_integral3_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- ex GiNaC::iterated_integral3_evalf( const ex & kernel_lst, const ex & lambda, const ex & N_trunc ) -->
+  <function name="GiNaC::iterated_integral3_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- ex GiNaC::iterated_integral_evalf_impl( const ex & kernel_lst, const ex & lambda, const ex & N_trunc ) -->
+  <function name="GiNaC::iterated_integral_evalf_impl">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void GiNaC::find_variant_indices( const exvector & v, exvector & variant_indices ) -->
+  <function name="GiNaC::find_variant_indices">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- bool GiNaC::hasindex( const ex & x, const ex & sym ) -->
+  <function name="GiNaC::hasindex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::idx_symmetrization( const ex & r, const exvector & local_dummy_indices ) -->
+  <function name="GiNaC::idx_symmetrization">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool GiNaC::indices_consistent( const exvector & v1, const exvector & v2 ) -->
+  <function name="GiNaC::indices_consistent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- size_t GiNaC::number_of_type( const exvector & v ) -->
+  <function name="GiNaC::number_of_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::product_to_exvector( const ex & e, exvector & v, bool & non_commutative ) -->
+  <function name="GiNaC::product_to_exvector">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::rename_dummy_indices( const ex & e, exvector & global_dummy_indices, exvector & local_dummy_indices ) -->
+  <function name="GiNaC::rename_dummy_indices">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void scalar_products::add_vectors( const lst & l, const ex & dim ) -->
+  <function name="scalar_products::add_vectors">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex ex::antisymmetrize( void ) -->
+  <function name="ex::antisymmetrize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- void indexed::archive( archive_node & n ) -->
+  <function name="indexed::archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- int indexed::compare_same_type( const basic & other ) -->
+  <function name="indexed::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex indexed::derivative( const symbol & s ) -->
+  <function name="indexed::derivative">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex indexed::eval( void ) -->
+  <function name="indexed::eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex indexed::expand( unsigned options ) -->
+  <function name="indexed::expand">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- exvector indexed::get_free_indices( void ) -->
+  <function name="indexed::get_free_indices">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="exvector"/>
+    <use-retval/>
+  </function>
+  <!-- ex indexed::imag_part( void ) -->
+  <function name="indexed::imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- bool indexed::info( unsigned inf ) -->
+  <function name="indexed::info">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void indexed::read_archive( const archive_node & n, lst & sym_lst ) -->
+  <function name="indexed::read_archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- ex indexed::real_part( void ) -->
+  <function name="indexed::real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- unsigned indexed::return_type( void ) -->
+  <function name="indexed::return_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- ex ex::symmetrize( void ) -->
+  <function name="ex::symmetrize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex ex::symmetrize_cyclic( void ) -->
+  <function name="ex::symmetrize_cyclic">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex indexed::thiscontainer( const exvector & v ) -->
+  <function name="indexed::thiscontainer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::adaptivesimpson( const ex & x, const ex & a_in, const ex & b_in, const ex & f, const ex & error ) -->
+  <function name="GiNaC::adaptivesimpson">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+    <arg nr="5" direction="in"/>
+  </function>
+  <!-- ex GiNaC::subsvalue( const ex & var, const ex & value, const ex & fun ) -->
+  <function name="GiNaC::subsvalue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void integral::archive( archive_node & n ) -->
+  <function name="integral::archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- int integral::compare_same_type( const basic & other ) -->
+  <function name="integral::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex integral::conjugate( void ) -->
+  <function name="integral::conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- int integral::degree( const ex & s ) -->
+  <function name="integral::degree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex integral::derivative( const symbol & s ) -->
+  <function name="integral::derivative">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex integral::eval( void ) -->
+  <function name="integral::eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex integral::eval_integ( void ) -->
+  <function name="integral::eval_integ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex integral::eval_ncmul( const exvector & v ) -->
+  <function name="integral::eval_ncmul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex integral::evalf( void ) -->
+  <function name="integral::evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex integral::expand( unsigned options ) -->
+  <function name="integral::expand">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int integral::ldegree( const ex & s ) -->
+  <function name="integral::ldegree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex & integral::let_op( size_t i ) -->
+  <function name="integral::let_op">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex &amp;"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- size_t integral::nops( void ) -->
+  <function name="integral::nops">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <use-retval/>
+  </function>
+  <!-- ex integral::op( size_t i ) -->
+  <function name="integral::op">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void integral::read_archive( const archive_node & n, lst & sym_lst ) -->
+  <function name="integral::read_archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- unsigned integral::return_type( void ) -->
+  <function name="integral::return_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- return_type_t integral::return_type_tinfo( void ) -->
+  <function name="integral::return_type_tinfo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="return_type_t"/>
+    <use-retval/>
+  </function>
+  <!-- bool mul::can_make_flat( const expair & p ) -->
+  <function name="mul::can_make_flat">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex mul::coeff( const ex & s, int n ) -->
+  <function name="mul::coeff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void mul::combine_overall_coeff( const ex & c ) -->
+  <function name="mul::combine_overall_coeff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int mul::compare_same_type( const basic & other ) -->
+  <function name="mul::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex mul::conjugate( void ) -->
+  <function name="mul::conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex mul::default_overall_coeff( void ) -->
+  <function name="mul::default_overall_coeff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- int mul::degree( const ex & s ) -->
+  <function name="mul::degree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex mul::derivative( const symbol & s ) -->
+  <function name="mul::derivative">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex mul::eval( void ) -->
+  <function name="mul::eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex mul::eval_ncmul( const exvector & v ) -->
+  <function name="mul::eval_ncmul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex mul::evalf( void ) -->
+  <function name="mul::evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex mul::evalm( void ) -->
+  <function name="mul::evalm">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- bool mul::expair_needs_further_processing( epp it ) -->
+  <function name="mul::expair_needs_further_processing">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex mul::expand( unsigned options ) -->
+  <function name="mul::expand">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool mul::has( const ex & pattern, unsigned options ) -->
+  <function name="mul::has">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex mul::imag_part( void ) -->
+  <function name="mul::imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- bool mul::info( unsigned inf ) -->
+  <function name="mul::info">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool mul::is_polynomial( const ex & var ) -->
+  <function name="mul::is_polynomial">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int mul::ldegree( const ex & s ) -->
+  <function name="mul::ldegree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex mul::real_part( void ) -->
+  <function name="mul::real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex mul::recombine_pair_to_ex( const expair & p ) -->
+  <function name="mul::recombine_pair_to_ex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- unsigned mul::return_type( void ) -->
+  <function name="mul::return_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- return_type_t mul::return_type_tinfo( void ) -->
+  <function name="mul::return_type_tinfo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="return_type_t"/>
+    <use-retval/>
+  </function>
+  <!-- expair mul::split_ex_to_pair( const ex & e ) -->
+  <function name="mul::split_ex_to_pair">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="expair"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex mul::thisexpairseq( const epvector & v, const ex & oc, bool do_index_renaming ) -->
+  <function name="mul::thisexpairseq">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void constant::archive( archive_node & n ) -->
+  <function name="constant::archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- unsigned constant::calchash( void ) -->
+  <function name="constant::calchash">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- int constant::compare_same_type( const basic & other ) -->
+  <function name="constant::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex constant::conjugate( void ) -->
+  <function name="constant::conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex constant::derivative( const symbol & s ) -->
+  <function name="constant::derivative">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex constant::evalf( void ) -->
+  <function name="constant::evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex constant::imag_part( void ) -->
+  <function name="constant::imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- bool constant::info( unsigned inf ) -->
+  <function name="constant::info">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool constant::is_equal_same_type( const basic & other ) -->
+  <function name="constant::is_equal_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool constant::is_polynomial( const ex & var ) -->
+  <function name="constant::is_polynomial">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void constant::read_archive( const archive_node & n, lst & sym_lst ) -->
+  <function name="constant::read_archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- ex constant::real_part( void ) -->
+  <function name="constant::real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- const cln::cl_N GiNaC::Li2_( const cln::cl_N & value ) -->
+  <function name="GiNaC::Li2_">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const cln::cl_N"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::coerce( T1 & dst, const T2 & arg ) -->
+  <function name="GiNaC::coerce">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- cln::float_format_t GiNaC::guess_precision( const cln::cl_N & x ) -->
+  <function name="GiNaC::guess_precision">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::float_format_t"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- cln::cl_N GiNaC::lanczos_coeffs::calc_lanczos_A( const cln::cl_N &  ) const -->
+  <function name="GiNaC::lanczos_coeffs::calc_lanczos_A">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int GiNaC::lanczos_coeffs::get_order( void ) -->
+  <function name="GiNaC::lanczos_coeffs::get_order">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- bool GiNaC::lanczos_coeffs::sufficiently_accurate( int digits ) -->
+  <function name="GiNaC::lanczos_coeffs::sufficiently_accurate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- const cln::cl_F GiNaC::make_real_float( const cln::cl_idecoded_float & dec ) -->
+  <function name="GiNaC::make_real_float">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const cln::cl_F"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::print_integer_csrc( const print_context & c, const cln::cl_I & x ) -->
+  <function name="GiNaC::print_integer_csrc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::print_real_cl_N( const print_context & c, const cln::cl_R & x ) -->
+  <function name="GiNaC::print_real_cl_N">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::print_real_csrc( const print_context & c, const cln::cl_R & x ) -->
+  <function name="GiNaC::print_real_csrc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::print_real_number( const print_context & c, const cln::cl_R & x ) -->
+  <function name="GiNaC::print_real_number">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- const cln::cl_F GiNaC::read_real_float( std::istream & s ) -->
+  <function name="GiNaC::read_real_float">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const cln::cl_F"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void GiNaC::write_real_float( std::ostream & s, const cln::cl_R & n ) -->
+  <function name="GiNaC::write_real_float">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void numeric::archive( archive_node & n ) -->
+  <function name="numeric::archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- unsigned numeric::calchash( void ) -->
+  <function name="numeric::calchash">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- ex numeric::coeff( const ex & s, int n ) -->
+  <function name="numeric::coeff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int numeric::compare_same_type( const basic & other ) -->
+  <function name="numeric::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex numeric::conjugate( void ) -->
+  <function name="numeric::conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex numeric::eval( void ) -->
+  <function name="numeric::eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex numeric::evalf( void ) -->
+  <function name="numeric::evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- bool numeric::has( const ex & other, unsigned options ) -->
+  <function name="numeric::has">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex numeric::imag_part( void ) -->
+  <function name="numeric::imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- bool numeric::info( unsigned inf ) -->
+  <function name="numeric::info">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool numeric::is_equal_same_type( const basic & other ) -->
+  <function name="numeric::is_equal_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool numeric::is_polynomial( const ex & var ) -->
+  <function name="numeric::is_polynomial">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int numeric::ldegree( const ex & s ) -->
+  <function name="numeric::ldegree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void numeric::read_archive( const archive_node & n, lst & sym_lst ) -->
+  <function name="numeric::read_archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- ex numeric::real_part( void ) -->
+  <function name="numeric::real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex add::coeff( const ex & s, int n ) -->
+  <function name="add::coeff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int add::compare_same_type( const basic & other ) -->
+  <function name="add::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex add::conjugate( void ) -->
+  <function name="add::conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- int add::degree( const ex & s ) -->
+  <function name="add::degree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex add::derivative( const symbol & y ) -->
+  <function name="add::derivative">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex add::eval( void ) -->
+  <function name="add::eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex add::eval_ncmul( const exvector & v ) -->
+  <function name="add::eval_ncmul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex add::evalm( void ) -->
+  <function name="add::evalm">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex add::expand( unsigned options ) -->
+  <function name="add::expand">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex add::imag_part( void ) -->
+  <function name="add::imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- bool add::info( unsigned inf ) -->
+  <function name="add::info">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool add::is_polynomial( const ex & var ) -->
+  <function name="add::is_polynomial">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int add::ldegree( const ex & s ) -->
+  <function name="add::ldegree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex add::real_part( void ) -->
+  <function name="add::real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex add::recombine_pair_to_ex( const expair & p ) -->
+  <function name="add::recombine_pair_to_ex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- unsigned add::return_type( void ) -->
+  <function name="add::return_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- return_type_t add::return_type_tinfo( void ) -->
+  <function name="add::return_type_tinfo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="return_type_t"/>
+    <use-retval/>
+  </function>
+  <!-- expair add::split_ex_to_pair( const ex & e ) -->
+  <function name="add::split_ex_to_pair">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="expair"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex add::thisexpairseq( const epvector & v, const ex & oc, bool do_index_renaming ) -->
+  <function name="add::thisexpairseq">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- const std::string & GiNaC::get_default_TeX_name( const std::string & name ) -->
+  <function name="GiNaC::get_default_TeX_name">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const std::string &amp;"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void symbol::archive( archive_node & n ) -->
+  <function name="symbol::archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- unsigned symbol::calchash( void ) -->
+  <function name="symbol::calchash">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- int symbol::compare_same_type( const basic & other ) -->
+  <function name="symbol::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex symbol::conjugate( void ) -->
+  <function name="symbol::conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex symbol::derivative( const symbol & s ) -->
+  <function name="symbol::derivative">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex symbol::imag_part( void ) -->
+  <function name="symbol::imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- bool symbol::info( unsigned inf ) -->
+  <function name="symbol::info">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool symbol::is_equal_same_type( const basic & other ) -->
+  <function name="symbol::is_equal_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool symbol::is_polynomial( const ex & var ) -->
+  <function name="symbol::is_polynomial">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void symbol::read_archive( const archive_node & n, lst & sym_lst ) -->
+  <function name="symbol::read_archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- ex symbol::real_part( void ) -->
+  <function name="symbol::real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex ncmul::coeff( const ex & s, int n ) -->
+  <function name="ncmul::coeff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int ncmul::compare_same_type( const basic & other ) -->
+  <function name="ncmul::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex ncmul::conjugate( void ) -->
+  <function name="ncmul::conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- int ncmul::degree( const ex & s ) -->
+  <function name="ncmul::degree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex ncmul::derivative( const symbol & s ) -->
+  <function name="ncmul::derivative">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex ncmul::eval( void ) -->
+  <function name="ncmul::eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex ncmul::evalm( void ) -->
+  <function name="ncmul::evalm">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex ncmul::expand( unsigned options ) -->
+  <function name="ncmul::expand">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex ncmul::imag_part( void ) -->
+  <function name="ncmul::imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- bool ncmul::info( unsigned inf ) -->
+  <function name="ncmul::info">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int ncmul::ldegree( const ex & s ) -->
+  <function name="ncmul::ldegree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex ncmul::real_part( void ) -->
+  <function name="ncmul::real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- unsigned ncmul::return_type( void ) -->
+  <function name="ncmul::return_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- return_type_t ncmul::return_type_tinfo( void ) -->
+  <function name="ncmul::return_type_tinfo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="return_type_t"/>
+    <use-retval/>
+  </function>
+  <!-- ex ncmul::thiscontainer( const exvector & v ) -->
+  <function name="ncmul::thiscontainer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::__anon1::B_eisenstein_series( const ex & q, const numeric & N_level, const numeric & K, const numeric & N_order ) -->
+  <function name="GiNaC::__anon1::B_eisenstein_series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- ex GiNaC::__anon1::E_eisenstein_series( const ex & q, const numeric & k, const numeric & N_level, const numeric & a, const numeric & b, const numeric & K, const numeric & N_order ) -->
+  <function name="GiNaC::__anon1::E_eisenstein_series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+    <arg nr="5" direction="in"/>
+    <arg nr="6" direction="in"/>
+    <arg nr="7" direction="in"/>
+  </function>
+  <!-- ex GiNaC::__anon1::Li_negative::get_symbolic_value( int n, const ex & x_val ) -->
+  <function name="GiNaC::__anon1::Li_negative::get_symbolic_value">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- numeric GiNaC::__anon1::coefficient_a0( const numeric & k, const numeric & a, const numeric & b ) -->
+  <function name="GiNaC::__anon1::coefficient_a0">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="numeric"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- numeric GiNaC::__anon1::divisor_function( const numeric & n, const numeric & a, const numeric & b, const numeric & k ) -->
+  <function name="GiNaC::__anon1::divisor_function">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="numeric"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- ex GiNaC::__anon1::eisenstein_series( const numeric & k, const ex & q, const numeric & a, const numeric & b, const numeric & N ) -->
+  <function name="GiNaC::__anon1::eisenstein_series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+    <arg nr="5" direction="in"/>
+  </function>
+  <!-- numeric GiNaC::__anon1::kronecker_symbol_prime( const numeric & a, const numeric & n ) -->
+  <function name="GiNaC::__anon1::kronecker_symbol_prime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="numeric"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- int integration_kernel::compare_same_type( const basic & other ) -->
+  <function name="integration_kernel::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex & multiple_polylog_kernel::let_op( size_t i ) -->
+  <function name="multiple_polylog_kernel::let_op">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex &amp;"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- size_t multiple_polylog_kernel::nops( void ) -->
+  <function name="multiple_polylog_kernel::nops">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <use-retval/>
+  </function>
+  <!-- ex multiple_polylog_kernel::op( size_t i ) -->
+  <function name="multiple_polylog_kernel::op">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex integration_kernel::series( const relational & r, int order, unsigned options ) -->
+  <function name="integration_kernel::series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::G2_eval( const ex & x_, const ex & y ) -->
+  <function name="GiNaC::G2_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::G2_evalf( const ex & x_, const ex & y ) -->
+  <function name="GiNaC::G2_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::G3_eval( const ex & x_, const ex & s_, const ex & y ) -->
+  <function name="GiNaC::G3_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- ex GiNaC::G3_evalf( const ex & x_, const ex & s_, const ex & y ) -->
+  <function name="GiNaC::G3_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- ex GiNaC::H_deriv( const ex & m_, const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::H_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::H_eval( const ex & m_, const ex & x ) -->
+  <function name="GiNaC::H_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::H_evalf( const ex & x1, const ex & x2 ) -->
+  <function name="GiNaC::H_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::H_print_latex( const ex & m_, const ex & x, const print_context & c ) -->
+  <function name="GiNaC::H_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- ex GiNaC::H_series( const ex & m, const ex & x, const relational & rel, int order, unsigned options ) -->
+  <function name="GiNaC::H_series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::Li_deriv( const ex & m_, const ex & x_, unsigned deriv_param ) -->
+  <function name="GiNaC::Li_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::Li_eval( const ex & m_, const ex & x_ ) -->
+  <function name="GiNaC::Li_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::Li_evalf( const ex & m_, const ex & x_ ) -->
+  <function name="GiNaC::Li_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::Li_print_latex( const ex & m_, const ex & x_, const print_context & c ) -->
+  <function name="GiNaC::Li_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- ex GiNaC::Li_series( const ex & m, const ex & x, const relational & rel, int order, unsigned options ) -->
+  <function name="GiNaC::Li_series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::S_deriv( const ex & n, const ex & p, const ex & x, unsigned deriv_param ) -->
+  <function name="GiNaC::S_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::S_eval( const ex & n, const ex & p, const ex & x ) -->
+  <function name="GiNaC::S_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- ex GiNaC::S_evalf( const ex & n, const ex & p, const ex & x ) -->
+  <function name="GiNaC::S_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void GiNaC::S_print_latex( const ex & n, const ex & p, const ex & x, const print_context & c ) -->
+  <function name="GiNaC::S_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- ex GiNaC::S_series( const ex & n, const ex & p, const ex & x, const relational & rel, int order, unsigned options ) -->
+  <function name="GiNaC::S_series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- cln::cl_N GiNaC::__anon1::Li2_do_sum( const cln::cl_N & x ) -->
+  <function name="GiNaC::__anon1::Li2_do_sum">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- cln::cl_N GiNaC::__anon1::Li2_do_sum_Xn( const cln::cl_N & x ) -->
+  <function name="GiNaC::__anon1::Li2_do_sum_Xn">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- cln::cl_N GiNaC::__anon1::Li_projection( int n, const cln::cl_N & x, const cln::float_format_t & prec ) -->
+  <function name="GiNaC::__anon1::Li_projection">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- cln::cl_N GiNaC::__anon1::Lin_do_sum( int n, const cln::cl_N & x ) -->
+  <function name="GiNaC::__anon1::Lin_do_sum">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- cln::cl_N GiNaC::__anon1::Lin_do_sum_Xn( int n, const cln::cl_N & x ) -->
+  <function name="GiNaC::__anon1::Lin_do_sum_Xn">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- const cln::cl_N GiNaC::__anon1::Lin_numeric( const int n, const cln::cl_N & x ) -->
+  <function name="GiNaC::__anon1::Lin_numeric">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const cln::cl_N"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- const cln::cl_N GiNaC::__anon1::S_num( int n, int p, const cln::cl_N & x ) -->
+  <function name="GiNaC::__anon1::S_num">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const cln::cl_N"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void GiNaC::__anon1::double_Xn( void ) -->
+  <function name="GiNaC::__anon1::double_Xn">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GiNaC::__anon1::fill_Xn( int n ) -->
+  <function name="GiNaC::__anon1::fill_Xn">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::__anon2::G_eval( const Gparameter & a, int scale, const exvector & gsyms ) -->
+  <function name="GiNaC::__anon2::G_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- ex GiNaC::__anon2::G_eval1( int a, int scale, const exvector & gsyms ) -->
+  <function name="GiNaC::__anon2::G_eval1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- ex GiNaC::__anon2::G_eval_to_G( const Gparameter & a, int scale, const exvector & gsyms ) -->
+  <function name="GiNaC::__anon2::G_eval_to_G">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- lst GiNaC::__anon2::convert_parameter_Li_to_H( const lst & m, const lst & x, ex & pf ) -->
+  <function name="GiNaC::__anon2::convert_parameter_Li_to_H">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="lst"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- Gparameter GiNaC::__anon2::convert_pending_integrals_G( const Gparameter & pending_integrals ) -->
+  <function name="GiNaC::__anon2::convert_pending_integrals_G">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="Gparameter"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::__anon2::depth_one_trafo_G( const Gparameter & pending_integrals, const Gparameter & a, int scale, const exvector & gsyms ) -->
+  <function name="GiNaC::__anon2::depth_one_trafo_G">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- ex GiNaC::__anon2::mLi_numeric( const lst & m, const lst & x ) -->
+  <function name="GiNaC::__anon2::mLi_numeric">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- cln::cl_N GiNaC::__anon2::multipleLi_do_sum( const std::vector<int> & s, const std::vector<cln::cl_N> & x ) -->
+  <function name="GiNaC::__anon2::multipleLi_do_sum">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- Gparameter GiNaC::__anon2::prepare_pending_integrals( const Gparameter & pending_integrals, int scale ) -->
+  <function name="GiNaC::__anon2::prepare_pending_integrals">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="Gparameter"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::__anon2::trailing_zeros_G( const Gparameter & a, int scale, const exvector & gsyms ) -->
+  <function name="GiNaC::__anon2::trailing_zeros_G">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- cln::cl_N GiNaC::__anon3::C( int n, int p ) -->
+  <function name="GiNaC::__anon3::C">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- cln::cl_N GiNaC::__anon3::S_do_sum( int n, int p, const cln::cl_N & x, const cln::float_format_t & prec ) -->
+  <function name="GiNaC::__anon3::S_do_sum">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- cln::cl_N GiNaC::__anon3::S_projection( int n, int p, const cln::cl_N & x, const cln::float_format_t & prec ) -->
+  <function name="GiNaC::__anon3::S_projection">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- cln::cl_N GiNaC::__anon3::a_k( int k ) -->
+  <function name="GiNaC::__anon3::a_k">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- cln::cl_N GiNaC::__anon3::b_k( int k ) -->
+  <function name="GiNaC::__anon3::b_k">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void GiNaC::__anon3::fill_Yn( int n, const cln::float_format_t & prec ) -->
+  <function name="GiNaC::__anon3::fill_Yn">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::__anon3::make_Yn_longer( int newsize, const cln::float_format_t & prec ) -->
+  <function name="GiNaC::__anon3::make_Yn_longer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- cln::cl_N GiNaC::__anon4::H_do_sum( const std::vector<int> & m, const cln::cl_N & x ) -->
+  <function name="GiNaC::__anon4::H_do_sum">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::__anon4::convert_H_to_zeta( const lst & m ) -->
+  <function name="GiNaC::__anon4::convert_H_to_zeta">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::__anon4::convert_parameter_H_to_Li( const lst & l, lst & m, lst & s, ex & pf ) -->
+  <function name="GiNaC::__anon4::convert_parameter_H_to_Li">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+    <arg nr="4" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::__anon4::trafo_H_1mxt1px_prepend_minusone( const ex & e, const ex & arg ) -->
+  <function name="GiNaC::__anon4::trafo_H_1mxt1px_prepend_minusone">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::__anon4::trafo_H_1mxt1px_prepend_one( const ex & e, const ex & arg ) -->
+  <function name="GiNaC::__anon4::trafo_H_1mxt1px_prepend_one">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::__anon4::trafo_H_1tx_prepend_minusone( const ex & e, const ex & arg ) -->
+  <function name="GiNaC::__anon4::trafo_H_1tx_prepend_minusone">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::__anon4::trafo_H_1tx_prepend_zero( const ex & e, const ex & arg ) -->
+  <function name="GiNaC::__anon4::trafo_H_1tx_prepend_zero">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::__anon4::trafo_H_mult( const ex & h1, const ex & h2 ) -->
+  <function name="GiNaC::__anon4::trafo_H_mult">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::__anon4::trafo_H_prepend_one( const ex & e, const ex & arg ) -->
+  <function name="GiNaC::__anon4::trafo_H_prepend_one">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::__anon5::halfcyclic_convolute( const std::vector<cln::cl_N> & a, const std::vector<cln::cl_N> & b, std::vector<cln::cl_N> & c ) -->
+  <function name="GiNaC::__anon5::halfcyclic_convolute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- cln::cl_N GiNaC::__anon5::zeta_do_Hoelder_convolution( const std::vector<int> & m_, const std::vector<int> & s_ ) -->
+  <function name="GiNaC::__anon5::zeta_do_Hoelder_convolution">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- cln::cl_N GiNaC::__anon5::zeta_do_sum_Crandall( const std::vector<int> & s ) -->
+  <function name="GiNaC::__anon5::zeta_do_sum_Crandall">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- cln::cl_N GiNaC::__anon5::zeta_do_sum_simple( const std::vector<int> & r ) -->
+  <function name="GiNaC::__anon5::zeta_do_sum_simple">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cln::cl_N"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::zeta1_deriv( const ex & m, unsigned deriv_param ) -->
+  <function name="GiNaC::zeta1_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::zeta1_eval( const ex & m ) -->
+  <function name="GiNaC::zeta1_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::zeta1_evalf( const ex & x ) -->
+  <function name="GiNaC::zeta1_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::zeta1_print_latex( const ex & m_, const print_context & c ) -->
+  <function name="GiNaC::zeta1_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::zeta2_deriv( const ex & m, const ex & s, unsigned deriv_param ) -->
+  <function name="GiNaC::zeta2_deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex GiNaC::zeta2_eval( const ex & m, const ex & s_ ) -->
+  <function name="GiNaC::zeta2_eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::zeta2_evalf( const ex & x, const ex & s ) -->
+  <function name="GiNaC::zeta2_evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::zeta2_print_latex( const ex & m_, const ex & s_, const print_context & c ) -->
+  <function name="GiNaC::zeta2_print_latex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void GiNaC::excompiler::add_opened_module( void * module, const std::string & name, bool clean_up ) -->
+  <function name="GiNaC::excompiler::add_opened_module">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void GiNaC::excompiler::clean_up( const std::vector<filedesc>::const_iterator it ) -->
+  <function name="GiNaC::excompiler::clean_up">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::excompiler::compile_src_file( const std::string filename, bool clean_up ) -->
+  <function name="GiNaC::excompiler::compile_src_file">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void GiNaC::excompiler::create_src_file( std::string & filename, std::ofstream & ofs ) -->
+  <function name="GiNaC::excompiler::create_src_file">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void * GiNaC::excompiler::link_so_file( const std::string filename, bool clean_up ) -->
+  <function name="GiNaC::excompiler::link_so_file">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void *"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void GiNaC::excompiler::unlink( const std::string filename ) -->
+  <function name="GiNaC::excompiler::unlink">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::__anon1::berlekamp( const umodpoly & a, upvec & upv ) -->
+  <function name="GiNaC::__anon1::berlekamp">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- cl_I GiNaC::__anon1::calc_bound( const ex & a, const ex & x, int maxdeg ) -->
+  <function name="GiNaC::__anon1::calc_bound">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="cl_I"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void GiNaC::__anon1::change_modulus( const cl_modint_ring & R, umodpoly & a ) -->
+  <function name="GiNaC::__anon1::change_modulus">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- bool GiNaC::__anon1::checkdivisors( const lst & f ) -->
+  <function name="GiNaC::__anon1::checkdivisors">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int GiNaC::__anon1::degree( const T & p ) -->
+  <function name="GiNaC::__anon1::degree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::__anon1::deriv( const umodpoly & a, umodpoly & d ) -->
+  <function name="GiNaC::__anon1::deriv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void GiNaC::__anon1::distinct_degree_factor( const umodpoly & a_, vector<int> & degrees, upvec & ddfactors ) -->
+  <function name="GiNaC::__anon1::distinct_degree_factor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void GiNaC::__anon1::div( const umodpoly & a, const umodpoly & b, umodpoly & q ) -->
+  <function name="GiNaC::__anon1::div">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void GiNaC::__anon1::eea_lift( const umodpoly & a, const umodpoly & b, const ex & x, unsigned int p, unsigned int k, umodpoly & s_, umodpoly & t_ ) -->
+  <function name="GiNaC::__anon1::eea_lift">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="6" direction="inout"/>
+    <arg nr="7" direction="inout"/>
+  </function>
+  <!-- bool GiNaC::__anon1::equal_one( const umodpoly & a ) -->
+  <function name="GiNaC::__anon1::equal_one">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::__anon1::expt_pos( umodpoly & a, unsigned int q ) -->
+  <function name="GiNaC::__anon1::expt_pos">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void GiNaC::__anon1::exteuclid( const umodpoly & a, const umodpoly & b, umodpoly & s, umodpoly & t ) -->
+  <function name="GiNaC::__anon1::exteuclid">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+    <arg nr="4" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::__anon1::factor1( const ex & poly, unsigned options ) -->
+  <function name="GiNaC::__anon1::factor1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void GiNaC::__anon1::factor_modular( const umodpoly & p, upvec & upv ) -->
+  <function name="GiNaC::__anon1::factor_modular">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::__anon1::factor_multivariate( const ex & poly, const exset & syms ) -->
+  <function name="GiNaC::__anon1::factor_multivariate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- umodpoly & GiNaC::__anon1::factor_partition::left( void ) -->
+  <function name="GiNaC::__anon1::factor_partition::left">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="umodpoly &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool GiNaC::__anon1::factor_partition::next( void ) -->
+  <function name="GiNaC::__anon1::factor_partition::next">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- umodpoly & GiNaC::__anon1::factor_partition::right( void ) -->
+  <function name="GiNaC::__anon1::factor_partition::right">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="umodpoly &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- size_t GiNaC::__anon1::factor_partition::size( void ) -->
+  <function name="GiNaC::__anon1::factor_partition::size">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <use-retval/>
+  </function>
+  <!-- size_t GiNaC::__anon1::factor_partition::size_left( void ) -->
+  <function name="GiNaC::__anon1::factor_partition::size_left">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <use-retval/>
+  </function>
+  <!-- size_t GiNaC::__anon1::factor_partition::size_right( void ) -->
+  <function name="GiNaC::__anon1::factor_partition::size_right">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <use-retval/>
+  </function>
+  <!-- void GiNaC::__anon1::factor_partition::split( void ) -->
+  <function name="GiNaC::__anon1::factor_partition::split">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GiNaC::__anon1::factor_partition::split_cached( void ) -->
+  <function name="GiNaC::__anon1::factor_partition::split_cached">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- ex GiNaC::__anon1::factor_sqrfree( const ex & poly ) -->
+  <function name="GiNaC::__anon1::factor_sqrfree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::__anon1::factor_univariate( const ex & poly, const ex & x, unsigned int & prime ) -->
+  <function name="GiNaC::__anon1::factor_univariate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void GiNaC::__anon1::gcd( const umodpoly & a, const umodpoly & b, umodpoly & c ) -->
+  <function name="GiNaC::__anon1::gcd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void GiNaC::__anon1::hensel_univar( const upoly & a_, unsigned int p, const umodpoly & u1_, const umodpoly & w1_, upoly & u, upoly & w ) -->
+  <function name="GiNaC::__anon1::hensel_univar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+    <arg nr="5" direction="inout"/>
+    <arg nr="6" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::__anon1::make_modular( const ex & e, const cl_modint_ring & R ) -->
+  <function name="GiNaC::__anon1::make_modular">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- size_t GiNaC::__anon1::modular_matrix::colsize( void ) -->
+  <function name="GiNaC::__anon1::modular_matrix::colsize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <use-retval/>
+  </function>
+  <!-- bool GiNaC::__anon1::modular_matrix::is_col_zero( size_t col ) -->
+  <function name="GiNaC::__anon1::modular_matrix::is_col_zero">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool GiNaC::__anon1::modular_matrix::is_row_zero( size_t row ) -->
+  <function name="GiNaC::__anon1::modular_matrix::is_row_zero">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void GiNaC::__anon1::modular_matrix::mul_col( size_t col, const cl_MI x ) -->
+  <function name="GiNaC::__anon1::modular_matrix::mul_col">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::__anon1::modular_matrix::mul_row( size_t row, const cl_MI x ) -->
+  <function name="GiNaC::__anon1::modular_matrix::mul_row">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- mvec::const_iterator GiNaC::__anon1::modular_matrix::row_begin( size_t row ) -->
+  <function name="GiNaC::__anon1::modular_matrix::row_begin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mvec::const_iterator"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- mvec::const_iterator GiNaC::__anon1::modular_matrix::row_end( size_t row ) -->
+  <function name="GiNaC::__anon1::modular_matrix::row_end">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mvec::const_iterator"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- size_t GiNaC::__anon1::modular_matrix::rowsize( void ) -->
+  <function name="GiNaC::__anon1::modular_matrix::rowsize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <use-retval/>
+  </function>
+  <!-- void GiNaC::__anon1::modular_matrix::set_row( size_t row, const vector<cl_MI> & newrow ) -->
+  <function name="GiNaC::__anon1::modular_matrix::set_row">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::__anon1::modular_matrix::sub_col( size_t col1, size_t col2, const cl_MI fac ) -->
+  <function name="GiNaC::__anon1::modular_matrix::sub_col">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void GiNaC::__anon1::modular_matrix::sub_row( size_t row1, size_t row2, const cl_MI fac ) -->
+  <function name="GiNaC::__anon1::modular_matrix::sub_row">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void GiNaC::__anon1::modular_matrix::switch_col( size_t col1, size_t col2 ) -->
+  <function name="GiNaC::__anon1::modular_matrix::switch_col">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void GiNaC::__anon1::modular_matrix::switch_row( size_t row1, size_t row2 ) -->
+  <function name="GiNaC::__anon1::modular_matrix::switch_row">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- upvec GiNaC::__anon1::multiterm_eea_lift( const upvec & a, const ex & x, unsigned int p, unsigned int k ) -->
+  <function name="GiNaC::__anon1::multiterm_eea_lift">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="upvec"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- unsigned int GiNaC::__anon1::next_prime( unsigned int p ) -->
+  <function name="GiNaC::__anon1::next_prime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned int"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool GiNaC::__anon1::normalize_in_field( umodpoly & a ) -->
+  <function name="GiNaC::__anon1::normalize_in_field">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void GiNaC::__anon1::nullspace( modular_matrix & M, vector<mvec> & basis ) -->
+  <function name="GiNaC::__anon1::nullspace">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::__anon1::put_factors_into_lst( const ex & e ) -->
+  <function name="GiNaC::__anon1::put_factors_into_lst">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::__anon1::q_matrix( const umodpoly & a_, modular_matrix & Q ) -->
+  <function name="GiNaC::__anon1::q_matrix">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void GiNaC::__anon1::reduce_coeff( umodpoly & a, const cl_I & x ) -->
+  <function name="GiNaC::__anon1::reduce_coeff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::__anon1::rem( const umodpoly & a, const umodpoly & b, umodpoly & r ) -->
+  <function name="GiNaC::__anon1::rem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void GiNaC::__anon1::remdiv( const umodpoly & a, const umodpoly & b, umodpoly & r, umodpoly & q ) -->
+  <function name="GiNaC::__anon1::remdiv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+    <arg nr="4" direction="inout"/>
+  </function>
+  <!-- upoly GiNaC::__anon1::replace_lc( const upoly & poly, const cl_I & lc ) -->
+  <function name="GiNaC::__anon1::replace_lc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="upoly"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::__anon1::same_degree_factor( const umodpoly & a, upvec & upv ) -->
+  <function name="GiNaC::__anon1::same_degree_factor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- bool GiNaC::__anon1::squarefree( const umodpoly & a ) -->
+  <function name="GiNaC::__anon1::squarefree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GiNaC::__anon1::umodpoly_from_ex( umodpoly & ump, const ex & e, const ex & x, const cl_modint_ring & R ) -->
+  <function name="GiNaC::__anon1::umodpoly_from_ex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- void GiNaC::__anon1::umodpoly_from_upoly( umodpoly & ump, const upoly & e, const cl_modint_ring & R ) -->
+  <function name="GiNaC::__anon1::umodpoly_from_upoly">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- ex GiNaC::__anon1::umodpoly_to_ex( const umodpoly & a, const ex & x ) -->
+  <function name="GiNaC::__anon1::umodpoly_to_ex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- umodpoly GiNaC::__anon1::umodpoly_to_umodpoly( const umodpoly & a, const cl_modint_ring & R, unsigned int m ) -->
+  <function name="GiNaC::__anon1::umodpoly_to_umodpoly">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="umodpoly"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- upoly GiNaC::__anon1::umodpoly_to_upoly( const umodpoly & a ) -->
+  <function name="GiNaC::__anon1::umodpoly_to_upoly">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="upoly"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool GiNaC::__anon1::unequal_one( const umodpoly & a ) -->
+  <function name="GiNaC::__anon1::unequal_one">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- upvec GiNaC::__anon1::univar_diophant( const upvec & a, const ex & x, unsigned int m, unsigned int p, unsigned int k ) -->
+  <function name="GiNaC::__anon1::univar_diophant">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="upvec"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void GiNaC::__anon1::upoly_from_ex( upoly & up, const ex & e, const ex & x ) -->
+  <function name="GiNaC::__anon1::upoly_from_ex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- ex GiNaC::__anon1::upoly_to_ex( const upoly & a, const ex & x ) -->
+  <function name="GiNaC::__anon1::upoly_to_ex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool GiNaC::is_color_tinfo( const return_type_t & ti ) -->
+  <function name="GiNaC::is_color_tinfo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex GiNaC::permute_free_index_to_front( const exvector & iv3, const exvector & iv2, int & sig ) -->
+  <function name="GiNaC::permute_free_index_to_front">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void color::archive( archive_node & n ) -->
+  <function name="color::archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- int color::compare_same_type( const basic & other ) -->
+  <function name="color::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool su3t::contract_with( exvector::iterator self, exvector::iterator other, exvector & v ) -->
+  <function name="su3t::contract_with">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- ex su3d::eval_indexed( const basic & i ) -->
+  <function name="su3d::eval_indexed">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex color::eval_ncmul( const exvector & v ) -->
+  <function name="color::eval_ncmul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool color::match_same_type( const basic & other ) -->
+  <function name="color::match_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void color::read_archive( const archive_node & n, lst & sym_lst ) -->
+  <function name="color::read_archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- return_type_t color::return_type_tinfo( void ) -->
+  <function name="color::return_type_tinfo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="return_type_t"/>
+    <use-retval/>
+  </function>
+  <!-- ex color::thiscontainer( const exvector & v ) -->
+  <function name="color::thiscontainer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex matrix::add_indexed( const ex & self, const ex & other ) -->
+  <function name="matrix::add_indexed">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void matrix::archive( archive_node & n ) -->
+  <function name="matrix::archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- int matrix::compare_same_type( const basic & other ) -->
+  <function name="matrix::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex matrix::conjugate( void ) -->
+  <function name="matrix::conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- bool matrix::contract_with( exvector::iterator self, exvector::iterator other, exvector & v ) -->
+  <function name="matrix::contract_with">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- ex matrix::eval_indexed( const basic & i ) -->
+  <function name="matrix::eval_indexed">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex matrix::imag_part( void ) -->
+  <function name="matrix::imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex & matrix::let_op( size_t i ) -->
+  <function name="matrix::let_op">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex &amp;"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool matrix::match_same_type( const basic & other ) -->
+  <function name="matrix::match_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex matrix::op( size_t i ) -->
+  <function name="matrix::op">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void matrix::read_archive( const archive_node & n, lst & sym_lst ) -->
+  <function name="matrix::read_archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- ex matrix::real_part( void ) -->
+  <function name="matrix::real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex matrix::scalar_mul_indexed( const ex & self, const numeric & other ) -->
+  <function name="matrix::scalar_mul_indexed">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex matrix::subs( const exmap & mp, unsigned options ) -->
+  <function name="matrix::subs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- const ex GiNaC::exadd( const ex & lh, const ex & rh ) -->
+  <function name="GiNaC::exadd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- const ex GiNaC::exminus( const ex & lh ) -->
+  <function name="GiNaC::exminus">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const ex GiNaC::exmul( const ex & lh, const ex & rh ) -->
+  <function name="GiNaC::exmul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- print_context * GiNaC::get_print_context( std::ios_base & s ) -->
+  <function name="GiNaC::get_print_context">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="print_context *"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- unsigned GiNaC::get_print_options( std::ios_base & s ) -->
+  <function name="GiNaC::get_print_options">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void GiNaC::my_ios_callback( std::ios_base::event ev, std::ios_base & s, int i ) -->
+  <function name="GiNaC::my_ios_callback">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int GiNaC::my_ios_index( void ) -->
+  <function name="GiNaC::my_ios_index">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void GiNaC::set_print_context( std::ios_base & s, const print_context & c ) -->
+  <function name="GiNaC::set_print_context">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GiNaC::set_print_options( std::ostream & s, unsigned options ) -->
+  <function name="GiNaC::set_print_options">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool lst::info( unsigned inf ) -->
+  <function name="lst::info">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void GiNaC::add_symbol( const ex & s, sym_desc_vec & v ) -->
+  <function name="GiNaC::add_symbol">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void GiNaC::collect_symbols( const ex & e, sym_desc_vec & v ) -->
+  <function name="GiNaC::collect_symbols">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- bool GiNaC::divide_in_z( const ex & a, const ex & b, ex & q, sym_desc_vec::const_iterator var ) -->
+  <function name="GiNaC::divide_in_z">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- ex GiNaC::find_common_factor( const ex & e, ex & factor, exmap & repl ) -->
+  <function name="GiNaC::find_common_factor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::frac_cancel( const ex & n, const ex & d ) -->
+  <function name="GiNaC::frac_cancel">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::gcd_pf_mul( const ex & a, const ex & b, ex * ca, ex * cb ) -->
+  <function name="GiNaC::gcd_pf_mul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+    <arg nr="4" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::gcd_pf_pow( const ex & a, const ex & b, ex * ca, ex * cb ) -->
+  <function name="GiNaC::gcd_pf_pow">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+    <arg nr="4" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::gcd_pf_pow_pow( const ex & a, const ex & b, ex * ca, ex * cb ) -->
+  <function name="GiNaC::gcd_pf_pow_pow">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+    <arg nr="4" direction="inout"/>
+  </function>
+  <!-- bool GiNaC::get_first_symbol( const ex & e, ex & x ) -->
+  <function name="GiNaC::get_first_symbol">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void GiNaC::get_symbol_stats( const ex & a, const ex & b, sym_desc_vec & v ) -->
+  <function name="GiNaC::get_symbol_stats">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::interpolate( const ex & gamma, const numeric & xi, const ex & x, int degree_hint = 1 ) -->
+  <function name="GiNaC::interpolate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" default="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- numeric GiNaC::lcm_of_coefficients_denominators( const ex & e ) -->
+  <function name="GiNaC::lcm_of_coefficients_denominators">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="numeric"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- numeric GiNaC::lcmcoeff( const ex & e, const numeric & l ) -->
+  <function name="GiNaC::lcmcoeff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="numeric"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::multiply_lcm( const ex & e, const numeric & lcm ) -->
+  <function name="GiNaC::multiply_lcm">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex GiNaC::replace_with_symbol( const ex & e, exmap & repl, exmap & rev_lookup, lst & modifier ) -->
+  <function name="GiNaC::replace_with_symbol">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+    <arg nr="4" direction="inout"/>
+  </function>
+  <!-- ex GiNaC::sqrfree( const ex & a, const lst & l ) -->
+  <function name="GiNaC::sqrfree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- epvector GiNaC::sqrfree_yun( const ex & a, const symbol & x ) -->
+  <function name="GiNaC::sqrfree_yun">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="epvector"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ex ex::content( const ex & x ) -->
+  <function name="ex::content">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex ex::denom( void ) -->
+  <function name="ex::denom">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- numeric ex::integer_content( void ) -->
+  <function name="ex::integer_content">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="numeric"/>
+    <use-retval/>
+  </function>
+  <!-- numeric ex::max_coefficient( void ) -->
+  <function name="ex::max_coefficient">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="numeric"/>
+    <use-retval/>
+  </function>
+  <!-- ex basic::normal( exmap & repl, exmap & rev_lookup, lst & modifier ) -->
+  <function name="basic::normal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- ex ex::numer( void ) -->
+  <function name="ex::numer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex ex::numer_denom( void ) -->
+  <function name="ex::numer_denom">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex ex::primpart( const ex & x ) -->
+  <function name="ex::primpart">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex basic::smod( const numeric & xi ) -->
+  <function name="basic::smod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex ex::to_polynomial( exmap & repl ) -->
+  <function name="ex::to_polynomial">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- ex ex::to_rational( exmap & repl ) -->
+  <function name="ex::to_rational">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- ex ex::unit( const ex & x ) -->
+  <function name="ex::unit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void ex::unitcontprim( const ex & x, ex & u, ex & c, ex & p ) -->
+  <function name="ex::unitcontprim">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+    <arg nr="4" direction="inout"/>
+  </function>
+  <!-- void minkmetric::archive( archive_node & n ) -->
+  <function name="minkmetric::archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- int minkmetric::compare_same_type( const basic & other ) -->
+  <function name="minkmetric::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool tensdelta::contract_with( exvector::iterator self, exvector::iterator other, exvector & v ) -->
+  <function name="tensdelta::contract_with">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- ex tensdelta::eval_indexed( const basic & i ) -->
+  <function name="tensdelta::eval_indexed">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool tensdelta::info( unsigned inf ) -->
+  <function name="tensdelta::info">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void minkmetric::read_archive( const archive_node & n, lst & sym_lst ) -->
+  <function name="minkmetric::read_archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void idx::archive( archive_node & n ) -->
+  <function name="idx::archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- unsigned idx::calchash( void ) -->
+  <function name="idx::calchash">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- int idx::compare_same_type( const basic & other ) -->
+  <function name="idx::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex idx::derivative( const symbol & s ) -->
+  <function name="idx::derivative">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex idx::evalf( void ) -->
+  <function name="idx::evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- bool idx::info( unsigned inf ) -->
+  <function name="idx::info">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex idx::map( map_function & f ) -->
+  <function name="idx::map">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool idx::match_same_type( const basic & other ) -->
+  <function name="idx::match_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- size_t idx::nops( void ) -->
+  <function name="idx::nops">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <use-retval/>
+  </function>
+  <!-- ex idx::op( size_t i ) -->
+  <function name="idx::op">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void idx::read_archive( const archive_node & n, lst & sym_lst ) -->
+  <function name="idx::read_archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- ex idx::subs( const exmap & m, unsigned options ) -->
+  <function name="idx::subs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- basic * GiNaC::dummy_func( void ) -->
+  <function name="GiNaC::dummy_func">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="basic *"/>
+    <use-retval/>
+  </function>
+  <!-- bool exprseq::info( unsigned inf ) -->
+  <function name="exprseq::info">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void GiNaC::print_operator( const print_context & c, relational::operators o ) -->
+  <function name="GiNaC::print_operator">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void relational::archive( archive_node & n ) -->
+  <function name="relational::archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- unsigned relational::calchash( void ) -->
+  <function name="relational::calchash">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- int relational::compare_same_type( const basic & other ) -->
+  <function name="relational::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex relational::eval_ncmul( const exvector & v ) -->
+  <function name="relational::eval_ncmul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool relational::info( unsigned inf ) -->
+  <function name="relational::info">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- relational::safe_bool relational::make_safe_bool( bool cond ) -->
+  <function name="relational::make_safe_bool">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="relational::safe_bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex relational::map( map_function & f ) -->
+  <function name="relational::map">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool relational::match_same_type( const basic & other ) -->
+  <function name="relational::match_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- size_t relational::nops( void ) -->
+  <function name="relational::nops">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <use-retval/>
+  </function>
+  <!-- ex relational::op( size_t i ) -->
+  <function name="relational::op">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void relational::read_archive( const archive_node & n, lst & sym_lst ) -->
+  <function name="relational::read_archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- unsigned relational::return_type( void ) -->
+  <function name="relational::return_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- return_type_t relational::return_type_tinfo( void ) -->
+  <function name="relational::return_type_tinfo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="return_type_t"/>
+    <use-retval/>
+  </function>
+  <!-- ex relational::subs( const exmap & m, unsigned options ) -->
+  <function name="relational::subs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void pseries::archive( archive_node & n ) -->
+  <function name="pseries::archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- ex pseries::coeff( const ex & s, int n ) -->
+  <function name="pseries::coeff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex pseries::collect( const ex & s, bool distributed ) -->
+  <function name="pseries::collect">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int pseries::compare_same_type( const basic & other ) -->
+  <function name="pseries::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex pseries::conjugate( void ) -->
+  <function name="pseries::conjugate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- int pseries::degree( const ex & s ) -->
+  <function name="pseries::degree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex pseries::derivative( const symbol & s ) -->
+  <function name="pseries::derivative">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ex pseries::eval( void ) -->
+  <function name="pseries::eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex pseries::eval_integ( void ) -->
+  <function name="pseries::eval_integ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex pseries::evalf( void ) -->
+  <function name="pseries::evalf">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex pseries::evalm( void ) -->
+  <function name="pseries::evalm">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex pseries::expand( unsigned options ) -->
+  <function name="pseries::expand">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex pseries::imag_part( void ) -->
+  <function name="pseries::imag_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- int pseries::ldegree( const ex & s ) -->
+  <function name="pseries::ldegree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- size_t pseries::nops( void ) -->
+  <function name="pseries::nops">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <use-retval/>
+  </function>
+  <!-- ex pseries::op( size_t i ) -->
+  <function name="pseries::op">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void pseries::read_archive( const archive_node & n, lst & sym_lst ) -->
+  <function name="pseries::read_archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- ex pseries::real_part( void ) -->
+  <function name="pseries::real_part">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <use-retval/>
+  </function>
+  <!-- ex basic::series( const relational & r, int order, unsigned options ) -->
+  <function name="basic::series">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- ex pseries::subs( const exmap & m, unsigned options ) -->
+  <function name="pseries::subs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- const symmetry & GiNaC::index0( void ) -->
+  <function name="GiNaC::index0">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const symmetry &amp;"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- const symmetry & GiNaC::index1( void ) -->
+  <function name="GiNaC::index1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const symmetry &amp;"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- const symmetry & GiNaC::index2( void ) -->
+  <function name="GiNaC::index2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const symmetry &amp;"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- const symmetry & GiNaC::index3( void ) -->
+  <function name="GiNaC::index3">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const symmetry &amp;"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- ex GiNaC::symm( const ex & e, exvector::const_iterator first, exvector::const_iterator last, bool asymmetric ) -->
+  <function name="GiNaC::symm">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ex"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void symmetry::archive( archive_node & n ) -->
+  <function name="symmetry::archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- unsigned symmetry::calchash( void ) -->
+  <function name="symmetry::calchash">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned"/>
+    <use-retval/>
+  </function>
+  <!-- int symmetry::compare_same_type( const basic & other ) -->
+  <function name="symmetry::compare_same_type">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void symmetry::read_archive( const archive_node & n, lst & sym_lst ) -->
+  <function name="symmetry::read_archive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+</def>
diff --git a/cfg/gnu.cfg b/cfg/gnu.cfg
index 97f562b7534..1c8d1597a7f 100644
--- a/cfg/gnu.cfg
+++ b/cfg/gnu.cfg
@@ -25,15 +25,46 @@
     <alloc init="false" buffer-size="malloc">pvalloc</alloc>
     <dealloc>free</dealloc>
   </memory>
-  <define name="bswap_16(x)" value="((unsigned short int) ((((x) &gt;&gt; 8) &amp; 0xff) | (((x) &amp; 0xff) &lt;&lt; 8)))"/>
+  <function name="bswap_16">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <returnValue type="uint16_t">((arg1 &amp; 0xff00u) &gt;&gt; 8) | ((arg1 &amp; 0x00ffu) &lt;&lt; 8)</returnValue>
+    <leak-ignore/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
   <define name="__bswap_constant_16(x)" value="bswap_16(x)"/>
   <define name="__builtin_bswap16(x)" value="bswap_16(x)"/>
   <define name="__bswap_16(x)" value="bswap_16(x)"/>
-  <define name="bswap_32(x)" value="((((x) &amp; 0xff000000) &gt;&gt; 24) | (((x) &amp; 0x00ff0000) &gt;&gt; 8) | (((x) &amp; 0x0000ff00) &lt;&lt; 8) | (((x) &amp; 0x000000ff) &lt;&lt; 24))"/>
+  <function name="bswap_32">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <returnValue type="uint32_t">((arg1 &amp; 0xff000000ul) &gt;&gt; 24) | ((arg1 &amp; 0x00ff0000ul) &gt;&gt; 8) | ((arg1 &amp; 0x0000ff00ul) &lt;&lt; 8) | ((arg1 &amp; 0x000000fful) &lt;&lt; 24)</returnValue>
+    <leak-ignore/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
   <define name="__bswap_constant_32(x)" value="bswap_32(x)"/>
   <define name="__builtin_bswap32(x)" value="bswap_32(x)"/>
   <define name="__bswap_32(x)" value="bswap_32(x)"/>
-  <define name="bswap_64(x)" value="((((x) &amp; 0xff00000000000000ull) &gt;&gt; 56) | (((x) &amp; 0x00ff000000000000ull) &gt;&gt; 40) | (((x) &amp; 0x0000ff0000000000ull) &gt;&gt; 24) | (((x) &amp; 0x000000ff00000000ull) &gt;&gt; 8) | (((x) &amp; 0x00000000ff000000ull) &lt;&lt; 8) | (((x) &amp; 0x0000000000ff0000ull) &lt;&lt; 24) | (((x) &amp; 0x000000000000ff00ull) &lt;&lt; 40) | (((x) &amp; 0x00000000000000ffull) &lt;&lt; 56))"/>
+  <function name="bswap_64">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <returnValue type="uint64_t">((arg1 &amp; 0xff00000000000000ull) &gt;&gt; 56) | ((arg1 &amp; 0x00ff000000000000ull) &gt;&gt; 40) | ((arg1 &amp; 0x0000ff0000000000ull) &gt;&gt; 24) | ((arg1 &amp; 0x000000ff00000000ull) &gt;&gt; 8) | ((arg1 &amp; 0x00000000ff000000ull) &lt;&lt; 8) | ((arg1 &amp; 0x0000000000ff0000ull) &lt;&lt; 24) | ((arg1 &amp; 0x000000000000ff00ull) &lt;&lt; 40) | ((arg1 &amp; 0x00000000000000ffull) &lt;&lt; 56)</returnValue>
+    <leak-ignore/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <define name="__builtin_bit_cast(type,value)" value="std::bit_cast&lt;type&gt;(value)"/>
   <define name="__bswap_constant_64(x)" value="bswap_64(x)"/>
   <define name="__builtin_bswap64(x)" value="bswap_64(x)"/>
   <define name="__bswap_64(x)" value="bswap_64(x)"/>
@@ -45,8 +76,10 @@
   <define name="__builtin_nan(str)" value="nan(str)"/>
   <define name="__builtin_nanf(str)" value="nanf(str)"/>
   <define name="__builtin_nanl(str)" value="nanl(str)"/>
-  <define name="__builtin_signbit(value)" value="signbit(value)"/>
   <define name="__extension__" value=""/>
+  <define name="__typeof__(T)" value="typeof(T)"/>
+  <define name="__glibc_unlikely(x)" value="(x)"/>
+  <define name="__glibc_likely(x)" value="(x)"/>
   <!-- void *__builtin_alloca (size_t size) -->
   <!-- alloca() is often defined as __builtin_alloca() so the define above does not work always -->
   <!-- void *alloca(size_t size); -->
@@ -59,12 +92,58 @@
       <valid>0:</valid>
     </arg>
   </function>
+  <!-- https://man7.org/linux/man-pages/man2/semop.2.html -->
+  <!-- int semtimedop(int semid, struct sembuf *sops, size_t nsops, const struct timespec *timeout); -->
+  <function name="semtimedop">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <!--  If the timeout argument is NULL, then semtimedop() behaves exactly like semop() -->
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void * __builtin_assume_aligned (const void *exp, size_t align, ...) -->
+  <!-- This function can have either two or three arguments, if it has three, the third argument should have integer type. -->
+  <function name="__builtin_assume_aligned">
+    <noreturn>false</noreturn>
+    <returnValue type="void *">arg1</returnValue>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in" default="0">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
   <!-- void * __builtin_memcpy(void *dest, const void *source, size_t size);-->
   <!-- memcpy() is sometimes defined as __builtin_memcpy() so the define above does not work -->
   <function name="__builtin_memcpy">
     <noreturn>false</noreturn>
     <returnValue type="void *"/>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="3"/>
     <arg nr="1" direction="out">
       <not-null/>
       <minsize type="argvalue" arg="3"/>
@@ -90,46 +169,64 @@
       <not-uninit/>
     </arg>
   </function>
-  <!-- int timerisset(struct timeval *tvp); -->
-  <function name="timerisset">
+    <!-- https://man7.org/linux/man-pages/man3/getenv.3.html -->
+    <!-- char * secure_getenv(const char *name); -->
+  <function name="secure_getenv">
+    <use-retval/>
+    <returnValue type="char *"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <use-retval/>
-    <returnValue type="int"/>
     <arg nr="1" direction="in">
-      <not-uninit/>
       <not-null/>
+      <not-uninit/>
+      <strz/>
     </arg>
   </function>
-  <!-- void timerclear(struct timeval *tvp); -->
-  <function name="timerclear">
+  <!-- see https://www.man7.org/linux/man-pages/man3/dlmopen.3.html -->
+  <!-- void *dlmopen(Lmid_t lmid, const char *filename, int flags); -->
+  <function name="dlmopen">
     <noreturn>false</noreturn>
-    <leak-ignore/>
-    <returnValue type="void"/>
-    <arg nr="1" direction="inout">
-      <not-null/>
+    <use-retval/>
+    <returnValue type="void*"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void timeradd(struct timeval *a, struct timeval *b, struct timeval *res);-->
-  <!-- void timersub(struct timeval *a, struct timeval *b, struct timeval *res);-->
-  <function name="timeradd,timersub">
+  <!-- https://gcc.gnu.org/onlinedocs/gcc-6.2.0/gcc/Alignment.html -->
+  <!-- __alignof__ is used like sizeof -->
+  <!-- Declaration for this GNU compiler extension could look like this: -->
+  <!-- size_t __alignof__(type); -->
+  <!-- size_t __alignof__(expression); -->
+  <function name="__alignof__">
     <noreturn>false</noreturn>
+    <use-retval/>
     <leak-ignore/>
-    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/getpw.3.html -->
+  <!-- int getpw(uid_t uid, char *buf); -->
+    <function name="getpw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
     <arg nr="1" direction="in">
       <not-uninit/>
-      <not-null/>
-    </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
-      <not-null/>
+      <not-bool/>
     </arg>
-    <arg nr="3" direction="out">
+    <arg nr="2" direction="out">
       <not-null/>
+      <not-bool/>
     </arg>
+    <warn severity="style" reason="Obsolescent" alternatives="getpwnam"/>
   </function>
-  <!-- int timercmp(struct timeval *a, struct timeval *b, CMP)-->
-  <define name="timercmp(a,b,CMP)" value="(((a)-&gt;tv_sec == (b)-&gt;tv_sec) ? ((a)-&gt;tv_usec CMP (b)-&gt;tv_usec) : ((a)-&gt;tv_sec CMP (b)-&gt;tv_sec))"/>
   <!-- int __builtin_types_compatible_p (type1, type2) -->
   <function name="__builtin_types_compatible_p">
     <noreturn>false</noreturn>
@@ -140,7 +237,8 @@
     <arg nr="2"/>
   </function>
   <!-- void __builtin_trap (void) -->
-  <function name="__builtin_trap">
+  <!-- void __builtin_unreachable (void) -->
+  <function name="__builtin_trap,__builtin_unreachable">
     <noreturn>true</noreturn>
   </function>
   <!-- int __builtin_popcount (unsigned int x) -->
@@ -158,6 +256,50 @@
       <not-bool/>
     </arg>
   </function>
+  <!-- https://man7.org/linux/man-pages/man3/mempcpy.3.html-->
+  <!-- wchar_t *wmempcpy(wchar_t *restrict dest, const wchar_t *restrict src, size_t n);-->
+  <function name="wmempcpy">
+    <returnValue type="wchar_t *"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="3"/>
+    <arg nr="1" direction="out">
+      <not-null/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/mempcpy.3.html-->
+  <!-- void *mempcpy(void *restrict dest, const void *restrict src, size_t n);-->
+  <function name="mempcpy">
+    <returnValue type="void *"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="3"/>
+    <arg nr="1" direction="out">
+      <not-null/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
   <!-- void xexit(int status); -->
   <function name="xexit">
     <noreturn>true</noreturn>
@@ -184,6 +326,7 @@
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- void xfree(void *block); -->
@@ -251,7 +394,7 @@
     <arg nr="1" direction="out">
       <not-null/>
       <not-bool/>
-      <minsize type="value" value="2"/>
+      <minsize type="value" value="2" baseType="int"/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -308,6 +451,7 @@
     <arg nr="2" direction="in">
       <formatstr/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- int isascii_l(int c, locale_t locale); -->
@@ -337,6 +481,7 @@
     <arg nr="2" direction="in">
       <formatstr/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -365,6 +510,114 @@
     </arg>
     <leak-ignore/>
   </function>
+  <!-- https://man7.org/linux/man-pages/man3/gethostbyaddr_r.3.html -->
+  <!-- int gethostbyaddr_r(const void *addr, socklen_t len, int type, struct hostent *restrict ret, char *restrict buf, size_t buflen, struct hostent **restrict result, int *restrict h_errnop); -->
+  <function name="gethostbyaddr_r">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <minsize type="argvalue" arg="6"/>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="7" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="8" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/gethostbyname2_r.3.html -->
+  <!-- int gethostbyname2_r(const char *name, int af, struct hostent *ret, char *buf, size_t buflen, struct hostent **result, int *h_errnop); -->
+  <function name="gethostbyname2_r">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <minsize type="argvalue" arg="5"/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="7" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/gethostbyname_r.3.html -->
+  <!-- int gethostbyname_r(const char *name, struct hostent *ret, char *buf, size_t buflen, struct hostent **result, int *h_errnop); -->
+  <function name="gethostbyname_r">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <minsize type="argvalue" arg="4"/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- https://www.gnu.org/software/libc/manual/html_node/Getopt-Long-Options.html#Getopt-Long-Options -->
   <!-- int getopt_long(int argc, char * const argv[],
            const char *optstring,
@@ -405,6 +658,7 @@
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- char *strndupa(const char *s, size_t n); -->
@@ -415,6 +669,7 @@
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -454,6 +709,7 @@
       <not-uninit/>
       <not-null/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- char *strdupa(const char *s); -->
@@ -465,6 +721,7 @@
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- http://www.gnu.org/software/libc/manual/html_node/Backtraces.html -->
@@ -472,6 +729,7 @@
   <function name="backtrace">
     <returnValue type="int"/>
     <noreturn>false</noreturn>
+    <leak-ignore/>
     <arg nr="1" direction="out">
       <not-null/>
       <minsize type="argvalue" arg="2"/>
@@ -565,6 +823,30 @@
       <not-bool/>
     </arg>
   </function>
+  <!-- https://man7.org/linux/man-pages/man3/getservent_r.3.html -->
+  <!-- int getservent_r(struct servent *restrict result_buf, char *restrict buf, size_t buflen, struct servent **restrict result); -->
+  <function name="getservent_r">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <pure/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- https://linux.die.net/man/3/ecvt_r -->
   <!-- int ecvt_r (double value, int ndigit, int *decpt, int *neg, char *buf, size_t len); -->
   <function name="ecvt_r">
@@ -679,21 +961,23 @@
     <warn severity="style" reason="Obsolescent" alternatives="sprintf"/>
   </function>
   <!-- https://www.gnu.org/software/gnulib/manual/html_node/c_002dstrcasestr.html -->
-  <!-- size_t strcasestr(const char *s1, const char *s2); -->
+  <!-- char* strcasestr(const char *s1, const char *s2); -->
   <function name="strcasestr">
     <use-retval/>
-    <returnValue type="size_t"/>
+    <returnValue type="char *"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <pure/>
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- http://linux.die.net/man/2/getresuid -->
@@ -773,6 +1057,7 @@
     <arg nr="1">
       <not-uninit/>
       <not-null/>
+      <strz/>
     </arg>
     <arg nr="2">
       <not-null/>
@@ -787,6 +1072,7 @@
       <not-uninit/>
       <not-null/>
       <not-bool/>
+      <strz/>
     </arg>
     <leak-ignore/>
   </function>
@@ -838,6 +1124,7 @@
     <arg nr="2" direction="in">
       <not-uninit/>
       <not-null/>
+      <strz/>
     </arg>
     <arg nr="3" direction="out">
       <not-null/>
@@ -876,6 +1163,7 @@
     <arg nr="1" direction="in">
       <not-null/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- https://linux.die.net/man/3/execvpe -->
@@ -887,6 +1175,7 @@
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -897,7 +1186,7 @@
     </arg>
   </function>
   <!-- https://linux.die.net/man/3/mkostemp -->
-  <!-- int mkostemp(char *template, int flags); 
+  <!-- int mkostemp(char *template, int flags);
        int mkstemps(char *template, int suffixlen);-->
   <function name="mkostemp,mkstemps">
     <returnValue type="int"/>
@@ -965,6 +1254,7 @@
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <minsize type="argvalue" arg="3"/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -994,12 +1284,37 @@
       <valid>0:</valid>
     </arg>
   </function>
+  <!-- https://man7.org/linux/man-pages/man3/qsort.3.html -->
+  <!-- void qsort_r(void *base, size_t n, size_t size, int (*cmp)(const void *, const void *, void *), void *arg); -->
+  <function name="qsort_r">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+      <minsize type="argvalue" arg="2"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="4" direction="out">
+      <not-null/>
+      <not-bool/>
+    </arg>
+  </function>
   <!-- http://man7.org/linux/man-pages/man3/ffs.3.html -->
-  <!-- int ffsl(long int i); 
+  <!-- int ffsl(long int i);
        int ffsll(long long int i); -->
   <function name="ffsl,ffsll">
     <use-retval/>
-    <returnValue type="int"/>
+    <!-- It returns the position of the first bit set, or 0 if no bits are set in i. -->
+    <returnValue type="int">arg1==0 &amp;0</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1154,6 +1469,7 @@
       <not-null/>
       <not-uninit/>
       <minsize type="argvalue" arg="2"/>
+      <strz/>
     </arg>
     <arg nr="2">
       <not-uninit/>
@@ -1206,6 +1522,25 @@
       <not-bool/>
     </arg>
   </function>
+  <!-- int euidaccess(const char *pathname, int mode); -->
+  <!-- int eaccess(const char *pathname, int mode); -->
+  <!-- Ref: https://man7.org/linux/man-pages/man3/euidaccess.3.html
+         Conforming to: These functions are nonstandard. Some other systems have an eaccess() function. -->
+  <function name="euidaccess,eaccess">
+    <use-retval/>
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
   <!-- char * dcgettext (const char *domainname, const char *msgid, int category); -->
   <function name="dcgettext">
     <noreturn>false</noreturn>
@@ -1226,11 +1561,6 @@
       <not-bool/>
     </arg>
   </function>
-  <!-- https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html -->
-  <!-- void __builtin_trap (void) -->
-  <function name="__builtin_trap">
-    <noreturn>true</noreturn>
-  </function>
   <!-- int __builtin_constant_p (exp) -->
   <function name="__builtin_constant_p">
     <noreturn>false</noreturn>
@@ -1259,6 +1589,123 @@
       <not-bool/>
     </arg>
   </function>
+  <!-- http://man7.org/linux/man-pages/man2/mmap.2.html -->
+  <!-- void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset); -->
+  <!-- In contrast to POSIX, the GNU mmap allows/requires (depends on the implementation) fd to be -1 if MAP_ANONYMOUS or MAP_ANON is specified -->
+  <function name="mmap">
+    <use-retval/>
+    <returnValue type="void *"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <valid>1:</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <valid>-1:</valid>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- Note: fstatat64() is a large-file version of the fstatat() function -->
+  <!-- int fstatat64(int dirfd, const char *pathname, struct stat64  *statbuf, int flags); -->
+  <function name="fstatat64">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-bool/>
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int __fxstatat64 (int __ver, int __fildes, const char *__filename, struct stat64 *__stat_buf, int __flag); -->
+  <function name="__fxstatat64">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="4" direction="out">
+      <not-null/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-bool/>
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/dlsym.3.html -->
+  <!-- void *dlvsym(void *restrict handle, const char *restrict symbol, const char *restrict version); -->
+  <function name="dlvsym">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="void*"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man2/getcwd.2.html -->
+  <!-- char *get_current_dir_name(void); -->
+  <function name="get_current_dir_name">
+    <returnValue type="char *"/>
+    <use-retval/>
+    <noreturn>false</noreturn>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/error.3.html -->
+  <!-- void error(int status, int errnum, const char *format, ...); -->
+  <!-- void error_at_line(int status, int errnum, const char *filename, unsigned int linenum, const char *format, ...); -->
+  <function name="error,error_at_line">
+    <noreturn>true</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="any" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- ########## Resource allocation ########## -->
   <resource>
     <alloc init="true">mkostemp</alloc>
@@ -1282,4 +1729,10 @@
   <define name="SIGIO" value="29"/>
   <define name="SIGPWR" value="30"/>
   <define name="SIGUNUSED" value="31"/>
+  <!-- see https://man7.org/linux/man-pages/man3/stdin.3.html -->
+  <define name="STDIN_FILENO" value="0"/>
+  <define name="STDOUT_FILENO" value="1"/>
+  <define name="STDERR_FILENO" value="2"/>
+  <entrypoint name="_init"/>
+  <entrypoint name="_fini"/>
 </def>
diff --git a/cfg/googletest.cfg b/cfg/googletest.cfg
index f8d2d7b5932..c32eef7274b 100644
--- a/cfg/googletest.cfg
+++ b/cfg/googletest.cfg
@@ -1,33 +1,39 @@
 <?xml version="1.0"?>
 <def format="2">
-  <!-- see https://github.com/google/googletest/blob/master/googletest/docs/primer.md -->
-  <define name="ASSERT_TRUE(cond)" value="(void)(cond)"/>
+  <!-- see https://github.com/google/googletest/blob/main/docs/primer.md -->
+  <define name="ASSERT_TRUE(cond)" value="{if (!(cond)) throw false;}"/>
   <define name="EXPECT_TRUE(cond)" value="(void)(cond)"/>
-  <define name="ASSERT_FALSE(cond)" value="(void)(cond)"/>
+  <define name="ASSERT_FALSE(cond)" value="{if (cond) throw false;}"/>
   <define name="EXPECT_FALSE(cond)" value="(void)(cond)"/>
-  <define name="ASSERT_EQ(val1,val2)" value="(void)((val1)==(val2))"/>
+  <define name="ASSERT_EQ(val1,val2)" value="{if (!((val1) == (val2))) throw false;}"/>
   <define name="EXPECT_EQ(val1,val2)" value="(void)((val1)==(val2))"/>
-  <define name="ASSERT_NE(val1,val2)" value="(void)((val1)!=(val2))"/>
+  <define name="ASSERT_NE(val1,val2)" value="{if (!((val1) != (val2))) throw false;}"/>
   <define name="EXPECT_NE(val1,val2)" value="(void)((val1)!=(val2))"/>
-  <define name="ASSERT_LT(val1,val2)" value="(void)((val1)&lt;(val2))"/>
+  <define name="ASSERT_LT(val1,val2)" value="{if (!((val1) &lt; (val2))) throw false;}"/>
   <define name="EXPECT_LT(val1,val2)" value="(void)((val1)&lt;(val2))"/>
-  <define name="ASSERT_LE(val1,val2)" value="(void)((val1)&lt;=(val2))"/>
+  <define name="ASSERT_LE(val1,val2)" value="{if (!((val1) &lt;= (val2))) throw false;}"/>
   <define name="EXPECT_LE(val1,val2)" value="(void)((val1)&lt;=(val2))"/>
-  <define name="ASSERT_GT(val1,val2)" value="(void)((val1)&gt;(val2))"/>
+  <define name="ASSERT_GT(val1,val2)" value="{if (!((val1) &gt; (val2))) throw false;}"/>
   <define name="EXPECT_GT(val1,val2)" value="(void)((val1)&gt;(val2))"/>
-  <define name="ASSERT_GE(val1,val2)" value="(void)((val1)&gt;=(val2))"/>
+  <define name="ASSERT_GE(val1,val2)" value="{if (!((val1) &gt;= (val2))) throw false;}"/>
   <define name="EXPECT_GE(val1,val2)" value="(void)((val1)&gt;=(val2))"/>
-  <define name="ASSERT_STREQ(str1,str2)" value="(void)(*(str1)==*(str2))"/>
+  <define name="ASSERT_STREQ(str1,str2)" value="{if (!(strcmp(str1, str2) == 0)) throw false;}"/>
   <define name="EXPECT_STREQ(str1,str2)" value="(void)(*(str1)==*(str2))"/>
-  <define name="ASSERT_STRNE(str1,str2)" value="(void)(*(str1)!=*(str2))"/>
+  <define name="ASSERT_STRNE(str1,str2)" value="{if (!(strcmp(str1, str2) != 0)) throw false;}"/>
   <define name="EXPECT_STRNE(str1,str2)" value="(void)(*(str1)!=*(str2))"/>
-  <define name="ASSERT_STRCASEEQ(str1,str2)" value="(void)(*(str1)==*(str2))"/>
+  <define name="ASSERT_STRCASEEQ(str1,str2)" value="{if (!(stricmp(str1, str2) == 0)) throw false;}"/>
   <define name="EXPECT_STRCASEEQ(str1,str2)" value="(void)(*(str1)==*(str2))"/>
-  <define name="ASSERT_STRCASENE(str1,str2)" value="(void)(*(str1)!=*(str2))"/>
+  <define name="ASSERT_STRCASENE(str1,str2)" value="{if (!(stricmp(str1, str2) != 0)) throw false;}"/>
   <define name="EXPECT_STRCASENE(str1,str2)" value="(void)(*(str1)!=*(str2))"/>
-  <define name="TEST(A,B)" value="void __ ## A ## _ ## B ( )"/>
-  <define name="TEST_F(A,B)" value="void __ ## A ## _ ## B ( )"/>
-  <define name="TEST_P(A,B)" value="void __ ## A ## _ ## B ( )"/>
+  <define name="ASSERT_THROW(code, e)" value="try{code;}catch(e){}"/>
+  <define name="EXPECT_THROW(code, e)" value="try{code;}catch(e){}"/>
+  <define name="ASSERT_NO_THROW(code)" value="code"/>
+  <define name="EXPECT_NO_THROW(code)" value="code"/>
+  <define name="TEST(A,B)" value="class __ ## A ## _ ## B { public: static void testBody( ); }; __ ## A ## _ ## B::testBody()"/>
+  <define name="TEST_F(A,B)" value="class __ ## A ## _ ## B { public: static void testBody( ); }; __ ## A ## _ ## B::testBody()"/>
+  <define name="TEST_P(A,B)" value="class __ ## A ## _ ## B { public: static void testBody( ); }; __ ## A ## _ ## B::testBody()"/>
+  <define name="TYPED_TEST(A,B)" value="class __ ## A ## _ ## B { public: static void testBody( ); }; __ ## A ## _ ## B::testBody()"/>
+  <define name="TYPED_TEST_P(A,B)" value="class __ ## A ## _ ## B { public: static void testBody( ); }; __ ## A ## _ ## B::testBody()"/>
   <define name="GTEST_API_" value=""/>
   <define name="GTEST_FLAG(name)" value="FLAGS_gtest_##name"/>
   <define name="GTEST_DECLARE_bool_(name)" value="GTEST_API_ extern bool GTEST_FLAG(name)"/>
@@ -39,4 +45,18 @@
   <define name="GTEST_CONCAT_TOKEN_(foo, bar)" value="GTEST_CONCAT_TOKEN_IMPL_(foo, bar)"/>
   <define name="GTEST_CONCAT_TOKEN_IMPL_(foo, bar)" value="foo ## bar"/>
   <define name="GTEST_STRINGIFY_(name)" value="#name"/>
+  <define name="GTEST_REFERENCE_TO_CONST_(T)" value="typename ::testing::internal::ConstRef&lt;T&gt;::type"/>
+  <define name="GTEST_ATTRIBUTE_UNUSED_" value="__attribute__ ((unused))"/>
+  <define name="MATCHER(name, description,...)" value="bool name##Matcher&lt;_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain( GTEST_REFERENCE_TO_CONST_(arg_type) arg, ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) const"/>
+  <define name="MATCHER_P(name, p0, description)" value="bool name##MatcherP&lt;p0##_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain( GTEST_REFERENCE_TO_CONST_(arg_type) arg, ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) const"/>
+  <define name="MATCHER_P2(name, p0, p1, description)" value="bool name##MatcherP2&lt;p0##_type, p1##_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain(GTEST_REFERENCE_TO_CONST_(arg_type) arg,::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) const"/>
+  <define name="MATCHER_P3(name, p0, p1, p2, description)" value="bool name##MatcherP3&lt;p0##_type, p1##_type, p2##_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain(GTEST_REFERENCE_TO_CONST_(arg_type) arg,::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) const"/>
+  <define name="MATCHER_P4(name, p0, p1, p2, p3, description)" value="bool name##MatcherP4&lt;p0##_type, p1##_type, p2##_type, p3##_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain(GTEST_REFERENCE_TO_CONST_(arg_type) arg,::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) const"/>
+  <define name="MATCHER_P5(name, p0, p1, p2, p3, p4, description)" value="bool name##MatcherP5&lt;p0##_type, p1##_type, p2##_type, p3##_type, p4##_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain(GTEST_REFERENCE_TO_CONST_(arg_type) arg,::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) const"/>
+  <define name="MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description)" value="bool name##MatcherP6&lt;p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain(GTEST_REFERENCE_TO_CONST_(arg_type) arg,::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) const"/>
+  <define name="MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description)" value="bool name##MatcherP7&lt;p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, p6##_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain(GTEST_REFERENCE_TO_CONST_(arg_type) arg,::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) const"/>
+  <define name="MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description)" value="bool name##MatcherP8&lt;p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, p6##_type, p7##_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain(GTEST_REFERENCE_TO_CONST_(arg_type) arg,::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) const"/>
+  <define name="MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description)" value="bool name##MatcherP9&lt;p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, p6##_type, p7##_type, p8##_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain(GTEST_REFERENCE_TO_CONST_(arg_type) arg,::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) const"/>
+  <define name="MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description)" value="bool name##MatcherP10&lt;p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, p6##_type, p7##_type, p8##_type, p9##_type&gt;::gmock_Impl&lt;arg_type&gt;::MatchAndExplain(GTEST_REFERENCE_TO_CONST_(arg_type) arg,::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_) const"/>
+  <define name="MOCK_METHOD(...)" value=""/>
 </def>
diff --git a/cfg/gtk.cfg b/cfg/gtk.cfg
index a0af9b3e8a2..4dd9700c62c 100644
--- a/cfg/gtk.cfg
+++ b/cfg/gtk.cfg
@@ -2,10 +2,12 @@
 <!-- This file once has been generated automatically. See https://github.com/scriptum/cppcheck-libs -->
 <!-- Now it is maintained and extended manually. -->
 <def format="2">
-  <define name="g_return_if_fail(expr)" value="do{if(!(expr)){return;}}while(0)"/>
-  <define name="g_return_val_if_fail(expr, val)" value="do{if(!(expr)){return val;}}while(0)"/>
-  <define name="g_return_if_reached()" value="do{return;}while(0)"/>
-  <define name="g_return_val_if_reached(val)" value="do{return val;}while(0)"/>
+  <define name="TRUE" value="(!FALSE)"/>
+  <define name="FALSE" value="(0)"/>
+  <define name="g_return_if_fail(expr)" value="do{if(!(expr)){return;}}while(0);"/>
+  <define name="g_return_val_if_fail(expr,val)" value="do{if(!(expr)){return (val);}}while(0);"/>
+  <define name="g_return_if_reached()" value="do{return;}while(0);"/>
+  <define name="g_return_val_if_reached(val)" value="do{return (val);}while(0);"/>
   <define name="G_CALLBACK(cb)" value="cb"/>
   <define name="GTK_SIGNAL_FUNC(f)" value="G_CALLBACK(f)"/>
   <!-- https://developer.gnome.org/glib/stable/glib-Miscellaneous-Macros.html -->
@@ -36,11 +38,22 @@
   <define name="G_STRINGIFY_ARG(contents)" value="#contents"/>
   <define name="G_STRLOC" value="__FILE__ &quot;:&quot; G_STRINGIFY (__LINE__)"/>
   <define name="G_STRFUNC" value="((const char*) (__FUNCTION__))"/>
+  <define name="G_DEFINE_TYPE(TN, t_n, T_P)" value=""/>
   <define name="G_DEFINE_TYPE_WITH_PRIVATE(TN, t_n, T_P)" value=""/>
   <define name="G_DEFINE_TYPE_WITH_CODE(TN, t_n, T_P, _C_)" value=""/>
+  <define name="G_DEFINE_FINAL_TYPE(TN, t_n, T_P)" value=""/>
+  <define name="G_DEFINE_FINAL_TYPE_WITH_PRIVATE(TN, t_n, T_P)" value=""/>
+  <define name="G_DEFINE_FINAL_TYPE_WITH_CODE(TN, t_n, T_P, _C_)" value=""/>
   <define name="G_DEFINE_ABSTRACT_TYPE(TN, t_n, T_P)" value=""/>
   <define name="G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE(TN, t_n, T_P)" value=""/>
   <define name="G_DEFINE_ABSTRACT_TYPE_WITH_CODE(TN, t_n, T_P, _C_)" value=""/>
+  <define name="G_DEFINE_DYNAMIC_TYPE(TN, t_n, T_P)" value=""/>
+  <define name="G_DEFINE_DYNAMIC_TYPE_EXTENDED(TN, t_n, T_P, _f_, _C_)" value=""/>
+  <define name="G_DEFINE_BOXED_TYPE(TypeName,type_name,copy_func,free_func)" value=""/>
+  <define name="G_DEFINE_BOXED_TYPE_WITH_CODE(TypeName,type_name,copy_func,free_func,_C_)" value=""/>
+  <define name="G_DEFINE_QUARK(QN,q_n)" value=""/>
+  <define name="G_BEGIN_DECLS" value=""/>
+  <define name="G_END_DECLS" value=""/>
   <define name="G_ADD_PRIVATE(TypeName)" value=""/>
   <define name="G_PRIVATE_OFFSET(TypeName, field)" value=""/>
   <define name="G_PRIVATE_FIELD(TypeName, inst, field_type, field_name)" value=""/>
@@ -49,6 +62,9 @@
   <define name="G_DEFINE_INTERFACE_WITH_CODE(TN, t_n, T_P, _C_)" value=""/>
   <define name="G_DEFINE_TYPE_EXTENDED(TN, t_n, T_P, _f_, _C_)" value=""/>
   <define name="G_IMPLEMENT_INTERFACE(TYPE_IFACE, iface_init)" value=""/>
+  <define name="G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC(TypeName, func)" value=""/>
+  <define name="G_DEFINE_AUTO_CLEANUP_FREE_FUNC(TypeName, func, none)" value=""/>
+  <define name="G_DEFINE_AUTOPTR_CLEANUP_FUNC(TypeName, func)" value=""/>
   <define name="MAX(a, b)" value="(((a) &gt; (b)) ? (a) : (b))"/>
   <define name="MIN(a, b)" value="(((a) &lt; (b)) ? (a) : (b))"/>
   <define name="ABS(a)" value="(((a) &lt; 0) ? -(a) : (a))"/>
@@ -96,6 +112,7 @@
   <define name="g_try_new(struct_type, n_structs)" value="_G_NEW (struct_type, n_structs, try_malloc)"/>
   <define name="g_try_new0(struct_type, n_structs)" value="_G_NEW (struct_type, n_structs, try_malloc0)"/>
   <define name="g_try_renew(struct_type, mem, n_structs)" value="_G_RENEW (struct_type, mem, n_structs, try_realloc)"/>
+  <define name="GTK_BUTTON(obj)" value="((GtkButton*)(obj))"/>
   <define name="GTK_BOX(obj)" value="((GtkBox*)(obj))"/>
   <define name="GTK_CONTAINER(obj)" value="((GtkContainer*)(obj))"/>
   <define name="GTK_ENTRY(obj)" value="((GtkEntry*)(obj))"/>
@@ -106,6 +123,7 @@
   <define name="GTK_MISC(obj)" value="((GtkMisc*)(obj))"/>
   <define name="GTK_NOTEBOOK(obj)" value="((GtkNotebook*)(obj))"/>
   <define name="GTK_TABLE(obj)" value="((GtkTable*)(obj))"/>
+  <define name="GTK_TEXT_VIEW(obj)" value="((GtkTextView*)(obj))"/>
   <define name="GTK_SPIN_BUTTON(obj)" value="((GtkSpinButton*)(obj))"/>
   <define name="GTK_TREE_VIEW(obj)" value="((GtkTreeView*)(obj))"/>
   <define name="GTK_TREE_MODEL(obj)" value="((GtkTreeModel*)(obj))"/>
@@ -161,6 +179,15 @@
   <define name="NC_(context, string)" value="(string)"/>
   <define name="g_assert(expr)" value="assert(expr)"/>
   <define name="g_assert_not_reached()" value="assert(NULL)"/>
+  <define name="g_assert_true(expr)" value="g_assert(expr)"/>
+  <define name="g_assert_false(expr)" value="g_assert(!(expr))"/>
+  <define name="g_assert_cmpstr(s1, cmp, s2)" value="g_assert_true(g_strcmp0 ((s1), (s2)) cmp 0)"/>
+  <define name="g_assert_cmpint(n1, cmp, n2)" value="g_assert_true((n1) cmp (n2))"/>
+  <define name="g_assert_cmpuint(n1, cmp, n2)" value="g_assert_true((n1) cmp (n2))"/>
+  <define name="g_assert_cmphex(n1, cmp, n2)" value="g_assert_true((n1) cmp (n2))"/>
+  <define name="g_assert_cmpfloat(n1, cmp, n2)" value="g_assert_true((n1) cmp (n2))"/>
+  <define name="g_assert_null(expr)" value="g_assert_true((expr) == NULL)"/>
+  <define name="g_assert_nonnull(expr)" value="g_assert_true((expr) != NULL)"/>
   <define name="g_signal_connect(instance, detailed_signal, c_handler, data)" value="g_signal_connect_data ((instance), (detailed_signal), (c_handler), (data), NULL, (GConnectFlags) 0)"/>
   <define name="g_signal_connect_after(instance, detailed_signal, c_handler, data)" value="g_signal_connect_data ((instance), (detailed_signal), (c_handler), (data), NULL, G_CONNECT_AFTER)"/>
   <define name="g_signal_connect_swapped(instance, detailed_signal, c_handler, data)" value="g_signal_connect_data ((instance), (detailed_signal), (c_handler), (data), NULL, G_CONNECT_SWAPPED)"/>
@@ -177,710 +204,770 @@
   <define name="g_array_index(a,t,i)" value="(((t*) (void *) (a)-&gt;data) [(i)])"/>
   <define name="g_ptr_array_index(array,index_)" value="((array)-&gt;pdata)[index_]"/>
   <define name="g_slist_next(slist)" value="((slist) ? (((GSList *)(slist))-&gt;next) : NULL)"/>
+  <define name="g_strstrip(string)" value="g_strchomp (g_strchug (string))"/>
+  <!-- https://docs.gtk.org/glib/struct.VariantType.html -->
+  <define name="G_VARIANT_TYPE_BOOLEAN" value="((const GVariantType *) &quot;b&quot;)"/>
+  <define name="G_VARIANT_TYPE_BYTE" value="((const GVariantType *) &quot;y&quot;)"/>
+  <define name="G_VARIANT_TYPE_INT16" value="((const GVariantType *) &quot;n&quot;)"/>
+  <define name="G_VARIANT_TYPE_UINT16" value="((const GVariantType *) &quot;q&quot;)"/>
+  <define name="G_VARIANT_TYPE_INT32" value="((const GVariantType *) &quot;i&quot;)"/>
+  <define name="G_VARIANT_TYPE_UINT32" value="((const GVariantType *) &quot;u&quot;)"/>
+  <define name="G_VARIANT_TYPE_INT64" value="((const GVariantType *) &quot;x&quot;)"/>
+  <define name="G_VARIANT_TYPE_UINT64" value="((const GVariantType *) &quot;t&quot;)"/>
+  <define name="G_VARIANT_TYPE_DOUBLE" value="((const GVariantType *) &quot;d&quot;)"/>
+  <define name="G_VARIANT_TYPE_STRING" value="((const GVariantType *) &quot;s&quot;)"/>
+  <define name="G_VARIANT_TYPE_OBJECT_PATH" value="((const GVariantType *) &quot;o&quot;)"/>
+  <define name="G_VARIANT_TYPE_SIGNATURE" value="((const GVariantType *) &quot;g&quot;)"/>
+  <define name="G_VARIANT_TYPE_VARIANT" value="((const GVariantType *) &quot;v&quot;)"/>
+  <define name="G_VARIANT_TYPE_HANDLE" value="((const GVariantType *) &quot;h&quot;)"/>
+  <define name="G_VARIANT_TYPE_UNIT" value="((const GVariantType *) &quot;()&quot;)"/>
+  <define name="G_VARIANT_TYPE_ANY" value="((const GVariantType *) &quot;*&quot;)"/>
+  <define name="G_VARIANT_TYPE_BASIC" value="((const GVariantType *) &quot;?&quot;)"/>
+  <define name="G_VARIANT_TYPE_MAYBE" value="((const GVariantType *) &quot;m*&quot;)"/>
+  <define name="G_VARIANT_TYPE_ARRAY" value="((const GVariantType *) &quot;a*&quot;)"/>
+  <define name="G_VARIANT_TYPE_TUPLE" value="((const GVariantType *) &quot;r&quot;)"/>
+  <define name="G_VARIANT_TYPE_DICT_ENTRY" value="((const GVariantType *) &quot;{?*}&quot;)"/>
+  <define name="G_VARIANT_TYPE_DICTIONARY" value="((const GVariantType *) &quot;a{?*}&quot;)"/>
+  <define name="G_VARIANT_TYPE_STRING_ARRAY" value="((const GVariantType *) &quot;as&quot;)"/>
+  <define name="G_VARIANT_TYPE_OBJECT_PATH_ARRAY" value="((const GVariantType *) &quot;ao&quot;)"/>
+  <define name="G_VARIANT_TYPE_BYTESTRING" value="((const GVariantType *) &quot;ay&quot;)"/>
+  <define name="G_VARIANT_TYPE_BYTESTRING_ARRAY" value="((const GVariantType *) &quot;aay&quot;)"/>
+  <define name="G_VARIANT_TYPE_VARDICT" value="((const GVariantType *) &quot;a{sv}&quot;)"/>
+  <define name="G_VARIANT_TYPE(s)" value="((const GVariantType *) (s))"/>
   <memory>
-    <alloc init="true">g_thread_new</alloc>
-    <alloc init="true">g_thread_try_new</alloc>
+    <alloc init="true" no-fail="true">g_thread_new</alloc>
+    <alloc init="true" no-fail="false">g_thread_try_new</alloc>
     <use>g_thread_ref</use>
     <dealloc>g_thread_unref</dealloc>
+    <dealloc>g_thread_join</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_variant_iter_copy</alloc>
-    <alloc init="true">g_variant_iter_new</alloc>
+    <alloc init="true" no-fail="true">g_variant_iter_copy</alloc>
+    <alloc init="true" no-fail="true">g_variant_iter_new</alloc>
     <dealloc>g_variant_iter_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_source_new</alloc>
-    <alloc init="true">g_idle_source_new</alloc>
-    <alloc init="true">g_timeout_source_new</alloc>
-    <alloc init="true">g_timeout_source_new_seconds</alloc>
-    <alloc init="true">g_child_watch_source_new</alloc>
-    <alloc init="true">g_cancellable_source_new</alloc>
-    <alloc init="true">g_io_create_watch</alloc>
+    <alloc init="true" no-fail="true">g_source_new</alloc>
+    <alloc init="true" no-fail="true">g_idle_source_new</alloc>
+    <alloc init="true" no-fail="true">g_timeout_source_new</alloc>
+    <alloc init="true" no-fail="true">g_timeout_source_new_seconds</alloc>
+    <alloc init="true" no-fail="true">g_child_watch_source_new</alloc>
+    <alloc init="true" no-fail="true">g_cancellable_source_new</alloc>
+    <alloc init="true" no-fail="true">g_io_create_watch</alloc>
     <use>g_source_ref</use>
     <dealloc>g_source_unref</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_date_time_new</alloc>
-    <alloc init="true">g_date_time_new_now</alloc>
-    <alloc init="true">g_date_time_new_now_local</alloc>
-    <alloc init="true">g_date_time_new_now_utc</alloc>
-    <alloc init="true">g_date_time_new_from_unix_local</alloc>
-    <alloc init="true">g_date_time_new_from_unix_utc</alloc>
-    <alloc init="true">g_date_time_new_from_timeval_local</alloc>
-    <alloc init="true">g_date_time_new_from_timeval_utc</alloc>
-    <alloc init="true">g_date_time_new_local</alloc>
-    <alloc init="true">g_date_time_new_utc</alloc>
-    <alloc init="true">g_date_time_add</alloc>
-    <alloc init="true">g_date_time_add_years</alloc>
-    <alloc init="true">g_date_time_add_months</alloc>
-    <alloc init="true">g_date_time_add_weeks</alloc>
-    <alloc init="true">g_date_time_add_days</alloc>
-    <alloc init="true">g_date_time_add_hours</alloc>
-    <alloc init="true">g_date_time_add_minutes</alloc>
-    <alloc init="true">g_date_time_add_seconds</alloc>
-    <alloc init="true">g_date_time_add_full</alloc>
-    <alloc init="true">g_date_time_to_timezone</alloc>
-    <alloc init="true">g_date_time_to_local</alloc>
-    <alloc init="true">g_date_time_to_utc</alloc>
+    <alloc init="true" no-fail="true">g_date_time_new</alloc>
+    <alloc init="true" no-fail="true">g_date_time_new_now</alloc>
+    <alloc init="true" no-fail="true">g_date_time_new_now_local</alloc>
+    <alloc init="true" no-fail="true">g_date_time_new_now_utc</alloc>
+    <alloc init="true" no-fail="true">g_date_time_new_from_unix_local</alloc>
+    <alloc init="true" no-fail="true">g_date_time_new_from_unix_utc</alloc>
+    <alloc init="true" no-fail="true">g_date_time_new_from_timeval_local</alloc>
+    <alloc init="true" no-fail="true">g_date_time_new_from_timeval_utc</alloc>
+    <alloc init="true" no-fail="true">g_date_time_new_local</alloc>
+    <alloc init="true" no-fail="true">g_date_time_new_utc</alloc>
+    <alloc init="true" no-fail="true">g_date_time_add</alloc>
+    <alloc init="true" no-fail="true">g_date_time_add_years</alloc>
+    <alloc init="true" no-fail="true">g_date_time_add_months</alloc>
+    <alloc init="true" no-fail="true">g_date_time_add_weeks</alloc>
+    <alloc init="true" no-fail="true">g_date_time_add_days</alloc>
+    <alloc init="true" no-fail="true">g_date_time_add_hours</alloc>
+    <alloc init="true" no-fail="true">g_date_time_add_minutes</alloc>
+    <alloc init="true" no-fail="true">g_date_time_add_seconds</alloc>
+    <alloc init="true" no-fail="true">g_date_time_add_full</alloc>
+    <alloc init="true" no-fail="true">g_date_time_to_timezone</alloc>
+    <alloc init="true" no-fail="true">g_date_time_to_local</alloc>
+    <alloc init="true" no-fail="true">g_date_time_to_utc</alloc>
     <use>g_date_time_ref</use>
     <dealloc>g_date_time_unref</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_dir_open</alloc>
+    <alloc init="true" no-fail="false">g_dir_open</alloc>
     <alloc init="true">g_dir_rewind</alloc>
     <dealloc>g_dir_close</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_timer_new</alloc>
+    <alloc init="true" no-fail="true">g_timer_new</alloc>
     <dealloc>g_timer_destroy</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_file_attribute_info_list_new</alloc>
-    <alloc init="true">g_file_attribute_info_list_dup</alloc>
+    <alloc init="true" no-fail="true">g_file_attribute_info_list_new</alloc>
+    <alloc init="true" no-fail="true">g_file_attribute_info_list_dup</alloc>
     <use>g_file_attribute_info_list_ref</use>
     <dealloc>g_file_attribute_info_list_unref</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_slist_alloc</alloc>
-    <alloc init="true">g_slist_copy</alloc>
-    <alloc init="true">g_slist_copy_deep</alloc>
+    <alloc init="true" no-fail="true">g_slist_alloc</alloc>
+    <alloc init="true" no-fail="true">g_slist_copy</alloc>
+    <alloc init="true" no-fail="true">g_slist_copy_deep</alloc>
     <dealloc>g_slist_free</dealloc>
     <dealloc>g_slist_free_1</dealloc>
     <dealloc>g_slist_free_full</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_variant_new</alloc>
-    <alloc init="true">g_variant_new_va</alloc>
-    <alloc init="true">g_variant_new_boolean</alloc>
-    <alloc init="true">g_variant_new_byte</alloc>
-    <alloc init="true">g_variant_new_int16</alloc>
-    <alloc init="true">g_variant_new_uint16</alloc>
-    <alloc init="true">g_variant_new_int32</alloc>
-    <alloc init="true">g_variant_new_uint32</alloc>
-    <alloc init="true">g_variant_new_int64</alloc>
-    <alloc init="true">g_variant_new_uint64</alloc>
-    <alloc init="true">g_variant_new_handle</alloc>
-    <alloc init="true">g_variant_new_double</alloc>
-    <alloc init="true">g_variant_new_string</alloc>
-    <alloc init="true">g_variant_new_take_string</alloc>
-    <alloc init="true">g_variant_new_printf</alloc>
-    <alloc init="true">g_variant_new_signature</alloc>
-    <alloc init="true">g_variant_new_object_path</alloc>
-    <alloc init="true">g_variant_new_variant</alloc>
-    <alloc init="true">g_variant_new_objv</alloc>
-    <alloc init="true">g_variant_new_strv</alloc>
-    <alloc init="true">g_variant_new_bytestring</alloc>
-    <alloc init="true">g_variant_new_bytestring_array</alloc>
-    <alloc init="true">g_variant_new_maybe</alloc>
-    <alloc init="true">g_variant_new_array</alloc>
-    <alloc init="true">g_variant_new_tuple</alloc>
-    <alloc init="true">g_variant_new_dict_entry</alloc>
-    <alloc init="true">g_variant_new_fixed_array</alloc>
-    <alloc init="true">g_variant_new_from_data</alloc>
-    <alloc init="true">g_variant_new_from_bytes</alloc>
-    <alloc init="true">g_variant_builder_end</alloc>
-    <alloc init="true">g_variant_new_parsed_va</alloc>
-    <alloc init="true">g_variant_new_parsed</alloc>
-    <alloc init="true">g_variant_byteswap</alloc>
-    <alloc init="true">g_variant_get_child_value</alloc>
-    <alloc init="true">g_variant_get_normal_form</alloc>
-    <alloc init="true">g_variant_parse</alloc>
+    <alloc init="true" no-fail="true">g_variant_new</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_va</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_boolean</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_byte</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_int16</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_uint16</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_int32</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_uint32</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_int64</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_uint64</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_handle</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_double</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_string</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_take_string</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_printf</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_signature</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_object_path</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_variant</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_objv</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_strv</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_bytestring</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_bytestring_array</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_maybe</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_array</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_tuple</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_dict_entry</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_fixed_array</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_from_data</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_from_bytes</alloc>
+    <alloc init="true" no-fail="true">g_variant_builder_end</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_parsed_va</alloc>
+    <alloc init="true" no-fail="true">g_variant_new_parsed</alloc>
+    <alloc init="true" no-fail="true">g_variant_byteswap</alloc>
+    <alloc init="true" no-fail="true">g_variant_get_child_value</alloc>
+    <alloc init="true" no-fail="true">g_variant_get_normal_form</alloc>
+    <alloc init="true" no-fail="true">g_variant_parse</alloc>
     <use>g_variant_ref</use>
     <use>g_variant_take_ref</use>
+    <use>g_variant_builder_add</use>
+    <use>g_variant_builder_add_value</use>
+    <use>g_variant_builder_add_parsed</use>
     <use>g_variant_ref_sink</use>
     <dealloc>g_variant_unref</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_variant_iter_new</alloc>
+    <alloc init="true" no-fail="true">g_variant_iter_new</alloc>
     <dealloc>g_variant_iter_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_variant_type_new</alloc>
-    <alloc init="true">g_variant_type_copy</alloc>
-    <alloc init="true">g_variant_type_new_array</alloc>
-    <alloc init="true">g_variant_type_new_dict_entry</alloc>
-    <alloc init="true">g_variant_type_new_maybe</alloc>
-    <alloc init="true">g_variant_type_new_tuple</alloc>
+    <alloc init="true" no-fail="true">g_variant_type_new</alloc>
+    <alloc init="true" no-fail="true">g_variant_type_copy</alloc>
+    <alloc init="true" no-fail="true">g_variant_type_new_array</alloc>
+    <alloc init="true" no-fail="true">g_variant_type_new_dict_entry</alloc>
+    <alloc init="true" no-fail="true">g_variant_type_new_maybe</alloc>
+    <alloc init="true" no-fail="true">g_variant_type_new_tuple</alloc>
     <dealloc>g_variant_type_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_allocator_new</alloc>
+    <alloc init="true" no-fail="true">g_allocator_new</alloc>
     <dealloc>g_allocator_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_bookmark_file_new</alloc>
+    <alloc init="true" no-fail="true">g_bookmark_file_new</alloc>
     <dealloc>g_bookmark_file_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_srv_target_new</alloc>
+    <alloc init="true" no-fail="true">g_srv_target_new</alloc>
     <dealloc>g_srv_target_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_string_chunk_new</alloc>
+    <alloc init="true" no-fail="true">g_string_chunk_new</alloc>
     <dealloc>g_string_chunk_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_test_log_buffer_new</alloc>
+    <alloc init="true" no-fail="true">g_test_log_buffer_new</alloc>
     <dealloc>g_test_log_buffer_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_value_array_new</alloc>
+    <alloc init="true" no-fail="true">g_value_array_new</alloc>
     <dealloc>g_value_array_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_cache_new</alloc>
+    <alloc init="true" no-fail="true">g_cache_new</alloc>
     <dealloc>g_cache_destroy</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_cclosure_new</alloc>
-    <alloc init="true">g_cclosure_new_swap</alloc>
-    <alloc init="true">g_cclosure_new_object</alloc>
-    <alloc init="true">g_cclosure_new_object_swap</alloc>
-    <alloc init="true">g_closure_new_object</alloc>
-    <alloc init="true">g_closure_new_simple</alloc>
+    <alloc init="true" no-fail="true">g_cclosure_new</alloc>
+    <alloc init="true" no-fail="true">g_cclosure_new_swap</alloc>
+    <alloc init="true" no-fail="true">g_cclosure_new_object</alloc>
+    <alloc init="true" no-fail="true">g_cclosure_new_object_swap</alloc>
+    <alloc init="true" no-fail="true">g_closure_new_object</alloc>
+    <alloc init="true" no-fail="true">g_closure_new_simple</alloc>
     <use>g_closure_ref</use>
     <dealloc>g_closure_unref</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_array_new</alloc>
-    <alloc init="true">g_array_sized_new</alloc>
+    <alloc init="true" no-fail="true">g_array_new</alloc>
+    <alloc init="true" no-fail="true">g_array_sized_new</alloc>
     <use>g_array_ref</use>
     <dealloc>g_array_free</dealloc>
     <dealloc>g_array_unref</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_async_queue_new</alloc>
-    <alloc init="true">g_async_queue_new_full</alloc>
+    <alloc init="true" no-fail="true">g_async_queue_new</alloc>
+    <alloc init="true" no-fail="true">g_async_queue_new_full</alloc>
     <use>g_async_queue_ref</use>
     <dealloc>g_async_queue_unref</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_byte_array_new</alloc>
-    <alloc init="true">g_byte_array_sized_new</alloc>
-    <alloc init="true">g_byte_array_new_take</alloc>
-    <alloc init="true">g_byte_array_sized_new</alloc>
-    <alloc init="true">g_bytes_unref_to_array</alloc>
+    <alloc init="true" no-fail="true">g_byte_array_new</alloc>
+    <alloc init="true" no-fail="true">g_byte_array_sized_new</alloc>
+    <alloc init="true" no-fail="true">g_byte_array_new_take</alloc>
+    <alloc init="true" no-fail="true">g_byte_array_sized_new</alloc>
+    <alloc init="true" no-fail="true">g_bytes_unref_to_array</alloc>
     <use>g_byte_array_ref</use>
     <dealloc>g_byte_array_free</dealloc>
     <dealloc>g_byte_array_unref</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_checksum_new</alloc>
-    <alloc init="true">g_checksum_copy</alloc>
+    <alloc init="true" no-fail="true">g_checksum_new</alloc>
+    <alloc init="true" no-fail="true">g_checksum_copy</alloc>
     <dealloc>g_checksum_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_main_loop_new</alloc>
-    <alloc init="true">g_main_new</alloc>
+    <alloc init="true" no-fail="true">g_main_loop_new</alloc>
+    <alloc init="true" no-fail="true">g_main_new</alloc>
     <use>g_main_loop_ref</use>
     <dealloc>g_main_loop_unref</dealloc>
     <dealloc>g_main_destroy</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_main_context_new</alloc>
+    <alloc init="true" no-fail="true">g_main_context_new</alloc>
     <use>g_main_context_ref</use>
     <dealloc>g_main_context_unref</dealloc>
     <dealloc>g_main_destroy</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_thread_pool_new</alloc>
+    <alloc init="true" no-fail="true">g_thread_pool_new</alloc>
     <dealloc>g_thread_pool_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_error_copy</alloc>
-    <alloc init="true">g_error_new_valist</alloc>
-    <alloc init="true">g_error_new_literal</alloc>
-    <alloc init="true">g_error_new</alloc>
+    <alloc init="true" no-fail="true">g_error_copy</alloc>
+    <alloc init="true" no-fail="true">g_error_new_valist</alloc>
+    <alloc init="true" no-fail="true">g_error_new_literal</alloc>
+    <alloc init="true" no-fail="true">g_error_new</alloc>
     <dealloc>g_error_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_string_new</alloc>
-    <alloc init="true">g_string_new_len</alloc>
-    <alloc init="true">g_string_sized_new</alloc>
-    <alloc init="true">g_variant_print_string</alloc>
+    <alloc init="true" no-fail="true">g_string_new</alloc>
+    <alloc init="true" no-fail="true">g_string_new_len</alloc>
+    <alloc init="true" no-fail="true">g_string_sized_new</alloc>
+    <alloc init="true" no-fail="true">g_variant_print_string</alloc>
     <dealloc>g_string_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_ptr_array_new</alloc>
-    <alloc init="true">g_ptr_array_new_full</alloc>
-    <alloc init="true">g_ptr_array_new_with_free_func</alloc>
+    <alloc init="true" no-fail="true">g_ptr_array_new</alloc>
+    <alloc init="true" no-fail="true">g_ptr_array_new_full</alloc>
+    <alloc init="true" no-fail="true">g_ptr_array_new_with_free_func</alloc>
     <use>g_ptr_array_ref</use>
     <dealloc>g_ptr_array_free</dealloc>
     <dealloc>g_ptr_array_unref</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_pattern_spec_new</alloc>
+    <alloc init="true" no-fail="true">g_pattern_spec_new</alloc>
     <dealloc>g_pattern_spec_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_key_file_new</alloc>
+    <alloc init="true" no-fail="true">g_key_file_new</alloc>
     <use>g_key_file_ref</use>
     <dealloc>g_key_file_free</dealloc>
     <dealloc>g_key_file_unref</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_io_module_scope_new</alloc>
+    <alloc init="true" no-fail="true">g_io_module_scope_new</alloc>
     <dealloc>g_io_module_scope_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_ascii_strdown</alloc>
-    <alloc init="true">g_ascii_strup</alloc>
-    <alloc init="true">g_base64_decode</alloc>
-    <alloc init="true">g_base64_encode</alloc>
-    <alloc init="true">g_bookmark_file_get_description</alloc>
-    <alloc init="true">g_bookmark_file_get_mime_type</alloc>
-    <alloc init="true">g_bookmark_file_get_title</alloc>
-    <alloc init="true">g_bookmark_file_to_data</alloc>
-    <alloc init="true">g_build_filename</alloc>
-    <alloc init="true">g_build_filenamev</alloc>
-    <alloc init="true">g_build_path</alloc>
-    <alloc init="true">g_build_pathv</alloc>
-    <alloc init="true">g_bytes_unref_to_data</alloc>
-    <alloc init="true">g_compute_checksum_for_bytes</alloc>
-    <alloc init="true">g_compute_checksum_for_data</alloc>
-    <alloc init="true">g_compute_checksum_for_string</alloc>
-    <alloc init="true">g_compute_hmac_for_data</alloc>
-    <alloc init="true">g_compute_hmac_for_string</alloc>
-    <alloc init="true">g_convert</alloc>
-    <alloc init="true">g_convert_with_fallback</alloc>
-    <alloc init="true">g_convert_with_iconv</alloc>
-    <alloc init="true">g_credentials_to_string</alloc>
-    <alloc init="true">g_date_time_format</alloc>
-    <alloc init="true">g_filename_display_basename</alloc>
-    <alloc init="true">g_filename_display_name</alloc>
-    <alloc init="true">g_filename_from_uri</alloc>
-    <alloc init="true">g_filename_to_uri</alloc>
-    <alloc init="true">g_get_codeset</alloc>
-    <alloc init="true">g_get_current_dir</alloc>
-    <alloc init="true">g_get_locale_variants</alloc>
-    <alloc init="true">g_key_file_get_start_group</alloc>
-    <alloc init="true">g_key_file_to_data</alloc>
-    <alloc buffer-size="malloc">g_malloc</alloc>
-    <realloc buffer-size="malloc:2">g_realloc</realloc>
-    <alloc init="true" buffer-size="malloc">g_malloc0</alloc>
-    <alloc init="true" buffer-size="calloc">g_malloc0_n</alloc>
-    <alloc buffer-size="calloc">g_malloc_n</alloc>
-    <realloc buffer-size="calloc:2,3">g_realloc_n</realloc>
-    <alloc init="true">g_memdup</alloc>
-    <alloc init="true">g_path_get_basename</alloc>
-    <alloc init="true">g_path_get_dirname</alloc>
-    <alloc>g_slice_alloc</alloc>
-    <alloc init="true">g_slice_alloc0</alloc>
-    <alloc init="true">g_slice_copy</alloc>
-    <alloc init="true">g_strcompress</alloc>
-    <alloc init="true">g_strconcat</alloc>
-    <alloc init="true" buffer-size="strdup">g_strdup</alloc>
-    <alloc init="true">g_strdup_printf</alloc>
-    <alloc init="true">g_strdup_vprintf</alloc>
-    <alloc init="true">g_strescape</alloc>
-    <alloc init="true">g_strjoin</alloc>
-    <alloc init="true">g_strjoinv</alloc>
-    <alloc init="true">g_strndup</alloc>
-    <alloc init="true">g_strnfill</alloc>
-    <alloc init="true">g_time_val_to_iso8601</alloc>
-    <alloc buffer-size="malloc">g_try_malloc</alloc>
-    <realloc buffer-size="malloc:2">g_try_realloc</realloc>
-    <alloc init="true" buffer-size="malloc">g_try_malloc0</alloc>
-    <alloc init="true" buffer-size="calloc">g_try_malloc0_n</alloc>
-    <alloc buffer-size="calloc">g_try_malloc_n</alloc>
-    <realloc buffer-size="calloc:2,3">g_try_realloc_n</realloc>
-    <alloc init="true">g_ucs4_to_utf16</alloc>
-    <alloc init="true">g_ucs4_to_utf8</alloc>
-    <alloc init="true">g_unicode_canonical_decomposition</alloc>
-    <alloc init="true">g_utf16_to_ucs4</alloc>
-    <alloc init="true">g_utf16_to_utf8</alloc>
-    <alloc init="true">g_utf8_casefold</alloc>
-    <alloc init="true">g_utf8_collate_key</alloc>
-    <alloc init="true">g_utf8_collate_key_for_filename</alloc>
-    <alloc init="true">g_utf8_normalize</alloc>
-    <alloc init="true">g_utf8_strdown</alloc>
-    <alloc init="true">g_utf8_strreverse</alloc>
-    <alloc init="true">g_utf8_strup</alloc>
-    <alloc init="true">g_utf8_substring</alloc>
-    <alloc init="true">g_utf8_to_ucs4</alloc>
-    <alloc init="true">g_utf8_to_ucs4_fast</alloc>
-    <alloc init="true">g_utf8_to_ucs4_fast</alloc>
-    <alloc init="true">g_utf8_to_utf16</alloc>
-    <alloc init="true">g_key_file_get_locale_string</alloc>
-    <alloc init="true">g_key_file_get_value</alloc>
-    <alloc init="true">g_key_file_get_string</alloc>
-    <alloc init="true">g_key_file_get_boolean_list</alloc>
-    <alloc init="true">g_key_file_get_integer_list</alloc>
-    <alloc init="true">g_key_file_get_double_list</alloc>
-    <alloc init="true">g_key_file_get_comment</alloc>
-    <alloc init="true">g_dbus_proxy_get_name_owner</alloc>
-    <alloc init="true">g_file_info_get_attribute_as_string</alloc>
-    <alloc init="true">g_file_attribute_matcher_to_string</alloc>
-    <alloc init="true">g_app_launch_context_get_environment</alloc>
-    <alloc init="true">g_app_launch_context_get_startup_notify_id</alloc>
-    <alloc init="true">g_filename_completer_get_completion_suffix</alloc>
-    <alloc init="true">g_inet_address_mask_to_string</alloc>
-    <alloc init="true">g_variant_dup_string</alloc>
-    <alloc init="true">g_variant_dup_bytestring</alloc>
-    <alloc init="true">g_variant_get_objv</alloc>
-    <alloc init="true">g_variant_get_strv</alloc>
-    <alloc init="true">g_variant_print</alloc>
-    <alloc init="true">g_datalist_id_dup_data</alloc>
-    <alloc init="true">g_dir_make_tmp</alloc>
-    <alloc init="true">g_filename_from_utf8</alloc>
-    <alloc init="true">g_filename_to_utf8</alloc>
-    <alloc init="true">g_file_read_link</alloc>
-    <alloc init="true">g_find_program_in_path</alloc>
-    <alloc init="true">g_format_size</alloc>
-    <alloc init="true">g_format_size_for_display</alloc>
-    <alloc init="true">g_format_size_full</alloc>
-    <alloc init="true">g_hostname_to_ascii</alloc>
-    <alloc init="true">g_hostname_to_unicode</alloc>
-    <alloc init="true">g_locale_from_utf8</alloc>
-    <alloc init="true">g_locale_to_utf8</alloc>
-    <alloc init="true">g_markup_escape_text</alloc>
-    <alloc init="true">g_markup_printf_escaped</alloc>
-    <alloc init="true">g_markup_vprintf_escaped</alloc>
-    <alloc init="true">g_match_info_expand_references</alloc>
-    <alloc init="true">g_match_info_fetch</alloc>
-    <alloc init="true">g_match_info_fetch_named</alloc>
-    <alloc init="true">g_option_context_get_help</alloc>
-    <alloc init="true">g_regex_escape_nul</alloc>
-    <alloc init="true">g_regex_escape_string</alloc>
-    <alloc init="true">g_regex_replace</alloc>
-    <alloc init="true">g_regex_replace_eval</alloc>
-    <alloc init="true">g_regex_replace_literal</alloc>
-    <alloc init="true">g_shell_quote</alloc>
-    <alloc init="true">g_shell_unquote</alloc>
-    <alloc init="true">g_uri_escape_string</alloc>
-    <alloc init="true">g_uri_parse_scheme</alloc>
-    <alloc init="true">g_uri_unescape_segment</alloc>
-    <alloc init="true">g_uri_unescape_string</alloc>
-    <alloc init="true">g_variant_type_dup_string</alloc>
+    <alloc init="true" no-fail="true">g_ascii_strdown</alloc>
+    <alloc init="true" no-fail="true">g_ascii_strup</alloc>
+    <alloc init="true" no-fail="true">g_base64_decode</alloc>
+    <alloc init="true" no-fail="true">g_base64_encode</alloc>
+    <alloc init="true" no-fail="true">g_bookmark_file_get_description</alloc>
+    <alloc init="true" no-fail="true">g_bookmark_file_get_mime_type</alloc>
+    <alloc init="true" no-fail="true">g_bookmark_file_get_title</alloc>
+    <alloc init="true" no-fail="true">g_bookmark_file_to_data</alloc>
+    <alloc init="true" no-fail="true">g_build_filename</alloc>
+    <alloc init="true" no-fail="true">g_build_filenamev</alloc>
+    <alloc init="true" no-fail="true">g_build_path</alloc>
+    <alloc init="true" no-fail="true">g_build_pathv</alloc>
+    <alloc init="true" no-fail="true">g_bytes_unref_to_data</alloc>
+    <alloc init="true" no-fail="true">g_compute_checksum_for_bytes</alloc>
+    <alloc init="true" no-fail="true">g_compute_checksum_for_data</alloc>
+    <alloc init="true" no-fail="true">g_compute_checksum_for_string</alloc>
+    <alloc init="true" no-fail="true">g_compute_hmac_for_data</alloc>
+    <alloc init="true" no-fail="true">g_compute_hmac_for_string</alloc>
+    <alloc init="true" no-fail="true">g_convert</alloc>
+    <alloc init="true" no-fail="true">g_convert_with_fallback</alloc>
+    <alloc init="true" no-fail="true">g_convert_with_iconv</alloc>
+    <alloc init="true" no-fail="true">g_credentials_to_string</alloc>
+    <alloc init="true" no-fail="true">g_date_time_format</alloc>
+    <alloc init="true" no-fail="true">g_filename_display_basename</alloc>
+    <alloc init="true" no-fail="true">g_filename_display_name</alloc>
+    <alloc init="true" no-fail="true">g_filename_from_uri</alloc>
+    <alloc init="true" no-fail="true">g_filename_to_uri</alloc>
+    <alloc init="true" no-fail="true">g_get_codeset</alloc>
+    <alloc init="true" no-fail="true">g_get_current_dir</alloc>
+    <alloc init="true" no-fail="true">g_get_locale_variants</alloc>
+    <alloc init="true" no-fail="true">g_key_file_get_start_group</alloc>
+    <alloc init="true" no-fail="true">g_key_file_to_data</alloc>
+    <alloc buffer-size="malloc" no-fail="true">g_malloc</alloc>
+    <realloc buffer-size="malloc:2" no-fail="true">g_realloc</realloc>
+    <alloc init="true" buffer-size="malloc" no-fail="true">g_malloc0</alloc>
+    <alloc init="true" buffer-size="calloc" no-fail="true">g_malloc0_n</alloc>
+    <alloc buffer-size="calloc" no-fail="true">g_malloc_n</alloc>
+    <realloc buffer-size="calloc:2,3" no-fail="true">g_realloc_n</realloc>
+    <alloc init="true" no-fail="true">g_memdup</alloc>
+    <alloc init="true" no-fail="true">g_path_get_basename</alloc>
+    <alloc init="true" no-fail="true">g_path_get_dirname</alloc>
+    <alloc no-fail="true">g_slice_alloc</alloc>
+    <alloc init="true" no-fail="true">g_slice_alloc0</alloc>
+    <alloc init="true" no-fail="true">g_slice_copy</alloc>
+    <alloc init="true" no-fail="true">g_strcompress</alloc>
+    <alloc init="true" no-fail="true">g_strconcat</alloc>
+    <alloc init="true" buffer-size="strdup" no-fail="true">g_strdup</alloc>
+    <alloc init="true" no-fail="true">g_strdup_printf</alloc>
+    <alloc init="true" no-fail="true">g_strdup_vprintf</alloc>
+    <alloc init="true" no-fail="true">g_strescape</alloc>
+    <alloc init="true" no-fail="true">g_strjoin</alloc>
+    <alloc init="true" no-fail="true">g_strjoinv</alloc>
+    <alloc init="true" no-fail="true">g_strndup</alloc>
+    <alloc init="true" no-fail="true">g_strnfill</alloc>
+    <alloc init="true" no-fail="true">g_time_val_to_iso8601</alloc>
+    <alloc buffer-size="malloc" no-fail="false">g_try_malloc</alloc>
+    <realloc buffer-size="malloc:2" no-fail="false">g_try_realloc</realloc>
+    <alloc init="true" buffer-size="malloc" no-fail="false">g_try_malloc0</alloc>
+    <alloc init="true" buffer-size="calloc" no-fail="false">g_try_malloc0_n</alloc>
+    <alloc buffer-size="calloc" no-fail="false">g_try_malloc_n</alloc>
+    <realloc buffer-size="calloc:2,3" no-fail="false">g_try_realloc_n</realloc>
+    <alloc init="true" no-fail="true">g_ucs4_to_utf16</alloc>
+    <alloc init="true" no-fail="true">g_ucs4_to_utf8</alloc>
+    <alloc init="true" no-fail="true">g_unicode_canonical_decomposition</alloc>
+    <alloc init="true" no-fail="true">g_utf16_to_ucs4</alloc>
+    <alloc init="true" no-fail="true">g_utf16_to_utf8</alloc>
+    <alloc init="true" no-fail="true">g_utf8_casefold</alloc>
+    <alloc init="true" no-fail="true">g_utf8_collate_key</alloc>
+    <alloc init="true" no-fail="true">g_utf8_collate_key_for_filename</alloc>
+    <alloc init="true" no-fail="true">g_utf8_normalize</alloc>
+    <alloc init="true" no-fail="true">g_utf8_strdown</alloc>
+    <alloc init="true" no-fail="true">g_utf8_strreverse</alloc>
+    <alloc init="true" no-fail="true">g_utf8_strup</alloc>
+    <alloc init="true" no-fail="true">g_utf8_substring</alloc>
+    <alloc init="true" no-fail="true">g_utf8_to_ucs4</alloc>
+    <alloc init="true" no-fail="true">g_utf8_to_ucs4_fast</alloc>
+    <alloc init="true" no-fail="true">g_utf8_to_ucs4_fast</alloc>
+    <alloc init="true" no-fail="true">g_utf8_to_utf16</alloc>
+    <alloc init="true" no-fail="true">g_key_file_get_locale_string</alloc>
+    <alloc init="true" no-fail="true">g_key_file_get_value</alloc>
+    <alloc init="true" no-fail="true">g_key_file_get_string</alloc>
+    <alloc init="true" no-fail="true">g_key_file_get_boolean_list</alloc>
+    <alloc init="true" no-fail="true">g_key_file_get_integer_list</alloc>
+    <alloc init="true" no-fail="true">g_key_file_get_double_list</alloc>
+    <alloc init="true" no-fail="true">g_key_file_get_comment</alloc>
+    <alloc init="true" no-fail="true">g_dbus_proxy_get_name_owner</alloc>
+    <alloc init="true" no-fail="true">g_file_info_get_attribute_as_string</alloc>
+    <alloc init="true" no-fail="true">g_file_attribute_matcher_to_string</alloc>
+    <alloc init="true" no-fail="true">g_app_launch_context_get_environment</alloc>
+    <alloc init="true" no-fail="true">g_app_launch_context_get_startup_notify_id</alloc>
+    <alloc init="true" no-fail="true">g_filename_completer_get_completion_suffix</alloc>
+    <alloc init="true" no-fail="true">g_inet_address_mask_to_string</alloc>
+    <alloc init="true" no-fail="true">g_variant_dup_string</alloc>
+    <alloc init="true" no-fail="true">g_variant_dup_bytestring</alloc>
+    <alloc init="true" no-fail="true">g_variant_get_objv</alloc>
+    <alloc init="true" no-fail="true">g_variant_get_strv</alloc>
+    <alloc init="true" no-fail="true">g_variant_print</alloc>
+    <alloc init="true" no-fail="true">g_datalist_id_dup_data</alloc>
+    <alloc init="true" no-fail="true">g_dir_make_tmp</alloc>
+    <alloc init="true" no-fail="true">g_filename_from_utf8</alloc>
+    <alloc init="true" no-fail="true">g_filename_to_utf8</alloc>
+    <alloc init="true" no-fail="true">g_file_read_link</alloc>
+    <alloc init="true" no-fail="true">g_find_program_in_path</alloc>
+    <alloc init="true" no-fail="true">g_format_size</alloc>
+    <alloc init="true" no-fail="true">g_format_size_for_display</alloc>
+    <alloc init="true" no-fail="true">g_format_size_full</alloc>
+    <alloc init="true" no-fail="true">g_hostname_to_ascii</alloc>
+    <alloc init="true" no-fail="true">g_hostname_to_unicode</alloc>
+    <alloc init="true" no-fail="true">g_locale_from_utf8</alloc>
+    <alloc init="true" no-fail="true">g_locale_to_utf8</alloc>
+    <alloc init="true" no-fail="true">g_markup_escape_text</alloc>
+    <alloc init="true" no-fail="true">g_markup_printf_escaped</alloc>
+    <alloc init="true" no-fail="true">g_markup_vprintf_escaped</alloc>
+    <alloc init="true" no-fail="true">g_match_info_expand_references</alloc>
+    <alloc init="true" no-fail="true">g_match_info_fetch</alloc>
+    <alloc init="true" no-fail="true">g_match_info_fetch_named</alloc>
+    <alloc init="true" no-fail="true">g_option_context_get_help</alloc>
+    <alloc init="true" no-fail="true">g_regex_escape_nul</alloc>
+    <alloc init="true" no-fail="true">g_regex_escape_string</alloc>
+    <alloc init="true" no-fail="true">g_regex_replace</alloc>
+    <alloc init="true" no-fail="true">g_regex_replace_eval</alloc>
+    <alloc init="true" no-fail="true">g_regex_replace_literal</alloc>
+    <alloc init="true" no-fail="true">g_shell_quote</alloc>
+    <alloc init="true" no-fail="true">g_shell_unquote</alloc>
+    <alloc init="true" no-fail="true">g_uri_escape_string</alloc>
+    <alloc init="true" no-fail="true">g_uri_parse_scheme</alloc>
+    <alloc init="true" no-fail="true">g_uri_unescape_segment</alloc>
+    <alloc init="true" no-fail="true">g_uri_unescape_string</alloc>
+    <alloc init="true" no-fail="true">g_variant_type_dup_string</alloc>
+    <alloc init="true" no-fail="true">g_value_dup_string</alloc>
     <use>g_register_data</use>
     <dealloc>g_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_hash_table_new_full</alloc>
-    <alloc init="true">g_hash_table_new</alloc>
+    <alloc init="true" no-fail="true">g_hash_table_new_full</alloc>
+    <alloc init="true" no-fail="true">g_hash_table_new</alloc>
     <use>g_hash_table_ref</use>
     <dealloc>g_hash_table_destroy</dealloc>
     <dealloc>g_hash_table_unref</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_io_channel_unix_new</alloc>
-    <alloc init="true">g_io_channel_win32_new_fd</alloc>
-    <alloc init="true">g_io_channel_win32_new_socket</alloc>
-    <alloc init="true">g_io_channel_win32_new_messages</alloc>
-    <alloc init="true">g_io_channel_new_file</alloc>
+    <alloc init="true" no-fail="true">g_io_channel_unix_new</alloc>
+    <alloc init="true" no-fail="true">g_io_channel_win32_new_fd</alloc>
+    <alloc init="true" no-fail="true">g_io_channel_win32_new_socket</alloc>
+    <alloc init="true" no-fail="true">g_io_channel_win32_new_messages</alloc>
+    <alloc init="true" no-fail="true">g_io_channel_new_file</alloc>
     <use>g_io_channel_ref</use>
     <dealloc>g_io_channel_close</dealloc>
     <dealloc>g_io_channel_shutdown</dealloc>
     <dealloc>g_io_channel_unref</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_emblemed_icon_get_emblems</alloc>
-    <alloc init="true">g_list_alloc</alloc>
-    <alloc init="true">g_list_copy</alloc>
-    <alloc init="true">g_list_copy_deep</alloc>
-    <alloc init="true">g_app_info_get_all</alloc>
-    <alloc init="true">g_app_info_get_all_for_type</alloc>
-    <alloc init="true">g_app_info_get_fallback_for_type</alloc>
-    <alloc init="true">g_app_info_get_recommended_for_type</alloc>
-    <alloc init="true">g_io_modules_load_all_in_directory</alloc>
-    <alloc init="true">g_io_modules_load_all_in_directory_with_scope</alloc>
-    <alloc init="true">g_hash_table_get_keys</alloc>
-    <alloc init="true">g_hash_table_get_values</alloc>
+    <alloc init="true" no-fail="true">g_emblemed_icon_get_emblems</alloc>
+    <alloc init="true" no-fail="true">g_list_alloc</alloc>
+    <alloc init="true" no-fail="true">g_list_copy</alloc>
+    <alloc init="true" no-fail="true">g_list_copy_deep</alloc>
+    <alloc init="true" no-fail="true">g_app_info_get_all</alloc>
+    <alloc init="true" no-fail="true">g_app_info_get_all_for_type</alloc>
+    <alloc init="true" no-fail="true">g_app_info_get_fallback_for_type</alloc>
+    <alloc init="true" no-fail="true">g_app_info_get_recommended_for_type</alloc>
+    <alloc init="true" no-fail="true">g_io_modules_load_all_in_directory</alloc>
+    <alloc init="true" no-fail="true">g_io_modules_load_all_in_directory_with_scope</alloc>
+    <alloc init="true" no-fail="true">g_hash_table_get_keys</alloc>
+    <alloc init="true" no-fail="true">g_hash_table_get_values</alloc>
     <dealloc>g_list_free</dealloc>
     <dealloc>g_list_free_1</dealloc>
     <dealloc>g_list_free_full</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_regex_new</alloc>
+    <alloc init="true" no-fail="true">g_regex_new</alloc>
     <use>g_regex_ref</use>
     <dealloc>g_regex_unref</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_node_new</alloc>
-    <alloc init="true">g_node_copy</alloc>
-    <alloc init="true">g_node_copy_deep</alloc>
+    <alloc init="true" no-fail="true">g_node_new</alloc>
+    <alloc init="true" no-fail="true">g_node_copy</alloc>
+    <alloc init="true" no-fail="true">g_node_copy_deep</alloc>
     <dealloc>g_node_destroy</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_time_zone_new</alloc>
-    <alloc init="true">g_time_zone_new_local</alloc>
-    <alloc init="true">g_time_zone_new_utc</alloc>
+    <alloc init="true" no-fail="true">g_time_zone_new</alloc>
+    <alloc init="true" no-fail="true">g_time_zone_new_local</alloc>
+    <alloc init="true" no-fail="true">g_time_zone_new_utc</alloc>
     <use>g_time_zone_ref</use>
     <dealloc>g_time_zone_unref</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_markup_parse_context_new</alloc>
+    <alloc init="true" no-fail="true">g_markup_parse_context_new</alloc>
     <dealloc>g_markup_parse_context_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_mapped_file_new</alloc>
-    <alloc init="true">g_mapped_file_new_from_fd</alloc>
+    <alloc init="true" no-fail="true">g_mapped_file_new</alloc>
+    <alloc init="true" no-fail="true">g_mapped_file_new_from_fd</alloc>
     <use>g_mapped_file_ref</use>
     <dealloc>g_mapped_file_free</dealloc>
     <dealloc>g_mapped_file_unref</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_mutex_new</alloc>
+    <alloc init="true" no-fail="true">g_mutex_new</alloc>
     <dealloc>g_mutex_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_mem_chunk_new</alloc>
+    <alloc init="true" no-fail="true">g_mem_chunk_new</alloc>
     <dealloc>g_mem_chunk_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_option_group_new</alloc>
+    <alloc init="true" no-fail="true">g_option_group_new</alloc>
     <dealloc>g_option_group_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_option_context_new</alloc>
+    <alloc init="true" no-fail="true">g_option_context_new</alloc>
     <dealloc>g_option_context_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_rand_new</alloc>
-    <alloc init="true">g_rand_copy</alloc>
-    <alloc init="true">g_rand_new_with_seed</alloc>
-    <alloc init="true">g_rand_new_with_seed_array</alloc>
+    <alloc init="true" no-fail="true">g_rand_new</alloc>
+    <alloc init="true" no-fail="true">g_rand_copy</alloc>
+    <alloc init="true" no-fail="true">g_rand_new_with_seed</alloc>
+    <alloc init="true" no-fail="true">g_rand_new_with_seed_array</alloc>
     <dealloc>g_rand_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_queue_new</alloc>
-    <alloc init="true">g_queue_copy</alloc>
+    <alloc init="true" no-fail="true">g_queue_new</alloc>
+    <alloc init="true" no-fail="true">g_queue_copy</alloc>
     <dealloc>g_queue_free</dealloc>
+    <dealloc>g_queue_free_full</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_slice_new</alloc>
+    <alloc init="true" no-fail="true">g_slice_new</alloc>
     <dealloc>g_slice_free</dealloc>
     <dealloc>g_slice_free1</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_sequence_new</alloc>
+    <alloc init="true" no-fail="true">g_sequence_new</alloc>
     <dealloc>g_sequence_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_completion_new</alloc>
+    <alloc init="true" no-fail="true">g_completion_new</alloc>
     <dealloc>g_completion_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_chunk_new</alloc>
+    <alloc init="true" no-fail="true">g_chunk_new</alloc>
     <dealloc>g_chunk_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_bytes_new</alloc>
-    <alloc init="true">g_bytes_new_take</alloc>
-    <alloc init="true">g_bytes_new_static</alloc>
-    <alloc init="true">g_bytes_new_with_free_func</alloc>
-    <alloc init="true">g_bytes_new_from_bytes</alloc>
-    <alloc init="true">g_byte_array_free_to_bytes</alloc>
-    <alloc init="true">g_memory_output_stream_steal_as_bytes</alloc>
-    <alloc init="true">g_variant_get_data_as_bytes</alloc>
-    <alloc init="true">g_mapped_file_get_bytes</alloc>
+    <alloc init="true" no-fail="true">g_bytes_new</alloc>
+    <alloc init="true" no-fail="true">g_bytes_new_take</alloc>
+    <alloc init="true" no-fail="true">g_bytes_new_static</alloc>
+    <alloc init="true" no-fail="true">g_bytes_new_with_free_func</alloc>
+    <alloc init="true" no-fail="true">g_bytes_new_from_bytes</alloc>
+    <alloc init="true" no-fail="true">g_byte_array_free_to_bytes</alloc>
+    <alloc init="true" no-fail="true">g_memory_output_stream_steal_as_bytes</alloc>
+    <alloc init="true" no-fail="true">g_variant_get_data_as_bytes</alloc>
+    <alloc init="true" no-fail="true">g_mapped_file_get_bytes</alloc>
     <use>g_bytes_ref</use>
     <dealloc>g_bytes_unref</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_bookmark_file_get_uris</alloc>
-    <alloc init="true">g_bookmark_file_get_groups</alloc>
-    <alloc init="true">g_bookmark_file_get_applications</alloc>
-    <alloc init="true">g_key_file_get_groups</alloc>
-    <alloc init="true">g_key_file_get_keys</alloc>
-    <alloc init="true">g_strdupv</alloc>
-    <alloc init="true">g_strsplit</alloc>
-    <alloc init="true">g_strsplit_set</alloc>
-    <alloc init="true">g_uri_list_extract_uris</alloc>
-    <alloc init="true">g_key_file_get_string_list</alloc>
-    <alloc init="true">g_key_file_get_locale_string_list</alloc>
-    <alloc init="true">g_file_info_list_attributes</alloc>
-    <alloc init="true">g_file_info_get_attribute_stringv</alloc>
-    <alloc init="true">g_app_launch_context_get_environment</alloc>
-    <alloc init="true">g_filename_completer_get_completions</alloc>
-    <alloc init="true">g_io_module_query</alloc>
-    <alloc init="true">g_variant_dup_objv</alloc>
-    <alloc init="true">g_variant_dup_bytestring_array</alloc>
-    <alloc init="true">g_environ_setenv</alloc>
-    <alloc init="true">g_environ_unsetenv</alloc>
-    <alloc init="true">g_get_environ</alloc>
-    <alloc init="true">g_listenv</alloc>
-    <alloc init="true">g_match_info_fetch_all</alloc>
-    <alloc init="true">g_regex_split</alloc>
-    <alloc init="true">g_regex_split_full</alloc>
-    <alloc init="true">g_regex_split_simple</alloc>
-    <alloc init="true">g_regex_split_simple</alloc>
-    <alloc init="true">g_variant_dup_strv</alloc>
+    <alloc init="true" no-fail="true">g_bookmark_file_get_uris</alloc>
+    <alloc init="true" no-fail="true">g_bookmark_file_get_groups</alloc>
+    <alloc init="true" no-fail="true">g_bookmark_file_get_applications</alloc>
+    <alloc init="true" no-fail="true">g_key_file_get_groups</alloc>
+    <alloc init="true" no-fail="true">g_key_file_get_keys</alloc>
+    <alloc init="true" no-fail="true">g_strdupv</alloc>
+    <alloc init="true" no-fail="true">g_strsplit</alloc>
+    <alloc init="true" no-fail="true">g_strsplit_set</alloc>
+    <alloc init="true" no-fail="true">g_uri_list_extract_uris</alloc>
+    <alloc init="true" no-fail="true">g_key_file_get_string_list</alloc>
+    <alloc init="true" no-fail="true">g_key_file_get_locale_string_list</alloc>
+    <alloc init="true" no-fail="true">g_file_info_list_attributes</alloc>
+    <alloc init="true" no-fail="true">g_file_info_get_attribute_stringv</alloc>
+    <alloc init="true" no-fail="true">g_app_launch_context_get_environment</alloc>
+    <alloc init="true" no-fail="true">g_filename_completer_get_completions</alloc>
+    <alloc init="true" no-fail="true">g_io_module_query</alloc>
+    <alloc init="true" no-fail="true">g_variant_dup_objv</alloc>
+    <alloc init="true" no-fail="true">g_variant_dup_bytestring_array</alloc>
+    <alloc init="true" no-fail="true">g_environ_setenv</alloc>
+    <alloc init="true" no-fail="true">g_environ_unsetenv</alloc>
+    <alloc init="true" no-fail="true">g_get_environ</alloc>
+    <alloc init="true" no-fail="true">g_listenv</alloc>
+    <alloc init="true" no-fail="true">g_match_info_fetch_all</alloc>
+    <alloc init="true" no-fail="true">g_regex_split</alloc>
+    <alloc init="true" no-fail="true">g_regex_split_full</alloc>
+    <alloc init="true" no-fail="true">g_regex_split_simple</alloc>
+    <alloc init="true" no-fail="true">g_regex_split_simple</alloc>
+    <alloc init="true" no-fail="true">g_variant_dup_strv</alloc>
     <dealloc>g_strfreev</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_hmac_new</alloc>
-    <alloc init="true">g_hmac_copy</alloc>
+    <alloc init="true" no-fail="true">g_hmac_new</alloc>
+    <alloc init="true" no-fail="true">g_hmac_copy</alloc>
     <use>g_hmac_ref</use>
     <dealloc>g_hmac_unref</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_hook_alloc</alloc>
+    <alloc init="true" no-fail="true">g_hook_alloc</alloc>
     <use>g_hook_ref</use>
     <dealloc>g_hook_unref</dealloc>
     <dealloc>g_hook_destroy</dealloc>
     <dealloc>g_hook_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_date_new</alloc>
-    <alloc init="true">g_date_new_dmy</alloc>
-    <alloc init="true">g_date_new_julian</alloc>
+    <alloc init="true" no-fail="true">g_date_new</alloc>
+    <alloc init="true" no-fail="true">g_date_new_dmy</alloc>
+    <alloc init="true" no-fail="true">g_date_new_julian</alloc>
     <dealloc>g_date_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_variant_builder_new</alloc>
+    <alloc init="true" no-fail="true">g_variant_builder_new</alloc>
     <use>g_variant_builder_ref</use>
     <dealloc>g_variant_builder_unref</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_cond_new</alloc>
+    <alloc init="true" no-fail="true">g_cond_new</alloc>
     <dealloc>g_cond_free</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_app_launch_context_new</alloc>
-    <alloc init="true">g_app_info_create_from_commandline</alloc>
-    <alloc init="true">g_app_info_dup</alloc>
-    <alloc init="true">g_app_info_get_default_for_type</alloc>
-    <alloc init="true">g_app_info_get_default_for_uri_scheme</alloc>
-    <alloc init="true">g_application_new</alloc>
-    <alloc init="true">g_application_get_dbus_connection</alloc>
-    <alloc init="true">g_application_get_default</alloc>
-    <alloc init="true">g_buffered_input_stream_new</alloc>
-    <alloc init="true">g_buffered_output_stream_new</alloc>
-    <alloc init="true">g_cancellable_new</alloc>
-    <alloc init="true">g_charset_converter_new</alloc>
-    <alloc init="true">g_converter_input_stream_new</alloc>
-    <alloc init="true">g_converter_output_stream_new</alloc>
-    <alloc init="true">g_credentials_new</alloc>
-    <alloc init="true">g_data_input_stream_new</alloc>
-    <alloc init="true">g_data_output_stream_new</alloc>
-    <alloc init="true">g_dbus_auth_observer_new</alloc>
-    <alloc init="true">g_dbus_connection_new_finish</alloc>
-    <alloc init="true">g_dbus_connection_new_sync</alloc>
-    <alloc init="true">g_dbus_connection_new_for_address_finish</alloc>
-    <alloc init="true">g_dbus_connection_new_for_address_sync</alloc>
-    <alloc init="true">g_dbus_message_new</alloc>
-    <alloc init="true">g_dbus_message_new_signal</alloc>
-    <alloc init="true">g_dbus_message_new_method_call</alloc>
-    <alloc init="true">g_dbus_message_new_method_reply</alloc>
-    <alloc init="true">g_dbus_message_new_method_error</alloc>
-    <alloc init="true">g_dbus_message_new_method_error_valist</alloc>
-    <alloc init="true">g_dbus_message_new_method_error_literal</alloc>
-    <alloc init="true">g_dbus_object_manager_client_new_finish</alloc>
-    <alloc init="true">g_dbus_object_manager_client_new_sync</alloc>
-    <alloc init="true">g_dbus_object_manager_client_new_for_bus_finish</alloc>
-    <alloc init="true">g_dbus_object_manager_client_new_for_bus_sync</alloc>
-    <alloc init="true">g_dbus_object_manager_server_new</alloc>
-    <alloc init="true">g_dbus_object_manager_server_get_connection</alloc>
-    <alloc init="true">g_dbus_object_proxy_new</alloc>
-    <alloc init="true">g_dbus_object_skeleton_new</alloc>
-    <alloc init="true">g_dbus_proxy_new_finish</alloc>
-    <alloc init="true">g_dbus_proxy_new_sync</alloc>
-    <alloc init="true">g_dbus_proxy_new_for_bus_finish</alloc>
-    <alloc init="true">g_dbus_proxy_new_for_bus_sync</alloc>
-    <alloc init="true">g_emblemed_icon_new</alloc>
-    <alloc init="true">g_emblem_new</alloc>
-    <alloc init="true">g_emblem_new_with_origin</alloc>
-    <alloc init="true">g_file_icon_new</alloc>
-    <alloc init="true">g_file_icon_get_file</alloc>
-    <alloc init="true">g_file_info_new</alloc>
-    <alloc init="true">g_file_info_dup</alloc>
-    <alloc init="true">g_file_info_get_icon</alloc>
-    <alloc init="true">g_file_info_get_symbolic_icon</alloc>
-    <alloc init="true">g_file_info_get_attribute_object</alloc>
-    <alloc init="true">g_file_info_get_deletion_date</alloc>
-    <alloc init="true">g_filename_completer_new</alloc>
-    <alloc init="true">g_inet_address_mask_new</alloc>
-    <alloc init="true">g_inet_address_mask_new_from_string</alloc>
-    <alloc init="true">g_inet_address_mask_get_address</alloc>
-    <alloc init="true">g_inet_socket_address_new</alloc>
-    <alloc init="true">g_inet_socket_address_get_address</alloc>
-    <alloc init="true">g_initable_new</alloc>
-    <alloc init="true">g_initable_new_valist</alloc>
-    <alloc init="true">g_initable_newv</alloc>
-    <alloc init="true">g_io_module_new</alloc>
-    <alloc init="true">g_io_module_scope_new</alloc>
-    <alloc init="true">g_keyfile_settings_backend_new</alloc>
-    <alloc init="true">g_memory_input_stream_new</alloc>
-    <alloc init="true">g_memory_input_stream_new_from_data</alloc>
-    <alloc init="true">g_memory_input_stream_new_from_bytes</alloc>
-    <alloc init="true">g_memory_output_stream_new</alloc>
-    <alloc init="true">g_memory_output_stream_new_resizable</alloc>
-    <alloc init="true">g_memory_settings_backend_new</alloc>
-    <alloc init="true">g_null_settings_backend_new</alloc>
-    <alloc init="true">g_menu_item_new</alloc>
-    <alloc init="true">g_menu_item_new_section</alloc>
-    <alloc init="true">g_menu_item_new_submenu</alloc>
-    <alloc init="true">g_menu_item_new_from_model</alloc>
-    <alloc init="true">g_menu_new</alloc>
-    <alloc init="true">g_mount_operation_new</alloc>
-    <alloc init="true">g_network_address_new</alloc>
-    <alloc init="true">g_network_service_new</alloc>
-    <alloc init="true">g_object_new</alloc>
-    <alloc init="true">g_param_spec_pool_new</alloc>
-    <alloc init="true">g_pollable_source_new</alloc>
-    <alloc init="true">g_private_new</alloc>
-    <alloc init="true">g_proxy_address_new</alloc>
-    <alloc init="true">g_ptr_array_sized_new</alloc>
-    <alloc init="true">g_relation_new</alloc>
-    <alloc init="true">g_scanner_new</alloc>
-    <alloc init="true">g_settings_new</alloc>
-    <alloc init="true">g_signal_type_cclosure_new</alloc>
-    <alloc init="true">g_simple_action_group_new</alloc>
-    <alloc init="true">g_simple_action_new</alloc>
-    <alloc init="true">g_simple_async_result_new</alloc>
-    <alloc init="true">g_simple_permission_new</alloc>
-    <alloc init="true">g_socket_client_new</alloc>
-    <alloc init="true">g_socket_listener_new</alloc>
-    <alloc init="true">g_socket_new</alloc>
-    <alloc init="true">g_socket_service_new</alloc>
-    <alloc init="true">g_tcp_wrapper_connection_new</alloc>
-    <alloc init="true">g_test_dbus_new</alloc>
-    <alloc init="true">g_themed_icon_new</alloc>
-    <alloc init="true">g_threaded_socket_service_new</alloc>
-    <alloc init="true">g_tls_client_connection_new</alloc>
-    <alloc init="true">g_tls_file_database_new</alloc>
-    <alloc init="true">g_tls_password_new</alloc>
-    <alloc init="true">g_tls_server_connection_new</alloc>
-    <alloc init="true">g_unix_signal_source_new</alloc>
-    <alloc init="true">g_zlib_compressor_new</alloc>
-    <alloc init="true">g_zlib_decompressor_new</alloc>
+    <alloc init="true" no-fail="true">g_app_launch_context_new</alloc>
+    <alloc init="true" no-fail="true">g_app_info_create_from_commandline</alloc>
+    <alloc init="true" no-fail="true">g_app_info_dup</alloc>
+    <alloc init="true" no-fail="true">g_app_info_get_default_for_type</alloc>
+    <alloc init="true" no-fail="true">g_app_info_get_default_for_uri_scheme</alloc>
+    <alloc init="true" no-fail="true">g_application_new</alloc>
+    <alloc init="true" no-fail="true">g_application_get_dbus_connection</alloc>
+    <alloc init="true" no-fail="true">g_application_get_default</alloc>
+    <alloc init="true" no-fail="true">g_buffered_input_stream_new</alloc>
+    <alloc init="true" no-fail="true">g_buffered_output_stream_new</alloc>
+    <alloc init="true" no-fail="true">g_cancellable_new</alloc>
+    <alloc init="true" no-fail="true">g_charset_converter_new</alloc>
+    <alloc init="true" no-fail="true">g_converter_input_stream_new</alloc>
+    <alloc init="true" no-fail="true">g_converter_output_stream_new</alloc>
+    <alloc init="true" no-fail="true">g_credentials_new</alloc>
+    <alloc init="true" no-fail="true">g_data_input_stream_new</alloc>
+    <alloc init="true" no-fail="true">g_data_output_stream_new</alloc>
+    <alloc init="true" no-fail="true">g_dbus_auth_observer_new</alloc>
+    <alloc init="true" no-fail="true">g_dbus_connection_new_finish</alloc>
+    <alloc init="true" no-fail="true">g_dbus_connection_new_sync</alloc>
+    <alloc init="true" no-fail="true">g_dbus_connection_new_for_address_finish</alloc>
+    <alloc init="true" no-fail="true">g_dbus_connection_new_for_address_sync</alloc>
+    <alloc init="true" no-fail="true">g_dbus_message_new</alloc>
+    <alloc init="true" no-fail="true">g_dbus_message_new_signal</alloc>
+    <alloc init="true" no-fail="true">g_dbus_message_new_method_call</alloc>
+    <alloc init="true" no-fail="true">g_dbus_message_new_method_reply</alloc>
+    <alloc init="true" no-fail="true">g_dbus_message_new_method_error</alloc>
+    <alloc init="true" no-fail="true">g_dbus_message_new_method_error_valist</alloc>
+    <alloc init="true" no-fail="true">g_dbus_message_new_method_error_literal</alloc>
+    <alloc init="true" no-fail="true">g_dbus_object_manager_client_new_finish</alloc>
+    <alloc init="true" no-fail="true">g_dbus_object_manager_client_new_sync</alloc>
+    <alloc init="true" no-fail="true">g_dbus_object_manager_client_new_for_bus_finish</alloc>
+    <alloc init="true" no-fail="true">g_dbus_object_manager_client_new_for_bus_sync</alloc>
+    <alloc init="true" no-fail="true">g_dbus_object_manager_server_new</alloc>
+    <alloc init="true" no-fail="true">g_dbus_object_manager_server_get_connection</alloc>
+    <alloc init="true" no-fail="true">g_dbus_object_proxy_new</alloc>
+    <alloc init="true" no-fail="true">g_dbus_object_skeleton_new</alloc>
+    <alloc init="true" no-fail="true">g_dbus_proxy_new_finish</alloc>
+    <alloc init="true" no-fail="true">g_dbus_proxy_new_sync</alloc>
+    <alloc init="true" no-fail="true">g_dbus_proxy_new_for_bus_finish</alloc>
+    <alloc init="true" no-fail="true">g_dbus_proxy_new_for_bus_sync</alloc>
+    <alloc init="true" no-fail="true">g_emblemed_icon_new</alloc>
+    <alloc init="true" no-fail="true">g_emblem_new</alloc>
+    <alloc init="true" no-fail="true">g_emblem_new_with_origin</alloc>
+    <alloc init="true" no-fail="true">g_file_icon_new</alloc>
+    <alloc init="true" no-fail="true">g_file_icon_get_file</alloc>
+    <alloc init="true" no-fail="true">g_file_info_new</alloc>
+    <alloc init="true" no-fail="true">g_file_info_dup</alloc>
+    <alloc init="true" no-fail="true">g_file_info_get_icon</alloc>
+    <alloc init="true" no-fail="true">g_file_info_get_symbolic_icon</alloc>
+    <alloc init="true" no-fail="true">g_file_info_get_attribute_object</alloc>
+    <alloc init="true" no-fail="true">g_file_info_get_deletion_date</alloc>
+    <alloc init="true" no-fail="true">g_filename_completer_new</alloc>
+    <alloc init="true" no-fail="true">g_inet_address_mask_new</alloc>
+    <alloc init="true" no-fail="true">g_inet_address_mask_new_from_string</alloc>
+    <alloc init="true" no-fail="true">g_inet_address_mask_get_address</alloc>
+    <alloc init="true" no-fail="true">g_inet_socket_address_new</alloc>
+    <alloc init="true" no-fail="true">g_inet_socket_address_get_address</alloc>
+    <alloc init="true" no-fail="true">g_initable_new</alloc>
+    <alloc init="true" no-fail="true">g_initable_new_valist</alloc>
+    <alloc init="true" no-fail="true">g_initable_newv</alloc>
+    <alloc init="true" no-fail="true">g_io_module_new</alloc>
+    <alloc init="true" no-fail="true">g_io_module_scope_new</alloc>
+    <alloc init="true" no-fail="true">g_keyfile_settings_backend_new</alloc>
+    <alloc init="true" no-fail="true">g_memory_input_stream_new</alloc>
+    <alloc init="true" no-fail="true">g_memory_input_stream_new_from_data</alloc>
+    <alloc init="true" no-fail="true">g_memory_input_stream_new_from_bytes</alloc>
+    <alloc init="true" no-fail="true">g_memory_output_stream_new</alloc>
+    <alloc init="true" no-fail="true">g_memory_output_stream_new_resizable</alloc>
+    <alloc init="true" no-fail="true">g_memory_settings_backend_new</alloc>
+    <alloc init="true" no-fail="true">g_null_settings_backend_new</alloc>
+    <alloc init="true" no-fail="true">g_menu_item_new</alloc>
+    <alloc init="true" no-fail="true">g_menu_item_new_section</alloc>
+    <alloc init="true" no-fail="true">g_menu_item_new_submenu</alloc>
+    <alloc init="true" no-fail="true">g_menu_item_new_from_model</alloc>
+    <alloc init="true" no-fail="true">g_menu_new</alloc>
+    <alloc init="true" no-fail="true">g_mount_operation_new</alloc>
+    <alloc init="true" no-fail="true">g_network_address_new</alloc>
+    <alloc init="true" no-fail="true">g_network_service_new</alloc>
+    <alloc init="true" no-fail="true">g_object_new</alloc>
+    <alloc init="true" no-fail="true">g_param_spec_pool_new</alloc>
+    <alloc init="true" no-fail="true">g_pollable_source_new</alloc>
+    <alloc init="true" no-fail="true">g_private_new</alloc>
+    <alloc init="true" no-fail="true">g_proxy_address_new</alloc>
+    <alloc init="true" no-fail="true">g_ptr_array_sized_new</alloc>
+    <alloc init="true" no-fail="true">g_relation_new</alloc>
+    <alloc init="true" no-fail="true">g_scanner_new</alloc>
+    <alloc init="true" no-fail="true">g_settings_new</alloc>
+    <alloc init="true" no-fail="true">g_signal_type_cclosure_new</alloc>
+    <alloc init="true" no-fail="true">g_simple_action_group_new</alloc>
+    <alloc init="true" no-fail="true">g_simple_action_new</alloc>
+    <alloc init="true" no-fail="true">g_simple_async_result_new</alloc>
+    <alloc init="true" no-fail="true">g_simple_permission_new</alloc>
+    <alloc init="true" no-fail="true">g_socket_client_new</alloc>
+    <alloc init="true" no-fail="true">g_socket_listener_new</alloc>
+    <alloc init="true" no-fail="true">g_socket_new</alloc>
+    <alloc init="true" no-fail="true">g_socket_service_new</alloc>
+    <alloc init="true" no-fail="true">g_tcp_wrapper_connection_new</alloc>
+    <alloc init="true" no-fail="true">g_test_dbus_new</alloc>
+    <alloc init="true" no-fail="true">g_themed_icon_new</alloc>
+    <alloc init="true" no-fail="true">g_threaded_socket_service_new</alloc>
+    <alloc init="true" no-fail="true">g_tls_client_connection_new</alloc>
+    <alloc init="true" no-fail="true">g_tls_file_database_new</alloc>
+    <alloc init="true" no-fail="true">g_tls_password_new</alloc>
+    <alloc init="true" no-fail="true">g_tls_server_connection_new</alloc>
+    <alloc init="true" no-fail="true">g_unix_signal_source_new</alloc>
+    <alloc init="true" no-fail="true">g_zlib_compressor_new</alloc>
+    <alloc init="true" no-fail="true">g_zlib_decompressor_new</alloc>
     <use>g_object_ref</use>
     <dealloc>g_object_unref</dealloc>
     <dealloc>gtk_widget_destroy</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_tree_new</alloc>
-    <alloc init="true">g_tree_new_full</alloc>
-    <alloc init="true">g_tree_new_with_data</alloc>
+    <alloc init="true" no-fail="true">g_tree_new</alloc>
+    <alloc init="true" no-fail="true">g_tree_new_full</alloc>
+    <alloc init="true" no-fail="true">g_tree_new_with_data</alloc>
     <use>g_tree_ref</use>
     <dealloc>g_tree_unref</dealloc>
+    <dealloc>g_tree_destroy</dealloc>
   </memory>
   <memory>
-    <alloc init="true">g_file_attribute_matcher_new</alloc>
-    <alloc init="true">g_file_attribute_matcher_subtract</alloc>
+    <alloc init="true" no-fail="true">g_file_attribute_matcher_new</alloc>
+    <alloc init="true" no-fail="true">g_file_attribute_matcher_subtract</alloc>
     <use>g_file_attribute_matcher_ref</use>
     <dealloc>g_file_attribute_matcher_unref</dealloc>
   </memory>
   <function name="g_exit">
     <noreturn>true</noreturn>
   </function>
+  <!-- void g_abort (void) -->
+  <function name="g_abort">
+    <noreturn>true</noreturn>
+  </function>
   <!-- gboolean g_hash_table_insert (GHashTable *hash_table, gpointer key, gpointer value); -->
   <function name="g_hash_table_insert">
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
     <arg nr="1" direction="inout">
       <not-uninit/>
+      <not-null/>
     </arg>
     <arg nr="2">
       <not-uninit/>
     </arg>
     <arg nr="3">
       <not-uninit/>
-      <not-bool/>
     </arg>
   </function>
+  <!-- gboolean g_hash_table_replace (GHashTable *hash_table, gpointer key, gpointer value); -->
   <function name="g_hash_table_replace">
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- GList * g_list_alloc (void); -->
+  <function name="g_list_alloc">
+    <noreturn>false</noreturn>
+    <returnValue type="GList *"/>
+    <use-retval/>
   </function>
   <!-- GList * g_list_append (GList *list, gpointer data); -->
   <function name="g_list_append">
@@ -891,18 +978,17 @@
     </arg>
     <arg nr="2">
       <not-uninit/>
-      <not-bool/>
     </arg>
   </function>
+  <!-- GList * g_list_last (GList *list); -->
   <!-- GList * g_list_first (GList *list); -->
-  <function name="g_list_first">
+  <function name="g_list_first,g_list_last">
     <noreturn>false</noreturn>
     <returnValue type="GList *"/>
     <use-retval/>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
-      <not-bool/>
     </arg>
   </function>
   <!-- void g_list_free (GList *list); -->
@@ -911,7 +997,6 @@
     <returnValue type="void"/>
     <arg nr="1">
       <not-uninit/>
-      <not-bool/>
     </arg>
   </function>
   <!-- void g_list_free_1 (GList *list); -->
@@ -920,7 +1005,6 @@
     <returnValue type="void"/>
     <arg nr="1">
       <not-uninit/>
-      <not-bool/>
     </arg>
   </function>
   <!-- void g_list_free_full (GList *list, GDestroyNotify free_func); -->
@@ -931,23 +1015,80 @@
       <not-uninit/>
     </arg>
     <arg nr="2">
-      <not-bool/>
+      <not-null/>
     </arg>
   </function>
+  <!-- GList* g_list_insert_before (GList* list, GList* sibling, gpointer data); -->
   <function name="g_list_insert_before">
     <noreturn>false</noreturn>
+    <returnValue type="GList *"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- GList* g_list_insert(GList* list, gpointer data, gint position); -->
   <function name="g_list_insert">
     <noreturn>false</noreturn>
+    <returnValue type="GList *"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
+  <!-- GList* g_list_insert_sorted(GList* list, gpointer data, GCompareFunc func); -->
   <function name="g_list_insert_sorted">
     <noreturn>false</noreturn>
+    <returnValue type="GList *"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-null/>
+    </arg>
   </function>
+  <!-- GList* g_list_insert_sorted_with_data(GList* list, gpointer data, GCompareDataFunc func, gpointer user_data); -->
   <function name="g_list_insert_sorted_with_data">
     <noreturn>false</noreturn>
+    <returnValue type="GList *"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-null/>
+    </arg>
+    <arg nr="4">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- GList* g_list_prepend(GList* list, gpointer data); -->
   <function name="g_list_prepend">
     <noreturn>false</noreturn>
+    <returnValue type="GList *"/>
+    <use-retval/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
   <function name="g_node_insert_after">
     <noreturn>false</noreturn>
@@ -961,26 +1102,77 @@
   <function name="g_node_prepend">
     <noreturn>false</noreturn>
   </function>
+  <!-- void g_ptr_array_add(GPtrArray* array, gpointer data); -->
   <function name="g_ptr_array_add">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_queue_push_head_link">
+  <!-- void g_queue_push_head_link (GQueue* queue, GList* link_); -->
+  <!-- void g_queue_push_tail_link(GQueue* queue, GList* link_); -->
+  <function name="g_queue_push_head_link,g_queue_push_tail_link">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
-  <function name="g_queue_push_head">
+  <!-- void g_queue_push_tail (GQueue* queue, gpointer data); -->
+  <!-- void g_queue_push_head (GQueue* queue, gpointer data); -->
+  <function name="g_queue_push_head,g_queue_push_tail">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- void g_queue_push_nth_link (GQueue* queue, gint n, GList* link_); -->
   <function name="g_queue_push_nth_link">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
+  <!-- void g_queue_push_nth (GQueue* queue, gpointer data, gint n); -->
   <function name="g_queue_push_nth">
     <noreturn>false</noreturn>
-  </function>
-  <function name="g_queue_push_tail_link">
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_queue_push_tail">
-    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
   <function name="g_sequence_append">
     <noreturn>false</noreturn>
@@ -997,20 +1189,31 @@
   <function name="g_sequence_prepend">
     <noreturn>false</noreturn>
   </function>
+  <!-- GSList * g_slist_alloc (void); -->
   <function name="g_slist_alloc">
     <noreturn>false</noreturn>
+    <returnValue type="GSList *"/>
+    <use-retval/>
   </function>
+  <!-- GList * g_slist_append (GSList *list, gpointer data); -->
   <function name="g_slist_append">
     <noreturn>false</noreturn>
+    <returnValue type="GSList *"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
   <!-- GSList * g_slist_copy (GSList *list); -->
   <function name="g_slist_copy">
     <noreturn>false</noreturn>
     <returnValue type="GSList *"/>
     <use-retval/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
-      <not-bool/>
     </arg>
   </function>
   <!-- void g_slist_free (GSList *list); -->
@@ -1018,35 +1221,87 @@
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <arg nr="1">
-      <not-bool/>
+      <not-uninit/>
     </arg>
   </function>
   <!-- void g_slist_free_full (GSList *list, GDestroyNotify free_func); -->
   <function name="g_slist_free_full">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1"/>
-    <arg nr="2"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
   </function>
   <!-- void g_slist_free_1 (GSList *list); -->
   <function name="g_slist_free_1">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <arg nr="1">
-      <not-bool/>
+      <not-uninit/>
     </arg>
   </function>
+  <!-- GSList* g_slist_insert_before (GSList* list, GSList* sibling, gpointer data); -->
   <function name="g_slist_insert_before">
     <noreturn>false</noreturn>
+    <returnValue type="GSList *"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- GSList* g_slist_insert(GSList* list, gpointer data, gint position); -->
   <function name="g_slist_insert">
     <noreturn>false</noreturn>
+    <returnValue type="GSList *"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
+  <!-- GSList* g_slist_insert_sorted(GSList* list, gpointer data, GCompareFunc func); -->
   <function name="g_slist_insert_sorted">
     <noreturn>false</noreturn>
+    <returnValue type="GSList *"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-null/>
+    </arg>
   </function>
+  <!-- GSList* g_slist_insert_sorted_with_data(GSList* list, gpointer data, GCompareDataFunc func, gpointer user_data); -->
   <function name="g_slist_insert_sorted_with_data">
     <noreturn>false</noreturn>
+    <returnValue type="GSList *"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-null/>
+    </arg>
+    <arg nr="4">
+      <not-uninit/>
+    </arg>
   </function>
   <!-- GSList * g_slist_prepend (GSList *list, gpointer data); -->
   <function name="g_slist_prepend">
@@ -1056,7 +1311,9 @@
     <arg nr="1">
       <not-uninit/>
     </arg>
-    <arg nr="2"/>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
   <!-- void gtk_list_store_set (GtkListStore *list_store,
                                 GtkTreeIter *iter,
@@ -1118,9 +1375,6 @@
   <function name="gtk_tree_view_column_pack_start">
     <noreturn>false</noreturn>
   </function>
-  <function name="g_variant_builder_add_value">
-    <noreturn>false</noreturn>
-  </function>
   <function name="gtk_box_set_child_packing">
     <noreturn>false</noreturn>
   </function>
@@ -1145,15 +1399,20 @@
   <function name="gtk_notebook_append_page">
     <noreturn>false</noreturn>
   </function>
+  <!-- void g_object_ref (gpointer object); -->
   <function name="g_object_ref">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-null/>
+    </arg>
   </function>
   <!-- void g_object_unref (gpointer object); -->
   <function name="g_object_unref">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <arg nr="1">
-      <not-bool/>
+      <not-null/>
     </arg>
   </function>
   <!-- #define G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec) -->
@@ -1165,197 +1424,623 @@
     <arg nr="2" direction="in"/>
     <arg nr="3" direction="in"/>
   </function>
+  <!-- GArray* g_array_append_vals ( GArray* array, gconstpointer data, guint len); -->
   <function name="g_array_append_vals">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GArray *"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
   </function>
+  <!-- guint g_array_get_element_size  ( GArray* array); -->
   <function name="g_array_get_element_size">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <use-retval/>
+    <returnValue type="guint"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
+  <!-- GArray* g_array_insert_vals ( GArray* array, guint index_, gconstpointer data, guint len); -->
   <function name="g_array_insert_vals">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GArray *"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
+    <arg nr="4">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
   </function>
+  <!-- GArray* g_array_prepend_vals ( GArray* array, gconstpointer data, guint len); -->
   <function name="g_array_prepend_vals">
     <leak-ignore/>
     <noreturn>false</noreturn>
-  </function>
-  <function name="g_array_remove_index">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_array_remove_index_fast">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_array_remove_range">
-    <leak-ignore/>
+    <returnValue type="GArray *"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- GArray* g_array_remove_index ( GArray* array, guint index_); -->
+  <!-- GArray* g_array_remove_index_fast ( GArray* array, guint index_); -->
+  <function name="g_array_remove_index,g_array_remove_index_fast">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="GArray *"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- GArray* g_array_remove_range ( GArray* array, guint index_, guint length); -->
+  <function name="g_array_remove_range">
+    <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GArray *"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
   </function>
+  <!-- void g_array_set_clear_func ( GArray* array, GDestroyNotify clear_func); -->
   <function name="g_array_set_clear_func">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
   </function>
+  <!-- GArray* g_array_set_size ( GArray* array, guint length); -->
   <function name="g_array_set_size">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GArray *"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
   </function>
+  <!-- void g_array_sort  ( GArray* array, GCompareFunc compare_func); -->
   <function name="g_array_sort">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
   </function>
+  <!-- void g_array_sort_with_data   ( GArray* array, GCompareFunc compare_func, gpointer user_data); -->
   <function name="g_array_sort_with_data">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="3"/>
   </function>
-  <function name="g_bookmark_file_error_quark">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
+  <!-- GByteArray * g_byte_array_append ( GByteArray * array, const guint8* data, guint len); -->
   <function name="g_byte_array_append">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GByteArray *"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="3">
+      <not-bool/>
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
   </function>
+  <!-- GByteArray * g_byte_array_prepend ( GByteArray * array, const guint8* data, guint len); -->
   <function name="g_byte_array_prepend">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GByteArray *"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="3">
+      <not-bool/>
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
   </function>
-  <function name="g_byte_array_remove_index">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_byte_array_remove_index_fast">
+  <!-- GByteArray* g_byte_array_remove_index ( GByteArray* array, guint index_); -->
+  <!-- GByteArray* g_byte_array_remove_index_fast ( GByteArray* array, guint index_); -->
+  <function name="g_byte_array_remove_index,g_byte_array_remove_index_fast">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GByteArray *"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
   </function>
+  <!-- GByteArray* g_byte_array_remove_range ( GByteArray* array, guint index_, guint length); -->
   <function name="g_byte_array_remove_range">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GByteArray *"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
   </function>
+  <!-- GByteArray* g_byte_array_set_size ( GByteArray* array, guint length); -->
   <function name="g_byte_array_set_size">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GByteArray *"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
   </function>
+  <!-- void g_byte_array_sort  ( GByteArray* array, GCompareFunc compare_func); -->
   <function name="g_byte_array_sort">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
   </function>
+  <!-- void g_byte_array_sort_with_data   ( GByteArray* array, GCompareFunc compare_func, gpointer user_data); -->
   <function name="g_byte_array_sort_with_data">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="3"/>
   </function>
+  <!-- gssize g_checksum_type_get_length    ( GChecksumType checksum_type); -->
   <function name="g_checksum_type_get_length">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gssize"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
+  <!-- guint8 get_days_in_month    ( GDateMonth month, GDateYear year); -->
   <function name="g_date_get_days_in_month">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="guint8"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
+  <!-- guint8 g_date_get_monday_weeks_in_year    (  GDateYear year); -->
   <function name="g_date_get_monday_weeks_in_year">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="guint8"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
+  <!-- guint8 g_date_get_sunday_weeks_in_year    (  GDateYear year); -->
   <function name="g_date_get_sunday_weeks_in_year">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="guint8"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
+  <!-- gboolean g_date_get_sunday_weeks_in_year    (  GDateYear year); -->
   <function name="g_date_is_leap_year">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
+  <!-- gsize g_date_strftime   (gchar* s, gsize slen, const gchar* format, const GDate* date); -->
   <function name="g_date_strftime">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gsize"/>
+    <arg nr="1">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <formatstr/>
+    <arg nr="3">
+      <not-uninit/>
+      <strz/>
+      <formatstr/>
+    </arg>
+    <arg nr="4">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
+  <!-- gboolean g_date_valid_day    (  GDateDay day); -->
   <function name="g_date_valid_day">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
+  <!-- gboolean g_date_valid_dmy    (  GDateDay day, GDateMonth month, GDateYear year); -->
   <function name="g_date_valid_dmy">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
+  <!-- gboolean g_date_valid_julian  (guint32 julian_date); -->
   <function name="g_date_valid_julian">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
   </function>
+  <!-- gboolean g_date_valid_month  (GDateMonth month); -->
   <function name="g_date_valid_month">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
+  <!-- gboolean g_date_valid_weekday  (GDateWeekday weekday); -->
   <function name="g_date_valid_weekday">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
+  <!-- gboolean g_date_valid_year  (GDateYear year); -->
   <function name="g_date_valid_year">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
+  <!-- gint g_date_time_compare  (gconstpointer dt1, gconstpointer dt2); -->
   <function name="g_date_time_compare">
     <leak-ignore/>
     <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_time_equal">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
+    <returnValue type="gint"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
+  <!-- gint g_date_time_equal  (gconstpointer dt1, gconstpointer dt2); -->
+  <function name="g_date_time_equal">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="gint"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- guint g_date_time_hash   (gconstpointer datetime); -->
   <function name="g_date_time_hash">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="guint"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- gboolean g_hash_table_add (GHashTable *hash_table, gpointer key); -->
   <function name="g_hash_table_add">
-    <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- gboolean g_hash_table_contains (GHashTable *hash_table, gpointer key); -->
   <function name="g_hash_table_contains">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- gpointer g_hash_table_find (GHashTable *hash_table, GHRFunc predicate, gpointer user_data); -->
   <function name="g_hash_table_find">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gpointer"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- void g_hash_table_foreach  (GHashTable *hash_table, GHRFunc func, gpointer user_data); -->
   <function name="g_hash_table_foreach">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_hash_table_foreach_remove">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_hash_table_foreach_steal">
+  <!-- guint g_hash_table_foreach_remove  (GHashTable *hash_table, GHRFunc func, gpointer user_data); -->
+  <!-- guint g_hash_table_foreach_steal  (GHashTable *hash_table, GHRFunc func, gpointer user_data); -->
+  <function name="g_hash_table_foreach_remove,g_hash_table_foreach_steal">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="guint"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- gpointer g_hash_table_lookup (GHashTable *hash_table, gconstpointer key); -->
   <function name="g_hash_table_lookup">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gpointer"/>
+    <use-retval/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- gboolean g_hash_table_lookup_extended (GHashTable *hash_table, gconstpointer key, gpointer* orig_key, gpointer* value); -->
   <function name="g_hash_table_lookup_extended">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="out"/>
+    <arg nr="4" direction="out"/>
   </function>
-  <function name="g_hash_table_remove">
+  <!-- gboolean g_hash_table_remove (GHashTable *hash_table, gconstpointer key); -->
+  <!-- gboolean g_hash_table_steal (GHashTable *hash_table, gconstpointer key); -->
+  <function name="g_hash_table_remove,g_hash_table_steal">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_hash_table_remove_all">
+  <!-- void g_hash_table_remove_all (GHashTable *hash_table); -->
+  <!-- void g_hash_table_steal_all (GHashTable *hash_table); -->
+  <function name="g_hash_table_remove_all,g_hash_table_steal_all">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
+  <!-- guint g_hash_table_size (GHashTable *hash_table); -->
   <function name="g_hash_table_size">
     <leak-ignore/>
     <noreturn>false</noreturn>
-  </function>
-  <function name="g_hash_table_steal">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_hash_table_steal_all">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
+    <returnValue type="guint"/>
+    <use-retval/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
   <function name="g_hook_destroy_link">
     <leak-ignore/>
@@ -1405,21 +2090,40 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- GIOChannelError g_io_channel_error_from_errno ( gint en) -->
   <function name="g_io_channel_error_from_errno">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GIOChannelError"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
-  <function name="g_io_channel_error_quark">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_key_file_error_quark">
+  <!-- GQuark g_io_channel_error_quark (void) -->
+  <!-- GQuark g_key_file_error_quark (void) -->
+  <!-- GQuark g_regex_error_quark (void) -->
+  <!-- GQuark g_thread_error_quark (void) -->
+  <!-- GQuark g_variant_parser_get_error_quark (void) -->
+  <!-- GQuark g_bookmark_file_error_quark (void) -->
+  <function name="g_io_channel_error_quark,g_key_file_error_quark,g_regex_error_quark,g_thread_error_quark,g_variant_parser_get_error_quark,g_bookmark_file_error_quark">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GQuark"/>
   </function>
+  <!-- GList * g_list_concat  (GList *list1, GList* list2); -->
   <function name="g_list_concat">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GList"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
   <!-- GList * g_list_copy (GList *list); -->
   <function name="g_list_copy">
@@ -1428,99 +2132,202 @@
     <use-retval/>
     <arg nr="1" direction="in">
       <not-uninit/>
-      <not-bool/>
     </arg>
   </function>
+  <!-- GList * g_list_delete_link (GList *list, GList* link_); -->
   <function name="g_list_delete_link">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GList"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- GList * g_list_find (GList *list, gconstpointer data); -->
   <function name="g_list_find">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GList"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- GList * g_list_find_custom (GList *list, gconstpointer data, GCompareFunc func); -->
   <function name="g_list_find_custom">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GList"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-null/>
+    </arg>
   </function>
-  <function name="g_list_first">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
+  <!-- void g_list_foreach  (GList *list, GFunc func, gpointer user_data); -->
   <function name="g_list_foreach">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- gint g_list_index (GList *list, gconstpointer data); -->
   <function name="g_list_index">
     <leak-ignore/>
     <noreturn>false</noreturn>
-  </function>
-  <function name="g_list_last">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
+    <returnValue type="gint"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
   <!-- guint g_list_length (GList *list); -->
   <function name="g_list_length">
+    <pure/>
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="guint"/>
     <use-retval/>
     <arg nr="1" direction="in">
       <not-uninit/>
-      <not-bool/>
     </arg>
   </function>
-  <function name="g_list_nth">
+  <!-- GList* g_list_nth  (GList *list, guint n); -->
+  <!-- GList* g_list_nth_prev  (GList *list, guint n); -->
+  <function name="g_list_nth,g_list_nth_prev">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GList*"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
   </function>
+  <!-- gpointer g_list_nth_data  (GList *list, guint n); -->
   <function name="g_list_nth_data">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gpointer"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
   </function>
-  <function name="g_list_nth_prev">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
+  <!-- gint g_list_position  (GList *list, GList *llink); -->
   <function name="g_list_position">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gint"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_list_remove">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_list_remove_all">
+  <!-- GList* g_list_remove (GList *list, gconstpointer data); -->
+  <!-- GList* g_list_remove_all (GList *list, gconstpointer data); -->
+  <function name="g_list_remove,g_list_remove_all">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GList*"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- GList* g_list_remove_link  (GList *list, GList *llink); -->
   <function name="g_list_remove_link">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GList*"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- GList* g_list_reverse (GList *list); -->
   <function name="g_list_reverse">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GList*"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- GList* g_list_sort  (GList *list, GCompareFunc compare_func); -->
   <function name="g_list_sort">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GList*"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
   </function>
+  <!-- GList* g_list_sort_with_data  (GList *list, GCompareFunc compare_func, gpointer user_data); -->
   <function name="g_list_sort_with_data">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GList*"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_main_context_default">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_main_context_get_thread_default">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_main_context_ref_thread_default">
+  <!--GMainContext* g_main_context_default (void) -->
+  <!--GMainContext* g_main_context_get_thread_default (void) -->
+  <!--GMainContext* g_main_context_ref_thread_default (void) -->
+  <function name="g_main_context_default,g_main_context_get_thread_default,g_main_context_ref_thread_default">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GMainContext*"/>
+    <use-retval/>
   </function>
   <function name="g_once_init_enter">
     <leak-ignore/>
@@ -1530,73 +2337,215 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- void g_ptr_array_foreach(GPtrArray* array, GFunc func, gpointer user_data); -->
   <function name="g_ptr_array_foreach">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_ptr_array_remove">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_ptr_array_remove_fast">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_ptr_array_remove_index">
+  <!-- gboolean g_ptr_array_remove ( GPtrArray* array, gpointer data); -->
+  <!-- gboolean g_ptr_array_remove_fast ( GPtrArray* array, gpointer data); -->
+  <function name="g_ptr_array_remove,g_ptr_array_remove_fast">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+      <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_ptr_array_remove_index_fast">
+  <!-- gpointer g_ptr_array_remove_index ( GPtrArray* array, guint index_); -->
+  <!-- gpointer g_ptr_array_remove_index_fast ( GPtrArray* array, guint index_); -->
+  <function name="g_ptr_array_remove_index,g_ptr_array_remove_index_fast">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gpointer"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
   </function>
+  <!-- GPtrArray* g_ptr_array_remove_range ( GPtrArray* array, guint index_, guint length); -->
   <function name="g_ptr_array_remove_range">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GPtrArray *"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
   </function>
+  <!-- void g_ptr_array_set_free_func ( GPtrArray* array, GDestroyNotify element_free_func); -->
   <function name="g_ptr_array_set_free_func">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
   </function>
+  <!-- void g_ptr_array_set_size ( GPtrArray* array, gint length); -->
   <function name="g_ptr_array_set_size">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
+  <!-- void g_ptr_array_sort  ( GPtrArray* array, GCompareFunc compare_func); -->
   <function name="g_ptr_array_sort">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
   </function>
+  <!-- void g_ptr_array_sort_with_data   ( GPtrArray* array, GCompareFunc compare_func, gpointer user_data); -->
   <function name="g_ptr_array_sort_with_data">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="3"/>
   </function>
+  <!-- gboolean g_regex_check_replacement    ( const gchar* replacement, gboolean* has_references, GError** error); -->
   <function name="g_regex_check_replacement">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out"/>
+    <arg nr="3" direction="out"/>
   </function>
-  <function name="g_regex_error_quark">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
+  <!-- gboolean g_regex_match_simple     ( const gchar* pattern, const gchar* string, GRegexCompileFlags compile_options, GRegexMatchFlags match_options); -->
   <function name="g_regex_match_simple">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
+    <arg nr="4">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- GSList * g_slist_concat  (GSList *list1, GSList* list2); -->
   <function name="g_slist_concat">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GSList"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- GSList * g_slist_delete_link (GSList *list, GSList* link_); -->
   <function name="g_slist_delete_link">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GSList"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- GSList * g_slist_find (GSList *list, gconstpointer data); -->
   <function name="g_slist_find">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GSList"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- GSList * g_slist_find_custom (GSList *list, gconstpointer data, GCompareFunc func); -->
   <function name="g_slist_find_custom">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GSList"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-null/>
+    </arg>
   </function>
   <!-- void g_slist_foreach (GSList *list, GFunc func, gpointer user_data); -->
   <function name="g_slist_foreach">
@@ -1606,8 +2555,12 @@
     <arg nr="1">
       <not-uninit/>
     </arg>
-    <arg nr="2"/>
-    <arg nr="3"/>
+    <arg nr="2">
+      <not-null/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
   </function>
   <!-- gint g_slist_index (GSList *list, gconstpointer data); -->
   <function name="g_slist_index">
@@ -1634,6 +2587,7 @@
   </function>
   <!-- guint g_slist_length (GSList *list); -->
   <function name="g_slist_length">
+    <pure/>
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="guint"/>
@@ -1642,41 +2596,110 @@
       <not-uninit/>
     </arg>
   </function>
+  <!-- GSList* g_slist_nth  (GSList *list, guint n); -->
   <function name="g_slist_nth">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GSList*"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
   </function>
+  <!-- gpointer g_slist_nth_data  (GSList *list, guint n); -->
   <function name="g_slist_nth_data">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gpointer"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
   </function>
+  <!-- gint g_slist_position  (GSList *list, GSList *llink); -->
   <function name="g_slist_position">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gint"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_slist_remove">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_slist_remove_all">
+  <!-- GSList* g_slist_remove (GSList *list, gconstpointer data); -->
+  <!-- GSList* g_slist_remove_all (GSList *list, gconstpointer data); -->
+  <function name="g_slist_remove,g_slist_remove_all">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GSList*"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- GSList* g_slist_remove_link  (GSList *list, GSList *llink); -->
   <function name="g_slist_remove_link">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GSList*"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- GSList* g_slist_reverse (GSList *list); -->
   <function name="g_slist_reverse">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GList*"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- GSList* g_slist_sort  (GSList *list, GCompareFunc compare_func); -->
   <function name="g_slist_sort">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GSList*"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
   </function>
+  <!-- GSList* g_slist_sort_with_data  (GSList *list, GCompareFunc compare_func, gpointer user_data); -->
   <function name="g_slist_sort_with_data">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GSList*"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
   </function>
   <function name="g_sequence_foreach_range">
     <leak-ignore/>
@@ -1722,115 +2745,413 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_source_remove">
+  <!-- void g_thread_exit (gpointer retval) -->
+  <function name="g_thread_exit">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_source_remove_by_funcs_user_data">
+  <!-- GThread* g_thread_self (void) -->
+  <function name="g_thread_self">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GThread*"/>
   </function>
-  <function name="g_source_remove_by_user_data">
+  <function name="g_thread_yield">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_source_set_name_by_id">
+  <function name="g_thread_pool_get_max_idle_time">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_thread_error_quark">
+  <function name="g_thread_pool_get_max_unused_threads">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_thread_exit">
+  <function name="g_thread_pool_get_num_unused_threads">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_thread_self">
+  <function name="g_thread_pool_set_max_idle_time">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_thread_yield">
+  <function name="g_thread_pool_set_max_unused_threads">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_thread_pool_get_max_idle_time">
+  <function name="g_thread_pool_stop_unused_threads">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_thread_pool_get_max_unused_threads">
+  <function name="g_time_val_from_iso8601">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_thread_pool_get_num_unused_threads">
+  <function name="g_trash_stack_height">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_thread_pool_set_max_idle_time">
+  <function name="g_trash_stack_peek">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_thread_pool_set_max_unused_threads">
+  <function name="g_trash_stack_pop">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_thread_pool_stop_unused_threads">
+  <function name="g_trash_stack_push">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_time_val_from_iso8601">
+  <!-- void g_value_copy (const GValue *src_value, GValue *dest_value); -->
+  <function name="g_value_copy">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
     <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-uninit/>
+      <not-null/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- gchar * g_value_dup_string (const GValue *value); -->
+  <function name="g_value_dup_string">
     <noreturn>false</noreturn>
+    <returnValue type="gchar *"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
-  <function name="g_trash_stack_height">
+  <!-- gboolean g_value_get_boolean (const GValue *value); -->
+  <function name="g_value_get_boolean">
+    <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
     <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- gdouble g_value_get_double (const GValue *value); -->
+  <function name="g_value_get_double">
     <noreturn>false</noreturn>
+    <returnValue type="gdouble"/>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <not-bool/>
+    </arg>
   </function>
-  <function name="g_trash_stack_peek">
+  <!-- gint g_value_get_int (const GValue *value); -->
+  <function name="g_value_get_int">
+    <noreturn>false</noreturn>
+    <returnValue type="gint"/>
+    <use-retval/>
     <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- gpointer g_value_get_object (const GValue *value); -->
+  <function name="g_value_get_object">
     <noreturn>false</noreturn>
+    <returnValue type="gpointer"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <not-bool/>
+    </arg>
   </function>
-  <function name="g_trash_stack_pop">
+  <!-- gpointer g_value_get_pointer (const GValue *value); -->
+  <function name="g_value_get_pointer">
+    <noreturn>false</noreturn>
+    <returnValue type="gpointer"/>
+    <use-retval/>
     <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const gchar * g_value_get_string (const GValue *value); -->
+  <function name="g_value_get_string">
     <noreturn>false</noreturn>
+    <returnValue type="const gchar *"/>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <not-bool/>
+    </arg>
   </function>
-  <function name="g_trash_stack_push">
+  <!-- guint g_value_get_uint (const GValue *value); -->
+  <function name="g_value_get_uint">
+    <noreturn>false</noreturn>
+    <returnValue type="guint"/>
+    <use-retval/>
     <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- guint64 g_value_get_uint64 (const GValue *value); -->
+  <function name="g_value_get_uint64">
     <noreturn>false</noreturn>
+    <returnValue type="guint64"/>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <not-bool/>
+    </arg>
   </function>
-  <function name="g_variant_is_object_path">
+  <!-- GValue * g_value_init (GValue *value, GType g_type); -->
+  <function name="g_value_init">
+    <noreturn>false</noreturn>
+    <returnValue type="GValue *">arg1</returnValue>
     <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void g_value_set_boolean (GValue *value, gboolean v_boolean); -->
+  <function name="g_value_set_boolean">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_variant_is_signature">
+  <!-- void g_value_set_double (GValue *value, gdouble v_double); -->
+  <function name="g_value_set_double">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
     <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void g_value_set_int (GValue *value, gint v_int); -->
+  <function name="g_value_set_int">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void g_value_set_object (GValue *value, gpointer v_object); -->
+  <function name="g_value_set_object">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="out">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void g_value_set_object_take_ownership (GValue *value, gpointer v_object); -->
+  <function name="g_value_set_object_take_ownership">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <warn severity="style" reason="Obsolete" alternatives="g_value_take_object">g_value_set_object_take_ownership has been deprecated since version 2.4 and should not be used in newly-written code. Use g_value_take_object() instead.</warn>
+    <arg nr="1" direction="out">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void g_value_set_pointer (GValue *value, gpointer v_pointer); -->
+  <function name="g_value_set_pointer">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="out">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void g_value_set_static_string (GValue *value, const gchar *v_string); -->
+  <!-- void g_value_set_string (GValue *value, const gchar *v_string); -->
+  <function name="g_value_set_static_string,g_value_set_string">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="out">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void g_value_set_string_take_ownership (GValue *value, gchar *v_string); -->
+  <function name="g_value_set_string_take_ownership">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <warn severity="style" reason="Obsolete" alternatives="g_value_take_string">g_value_set_string_take_ownership has been deprecated since version 2.4 and should not be used in newly-written code. Use g_value_take_string() instead.</warn>
+    <arg nr="1" direction="out">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void g_value_set_uint (GValue *value, guint v_uint); -->
+  <function name="g_value_set_uint">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void g_value_take_object (GValue *value, gpointer v_object); -->
+  <function name="g_value_take_object">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="out">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void g_value_take_string (GValue *value, gchar *v_string); -->
+  <function name="g_value_take_string">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="out">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void g_value_unset (GValue *value); -->
+  <function name="g_value_unset">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="out">
+      <not-null/>
+      <not-bool/>
+    </arg>
   </function>
-  <function name="g_variant_parser_get_error_quark">
+  <!-- gboolean g_variant_is_object_path (const gchar* string) -->
+  <!-- gboolean g_variant_is_signature  (const gchar* string) -->
+  <!-- gboolean g_variant_type_string_is_valid  (const gchar* type_string) -->
+  <function name="g_variant_is_object_path,g_variant_is_signature,g_variant_type_string_is_valid">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
   </function>
+  <!-- const GVariantType* g_variant_is_signature  (const gchar* arg0) -->
   <function name="g_variant_type_checked_">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="const GVariantType*"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
   </function>
-  <function name="g_variant_type_string_is_valid">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
+  <!-- gboolean g_variant_type_string_scan  (const gchar* string, const gchar* limit, const gchar** endptr) -->
   <function name="g_variant_type_string_scan">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <strz/>
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="out">
+      <strz/>
+    </arg>
   </function>
-  <function name="g_access">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_array_get_element_size">
-    <leak-ignore/>
+  <!-- void g_variant_unref (GVariant* value); -->
+  <function name="g_variant_unref">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
-  <function name="g_array_set_clear_func">
+  <function name="g_access">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
@@ -1851,9 +3172,31 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- gchar* g_ascii_formatd (  gchar* buffer,  gint buf_len,  const gchar* format,  gdouble d)-->
   <function name="g_ascii_formatd">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gchar*"/>
+    <arg nr="1" direction="out">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-bool/>
+      <not-uninit/>
+    </arg>
+    <formatstr/>
+    <arg nr="3" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+      <formatstr/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-bool/>
+      <not-uninit/>
+    </arg>
   </function>
   <!-- gboolean g_ascii_isalnum(gchar c); -->
   <function name="g_ascii_isalnum">
@@ -2008,11 +3351,13 @@
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- gchar * g_ascii_strdown(const gchar *str, gssize len); -->
@@ -2022,6 +3367,7 @@
     <use-retval/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -2037,9 +3383,11 @@
     <const/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -2170,21 +3518,47 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- gint g_atomic_int_add (volatile gint* atomic, gint val) -->
   <function name="g_atomic_int_add">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gint"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
+  <!-- guint g_atomic_int_and (volatile gint* atomic, guint val) -->
   <function name="g_atomic_int_and">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="guint"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
   <function name="g_atomic_int_compare_and_exchange">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- gboolean g_atomic_int_dec_and_test (volatile gint* atomic) -->
   <function name="g_atomic_int_dec_and_test">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
   <function name="g_atomic_int_exchange_and_add">
     <leak-ignore/>
@@ -2193,10 +3567,21 @@
   <function name="g_atomic_int_get">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gint"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
+  <!-- void g_atomic_int_inc (volatile gint* atomic) -->
   <function name="g_atomic_int_inc">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
   <function name="g_atomic_int_or">
     <leak-ignore/>
@@ -2254,9 +3639,18 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- const gchar * g_basename (const gchar *file_name); -->
   <function name="g_basename">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="const gchar *"/>
+    <use-retval/>
+    <warn severity="style" reason="Obsolete" alternatives="g_path_get_basename">g_basename has been deprecated since version 2.2 and should not be used in newly-written code. Use g_path_get_basename() instead, but notice that g_path_get_basename() allocates new memory for the returned string, unlike this function which returns a pointer into the argument.</warn>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
   <function name="g_bit_lock">
     <leak-ignore/>
@@ -2282,10 +3676,6 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_bookmark_file_error_quark">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
   <function name="g_chdir">
     <leak-ignore/>
     <noreturn>false</noreturn>
@@ -2294,17 +3684,42 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_checksum_type_get_length">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
+  <!-- guint g_child_watch_add (  GPid pid,  GChildWatchFunc function,  gpointer data) -->
   <function name="g_child_watch_add">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="guint"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- guint g_child_watch_add_full ( gint priority, GPid pid,  GChildWatchFunc function,  gpointer data, GDestoryNotify notify) -->
   <function name="g_child_watch_add_full">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="guint"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" direction="in"/>
   </function>
   <!-- void g_clear_error (GError **err); -->
   <function name="g_clear_error">
@@ -2314,9 +3729,19 @@
       <not-bool/>
     </arg>
   </function>
+  <!-- void g_clear_pointer (gpointer* pp, GDestroyNotify destroy); -->
   <function name="g_clear_pointer">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
   <function name="g_convert_error_quark">
     <leak-ignore/>
@@ -2386,62 +3811,6 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_date_get_days_in_month">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_get_monday_weeks_in_year">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_get_sunday_weeks_in_year">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_is_leap_year">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_strftime">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_time_compare">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_time_equal">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_time_hash">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_valid_day">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_valid_dmy">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_valid_julian">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_valid_month">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_valid_weekday">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_valid_year">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
   <function name="g_dcgettext">
     <leak-ignore/>
     <noreturn>false</noreturn>
@@ -2460,13 +3829,40 @@
       <not-bool/>
     </arg>
   </function>
+  <!-- gboolean g_direct_equal ( gconstpointer v1, gconstpointer v2) -->
   <function name="g_direct_equal">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- guint g_direct_hash ( gconstpointer v1, gconstpointer v2) -->
   <function name="g_direct_hash">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="guint"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- gchar * g_dirname (const gchar *file_name); -->
+  <function name="g_dirname">
+    <noreturn>false</noreturn>
+    <returnValue type="gchar *"/>
+    <use-retval/>
+    <warn severity="style" reason="Obsolete" alternatives="g_path_get_dirname">g_dirname is deprecated and should not be used in newly-written code. Use g_path_get_dirname() instead.</warn>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
   <function name="g_dngettext">
     <leak-ignore/>
@@ -2514,19 +3910,83 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_file_get_contents">
+  <!-- gboolean g_file_get_contents (const gchar* filename, gchar** contents, gsize* length, GError** error) -->
+  <function name="g_file_get_contents">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out"/>
+    <arg nr="3" direction="out"/>
+    <arg nr="4" direction="out"/>
+  </function>
+  <!-- gint g_file_open_tmp (const gchar* tmpl, gchar** name_used, GError** error) -->
+  <function name="g_file_open_tmp">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="gint"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <strz/>
+    </arg>
+    <arg nr="3" direction="out"/>
+  </function>
+  <!-- gboolean g_file_set_contents (const gchar* filename, const gchar* contents, gssize length, GError** error) -->
+  <function name="g_file_set_contents">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="out"/>
+  </function>
+  <!-- gboolean g_file_test (const gchar* filename, GFileTest test) -->
+  <function name="g_file_test">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_file_open_tmp">
+  <function name="g_file_info_get_attribute_object">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_file_set_contents">
+  <function name="g_file_info_get_icon">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_file_test">
+  <function name="g_file_info_get_symbolic_icon">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
@@ -2553,6 +4013,12 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- gchar * g_get_current_dir (void); -->
+  <function name="g_get_current_dir">
+    <noreturn>false</noreturn>
+    <returnValue type="gchar *"/>
+    <use-retval/>
+  </function>
   <function name="g_get_current_time">
     <leak-ignore/>
     <noreturn>false</noreturn>
@@ -2565,41 +4031,50 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_get_host_name">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
   <function name="g_get_language_names">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_get_monotonic_time">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_get_prgname">
+  <!-- const gchar* g_get_prgname (void) -->
+  <!-- const gchar* g_get_host_name (void) -->
+  <function name="g_get_prgname,g_get_host_name">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="const gchar *"/>
+    <use-retval/>
   </function>
   <function name="g_get_real_name">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_get_real_time">
+  <!-- gint64 g_get_real_time (void) -->
+  <!-- gint64 g_get_monotonic_time (void) -->
+  <function name="g_get_real_time,g_get_monotonic_time">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gint64"/>
+    <use-retval/>
   </function>
+  <!-- const gchar * const * g_get_system_config_dirs (void); -->
   <function name="g_get_system_config_dirs">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="const gchar *const *"/>
+    <use-retval/>
   </function>
+  <!-- const gchar * const * g_get_system_data_dirs (void); -->
   <function name="g_get_system_data_dirs">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="const gchar *const *"/>
+    <use-retval/>
   </function>
+  <!-- const gchar * g_get_tmp_dir (void); -->
   <function name="g_get_tmp_dir">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="const gchar *"/>
+    <use-retval/>
   </function>
   <function name="g_get_user_cache_dir">
     <leak-ignore/>
@@ -2625,53 +4100,17 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- const gchar * g_getenv (const gchar *variable); -->
   <function name="g_getenv">
     <leak-ignore/>
     <noreturn>false</noreturn>
-  </function>
-  <function name="g_hash_table_add">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_hash_table_contains">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_hash_table_lookup_extended">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_hash_table_remove">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_hash_table_remove_all">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_hash_table_size">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_hash_table_steal">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_hash_table_steal_all">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_hook_destroy_link">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_hook_insert_before">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_hook_prepend">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
+    <returnValue type="const gchar *"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
   <function name="g_hostname_is_ascii_encoded">
     <leak-ignore/>
@@ -2685,17 +4124,45 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!--guint g_idle_add (GSourceFunc function, gpointer data); -->
   <function name="g_idle_add">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="guint"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
+  <!--guint g_idle_add_full (gint priority, GSourceFunc function, gpointer data, GDestroyNotify notify); -->
   <function name="g_idle_add_full">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="guint"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
+    <arg nr="4">
+      <not-uninit/>
+    </arg>
   </function>
+  <!--gboolean g_idle_remove_by_data (gpointer data); -->
   <function name="g_idle_remove_by_data">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
   </function>
   <function name="g_int64_equal">
     <leak-ignore/>
@@ -2721,13 +4188,54 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- guint g_io_add_watch ( GIOChannel* channel, GIOCondition condition, GIOFunc func, gpointer user_data) -->
   <function name="g_io_add_watch">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="guint"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- guint g_io_add_watch_full ( GIOChannel* channel, gint priority, GIOCondition condition, GIOFunc func, gpointer user_data, GDestroyNotify notify) -->
   <function name="g_io_add_watch_full">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="guint"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
   <function name="g_io_channel_error_from_errno">
     <leak-ignore/>
@@ -2737,10 +4245,6 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_key_file_error_quark">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
   <function name="g_log">
     <leak-ignore/>
     <noreturn>false</noreturn>
@@ -2833,9 +4337,15 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- void g_nullify_pointer (gpointer *nullify_location); -->
   <function name="g_nullify_pointer">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="out">
+      <not-null/>
+      <not-bool/>
+    </arg>
   </function>
   <!-- void g_object_add_weak_pointer (GObject *object, gpointer *weak_pointer_location); -->
   <function name="g_object_add_weak_pointer">
@@ -3154,13 +4664,51 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- gchar * g_path_get_basename (const gchar *file_name); -->
+  <function name="g_path_get_basename">
+    <noreturn>false</noreturn>
+    <returnValue type="gchar *"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- gchar * g_path_get_dirname (const gchar *file_name); -->
+  <function name="g_path_get_dirname">
+    <noreturn>false</noreturn>
+    <returnValue type="gchar *"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- gboolean g_path_is_absolute (const gchar *file_name); -->
   <function name="g_path_is_absolute">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
+  <!-- const gchar * g_path_skip_root (const gchar *file_name); -->
   <function name="g_path_skip_root">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="const gchar *"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
   <function name="g_pattern_match">
     <leak-ignore/>
@@ -3256,26 +4804,6 @@
       <formatstr/>
     </arg>
   </function>
-  <function name="g_ptr_array_remove">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_ptr_array_remove_fast">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_ptr_array_remove_range">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_ptr_array_set_free_func">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_ptr_array_set_size">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
   <function name="g_qsort_with_data">
     <leak-ignore/>
     <noreturn>false</noreturn>
@@ -3308,9 +4836,19 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- gint32 g_random_int_range(gint32 begin, gint32 end) -->
   <function name="g_random_int_range">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gint32"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
   <function name="g_random_set_seed">
     <leak-ignore/>
@@ -3342,51 +4880,15 @@
       <valid>0:</valid>
     </arg>
   </function>
-  <function name="g_regex_check_replacement">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_regex_error_quark">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_regex_match_simple">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
   <function name="g_reload_user_special_dirs_cache">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_return_if_fail_warning">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_rmdir">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_sequence_move">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_sequence_move_range">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_sequence_remove">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_sequence_remove_range">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_sequence_set">
+  <function name="g_return_if_fail_warning">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_sequence_swap">
+  <function name="g_rmdir">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
@@ -3452,9 +4954,22 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- gboolean g_setenv (const gchar *variable, const gchar *value, gboolean overwrite); -->
   <function name="g_setenv">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
   <function name="g_shell_error_quark">
     <leak-ignore/>
@@ -3481,7 +4996,7 @@
     <noreturn>false</noreturn>
   </function>
   <function name="g_snprintf">
-    <returnValue type="int"/>
+    <returnValue type="gint"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1">
@@ -3583,6 +5098,7 @@
   </function>
   <!-- gboolean g_str_equal (gconstpointer v1, gconstpointer v2); -->
   <function name="g_str_equal">
+    <pure/>
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="gboolean"/>
@@ -3596,13 +5112,23 @@
       <not-uninit/>
     </arg>
   </function>
-  <function name="g_str_has_prefix">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_str_has_suffix">
+  <!-- gboolean g_str_has_prefix (const gchar* str, const gchar* prefix); -->
+  <!-- gboolean g_str_has_suffix (const gchar* str, const gchar* prefix); -->
+  <function name="g_str_has_prefix,g_str_has_suffix">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
   </function>
   <function name="g_str_hash">
     <leak-ignore/>
@@ -3631,27 +5157,40 @@
       <not-bool/>
     </arg>
   </function>
+  <!-- gchar * g_strchomp (gchar *string); -->
   <function name="g_strchomp">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gchar *">arg1</returnValue>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+      <strz/>
+    </arg>
   </function>
+  <!-- gchar * g_strchug (gchar *string); -->
   <function name="g_strchug">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gchar *">arg1</returnValue>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+      <strz/>
+    </arg>
   </function>
   <!-- int g_strcmp0 (const char *str1, const char *str2); -->
   <function name="g_strcmp0">
     <leak-ignore/>
+    <pure/>
     <noreturn>false</noreturn>
     <returnValue type="int"/>
     <use-retval/>
     <arg nr="1" direction="in">
-      <not-null/>
       <not-uninit/>
       <strz/>
     </arg>
     <arg nr="2" direction="in">
-      <not-null/>
       <not-uninit/>
       <strz/>
       <not-bool/>
@@ -3753,25 +5292,89 @@
       <valid>0:</valid>
     </arg>
   </function>
+  <!-- gchar * g_strndup (const gchar *str, gsize n); -->
+  <function name="g_strndup">
+    <noreturn>false</noreturn>
+    <returnValue type="gchar *"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- gchar * g_strreverse (gchar *string); -->
   <function name="g_strreverse">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gchar*"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
   </function>
+  <!-- gchar * g_strrstr (const gchar *haystack, const gchar* needle); -->
   <function name="g_strrstr">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gchar*"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
   </function>
-  <function name="g_strrstr_len">
+  <!-- gchar * g_strrstr_len (const gchar *haystack, gssize haystack_len, const gchar* needle); -->
+  <!-- gchar * g_strstr_len (const gchar *haystack, gssize haystack_len, const gchar* needle); -->
+  <function name="g_strrstr_len,g_strstr_len">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gchar*"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-bool/>
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
   </function>
   <function name="g_strsignal">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_strstr_len">
-    <leak-ignore/>
+  <!-- gchar ** g_strsplit (const gchar *string, const gchar *delimiter, gint max_tokens); -->
+  <function name="g_strsplit">
     <noreturn>false</noreturn>
+    <returnValue type="gchar **"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
   <function name="g_strtod">
     <leak-ignore/>
@@ -3785,9 +5388,17 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- guint g_strv_length (gchar** str_array) -->
   <function name="g_strv_length">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="guint"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
   </function>
   <function name="g_test_add_data_func">
     <leak-ignore/>
@@ -3925,65 +5536,47 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_thread_exit">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_thread_pool_get_max_idle_time">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_thread_pool_get_max_unused_threads">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_thread_pool_get_num_unused_threads">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_thread_pool_set_max_idle_time">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_thread_pool_set_max_unused_threads">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_thread_pool_stop_unused_threads">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_thread_yield">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_time_val_from_iso8601">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_timeout_add">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_timeout_add_full">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_timeout_add_seconds">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_timeout_add_seconds_full">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_trash_stack_height">
+  <!-- guint g_timeout_add ( guint interval, GSourceFunc function, gpointer data) -->
+  <!-- guint g_timeout_add_seconds ( guint interval, GSourceFunc function, gpointer data) -->
+  <function name="g_timeout_add,g_timeout_add_seconds">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="guint"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_trash_stack_push">
+  <!-- guint g_timeout_add_full (gint priority, guint interval, GSourceFunc function, gpointer data, GDestroyNotify notify) -->
+  <function name="g_timeout_add_full,g_timeout_add_seconds_full">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="guint"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
   <!-- gpointer g_try_malloc (gsize n_bytes); -->
   <!-- gpointer g_try_malloc0 (gsize n_bytes); -->
@@ -4205,9 +5798,16 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- void g_unsetenv (const gchar *variable); -->
   <function name="g_unsetenv">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
   <function name="g_usleep">
     <leak-ignore/>
@@ -4245,157 +5845,176 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_utf8_strchr">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_utf8_strlen">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_utf8_strncpy">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_utf8_strrchr">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_utf8_validate">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_variant_get_gtype">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_variant_is_object_path">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_variant_is_signature">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_variant_parser_get_error_quark">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_variant_type_checked_">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_variant_type_string_is_valid">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_variant_type_string_scan">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_vasprintf">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_vfprintf">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_vprintf">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_vsnprintf">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_vsprintf">
+  <function name="g_utf8_strchr">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_warn_message">
+  <function name="g_utf8_strlen">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_async_queue_length">
+  <function name="g_utf8_strncpy">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_async_queue_length_unlocked">
+  <function name="g_utf8_strrchr">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_async_queue_lock">
+  <function name="g_utf8_validate">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_async_queue_pop">
+  <function name="g_variant_get_gtype">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_async_queue_pop_unlocked">
+  <function name="g_vasprintf">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_async_queue_push">
+  <function name="g_vfprintf">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_async_queue_push_sorted">
+  <function name="g_vprintf">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_async_queue_push_sorted_unlocked">
+  <function name="g_vsnprintf">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_async_queue_push_unlocked">
+  <function name="g_vsprintf">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_async_queue_ref_unlocked">
+  <function name="g_warn_message">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_async_queue_sort">
+  <!-- gint g_async_queue_length (GAsyncQueue  *queue); -->
+  <!-- gint g_async_queue_length_unlocked (GAsyncQueue  *queue); -->
+  <function name="g_async_queue_length,g_async_queue_length_unlocked">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gint"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
-  <function name="g_async_queue_sort_unlocked">
+  <!-- void g_async_queue_lock (GAsyncQueue  *queue); -->
+  <!-- void g_async_queue_unlock (GAsyncQueue  *queue); -->
+  <function name="g_async_queue_lock,g_async_queue_unlock">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
-  <function name="g_async_queue_timed_pop">
+  <!-- gpointer g_async_queue_pop (GAsyncQueue  *queue); -->
+  <!-- gpointer g_async_queue_pop_unlocked (GAsyncQueue  *queue); -->
+  <!-- gpointer g_async_queue_try_pop (GAsyncQueue  *queue); -->
+  <!-- gpointer g_async_queue_try_pop_unlocked (GAsyncQueue  *queue); -->
+  <function name="g_async_queue_pop,g_async_queue_pop_unlocked,g_async_queue_try_pop,g_async_queue_try_pop_unlocked">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gpointer"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
-  <function name="g_async_queue_timed_pop_unlocked">
-    <leak-ignore/>
+  <!-- void g_async_queue_push (GAsyncQueue* queue, gpointer data); -->
+  <!-- void g_async_queue_push_unlocked (GAsyncQueue* queue, gpointer data); -->
+  <function name="g_async_queue_push,g_async_queue_push_unlocked">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
-  <function name="g_async_queue_timeout_pop">
-    <leak-ignore/>
+  <!-- void g_async_queue_push_sorted (GAsyncQueue* queue, gpointer data, GCompareDataFunc func, gpointer user_data); -->
+  <!-- void g_async_queue_push_sorted_unlocked (GAsyncQueue* queue, gpointer data, GCompareDataFunc func, gpointer user_data); -->
+  <function name="g_async_queue_push_sorted,g_async_queue_push_sorted_unlocked">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="3">
+      <not-null/>
+    </arg>
+    <arg nr="4">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_async_queue_timeout_pop_unlocked">
-    <leak-ignore/>
+  <!-- gpointer g_async_queue_ref (GAsyncQueue  *queue); -->
+  <!-- gpointer g_async_queue_ref_unlocked (GAsyncQueue  *queue); -->
+  <function name="g_async_queue_ref,g_async_queue_ref_unlocked">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
-  <function name="g_async_queue_try_pop">
+  <!-- void g_async_queue_sort (GAsyncQueue* queue, GCompareDataFunc func, gpointer user_data); -->
+  <!-- void g_async_queue_sort_unlocked (GAsyncQueue* queue, GCompareDataFunc func, gpointer user_data); -->
+  <function name="g_async_queue_sort,g_async_queue_sort_unlocked">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_async_queue_try_pop_unlocked">
+  <function name="g_async_queue_timed_pop,g_async_queue_timed_pop_unlocked">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <warn severity="style" reason="Obsolete" alternatives="g_async_queue_timeout_pop,g_async_queue_timeout_pop_unlocked">g_async_queue_timed_pop_unlocked is deprecated and should not be used in newly-written code.use g_async_queue_timeout_pop_unlocked().</warn>
   </function>
-  <function name="g_async_queue_unlock">
+  <!-- gpointer g_async_queue_timeout_pop (GAsyncQueue  *queue, guint64 timeout); -->
+  <!-- gpointer g_async_queue_timeout_pop_unlocked (GAsyncQueue  *queue, guint64 timeout); -->
+  <function name="g_async_queue_timeout_pop,g_async_queue_timeout_pop_unlocked">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gpointer"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
   </function>
   <function name="g_async_queue_unref_and_unlock">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <warn severity="style" reason="Obsolete" alternatives="g_async_queue_unref">g_async_queue_unref_and_unlock has been deprecated since version 2.8 and should not be used in newly-written code. Reference counting is done atomically. so g_async_queue_unref() can be used regardless of the queues lock.</warn>
   </function>
   <function name="g_bookmark_file_add_application">
     <leak-ignore/>
@@ -4529,25 +6148,70 @@
       <not-uninit/>
     </arg>
   </function>
+  <!-- gint g_bytes_compare (gconstpointer bytes1, gconstpointer bytes2) -->
   <function name="g_bytes_compare">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gint"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- gboolean g_bytes_equal(gconstpointer bytes1, gconstpointer bytes2) -->
   <function name="g_bytes_equal">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- gconstpointer g_bytes_get_data(GBytes* bytes, gsize* size) -->
   <function name="g_bytes_get_data">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="out">
+    </arg>
   </function>
+  <!-- gsize g_bytes_get_size(GBytes* bytes) -->
   <function name="g_bytes_get_size">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gsize"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- guint g_bytes_hash (gconstpointer bytes) -->
   <function name="g_bytes_hash">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="guint"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
   </function>
   <function name="g_checksum_get_digest">
     <leak-ignore/>
@@ -4721,65 +6385,57 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- GTimeSpan g_date_time_difference (GDateTime* end, GDateTime* begin) -->
   <function name="g_date_time_difference">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GTimeSpan"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_date_time_get_day_of_month">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_time_get_day_of_week">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_time_get_day_of_year">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_time_get_hour">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_time_get_microsecond">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_time_get_minute">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_time_get_month">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_time_get_second">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_time_get_seconds">
+  <!-- gint g_date_time_get_microsecond (GDateTime* datetime) -->
+  <!-- gint g_date_time_get_hour (GDateTime* datetime) -->
+  <!-- gint g_date_time_get_minute (GDateTime* datetime) -->
+  <!-- gint g_date_time_get_month (GDateTime* datetime) -->
+  <!-- gint g_date_time_get_second (GDateTime* datetime) -->
+  <!-- gint g_date_time_get_seconds (GDateTime* datetime) -->
+  <!-- gint g_date_time_get_day_of_year (GDateTime* datetime) -->
+  <!-- gint g_date_time_get_day_of_week (GDateTime* datetime) -->
+  <!-- gint g_date_time_get_day_of_month (GDateTime* datetime) -->
+  <!-- gint g_date_time_get_week_of_year (GDateTime* datetime) -->
+  <!-- gint g_date_time_get_year (GDateTime* datetime) -->
+  <!-- gint g_date_time_get_week_numbering_year (GDateTime* datetime) -->
+  <function name="g_date_time_get_week_numbering_year,g_date_time_get_microsecond,g_date_time_get_hour,g_date_time_get_day_of_year,g_date_time_get_week_of_year,g_date_time_get_year,g_date_time_get_day_of_week,g_date_time_get_day_of_month,g_date_time_get_second,g_date_time_get_seconds">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gint"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
   </function>
   <function name="g_date_time_get_timezone_abbreviation">
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- GTimeSpan g_date_time_to_unix (GDateTime* datetime) -->
   <function name="g_date_time_get_utc_offset">
     <leak-ignore/>
     <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_time_get_week_numbering_year">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_time_get_week_of_year">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_date_time_get_year">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
+    <returnValue type="GTimeSpan"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
   </function>
   <function name="g_date_time_get_ymd">
     <leak-ignore/>
@@ -4793,9 +6449,16 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- gint64 g_date_time_to_unix (GDateTime* datetime) -->
   <function name="g_date_time_to_unix">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gint64"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
   </function>
   <function name="g_dir_read_name">
     <leak-ignore/>
@@ -4900,9 +6563,16 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- void g_hash_table_iter_replace (GHashTableIter *iter, gpointer value); -->
   <function name="g_hash_table_iter_replace">
-    <leak-ignore/>
     <noreturn>false</noreturn>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
   <function name="g_hash_table_iter_steal">
     <leak-ignore/>
@@ -5492,9 +7162,16 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- void g_option_context_add_group (GOptionContext *context, GOptionGroup *group); -->
   <function name="g_option_context_add_group">
-    <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
   <function name="g_option_context_add_main_entries">
     <leak-ignore/>
@@ -5536,9 +7213,16 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- void g_option_context_set_main_group (GOptionContext *context, GOptionGroup *group); -->
   <function name="g_option_context_set_main_group">
-    <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
   <function name="g_option_context_set_summary">
     <leak-ignore/>
@@ -5588,129 +7272,344 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- void g_queue_clear (GQueue* queue) -->
   <function name="g_queue_clear">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
+  <!-- void g_queue_clear_full (GQueue* queue, GDestoryNotify free_func) -->
+  <function name="g_queue_clear_full">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" />
   </function>
+  <!-- void g_queue_delete_link (GQueue *queue, GList* link_); -->
   <function name="g_queue_delete_link">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- GList * g_queue_find (GQueue *queue, gconstpointer data); -->
+  <function name="g_queue_find">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="GList"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- GList * g_queue_find_custom (GQueue *queue, gconstpointer data, GCompareFunc func); -->
+  <function name="g_queue_find_custom">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="GList"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- void g_queue_foreach  (GQueue *queue, GFunc func, gpointer user_data); -->
+  <function name="g_queue_foreach">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_queue_find">
-    <leak-ignore/>
+  <!-- GQueue* g_queue_new(void); -->
+  <function name="g_queue_new">
     <noreturn>false</noreturn>
+    <returnValue type="GQueue*"/>
+    <use-retval/>
   </function>
-  <function name="g_queue_find_custom">
-    <leak-ignore/>
+  <!-- GQueue* g_queue_copy(GQueue* queue); -->
+  <function name="g_queue_copy">
     <noreturn>false</noreturn>
+    <returnValue type="GQueue*"/>
+    <use-retval/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
-  <function name="g_queue_foreach">
-    <leak-ignore/>
+  <!-- void g_queue_free  (GQueue *queue); -->
+  <function name="g_queue_free">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
+  <!-- void g_queue_free_full  (GQueue *queue, GDestroyNotify free_func); -->
   <function name="g_queue_free_full">
-    <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
   </function>
+  <!-- guint g_queue_get_length (GQueue *queue); -->
   <function name="g_queue_get_length">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="guint"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
+  <!-- gint g_queue_index (GQueue *queue, gconstpointer data); -->
   <function name="g_queue_index">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gint"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- void g_queue_init (GQueue* queue) -->
   <function name="g_queue_init">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
-  <function name="g_queue_insert_after">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_queue_insert_before">
+  <!-- void g_queue_insert_after (GQueue* queue, GList *sibling, gpointer data) -->
+  <!-- void g_queue_insert_before (GQueue* queue, GList *sibling, gpointer data) -->
+  <function name="g_queue_insert_after,g_queue_insert_before">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- void g_queue_insert_sorted  (GQueue* queue, gpointer data, GCompareDataFunc func, gpointer user_data) -->
   <function name="g_queue_insert_sorted">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-null/>
+    </arg>
+    <arg nr="4">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- gboolean g_queue_is_empty   (GQueue* queue) -->
   <function name="g_queue_is_empty">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
+  <!-- gint g_queue_link_index  (GQueue* queue) -->
   <function name="g_queue_link_index">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gint"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
-  <function name="g_queue_peek_head">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_queue_peek_head_link">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_queue_peek_nth">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_queue_peek_nth_link">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_queue_peek_tail">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_queue_peek_tail_link">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_queue_pop_head">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_queue_pop_head_link">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-  </function>
-  <function name="g_queue_pop_nth">
+  <!-- gpointer g_queue_peek_head  (GQueue* queue) -->
+  <!-- gpointer g_queue_peek_tail  (GQueue* queue) -->
+  <!-- gpointer g_queue_pop_head  (GQueue* queue) -->
+  <!-- gpointer g_queue_pop_tail  (GQueue* queue) -->
+  <function name="g_queue_peek_head,g_queue_peek_tail,g_queue_pop_head,g_queue_pop_tail">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gpointer"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
-  <function name="g_queue_pop_nth_link">
+  <!-- GList* g_queue_peek_head_link  (GQueue* queue) -->
+  <!-- GList* g_queue_peek_tail_link  (GQueue* queue) -->
+  <!-- GList* g_queue_pop_head_link  (GQueue* queue) -->
+  <!-- GList* g_queue_pop_tail_link  (GQueue* queue) -->
+  <function name="g_queue_peek_head_link,g_queue_peek_tail_link,g_queue_pop_head_link,g_queue_pop_tail_link">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GList*"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
-  <function name="g_queue_pop_tail">
+  <!-- gpointer g_queue_peek_nth  (GQueue* queue, guint n) -->
+  <!-- gpointer g_queue_pop_nth  (GQueue* queue, guint n) -->
+  <function name="g_queue_peek_nth,g_queue_pop_nth">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gpointer"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
   </function>
-  <function name="g_queue_pop_tail_link">
+  <!-- GList* g_queue_peek_nth_link  (GQueue* queue, guint n) -->
+  <!-- GList* g_queue_pop_nth_link  (GQueue* queue, guint n) -->
+  <function name="g_queue_peek_nth_link,g_queue_pop_nth_link">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GList*"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
   </function>
+  <!-- gpointer g_queue_remove   (GQueue* queue, gconstpointer data); -->
   <function name="g_queue_remove">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
+  <!-- gpointer g_queue_remove_all   (GQueue* queue, gconstpointer data); -->
   <function name="g_queue_remove_all">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="guint"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
+  <!-- void g_queue_reverse (GQueue* queue) -->
   <function name="g_queue_reverse">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
+  <!-- void g_queue_sort  (GQueue* queue, GCompareDataFunc func, gpointer user_data) -->
   <function name="g_queue_sort">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- void g_queue_unlink (GQueue* queue, GList *link_) -->
   <function name="g_queue_unlink">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
   <function name="g_rw_lock_clear">
     <leak-ignore/>
@@ -6444,53 +8343,158 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
-  <function name="g_tree_destroy">
-    <leak-ignore/>
+  <!-- GTree* g_tree_new(GCompareFunc key_compare_func); -->
+  <function name="g_tree_new">
     <noreturn>false</noreturn>
+    <returnValue type="GTree*"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
-  <function name="g_tree_foreach">
-    <leak-ignore/>
+  <!-- void g_tree_destroy (GTree *tree); -->
+  <function name="g_tree_destroy">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_tree_height">
+  <!-- void g_tree_foreach  (GTree *tree, GTraverseFunc func, gpointer user_data); -->
+  <function name="g_tree_foreach">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_tree_insert">
+  <!-- gint g_tree_node_key  (GTree *tree); -->
+  <!-- gint g_tree_node_value(GTree *tree); -->
+  <function name="g_tree_node_key,g_tree_node_value">
     <leak-ignore/>
+    <returnValue type="gpointer"/>
+    <use-retval/>
     <noreturn>false</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_tree_lookup">
+  <!-- gint g_tree_height  (GTree *tree); -->
+  <!-- gint g_tree_nnodes  (GTree *tree); -->
+  <function name="g_tree_height,g_tree_nnodes">
     <leak-ignore/>
+    <returnValue type="gint"/>
+    <use-retval/>
     <noreturn>false</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
-  <function name="g_tree_lookup_extended">
-    <leak-ignore/>
+  <!-- void g_tree_insert (GTree *tree, gpointer key, gpointer value); -->
+  <!-- void g_tree_replace (GTree *tree, gpointer key, gpointer value); -->
+  <function name="g_tree_insert,g_tree_replace">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_tree_nnodes">
+   <!-- gpointer g_tree_lookup (GTree *tree, gconstpointer key); -->
+  <function name="g_tree_lookup">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gpointer"/>
+    <use-retval/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_tree_remove">
+  <!-- gboolean g_tree_lookup_extended (GTree *tree, gconstpointer key, gpointer* orig_key, gpointer* value); -->
+  <function name="g_tree_lookup_extended">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <use-retval/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="out"/>
+    <arg nr="4" direction="out"/>
   </function>
-  <function name="g_tree_replace">
+  <!-- gboolean g_tree_remove (GTree *tree, gconstpointer key); -->
+  <!-- gboolean g_tree_steal (GTree *tree, gconstpointer key); -->
+  <function name="g_tree_remove,g_tree_steal">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gboolean"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
+  <!-- void g_tree_search  (GTree *tree, GCompareFunc func, gconstpointer user_data); -->
   <function name="g_tree_search">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="gpointer"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_tree_steal">
+  <!-- GTreeNode* g_tree_lower_bound (GTree *tree, gconstpointer key); -->
+  <!-- GTreeNode* g_tree_upper_bound (GTree *tree, gconstpointer key); -->
+  <function name="g_tree_lower_bound,g_tree_upper_bound">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="GTreeNode*"/>
+    <use-retval/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
   </function>
   <function name="g_tree_traverse">
     <leak-ignore/>
     <noreturn>false</noreturn>
+    <warn severity="style" reason="Obsolete" alternatives="g_tree_foreach">g_tree_traverse has been deprecated since version 2.2 and should not be used in newly-written code. The order of a balanced tree is somewhat arbitrary. If you just want to visit all nodes in sorted order, use g_tree_foreach() instead. If you really need to visit nodes in a different order, consider using an n-ary tree.</warn>
   </function>
   <!-- GLIB_AVAILABLE_IN_ALL gboolean g_type_check_class_is_a (GTypeClass *g_class, GType is_a_type) G_GNUC_PURE; -->
   <!-- GLIB_AVAILABLE_IN_ALL gboolean g_type_check_instance_is_a (GTypeInstance *instance, GType iface_type) G_GNUC_PURE; -->
@@ -6517,6 +8521,26 @@
       <not-bool/>
     </arg>
   </function>
+  <!-- gpointer g_type_class_peek (GType type); -->
+  <!-- gpointer g_type_class_peek_static (GType type); -->
+  <function name="g_type_class_peek,g_type_class_peek_static">
+    <noreturn>false</noreturn>
+    <returnValue type="gpointer"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- gpointer g_type_class_peek_parent (gpointer g_class); -->
+  <function name="g_type_class_peek_parent">
+    <noreturn>false</noreturn>
+    <returnValue type="gpointer"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
   <!-- GLIB_AVAILABLE_IN_ALL gpointer g_type_instance_get_private (GTypeInstance *instance, GType private_type); -->
   <function name="g_type_instance_get_private">
     <noreturn>false</noreturn>
@@ -6680,29 +8704,91 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- void g_variant_builder_add (GVariantBuilder* builder,const gchar* format_string, ...) -->
   <function name="g_variant_builder_add">
-    <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="variadic" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_variant_builder_add_parsed">
-    <leak-ignore/>
+  <!-- void g_variant_builder_add_value ( GVariantBuilder* builder, GVariant* value) -->
+  <function name="g_variant_builder_add_value">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_variant_builder_clear">
-    <leak-ignore/>
+  <!-- void g_variant_builder_add_parsed ( GVariantBuilder* builder, const gchar* format, ...) -->
+  <function name="g_variant_builder_add_parsed">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="variadic" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
-  <function name="g_variant_builder_close">
-    <leak-ignore/>
+  <!-- void g_variant_builder_clear ( GVariantBuilder* builder) -->
+  <!-- void g_variant_builder_close( GVariantBuilder* builder) -->
+  <function name="g_variant_builder_clear,g_variant_builder_close">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+    </arg>
   </function>
+  <!-- void g_variant_builder_init ( GVariantBuilder* builder, const GVariantType* type) -->
   <function name="g_variant_builder_init">
-    <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
+  <!-- void g_variant_builder_open ( GVariantBuilder* builder, const GVariantType* type) -->
   <function name="g_variant_builder_open">
-    <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
+  <!-- GVariant* g_variant_builder_end ( GVariantBuilder* builder) -->
+  <function name="g_variant_builder_end">
+    <noreturn>false</noreturn>
+    <returnValue type="GVariant*"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+    </arg>
   </function>
   <function name="g_variant_iter_init">
     <leak-ignore/>
@@ -6800,6 +8886,174 @@
     <leak-ignore/>
     <noreturn>false</noreturn>
   </function>
+  <!-- GVariant* g_variant_new(const gchar *format_string, ...); -->
+  <function name="g_variant_new">
+    <noreturn>false</noreturn>
+    <returnValue type="GVariant*"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <not-bool/>
+      <strz/>
+    </arg>
+    <arg nr="variadic" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- GVariant* g_variant_new_parsed (const gchar *format, ...) -->
+  <function name="g_variant_new_parsed">
+    <noreturn>false</noreturn>
+    <returnValue type="GVariant*"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <not-bool/>
+      <strz/>
+    </arg>
+    <arg nr="variadic" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- GVariant* g_variant_new_string (const gchar *string) -->
+  <function name="g_variant_new_string">
+    <noreturn>false</noreturn>
+    <returnValue type="GVariant*"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- GVariant* g_variant_new_take_string(gchar* string) -->
+  <function name="g_variant_new_take_string">
+    <noreturn>false</noreturn>
+    <returnValue type="GVariant*"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- GVariant* g_variant_new_printf (const gchar *format_string, ...) -->
+  <function name="g_variant_new_printf">
+    <noreturn>false</noreturn>
+    <returnValue type="GVariant*"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+      <formatstr/>
+    </arg>
+  </function>
+  <!-- GVariant* g_variant_new_byte (guint8 value) -->
+  <function name="g_variant_new_byte">
+    <noreturn>false</noreturn>
+    <returnValue type="GVariant*"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- GVariant* g_variant_new_int16 (gint16 value) -->
+  <function name="g_variant_new_int16">
+    <noreturn>false</noreturn>
+    <returnValue type="GVariant*"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- GVariant* g_variant_new_int32 (gint32 value) -->
+  <function name="g_variant_new_int32">
+    <noreturn>false</noreturn>
+    <returnValue type="GVariant*"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- GVariant* g_variant_new_int64 (gint64 value) -->
+  <function name="g_variant_new_int64">
+    <noreturn>false</noreturn>
+    <returnValue type="GVariant*"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- GVariant* g_variant_new_uint16 (guint16 value) -->
+  <function name="g_variant_new_uint16">
+    <noreturn>false</noreturn>
+    <returnValue type="GVariant*"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- GVariant* g_variant_new_uint32 (guint32 value) -->
+  <function name="g_variant_new_uint32">
+    <noreturn>false</noreturn>
+    <returnValue type="GVariant*"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- GVariant* g_variant_new_uint64 (guint64 value) -->
+  <function name="g_variant_new_uint64">
+    <noreturn>false</noreturn>
+    <returnValue type="GVariant*"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- GVariant* g_variant_new_double (gdouble value) -->
+  <function name="g_variant_new_double">
+    <noreturn>false</noreturn>
+    <returnValue type="GVariant*"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- GVariant* g_variant_new_boolean (gboolean value) -->
+  <function name="g_variant_new_boolean">
+    <noreturn>false</noreturn>
+    <returnValue type="GVariant*"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- GVariant* g_variant_parse(const GVariantType* type,const gchar* text,const gchar* limit,const gchar** endptr,GError** error) -->
+  <function name="g_variant_parse">
+    <noreturn>false</noreturn>
+    <returnValue type="GVariant*"/>
+    <use-retval/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="out"/>
+    <arg nr="5" direction="out"/>
+  </function>
   <!-- void g_message (const gchar *format, ...) -->
   <!-- void g_critical (const gchar *format, ...) -->
   <!-- void g_warning (const gchar *format, ...) -->
@@ -19911,9 +22165,8 @@
     <returnValue type="gchar *"/>
     <use-retval/>
     <arg nr="1">
-      <not-null/>
       <not-uninit/>
-      <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- gchar * g_strdup_printf (const gchar *format, ...); -->
@@ -19925,6 +22178,17 @@
       <formatstr/>
       <not-null/>
       <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- gchar ** g_strdupv (gchar** str_array);-->
+  <function name="g_strdupv">
+    <noreturn>false</noreturn>
+    <returnValue type="gchar **"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- gulong g_signal_connect_data (gpointer instance, const gchar *detailed_signal,
@@ -19944,7 +22208,9 @@
     <arg nr="3">
       <not-uninit/>
     </arg>
-    <arg nr="4"/>
+    <arg nr="4">
+      <not-uninit/>
+    </arg>
     <arg nr="5"/>
     <arg nr="6">
       <not-uninit/>
@@ -19964,6 +22230,7 @@
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <valid>0:</valid>
     </arg>
     <arg nr="3">
       <not-uninit/>
@@ -20024,6 +22291,7 @@
     </arg>
     <arg nr="9" direction="in">
       <not-uninit/>
+      <valid>0:</valid>
     </arg>
     <arg nr="variadic"/>
   </function>
@@ -20054,4 +22322,765 @@
   <podtype name="gintptr" sign="s"/>
   <podtype name="guintptr" sign="u"/>
   <podtype name="GType" sign="u"/>
+  <podtype name="GTimeSpan" sign="s" size="8"/>
+  <!-- gdk/gdkdevicetool.h -->
+  <define name="GDK_IS_DEVICE_TOOL(o)" value="(G_TYPE_CHECK_INSTANCE_TYPE((o),GDK_TYPE_DEVICE_TOOL))"/>
+  <define name="GDK_DEVICE_TOOL(o)" value="(G_TYPE_CHECK_INSTANCE_CAST((o),GDK_TYPE_DEVICE_TOOL,GdkDeviceTool))"/>
+  <define name="GDK_TYPE_DEVICE_TOOL" value="(gdk_device_tool_get_type())"/>
+  <define name="GDK_DEVICE_TOOL_TYPE_UNKNOWN" value="0"/>
+  <define name="GDK_DEVICE_TOOL_TYPE_PEN" value="1"/>
+  <define name="GDK_DEVICE_TOOL_TYPE_ERASER" value="2"/>
+  <define name="GDK_DEVICE_TOOL_TYPE_BRUSH" value="3"/>
+  <define name="GDK_DEVICE_TOOL_TYPE_PENCIL" value="4"/>
+  <define name="GDK_DEVICE_TOOL_TYPE_AIRBRUSH" value="5"/>
+  <define name="GDK_DEVICE_TOOL_TYPE_MOUSE" value="6"/>
+  <define name="GDK_DEVICE_TOOL_TYPE_LENS" value="7"/>
+  <!-- gdk/gdkcairocontext.h -->
+  <define name="GDK_CAIRO_ERROR" value="(gdk_cairo_error_quark())"/>
+  <define name="GDK_IS_CAIRO_CONTEXT(obj)" value="(G_TYPE_CHECK_INSTANCE_TYPE((obj),GDK_TYPE_CAIRO_CONTEXT))"/>
+  <define name="GDK_CAIRO_CONTEXT(obj)" value="(G_TYPE_CHECK_INSTANCE_CAST((obj),GDK_TYPE_CAIRO_CONTEXT,GdkCairoContext))"/>
+  <define name="GDK_TYPE_CAIRO_CONTEXT" value="(gdk_cairo_context_get_type())"/>
+  <!-- gtk/gtkaboutdialog.h -->
+  <define name="GTK_LICENSE_UNKNOWN" value="0"/>
+  <define name="GTK_LICENSE_CUSTOM" value="1"/>
+  <define name="GTK_LICENSE_GPL_2_0" value="2"/>
+  <define name="GTK_LICENSE_GPL_3_0" value="3"/>
+  <define name="GTK_LICENSE_LGPL_2_1" value="4"/>
+  <define name="GTK_LICENSE_LGPL_3_0" value="5"/>
+  <define name="GTK_LICENSE_BSD" value="6"/>
+  <define name="GTK_LICENSE_MIT_X11" value="7"/>
+  <define name="GTK_LICENSE_ARTISTIC" value="8"/>
+  <define name="GTK_LICENSE_GPL_2_0_ONLY" value="9"/>
+  <define name="GTK_LICENSE_GPL_3_0_ONLY" value="10"/>
+  <define name="GTK_LICENSE_LGPL_2_1_ONLY" value="11"/>
+  <define name="GTK_LICENSE_LGPL_3_0_ONLY" value="12"/>
+  <define name="GTK_LICENSE_AGPL_3_0" value="13"/>
+  <define name="GTK_LICENSE_AGPL_3_0_ONLY" value="14"/>
+  <define name="GTK_LICENSE_BSD_3" value="15"/>
+  <define name="GTK_LICENSE_APACHE_2_0" value="16"/>
+  <define name="GTK_LICENSE_MPL_2_0" value="17"/>
+  <define name="GTK_LICENSE_0BSD" value="18"/>
+  <!-- gtk/gtkaccessible.h -->
+  <define name="GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSABLE" value="0"/>
+  <define name="GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSED" value="1"/>
+  <define name="GTK_ACCESSIBLE_PLATFORM_STATE_ACTIVE" value="2"/>
+  <!-- gtk/gtkaccessibleprivate.h -->
+  <define name="GTK_ACCESSIBLE_PLATFORM_CHANGE_FOCUSABLE" value="1&lt;&lt;GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSABLE"/>
+  <define name="GTK_ACCESSIBLE_PLATFORM_CHANGE_FOCUSED" value="1&lt;&lt;GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSED"/>
+  <define name="GTK_ACCESSIBLE_PLATFORM_CHANGE_ACTIVE" value="1&lt;&lt;GTK_ACCESSIBLE_PLATFORM_STATE_ACTIVE"/>
+  <define name="GTK_ACCESSIBLE_CHILD_STATE_ADDED" value="0"/>
+  <define name="GTK_ACCESSIBLE_CHILD_STATE_REMOVED" value="1"/>
+  <define name="GTK_ACCESSIBLE_CHILD_CHANGE_ADDED" value="1&lt;&lt;GTK_ACCESSIBLE_CHILD_STATE_ADDED"/>
+  <define name="GTK_ACCESSIBLE_CHILD_CHANGE_REMOVED" value="1&lt;&lt;GTK_ACCESSIBLE_CHILD_STATE_REMOVED"/>
+  <define name="GTK_ACCESSIBLE_NAME_ALLOWED" value="0"/>
+  <define name="GTK_ACCESSIBLE_NAME_PROHIBITED" value="1"/>
+  <define name="GTK_ACCESSIBLE_NAME_REQUIRED" value="2"/>
+  <define name="GTK_ACCESSIBLE_NAME_RECOMMENDED" value="3"/>
+  <define name="GTK_ACCESSIBLE_NAME_NOT_RECOMMENDED" value="4"/>
+  <!-- gtk/gtkaccessibletext.h -->
+  <define name="GTK_ACCESSIBLE_TEXT_GRANULARITY_CHARACTER" value="0"/>
+  <define name="GTK_ACCESSIBLE_TEXT_GRANULARITY_WORD" value="1"/>
+  <define name="GTK_ACCESSIBLE_TEXT_GRANULARITY_SENTENCE" value="2"/>
+  <define name="GTK_ACCESSIBLE_TEXT_GRANULARITY_LINE" value="3"/>
+  <define name="GTK_ACCESSIBLE_TEXT_GRANULARITY_PARAGRAPH" value="4"/>
+  <define name="GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_INSERT" value="0"/>
+  <define name="GTK_ACCESSIBLE_TEXT_CONTENT_CHANGE_REMOVE" value="1"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_UNDERLINE_ERROR" value="&quot;error&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_UNDERLINE_DOUBLE" value="&quot;double&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_UNDERLINE_SINGLE" value="&quot;single&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_UNDERLINE_NONE" value="&quot;none&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_STYLE_NORMAL" value="&quot;normal&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_STRETCH" value="&quot;stretch&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_STRIKETHROUGH" value="&quot;strikethrough&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_STYLE" value="&quot;style&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_OVERLINE_NONE" value="&quot;none&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_STRETCH_CONDENSED" value="&quot;condensed&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_UNDERLINE" value="&quot;underline&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_EXPANDED" value="&quot;extra_expanded&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_WEIGHT" value="&quot;weight&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_BACKGROUND" value="&quot;bg-color&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_FAMILY" value="&quot;family-name&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_OVERLINE" value="&quot;overline&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_SIZE" value="&quot;size&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_VARIANT" value="&quot;variant&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_FOREGROUND" value="&quot;fg-color&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_STYLE_OBLIQUE" value="&quot;oblique&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_STRETCH_EXPANDED" value="&quot;expanded&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_VARIANT_TITLE_CAPS" value="&quot;title-caps&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_STYLE_ITALIC" value="&quot;italic&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_VARIANT_SMALL_CAPS" value="&quot;small-caps&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_PETITE_CAPS" value="&quot;all-petite-caps&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_SMALL_CAPS" value="&quot;all-small-caps&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_STRETCH_NORMAL" value="&quot;normal&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_VARIANT_PETITE_CAPS" value="&quot;petite-caps&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_OVERLINE_SINGLE" value="&quot;single&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_EXPANDED" value="&quot;semi_expanded&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_VARIANT_UNICASE" value="&quot;unicase&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_CONDENSED" value="&quot;ultra_condensed&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_CONDENSED" value="&quot;extra_condensed&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_EXPANDED" value="&quot;ultra_expanded&quot;"/>
+  <define name="GTK_ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_CONDENSED" value="&quot;semi_condensed&quot;"/>
+  <!-- gtk/gtkaccessiblevalueprivate.h -->
+  <define name="GTK_ACCESSIBLE_VALUE_TYPE_UNDEFINED" value="0"/>
+  <define name="GTK_ACCESSIBLE_VALUE_TYPE_BOOLEAN" value="1"/>
+  <define name="GTK_ACCESSIBLE_VALUE_TYPE_TRISTATE" value="2"/>
+  <define name="GTK_ACCESSIBLE_VALUE_TYPE_TOKEN" value="3"/>
+  <define name="GTK_ACCESSIBLE_VALUE_TYPE_INTEGER" value="4"/>
+  <define name="GTK_ACCESSIBLE_VALUE_TYPE_NUMBER" value="5"/>
+  <define name="GTK_ACCESSIBLE_VALUE_TYPE_STRING" value="6"/>
+  <define name="GTK_ACCESSIBLE_VALUE_TYPE_REFERENCE" value="7"/>
+  <define name="GTK_ACCESSIBLE_VALUE_TYPE_REFERENCE_LIST" value="8"/>
+  <!-- gtk/gtkactionbar.h -->
+  <define name="GTK_IS_ACTION_BAR(obj)" value="(G_TYPE_CHECK_INSTANCE_TYPE((obj),GTK_TYPE_ACTION_BAR))"/>
+  <define name="GTK_ACTION_BAR(obj)" value="(G_TYPE_CHECK_INSTANCE_CAST((obj),GTK_TYPE_ACTION_BAR,GtkActionBar))"/>
+  <define name="GTK_TYPE_ACTION_BAR" value="(gtk_action_bar_get_type())"/>
+  <!-- gtk/gtkadjustment.h -->
+  <define name="GTK_IS_ADJUSTMENT_CLASS(klass)" value="(G_TYPE_CHECK_CLASS_TYPE((klass),GTK_TYPE_ADJUSTMENT))"/>
+  <define name="GTK_ADJUSTMENT_GET_CLASS(obj)" value="(G_TYPE_INSTANCE_GET_CLASS((obj),GTK_TYPE_ADJUSTMENT,GtkAdjustmentClass))"/>
+  <define name="GTK_IS_ADJUSTMENT(obj)" value="(G_TYPE_CHECK_INSTANCE_TYPE((obj),GTK_TYPE_ADJUSTMENT))"/>
+  <define name="GTK_ADJUSTMENT_CLASS(klass)" value="(G_TYPE_CHECK_CLASS_CAST((klass),GTK_TYPE_ADJUSTMENT,GtkAdjustmentClass))"/>
+  <define name="GTK_ADJUSTMENT(obj)" value="(G_TYPE_CHECK_INSTANCE_CAST((obj),GTK_TYPE_ADJUSTMENT,GtkAdjustment))"/>
+  <define name="GTK_TYPE_ADJUSTMENT" value="(gtk_adjustment_get_type())"/>
+  <!-- gtk/gtkapplication.h -->
+  <define name="GTK_APPLICATION_GET_CLASS(obj)" value="(G_TYPE_INSTANCE_GET_CLASS((obj),GTK_TYPE_APPLICATION,GtkApplicationClass))"/>
+  <define name="GTK_IS_APPLICATION_CLASS(klass)" value="(G_TYPE_CHECK_CLASS_TYPE((klass),GTK_TYPE_APPLICATION))"/>
+  <define name="GTK_IS_APPLICATION(obj)" value="(G_TYPE_CHECK_INSTANCE_TYPE((obj),GTK_TYPE_APPLICATION))"/>
+  <define name="GTK_APPLICATION_CLASS(klass)" value="(G_TYPE_CHECK_CLASS_CAST((klass),GTK_TYPE_APPLICATION,GtkApplicationClass))"/>
+  <define name="GTK_APPLICATION(obj)" value="(G_TYPE_CHECK_INSTANCE_CAST((obj),GTK_TYPE_APPLICATION,GtkApplication))"/>
+  <define name="GTK_TYPE_APPLICATION" value="(gtk_application_get_type())"/>
+  <define name="GTK_APPLICATION_INHIBIT_LOGOUT" value="(1&lt;&lt;0)"/>
+  <define name="GTK_APPLICATION_INHIBIT_SWITCH" value="(1&lt;&lt;1)"/>
+  <define name="GTK_APPLICATION_INHIBIT_SUSPEND" value="(1&lt;&lt;2)"/>
+  <define name="GTK_APPLICATION_INHIBIT_IDLE" value="(1&lt;&lt;3)"/>
+  <!-- gtk/gtkbuilder.h -->
+  <define name="GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION" value="0"/>
+  <define name="GTK_BUILDER_ERROR_UNHANDLED_TAG" value="1"/>
+  <define name="GTK_BUILDER_ERROR_MISSING_ATTRIBUTE" value="2"/>
+  <define name="GTK_BUILDER_ERROR_INVALID_ATTRIBUTE" value="3"/>
+  <define name="GTK_BUILDER_ERROR_INVALID_TAG" value="4"/>
+  <define name="GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE" value="5"/>
+  <define name="GTK_BUILDER_ERROR_INVALID_VALUE" value="6"/>
+  <define name="GTK_BUILDER_ERROR_VERSION_MISMATCH" value="7"/>
+  <define name="GTK_BUILDER_ERROR_DUPLICATE_ID" value="8"/>
+  <define name="GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED" value="9"/>
+  <define name="GTK_BUILDER_ERROR_TEMPLATE_MISMATCH" value="10"/>
+  <define name="GTK_BUILDER_ERROR_INVALID_PROPERTY" value="11"/>
+  <define name="GTK_BUILDER_ERROR_INVALID_SIGNAL" value="12"/>
+  <define name="GTK_BUILDER_ERROR_INVALID_ID" value="13"/>
+  <define name="GTK_BUILDER_ERROR_INVALID_FUNCTION" value="14"/>
+  <!-- gtk/gtkbuilderscope.h -->
+  <define name="GTK_BUILDER_CLOSURE_SWAPPED" value="(1&lt;&lt;0)"/>
+  <!-- gtk/gtkdebug.h -->
+  <define name="GTK_DEBUG_TEXT" value="1&lt;&lt;0"/>
+  <define name="GTK_DEBUG_TREE" value="1&lt;&lt;1"/>
+  <define name="GTK_DEBUG_KEYBINDINGS" value="1&lt;&lt;2"/>
+  <define name="GTK_DEBUG_MODULES" value="1&lt;&lt;3"/>
+  <define name="GTK_DEBUG_GEOMETRY" value="1&lt;&lt;4"/>
+  <define name="GTK_DEBUG_ICONTHEME" value="1&lt;&lt;5"/>
+  <define name="GTK_DEBUG_PRINTING" value="1&lt;&lt;6"/>
+  <define name="GTK_DEBUG_BUILDER" value="1&lt;&lt;7"/>
+  <define name="GTK_DEBUG_SIZE_REQUEST" value="1&lt;&lt;8"/>
+  <define name="GTK_DEBUG_NO_CSS_CACHE" value="1&lt;&lt;9"/>
+  <define name="GTK_DEBUG_INTERACTIVE" value="1&lt;&lt;10"/>
+  <define name="GTK_DEBUG_ACTIONS" value="1&lt;&lt;12"/>
+  <define name="GTK_DEBUG_LAYOUT" value="1&lt;&lt;13"/>
+  <define name="GTK_DEBUG_SNAPSHOT" value="1&lt;&lt;14"/>
+  <define name="GTK_DEBUG_CONSTRAINTS" value="1&lt;&lt;15"/>
+  <define name="GTK_DEBUG_BUILDER_OBJECTS" value="1&lt;&lt;16"/>
+  <define name="GTK_DEBUG_A11Y" value="1&lt;&lt;17"/>
+  <define name="GTK_DEBUG_ICONFALLBACK" value="1&lt;&lt;18"/>
+  <define name="GTK_DEBUG_INVERT_TEXT_DIR" value="1&lt;&lt;19"/>
+  <!-- gtk/gtkdialogerror.h -->
+  <define name="GTK_DIALOG_ERROR_FAILED" value="0"/>
+  <define name="GTK_DIALOG_ERROR_CANCELLED" value="1"/>
+  <define name="GTK_DIALOG_ERROR_DISMISSED" value="2"/>
+  <!-- gtk/gtkeditable.h -->
+  <define name="GTK_EDITABLE_PROP_TEXT" value="0"/>
+  <define name="GTK_EDITABLE_PROP_CURSOR_POSITION" value="1"/>
+  <define name="GTK_EDITABLE_PROP_SELECTION_BOUND" value="2"/>
+  <define name="GTK_EDITABLE_PROP_EDITABLE" value="3"/>
+  <define name="GTK_EDITABLE_PROP_WIDTH_CHARS" value="4"/>
+  <define name="GTK_EDITABLE_PROP_MAX_WIDTH_CHARS" value="5"/>
+  <define name="GTK_EDITABLE_PROP_XALIGN" value="6"/>
+  <define name="GTK_EDITABLE_PROP_ENABLE_UNDO" value="7"/>
+  <define name="GTK_EDITABLE_NUM_PROPERTIES" value="8"/>
+  <!-- gtk/gtkentry.h -->
+  <define name="GTK_ENTRY_ICON_PRIMARY" value="0"/>
+  <define name="GTK_ENTRY_ICON_SECONDARY" value="1"/>
+  <!-- gtk/gtkenums.h -->
+  <define name="GTK_ARROW_UP" value="0"/>
+  <define name="GTK_ARROW_DOWN" value="1"/>
+  <define name="GTK_ARROW_LEFT" value="2"/>
+  <define name="GTK_ARROW_RIGHT" value="3"/>
+  <define name="GTK_ARROW_NONE" value="4"/>
+  <define name="GTK_BASELINE_POSITION_TOP" value="0"/>
+  <define name="GTK_BASELINE_POSITION_CENTER" value="1"/>
+  <define name="GTK_BASELINE_POSITION_BOTTOM" value="2"/>
+  <define name="GTK_CONTENT_FIT_FILL" value="0"/>
+  <define name="GTK_CONTENT_FIT_CONTAIN" value="1"/>
+  <define name="GTK_CONTENT_FIT_COVER" value="2"/>
+  <define name="GTK_CONTENT_FIT_SCALE_DOWN" value="3"/>
+  <define name="GTK_DELETE_CHARS" value="0"/>
+  <define name="GTK_DELETE_WORD_ENDS" value="1"/>
+  <define name="GTK_DELETE_WORDS" value="2"/>
+  <define name="GTK_DELETE_DISPLAY_LINES" value="3"/>
+  <define name="GTK_DELETE_DISPLAY_LINE_ENDS" value="4"/>
+  <define name="GTK_DELETE_PARAGRAPH_ENDS" value="5"/>
+  <define name="GTK_DELETE_PARAGRAPHS" value="6"/>
+  <define name="GTK_DELETE_WHITESPACE" value="7"/>
+  <define name="GTK_DIR_TAB_FORWARD" value="0"/>
+  <define name="GTK_DIR_TAB_BACKWARD" value="1"/>
+  <define name="GTK_DIR_UP" value="2"/>
+  <define name="GTK_DIR_DOWN" value="3"/>
+  <define name="GTK_DIR_LEFT" value="4"/>
+  <define name="GTK_DIR_RIGHT" value="5"/>
+  <define name="GTK_ICON_SIZE_INHERIT" value="0"/>
+  <define name="GTK_ICON_SIZE_NORMAL" value="1"/>
+  <define name="GTK_ICON_SIZE_LARGE" value="2"/>
+  <define name="GTK_SENSITIVITY_AUTO" value="0"/>
+  <define name="GTK_SENSITIVITY_ON" value="1"/>
+  <define name="GTK_SENSITIVITY_OFF" value="2"/>
+  <define name="GTK_TEXT_DIR_NONE" value="0"/>
+  <define name="GTK_TEXT_DIR_LTR" value="1"/>
+  <define name="GTK_TEXT_DIR_RTL" value="2"/>
+  <define name="GTK_JUSTIFY_LEFT" value="0"/>
+  <define name="GTK_JUSTIFY_RIGHT" value="1"/>
+  <define name="GTK_JUSTIFY_CENTER" value="2"/>
+  <define name="GTK_JUSTIFY_FILL" value="3"/>
+  <define name="GTK_LIST_TAB_ALL" value="0"/>
+  <define name="GTK_LIST_TAB_ITEM" value="1"/>
+  <define name="GTK_LIST_TAB_CELL" value="2"/>
+  <define name="GTK_LIST_SCROLL_NONE" value="0"/>
+  <define name="GTK_LIST_SCROLL_FOCUS" value="1&lt;&lt;0"/>
+  <define name="GTK_LIST_SCROLL_SELECT" value="1&lt;&lt;1"/>
+  <define name="GTK_MESSAGE_INFO" value="0"/>
+  <define name="GTK_MESSAGE_WARNING" value="1"/>
+  <define name="GTK_MESSAGE_QUESTION" value="2"/>
+  <define name="GTK_MESSAGE_ERROR" value="3"/>
+  <define name="GTK_MESSAGE_OTHER" value="4"/>
+  <define name="GTK_MOVEMENT_LOGICAL_POSITIONS" value="0"/>
+  <define name="GTK_MOVEMENT_VISUAL_POSITIONS" value="1"/>
+  <define name="GTK_MOVEMENT_WORDS" value="2"/>
+  <define name="GTK_MOVEMENT_DISPLAY_LINES" value="3"/>
+  <define name="GTK_MOVEMENT_DISPLAY_LINE_ENDS" value="4"/>
+  <define name="GTK_MOVEMENT_PARAGRAPHS" value="5"/>
+  <define name="GTK_MOVEMENT_PARAGRAPH_ENDS" value="6"/>
+  <define name="GTK_MOVEMENT_PAGES" value="7"/>
+  <define name="GTK_MOVEMENT_BUFFER_ENDS" value="8"/>
+  <define name="GTK_MOVEMENT_HORIZONTAL_PAGES" value="9"/>
+  <define name="GTK_NATURAL_WRAP_INHERIT" value="0"/>
+  <define name="GTK_NATURAL_WRAP_NONE" value="1"/>
+  <define name="GTK_NATURAL_WRAP_WORD" value="2"/>
+  <define name="GTK_SCROLL_STEPS" value="0"/>
+  <define name="GTK_SCROLL_PAGES" value="1"/>
+  <define name="GTK_SCROLL_ENDS" value="2"/>
+  <define name="GTK_SCROLL_HORIZONTAL_STEPS" value="3"/>
+  <define name="GTK_SCROLL_HORIZONTAL_PAGES" value="4"/>
+  <define name="GTK_SCROLL_HORIZONTAL_ENDS" value="5"/>
+  <define name="GTK_ORIENTATION_HORIZONTAL" value="0"/>
+  <define name="GTK_ORIENTATION_VERTICAL" value="1"/>
+  <define name="GTK_OVERFLOW_VISIBLE" value="0"/>
+  <define name="GTK_OVERFLOW_HIDDEN" value="1"/>
+  <define name="GTK_PACK_START" value="0"/>
+  <define name="GTK_PACK_END" value="1"/>
+  <define name="GTK_POS_LEFT" value="0"/>
+  <define name="GTK_POS_RIGHT" value="1"/>
+  <define name="GTK_POS_TOP" value="2"/>
+  <define name="GTK_POS_BOTTOM" value="3"/>
+  <define name="GTK_SCROLL_NONE" value="0"/>
+  <define name="GTK_SCROLL_JUMP" value="1"/>
+  <define name="GTK_SCROLL_STEP_BACKWARD" value="2"/>
+  <define name="GTK_SCROLL_STEP_FORWARD" value="3"/>
+  <define name="GTK_SCROLL_PAGE_BACKWARD" value="4"/>
+  <define name="GTK_SCROLL_PAGE_FORWARD" value="5"/>
+  <define name="GTK_SCROLL_STEP_UP" value="6"/>
+  <define name="GTK_SCROLL_STEP_DOWN" value="7"/>
+  <define name="GTK_SCROLL_PAGE_UP" value="8"/>
+  <define name="GTK_SCROLL_PAGE_DOWN" value="9"/>
+  <define name="GTK_SCROLL_STEP_LEFT" value="10"/>
+  <define name="GTK_SCROLL_STEP_RIGHT" value="11"/>
+  <define name="GTK_SCROLL_PAGE_LEFT" value="12"/>
+  <define name="GTK_SCROLL_PAGE_RIGHT" value="13"/>
+  <define name="GTK_SCROLL_START" value="14"/>
+  <define name="GTK_SCROLL_END" value="15"/>
+  <define name="GTK_SELECTION_NONE" value="0"/>
+  <define name="GTK_SELECTION_SINGLE" value="1"/>
+  <define name="GTK_SELECTION_BROWSE" value="2"/>
+  <define name="GTK_SELECTION_MULTIPLE" value="3"/>
+  <define name="GTK_WRAP_NONE" value="0"/>
+  <define name="GTK_WRAP_CHAR" value="1"/>
+  <define name="GTK_WRAP_WORD" value="2"/>
+  <define name="GTK_WRAP_WORD_CHAR" value="3"/>
+  <define name="GTK_SORT_ASCENDING" value="0"/>
+  <define name="GTK_SORT_DESCENDING" value="1"/>
+  <define name="GTK_PRINT_PAGES_ALL" value="0"/>
+  <define name="GTK_PRINT_PAGES_CURRENT" value="1"/>
+  <define name="GTK_PRINT_PAGES_RANGES" value="2"/>
+  <define name="GTK_PRINT_PAGES_SELECTION" value="3"/>
+  <define name="GTK_PAGE_SET_ALL" value="0"/>
+  <define name="GTK_PAGE_SET_EVEN" value="1"/>
+  <define name="GTK_PAGE_SET_ODD" value="2"/>
+  <define name="GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM" value="0"/>
+  <define name="GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP" value="1"/>
+  <define name="GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM" value="2"/>
+  <define name="GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP" value="3"/>
+  <define name="GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT" value="4"/>
+  <define name="GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT" value="5"/>
+  <define name="GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT" value="6"/>
+  <define name="GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT" value="7"/>
+  <define name="GTK_ORDERING_SMALLER" value="-1"/>
+  <define name="GTK_ORDERING_EQUAL" value="0"/>
+  <define name="GTK_ORDERING_LARGER" value="1"/>
+  <define name="GTK_PAGE_ORIENTATION_PORTRAIT" value="0"/>
+  <define name="GTK_PAGE_ORIENTATION_LANDSCAPE" value="1"/>
+  <define name="GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT" value="2"/>
+  <define name="GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE" value="3"/>
+  <define name="GTK_PRINT_QUALITY_LOW" value="0"/>
+  <define name="GTK_PRINT_QUALITY_NORMAL" value="1"/>
+  <define name="GTK_PRINT_QUALITY_HIGH" value="2"/>
+  <define name="GTK_PRINT_QUALITY_DRAFT" value="3"/>
+  <define name="GTK_PRINT_DUPLEX_SIMPLEX" value="0"/>
+  <define name="GTK_PRINT_DUPLEX_HORIZONTAL" value="1"/>
+  <define name="GTK_PRINT_DUPLEX_VERTICAL" value="2"/>
+  <define name="GTK_UNIT_NONE" value="0"/>
+  <define name="GTK_UNIT_POINTS" value="1"/>
+  <define name="GTK_UNIT_INCH" value="2"/>
+  <define name="GTK_UNIT_MM" value="3"/>
+  <define name="GTK_TREE_VIEW_GRID_LINES_NONE" value="0"/>
+  <define name="GTK_TREE_VIEW_GRID_LINES_HORIZONTAL" value="1"/>
+  <define name="GTK_TREE_VIEW_GRID_LINES_VERTICAL" value="2"/>
+  <define name="GTK_TREE_VIEW_GRID_LINES_BOTH" value="3"/>
+  <define name="GTK_SIZE_GROUP_NONE" value="0"/>
+  <define name="GTK_SIZE_GROUP_HORIZONTAL" value="1"/>
+  <define name="GTK_SIZE_GROUP_VERTICAL" value="2"/>
+  <define name="GTK_SIZE_GROUP_BOTH" value="3"/>
+  <define name="GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH" value="0"/>
+  <define name="GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT" value="1"/>
+  <define name="GTK_SIZE_REQUEST_CONSTANT_SIZE" value="2"/>
+  <define name="GTK_SCROLL_MINIMUM" value="0"/>
+  <define name="GTK_SCROLL_NATURAL" value="1"/>
+  <define name="GTK_STATE_FLAG_NORMAL" value="0"/>
+  <define name="GTK_STATE_FLAG_ACTIVE" value="1&lt;&lt;0"/>
+  <define name="GTK_STATE_FLAG_PRELIGHT" value="1&lt;&lt;1"/>
+  <define name="GTK_STATE_FLAG_SELECTED" value="1&lt;&lt;2"/>
+  <define name="GTK_STATE_FLAG_INSENSITIVE" value="1&lt;&lt;3"/>
+  <define name="GTK_STATE_FLAG_INCONSISTENT" value="1&lt;&lt;4"/>
+  <define name="GTK_STATE_FLAG_FOCUSED" value="1&lt;&lt;5"/>
+  <define name="GTK_STATE_FLAG_BACKDROP" value="1&lt;&lt;6"/>
+  <define name="GTK_STATE_FLAG_DIR_LTR" value="1&lt;&lt;7"/>
+  <define name="GTK_STATE_FLAG_DIR_RTL" value="1&lt;&lt;8"/>
+  <define name="GTK_STATE_FLAG_LINK" value="1&lt;&lt;9"/>
+  <define name="GTK_STATE_FLAG_VISITED" value="1&lt;&lt;10"/>
+  <define name="GTK_STATE_FLAG_CHECKED" value="1&lt;&lt;11"/>
+  <define name="GTK_STATE_FLAG_DROP_ACTIVE" value="1&lt;&lt;12"/>
+  <define name="GTK_STATE_FLAG_FOCUS_VISIBLE" value="1&lt;&lt;13"/>
+  <define name="GTK_STATE_FLAG_FOCUS_WITHIN" value="1&lt;&lt;14"/>
+  <define name="GTK_BORDER_STYLE_NONE" value="0"/>
+  <define name="GTK_BORDER_STYLE_HIDDEN" value="1"/>
+  <define name="GTK_BORDER_STYLE_SOLID" value="2"/>
+  <define name="GTK_BORDER_STYLE_INSET" value="3"/>
+  <define name="GTK_BORDER_STYLE_OUTSET" value="4"/>
+  <define name="GTK_BORDER_STYLE_DOTTED" value="5"/>
+  <define name="GTK_BORDER_STYLE_DASHED" value="6"/>
+  <define name="GTK_BORDER_STYLE_DOUBLE" value="7"/>
+  <define name="GTK_BORDER_STYLE_GROOVE" value="8"/>
+  <define name="GTK_BORDER_STYLE_RIDGE" value="9"/>
+  <define name="GTK_LEVEL_BAR_MODE_CONTINUOUS" value="0"/>
+  <define name="GTK_LEVEL_BAR_MODE_DISCRETE" value="1"/>
+  <define name="GTK_INPUT_PURPOSE_FREE_FORM" value="0"/>
+  <define name="GTK_INPUT_PURPOSE_ALPHA" value="1"/>
+  <define name="GTK_INPUT_PURPOSE_DIGITS" value="2"/>
+  <define name="GTK_INPUT_PURPOSE_NUMBER" value="3"/>
+  <define name="GTK_INPUT_PURPOSE_PHONE" value="4"/>
+  <define name="GTK_INPUT_PURPOSE_URL" value="5"/>
+  <define name="GTK_INPUT_PURPOSE_EMAIL" value="6"/>
+  <define name="GTK_INPUT_PURPOSE_NAME" value="7"/>
+  <define name="GTK_INPUT_PURPOSE_PASSWORD" value="8"/>
+  <define name="GTK_INPUT_PURPOSE_PIN" value="9"/>
+  <define name="GTK_INPUT_PURPOSE_TERMINAL" value="10"/>
+  <define name="GTK_INPUT_HINT_NONE" value="0"/>
+  <define name="GTK_INPUT_HINT_SPELLCHECK" value="1&lt;&lt;0"/>
+  <define name="GTK_INPUT_HINT_NO_SPELLCHECK" value="1&lt;&lt;1"/>
+  <define name="GTK_INPUT_HINT_WORD_COMPLETION" value="1&lt;&lt;2"/>
+  <define name="GTK_INPUT_HINT_LOWERCASE" value="1&lt;&lt;3"/>
+  <define name="GTK_INPUT_HINT_UPPERCASE_CHARS" value="1&lt;&lt;4"/>
+  <define name="GTK_INPUT_HINT_UPPERCASE_WORDS" value="1&lt;&lt;5"/>
+  <define name="GTK_INPUT_HINT_UPPERCASE_SENTENCES" value="1&lt;&lt;6"/>
+  <define name="GTK_INPUT_HINT_INHIBIT_OSK" value="1&lt;&lt;7"/>
+  <define name="GTK_INPUT_HINT_VERTICAL_WRITING" value="1&lt;&lt;8"/>
+  <define name="GTK_INPUT_HINT_EMOJI" value="1&lt;&lt;9"/>
+  <define name="GTK_INPUT_HINT_NO_EMOJI" value="1&lt;&lt;10"/>
+  <define name="GTK_INPUT_HINT_PRIVATE" value="1&lt;&lt;11"/>
+  <define name="GTK_PHASE_NONE" value="0"/>
+  <define name="GTK_PHASE_CAPTURE" value="1"/>
+  <define name="GTK_PHASE_BUBBLE" value="2"/>
+  <define name="GTK_PHASE_TARGET" value="3"/>
+  <define name="GTK_LIMIT_NONE" value="0"/>
+  <define name="GTK_LIMIT_SAME_NATIVE" value="1"/>
+  <define name="GTK_EVENT_SEQUENCE_NONE" value="0"/>
+  <define name="GTK_EVENT_SEQUENCE_CLAIMED" value="1"/>
+  <define name="GTK_EVENT_SEQUENCE_DENIED" value="2"/>
+  <define name="GTK_PAN_DIRECTION_LEFT" value="0"/>
+  <define name="GTK_PAN_DIRECTION_RIGHT" value="1"/>
+  <define name="GTK_PAN_DIRECTION_UP" value="2"/>
+  <define name="GTK_PAN_DIRECTION_DOWN" value="3"/>
+  <define name="GTK_SHORTCUT_SCOPE_LOCAL" value="0"/>
+  <define name="GTK_SHORTCUT_SCOPE_MANAGED" value="1"/>
+  <define name="GTK_SHORTCUT_SCOPE_GLOBAL" value="2"/>
+  <define name="GTK_PICK_DEFAULT" value="0"/>
+  <define name="GTK_PICK_INSENSITIVE" value="1&lt;&lt;0"/>
+  <define name="GTK_PICK_NON_TARGETABLE" value="1&lt;&lt;1"/>
+  <define name="GTK_CONSTRAINT_RELATION_LE" value="-1"/>
+  <define name="GTK_CONSTRAINT_RELATION_EQ" value="0"/>
+  <define name="GTK_CONSTRAINT_RELATION_GE" value="1"/>
+  <define name="GTK_CONSTRAINT_STRENGTH_REQUIRED" value="1001001000"/>
+  <define name="GTK_CONSTRAINT_STRENGTH_STRONG" value="1000000000"/>
+  <define name="GTK_CONSTRAINT_STRENGTH_MEDIUM" value="1000"/>
+  <define name="GTK_CONSTRAINT_STRENGTH_WEAK" value="1"/>
+  <define name="GTK_CONSTRAINT_ATTRIBUTE_NONE" value="0"/>
+  <define name="GTK_CONSTRAINT_ATTRIBUTE_LEFT" value="1"/>
+  <define name="GTK_CONSTRAINT_ATTRIBUTE_RIGHT" value="2"/>
+  <define name="GTK_CONSTRAINT_ATTRIBUTE_TOP" value="3"/>
+  <define name="GTK_CONSTRAINT_ATTRIBUTE_BOTTOM" value="4"/>
+  <define name="GTK_CONSTRAINT_ATTRIBUTE_START" value="5"/>
+  <define name="GTK_CONSTRAINT_ATTRIBUTE_END" value="6"/>
+  <define name="GTK_CONSTRAINT_ATTRIBUTE_WIDTH" value="7"/>
+  <define name="GTK_CONSTRAINT_ATTRIBUTE_HEIGHT" value="8"/>
+  <define name="GTK_CONSTRAINT_ATTRIBUTE_CENTER_X" value="9"/>
+  <define name="GTK_CONSTRAINT_ATTRIBUTE_CENTER_Y" value="10"/>
+  <define name="GTK_CONSTRAINT_ATTRIBUTE_BASELINE" value="11"/>
+  <define name="GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_SYMBOL" value="0"/>
+  <define name="GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_ATTRIBUTE" value="1"/>
+  <define name="GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_VIEW" value="2"/>
+  <define name="GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_METRIC" value="3"/>
+  <define name="GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_PRIORITY" value="4"/>
+  <define name="GTK_CONSTRAINT_VFL_PARSER_ERROR_INVALID_RELATION" value="5"/>
+  <define name="GTK_SYSTEM_SETTING_DPI" value="0"/>
+  <define name="GTK_SYSTEM_SETTING_FONT_NAME" value="1"/>
+  <define name="GTK_SYSTEM_SETTING_FONT_CONFIG" value="2"/>
+  <define name="GTK_SYSTEM_SETTING_DISPLAY" value="3"/>
+  <define name="GTK_SYSTEM_SETTING_ICON_THEME" value="4"/>
+  <define name="GTK_SYMBOLIC_COLOR_FOREGROUND" value="0"/>
+  <define name="GTK_SYMBOLIC_COLOR_ERROR" value="1"/>
+  <define name="GTK_SYMBOLIC_COLOR_WARNING" value="2"/>
+  <define name="GTK_SYMBOLIC_COLOR_SUCCESS" value="3"/>
+  <define name="GTK_ACCESSIBLE_STATE_BUSY" value="0"/>
+  <define name="GTK_ACCESSIBLE_STATE_CHECKED" value="1"/>
+  <define name="GTK_ACCESSIBLE_STATE_DISABLED" value="2"/>
+  <define name="GTK_ACCESSIBLE_STATE_EXPANDED" value="3"/>
+  <define name="GTK_ACCESSIBLE_STATE_HIDDEN" value="4"/>
+  <define name="GTK_ACCESSIBLE_STATE_INVALID" value="5"/>
+  <define name="GTK_ACCESSIBLE_STATE_PRESSED" value="6"/>
+  <define name="GTK_ACCESSIBLE_STATE_SELECTED" value="7"/>
+  <define name="GTK_ACCESSIBLE_STATE_VISITED" value="8"/>
+  <define name="GTK_ACCESSIBLE_ROLE_ALERT" value="0"/>
+  <define name="GTK_ACCESSIBLE_ROLE_ALERT_DIALOG" value="1"/>
+  <define name="GTK_ACCESSIBLE_ROLE_BANNER" value="2"/>
+  <define name="GTK_ACCESSIBLE_ROLE_BUTTON" value="3"/>
+  <define name="GTK_ACCESSIBLE_ROLE_CAPTION" value="4"/>
+  <define name="GTK_ACCESSIBLE_ROLE_CELL" value="5"/>
+  <define name="GTK_ACCESSIBLE_ROLE_CHECKBOX" value="6"/>
+  <define name="GTK_ACCESSIBLE_ROLE_COLUMN_HEADER" value="7"/>
+  <define name="GTK_ACCESSIBLE_ROLE_COMBO_BOX" value="8"/>
+  <define name="GTK_ACCESSIBLE_ROLE_COMMAND" value="9"/>
+  <define name="GTK_ACCESSIBLE_ROLE_COMPOSITE" value="10"/>
+  <define name="GTK_ACCESSIBLE_ROLE_DIALOG" value="11"/>
+  <define name="GTK_ACCESSIBLE_ROLE_DOCUMENT" value="12"/>
+  <define name="GTK_ACCESSIBLE_ROLE_FEED" value="13"/>
+  <define name="GTK_ACCESSIBLE_ROLE_FORM" value="14"/>
+  <define name="GTK_ACCESSIBLE_ROLE_GENERIC" value="15"/>
+  <define name="GTK_ACCESSIBLE_ROLE_GRID" value="16"/>
+  <define name="GTK_ACCESSIBLE_ROLE_GRID_CELL" value="17"/>
+  <define name="GTK_ACCESSIBLE_ROLE_GROUP" value="18"/>
+  <define name="GTK_ACCESSIBLE_ROLE_HEADING" value="19"/>
+  <define name="GTK_ACCESSIBLE_ROLE_IMG" value="20"/>
+  <define name="GTK_ACCESSIBLE_ROLE_INPUT" value="21"/>
+  <define name="GTK_ACCESSIBLE_ROLE_LABEL" value="22"/>
+  <define name="GTK_ACCESSIBLE_ROLE_LANDMARK" value="23"/>
+  <define name="GTK_ACCESSIBLE_ROLE_LEGEND" value="24"/>
+  <define name="GTK_ACCESSIBLE_ROLE_LINK" value="25"/>
+  <define name="GTK_ACCESSIBLE_ROLE_LIST" value="26"/>
+  <define name="GTK_ACCESSIBLE_ROLE_LIST_BOX" value="27"/>
+  <define name="GTK_ACCESSIBLE_ROLE_LIST_ITEM" value="28"/>
+  <define name="GTK_ACCESSIBLE_ROLE_LOG" value="29"/>
+  <define name="GTK_ACCESSIBLE_ROLE_MAIN" value="30"/>
+  <define name="GTK_ACCESSIBLE_ROLE_MARQUEE" value="31"/>
+  <define name="GTK_ACCESSIBLE_ROLE_MATH" value="32"/>
+  <define name="GTK_ACCESSIBLE_ROLE_METER" value="33"/>
+  <define name="GTK_ACCESSIBLE_ROLE_MENU" value="34"/>
+  <define name="GTK_ACCESSIBLE_ROLE_MENU_BAR" value="35"/>
+  <define name="GTK_ACCESSIBLE_ROLE_MENU_ITEM" value="36"/>
+  <define name="GTK_ACCESSIBLE_ROLE_MENU_ITEM_CHECKBOX" value="37"/>
+  <define name="GTK_ACCESSIBLE_ROLE_MENU_ITEM_RADIO" value="38"/>
+  <define name="GTK_ACCESSIBLE_ROLE_NAVIGATION" value="39"/>
+  <define name="GTK_ACCESSIBLE_ROLE_NONE" value="40"/>
+  <define name="GTK_ACCESSIBLE_ROLE_NOTE" value="41"/>
+  <define name="GTK_ACCESSIBLE_ROLE_OPTION" value="42"/>
+  <define name="GTK_ACCESSIBLE_ROLE_PRESENTATION" value="43"/>
+  <define name="GTK_ACCESSIBLE_ROLE_PROGRESS_BAR" value="44"/>
+  <define name="GTK_ACCESSIBLE_ROLE_RADIO" value="45"/>
+  <define name="GTK_ACCESSIBLE_ROLE_RADIO_GROUP" value="46"/>
+  <define name="GTK_ACCESSIBLE_ROLE_RANGE" value="47"/>
+  <define name="GTK_ACCESSIBLE_ROLE_REGION" value="48"/>
+  <define name="GTK_ACCESSIBLE_ROLE_ROW" value="49"/>
+  <define name="GTK_ACCESSIBLE_ROLE_ROW_GROUP" value="50"/>
+  <define name="GTK_ACCESSIBLE_ROLE_ROW_HEADER" value="51"/>
+  <define name="GTK_ACCESSIBLE_ROLE_SCROLLBAR" value="52"/>
+  <define name="GTK_ACCESSIBLE_ROLE_SEARCH" value="53"/>
+  <define name="GTK_ACCESSIBLE_ROLE_SEARCH_BOX" value="54"/>
+  <define name="GTK_ACCESSIBLE_ROLE_SECTION" value="55"/>
+  <define name="GTK_ACCESSIBLE_ROLE_SECTION_HEAD" value="56"/>
+  <define name="GTK_ACCESSIBLE_ROLE_SELECT" value="57"/>
+  <define name="GTK_ACCESSIBLE_ROLE_SEPARATOR" value="58"/>
+  <define name="GTK_ACCESSIBLE_ROLE_SLIDER" value="59"/>
+  <define name="GTK_ACCESSIBLE_ROLE_SPIN_BUTTON" value="60"/>
+  <define name="GTK_ACCESSIBLE_ROLE_STATUS" value="61"/>
+  <define name="GTK_ACCESSIBLE_ROLE_STRUCTURE" value="62"/>
+  <define name="GTK_ACCESSIBLE_ROLE_SWITCH" value="63"/>
+  <define name="GTK_ACCESSIBLE_ROLE_TAB" value="64"/>
+  <define name="GTK_ACCESSIBLE_ROLE_TABLE" value="65"/>
+  <define name="GTK_ACCESSIBLE_ROLE_TAB_LIST" value="66"/>
+  <define name="GTK_ACCESSIBLE_ROLE_TAB_PANEL" value="67"/>
+  <define name="GTK_ACCESSIBLE_ROLE_TEXT_BOX" value="68"/>
+  <define name="GTK_ACCESSIBLE_ROLE_TIME" value="69"/>
+  <define name="GTK_ACCESSIBLE_ROLE_TIMER" value="70"/>
+  <define name="GTK_ACCESSIBLE_ROLE_TOOLBAR" value="71"/>
+  <define name="GTK_ACCESSIBLE_ROLE_TOOLTIP" value="72"/>
+  <define name="GTK_ACCESSIBLE_ROLE_TREE" value="73"/>
+  <define name="GTK_ACCESSIBLE_ROLE_TREE_GRID" value="74"/>
+  <define name="GTK_ACCESSIBLE_ROLE_TREE_ITEM" value="75"/>
+  <define name="GTK_ACCESSIBLE_ROLE_WIDGET" value="76"/>
+  <define name="GTK_ACCESSIBLE_ROLE_WINDOW" value="77"/>
+  <define name="GTK_ACCESSIBLE_ROLE_TOGGLE_BUTTON" value="78"/>
+  <define name="GTK_ACCESSIBLE_ROLE_APPLICATION" value="79"/>
+  <define name="GTK_ACCESSIBLE_ROLE_PARAGRAPH" value="80"/>
+  <define name="GTK_ACCESSIBLE_ROLE_BLOCK_QUOTE" value="81"/>
+  <define name="GTK_ACCESSIBLE_ROLE_ARTICLE" value="82"/>
+  <define name="GTK_ACCESSIBLE_ROLE_COMMENT" value="83"/>
+  <define name="GTK_ACCESSIBLE_ROLE_TERMINAL" value="84"/>
+  <define name="GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE" value="0"/>
+  <define name="GTK_ACCESSIBLE_PROPERTY_DESCRIPTION" value="1"/>
+  <define name="GTK_ACCESSIBLE_PROPERTY_HAS_POPUP" value="2"/>
+  <define name="GTK_ACCESSIBLE_PROPERTY_KEY_SHORTCUTS" value="3"/>
+  <define name="GTK_ACCESSIBLE_PROPERTY_LABEL" value="4"/>
+  <define name="GTK_ACCESSIBLE_PROPERTY_LEVEL" value="5"/>
+  <define name="GTK_ACCESSIBLE_PROPERTY_MODAL" value="6"/>
+  <define name="GTK_ACCESSIBLE_PROPERTY_MULTI_LINE" value="7"/>
+  <define name="GTK_ACCESSIBLE_PROPERTY_MULTI_SELECTABLE" value="8"/>
+  <define name="GTK_ACCESSIBLE_PROPERTY_ORIENTATION" value="9"/>
+  <define name="GTK_ACCESSIBLE_PROPERTY_PLACEHOLDER" value="10"/>
+  <define name="GTK_ACCESSIBLE_PROPERTY_READ_ONLY" value="11"/>
+  <define name="GTK_ACCESSIBLE_PROPERTY_REQUIRED" value="12"/>
+  <define name="GTK_ACCESSIBLE_PROPERTY_ROLE_DESCRIPTION" value="13"/>
+  <define name="GTK_ACCESSIBLE_PROPERTY_SORT" value="14"/>
+  <define name="GTK_ACCESSIBLE_PROPERTY_VALUE_MAX" value="15"/>
+  <define name="GTK_ACCESSIBLE_PROPERTY_VALUE_MIN" value="16"/>
+  <define name="GTK_ACCESSIBLE_PROPERTY_VALUE_NOW" value="17"/>
+  <define name="GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT" value="18"/>
+  <define name="GTK_ACCESSIBLE_RELATION_ACTIVE_DESCENDANT" value="0"/>
+  <define name="GTK_ACCESSIBLE_RELATION_COL_COUNT" value="1"/>
+  <define name="GTK_ACCESSIBLE_RELATION_COL_INDEX" value="2"/>
+  <define name="GTK_ACCESSIBLE_RELATION_COL_INDEX_TEXT" value="3"/>
+  <define name="GTK_ACCESSIBLE_RELATION_COL_SPAN" value="4"/>
+  <define name="GTK_ACCESSIBLE_RELATION_CONTROLS" value="5"/>
+  <define name="GTK_ACCESSIBLE_RELATION_DESCRIBED_BY" value="6"/>
+  <define name="GTK_ACCESSIBLE_RELATION_DETAILS" value="7"/>
+  <define name="GTK_ACCESSIBLE_RELATION_ERROR_MESSAGE" value="8"/>
+  <define name="GTK_ACCESSIBLE_RELATION_FLOW_TO" value="9"/>
+  <define name="GTK_ACCESSIBLE_RELATION_LABELLED_BY" value="10"/>
+  <define name="GTK_ACCESSIBLE_RELATION_OWNS" value="11"/>
+  <define name="GTK_ACCESSIBLE_RELATION_POS_IN_SET" value="12"/>
+  <define name="GTK_ACCESSIBLE_RELATION_ROW_COUNT" value="13"/>
+  <define name="GTK_ACCESSIBLE_RELATION_ROW_INDEX" value="14"/>
+  <define name="GTK_ACCESSIBLE_RELATION_ROW_INDEX_TEXT" value="15"/>
+  <define name="GTK_ACCESSIBLE_RELATION_ROW_SPAN" value="16"/>
+  <define name="GTK_ACCESSIBLE_RELATION_SET_SIZE" value="17"/>
+  <define name="GTK_ACCESSIBLE_TRISTATE_FALSE" value="0"/>
+  <define name="GTK_ACCESSIBLE_TRISTATE_TRUE" value="1"/>
+  <define name="GTK_ACCESSIBLE_TRISTATE_MIXED" value="2"/>
+  <define name="GTK_ACCESSIBLE_INVALID_FALSE" value="0"/>
+  <define name="GTK_ACCESSIBLE_INVALID_TRUE" value="1"/>
+  <define name="GTK_ACCESSIBLE_INVALID_GRAMMAR" value="2"/>
+  <define name="GTK_ACCESSIBLE_INVALID_SPELLING" value="3"/>
+  <define name="GTK_ACCESSIBLE_AUTOCOMPLETE_NONE" value="0"/>
+  <define name="GTK_ACCESSIBLE_AUTOCOMPLETE_INLINE" value="1"/>
+  <define name="GTK_ACCESSIBLE_AUTOCOMPLETE_LIST" value="2"/>
+  <define name="GTK_ACCESSIBLE_AUTOCOMPLETE_BOTH" value="3"/>
+  <define name="GTK_ACCESSIBLE_SORT_NONE" value="0"/>
+  <define name="GTK_ACCESSIBLE_SORT_ASCENDING" value="1"/>
+  <define name="GTK_ACCESSIBLE_SORT_DESCENDING" value="2"/>
+  <define name="GTK_ACCESSIBLE_SORT_OTHER" value="3"/>
+  <define name="GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_LOW" value="0"/>
+  <define name="GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_MEDIUM" value="1"/>
+  <define name="GTK_ACCESSIBLE_ANNOUNCEMENT_PRIORITY_HIGH" value="2"/>
+  <define name="GTK_POPOVER_MENU_SLIDING" value="0"/>
+  <define name="GTK_POPOVER_MENU_NESTED" value="1&lt;&lt;0"/>
+  <!-- gtk/gtkeventcontrollerscroll.h -->
+  <define name="GTK_EVENT_CONTROLLER_SCROLL_NONE" value="0"/>
+  <define name="GTK_EVENT_CONTROLLER_SCROLL_VERTICAL" value="1&lt;&lt;0"/>
+  <define name="GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL" value="1&lt;&lt;1"/>
+  <define name="GTK_EVENT_CONTROLLER_SCROLL_DISCRETE" value="1&lt;&lt;2"/>
+  <define name="GTK_EVENT_CONTROLLER_SCROLL_KINETIC" value="1&lt;&lt;3"/>
+  <define name="GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES" value="(GTK_EVENT_CONTROLLER_SCROLL_VERTICAL|GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL)"/>
+  <!-- gtk/gtkfilechooserutils.h -->
+  <define name="GTK_FILE_CHOOSER_PROP_FIRST" value="0x1000"/>
+  <define name="GTK_FILE_CHOOSER_PROP_ACTION" value="0x1000"/>
+  <define name="GTK_FILE_CHOOSER_PROP_FILTER" value="4097"/>
+  <define name="GTK_FILE_CHOOSER_PROP_SELECT_MULTIPLE" value="4098"/>
+  <define name="GTK_FILE_CHOOSER_PROP_CREATE_FOLDERS" value="4099"/>
+  <define name="GTK_FILE_CHOOSER_PROP_FILTERS" value="4100"/>
+  <define name="GTK_FILE_CHOOSER_PROP_SHORTCUT_FOLDERS" value="4101"/>
+  <define name="GTK_FILE_CHOOSER_PROP_LAST" value="4101"/>
+  <!-- gtk/gtkfilter.h -->
+  <define name="GTK_FILTER_MATCH_SOME" value="0"/>
+  <define name="GTK_FILTER_MATCH_NONE" value="1"/>
+  <define name="GTK_FILTER_MATCH_ALL" value="2"/>
+  <define name="GTK_FILTER_CHANGE_DIFFERENT" value="0"/>
+  <define name="GTK_FILTER_CHANGE_LESS_STRICT" value="1"/>
+  <define name="GTK_FILTER_CHANGE_MORE_STRICT" value="2"/>
+  <!-- gtk/gtkfontchooserutils.h -->
+  <define name="GTK_FONT_CHOOSER_PROP_FIRST" value="0x4000"/>
+  <define name="GTK_FONT_CHOOSER_PROP_FONT" value="16385"/>
+  <define name="GTK_FONT_CHOOSER_PROP_FONT_DESC" value="16386"/>
+  <define name="GTK_FONT_CHOOSER_PROP_PREVIEW_TEXT" value="16387"/>
+  <define name="GTK_FONT_CHOOSER_PROP_SHOW_PREVIEW_ENTRY" value="16388"/>
+  <define name="GTK_FONT_CHOOSER_PROP_LEVEL" value="16389"/>
+  <define name="GTK_FONT_CHOOSER_PROP_FONT_FEATURES" value="16390"/>
+  <define name="GTK_FONT_CHOOSER_PROP_LANGUAGE" value="16391"/>
+  <define name="GTK_FONT_CHOOSER_PROP_LAST" value="16392"/>
+  <!-- gtk/gtkfontdialogbutton.h -->
+  <define name="GTK_FONT_LEVEL_FAMILY" value="0"/>
+  <define name="GTK_FONT_LEVEL_FACE" value="1"/>
+  <define name="GTK_FONT_LEVEL_FONT" value="2"/>
+  <define name="GTK_FONT_LEVEL_FEATURES" value="3"/>
+  <!-- gtk/gtkgraphicsoffload.h -->
+  <define name="GTK_GRAPHICS_OFFLOAD_ENABLED" value="0"/>
+  <define name="GTK_GRAPHICS_OFFLOAD_DISABLED" value="1"/>
+  <!-- gtk/gtkicontheme.h -->
+  <define name="GTK_ICON_LOOKUP_FORCE_REGULAR" value="1&lt;&lt;0"/>
+  <define name="GTK_ICON_LOOKUP_FORCE_SYMBOLIC" value="1&lt;&lt;1"/>
+  <define name="GTK_ICON_LOOKUP_PRELOAD" value="1&lt;&lt;2"/>
+  <define name="GTK_ICON_THEME_NOT_FOUND" value="0"/>
+  <define name="GTK_ICON_THEME_FAILED" value="1"/>
+  <!-- gtk/gtkimage.h -->
+  <define name="GTK_IMAGE_EMPTY" value="0"/>
+  <define name="GTK_IMAGE_ICON_NAME" value="1"/>
+  <define name="GTK_IMAGE_GICON" value="2"/>
+  <define name="GTK_IMAGE_PAINTABLE" value="3"/>
+  <!-- gtk/gtk.h -->
+  <define name="GTK_STOCK_ZOOM_IN" value="&quot;gtk-zoom-in&quot;"/>
+  <define name="GTK_STOCK_ZOOM_FIT" value="&quot;gtk-zoom-fit&quot;"/>
+  <define name="GTK_STOCK_ZOOM_100" value="&quot;gtk-zoom-100&quot;"/>
+  <define name="GTK_STOCK_UNINDENT" value="&quot;gtk-unindent&quot;"/>
+  <define name="GTK_STOCK_UNDERLINE" value="&quot;gtk-underline&quot;"/>
+  <define name="GTK_STOCK_UNDELETE" value="&quot;gtk-undelete&quot;"/>
+  <define name="GTK_STOCK_SELECT_FONT" value="&quot;gtk-select-font&quot;"/>
+  <define name="GTK_STOCK_SELECT_ALL" value="&quot;gtk-select-all&quot;"/>
+  <define name="GTK_STOCK_SAVE" value="&quot;gtk-save&quot;"/>
+  <define name="GTK_STOCK_REMOVE" value="&quot;gtk-remove&quot;"/>
+  <define name="GTK_STOCK_REDO" value="&quot;gtk-redo&quot;"/>
+  <define name="GTK_STOCK_SORT_DESCENDING" value="&quot;gtk-sort-descending&quot;"/>
+  <define name="GTK_STOCK_PROPERTIES" value="&quot;gtk-properties&quot;"/>
+  <define name="GTK_STOCK_PRINT_REPORT" value="&quot;gtk-print-report&quot;"/>
+  <define name="GTK_STOCK_PRINT_PREVIEW" value="&quot;gtk-print-preview&quot;"/>
+  <define name="GTK_STOCK_PRINT_ERROR" value="&quot;gtk-print-error&quot;"/>
+  <define name="GTK_STOCK_UNDO" value="&quot;gtk-undo&quot;"/>
+  <define name="GTK_STOCK_REFRESH" value="&quot;gtk-refresh&quot;"/>
+  <define name="GTK_STOCK_PRINT" value="&quot;gtk-print&quot;"/>
+  <define name="GTK_STOCK_PREFERENCES" value="&quot;gtk-preferences&quot;"/>
+  <define name="GTK_STOCK_ORIENTATION_REVERSE_PORTRAIT" value="&quot;gtk-orientation-reverse-portrait&quot;"/>
+  <define name="GTK_STOCK_QUIT" value="&quot;gtk-quit&quot;"/>
+  <define name="GTK_STOCK_ORIENTATION_PORTRAIT" value="&quot;gtk-orientation-portrait&quot;"/>
+  <define name="GTK_STOCK_OPEN" value="&quot;gtk-open&quot;"/>
+  <define name="GTK_STOCK_STRIKETHROUGH" value="&quot;gtk-strikethrough&quot;"/>
+  <define name="GTK_STOCK_REVERT_TO_SAVED" value="&quot;gtk-revert-to-saved&quot;"/>
+  <define name="GTK_STOCK_PAGE_SETUP" value="&quot;gtk-page-setup&quot;"/>
+  <define name="GTK_STOCK_OK" value="&quot;gtk-ok&quot;"/>
+  <define name="GTK_STOCK_NO" value="&quot;gtk-no&quot;"/>
+  <define name="GTK_STOCK_NEW" value="&quot;gtk-new&quot;"/>
+  <define name="GTK_STOCK_MISSING_IMAGE" value="&quot;gtk-missing-image&quot;"/>
+  <define name="GTK_STOCK_MEDIA_STOP" value="&quot;gtk-media-stop&quot;"/>
+  <define name="GTK_STOCK_FIND" value="&quot;gtk-find&quot;"/>
+  <define name="GTK_STOCK_ORIENTATION_LANDSCAPE" value="&quot;gtk-orientation-landscape&quot;"/>
+  <define name="GTK_STOCK_DISCARD" value="&quot;gtk-discard&quot;"/>
+  <define name="GTK_STOCK_ADD" value="&quot;gtk-add&quot;"/>
+  <define name="GTK_STOCK_ORIENTATION_REVERSE_LANDSCAPE" value="&quot;gtk-orientation-reverse-landscape&quot;"/>
+  <define name="GTK_STOCK_FILE" value="&quot;gtk-file&quot;"/>
+  <define name="GTK_STOCK_DELETE" value="&quot;gtk-delete&quot;"/>
+  <define name="GTK_STOCK_EDIT" value="&quot;gtk-edit&quot;"/>
+  <define name="GTK_STOCK_DISCONNECT" value="&quot;gtk-disconnect&quot;"/>
+  <define name="GTK_STOCK_COPY" value="&quot;gtk-copy&quot;"/>
+  <define name="GTK_STOCK_PRINT_WARNING" value="&quot;gtk-print-warning&quot;"/>
+  <define name="GTK_STOCK_MEDIA_REWIND" value="&quot;gtk-media-rewind&quot;"/>
+  <define name="GTK_STOCK_EXECUTE" value="&quot;gtk-execute&quot;"/>
+  <define name="GTK_STOCK_GO_FORWARD" value="&quot;gtk-go-forward&quot;"/>
+  <define name="GTK_STOCK_DIALOG_WARNING" value="&quot;gtk-dialog-warning&quot;"/>
+  <define name="GTK_STOCK_SELECT_COLOR" value="&quot;gtk-select-color&quot;"/>
+  <define name="GTK_STOCK_CLEAR" value="&quot;gtk-clear&quot;"/>
+  <define name="GTK_STOCK_CAPS_LOCK_WARNING" value="&quot;gtk-caps-lock-warning&quot;"/>
+  <define name="GTK_STOCK_SAVE_AS" value="&quot;gtk-save-as&quot;"/>
+  <define name="GTK_STOCK_CUT" value="&quot;gtk-cut&quot;"/>
+  <define name="GTK_STOCK_PASTE" value="&quot;gtk-paste&quot;"/>
+  <define name="GTK_STOCK_CONVERT" value="&quot;gtk-convert&quot;"/>
+  <define name="GTK_STOCK_GO_UP" value="&quot;gtk-go-up&quot;"/>
+  <define name="GTK_STOCK_DIRECTORY" value="&quot;gtk-directory&quot;"/>
+  <define name="GTK_STOCK_HARDDISK" value="&quot;gtk-harddisk&quot;"/>
+  <define name="GTK_STOCK_MEDIA_PREVIOUS" value="&quot;gtk-media-previous&quot;"/>
+  <define name="GTK_STOCK_BOLD" value="&quot;gtk-bold&quot;"/>
+  <define name="GTK_STOCK_CDROM" value="&quot;gtk-cdrom&quot;"/>
+  <define name="GTK_STOCK_JUSTIFY_LEFT" value="&quot;gtk-justify-left&quot;"/>
+  <define name="GTK_STOCK_NETWORK" value="&quot;gtk-network&quot;"/>
+  <define name="GTK_STOCK_DIALOG_AUTHENTICATION" value="&quot;gtk-dialog-authentication&quot;"/>
+  <define name="GTK_STOCK_PRINT_PAUSED" value="&quot;gtk-print-paused&quot;"/>
+  <define name="GTK_STOCK_DND" value="&quot;gtk-dnd&quot;"/>
+  <define name="GTK_STOCK_FIND_AND_REPLACE" value="&quot;gtk-find-and-replace&quot;"/>
+  <define name="GTK_STOCK_SORT_ASCENDING" value="&quot;gtk-sort-ascending&quot;"/>
+  <define name="GTK_STOCK_MEDIA_PLAY" value="&quot;gtk-media-play&quot;"/>
+  <define name="GTK_STOCK_INDEX" value="&quot;gtk-index&quot;"/>
+  <define name="GTK_STOCK_CONNECT" value="&quot;gtk-connect&quot;"/>
+  <define name="GTK_STOCK_STOP" value="&quot;gtk-stop&quot;"/>
+  <define name="GTK_STOCK_CANCEL" value="&quot;gtk-cancel&quot;"/>
+  <define name="GTK_STOCK_DIALOG_INFO" value="&quot;gtk-dialog-info&quot;"/>
+  <define name="GTK_STOCK_APPLY" value="&quot;gtk-apply&quot;"/>
+  <define name="GTK_STOCK_DIALOG_QUESTION" value="&quot;gtk-dialog-question&quot;"/>
+  <define name="GTK_STOCK_MEDIA_RECORD" value="&quot;gtk-media-record&quot;"/>
+  <define name="GTK_STOCK_COLOR_PICKER" value="&quot;gtk-color-picker&quot;"/>
+  <define name="GTK_STOCK_DIALOG_ERROR" value="&quot;gtk-dialog-error&quot;"/>
+  <define name="GTK_STOCK_GOTO_TOP" value="&quot;gtk-goto-top&quot;"/>
+  <define name="GTK_STOCK_FLOPPY" value="&quot;gtk-floppy&quot;"/>
+  <define name="GTK_STOCK_GOTO_BOTTOM" value="&quot;gtk-goto-bottom&quot;"/>
+  <define name="GTK_STOCK_JUMP_TO" value="&quot;gtk-jump-to&quot;"/>
+  <define name="GTK_STOCK_JUSTIFY_CENTER" value="&quot;gtk-justify-center&quot;"/>
+  <define name="GTK_STOCK_YES" value="&quot;gtk-yes&quot;"/>
+  <define name="GTK_STOCK_SPELL_CHECK" value="&quot;gtk-spell-check&quot;"/>
+  <define name="GTK_STOCK_MEDIA_NEXT" value="&quot;gtk-media-next&quot;"/>
+  <define name="GTK_STOCK_GOTO_FIRST" value="&quot;gtk-goto-first&quot;"/>
+  <define name="GTK_STOCK_JUSTIFY_FILL" value="&quot;gtk-justify-fill&quot;"/>
+  <define name="GTK_STOCK_GOTO_LAST" value="&quot;gtk-goto-last&quot;"/>
+  <define name="GTK_STOCK_GO_BACK" value="&quot;gtk-go-back&quot;"/>
+  <define name="GTK_STOCK_FULLSCREEN" value="&quot;gtk-fullscreen&quot;"/>
+  <define name="GTK_STOCK_HOME" value="&quot;gtk-home&quot;"/>
+  <define name="GTK_STOCK_GO_DOWN" value="&quot;gtk-go-down&quot;"/>
+  <define name="GTK_STOCK_INFO" value="&quot;gtk-info&quot;"/>
+  <define name="GTK_STOCK_ZOOM_OUT" value="&quot;gtk-zoom-out&quot;"/>
+  <define name="GTK_STOCK_ABOUT" value="&quot;gtk-about&quot;"/>
+  <define name="GTK_STOCK_LEAVE_FULLSCREEN" value="&quot;gtk-leave-fullscreen&quot;"/>
+  <define name="GTK_STOCK_HELP" value="&quot;gtk-help&quot;"/>
+  <define name="GTK_STOCK_DND_MULTIPLE" value="&quot;gtk-dnd-multiple&quot;"/>
+  <define name="GTK_STOCK_ITALIC" value="&quot;gtk-italic&quot;"/>
+  <define name="GTK_STOCK_JUSTIFY_RIGHT" value="&quot;gtk-justify-right&quot;"/>
+  <define name="GTK_STOCK_MEDIA_FORWARD" value="&quot;gtk-media-forward&quot;"/>
+  <define name="GTK_STOCK_CLOSE" value="&quot;gtk-close&quot;"/>
+  <define name="GTK_STOCK_INDENT" value="&quot;gtk-indent&quot;"/>
+  <define name="GTK_STOCK_MEDIA_PAUSE" value="&quot;gtk-media-pause&quot;"/>
+  <define name="GTK_PRIORITY_LOW" value="G_PRIORITY_LOW"/>
+  <define name="GTK_PRIORITY_DEFAULT" value="G_PRIORITY_DEFAULT_IDLE"/>
+  <define name="GTK_PRIORITY_INTERNAL" value="GTK_PRIORITY_REDRAW"/>
+  <define name="GTK_PRIORITY_HIGH" value="G_PRIORITY_HIGH"/>
+  <define name="GTK_PRIORITY_RESIZE" value="(G_PRIORITY_HIGH_IDLE+10)"/>
+  <define name="GTK_PRIORITY_REDRAW" value="(G_PRIORITY_HIGH_IDLE+20)"/>
+  <!-- version check for GLib, ATK and GTK -->
+  <define name="GLIB_CHECK_VERSION(major, minor, micro)" value="1"/>
+  <define name="ATK_CHECK_VERSION(major, minor, micro)" value="1"/>
+  <define name="GTK_CHECK_VERSION(major, minor, micro)" value="1"/>
 </def>
diff --git a/cfg/icu.cfg b/cfg/icu.cfg
new file mode 100644
index 00000000000..5e1f9163fd0
--- /dev/null
+++ b/cfg/icu.cfg
@@ -0,0 +1,221 @@
+<?xml version="1.0"?>
+<def format="2">
+  <!-- This library contains configuration of ICU-project (http://userguide.icu-project.org/) -->
+  <!-- https://unicode-org.github.io/icu-docs/apidoc/dev/icu4c/utypes_8h.html -->
+  <define name="U_SUCCESS(x)" value="((x)&lt;=0)"/>
+  <define name="U_FAILURE(x)" value="((x)&gt;0)"/>
+  <define name="U_STANDARD_CPP_NAMESPACE" value=""/>
+  <define name="U_IO_API" value=""/>
+  <define name="U_EXPORT" value=""/>
+  <define name="U_EXPORT2" value=""/>
+  <define name="U_IMPORT" value=""/>
+  <define name="U_HIDDEN" value=""/>
+  <define name="U_LAYOUT_API" value=""/>
+  <define name="U_I18N_API" value=""/>
+  <define name="U_LAYOUTEX_API" value=""/>
+  <define name="U_DATA_API" value=""/>
+  <define name="U_SHOW_CPLUSPLUS_API" value="0"/>
+  <define name="U_ICUDATA_TYPE_LITLETTER" value="l"/>
+  <define name="U_ICUDATA_NAME" value="&quot;icudt&quot;U_ICU_VERSION_SHORTU_ICUDATA_TYPE_LETTER"/>
+  <define name="U_TOOLUTIL_API" value=""/>
+  <define name="U_DATE_MIN" value="-U_DATE_MAX"/>
+  <define name="U_MILLIS_PER_SECOND" value="(1000)"/>
+  <define name="U_ICUDATA_ENTRY_POINT" value="U_DEF2_ICUDATA_ENTRY_POINT(U_ICU_VERSION_MAJOR_NUM,U_LIB_SUFFIX_C_NAME)"/>
+  <define name="U_MILLIS_PER_MINUTE" value="(60000)"/>
+  <define name="U_MILLIS_PER_HOUR" value="(3600000)"/>
+  <define name="U_COMMON_API" value=""/>
+  <define name="U_MILLIS_PER_DAY" value="(86400000)"/>
+  <define name="U_ICUDATA_TYPE_LETTER" value="&quot;l&quot;"/>
+  <define name="U_DATE_MAX" value="DBL_MAX"/>
+  <define name="U_COMBINED_IMPLEMENTATION" value="1"/>
+  <define name="U_HIDE_INTERNAL_API" value="1"/>
+  <define name="U_HIDE_DRAFT_API" value="1"/>
+  <!-- enum UErrorCode -->
+  <define name="U_USING_FALLBACK_WARNING" value="-128"/>
+  <define name="U_ERROR_WARNING_START" value="-128"/>
+  <define name="U_USING_DEFAULT_WARNING" value="-127"/>
+  <define name="U_SAFECLONE_ALLOCATED_WARNING" value="-126"/>
+  <define name="U_STATE_OLD_WARNING" value="-125"/>
+  <define name="U_STRING_NOT_TERMINATED_WARNING" value="-124"/>
+  <define name="U_SORT_KEY_TOO_SHORT_WARNING" value="-123"/>
+  <define name="U_AMBIGUOUS_ALIAS_WARNING" value="-122"/>
+  <define name="U_DIFFERENT_UCA_VERSION" value="-121"/>
+  <define name="U_PLUGIN_CHANGED_LEVEL_WARNING" value="-120"/>
+  <define name="U_ERROR_WARNING_LIMIT" value="-119"/>
+  <define name="U_ZERO_ERROR" value="0"/>
+  <define name="U_ILLEGAL_ARGUMENT_ERROR" value="1"/>
+  <define name="U_MISSING_RESOURCE_ERROR" value="2"/>
+  <define name="U_INVALID_FORMAT_ERROR" value="3"/>
+  <define name="U_FILE_ACCESS_ERROR" value="4"/>
+  <define name="U_INTERNAL_PROGRAM_ERROR" value="5"/>
+  <define name="U_MESSAGE_PARSE_ERROR" value="6"/>
+  <define name="U_MEMORY_ALLOCATION_ERROR" value="7"/>
+  <define name="U_INDEX_OUTOFBOUNDS_ERROR" value="8"/>
+  <define name="U_PARSE_ERROR" value="9"/>
+  <define name="U_INVALID_CHAR_FOUND" value="10"/>
+  <define name="U_TRUNCATED_CHAR_FOUND" value="11"/>
+  <define name="U_ILLEGAL_CHAR_FOUND" value="12"/>
+  <define name="U_INVALID_TABLE_FORMAT" value="13"/>
+  <define name="U_INVALID_TABLE_FILE" value="14"/>
+  <define name="U_BUFFER_OVERFLOW_ERROR" value="15"/>
+  <define name="U_UNSUPPORTED_ERROR" value="16"/>
+  <define name="U_RESOURCE_TYPE_MISMATCH" value="17"/>
+  <define name="U_ILLEGAL_ESCAPE_SEQUENCE" value="18"/>
+  <define name="U_UNSUPPORTED_ESCAPE_SEQUENCE" value="19"/>
+  <define name="U_NO_SPACE_AVAILABLE" value="20"/>
+  <define name="U_CE_NOT_FOUND_ERROR" value="21"/>
+  <define name="U_PRIMARY_TOO_LONG_ERROR" value="22"/>
+  <define name="U_STATE_TOO_OLD_ERROR" value="23"/>
+  <define name="U_TOO_MANY_ALIASES_ERROR" value="24"/>
+  <define name="U_ENUM_OUT_OF_SYNC_ERROR" value="25"/>
+  <define name="U_INVARIANT_CONVERSION_ERROR" value="26"/>
+  <define name="U_INVALID_STATE_ERROR" value="27"/>
+  <define name="U_COLLATOR_VERSION_MISMATCH" value="28"/>
+  <define name="U_USELESS_COLLATOR_ERROR" value="29"/>
+  <define name="U_NO_WRITE_PERMISSION" value="30"/>
+  <define name="U_INPUT_TOO_LONG_ERROR" value="31"/>
+  <define name="U_STANDARD_ERROR_LIMIT" value="32"/>
+  <define name="U_BAD_VARIABLE_DEFINITION" value="0x10000"/>
+  <define name="U_PARSE_ERROR_START" value="0x10000"/>
+  <define name="U_MALFORMED_RULE" value="65537"/>
+  <define name="U_MALFORMED_SET" value="65538"/>
+  <define name="U_MALFORMED_SYMBOL_REFERENCE" value="65539"/>
+  <define name="U_MALFORMED_UNICODE_ESCAPE" value="65540"/>
+  <define name="U_MALFORMED_VARIABLE_DEFINITION" value="65541"/>
+  <define name="U_MALFORMED_VARIABLE_REFERENCE" value="65542"/>
+  <define name="U_MISMATCHED_SEGMENT_DELIMITERS" value="65543"/>
+  <define name="U_MISPLACED_ANCHOR_START" value="65544"/>
+  <define name="U_MISPLACED_CURSOR_OFFSET" value="65545"/>
+  <define name="U_MISPLACED_QUANTIFIER" value="65546"/>
+  <define name="U_MISSING_OPERATOR" value="65547"/>
+  <define name="U_MISSING_SEGMENT_CLOSE" value="65548"/>
+  <define name="U_MULTIPLE_ANTE_CONTEXTS" value="65549"/>
+  <define name="U_MULTIPLE_CURSORS" value="65550"/>
+  <define name="U_MULTIPLE_POST_CONTEXTS" value="65551"/>
+  <define name="U_TRAILING_BACKSLASH" value="65552"/>
+  <define name="U_UNDEFINED_SEGMENT_REFERENCE" value="65553"/>
+  <define name="U_UNDEFINED_VARIABLE" value="65554"/>
+  <define name="U_UNQUOTED_SPECIAL" value="65555"/>
+  <define name="U_UNTERMINATED_QUOTE" value="65556"/>
+  <define name="U_RULE_MASK_ERROR" value="65557"/>
+  <define name="U_MISPLACED_COMPOUND_FILTER" value="65558"/>
+  <define name="U_MULTIPLE_COMPOUND_FILTERS" value="65559"/>
+  <define name="U_INVALID_RBT_SYNTAX" value="65560"/>
+  <define name="U_INVALID_PROPERTY_PATTERN" value="65561"/>
+  <define name="U_MALFORMED_PRAGMA" value="65562"/>
+  <define name="U_UNCLOSED_SEGMENT" value="65563"/>
+  <define name="U_ILLEGAL_CHAR_IN_SEGMENT" value="65564"/>
+  <define name="U_VARIABLE_RANGE_EXHAUSTED" value="65565"/>
+  <define name="U_VARIABLE_RANGE_OVERLAP" value="65566"/>
+  <define name="U_ILLEGAL_CHARACTER" value="65567"/>
+  <define name="U_INTERNAL_TRANSLITERATOR_ERROR" value="65568"/>
+  <define name="U_INVALID_ID" value="65569"/>
+  <define name="U_INVALID_FUNCTION" value="65570"/>
+  <define name="U_PARSE_ERROR_LIMIT" value="65571"/>
+  <define name="U_UNEXPECTED_TOKEN" value="0x10100"/>
+  <define name="U_FMT_PARSE_ERROR_START" value="0x10100"/>
+  <define name="U_MULTIPLE_DECIMAL_SEPARATORS" value="65793"/>
+  <define name="U_MULTIPLE_DECIMAL_SEPERATORS" value="65793"/>
+  <define name="U_MULTIPLE_EXPONENTIAL_SYMBOLS" value="65794"/>
+  <define name="U_MALFORMED_EXPONENTIAL_PATTERN" value="65795"/>
+  <define name="U_MULTIPLE_PERCENT_SYMBOLS" value="65796"/>
+  <define name="U_MULTIPLE_PERMILL_SYMBOLS" value="65797"/>
+  <define name="U_MULTIPLE_PAD_SPECIFIERS" value="65798"/>
+  <define name="U_PATTERN_SYNTAX_ERROR" value="65799"/>
+  <define name="U_ILLEGAL_PAD_POSITION" value="65800"/>
+  <define name="U_UNMATCHED_BRACES" value="65801"/>
+  <define name="U_UNSUPPORTED_PROPERTY" value="65802"/>
+  <define name="U_UNSUPPORTED_ATTRIBUTE" value="65803"/>
+  <define name="U_ARGUMENT_TYPE_MISMATCH" value="65804"/>
+  <define name="U_DUPLICATE_KEYWORD" value="65805"/>
+  <define name="U_UNDEFINED_KEYWORD" value="65806"/>
+  <define name="U_DEFAULT_KEYWORD_MISSING" value="65807"/>
+  <define name="U_DECIMAL_NUMBER_SYNTAX_ERROR" value="65808"/>
+  <define name="U_FORMAT_INEXACT_ERROR" value="65809"/>
+  <define name="U_NUMBER_ARG_OUTOFBOUNDS_ERROR" value="65810"/>
+  <define name="U_NUMBER_SKELETON_SYNTAX_ERROR" value="65811"/>
+  <define name="U_MF_UNRESOLVED_VARIABLE_ERROR" value="65812"/>
+  <define name="U_MF_SYNTAX_ERROR" value="65813"/>
+  <define name="U_MF_UNKNOWN_FUNCTION_ERROR" value="65814"/>
+  <define name="U_MF_VARIANT_KEY_MISMATCH_ERROR" value="65815"/>
+  <define name="U_MF_FORMATTING_ERROR" value="65816"/>
+  <define name="U_MF_NONEXHAUSTIVE_PATTERN_ERROR" value="65817"/>
+  <define name="U_MF_DUPLICATE_OPTION_NAME_ERROR" value="65818"/>
+  <define name="U_MF_SELECTOR_ERROR" value="65819"/>
+  <define name="U_MF_MISSING_SELECTOR_ANNOTATION_ERROR" value="65820"/>
+  <define name="U_MF_DUPLICATE_DECLARATION_ERROR" value="65821"/>
+  <define name="U_MF_OPERAND_MISMATCH_ERROR" value="65822"/>
+  <define name="U_MF_UNSUPPORTED_STATEMENT_ERROR" value="65823"/>
+  <define name="U_MF_UNSUPPORTED_EXPRESSION_ERROR" value="65824"/>
+  <define name="U_FMT_PARSE_ERROR_LIMIT" value="0x10121"/>
+  <define name="U_BRK_INTERNAL_ERROR" value="0x10200"/>
+  <define name="U_BRK_ERROR_START" value="0x10200"/>
+  <define name="U_BRK_HEX_DIGITS_EXPECTED" value="66049"/>
+  <define name="U_BRK_SEMICOLON_EXPECTED" value="66050"/>
+  <define name="U_BRK_RULE_SYNTAX" value="66051"/>
+  <define name="U_BRK_UNCLOSED_SET" value="66052"/>
+  <define name="U_BRK_ASSIGN_ERROR" value="66053"/>
+  <define name="U_BRK_VARIABLE_REDFINITION" value="66054"/>
+  <define name="U_BRK_MISMATCHED_PAREN" value="66055"/>
+  <define name="U_BRK_NEW_LINE_IN_QUOTED_STRING" value="66056"/>
+  <define name="U_BRK_UNDEFINED_VARIABLE" value="66057"/>
+  <define name="U_BRK_INIT_ERROR" value="66058"/>
+  <define name="U_BRK_RULE_EMPTY_SET" value="66059"/>
+  <define name="U_BRK_UNRECOGNIZED_OPTION" value="66060"/>
+  <define name="U_BRK_MALFORMED_RULE_TAG" value="66061"/>
+  <define name="U_BRK_ERROR_LIMIT" value="66062"/>
+  <define name="U_REGEX_INTERNAL_ERROR" value="0x10300"/>
+  <define name="U_REGEX_ERROR_START" value="0x10300"/>
+  <define name="U_REGEX_RULE_SYNTAX" value="66305"/>
+  <define name="U_REGEX_INVALID_STATE" value="66306"/>
+  <define name="U_REGEX_BAD_ESCAPE_SEQUENCE" value="66307"/>
+  <define name="U_REGEX_PROPERTY_SYNTAX" value="66308"/>
+  <define name="U_REGEX_UNIMPLEMENTED" value="66309"/>
+  <define name="U_REGEX_MISMATCHED_PAREN" value="66310"/>
+  <define name="U_REGEX_NUMBER_TOO_BIG" value="66311"/>
+  <define name="U_REGEX_BAD_INTERVAL" value="66312"/>
+  <define name="U_REGEX_MAX_LT_MIN" value="66313"/>
+  <define name="U_REGEX_INVALID_BACK_REF" value="66314"/>
+  <define name="U_REGEX_INVALID_FLAG" value="66315"/>
+  <define name="U_REGEX_LOOK_BEHIND_LIMIT" value="66316"/>
+  <define name="U_REGEX_SET_CONTAINS_STRING" value="66317"/>
+  <define name="U_REGEX_OCTAL_TOO_BIG" value="66318"/>
+  <define name="U_REGEX_MISSING_CLOSE_BRACKET" value="U_REGEX_SET_CONTAINS_STRING+2"/>
+  <define name="U_REGEX_INVALID_RANGE" value="66319"/>
+  <define name="U_REGEX_STACK_OVERFLOW" value="66320"/>
+  <define name="U_REGEX_TIME_OUT" value="66321"/>
+  <define name="U_REGEX_STOPPED_BY_CALLER" value="66322"/>
+  <define name="U_REGEX_PATTERN_TOO_BIG" value="66323"/>
+  <define name="U_REGEX_INVALID_CAPTURE_GROUP_NAME" value="66324"/>
+  <define name="U_REGEX_ERROR_LIMIT" value="U_REGEX_STOPPED_BY_CALLER+3"/>
+  <define name="U_IDNA_PROHIBITED_ERROR" value="0x10400"/>
+  <define name="U_IDNA_ERROR_START" value="0x10400"/>
+  <define name="U_IDNA_UNASSIGNED_ERROR" value="66561"/>
+  <define name="U_IDNA_CHECK_BIDI_ERROR" value="66562"/>
+  <define name="U_IDNA_STD3_ASCII_RULES_ERROR" value="66563"/>
+  <define name="U_IDNA_ACE_PREFIX_ERROR" value="66564"/>
+  <define name="U_IDNA_VERIFICATION_ERROR" value="66565"/>
+  <define name="U_IDNA_LABEL_TOO_LONG_ERROR" value="66566"/>
+  <define name="U_IDNA_ZERO_LENGTH_LABEL_ERROR" value="66567"/>
+  <define name="U_IDNA_DOMAIN_NAME_TOO_LONG_ERROR" value="66568"/>
+  <define name="U_IDNA_ERROR_LIMIT" value="66569"/>
+  <define name="U_STRINGPREP_PROHIBITED_ERROR" value="0x10400"/>
+  <define name="U_STRINGPREP_UNASSIGNED_ERROR" value="66561"/>
+  <define name="U_STRINGPREP_CHECK_BIDI_ERROR" value="66562"/>
+  <define name="U_PLUGIN_ERROR_START" value="0x10500"/>
+  <define name="U_PLUGIN_TOO_HIGH" value="0x10500"/>
+  <define name="U_PLUGIN_DIDNT_SET_LEVEL" value="66817"/>
+  <define name="U_PLUGIN_ERROR_LIMIT" value="66818"/>
+  <define name="U_ERROR_LIMIT" value="66818"/>
+  <!-- utf8.h -->
+  <!-- https://unicode-org.github.io/icu-docs/apidoc/dev/icu4c/utf_8h.html#a7d794df2276384e748f2836b25b58f7d -->
+  <define name="U_IS_SURROGATE_TRAIL(c)" value="(((c)&amp;0x400)!=0)"/>
+  <define name="U_IS_SURROGATE(c)" value="(((c)&amp;0xfffff800)==0xd800)"/>
+  <define name="U_IS_TRAIL(c)" value="(((c)&amp;0xfffffc00)==0xdc00)"/>
+  <define name="U_IS_SURROGATE_LEAD(c)" value="(((c)&amp;0x400)==0)"/>
+  <define name="U_IS_LEAD(c)" value="(((c)&amp;0xfffffc00)==0xd800)"/>
+  <define name="U_IS_SUPPLEMENTARY(c)" value="((uint32_t)((c)-0x10000)&lt;=0xfffff)"/>
+  <define name="U_IS_BMP(c)" value="((uint32_t)(c)&lt;=0xffff)"/>
+  <define name="U_IS_UNICODE_CHAR(c)" value="((uint32_t)(c)&lt;0xd800||(0xdfff&lt;(c)&amp;&amp;(c)&lt;=0x10ffff&amp;&amp;!U_IS_UNICODE_NONCHAR(c))"/>
+  <define name="U_IS_UNICODE_NONCHAR(c)" value="((c)&gt;=0xfdd0&amp;&amp;((c)&lt;=0xfdef||((c)&amp;0xfffe)==0xfffe)&amp;&amp;(c)&lt;=0x10ffff)"/> 
+</def>
diff --git a/cfg/kde.cfg b/cfg/kde.cfg
new file mode 100644
index 00000000000..1131d5e0c50
--- /dev/null
+++ b/cfg/kde.cfg
@@ -0,0 +1,92 @@
+<?xml version="1.0"?>
+<def format="2">
+  <!-- KDE Library Configuration https://kde.org -->
+  <!-- The KDE library is typically not included by one specific header file, there are many -->
+  <!-- different ones, like for Qt. Examples: "#include <KApplication>" or "#include <KMessageBox>" -->
+  <!-- ########## KDE Types ########## -->
+  <!-- ########## KDE Macros / Defines ########## -->
+  <define name="K_GLOBAL_STATIC_STRUCT_NAME(NAME)" value="_k_##NAME##__LINE__"/>
+  <define name="K_GLOBAL_STATIC(TYPE, NAME)" value="K_GLOBAL_STATIC_WITH_ARGS(TYPE, NAME, ())"/>
+  <define name="K_GLOBAL_STATIC_WITH_ARGS(TYPE, NAME, ARGS)" value="static struct K_GLOBAL_STATIC_STRUCT_NAME(NAME) NAME;"/>
+  <define name="KDE_ISLIKELY(x)" value="(x)"/>
+  <define name="KDE_ISUNLIKELY(x)" value="(x)"/>
+  <define name="KDE_IS_VERSION(a, b, c)" value="( KDE_VERSION &gt;= KDE_MAKE_VERSION(a,b,c) )"/>
+  <define name="KDE_EXPORT" value=""/>
+  <define name="KDE_IMPORT" value=""/>
+  <define name="KDE_MAKE_VERSION(a, b, c)" value="(((a) &lt;&lt; 16) | ((b) &lt;&lt; 8) | (c))"/>
+  <define name="KDE_MUST_USE_RESULT" value="__attribute__((__warn_unused_result__))"/>
+  <define name="KDE_NO_DEPRECATED" value=""/>
+  <define name="KDE_NO_EXPORT" value=""/>
+  <define name="KDE_PACKED" value=""/>
+  <define name="KDE_VERSION" value="KDE_MAKE_VERSION(KDE_VERSION_MAJOR,KDE_VERSION_MINOR,KDE_VERSION_RELEASE)"/>
+  <define name="KDE_WEAK_SYMBOL" value=""/>
+  <define name="K_PLUGIN_CLASS_WITH_JSON(class_name, json_name)" value=""/>
+  <define name="K_PLUGIN_CLASS(class_name)" value=""/>
+  <define name="K_PLUGIN_FACTORY(class_name, ...)" value=""/>
+  <define name="K_PLUGIN_FACTORY_WITH_JSON(class_name, json_name, ...)" value=""/>
+  <define name="EXPORT_KONTACT_PLUGIN_WITH_JSON(class_name, json_name)" value=""/>
+  <!-- ########## KDE Allocation / Deallocation ########## -->
+  <!-- ########## KDE Functions ########## -->
+  <!-- template<typename T > T KConfigGroup::readEntry ( const QString & key, const T & aDefault ) const -->
+  <!-- template<typename T > T KConfigGroup::readEntry ( const char * key, const T & aDefault ) const -->
+  <!-- QVariant KConfigGroup::readEntry ( const QString & key, const QVariant & aDefault ) const -->
+  <!-- QVariant KConfigGroup::readEntry ( const char * key, const QVariant & aDefault ) const -->
+  <!-- QString KConfigGroup::readEntry ( const QString & key, const QString & aDefault ) const -->
+  <!-- QString KConfigGroup::readEntry ( const char * key, const QString & aDefault ) const -->
+  <!-- QString KConfigGroup::readEntry ( const QString & key, const char * aDefault = 0 ) const -->
+  <!-- QString KConfigGroup::readEntry ( const char * key, const char * aDefault = 0 ) const -->
+  <!-- QVariantList KConfigGroup::readEntry ( const QString & key, const QVariantList & aDefault ) const -->
+  <!-- QVariantList KConfigGroup::readEntry ( const char * key, const QVariantList & aDefault ) const -->
+  <!-- QStringList KConfigGroup::readEntry ( const QString & key, const QStringList & aDefault ) const -->
+  <!-- QStringList KConfigGroup::readEntry ( const char * key, const QStringList & aDefault ) const -->
+  <!-- template<typename T > QList<T> KConfigGroup::readEntry ( const QString & key, const QList< T > & aDefault ) const -->
+  <!-- template<typename T > QList<T> KConfigGroup::readEntry ( const char * key, const QList< T > & aDefault ) const -->
+  <function name="KConfigGroup::readEntry">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in" default="0">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- QString i18n(const char*) -->
+  <!-- QString xi18n(const char*) -->
+  <function name="i18n,xi18n">
+    <noreturn>false</noreturn>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="QString"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- KLocalizedString ki18n(const char*) -->
+  <function name="ki18n">
+    <noreturn>false</noreturn>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="KLocalizedString"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- QString i18nc(const char*, const char*) -->
+  <!-- QString xi18nc(const char*, const char*) -->
+  <function name="i18nc,xi18nc">
+    <noreturn>false</noreturn>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="QString"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- KLocalizedString ki18nc(const char*, const char*) -->
+  <function name="ki18nc">
+    <noreturn>false</noreturn>
+    <pure/>
+    <leak-ignore/>
+    <returnValue type="KLocalizedString"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+</def>
diff --git a/cfg/libcerror.cfg b/cfg/libcerror.cfg
index 0bdd0874eb8..ce621e99d44 100644
--- a/cfg/libcerror.cfg
+++ b/cfg/libcerror.cfg
@@ -125,4 +125,79 @@
       <strz/>
     </arg>
   </function>
+  <!-- enum LIBCERROR_ERROR_DOMAINS: -->
+  <define name="LIBCERROR_ERROR_DOMAIN_ARGUMENTS" value="(int)&apos;a&apos;"/>
+  <define name="LIBCERROR_ERROR_DOMAIN_CONVERSION" value="(int)&apos;c&apos;"/>
+  <define name="LIBCERROR_ERROR_DOMAIN_COMPRESSION" value="(int)&apos;C&apos;"/>
+  <define name="LIBCERROR_ERROR_DOMAIN_ENCRYPTION" value="(int)&apos;E&apos;"/>
+  <define name="LIBCERROR_ERROR_DOMAIN_IO" value="(int)&apos;I&apos;"/>
+  <define name="LIBCERROR_ERROR_DOMAIN_INPUT" value="(int)&apos;i&apos;"/>
+  <define name="LIBCERROR_ERROR_DOMAIN_MEMORY" value="(int)&apos;m&apos;"/>
+  <define name="LIBCERROR_ERROR_DOMAIN_OUTPUT" value="(int)&apos;o&apos;"/>
+  <define name="LIBCERROR_ERROR_DOMAIN_RUNTIME" value="(int)&apos;r&apos;"/>
+  <!-- enum LIBCERROR_ARGUMENT_ERROR: -->
+  <define name="LIBCERROR_ARGUMENT_ERROR_GENERIC" value="0"/>
+  <define name="LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE" value="1"/>
+  <define name="LIBCERROR_ARGUMENT_ERROR_VALUE_LESS_THAN_ZERO" value="2"/>
+  <define name="LIBCERROR_ARGUMENT_ERROR_VALUE_ZERO_OR_LESS" value="3"/>
+  <define name="LIBCERROR_ARGUMENT_ERROR_VALUE_EXCEEDS_MAXIMUM" value="4"/>
+  <define name="LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_SMALL" value="5"/>
+  <define name="LIBCERROR_ARGUMENT_ERROR_VALUE_TOO_LARGE" value="6"/>
+  <define name="LIBCERROR_ARGUMENT_ERROR_VALUE_OUT_OF_BOUNDS" value="7"/>
+  <define name="LIBCERROR_ARGUMENT_ERROR_UNSUPPORTED_VALUE" value="8"/>
+  <define name="LIBCERROR_ARGUMENT_ERROR_CONFLICTING_VALUE" value="9"/>
+  <!-- enum LIBCERROR_CONVERSION_ERROR: -->
+  <define name="LIBCERROR_CONVERSION_ERROR_GENERIC" value="0"/>
+  <define name="LIBCERROR_CONVERSION_ERROR_INPUT_FAILED" value="1"/>
+  <define name="LIBCERROR_CONVERSION_ERROR_OUTPUT_FAILED" value="2"/>
+  <!-- enum LIBCERROR_COMPRESSION_ERROR: -->
+  <define name="LIBCERROR_COMPRESSION_ERROR_GENERIC" value="0"/>
+  <define name="LIBCERROR_COMPRESSION_ERROR_COMPRESS_FAILED" value="1"/>
+  <define name="LIBCERROR_COMPRESSION_ERROR_DECOMPRESS_FAILED" value="2"/>
+  <!-- enum LIBCERROR_ENCRYPTION_ERROR: -->
+  <define name="LIBCERROR_ENCRYPTION_ERROR_GENERIC" value="0"/>
+  <define name="LIBCERROR_ENCRYPTION_ERROR_ENCRYPT_FAILED" value="1"/>
+  <define name="LIBCERROR_ENCRYPTION_ERROR_DECRYPT_FAILED" value="2"/>
+  <!-- enum LIBCERROR_IO_ERROR: -->
+  <define name="LIBCERROR_IO_ERROR_GENERIC" value="0"/>
+  <define name="LIBCERROR_IO_ERROR_OPEN_FAILED" value="1"/>
+  <define name="LIBCERROR_IO_ERROR_CLOSE_FAILED" value="2"/>
+  <define name="LIBCERROR_IO_ERROR_SEEK_FAILED" value="3"/>
+  <define name="LIBCERROR_IO_ERROR_READ_FAILED" value="4"/>
+  <define name="LIBCERROR_IO_ERROR_WRITE_FAILED" value="5"/>
+  <define name="LIBCERROR_IO_ERROR_ACCESS_DENIED" value="6"/>
+  <define name="LIBCERROR_IO_ERROR_INVALID_RESOURCE" value="7"/>
+  <define name="LIBCERROR_IO_ERROR_IOCTL_FAILED" value="8"/>
+  <define name="LIBCERROR_IO_ERROR_UNLINK_FAILED" value="9"/>
+  <!-- enum LIBCERROR_INPUT_ERROR: -->
+  <define name="LIBCERROR_INPUT_ERROR_GENERIC" value="0"/>
+  <define name="LIBCERROR_INPUT_ERROR_INVALID_DATA" value="1"/>
+  <define name="LIBCERROR_INPUT_ERROR_SIGNATURE_MISMATCH" value="2"/>
+  <define name="LIBCERROR_INPUT_ERROR_CHECKSUM_MISMATCH" value="3"/>
+  <define name="LIBCERROR_INPUT_ERROR_VALUE_MISMATCH" value="4"/>
+  <!-- enum LIBCERROR_MEMORY_ERROR: -->
+  <define name="LIBCERROR_MEMORY_ERROR_GENERIC" value="0"/>
+  <define name="LIBCERROR_MEMORY_ERROR_INSUFFICIENT" value="1"/>
+  <define name="LIBCERROR_MEMORY_ERROR_COPY_FAILED" value="2"/>
+  <define name="LIBCERROR_MEMORY_ERROR_SET_FAILED" value="3"/>
+  <!-- enum LIBCERROR_OUTPUT_ERROR: -->
+  <define name="LIBCERROR_OUTPUT_ERROR_GENERIC" value="0"/>
+  <define name="LIBCERROR_OUTPUT_ERROR_INSUFFICIENT_SPACE" value="1"/>
+  <!-- enum LIBCERROR_RUNTIME_ERROR: -->
+  <define name="LIBCERROR_RUNTIME_ERROR_GENERIC" value="0"/>
+  <define name="LIBCERROR_RUNTIME_ERROR_VALUE_MISSING" value="1"/>
+  <define name="LIBCERROR_RUNTIME_ERROR_VALUE_ALREADY_SET" value="2"/>
+  <define name="LIBCERROR_RUNTIME_ERROR_INITIALIZE_FAILED" value="3"/>
+  <define name="LIBCERROR_RUNTIME_ERROR_RESIZE_FAILED" value="4"/>
+  <define name="LIBCERROR_RUNTIME_ERROR_FINALIZE_FAILED" value="5"/>
+  <define name="LIBCERROR_RUNTIME_ERROR_GET_FAILED" value="6"/>
+  <define name="LIBCERROR_RUNTIME_ERROR_SET_FAILED" value="7"/>
+  <define name="LIBCERROR_RUNTIME_ERROR_APPEND_FAILED" value="8"/>
+  <define name="LIBCERROR_RUNTIME_ERROR_COPY_FAILED" value="9"/>
+  <define name="LIBCERROR_RUNTIME_ERROR_REMOVE_FAILED" value="10"/>
+  <define name="LIBCERROR_RUNTIME_ERROR_PRINT_FAILED" value="11"/>
+  <define name="LIBCERROR_RUNTIME_ERROR_VALUE_OUT_OF_BOUNDS" value="12"/>
+  <define name="LIBCERROR_RUNTIME_ERROR_VALUE_EXCEEDS_MAXIMUM" value="13"/>
+  <define name="LIBCERROR_RUNTIME_ERROR_UNSUPPORTED_VALUE" value="14"/>
+  <define name="LIBCERROR_RUNTIME_ERROR_ABORT_REQUESTED" value="15"/>
 </def>
diff --git a/cfg/libsigc++.cfg b/cfg/libsigc++.cfg
new file mode 100644
index 00000000000..f03804fa8e5
--- /dev/null
+++ b/cfg/libsigc++.cfg
@@ -0,0 +1,36 @@
+<?xml version="1.0"?>
+<def format="2">
+  <!-- libsigc++ Library Configuration https://libsigcplusplus.github.io/libsigcplusplus/ -->
+  <!-- On GitHub: https://github.com/libsigcplusplus/libsigcplusplus -->
+  <!-- Typically included via: "#include <sigc++/sigc++.h>" -->
+  <!-- ########## libsigc++ Types ########## -->
+  <!-- ########## libsigc++ Macros / Defines ########## -->
+  <!-- ########## libsigc++ Allocation / Deallocation ########## -->
+  <!-- ########## libsigc++ Functions ########## -->
+  <!-- sigc::mem_fun for libsigc++ 2.0: -->
+  <!-- template<class T_return , class T_obj >
+           mem_functor0< T_return, T_obj > sigc::mem_fun (T_return(T_obj::* _A_func)()) -->
+  <!-- template<class T_arg1 , class T_return , class T_obj >
+           mem_functor1< T_return, T_obj, T_arg1 > sigc::mem_fun (T_return(T_obj::* _A_func)(T_arg1)) -->
+  <!-- template<class T_arg1 , class T_arg2 , class T_return , class T_obj >
+           mem_functor2< T_return, T_obj, T_arg1, T_arg2 > sigc::mem_fun (T_return(T_obj::* _A_func)(T_arg1, T_arg2)) -->
+  <!-- and so on, until:
+       template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj >
+           mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > sigc::mem_fun (T_return(T_obj::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)) -->
+  <!-- template<class T_return , class T_obj , class T_obj2 >
+           bound_mem_functor0< T_return, T_obj > sigc::mem_fun (T_obj* _A_obj, T_return(T_obj2::* _A_func)()) -->
+  <!-- and so on, until:
+       template<class T_arg1 , class T_arg2 , class T_arg3 , class T_arg4 , class T_arg5 , class T_arg6 , class T_arg7 , class T_return , class T_obj , class T_obj2 >
+           bound_mem_functor7< T_return, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 > sigc::mem_fun (T_obj& _A_obj, T_return(T_obj2::* _A_func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7)) -->
+  <!-- sigc::mem_fun since libsigc++ 3.0 -->
+  <!-- template<typename T_return , typename T_obj , typename... T_arg>
+           decltype(auto) sigc::mem_fun (T_return(T_obj::* func)(T_arg...)) -->
+  <!-- template<typename T_return , typename T_obj , typename T_obj2 , typename... T_arg>
+           decltype(auto) sigc::mem_fun (T_obj& obj, T_return(T_obj2::* func)(T_arg...)) -->
+  <function name="sigc::mem_fun">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <arg nr="1"/>
+    <arg nr="2" default=""/>
+  </function>
+</def>
diff --git a/cfg/mfc.cfg b/cfg/mfc.cfg
index f1718dc41ac..1a8100f2ef0 100644
--- a/cfg/mfc.cfg
+++ b/cfg/mfc.cfg
@@ -1,5 +1,6 @@
 <?xml version="1.0"?>
 <def format="2">
+  <define name="DECLARE_MESSAGE_MAP()" value=""/>
   <define name="BEGIN_MESSAGE_MAP(x,y)" value=""/>
   <define name="BEGIN_TEMPLATE_MESSAGE_MAP(x,y,z)" value=""/>
   <define name="ON_COMMAND(x,y)" value=""/>
@@ -252,4 +253,19 @@
   <define name="ON_THREAD_MESSAGE(x,y)" value=""/>
   <define name="ON_REGISTERED_THREAD_MESSAGE(x,y)" value=""/>
   <define name="END_MESSAGE_MAP()" value=""/>
+  <define name="DECLARE_DYNAMIC(x)" value=""/>
+  <define name="IMPLEMENT_DYNAMIC(x,y)" value=""/>
+  <define name="DECLARE_DYNCREATE(x)" value=""/>
+  <define name="IMPLEMENT_DYNCREATE(x,y)" value=""/>
+  <define name="DECLARE_SERIAL(x)" value=""/>
+  <define name="IMPLEMENT_SERIAL(x,y,z)" value=""/>
+  <define name="DECLARE_EVENTSINK_MAP()" value=""/>
+  <define name="END_EVENTSINK_MAP()" value=""/>
+  <define name="BEGIN_EVENTSINK_MAP(x,y)" value=""/>
+  <define name="ON_EVENT(a,b,c,d,e)" value=""/>
+  <define name="ON_EVENT_RANGE(a,b,c,d,e,f)" value=""/>
+  <define name="ON_EVENT_REFLECT(a,b,c,d)" value=""/>
+  <define name="ON_PROPNOTIFY(a,b,c,d,e)" value=""/>
+  <define name="ON_PROPNOTIFY_RANGE(a,b,c,d,e,f)" value=""/>
+  <define name="ON_PROPNOTIFY_REFLECT(a,b,c,d)" value=""/>
 </def>
diff --git a/cfg/microsoft_atl.cfg b/cfg/microsoft_atl.cfg
index 05e26a90b03..3cd784bbf70 100644
--- a/cfg/microsoft_atl.cfg
+++ b/cfg/microsoft_atl.cfg
@@ -3,6 +3,11 @@
   <!-- Microsoft Windows ATL (Active Template Library) https://docs.microsoft.com/en-us/cpp/atl/atl-com-desktop-components -->
   <define name="BEGIN_COM_MAP(x)" value=""/>
   <define name="END_COM_MAP()" value=""/>
+  <define name="BEGIN_MSG_MAP(x)" value=""/>
+  <define name="MESSAGE_HANDLER(msg, func)" value=""/>
+  <define name="COMMAND_HANDLER(id, code, func)" value=""/>
+  <define name="CHAIN_MSG_MAP(theChainClass)" value=""/>
+  <define name="END_MSG_MAP()" value=""/>
   <define name="COM_INTERFACE_ENTRY(x)" value=""/>
   <define name="COM_INTERFACE_ENTRY2(x, x2)" value=""/>
   <define name="COM_INTERFACE_ENTRY_IID(iid, x)" value=""/>
@@ -20,8 +25,16 @@
   <define name="COM_INTERFACE_ENTRY_NOINTERFACE(x)" value=""/>
   <define name="DECLARE_LIBID(libid)" value=""/>
   <define name="DECLARE_NO_REGISTRY()" value=""/>
+  <define name="DECLARE_NOT_AGGREGATABLE(x)" value=""/>
+  <define name="DECLARE_OBJECT_DESCRIPTION(x)" value=""/>
+  <define name="DECLARE_PROTECT_FINAL_CONSTRUCT()" value=""/>
   <define name="DECLARE_REGISTRY(class,pid,vpid,nid,flags)" value=""/>
   <define name="DECLARE_REGISTRY_APPID_RESOURCEID(resid,appid)" value=""/>
   <define name="DECLARE_REGISTRY_RESOURCE(x)" value=""/>
   <define name="DECLARE_REGISTRY_RESOURCEID(x)" value=""/>
+  <define name="STDMETHOD(method)" value="HRESULT STDMETHODCALLTYPE method"/>
+  <define name="STDMETHOD_(type,method)" value="type STDMETHODCALLTYPE method"/>
+  <define name="IFACEMETHOD(method)" value="STDMETHOD(method)"/>
+  <define name="IFACEMETHOD_(type,method)" value="STDMETHOD_(type,method)"/>
+  <define name="OBJECT_ENTRY_AUTO(clsid, class)" value=""/>
 </def>
diff --git a/cfg/microsoft_sal.cfg b/cfg/microsoft_sal.cfg
index 82d4c23c4fa..36371a3610b 100644
--- a/cfg/microsoft_sal.cfg
+++ b/cfg/microsoft_sal.cfg
@@ -131,7 +131,7 @@
   <define name="_Return_type_success_(expr)" value=""/>
   <define name="_Success_(expr)" value=""/>
   <!-- Struct and Class Annotations -->
-  <define name="_Field_range_(low, high)" value=""/>
+  <define name="_Field_range_(low, high)" value="__cppcheck_low__(low) __cppcheck_high__(high)"/>
   <define name="_Field_size_(size)" value=""/>
   <define name="_Field_size_opt_(size)" value=""/>
   <define name="_Field_size_bytes_(size)" value=""/>
@@ -338,7 +338,6 @@
   <define name="__blocksOn(resource)" value=""/>
   <define name="__callback" value=""/>
   <define name="__checkReturn" value=""/>
-  <define name="__format_string" value=""/>
   <define name="__in_awcount(expr,size)" value=""/>
   <define name="__nullnullterminated" value=""/>
   <define name="__nullterminated" value=""/>
diff --git a/cfg/microsoft_unittest.cfg b/cfg/microsoft_unittest.cfg
new file mode 100644
index 00000000000..35c9c5a9a37
--- /dev/null
+++ b/cfg/microsoft_unittest.cfg
@@ -0,0 +1,20 @@
+<?xml version="1.0"?>
+<def format="2">
+  <define name="TEST_CLASS(className)" value="class className : public ::Microsoft::VisualStudio::CppUnitTestFramework::TestClass&lt;className&gt;"/>
+  <define name="TEST_METHOD(methodName)" value="void methodName()"/>
+  <define name="TEST_MODULE_INITIALIZE(methodName)" value="void methodName()"/>
+  <define name="TEST_MODULE_CLEANUP(methodName)" value="void methodName()"/>
+  <define name="TEST_CLASS_INITIALIZE(methodName)" value="static void methodName()"/>
+  <define name="TEST_CLASS_CLEANUP(methodName)" value="static void methodName()"/>
+  <define name="TEST_METHOD_INITIALIZE(methodName)" value="void methodName()"/>
+  <define name="TEST_METHOD_CLEANUP(methodName)" value="void methodName()"/>
+  <define name="BEGIN_TEST_CLASS_ATTRIBUTE()" value=""/>
+  <define name="TEST_CLASS_ATTRIBUTE(attributeName, attributeValue)" value=""/>
+  <define name="END_TEST_CLASS_ATTRIBUTE()" value=""/>
+  <define name="BEGIN_TEST_METHOD_ATTRIBUTE(methodName)" value=""/>
+  <define name="TEST_METHOD_ATTRIBUTE(attributeName, attributeValue)" value=""/>
+  <define name="END_TEST_METHOD_ATTRIBUTE()" value=""/>
+  <define name="BEGIN_TEST_MODULE_ATTRIBUTE()" value=""/>
+  <define name="TEST_MODULE_ATTRIBUTE(attributeName, attributeValue)" value=""/>
+  <define name="END_TEST_MODULE_ATTRIBUTE()" value=""/>
+</def>
diff --git a/cfg/motif.cfg b/cfg/motif.cfg
index 4654fac54eb..f4221a23018 100644
--- a/cfg/motif.cfg
+++ b/cfg/motif.cfg
@@ -160,9 +160,7 @@
   <function name="XtSetArg">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1">
-      <not-uninit/>
-    </arg>
+    <arg nr="1"/>
     <arg nr="2">
       <not-uninit/>
       <strz/>
diff --git a/cfg/ntl.cfg b/cfg/ntl.cfg
new file mode 100644
index 00000000000..6c42dfb09a1
--- /dev/null
+++ b/cfg/ntl.cfg
@@ -0,0 +1,6907 @@
+<?xml version="1.0"?>
+<def format="2">
+  <!-- void Vec::AdjustAlloc( long n ) -->
+  <function name="Vec::AdjustAlloc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void Vec::AdjustLength( long n ) -->
+  <function name="Vec::AdjustLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void Vec::AdjustMaxLength( long n ) -->
+  <function name="Vec::AdjustMaxLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void Vec::AllocateTo( long n ) -->
+  <function name="Vec::AllocateTo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void Vec::BlockConstruct( T * p, long n ) -->
+  <function name="Vec::BlockConstruct">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void Vec::BlockConstructFromObj( T * p, long n, const T & q ) -->
+  <function name="Vec::BlockConstructFromObj">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void Vec::BlockConstructFromVec( T * p, long n, const T * q ) -->
+  <function name="Vec::BlockConstructFromVec">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void Vec::BlockDestroy( T * p, long n ) -->
+  <function name="Vec::BlockDestroy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void Vec::DoSetLengthAndApply( long n, F & f ) -->
+  <function name="Vec::DoSetLengthAndApply">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void Vec::FixAtCurrentLength( void ) -->
+  <function name="Vec::FixAtCurrentLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void Vec::FixLength( long n ) -->
+  <function name="Vec::FixLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void Vec::InitAndApply( long n, F & f ) -->
+  <function name="Vec::InitAndApply">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- long Vec::MaxLength( void ) -->
+  <function name="Vec::MaxLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void Vec::QuickSetLength( long n ) -->
+  <function name="Vec::QuickSetLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void Vec::SetLengthAndApply( long n, F f ) -->
+  <function name="Vec::SetLengthAndApply">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void Vec::SetMaxLength( long n ) -->
+  <function name="Vec::SetMaxLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void Vec::_vec_deleter::apply( T * p ) -->
+  <function name="Vec::_vec_deleter::apply">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- long Vec::allocated( void ) -->
+  <function name="Vec::allocated">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- long Vec::fixed( void ) -->
+  <function name="Vec::fixed">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void Vec::kill( void ) -->
+  <function name="Vec::kill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- long Vec::length( void ) -->
+  <function name="Vec::length">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- long Vec::position( const T & a ) const -->
+  <function name="Vec::position">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long Vec::position1( const T & a ) const -->
+  <function name="Vec::position1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void VecStrategy::do_BlockConstruct( T * p, long n ) -->
+  <function name="VecStrategy::do_BlockConstruct">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void VecStrategy::do_BlockConstruct( T * p, long n ) -->
+  <function name="VecStrategy::do_BlockConstruct">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void VecStrategy::do_BlockConstructFromObj( T * p, long n, const T & q ) -->
+  <function name="VecStrategy::do_BlockConstructFromObj">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void VecStrategy::do_BlockConstructFromObj( T * p, long n, const T & q ) -->
+  <function name="VecStrategy::do_BlockConstructFromObj">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void VecStrategy::do_BlockConstructFromVec( T * p, long n, const T * q ) -->
+  <function name="VecStrategy::do_BlockConstructFromVec">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void VecStrategy::do_BlockConstructFromVec( T * p, long n, const T * q ) -->
+  <function name="VecStrategy::do_BlockConstructFromVec">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void VecStrategy::do_BlockDestroy( T * p, long n ) -->
+  <function name="VecStrategy::do_BlockDestroy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void VecStrategy::do_BlockDestroy( T * p, long n ) -->
+  <function name="VecStrategy::do_BlockDestroy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long mat_ZZ_p_opaque::NumCols( void ) -->
+  <function name="mat_ZZ_p_opaque::NumCols">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- long mat_ZZ_p_opaque::NumRows( void ) -->
+  <function name="mat_ZZ_p_opaque::NumRows">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- bool mat_ZZ_p_opaque::initialized( void ) -->
+  <function name="mat_ZZ_p_opaque::initialized">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void mat_ZZ_p_opaque::move( mat_ZZ_p & A ) -->
+  <function name="mat_ZZ_p_opaque::move">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- long LazyTable::Builder::amt( void ) -->
+  <function name="LazyTable::Builder::amt">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void LazyTable::Builder::move( UniquePtr<T> & p ) -->
+  <function name="LazyTable::Builder::move">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- long LazyTable::length( void ) -->
+  <function name="LazyTable::length">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- long xdouble::OutputPrecision( void ) -->
+  <function name="xdouble::OutputPrecision">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void xdouble::SetOutputPrecision( long p ) -->
+  <function name="xdouble::SetOutputPrecision">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long xdouble::exponent( void ) -->
+  <function name="xdouble::exponent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- double xdouble::mantissa( void ) -->
+  <function name="xdouble::mantissa">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void xdouble::normalize( void ) -->
+  <function name="xdouble::normalize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GF2EX::SetLength( long n ) -->
+  <function name="GF2EX::SetLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GF2EX::SetMaxLength( long n ) -->
+  <function name="GF2EX::SetMaxLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GF2EX::kill( void ) -->
+  <function name="GF2EX::kill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GF2EX::normalize( void ) -->
+  <function name="GF2EX::normalize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GF2EX::swap( GF2EX & x ) -->
+  <function name="GF2EX::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- long ZZVec::BaseSize( void ) -->
+  <function name="ZZVec::BaseSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void ZZVec::SetSize( long n, long d ) -->
+  <function name="ZZVec::SetSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void ZZVec::kill( void ) -->
+  <function name="ZZVec::kill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- long ZZVec::length( void ) -->
+  <function name="ZZVec::length">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void ZZVec::move( ZZVec & other ) -->
+  <function name="ZZVec::move">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void ZZVec::swap( ZZVec & x ) -->
+  <function name="ZZVec::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void WordVector::DoSetLength( long n ) -->
+  <function name="WordVector::DoSetLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void WordVector::KillBig( void ) -->
+  <function name="WordVector::KillBig">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- long WordVector::MaxLength( void ) -->
+  <function name="WordVector::MaxLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void WordVector::QuickSetLength( long n ) -->
+  <function name="WordVector::QuickSetLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void WordVector::SetLength( long n ) -->
+  <function name="WordVector::SetLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void WordVector::SetMaxLength( long n ) -->
+  <function name="WordVector::SetMaxLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void WordVector::ZeroLength( void ) -->
+  <function name="WordVector::ZeroLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- const _ntl_ulong * WordVector::elts( void ) -->
+  <function name="WordVector::elts">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const _ntl_ulong *"/>
+    <use-retval/>
+  </function>
+  <!-- _ntl_ulong * WordVector::elts( void ) -->
+  <function name="WordVector::elts">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="_ntl_ulong *"/>
+    <use-retval/>
+  </function>
+  <!-- void WordVector::kill( void ) -->
+  <function name="WordVector::kill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- long WordVector::length( void ) -->
+  <function name="WordVector::length">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- bool WordVector::pinned( void ) -->
+  <function name="WordVector::pinned">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void WordVector::swap( WordVector & y ) -->
+  <function name="WordVector::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void WordVector::unpinned_move( WordVector & other ) -->
+  <function name="WordVector::unpinned_move">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void WordVector::unpinned_swap( WordVector & other ) -->
+  <function name="WordVector::unpinned_swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void DummyScopeGuard::relax( void ) -->
+  <function name="DummyScopeGuard::relax">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void WrappedPtr::kill( void ) -->
+  <function name="WrappedPtr::kill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void WrappedPtr::move( WrappedPtr & other ) -->
+  <function name="WrappedPtr::move">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void WrappedPtr::swap( WrappedPtr & other ) -->
+  <function name="WrappedPtr::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void scope_guard::relax( void ) -->
+  <function name="scope_guard::relax">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void FileList::AddFile( const char * name ) -->
+  <function name="FileList::AddFile">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void FileList::RemoveLast( void ) -->
+  <function name="FileList::RemoveLast">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void zz_pEX::SetLength( long n ) -->
+  <function name="zz_pEX::SetLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void zz_pEX::SetMaxLength( long n ) -->
+  <function name="zz_pEX::SetMaxLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void zz_pEX::kill( void ) -->
+  <function name="zz_pEX::kill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void zz_pEX::normalize( void ) -->
+  <function name="zz_pEX::normalize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void zz_pEX::swap( zz_pEX & x ) -->
+  <function name="zz_pEX::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- const zz_pEX & zz_pEX::zero( void ) -->
+  <function name="zz_pEX::zero">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const zz_pEX &amp;"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- const zz_pEX & zz_pEXModulus::val( void ) -->
+  <function name="zz_pEXModulus::val">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const zz_pEX &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- void AlignedArray::SetLength( long n ) -->
+  <function name="AlignedArray::SetLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool AlignedArray::cannot_compare_these_types( void ) -->
+  <function name="AlignedArray::cannot_compare_these_types">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void AlignedArray::move( AlignedArray & other ) -->
+  <function name="AlignedArray::move">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- char * AlignedArray::release( void ) -->
+  <function name="AlignedArray::release">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="char *"/>
+    <use-retval/>
+  </function>
+  <!-- void AlignedArray::swap( AlignedArray & other ) -->
+  <function name="AlignedArray::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void CloneablePtr::AddRef( void ) -->
+  <function name="CloneablePtr::AddRef">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void CloneablePtr::RemoveRef( void ) -->
+  <function name="CloneablePtr::RemoveRef">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- CloneablePtr CloneablePtr::clone( void ) -->
+  <function name="CloneablePtr::clone">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="CloneablePtr"/>
+    <use-retval/>
+  </function>
+  <!-- long CloneablePtr::get_count( void ) -->
+  <function name="CloneablePtr::get_count">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void CloneablePtr::swap( CloneablePtr & other ) -->
+  <function name="CloneablePtr::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- CloneablePtrControl * CloneablePtrControlDerived::clone( void ) -->
+  <function name="CloneablePtrControlDerived::clone">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="CloneablePtrControl *"/>
+    <use-retval/>
+  </function>
+  <!-- void * CloneablePtrControlDerived::get( void ) -->
+  <function name="CloneablePtrControlDerived::get">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void *"/>
+    <use-retval/>
+  </function>
+  <!-- bool CopiedPtr::cannot_compare_these_types( void ) -->
+  <function name="CopiedPtr::cannot_compare_these_types">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void CopiedPtr::make( void ) -->
+  <function name="CopiedPtr::make">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void CopiedPtr::move( CopiedPtr & other ) -->
+  <function name="CopiedPtr::move">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void CopiedPtr::reset( T * p = 0 ) -->
+  <function name="CopiedPtr::reset">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" default="0" direction="inout"/>
+  </function>
+  <!-- void CopiedPtr::swap( CopiedPtr & other ) -->
+  <function name="CopiedPtr::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void DefaultDeleterPolicy::deleter( T * p ) -->
+  <function name="DefaultDeleterPolicy::deleter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- CloneablePtrControl * MakeCloneableAux::clone( void ) -->
+  <function name="MakeCloneableAux::clone">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="CloneablePtrControl *"/>
+    <use-retval/>
+  </function>
+  <!-- void * MakeCloneableAux::get( void ) -->
+  <function name="MakeCloneableAux::get">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void *"/>
+    <use-retval/>
+  </function>
+  <!-- bool OptionalVal::exists( void ) -->
+  <function name="OptionalVal::exists">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void OptionalVal::make( void ) -->
+  <function name="OptionalVal::make">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void OptionalVal::move( OptionalVal & other ) -->
+  <function name="OptionalVal::move">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void OptionalVal::reset( T * p = 0 ) -->
+  <function name="OptionalVal::reset">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" default="0" direction="inout"/>
+  </function>
+  <!-- void OptionalVal::swap( OptionalVal & other ) -->
+  <function name="OptionalVal::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void SmartPtr::AddRef( void ) -->
+  <function name="SmartPtr::AddRef">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void SmartPtr::RemoveRef( void ) -->
+  <function name="SmartPtr::RemoveRef">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- long SmartPtr::get_count( void ) -->
+  <function name="SmartPtr::get_count">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void SmartPtr::swap( SmartPtr & other ) -->
+  <function name="SmartPtr::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void Unique2DArray::SetDims( long n, long m ) -->
+  <function name="Unique2DArray::SetDims">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void Unique2DArray::SetDimsFrom1( long n, long m ) -->
+  <function name="Unique2DArray::SetDimsFrom1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void Unique2DArray::SetLength( long n ) -->
+  <function name="Unique2DArray::SetLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool Unique2DArray::cannot_compare_these_types( void ) -->
+  <function name="Unique2DArray::cannot_compare_these_types">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- T_ptr * Unique2DArray::get( void ) -->
+  <function name="Unique2DArray::get">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="T_ptr *"/>
+    <use-retval/>
+  </function>
+  <!-- void Unique2DArray::move( Unique2DArray & other ) -->
+  <function name="Unique2DArray::move">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- T_ptr * Unique2DArray::release( void ) -->
+  <function name="Unique2DArray::release">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="T_ptr *"/>
+    <use-retval/>
+  </function>
+  <!-- void Unique2DArray::reset( void ) -->
+  <function name="Unique2DArray::reset">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void Unique2DArray::swap( Unique2DArray & other ) -->
+  <function name="Unique2DArray::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void UniqueArray::SetLength( long n ) -->
+  <function name="UniqueArray::SetLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool UniqueArray::cannot_compare_these_types( void ) -->
+  <function name="UniqueArray::cannot_compare_these_types">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void UniqueArray::move( UniqueArray & other ) -->
+  <function name="UniqueArray::move">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void UniqueArray::reset( T * p = 0 ) -->
+  <function name="UniqueArray::reset">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" default="0" direction="inout"/>
+  </function>
+  <!-- void UniqueArray::swap( UniqueArray & other ) -->
+  <function name="UniqueArray::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool UniquePtr::cannot_compare_these_types( void ) -->
+  <function name="UniquePtr::cannot_compare_these_types">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void UniquePtr::make( void ) -->
+  <function name="UniquePtr::make">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void UniquePtr::move( UniquePtr & other ) -->
+  <function name="UniquePtr::move">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void UniquePtr::reset( T * p = 0 ) -->
+  <function name="UniquePtr::reset">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" default="0" direction="inout"/>
+  </function>
+  <!-- void UniquePtr::swap( UniquePtr & other ) -->
+  <function name="UniquePtr::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- double MatPrime_crt_helper::GetCost( void ) -->
+  <function name="MatPrime_crt_helper::GetCost">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double MatPrime_crt_helper::GetCost( void ) -->
+  <function name="MatPrime_crt_helper::GetCost">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- long MatPrime_crt_helper::GetNumPrimes( void ) -->
+  <function name="MatPrime_crt_helper::GetNumPrimes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- long MatPrime_crt_helper::GetNumPrimes( void ) -->
+  <function name="MatPrime_crt_helper::GetNumPrimes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void FFTMulTabsDeleterPolicy::deleter( FFTMulTabs * p ) -->
+  <function name="FFTMulTabsDeleterPolicy::deleter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void BasicThreadPool::CompositeSignal::send( T _val, T1 _val1 ) -->
+  <function name="BasicThreadPool::CompositeSignal::send">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- T BasicThreadPool::CompositeSignal::wait( T1 & _val1 ) -->
+  <function name="BasicThreadPool::CompositeSignal::wait">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="T"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- BasicThreadPool * BasicThreadPool::ConcurrentTask::getBasicThreadPool( void ) -->
+  <function name="BasicThreadPool::ConcurrentTask::getBasicThreadPool">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="BasicThreadPool *"/>
+    <use-retval/>
+  </function>
+  <!-- void BasicThreadPool::ConcurrentTaskFct1::run( long index ) -->
+  <function name="BasicThreadPool::ConcurrentTaskFct1::run">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void BasicThreadPool::ConcurrentTaskFct::run( long index ) -->
+  <function name="BasicThreadPool::ConcurrentTaskFct::run">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void BasicThreadPool::ConcurrentTaskTerminate::run( long index ) -->
+  <function name="BasicThreadPool::ConcurrentTaskTerminate::run">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long BasicThreadPool::NumThreads( void ) -->
+  <function name="BasicThreadPool::NumThreads">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void BasicThreadPool::SimpleSignal::send( T new_val ) -->
+  <function name="BasicThreadPool::SimpleSignal::send">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- T BasicThreadPool::SimpleSignal::wait( void ) -->
+  <function name="BasicThreadPool::SimpleSignal::wait">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="T"/>
+    <use-retval/>
+  </function>
+  <!-- bool BasicThreadPool::active( void ) -->
+  <function name="BasicThreadPool::active">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void BasicThreadPool::add( long n = 1 ) -->
+  <function name="BasicThreadPool::add">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" default="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void BasicThreadPool::begin( long cnt ) -->
+  <function name="BasicThreadPool::begin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void BasicThreadPool::end( void ) -->
+  <function name="BasicThreadPool::end">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void BasicThreadPool::exec_index( long cnt, const Fct & fct ) -->
+  <function name="BasicThreadPool::exec_index">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void BasicThreadPool::exec_range( long sz, const Fct & fct ) -->
+  <function name="BasicThreadPool::exec_range">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void BasicThreadPool::launch( ConcurrentTask * task, long index ) -->
+  <function name="BasicThreadPool::launch">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void BasicThreadPool::move( BasicThreadPool & other, long n = 1 ) -->
+  <function name="BasicThreadPool::move">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" default="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void BasicThreadPool::relaxed_exec_index( BasicThreadPool * pool, long cnt, const Fct & fct ) -->
+  <function name="BasicThreadPool::relaxed_exec_index">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void BasicThreadPool::relaxed_exec_range( BasicThreadPool * pool, long sz, const Fct & fct ) -->
+  <function name="BasicThreadPool::relaxed_exec_range">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void BasicThreadPool::remove( long n = 1 ) -->
+  <function name="BasicThreadPool::remove">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" default="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void BasicThreadPool::runOneTask( ConcurrentTask * task, long index ) -->
+  <function name="BasicThreadPool::runOneTask">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long PartitionInfo::NumIntervals( void ) -->
+  <function name="PartitionInfo::NumIntervals">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void PartitionInfo::interval( long & first, long & last, long i ) -->
+  <function name="PartitionInfo::interval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void RecursiveThreadPool::exec_pair( long mid, const Fct0 & fct0, const Fct1 & fct1 ) -->
+  <function name="RecursiveThreadPool::exec_pair">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- bool RecursiveThreadPoolHelper::concurrent( void ) -->
+  <function name="RecursiveThreadPoolHelper::concurrent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- RecursiveThreadPool * RecursiveThreadPoolHelper::subpool( long i ) -->
+  <function name="RecursiveThreadPoolHelper::subpool">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="RecursiveThreadPool *"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long ZZ_pE::DivCross( void ) -->
+  <function name="ZZ_pE::DivCross">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- ZZ_pX & ZZ_pE::LoopHole( void ) -->
+  <function name="ZZ_pE::LoopHole">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ZZ_pX &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- long ZZ_pE::ModCross( void ) -->
+  <function name="ZZ_pE::ModCross">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void ZZ_pE::allocate( void ) -->
+  <function name="ZZ_pE::allocate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- long ZZ_pE::degree( void ) -->
+  <function name="ZZ_pE::degree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void ZZ_pE::init( const ZZ_pX &  ) -->
+  <function name="ZZ_pE::init">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long ZZ_pE::initialized( void ) -->
+  <function name="ZZ_pE::initialized">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- const ZZ_pXModulus & ZZ_pE::modulus( void ) -->
+  <function name="ZZ_pE::modulus">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const ZZ_pXModulus &amp;"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void ZZ_pE::swap( ZZ_pE & x ) -->
+  <function name="ZZ_pE::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- const ZZ_pE & ZZ_pE::zero( void ) -->
+  <function name="ZZ_pE::zero">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const ZZ_pE &amp;"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void ZZ_pEBak::restore( void ) -->
+  <function name="ZZ_pEBak::restore">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void ZZ_pEBak::save( void ) -->
+  <function name="ZZ_pEBak::save">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void ZZ_pEContext::restore( void ) const -->
+  <function name="ZZ_pEContext::restore">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+  </function>
+  <!-- void ZZ_pEContext::save( void ) -->
+  <function name="ZZ_pEContext::save">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- long PrimeSeq::next( void ) -->
+  <function name="PrimeSeq::next">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void PrimeSeq::reset( long b ) -->
+  <function name="PrimeSeq::reset">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void PrimeSeq::start( void ) -->
+  <function name="PrimeSeq::start">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void RandomBndGenerator::build( long _p ) -->
+  <function name="RandomBndGenerator::build">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long RandomBndGenerator::next( void ) -->
+  <function name="RandomBndGenerator::next">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void RandomStream::get( unsigned char * res, long n ) -->
+  <function name="RandomStream::get">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void RandomStream::set_nonce( unsigned long nonce ) -->
+  <function name="RandomStream::set_nonce">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void RandomStream_impl_deleter::deleter( RandomStream_impl * p ) -->
+  <function name="RandomStream_impl_deleter::deleter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void ZZ::Deleter::apply( _ntl_gbigint p ) -->
+  <function name="ZZ::Deleter::apply">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void ZZ::KillBig( void ) -->
+  <function name="ZZ::KillBig">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- long ZZ::MaxAlloc( void ) -->
+  <function name="ZZ::MaxAlloc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void ZZ::SetSize( long k ) -->
+  <function name="ZZ::SetSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long ZZ::SinglePrecision( void ) -->
+  <function name="ZZ::SinglePrecision">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- long ZZ::WideSinglePrecision( void ) -->
+  <function name="ZZ::WideSinglePrecision">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void ZZ::kill( void ) -->
+  <function name="ZZ::kill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- long ZZ::null( void ) -->
+  <function name="ZZ::null">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- bool ZZ::pinned( void ) -->
+  <function name="ZZ::pinned">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- long ZZ::size( void ) -->
+  <function name="ZZ::size">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void ZZ::swap( ZZ & x ) -->
+  <function name="ZZ::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- long ZZ::validate( void ) -->
+  <function name="ZZ::validate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void ZZ_CRTStructAdapter::eval( ZZ & t, const long * a, ZZ_TmpVecAdapter & tmp_vec ) -->
+  <function name="ZZ_CRTStructAdapter::eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void ZZ_CRTStructAdapter::insert( long i, const ZZ & m ) -->
+  <function name="ZZ_CRTStructAdapter::insert">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool ZZ_CRTStructAdapter::special( void ) -->
+  <function name="ZZ_CRTStructAdapter::special">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void ZZ_ReduceStructAdapter::adjust( ZZ & x ) -->
+  <function name="ZZ_ReduceStructAdapter::adjust">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void ZZ_ReduceStructAdapter::eval( ZZ & x, ZZ & a ) -->
+  <function name="ZZ_ReduceStructAdapter::eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void ZZ_ReduceStructAdapter::init( const ZZ & p, const ZZ & excess ) -->
+  <function name="ZZ_ReduceStructAdapter::init">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void ZZ_RemStructAdapter::eval( long * x, const ZZ & a, ZZ_TmpVecAdapter & tmp_vec ) -->
+  <function name="ZZ_RemStructAdapter::eval">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void old_RandomStream::do_get( unsigned char * res, long n ) -->
+  <function name="old_RandomStream::do_get">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void old_RandomStream::get( unsigned char * res, long n ) -->
+  <function name="old_RandomStream::get">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void sp_ZZ_reduce_struct::build( long _p ) -->
+  <function name="sp_ZZ_reduce_struct::build">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long sp_ZZ_reduce_struct::rem( const ZZ & a ) -->
+  <function name="sp_ZZ_reduce_struct::rem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void sp_ZZ_reduce_struct_policy::deleter( _ntl_general_rem_one_struct * pinfo ) -->
+  <function name="sp_ZZ_reduce_struct_policy::deleter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void FFTRep::DoSetSize( long NewK, long NewNumPrimes ) -->
+  <function name="FFTRep::DoSetSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void FFTRep::SetSize( long NewK ) -->
+  <function name="FFTRep::SetSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void ZZ_pX::SetLength( long n ) -->
+  <function name="ZZ_pX::SetLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void ZZ_pX::SetMaxLength( long n ) -->
+  <function name="ZZ_pX::SetMaxLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void ZZ_pX::kill( void ) -->
+  <function name="ZZ_pX::kill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void ZZ_pX::normalize( void ) -->
+  <function name="ZZ_pX::normalize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void ZZ_pX::swap( ZZ_pX & x ) -->
+  <function name="ZZ_pX::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- const ZZ_pX & ZZ_pX::zero( void ) -->
+  <function name="ZZ_pX::zero">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const ZZ_pX &amp;"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void ZZ_pXModRep::SetSize( long NewN ) -->
+  <function name="ZZ_pXModRep::SetSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const ZZ_pX & ZZ_pXModulus::val( void ) -->
+  <function name="ZZ_pXModulus::val">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const ZZ_pX &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const ZZ_pX & ZZ_pXMultiplier::val( void ) -->
+  <function name="ZZ_pXMultiplier::val">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const ZZ_pX &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- PD PD::load( const double * p ) -->
+  <function name="PD::load">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="PD"/>
+    <pure/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- PD PD::load( const double * p ) -->
+  <function name="PD::load">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="PD"/>
+    <pure/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- PD PD::load( const double * p ) -->
+  <function name="PD::load">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="PD"/>
+    <pure/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- PD PD::loadu( const double * p ) -->
+  <function name="PD::loadu">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="PD"/>
+    <pure/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- PD PD::loadu( const double * p ) -->
+  <function name="PD::loadu">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="PD"/>
+    <pure/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- PD PD::loadu( const double * p ) -->
+  <function name="PD::loadu">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="PD"/>
+    <pure/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void fftRep::DoSetSize( long NewK, long NewNumPrimes ) -->
+  <function name="fftRep::DoSetSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void fftRep::SetSize( long NewK ) -->
+  <function name="fftRep::SetSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void zz_pX::SetLength( long n ) -->
+  <function name="zz_pX::SetLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void zz_pX::SetMaxLength( long n ) -->
+  <function name="zz_pX::SetMaxLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void zz_pX::kill( void ) -->
+  <function name="zz_pX::kill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void zz_pX::normalize( void ) -->
+  <function name="zz_pX::normalize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void zz_pX::swap( zz_pX & x ) -->
+  <function name="zz_pX::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- const zz_pX & zz_pX::zero( void ) -->
+  <function name="zz_pX::zero">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const zz_pX &amp;"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- const zz_pX & zz_pXModulus::val( void ) -->
+  <function name="zz_pXModulus::val">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const zz_pX &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const zz_pX & zz_pXMultiplier::val( void ) -->
+  <function name="zz_pXMultiplier::val">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const zz_pX &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- void ZZX::SetLength( long n ) -->
+  <function name="ZZX::SetLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void ZZX::SetMaxLength( long n ) -->
+  <function name="ZZX::SetMaxLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void ZZX::kill( void ) -->
+  <function name="ZZX::kill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void ZZX::normalize( void ) -->
+  <function name="ZZX::normalize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void ZZX::swap( ZZX & x ) -->
+  <function name="ZZX::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void Vec::FixAtCurrentLength( void ) -->
+  <function name="Vec::FixAtCurrentLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void Vec::FixLength( long n ) -->
+  <function name="Vec::FixLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long Vec::MaxLength( void ) -->
+  <function name="Vec::MaxLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void Vec::SetMaxLength( long n ) -->
+  <function name="Vec::SetMaxLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long Vec::allocated( void ) -->
+  <function name="Vec::allocated">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- ref_GF2 Vec::at( long i ) -->
+  <function name="Vec::at">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ref_GF2"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const_iterator Vec::begin( void ) -->
+  <function name="Vec::begin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const_iterator"/>
+    <use-retval/>
+  </function>
+  <!-- iterator Vec::begin( void ) -->
+  <function name="Vec::begin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="iterator"/>
+    <use-retval/>
+  </function>
+  <!-- const_iterator Vec::end( void ) -->
+  <function name="Vec::end">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const_iterator"/>
+    <use-retval/>
+  </function>
+  <!-- iterator Vec::end( void ) -->
+  <function name="Vec::end">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="iterator"/>
+    <use-retval/>
+  </function>
+  <!-- long Vec::fixed( void ) -->
+  <function name="Vec::fixed">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void Vec::kill( void ) -->
+  <function name="Vec::kill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- long Vec::length( void ) -->
+  <function name="Vec::length">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void Vec::proxy_iterator_impl::add( long x ) -->
+  <function name="Vec::proxy_iterator_impl::add">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void Vec::proxy_iterator_impl::dec( void ) -->
+  <function name="Vec::proxy_iterator_impl::dec">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- long Vec::proxy_iterator_impl::diff( const proxy_iterator_impl & other ) -->
+  <function name="Vec::proxy_iterator_impl::diff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool Vec::proxy_iterator_impl::eq( const proxy_iterator_impl & other ) -->
+  <function name="Vec::proxy_iterator_impl::eq">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void Vec::proxy_iterator_impl::inc( void ) -->
+  <function name="Vec::proxy_iterator_impl::inc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- ref_GF2 Vec::proxy_iterator_impl::make_ref_GF2( void ) -->
+  <function name="Vec::proxy_iterator_impl::make_ref_GF2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ref_GF2"/>
+    <use-retval/>
+  </function>
+  <!-- long RR::OutputPrecision( void ) -->
+  <function name="RR::OutputPrecision">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void RR::SetOutputPrecision( long p ) -->
+  <function name="RR::SetOutputPrecision">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void RR::SetPrecision( long p ) -->
+  <function name="RR::SetPrecision">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long RR::exponent( void ) -->
+  <function name="RR::exponent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- long RR::precision( void ) -->
+  <function name="RR::precision">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void RR::swap( RR & z ) -->
+  <function name="RR::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- long quad_float::OutputPrecision( void ) -->
+  <function name="quad_float::OutputPrecision">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void quad_float::SetOutputPrecision( long p ) -->
+  <function name="quad_float::SetOutputPrecision">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- unsigned long AtomicCounter::inc( void ) -->
+  <function name="AtomicCounter::inc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned long"/>
+    <use-retval/>
+  </function>
+  <!-- void AtomicLowWaterMark::UpdateMin( unsigned long val ) -->
+  <function name="AtomicLowWaterMark::UpdateMin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool AtomicRefCount::dec( void ) -->
+  <function name="AtomicRefCount::dec">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- long AtomicRefCount::get_count( void ) -->
+  <function name="AtomicRefCount::get_count">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void AtomicRefCount::inc( void ) -->
+  <function name="AtomicRefCount::inc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GuardProxy::lock( void ) -->
+  <function name="GuardProxy::lock">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- long GF2E::DivCross( void ) -->
+  <function name="GF2E::DivCross">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- long GF2E::GCDCross( void ) -->
+  <function name="GF2E::GCDCross">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- long GF2E::KarCross( void ) -->
+  <function name="GF2E::KarCross">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- long GF2E::ModCross( void ) -->
+  <function name="GF2E::ModCross">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- long GF2E::WordLength( void ) -->
+  <function name="GF2E::WordLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void GF2E::allocate( void ) -->
+  <function name="GF2E::allocate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- long GF2E::degree( void ) -->
+  <function name="GF2E::degree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void GF2E::init( const GF2X & NewP ) -->
+  <function name="GF2E::init">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const GF2XModulus & GF2E::modulus( void ) -->
+  <function name="GF2E::modulus">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const GF2XModulus &amp;"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- long GF2E::storage( void ) -->
+  <function name="GF2E::storage">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void GF2E::swap( GF2E & y ) -->
+  <function name="GF2E::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void GF2EBak::restore( void ) -->
+  <function name="GF2EBak::restore">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GF2EBak::save( void ) -->
+  <function name="GF2EBak::save">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GF2EContext::restore( void ) const -->
+  <function name="GF2EContext::restore">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+  </function>
+  <!-- void GF2EContext::save( void ) -->
+  <function name="GF2EContext::save">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void zz_p::FFTInit( long index ) -->
+  <function name="zz_p::FFTInit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool zz_p::IsFFTPrime( void ) -->
+  <function name="zz_p::IsFFTPrime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- long & zz_p::LoopHole( void ) -->
+  <function name="zz_p::LoopHole">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- mulmod_t zz_p::ModulusInverse( void ) -->
+  <function name="zz_p::ModulusInverse">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mulmod_t"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- long zz_p::PrimeCnt( void ) -->
+  <function name="zz_p::PrimeCnt">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void zz_p::UserFFTInit( long q ) -->
+  <function name="zz_p::UserFFTInit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const sp_ZZ_reduce_struct & zz_p::ZZ_red_struct( void ) -->
+  <function name="zz_p::ZZ_red_struct">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const sp_ZZ_reduce_struct &amp;"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void zz_p::allocate( void ) -->
+  <function name="zz_p::allocate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void zz_p::init( long NewP, long maxroot = NTL_FFTMaxRoot ) -->
+  <function name="zz_p::init">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" default="NTL_FFTMaxRoot" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- sp_ll_reduce_struct zz_p::ll_red_struct( void ) -->
+  <function name="zz_p::ll_red_struct">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="sp_ll_reduce_struct"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- long zz_p::modulus( void ) -->
+  <function name="zz_p::modulus">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- sp_reduce_struct zz_p::red_struct( void ) -->
+  <function name="zz_p::red_struct">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="sp_reduce_struct"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- long zz_p::storage( void ) -->
+  <function name="zz_p::storage">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- zz_p zz_p::zero( void ) -->
+  <function name="zz_p::zero">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="zz_p"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void zz_pBak::restore( void ) -->
+  <function name="zz_pBak::restore">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void zz_pBak::save( void ) -->
+  <function name="zz_pBak::save">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- mulmod_t zz_pContext::ModulusInverse( void ) -->
+  <function name="zz_pContext::ModulusInverse">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mulmod_t"/>
+    <use-retval/>
+  </function>
+  <!-- const sp_ZZ_reduce_struct & zz_pContext::ZZ_red_struct( void ) -->
+  <function name="zz_pContext::ZZ_red_struct">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const sp_ZZ_reduce_struct &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool zz_pContext::equals( const zz_pContext & other ) -->
+  <function name="zz_pContext::equals">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long zz_pContext::modulus( void ) -->
+  <function name="zz_pContext::modulus">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- bool zz_pContext::null( void ) -->
+  <function name="zz_pContext::null">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- sp_reduce_struct zz_pContext::red_struct( void ) -->
+  <function name="zz_pContext::red_struct">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="sp_reduce_struct"/>
+    <use-retval/>
+  </function>
+  <!-- void zz_pContext::restore( void ) const -->
+  <function name="zz_pContext::restore">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+  </function>
+  <!-- void zz_pContext::save( void ) -->
+  <function name="zz_pContext::save">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void ZZ_pEX::SetLength( long n ) -->
+  <function name="ZZ_pEX::SetLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void ZZ_pEX::SetMaxLength( long n ) -->
+  <function name="ZZ_pEX::SetMaxLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void ZZ_pEX::kill( void ) -->
+  <function name="ZZ_pEX::kill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void ZZ_pEX::normalize( void ) -->
+  <function name="ZZ_pEX::normalize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void ZZ_pEX::swap( ZZ_pEX & x ) -->
+  <function name="ZZ_pEX::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- const ZZ_pEX & ZZ_pEX::zero( void ) -->
+  <function name="ZZ_pEX::zero">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const ZZ_pEX &amp;"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- const ZZ_pEX & ZZ_pEXModulus::val( void ) -->
+  <function name="ZZ_pEXModulus::val">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const ZZ_pEX &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- void ZZ_p::DoInstall( void ) -->
+  <function name="ZZ_p::DoInstall">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+  </function>
+  <!-- long ZZ_p::ExtendedModulusSize( void ) -->
+  <function name="ZZ_p::ExtendedModulusSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- const ZZ_pFFTInfoT * ZZ_p::GetFFTInfo( void ) -->
+  <function name="ZZ_p::GetFFTInfo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const ZZ_pFFTInfoT *"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- ZZ_pTmpSpaceT * ZZ_p::GetTmpSpace( void ) -->
+  <function name="ZZ_p::GetTmpSpace">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ZZ_pTmpSpaceT *"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void ZZ_p::KillBig( void ) -->
+  <function name="ZZ_p::KillBig">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- long ZZ_p::ModulusSize( void ) -->
+  <function name="ZZ_p::ModulusSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void ZZ_p::allocate( void ) -->
+  <function name="ZZ_p::allocate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void ZZ_p::init( const ZZ &  ) -->
+  <function name="ZZ_p::init">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void ZZ_p::install( void ) -->
+  <function name="ZZ_p::install">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+  </function>
+  <!-- long ZZ_p::storage( void ) -->
+  <function name="ZZ_p::storage">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void ZZ_p::swap( ZZ_p & x ) -->
+  <function name="ZZ_p::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- const ZZ_p & ZZ_p::zero( void ) -->
+  <function name="ZZ_p::zero">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const ZZ_p &amp;"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void ZZ_pBak::restore( void ) -->
+  <function name="ZZ_pBak::restore">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void ZZ_pBak::save( void ) -->
+  <function name="ZZ_pBak::save">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void ZZ_pContext::restore( void ) const -->
+  <function name="ZZ_pContext::restore">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+  </function>
+  <!-- void ZZ_pContext::save( void ) -->
+  <function name="ZZ_pContext::save">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void ZZ_pInfoT::MatPrime_crt_helper_deleter_policy::deleter( MatPrime_crt_helper * p ) -->
+  <function name="ZZ_pInfoT::MatPrime_crt_helper_deleter_policy::deleter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void GF2::allocate( void ) -->
+  <function name="GF2::allocate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- long GF2::modulus( void ) -->
+  <function name="GF2::modulus">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void GF2::swap( GF2 & x ) -->
+  <function name="GF2::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- GF2 GF2::zero( void ) -->
+  <function name="GF2::zero">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="GF2"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void GF2Bak::restore( void ) -->
+  <function name="GF2Bak::restore">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GF2Bak::save( void ) -->
+  <function name="GF2Bak::save">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GF2Context::restore( void ) -->
+  <function name="GF2Context::restore">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GF2Context::save( void ) -->
+  <function name="GF2Context::save">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void ref_GF2::swap( ref_GF2 x ) -->
+  <function name="ref_GF2::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void GF2X::KillBig( void ) -->
+  <function name="GF2X::KillBig">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GF2X::SetLength( long n ) -->
+  <function name="GF2X::SetLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GF2X::SetMaxLength( long n ) -->
+  <function name="GF2X::SetMaxLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GF2X::kill( void ) -->
+  <function name="GF2X::kill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GF2X::normalize( void ) -->
+  <function name="GF2X::normalize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void GF2X::swap( GF2X & x ) -->
+  <function name="GF2X::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- long GF2XModulus::WordLength( void ) -->
+  <function name="GF2XModulus::WordLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- long GF2XVec::BaseSize( void ) -->
+  <function name="GF2XVec::BaseSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void GF2XVec::SetSize( long n, long d ) -->
+  <function name="GF2XVec::SetSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GF2XVec::kill( void ) -->
+  <function name="GF2XVec::kill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- long GF2XVec::length( void ) -->
+  <function name="GF2XVec::length">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void GF2XVec::move( GF2XVec & other ) -->
+  <function name="GF2XVec::move">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void GF2XVec::swap( GF2XVec & x ) -->
+  <function name="GF2XVec::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool Lazy::built( void ) -->
+  <function name="Lazy::built">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void Lazy::kill( void ) -->
+  <function name="Lazy::kill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- long zz_pE::DivCross( void ) -->
+  <function name="zz_pE::DivCross">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- zz_pX & zz_pE::LoopHole( void ) -->
+  <function name="zz_pE::LoopHole">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="zz_pX &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- long zz_pE::ModCross( void ) -->
+  <function name="zz_pE::ModCross">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void zz_pE::allocate( void ) -->
+  <function name="zz_pE::allocate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- long zz_pE::degree( void ) -->
+  <function name="zz_pE::degree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void zz_pE::init( const zz_pX &  ) -->
+  <function name="zz_pE::init">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long zz_pE::initialized( void ) -->
+  <function name="zz_pE::initialized">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- const zz_pXModulus & zz_pE::modulus( void ) -->
+  <function name="zz_pE::modulus">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const zz_pXModulus &amp;"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void zz_pE::swap( zz_pE & x ) -->
+  <function name="zz_pE::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- const zz_pE & zz_pE::zero( void ) -->
+  <function name="zz_pE::zero">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const zz_pE &amp;"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void zz_pEBak::restore( void ) -->
+  <function name="zz_pEBak::restore">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void zz_pEBak::save( void ) -->
+  <function name="zz_pEBak::save">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void zz_pEContext::restore( void ) const -->
+  <function name="zz_pEContext::restore">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+  </function>
+  <!-- void zz_pEContext::save( void ) -->
+  <function name="zz_pEContext::save">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- long Mat::NumCols( void ) -->
+  <function name="Mat::NumCols">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- long Mat::NumRows( void ) -->
+  <function name="Mat::NumRows">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void Mat::SetDims( long n, long m ) -->
+  <function name="Mat::SetDims">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long Mat::alias( const Vec<T> & a ) -->
+  <function name="Mat::alias">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const_reference Mat::get( long i, long j ) -->
+  <function name="Mat::get">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const_reference"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void Mat::kill( void ) -->
+  <function name="Mat::kill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void Mat::move( Mat & other ) -->
+  <function name="Mat::move">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- long Mat::position( const Vec<T> & a ) -->
+  <function name="Mat::position">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long Mat::position1( const Vec<T> & a ) -->
+  <function name="Mat::position1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void Mat::swap( Mat & other ) -->
+  <function name="Mat::swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void default_BlockConstruct( T * p, long n ) -->
+  <function name="default_BlockConstruct">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void default_BlockConstructFromObj( T * p, long n, const T & q ) -->
+  <function name="default_BlockConstructFromObj">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void default_BlockConstructFromVec( T * p, long n, const T * q ) -->
+  <function name="default_BlockConstructFromVec">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void default_BlockDestroy( T * p, long n ) -->
+  <function name="default_BlockDestroy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- mat_ZZ_p ident_mat_ZZ_p( long n ) -->
+  <function name="ident_mat_ZZ_p">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mat_ZZ_p"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- mat_ZZ_p_opaque_body * mat_ZZ_p_opaque_body_move( mat_ZZ_p & A ) -->
+  <function name="mat_ZZ_p_opaque_body_move">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mat_ZZ_p_opaque_body *"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void mul_transpose( mat_ZZ_p & X, const mat_ZZ_p & A, const mat_ZZ_p_opaque & B ) -->
+  <function name="mul_transpose">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- mat_ZZ_p random_mat_ZZ_p( long n, long m ) -->
+  <function name="random_mat_ZZ_p">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mat_ZZ_p"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- mat_GF2E ident_mat_GF2E( long n ) -->
+  <function name="ident_mat_GF2E">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mat_GF2E"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- mat_GF2E random_mat_GF2E( long n, long m ) -->
+  <function name="random_mat_GF2E">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mat_GF2E"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void MulAdd( xdouble & z, const xdouble & a, const xdouble & b, const xdouble & c ) -->
+  <function name="MulAdd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- void MulSub( xdouble & z, const xdouble & a, const xdouble & b, const xdouble & c ) -->
+  <function name="MulSub">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- xdouble power2_xdouble( long e ) -->
+  <function name="power2_xdouble">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="xdouble"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- xdouble xexp( double x ) -->
+  <function name="xexp">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="xdouble"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- GF2EX random_GF2EX( long n ) -->
+  <function name="random_GF2EX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="GF2EX"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- GF2EX to_GF2EX( long a ) -->
+  <function name="to_GF2EX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="GF2EX"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void CharPoly( zz_pX & f, const mat_zz_p & M ) -->
+  <function name="CharPoly">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ZZ_pEX BuildIrred_ZZ_pEX( long n ) -->
+  <function name="BuildIrred_ZZ_pEX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ZZ_pEX"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long WV_BlockConstructAlloc( WordVector & x, long d, long n ) -->
+  <function name="WV_BlockConstructAlloc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void WV_BlockConstructSet( WordVector & x, WordVector & y, long i ) -->
+  <function name="WV_BlockConstructSet">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long WV_BlockDestroy( WordVector & x ) -->
+  <function name="WV_BlockDestroy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- long WV_storage( long d ) -->
+  <function name="WV_storage">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- vec_ZZ_p random_vec_ZZ_p( long n ) -->
+  <function name="random_vec_ZZ_p">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="vec_ZZ_p"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- vec_ZZ to_vec_ZZ( const vec_ZZ_p & a ) -->
+  <function name="to_vec_ZZ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="vec_ZZ"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- vec_ZZ_p to_vec_ZZ_p( const vec_ZZ & a ) -->
+  <function name="to_vec_ZZ_p">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="vec_ZZ_p"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- mat_GF2 ident_mat_GF2( long n ) -->
+  <function name="ident_mat_GF2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mat_GF2"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- mat_GF2 random_mat_GF2( long n, long m ) -->
+  <function name="random_mat_GF2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mat_GF2"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- mat_GF2 to_mat_GF2( const vec_vec_GF2 & a ) -->
+  <function name="to_mat_GF2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mat_GF2"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void ArithmeticError( const char * msg ) -->
+  <function name="ArithmeticError">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long CharToIntVal( long c ) -->
+  <function name="CharToIntVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void Error( const char * msg ) -->
+  <function name="Error">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void FileError( const char * msg ) -->
+  <function name="FileError">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void ForceToMem( double * p ) -->
+  <function name="ForceToMem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- unsigned long GetPID( void ) -->
+  <function name="GetPID">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned long"/>
+    <use-retval/>
+  </function>
+  <!-- double GetTime( void ) -->
+  <function name="GetTime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double GetWallTime( void ) -->
+  <function name="GetWallTime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void InputError( const char * msg ) -->
+  <function name="InputError">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- char IntValToChar( long a ) -->
+  <function name="IntValToChar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="char"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long IsEOFChar( long c ) -->
+  <function name="IsEOFChar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long IsWhiteSpace( long c ) -->
+  <function name="IsWhiteSpace">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void LogicError( const char * msg ) -->
+  <function name="LogicError">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void MemoryError( void ) -->
+  <function name="MemoryError">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void ResourceError( const char * msg ) -->
+  <function name="ResourceError">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void TerminalError( const char * s ) -->
+  <function name="TerminalError">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- double TrueDouble( double x ) -->
+  <function name="TrueDouble">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- unsigned long _ntl_GetPID( void ) -->
+  <function name="_ntl_GetPID">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned long"/>
+    <use-retval/>
+  </function>
+  <!-- double _ntl_GetTime( void ) -->
+  <function name="_ntl_GetTime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- const char * FileName( const char * stem, long d ) -->
+  <function name="FileName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const char *"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- zz_pEX random_zz_pEX( long n ) -->
+  <function name="random_zz_pEX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="zz_pEX"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- zz_pEX to_zz_pEX( long a ) -->
+  <function name="to_zz_pEX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="zz_pEX"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- mat_zz_p ident_mat_zz_p( long n ) -->
+  <function name="ident_mat_zz_p">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mat_zz_p"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- mat_zz_p random_mat_zz_p( long n, long m ) -->
+  <function name="random_mat_zz_p">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mat_zz_p"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void relaxed_solve( zz_p & d, vec_zz_p & x, const mat_zz_p & A, const vec_zz_p & b, bool relax = true ) -->
+  <function name="relaxed_solve">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+    <arg nr="5" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- long MulDivRem( long & qres, long a, long b, long n, wide_double bninv ) -->
+  <function name="MulDivRem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="in"/>
+  </function>
+  <!-- long MulMod2( long a, long b, long n, wide_double bninv ) -->
+  <function name="MulMod2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- long MulMod2_legacy( long a, long b, long n, wide_double bninv ) -->
+  <function name="MulMod2_legacy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- long MulModPrecon( long a, long b, long n, unsigned long bninv ) -->
+  <function name="MulModPrecon">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long MulModPreconWithQuo( long & qres, long a, long b, long n, unsigned long bninv ) -->
+  <function name="MulModPreconWithQuo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long MulModWithQuo( long & qres, long a, long b, long n, wide_double ninv ) -->
+  <function name="MulModWithQuo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="in"/>
+  </function>
+  <!-- bool NormalizedModulus( wide_double ninv ) -->
+  <function name="NormalizedModulus">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long NormalizedMulMod( long a, long b, long n, wide_double ninv ) -->
+  <function name="NormalizedMulMod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- wide_double PrepMulMod( long n ) -->
+  <function name="PrepMulMod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wide_double"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void VectorMulMod( long k, long * x, const long * a, long b, long n ) -->
+  <function name="VectorMulMod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long sp_CorrectDeficit( long a, long n ) -->
+  <function name="sp_CorrectDeficit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long sp_CorrectDeficitQuo( T & q, long a, long n, long amt = 1 ) -->
+  <function name="sp_CorrectDeficitQuo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" default="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long sp_CorrectExcess( long a, long n ) -->
+  <function name="sp_CorrectExcess">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long sp_CorrectExcessQuo( T & q, long a, long n, long amt = 1 ) -->
+  <function name="sp_CorrectExcessQuo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" default="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool sp_Negative( unsigned long a ) -->
+  <function name="sp_Negative">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- sp_reduce_struct sp_PrepRem( long n ) -->
+  <function name="sp_PrepRem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="sp_reduce_struct"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long sp_SignMask( long a ) -->
+  <function name="sp_SignMask">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- vec_ZZX SFFactor( const ZZX & f, long verbose = 0, long bnd = 0 ) -->
+  <function name="SFFactor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="vec_ZZX"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long GetMatPrime( long i ) -->
+  <function name="GetMatPrime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void InitMatPrimeInfo( MatPrimeInfo & info, long q, long w ) -->
+  <function name="InitMatPrimeInfo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void RestoreMatPrime( long i ) -->
+  <function name="RestoreMatPrime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void UseMatPrime( long index ) -->
+  <function name="UseMatPrime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void init_scratch( const MatPrime_crt_helper & H, MatPrime_crt_helper_scratch & scratch ) -->
+  <function name="init_scratch">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- long CalcMaxRoot( long p ) -->
+  <function name="CalcMaxRoot">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void FFTFwd( long * A, const long * a, long k, const FFTPrimeInfo & info ) -->
+  <function name="FFTFwd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- void FFTFwd_trans( long * A, const long * a, long k, const FFTPrimeInfo & info ) -->
+  <function name="FFTFwd_trans">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- void FFTFwd_trunc( long * A, const long * a, long k, long i, long yn, long xn ) -->
+  <function name="FFTFwd_trunc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void FFTRev1( long * A, const long * a, long k, const FFTPrimeInfo & info ) -->
+  <function name="FFTRev1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- void FFTRev1_trans( long * A, const long * a, long k, const FFTPrimeInfo & info ) -->
+  <function name="FFTRev1_trans">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- void FFTRev1_trunc( long * A, const long * a, long k, long i, long yn ) -->
+  <function name="FFTRev1_trunc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long GetFFTPrime( long i ) -->
+  <function name="GetFFTPrime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- mulmod_t GetFFTPrimeInv( long i ) -->
+  <function name="GetFFTPrimeInv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mulmod_t"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- double GetFFTPrimeRecip( long i ) -->
+  <function name="GetFFTPrimeRecip">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void InitFFTPrimeInfo( FFTPrimeInfo & info, long q, long w, long bigtab_index ) -->
+  <function name="InitFFTPrimeInfo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long IsFFTPrime( long n, long & w ) -->
+  <function name="IsFFTPrime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void UseFFTPrime( long index ) -->
+  <function name="UseFFTPrime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- vec_GF2E random_vec_GF2E( long n ) -->
+  <function name="random_vec_GF2E">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="vec_GF2E"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long AvailableThreads( void ) -->
+  <function name="AvailableThreads">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- BasicThreadPool * GetThreadPool( void ) -->
+  <function name="GetThreadPool">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="BasicThreadPool *"/>
+    <use-retval/>
+  </function>
+  <!-- BasicThreadPool * ReleaseThreadPool( void ) -->
+  <function name="ReleaseThreadPool">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="BasicThreadPool *"/>
+    <use-retval/>
+  </function>
+  <!-- void ResetThreadPool( BasicThreadPool * pool = 0 ) -->
+  <function name="ResetThreadPool">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" default="0" direction="inout"/>
+  </function>
+  <!-- void SetNumThreads( long n ) -->
+  <function name="SetNumThreads">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- vec_ZZ_pE random_vec_ZZ_pE( long n ) -->
+  <function name="random_vec_ZZ_pE">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="vec_ZZ_pE"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ZZ_pX BuildIrred_ZZ_pX( long n ) -->
+  <function name="BuildIrred_ZZ_pX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ZZ_pX"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ZZ_pE random_ZZ_pE( void ) -->
+  <function name="random_ZZ_pE">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ZZ_pE"/>
+    <use-retval/>
+  </function>
+  <!-- ZZ_pE to_ZZ_pE( const ZZ_pX & a ) -->
+  <function name="to_ZZ_pE">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ZZ_pE"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void BytesFromZZ( unsigned char * p, const ZZ & a, long n ) -->
+  <function name="BytesFromZZ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long CRTInRange( const ZZ & gg, const ZZ & aa ) -->
+  <function name="CRTInRange">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void GCD_alt( ZZ & d, const ZZ & a, const ZZ & b ) -->
+  <function name="GCD_alt">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void GenGermainPrime( ZZ & n, long l, long err = 80 ) -->
+  <function name="GenGermainPrime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" default="80" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ZZ GenGermainPrime_ZZ( long l, long err = 80 ) -->
+  <function name="GenGermainPrime_ZZ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ZZ"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" default="80" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long GenGermainPrime_long( long l, long err = 80 ) -->
+  <function name="GenGermainPrime_long">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" default="80" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void GenPrime( ZZ & n, long l, long err = 80 ) -->
+  <function name="GenPrime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" default="80" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ZZ GenPrime_ZZ( long l, long err = 80 ) -->
+  <function name="GenPrime_ZZ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ZZ"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" default="80" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long GenPrime_long( long l, long err = 80 ) -->
+  <function name="GenPrime_long">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" default="80" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- RandomStream & GetCurrentRandomStream( void ) -->
+  <function name="GetCurrentRandomStream">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="RandomStream &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- long IsOdd( const ZZ & a ) -->
+  <function name="IsOdd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long Jacobi( const ZZ & a, const ZZ & n ) -->
+  <function name="Jacobi">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void LowLevelPowerMod( ZZ & x, const ZZ & a, const ZZ & e, const ZZ & n ) -->
+  <function name="LowLevelPowerMod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- long MakeOdd( ZZ & x ) -->
+  <function name="MakeOdd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- long MillerWitness( const ZZ & n, const ZZ & w ) -->
+  <function name="MillerWitness">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- long NextPowerOfTwo( long m ) -->
+  <function name="NextPowerOfTwo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long NumTwos( const ZZ & x ) -->
+  <function name="NumTwos">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long ProbPrime( const ZZ & n, long NumTrials = 10 ) -->
+  <function name="ProbPrime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="10" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void QuickAccumBegin( ZZ & x, long sz ) -->
+  <function name="QuickAccumBegin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void QuickAccumEnd( ZZ & x ) -->
+  <function name="QuickAccumEnd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void QuickAccumMulAdd( ZZ & x, const ZZ & y, long b ) -->
+  <function name="QuickAccumMulAdd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void QuickRem( ZZ & r, const ZZ & b ) -->
+  <function name="QuickRem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void RandomBits( long & x, long l ) -->
+  <function name="RandomBits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ZZ RandomBits_ZZ( long NumBits ) -->
+  <function name="RandomBits_ZZ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ZZ"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long RandomBits_long( long l ) -->
+  <function name="RandomBits_long">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- unsigned long RandomBits_ulong( long l ) -->
+  <function name="RandomBits_ulong">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void RandomLen( long & x, long l ) -->
+  <function name="RandomLen">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ZZ RandomLen_ZZ( long NumBits ) -->
+  <function name="RandomLen_ZZ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ZZ"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long RandomLen_long( long l ) -->
+  <function name="RandomLen_long">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void RandomPrime( ZZ & n, long l, long NumTrials = 10 ) -->
+  <function name="RandomPrime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" default="10" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ZZ RandomPrime_ZZ( long l, long NumTrials = 10 ) -->
+  <function name="RandomPrime_ZZ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ZZ"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" default="10" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long RandomPrime_long( long l, long NumTrials = 10 ) -->
+  <function name="RandomPrime_long">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" default="10" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void RandomStream_impl_set_nonce( RandomStream_impl & impl, unsigned long nonce ) -->
+  <function name="RandomStream_impl_set_nonce">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- unsigned long RandomWord( void ) -->
+  <function name="RandomWord">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned long"/>
+    <use-retval/>
+  </function>
+  <!-- long SetBit( ZZ & x, long p ) -->
+  <function name="SetBit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void SetSeed( const ZZ & s ) -->
+  <function name="SetSeed">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void SubPos( ZZ & x, const ZZ & a, const ZZ & b ) -->
+  <function name="SubPos">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- long SwitchBit( ZZ & x, long p ) -->
+  <function name="SwitchBit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void VectorRandomBnd( long k, long * x, long n ) -->
+  <function name="VectorRandomBnd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void VectorRandomWord( long k, unsigned long * x ) -->
+  <function name="VectorRandomWord">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- long ZZ_BlockConstructAlloc( ZZ & x, long d, long n ) -->
+  <function name="ZZ_BlockConstructAlloc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void ZZ_BlockConstructSet( ZZ & x, ZZ & y, long i ) -->
+  <function name="ZZ_BlockConstructSet">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long ZZ_BlockDestroy( ZZ & x ) -->
+  <function name="ZZ_BlockDestroy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- long ZZ_RoundCorrection( const ZZ & a, long k, long residual ) -->
+  <function name="ZZ_RoundCorrection">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long ZZ_storage( long d ) -->
+  <function name="ZZ_storage">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long bit( const ZZ & a, long k ) -->
+  <function name="bit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void bit_and( ZZ & x, const ZZ & a, const ZZ & b ) -->
+  <function name="bit_and">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void bit_or( ZZ & x, const ZZ & a, const ZZ & b ) -->
+  <function name="bit_or">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void bit_xor( ZZ & x, const ZZ & a, const ZZ & b ) -->
+  <function name="bit_xor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- long digit( const ZZ & a, long k ) -->
+  <function name="digit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ZZ power2_ZZ( long e ) -->
+  <function name="power2_ZZ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ZZ"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ZZ power_ZZ( long a, long e ) -->
+  <function name="power_ZZ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ZZ"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long power_long( long a, long e ) -->
+  <function name="power_long">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- unsigned int to_uint( const ZZ & a ) -->
+  <function name="to_uint">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- unsigned long to_ulong( const ZZ & a ) -->
+  <function name="to_ulong">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- ZZ trunc_ZZ( const ZZ & a, long k ) -->
+  <function name="trunc_ZZ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ZZ"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long trunc_long( const ZZ & a, long k ) -->
+  <function name="trunc_long">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void FromFFTRep( ZZ_pX & x, FFTRep & y, long lo, long hi ) -->
+  <function name="FromFFTRep">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void FromZZ_pXModRep( ZZ_pX & x, const ZZ_pXModRep & a, long lo, long hi ) -->
+  <function name="FromZZ_pXModRep">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void NDFromFFTRep( ZZ_pX & x, const FFTRep & y, long lo, long hi, FFTRep & temp ) -->
+  <function name="NDFromFFTRep">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="inout"/>
+  </function>
+  <!-- void RevFromFFTRep( vec_ZZ_p & x, FFTRep & y, long lo, long hi ) -->
+  <function name="RevFromFFTRep">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void ToFFTRep( FFTRep & y, const ZZ_pX & x, long k, long lo, long hi ) -->
+  <function name="ToFFTRep">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void ToFFTRep_trunc( FFTRep & y, const ZZ_pX & x, long k, long len ) -->
+  <function name="ToFFTRep_trunc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void ToZZ_pXModRep( ZZ_pXModRep & x, const ZZ_pX & a, long lo, long hi ) -->
+  <function name="ToZZ_pXModRep">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ZZ_pX random_ZZ_pX( long n ) -->
+  <function name="random_ZZ_pX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ZZ_pX"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long & _ntl_ALLOC( _ntl_gbigint p ) -->
+  <function name="_ntl_ALLOC">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long &amp;"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long _ntl_PINNED( _ntl_gbigint p ) -->
+  <function name="_ntl_PINNED">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long & _ntl_SIZE( _ntl_gbigint p ) -->
+  <function name="_ntl_SIZE">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long &amp;"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long _ntl_ZEROP( _ntl_gbigint p ) -->
+  <function name="_ntl_ZEROP">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long _ntl_g2log( _ntl_gbigint a ) -->
+  <function name="_ntl_g2log">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long _ntl_g2logs( long a ) -->
+  <function name="_ntl_g2logs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void _ntl_gabs( _ntl_gbigint * a ) -->
+  <function name="_ntl_gabs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void _ntl_gadd( _ntl_gbigint a, _ntl_gbigint b, _ntl_gbigint * c ) -->
+  <function name="_ntl_gadd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_gaddmod( _ntl_gbigint a, _ntl_gbigint b, _ntl_gbigint n, _ntl_gbigint * c ) -->
+  <function name="_ntl_gaddmod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="inout"/>
+  </function>
+  <!-- void _ntl_gaddmul( _ntl_gbigint x, _ntl_gbigint y, _ntl_gbigint * ww ) -->
+  <function name="_ntl_gaddmul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_gand( _ntl_gbigint a, _ntl_gbigint b, _ntl_gbigint * c ) -->
+  <function name="_ntl_gand">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- long _ntl_gbit( _ntl_gbigint a, long p ) -->
+  <function name="_ntl_gbit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long _ntl_gblock_construct_alloc( _ntl_gbigint * x, long d, long n ) -->
+  <function name="_ntl_gblock_construct_alloc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void _ntl_gblock_construct_set( _ntl_gbigint x, _ntl_gbigint * y, long i ) -->
+  <function name="_ntl_gblock_construct_set">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long _ntl_gblock_destroy( _ntl_gbigint x ) -->
+  <function name="_ntl_gblock_destroy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long _ntl_gblock_storage( long d ) -->
+  <function name="_ntl_gblock_storage">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void _ntl_gbytesfromz( unsigned char * p, _ntl_gbigint a, long nn ) -->
+  <function name="_ntl_gbytesfromz">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long _ntl_gcompare( _ntl_gbigint a, _ntl_gbigint b ) -->
+  <function name="_ntl_gcompare">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void _ntl_gcopy( _ntl_gbigint a, _ntl_gbigint * b ) -->
+  <function name="_ntl_gcopy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- long _ntl_gcrtinrange( _ntl_gbigint g, _ntl_gbigint a ) -->
+  <function name="_ntl_gcrtinrange">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- long _ntl_gdigit( _ntl_gbigint a, long i ) -->
+  <function name="_ntl_gdigit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void _ntl_gdiv( _ntl_gbigint a, _ntl_gbigint b, _ntl_gbigint * q, _ntl_gbigint * r ) -->
+  <function name="_ntl_gdiv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+    <arg nr="4" direction="inout"/>
+  </function>
+  <!-- double _ntl_gdoub( _ntl_gbigint n ) -->
+  <function name="_ntl_gdoub">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void _ntl_gdoubtoz( double a, _ntl_gbigint * x ) -->
+  <function name="_ntl_gdoubtoz">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void _ntl_gexp( _ntl_gbigint a, long e, _ntl_gbigint * b ) -->
+  <function name="_ntl_gexp">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_gexps( long a, long e, _ntl_gbigint * b ) -->
+  <function name="_ntl_gexps">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_gfree( _ntl_gbigint x ) -->
+  <function name="_ntl_gfree">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void _ntl_gfrombytes( _ntl_gbigint * x, const unsigned char * p, long n ) -->
+  <function name="_ntl_gfrombytes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void _ntl_ggcd( _ntl_gbigint m1, _ntl_gbigint m2, _ntl_gbigint * r ) -->
+  <function name="_ntl_ggcd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_ggcd_alt( _ntl_gbigint m1, _ntl_gbigint m2, _ntl_gbigint * r ) -->
+  <function name="_ntl_ggcd_alt">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_gintoz( long d, _ntl_gbigint * a ) -->
+  <function name="_ntl_gintoz">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- long _ntl_ginv( _ntl_gbigint a, _ntl_gbigint b, _ntl_gbigint * c ) -->
+  <function name="_ntl_ginv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_ginvmod( _ntl_gbigint a, _ntl_gbigint n, _ntl_gbigint * c ) -->
+  <function name="_ntl_ginvmod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- long _ntl_gisone( _ntl_gbigint n ) -->
+  <function name="_ntl_gisone">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long _ntl_giszero( _ntl_gbigint a ) -->
+  <function name="_ntl_giszero">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- double _ntl_glog( _ntl_gbigint a ) -->
+  <function name="_ntl_glog">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void _ntl_glowbits( _ntl_gbigint a, long k, _ntl_gbigint * b ) -->
+  <function name="_ntl_glowbits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_glshift( _ntl_gbigint n, long k, _ntl_gbigint * a ) -->
+  <function name="_ntl_glshift">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- long _ntl_gmakeodd( _ntl_gbigint * n ) -->
+  <function name="_ntl_gmakeodd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- long _ntl_gmaxalloc( _ntl_gbigint x ) -->
+  <function name="_ntl_gmaxalloc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void _ntl_gmod( _ntl_gbigint a, _ntl_gbigint b, _ntl_gbigint * r ) -->
+  <function name="_ntl_gmod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_gmul( _ntl_gbigint a, _ntl_gbigint b, _ntl_gbigint * c ) -->
+  <function name="_ntl_gmul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_gmulmod( _ntl_gbigint a, _ntl_gbigint b, _ntl_gbigint n, _ntl_gbigint * c ) -->
+  <function name="_ntl_gmulmod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="inout"/>
+  </function>
+  <!-- void _ntl_gnegate( _ntl_gbigint * a ) -->
+  <function name="_ntl_gnegate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- long _ntl_gnumtwos( _ntl_gbigint n ) -->
+  <function name="_ntl_gnumtwos">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long _ntl_godd( _ntl_gbigint a ) -->
+  <function name="_ntl_godd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void _ntl_gone( _ntl_gbigint * a ) -->
+  <function name="_ntl_gone">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void _ntl_gor( _ntl_gbigint a, _ntl_gbigint b, _ntl_gbigint * c ) -->
+  <function name="_ntl_gor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_gquickmod( _ntl_gbigint * r, _ntl_gbigint b ) -->
+  <function name="_ntl_gquickmod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- long _ntl_ground_correction( _ntl_gbigint a, long k, long residual ) -->
+  <function name="_ntl_ground_correction">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void _ntl_grshift( _ntl_gbigint n, long k, _ntl_gbigint * a ) -->
+  <function name="_ntl_grshift">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_gsadd( _ntl_gbigint a, long d, _ntl_gbigint * b ) -->
+  <function name="_ntl_gsadd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_gsaddmul( _ntl_gbigint x, long y, _ntl_gbigint * ww ) -->
+  <function name="_ntl_gsaddmul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- long _ntl_gscompare( _ntl_gbigint a, long b ) -->
+  <function name="_ntl_gscompare">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long _ntl_gsdiv( _ntl_gbigint a, long b, _ntl_gbigint * q ) -->
+  <function name="_ntl_gsdiv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- long _ntl_gsetbit( _ntl_gbigint * a, long p ) -->
+  <function name="_ntl_gsetbit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void _ntl_gsetlength( _ntl_gbigint * v, long len ) -->
+  <function name="_ntl_gsetlength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long _ntl_gsign( _ntl_gbigint a ) -->
+  <function name="_ntl_gsign">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long _ntl_gsize( _ntl_gbigint rep ) -->
+  <function name="_ntl_gsize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long _ntl_gslowbits( _ntl_gbigint a, long k ) -->
+  <function name="_ntl_gslowbits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long _ntl_gsmod( _ntl_gbigint a, long d ) -->
+  <function name="_ntl_gsmod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void _ntl_gsmul( _ntl_gbigint a, long d, _ntl_gbigint * b ) -->
+  <function name="_ntl_gsmul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_gsmulmod( _ntl_gbigint a, long b, _ntl_gbigint n, _ntl_gbigint * c ) -->
+  <function name="_ntl_gsmulmod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="inout"/>
+  </function>
+  <!-- long _ntl_gsptest( _ntl_gbigint a ) -->
+  <function name="_ntl_gsptest">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void _ntl_gsq( _ntl_gbigint a, _ntl_gbigint * c ) -->
+  <function name="_ntl_gsq">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void _ntl_gsqmod( _ntl_gbigint a, _ntl_gbigint n, _ntl_gbigint * c ) -->
+  <function name="_ntl_gsqmod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_gsqrt( _ntl_gbigint n, _ntl_gbigint * r ) -->
+  <function name="_ntl_gsqrt">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- long _ntl_gsqrts( long n ) -->
+  <function name="_ntl_gsqrts">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void _ntl_gssub( _ntl_gbigint a, long d, _ntl_gbigint * b ) -->
+  <function name="_ntl_gssub">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_gssubmul( _ntl_gbigint x, long y, _ntl_gbigint * ww ) -->
+  <function name="_ntl_gssubmul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_gsub( _ntl_gbigint a, _ntl_gbigint b, _ntl_gbigint * c ) -->
+  <function name="_ntl_gsub">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_gsubmod( _ntl_gbigint a, _ntl_gbigint b, _ntl_gbigint n, _ntl_gbigint * c ) -->
+  <function name="_ntl_gsubmod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="inout"/>
+  </function>
+  <!-- void _ntl_gsubmul( _ntl_gbigint x, _ntl_gbigint y, _ntl_gbigint * ww ) -->
+  <function name="_ntl_gsubmul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_gsubpos( _ntl_gbigint a, _ntl_gbigint b, _ntl_gbigint * c ) -->
+  <function name="_ntl_gsubpos">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_gswap( _ntl_gbigint * a, _ntl_gbigint * b ) -->
+  <function name="_ntl_gswap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- long _ntl_gswitchbit( _ntl_gbigint * a, long p ) -->
+  <function name="_ntl_gswitchbit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long _ntl_gtoint( _ntl_gbigint a ) -->
+  <function name="_ntl_gtoint">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- unsigned long _ntl_gtouint( _ntl_gbigint a ) -->
+  <function name="_ntl_gtouint">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void _ntl_guintoz( unsigned long d, _ntl_gbigint * a ) -->
+  <function name="_ntl_guintoz">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- long _ntl_gvalidate( _ntl_gbigint a ) -->
+  <function name="_ntl_gvalidate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long _ntl_gweight( _ntl_gbigint a ) -->
+  <function name="_ntl_gweight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long _ntl_gweights( long a ) -->
+  <function name="_ntl_gweights">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long _ntl_gwsptest( _ntl_gbigint a ) -->
+  <function name="_ntl_gwsptest">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void _ntl_gxor( _ntl_gbigint a, _ntl_gbigint b, _ntl_gbigint * c ) -->
+  <function name="_ntl_gxor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void _ntl_gzero( _ntl_gbigint * a ) -->
+  <function name="_ntl_gzero">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void FromfftRep( zz_pX & x, fftRep & y, long lo, long hi ) -->
+  <function name="FromfftRep">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void NDFromfftRep( zz_pX & x, const fftRep & y, long lo, long hi, fftRep & temp ) -->
+  <function name="NDFromfftRep">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="inout"/>
+  </function>
+  <!-- void RevFromfftRep( vec_zz_p & x, fftRep & y, long lo, long hi ) -->
+  <function name="RevFromfftRep">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void TofftRep( fftRep & y, const zz_pX & x, long k, long lo, long hi ) -->
+  <function name="TofftRep">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void TofftRep_trunc( fftRep & y, const zz_pX & x, long k, long len ) -->
+  <function name="TofftRep_trunc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- zz_pX random_zz_pX( long n ) -->
+  <function name="random_zz_pX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="zz_pX"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long CharPolyBound( const ZZX & a, const ZZX & f ) -->
+  <function name="CharPolyBound">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- long HomDivide( ZZX & q, const ZZX & a, const ZZX & b ) -->
+  <function name="HomDivide">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void HomMul( ZZX & x, const ZZX & a, const ZZX & b ) -->
+  <function name="HomMul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void HomPseudoDiv( ZZX & q, const ZZX & a, const ZZX & b ) -->
+  <function name="HomPseudoDiv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void HomPseudoDivRem( ZZX & q, ZZX & r, const ZZX & a, const ZZX & b ) -->
+  <function name="HomPseudoDivRem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- void HomPseudoRem( ZZX & r, const ZZX & a, const ZZX & b ) -->
+  <function name="HomPseudoRem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void HomSqr( ZZX & x, const ZZX & a ) -->
+  <function name="HomSqr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void KarMul( ZZX & x, const ZZX & a, const ZZX & b ) -->
+  <function name="KarMul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void KarSqr( ZZX & x, const ZZX & a ) -->
+  <function name="KarSqr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- long MaxBits( const ZZX & f ) -->
+  <function name="MaxBits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long PlainDivide( ZZX & q, const ZZX & a, const ZZX & b ) -->
+  <function name="PlainDivide">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void PlainPseudoDiv( ZZX & q, const ZZX & a, const ZZX & b ) -->
+  <function name="PlainPseudoDiv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void PlainPseudoDivRem( ZZX & q, ZZX & r, const ZZX & a, const ZZX & b ) -->
+  <function name="PlainPseudoDivRem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- void PlainPseudoRem( ZZX & r, const ZZX & a, const ZZX & b ) -->
+  <function name="PlainPseudoRem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void PseudoDivRem( ZZX & q, ZZX & r, const ZZX & a, const ZZX & b ) -->
+  <function name="PseudoDivRem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- void SSMul( ZZX & x, const ZZX & a, const ZZX & b ) -->
+  <function name="SSMul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- double SSRatio( long na, long maxa, long nb, long maxb ) -->
+  <function name="SSRatio">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void SSSqr( ZZX & x, const ZZX & a ) -->
+  <function name="SSSqr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- ZZX to_ZZX( long a ) -->
+  <function name="to_ZZX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ZZX"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- mat_ZZ_pE ident_mat_ZZ_pE( long n ) -->
+  <function name="ident_mat_ZZ_pE">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mat_ZZ_pE"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- mat_ZZ_pE random_mat_ZZ_pE( long n, long m ) -->
+  <function name="random_mat_ZZ_pE">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mat_ZZ_pE"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- vec_zz_p random_vec_zz_p( long n ) -->
+  <function name="random_vec_zz_p">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="vec_zz_p"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- vec_ZZ to_vec_ZZ( const vec_zz_p & a ) -->
+  <function name="to_vec_ZZ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="vec_ZZ"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- vec_zz_p to_vec_zz_p( const vec_ZZ & a ) -->
+  <function name="to_vec_zz_p">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="vec_zz_p"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long FFTRoundUp( long xn, long k ) -->
+  <function name="FFTRoundUp">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- mat_RR ident_mat_RR( long n ) -->
+  <function name="ident_mat_RR">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mat_RR"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- vec_GF2 random_vec_GF2( long n ) -->
+  <function name="random_vec_GF2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="vec_GF2"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void HNF( mat_ZZ & W, const mat_ZZ & A, const ZZ & D ) -->
+  <function name="HNF">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void ComputePi( RR & res ) -->
+  <function name="ComputePi">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- RR ComputePi_RR( void ) -->
+  <function name="ComputePi_RR">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="RR"/>
+    <use-retval/>
+  </function>
+  <!-- RR power2_RR( long e ) -->
+  <function name="power2_RR">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="RR"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- RR random_RR( void ) -->
+  <function name="random_RR">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="RR"/>
+    <use-retval/>
+  </function>
+  <!-- RR to_RR( int a ) -->
+  <function name="to_RR">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="RR"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const ZZ_limb_t * ZZ_limbs_get( const ZZ & a ) -->
+  <function name="ZZ_limbs_get">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const ZZ_limb_t *"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void ZZ_limbs_set( ZZ & x, const ZZ_limb_t * p, long n ) -->
+  <function name="ZZ_limbs_set">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const _ntl_limb_t * _ntl_glimbs_get( _ntl_gbigint p ) -->
+  <function name="_ntl_glimbs_get">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const _ntl_limb_t *"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void _ntl_glimbs_set( const _ntl_limb_t * p, long n, _ntl_gbigint * x ) -->
+  <function name="_ntl_glimbs_set">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- quad_float ldexp( const quad_float & x, long exp ) -->
+  <function name="ldexp">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="quad_float"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- quad_float power2_quad_float( long e ) -->
+  <function name="power2_quad_float">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="quad_float"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void quad_float_PrecisionOK( long & , const double &  ) -->
+  <function name="quad_float_PrecisionOK">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void quad_float_in_place_add( quad_float & x, const quad_float & y ) -->
+  <function name="quad_float_in_place_add">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void quad_float_in_place_div( quad_float & x, const quad_float & y ) -->
+  <function name="quad_float_in_place_div">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void quad_float_in_place_mul( quad_float & x, const quad_float & y ) -->
+  <function name="quad_float_in_place_mul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void quad_float_in_place_negate( quad_float & x ) -->
+  <function name="quad_float_in_place_negate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void quad_float_in_place_sqrt( quad_float & y, double & c_ref ) -->
+  <function name="quad_float_in_place_sqrt">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void quad_float_in_place_sub( quad_float & x, const quad_float & y ) -->
+  <function name="quad_float_in_place_sub">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void quad_float_normalize( quad_float & z, const double & xhi, const double & xlo ) -->
+  <function name="quad_float_normalize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- quad_float random_quad_float( void ) -->
+  <function name="random_quad_float">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="quad_float"/>
+    <use-retval/>
+  </function>
+  <!-- zz_pX BuildIrred_zz_pX( long n ) -->
+  <function name="BuildIrred_zz_pX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="zz_pX"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- GF2EX BuildIrred_GF2EX( long n ) -->
+  <function name="BuildIrred_GF2EX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="GF2EX"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void ComposeFrobeniusMap( GF2EX & y, const GF2EXModulus & F ) -->
+  <function name="ComposeFrobeniusMap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void PlainFrobeniusMap( GF2EX & h, const GF2EXModulus & F ) -->
+  <function name="PlainFrobeniusMap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- long UseComposeFrobenius( long d, long n ) -->
+  <function name="UseComposeFrobenius">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void FactorInt( FacVec & fvec, long n ) -->
+  <function name="FactorInt">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- GF2E random_GF2E( void ) -->
+  <function name="random_GF2E">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="GF2E"/>
+    <use-retval/>
+  </function>
+  <!-- GF2E to_GF2E( const GF2X & a ) -->
+  <function name="to_GF2E">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="GF2E"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const sp_ZZ_reduce_struct & GetFFT_ZZ_red_struct( long i ) -->
+  <function name="GetFFT_ZZ_red_struct">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const sp_ZZ_reduce_struct &amp;"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void VectorConv( long k, zz_p * x, const long * a ) -->
+  <function name="VectorConv">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void VectorRandom( long k, zz_p * x ) -->
+  <function name="VectorRandom">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- zz_p random_zz_p( void ) -->
+  <function name="random_zz_p">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="zz_p"/>
+    <use-retval/>
+  </function>
+  <!-- void swap( zz_p & x, zz_p & y ) -->
+  <function name="swap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- zz_p to_zz_p( long a ) -->
+  <function name="to_zz_p">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="zz_p"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- zz_pEX BuildIrred_zz_pEX( long n ) -->
+  <function name="BuildIrred_zz_pEX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="zz_pEX"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ZZ_pEX random_ZZ_pEX( long n ) -->
+  <function name="random_ZZ_pEX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ZZ_pEX"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ZZ_pEX to_ZZ_pEX( long a ) -->
+  <function name="to_ZZ_pEX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ZZ_pEX"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- ZZ_p random_ZZ_p( void ) -->
+  <function name="random_ZZ_p">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ZZ_p"/>
+    <use-retval/>
+  </function>
+  <!-- ZZ_p to_ZZ_p( const ZZ & a ) -->
+  <function name="to_ZZ_p">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ZZ_p"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- GF2 random_GF2( void ) -->
+  <function name="random_GF2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="GF2"/>
+    <use-retval/>
+  </function>
+  <!-- GF2 to_GF2( long a ) -->
+  <function name="to_GF2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="GF2"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void HenselSolve1( ZZ & d_out, vec_ZZ & x_out, const mat_ZZ & A, const vec_ZZ & b ) -->
+  <function name="HenselSolve1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- mat_ZZ ident_mat_ZZ( long n ) -->
+  <function name="ident_mat_ZZ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mat_ZZ"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void solve1( ZZ & d_out, vec_ZZ & x_out, const mat_ZZ & A, const vec_ZZ & b ) -->
+  <function name="solve1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- mat_ZZ_p to_mat_ZZ_p( const mat_ZZ & a ) -->
+  <function name="to_mat_ZZ_p">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mat_ZZ_p"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- mat_zz_p to_mat_zz_p( const mat_ZZ & a ) -->
+  <function name="to_mat_zz_p">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mat_zz_p"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void BytesFromGF2X( unsigned char * p, const GF2X & a, long n ) -->
+  <function name="BytesFromGF2X">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void CopyReverse( GF2X & c, const GF2X & a, long hi ) -->
+  <function name="CopyReverse">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void MinPolyInternal( GF2X & h, const GF2X & x, long m ) -->
+  <function name="MinPolyInternal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void OldGCD( GF2X & d, const GF2X & a, const GF2X & b ) -->
+  <function name="OldGCD">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void OldMinPolyInternal( GF2X & h, const GF2X & x, long m ) -->
+  <function name="OldMinPolyInternal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void OldMul( GF2X & c, const GF2X & a, const GF2X & b ) -->
+  <function name="OldMul">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void OldXGCD( GF2X & d, GF2X & s, GF2X & t, const GF2X & a, const GF2X & b ) -->
+  <function name="OldXGCD">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+    <arg nr="4" direction="in"/>
+    <arg nr="5" direction="in"/>
+  </function>
+  <!-- GF2X random_GF2X( long n ) -->
+  <function name="random_GF2X">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="GF2X"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- GF2X to_GF2X( long a ) -->
+  <function name="to_GF2X">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="GF2X"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- vec_GF2 to_vec_GF2( const GF2X & a ) -->
+  <function name="to_vec_GF2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="vec_GF2"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- vec_zz_pE random_vec_zz_pE( long n ) -->
+  <function name="random_vec_zz_pE">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="vec_zz_pE"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- mat_zz_pE ident_mat_zz_pE( long n ) -->
+  <function name="ident_mat_zz_pE">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mat_zz_pE"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- mat_zz_pE random_mat_zz_pE( long n, long m ) -->
+  <function name="random_mat_zz_pE">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="mat_zz_pE"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const zz_pX & _zz_pE__rep( const zz_pE & a ) -->
+  <function name="_zz_pE__rep">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const zz_pX &amp;"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- zz_pE random_zz_pE( void ) -->
+  <function name="random_zz_pE">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="zz_pE"/>
+    <use-retval/>
+  </function>
+  <!-- zz_pE to_zz_pE( const zz_pX & a ) -->
+  <function name="to_zz_pE">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="zz_pE"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- GF2X BuildIrred_GF2X( long n ) -->
+  <function name="BuildIrred_GF2X">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="GF2X"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void BuildSparseIrred( GF2X & f, long n ) -->
+  <function name="BuildSparseIrred">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- GF2X BuildSparseIrred_GF2X( long n ) -->
+  <function name="BuildSparseIrred_GF2X">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="GF2X"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void DDF( vec_pair_GF2X_long & factors, const GF2X & ff, long verbose = 0 ) -->
+  <function name="DDF">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void EDF( vec_GF2X & factors, const GF2X & ff, long d, long verbose = 0 ) -->
+  <function name="EDF">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void CharPoly( ZZX & f, const mat_ZZ & M, long deterministic = 0 ) -->
+  <function name="CharPoly">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void _ntl_ForceToMem( double * p ) -->
+  <function name="_ntl_ForceToMem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- double _ntl_GetWallTime( void ) -->
+  <function name="_ntl_GetWallTime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- long _ntl_IsFinite( double * p ) -->
+  <function name="_ntl_IsFinite">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- double _ntl_ldexp( double x, long e ) -->
+  <function name="_ntl_ldexp">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- char * _ntl_make_aligned( char * p, long align ) -->
+  <function name="_ntl_make_aligned">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="char *"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long _ntl_vec_grow( long n ) -->
+  <function name="_ntl_vec_grow">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void ComputeGS( const mat_ZZ & B, mat_RR & mu, vec_RR & c ) -->
+  <function name="ComputeGS">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- long LLL( ZZ & det, mat_ZZ & B, long verbose = 0 ) -->
+  <function name="LLL">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long LLL_plus( vec_ZZ & D, mat_ZZ & B, mat_ZZ & U, long verbose = 0 ) -->
+  <function name="LLL_plus">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+    <arg nr="4" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long LatticeSolve( vec_ZZ & x, const mat_ZZ & A, const vec_ZZ & y, long reduce = 0 ) -->
+  <function name="LatticeSolve">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void NearVector( vec_ZZ & ww, const mat_ZZ & BB, const vec_ZZ & a ) -->
+  <function name="NearVector">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void CharPoly( ZZ_pX & f, const mat_ZZ_p & M ) -->
+  <function name="CharPoly">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+</def>
diff --git a/cfg/opencv2.cfg b/cfg/opencv2.cfg
new file mode 100644
index 00000000000..80b51ad7a08
--- /dev/null
+++ b/cfg/opencv2.cfg
@@ -0,0 +1,132 @@
+<?xml version="1.0"?>
+<def format="2">
+  <!-- OpenCV (Open Source Computer Vision Library) Library Configuration http://opencv.org) -->
+  <!-- This configuration is for the OpenCV 2.x API (The C++ API, not the older C API) -->
+  <!-- The OpenCV library is typically included by '#include <opencv2/*>' or -->
+  <!-- '#include "opencv2/*"'. -->
+  <!-- ########## OpenCV Types ########## -->
+  <podtype name="cv::int8_t" sign="s" size="1"/>
+  <podtype name="cv::int16_t" sign="s" size="2"/>
+  <podtype name="cv::int32_t" sign="s" size="4"/>
+  <podtype name="cv::int64_t" sign="s" size="8"/>
+  <podtype name="cv::uint8_t" sign="u" size="1"/>
+  <podtype name="cv::uint16_t" sign="u" size="2"/>
+  <podtype name="cv::uint32_t" sign="u" size="4"/>
+  <podtype name="cv::uint64_t" sign="u" size="8"/>
+  <smart-pointer class-name="cv::Ptr"/>
+  <!-- ########## OpenCV Macros / Defines ########## -->
+  <define name="CV_ALWAYS_INLINE" value="inline"/>
+  <define name="CV_EXTERN_C" value="extern &quot;C&quot;"/>
+  <define name="CV_OVERRIDE" value="override"/>
+  <define name="CV_PI" value="3.1415926535897932384626433832795"/>
+  <define name="CV_2PI" value="6.283185307179586476925286766559"/>
+  <define name="CV_LOG2" value="0.69314718055994530941723212145818"/>
+  <define name="CV_MAT_CN_MASK" value="((CV_CN_MAX - 1) &lt;&lt; CV_CN_SHIFT)"/>
+  <define name="CV_MAT_CN(flags)" value="((((flags) &amp; CV_MAT_CN_MASK) &gt;&gt; CV_CN_SHIFT) + 1)"/>
+  <define name="CV_MAT_TYPE_MASK" value="(CV_DEPTH_MAX*CV_CN_MAX - 1)"/>
+  <define name="CV_MAT_TYPE(flags)" value="((flags) &amp; CV_MAT_TYPE_MASK)"/>
+  <define name="CV_MAT_CONT_FLAG_SHIFT" value="14"/>
+  <define name="CV_MAT_CONT_FLAG" value="(1 &lt;&lt; CV_MAT_CONT_FLAG_SHIFT)"/>
+  <define name="CV_IS_MAT_CONT(flags)" value="((flags) &amp; CV_MAT_CONT_FLAG)"/>
+  <define name="CV_IS_CONT_MAT" value="CV_IS_MAT_CONT"/>
+  <define name="CV_SUBMAT_FLAG_SHIFT" value="15"/>
+  <define name="CV_SUBMAT_FLAG" value="(1 &lt;&lt; CV_SUBMAT_FLAG_SHIFT)"/>
+  <define name="CV_IS_SUBMAT(flags)" value="((flags) &amp; CV_MAT_SUBMAT_FLAG)"/>
+  <define name="MIN(a,b)" value="((a) &gt; (b) ? (b) : (a))"/>
+  <define name="MAX(a,b)" value="((a) &lt; (b) ? (b) : (a))"/>
+  <define name="CV_Error(code,msg)" value="cv::error( code, msg, CV_Func, __FILE__, __LINE__ )"/>
+  <define name="CV_Assert(expr)" value="do { if(!!(expr)) ; else cv::error( cv::Error::StsAssert, #expr, CV_Func, __FILE__, __LINE__ ); } while(0)"/>
+  <!-- ########## OpenCV containers ########## -->
+  <!-- OpenCV containers that are similar to std containers -->
+  <container id="cvString" startPattern="cv :: String" inherits="stdString"/>
+  <!-- ########## OpenCV Allocation / Deallocation ########## -->
+  <memory>
+    <alloc init="false" buffer-size="malloc">cv::fastMalloc</alloc>
+    <dealloc>cv::fastFree</dealloc>
+  </memory>
+  <!-- ########## OpenCV Functions ########## -->
+  <!-- void cv::errorNoReturn	(int _code, const String & _err, const char * _func, const char * _file, int _line) -->
+  <function name="cv::errorNoReturn">
+    <noreturn>true</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void cv::fastFree (void *ptr) -->
+  <function name="cv::fastFree">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void * cv::fastMalloc (size_t bufSize) -->
+  <function name="cv::fastMalloc">
+    <noreturn>false</noreturn>
+    <returnValue type="void *"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- Mat cv::imread ( const String & filename, int flags = IMREAD_COLOR ) -->
+  <function name="cv::imread">
+    <noreturn>false</noreturn>
+    <returnValue type="cv::Mat"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in" default="cv::IMREAD_COLOR">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void cv::imshow ( const String & winname, InputArray mat ) -->
+  <!-- void cv::imshow ( const String & winname, const ogl::Texture2D & tex ) -->
+  <function name="cv::imshow">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void cv::namedWindow ( const String & winname, int flags = WINDOW_AUTOSIZE ) -->
+  <function name="cv::namedWindow">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in" default="cv::WINDOW_AUTOSIZE">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int cv::waitKey ( int delay = 0 ) -->
+  <function name="cv::waitKey">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in" default="0">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+</def>
diff --git a/cfg/opengl.cfg b/cfg/opengl.cfg
index 1c633c92aef..ec37abf5516 100644
--- a/cfg/opengl.cfg
+++ b/cfg/opengl.cfg
@@ -211,6 +211,7 @@
   <!-- https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glIsEnabled.xml -->
   <!-- GLboolean glIsEnabled( GLenum cap ); -->
   <function name="glIsEnabled">
+    <pure/>
     <noreturn>false</noreturn>
     <returnValue type="GLboolean"/>
     <use-retval/>
@@ -231,6 +232,39 @@
       <not-uninit/>
     </arg>
   </function>
+  <!-- https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glMaterial.xml -->
+  <!-- void glMaterialf( GLenum face, GLenum pname, GLfloat param); -->
+  <!-- void glMateriali( GLenum face, GLenum pname, GLint param); -->
+  <function name="glMaterialf,glMateriali">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void glMaterialfv( GLenum face, GLenum pname, const GLfloat * params); -->
+  <!-- void glMaterialiv( GLenum face, GLenum pname, const GLint * params); -->
+  <function name="glMaterialfv,glMaterialiv">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glMatrixMode.xml -->
   <!-- void glMatrixMode( GLenum mode); -->
   <function name="glMatrixMode">
diff --git a/cfg/openssl.cfg b/cfg/openssl.cfg
new file mode 100644
index 00000000000..d6dd39bdf81
--- /dev/null
+++ b/cfg/openssl.cfg
@@ -0,0 +1,174 @@
+<?xml version="1.0"?>
+<def format="2">
+  <!-- OpenSSL Library Configuration https://www.openssl.org/ -->
+  <!-- The OpenSSL library is typically included by "#include <openssl/*.h>" -->
+  <!-- ########## OpenSSL Types ########## -->
+  <!-- ########## OpenSSL Macros / Defines ########## -->
+  <!-- ########## OpenSSL Allocation / Deallocation ########## -->
+  <resource>
+    <alloc>EVP_CIPHER_CTX_new</alloc>
+    <dealloc>EVP_CIPHER_CTX_free</dealloc>
+  </resource>
+  <!-- ########## OpenSSL Functions ########## -->
+  <!-- int BIO_free(BIO *a); -->
+  <function name="BIO_free">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- BIO * BIO_new(const BIO_METHOD *type); -->
+  <function name="BIO_new">
+    <noreturn>false</noreturn>
+    <returnValue type="BIO *"/>
+    <use-retval/>
+    <arg nr="1"/>
+  </function>
+  <!-- int BIO_printf(BIO *bio, const char *format, ...) -->
+  <function name="BIO_printf">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <formatstr/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <formatstr/>
+    </arg>
+  </function>
+  <!-- int BIO_snprintf(char *buf, size_t n, const char *format, ...) -->
+  <function name="BIO_snprintf">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <minsize type="argvalue" arg="2"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <formatstr/>
+    <arg nr="3" direction="in">
+      <formatstr/>
+      <not-null/>
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void BIO_vfree(BIO *a); -->
+  <function name="BIO_vfree">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int BIO_vprintf(BIO *bio, const char *format, va_list args) -->
+  <function name="BIO_vprintf">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <formatstr/>
+    </arg>
+    <arg nr="3"/>
+  </function>
+  <!-- int BIO_vsnprintf(char *buf, size_t n, const char *format, va_list args) -->
+  <function name="BIO_vsnprintf">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <minsize type="argvalue" arg="2"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <formatstr/>
+    </arg>
+    <arg nr="4"/>
+  </function>
+  <!-- void EVP_CIPHER_CTX_free(EVP_CIPHER_CTX *ctx); -->
+  <function name="EVP_CIPHER_CTX_free">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1"/>
+  </function>
+  <!-- EVP_CIPHER_CTX *EVP_CIPHER_CTX_new(void); -->
+  <function name="EVP_CIPHER_CTX_new">
+    <noreturn>false</noreturn>
+    <returnValue type="EVP_CIPHER_CTX *"/>
+    <use-retval/>
+  </function>
+  <!-- int EVP_CIPHER_CTX_reset(EVP_CIPHER_CTX *ctx); -->
+  <function name="EVP_CIPHER_CTX_reset">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <arg nr="1">
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int EVP_EncryptFinal_ex(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl); -->
+  <function name="EVP_EncryptFinal_ex">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <arg nr="1"/>
+    <arg nr="2" direction="out"/>
+    <arg nr="3" direction="out">
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *type,
+                              ENGINE *impl, const unsigned char *key, const unsigned char *iv); -->
+  <function name="EVP_EncryptInit_ex">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <arg nr="1"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out,
+                             int *outl, const unsigned char *in, int inl); -->
+  <function name="EVP_EncryptUpdate">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <arg nr="1"/>
+    <arg nr="2" direction="out"/>
+    <arg nr="3" direction="out"/>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <minsize type="argvalue" arg="5"/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+</def>
diff --git a/cfg/pcre.cfg b/cfg/pcre.cfg
new file mode 100644
index 00000000000..2ab79ee94c5
--- /dev/null
+++ b/cfg/pcre.cfg
@@ -0,0 +1,165 @@
+<?xml version="1.0"?>
+<def>
+  <define name="PCRE_ANCHORED" value="0x00000010"/>
+  <define name="PCRE_AUTO_CALLOUT" value="0x00004000"/>
+  <define name="PCRE_BSR_ANYCRLF" value="0x00800000"/>
+  <define name="PCRE_BSR_UNICODE" value="0x01000000"/>
+  <define name="PCRE_CASELESS" value="0x00000001"/>
+  <define name="PCRE_CONFIG_BSR" value="8"/>
+  <define name="PCRE_CONFIG_JIT" value="9"/>
+  <define name="PCRE_CONFIG_JITTARGET" value="11"/>
+  <define name="PCRE_CONFIG_LINK_SIZE" value="2"/>
+  <define name="PCRE_CONFIG_MATCH_LIMIT" value="4"/>
+  <define name="PCRE_CONFIG_MATCH_LIMIT_RECURSION" value="7"/>
+  <define name="PCRE_CONFIG_NEWLINE" value="1"/>
+  <define name="PCRE_CONFIG_PARENS_LIMIT" value="13"/>
+  <define name="PCRE_CONFIG_POSIX_MALLOC_THRESHOLD" value="3"/>
+  <define name="PCRE_CONFIG_STACKRECURSE" value="5"/>
+  <define name="PCRE_CONFIG_UNICODE_PROPERTIES" value="6"/>
+  <define name="PCRE_CONFIG_UTF16" value="10"/>
+  <define name="PCRE_CONFIG_UTF32" value="12"/>
+  <define name="PCRE_CONFIG_UTF8" value="0"/>
+  <define name="PCRE_DFA_RESTART" value="0x00020000"/>
+  <define name="PCRE_DFA_SHORTEST" value="0x00010000"/>
+  <define name="PCRE_DOLLAR_ENDONLY" value="0x00000020"/>
+  <define name="PCRE_DOTALL" value="0x00000004"/>
+  <define name="PCRE_DUPNAMES" value="0x00080000"/>
+  <define name="PCRE_ERROR_BADCOUNT" value="(-15)"/>
+  <define name="PCRE_ERROR_BADENDIANNESS" value="(-29)"/>
+  <define name="PCRE_ERROR_BADLENGTH" value="(-32)"/>
+  <define name="PCRE_ERROR_BADMAGIC" value="(-4)"/>
+  <define name="PCRE_ERROR_BADMODE" value="(-28)"/>
+  <define name="PCRE_ERROR_BADNEWLINE" value="(-23)"/>
+  <define name="PCRE_ERROR_BADOFFSET" value="(-24)"/>
+  <define name="PCRE_ERROR_BADOPTION" value="(-3)"/>
+  <define name="PCRE_ERROR_BADPARTIAL" value="(-13)"/>
+  <define name="PCRE_ERROR_BADUTF16" value="(-10)"/>
+  <define name="PCRE_ERROR_BADUTF16_OFFSET" value="(-11)"/>
+  <define name="PCRE_ERROR_BADUTF32" value="(-10)"/>
+  <define name="PCRE_ERROR_BADUTF8" value="(-10)"/>
+  <define name="PCRE_ERROR_BADUTF8_OFFSET" value="(-11)"/>
+  <define name="PCRE_ERROR_CALLOUT" value="(-9)"/>
+  <define name="PCRE_ERROR_DFA_BADRESTART" value="(-30)"/>
+  <define name="PCRE_ERROR_DFA_RECURSE" value="(-20)"/>
+  <define name="PCRE_ERROR_DFA_UCOND" value="(-17)"/>
+  <define name="PCRE_ERROR_DFA_UITEM" value="(-16)"/>
+  <define name="PCRE_ERROR_DFA_UMLIMIT" value="(-18)"/>
+  <define name="PCRE_ERROR_DFA_WSSIZE" value="(-19)"/>
+  <define name="PCRE_ERROR_INTERNAL" value="(-14)"/>
+  <define name="PCRE_ERROR_JIT_BADOPTION" value="(-31)"/>
+  <define name="PCRE_ERROR_JIT_STACKLIMIT" value="(-27)"/>
+  <define name="PCRE_ERROR_MATCHLIMIT" value="(-8)"/>
+  <define name="PCRE_ERROR_NOMATCH" value="(-1)"/>
+  <define name="PCRE_ERROR_NOMEMORY" value="(-6)"/>
+  <define name="PCRE_ERROR_NOSUBSTRING" value="(-7)"/>
+  <define name="PCRE_ERROR_NULL" value="(-2)"/>
+  <define name="PCRE_ERROR_NULLWSLIMIT" value="(-22)"/>
+  <define name="PCRE_ERROR_PARTIAL" value="(-12)"/>
+  <define name="PCRE_ERROR_RECURSELOOP" value="(-26)"/>
+  <define name="PCRE_ERROR_RECURSIONLIMIT" value="(-21)"/>
+  <define name="PCRE_ERROR_SHORTUTF16" value="(-25)"/>
+  <define name="PCRE_ERROR_SHORTUTF8" value="(-25)"/>
+  <define name="PCRE_ERROR_UNKNOWN_NODE" value="(-5)"/>
+  <define name="PCRE_ERROR_UNKNOWN_OPCODE" value="(-5)"/>
+  <define name="PCRE_ERROR_UNSET" value="(-33)"/>
+  <define name="PCRE_EXTENDED" value="0x00000008"/>
+  <define name="PCRE_EXTRA" value="0x00000040"/>
+  <define name="PCRE_EXTRA_CALLOUT_DATA" value="0x0004"/>
+  <define name="PCRE_EXTRA_EXECUTABLE_JIT" value="0x0040"/>
+  <define name="PCRE_EXTRA_MARK" value="0x0020"/>
+  <define name="PCRE_EXTRA_MATCH_LIMIT" value="0x0002"/>
+  <define name="PCRE_EXTRA_MATCH_LIMIT_RECURSION" value="0x0010"/>
+  <define name="PCRE_EXTRA_STUDY_DATA" value="0x0001"/>
+  <define name="PCRE_EXTRA_TABLES" value="0x0008"/>
+  <define name="PCRE_FIRSTLINE" value="0x00040000"/>
+  <define name="PCRE_INFO_BACKREFMAX" value="3"/>
+  <define name="PCRE_INFO_CAPTURECOUNT" value="2"/>
+  <define name="PCRE_INFO_DEFAULT_TABLES" value="11"/>
+  <define name="PCRE_INFO_FIRSTBYTE" value="4"/>
+  <define name="PCRE_INFO_FIRSTCHAR" value="4"/>
+  <define name="PCRE_INFO_FIRSTCHARACTER" value="19"/>
+  <define name="PCRE_INFO_FIRSTCHARACTERFLAGS" value="20"/>
+  <define name="PCRE_INFO_FIRSTTABLE" value="5"/>
+  <define name="PCRE_INFO_HASCRORLF" value="14"/>
+  <define name="PCRE_INFO_JCHANGED" value="13"/>
+  <define name="PCRE_INFO_JIT" value="16"/>
+  <define name="PCRE_INFO_JITSIZE" value="17"/>
+  <define name="PCRE_INFO_LASTLITERAL" value="6"/>
+  <define name="PCRE_INFO_MATCHLIMIT" value="23"/>
+  <define name="PCRE_INFO_MATCH_EMPTY" value="25"/>
+  <define name="PCRE_INFO_MAXLOOKBEHIND" value="18"/>
+  <define name="PCRE_INFO_MINLENGTH" value="15"/>
+  <define name="PCRE_INFO_NAMECOUNT" value="8"/>
+  <define name="PCRE_INFO_NAMEENTRYSIZE" value="7"/>
+  <define name="PCRE_INFO_NAMETABLE" value="9"/>
+  <define name="PCRE_INFO_OKPARTIAL" value="12"/>
+  <define name="PCRE_INFO_OPTIONS" value="0"/>
+  <define name="PCRE_INFO_RECURSIONLIMIT" value="24"/>
+  <define name="PCRE_INFO_REQUIREDCHAR" value="21"/>
+  <define name="PCRE_INFO_REQUIREDCHARFLAGS" value="22"/>
+  <define name="PCRE_INFO_SIZE" value="1"/>
+  <define name="PCRE_INFO_STUDYSIZE" value="10"/>
+  <define name="PCRE_JAVASCRIPT_COMPAT" value="0x02000000"/>
+  <define name="PCRE_MULTILINE" value="0x00000002"/>
+  <define name="PCRE_NEVER_UTF" value="0x00010000"/>
+  <define name="PCRE_NEWLINE_ANY" value="0x00400000"/>
+  <define name="PCRE_NEWLINE_ANYCRLF" value="0x00500000"/>
+  <define name="PCRE_NEWLINE_CR" value="0x00100000"/>
+  <define name="PCRE_NEWLINE_CRLF" value="0x00300000"/>
+  <define name="PCRE_NEWLINE_LF" value="0x00200000"/>
+  <define name="PCRE_NOTBOL" value="0x00000080"/>
+  <define name="PCRE_NOTEMPTY" value="0x00000400"/>
+  <define name="PCRE_NOTEMPTY_ATSTART" value="0x10000000"/>
+  <define name="PCRE_NOTEOL" value="0x00000100"/>
+  <define name="PCRE_NO_AUTO_CAPTURE" value="0x00001000"/>
+  <define name="PCRE_NO_AUTO_POSSESS" value="0x00020000"/>
+  <define name="PCRE_NO_START_OPTIMISE" value="0x04000000"/>
+  <define name="PCRE_NO_START_OPTIMIZE" value="0x04000000"/>
+  <define name="PCRE_NO_UTF16_CHECK" value="0x00002000"/>
+  <define name="PCRE_NO_UTF32_CHECK" value="0x00002000"/>
+  <define name="PCRE_NO_UTF8_CHECK" value="0x00002000"/>
+  <define name="PCRE_PARTIAL" value="0x00008000"/>
+  <define name="PCRE_PARTIAL_HARD" value="0x08000000"/>
+  <define name="PCRE_PARTIAL_SOFT" value="0x00008000"/>
+  <define name="PCRE_STUDY_EXTRA_NEEDED" value="0x0008"/>
+  <define name="PCRE_STUDY_JIT_COMPILE" value="0x0001"/>
+  <define name="PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE" value="0x0004"/>
+  <define name="PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE" value="0x0002"/>
+  <define name="PCRE_UCP" value="0x20000000"/>
+  <define name="PCRE_UNGREEDY" value="0x00000200"/>
+  <define name="PCRE_UTF16" value="0x00000800"/>
+  <define name="PCRE_UTF16_ERR0" value="0"/>
+  <define name="PCRE_UTF16_ERR1" value="1"/>
+  <define name="PCRE_UTF16_ERR2" value="2"/>
+  <define name="PCRE_UTF16_ERR3" value="3"/>
+  <define name="PCRE_UTF16_ERR4" value="4"/>
+  <define name="PCRE_UTF32" value="0x00000800"/>
+  <define name="PCRE_UTF32_ERR0" value="0"/>
+  <define name="PCRE_UTF32_ERR1" value="1"/>
+  <define name="PCRE_UTF32_ERR2" value="2"/>
+  <define name="PCRE_UTF32_ERR3" value="3"/>
+  <define name="PCRE_UTF8" value="0x00000800"/>
+  <define name="PCRE_UTF8_ERR0" value="0"/>
+  <define name="PCRE_UTF8_ERR1" value="1"/>
+  <define name="PCRE_UTF8_ERR10" value="10"/>
+  <define name="PCRE_UTF8_ERR11" value="11"/>
+  <define name="PCRE_UTF8_ERR12" value="12"/>
+  <define name="PCRE_UTF8_ERR13" value="13"/>
+  <define name="PCRE_UTF8_ERR14" value="14"/>
+  <define name="PCRE_UTF8_ERR15" value="15"/>
+  <define name="PCRE_UTF8_ERR16" value="16"/>
+  <define name="PCRE_UTF8_ERR17" value="17"/>
+  <define name="PCRE_UTF8_ERR18" value="18"/>
+  <define name="PCRE_UTF8_ERR19" value="19"/>
+  <define name="PCRE_UTF8_ERR2" value="2"/>
+  <define name="PCRE_UTF8_ERR20" value="20"/>
+  <define name="PCRE_UTF8_ERR21" value="21"/>
+  <define name="PCRE_UTF8_ERR22" value="22"/>
+  <define name="PCRE_UTF8_ERR3" value="3"/>
+  <define name="PCRE_UTF8_ERR4" value="4"/>
+  <define name="PCRE_UTF8_ERR5" value="5"/>
+  <define name="PCRE_UTF8_ERR6" value="6"/>
+  <define name="PCRE_UTF8_ERR7" value="7"/>
+  <define name="PCRE_UTF8_ERR8" value="8"/>
+  <define name="PCRE_UTF8_ERR9" value="9"/>
+</def>
diff --git a/cfg/posix.cfg b/cfg/posix.cfg
index 6d83b6676af..751142bacc1 100644
--- a/cfg/posix.cfg
+++ b/cfg/posix.cfg
@@ -14,6 +14,149 @@
       <not-bool/>
     </arg>
   </function>
+  <!-- int semop(int semid, struct sembuf *sops, size_t nsops); -->
+  <function name="semop">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/wcsnrtombs.3.html -->
+  <!-- size_t wcsnrtombs(char *restrict dest, const wchar_t **restrict src, size_t nwc, size_t len, mbstate_t *restrict ps); -->
+  <function name="wcsnrtombs">
+    <use-retval/>
+    <returnValue type="size_t"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-bool/>
+      <minsize type="argvalue" arg="4"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="5" direction="inout">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/aio_read.3.html -->
+  <!-- int aio_read(struct aiocb *aiocbp); -->
+  <!-- https://man7.org/linux/man-pages/man3/aio_write.3.html -->
+  <!-- int aio_write(struct aiocb *aiocbp); -->
+  <function name="aio_read,aio_write">
+    <use-retval/>
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/aio_return.3.html -->
+  <!-- ssize_t aio_return(struct aiocb *aiocbp); -->
+  <function name="aio_return">
+    <use-retval/>
+    <returnValue type="ssize_t"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/aio_error.3.html -->
+  <!-- int aio_error(struct aiocb *aiocbp); -->
+  <function name="aio_error">
+    <use-retval/>
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/aio_fsync.3.html -->
+  <!-- int aio_fsync(int op, struct aiocb *aiocbp); -->
+  <function name="aio_fsync">
+    <use-retval/>
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="inout">
+      <not-null/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/aio_cancel.3.html -->
+  <!-- int aio_cancel(int fd, struct aiocb *aiocbp); -->
+  <function name="aio_cancel">
+    <use-retval/>
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="inout">
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/aio_suspend.3.html -->
+  <!-- int aio_suspend(const struct aiocb *const aiocb_list[], int nitems, const struct timespec *restrict timeout); -->
+  <function name="aio_suspend">
+    <use-retval/>
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
   <!-- http://man7.org/linux/man-pages/man3/a64l.3.html -->
   <!-- long a64l(const char *str64); -->
   <function name="a64l">
@@ -52,6 +195,7 @@
     <arg nr="1" direction="in">
       <not-uninit/>
       <valid>0:255</valid>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -67,6 +211,7 @@
     <arg nr="1" direction="in">
       <not-uninit/>
       <valid>0:255</valid>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -82,6 +227,7 @@
     <arg nr="1" direction="in">
       <not-uninit/>
       <valid>0:255</valid>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -97,6 +243,7 @@
     <arg nr="1" direction="in">
       <not-uninit/>
       <valid>0:255</valid>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -112,6 +259,7 @@
     <arg nr="1" direction="in">
       <not-uninit/>
       <valid>0:255</valid>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -127,6 +275,7 @@
     <arg nr="1" direction="in">
       <not-uninit/>
       <valid>0:255</valid>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -142,6 +291,7 @@
     <arg nr="1" direction="in">
       <not-uninit/>
       <valid>0:255</valid>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -157,6 +307,7 @@
     <arg nr="1" direction="in">
       <not-uninit/>
       <valid>0:255</valid>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -172,6 +323,7 @@
     <arg nr="1" direction="in">
       <not-uninit/>
       <valid>0:255</valid>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -187,6 +339,7 @@
     <arg nr="1" direction="in">
       <not-uninit/>
       <valid>0:255</valid>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -201,6 +354,7 @@
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:255</valid>
     </arg>
   </function>
@@ -262,6 +416,7 @@
     <arg nr="1" direction="in">
       <not-uninit/>
       <not-null/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -356,6 +511,13 @@
       <not-uninit/>
     </arg>
   </function>
+  <!-- see https://www.man7.org/linux/man-pages/man3/dlerror.3.html -->
+  <!-- char *dlerror(void); -->
+  <function name="dlerror">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <returnValue type="char*"/>
+  </function>
   <!-- see http://pubs.opengroup.org/onlinepubs/9699919799/functions/dlopen.html -->
   <!-- void *dlopen(const char *file, int mode); -->
   <function name="dlopen">
@@ -364,6 +526,7 @@
     <returnValue type="void*"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -382,6 +545,7 @@
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- see http://pubs.opengroup.org/onlinepubs/9699919799/functions/dlclose.html -->
@@ -451,6 +615,7 @@
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="inout">
@@ -464,6 +629,7 @@
     <returnValue type="int"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
@@ -478,6 +644,7 @@
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="inout">
@@ -516,6 +683,7 @@
     <arg nr="1" direction="in">
       <not-uninit/>
       <not-null/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -547,6 +715,7 @@
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -560,6 +729,7 @@
     <returnValue type="int"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -573,6 +743,7 @@
     <returnValue type="int"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
@@ -587,6 +758,7 @@
     <returnValue type="int"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
@@ -624,15 +796,17 @@
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
-      <not-null/>
+      <valid>0:</valid>
       <not-uninit/>
       <not-bool/>
     </arg>
     <arg nr="3" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- int symlink(const char *oldpath, const char *newpath); -->
@@ -643,11 +817,13 @@
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- int open(const char *pathname, int flags) -->
@@ -660,6 +836,7 @@
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -679,10 +856,12 @@
     <noreturn>false</noreturn>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -701,6 +880,7 @@
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -736,6 +916,7 @@ The obsolescent function 'usleep' is called. POSIX.1-2001 declares usleep() func
     <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- http://man7.org/linux/man-pages/man3/dirfd.3.html -->
@@ -757,10 +938,12 @@ The obsolescent function 'usleep' is called. POSIX.1-2001 declares usleep() func
     <returnValue type="int"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -779,6 +962,7 @@ The obsolescent function 'usleep' is called. POSIX.1-2001 declares usleep() func
     <arg nr="1" direction="in">
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- http://man7.org/linux/man-pages/man2/alarm.2.html -->
@@ -844,6 +1028,7 @@ The obsolescent function 'usleep' is called. POSIX.1-2001 declares usleep() func
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
     <warn severity="portability">Non reentrant function 'getprotobyname' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getprotobyname_r'.</warn>
   </function>
@@ -876,10 +1061,12 @@ The obsolescent function 'usleep' is called. POSIX.1-2001 declares usleep() func
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
     <warn severity="portability">Non reentrant function 'getservbyname' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getservbyname_r'.</warn>
   </function>
@@ -891,10 +1078,12 @@ The obsolescent function 'usleep' is called. POSIX.1-2001 declares usleep() func
     <returnValue type="struct servent *"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
     <warn severity="portability">Non reentrant function 'getservbyport' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getservbyport_r'.</warn>
   </function>
@@ -916,6 +1105,7 @@ The obsolescent function 'usleep' is called. POSIX.1-2001 declares usleep() func
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
     <warn severity="portability">Non reentrant function 'getnetbyname' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getnetbyname_r'.</warn>
   </function>
@@ -927,6 +1117,7 @@ The obsolescent function 'usleep' is called. POSIX.1-2001 declares usleep() func
     <returnValue type="struct netent *"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -952,6 +1143,7 @@ The obsolescent function 'usleep' is called. POSIX.1-2001 declares usleep() func
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
     <warn severity="style" reason="Obsolescent" alternatives="getaddrinfo"/>
   </function>
@@ -964,6 +1156,7 @@ The obsolescent function 'usleep' is called. POSIX.1-2001 declares usleep() func
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -983,6 +1176,7 @@ The obsolescent function 'usleep' is called. POSIX.1-2001 declares usleep() func
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -1041,17 +1235,7 @@ The obsolescent function 'usleep' is called. POSIX.1-2001 declares usleep() func
       <not-null/>
       <not-uninit/>
       <not-bool/>
-    </arg>
-  </function>
-  <!-- char *strdup(const char *s); -->
-  <function name="strdup">
-    <noreturn>false</noreturn>
-    <returnValue type="char *"/>
-    <use-retval/>
-    <arg nr="1">
-      <not-null/>
-      <not-uninit/>
-      <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- char *strndup(const char *s, size_t n); -->
@@ -1062,6 +1246,7 @@ The obsolescent function 'usleep' is called. POSIX.1-2001 declares usleep() func
     <arg nr="1">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2">
       <not-uninit/>
@@ -1078,6 +1263,7 @@ The obsolescent function 'usleep' is called. POSIX.1-2001 declares usleep() func
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- int mkstemp(char *template); -->
@@ -1137,6 +1323,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -1151,6 +1338,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -1166,10 +1354,12 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -1185,10 +1375,12 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -1202,10 +1394,12 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -1223,10 +1417,12 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -1250,6 +1446,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- int chdir(const char *path); -->
@@ -1261,6 +1458,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- int chroot(const char *path); -->
@@ -1272,6 +1470,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- int link(const char *oldpath, const char *newpath); -->
@@ -1282,11 +1481,13 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- int linkat(int fd1, const char *path1, int fd2, const char *path2, int flag); -->
@@ -1296,19 +1497,24 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="int"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>0:</valid>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <valid>0:</valid>
     </arg>
     <arg nr="4" direction="in">
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- int unlinkat(int fd, const char *path, int flag); -->
@@ -1318,14 +1524,18 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="int"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>0:</valid>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- int unlink(const char *pathname); -->
@@ -1337,6 +1547,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- int stat(const char *file_name, struct stat *buf); -->
@@ -1347,6 +1558,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="out">
       <not-null/>
@@ -1361,19 +1573,20 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="out">
       <not-null/>
       <not-bool/>
     </arg>
   </function>
-  <!-- int fstat(const char *file_name, struct stat *buf); -->
+  <!-- int fstat(int fd, struct stat *statbuf); -->
   <function name="fstat">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="int"/>
     <arg nr="1" direction="in">
-      <not-null/>
+      <valid>0:</valid>
       <not-uninit/>
     </arg>
     <arg nr="2" direction="out">
@@ -1382,19 +1595,18 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
   </function>
   <!-- int fstatat(int dirfd, const char *pathname, struct stat *statbuf, int flags); -->
-  <!-- Note: fstatat64() is a large-file version of the fstatat() function as defined in POSIX 1003.1-2008 (ISO/IEC 9945-2009). -->
-  <!-- int fstatat64(int dirfd, const char *pathname, struct stat64  *statbuf, int flags); -->
-  <!-- int __fxstatat64(int dirfd, const char *pathname, struct stat64  *statbuf, int flags); -->
-  <function name="fstatat,fstatat64,__fxstatat64">
+  <function name="fstatat">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="int"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="out">
       <not-null/>
@@ -1413,6 +1625,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -1426,6 +1639,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="mode_t"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- int fchmod(int fildes, mode_t mode); -->
@@ -1450,6 +1664,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -1467,6 +1682,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -1483,6 +1699,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="int"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
@@ -1511,6 +1728,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -1518,6 +1736,20 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <warn severity="style" reason="Obsolescent" alternatives="utimensat"/>
   </function>
+  <!-- https://man7.org/linux/man-pages/man3/encrypt.3.html -->
+  <!-- void encrypt(char block[64], int edflag);-->
+  <function name="encrypt">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <minsize type="value" value="64" baseType="char"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- int futimens(int fd, const struct timespec times[2]);-->
   <function name="futimens">
     <noreturn>false</noreturn>
@@ -1525,12 +1757,13 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="int"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
-    <arg nr="3" direction="in">
+    <arg nr="2" direction="in">
       <not-uninit/>
       <not-bool/>
-      <minsize type="value" value="2"/>
+      <minsize type="value" value="2" baseType="timespec"/>
     </arg>
   </function>
   <!-- int utimensat(int dirfd, const char *pathname, const struct timespec times[2], int flags);-->
@@ -1540,15 +1773,17 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="int"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
       <not-bool/>
-      <minsize type="value" value="2"/>
+      <minsize type="value" value="2" baseType="timespec"/>
     </arg>
     <arg nr="4" direction="in">
       <not-uninit/>
@@ -1563,12 +1798,14 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
       <not-bool/>
-      <minsize type="value" value="2"/>
+      <minsize type="value" value="2" baseType="timeval"/>
     </arg>
+    <warn severity="style" reason="Obsolescent" alternatives="utimensat"/>
   </function>
   <!-- DIR *opendir(const char *name); -->
   <function name="opendir">
@@ -1579,6 +1816,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- DIR *fdopendir(int fd); -->
@@ -1612,11 +1850,13 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2">
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- int pclose(FILE *stream); -->
@@ -1635,9 +1875,11 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="int"/>
     <arg nr="1">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3">
       <not-uninit/>
@@ -1653,12 +1895,15 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="4" direction="in">
       <not-null/>
@@ -1678,12 +1923,15 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="4" direction="out">
       <not-null/>
@@ -1701,6 +1949,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1">
       <not-uninit/>
       <not-bool/>
+      <valid>-20:19</valid>
     </arg>
   </function>
   <!-- int pause(void); -->
@@ -1726,6 +1975,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="size_t"/>
     <arg nr="1">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2">
       <not-uninit/>
@@ -1743,6 +1993,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="long int"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
@@ -1758,6 +2009,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -1781,12 +2033,14 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <noreturn>false</noreturn>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2">
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- long int random(void); -->
@@ -1799,8 +2053,8 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
   <function name="srandom">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <!-- It is common practice to call srandom with an uninitialized 
-         variable. Therefore, no warning shall be generated in this 
+    <!-- It is common practice to call srandom with an uninitialized
+         variable. Therefore, no warning shall be generated in this
          very special case. -->
     <arg nr="1"/>
   </function>
@@ -1825,6 +2079,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="2">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- int rand_r(unsigned int *seedp); -->
@@ -1848,13 +2103,16 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
+  <!-- https://man7.org/linux/man-pages/man3/strncasecmp.3.html -->
   <!-- int strncasecmp(const char *s1, const char *s2, size_t n); -->
   <function name="strncasecmp">
     <pure/>
@@ -1865,41 +2123,156 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <minsize type="argvalue" arg="3"/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <minsize type="argvalue" arg="3"/>
     </arg>
     <arg nr="3" direction="in">
       <not-bool/>
       <valid>0:</valid>
     </arg>
   </function>
-  <!-- ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count); -->
-  <function name="sendfile">
+  <!-- https://man7.org/linux/man-pages/man3/wcsncasecmp.3.html -->
+  <!-- int wcsncasecmp(const wchar_t *s1, const wchar_t *s2, size_t n) -->
+  <function name="wcsncasecmp">
+    <pure/>
+    <use-retval/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count); -->
+  <function name="sendfile">
     <leak-ignore/>
     <returnValue type="ssize_t"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
     </arg>
     <arg nr="4" direction="in">
+      <not-bool/>
       <valid>1:</valid>
     </arg>
   </function>
+  <!-- void srand48(long int seedval); -->
+  <function name="srand48">
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- unsigned short *seed48(unsigned short seed16v[3]); -->
+  <function name="seed48">
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="unsigned short *"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+      <minsize type="value" value="3" baseType="unsigned short"/>
+    </arg>
+  </function>
+  <!-- long int jrand48(unsigned short xsubi[3]); -->
+  <function name="jrand48">
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="long int"/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+      <minsize type="value" value="3" baseType="unsigned short"/>
+    </arg>
+  </function>
+  <!-- long int nrand48(unsigned short xsubi[3]); -->
+  <function name="nrand48">
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="long int"/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+      <minsize type="value" value="3" baseType="unsigned short"/>
+    </arg>
+  </function>
+  <!-- double erand48(unsigned short xsubi[3]); -->
+  <function name="erand48">
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="double"/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+      <minsize type="value" value="3" baseType="unsigned short"/>
+    </arg>
+  </function>
+  <!-- void lcong48(unsigned short param[7]); -->
+  <function name="lcong48">
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+      <minsize type="value" value="7" baseType="unsigned short"/>
+    </arg>
+  </function>
   <!-- ssize_t read(int fd, void *buf, size_t count); -->
   <function name="read">
     <leak-ignore/>
     <returnValue type="ssize_t"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="out">
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/read.3p.html -->
+  <!-- ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset); -->
+  <function name="pread">
+    <leak-ignore/>
+    <returnValue type="ssize_t"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="out">
@@ -1910,6 +2283,10 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-bool/>
       <valid>0:</valid>
     </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
   <!-- ssize_t write(int fildes, const void *buf, size_t nbyte); -->
   <function name="write">
@@ -1918,9 +2295,31 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="ssize_t"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/write.3p.html -->
+  <!-- ssize_t pwrite(int fd, const void *buf, size_t count, off_t offset); -->
+  <function name="pwrite">
+    <returnValue type="ssize_t"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
       <valid>0:</valid>
+      <not-uninit/>
     </arg>
     <arg nr="2" direction="in">
+      <not-null/>
       <not-uninit/>
       <minsize type="argvalue" arg="3"/>
     </arg>
@@ -1929,19 +2328,26 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-bool/>
       <valid>0:</valid>
     </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
   <!-- ssize_t recv(int sockfd, void *buf, size_t len, int flags); -->
   <function name="recv">
     <returnValue type="ssize_t"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="out">
+      <not-null/>
       <minsize type="argvalue" arg="3"/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <valid>0:</valid>
     </arg>
     <arg nr="4" direction="in">
       <not-uninit/>
@@ -1954,16 +2360,21 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="ssize_t"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="out">
+      <not-null/>
       <minsize type="argvalue" arg="3"/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
     </arg>
     <arg nr="4" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="5" direction="out"/>
     <arg nr="6" direction="inout">
@@ -1991,36 +2402,47 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
       <minsize type="argvalue" arg="3"/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <valid>0:</valid>
     </arg>
     <arg nr="4" direction="in">
       <not-uninit/>
       <not-bool/>
     </arg>
   </function>
+  <!-- https://man7.org/linux/man-pages/man3/sendto.3p.html -->
   <!-- ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                       const struct sockaddr *dest_addr, socklen_t addrlen); -->
   <function name="sendto">
     <returnValue type="ssize_t"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
+      <not-null/>
       <minsize type="argvalue" arg="3"/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="4" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="5" direction="in"/>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+    </arg>
     <arg nr="6" direction="in">
       <not-bool/>
+      <not-uninit/>
+      <valid>0:</valid>
     </arg>
   </function>
   <!-- ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags); -->
@@ -2028,6 +2450,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="ssize_t"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
@@ -2050,16 +2473,20 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>1:</valid>
     </arg>
     <arg nr="3" direction="in">
+      <not-bool/>
       <not-uninit/>
     </arg>
     <arg nr="4" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="5" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="6" direction="in">
@@ -2078,16 +2505,20 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>1:</valid>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="4" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="5" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="6" direction="in">
@@ -2117,9 +2548,11 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -2132,10 +2565,12 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="int"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="any">
       <not-uninit/>
@@ -2149,10 +2584,12 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="int"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="any">
       <not-uninit/>
@@ -2164,10 +2601,12 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <formatstr/>
     <arg nr="2" direction="in">
       <formatstr/>
+      <strz/>
     </arg>
     <arg nr="any">
       <not-uninit/>
@@ -2180,10 +2619,12 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
       <formatstr/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -2260,7 +2701,6 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
   </function>
   <!-- int setuid(uid_t uid); -->
   <function name="setuid">
-    <use-retval/>
     <returnValue type="int"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
@@ -2271,7 +2711,6 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
   </function>
   <!-- int seteuid(uid_t euid); -->
   <function name="seteuid">
-    <use-retval/>
     <returnValue type="int"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
@@ -2282,7 +2721,6 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
   </function>
   <!-- int setgid(gid_t gid); -->
   <function name="setgid">
-    <use-retval/>
     <returnValue type="int"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
@@ -2293,7 +2731,6 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
   </function>
   <!-- int setegid(gid_t egid); -->
   <function name="setegid">
-    <use-retval/>
     <returnValue type="int"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
@@ -2308,6 +2745,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <noreturn>false</noreturn>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -2320,17 +2758,20 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <noreturn>false</noreturn>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="4" direction="out">
       <not-null/>
       <not-bool/>
-      <minsize type="value" value="2"/>
+      <minsize type="value" value="2" baseType="int"/>
     </arg>
   </function>
   <!-- http://man7.org/linux/man-pages/man2/socketpair.2.html -->
@@ -2342,14 +2783,14 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="out">
       <not-null/>
       <not-bool/>
-      <minsize type="value" value="2"/>
+      <minsize type="value" value="2" baseType="int"/>
     </arg>
   </function>
   <!-- int pselect(int nfds, fd_set *restrict readfds,
        fd_set *restrict writefds, fd_set *restrict errorfds,
        const struct timespec *restrict timeout,
        const sigset_t *restrict sigmask);
-	   see http://pubs.opengroup.org/onlinepubs/9699919799/functions/pselect.html -->
+       see http://pubs.opengroup.org/onlinepubs/9699919799/functions/pselect.html -->
   <function name="pselect">
     <noreturn>false</noreturn>
     <returnValue type="int"/>
@@ -2408,6 +2849,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <noreturn>false</noreturn>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -2420,6 +2862,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <noreturn>false</noreturn>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -2573,6 +3016,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="any"/>
   </function>
@@ -2589,6 +3033,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="4" direction="out">
@@ -2609,9 +3054,12 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
     </arg>
     <arg nr="4" direction="in">
       <not-bool/>
+      <valid>0:</valid>
     </arg>
   </function>
   <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/mq_setattr.html -->
@@ -2642,6 +3090,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="4" direction="out"/>
     <arg nr="5" direction="in">
@@ -2659,7 +3108,10 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <not-null/>
       <minsize type="argvalue" arg="3"/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -2668,6 +3120,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-uninit/>
     </arg>
     <arg nr="5" direction="in">
+      <not-null/>
       <not-uninit/>
       <not-bool/>
     </arg>
@@ -2680,6 +3133,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/dbm_clearerr.html -->
@@ -2766,9 +3220,11 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -2811,9 +3267,11 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <noreturn>false</noreturn>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -2822,6 +3280,55 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-bool/>
     </arg>
   </function>
+  <!-- int getnameinfo(const struct sockaddr *restrict sa,
+                       socklen_t salen,
+                       char *restrict node,
+                       socklen_t nodelen,
+                       char *restrict service,
+                       socklen_t servicelen,
+                       int flags); -->
+  <function name="getnameinfo">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <minsize type="argvalue" arg="2"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="3" direction="out">
+      <minsize type="argvalue" arg="4"/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="5" direction="out">
+      <minsize type="argvalue" arg="6"/>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="7" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const char *gai_strerror(int ecode); -->
+  <function name="gai_strerror">
+    <noreturn>false</noreturn>
+    <returnValue type="const char *"/>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
   <!-- void endhostent(void); -->
   <function name="endhostent">
     <noreturn>false</noreturn>
@@ -2833,6 +3340,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- int uname(struct utsname *buf); -->
@@ -2844,7 +3352,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-bool/>
     </arg>
   </function>
-  <!--void           endpwent(void); -->
+  <!--void endpwent(void); -->
   <function name="endpwent">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
@@ -2856,44 +3364,96 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <noreturn>false</noreturn>
     <warn severity="portability">Non reentrant function 'getpwent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getpwent_r'.</warn>
   </function>
-  <!--struct passwd *getpwnam(const char *); -->
-  <function name="getpwnam">
+  <!-- https://man7.org/linux/man-pages/man3/getpwent_r.3.html-->
+  <!-- int fgetpwent_r(FILE *restrict stream, struct passwd *restrict pwbuf, char *restrict buf, size_t buflen, struct passwd **restrict pwbufp); -->
+  <function name="fgetpwent_r">
     <use-retval/>
-    <returnValue type="struct passwd *"/>
+    <returnValue type="int"/>
     <noreturn>false</noreturn>
-    <arg nr="1" direction="in">
+    <arg nr="1">
+      <not-null/>
       <not-uninit/>
-      <not-bool/>
     </arg>
-    <warn severity="portability">Non reentrant function 'getpwnam' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getpwnam_r'.</warn>
-  </function>
-  <!-- char *strtok(char *s, const char *ct); -->
-  <function name="strtok,std::strtok">
-    <!-- Already configured in std.cfg. Add only a warning for POSIX that a
-    threadsafe function exists that should be used. -->
-    <warn severity="portability">Non reentrant function 'strtok' called. For threadsafe applications it is recommended to use the reentrant replacement function 'strtok_r'.</warn>
-  </function>
-  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/strtok.html -->
-  <!-- char *strtok_r(char *str, const char *delim, char **saveptr); -->
-  <function name="strtok_r">
-    <!-- strtok may modify the first argument, so using the return value is not mandatory -->
-    <noreturn>false</noreturn>
-    <returnValue type="char *"/>
-    <pure/>
-    <leak-ignore/>
-    <arg nr="1" direction="inout">
+    <arg nr="2" direction="in">
+      <not-null/>
       <not-uninit/>
     </arg>
-    <arg nr="2" direction="in">
+    <arg nr="3" direction="out">
       <not-null/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="4" direction="in">
       <not-uninit/>
+      <valid>0:</valid>
     </arg>
-    <arg nr="3" direction="inout">
+    <arg nr="5" direction="out">
       <not-null/>
       <not-bool/>
     </arg>
   </function>
-  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpwnam.html -->
+  <!-- https://man7.org/linux/man-pages/man3/getpwent_r.3.html-->
+  <!-- int getpwent_r(struct passwd *restrict pwbuf, char *restrict buf, size_t buflen, struct passwd **restrict pwbufp); -->
+  <function name="getpwent_r">
+    <use-retval/>
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="4" direction="out">
+      <not-null/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!--struct passwd *getpwnam(const char *); -->
+  <function name="getpwnam">
+    <use-retval/>
+    <returnValue type="struct passwd *"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <strz/>
+    </arg>
+    <warn severity="portability">Non reentrant function 'getpwnam' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getpwnam_r'.</warn>
+  </function>
+  <!-- char *strtok(char *s, const char *ct); -->
+  <function name="strtok,std::strtok">
+    <!-- Already configured in std.cfg. Add only a warning for POSIX that a
+    threadsafe function exists that should be used. -->
+    <warn severity="portability">Non reentrant function 'strtok' called. For threadsafe applications it is recommended to use the reentrant replacement function 'strtok_r'.</warn>
+  </function>
+  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/strtok.html -->
+  <!-- char *strtok_r(char *str, const char *delim, char **saveptr); -->
+  <function name="strtok_r">
+    <!-- strtok may modify the first argument, so using the return value is not mandatory -->
+    <noreturn>false</noreturn>
+    <returnValue type="char *"/>
+    <pure/>
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="inout">
+      <not-null/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpwnam.html -->
   <!-- int getpwnam_r(const char *name, struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result); -->
   <function name="getpwnam_r">
     <use-retval/>
@@ -2901,17 +3461,24 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <noreturn>false</noreturn>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
     </arg>
-    <arg nr="2" direction="out"/>
     <arg nr="3" direction="out">
+      <not-null/>
       <minsize type="argvalue" arg="4"/>
     </arg>
     <arg nr="4" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="5" direction="out">
       <not-bool/>
+      <not-null/>
     </arg>
   </function>
   <!-- struct passwd *getpwuid(uid_t uid); -->
@@ -2925,24 +3492,31 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <warn severity="portability">Non reentrant function 'getpwuid' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getpwuid_r'.</warn>
   </function>
-  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpwuid.html -->
-  <!-- int getpwuid_r(uid_t uid, struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result); -->
+  <!-- https://man7.org/linux/man-pages/man3/getpwnam.3.html -->
+  <!-- int getpwuid_r(uid_t uid, struct passwd *restrict pwd, char *restrict buf, size_t buflen, struct passwd **restrict result) -->
   <function name="getpwuid_r">
     <returnValue type="int"/>
+    <use-retval/>
     <noreturn>false</noreturn>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
     </arg>
-    <arg nr="2" direction="out"/>
     <arg nr="3" direction="out">
+      <not-null/>
       <minsize type="argvalue" arg="4"/>
     </arg>
     <arg nr="4" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="5" direction="out">
       <not-bool/>
+      <not-null/>
     </arg>
   </function>
   <!-- void setpwent(void); -->
@@ -2971,13 +3545,16 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="4" direction="in">
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/catopen.html -->
@@ -2988,6 +3565,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -3011,6 +3589,90 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-bool/>
     </arg>
   </function>
+  <!-- https://man7.org/linux/man-pages/man3/lsearch.3.html -->
+  <!-- void *lfind(const void *key, const void *base, size_t *nmemb, size_t size, int(*compar)(const void *, const void *)); -->
+  <function name="lfind">
+    <returnValue type="void *"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <minsize type="argvalue" arg="4"/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>1:</valid>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/lsearch.3.html -->
+  <!-- void *lsearch(const void *key, void *base, size_t *nmemb, size_t size, int(*compar)(const void *, const void *)); -->
+  <function name="lsearch">
+    <returnValue type="void *"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <minsize type="argvalue" arg="4"/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>1:</valid>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/mbsnrtowcs.3.html -->
+  <!-- size_t mbsnrtowcs(wchar_t *restrict dest, const char **restrict src, size_t nms, size_t len, mbstate_t *restrict ps) -->
+  <function name="mbsnrtowcs">
+    <returnValue type="size_t"/>
+    <use-retval/>
+    <noreturn>false</noreturn>
+    <!-- If dest is NULL, len is ignored, and the conversion proceeds as
+       above, except that the converted wide characters are not written
+       out to memory, and that no length limit exists. -->
+    <arg nr="1" direction="out"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <!-- In both of the above cases, if ps is NULL, a static anonymous
+       state known only to the mbsrtowcs() function is used instead. -->
+    <arg nr="5" direction="in"/>
+  </function>
   <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/regcomp.html -->
   <!-- int regcomp(regex_t *restrict preg, const char *restrict pattern, int cflags); -->
   <function name="regcomp">
@@ -3021,6 +3683,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -3057,9 +3720,11 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="4" direction="out"/>
@@ -3104,6 +3769,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <noreturn>false</noreturn>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="out">
@@ -3129,6 +3795,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="int"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="out">
       <not-null/>
@@ -3142,6 +3809,8 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <noreturn>false</noreturn>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -3155,10 +3824,12 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <noreturn>false</noreturn>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -3182,6 +3853,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="out">
       <not-null/>
@@ -3202,6 +3874,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="out">
       <not-null/>
@@ -3222,6 +3895,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="out">
       <not-null/>
@@ -3237,15 +3911,63 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:2</valid>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/lseek64.3.html -->
+  <!-- off64_t lseek64(int fildes, off64_t offset, int whence); defined in POSIX.1 (1996). -->
+  <function name="lseek64">
+    <returnValue type="off64_t"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:2</valid>
     </arg>
   </function>
+  <!-- https://man7.org/linux/man-pages/man3/lseek64.3.html -->
+  <!-- loff_t llseek(int fd, loff_t offset, int whence); -->
+  <function name="llseek">
+    <returnValue type="loff_t"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:2</valid>
+    </arg>
+    <!-- Note: Since glibc 2.28, this function symbol is no longer available to newly linked applications. -->
+    <warn severity="style" reason="Obsolescent" alternatives="lseek64"/>
+  </function>
   <!-- int nanosleep(const struct timespec *rqtp, struct timespec *rmtp); -->
   <function name="nanosleep">
     <returnValue type="int"/>
@@ -3266,6 +3988,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- char *getpass(const char *prompt); -->
@@ -3276,6 +3999,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- http://pubs.opengroup.org/onlinepubs/009695399/basedefs/stdlib.h.html -->
@@ -3285,6 +4009,13 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="double"/>
     <noreturn>false</noreturn>
   </function>
+  <!-- long int lrand48(void); -->
+  <!-- long int mrand48(void); -->
+  <function name="lrand48,mrand48">
+    <use-retval/>
+    <returnValue type="long int"/>
+    <noreturn>false</noreturn>
+  </function>
   <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/putenv.html -->
   <!-- int putenv(char *string); -->
   <function name="putenv">
@@ -3304,10 +4035,12 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -3321,6 +4054,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- struct tm * localtime(const time_t *tp); -->
@@ -3328,6 +4062,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <noreturn>false</noreturn>
     <returnValue type="struct tm *"/>
     <leak-ignore/>
+    <use-retval/>
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
@@ -3360,7 +4095,6 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-uninit/>
       <not-bool/>
     </arg>
-    <warn severity="portability">Non reentrant function 'readdir' called. For threadsafe applications it is recommended to use the reentrant replacement function 'readdir_r'.</warn>
   </function>
   <!-- int readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result); -->
   <function name="readdir_r">
@@ -3388,6 +4122,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="out">
       <not-null/>
@@ -3406,19 +4141,26 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
     </arg>
     <arg nr="4" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
+  <!-- https://man7.org/linux/man-pages/man2/readlink.2.html -->
   <!-- int readlinkat(int dirfd, const char *pathname, char *buf, size_t bufsiz); -->
   <function name="readlinkat">
     <returnValue type="int"/>
@@ -3426,10 +4168,13 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="out">
       <not-null/>
@@ -3441,6 +4186,30 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <valid>0:</valid>
     </arg>
   </function>
+  <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/strxfrm_l.html -->
+  <!-- size_t strxfrm_l(char *restrict s1, const char *restrict s2, size_t n, locale_t locale) -->
+  <function name="strxfrm_l">
+    <returnValue type="size_t"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <!-- In case the 3rd argument is 0, the 1st argument is permitted to be a null pointer. (#6306) -->
+    <arg nr="1" direction="out">
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>  
   <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/asctime.html -->
   <!-- char *asctime_r(const struct tm *tm, char *buf); -->
   <function name="asctime_r">
@@ -3523,6 +4292,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <noreturn>false</noreturn>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -3535,6 +4305,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <noreturn>false</noreturn>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -3587,6 +4358,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-uninit/>
     </arg>
     <arg nr="3">
+      <not-bool/>
       <not-uninit/>
     </arg>
     <arg nr="any"/>
@@ -3620,6 +4392,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -3642,6 +4415,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <warn severity="style" reason="Obsolescent" alternatives="scalbln,scalblnf,scalbln,scalbn,scalbnf,scalbnl"/>
   </function>
+  <!-- https://man7.org/linux/man-pages/man3/bcopy.3.html -->
   <!-- void bcopy(const void *s1, void *s2, size_t n); -->
   <function name="bcopy">
     <noreturn>false</noreturn>
@@ -3657,6 +4431,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <warn severity="style" reason="Obsolescent" alternatives="memcpy,memmove"/>
@@ -3688,9 +4463,11 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="out">
       <not-null/>
+      <minsize type="argvalue" arg="2"/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <warn severity="style" reason="Obsolescent" alternatives="memset"/>
@@ -3716,11 +4493,13 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
     <warn severity="style" reason="Obsolescent" alternatives="wcsstr"/>
   </function>
@@ -3729,6 +4508,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="char *"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" strlen-arg="2"/>
     <arg nr="1" direction="out">
       <not-null/>
       <minsize type="strlen" arg="2"/>
@@ -3749,6 +4529,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -3765,6 +4546,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -3880,6 +4662,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/pthread_self.html -->
@@ -3898,61 +4681,205 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-null/>
     </arg>
   </function>
-  <!-- int pthread_attr_init(pthread_attr_t *attr); -->
-  <function name="pthread_attr_init">
-    <noreturn>false</noreturn>
+  <!-- int pthread_attr_init(pthread_attr_t *attr); -->
+  <function name="pthread_attr_init">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- https://pubs.opengroup.org/onlinepubs/009695399/functions/pthread_attr_getstackaddr.html -->
+  <!-- int pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr); -->
+  <function name="pthread_attr_setstackaddr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <warn severity="style" reason="Obsolescent" alternatives="pthread_attr_setstack"/>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/pthread_attr_setstack.3.html -->
+  <!-- int pthread_attr_setstack(pthread_attr_t *attr, void *stackaddr, size_t stacksize); -->
+  <function name="pthread_attr_setstack">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr); -->
+  <function name="pthread_attr_getstackaddr">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+      <not-bool/>
+    </arg>
+    <warn severity="style" reason="Obsolescent" alternatives="pthread_attr_getstack"/>
+  </function>
+  <!-- int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize); -->
+  <!-- int pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize); -->
+  <function name="pthread_attr_setstacksize,pthread_attr_setguardsize">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <arg nr="1">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/pthread_attr_getstack.3.html -->
+  <!-- int pthread_attr_getstack(const pthread_attr_t *restrict attr, void **restrict stackaddr, size_t *restrict stacksize); -->
+  <function name="pthread_attr_getstack">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int posix_trace_trygetnext_event(trace_id_t trid,
+           struct posix_trace_event_info *restrict event,
+           void *restrict data, size_t num_bytes,
+           size_t *restrict data_len, int *restrict unavailable); -->
+  <function name="posix_trace_trygetnext_event">
+    <returnValue type="int"/>
+    <use-retval/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="4" direction="in">
+      <valid>0:</valid>
+    </arg>
+    <arg nr="5" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="6" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- int posix_trace_timedgetnext_event(trace_id_t trid, struct posix_trace_event_info *restrict event, void *restrict data, size_t num_bytes, size_t *restrict data_len, int *restrict unavailable, const struct timespec *restrict abstime); -->
+  <function name="posix_trace_timedgetnext_event">
     <returnValue type="int"/>
-    <arg nr="1" direction="out">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="out">
       <not-null/>
     </arg>
-  </function>
-  <!-- https://pubs.opengroup.org/onlinepubs/009695399/functions/pthread_attr_getstackaddr.html -->
-  <!-- int pthread_attr_setstackaddr(pthread_attr_t *attr, void *stackaddr); -->
-  <function name="pthread_attr_setstackaddr">
-    <noreturn>false</noreturn>
-    <leak-ignore/>
-    <returnValue type="int"/>
-    <arg nr="1">
+    <arg nr="3" direction="out">
       <not-null/>
+    </arg>
+    <arg nr="4" direction="in">
       <not-uninit/>
+      <valid>0:</valid>
     </arg>
-    <arg nr="2">
+    <arg nr="5" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="6" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="7" direction="in">
       <not-null/>
-      <not-uninit/>
-      <not-bool/>
     </arg>
-    <warn severity="style" reason="Obsolescent" alternatives="pthread_attr_setstack"/>
   </function>
-  <!-- int pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stackaddr); -->
-  <function name="pthread_attr_getstackaddr">
-    <noreturn>false</noreturn>
+  <!-- void posix_trace_event(trace_event_id_t event_id,
+       const void *restrictdata_ptr, size_t data_len); -->
+  <function name="posix_trace_event">
     <leak-ignore/>
-    <returnValue type="int"/>
-    <arg nr="1">
-      <not-null/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>1:</valid>
     </arg>
-    <arg nr="2">
+    <arg nr="2" direction="in">
+      <not-uninit/>
       <not-null/>
-      <not-bool/>
     </arg>
-    <warn severity="style" reason="Obsolescent" alternatives="pthread_attr_getstack"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
   </function>
-  <!-- int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize); -->
-  <!-- int pthread_attr_setguardsize(pthread_attr_t *attr, size_t guardsize); -->
-  <function name="pthread_attr_setstacksize,pthread_attr_setguardsize">
-    <noreturn>false</noreturn>
+  <!-- int posix_trace_getnext_event(trace_id_t trid,
+           struct posix_trace_event_info *restrict event,
+           void *restrict data, size_t num_bytes,
+           size_t *restrict data_len, int *restrict unavailable); -->
+  <function name="posix_trace_getnext_event">
     <returnValue type="int"/>
-    <leak-ignore/>
-    <arg nr="1">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-uninit/>
       <not-null/>
+    </arg>
+    <arg nr="3" direction="in">
       <not-uninit/>
+      <not-null/>
+      <minsize type="argvalue" arg="4"/>
     </arg>
-    <arg nr="2" direction="in">
+    <arg nr="4" direction="in">
       <not-uninit/>
-      <not-bool/>
       <valid>0:</valid>
     </arg>
+    <arg nr="5" direction="out">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="6" direction="out">
+      <not-null/>
+      <not-uninit/>
+    </arg>
   </function>
   <!-- int pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *stacksize); -->
   <!-- int pthread_attr_getguardsize(const pthread_attr_t *attr, size_t *guardsize); -->
@@ -4075,7 +5002,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <warn severity="portability">Non reentrant function 'ttyname' called. For threadsafe applications it is recommended to use the reentrant replacement function 'ttyname_r'.</warn>
   </function>
   <!-- int ttyname_r(int fd, char *buf, size_t buflen); -->
-  <function name="ttyname">
+  <function name="ttyname_r">
     <use-retval/>
     <returnValue type="int"/>
     <noreturn>false</noreturn>
@@ -4092,6 +5019,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
   </function>
@@ -4105,6 +5033,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
     <warn severity="portability">Non reentrant function 'getspnam' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getspnam_r'.</warn>
   </function>
@@ -4139,6 +5068,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
     <warn severity="portability">Non reentrant function 'sgetspent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'sgetspent_r'.</warn>
   </function>
@@ -4175,6 +5105,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="4" direction="out">
@@ -4221,6 +5152,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-null/>
       <not-uninit/>
       <not-bool/>
+      <strz/>
     </arg>
     <warn severity="portability">Non reentrant function 'getgrnam' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getgrnam_r'.</warn>
   </function>
@@ -4236,6 +5168,61 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <warn severity="portability">Non reentrant function 'getgrgid' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getgrgid_r'.</warn>
   </function>
+  <!-- https://man7.org/linux/man-pages/man3/getgrnam.3.html -->
+  <!-- int getgrnam_r(const char *restrict name, struct group *restrict grp, char *restrict buf, size_t buflen, struct group **restrict result); -->
+  <function name="getgrnam_r">
+    <returnValue type="int"/>
+    <use-retval/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
+      <minsize type="argvalue" arg="4"/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="5" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/getgrnam.3.html -->
+  <!-- int getgrgid_r(gid_t gid, struct group *restrict grp, char *restrict buf, size_t buflen, struct group **restrict result); -->
+  <function name="getgrgid_r">
+    <returnValue type="int"/>
+    <use-retval/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
+      <minsize type="argvalue" arg="4"/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="5" direction="out">
+      <not-null/>
+    </arg>
+  </function>
   <!-- char *getlogin(void); -->
   <function name="getlogin">
     <returnValue type="char *"/>
@@ -4244,6 +5231,63 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <warn severity="portability">Non reentrant function 'getlogin' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getlogin_r'.</warn>
   </function>
+  <!-- https://man7.org/linux/man-pages/man3/getline.3.html -->
+  <!-- ssize_t getline(char **lineptr, size_t *n, FILE *stream); -->
+  <function name="getline">
+    <returnValue type="ssize_t"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <!-- If *lineptr is set to NULL before the call, then getline() will
+         allocate a buffer for storing the line.  This buffer should be
+         freed by the user program even if getline() failed.-->
+    <arg nr="1" direction="out"/>
+    <arg nr="2" direction="inout">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="inout">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/getline.3.html -->
+  <!-- ssize_t getdelim(char **lineptr, size_t *n, int delim, FILE *stream); -->
+  <function name="getdelim">
+    <returnValue type="ssize_t"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <!-- If *lineptr is set to NULL before the call, then getdelim() will
+         allocate a buffer for storing the line.  This buffer should be
+         freed by the user program even if getdelim() failed.-->
+    <arg nr="1" direction="out"/>
+    <arg nr="2" direction="inout">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <valid>0:255</valid>
+    </arg>
+    <arg nr="4" direction="inout">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/getlogin.3.html -->
+  <!-- int getlogin_r(char *buf, size_t bufsize); -->
+  <function name="getlogin_r">
+    <returnValue type="int"/>
+    <use-retval/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+      <minsize type="argvalue" arg="2"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-bool/>
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+  </function>
   <!-- char *ctermid(char *s); -->
   <function name="ctermid">
     <returnValue type="char *"/>
@@ -4263,6 +5307,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-uninit/>
       <not-null/>
+      <strz/>
     </arg>
     <arg nr="2" direction="out">
       <not-bool/>
@@ -4280,8 +5325,28 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-bool/>
     </arg>
   </function>
+  <!-- https://man7.org/linux/man-pages/man3/wcswidth.3.html -->
+  <!-- int wcswidth(const wchar_t *s, size_t n); -->
+  <function name="wcswidth">
+    <returnValue type="int"/>
+    <use-retval/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+      <minsize type="argvalue" arg="2"/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
   <!-- http://man7.org/linux/man-pages/man3/scandir.3.html -->
-  <!-- int scandir(const char *dirp, 
+  <!-- int scandir(const char *dirp,
                     struct dirent ***namelist,
                     int (*filter)(const struct dirent *),
                     int (*compar)(const struct dirent **, const struct dirent **));-->
@@ -4293,6 +5358,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="out">
       <not-null/>
@@ -4319,8 +5385,9 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-bool/>
     </arg>
   </function>
-  <!-- int fseeko(FILE *stream, off_t offset, int whence); -->
-  <function name="fseeko">
+  <!-- int fseeko  (FILE *stream, off_t offset  , int whence); -->
+  <!-- int fseeko64(FILE *stream, off64_t offset, int whence); -->
+  <function name="fseeko,fseeko64">
     <returnValue type="int"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
@@ -4330,10 +5397,12 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
       <not-bool/>
+      <valid>0:2</valid>
     </arg>
   </function>
   <!-- off_t ftello(FILE *stream); -->
@@ -4349,7 +5418,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
   </function>
   <!-- https://pubs.opengroup.org/onlinepubs/9699919799/functions/exec.html -->
-  <!-- int execv(const char *path, char *const argv[]); 
+  <!-- int execv(const char *path, char *const argv[]);
        int execvp(const char *file, char *const argv[]); -->
   <function name="execv,execvp">
     <returnValue type="int"/>
@@ -4381,6 +5450,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="out"/>
     <arg nr="3" direction="in">
@@ -4400,6 +5470,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <minsize type="argvalue" arg="2"/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -4407,10 +5478,23 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <valid>0:</valid>
     </arg>
   </function>
+  <!-- https://man7.org/linux/man-pages/man3/wcwidth.3.html -->
+  <!-- int wcwidth(wchar_t c); -->
+  <function name="wcwidth">
+    <returnValue type="int"/>
+    <use-retval/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
   <!-- http://man7.org/linux/man-pages/man3/ffs.3.html -->
   <!-- int ffs(int i); -->
   <function name="ffs">
-    <returnValue type="int"/>
+    <!-- It returns the position of the first bit set, or 0 if no bits are set in i. -->
+    <returnValue type="int">arg1==0 &amp;0</returnValue>
     <use-retval/>
     <noreturn>false</noreturn>
     <leak-ignore/>
@@ -4427,9 +5511,11 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3">
       <!-- direction (in/out) depends on the value of arg2 "cmd" -->
@@ -4444,9 +5530,11 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="3" direction="in">
@@ -4462,6 +5550,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in"/>
     <arg nr="3" direction="in">
@@ -4487,6 +5576,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="out">
       <not-null/>
@@ -4501,6 +5591,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -4516,9 +5607,11 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="1" direction="in">
       <not-uninit/>
       <not-null/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -4545,13 +5638,15 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="wchar_t *"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" count-arg="3"/>
     <arg nr="1" direction="out">
       <not-null/>
-      <minsize type="argvalue" arg="3"/>
+      <minsize type="argvalue" arg="3" baseType="wchar_t"/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <minsize type="argvalue" arg="3"/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -4565,6 +5660,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="char *"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="3"/>
     <arg nr="1" direction="out">
       <not-null/>
       <minsize type="argvalue" arg="3"/>
@@ -4572,6 +5668,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -4585,6 +5682,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <returnValue type="void *"/>
     <noreturn>false</noreturn>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="4"/>
     <arg nr="1" direction="out">
       <not-null/>
       <minsize type="sizeof" arg="2"/>
@@ -4596,6 +5694,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="4" direction="in">
@@ -4613,6 +5712,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <use-retval/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2">
@@ -4623,6 +5723,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
       <not-uninit/>
       <not-null/>
       <not-bool/>
+      <strz/>
     </arg>
   </function>
   <!-- http://man7.org/linux/man-pages/man2/setitimer.2.html-->
@@ -4633,6 +5734,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="out">
       <not-null/>
@@ -4647,6 +5749,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -4664,6 +5767,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in"/>
     <arg nr="3" direction="out">
@@ -4693,6 +5797,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- http://pubs.opengroup.org/onlinepubs/9699919799/functions/sigsetjmp.html -->
@@ -4717,18 +5822,18 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
   </function>
   <!-- http://pubs.opengroup.org/onlinepubs/9699919799/functions/sigprocmask.html -->
-  <!-- int pthread_sigmask(int how, const sigset_t *restrict set,
-       sigset_t *restrict oset);
-		int sigprocmask(int how, const sigset_t *restrict set,
-       sigset_t *restrict oset); -->
+  <!-- int pthread_sigmask(int how, const sigset_t *restrict set, sigset_t *restrict oset);
+        int sigprocmask(int how, const sigset_t *restrict set, sigset_t *restrict oset); -->
   <function name="pthread_sigmask,sigprocmask">
     <noreturn>false</noreturn>
     <returnValue type="int"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="out">
       <not-uninit/>
@@ -4762,6 +5867,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="out">
       <not-null/>
@@ -4854,7 +5960,10 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="out"/>
-    <arg nr="2" direction="in"/>
+    <arg nr="2" direction="in">
+        <not-uninit/>
+        <strz/>
+    </arg>
     <arg nr="3" direction="in"/>
     <arg nr="4" direction="in"/>
     <arg nr="5"/>
@@ -4870,9 +5979,11 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3">
       <!-- direction (in/out) depends on the value of arg2 "cmd" -->
@@ -4888,6 +5999,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <use-retval/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -4903,6 +6015,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="out">
       <not-null/>
@@ -4911,10 +6024,12 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="4" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="5" direction="in">
       <not-uninit/>
@@ -4929,6 +6044,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
@@ -4938,6 +6054,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="4" direction="in">
@@ -4953,6 +6070,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
@@ -4968,6 +6086,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
@@ -4984,6 +6103,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
@@ -5000,6 +6120,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="out">
@@ -5015,10 +6136,12 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="in">
       <not-null/>
@@ -5073,7 +6196,9 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <returnValue type="void"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="3"/>
     <arg nr="1" direction="in">
+      <not-null/>
       <not-uninit/>
       <minsize type="argvalue" arg="3"/>
     </arg>
@@ -5083,6 +6208,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
   </function>
@@ -5103,6 +6229,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>1:</valid>
     </arg>
   </function>
@@ -5117,9 +6244,11 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
   </function>
@@ -5131,6 +6260,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <noreturn>false</noreturn>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:</valid>
     </arg>
     <warn severity="style" alternatives="malloc,mmap" reason="Obsolete"/>
@@ -5148,11 +6278,15 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <dealloc>free</dealloc>
   </memory>
   <memory>
-    <alloc init="true" buffer-size="strdup">strdup</alloc>
     <alloc init="true">strndup</alloc>
     <alloc init="true">wcsdup</alloc>
     <dealloc>free</dealloc>
   </memory>
+  <memory>
+    <alloc init="true" arg="1">getline</alloc>
+    <alloc init="true" arg="1">getdelim</alloc>
+    <dealloc>free</dealloc>
+  </memory>
   <memory>
     <alloc init="true">mmap</alloc>
     <alloc init="true">mmap64</alloc>
@@ -5165,6 +6299,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
     <alloc init="true">openat</alloc>
     <alloc init="true">socket</alloc>
     <dealloc>close</dealloc>
+    <dealloc>fdopen</dealloc>
   </resource>
   <resource>
     <alloc init="true">opendir</alloc>
@@ -5201,6 +6336,8 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
   <podtype name="id_t" sign="s"/>
   <podtype name="blkcnt_t" sign="s"/>
   <podtype name="off_t" sign="s"/>
+  <podtype name="loff_t" sign="s" size="8"/>
+  <podtype name="off64_t" sign="s" size="8"/>
   <podtype name="fsblkcnt_t" sign="u"/>
   <podtype name="fsfilcnt_t" sign="u"/>
   <podtype name="ino_t" sign="u"/>
@@ -5272,7 +6409,7 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
   <define name="S_IFDIR" value="0040000"/>
   <define name="S_IFCHR" value="0020000"/>
   <define name="S_IFIFO" value="0010000"/>
-  <!-- see http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/signal.h.html 
+  <!-- see http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/signal.h.html
        Some other signals are defined in std.cfg! -->
   <define name="SIGHUP" value="1"/>
   <define name="SIGQUIT" value="3"/>
@@ -5296,4 +6433,13 @@ The function 'mktemp' is considered to be dangerous due to race conditions and s
   <define name="SIGPROF" value="27"/>
   <define name="SIGPOLL" value="29"/>
   <define name="SIGSYS" value="31"/>
+  <define name="F_OK" value="0"/>
+  <define name="R_OK" value="4"/>
+  <define name="W_OK" value="2"/>
+  <define name="X_OK" value="1"/>
+  <!-- https://man7.org/linux/man-pages/man3/lockf.3.html -->
+  <define name="F_LOCK" value="1"/>
+  <define name="F_TEST" value="3"/>
+  <define name="F_TLOCK" value="2"/>
+  <define name="F_ULOCK" value="0"/>
 </def>
diff --git a/cfg/protobuf.cfg b/cfg/protobuf.cfg
new file mode 100644
index 00000000000..8ff5570c952
--- /dev/null
+++ b/cfg/protobuf.cfg
@@ -0,0 +1,10 @@
+<?xml version="1.0"?>
+<def format="2">
+  <define name="PROTOBUF_PRAGMA_INIT_SEG" value=""/>
+  <define name="PROTOBUF_VERSION" value="9999999"/>
+  <define name="PROTOBUF_MIN_PROTOC_VERSION" value="0"/>
+  <define name="PROTOBUF_NAMESPACE_OPEN" value=""/>
+  <define name="PROTOBUF_NAMESPACE_CLOSE" value=""/>
+  <define name="PROTOBUF_SECTION_VARIABLE(SECTION)" value=""/>
+  <define name="GOOGLE_PROTOBUF_RUNTIME_DEPRECATED(MSG)" value=""/>
+</def>
diff --git a/cfg/python.cfg b/cfg/python.cfg
index ed2fad429f3..30479cd87b8 100644
--- a/cfg/python.cfg
+++ b/cfg/python.cfg
@@ -1,5 +1,9 @@
 <?xml version="1.0"?>
 <def format="2">
+  <define name="Py_RETURN_FALSE" value="return Py_INCREF(Py_False), Py_False"/>
+  <define name="Py_RETURN_NONE" value="return Py_INCREF(Py_None), Py_None"/>
+  <define name="Py_RETURN_TRUE" value="return Py_INCREF(Py_True), Py_True"/>
+
   <!-- Python C API. see https://docs.python.org/2/c-api/index.html -->
   <!-- ########## Python C API Types ########## -->
   <define name="PY_LONG_LONG" value="long long"/>
@@ -431,6 +435,58 @@
       <strz/>
     </arg>
   </function>
+  <!-- double PyFloat_AsDouble(PyObject *pyfloat) -->
+  <function name="PyFloat_AsDouble">
+    <noreturn>false</noreturn>
+    <returnValue type="double"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- double PyFloat_AS_DOUBLE(PyObject *pyfloat) -->
+  <function name="PyFloat_AS_DOUBLE">
+    <noreturn>false</noreturn>
+    <returnValue type="double"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int PyFloat_Check(PyObject *p) -->
+  <!-- int PyFloat_CheckExact(PyObject *p) -->
+  <function name="PyFloat_Check,PyFloat_CheckExact">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- PyObject* PyFloat_FromDouble(double v) -->
+  <function name="PyFloat_FromDouble">
+    <noreturn>false</noreturn>
+    <returnValue type="PyObject*"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- PyObject* PyFloat_FromString(PyObject *str) -->
+  <function name="PyFloat_FromString">
+    <noreturn>false</noreturn>
+    <returnValue type="PyObject*"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
   <!-- int PyInt_Check(PyObject *o) -->
   <function name="PyInt_Check">
     <returnValue type="int"/>
@@ -499,6 +555,62 @@
       <valid>0:</valid>
     </arg>
   </function>
+  <!-- int PyModule_AddIntConstant(PyObject *module, const char *name, long value) -->
+  <function name="PyModule_AddIntConstant">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int PyModule_AddObject(PyObject *module, const char *name, PyObject *value) -->
+  <!-- The hint "This means that its return value must be checked, and calling code must Py_DECREF()
+       value manually on error." in the documentation suggests to add use-retval. -->
+  <function name="PyModule_AddObject">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3">
+      <not-null/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int PyModule_AddStringConstant(PyObject *module, const char *name, const char *value) -->
+  <function name="PyModule_AddStringConstant">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+      <not-bool/>
+    </arg>
+  </function>
   <!-- void PyObject_Del(void *op) -->
   <function name="PyObject_Del">
     <noreturn>false</noreturn>
@@ -507,6 +619,21 @@
       <not-uninit/>
     </arg>
   </function>
+  <!-- PyObject* PyObject_GetAttrString(PyObject *o, const char *attr_name) -->
+  <function name="PyObject_GetAttrString">
+    <noreturn>false</noreturn>
+    <returnValue type="PyObject*"/>
+    <use-retval/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+      <not-bool/>
+    </arg>
+  </function>
   <!-- PyAPI_FUNC(PyObject *) _PyObject_New(PyTypeObject *); -->
   <function name="_PyObject_New">
     <noreturn>false</noreturn>
diff --git a/cfg/qt.cfg b/cfg/qt.cfg
index babd4be2d9c..5371e598568 100644
--- a/cfg/qt.cfg
+++ b/cfg/qt.cfg
@@ -59,10 +59,11 @@
   <reflection>
     <call arg="2">invokeMethod</call>
   </reflection>
-  <define name="SIGNAL(X)" value="#X"/>
-  <define name="SLOT(X)" value="#X"/>
+  <define name="SIGNAL(X)" value="X"/>
+  <define name="SLOT(X)" value="X"/>
   <!-- T qAbs(const T &t) -->
   <function name="qAbs">
+    <pure/>
     <noreturn>false</noreturn>
     <use-retval/>
     <arg nr="1" direction="in">
@@ -72,6 +73,7 @@
   </function>
   <!-- const T &qBound(const T &min, const T &val, const T &max) -->
   <function name="qBound">
+    <pure/>
     <noreturn>false</noreturn>
     <use-retval/>
     <arg nr="1" direction="in">
@@ -97,6 +99,79 @@
       <not-uninit/>
     </arg>
   </function>
+  <!-- quint32 qFloatDistance(float a, float b) -->
+  <!-- quint64 qFloatDistance(double a, double b) -->
+  <function name="qFloatDistance">
+    <pure/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- QString qFormatLogMessage(QtMsgType type, const QMessageLogContext &context, const QString &str) -->
+  <function name="qFormatLogMessage">
+    <noreturn>false</noreturn>
+    <returnValue type="QString"/>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool qFuzzyCompare(double p1, double p2) -->
+  <!-- bool qFuzzyCompare(float p1, float p2) -->
+  <function name="qFuzzyCompare">
+    <pure/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool qFuzzyIsNull(double d) -->
+  <!-- bool qFuzzyIsNull(float f) -->
+  <function name="qFuzzyIsNull">
+    <pure/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- QByteArray qgetenv(const char *varName) -->
+  <function name="qgetenv">
+    <noreturn>false</noreturn>
+    <returnValue type="QByteArray"/>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <strz/>
+    </arg>
+  </function>
   <!-- double qInf() -->
   <function name="qInf">
     <noreturn>false</noreturn>
@@ -106,6 +181,7 @@
   <!-- bool	qIsFinite(double d) -->
   <!-- bool qIsFinite(float f) -->
   <function name="qIsFinite">
+    <pure/>
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
     <use-retval/>
@@ -118,6 +194,7 @@
   <!-- bool qIsInf(double d) -->
   <!-- bool qIsInf(float f) -->
   <function name="qIsInf">
+    <pure/>
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
     <use-retval/>
@@ -130,6 +207,7 @@
   <!-- bool qIsNaN(double d) -->
   <!-- bool qIsNaN(float f) -->
   <function name="qIsNaN">
+    <pure/>
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
     <use-retval/>
@@ -173,9 +251,30 @@
       <not-uninit/>
     </arg>
   </function>
+  <!-- bool qputenv(const char *varName, const QByteArray &value) -->
+  <function name="qputenv">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- double qQNaN() -->
+  <function name="qQNaN">
+    <noreturn>false</noreturn>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
   <!-- int qRound(double d) -->
   <!-- int qRound(float d) -->
   <function name="qRound">
+    <pure/>
     <noreturn>false</noreturn>
     <returnValue type="int"/>
     <use-retval/>
@@ -184,6 +283,24 @@
       <not-bool/>
     </arg>
   </function>
+  <!-- qint64 qRound64(double d) -->
+  <!-- qint64 qRound64(float d) -->
+  <function name="qRound64">
+    <pure/>
+    <noreturn>false</noreturn>
+    <returnValue type="qint64"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- double qSNaN() -->
+  <function name="qSNaN">
+    <noreturn>false</noreturn>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
   <!-- void qSort(RandomAccessIterator begin, RandomAccessIterator end) -->
   <!-- void qSort(RandomAccessIterator begin, RandomAccessIterator end, LessThan lessThan) -->
   <!-- void qSort(Container &container) -->
@@ -217,6 +334,31 @@
     <arg nr="1" direction="inout"/>
     <arg nr="2" direction="inout"/>
   </function>
+  <!-- QString qtTrId(const char *id, int n = ...) -->
+  <function name="qtTrId">
+    <noreturn>false</noreturn>
+    <returnValue type="QString"/>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in" default="">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool qunsetenv(const char *varName) -->
+  <function name="qunsetenv">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <strz/>
+    </arg>
+  </function>
   <!-- const char *qUtf8Printable(const QString &str) -->
   <function name="qUtf8Printable">
     <noreturn>false</noreturn>
@@ -237,14 +379,21 @@
       <not-uninit/>
     </arg>
   </function>
+  <!-- const char *qVersion() -->
+  <function name="qVersion">
+    <noreturn>false</noreturn>
+    <returnValue type="const char *"/>
+    <use-retval/>
+  </function>
   <!-- QMetaObject::Connection QObject::connect(const QObject *sender, const char *signal, const char *method, Qt::ConnectionType type = Qt::AutoConnection) const -->
   <!-- QMetaObject::Connection QObject::connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type = Qt::AutoConnection) // static -->
   <!-- QMetaObject::Connection QObject::connect(const QObject *sender, const QMetaMethod &signal, const QObject *receiver, const QMetaMethod &method, Qt::ConnectionType type = Qt::AutoConnection) // static -->
   <!-- QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method, Qt::ConnectionType type = Qt::AutoConnection) // static -->
   <!-- QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, Functor functor) // static -->
   <!-- QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, const QObject *context, Functor functor, Qt::ConnectionType type = Qt::AutoConnection) // static -->
-  <function name="connect,QObject::connect">
+  <function name="QObject::connect">
     <noreturn>false</noreturn>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
@@ -276,6 +425,7 @@
   <!-- bool QObject::disconnect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method) // static -->
   <function name="disconnect,QObject::disconnect">
     <noreturn>false</noreturn>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
@@ -304,10 +454,12 @@
   <!-- QAction *QMenu::addAction(const QIcon &icon, const QString &text, const QObject *receiver, PointerToMemberFunction method, const QKeySequence &shortcut = ...) -->
   <!-- QAction *QMenu::addAction(const QIcon &icon, const QString &text, Functor functor, const QKeySequence &shortcut = ...) -->
   <!-- QAction *QMenu::addAction(const QIcon &icon, const QString &text, const QObject *context, Functor functor, const QKeySequence &shortcut = 0) -->
+  <!-- void QWidget::addAction(QAction *action) -->
   <function name="QMenu::addAction">
     <noreturn>false</noreturn>
     <returnValue type="QAction *"/>
-    <arg nr="1" direction="in">
+    <leak-ignore/>
+    <arg nr="1">
       <not-uninit/>
       <not-bool/>
     </arg>
@@ -606,6 +758,19 @@
       <not-uninit/>
     </arg>
   </function>
+  <!-- bool QString::isEmpty() const -->
+  <!-- bool QString::isLower() const -->
+  <!-- bool QString::isUpper() const -->
+  <!-- bool QString::isNull() const -->
+  <!-- bool QString::isRightToLeft() const -->
+  <!-- bool QString::isValidUtf16() const -->
+  <function name="QString::isEmpty,QString::isLower,QString::isNull,QString::isRightToLeft,QString::isUpper,QString::isValidUtf16">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <leak-ignore/>
+    <const/>
+  </function>
   <!-- QString & QString::sprintf(const char * cformat, ...); -->
   <function name="QString::sprintf">
     <noreturn>false</noreturn>
@@ -624,7 +789,7 @@
   <function name="QList::append,QStringList::append">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
   </function>
@@ -744,21 +909,6 @@
     <use-retval/>
     <const/>
   </function>
-  <!-- iterator QList::..() -->
-  <function name="QList::begin,QList::end,QList::cbegin,QList::cend,QList::constBegin,QList::constEnd,QList::rbegin,QList::rend,QList::crbegin,QList::crend">
-    <noreturn>false</noreturn>
-    <use-retval/>
-  </function>
-  <!-- iterator QString::..() -->
-  <function name="QString::begin,QString::end,QString::cbegin,QString::cend,QString::constBegin,QString::constEnd,QString::rbegin,QString::rend,QString::crbegin,QString::crend">
-    <noreturn>false</noreturn>
-    <use-retval/>
-  </function>
-  <!-- iterator QStringList::..() -->
-  <function name="QStringList::begin,QStringList::end,QStringList::cbegin,QStringList::cend,QStringList::constBegin,QStringList::constEnd,QStringList::rbegin,QStringList::rend,QStringList::crbegin,QStringList::crend">
-    <noreturn>false</noreturn>
-    <use-retval/>
-  </function>
   <!-- QStandardItem *QStandardItem::child(int row, int column = 0) const -->
   <function name="QStandardItem::child">
     <noreturn>false</noreturn>
@@ -781,9 +931,17 @@
       <not-bool/>
     </arg>
   </function>
-  <!-- void QString::clear() -->
-  <function name="QList::clear,QString::clear">
+  <!-- QString QString::chopped(int len) const -->
+  <function name="QString::chopped">
     <noreturn>false</noreturn>
+    <returnValue type="QString"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
   </function>
   <!-- int QString::compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs = Qt::CaseSensitive) //static -->
   <!-- int QString::compare(QLatin1String other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const -->
@@ -795,6 +953,7 @@
   <function name="QString::compare">
     <noreturn>false</noreturn>
     <returnValue type="int"/>
+    <const/>
     <use-retval/>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -819,6 +978,25 @@
       <not-uninit/>
     </arg>
   </function>
+  <!-- template <typename AT> qsizetype QSignalSpy::count(const AT &value) const -->
+  <!-- template <typename AT> qsizetype QSignalSpy::count() const -->
+  <!-- template <typename AT> qsizetype QSignalSpy::size() const -->
+  <function name="QSignalSpy::count,QSignalSpy::size">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <returnValue type="qsize"/>
+    <const/>
+    <arg nr="1" direction="in" default="">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- QIcon QIcon::fromTheme(const QString &name)-->
+  <function name="QIcon::fromTheme">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <returnValue type="QIcon"/>
+    <arg nr="1" direction="in"/>
+  </function>
   <!-- ##### QMap https://doc.qt.io/qt-5/qmap.html ##### -->
   <!-- QMap::const_iterator QMap::constFind(const Key &key) const -->
   <function name="QMap::constFind">
@@ -876,14 +1054,6 @@
       <not-uninit/>
     </arg>
   </function>
-  <!-- bool QMap::isEmpty() const -->
-  <function name="QMap::isEmpty">
-    <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <use-retval/>
-    <leak-ignore/>
-    <const/>
-  </function>
   <!-- const Key QMap::key(const T &value, const Key &defaultKey = Key()) const -->
   <function name="QMap::key">
     <noreturn>false</noreturn>
@@ -969,33 +1139,6 @@
       <not-uninit/>
     </arg>
   </function>
-  <!-- int QList::count() const -->
-  <!-- int QList::length() const -->
-  <!-- int QList::size() const -->
-  <!-- int QString::count() const -->
-  <!-- int QString::length() const -->
-  <!-- int QString::size() const -->
-  <!-- int QStringList::count() const -->
-  <!-- int QStringList::length() const -->
-  <!-- int QStringList::size() const -->
-  <function name="QList::count,QList::length,QList::size,QString::count,QString::length,QString::size,QStringList::count,QStringList::length,QStringList::size">
-    <noreturn>false</noreturn>
-    <use-retval/>
-    <returnValue type="signed int"/>
-    <const/>
-  </function>
-  <!-- bool QList::empty() const -->
-  <!-- bool QList::isEmpty() const -->
-  <!-- bool QString::isEmpty() const -->
-  <!-- bool QString::isNull() const -->
-  <!-- bool QStringList::empty() const -->
-  <!-- bool QStringList::isEmpty() const -->
-  <function name="QList::empty,QList::isEmpty,QString::isEmpty,QString::isNull,QStringList::empty,QStringList::isEmpty">
-    <noreturn>false</noreturn>
-    <use-retval/>
-    <returnValue type="bool"/>
-    <const/>
-  </function>
   <!-- void QList::insert(int i, const T &value) -->
   <!-- iterator QList::insert(iterator before, const T &value) -->
   <!-- QStringList inherits from QList -->
@@ -1271,13 +1414,6 @@
       <not-bool/>
     </arg>
   </function>
-  <!-- bool QString::isRightToLeft() const -->
-  <function name="QString::isRightToLeft">
-    <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <use-retval/>
-    <const/>
-  </function>
   <!-- int QList::lastIndexOf(const T &value, int from = -1) const -->
   <!-- int QStringList::lastIndexOf(const QString &value, int from = -1) const -->
   <function name="QList::lastIndexOf,QStringList::lastIndexOf">
@@ -1318,6 +1454,30 @@
       <not-uninit/>
     </arg>
   </function>
+  <!-- qsizetype QString::length() const -->
+  <function name="QString::length">
+    <noreturn>false</noreturn>
+    <returnValue type="qsizetype"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- int QImage::width() const -->
+  <!-- int QImage::height() const -->
+  <!-- int QImage::dotsPerMeterX() const -->
+  <!-- int QImage::dotsPerMeterY() const -->
+  <function name="QImage::width,QImage::height,QImage::dotsPerMeterX,QImage::dotsPerMeterY">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- QSize QImage::size() const -->
+  <function name="QImage::size">
+    <noreturn>false</noreturn>
+    <returnValue type="QSize"/>
+    <use-retval/>
+    <const/>
+  </function>
   <!-- QString QString::leftJustified(int width, QChar fill = QLatin1Char(' '), bool truncate = false) const -->
   <function name="QString::leftJustified">
     <noreturn>false</noreturn>
@@ -1453,7 +1613,7 @@
   <function name="QList::prepend,QStringList::prepend">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
   </function>
@@ -1477,7 +1637,7 @@
   <function name="QList::push_back,QStringList::push_back">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
   </function>
@@ -1495,7 +1655,7 @@
   <function name="QList::push_front,QStringList::push_front">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
   </function>
@@ -1558,7 +1718,7 @@
   <function name="QList::removeAll,QStringList::removeAll">
     <noreturn>false</noreturn>
     <returnValue type="int"/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
   </function>
@@ -2097,7 +2257,7 @@
     <const/>
   </function>
   <!-- QString QString::vasprintf(const char *cformat, va_list ap) // static -->
-  <function name="QString::vsprintf">
+  <function name="QString::vasprintf">
     <noreturn>false</noreturn>
     <returnValue type="QString"/>
     <use-retval/>
@@ -2147,6 +2307,7 @@
       <not-null/>
     </arg>
   </function>
+  <!-- https://doc.qt.io/qt-5/qdir.html -->
   <!-- QString QDir::fromNativeSeparators(const QString &pathName) -->
   <!-- QString QDir::toNativeSeparators(const QString &pathName) -->
   <function name="QDir::fromNativeSeparators,QDir::toNativeSeparators">
@@ -2158,6 +2319,123 @@
       <not-bool/>
     </arg>
   </function>
+  <!-- bool QDir::mkdir(const QString &dirPath) const -->
+  <!-- bool QDir::mkpath(const QString &dirPath) const -->
+  <!-- do not mark as const as it is not const from a side effect standpoint-->
+  <function name="QDir::mkdir,QDir::mkpath">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval type="error-code"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- QString QDir::path() const -->
+  <function name="QDir::path">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <returnValue type="QString"/>
+  </function>
+  <!-- QString absolutePath() const -->
+  <!-- QString canonicalPath() const -->
+  <!-- QString dirName() const -->
+  <function name="QDir::absolutePath,QDir::canonicalPath,QDir::dirName">
+    <noreturn>false</noreturn>
+    <returnValue type="QString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool QDir::cd(const QString &dirName) -->
+  <function name="QDir::cd">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval type="error-code"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- QString QDir::absoluteFilePath(const QString &fileName) -->
+  <function name="QDir::absoluteFilePath">
+    <noreturn>false</noreturn>
+    <returnValue type="QString"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <const/>
+  </function>
+  <!-- QString QDir::filePath(const QString &fileName) -->
+  <function name="QDir::filePath">
+    <noreturn>false</noreturn>
+    <returnValue type="QString"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <const/>
+  </function>
+  <!-- static QString QDir::cleanPath(const QString &path) -->
+  <function name="QDir::cleanPath">
+    <noreturn>false</noreturn>
+    <returnValue type="QString"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <const/>
+  </function>
+  <!-- static QString QDir::currentPath() -->
+  <!-- static QString QDir::tempPath() -->
+  <function name="QDir::currentPath,QDir::tempPath">
+    <noreturn>false</noreturn>
+    <returnValue type="QString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- QStringList QDir::entryList(const QStringList &nameFilters, QDir::Filters filters = NoFilter, QDir::SortFlags sort = NoSort) const-->
+  <!-- QStringList QDir::entryList(QDir::Filters filters = NoFilter, QDir::SortFlags sort = NoSort)const-->
+  <function name="QDir::entryList">
+    <noreturn>false</noreturn>
+    <returnValue type="QStringList"/>
+    <use-retval/>
+    <arg nr="any">
+      <not-uninit/>
+    </arg>
+    <const/>
+  </function>
+  <!-- QFileInfoList QDir::entryInfoList(const QStringList &nameFilters, QDir::Filters filters = NoFilter, QDir::SortFlags sort = NoSort) const -->
+  <!-- QFileInfoList QDir::entryInfoList(QDir::Filters filters = NoFilter, QDir::SortFlags sort = NoSort) const -->
+  <function name="QDir::entryInfoList">
+    <noreturn>false</noreturn>
+    <returnValue type="QFileInfoList"/>
+    <use-retval/>
+    <arg nr="any">
+      <not-uninit/>
+    </arg>
+    <const/>
+  </function>
+  <!-- bool QDir::cdUp() -->
+  <function name="QDir::cdUp">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval type="error-code"/>
+  </function>
+  <!-- bool QDir::exists(QString &name) const -->
+  <!-- bool QDir::exists() const -->
+  <function name="QDir::exists">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" default="&quot;&quot;" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
   <!-- bool QFile::exists(const QString &fileName) // static -->
   <!-- bool QFile::exists() const -->
   <function name="QFile::exists">
@@ -2170,6 +2448,34 @@
       <not-bool/>
     </arg>
   </function>
+  <!-- uint QDir::count() const -->
+  <function name="QDir::count">
+    <noreturn>false</noreturn>
+    <returnValue type="uint"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- QChar QDir::separator() static -->
+  <function name="QDir::separator">
+    <noreturn>false</noreturn>
+    <returnValue type="QChar"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- QDir QDir::home() static -->
+  <function name="QDir::home">
+    <noreturn>false</noreturn>
+    <returnValue type="QDir"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- QString QDir::homePath() static -->
+  <function name="QDir::homePath">
+    <noreturn>false</noreturn>
+    <returnValue type="QString"/>
+    <use-retval/>
+    <const/>
+  </function>
   <!-- bool QFile::open(OpenMode mode) -->
   <!-- bool QFile::open(FILE *fh, OpenMode mode, FileHandleFlags handleFlags = DontCloseHandle) -->
   <!-- bool QFile::open(int fd, OpenMode mode, FileHandleFlags handleFlags = DontCloseHandle) -->
@@ -2223,6 +2529,37 @@
     <use-retval/>
     <const/>
   </function>
+  <!-- https://doc.qt.io/qt-5/qlockfile.html -->
+  <!-- bool QLockFile::lock() -->
+  <!-- bool QLockFile::removeStaleLockFile() -->
+  <function name="QLockFile::lock,QLockFile::removeStaleLockFile">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval type="error-code"/>
+  </function>
+  <!-- bool QLockFile::isLocked() const -->
+  <function name="QLockFile::isLocked">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- int QLockFile::staleLockTime() const -->
+  <function name="QLockFile::staleLockTime">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool QLockFile::tryLock(int timeout = 0) -->
+  <function name="QLockFile::tryLock">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- QString QFileDialog::getOpenFileName(QWidget *parent = Q_NULLPTR, const QString &caption = QString(), const QString &dir = QString(), const QString &filter = QString(), QString *selectedFilter = Q_NULLPTR, Options options = Options()) //static -->
   <!-- QString QFileDialog::getSaveFileName(QWidget *parent = Q_NULLPTR, const QString &caption = QString(), const QString &dir = QString(), const QString &filter = QString(), QString *selectedFilter = Q_NULLPTR, Options options = Options()) //static -->
   <!-- QString QFileDialog::getExistingDirectory(QWidget *parent = Q_NULLPTR, const QString &caption = QString(), const QString &dir = QString(), Options options = ShowDirsOnly) //static -->
@@ -2372,7 +2709,7 @@
   <function name="QBoxLayout::addWidget,QVBoxLayout::addWidget,QHBoxLayout::addWidget">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
     <arg nr="2" default="0" direction="in">
@@ -2501,6 +2838,7 @@
     <arg nr="1" direction="in" default=""/>
     <arg nr="2" direction="in" default=""/>
     <arg nr="3" direction="in" default=""/>
+    <const/>
   </function>
   <!-- int QDate::month() const -->
   <function name="QDate::month">
@@ -2557,6 +2895,14 @@
       <not-bool/>
     </arg>
   </function>
+  <!-- int QModelIndex::column() const -->
+  <!-- int QModelIndex::row() const -->
+  <function name="QModelIndex::row,QModelIndex::column">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
   <!-- int QDate::year() const -->
   <function name="QDate::year">
     <noreturn>false</noreturn>
@@ -2588,6 +2934,156 @@
     <use-retval/>
     <const/>
   </function>
+  <!--qreal QRectF::bottom () const -->
+  <!--qreal QRectF::height () const -->
+  <!--qreal QRectF::width () const -->
+  <!--qreal QRectF::left () const -->
+  <!--qreal QRectF::right () const -->
+  <!--qreal QRectF::top () const -->
+  <!--qreal QRectF::x () const -->
+  <!--qreal QRectF::y () const -->
+  <function name="QRectF::bottom,QRectF::height,QRectF::left,QRectF::right,QRectF::top,QRectF::width,QRectF::x,QRectF::y">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="qreal"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!--QSizeF QRectF::size () const -->
+  <function name="QRectF::size">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="QSizeF"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!--bool QRectF::isEmpty () const -->
+  <!--bool QRectF::isNull () const -->
+  <!--bool QRectF::isValid () const -->
+  <!--bool QModelIndex::isValid () const -->
+  <function name="QRectF::isEmpty,QRectF::isNull,QRectF::isValid,QModelIndex::isValid">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!--QPointF QRectF::topLeft () const -->
+  <!--QPointF QRectF::topRight () const -->
+  <!--QPointF QRectF::bottomLeft () const -->
+  <!--QPointF QRectF::bottomRight () const -->
+  <!--QPointF QRectF::center () const -->
+  <function name="QRectF::topLeft,QRectF::topRight,QRectF::bottomLeft,QRectF::bottomRight,QRectF::center">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="QPointF"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!--qreal QPointF::x () const -->
+  <!--qreal QPointF::y () const -->
+  <!--qreal QPointF::manhattanLength () const -->
+  <function name="QPointF::x,QPointF::y,QPointF::manhattanLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="qreal"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!--qreal& QPointF::rx () const -->
+  <!--qreal& QPointF::ry () const -->
+  <function name="QPointF::rx,QPointF::ry">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="qreal &amp;"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!--int QRect::bottom () const -->
+  <!--int QRect::height () const -->
+  <!--int QRect::width () const -->
+  <!--int QRect::left () const -->
+  <!--int QRect::right () const -->
+  <!--int QRect::top () const -->
+  <!--int QRect::x () const -->
+  <!--int QRect::y () const -->
+  <!--int QSize::width () const -->
+  <!--int QSize::height () const -->
+  <function name="QRect::bottom,QRect::height,QRect::left,QRect::right,QRect::top,QRect::width,QRect::x,QRect::y,QSize::width,QSize::height">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!--QSize QRect::size () const -->
+  <function name="QRect::size">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="QSize"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!--bool QRect::isEmpty () const -->
+  <!--bool QRect::isNull () const -->
+  <!--bool QRect::isValid () const -->
+  <!--bool QSize::isValid () const -->
+  <!--bool QSize::isEmpty () const -->
+  <!--bool QSize::isNull () const -->
+  <function name="QRect::isEmpty,QRect::isNull,QRect::isValid,QSize::isValid,QSize::isEmpty,QSize::isNull">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!--QPoint QRect::topLeft () const -->
+  <!--QPoint QRect::topRight () const -->
+  <!--QPoint QRect::bottomLeft () const -->
+  <!--QPoint QRect::bottomRight () const -->
+  <!--QPoint QRect::center () const -->
+  <function name="QRect::topLeft,QRect::topRight,QRect::bottomLeft,QRect::bottomRight,QRect::center">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="QPoint"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!--int QPoint::x() const -->
+  <!--int QPoint::y() const -->
+  <!--int QPoint::manhattanLength() const -->
+  <function name="QPoint::x,QPoint::y,QPoint::manhattanLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!--bool QPoint::isNull() const -->
+  <!--bool QPointF::isNull() const -->
+  <function name="QPoint::isNull,QPointF::isNull">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+     <const/>
+  </function>
+  <!--void QRect::setHeight(int h) -->
+  <!--void QRect::setWidth(int w) -->
+  <!--void QSize::setHeight(int h) -->
+  <!--void QSize::setWidth(int w) -->
+  <!--void QPoint::setX(int x) -->
+  <!--void QPoint::setY(int y) -->
+  <!--void QPointF::setX(qreal x) -->
+  <!--void QPointF::setY(qreal y) -->
+  <function name="QRect::setHeight,QRect::setWidth,QSize::setHeight,QSize::setWidth,QPoint::setX,QPoint::setY,QPointF::setX,QPointF::setY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- void QPainter::drawEllipse(const QRectF &rectangle) -->
   <!-- void QPainter::drawEllipse(const QRect &rectangle) -->
   <!-- void QPainter::drawEllipse(int x, int y, int width, int height) -->
@@ -2899,7 +3395,7 @@
     <returnValue type="bool"/>
     <use-retval/>
     <const/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-uninit/>
     </arg>
   </function>
@@ -2910,7 +3406,7 @@
     <returnValue type="int"/>
     <use-retval/>
     <const/>
-    <arg nr="1" direction="in" default="">
+    <arg nr="1" default="">
       <not-uninit/>
     </arg>
   </function>
@@ -2926,7 +3422,7 @@
   <function name="QHash::find">
     <noreturn>false</noreturn>
     <use-retval/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-uninit/>
     </arg>
   </function>
@@ -2934,10 +3430,10 @@
   <function name="QHash::insert">
     <noreturn>false</noreturn>
     <returnValue type="QHash::iterator"/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-uninit/>
     </arg>
-    <arg nr="2" direction="in">
+    <arg nr="2">
       <not-uninit/>
     </arg>
   </function>
@@ -2974,10 +3470,10 @@
     <noreturn>false</noreturn>
     <use-retval/>
     <const/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-uninit/>
     </arg>
-    <arg nr="2" direction="in" default="">
+    <arg nr="2" default="">
       <not-uninit/>
     </arg>
   </function>
@@ -2987,13 +3483,13 @@
     <noreturn>false</noreturn>
     <use-retval/>
     <const/>
-    <arg nr="1" direction="in" default="">
+    <arg nr="1" default="">
       <not-uninit/>
     </arg>
   </function>
   <!-- QXmlStreamWriter https://doc.qt.io/qt-5/qxmlstreamwriter.html -->
   <!-- bool	QXmlStreamWriter::autoFormatting() const -->
-  <function name="QXmlStreamWriter::autoFormattingIndent">
+  <function name="QXmlStreamWriter::autoFormatting">
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
     <use-retval/>
@@ -3017,7 +3513,7 @@
     <const/>
   </function>
   <!-- QIODevice *QXmlStreamWriter::device() const -->
-  <function name="QXmlStreamWriter::codec">
+  <function name="QXmlStreamWriter::device">
     <noreturn>false</noreturn>
     <returnValue type="QIODevice *"/>
     <use-retval/>
@@ -3070,7 +3566,7 @@
     </arg>
   </function>
   <!-- void QXmlStreamWriter::writeAttributes(const QXmlStreamAttributes &attributes) -->
-  <function name="QXmlStreamWriter::writeAttribute">
+  <function name="QXmlStreamWriter::writeAttributes">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
@@ -3465,7 +3961,6 @@
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
-      <not-bool/>
     </arg>
   </function>
   <!-- void QAction::setShortcut(const QKeySequence &shortcut) -->
@@ -3626,7 +4121,7 @@
     </arg>
   </function>
   <!-- void QLabel::setWordWrap(bool on) -->
-  <function name="QLabel::setText">
+  <function name="QLabel::setWordWrap">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
@@ -3801,7 +4296,7 @@
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
   </function>
@@ -3816,11 +4311,6 @@
       <valid>0:</valid>
     </arg>
   </function>
-  <!-- void QVector::clear() -->
-  <function name="QVector::clear,QStack::clear">
-    <noreturn>false</noreturn>
-    <returnValue type="void"/>
-  </function>
   <!-- bool QVector::contains(const T &value) const -->
   <function name="QVector::contains,QStack::contains">
     <noreturn>false</noreturn>
@@ -3828,7 +4318,7 @@
     <use-retval/>
     <leak-ignore/>
     <const/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
   </function>
@@ -3844,33 +4334,20 @@
       <not-uninit/>
     </arg>
   </function>
-  <!-- T *QVector::data() -->
-  <!-- const T *QVector::data() const -->
-  <function name="QVector::data,QStack::data">
-    <noreturn>false</noreturn>
-    <use-retval/>
-  </function>
-  <!-- bool QVector::empty() const -->
-  <function name="QVector::empty,QStack::empty">
-    <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <use-retval/>
-    <const/>
-  </function>
   <!-- bool QVector::endsWith(const T &value) const -->
   <function name="QVector::endsWith,QStack::endsWith">
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
     <use-retval/>
     <const/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
   </function>
   <!-- QVector<T> &QVector::fill(const T &value, int size = ...) -->
   <function name="QVector::fill,QStack::fill">
     <noreturn>false</noreturn>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
     <arg nr="2" direction="in" default="-1">
@@ -3885,7 +4362,7 @@
     <use-retval/>
     <leak-ignore/>
     <const/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
     <arg nr="2" direction="in" default="">
@@ -3898,23 +4375,16 @@
   <function name="QVector::insert,QStack::insert">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="3" direction="in">
+    <arg nr="3" direction="in" indirect="0">
       <not-uninit/>
     </arg>
   </function>
-  <!-- bool QVector::isEmpty() const -->
-  <function name="QVector::isEmpty,QStack::isEmpty">
-    <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <use-retval/>
-    <const/>
-  </function>
   <!-- int QVector::lastIndexOf(const T &value, int from = ...) const -->
   <function name="QVector::lastIndexOf,QStack::lastIndexOf">
     <noreturn>false</noreturn>
@@ -3922,7 +4392,7 @@
     <use-retval/>
     <leak-ignore/>
     <const/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
     <arg nr="2" direction="in" default="-1">
@@ -3930,20 +4400,13 @@
       <not-bool/>
     </arg>
   </function>
-  <!-- int QVector::length() const -->
-  <function name="QVector::length,QStack::length">
-    <noreturn>false</noreturn>
-    <returnValue type="int"/>
-    <use-retval/>
-    <const/>
-  </function>
   <!-- void QVector::push_back(const T &value) -->
   <!-- void QVector::push_back(T &&value) -->
   <function name="QVector::push_back,QStack::push_back">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
   </function>
@@ -3965,7 +4428,7 @@
   <function name="QVector::removeAll,QStack::removeAll">
     <noreturn>false</noreturn>
     <returnValue type="int"/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
   </function>
@@ -3985,7 +4448,7 @@
       <not-uninit/>
       <valid>0:</valid>
     </arg>
-    <arg nr="2" direction="in">
+    <arg nr="2" direction="in" indirect="0">
       <not-uninit/>
     </arg>
   </function>
@@ -4024,7 +4487,7 @@
     <use-retval/>
     <leak-ignore/>
     <const/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
   </function>
@@ -4085,7 +4548,7 @@
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
   </function>
@@ -4096,7 +4559,7 @@
     <returnValue type="int"/>
     <use-retval/>
     <const/>
-    <arg nr="1" direction="in" default="">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
   </function>
@@ -4107,7 +4570,7 @@
     <use-retval/>
     <leak-ignore/>
     <const/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
   </function>
@@ -4136,7 +4599,7 @@
     <use-retval/>
     <leak-ignore/>
     <const/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
   </function>
@@ -4441,6 +4904,17 @@
     <use-retval/>
     <const/>
   </function>
+  <!-- QSqlDatabase https://doc.qt.io/qt-5/qsqldatabase.html -->
+  <!-- bool QSqlDatabase::commit() -->
+  <!-- bool QSqlDatabase::rollback() -->
+  <!-- bool QSqlDatabase::open() -->
+  <!-- bool QSqlDatabase::transaction() -->
+  <function name="QSqlDatabase::commit,QSqlDatabase::rollback,QSqlDatabase::open,QSqlDatabase::transaction">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval type="error-code"/>
+    <leak-ignore/>
+  </function>
   <!-- QSqlQuery https://doc.qt.io/qt-5/qsqlquery.html -->
   <!-- void QSqlQuery::addBindValue(const QVariant &val, QSql::ParamType paramType = QSql::In) -->
   <function name="QSqlQuery::addBindValue">
@@ -4516,6 +4990,7 @@
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
     <leak-ignore/>
+    <use-retval type="error-code"/>
     <arg nr="1" direction="in" default="">
       <not-uninit/>
       <not-bool/>
@@ -4627,6 +5102,7 @@
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
     <leak-ignore/>
+    <use-retval type="error-code"/>
     <arg nr="1" direction="in">
       <not-uninit/>
       <not-bool/>
@@ -4701,7 +5177,7 @@
     </arg>
   </function>
   <!-- ##### Container ##### -->
-  <container id="qtContainer" opLessAllowed="false" itEndPattern="&gt; :: iterator|const_iterator">
+  <container id="qtContainer" endPattern="&gt; !!::" opLessAllowed="false" itEndPattern="&gt; :: iterator|const_iterator">
     <type templateParameter="0"/>
     <size>
       <function name="append" action="push"/>
@@ -4735,6 +5211,7 @@
       <function name="pop_front" action="pop"/>
       <function name="removeAll" action="change"/>
       <function name="removeAt" action="pop"/>
+      <function name="removeDuplicates" action="change"/>
       <function name="removeFirst" action="pop"/>
       <function name="removeLast" action="pop"/>
       <function name="takeAt" action="pop"/>
@@ -4804,6 +5281,7 @@
       <function name="back" yields="item"/>
       <function name="last" yields="item"/>
       <function name="data" yields="buffer"/>
+      <function name="constData" yields="buffer-nt"/>
       <function name="rbegin" yields="start-iterator"/>
       <function name="crbegin" yields="start-iterator"/>
       <function name="rend" yields="end-iterator"/>
@@ -4830,6 +5308,25 @@
       <function name="shrink_to_fit" action="change-internal"/>
       <function name="squeeze" action="change-internal"/>
       <function name="reserve" action="change-internal"/>
+      <function name="chop" action="change"/>
+      <function name="remove" action="change"/>
+      <function name="append" action="append"/>
+    </size>
+    <access indexOperator="array-like">
+      <function name="at" yields="at_index"/>
+      <function name="front" yields="item"/>
+      <function name="back" yields="item"/>
+      <function name="rbegin" yields="start-iterator"/>
+      <function name="crbegin" yields="start-iterator"/>
+      <function name="rend" yields="end-iterator"/>
+      <function name="crend" yields="end-iterator"/>
+    </access>
+  </container>
+  <container id="qtLatin1String" startPattern="QLatin1String" endPattern="" inherits="qtContainer" opLessAllowed="true" itEndPattern=":: const_iterator|const_reverse_iterator">
+    <type string="std-like"/>
+    <size>
+      <function name="isNull" yields="empty"/>
+      <function name="chop" action="change"/>
     </size>
     <access indexOperator="array-like">
       <function name="at" yields="at_index"/>
@@ -4856,22 +5353,71 @@
       <function name="at" yields="at_index"/>
       <function name="front" yields="item"/>
       <function name="back" yields="item"/>
+      <function name="data" yields="buffer"/>
+      <function name="constData" yields="buffer-nt"/>
       <function name="rbegin" yields="start-iterator"/>
       <function name="crbegin" yields="start-iterator"/>
       <function name="rend" yields="end-iterator"/>
       <function name="crend" yields="end-iterator"/>
     </access>
   </container>
-  <!-- TODO: Inheriting from qtList also inherits from qtContainer which sets "<type templateParameter="0"/>". This is not correct, but seems to do no harm. Currently this can not be unset. -->
-  <container id="qtStringList" startPattern="QStringList" inherits="qtList" opLessAllowed="true" itEndPattern=":: iterator|const_iterator|reverse_iterator|const_reverse_iterator">
-    <size>
-      <function name="removeDuplicates" action="change"/>
-    </size>
+  <container id="qtMap" startPattern="QMap|QMultiMap|QHash &lt;" inherits="qtContainer">
+    <type templateParameter="1" associative="std-like"/>
+    <rangeItemRecordType>
+      <member name="first" templateParameter="0"/>
+      <member name="second" templateParameter="1"/>
+    </rangeItemRecordType>
+    <access>
+      <function name="count" action="find"/>
+      <function name="find" action="find" yields="iterator"/>
+      <function name="insert" action="push"/>
+      <function name="lower_bound" yields="iterator"/>
+      <function name="upper_bound" yields="iterator"/>
+    </access>
   </container>
+  <container id="qtSet" startPattern="QSet &lt;" inherits="qtContainer">
+    <access>
+      <function name="count" action="find"/>
+      <function name="find" action="find" yields="iterator"/>
+      <function name="insert" action="push"/>
+    </access>
+  </container>
+  <container id="qtQueue" startPattern="QQueue &lt;" inherits="qtContainer">
+    <access>
+      <function name="at" yields="at_index"/>
+      <function name="emplace" action="push" yields="item"/>
+      <function name="push_front" action="push"/>
+      <function name="push_back" action="push"/>
+      <function name="pop_back" action="pop"/>
+      <function name="pop_front" action="pop"/>
+      <function name="front" yields="item"/>
+      <function name="back" yields="item"/>
+    </access>
+  </container>
+  <type-checks>
+    <unusedvar>
+      <suppress>QApplication</suppress>
+      <suppress>QMutexLocker</suppress>
+      <check>QRect</check>
+      <check>QRectF</check>
+      <check>QSize</check>
+      <check>QSizeF</check>
+      <check>QPoint</check>
+      <check>QPointF</check>
+      <check>QRegion</check>
+      <check>QTransform</check>
+    </unusedvar>
+    <operatorEqVarError>
+      <suppress>QMutex</suppress>
+      <suppress>QRecursiveMutex</suppress>
+      <suppress>QSemaphore</suppress>
+      <suppress>QReadWriteLock</suppress>
+    </operatorEqVarError>
+  </type-checks>
+  <!-- Treat QStringList as QList<QString> since we can't remove the template parameter when we inherit. -->
+  <define name="QStringList" value="QList&lt;QString&gt;"/>
   <define name="Q_ARG(type, data)" value="QArgument&lt;type &gt;(#type, data)"/>
-  <!-- TODO: Enable when ticket 8479 got fixed
   <define name="Q_D(Class)" value="Class##Private * const d = d_func()"/>
-  -->
   <define name="Q_CLASSINFO(Name, Value)" value=""/>
   <define name="Q_EXPORT_PLUGIN(ClassName)" value=""/>
   <define name="Q_EXPORT_PLUGIN2(a,ClassName)" value=""/>
@@ -4879,8 +5425,11 @@
   <define name="Q_IMPORT_PLUGIN2(a,ClassName)" value=""/>
   <define name="Q_GLOBAL_STATIC(Type,VariableName)" value=""/>
   <define name="Q_GLOBAL_STATIC_WITH_ARGS(Type,VariableName,Arguments)" value=""/>
+  <define name="Q_NAMESPACE_EXPORT" value=""/>
   <define name="Q_DECL_EXPORT" value=""/>
   <define name="Q_DECL_IMPORT" value=""/>
+  <define name="Q_DECL_DEPRECATED" value=""/>
+  <define name="Q_DECL_DEPRECATED_X(text)" value=""/>
   <define name="QT_DECLARE_DEPRECATED_TR_FUNCTIONS(context)" value="static inline QString trUtf8(const char *sourceText, const char *disambiguation = Q_NULLPTR, int n = -1) { return QCoreApplication::translate(#context, sourceText, disambiguation, n); }"/>
   <define name="Q_DECLARE_FLAGS(x,y)" value=""/>
   <define name="Q_DECLARE_SEQUENTIAL_ITERATOR(C)" value=""/>
@@ -4890,49 +5439,83 @@
   <define name="Q_DECLARE_INTERFACE(ClassName,Identifier)" value=""/>
   <define name="Q_DECLARE_LOGGING_CATEGORY(name)" value="extern const QLoggingCategory &amp;name();"/>
   <define name="Q_DECLARE_OPERATORS_FOR_FLAGS(x)" value=""/>
-  <define name="Q_DECLARE_METATYPE(x)" value=""/>
+  <define name="Q_DECLARE_ASSOCIATIVE_CONTAINER_METATYPE(Container)" value=""/>
+  <define name="Q_DECLARE_METATYPE(Type)" value=""/>
+  <define name="Q_DECLARE_OPAQUE_POINTER(PointerType)" value="QT_BEGIN_NAMESPACE namespace QtPrivate { template &lt;&gt; struct IsPointerDeclaredOpaque&lt;PointerType&gt;: std::true_type {};} QT_END_NAMESPACE"/>
+  <define name="Q_DECLARE_SEQUENTIAL_CONTAINER_METATYPE(Container)" value=""/>
+  <define name="Q_DECLARE_SMART_POINTER_METATYPE(SmartPointer)" value=""/>
+  <define name="Q_DECLARE_BUILTIN_METATYPE(TYPE, NAME)" value=""/>
   <define name="Q_DECLARE_PRIVATE(Class)" value="inline Class##Private* d_func() { return reinterpret_cast&lt;Class##Private*&gt;(qGetPtrHelper(d_ptr)); } inline const Class##Private d_func() const { return reinterpret_cast&lt;const Class##Private *&gt;(qGetPtrHelper(d_ptr)); } friend class Class##Private;"/>
   <define name="Q_DECLARE_PRIVATE_D(Dptr, Class)" value="inline Class##Private* d_func() { return reinterpret_cast&lt;Class##Private *&gt;(qGetPtrHelper(Dptr)); } inline const Class##Private* d_func() const { return reinterpret_cast&lt;const Class##Private *&gt;(qGetPtrHelper(Dptr)); } friend class Class##Private;"/>
   <define name="Q_DECLARE_PUBLIC(Class)" value="inline Class##Public* d_func() { return reinterpret_cast&lt;Class##Public*&gt;(qGetPtrHelper(d_ptr)); } inline const Class##Public d_func() const { return reinterpret_cast&lt;const Class##Public *&gt;(qGetPtrHelper(d_ptr)); } friend class Class##Public;"/>
   <define name="Q_DECLARE_TR_FUNCTIONS(context)" value="public: static inline QString tr(const char *sourceText, const char *disambiguation = Q_NULLPTR, int n = -1) { return QCoreApplication::translate(#context, sourceText, disambiguation, n); } QT_DECLARE_DEPRECATED_TR_FUNCTIONS(context) private:"/>
-  <define name="Q_DISABLE_COPY(C)" value="C(C&amp;);C&amp; operator=(const C&amp;);"/>
+  <define name="Q_DISABLE_COPY(Class)" value="Class(Class&amp;);Class&amp; operator=(const Class&amp;);"/>
+  <define name="Q_DISABLE_COPY_MOVE(Class)" value="Class(Class&amp;);Class&amp; operator=(const Class&amp;);Class(C&amp;&amp;);Class&amp; operator=(Class&amp;&amp;);"/>
+  <define name="Q_EMIT" value=""/>
   <define name="Q_ENUM(X)" value=""/>
   <define name="Q_ENUMS(X)" value=""/>
+  <define name="Q_ENUM_NS(X)" value=""/>
+  <define name="Q_FLAG(X)" value=""/>
   <define name="Q_FLAGS(X)" value=""/>
+  <define name="Q_FLAG_NS(X)" value=""/>
   <define name="Q_FOREVER" value="for (;;)"/>
   <define name="Q_INTERFACES(X)" value=""/>
   <define name="Q_LIKELY(expr)" value="expr"/>
+  <define name="Q_NAMESPACE" value=""/>
   <define name="Q_NULLPTR" value="NULL"/>
-  <define name="Q_OBJECT" value=""/>
+  <define name="Q_OBJECT" value="static void qt_static_metacall(QObject*,QMetaObject::Call,int,void**);virtual const MetaObject* metaObject() const;virtual void* qt_metacast(const char*);virtual int qt_metacall(QMetaObject::Call,int,void**);"/>
   <define name="Q_PRIVATE_SLOT(d, signature)" value=""/>
-  <define name="Q_PROPERTY(X)" value=""/>
+  <define name="Q_SLOTS" value=""/>
+  <!-- Treat as variadic macro to avoid preprocessorErrorDirective -->
+  <define name="Q_PROPERTY(...)" value=""/>
   <define name="Q_Q(Class)" value="Class * const q = q_func()"/>
   <define name="Q_RETURN_ARG(type, data)" value="QReturnArgument&lt;type &gt;(#type, data)"/>
   <define name="Q_UNLIKELY(expr)" value="expr"/>
-  <define name="Q_UNUSED(X)" value="(void)(X)"/>
+  <define name="Q_UNUSED(X)" value="(void)(X);"/>
+  <define name="QT_USE_NAMESPACE" value=""/>
+  <define name="QT_BEGIN_NAMESPACE" value=""/>
+  <define name="QT_END_NAMESPACE" value=""/>
+  <define name="QT_BEGIN_MOC_NAMESPACE" value=""/>
+  <define name="QT_END_MOC_NAMESPACE" value=""/>
+  <define name="QT_BEGIN_HEADER" value=""/>
+  <define name="QT_END_HEADER" value=""/>
   <define name="QT_TR_NOOP(x)" value="x"/>
   <define name="QT_TR_NOOP_UTF8(x)" value="x"/>
   <define name="QT_TRANSLATE_NOOP(scope, x)" value="x"/>
   <define name="QT_TRANSLATE_NOOP_UTF8(scope, x)" value="x"/>
   <define name="QT_TRANSLATE_NOOP3(scope, x, comment)" value="{x, comment}"/>
   <define name="QT_TRANSLATE_NOOP3_UTF8(scope, x, comment)" value="{x, comment}"/>
+  <define name="QT_WARNING_PUSH" value=""/>
+  <define name="QT_WARNING_POP" value=""/>
+  <define name="QT_WARNING_DISABLE_MSVC(number)" value=""/>
+  <define name="QT_WARNING_DISABLE_INTEL(number)" value=""/>
+  <define name="QT_WARNING_DISABLE_CLANG(text)" value=""/>
+  <define name="QT_WARNING_DISABLE_GCC(text)" value=""/>
+  <define name="QT_WARNING_DISABLE_DEPRECATED" value=""/>
+  <define name="QT_STRINGIFY(x)" value="#x"/>
   <define name="QCOMPARE(actual, expected)" value="(void)((actual)==(expected))"/>
   <define name="QVERIFY(condition)" value="(void)(condition)"/>
-  <define name="QVERIFY2(condition, message)" value="(void)(condition)"/>
+  <define name="QVERIFY2(condition, message)" value="(void)(condition),(void)(message)"/>
   <define name="QBENCHMARK_ONCE" value=""/>
   <define name="QBENCHMARK" value=""/>
   <define name="QTRY_COMPARE(actual, expected)" value="(void)((actual)==(expected))"/>
   <define name="QTRY_COMPARE_WITH_TIMEOUT(actual, expected, timeout)" value="(void)((actual)==(expected))"/>
-  <define name="QTRY_VERIFY2(condition, message)" value="(void)(condition)"/>
+  <define name="QTRY_VERIFY2(condition, message)" value="(void)(condition),(void)(message)"/>
   <define name="QTRY_VERIFY(condition)" value="(void)(condition)"/>
-  <define name="QTRY_VERIFY2_WITH_TIMEOUT(condition, message, timeout)" value="(void)(condition)"/>
-  <define name="QTRY_VERIFY_WITH_TIMEOUT(condition, timeout)" value="(void)(condition)"/>
+  <define name="QTRY_VERIFY2_WITH_TIMEOUT(condition, message, timeout)" value="(void)(condition),(void)(message),(void)(timeout)"/>
+  <define name="QTRY_VERIFY_WITH_TIMEOUT(condition, timeout)" value="(void)(condition),(void)(timeout)"/>
   <define name="QTEST_GUILESS_MAIN(testclass)" value=""/>
   <define name="QTEST_APPLESS_MAIN(testclass)" value=""/>
+  <define name="QTEST_MAIN(testclass)" value=""/>
+  <define name="Q_CONSTRUCTOR_FUNCTION0(AFUNC)" value=""/>
+  <define name="Q_CONSTRUCTOR_FUNCTION(AFUNC)" value=""/>
   <define name="Q_FOREACH(A,B)" value="for(A:B)"/>
   <define name="foreach(A,B)" value="for(A:B)"/>
   <define name="forever" value="for (;;)"/>
-  <define name="emit(X)" value="(X)"/>
+  <define name="emit" value=""/>
+  <define name="slots" value=""/>
+  <define name="signals" value="protected"/>
+  <define name="Q_SIGNALS" value="protected"/>
   <define name="Q_OVERRIDE(x)" value=""/>
   <define name="Q_PLUGIN_METADATA(x)" value=""/>
   <define name="Q_ASSERT(condition)" value="assert(condition)"/>
@@ -4943,14 +5526,43 @@
   <define name="QTC_ASSERT(cond," value="action) if (Q_LIKELY(cond)) {} else { QTC_ASSERT_STRING(#cond); action; } do {} while (0)"/>
   <define name="QTC_CHECK(cond)" value="if (Q_LIKELY(cond)) {} else { QTC_ASSERT_STRING(#cond); } do {} while (0)"/>
   <define name="QTC_GUARD(cond)" value="((Q_LIKELY(cond)) ? true : (QTC_ASSERT_STRING(#cond), false))"/>
-  <define name="QTC_ASSERT(cond, action)" value="if (Q_LIKELY(cond)) {} else { QTC_ASSERT_STRING(#cond); action; } do {} while (0)"/>
-  <define name="QTC_CHECK(cond)" value="if (Q_LIKELY(cond)) {} else { QTC_ASSERT_STRING(#cond); } do {} while (0)"/>
-  <define name="QTC_GUARD(cond)" value="((Q_LIKELY(cond)) ? true : (QTC_ASSERT_STRING(#cond), false))"/>
   <define name="Q_LOGGING_CATEGORY(name,...)" value=""/>
   <define name="QT_FORWARD_DECLARE_CLASS(name)" value="class name;"/>
   <define name="QT_FORWARD_DECLARE_STRUCT(name)" value="struct name;"/>
+  <define name="QT_VERSION_CHECK(major, minor, patch)" value="((major&lt;&lt;16)|(minor&lt;&lt;8)|(patch))"/>
+  <define name="QT_CONFIG(feature)" value="1"/>
+  <!-- https://doc.qt.io/qt-6/qqmlintegration-h-qtqml-proxy.html -->
+  <define name="QML_ADDED_IN_VERSION(MAJOR, MINOR)" value=""/>
+  <define name="QML_ANONYMOUS" value=""/>
+  <define name="QML_ATTACHED(ATTACHED_TYPE)" value=""/>
+  <define name="QML_CONSTRUCTIBLE_VALUE" value=""/>
+  <define name="QML_ELEMENT" value=""/>
+  <define name="QML_EXTENDED(EXTENDED_TYPE)" value=""/>
+  <define name="QML_EXTENDED_NAMESPACE(EXTENSION_NAMESPACE)" value=""/>
+  <define name="QML_EXTRA_VERSION(MAJOR, MINOR)" value=""/>
+  <define name="QML_FOREIGN(FOREIGN_TYPE)" value=""/>
+  <define name="QML_FOREIGN_NAMESPACE(FOREIGN_NAMESPACE)" value=""/>
+  <define name="QML_IMPLEMENTS_INTERFACES(interfaces)" value=""/>
+  <define name="QML_INTERFACE" value=""/>
+  <define name="QML_NAMED_ELEMENT(name)" value=""/>
+  <define name="QML_REMOVED_IN_VERSION(MAJOR, MINOR)" value=""/>
+  <define name="QML_SEQUENTIAL_CONTAINER(VALUE_TYPE)" value=""/>
+  <define name="QML_SINGLETON" value=""/>
+  <define name="QML_STRUCTURED_VALUE" value=""/>
+  <define name="QML_UNAVAILABLE" value=""/>
+  <define name="QML_UNCREATABLE(reason)" value=""/>
+  <define name="QML_VALUE_TYPE(name)" value=""/>
+  <!-- https://doc.qt.io/qt-6/qqml-h-qtqml-proxy.html -->
+  <define name="QML_DECLARE_TYPE" value=""/>
+  <define name="QML_DECLARE_TYPEINFO(Type, Flags)" value=""/>
+  <!-- https://doc.qt.io/qt-6/qobjectbindableproperty.html -->
+  <define name="Q_OBJECT_BINDABLE_PROPERTY(containingClass, type, name, signal)" value=""/>
+  <define name="Q_OBJECT_BINDABLE_PROPERTY_WITH_ARGS(containingClass, type, name, initialvalue, signal)" value=""/>
+  <!-- https://doc.qt.io/qt-6/qqmlengineextensionplugin.html -->
+  <define name="Q_IMPORT_QML_PLUGIN(PluginName)" value=""/>
   <!-- https://doc.qt.io/qt-5/qstring.html#QStringLiteral -->
   <define name="QStringLiteral(str)" value="QString::fromUtf8(str, sizeof(str) - 1)"/>
+  <define name="QByteArrayLiteral(str)" value="QByteArray(str)"/>
   <!-- https://doc.qt.io/qt-5/qtglobal.html#qreal-typedef -->
   <define name="qreal" value="double"/>
   <podtype name="qint8" sign="s" size="1"/>
@@ -4979,8 +5591,12 @@
   <smart-pointer class-name="QSharedPointer"/>
   <smart-pointer class-name="QWeakPointer"/>
   <smart-pointer class-name="QPointer"/>
-  <smart-pointer class-name="QScopedPointer"/>
-  <smart-pointer class-name="QScopedArrayPointer"/>
+  <smart-pointer class-name="QScopedPointer">
+    <unique/>
+  </smart-pointer>
+  <smart-pointer class-name="QScopedArrayPointer">
+    <unique/>
+  </smart-pointer>
   <!-- Internal Smart Pointers -->
   <smart-pointer class-name="QtPatternist::AutoPtr"/>
   <smart-pointer class-name="QGuard"/>
diff --git a/cfg/ruby.cfg b/cfg/ruby.cfg
index 1b54eeef4df..fbf037fb1e9 100644
--- a/cfg/ruby.cfg
+++ b/cfg/ruby.cfg
@@ -1,6 +1,78 @@
 <?xml version="1.0"?>
 <def format="2">
   <!-- Ruby C API. see https://docs.ruby-lang.org/en/2.5.0/extension_rdoc.html -->
+  <!-- INT2NUM() is a macro resulting in something like this: VALUE INT2NUM(int v) -->
+  <!-- UINT2NUM() is something like this: VALUE UINT2NUM(unsigned int v) -->
+  <!-- LONG2NUM() is something like this: VALUE LONG2NUM(long v) -->
+  <!-- ULONG2NUM() is something like this: VALUE ULONG2NUM(unsigned long v) -->
+  <!-- LL2NUM() is something like this: VALUE LL2NUM(long long v) -->
+  <!-- ULL2NUM() is something like this: VALUE ULL2NUM(unsigned long long v) -->
+  <function name="INT2NUM,UINT2NUM,LONG2NUM,ULONG2NUM,LL2NUM,ULL2NUM">
+    <noreturn>false</noreturn>
+    <returnValue type="VALUE"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- NUM2INT() is something like this: int NUM2INT(VALUE v) -->
+  <!-- FIX2INT() is something like this: int FIX2INT(VALUE v) -->
+  <function name="NUM2INT,FIX2INT">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- NUM2UINT() is something like this: unsigned int NUM2UINT(VALUE v) -->
+  <!-- FIX2UINT() is something like this: unsigned int FIX2UINT(VALUE v) -->
+  <function name="NUM2UINT,FIX2UINT">
+    <noreturn>false</noreturn>
+    <returnValue type="unsigned int"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- NUM2LONG() is something like this: long NUM2LONG(VALUE v) -->
+  <!-- FIX2LONG() is something like this: long FIX2LONG(VALUE v) -->
+  <function name="NUM2LONG,FIX2LONG">
+    <noreturn>false</noreturn>
+    <returnValue type="long"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- NUM2ULONG() is something like this: unsigned long NUM2ULONG(VALUE v) -->
+  <!-- FIX2ULONG() is something like this: unsigned long FIX2ULONG(VALUE v) -->
+  <function name="NUM2ULONG,FIX2ULONG">
+    <noreturn>false</noreturn>
+    <returnValue type="unsigned long"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- NUM2LL() is something like this: long long NUM2LL(VALUE v) -->
+  <function name="NUM2LL">
+    <noreturn>false</noreturn>
+    <returnValue type="long long"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- NUM2ULL()  is something like this: unsigned long long NUM2ULL(VALUE v) -->
+  <function name="NUM2ULL">
+    <noreturn>false</noreturn>
+    <returnValue type="unsigned long long"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- void rb_define_const(VALUE klass, const char *name, VALUE val)  -->
   <function name="rb_define_const">
     <leak-ignore/>
@@ -66,4 +138,5 @@
     </arg>
   </function>
   <podtype name="ID"/>
+  <podtype name="VALUE" sign="u"/>
 </def>
diff --git a/cfg/selinux.cfg b/cfg/selinux.cfg
new file mode 100644
index 00000000000..e2d7ac34dc3
--- /dev/null
+++ b/cfg/selinux.cfg
@@ -0,0 +1,3621 @@
+<?xml version="1.0"?>
+<def format="2">
+  <!-- <selinux/restorecon.h> -->
+  <!-- https://man7.org/linux/man-pages/man3/selinux_restorecon.3.html -->
+  <!-- int selinux_restorecon(const char *pathname, unsigned int restorecon_flags); -->
+  <function name="selinux_restorecon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int selinux_restorecon_parallel(const char *pathname, unsigned int restorecon_flags, size_t nthreads); -->
+  <function name="selinux_restorecon_parallel">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <define name="SELINUX_RESTORECON_IGNORE_DIGEST" value="0x00001"/>
+  <define name="SELINUX_RESTORECON_NOCHANGE" value="0x00002"/>
+  <define name="SELINUX_RESTORECON_SET_SPECFILE_CTX" value="0x00004"/>
+  <define name="SELINUX_RESTORECON_RECURSE" value="0x00008"/>
+  <define name="SELINUX_RESTORECON_VERBOSE" value="0x00010"/>
+  <define name="SELINUX_RESTORECON_PROGRESS" value="0x00020"/>
+  <define name="SELINUX_RESTORECON_REALPATH" value="0x00040"/>
+  <define name="SELINUX_RESTORECON_XDEV" value="0x00080"/>
+  <define name="SELINUX_RESTORECON_ADD_ASSOC" value="0x00100"/>
+  <define name="SELINUX_RESTORECON_ABORT_ON_ERROR" value="0x00200"/>
+  <define name="SELINUX_RESTORECON_SYSLOG_CHANGES" value="0x00400"/>
+  <define name="SELINUX_RESTORECON_LOG_MATCHES" value="0x00800"/>
+  <define name="SELINUX_RESTORECON_IGNORE_NOENTRY" value="0x01000"/>
+  <define name="SELINUX_RESTORECON_IGNORE_MOUNTS" value="0x02000"/>
+  <define name="SELINUX_RESTORECON_MASS_RELABEL" value="0x04000"/>
+  <define name="SELINUX_RESTORECON_SKIP_DIGEST" value="0x08000"/>
+  <define name="SELINUX_RESTORECON_CONFLICT_ERROR" value="0x10000"/>
+  <define name="SELINUX_RESTORECON_COUNT_ERRORS" value="0x20000"/>
+  <!-- https://man7.org/linux/man-pages/man3/selinux_restorecon_set_sehandle.3.html -->
+  <!-- void selinux_restorecon_set_sehandle(struct selabel_handle *hndl); -->
+  <function name="selinux_restorecon_set_sehandle">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/selinux_restorecon_default_handle.3.html -->
+  <!-- struct selabel_handle *selinux_restorecon_default_handle(void); -->
+  <function name="selinux_restorecon_default_handle">
+    <returnValue type="struct selabel_handle *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/selinux_restorecon_set_exclude_list.3.html -->
+  <!-- void selinux_restorecon_set_exclude_list(const char **exclude_list); -->
+  <function name="selinux_restorecon_set_exclude_list">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/selinux_restorecon_set_alt_rootpath.3.html -->
+  <!-- int selinux_restorecon_set_alt_rootpath(const char *alt_rootpath); -->
+  <function name="selinux_restorecon_set_alt_rootpath">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/selinux_restorecon_get_skipped_errors.3.html -->
+  <!-- long unsigned selinux_restorecon_get_skipped_errors(void); -->
+  <function name="selinux_restorecon_get_skipped_errors">
+    <returnValue type="unsigned long"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/selinux_restorecon_xattr.3.html -->
+  <!-- int selinux_restorecon_xattr(const char *pathname, unsigned int xattr_flags, struct dir_xattr ***xattr_list); -->
+  <function name="selinux_restorecon_xattr">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <define name="SELINUX_RESTORECON_XATTR_RECURSE" value="0x0001"/>
+  <define name="SELINUX_RESTORECON_XATTR_DELETE_NONMATCH_DIGESTS" value="0x0002"/>
+  <define name="SELINUX_RESTORECON_XATTR_DELETE_ALL_DIGESTS" value="0x0004"/>
+  <define name="SELINUX_RESTORECON_XATTR_IGNORE_MOUNTS" value="0x0008"/>
+  <!-- <selinux/get_default_type.h> -->
+  <!-- https://man7.org/linux/man-pages/man3/selinux_binary_policy_path.3.html -->
+  <!-- const char *selinux_default_type_path(void); -->
+  <function name="selinux_default_type_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/get_ordered_context_list.3.html -->
+  <!-- int get_default_type(const char *role, char **type); -->
+  <function name="get_default_type">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">get_default_type</alloc>
+    <dealloc>free</dealloc>
+  </memory>
+  <!-- <selinux/label.h> -->
+  <!-- https://man7.org/linux/man-pages/man3/selabel_open.3.html -->
+  <podtype name="selabel_handle"/>
+  <!-- struct selabel_handle *selabel_open(unsigned int backend, const struct selinux_opt *opts, unsigned nopts); -->
+  <function name="selabel_open">
+    <returnValue type="struct selabel_handle *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:5</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <define name="SELABEL_CTX_FILE" value="0"/>
+  <define name="SELABEL_CTX_MEDIA" value="1"/>
+  <define name="SELABEL_CTX_X" value="2"/>
+  <define name="SELABEL_CTX_DB" value="3"/>
+  <define name="SELABEL_CTX_ANDROID_PROP" value="4"/>
+  <define name="SELABEL_CTX_ANDROID_SERVICE" value="5"/>
+  <define name="SELABEL_OPT_UNUSED" value="0"/>
+  <define name="SELABEL_OPT_VALIDATE" value="1"/>
+  <define name="SELABEL_OPT_BASEONLY" value="2"/>
+  <define name="SELABEL_OPT_PATH" value="3"/>
+  <define name="SELABEL_OPT_SUBSET" value="4"/>
+  <define name="SELABEL_OPT_DIGEST" value="5"/>
+  <define name="SELABEL_NOPT" value="6"/>
+  <!-- void selabel_close(struct selabel_handle *handle); -->
+  <function name="selabel_close">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
+  <resource>
+    <alloc init="true">selabel_open</alloc>
+    <dealloc>selabel_close</dealloc>
+  </resource>
+  <!-- https://man7.org/linux/man-pages/man3/selabel_lookup.3.html -->
+  <!-- int selabel_lookup(struct selabel_handle *handle, char **con, const char *key, int type); -->
+  <function name="selabel_lookup">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">selabel_lookup</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int selabel_lookup_raw(struct selabel_handle *handle, char **con, const char *key, int type); -->
+  <function name="selabel_lookup_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">selabel_lookup_raw</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- https://man7.org/linux/man-pages/man3/selabel_partial_match.3.html -->
+  <!-- bool selabel_partial_match(struct selabel_handle *handle, const char *key); -->
+  <function name="selabel_lookup_raw">
+    <returnValue type="bool"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/selabel_get_digests_all_partial_matches.3.html -->
+  <!-- bool selabel_get_digests_all_partial_matches(struct selabel_handle *rec, const char *key, uint8_t **calculated_digest, uint8_t **xattr_digest, size_t *digest_len); -->
+  <function name="selabel_get_digests_all_partial_matches">
+    <returnValue type="bool"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="4" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="5" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="3">selabel_get_digests_all_partial_matches</alloc>
+    <dealloc>free</dealloc>
+  </memory>
+  <memory>
+    <alloc init="true" arg="4">selabel_get_digests_all_partial_matches</alloc>
+    <dealloc>free</dealloc>
+  </memory>
+  <!-- bool selabel_hash_all_partial_matches(struct selabel_handle *rec, const char *key, uint8_t* digest); -->
+  <function name="selabel_hash_all_partial_matches">
+    <returnValue type="bool"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/selabel_lookup_best_match.3.html -->
+  <!-- int selabel_lookup_best_match(struct selabel_handle *rec, char **con, const char *key, const char **aliases, int type); -->
+  <function name="selabel_lookup_best_match">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">selabel_lookup_best_match</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int selabel_lookup_best_match_raw(struct selabel_handle *rec, char **con, const char *key, const char **aliases, int type); -->
+  <function name="selabel_lookup_best_match_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">selabel_lookup_best_match_raw</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- https://man7.org/linux/man-pages/man3/selabel_digest.3.html -->
+  <!-- int selabel_digest(struct selabel_handle *rec, unsigned char **digest, size_t *digest_len, char ***specfiles, size_t *num_specfiles); -->
+  <function name="selabel_digest">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="4" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="5" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- enum selabel_cmp_result selabel_cmp(const struct selabel_handle *h1, const struct selabel_handle *h2); -->
+  <function name="selabel_cmp">
+    <returnValue type="enum selabel_cmp_result"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/selabel_stats.3.html -->
+  <!-- void selabel_stats(struct selabel_handle *handle); -->
+  <function name="selabel_stats">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man5/selabel_x.5.html -->
+  <define name="SELABEL_X_PROP" value="1"/>
+  <define name="SELABEL_X_EXT" value="2"/>
+  <define name="SELABEL_X_CLIENT" value="3"/>
+  <define name="SELABEL_X_EVENT" value="4"/>
+  <define name="SELABEL_X_SELN" value="5"/>
+  <define name="SELABEL_X_POLYPROP" value="6"/>
+  <define name="SELABEL_X_POLYSELN" value="7"/>
+  <!-- https://man7.org/linux/man-pages/man5/selabel_db.5.html -->
+  <define name="SELABEL_DB_DATABASE" value="1"/>
+  <define name="SELABEL_DB_SCHEMA" value="2"/>
+  <define name="SELABEL_DB_TABLE" value="3"/>
+  <define name="SELABEL_DB_COLUMN" value="4"/>
+  <define name="SELABEL_DB_SEQUENCE" value="5"/>
+  <define name="SELABEL_DB_VIEW" value="6"/>
+  <define name="SELABEL_DB_PROCEDURE" value="7"/>
+  <define name="SELABEL_DB_BLOB" value="8"/>
+  <define name="SELABEL_DB_TUPLE" value="9"/>
+  <define name="SELABEL_DB_LANGUAGE" value="10"/>
+  <define name="SELABEL_DB_EXCEPTION" value="11"/>
+  <define name="SELABEL_DB_DATATYPE" value="12"/>
+  <!-- <selinux/context.h> -->
+  <!-- https://man7.org/linux/man-pages/man3/context_new.3.html -->
+  <podtype name="context_t"/>
+  <!-- context_t context_new(const char *str); -->
+  <function name="context_new">
+    <returnValue type="context_new"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- const char *context_str(context_t con); -->
+  <function name="context_str">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void context_free(context_t con); -->
+  <function name="context_free">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true">context_new</alloc>
+    <dealloc>context_free</dealloc>
+  </memory>
+  <!-- const char *context_type_get(context_t con); -->
+  <function name="context_type_get">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- const char *context_range_get(context_t con); -->
+  <function name="context_range_get">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- const char *context_role_get(context_t con); -->
+  <function name="context_role_get">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- const char *context_user_get(context_t con); -->
+  <function name="context_user_get">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int context_type_set(context_t con, const char *type); -->
+  <function name="context_type_set">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int context_range_set(context_t con, const char *type); -->
+  <function name="context_range_set">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int context_role_set(context_t con, const char *type); -->
+  <function name="context_role_set">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int context_user_set(context_t con, const char *type); -->
+  <function name="context_user_set">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- <selinux/get_context_list.h> -->
+  <define name="SELINUX_DEFAULTUSER" value="&quot;user_u&quot;"/>
+  <!-- https://man7.org/linux/man-pages/man3/get_ordered_context_list.3.html -->
+  <!-- int get_ordered_context_list(const char *user, const char *fromcon, char *** list); -->
+  <function name="get_ordered_context_list">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="3">get_ordered_context_list</alloc>
+    <dealloc>freeconary</dealloc>
+  </memory>
+  <!-- int get_ordered_context_list_with_level(const char *user, const char *level, const char *fromcon, char *** list); -->
+  <function name="get_ordered_context_list_with_level">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="4" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="4">get_ordered_context_list_with_level</alloc>
+    <dealloc>freeconary</dealloc>
+  </memory>
+  <!-- int get_default_context(const char *user, const char *fromcon, char ** newcon); -->
+  <function name="get_default_context">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="3">get_default_context</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int get_default_context_with_level(const char *user, const char *level, const char *fromcon, char ** newcon); -->
+  <function name="get_default_context_with_level">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="4" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="4">get_default_context_with_level</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int get_default_context_with_role(const char *user, const char *role, const char *fromcon, char ** newcon); -->
+  <function name="get_default_context_with_role">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="4" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="4">get_default_context_with_role</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int get_default_context_with_rolelevel(const char *user, const char *role, const char *level, const char *fromcon, char ** newcon); -->
+  <function name="get_default_context_with_rolelevel">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="5" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="5">get_default_context_with_rolelevel</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int query_user_context(char ** list, char ** newcon); -->
+  <function name="query_user_context">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">query_user_context</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int manual_user_enter_context(const char *user, char ** newcon); -->
+  <function name="manual_user_enter_context">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">manual_user_enter_context</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- <selinux/avc.h> -->
+  <podtype name="security_id"/>
+  <define name="SECSID_WILD" value="NULL"/>
+  <define name="AVC_OPT_UNUSED" value="0"/>
+  <define name="AVC_OPT_SETENFORCE" value="1"/>
+  <define name="AVC_CALLBACK_GRANT" value="1"/>
+  <define name="AVC_CALLBACK_TRY_REVOKE" value="2"/>
+  <define name="AVC_CALLBACK_REVOKE" value="4"/>
+  <define name="AVC_CALLBACK_RESET" value="8"/>
+  <define name="AVC_CALLBACK_AUDITALLOW_ENABLE" value="16"/>
+  <define name="AVC_CALLBACK_AUDITALLOW_DISABLE" value="32"/>
+  <define name="AVC_CALLBACK_AUDITDENY_ENABLE" value="64"/>
+  <define name="AVC_CALLBACK_AUDITDENY_DISABLE" value="128"/>
+  <define name="AVC_CACHE_STATS" value="1"/>
+  <!-- https://man7.org/linux/man-pages/man3/avc_context_to_sid.3.html -->
+  <!-- int avc_sid_to_context(security_id_t sid, char ** ctx); -->
+  <function name="avc_sid_to_context">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">avc_sid_to_context</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int avc_sid_to_context_raw(security_id_t sid, char ** ctx); -->
+  <function name="avc_sid_to_context_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">avc_sid_to_context</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int avc_context_to_sid(const char * ctx, security_id_t * sid); -->
+  <function name="avc_context_to_sid">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- int avc_context_to_sid_raw(const char * ctx, security_id_t * sid); -->
+  <function name="avc_context_to_sid_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- int avc_get_initial_sid(const char *name, security_id_t * sid); -->
+  <function name="avc_get_initial_sid">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- int sidget(security_id_t sid); -->
+  <function name="sidget">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int sidput(security_id_t sid); -->
+  <function name="sidput">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/avc_init.3.html -->
+  <!-- int avc_init(const char *msgprefix, const struct avc_memory_callback *mem_callbacks, const struct avc_log_callback *log_callbacks, const struct avc_thread_callback *thread_callbacks,
+  const struct avc_lock_callback *lock_callbacks) -->
+  <function name="avc_init">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/avc_open.3.html -->
+  <!-- int avc_open(struct selinux_opt *opts, unsigned nopts); -->
+  <function name="avc_open">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <minsize type="argvalue" arg="2"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void avc_cleanup(void); -->
+  <function name="avc_cleanup">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+  </function>
+  <!-- int avc_reset(void); -->
+  <function name="avc_reset">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- void avc_destroy(void); -->
+  <function name="avc_destroy">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/avc_has_perm.3.html -->
+  <!-- int avc_has_perm_noaudit(security_id_t ssid, security_id_t tsid, security_class_t tclass, access_vector_t requested, struct avc_entry_ref *aeref, struct av_decision *avd); -->
+  <function name="avc_has_perm_noaudit">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="6" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int avc_has_perm(security_id_t ssid, security_id_t tsid, security_class_t tclass, access_vector_t requested, struct avc_entry_ref *aeref, void *auditdata); -->
+  <function name="avc_has_perm">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="6" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void avc_audit(security_id_t ssid, security_id_t tsid, security_class_t tclass, access_vector_t requested, struct av_decision *avd, int result, void *auditdata); -->
+  <function name="avc_audit">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="7" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/avc_compute_create.3.html -->
+  <!-- int avc_compute_create(security_id_t ssid, security_id_t tsid, security_class_t tclass, security_id_t * newsid); -->
+  <function name="avc_compute_create">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- int avc_compute_member(security_id_t ssid, security_id_t tsid, security_class_t tclass, security_id_t * newsid); -->
+  <function name="avc_compute_member">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/avc_add_callback.3.html -->
+  <!-- int avc_add_callback(int (*callback) (uint32_t event, security_id_t ssid, security_id_t tsid, security_class_t tclass, access_vector_t perms, access_vector_t * out_retained), uint32_t events, security_id_t ssid, security_id_t tsid, security_class_t tclass,
+  access_vector_t perms); -->
+  <function name="avc_add_callback">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/avc_cache_stats.3.html -->
+  <!-- void avc_cache_stats(struct avc_cache_stats *stats); -->
+  <function name="avc_cache_stats">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void avc_av_stats(void); -->
+  <function name="avc_av_stats">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+  </function>
+  <!-- void avc_sid_stats(void); -->
+  <function name="avc_sid_stats">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/avc_netlink_loop.3.html -->
+  <!-- int avc_netlink_open(int blocking); -->
+  <function name="avc_netlink_open">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <valid>0,1</valid>
+    </arg>
+  </function>
+  <!-- void avc_netlink_loop(void); -->
+  <function name="avc_netlink_loop">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+  </function>
+  <!-- void avc_netlink_close(void); -->
+  <function name="avc_netlink_close">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+  </function>
+  <!-- int avc_netlink_acquire_fd(void); -->
+  <function name="avc_netlink_acquire_fd">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- void avc_netlink_release_fd(void); -->
+  <function name="avc_netlink_release_fd">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+  </function>
+  <!-- int avc_netlink_check_nb(void); -->
+  <function name="avc_netlink_check_nb">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/selinux_status_open.3.html -->
+  <!-- int selinux_status_open(int fallback); -->
+  <function name="selinux_status_open">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <valid>0,1</valid>
+    </arg>
+  </function>
+  <!-- void selinux_status_close(void); -->
+  <function name="selinux_status_close">
+    <noreturn>false</noreturn>
+  </function>
+  <!-- TODO: somehow model hidden resource
+  <resource>
+    <alloc init="true">selinux_status_open</alloc>
+    <dealloc>selinux_status_close</dealloc>
+  </resource> -->
+  <!-- int selinux_status_updated(void); -->
+  <function name="selinux_status_updated">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- int selinux_status_getenforce(void); -->
+  <function name="selinux_status_getenforce">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- int selinux_status_policyload(void); -->
+  <function name="selinux_status_policyload">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- int selinux_status_deny_unknown(void); -->
+  <function name="selinux_status_deny_unknown">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- <selinux/selinux.h> -->
+  <podtype name="security_context_t"/>
+  <podtype name="access_vector_t"/>
+  <podtype name="security_class_t"/>
+  <podtype name="av_decision"/>
+  <podtype name="selinux_opt"/>
+  <podtype name="selinux_callback"/>
+  <podtype name="SELboolean"/>
+  <podtype name="security_class_mapping"/>
+  <define name="SELINUX_AVD_FLAGS_PERMISSIVE" value="0x0001"/>
+  <define name="SELINUX_CB_LOG" value="0"/>
+  <define name="SELINUX_CB_AUDIT" value="1"/>
+  <define name="SELINUX_CB_VALIDATE" value="2"/>
+  <define name="SELINUX_CB_SETENFORCE" value="3"/>
+  <define name="SELINUX_CB_POLICYLOAD" value="4"/>
+  <define name="SELINUX_ERROR" value="0"/>
+  <define name="SELINUX_WARNING" value="1"/>
+  <define name="SELINUX_INFO" value="2"/>
+  <define name="SELINUX_AVC" value="3"/>
+  <define name="SELINUX_POLICYLOAD" value="4"/>
+  <define name="SELINUX_SETENFORCE" value="5"/>
+  <define name="SELINUX_TRANS_DIR" value="&quot;/var/run/setrans&quot;"/>
+  <define name="MATCHPATHCON_BASEONLY" value="1"/>
+  <define name="MATCHPATHCON_NOTRANS" value="2"/>
+  <define name="MATCHPATHCON_VALIDATE" value="4"/>
+  <!-- https://man7.org/linux/man-pages/man3/is_selinux_enabled.3.html -->
+  <!-- int is_selinux_enabled(void); -->
+  <function name="is_selinux_enabled">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- int is_selinux_mls_enabled(void); -->
+  <function name="is_selinux_mls_enabled">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/getcon.3.html -->
+  <!-- void freecon(char * con); -->
+  <function name="freecon">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void freeconary(char ** con); -->
+  <function name="freeconary">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int getcon(char ** con); -->
+  <function name="getcon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="1">getcon</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int getcon_raw(char ** con); -->
+  <function name="getcon_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="1">getcon_raw</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int getprevcon(char ** con); -->
+  <function name="getprevcon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="1">getprevcon</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int getprevcon_raw(char ** con); -->
+  <function name="getprevcon_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="1">getprevcon_raw</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int getexeccon(char ** con); -->
+  <function name="getexeccon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="1">getexeccon</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int getexeccon_raw(char ** con); -->
+  <function name="getexeccon_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="1">getexeccon_raw</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int getpidcon(pid_t pid, char ** con); -->
+  <function name="getpidcon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">getpidcon</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int getpidcon_raw(pid_t pid, char ** con); -->
+  <function name="getpidcon_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">getpidcon_raw</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int getpidprevcon(pid_t pid, char ** con); -->
+  <function name="getpidprevcon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">getpidprevcon</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int getpidprevcon_raw(pid_t pid, char ** con); -->
+  <function name="getpidprevcon_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">getpidprevcon_raw</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int setcon(const char * con); -->
+  <function name="setcon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int setcon_raw(const char * con); -->
+  <function name="setcon_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int setexeccon(const char * con); -->
+  <function name="setexeccon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int setexeccon_raw(const char * con); -->
+  <function name="setexeccon_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int setexecfilecon(const char *filename, const char *fallback_type); -->
+  <function name="setexecfilecon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int getfscreatecon(char ** con); -->
+  <function name="getfscreatecon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="1">getfscreatecon</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int getfscreatecon_raw(char ** con); -->
+  <function name="getfscreatecon_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="1">getfscreatecon_raw</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int setfscreatecon(const char * con); -->
+  <function name="setfscreatecon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int setfscreatecon_raw(const char * con); -->
+  <function name="setfscreatecon_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int getkeycreatecon(char ** con); -->
+  <function name="getkeycreatecon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="1">getkeycreatecon</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int getkeycreatecon_raw(char ** con); -->
+  <function name="getkeycreatecon_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="1">getkeycreatecon_raw</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int setkeycreatecon(const char * con); -->
+  <function name="setkeycreatecon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int setkeycreatecon_raw(const char * con); -->
+  <function name="setkeycreatecon_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int getsockcreatecon(char ** con); -->
+  <function name="getsockcreatecon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="1">getsockcreatecon</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int getsockcreatecon_raw(char ** con); -->
+  <function name="getsockcreatecon_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="1">getsockcreatecon_raw</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int setsockcreatecon(const char * con); -->
+  <function name="setsockcreatecon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int setsockcreatecon_raw(const char * con); -->
+  <function name="setsockcreatecon_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int getpeercon(int fd, char ** con); -->
+  <function name="getpeercon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">getpeercon</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int getpeercon_raw(int fd, char ** con); -->
+  <function name="getpeercon_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">getpeercon_raw</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- https://man7.org/linux/man-pages/man3/getfilecon.3.html -->
+  <!-- int getfilecon(const char *path, char ** con); -->
+  <function name="getfilecon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">getfilecon</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int getfilecon_raw(const char *path, char ** con); -->
+  <function name="getfilecon_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">getfilecon_raw</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int lgetfilecon(const char *path, char ** con); -->
+  <function name="lgetfilecon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">lgetfilecon</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int lgetfilecon_raw(const char *path, char ** con); -->
+  <function name="lgetfilecon_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">lgetfilecon_raw</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int fgetfilecon(int fd, char ** con); -->
+  <function name="fgetfilecon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">fgetfilecon</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int fgetfilecon_raw(int fd, char ** con); -->
+  <function name="fgetfilecon_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">fgetfilecon_raw</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- https://man7.org/linux/man-pages/man3/setfilecon.3.html -->
+  <!-- int setfilecon(const char *path, const char * con); -->
+  <function name="setfilecon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int setfilecon_raw(const char *path, const char * con); -->
+  <function name="setfilecon_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int lsetfilecon(const char *path, const char * con); -->
+  <function name="lsetfilecon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int lsetfilecon_raw(const char *path, const char * con); -->
+  <function name="lsetfilecon_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int fsetfilecon(int fd, const char * con); -->
+  <function name="fsetfilecon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int fsetfilecon_raw(int fd, const char * con); -->
+  <function name="fsetfilecon_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- union selinux_callback selinux_get_callback(int type); -->
+  <function name="selinux_get_callback">
+    <returnValue type="union selinux_callback"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:4</valid>
+    </arg>
+  </function>
+  <!-- void selinux_set_callback(int type, union selinux_callback cb); -->
+  <function name="selinux_set_callback">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:4</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/security_compute_av.3.html -->
+  <!-- int security_compute_av(const char * scon, const char * tcon, security_class_t tclass, access_vector_t requested, struct av_decision *avd); -->
+  <function name="security_compute_av">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="out">
+    </arg>
+  </function>
+  <!-- int security_compute_av_raw(const char * scon, const char * tcon, security_class_t tclass, access_vector_t requested, struct av_decision *avd); -->
+  <function name="security_compute_av_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="out">
+    </arg>
+  </function>
+  <!-- int security_compute_av_flags(const char * scon, const char * tcon, security_class_t tclass, access_vector_t requested, struct av_decision *avd); -->
+  <function name="security_compute_av_flags">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="out">
+    </arg>
+  </function>
+  <!-- int security_compute_av_flags_raw(const char * scon, const char * tcon, security_class_t tclass, access_vector_t requested, struct av_decision *avd); -->
+  <function name="security_compute_av_flags_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="out">
+    </arg>
+  </function>
+  <!-- int security_compute_create(const char * scon, const char * tcon, security_class_t tclass, char ** newcon); -->
+  <function name="security_compute_create">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="4">security_compute_create</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int security_compute_create_raw(const char * scon, const char * tcon, security_class_t tclass, char ** newcon); -->
+  <function name="security_compute_create_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="4">security_compute_create_raw</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int security_compute_create_name(const char * scon, const char * tcon, security_class_t tclass, const char *objname, char ** newcon); -->
+  <function name="security_compute_create_name">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="5" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="5">security_compute_create_name</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int security_compute_create_name_raw(const char * scon, const char * tcon, security_class_t tclass, const char *objname, char ** newcon); -->
+  <function name="security_compute_create_name_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="5" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="5">security_compute_create_name_raw</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int security_compute_relabel(const char * scon, const char * tcon, security_class_t tclass, char ** newcon); -->
+  <function name="security_compute_relabel">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="4">security_compute_relabel</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int security_compute_relabel_raw(const char * scon, const char * tcon, security_class_t tclass, char ** newcon); -->
+  <function name="security_compute_relabel_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="4">security_compute_relabel</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int security_compute_member(const char * scon, const char * tcon, security_class_t tclass, char ** newcon); -->
+  <function name="security_compute_member">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="4">security_compute_member</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int security_compute_member_raw(const char * scon, const char * tcon, security_class_t tclass, char ** newcon); -->
+  <function name="security_compute_member_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="4">security_compute_member_raw</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int security_compute_user(const char * scon, const char *username, char *** con); -->
+  <function name="security_compute_user">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="3">security_compute_user</alloc>
+    <dealloc>freeconary</dealloc>
+  </memory>
+  <!-- int security_compute_user_raw(const char * scon, const char *username, char *** con); -->
+  <function name="security_compute_user_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="3">security_compute_user_raw</alloc>
+    <dealloc>freeconary</dealloc>
+  </memory>
+  <!-- int security_validatetrans(const char *scon, const char *tcon, security_class_t tclass, const char *newcon); -->
+  <function name="security_validatetrans">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int security_validatetrans_raw(const char *scon, const char *tcon, security_class_t tclass, const char *newcon); -->
+  <function name="security_validatetrans_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int selinux_check_access(const char * scon, const char * tcon, const char *tclass, const char *perm, void *auditdata); -->
+  <function name="selinux_check_access">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int selinux_check_passwd_access(access_vector_t requested) -->
+  <function name="selinux_check_passwd_access">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int checkPasswdAccess(access_vector_t requested) -->
+  <function name="checkPasswdAccess">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int security_get_initial_context(const char *name, char ** con); -->
+  <function name="security_get_initial_context">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">security_get_initial_context</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int security_get_initial_context_raw(const char *name, char ** con); -->
+  <function name="security_get_initial_context_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">security_get_initial_context_raw</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- https://man7.org/linux/man-pages/man3/security_load_policy.3.html -->
+  <!-- int security_load_policy(const void *data, size_t len); -->
+  <function name="security_load_policy">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <minsize type="argvalue" arg="2"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int selinux_mkload_policy(int preservebools); -->
+  <function name="selinux_mkload_policy">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0,1</valid>
+    </arg>
+  </function>
+  <!-- int selinux_init_load_policy(int *enforce); -->
+  <function name="selinux_init_load_policy">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/security_load_booleans.3.html -->
+  <!-- int security_set_boolean_list(size_t boolcnt, SELboolean * boollist, int permanent); -->
+  <function name="security_set_boolean_list">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <minsize type="argvalue" arg="1"/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0</valid>
+    </arg>
+  </function>
+  <!-- int security_get_boolean_names(char ***names, int *len); -->
+  <function name="security_get_boolean_names">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="1">security_get_boolean_names</alloc>
+    <dealloc>free</dealloc>
+  </memory>
+  <!-- int security_get_boolean_pending(const char *name); -->
+  <function name="security_get_boolean_pending">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int security_get_boolean_active(const char *name); -->
+  <function name="security_get_boolean_active">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int security_set_boolean(const char *name, int value); -->
+  <function name="security_set_boolean">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <valid>0,1</valid>
+    </arg>
+  </function>
+  <!-- int security_commit_booleans(void); -->
+  <function name="security_commit_booleans">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- int security_load_booleans(char *path) -->
+  <function name="security_load_booleans">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/security_check_context.3.html -->
+  <!-- int security_check_context(const char * con); -->
+  <function name="security_check_context">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int security_check_context_raw(const char * con); -->
+  <function name="security_check_context_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int security_canonicalize_context(const char * con, char ** canoncon); -->
+  <function name="security_canonicalize_context">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">security_canonicalize_context</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int security_canonicalize_context_raw(const char * con, char ** canoncon); -->
+  <function name="security_canonicalize_context_raw">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">security_canonicalize_context</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- https://man7.org/linux/man-pages/man3/security_getenforce.3.html -->
+  <!-- int security_getenforce(void); -->
+  <function name="security_getenforce">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- int security_setenforce(int value); -->
+  <function name="security_setenforce">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <valid>0,1</valid>
+    </arg>
+  </function>
+  <!-- int security_reject_unknown(void); -->
+  <function name="security_reject_unknown">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- int security_deny_unknown(void); -->
+  <function name="security_deny_unknown">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- int security_get_checkreqprot(void); -->
+  <function name="security_get_checkreqprot">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/security_disable.3.html -->
+  <!-- int security_disable(void); -->
+  <function name="security_disable">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <warn severity="warning">Disabling SELinux at runtime is deprecated and may not be supported on modern Linux kernels.</warn>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/security_policyvers.3.html -->
+  <!-- int security_policyvers(void); -->
+  <function name="security_policyvers">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/selinux_set_mapping.3.html -->
+  <!-- int selinux_set_mapping(const struct security_class_mapping *map); -->
+  <function name="selinux_set_mapping">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/security_class_to_string.3.html -->
+  <!-- security_class_t mode_to_security_class(mode_t mode); -->
+  <function name="mode_to_security_class">
+    <returnValue type="security_class_t"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- security_class_t string_to_security_class(const char *name); -->
+  <function name="string_to_security_class">
+    <returnValue type="security_class_t"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- const char *security_class_to_string(security_class_t cls); -->
+  <function name="security_class_to_string">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const char *security_av_perm_to_string(security_class_t tclass, access_vector_t perm); -->
+  <function name="security_av_perm_to_string">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- access_vector_t string_to_av_perm(security_class_t tclass, const char *name); -->
+  <function name="string_to_av_perm">
+    <returnValue type="access_vector_t"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int security_av_string(security_class_t tclass, access_vector_t av, char **result); -->
+  <function name="security_av_string">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="3">security_av_string</alloc>
+    <dealloc>free</dealloc>
+  </memory>
+  <!-- void print_access_vector(security_class_t tclass, access_vector_t av); -->
+  <function name="print_access_vector">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void selinux_flush_class_cache(void); -->
+  <function name="selinux_flush_class_cache">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/set_matchpathcon_flags.3.html -->
+  <!-- void set_matchpathcon_printf(void (*f) (const char *fmt, ...)); -->
+  <function name="set_matchpathcon_printf">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void set_matchpathcon_invalidcon(int (*f) (const char *path, unsigned lineno, char *context)); -->
+  <function name="set_matchpathcon_invalidcon">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void set_matchpathcon_flags(unsigned int flags); -->
+  <function name="set_matchpathcon_flags">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:7</valid>
+    </arg>
+  </function>
+  <!-- void set_matchpathcon_canoncon(int (*f) (const char *path, unsigned lineno, char **context)); -->
+  <function name="set_matchpathcon_canoncon">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/matchpathcon.3.html -->
+  <!-- int matchpathcon_init(const char *path) -->
+  <function name="matchpathcon_init">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int matchpathcon_init_prefix(const char *path, const char *prefix); -->
+  <function name="matchpathcon_init_prefix">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- void matchpathcon_fini(void) -->
+  <function name="matchpathcon_fini">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+  </function>
+  <!-- int realpath_not_final(const char *name, char *resolved_path); -->
+  <function name="realpath_not_final">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+      <minsize type="value" value="4097" baseType="char"/>
+    </arg>
+  </function>
+  <!-- int matchpathcon(const char *path, mode_t mode, char ** con) -->
+  <function name="matchpathcon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="3">matchpathcon</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- int matchpathcon_index(const char *path, mode_t mode, char ** con) -->
+  <function name="matchpathcon_index">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="3">matchpathcon_index</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- https://man7.org/linux/man-pages/man3/matchpathcon_checkmatches.3.html -->
+  <!-- int matchpathcon_filespec_add(ino_t ino, int specind, const char *file); -->
+  <function name="matchpathcon_filespec_add">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- void matchpathcon_filespec_destroy(void); -->
+  <function name="matchpathcon_filespec_destroy">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+  </function>
+  <!-- void matchpathcon_filespec_eval(void); -->
+  <function name="matchpathcon_filespec_eval">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+  </function>
+  <!-- void matchpathcon_checkmatches(char *str); -->
+  <function name="matchpathcon_checkmatches">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <!-- unused parameter -->
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/matchmediacon.3.html -->
+  <!-- int matchmediacon(const char *media, char ** con); -->
+  <function name="matchmediacon">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-uninit/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">matchmediacon</alloc>
+    <dealloc>freecon</dealloc>
+  </memory>
+  <!-- https://man7.org/linux/man-pages/man3/selinux_getenforcemode.3.html -->
+  <!-- int selinux_getenforcemode(int *enforce); -->
+  <function name="selinux_getenforcemode">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/selinux_boolean_sub.3.html -->
+  <!-- char *selinux_boolean_sub(const char *boolean_name); -->
+  <function name="selinux_boolean_sub">
+    <returnValue type="char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true">selinux_boolean_sub</alloc>
+    <dealloc>free</dealloc>
+  </memory>
+  <!-- https://man7.org/linux/man-pages/man3/selinux_getpolicytype.3.html -->
+  <!-- int selinux_getpolicytype(char **policytype); -->
+  <function name="selinux_getpolicytype">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="1">selinux_getpolicytype</alloc>
+    <dealloc>free</dealloc>
+  </memory>
+  <!-- https://man7.org/linux/man-pages/man3/selinux_policy_root.3.html -->
+  <!-- const char *selinux_policy_root(void); -->
+  <function name="selinux_policy_root">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- int selinux_set_policy_root(const char *rootpath); -->
+  <function name="selinux_set_policy_root">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/selinux_binary_policy_path.3.html -->
+  <!-- const char *selinux_current_policy_path(void); -->
+  <function name="selinux_current_policy_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_binary_policy_path(void); -->
+  <function name="selinux_binary_policy_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_failsafe_context_path(void); -->
+  <function name="selinux_failsafe_context_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_removable_context_path(void); -->
+  <function name="selinux_removable_context_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_default_context_path(void); -->
+  <function name="selinux_default_context_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_user_contexts_path(void); -->
+  <function name="selinux_user_contexts_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_file_context_path(void); -->
+  <function name="selinux_file_context_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_file_context_homedir_path(void); -->
+  <function name="selinux_file_context_homedir_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_file_context_local_path(void); -->
+  <function name="selinux_file_context_local_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_file_context_subs_path(void); -->
+  <function name="selinux_file_context_subs_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_file_context_subs_dist_path(void); -->
+  <function name="selinux_file_context_subs_dist_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_homedir_context_path(void); -->
+  <function name="selinux_homedir_context_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_media_context_path(void); -->
+  <function name="selinux_media_context_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_virtual_domain_context_path(void); -->
+  <function name="selinux_virtual_domain_context_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_virtual_image_context_path(void); -->
+  <function name="selinux_virtual_image_context_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_lxc_contexts_path(void); -->
+  <function name="selinux_lxc_contexts_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_x_context_path(void); -->
+  <function name="selinux_x_context_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_sepgsql_context_path(void); -->
+  <function name="selinux_sepgsql_context_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_openrc_contexts_path(void); -->
+  <function name="selinux_openrc_contexts_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_openssh_contexts_path(void); -->
+  <function name="selinux_openssh_contexts_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_snapperd_contexts_path(void); -->
+  <function name="selinux_snapperd_contexts_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_systemd_contexts_path(void); -->
+  <function name="selinux_systemd_contexts_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_contexts_path(void); -->
+  <function name="selinux_contexts_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_securetty_types_path(void); -->
+  <function name="selinux_securetty_types_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_booleans_subs_path(void); -->
+  <function name="selinux_booleans_subs_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_booleans_path(void); -->
+  <function name="selinux_booleans_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_customizable_types_path(void); -->
+  <function name="selinux_customizable_types_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_users_path(void); -->
+  <function name="selinux_users_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_usersconf_path(void); -->
+  <function name="selinux_usersconf_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_translations_path(void); -->
+  <function name="selinux_translations_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_colors_path(void); -->
+  <function name="selinux_colors_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_netfilter_context_path(void); -->
+  <function name="selinux_netfilter_context_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- const char *selinux_path(void); -->
+  <function name="selinux_path">
+    <returnValue type="const char *"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/selinux_check_securetty_context.3.html -->
+  <!-- int selinux_check_securetty_context(const char * tty_context); -->
+  <function name="selinux_check_securetty_context">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/init_selinuxmnt.3.html -->
+  <!-- void set_selinuxmnt(const char *mnt); -->
+  <function name="set_selinuxmnt">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- void fini_selinuxmnt(void); -->
+  <function name="fini_selinuxmnt">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+  </function>
+  <!-- int selinuxfs_exists(void); -->
+  <function name="selinuxfs_exists">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/is_context_customizable.3.html -->
+  <!-- int is_context_customizable(const char * scontext); -->
+  <function name="is_context_customizable">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/selinux_raw_context_to_color.3.html -->
+  <!-- int selinux_raw_context_to_color(const char * raw, char **color_str); -->
+  <function name="selinux_raw_context_to_color">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">selinux_raw_context_to_color</alloc>
+    <dealloc>free</dealloc>
+  </memory>
+  <!-- int selinux_trans_to_raw_context(const char * trans, char ** rawp); -->
+  <function name="selinux_trans_to_raw_context">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">selinux_trans_to_raw_context</alloc>
+    <dealloc>free</dealloc>
+  </memory>
+  <!-- int selinux_raw_to_trans_context(const char * raw, char ** transp); -->
+  <function name="selinux_raw_to_trans_context">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">selinux_raw_to_trans_context</alloc>
+    <dealloc>free</dealloc>
+  </memory>
+  <!-- https://man7.org/linux/man-pages/man3/getseuserbyname.3.html -->
+  <!-- int getseuserbyname(const char *linuxuser, char **seuser, char **level); -->
+  <function name="getseuserbyname">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="2">getseuserbyname</alloc>
+    <dealloc>free</dealloc>
+  </memory>
+  <memory>
+    <alloc init="true" arg="3">getseuserbyname</alloc>
+    <dealloc>free</dealloc>
+  </memory>
+  <!-- int getseuser(const char *username, const char *service, char **r_seuser, char **r_level); -->
+  <function name="getseuser">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="4" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <memory>
+    <alloc init="true" arg="3">getseuser</alloc>
+    <dealloc>free</dealloc>
+  </memory>
+  <memory>
+    <alloc init="true" arg="4">getseuser</alloc>
+    <dealloc>free</dealloc>
+  </memory>
+  <!-- https://man7.org/linux/man-pages/man3/selinux_file_context_cmp.3.html -->
+  <!-- int selinux_file_context_cmp(const char * a, const char * b); -->
+  <function name="selinux_file_context_cmp">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/selinux_file_context_verify.3.html -->
+  <!-- int selinux_file_context_verify(const char *path, mode_t mode); -->
+  <function name="selinux_file_context_verify">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- https://man7.org/linux/man-pages/man3/selinux_lsetfilecon_default.3.html -->
+  <!-- int selinux_lsetfilecon_default(const char *path); -->
+  <function name="selinux_lsetfilecon_default">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- void selinux_reset_config(void); -->
+  <function name="selinux_reset_config">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <warn severity="warning">This function is not thread safe. Be very sure that no other threads are calling into libselinux when this is called.</warn>
+  </function>
+</def>
diff --git a/cfg/sqlite3.cfg b/cfg/sqlite3.cfg
index 0b0a439b18c..6c5811f1f75 100644
--- a/cfg/sqlite3.cfg
+++ b/cfg/sqlite3.cfg
@@ -966,6 +966,7 @@
   <!-- https://www.sqlite.org/capi3ref.html#sqlite3_mutex_held -->
   <!-- int sqlite3_mutex_held(sqlite3_mutex*); -->
   <function name="sqlite3_mutex_held">
+    <pure/>
     <noreturn>false</noreturn>
     <returnValue type="int"/>
     <use-retval/>
@@ -988,6 +989,7 @@
   <!-- https://www.sqlite.org/capi3ref.html#sqlite3_mutex_held -->
   <!-- int sqlite3_mutex_notheld(sqlite3_mutex*); -->
   <function name="sqlite3_mutex_notheld">
+    <pure/>
     <noreturn>false</noreturn>
     <returnValue type="int"/>
     <use-retval/>
@@ -1025,6 +1027,48 @@
       <not-bool/>
     </arg>
   </function>
+  <!-- https://www.sqlite.org/capi3ref.html#sqlite3_open -->
+  <!-- int sqlite3_open16(const void *filename,   /* Database filename (UTF-16) */
+                          sqlite3 **ppDb          /* OUT: SQLite db handle */); -->
+  <function name="sqlite3_open16">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- https://www.sqlite.org/capi3ref.html#sqlite3_open -->
+  <!-- int sqlite3_open_v2(const char *filename,   /* Database filename (UTF-8) */
+                           sqlite3 **ppDb,         /* OUT: SQLite db handle */
+                           int flags,              /* Flags */
+                           const char *zVfs        /* Name of VFS module to use */); -->
+  <function name="sqlite3_open_v2">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
   <!-- https://www.sqlite.org/capi3ref.html#sqlite3_prepare -->
   <!-- int sqlite3_prepare(sqlite3 *db,            /* Database handle */
                            const char *zSql,       /* SQL statement, UTF-8 encoded */
diff --git a/cfg/std.cfg b/cfg/std.cfg
index 0f95f26a150..70e9cc17746 100644
--- a/cfg/std.cfg
+++ b/cfg/std.cfg
@@ -1,17 +1,18 @@
 <?xml version="1.0"?>
 <def format="2">
+  <!-- stdint.h -->
   <define name="INT8_MIN" value="-128"/>
   <define name="INT16_MIN" value="-32768"/>
-  <define name="INT32_MIN" value="-2147483648"/>
-  <define name="INT64_MIN" value="-9223372036854775808"/>
+  <define name="INT32_MIN" value="(-2147483647-1)"/>
+  <define name="INT64_MIN" value="(-9223372036854775807-1)"/>
   <define name="INT_FAST8_MIN" value="-128"/>
-  <define name="INT_FAST16_MIN" value="-9223372036854775808"/>
-  <define name="INT_FAST32_MIN" value="-9223372036854775808"/>
-  <define name="INT_FAST64_MIN" value="-9223372036854775808"/>
+  <define name="INT_FAST16_MIN" value="(-9223372036854775807-1)"/>
+  <define name="INT_FAST32_MIN" value="(-9223372036854775807-1)"/>
+  <define name="INT_FAST64_MIN" value="(-9223372036854775807-1)"/>
   <define name="INT_LEAST8_MIN" value="-128"/>
   <define name="INT_LEAST16_MIN" value="-32768"/>
-  <define name="INT_LEAST32_MIN" value="-2147483648"/>
-  <define name="INT_LEAST64_MIN" value="-9223372036854775808"/>
+  <define name="INT_LEAST32_MIN" value="(-2147483647-1)"/>
+  <define name="INT_LEAST64_MIN" value="(-9223372036854775807-1)"/>
   <define name="INT8_MAX" value="127"/>
   <define name="INT16_MAX" value="32767"/>
   <define name="INT32_MAX" value="2147483647"/>
@@ -24,18 +25,19 @@
   <define name="INT_LEAST16_MAX" value="32767"/>
   <define name="INT_LEAST32_MAX" value="2147483647"/>
   <define name="INT_LEAST64_MAX" value="9223372036854775807"/>
-  <define name="UINT8_MAX" value="255"/>
-  <define name="UINT16_MAX" value="65535"/>
-  <define name="UINT32_MAX" value="4294967295"/>
-  <define name="UINT64_MAX" value="18446744073709551615"/>
-  <define name="UINT_FAST8_MAX" value="255"/>
-  <define name="UINT_FAST16_MAX" value="18446744073709551615"/>
-  <define name="UINT_FAST32_MAX" value="18446744073709551615"/>
-  <define name="UINT_FAST64_MAX" value="18446744073709551615"/>
-  <define name="UINT_LEAST8_MAX" value="255"/>
-  <define name="UINT_LEAST16_MAX" value="65535"/>
-  <define name="UINT_LEAST32_MAX" value="4294967295"/>
-  <define name="UINT_LEAST64_MAX" value="18446744073709551615"/>
+  <define name="UINT8_MAX" value="255U"/>
+  <define name="UINT16_MAX" value="65535U"/>
+  <define name="UINT32_MAX" value="4294967295U"/>
+  <define name="UINT64_MAX" value="18446744073709551615U"/>
+  <define name="UINT_FAST8_MAX" value="255U"/>
+  <define name="UINT_FAST16_MAX" value="18446744073709551615U"/>
+  <define name="UINT_FAST32_MAX" value="18446744073709551615U"/>
+  <define name="UINT_FAST64_MAX" value="18446744073709551615U"/>
+  <define name="UINT_LEAST8_MAX" value="255U"/>
+  <define name="UINT_LEAST16_MAX" value="65535U"/>
+  <define name="UINT_LEAST32_MAX" value="4294967295U"/>
+  <define name="UINT_LEAST64_MAX" value="18446744073709551615U"/>
+  <!-- math.h -->
   <define name="M_E" value="2.7182818284590452354"/>
   <define name="M_LOG2E" value="1.4426950408889634074"/>
   <define name="M_LOG10E" value="0.43429448190325182765"/>
@@ -49,12 +51,30 @@
   <define name="M_2_SQRTPI" value="1.12837916709551257390"/>
   <define name="M_SQRT2" value="1.41421356237309504880"/>
   <define name="M_SQRT1_2" value="0.70710678118654752440"/>
+  <define name="_IOFBF" value="0"/>
+  <define name="_IOLBF" value="1"/>
+  <define name="_IONBF" value="2"/>
+  <!-- https://en.cppreference.com/w/cpp/numeric/math/FP_categories -->
+  <define name="FP_NORMAL" value="1"/>
+  <define name="FP_SUBNORMAL" value="2"/>
+  <define name="FP_ZERO" value="3"/>
+  <define name="FP_INFINITE" value="4"/>
+  <define name="FP_NAN" value="5"/>
   <!-- errno_t is a typedef for int -->
   <define name="errno_t" value="int"/>
   <!-- void abort(void); -->
-  <function name="abort,std::abort">
+  <!--              void std::terminate();          (until C++11) -->
+  <!-- [[noreturn]] void std::terminate() noexcept; (since C++11) -->
+  <function name="abort,std::abort,std::terminate">
     <noreturn>true</noreturn>
   </function>
+  <!--              void unexpected(); (until C++11)          -->
+  <!-- [[noreturn]] void unexpected(); (since C++11)          -->
+  <!-- (deprecated)(removed in C++17)                         -->
+  <function name="std::unexpected">
+    <noreturn>true</noreturn>
+    <warn severity="style" alternatives="std::terminate" reason="Obsolete"/>
+  </function>
   <!-- int abs(int j); -->
   <function name="abs,std::abs">
     <use-retval/>
@@ -116,7 +136,7 @@
   <function name="acos,std::acos">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">acos(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -128,7 +148,7 @@
   <function name="acosf,std::acosf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">acos(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -140,7 +160,7 @@
   <function name="acosl,std::acosl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">acos(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -152,33 +172,36 @@
   <function name="acosh,std::acosh">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">acosh(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>1.0:</valid>
     </arg>
   </function>
   <!-- float acoshf(float x); -->
   <function name="acoshf,std::acoshf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">acosh(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>1.0:</valid>
     </arg>
   </function>
   <!-- long double acoshl(long double x); -->
   <function name="acoshl,std::acoshl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">acosh(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>1.0:</valid>
     </arg>
   </function>
   <!-- char *asctime(const struct tm *tm) -->
@@ -225,7 +248,7 @@
   <function name="sqrt,std::sqrt">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">sqrt(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -237,7 +260,7 @@
   <function name="sqrtf,std::sqrtf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">sqrt(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -249,7 +272,7 @@
   <function name="sqrtl,std::sqrtl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">sqrt(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -273,7 +296,7 @@
   <function name="sinh,std::sinh">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">sinh(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -284,7 +307,7 @@
   <function name="sinhf,std::sinhf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">sinh(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -295,7 +318,7 @@
   <function name="sinhl,std::sinhl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">sinh(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -306,7 +329,7 @@
   <function name="sin,std::sin">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">sin(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -317,7 +340,7 @@
   <function name="sinf,std::sinf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">sin(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -328,7 +351,7 @@
   <function name="sinl,std::sinl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">sin(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -363,7 +386,7 @@
   <function name="asin,std::asin">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">asin(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -375,7 +398,7 @@
   <function name="asinf,std::asinf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">asin(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -387,7 +410,7 @@
   <function name="asinl,std::asinl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">asin(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -411,7 +434,7 @@
   <function name="asinh,std::asinh">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">asinh(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -422,7 +445,7 @@
   <function name="asinhf,std::asinhf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">asinh(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -433,7 +456,7 @@
   <function name="asinhl,std::asinhl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">asinh(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -460,14 +483,16 @@
     <leak-ignore/>
     <arg nr="1" direction="out">
       <not-null/>
+      <minsize type="argvalue" arg="2"/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <valid>0:</valid>
     </arg>
     <arg nr="3" direction="in">
       <not-null/>
       <not-uninit/>
-      <valid>0:</valid>
+      <strz/>
     </arg>
     <arg nr="4" direction="in">
       <not-null/>
@@ -478,7 +503,7 @@
   <function name="tan,std::tan">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">tan(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -489,7 +514,7 @@
   <function name="tanf,std::tanf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">tan(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -500,7 +525,7 @@
   <function name="tanl,std::tanl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">tan(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -523,7 +548,7 @@
   <function name="tanh,std::tanh">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">tanh(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -534,7 +559,7 @@
   <function name="tanhf,std::tanhf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">tanh(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -545,7 +570,7 @@
   <function name="tanhl,std::tanhl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">tanh(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -642,6 +667,8 @@
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <!-- Note: flag values (FE_ALL_EXCEPT,FE_DIVBYZERO, etc.) are defined in this file -->
+      <valid>1:31</valid>
     </arg>
   </function>
   <!-- int fesetround(int rdir); -->
@@ -660,6 +687,8 @@
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <!-- Note: flag values (FE_ALL_EXCEPT,FE_DIVBYZERO, etc.) are defined in this file -->
+      <valid>1:31</valid>
     </arg>
   </function>
   <!-- int feupdateenv(const fenv_t* envp); -->
@@ -676,7 +705,7 @@
   <function name="atan,std::atan">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">atan(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -687,7 +716,7 @@
   <function name="atanf,std::atanf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">atan(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -698,7 +727,7 @@
   <function name="atanl,std::atanl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">atan(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -717,44 +746,53 @@
       <not-uninit/>
     </arg>
   </function>
+  <!-- https://en.cppreference.com/w/cpp/numeric/math/tgamma -->
   <!-- double tgamma(double x); -->
   <function name="tgamma,std::tgamma">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">tgamma(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <!-- If x is zero or a negative integer for which the function is asymptotic, it may cause a pole error (depending on implementation).-->
+      <valid>!0.0:</valid>
     </arg>
   </function>
+  <!-- https://en.cppreference.com/w/cpp/numeric/math/tgamma -->
   <!-- float tgammaf(float x); -->
   <function name="tgammaf,std::tgammaf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">tgamma(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <!-- If x is zero or a negative integer for which the function is asymptotic, it may cause a pole error (depending on implementation).-->
+      <valid>!0.0:</valid>
     </arg>
   </function>
+  <!-- https://en.cppreference.com/w/cpp/numeric/math/tgamma -->
   <!-- long double tgammal(long double x); -->
   <function name="tgammal,std::tgammal">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">tgamma(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <!-- If x is zero or a negative integer for which the function is asymptotic, it may cause a pole error (depending on implementation).-->
+      <valid>!0.0:</valid>
     </arg>
   </function>
   <!-- double trunc(double x); -->
   <function name="trunc,std::trunc">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">trunc(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -765,7 +803,7 @@
   <function name="truncf,std::truncf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">trunc(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -776,7 +814,7 @@
   <function name="truncl,std::truncl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">trunc(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -787,33 +825,36 @@
   <function name="atanh,std::atanh">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">atanh(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>-1.0:1.0</valid>
     </arg>
   </function>
   <!-- float atanhf(float x); -->
   <function name="atanhf,std::atanhf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">atanh(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>-1.0:1.0</valid>
     </arg>
   </function>
   <!-- long double atanhl(long double x); -->
   <function name="atanhl,std::atanhl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">atanh(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>-1.0:1.0</valid>
     </arg>
   </function>
   <!-- double complex catanh(double complex x); -->
@@ -832,7 +873,7 @@
   <function name="atan2,std::atan2">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">atan2(arg1, arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -846,7 +887,7 @@
   <function name="atan2f,std::atan2f">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">atan2(arg1, arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -860,7 +901,7 @@
   <function name="atan2l,std::atan2l">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">atan2(arg1, arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -933,13 +974,13 @@
     </arg>
   </function>
   <!-- void * calloc(size_t nitems, size_t size); -->
-  <function name="calloc">
+  <function name="calloc,std::calloc">
     <use-retval/>
     <noreturn>false</noreturn>
     <returnValue type="void *"/>
     <arg nr="1" direction="in">
       <not-uninit/>
-      <valid>1:</valid>
+      <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -950,7 +991,7 @@
   <function name="ceil,std::ceil">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">ceil(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -961,7 +1002,7 @@
   <function name="ceilf,std::ceilf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">ceil(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -972,7 +1013,7 @@
   <function name="ceill,std::ceill">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">ceil(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1042,7 +1083,7 @@
   <function name="cbrt,std::cbrt">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">cbrt(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1053,7 +1094,7 @@
   <function name="cbrtf,std::cbrtf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">cbrt(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1064,7 +1105,7 @@
   <function name="cbrtl,std::cbrtl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">cbrt(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1075,7 +1116,7 @@
   <function name="cos,std::cos">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">cos(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1086,7 +1127,7 @@
   <function name="cosf,std::cosf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">cos(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1097,7 +1138,7 @@
   <function name="cosl,std::cosl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">cos(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1239,11 +1280,13 @@
       <not-uninit/>
     </arg>
   </function>
+  <define name="EXIT_SUCCESS" value="0"/>
+  <define name="EXIT_FAILURE" value="1"/>
   <!-- double erf(double x); -->
   <function name="erf,std::erf">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">erf(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1254,7 +1297,7 @@
   <function name="erff,std::erff">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">erf(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1265,7 +1308,7 @@
   <function name="erfl,std::erfl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">erf(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1276,7 +1319,7 @@
   <function name="erfc,std::erfc">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">erfc(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1287,7 +1330,7 @@
   <function name="erfcf,std::erfcf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">erfc(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1298,7 +1341,7 @@
   <function name="erfcl,std::erfcl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">erfc(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1342,7 +1385,7 @@
   <function name="exp,std::exp">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">exp(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1353,7 +1396,7 @@
   <function name="expf,std::expf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">exp(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1364,7 +1407,7 @@
   <function name="expl,std::expl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">exp(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1399,7 +1442,7 @@
   <function name="exp2,std::exp2">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">exp2(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1410,7 +1453,7 @@
   <function name="exp2f,std::exp2f">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">exp2(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1421,7 +1464,7 @@
   <function name="exp2l,std::exp2l">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">exp2(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1432,7 +1475,7 @@
   <function name="expm1,std::expm1">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">expm1(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1443,7 +1486,7 @@
   <function name="expm1f,std::expm1f">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">expm1(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1454,7 +1497,7 @@
   <function name="expm1l,std::expm1l">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">expm1(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1469,11 +1512,21 @@
       <not-uninit/>
     </arg>
   </function>
+  <!-- int std::at_quick_exit( /*atexit-handler*/* func ) noexcept;-->
+  <function name="std::at_quick_exit,at_quick_exit">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
   <!-- double fabs(double x); -->
   <function name="fabs,std::fabs">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">fabs(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1484,7 +1537,7 @@
   <function name="fabsf,std::fabsf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">fabs(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1495,7 +1548,7 @@
   <function name="fabsl,std::fabsl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">fabs(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1506,7 +1559,7 @@
   <function name="fdim,std::fdim">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">fdim(arg1, arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1520,7 +1573,7 @@
   <function name="fdimf,std::fdimf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">fdim(arg1, arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1534,7 +1587,7 @@
   <function name="fdiml,std::fdiml">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">fdim(arg1, arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1559,7 +1612,7 @@
     <returnValue type="int"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-null/>
       <not-uninit/>
     </arg>
@@ -1570,7 +1623,7 @@
     <returnValue type="int"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-null/>
       <not-uninit/>
     </arg>
@@ -1581,6 +1634,7 @@
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="inout">
+      <!-- If stream is a null pointer, all streams are flushed. -->
       <not-uninit/>
     </arg>
   </function>
@@ -1623,7 +1677,7 @@
   <function name="floor,std::floor">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">floor(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1634,7 +1688,7 @@
   <function name="floorf,std::floorf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">floor(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1645,7 +1699,7 @@
   <function name="floorl,std::floorl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">floor(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1707,7 +1761,7 @@
   <function name="fmax,std::fmax">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">fmax(arg1,arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1721,7 +1775,7 @@
   <function name="fmaxf,std::fmaxf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">fmax(arg1,arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1735,7 +1789,7 @@
   <function name="fmaxl,std::fmaxl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">fmax(arg1,arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1749,7 +1803,7 @@
   <function name="fmin,std::fmin">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">fmin(arg1,arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1763,7 +1817,7 @@
   <function name="fminf,std::fminf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">fmin(arg1,arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1777,7 +1831,7 @@
   <function name="fminl,std::fminl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">fmin(arg1,arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1791,7 +1845,7 @@
   <function name="fmod,std::fmod">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">fmod(arg1,arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1799,13 +1853,14 @@
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <valid>!0.0</valid>
     </arg>
   </function>
   <!-- float fmodf(float x, float y); -->
   <function name="fmodf,std::fmodf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">fmod(arg1,arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1813,13 +1868,14 @@
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <valid>!0.0</valid>
     </arg>
   </function>
   <!-- long double fmodl(long double x, long double y); -->
   <function name="fmodl,std::fmodl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">fmod(arg1,arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -1827,6 +1883,7 @@
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <valid>!0.0</valid>
     </arg>
   </function>
   <!-- FILE * fopen(const char *filename, const char* mode); -->
@@ -1834,7 +1891,8 @@
     <use-retval/>
     <returnValue type="FILE *"/>
     <noreturn>false</noreturn>
-    <arg nr="1" direction="in">
+      <leak-ignore/>
+      <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
       <strz/>
@@ -1842,6 +1900,7 @@
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- errno_t fopen_s(FILE *restrict *restrict streamptr,-->
@@ -1850,6 +1909,7 @@
   <function name="fopen_s">
     <returnValue type="errno_t"/>
     <noreturn>false</noreturn>
+    <leak-ignore/>
     <arg nr="1">
       <not-null/>
     </arg>
@@ -1861,6 +1921,7 @@
     <arg nr="3" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- int fprintf(FILE *stream, const char *format, ...); -->
@@ -1875,7 +1936,9 @@
     <formatstr/>
     <arg nr="2" direction="in">
       <formatstr/>
+      <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- int vfprintf(FILE *stream, const char *format, va_list arg); -->
@@ -1888,10 +1951,12 @@
       <not-uninit/>
     </arg>
     <arg nr="2" direction="in">
+      <not-null/>
       <not-uninit/>
       <formatstr/>
+      <strz/>
     </arg>
-    <arg nr="3"/>
+    <arg nr="3" direction="in"/>
   </function>
   <!-- int vfwprintf(FILE *stream, const wchar_t *format, va_list arg); -->
   <function name="vfwprintf,std::vfwprintf">
@@ -1901,11 +1966,15 @@
     <arg nr="1" direction="inout">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
+      <not-null/>
       <not-uninit/>
+      <formatstr/>
+      <strz/>
     </arg>
-    <arg nr="3"/>
+    <arg nr="3" direction="in"/>
   </function>
   <!-- int fputc(int c, FILE *stream); -->
   <function name="fputc,std::fputc">
@@ -1959,6 +2028,7 @@
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="inout">
       <not-null/>
@@ -2007,6 +2077,7 @@
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="inout">
       <not-null/>
@@ -2023,10 +2094,12 @@
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="4">
       <not-null/>
@@ -2074,7 +2147,7 @@
   <function name="hypot,std::hypot">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">hypot(arg1, arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -2091,7 +2164,7 @@
   <function name="hypotf,std::hypotf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">hypot(arg1, arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -2105,7 +2178,7 @@
   <function name="hypotl,std::hypotl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">hypot(arg1, arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -2127,6 +2200,7 @@
     <arg nr="2" direction="in">
       <formatstr/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- int vfscanf(FILE *stream, const char * format, va_list arg); -->
@@ -2139,6 +2213,7 @@
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3"/>
   </function>
@@ -2153,6 +2228,7 @@
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3"/>
   </function>
@@ -2170,6 +2246,8 @@
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:2</valid>
     </arg>
   </function>
   <!-- int fsetpos(FILE *stream, const fpos_t *ptr); -->
@@ -2240,7 +2318,7 @@
     <returnValue type="int"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-null/>
       <not-uninit/>
     </arg>
@@ -2278,6 +2356,7 @@
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -2347,10 +2426,13 @@
     <returnValue type="size_t"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="out"/>
+    <arg nr="1" direction="out">
+      <not-uninit/>
+    </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -2362,7 +2444,9 @@
     <returnValue type="size_t"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="out"/>
+    <arg nr="1" direction="out">
+      <not-uninit indirect="1"/>
+    </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
@@ -2407,6 +2491,7 @@
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -2505,6 +2590,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:255</valid>
     </arg>
   </function>
@@ -2517,6 +2603,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- int isalpha(int c); -->
@@ -2528,6 +2615,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:255</valid>
     </arg>
   </function>
@@ -2540,6 +2628,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- int isblank(int c); -->
@@ -2551,6 +2640,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:255</valid>
     </arg>
   </function>
@@ -2563,6 +2653,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- int iscntrl(int c); -->
@@ -2574,6 +2665,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:255</valid>
     </arg>
   </function>
@@ -2586,6 +2678,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- int iswctype( wint_t wc, wctype_t desc ); -->
@@ -2611,6 +2704,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:255</valid>
     </arg>
   </function>
@@ -2623,6 +2717,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- int isgraph(int c); -->
@@ -2633,6 +2728,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
+      <not-bool/>
       <not-uninit/>
       <valid>0:255</valid>
     </arg>
@@ -2646,6 +2742,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- int islower(int c); -->
@@ -2657,6 +2754,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:255</valid>
     </arg>
   </function>
@@ -2669,6 +2767,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- int isprint(int c); -->
@@ -2680,6 +2779,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:255</valid>
     </arg>
   </function>
@@ -2692,6 +2792,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- int ispunct(int c); -->
@@ -2703,6 +2804,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:255</valid>
     </arg>
   </function>
@@ -2715,6 +2817,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- int isspace(int c); -->
@@ -2726,6 +2829,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:255</valid>
     </arg>
   </function>
@@ -2738,6 +2842,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- int isupper(int c); -->
@@ -2749,6 +2854,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:255</valid>
     </arg>
   </function>
@@ -2761,6 +2867,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- int isxdigit(int c); -->
@@ -2772,6 +2879,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:255</valid>
     </arg>
   </function>
@@ -2784,6 +2892,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- wint_t towctrans(wint_t c, wctrans_t desc); -->
@@ -2804,7 +2913,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="towlower,std::towlower">
     <use-retval/>
     <pure/>
-    <returnValue type="wint_t"/>
+    <returnValue type="wint_t">arg1 &lt; 'A' || arg1 &gt; 'Z' ? arg1 : arg1 + 32</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -2815,7 +2924,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="towupper,std::towupper">
     <use-retval/>
     <pure/>
-    <returnValue type="wint_t"/>
+    <returnValue type="wint_t">arg1 &lt; 'a' || arg1 &gt; 'z' ? arg1 : arg1 - 32</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -2908,7 +3017,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="ldexp,std::ldexp">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">ldexp(arg1,arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -2922,7 +3031,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="ldexpf,std::ldexpf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">ldexp(arg1,arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -2936,7 +3045,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="ldexpl,std::ldexpl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">ldexp(arg1,arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -2946,37 +3055,46 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <not-uninit/>
     </arg>
   </function>
+  <!-- https://cplusplus.com/reference/cmath/lgamma/ -->
   <!-- double lgamma(double x); -->
   <function name="lgamma,std::lgamma">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">lgamma(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <!-- If x is zero or a negative integer for which the function is asymptotic, it may cause a pole error (depending on implementation).-->
+      <valid>!0.0:</valid>
     </arg>
   </function>
+  <!-- https://cplusplus.com/reference/cmath/lgamma/ -->
   <!-- float lgammaf(float x); -->
   <function name="lgammaf,std::lgammaf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">lgamma(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <!-- If x is zero or a negative integer for which the function is asymptotic, it may cause a pole error (depending on implementation).-->
+      <valid>!0.0:</valid>
     </arg>
   </function>
+  <!-- https://cplusplus.com/reference/cmath/lgamma/ -->
   <!-- long double lgammal(long double x); -->
   <function name="lgammal,std::lgammal">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">lgamma(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <!-- If x is zero or a negative integer for which the function is asymptotic, it may cause a pole error (depending on implementation).-->
+      <valid>!0.0:</valid>
     </arg>
   </function>
   <!-- double rint(double x); -->
@@ -3065,7 +3183,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- int rand(void); -->
-  <function name="rand">
+  <function name="rand,std::rand">
     <use-retval/>
     <returnValue type="int" unknownValues="all"/>
     <noreturn>false</noreturn>
@@ -3111,6 +3229,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   </function>
   <!-- struct tm * localtime(const time_t *tp); -->
   <function name="localtime,std::localtime">
+    <use-retval/>
     <returnValue type="struct tm *"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
@@ -3126,6 +3245,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-null/>
+      <not-uninit/>
     </arg>
     <arg nr="2" direction="out">
       <not-null/>
@@ -3134,31 +3254,34 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <!-- double log(double x); -->
   <function name="log,std::log">
     <use-retval/>
-    <returnValue type="double"/>
+    <returnValue type="double">log(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>4.94066e-324:</valid>
     </arg>
   </function>
   <!-- float logf(float x); -->
   <function name="logf,std::logf">
     <use-retval/>
-    <returnValue type="float"/>
+    <returnValue type="float">log(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>1.4013e-45:</valid>
     </arg>
   </function>
   <!-- long double logl(long double x);-->
   <function name="logl,std::logl">
     <use-retval/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">log(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>4.94066e-324:</valid>
     </arg>
   </function>
   <!-- double complex clog(double complex x); -->
@@ -3195,11 +3318,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- int isfinite(double x); -->
-  <!-- bool isfinite(float x); // since C++11 -->
-  <!-- bool isfinite(double x); // since C++11 -->
-  <!-- bool isfinite(long double x); // since C++11 -->
-  <!-- bool isfinite(Integral x); // since C++11 -->
-  <function name="isfinite,std::isfinite">
+  <function name="isfinite">
     <use-retval/>
     <pure/>
     <returnValue type="int"/>
@@ -3210,8 +3329,23 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <not-bool/>
     </arg>
   </function>
+  <!-- bool std::isfinite(float x); // since C++11 -->
+  <!-- bool std::isfinite(double x); // since C++11 -->
+  <!-- bool std::isfinite(long double x); // since C++11 -->
+  <!-- bool std::isfinite(Integral x); // since C++11 -->
+  <function name="std::isfinite">
+    <use-retval/>
+    <pure/>
+    <returnValue type="bool"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
   <!-- int isgreater(double x, double y); -->
-  <function name="isgreater,std::isgreater">
+  <function name="isgreater">
     <use-retval/>
     <pure/>
     <returnValue type="int">arg1&gt;arg2?1:0</returnValue>
@@ -3224,8 +3358,22 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <not-uninit/>
     </arg>
   </function>
+  <!-- bool std::isgreater(double x, double y); -->
+  <function name="std::isgreater">
+    <use-retval/>
+    <pure/>
+    <returnValue type="bool">arg1&gt;arg2?1:0</returnValue>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- int isgreaterequal(double x, double y); -->
-  <function name="isgreaterequal,std::isgreaterequal">
+  <function name="isgreaterequal">
     <use-retval/>
     <pure/>
     <returnValue type="int">arg1 &gt;= arg2?1:0</returnValue>
@@ -3238,12 +3386,22 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <not-uninit/>
     </arg>
   </function>
+  <!-- bool std::isgreaterequal(double x, double y); -->
+  <function name="std::isgreaterequal">
+    <use-retval/>
+    <pure/>
+    <returnValue type="bool">arg1 &gt;= arg2?1:0</returnValue>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- int isinf(double x); -->
-  <!-- bool isinf(float x); // since C++11 -->
-  <!-- bool isinf(double x); // since C++11 -->
-  <!-- bool isinf(long double x); // since C++11 -->
-  <!-- bool isinf(Integral x); // since C++11 -->
-  <function name="isinf,std::isinf">
+  <function name="isinf">
     <use-retval/>
     <pure/>
     <returnValue type="int"/>
@@ -3254,11 +3412,26 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <not-bool/>
     </arg>
   </function>
+  <!-- bool std::isinf(float x); // since C++11 -->
+  <!-- bool std::isinf(double x); // since C++11 -->
+  <!-- bool std::isinf(long double x); // since C++11 -->
+  <!-- bool std::isinf(Integral x); // since C++11 -->
+  <function name="std::isinf">
+    <use-retval/>
+    <pure/>
+    <returnValue type="bool"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
   <!-- double logb(double x); -->
   <function name="logb,std::logb">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">logb(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -3269,7 +3442,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="logbf,std::logbf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">logb(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -3280,7 +3453,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="logbl,std::logbl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">logb(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -3340,6 +3513,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- float nanf(const char *tagp); -->
@@ -3352,6 +3526,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- long double nanl(const char *tagp); -->
@@ -3364,6 +3539,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- int isnan(double x); -->
@@ -3422,7 +3598,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="ilogb,std::ilogb">
     <use-retval/>
     <pure/>
-    <returnValue type="int"/>
+    <returnValue type="int">ilogb(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -3433,7 +3609,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="ilogbf,std::ilogbf">
     <use-retval/>
     <pure/>
-    <returnValue type="int"/>
+    <returnValue type="int">ilogb(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -3444,7 +3620,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="ilogbl,std::ilogbl">
     <use-retval/>
     <pure/>
-    <returnValue type="int"/>
+    <returnValue type="int">ilogb(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -3455,40 +3631,43 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="log10,std::log10">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">log10(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>4.94066e-324:</valid>
     </arg>
   </function>
   <!-- float log10f(float x);-->
   <function name="log10f,std::log10f">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">log10(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>1.4013e-45:</valid>
     </arg>
   </function>
   <!-- long double log10l(long double x); -->
   <function name="log10l,std::log10l">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">log10(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>4.94066e-324:</valid>
     </arg>
   </function>
   <!-- double log1p(double x); -->
   <function name="log1p,std::log1p">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">log1p(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -3499,7 +3678,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="log1pf,std::log1pf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">log1p(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -3510,7 +3689,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="log1pl,std::log1pl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">log1p(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -3521,40 +3700,43 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="log2,std::log2">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">log2(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>4.94066e-324:</valid>
     </arg>
   </function>
   <!-- float log2f(float x); -->
   <function name="log2f,std::log2f">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">log2(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>1.4013e-45:</valid>
     </arg>
   </function>
   <!-- long double log2l(long double x); -->
   <function name="log2l,std::log2l">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">log2(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>4.94066e-324:</valid>
     </arg>
   </function>
   <!-- double nearbyint(double x); -->
   <function name="nearbyint,std::nearbyint">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">nearbyint(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -3565,7 +3747,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="nearbyintf,std::nearbyintf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">nearbyint(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -3576,7 +3758,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="nearbyintl,std::nearbyintl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">nearbyint(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -3587,7 +3769,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="nextafter,std::nextafter">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">nextafter(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -3601,7 +3783,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="nextafterf,std::nextafterf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">nextafter(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -3615,7 +3797,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="nextafterl,std::nextafterl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">nextafter(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -3629,7 +3811,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="nexttoward,std::nexttoward">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">nexttoward(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -3643,7 +3825,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="nexttowardf,std::nexttowardf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">nexttoward(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -3657,7 +3839,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="nexttowardl,std::nexttowardl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">nexttoward(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -3712,15 +3894,15 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <valid>0:</valid>
     </arg>
   </function>
-  <!-- const void * memchr ( const void * ptr, int value, size_t num );-->
-  <!-- void * memchr (       void * ptr, int value, size_t num );-->
+  <!-- const void * memchr ( const void * ptr, int value, size_t num ); -->
+  <!--       void * memchr (       void * ptr, int value, size_t num ); -->
   <function name="memchr,std::memchr">
     <use-retval/>
     <pure/>
     <returnValue type="void *"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-null/>
       <not-uninit/>
       <minsize type="argvalue" arg="3"/>
@@ -3743,7 +3925,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <returnValue type="wchar_t *"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-null/>
       <not-uninit/>
       <minsize type="argvalue" arg="3"/>
@@ -3806,10 +3988,11 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- void * memcpy(void *ct, const void *cs, size_t n);-->
-  <!-- wchar_t * wmemcpy(wchar_t *ct, const wchar_t *cs, size_t n);-->
-  <function name="memcpy,std::memcpy,wmemcpy,std::wmemcpy">
+  <function name="memcpy,std::memcpy">
+    <returnValue type="void *"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="3"/>
     <arg nr="1" direction="out">
       <not-null/>
       <minsize type="argvalue" arg="3"/>
@@ -3825,7 +4008,28 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <valid>0:</valid>
     </arg>
   </function>
-  <!-- errno_t  memcpy_s( void *restrict dest, rsize_t destsz, const void *restrict src, rsize_t count );-->
+  <!-- wchar_t* wmemcpy( wchar_t* dest, const wchar_t* src, std::size_t count ); -->
+  <function name="wmemcpy,std::wmemcpy">
+    <returnValue type="wchar_t *"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" count-arg="3"/>
+    <arg nr="1" direction="out">
+      <not-null/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- errno_t  memcpy_s( void *restrict dest, rsize_t destsz, const void *restrict src, rsize_t count );-->
   <!-- errno_t wmemcpy_s( wchar_t *restrict dest, rsize_t destsz, const wchar_t *restrict src, rsize_t count );-->
   <function name="memcpy_s,wmemcpy_s">
     <returnValue type="errno_t"/>
@@ -3850,9 +4054,30 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- void * memmove(void *ct, const void *cs, size_t n); -->
+  <function name="memmove,std::memmove">
+    <noreturn>false</noreturn>
+    <returnValue type="void *"/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="2">
+      <!-- TODO: direction? memory could be overwritten -->
+      <not-null/>
+      <not-uninit/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
   <!-- wchar_t * wmemmove(wchar_t *ct, const wchar_t *cs, size_t n); -->
-  <function name="memmove,std::memmove,wmemmove,std::wmemmove">
+  <function name="wmemmove,std::wmemmove">
     <noreturn>false</noreturn>
+    <returnValue type="wchar_t *"/>
     <leak-ignore/>
     <arg nr="1" direction="out">
       <not-null/>
@@ -3928,8 +4153,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- time_t mktime(struct tm *tp); -->
-  <!-- time_t mkxtime(struct tmx *tp); -->
-  <function name="mktime,std::mktime,mkxtime">
+  <function name="mktime,std::mktime">
     <returnValue type="time_t"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
@@ -3981,13 +4205,14 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- double pow(double x, double y); -->
   <function name="pow,std::pow">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">pow(arg1, arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -4001,7 +4226,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="powf,std::powf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">pow(arg1, arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -4015,7 +4240,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="powl,std::powl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">pow(arg1, arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -4040,11 +4265,12 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <not-uninit/>
     </arg>
   </function>
-  <!-- double remainder(double x, double y); -->
-  <function name="remainder,std::remainder">
+  <!-- float  remquo (float x , float y , int *quo); -->
+  <!-- double remquo (double x, double y, int *quo); -->
+  <!-- long double remquo (long double x, long double y, int *quo); -->
+  <function name="remquo,std::remquo">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -4052,10 +4278,14 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <valid>!0.0</valid>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
     </arg>
   </function>
-  <!-- float remainderf(float x, float y); -->
-  <function name="remainderf,std::remainderf">
+  <!-- float  remquof (float x , float y , int *quo); -->
+  <function name="remquof,std::remquof">
     <use-retval/>
     <pure/>
     <returnValue type="float"/>
@@ -4066,10 +4296,14 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <valid>!0.0</valid>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
     </arg>
   </function>
-  <!-- long double remainderl(long double x, long double y); -->
-  <function name="remainderl,std::remainderl">
+  <!-- long double  remquol (long double x , long double y , int *quo); -->
+  <function name="remquol,std::remquol">
     <use-retval/>
     <pure/>
     <returnValue type="long double"/>
@@ -4080,13 +4314,17 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <valid>!0.0</valid>
+    </arg>
+    <arg nr="3" direction="out">
+      <not-null/>
     </arg>
   </function>
-  <!-- double remquo(double, x, double y, int *quo); -->
-  <function name="remquo,std::remquo">
+  <!-- double remainder(double x, double y); -->
+  <function name="remainder,std::remainder">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">remainder(arg1,arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -4094,16 +4332,14 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
-    </arg>
-    <arg nr="3" direction="out">
-      <not-null/>
+      <valid>!0.0</valid>
     </arg>
   </function>
-  <!-- float remquof(float x, float y, int *quo); -->
-  <function name="remquof,std::remquof">
+  <!-- float remainderf(float x, float y); -->
+  <function name="remainderf,std::remainderf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">remainder(arg1,arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -4111,16 +4347,14 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
-    </arg>
-    <arg nr="3" direction="out">
-      <not-null/>
+      <valid>!0.0</valid>
     </arg>
   </function>
-  <!-- long double remquol(long double x, long double y, int *quo); -->
-  <function name="remquol,std::remquol">
+  <!-- long double remainderl(long double x, long double y); -->
+  <function name="remainderl,std::remainderl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">remainder(arg1,arg2)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -4128,9 +4362,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
-    </arg>
-    <arg nr="3" direction="out">
-      <not-null/>
+      <valid>!0.0</valid>
     </arg>
   </function>
   <!-- int printf(const char *format, ...); -->
@@ -4142,6 +4374,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <formatstr/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- int vprintf(const char *format, va_list arg); -->
@@ -4152,6 +4385,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-uninit/>
       <formatstr/>
+      <strz/>
     </arg>
     <arg nr="2"/>
   </function>
@@ -4162,10 +4396,44 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2"/>
   </function>
-  <!-- void* bsearch(const void* key, const void* base, size_t num, size_t size, int(*compar)(const void*,const void*));-->
+  <!-- void* bsearch_s( const void *key, const void *ptr , rsize_t count, rsize_t size, int (*comp)(const void *, const void *, void *), void *context ); since C11-->
+  <function name="bsearch_s">
+    <use-retval/>
+    <pure/>
+    <returnValue type="void *"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void* bsearch  ( const void* key, const void* base   , size_t num,  size_t size, int(*compar)(const void*,const void*));-->
   <function name="bsearch,std::bsearch">
     <use-retval/>
     <pure/>
@@ -4179,6 +4447,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <minsize type="argvalue" arg="3"/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -4201,6 +4470,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="inout">
       <not-null/>
       <not-uninit/>
+      <minsize type="argvalue" arg="2"/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -4210,9 +4480,10 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <not-uninit/>
       <valid>0:</valid>
     </arg>
-    <arg nr="4" direction="in">
+    <arg nr="4">
       <not-null/>
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- int putc(int c, FILE *stream); -->
@@ -4310,23 +4581,6 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <valid>0:</valid>
     </arg>
   </function>
-  <!-- void *reallocarray(void *ptr, size_t nmemb, size_t size); -->
-  <function name="reallocarray,std::reallocarray">
-    <returnValue type="void *"/>
-    <use-retval/>
-    <noreturn>false</noreturn>
-    <arg nr="1">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
-      <valid>0:</valid>
-    </arg>
-    <arg nr="3" direction="in">
-      <not-uninit/>
-      <valid>0:</valid>
-    </arg>
-  </function>
   <!-- int remove(const char *filename); -->
   <function name="remove,std::remove">
     <returnValue type="int"/>
@@ -4368,7 +4622,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="round,std::round">
     <use-retval/>
     <pure/>
-    <returnValue type="double"/>
+    <returnValue type="double">round(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -4379,7 +4633,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="roundf,std::roundf">
     <use-retval/>
     <pure/>
-    <returnValue type="float"/>
+    <returnValue type="float">round(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -4390,7 +4644,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="roundl,std::roundl">
     <use-retval/>
     <pure/>
-    <returnValue type="long double"/>
+    <returnValue type="long double">round(arg1)</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -4438,7 +4692,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <!-- int raise(int sig); -->
   <function name="raise,std::raise">
     <returnValue type="int"/>
-    <noreturn>false</noreturn>
+    <noreturn>maybe</noreturn>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
@@ -4453,6 +4707,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <formatstr/>
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- int vsscanf(const char *s, const char *format, va_list arg); -->
@@ -4463,10 +4718,12 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3"/>
   </function>
@@ -4478,10 +4735,12 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3"/>
   </function>
@@ -4493,6 +4752,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2"/>
   </function>
@@ -4503,6 +4763,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-null/>
+      <strz/>
     </arg>
     <arg nr="2"/>
   </function>
@@ -4530,9 +4791,12 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
     <arg nr="2">
       <not-uninit/>
+      <minsize type="argvalue" arg="4"/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <!-- Note: _IOFBF=0, _IOLBF=1 and _IONBF=2  has been set to in this configuration-->
+      <valid>0:2</valid>
     </arg>
     <arg nr="4" direction="in">
       <not-uninit/>
@@ -4551,10 +4815,12 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <returnValue type="char *"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" strlen-arg="2"/>
     <arg nr="1" direction="inout">
       <not-null/>
       <not-uninit/>
       <strz/>
+      <minsize type="strlen" arg="2"/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
@@ -4562,17 +4828,19 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <strz/>
     </arg>
   </function>
-  <!-- wchar_t wcscat(wchar_t *deststr, const char *srcstr); -->
+  <!-- wchar_t wcscat(wchar_t *deststr, const wchar_t *srcstr); -->
   <function name="wcscat,std::wcscat">
     <returnValue type="wchar_t"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" strlen-arg="2"/>
     <arg nr="1" direction="inout">
       <not-null/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- size_t wcrtomb(char *s, wchar_t wc, mbstate_t *ps); -->
@@ -4588,6 +4856,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   </function>
   <!-- char * strchr(const char *cs, int c); -->
   <function name="strchr,std::strchr">
+    <pure/>
     <use-retval/>
     <returnValue type="char *"/>
     <noreturn>false</noreturn>
@@ -4602,7 +4871,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <valid>0:255</valid>
     </arg>
   </function>
-  <!-- wchar_t wcschr(const wchar_t *cs, wchar_t c); -->
+  <!-- wchar_t* wcschr(const wchar_t *cs, wchar_t c); -->
   <function name="wcschr,std::wcschr">
     <use-retval/>
     <returnValue type="wchar_t"/>
@@ -4611,13 +4880,15 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
     </arg>
   </function>
   <!-- int strcmp(const char *str1, const char *str2); -->
-  <function name="strcmp,std::strcmp">
+  <!-- int wcscmp(const wchar_t *str1, const wchar_t *str2) -->
+  <function name="strcmp,std::strcmp,wcscmp,std::wcscmp">
     <use-retval/>
     <pure/>
     <returnValue type="int"/>
@@ -4634,26 +4905,11 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <strz/>
     </arg>
   </function>
-  <!-- int wcscmp(const wchar_t *str1, const wchar_t c); -->
-  <function name="wcscmp,std::wcscmp">
-    <use-retval/>
-    <pure/>
-    <returnValue type="int"/>
-    <noreturn>false</noreturn>
-    <leak-ignore/>
-    <arg nr="1" direction="in">
-      <not-null/>
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in">
-      <not-null/>
-      <not-uninit/>
-    </arg>
-  </function>
   <!-- char *strcpy(char *desstr, const char *srcstr); -->
   <function name="strcpy,std::strcpy">
-    <returnValue type="char *"/>
+    <returnValue type="char *">arg1</returnValue>
     <noreturn>false</noreturn>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" strlen-arg="2"/>
     <leak-ignore/>
     <arg nr="1" direction="out">
       <not-null/>
@@ -4689,22 +4945,24 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <returnValue type="wchar_t *"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" strlen-arg="2"/>
     <arg nr="1" direction="out">
       <not-null/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- size_t strftime(char *s, size_t max, const char *fmt, const struct tm *p); -->
-  <!-- size_t strfxtime(char *s, size_t max, const char *fmt, const struct tmx *p); -->
-  <function name="strftime,std::strftime,strfxtime">
+  <function name="strftime,std::strftime">
     <returnValue type="size_t"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="out">
       <not-null/>
+      <minsize type="argvalue" arg="2"/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -4713,6 +4971,8 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="3" direction="in">
       <not-null/>
       <not-uninit/>
+      <formatstr/>
+      <strz/>
     </arg>
     <arg nr="4" direction="in">
       <not-null/>
@@ -4735,9 +4995,10 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   </function>
   <!-- char *strncpy(char *s, const char *ct, size_t n); -->
   <function name="strncpy,std::strncpy">
-    <returnValue type="char *"/>
+    <returnValue type="char *">arg1</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="3"/>
     <arg nr="1" direction="out">
       <not-null/>
       <minsize type="argvalue" arg="3"/>
@@ -4770,6 +5031,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <not-null/>
       <not-uninit/>
       <minsize type="argvalue" arg="4"/>
+      <strz/>
     </arg>
     <arg nr="4" direction="in">
       <not-uninit/>
@@ -4785,10 +5047,12 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- char * strncat(char *ct, const char *s, size_t n); -->
@@ -4796,6 +5060,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <returnValue type="char *"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="3"/>
     <arg nr="1" direction="inout">
       <not-null/>
       <not-uninit/>
@@ -4831,6 +5096,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="3" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- errno_t strncat_s(char *restrict dest, rsize_t destsz, const char *restrict src, rsize_t count); // since C11 -->
@@ -4851,6 +5117,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <not-null/>
       <not-uninit/>
       <minsize type="argvalue" arg="4"/>
+      <strz/>
     </arg>
     <arg nr="4" direction="in">
       <not-uninit/>
@@ -4861,6 +5128,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <noreturn>false</noreturn>
     <returnValue type="wchar_t *"/>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" count-arg="3"/>
     <arg nr="1" direction="inout">
       <not-null/>
       <not-uninit/>
@@ -4878,28 +5146,8 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- int strncmp(const char *s1, const char *s2, size_t n); -->
-  <function name="strncmp,std::strncmp">
-    <use-retval/>
-    <pure/>
-    <returnValue type="int"/>
-    <noreturn>false</noreturn>
-    <leak-ignore/>
-    <arg nr="1" direction="in">
-      <not-null/>
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in">
-      <not-null/>
-      <not-uninit/>
-    </arg>
-    <arg nr="3" direction="in">
-      <not-uninit/>
-      <not-bool/>
-      <valid>0:</valid>
-    </arg>
-  </function>
   <!-- int wcsncmp(const wchar_t* wcs1, const wchar_t* wcs2, size_t num); -->
-  <function name="wcsncmp,std::wcsncmp">
+  <function name="strncmp,std::strncmp,wcsncmp,std::wcsncmp">
     <use-retval/>
     <pure/>
     <returnValue type="int"/>
@@ -4921,11 +5169,12 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   </function>
   <!-- char* strstr(const char *s1, const char *s2); -->
   <function name="strstr,std::strstr">
+    <pure/>
     <use-retval/>
     <returnValue type="char *"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-null/>
       <not-uninit/>
       <strz/>
@@ -4943,13 +5192,15 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <returnValue type="wchar_t *"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- size_t strspn(const char *cs, const char *ct); -->
@@ -4975,10 +5226,14 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <noreturn>false</noreturn>
     <leak-ignore/>
     <!-- In case the 3rd argument is 0, the 1st argument is permitted to be a null pointer. (#6306) -->
-    <arg nr="1" direction="out"/>
+    <arg nr="1" direction="out">
+      <minsize type="argvalue" arg="3"/>
+    </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
+      <minsize type="argvalue" arg="3"/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -4990,11 +5245,13 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <returnValue type="size_t"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="3"/>
     <!-- In case the 3rd argument is 0, the 1st argument is permitted to be a null pointer. (#6306) -->
     <arg nr="1" direction="out"/>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
@@ -5011,10 +5268,12 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- struct lconv* localeconv(void); -->
@@ -5071,10 +5330,12 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- size_t wcscspn(const wchar_t *cs, const wchar_t *ct); -->
@@ -5087,10 +5348,12 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- wchar_t * wcspbrk(const wchar_t *ct, wchar_t *c); -->
@@ -5102,6 +5365,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -5112,9 +5376,10 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <returnValue type="wchar_t *"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" count-arg="3"/>
     <arg nr="1">
       <not-null/>
-      <minsize type="argvalue" arg="3"/>
+      <minsize type="argvalue" arg="3" baseType="wchar_t"/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
@@ -5135,10 +5400,12 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- int wcscoll(const wchar_t *s1, const wchar_t *s2); -->
@@ -5150,15 +5417,18 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- const char * strrchr(const char * str, int character);-->
   <!-- char * strrchr(char * str, int character); -->
   <function name="strrchr,std::strrchr">
+    <pure/>
     <use-retval/>
     <returnValue type="char *"/>
     <noreturn>false</noreturn>
@@ -5174,15 +5444,16 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- const wchar_t* wcsrchr(const wchar_t* ws, wchar_t wc);-->
-  <!-- wchar_t* wcsrchr(wchar_t* ws, wchar_t wc); -->
+  <!--       wchar_t* wcsrchr(wchar_t* ws, wchar_t wc); -->
   <function name="wcsrchr,std::wcsrchr">
     <use-retval/>
     <returnValue type="wchar_t *"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -5193,7 +5464,9 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <returnValue type="size_t"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="out"/>
+    <arg nr="1" direction="out">
+      <minsize type="argvalue" arg="3"/>
+    </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
@@ -5217,6 +5490,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- float strtof(const char *s, char **endp); -->
@@ -5396,25 +5670,35 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <returnValue type="FILE *"/>
     <noreturn>false</noreturn>
   </function>
+  <!-- FILE *std::tmpfile(void); -->
+  <!-- https://en.cppreference.com/w/cpp/io/c/tmpfile -->
+  <function name="std::tmpfile">
+    <use-retval/>
+    <returnValue type="std::FILE *"/>
+    <noreturn>false</noreturn>
+  </function>
   <!-- int tolower(int c); -->
   <function name="tolower,std::tolower">
+    <pure/>
     <use-retval/>
-    <returnValue type="int"/>
+    <returnValue type="int">arg1 &lt; 'A' || arg1 &gt; 'Z' ? arg1 : arg1 + 32</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:255</valid>
     </arg>
   </function>
   <!-- int toupper(int c); -->
   <function name="toupper,std::toupper">
     <use-retval/>
-    <returnValue type="int"/>
+    <returnValue type="int">arg1 &lt; 'a' || arg1 &gt; 'z' ? arg1 : arg1 - 32</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>0:255</valid>
     </arg>
   </function>
@@ -5460,6 +5744,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="out"/>
   </function>
@@ -5472,6 +5757,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="out"/>
   </function>
@@ -5484,6 +5770,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="out"/>
   </function>
@@ -5700,6 +5987,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="inout">
       <not-null/>
@@ -5714,6 +6002,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="out"/>
     <arg nr="3" direction="in">
@@ -5730,6 +6019,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="out"/>
     <arg nr="3" direction="in">
@@ -5746,6 +6036,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="out"/>
     <arg nr="3" direction="in">
@@ -5762,6 +6053,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="out"/>
     <arg nr="3" direction="in">
@@ -5778,6 +6070,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="out"/>
     <arg nr="3" direction="in">
@@ -5794,6 +6087,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="out"/>
     <arg nr="3" direction="in">
@@ -5811,6 +6105,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <formatstr/>
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- int sprintf(char *s, const char *format, ...); -->
@@ -5827,6 +6122,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <formatstr/>
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- int sprintf_s(char *restrict buffer, rsize_t bufsz, const char *restrict format, ...); // since C11 // TODO: conflicts with the Windows functions where it is overloaded for C++ also -->
@@ -5863,6 +6159,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="2" direction="in">
       <not-uninit/>
       <valid>0:</valid>
+      <strz/>
     </arg>
     <arg nr="3" direction="in">
       <!-- Due to different swprintf definitions "<formatstr/>" can not be used here. See https://trac.cppcheck.net/ticket/4790 -->
@@ -5876,12 +6173,13 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="out">
-      <not-null/>
+      <not-uninit/>
     </arg>
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
       <formatstr/>
+      <strz/>
     </arg>
     <arg nr="3"/>
   </function>
@@ -5901,7 +6199,9 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="3" direction="in">
       <not-null/>
       <not-uninit/>
-    </arg>
+      <formatstr/>
+      <strz/>
+    </arg>
     <arg nr="4"/>
   </function>
   <!-- int fwprintf(FILE* stream, const wchar_t* format, ...); -->
@@ -5917,6 +6217,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <formatstr/>
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- int snprintf(char *s, size_t n, const char *format, ...); -->
@@ -5937,6 +6238,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <formatstr/>
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- int vsnprintf(char *s, size_t n, const char *format, va_list arg); -->
@@ -5956,6 +6258,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <not-null/>
       <not-uninit/>
       <formatstr/>
+      <strz/>
     </arg>
     <arg nr="4"/>
   </function>
@@ -5969,6 +6272,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <formatstr/>
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- int sscanf(const char *string, const char * format, ...); -->
@@ -5978,12 +6282,14 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <strz/>
     </arg>
     <formatstr scan="true"/>
     <arg nr="2" direction="in">
       <formatstr/>
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- int fwscanf(FILE* stream, const wchar_t* format, ...); -->
@@ -5998,6 +6304,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="2" direction="in">
       <formatstr/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- int swscanf(const wchar_t *string, const wchar_t *format, ...); -->
@@ -6007,11 +6314,13 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <strz/>
     </arg>
     <formatstr scan="true"/>
     <arg nr="2" direction="in">
       <formatstr/>
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- int system(const char *command); -->
@@ -6020,7 +6329,9 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
+      <!-- If a null pointer is given, command processor is checked for existence -->
       <not-uninit/>
+      <strz/>
     </arg>
   </function>
   <!-- /*unspecified*/ setw(int n); -->
@@ -6031,8 +6342,59 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <not-uninit/>
     </arg>
   </function>
+  <!-- template <class T> std::numeric_limits<T>::epsilon(void); -->
+  <function name="std::numeric_limits::epsilon">
+    <use-retval/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <pure/>
+  </function>
+  <!-- static std::chrono::steady_clock::time_point std::chrono::high_resolution_clock::now() noexcept;-->
+  <function name="std::chrono::high_resolution_clock::now">
+    <use-retval/>
+    <returnValue type="std::chrono::steady_clock::time_point"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+  </function>
+  <!-- static std::chrono::system_clock::time_point std::chrono::system_clock::now() noexcept;-->
+  <function name="std::chrono::system_clock::now">
+    <use-retval/>
+    <returnValue type="std::chrono::system_clock::time_point"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+  </function>
+  <!-- static std::time_t std::chrono::system_clock::to_time_t( const time_point& t ) noexcept;-->
+  <function name="std::chrono::system_clock::to_time_t">
+    <use-retval/>
+    <returnValue type="std::time_t"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in"/>
+    <leak-ignore/>
+  </function>
+  <!-- template< class T >                constexpr const T& std::clamp( const T& v, const T& lo, const T& hi);                (since C++17) -->
+  <!-- template< class T, class Compare > constexpr const T& std::clamp( const T& v, const T& lo, const T& hi, Compare comp ); (since C++17) -->
+  <!-- https://en.cppreference.com/w/cpp/algorithm/clamp -->
+  <function name="std::clamp">
+    <use-retval/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <pure/>
+    <returnValue>arg1&lt;arg2?arg2:arg1&gt;arg3?arg3:arg1</returnValue>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="in" default="">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- template <class T> const T& min(const T& a, const T& b); -->
-  <function name="min,std::min">
+  <function name="std::min">
     <use-retval/>
     <noreturn>false</noreturn>
     <leak-ignore/>
@@ -6046,7 +6408,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- template <class T> const T& max(const T& a, const T& b); -->
-  <function name="max,std::max">
+  <function name="std::max">
     <use-retval/>
     <noreturn>false</noreturn>
     <leak-ignore/>
@@ -6083,6 +6445,38 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <not-uninit/>
     </arg>
   </function>
+  <!-- char std::ios::fill() const; -->
+  <!-- char std::ios::fill(char_type c); -->
+  <!-- char std::ostringstream::fill() const; -->
+  <!-- char std::ostringstream::fill(char_type c); -->
+  <function name="std::ios::fill,std::ostringstream::fill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <arg nr="1" direction="in" default="">
+      <not-uninit/>
+    </arg>
+  </function>
+ <!-- std::ios_base::fmtflags std::ios_base::flags() const;                          -->
+ <!-- std::ios_base::fmtflags std::ios_base::flags( std::ios_base::fmtflags flags ); -->
+  <function name="std::ios_base::flags">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="std::ios_base::fmtflags"/>
+    <arg nr="1" direction="in" default="">
+      <not-uninit/>
+    </arg>
+  </function>
+ <!-- std::ostream::fmtflags std::ostream::flags() const;                          -->
+ <!-- std::ostream::fmtflags std::ostream::flags( std::ostream::fmtflags flags );  -->
+  <function name="std::ostream::flags">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="std::ostream::fmtflags"/>
+    <arg nr="1" direction="in" default="">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- std::ios_base::fmtflags std::ios_base::setf( std::ios_base::fmtflags flags ); -->
   <!-- std::ios_base::fmtflags std::ios_base::setf( std::ios_base::fmtflags flags, std::ios_base::fmtflags mask ); -->
   <!-- std::ios_base::fmtflags std::ostringstream::setf( std::ios_base::fmtflags flags ); -->
@@ -6106,7 +6500,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <!--std::streamsize std::ios_base::precision(streamsize prec)-->
   <!--std::streamsize std::ostringstream::precision(streamsize prec)-->
   <!--std::streamsize std::ostream::precision(streamsize prec)-->
-  <function name="std::ios_base::precision,std::ostringstream::precision,std::ostream::precision">
+  <function name="std::ios_base::precision,std::ostringstream::precision,std::ostream::precision,std::ofstream::precision">
     <noreturn>false</noreturn>
     <returnValue type="std::streamsize"/>
     <leak-ignore/>
@@ -6131,38 +6525,29 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
                             std::istream& std::istream::get (char* s, streamsize n, char delim);
        stream buffer (3)    std::istream& std::istream::get (streambuf& sb);
                             std::istream& std::istream::get (streambuf& sb, char delim);-->
-  <!-- single character (1)                 int std::istringstream::get ();
-                            std::istringstream& std::istringstream::get (char& c);
-       c-string (2)         std::istringstream& std::istringstream::get (char* s, streamsize n);
-                            std::istringstream& std::istringstream::get (char* s, streamsize n, char delim);
-       stream buffer (3)    std::istringstream& std::istringstream::get (streambuf& sb);
-                            std::istringstream& std::istringstream::get (streambuf& sb, char delim);-->
-  <!-- There is currently no way to define this properly because Cppcheck lacks support for 
+  <!-- There is currently no way to define this properly because Cppcheck lacks support for
        overloaded functions.-->
-  <function name="std::istream::get,std::istringstream::get">
+  <function name="std::istream::get,std::istringstream::get,std::ifstream::get">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="any"/>
-  </function>
-  <!-- /*unspecified*/ setbase(int base); -->
-  <function name="setbase,std::setbase">
-    <noreturn>false</noreturn>
-    <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="out">
+      <not-null/>
+      <strz/>
+      <minsize type="argvalue" arg="2"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="3" default="'\n'" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!-- struct tmx *zonetime(const time_t *tp, int zone); -->
-  <function name="zonetime">
-    <use-retval/>
-    <returnValue type="struct tmx *"/>
+  <!-- /*unspecified*/ setbase(int base); -->
+  <function name="setbase,std::setbase">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
-      <not-null/>
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in">
       <not-uninit/>
     </arg>
   </function>
@@ -6200,50 +6585,107 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <not-uninit/>
     </arg>
   </function>
-  <!-- template< class T > void swap( T& a, T& b );-->
-  <function name="std::swap">
+  <!-- (1) (since C++17) bool std::filesystem::exists( std::filesystem::file_status s ) noexcept; -->
+  <!-- (2) (since C++17) bool std::filesystem::exists( const std::filesystem::path& p ); -->
+  <!-- (3) (since C++17) bool std::filesystem::exists( const std::filesystem::path& p, std::error_code& ec ) noexcept; -->
+  <!-- (1) (since C++17) bool std::filesystem::is_block_file( std::filesystem::file_status s ) noexcept; -->
+  <!-- (2) (since C++17) bool std::filesystem::is_block_file( const std::filesystem::path& p ); -->
+  <!-- (3) (since C++17) bool std::filesystem::is_block_file( const std::filesystem::path& p, std::error_code& ec ) noexcept; -->
+  <!-- (1) (since C++17) bool std::filesystem::is_character_file( std::filesystem::file_status s ) noexcept; -->
+  <!-- (2) (since C++17) bool std::filesystem::is_character_file( const std::filesystem::path& p ); -->
+  <!-- (3) (since C++17) bool std::filesystem::is_character_file( const std::filesystem::path& p, std::error_code& ec ) noexcept; -->
+  <!-- (1) (since C++17) bool std::filesystem::is_directory( std::filesystem::file_status s ) noexcept; -->
+  <!-- (2) (since C++17) bool std::filesystem::is_directory( const std::filesystem::path& p ); -->
+  <!-- (3) (since C++17) bool std::filesystem::is_directory( const std::filesystem::path& p, std::error_code& ec ) noexcept; -->
+  <!-- (1) (since C++17) bool std::filesystem::is_empty const std::filesystem::path& p ); -->
+  <!-- (2) (since C++17) bool std::filesystem::is_empty( const std::filesystem::path& p, std::error_code& ec ) noexcept; -->
+  <!-- (1) (since C++17) bool std::filesystem::is_fifo( std::filesystem::file_status s ) noexcept; -->
+  <!-- (2) (since C++17) bool std::filesystem::is_fifo const std::filesystem::path& p ); -->
+  <!-- (3) (since C++17) bool std::filesystem::is_fifo( const std::filesystem::path& p, std::error_code& ec ) noexcept; -->
+  <!-- (1) (since C++17) bool std::filesystem::is_other( std::filesystem::file_status s ) noexcept; -->
+  <!-- (2) (since C++17) bool std::filesystem::is_other const std::filesystem::path& p ); -->
+  <!-- (3) (since C++17) bool std::filesystem::is_other( const std::filesystem::path& p, std::error_code& ec ) noexcept; -->
+  <!-- (1) (since C++17) bool std::filesystem::is_regular_file( std::filesystem::file_status s ) noexcept; -->
+  <!-- (2) (since C++17) bool std::filesystem::is_regular_file( const std::filesystem::path& p ); -->
+  <!-- (3) (since C++17) bool std::filesystem::is_regular_file( const std::filesystem::path& p, std::error_code& ec ) noexcept; -->
+  <!-- (1) (since C++17) bool std::filesystem::is_socket( std::filesystem::file_status s ) noexcept; -->
+  <!-- (2) (since C++17) bool std::filesystem::is_socket( const std::filesystem::path& p ); -->
+  <!-- (3) (since C++17) bool std::filesystem::is_socket( const std::filesystem::path& p, std::error_code& ec ) noexcept; -->
+  <!-- (1) (since C++17) bool std::filesystem::is_symlink( std::filesystem::file_status s ) noexcept; -->
+  <!-- (2) (since C++17) bool std::filesystem::is_symlink( const std::filesystem::path& p ); -->
+  <!-- (3) (since C++17) bool std::filesystem::is_symlink( const std::filesystem::path& p, std::error_code& ec ) noexcept; -->
+  <function name="std::filesystem::exists,std::filesystem::is_block_file,std::filesystem::is_character_file,std::filesystem::is_directory,std::filesystem::is_empty,std::filesystem::is_fifo,std::filesystem::is_other,std::filesystem::is_regular_file,std::filesystem::is_socket,std::filesystem::is_symlink">
+    <returnValue type="bool"/>
     <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="out" default=""/>
+  </function>
+  <!-- https://en.cppreference.com/w/cpp/filesystem/create_symlink -->
+  <!-- (1) (since C++17) void create_symlink(const std::filesystem::path& target, const std::filesystem::path& link ); -->
+  <!-- (2) (since C++17) void create_symlink(const std::filesystem::path& target, const std::filesystem::path& link, std::error_code& ec ) noexcept; -->
+  <!-- (1) (since C++17) void create_directory_symlink(const std::filesystem::path& target, const std::filesystem::path& link ); -->
+  <!-- (2) (since C++17) void create_directory_symlink(const std::filesystem::path& target, const std::filesystem::path& link, std::error_code& ec ) noexcept; -->
+  <!-- https://en.cppreference.com/w/cpp/filesystem/create_hard_link -->
+  <!-- (1) (since C++17) void create_hard_link(const std::filesystem::path& target, const std::filesystem::path& link ); -->
+  <!-- (2) (since C++17) void create_hard_link(const std::filesystem::path& target, const std::filesystem::path& link, std::error_code& ec ) noexcept; -->
+  <function name="std::filesystem::create_symlink,std::filesystem::create_directory_symlink,std::filesystem::create_hard_link">
     <returnValue type="void"/>
-    <arg nr="1">
-      <not-uninit/>
-    </arg>
-    <arg nr="2">
-      <not-uninit/>
-    </arg>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="out" default=""/>
   </function>
   <!-- std::string std::ostringstream::str() const; -->
   <!-- std::string std::stringstream::str() const; -->
+  <!-- std::string std::basic_stringstream::str() const; -->
   <!-- @todo Implement the second version when function overloading is possible: -->
   <!--       void std::ostringstream::str(const string & s); -->
-  <function name="std::ostringstream::str,std::stringstream::str">
+  <function name="std::istringstream::str,std::ostringstream::str,std::stringstream::str,std::basic_stringstream::str">
     <use-retval/>
     <const/>
     <returnValue type="std::string"/>
     <noreturn>false</noreturn>
   </function>
+  <!-- std::ios::pos_type std::istream::tellg( void ); -->
+  <!-- std::ios::pos_type std::ifstream::tellg( void ); -->
+  <function name="std::istream::tellg,std::basic_istream::tellg,std::ifstream::tellg,std::basic_ifstream::tellg">
+    <use-retval/>
+    <returnValue type="std::ios::pos_type"/>
+    <noreturn>false</noreturn>
+  </function>
   <!-- bool good() const; -->
-  <function name="std::ios::good,std::ios_base::good,std::ostream::good,std::ofstream::good,std::ostringstream::good">
+  <function name="std::ios::good,std::wifstream::good,std::ios_base::good,std::ostream::good,std::ofstream::good,std::ostringstream::good,std::ifstream::good,std::istream::good,std::istringstream::good,std::wistringstream::good,std::basic_istringstream::good">
     <use-retval/>
     <const/>
     <returnValue type="bool"/>
     <noreturn>false</noreturn>
   </function>
   <!-- bool eof() const; -->
-  <function name="std::ios::eof,std::ios_base::eof,std::ostream::eof,std::ofstream::eof,std::ostringstream::eof">
+  <function name="std::ios::eof,std::ios_base::eof,std::ostream::eof,std::ofstream::eof,std::ostringstream::eof,std::istringstream::eof,std::wistringstream::eof,std::basic_istringstream::eof,std::istream::eof,std::ifstream::eof">
     <use-retval/>
     <const/>
     <returnValue type="bool"/>
     <noreturn>false</noreturn>
   </function>
   <!-- bool fail() const; -->
-  <function name="std::ios::fail,std::ios_base::fail,std::ostream::fail,std::ofstream::fail,std::ostringstream::fail">
+  <function name="std::ios::fail,std::ios_base::fail,std::ostream::fail,std::ofstream::fail,std::ostringstream::fail,std::ifstream::fail,std::istringstream::fail,std::wistringstream::fail,std::basic_istringstream::fail,std::istream::fail">
     <use-retval/>
     <const/>
     <returnValue type="bool"/>
     <noreturn>false</noreturn>
   </function>
   <!-- bool bad() const; -->
-  <function name="std::ios::bad,std::ios_base::bad,std::ostream::bad,std::ofstream::bad,std::ostringstream::bad">
+  <function name="std::ios::bad,std::wifstream::bad,std::ios_base::bad,std::ostream::bad,std::ofstream::bad,std::ostringstream::bad,std::ifstream::bad,std::istringstream::bad,std::wistringstream::bad,std::basic_istringstream::bad,std::istream::bad">
+    <use-retval/>
+    <const/>
+    <returnValue type="bool"/>
+    <noreturn>false</noreturn>
+  </function>
+  <!-- bool is_open() const; -->
+  <function name="std::basic_ifstream::is_open,std::ifstream::is_open,std::basic_ofstream::is_open,std::ofstream::is_open,std::wifstream::is_open">
     <use-retval/>
     <const/>
     <returnValue type="bool"/>
@@ -6257,10 +6699,51 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-uninit/>
       <not-null/>
+      <minsize type="argvalue" arg="2"/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
-      <valid>1:</valid>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!--std::ostringstream& std::ostringstream::write (const char* s, streamsize n);-->
+  <function name="std::ostringstream::write">
+    <returnValue type="std::ostringstream &amp;"/>
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <minsize type="argvalue" arg="2"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!--https://en.cppreference.com/w/cpp/io/manip/quoted -->
+  <!--template< class CharT >
+      /*unspecified*/ quoted( const CharT* s,
+                              CharT delim = CharT('"'), CharT escape = CharT('\\') ); (1)(since C++14)
+      template< class CharT, class Traits, class Allocator >
+      /*unspecified*/ quoted( const std::basic_string<CharT, Traits, Allocator>& s,
+                              CharT delim = CharT('"'), CharT escape = CharT('\\') ); (2)(since C++14)
+      template< class CharT, class Traits>
+      /*unspecified*/ quoted( std::basic_string_view<CharT, Traits> s,
+                              CharT delim = CharT('"'), CharT escape = CharT('\\') ); (3)(since C++17)
+      template< class CharT, class Traits, class Allocator >
+      /*unspecified*/ quoted( std::basic_string<CharT, Traits, Allocator>& s,
+                              CharT delim=CharT('"'), CharT escape=CharT('\\') ); (4)(since C++14) -->
+  <function name="std::quoted">
+    <!-- This function returns an object of unspecified type -->
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="&apos;&quot;&apos;">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in" default="&apos;\\&apos;">
+      <not-uninit/>
     </arg>
   </function>
   <!--std::ostream& std::ostream::write (const char* s, streamsize n);-->
@@ -6271,10 +6754,11 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-uninit/>
       <not-null/>
+      <minsize type="argvalue" arg="2"/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
-      <valid>1:</valid>
+      <valid>0:</valid>
     </arg>
   </function>
   <!--std::fstream& std::fstream::write (const char* s, streamsize n);-->
@@ -6285,10 +6769,11 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1" direction="in">
       <not-uninit/>
       <not-null/>
+      <minsize type="argvalue" arg="2"/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
-      <valid>1:</valid>
+      <valid>0:</valid>
     </arg>
   </function>
   <!-- void std::vector::assign( size_type count, const T& value ); -->
@@ -6300,25 +6785,10 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <arg nr="1">
       <not-uninit/>
     </arg>
-    <arg nr="2" default="0">
+    <arg nr="2" default="0" direction="in" indirect="0">
       <not-uninit/>
     </arg>
   </function>
-  <!-- void clear(); // until C++11 -->
-  <!-- void clear() noexcept; // since C++11 -->
-  <function name="std::deque::clear,std::list::clear,std::forward_list::clear,std::map::clear,std::unordered_map::clear,std::queue::clear,std::set::clear,std::unordered_set::clear,std::stack::clear,std::string::clear,std::wstring::clear,std::basic_string::clear,std::vector::clear">
-    <noreturn>false</noreturn>
-    <returnValue type="void"/>
-  </function>
-  <!-- bool empty() const; // until C++11 -->
-  <!-- constexpr bool empty() const noexcept; // since C++11 until C++20 -->
-  <!-- [[nodiscard]] constexpr bool empty() const noexcept; // since C++20 -->
-  <function name="std::array::empty,std::deque::empty,std::list::empty,std::forward_list::empty,std::map::empty,std::unordered_map::empty,std::queue::empty,std::set::empty,std::unordered_set::empty,std::stack::empty,std::string::empty,std::wstring::empty,std::basic_string::empty,std::vector::empty">
-    <use-retval/>
-    <const/>
-    <returnValue type="bool"/>
-    <noreturn>false</noreturn>
-  </function>
   <!-- void std::deque::push_back( const T& value ); -->
   <!-- void std::deque::push_back( T&& value ); // since C++11 -->
   <!-- void std::deque::push_front( const T& value ); -->
@@ -6335,10 +6805,10 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <!-- void std::stack::push( value_type&& value ); // since C++11 -->
   <!-- void std::vector::push_back( const T& value ); -->
   <!-- void std::vector::push_back( T&& value ); // since C++11 -->
-  <function name="std::deque::push_back,std::deque::push_front,std::list::push_back,std::list::push_front,std::forward_list::push_front,std::queue::push,std::stack::push,std::vector::push_back">
+  <function name="std::deque::push_back,std::deque::push_front,std::list::push_back,std::list::push_front,std::forward_list::push_front,std::queue::push,std::priority_queue::push,std::stack::push,std::vector::push_back">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1">
+    <arg nr="1" direction="in" indirect="0">
       <not-uninit/>
     </arg>
   </function>
@@ -6356,35 +6826,36 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <!-- For std::set::insert see http://en.cppreference.com/w/cpp/container/set/insert -->
   <!-- For std::string::insert see http://en.cppreference.com/w/cpp/string/basic_string/insert -->
   <!-- For std::vector::insert see http://en.cppreference.com/w/cpp/container/vector/insert -->
+  <!-- For std::unordered_map::insert see https://en.cppreference.com/w/cpp/container/unordered_map/insert -->
+  <!-- For std::unordered_set::insert see https://en.cppreference.com/w/cpp/container/unordered_set/insert -->
   <!-- Return value type is "iterator" or "void" depending on the overloaded function. -->
-  <function name="std::list::insert,std::multimap::insert,std::map::insert,std::set::insert,std::multiset::insert,std::string::insert,std::vector::insert">
+  <function name="std::list::insert,std::multimap::insert,std::map::insert,std::set::insert,std::multiset::insert,std::string::insert,std::vector::insert,std::unordered_map::insert,std::unordered_set::insert">
     <noreturn>false</noreturn>
     <arg nr="1">
       <not-uninit/>
     </arg>
-    <arg nr="2" default="0">
+    <arg nr="2" default="0" direction="in" indirect="0">
       <not-uninit/>
     </arg>
-    <arg nr="3" default="0">
+    <arg nr="3" default="0" direction="in" indirect="0">
       <not-uninit/>
     </arg>
   </function>
-  <function name="std::deque::emplace_back,std::deque::emplace_front,std::list::emplace_back,std::list::emplace_front,std::forward_list::emplace_front,std::queue::emplace,std::stack::emplace,std::vector::emplace_back,std::vector::emplace_front">
+  <function name="std::deque::emplace_back,std::deque::emplace_front,std::list::emplace_back,std::list::emplace_front,std::forward_list::emplace_front,std::queue::emplace,std::priority_queue::emplace,std::stack::emplace,std::vector::emplace_back,std::vector::emplace_front,std::unordered_set::emplace">
     <noreturn>false</noreturn>
     <arg nr="variadic">
       <not-uninit/>
     </arg>
   </function>
-  <function name="std::list::find,std::map::find,std::set::find,std::vector::find,std::unordered_map::find,std::unordered_multimap::find,std::unordered_set::find,std::unordered_multiset::find,std::multiset::find,std::multimap::find">
+  <function name="std::map::find,std::set::find,std::unordered_map::find,std::unordered_multimap::find,std::unordered_set::find,std::unordered_multiset::find,std::multiset::find,std::multimap::find">
     <use-retval/>
-    <const/>
     <returnValue type="iterator"/>
     <noreturn>false</noreturn>
     <arg nr="1">
       <not-uninit/>
     </arg>
   </function>
-  <function name="std::deque::size,std::deque::max_size,std::list::size,std::list::max_size,std::map::size,std::map::max_size,std::unordered_map::size,std::unordered_map::max_size,std::queue::size,std::set::size,std::set::max_size,std::unordered_set::size,std::unordered_set::max_size,std::stack::size,std::string::size,std::wstring::size,std::vector::size,std::vector::capacity,std::vector::max_size,std::array::size,std::array::max_size">
+  <function name="std::deque::max_size,std::list::max_size,std::map::max_size,std::unordered_map::max_size,std::set::max_size,std::unordered_set::max_size,std::vector::capacity,std::vector::max_size,std::span::size_bytes">
     <use-retval/>
     <const/>
     <returnValue type="std::size_t"/>
@@ -6393,32 +6864,26 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <!--                     size_type std::map::count( const Key& key ) const; -->
   <!-- template< class K > size_type std::map::count( const K& x ) const; // since C++14 -->
   <!--                     size_type std::set::count( const value_type& val) const; -->
-  <function name="std::map::count,std::set::count">
+  <!--                     size_type std::unordered_set::count( const Key& key ) const; -->
+  <!--                     size_type std::unordered_map::count( const Key& key ) const; -->
+  <!--                     size_type std::multimap::count( const Key& key ) const; -->
+  <function name="std::map::count,std::set::count,std::unordered_set::count,std::unordered_map::count,std::multimap::count">
     <noreturn>false</noreturn>
-    <returnValue type="size_t"/>
+    <returnValue type="std::size_t"/>
     <use-retval/>
     <const/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!-- void std::vector::push_back (const value_type& val); -->
-  <!-- void std::vector::push_back (value_type&& val); // since C++11-->
-  <function name="std::vector::push_back,std::vector::pop_back">
-    <noreturn>false</noreturn>
-    <returnValue type="void"/>
-    <arg nr="1"/>
-  </function>
-  <!-- void std::vector::pop_back (void); -->
-  <function name="std::vector::pop_back">
+  <function name="std::string::size,std::string::length,std::string_view::size,std::string_view::length,std::wstring_view::size,std::wstring_view::length,std::wstring::size,std::wstring::length">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
-  </function>
-  <function name="std::list::back,std::list::front,std::forward_list::front,std::queue::back,std::queue::front,std::vector::back,std::vector::front,std::array::front,std::array::back">
+    <returnValue type="std::size_t"/>
     <use-retval/>
-    <noreturn>false</noreturn>
+    <const/>
+    <leak-ignore/>
   </function>
-  <function name="std::vector::at">
+  <function name="std::vector::at,std::deque::at,std::array::at,std::string_view::at,std::wstring_view::at">
     <use-retval/>
     <noreturn>false</noreturn>
     <arg nr="1">
@@ -6426,10 +6891,6 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <valid>0:</valid>
     </arg>
   </function>
-  <function name="std::list::pop_back,std::list::pop_front,std::forward_list::pop_front,std::vector::pop_back">
-    <noreturn>false</noreturn>
-    <returnValue type="void"/>
-  </function>
   <!-- void std::vector::reserve(size_type new_capacity); -->
   <function name="std::vector::reserve">
     <noreturn>false</noreturn>
@@ -6486,15 +6947,44 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <!-- template< class T2, std::size_t N > void swap( T2 (&a)[N], T2 (&b)[N]) -->
   <!-- template< class T2, std::size_t N > constexpr void swap( T2 (&a)[N], T2 (&b)[N]) -->
   <function name="std::swap">
+    <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1"/>
-    <arg nr="2"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- https://en.cppreference.com/w/cpp/utility/exchange -->
+  <!-- template< class T, class U = T > constexpr T exchange( T& obj, U&& new_value ) -->
+  <function name="std::exchange">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <returnValue>arg1</returnValue>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- https://en.cppreference.com/w/cpp/memory/addressof -->
+  <!-- template< class T > constexpr T* addressof( T& arg ) noexcept; -->
+  <function name="std::addressof">
+    <leak-ignore/>
+    <use-retval/>
+    <noreturn>false</noreturn>
+    <returnValue type="void*">&amp; arg1</returnValue>
+    <arg nr="1">
+    </arg>
   </function>
-  <function name="std::stack::pop,std::queue::pop">
+  <function name="std::stack::pop,std::queue::pop,std::priority_queue::pop">
     <noreturn>false</noreturn>
   </function>
-  <function name="std::stack::top">
+  <function name="std::stack::top,std::priority_queue::top">
     <use-retval/>
     <noreturn>false</noreturn>
   </function>
@@ -6567,25 +7057,37 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <!-- template < class T > int compare( const T& t ) const; // since C++17 -->
   <!-- template < class T > int compare( size_type pos1, size_type count1, const T& t ) const; // since C++17 -->
   <!-- template < class T > int compare( size_type pos1, size_type count1, const T& t, size_type pos2, size_type count2 = npos) const; // since C++17 -->
-  <function name="std::string::compare,std::wstring::compare">
+  <function name="std::string::compare,std::string_view::compare,std::wstring_view::compare,std::wstring::compare">
     <noreturn>false</noreturn>
     <returnValue type="int"/>
     <use-retval/>
     <const/>
     <leak-ignore/>
-    <arg nr="1">
+    <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="2" default="0">
+    <arg nr="2" default="0" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="3" default="0">
+    <arg nr="3" default="0" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" default="0" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="4" default="0">
+    <arg nr="5" default="0" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="5" default="0">
+  </function>
+  <!-- constexpr bool std::string::starts_with( std::basic_string_view<CharT,Traits> sv ) const noexcept; // since C++20 -->
+  <!-- constexpr bool starts_with( CharT ch ) const noexcept; // since C++20 -->
+  <!-- constexpr bool starts_with( const CharT* s ) const; // since C++20 -->
+  <function name="std::string::starts_with,std::wstring::starts_with,std::string::ends_with,std::wstring::ends_with">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
   </function>
@@ -6628,6 +7130,16 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <returnValue type="const char *"/>
     <noreturn>false</noreturn>
   </function>
+  <!-- const wchar_t* c_str() const; // until C++11 -->
+  <!-- const wchar_t* c_str() const noexcept; // since C++11 -->
+  <!-- const wchar_t* data() const; // until C++11 -->
+  <!-- const wchar_t* data() const noexcept; // since C++11 -->
+  <function name="std::wstring::c_str,std::wstring::data">
+    <use-retval/>
+    <const/>
+    <returnValue type="const wchar_t *"/>
+    <noreturn>false</noreturn>
+  </function>
   <!-- char& front(); -->
   <!-- const char& front() const; -->
   <function name="std::string::front">
@@ -6635,6 +7147,13 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <returnValue type="char &amp;"/>
     <noreturn>false</noreturn>
   </function>
+  <!-- wchar_t& front(); -->
+  <!-- const wchar_t& front() const; -->
+  <function name="std::wstring::front">
+    <use-retval/>
+    <returnValue type="wchar_t &amp;"/>
+    <noreturn>false</noreturn>
+  </function>
   <!-- size_t find (const string& str, size_t pos = 0) const; -->
   <!-- size_t find (const char* s, size_t pos, size_t n) const; -->
   <!-- size_t find (char c, size_t pos = 0) const;-->
@@ -6661,14 +7180,38 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <valid>0:</valid>
     </arg>
   </function>
-  <function name="std::string::length,std::wstring::length,std::basic_string::size,std::basic_string::length">
+  <function name="std::string::substr">
+    <use-retval/>
     <const/>
+    <returnValue type="std::string"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <function name="std::wstring::substr">
     <use-retval/>
-    <returnValue type="std::size_t"/>
+    <const/>
+    <returnValue type="std::wstring"/>
     <noreturn>false</noreturn>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
   </function>
-  <function name="std::string::substr,std::wstring::substr,std::basic_string::substr">
+  <function name="std::basic_string::substr">
     <use-retval/>
+    <const/>
+    <returnValue type="std::basic_string"/>
     <noreturn>false</noreturn>
     <arg nr="1" default="0" direction="in">
       <not-uninit/>
@@ -6676,10 +7219,17 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
     <arg nr="2" default="0" direction="in">
       <not-uninit/>
+      <valid>0:</valid>
     </arg>
   </function>
+  <!-- int std::istream::peak();-->
+  <function name="std::istream::peek">
+    <use-retval/>
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+  </function>
   <!-- void std::ios::clear (std::ios::iostate state = std::ios::goodbit);-->
-  <function name="std::ios::clear,std::fstream::clear">
+  <function name="std::ios::clear,std::fstream::clear,std::istream::clear">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" default="std::ios::goodbit">
@@ -6759,37 +7309,19 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
       <not-uninit/>
     </arg>
   </function>
-  <!-- istream& get (char* s, streamsize n ); -->
-  <!-- istream& get (char* s, streamsize n, char delim ); -->
-  <function name="std::istream::get,std::ifstream::get">
+  <!-- Not part of standard, but widely supported by runtime libraries. -->
+  <!-- char * itoa (int value, char * str, int base); -->
+  <function name="itoa">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="out">
+    <returnValue type="char *"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="out">
       <not-null/>
-      <strz/>
-      <minsize type="argvalue" arg="2"/>
     </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
-      <valid>0:</valid>
-    </arg>
-    <arg nr="3" default="'\n'" direction="in">
-      <not-uninit/>
-    </arg>
-  </function>
-  <!-- Not part of standard, but widely supported by runtime libraries. -->
-  <!-- char * itoa (int value, char * str, int base); -->
-  <function name="itoa">
-    <noreturn>false</noreturn>
-    <leak-ignore/>
-    <returnValue type="char *"/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="out">
-      <not-null/>
-    </arg>
-    <arg nr="3" direction="in">
+    <arg nr="3" direction="in">
       <not-uninit/>
       <valid>2:36</valid>
     </arg>
@@ -6974,12 +7506,16 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
       <not-uninit/>
     </arg>
   </function>
+  <!-- void std::ofstream::open(const char* filename        , ios_base::openmode mode = ios_base::out); -->
   <!-- void std::ofstream::open(const std::string & filename, ios_base::openmode mode = ios_base::out); -->
   <function name="std::ofstream::open">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="void"/>
-    <arg nr="1" direction="in"/>
+    <arg nr="1" direction="in">
+       <not-null/>
+       <not-uninit/>
+    </arg>
     <arg nr="2" direction="in" default="std::ios_base::out">
       <not-uninit/>
     </arg>
@@ -6990,18 +7526,32 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="void"/>
-    <arg nr="1" direction="in"/>
+    <arg nr="1" direction="in">
+       <not-null/>
+       <not-uninit/>
+    </arg>
     <arg nr="2" direction="in" default="std::ios_base::in">
       <not-uninit/>
     </arg>
   </function>
+  <!-- void std::ifstream::close(); -->
+  <!-- void std::ofstream::close(); -->
+  <!-- void std::fstream::close(); -->
+  <!-- void std::wifstream::close(); -->
+  <function name="std::ifstream::close,std::ofstream::close,std::fstream::close,std::wifstream::close">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+  </function>
   <!-- void std::fstream::open(const char* filename, ios_base::openmode mode = ios_base::in | ios_base::out); -->
   <!-- void std::fstream::open(const std::string& filename, ios_base::openmode mode = ios_base::in | ios_base::out); -->
   <function name="std::fstream::open">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="void"/>
-    <arg nr="1" direction="in"/>
+    <arg nr="1" direction="in">
+       <not-null/>
+       <not-uninit/>
+    </arg>
     <arg nr="2" direction="in" default="std::ios_base::in | std::ios_base::out">
       <not-uninit/>
     </arg>
@@ -7014,6 +7564,7 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
     <use-retval/>
     <returnValue type="std::filebuf *"/>
     <arg nr="1" direction="in">
+      <not-null/>
       <not-uninit/>
     </arg>
     <arg nr="2" direction="in">
@@ -7030,6 +7581,34 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
       <valid>0:</valid>
     </arg>
   </function>
+  <!-- https://en.cppreference.com/w/cpp/string/basic_string_view/substr -->
+  <!-- constexpr basic_string_view substr( size_type pos = 0, size_type count = npos ) const; -->
+  <function name="std::string_view::substr">
+    <use-retval/>
+    <returnValue type="std::string_view"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <function name="std::wstring_view::substr">
+    <use-retval/>
+    <returnValue type="std::wstring_view"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+  </function>
   <!-- default (1) template <class ForwardIterator>                ForwardIterator std::min_element (ForwardIterator first, ForwardIterator last);
         custom (2) template <class ForwardIterator, class Compare> ForwardIterator std::min_element (ForwardIterator first, ForwardIterator last, Compare comp); -->
   <!-- default (1) template <class ForwardIterator>                ForwardIterator std::max_element (ForwardIterator first, ForwardIterator last);
@@ -7050,10 +7629,24 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
       <not-uninit/>
     </arg>
   </function>
+  <!-- template< class ForwardIt > std::pair<ForwardIt,ForwardIt> std::minmax_element( ForwardIt first, ForwardIt last ) -->
+  <!-- template< class ForwardIt > std::pair<ForwardIt,ForwardIt> std::minmax( ForwardIt first, ForwardIt last ) -->
+  <function name="std::minmax_element,std::minmax">
+    <use-retval/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <iterator container="1" type="first"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <iterator container="1" type="last"/>
+    </arg>
+  </function>
   <!-- template<class InputIterator> typename iterator_traits<InputIterator>::difference_type std::distance (InputIterator first, InputIterator last); -->
   <function name="std::distance">
     <use-retval/>
-    <returnValue type="std::size_t"/>
+    <returnValue type="std::ptrdiff_t"/>
     <noreturn>false</noreturn>
     <arg nr="1" direction="in">
       <not-uninit/>
@@ -7087,15 +7680,15 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
   <function name="std::rotate">
     <returnValue type="iterator" container="1"/>
     <noreturn>false</noreturn>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="inout">
       <not-uninit/>
       <iterator container="1" type="first"/>
     </arg>
-    <arg nr="2" direction="in">
+    <arg nr="2" direction="inout">
       <not-uninit/>
       <iterator container="1" type="middle"/>
     </arg>
-    <arg nr="3" direction="in">
+    <arg nr="3" direction="inout">
       <not-uninit/>
       <iterator container="1" type="last"/>
     </arg>
@@ -7117,9 +7710,9 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
       <not-uninit/>
     </arg>
   </function>
-  <!-- InputIterator std::find(InputIterator first, InputIterator last, T val) -->
-  <!-- InputIterator std::find_if(InputIterator first, InputIterator last, UnaryPredicate val) -->
-  <!-- InputIterator std::find_if_not(InputIterator first, InputIterator last, UnaryPredicate val) -->
+  <!-- template< class InputIterator, class T >              InputIterator std::find(InputIterator first, InputIterator last, T val) -->
+  <!-- template< class InputIterator, class UnaryPredicate > InputIterator std::find_if(InputIterator first, InputIterator last, UnaryPredicate val) -->
+  <!-- template< class InputIterator, class UnaryPredicate > InputIterator std::find_if_not(InputIterator first, InputIterator last, UnaryPredicate val) -->
   <function name="std::find,std::find_if,std::find_if_not">
     <use-retval/>
     <returnValue type="iterator" container="1"/>
@@ -7136,6 +7729,23 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
       <not-uninit/>
     </arg>
   </function>
+  <!-- template< class BidirIt, class UnaryPred > BidirIt partition( BidirIt first, BidirIt last, UnaryPred p ); -->
+  <!-- template< class BidirIt, class UnaryPred > BidirIt stable_partition( BidirIt first, BidirIt last, UnaryPred p ); -->
+  <function name="std::partition,std::stable_partition">
+    <returnValue type="iterator" container="1"/>
+    <noreturn>false</noreturn>
+    <arg nr="1">
+      <not-uninit/>
+      <iterator container="1" type="first"/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <iterator container="1" type="last"/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- template< class InputIt, class OutputIt > OutputIt copy( InputIt first, InputIt last, OutputIt d_first ); -->
   <function name="std::copy">
     <returnValue type="iterator" container="2"/>
@@ -7153,10 +7763,28 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
       <iterator container="2" type="first"/>
     </arg>
   </function>
+  <!-- template< class InputIt, class Size, class OutputIt > OutputIt copy_n( InputIt first, Size count, OutputIt result ); -->
+  <function name="std::copy_n">
+    <returnValue type="iterator" container="2"/>
+    <noreturn>false</noreturn>
+    <arg nr="1">
+      <not-uninit/>
+      <iterator container="1" type="first"/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+      <iterator container="2" type="first"/>
+    </arg>
+  </function>
   <!--        template <class RandomAccessIterator>                            void std::sort (RandomAccessIterator first, RandomAccessIterator last);                (until C++20) -->
   <!--        template <class RandomAccessIterator>  constexpr                 void std::sort (RandomAccessIterator first, RandomAccessIterator last);                (since C++20) -->
   <!-- @todo: template< class ExecutionPolicy, class RandomIt >                void std::sort (ExecutionPolicy&& policy, RandomIt first, RandomIt last);              (since C++17) -->
-  <!-- @todo: template< class RandomIt, class Compare >                        void std::sort (RandomIt first, RandomIt last, Compare comp);                          (unitl C++17) -->
+  <!-- @todo: template< class RandomIt, class Compare >                        void std::sort (RandomIt first, RandomIt last, Compare comp);                          (until C++17) -->
   <!-- @todo: template< class RandomIt, class Compare > constexpr              void std::sort (RandomIt first, RandomIt last, Compare comp);                          (since C++20) -->
   <!-- @todo: template< class ExecutionPolicy, class RandomIt, class Compare > void std::sort (ExecutionPolicy&& policy, RandomIt first, RandomIt last, Compare comp);(since C++17) -->
   <function name="std::sort">
@@ -7171,6 +7799,60 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
       <iterator container="1" type="last"/>
     </arg>
   </function>
+  <!--        template< class RandomIt>                                        void stable_sort( RandomIt first, RandomIt last );                                                            -->
+  <!-- @todo: template< class ExecutionPolicy, class RandomIt >                void stable_sort( ExecutionPolicy&& policy, RandomIt first, RandomIt last );                    (since C++17) -->
+  <!-- @todo: template< class RandomIt, class Compare >                        void stable_sort( RandomIt first, RandomIt last, Compare comp );                                              -->
+  <!-- @todo: template< class ExecutionPolicy, class RandomIt, class Compare > void stable_std::sort( ExecutionPolicy&& policy, RandomIt first, RandomIt last, Compare comp ); (since C++17) -->
+  <function name="std::stable_sort">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-uninit/>
+      <iterator container="1" type="first"/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <iterator container="1" type="last"/>
+    </arg>
+  </function>
+  <!-- template< class InputIt1, class InputIt2, class OutputIt > OutputIt merge( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, OutputIt d_first ); -->
+  <function name="std::merge">
+    <noreturn>false</noreturn>
+    <returnValue type="iterator" container="3"/>
+    <arg nr="1">
+      <not-uninit/>
+      <iterator container="1" type="first"/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <iterator container="1" type="last"/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+      <iterator container="2" type="first"/>
+    </arg>
+    <arg nr="4">
+      <not-uninit/>
+      <iterator container="2" type="last"/>
+    </arg>
+    <arg nr="5">
+      <not-uninit/>
+      <iterator container="3" type="first"/>
+    </arg>
+  </function>
+  <!-- template< class RandomIt > void push_heap( RandomIt first, RandomIt last ); -->
+  <function name="std::push_heap">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-uninit/>
+      <iterator container="1" type="first"/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <iterator container="1" type="last"/>
+    </arg>
+  </function>
   <!-- template< class RandomIt >                   void std::random_shuffle( RandomIt first, RandomIt last ); (deprecated in C++14) (removed in C++17) -->
   <!-- template< class RandomIt, class RandomFunc > void std::random_shuffle( RandomIt first, RandomIt last, RandomFunc& r ); (until C++11) -->
   <!-- template< class RandomIt, class RandomFunc > void std::random_shuffle( RandomIt first, RandomIt last, RandomFunc&& r ); (since C++11) (deprecated in C++14) (removed in C++17) -->
@@ -7206,6 +7888,43 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
       <not-uninit/>
     </arg>
   </function>
+  <!-- template< class ForwardIt, class Generator >                        void std::generate (ForwardIt first, ForwardIt last, Generator g ); (until C++20) -->
+  <!-- template< class ForwardIt, class Generator > constexpr              void std::generate (ForwardIt first, ForwardIt last, Generator g ); (since C++20) -->
+  <!-- template< class ExecutionPolicy, class ForwardIt, class Generator > void std::generate (ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, Generator g ); (since C++17) -->
+  <function name="std::generate">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="any">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- template< class OutputIt, class Size, class T > void std::fill_n( OutputIt first, Size count, const T& value ); // until C++11 -->
+  <!-- template< class OutputIt, class Size, class T > OutputIt std::fill_n( OutputIt first, Size count, const T& value ); // since C++11, until C++20 -->
+  <!-- template< class OutputIt, class Size, class T > constexpr OutputIt std::fill_n( OutputIt first, Size count, const T& value ); // since C++20 -->
+  <!-- template< class ExecutionPolicy, class ForwardIt, class Size, class T > ForwardIt std::fill_n( ExecutionPolicy&& policy, ForwardIt first, Size count, const T& value ); // since C++17 -->
+  <function name="std::fill_n">
+    <noreturn>false</noreturn>
+    <arg nr="1"/>
+    <arg nr="2"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in" default=""/>
+  </function>
+  <!-- template< class ForwardIt, class T > void iota( ForwardIt first, ForwardIt last, T value ); -->
+  <function name="std::iota">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-uninit/>
+      <iterator container="1" type="first"/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <iterator container="1" type="last"/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- @todo: iterator iterator erase (const_iterator position); -->
   <!-- iterator std::vector::erase( iterator first, iterator last ); -->
   <!-- iterator std::map::erase( iterator first, iterator last ); -->
@@ -7437,6 +8156,15 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
       <not-uninit/>
     </arg>
   </function>
+  <!-- template< class InputIt, class Distance >           void std::advance( InputIt& it, Distance n ); (until C++17) -->
+  <!-- template< class InputIt, class Distance > constexpr void std::advance( InputIt& it, Distance n );               -->
+  <function name="std::advance">
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
   <!-- template< class ForwardIt, class T >           ForwardIt lower_bound( ForwardIt first, ForwardIt last, const T& value ); (until C++20) -->
   <!-- template< class ForwardIt, class T > constexpr ForwardIt lower_bound( ForwardIt first, ForwardIt last, const T& value ); (since C++20) -->
   <!-- TODO: template< class ForwardIt, class T, class Compare >           ForwardIt lower_bound( ForwardIt first, ForwardIt last, const T& value, Compare comp ); (until C++20) -->
@@ -7518,6 +8246,7 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
   <!-- template< class T1, class T2 > std::pair<V1,V2> make_pair( T1&& t, T2&& u ); // since C++11 until C++14 -->
   <!-- template< class T1, class T2 > constexpr std::pair<V1,V2> make_pair( T1&& t, T2&& u ); // since C++14 -->
   <function name="std::make_pair">
+    <pure/>
     <noreturn>false</noreturn>
     <use-retval/>
     <arg nr="1"/>
@@ -7530,11 +8259,36 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
     <use-retval/>
     <arg nr="1">
       <not-uninit/>
+    </arg>
+  </function>
+  <!-- template< class ForwardIt, class T >                bool binary_search( ForwardIt first, ForwardIt last, const T& value ); (until C++20) -->
+  <!-- template< class ForwardIt, class T >      constexpr bool binary_search( ForwardIt first, ForwardIt last, const T& value ); (since C++20) -->
+  <!-- template< class ForwardIt, class T, class Compare >           bool binary_search( ForwardIt first, ForwardIt last, const T& value, Compare comp ); (until C++20) -->
+  <!-- template< class ForwardIt, class T, class Compare > constexpr bool binary_search( ForwardIt first, ForwardIt last, const T& value, Compare comp ); (since C++20 -->
+  <function name="std::binary_search">
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
       <iterator container="1" type="first"/>
     </arg>
+    <arg nr="2" direction="in" >
+      <not-uninit/>
+      <iterator container="1" type="last"/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="in" default="0">
+      <not-uninit/>
+    </arg>
   </function>
   <!--#define offsetof(type, member) /*implementation-defined*/-->
   <function name="offsetof">
+    <pure/>
     <noreturn>false</noreturn>
     <returnValue type="std::size_t"/>
     <use-retval/>
@@ -7558,7 +8312,11 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
   <function name="std::next">
     <noreturn>false</noreturn>
     <use-retval/>
-    <arg nr="1"/>
+    <leak-ignore/>
+    <container yields="iterator"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
     <arg nr="2" direction="in" default="1">
       <not-uninit/>
     </arg>
@@ -7569,11 +8327,55 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
   <function name="std::prev">
     <noreturn>false</noreturn>
     <use-retval/>
-    <arg nr="1"/>
+    <leak-ignore/>
+    <container yields="iterator"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
     <arg nr="2" direction="in" default="1">
       <not-uninit/>
     </arg>
   </function>
+  <function name="std::size">
+    <pure/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <container yields="size"/>
+    <returnValue type="size_t"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <function name="std::ssize">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <container yields="size"/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <function name="std::empty">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <container yields="empty"/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <function name="std::data">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <container yields="buffer"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- template< class F, class... Args > /*unspecified*/ bind( F&& f, Args&&... args ); // since C++11 -->
   <!-- template< class R, class F, class... Args > /*unspecified*/ bind( F&& f, Args&&... args ); // since C++11 -->
   <function name="std::bind">
@@ -7584,52 +8386,482 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
     </arg>
     <arg nr="any"/>
   </function>
-  <memory>
-    <alloc init="false" buffer-size="malloc">malloc</alloc>
-    <alloc init="true" buffer-size="calloc">calloc</alloc>
-    <alloc init="false" buffer-size="malloc:2">aligned_alloc</alloc>
-    <realloc init="false" buffer-size="malloc:2">realloc</realloc>
-    <realloc init="false" buffer-size="calloc:2,3">reallocarray</realloc>
-    <dealloc>free</dealloc>
-  </memory>
-  <resource>
-    <alloc init="true">fopen</alloc>
-    <alloc init="true">tmpfile</alloc>
-    <realloc init="true" realloc-arg="3">freopen</realloc>
-    <dealloc>fclose</dealloc>
-  </resource>
-  <container id="stdContainer" endPattern="&gt; !!::" opLessAllowed="false" itEndPattern="&gt; :: iterator|const_iterator|reverse_iterator|const_reverse_iterator">
-    <type templateParameter="0"/>
-    <size>
-      <function name="resize" action="resize"/>
-      <function name="clear" action="clear"/>
-      <function name="size" yields="size"/>
-      <function name="empty" yields="empty"/>
-      <function name="erase" action="erase"/>
-      <function name="insert" action="insert" yields="iterator"/>
-      <function name="emplace" action="push" yields="iterator"/>
-      <function name="swap" action="change"/>
-      <function name="assign" action="change"/>
-    </size>
-    <access>
-      <function name="begin" yields="start-iterator"/>
-      <function name="cbegin" yields="start-iterator"/>
-      <function name="rbegin" yields="start-iterator"/>
-      <function name="crbegin" yields="start-iterator"/>
-      <function name="end" yields="end-iterator"/>
-      <function name="cend" yields="end-iterator"/>
+  <!--       T& std::map::at( const Key& key );       // since C++11 -->
+  <!-- const T& std::map::at( const Key& key ) const; // since C++11 -->
+  <!--       T& std::unordered_map::at( const Key& key );       // since C++11 -->
+  <!-- const T& std::unordered_map::at( const Key& key ) const; // since C++11 -->
+  <function name="std::map::at,std::unordered_map::at">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- (1) std::basic_streambuf<CharT, Traits>* std::ostringstream::rdbuf() const; -->
+  <!-- (2) std::basic_streambuf<CharT, Traits>* std::ostringstream::rdbuf( std::basic_streambuf<CharT, Traits>* sb ); -->
+  <function name="std::ostringstream::rdbuf">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in" default="nullptr">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- C Threads https://en.cppreference.com/w/c/thread -->
+  <!-- int thrd_create( thrd_t *thr, thrd_start_t func, void *arg ); // since C11 -->
+  <function name="thrd_create">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="2"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- thrd_t thrd_current(void); // since C11 -->
+  <function name="thrd_current">
+    <noreturn>false</noreturn>
+    <returnValue type="thrd_t"/>
+    <use-retval/>
+  </function>
+  <!-- int thrd_detach( thrd_t thr ); // since C11 -->
+  <function name="thrd_detach">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int thrd_equal( thrd_t lhs, thrd_t rhs ); // since C11 -->
+  <function name="thrd_equal">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- _Noreturn void thrd_exit( int res ); // since C11 -->
+  <function name="thrd_exit">
+    <noreturn>true</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int thrd_join( thrd_t thr, int *res ); // since C11 -->
+  <function name="thrd_join">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int thrd_sleep( const struct timespec* duration, struct timespec* remaining ); // since C11 -->
+  <function name="thrd_sleep">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void thrd_yield(void); // since C11 -->
+  <function name="thrd_yield">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+  </function>
+  <!-- Mutual exclusion https://en.cppreference.com/w/c/thread -->
+  <!-- void mtx_destroy( mtx_t *mutex ); // since C11 -->
+  <function name="mtx_destroy">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- char *strdup(const char *s); -->
+  <function name="strdup">
+    <noreturn>false</noreturn>
+    <returnValue type="char *"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int mtx_init( mtx_t* mutex, int type ); // since C11 -->
+  <function name="mtx_init">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int mtx_lock( mtx_t* mutex ); // since C11 -->
+  <function name="mtx_lock">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int mtx_timedlock( mtx_t *restrict mutex, const struct timespec *restrict time_point ); // since C11 -->
+  <function name="mtx_timedlock">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int mtx_trylock( mtx_t *mutex ); // since C11 -->
+  <function name="mtx_trylock">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int mtx_unlock( mtx_t *mutex ); // since C11 -->
+  <function name="mtx_unlock">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+    <!-- void std::string::shrink_to_fit(void) ; (since C++11) -->
+    <!-- void std::wstring::shrink_to_fit(void) ; (since C++11) -->
+  <function name="std::string::shrink_to_fit,std::wstring::shrink_to_fit,std::vector::shrink_to_fit">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+  </function>
+  <!-- bool std::bitset::all() const noexcept; (since C++11) -->
+  <!-- bool std::bitset::any() const; (until C++11) -->
+  <!-- bool std::bitset::any() const noexcept; (since C++11) -->
+  <!-- bool std::bitset::none() const; (until C++11) -->
+  <!-- bool std::bitset::none() const noexcept; (since C++11)-->
+  <function name="std::bitset::all,std::bitset::any,std::bitset::none">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <const/>
+  </function>
+  <!-- std::size_t std::bitset::count() const; (until C++11) -->
+  <!-- std::size_t  std::bitset::count() const noexcept; (since C++11)-->
+  <!-- std::size_t  std::bitset::size() const; (until C++11) -->
+  <!-- constexpr std::size_t std::bitset::size() const noexcept; (since C++11)-->
+  <function name="std::bitset::count,std::bitset::size">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <returnValue type="std::size_t"/>
+    <leak-ignore/>
+    <const/>
+  </function>
+  <!-- unsigned long long std::bitset::to_ullong() const ; (since C++11) -->
+  <function name="std::bitset::to_ullong">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <returnValue type="unsigned long long"/>
+    <leak-ignore/>
+    <const/>
+  </function>
+  <!-- unsigned long std::bitset::to_ulong() const ; -->
+  <function name="std::bitset::to_ulong">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <returnValue type="unsigned long"/>
+    <leak-ignore/>
+    <const/>
+  </function>
+  <!-- std::string std::bitset::to_string() const ; -->
+  <function name="std::bitset::to_string">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <returnValue type="std::string"/>
+    <leak-ignore/>
+    <const/>
+  </function>
+  <!-- bool std::bitset< N >::test( std::size_t pos ) const -->
+  <function name="std::bitset::test">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- std::bitset& std::bitset< N >::set( ) (until C++11) -->
+  <!-- std::bitset& std::bitset< N >::set( ) noexcept (since C++11) -->
+  <!-- std::bitset& std::bitset< N >::set( std::size_t pos, bool value = true ) noexcept (since C++11) -->
+  <function name="std::bitset::set">
+    <noreturn>false</noreturn>
+    <returnValue type="std::bitset &amp;"/>
+    <leak-ignore/>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- std::bitset& std::bitset< N >::reset( ) (until C++11) -->
+  <!-- std::bitset& std::bitset< N >::reset( ) noexcept (since C++11) -->
+  <!-- std::bitset& std::bitset< N >::reset( std::size_t pos ) noexcept (since C++11) -->
+  <!-- std::bitset& std::bitset< N >::flip( ) (until C++11) -->
+  <!-- std::bitset& std::bitset< N >::flip( ) noexcept (since C++11) -->
+  <!-- std::bitset& std::bitset< N >::flip( std::size_t pos ) noexcept (since C++11) -->
+  <function name="std::bitset::reset,std::bitset::flip">
+    <noreturn>false</noreturn>
+    <returnValue type="std::bitset &amp;"/>
+    <leak-ignore/>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- std::pair<iterator,iterator> std::map::equal_range( const Key& key ); -->
+  <!-- std::pair<const_iterator,const_iterator> std::map::equal_range( const Key& key ) const; -->
+  <!-- template< class K > std::pair<iterator,iterator> std::map::equal_range( const K& x ); // since C++14 -->
+  <!-- template< class K > std::pair<const_iterator,const_iterator> std::map::equal_range( const K& x ) const; // since C++14 -->
+  <function name="std::map::equal_range">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- iterator std::map::lower_bound( const Key& key ); -->
+  <!-- const_iterator lower_bound( const Key& key ) const; -->
+  <!-- template< class K > iterator std::map::lower_bound(const K& x); // since C++14 -->
+  <!-- template< class K > const_iterator std::map::lower_bound(const K& x) const; // since C++14 -->
+  <function name="std::map::lower_bound">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- iterator std::map::upper_bound( const Key& key ); -->
+  <!-- const_iterator std::map::upper_bound( const Key& key ) const; -->
+  <!-- template< class K > iterator std::map::upper_bound( const K& x ); // since C++14 -->
+  <!-- template< class K > const_iterator std::map::upper_bound( const K& x ) const; // since C++14 -->
+  <function name="std::map::upper_bound">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool std::map::contains( const Key& key ) const; // since C++20 -->
+  <!-- template< class K > bool std::map::contains( const K& x ) const; // since C++20 -->
+  <function name="std::map::contains">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <function name="std::span::first">
+    <use-retval/>
+    <returnValue type="std::span"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <function name="std::span::last">
+    <use-retval/>
+    <returnValue type="std::span"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <function name="std::span::subspan">
+    <use-retval/>
+    <returnValue type="std::span"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <function name="std::begin,std::cbegin,std::rbegin,std::crbegin">
+    <use-retval/>
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in"/>
+    <container yields="start-iterator"/>
+    <returnValue type="iterator" container="1"/>
+  </function>
+  <function name="std::end,std::cend,std::rend,std::crend">
+    <use-retval/>
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in"/>
+    <container yields="end-iterator"/>
+    <returnValue type="iterator" container="1"/>
+  </function>
+  <function name="std::auto_ptr::get,std::shared_ptr::get,std::unique_ptr::get,std::weak_ptr::get">
+    <use-retval/>
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+  </function>
+  <function name="std::auto_ptr::reset,std::shared_ptr::reset,std::unique_ptr::reset,std::weak_ptr::reset">
+    <noreturn>false</noreturn>
+    <arg nr="1" default="0">
+      <not-uninit/>
+    </arg>
+  </function>
+  <function name="std::auto_ptr::release,std::unique_ptr::release">
+    <use-retval/>
+    <noreturn>false</noreturn>
+  </function>
+  <function name="std::tie">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <arg nr="variadic">
+    </arg>
+  </function>
+  <function name="std::as_const">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <function name="std::exception::what,std::logic_error::what,std::invalid_argument::what,std::domain_error::what,std::length_error::what,std::out_of_range::what,std::future_error::what,std::runtime_error::what,std::range_error::what,std::overflow_error::what,std::underflow_error::what,std::regex_error::what,std::system_error::what,std::ios_base::failure::what,std::filesystem::filesystem_error::what,std::nonexistent_local_time::what,std::ambiguous_local_time::what,std::format_error::what,std::bad_typeid::what,std::bad_cast::what,std::bad_any_cast::what,std::bad_optional_access::what,std::bad_expected_access::what,std::bad_weak_ptr::what,std::bad_function_call::what,std::bad_alloc::what,std::bad_array_new_length::what,std::bad_exception::what,std::bad_variant_access::what">
+    <const/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <returnValue type="const char *"/>
+  </function>
+  <!-- https://en.cppreference.com/w/cpp/error/uncaught_exception -->
+  <!-- (until C++11):                                          bool std::uncaught_exception() throw();  -->
+  <!-- (since C++11) (deprecated in C++17) (removed in C++20): bool std::uncaught_exception() noexcept; -->
+  <function name="std::uncaught_exception">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- https://en.cppreference.com/w/cpp/error/uncaught_exception -->
+  <!-- (since C++17) (constexpr since C++26): int std::uncaught_exceptions() noexcept; -->
+  <function name="std::uncaught_exceptions">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <memory>
+    <alloc init="false" buffer-size="malloc">malloc,std::malloc</alloc>
+    <alloc init="true" buffer-size="calloc">calloc,std::calloc</alloc>
+    <alloc init="false" buffer-size="malloc:2">aligned_alloc,std::aligned_alloc</alloc>
+    <realloc init="false" buffer-size="malloc:2">realloc,std::realloc</realloc>
+    <dealloc>free,std::free</dealloc>
+  </memory>
+  <memory>
+    <alloc init="true" buffer-size="strdup">strdup,std::strdup</alloc>
+    <dealloc>free,std::free</dealloc>
+  </memory>
+  <resource>
+    <alloc init="true">fopen,std::fopen</alloc>
+    <alloc init="true">tmpfile,std::tmpfile</alloc>
+    <realloc init="true" realloc-arg="3">freopen,std::freopen</realloc>
+    <dealloc>fclose,std::fclose</dealloc>
+  </resource>
+  <container id="stdContainer" endPattern="&gt; !!::" opLessAllowed="false" itEndPattern="&gt; :: iterator|const_iterator|reverse_iterator|const_reverse_iterator" hasInitializerListConstructor="true">
+    <type templateParameter="0"/>
+    <size>
+      <function name="resize" action="resize"/>
+      <function name="clear" action="clear"/>
+      <function name="size" yields="size" returnType="std::size_t"/>
+      <function name="empty" yields="empty" returnType="bool"/>
+      <function name="erase" action="erase"/>
+      <function name="insert" action="insert" yields="iterator"/>
+      <function name="emplace" action="push" yields="iterator"/>
+      <function name="swap" action="change"/>
+      <function name="assign" action="change"/>
+    </size>
+    <access>
+      <function name="begin" yields="start-iterator"/>
+      <function name="cbegin" yields="start-iterator"/>
+      <function name="rbegin" yields="start-iterator"/>
+      <function name="crbegin" yields="start-iterator"/>
+      <function name="end" yields="end-iterator"/>
+      <function name="cend" yields="end-iterator"/>
       <function name="rend" yields="end-iterator"/>
       <function name="crend" yields="end-iterator"/>
     </access>
   </container>
-  <container id="stdVectorDeque" startPattern="std :: vector|deque &lt;" inherits="stdContainer" opLessAllowed="true">
+  <container id="stdVectorDeque" inherits="stdContainer" opLessAllowed="true">
     <size>
       <function name="push_back" action="push"/>
       <function name="emplace_back" action="push"/>
       <function name="pop_back" action="pop"/>
       <function name="push_front" action="push"/>
       <function name="emplace_front" action="push"/>
-      <function name="pop_front" action="pop"/>
     </size>
     <access indexOperator="array-like">
       <function name="at" yields="at_index"/>
@@ -7640,9 +8872,22 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
       <function name="reserve" action="change-internal"/>
     </access>
   </container>
+  <container id="stdVector" startPattern="std :: vector &lt;" inherits="stdVectorDeque">
+    <type unstable="erase insert"/>
+    <access>
+      <function name="emplace_back" action="push" yields="item"/>
+      <function name="emplace_front" action="push" yields="item"/>
+    </access>
+  </container>
+  <container id="stdDeque" startPattern="std :: deque &lt;" inherits="stdVectorDeque">
+    <type unstable="erase insert"/>
+    <size>
+      <function name="pop_front" action="pop"/>
+    </size>
+  </container>
   <container id="stdArray" startPattern="std :: array &lt;" inherits="stdContainer" opLessAllowed="true">
     <size templateParameter="1">
-      <function name="max_size" yields="size"/>
+      <function name="max_size" yields="size" returnType="std::size_t"/>
     </size>
     <access indexOperator="array-like">
       <function name="at" yields="at_index"/>
@@ -7656,16 +8901,18 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
     <size templateParameter="0"/>
     <access indexOperator="array-like"/>
   </container>
-  <container id="stdQueue" startPattern="std :: queue|priority_queue &lt;" inherits="stdContainer">
+  <container id="stdQueue" startPattern="std :: queue &lt;" inherits="stdContainer">
     <access>
+      <function name="emplace" action="push" yields="item"/>
       <function name="push" action="push"/>
       <function name="pop" action="pop"/>
       <function name="front" yields="item"/>
       <function name="back" yields="item"/>
     </access>
   </container>
-  <container id="stdStack" startPattern="std :: stack &lt;" inherits="stdContainer">
+  <container id="stdStack" startPattern="std :: stack|priority_queue &lt;" inherits="stdContainer">
     <access>
+      <function name="emplace" action="push" yields="item"/>
       <function name="push" action="push"/>
       <function name="pop" action="pop"/>
       <function name="top" yields="item"/>
@@ -7684,8 +8931,11 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
   </container>
   <container id="stdMultiMap" startPattern="std :: multimap|unordered_multimap &lt;" inherits="stdContainer">
     <type templateParameter="1" associative="std-like"/>
+    <rangeItemRecordType>
+      <member name="first" templateParameter="0"/>
+      <member name="second" templateParameter="1"/>
+    </rangeItemRecordType>
     <access>
-      <function name="at" yields="at_index"/>
       <function name="count" action="find"/>
       <function name="find" action="find" yields="iterator"/>
       <function name="emplace_hint" action="push" yields="iterator"/>
@@ -7708,16 +8958,17 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
       <function name="emplace" action="push"/>
       <function name="try_emplace" action="push"/>
       <function name="insert_or_assign" action="push"/>
+      <function name="at" yields="at_index"/>
     </access>
   </container>
   <container id="stdList" startPattern="std :: list|forward_list &lt;" inherits="stdContainer">
     <size>
       <function name="push_back" action="push"/>
-      <function name="emplace_back" action="push"/>
+      <function name="emplace_back" action="push" yields="item"/>
       <function name="emplace_after" action="push"/>
       <function name="pop_back" action="pop"/>
       <function name="push_front" action="push"/>
-      <function name="emplace_front" action="push"/>
+      <function name="emplace_front" action="push" yields="item"/>
       <function name="pop_front" action="pop"/>
       <function name="erase_after" action="erase"/>
       <function name="insert_after" action="insert"/>
@@ -7737,15 +8988,16 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
       <function name="sort" action="change-content"/>
     </access>
   </container>
-  <container id="stdAllString" inherits="stdContainer" opLessAllowed="true">
-    <type string="std-like"/>
+  <container id="stdAllString" inherits="stdContainer" opLessAllowed="true" hasInitializerListConstructor="false">
+    <type string="std-like" unstable="erase insert"/>
     <size>
       <function name="push_back" action="push"/>
       <function name="pop_back" action="pop"/>
-      <function name="append" action="change"/>
+      <function name="append" action="append"/>
       <function name="replace" action="change"/>
       <function name="reserve" action="change-internal"/>
       <function name="shrink_to_fit" action="change-internal"/>
+      <function name="length" yields="size" returnType="std::size_t"/>
     </size>
     <access indexOperator="array-like">
       <function name="at" yields="at_index"/>
@@ -7753,23 +9005,111 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
       <function name="back" yields="item"/>
       <function name="data" yields="buffer"/>
       <function name="c_str" yields="buffer-nt"/>
-      <function name="length" yields="size"/>
-      <function name="find" action="find"/>
-      <function name="rfind" action="find"/>
-      <function name="find_last_of" action="find"/>
-      <function name="find_last_not_of" action="find"/>
-      <function name="find_first_of" action="find"/>
-      <function name="find_first_not_of" action="find"/>
+      <function name="find" action="find-const"/>
+      <function name="rfind" action="find-const"/>
+      <function name="find_last_of" action="find-const"/>
+      <function name="find_last_not_of" action="find-const"/>
+      <function name="find_first_of" action="find-const"/>
+      <function name="find_first_not_of" action="find-const"/>
     </access>
   </container>
   <container id="stdBasicString" startPattern="std :: basic_string &lt;" inherits="stdAllString">
     <type templateParameter="0"/>
   </container>
   <container id="stdString" startPattern="std :: string|wstring|u16string|u32string" endPattern="" inherits="stdAllString"/>
-  <smart-pointer class-name="std::auto_ptr"/>
+  <container id="stdAllStringView" inherits="stdAllString" view="true">
+    <size>
+      <function name="remove_prefix" action="change"/>
+      <function name="remove_suffix" action="change"/>
+    </size>
+  </container>
+  <container id="stdBasicStringView" startPattern="std :: basic_string_view &lt;" inherits="stdAllStringView">
+    <type templateParameter="0"/>
+  </container>
+  <container id="stdInitializerList" startPattern="std :: initializer_list &lt;" endPattern="&gt; !!::" opLessAllowed="false" itEndPattern="&gt; :: iterator|const_iterator" hasInitializerListConstructor="true">
+    <type templateParameter="0"/>
+    <size>
+      <function name="size" yields="size" returnType="std::size_t"/>
+    </size>
+    <access>
+      <function name="begin" yields="start-iterator"/>
+      <function name="end" yields="end-iterator"/>
+    </access>
+  </container>
+  <container id="stdStringView" startPattern="std :: string_view|wstring_view|u16string_view|u32string_view" endPattern="" inherits="stdAllStringView"/>
+  <container id="stdExperimentalStringView" startPattern="std :: experimental :: string_view|wstring_view|u16string_view|u32string_view" endPattern="" inherits="stdAllStringView"/>
+  <container id="stdExperimentalBasicStringView" startPattern="std :: experimental :: basic_string_view &lt;" inherits="stdBasicStringView" />
+  <container id="stdSpan" startPattern="std :: span" endPattern="" inherits="stdContainer" view="true">
+    <access indexOperator="array-like">
+      <function name="front" yields="item"/>
+      <function name="back" yields="item"/>
+      <function name="data" yields="buffer"/>
+    </access>
+  </container>
+  <smart-pointer class-name="std::auto_ptr">
+    <unique/>
+  </smart-pointer>
   <smart-pointer class-name="std::shared_ptr"/>
-  <smart-pointer class-name="std::unique_ptr"/>
+  <smart-pointer class-name="std::unique_ptr">
+    <unique/>
+  </smart-pointer>
   <smart-pointer class-name="std::weak_ptr"/>
+  <type-checks>
+    <unusedvar>
+      <suppress>std::fstream</suppress>
+      <suppress>std::wfstream</suppress>
+      <suppress>std::ofstream</suppress>
+      <suppress>std::wofstream</suppress>
+      <suppress>std::basic_fstream</suppress>
+      <suppress>std::basic_ofstream</suppress>
+      <checkFiniteLifetime>std::insert_iterator</checkFiniteLifetime>
+      <checkFiniteLifetime>std::lock_guard</checkFiniteLifetime>
+      <checkFiniteLifetime>std::scoped_lock</checkFiniteLifetime>
+      <checkFiniteLifetime>std::unique_lock</checkFiniteLifetime>
+      <checkFiniteLifetime>std::shared_lock</checkFiniteLifetime>
+      <check>std::pair</check>
+      <check>std::complex</check>
+      <check>std::exception</check>
+      <check>std::logic_error</check>
+      <check>std::domain_error</check>
+      <check>std::invalid_argument</check>
+      <check>std::length_error</check>
+      <check>std::out_of_range</check>
+      <check>std::future_error</check>
+      <check>std::runtime_error</check>
+      <check>std::range_error</check>
+      <check>std::overflow_error</check>
+      <check>std::underflow_error</check>
+      <check>std::regex_error</check>
+      <check>std::system_error</check>
+      <check>std::format_error</check>
+      <check>std::bad_typeid</check>
+      <check>std::bad_cast</check>
+      <check>std::monostate</check>
+      <check>std::bad_optional_access</check>
+      <check>std::bad_expected_access</check>
+      <check>std::bad_weak_ptr</check>
+      <check>std::bad_function_call</check>
+      <check>std::bad_alloc</check>
+      <check>std::bad_array_new_length</check>
+      <check>std::bad_exception</check>
+      <check>std::ios_base::failure</check>
+      <check>std::filesystem::filesystem_error</check>
+      <check>std::bad_variant_access</check>
+      <check>std::span</check>
+      <check>std::stringstream</check>
+      <check>std::wstringstream</check>
+      <check>std::istringstream</check>
+      <check>std::wistringstream</check>
+      <check>std::ostringstream</check>
+      <check>std::wostringstream</check>
+    </unusedvar>
+    <operatorEqVarError>
+      <suppress>std::mutex</suppress>
+      <suppress>std::recursive_mutex</suppress>
+    </operatorEqVarError>
+  </type-checks>
+  <podtype name="char8_t,std::char8_t" sign="u" size="1"/>
   <podtype name="char16_t,std::char16_t" sign="u" size="2"/>
   <podtype name="char32_t,std::char32_t" sign="u" size="4"/>
   <podtype name="int8_t,std::int8_t" sign="s" size="1"/>
@@ -7800,7 +9140,6 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
   <podtype name="uintptr_t,std::uintptr_t" sign="u"/>
   <podtype name="intmax_t,std::intmax_t" sign="s"/>
   <podtype name="uintmax_t,std::uintmax_t" sign="u"/>
-  <podtype name="size_t,std::size_t" sign="u"/>
   <podtype name="std::string::size_type" sign="u"/>
   <podtype name="std::wstring::size_type" sign="u"/>
   <podtype name="std::u16string::size_type" sign="u"/>
@@ -7845,6 +9184,7 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
   <podtype name="std::atomic_ulong" stdtype="long" sign="u"/>
   <podtype name="std::atomic_llong" stdtype="long long" sign="s"/>
   <podtype name="std::atomic_ullong" stdtype="long long" sign="u"/>
+  <podtype name="std::atomic_char8_t" size="1"/>
   <podtype name="std::atomic_char16_t" size="2"/>
   <podtype name="std::atomic_char32_t" size="4"/>
   <podtype name="std::atomic_wchar_t" size="2"/>
@@ -7871,11 +9211,22 @@ initializer list (7) string& replace (const_iterator i1, const_iterator i2, init
   <podtype name="std::atomic_intmax_t"/>
   <podtype name="std::atomic_uintmax_t"/>
   <!-- https://en.cppreference.com/w/c/program/SIG_types
-		Values are in alignment with posix.cfg -->
+        Values are in alignment with posix.cfg -->
   <define name="SIGTERM" value="15"/>
   <define name="SIGSEGV" value="11"/>
   <define name="SIGINT" value="2"/>
   <define name="SIGKILL" value="9"/>
   <define name="SIGABRT" value="6"/>
   <define name="SIGFPE" value="8"/>
+  <!-- http://www.cplusplus.com/reference/cstdio/fseek/ -->
+  <define name="SEEK_CUR" value="1"/>
+  <define name="SEEK_END" value="2"/>
+  <define name="SEEK_SET" value="0"/>
+  <!-- https://en.cppreference.com/w/c/numeric/fenv/FE_exceptions -->
+  <define name="FE_INEXACT" value="1"/>
+  <define name="FE_UNDERFLOW" value="2"/>
+  <define name="FE_OVERFLOW" value="4"/>
+  <define name="FE_DIVBYZERO" value="8"/>
+  <define name="FE_INVALID" value="16"/>
+  <define name="FE_ALL_EXCEPT" value="31"/>
 </def>
diff --git a/cfg/tinyxml2.cfg b/cfg/tinyxml2.cfg
index 2fdee227bc6..e652fa9c11d 100644
--- a/cfg/tinyxml2.cfg
+++ b/cfg/tinyxml2.cfg
@@ -1,24 +1,5 @@
 <?xml version="1.0"?>
 <def format="2">
-  <define name="XML_SUCCESS" value="0"/>
-  <define name="XML_NO_ATTRIBUTE" value="1"/>
-  <define name="XML_WRONG_ATTRIBUTE_TYPE" value="2"/>
-  <define name="XML_ERROR_FILE_NOT_FOUND" value="3"/>
-  <define name="XML_ERROR_FILE_COULD_NOT_BE_OPENED" value="4"/>
-  <define name="XML_ERROR_FILE_READ_ERROR" value="5"/>
-  <define name="XML_ERROR_PARSING_ELEMENT" value="6"/>
-  <define name="XML_ERROR_PARSING_ATTRIBUTE" value="7"/>
-  <define name="XML_ERROR_PARSING_TEXT" value="8"/>
-  <define name="XML_ERROR_PARSING_COMMENT" value="9"/>
-  <define name="XML_ERROR_PARSING_DECLARATION" value="10"/>
-  <define name="XML_ERROR_PARSING_UNKNOWN" value="11"/>
-  <define name="XML_ERROR_EMPTY_DOCUMENT" value="12"/>
-  <define name="XML_ERROR_MISMATCHED_ELEMENT" value="13"/>
-  <define name="XML_ERROR_PARSING" value="14"/>
-  <define name="XML_CAN_NOT_CONVERT_TEXT" value="15"/>
-  <define name="XML_NO_TEXT_NODE" value="16"/>
-  <define name="XML_ELEMENT_DEPTH_EXCEEDED" value="17"/>
-  <define name="XML_ERROR_COUNT" value="18"/>
   <!-- tinyxml2::XMLError tinyxml2::XMLDocument::LoadFile( const char* filename ) -->
   <!-- tinyxml2::XMLError tinyxml2::XMLDocument::LoadFile( FILE* ) -->
   <function name="tinyxml2::XMLDocument::LoadFile">
diff --git a/cfg/vcl.cfg b/cfg/vcl.cfg
new file mode 100644
index 00000000000..bf288ce32b1
--- /dev/null
+++ b/cfg/vcl.cfg
@@ -0,0 +1,4 @@
+<?xml version="1.0"?>
+<def format="2">
+  <!-- Embarcadero Visual Component Library -->
+</def>
diff --git a/cfg/windows.cfg b/cfg/windows.cfg
index 586dcef3481..d698f320d3f 100644
--- a/cfg/windows.cfg
+++ b/cfg/windows.cfg
@@ -1188,6 +1188,12 @@
     <dealloc>FreeLibrary</dealloc>
     <dealloc>FreeLibraryAndExitThread</dealloc>
   </resource>
+  <memory>
+    <alloc arg="2">UuidToString</alloc>
+    <alloc arg="2">UuidToStringA</alloc>
+    <alloc arg="2">UuidToStringW</alloc>
+    <dealloc>RpcStringFree</dealloc>
+  </memory>
   <memory>
     <alloc buffer-size="malloc:2">ExAllocatePool</alloc>
     <alloc buffer-size="malloc:2">ExAllocatePoolWithQuota</alloc>
@@ -1197,6 +1203,12 @@
     <dealloc>ExFreePool</dealloc>
     <dealloc>ExFreePoolWithTag</dealloc>
   </memory>
+  <memory>
+    <alloc init="false" arg="1">_dupenv_s</alloc>
+    <alloc init="false" arg="1">_wdupenv_s</alloc>
+    <alloc init="false" arg="1">_tdupenv_s</alloc>
+    <dealloc>free</dealloc>
+  </memory>
   <memory>
     <alloc buffer-size="malloc:3">HeapAlloc</alloc>
     <alloc>HeapReAlloc</alloc>
@@ -1343,6 +1355,23 @@
       <not-bool/>
       <valid>0:</valid>
     </arg>
+  </function>
+    <!-- errno_t _access_s(const char *path, int mode); -->
+    <!-- errno_t _waccess_s(const wchar_t *path, int mode); -->
+  <function name="_access_s,_waccess_s,_taccess_s">
+    <use-retval/>
+    <returnValue type="errno_t"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
   <!--VOID RtlCopyBytes(
   _Out_       PVOID  Destination,
@@ -1382,6 +1411,69 @@
     </arg>
     <warn severity="style" reason="Obsolete" alternatives="RtlFillMemory"/>
   </function>
+  <!-- unsigned int _get_output_format(); -->
+  <function name="_get_output_format">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="unsigned int"/>
+    <warn severity="style" reason="Obsolete" alternatives="No_alternatives_available"/>
+  </function>
+  <!-- int _heapadd(void *memblock, size_t size); -->
+  <function name="_heapadd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <warn severity="style" reason="Obsolete" alternatives="No_alternatives_available"/>
+  </function>
+  <!-- char *_cgets(char *buffer); -->
+  <!-- template <size_t size> char *_cgets(char (&buffer)[size]); // C++ only -->
+  <function name="_cgets">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="char *"/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+    <warn severity="style" reason="Obsolete" alternatives="_cgets_s"/>
+  </function>
+  <!-- wchar_t *_cgetws(wchar_t *buffer); -->
+  <!-- wchar_t *_getws(wchar_t *buffer); -->
+  <!-- template <size_t size> wchar_t *_cgetws(wchar_t (&buffer)[size]); // C++ only -->
+  <function name="_cgetws,_getws">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="wchar_t *"/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+    <warn severity="style" reason="Obsolete" alternatives="_cgetws_s,_getws_s"/>
+  </function>
+  <!-- int _iswctype( wint_t wc, wctype_t desc ); -->
+  <!-- int is_wctype( wint_t wc, wctype_t desc ); -->
+  <function name="_iswctype,is_wctype">
+    <use-retval/>
+    <pure/>
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <warn severity="style" reason="Obsolete" alternatives="iswctype"/>
+  </function>
   <!--PVOID RtlSecureZeroMemory(
   _Out_ PVOID  ptr,
   _In_  SIZE_T cnt);-->
@@ -1462,6 +1554,7 @@
       <formatstr/>
       <not-uninit/>
       <not-null/>
+      <strz/>
     </arg>
   </function>
   <!-- int fprintf_s(FILE *stream, const char *format [, argument ]...); -->
@@ -1474,6 +1567,7 @@
       <formatstr/>
       <not-uninit/>
       <not-null/>
+      <strz/>
     </arg>
   </function>
   <!-- int fwprintf_s(FILE *stream, const wchar_t *format [, argument ]...); -->
@@ -1486,6 +1580,7 @@
       <formatstr/>
       <not-uninit/>
       <not-null/>
+      <strz/>
     </arg>
   </function>
   <!-- int _snprintf_s(char *buffer, size_t sizeOfBuffer, size_t count, const char *format [, argument] ...); -->
@@ -1535,6 +1630,30 @@
       <not-null/>
     </arg>
   </function>
+  <!-- DWORD MsgWaitForMultipleObjectsEx(DWORD nCount, const HANDLE *pHandles, DWORD dwMilliseconds, DWORD dwWakeMask, DWORD dwFlags); -->
+  <function name="MsgWaitForMultipleObjectsEx">
+    <noreturn>false</noreturn>
+    <returnValue type="DWORD"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- ULONG DbgPrintEx(ULONG ComponentId, ULONG Level, PCSTR Format, ...); -->
   <function name="DbgPrintEx">
     <noreturn>false</noreturn>
@@ -1562,6 +1681,24 @@
     </arg>
     <arg nr="4"/>
   </function>
+  <!-- errno_t _dupenv_s(char **buffer, size_t *numberOfElements, const char *varname);
+       errno_t _wdupenv_s(wchar_t **buffer, size_t *numberOfElements, const wchar_t *varname); -->
+  <function name="_dupenv_s,_wdupenv_s,_tdupenv_s">
+    <noreturn>false</noreturn>
+    <returnValue type="errno_t"/>
+    <arg nr="1" direction="out">
+      <not-null/>
+      <minsize type="argvalue" arg="2"/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
   <!-- ULONG vDbgPrintExWithPrefix(PCCH Prefix, ULONG ComponentId, ULONG Level, PCCH Format, va_list arglist); -->
   <function name="vDbgPrintExWithPrefix">
     <noreturn>false</noreturn>
@@ -1586,6 +1723,7 @@
       <formatstr/>
       <not-uninit/>
       <not-null/>
+      <strz/>
     </arg>
   </function>
   <!-- int wscanf_s(const wchar_t *format [, argument]...); -->
@@ -1597,6 +1735,7 @@
       <formatstr/>
       <not-uninit/>
       <not-null/>
+      <strz/>
     </arg>
   </function>
   <!-- int sscanf_s(const char *buffer, const char *format [, argument ] ...); -->
@@ -1611,6 +1750,7 @@
       <formatstr/>
       <not-uninit/>
       <not-null/>
+      <strz/>
     </arg>
   </function>
   <!-- int fscanf_s(FILE *stream, const char *format [, argument ]...); -->
@@ -1622,6 +1762,7 @@
       <formatstr/>
       <not-uninit/>
       <not-null/>
+      <strz/>
     </arg>
   </function>
   <!-- int fwscanf_s(FILE *stream, const wchar_t *format [, argument ]...); -->
@@ -1633,6 +1774,7 @@
       <formatstr/>
       <not-uninit/>
       <not-null/>
+      <strz/>
     </arg>
   </function>
   <!-- int swscanf_s(const wchar_t *buffer, const wchar_t *format [, argument ] ...); -->
@@ -1647,13 +1789,14 @@
       <formatstr/>
       <not-uninit/>
       <not-null/>
+      <strz/>
     </arg>
   </function>
   <!-- BOOL WINAPI CloseHandle(_In_  HANDLE hObject); -->
   <function name="CloseHandle">
     <noreturn>false</noreturn>
     <returnValue type="BOOL"/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-uninit/>
     </arg>
   </function>
@@ -1686,6 +1829,121 @@
     <returnValue type="LPWSTR"/>
     <use-retval/>
   </function>
+  <!-- LPWSTR lstrcpyW( LPWSTR  lpString1, LPCWSTR lpString2); -->
+  <function name="lstrcpyW">
+    <returnValue type="LPWSTR">arg1</returnValue>
+    <noreturn>false</noreturn>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" strlen-arg="2"/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+      <minsize type="strlen" arg="2"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- LPSTR lstrcpyA(LPSTR  lpString1, LPCSTR lpString2); -->
+  <function name="lstrcpyA">
+    <returnValue type="LPSTR">arg1</returnValue>
+    <noreturn>false</noreturn>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" strlen-arg="2"/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+      <minsize type="strlen" arg="2"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- LPWSTR lstrcpynW(LPWSTR destination, LPCWSTR source, int iMaxLength);-->
+  <function name="lstrcpynW">
+    <noreturn>false</noreturn>
+    <returnValue type="LPWSTR"/>
+    <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="3"/>
+    <arg nr="1" direction="out">
+      <not-null/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <valid>1:</valid>
+    </arg>
+    <warn severity="style">Security Warning: Consider using StringCchCopy instead. Using this function incorrectly can compromise the security of your application. This function uses structured exception handling (SEH) to catch access violations and other errors. When this function catches SEH errors, it returns NULL without null-terminating the string and without notifying the caller of the error. The caller is not safe to assume that insufficient space is the error condition.</warn>
+  </function>
+  <!-- LPSTR lstrcpynA(LPSTR  destination, LPCSTR  source, int iMaxLength);-->
+  <function name="lstrcpynA">
+    <noreturn>false</noreturn>
+    <returnValue type="LPSTR"/>
+    <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="3"/>
+    <arg nr="1" direction="out">
+      <not-null/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <valid>1:</valid>
+    </arg>
+    <warn severity="style">Security Warning: Consider using StringCchCopy instead. Using this function incorrectly can compromise the security of your application. This function uses structured exception handling (SEH) to catch access violations and other errors. When this function catches SEH errors, it returns NULL without null-terminating the string and without notifying the caller of the error. The caller is not safe to assume that insufficient space is the error condition.</warn>
+  </function>
+  <!-- STRSAFEAPI StringCchCopyA(STRSAFE_LPSTR  pszDest, size_t cchDest, STRSAFE_LPCSTR pszSrc);-->
+  <!-- STRSAFEAPI StringCchCopyW(STRSAFE_LPSTR  pszDest, size_t cchDest, STRSAFE_LPCSTR pszSrc);-->
+  <function name="StringCchCopy,StringCchCopyA,StringCchCopyW">
+    <noreturn>false</noreturn>
+    <returnValue type="STRSAFEAPI"/>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+      <minsize type="argvalue" arg="2"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <valid>1:</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int _utime(const char *filename, struct _utimbuf *times); -->
+  <!-- int _utime32(const char *filename, struct __utimbuf32 *times); -->
+  <!-- int _utime64(const char *filename, struct __utimbuf64 *times); -->
+  <!-- int _wutime(const wchar_t *filename, struct _utimbuf *times); -->
+  <!-- int _wutime32(const wchar_t *filename, struct __utimbuf32 *times); -->
+  <!-- int _wutime64(const wchar_t *filename, struct __utimbuf64 *times); -->
+  <function name="_utime,_utime32,_utime64,_wutime,_wutime32,_wutime64">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
   <!-- BOOL GetCommState(HANDLE hFile, LPDCB  lpDCB); -->
   <function name="GetCommState">
     <noreturn>false</noreturn>
@@ -1697,6 +1955,41 @@
       <not-null/>
     </arg>
   </function>
+  <!-- BOOL ReadDirectoryChangesW(
+  HANDLE                          hDirectory,
+  LPVOID                          lpBuffer,
+  DWORD                           nBufferLength,
+  BOOL                            bWatchSubtree,
+  DWORD                           dwNotifyFilter,
+  LPDWORD                         lpBytesReturned,
+  LPOVERLAPPED                    lpOverlapped,
+  LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
+); -->
+  <function name="ReadDirectoryChangesW">
+    <noreturn>false</noreturn>
+    <returnValue type="BOOL"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-uninit/>
+      <not-null/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <valid>1:</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="6" direction="out"/>
+    <arg nr="7" direction="out"/>
+    <arg nr="8" direction="in"/>
+  </function>
   <!-- BOOL WINAPI BuildCommDCB(
   _In_   LPCTSTR lpDef,
   _Out_  LPDCB lpDCB); -->
@@ -1896,6 +2189,7 @@
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="inout">
       <not-null/>
@@ -1918,6 +2212,7 @@
     <arg nr="2" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="3" direction="inout">
       <not-null/>
@@ -1948,7 +2243,7 @@
     <noreturn>false</noreturn>
     <returnValue type="HRESULT"/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-uninit/>
     </arg>
     <arg nr="2" direction="in">
@@ -1997,10 +2292,11 @@
       <not-uninit/>
     </arg>
   </function>
-  <!-- int _stricmp_l(const char *string1, const char *string2, _locale_t locale);  -->
-  <!-- int _wcsicmp_l(const wchar_t *string1, const wchar_t *string2, _locale_t locale); -->
-  <!-- int _mbsicmp_l(const wchar_t *string1, const wchar_t *string2, _locale_t locale); -->
-  <function name="_stricmp_l,_wcsicmp_l,_mbsicmp_l">
+  <!-- int _stricmp(const char *s1, const char *s2); -->
+  <!-- int _wcsicmp(const wchar_t *s1, const wchar_t *s2); -->
+  <!-- int _mbsicmp(const unsigned char *string1, const unsigned char *string2); -->
+  <!-- https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/stricmp-wcsicmp-mbsicmp-stricmp-l-wcsicmp-l-mbsicmp-l?view=msvc-170  -->
+  <function name="_stricmp,_wcsicmp,_mbsicmp,_tcsicmp">
     <noreturn>false</noreturn>
     <returnValue type="int"/>
     <leak-ignore/>
@@ -2008,32 +2304,69 @@
     <arg nr="1" direction="in">
       <not-uninit/>
       <not-null/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
       <not-null/>
+      <strz/>
     </arg>
-    <arg nr="3" direction="in">
+  </function>
+  <!-- int stricmp(const char *s1, const char *s2); -->
+  <!-- https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/stricmp-wcsicmp?view=msvc-170 -->
+  <function name="stricmp">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <use-retval/>
+    <warn severity="style" reason="Obsolescent" alternatives="_stricmp"/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
     </arg>
   </function>
-  <!-- int stricmp(const char *s1, const char *s2); -->
-  <!-- int _stricmp(const char *s1, const char *s2); -->
   <!-- int wcsicmp(const wchar_t *s1, const wchar_t *s2); -->
-  <!-- int _wcsicmp(const wchar_t *s1, const wchar_t *s2); -->
-  <!-- int _mbsicmp(const unsigned char *string1, const unsigned char *string2); -->
-  <function name="stricmp,_stricmp,wcsicmp,_wcsicmp,_mbsicmp,_tcsicmp">
+  <!-- https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/stricmp-wcsicmp?view=msvc-170 -->
+  <function name="wcsicmp">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+    <use-retval/>
+    <warn severity="style" reason="Obsolescent" alternatives="_wcsicmp"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int strcmpi(const char *s1, const char *s2); -->
+  <!-- https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/strcmpi?view=msvc-170  -->
+  <function name="strcmpi">
     <noreturn>false</noreturn>
     <returnValue type="int"/>
     <leak-ignore/>
     <use-retval/>
+    <warn severity="style" alternatives="_stricmp" reason="Obsolete">It is recommend you use _stricmp instead.</warn>
     <arg nr="1" direction="in">
       <not-uninit/>
       <not-null/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
       <not-null/>
+      <strz/>
     </arg>
   </function>
   <!-- DWORD WINAPI GetFileAttributes(_In_ LPCTSTR lpFileName);-->
@@ -2096,7 +2429,7 @@
     implemented in Cppcheck. It can not (yet) be configured in the configuration
     file. See #8381 -->
   </function>
-  <!-- int _sprintf_s_l(char *buffer, size_t sizeOfBuffer, const char *format, locale_t locale, ... ); 
+  <!-- int _sprintf_s_l(char *buffer, size_t sizeOfBuffer, const char *format, locale_t locale, ... );
        int _swprintf_s_l(wchar_t *buffer, size_t sizeOfBuffer, const wchar_t *format, locale_t locale, ...);-->
   <function name="_sprintf_s_l,_swprintf_s_l">
     <noreturn>false</noreturn>
@@ -2114,6 +2447,7 @@
       <formatstr/>
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="4" direction="in">
       <not-uninit/>
@@ -2145,7 +2479,7 @@
     <arg nr="7" direction="inout"/>
     <arg nr="8" direction="out"/>
   </function>
-  <!-- 
+  <!--
 HFONT CreateFont(
   _In_  int nHeight,
   _In_  int nWidth,
@@ -2218,11 +2552,12 @@ HFONT CreateFont(
     <arg nr="3" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="4"/>
   </function>
-  <!-- int _vsnprintf_l (char *buffer   , size_t count, const char *format, locale_t locale,  va_list argptr); 
-       int _vsnwprintf_l(wchar_t *buffer, size_t count, const wchar_t *format, locale_t locale, va_list argptr); 
+  <!-- int _vsnprintf_l (char *buffer   , size_t count, const char *format, locale_t locale,  va_list argptr);
+       int _vsnwprintf_l(wchar_t *buffer, size_t count, const wchar_t *format, locale_t locale, va_list argptr);
        int _vswprintf_l(wchar_t *buffer,  size_t count, const wchar_t *format, locale_t locale, va_list argptr);-->
   <function name="_vsnprintf_l,_vsnwprintf_l,_vswprintf_l">
     <noreturn>false</noreturn>
@@ -2239,13 +2574,14 @@ HFONT CreateFont(
     <arg nr="3" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="4" direction="in">
       <not-uninit/>
     </arg>
     <arg nr="5"/>
   </function>
-  <!-- int vsnprintf_s(char *buffer, size_t sizeOfBuffer, size_t count, const char *format, va_list argptr); 
+  <!-- int vsnprintf_s(char *buffer, size_t sizeOfBuffer, size_t count, const char *format, va_list argptr);
        int _vsnprintf_s( char *buffer, size_t sizeOfBuffer, size_t count, const char *format, va_list argptr);
        int _vsnwprintf_s( wchar_t *buffer, size_t sizeOfBuffer, size_t count, const wchar_t *format, va_list argptr); -->
   <function name="vsnprintf_s,_vsnprintf_s,_vsnwprintf_s">
@@ -2267,10 +2603,11 @@ HFONT CreateFont(
     <arg nr="4" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="5"/>
   </function>
-  <!-- int _vsnprintf_s_l(char *buffer, size_t sizeOfBuffer, size_t count, const char *format, locale_t locale,  va_list argptr); 
+  <!-- int _vsnprintf_s_l(char *buffer, size_t sizeOfBuffer, size_t count, const char *format, locale_t locale,  va_list argptr);
        int _vsnwprintf_s_l(wchar_t *buffer, size_t sizeOfBuffer, size_t count, const wchar_t *format, locale_t locale, va_list argptr); -->
   <function name="_vsnprintf_s_l,_vsnwprintf_s_l">
     <noreturn>false</noreturn>
@@ -2297,7 +2634,7 @@ HFONT CreateFont(
     </arg>
     <arg nr="6"/>
   </function>
-  <!-- int _vsprintf_l(char *buffer, const char *format, locale_t locale, va_list argptr); 
+  <!-- int _vsprintf_l(char *buffer, const char *format, locale_t locale, va_list argptr);
       int __vswprintf_l(wchar_t *buffer, const wchar_t *format, locale_t locale, va_list argptr);-->
   <function name="_vsprintf_l,__vswprintf_l">
     <noreturn>false</noreturn>
@@ -2314,18 +2651,6 @@ HFONT CreateFont(
     </arg>
     <arg nr="4"/>
   </function>
-  <!-- char *strdup(const char *s); -->
-  <function name="strdup">
-    <noreturn>false</noreturn>
-    <returnValue type="char *"/>
-    <use-retval/>
-    <warn severity="style" alternatives="_strdup" reason="Obsolete">These POSIX functions are deprecated. Use the ISO C++ conformant _strdup, _wcsdup, _mbsdup instead.</warn>
-    <arg nr="1">
-      <not-null/>
-      <not-uninit/>
-      <not-bool/>
-    </arg>
-  </function>
   <!-- wchar_t *wcsdup(const wchar_t *s); -->
   <function name="wcsdup">
     <noreturn>false</noreturn>
@@ -2349,7 +2674,7 @@ HFONT CreateFont(
       <not-uninit/>
     </arg>
   </function>
-  <!-- char *_strdup_dbg(const char *strSource, int blockType, const char *filename, int linenumber );  
+  <!-- char *_strdup_dbg(const char *strSource, int blockType, const char *filename, int linenumber );
        wchar_t *_wcsdup_dbg(const wchar_t *strSource, int blockType, const char *filename, int linenumber);-->
   <function name="_strdup_dbg,_wcsdup_dbg,_tcsdup_dbg">
     <noreturn>false</noreturn>
@@ -2374,7 +2699,25 @@ HFONT CreateFont(
     <use-retval/>
     <pure/>
     <noreturn>false</noreturn>
-    <returnValue type="int"/>
+    <returnValue type="int">strcmp(arg1,arg2)</returnValue>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!-- int _mbscmp_l(const unsigned char *string1, const unsigned char *string2, _locale_t locale); -->
+  <function name="_mbscmp_l,_tscmp_l">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <returnValue type="int">strcmp(arg1,arg2)</returnValue>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-null/>
@@ -2386,8 +2729,9 @@ HFONT CreateFont(
       <not-uninit/>
       <strz/>
     </arg>
+    <arg nr="3" direction="in"/>
   </function>
-  <!-- int _snprintf(char *s, size_t n, const char *format, ...); 
+  <!-- int _snprintf(char *s, size_t n, const char *format, ...);
        int _snwprintf(wchar_t *buffer, size_t count, const wchar_t *format, ...);-->
   <function name="_snprintf,_snwprintf,_sntprintf">
     <noreturn>false</noreturn>
@@ -2407,6 +2751,20 @@ HFONT CreateFont(
       <not-uninit/>
     </arg>
   </function>
+  <!-- unsigned char *_mbscpy(unsigned char *strDestination, const unsigned char *strSource); -->
+  <function name="_mbscpy,_tcscpy">
+    <returnValue type="unsigned char *"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" strlen-arg="2"/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- errno_t wcscpy_s(wchar_t *strDestination, size_t numberOfElements, const wchar_t *strSource);
        errno_t _mbscpy_s(unsigned char *strDestination, size_t numberOfElements, const unsigned char *strSource); -->
   <function name="wcscpy_s,_mbscpy_s,_tcscpy_s">
@@ -2489,10 +2847,12 @@ HFONT CreateFont(
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:2</valid>
     </arg>
   </function>
-  <!-- __int64 _ftelli64(FILE *stream); 
-         long _ftell_nolock(FILE *stream);  
+  <!-- __int64 _ftelli64(FILE *stream);
+         long _ftell_nolock(FILE *stream);
        __int64 _ftelli64_nolock(FILE *stream); -->
   <function name="_ftelli64,_ftell_nolock,_ftelli64_nolock">
     <noreturn>false</noreturn>
@@ -2689,7 +3049,7 @@ HFONT CreateFont(
     <arg nr="1" direction="out">
       <not-null/>
     </arg>
-    <arg nr="2" direction="in">
+    <arg nr="2">
       <not-uninit/>
     </arg>
     <arg nr="3" direction="in">
@@ -2714,7 +3074,7 @@ HFONT CreateFont(
     <arg nr="1" direction="out">
       <not-null/>
     </arg>
-    <arg nr="2" direction="in">
+    <arg nr="2">
       <not-uninit/>
     </arg>
     <arg nr="3" direction="in">
@@ -2752,7 +3112,7 @@ HFONT CreateFont(
   _In_ LPARAM lParam); -->
   <function name="SendMessage,SendMessageA,SendMessageW">
     <noreturn>false</noreturn>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-null/>
       <not-uninit/>
     </arg>
@@ -2773,7 +3133,7 @@ HFONT CreateFont(
   _In_     LPARAM lParam); -->
   <function name="PostMessage,PostMessageA,PostMessageW">
     <noreturn>false</noreturn>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-uninit/>
     </arg>
     <arg nr="2" direction="in">
@@ -3035,7 +3395,7 @@ HFONT CreateFont(
     <noreturn>false</noreturn>
     <returnValue type="LPVOID"/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-null/>
     </arg>
   </function>
@@ -3044,10 +3404,10 @@ HFONT CreateFont(
     <noreturn>false</noreturn>
     <returnValue type="HGLOBAL"/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-uninit/>
     </arg>
-    <arg nr="2" direction="in">
+    <arg nr="2">
       <not-uninit/>
     </arg>
   </function>
@@ -3056,7 +3416,7 @@ HFONT CreateFont(
     <noreturn>false</noreturn>
     <returnValue type="BOOL"/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-null/>
       <not-uninit/>
     </arg>
@@ -3068,13 +3428,34 @@ HFONT CreateFont(
     <noreturn>false</noreturn>
     <returnValue type="BOOL"/>
     <leak-ignore/>
+    <arg nr="1">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int _stricmp_l(const char *str1, const char *str2, _locale_t locale); -->
+  <!-- int _wcsicmp_l(const wchar_t *str1, const wchar_t *str2, _locale_t locale) -->
+  <!-- int _mbsicmp_l(const unsigned char *str1, const unsigned char *str2, _locale_t locale) -->
+  <function name="_stricmp_l,_wcsicmp_l,_mbsicmp_l,_tcsicmp_l">
+    <use-retval/>
+    <pure/>
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
     <arg nr="2" direction="in">
+      <not-null/>
       <not-uninit/>
+      <strz/>
     </arg>
+    <arg nr="3" direction="in"/>
   </function>
   <!-- HWND WINAPI CreateWindow(
   _In_opt_ LPCTSTR   lpClassName,
@@ -3120,10 +3501,10 @@ HFONT CreateFont(
     <arg nr="9" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="10" direction="in">
+    <arg nr="10">
       <not-uninit/>
     </arg>
-    <arg nr="11" direction="in">
+    <arg nr="11">
       <not-uninit/>
     </arg>
   </function>
@@ -3175,10 +3556,10 @@ HFONT CreateFont(
     <arg nr="10" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="11" direction="in">
+    <arg nr="11">
       <not-uninit/>
     </arg>
-    <arg nr="12" direction="in">
+    <arg nr="12">
       <not-uninit/>
     </arg>
   </function>
@@ -3189,7 +3570,7 @@ HFONT CreateFont(
     <noreturn>false</noreturn>
     <returnValue type="BOOL"/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-null/>
       <not-uninit/>
     </arg>
@@ -3297,7 +3678,7 @@ HFONT CreateFont(
       <not-uninit/>
     </arg>
   </function>
-  <!-- int _rmdir(const char *dirname); 
+  <!-- int _rmdir(const char *dirname);
        int _wrmdir(const wchar_t *dirname);-->
   <function name="_rmdir,_wrmdir">
     <noreturn>false</noreturn>
@@ -3387,7 +3768,7 @@ HFONT CreateFont(
     <noreturn>false</noreturn>
     <returnValue type="DWORD"/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-uninit/>
     </arg>
     <arg nr="2" direction="in">
@@ -3403,7 +3784,7 @@ HFONT CreateFont(
       <not-uninit/>
     </arg>
   </function>
-  <!-- FILE *_popen( const char *command, const char *mode ); 
+  <!-- FILE *_popen( const char *command, const char *mode );
        FILE *_wpopen(const wchar_t *command, const wchar_t *mode);-->
   <function name="_popen,_wpopen,_tpopen">
     <noreturn>false</noreturn>
@@ -3434,7 +3815,7 @@ HFONT CreateFont(
     <use-retval/>
     <noreturn>false</noreturn>
     <returnValue type="HRSRC"/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-uninit/>
     </arg>
     <arg nr="2" direction="in">
@@ -3471,6 +3852,30 @@ HFONT CreateFont(
       <not-uninit/>
     </arg>
   </function>
+  <!-- HANDLE FindFirstFileNameW(
+  LPCWSTR lpFileName,
+  DWORD   dwFlags,
+  LPDWORD StringLength,
+  PWSTR   LinkName ); -->
+  <function name="FindFirstFileNameW">
+    <use-retval/>
+    <noreturn>false</noreturn>
+    <returnValue type="HANDLE"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <!-- Reserved; specify zero (0). -->
+      <valid>0</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="out">
+      <not-null/>
+    </arg>
+  </function>
   <!-- HANDLE WINAPI FindFirstFileEx(
   _In_       LPCTSTR            lpFileName,
   _In_       FINDEX_INFO_LEVELS fInfoLevelId,
@@ -3565,7 +3970,7 @@ HFONT CreateFont(
       <not-uninit/>
       <not-null/>
     </arg>
-    <arg nr="4" direction="in">
+    <arg nr="4">
       <not-uninit/>
     </arg>
     <arg nr="5" direction="in">
@@ -3715,7 +4120,7 @@ HFONT CreateFont(
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="2" direction="in">
+    <arg nr="2">
       <not-uninit/>
     </arg>
     <arg nr="3" direction="out"/>
@@ -3801,6 +4206,7 @@ HFONT CreateFont(
     <leak-ignore/>
     <returnValue type="void *"/>
     <noreturn>false</noreturn>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="4"/>
     <arg nr="1" direction="out">
       <not-null/>
       <minsize type="sizeof" arg="2"/>
@@ -3855,6 +4261,7 @@ HFONT CreateFont(
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="3"/>
     <arg nr="1" direction="inout">
       <not-null/>
       <not-uninit/>
@@ -3993,8 +4400,8 @@ HFONT CreateFont(
       <strz/>
     </arg>
   </function>
-  <!-- unsigned char *_mbsrchr_l(const unsigned char *str, unsigned int c, _locale_t locale ); // C only  
-       unsigned char *_mbsrchr_l(unsigned char *str, unsigned int c, _locale_t locale ); // C++ only  
+  <!-- unsigned char *_mbsrchr_l(const unsigned char *str, unsigned int c, _locale_t locale ); // C only
+       unsigned char *_mbsrchr_l(unsigned char *str, unsigned int c, _locale_t locale ); // C++ only
        const unsigned char *_mbsrchr_l(const unsigned char *str, unsigned int c, _locale_t locale ); // C++ only-->
   <function name="_mbsrchr_l">
     <use-retval/>
@@ -4027,8 +4434,8 @@ HFONT CreateFont(
       <not-uninit/>
     </arg>
   </function>
-  <!-- unsigned char *_mbsrchr(const unsigned char *str, unsigned int c); // C only  
-       unsigned char *_mbsrchr(unsigned char *str, unsigned int c); // C++ only  
+  <!-- unsigned char *_mbsrchr(const unsigned char *str, unsigned int c); // C only
+       unsigned char *_mbsrchr(unsigned char *str, unsigned int c); // C++ only
        const unsigned char *_mbsrchr(const unsigned char *str, unsigned int c); // C++ only-->
   <function name="_mbsrchr,_tcsrchr">
     <use-retval/>
@@ -4043,6 +4450,16 @@ HFONT CreateFont(
       <not-uninit/>
     </arg>
   </function>
+  <!-- error_t _get_timezone( long* seconds); -->
+  <!-- error_t _get_daylight( int* hours ); -->
+  <function name="_get_timezone,_get_daylight">
+    <noreturn>false</noreturn>
+    <returnValue type="error_t"/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+  </function>
   <!-- size_t _strftime_l(char *strDest, size_t maxsize, const char *format, const struct tm *timeptr, _locale_t locale); -->
   <!-- size_t _wcsftime_l(wchar_t *strDest, size_t maxsize, const wchar_t *format, const struct tm *timeptr, _locale_t locale);  -->
   <function name="_strftime_l,_wcsftime_l">
@@ -4131,6 +4548,7 @@ HFONT CreateFont(
   <function name="_mbsncpy,_mbsnbcpy,_tcsncpy">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="3"/>
     <arg nr="1" direction="out">
       <not-null/>
       <minsize type="argvalue" arg="3"/>
@@ -4173,6 +4591,7 @@ HFONT CreateFont(
   <function name="_strncpy_l,_wcsncpy_l,_mbsncpy_l,_tcsncpy_l">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="3"/>
     <arg nr="1" direction="out">
       <not-null/>
       <minsize type="argvalue" arg="3"/>
@@ -4218,6 +4637,18 @@ HFONT CreateFont(
       <not-bool/>
     </arg>
   </function>
+  <!-- struct tm *_localtime32( const __time32_t *sourceTime );
+       struct tm *_localtime64( const __time64_t *sourceTime );  -->
+  <function name="_localtime32,_localtime64">
+    <returnValue type="struct tm *"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- errno_t _localtime32_s( struct tm* _tm, const __time32_t *time);
        errno_t _localtime64_s( struct tm* _tm, const __time64_t *time); -->
   <function name="_localtime32_s,_localtime64_s">
@@ -4251,6 +4682,108 @@ HFONT CreateFont(
       <not-bool/>
     </arg>
   </function>
+  <!-- unsigned int _setsystime(struct tm * tp, unsigned int ms); -->
+  <function name="_setsystime">
+    <returnValue type="unsigned int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <warn severity="style" reason="Obsolete" alternatives="SetLocalTime"/>
+  </function>
+  <!-- unsigned int _getsystime(struct tm * tp)-->
+  <function name="_getsystime">
+    <returnValue type="unsigned int"/>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <warn severity="style" reason="Obsolete" alternatives="GetLocalTime"/>
+  </function>
+  <!-- void _sleep(unsigned long ulTime); -->
+  <function name="_sleep">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <warn severity="style" reason="Obsolete" alternatives="Sleep"/>
+  </function>
+  <!-- void _beep(unsigned nFreq, unsigned nDur); -->
+  <function name="_beep">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <warn severity="style" reason="Obsolete" alternatives="Beep"/>
+  </function>
+  <!-- void _seterrormode (int mode); -->
+  <function name="_seterrormode">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-bool/>
+      <not-uninit/>
+    </arg>
+    <warn severity="style" reason="Obsolete" alternatives="SetErrorMode"/>
+  </function>
+  <!-- intptr_t _loaddll (char *name); -->
+  <function name="_loaddll">
+    <returnValue type="intptr_t"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-bool/>
+      <not-null/>
+    </arg>
+    <warn severity="style" reason="Obsolete" alternatives="LoadLibrary,LoadLibraryEx,LoadPackagedLibrary"/>
+  </function>
+  <!-- int _unloaddll(intptr_t handle); -->
+  <function name="_unloaddll">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-bool/>
+      <not-uninit/>
+    </arg>
+    <warn severity="style" reason="Obsolete" alternatives="FreeLibrary"/>
+  </function>
+  <!-- FARPROC _getdllprocaddr (intptr_t hModule, char *lpProcName, intptr_t iOrdinal)-->
+  <function name="_getdllprocaddr">
+    <returnValue type="FARPROC"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-bool/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-bool/>
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-bool/>
+      <not-uninit/>
+    </arg>
+    <warn severity="style" reason="Obsolete" alternatives="GetProcAddress"/>
+  </function>
   <!-- BOOL WINAPI CreateDirectory(_In_ LPCTSTR lpPathName,
                                    _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes); -->
   <function name="CreateDirectory,CreateDirectoryA,CreateDirectoryW">
@@ -4364,7 +4897,7 @@ HFONT CreateFont(
     <returnValue type="HMODULE"/>
     <use-retval/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-uninit/>
       <strz/>
     </arg>
@@ -4410,18 +4943,61 @@ HFONT CreateFont(
   <function name="FreeLibrary">
     <noreturn>false</noreturn>
     <returnValue type="BOOL"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int _isatty(int fd); -->
+  <function name="_isatty">
+    <use-retval/>
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1">
+      <valid>0:</valid>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!--BOOL WINAPI FlushConsoleInputBuffer(_In_ HANDLE hConsoleInput);-->
+  <function name="FlushConsoleInputBuffer">
+    <noreturn>false</noreturn>
+    <returnValue type="BOOL"/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-null/>
       <not-bool/>
     </arg>
   </function>
+  <!-- HANDLE OpenProcess([in] DWORD dwDesiredAccess,
+                          [in] BOOL  bInheritHandle,
+                          [in] DWORD dwProcessId); -->
+  <!-- HANDLE OpenThread ([in] DWORD dwDesiredAccess,
+                          [in] BOOL  bInheritHandle,
+                          [in] DWORD dwThreadId); -->
+  <function name="OpenProcess,OpenThread">
+    <use-retval/>
+    <noreturn>false</noreturn>
+    <returnValue type="HANDLE"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
   <!--VOID WINAPI FreeLibraryAndExitThread(
   _In_ HMODULE hModule,
   _In_ DWORD   dwExitCode);-->
   <function name="FreeLibraryAndExitThread">
     <noreturn>true</noreturn>
     <returnValue type="VOID"/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-uninit/>
       <not-bool/>
     </arg>
@@ -4435,20 +5011,60 @@ HFONT CreateFont(
   <function name="GetModuleFileName,GetModuleFileNameA,GetModuleFileNameW">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="DWORD"/>
+    <returnValue type="DWORD"/>
+    <arg nr="1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-uninit/>
+      <strz/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>1:</valid>
+    </arg>
+  </function>
+  <!--BOOL WINAPI GetCurrentConsoleFontEx(
+  _In_  HANDLE               hConsoleOutput,
+  _In_  BOOL                 bMaximumWindow,
+  _Out_ PCONSOLE_FONT_INFOEX lpConsoleCurrentFontEx);-->
+  <function name="GetCurrentConsoleFontEx">
+    <noreturn>false</noreturn>
+    <returnValue type="BOOL"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-null/>
+    </arg>
+  </function>
+  <!--BOOL WINAPI SetCurrentConsoleFontEx(
+  _In_ HANDLE               hConsoleOutput,
+  _In_ BOOL                 bMaximumWindow,
+  _In_ PCONSOLE_FONT_INFOEX lpConsoleCurrentFontEx);-->
+  <function name="SetCurrentConsoleFontEx">
+    <noreturn>false</noreturn>
+    <returnValue type="BOOL"/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
       <not-bool/>
+      <not-null/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
-      <strz/>
-      <minsize type="argvalue" arg="3"/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
-      <not-bool/>
-      <valid>1:</valid>
     </arg>
   </function>
   <!--FARPROC WINAPI GetProcAddress(
@@ -4456,9 +5072,10 @@ HFONT CreateFont(
   _In_ LPCSTR  lpProcName);-->
   <function name="GetProcAddress">
     <noreturn>false</noreturn>
+    <returnValue type="FARPROC"/>
     <use-retval/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-uninit/>
       <not-bool/>
       <not-null/>
@@ -4515,6 +5132,8 @@ HFONT CreateFont(
       <not-bool/>
     </arg>
   </function>
+  <define name="CREATE_EVENT_INITIAL_SET" value="0x00000002"/>
+  <define name="CREATE_EVENT_MANUAL_RESET" value="0x00000001"/>
   <!--HANDLE WINAPI OpenEvent(
   _In_ DWORD   dwDesiredAccess,
   _In_ BOOL    bInheritHandle,
@@ -4545,7 +5164,7 @@ HFONT CreateFont(
     <noreturn>false</noreturn>
     <returnValue type="BOOL"/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-null/>
       <not-uninit/>
     </arg>
@@ -4575,6 +5194,19 @@ HFONT CreateFont(
       <not-bool/>
     </arg>
   </function>
+  <!--BOOL SetFileAttributesA(LPCSTR  lpFileName, DWORD  dwFileAttributes);-->
+  <!--BOOL SetFileAttributesW(LPCWSTR lpFileName, DWORD  dwFileAttributes);-->
+  <function name="SetFileAttributes,SetFileAttributesA,SetFileAttributesW">
+    <noreturn>false</noreturn>
+    <returnValue type="BOOL"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
   <!--BOOL WINAPI InitializeCriticalSectionEx(
   _Out_ LPCRITICAL_SECTION lpCriticalSection,
   _In_  DWORD              dwSpinCount,
@@ -4658,15 +5290,71 @@ HFONT CreateFont(
       <not-bool/>
     </arg>
   </function>
-  <!--LPTSTR WINAPI lstrcat(
-  _Inout_ LPTSTR lpString1,
-  _In_    LPTSTR lpString2);-->
+  <!--LPTSTR WINAPI lstrcat( _Inout_ LPTSTR lpString1, _In_ LPTSTR lpString2);-->
   <!-- TODO: When implemented use minsize for argument 1 to verify that the
   buffer is at least "(strlen(arg1)+strlen(arg2)+1)*sizeof(TCHAR)" bytes in size.-->
   <function name="lstrcat">
     <returnValue type="LPTSTR"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" strlen-arg="2"/>
+    <warn severity="style" alternatives="StringCchCat">Due to security concerns it is not recommended to use this function, see MSDN for details.</warn>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!--LPSTR lstrcatA(LPSTR lpString1, LPCSTR lpString2);-->
+  <!-- TODO: When implemented use minsize for argument 1 to verify that the
+  buffer is at least "(strlen(arg1)+strlen(arg2)+1)*sizeof(TCHAR)" bytes in size.-->
+  <function name="lstrcatA">
+    <returnValue type="LPSTR"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" strlen-arg="2"/>
+    <warn severity="style" alternatives="StringCchCat">Due to security concerns it is not recommended to use this function, see MSDN for details.</warn>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+    <!-- PWSTR StrCatW(PWSTR psz1, PCWSTR psz2); -->
+  <function name="StrCatW">
+    <returnValue type="PWSTR"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" strlen-arg="2"/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+  <!--LPWSTR lstrcatW( _Inout_ LPWSTR lpString1, _In_ LPCWSTR lpString2);-->
+  <!-- TODO: When implemented use minsize for argument 1 to verify that the
+  buffer is at least "(strlen(arg1)+strlen(arg2)+1)*sizeof(TCHAR)" bytes in size.-->
+  <function name="lstrcatW">
+    <returnValue type="LPWSTR"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" strlen-arg="2"/>
     <warn severity="style" alternatives="StringCchCat">Due to security concerns it is not recommended to use this function, see MSDN for details.</warn>
     <arg nr="1" direction="inout">
       <not-null/>
@@ -4788,6 +5476,18 @@ HFONT CreateFont(
       <not-bool/>
     </arg>
   </function>
+  <!--BOOL TerminateThread(HANDLE hThread,DWORD  dwExitCode);-->
+  <function name="TerminateThread">
+    <returnValue type="BOOL"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
   <!--HANDLE WINAPI CreateMutex(
   _In_opt_ LPSECURITY_ATTRIBUTES lpMutexAttributes,
   _In_     BOOL                  bInitialOwner,
@@ -4857,13 +5557,12 @@ HFONT CreateFont(
     <returnValue type="BOOL"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-uninit/>
       <not-bool/>
     </arg>
   </function>
-  <!--void *_malloca(
-  size_t size);-->
+  <!--void *_malloca(size_t size);-->
   <function name="_malloca">
     <returnValue type="void *"/>
     <use-retval/>
@@ -4873,8 +5572,7 @@ HFONT CreateFont(
       <valid>0:</valid>
     </arg>
   </function>
-  <!--void *_alloca(
-  size_t size);-->
+  <!--void *_alloca(size_t size);-->
   <function name="_alloca">
     <returnValue type="void *"/>
     <noreturn>false</noreturn>
@@ -4883,9 +5581,9 @@ HFONT CreateFont(
       <not-uninit/>
       <valid>0:</valid>
     </arg>
+    <warn severity="style" alternatives="_malloca">This function is deprecated because a more secure version is available '_malloca'.</warn>
   </function>
-  <!--void _freea(
-  void *memblock);-->
+  <!--void _freea(void *memblock);-->
   <function name="_freea">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
@@ -4982,6 +5680,17 @@ HFONT CreateFont(
       <not-null/>
     </arg>
   </function>
+  <define name="SECURITY_NULL_SID_AUTHORITY" value="0"/>
+  <define name="SECURITY_WORLD_SID_AUTHORITY" value="1"/>
+  <define name="SECURITY_LOCAL_SID_AUTHORITY" value="2"/>
+  <define name="SECURITY_CREATOR_SID_AUTHORITY" value="3"/>
+  <define name="SECURITY_NT_AUTHORITY" value="5"/>
+  <define name="SECURITY_NULL_RID" value="0"/>
+  <define name="SECURITY_WORLD_RID" value="0"/>
+  <define name="SECURITY_LOCAL_RID" value="0"/>
+  <define name="SECURITY_LOCAL_LOGON_RID" value="1"/>
+  <define name="SECURITY_CREATOR_OWNER_RID" value="0"/>
+  <define name="SECURITY_CREATOR_GROUP_RID" value="1"/>
   <!--PVOID WINAPI FreeSid(_In_ PSID pSid);-->
   <function name="FreeSid">
     <noreturn>false</noreturn>
@@ -5070,6 +5779,29 @@ HFONT CreateFont(
       <not-uninit/>
     </arg>
   </function>
+  <!--RPC_STATUS UuidToString(const UUID *Uuid, RPC_CSTR *StringUuid);-->
+  <!--RPC_STATUS UuidToStringA(const UUID *Uuid, RPC_CSTR *StringUuid);-->
+  <!--RPC_STATUS UuidToStringW(const UUID *Uuid, RPC_CSTR *StringUuid);-->
+  <function name="UuidToString,UuidToStringA,UuidToStringW">
+    <noreturn>false</noreturn>
+    <returnValue type="RPC_STATUS"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <!--RPC_STATUS RpcStringFree(RPC_CSTR *String);-->
+  <function name="RpcStringFree">
+    <noreturn>false</noreturn>
+    <returnValue type="RPC_STATUS"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
   <!--BOOL WINAPI HeapValidate(
   _In_     HANDLE  hHeap,
   _In_     DWORD   dwFlags,
@@ -5118,7 +5850,7 @@ HFONT CreateFont(
     <returnValue type="int"/>
     <leak-ignore/>
     <!-- The function does nothing (useful) if arg1 is nullptr or arg2 is nullptr or arg3 is 0 -->
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-null/>
     </arg>
     <arg nr="2" direction="out">
@@ -5317,6 +6049,16 @@ HFONT CreateFont(
       <strz/>
     </arg>
   </function>
+  <!--void GetSystemInfo(LPSYSTEM_INFO lpSystemInfo); -->
+  <!--void GetNativeSystemInfo(LPSYSTEM_INFO lpSystemInfo);-->
+  <function name="GetSystemInfo,GetNativeSystemInfo">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+  </function>
   <!--char* FAR inet_ntoa(
   __in  struct   in_addr in);-->
   <function name="inet_ntoa">
@@ -5645,7 +6387,7 @@ HFONT CreateFont(
   <!-- int _tolower(int c); -->
   <function name="_tolower">
     <use-retval/>
-    <returnValue type="int"/>
+    <returnValue type="int">arg1 &lt; 'A' || arg1 &gt; 'Z' ? arg1 : arg1 + 32</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -5683,7 +6425,7 @@ HFONT CreateFont(
   <!-- int _toupper(int c); -->
   <function name="_toupper">
     <use-retval/>
-    <returnValue type="int"/>
+    <returnValue type="int">arg1 &lt; 'a' || arg1 &gt; 'z' ? arg1 : arg1 - 32</returnValue>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
@@ -5786,7 +6528,7 @@ HFONT CreateFont(
   <function name="LocalFree">
     <noreturn>false</noreturn>
     <returnValue type="HLOCAL"/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-bool/>
     </arg>
   </function>
@@ -5822,6 +6564,35 @@ HFONT CreateFont(
       <not-bool/>
     </arg>
   </function>
+  <!-- DWORD FormatMessage(
+  DWORD   dwFlags,
+  LPCVOID lpSource,
+  DWORD   dwMessageId,
+  DWORD   dwLanguageId,
+  LPTSTR  lpBuffer,
+  DWORD   nSize,
+  va_list *Arguments); -->
+  <function name="FormatMessage,FormatMessageA,FormatMessageW">
+    <noreturn>false</noreturn>
+    <returnValue type="DWORD"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" direction="out"/>
+    <arg nr="6" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="7" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- DWORD WINAPI SetFilePointer(
   _In_        HANDLE hFile,
   _In_        LONG   lDistanceToMove,
@@ -5844,12 +6615,81 @@ HFONT CreateFont(
       <not-uninit/>
     </arg>
   </function>
+  <!-- wchar_t *_wcsncat_l(wchar_t *ct, const wchar_t *cs, size_t n, _locale_t locale); -->
+  <function name="_wcsncat_l">
+    <noreturn>false</noreturn>
+    <returnValue type="wchar_t *"/>
+    <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="3"/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- unsigned char *_mbsncat_l(unsigned char *strDest, const unsigned char *strSource, size_t count, _locale_t locale); -->
+  <function name="_mbsncat_l">
+    <noreturn>false</noreturn>
+    <returnValue type="unsigned char *"/>
+    <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="3"/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- unsigned char *_mbsncat(unsigned char *strDest, const unsigned char *strSource, size_t count); -->
+  <function name="_mbsncat">
+    <noreturn>false</noreturn>
+    <returnValue type="unsigned char *"/>
+    <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" size-arg="3"/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+      <minsize type="argvalue" arg="3"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
   <!-- unsigned char *_mbscat(unsigned char *strDestination, const unsigned char *strSource); -->
   <!-- template <size_t size> unsigned char *_mbscat(unsigned char (&strDestination)[size], const unsigned char *strSource); // C++ only -->
   <function name="_mbscat">
     <returnValue type="unsigned char *"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <not-overlapping-data ptr1-arg="1" ptr2-arg="2" strlen-arg="2"/>
     <arg nr="1" direction="inout">
       <not-null/>
       <not-uninit/>
@@ -5966,6 +6806,18 @@ HFONT CreateFont(
       <not-bool/>
     </arg>
   </function>
+  <!-- int _chdir(const char *path); -->
+  <!-- int _wchdir(const wchar_t *path); -->
+  <function name="_chdir,_wchdir,_tchdir">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
   <!-- int _finite(double x);
        int _finitef(float x); /* x64 and ARM/ARM64 only */ -->
   <function name="_finite,_finitef">
@@ -5979,6 +6831,21 @@ HFONT CreateFont(
       <not-bool/>
     </arg>
   </function>
+  <!-- ULONG UpdateTraceA(CONTROLTRACE_ID TraceId, LPCSTR  InstanceName, PEVENT_TRACE_PROPERTIES Properties); -->
+  <!-- ULONG UpdateTraceW(CONTROLTRACE_ID TraceId, LPCWSTR InstanceName, PEVENT_TRACE_PROPERTIES Properties); -->
+  <function name="UpdateTraceA,UpdateTraceW">
+    <noreturn>false</noreturn>
+    <returnValue type="ULONG"/>
+    <use-retval/>
+    <warn severity="style" alternatives="ControlTrace" reason="Obsolete">This function is obsolete. The ControlTrace function supersedes this function.</warn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="out"/>
+  </function>
   <!-- BOOL DeviceIoControl(
   _In_ HANDLE hDevice,
   _In_ DWORD dwIoControlCode,
@@ -6040,6 +6907,22 @@ HFONT CreateFont(
       <not-uninit/>
     </arg>
   </function>
+  <!-- BOOL SystemParametersInfoA(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni); -->
+  <function name="SystemParametersInfo,SystemParametersInfoA,SystemParametersInfoW">
+    <noreturn>false</noreturn>
+    <returnValue type="BOOL"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="out"/>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- BOOL WINAPI CancelIo(
   _In_ HANDLE hFile); -->
   <function name="CancelIo">
@@ -6127,7 +7010,7 @@ HFONT CreateFont(
     <returnValue type="HWND"/>
     <use-retval/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <not-uninit/>
     </arg>
     <arg nr="2" direction="in">
@@ -6137,7 +7020,7 @@ HFONT CreateFont(
   </function>
   <!-- int _atoi_l(const char *str, _locale_t locale); -->
   <!-- int _wtoi_l(const wchar_t *str, _locale_t locale); -->
-  <function name="_atol_l,_wtol_l">
+  <function name="_atoi_l,_wtoi_l">
     <noreturn>false</noreturn>
     <returnValue type="int"/>
     <use-retval/>
@@ -6223,25 +7106,6 @@ HFONT CreateFont(
       <not-bool/>
     </arg>
   </function>
-  <!-- VERSIONHELPERAPI is defined as "inline bool" in VersionHelpers.h -->
-  <!-- VERSIONHELPERAPI IsWindowsXPOrGreater(); -->
-  <!-- VERSIONHELPERAPI IsWindowsXPSP1OrGreater(); -->
-  <!-- VERSIONHELPERAPI IsWindowsXPSP2OrGreater(); -->
-  <!-- VERSIONHELPERAPI IsWindowsXPSP3OrGreater(); -->
-  <!-- VERSIONHELPERAPI IsWindowsVistaOrGreater(); -->
-  <!-- VERSIONHELPERAPI IsWindowsVistaSP1OrGreater(); -->
-  <!-- VERSIONHELPERAPI IsWindowsVistaSP2OrGreater(); -->
-  <!-- VERSIONHELPERAPI IsWindows7OrGreater(); -->
-  <!-- VERSIONHELPERAPI IsWindows7SP1OrGreater(); -->
-  <!-- VERSIONHELPERAPI IsWindows8OrGreater(); -->
-  <!-- VERSIONHELPERAPI IsWindows8Point1OrGreater(); -->
-  <!-- VERSIONHELPERAPI IsWindows10OrGreater(); -->
-  <!-- VERSIONHELPERAPI IsWindowsServer(); -->
-  <function name="IsWindowsXPOrGreater,IsWindowsXPSP1OrGreater,IsWindowsXPSP2OrGreater,IsWindowsXPSP3OrGreater,IsWindowsVistaOrGreater,IsWindowsVistaSP1OrGreater,IsWindowsVistaSP2OrGreater,IsWindows7OrGreater,IsWindows7SP1OrGreater,IsWindows8OrGreater,IsWindows8Point1OrGreater,IsWindows10OrGreater,IsWindowsServer">
-    <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <use-retval/>
-  </function>
   <!-- int _setmode (int fd, int mode); -->
   <function name="_setmode">
     <noreturn>false</noreturn>
@@ -6309,6 +7173,15 @@ HFONT CreateFont(
       <not-bool/>
     </arg>
   </function>
+  <!-- __alignof Operator, declaration could look like this: size_t __alignof(type); -->
+  <!-- _alignof is a synonym -->
+  <function name="__alignof,_alignof">
+    <noreturn>false</noreturn>
+    <returnValue type="size_t"/>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+  </function>
   <podtype name="POINTER_SIGNED" sign="s"/>
   <podtype name="POINTER_UNSIGNED" sign="u"/>
   <podtype name="__time32_t" sign="s" size="4"/>
@@ -6317,24 +7190,22 @@ HFONT CreateFont(
   <define name="afx_msg" value=""/>
   <define name="AFX_EXT_CLASS" value=""/>
   <define name="DEBUG_NEW" value="new"/>
-  <define name="DECLARE_MESSAGE_MAP()" value=""/>
-  <define name="DECLARE_DYNAMIC(x)" value=""/>
-  <define name="DECLARE_DYNAMIC_CLASS(x)" value=""/>
-  <define name="DECLARE_DYNCREATE(x)" value=""/>
-  <define name="DECLARE_SERIAL(x)" value=""/>
-  <define name="IMPLEMENT_DYNAMIC(name,base)" value=""/>
-  <define name="IMPLEMENT_DYNCREATE(name,base)" value=""/>
-  <define name="IMPLEMENT_SERIAL(name,base,schema)" value=""/>
-  <define name="INVALID_HANDLE_VALUE" value="0"/>
-  <define name="INVALID_SOCKET" value="0"/>
+  <define name="INVALID_HANDLE_VALUE" value="-1"/>
+  <define name="INVALID_SOCKET" value="-1"/>
   <define name="WINAPI" value="__stdcall"/>
   <define name="STDMETHODCALLTYPE" value="__stdcall"/>
   <define name="STDMETHODIMP" value="HRESULT STDMETHODCALLTYPE"/>
   <define name="STDMETHODIMP_(type)" value="type STDMETHODCALLTYPE"/>
+  <define name="IFACEMETHODIMP" value="STDMETHODIMP"/>
+  <define name="IFACEMETHODIMP_(type)" value="STDMETHODIMP_(type)"/>
   <!-- Text conversion macros like 'TEXT()', '_TEXT()' and '_T()' are handled internally by Cppcheck. There is no need to added them here. -->
   <define name="__pragma(x)" value=""/>
   <define name="_countof(_Array)" value="(sizeof(_Array) / sizeof(_Array[0]))"/>
   <define name="__wchar_t" value="wchar_t"/>
+  <define name="__try" value="try"/>
+  <define name="__except(x)" value="catch(...)"/>
+  <define name="__finally" value="__dummy_lbl:"/>
+  <define name="__leave" value="goto __dummy_lbl;"/>
   <define name="RtlEqualMemory(Destination,Source,Length)" value="(!memcmp((Destination),(Source),(Length)))"/>
   <define name="RtlMoveMemory(Destination,Source,Length)" value="memmove((Destination),(Source),(Length))"/>
   <define name="RtlCopyMemory(Destination,Source,Length)" value="memcpy((Destination),(Source),(Length))"/>
@@ -6833,6 +7704,22 @@ HFONT CreateFont(
   <define name="WINCODEC_ERR_INVALIDQUERYCHARACTER" value="0x88982F93"/>
   <define name="WINCODEC_ERR_WIN32ERROR" value="0x88982F94"/>
   <define name="WINCODEC_ERR_INVALIDPROGRESSIVELEVEL" value="0x88982F95"/>
+  <!-- strsafe.h -->
+  <define name="S_OK" value="((HRESULT)0L)"/>
+  <define name="S_FALSE" value="((HRESULT)1L)"/>
+  <define name="STRSAFE_MAX_LENGTH" value="(STRSAFE_MAX_CCH-1)"/>
+  <define name="STRSAFE_IGNORE_NULLS" value="0x00000100"/>
+  <define name="STRSAFE_FILL_BEHIND_NULL" value="0x00000200"/>
+  <define name="STRSAFE_FILL_ON_FAILURE" value="0x00000400"/>
+  <define name="STRSAFE_NULL_ON_FAILURE" value="0x00000800"/>
+  <define name="STRSAFE_NO_TRUNCATION" value="0x00001000"/>
+  <define name="STRSAFE_VALID_FLAGS" value="(0x000000FF|STRSAFE_IGNORE_NULLS|STRSAFE_FILL_BEHIND_NULL|STRSAFE_FILL_ON_FAILURE|STRSAFE_NULL_ON_FAILURE|STRSAFE_NO_TRUNCATION)"/>
+  <define name="STRSAFE_FILL_BYTE(x)" value="((DWORD)((x&amp;0x000000FF)|STRSAFE_FILL_BEHIND_NULL))"/>
+  <define name="STRSAFE_FAILURE_BYTE(x)" value="((DWORD)((x&amp;0x000000FF)|STRSAFE_FILL_ON_FAILURE))"/>
+  <define name="STRSAFE_GET_FILL_PATTERN(dwFlags)" value="((int)(dwFlags&amp;0x000000FF))"/>
+  <define name="STRSAFE_E_INSUFFICIENT_BUFFER" value="((HRESULT)0x8007007AL)"/>
+  <define name="STRSAFE_E_INVALID_PARAMETER" value="((HRESULT)0x80070057L)"/>
+  <define name="STRSAFE_E_END_OF_FILE" value="((HRESULT)0x80070026L)"/>
   <!-- Winerror.h: COM Error Codes (WPN, MBN, P2P, Bluetooth) -->
   <define name="WPN_E_CHANNEL_CLOSED" value="0x803E0100"/>
   <define name="WPN_E_CHANNEL_REQUEST_NOT_COMPLETE" value="0x803E0101"/>
@@ -6994,11 +7881,6 @@ HFONT CreateFont(
   <define name="E_BLUETOOTH_ATT_UNSUPPORTED_GROUP_TYPE" value="0x80650010"/>
   <define name="E_BLUETOOTH_ATT_INSUFFICIENT_RESOURCES" value="0x80650011"/>
   <define name="E_BLUETOOTH_ATT_UNKNOWN_ERROR" value="0x80651000"/>
-  <!--RpcDce.h: Authorization Constants Ref.: https://msdn.microsoft.com/en-us/library/windows/desktop/ms690276(v=vs.85).aspx -->
-  <define name="RPC_C_AUTHZ_NONE" value="0"/>
-  <define name="RPC_C_AUTHZ_NAME" value="1"/>
-  <define name="RPC_C_AUTHZ_DCE" value="2"/>
-  <define name="RPC_C_AUTHZ_DEFAULT" value="0xffffffff"/>
   <!-- Winerror.h: COM Error Codes (COMADMIN, FILTER, GRAPHICS) Ref.: https://msdn.microsoft.com/en-us/library/windows/desktop/dd542647(v=vs.85).aspx -->
   <define name="COMADMIN_E_OBJECTERRORS" value="0x80110401"/>
   <define name="COMADMIN_E_OBJECTINVALID" value="0x80110402"/>
@@ -7097,15 +7979,6 @@ HFONT CreateFont(
   <define name="IO_REPARSE_TAG_SIS" value="0x80000007"/>
   <define name="IO_REPARSE_TAG_SYMLINK" value="0xA000000C"/>
   <define name="IO_REPARSE_TAG_WIM" value="0x80000008"/>
-  <define name="CREATE_PROCESS_DEBUG_EVENT" value="3"/>
-  <define name="CREATE_THREAD_DEBUG_EVENT" value="2"/>
-  <define name="EXCEPTION_DEBUG_EVENT" value="1"/>
-  <define name="EXIT_PROCESS_DEBUG_EVENT" value="5"/>
-  <define name="EXIT_THREAD_DEBUG_EVENT" value="4"/>
-  <define name="LOAD_DLL_DEBUG_EVENT" value="6"/>
-  <define name="OUTPUT_DEBUG_STRING_EVENT" value="8"/>
-  <define name="RIP_EVENT" value="9"/>
-  <define name="UNLOAD_DLL_DEBUG_EVENT" value="7"/>
   <define name="COMADMIN_E_OBJECT_PARENT_MISSING" value="0x80110808"/>
   <define name="COMADMIN_E_OBJECT_DOES_NOT_EXIST" value="0x80110809"/>
   <define name="COMADMIN_E_APP_NOT_RUNNING" value="0x8011080A"/>
@@ -7943,9 +8816,6 @@ HFONT CreateFont(
   <define name="CO_E_CANCEL_DISABLED" value="0x80010140"/>
   <define name="RPC_E_UNEXPECTED" value="0x8001FFFF"/>
   <define name="LHND" value="0x0042"/>
-  <define name="LMEM_FIXED" value="0x0000"/>
-  <define name="LMEM_MOVEABLE" value="0x0002"/>
-  <define name="LMEM_ZEROINIT" value="0x0040"/>
   <define name="LPTR" value="0x0040"/>
   <define name="NONZEROLHND" value="0x0002"/>
   <define name="NONZEROLPTR" value="0x0000"/>
@@ -11767,7 +12637,6 @@ HFONT CreateFont(
   <define name="WAIT_ABANDONED" value="(0x00000080L)"/>
   <define name="WAIT_ABANDONED_0" value="(0x00000080L)"/>
   <define name="WAIT_IO_COMPLETION" value="STATUS_USER_APC"/>
-  <define name="SecureZeroMemory" value="RtlSecureZeroMemory"/>
   <define name="CaptureStackBackTrace" value="RtlCaptureStackBackTrace"/>
   <define name="FILE_FLAG_WRITE_THROUGH" value="0x80000000"/>
   <define name="FILE_FLAG_OVERLAPPED" value="0x40000000"/>
@@ -12360,6 +13229,7 @@ HFONT CreateFont(
   <define name="ENCLAVE_TYPE_VBS" value="0x00000010"/>
   <define name="ENCLAVE_TYPE_SGX" value="0x00000001"/>
   <define name="ENCLAVE_TYPE_SGX2" value="0x00000002"/>
+  <define name="ENCLAVE_TYPE_VBS_BASIC" value="0x00000011"/>
   <define name="MEM_PRIVATE" value="0x00020000"/>
   <define name="MEM_MAPPED" value="0x00040000"/>
   <define name="MEM_IMAGE" value="0x01000000"/>
@@ -12563,6 +13433,232 @@ HFONT CreateFont(
   <define name="INVALID_SET_FILE_POINTER" value="((DWORD)-1)"/>
   <define name="INVALID_FILE_ATTRIBUTES" value="((DWORD)-1)"/>
   <!-- WinUser.h -->
+  <define name="SPI_GETBEEP" value="0x0001"/>
+  <define name="SPI_SETBEEP" value="0x0002"/>
+  <define name="SPI_GETMOUSE" value="0x0003"/>
+  <define name="SPI_SETMOUSE" value="0x0004"/>
+  <define name="SPI_GETBORDER" value="0x0005"/>
+  <define name="SPI_SETBORDER" value="0x0006"/>
+  <define name="SPI_GETKEYBOARDSPEED" value="0x000A"/>
+  <define name="SPI_SETKEYBOARDSPEED" value="0x000B"/>
+  <define name="SPI_LANGDRIVER" value="0x000C"/>
+  <define name="SPI_ICONHORIZONTALSPACING" value="0x000D"/>
+  <define name="SPI_GETSCREENSAVETIMEOUT" value="0x000E"/>
+  <define name="SPI_SETSCREENSAVETIMEOUT" value="0x000F"/>
+  <define name="SPI_GETSCREENSAVEACTIVE" value="0x0010"/>
+  <define name="SPI_SETSCREENSAVEACTIVE" value="0x0011"/>
+  <define name="SPI_GETGRIDGRANULARITY" value="0x0012"/>
+  <define name="SPI_SETGRIDGRANULARITY" value="0x0013"/>
+  <define name="SPI_SETDESKWALLPAPER" value="0x0014"/>
+  <define name="SPI_SETDESKPATTERN" value="0x0015"/>
+  <define name="SPI_GETKEYBOARDDELAY" value="0x0016"/>
+  <define name="SPI_SETKEYBOARDDELAY" value="0x0017"/>
+  <define name="SPI_ICONVERTICALSPACING" value="0x0018"/>
+  <define name="SPI_GETICONTITLEWRAP" value="0x0019"/>
+  <define name="SPI_SETICONTITLEWRAP" value="0x001A"/>
+  <define name="SPI_GETMENUDROPALIGNMENT" value="0x001B"/>
+  <define name="SPI_SETMENUDROPALIGNMENT" value="0x001C"/>
+  <define name="SPI_SETDOUBLECLKWIDTH" value="0x001D"/>
+  <define name="SPI_SETDOUBLECLKHEIGHT" value="0x001E"/>
+  <define name="SPI_GETICONTITLELOGFONT" value="0x001F"/>
+  <define name="SPI_SETDOUBLECLICKTIME" value="0x0020"/>
+  <define name="SPI_SETMOUSEBUTTONSWAP" value="0x0021"/>
+  <define name="SPI_SETICONTITLELOGFONT" value="0x0022"/>
+  <define name="SPI_GETFASTTASKSWITCH" value="0x0023"/>
+  <define name="SPI_SETFASTTASKSWITCH" value="0x0024"/>
+  <define name="SPI_SETDRAGFULLWINDOWS" value="0x0025"/>
+  <define name="SPI_GETDRAGFULLWINDOWS" value="0x0026"/>
+  <define name="SPI_GETNONCLIENTMETRICS" value="0x0029"/>
+  <define name="SPI_SETNONCLIENTMETRICS" value="0x002A"/>
+  <define name="SPI_GETMINIMIZEDMETRICS" value="0x002B"/>
+  <define name="SPI_SETMINIMIZEDMETRICS" value="0x002C"/>
+  <define name="SPI_GETICONMETRICS" value="0x002D"/>
+  <define name="SPI_SETICONMETRICS" value="0x002E"/>
+  <define name="SPI_SETWORKAREA" value="0x002F"/>
+  <define name="SPI_GETWORKAREA" value="0x0030"/>
+  <define name="SPI_SETPENWINDOWS" value="0x0031"/>
+  <define name="SPI_GETHIGHCONTRAST" value="0x0042"/>
+  <define name="SPI_SETHIGHCONTRAST" value="0x0043"/>
+  <define name="SPI_GETKEYBOARDPREF" value="0x0044"/>
+  <define name="SPI_SETKEYBOARDPREF" value="0x0045"/>
+  <define name="SPI_GETSCREENREADER" value="0x0046"/>
+  <define name="SPI_SETSCREENREADER" value="0x0047"/>
+  <define name="SPI_GETANIMATION" value="0x0048"/>
+  <define name="SPI_SETANIMATION" value="0x0049"/>
+  <define name="SPI_GETFONTSMOOTHING" value="0x004A"/>
+  <define name="SPI_SETFONTSMOOTHING" value="0x004B"/>
+  <define name="SPI_SETDRAGWIDTH" value="0x004C"/>
+  <define name="SPI_SETDRAGHEIGHT" value="0x004D"/>
+  <define name="SPI_SETHANDHELD" value="0x004E"/>
+  <define name="SPI_GETLOWPOWERTIMEOUT" value="0x004F"/>
+  <define name="SPI_GETPOWEROFFTIMEOUT" value="0x0050"/>
+  <define name="SPI_SETLOWPOWERTIMEOUT" value="0x0051"/>
+  <define name="SPI_SETPOWEROFFTIMEOUT" value="0x0052"/>
+  <define name="SPI_GETLOWPOWERACTIVE" value="0x0053"/>
+  <define name="SPI_GETPOWEROFFACTIVE" value="0x0054"/>
+  <define name="SPI_SETLOWPOWERACTIVE" value="0x0055"/>
+  <define name="SPI_SETPOWEROFFACTIVE" value="0x0056"/>
+  <define name="SPI_SETCURSORS" value="0x0057"/>
+  <define name="SPI_SETICONS" value="0x0058"/>
+  <define name="SPI_GETDEFAULTINPUTLANG" value="0x0059"/>
+  <define name="SPI_SETDEFAULTINPUTLANG" value="0x005A"/>
+  <define name="SPI_SETLANGTOGGLE" value="0x005B"/>
+  <define name="SPI_GETWINDOWSEXTENSION" value="0x005C"/>
+  <define name="SPI_SETMOUSETRAILS" value="0x005D"/>
+  <define name="SPI_GETMOUSETRAILS" value="0x005E"/>
+  <define name="SPI_SETSCREENSAVERRUNNING" value="0x0061"/>
+  <define name="SPI_SCREENSAVERRUNNING" value="SPI_SETSCREENSAVERRUNNING"/>
+  <define name="SPI_GETFILTERKEYS" value="0x0032"/>
+  <define name="SPI_SETFILTERKEYS" value="0x0033"/>
+  <define name="SPI_GETTOGGLEKEYS" value="0x0034"/>
+  <define name="SPI_SETTOGGLEKEYS" value="0x0035"/>
+  <define name="SPI_GETMOUSEKEYS" value="0x0036"/>
+  <define name="SPI_SETMOUSEKEYS" value="0x0037"/>
+  <define name="SPI_GETSHOWSOUNDS" value="0x0038"/>
+  <define name="SPI_SETSHOWSOUNDS" value="0x0039"/>
+  <define name="SPI_GETSTICKYKEYS" value="0x003A"/>
+  <define name="SPI_SETSTICKYKEYS" value="0x003B"/>
+  <define name="SPI_GETACCESSTIMEOUT" value="0x003C"/>
+  <define name="SPI_SETACCESSTIMEOUT" value="0x003D"/>
+  <define name="SPI_GETSERIALKEYS" value="0x003E"/>
+  <define name="SPI_SETSERIALKEYS" value="0x003F"/>
+  <define name="SPI_GETSOUNDSENTRY" value="0x0040"/>
+  <define name="SPI_SETSOUNDSENTRY" value="0x0041"/>
+  <define name="SPI_GETSNAPTODEFBUTTON" value="0x005F"/>
+  <define name="SPI_SETSNAPTODEFBUTTON" value="0x0060"/>
+  <define name="SPI_GETMOUSEHOVERWIDTH" value="0x0062"/>
+  <define name="SPI_SETMOUSEHOVERWIDTH" value="0x0063"/>
+  <define name="SPI_GETMOUSEHOVERHEIGHT" value="0x0064"/>
+  <define name="SPI_SETMOUSEHOVERHEIGHT" value="0x0065"/>
+  <define name="SPI_GETMOUSEHOVERTIME" value="0x0066"/>
+  <define name="SPI_SETMOUSEHOVERTIME" value="0x0067"/>
+  <define name="SPI_GETWHEELSCROLLLINES" value="0x0068"/>
+  <define name="SPI_SETWHEELSCROLLLINES" value="0x0069"/>
+  <define name="SPI_GETMENUSHOWDELAY" value="0x006A"/>
+  <define name="SPI_SETMENUSHOWDELAY" value="0x006B"/>
+  <define name="SPI_GETWHEELSCROLLCHARS" value="0x006C"/>
+  <define name="SPI_SETWHEELSCROLLCHARS" value="0x006D"/>
+  <define name="SPI_GETSHOWIMEUI" value="0x006E"/>
+  <define name="SPI_SETSHOWIMEUI" value="0x006F"/>
+  <define name="SPI_GETMOUSESPEED" value="0x0070"/>
+  <define name="SPI_SETMOUSESPEED" value="0x0071"/>
+  <define name="SPI_GETSCREENSAVERRUNNING" value="0x0072"/>
+  <define name="SPI_GETDESKWALLPAPER" value="0x0073"/>
+  <define name="SPI_GETAUDIODESCRIPTION" value="0x0074"/>
+  <define name="SPI_SETAUDIODESCRIPTION" value="0x0075"/>
+  <define name="SPI_GETSCREENSAVESECURE" value="0x0076"/>
+  <define name="SPI_SETSCREENSAVESECURE" value="0x0077"/>
+  <define name="SPI_GETHUNGAPPTIMEOUT" value="0x0078"/>
+  <define name="SPI_SETHUNGAPPTIMEOUT" value="0x0079"/>
+  <define name="SPI_GETWAITTOKILLTIMEOUT" value="0x007A"/>
+  <define name="SPI_SETWAITTOKILLTIMEOUT" value="0x007B"/>
+  <define name="SPI_GETWAITTOKILLSERVICETIMEOUT" value="0x007C"/>
+  <define name="SPI_SETWAITTOKILLSERVICETIMEOUT" value="0x007D"/>
+  <define name="SPI_GETMOUSEDOCKTHRESHOLD" value="0x007E"/>
+  <define name="SPI_SETMOUSEDOCKTHRESHOLD" value="0x007F"/>
+  <define name="SPI_GETPENDOCKTHRESHOLD" value="0x0080"/>
+  <define name="SPI_SETPENDOCKTHRESHOLD" value="0x0081"/>
+  <define name="SPI_GETWINARRANGING" value="0x0082"/>
+  <define name="SPI_SETWINARRANGING" value="0x0083"/>
+  <define name="SPI_GETMOUSEDRAGOUTTHRESHOLD" value="0x0084"/>
+  <define name="SPI_SETMOUSEDRAGOUTTHRESHOLD" value="0x0085"/>
+  <define name="SPI_GETPENDRAGOUTTHRESHOLD" value="0x0086"/>
+  <define name="SPI_SETPENDRAGOUTTHRESHOLD" value="0x0087"/>
+  <define name="SPI_GETMOUSESIDEMOVETHRESHOLD" value="0x0088"/>
+  <define name="SPI_SETMOUSESIDEMOVETHRESHOLD" value="0x0089"/>
+  <define name="SPI_GETPENSIDEMOVETHRESHOLD" value="0x008A"/>
+  <define name="SPI_SETPENSIDEMOVETHRESHOLD" value="0x008B"/>
+  <define name="SPI_GETDRAGFROMMAXIMIZE" value="0x008C"/>
+  <define name="SPI_SETDRAGFROMMAXIMIZE" value="0x008D"/>
+  <define name="SPI_GETSNAPSIZING" value="0x008E"/>
+  <define name="SPI_SETSNAPSIZING" value="0x008F"/>
+  <define name="SPI_GETDOCKMOVING" value="0x0090"/>
+  <define name="SPI_SETDOCKMOVING" value="0x0091"/>
+  <define name="IDOK" value="1"/>
+  <define name="IDCANCEL" value="2"/>
+  <define name="IDABORT" value="3"/>
+  <define name="IDRETRY" value="4"/>
+  <define name="IDIGNORE" value="5"/>
+  <define name="IDYES" value="6"/>
+  <define name="IDNO" value="7"/>
+  <define name="IDCLOSE" value="8"/>
+  <define name="IDHELP" value="9"/>
+  <define name="IDTRYAGAIN" value="10"/>
+  <define name="IDCONTINUE" value="11"/>
+  <define name="IDTIMEOUT" value="32000"/>
+  <define name="ES_LEFT" value="0x0000L"/>
+  <define name="ES_CENTER" value="0x0001L"/>
+  <define name="ES_RIGHT" value="0x0002L"/>
+  <define name="ES_MULTILINE" value="0x0004L"/>
+  <define name="ES_UPPERCASE" value="0x0008L"/>
+  <define name="ES_LOWERCASE" value="0x0010L"/>
+  <define name="ES_PASSWORD" value="0x0020L"/>
+  <define name="ES_AUTOVSCROLL" value="0x0040L"/>
+  <define name="ES_AUTOHSCROLL" value="0x0080L"/>
+  <define name="ES_NOHIDESEL" value="0x0100L"/>
+  <define name="ES_OEMCONVERT" value="0x0400L"/>
+  <define name="ES_READONLY" value="0x0800L"/>
+  <define name="ES_WANTRETURN" value="0x1000L"/>
+  <define name="ES_NUMBER" value="0x2000L"/>
+  <define name="EN_SETFOCUS" value="0x0100"/>
+  <define name="EN_KILLFOCUS" value="0x0200"/>
+  <define name="EN_CHANGE" value="0x0300"/>
+  <define name="EN_UPDATE" value="0x0400"/>
+  <define name="EN_ERRSPACE" value="0x0500"/>
+  <define name="EN_MAXTEXT" value="0x0501"/>
+  <define name="EN_HSCROLL" value="0x0601"/>
+  <define name="EN_VSCROLL" value="0x0602"/>
+  <define name="EN_ALIGN_LTR_EC" value="0x0700"/>
+  <define name="EN_ALIGN_RTL_EC" value="0x0701"/>
+  <define name="EN_BEFORE_PASTE" value="0x0800"/>
+  <define name="EN_AFTER_PASTE" value="0x0801"/>
+  <define name="EC_LEFTMARGIN" value="0x0001"/>
+  <define name="EC_RIGHTMARGIN" value="0x0002"/>
+  <define name="EC_USEFONTINFO" value="0xffff"/>
+  <define name="EMSIS_COMPOSITIONSTRING" value="0x0001"/>
+  <define name="EIMES_GETCOMPSTRATONCE" value="0x0001"/>
+  <define name="EIMES_CANCELCOMPSTRINFOCUS" value="0x0002"/>
+  <define name="EIMES_COMPLETECOMPSTRKILLFOCUS" value="0x0004"/>
+  <define name="EM_GETSEL" value="0x00B0"/>
+  <define name="EM_SETSEL" value="0x00B1"/>
+  <define name="EM_GETRECT" value="0x00B2"/>
+  <define name="EM_SETRECT" value="0x00B3"/>
+  <define name="EM_SETRECTNP" value="0x00B4"/>
+  <define name="EM_SCROLL" value="0x00B5"/>
+  <define name="EM_LINESCROLL" value="0x00B6"/>
+  <define name="EM_SCROLLCARET" value="0x00B7"/>
+  <define name="EM_GETMODIFY" value="0x00B8"/>
+  <define name="EM_SETMODIFY" value="0x00B9"/>
+  <define name="EM_GETLINECOUNT" value="0x00BA"/>
+  <define name="EM_LINEINDEX" value="0x00BB"/>
+  <define name="EM_SETHANDLE" value="0x00BC"/>
+  <define name="EM_GETHANDLE" value="0x00BD"/>
+  <define name="EM_GETTHUMB" value="0x00BE"/>
+  <define name="EM_LINELENGTH" value="0x00C1"/>
+  <define name="EM_REPLACESEL" value="0x00C2"/>
+  <define name="EM_GETLINE" value="0x00C4"/>
+  <define name="EM_LIMITTEXT" value="0x00C5"/>
+  <define name="EM_CANUNDO" value="0x00C6"/>
+  <define name="EM_UNDO" value="0x00C7"/>
+  <define name="EM_FMTLINES" value="0x00C8"/>
+  <define name="EM_LINEFROMCHAR" value="0x00C9"/>
+  <define name="EM_SETTABSTOPS" value="0x00CB"/>
+  <define name="EM_SETPASSWORDCHAR" value="0x00CC"/>
+  <define name="EM_EMPTYUNDOBUFFER" value="0x00CD"/>
+  <define name="EM_GETFIRSTVISIBLELINE" value="0x00CE"/>
+  <define name="EM_SETREADONLY" value="0x00CF"/>
+  <define name="EM_SETWORDBREAKPROC" value="0x00D0"/>
+  <define name="EM_GETWORDBREAKPROC" value="0x00D1"/>
+  <define name="EM_GETPASSWORDCHAR" value="0x00D2"/>
+  <define name="EM_SETMARGINS" value="0x00D3"/>
+  <define name="EM_GETMARGINS" value="0x00D4"/>
+  <define name="EM_SETLIMITTEXT" value="0x00C5"/>
+  <define name="EM_GETLIMITTEXT" value="0x00D5"/>
+  <define name="EM_POSFROMCHAR" value="0x00D6"/>
+  <define name="EM_CHARFROMPOS" value="0x00D7"/>
+  <define name="EM_SETIMESTATUS" value="0x00D8"/>
+  <define name="EM_GETIMESTATUS" value="0x00D9"/>
+  <define name="EM_ENABLEFEATURE" value="0x00DA"/>
   <define name="SW_HIDE" value="0"/>
   <define name="SW_SHOWNORMAL" value="1"/>
   <define name="SW_NORMAL" value="1"/>
@@ -12935,10 +14031,6 @@ HFONT CreateFont(
   <define name="FAPPCOMMAND_KEY" value="0"/>
   <define name="FAPPCOMMAND_OEM" value="0x1000"/>
   <define name="FAPPCOMMAND_MASK" value="0xF000"/>
-  <define name="MoveMemory" value="RtlMoveMemory"/>
-  <define name="CopyMemory" value="RtlCopyMemory"/>
-  <define name="FillMemory" value="RtlFillMemory"/>
-  <define name="ZeroMemory" value="RtlZeroMemory"/>
   <define name="FIND_FIRST_EX_CASE_SENSITIVE" value="0x00000001"/>
   <define name="FIND_FIRST_EX_LARGE_FETCH" value="0x00000002"/>
   <define name="FIND_FIRST_EX_ON_DISK_ENTRIES_ONLY" value="0x00000004"/>
@@ -12995,4 +14087,3151 @@ HFONT CreateFont(
   <define name="LMEM_INVALID_HANDLE" value="0x8000"/>
   <define name="LMEM_DISCARDED" value="0x4000"/>
   <define name="LMEM_LOCKCOUNT" value="0x00FF"/>
+  <define name="MWMO_WAITALL" value="0x0001"/>
+  <define name="MWMO_ALERTABLE" value="0x0002"/>
+  <define name="MWMO_INPUTAVAILABLE" value="0x0004"/>
+  <define name="QS_KEY" value="0x0001"/>
+  <define name="QS_MOUSEMOVE" value="0x0002"/>
+  <define name="QS_MOUSEBUTTON" value="0x0004"/>
+  <define name="QS_POSTMESSAGE" value="0x0008"/>
+  <define name="QS_TIMER" value="0x0010"/>
+  <define name="QS_PAINT" value="0x0020"/>
+  <define name="QS_SENDMESSAGE" value="0x0040"/>
+  <define name="QS_HOTKEY" value="0x0080"/>
+  <define name="QS_ALLPOSTMESSAGE" value="0x0100"/>
+  <define name="QS_ALLEVENTS" value="(QS_INPUT|QS_POSTMESSAGE|QS_TIMER|QS_PAINT|QS_HOTKEY)"/>
+  <define name="QS_ALLINPUT" value="(QS_INPUT|QS_POSTMESSAGE|QS_TIMER|QS_PAINT|QS_HOTKEY|QS_SENDMESSAGE)"/>
+  <define name="QS_RAWINPUT" value="0x0400"/>
+  <define name="QS_TOUCH" value="0x0800"/>
+  <define name="QS_POINTER" value="0x1000"/>
+  <define name="QS_MOUSE" value="(QS_MOUSEMOVE|QS_MOUSEBUTTON)"/>
+  <define name="QS_INPUT" value="(QS_MOUSE|QS_KEY|QS_RAWINPUT|QS_TOUCH|QS_POINTER)"/>
+  <!-- shellapi.h -->
+  <define name="SE_ERR_FNF" value="2"/>
+  <define name="SE_ERR_PNF" value="3"/>
+  <define name="SE_ERR_ACCESSDENIED" value="5"/>
+  <define name="SE_ERR_OOM" value="8"/>
+  <define name="SE_ERR_DLLNOTFOUND" value="32"/>
+  <define name="SE_ERR_SHARE" value="26"/>
+  <define name="SE_ERR_ASSOCINCOMPLETE" value="27"/>
+  <define name="SE_ERR_DDETIMEOUT" value="28"/>
+  <define name="SE_ERR_DDEFAIL" value="29"/>
+  <define name="SE_ERR_DDEBUSY" value="30"/>
+  <define name="SE_ERR_NOASSOC" value="31"/>
+  <define name="SEE_MASK_DEFAULT" value="0x00000000"/>
+  <define name="SEE_MASK_CLASSNAME" value="0x00000001"/>
+  <define name="SEE_MASK_CLASSKEY" value="0x00000003"/>
+  <define name="SEE_MASK_IDLIST" value="0x00000004"/>
+  <define name="SEE_MASK_INVOKEIDLIST" value="0x0000000c"/>
+  <define name="SEE_MASK_ICON" value="0x00000010"/>
+  <define name="SEE_MASK_HOTKEY" value="0x00000020"/>
+  <define name="SEE_MASK_NOCLOSEPROCESS" value="0x00000040"/>
+  <define name="SEE_MASK_CONNECTNETDRV" value="0x00000080"/>
+  <define name="SEE_MASK_NOASYNC" value="0x00000100"/>
+  <define name="SEE_MASK_FLAG_DDEWAIT" value="SEE_MASK_NOASYNC"/>
+  <define name="SEE_MASK_DOENVSUBST" value="0x00000200"/>
+  <define name="SEE_MASK_FLAG_NO_UI" value="0x00000400"/>
+  <define name="SEE_MASK_UNICODE" value="0x00004000"/>
+  <define name="SEE_MASK_NO_CONSOLE" value="0x00008000"/>
+  <define name="SEE_MASK_ASYNCOK" value="0x00100000"/>
+  <define name="SEE_MASK_HMONITOR" value="0x00200000"/>
+  <define name="SEE_MASK_NOZONECHECKS" value="0x00800000"/>
+  <define name="SEE_MASK_NOQUERYCLASSSTORE" value="0x01000000"/>
+  <define name="SEE_MASK_WAITFORINPUTIDLE" value="0x02000000"/>
+  <define name="SEE_MASK_FLAG_LOG_USAGE" value="0x04000000"/>
+  <define name="SEE_MASK_FLAG_HINST_IS_SITE" value="0x08000000"/>
+  <define name="SHGFI_ICON" value="0x000000100"/>
+  <define name="SHGFI_DISPLAYNAME" value="0x000000200"/>
+  <define name="SHGFI_TYPENAME" value="0x000000400"/>
+  <define name="SHGFI_ATTRIBUTES" value="0x000000800"/>
+  <define name="SHGFI_ICONLOCATION" value="0x000001000"/>
+  <define name="SHGFI_EXETYPE" value="0x000002000"/>
+  <define name="SHGFI_SYSICONINDEX" value="0x000004000"/>
+  <define name="SHGFI_LINKOVERLAY" value="0x000008000"/>
+  <define name="SHGFI_SELECTED" value="0x000010000"/>
+  <define name="SHGFI_ATTR_SPECIFIED" value="0x000020000"/>
+  <define name="SHGFI_LARGEICON" value="0x000000000"/>
+  <define name="SHGFI_SMALLICON" value="0x000000001"/>
+  <define name="SHGFI_OPENICON" value="0x000000002"/>
+  <define name="SHGFI_SHELLICONSIZE" value="0x000000004"/>
+  <define name="SHGFI_PIDL" value="0x000000008"/>
+  <define name="SHGFI_USEFILEATTRIBUTES" value="0x000000010"/>
+  <define name="SHGFI_ADDOVERLAYS" value="0x000000020"/>
+  <define name="SHGFI_OVERLAYINDEX" value="0x000000040"/>
+  <define name="SIID_DOCNOASSOC" value="0"/>
+  <define name="SIID_DOCASSOC" value="1"/>
+  <define name="SIID_APPLICATION" value="2"/>
+  <define name="SIID_FOLDER" value="3"/>
+  <define name="SIID_FOLDEROPEN" value="4"/>
+  <define name="SIID_DRIVE525" value="5"/>
+  <define name="SIID_DRIVE35" value="6"/>
+  <define name="SIID_DRIVEREMOVE" value="7"/>
+  <define name="SIID_DRIVEFIXED" value="8"/>
+  <define name="SIID_DRIVENET" value="9"/>
+  <define name="SIID_DRIVENETDISABLED" value="10"/>
+  <define name="SIID_DRIVECD" value="11"/>
+  <define name="SIID_DRIVERAM" value="12"/>
+  <define name="SIID_WORLD" value="13"/>
+  <define name="SIID_SERVER" value="15"/>
+  <define name="SIID_PRINTER" value="16"/>
+  <define name="SIID_MYNETWORK" value="17"/>
+  <define name="SIID_FIND" value="22"/>
+  <define name="SIID_HELP" value="23"/>
+  <define name="SIID_SHARE" value="28"/>
+  <define name="SIID_LINK" value="29"/>
+  <define name="SIID_SLOWFILE" value="30"/>
+  <define name="SIID_RECYCLER" value="31"/>
+  <define name="SIID_RECYCLERFULL" value="32"/>
+  <define name="SIID_MEDIACDAUDIO" value="40"/>
+  <define name="SIID_LOCK" value="47"/>
+  <define name="SIID_AUTOLIST" value="49"/>
+  <define name="SIID_PRINTERNET" value="50"/>
+  <define name="SIID_SERVERSHARE" value="51"/>
+  <define name="SIID_PRINTERFAX" value="52"/>
+  <define name="SIID_PRINTERFAXNET" value="53"/>
+  <define name="SIID_PRINTERFILE" value="54"/>
+  <define name="SIID_STACK" value="55"/>
+  <define name="SIID_MEDIASVCD" value="56"/>
+  <define name="SIID_STUFFEDFOLDER" value="57"/>
+  <define name="SIID_DRIVEUNKNOWN" value="58"/>
+  <define name="SIID_DRIVEDVD" value="59"/>
+  <define name="SIID_MEDIADVD" value="60"/>
+  <define name="SIID_MEDIADVDRAM" value="61"/>
+  <define name="SIID_MEDIADVDRW" value="62"/>
+  <define name="SIID_MEDIADVDR" value="63"/>
+  <define name="SIID_MEDIADVDROM" value="64"/>
+  <define name="SIID_MEDIACDAUDIOPLUS" value="65"/>
+  <define name="SIID_MEDIACDRW" value="66"/>
+  <define name="SIID_MEDIACDR" value="67"/>
+  <define name="SIID_MEDIACDBURN" value="68"/>
+  <define name="SIID_MEDIABLANKCD" value="69"/>
+  <define name="SIID_MEDIACDROM" value="70"/>
+  <define name="SIID_AUDIOFILES" value="71"/>
+  <define name="SIID_IMAGEFILES" value="72"/>
+  <define name="SIID_VIDEOFILES" value="73"/>
+  <define name="SIID_MIXEDFILES" value="74"/>
+  <define name="SIID_FOLDERBACK" value="75"/>
+  <define name="SIID_FOLDERFRONT" value="76"/>
+  <define name="SIID_SHIELD" value="77"/>
+  <define name="SIID_WARNING" value="78"/>
+  <define name="SIID_INFO" value="79"/>
+  <define name="SIID_ERROR" value="80"/>
+  <define name="SIID_KEY" value="81"/>
+  <define name="SIID_SOFTWARE" value="82"/>
+  <define name="SIID_RENAME" value="83"/>
+  <define name="SIID_DELETE" value="84"/>
+  <define name="SIID_MEDIAAUDIODVD" value="85"/>
+  <define name="SIID_MEDIAMOVIEDVD" value="86"/>
+  <define name="SIID_MEDIAENHANCEDCD" value="87"/>
+  <define name="SIID_MEDIAENHANCEDDVD" value="88"/>
+  <define name="SIID_MEDIAHDDVD" value="89"/>
+  <define name="SIID_MEDIABLURAY" value="90"/>
+  <define name="SIID_MEDIAVCD" value="91"/>
+  <define name="SIID_MEDIADVDPLUSR" value="92"/>
+  <define name="SIID_MEDIADVDPLUSRW" value="93"/>
+  <define name="SIID_DESKTOPPC" value="94"/>
+  <define name="SIID_MOBILEPC" value="95"/>
+  <define name="SIID_USERS" value="96"/>
+  <define name="SIID_MEDIASMARTMEDIA" value="97"/>
+  <define name="SIID_MEDIACOMPACTFLASH" value="98"/>
+  <define name="SIID_DEVICECELLPHONE" value="99"/>
+  <define name="SIID_DEVICECAMERA" value="100"/>
+  <define name="SIID_DEVICEVIDEOCAMERA" value="101"/>
+  <define name="SIID_DEVICEAUDIOPLAYER" value="102"/>
+  <define name="SIID_NETWORKCONNECT" value="103"/>
+  <define name="SIID_INTERNET" value="104"/>
+  <define name="SIID_ZIPFILE" value="105"/>
+  <define name="SIID_SETTINGS" value="106"/>
+  <define name="SIID_DRIVEHDDVD" value="132"/>
+  <define name="SIID_DRIVEBD" value="133"/>
+  <define name="SIID_MEDIAHDDVDROM" value="134"/>
+  <define name="SIID_MEDIAHDDVDR" value="135"/>
+  <define name="SIID_MEDIAHDDVDRAM" value="136"/>
+  <define name="SIID_MEDIABDROM" value="137"/>
+  <define name="SIID_MEDIABDR" value="138"/>
+  <define name="SIID_MEDIABDRE" value="139"/>
+  <define name="SIID_CLUSTEREDDRIVE" value="140"/>
+  <define name="SIID_MAX_ICONS" value="181"/>
+  <!-- constants from winnt.h -->
+  <define name="GENERIC_READ" value="0x80000000L" />
+  <define name="GENERIC_WRITE" value="0x40000000L" />
+  <define name="GENERIC_EXECUTE" value="0x20000000L" />
+  <define name="GENERIC_ALL" value="0x10000000L" />
+  <define name="LANG_AFRIKAANS" value="0x36"/>
+  <define name="LANG_ALBANIAN" value="0x1c"/>
+  <define name="LANG_ALSATIAN" value="0x84"/>
+  <define name="LANG_AMHARIC" value="0x5e"/>
+  <define name="LANG_ARABIC" value="0x01"/>
+  <define name="LANG_ARMENIAN" value="0x2b"/>
+  <define name="LANG_ASSAMESE" value="0x4d"/>
+  <define name="LANG_AZERBAIJANI" value="0x2c"/>
+  <define name="LANG_AZERI" value="0x2c"/>
+  <define name="LANG_BANGLA" value="0x45"/>
+  <define name="LANG_BASHKIR" value="0x6d"/>
+  <define name="LANG_BASQUE" value="0x2d"/>
+  <define name="LANG_BELARUSIAN" value="0x23"/>
+  <define name="LANG_BENGALI" value="0x45"/>
+  <define name="LANG_BOSNIAN" value="0x1a"/>
+  <define name="LANG_BOSNIAN_NEUTRAL" value="0x781a"/>
+  <define name="LANG_BRETON" value="0x7e"/>
+  <define name="LANG_BULGARIAN" value="0x02"/>
+  <define name="LANG_CATALAN" value="0x03"/>
+  <define name="LANG_CENTRAL_KURDISH" value="0x92"/>
+  <define name="LANG_CHEROKEE" value="0x5c"/>
+  <define name="LANG_CHINESE" value="0x04"/>
+  <define name="LANG_CHINESE_SIMPLIFIED" value="0x04"/>
+  <define name="LANG_CHINESE_TRADITIONAL" value="0x7c04"/>
+  <define name="LANG_CORSICAN" value="0x83"/>
+  <define name="LANG_CROATIAN" value="0x1a"/>
+  <define name="LANG_CZECH" value="0x05"/>
+  <define name="LANG_DANISH" value="0x06"/>
+  <define name="LANG_DARI" value="0x8c"/>
+  <define name="LANG_DIVEHI" value="0x65"/>
+  <define name="LANG_DUTCH" value="0x13"/>
+  <define name="LANG_ENGLISH" value="0x09"/>
+  <define name="LANG_ESTONIAN" value="0x25"/>
+  <define name="LANG_FAEROESE" value="0x38"/>
+  <define name="LANG_FARSI" value="0x29"/>
+  <define name="LANG_FILIPINO" value="0x64"/>
+  <define name="LANG_FINNISH" value="0x0b"/>
+  <define name="LANG_FRENCH" value="0x0c"/>
+  <define name="LANG_FRISIAN" value="0x62"/>
+  <define name="LANG_FULAH" value="0x67"/>
+  <define name="LANG_GALICIAN" value="0x56"/>
+  <define name="LANG_GEORGIAN" value="0x37"/>
+  <define name="LANG_GERMAN" value="0x07"/>
+  <define name="LANG_GREEK" value="0x08"/>
+  <define name="LANG_GREENLANDIC" value="0x6f"/>
+  <define name="LANG_GUJARATI" value="0x47"/>
+  <define name="LANG_HAUSA" value="0x68"/>
+  <define name="LANG_HAWAIIAN" value="0x75"/>
+  <define name="LANG_HEBREW" value="0x0d"/>
+  <define name="LANG_HINDI" value="0x39"/>
+  <define name="LANG_HUNGARIAN" value="0x0e"/>
+  <define name="LANG_ICELANDIC" value="0x0f"/>
+  <define name="LANG_IGBO" value="0x70"/>
+  <define name="LANG_INDONESIAN" value="0x21"/>
+  <define name="LANG_INUKTITUT" value="0x5d"/>
+  <define name="LANG_INVARIANT" value="0x7f"/>
+  <define name="LANG_IRISH" value="0x3c"/>
+  <define name="LANG_ITALIAN" value="0x10"/>
+  <define name="LANG_JAPANESE" value="0x11"/>
+  <define name="LANG_KANNADA" value="0x4b"/>
+  <define name="LANG_KASHMIRI" value="0x60"/>
+  <define name="LANG_KAZAK" value="0x3f"/>
+  <define name="LANG_KHMER" value="0x53"/>
+  <define name="LANG_KICHE" value="0x86"/>
+  <define name="LANG_KINYARWANDA" value="0x87"/>
+  <define name="LANG_KONKANI" value="0x57"/>
+  <define name="LANG_KOREAN" value="0x12"/>
+  <define name="LANG_KYRGYZ" value="0x40"/>
+  <define name="LANG_LAO" value="0x54"/>
+  <define name="LANG_LATVIAN" value="0x26"/>
+  <define name="LANG_LITHUANIAN" value="0x27"/>
+  <define name="LANG_LOWER_SORBIAN" value="0x2e"/>
+  <define name="LANG_LUXEMBOURGISH" value="0x6e"/>
+  <define name="LANG_MACEDONIAN" value="0x2f"/>
+  <define name="LANG_MALAY" value="0x3e"/>
+  <define name="LANG_MALAYALAM" value="0x4c"/>
+  <define name="LANG_MALTESE" value="0x3a"/>
+  <define name="LANG_MANIPURI" value="0x58"/>
+  <define name="LANG_MAORI" value="0x81"/>
+  <define name="LANG_MAPUDUNGUN" value="0x7a"/>
+  <define name="LANG_MARATHI" value="0x4e"/>
+  <define name="LANG_MOHAWK" value="0x7c"/>
+  <define name="LANG_MONGOLIAN" value="0x50"/>
+  <define name="LANG_NEPALI" value="0x61"/>
+  <define name="LANG_NEUTRAL" value="0x00"/>
+  <define name="LANG_NORWEGIAN" value="0x14"/>
+  <define name="LANG_OCCITAN" value="0x82"/>
+  <define name="LANG_ODIA" value="0x48"/>
+  <define name="LANG_ORIYA" value="0x48"/>
+  <define name="LANG_PASHTO" value="0x63"/>
+  <define name="LANG_PERSIAN" value="0x29"/>
+  <define name="LANG_POLISH" value="0x15"/>
+  <define name="LANG_PORTUGUESE" value="0x16"/>
+  <define name="LANG_PULAR" value="0x67"/>
+  <define name="LANG_PUNJABI" value="0x46"/>
+  <define name="LANG_QUECHUA" value="0x6b"/>
+  <define name="LANG_ROMANIAN" value="0x18"/>
+  <define name="LANG_ROMANSH" value="0x17"/>
+  <define name="LANG_RUSSIAN" value="0x19"/>
+  <define name="LANG_SAKHA" value="0x85"/>
+  <define name="LANG_SAMI" value="0x3b"/>
+  <define name="LANG_SANSKRIT" value="0x4f"/>
+  <define name="LANG_SCOTTISH_GAELIC" value="0x91"/>
+  <define name="LANG_SERBIAN" value="0x1a"/>
+  <define name="LANG_SERBIAN_NEUTRAL" value="0x7c1a"/>
+  <define name="LANG_SINDHI" value="0x59"/>
+  <define name="LANG_SINHALESE" value="0x5b"/>
+  <define name="LANG_SLOVAK" value="0x1b"/>
+  <define name="LANG_SLOVENIAN" value="0x24"/>
+  <define name="LANG_SOTHO" value="0x6c"/>
+  <define name="LANG_SPANISH" value="0x0a"/>
+  <define name="LANG_SWAHILI" value="0x41"/>
+  <define name="LANG_SWEDISH" value="0x1d"/>
+  <define name="LANG_SYRIAC" value="0x5a"/>
+  <define name="LANG_TAJIK" value="0x28"/>
+  <define name="LANG_TAMAZIGHT" value="0x5f"/>
+  <define name="LANG_TAMIL" value="0x49"/>
+  <define name="LANG_TATAR" value="0x44"/>
+  <define name="LANG_TELUGU" value="0x4a"/>
+  <define name="LANG_THAI" value="0x1e"/>
+  <define name="LANG_TIBETAN" value="0x51"/>
+  <define name="LANG_TIGRIGNA" value="0x73"/>
+  <define name="LANG_TIGRINYA" value="0x73"/>
+  <define name="LANG_TSWANA" value="0x32"/>
+  <define name="LANG_TURKISH" value="0x1f"/>
+  <define name="LANG_TURKMEN" value="0x42"/>
+  <define name="LANG_UIGHUR" value="0x80"/>
+  <define name="LANG_UKRAINIAN" value="0x22"/>
+  <define name="LANG_UPPER_SORBIAN" value="0x2e"/>
+  <define name="LANG_URDU" value="0x20"/>
+  <define name="LANG_UZBEK" value="0x43"/>
+  <define name="LANG_VALENCIAN" value="0x03"/>
+  <define name="LANG_VIETNAMESE" value="0x2a"/>
+  <define name="LANG_WELSH" value="0x52"/>
+  <define name="LANG_WOLOF" value="0x88"/>
+  <define name="LANG_XHOSA" value="0x34"/>
+  <define name="LANG_YAKUT" value="0x85"/>
+  <define name="LANG_YI" value="0x78"/>
+  <define name="LANG_YORUBA" value="0x6a"/>
+  <define name="LANG_ZULU" value="0x35"/>
+  <define name="SUBLANG_AFRIKAANS_SOUTH_AFRICA" value="0x01"/>
+  <define name="SUBLANG_ALBANIAN_ALBANIA" value="0x01"/>
+  <define name="SUBLANG_ALSATIAN_FRANCE" value="0x01"/>
+  <define name="SUBLANG_AMHARIC_ETHIOPIA" value="0x01"/>
+  <define name="SUBLANG_ARABIC_ALGERIA" value="0x05"/>
+  <define name="SUBLANG_ARABIC_BAHRAIN" value="0x0f"/>
+  <define name="SUBLANG_ARABIC_EGYPT" value="0x03"/>
+  <define name="SUBLANG_ARABIC_IRAQ" value="0x02"/>
+  <define name="SUBLANG_ARABIC_JORDAN" value="0x0b"/>
+  <define name="SUBLANG_ARABIC_KUWAIT" value="0x0d"/>
+  <define name="SUBLANG_ARABIC_LEBANON" value="0x0c"/>
+  <define name="SUBLANG_ARABIC_LIBYA" value="0x04"/>
+  <define name="SUBLANG_ARABIC_MOROCCO" value="0x06"/>
+  <define name="SUBLANG_ARABIC_OMAN" value="0x08"/>
+  <define name="SUBLANG_ARABIC_QATAR" value="0x10"/>
+  <define name="SUBLANG_ARABIC_SAUDI_ARABIA" value="0x01"/>
+  <define name="SUBLANG_ARABIC_SYRIA" value="0x0a"/>
+  <define name="SUBLANG_ARABIC_TUNISIA" value="0x07"/>
+  <define name="SUBLANG_ARABIC_UAE" value="0x0e"/>
+  <define name="SUBLANG_ARABIC_YEMEN" value="0x09"/>
+  <define name="SUBLANG_ARMENIAN_ARMENIA" value="0x01"/>
+  <define name="SUBLANG_ASSAMESE_INDIA" value="0x01"/>
+  <define name="SUBLANG_AZERBAIJANI_AZERBAIJAN_CYRILLIC" value="0x02"/>
+  <define name="SUBLANG_AZERBAIJANI_AZERBAIJAN_LATIN" value="0x01"/>
+  <define name="SUBLANG_AZERI_CYRILLIC" value="0x02"/>
+  <define name="SUBLANG_AZERI_LATIN" value="0x01"/>
+  <define name="SUBLANG_BANGLA_BANGLADESH" value="0x02"/>
+  <define name="SUBLANG_BANGLA_INDIA" value="0x01"/>
+  <define name="SUBLANG_BASHKIR_RUSSIA" value="0x01"/>
+  <define name="SUBLANG_BASQUE_BASQUE" value="0x01"/>
+  <define name="SUBLANG_BELARUSIAN_BELARUS" value="0x01"/>
+  <define name="SUBLANG_BENGALI_BANGLADESH" value="0x02"/>
+  <define name="SUBLANG_BENGALI_INDIA" value="0x01"/>
+  <define name="SUBLANG_BOSNIAN_BOSNIA_HERZEGOVINA_CYRILLIC" value="0x08"/>
+  <define name="SUBLANG_BOSNIAN_BOSNIA_HERZEGOVINA_LATIN" value="0x05"/>
+  <define name="SUBLANG_BRETON_FRANCE" value="0x01"/>
+  <define name="SUBLANG_BULGARIAN_BULGARIA" value="0x01"/>
+  <define name="SUBLANG_CATALAN_CATALAN" value="0x01"/>
+  <define name="SUBLANG_CENTRAL_KURDISH_IRAQ" value="0x01"/>
+  <define name="SUBLANG_CHEROKEE_CHEROKEE" value="0x01"/>
+  <define name="SUBLANG_CHINESE_HONGKONG" value="0x03"/>
+  <define name="SUBLANG_CHINESE_MACAU" value="0x05"/>
+  <define name="SUBLANG_CHINESE_SIMPLIFIED" value="0x02"/>
+  <define name="SUBLANG_CHINESE_SINGAPORE" value="0x04"/>
+  <define name="SUBLANG_CHINESE_TRADITIONAL" value="0x01"/>
+  <define name="SUBLANG_CORSICAN_FRANCE" value="0x01"/>
+  <define name="SUBLANG_CROATIAN_BOSNIA_HERZEGOVINA_LATIN" value="0x04"/>
+  <define name="SUBLANG_CROATIAN_CROATIA" value="0x01"/>
+  <define name="SUBLANG_CUSTOM_DEFAULT" value="0x03"/>
+  <define name="SUBLANG_CUSTOM_UNSPECIFIED" value="0x04"/>
+  <define name="SUBLANG_CZECH_CZECH_REPUBLIC" value="0x01"/>
+  <define name="SUBLANG_DANISH_DENMARK" value="0x01"/>
+  <define name="SUBLANG_DARI_AFGHANISTAN" value="0x01"/>
+  <define name="SUBLANG_DEFAULT" value="0x01"/>
+  <define name="SUBLANG_DIVEHI_MALDIVES" value="0x01"/>
+  <define name="SUBLANG_DUTCH" value="0x01"/>
+  <define name="SUBLANG_DUTCH_BELGIAN" value="0x02"/>
+  <define name="SUBLANG_ENGLISH_AUS" value="0x03"/>
+  <define name="SUBLANG_ENGLISH_BELIZE" value="0x0a"/>
+  <define name="SUBLANG_ENGLISH_CAN" value="0x04"/>
+  <define name="SUBLANG_ENGLISH_CARIBBEAN" value="0x09"/>
+  <define name="SUBLANG_ENGLISH_EIRE" value="0x06"/>
+  <define name="SUBLANG_ENGLISH_INDIA" value="0x10"/>
+  <define name="SUBLANG_ENGLISH_JAMAICA" value="0x08"/>
+  <define name="SUBLANG_ENGLISH_MALAYSIA" value="0x11"/>
+  <define name="SUBLANG_ENGLISH_NZ" value="0x05"/>
+  <define name="SUBLANG_ENGLISH_PHILIPPINES" value="0x0d"/>
+  <define name="SUBLANG_ENGLISH_SINGAPORE" value="0x12"/>
+  <define name="SUBLANG_ENGLISH_SOUTH_AFRICA" value="0x07"/>
+  <define name="SUBLANG_ENGLISH_TRINIDAD" value="0x0b"/>
+  <define name="SUBLANG_ENGLISH_UK" value="0x02"/>
+  <define name="SUBLANG_ENGLISH_US" value="0x01"/>
+  <define name="SUBLANG_ENGLISH_ZIMBABWE" value="0x0c"/>
+  <define name="SUBLANG_ESTONIAN_ESTONIA" value="0x01"/>
+  <define name="SUBLANG_FAEROESE_FAROE_ISLANDS" value="0x01"/>
+  <define name="SUBLANG_FILIPINO_PHILIPPINES" value="0x01"/>
+  <define name="SUBLANG_FINNISH_FINLAND" value="0x01"/>
+  <define name="SUBLANG_FRENCH" value="0x01"/>
+  <define name="SUBLANG_FRENCH_BELGIAN" value="0x02"/>
+  <define name="SUBLANG_FRENCH_CANADIAN" value="0x03"/>
+  <define name="SUBLANG_FRENCH_LUXEMBOURG" value="0x05"/>
+  <define name="SUBLANG_FRENCH_MONACO" value="0x06"/>
+  <define name="SUBLANG_FRENCH_SWISS" value="0x04"/>
+  <define name="SUBLANG_FRISIAN_NETHERLANDS" value="0x01"/>
+  <define name="SUBLANG_FULAH_SENEGAL" value="0x02"/>
+  <define name="SUBLANG_GALICIAN_GALICIAN" value="0x01"/>
+  <define name="SUBLANG_GEORGIAN_GEORGIA" value="0x01"/>
+  <define name="SUBLANG_GERMAN" value="0x01"/>
+  <define name="SUBLANG_GERMAN_AUSTRIAN" value="0x03"/>
+  <define name="SUBLANG_GERMAN_LIECHTENSTEIN" value="0x05"/>
+  <define name="SUBLANG_GERMAN_LUXEMBOURG" value="0x04"/>
+  <define name="SUBLANG_GERMAN_SWISS" value="0x02"/>
+  <define name="SUBLANG_GREEK_GREECE" value="0x01"/>
+  <define name="SUBLANG_GREENLANDIC_GREENLAND" value="0x01"/>
+  <define name="SUBLANG_GUJARATI_INDIA" value="0x01"/>
+  <define name="SUBLANG_HAUSA_NIGERIA_LATIN" value="0x01"/>
+  <define name="SUBLANG_HAWAIIAN_US" value="0x01"/>
+  <define name="SUBLANG_HEBREW_ISRAEL" value="0x01"/>
+  <define name="SUBLANG_HINDI_INDIA" value="0x01"/>
+  <define name="SUBLANG_HUNGARIAN_HUNGARY" value="0x01"/>
+  <define name="SUBLANG_ICELANDIC_ICELAND" value="0x01"/>
+  <define name="SUBLANG_IGBO_NIGERIA" value="0x01"/>
+  <define name="SUBLANG_INDONESIAN_INDONESIA" value="0x01"/>
+  <define name="SUBLANG_INUKTITUT_CANADA" value="0x01"/>
+  <define name="SUBLANG_INUKTITUT_CANADA_LATIN" value="0x02"/>
+  <define name="SUBLANG_IRISH_IRELAND" value="0x02"/>
+  <define name="SUBLANG_ITALIAN" value="0x01"/>
+  <define name="SUBLANG_ITALIAN_SWISS" value="0x02"/>
+  <define name="SUBLANG_JAPANESE_JAPAN" value="0x01"/>
+  <define name="SUBLANG_KANNADA_INDIA" value="0x01"/>
+  <define name="SUBLANG_KASHMIRI_INDIA" value="0x02"/>
+  <define name="SUBLANG_KASHMIRI_SASIA" value="0x02"/>
+  <define name="SUBLANG_KAZAK_KAZAKHSTAN" value="0x01"/>
+  <define name="SUBLANG_KHMER_CAMBODIA" value="0x01"/>
+  <define name="SUBLANG_KICHE_GUATEMALA" value="0x01"/>
+  <define name="SUBLANG_KINYARWANDA_RWANDA" value="0x01"/>
+  <define name="SUBLANG_KONKANI_INDIA" value="0x01"/>
+  <define name="SUBLANG_KOREAN" value="0x01"/>
+  <define name="SUBLANG_KYRGYZ_KYRGYZSTAN" value="0x01"/>
+  <define name="SUBLANG_LAO_LAO" value="0x01"/>
+  <define name="SUBLANG_LATVIAN_LATVIA" value="0x01"/>
+  <define name="SUBLANG_LITHUANIAN" value="0x01"/>
+  <define name="SUBLANG_LOWER_SORBIAN_GERMANY" value="0x02"/>
+  <define name="SUBLANG_LUXEMBOURGISH_LUXEMBOURG" value="0x01"/>
+  <define name="SUBLANG_MACEDONIAN_MACEDONIA" value="0x01"/>
+  <define name="SUBLANG_MALAYALAM_INDIA" value="0x01"/>
+  <define name="SUBLANG_MALAY_BRUNEI_DARUSSALAM" value="0x02"/>
+  <define name="SUBLANG_MALAY_MALAYSIA" value="0x01"/>
+  <define name="SUBLANG_MALTESE_MALTA" value="0x01"/>
+  <define name="SUBLANG_MAORI_NEW_ZEALAND" value="0x01"/>
+  <define name="SUBLANG_MAPUDUNGUN_CHILE" value="0x01"/>
+  <define name="SUBLANG_MARATHI_INDIA" value="0x01"/>
+  <define name="SUBLANG_MOHAWK_MOHAWK" value="0x01"/>
+  <define name="SUBLANG_MONGOLIAN_CYRILLIC_MONGOLIA" value="0x01"/>
+  <define name="SUBLANG_MONGOLIAN_PRC" value="0x02"/>
+  <define name="SUBLANG_NEPALI_INDIA" value="0x02"/>
+  <define name="SUBLANG_NEPALI_NEPAL" value="0x01"/>
+  <define name="SUBLANG_NEUTRAL" value="0x00"/>
+  <define name="SUBLANG_NORWEGIAN_BOKMAL" value="0x01"/>
+  <define name="SUBLANG_NORWEGIAN_NYNORSK" value="0x02"/>
+  <define name="SUBLANG_OCCITAN_FRANCE" value="0x01"/>
+  <define name="SUBLANG_ODIA_INDIA" value="0x01"/>
+  <define name="SUBLANG_ORIYA_INDIA" value="0x01"/>
+  <define name="SUBLANG_PASHTO_AFGHANISTAN" value="0x01"/>
+  <define name="SUBLANG_PERSIAN_IRAN" value="0x01"/>
+  <define name="SUBLANG_POLISH_POLAND" value="0x01"/>
+  <define name="SUBLANG_PORTUGUESE" value="0x02"/>
+  <define name="SUBLANG_PORTUGUESE_BRAZILIAN" value="0x01"/>
+  <define name="SUBLANG_PULAR_SENEGAL" value="0x02"/>
+  <define name="SUBLANG_PUNJABI_INDIA" value="0x01"/>
+  <define name="SUBLANG_PUNJABI_PAKISTAN" value="0x02"/>
+  <define name="SUBLANG_QUECHUA_BOLIVIA" value="0x01"/>
+  <define name="SUBLANG_QUECHUA_ECUADOR" value="0x02"/>
+  <define name="SUBLANG_QUECHUA_PERU" value="0x03"/>
+  <define name="SUBLANG_ROMANIAN_ROMANIA" value="0x01"/>
+  <define name="SUBLANG_ROMANSH_SWITZERLAND" value="0x01"/>
+  <define name="SUBLANG_RUSSIAN_RUSSIA" value="0x01"/>
+  <define name="SUBLANG_SAKHA_RUSSIA" value="0x01"/>
+  <define name="SUBLANG_SAMI_INARI_FINLAND" value="0x09"/>
+  <define name="SUBLANG_SAMI_LULE_NORWAY" value="0x04"/>
+  <define name="SUBLANG_SAMI_LULE_SWEDEN" value="0x05"/>
+  <define name="SUBLANG_SAMI_NORTHERN_FINLAND" value="0x03"/>
+  <define name="SUBLANG_SAMI_NORTHERN_NORWAY" value="0x01"/>
+  <define name="SUBLANG_SAMI_NORTHERN_SWEDEN" value="0x02"/>
+  <define name="SUBLANG_SAMI_SKOLT_FINLAND" value="0x08"/>
+  <define name="SUBLANG_SAMI_SOUTHERN_NORWAY" value="0x06"/>
+  <define name="SUBLANG_SAMI_SOUTHERN_SWEDEN" value="0x07"/>
+  <define name="SUBLANG_SANSKRIT_INDIA" value="0x01"/>
+  <define name="SUBLANG_SCOTTISH_GAELIC" value="0x01"/>
+  <define name="SUBLANG_SERBIAN_BOSNIA_HERZEGOVINA_CYRILLIC" value="0x07"/>
+  <define name="SUBLANG_SERBIAN_BOSNIA_HERZEGOVINA_LATIN" value="0x06"/>
+  <define name="SUBLANG_SERBIAN_CROATIA" value="0x01"/>
+  <define name="SUBLANG_SERBIAN_CYRILLIC" value="0x03"/>
+  <define name="SUBLANG_SERBIAN_LATIN" value="0x02"/>
+  <define name="SUBLANG_SERBIAN_MONTENEGRO_CYRILLIC" value="0x0c"/>
+  <define name="SUBLANG_SERBIAN_MONTENEGRO_LATIN" value="0x0b"/>
+  <define name="SUBLANG_SERBIAN_SERBIA_CYRILLIC" value="0x0a"/>
+  <define name="SUBLANG_SERBIAN_SERBIA_LATIN" value="0x09"/>
+  <define name="SUBLANG_SINDHI_AFGHANISTAN" value="0x02"/>
+  <define name="SUBLANG_SINDHI_INDIA" value="0x01"/>
+  <define name="SUBLANG_SINDHI_PAKISTAN" value="0x02"/>
+  <define name="SUBLANG_SINHALESE_SRI_LANKA" value="0x01"/>
+  <define name="SUBLANG_SLOVAK_SLOVAKIA" value="0x01"/>
+  <define name="SUBLANG_SLOVENIAN_SLOVENIA" value="0x01"/>
+  <define name="SUBLANG_SOTHO_NORTHERN_SOUTH_AFRICA" value="0x01"/>
+  <define name="SUBLANG_SPANISH" value="0x01"/>
+  <define name="SUBLANG_SPANISH_ARGENTINA" value="0x0b"/>
+  <define name="SUBLANG_SPANISH_BOLIVIA" value="0x10"/>
+  <define name="SUBLANG_SPANISH_CHILE" value="0x0d"/>
+  <define name="SUBLANG_SPANISH_COLOMBIA" value="0x09"/>
+  <define name="SUBLANG_SPANISH_COSTA_RICA" value="0x05"/>
+  <define name="SUBLANG_SPANISH_DOMINICAN_REPUBLIC" value="0x07"/>
+  <define name="SUBLANG_SPANISH_ECUADOR" value="0x0c"/>
+  <define name="SUBLANG_SPANISH_EL_SALVADOR" value="0x11"/>
+  <define name="SUBLANG_SPANISH_GUATEMALA" value="0x04"/>
+  <define name="SUBLANG_SPANISH_HONDURAS" value="0x12"/>
+  <define name="SUBLANG_SPANISH_MEXICAN" value="0x02"/>
+  <define name="SUBLANG_SPANISH_MODERN" value="0x03"/>
+  <define name="SUBLANG_SPANISH_NICARAGUA" value="0x13"/>
+  <define name="SUBLANG_SPANISH_PANAMA" value="0x06"/>
+  <define name="SUBLANG_SPANISH_PARAGUAY" value="0x0f"/>
+  <define name="SUBLANG_SPANISH_PERU" value="0x0a"/>
+  <define name="SUBLANG_SPANISH_PUERTO_RICO" value="0x14"/>
+  <define name="SUBLANG_SPANISH_URUGUAY" value="0x0e"/>
+  <define name="SUBLANG_SPANISH_US" value="0x15"/>
+  <define name="SUBLANG_SPANISH_VENEZUELA" value="0x08"/>
+  <define name="SUBLANG_SWAHILI_KENYA" value="0x01"/>
+  <define name="SUBLANG_SWEDISH" value="0x01"/>
+  <define name="SUBLANG_SWEDISH_FINLAND" value="0x02"/>
+  <define name="SUBLANG_SYRIAC_SYRIA" value="0x01"/>
+  <define name="SUBLANG_SYS_DEFAULT" value="0x02"/>
+  <define name="SUBLANG_TAJIK_TAJIKISTAN" value="0x01"/>
+  <define name="SUBLANG_TAMAZIGHT_ALGERIA_LATIN" value="0x02"/>
+  <define name="SUBLANG_TAMAZIGHT_MOROCCO_TIFINAGH" value="0x04"/>
+  <define name="SUBLANG_TAMIL_INDIA" value="0x01"/>
+  <define name="SUBLANG_TAMIL_SRI_LANKA" value="0x02"/>
+  <define name="SUBLANG_TATAR_RUSSIA" value="0x01"/>
+  <define name="SUBLANG_TELUGU_INDIA" value="0x01"/>
+  <define name="SUBLANG_THAI_THAILAND" value="0x01"/>
+  <define name="SUBLANG_TIBETAN_PRC" value="0x01"/>
+  <define name="SUBLANG_TIGRIGNA_ERITREA" value="0x02"/>
+  <define name="SUBLANG_TIGRINYA_ERITREA" value="0x02"/>
+  <define name="SUBLANG_TIGRINYA_ETHIOPIA" value="0x01"/>
+  <define name="SUBLANG_TSWANA_BOTSWANA" value="0x02"/>
+  <define name="SUBLANG_TSWANA_SOUTH_AFRICA" value="0x01"/>
+  <define name="SUBLANG_TURKISH_TURKEY" value="0x01"/>
+  <define name="SUBLANG_TURKMEN_TURKMENISTAN" value="0x01"/>
+  <define name="SUBLANG_UIGHUR_PRC" value="0x01"/>
+  <define name="SUBLANG_UI_CUSTOM_DEFAULT" value="0x05"/>
+  <define name="SUBLANG_UKRAINIAN_UKRAINE" value="0x01"/>
+  <define name="SUBLANG_UPPER_SORBIAN_GERMANY" value="0x01"/>
+  <define name="SUBLANG_URDU_INDIA" value="0x02"/>
+  <define name="SUBLANG_URDU_PAKISTAN" value="0x01"/>
+  <define name="SUBLANG_UZBEK_CYRILLIC" value="0x02"/>
+  <define name="SUBLANG_UZBEK_LATIN" value="0x01"/>
+  <define name="SUBLANG_VALENCIAN_VALENCIA" value="0x02"/>
+  <define name="SUBLANG_VIETNAMESE_VIETNAM" value="0x01"/>
+  <define name="SUBLANG_WELSH_UNITED_KINGDOM" value="0x01"/>
+  <define name="SUBLANG_WOLOF_SENEGAL" value="0x01"/>
+  <define name="SUBLANG_XHOSA_SOUTH_AFRICA" value="0x01"/>
+  <define name="SUBLANG_YAKUT_RUSSIA" value="0x01"/>
+  <define name="SUBLANG_YI_PRC" value="0x01"/>
+  <define name="SUBLANG_YORUBA_NIGERIA" value="0x01"/>
+  <define name="SUBLANG_ZULU_SOUTH_AFRICA" value="0x01"/>
+  <define name="FILE_ALL_ACCESS" value="(STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1FF)"/>
+  <define name="MAXIMUM_WAIT_OBJECTS" value="64"/>
+  <define name="MAXIMUM_SUSPEND_COUNT" value="0x7F"/>
+  <define name="VBS_BASIC_PAGE_MEASURED_DATA" value="0x00000001"/>
+  <define name="VBS_BASIC_PAGE_UNMEASURED_DATA" value="0x00000002"/>
+  <define name="VBS_BASIC_PAGE_ZERO_FILL" value="0x00000003"/>
+  <define name="VBS_BASIC_PAGE_THREAD_DESCRIPTOR" value="0x00000004"/>
+  <define name="VBS_BASIC_PAGE_SYSTEM_CALL" value="0x00000005"/>
+  <define name="MEM_EXTENDED_PARAMETER_NONPAGED" value="0x00000002"/>
+  <define name="MEM_EXTENDED_PARAMETER_ZERO_PAGES_OPTIONAL" value="0x00000004"/>
+  <define name="MEM_EXTENDED_PARAMETER_NONPAGED_LARGE" value="0x00000008"/>
+  <define name="MEM_EXTENDED_PARAMETER_NONPAGED_HUGE" value="0x00000010"/>
+  <!-- WinBase.h -->
+  <define name="HasOverlappedIoCompleted(lpOverlapped)" value="(((DWORD)(lpOverlapped)-&gt;Internal)!=STATUS_PENDING)"/>
+  <define name="PROCESS_DEP_ENABLE" value="0x00000001"/>
+  <define name="PROCESS_DEP_DISABLE_ATL_THUNK_EMULATION" value="0x00000002"/>
+  <define name="SCS_32BIT_BINARY" value="0"/>
+  <define name="SCS_DOS_BINARY" value="1"/>
+  <define name="SCS_WOW_BINARY" value="2"/>
+  <define name="SCS_PIF_BINARY" value="3"/>
+  <define name="SCS_POSIX_BINARY" value="4"/>
+  <define name="SCS_OS216_BINARY" value="5"/>
+  <define name="SCS_64BIT_BINARY" value="6"/>
+  <define name="DEBUG_PROCESS" value="0x00000001"/>
+  <define name="DEBUG_ONLY_THIS_PROCESS" value="0x00000002"/>
+  <define name="CREATE_SUSPENDED" value="0x00000004"/>
+  <define name="DETACHED_PROCESS" value="0x00000008"/>
+  <define name="CREATE_NEW_CONSOLE" value="0x00000010"/>
+  <define name="NORMAL_PRIORITY_CLASS" value="0x00000020"/>
+  <define name="IDLE_PRIORITY_CLASS" value="0x00000040"/>
+  <define name="HIGH_PRIORITY_CLASS" value="0x00000080"/>
+  <define name="REALTIME_PRIORITY_CLASS" value="0x00000100"/>
+  <define name="CREATE_NEW_PROCESS_GROUP" value="0x00000200"/>
+  <define name="CREATE_UNICODE_ENVIRONMENT" value="0x00000400"/>
+  <define name="CREATE_SEPARATE_WOW_VDM" value="0x00000800"/>
+  <define name="CREATE_SHARED_WOW_VDM" value="0x00001000"/>
+  <define name="CREATE_FORCEDOS" value="0x00002000"/>
+  <define name="BELOW_NORMAL_PRIORITY_CLASS" value="0x00004000"/>
+  <define name="ABOVE_NORMAL_PRIORITY_CLASS" value="0x00008000"/>
+  <define name="INHERIT_PARENT_AFFINITY" value="0x00010000"/>
+  <define name="INHERIT_CALLER_PRIORITY" value="0x00020000"/>
+  <define name="CREATE_PROTECTED_PROCESS" value="0x00040000"/>
+  <define name="EXTENDED_STARTUPINFO_PRESENT" value="0x00080000"/>
+  <define name="PROCESS_MODE_BACKGROUND_BEGIN" value="0x00100000"/>
+  <define name="PROCESS_MODE_BACKGROUND_END" value="0x00200000"/>
+  <define name="CREATE_SECURE_PROCESS" value="0x00400000"/>
+  <define name="CREATE_BREAKAWAY_FROM_JOB" value="0x01000000"/>
+  <define name="CREATE_PRESERVE_CODE_AUTHZ_LEVEL" value="0x02000000"/>
+  <define name="CREATE_DEFAULT_ERROR_MODE" value="0x04000000"/>
+  <define name="CREATE_NO_WINDOW" value="0x08000000"/>
+  <define name="PROFILE_USER" value="0x10000000"/>
+  <define name="PROFILE_KERNEL" value="0x20000000"/>
+  <define name="PROFILE_SERVER" value="0x40000000"/>
+  <define name="CREATE_IGNORE_SYSTEM_DEFAULT" value="0x80000000"/>
+  <define name="STACK_SIZE_PARAM_IS_A_RESERVATION" value="0x00010000"/>
+  <define name="THREAD_PRIORITY_LOWEST" value="THREAD_BASE_PRIORITY_MIN"/>
+  <define name="THREAD_PRIORITY_BELOW_NORMAL" value="(THREAD_PRIORITY_LOWEST+1)"/>
+  <define name="THREAD_PRIORITY_NORMAL" value="0"/>
+  <define name="THREAD_PRIORITY_HIGHEST" value="THREAD_BASE_PRIORITY_MAX"/>
+  <define name="THREAD_PRIORITY_ABOVE_NORMAL" value="(THREAD_PRIORITY_HIGHEST-1)"/>
+  <define name="THREAD_PRIORITY_ERROR_RETURN" value="(MAXLONG)"/>
+  <define name="THREAD_PRIORITY_TIME_CRITICAL" value="THREAD_BASE_PRIORITY_LOWRT"/>
+  <define name="THREAD_PRIORITY_IDLE" value="THREAD_BASE_PRIORITY_IDLE"/>
+  <define name="THREAD_MODE_BACKGROUND_BEGIN" value="0x00010000"/>
+  <define name="THREAD_MODE_BACKGROUND_END" value="0x00020000"/>
+  <define name="VOLUME_NAME_DOS" value="0x0"/>
+  <define name="VOLUME_NAME_GUID" value="0x1"/>
+  <define name="VOLUME_NAME_NT" value="0x2"/>
+  <define name="VOLUME_NAME_NONE" value="0x4"/>
+  <define name="FILE_NAME_NORMALIZED" value="0x0"/>
+  <define name="FILE_NAME_OPENED" value="0x8"/>
+  <define name="FreeModule(hLibModule)" value="FreeLibrary((hLibModule))"/>
+  <define name="MakeProcInstance(lpProc,hInstance)" value="(lpProc)"/>
+  <define name="FreeProcInstance(lpProc)" value="(lpProc)"/>
+  <define name="GMEM_FIXED" value="0x0000"/>
+  <define name="GMEM_MOVEABLE" value="0x0002"/>
+  <define name="GMEM_NOCOMPACT" value="0x0010"/>
+  <define name="GMEM_NODISCARD" value="0x0020"/>
+  <define name="GMEM_ZEROINIT" value="0x0040"/>
+  <define name="GMEM_MODIFY" value="0x0080"/>
+  <define name="GMEM_DISCARDABLE" value="0x0100"/>
+  <define name="GMEM_NOT_BANKED" value="0x1000"/>
+  <define name="GMEM_SHARE" value="0x2000"/>
+  <define name="GMEM_DDESHARE" value="0x2000"/>
+  <define name="GMEM_NOTIFY" value="0x4000"/>
+  <define name="GMEM_LOWER" value="GMEM_NOT_BANKED"/>
+  <define name="GMEM_VALID_FLAGS" value="0x7F72"/>
+  <define name="GMEM_INVALID_HANDLE" value="0x8000"/>
+  <define name="GHND" value="(GMEM_MOVEABLE|GMEM_ZEROINIT)"/>
+  <define name="GPTR" value="(GMEM_FIXED|GMEM_ZEROINIT)"/>
+  <define name="GlobalLRUNewest(h)" value="((HANDLE)(h))"/>
+  <define name="GlobalLRUOldest(h)" value="((HANDLE)(h))"/>
+  <define name="GlobalDiscard(h)" value="GlobalReAlloc((h),0,GMEM_MOVEABLE)"/>
+  <define name="GMEM_DISCARDED" value="0x4000"/>
+  <define name="GMEM_LOCKCOUNT" value="0x00FF"/>
+  <define name="FORMAT_MESSAGE_ALLOCATE_BUFFER" value="0x00000100"/>
+  <define name="FORMAT_MESSAGE_ARGUMENT_ARRAY" value="0x00002000"/>
+  <define name="FORMAT_MESSAGE_FROM_HMODULE" value="0x00000800"/>
+  <define name="FORMAT_MESSAGE_FROM_STRING" value="0x00000400"/>
+  <define name="FORMAT_MESSAGE_FROM_SYSTEM" value="0x00001000"/>
+  <define name="FORMAT_MESSAGE_IGNORE_INSERTS" value="0x00000200"/>
+  <define name="FORMAT_MESSAGE_MAX_WIDTH_MASK" value="0x000000FF"/>
+  <!-- consoleapi3.h -->
+  <define name="CONSOLE_NO_SELECTION" value="0x0000"/>
+  <define name="CONSOLE_SELECTION_IN_PROGRESS" value="0x0001"/>
+  <define name="CONSOLE_SELECTION_NOT_EMPTY" value="0x0002"/>
+  <define name="CONSOLE_MOUSE_SELECTION" value="0x0004"/>
+  <define name="CONSOLE_MOUSE_DOWN" value="0x0008"/>
+  <define name="CONSOLE_FULLSCREEN" value="1"/>
+  <define name="CONSOLE_FULLSCREEN_HARDWARE" value="2"/>
+  <define name="CONSOLE_FULLSCREEN_MODE" value="1"/>
+  <define name="CONSOLE_WINDOWED_MODE" value="2"/>
+  <!-- wingdi.h -->
+  <define name="ABORTDOC" value="2"/>
+  <define name="ABSOLUTE" value="1"/>
+  <define name="AC_SRC_ALPHA" value="0x01"/>
+  <define name="AC_SRC_OVER" value="0x00"/>
+  <define name="AD_CLOCKWISE" value="2"/>
+  <define name="AD_COUNTERCLOCKWISE" value="1"/>
+  <define name="ALTERNATE" value="1"/>
+  <define name="ANSI_CHARSET" value="0"/>
+  <define name="ANSI_FIXED_FONT" value="11"/>
+  <define name="ANSI_VAR_FONT" value="12"/>
+  <define name="ANTIALIASED_QUALITY" value="4"/>
+  <define name="ARABIC_CHARSET" value="178"/>
+  <define name="ASPECTX" value="40"/>
+  <define name="ASPECTXY" value="44"/>
+  <define name="ASPECTY" value="42"/>
+  <define name="ASPECT_FILTERING" value="0x0001"/>
+  <define name="AddFontResource" value="AddFontResourceA"/>
+  <define name="AddFontResourceEx" value="AddFontResourceExA"/>
+  <define name="BALTIC_CHARSET" value="186"/>
+  <define name="BANDINFO" value="24"/>
+  <define name="BEGIN_PATH" value="4096"/>
+  <define name="BITSPIXEL" value="12"/>
+  <define name="BI_BITFIELDS" value="3L"/>
+  <define name="BI_JPEG" value="4L"/>
+  <define name="BI_PNG" value="5L"/>
+  <define name="BI_RGB" value="0L"/>
+  <define name="BI_RLE4" value="2L"/>
+  <define name="BI_RLE8" value="1L"/>
+  <define name="BKMODE_LAST" value="2"/>
+  <define name="BLACKNESS" value="(DWORD)0x00000042"/>
+  <define name="BLACKONWHITE" value="1"/>
+  <define name="BLACK_BRUSH" value="4"/>
+  <define name="BLACK_PEN" value="7"/>
+  <define name="BLTALIGNMENT" value="119"/>
+  <define name="BS_DIBPATTERN" value="5"/>
+  <define name="BS_DIBPATTERN8X8" value="8"/>
+  <define name="BS_DIBPATTERNPT" value="6"/>
+  <define name="BS_HATCHED" value="2"/>
+  <define name="BS_HOLLOW" value="BS_NULL"/>
+  <define name="BS_INDEXED" value="4"/>
+  <define name="BS_MONOPATTERN" value="9"/>
+  <define name="BS_NULL" value="1"/>
+  <define name="BS_PATTERN" value="3"/>
+  <define name="BS_PATTERN8X8" value="7"/>
+  <define name="BS_SOLID" value="0"/>
+  <define name="CAPTUREBLT" value="(DWORD)0x40000000"/>
+  <define name="CA_LOG_FILTER" value="0x0002"/>
+  <define name="CA_NEGATIVE" value="0x0001"/>
+  <define name="CBM_INIT" value="0x04L"/>
+  <define name="CCHDEVICENAME" value="32"/>
+  <define name="CCHFORMNAME" value="32"/>
+  <define name="CC_CHORD" value="4"/>
+  <define name="CC_CIRCLES" value="1"/>
+  <define name="CC_ELLIPSES" value="8"/>
+  <define name="CC_INTERIORS" value="128"/>
+  <define name="CC_NONE" value="0"/>
+  <define name="CC_PIE" value="2"/>
+  <define name="CC_ROUNDRECT" value="256"/>
+  <define name="CC_STYLED" value="32"/>
+  <define name="CC_WIDE" value="16"/>
+  <define name="CC_WIDESTYLED" value="64"/>
+  <define name="CHECKJPEGFORMAT" value="4119"/>
+  <define name="CHECKPNGFORMAT" value="4120"/>
+  <define name="CHINESEBIG5_CHARSET" value="136"/>
+  <define name="CLEARTYPE_NATURAL_QUALITY" value="6"/>
+  <define name="CLEARTYPE_QUALITY" value="5"/>
+  <define name="CLIPCAPS" value="36"/>
+  <define name="CLIP_CHARACTER_PRECIS" value="1"/>
+  <define name="CLIP_DEFAULT_PRECIS" value="0"/>
+  <define name="CLIP_DFA_DISABLE" value="(4&lt;&lt;4)"/>
+  <define name="CLIP_EMBEDDED" value="(8&lt;&lt;4)"/>
+  <define name="CLIP_LH_ANGLES" value="(1&lt;&lt;4)"/>
+  <define name="CLIP_MASK" value="0xf"/>
+  <define name="CLIP_STROKE_PRECIS" value="2"/>
+  <define name="CLIP_TO_PATH" value="4097"/>
+  <define name="CLIP_TT_ALWAYS" value="(2&lt;&lt;4)"/>
+  <define name="CLOSECHANNEL" value="4112"/>
+  <define name="CLR_INVALID" value="0xFFFFFFFF"/>
+  <define name="CMYK(c,m,y,k)" value="((COLORREF)((((BYTE)(k)|((WORD)((BYTE)(y))&lt;&lt;8))|(((DWORD)(BYTE)(m))&lt;&lt;16))|(((DWORD)(BYTE)(c))&lt;&lt;24)))"/>
+  <define name="CM_CMYK_COLOR" value="0x00000004"/>
+  <define name="CM_DEVICE_ICM" value="0x00000001"/>
+  <define name="CM_GAMMA_RAMP" value="0x00000002"/>
+  <define name="CM_IN_GAMUT" value="0"/>
+  <define name="CM_NONE" value="0x00000000"/>
+  <define name="CM_OUT_OF_GAMUT" value="255"/>
+  <define name="COLORMATCHTOTARGET_EMBEDED" value="0x00000001"/>
+  <define name="COLORMGMTCAPS" value="121"/>
+  <define name="COLORONCOLOR" value="3"/>
+  <define name="COLORRES" value="108"/>
+  <define name="COLOR_ADJ_MAX" value="(SHORT)100"/>
+  <define name="COLOR_ADJ_MIN" value="(SHORT)-100"/>
+  <define name="COMPLEXREGION" value="3"/>
+  <define name="CP_NONE" value="0"/>
+  <define name="CP_RECTANGLE" value="1"/>
+  <define name="CP_REGION" value="2"/>
+  <define name="CREATECOLORSPACE_EMBEDED" value="0x00000001"/>
+  <define name="CS_DELETE_TRANSFORM" value="0x00000003L"/>
+  <define name="CS_DISABLE" value="0x00000002L"/>
+  <define name="CS_ENABLE" value="0x00000001L"/>
+  <define name="CURVECAPS" value="28"/>
+  <define name="CopyEnhMetaFile" value="CopyEnhMetaFileA"/>
+  <define name="CopyMetaFile" value="CopyMetaFileA"/>
+  <define name="CreateColorSpace" value="CreateColorSpaceA"/>
+  <define name="CreateDC" value="CreateDCA"/>
+  <define name="CreateEnhMetaFile" value="CreateEnhMetaFileA"/>
+  <define name="CreateFont" value="CreateFontA"/>
+  <define name="CreateFontIndirect" value="CreateFontIndirectA"/>
+  <define name="CreateFontIndirectEx" value="CreateFontIndirectExA"/>
+  <define name="CreateIC" value="CreateICA"/>
+  <define name="CreateMetaFile" value="CreateMetaFileA"/>
+  <define name="CreateScalableFontResource" value="CreateScalableFontResourceA"/>
+  <define name="DCBA_FACEDOWNCENTER" value="0x0101"/>
+  <define name="DCBA_FACEDOWNLEFT" value="0x0102"/>
+  <define name="DCBA_FACEDOWNNONE" value="0x0100"/>
+  <define name="DCBA_FACEDOWNRIGHT" value="0x0103"/>
+  <define name="DCBA_FACEUPCENTER" value="0x0001"/>
+  <define name="DCBA_FACEUPLEFT" value="0x0002"/>
+  <define name="DCBA_FACEUPNONE" value="0x0000"/>
+  <define name="DCBA_FACEUPRIGHT" value="0x0003"/>
+  <define name="DCB_ACCUMULATE" value="0x0002"/>
+  <define name="DCB_DIRTY" value="DCB_ACCUMULATE"/>
+  <define name="DCB_DISABLE" value="0x0008"/>
+  <define name="DCB_ENABLE" value="0x0004"/>
+  <define name="DCB_RESET" value="0x0001"/>
+  <define name="DCB_SET" value="(DCB_RESET|DCB_ACCUMULATE)"/>
+  <define name="DCTT_BITMAP" value="0x0000001L"/>
+  <define name="DCTT_DOWNLOAD" value="0x0000002L"/>
+  <define name="DCTT_DOWNLOAD_OUTLINE" value="0x0000008L"/>
+  <define name="DCTT_SUBDEV" value="0x0000004L"/>
+  <define name="DC_BINADJUST" value="19"/>
+  <define name="DC_BINNAMES" value="12"/>
+  <define name="DC_BINS" value="6"/>
+  <define name="DC_BRUSH" value="18"/>
+  <define name="DC_COLLATE" value="22"/>
+  <define name="DC_COLORDEVICE" value="32"/>
+  <define name="DC_COPIES" value="18"/>
+  <define name="DC_DATATYPE_PRODUCED" value="21"/>
+  <define name="DC_DRIVER" value="11"/>
+  <define name="DC_DUPLEX" value="7"/>
+  <define name="DC_EMF_COMPLIANT" value="20"/>
+  <define name="DC_ENUMRESOLUTIONS" value="13"/>
+  <define name="DC_EXTRA" value="9"/>
+  <define name="DC_FIELDS" value="1"/>
+  <define name="DC_FILEDEPENDENCIES" value="14"/>
+  <define name="DC_MANUFACTURER" value="23"/>
+  <define name="DC_MAXEXTENT" value="5"/>
+  <define name="DC_MEDIAREADY" value="29"/>
+  <define name="DC_MEDIATYPENAMES" value="34"/>
+  <define name="DC_MEDIATYPES" value="35"/>
+  <define name="DC_MINEXTENT" value="4"/>
+  <define name="DC_MODEL" value="24"/>
+  <define name="DC_NUP" value="33"/>
+  <define name="DC_ORIENTATION" value="17"/>
+  <define name="DC_PAPERNAMES" value="16"/>
+  <define name="DC_PAPERS" value="2"/>
+  <define name="DC_PAPERSIZE" value="3"/>
+  <define name="DC_PEN" value="19"/>
+  <define name="DC_PERSONALITY" value="25"/>
+  <define name="DC_PRINTERMEM" value="28"/>
+  <define name="DC_PRINTRATE" value="26"/>
+  <define name="DC_PRINTRATEPPM" value="31"/>
+  <define name="DC_PRINTRATEUNIT" value="27"/>
+  <define name="DC_SIZE" value="8"/>
+  <define name="DC_STAPLE" value="30"/>
+  <define name="DC_TRUETYPE" value="15"/>
+  <define name="DC_VERSION" value="10"/>
+  <define name="DEFAULT_CHARSET" value="1"/>
+  <define name="DEFAULT_GUI_FONT" value="17"/>
+  <define name="DEFAULT_PALETTE" value="15"/>
+  <define name="DEFAULT_PITCH" value="0"/>
+  <define name="DEFAULT_QUALITY" value="0"/>
+  <define name="DESKTOPHORZRES" value="118"/>
+  <define name="DESKTOPVERTRES" value="117"/>
+  <define name="DEVICEDATA" value="19"/>
+  <define name="DEVICE_DEFAULT_FONT" value="14"/>
+  <define name="DEVICE_FONTTYPE" value="0x0002"/>
+  <define name="DIB_PAL_COLORS" value="1"/>
+  <define name="DIB_RGB_COLORS" value="0"/>
+  <define name="DISPLAYCONFIG_MAXPATH" value="1024"/>
+  <define name="DISPLAYCONFIG_PATH_ACTIVE" value="0x00000001"/>
+  <define name="DISPLAYCONFIG_PATH_CLONE_GROUP_INVALID" value="0xffff"/>
+  <define name="DISPLAYCONFIG_PATH_DESKTOP_IMAGE_IDX_INVALID" value="0xffff"/>
+  <define name="DISPLAYCONFIG_PATH_MODE_IDX_INVALID" value="0xffffffff"/>
+  <define name="DISPLAYCONFIG_PATH_PREFERRED_UNSCALED" value="0x00000004"/>
+  <define name="DISPLAYCONFIG_PATH_SOURCE_MODE_IDX_INVALID" value="0xffff"/>
+  <define name="DISPLAYCONFIG_PATH_SUPPORT_VIRTUAL_MODE" value="0x00000008"/>
+  <define name="DISPLAYCONFIG_PATH_TARGET_MODE_IDX_INVALID" value="0xffff"/>
+  <define name="DISPLAYCONFIG_PATH_VALID_FLAGS" value="0x0000000D"/>
+  <define name="DISPLAYCONFIG_SOURCE_IN_USE" value="0x00000001"/>
+  <define name="DISPLAYCONFIG_TARGET_FORCED_AVAILABILITY_BOOT" value="0x00000004"/>
+  <define name="DISPLAYCONFIG_TARGET_FORCED_AVAILABILITY_PATH" value="0x00000008"/>
+  <define name="DISPLAYCONFIG_TARGET_FORCED_AVAILABILITY_SYSTEM" value="0x00000010"/>
+  <define name="DISPLAYCONFIG_TARGET_FORCIBLE" value="0x00000002"/>
+  <define name="DISPLAYCONFIG_TARGET_IN_USE" value="0x00000001"/>
+  <define name="DISPLAYCONFIG_TARGET_IS_HMD" value="0x00000020"/>
+  <define name="DISPLAY_DEVICE_ACC_DRIVER" value="0x00000040"/>
+  <define name="DISPLAY_DEVICE_ACTIVE" value="0x00000001"/>
+  <define name="DISPLAY_DEVICE_ATTACHED" value="0x00000002"/>
+  <define name="DISPLAY_DEVICE_ATTACHED_TO_DESKTOP" value="0x00000001"/>
+  <define name="DISPLAY_DEVICE_DISCONNECT" value="0x02000000"/>
+  <define name="DISPLAY_DEVICE_MIRRORING_DRIVER" value="0x00000008"/>
+  <define name="DISPLAY_DEVICE_MODESPRUNED" value="0x08000000"/>
+  <define name="DISPLAY_DEVICE_MULTI_DRIVER" value="0x00000002"/>
+  <define name="DISPLAY_DEVICE_PRIMARY_DEVICE" value="0x00000004"/>
+  <define name="DISPLAY_DEVICE_RDPUDD" value="0x01000000"/>
+  <define name="DISPLAY_DEVICE_REMOTE" value="0x04000000"/>
+  <define name="DISPLAY_DEVICE_REMOVABLE" value="0x00000020"/>
+  <define name="DISPLAY_DEVICE_TS_COMPATIBLE" value="0x00200000"/>
+  <define name="DISPLAY_DEVICE_UNSAFE_MODES_ON" value="0x00080000"/>
+  <define name="DISPLAY_DEVICE_VGA_COMPATIBLE" value="0x00000010"/>
+  <define name="DI_APPBANDING" value="0x00000001"/>
+  <define name="DI_ROPS_READ_DESTINATION" value="0x00000002"/>
+  <define name="DKGRAY_BRUSH" value="3"/>
+  <define name="DMBIN_AUTO" value="7"/>
+  <define name="DMBIN_CASSETTE" value="14"/>
+  <define name="DMBIN_ENVELOPE" value="5"/>
+  <define name="DMBIN_ENVMANUAL" value="6"/>
+  <define name="DMBIN_FIRST" value="DMBIN_UPPER"/>
+  <define name="DMBIN_FORMSOURCE" value="15"/>
+  <define name="DMBIN_LARGECAPACITY" value="11"/>
+  <define name="DMBIN_LARGEFMT" value="10"/>
+  <define name="DMBIN_LAST" value="DMBIN_FORMSOURCE"/>
+  <define name="DMBIN_LOWER" value="2"/>
+  <define name="DMBIN_MANUAL" value="4"/>
+  <define name="DMBIN_MIDDLE" value="3"/>
+  <define name="DMBIN_ONLYONE" value="1"/>
+  <define name="DMBIN_SMALLFMT" value="9"/>
+  <define name="DMBIN_TRACTOR" value="8"/>
+  <define name="DMBIN_UPPER" value="1"/>
+  <define name="DMBIN_USER" value="256"/>
+  <define name="DMCOLLATE_FALSE" value="0"/>
+  <define name="DMCOLLATE_TRUE" value="1"/>
+  <define name="DMCOLOR_COLOR" value="2"/>
+  <define name="DMCOLOR_MONOCHROME" value="1"/>
+  <define name="DMDFO_CENTER" value="2"/>
+  <define name="DMDFO_DEFAULT" value="0"/>
+  <define name="DMDFO_STRETCH" value="1"/>
+  <define name="DMDISPLAYFLAGS_TEXTMODE" value="0x00000004"/>
+  <define name="DMDITHER_COARSE" value="2"/>
+  <define name="DMDITHER_ERRORDIFFUSION" value="5"/>
+  <define name="DMDITHER_FINE" value="3"/>
+  <define name="DMDITHER_GRAYSCALE" value="10"/>
+  <define name="DMDITHER_LINEART" value="4"/>
+  <define name="DMDITHER_NONE" value="1"/>
+  <define name="DMDITHER_RESERVED6" value="6"/>
+  <define name="DMDITHER_RESERVED7" value="7"/>
+  <define name="DMDITHER_RESERVED8" value="8"/>
+  <define name="DMDITHER_RESERVED9" value="9"/>
+  <define name="DMDITHER_USER" value="256"/>
+  <define name="DMDO_180" value="2"/>
+  <define name="DMDO_270" value="3"/>
+  <define name="DMDO_90" value="1"/>
+  <define name="DMDO_DEFAULT" value="0"/>
+  <define name="DMDUP_HORIZONTAL" value="3"/>
+  <define name="DMDUP_SIMPLEX" value="1"/>
+  <define name="DMDUP_VERTICAL" value="2"/>
+  <define name="DMICMMETHOD_DEVICE" value="4"/>
+  <define name="DMICMMETHOD_DRIVER" value="3"/>
+  <define name="DMICMMETHOD_NONE" value="1"/>
+  <define name="DMICMMETHOD_SYSTEM" value="2"/>
+  <define name="DMICMMETHOD_USER" value="256"/>
+  <define name="DMICM_ABS_COLORIMETRIC" value="4"/>
+  <define name="DMICM_COLORIMETRIC" value="3"/>
+  <define name="DMICM_CONTRAST" value="2"/>
+  <define name="DMICM_SATURATE" value="1"/>
+  <define name="DMICM_USER" value="256"/>
+  <define name="DMMEDIA_GLOSSY" value="3"/>
+  <define name="DMMEDIA_STANDARD" value="1"/>
+  <define name="DMMEDIA_TRANSPARENCY" value="2"/>
+  <define name="DMMEDIA_USER" value="256"/>
+  <define name="DMNUP_ONEUP" value="2"/>
+  <define name="DMNUP_SYSTEM" value="1"/>
+  <define name="DMORIENT_LANDSCAPE" value="2"/>
+  <define name="DMORIENT_PORTRAIT" value="1"/>
+  <define name="DMPAPER_10X11" value="45"/>
+  <define name="DMPAPER_10X14" value="16"/>
+  <define name="DMPAPER_11X17" value="17"/>
+  <define name="DMPAPER_12X11" value="90"/>
+  <define name="DMPAPER_15X11" value="46"/>
+  <define name="DMPAPER_9X11" value="44"/>
+  <define name="DMPAPER_A2" value="66"/>
+  <define name="DMPAPER_A3" value="8"/>
+  <define name="DMPAPER_A3_EXTRA" value="63"/>
+  <define name="DMPAPER_A3_EXTRA_TRANSVERSE" value="68"/>
+  <define name="DMPAPER_A3_ROTATED" value="76"/>
+  <define name="DMPAPER_A3_TRANSVERSE" value="67"/>
+  <define name="DMPAPER_A4" value="9"/>
+  <define name="DMPAPER_A4SMALL" value="10"/>
+  <define name="DMPAPER_A4_EXTRA" value="53"/>
+  <define name="DMPAPER_A4_PLUS" value="60"/>
+  <define name="DMPAPER_A4_ROTATED" value="77"/>
+  <define name="DMPAPER_A4_TRANSVERSE" value="55"/>
+  <define name="DMPAPER_A5" value="11"/>
+  <define name="DMPAPER_A5_EXTRA" value="64"/>
+  <define name="DMPAPER_A5_ROTATED" value="78"/>
+  <define name="DMPAPER_A5_TRANSVERSE" value="61"/>
+  <define name="DMPAPER_A6" value="70"/>
+  <define name="DMPAPER_A6_ROTATED" value="83"/>
+  <define name="DMPAPER_A_PLUS" value="57"/>
+  <define name="DMPAPER_B4" value="12"/>
+  <define name="DMPAPER_B4_JIS_ROTATED" value="79"/>
+  <define name="DMPAPER_B5" value="13"/>
+  <define name="DMPAPER_B5_EXTRA" value="65"/>
+  <define name="DMPAPER_B5_JIS_ROTATED" value="80"/>
+  <define name="DMPAPER_B5_TRANSVERSE" value="62"/>
+  <define name="DMPAPER_B6_JIS" value="88"/>
+  <define name="DMPAPER_B6_JIS_ROTATED" value="89"/>
+  <define name="DMPAPER_B_PLUS" value="58"/>
+  <define name="DMPAPER_CSHEET" value="24"/>
+  <define name="DMPAPER_DBL_JAPANESE_POSTCARD" value="69"/>
+  <define name="DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED" value="82"/>
+  <define name="DMPAPER_DSHEET" value="25"/>
+  <define name="DMPAPER_ENV_10" value="20"/>
+  <define name="DMPAPER_ENV_11" value="21"/>
+  <define name="DMPAPER_ENV_12" value="22"/>
+  <define name="DMPAPER_ENV_14" value="23"/>
+  <define name="DMPAPER_ENV_9" value="19"/>
+  <define name="DMPAPER_ENV_B4" value="33"/>
+  <define name="DMPAPER_ENV_B5" value="34"/>
+  <define name="DMPAPER_ENV_B6" value="35"/>
+  <define name="DMPAPER_ENV_C3" value="29"/>
+  <define name="DMPAPER_ENV_C4" value="30"/>
+  <define name="DMPAPER_ENV_C5" value="28"/>
+  <define name="DMPAPER_ENV_C6" value="31"/>
+  <define name="DMPAPER_ENV_C65" value="32"/>
+  <define name="DMPAPER_ENV_DL" value="27"/>
+  <define name="DMPAPER_ENV_INVITE" value="47"/>
+  <define name="DMPAPER_ENV_ITALY" value="36"/>
+  <define name="DMPAPER_ENV_MONARCH" value="37"/>
+  <define name="DMPAPER_ENV_PERSONAL" value="38"/>
+  <define name="DMPAPER_ESHEET" value="26"/>
+  <define name="DMPAPER_EXECUTIVE" value="7"/>
+  <define name="DMPAPER_FANFOLD_LGL_GERMAN" value="41"/>
+  <define name="DMPAPER_FANFOLD_STD_GERMAN" value="40"/>
+  <define name="DMPAPER_FANFOLD_US" value="39"/>
+  <define name="DMPAPER_FIRST" value="DMPAPER_LETTER"/>
+  <define name="DMPAPER_FOLIO" value="14"/>
+  <define name="DMPAPER_ISO_B4" value="42"/>
+  <define name="DMPAPER_JAPANESE_POSTCARD" value="43"/>
+  <define name="DMPAPER_JAPANESE_POSTCARD_ROTATED" value="81"/>
+  <define name="DMPAPER_JENV_CHOU3" value="73"/>
+  <define name="DMPAPER_JENV_CHOU3_ROTATED" value="86"/>
+  <define name="DMPAPER_JENV_CHOU4" value="74"/>
+  <define name="DMPAPER_JENV_CHOU4_ROTATED" value="87"/>
+  <define name="DMPAPER_JENV_KAKU2" value="71"/>
+  <define name="DMPAPER_JENV_KAKU2_ROTATED" value="84"/>
+  <define name="DMPAPER_JENV_KAKU3" value="72"/>
+  <define name="DMPAPER_JENV_KAKU3_ROTATED" value="85"/>
+  <define name="DMPAPER_JENV_YOU4" value="91"/>
+  <define name="DMPAPER_JENV_YOU4_ROTATED" value="92"/>
+  <define name="DMPAPER_LAST" value="DMPAPER_FANFOLD_LGL_GERMAN"/>
+  <define name="DMPAPER_LEDGER" value="4"/>
+  <define name="DMPAPER_LEGAL" value="5"/>
+  <define name="DMPAPER_LEGAL_EXTRA" value="51"/>
+  <define name="DMPAPER_LETTER" value="1"/>
+  <define name="DMPAPER_LETTERSMALL" value="2"/>
+  <define name="DMPAPER_LETTER_EXTRA" value="50"/>
+  <define name="DMPAPER_LETTER_EXTRA_TRANSVERSE" value="56"/>
+  <define name="DMPAPER_LETTER_PLUS" value="59"/>
+  <define name="DMPAPER_LETTER_ROTATED" value="75"/>
+  <define name="DMPAPER_LETTER_TRANSVERSE" value="54"/>
+  <define name="DMPAPER_NOTE" value="18"/>
+  <define name="DMPAPER_P16K" value="93"/>
+  <define name="DMPAPER_P16K_ROTATED" value="106"/>
+  <define name="DMPAPER_P32K" value="94"/>
+  <define name="DMPAPER_P32KBIG" value="95"/>
+  <define name="DMPAPER_P32KBIG_ROTATED" value="108"/>
+  <define name="DMPAPER_P32K_ROTATED" value="107"/>
+  <define name="DMPAPER_PENV_1" value="96"/>
+  <define name="DMPAPER_PENV_10" value="105"/>
+  <define name="DMPAPER_PENV_10_ROTATED" value="118"/>
+  <define name="DMPAPER_PENV_1_ROTATED" value="109"/>
+  <define name="DMPAPER_PENV_2" value="97"/>
+  <define name="DMPAPER_PENV_2_ROTATED" value="110"/>
+  <define name="DMPAPER_PENV_3" value="98"/>
+  <define name="DMPAPER_PENV_3_ROTATED" value="111"/>
+  <define name="DMPAPER_PENV_4" value="99"/>
+  <define name="DMPAPER_PENV_4_ROTATED" value="112"/>
+  <define name="DMPAPER_PENV_5" value="100"/>
+  <define name="DMPAPER_PENV_5_ROTATED" value="113"/>
+  <define name="DMPAPER_PENV_6" value="101"/>
+  <define name="DMPAPER_PENV_6_ROTATED" value="114"/>
+  <define name="DMPAPER_PENV_7" value="102"/>
+  <define name="DMPAPER_PENV_7_ROTATED" value="115"/>
+  <define name="DMPAPER_PENV_8" value="103"/>
+  <define name="DMPAPER_PENV_8_ROTATED" value="116"/>
+  <define name="DMPAPER_PENV_9" value="104"/>
+  <define name="DMPAPER_PENV_9_ROTATED" value="117"/>
+  <define name="DMPAPER_QUARTO" value="15"/>
+  <define name="DMPAPER_RESERVED_48" value="48"/>
+  <define name="DMPAPER_RESERVED_49" value="49"/>
+  <define name="DMPAPER_STATEMENT" value="6"/>
+  <define name="DMPAPER_TABLOID" value="3"/>
+  <define name="DMPAPER_TABLOID_EXTRA" value="52"/>
+  <define name="DMPAPER_USER" value="256"/>
+  <define name="DMRES_DRAFT" value="(-1)"/>
+  <define name="DMRES_HIGH" value="(-4)"/>
+  <define name="DMRES_LOW" value="(-2)"/>
+  <define name="DMRES_MEDIUM" value="(-3)"/>
+  <define name="DMTT_BITMAP" value="1"/>
+  <define name="DMTT_DOWNLOAD" value="2"/>
+  <define name="DMTT_DOWNLOAD_OUTLINE" value="4"/>
+  <define name="DMTT_SUBDEV" value="3"/>
+  <define name="DM_BITSPERPEL" value="0x00040000L"/>
+  <define name="DM_COLLATE" value="0x00008000L"/>
+  <define name="DM_COLOR" value="0x00000800L"/>
+  <define name="DM_COPIES" value="0x00000100L"/>
+  <define name="DM_COPY" value="2"/>
+  <define name="DM_DEFAULTSOURCE" value="0x00000200L"/>
+  <define name="DM_DISPLAYFIXEDOUTPUT" value="0x20000000L"/>
+  <define name="DM_DISPLAYFLAGS" value="0x00200000L"/>
+  <define name="DM_DISPLAYFREQUENCY" value="0x00400000L"/>
+  <define name="DM_DISPLAYORIENTATION" value="0x00000080L"/>
+  <define name="DM_DITHERTYPE" value="0x04000000L"/>
+  <define name="DM_DUPLEX" value="0x00001000L"/>
+  <define name="DM_FORMNAME" value="0x00010000L"/>
+  <define name="DM_ICMINTENT" value="0x01000000L"/>
+  <define name="DM_ICMMETHOD" value="0x00800000L"/>
+  <define name="DM_INTERLACED" value="0x00000002"/>
+  <define name="DM_IN_BUFFER" value="DM_MODIFY"/>
+  <define name="DM_IN_PROMPT" value="DM_PROMPT"/>
+  <define name="DM_LOGPIXELS" value="0x00020000L"/>
+  <define name="DM_MEDIATYPE" value="0x02000000L"/>
+  <define name="DM_MODIFY" value="8"/>
+  <define name="DM_NUP" value="0x00000040L"/>
+  <define name="DM_ORIENTATION" value="0x00000001L"/>
+  <define name="DM_OUT_BUFFER" value="DM_COPY"/>
+  <define name="DM_OUT_DEFAULT" value="DM_UPDATE"/>
+  <define name="DM_PANNINGHEIGHT" value="0x10000000L"/>
+  <define name="DM_PANNINGWIDTH" value="0x08000000L"/>
+  <define name="DM_PAPERLENGTH" value="0x00000004L"/>
+  <define name="DM_PAPERSIZE" value="0x00000002L"/>
+  <define name="DM_PAPERWIDTH" value="0x00000008L"/>
+  <define name="DM_PELSHEIGHT" value="0x00100000L"/>
+  <define name="DM_PELSWIDTH" value="0x00080000L"/>
+  <define name="DM_POSITION" value="0x00000020L"/>
+  <define name="DM_PRINTQUALITY" value="0x00000400L"/>
+  <define name="DM_PROMPT" value="4"/>
+  <define name="DM_SCALE" value="0x00000010L"/>
+  <define name="DM_SPECVERSION" value="0x0320"/>
+  <define name="DM_TTOPTION" value="0x00004000L"/>
+  <define name="DM_UPDATE" value="1"/>
+  <define name="DM_YRESOLUTION" value="0x00002000L"/>
+  <define name="DOWNLOADFACE" value="514"/>
+  <define name="DOWNLOADHEADER" value="4111"/>
+  <define name="DRAFTMODE" value="7"/>
+  <define name="DRAFT_QUALITY" value="1"/>
+  <define name="DRAWPATTERNRECT" value="25"/>
+  <define name="DRIVERVERSION" value="0"/>
+  <define name="DSTINVERT" value="(DWORD)0x00550009"/>
+  <define name="DT_CHARSTREAM" value="4"/>
+  <define name="DT_DISPFILE" value="6"/>
+  <define name="DT_METAFILE" value="5"/>
+  <define name="DT_PLOTTER" value="0"/>
+  <define name="DT_RASCAMERA" value="3"/>
+  <define name="DT_RASDISPLAY" value="1"/>
+  <define name="DT_RASPRINTER" value="2"/>
+  <define name="DeviceCapabilities" value="DeviceCapabilitiesA"/>
+  <define name="EASTEUROPE_CHARSET" value="238"/>
+  <define name="ELF_CULTURE_LATIN" value="0"/>
+  <define name="ELF_VENDOR_SIZE" value="4"/>
+  <define name="ELF_VERSION" value="0"/>
+  <define name="EMR_ABORTPATH" value="68"/>
+  <define name="EMR_ALPHABLEND" value="114"/>
+  <define name="EMR_ANGLEARC" value="41"/>
+  <define name="EMR_ARC" value="45"/>
+  <define name="EMR_ARCTO" value="55"/>
+  <define name="EMR_BEGINPATH" value="59"/>
+  <define name="EMR_BITBLT" value="76"/>
+  <define name="EMR_CHORD" value="46"/>
+  <define name="EMR_CLOSEFIGURE" value="61"/>
+  <define name="EMR_COLORCORRECTPALETTE" value="111"/>
+  <define name="EMR_COLORMATCHTOTARGETW" value="121"/>
+  <define name="EMR_CREATEBRUSHINDIRECT" value="39"/>
+  <define name="EMR_CREATECOLORSPACE" value="99"/>
+  <define name="EMR_CREATECOLORSPACEW" value="122"/>
+  <define name="EMR_CREATEDIBPATTERNBRUSHPT" value="94"/>
+  <define name="EMR_CREATEMONOBRUSH" value="93"/>
+  <define name="EMR_CREATEPALETTE" value="49"/>
+  <define name="EMR_CREATEPEN" value="38"/>
+  <define name="EMR_DELETECOLORSPACE" value="101"/>
+  <define name="EMR_DELETEOBJECT" value="40"/>
+  <define name="EMR_ELLIPSE" value="42"/>
+  <define name="EMR_ENDPATH" value="60"/>
+  <define name="EMR_EOF" value="14"/>
+  <define name="EMR_EXCLUDECLIPRECT" value="29"/>
+  <define name="EMR_EXTCREATEFONTINDIRECTW" value="82"/>
+  <define name="EMR_EXTCREATEPEN" value="95"/>
+  <define name="EMR_EXTFLOODFILL" value="53"/>
+  <define name="EMR_EXTSELECTCLIPRGN" value="75"/>
+  <define name="EMR_EXTTEXTOUTA" value="83"/>
+  <define name="EMR_EXTTEXTOUTW" value="84"/>
+  <define name="EMR_FILLPATH" value="62"/>
+  <define name="EMR_FILLRGN" value="71"/>
+  <define name="EMR_FLATTENPATH" value="65"/>
+  <define name="EMR_FRAMERGN" value="72"/>
+  <define name="EMR_GDICOMMENT" value="70"/>
+  <define name="EMR_GLSBOUNDEDRECORD" value="103"/>
+  <define name="EMR_GLSRECORD" value="102"/>
+  <define name="EMR_GRADIENTFILL" value="118"/>
+  <define name="EMR_HEADER" value="1"/>
+  <define name="EMR_INTERSECTCLIPRECT" value="30"/>
+  <define name="EMR_INVERTRGN" value="73"/>
+  <define name="EMR_LINETO" value="54"/>
+  <define name="EMR_MASKBLT" value="78"/>
+  <define name="EMR_MAX" value="97"/>
+  <define name="EMR_MIN" value="1"/>
+  <define name="EMR_MODIFYWORLDTRANSFORM" value="36"/>
+  <define name="EMR_MOVETOEX" value="27"/>
+  <define name="EMR_OFFSETCLIPRGN" value="26"/>
+  <define name="EMR_PAINTRGN" value="74"/>
+  <define name="EMR_PIE" value="47"/>
+  <define name="EMR_PIXELFORMAT" value="104"/>
+  <define name="EMR_PLGBLT" value="79"/>
+  <define name="EMR_POLYBEZIER" value="2"/>
+  <define name="EMR_POLYBEZIER16" value="85"/>
+  <define name="EMR_POLYBEZIERTO" value="5"/>
+  <define name="EMR_POLYBEZIERTO16" value="88"/>
+  <define name="EMR_POLYDRAW" value="56"/>
+  <define name="EMR_POLYDRAW16" value="92"/>
+  <define name="EMR_POLYGON" value="3"/>
+  <define name="EMR_POLYGON16" value="86"/>
+  <define name="EMR_POLYLINE" value="4"/>
+  <define name="EMR_POLYLINE16" value="87"/>
+  <define name="EMR_POLYLINETO" value="6"/>
+  <define name="EMR_POLYLINETO16" value="89"/>
+  <define name="EMR_POLYPOLYGON" value="8"/>
+  <define name="EMR_POLYPOLYGON16" value="91"/>
+  <define name="EMR_POLYPOLYLINE" value="7"/>
+  <define name="EMR_POLYPOLYLINE16" value="90"/>
+  <define name="EMR_POLYTEXTOUTA" value="96"/>
+  <define name="EMR_POLYTEXTOUTW" value="97"/>
+  <define name="EMR_REALIZEPALETTE" value="52"/>
+  <define name="EMR_RECTANGLE" value="43"/>
+  <define name="EMR_RESERVED_105" value="105"/>
+  <define name="EMR_RESERVED_106" value="106"/>
+  <define name="EMR_RESERVED_107" value="107"/>
+  <define name="EMR_RESERVED_108" value="108"/>
+  <define name="EMR_RESERVED_109" value="109"/>
+  <define name="EMR_RESERVED_110" value="110"/>
+  <define name="EMR_RESERVED_117" value="117"/>
+  <define name="EMR_RESERVED_119" value="119"/>
+  <define name="EMR_RESERVED_120" value="120"/>
+  <define name="EMR_RESIZEPALETTE" value="51"/>
+  <define name="EMR_RESTOREDC" value="34"/>
+  <define name="EMR_ROUNDRECT" value="44"/>
+  <define name="EMR_SAVEDC" value="33"/>
+  <define name="EMR_SCALEVIEWPORTEXTEX" value="31"/>
+  <define name="EMR_SCALEWINDOWEXTEX" value="32"/>
+  <define name="EMR_SELECTCLIPPATH" value="67"/>
+  <define name="EMR_SELECTOBJECT" value="37"/>
+  <define name="EMR_SELECTPALETTE" value="48"/>
+  <define name="EMR_SETARCDIRECTION" value="57"/>
+  <define name="EMR_SETBKCOLOR" value="25"/>
+  <define name="EMR_SETBKMODE" value="18"/>
+  <define name="EMR_SETBRUSHORGEX" value="13"/>
+  <define name="EMR_SETCOLORADJUSTMENT" value="23"/>
+  <define name="EMR_SETCOLORSPACE" value="100"/>
+  <define name="EMR_SETDIBITSTODEVICE" value="80"/>
+  <define name="EMR_SETICMMODE" value="98"/>
+  <define name="EMR_SETICMPROFILEA" value="112"/>
+  <define name="EMR_SETICMPROFILEW" value="113"/>
+  <define name="EMR_SETLAYOUT" value="115"/>
+  <define name="EMR_SETMAPMODE" value="17"/>
+  <define name="EMR_SETMAPPERFLAGS" value="16"/>
+  <define name="EMR_SETMETARGN" value="28"/>
+  <define name="EMR_SETMITERLIMIT" value="58"/>
+  <define name="EMR_SETPALETTEENTRIES" value="50"/>
+  <define name="EMR_SETPIXELV" value="15"/>
+  <define name="EMR_SETPOLYFILLMODE" value="19"/>
+  <define name="EMR_SETROP2" value="20"/>
+  <define name="EMR_SETSTRETCHBLTMODE" value="21"/>
+  <define name="EMR_SETTEXTALIGN" value="22"/>
+  <define name="EMR_SETTEXTCOLOR" value="24"/>
+  <define name="EMR_SETVIEWPORTEXTEX" value="11"/>
+  <define name="EMR_SETVIEWPORTORGEX" value="12"/>
+  <define name="EMR_SETWINDOWEXTEX" value="9"/>
+  <define name="EMR_SETWINDOWORGEX" value="10"/>
+  <define name="EMR_SETWORLDTRANSFORM" value="35"/>
+  <define name="EMR_STRETCHBLT" value="77"/>
+  <define name="EMR_STRETCHDIBITS" value="81"/>
+  <define name="EMR_STROKEANDFILLPATH" value="63"/>
+  <define name="EMR_STROKEPATH" value="64"/>
+  <define name="EMR_TRANSPARENTBLT" value="116"/>
+  <define name="EMR_WIDENPATH" value="66"/>
+  <define name="ENABLEDUPLEX" value="28"/>
+  <define name="ENABLEPAIRKERNING" value="769"/>
+  <define name="ENABLERELATIVEWIDTHS" value="768"/>
+  <define name="ENCAPSULATED_POSTSCRIPT" value="4116"/>
+  <define name="ENDDOC" value="11"/>
+  <define name="END_PATH" value="4098"/>
+  <define name="ENHMETA_SIGNATURE" value="0x20454D46"/>
+  <define name="ENHMETA_STOCK_OBJECT" value="0x80000000"/>
+  <define name="ENUMPAPERBINS" value="31"/>
+  <define name="ENUMPAPERMETRICS" value="34"/>
+  <define name="EPSPRINTING" value="33"/>
+  <define name="EPS_SIGNATURE" value="0x46535045"/>
+  <define name="ERROR" value="0"/>
+  <define name="ETO_CLIPPED" value="0x0004"/>
+  <define name="ETO_GLYPH_INDEX" value="0x0010"/>
+  <define name="ETO_IGNORELANGUAGE" value="0x1000"/>
+  <define name="ETO_NUMERICSLATIN" value="0x0800"/>
+  <define name="ETO_NUMERICSLOCAL" value="0x0400"/>
+  <define name="ETO_OPAQUE" value="0x0002"/>
+  <define name="ETO_PDY" value="0x2000"/>
+  <define name="ETO_REVERSE_INDEX_MAP" value="0x10000"/>
+  <define name="ETO_RTLREADING" value="0x0080"/>
+  <define name="EXTTEXTOUT" value="512"/>
+  <define name="EXT_DEVICE_CAPS" value="4099"/>
+  <define name="EnumFontFamilies" value="EnumFontFamiliesA"/>
+  <define name="EnumFontFamiliesEx" value="EnumFontFamiliesExA"/>
+  <define name="EnumFonts" value="EnumFontsA"/>
+  <define name="EnumICMProfiles" value="EnumICMProfilesA"/>
+  <define name="ExtTextOut" value="ExtTextOutA"/>
+  <define name="FEATURESETTING_CUSTPAPER" value="3"/>
+  <define name="FEATURESETTING_MIRROR" value="4"/>
+  <define name="FEATURESETTING_NEGATIVE" value="5"/>
+  <define name="FEATURESETTING_NUP" value="0"/>
+  <define name="FEATURESETTING_OUTPUT" value="1"/>
+  <define name="FEATURESETTING_PRIVATE_BEGIN" value="0x1000"/>
+  <define name="FEATURESETTING_PRIVATE_END" value="0x1FFF"/>
+  <define name="FEATURESETTING_PROTOCOL" value="6"/>
+  <define name="FEATURESETTING_PSLEVEL" value="2"/>
+  <define name="FF_DECORATIVE" value="(5&lt;&lt;4)"/>
+  <define name="FF_DONTCARE" value="(0&lt;&lt;4)"/>
+  <define name="FF_MODERN" value="(3&lt;&lt;4)"/>
+  <define name="FF_ROMAN" value="(1&lt;&lt;4)"/>
+  <define name="FF_SCRIPT" value="(4&lt;&lt;4)"/>
+  <define name="FF_SWISS" value="(2&lt;&lt;4)"/>
+  <define name="FIXED_PITCH" value="1"/>
+  <define name="FLI_GLYPHS" value="0x00040000L"/>
+  <define name="FLI_MASK" value="0x103B"/>
+  <define name="FLOODFILLBORDER" value="0"/>
+  <define name="FLOODFILLSURFACE" value="1"/>
+  <define name="FLUSHOUTPUT" value="6"/>
+  <define name="FONTMAPPER_MAX" value="10"/>
+  <define name="FR_NOT_ENUM" value="0x20"/>
+  <define name="FR_PRIVATE" value="0x10"/>
+  <define name="FS_ARABIC" value="0x00000040L"/>
+  <define name="FS_BALTIC" value="0x00000080L"/>
+  <define name="FS_CHINESESIMP" value="0x00040000L"/>
+  <define name="FS_CHINESETRAD" value="0x00100000L"/>
+  <define name="FS_CYRILLIC" value="0x00000004L"/>
+  <define name="FS_GREEK" value="0x00000008L"/>
+  <define name="FS_HEBREW" value="0x00000020L"/>
+  <define name="FS_JISJAPAN" value="0x00020000L"/>
+  <define name="FS_JOHAB" value="0x00200000L"/>
+  <define name="FS_LATIN1" value="0x00000001L"/>
+  <define name="FS_LATIN2" value="0x00000002L"/>
+  <define name="FS_SYMBOL" value="0x80000000L"/>
+  <define name="FS_THAI" value="0x00010000L"/>
+  <define name="FS_TURKISH" value="0x00000010L"/>
+  <define name="FS_VIETNAMESE" value="0x00000100L"/>
+  <define name="FS_WANSUNG" value="0x00080000L"/>
+  <define name="FW_BLACK" value="FW_HEAVY"/>
+  <define name="FW_BOLD" value="700"/>
+  <define name="FW_DEMIBOLD" value="FW_SEMIBOLD"/>
+  <define name="FW_DONTCARE" value="0"/>
+  <define name="FW_EXTRABOLD" value="800"/>
+  <define name="FW_EXTRALIGHT" value="200"/>
+  <define name="FW_HEAVY" value="900"/>
+  <define name="FW_LIGHT" value="300"/>
+  <define name="FW_MEDIUM" value="500"/>
+  <define name="FW_NORMAL" value="400"/>
+  <define name="FW_REGULAR" value="FW_NORMAL"/>
+  <define name="FW_SEMIBOLD" value="600"/>
+  <define name="FW_THIN" value="100"/>
+  <define name="FW_ULTRABOLD" value="FW_EXTRABOLD"/>
+  <define name="FW_ULTRALIGHT" value="FW_EXTRALIGHT"/>
+  <define name="GB2312_CHARSET" value="134"/>
+  <define name="GCPCLASS_ARABIC" value="2"/>
+  <define name="GCPCLASS_HEBREW" value="2"/>
+  <define name="GCPCLASS_LATIN" value="1"/>
+  <define name="GCPCLASS_LATINNUMBER" value="5"/>
+  <define name="GCPCLASS_LATINNUMERICSEPARATOR" value="7"/>
+  <define name="GCPCLASS_LATINNUMERICTERMINATOR" value="6"/>
+  <define name="GCPCLASS_LOCALNUMBER" value="4"/>
+  <define name="GCPCLASS_NEUTRAL" value="3"/>
+  <define name="GCPCLASS_NUMERICSEPARATOR" value="8"/>
+  <define name="GCPCLASS_POSTBOUNDLTR" value="0x20"/>
+  <define name="GCPCLASS_POSTBOUNDRTL" value="0x10"/>
+  <define name="GCPCLASS_PREBOUNDLTR" value="0x80"/>
+  <define name="GCPCLASS_PREBOUNDRTL" value="0x40"/>
+  <define name="GCPGLYPH_LINKAFTER" value="0x4000"/>
+  <define name="GCPGLYPH_LINKBEFORE" value="0x8000"/>
+  <define name="GCP_CLASSIN" value="0x00080000L"/>
+  <define name="GCP_DBCS" value="0x0001"/>
+  <define name="GCP_DIACRITIC" value="0x0100"/>
+  <define name="GCP_DISPLAYZWG" value="0x00400000L"/>
+  <define name="GCP_ERROR" value="0x8000"/>
+  <define name="GCP_GLYPHSHAPE" value="0x0010"/>
+  <define name="GCP_JUSTIFY" value="0x00010000L"/>
+  <define name="GCP_JUSTIFYIN" value="0x00200000L"/>
+  <define name="GCP_KASHIDA" value="0x0400"/>
+  <define name="GCP_LIGATE" value="0x0020"/>
+  <define name="GCP_MAXEXTENT" value="0x00100000L"/>
+  <define name="GCP_NEUTRALOVERRIDE" value="0x02000000L"/>
+  <define name="GCP_NUMERICOVERRIDE" value="0x01000000L"/>
+  <define name="GCP_NUMERICSLATIN" value="0x04000000L"/>
+  <define name="GCP_NUMERICSLOCAL" value="0x08000000L"/>
+  <define name="GCP_REORDER" value="0x0002"/>
+  <define name="GCP_SYMSWAPOFF" value="0x00800000L"/>
+  <define name="GCP_USEKERNING" value="0x0008"/>
+  <define name="GDICOMMENT_BEGINGROUP" value="0x00000002"/>
+  <define name="GDICOMMENT_ENDGROUP" value="0x00000003"/>
+  <define name="GDICOMMENT_IDENTIFIER" value="0x43494447"/>
+  <define name="GDICOMMENT_MULTIFORMATS" value="0x40000004"/>
+  <define name="GDICOMMENT_UNICODE_END" value="0x00000080"/>
+  <define name="GDICOMMENT_UNICODE_STRING" value="0x00000040"/>
+  <define name="GDICOMMENT_WINDOWS_METAFILE" value="0x80000001"/>
+  <define name="GDIPLUS_TS_QUERYVER" value="4122"/>
+  <define name="GDIPLUS_TS_RECORD" value="4123"/>
+  <define name="GDIREGISTERDDRAWPACKETVERSION" value="0x1"/>
+  <define name="GDI_DIBSIZE(bi)" value="((bi).biHeight&lt;0?(-1)*(GDI__DIBSIZE(bi)):GDI__DIBSIZE(bi))"/>
+  <define name="GDI_DIBWIDTHBYTES(bi)" value="(DWORD)GDI_WIDTHBYTES((DWORD)(bi).biWidth*(DWORD)(bi).biBitCount)"/>
+  <define name="GDI_ERROR" value="(0xFFFFFFFFL)"/>
+  <define name="GDI_OBJ_LAST" value="OBJ_COLORSPACE"/>
+  <define name="GDI_WIDTHBYTES(bits)" value="((DWORD)(((bits)+31)&amp;(~31))/8)"/>
+  <define name="GDI__DIBSIZE(bi)" value="(GDI_DIBWIDTHBYTES(bi)*(DWORD)(bi).biHeight)"/>
+  <define name="GETCOLORTABLE" value="5"/>
+  <define name="GETDEVICEUNITS" value="42"/>
+  <define name="GETEXTENDEDTEXTMETRICS" value="256"/>
+  <define name="GETEXTENTTABLE" value="257"/>
+  <define name="GETFACENAME" value="513"/>
+  <define name="GETPAIRKERNTABLE" value="258"/>
+  <define name="GETPENWIDTH" value="16"/>
+  <define name="GETPHYSPAGESIZE" value="12"/>
+  <define name="GETPRINTINGOFFSET" value="13"/>
+  <define name="GETSCALINGFACTOR" value="14"/>
+  <define name="GETSETPAPERBINS" value="29"/>
+  <define name="GETSETPAPERMETRICS" value="35"/>
+  <define name="GETSETPRINTORIENT" value="30"/>
+  <define name="GETSETSCREENPARAMS" value="3072"/>
+  <define name="GETTECHNOLGY" value="20"/>
+  <define name="GETTECHNOLOGY" value="20"/>
+  <define name="GETTRACKKERNTABLE" value="259"/>
+  <define name="GETVECTORBRUSHSIZE" value="27"/>
+  <define name="GETVECTORPENSIZE" value="26"/>
+  <define name="GET_PS_FEATURESETTING" value="4121"/>
+  <define name="GGI_MARK_NONEXISTING_GLYPHS" value="0X0001"/>
+  <define name="GGO_BEZIER" value="3"/>
+  <define name="GGO_BITMAP" value="1"/>
+  <define name="GGO_GLYPH_INDEX" value="0x0080"/>
+  <define name="GGO_GRAY2_BITMAP" value="4"/>
+  <define name="GGO_GRAY4_BITMAP" value="5"/>
+  <define name="GGO_GRAY8_BITMAP" value="6"/>
+  <define name="GGO_METRICS" value="0"/>
+  <define name="GGO_NATIVE" value="2"/>
+  <define name="GGO_UNHINTED" value="0x0100"/>
+  <define name="GM_ADVANCED" value="2"/>
+  <define name="GM_COMPATIBLE" value="1"/>
+  <define name="GM_LAST" value="2"/>
+  <define name="GRADIENT_FILL_OP_FLAG" value="0x000000ff"/>
+  <define name="GRADIENT_FILL_RECT_H" value="0x00000000"/>
+  <define name="GRADIENT_FILL_RECT_V" value="0x00000001"/>
+  <define name="GRADIENT_FILL_TRIANGLE" value="0x00000002"/>
+  <define name="GRAY_BRUSH" value="2"/>
+  <define name="GREEK_CHARSET" value="161"/>
+  <define name="GS_8BIT_INDICES" value="0x00000001"/>
+  <define name="GetBValue(rgb)" value="(LOBYTE((rgb)&gt;&gt;16))"/>
+  <define name="GetCValue(cmyk)" value="((BYTE)((cmyk)&gt;&gt;24))"/>
+  <define name="GetCharABCWidths" value="GetCharABCWidthsA"/>
+  <define name="GetCharABCWidthsFloat" value="GetCharABCWidthsFloatA"/>
+  <define name="GetCharWidth" value="GetCharWidthA"/>
+  <define name="GetCharWidth32" value="GetCharWidth32A"/>
+  <define name="GetCharWidthFloat" value="GetCharWidthFloatA"/>
+  <define name="GetCharacterPlacement" value="GetCharacterPlacementA"/>
+  <define name="GetEnhMetaFile" value="GetEnhMetaFileA"/>
+  <define name="GetEnhMetaFileDescription" value="GetEnhMetaFileDescriptionA"/>
+  <define name="GetGValue(rgb)" value="(LOBYTE(((WORD)(rgb))&gt;&gt;8))"/>
+  <define name="GetGlyphIndices" value="GetGlyphIndicesA"/>
+  <define name="GetGlyphOutline" value="GetGlyphOutlineA"/>
+  <define name="GetICMProfile" value="GetICMProfileA"/>
+  <define name="GetKValue(cmyk)" value="((BYTE)(cmyk))"/>
+  <define name="GetKerningPairs" value="GetKerningPairsA"/>
+  <define name="GetLogColorSpace" value="GetLogColorSpaceA"/>
+  <define name="GetMValue(cmyk)" value="((BYTE)((cmyk)&gt;&gt;16))"/>
+  <define name="GetMetaFile" value="GetMetaFileA"/>
+  <define name="GetObject" value="GetObjectA"/>
+  <define name="GetOutlineTextMetrics" value="GetOutlineTextMetricsA"/>
+  <define name="GetRValue(rgb)" value="(LOBYTE(rgb))"/>
+  <define name="GetTextExtentExPoint" value="GetTextExtentExPointA"/>
+  <define name="GetTextExtentPoint" value="GetTextExtentPointA"/>
+  <define name="GetTextExtentPoint32" value="GetTextExtentPoint32A"/>
+  <define name="GetTextFace" value="GetTextFaceA"/>
+  <define name="GetTextMetrics" value="GetTextMetricsA"/>
+  <define name="GetYValue(cmyk)" value="((BYTE)((cmyk)&gt;&gt;8))"/>
+  <define name="HALFTONE" value="4"/>
+  <define name="HANGEUL_CHARSET" value="129"/>
+  <define name="HANGUL_CHARSET" value="129"/>
+  <define name="HEBREW_CHARSET" value="177"/>
+  <define name="HGDI_ERROR" value="((HANDLE)-1)"/>
+  <define name="HOLLOW_BRUSH" value="NULL_BRUSH"/>
+  <define name="HORZRES" value="8"/>
+  <define name="HORZSIZE" value="4"/>
+  <define name="HS_API_MAX" value="12"/>
+  <define name="HS_BDIAGONAL" value="3"/>
+  <define name="HS_CROSS" value="4"/>
+  <define name="HS_DIAGCROSS" value="5"/>
+  <define name="HS_FDIAGONAL" value="2"/>
+  <define name="HS_HORIZONTAL" value="0"/>
+  <define name="HS_VERTICAL" value="1"/>
+  <define name="ICMENUMPROC" value="ICMENUMPROCA"/>
+  <define name="ICM_ADDPROFILE" value="1"/>
+  <define name="ICM_DELETEPROFILE" value="2"/>
+  <define name="ICM_DONE_OUTSIDEDC" value="4"/>
+  <define name="ICM_OFF" value="1"/>
+  <define name="ICM_ON" value="2"/>
+  <define name="ICM_QUERY" value="3"/>
+  <define name="ICM_QUERYMATCH" value="7"/>
+  <define name="ICM_QUERYPROFILE" value="3"/>
+  <define name="ICM_REGISTERICMATCHER" value="5"/>
+  <define name="ICM_SETDEFAULTPROFILE" value="4"/>
+  <define name="ICM_UNREGISTERICMATCHER" value="6"/>
+  <define name="ILLUMINANT_A" value="1"/>
+  <define name="ILLUMINANT_B" value="2"/>
+  <define name="ILLUMINANT_C" value="3"/>
+  <define name="ILLUMINANT_D50" value="4"/>
+  <define name="ILLUMINANT_D55" value="5"/>
+  <define name="ILLUMINANT_D65" value="6"/>
+  <define name="ILLUMINANT_D75" value="7"/>
+  <define name="ILLUMINANT_DAYLIGHT" value="ILLUMINANT_C"/>
+  <define name="ILLUMINANT_DEVICE_DEFAULT" value="0"/>
+  <define name="ILLUMINANT_F2" value="8"/>
+  <define name="ILLUMINANT_FLUORESCENT" value="ILLUMINANT_F2"/>
+  <define name="ILLUMINANT_MAX_INDEX" value="ILLUMINANT_F2"/>
+  <define name="ILLUMINANT_NTSC" value="ILLUMINANT_C"/>
+  <define name="ILLUMINANT_TUNGSTEN" value="ILLUMINANT_A"/>
+  <define name="JOHAB_CHARSET" value="130"/>
+  <define name="LAYOUT_BITMAPORIENTATIONPRESERVED" value="0x00000008"/>
+  <define name="LAYOUT_BTT" value="0x00000002"/>
+  <define name="LAYOUT_ORIENTATIONMASK" value="(LAYOUT_RTL|LAYOUT_BTT|LAYOUT_VBH)"/>
+  <define name="LAYOUT_RTL" value="0x00000001"/>
+  <define name="LAYOUT_VBH" value="0x00000004"/>
+  <define name="LCS_CALIBRATED_RGB" value="0x00000000L"/>
+  <define name="LCS_GM_ABS_COLORIMETRIC" value="0x00000008L"/>
+  <define name="LCS_GM_BUSINESS" value="0x00000001L"/>
+  <define name="LCS_GM_GRAPHICS" value="0x00000002L"/>
+  <define name="LCS_GM_IMAGES" value="0x00000004L"/>
+  <define name="LCS_SIGNATURE" value="'PSOC'"/>
+  <define name="LCS_WINDOWS_COLOR_SPACE" value="'Win'"/>
+  <define name="LCS_sRGB" value="'sRGB'"/>
+  <define name="LC_INTERIORS" value="128"/>
+  <define name="LC_MARKER" value="4"/>
+  <define name="LC_NONE" value="0"/>
+  <define name="LC_POLYLINE" value="2"/>
+  <define name="LC_POLYMARKER" value="8"/>
+  <define name="LC_STYLED" value="32"/>
+  <define name="LC_WIDE" value="16"/>
+  <define name="LC_WIDESTYLED" value="64"/>
+  <define name="LF_FACESIZE" value="32"/>
+  <define name="LF_FULLFACESIZE" value="64"/>
+  <define name="LINECAPS" value="30"/>
+  <define name="LOGPIXELSX" value="88"/>
+  <define name="LOGPIXELSY" value="90"/>
+  <define name="LPD_DOUBLEBUFFER" value="0x00000001"/>
+  <define name="LPD_SHARE_ACCUM" value="0x00000100"/>
+  <define name="LPD_SHARE_DEPTH" value="0x00000040"/>
+  <define name="LPD_SHARE_STENCIL" value="0x00000080"/>
+  <define name="LPD_STEREO" value="0x00000002"/>
+  <define name="LPD_SUPPORT_GDI" value="0x00000010"/>
+  <define name="LPD_SUPPORT_OPENGL" value="0x00000020"/>
+  <define name="LPD_SWAP_COPY" value="0x00000400"/>
+  <define name="LPD_SWAP_EXCHANGE" value="0x00000200"/>
+  <define name="LPD_TRANSPARENT" value="0x00001000"/>
+  <define name="LPD_TYPE_COLORINDEX" value="1"/>
+  <define name="LPD_TYPE_RGBA" value="0"/>
+  <define name="LTGRAY_BRUSH" value="1"/>
+  <define name="MAC_CHARSET" value="77"/>
+  <define name="MAKEPOINTS(l)" value="(*((POINTSFAR*)&amp;(l)))"/>
+  <define name="MAKEROP4(fore,back)" value="(DWORD)((((back)&lt;&lt;8)&amp;0xFF000000)|(fore))"/>
+  <define name="MAXSTRETCHBLTMODE" value="4"/>
+  <define name="MERGECOPY" value="(DWORD)0x00C000CA"/>
+  <define name="MERGEPAINT" value="(DWORD)0x00BB0226"/>
+  <define name="METAFILE_DRIVER" value="2049"/>
+  <define name="META_ANIMATEPALETTE" value="0x0436"/>
+  <define name="META_ARC" value="0x0817"/>
+  <define name="META_BITBLT" value="0x0922"/>
+  <define name="META_CHORD" value="0x0830"/>
+  <define name="META_CREATEBRUSHINDIRECT" value="0x02FC"/>
+  <define name="META_CREATEFONTINDIRECT" value="0x02FB"/>
+  <define name="META_CREATEPALETTE" value="0x00f7"/>
+  <define name="META_CREATEPATTERNBRUSH" value="0x01F9"/>
+  <define name="META_CREATEPENINDIRECT" value="0x02FA"/>
+  <define name="META_CREATEREGION" value="0x06FF"/>
+  <define name="META_DELETEOBJECT" value="0x01f0"/>
+  <define name="META_DIBBITBLT" value="0x0940"/>
+  <define name="META_DIBCREATEPATTERNBRUSH" value="0x0142"/>
+  <define name="META_DIBSTRETCHBLT" value="0x0b41"/>
+  <define name="META_ELLIPSE" value="0x0418"/>
+  <define name="META_ESCAPE" value="0x0626"/>
+  <define name="META_EXCLUDECLIPRECT" value="0x0415"/>
+  <define name="META_EXTFLOODFILL" value="0x0548"/>
+  <define name="META_EXTTEXTOUT" value="0x0a32"/>
+  <define name="META_FILLREGION" value="0x0228"/>
+  <define name="META_FLOODFILL" value="0x0419"/>
+  <define name="META_FRAMEREGION" value="0x0429"/>
+  <define name="META_INTERSECTCLIPRECT" value="0x0416"/>
+  <define name="META_INVERTREGION" value="0x012A"/>
+  <define name="META_LINETO" value="0x0213"/>
+  <define name="META_MOVETO" value="0x0214"/>
+  <define name="META_OFFSETCLIPRGN" value="0x0220"/>
+  <define name="META_OFFSETVIEWPORTORG" value="0x0211"/>
+  <define name="META_OFFSETWINDOWORG" value="0x020F"/>
+  <define name="META_PAINTREGION" value="0x012B"/>
+  <define name="META_PATBLT" value="0x061D"/>
+  <define name="META_PIE" value="0x081A"/>
+  <define name="META_POLYGON" value="0x0324"/>
+  <define name="META_POLYLINE" value="0x0325"/>
+  <define name="META_POLYPOLYGON" value="0x0538"/>
+  <define name="META_REALIZEPALETTE" value="0x0035"/>
+  <define name="META_RECTANGLE" value="0x041B"/>
+  <define name="META_RESIZEPALETTE" value="0x0139"/>
+  <define name="META_RESTOREDC" value="0x0127"/>
+  <define name="META_ROUNDRECT" value="0x061C"/>
+  <define name="META_SAVEDC" value="0x001E"/>
+  <define name="META_SCALEVIEWPORTEXT" value="0x0412"/>
+  <define name="META_SCALEWINDOWEXT" value="0x0410"/>
+  <define name="META_SELECTCLIPREGION" value="0x012C"/>
+  <define name="META_SELECTOBJECT" value="0x012D"/>
+  <define name="META_SELECTPALETTE" value="0x0234"/>
+  <define name="META_SETBKCOLOR" value="0x0201"/>
+  <define name="META_SETBKMODE" value="0x0102"/>
+  <define name="META_SETDIBTODEV" value="0x0d33"/>
+  <define name="META_SETLAYOUT" value="0x0149"/>
+  <define name="META_SETMAPMODE" value="0x0103"/>
+  <define name="META_SETMAPPERFLAGS" value="0x0231"/>
+  <define name="META_SETPALENTRIES" value="0x0037"/>
+  <define name="META_SETPIXEL" value="0x041F"/>
+  <define name="META_SETPOLYFILLMODE" value="0x0106"/>
+  <define name="META_SETRELABS" value="0x0105"/>
+  <define name="META_SETROP2" value="0x0104"/>
+  <define name="META_SETSTRETCHBLTMODE" value="0x0107"/>
+  <define name="META_SETTEXTALIGN" value="0x012E"/>
+  <define name="META_SETTEXTCHAREXTRA" value="0x0108"/>
+  <define name="META_SETTEXTCOLOR" value="0x0209"/>
+  <define name="META_SETTEXTJUSTIFICATION" value="0x020A"/>
+  <define name="META_SETVIEWPORTEXT" value="0x020E"/>
+  <define name="META_SETVIEWPORTORG" value="0x020D"/>
+  <define name="META_SETWINDOWEXT" value="0x020C"/>
+  <define name="META_SETWINDOWORG" value="0x020B"/>
+  <define name="META_STRETCHBLT" value="0x0B23"/>
+  <define name="META_STRETCHDIB" value="0x0f43"/>
+  <define name="META_TEXTOUT" value="0x0521"/>
+  <define name="MFCOMMENT" value="15"/>
+  <define name="MILCORE_TS_QUERYVER_RESULT_FALSE" value="0x0"/>
+  <define name="MILCORE_TS_QUERYVER_RESULT_TRUE" value="0x7FFFFFFF"/>
+  <define name="MM_ANISOTROPIC" value="8"/>
+  <define name="MM_HIENGLISH" value="5"/>
+  <define name="MM_HIMETRIC" value="3"/>
+  <define name="MM_ISOTROPIC" value="7"/>
+  <define name="MM_LOENGLISH" value="4"/>
+  <define name="MM_LOMETRIC" value="2"/>
+  <define name="MM_MAX" value="MM_ANISOTROPIC"/>
+  <define name="MM_MAX_AXES_NAMELEN" value="16"/>
+  <define name="MM_MAX_FIXEDSCALE" value="MM_TWIPS"/>
+  <define name="MM_MAX_NUMAXES" value="16"/>
+  <define name="MM_MIN" value="MM_TEXT"/>
+  <define name="MM_TEXT" value="1"/>
+  <define name="MM_TWIPS" value="6"/>
+  <define name="MONO_FONT" value="8"/>
+  <define name="MOUSETRAILS" value="39"/>
+  <define name="MWT_IDENTITY" value="1"/>
+  <define name="MWT_LEFTMULTIPLY" value="2"/>
+  <define name="MWT_MAX" value="MWT_RIGHTMULTIPLY"/>
+  <define name="MWT_MIN" value="MWT_IDENTITY"/>
+  <define name="MWT_RIGHTMULTIPLY" value="3"/>
+  <define name="NEWFRAME" value="1"/>
+  <define name="NEXTBAND" value="3"/>
+  <define name="NOMIRRORBITMAP" value="(DWORD)0x80000000"/>
+  <define name="NONANTIALIASED_QUALITY" value="3"/>
+  <define name="NOTSRCCOPY" value="(DWORD)0x00330008"/>
+  <define name="NOTSRCERASE" value="(DWORD)0x001100A6"/>
+  <define name="NTM_BOLD" value="0x00000020L"/>
+  <define name="NTM_DSIG" value="0x00200000"/>
+  <define name="NTM_ITALIC" value="0x00000001L"/>
+  <define name="NTM_MULTIPLEMASTER" value="0x00080000"/>
+  <define name="NTM_NONNEGATIVE_AC" value="0x00010000"/>
+  <define name="NTM_PS_OPENTYPE" value="0x00020000"/>
+  <define name="NTM_REGULAR" value="0x00000040L"/>
+  <define name="NTM_TT_OPENTYPE" value="0x00040000"/>
+  <define name="NTM_TYPE1" value="0x00100000"/>
+  <define name="NULLREGION" value="1"/>
+  <define name="NULL_BRUSH" value="5"/>
+  <define name="NULL_PEN" value="8"/>
+  <define name="NUMBRUSHES" value="16"/>
+  <define name="NUMCOLORS" value="24"/>
+  <define name="NUMFONTS" value="22"/>
+  <define name="NUMMARKERS" value="20"/>
+  <define name="NUMPENS" value="18"/>
+  <define name="NUMRESERVED" value="106"/>
+  <define name="OBJ_BITMAP" value="7"/>
+  <define name="OBJ_BRUSH" value="2"/>
+  <define name="OBJ_COLORSPACE" value="14"/>
+  <define name="OBJ_DC" value="3"/>
+  <define name="OBJ_ENHMETADC" value="12"/>
+  <define name="OBJ_ENHMETAFILE" value="13"/>
+  <define name="OBJ_EXTPEN" value="11"/>
+  <define name="OBJ_FONT" value="6"/>
+  <define name="OBJ_MEMDC" value="10"/>
+  <define name="OBJ_METADC" value="4"/>
+  <define name="OBJ_METAFILE" value="9"/>
+  <define name="OBJ_PAL" value="5"/>
+  <define name="OBJ_PEN" value="1"/>
+  <define name="OBJ_REGION" value="8"/>
+  <define name="OEM_CHARSET" value="255"/>
+  <define name="OEM_FIXED_FONT" value="10"/>
+  <define name="OLDFONTENUMPROC" value="OLDFONTENUMPROCA"/>
+  <define name="OPAQUE" value="2"/>
+  <define name="OPENCHANNEL" value="4110"/>
+  <define name="OUT_CHARACTER_PRECIS" value="2"/>
+  <define name="OUT_DEFAULT_PRECIS" value="0"/>
+  <define name="OUT_DEVICE_PRECIS" value="5"/>
+  <define name="OUT_OUTLINE_PRECIS" value="8"/>
+  <define name="OUT_PS_ONLY_PRECIS" value="10"/>
+  <define name="OUT_RASTER_PRECIS" value="6"/>
+  <define name="OUT_SCREEN_OUTLINE_PRECIS" value="9"/>
+  <define name="OUT_STRING_PRECIS" value="1"/>
+  <define name="OUT_STROKE_PRECIS" value="3"/>
+  <define name="OUT_TT_ONLY_PRECIS" value="7"/>
+  <define name="OUT_TT_PRECIS" value="4"/>
+  <define name="PALETTEINDEX(i)" value="((COLORREF)(0x01000000|(DWORD)(WORD)(i)))"/>
+  <define name="PALETTERGB(r,g,b)" value="(0x02000000|RGB(r,g,b))"/>
+  <define name="PANOSE_COUNT" value="10"/>
+  <define name="PAN_ANY" value="0"/>
+  <define name="PAN_ARMSTYLE_INDEX" value="6"/>
+  <define name="PAN_BENT_ARMS_DOUBLE_SERIF" value="11"/>
+  <define name="PAN_BENT_ARMS_HORZ" value="7"/>
+  <define name="PAN_BENT_ARMS_SINGLE_SERIF" value="10"/>
+  <define name="PAN_BENT_ARMS_VERT" value="9"/>
+  <define name="PAN_BENT_ARMS_WEDGE" value="8"/>
+  <define name="PAN_CONTRAST_HIGH" value="8"/>
+  <define name="PAN_CONTRAST_INDEX" value="4"/>
+  <define name="PAN_CONTRAST_LOW" value="4"/>
+  <define name="PAN_CONTRAST_MEDIUM" value="6"/>
+  <define name="PAN_CONTRAST_MEDIUM_HIGH" value="7"/>
+  <define name="PAN_CONTRAST_MEDIUM_LOW" value="5"/>
+  <define name="PAN_CONTRAST_NONE" value="2"/>
+  <define name="PAN_CONTRAST_VERY_HIGH" value="9"/>
+  <define name="PAN_CONTRAST_VERY_LOW" value="3"/>
+  <define name="PAN_CULTURE_LATIN" value="0"/>
+  <define name="PAN_FAMILYTYPE_INDEX" value="0"/>
+  <define name="PAN_FAMILY_DECORATIVE" value="4"/>
+  <define name="PAN_FAMILY_PICTORIAL" value="5"/>
+  <define name="PAN_FAMILY_SCRIPT" value="3"/>
+  <define name="PAN_FAMILY_TEXT_DISPLAY" value="2"/>
+  <define name="PAN_LETTERFORM_INDEX" value="7"/>
+  <define name="PAN_LETT_NORMAL_BOXED" value="4"/>
+  <define name="PAN_LETT_NORMAL_CONTACT" value="2"/>
+  <define name="PAN_LETT_NORMAL_FLATTENED" value="5"/>
+  <define name="PAN_LETT_NORMAL_OFF_CENTER" value="7"/>
+  <define name="PAN_LETT_NORMAL_ROUNDED" value="6"/>
+  <define name="PAN_LETT_NORMAL_SQUARE" value="8"/>
+  <define name="PAN_LETT_NORMAL_WEIGHTED" value="3"/>
+  <define name="PAN_LETT_OBLIQUE_BOXED" value="11"/>
+  <define name="PAN_LETT_OBLIQUE_CONTACT" value="9"/>
+  <define name="PAN_LETT_OBLIQUE_FLATTENED" value="12"/>
+  <define name="PAN_LETT_OBLIQUE_OFF_CENTER" value="14"/>
+  <define name="PAN_LETT_OBLIQUE_ROUNDED" value="13"/>
+  <define name="PAN_LETT_OBLIQUE_SQUARE" value="15"/>
+  <define name="PAN_LETT_OBLIQUE_WEIGHTED" value="10"/>
+  <define name="PAN_MIDLINE_CONSTANT_POINTED" value="9"/>
+  <define name="PAN_MIDLINE_CONSTANT_SERIFED" value="10"/>
+  <define name="PAN_MIDLINE_CONSTANT_TRIMMED" value="8"/>
+  <define name="PAN_MIDLINE_HIGH_POINTED" value="6"/>
+  <define name="PAN_MIDLINE_HIGH_SERIFED" value="7"/>
+  <define name="PAN_MIDLINE_HIGH_TRIMMED" value="5"/>
+  <define name="PAN_MIDLINE_INDEX" value="8"/>
+  <define name="PAN_MIDLINE_LOW_POINTED" value="12"/>
+  <define name="PAN_MIDLINE_LOW_SERIFED" value="13"/>
+  <define name="PAN_MIDLINE_LOW_TRIMMED" value="11"/>
+  <define name="PAN_MIDLINE_STANDARD_POINTED" value="3"/>
+  <define name="PAN_MIDLINE_STANDARD_SERIFED" value="4"/>
+  <define name="PAN_MIDLINE_STANDARD_TRIMMED" value="2"/>
+  <define name="PAN_NO_FIT" value="1"/>
+  <define name="PAN_PROPORTION_INDEX" value="3"/>
+  <define name="PAN_PROP_CONDENSED" value="6"/>
+  <define name="PAN_PROP_EVEN_WIDTH" value="4"/>
+  <define name="PAN_PROP_EXPANDED" value="5"/>
+  <define name="PAN_PROP_MODERN" value="3"/>
+  <define name="PAN_PROP_MONOSPACED" value="9"/>
+  <define name="PAN_PROP_OLD_STYLE" value="2"/>
+  <define name="PAN_PROP_VERY_CONDENSED" value="8"/>
+  <define name="PAN_PROP_VERY_EXPANDED" value="7"/>
+  <define name="PAN_SERIFSTYLE_INDEX" value="1"/>
+  <define name="PAN_SERIF_BONE" value="8"/>
+  <define name="PAN_SERIF_COVE" value="2"/>
+  <define name="PAN_SERIF_EXAGGERATED" value="9"/>
+  <define name="PAN_SERIF_FLARED" value="14"/>
+  <define name="PAN_SERIF_NORMAL_SANS" value="11"/>
+  <define name="PAN_SERIF_OBTUSE_COVE" value="3"/>
+  <define name="PAN_SERIF_OBTUSE_SANS" value="12"/>
+  <define name="PAN_SERIF_OBTUSE_SQUARE_COVE" value="5"/>
+  <define name="PAN_SERIF_PERP_SANS" value="13"/>
+  <define name="PAN_SERIF_ROUNDED" value="15"/>
+  <define name="PAN_SERIF_SQUARE" value="6"/>
+  <define name="PAN_SERIF_SQUARE_COVE" value="4"/>
+  <define name="PAN_SERIF_THIN" value="7"/>
+  <define name="PAN_SERIF_TRIANGLE" value="10"/>
+  <define name="PAN_STRAIGHT_ARMS_DOUBLE_SERIF" value="6"/>
+  <define name="PAN_STRAIGHT_ARMS_HORZ" value="2"/>
+  <define name="PAN_STRAIGHT_ARMS_SINGLE_SERIF" value="5"/>
+  <define name="PAN_STRAIGHT_ARMS_VERT" value="4"/>
+  <define name="PAN_STRAIGHT_ARMS_WEDGE" value="3"/>
+  <define name="PAN_STROKEVARIATION_INDEX" value="5"/>
+  <define name="PAN_STROKE_GRADUAL_DIAG" value="2"/>
+  <define name="PAN_STROKE_GRADUAL_HORZ" value="5"/>
+  <define name="PAN_STROKE_GRADUAL_TRAN" value="3"/>
+  <define name="PAN_STROKE_GRADUAL_VERT" value="4"/>
+  <define name="PAN_STROKE_INSTANT_VERT" value="8"/>
+  <define name="PAN_STROKE_RAPID_HORZ" value="7"/>
+  <define name="PAN_STROKE_RAPID_VERT" value="6"/>
+  <define name="PAN_WEIGHT_BLACK" value="10"/>
+  <define name="PAN_WEIGHT_BOLD" value="8"/>
+  <define name="PAN_WEIGHT_BOOK" value="5"/>
+  <define name="PAN_WEIGHT_DEMI" value="7"/>
+  <define name="PAN_WEIGHT_HEAVY" value="9"/>
+  <define name="PAN_WEIGHT_INDEX" value="2"/>
+  <define name="PAN_WEIGHT_LIGHT" value="3"/>
+  <define name="PAN_WEIGHT_MEDIUM" value="6"/>
+  <define name="PAN_WEIGHT_NORD" value="11"/>
+  <define name="PAN_WEIGHT_THIN" value="4"/>
+  <define name="PAN_WEIGHT_VERY_LIGHT" value="2"/>
+  <define name="PAN_XHEIGHT_CONSTANT_LARGE" value="4"/>
+  <define name="PAN_XHEIGHT_CONSTANT_SMALL" value="2"/>
+  <define name="PAN_XHEIGHT_CONSTANT_STD" value="3"/>
+  <define name="PAN_XHEIGHT_DUCKING_LARGE" value="7"/>
+  <define name="PAN_XHEIGHT_DUCKING_SMALL" value="5"/>
+  <define name="PAN_XHEIGHT_DUCKING_STD" value="6"/>
+  <define name="PAN_XHEIGHT_INDEX" value="9"/>
+  <define name="PASSTHROUGH" value="19"/>
+  <define name="PATCOPY" value="(DWORD)0x00F00021"/>
+  <define name="PATINVERT" value="(DWORD)0x005A0049"/>
+  <define name="PATPAINT" value="(DWORD)0x00FB0A09"/>
+  <define name="PC_EXPLICIT" value="0x02"/>
+  <define name="PC_INTERIORS" value="128"/>
+  <define name="PC_NOCOLLAPSE" value="0x04"/>
+  <define name="PC_NONE" value="0"/>
+  <define name="PC_PATHS" value="512"/>
+  <define name="PC_POLYGON" value="1"/>
+  <define name="PC_POLYPOLYGON" value="256"/>
+  <define name="PC_RECTANGLE" value="2"/>
+  <define name="PC_RESERVED" value="0x01"/>
+  <define name="PC_SCANLINE" value="8"/>
+  <define name="PC_STYLED" value="32"/>
+  <define name="PC_TRAPEZOID" value="4"/>
+  <define name="PC_WIDE" value="16"/>
+  <define name="PC_WIDESTYLED" value="64"/>
+  <define name="PC_WINDPOLYGON" value="4"/>
+  <define name="PDEVICESIZE" value="26"/>
+  <define name="PFD_DEPTH_DONTCARE" value="0x20000000"/>
+  <define name="PFD_DIRECT3D_ACCELERATED" value="0x00004000"/>
+  <define name="PFD_DOUBLEBUFFER" value="0x00000001"/>
+  <define name="PFD_DOUBLEBUFFER_DONTCARE" value="0x40000000"/>
+  <define name="PFD_DRAW_TO_BITMAP" value="0x00000008"/>
+  <define name="PFD_DRAW_TO_WINDOW" value="0x00000004"/>
+  <define name="PFD_GENERIC_ACCELERATED" value="0x00001000"/>
+  <define name="PFD_GENERIC_FORMAT" value="0x00000040"/>
+  <define name="PFD_MAIN_PLANE" value="0"/>
+  <define name="PFD_NEED_PALETTE" value="0x00000080"/>
+  <define name="PFD_NEED_SYSTEM_PALETTE" value="0x00000100"/>
+  <define name="PFD_OVERLAY_PLANE" value="1"/>
+  <define name="PFD_STEREO" value="0x00000002"/>
+  <define name="PFD_STEREO_DONTCARE" value="0x80000000"/>
+  <define name="PFD_SUPPORT_COMPOSITION" value="0x00008000"/>
+  <define name="PFD_SUPPORT_DIRECTDRAW" value="0x00002000"/>
+  <define name="PFD_SUPPORT_GDI" value="0x00000010"/>
+  <define name="PFD_SUPPORT_OPENGL" value="0x00000020"/>
+  <define name="PFD_SWAP_COPY" value="0x00000400"/>
+  <define name="PFD_SWAP_EXCHANGE" value="0x00000200"/>
+  <define name="PFD_SWAP_LAYER_BUFFERS" value="0x00000800"/>
+  <define name="PFD_TYPE_COLORINDEX" value="1"/>
+  <define name="PFD_TYPE_RGBA" value="0"/>
+  <define name="PFD_UNDERLAY_PLANE" value="(-1)"/>
+  <define name="PHYSICALHEIGHT" value="111"/>
+  <define name="PHYSICALOFFSETX" value="112"/>
+  <define name="PHYSICALOFFSETY" value="113"/>
+  <define name="PHYSICALWIDTH" value="110"/>
+  <define name="PLANES" value="14"/>
+  <define name="POLYFILL_LAST" value="2"/>
+  <define name="POLYGONALCAPS" value="32"/>
+  <define name="POSTSCRIPT_DATA" value="37"/>
+  <define name="POSTSCRIPT_IDENTIFY" value="4117"/>
+  <define name="POSTSCRIPT_IGNORE" value="38"/>
+  <define name="POSTSCRIPT_INJECTION" value="4118"/>
+  <define name="POSTSCRIPT_PASSTHROUGH" value="4115"/>
+  <define name="PRINTRATEUNIT_CPS" value="2"/>
+  <define name="PRINTRATEUNIT_IPM" value="4"/>
+  <define name="PRINTRATEUNIT_LPM" value="3"/>
+  <define name="PRINTRATEUNIT_PPM" value="1"/>
+  <define name="PROFILE_EMBEDDED" value="'MBED'"/>
+  <define name="PROFILE_LINKED" value="'LINK'"/>
+  <define name="PROOF_QUALITY" value="2"/>
+  <define name="PR_JOBSTATUS" value="0x0000"/>
+  <define name="PSIDENT_GDICENTRIC" value="0"/>
+  <define name="PSIDENT_PSCENTRIC" value="1"/>
+  <define name="PSINJECT_BEGINDEFAULTS" value="12"/>
+  <define name="PSINJECT_BEGINPAGESETUP" value="101"/>
+  <define name="PSINJECT_BEGINPROLOG" value="14"/>
+  <define name="PSINJECT_BEGINSETUP" value="16"/>
+  <define name="PSINJECT_BEGINSTREAM" value="1"/>
+  <define name="PSINJECT_BOUNDINGBOX" value="9"/>
+  <define name="PSINJECT_COMMENTS" value="11"/>
+  <define name="PSINJECT_DLFONT" value="0xdddddddd"/>
+  <define name="PSINJECT_DOCNEEDEDRES" value="5"/>
+  <define name="PSINJECT_DOCSUPPLIEDRES" value="6"/>
+  <define name="PSINJECT_DOCUMENTPROCESSCOLORS" value="10"/>
+  <define name="PSINJECT_DOCUMENTPROCESSCOLORSATEND" value="21"/>
+  <define name="PSINJECT_ENDDEFAULTS" value="13"/>
+  <define name="PSINJECT_ENDPAGECOMMENTS" value="107"/>
+  <define name="PSINJECT_ENDPAGESETUP" value="102"/>
+  <define name="PSINJECT_ENDPROLOG" value="15"/>
+  <define name="PSINJECT_ENDSETUP" value="17"/>
+  <define name="PSINJECT_ENDSTREAM" value="20"/>
+  <define name="PSINJECT_EOF" value="19"/>
+  <define name="PSINJECT_ORIENTATION" value="8"/>
+  <define name="PSINJECT_PAGEBBOX" value="106"/>
+  <define name="PSINJECT_PAGENUMBER" value="100"/>
+  <define name="PSINJECT_PAGEORDER" value="7"/>
+  <define name="PSINJECT_PAGES" value="4"/>
+  <define name="PSINJECT_PAGESATEND" value="3"/>
+  <define name="PSINJECT_PAGETRAILER" value="103"/>
+  <define name="PSINJECT_PLATECOLOR" value="104"/>
+  <define name="PSINJECT_PSADOBE" value="2"/>
+  <define name="PSINJECT_SHOWPAGE" value="105"/>
+  <define name="PSINJECT_TRAILER" value="18"/>
+  <define name="PSINJECT_VMRESTORE" value="201"/>
+  <define name="PSINJECT_VMSAVE" value="200"/>
+  <define name="PSPROTOCOL_ASCII" value="0"/>
+  <define name="PSPROTOCOL_BCP" value="1"/>
+  <define name="PSPROTOCOL_BINARY" value="3"/>
+  <define name="PSPROTOCOL_TBCP" value="2"/>
+  <define name="PS_ALTERNATE" value="8"/>
+  <define name="PS_COSMETIC" value="0x00000000"/>
+  <define name="PS_DASH" value="1"/>
+  <define name="PS_DASHDOT" value="3"/>
+  <define name="PS_DASHDOTDOT" value="4"/>
+  <define name="PS_DOT" value="2"/>
+  <define name="PS_ENDCAP_FLAT" value="0x00000200"/>
+  <define name="PS_ENDCAP_MASK" value="0x00000F00"/>
+  <define name="PS_ENDCAP_ROUND" value="0x00000000"/>
+  <define name="PS_ENDCAP_SQUARE" value="0x00000100"/>
+  <define name="PS_GEOMETRIC" value="0x00010000"/>
+  <define name="PS_INSIDEFRAME" value="6"/>
+  <define name="PS_JOIN_BEVEL" value="0x00001000"/>
+  <define name="PS_JOIN_MASK" value="0x0000F000"/>
+  <define name="PS_JOIN_MITER" value="0x00002000"/>
+  <define name="PS_JOIN_ROUND" value="0x00000000"/>
+  <define name="PS_NULL" value="5"/>
+  <define name="PS_SOLID" value="0"/>
+  <define name="PS_STYLE_MASK" value="0x0000000F"/>
+  <define name="PS_TYPE_MASK" value="0x000F0000"/>
+  <define name="PS_USERSTYLE" value="7"/>
+  <define name="PT_BEZIERTO" value="0x04"/>
+  <define name="PT_CLOSEFIGURE" value="0x01"/>
+  <define name="PT_LINETO" value="0x02"/>
+  <define name="PT_MOVETO" value="0x06"/>
+  <define name="PolyTextOut" value="PolyTextOutA"/>
+  <define name="QDC_ALL_PATHS" value="0x00000001"/>
+  <define name="QDC_DATABASE_CURRENT" value="0x00000004"/>
+  <define name="QDC_INCLUDE_HMD" value="0x00000020"/>
+  <define name="QDC_ONLY_ACTIVE_PATHS" value="0x00000002"/>
+  <define name="QDC_VIRTUAL_MODE_AWARE" value="0x00000010"/>
+  <define name="QDI_DIBTOSCREEN" value="4"/>
+  <define name="QDI_GETDIBITS" value="2"/>
+  <define name="QDI_SETDIBITS" value="1"/>
+  <define name="QDI_STRETCHDIB" value="8"/>
+  <define name="QUERYDIBSUPPORT" value="3073"/>
+  <define name="QUERYESCSUPPORT" value="8"/>
+  <define name="R2_BLACK" value="1"/>
+  <define name="R2_COPYPEN" value="13"/>
+  <define name="R2_LAST" value="16"/>
+  <define name="R2_MASKNOTPEN" value="3"/>
+  <define name="R2_MASKPEN" value="9"/>
+  <define name="R2_MASKPENNOT" value="5"/>
+  <define name="R2_MERGENOTPEN" value="12"/>
+  <define name="R2_MERGEPEN" value="15"/>
+  <define name="R2_MERGEPENNOT" value="14"/>
+  <define name="R2_NOP" value="11"/>
+  <define name="R2_NOT" value="6"/>
+  <define name="R2_NOTCOPYPEN" value="4"/>
+  <define name="R2_NOTMASKPEN" value="8"/>
+  <define name="R2_NOTMERGEPEN" value="2"/>
+  <define name="R2_NOTXORPEN" value="10"/>
+  <define name="R2_WHITE" value="16"/>
+  <define name="R2_XORPEN" value="7"/>
+  <define name="RASTERCAPS" value="38"/>
+  <define name="RASTER_FONTTYPE" value="0x0001"/>
+  <define name="RC_BANDING" value="2"/>
+  <define name="RC_BIGFONT" value="0x0400"/>
+  <define name="RC_BITBLT" value="1"/>
+  <define name="RC_BITMAP64" value="8"/>
+  <define name="RC_DEVBITS" value="0x8000"/>
+  <define name="RC_DIBTODEV" value="0x0200"/>
+  <define name="RC_DI_BITMAP" value="0x0080"/>
+  <define name="RC_FLOODFILL" value="0x1000"/>
+  <define name="RC_GDI20_OUTPUT" value="0x0010"/>
+  <define name="RC_GDI20_STATE" value="0x0020"/>
+  <define name="RC_NONE" value=""/>
+  <define name="RC_OP_DX_OUTPUT" value="0x4000"/>
+  <define name="RC_PALETTE" value="0x0100"/>
+  <define name="RC_SAVEBITMAP" value="0x0040"/>
+  <define name="RC_SCALING" value="4"/>
+  <define name="RC_STRETCHBLT" value="0x0800"/>
+  <define name="RC_STRETCHDIB" value="0x2000"/>
+  <define name="RDH_RECTANGLES" value="1"/>
+  <define name="REFERENCE_BLACK_MAX" value="(WORD)4000"/>
+  <define name="REFERENCE_BLACK_MIN" value="(WORD)0"/>
+  <define name="REFERENCE_WHITE_MAX" value="(WORD)10000"/>
+  <define name="REFERENCE_WHITE_MIN" value="(WORD)6000"/>
+  <define name="RELATIVE" value="2"/>
+  <define name="RESTORE_CTM" value="4100"/>
+  <define name="RGB(r,g,b)" value="((COLORREF)(((BYTE)(r)|((WORD)((BYTE)(g))&lt;&lt;8))|(((DWORD)(BYTE)(b))&lt;&lt;16)))"/>
+  <define name="RGB_GAMMA_MAX" value="(WORD)65000"/>
+  <define name="RGB_GAMMA_MIN" value="(WORD)02500"/>
+  <define name="RGN_AND" value="1"/>
+  <define name="RGN_COPY" value="5"/>
+  <define name="RGN_DIFF" value="4"/>
+  <define name="RGN_ERROR" value="ERROR"/>
+  <define name="RGN_MAX" value="RGN_COPY"/>
+  <define name="RGN_MIN" value="RGN_AND"/>
+  <define name="RGN_OR" value="2"/>
+  <define name="RGN_XOR" value="3"/>
+  <define name="RUSSIAN_CHARSET" value="204"/>
+  <define name="RemoveFontResource" value="RemoveFontResourceA"/>
+  <define name="RemoveFontResourceEx" value="RemoveFontResourceExA"/>
+  <define name="ResetDC" value="ResetDCA"/>
+  <define name="SAVE_CTM" value="4101"/>
+  <define name="SB_CONST_ALPHA" value="0x00000001"/>
+  <define name="SB_GRAD_RECT" value="0x00000010"/>
+  <define name="SB_GRAD_TRI" value="0x00000020"/>
+  <define name="SB_NONE" value="0x00000000"/>
+  <define name="SB_PIXEL_ALPHA" value="0x00000002"/>
+  <define name="SB_PREMULT_ALPHA" value="0x00000004"/>
+  <define name="SCALINGFACTORX" value="114"/>
+  <define name="SCALINGFACTORY" value="115"/>
+  <define name="SDC_ALLOW_CHANGES" value="0x00000400"/>
+  <define name="SDC_ALLOW_PATH_ORDER_CHANGES" value="0x00002000"/>
+  <define name="SDC_APPLY" value="0x00000080"/>
+  <define name="SDC_FORCE_MODE_ENUMERATION" value="0x00001000"/>
+  <define name="SDC_NO_OPTIMIZATION" value="0x00000100"/>
+  <define name="SDC_PATH_PERSIST_IF_REQUIRED" value="0x00000800"/>
+  <define name="SDC_SAVE_TO_DATABASE" value="0x00000200"/>
+  <define name="SDC_TOPOLOGY_CLONE" value="0x00000002"/>
+  <define name="SDC_TOPOLOGY_EXTEND" value="0x00000004"/>
+  <define name="SDC_TOPOLOGY_EXTERNAL" value="0x00000008"/>
+  <define name="SDC_TOPOLOGY_INTERNAL" value="0x00000001"/>
+  <define name="SDC_TOPOLOGY_SUPPLIED" value="0x00000010"/>
+  <define name="SDC_USE_DATABASE_CURRENT" value="(SDC_TOPOLOGY_INTERNAL|SDC_TOPOLOGY_CLONE|SDC_TOPOLOGY_EXTEND|SDC_TOPOLOGY_EXTERNAL)"/>
+  <define name="SDC_USE_SUPPLIED_DISPLAY_CONFIG" value="0x00000020"/>
+  <define name="SDC_VALIDATE" value="0x00000040"/>
+  <define name="SDC_VIRTUAL_MODE_AWARE" value="0x00008000"/>
+  <define name="SELECTPAPERSOURCE" value="18"/>
+  <define name="SETABORTPROC" value="9"/>
+  <define name="SETALLJUSTVALUES" value="771"/>
+  <define name="SETCHARSET" value="772"/>
+  <define name="SETCOLORTABLE" value="4"/>
+  <define name="SETCOPYCOUNT" value="17"/>
+  <define name="SETDIBSCALING" value="32"/>
+  <define name="SETICMPROFILE_EMBEDED" value="0x00000001"/>
+  <define name="SETKERNTRACK" value="770"/>
+  <define name="SETLINECAP" value="21"/>
+  <define name="SETLINEJOIN" value="22"/>
+  <define name="SETMITERLIMIT" value="23"/>
+  <define name="SET_ARC_DIRECTION" value="4102"/>
+  <define name="SET_BACKGROUND_COLOR" value="4103"/>
+  <define name="SET_BOUNDS" value="4109"/>
+  <define name="SET_CLIP_BOX" value="4108"/>
+  <define name="SET_MIRROR_MODE" value="4110"/>
+  <define name="SET_POLY_MODE" value="4104"/>
+  <define name="SET_SCREEN_ANGLE" value="4105"/>
+  <define name="SET_SPREAD" value="4106"/>
+  <define name="SHADEBLENDCAPS" value="120"/>
+  <define name="SHIFTJIS_CHARSET" value="128"/>
+  <define name="SIMPLEREGION" value="2"/>
+  <define name="SIZEPALETTE" value="104"/>
+  <define name="SPCLPASSTHROUGH2" value="4568"/>
+  <define name="SP_APPABORT" value="(-2)"/>
+  <define name="SP_ERROR" value="(-1)"/>
+  <define name="SP_NOTREPORTED" value="0x4000"/>
+  <define name="SP_OUTOFDISK" value="(-4)"/>
+  <define name="SP_OUTOFMEMORY" value="(-5)"/>
+  <define name="SP_USERABORT" value="(-3)"/>
+  <define name="SRCAND" value="(DWORD)0x008800C6"/>
+  <define name="SRCCOPY" value="(DWORD)0x00CC0020"/>
+  <define name="SRCERASE" value="(DWORD)0x00440328"/>
+  <define name="SRCINVERT" value="(DWORD)0x00660046"/>
+  <define name="SRCPAINT" value="(DWORD)0x00EE0086"/>
+  <define name="STAMP_AXESLIST" value="(0x8000000+'a'+('l'&lt;&lt;8))"/>
+  <define name="STAMP_CFF2" value="(0x8000000+'c'+('v'&lt;&lt;8))"/>
+  <define name="STAMP_DESIGNVECTOR" value="(0x8000000+'d'+('v'&lt;&lt;8))"/>
+  <define name="STAMP_TRUETYPE_VARIATION" value="(0x8000000+'t'+('v'&lt;&lt;8))"/>
+  <define name="STARTDOC" value="10"/>
+  <define name="STOCK_LAST" value="16"/>
+  <define name="STRETCHBLT" value="2048"/>
+  <define name="STRETCH_ANDSCANS" value="BLACKONWHITE"/>
+  <define name="STRETCH_DELETESCANS" value="COLORONCOLOR"/>
+  <define name="STRETCH_HALFTONE" value="HALFTONE"/>
+  <define name="STRETCH_ORSCANS" value="WHITEONBLACK"/>
+  <define name="SYMBOL_CHARSET" value="2"/>
+  <define name="SYSPAL_ERROR" value="0"/>
+  <define name="SYSPAL_NOSTATIC" value="2"/>
+  <define name="SYSPAL_NOSTATIC256" value="3"/>
+  <define name="SYSPAL_STATIC" value="1"/>
+  <define name="SYSRGN" value="4"/>
+  <define name="SYSTEM_FIXED_FONT" value="16"/>
+  <define name="SYSTEM_FONT" value="13"/>
+  <define name="SetICMProfile" value="SetICMProfileA"/>
+  <define name="StartDoc" value="StartDocA"/>
+  <define name="TA_BASELINE" value="24"/>
+  <define name="TA_BOTTOM" value="8"/>
+  <define name="TA_CENTER" value="6"/>
+  <define name="TA_LEFT" value="0"/>
+  <define name="TA_MASK" value="(TA_BASELINE+TA_CENTER+TA_UPDATECP)"/>
+  <define name="TA_NOUPDATECP" value="0"/>
+  <define name="TA_RIGHT" value="2"/>
+  <define name="TA_RTLREADING" value="256"/>
+  <define name="TA_TOP" value="0"/>
+  <define name="TA_UPDATECP" value="1"/>
+  <define name="TCI_SRCCHARSET" value="1"/>
+  <define name="TCI_SRCCODEPAGE" value="2"/>
+  <define name="TCI_SRCFONTSIG" value="3"/>
+  <define name="TCI_SRCLOCALE" value="0x1000"/>
+  <define name="TC_CP_STROKE" value="0x00000004"/>
+  <define name="TC_CR_90" value="0x00000008"/>
+  <define name="TC_CR_ANY" value="0x00000010"/>
+  <define name="TC_EA_DOUBLE" value="0x00000200"/>
+  <define name="TC_IA_ABLE" value="0x00000400"/>
+  <define name="TC_OP_CHARACTER" value="0x00000001"/>
+  <define name="TC_OP_STROKE" value="0x00000002"/>
+  <define name="TC_RA_ABLE" value="0x00002000"/>
+  <define name="TC_RESERVED" value="0x00008000"/>
+  <define name="TC_SA_CONTIN" value="0x00000100"/>
+  <define name="TC_SA_DOUBLE" value="0x00000040"/>
+  <define name="TC_SA_INTEGER" value="0x00000080"/>
+  <define name="TC_SCROLLBLT" value="0x00010000"/>
+  <define name="TC_SF_X_YINDEP" value="0x00000020"/>
+  <define name="TC_SO_ABLE" value="0x00001000"/>
+  <define name="TC_UA_ABLE" value="0x00000800"/>
+  <define name="TC_VA_ABLE" value="0x00004000"/>
+  <define name="TECHNOLOGY" value="2"/>
+  <define name="TEXTCAPS" value="34"/>
+  <define name="THAI_CHARSET" value="222"/>
+  <define name="TMPF_DEVICE" value="0x08"/>
+  <define name="TMPF_FIXED_PITCH" value="0x01"/>
+  <define name="TMPF_TRUETYPE" value="0x04"/>
+  <define name="TMPF_VECTOR" value="0x02"/>
+  <define name="TRANSFORM_CTM" value="4107"/>
+  <define name="TRANSPARENT" value="1"/>
+  <define name="TRUETYPE_FONTTYPE" value="0x0004"/>
+  <define name="TT_AVAILABLE" value="0x0001"/>
+  <define name="TT_ENABLED" value="0x0002"/>
+  <define name="TT_POLYGON_TYPE" value="24"/>
+  <define name="TT_PRIM_CSPLINE" value="3"/>
+  <define name="TT_PRIM_LINE" value="1"/>
+  <define name="TT_PRIM_QSPLINE" value="2"/>
+  <define name="TURKISH_CHARSET" value="162"/>
+  <define name="TextOut" value="TextOutA"/>
+  <define name="UpdateICMRegKey" value="UpdateICMRegKeyA"/>
+  <define name="VARIABLE_PITCH" value="2"/>
+  <define name="VERTRES" value="10"/>
+  <define name="VERTSIZE" value="6"/>
+  <define name="VIETNAMESE_CHARSET" value="163"/>
+  <define name="VREFRESH" value="116"/>
+  <define name="VTA_BASELINE" value="TA_BASELINE"/>
+  <define name="VTA_BOTTOM" value="TA_RIGHT"/>
+  <define name="VTA_CENTER" value="TA_CENTER"/>
+  <define name="VTA_LEFT" value="TA_BOTTOM"/>
+  <define name="VTA_RIGHT" value="TA_TOP"/>
+  <define name="VTA_TOP" value="TA_LEFT"/>
+  <define name="WGL_FONT_LINES" value="0"/>
+  <define name="WGL_FONT_POLYGONS" value="1"/>
+  <define name="WGL_SWAPMULTIPLE_MAX" value="16"/>
+  <define name="WGL_SWAP_MAIN_PLANE" value="0x00000001"/>
+  <define name="WGL_SWAP_OVERLAY1" value="0x00000002"/>
+  <define name="WGL_SWAP_OVERLAY10" value="0x00000400"/>
+  <define name="WGL_SWAP_OVERLAY11" value="0x00000800"/>
+  <define name="WGL_SWAP_OVERLAY12" value="0x00001000"/>
+  <define name="WGL_SWAP_OVERLAY13" value="0x00002000"/>
+  <define name="WGL_SWAP_OVERLAY14" value="0x00004000"/>
+  <define name="WGL_SWAP_OVERLAY15" value="0x00008000"/>
+  <define name="WGL_SWAP_OVERLAY2" value="0x00000004"/>
+  <define name="WGL_SWAP_OVERLAY3" value="0x00000008"/>
+  <define name="WGL_SWAP_OVERLAY4" value="0x00000010"/>
+  <define name="WGL_SWAP_OVERLAY5" value="0x00000020"/>
+  <define name="WGL_SWAP_OVERLAY6" value="0x00000040"/>
+  <define name="WGL_SWAP_OVERLAY7" value="0x00000080"/>
+  <define name="WGL_SWAP_OVERLAY8" value="0x00000100"/>
+  <define name="WGL_SWAP_OVERLAY9" value="0x00000200"/>
+  <define name="WGL_SWAP_UNDERLAY1" value="0x00010000"/>
+  <define name="WGL_SWAP_UNDERLAY10" value="0x02000000"/>
+  <define name="WGL_SWAP_UNDERLAY11" value="0x04000000"/>
+  <define name="WGL_SWAP_UNDERLAY12" value="0x08000000"/>
+  <define name="WGL_SWAP_UNDERLAY13" value="0x10000000"/>
+  <define name="WGL_SWAP_UNDERLAY14" value="0x20000000"/>
+  <define name="WGL_SWAP_UNDERLAY15" value="0x40000000"/>
+  <define name="WGL_SWAP_UNDERLAY2" value="0x00020000"/>
+  <define name="WGL_SWAP_UNDERLAY3" value="0x00040000"/>
+  <define name="WGL_SWAP_UNDERLAY4" value="0x00080000"/>
+  <define name="WGL_SWAP_UNDERLAY5" value="0x00100000"/>
+  <define name="WGL_SWAP_UNDERLAY6" value="0x00200000"/>
+  <define name="WGL_SWAP_UNDERLAY7" value="0x00400000"/>
+  <define name="WGL_SWAP_UNDERLAY8" value="0x00800000"/>
+  <define name="WGL_SWAP_UNDERLAY9" value="0x01000000"/>
+  <define name="WHITENESS" value="(DWORD)0x00FF0062"/>
+  <define name="WHITEONBLACK" value="2"/>
+  <define name="WHITE_BRUSH" value="0"/>
+  <define name="WHITE_PEN" value="6"/>
+  <define name="WINDING" value="2"/>
+  <define name="WINGDIAPI" value=""/>
+  <define name="WINSPOOLAPI" value=""/>
+  <define name="WINVER" value="0x0500"/>
+  <define name="_LOGPALETTE_DEFINED" value=""/>
+  <define name="_PALETTEENTRY_DEFINED" value=""/>
+  <define name="_TEXTMETRIC_DEFINED" value=""/>
+  <define name="_WINGDI_" value=""/>
+  <define name="_XFORM_" value=""/>
+  <define name="wglUseFontBitmaps" value="wglUseFontBitmapsA"/>
+  <define name="wglUseFontOutlines" value="wglUseFontOutlinesA"/>
+  <!-- ShlObj_core.h -->
+  <define name="ADDURL_SILENT" value="0X0001"/>
+  <define name="AD_APPLY_ALL" value="(AD_APPLY_SAVE|AD_APPLY_HTMLGEN|AD_APPLY_REFRESH)"/>
+  <define name="AD_APPLY_BUFFERED_REFRESH" value="0x00000010"/>
+  <define name="AD_APPLY_DYNAMICREFRESH" value="0x00000020"/>
+  <define name="AD_APPLY_FORCE" value="0x00000008"/>
+  <define name="AD_APPLY_HTMLGEN" value="0x00000002"/>
+  <define name="AD_APPLY_REFRESH" value="0x00000004"/>
+  <define name="AD_APPLY_SAVE" value="0x00000001"/>
+  <define name="AD_GETWP_BMP" value="0x00000000"/>
+  <define name="AD_GETWP_IMAGE" value="0x00000001"/>
+  <define name="AD_GETWP_LAST_APPLIED" value="0x00000002"/>
+  <define name="BFFM_ENABLEOK" value="(WM_USER+101)"/>
+  <define name="BFFM_INITIALIZED" value="1"/>
+  <define name="BFFM_IUNKNOWN" value="5"/>
+  <define name="BFFM_SELCHANGED" value="2"/>
+  <define name="BFFM_SETEXPANDED" value="(WM_USER+106)"/>
+  <define name="BFFM_SETOKTEXT" value="(WM_USER+105)"/>
+  <define name="BFFM_SETSELECTION" value="BFFM_SETSELECTIONA"/>
+  <define name="BFFM_SETSELECTIONA" value="(WM_USER+102)"/>
+  <define name="BFFM_SETSELECTIONW" value="(WM_USER+103)"/>
+  <define name="BFFM_SETSTATUSTEXT" value="BFFM_SETSTATUSTEXTA"/>
+  <define name="BFFM_SETSTATUSTEXTA" value="(WM_USER+100)"/>
+  <define name="BFFM_SETSTATUSTEXTW" value="(WM_USER+104)"/>
+  <define name="BFFM_VALIDATEFAILED" value="BFFM_VALIDATEFAILEDA"/>
+  <define name="BFFM_VALIDATEFAILEDA" value="3"/>
+  <define name="BFFM_VALIDATEFAILEDW" value="4"/>
+  <define name="BIF_BROWSEFILEJUNCTIONS" value="0x00010000"/>
+  <define name="BIF_BROWSEFORCOMPUTER" value="0x00001000"/>
+  <define name="BIF_BROWSEFORPRINTER" value="0x00002000"/>
+  <define name="BIF_BROWSEINCLUDEFILES" value="0x00004000"/>
+  <define name="BIF_BROWSEINCLUDEURLS" value="0x00000080"/>
+  <define name="BIF_DONTGOBELOWDOMAIN" value="0x00000002"/>
+  <define name="BIF_EDITBOX" value="0x00000010"/>
+  <define name="BIF_NEWDIALOGSTYLE" value="0x00000040"/>
+  <define name="BIF_NONEWFOLDERBUTTON" value="0x00000200"/>
+  <define name="BIF_NOTRANSLATETARGETS" value="0x00000400"/>
+  <define name="BIF_RETURNFSANCESTORS" value="0x00000008"/>
+  <define name="BIF_RETURNONLYFSDIRS" value="0x00000001"/>
+  <define name="BIF_SHAREABLE" value="0x00008000"/>
+  <define name="BIF_STATUSTEXT" value="0x00000004"/>
+  <define name="BIF_UAHINT" value="0x00000100"/>
+  <define name="BIF_USENEWUI" value="(BIF_NEWDIALOGSTYLE|BIF_EDITBOX)"/>
+  <define name="BIF_VALIDATE" value="0x00000020"/>
+  <define name="BROWSEINFO" value="BROWSEINFOA"/>
+  <define name="BROWSEUIAPI" value="EXTERN_CDECLSPEC_IMPORTHRESULTSTDAPICALLTYPE"/>
+  <define name="BROWSEUIAPI_(type)" value="EXTERN_CDECLSPEC_IMPORTtypeSTDAPICALLTYPE"/>
+  <define name="CABINETSTATE_VERSION" value="2"/>
+  <define name="CFSTR_AUTOPLAY_SHELLIDLISTS" value="TEXT(&quot;AutoplayEnumeratedIDListArray&quot;)"/>
+  <define name="CFSTR_DROPDESCRIPTION" value="TEXT(&quot;DropDescription&quot;)"/>
+  <define name="CFSTR_FILECONTENTS" value="TEXT(&quot;FileContents&quot;)"/>
+  <define name="CFSTR_FILEDESCRIPTOR" value="CFSTR_FILEDESCRIPTORA"/>
+  <define name="CFSTR_FILEDESCRIPTORA" value="TEXT(&quot;FileGroupDescriptor&quot;)"/>
+  <define name="CFSTR_FILEDESCRIPTORW" value="TEXT(&quot;FileGroupDescriptorW&quot;)"/>
+  <define name="CFSTR_FILENAME" value="CFSTR_FILENAMEA"/>
+  <define name="CFSTR_FILENAMEA" value="TEXT(&quot;FileName&quot;)"/>
+  <define name="CFSTR_FILENAMEMAP" value="CFSTR_FILENAMEMAPA"/>
+  <define name="CFSTR_FILENAMEMAPA" value="TEXT(&quot;FileNameMap&quot;)"/>
+  <define name="CFSTR_FILENAMEMAPW" value="TEXT(&quot;FileNameMapW&quot;)"/>
+  <define name="CFSTR_FILENAMEW" value="TEXT(&quot;FileNameW&quot;)"/>
+  <define name="CFSTR_FILE_ATTRIBUTES_ARRAY" value="TEXT(&quot;FileAttributesArray&quot;)"/>
+  <define name="CFSTR_INDRAGLOOP" value="TEXT(&quot;InShellDragLoop&quot;)"/>
+  <define name="CFSTR_INETURL" value="CFSTR_INETURLA"/>
+  <define name="CFSTR_INETURLA" value="CFSTR_SHELLURL"/>
+  <define name="CFSTR_INETURLW" value="TEXT(&quot;UniformResourceLocatorW&quot;)"/>
+  <define name="CFSTR_INVOKECOMMAND_DROPPARAM" value="TEXT(&quot;InvokeCommandDropParam&quot;)"/>
+  <define name="CFSTR_LOGICALPERFORMEDDROPEFFECT" value="TEXT(&quot;LogicalPerformedDropEffect&quot;)"/>
+  <define name="CFSTR_MOUNTEDVOLUME" value="TEXT(&quot;MountedVolume&quot;)"/>
+  <define name="CFSTR_NETRESOURCES" value="TEXT(&quot;NetResource&quot;)"/>
+  <define name="CFSTR_PASTESUCCEEDED" value="TEXT(&quot;PasteSucceeded&quot;)"/>
+  <define name="CFSTR_PERFORMEDDROPEFFECT" value="TEXT(&quot;PerformedDropEffect&quot;)"/>
+  <define name="CFSTR_PERSISTEDDATAOBJECT" value="TEXT(&quot;PersistedDataObject&quot;)"/>
+  <define name="CFSTR_PREFERREDDROPEFFECT" value="TEXT(&quot;PreferredDropEffect&quot;)"/>
+  <define name="CFSTR_PRINTERGROUP" value="TEXT(&quot;PrinterFriendlyName&quot;)"/>
+  <define name="CFSTR_SHELLDROPHANDLER" value="TEXT(&quot;DropHandlerCLSID&quot;)"/>
+  <define name="CFSTR_SHELLIDLIST" value="TEXT(&quot;ShellIDListArray&quot;)"/>
+  <define name="CFSTR_SHELLIDLISTOFFSET" value="TEXT(&quot;ShellObjectOffsets&quot;)"/>
+  <define name="CFSTR_SHELLURL" value="TEXT(&quot;UniformResourceLocator&quot;)"/>
+  <define name="CFSTR_TARGETCLSID" value="TEXT(&quot;TargetCLSID&quot;)"/>
+  <define name="CFSTR_UNTRUSTEDDRAGDROP" value="TEXT(&quot;UntrustedDragDrop&quot;)"/>
+  <define name="CFSTR_ZONEIDENTIFIER" value="TEXT(&quot;ZoneIdentifier&quot;)"/>
+  <define name="CMDID_INTSHORTCUTCREATE" value="ISHCUTCMDID_INTSHORTCUTCREATE"/>
+  <define name="COMPONENT_DEFAULT_LEFT" value="(0xFFFF)"/>
+  <define name="COMPONENT_DEFAULT_TOP" value="(0xFFFF)"/>
+  <define name="COMPONENT_TOP" value="(0x3fffffff)"/>
+  <define name="COMP_ELEM_ALL" value="(COMP_ELEM_TYPE|COMP_ELEM_CHECKED|COMP_ELEM_DIRTY|COMP_ELEM_NOSCROLL|COMP_ELEM_POS_LEFT|COMP_ELEM_SIZE_WIDTH|COMP_ELEM_SIZE_HEIGHT|COMP_ELEM_POS_ZINDEX|COMP_ELEM_SOURCE|COMP_ELEM_FRIENDLYNAME|COMP_ELEM_POS_TOP|COMP_ELEM_SUBSCRIBEDURL|COMP_ELEM_ORIGINAL_CSI|COMP_ELEM_RESTORED_CSI|COMP_ELEM_CURITEMSTATE)"/>
+  <define name="COMP_ELEM_CHECKED" value="0x00000002"/>
+  <define name="COMP_ELEM_CURITEMSTATE" value="0x00004000"/>
+  <define name="COMP_ELEM_DIRTY" value="0x00000004"/>
+  <define name="COMP_ELEM_FRIENDLYNAME" value="0x00000400"/>
+  <define name="COMP_ELEM_NOSCROLL" value="0x00000008"/>
+  <define name="COMP_ELEM_ORIGINAL_CSI" value="0x00001000"/>
+  <define name="COMP_ELEM_POS_LEFT" value="0x00000010"/>
+  <define name="COMP_ELEM_POS_TOP" value="0x00000020"/>
+  <define name="COMP_ELEM_POS_ZINDEX" value="0x00000100"/>
+  <define name="COMP_ELEM_RESTORED_CSI" value="0x00002000"/>
+  <define name="COMP_ELEM_SIZE_HEIGHT" value="0x00000080"/>
+  <define name="COMP_ELEM_SIZE_WIDTH" value="0x00000040"/>
+  <define name="COMP_ELEM_SOURCE" value="0x00000200"/>
+  <define name="COMP_ELEM_SUBSCRIBEDURL" value="0x00000800"/>
+  <define name="COMP_ELEM_TYPE" value="0x00000001"/>
+  <define name="COMP_TYPE_CFHTML" value="4"/>
+  <define name="COMP_TYPE_CONTROL" value="3"/>
+  <define name="COMP_TYPE_HTMLDOC" value="0"/>
+  <define name="COMP_TYPE_MAX" value="4"/>
+  <define name="COMP_TYPE_PICTURE" value="1"/>
+  <define name="COMP_TYPE_WEBSITE" value="2"/>
+  <define name="CSIDL_ADMINTOOLS" value="0x0030"/>
+  <define name="CSIDL_ALTSTARTUP" value="0x001d"/>
+  <define name="CSIDL_APPDATA" value="0x001a"/>
+  <define name="CSIDL_BITBUCKET" value="0x000a"/>
+  <define name="CSIDL_CDBURN_AREA" value="0x003b"/>
+  <define name="CSIDL_COMMON_ADMINTOOLS" value="0x002f"/>
+  <define name="CSIDL_COMMON_ALTSTARTUP" value="0x001e"/>
+  <define name="CSIDL_COMMON_APPDATA" value="0x0023"/>
+  <define name="CSIDL_COMMON_DESKTOPDIRECTORY" value="0x0019"/>
+  <define name="CSIDL_COMMON_DOCUMENTS" value="0x002e"/>
+  <define name="CSIDL_COMMON_FAVORITES" value="0x001f"/>
+  <define name="CSIDL_COMMON_MUSIC" value="0x0035"/>
+  <define name="CSIDL_COMMON_OEM_LINKS" value="0x003a"/>
+  <define name="CSIDL_COMMON_PICTURES" value="0x0036"/>
+  <define name="CSIDL_COMMON_PROGRAMS" value="0X0017"/>
+  <define name="CSIDL_COMMON_STARTMENU" value="0x0016"/>
+  <define name="CSIDL_COMMON_STARTUP" value="0x0018"/>
+  <define name="CSIDL_COMMON_TEMPLATES" value="0x002d"/>
+  <define name="CSIDL_COMMON_VIDEO" value="0x0037"/>
+  <define name="CSIDL_COMPUTERSNEARME" value="0x003d"/>
+  <define name="CSIDL_CONNECTIONS" value="0x0031"/>
+  <define name="CSIDL_CONTROLS" value="0x0003"/>
+  <define name="CSIDL_COOKIES" value="0x0021"/>
+  <define name="CSIDL_DESKTOP" value="0x0000"/>
+  <define name="CSIDL_DESKTOPDIRECTORY" value="0x0010"/>
+  <define name="CSIDL_DRIVES" value="0x0011"/>
+  <define name="CSIDL_FAVORITES" value="0x0006"/>
+  <define name="CSIDL_FLAG_CREATE" value="0x8000"/>
+  <define name="CSIDL_FLAG_DONT_UNEXPAND" value="0x2000"/>
+  <define name="CSIDL_FLAG_DONT_VERIFY" value="0x4000"/>
+  <define name="CSIDL_FLAG_MASK" value="0xFF00"/>
+  <define name="CSIDL_FLAG_NO_ALIAS" value="0x1000"/>
+  <define name="CSIDL_FLAG_PER_USER_INIT" value="0x0800"/>
+  <define name="CSIDL_FONTS" value="0x0014"/>
+  <define name="CSIDL_HISTORY" value="0x0022"/>
+  <define name="CSIDL_INTERNET" value="0x0001"/>
+  <define name="CSIDL_INTERNET_CACHE" value="0x0020"/>
+  <define name="CSIDL_LOCAL_APPDATA" value="0x001c"/>
+  <define name="CSIDL_MYDOCUMENTS" value="CSIDL_PERSONAL"/>
+  <define name="CSIDL_MYMUSIC" value="0x000d"/>
+  <define name="CSIDL_MYPICTURES" value="0x0027"/>
+  <define name="CSIDL_MYVIDEO" value="0x000e"/>
+  <define name="CSIDL_NETHOOD" value="0x0013"/>
+  <define name="CSIDL_NETWORK" value="0x0012"/>
+  <define name="CSIDL_PERSONAL" value="0x0005"/>
+  <define name="CSIDL_PRINTERS" value="0x0004"/>
+  <define name="CSIDL_PRINTHOOD" value="0x001b"/>
+  <define name="CSIDL_PROFILE" value="0x0028"/>
+  <define name="CSIDL_PROGRAMS" value="0x0002"/>
+  <define name="CSIDL_PROGRAM_FILES" value="0x0026"/>
+  <define name="CSIDL_PROGRAM_FILESX86" value="0x002a"/>
+  <define name="CSIDL_PROGRAM_FILES_COMMON" value="0x002b"/>
+  <define name="CSIDL_PROGRAM_FILES_COMMONX86" value="0x002c"/>
+  <define name="CSIDL_RECENT" value="0x0008"/>
+  <define name="CSIDL_RESOURCES" value="0x0038"/>
+  <define name="CSIDL_RESOURCES_LOCALIZED" value="0x0039"/>
+  <define name="CSIDL_SENDTO" value="0x0009"/>
+  <define name="CSIDL_STARTMENU" value="0x000b"/>
+  <define name="CSIDL_STARTUP" value="0x0007"/>
+  <define name="CSIDL_SYSTEM" value="0x0025"/>
+  <define name="CSIDL_SYSTEMX86" value="0x0029"/>
+  <define name="CSIDL_TEMPLATES" value="0x0015"/>
+  <define name="CSIDL_WINDOWS" value="0x0024"/>
+  <define name="DFM_CMD_COPY" value="((UINT)-3)"/>
+  <define name="DFM_CMD_DELETE" value="((UINT)-1)"/>
+  <define name="DFM_CMD_LINK" value="((UINT)-4)"/>
+  <define name="DFM_CMD_MODALPROP" value="((UINT)-12)"/>
+  <define name="DFM_CMD_MOVE" value="((UINT)-2)"/>
+  <define name="DFM_CMD_NEWFOLDER" value="((UINT)-6)"/>
+  <define name="DFM_CMD_PASTE" value="((UINT)-7)"/>
+  <define name="DFM_CMD_PASTELINK" value="((UINT)-10)"/>
+  <define name="DFM_CMD_PASTESPECIAL" value="((UINT)-11)"/>
+  <define name="DFM_CMD_PROPERTIES" value="((UINT)-5)"/>
+  <define name="DFM_CMD_RENAME" value="((UINT)-13)"/>
+  <define name="DFM_CMD_VIEWDETAILS" value="((UINT)-9)"/>
+  <define name="DFM_CMD_VIEWLIST" value="((UINT)-8)"/>
+  <define name="DFM_GETDEFSTATICID" value="14"/>
+  <define name="DFM_GETHELPTEXT" value="5"/>
+  <define name="DFM_GETHELPTEXTW" value="11"/>
+  <define name="DFM_GETVERBA" value="16"/>
+  <define name="DFM_GETVERBW" value="15"/>
+  <define name="DFM_INVOKECOMMAND" value="2"/>
+  <define name="DFM_INVOKECOMMANDEX" value="12"/>
+  <define name="DFM_MAPCOMMANDNAME" value="13"/>
+  <define name="DFM_MERGECONTEXTMENU" value="1"/>
+  <define name="DFM_MERGECONTEXTMENU_BOTTOM" value="17"/>
+  <define name="DFM_MERGECONTEXTMENU_TOP" value="10"/>
+  <define name="DFM_MODIFYQCMFLAGS" value="18"/>
+  <define name="DFM_VALIDATECMD" value="9"/>
+  <define name="DFM_WM_DRAWITEM" value="7"/>
+  <define name="DFM_WM_INITMENUPOPUP" value="8"/>
+  <define name="DFM_WM_MEASUREITEM" value="6"/>
+  <define name="DVASPECT_COPY" value="3"/>
+  <define name="DVASPECT_LINK" value="4"/>
+  <define name="DVASPECT_SHORTNAME" value="2"/>
+  <define name="EXP_DARWIN_ID_SIG" value="0xA0000006"/>
+  <define name="EXP_PROPERTYSTORAGE_SIG" value="0xA0000009"/>
+  <define name="EXP_SPECIAL_FOLDER_SIG" value="0xA0000005"/>
+  <define name="EXP_SZ_ICON_SIG" value="0xA0000007"/>
+  <define name="EXP_SZ_LINK_SIG" value="0xA0000001"/>
+  <define name="FCIDM_BROWSERFIRST" value="0xa000"/>
+  <define name="FCIDM_BROWSERLAST" value="0xbf00"/>
+  <define name="FCIDM_GLOBALFIRST" value="0x8000"/>
+  <define name="FCIDM_GLOBALLAST" value="0x9fff"/>
+  <define name="FCIDM_MENU_EDIT" value="(FCIDM_GLOBALFIRST+0x0040)"/>
+  <define name="FCIDM_MENU_EXPLORE" value="(FCIDM_GLOBALFIRST+0x0150)"/>
+  <define name="FCIDM_MENU_FAVORITES" value="(FCIDM_GLOBALFIRST+0x0170)"/>
+  <define name="FCIDM_MENU_FILE" value="(FCIDM_GLOBALFIRST+0x0000)"/>
+  <define name="FCIDM_MENU_FIND" value="(FCIDM_GLOBALFIRST+0x0140)"/>
+  <define name="FCIDM_MENU_HELP" value="(FCIDM_GLOBALFIRST+0x0100)"/>
+  <define name="FCIDM_MENU_TOOLS" value="(FCIDM_GLOBALFIRST+0x00c0)"/>
+  <define name="FCIDM_MENU_TOOLS_SEP_GOTO" value="(FCIDM_GLOBALFIRST+0x00c1)"/>
+  <define name="FCIDM_MENU_VIEW" value="(FCIDM_GLOBALFIRST+0x0080)"/>
+  <define name="FCIDM_MENU_VIEW_SEP_OPTIONS" value="(FCIDM_GLOBALFIRST+0x0081)"/>
+  <define name="FCIDM_SHVIEWFIRST" value="0x0000"/>
+  <define name="FCIDM_SHVIEWLAST" value="0x7fff"/>
+  <define name="FCSM_CLSID" value="0x00000008"/>
+  <define name="FCSM_FLAGS" value="0x00000040"/>
+  <define name="FCSM_ICONFILE" value="0x00000010"/>
+  <define name="FCSM_INFOTIP" value="0x00000004"/>
+  <define name="FCSM_LOGO" value="0x00000020"/>
+  <define name="FCSM_VIEWID" value="0x00000001"/>
+  <define name="FCSM_WEBVIEWTEMPLATE" value="0x00000002"/>
+  <define name="FCS_FLAG_DRAGDROP" value="2"/>
+  <define name="FCS_FORCEWRITE" value="0x00000002"/>
+  <define name="FCS_READ" value="0x00000001"/>
+  <define name="FCS_WRITE" value="(FCS_READ|FCS_FORCEWRITE)"/>
+  <define name="FILEDESCRIPTOR" value="FILEDESCRIPTORA"/>
+  <define name="FILEGROUPDESCRIPTOR" value="FILEGROUPDESCRIPTORA"/>
+  <define name="GIL_ASYNC" value="0x0020"/>
+  <define name="GIL_CHECKSHIELD" value="0x0200"/>
+  <define name="GIL_DEFAULTICON" value="0x0040"/>
+  <define name="GIL_DONTCACHE" value="0x0010"/>
+  <define name="GIL_FORCENOSHIELD" value="0x0400"/>
+  <define name="GIL_FORSHELL" value="0x0002"/>
+  <define name="GIL_FORSHORTCUT" value="0x0080"/>
+  <define name="GIL_NOTFILENAME" value="0x0008"/>
+  <define name="GIL_OPENICON" value="0x0001"/>
+  <define name="GIL_PERCLASS" value="0x0004"/>
+  <define name="GIL_PERINSTANCE" value="0x0002"/>
+  <define name="GIL_SHIELD" value="0x0200"/>
+  <define name="GIL_SIMULATEDOC" value="0x0001"/>
+  <define name="HPSXA_DEFINED" value=""/>
+  <define name="IDO_SHGIOI_DEFAULT" value="0x0FFFFFFFC"/>
+  <define name="IDO_SHGIOI_LINK" value="0x0FFFFFFE"/>
+  <define name="IDO_SHGIOI_SHARE" value="0x0FFFFFFF"/>
+  <define name="IDO_SHGIOI_SLOWFILE" value="0x0FFFFFFFD"/>
+  <define name="IExtractIcon" value="IExtractIconA"/>
+  <define name="IExtractIconVtbl" value="IExtractIconAVtbl"/>
+  <define name="ILCloneChild" value="ILCloneFirst"/>
+  <define name="ILCloneFull" value="ILClone"/>
+  <define name="ILCreateFromPath" value="ILCreateFromPathA"/>
+  <define name="ILIsAligned(pidl)" value="(((DWORD_PTR)(pidl)&amp;(sizeof(void*)-1))==0)"/>
+  <define name="ILIsChild(pidl)" value="(ILIsEmpty(pidl)||ILIsEmpty(ILNext(pidl)))"/>
+  <define name="ILIsEmpty(pidl)" value="((pidl)==NULL||(pidl)-&gt;mkid.cb==0)"/>
+  <define name="ILNext(pidl)" value="ILSkip(pidl,(pidl)-&gt;mkid.cb)"/>
+  <define name="ILSkip(pidl,cb)" value="((PUIDLIST_RELATIVE)VOID_OFFSET((pidl),(cb)))"/>
+  <define name="INTERFACE" value="INamedPropertyBag"/>
+  <define name="IS_FULLSCREEN" value="0x00000002"/>
+  <define name="IS_NORMAL" value="0x00000001"/>
+  <define name="IS_SPLIT" value="0x00000004"/>
+  <define name="IS_VALIDSIZESTATEBITS" value="(IS_NORMAL|IS_SPLIT|IS_FULLSCREEN)"/>
+  <define name="IS_VALIDSTATEBITS" value="(IS_NORMAL|IS_SPLIT|IS_FULLSCREEN|0x80000000|0x40000000)"/>
+  <define name="IShellExecuteHook" value="IShellExecuteHookA"/>
+  <define name="IShellExecuteHookVtbl" value="IShellExecuteHookAVtbl"/>
+  <define name="LPBROWSEINFO" value="LPBROWSEINFOA"/>
+  <define name="LPEXTRACTICON" value="LPEXTRACTICONA"/>
+  <define name="LPFILEDESCRIPTOR" value="LPFILEDESCRIPTORA"/>
+  <define name="LPFILEGROUPDESCRIPTOR" value="LPFILEGROUPDESCRIPTORA"/>
+  <define name="LPSHELLSTATE" value="LPSHELLSTATEA"/>
+  <define name="MAX_COLUMN_DESC_LEN" value="128"/>
+  <define name="MAX_COLUMN_NAME_LEN" value="80"/>
+  <define name="MM_ADDSEPARATOR" value="0x00000001L"/>
+  <define name="MM_DONTREMOVESEPS" value="0x00000004L"/>
+  <define name="MM_SUBMENUSHAVEIDS" value="0x00000002L"/>
+  <define name="NT_CONSOLE_PROPS_SIG" value="0xA0000002"/>
+  <define name="NT_FE_CONSOLE_PROPS_SIG" value="0xA0000004"/>
+  <define name="NUM_POINTS" value="3"/>
+  <define name="OFASI_EDIT" value="0x0001"/>
+  <define name="OFASI_OPENDESKTOP" value="0x0002"/>
+  <define name="OI_ASYNC" value="0xFFFFEEEE"/>
+  <define name="OI_DEFAULT" value="0x00000000"/>
+  <define name="PBROWSEINFO" value="PBROWSEINFOA"/>
+  <define name="PCS_FATAL" value="0x80000000"/>
+  <define name="PCS_PATHTOOLONG" value="0x00000008"/>
+  <define name="PCS_REMOVEDCHAR" value="0x00000002"/>
+  <define name="PCS_REPLACEDCHAR" value="0x00000001"/>
+  <define name="PCS_TRUNCATED" value="0x00000004"/>
+  <define name="PDTIMER_PAUSE" value="0x00000002"/>
+  <define name="PDTIMER_RESET" value="0x00000001"/>
+  <define name="PDTIMER_RESUME" value="0x00000003"/>
+  <define name="PIDISF_CACHEDSTICKY" value="0x00000002"/>
+  <define name="PIDISF_CACHEIMAGES" value="0x00000010"/>
+  <define name="PIDISF_FOLLOWALLLINKS" value="0x00000020"/>
+  <define name="PIDISF_RECENTLYCHANGED" value="0x00000001"/>
+  <define name="PIDISM_DONTWATCH" value="2"/>
+  <define name="PIDISM_GLOBAL" value="0"/>
+  <define name="PIDISM_WATCH" value="1"/>
+  <define name="PIDISR_NEEDS_ADD" value="1"/>
+  <define name="PIDISR_NEEDS_DELETE" value="3"/>
+  <define name="PIDISR_NEEDS_UPDATE" value="2"/>
+  <define name="PIDISR_UP_TO_DATE" value="0"/>
+  <define name="PID_INTSITE_AUTHOR" value="3"/>
+  <define name="PID_INTSITE_CODEPAGE" value="18"/>
+  <define name="PID_INTSITE_COMMENT" value="8"/>
+  <define name="PID_INTSITE_CONTENTCODE" value="11"/>
+  <define name="PID_INTSITE_CONTENTLEN" value="10"/>
+  <define name="PID_INTSITE_DESCRIPTION" value="7"/>
+  <define name="PID_INTSITE_FLAGS" value="9"/>
+  <define name="PID_INTSITE_ICONFILE" value="21"/>
+  <define name="PID_INTSITE_ICONINDEX" value="20"/>
+  <define name="PID_INTSITE_LASTMOD" value="5"/>
+  <define name="PID_INTSITE_LASTVISIT" value="4"/>
+  <define name="PID_INTSITE_RECURSE" value="12"/>
+  <define name="PID_INTSITE_ROAMED" value="34"/>
+  <define name="PID_INTSITE_SUBSCRIPTION" value="14"/>
+  <define name="PID_INTSITE_TITLE" value="16"/>
+  <define name="PID_INTSITE_TRACKING" value="19"/>
+  <define name="PID_INTSITE_URL" value="15"/>
+  <define name="PID_INTSITE_VISITCOUNT" value="6"/>
+  <define name="PID_INTSITE_WATCH" value="13"/>
+  <define name="PID_INTSITE_WHATSNEW" value="2"/>
+  <define name="PID_IS_AUTHOR" value="11"/>
+  <define name="PID_IS_COMMENT" value="13"/>
+  <define name="PID_IS_DESCRIPTION" value="12"/>
+  <define name="PID_IS_HOTKEY" value="6"/>
+  <define name="PID_IS_ICONFILE" value="9"/>
+  <define name="PID_IS_ICONINDEX" value="8"/>
+  <define name="PID_IS_NAME" value="4"/>
+  <define name="PID_IS_ROAMED" value="15"/>
+  <define name="PID_IS_SHOWCMD" value="7"/>
+  <define name="PID_IS_URL" value="2"/>
+  <define name="PID_IS_WHATSNEW" value="10"/>
+  <define name="PID_IS_WORKINGDIR" value="5"/>
+  <define name="PIFDEFFILESIZE" value="80"/>
+  <define name="PIFDEFPATHSIZE" value="64"/>
+  <define name="PIFMAXFILEPATH" value="260"/>
+  <define name="PIFNAMESIZE" value="30"/>
+  <define name="PIFPARAMSSIZE" value="64"/>
+  <define name="PIFSHDATASIZE" value="64"/>
+  <define name="PIFSHPROGSIZE" value="64"/>
+  <define name="PIFSTARTLOCSIZE" value="63"/>
+  <define name="PRF_DONTFINDLNK" value="0x0008"/>
+  <define name="PRF_FIRSTDIRDEF" value="0x0004"/>
+  <define name="PRF_REQUIREABSOLUTE" value="0x0010"/>
+  <define name="PRF_TRYPROGRAMEXTENSIONS" value="(0x0002|PRF_VERIFYEXISTS)"/>
+  <define name="PRF_VERIFYEXISTS" value="0x0001"/>
+  <define name="PROGDLG_AUTOTIME" value="0x00000002"/>
+  <define name="PROGDLG_MARQUEEPROGRESS" value="0x00000020"/>
+  <define name="PROGDLG_MODAL" value="0x00000001"/>
+  <define name="PROGDLG_NOCANCEL" value="0x00000040"/>
+  <define name="PROGDLG_NOMINIMIZE" value="0x00000008"/>
+  <define name="PROGDLG_NOPROGRESSBAR" value="0x00000010"/>
+  <define name="PROGDLG_NORMAL" value="0x00000000"/>
+  <define name="PROGDLG_NOTIME" value="0x00000004"/>
+  <define name="QCMINFO_PLACE_AFTER" value="1"/>
+  <define name="QCMINFO_PLACE_BEFORE" value="0"/>
+  <define name="QIF_CACHED" value="0x00000001"/>
+  <define name="QIF_DONTEXPANDFOLDER" value="0x00000002"/>
+  <define name="QITIPF_DEFAULT" value="0x00000000"/>
+  <define name="QITIPF_LINKNOTARGET" value="0x00000002"/>
+  <define name="QITIPF_LINKUSETARGET" value="0x00000004"/>
+  <define name="QITIPF_SINGLELINE" value="0x00000010"/>
+  <define name="QITIPF_USENAME" value="0x00000001"/>
+  <define name="QITIPF_USESLOWTIP" value="0x00000008"/>
+  <define name="REGSTR_PATH_SPECIAL_FOLDERS" value="REGSTR_PATH_EXPLORERTEXT(&quot;\\ShellFolders&quot;)"/>
+  <define name="SFVM_ADDPROPERTYPAGES" value="47"/>
+  <define name="SFVM_BACKGROUNDENUM" value="32"/>
+  <define name="SFVM_BACKGROUNDENUMDONE" value="48"/>
+  <define name="SFVM_COLUMNCLICK" value="24"/>
+  <define name="SFVM_DEFITEMCOUNT" value="26"/>
+  <define name="SFVM_DEFVIEWMODE" value="27"/>
+  <define name="SFVM_DIDDRAGDROP" value="36"/>
+  <define name="SFVM_FSNOTIFY" value="14"/>
+  <define name="SFVM_GETANIMATION" value="68"/>
+  <define name="SFVM_GETBUTTONINFO" value="5"/>
+  <define name="SFVM_GETBUTTONS" value="6"/>
+  <define name="SFVM_GETDETAILSOF" value="23"/>
+  <define name="SFVM_GETHELPTEXT" value="3"/>
+  <define name="SFVM_GETHELPTOPIC" value="63"/>
+  <define name="SFVM_GETNOTIFY" value="49"/>
+  <define name="SFVM_GETPANE" value="59"/>
+  <define name="SFVM_GETSORTDEFAULTS" value="53"/>
+  <define name="SFVM_GETTOOLTIPTEXT" value="4"/>
+  <define name="SFVM_GETZONE" value="58"/>
+  <define name="SFVM_INITMENUPOPUP" value="7"/>
+  <define name="SFVM_INVOKECOMMAND" value="2"/>
+  <define name="SFVM_MERGEMENU" value="1"/>
+  <define name="SFVM_QUERYFSNOTIFY" value="25"/>
+  <define name="SFVM_SETISFV" value="39"/>
+  <define name="SFVM_SIZE" value="57"/>
+  <define name="SFVM_THISIDLIST" value="41"/>
+  <define name="SFVM_UNMERGEMENU" value="28"/>
+  <define name="SFVM_UPDATESTATUSBAR" value="31"/>
+  <define name="SFVM_WINDOWCREATED" value="15"/>
+  <define name="SFVSOC_INVALIDATE_ALL" value="0x00000001"/>
+  <define name="SFVSOC_NOSCROLL" value="LVSICF_NOSCROLL"/>
+  <define name="SFVS_SELECT_ALLITEMS" value="0x1"/>
+  <define name="SFVS_SELECT_INVERT" value="0x2"/>
+  <define name="SFVS_SELECT_NONE" value="0x0"/>
+  <define name="SHARD_PATH" value="SHARD_PATHA"/>
+  <define name="SHBrowseForFolder" value="SHBrowseForFolderA"/>
+  <define name="SHCNEE_MSI_CHANGE" value="4L"/>
+  <define name="SHCNEE_MSI_UNINSTALL" value="5L"/>
+  <define name="SHCNEE_ORDERCHANGED" value="2L"/>
+  <define name="SHCNE_ALLEVENTS" value="0x7FFFFFFFL"/>
+  <define name="SHCNE_ASSOCCHANGED" value="0x08000000L"/>
+  <define name="SHCNE_ATTRIBUTES" value="0x00000800L"/>
+  <define name="SHCNE_CREATE" value="0x00000002L"/>
+  <define name="SHCNE_DELETE" value="0x00000004L"/>
+  <define name="SHCNE_DISKEVENTS" value="0x0002381FL"/>
+  <define name="SHCNE_DRIVEADD" value="0x00000100L"/>
+  <define name="SHCNE_DRIVEADDGUI" value="0x00010000L"/>
+  <define name="SHCNE_DRIVEREMOVED" value="0x00000080L"/>
+  <define name="SHCNE_EXTENDED_EVENT" value="0x04000000L"/>
+  <define name="SHCNE_FREESPACE" value="0x00040000L"/>
+  <define name="SHCNE_GLOBALEVENTS" value="0x0C0581E0L"/>
+  <define name="SHCNE_INTERRUPT" value="0x80000000L"/>
+  <define name="SHCNE_MEDIAINSERTED" value="0x00000020L"/>
+  <define name="SHCNE_MEDIAREMOVED" value="0x00000040L"/>
+  <define name="SHCNE_MKDIR" value="0x00000008L"/>
+  <define name="SHCNE_NETSHARE" value="0x00000200L"/>
+  <define name="SHCNE_NETUNSHARE" value="0x00000400L"/>
+  <define name="SHCNE_RENAMEFOLDER" value="0x00020000L"/>
+  <define name="SHCNE_RENAMEITEM" value="0x00000001L"/>
+  <define name="SHCNE_RMDIR" value="0x00000010L"/>
+  <define name="SHCNE_SERVERDISCONNECT" value="0x00004000L"/>
+  <define name="SHCNE_UPDATEDIR" value="0x00001000L"/>
+  <define name="SHCNE_UPDATEIMAGE" value="0x00008000L"/>
+  <define name="SHCNE_UPDATEITEM" value="0x00002000L"/>
+  <define name="SHCNF_DWORD" value="0x0003"/>
+  <define name="SHCNF_FLUSH" value="0x1000"/>
+  <define name="SHCNF_FLUSHNOWAIT" value="0x3000"/>
+  <define name="SHCNF_IDLIST" value="0x0000"/>
+  <define name="SHCNF_NOTIFYRECURSIVE" value="0x10000"/>
+  <define name="SHCNF_PATH" value="SHCNF_PATHA"/>
+  <define name="SHCNF_PATHA" value="0x0001"/>
+  <define name="SHCNF_PATHW" value="0x0005"/>
+  <define name="SHCNF_PRINTER" value="SHCNF_PRINTERA"/>
+  <define name="SHCNF_PRINTERA" value="0x0002"/>
+  <define name="SHCNF_PRINTERW" value="0x0006"/>
+  <define name="SHCNF_TYPE" value="0x00FF"/>
+  <define name="SHCNRF_InterruptLevel" value="0x0001"/>
+  <define name="SHCNRF_NewDelivery" value="0x8000"/>
+  <define name="SHCNRF_RecursiveInterrupt" value="0x1000"/>
+  <define name="SHCNRF_ShellLevel" value="0x0002"/>
+  <define name="SHCreateDirectoryEx" value="SHCreateDirectoryExA"/>
+  <define name="SHCreateFileExtractIcon" value="SHCreateFileExtractIconA"/>
+  <define name="SHDID_COMPUTER_AUDIO" value="19"/>
+  <define name="SHDID_COMPUTER_CDROM" value="10"/>
+  <define name="SHDID_COMPUTER_DRIVE35" value="5"/>
+  <define name="SHDID_COMPUTER_DRIVE525" value="6"/>
+  <define name="SHDID_COMPUTER_FIXED" value="8"/>
+  <define name="SHDID_COMPUTER_IMAGING" value="18"/>
+  <define name="SHDID_COMPUTER_NETDRIVE" value="9"/>
+  <define name="SHDID_COMPUTER_OTHER" value="12"/>
+  <define name="SHDID_COMPUTER_RAMDISK" value="11"/>
+  <define name="SHDID_COMPUTER_REMOVABLE" value="7"/>
+  <define name="SHDID_COMPUTER_SHAREDDOCS" value="20"/>
+  <define name="SHDID_FS_DIRECTORY" value="3"/>
+  <define name="SHDID_FS_FILE" value="2"/>
+  <define name="SHDID_FS_OTHER" value="4"/>
+  <define name="SHDID_MOBILE_DEVICE" value="21"/>
+  <define name="SHDID_NET_DOMAIN" value="13"/>
+  <define name="SHDID_NET_OTHER" value="17"/>
+  <define name="SHDID_NET_RESTOFNET" value="16"/>
+  <define name="SHDID_NET_SERVER" value="14"/>
+  <define name="SHDID_NET_SHARE" value="15"/>
+  <define name="SHDID_REMOTE_DESKTOP_DRIVE" value="22"/>
+  <define name="SHDID_ROOT_REGITEM" value="1"/>
+  <define name="SHDOCAPI" value="EXTERN_CDECLSPEC_IMPORTHRESULTSTDAPICALLTYPE"/>
+  <define name="SHDOCAPI_(type)" value="EXTERN_CDECLSPEC_IMPORTtypeSTDAPICALLTYPE"/>
+  <define name="SHDefExtractIcon" value="SHDefExtractIconA"/>
+  <define name="SHELLSTATE" value="SHELLSTATEA"/>
+  <define name="SHELLSTATEVERSION_IE4" value="9"/>
+  <define name="SHELLSTATEVERSION_WIN2K" value="10"/>
+  <define name="SHELLSTATE_SIZE_IE4" value="FIELD_OFFSET(SHELLSTATE,uNotUsed)"/>
+  <define name="SHELLSTATE_SIZE_NT4" value="FIELD_OFFSET(SHELLSTATE,version)"/>
+  <define name="SHELLSTATE_SIZE_WIN2K" value="sizeof(SHELLSTATE)"/>
+  <define name="SHELLSTATE_SIZE_WIN95" value="FIELD_OFFSET(SHELLSTATE,lParamSort)"/>
+  <define name="SHFMT_CANCEL" value="0xFFFFFFFEL"/>
+  <define name="SHFMT_ERROR" value="0xFFFFFFFFL"/>
+  <define name="SHFMT_ID_DEFAULT" value="0xFFFF"/>
+  <define name="SHFMT_NOFORMAT" value="0xFFFFFFFDL"/>
+  <define name="SHFMT_OPT_FULL" value="0x0001"/>
+  <define name="SHFMT_OPT_SYSONLY" value="0x0002"/>
+  <define name="SHFOLDERAPI" value="EXTERN_CDECLSPEC_IMPORTHRESULTSTDAPICALLTYPE"/>
+  <define name="SHGDFIL_DESCRIPTIONID" value="3"/>
+  <define name="SHGDFIL_FINDDATA" value="1"/>
+  <define name="SHGDFIL_NETRESOURCE" value="2"/>
+  <define name="SHGetDataFromIDList" value="SHGetDataFromIDListA"/>
+  <define name="SHGetFolderPath" value="SHGetFolderPathA"/>
+  <define name="SHGetFolderPathAndSubDir" value="SHGetFolderPathAndSubDirA"/>
+  <define name="SHGetIconOverlayIndex" value="SHGetIconOverlayIndexA"/>
+  <define name="SHGetPathFromIDList" value="SHGetPathFromIDListA"/>
+  <define name="SHGetSpecialFolderPath" value="SHGetSpecialFolderPathA"/>
+  <define name="SHOP_FILEPATH" value="0x00000002"/>
+  <define name="SHOP_PRINTERNAME" value="0x00000001"/>
+  <define name="SHOP_VOLUMEGUID" value="0x00000004"/>
+  <define name="SHPPFW_ASKDIRCREATE" value="0x00000002"/>
+  <define name="SHPPFW_DEFAULT" value="SHPPFW_DIRCREATE"/>
+  <define name="SHPPFW_DIRCREATE" value="0x00000001"/>
+  <define name="SHPPFW_IGNOREFILENAME" value="0x00000004"/>
+  <define name="SHPPFW_MEDIACHECKONLY" value="0x00000010"/>
+  <define name="SHPPFW_NONE" value="0x00000000"/>
+  <define name="SHPPFW_NOWRITECHECK" value="0x00000008"/>
+  <define name="SHPathPrepareForWrite" value="SHPathPrepareForWriteA"/>
+  <define name="SHSTDAPI" value="EXTERN_CDECLSPEC_IMPORTHRESULTSTDAPICALLTYPE"/>
+  <define name="SHSTDAPI_(type)" value="EXTERN_CDECLSPEC_IMPORTtypeSTDAPICALLTYPE"/>
+  <define name="SHSTDDOCAPI" value="EXTERN_CDECLSPEC_IMPORTHRESULTSTDAPICALLTYPE"/>
+  <define name="SHSTDDOCAPI_(type)" value="EXTERN_CDECLSPEC_IMPORTtypeSTDAPICALLTYPE"/>
+  <define name="SHSetFolderPath" value="SHSetFolderPathA"/>
+  <define name="SHStartNetConnectionDialog" value="SHStartNetConnectionDialogA"/>
+  <define name="SHUpdateImage" value="SHUpdateImageA"/>
+  <define name="SIOM_ICONINDEX" value="0x2"/>
+  <define name="SIOM_OVERLAYINDEX" value="0x1"/>
+  <define name="SIOM_RESERVED_DEFAULT" value="3"/>
+  <define name="SIOM_RESERVED_LINK" value="1"/>
+  <define name="SIOM_RESERVED_SHARED" value="0"/>
+  <define name="SIOM_RESERVED_SLOWFILE" value="2"/>
+  <define name="SSF_AUTOCHECKSELECT" value="0x00800000"/>
+  <define name="SSF_DESKTOPHTML" value="0x00000200"/>
+  <define name="SSF_DONTPRETTYPATH" value="0x00000800"/>
+  <define name="SSF_DOUBLECLICKINWEBVIEW" value="0x00000080"/>
+  <define name="SSF_FILTER" value="0x00010000"/>
+  <define name="SSF_HIDDENFILEEXTS" value="0x00000004"/>
+  <define name="SSF_HIDEICONS" value="0x00004000"/>
+  <define name="SSF_ICONSONLY" value="0x01000000"/>
+  <define name="SSF_MAPNETDRVBUTTON" value="0x00001000"/>
+  <define name="SSF_NOCONFIRMRECYCLE" value="0x00008000"/>
+  <define name="SSF_NONETCRAWLING" value="0x00100000"/>
+  <define name="SSF_SEPPROCESS" value="0x00080000"/>
+  <define name="SSF_SERVERADMINUI" value="0x00000004"/>
+  <define name="SSF_SHOWALLOBJECTS" value="0x00000001"/>
+  <define name="SSF_SHOWATTRIBCOL" value="0x00000100"/>
+  <define name="SSF_SHOWCOMPCOLOR" value="0x00000008"/>
+  <define name="SSF_SHOWEXTENSIONS" value="0x00000002"/>
+  <define name="SSF_SHOWINFOTIP" value="0x00002000"/>
+  <define name="SSF_SHOWSTARTPAGE" value="0x00400000"/>
+  <define name="SSF_SHOWSTATUSBAR" value="0x04000000"/>
+  <define name="SSF_SHOWSUPERHIDDEN" value="0x00040000"/>
+  <define name="SSF_SHOWSYSFILES" value="0x00000020"/>
+  <define name="SSF_SHOWTYPEOVERLAY" value="0x02000000"/>
+  <define name="SSF_SORTCOLUMNS" value="0x00000010"/>
+  <define name="SSF_STARTPANELON" value="0x00200000"/>
+  <define name="SSF_WEBVIEW" value="0x00020000"/>
+  <define name="SSF_WIN95CLASSIC" value="0x00000400"/>
+  <define name="STR_PARSE_PARTIAL_IDLIST" value="L&quot;ParseOriginalItem&quot;"/>
+  <define name="STR_PARSE_WITH_PROPERTIES" value="L&quot;ParseWithProperties&quot;"/>
+  <define name="Shell_GetCachedImageIndex" value="Shell_GetCachedImageIndexA"/>
+  <define name="VALIDATEUNC_CONNECT" value="0x0001"/>
+  <define name="VALIDATEUNC_NOUI" value="0x0002"/>
+  <define name="VALIDATEUNC_PERSIST" value="0x0008"/>
+  <define name="VALIDATEUNC_PRINT" value="0x0004"/>
+  <define name="VALIDATEUNC_VALID" value="0x0007"/>
+  <define name="VOID_OFFSET(pv,cb)" value="((void*)(((BYTE*)(pv))+(cb)))"/>
+  <define name="WINSHELLAPI" value="DECLSPEC_IMPORT"/>
+  <define name="WPSTYLE_CENTER" value="0"/>
+  <define name="WPSTYLE_CROPTOFIT" value="4"/>
+  <define name="WPSTYLE_KEEPASPECT" value="3"/>
+  <define name="WPSTYLE_MAX" value="3"/>
+  <define name="WPSTYLE_SPAN" value="5"/>
+  <define name="WPSTYLE_STRETCH" value="2"/>
+  <define name="WPSTYLE_TILE" value="1"/>
+  <!-- Ras.h -->
+  <define name="RASAPIVERSION_500" value="1"/>
+  <define name="RASAPIVERSION_501" value="2"/>
+  <define name="RASAPIVERSION_600" value="3"/>
+  <define name="RASAPIVERSION_601" value="4"/>
+  <!-- Winerror.h: COM Error Codes (Security and Setup) -->
+  <!-- Winerror.h: COM Error Codes (Generic) -->
+  <!-- Winerror.h: COM Error Codes (XACT, SCHED, OLE) -->
+  <define name="XACT_E_ALREADYOTHERSINGLEPHASE" value="0x8004D000"/>
+  <define name="XACT_E_CANTRETAIN" value="0x8004D001"/>
+  <define name="XACT_E_COMMITFAILED" value="0x8004D002"/>
+  <define name="XACT_E_COMMITPREVENTED" value="0x8004D003"/>
+  <define name="XACT_E_HEURISTICABORT" value="0x8004D004"/>
+  <define name="XACT_E_HEURISTICCOMMIT" value="0x8004D005"/>
+  <define name="XACT_E_HEURISTICDAMAGE" value="0x8004D006"/>
+  <define name="XACT_E_HEURISTICDANGER" value="0x8004D007"/>
+  <define name="XACT_E_ISOLATIONLEVEL" value="0x8004D008"/>
+  <define name="XACT_E_NOASYNC" value="0x8004D009"/>
+  <define name="XACT_E_NOENLIST" value="0x8004D00A"/>
+  <define name="XACT_E_NOISORETAIN" value="0x8004D00B"/>
+  <define name="XACT_E_NORESOURCE" value="0x8004D00C"/>
+  <define name="XACT_E_NOTCURRENT" value="0x8004D00D"/>
+  <define name="XACT_E_NOTRANSACTION" value="0x8004D00E"/>
+  <define name="XACT_E_NOTSUPPORTED" value="0x8004D00F"/>
+  <define name="XACT_E_UNKNOWNRMGRID" value="0x8004D010"/>
+  <define name="XACT_E_WRONGSTATE" value="0x8004D011"/>
+  <define name="XACT_E_WRONGUOW" value="0x8004D012"/>
+  <define name="XACT_E_XTIONEXISTS" value="0x8004D013"/>
+  <define name="XACT_E_NOIMPORTOBJECT" value="0x8004D014"/>
+  <define name="XACT_E_INVALIDCOOKIE" value="0x8004D015"/>
+  <define name="XACT_E_INDOUBT" value="0x8004D016"/>
+  <define name="XACT_E_NOTIMEOUT" value="0x8004D017"/>
+  <define name="XACT_E_ALREADYINPROGRESS" value="0x8004D018"/>
+  <define name="XACT_E_ABORTED" value="0x8004D019"/>
+  <define name="XACT_E_LOGFULL" value="0x8004D01A"/>
+  <define name="XACT_E_TMNOTAVAILABLE" value="0x8004D01B"/>
+  <define name="XACT_E_CONNECTION_DOWN" value="0x8004D01C"/>
+  <define name="XACT_E_CONNECTION_DENIED" value="0x8004D01D"/>
+  <define name="XACT_E_REENLISTTIMEOUT" value="0x8004D01E"/>
+  <define name="XACT_E_TIP_CONNECT_FAILED" value="0x8004D01F"/>
+  <define name="XACT_E_TIP_PROTOCOL_ERROR" value="0x8004D020"/>
+  <define name="XACT_E_TIP_PULL_FAILED" value="0x8004D021"/>
+  <define name="XACT_E_DEST_TMNOTAVAILABLE" value="0x8004D022"/>
+  <define name="XACT_E_TIP_DISABLED" value="0x8004D023"/>
+  <define name="XACT_E_NETWORK_TX_DISABLED" value="0x8004D024"/>
+  <define name="XACT_E_PARTNER_NETWORK_TX_DISABLED" value="0x8004D025"/>
+  <define name="XACT_E_XA_TX_DISABLED" value="0x8004D026"/>
+  <define name="XACT_E_UNABLE_TO_READ_DTC_CONFIG" value="0x8004D027"/>
+  <define name="XACT_E_UNABLE_TO_LOAD_DTC_PROXY" value="0x8004D028"/>
+  <define name="XACT_E_ABORTING" value="0x8004D029"/>
+  <define name="XACT_E_PUSH_COMM_FAILURE" value="0x8004D02A"/>
+  <define name="XACT_E_PULL_COMM_FAILURE" value="0x8004D02B"/>
+  <define name="XACT_E_LU_TX_DISABLED" value="0x8004D02C"/>
+  <define name="XACT_E_CLERKNOTFOUND" value="0x8004D080"/>
+  <define name="XACT_E_CLERKEXISTS" value="0x8004D081"/>
+  <define name="XACT_E_RECOVERYINPROGRESS" value="0x8004D082"/>
+  <define name="XACT_E_TRANSACTIONCLOSED" value="0x8004D083"/>
+  <define name="XACT_E_INVALIDLSN" value="0x8004D084"/>
+  <define name="XACT_E_REPLAYREQUEST" value="0x8004D085"/>
+  <define name="XACT_S_ASYNC" value="0x0004D000"/>
+  <define name="XACT_S_DEFECT" value="0x0004D001"/>
+  <define name="XACT_S_READONLY" value="0x0004D002"/>
+  <define name="XACT_S_SOMENORETAIN" value="0x0004D003"/>
+  <define name="XACT_S_OKINFORM" value="0x0004D004"/>
+  <define name="XACT_S_MADECHANGESCONTENT" value="0x0004D005"/>
+  <define name="XACT_S_MADECHANGESINFORM" value="0x0004D006"/>
+  <define name="XACT_S_ALLNORETAIN" value="0x0004D007"/>
+  <define name="XACT_S_ABORTING" value="0x0004D008"/>
+  <define name="XACT_S_SINGLEPHASE" value="0x0004D009"/>
+  <define name="XACT_S_LOCALLY_OK" value="0x0004D00A"/>
+  <define name="XACT_S_LASTRESOURCEMANAGER" value="0x0004D010"/>
+  <define name="CONTEXT_E_ABORTED" value="0x8004E002"/>
+  <define name="CONTEXT_E_ABORTING" value="0x8004E003"/>
+  <define name="CONTEXT_E_NOCONTEXT" value="0x8004E004"/>
+  <define name="CONTEXT_E_WOULD_DEADLOCK" value="0x8004E005"/>
+  <define name="CONTEXT_E_SYNCH_TIMEOUT" value="0x8004E006"/>
+  <define name="CONTEXT_E_OLDREF" value="0x8004E007"/>
+  <define name="CONTEXT_E_ROLENOTFOUND" value="0x8004E00C"/>
+  <define name="CONTEXT_E_TMNOTAVAILABLE" value="0x8004E00F"/>
+  <define name="CO_E_ACTIVATIONFAILED" value="0x8004E021"/>
+  <define name="CO_E_ACTIVATIONFAILED_EVENTLOGGED" value="0x8004E022"/>
+  <define name="CO_E_ACTIVATIONFAILED_CATALOGERROR" value="0x8004E023"/>
+  <define name="CO_E_ACTIVATIONFAILED_TIMEOUT" value="0x8004E024"/>
+  <define name="CO_E_INITIALIZATIONFAILED" value="0x8004E025"/>
+  <define name="CONTEXT_E_NOJIT" value="0x8004E026"/>
+  <define name="CONTEXT_E_NOTRANSACTION" value="0x8004E027"/>
+  <define name="CO_E_THREADINGMODEL_CHANGED" value="0x8004E028"/>
+  <define name="CO_E_NOIISINTRINSICS" value="0x8004E029"/>
+  <define name="CO_E_NOCOOKIES" value="0x8004E02A"/>
+  <define name="CO_E_DBERROR" value="0x8004E02B"/>
+  <define name="CO_E_NOTPOOLED" value="0x8004E02C"/>
+  <define name="CO_E_NOTCONSTRUCTED" value="0x8004E02D"/>
+  <define name="CO_E_NOSYNCHRONIZATION" value="0x8004E02E"/>
+  <define name="CO_E_ISOLEVELMISMATCH" value="0x8004E02F"/>
+  <define name="CO_E_CALL_OUT_OF_TX_SCOPE_NOT_ALLOWED" value="0x8004E030"/>
+  <define name="CO_E_EXIT_TRANSACTION_SCOPE_NOT_CALLED" value="0x8004E031"/>
+  <define name="OLE_S_USEREG" value="0x00040000"/>
+  <define name="OLE_S_STATIC" value="0x00040001"/>
+  <define name="OLE_S_MAC_CLIPFORMAT" value="0x00040002"/>
+  <define name="DRAGDROP_S_DROP" value="0x00040100"/>
+  <define name="DRAGDROP_S_CANCEL" value="0x00040101"/>
+  <define name="DRAGDROP_S_USEDEFAULTCURSORS" value="0x00040102"/>
+  <define name="DATA_S_SAMEFORMATETC" value="0x00040130"/>
+  <define name="VIEW_S_ALREADY_FROZEN" value="0x00040140"/>
+  <define name="CACHE_S_FORMATETC_NOTSUPPORTED" value="0x00040170"/>
+  <define name="CACHE_S_SAMECACHE" value="0x00040171"/>
+  <define name="CACHE_S_SOMECACHES_NOTUPDATED" value="0x00040172"/>
+  <define name="OLEOBJ_S_INVALIDVERB" value="0x00040180"/>
+  <define name="OLEOBJ_S_CANNOT_DOVERB_NOW" value="0x00040181"/>
+  <define name="OLEOBJ_S_INVALIDHWND" value="0x00040182"/>
+  <define name="INPLACE_S_TRUNCATED" value="0x000401A0"/>
+  <define name="CONVERT10_S_NO_PRESENTATION" value="0x000401C0"/>
+  <define name="MK_S_REDUCED_TO_SELF" value="0x000401E2"/>
+  <define name="MK_S_ME" value="0x000401E4"/>
+  <define name="MK_S_HIM" value="0x000401E5"/>
+  <define name="MK_S_US" value="0x000401E6"/>
+  <define name="MK_S_MONIKERALREADYREGISTERED" value="0x000401E7"/>
+  <define name="SCHED_S_TASK_READY" value="0x00041300"/>
+  <define name="SCHED_S_TASK_RUNNING" value="0x00041301"/>
+  <define name="SCHED_S_TASK_DISABLED" value="0x00041302"/>
+  <define name="SCHED_S_TASK_HAS_NOT_RUN" value="0x00041303"/>
+  <define name="SCHED_S_TASK_NO_MORE_RUNS" value="0x00041304"/>
+  <define name="SCHED_S_TASK_NOT_SCHEDULED" value="0x00041305"/>
+  <define name="SCHED_S_TASK_TERMINATED" value="0x00041306"/>
+  <define name="SCHED_S_TASK_NO_VALID_TRIGGERS" value="0x00041307"/>
+  <define name="SCHED_S_EVENT_TRIGGER" value="0x00041308"/>
+  <define name="SCHED_E_TRIGGER_NOT_FOUND" value="0x80041309"/>
+  <define name="SCHED_E_TASK_NOT_READY" value="0x8004130A"/>
+  <define name="SCHED_E_TASK_NOT_RUNNING" value="0x8004130B"/>
+  <define name="SCHED_E_SERVICE_NOT_INSTALLED" value="0x8004130C"/>
+  <define name="SCHED_E_CANNOT_OPEN_TASK" value="0x8004130D"/>
+  <define name="SCHED_E_INVALID_TASK" value="0x8004130E"/>
+  <define name="SCHED_E_ACCOUNT_INFORMATION_NOT_SET" value="0x8004130F"/>
+  <define name="SCHED_E_ACCOUNT_NAME_NOT_FOUND" value="0x80041310"/>
+  <define name="SCHED_E_ACCOUNT_DBASE_CORRUPT" value="0x80041311"/>
+  <define name="SCHED_E_NO_SECURITY_SERVICES" value="0x80041312"/>
+  <define name="SCHED_E_UNKNOWN_OBJECT_VERSION" value="0x80041313"/>
+  <define name="SCHED_E_UNSUPPORTED_ACCOUNT_OPTION" value="0x80041314"/>
+  <define name="SCHED_E_SERVICE_NOT_RUNNING" value="0x80041315"/>
+  <define name="SCHED_E_UNEXPECTEDNODE" value="0x80041316"/>
+  <define name="SCHED_E_NAMESPACE" value="0x80041317"/>
+  <define name="SCHED_E_INVALIDVALUE" value="0x80041318"/>
+  <define name="SCHED_E_MISSINGNODE" value="0x80041319"/>
+  <define name="SCHED_E_MALFORMEDXML" value="0x8004131A"/>
+  <define name="SCHED_S_SOME_TRIGGERS_FAILED" value="0x0004131B"/>
+  <define name="SCHED_S_BATCH_LOGON_PROBLEM" value="0x0004131C"/>
+  <define name="SCHED_E_TOO_MANY_NODES" value="0x8004131D"/>
+  <define name="SCHED_E_PAST_END_BOUNDARY" value="0x8004131E"/>
+  <define name="SCHED_E_ALREADY_RUNNING" value="0x8004131F"/>
+  <define name="SCHED_E_USER_NOT_LOGGED_ON" value="0x80041320"/>
+  <define name="SCHED_E_INVALID_TASK_HASH" value="0x80041321"/>
+  <define name="SCHED_E_SERVICE_NOT_AVAILABLE" value="0x80041322"/>
+  <define name="SCHED_E_SERVICE_TOO_BUSY" value="0x80041323"/>
+  <define name="SCHED_E_TASK_ATTEMPTED" value="0x80041324"/>
+  <define name="SCHED_S_TASK_QUEUED" value="0x00041325"/>
+  <define name="SCHED_E_TASK_DISABLED" value="0x80041326"/>
+  <define name="SCHED_E_TASK_NOT_V1_COMPAT" value="0x80041327"/>
+  <define name="SCHED_E_START_ON_DEMAND" value="0x80041328"/>
+  <define name="SCHED_E_TASK_NOT_UBPM_COMPAT" value="0x80041329"/>
+  <define name="CO_E_CLASS_CREATE_FAILED" value="0x80080001"/>
+  <define name="CO_E_SCM_ERROR" value="0x80080002"/>
+  <define name="CO_E_SCM_RPC_FAILURE" value="0x80080003"/>
+  <define name="CO_E_BAD_PATH" value="0x80080004"/>
+  <define name="CO_E_SERVER_EXEC_FAILURE" value="0x80080005"/>
+  <define name="CO_E_OBJSRV_RPC_FAILURE" value="0x80080006"/>
+  <define name="MK_E_NO_NORMALIZED" value="0x80080007"/>
+  <define name="CO_E_SERVER_STOPPING" value="0x80080008"/>
+  <define name="MEM_E_INVALID_ROOT" value="0x80080009"/>
+  <define name="MEM_E_INVALID_LINK" value="0x80080010"/>
+  <define name="MEM_E_INVALID_SIZE" value="0x80080011"/>
+  <define name="CO_S_NOTALLINTERFACES" value="0x00080012"/>
+  <define name="CO_S_MACHINENAMENOTFOUND" value="0x00080013"/>
+  <define name="CO_E_MISSING_DISPLAYNAME" value="0x80080015"/>
+  <define name="CO_E_RUNAS_VALUE_MUST_BE_AAA" value="0x80080016"/>
+  <define name="CO_E_ELEVATION_DISABLED" value="0x80080017"/>
+  <define name="DISP_E_UNKNOWNINTERFACE" value="0x80020001"/>
+  <define name="DISP_E_MEMBERNOTFOUND" value="0x80020003"/>
+  <define name="DISP_E_PARAMNOTFOUND" value="0x80020004"/>
+  <define name="DISP_E_TYPEMISMATCH" value="0x80020005"/>
+  <define name="DISP_E_UNKNOWNNAME" value="0x80020006"/>
+  <define name="DISP_E_NONAMEDARGS" value="0x80020007"/>
+  <define name="DISP_E_BADVARTYPE" value="0x80020008"/>
+  <define name="DISP_E_EXCEPTION" value="0x80020009"/>
+  <define name="DISP_E_OVERFLOW" value="0x8002000A"/>
+  <define name="DISP_E_BADINDEX" value="0x8002000B"/>
+  <define name="DISP_E_UNKNOWNLCID" value="0x8002000C"/>
+  <define name="DISP_E_ARRAYISLOCKED" value="0x8002000D"/>
+  <define name="DISP_E_BADPARAMCOUNT" value="0x8002000E"/>
+  <define name="DISP_E_PARAMNOTOPTIONAL" value="0x8002000F"/>
+  <define name="DISP_E_BADCALLEE" value="0x80020010"/>
+  <define name="DISP_E_NOTACOLLECTION" value="0x80020011"/>
+  <define name="DISP_E_DIVBYZERO" value="0x80020012"/>
+  <define name="DISP_E_BUFFERTOOSMALL" value="0x80020013"/>
+  <define name="TYPE_E_BUFFERTOOSMALL" value="0x80028016"/>
+  <define name="TYPE_E_FIELDNOTFOUND" value="0x80028017"/>
+  <define name="TYPE_E_INVDATAREAD" value="0x80028018"/>
+  <define name="TYPE_E_UNSUPFORMAT" value="0x80028019"/>
+  <define name="TYPE_E_REGISTRYACCESS" value="0x8002801C"/>
+  <define name="TYPE_E_LIBNOTREGISTERED" value="0x8002801D"/>
+  <define name="TYPE_E_UNDEFINEDTYPE" value="0x80028027"/>
+  <define name="TYPE_E_QUALIFIEDNAMEDISALLOWED" value="0x80028028"/>
+  <define name="TYPE_E_INVALIDSTATE" value="0x80028029"/>
+  <define name="TYPE_E_WRONGTYPEKIND" value="0x8002802A"/>
+  <define name="TYPE_E_ELEMENTNOTFOUND" value="0x8002802B"/>
+  <define name="TYPE_E_AMBIGUOUSNAME" value="0x8002802C"/>
+  <define name="TYPE_E_NAMECONFLICT" value="0x8002802D"/>
+  <define name="TYPE_E_UNKNOWNLCID" value="0x8002802E"/>
+  <define name="TYPE_E_DLLFUNCTIONNOTFOUND" value="0x8002802F"/>
+  <define name="TYPE_E_BADMODULEKIND" value="0x800288BD"/>
+  <define name="TYPE_E_SIZETOOBIG" value="0x800288C5"/>
+  <define name="TYPE_E_DUPLICATEID" value="0x800288C6"/>
+  <define name="TYPE_E_INVALIDID" value="0x800288CF"/>
+  <define name="TYPE_E_TYPEMISMATCH" value="0x80028CA0"/>
+  <define name="TYPE_E_OUTOFBOUNDS" value="0x80028CA1"/>
+  <define name="TYPE_E_IOERROR" value="0x80028CA2"/>
+  <define name="TYPE_E_CANTCREATETMPFILE" value="0x80028CA3"/>
+  <define name="TYPE_E_CANTLOADLIBRARY" value="0x80029C4A"/>
+  <define name="TYPE_E_INCONSISTENTPROPFUNCS" value="0x80029C83"/>
+  <define name="TYPE_E_CIRCULARTYPE" value="0x80029C84"/>
+  <!-- winnt.h -->
+  <define name="UNREFERENCED_PARAMETER(P)" value="((void)(P))"/>
+  <define name="DBG_UNREFERENCED_PARAMETER(P)" value="((void)(P))"/>
+  <define name="DBG_UNREFERENCED_LOCAL_VARIABLE(P)" value="((void)(P))"/>
+  <!-- winreg.h -->
+  <define name="REG_OPTION_BACKUP_RESTORE" value="0x00000004L"/>
+  <define name="REG_OPTION_CREATE_LINK" value="0x00000002L"/>
+  <define name="REG_OPTION_NON_VOLATILE" value="0x00000000L"/>
+  <define name="REG_OPTION_VOLATILE" value="0x00000001L"/>
+  <define name="REG_CREATED_NEW_KEY" value="0x00000001L"/>
+  <define name="REG_OPENED_EXISTING_KEY" value="0x00000002L"/>
+  <define name="SHUTDOWN_FORCE_OTHERS" value="0x00000001"/>
+  <define name="SHUTDOWN_FORCE_SELF" value="0x00000002"/>
+  <define name="SHUTDOWN_GRACE_OVERRIDE" value="0x00000020"/>
+  <define name="SHUTDOWN_HYBRID" value="0x00000200"/>
+  <define name="SHUTDOWN_INSTALL_UPDATES" value="0x00000040"/>
+  <define name="SHUTDOWN_NOREBOOT" value="0x00000010"/>
+  <define name="SHUTDOWN_POWEROFF" value="0x00000008"/>
+  <define name="SHUTDOWN_RESTART" value="0x00000004"/>
+  <define name="SHUTDOWN_RESTARTAPPS" value="0x00000080"/>
+  <define name="RRF_RT_ANY" value="0x0000ffff"/>
+  <define name="RRF_RT_DWORD" value="0x00000018"/>
+  <define name="RRF_RT_QWORD" value="0x00000048"/>
+  <define name="RRF_RT_REG_BINARY" value="0x00000008"/>
+  <define name="RRF_RT_REG_DWORD" value="0x00000010"/>
+  <define name="RRF_RT_REG_EXPAND_SZ" value="0x00000004"/>
+  <define name="RRF_RT_REG_MULTI_SZ" value="0x00000020"/>
+  <define name="RRF_RT_REG_NONE" value="0x00000001"/>
+  <define name="RRF_RT_REG_QWORD" value="0x00000040"/>
+  <define name="RRF_RT_REG_SZ" value="0x00000002"/>
+  <define name="RRF_NOEXPAND" value="0x10000000"/>
+  <define name="RRF_ZEROONFAILURE" value="0x20000000"/>
+  <define name="RRF_SUBKEY_WOW6464KEY" value="0x00010000"/>
+  <define name="RRF_SUBKEY_WOW6432KEY" value="0x00020000"/>
+  <define name="REG_MUI_STRING_TRUNCATE" value="0x00000001"/>
+  <define name="REG_NOTIFY_CHANGE_NAME" value="0x00000001L"/>
+  <define name="REG_NOTIFY_CHANGE_ATTRIBUTES" value="0x00000002L"/>
+  <define name="REG_NOTIFY_CHANGE_LAST_SET" value="0x00000004L"/>
+  <define name="REG_NOTIFY_CHANGE_SECURITY" value="0x00000008L"/>
+  <define name="REG_NOTIFY_THREAD_AGNOSTIC" value="0x10000000L"/>
+  <define name="REG_WHOLE_HIVE_VOLATILE" value="0x00000001L"/>
+  <define name="DOCKINFO_DOCKED" value="0x2"/>
+  <define name="DOCKINFO_UNDOCKED" value="0x1"/>
+  <define name="DOCKINFO_USER_DOCKED" value="0x5"/>
+  <define name="DOCKINFO_USER_SUPPLIED" value="0x4"/>
+  <define name="DOCKINFO_USER_UNDOCKED" value="0x6"/>
+  <define name="FCIERR_ALLOC_FAIL" value="0x03"/>
+  <define name="FCIERR_CAB_FILE" value="0x06"/>
+  <define name="FCIERR_CAB_FORMAT_LIMIT" value="0x09"/>
+  <define name="FCIERR_MCI_FAIL" value="0x08"/>
+  <define name="FCIERR_NONE" value="0x00"/>
+  <define name="FCIERR_OPEN_SRC" value="0x01"/>
+  <define name="FCIERR_READ_SRC" value="0x02"/>
+  <define name="FCIERR_TEMP_FILE" value="0x04"/>
+  <define name="FCIERR_USER_ABORT" value="0x07"/>
+  <define name="FDIERROR_ALLOC_FAIL" value="0x05"/>
+  <define name="FDIERROR_BAD_COMPR_TYPE" value="0x06"/>
+  <define name="FDIERROR_CABINET_NOT_FOUND" value="0x01"/>
+  <define name="FDIERROR_CORRUPT_CABINET" value="0x04"/>
+  <define name="FDIERROR_MDI_FAIL" value="0x07"/>
+  <define name="FDIERROR_NONE" value="0x00"/>
+  <define name="FDIERROR_NOT_A_CABINET" value="0x02"/>
+  <define name="FDIERROR_RESERVE_MISMATCH" value="0x09"/>
+  <define name="FDIERROR_TARGET_FILE" value="0x08"/>
+  <define name="FDIERROR_UNKNOWN_CABINET_VERSION" value="0x03"/>
+  <define name="FDIERROR_USER_ABORT" value="0x0B"/>
+  <define name="FDIERROR_WRONG_CABINET" value="0x0A"/>
+  <define name="FH_STATE_DISABLED_BY_GP" value="0x02"/>
+  <define name="FH_STATE_FATAL_CONFIG_ERROR" value="0x03"/>
+  <define name="FH_STATE_NOT_TRACKED" value="0x00"/>
+  <define name="FH_STATE_NO_ERROR" value="0xFF"/>
+  <define name="FH_STATE_OFF" value="0x01"/>
+  <define name="FH_STATE_STAGING_FULL" value="0x12"/>
+  <define name="FH_STATE_TARGET_ABSENT" value="0x15"/>
+  <define name="FH_STATE_TARGET_ACCESS_DENIED" value="0x0E"/>
+  <define name="FH_STATE_TARGET_FULL" value="0x11"/>
+  <define name="FH_STATE_TARGET_FULL_RETENTION_MAX" value="0x10"/>
+  <define name="FH_STATE_TARGET_LOW_SPACE" value="0x14"/>
+  <define name="FH_STATE_TARGET_LOW_SPACE_RETENTION_MAX" value="0x13"/>
+  <define name="FH_STATE_TARGET_VOLUME_DIRTY" value="0x0F"/>
+  <define name="FH_STATE_TOO_MUCH_BEHIND" value="0x16"/>
+  <define name="ICW_ALREADYRUN" value="0x0004"/>
+  <define name="ICW_CHECKSTATUS" value="0x0001"/>
+  <define name="ICW_FULLPRESENT" value="0x0001"/>
+  <define name="ICW_FULL_SMARTSTART" value="0x800"/>
+  <define name="ICW_LAUNCHEDFULL" value="0x0100"/>
+  <define name="ICW_LAUNCHEDMANUAL" value="0x0200"/>
+  <define name="ICW_LAUNCHFULL" value="0x0100"/>
+  <define name="ICW_LAUNCHMANUAL" value="0x0200"/>
+  <define name="ICW_MANUALPRESENT" value="0x0002"/>
+  <define name="ICW_USE_SHELLNEXT" value="0x0400"/>
+  <define name="KEY_WOW64_32KEY" value="0x0200"/>
+  <define name="KEY_WOW64_64KEY" value="0x0100"/>
+  <define name="NETLOGON_CONTROL_CHANGE_PASSWORD" value="9"/>
+  <define name="NETLOGON_CONTROL_FORCE_DNS_REG" value="11"/>
+  <define name="NETLOGON_CONTROL_PDC_REPLICATE" value="4"/>
+  <define name="NETLOGON_CONTROL_QUERY" value="1"/>
+  <define name="NETLOGON_CONTROL_QUERY_DNS_REG" value="12"/>
+  <define name="NETLOGON_CONTROL_REDISCOVER" value="5"/>
+  <define name="NETLOGON_CONTROL_REPLICATE" value="2"/>
+  <define name="NETLOGON_CONTROL_SYNCHRONIZE" value="3"/>
+  <define name="NETLOGON_CONTROL_TC_QUERY" value="6"/>
+  <define name="NETLOGON_CONTROL_TC_VERIFY" value="10"/>
+  <define name="NETLOGON_DNS_UPDATE_FAILURE" value="0x00000040"/>
+  <define name="NETLOGON_FULL_SYNC_REPLICATION" value="0x00000004"/>
+  <define name="NETLOGON_HAS_IP" value="0x00000010"/>
+  <define name="NETLOGON_HAS_TIMESERV" value="0x00000020"/>
+  <define name="NETLOGON_REDO_NEEDED" value="0x00000008"/>
+  <define name="NETLOGON_REPLICATION_IN_PROGRESS" value="0x00000002"/>
+  <define name="NETLOGON_REPLICATION_NEEDED" value="0x00000001"/>
+  <define name="NETLOGON_VERIFY_STATUS_RETURNED" value="0x00000080"/>
+  <define name="REG_FORCE_RESTORE" value="0x00000008L"/>
+  <define name="REG_LATEST_FORMAT" value="2"/>
+  <define name="REG_NO_COMPRESSION" value="4"/>
+  <define name="REG_STANDARD_FORMAT" value="1"/>
+  <define name="SSRVACTION_EVENT" value="3"/>
+  <define name="SSRVACTION_QUERYCANCEL" value="2"/>
+  <define name="SSRVACTION_SIZE" value="5"/>
+  <define name="SSRVACTION_TRACE" value="1"/>
+  <define name="VARIABLE_ATTRIBUTE_APPEND_WRITE" value="0x00000040"/>
+  <define name="VARIABLE_ATTRIBUTE_AUTHENTICATED_WRITE_ACCESS" value="0x00000010"/>
+  <define name="VARIABLE_ATTRIBUTE_BOOTSERVICE_ACCESS" value="0x00000002"/>
+  <define name="VARIABLE_ATTRIBUTE_HARDWARE_ERROR_RECORD" value="0x00000008"/>
+  <define name="VARIABLE_ATTRIBUTE_NON_VOLATILE" value="0x00000001"/>
+  <define name="VARIABLE_ATTRIBUTE_RUNTIME_ACCESS" value="0x00000004"/>
+  <define name="VARIABLE_ATTRIBUTE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS" value="0x00000020"/>
+  <define name="VER_BUILDNUMBER" value="0x0000004"/>
+  <define name="VER_EQUAL" value="1"/>
+  <define name="VER_GREATER" value="2"/>
+  <define name="VER_GREATER_EQUAL" value="3"/>
+  <define name="VER_LESS" value="4"/>
+  <define name="VER_LESS_EQUAL" value="5"/>
+  <define name="VER_MAJORVERSION" value="0x0000002"/>
+  <define name="VER_MINORVERSION" value="0x0000001"/>
+  <define name="VER_NT_DOMAIN_CONTROLLER" value="0x0000002"/>
+  <define name="VER_NT_SERVER" value="0x0000003"/>
+  <define name="VER_NT_WORKSTATION" value="0x0000001"/>
+  <define name="VER_OR" value="7"/>
+  <define name="VER_PLATFORMID" value="0x0000008"/>
+  <define name="VER_PLATFORM_WIN32_NT" value="2"/>
+  <define name="VER_PRODUCT_TYPE" value="0x0000080"/>
+  <define name="VER_SERVICEPACKMAJOR" value="0x0000020"/>
+  <define name="VER_SERVICEPACKMINOR" value="0x0000010"/>
+  <define name="VER_SUITENAME" value="0x0000040"/>
+  <define name="VER_SUITE_BACKOFFICE" value="0x00000004"/>
+  <define name="VER_SUITE_BLADE" value="0x00000400"/>
+  <define name="VER_SUITE_COMPUTE_SERVER" value="0x00004000"/>
+  <define name="VER_SUITE_DATACENTER" value="0x00000080"/>
+  <define name="VER_SUITE_EMBEDDEDNT" value="0x00000040"/>
+  <define name="VER_SUITE_ENTERPRISE" value="0x00000002"/>
+  <define name="VER_SUITE_MULTIUSERTS" value="0x00020000"/>
+  <define name="VER_SUITE_PERSONAL" value="0x00000200"/>
+  <define name="VER_SUITE_SINGLEUSERTS" value="0x00000100"/>
+  <define name="VER_SUITE_SMALLBUSINESS" value="0x00000001"/>
+  <define name="VER_SUITE_SMALLBUSINESS_RESTRICTED" value="0x00000020"/>
+  <define name="VER_SUITE_STORAGE_SERVER" value="0x00002000"/>
+  <define name="VER_SUITE_TERMINAL" value="0x00000010"/>
+  <define name="VER_SUITE_WH_SERVER" value="0x00008000"/>
+  <!-- https://learn.microsoft.com/en-us/cpp/build/reference/entry-entry-point-symbol -->
+  <entrypoint name="mainCRTStartup"/>
+  <entrypoint name="WinMain"/>
+  <entrypoint name="WinMainCRTStartup"/>
+  <entrypoint name="DllMain"/>
+  <entrypoint name="_DllMainCRTStartup"/>
+  <!-- TODO: these are UNICODE-specific -->
+  <entrypoint name="wmain"/>
+  <entrypoint name="wmainCRTStartup"/>
+  <entrypoint name="wWinMain"/>
+  <entrypoint name="wWinMainCRTStartup"/>
+  <!-- TODO: this is actually a define -->
+  <entrypoint name="_tmain"/>
 </def>
diff --git a/cfg/wxsqlite3.cfg b/cfg/wxsqlite3.cfg
new file mode 100644
index 00000000000..0987c3d5275
--- /dev/null
+++ b/cfg/wxsqlite3.cfg
@@ -0,0 +1,1955 @@
+<?xml version="1.0"?>
+<def format="2">
+  <!-- wxString wxSQLite3Authorizer::AuthorizationCodeToString( wxSQLite3Authorizer::wxAuthorizationCode type ) -->
+  <function name="wxSQLite3Authorizer::AuthorizationCodeToString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSQLite3Blob::CheckBlob( void ) const -->
+  <function name="wxSQLite3Blob::CheckBlob">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+  </function>
+  <!-- int wxSQLite3Blob::GetSize( void ) const -->
+  <function name="wxSQLite3Blob::GetSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool wxSQLite3Blob::IsOk( void ) const -->
+  <function name="wxSQLite3Blob::IsOk">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool wxSQLite3Blob::IsReadOnly( void ) const -->
+  <function name="wxSQLite3Blob::IsReadOnly">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxMemoryBuffer & wxSQLite3Blob::Read( wxMemoryBuffer & blobValue, int length, int offset ) const -->
+  <function name="wxSQLite3Blob::Read">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxMemoryBuffer &amp;"/>
+    <const/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3Blob::Rebind( wxLongLong rowid ) -->
+  <function name="wxSQLite3Blob::Rebind">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSQLite3Blob::Write( const wxMemoryBuffer & blobValue, int offset ) -->
+  <function name="wxSQLite3Blob::Write">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxSQLite3CipherType wxSQLite3Cipher::GetCipher( wxSQLite3Database & db ) -->
+  <function name="wxSQLite3Cipher::GetCipher">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSQLite3CipherType"/>
+    <use-retval/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxSQLite3CipherType wxSQLite3Cipher::GetCipherDefault( wxSQLite3Database & db ) -->
+  <function name="wxSQLite3Cipher::GetCipherDefault">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSQLite3CipherType"/>
+    <use-retval/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- const wxString wxSQLite3Cipher::GetCipherName( wxSQLite3CipherType cipherType ) -->
+  <function name="wxSQLite3Cipher::GetCipherName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int wxSQLite3Cipher::GetCipherParameterMax( const wxString & cipherName, const wxString & paramName ) -->
+  <function name="wxSQLite3Cipher::GetCipherParameterMax">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- int wxSQLite3Cipher::GetCipherParameterMin( const wxString & cipherName, const wxString & paramName ) -->
+  <function name="wxSQLite3Cipher::GetCipherParameterMin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void * wxSQLite3Cipher::GetDatabaseHandle( wxSQLite3Database & db ) -->
+  <function name="wxSQLite3Cipher::GetDatabaseHandle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void *"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxSQLite3CipherType wxSQLite3Cipher::GetGlobalCipherDefault( void ) -->
+  <function name="wxSQLite3Cipher::GetGlobalCipherDefault">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSQLite3CipherType"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- int wxSQLite3Cipher::GetLegacyPageSize( void ) const -->
+  <function name="wxSQLite3Cipher::GetLegacyPageSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool wxSQLite3Cipher::InitializeFromCurrent( wxSQLite3Database & db ) -->
+  <function name="wxSQLite3Cipher::InitializeFromCurrent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool wxSQLite3Cipher::InitializeFromCurrentDefault( wxSQLite3Database & db ) -->
+  <function name="wxSQLite3Cipher::InitializeFromCurrentDefault">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool wxSQLite3Cipher::InitializeFromGlobalDefault( void ) -->
+  <function name="wxSQLite3Cipher::InitializeFromGlobalDefault">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSQLite3Cipher::IsOk( void ) const -->
+  <function name="wxSQLite3Cipher::IsOk">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool wxSQLite3Cipher::SetCipher( wxSQLite3Database & db, wxSQLite3CipherType cipherType ) -->
+  <function name="wxSQLite3Cipher::SetCipher">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSQLite3Cipher::SetCipherDefault( wxSQLite3Database & db, wxSQLite3CipherType cipherType ) -->
+  <function name="wxSQLite3Cipher::SetCipherDefault">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSQLite3Cipher::SetCipherType( wxSQLite3CipherType cipherType ) -->
+  <function name="wxSQLite3Cipher::SetCipherType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSQLite3Cipher::SetInitialized( bool initialized ) -->
+  <function name="wxSQLite3Cipher::SetInitialized">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3Cipher::SetLegacyPageSize( int pageSize ) -->
+  <function name="wxSQLite3Cipher::SetLegacyPageSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool wxSQLite3CipherAes128::GetLegacy( void ) -->
+  <function name="wxSQLite3CipherAes128::GetLegacy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSQLite3CipherAes128::InitializeFromCurrent( wxSQLite3Database & db ) -->
+  <function name="wxSQLite3CipherAes128::InitializeFromCurrent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool wxSQLite3CipherAes128::InitializeFromCurrentDefault( wxSQLite3Database & db ) -->
+  <function name="wxSQLite3CipherAes128::InitializeFromCurrentDefault">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool wxSQLite3CipherAes128::InitializeFromGlobalDefault( void ) -->
+  <function name="wxSQLite3CipherAes128::InitializeFromGlobalDefault">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSQLite3CipherAes128::SetLegacy( bool legacy ) -->
+  <function name="wxSQLite3CipherAes128::SetLegacy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int wxSQLite3CipherAes256::GetKdfIter( void ) -->
+  <function name="wxSQLite3CipherAes256::GetKdfIter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSQLite3CipherAes256::GetLegacy( void ) -->
+  <function name="wxSQLite3CipherAes256::GetLegacy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSQLite3CipherAes256::InitializeFromCurrent( wxSQLite3Database & db ) -->
+  <function name="wxSQLite3CipherAes256::InitializeFromCurrent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool wxSQLite3CipherAes256::InitializeFromCurrentDefault( wxSQLite3Database & db ) -->
+  <function name="wxSQLite3CipherAes256::InitializeFromCurrentDefault">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool wxSQLite3CipherAes256::InitializeFromGlobalDefault( void ) -->
+  <function name="wxSQLite3CipherAes256::InitializeFromGlobalDefault">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSQLite3CipherAes256::SetKdfIter( int kdfIter ) -->
+  <function name="wxSQLite3CipherAes256::SetKdfIter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3CipherAes256::SetLegacy( bool legacy ) -->
+  <function name="wxSQLite3CipherAes256::SetLegacy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int wxSQLite3CipherChaCha20::GetKdfIter( void ) -->
+  <function name="wxSQLite3CipherChaCha20::GetKdfIter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSQLite3CipherChaCha20::GetLegacy( void ) -->
+  <function name="wxSQLite3CipherChaCha20::GetLegacy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSQLite3CipherChaCha20::InitializeFromCurrent( wxSQLite3Database & db ) -->
+  <function name="wxSQLite3CipherChaCha20::InitializeFromCurrent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool wxSQLite3CipherChaCha20::InitializeFromCurrentDefault( wxSQLite3Database & db ) -->
+  <function name="wxSQLite3CipherChaCha20::InitializeFromCurrentDefault">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool wxSQLite3CipherChaCha20::InitializeFromGlobalDefault( void ) -->
+  <function name="wxSQLite3CipherChaCha20::InitializeFromGlobalDefault">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSQLite3CipherChaCha20::SetKdfIter( int kdfIter ) -->
+  <function name="wxSQLite3CipherChaCha20::SetKdfIter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3CipherChaCha20::SetLegacy( bool legacy ) -->
+  <function name="wxSQLite3CipherChaCha20::SetLegacy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool wxSQLite3CipherRC4::GetLegacy( void ) -->
+  <function name="wxSQLite3CipherRC4::GetLegacy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSQLite3CipherRC4::InitializeFromCurrent( wxSQLite3Database & db ) -->
+  <function name="wxSQLite3CipherRC4::InitializeFromCurrent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool wxSQLite3CipherRC4::InitializeFromCurrentDefault( wxSQLite3Database & db ) -->
+  <function name="wxSQLite3CipherRC4::InitializeFromCurrentDefault">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool wxSQLite3CipherRC4::InitializeFromGlobalDefault( void ) -->
+  <function name="wxSQLite3CipherRC4::InitializeFromGlobalDefault">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- int wxSQLite3CipherSQLCipher::GetFastKdfIter( void ) -->
+  <function name="wxSQLite3CipherSQLCipher::GetFastKdfIter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- Algorithm wxSQLite3CipherSQLCipher::GetHmacAlgorithm( void ) -->
+  <function name="wxSQLite3CipherSQLCipher::GetHmacAlgorithm">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="Algorithm"/>
+    <use-retval/>
+  </function>
+  <!-- int wxSQLite3CipherSQLCipher::GetHmacPgNo( void ) -->
+  <function name="wxSQLite3CipherSQLCipher::GetHmacPgNo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- int wxSQLite3CipherSQLCipher::GetHmacSaltMask( void ) -->
+  <function name="wxSQLite3CipherSQLCipher::GetHmacSaltMask">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSQLite3CipherSQLCipher::GetHmacUse( void ) -->
+  <function name="wxSQLite3CipherSQLCipher::GetHmacUse">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- Algorithm wxSQLite3CipherSQLCipher::GetKdfAlgorithm( void ) -->
+  <function name="wxSQLite3CipherSQLCipher::GetKdfAlgorithm">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="Algorithm"/>
+    <use-retval/>
+  </function>
+  <!-- int wxSQLite3CipherSQLCipher::GetKdfIter( void ) -->
+  <function name="wxSQLite3CipherSQLCipher::GetKdfIter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSQLite3CipherSQLCipher::GetLegacy( void ) -->
+  <function name="wxSQLite3CipherSQLCipher::GetLegacy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- int wxSQLite3CipherSQLCipher::GetLegacyVersion( void ) -->
+  <function name="wxSQLite3CipherSQLCipher::GetLegacyVersion">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSQLite3CipherSQLCipher::InitializeFromCurrent( wxSQLite3Database & db ) -->
+  <function name="wxSQLite3CipherSQLCipher::InitializeFromCurrent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool wxSQLite3CipherSQLCipher::InitializeFromCurrentDefault( wxSQLite3Database & db ) -->
+  <function name="wxSQLite3CipherSQLCipher::InitializeFromCurrentDefault">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool wxSQLite3CipherSQLCipher::InitializeFromGlobalDefault( void ) -->
+  <function name="wxSQLite3CipherSQLCipher::InitializeFromGlobalDefault">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSQLite3CipherSQLCipher::InitializeVersionDefault( int version ) -->
+  <function name="wxSQLite3CipherSQLCipher::InitializeVersionDefault">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3CipherSQLCipher::SetFastKdfIter( int fastKdfIter ) -->
+  <function name="wxSQLite3CipherSQLCipher::SetFastKdfIter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3CipherSQLCipher::SetHmacAlgorithm( Algorithm algorithm ) -->
+  <function name="wxSQLite3CipherSQLCipher::SetHmacAlgorithm">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSQLite3CipherSQLCipher::SetHmacPgNo( int hmacPgNo ) -->
+  <function name="wxSQLite3CipherSQLCipher::SetHmacPgNo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3CipherSQLCipher::SetHmacSaltMask( int hmacSaltMask ) -->
+  <function name="wxSQLite3CipherSQLCipher::SetHmacSaltMask">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3CipherSQLCipher::SetHmacUse( bool hmacUse ) -->
+  <function name="wxSQLite3CipherSQLCipher::SetHmacUse">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3CipherSQLCipher::SetKdfAlgorithm( Algorithm algorithm ) -->
+  <function name="wxSQLite3CipherSQLCipher::SetKdfAlgorithm">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSQLite3CipherSQLCipher::SetKdfIter( int kdfIter ) -->
+  <function name="wxSQLite3CipherSQLCipher::SetKdfIter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3CipherSQLCipher::SetLegacy( bool legacy ) -->
+  <function name="wxSQLite3CipherSQLCipher::SetLegacy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int wxSQLite3Collation::Compare( const wxString & text1, const wxString & text2 ) -->
+  <function name="wxSQLite3Collation::Compare">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSQLite3Database::AutoWriteAheadLogCheckpoint( int frameCount ) -->
+  <function name="wxSQLite3Database::AutoWriteAheadLogCheckpoint">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3Database::Begin( wxSQLite3TransactionType transactionType = WXSQLITE_TRANSACTION_DEFAULT ) -->
+  <function name="wxSQLite3Database::Begin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" default="WXSQLITE_TRANSACTION_DEFAULT" direction="in"/>
+  </function>
+  <!-- void wxSQLite3Database::CheckDatabase( void ) const -->
+  <function name="wxSQLite3Database::CheckDatabase">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+  </function>
+  <!-- void wxSQLite3Database::Commit( void ) -->
+  <function name="wxSQLite3Database::Commit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- bool wxSQLite3Database::CompileOptionUsed( const wxString & optionName ) -->
+  <function name="wxSQLite3Database::CompileOptionUsed">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSQLite3IntegerCollection wxSQLite3Database::CreateIntegerCollection( const wxString & collectionName ) -->
+  <function name="wxSQLite3Database::CreateIntegerCollection">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSQLite3IntegerCollection"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSQLite3StringCollection wxSQLite3Database::CreateStringCollection( const wxString & collectionName ) -->
+  <function name="wxSQLite3Database::CreateStringCollection">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSQLite3StringCollection"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSQLite3Database::DetachDatabase( const wxString & schemaName ) -->
+  <function name="wxSQLite3Database::DetachDatabase">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSQLite3Database::EnableForeignKeySupport( bool enable ) -->
+  <function name="wxSQLite3Database::EnableForeignKeySupport">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3Database::EnableLoadExtension( bool enable ) -->
+  <function name="wxSQLite3Database::EnableLoadExtension">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3Database::ExecCollationNeeded( void * db, void * internalDb, int eTextRep, const char * name ) -->
+  <function name="wxSQLite3Database::ExecCollationNeeded">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="inout">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int wxSQLite3Database::ExecComparisonWithCollation( void * collation, int len1, const void * txt1, int len2, const void * txt2 ) -->
+  <function name="wxSQLite3Database::ExecComparisonWithCollation">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="inout">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" direction="inout">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool wxSQLite3Database::GetAutoCommit( void ) const -->
+  <function name="wxSQLite3Database::GetAutoCommit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxString wxSQLite3Database::GetCompileOptionName( int optionIndex ) -->
+  <function name="wxSQLite3Database::GetCompileOptionName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSQLite3Database::GetDatabaseFilename( const wxString & databaseName ) -->
+  <function name="wxSQLite3Database::GetDatabaseFilename">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void * wxSQLite3Database::GetDatabaseHandle( void ) const -->
+  <function name="wxSQLite3Database::GetDatabaseHandle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void *"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSQLite3JournalMode wxSQLite3Database::GetJournalMode( const wxString & database = wxEmptyString ) -->
+  <function name="wxSQLite3Database::GetJournalMode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSQLite3JournalMode"/>
+    <use-retval/>
+    <arg nr="1" default="wxEmptyString" direction="in"/>
+  </function>
+  <!-- wxString wxSQLite3Database::GetKeySalt( const wxString & schemaName = wxEmptyString ) const -->
+  <function name="wxSQLite3Database::GetKeySalt">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" default="wxEmptyString" direction="in"/>
+  </function>
+  <!-- wxLongLong wxSQLite3Database::GetLastRowId( void ) const -->
+  <function name="wxSQLite3Database::GetLastRowId">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxLongLong"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- int wxSQLite3Database::GetLimit( wxSQLite3LimitType id ) const -->
+  <function name="wxSQLite3Database::GetLimit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxString wxSQLite3Database::GetSourceId( void ) -->
+  <function name="wxSQLite3Database::GetSourceId">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- int wxSQLite3Database::GetSystemErrorCode( void ) const -->
+  <function name="wxSQLite3Database::GetSystemErrorCode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void wxSQLite3Database::GetUserList( wxArrayString & userList ) -->
+  <function name="wxSQLite3Database::GetUserList">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxString wxSQLite3Database::GetVersion( void ) -->
+  <function name="wxSQLite3Database::GetVersion">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- wxString wxSQLite3Database::GetWrapperVersion( void ) -->
+  <function name="wxSQLite3Database::GetWrapperVersion">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- bool wxSQLite3Database::HasBackupSupport( void ) -->
+  <function name="wxSQLite3Database::HasBackupSupport">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- bool wxSQLite3Database::HasEncryptionSupport( void ) -->
+  <function name="wxSQLite3Database::HasEncryptionSupport">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- bool wxSQLite3Database::HasIncrementalBlobSupport( void ) -->
+  <function name="wxSQLite3Database::HasIncrementalBlobSupport">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- bool wxSQLite3Database::HasLoadExtSupport( void ) -->
+  <function name="wxSQLite3Database::HasLoadExtSupport">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- bool wxSQLite3Database::HasMetaDataSupport( void ) -->
+  <function name="wxSQLite3Database::HasMetaDataSupport">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- bool wxSQLite3Database::HasNamedCollectionSupport( void ) -->
+  <function name="wxSQLite3Database::HasNamedCollectionSupport">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- bool wxSQLite3Database::HasPointerParamsSupport( void ) -->
+  <function name="wxSQLite3Database::HasPointerParamsSupport">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- bool wxSQLite3Database::HasSavepointSupport( void ) -->
+  <function name="wxSQLite3Database::HasSavepointSupport">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- bool wxSQLite3Database::HasUserAuthenticationSupport( void ) -->
+  <function name="wxSQLite3Database::HasUserAuthenticationSupport">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- bool wxSQLite3Database::HasWriteAheadLogSupport( void ) -->
+  <function name="wxSQLite3Database::HasWriteAheadLogSupport">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- void wxSQLite3Database::Interrupt( void ) -->
+  <function name="wxSQLite3Database::Interrupt">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- bool wxSQLite3Database::IsEncrypted( void ) -->
+  <function name="wxSQLite3Database::IsEncrypted">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSQLite3Database::IsForeignKeySupportEnabled( void ) -->
+  <function name="wxSQLite3Database::IsForeignKeySupportEnabled">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSQLite3Database::IsOpen( void ) const -->
+  <function name="wxSQLite3Database::IsOpen">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool wxSQLite3Database::IsSharedCacheEnabled( void ) -->
+  <function name="wxSQLite3Database::IsSharedCacheEnabled">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <pure/>
+  </function>
+  <!-- wxString wxSQLite3Database::LimitTypeToString( wxSQLite3LimitType type ) -->
+  <function name="wxSQLite3Database::LimitTypeToString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void * wxSQLite3Database::Prepare( const char * sql ) -->
+  <function name="wxSQLite3Database::Prepare">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void *"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void * wxSQLite3Database::PreparePersistent( const char * sql ) -->
+  <function name="wxSQLite3Database::PreparePersistent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void *"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int wxSQLite3Database::QueryRollbackState( void ) const -->
+  <function name="wxSQLite3Database::QueryRollbackState">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSQLite3TransactionState wxSQLite3Database::QueryTransactionState( const wxString & schemaName = wxEmptyString ) const -->
+  <function name="wxSQLite3Database::QueryTransactionState">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSQLite3TransactionState"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" default="wxEmptyString" direction="in"/>
+  </function>
+  <!-- bool wxSQLite3Database::Randomness( int n, wxMemoryBuffer & random ) -->
+  <function name="wxSQLite3Database::Randomness">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void wxSQLite3Database::ReleaseMemory( void ) -->
+  <function name="wxSQLite3Database::ReleaseMemory">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxSQLite3Database::ReleaseSavepoint( const wxString & savepointName ) -->
+  <function name="wxSQLite3Database::ReleaseSavepoint">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSQLite3Database::RemoveAuthorizer( void ) -->
+  <function name="wxSQLite3Database::RemoveAuthorizer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSQLite3Database::Rollback( const wxString & savepointName = wxEmptyString ) -->
+  <function name="wxSQLite3Database::Rollback">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" default="wxEmptyString" direction="in"/>
+  </function>
+  <!-- void wxSQLite3Database::Savepoint( const wxString & savepointName ) -->
+  <function name="wxSQLite3Database::Savepoint">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSQLite3Database::SetAuthorizer( wxSQLite3Authorizer & authorizer ) -->
+  <function name="wxSQLite3Database::SetAuthorizer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSQLite3Database::SetBackupRestorePageCount( int pageCount ) -->
+  <function name="wxSQLite3Database::SetBackupRestorePageCount">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3Database::SetBusyTimeout( int milliSeconds ) -->
+  <function name="wxSQLite3Database::SetBusyTimeout">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3Database::SetCollation( const wxString & name, wxSQLite3Collation * collation ) -->
+  <function name="wxSQLite3Database::SetCollation">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void wxSQLite3Database::SetCollationNeededCallback( void ) -->
+  <function name="wxSQLite3Database::SetCollationNeededCallback">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxSQLite3Database::SetCommitHook( wxSQLite3Hook * commitHook ) -->
+  <function name="wxSQLite3Database::SetCommitHook">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxSQLite3JournalMode wxSQLite3Database::SetJournalMode( wxSQLite3JournalMode mode, const wxString & database = wxEmptyString ) -->
+  <function name="wxSQLite3Database::SetJournalMode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSQLite3JournalMode"/>
+    <use-retval/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="wxEmptyString" direction="in"/>
+  </function>
+  <!-- int wxSQLite3Database::SetLimit( wxSQLite3LimitType id, int newValue ) -->
+  <function name="wxSQLite3Database::SetLimit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3Database::SetRollbackHook( wxSQLite3Hook * rollbackHook ) -->
+  <function name="wxSQLite3Database::SetRollbackHook">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSQLite3Database::SetSharedCache( bool enable ) -->
+  <function name="wxSQLite3Database::SetSharedCache">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool wxSQLite3Database::SetTemporaryDirectory( const wxString & tempDirectory ) -->
+  <function name="wxSQLite3Database::SetTemporaryDirectory">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSQLite3Database::SetUpdateHook( wxSQLite3Hook * updateHook ) -->
+  <function name="wxSQLite3Database::SetUpdateHook">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSQLite3Database::SetWriteAheadLogHook( wxSQLite3Hook * walHook ) -->
+  <function name="wxSQLite3Database::SetWriteAheadLogHook">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSQLite3Database::ShutdownSQLite( void ) -->
+  <function name="wxSQLite3Database::ShutdownSQLite">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+  </function>
+  <!-- bool wxSQLite3Database::UserAdd( const wxString & username, const wxString & password, bool isAdmin = false ) -->
+  <function name="wxSQLite3Database::UserAdd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool wxSQLite3Database::UserChange( const wxString & username, const wxString & password, bool isAdmin ) -->
+  <function name="wxSQLite3Database::UserChange">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool wxSQLite3Database::UserDelete( const wxString & username ) -->
+  <function name="wxSQLite3Database::UserDelete">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSQLite3Database::UserIsPrivileged( const wxString & username ) -->
+  <function name="wxSQLite3Database::UserIsPrivileged">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSQLite3Database::UserLogin( const wxString & username, const wxString & password ) -->
+  <function name="wxSQLite3Database::UserLogin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSQLite3Database::Vacuum( void ) -->
+  <function name="wxSQLite3Database::Vacuum">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- const wxString wxSQLite3Exception::ErrorCodeAsString( int errorCode ) -->
+  <function name="wxSQLite3Exception::ErrorCodeAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString"/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int wxSQLite3Exception::GetErrorCode( void ) -->
+  <function name="wxSQLite3Exception::GetErrorCode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- int wxSQLite3Exception::GetExtendedErrorCode( void ) -->
+  <function name="wxSQLite3Exception::GetExtendedErrorCode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString wxSQLite3Exception::GetMessage( void ) -->
+  <function name="wxSQLite3Exception::GetMessage">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSQLite3FunctionContext::ExecAggregateFinalize( void * ctx ) -->
+  <function name="wxSQLite3FunctionContext::ExecAggregateFinalize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSQLite3FunctionContext::ExecAggregateStep( void * ctx, int argc, void * argv ) -->
+  <function name="wxSQLite3FunctionContext::ExecAggregateStep">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- int wxSQLite3FunctionContext::ExecCommitHook( void * hook ) -->
+  <function name="wxSQLite3FunctionContext::ExecCommitHook">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSQLite3FunctionContext::ExecRollbackHook( void * hook ) -->
+  <function name="wxSQLite3FunctionContext::ExecRollbackHook">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSQLite3FunctionContext::ExecScalarFunction( void * ctx, int argc, void * argv ) -->
+  <function name="wxSQLite3FunctionContext::ExecScalarFunction">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void wxSQLite3FunctionContext::ExecWindowFinalize( void * ctx ) -->
+  <function name="wxSQLite3FunctionContext::ExecWindowFinalize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSQLite3FunctionContext::ExecWindowInverse( void * ctx, int argc, void * argv ) -->
+  <function name="wxSQLite3FunctionContext::ExecWindowInverse">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void wxSQLite3FunctionContext::ExecWindowStep( void * ctx, int argc, void * argv ) -->
+  <function name="wxSQLite3FunctionContext::ExecWindowStep">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void wxSQLite3FunctionContext::ExecWindowValue( void * ctx ) -->
+  <function name="wxSQLite3FunctionContext::ExecWindowValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- int wxSQLite3FunctionContext::GetAggregateCount( void ) const -->
+  <function name="wxSQLite3FunctionContext::GetAggregateCount">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void * wxSQLite3FunctionContext::GetAggregateStruct( int len ) const -->
+  <function name="wxSQLite3FunctionContext::GetAggregateStruct">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void *"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int wxSQLite3FunctionContext::GetArgCount( void ) const -->
+  <function name="wxSQLite3FunctionContext::GetArgCount">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- int wxSQLite3FunctionContext::GetArgType( int argIndex ) const -->
+  <function name="wxSQLite3FunctionContext::GetArgType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- double wxSQLite3FunctionContext::GetDouble( int argIndex, double nullValue = 0 ) const -->
+  <function name="wxSQLite3FunctionContext::GetDouble">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- int wxSQLite3FunctionContext::GetInt( int argIndex, int nullValue = 0 ) const -->
+  <function name="wxSQLite3FunctionContext::GetInt">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxLongLong wxSQLite3FunctionContext::GetInt64( int argIndex, wxLongLong nullValue = 0 ) const -->
+  <function name="wxSQLite3FunctionContext::GetInt64">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxLongLong"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" default="0" direction="in"/>
+  </function>
+  <!-- void * wxSQLite3FunctionContext::GetPointer( int argIndex, const wxString & pointerType ) const -->
+  <function name="wxSQLite3FunctionContext::GetPointer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void *"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxString wxSQLite3FunctionContext::GetString( int argIndex, const wxString & nullValue = wxEmptyString ) const -->
+  <function name="wxSQLite3FunctionContext::GetString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" default="wxEmptyString" direction="in"/>
+  </function>
+  <!-- bool wxSQLite3FunctionContext::IsNull( int argIndex ) const -->
+  <function name="wxSQLite3FunctionContext::IsNull">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- const char * wxSQLite3FunctionContext::MakePointerTypeCopy( const wxString & pointerType ) -->
+  <function name="wxSQLite3FunctionContext::MakePointerTypeCopy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const char *"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSQLite3FunctionContext::SetResultArg( int argIndex ) -->
+  <function name="wxSQLite3FunctionContext::SetResultArg">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3FunctionContext::SetResultError( const wxString & errmsg ) -->
+  <function name="wxSQLite3FunctionContext::SetResultError">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSQLite3FunctionContext::SetResultNull( void ) -->
+  <function name="wxSQLite3FunctionContext::SetResultNull">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxSQLite3FunctionContext::SetResultZeroBlob( int blobSize ) -->
+  <function name="wxSQLite3FunctionContext::SetResultZeroBlob">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool wxSQLite3Hook::CommitCallback( void ) -->
+  <function name="wxSQLite3Hook::CommitCallback">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- wxSQLite3Database * wxSQLite3Hook::GetDatabase( void ) -->
+  <function name="wxSQLite3Hook::GetDatabase">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSQLite3Database *"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSQLite3Hook::RollbackCallback( void ) -->
+  <function name="wxSQLite3Hook::RollbackCallback">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxSQLite3Hook::SetDatabase( wxSQLite3Database * db ) -->
+  <function name="wxSQLite3Hook::SetDatabase">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSQLite3Logger::Activate( bool active = true ) -->
+  <function name="wxSQLite3Logger::Activate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3Logger::Deactivate( void ) -->
+  <function name="wxSQLite3Logger::Deactivate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxSQLite3Logger::ExecLoggerHook( void * logger, int errorCode, const char * errorMsg ) -->
+  <function name="wxSQLite3Logger::ExecLoggerHook">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="inout">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3Logger::HandleLogMessage( int errorCode, const wxString & errorMessage ) -->
+  <function name="wxSQLite3Logger::HandleLogMessage">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSQLite3Logger::IsActive( void ) -->
+  <function name="wxSQLite3Logger::IsActive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSQLite3NamedCollection::GetName( void ) -->
+  <function name="wxSQLite3NamedCollection::GetName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSQLite3NamedCollection::IsOk( void ) -->
+  <function name="wxSQLite3NamedCollection::IsOk">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSQLite3RegExpOperator::Execute( wxSQLite3FunctionContext & ctx ) -->
+  <function name="wxSQLite3RegExpOperator::Execute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSQLite3ResultSet::CheckStmt( void ) const -->
+  <function name="wxSQLite3ResultSet::CheckStmt">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+  </function>
+  <!-- bool wxSQLite3ResultSet::CursorMoved( void ) const -->
+  <function name="wxSQLite3ResultSet::CursorMoved">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool wxSQLite3ResultSet::Eof( void ) const -->
+  <function name="wxSQLite3ResultSet::Eof">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- int wxSQLite3ResultSet::FindColumnIndex( const wxString & columnName ) const -->
+  <function name="wxSQLite3ResultSet::FindColumnIndex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int wxSQLite3ResultSet::GetColumnCount( void ) const -->
+  <function name="wxSQLite3ResultSet::GetColumnCount">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxString wxSQLite3ResultSet::GetColumnName( int columnIndex ) const -->
+  <function name="wxSQLite3ResultSet::GetColumnName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int wxSQLite3ResultSet::GetColumnType( int columnIndex ) const -->
+  <function name="wxSQLite3ResultSet::GetColumnType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSQLite3ResultSet::GetDatabaseName( int columnIndex ) const -->
+  <function name="wxSQLite3ResultSet::GetDatabaseName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSQLite3ResultSet::GetDeclaredColumnType( int columnIndex ) const -->
+  <function name="wxSQLite3ResultSet::GetDeclaredColumnType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSQLite3ResultSet::GetExpandedSQL( void ) const -->
+  <function name="wxSQLite3ResultSet::GetExpandedSQL">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxString wxSQLite3ResultSet::GetOriginName( int columnIndex ) const -->
+  <function name="wxSQLite3ResultSet::GetOriginName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSQLite3ResultSet::GetSQL( void ) const -->
+  <function name="wxSQLite3ResultSet::GetSQL">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxString wxSQLite3ResultSet::GetTableName( int columnIndex ) const -->
+  <function name="wxSQLite3ResultSet::GetTableName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool wxSQLite3ResultSet::IsOk( void ) const -->
+  <function name="wxSQLite3ResultSet::IsOk">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool wxSQLite3ResultSet::NextRow( void ) -->
+  <function name="wxSQLite3ResultSet::NextRow">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSQLite3Statement::BindBool( int paramIndex, bool value ) -->
+  <function name="wxSQLite3Statement::BindBool">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3Statement::BindDate( int paramIndex, const wxDateTime & date ) -->
+  <function name="wxSQLite3Statement::BindDate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSQLite3Statement::BindDateTime( int paramIndex, const wxDateTime & datetime ) -->
+  <function name="wxSQLite3Statement::BindDateTime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSQLite3Statement::BindJulianDayNumber( int paramIndex, const wxDateTime & datetime ) -->
+  <function name="wxSQLite3Statement::BindJulianDayNumber">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSQLite3Statement::BindNull( int paramIndex ) -->
+  <function name="wxSQLite3Statement::BindNull">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3Statement::BindNumericDateTime( int paramIndex, const wxDateTime & datetime ) -->
+  <function name="wxSQLite3Statement::BindNumericDateTime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSQLite3Statement::BindTime( int paramIndex, const wxDateTime & time ) -->
+  <function name="wxSQLite3Statement::BindTime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSQLite3Statement::BindTimestamp( int paramIndex, const wxDateTime & timestamp ) -->
+  <function name="wxSQLite3Statement::BindTimestamp">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSQLite3Statement::BindUnixDateTime( int paramIndex, const wxDateTime & datetime ) -->
+  <function name="wxSQLite3Statement::BindUnixDateTime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSQLite3Statement::BindZeroBlob( int paramIndex, int blobSize ) -->
+  <function name="wxSQLite3Statement::BindZeroBlob">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3Statement::CheckDatabase( void ) const -->
+  <function name="wxSQLite3Statement::CheckDatabase">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+  </function>
+  <!-- void wxSQLite3Statement::CheckStmt( void ) const -->
+  <function name="wxSQLite3Statement::CheckStmt">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+  </function>
+  <!-- void wxSQLite3Statement::ClearBindings( void ) -->
+  <function name="wxSQLite3Statement::ClearBindings">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- wxSQLite3ResultSet wxSQLite3Statement::ExecuteQuery( void ) -->
+  <function name="wxSQLite3Statement::ExecuteQuery">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSQLite3ResultSet"/>
+    <use-retval/>
+  </function>
+  <!-- int wxSQLite3Statement::ExecuteScalar( void ) -->
+  <function name="wxSQLite3Statement::ExecuteScalar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- int wxSQLite3Statement::ExecuteUpdate( void ) -->
+  <function name="wxSQLite3Statement::ExecuteUpdate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSQLite3Statement::GetExpandedSQL( void ) const -->
+  <function name="wxSQLite3Statement::GetExpandedSQL">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- int wxSQLite3Statement::GetParamCount( void ) const -->
+  <function name="wxSQLite3Statement::GetParamCount">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- int wxSQLite3Statement::GetParamIndex( const wxString & paramName ) const -->
+  <function name="wxSQLite3Statement::GetParamIndex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxString wxSQLite3Statement::GetParamName( int paramIndex ) const -->
+  <function name="wxSQLite3Statement::GetParamName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSQLite3Statement::GetSQL( void ) const -->
+  <function name="wxSQLite3Statement::GetSQL">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool wxSQLite3Statement::IsBusy( void ) const -->
+  <function name="wxSQLite3Statement::IsBusy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool wxSQLite3Statement::IsOk( void ) const -->
+  <function name="wxSQLite3Statement::IsOk">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool wxSQLite3Statement::IsReadOnly( void ) const -->
+  <function name="wxSQLite3Statement::IsReadOnly">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void wxSQLite3Statement::Reset( void ) -->
+  <function name="wxSQLite3Statement::Reset">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- int wxSQLite3Statement::Status( wxSQLite3StatementStatus opCode, bool resetFlag = false ) const -->
+  <function name="wxSQLite3Statement::Status">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3StatementBuffer::Clear( void ) -->
+  <function name="wxSQLite3StatementBuffer::Clear">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- const char * wxSQLite3StatementBuffer::FormatV( const char * format, va_list va ) -->
+  <function name="wxSQLite3StatementBuffer::FormatV">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const char *"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSQLite3StringCollection::Bind( const wxArrayString & stringCollection ) -->
+  <function name="wxSQLite3StringCollection::Bind">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSQLite3Table::CheckResults( void ) const -->
+  <function name="wxSQLite3Table::CheckResults">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+  </function>
+  <!-- void wxSQLite3Table::Finalize( void ) -->
+  <function name="wxSQLite3Table::Finalize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- int wxSQLite3Table::FindColumnIndex( const wxString & columnName ) const -->
+  <function name="wxSQLite3Table::FindColumnIndex">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int wxSQLite3Table::GetColumnCount( void ) const -->
+  <function name="wxSQLite3Table::GetColumnCount">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxString wxSQLite3Table::GetColumnName( int columnIndex ) const -->
+  <function name="wxSQLite3Table::GetColumnName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int wxSQLite3Table::GetRowCount( void ) const -->
+  <function name="wxSQLite3Table::GetRowCount">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool wxSQLite3Table::IsOk( void ) const -->
+  <function name="wxSQLite3Table::IsOk">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void wxSQLite3Table::SetRow( int row ) -->
+  <function name="wxSQLite3Table::SetRow">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSQLite3Transaction::Commit( void ) -->
+  <function name="wxSQLite3Transaction::Commit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- bool wxSQLite3Transaction::IsActive( void ) -->
+  <function name="wxSQLite3Transaction::IsActive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSQLite3Transaction::Rollback( void ) -->
+  <function name="wxSQLite3Transaction::Rollback">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+</def>
diff --git a/cfg/wxsvg.cfg b/cfg/wxsvg.cfg
new file mode 100644
index 00000000000..c4e60d630f0
--- /dev/null
+++ b/cfg/wxsvg.cfg
@@ -0,0 +1,16905 @@
+<?xml version="1.0"?>
+<def format="2">
+  <!-- void wxCSSStyleDeclaration::Add( const wxCSSStyleDeclaration & style ) -->
+  <function name="wxCSSStyleDeclaration::Add">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetAlignmentBaseline( void ) -->
+  <function name="wxCSSStyleDeclaration::GetAlignmentBaseline">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxCSSStyleDeclaration::GetBaselineShift( void ) -->
+  <function name="wxCSSStyleDeclaration::GetBaselineShift">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxCSSStyleDeclaration::GetCSSText( void ) const -->
+  <function name="wxCSSStyleDeclaration::GetCSSText">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxCSSStyleDeclaration::GetClip( void ) -->
+  <function name="wxCSSStyleDeclaration::GetClip">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxCSSStyleDeclaration::GetClipPath( void ) -->
+  <function name="wxCSSStyleDeclaration::GetClipPath">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetClipRule( void ) -->
+  <function name="wxCSSStyleDeclaration::GetClipRule">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxRGBColor wxCSSStyleDeclaration::GetColor( void ) -->
+  <function name="wxCSSStyleDeclaration::GetColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxRGBColor"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetColorInterpolation( void ) -->
+  <function name="wxCSSStyleDeclaration::GetColorInterpolation">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetColorInterpolationFilters( void ) -->
+  <function name="wxCSSStyleDeclaration::GetColorInterpolationFilters">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxCSSStyleDeclaration::GetColorProfile( void ) -->
+  <function name="wxCSSStyleDeclaration::GetColorProfile">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetColorRendering( void ) -->
+  <function name="wxCSSStyleDeclaration::GetColorRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxCSSStyleDeclaration::GetCursor( void ) -->
+  <function name="wxCSSStyleDeclaration::GetCursor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetDirection( void ) -->
+  <function name="wxCSSStyleDeclaration::GetDirection">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetDisplay( void ) -->
+  <function name="wxCSSStyleDeclaration::GetDisplay">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetDominantBaseline( void ) -->
+  <function name="wxCSSStyleDeclaration::GetDominantBaseline">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetEnableBackground( void ) -->
+  <function name="wxCSSStyleDeclaration::GetEnableBackground">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGPaint & wxCSSStyleDeclaration::GetFill( void ) -->
+  <function name="wxCSSStyleDeclaration::GetFill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGPaint &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- double wxCSSStyleDeclaration::GetFillOpacity( void ) -->
+  <function name="wxCSSStyleDeclaration::GetFillOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetFillRule( void ) -->
+  <function name="wxCSSStyleDeclaration::GetFillRule">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxCSSStyleDeclaration::GetFilter( void ) -->
+  <function name="wxCSSStyleDeclaration::GetFilter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGColor & wxCSSStyleDeclaration::GetFloodColor( void ) -->
+  <function name="wxCSSStyleDeclaration::GetFloodColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGColor &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- double wxCSSStyleDeclaration::GetFloodOpacity( void ) -->
+  <function name="wxCSSStyleDeclaration::GetFloodOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxCSSStyleDeclaration::GetFontFamily( void ) -->
+  <function name="wxCSSStyleDeclaration::GetFontFamily">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+  </function>
+  <!-- double wxCSSStyleDeclaration::GetFontSize( void ) -->
+  <function name="wxCSSStyleDeclaration::GetFontSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxCSSStyleDeclaration::GetFontSizeAdjust( void ) -->
+  <function name="wxCSSStyleDeclaration::GetFontSizeAdjust">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetFontStretch( void ) -->
+  <function name="wxCSSStyleDeclaration::GetFontStretch">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetFontStyle( void ) -->
+  <function name="wxCSSStyleDeclaration::GetFontStyle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetFontVariant( void ) -->
+  <function name="wxCSSStyleDeclaration::GetFontVariant">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetFontWeight( void ) -->
+  <function name="wxCSSStyleDeclaration::GetFontWeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- double wxCSSStyleDeclaration::GetGlyphOrientationHorizontal( void ) -->
+  <function name="wxCSSStyleDeclaration::GetGlyphOrientationHorizontal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxCSSStyleDeclaration::GetGlyphOrientationVertical( void ) -->
+  <function name="wxCSSStyleDeclaration::GetGlyphOrientationVertical">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetImageRendering( void ) -->
+  <function name="wxCSSStyleDeclaration::GetImageRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxCSSStyleDeclaration::GetKerning( void ) -->
+  <function name="wxCSSStyleDeclaration::GetKerning">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxCSSStyleDeclaration::GetLetterSpacing( void ) -->
+  <function name="wxCSSStyleDeclaration::GetLetterSpacing">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGColor & wxCSSStyleDeclaration::GetLightingColor( void ) -->
+  <function name="wxCSSStyleDeclaration::GetLightingColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGColor &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxCSSStyleDeclaration::GetMarkerEnd( void ) -->
+  <function name="wxCSSStyleDeclaration::GetMarkerEnd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxCSSStyleDeclaration::GetMarkerMid( void ) -->
+  <function name="wxCSSStyleDeclaration::GetMarkerMid">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxCSSStyleDeclaration::GetMarkerStart( void ) -->
+  <function name="wxCSSStyleDeclaration::GetMarkerStart">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxCSSStyleDeclaration::GetMask( void ) -->
+  <function name="wxCSSStyleDeclaration::GetMask">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- double wxCSSStyleDeclaration::GetOpacity( void ) -->
+  <function name="wxCSSStyleDeclaration::GetOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetOverflow( void ) -->
+  <function name="wxCSSStyleDeclaration::GetOverflow">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetPointerEvents( void ) -->
+  <function name="wxCSSStyleDeclaration::GetPointerEvents">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_PROPERTY wxCSSStyleDeclaration::GetPropertyId( const wxString & propertyName ) -->
+  <function name="wxCSSStyleDeclaration::GetPropertyId">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_PROPERTY"/>
+    <use-retval/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxString wxCSSStyleDeclaration::GetPropertyName( wxCSS_PROPERTY propertyId ) -->
+  <function name="wxCSSStyleDeclaration::GetPropertyName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetShapeRendering( void ) -->
+  <function name="wxCSSStyleDeclaration::GetShapeRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGColor & wxCSSStyleDeclaration::GetStopColor( void ) -->
+  <function name="wxCSSStyleDeclaration::GetStopColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGColor &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- double wxCSSStyleDeclaration::GetStopOpacity( void ) -->
+  <function name="wxCSSStyleDeclaration::GetStopOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGPaint & wxCSSStyleDeclaration::GetStroke( void ) -->
+  <function name="wxCSSStyleDeclaration::GetStroke">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGPaint &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSValueList & wxCSSStyleDeclaration::GetStrokeDasharray( void ) -->
+  <function name="wxCSSStyleDeclaration::GetStrokeDasharray">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSValueList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- double wxCSSStyleDeclaration::GetStrokeDashoffset( void ) -->
+  <function name="wxCSSStyleDeclaration::GetStrokeDashoffset">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetStrokeLinecap( void ) -->
+  <function name="wxCSSStyleDeclaration::GetStrokeLinecap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetStrokeLinejoin( void ) -->
+  <function name="wxCSSStyleDeclaration::GetStrokeLinejoin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- double wxCSSStyleDeclaration::GetStrokeMiterlimit( void ) -->
+  <function name="wxCSSStyleDeclaration::GetStrokeMiterlimit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxCSSStyleDeclaration::GetStrokeOpacity( void ) -->
+  <function name="wxCSSStyleDeclaration::GetStrokeOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxCSSStyleDeclaration::GetStrokeWidth( void ) -->
+  <function name="wxCSSStyleDeclaration::GetStrokeWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetTextAnchor( void ) -->
+  <function name="wxCSSStyleDeclaration::GetTextAnchor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetTextDecoration( void ) -->
+  <function name="wxCSSStyleDeclaration::GetTextDecoration">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetTextRendering( void ) -->
+  <function name="wxCSSStyleDeclaration::GetTextRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetUnicodeBidi( void ) -->
+  <function name="wxCSSStyleDeclaration::GetUnicodeBidi">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetVisibility( void ) -->
+  <function name="wxCSSStyleDeclaration::GetVisibility">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxCSSStyleDeclaration::GetWordSpacing( void ) -->
+  <function name="wxCSSStyleDeclaration::GetWordSpacing">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSStyleDeclaration::GetWritingMode( void ) -->
+  <function name="wxCSSStyleDeclaration::GetWritingMode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasAlignmentBaseline( void ) -->
+  <function name="wxCSSStyleDeclaration::HasAlignmentBaseline">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasBaselineShift( void ) -->
+  <function name="wxCSSStyleDeclaration::HasBaselineShift">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasClip( void ) -->
+  <function name="wxCSSStyleDeclaration::HasClip">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasClipPath( void ) -->
+  <function name="wxCSSStyleDeclaration::HasClipPath">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasClipRule( void ) -->
+  <function name="wxCSSStyleDeclaration::HasClipRule">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasColor( void ) -->
+  <function name="wxCSSStyleDeclaration::HasColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasColorInterpolation( void ) -->
+  <function name="wxCSSStyleDeclaration::HasColorInterpolation">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasColorInterpolationFilters( void ) -->
+  <function name="wxCSSStyleDeclaration::HasColorInterpolationFilters">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasColorProfile( void ) -->
+  <function name="wxCSSStyleDeclaration::HasColorProfile">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasColorRendering( void ) -->
+  <function name="wxCSSStyleDeclaration::HasColorRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasCursor( void ) -->
+  <function name="wxCSSStyleDeclaration::HasCursor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasDirection( void ) -->
+  <function name="wxCSSStyleDeclaration::HasDirection">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasDisplay( void ) -->
+  <function name="wxCSSStyleDeclaration::HasDisplay">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasDominantBaseline( void ) -->
+  <function name="wxCSSStyleDeclaration::HasDominantBaseline">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasEnableBackground( void ) -->
+  <function name="wxCSSStyleDeclaration::HasEnableBackground">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasFill( void ) -->
+  <function name="wxCSSStyleDeclaration::HasFill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasFillOpacity( void ) -->
+  <function name="wxCSSStyleDeclaration::HasFillOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasFillRule( void ) -->
+  <function name="wxCSSStyleDeclaration::HasFillRule">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasFilter( void ) -->
+  <function name="wxCSSStyleDeclaration::HasFilter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasFloodColor( void ) -->
+  <function name="wxCSSStyleDeclaration::HasFloodColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasFloodOpacity( void ) -->
+  <function name="wxCSSStyleDeclaration::HasFloodOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasFontFamily( void ) -->
+  <function name="wxCSSStyleDeclaration::HasFontFamily">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasFontSize( void ) -->
+  <function name="wxCSSStyleDeclaration::HasFontSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasFontSizeAdjust( void ) -->
+  <function name="wxCSSStyleDeclaration::HasFontSizeAdjust">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasFontStretch( void ) -->
+  <function name="wxCSSStyleDeclaration::HasFontStretch">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasFontStyle( void ) -->
+  <function name="wxCSSStyleDeclaration::HasFontStyle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasFontVariant( void ) -->
+  <function name="wxCSSStyleDeclaration::HasFontVariant">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasFontWeight( void ) -->
+  <function name="wxCSSStyleDeclaration::HasFontWeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasGlyphOrientationHorizontal( void ) -->
+  <function name="wxCSSStyleDeclaration::HasGlyphOrientationHorizontal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasGlyphOrientationVertical( void ) -->
+  <function name="wxCSSStyleDeclaration::HasGlyphOrientationVertical">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasImageRendering( void ) -->
+  <function name="wxCSSStyleDeclaration::HasImageRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasKerning( void ) -->
+  <function name="wxCSSStyleDeclaration::HasKerning">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasLetterSpacing( void ) -->
+  <function name="wxCSSStyleDeclaration::HasLetterSpacing">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasLightingColor( void ) -->
+  <function name="wxCSSStyleDeclaration::HasLightingColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasMarkerEnd( void ) -->
+  <function name="wxCSSStyleDeclaration::HasMarkerEnd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasMarkerMid( void ) -->
+  <function name="wxCSSStyleDeclaration::HasMarkerMid">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasMarkerStart( void ) -->
+  <function name="wxCSSStyleDeclaration::HasMarkerStart">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasMask( void ) -->
+  <function name="wxCSSStyleDeclaration::HasMask">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasOpacity( void ) -->
+  <function name="wxCSSStyleDeclaration::HasOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasOverflow( void ) -->
+  <function name="wxCSSStyleDeclaration::HasOverflow">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasPointerEvents( void ) -->
+  <function name="wxCSSStyleDeclaration::HasPointerEvents">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasShapeRendering( void ) -->
+  <function name="wxCSSStyleDeclaration::HasShapeRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasStopColor( void ) -->
+  <function name="wxCSSStyleDeclaration::HasStopColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasStopOpacity( void ) -->
+  <function name="wxCSSStyleDeclaration::HasStopOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasStroke( void ) -->
+  <function name="wxCSSStyleDeclaration::HasStroke">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasStrokeDasharray( void ) -->
+  <function name="wxCSSStyleDeclaration::HasStrokeDasharray">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasStrokeDashoffset( void ) -->
+  <function name="wxCSSStyleDeclaration::HasStrokeDashoffset">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasStrokeLinecap( void ) -->
+  <function name="wxCSSStyleDeclaration::HasStrokeLinecap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasStrokeLinejoin( void ) -->
+  <function name="wxCSSStyleDeclaration::HasStrokeLinejoin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasStrokeMiterlimit( void ) -->
+  <function name="wxCSSStyleDeclaration::HasStrokeMiterlimit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasStrokeOpacity( void ) -->
+  <function name="wxCSSStyleDeclaration::HasStrokeOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasStrokeWidth( void ) -->
+  <function name="wxCSSStyleDeclaration::HasStrokeWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasTextAnchor( void ) -->
+  <function name="wxCSSStyleDeclaration::HasTextAnchor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasTextDecoration( void ) -->
+  <function name="wxCSSStyleDeclaration::HasTextDecoration">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasTextRendering( void ) -->
+  <function name="wxCSSStyleDeclaration::HasTextRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasUnicodeBidi( void ) -->
+  <function name="wxCSSStyleDeclaration::HasUnicodeBidi">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasVisibility( void ) -->
+  <function name="wxCSSStyleDeclaration::HasVisibility">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasWordSpacing( void ) -->
+  <function name="wxCSSStyleDeclaration::HasWordSpacing">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxCSSStyleDeclaration::HasWritingMode( void ) -->
+  <function name="wxCSSStyleDeclaration::HasWritingMode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- wxRGBColor wxCSSStyleDeclaration::ParseColor( const wxString & value ) -->
+  <function name="wxCSSStyleDeclaration::ParseColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxRGBColor"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- double wxCSSStyleDeclaration::ParseNumber( const wxString & value ) -->
+  <function name="wxCSSStyleDeclaration::ParseNumber">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::ParseSVGPaint( wxSVGPaint & paint, const wxString & value ) -->
+  <function name="wxCSSStyleDeclaration::ParseSVGPaint">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetAlignmentBaseline( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetAlignmentBaseline">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetBaselineShift( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxCSSStyleDeclaration::SetBaselineShift">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetCSSText( const wxString & text ) -->
+  <function name="wxCSSStyleDeclaration::SetCSSText">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetClip( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxCSSStyleDeclaration::SetClip">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetClipPath( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxCSSStyleDeclaration::SetClipPath">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetClipRule( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetClipRule">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetColor( const wxRGBColor & value ) -->
+  <function name="wxCSSStyleDeclaration::SetColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetColorInterpolation( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetColorInterpolation">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetColorInterpolationFilters( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetColorInterpolationFilters">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetColorProfile( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxCSSStyleDeclaration::SetColorProfile">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetColorRendering( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetColorRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetCursor( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxCSSStyleDeclaration::SetCursor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetDirection( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetDirection">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetDisplay( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetDisplay">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetDominantBaseline( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetDominantBaseline">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetEnableBackground( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetEnableBackground">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetFill( const wxSVGPaint & value ) -->
+  <function name="wxCSSStyleDeclaration::SetFill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetFillOpacity( double value ) -->
+  <function name="wxCSSStyleDeclaration::SetFillOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetFillRule( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetFillRule">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetFilter( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxCSSStyleDeclaration::SetFilter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetFloodColor( const wxSVGColor & value ) -->
+  <function name="wxCSSStyleDeclaration::SetFloodColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetFloodOpacity( double value ) -->
+  <function name="wxCSSStyleDeclaration::SetFloodOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetFontFamily( const wxString & value ) -->
+  <function name="wxCSSStyleDeclaration::SetFontFamily">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetFontSize( double value ) -->
+  <function name="wxCSSStyleDeclaration::SetFontSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetFontSizeAdjust( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxCSSStyleDeclaration::SetFontSizeAdjust">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetFontStretch( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetFontStretch">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetFontStyle( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetFontStyle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetFontVariant( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetFontVariant">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetFontWeight( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetFontWeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetGlyphOrientationHorizontal( double value ) -->
+  <function name="wxCSSStyleDeclaration::SetGlyphOrientationHorizontal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetGlyphOrientationVertical( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxCSSStyleDeclaration::SetGlyphOrientationVertical">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetImageRendering( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetImageRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetKerning( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxCSSStyleDeclaration::SetKerning">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetLetterSpacing( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxCSSStyleDeclaration::SetLetterSpacing">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetLightingColor( const wxSVGColor & value ) -->
+  <function name="wxCSSStyleDeclaration::SetLightingColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetMarkerEnd( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxCSSStyleDeclaration::SetMarkerEnd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetMarkerMid( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxCSSStyleDeclaration::SetMarkerMid">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetMarkerStart( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxCSSStyleDeclaration::SetMarkerStart">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetMask( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxCSSStyleDeclaration::SetMask">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetOpacity( double value ) -->
+  <function name="wxCSSStyleDeclaration::SetOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetOverflow( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetOverflow">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetPointerEvents( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetPointerEvents">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetShapeRendering( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetShapeRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetStopColor( const wxSVGColor & value ) -->
+  <function name="wxCSSStyleDeclaration::SetStopColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetStopOpacity( double value ) -->
+  <function name="wxCSSStyleDeclaration::SetStopOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetStroke( const wxSVGPaint & value ) -->
+  <function name="wxCSSStyleDeclaration::SetStroke">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetStrokeDasharray( const wxCSSValueList & value ) -->
+  <function name="wxCSSStyleDeclaration::SetStrokeDasharray">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetStrokeDashoffset( double value ) -->
+  <function name="wxCSSStyleDeclaration::SetStrokeDashoffset">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetStrokeLinecap( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetStrokeLinecap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetStrokeLinejoin( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetStrokeLinejoin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetStrokeMiterlimit( double value ) -->
+  <function name="wxCSSStyleDeclaration::SetStrokeMiterlimit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetStrokeOpacity( double value ) -->
+  <function name="wxCSSStyleDeclaration::SetStrokeOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetStrokeWidth( double value ) -->
+  <function name="wxCSSStyleDeclaration::SetStrokeWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetTextAnchor( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetTextAnchor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetTextDecoration( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetTextDecoration">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetTextRendering( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetTextRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetUnicodeBidi( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetUnicodeBidi">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetVisibility( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetVisibility">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetWordSpacing( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxCSSStyleDeclaration::SetWordSpacing">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleDeclaration::SetWritingMode( wxCSS_VALUE value ) -->
+  <function name="wxCSSStyleDeclaration::SetWritingMode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSStyleRef::Add( const wxCSSStyleDeclaration & style ) -->
+  <function name="wxCSSStyleRef::Add">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSPrimitiveValue::CleanUp( void ) -->
+  <function name="wxCSSPrimitiveValue::CleanUp">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- wxCSSValue * wxCSSPrimitiveValue::Clone( void ) -->
+  <function name="wxCSSPrimitiveValue::Clone">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSSValue *"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_PRIMITIVE_TYPE wxCSSPrimitiveValue::GetCSSPrimitiveType( void ) -->
+  <function name="wxCSSPrimitiveValue::GetCSSPrimitiveType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_PRIMITIVE_TYPE"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxCSSPrimitiveValue::GetCSSText( void ) const -->
+  <function name="wxCSSPrimitiveValue::GetCSSText">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- double wxCSSPrimitiveValue::GetFloatValue( wxCSS_PRIMITIVE_TYPE unitType = wxCSS_NUMBER ) const -->
+  <function name="wxCSSPrimitiveValue::GetFloatValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <const/>
+    <arg nr="1" default="wxCSS_NUMBER" direction="in"/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSPrimitiveValue::GetIdentValue( void ) const -->
+  <function name="wxCSSPrimitiveValue::GetIdentValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxRGBColor wxCSSPrimitiveValue::GetRGBColorValue( void ) const -->
+  <function name="wxCSSPrimitiveValue::GetRGBColorValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxRGBColor"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxRect wxCSSPrimitiveValue::GetRectValue( void ) const -->
+  <function name="wxCSSPrimitiveValue::GetRectValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxRect"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxString wxCSSPrimitiveValue::GetStringValue( void ) const -->
+  <function name="wxCSSPrimitiveValue::GetStringValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void wxCSSPrimitiveValue::SetCSSPrimitiveType( wxCSS_PRIMITIVE_TYPE primitiveType ) -->
+  <function name="wxCSSPrimitiveValue::SetCSSPrimitiveType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSPrimitiveValue::SetFloatValue( wxCSS_PRIMITIVE_TYPE unitType, double floatValue ) -->
+  <function name="wxCSSPrimitiveValue::SetFloatValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxCSSPrimitiveValue::SetIdentValue( wxCSS_VALUE ident ) -->
+  <function name="wxCSSPrimitiveValue::SetIdentValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSPrimitiveValue::SetRGBColorValue( const wxRGBColor & color ) -->
+  <function name="wxCSSPrimitiveValue::SetRGBColorValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSPrimitiveValue::SetRectValue( const wxRect & rect ) -->
+  <function name="wxCSSPrimitiveValue::SetRectValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSPrimitiveValue::SetStringValue( wxCSS_PRIMITIVE_TYPE stringType, const wxString & stringValue ) -->
+  <function name="wxCSSPrimitiveValue::SetStringValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxCSS_VALUE_TYPE wxCSSValue::GetCSSValueType( void ) -->
+  <function name="wxCSSValue::GetCSSValueType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE_TYPE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxCSSValue::GetValueId( wxString value ) -->
+  <function name="wxCSSValue::GetValueId">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxString wxCSSValue::GetValueString( wxCSS_VALUE value ) -->
+  <function name="wxCSSValue::GetValueString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxCSSValue::SetCSSValueType( wxCSS_VALUE_TYPE cssValueType ) -->
+  <function name="wxCSSValue::SetCSSValueType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxCSSValue * wxCSSValueList::Clone( void ) -->
+  <function name="wxCSSValueList::Clone">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSSValue *"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxCSSValueList::GetCSSText( void ) const -->
+  <function name="wxCSSValueList::GetCSSText">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- int wxCSSValueList::GetLength( void ) -->
+  <function name="wxCSSValueList::GetLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSSPrimitiveValue wxCSSValueList::Item( int index ) -->
+  <function name="wxCSSValueList::Item">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSSPrimitiveValue"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void wxCSSValueList::SetCSSText( const wxString & value ) -->
+  <function name="wxCSSValueList::SetCSSText">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int ExifHandler::getOrient( const wxString & filename ) -->
+  <function name="ExifHandler::getOrient">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void ExifHandler::rotateImage( const wxString & filename, wxImage & image ) -->
+  <function name="ExifHandler::rotateImage">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- wxSVGDocument * wxGetSVGDocument::GetSVGDocument( void ) -->
+  <function name="wxGetSVGDocument::GetSVGDocument">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDocument *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGElement * wxNodeListCls::GetElement( int i ) -->
+  <function name="wxNodeListCls::GetElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGElement *"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxSVGElement * wxNodeListCls::GetFirstElement( void ) -->
+  <function name="wxNodeListCls::GetFirstElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGElement *"/>
+    <use-retval/>
+  </function>
+  <!-- int wxNodeListCls::GetSize( void ) -->
+  <function name="wxNodeListCls::GetSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGAElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGAElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGAElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGAElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGAElement::GetAttributes( void ) const -->
+  <function name="wxSVGAElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGRect wxSVGAElement::GetBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGAElement::GetBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGAElement::GetCTM( void ) -->
+  <function name="wxSVGAElement::GetCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGAElement::GetDtd( void ) -->
+  <function name="wxSVGAElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGRect wxSVGAElement::GetResultBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGAElement::GetResultBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGAElement::GetScreenCTM( void ) -->
+  <function name="wxSVGAElement::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedString & wxSVGAElement::GetTarget( void ) -->
+  <function name="wxSVGAElement::GetTarget">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGAElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGAElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGAElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGAElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGAElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGAElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGAltGlyphDefElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGAltGlyphDefElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGAltGlyphDefElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGAltGlyphDefElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGAltGlyphDefElement::GetAttributes( void ) const -->
+  <function name="wxSVGAltGlyphDefElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGAltGlyphDefElement::GetDtd( void ) -->
+  <function name="wxSVGAltGlyphDefElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGAltGlyphDefElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGAltGlyphDefElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGAltGlyphDefElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGAltGlyphDefElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGAltGlyphElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGAltGlyphElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGAltGlyphElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGAltGlyphElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGAltGlyphElement::GetAttributes( void ) const -->
+  <function name="wxSVGAltGlyphElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGAltGlyphElement::GetDtd( void ) -->
+  <function name="wxSVGAltGlyphElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGAltGlyphElement::GetFormat( void ) -->
+  <function name="wxSVGAltGlyphElement::GetFormat">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGAltGlyphElement::GetGlyphRef( void ) -->
+  <function name="wxSVGAltGlyphElement::GetGlyphRef">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGAltGlyphElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGAltGlyphElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGAltGlyphElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGAltGlyphElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGAltGlyphElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGAltGlyphElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGAltGlyphElement::SetFormat( const wxString & n ) -->
+  <function name="wxSVGAltGlyphElement::SetFormat">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAltGlyphElement::SetGlyphRef( const wxString & n ) -->
+  <function name="wxSVGAltGlyphElement::SetGlyphRef">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGAltGlyphItemElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGAltGlyphItemElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGAltGlyphItemElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGAltGlyphItemElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGAltGlyphItemElement::GetAttributes( void ) const -->
+  <function name="wxSVGAltGlyphItemElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGAltGlyphItemElement::GetDtd( void ) -->
+  <function name="wxSVGAltGlyphItemElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGAltGlyphItemElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGAltGlyphItemElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGAltGlyphItemElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGAltGlyphItemElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGAngle::ConvertToSpecifiedUnits( wxSVG_ANGLETYPE unitType ) -->
+  <function name="wxSVGAngle::ConvertToSpecifiedUnits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSVG_ANGLETYPE wxSVGAngle::GetUnitType( void ) -->
+  <function name="wxSVGAngle::GetUnitType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVG_ANGLETYPE"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGAngle::GetValue( void ) -->
+  <function name="wxSVGAngle::GetValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSVGAngle::GetValueAsString( void ) const -->
+  <function name="wxSVGAngle::GetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- double wxSVGAngle::GetValueInSpecifiedUnits( void ) -->
+  <function name="wxSVGAngle::GetValueInSpecifiedUnits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGAngle::NewValueSpecifiedUnits( wxSVG_ANGLETYPE unitType, double valueInSpecifiedUnits ) -->
+  <function name="wxSVGAngle::NewValueSpecifiedUnits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGAngle::SetUnitType( const wxSVG_ANGLETYPE & n ) -->
+  <function name="wxSVGAngle::SetUnitType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAngle::SetValue( double n ) -->
+  <function name="wxSVGAngle::SetValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGAngle::SetValueAsString( const wxString & n ) -->
+  <function name="wxSVGAngle::SetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAngle::SetValueInSpecifiedUnits( double n ) -->
+  <function name="wxSVGAngle::SetValueInSpecifiedUnits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGAnimateColorElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGAnimateColorElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGAnimateColorElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGAnimateColorElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGAnimateColorElement::GetAttributes( void ) const -->
+  <function name="wxSVGAnimateColorElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGAnimateColorElement::GetDtd( void ) -->
+  <function name="wxSVGAnimateColorElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGAnimateColorElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGAnimateColorElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGAnimateColorElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGAnimateColorElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGAnimateElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGAnimateElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGAnimateElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGAnimateElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGAnimateElement::GetAttributes( void ) const -->
+  <function name="wxSVGAnimateElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGAnimateElement::GetDtd( void ) -->
+  <function name="wxSVGAnimateElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGAnimateElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGAnimateElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGAnimateElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGAnimateElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimateMotionElement::ApplyAnimation( void ) -->
+  <function name="wxSVGAnimateMotionElement::ApplyAnimation">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGAnimateMotionElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGAnimateMotionElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGAnimateMotionElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGAnimateMotionElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGAnimateMotionElement::GetAttributes( void ) const -->
+  <function name="wxSVGAnimateMotionElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGAnimateMotionElement::GetDtd( void ) -->
+  <function name="wxSVGAnimateMotionElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGAnimateMotionElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGAnimateMotionElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGAnimateMotionElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGAnimateMotionElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimateTransformElement::ApplyAnimation( void ) -->
+  <function name="wxSVGAnimateTransformElement::ApplyAnimation">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGAnimateTransformElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGAnimateTransformElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGAnimateTransformElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGAnimateTransformElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGAnimateTransformElement::GetAttributes( void ) const -->
+  <function name="wxSVGAnimateTransformElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGAnimateTransformElement::GetDtd( void ) -->
+  <function name="wxSVGAnimateTransformElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVG_ANIMATETRANSFORM wxSVGAnimateTransformElement::GetType( void ) -->
+  <function name="wxSVGAnimateTransformElement::GetType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVG_ANIMATETRANSFORM"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGAnimateTransformElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGAnimateTransformElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGAnimateTransformElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGAnimateTransformElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimateTransformElement::SetType( const wxSVG_ANIMATETRANSFORM & n ) -->
+  <function name="wxSVGAnimateTransformElement::SetType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSVGAngle & wxSVGAnimatedAngle::GetAnimVal( void ) -->
+  <function name="wxSVGAnimatedAngle::GetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGAngle &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAngle & wxSVGAnimatedAngle::GetAnimVal( void ) -->
+  <function name="wxSVGAnimatedAngle::GetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAngle &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGAngle & wxSVGAnimatedAngle::GetBaseVal( void ) -->
+  <function name="wxSVGAnimatedAngle::GetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGAngle &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAngle & wxSVGAnimatedAngle::GetBaseVal( void ) -->
+  <function name="wxSVGAnimatedAngle::GetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAngle &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGAnimatedAngle::ResetAnimVal( void ) -->
+  <function name="wxSVGAnimatedAngle::ResetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxSVGAnimatedAngle::SetAnimVal( const wxSVGAngle & value ) -->
+  <function name="wxSVGAnimatedAngle::SetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimatedAngle::SetBaseVal( const wxSVGAngle & value ) -->
+  <function name="wxSVGAnimatedAngle::SetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGAnimatedBoolean::GetAnimVal( void ) -->
+  <function name="wxSVGAnimatedBoolean::GetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGAnimatedBoolean::GetBaseVal( void ) -->
+  <function name="wxSVGAnimatedBoolean::GetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGAnimatedBoolean::SetAnimVal( bool value ) -->
+  <function name="wxSVGAnimatedBoolean::SetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSVGAnimatedBoolean::SetBaseVal( bool value ) -->
+  <function name="wxSVGAnimatedBoolean::SetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- unsigned char wxSVGAnimatedEnumeration::GetAnimVal( void ) -->
+  <function name="wxSVGAnimatedEnumeration::GetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned char"/>
+    <use-retval/>
+  </function>
+  <!-- unsigned char wxSVGAnimatedEnumeration::GetBaseVal( void ) -->
+  <function name="wxSVGAnimatedEnumeration::GetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned char"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGAnimatedEnumeration::SetAnimVal( unsigned char value ) -->
+  <function name="wxSVGAnimatedEnumeration::SetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void wxSVGAnimatedEnumeration::SetBaseVal( unsigned char value ) -->
+  <function name="wxSVGAnimatedEnumeration::SetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long wxSVGAnimatedInteger::GetAnimVal( void ) -->
+  <function name="wxSVGAnimatedInteger::GetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- long wxSVGAnimatedInteger::GetBaseVal( void ) -->
+  <function name="wxSVGAnimatedInteger::GetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGAnimatedInteger::SetAnimVal( long value ) -->
+  <function name="wxSVGAnimatedInteger::SetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void wxSVGAnimatedInteger::SetBaseVal( long value ) -->
+  <function name="wxSVGAnimatedInteger::SetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxSVGLength & wxSVGAnimatedLength::GetAnimVal( void ) -->
+  <function name="wxSVGAnimatedLength::GetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGLength & wxSVGAnimatedLength::GetAnimVal( void ) -->
+  <function name="wxSVGAnimatedLength::GetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGLength & wxSVGAnimatedLength::GetBaseVal( void ) -->
+  <function name="wxSVGAnimatedLength::GetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGLength & wxSVGAnimatedLength::GetBaseVal( void ) -->
+  <function name="wxSVGAnimatedLength::GetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGAnimatedLength::ResetAnimVal( void ) -->
+  <function name="wxSVGAnimatedLength::ResetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxSVGAnimatedLength::SetAnimVal( const wxSVGLength & value ) -->
+  <function name="wxSVGAnimatedLength::SetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimatedLength::SetBaseVal( const wxSVGLength & value ) -->
+  <function name="wxSVGAnimatedLength::SetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSVGLengthList & wxSVGAnimatedLengthList::GetAnimVal( void ) -->
+  <function name="wxSVGAnimatedLengthList::GetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGLengthList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGLengthList & wxSVGAnimatedLengthList::GetAnimVal( void ) -->
+  <function name="wxSVGAnimatedLengthList::GetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGLengthList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGLengthList & wxSVGAnimatedLengthList::GetBaseVal( void ) -->
+  <function name="wxSVGAnimatedLengthList::GetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGLengthList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGLengthList & wxSVGAnimatedLengthList::GetBaseVal( void ) -->
+  <function name="wxSVGAnimatedLengthList::GetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGLengthList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGAnimatedLengthList::ResetAnimVal( void ) -->
+  <function name="wxSVGAnimatedLengthList::ResetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxSVGAnimatedLengthList::SetAnimVal( const wxSVGLengthList & value ) -->
+  <function name="wxSVGAnimatedLengthList::SetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimatedLengthList::SetBaseVal( const wxSVGLengthList & value ) -->
+  <function name="wxSVGAnimatedLengthList::SetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- float wxSVGAnimatedNumber::GetAnimVal( void ) -->
+  <function name="wxSVGAnimatedNumber::GetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <use-retval/>
+  </function>
+  <!-- float wxSVGAnimatedNumber::GetBaseVal( void ) -->
+  <function name="wxSVGAnimatedNumber::GetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGAnimatedNumber::SetAnimVal( float value ) -->
+  <function name="wxSVGAnimatedNumber::SetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-3.402823e+38:3.402823e+38</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGAnimatedNumber::SetBaseVal( float value ) -->
+  <function name="wxSVGAnimatedNumber::SetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-3.402823e+38:3.402823e+38</valid>
+    </arg>
+  </function>
+  <!-- wxSVGNumberList & wxSVGAnimatedNumberList::GetAnimVal( void ) -->
+  <function name="wxSVGAnimatedNumberList::GetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGNumberList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGNumberList & wxSVGAnimatedNumberList::GetAnimVal( void ) -->
+  <function name="wxSVGAnimatedNumberList::GetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGNumberList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGNumberList & wxSVGAnimatedNumberList::GetBaseVal( void ) -->
+  <function name="wxSVGAnimatedNumberList::GetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGNumberList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGNumberList & wxSVGAnimatedNumberList::GetBaseVal( void ) -->
+  <function name="wxSVGAnimatedNumberList::GetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGNumberList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGAnimatedNumberList::ResetAnimVal( void ) -->
+  <function name="wxSVGAnimatedNumberList::ResetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxSVGAnimatedNumberList::SetAnimVal( const wxSVGNumberList & value ) -->
+  <function name="wxSVGAnimatedNumberList::SetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimatedNumberList::SetBaseVal( const wxSVGNumberList & value ) -->
+  <function name="wxSVGAnimatedNumberList::SetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const wxSVGPathSegList & wxSVGAnimatedPathData::GetAnimatedNormalizedPathSegList( void ) -->
+  <function name="wxSVGAnimatedPathData::GetAnimatedNormalizedPathSegList">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGPathSegList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGPathSegList & wxSVGAnimatedPathData::GetAnimatedPathSegList( void ) -->
+  <function name="wxSVGAnimatedPathData::GetAnimatedPathSegList">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGPathSegList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSVGAnimatedPathData::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGAnimatedPathData::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGAnimatedPathData::GetAttributes( void ) const -->
+  <function name="wxSVGAnimatedPathData::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxSVGPathSegList & wxSVGAnimatedPathData::GetNormalizedPathSegList( void ) -->
+  <function name="wxSVGAnimatedPathData::GetNormalizedPathSegList">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGPathSegList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGPathSegList & wxSVGAnimatedPathData::GetPathSegList( void ) -->
+  <function name="wxSVGAnimatedPathData::GetPathSegList">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGPathSegList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGAnimatedPathData::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGAnimatedPathData::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimatedPathData::SetAnimatedNormalizedPathSegList( const wxSVGPathSegList & n ) -->
+  <function name="wxSVGAnimatedPathData::SetAnimatedNormalizedPathSegList">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimatedPathData::SetAnimatedPathSegList( const wxSVGPathSegList & n ) -->
+  <function name="wxSVGAnimatedPathData::SetAnimatedPathSegList">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGAnimatedPathData::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGAnimatedPathData::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimatedPathData::SetNormalizedPathSegList( const wxSVGPathSegList & n ) -->
+  <function name="wxSVGAnimatedPathData::SetNormalizedPathSegList">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimatedPathData::SetPathSegList( const wxSVGPathSegList & n ) -->
+  <function name="wxSVGAnimatedPathData::SetPathSegList">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const wxSVGPointList & wxSVGAnimatedPoints::GetAnimatedPoints( void ) -->
+  <function name="wxSVGAnimatedPoints::GetAnimatedPoints">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGPointList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSVGAnimatedPoints::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGAnimatedPoints::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGAnimatedPoints::GetAttributes( void ) const -->
+  <function name="wxSVGAnimatedPoints::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxSVGPointList & wxSVGAnimatedPoints::GetPoints( void ) -->
+  <function name="wxSVGAnimatedPoints::GetPoints">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGPointList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGAnimatedPoints::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGAnimatedPoints::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimatedPoints::SetAnimatedPoints( const wxSVGPointList & n ) -->
+  <function name="wxSVGAnimatedPoints::SetAnimatedPoints">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGAnimatedPoints::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGAnimatedPoints::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimatedPoints::SetPoints( const wxSVGPointList & n ) -->
+  <function name="wxSVGAnimatedPoints::SetPoints">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSVGPreserveAspectRatio & wxSVGAnimatedPreserveAspectRatio::GetAnimVal( void ) -->
+  <function name="wxSVGAnimatedPreserveAspectRatio::GetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPreserveAspectRatio &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGPreserveAspectRatio & wxSVGAnimatedPreserveAspectRatio::GetAnimVal( void ) -->
+  <function name="wxSVGAnimatedPreserveAspectRatio::GetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGPreserveAspectRatio &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGPreserveAspectRatio & wxSVGAnimatedPreserveAspectRatio::GetBaseVal( void ) -->
+  <function name="wxSVGAnimatedPreserveAspectRatio::GetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPreserveAspectRatio &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGPreserveAspectRatio & wxSVGAnimatedPreserveAspectRatio::GetBaseVal( void ) -->
+  <function name="wxSVGAnimatedPreserveAspectRatio::GetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGPreserveAspectRatio &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGAnimatedPreserveAspectRatio::ResetAnimVal( void ) -->
+  <function name="wxSVGAnimatedPreserveAspectRatio::ResetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxSVGAnimatedPreserveAspectRatio::SetAnimVal( const wxSVGPreserveAspectRatio & value ) -->
+  <function name="wxSVGAnimatedPreserveAspectRatio::SetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimatedPreserveAspectRatio::SetBaseVal( const wxSVGPreserveAspectRatio & value ) -->
+  <function name="wxSVGAnimatedPreserveAspectRatio::SetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSVGRect & wxSVGAnimatedRect::GetAnimVal( void ) -->
+  <function name="wxSVGAnimatedRect::GetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGRect & wxSVGAnimatedRect::GetAnimVal( void ) -->
+  <function name="wxSVGAnimatedRect::GetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGRect &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGRect & wxSVGAnimatedRect::GetBaseVal( void ) -->
+  <function name="wxSVGAnimatedRect::GetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGRect & wxSVGAnimatedRect::GetBaseVal( void ) -->
+  <function name="wxSVGAnimatedRect::GetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGRect &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGAnimatedRect::ResetAnimVal( void ) -->
+  <function name="wxSVGAnimatedRect::ResetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxSVGAnimatedRect::SetAnimVal( const wxSVGRect & value ) -->
+  <function name="wxSVGAnimatedRect::SetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimatedRect::SetBaseVal( const wxSVGRect & value ) -->
+  <function name="wxSVGAnimatedRect::SetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxString & wxSVGAnimatedString::GetAnimVal( void ) -->
+  <function name="wxSVGAnimatedString::GetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGAnimatedString::GetAnimVal( void ) -->
+  <function name="wxSVGAnimatedString::GetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxString & wxSVGAnimatedString::GetBaseVal( void ) -->
+  <function name="wxSVGAnimatedString::GetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGAnimatedString::GetBaseVal( void ) -->
+  <function name="wxSVGAnimatedString::GetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGAnimatedString::ResetAnimVal( void ) -->
+  <function name="wxSVGAnimatedString::ResetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxSVGAnimatedString::SetAnimVal( const wxString & value ) -->
+  <function name="wxSVGAnimatedString::SetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimatedString::SetBaseVal( const wxString & value ) -->
+  <function name="wxSVGAnimatedString::SetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSVGTransformList & wxSVGAnimatedTransformList::GetAnimVal( void ) -->
+  <function name="wxSVGAnimatedTransformList::GetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGTransformList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGTransformList & wxSVGAnimatedTransformList::GetAnimVal( void ) -->
+  <function name="wxSVGAnimatedTransformList::GetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGTransformList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGTransformList & wxSVGAnimatedTransformList::GetBaseVal( void ) -->
+  <function name="wxSVGAnimatedTransformList::GetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGTransformList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGTransformList & wxSVGAnimatedTransformList::GetBaseVal( void ) -->
+  <function name="wxSVGAnimatedTransformList::GetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGTransformList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGAnimatedTransformList::ResetAnimVal( void ) -->
+  <function name="wxSVGAnimatedTransformList::ResetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxSVGAnimatedTransformList::SetAnimVal( const wxSVGTransformList & value ) -->
+  <function name="wxSVGAnimatedTransformList::SetAnimVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimatedTransformList::SetBaseVal( const wxSVGTransformList & value ) -->
+  <function name="wxSVGAnimatedTransformList::SetBaseVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const wxRGBColor & wxSVGAnimatedType::GetColor( void ) -->
+  <function name="wxSVGAnimatedType::GetColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxRGBColor &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGLength & wxSVGAnimatedType::GetLength( void ) -->
+  <function name="wxSVGAnimatedType::GetLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGLengthList & wxSVGAnimatedType::GetLengthList( void ) -->
+  <function name="wxSVGAnimatedType::GetLengthList">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGLengthList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGNumberList & wxSVGAnimatedType::GetNumberList( void ) -->
+  <function name="wxSVGAnimatedType::GetNumberList">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGNumberList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVG_ANIMATED_PROPERTY_TYPE wxSVGAnimatedType::GetPropertyType( void ) -->
+  <function name="wxSVGAnimatedType::GetPropertyType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVG_ANIMATED_PROPERTY_TYPE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGAnimatedType::GetString( void ) -->
+  <function name="wxSVGAnimatedType::GetString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGTransformList & wxSVGAnimatedType::GetTransformList( void ) -->
+  <function name="wxSVGAnimatedType::GetTransformList">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGTransformList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSVGAnimatedType::GetValueAsString( void ) const -->
+  <function name="wxSVGAnimatedType::GetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void wxSVGAnimatedType::SetValueAsString( const wxString & value ) -->
+  <function name="wxSVGAnimatedType::SetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimationElement::ApplyAnimation( void ) -->
+  <function name="wxSVGAnimationElement::ApplyAnimation">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- wxSVG_ANIMATION_ACCUMULATE wxSVGAnimationElement::GetAccumulate( void ) -->
+  <function name="wxSVGAnimationElement::GetAccumulate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVG_ANIMATION_ACCUMULATE"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVG_ANIMATION_ADDITIVE wxSVGAnimationElement::GetAdditive( void ) -->
+  <function name="wxSVGAnimationElement::GetAdditive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVG_ANIMATION_ADDITIVE"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSVGAnimationElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGAnimationElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const wxString & wxSVGAnimationElement::GetAttributeName( void ) -->
+  <function name="wxSVGAnimationElement::GetAttributeName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGAnimationElement::GetAttributes( void ) const -->
+  <function name="wxSVGAnimationElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- double wxSVGAnimationElement::GetBegin( void ) -->
+  <function name="wxSVGAnimationElement::GetBegin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGAnimationElement::GetCurrentTime( void ) -->
+  <function name="wxSVGAnimationElement::GetCurrentTime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSVGAnimationElement::GetCustomAttribute( const wxString & name ) const -->
+  <function name="wxSVGAnimationElement::GetCustomAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGAnimationElement::GetCustomAttributes( void ) const -->
+  <function name="wxSVGAnimationElement::GetCustomAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- double wxSVGAnimationElement::GetDur( void ) -->
+  <function name="wxSVGAnimationElement::GetDur">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVG_ANIMATION_FILL wxSVGAnimationElement::GetFill( void ) -->
+  <function name="wxSVGAnimationElement::GetFill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVG_ANIMATION_FILL"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedType & wxSVGAnimationElement::GetFrom( void ) -->
+  <function name="wxSVGAnimationElement::GetFrom">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedType &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGAnimationElement::GetHref( void ) -->
+  <function name="wxSVGAnimationElement::GetHref">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGAnimationElement::GetSimpleDuration( void ) -->
+  <function name="wxSVGAnimationElement::GetSimpleDuration">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGAnimationElement::GetStartTime( void ) -->
+  <function name="wxSVGAnimationElement::GetStartTime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGElement * wxSVGAnimationElement::GetTargetElement( void ) const -->
+  <function name="wxSVGAnimationElement::GetTargetElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGElement *"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxSVGAnimatedType & wxSVGAnimationElement::GetTo( void ) -->
+  <function name="wxSVGAnimationElement::GetTo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedType &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGAnimationElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGAnimationElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGAnimationElement::HasCustomAttribute( const wxString & name ) const -->
+  <function name="wxSVGAnimationElement::HasCustomAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimationElement::SetAccumulate( const wxSVG_ANIMATION_ACCUMULATE & n ) -->
+  <function name="wxSVGAnimationElement::SetAccumulate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimationElement::SetAdditive( const wxSVG_ANIMATION_ADDITIVE & n ) -->
+  <function name="wxSVGAnimationElement::SetAdditive">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGAnimationElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGAnimationElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimationElement::SetAttributeName( const wxString & n ) -->
+  <function name="wxSVGAnimationElement::SetAttributeName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimationElement::SetBegin( double n ) -->
+  <function name="wxSVGAnimationElement::SetBegin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- bool wxSVGAnimationElement::SetCustomAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGAnimationElement::SetCustomAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimationElement::SetDur( double n ) -->
+  <function name="wxSVGAnimationElement::SetDur">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGAnimationElement::SetFill( const wxSVG_ANIMATION_FILL & n ) -->
+  <function name="wxSVGAnimationElement::SetFill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimationElement::SetFrom( const wxSVGAnimatedType & n ) -->
+  <function name="wxSVGAnimationElement::SetFrom">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimationElement::SetHref( const wxString & n ) -->
+  <function name="wxSVGAnimationElement::SetHref">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGAnimationElement::SetTo( const wxSVGAnimatedType & n ) -->
+  <function name="wxSVGAnimationElement::SetTo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGCanvas::DrawCircle( wxSVGCircleElement * element, wxSVGMatrix * matrix, const wxCSSStyleDeclaration * style = NULL ) -->
+  <function name="wxSVGCanvas::DrawCircle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" default="NULL" direction="inout"/>
+  </function>
+  <!-- void wxSVGCanvas::DrawEllipse( wxSVGEllipseElement * element, wxSVGMatrix * matrix, const wxCSSStyleDeclaration * style = NULL ) -->
+  <function name="wxSVGCanvas::DrawEllipse">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" default="NULL" direction="inout"/>
+  </function>
+  <!-- void wxSVGCanvas::DrawLine( wxSVGLineElement * element, wxSVGMatrix * matrix, const wxCSSStyleDeclaration * style = NULL ) -->
+  <function name="wxSVGCanvas::DrawLine">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" default="NULL" direction="inout"/>
+  </function>
+  <!-- void wxSVGCanvas::DrawPath( wxSVGPathElement * element, wxSVGMatrix * matrix, const wxCSSStyleDeclaration * style = NULL ) -->
+  <function name="wxSVGCanvas::DrawPath">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" default="NULL" direction="inout"/>
+  </function>
+  <!-- void wxSVGCanvas::DrawPolygon( wxSVGPolygonElement * element, wxSVGMatrix * matrix, const wxCSSStyleDeclaration * style = NULL ) -->
+  <function name="wxSVGCanvas::DrawPolygon">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" default="NULL" direction="inout"/>
+  </function>
+  <!-- void wxSVGCanvas::DrawPolyline( wxSVGPolylineElement * element, wxSVGMatrix * matrix, const wxCSSStyleDeclaration * style = NULL ) -->
+  <function name="wxSVGCanvas::DrawPolyline">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" default="NULL" direction="inout"/>
+  </function>
+  <!-- void wxSVGCanvas::DrawRect( wxSVGRectElement * element, wxSVGMatrix * matrix, const wxCSSStyleDeclaration * style = NULL ) -->
+  <function name="wxSVGCanvas::DrawRect">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" default="NULL" direction="inout"/>
+  </function>
+  <!-- void wxSVGCanvas::DrawText( wxSVGTextElement * element, wxSVGMatrix * matrix, const wxCSSStyleDeclaration * style = NULL ) -->
+  <function name="wxSVGCanvas::DrawText">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" default="NULL" direction="inout"/>
+  </function>
+  <!-- void wxSVGCanvas::EnableItemsCache( bool enable = true ) -->
+  <function name="wxSVGCanvas::EnableItemsCache">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxSVGGradientElement * wxSVGCanvas::GetGradientElement( const wxSVGSVGElement & svgElem, const wxString & href ) -->
+  <function name="wxSVGCanvas::GetGradientElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGGradientElement *"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- unsigned int wxSVGCanvas::GetGradientStops( const wxSVGSVGElement & svgElem, wxSVGGradientElement * gradElem, float opacity ) -->
+  <function name="wxSVGCanvas::GetGradientStops">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned int"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-3.402823e+38:3.402823e+38</valid>
+    </arg>
+  </function>
+  <!-- wxSVGMarkerElement * wxSVGCanvas::GetMarkerElement( const wxSVGSVGElement & svgElem, const wxString & href ) -->
+  <function name="wxSVGCanvas::GetMarkerElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMarkerElement *"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSVGPatternElement * wxSVGCanvas::GetPatternElement( const wxSVGSVGElement & svgElem, wxString href ) -->
+  <function name="wxSVGCanvas::GetPatternElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPatternElement *"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGCanvas::IsItemsCached( void ) -->
+  <function name="wxSVGCanvas::IsItemsCached">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGCanvas::LoadImages( wxSVGElement * parent1, wxSVGElement * parent2, wxProgressDialog * progressDlg ) -->
+  <function name="wxSVGCanvas::LoadImages">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- int wxSVGCanvasImage::GetDefaultHeight( void ) -->
+  <function name="wxSVGCanvasImage::GetDefaultHeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- int wxSVGCanvasImage::GetDefaultWidth( void ) -->
+  <function name="wxSVGCanvasImage::GetDefaultWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGPreserveAspectRatio & wxSVGCanvasImage::GetPreserveAspectRatio( void ) -->
+  <function name="wxSVGCanvasImage::GetPreserveAspectRatio">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGPreserveAspectRatio &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGSVGElement * wxSVGCanvasImage::GetSvgImage( wxSVGDocument * doc = NULL ) -->
+  <function name="wxSVGCanvasImage::GetSvgImage">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGSVGElement *"/>
+    <arg nr="1" default="NULL" direction="inout"/>
+  </function>
+  <!-- void wxSVGCanvasImage::Init( wxSVGImageElement & element, const wxCSSStyleDeclaration & style, wxProgressDialog * progressDlg ) -->
+  <function name="wxSVGCanvasImage::Init">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- wxSVGRect wxSVGCanvasItem::GetBBox( const wxSVGMatrix * matrix = NULL ) -->
+  <function name="wxSVGCanvasItem::GetBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="NULL" direction="inout"/>
+  </function>
+  <!-- wxSVGCanvasItemType wxSVGCanvasItem::GetType( void ) -->
+  <function name="wxSVGCanvasItem::GetType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGCanvasItemType"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGCanvasPath::ClosePath( void ) -->
+  <function name="wxSVGCanvasPath::ClosePath">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGCanvasPath::CurveToCubic( double x1, double y1, double x2, double y2, double x, double y, bool relative = false ) -->
+  <function name="wxSVGCanvasPath::CurveToCubic">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="7" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSVGCanvasPath::CurveToCubicSmooth( double x2, double y2, double x, double y, bool relative = false ) -->
+  <function name="wxSVGCanvasPath::CurveToCubicSmooth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="5" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSVGCanvasPath::CurveToQuadratic( double x1, double y1, double x, double y, bool relative = false ) -->
+  <function name="wxSVGCanvasPath::CurveToQuadratic">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="5" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSVGCanvasPath::CurveToQuadraticSmooth( double x, double y, bool relative = false ) -->
+  <function name="wxSVGCanvasPath::CurveToQuadraticSmooth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="3" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool wxSVGCanvasPath::GetFill( void ) -->
+  <function name="wxSVGCanvasPath::GetFill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGCanvasPath::LineTo( double x, double y, bool relative = false ) -->
+  <function name="wxSVGCanvasPath::LineTo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="3" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSVGCanvasPath::LineToHorizontal( double x, bool relative = false ) -->
+  <function name="wxSVGCanvasPath::LineToHorizontal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSVGCanvasPath::LineToVertical( double y, bool relative = false ) -->
+  <function name="wxSVGCanvasPath::LineToVertical">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSVGCanvasPath::MoveTo( double x, double y, bool relative = false ) -->
+  <function name="wxSVGCanvasPath::MoveTo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="3" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSVGCanvasPath::SetFill( bool fill = true ) -->
+  <function name="wxSVGCanvasPath::SetFill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int wxSVGCanvasSvgImageData::DecRef( void ) -->
+  <function name="wxSVGCanvasSvgImageData::DecRef">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGSVGElement * wxSVGCanvasSvgImageData::GetSvgImage( void ) -->
+  <function name="wxSVGCanvasSvgImageData::GetSvgImage">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGSVGElement *"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGCanvasSvgImageData::IncRef( void ) -->
+  <function name="wxSVGCanvasSvgImageData::IncRef">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxSVGCanvasText::AddChunk( const wxString & text, const wxCSSStyleDeclaration & style, wxSVGMatrix * matrix ) -->
+  <function name="wxSVGCanvasText::AddChunk">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- void wxSVGCanvasText::BeginChar( wxSVGMatrix * matrix ) -->
+  <function name="wxSVGCanvasText::BeginChar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSVGCanvasText::EndChar( void ) -->
+  <function name="wxSVGCanvasText::EndChar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxSVGCanvasText::EndTextAnchor( void ) -->
+  <function name="wxSVGCanvasText::EndTextAnchor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- wxSVGRect wxSVGCanvasText::GetBBox( const wxSVGMatrix * matrix = NULL ) -->
+  <function name="wxSVGCanvasText::GetBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="NULL" direction="inout"/>
+  </function>
+  <!-- long wxSVGCanvasText::GetCharNumAtPosition( const wxSVGPoint & point ) -->
+  <function name="wxSVGCanvasText::GetCharNumAtPosition">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSVGCanvasTextChunk * wxSVGCanvasText::GetChunk( unsigned long & charnum ) -->
+  <function name="wxSVGCanvasText::GetChunk">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGCanvasTextChunk *"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- double wxSVGCanvasText::GetComputedTextLength( void ) -->
+  <function name="wxSVGCanvasText::GetComputedTextLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGPoint wxSVGCanvasText::GetEndPositionOfChar( unsigned long charnum ) -->
+  <function name="wxSVGCanvasText::GetEndPositionOfChar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPoint"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxSVGRect wxSVGCanvasText::GetExtentOfChar( unsigned long charnum ) -->
+  <function name="wxSVGCanvasText::GetExtentOfChar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long wxSVGCanvasText::GetNumberOfChars( void ) -->
+  <function name="wxSVGCanvasText::GetNumberOfChars">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGCanvasText::GetRotationOfChar( unsigned long charnum ) -->
+  <function name="wxSVGCanvasText::GetRotationOfChar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxSVGPoint wxSVGCanvasText::GetStartPositionOfChar( unsigned long charnum ) -->
+  <function name="wxSVGCanvasText::GetStartPositionOfChar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPoint"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- double wxSVGCanvasText::GetSubStringLength( unsigned long charnum, unsigned long nchars ) -->
+  <function name="wxSVGCanvasText::GetSubStringLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- double wxSVGCanvasVideo::GetDuration( void ) -->
+  <function name="wxSVGCanvasVideo::GetDuration">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGCanvasVideo::Init( wxSVGVideoElement & element, const wxCSSStyleDeclaration & style, wxProgressDialog * progressDlg ) -->
+  <function name="wxSVGCanvasVideo::Init">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- int wxSVGCanvasVideoData::DecRef( void ) -->
+  <function name="wxSVGCanvasVideoData::DecRef">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+  </function>
+  <!-- wxImage wxSVGCanvasVideoData::GetImage( double time ) -->
+  <function name="wxSVGCanvasVideoData::GetImage">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxImage"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxFfmpegMediaDecoder * wxSVGCanvasVideoData::GetMediaDecoder( void ) -->
+  <function name="wxSVGCanvasVideoData::GetMediaDecoder">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxFfmpegMediaDecoder *"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGCanvasVideoData::IncRef( void ) -->
+  <function name="wxSVGCanvasVideoData::IncRef">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGCircleElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGCircleElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGCircleElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGCircleElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGCircleElement::GetAttributes( void ) const -->
+  <function name="wxSVGCircleElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGRect wxSVGCircleElement::GetBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGCircleElement::GetBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGCircleElement::GetCTM( void ) -->
+  <function name="wxSVGCircleElement::GetCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGCanvasItem * wxSVGCircleElement::GetCanvasItem( void ) -->
+  <function name="wxSVGCircleElement::GetCanvasItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGCanvasItem *"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGCircleElement::GetCx( void ) -->
+  <function name="wxSVGCircleElement::GetCx">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGCircleElement::GetCy( void ) -->
+  <function name="wxSVGCircleElement::GetCy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGCircleElement::GetDtd( void ) -->
+  <function name="wxSVGCircleElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGCircleElement::GetR( void ) -->
+  <function name="wxSVGCircleElement::GetR">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGRect wxSVGCircleElement::GetResultBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGCircleElement::GetResultBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGCircleElement::GetScreenCTM( void ) -->
+  <function name="wxSVGCircleElement::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGCircleElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGCircleElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGCircleElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGCircleElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGCircleElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGCircleElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGCircleElement::SetCanvasItem( wxSVGCanvasItem * canvasItem ) -->
+  <function name="wxSVGCircleElement::SetCanvasItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGClipPathElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGClipPathElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGClipPathElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGClipPathElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGClipPathElement::GetAttributes( void ) const -->
+  <function name="wxSVGClipPathElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGRect wxSVGClipPathElement::GetBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGClipPathElement::GetBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGClipPathElement::GetCTM( void ) -->
+  <function name="wxSVGClipPathElement::GetCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGClipPathElement::GetClipPathUnits( void ) -->
+  <function name="wxSVGClipPathElement::GetClipPathUnits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGClipPathElement::GetDtd( void ) -->
+  <function name="wxSVGClipPathElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGRect wxSVGClipPathElement::GetResultBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGClipPathElement::GetResultBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGClipPathElement::GetScreenCTM( void ) -->
+  <function name="wxSVGClipPathElement::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGClipPathElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGClipPathElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGClipPathElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGClipPathElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGClipPathElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGClipPathElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxCSSValue * wxSVGColor::Clone( void ) -->
+  <function name="wxSVGColor::Clone">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSSValue *"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSVGColor::GetCSSText( void ) const -->
+  <function name="wxSVGColor::GetCSSText">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVG_COLORTYPE wxSVGColor::GetColorType( void ) -->
+  <function name="wxSVGColor::GetColorType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVG_COLORTYPE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGICCColor & wxSVGColor::GetICCColor( void ) -->
+  <function name="wxSVGColor::GetICCColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGICCColor &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxRGBColor & wxSVGColor::GetRGBColor( void ) -->
+  <function name="wxSVGColor::GetRGBColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxRGBColor &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGColor::SetColor( wxSVG_COLORTYPE colorType, const wxString & rgbColor, const wxString & iccColor ) -->
+  <function name="wxSVGColor::SetColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void wxSVGColor::SetColorType( const wxSVG_COLORTYPE & n ) -->
+  <function name="wxSVGColor::SetColorType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGColor::SetICCColor( const wxSVGICCColor & iccColor ) -->
+  <function name="wxSVGColor::SetICCColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGColor::SetRGBColorICCColor( const wxString & rgbColor, const wxString & iccColor ) -->
+  <function name="wxSVGColor::SetRGBColorICCColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGColorProfileElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGColorProfileElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGColorProfileElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGColorProfileElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGColorProfileElement::GetAttributes( void ) const -->
+  <function name="wxSVGColorProfileElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGColorProfileElement::GetDtd( void ) -->
+  <function name="wxSVGColorProfileElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGColorProfileElement::GetLocal( void ) -->
+  <function name="wxSVGColorProfileElement::GetLocal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGColorProfileElement::GetName( void ) -->
+  <function name="wxSVGColorProfileElement::GetName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxRENDERING_INTENT wxSVGColorProfileElement::GetRenderingIntent( void ) -->
+  <function name="wxSVGColorProfileElement::GetRenderingIntent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxRENDERING_INTENT"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGColorProfileElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGColorProfileElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGColorProfileElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGColorProfileElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGColorProfileElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGColorProfileElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGColorProfileElement::SetLocal( const wxString & n ) -->
+  <function name="wxSVGColorProfileElement::SetLocal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGColorProfileElement::SetName( const wxString & n ) -->
+  <function name="wxSVGColorProfileElement::SetName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGColorProfileElement::SetRenderingIntent( const wxRENDERING_INTENT & n ) -->
+  <function name="wxSVGColorProfileElement::SetRenderingIntent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const wxString & wxSVGColorProfileRule::GetName( void ) -->
+  <function name="wxSVGColorProfileRule::GetName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxRENDERING_INTENT wxSVGColorProfileRule::GetRenderingIntent( void ) -->
+  <function name="wxSVGColorProfileRule::GetRenderingIntent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxRENDERING_INTENT"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGColorProfileRule::GetSrc( void ) -->
+  <function name="wxSVGColorProfileRule::GetSrc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGColorProfileRule::SetName( const wxString & n ) -->
+  <function name="wxSVGColorProfileRule::SetName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGColorProfileRule::SetRenderingIntent( const wxRENDERING_INTENT & n ) -->
+  <function name="wxSVGColorProfileRule::SetRenderingIntent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGColorProfileRule::SetSrc( const wxString & n ) -->
+  <function name="wxSVGColorProfileRule::SetSrc">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGComponentTransferFunctionElement::GetAmplitude( void ) -->
+  <function name="wxSVGComponentTransferFunctionElement::GetAmplitude">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSVGComponentTransferFunctionElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGComponentTransferFunctionElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGComponentTransferFunctionElement::GetAttributes( void ) const -->
+  <function name="wxSVGComponentTransferFunctionElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGComponentTransferFunctionElement::GetExponent( void ) -->
+  <function name="wxSVGComponentTransferFunctionElement::GetExponent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGComponentTransferFunctionElement::GetIntercept( void ) -->
+  <function name="wxSVGComponentTransferFunctionElement::GetIntercept">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGComponentTransferFunctionElement::GetOffset( void ) -->
+  <function name="wxSVGComponentTransferFunctionElement::GetOffset">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGComponentTransferFunctionElement::GetSlope( void ) -->
+  <function name="wxSVGComponentTransferFunctionElement::GetSlope">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumberList & wxSVGComponentTransferFunctionElement::GetTableValues( void ) -->
+  <function name="wxSVGComponentTransferFunctionElement::GetTableValues">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumberList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGComponentTransferFunctionElement::GetType( void ) -->
+  <function name="wxSVGComponentTransferFunctionElement::GetType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGComponentTransferFunctionElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGComponentTransferFunctionElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGComponentTransferFunctionElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGComponentTransferFunctionElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGComponentTransferFunctionElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGComponentTransferFunctionElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGCursorElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGCursorElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGCursorElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGCursorElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGCursorElement::GetAttributes( void ) const -->
+  <function name="wxSVGCursorElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGCursorElement::GetDtd( void ) -->
+  <function name="wxSVGCursorElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGCursorElement::GetX( void ) -->
+  <function name="wxSVGCursorElement::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGCursorElement::GetY( void ) -->
+  <function name="wxSVGCursorElement::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGCursorElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGCursorElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGCursorElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGCursorElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGCursorElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGCursorElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGDefinitionSrcElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGDefinitionSrcElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGDefinitionSrcElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGDefinitionSrcElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGDefinitionSrcElement::GetAttributes( void ) const -->
+  <function name="wxSVGDefinitionSrcElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGDefinitionSrcElement::GetDtd( void ) -->
+  <function name="wxSVGDefinitionSrcElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGDefinitionSrcElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGDefinitionSrcElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGDefinitionSrcElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGDefinitionSrcElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGDefsElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGDefsElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGDefsElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGDefsElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGDefsElement::GetAttributes( void ) const -->
+  <function name="wxSVGDefsElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGRect wxSVGDefsElement::GetBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGDefsElement::GetBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGDefsElement::GetCTM( void ) -->
+  <function name="wxSVGDefsElement::GetCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGDefsElement::GetDtd( void ) -->
+  <function name="wxSVGDefsElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGRect wxSVGDefsElement::GetResultBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGDefsElement::GetResultBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGDefsElement::GetScreenCTM( void ) -->
+  <function name="wxSVGDefsElement::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGDefsElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGDefsElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGDefsElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGDefsElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGDefsElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGDefsElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGDescElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGDescElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGDescElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGDescElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGDescElement::GetAttributes( void ) const -->
+  <function name="wxSVGDescElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGDescElement::GetDtd( void ) -->
+  <function name="wxSVGDescElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGDescElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGDescElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGDescElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGDescElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGDescElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGDescElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGDocument::ApplyAnimation( wxSVGElement * parent, wxSVGSVGElement * ownerSVGElement ) -->
+  <function name="wxSVGDocument::ApplyAnimation">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- wxSvgXmlElement * wxSVGDocument::CreateElement( const wxString & tagName ) -->
+  <function name="wxSVGDocument::CreateElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlElement *"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlElement * wxSVGDocument::CreateElementNS( const wxString & namespaceURI, const wxString & qualifiedName ) -->
+  <function name="wxSVGDocument::CreateElementNS">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlElement *"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSVGCanvas * wxSVGDocument::GetCanvas( void ) -->
+  <function name="wxSVGDocument::GetCanvas">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGCanvas *"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGDocument::GetCurrentTime( void ) -->
+  <function name="wxSVGDocument::GetCurrentTime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGDocument::GetDomain( void ) -->
+  <function name="wxSVGDocument::GetDomain">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGElement * wxSVGDocument::GetElementById( const wxString & id ) -->
+  <function name="wxSVGDocument::GetElementById">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGElement *"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- const wxString & wxSVGDocument::GetPath( void ) -->
+  <function name="wxSVGDocument::GetPath">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGDocument::GetReferrer( void ) -->
+  <function name="wxSVGDocument::GetReferrer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGSVGElement * wxSVGDocument::GetRootElement( void ) -->
+  <function name="wxSVGDocument::GetRootElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGSVGElement *"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGDocument::GetScale( void ) -->
+  <function name="wxSVGDocument::GetScale">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGDocument::GetScaleX( void ) -->
+  <function name="wxSVGDocument::GetScaleX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGDocument::GetScaleY( void ) -->
+  <function name="wxSVGDocument::GetScaleY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGMatrix & wxSVGDocument::GetScreenCTM( void ) -->
+  <function name="wxSVGDocument::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGMatrix &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSVGDocument::GetTitle( void ) -->
+  <function name="wxSVGDocument::GetTitle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGDocument::GetURL( void ) -->
+  <function name="wxSVGDocument::GetURL">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGDocument::Init( void ) -->
+  <function name="wxSVGDocument::Init">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxSVGDocument::SetCurrentTime( double seconds ) -->
+  <function name="wxSVGDocument::SetCurrentTime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGDocument::SetDomain( const wxString & n ) -->
+  <function name="wxSVGDocument::SetDomain">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGDocument::SetPath( const wxString & n ) -->
+  <function name="wxSVGDocument::SetPath">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGDocument::SetReferrer( const wxString & n ) -->
+  <function name="wxSVGDocument::SetReferrer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGDocument::SetRootElement( wxSVGSVGElement * n ) -->
+  <function name="wxSVGDocument::SetRootElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSVGDocument::SetTitle( const wxString & n ) -->
+  <function name="wxSVGDocument::SetTitle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGDocument::SetURL( const wxString & n ) -->
+  <function name="wxSVGDocument::SetURL">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGElement::AddProperty( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGElement::AddProperty">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxString wxSVGElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGElement::GetAttributes( void ) const -->
+  <function name="wxSVGElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxString & wxSVGElement::GetId( void ) -->
+  <function name="wxSVGElement::GetId">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGSVGElement * wxSVGElement::GetOwnerSVGElement( void ) -->
+  <function name="wxSVGElement::GetOwnerSVGElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGSVGElement *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGElement * wxSVGElement::GetSvgElement( void ) -->
+  <function name="wxSVGElement::GetSvgElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGElement *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGElement * wxSVGElement::GetViewportElement( void ) -->
+  <function name="wxSVGElement::GetViewportElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGElement *"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGElement::GetXmlbase( void ) -->
+  <function name="wxSVGElement::GetXmlbase">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGElement::SetId( const wxString & n ) -->
+  <function name="wxSVGElement::SetId">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGElement::SetOwnerSVGElement( wxSVGSVGElement * n ) -->
+  <function name="wxSVGElement::SetOwnerSVGElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSVGElement::SetViewportElement( wxSVGElement * n ) -->
+  <function name="wxSVGElement::SetViewportElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSVGElement::SetXmlbase( const wxString & n ) -->
+  <function name="wxSVGElement::SetXmlbase">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSVGElementInstanceList * wxSVGElementInstance::GetChildNodes( void ) -->
+  <function name="wxSVGElementInstance::GetChildNodes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGElementInstanceList *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGElement * wxSVGElementInstance::GetCorrespondingElement( void ) -->
+  <function name="wxSVGElementInstance::GetCorrespondingElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGElement *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGUseElement * wxSVGElementInstance::GetCorrespondingUseElement( void ) -->
+  <function name="wxSVGElementInstance::GetCorrespondingUseElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGUseElement *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGElementInstance * wxSVGElementInstance::GetFirstChild( void ) -->
+  <function name="wxSVGElementInstance::GetFirstChild">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGElementInstance *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGElementInstance * wxSVGElementInstance::GetLastChild( void ) -->
+  <function name="wxSVGElementInstance::GetLastChild">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGElementInstance *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGElementInstance * wxSVGElementInstance::GetNextSibling( void ) -->
+  <function name="wxSVGElementInstance::GetNextSibling">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGElementInstance *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGElementInstance * wxSVGElementInstance::GetParentNode( void ) -->
+  <function name="wxSVGElementInstance::GetParentNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGElementInstance *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGElementInstance * wxSVGElementInstance::GetPreviousSibling( void ) -->
+  <function name="wxSVGElementInstance::GetPreviousSibling">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGElementInstance *"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGElementInstance::SetChildNodes( wxSVGElementInstanceList * n ) -->
+  <function name="wxSVGElementInstance::SetChildNodes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSVGElementInstance::SetCorrespondingElement( wxSVGElement * n ) -->
+  <function name="wxSVGElementInstance::SetCorrespondingElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSVGElementInstance::SetCorrespondingUseElement( wxSVGUseElement * n ) -->
+  <function name="wxSVGElementInstance::SetCorrespondingUseElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSVGElementInstance::SetFirstChild( wxSVGElementInstance * n ) -->
+  <function name="wxSVGElementInstance::SetFirstChild">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSVGElementInstance::SetLastChild( wxSVGElementInstance * n ) -->
+  <function name="wxSVGElementInstance::SetLastChild">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSVGElementInstance::SetNextSibling( wxSVGElementInstance * n ) -->
+  <function name="wxSVGElementInstance::SetNextSibling">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSVGElementInstance::SetParentNode( wxSVGElementInstance * n ) -->
+  <function name="wxSVGElementInstance::SetParentNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSVGElementInstance::SetPreviousSibling( wxSVGElementInstance * n ) -->
+  <function name="wxSVGElementInstance::SetPreviousSibling">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGEllipseElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGEllipseElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGEllipseElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGEllipseElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGEllipseElement::GetAttributes( void ) const -->
+  <function name="wxSVGEllipseElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGRect wxSVGEllipseElement::GetBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGEllipseElement::GetBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGEllipseElement::GetCTM( void ) -->
+  <function name="wxSVGEllipseElement::GetCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGCanvasItem * wxSVGEllipseElement::GetCanvasItem( void ) -->
+  <function name="wxSVGEllipseElement::GetCanvasItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGCanvasItem *"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGEllipseElement::GetCx( void ) -->
+  <function name="wxSVGEllipseElement::GetCx">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGEllipseElement::GetCy( void ) -->
+  <function name="wxSVGEllipseElement::GetCy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGEllipseElement::GetDtd( void ) -->
+  <function name="wxSVGEllipseElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGRect wxSVGEllipseElement::GetResultBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGEllipseElement::GetResultBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGEllipseElement::GetRx( void ) -->
+  <function name="wxSVGEllipseElement::GetRx">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGEllipseElement::GetRy( void ) -->
+  <function name="wxSVGEllipseElement::GetRy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGMatrix wxSVGEllipseElement::GetScreenCTM( void ) -->
+  <function name="wxSVGEllipseElement::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGEllipseElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGEllipseElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGEllipseElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGEllipseElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGEllipseElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGEllipseElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGEllipseElement::SetCanvasItem( wxSVGCanvasItem * canvasItem ) -->
+  <function name="wxSVGEllipseElement::SetCanvasItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxString wxSVGExternalResourcesRequired::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGExternalResourcesRequired::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGExternalResourcesRequired::GetAttributes( void ) const -->
+  <function name="wxSVGExternalResourcesRequired::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxSVGAnimatedBoolean & wxSVGExternalResourcesRequired::GetExternalResourcesRequired( void ) -->
+  <function name="wxSVGExternalResourcesRequired::GetExternalResourcesRequired">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedBoolean &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGExternalResourcesRequired::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGExternalResourcesRequired::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGExternalResourcesRequired::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGExternalResourcesRequired::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGExternalResourcesRequired::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGExternalResourcesRequired::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFEBlendElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFEBlendElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFEBlendElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEBlendElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFEBlendElement::GetAttributes( void ) const -->
+  <function name="wxSVGFEBlendElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFEBlendElement::GetDtd( void ) -->
+  <function name="wxSVGFEBlendElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedString & wxSVGFEBlendElement::GetIn1( void ) -->
+  <function name="wxSVGFEBlendElement::GetIn1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedString & wxSVGFEBlendElement::GetIn2( void ) -->
+  <function name="wxSVGFEBlendElement::GetIn2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGFEBlendElement::GetMode( void ) -->
+  <function name="wxSVGFEBlendElement::GetMode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFEBlendElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEBlendElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEBlendElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFEBlendElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEBlendElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFEBlendElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFEColorMatrixElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFEColorMatrixElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFEColorMatrixElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEColorMatrixElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFEColorMatrixElement::GetAttributes( void ) const -->
+  <function name="wxSVGFEColorMatrixElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFEColorMatrixElement::GetDtd( void ) -->
+  <function name="wxSVGFEColorMatrixElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedString & wxSVGFEColorMatrixElement::GetIn1( void ) -->
+  <function name="wxSVGFEColorMatrixElement::GetIn1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGFEColorMatrixElement::GetType( void ) -->
+  <function name="wxSVGFEColorMatrixElement::GetType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumberList & wxSVGFEColorMatrixElement::GetValues( void ) -->
+  <function name="wxSVGFEColorMatrixElement::GetValues">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumberList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFEColorMatrixElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEColorMatrixElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEColorMatrixElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFEColorMatrixElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEColorMatrixElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFEColorMatrixElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFEComponentTransferElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFEComponentTransferElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFEComponentTransferElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEComponentTransferElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFEComponentTransferElement::GetAttributes( void ) const -->
+  <function name="wxSVGFEComponentTransferElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFEComponentTransferElement::GetDtd( void ) -->
+  <function name="wxSVGFEComponentTransferElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedString & wxSVGFEComponentTransferElement::GetIn1( void ) -->
+  <function name="wxSVGFEComponentTransferElement::GetIn1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFEComponentTransferElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEComponentTransferElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEComponentTransferElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFEComponentTransferElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEComponentTransferElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFEComponentTransferElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFECompositeElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFECompositeElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFECompositeElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFECompositeElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFECompositeElement::GetAttributes( void ) const -->
+  <function name="wxSVGFECompositeElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFECompositeElement::GetDtd( void ) -->
+  <function name="wxSVGFECompositeElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedString & wxSVGFECompositeElement::GetIn1( void ) -->
+  <function name="wxSVGFECompositeElement::GetIn1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedString & wxSVGFECompositeElement::GetIn2( void ) -->
+  <function name="wxSVGFECompositeElement::GetIn2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFECompositeElement::GetK1( void ) -->
+  <function name="wxSVGFECompositeElement::GetK1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFECompositeElement::GetK2( void ) -->
+  <function name="wxSVGFECompositeElement::GetK2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFECompositeElement::GetK3( void ) -->
+  <function name="wxSVGFECompositeElement::GetK3">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFECompositeElement::GetK4( void ) -->
+  <function name="wxSVGFECompositeElement::GetK4">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGFECompositeElement::GetOperator( void ) -->
+  <function name="wxSVGFECompositeElement::GetOperator">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFECompositeElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFECompositeElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFECompositeElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFECompositeElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFECompositeElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFECompositeElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFEConvolveMatrixElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFEConvolveMatrixElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFEConvolveMatrixElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEConvolveMatrixElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFEConvolveMatrixElement::GetAttributes( void ) const -->
+  <function name="wxSVGFEConvolveMatrixElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFEConvolveMatrixElement::GetBias( void ) -->
+  <function name="wxSVGFEConvolveMatrixElement::GetBias">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFEConvolveMatrixElement::GetDivisor( void ) -->
+  <function name="wxSVGFEConvolveMatrixElement::GetDivisor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGFEConvolveMatrixElement::GetDtd( void ) -->
+  <function name="wxSVGFEConvolveMatrixElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGFEConvolveMatrixElement::GetEdgeMode( void ) -->
+  <function name="wxSVGFEConvolveMatrixElement::GetEdgeMode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumberList & wxSVGFEConvolveMatrixElement::GetKernelMatrix( void ) -->
+  <function name="wxSVGFEConvolveMatrixElement::GetKernelMatrix">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumberList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGFEConvolveMatrixElement::GetKernelUnitLengthX( void ) -->
+  <function name="wxSVGFEConvolveMatrixElement::GetKernelUnitLengthX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGFEConvolveMatrixElement::GetKernelUnitLengthY( void ) -->
+  <function name="wxSVGFEConvolveMatrixElement::GetKernelUnitLengthY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedInteger & wxSVGFEConvolveMatrixElement::GetOrderX( void ) -->
+  <function name="wxSVGFEConvolveMatrixElement::GetOrderX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedInteger &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedInteger & wxSVGFEConvolveMatrixElement::GetOrderY( void ) -->
+  <function name="wxSVGFEConvolveMatrixElement::GetOrderY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedInteger &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedBoolean & wxSVGFEConvolveMatrixElement::GetPreserveAlpha( void ) -->
+  <function name="wxSVGFEConvolveMatrixElement::GetPreserveAlpha">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedBoolean &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedInteger & wxSVGFEConvolveMatrixElement::GetTargetX( void ) -->
+  <function name="wxSVGFEConvolveMatrixElement::GetTargetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedInteger &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedInteger & wxSVGFEConvolveMatrixElement::GetTargetY( void ) -->
+  <function name="wxSVGFEConvolveMatrixElement::GetTargetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedInteger &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFEConvolveMatrixElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEConvolveMatrixElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEConvolveMatrixElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFEConvolveMatrixElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEConvolveMatrixElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFEConvolveMatrixElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFEDiffuseLightingElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFEDiffuseLightingElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFEDiffuseLightingElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEDiffuseLightingElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFEDiffuseLightingElement::GetAttributes( void ) const -->
+  <function name="wxSVGFEDiffuseLightingElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFEDiffuseLightingElement::GetDiffuseConstant( void ) -->
+  <function name="wxSVGFEDiffuseLightingElement::GetDiffuseConstant">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGFEDiffuseLightingElement::GetDtd( void ) -->
+  <function name="wxSVGFEDiffuseLightingElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedString & wxSVGFEDiffuseLightingElement::GetIn1( void ) -->
+  <function name="wxSVGFEDiffuseLightingElement::GetIn1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFEDiffuseLightingElement::GetSurfaceScale( void ) -->
+  <function name="wxSVGFEDiffuseLightingElement::GetSurfaceScale">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFEDiffuseLightingElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEDiffuseLightingElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEDiffuseLightingElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFEDiffuseLightingElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEDiffuseLightingElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFEDiffuseLightingElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFEDisplacementMapElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFEDisplacementMapElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFEDisplacementMapElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEDisplacementMapElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFEDisplacementMapElement::GetAttributes( void ) const -->
+  <function name="wxSVGFEDisplacementMapElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFEDisplacementMapElement::GetDtd( void ) -->
+  <function name="wxSVGFEDisplacementMapElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedString & wxSVGFEDisplacementMapElement::GetIn1( void ) -->
+  <function name="wxSVGFEDisplacementMapElement::GetIn1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedString & wxSVGFEDisplacementMapElement::GetIn2( void ) -->
+  <function name="wxSVGFEDisplacementMapElement::GetIn2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFEDisplacementMapElement::GetScale( void ) -->
+  <function name="wxSVGFEDisplacementMapElement::GetScale">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGFEDisplacementMapElement::GetXChannelSelector( void ) -->
+  <function name="wxSVGFEDisplacementMapElement::GetXChannelSelector">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGFEDisplacementMapElement::GetYChannelSelector( void ) -->
+  <function name="wxSVGFEDisplacementMapElement::GetYChannelSelector">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFEDisplacementMapElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEDisplacementMapElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEDisplacementMapElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFEDisplacementMapElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEDisplacementMapElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFEDisplacementMapElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFEDistantLightElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFEDistantLightElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFEDistantLightElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEDistantLightElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFEDistantLightElement::GetAttributes( void ) const -->
+  <function name="wxSVGFEDistantLightElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFEDistantLightElement::GetAzimuth( void ) -->
+  <function name="wxSVGFEDistantLightElement::GetAzimuth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGFEDistantLightElement::GetDtd( void ) -->
+  <function name="wxSVGFEDistantLightElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFEDistantLightElement::GetElevation( void ) -->
+  <function name="wxSVGFEDistantLightElement::GetElevation">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFEDistantLightElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEDistantLightElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEDistantLightElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFEDistantLightElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEDistantLightElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFEDistantLightElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFEFloodElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFEFloodElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFEFloodElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEFloodElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFEFloodElement::GetAttributes( void ) const -->
+  <function name="wxSVGFEFloodElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFEFloodElement::GetDtd( void ) -->
+  <function name="wxSVGFEFloodElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedString & wxSVGFEFloodElement::GetIn1( void ) -->
+  <function name="wxSVGFEFloodElement::GetIn1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFEFloodElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEFloodElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEFloodElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFEFloodElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEFloodElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFEFloodElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFEFuncAElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFEFuncAElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFEFuncAElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEFuncAElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFEFuncAElement::GetAttributes( void ) const -->
+  <function name="wxSVGFEFuncAElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFEFuncAElement::GetDtd( void ) -->
+  <function name="wxSVGFEFuncAElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFEFuncAElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEFuncAElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEFuncAElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFEFuncAElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEFuncAElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFEFuncAElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFEFuncBElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFEFuncBElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFEFuncBElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEFuncBElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFEFuncBElement::GetAttributes( void ) const -->
+  <function name="wxSVGFEFuncBElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFEFuncBElement::GetDtd( void ) -->
+  <function name="wxSVGFEFuncBElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFEFuncBElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEFuncBElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEFuncBElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFEFuncBElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEFuncBElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFEFuncBElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFEFuncGElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFEFuncGElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFEFuncGElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEFuncGElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFEFuncGElement::GetAttributes( void ) const -->
+  <function name="wxSVGFEFuncGElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFEFuncGElement::GetDtd( void ) -->
+  <function name="wxSVGFEFuncGElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFEFuncGElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEFuncGElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEFuncGElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFEFuncGElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEFuncGElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFEFuncGElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFEFuncRElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFEFuncRElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFEFuncRElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEFuncRElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFEFuncRElement::GetAttributes( void ) const -->
+  <function name="wxSVGFEFuncRElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFEFuncRElement::GetDtd( void ) -->
+  <function name="wxSVGFEFuncRElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFEFuncRElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEFuncRElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEFuncRElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFEFuncRElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEFuncRElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFEFuncRElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFEGaussianBlurElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFEGaussianBlurElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFEGaussianBlurElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEGaussianBlurElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFEGaussianBlurElement::GetAttributes( void ) const -->
+  <function name="wxSVGFEGaussianBlurElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxString wxSVGFEGaussianBlurElement::GetCustomAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEGaussianBlurElement::GetCustomAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFEGaussianBlurElement::GetCustomAttributes( void ) const -->
+  <function name="wxSVGFEGaussianBlurElement::GetCustomAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFEGaussianBlurElement::GetDtd( void ) -->
+  <function name="wxSVGFEGaussianBlurElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedString & wxSVGFEGaussianBlurElement::GetIn1( void ) -->
+  <function name="wxSVGFEGaussianBlurElement::GetIn1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFEGaussianBlurElement::GetStdDeviationX( void ) -->
+  <function name="wxSVGFEGaussianBlurElement::GetStdDeviationX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFEGaussianBlurElement::GetStdDeviationY( void ) -->
+  <function name="wxSVGFEGaussianBlurElement::GetStdDeviationY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFEGaussianBlurElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEGaussianBlurElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEGaussianBlurElement::HasCustomAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEGaussianBlurElement::HasCustomAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEGaussianBlurElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFEGaussianBlurElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEGaussianBlurElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFEGaussianBlurElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEGaussianBlurElement::SetCustomAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFEGaussianBlurElement::SetCustomAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEGaussianBlurElement::SetCustomAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFEGaussianBlurElement::SetCustomAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGFEGaussianBlurElement::SetStdDeviation( double stdDeviationX, double stdDeviationY ) -->
+  <function name="wxSVGFEGaussianBlurElement::SetStdDeviation">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFEImageElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFEImageElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFEImageElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEImageElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFEImageElement::GetAttributes( void ) const -->
+  <function name="wxSVGFEImageElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFEImageElement::GetDtd( void ) -->
+  <function name="wxSVGFEImageElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFEImageElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEImageElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEImageElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFEImageElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEImageElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFEImageElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFEMergeElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFEMergeElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFEMergeElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEMergeElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFEMergeElement::GetAttributes( void ) const -->
+  <function name="wxSVGFEMergeElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFEMergeElement::GetDtd( void ) -->
+  <function name="wxSVGFEMergeElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFEMergeElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEMergeElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEMergeElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFEMergeElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEMergeElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFEMergeElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFEMergeNodeElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFEMergeNodeElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFEMergeNodeElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEMergeNodeElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFEMergeNodeElement::GetAttributes( void ) const -->
+  <function name="wxSVGFEMergeNodeElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFEMergeNodeElement::GetDtd( void ) -->
+  <function name="wxSVGFEMergeNodeElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedString & wxSVGFEMergeNodeElement::GetIn1( void ) -->
+  <function name="wxSVGFEMergeNodeElement::GetIn1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFEMergeNodeElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEMergeNodeElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEMergeNodeElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFEMergeNodeElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEMergeNodeElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFEMergeNodeElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFEMorphologyElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFEMorphologyElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFEMorphologyElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEMorphologyElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFEMorphologyElement::GetAttributes( void ) const -->
+  <function name="wxSVGFEMorphologyElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFEMorphologyElement::GetDtd( void ) -->
+  <function name="wxSVGFEMorphologyElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedString & wxSVGFEMorphologyElement::GetIn1( void ) -->
+  <function name="wxSVGFEMorphologyElement::GetIn1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGFEMorphologyElement::GetOperator( void ) -->
+  <function name="wxSVGFEMorphologyElement::GetOperator">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGFEMorphologyElement::GetRadiusX( void ) -->
+  <function name="wxSVGFEMorphologyElement::GetRadiusX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGFEMorphologyElement::GetRadiusY( void ) -->
+  <function name="wxSVGFEMorphologyElement::GetRadiusY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFEMorphologyElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEMorphologyElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEMorphologyElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFEMorphologyElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEMorphologyElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFEMorphologyElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFEOffsetElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFEOffsetElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFEOffsetElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEOffsetElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFEOffsetElement::GetAttributes( void ) const -->
+  <function name="wxSVGFEOffsetElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFEOffsetElement::GetDtd( void ) -->
+  <function name="wxSVGFEOffsetElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFEOffsetElement::GetDx( void ) -->
+  <function name="wxSVGFEOffsetElement::GetDx">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFEOffsetElement::GetDy( void ) -->
+  <function name="wxSVGFEOffsetElement::GetDy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedString & wxSVGFEOffsetElement::GetIn1( void ) -->
+  <function name="wxSVGFEOffsetElement::GetIn1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFEOffsetElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEOffsetElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEOffsetElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFEOffsetElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEOffsetElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFEOffsetElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFEPointLightElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFEPointLightElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFEPointLightElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEPointLightElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFEPointLightElement::GetAttributes( void ) const -->
+  <function name="wxSVGFEPointLightElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFEPointLightElement::GetDtd( void ) -->
+  <function name="wxSVGFEPointLightElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFEPointLightElement::GetX( void ) -->
+  <function name="wxSVGFEPointLightElement::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFEPointLightElement::GetY( void ) -->
+  <function name="wxSVGFEPointLightElement::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFEPointLightElement::GetZ( void ) -->
+  <function name="wxSVGFEPointLightElement::GetZ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFEPointLightElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFEPointLightElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEPointLightElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFEPointLightElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFEPointLightElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFEPointLightElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFESpecularLightingElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFESpecularLightingElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFESpecularLightingElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFESpecularLightingElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFESpecularLightingElement::GetAttributes( void ) const -->
+  <function name="wxSVGFESpecularLightingElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFESpecularLightingElement::GetDtd( void ) -->
+  <function name="wxSVGFESpecularLightingElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedString & wxSVGFESpecularLightingElement::GetIn1( void ) -->
+  <function name="wxSVGFESpecularLightingElement::GetIn1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFESpecularLightingElement::GetSpecularConstant( void ) -->
+  <function name="wxSVGFESpecularLightingElement::GetSpecularConstant">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFESpecularLightingElement::GetSpecularExponent( void ) -->
+  <function name="wxSVGFESpecularLightingElement::GetSpecularExponent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFESpecularLightingElement::GetSurfaceScale( void ) -->
+  <function name="wxSVGFESpecularLightingElement::GetSurfaceScale">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFESpecularLightingElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFESpecularLightingElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFESpecularLightingElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFESpecularLightingElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFESpecularLightingElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFESpecularLightingElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFESpotLightElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFESpotLightElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFESpotLightElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFESpotLightElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFESpotLightElement::GetAttributes( void ) const -->
+  <function name="wxSVGFESpotLightElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFESpotLightElement::GetDtd( void ) -->
+  <function name="wxSVGFESpotLightElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFESpotLightElement::GetLimitingConeAngle( void ) -->
+  <function name="wxSVGFESpotLightElement::GetLimitingConeAngle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFESpotLightElement::GetPointsAtX( void ) -->
+  <function name="wxSVGFESpotLightElement::GetPointsAtX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFESpotLightElement::GetPointsAtY( void ) -->
+  <function name="wxSVGFESpotLightElement::GetPointsAtY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFESpotLightElement::GetPointsAtZ( void ) -->
+  <function name="wxSVGFESpotLightElement::GetPointsAtZ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFESpotLightElement::GetSpecularExponent( void ) -->
+  <function name="wxSVGFESpotLightElement::GetSpecularExponent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFESpotLightElement::GetX( void ) -->
+  <function name="wxSVGFESpotLightElement::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFESpotLightElement::GetY( void ) -->
+  <function name="wxSVGFESpotLightElement::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFESpotLightElement::GetZ( void ) -->
+  <function name="wxSVGFESpotLightElement::GetZ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFESpotLightElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFESpotLightElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFESpotLightElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFESpotLightElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFESpotLightElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFESpotLightElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFETileElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFETileElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFETileElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFETileElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFETileElement::GetAttributes( void ) const -->
+  <function name="wxSVGFETileElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFETileElement::GetDtd( void ) -->
+  <function name="wxSVGFETileElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedString & wxSVGFETileElement::GetIn1( void ) -->
+  <function name="wxSVGFETileElement::GetIn1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFETileElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFETileElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFETileElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFETileElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFETileElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFETileElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFETurbulenceElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFETurbulenceElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFETurbulenceElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFETurbulenceElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFETurbulenceElement::GetAttributes( void ) const -->
+  <function name="wxSVGFETurbulenceElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFETurbulenceElement::GetBaseFrequencyX( void ) -->
+  <function name="wxSVGFETurbulenceElement::GetBaseFrequencyX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFETurbulenceElement::GetBaseFrequencyY( void ) -->
+  <function name="wxSVGFETurbulenceElement::GetBaseFrequencyY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGFETurbulenceElement::GetDtd( void ) -->
+  <function name="wxSVGFETurbulenceElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedInteger & wxSVGFETurbulenceElement::GetNumOctaves( void ) -->
+  <function name="wxSVGFETurbulenceElement::GetNumOctaves">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedInteger &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGFETurbulenceElement::GetSeed( void ) -->
+  <function name="wxSVGFETurbulenceElement::GetSeed">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGFETurbulenceElement::GetStitchTiles( void ) -->
+  <function name="wxSVGFETurbulenceElement::GetStitchTiles">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGFETurbulenceElement::GetType( void ) -->
+  <function name="wxSVGFETurbulenceElement::GetType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFETurbulenceElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFETurbulenceElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFETurbulenceElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFETurbulenceElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFETurbulenceElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFETurbulenceElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFilterElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFilterElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFilterElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFilterElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFilterElement::GetAttributes( void ) const -->
+  <function name="wxSVGFilterElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFilterElement::GetDtd( void ) -->
+  <function name="wxSVGFilterElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedInteger & wxSVGFilterElement::GetFilterResX( void ) -->
+  <function name="wxSVGFilterElement::GetFilterResX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedInteger &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedInteger & wxSVGFilterElement::GetFilterResY( void ) -->
+  <function name="wxSVGFilterElement::GetFilterResY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedInteger &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGFilterElement::GetFilterUnits( void ) -->
+  <function name="wxSVGFilterElement::GetFilterUnits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGFilterElement::GetHeight( void ) -->
+  <function name="wxSVGFilterElement::GetHeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGFilterElement::GetPrimitiveUnits( void ) -->
+  <function name="wxSVGFilterElement::GetPrimitiveUnits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGFilterElement::GetWidth( void ) -->
+  <function name="wxSVGFilterElement::GetWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGFilterElement::GetX( void ) -->
+  <function name="wxSVGFilterElement::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGFilterElement::GetY( void ) -->
+  <function name="wxSVGFilterElement::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFilterElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFilterElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFilterElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFilterElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFilterElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFilterElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGFilterElement::SetFilterRes( unsigned long filterResX, unsigned long filterResY ) -->
+  <function name="wxSVGFilterElement::SetFilterRes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFilterPrimitiveStandardAttributes::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFilterPrimitiveStandardAttributes::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFilterPrimitiveStandardAttributes::GetAttributes( void ) const -->
+  <function name="wxSVGFilterPrimitiveStandardAttributes::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGFilterPrimitiveStandardAttributes::GetHeight( void ) -->
+  <function name="wxSVGFilterPrimitiveStandardAttributes::GetHeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedString & wxSVGFilterPrimitiveStandardAttributes::GetResult( void ) -->
+  <function name="wxSVGFilterPrimitiveStandardAttributes::GetResult">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGFilterPrimitiveStandardAttributes::GetWidth( void ) -->
+  <function name="wxSVGFilterPrimitiveStandardAttributes::GetWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGFilterPrimitiveStandardAttributes::GetX( void ) -->
+  <function name="wxSVGFilterPrimitiveStandardAttributes::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGFilterPrimitiveStandardAttributes::GetY( void ) -->
+  <function name="wxSVGFilterPrimitiveStandardAttributes::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFilterPrimitiveStandardAttributes::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFilterPrimitiveStandardAttributes::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFilterPrimitiveStandardAttributes::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFilterPrimitiveStandardAttributes::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFilterPrimitiveStandardAttributes::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFilterPrimitiveStandardAttributes::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxString wxSVGFitToViewBox::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFitToViewBox::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFitToViewBox::GetAttributes( void ) const -->
+  <function name="wxSVGFitToViewBox::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxSVGAnimatedPreserveAspectRatio & wxSVGFitToViewBox::GetPreserveAspectRatio( void ) -->
+  <function name="wxSVGFitToViewBox::GetPreserveAspectRatio">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedPreserveAspectRatio &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedRect & wxSVGFitToViewBox::GetViewBox( void ) -->
+  <function name="wxSVGFitToViewBox::GetViewBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedRect &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFitToViewBox::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFitToViewBox::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFitToViewBox::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFitToViewBox::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFitToViewBox::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFitToViewBox::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGFitToViewBox::UpdateMatrix( wxSVGMatrix & matrix, const wxSVGLength & width, const wxSVGLength & height ) -->
+  <function name="wxSVGFitToViewBox::UpdateMatrix">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFontElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFontElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFontElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFontElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFontElement::GetAttributes( void ) const -->
+  <function name="wxSVGFontElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFontElement::GetDtd( void ) -->
+  <function name="wxSVGFontElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFontElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFontElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFontElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGFontElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGFontElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFontElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFontFaceElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFontFaceElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFontFaceElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFontFaceElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFontFaceElement::GetAttributes( void ) const -->
+  <function name="wxSVGFontFaceElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFontFaceElement::GetDtd( void ) -->
+  <function name="wxSVGFontFaceElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFontFaceElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFontFaceElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFontFaceElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFontFaceElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFontFaceFormatElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFontFaceFormatElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFontFaceFormatElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFontFaceFormatElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFontFaceFormatElement::GetAttributes( void ) const -->
+  <function name="wxSVGFontFaceFormatElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFontFaceFormatElement::GetDtd( void ) -->
+  <function name="wxSVGFontFaceFormatElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFontFaceFormatElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFontFaceFormatElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFontFaceFormatElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFontFaceFormatElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFontFaceNameElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFontFaceNameElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFontFaceNameElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFontFaceNameElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFontFaceNameElement::GetAttributes( void ) const -->
+  <function name="wxSVGFontFaceNameElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFontFaceNameElement::GetDtd( void ) -->
+  <function name="wxSVGFontFaceNameElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFontFaceNameElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFontFaceNameElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFontFaceNameElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFontFaceNameElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFontFaceSrcElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFontFaceSrcElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFontFaceSrcElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFontFaceSrcElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFontFaceSrcElement::GetAttributes( void ) const -->
+  <function name="wxSVGFontFaceSrcElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFontFaceSrcElement::GetDtd( void ) -->
+  <function name="wxSVGFontFaceSrcElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFontFaceSrcElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFontFaceSrcElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFontFaceSrcElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFontFaceSrcElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGFontFaceUriElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGFontFaceUriElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGFontFaceUriElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGFontFaceUriElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGFontFaceUriElement::GetAttributes( void ) const -->
+  <function name="wxSVGFontFaceUriElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGFontFaceUriElement::GetDtd( void ) -->
+  <function name="wxSVGFontFaceUriElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGFontFaceUriElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGFontFaceUriElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGFontFaceUriElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGFontFaceUriElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGForeignObjectElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGForeignObjectElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGForeignObjectElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGForeignObjectElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGForeignObjectElement::GetAttributes( void ) const -->
+  <function name="wxSVGForeignObjectElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGRect wxSVGForeignObjectElement::GetBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGForeignObjectElement::GetBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGForeignObjectElement::GetCTM( void ) -->
+  <function name="wxSVGForeignObjectElement::GetCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGForeignObjectElement::GetDtd( void ) -->
+  <function name="wxSVGForeignObjectElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGForeignObjectElement::GetHeight( void ) -->
+  <function name="wxSVGForeignObjectElement::GetHeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGRect wxSVGForeignObjectElement::GetResultBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGForeignObjectElement::GetResultBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGForeignObjectElement::GetScreenCTM( void ) -->
+  <function name="wxSVGForeignObjectElement::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGForeignObjectElement::GetWidth( void ) -->
+  <function name="wxSVGForeignObjectElement::GetWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGForeignObjectElement::GetX( void ) -->
+  <function name="wxSVGForeignObjectElement::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGForeignObjectElement::GetY( void ) -->
+  <function name="wxSVGForeignObjectElement::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGForeignObjectElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGForeignObjectElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGForeignObjectElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGForeignObjectElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGForeignObjectElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGForeignObjectElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGGElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGGElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGGElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGGElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGGElement::GetAttributes( void ) const -->
+  <function name="wxSVGGElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGRect wxSVGGElement::GetBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGGElement::GetBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGGElement::GetCTM( void ) -->
+  <function name="wxSVGGElement::GetCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGGElement::GetDtd( void ) -->
+  <function name="wxSVGGElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGRect wxSVGGElement::GetResultBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGGElement::GetResultBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGGElement::GetScreenCTM( void ) -->
+  <function name="wxSVGGElement::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGGElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGGElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGGElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGGElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGGElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGGElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGGlyphElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGGlyphElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGGlyphElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGGlyphElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGGlyphElement::GetAttributes( void ) const -->
+  <function name="wxSVGGlyphElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGGlyphElement::GetDtd( void ) -->
+  <function name="wxSVGGlyphElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGGlyphElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGGlyphElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGGlyphElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGGlyphElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGGlyphElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGGlyphElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGGlyphRefElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGGlyphRefElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGGlyphRefElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGGlyphRefElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGGlyphRefElement::GetAttributes( void ) const -->
+  <function name="wxSVGGlyphRefElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGGlyphRefElement::GetDtd( void ) -->
+  <function name="wxSVGGlyphRefElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGGlyphRefElement::GetDx( void ) -->
+  <function name="wxSVGGlyphRefElement::GetDx">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGGlyphRefElement::GetDy( void ) -->
+  <function name="wxSVGGlyphRefElement::GetDy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGGlyphRefElement::GetFormat( void ) -->
+  <function name="wxSVGGlyphRefElement::GetFormat">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGGlyphRefElement::GetGlyphRef( void ) -->
+  <function name="wxSVGGlyphRefElement::GetGlyphRef">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGGlyphRefElement::GetX( void ) -->
+  <function name="wxSVGGlyphRefElement::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGGlyphRefElement::GetY( void ) -->
+  <function name="wxSVGGlyphRefElement::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGGlyphRefElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGGlyphRefElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGGlyphRefElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGGlyphRefElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGGlyphRefElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGGlyphRefElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGGlyphRefElement::SetDx( double n ) -->
+  <function name="wxSVGGlyphRefElement::SetDx">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGGlyphRefElement::SetDy( double n ) -->
+  <function name="wxSVGGlyphRefElement::SetDy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGGlyphRefElement::SetFormat( const wxString & n ) -->
+  <function name="wxSVGGlyphRefElement::SetFormat">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGGlyphRefElement::SetGlyphRef( const wxString & n ) -->
+  <function name="wxSVGGlyphRefElement::SetGlyphRef">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGGlyphRefElement::SetX( double n ) -->
+  <function name="wxSVGGlyphRefElement::SetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGGlyphRefElement::SetY( double n ) -->
+  <function name="wxSVGGlyphRefElement::SetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxString wxSVGGradientElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGGradientElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGGradientElement::GetAttributes( void ) const -->
+  <function name="wxSVGGradientElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxSVGAnimatedTransformList & wxSVGGradientElement::GetGradientTransform( void ) -->
+  <function name="wxSVGGradientElement::GetGradientTransform">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedTransformList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGGradientElement::GetGradientUnits( void ) -->
+  <function name="wxSVGGradientElement::GetGradientUnits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGGradientElement::GetSpreadMethod( void ) -->
+  <function name="wxSVGGradientElement::GetSpreadMethod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGGradientElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGGradientElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGGradientElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGGradientElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGGradientElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGGradientElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGHKernElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGHKernElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGHKernElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGHKernElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGHKernElement::GetAttributes( void ) const -->
+  <function name="wxSVGHKernElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGHKernElement::GetDtd( void ) -->
+  <function name="wxSVGHKernElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGHKernElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGHKernElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGHKernElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGHKernElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- const wxString & wxSVGICCColor::GetColorProfile( void ) -->
+  <function name="wxSVGICCColor::GetColorProfile">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGNumberList & wxSVGICCColor::GetColors( void ) -->
+  <function name="wxSVGICCColor::GetColors">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGNumberList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGICCColor::SetColorProfile( const wxString & n ) -->
+  <function name="wxSVGICCColor::SetColorProfile">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGICCColor::SetColors( const wxSVGNumberList & n ) -->
+  <function name="wxSVGICCColor::SetColors">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGImageElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGImageElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGImageElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGImageElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGImageElement::GetAttributes( void ) const -->
+  <function name="wxSVGImageElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGRect wxSVGImageElement::GetBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGImageElement::GetBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGImageElement::GetCTM( void ) -->
+  <function name="wxSVGImageElement::GetCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGCanvasItem * wxSVGImageElement::GetCanvasItem( void ) -->
+  <function name="wxSVGImageElement::GetCanvasItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGCanvasItem *"/>
+    <use-retval/>
+  </function>
+  <!-- int wxSVGImageElement::GetDefaultHeight( wxProgressDialog * progressDlg = NULL ) -->
+  <function name="wxSVGImageElement::GetDefaultHeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" default="NULL" direction="inout"/>
+  </function>
+  <!-- int wxSVGImageElement::GetDefaultWidth( wxProgressDialog * progressDlg = NULL ) -->
+  <function name="wxSVGImageElement::GetDefaultWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" default="NULL" direction="inout"/>
+  </function>
+  <!-- wxSVGDTD wxSVGImageElement::GetDtd( void ) -->
+  <function name="wxSVGImageElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGImageElement::GetHeight( void ) -->
+  <function name="wxSVGImageElement::GetHeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedPreserveAspectRatio & wxSVGImageElement::GetPreserveAspectRatio( void ) -->
+  <function name="wxSVGImageElement::GetPreserveAspectRatio">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedPreserveAspectRatio &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGRect wxSVGImageElement::GetResultBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGImageElement::GetResultBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGImageElement::GetScreenCTM( void ) -->
+  <function name="wxSVGImageElement::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGImageElement::GetWidth( void ) -->
+  <function name="wxSVGImageElement::GetWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGImageElement::GetX( void ) -->
+  <function name="wxSVGImageElement::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGImageElement::GetY( void ) -->
+  <function name="wxSVGImageElement::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGImageElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGImageElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGImageElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGImageElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGImageElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGImageElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGImageElement::SetCanvasItem( wxSVGCanvasItem * canvasItem ) -->
+  <function name="wxSVGImageElement::SetCanvasItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSVGImageElement::SetDefaultSize( wxProgressDialog * progressDlg = NULL ) -->
+  <function name="wxSVGImageElement::SetDefaultSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" default="NULL" direction="inout"/>
+  </function>
+  <!-- wxString wxSVGLangSpace::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGLangSpace::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGLangSpace::GetAttributes( void ) const -->
+  <function name="wxSVGLangSpace::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxString & wxSVGLangSpace::GetXmllang( void ) -->
+  <function name="wxSVGLangSpace::GetXmllang">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGLangSpace::GetXmlspace( void ) -->
+  <function name="wxSVGLangSpace::GetXmlspace">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGLangSpace::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGLangSpace::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGLangSpace::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGLangSpace::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGLangSpace::SetXmllang( const wxString & n ) -->
+  <function name="wxSVGLangSpace::SetXmllang">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGLangSpace::SetXmlspace( const wxString & n ) -->
+  <function name="wxSVGLangSpace::SetXmlspace">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGLength::ConvertToSpecifiedUnits( wxSVG_LENGTHTYPE unitType ) -->
+  <function name="wxSVGLength::ConvertToSpecifiedUnits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSVG_LENGTHTYPE wxSVGLength::GetUnitType( void ) -->
+  <function name="wxSVGLength::GetUnitType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVG_LENGTHTYPE"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGLength::GetValue( void ) -->
+  <function name="wxSVGLength::GetValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSVGLength::GetValueAsString( void ) const -->
+  <function name="wxSVGLength::GetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- double wxSVGLength::GetValueInSpecifiedUnits( void ) -->
+  <function name="wxSVGLength::GetValueInSpecifiedUnits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGLength::NewValueSpecifiedUnits( wxSVG_LENGTHTYPE unitType, double valueInSpecifiedUnits ) -->
+  <function name="wxSVGLength::NewValueSpecifiedUnits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGLength::SetUnitType( const wxSVG_LENGTHTYPE & n ) -->
+  <function name="wxSVGLength::SetUnitType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGLength::SetValue( double n ) -->
+  <function name="wxSVGLength::SetValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGLength::SetValueAsString( const wxString & n ) -->
+  <function name="wxSVGLength::SetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGLength::SetValueInSpecifiedUnits( double n ) -->
+  <function name="wxSVGLength::SetValueInSpecifiedUnits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGLength::ToViewportHeight( float viewportHeight ) -->
+  <function name="wxSVGLength::ToViewportHeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-3.402823e+38:3.402823e+38</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGLength::ToViewportSize( float viewportWidth, float viewportHeight ) -->
+  <function name="wxSVGLength::ToViewportSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-3.402823e+38:3.402823e+38</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-3.402823e+38:3.402823e+38</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGLength::ToViewportWidth( float viewportWidth ) -->
+  <function name="wxSVGLength::ToViewportWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-3.402823e+38:3.402823e+38</valid>
+    </arg>
+  </function>
+  <!-- wxString wxSVGLengthList::GetValueAsString( void ) const -->
+  <function name="wxSVGLengthList::GetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void wxSVGLengthList::SetValueAsString( const wxString & value ) -->
+  <function name="wxSVGLengthList::SetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGLineElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGLineElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGLineElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGLineElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGLineElement::GetAttributes( void ) const -->
+  <function name="wxSVGLineElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGRect wxSVGLineElement::GetBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGLineElement::GetBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGLineElement::GetCTM( void ) -->
+  <function name="wxSVGLineElement::GetCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGCanvasItem * wxSVGLineElement::GetCanvasItem( void ) -->
+  <function name="wxSVGLineElement::GetCanvasItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGCanvasItem *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGLineElement::GetDtd( void ) -->
+  <function name="wxSVGLineElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGRect wxSVGLineElement::GetResultBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGLineElement::GetResultBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGLineElement::GetScreenCTM( void ) -->
+  <function name="wxSVGLineElement::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGLineElement::GetX1( void ) -->
+  <function name="wxSVGLineElement::GetX1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGLineElement::GetX2( void ) -->
+  <function name="wxSVGLineElement::GetX2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGLineElement::GetY1( void ) -->
+  <function name="wxSVGLineElement::GetY1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGLineElement::GetY2( void ) -->
+  <function name="wxSVGLineElement::GetY2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGLineElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGLineElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGLineElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGLineElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGLineElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGLineElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGLineElement::SetCanvasItem( wxSVGCanvasItem * canvasItem ) -->
+  <function name="wxSVGLineElement::SetCanvasItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGLinearGradientElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGLinearGradientElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGLinearGradientElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGLinearGradientElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGLinearGradientElement::GetAttributes( void ) const -->
+  <function name="wxSVGLinearGradientElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGLinearGradientElement::GetDtd( void ) -->
+  <function name="wxSVGLinearGradientElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGLinearGradientElement::GetX1( void ) -->
+  <function name="wxSVGLinearGradientElement::GetX1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGLinearGradientElement::GetX2( void ) -->
+  <function name="wxSVGLinearGradientElement::GetX2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGLinearGradientElement::GetY1( void ) -->
+  <function name="wxSVGLinearGradientElement::GetY1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGLinearGradientElement::GetY2( void ) -->
+  <function name="wxSVGLinearGradientElement::GetY2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGLinearGradientElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGLinearGradientElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGLinearGradientElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGLinearGradientElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGLinearGradientElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGLinearGradientElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGLocatable::GetCTM( const wxSVGElement * element ) -->
+  <function name="wxSVGLocatable::GetCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxSVGRect wxSVGLocatable::GetChildrenBBox( const wxSVGElement * element, wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGLocatable::GetChildrenBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGRect wxSVGLocatable::GetChildrenResultBBox( const wxSVGElement * element, wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGLocatable::GetChildrenResultBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGRect wxSVGLocatable::GetElementBBox( const wxSVGElement * element, wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGLocatable::GetElementBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGRect wxSVGLocatable::GetElementResultBBox( const wxSVGElement * element, wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGLocatable::GetElementResultBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGElement * wxSVGLocatable::GetFarthestViewportElement( void ) -->
+  <function name="wxSVGLocatable::GetFarthestViewportElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGElement *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGMatrix wxSVGLocatable::GetMatrix( wxSVG_COORDINATES coordinates ) -->
+  <function name="wxSVGLocatable::GetMatrix">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSVGElement * wxSVGLocatable::GetNearestViewportElement( void ) -->
+  <function name="wxSVGLocatable::GetNearestViewportElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGElement *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGMatrix wxSVGLocatable::GetParentMatrix( const wxSVGElement * element ) -->
+  <function name="wxSVGLocatable::GetParentMatrix">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGLocatable::GetScreenCTM( const wxSVGElement * element ) -->
+  <function name="wxSVGLocatable::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <pure/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGLocatable::GetTransformToElement( const wxSVGElement & element ) const -->
+  <function name="wxSVGLocatable::GetTransformToElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGLocatable::SetFarthestViewportElement( wxSVGElement * n ) -->
+  <function name="wxSVGLocatable::SetFarthestViewportElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSVGLocatable::SetNearestViewportElement( wxSVGElement * n ) -->
+  <function name="wxSVGLocatable::SetNearestViewportElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGMPathElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGMPathElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGMPathElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGMPathElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGMPathElement::GetAttributes( void ) const -->
+  <function name="wxSVGMPathElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGMPathElement::GetDtd( void ) -->
+  <function name="wxSVGMPathElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGMPathElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGMPathElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGMPathElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGMPathElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGMPathElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGMPathElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGMarkerElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGMarkerElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGMarkerElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGMarkerElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGMarkerElement::GetAttributes( void ) const -->
+  <function name="wxSVGMarkerElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGMarkerElement::GetDtd( void ) -->
+  <function name="wxSVGMarkerElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGMarkerElement::GetMarkerHeight( void ) -->
+  <function name="wxSVGMarkerElement::GetMarkerHeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGMarkerElement::GetMarkerUnits( void ) -->
+  <function name="wxSVGMarkerElement::GetMarkerUnits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGMarkerElement::GetMarkerWidth( void ) -->
+  <function name="wxSVGMarkerElement::GetMarkerWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedAngle & wxSVGMarkerElement::GetOrientAngle( void ) -->
+  <function name="wxSVGMarkerElement::GetOrientAngle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedAngle &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGMarkerElement::GetOrientType( void ) -->
+  <function name="wxSVGMarkerElement::GetOrientType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGMarkerElement::GetRefX( void ) -->
+  <function name="wxSVGMarkerElement::GetRefX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGMarkerElement::GetRefY( void ) -->
+  <function name="wxSVGMarkerElement::GetRefY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGMarkerElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGMarkerElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGMarkerElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGMarkerElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGMarkerElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGMarkerElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGMarkerElement::SetOrientToAngle( const wxSVGAngle & angle ) -->
+  <function name="wxSVGMarkerElement::SetOrientToAngle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGMarkerElement::SetOrientToAuto( void ) -->
+  <function name="wxSVGMarkerElement::SetOrientToAuto">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGMaskElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGMaskElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGMaskElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGMaskElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGMaskElement::GetAttributes( void ) const -->
+  <function name="wxSVGMaskElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGMaskElement::GetDtd( void ) -->
+  <function name="wxSVGMaskElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGMaskElement::GetHeight( void ) -->
+  <function name="wxSVGMaskElement::GetHeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGMaskElement::GetMaskContentUnits( void ) -->
+  <function name="wxSVGMaskElement::GetMaskContentUnits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGMaskElement::GetMaskUnits( void ) -->
+  <function name="wxSVGMaskElement::GetMaskUnits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGMaskElement::GetWidth( void ) -->
+  <function name="wxSVGMaskElement::GetWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGMaskElement::GetX( void ) -->
+  <function name="wxSVGMaskElement::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGMaskElement::GetY( void ) -->
+  <function name="wxSVGMaskElement::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGMaskElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGMaskElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGMaskElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGMaskElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGMaskElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGMaskElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGMatrix::FlipX( void ) const -->
+  <function name="wxSVGMatrix::FlipX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGMatrix wxSVGMatrix::FlipY( void ) const -->
+  <function name="wxSVGMatrix::FlipY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- double wxSVGMatrix::GetA( void ) -->
+  <function name="wxSVGMatrix::GetA">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGMatrix::GetB( void ) -->
+  <function name="wxSVGMatrix::GetB">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGMatrix::GetC( void ) -->
+  <function name="wxSVGMatrix::GetC">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGMatrix::GetD( void ) -->
+  <function name="wxSVGMatrix::GetD">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGMatrix::GetE( void ) -->
+  <function name="wxSVGMatrix::GetE">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGMatrix::GetF( void ) -->
+  <function name="wxSVGMatrix::GetF">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGMatrix wxSVGMatrix::Inverse( void ) const -->
+  <function name="wxSVGMatrix::Inverse">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGMatrix wxSVGMatrix::Multiply( const wxSVGMatrix & secondMatrix ) const -->
+  <function name="wxSVGMatrix::Multiply">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGMatrix::Rotate( double angle ) const -->
+  <function name="wxSVGMatrix::Rotate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGMatrix wxSVGMatrix::RotateFromVector( double x, double y ) const -->
+  <function name="wxSVGMatrix::RotateFromVector">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGMatrix wxSVGMatrix::Scale( double scaleFactor ) const -->
+  <function name="wxSVGMatrix::Scale">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGMatrix wxSVGMatrix::ScaleNonUniform( double scaleFactorX, double scaleFactorY ) const -->
+  <function name="wxSVGMatrix::ScaleNonUniform">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGMatrix::SetA( double n ) -->
+  <function name="wxSVGMatrix::SetA">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGMatrix::SetB( double n ) -->
+  <function name="wxSVGMatrix::SetB">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGMatrix::SetC( double n ) -->
+  <function name="wxSVGMatrix::SetC">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGMatrix::SetD( double n ) -->
+  <function name="wxSVGMatrix::SetD">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGMatrix::SetE( double n ) -->
+  <function name="wxSVGMatrix::SetE">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGMatrix::SetF( double n ) -->
+  <function name="wxSVGMatrix::SetF">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGMatrix wxSVGMatrix::SkewX( double angle ) const -->
+  <function name="wxSVGMatrix::SkewX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGMatrix wxSVGMatrix::SkewY( double angle ) const -->
+  <function name="wxSVGMatrix::SkewY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGMatrix wxSVGMatrix::Translate( double x, double y ) const -->
+  <function name="wxSVGMatrix::Translate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGMetadataElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGMetadataElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGMetadataElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGMetadataElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGMetadataElement::GetAttributes( void ) const -->
+  <function name="wxSVGMetadataElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGMetadataElement::GetDtd( void ) -->
+  <function name="wxSVGMetadataElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGMetadataElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGMetadataElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGMetadataElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGMetadataElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGMissingGlyphElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGMissingGlyphElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGMissingGlyphElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGMissingGlyphElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGMissingGlyphElement::GetAttributes( void ) const -->
+  <function name="wxSVGMissingGlyphElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGMissingGlyphElement::GetDtd( void ) -->
+  <function name="wxSVGMissingGlyphElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGMissingGlyphElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGMissingGlyphElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGMissingGlyphElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGMissingGlyphElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGMissingGlyphElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGMissingGlyphElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- double wxSVGNumber::GetValue( void ) -->
+  <function name="wxSVGNumber::GetValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGNumber::SetValue( double n ) -->
+  <function name="wxSVGNumber::SetValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxString wxSVGNumberList::GetValueAsString( void ) const -->
+  <function name="wxSVGNumberList::GetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void wxSVGNumberList::SetValueAsString( const wxString & value ) -->
+  <function name="wxSVGNumberList::SetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxCSSValue * wxSVGPaint::Clone( void ) -->
+  <function name="wxSVGPaint::Clone">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSSValue *"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSVGPaint::GetCSSText( void ) const -->
+  <function name="wxSVGPaint::GetCSSText">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVG_PAINTTYPE wxSVGPaint::GetPaintType( void ) -->
+  <function name="wxSVGPaint::GetPaintType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVG_PAINTTYPE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGPaint::GetUri( void ) -->
+  <function name="wxSVGPaint::GetUri">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGPaint::Ok( void ) -->
+  <function name="wxSVGPaint::Ok">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGPaint::SetICCColor( const wxSVGICCColor & iccColor ) -->
+  <function name="wxSVGPaint::SetICCColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGPaint::SetPaint( wxSVG_PAINTTYPE paintType, const wxString & uri, const wxString & rgbColor, const wxString & iccColor ) -->
+  <function name="wxSVGPaint::SetPaint">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+  </function>
+  <!-- void wxSVGPaint::SetPaintType( const wxSVG_PAINTTYPE & n ) -->
+  <function name="wxSVGPaint::SetPaintType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGPaint::SetRGBColor( const wxRGBColor & rgbColor ) -->
+  <function name="wxSVGPaint::SetRGBColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGPaint::SetUri( const wxString & uri ) -->
+  <function name="wxSVGPaint::SetUri">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGPathElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGPathElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxSVGPathSegArcAbs wxSVGPathElement::CreateSVGPathSegArcAbs( double x, double y, double r1, double r2, double angle, bool largeArcFlag, bool sweepFlag ) const -->
+  <function name="wxSVGPathElement::CreateSVGPathSegArcAbs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPathSegArcAbs"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="7" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxSVGPathSegArcRel wxSVGPathElement::CreateSVGPathSegArcRel( double x, double y, double r1, double r2, double angle, bool largeArcFlag, bool sweepFlag ) const -->
+  <function name="wxSVGPathElement::CreateSVGPathSegArcRel">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPathSegArcRel"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="7" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxSVGPathSegClosePath wxSVGPathElement::CreateSVGPathSegClosePath( void ) const -->
+  <function name="wxSVGPathElement::CreateSVGPathSegClosePath">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPathSegClosePath"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGPathSegCurvetoCubicAbs wxSVGPathElement::CreateSVGPathSegCurvetoCubicAbs( double x, double y, double x1, double y1, double x2, double y2 ) const -->
+  <function name="wxSVGPathElement::CreateSVGPathSegCurvetoCubicAbs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPathSegCurvetoCubicAbs"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGPathSegCurvetoCubicRel wxSVGPathElement::CreateSVGPathSegCurvetoCubicRel( double x, double y, double x1, double y1, double x2, double y2 ) const -->
+  <function name="wxSVGPathElement::CreateSVGPathSegCurvetoCubicRel">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPathSegCurvetoCubicRel"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGPathSegCurvetoCubicSmoothAbs wxSVGPathElement::CreateSVGPathSegCurvetoCubicSmoothAbs( double x, double y, double x2, double y2 ) const -->
+  <function name="wxSVGPathElement::CreateSVGPathSegCurvetoCubicSmoothAbs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPathSegCurvetoCubicSmoothAbs"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGPathSegCurvetoCubicSmoothRel wxSVGPathElement::CreateSVGPathSegCurvetoCubicSmoothRel( double x, double y, double x2, double y2 ) const -->
+  <function name="wxSVGPathElement::CreateSVGPathSegCurvetoCubicSmoothRel">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPathSegCurvetoCubicSmoothRel"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGPathSegCurvetoQuadraticAbs wxSVGPathElement::CreateSVGPathSegCurvetoQuadraticAbs( double x, double y, double x1, double y1 ) const -->
+  <function name="wxSVGPathElement::CreateSVGPathSegCurvetoQuadraticAbs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPathSegCurvetoQuadraticAbs"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGPathSegCurvetoQuadraticRel wxSVGPathElement::CreateSVGPathSegCurvetoQuadraticRel( double x, double y, double x1, double y1 ) const -->
+  <function name="wxSVGPathElement::CreateSVGPathSegCurvetoQuadraticRel">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPathSegCurvetoQuadraticRel"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGPathSegCurvetoQuadraticSmoothAbs wxSVGPathElement::CreateSVGPathSegCurvetoQuadraticSmoothAbs( double x, double y ) const -->
+  <function name="wxSVGPathElement::CreateSVGPathSegCurvetoQuadraticSmoothAbs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPathSegCurvetoQuadraticSmoothAbs"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGPathSegCurvetoQuadraticSmoothRel wxSVGPathElement::CreateSVGPathSegCurvetoQuadraticSmoothRel( double x, double y ) const -->
+  <function name="wxSVGPathElement::CreateSVGPathSegCurvetoQuadraticSmoothRel">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPathSegCurvetoQuadraticSmoothRel"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGPathSegLinetoAbs wxSVGPathElement::CreateSVGPathSegLinetoAbs( double x, double y ) const -->
+  <function name="wxSVGPathElement::CreateSVGPathSegLinetoAbs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPathSegLinetoAbs"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGPathSegLinetoHorizontalAbs wxSVGPathElement::CreateSVGPathSegLinetoHorizontalAbs( double x ) const -->
+  <function name="wxSVGPathElement::CreateSVGPathSegLinetoHorizontalAbs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPathSegLinetoHorizontalAbs"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGPathSegLinetoHorizontalRel wxSVGPathElement::CreateSVGPathSegLinetoHorizontalRel( double x ) const -->
+  <function name="wxSVGPathElement::CreateSVGPathSegLinetoHorizontalRel">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPathSegLinetoHorizontalRel"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGPathSegLinetoRel wxSVGPathElement::CreateSVGPathSegLinetoRel( double x, double y ) const -->
+  <function name="wxSVGPathElement::CreateSVGPathSegLinetoRel">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPathSegLinetoRel"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGPathSegLinetoVerticalAbs wxSVGPathElement::CreateSVGPathSegLinetoVerticalAbs( double y ) const -->
+  <function name="wxSVGPathElement::CreateSVGPathSegLinetoVerticalAbs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPathSegLinetoVerticalAbs"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGPathSegLinetoVerticalRel wxSVGPathElement::CreateSVGPathSegLinetoVerticalRel( double y ) const -->
+  <function name="wxSVGPathElement::CreateSVGPathSegLinetoVerticalRel">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPathSegLinetoVerticalRel"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGPathSegMovetoAbs wxSVGPathElement::CreateSVGPathSegMovetoAbs( double x, double y ) const -->
+  <function name="wxSVGPathElement::CreateSVGPathSegMovetoAbs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPathSegMovetoAbs"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGPathSegMovetoRel wxSVGPathElement::CreateSVGPathSegMovetoRel( double x, double y ) const -->
+  <function name="wxSVGPathElement::CreateSVGPathSegMovetoRel">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPathSegMovetoRel"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxString wxSVGPathElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGPathElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGPathElement::GetAttributes( void ) const -->
+  <function name="wxSVGPathElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGRect wxSVGPathElement::GetBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGPathElement::GetBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGPathElement::GetCTM( void ) -->
+  <function name="wxSVGPathElement::GetCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGCanvasItem * wxSVGPathElement::GetCanvasItem( void ) -->
+  <function name="wxSVGPathElement::GetCanvasItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGCanvasItem *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGPathElement::GetDtd( void ) -->
+  <function name="wxSVGPathElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGPathElement::GetPathLength( void ) -->
+  <function name="wxSVGPathElement::GetPathLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- unsigned long wxSVGPathElement::GetPathSegAtLength( double distance ) -->
+  <function name="wxSVGPathElement::GetPathSegAtLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGPoint wxSVGPathElement::GetPointAtLength( double distance ) -->
+  <function name="wxSVGPathElement::GetPointAtLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPoint"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSVGRect wxSVGPathElement::GetResultBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGPathElement::GetResultBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGPathElement::GetScreenCTM( void ) -->
+  <function name="wxSVGPathElement::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathElement::GetTotalLength( void ) -->
+  <function name="wxSVGPathElement::GetTotalLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGPathElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGPathElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGPathElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGPathElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGPathElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGPathElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGPathElement::SetCanvasItem( wxSVGCanvasItem * canvasItem ) -->
+  <function name="wxSVGPathElement::SetCanvasItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxPATHSEG wxSVGPathSeg::GetPathSegType( void ) -->
+  <function name="wxSVGPathSeg::GetPathSegType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxPATHSEG"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGPathSeg::GetPathSegTypeAsLetter( void ) -->
+  <function name="wxSVGPathSeg::GetPathSegTypeAsLetter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGPathSeg::SetPathSegType( const wxPATHSEG & n ) -->
+  <function name="wxSVGPathSeg::SetPathSegType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGPathSeg::SetPathSegTypeAsLetter( const wxString & n ) -->
+  <function name="wxSVGPathSeg::SetPathSegTypeAsLetter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- double wxSVGPathSegArcAbs::GetAngle( void ) -->
+  <function name="wxSVGPathSegArcAbs::GetAngle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGPathSegArcAbs::GetLargeArcFlag( void ) -->
+  <function name="wxSVGPathSegArcAbs::GetLargeArcFlag">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegArcAbs::GetR1( void ) -->
+  <function name="wxSVGPathSegArcAbs::GetR1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegArcAbs::GetR2( void ) -->
+  <function name="wxSVGPathSegArcAbs::GetR2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGPathSegArcAbs::GetSweepFlag( void ) -->
+  <function name="wxSVGPathSegArcAbs::GetSweepFlag">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegArcAbs::GetX( void ) -->
+  <function name="wxSVGPathSegArcAbs::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegArcAbs::GetY( void ) -->
+  <function name="wxSVGPathSegArcAbs::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGPathSegArcAbs::SetAngle( double n ) -->
+  <function name="wxSVGPathSegArcAbs::SetAngle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegArcAbs::SetLargeArcFlag( bool n ) -->
+  <function name="wxSVGPathSegArcAbs::SetLargeArcFlag">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegArcAbs::SetR1( double n ) -->
+  <function name="wxSVGPathSegArcAbs::SetR1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegArcAbs::SetR2( double n ) -->
+  <function name="wxSVGPathSegArcAbs::SetR2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegArcAbs::SetSweepFlag( bool n ) -->
+  <function name="wxSVGPathSegArcAbs::SetSweepFlag">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegArcAbs::SetX( double n ) -->
+  <function name="wxSVGPathSegArcAbs::SetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegArcAbs::SetY( double n ) -->
+  <function name="wxSVGPathSegArcAbs::SetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- double wxSVGPathSegArcRel::GetAngle( void ) -->
+  <function name="wxSVGPathSegArcRel::GetAngle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGPathSegArcRel::GetLargeArcFlag( void ) -->
+  <function name="wxSVGPathSegArcRel::GetLargeArcFlag">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegArcRel::GetR1( void ) -->
+  <function name="wxSVGPathSegArcRel::GetR1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegArcRel::GetR2( void ) -->
+  <function name="wxSVGPathSegArcRel::GetR2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGPathSegArcRel::GetSweepFlag( void ) -->
+  <function name="wxSVGPathSegArcRel::GetSweepFlag">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegArcRel::GetX( void ) -->
+  <function name="wxSVGPathSegArcRel::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegArcRel::GetY( void ) -->
+  <function name="wxSVGPathSegArcRel::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGPathSegArcRel::SetAngle( double n ) -->
+  <function name="wxSVGPathSegArcRel::SetAngle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegArcRel::SetLargeArcFlag( bool n ) -->
+  <function name="wxSVGPathSegArcRel::SetLargeArcFlag">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegArcRel::SetR1( double n ) -->
+  <function name="wxSVGPathSegArcRel::SetR1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegArcRel::SetR2( double n ) -->
+  <function name="wxSVGPathSegArcRel::SetR2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegArcRel::SetSweepFlag( bool n ) -->
+  <function name="wxSVGPathSegArcRel::SetSweepFlag">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegArcRel::SetX( double n ) -->
+  <function name="wxSVGPathSegArcRel::SetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegArcRel::SetY( double n ) -->
+  <function name="wxSVGPathSegArcRel::SetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- double wxSVGPathSegCurvetoCubicAbs::GetX( void ) -->
+  <function name="wxSVGPathSegCurvetoCubicAbs::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoCubicAbs::GetX1( void ) -->
+  <function name="wxSVGPathSegCurvetoCubicAbs::GetX1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoCubicAbs::GetX2( void ) -->
+  <function name="wxSVGPathSegCurvetoCubicAbs::GetX2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoCubicAbs::GetY( void ) -->
+  <function name="wxSVGPathSegCurvetoCubicAbs::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoCubicAbs::GetY1( void ) -->
+  <function name="wxSVGPathSegCurvetoCubicAbs::GetY1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoCubicAbs::GetY2( void ) -->
+  <function name="wxSVGPathSegCurvetoCubicAbs::GetY2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGPathSegCurvetoCubicAbs::SetX( double n ) -->
+  <function name="wxSVGPathSegCurvetoCubicAbs::SetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoCubicAbs::SetX1( double n ) -->
+  <function name="wxSVGPathSegCurvetoCubicAbs::SetX1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoCubicAbs::SetX2( double n ) -->
+  <function name="wxSVGPathSegCurvetoCubicAbs::SetX2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoCubicAbs::SetY( double n ) -->
+  <function name="wxSVGPathSegCurvetoCubicAbs::SetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoCubicAbs::SetY1( double n ) -->
+  <function name="wxSVGPathSegCurvetoCubicAbs::SetY1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoCubicAbs::SetY2( double n ) -->
+  <function name="wxSVGPathSegCurvetoCubicAbs::SetY2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- double wxSVGPathSegCurvetoCubicRel::GetX( void ) -->
+  <function name="wxSVGPathSegCurvetoCubicRel::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoCubicRel::GetX1( void ) -->
+  <function name="wxSVGPathSegCurvetoCubicRel::GetX1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoCubicRel::GetX2( void ) -->
+  <function name="wxSVGPathSegCurvetoCubicRel::GetX2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoCubicRel::GetY( void ) -->
+  <function name="wxSVGPathSegCurvetoCubicRel::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoCubicRel::GetY1( void ) -->
+  <function name="wxSVGPathSegCurvetoCubicRel::GetY1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoCubicRel::GetY2( void ) -->
+  <function name="wxSVGPathSegCurvetoCubicRel::GetY2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGPathSegCurvetoCubicRel::SetX( double n ) -->
+  <function name="wxSVGPathSegCurvetoCubicRel::SetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoCubicRel::SetX1( double n ) -->
+  <function name="wxSVGPathSegCurvetoCubicRel::SetX1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoCubicRel::SetX2( double n ) -->
+  <function name="wxSVGPathSegCurvetoCubicRel::SetX2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoCubicRel::SetY( double n ) -->
+  <function name="wxSVGPathSegCurvetoCubicRel::SetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoCubicRel::SetY1( double n ) -->
+  <function name="wxSVGPathSegCurvetoCubicRel::SetY1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoCubicRel::SetY2( double n ) -->
+  <function name="wxSVGPathSegCurvetoCubicRel::SetY2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- double wxSVGPathSegCurvetoCubicSmoothAbs::GetX( void ) -->
+  <function name="wxSVGPathSegCurvetoCubicSmoothAbs::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoCubicSmoothAbs::GetX2( void ) -->
+  <function name="wxSVGPathSegCurvetoCubicSmoothAbs::GetX2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoCubicSmoothAbs::GetY( void ) -->
+  <function name="wxSVGPathSegCurvetoCubicSmoothAbs::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoCubicSmoothAbs::GetY2( void ) -->
+  <function name="wxSVGPathSegCurvetoCubicSmoothAbs::GetY2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGPathSegCurvetoCubicSmoothAbs::SetX( double n ) -->
+  <function name="wxSVGPathSegCurvetoCubicSmoothAbs::SetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoCubicSmoothAbs::SetX2( double n ) -->
+  <function name="wxSVGPathSegCurvetoCubicSmoothAbs::SetX2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoCubicSmoothAbs::SetY( double n ) -->
+  <function name="wxSVGPathSegCurvetoCubicSmoothAbs::SetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoCubicSmoothAbs::SetY2( double n ) -->
+  <function name="wxSVGPathSegCurvetoCubicSmoothAbs::SetY2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- double wxSVGPathSegCurvetoCubicSmoothRel::GetX( void ) -->
+  <function name="wxSVGPathSegCurvetoCubicSmoothRel::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoCubicSmoothRel::GetX2( void ) -->
+  <function name="wxSVGPathSegCurvetoCubicSmoothRel::GetX2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoCubicSmoothRel::GetY( void ) -->
+  <function name="wxSVGPathSegCurvetoCubicSmoothRel::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoCubicSmoothRel::GetY2( void ) -->
+  <function name="wxSVGPathSegCurvetoCubicSmoothRel::GetY2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGPathSegCurvetoCubicSmoothRel::SetX( double n ) -->
+  <function name="wxSVGPathSegCurvetoCubicSmoothRel::SetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoCubicSmoothRel::SetX2( double n ) -->
+  <function name="wxSVGPathSegCurvetoCubicSmoothRel::SetX2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoCubicSmoothRel::SetY( double n ) -->
+  <function name="wxSVGPathSegCurvetoCubicSmoothRel::SetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoCubicSmoothRel::SetY2( double n ) -->
+  <function name="wxSVGPathSegCurvetoCubicSmoothRel::SetY2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- double wxSVGPathSegCurvetoQuadraticAbs::GetX( void ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticAbs::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoQuadraticAbs::GetX1( void ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticAbs::GetX1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoQuadraticAbs::GetY( void ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticAbs::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoQuadraticAbs::GetY1( void ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticAbs::GetY1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGPathSegCurvetoQuadraticAbs::SetX( double n ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticAbs::SetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoQuadraticAbs::SetX1( double n ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticAbs::SetX1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoQuadraticAbs::SetY( double n ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticAbs::SetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoQuadraticAbs::SetY1( double n ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticAbs::SetY1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- double wxSVGPathSegCurvetoQuadraticRel::GetX( void ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticRel::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoQuadraticRel::GetX1( void ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticRel::GetX1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoQuadraticRel::GetY( void ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticRel::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoQuadraticRel::GetY1( void ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticRel::GetY1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGPathSegCurvetoQuadraticRel::SetX( double n ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticRel::SetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoQuadraticRel::SetX1( double n ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticRel::SetX1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoQuadraticRel::SetY( double n ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticRel::SetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoQuadraticRel::SetY1( double n ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticRel::SetY1">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- double wxSVGPathSegCurvetoQuadraticSmoothAbs::GetX( void ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticSmoothAbs::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoQuadraticSmoothAbs::GetY( void ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticSmoothAbs::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGPathSegCurvetoQuadraticSmoothAbs::SetX( double n ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticSmoothAbs::SetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoQuadraticSmoothAbs::SetY( double n ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticSmoothAbs::SetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- double wxSVGPathSegCurvetoQuadraticSmoothRel::GetX( void ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticSmoothRel::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegCurvetoQuadraticSmoothRel::GetY( void ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticSmoothRel::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGPathSegCurvetoQuadraticSmoothRel::SetX( double n ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticSmoothRel::SetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegCurvetoQuadraticSmoothRel::SetY( double n ) -->
+  <function name="wxSVGPathSegCurvetoQuadraticSmoothRel::SetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- double wxSVGPathSegLinetoAbs::GetX( void ) -->
+  <function name="wxSVGPathSegLinetoAbs::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegLinetoAbs::GetY( void ) -->
+  <function name="wxSVGPathSegLinetoAbs::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGPathSegLinetoAbs::SetX( double n ) -->
+  <function name="wxSVGPathSegLinetoAbs::SetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegLinetoAbs::SetY( double n ) -->
+  <function name="wxSVGPathSegLinetoAbs::SetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- double wxSVGPathSegLinetoHorizontalAbs::GetX( void ) -->
+  <function name="wxSVGPathSegLinetoHorizontalAbs::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGPathSegLinetoHorizontalAbs::SetX( double n ) -->
+  <function name="wxSVGPathSegLinetoHorizontalAbs::SetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- double wxSVGPathSegLinetoHorizontalRel::GetX( void ) -->
+  <function name="wxSVGPathSegLinetoHorizontalRel::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGPathSegLinetoHorizontalRel::SetX( double n ) -->
+  <function name="wxSVGPathSegLinetoHorizontalRel::SetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- double wxSVGPathSegLinetoRel::GetX( void ) -->
+  <function name="wxSVGPathSegLinetoRel::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegLinetoRel::GetY( void ) -->
+  <function name="wxSVGPathSegLinetoRel::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGPathSegLinetoRel::SetX( double n ) -->
+  <function name="wxSVGPathSegLinetoRel::SetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegLinetoRel::SetY( double n ) -->
+  <function name="wxSVGPathSegLinetoRel::SetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- double wxSVGPathSegLinetoVerticalAbs::GetY( void ) -->
+  <function name="wxSVGPathSegLinetoVerticalAbs::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGPathSegLinetoVerticalAbs::SetY( double n ) -->
+  <function name="wxSVGPathSegLinetoVerticalAbs::SetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- double wxSVGPathSegLinetoVerticalRel::GetY( void ) -->
+  <function name="wxSVGPathSegLinetoVerticalRel::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGPathSegLinetoVerticalRel::SetY( double n ) -->
+  <function name="wxSVGPathSegLinetoVerticalRel::SetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegList::DoCopy( const wxSVGPathSegList & src ) -->
+  <function name="wxSVGPathSegList::DoCopy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxString wxSVGPathSegList::GetValueAsString( void ) const -->
+  <function name="wxSVGPathSegList::GetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void wxSVGPathSegList::SetValueAsString( const wxString & value ) -->
+  <function name="wxSVGPathSegList::SetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- double wxSVGPathSegMovetoAbs::GetX( void ) -->
+  <function name="wxSVGPathSegMovetoAbs::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegMovetoAbs::GetY( void ) -->
+  <function name="wxSVGPathSegMovetoAbs::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGPathSegMovetoAbs::SetX( double n ) -->
+  <function name="wxSVGPathSegMovetoAbs::SetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegMovetoAbs::SetY( double n ) -->
+  <function name="wxSVGPathSegMovetoAbs::SetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- double wxSVGPathSegMovetoRel::GetX( void ) -->
+  <function name="wxSVGPathSegMovetoRel::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPathSegMovetoRel::GetY( void ) -->
+  <function name="wxSVGPathSegMovetoRel::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGPathSegMovetoRel::SetX( double n ) -->
+  <function name="wxSVGPathSegMovetoRel::SetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPathSegMovetoRel::SetY( double n ) -->
+  <function name="wxSVGPathSegMovetoRel::SetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGPatternElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGPatternElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGPatternElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGPatternElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGPatternElement::GetAttributes( void ) const -->
+  <function name="wxSVGPatternElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGPatternElement::GetDtd( void ) -->
+  <function name="wxSVGPatternElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGPatternElement::GetHeight( void ) -->
+  <function name="wxSVGPatternElement::GetHeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGPatternElement::GetPatternContentUnits( void ) -->
+  <function name="wxSVGPatternElement::GetPatternContentUnits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedTransformList & wxSVGPatternElement::GetPatternTransform( void ) -->
+  <function name="wxSVGPatternElement::GetPatternTransform">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedTransformList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGPatternElement::GetPatternUnits( void ) -->
+  <function name="wxSVGPatternElement::GetPatternUnits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGPatternElement::GetWidth( void ) -->
+  <function name="wxSVGPatternElement::GetWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGPatternElement::GetX( void ) -->
+  <function name="wxSVGPatternElement::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGPatternElement::GetY( void ) -->
+  <function name="wxSVGPatternElement::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGPatternElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGPatternElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGPatternElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGPatternElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGPatternElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGPatternElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- double wxSVGPoint::GetX( void ) -->
+  <function name="wxSVGPoint::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGPoint::GetY( void ) -->
+  <function name="wxSVGPoint::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGPoint wxSVGPoint::MatrixTransform( const wxSVGMatrix & matrix ) const -->
+  <function name="wxSVGPoint::MatrixTransform">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPoint"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGPoint::SetX( double n ) -->
+  <function name="wxSVGPoint::SetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGPoint::SetY( double n ) -->
+  <function name="wxSVGPoint::SetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxString wxSVGPointList::GetValueAsString( void ) const -->
+  <function name="wxSVGPointList::GetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void wxSVGPointList::SetValueAsString( const wxString & value ) -->
+  <function name="wxSVGPointList::SetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGPolygonElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGPolygonElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGPolygonElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGPolygonElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGPolygonElement::GetAttributes( void ) const -->
+  <function name="wxSVGPolygonElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGRect wxSVGPolygonElement::GetBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGPolygonElement::GetBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGPolygonElement::GetCTM( void ) -->
+  <function name="wxSVGPolygonElement::GetCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGCanvasItem * wxSVGPolygonElement::GetCanvasItem( void ) -->
+  <function name="wxSVGPolygonElement::GetCanvasItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGCanvasItem *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGPolygonElement::GetDtd( void ) -->
+  <function name="wxSVGPolygonElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGRect wxSVGPolygonElement::GetResultBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGPolygonElement::GetResultBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGPolygonElement::GetScreenCTM( void ) -->
+  <function name="wxSVGPolygonElement::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGPolygonElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGPolygonElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGPolygonElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGPolygonElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGPolygonElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGPolygonElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGPolygonElement::SetCanvasItem( wxSVGCanvasItem * canvasItem ) -->
+  <function name="wxSVGPolygonElement::SetCanvasItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGPolylineElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGPolylineElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGPolylineElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGPolylineElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGPolylineElement::GetAttributes( void ) const -->
+  <function name="wxSVGPolylineElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGRect wxSVGPolylineElement::GetBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGPolylineElement::GetBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGPolylineElement::GetCTM( void ) -->
+  <function name="wxSVGPolylineElement::GetCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGCanvasItem * wxSVGPolylineElement::GetCanvasItem( void ) -->
+  <function name="wxSVGPolylineElement::GetCanvasItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGCanvasItem *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGPolylineElement::GetDtd( void ) -->
+  <function name="wxSVGPolylineElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGRect wxSVGPolylineElement::GetResultBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGPolylineElement::GetResultBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGPolylineElement::GetScreenCTM( void ) -->
+  <function name="wxSVGPolylineElement::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGPolylineElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGPolylineElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGPolylineElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGPolylineElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGPolylineElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGPolylineElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGPolylineElement::SetCanvasItem( wxSVGCanvasItem * canvasItem ) -->
+  <function name="wxSVGPolylineElement::SetCanvasItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxSVG_PRESERVEASPECTRATIO wxSVGPreserveAspectRatio::GetAlign( void ) -->
+  <function name="wxSVGPreserveAspectRatio::GetAlign">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVG_PRESERVEASPECTRATIO"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVG_MEETORSLICE wxSVGPreserveAspectRatio::GetMeetOrSlice( void ) -->
+  <function name="wxSVGPreserveAspectRatio::GetMeetOrSlice">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVG_MEETORSLICE"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSVGPreserveAspectRatio::GetValueAsString( void ) const -->
+  <function name="wxSVGPreserveAspectRatio::GetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void wxSVGPreserveAspectRatio::SetAlign( const wxSVG_PRESERVEASPECTRATIO & n ) -->
+  <function name="wxSVGPreserveAspectRatio::SetAlign">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGPreserveAspectRatio::SetMeetOrSlice( const wxSVG_MEETORSLICE & n ) -->
+  <function name="wxSVGPreserveAspectRatio::SetMeetOrSlice">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGPreserveAspectRatio::SetValueAsString( const wxString & value ) -->
+  <function name="wxSVGPreserveAspectRatio::SetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGRadialGradientElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGRadialGradientElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGRadialGradientElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGRadialGradientElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGRadialGradientElement::GetAttributes( void ) const -->
+  <function name="wxSVGRadialGradientElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGRadialGradientElement::GetCx( void ) -->
+  <function name="wxSVGRadialGradientElement::GetCx">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGRadialGradientElement::GetCy( void ) -->
+  <function name="wxSVGRadialGradientElement::GetCy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGRadialGradientElement::GetDtd( void ) -->
+  <function name="wxSVGRadialGradientElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGRadialGradientElement::GetFx( void ) -->
+  <function name="wxSVGRadialGradientElement::GetFx">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGRadialGradientElement::GetFy( void ) -->
+  <function name="wxSVGRadialGradientElement::GetFy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGRadialGradientElement::GetQualifiedCx( void ) const -->
+  <function name="wxSVGRadialGradientElement::GetQualifiedCx">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- double wxSVGRadialGradientElement::GetQualifiedCy( void ) const -->
+  <function name="wxSVGRadialGradientElement::GetQualifiedCy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- double wxSVGRadialGradientElement::GetQualifiedFx( void ) const -->
+  <function name="wxSVGRadialGradientElement::GetQualifiedFx">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- double wxSVGRadialGradientElement::GetQualifiedFy( void ) const -->
+  <function name="wxSVGRadialGradientElement::GetQualifiedFy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- double wxSVGRadialGradientElement::GetQualifiedR( void ) const -->
+  <function name="wxSVGRadialGradientElement::GetQualifiedR">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGRadialGradientElement::GetR( void ) -->
+  <function name="wxSVGRadialGradientElement::GetR">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGRadialGradientElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGRadialGradientElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGRadialGradientElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGRadialGradientElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGRadialGradientElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGRadialGradientElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGRect::Clear( void ) -->
+  <function name="wxSVGRect::Clear">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- double wxSVGRect::GetHeight( void ) -->
+  <function name="wxSVGRect::GetHeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSVGRect::GetValueAsString( void ) const -->
+  <function name="wxSVGRect::GetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- double wxSVGRect::GetWidth( void ) -->
+  <function name="wxSVGRect::GetWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGRect::GetX( void ) -->
+  <function name="wxSVGRect::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGRect::GetY( void ) -->
+  <function name="wxSVGRect::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGRect::IsEmpty( void ) -->
+  <function name="wxSVGRect::IsEmpty">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGRect wxSVGRect::MatrixTransform( const wxSVGMatrix & matrix ) const -->
+  <function name="wxSVGRect::MatrixTransform">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGRect::SetHeight( double n ) -->
+  <function name="wxSVGRect::SetHeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGRect::SetValueAsString( const wxString & value ) -->
+  <function name="wxSVGRect::SetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGRect::SetWidth( double n ) -->
+  <function name="wxSVGRect::SetWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGRect::SetX( double n ) -->
+  <function name="wxSVGRect::SetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGRect::SetY( double n ) -->
+  <function name="wxSVGRect::SetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGRectElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGRectElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGRectElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGRectElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGRectElement::GetAttributes( void ) const -->
+  <function name="wxSVGRectElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGRect wxSVGRectElement::GetBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGRectElement::GetBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGRectElement::GetCTM( void ) -->
+  <function name="wxSVGRectElement::GetCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGCanvasItem * wxSVGRectElement::GetCanvasItem( void ) -->
+  <function name="wxSVGRectElement::GetCanvasItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGCanvasItem *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGRectElement::GetDtd( void ) -->
+  <function name="wxSVGRectElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGRectElement::GetHeight( void ) -->
+  <function name="wxSVGRectElement::GetHeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGRect wxSVGRectElement::GetResultBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGRectElement::GetResultBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGRectElement::GetRx( void ) -->
+  <function name="wxSVGRectElement::GetRx">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGRectElement::GetRy( void ) -->
+  <function name="wxSVGRectElement::GetRy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGMatrix wxSVGRectElement::GetScreenCTM( void ) -->
+  <function name="wxSVGRectElement::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGRectElement::GetWidth( void ) -->
+  <function name="wxSVGRectElement::GetWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGRectElement::GetX( void ) -->
+  <function name="wxSVGRectElement::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGRectElement::GetY( void ) -->
+  <function name="wxSVGRectElement::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGRectElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGRectElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGRectElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGRectElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGRectElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGRectElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGRectElement::SetCanvasItem( wxSVGCanvasItem * canvasItem ) -->
+  <function name="wxSVGRectElement::SetCanvasItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool wxSVGSVGElement::AnimationsPaused( void ) -->
+  <function name="wxSVGSVGElement::AnimationsPaused">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGSVGElement::CheckEnclosure( const wxSVGElement & element, const wxSVGRect & rect ) -->
+  <function name="wxSVGSVGElement::CheckEnclosure">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGSVGElement::CheckIntersection( const wxSVGElement & element, const wxSVGRect & rect ) -->
+  <function name="wxSVGSVGElement::CheckIntersection">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGSVGElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGSVGElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxSVGAngle wxSVGSVGElement::CreateSVGAngle( void ) const -->
+  <function name="wxSVGSVGElement::CreateSVGAngle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGAngle"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGLength wxSVGSVGElement::CreateSVGLength( void ) const -->
+  <function name="wxSVGSVGElement::CreateSVGLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGLength"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGMatrix wxSVGSVGElement::CreateSVGMatrix( void ) const -->
+  <function name="wxSVGSVGElement::CreateSVGMatrix">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGNumber wxSVGSVGElement::CreateSVGNumber( void ) const -->
+  <function name="wxSVGSVGElement::CreateSVGNumber">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGNumber"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGPoint wxSVGSVGElement::CreateSVGPoint( void ) const -->
+  <function name="wxSVGSVGElement::CreateSVGPoint">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPoint"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGRect wxSVGSVGElement::CreateSVGRect( void ) const -->
+  <function name="wxSVGSVGElement::CreateSVGRect">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGTransform wxSVGSVGElement::CreateSVGTransform( void ) const -->
+  <function name="wxSVGSVGElement::CreateSVGTransform">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGTransform"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGTransform wxSVGSVGElement::CreateSVGTransformFromMatrix( const wxSVGMatrix & matrix ) const -->
+  <function name="wxSVGSVGElement::CreateSVGTransformFromMatrix">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGTransform"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGSVGElement::DeselectAll( void ) -->
+  <function name="wxSVGSVGElement::DeselectAll">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxSVGSVGElement::ForceRedraw( void ) -->
+  <function name="wxSVGSVGElement::ForceRedraw">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- wxString wxSVGSVGElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGSVGElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGSVGElement::GetAttributes( void ) const -->
+  <function name="wxSVGSVGElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGRect wxSVGSVGElement::GetBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGSVGElement::GetBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGSVGElement::GetCTM( void ) -->
+  <function name="wxSVGSVGElement::GetCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGSVGElement::GetContentScriptType( void ) -->
+  <function name="wxSVGSVGElement::GetContentScriptType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGSVGElement::GetContentStyleType( void ) -->
+  <function name="wxSVGSVGElement::GetContentStyleType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGSVGElement::GetCurrentScale( void ) -->
+  <function name="wxSVGSVGElement::GetCurrentScale">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGSVGElement::GetCurrentTime( void ) -->
+  <function name="wxSVGSVGElement::GetCurrentTime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGPoint & wxSVGSVGElement::GetCurrentTranslate( void ) -->
+  <function name="wxSVGSVGElement::GetCurrentTranslate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGPoint &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGViewSpec & wxSVGSVGElement::GetCurrentView( void ) -->
+  <function name="wxSVGSVGElement::GetCurrentView">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGViewSpec &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGSVGElement::GetDtd( void ) -->
+  <function name="wxSVGSVGElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- wxSvgXmlElement * wxSVGSVGElement::GetElementById( const wxString & elementId ) const -->
+  <function name="wxSVGSVGElement::GetElementById">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlElement *"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxNodeList wxSVGSVGElement::GetEnclosureList( const wxSVGRect & rect, const wxSVGElement & referenceElement ) -->
+  <function name="wxSVGSVGElement::GetEnclosureList">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxNodeList"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGSVGElement::GetHeight( void ) -->
+  <function name="wxSVGSVGElement::GetHeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxNodeList wxSVGSVGElement::GetIntersectionList( const wxSVGRect & rect, const wxSVGElement & referenceElement ) -->
+  <function name="wxSVGSVGElement::GetIntersectionList">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxNodeList"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- double wxSVGSVGElement::GetPixelUnitToMillimeterX( void ) -->
+  <function name="wxSVGSVGElement::GetPixelUnitToMillimeterX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGSVGElement::GetPixelUnitToMillimeterY( void ) -->
+  <function name="wxSVGSVGElement::GetPixelUnitToMillimeterY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGRect wxSVGSVGElement::GetResultBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGSVGElement::GetResultBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGSVGElement::GetScreenCTM( void ) -->
+  <function name="wxSVGSVGElement::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGSVGElement::GetScreenPixelToMillimeterX( void ) -->
+  <function name="wxSVGSVGElement::GetScreenPixelToMillimeterX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGSVGElement::GetScreenPixelToMillimeterY( void ) -->
+  <function name="wxSVGSVGElement::GetScreenPixelToMillimeterY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGSVGElement::GetUseCurrentView( void ) -->
+  <function name="wxSVGSVGElement::GetUseCurrentView">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGRect & wxSVGSVGElement::GetViewport( void ) -->
+  <function name="wxSVGSVGElement::GetViewport">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGRect &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGSVGElement::GetWidth( void ) -->
+  <function name="wxSVGSVGElement::GetWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGSVGElement::GetX( void ) -->
+  <function name="wxSVGSVGElement::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGSVGElement::GetY( void ) -->
+  <function name="wxSVGSVGElement::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGSVGElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGSVGElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGSVGElement::PauseAnimations( void ) -->
+  <function name="wxSVGSVGElement::PauseAnimations">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- bool wxSVGSVGElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGSVGElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGSVGElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGSVGElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGSVGElement::SetContentScriptType( const wxString & n ) -->
+  <function name="wxSVGSVGElement::SetContentScriptType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGSVGElement::SetContentStyleType( const wxString & n ) -->
+  <function name="wxSVGSVGElement::SetContentStyleType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGSVGElement::SetCurrentScale( double n ) -->
+  <function name="wxSVGSVGElement::SetCurrentScale">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGSVGElement::SetCurrentTime( double seconds ) -->
+  <function name="wxSVGSVGElement::SetCurrentTime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGSVGElement::SetCurrentTranslate( const wxSVGPoint & n ) -->
+  <function name="wxSVGSVGElement::SetCurrentTranslate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGSVGElement::SetCurrentView( const wxSVGViewSpec & n ) -->
+  <function name="wxSVGSVGElement::SetCurrentView">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGSVGElement::SetPixelUnitToMillimeterX( double n ) -->
+  <function name="wxSVGSVGElement::SetPixelUnitToMillimeterX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGSVGElement::SetPixelUnitToMillimeterY( double n ) -->
+  <function name="wxSVGSVGElement::SetPixelUnitToMillimeterY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGSVGElement::SetScreenPixelToMillimeterX( double n ) -->
+  <function name="wxSVGSVGElement::SetScreenPixelToMillimeterX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGSVGElement::SetScreenPixelToMillimeterY( double n ) -->
+  <function name="wxSVGSVGElement::SetScreenPixelToMillimeterY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGSVGElement::SetUseCurrentView( bool n ) -->
+  <function name="wxSVGSVGElement::SetUseCurrentView">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSVGSVGElement::SetViewport( const wxSVGRect & n ) -->
+  <function name="wxSVGSVGElement::SetViewport">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- unsigned long wxSVGSVGElement::SuspendRedraw( unsigned long max_wait_milliseconds ) -->
+  <function name="wxSVGSVGElement::SuspendRedraw">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned long"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void wxSVGSVGElement::UnpauseAnimations( void ) -->
+  <function name="wxSVGSVGElement::UnpauseAnimations">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxSVGSVGElement::UnsuspendRedraw( unsigned long suspend_handle_id ) -->
+  <function name="wxSVGSVGElement::UnsuspendRedraw">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void wxSVGSVGElement::UnsuspendRedrawAll( void ) -->
+  <function name="wxSVGSVGElement::UnsuspendRedrawAll">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxSVGSVGElement::UpdateMatrix( wxSVGMatrix & matrix ) -->
+  <function name="wxSVGSVGElement::UpdateMatrix">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGScriptElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGScriptElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGScriptElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGScriptElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGScriptElement::GetAttributes( void ) const -->
+  <function name="wxSVGScriptElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGScriptElement::GetDtd( void ) -->
+  <function name="wxSVGScriptElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGScriptElement::GetType( void ) -->
+  <function name="wxSVGScriptElement::GetType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGScriptElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGScriptElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGScriptElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGScriptElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGScriptElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGScriptElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGScriptElement::SetType( const wxString & n ) -->
+  <function name="wxSVGScriptElement::SetType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGSetElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGSetElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGSetElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGSetElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGSetElement::GetAttributes( void ) const -->
+  <function name="wxSVGSetElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGSetElement::GetDtd( void ) -->
+  <function name="wxSVGSetElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGSetElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGSetElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGSetElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGSetElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGStopElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGStopElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGStopElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGStopElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGStopElement::GetAttributes( void ) const -->
+  <function name="wxSVGStopElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGStopElement::GetDtd( void ) -->
+  <function name="wxSVGStopElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumber & wxSVGStopElement::GetOffset( void ) -->
+  <function name="wxSVGStopElement::GetOffset">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumber &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStopElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGStopElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGStopElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGStopElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGStopElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGStopElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetAlignmentBaseline( void ) -->
+  <function name="wxSVGStylable::GetAlignmentBaseline">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSStyleDeclaration & wxSVGStylable::GetAnimStyle( void ) -->
+  <function name="wxSVGStylable::GetAnimStyle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSStyleDeclaration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSVGStylable::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGStylable::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGStylable::GetAttributes( void ) const -->
+  <function name="wxSVGStylable::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxSVGStylable::GetBaselineShift( void ) -->
+  <function name="wxSVGStylable::GetBaselineShift">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedString & wxSVGStylable::GetClassName( void ) -->
+  <function name="wxSVGStylable::GetClassName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxSVGStylable::GetClip( void ) -->
+  <function name="wxSVGStylable::GetClip">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxSVGStylable::GetClipPath( void ) -->
+  <function name="wxSVGStylable::GetClipPath">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetClipRule( void ) -->
+  <function name="wxSVGStylable::GetClipRule">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxRGBColor wxSVGStylable::GetColor( void ) -->
+  <function name="wxSVGStylable::GetColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxRGBColor"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetColorInterpolation( void ) -->
+  <function name="wxSVGStylable::GetColorInterpolation">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetColorInterpolationFilters( void ) -->
+  <function name="wxSVGStylable::GetColorInterpolationFilters">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxSVGStylable::GetColorProfile( void ) -->
+  <function name="wxSVGStylable::GetColorProfile">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetColorRendering( void ) -->
+  <function name="wxSVGStylable::GetColorRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxSVGStylable::GetCursor( void ) -->
+  <function name="wxSVGStylable::GetCursor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSVGStylable::GetCustomAttribute( const wxString & name ) const -->
+  <function name="wxSVGStylable::GetCustomAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGStylable::GetCustomAttributes( void ) const -->
+  <function name="wxSVGStylable::GetCustomAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetDirection( void ) -->
+  <function name="wxSVGStylable::GetDirection">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetDisplay( void ) -->
+  <function name="wxSVGStylable::GetDisplay">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetDominantBaseline( void ) -->
+  <function name="wxSVGStylable::GetDominantBaseline">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSStyleDeclaration & wxSVGStylable::GetElementStyle( const wxSVGElement & element ) -->
+  <function name="wxSVGStylable::GetElementStyle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSStyleDeclaration &amp;"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetEnableBackground( void ) -->
+  <function name="wxSVGStylable::GetEnableBackground">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGPaint & wxSVGStylable::GetFill( void ) -->
+  <function name="wxSVGStylable::GetFill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGPaint &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGStylable::GetFillOpacity( void ) -->
+  <function name="wxSVGStylable::GetFillOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetFillRule( void ) -->
+  <function name="wxSVGStylable::GetFillRule">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxSVGStylable::GetFilter( void ) -->
+  <function name="wxSVGStylable::GetFilter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGColor & wxSVGStylable::GetFloodColor( void ) -->
+  <function name="wxSVGStylable::GetFloodColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGColor &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGStylable::GetFloodOpacity( void ) -->
+  <function name="wxSVGStylable::GetFloodOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSVGStylable::GetFontFamily( void ) -->
+  <function name="wxSVGStylable::GetFontFamily">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGStylable::GetFontSize( void ) -->
+  <function name="wxSVGStylable::GetFontSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxSVGStylable::GetFontSizeAdjust( void ) -->
+  <function name="wxSVGStylable::GetFontSizeAdjust">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetFontStretch( void ) -->
+  <function name="wxSVGStylable::GetFontStretch">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetFontStyle( void ) -->
+  <function name="wxSVGStylable::GetFontStyle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetFontVariant( void ) -->
+  <function name="wxSVGStylable::GetFontVariant">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetFontWeight( void ) -->
+  <function name="wxSVGStylable::GetFontWeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGStylable::GetGlyphOrientationHorizontal( void ) -->
+  <function name="wxSVGStylable::GetGlyphOrientationHorizontal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxSVGStylable::GetGlyphOrientationVertical( void ) -->
+  <function name="wxSVGStylable::GetGlyphOrientationVertical">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetImageRendering( void ) -->
+  <function name="wxSVGStylable::GetImageRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxSVGStylable::GetKerning( void ) -->
+  <function name="wxSVGStylable::GetKerning">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxSVGStylable::GetLetterSpacing( void ) -->
+  <function name="wxSVGStylable::GetLetterSpacing">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGColor & wxSVGStylable::GetLightingColor( void ) -->
+  <function name="wxSVGStylable::GetLightingColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGColor &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxSVGStylable::GetMarkerEnd( void ) -->
+  <function name="wxSVGStylable::GetMarkerEnd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxSVGStylable::GetMarkerMid( void ) -->
+  <function name="wxSVGStylable::GetMarkerMid">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxSVGStylable::GetMarkerStart( void ) -->
+  <function name="wxSVGStylable::GetMarkerStart">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxSVGStylable::GetMask( void ) -->
+  <function name="wxSVGStylable::GetMask">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGStylable::GetOpacity( void ) -->
+  <function name="wxSVGStylable::GetOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetOverflow( void ) -->
+  <function name="wxSVGStylable::GetOverflow">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetPointerEvents( void ) -->
+  <function name="wxSVGStylable::GetPointerEvents">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSValue & wxSVGStylable::GetPresentationAttribute( const wxString & name ) -->
+  <function name="wxSVGStylable::GetPresentationAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSValue &amp;"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxCSSStyleDeclaration wxSVGStylable::GetResultStyle( const wxSVGElement & element ) -->
+  <function name="wxSVGStylable::GetResultStyle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSSStyleDeclaration"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetShapeRendering( void ) -->
+  <function name="wxSVGStylable::GetShapeRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGColor & wxSVGStylable::GetStopColor( void ) -->
+  <function name="wxSVGStylable::GetStopColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGColor &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGStylable::GetStopOpacity( void ) -->
+  <function name="wxSVGStylable::GetStopOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGPaint & wxSVGStylable::GetStroke( void ) -->
+  <function name="wxSVGStylable::GetStroke">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGPaint &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSValueList & wxSVGStylable::GetStrokeDasharray( void ) -->
+  <function name="wxSVGStylable::GetStrokeDasharray">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSValueList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGStylable::GetStrokeDashoffset( void ) -->
+  <function name="wxSVGStylable::GetStrokeDashoffset">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetStrokeLinecap( void ) -->
+  <function name="wxSVGStylable::GetStrokeLinecap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetStrokeLinejoin( void ) -->
+  <function name="wxSVGStylable::GetStrokeLinejoin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGStylable::GetStrokeMiterlimit( void ) -->
+  <function name="wxSVGStylable::GetStrokeMiterlimit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGStylable::GetStrokeOpacity( void ) -->
+  <function name="wxSVGStylable::GetStrokeOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGStylable::GetStrokeWidth( void ) -->
+  <function name="wxSVGStylable::GetStrokeWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSStyleDeclaration & wxSVGStylable::GetStyle( void ) -->
+  <function name="wxSVGStylable::GetStyle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSStyleDeclaration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetTextAnchor( void ) -->
+  <function name="wxSVGStylable::GetTextAnchor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetTextDecoration( void ) -->
+  <function name="wxSVGStylable::GetTextDecoration">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetTextRendering( void ) -->
+  <function name="wxSVGStylable::GetTextRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetUnicodeBidi( void ) -->
+  <function name="wxSVGStylable::GetUnicodeBidi">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetVisibility( void ) -->
+  <function name="wxSVGStylable::GetVisibility">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- const wxCSSPrimitiveValue & wxSVGStylable::GetWordSpacing( void ) -->
+  <function name="wxSVGStylable::GetWordSpacing">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxCSSPrimitiveValue &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxCSS_VALUE wxSVGStylable::GetWritingMode( void ) -->
+  <function name="wxSVGStylable::GetWritingMode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxCSS_VALUE"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasAlignmentBaseline( void ) -->
+  <function name="wxSVGStylable::HasAlignmentBaseline">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGStylable::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGStylable::HasBaselineShift( void ) -->
+  <function name="wxSVGStylable::HasBaselineShift">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasClip( void ) -->
+  <function name="wxSVGStylable::HasClip">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasClipPath( void ) -->
+  <function name="wxSVGStylable::HasClipPath">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasClipRule( void ) -->
+  <function name="wxSVGStylable::HasClipRule">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasColor( void ) -->
+  <function name="wxSVGStylable::HasColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasColorInterpolation( void ) -->
+  <function name="wxSVGStylable::HasColorInterpolation">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasColorInterpolationFilters( void ) -->
+  <function name="wxSVGStylable::HasColorInterpolationFilters">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasColorProfile( void ) -->
+  <function name="wxSVGStylable::HasColorProfile">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasColorRendering( void ) -->
+  <function name="wxSVGStylable::HasColorRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasCursor( void ) -->
+  <function name="wxSVGStylable::HasCursor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasCustomAttribute( const wxString & name ) const -->
+  <function name="wxSVGStylable::HasCustomAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGStylable::HasDirection( void ) -->
+  <function name="wxSVGStylable::HasDirection">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasDisplay( void ) -->
+  <function name="wxSVGStylable::HasDisplay">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasDominantBaseline( void ) -->
+  <function name="wxSVGStylable::HasDominantBaseline">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasEnableBackground( void ) -->
+  <function name="wxSVGStylable::HasEnableBackground">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasFill( void ) -->
+  <function name="wxSVGStylable::HasFill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasFillOpacity( void ) -->
+  <function name="wxSVGStylable::HasFillOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasFillRule( void ) -->
+  <function name="wxSVGStylable::HasFillRule">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasFilter( void ) -->
+  <function name="wxSVGStylable::HasFilter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasFloodColor( void ) -->
+  <function name="wxSVGStylable::HasFloodColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasFloodOpacity( void ) -->
+  <function name="wxSVGStylable::HasFloodOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasFontFamily( void ) -->
+  <function name="wxSVGStylable::HasFontFamily">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasFontSize( void ) -->
+  <function name="wxSVGStylable::HasFontSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasFontSizeAdjust( void ) -->
+  <function name="wxSVGStylable::HasFontSizeAdjust">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasFontStretch( void ) -->
+  <function name="wxSVGStylable::HasFontStretch">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasFontStyle( void ) -->
+  <function name="wxSVGStylable::HasFontStyle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasFontVariant( void ) -->
+  <function name="wxSVGStylable::HasFontVariant">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasFontWeight( void ) -->
+  <function name="wxSVGStylable::HasFontWeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasGlyphOrientationHorizontal( void ) -->
+  <function name="wxSVGStylable::HasGlyphOrientationHorizontal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasGlyphOrientationVertical( void ) -->
+  <function name="wxSVGStylable::HasGlyphOrientationVertical">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasImageRendering( void ) -->
+  <function name="wxSVGStylable::HasImageRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasKerning( void ) -->
+  <function name="wxSVGStylable::HasKerning">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasLetterSpacing( void ) -->
+  <function name="wxSVGStylable::HasLetterSpacing">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasLightingColor( void ) -->
+  <function name="wxSVGStylable::HasLightingColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasMarkerEnd( void ) -->
+  <function name="wxSVGStylable::HasMarkerEnd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasMarkerMid( void ) -->
+  <function name="wxSVGStylable::HasMarkerMid">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasMarkerStart( void ) -->
+  <function name="wxSVGStylable::HasMarkerStart">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasMask( void ) -->
+  <function name="wxSVGStylable::HasMask">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasOpacity( void ) -->
+  <function name="wxSVGStylable::HasOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasOverflow( void ) -->
+  <function name="wxSVGStylable::HasOverflow">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasPointerEvents( void ) -->
+  <function name="wxSVGStylable::HasPointerEvents">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasShapeRendering( void ) -->
+  <function name="wxSVGStylable::HasShapeRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasStopColor( void ) -->
+  <function name="wxSVGStylable::HasStopColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasStopOpacity( void ) -->
+  <function name="wxSVGStylable::HasStopOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasStroke( void ) -->
+  <function name="wxSVGStylable::HasStroke">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasStrokeDasharray( void ) -->
+  <function name="wxSVGStylable::HasStrokeDasharray">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasStrokeDashoffset( void ) -->
+  <function name="wxSVGStylable::HasStrokeDashoffset">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasStrokeLinecap( void ) -->
+  <function name="wxSVGStylable::HasStrokeLinecap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasStrokeLinejoin( void ) -->
+  <function name="wxSVGStylable::HasStrokeLinejoin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasStrokeMiterlimit( void ) -->
+  <function name="wxSVGStylable::HasStrokeMiterlimit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasStrokeOpacity( void ) -->
+  <function name="wxSVGStylable::HasStrokeOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasStrokeWidth( void ) -->
+  <function name="wxSVGStylable::HasStrokeWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasTextAnchor( void ) -->
+  <function name="wxSVGStylable::HasTextAnchor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasTextDecoration( void ) -->
+  <function name="wxSVGStylable::HasTextDecoration">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasTextRendering( void ) -->
+  <function name="wxSVGStylable::HasTextRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasUnicodeBidi( void ) -->
+  <function name="wxSVGStylable::HasUnicodeBidi">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasVisibility( void ) -->
+  <function name="wxSVGStylable::HasVisibility">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasWordSpacing( void ) -->
+  <function name="wxSVGStylable::HasWordSpacing">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStylable::HasWritingMode( void ) -->
+  <function name="wxSVGStylable::HasWritingMode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGStylable::SetAlignmentBaseline( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetAlignmentBaseline">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetAnimStyle( const wxCSSStyleDeclaration & n ) -->
+  <function name="wxSVGStylable::SetAnimStyle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGStylable::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGStylable::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGStylable::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGStylable::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetBaselineShift( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxSVGStylable::SetBaselineShift">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetClip( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxSVGStylable::SetClip">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetClipPath( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxSVGStylable::SetClipPath">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetClipRule( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetClipRule">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetColor( const wxRGBColor & value ) -->
+  <function name="wxSVGStylable::SetColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetColorInterpolation( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetColorInterpolation">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetColorInterpolationFilters( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetColorInterpolationFilters">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetColorProfile( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxSVGStylable::SetColorProfile">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetColorRendering( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetColorRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetCursor( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxSVGStylable::SetCursor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGStylable::SetCustomAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGStylable::SetCustomAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGStylable::SetCustomAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGStylable::SetCustomAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetDirection( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetDirection">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetDisplay( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetDisplay">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetDominantBaseline( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetDominantBaseline">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetEnableBackground( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetEnableBackground">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetFill( const wxSVGPaint & value ) -->
+  <function name="wxSVGStylable::SetFill">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetFillOpacity( double value ) -->
+  <function name="wxSVGStylable::SetFillOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGStylable::SetFillRule( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetFillRule">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetFilter( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxSVGStylable::SetFilter">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetFloodColor( const wxSVGColor & value ) -->
+  <function name="wxSVGStylable::SetFloodColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetFloodOpacity( double value ) -->
+  <function name="wxSVGStylable::SetFloodOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGStylable::SetFontFamily( const wxString & value ) -->
+  <function name="wxSVGStylable::SetFontFamily">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetFontSize( double value ) -->
+  <function name="wxSVGStylable::SetFontSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGStylable::SetFontSizeAdjust( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxSVGStylable::SetFontSizeAdjust">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetFontStretch( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetFontStretch">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetFontStyle( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetFontStyle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetFontVariant( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetFontVariant">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetFontWeight( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetFontWeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetGlyphOrientationHorizontal( double value ) -->
+  <function name="wxSVGStylable::SetGlyphOrientationHorizontal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGStylable::SetGlyphOrientationVertical( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxSVGStylable::SetGlyphOrientationVertical">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetImageRendering( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetImageRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetKerning( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxSVGStylable::SetKerning">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetLetterSpacing( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxSVGStylable::SetLetterSpacing">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetLightingColor( const wxSVGColor & value ) -->
+  <function name="wxSVGStylable::SetLightingColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetMarkerEnd( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxSVGStylable::SetMarkerEnd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetMarkerMid( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxSVGStylable::SetMarkerMid">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetMarkerStart( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxSVGStylable::SetMarkerStart">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetMask( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxSVGStylable::SetMask">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetOpacity( double value ) -->
+  <function name="wxSVGStylable::SetOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGStylable::SetOverflow( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetOverflow">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetPointerEvents( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetPointerEvents">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetShapeRendering( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetShapeRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetStopColor( const wxSVGColor & value ) -->
+  <function name="wxSVGStylable::SetStopColor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetStopOpacity( double value ) -->
+  <function name="wxSVGStylable::SetStopOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGStylable::SetStroke( const wxSVGPaint & value ) -->
+  <function name="wxSVGStylable::SetStroke">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetStrokeDasharray( const wxCSSValueList & value ) -->
+  <function name="wxSVGStylable::SetStrokeDasharray">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetStrokeDashoffset( double value ) -->
+  <function name="wxSVGStylable::SetStrokeDashoffset">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGStylable::SetStrokeLinecap( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetStrokeLinecap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetStrokeLinejoin( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetStrokeLinejoin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetStrokeMiterlimit( double value ) -->
+  <function name="wxSVGStylable::SetStrokeMiterlimit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGStylable::SetStrokeOpacity( double value ) -->
+  <function name="wxSVGStylable::SetStrokeOpacity">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGStylable::SetStrokeWidth( double value ) -->
+  <function name="wxSVGStylable::SetStrokeWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGStylable::SetStyle( const wxCSSStyleDeclaration & n ) -->
+  <function name="wxSVGStylable::SetStyle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetTextAnchor( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetTextAnchor">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetTextDecoration( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetTextDecoration">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetTextRendering( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetTextRendering">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetUnicodeBidi( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetUnicodeBidi">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetVisibility( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetVisibility">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetWordSpacing( const wxCSSPrimitiveValue & value ) -->
+  <function name="wxSVGStylable::SetWordSpacing">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStylable::SetWritingMode( wxCSS_VALUE value ) -->
+  <function name="wxSVGStylable::SetWritingMode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGStyleElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGStyleElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGStyleElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGStyleElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGStyleElement::GetAttributes( void ) const -->
+  <function name="wxSVGStyleElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGStyleElement::GetDtd( void ) -->
+  <function name="wxSVGStyleElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGStyleElement::GetMedia( void ) -->
+  <function name="wxSVGStyleElement::GetMedia">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGStyleElement::GetTitle( void ) -->
+  <function name="wxSVGStyleElement::GetTitle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGStyleElement::GetType( void ) -->
+  <function name="wxSVGStyleElement::GetType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGStyleElement::GetXmlspace( void ) -->
+  <function name="wxSVGStyleElement::GetXmlspace">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGStyleElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGStyleElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGStyleElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGStyleElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGStyleElement::SetMedia( const wxString & n ) -->
+  <function name="wxSVGStyleElement::SetMedia">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStyleElement::SetTitle( const wxString & n ) -->
+  <function name="wxSVGStyleElement::SetTitle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStyleElement::SetType( const wxString & n ) -->
+  <function name="wxSVGStyleElement::SetType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGStyleElement::SetXmlspace( const wxString & n ) -->
+  <function name="wxSVGStyleElement::SetXmlspace">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGSwitchElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGSwitchElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGSwitchElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGSwitchElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGSwitchElement::GetAttributes( void ) const -->
+  <function name="wxSVGSwitchElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGRect wxSVGSwitchElement::GetBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGSwitchElement::GetBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGSwitchElement::GetCTM( void ) -->
+  <function name="wxSVGSwitchElement::GetCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGSwitchElement::GetDtd( void ) -->
+  <function name="wxSVGSwitchElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGRect wxSVGSwitchElement::GetResultBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGSwitchElement::GetResultBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGSwitchElement::GetScreenCTM( void ) -->
+  <function name="wxSVGSwitchElement::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGSwitchElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGSwitchElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGSwitchElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGSwitchElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGSwitchElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGSwitchElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGSymbolElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGSymbolElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGSymbolElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGSymbolElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGSymbolElement::GetAttributes( void ) const -->
+  <function name="wxSVGSymbolElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGSymbolElement::GetDtd( void ) -->
+  <function name="wxSVGSymbolElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGSymbolElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGSymbolElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGSymbolElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGSymbolElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGSymbolElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGSymbolElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGTBreakElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGTBreakElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGTBreakElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGTBreakElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGTBreakElement::GetAttributes( void ) const -->
+  <function name="wxSVGTBreakElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGTBreakElement::GetDtd( void ) -->
+  <function name="wxSVGTBreakElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGTBreakElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGTBreakElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGTBreakElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGTBreakElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGTRefElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGTRefElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGTRefElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGTRefElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGTRefElement::GetAttributes( void ) const -->
+  <function name="wxSVGTRefElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGTRefElement::GetDtd( void ) -->
+  <function name="wxSVGTRefElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGTRefElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGTRefElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGTRefElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGTRefElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGTRefElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGTRefElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGTSpanElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGTSpanElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGTSpanElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGTSpanElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGTSpanElement::GetAttributes( void ) const -->
+  <function name="wxSVGTSpanElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGTSpanElement::GetDtd( void ) -->
+  <function name="wxSVGTSpanElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGTSpanElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGTSpanElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGTSpanElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGTSpanElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGTSpanElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGTSpanElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxString wxSVGTests::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGTests::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGTests::GetAttributes( void ) const -->
+  <function name="wxSVGTests::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxSVGStringList & wxSVGTests::GetRequiredExtensions( void ) -->
+  <function name="wxSVGTests::GetRequiredExtensions">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGStringList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGStringList & wxSVGTests::GetRequiredFeatures( void ) -->
+  <function name="wxSVGTests::GetRequiredFeatures">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGStringList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGStringList & wxSVGTests::GetSystemLanguage( void ) -->
+  <function name="wxSVGTests::GetSystemLanguage">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGStringList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGTests::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGTests::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGTests::HasExtension( const wxString & extension ) -->
+  <function name="wxSVGTests::HasExtension">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGTests::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGTests::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGTests::SetRequiredExtensions( const wxSVGStringList & n ) -->
+  <function name="wxSVGTests::SetRequiredExtensions">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGTests::SetRequiredFeatures( const wxSVGStringList & n ) -->
+  <function name="wxSVGTests::SetRequiredFeatures">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGTests::SetSystemLanguage( const wxSVGStringList & n ) -->
+  <function name="wxSVGTests::SetSystemLanguage">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxString wxSVGTextContentElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGTextContentElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGTextContentElement::GetAttributes( void ) const -->
+  <function name="wxSVGTextContentElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- long wxSVGTextContentElement::GetCharNumAtPosition( const wxSVGPoint & point ) -->
+  <function name="wxSVGTextContentElement::GetCharNumAtPosition">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- double wxSVGTextContentElement::GetComputedTextLength( void ) -->
+  <function name="wxSVGTextContentElement::GetComputedTextLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGPoint wxSVGTextContentElement::GetEndPositionOfChar( unsigned long charnum ) -->
+  <function name="wxSVGTextContentElement::GetEndPositionOfChar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPoint"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxSVGRect wxSVGTextContentElement::GetExtentOfChar( unsigned long charnum ) -->
+  <function name="wxSVGTextContentElement::GetExtentOfChar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGTextContentElement::GetLengthAdjust( void ) -->
+  <function name="wxSVGTextContentElement::GetLengthAdjust">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- long wxSVGTextContentElement::GetNumberOfChars( void ) -->
+  <function name="wxSVGTextContentElement::GetNumberOfChars">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGTextContentElement::GetRotationOfChar( unsigned long charnum ) -->
+  <function name="wxSVGTextContentElement::GetRotationOfChar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxSVGPoint wxSVGTextContentElement::GetStartPositionOfChar( unsigned long charnum ) -->
+  <function name="wxSVGTextContentElement::GetStartPositionOfChar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPoint"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- double wxSVGTextContentElement::GetSubStringLength( unsigned long charnum, unsigned long nchars ) -->
+  <function name="wxSVGTextContentElement::GetSubStringLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGTextContentElement::GetTextLength( void ) -->
+  <function name="wxSVGTextContentElement::GetTextLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGTextContentElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGTextContentElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGTextContentElement::SelectSubString( unsigned long charnum, unsigned long nchars ) -->
+  <function name="wxSVGTextContentElement::SelectSubString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool wxSVGTextContentElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGTextContentElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGTextContentElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGTextContentElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGTextElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGTextElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGTextElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGTextElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGTextElement::GetAttributes( void ) const -->
+  <function name="wxSVGTextElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGRect wxSVGTextElement::GetBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGTextElement::GetBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGTextElement::GetCTM( void ) -->
+  <function name="wxSVGTextElement::GetCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGCanvasItem * wxSVGTextElement::GetCanvasItem( void ) -->
+  <function name="wxSVGTextElement::GetCanvasItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGCanvasItem *"/>
+    <use-retval/>
+  </function>
+  <!-- long wxSVGTextElement::GetCharNumAtPosition( const wxSVGPoint & point ) -->
+  <function name="wxSVGTextElement::GetCharNumAtPosition">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- double wxSVGTextElement::GetComputedTextLength( void ) -->
+  <function name="wxSVGTextElement::GetComputedTextLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGTextElement::GetDtd( void ) -->
+  <function name="wxSVGTextElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGPoint wxSVGTextElement::GetEndPositionOfChar( unsigned long charnum ) -->
+  <function name="wxSVGTextElement::GetEndPositionOfChar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPoint"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxSVGRect wxSVGTextElement::GetExtentOfChar( unsigned long charnum ) -->
+  <function name="wxSVGTextElement::GetExtentOfChar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long wxSVGTextElement::GetNumberOfChars( void ) -->
+  <function name="wxSVGTextElement::GetNumberOfChars">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGRect wxSVGTextElement::GetResultBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGTextElement::GetResultBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- double wxSVGTextElement::GetRotationOfChar( unsigned long charnum ) -->
+  <function name="wxSVGTextElement::GetRotationOfChar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxSVGMatrix wxSVGTextElement::GetScreenCTM( void ) -->
+  <function name="wxSVGTextElement::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGPoint wxSVGTextElement::GetStartPositionOfChar( unsigned long charnum ) -->
+  <function name="wxSVGTextElement::GetStartPositionOfChar">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGPoint"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- double wxSVGTextElement::GetSubStringLength( unsigned long charnum, unsigned long nchars ) -->
+  <function name="wxSVGTextElement::GetSubStringLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool wxSVGTextElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGTextElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGTextElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGTextElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGTextElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGTextElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGTextElement::SetCanvasItem( wxSVGCanvasItem * canvasItem ) -->
+  <function name="wxSVGTextElement::SetCanvasItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGTextPathElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGTextPathElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGTextPathElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGTextPathElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGTextPathElement::GetAttributes( void ) const -->
+  <function name="wxSVGTextPathElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGTextPathElement::GetDtd( void ) -->
+  <function name="wxSVGTextPathElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGTextPathElement::GetMethod( void ) -->
+  <function name="wxSVGTextPathElement::GetMethod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedEnumeration & wxSVGTextPathElement::GetSpacing( void ) -->
+  <function name="wxSVGTextPathElement::GetSpacing">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedEnumeration &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGTextPathElement::GetStartOffset( void ) -->
+  <function name="wxSVGTextPathElement::GetStartOffset">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGTextPathElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGTextPathElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGTextPathElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGTextPathElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGTextPathElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGTextPathElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxString wxSVGTextPositioningElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGTextPositioningElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGTextPositioningElement::GetAttributes( void ) const -->
+  <function name="wxSVGTextPositioningElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxSVGAnimatedLengthList & wxSVGTextPositioningElement::GetDx( void ) -->
+  <function name="wxSVGTextPositioningElement::GetDx">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLengthList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLengthList & wxSVGTextPositioningElement::GetDy( void ) -->
+  <function name="wxSVGTextPositioningElement::GetDy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLengthList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedNumberList & wxSVGTextPositioningElement::GetRotate( void ) -->
+  <function name="wxSVGTextPositioningElement::GetRotate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedNumberList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLengthList & wxSVGTextPositioningElement::GetX( void ) -->
+  <function name="wxSVGTextPositioningElement::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLengthList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLengthList & wxSVGTextPositioningElement::GetY( void ) -->
+  <function name="wxSVGTextPositioningElement::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLengthList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGTextPositioningElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGTextPositioningElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGTextPositioningElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGTextPositioningElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGTextPositioningElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGTextPositioningElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGTitleElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGTitleElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGTitleElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGTitleElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGTitleElement::GetAttributes( void ) const -->
+  <function name="wxSVGTitleElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGTitleElement::GetDtd( void ) -->
+  <function name="wxSVGTitleElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGTitleElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGTitleElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGTitleElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGTitleElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGTitleElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGTitleElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- double wxSVGTransform::GetAngle( void ) -->
+  <function name="wxSVGTransform::GetAngle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGMatrix & wxSVGTransform::GetMatrix( void ) -->
+  <function name="wxSVGTransform::GetMatrix">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGMatrix &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVG_TRANSFORM wxSVGTransform::GetType( void ) -->
+  <function name="wxSVGTransform::GetType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVG_TRANSFORM"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSVGTransform::GetValueAsString( void ) const -->
+  <function name="wxSVGTransform::GetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void wxSVGTransform::SetAngle( double n ) -->
+  <function name="wxSVGTransform::SetAngle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGTransform::SetMatrix( const wxSVGMatrix & n ) -->
+  <function name="wxSVGTransform::SetMatrix">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGTransform::SetRotate( double angle, double cx, double cy ) -->
+  <function name="wxSVGTransform::SetRotate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGTransform::SetScale( double sx, double sy ) -->
+  <function name="wxSVGTransform::SetScale">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGTransform::SetSkewX( double angle ) -->
+  <function name="wxSVGTransform::SetSkewX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGTransform::SetSkewY( double angle ) -->
+  <function name="wxSVGTransform::SetSkewY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGTransform::SetTranslate( double tx, double ty ) -->
+  <function name="wxSVGTransform::SetTranslate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGTransform::SetType( const wxSVG_TRANSFORM & n ) -->
+  <function name="wxSVGTransform::SetType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGTransform::SetValueAsString( const wxString & value ) -->
+  <function name="wxSVGTransform::SetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxString wxSVGTransformList::GetValueAsString( void ) const -->
+  <function name="wxSVGTransformList::GetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void wxSVGTransformList::SetValueAsString( const wxString & value ) -->
+  <function name="wxSVGTransformList::SetValueAsString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxString wxSVGTransformable::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGTransformable::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGTransformable::GetAttributes( void ) const -->
+  <function name="wxSVGTransformable::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxSVGAnimatedTransformList & wxSVGTransformable::GetTransform( void ) -->
+  <function name="wxSVGTransformable::GetTransform">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedTransformList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGAnimatedTransformList & wxSVGTransformable::GetTransformList( void ) -->
+  <function name="wxSVGTransformable::GetTransformList">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGAnimatedTransformList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGTransformable::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGTransformable::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGTransformable::Rotate( double angle, double cx = 0, double cy = 0 ) -->
+  <function name="wxSVGTransformable::Rotate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="3" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- bool wxSVGTransformable::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGTransformable::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGTransformable::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGTransformable::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGTransformable::SkewX( double angle ) -->
+  <function name="wxSVGTransformable::SkewX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGTransformable::SkewY( double angle ) -->
+  <function name="wxSVGTransformable::SkewY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGTransformable::Transform( const wxSVGMatrix & matrix ) -->
+  <function name="wxSVGTransformable::Transform">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGTransformable::Translate( double tx, double ty ) -->
+  <function name="wxSVGTransformable::Translate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGTransformable::UpdateMatrix( wxSVGMatrix & matrix ) const -->
+  <function name="wxSVGTransformable::UpdateMatrix">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxString wxSVGURIReference::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGURIReference::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGURIReference::GetAttributes( void ) const -->
+  <function name="wxSVGURIReference::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxSVGAnimatedString & wxSVGURIReference::GetHref( void ) -->
+  <function name="wxSVGURIReference::GetHref">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGURIReference::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGURIReference::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGURIReference::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGURIReference::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGURIReference::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGURIReference::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGUseElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGUseElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxSVGElementInstance * wxSVGUseElement::GetAnimatedInstanceRoot( void ) -->
+  <function name="wxSVGUseElement::GetAnimatedInstanceRoot">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGElementInstance *"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSVGUseElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGUseElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGUseElement::GetAttributes( void ) const -->
+  <function name="wxSVGUseElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGRect wxSVGUseElement::GetBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGUseElement::GetBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGUseElement::GetCTM( void ) -->
+  <function name="wxSVGUseElement::GetCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGUseElement::GetDtd( void ) -->
+  <function name="wxSVGUseElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGUseElement::GetHeight( void ) -->
+  <function name="wxSVGUseElement::GetHeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGElementInstance * wxSVGUseElement::GetInstanceRoot( void ) -->
+  <function name="wxSVGUseElement::GetInstanceRoot">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGElementInstance *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGRect wxSVGUseElement::GetResultBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGUseElement::GetResultBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGUseElement::GetScreenCTM( void ) -->
+  <function name="wxSVGUseElement::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGUseElement::GetWidth( void ) -->
+  <function name="wxSVGUseElement::GetWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGUseElement::GetX( void ) -->
+  <function name="wxSVGUseElement::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGUseElement::GetY( void ) -->
+  <function name="wxSVGUseElement::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGUseElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGUseElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGUseElement::SetAnimatedInstanceRoot( wxSVGElementInstance * n ) -->
+  <function name="wxSVGUseElement::SetAnimatedInstanceRoot">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool wxSVGUseElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGUseElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGUseElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGUseElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGUseElement::SetInstanceRoot( wxSVGElementInstance * n ) -->
+  <function name="wxSVGUseElement::SetInstanceRoot">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGVKernElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGVKernElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGVKernElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGVKernElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGVKernElement::GetAttributes( void ) const -->
+  <function name="wxSVGVKernElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGVKernElement::GetDtd( void ) -->
+  <function name="wxSVGVKernElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGVKernElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGVKernElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGVKernElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGVKernElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGVideoElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGVideoElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGVideoElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGVideoElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGVideoElement::GetAttributes( void ) const -->
+  <function name="wxSVGVideoElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGRect wxSVGVideoElement::GetBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGVideoElement::GetBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- double wxSVGVideoElement::GetBegin( void ) -->
+  <function name="wxSVGVideoElement::GetBegin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGMatrix wxSVGVideoElement::GetCTM( void ) -->
+  <function name="wxSVGVideoElement::GetCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGCanvasItem * wxSVGVideoElement::GetCanvasItem( void ) -->
+  <function name="wxSVGVideoElement::GetCanvasItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGCanvasItem *"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGVideoElement::GetClipBegin( void ) -->
+  <function name="wxSVGVideoElement::GetClipBegin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGVideoElement::GetClipEnd( void ) -->
+  <function name="wxSVGVideoElement::GetClipEnd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGDTD wxSVGVideoElement::GetDtd( void ) -->
+  <function name="wxSVGVideoElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGVideoElement::GetDur( void ) -->
+  <function name="wxSVGVideoElement::GetDur">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGVideoElement::GetDuration( wxProgressDialog * progressDlg = NULL ) -->
+  <function name="wxSVGVideoElement::GetDuration">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1" default="NULL" direction="inout"/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGVideoElement::GetHeight( void ) -->
+  <function name="wxSVGVideoElement::GetHeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedPreserveAspectRatio & wxSVGVideoElement::GetPreserveAspectRatio( void ) -->
+  <function name="wxSVGVideoElement::GetPreserveAspectRatio">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedPreserveAspectRatio &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGRect wxSVGVideoElement::GetResultBBox( wxSVG_COORDINATES coordinates = wxSVG_COORDINATES_USER ) -->
+  <function name="wxSVGVideoElement::GetResultBBox">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGRect"/>
+    <arg nr="1" default="wxSVG_COORDINATES_USER" direction="in"/>
+  </function>
+  <!-- wxSVGMatrix wxSVGVideoElement::GetScreenCTM( void ) -->
+  <function name="wxSVGVideoElement::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGVideoElement::GetWidth( void ) -->
+  <function name="wxSVGVideoElement::GetWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGVideoElement::GetX( void ) -->
+  <function name="wxSVGVideoElement::GetX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGAnimatedLength & wxSVGVideoElement::GetY( void ) -->
+  <function name="wxSVGVideoElement::GetY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGAnimatedLength &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGVideoElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGVideoElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGVideoElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGVideoElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGVideoElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGVideoElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGVideoElement::SetBegin( double n ) -->
+  <function name="wxSVGVideoElement::SetBegin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGVideoElement::SetCanvasItem( wxSVGCanvasItem * canvasItem ) -->
+  <function name="wxSVGVideoElement::SetCanvasItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSVGVideoElement::SetClipBegin( double n ) -->
+  <function name="wxSVGVideoElement::SetClipBegin">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGVideoElement::SetClipEnd( double n ) -->
+  <function name="wxSVGVideoElement::SetClipEnd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGVideoElement::SetDur( double n ) -->
+  <function name="wxSVGVideoElement::SetDur">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- wxSvgXmlNode * wxSVGViewElement::CloneNode( bool deep = true ) -->
+  <function name="wxSVGViewElement::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxSVGViewElement::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGViewElement::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGViewElement::GetAttributes( void ) const -->
+  <function name="wxSVGViewElement::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGDTD wxSVGViewElement::GetDtd( void ) -->
+  <function name="wxSVGViewElement::GetDtd">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDTD"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGStringList & wxSVGViewElement::GetViewTarget( void ) -->
+  <function name="wxSVGViewElement::GetViewTarget">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGStringList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGViewElement::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGViewElement::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGViewElement::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGViewElement::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGViewElement::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGViewElement::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGViewElement::SetViewTarget( const wxSVGStringList & n ) -->
+  <function name="wxSVGViewElement::SetViewTarget">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxString wxSVGViewSpec::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGViewSpec::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGViewSpec::GetAttributes( void ) const -->
+  <function name="wxSVGViewSpec::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- const wxString & wxSVGViewSpec::GetPreserveAspectRatioString( void ) -->
+  <function name="wxSVGViewSpec::GetPreserveAspectRatioString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGTransformList & wxSVGViewSpec::GetTransform( void ) -->
+  <function name="wxSVGViewSpec::GetTransform">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGTransformList &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGViewSpec::GetTransformString( void ) -->
+  <function name="wxSVGViewSpec::GetTransformString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGViewSpec::GetViewBoxString( void ) -->
+  <function name="wxSVGViewSpec::GetViewBoxString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGElement * wxSVGViewSpec::GetViewTarget( void ) -->
+  <function name="wxSVGViewSpec::GetViewTarget">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGElement *"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxSVGViewSpec::GetViewTargetString( void ) -->
+  <function name="wxSVGViewSpec::GetViewTargetString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGViewSpec::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGViewSpec::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGViewSpec::SetAnimatedValue( const wxString & name, const wxSVGAnimatedType & value ) -->
+  <function name="wxSVGViewSpec::SetAnimatedValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxSVGViewSpec::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGViewSpec::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGViewSpec::SetPreserveAspectRatioString( const wxString & n ) -->
+  <function name="wxSVGViewSpec::SetPreserveAspectRatioString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGViewSpec::SetTransform( const wxSVGTransformList & n ) -->
+  <function name="wxSVGViewSpec::SetTransform">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGViewSpec::SetTransformString( const wxString & n ) -->
+  <function name="wxSVGViewSpec::SetTransformString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGViewSpec::SetViewBoxString( const wxString & n ) -->
+  <function name="wxSVGViewSpec::SetViewBoxString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGViewSpec::SetViewTarget( wxSVGElement * n ) -->
+  <function name="wxSVGViewSpec::SetViewTarget">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSVGViewSpec::SetViewTargetString( const wxString & n ) -->
+  <function name="wxSVGViewSpec::SetViewTargetString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxString wxSVGZoomAndPan::GetAttribute( const wxString & name ) const -->
+  <function name="wxSVGZoomAndPan::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSVGZoomAndPan::GetAttributes( void ) const -->
+  <function name="wxSVGZoomAndPan::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVG_ZOOMANDPAN wxSVGZoomAndPan::GetZoomAndPan( void ) -->
+  <function name="wxSVGZoomAndPan::GetZoomAndPan">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVG_ZOOMANDPAN"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSVGZoomAndPan::HasAttribute( const wxString & name ) const -->
+  <function name="wxSVGZoomAndPan::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGZoomAndPan::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSVGZoomAndPan::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSVGZoomAndPan::SetZoomAndPan( const wxSVG_ZOOMANDPAN & n ) -->
+  <function name="wxSVGZoomAndPan::SetZoomAndPan">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- double wxSVGZoomEvent::GetNewScale( void ) -->
+  <function name="wxSVGZoomEvent::GetNewScale">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGPoint & wxSVGZoomEvent::GetNewTranslate( void ) -->
+  <function name="wxSVGZoomEvent::GetNewTranslate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGPoint &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGZoomEvent::GetPreviousScale( void ) -->
+  <function name="wxSVGZoomEvent::GetPreviousScale">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGPoint & wxSVGZoomEvent::GetPreviousTranslate( void ) -->
+  <function name="wxSVGZoomEvent::GetPreviousTranslate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGPoint &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- const wxSVGRect & wxSVGZoomEvent::GetZoomRectScreen( void ) -->
+  <function name="wxSVGZoomEvent::GetZoomRectScreen">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="const wxSVGRect &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSVGZoomEvent::SetNewScale( double n ) -->
+  <function name="wxSVGZoomEvent::SetNewScale">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGZoomEvent::SetNewTranslate( const wxSVGPoint & n ) -->
+  <function name="wxSVGZoomEvent::SetNewTranslate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGZoomEvent::SetPreviousScale( double n ) -->
+  <function name="wxSVGZoomEvent::SetPreviousScale">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGZoomEvent::SetPreviousTranslate( const wxSVGPoint & n ) -->
+  <function name="wxSVGZoomEvent::SetPreviousTranslate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGZoomEvent::SetZoomRectScreen( const wxSVGRect & n ) -->
+  <function name="wxSVGZoomEvent::SetZoomRectScreen">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSVGHandler::DoCanRead( wxInputStream & stream ) -->
+  <function name="wxSVGHandler::DoCanRead">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool wxSVGHandler::LoadFile( wxImage * image, wxInputStream & stream, bool verbose = true, int index = -1 ) -->
+  <function name="wxSVGHandler::LoadFile">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" default="-1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool wxSVGHandler::SaveFile( wxImage * image, wxOutputStream & stream, bool verbose = true ) -->
+  <function name="wxSVGHandler::SaveFile">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool wxFfmpegMediaDecoder::BeginDecode( int width = -1, int height = -1 ) -->
+  <function name="wxFfmpegMediaDecoder::BeginDecode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <arg nr="1" default="-1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" default="-1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void wxFfmpegMediaDecoder::Close( void ) -->
+  <function name="wxFfmpegMediaDecoder::Close">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxFfmpegMediaDecoder::CloseVideoDecoder( void ) -->
+  <function name="wxFfmpegMediaDecoder::CloseVideoDecoder">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxFfmpegMediaDecoder::EndDecode( void ) -->
+  <function name="wxFfmpegMediaDecoder::EndDecode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- int wxFfmpegMediaDecoder::GetBitrate( unsigned int streamIndex ) -->
+  <function name="wxFfmpegMediaDecoder::GetBitrate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int wxFfmpegMediaDecoder::GetChannelNumber( unsigned int streamIndex ) -->
+  <function name="wxFfmpegMediaDecoder::GetChannelNumber">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxString wxFfmpegMediaDecoder::GetCodecName( unsigned int streamIndex ) -->
+  <function name="wxFfmpegMediaDecoder::GetCodecName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxString wxFfmpegMediaDecoder::GetCodecTag( unsigned int streamIndex ) -->
+  <function name="wxFfmpegMediaDecoder::GetCodecTag">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- float wxFfmpegMediaDecoder::GetCodecTimeBase( void ) -->
+  <function name="wxFfmpegMediaDecoder::GetCodecTimeBase">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <use-retval/>
+  </function>
+  <!-- double wxFfmpegMediaDecoder::GetDuration( void ) -->
+  <function name="wxFfmpegMediaDecoder::GetDuration">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxFfmpegMediaDecoder::GetFormatName( void ) -->
+  <function name="wxFfmpegMediaDecoder::GetFormatName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+  </function>
+  <!-- float wxFfmpegMediaDecoder::GetFps( void ) -->
+  <function name="wxFfmpegMediaDecoder::GetFps">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <use-retval/>
+  </function>
+  <!-- float wxFfmpegMediaDecoder::GetFrameAspectRatio( void ) -->
+  <function name="wxFfmpegMediaDecoder::GetFrameAspectRatio">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <use-retval/>
+  </function>
+  <!-- wxImage wxFfmpegMediaDecoder::GetNextFrame( void ) -->
+  <function name="wxFfmpegMediaDecoder::GetNextFrame">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxImage"/>
+    <use-retval/>
+  </function>
+  <!-- double wxFfmpegMediaDecoder::GetPosition( void ) -->
+  <function name="wxFfmpegMediaDecoder::GetPosition">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+  </function>
+  <!-- int wxFfmpegMediaDecoder::GetSampleRate( unsigned int streamIndex ) -->
+  <function name="wxFfmpegMediaDecoder::GetSampleRate">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- unsigned int wxFfmpegMediaDecoder::GetStreamCount( void ) -->
+  <function name="wxFfmpegMediaDecoder::GetStreamCount">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned int"/>
+    <use-retval/>
+  </function>
+  <!-- StreamType wxFfmpegMediaDecoder::GetStreamType( unsigned int streamIndex ) -->
+  <function name="wxFfmpegMediaDecoder::GetStreamType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="StreamType"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxSize wxFfmpegMediaDecoder::GetVideoSize( void ) -->
+  <function name="wxFfmpegMediaDecoder::GetVideoSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSize"/>
+    <use-retval/>
+  </function>
+  <!-- AVStream * wxFfmpegMediaDecoder::GetVideoStream( void ) -->
+  <function name="wxFfmpegMediaDecoder::GetVideoStream">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="AVStream *"/>
+    <use-retval/>
+  </function>
+  <!-- void wxFfmpegMediaDecoder::Init( void ) -->
+  <function name="wxFfmpegMediaDecoder::Init">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <pure/>
+  </function>
+  <!-- bool wxFfmpegMediaDecoder::Load( const wxString & fileName ) -->
+  <function name="wxFfmpegMediaDecoder::Load">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxFfmpegMediaDecoder::OpenVideoDecoder( void ) -->
+  <function name="wxFfmpegMediaDecoder::OpenVideoDecoder">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxFfmpegMediaDecoder::SetPosition( double pos, bool keyFrame = true, bool seekBackward = true ) -->
+  <function name="wxFfmpegMediaDecoder::SetPosition">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="2" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSVGCtrlBase::Clear( void ) -->
+  <function name="wxSVGCtrlBase::Clear">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- wxSVGDocument * wxSVGCtrlBase::GetSVG( void ) -->
+  <function name="wxSVGCtrlBase::GetSVG">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGDocument *"/>
+    <use-retval/>
+  </function>
+  <!-- double wxSVGCtrlBase::GetScale( void ) const -->
+  <function name="wxSVGCtrlBase::GetScale">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- double wxSVGCtrlBase::GetScaleX( void ) const -->
+  <function name="wxSVGCtrlBase::GetScaleX">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- double wxSVGCtrlBase::GetScaleY( void ) const -->
+  <function name="wxSVGCtrlBase::GetScaleY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSVGMatrix wxSVGCtrlBase::GetScreenCTM( void ) const -->
+  <function name="wxSVGCtrlBase::GetScreenCTM">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGMatrix"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- void wxSVGCtrlBase::Init( void ) -->
+  <function name="wxSVGCtrlBase::Init">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- bool wxSVGCtrlBase::Load( const wxString & filename ) -->
+  <function name="wxSVGCtrlBase::Load">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSVGCtrlBase::MoveElement( wxSVGElement * elem, double Xposition, double Yposition ) -->
+  <function name="wxSVGCtrlBase::MoveElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>-1.79769e+308:1.79769e+308</valid>
+    </arg>
+  </function>
+  <!-- void wxSVGCtrlBase::OnEraseBackground( wxEraseEvent & event ) -->
+  <function name="wxSVGCtrlBase::OnEraseBackground">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSVGCtrlBase::OnPaint( wxPaintEvent & event ) -->
+  <function name="wxSVGCtrlBase::OnPaint">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSVGCtrlBase::OnResize( wxSizeEvent & event ) -->
+  <function name="wxSVGCtrlBase::OnResize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSVGCtrlBase::RepaintBuffer( void ) -->
+  <function name="wxSVGCtrlBase::RepaintBuffer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxSVGCtrlBase::SetFitToFrame( bool fit = true ) -->
+  <function name="wxSVGCtrlBase::SetFitToFrame">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSVGCtrlBase::SetSVG( wxSVGDocument * doc ) -->
+  <function name="wxSVGCtrlBase::SetSVG">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxString wxSvgXmlAttribute::GetName( void ) -->
+  <function name="wxSvgXmlAttribute::GetName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSvgXmlAttribute::GetValue( void ) -->
+  <function name="wxSvgXmlAttribute::GetValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSvgXmlAttribute::SetName( const wxString & name ) -->
+  <function name="wxSvgXmlAttribute::SetName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSvgXmlAttribute::SetValue( const wxString & value ) -->
+  <function name="wxSvgXmlAttribute::SetValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSvgXmlDocument::AppendChild( wxSvgXmlNode * child ) -->
+  <function name="wxSvgXmlDocument::AppendChild">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxSvgXmlElement * wxSvgXmlDocument::CreateElement( const wxString & tagName ) -->
+  <function name="wxSvgXmlDocument::CreateElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlElement *"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSvgXmlDocument::DoCopy( const wxSvgXmlDocument & doc ) -->
+  <function name="wxSvgXmlDocument::DoCopy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxString wxSvgXmlDocument::GetEncoding( void ) -->
+  <function name="wxSvgXmlDocument::GetEncoding">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSvgXmlDocument::GetFileEncoding( void ) -->
+  <function name="wxSvgXmlDocument::GetFileEncoding">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+  </function>
+  <!-- wxSvgXmlNode * wxSvgXmlDocument::GetFirstChild( void ) -->
+  <function name="wxSvgXmlDocument::GetFirstChild">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSvgXmlNode * wxSvgXmlDocument::GetRoot( void ) -->
+  <function name="wxSvgXmlDocument::GetRoot">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSvgXmlDocument::GetVersion( void ) -->
+  <function name="wxSvgXmlDocument::GetVersion">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSvgXmlDocument::IsOk( void ) -->
+  <function name="wxSvgXmlDocument::IsOk">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
+  <!-- wxSvgXmlNode * wxSvgXmlDocument::RemoveChild( wxSvgXmlNode * child ) -->
+  <function name="wxSvgXmlDocument::RemoveChild">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSvgXmlDocument::SetEncoding( const wxString & enc ) -->
+  <function name="wxSvgXmlDocument::SetEncoding">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSvgXmlDocument::SetFileEncoding( const wxString & encoding ) -->
+  <function name="wxSvgXmlDocument::SetFileEncoding">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSvgXmlDocument::SetRoot( wxSvgXmlNode * node ) -->
+  <function name="wxSvgXmlDocument::SetRoot">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSvgXmlDocument::SetVersion( const wxString & version ) -->
+  <function name="wxSvgXmlDocument::SetVersion">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSvgXmlNode::AddChild( wxSvgXmlNode * child ) -->
+  <function name="wxSvgXmlNode::AddChild">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSvgXmlNode::AppendChild( wxSvgXmlNode * child ) -->
+  <function name="wxSvgXmlNode::AppendChild">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSvgXmlNode::CloneNode( bool deep = true ) -->
+  <function name="wxSvgXmlNode::CloneNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool wxSvgXmlNode::DeleteProperty( const wxString & name ) -->
+  <function name="wxSvgXmlNode::DeleteProperty">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSvgXmlNode::DoCopy( const wxSvgXmlNode & node ) -->
+  <function name="wxSvgXmlNode::DoCopy">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxString wxSvgXmlNode::GetAttribute( const wxString & name ) const -->
+  <function name="wxSvgXmlNode::GetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlAttrHash wxSvgXmlNode::GetAttributes( void ) const -->
+  <function name="wxSvgXmlNode::GetAttributes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlAttrHash"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxSvgXmlNode * wxSvgXmlNode::GetChildNodes( void ) -->
+  <function name="wxSvgXmlNode::GetChildNodes">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSvgXmlNode * wxSvgXmlNode::GetChildren( void ) -->
+  <function name="wxSvgXmlNode::GetChildren">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSvgXmlNode::GetContent( void ) -->
+  <function name="wxSvgXmlNode::GetContent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+  </function>
+  <!-- wxSvgXmlNode * wxSvgXmlNode::GetFirstChild( void ) -->
+  <function name="wxSvgXmlNode::GetFirstChild">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSvgXmlNode * wxSvgXmlNode::GetLastChild( void ) const -->
+  <function name="wxSvgXmlNode::GetLastChild">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxString wxSvgXmlNode::GetName( void ) -->
+  <function name="wxSvgXmlNode::GetName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+  </function>
+  <!-- wxSvgXmlNode * wxSvgXmlNode::GetNext( void ) -->
+  <function name="wxSvgXmlNode::GetNext">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSvgXmlNode * wxSvgXmlNode::GetNextSibling( void ) -->
+  <function name="wxSvgXmlNode::GetNextSibling">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSvgXmlDocument * wxSvgXmlNode::GetOwnerDocument( void ) -->
+  <function name="wxSvgXmlNode::GetOwnerDocument">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlDocument *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSvgXmlNode * wxSvgXmlNode::GetParent( void ) -->
+  <function name="wxSvgXmlNode::GetParent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSvgXmlNode * wxSvgXmlNode::GetParentNode( void ) -->
+  <function name="wxSvgXmlNode::GetParentNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSvgXmlNode * wxSvgXmlNode::GetPreviousSibling( void ) const -->
+  <function name="wxSvgXmlNode::GetPreviousSibling">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool wxSvgXmlNode::GetPropVal( const wxString & propName, wxString * value ) const -->
+  <function name="wxSvgXmlNode::GetPropVal">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- wxSvgXmlProperty * wxSvgXmlNode::GetProperties( void ) -->
+  <function name="wxSvgXmlNode::GetProperties">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlProperty *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSVGElement * wxSvgXmlNode::GetSvgElement( void ) -->
+  <function name="wxSvgXmlNode::GetSvgElement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSVGElement *"/>
+    <use-retval/>
+  </function>
+  <!-- wxSvgXmlNodeType wxSvgXmlNode::GetType( void ) -->
+  <function name="wxSvgXmlNode::GetType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNodeType"/>
+    <use-retval/>
+  </function>
+  <!-- bool wxSvgXmlNode::HasAttribute( const wxString & name ) const -->
+  <function name="wxSvgXmlNode::HasAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSvgXmlNode::HasProp( const wxString & propName ) const -->
+  <function name="wxSvgXmlNode::HasProp">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * wxSvgXmlNode::InsertBefore( wxSvgXmlNode * newChild, wxSvgXmlNode * refChild ) -->
+  <function name="wxSvgXmlNode::InsertBefore">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void wxSvgXmlNode::InsertChild( wxSvgXmlNode * child, wxSvgXmlNode * before_node ) -->
+  <function name="wxSvgXmlNode::InsertChild">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+  </function>
+  <!-- void wxSvgXmlNode::RemoveAttribute( const wxString & name ) -->
+  <function name="wxSvgXmlNode::RemoveAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxSvgXmlNode::RemoveChild( wxSvgXmlNode * child ) -->
+  <function name="wxSvgXmlNode::RemoveChild">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool wxSvgXmlNode::SetAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxSvgXmlNode::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxSvgXmlNode::SetChildren( wxSvgXmlNode * child ) -->
+  <function name="wxSvgXmlNode::SetChildren">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSvgXmlNode::SetContent( const wxString & con ) -->
+  <function name="wxSvgXmlNode::SetContent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSvgXmlNode::SetName( const wxString & name ) -->
+  <function name="wxSvgXmlNode::SetName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSvgXmlNode::SetNext( wxSvgXmlNode * next ) -->
+  <function name="wxSvgXmlNode::SetNext">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSvgXmlNode::SetOwnerDocument( wxSvgXmlDocument * ownerDocument ) -->
+  <function name="wxSvgXmlNode::SetOwnerDocument">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSvgXmlNode::SetParent( wxSvgXmlNode * parent ) -->
+  <function name="wxSvgXmlNode::SetParent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSvgXmlNode::SetProperties( wxSvgXmlProperty * prop ) -->
+  <function name="wxSvgXmlNode::SetProperties">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSvgXmlNode::SetType( wxSvgXmlNodeType type ) -->
+  <function name="wxSvgXmlNode::SetType">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxString wxSvgXmlProperty::GetName( void ) -->
+  <function name="wxSvgXmlProperty::GetName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+  </function>
+  <!-- wxSvgXmlProperty * wxSvgXmlProperty::GetNext( void ) -->
+  <function name="wxSvgXmlProperty::GetNext">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlProperty *"/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxSvgXmlProperty::GetValue( void ) -->
+  <function name="wxSvgXmlProperty::GetValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+  </function>
+  <!-- void wxSvgXmlProperty::SetName( const wxString & name ) -->
+  <function name="wxSvgXmlProperty::SetName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSvgXmlProperty::SetNext( wxSvgXmlProperty * next ) -->
+  <function name="wxSvgXmlProperty::SetNext">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxSvgXmlProperty::SetValue( const wxString & value ) -->
+  <function name="wxSvgXmlProperty::SetValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * XmlFindNode( wxSvgXmlNode * parent, const wxString & name ) -->
+  <function name="XmlFindNode">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxSvgXmlNode * XmlFindNodeSimple( wxSvgXmlNode * parent, const wxString & path ) -->
+  <function name="XmlFindNodeSimple">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSvgXmlNode *"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxString XmlGetClass( wxSvgXmlNode * parent ) -->
+  <function name="XmlGetClass">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- wxString XmlReadValue( wxSvgXmlNode * parent, const wxString & name ) -->
+  <function name="XmlReadValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void XmlSetClass( wxSvgXmlNode * parent, const wxString & classname ) -->
+  <function name="XmlSetClass">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void XmlWriteValue( wxSvgXmlNode * parent, const wxString & name, const wxString & value ) -->
+  <function name="XmlWriteValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+</def>
diff --git a/cfg/wxwidgets.cfg b/cfg/wxwidgets.cfg
index e7e28181f93..9dea60761d1 100644
--- a/cfg/wxwidgets.cfg
+++ b/cfg/wxwidgets.cfg
@@ -1,5 +1,116 @@
 <?xml version="1.0"?>
 <def format="2">
+  <type-checks>
+    <unusedvar>
+      <check>wxAcceleratorEntry</check>
+      <check>wxAny</check>
+      <check>wxArchiveIterator</check>
+      <check>wxArrayDouble</check>
+      <check>wxArrayInt</check>
+      <check>wxArrayPtrVoid</check>
+      <check>wxArrayShort</check>
+      <check>wxArrayString</check>
+      <check>wxBitmap</check>
+      <check>wxBitmapBundle</check>
+      <check>wxBitmapHandler</check>
+      <check>wxBoxSizer</check>
+      <check>wxBrush</check>
+      <check>wxChar</check>
+      <check>wxUniChar</check>
+      <check>wxUniCharRef</check>
+      <check>wxColour</check>
+      <check>wxColourDatabase</check>
+      <check>wxCursor</check>
+      <check>wxDateSpan</check>
+      <check>wxDelegateRendererNative</check>
+      <check>wxHeaderButtonParams</check>
+      <check>wxRendererNative</check>
+      <check>wxRendererVersion</check>
+      <check>wxTextWrapper</check>
+      <check>wxDCClipper</check>
+      <check>wxDCBrushChanger</check>
+      <check>wxDCFontChanger</check>
+      <check>wxDCPenChanger</check>
+      <check>wxDCTextColourChanger</check>
+      <check>wxDCTextBgColourChanger</check>
+      <check>wxDCTextBgModeChanger</check>
+      <check>wxFileType</check>
+      <check>wxFont</check>
+      <check>wxFlexGridSizer</check>
+      <check>wxFontEnumerator</check>
+      <check>wxFontInfo</check>
+      <check>wxFontList</check>
+      <check>wxFontMetrics</check>
+      <check>wxGBPosition</check>
+      <check>wxGBSizerItem</check>
+      <check>wxGBSpan</check>
+      <check>wxGDIObject</check>
+      <check>wxGraphicsBrush</check>
+      <check>wxGraphicsFont</check>
+      <check>wxGraphicsGradientStop</check>
+      <check>wxGraphicsGradientStops</check>
+      <check>wxGraphicsMatrix</check>
+      <check>wxGraphicsPath</check>
+      <check>wxGridBagSizer</check>
+      <check>wxGridSizer</check>
+      <check>wxIcon</check>
+      <check>wxIconBundle</check>
+      <check>wxIconLocation</check>
+      <check>wxIFFHandler</check>
+      <check>wxImage</check>
+      <check>wxImageHandler</check>
+      <check>wxGIFHandler</check>
+      <check>wxJPEGHandler</check>
+      <check>wxPCXHandler</check>
+      <check>wxPNGHandler</check>
+      <check>wxPNMHandler</check>
+      <check>wxTGAHandler</check>
+      <check>wxTIFFHandler</check>
+      <check>wxXPMHandler</check>
+      <check>wxMask</check>
+      <check>wxMetafile</check>
+      <check>wxNativeFontInfo</check>
+      <check>wxPalette</check>
+      <check>wxPen</check>
+      <check>wxPenList</check>
+      <check>wxPoint</check>
+      <check>wxPoint2DDouble</check>
+      <check>wxPoint2DInt</check>
+      <check>wxPosition</check>
+      <check>wxRealPoint</check>
+      <check>wxRegion</check>
+      <check>wxRegionContain</check>
+      <check>wxRegionIterator</check>
+      <check>wxRegEx</check>
+      <check>wxRect</check>
+      <check>wxSize</check>
+      <check>wxSizer</check>
+      <check>wxSizerItem</check>
+      <check>wxSplitterRenderParams</check>
+      <check>wxStaticBoxSizer</check>
+      <check>wxStdDialogButtonSizer</check>
+      <check>wxSystemOptions</check>
+      <check>wxSystemSettings</check>
+      <check>wxTarEntry</check>
+      <check>wxTarInputStream</check>
+      <check>wxTimeSpan</check>
+      <check>wxUString</check>
+      <check>wxVariant</check>
+      <check>wxVariantData</check>
+      <check>wxVariantDataCurrency</check>
+      <check>wxVariantDataErrorCode</check>
+      <check>wxVariantDataSafeArray</check>
+      <check>wxVector</check>
+      <check>wxVersionInfo</check>
+      <check>wxWrapSizer</check>
+      <check>wxZipEntry</check>
+      <check>wxZipInputStream</check>
+    </unusedvar>
+    <operatorEqVarError>
+    </operatorEqVarError>
+  </type-checks>
+  <!-- https://github.com/wxWidgets/wxWidgets/blob/master/include/wx/version.h -->
+  <define name="wxCHECK_VERSION(major,minor,release)" value="1"/>
   <!-- http://docs.wxwidgets.org/trunk/group__group__funcmacro__string.html#ga437ea6ba615b75dac8603e96ec864160 -->
   <!-- #define wxT(string) -->
   <define name="wxT(str)" value="str"/>
@@ -18,11 +129,19 @@
   <!-- http://docs.wxwidgets.org/trunk/group__group__funcmacro__string.html#ga8a02b8875a521df57263a9e6f090f2d0 -->
   <!-- const wxString& _(const wxString & string) // Macro that expands to wxGetTranslation -->
   <define name="_(str)" value="wxGetTranslation(str)"/>
-  <!-- wxVector<T> is a template class which implements most of the std::vector functions -->
+  <define name="wxPLURAL(str,plural,n)" value="wxGetTranslation(str,plural,n)"/>
+  <define name="wxLongLong_t" value="int64_t"/>
   <define name="wxExit" value="exit"/>
+  <!-- wxVector<T> is a template class which implements most of the std::vector functions -->
   <define name="wxVector" value="std::vector"/>
+  <define name="wxArrayString" value="std::vector &lt; wxString &gt;"/>
+  <define name="wxArrayInt" value="std::vector &lt; int &gt;"/>
+  <define name="wxLongLongFmtSpec" value="ll"/>
+  <define name="wxColor" value="wxColour"/>
   <define name="wxOVERRIDE" value="override"/>
   <define name="wxEXPLICIT" value="explicit"/>
+  <define name="WX_CHECK_BUILD_OPTIONS(libName)" value=""/>
+  <define name="IMPLEMENT_VARIANT_OBJECT_SHALLOWCMP(name)" value=""/>
   <define name="wxICON(name)" value="name"/>
   <define name="wxBITMAP(name)" value="name"/>
   <define name="WXSIZEOF(array)" value="(sizeof(array)/sizeof(array[0]))"/>
@@ -32,22 +151,59 @@
   <define name="wxConstCast(p,classname)" value="const_cast&lt;(classname)&gt;(p)"/>
   <define name="wxStaticCast(p,classname)" value="static_cast&lt;(classname)&gt;(p)"/>
   <define name="wx_reinterpret_cast(t,x)" value="reinterpret_cast&lt;t&gt;(x)"/>
+  <define name="wxPtrToUInt(p)" value="reinterpret_cast&lt; wxUIntPtr &gt;(p)"/>
+  <define name="wxUIntToPtr(p)" value="reinterpret_cast&lt; void * &gt;(p)"/>
   <define name="wxEVENT_HANDLER_CAST( functype, func )" value="reinterpret_cast&lt;functype&gt;(&amp;func);"/>
   <define name="wxDLG_UNIT(parent,pt)" value="parent-&lt;ConvertDialogToPixels(pt)"/>
-  <define name="wxDL_INIT_FUNC(pfx, name, dynlib)" value=""/>
   <define name="wxDL_INIT_FUNC_AW(pfx, name, dynlib)" value=""/>
   <define name="wxDYNLIB_FUNCTION(type, name, dynlib)" value=""/>
+  <define name="WX_DEFINE_EXPORTED_LIST(name)" value=""/>
+  <define name="IMPLEMENT_HELP_PROVISION(name)" value=""/>
+  <define name="WX_EVENT_TABLE_INPUT_CONSUMER(name)" value=""/>
   <define name="wxEVT_NULL" value="wxEventType"/>
   <define name="TAG_HANDLER_BEGIN(a,b)" value=""/>
   <define name="TAG_HANDLER_END(a)" value=""/>
   <define name="TAGS_MODULE_BEGIN(a)" value=""/>
   <define name="TAGS_MODULE_ADD(a)" value=""/>
   <define name="TAGS_MODULE_END(a)" value=""/>
+  <define name="EVT_HYPERLINK(id,func)" value=""/>
   <define name="EVT_ICONIZE(a)" value=""/>
+  <define name="EVT_DROP_FILES(a)" value=""/>
+  <define name="EVT_AUI_FIND_MANAGER(func)" value=""/>
+  <define name="EVT_CALCULATE_LAYOUT(func)" value=""/>
+  <define name="EVT_JOY_BUTTON_DOWN(func)" value=""/>
+  <define name="EVT_JOY_BUTTON_UP(func)" value=""/>
+  <define name="EVT_JOY_MOVE(func)" value=""/>
+  <define name="EVT_JOY_ZMOVE(func)" value=""/>
+  <define name="EVT_JOYSTICK_EVENTS(func)" value=""/>
+  <define name="EVT_LIST_ITEM_CHECKED(id,func)" value=""/>
+  <define name="EVT_LIST_ITEM_UNCHECKED(id,func)" value=""/>
+  <define name="EVT_RIBBONBAR_PAGE_CHANGED(id,func)" value=""/>
+  <define name="EVT_RIBBONBAR_PAGE_CHANGING(id,func)" value=""/>
+  <define name="EVT_RIBBONBAR_TAB_MIDDLE_DOWN(id,func)" value=""/>
+  <define name="EVT_RIBBONBAR_TAB_MIDDLE_UP(id,func)" value=""/>
+  <define name="EVT_RIBBONBAR_TAB_RIGHT_DOWN(id,func)" value=""/>
+  <define name="EVT_RIBBONBAR_TAB_RIGHT_UP(id,func)" value=""/>
+  <define name="EVT_RIBBONBAR_TAB_LEFT_DCLICK(id,func)" value=""/>
+  <define name="EVT_RIBBONBAR_TOGGLED(id,func)" value=""/>
+  <define name="EVT_RIBBONBAR_HELP_CLICK(id,func)" value=""/>
+  <define name="EVT_RIBBONBUTTONBAR_CLICKED(id,func)" value=""/>
+  <define name="EVT_RIBBONBUTTONBAR_DROPDOWN_CLICKED(id,func)" value=""/>
+  <define name="EVT_RIBBONGALLERY_SELECTED(id,func)" value=""/>
+  <define name="EVT_RIBBONGALLERY_CLICKED(id,func)" value=""/>
+  <define name="EVT_RIBBONGALLERY_HOVER_CHANGED(id,func)" value=""/>
+  <define name="EVT_RIBBONPANEL_EXTBUTTON_ACTIVATED(id,func)" value=""/>
+  <define name="EVT_RIBBONTOOLBAR_CLICKED(id,func)" value=""/>
+  <define name="EVT_RIBBONTOOLBAR_DROPDOWN_CLICKED(id,func)" value=""/>
+  <define name="EVT_BOOKCTRL_PAGE_CHANGED(id,func)" value=""/>
+  <define name="EVT_BOOKCTRL_PAGE_CHANGING(id,func)" value=""/>
+  <define name="EVT_SPLITTER_SASH_POS_RESIZE(id,func)" value=""/>
   <define name="EVT_SPLITTER_SASH_POS_CHANGING(id,func)" value=""/>
   <define name="EVT_SPLITTER_SASH_POS_CHANGED(id,func)" value=""/>
   <define name="EVT_SPLITTER_UNSPLIT(id,func)" value=""/>
   <define name="EVT_SPLITTER_DCLICK(id,func)" value=""/>
+  <define name="EVT_CHOICEBOOK_PAGE_CHANGED(id,func)" value=""/>
+  <define name="EVT_CHOICEBOOK_PAGE_CHANGING(id,func)" value=""/>
   <define name="EVT_MENU(id,func)" value=""/>
   <define name="EVT_MENU_RANGE(id1,id2,func)" value=""/>
   <define name="EVT_MENU_OPEN(func)" value=""/>
@@ -85,13 +241,14 @@
   <define name="EVT_TREE_ITEM_GETTOOLTIP(id,func)" value=""/>
   <define name="EVT_TREE_ITEM_MENU(id,func)" value=""/>
   <define name="EVT_TREE_STATE_IMAGE_CLICK(id,func)" value=""/>
+  <define name="EVT_SEARCH(id,func)" value=""/>
+  <define name="EVT_SEARCH_CANCEL(id,func)" value=""/>
   <define name="EVT_SEARCHCTRL_CANCEL_BTN(id,func)" value=""/>
   <define name="EVT_SEARCHCTRL_SEARCH_BTN(id,func)" value=""/>
   <define name="EVT_HTML_CELL_CLICKED(id,func)" value=""/>
   <define name="EVT_SYS_COLOUR_CHANGED(func)" value=""/>
   <define name="EVT_HTML_CELL_HOVER(id,func)" value=""/>
   <define name="EVT_HTML_LINK_CLICKED(id,func)" value=""/>
-  <define name="EVT_MENU(id,func)" value=""/>
   <define name="EVT_BUTTON(id,func)" value=""/>
   <define name="EVT_UPDATE_UI(id,func)" value=""/>
   <define name="EVT_UPDATE_UI_RANGE(id1,id2,func)" value=""/>
@@ -120,6 +277,7 @@
   <define name="EVT_DATAVIEW_ITEM_DROP_POSSIBLE(id,func)" value=""/>
   <define name="EVT_DATAVIEW_ITEM_DROP(id,func)" value=""/>
   <define name="EVT_DATAVIEW_CACHE_HINT(id,func)" value=""/>
+  <define name="EVT_DATAVIEW_ITEM_START_EDITING(id,func)" value=""/>
   <define name="EVT_RADIOBUTTON(id,func)" value=""/>
   <define name="EVT_SASH_DRAGGED_RANGE(id1,id2,func)" value=""/>
   <define name="EVT_CHECKBOX(id,func)" value=""/>
@@ -142,17 +300,38 @@
   <define name="EVT_COLLAPSIBLEPANE_CHANGED(id,func)" value=""/>
   <define name="EVT_WIZARD_CANCEL(id,func)" value=""/>
   <define name="EVT_COLOURPICKER_CHANGED(id,func)" value=""/>
+  <define name="EVT_HEADER_CLICK(id,func)" value=""/>
+  <define name="EVT_HEADER_RIGHT_CLICK(id,func)" value=""/>
+  <define name="EVT_HEADER_MIDDLE_CLICK(id,func)" value=""/>
+  <define name="EVT_HEADER_DCLICK(id,func)" value=""/>
+  <define name="EVT_HEADER_RIGHT_DCLICK(id,func)" value=""/>
+  <define name="EVT_HEADER_MIDDLE_DCLICK(id,func)" value=""/>
+  <define name="EVT_HEADER_SEPARATOR_DCLICK(id,func)" value=""/>
+  <define name="EVT_HEADER_BEGIN_RESIZE(id,func)" value=""/>
+  <define name="EVT_HEADER_RESIZING(id,func)" value=""/>
+  <define name="EVT_HEADER_END_RESIZE(id,func)" value=""/>
+  <define name="EVT_HEADER_BEGIN_REORDER(id,func)" value=""/>
+  <define name="EVT_HEADER_END_REORDER(id,func)" value=""/>
+  <define name="EVT_HEADER_DRAGGING_CANCELLED(id,func)" value=""/>
   <define name="EVT_LISTBOX(id,func)" value=""/>
   <define name="EVT_LISTBOX_DCLICK(id,func)" value=""/>
   <define name="EVT_COMMAND(id,event,func)" value=""/>
   <define name="EVT_COMMAND_RANGE(id1,id2,event,func)" value=""/>
-  <define name="EVT_COMMAND_SCROLL(id,func)" value=""/>
   <define name="EVT_TOOL_ENTER(id,func)" value=""/>
+  <define name="EVT_TOOL_DROPDOWN(id,func)" value=""/>
+  <define name="EVT_COMMAND_LEFT_CLICK(id,func)" value=""/>
+  <define name="EVT_COMMAND_LEFT_DCLICK(id,func)" value=""/>
+  <define name="EVT_COMMAND_RIGHT_CLICK(id,func)" value=""/>
+  <define name="EVT_COMMAND_SET_FOCUS(id,func)" value=""/>
+  <define name="EVT_COMMAND_KILL_FOCUS(id,func)" value=""/>
+  <define name="EVT_COMMAND_ENTER(id,func)" value=""/>
   <define name="EVT_FIND(id,func)" value=""/>
   <define name="EVT_FIND_NEXT(id,func)" value=""/>
   <define name="EVT_FIND_REPLACE(id,func)" value=""/>
   <define name="EVT_FIND_REPLACE_ALL(id,func)" value=""/>
   <define name="EVT_FIND_CLOSE(id,func)" value=""/>
+  <define name="EVT_SET_CURSOR(func)" value=""/>
+  <define name="EVT_MIDDLE_DCLICK(func)" value=""/>
   <define name="EVT_CONTEXT_MENU(func)" value=""/>
   <define name="EVT_IDLE(func)" value=""/>
   <define name="EVT_TEXT_URL(id,func)" value=""/>
@@ -183,9 +362,12 @@
   <define name="EVT_NOTEBOOK_PAGE_CHANGED(id,func)" value=""/>
   <define name="EVT_NOTEBOOK_PAGE_CHANGING(id,func)" value=""/>
   <define name="EVT_FILEPICKER_CHANGED(id,func)" value=""/>
-  <define name="EVT_UPDATE_UI(id,func)" value=""/>
+  <define name="EVT_TIME_CHANGED(id,func)" value=""/>
+  <define name="EVT_CUSTOM(event,id,func)" value=""/>
+  <define name="EVT_NOTIFY(event,id,func)" value=""/>
+  <define name="EVT_CUSTOM_RANGE(event,id1,id2, func)" value=""/>
+  <define name="EVT_NOTIFY_RANGE(event,id1,id2, func)" value=""/>
   <define name="EVT_CHOICE(id,func)" value=""/>
-  <define name="EVT_CAPTIONBAR(id,func)" value=""/>
   <define name="EVT_PG_SELECTED(id,func)" value=""/>
   <define name="EVT_PG_CHANGING(id,func)" value=""/>
   <define name="EVT_PG_CHANGED(id,func)" value=""/>
@@ -204,6 +386,7 @@
   <define name="EVT_GRID_CMD_LABEL_RIGHT_DCLICK(id,func)" value=""/>
   <define name="EVT_GRID_CMD_LABEL_LEFT_CLICK(id,func)" value=""/>
   <define name="EVT_GRID_CMD_LABEL_RIGHT_CLICK(id,func)" value=""/>
+  <define name="EVT_GRID_CMD_CELL_LEFT_DCLICK(id,func)" value=""/>
   <define name="EVT_GRID_CMD_CELL_RIGHT_DCLICK(id,func)" value=""/>
   <define name="EVT_GRID_CMD_CELL_CHANGE(id,func)" value=""/>
   <define name="EVT_GRID_CMD_CELL_CHANGED(id,func)" value=""/>
@@ -211,6 +394,28 @@
   <define name="EVT_GRID_CMD_SELECT_CELL(id,func)" value=""/>
   <define name="EVT_GRID_CMD_EDITOR_HIDDEN(id,func)" value=""/>
   <define name="EVT_GRID_CMD_EDITOR_SHOWN(id,func)" value=""/>
+  <define name="EVT_COLOURPICKER_CURRENT_CHANGED(id,func)" value=""/>
+  <define name="EVT_COLOURPICKER_DIALOG_CANCELLED(id,func)" value=""/>
+  <define name="EVT_COLLAPSIBLEHEADER_CHANGED(id,func)" value=""/>
+  <define name="EVT_DIRCTRL_SELECTIONCHANGED(id,func)" value=""/>
+  <define name="EVT_DIRCTRL_FILEACTIVATED(id,func)" value=""/>
+  <define name="EVT_FILECTRL_FILEACTIVATED(id,func)" value=""/>
+  <define name="EVT_FILECTRL_SELECTIONCHANGED(id,func)" value=""/>
+  <define name="EVT_FILECTRL_FOLDERCHANGED(id,func)" value=""/>
+  <define name="EVT_FILECTRL_FILTERCHANGED(id,func)" value=""/>
+  <define name="EVT_LISTBOOK_PAGE_CHANGED(id,func)" value=""/>
+  <define name="EVT_LISTBOOK_PAGE_CHANGING(id,func)" value=""/>
+  <define name="EVT_TREEBOOK_PAGE_CHANGED(id,func)" value=""/>
+  <define name="EVT_TREEBOOK_PAGE_CHANGING(id,func)" value=""/>
+  <define name="EVT_TREEBOOK_NODE_COLLAPSED(id,func)" value=""/>
+  <define name="EVT_TREEBOOK_NODE_EXPANDED(id,func)" value=""/>
+  <define name="EVT_TREELIST_SELECTION_CHANGED(id,func)" value=""/>
+  <define name="EVT_TREELIST_ITEM_EXPANDING(id,func)" value=""/>
+  <define name="EVT_TREELIST_ITEM_EXPANDED(id,func)" value=""/>
+  <define name="EVT_TREELIST_ITEM_CHECKED(id,func)" value=""/>
+  <define name="EVT_TREELIST_ITEM_ACTIVATED(id,func)" value=""/>
+  <define name="EVT_TREELIST_ITEM_CONTEXT_MENU(id,func)" value=""/>
+  <define name="EVT_TREELIST_COLUMN_SORTED(id,func)" value=""/>
   <define name="EVT_AUINOTEBOOK_PAGE_CLOSE(id,func)" value=""/>
   <define name="EVT_AUINOTEBOOK_PAGE_CLOSED(id,func)" value=""/>
   <define name="EVT_AUINOTEBOOK_PAGE_CHANGED(id,func)" value=""/>
@@ -244,20 +449,19 @@
   <define name="EVT_SIZE(func)" value=""/>
   <define name="EVT_SET_FOCUS(func)" value=""/>
   <define name="EVT_PAINT(func)" value=""/>
+  <define name="EVT_NC_PAINT(func)" value=""/>
   <define name="EVT_LEFT_DOWN(func)" value=""/>
   <define name="EVT_LEFT_UP(func)" value=""/>
-  <define name="EVT_DIRPICKER_CHANGED(func)" value=""/>
+  <define name="EVT_DIRPICKER_CHANGED(id,func)" value=""/>
   <define name="EVT_RIGHT_DCLICK(func)" value=""/>
   <define name="EVT_RIGHT_DOWN(func)" value=""/>
   <define name="EVT_MOTION(func)" value=""/>
   <define name="EVT_MIDDLE_UP(func)" value=""/>
-  <define name="EVT_MOUSEWHEEL(func)" value=""/>
   <define name="EVT_MOUSE_CAPTURE_LOST(func)" value=""/>
   <define name="EVT_RIGHT_UP(func)" value=""/>
   <define name="EVT_KEY_DOWN(func)" value=""/>
   <define name="EVT_KEY_UP(func)" value=""/>
   <define name="EVT_LEFT_DCLICK(func)" value=""/>
-  <define name="EVT_MOTION(func)" value=""/>
   <define name="EVT_ENTER_WINDOW(func)" value=""/>
   <define name="EVT_LEAVE_WINDOW(func)" value=""/>
   <define name="EVT_MOUSEWHEEL(func)" value=""/>
@@ -270,7 +474,10 @@
   <define name="EVT_CLOSE(func)" value=""/>
   <define name="EVT_QUERY_END_SESSION(func)" value=""/>
   <define name="EVT_END_SESSION(func)" value=""/>
+  <define name="EVT_MAXIMIZE(func)" value=""/>
   <define name="EVT_TASKBAR_LEFT_DCLICK(func)" value=""/>
+  <define name="EVT_TASKBAR_LEFT_DOWN(func)" value=""/>
+  <define name="EVT_TASKBAR_LEFT_UP(func)" value=""/>
   <define name="EVT_SCROLL(func)" value=""/>
   <define name="EVT_SCROLL_TOP(func)" value=""/>
   <define name="EVT_SCROLL_BOTTOM(func)" value=""/>
@@ -281,6 +488,9 @@
   <define name="EVT_SCROLL_THUMBTRACK(func)" value=""/>
   <define name="EVT_SCROLL_THUMBRELEASE(func)" value=""/>
   <define name="EVT_SCROLL_CHANGED(func)" value=""/>
+  <define name="EVT_WINDOW_CREATE(func)" value=""/>
+  <define name="EVT_FONTPICKER_CHANGED(id,func)" value=""/>
+  <define name="EVT_THREAD(id,func)" value=""/>
   <define name="EVT_COMMAND_SCROLL(id,func)" value=""/>
   <define name="EVT_COMMAND_SCROLL_TOP(id,func)" value=""/>
   <define name="EVT_COMMAND_SCROLL_BOTTOM(id,func)" value=""/>
@@ -289,10 +499,12 @@
   <define name="EVT_COMMAND_SCROLL_PAGEUP(id,func)" value=""/>
   <define name="EVT_COMMAND_SCROLL_PAGEDOWN(id,func)" value=""/>
   <define name="EVT_COMMAND_SCROLL_THUMBTRACK(id,func)" value=""/>
-  <define name="EVT_COMMAND_SCROLL_THUMBRELEASE(func)" value=""/>
-  <define name="EVT_COMMAND_SCROLL_CHANGED(func)" value=""/>
+  <define name="EVT_COMMAND_SCROLL_THUMBRELEASE(id,func)" value=""/>
+  <define name="EVT_COMMAND_SCROLL_CHANGED(id,func)" value=""/>
+  <define name="EVT_DPI_CHANGED(func)" value=""/>
   <define name="EVT_KILL_FOCUS(func)" value=""/>
-  <define name="EVT_MOUSE_EVENTS(func)" value=""/>
+  <define name="EVT_MOUSE_CAPTURE_CHANGED(func)" value=""/>
+  <define name="EVT_PALETTE_CHANGED(func)" value=""/>
   <define name="EVT_MIDDLE_DOWN(func)" value=""/>
   <define name="EVT_AUI_PANE_BUTTON(func)" value=""/>
   <define name="EVT_AUI_PANE_CLOSE(func)" value=""/>
@@ -301,7 +513,11 @@
   <define name="EVT_AUI_PANE_ACTIVATED(func)" value=""/>
   <define name="EVT_AUI_RENDER(func)" value=""/>
   <define name="EVT_GRID_COL_SORT(func)" value=""/>
+  <define name="EVT_GRID_RANGE_SELECTING(func)" value=""/>
   <define name="EVT_GRID_RANGE_SELECT(func)" value=""/>
+  <define name="EVT_GRID_RANGE_SELECTED(func)" value=""/>
+  <define name="EVT_GRID_CMD_RANGE_SELECTING(id,func)" value=""/>
+  <define name="EVT_GRID_CMD_RANGE_SELECTED(id,func)" value=""/>
   <define name="EVT_GRID_ROW_SIZE(func)" value=""/>
   <define name="EVT_GRID_COL_SIZE(func)" value=""/>
   <define name="EVT_GRID_COL_MOVE(func)" value=""/>
@@ -316,6 +532,9 @@
   <define name="EVT_GRID_EDITOR_SHOWN(func)" value=""/>
   <define name="EVT_GRID_EDITOR_HIDDEN(func)" value=""/>
   <define name="EVT_GRID_EDITOR_CREATED(func)" value=""/>
+  <define name="wx__DECLARE_EVT2(evt, id1, id2, fn)" value=""/>
+  <define name="wx__DECLARE_EVT1(evt, id, fn)" value=""/>
+  <define name="wx__DECLARE_EVT0(evt,fn)" value=""/>
   <!-- wxEVT_GRID_CELL_CHANGE event has been renamed to wxEVT_GRID_CELL_CHANGED since wxWidgets-2.8.x-->
   <define name="EVT_GRID_CELL_CHANGE(func)" value=""/>
   <define name="EVT_GRID_CELL_CHANGED(func)" value=""/>
@@ -401,8 +620,8 @@
   <define name="IMPLEMENT_APP_NO_MAIN(appname)" value=""/>
   <!-- Override macros which don't necessarily require semicolons at the end -->
   <define name="WXUNUSED(n)" value=""/>
-  <define name="wxDELETE(ptr)" value="{ delete ptr; ptr = NULL; }"/>
-  <define name="wxDELETEA(ptr)" value="{ delete [] ptr; ptr = NULL; }"/>
+  <define name="wxDELETE(ptr)" value="{ delete ptr; ptr = nullptr; }"/>
+  <define name="wxDELETEA(ptr)" value="{ delete [] ptr; ptr = nullptr; }"/>
   <define name="WXDLLIMPEXP_FWD_CORE" value=""/>
   <define name="WXDLLIMPEXP_FWD_BASE" value=""/>
   <define name="WXDLLIMPEXP_CORE" value=""/>
@@ -435,10 +654,33 @@
   <define name="wxDECLARE_APP(MyApp)" value="extern appname&amp; wxGetApp()"/>
   <define name="DECLARE_APP(MyApp)" value="extern appname&amp; wxGetApp()"/>
   <define name="DECLARE_CLASS(n)" value=""/>
+  <define name="CLASSINFO(n)" value="wxCLASSINFO(n)"/>
+  <define name="IMPLEMENT_ABSTRACT_CLASS2(n,b1,b2)" value="wxIMPLEMENT_ABSTRACT_CLASS2(n,b1,b2)"/>
+  <define name="IMPLEMENT_ABSTRACT_PLUGGABLE_CLASS(n,b)" value="wxIMPLEMENT_ABSTRACT_PLUGGABLE_CLASS(n,b)"/>
+  <define name="IMPLEMENT_ABSTRACT_PLUGGABLE_CLASS2(n,b,b2)" value="wxIMPLEMENT_ABSTRACT_PLUGGABLE_CLASS2(n,b,b2)"/>
+  <define name="IMPLEMENT_CLASS2(n,b1,b2)" value="wxIMPLEMENT_CLASS2(n,b1,b2)"/>
+  <define name="IMPLEMENT_DYNAMIC_CLASS2(n,b1,b2)" value="wxIMPLEMENT_DYNAMIC_CLASS2(n,b1,b2)"/>
+  <define name="IMPLEMENT_PLUGGABLE_CLASS(n,b)" value="wxIMPLEMENT_PLUGGABLE_CLASS(n,b)"/>
+  <define name="IMPLEMENT_PLUGGABLE_CLASS2(n,b,b2)" value="wxIMPLEMENT_PLUGGABLE_CLASS2(n,b,b2)"/>
+  <define name="IMPLEMENT_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS(n,b)" value="wxIMPLEMENT_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS(n,b)"/>
+  <define name="IMPLEMENT_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS2(n,b,b2)" value="wxIMPLEMENT_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS2(n,b,b2)"/>
+  <define name="IMPLEMENT_USER_EXPORTED_PLUGGABLE_CLASS(n,b)" value="wxIMPLEMENT_USER_EXPORTED_PLUGGABLE_CLASS(n,b)"/>
+  <define name="IMPLEMENT_USER_EXPORTED_PLUGGABLE_CLASS2(n,b,b2)" value="wxIMPLEMENT_USER_EXPORTED_PLUGGABLE_CLASS2(n,b,b2)"/>
+  <define name="DECLARE_ABSTRACT_PLUGGABLE_CLASS(n)" value="wxDECLARE_ABSTRACT_PLUGGABLE_CLASS(n);"/>
+  <define name="DECLARE_CLASS_INFO_ITERATORS()" value="wxDECLARE_CLASS_INFO_ITERATORS();"/>
+  <define name="DECLARE_DYNAMIC_CLASS_NO_ASSIGN(n)" value="wxDECLARE_DYNAMIC_CLASS_NO_ASSIGN(n);"/>
+  <define name="DECLARE_DYNAMIC_CLASS_NO_COPY(n)" value="wxDECLARE_DYNAMIC_CLASS_NO_COPY(n);"/>
+  <define name="DECLARE_PLUGGABLE_CLASS(n)" value="wxDECLARE_PLUGGABLE_CLASS(n);"/>
+  <define name="DECLARE_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS(n,u)" value="wxDECLARE_USER_EXPORTED_ABSTRACT_PLUGGABLE_CLASS(n,u);"/>
+  <define name="DECLARE_USER_EXPORTED_PLUGGABLE_CLASS(n,u)" value="wxDECLARE_USER_EXPORTED_PLUGGABLE_CLASS(n,u);"/>
   <define name="DECLARE_DYNAMIC_CLASS(n)" value=""/>
   <define name="wxDECLARE_ABSTRACT_CLASS(n)" value=""/>
   <define name="IMPLEMENT_CLASS(a,b)" value=""/>
   <define name="wxIMPLEMENT_CLASS(a,b)" value=""/>
+  <define name="EVT_POWER_SUSPENDING(n)" value=""/>
+  <define name="EVT_POWER_SUSPENDED(n)" value=""/>
+  <define name="EVT_POWER_SUSPEND_CANCEL(n)" value=""/>
+  <define name="EVT_POWER_RESUME(n)" value=""/>
   <define name="DECLARE_ABSTRACT_CLASS(n)" value=""/>
   <define name="IMPLEMENT_DYNAMIC_CLASS(n,b)" value=""/>
   <define name="IMPLEMENT_ABSTRACT_CLASS(n,b)" value=""/>
@@ -447,10 +689,7 @@
   <define name="BEGIN_DECLARE_EVENT_TYPES()" value=""/>
   <define name="END_DECLARE_EVENT_TYPES()" value=""/>
   <define name="DECLARE_EXPORTED_EVENT_TYPE(expdecl, name, value)" value=""/>
-  <define name="DECLARE_EVENT_TYPE(name, value)" value=""/>
-  <define name="DECLARE_LOCAL_EVENT_TYPE(name, value)" value=""/>
   <define name="DEFINE_EVENT_TYPE(name)" value="const wxEventType name = wxNewEventType();"/>
-  <define name="DEFINE_LOCAL_EVENT_TYPE(name)" value=""/>
   <define name="WX_DECLARE_STRING_HASH_MAP(name, value)" value=""/>
   <define name="DECLARE_LOCAL_EVENT_TYPE(name, value)" value=""/>
   <define name="DEFINE_LOCAL_EVENT_TYPE(name)" value=""/>
@@ -464,8 +703,9 @@
   <define name="DECLARE_NO_COPY_TEMPLATE_CLASS(classname,arg)" value="private: classname(const classname&lt;arg&gt;&amp;); classname&amp; operator=(const classname&lt;arg&gt;&amp;)"/>
   <define name="wxDECLARE_NO_COPY_TEMPLATE_CLASS(classname,arg)" value="private: classname(const classname&lt;arg&gt;&amp;); classname&amp; operator=(const classname&lt;arg&gt;&amp;)"/>
   <define name="wxDECLARE_NO_COPY_TEMPLATE_CLASS_2(classname,arg1,arg2)" value="private: classname(const classname&lt;arg1, arg2&gt;&amp;); classname&amp; operator=(const classname&lt;arg1, arg2&gt;&amp;)"/>
-  <define name="wxDEFINE_EVENT( name, type )" value=""/>
-  <define name="BEGIN_EVENT_TABLE(a,b)" value="wxBEGIN_EVENT_TABLE(a,b)"/>
+  <define name="wxDEFINE_EVENT(name,type)" value=""/>
+  <define name="BEGIN_EVENT_TABLE(a,b)" value="BeginEventTable("/>
+  <define name="END_EVENT_TABLE()" value="EndEventTable);"/>
   <define name="BEGIN_EVENT_TABLE_TEMPLATE1(a,b,T1)" value=""/>
   <define name="BEGIN_EVENT_TABLE_TEMPLATE2(a,b,T1,T2)" value=""/>
   <define name="BEGIN_EVENT_TABLE_TEMPLATE3(a,b,T1,T2,T3)" value=""/>
@@ -474,14 +714,12 @@
   <define name="BEGIN_EVENT_TABLE_TEMPLATE6(a,b,T1,T2,T3,T4,T5,T6)" value=""/>
   <define name="BEGIN_EVENT_TABLE_TEMPLATE7(a,b,T1,T2,T3,T4,T5,T6,T7)" value=""/>
   <define name="BEGIN_EVENT_TABLE_TEMPLATE8(a,b,T1,T2,T3,T4,T5,T6,T7,T8)" value=""/>
-  <define name="END_EVENT_TABLE()" value="wxEND_EVENT_TABLE()"/>
   <define name="wxBEGIN_EVENT_TABLE(theClass, baseClass)" value=""/>
-  <define name="wxDECLARE_EVENT_TABLE_ENTRY(type, winid, idLast, fn, obj)" value=""/>
+  <define name="wxDECLARE_EVENT_TABLE_ENTRY(type, winid, idLast, fn, obj)" value="wxEventTableEntry(type, winid, idLast, wxNewEventTableFunctor(type, fn), obj)"/>
   <define name="wxDECLARE_EVENT_TABLE_TERMINATOR()" value=""/>
   <define name="wxDEFINE_EVENT_ALIAS( name, type, value )" value=""/>
   <define name="wxDECLARE_EXPORTED_EVENT_ALIAS( expdecl, name, type )" value=""/>
   <define name="wxEND_EVENT_TABLE()" value=""/>
-  <define name="wxDECLARE_EVENT_TABLE_TERMINATOR()" value=""/>
   <!-- http://docs.wxwidgets.org/trunk/group__group__funcmacro__debug.html -->
   <!-- #define wxASSERT(condition) -->
   <define name="wxASSERT(condition)" value="assert(condition)"/>
@@ -495,7 +733,7 @@
   <define name="wxCHECK2(condition, operation)" value=""/>
   <define name="wxCHECK(condition, retValue)" value=""/>
   <define name="wxFAIL_MSG(message)" value=""/>
-  <define name="wxUnusedVar(var)" value=""/>
+  <define name="wxUnusedVar(var)" value="(void)var"/>
   <define name="wxCOMPILE_TIME_ASSERT(condition, retValue)" value="assert(condition)"/>
   <define name="wxCHECK_MSG(condition, retValue, msg)" value=""/>
   <define name="wxCHECK_RET(condition, retValue)" value=""/>
@@ -535,6 +773,8 @@
   <define name="wxIMAGE_QUALITY_BOX_AVERAGE" value="3"/>
   <define name="wxIMAGE_QUALITY_NORMAL" value="4"/>
   <define name="wxIMAGE_QUALITY_HIGH" value="5"/>
+  <define name="wxFS_READ" value="1"/>
+  <define name="wxFS_SEEKABLE" value="4"/>
   <define name="wxTextFileType_None" value="0"/>
   <define name="wxTextFileType_Unix" value="1"/>
   <define name="wxTextFileType_Dos" value="2"/>
@@ -542,6 +782,20 @@
   <define name="wxTextFileType_Os2" value="4"/>
   <define name="wxTextEntryDialogStyle" value="(wxOK | wxCANCEL | wxCENTRE | wxWS_EX_VALIDATE_RECURSIVELY)"/>
   <define name="wxWS_EX_VALIDATE_RECURSIVELY" value="1"/>
+  <define name="wxUPDATE_UI_PROCESS_ALL" value="0"/>
+  <define name="wxUPDATE_UI_PROCESS_SPECIFIED" value="1"/>
+  <define name="wxMOUSE_WHEEL_VERTICAL" value="0"/>
+  <define name="wxMOUSE_WHEEL_HORIZONTAL" value="1"/>
+  <define name="wxPOWER_RESOURCE_SCREEN" value="0"/>
+  <define name="wxPOWER_RESOURCE_SYSTEM" value="1"/>
+  <define name="wxBATTERY_NORMAL_STATE" value="0"/>
+  <define name="wxBATTERY_LOW_STATE" value="1"/>
+  <define name="wxBATTERY_CRITICAL_STATE" value="2"/>
+  <define name="wxBATTERY_SHUTDOWN_STATE" value="3"/>
+  <define name="wxBATTERY_UNKNOWN_STATE" value="4"/>
+  <define name="wxPOWER_SOCKET" value="0"/>
+  <define name="wxPOWER_BATTERY" value="1"/>
+  <define name="wxPOWER_UNKNOWN" value="2"/>
   <define name="wxPNG_TYPE_COLOUR" value="0"/>
   <define name="wxPNG_TYPE_GREY" value="2"/>
   <define name="wxPNG_TYPE_GREY_RED" value="3"/>
@@ -555,6 +809,10 @@
   <define name="wxBMP_4BPP" value="4"/>
   <define name="wxBMP_1BPP" value="1"/>
   <define name="wxBMP_1BPP_BW" value="2"/>
+  <define name="wxSHUTDOWN_FORCE" value="1"/>
+  <define name="wxSHUTDOWN_POWEROFF" value="2"/>
+  <define name="wxSHUTDOWN_REBOOT" value="4"/>
+  <define name="wxSHUTDOWN_LOGOFF" value="8"/>
   <define name="wxDIR_FILES" value="0x0001"/>
   <define name="wxDIR_DIRS" value="0x0002"/>
   <define name="wxDIR_HIDDEN" value="0x0004"/>
@@ -587,6 +845,9 @@
   <define name="wxMM_LOMETRIC" value="3"/>
   <define name="wxMM_TWIPS" value="4"/>
   <define name="wxMM_POINTS" value="5"/>
+  <define name="wxFromStart" value="0"/>
+  <define name="wxFromCurrent" value="1"/>
+  <define name="wxFromEnd" value="2"/>
   <define name="wxDVC_DEFAULT_RENDERER_SIZE" value="20"/>
   <define name="wxDVC_DEFAULT_WIDTH" value="80"/>
   <define name="wxDVC_TOGGLE_DEFAULT_WIDTH" value="30"/>
@@ -599,13 +860,6 @@
   <define name="wxDV_VERT_RULES" value="0x0008"/>
   <define name="wxDV_ROW_LINES" value="0x0010"/>
   <define name="wxDV_VARIABLE_LINE_HEIGHT" value="0x0020"/>
-  <define name="wxDATAVIEW_CELL_INERT" value="0"/>
-  <define name="wxDATAVIEW_CELL_ACTIVATABLE" value="1"/>
-  <define name="wxDATAVIEW_CELL_EDITABLE" value="2"/>
-  <define name="wxDATAVIEW_CELL_SELECTED" value="1"/>
-  <define name="wxDATAVIEW_CELL_PRELIT" value="2"/>
-  <define name="wxDATAVIEW_CELL_INSENSITIVE" value="4"/>
-  <define name="wxDATAVIEW_CELL_FOCUSED" value="8"/>
   <define name="wxDATAVIEW_COL_RESIZABLE" value="1"/>
   <define name="wxDATAVIEW_COL_SORTABLE" value="2"/>
   <define name="wxDATAVIEW_COL_REORDERABLE" value="4"/>
@@ -632,10 +886,6 @@
   <define name="wxFLP_FILE_MUST_EXIST" value="0x2000"/>
   <define name="wxFLP_CHANGE_DIR" value="0x4000"/>
   <define name="wxFLP_SMALL" value="0x8000"/>
-  <define name="wxGridSelectCells" value="0"/>
-  <define name="wxGridSelectRows" value="1"/>
-  <define name="wxGridSelectColumns" value="2"/>
-  <define name="wxGridSelectRowsOrColumns" value="3"/>
   <define name="wxANTIALIAS_NONE" value="0"/>
   <define name="wxANTIALIAS_DEFAULT" value="1"/>
   <define name="wxINTERPOLATION_DEFAULT" value="0"/>
@@ -657,8 +907,215 @@
   <define name="wxCOMPOSITION_DEST_ATOP" value="10"/>
   <define name="wxCOMPOSITION_XOR" value="11"/>
   <define name="wxCOMPOSITION_ADD" value="12"/>
+  <define name="wxFONTFLAG_DEFAULT" value="0"/>
+  <define name="wxFONTFLAG_ITALIC" value="1"/>
+  <define name="wxFONTFLAG_SLANT" value="0x2"/>
+  <define name="wxFONTFLAG_LIGHT" value="0x4"/>
+  <define name="wxFONTFLAG_BOLD" value="0x8"/>
+  <define name="wxFONTFLAG_ANTIALIASED" value="0x10"/>
+  <define name="wxFONTFLAG_NOT_ANTIALIASED" value="0x20"/>
+  <define name="wxFONTFLAG_UNDERLINED" value="0x40"/>
+  <define name="wxFONTFLAG_STRIKETHROUGH" value="0x80"/>
+  <define name="wxFONTFLAG_MASK" value="0x100"/>
   <define name="wxFONTENCODING_SYSTEM" value="-1"/>
   <define name="wxFONTENCODING_DEFAULT" value="0"/>
+  <define name="wxFONTENCODING_ISO8859_1" value="1"/>
+  <define name="wxFONTENCODING_ISO8859_2" value="2"/>
+  <define name="wxFONTENCODING_ISO8859_3" value="3"/>
+  <define name="wxFONTENCODING_ISO8859_4" value="4"/>
+  <define name="wxFONTENCODING_ISO8859_5" value="5"/>
+  <define name="wxFONTENCODING_ISO8859_6" value="6"/>
+  <define name="wxFONTENCODING_ISO8859_7" value="7"/>
+  <define name="wxFONTENCODING_ISO8859_8" value="8"/>
+  <define name="wxFONTENCODING_ISO8859_9" value="9"/>
+  <define name="wxFONTENCODING_ISO8859_10" value="10"/>
+  <define name="wxFONTENCODING_ISO8859_11" value="11"/>
+  <define name="wxFONTENCODING_ISO8859_12" value="12"/>
+  <define name="wxFONTENCODING_ISO8859_13" value="13"/>
+  <define name="wxFONTENCODING_ISO8859_14" value="14"/>
+  <define name="wxFONTENCODING_ISO8859_15" value="15"/>
+  <define name="wxFONTENCODING_ISO8859_MAX" value="16"/>
+  <define name="wxFONTENCODING_KOI8" value="17"/>
+  <define name="wxFONTENCODING_KOI8_U" value="18"/>
+  <define name="wxFONTENCODING_ALTERNATIVE" value="19"/>
+  <define name="wxFONTENCODING_BULGARIAN" value="20"/>
+  <define name="wxFONTENCODING_CP437" value="21"/>
+  <define name="wxFONTENCODING_CP850" value="22"/>
+  <define name="wxFONTENCODING_CP852" value="23"/>
+  <define name="wxFONTENCODING_CP855" value="24"/>
+  <define name="wxFONTENCODING_CP866" value="25"/>
+  <define name="wxFONTENCODING_CP874" value="26"/>
+  <define name="wxFONTENCODING_CP932" value="27"/>
+  <define name="wxFONTENCODING_CP936" value="28"/>
+  <define name="wxFONTENCODING_CP949" value="29"/>
+  <define name="wxFONTENCODING_CP950" value="30"/>
+  <define name="wxFONTENCODING_CP1250" value="31"/>
+  <define name="wxFONTENCODING_CP1251" value="32"/>
+  <define name="wxFONTENCODING_CP1252" value="33"/>
+  <define name="wxFONTENCODING_CP1253" value="34"/>
+  <define name="wxFONTENCODING_CP1254" value="35"/>
+  <define name="wxFONTENCODING_CP1255" value="36"/>
+  <define name="wxFONTENCODING_CP1256" value="37"/>
+  <define name="wxFONTENCODING_CP1257" value="38"/>
+  <define name="wxFONTENCODING_CP1258" value="39"/>
+  <define name="wxFONTENCODING_CP1361" value="40"/>
+  <define name="wxFONTENCODING_CP12_MAX" value="41"/>
+  <define name="wxFONTENCODING_UTF7" value="42"/>
+  <define name="wxFONTENCODING_UTF8" value="43"/>
+  <define name="wxFONTENCODING_EUC_JP" value="44"/>
+  <define name="wxFONTENCODING_UTF16BE" value="45"/>
+  <define name="wxFONTENCODING_UTF16LE" value="46"/>
+  <define name="wxFONTENCODING_UTF32BE" value="47"/>
+  <define name="wxFONTENCODING_UTF32LE" value="48"/>
+  <define name="wxFONTENCODING_MACROMAN" value="49"/>
+  <define name="wxFONTENCODING_MACJAPANESE" value="50"/>
+  <define name="wxFONTENCODING_MACCHINESETRAD" value="51"/>
+  <define name="wxFONTENCODING_MACKOREAN" value="52"/>
+  <define name="wxFONTENCODING_MACARABIC" value="53"/>
+  <define name="wxFONTENCODING_MACHEBREW" value="54"/>
+  <define name="wxFONTENCODING_MACGREEK" value="55"/>
+  <define name="wxFONTENCODING_MACCYRILLIC" value="56"/>
+  <define name="wxFONTENCODING_MACDEVANAGARI" value="57"/>
+  <define name="wxFONTENCODING_MACGURMUKHI" value="58"/>
+  <define name="wxFONTENCODING_MACGUJARATI" value="59"/>
+  <define name="wxFONTENCODING_MACORIYA" value="60"/>
+  <define name="wxFONTENCODING_MACBENGALI" value="61"/>
+  <define name="wxFONTENCODING_MACTAMIL" value="62"/>
+  <define name="wxFONTENCODING_MACTELUGU" value="63"/>
+  <define name="wxFONTENCODING_MACKANNADA" value="64"/>
+  <define name="wxFONTENCODING_MACMALAJALAM" value="65"/>
+  <define name="wxFONTENCODING_MACSINHALESE" value="66"/>
+  <define name="wxFONTENCODING_MACBURMESE" value="67"/>
+  <define name="wxFONTENCODING_MACKHMER" value="68"/>
+  <define name="wxFONTENCODING_MACTHAI" value="69"/>
+  <define name="wxFONTENCODING_MACLAOTIAN" value="70"/>
+  <define name="wxFONTENCODING_MACGEORGIAN" value="71"/>
+  <define name="wxFONTENCODING_MACARMENIAN" value="72"/>
+  <define name="wxFONTENCODING_MACCHINESESIMP" value="73"/>
+  <define name="wxFONTENCODING_MACTIBETAN" value="74"/>
+  <define name="wxFONTENCODING_MACMONGOLIAN" value="75"/>
+  <define name="wxFONTENCODING_MACETHIOPIC" value="76"/>
+  <define name="wxFONTENCODING_MACCENTRALEUR" value="77"/>
+  <define name="wxFONTENCODING_MACVIATNAMESE" value="78"/>
+  <define name="wxFONTENCODING_MACARABICEXT" value="79"/>
+  <define name="wxFONTENCODING_MACSYMBOL" value="80"/>
+  <define name="wxFONTENCODING_MACDINGBATS" value="81"/>
+  <define name="wxFONTENCODING_MACTURKISH" value="82"/>
+  <define name="wxFONTENCODING_MACCROATIAN" value="83"/>
+  <define name="wxFONTENCODING_MACICELANDIC" value="84"/>
+  <define name="wxFONTENCODING_MACROMANIAN" value="85"/>
+  <define name="wxFONTENCODING_MACCELTIC" value="86"/>
+  <define name="wxFONTENCODING_MACGAELIC" value="87"/>
+  <define name="wxFONTENCODING_MACKEYBOARD" value="88"/>
+  <define name="wxFONTENCODING_ISO2022_JP" value="89"/>
+  <define name="wxFONTENCODING_MAX" value="90"/>
+  <define name="wxFONTENCODING_MACMIN" value="49"/>
+  <define name="wxFONTENCODING_MACMAX" value="88"/>
+  <define name="wxFONTENCODING_UTF16" value="91"/>
+  <define name="wxFONTENCODING_UTF32" value="92"/>
+  <define name="wxFONTENCODING_UNICODE" value="93"/>
+  <define name="wxFONTENCODING_GB2312" value="28"/>
+  <define name="wxFONTENCODING_BIG5" value="30"/>
+  <define name="wxFONTENCODING_SHIFT_JIS" value="27"/>
+  <define name="wxFONTENCODING_EUC_KR" value="29"/>
+  <define name="wxFONTENCODING_JOHAB" value="40"/>
+  <define name="wxFONTENCODING_VIETNAMESE" value="39"/>
+  <define name="wxSYS_OEM_FIXED_FONT" value="10"/>
+  <define name="wxSYS_ANSI_FIXED_FONT" value="11"/>
+  <define name="wxSYS_ANSI_VAR_FONT" value="12"/>
+  <define name="wxSYS_SYSTEM_FONT" value="13"/>
+  <define name="wxSYS_DEVICE_DEFAULT_FONT" value="14"/>
+  <define name="wxSYS_COLOUR_SCROLLBAR" value="0"/>
+  <define name="wxSYS_COLOUR_DESKTOP" value="1"/>
+  <define name="wxSYS_COLOUR_ACTIVECAPTION" value="2"/>
+  <define name="wxSYS_COLOUR_INACTIVECAPTION" value="3"/>
+  <define name="wxSYS_COLOUR_MENU" value="4"/>
+  <define name="wxSYS_COLOUR_WINDOW" value="5"/>
+  <define name="wxSYS_COLOUR_WINDOWFRAME" value="6"/>
+  <define name="wxSYS_COLOUR_MENUTEXT" value="7"/>
+  <define name="wxSYS_COLOUR_WINDOWTEXT" value="8"/>
+  <define name="wxSYS_COLOUR_CAPTIONTEXT" value="9"/>
+  <define name="wxSYS_COLOUR_ACTIVEBORDER" value="10"/>
+  <define name="wxSYS_COLOUR_APPWORKSPACE" value="12"/>
+  <define name="wxSYS_COLOUR_HIGHLIGHT" value="13"/>
+  <define name="wxSYS_COLOUR_HIGHLIGHTTEXT" value="14"/>
+  <define name="wxSYS_COLOUR_BTNFACE" value="15"/>
+  <define name="wxSYS_COLOUR_BTNSHADOW" value="16"/>
+  <define name="wxSYS_COLOUR_GRAYTEXT" value="17"/>
+  <define name="wxSYS_COLOUR_BTNTEXT" value="18"/>
+  <define name="wxSYS_COLOUR_INACTIVECAPTIONTEXT" value="19"/>
+  <define name="wxSYS_COLOUR_BTNHIGHLIGHT" value="20"/>
+  <define name="wxSYS_COLOUR_3DDKSHADOW" value="21"/>
+  <define name="wxSYS_COLOUR_3DLIGHT" value="22"/>
+  <define name="wxSYS_COLOUR_INFOTEXT" value="23"/>
+  <define name="wxSYS_COLOUR_INFOBK" value="24"/>
+  <define name="wxSYS_COLOUR_LISTBOX" value="25"/>
+  <define name="wxSYS_COLOUR_HOTLIGHT" value="26"/>
+  <define name="wxSYS_COLOUR_GRADIENTACTIVECAPTION" value="27"/>
+  <define name="wxSYS_COLOUR_GRADIENTINACTIVECAPTION" value="28"/>
+  <define name="wxSYS_COLOUR_MENUHILIGHT" value="29"/>
+  <define name="wxSYS_COLOUR_MENUBAR" value="30"/>
+  <define name="wxSYS_COLOUR_LISTBOXTEXT" value="31"/>
+  <define name="wxSYS_COLOUR_LISTBOXHIGHLIGHTTEXT" value="32"/>
+  <define name="wxSYS_COLOUR_3DFACE" value="15"/>
+  <define name="wxSYS_COLOUR_3DSHADOW" value="16"/>
+  <define name="wxSYS_COLOUR_BTNHILIGHT" value="20"/>
+  <define name="wxSYS_COLOUR_3DHIGHLIGHT" value="20"/>
+  <define name="wxSYS_COLOUR_3DHILIGHT" value="20"/>
+  <define name="wxSYS_COLOUR_FRAMEBK" value="15"/>
+  <define name="wxSYS_MOUSE_BUTTONS" value="0"/>
+  <define name="wxSYS_BORDER_X" value="1"/>
+  <define name="wxSYS_BORDER_Y" value="2"/>
+  <define name="wxSYS_CURSOR_X" value="3"/>
+  <define name="wxSYS_CURSOR_Y" value="4"/>
+  <define name="wxSYS_DCLICK_X" value="5"/>
+  <define name="wxSYS_DCLICK_Y" value="6"/>
+  <define name="wxSYS_DRAG_X" value="7"/>
+  <define name="wxSYS_DRAG_Y" value="8"/>
+  <define name="wxSYS_EDGE_X" value="9"/>
+  <define name="wxSYS_EDGE_Y" value="10"/>
+  <define name="wxSYS_HSCROLL_ARROW_X" value="11"/>
+  <define name="wxSYS_HSCROLL_ARROW_Y" value="12"/>
+  <define name="wxSYS_HTHUMB_X" value="13"/>
+  <define name="wxSYS_ICON_X" value="14"/>
+  <define name="wxSYS_ICON_Y" value="15"/>
+  <define name="wxSYS_ICONSPACING_X" value="16"/>
+  <define name="wxSYS_ICONSPACING_Y" value="17"/>
+  <define name="wxSYS_WINDOWMIN_X" value="18"/>
+  <define name="wxSYS_WINDOWMIN_Y" value="19"/>
+  <define name="wxSYS_SCREEN_X" value="20"/>
+  <define name="wxSYS_SCREEN_Y" value="21"/>
+  <define name="wxSYS_FRAMESIZE_X" value="22"/>
+  <define name="wxSYS_FRAMESIZE_Y" value="23"/>
+  <define name="wxSYS_SMALLICON_X" value="24"/>
+  <define name="wxSYS_SMALLICON_Y" value="25"/>
+  <define name="wxSYS_HSCROLL_Y" value="26"/>
+  <define name="wxSYS_VSCROLL_X" value="27"/>
+  <define name="wxSYS_VSCROLL_ARROW_X" value="28"/>
+  <define name="wxSYS_VSCROLL_ARROW_Y" value="29"/>
+  <define name="wxSYS_VTHUMB_Y" value="30"/>
+  <define name="wxSYS_CAPTION_Y" value="31"/>
+  <define name="wxSYS_MENU_Y" value="32"/>
+  <define name="wxSYS_NETWORK_PRESENT" value="33"/>
+  <define name="wxSYS_PENWINDOWS_PRESENT" value="34"/>
+  <define name="wxSYS_SHOW_SOUNDS" value="35"/>
+  <define name="wxSYS_SWAP_BUTTONS" value="36"/>
+  <define name="wxSYS_DCLICK_MSEC" value="37"/>
+  <define name="wxSYS_CAN_DRAW_FRAME_DECORATIONS" value="1"/>
+  <define name="wxSYS_CAN_ICONIZE_FRAME" value="2"/>
+  <define name="wxSYS_TABLET_PRESENT" value="3"/>
+  <define name="wxSYS_SCREEN_NONE" value="0"/>
+  <define name="wxSYS_SCREEN_TINY" value="1"/>
+  <define name="wxSYS_SCREEN_PDA" value="2"/>
+  <define name="wxSYS_SCREEN_SMALL" value="3"/>
+  <define name="wxSYS_SCREEN_DESKTOP" value="4"/>
+  <define name="wxFONTSIZE_XX_SMALL" value="-3"/>
+  <define name="wxFONTSIZE_X_SMALL" value="-2"/>
+  <define name="wxFONTSIZE_SMALL" value="-1"/>
+  <define name="wxFONTSIZE_MEDIUM" value="0"/>
+  <define name="wxFONTSIZE_LARGE" value="1"/>
+  <define name="wxFONTSIZE_X_LARGE" value="2"/>
+  <define name="wxFONTSIZE_XX_LARGE" value="3"/>
   <define name="wxDATAVIEW_CELL_INERT" value="0"/>
   <define name="wxDATAVIEW_CELL_ACTIVATABLE" value="1"/>
   <define name="wxDATAVIEW_CELL_EDITABLE" value="2"/>
@@ -674,11 +1131,6 @@
   <define name="wxCHK_2STATE" value="0x4000"/>
   <define name="wxCHK_3STATE" value="0x1000"/>
   <define name="wxCHK_ALLOW_3RD_STATE_FOR_USER" value="0x2000"/>
-  <define name="wxSYS_OEM_FIXED_FONT" value="10"/>
-  <define name="wxSYS_ANSI_FIXED_FONT" value="11"/>
-  <define name="wxSYS_ANSI_VAR_FONT" value="12"/>
-  <define name="wxSYS_SYSTEM_FONT" value="13"/>
-  <define name="wxSYS_DEVICE_DEFAULT_FONT" value="14"/>
   <define name="wxSYS_DEFAULT_PALETTE" value="15"/>
   <define name="wxSYS_SYSTEM_FIXED_FONT" value="16"/>
   <define name="wxSYS_DEFAULT_GUI_FONT" value="17"/>
@@ -2894,14 +3346,19 @@
   <define name="wxSTC_EDI_UNA" value="6"/>
   <define name="wxSTC_EDI_UNH" value="7"/>
   <define name="wxSTC_EDI_BADSEGMENT" value="8"/>
-  <define name="wxANIMATION_TYPE_INVALID" value="0"/>
-  <define name="wxANIMATION_TYPE_GIF" value="1"/>
-  <define name="wxANIMATION_TYPE_ANI" value="2"/>
   <define name="wxANIMATION_TYPE_ANIY" value="3"/>
   <define name="wxANIM_UNSPECIFIED" value="-1"/>
   <define name="wxANIM_DONOTREMOVE" value="0"/>
   <define name="wxANIM_TOBACKGROUND" value="1"/>
   <define name="wxANIM_TOPREVIOUS" value="2"/>
+  <define name="wxELLIPSIZE_FLAGS_NONE" value="0"/>
+  <define name="wxELLIPSIZE_FLAGS_PROCESS_MNEMONICS" value="1"/>
+  <define name="wxELLIPSIZE_FLAGS_EXPAND_TABS" value="2"/>
+  <define name="wxELLIPSIZE_FLAGS_DEFAULT" value="wxELLIPSIZE_FLAGS_PROCESS_MNEMONICS|wxELLIPSIZE_FLAGS_EXPAND_TABS"/>
+  <define name="wxELLIPSIZE_NONE" value="0"/>
+  <define name="wxELLIPSIZE_START" value="1"/>
+  <define name="wxELLIPSIZE_MIDDLE" value="2"/>
+  <define name="wxELLIPSIZE_END" value="3"/>
   <define name="wxCURSOR_NONE" value="0"/>
   <define name="wxCURSOR_ARROW" value="1"/>
   <define name="wxCURSOR_RIGHT_ARROW" value="2"/>
@@ -3045,6 +3502,24 @@
   <define name="wxLIST_FORMAT_RIGHT" value="1"/>
   <define name="wxLIST_FORMAT_CENTRE" value="2"/>
   <define name="wxLIST_FORMAT_CENTER" value="3"/>
+  <define name="wxCMD_LINE_OPTION_MANDATORY" value="0x01"/>
+  <define name="wxCMD_LINE_PARAM_OPTIONAL" value="0x02"/>
+  <define name="wxCMD_LINE_PARAM_MULTIPLE" value="0x04"/>
+  <define name="wxCMD_LINE_OPTION_HELP" value="0x08"/>
+  <define name="wxCMD_LINE_NEEDS_SEPARATOR" value="0x10"/>
+  <define name="wxCMD_LINE_SWITCH_NEGATABLE" value="0x20"/>
+  <define name="wxCMD_LINE_VAL_STRING" value="0"/>
+  <define name="wxCMD_LINE_VAL_NUMBER" value="1"/>
+  <define name="wxCMD_LINE_VAL_DATE" value="2"/>
+  <define name="wxCMD_LINE_VAL_DOUBLE" value="3"/>
+  <define name="wxCMD_LINE_VAL_NONE" value="4"/>
+  <define name="wxCMD_LINE_SWITCH" value="0"/>
+  <define name="wxCMD_LINE_OPTION" value="1"/>
+  <define name="wxCMD_LINE_PARAM" value="2"/>
+  <define name="wxCMD_LINE_USAGE_TEXT" value="3"/>
+  <define name="wxCMD_LINE_NONE" value="4"/>
+  <define name="wxCMD_LINE_SPLIT_DOS" value="0"/>
+  <define name="wxCMD_LINE_SPLIT_UNIX" value="1"/>
   <define name="wxFILTER_NONE" value="0"/>
   <define name="wxFILTER_EMPTY" value="1"/>
   <define name="wxFILTER_ASCII" value="2"/>
@@ -3088,13 +3563,6 @@
   <define name="wxGRID_DRAW_DEFAULT" value="15"/>
   <define name="wxSafeIncRef(p)" value="if ( p ) (p)-&gt;IncRef()"/>
   <define name="wxSafeDecRef(p)" value="if ( p ) (p)-&gt;DecRef()"/>
-  <define name="wxDV_SINGLE" value="0x0000"/>
-  <define name="wxDV_MULTIPLE" value="0x0001"/>
-  <define name="wxDV_NO_HEADER" value="0x0002"/>
-  <define name="wxDV_HORIZ_RULES" value="0x0004"/>
-  <define name="wxDV_VERT_RULES" value="0x0008"/>
-  <define name="wxDV_ROW_LINES" value="0x0010"/>
-  <define name="wxDV_VARIABLE_LINE_HEIGHT" value="0x0020"/>
   <define name="wxGA_PROGRESS" value="0x0010"/>
   <define name="wxGA_SMOOTH" value="0x0020"/>
   <define name="wxGA_TEXT" value="0x0040"/>
@@ -3148,6 +3616,10 @@
   <define name="wxLAYOUT_LENGTH_X" value="0"/>
   <define name="wxLAYOUT_MRU_LENGTH" value="0x10"/>
   <define name="wxLAYOUT_QUERY" value="0x100"/>
+  <!-- enum wxRegionContain -->
+  <define name="wxOutRegion" value="0"/>
+  <define name="wxPartRegion" value="1"/>
+  <define name="wxInRegion" value="2"/>
   <define name="wxLOG_FatalError" value="0"/>
   <define name="wxLOG_Error" value="1"/>
   <define name="wxLOG_Warning" value="2"/>
@@ -3309,47 +3781,9 @@
   <define name="wxTB_RIGHT" value="0x4000"/>
   <define name="wxTB_DEFAULT_STYLE" value="0x0004"/>
   <!-- Start of standard button and menu IDs -->
-  <define name="wxSYS_COLOUR_SCROLLBAR" value="0"/>
-  <define name="wxSYS_COLOUR_DESKTOP" value="1"/>
-  <define name="wxSYS_COLOUR_ACTIVECAPTION" value="2"/>
-  <define name="wxSYS_COLOUR_INACTIVECAPTION" value="3"/>
-  <define name="wxSYS_COLOUR_MENU" value="4"/>
-  <define name="wxSYS_COLOUR_WINDOW" value="5"/>
-  <define name="wxSYS_COLOUR_WINDOWFRAME" value="6"/>
-  <define name="wxSYS_COLOUR_MENUTEXT" value="7"/>
-  <define name="wxSYS_COLOUR_WINDOWTEXT" value="8"/>
-  <define name="wxSYS_COLOUR_CAPTIONTEXT" value="9"/>
-  <define name="wxSYS_COLOUR_ACTIVEBORDER" value="10"/>
   <define name="wxSYS_COLOUR_INACTIVEBORDER" value="11"/>
-  <define name="wxSYS_COLOUR_APPWORKSPACE" value="12"/>
-  <define name="wxSYS_COLOUR_HIGHLIGHT" value="13"/>
-  <define name="wxSYS_COLOUR_HIGHLIGHTTEXT" value="14"/>
-  <define name="wxSYS_COLOUR_BTNFACE" value="15"/>
-  <define name="wxSYS_COLOUR_BTNSHADOW" value="16"/>
-  <define name="wxSYS_COLOUR_GRAYTEXT" value="17"/>
-  <define name="wxSYS_COLOUR_BTNTEXT" value="18"/>
-  <define name="wxSYS_COLOUR_INACTIVECAPTIONTEXT" value="19"/>
-  <define name="wxSYS_COLOUR_BTNHIGHLIGHT" value="20"/>
-  <define name="wxSYS_COLOUR_3DDKSHADOW" value="21"/>
-  <define name="wxSYS_COLOUR_3DLIGHT" value="22"/>
-  <define name="wxSYS_COLOUR_INFOTEXT" value="23"/>
-  <define name="wxSYS_COLOUR_INFOBK" value="24"/>
-  <define name="wxSYS_COLOUR_LISTBOX" value="25"/>
-  <define name="wxSYS_COLOUR_HOTLIGHT" value="26"/>
-  <define name="wxSYS_COLOUR_GRADIENTACTIVECAPTION" value="27"/>
-  <define name="wxSYS_COLOUR_GRADIENTINACTIVECAPTION" value="28"/>
-  <define name="wxSYS_COLOUR_MENUHILIGHT" value="29"/>
-  <define name="wxSYS_COLOUR_MENUBAR" value="30"/>
-  <define name="wxSYS_COLOUR_LISTBOXTEXT" value="31"/>
-  <define name="wxSYS_COLOUR_LISTBOXHIGHLIGHTTEXT" value="32"/>
   <define name="wxSYS_COLOUR_MAX" value="33"/>
   <define name="wxSYS_COLOUR_BACKGROUND" value="15"/>
-  <define name="wxSYS_COLOUR_3DFACE" value="15"/>
-  <define name="wxSYS_COLOUR_3DSHADOW" value="16"/>
-  <define name="wxSYS_COLOUR_BTNHILIGHT" value="20"/>
-  <define name="wxSYS_COLOUR_3DHIGHLIGHT" value="20"/>
-  <define name="wxSYS_COLOUR_3DHILIGHT" value="20"/>
-  <define name="wxSYS_COLOUR_FRAMEBK" value="15"/>
   <define name="wxID_OK" value="5100"/>
   <define name="wxID_CANCEL" value="5101"/>
   <define name="wxID_APPLY" value="5102"/>
@@ -3458,23 +3892,7 @@
   <define name="wxBK_HITTEST_ONLABEL" value="3"/>
   <define name="wxBK_HITTEST_ONITEM" value="4"/>
   <define name="wxBK_HITTEST_ONPAGE" value="5"/>
-  <define name="wxCMD_LINE_OPTION_MANDATORY" value="0x01"/>
-  <define name="wxCMD_LINE_PARAM_OPTIONAL" value="0x02"/>
-  <define name="wxCMD_LINE_PARAM_MULTIPLE" value="0x04"/>
-  <define name="wxCMD_LINE_OPTION_HELP" value="0x08"/>
-  <define name="wxCMD_LINE_NEEDS_SEPARATOR" value="0x10"/>
-  <define name="wxCMD_LINE_SWITCH_NEGATABLE" value="0x20"/>
   <define name="wxCMD_LINE_HIDDEN" value="0x40"/>
-  <define name="wxCMD_LINE_VAL_STRING" value="0"/>
-  <define name="wxCMD_LINE_VAL_NUMBER" value="1"/>
-  <define name="wxCMD_LINE_VAL_DATE" value="2"/>
-  <define name="wxCMD_LINE_VAL_DOUBLE" value="3"/>
-  <define name="wxCMD_LINE_VAL_NONE" value="4"/>
-  <define name="wxCMD_LINE_SWITCH" value="0"/>
-  <define name="wxCMD_LINE_OPTION" value="1"/>
-  <define name="wxCMD_LINE_PARAM" value="2"/>
-  <define name="wxCMD_LINE_USAGE_TEXT" value="3"/>
-  <define name="wxCMD_LINE_NONE" value="4"/>
   <define name="wxCMD_SWITCH_OFF" value="-1"/>
   <define name="wxCMD_SWITCH_NOT_FOUND" value="0"/>
   <define name="wxCMD_SWITCH_ON" value="1"/>
@@ -3535,13 +3953,75 @@
   <define name="wxFILE_EXISTS_DIR" value="2"/>
   <define name="wxFILE_EXISTS_SYMLINK" value="0x1004"/>
   <define name="wxFILE_EXISTS_DEVICE" value="0x0008"/>
-  <define name="wxFILE_EXISTS_FIFO" value="0x0016"/>
-  <define name="wxFILE_EXISTS_SOCKET" value="0x0032"/>
+  <define name="wxFILE_EXISTS_FIFO" value="0x0010"/>
+  <define name="wxFILE_EXISTS_SOCKET" value="0x0020"/>
   <define name="wxFILE_EXISTS_NO_FOLLOW" value="0x1000"/>
   <define name="wxFILE_EXISTS_ANY" value="0x1FFF"/>
+  <define name="wxFILE_KIND_UNKNOWN" value="0"/>
+  <define name="wxFILE_KIND_DISK" value="1"/>
+  <define name="wxFILE_KIND_TERMINAL" value="2"/>
+  <define name="wxFILE_KIND_PIPE" value="3"/>
   <define name="wxPG_ITERATOR_CREATE_MASKS(FLAGS,A,B)" value="{ A = (FLAGS ^ 29732) &amp; 29732 &amp; 0xFFFF; B = ((FLAGS&lt;&lt;16) ^ 29732) &amp; 29732 &amp; 0xFFFF; }"/>
   <define name="wxPG_ITERATOR_PARENTEXMASK_TEST(PWC,PARENTMASK)" value="( !PWC-&gt;HasFlag(PARENTMASK) &amp;&amp; PWC-&gt;GetChildCount() )"/>
   <define name="wxPG_IT_CHILDREN(A)" value="((A)&lt;&lt;16)"/>
+  <define name="wxPG_XBEFORETEXT" value="4"/>
+  <define name="wxPG_VFB_STAY_IN_PROPERTY" value="0x01"/>
+  <define name="wxPG_VFB_BEEP" value="0x02"/>
+  <define name="wxPG_VFB_MARK_CELL" value="0x04"/>
+  <define name="wxPG_VFB_SHOW_MESSAGE" value="0x08"/>
+  <define name="wxPG_VFB_SHOW_MESSAGEBOX" value="0x10"/>
+  <define name="wxPG_VFB_SHOW_MESSAGE_ON_STATUSBAR" value="0x20"/>
+  <define name="wxPG_VFB_DEFAULT" value="20"/>
+  <define name="wxPG_VFB_UNDEFINED" value="0x80"/>
+  <define name="wxPG_ACTION_INVALID" value="0"/>
+  <define name="wxPG_ACTION_NEXT_PROPERTY" value="1"/>
+  <define name="wxPG_ACTION_PREV_PROPERTY" value="2"/>
+  <define name="wxPG_ACTION_EXPAND_PROPERTY" value="3"/>
+  <define name="wxPG_ACTION_COLLAPSE_PROPERTY" value="4"/>
+  <define name="wxPG_ACTION_CANCEL_EDIT" value="5"/>
+  <define name="wxPG_ACTION_EDIT" value="6"/>
+  <define name="wxPG_ACTION_PRESS_BUTTON" value="7"/>
+  <define name="wxPG_ACTION_MAX" value="8"/>
+  <define name="wxPG_SEL_FOCUS" value="0x0001"/>
+  <define name="wxPG_SEL_FORCE" value="0x0002"/>
+  <define name="wxPG_SEL_NONVISIBLE" value="0x0004"/>
+  <define name="wxPG_SEL_NOVALIDATE" value="0x0008"/>
+  <define name="wxPG_SEL_DELETING" value="0x0010"/>
+  <define name="wxPG_SEL_SETUNSPEC" value="0x0020"/>
+  <define name="wxPG_SEL_DIALOGVAL" value="0x0040"/>
+  <define name="wxPG_SEL_DONT_SEND_EVENT" value="0x0080"/>
+  <define name="wxPG_SEL_NO_REFRESH" value="0x0100"/>
+  <define name="wxPG_SPLITTER_REFRESH" value="0x0001"/>
+  <define name="wxPG_SPLITTER_ALL_PAGES" value="0x0002"/>
+  <define name="wxPG_SPLITTER_FROM_EVENT" value="0x0004"/>
+  <define name="wxPG_SPLITTER_FROM_AUTO_CENTER" value="0x0008"/>
+  <define name="wxPG_FL_INITIALIZED" value="0x0001"/>
+  <define name="wxPG_FL_ACTIVATION_BY_CLICK" value="0x0002"/>
+  <define name="wxPG_FL_DONT_CENTER_SPLITTER" value="0x0004"/>
+  <define name="wxPG_FL_FOCUSED" value="0x0008"/>
+  <define name="wxPG_FL_MOUSE_CAPTURED" value="0x0010"/>
+  <define name="wxPG_FL_MOUSE_INSIDE" value="0x0020"/>
+  <define name="wxPG_FL_VALUE_MODIFIED" value="0x0040"/>
+  <define name="wxPG_FL_PRIMARY_FILLS_ENTIRE" value="0x0080"/>
+  <define name="wxPG_FL_CUR_USES_CUSTOM_IMAGE" value="0x0100"/>
+  <define name="wxPG_FL_CELL_OVERRIDES_SEL" value="0x0200"/>
+  <define name="wxPG_FL_SCROLLED" value="0x0400"/>
+  <define name="wxPG_FL_ADDING_HIDEABLES" value="0x0800"/>
+  <define name="wxPG_FL_NOSTATUSBARHELP" value="0x1000"/>
+  <define name="wxPG_FL_CREATEDSTATE" value="0x2000"/>
+  <define name="wxPG_FL_DESC_REFRESH_REQUIRED" value="0x8000"/>
+  <define name="wxPG_FL_IN_MANAGER" value="0x00020000"/>
+  <define name="wxPG_FL_GOOD_SIZE_SET" value="0x00040000"/>
+  <define name="wxPG_FL_IN_SELECT_PROPERTY" value="0x00100000"/>
+  <define name="wxPG_FL_STRING_IN_STATUSBAR" value="0x00200000"/>
+  <define name="wxPG_FL_CATMODE_AUTO_SORT" value="0x01000000"/>
+  <define name="wxPG_MAN_FL_PAGE_INSERTED" value="0x02000000"/>
+  <define name="wxPG_FL_ABNORMAL_EDITOR" value="0x04000000"/>
+  <define name="wxPG_FL_IN_HANDLECUSTOMEDITOREVENT" value="0x08000000"/>
+  <define name="wxPG_FL_VALUE_CHANGE_IN_EVENT" value="0x10000000"/>
+  <define name="wxPG_FL_FIXED_WIDTH_EDITOR" value="0x20000000"/>
+  <define name="wxPG_FL_HAS_VIRTUAL_WIDTH" value="0x40000000"/>
+  <define name="wxPG_FL_RECALCULATING_VIRTUAL_SIZE" value="0x80000000"/>
   <define name="wxPG_ITERATE_PROPERTIES" value="1610634272"/>
   <define name="wxPG_ITERATE_HIDDEN" value="2097156"/>
   <define name="wxPG_ITERATE_FIXED_CHILDREN" value="1677743136"/>
@@ -3599,15 +4079,15 @@
   <define name="wxPG_EX_WINDOW_PGMAN_STYLE_MASK" value="419471360"/>
   <define name="wxPG_EX_WINDOW_STYLE_MASK" value="528068608"/>
   <define name="wxPG_EX_DISABLE_TLP_TRACKING" value="0"/>
-  <define name="wxPG_VFB_STAY_IN_PROPERTY" value="0x01"/>
-  <define name="wxPG_VFB_BEEP" value="0x02"/>
-  <define name="wxPG_VFB_MARK_CELL" value="0x04"/>
-  <define name="wxPG_VFB_SHOW_MESSAGE" value="0x08"/>
-  <define name="wxPG_VFB_SHOW_MESSAGEBOX" value="0x10"/>
-  <define name="wxPG_VFB_SHOW_MESSAGE_ON_STATUSBAR" value="0x20"/>
-  <define name="wxPG_VFB_DEFAULT" value="20"/>
-  <define name="wxPG_VFB_UNDEFINED" value="0x80"/>
   <define name="wxPGVFBFlags" value="unsigned char"/>
+  <define name="wxTL_SINGLE" value="0x0000"/>
+  <define name="wxTL_MULTIPLE" value="0x0001"/>
+  <define name="wxTL_CHECKBOX" value="0x0002"/>
+  <define name="wxTL_3STATE" value="0x0004"/>
+  <define name="wxTL_USER_3STATE" value="0x0008"/>
+  <define name="wxTL_NO_HEADER" value="0x0010"/>
+  <define name="wxTL_DEFAULT_STYLE" value="0x0000"/>
+  <define name="wxTL_STYLE_MASK" value="1"/>
   <define name="wxNUM_VAL_DEFAULT" value="0x00"/>
   <define name="wxNUM_VAL_THOUSANDS_SEPARATOR" value="0x01"/>
   <define name="wxNUM_VAL_ZERO_AS_BLANK" value="0x02"/>
@@ -3638,6 +4118,19 @@
   <define name="wxPAGE_EVEN" value="1"/>
   <define name="wxPAGE_ALL" value="2"/>
   <!-- End of wxPropertyGrid defines -->
+  <define name="wxDL_LAZY" value="0x00000001"/>
+  <define name="wxDL_NOW" value="0x00000002"/>
+  <define name="wxDL_GLOBAL" value="0x00000004"/>
+  <define name="wxDL_VERBATIM" value="0x00000008"/>
+  <define name="wxDL_NOSHARE" value="0x00000010"/>
+  <define name="wxDL_QUIET" value="0x00000020"/>
+  <define name="wxDL_GET_LOADED" value="0x00000040"/>
+  <define name="wxDL_DEFAULT" value="0x00000002"/>
+  <define name="wxDL_LIBRARY" value="0"/>
+  <define name="wxDL_MODULE" value="1"/>
+  <define name="wxDL_PLUGIN_GUI" value="0"/>
+  <define name="wxDL_PLUGIN_BASE" value="1"/>
+  <define name="wxDL_INIT_FUNC(pfx, name, dynlib)" value="pfx ## name = static_cast &gt; name ## _t &lt;((dynlib).RawGetSymbol(#name))"/>
   <define name="wxKEY_NONE" value="0"/>
   <define name="wxKEY_INTEGER" value="1"/>
   <define name="wxKEY_STRING" value="2"/>
@@ -3809,6 +4302,26 @@
   <define name="WXK_LAUNCH_MAIL" value="435"/>
   <define name="WXK_LAUNCH_APP1" value="436"/>
   <define name="WXK_LAUNCH_APP2" value="437"/>
+  <define name="_WX_DECLARE_TYPEINFO_CUSTOM(CLS,IDENTFUNC)" value=""/>
+  <define name="WX_DECLARE_TYPEINFO_INLINE(CLS)" value=""/>
+  <define name="WX_DECLARE_TYPEINFO(CLS)" value=""/>
+  <define name="WX_DEFINE_TYPEINFO(CLS)" value=""/>
+  <define name="WX_DECLARE_ABSTRACT_TYPEINFO(CLS)" value=""/>
+  <define name="WX_PG_DECLARE_BASIC_TYPE_METHODS()" value=""/>
+  <define name="WX_PG_IMPLEMENT_VARIANT_DATA(classname)" value=""/>
+  <define name="WX_PG_IMPLEMENT_VARIANT_DATA_EXPORTED_DUMMY_EQ(classname,value)" value=""/>
+  <define name="WX_PG_IMPLEMENT_VARIANT_DATA_DUMMY_EQ(classname)" value=""/>
+  <define name="WX_PG_DECLARE_DERIVED_PROPERTY_CLASS(classname)" value=""/>
+  <define name="WX_PG_IMPLEMENT_DERIVED_PROPERTY_CLASS(NAME,UPNAME,T_AS_ARG)" value=""/>
+  <define name="WX_PG_DECLARE_CHOICE_METHODS()" value=""/>
+  <define name="WX_PG_DECLARE_EVENT_METHODS()" value=""/>
+  <define name="WX_PG_DECLARE_PARENTAL_METHODS()" value=""/>
+  <define name="WX_PG_DECLARE_CUSTOM_PAINT_METHODS()" value=""/>
+  <define name="WX_PG_DECLARE_ATTRIBUTE_METHODS()" value=""/>
+  <define name="WX_PG_DECLARE_VALIDATOR_METHODS()" value=""/>
+  <define name="WX_PG_DECLARE_PROPERTY_CLASS(name)" value=""/>
+  <define name="WX_PG_IMPLEMENT_PROPERTY_CLASS_PLAIN(PROPNAME,T,EDITOR)" value=""/>
+  <define name="WX_PG_IMPLEMENT_PROPERTY_CLASS(NAME,UPCLASS,T,T_AS_ARG,EDITOR)" value=""/>
   <define name="wxDEFAULT" value="70"/>
   <define name="wxDECORATIVE" value="71"/>
   <define name="wxROMAN" value="72"/>
@@ -4255,17 +4768,39 @@
   <define name="wxRED_BRUSH" value="wxStockGDI::GetBrush(wxStockGDI::BRUSH_RED)"/>
   <define name="wxTRANSPARENT_BRUSH" value="wxStockGDI::GetBrush(wxStockGDI::BRUSH_TRANSPARENT)"/>
   <define name="wxWHITE_BRUSH" value="wxStockGDI::GetBrush(wxStockGDI::BRUSH_WHITE)"/>
-  <define name="wxBLACK" value="wxStockGDI::GetColour(wxStockGDI::COLOUR_BLACK)"/>
-  <define name="wxBLUE" value="wxStockGDI::GetColour(wxStockGDI::COLOUR_BLUE)"/>
-  <define name="wxCYAN" value="wxStockGDI::GetColour(wxStockGDI::COLOUR_CYAN)"/>
-  <define name="wxGREEN" value="wxStockGDI::GetColour(wxStockGDI::COLOUR_GREEN)"/>
-  <define name="wxYELLOW" value="wxStockGDI::GetColour(wxStockGDI::COLOUR_YELLOW)"/>
-  <define name="wxLIGHT_GREY" value="wxStockGDI::GetColour(wxStockGDI::COLOUR_LIGHTGREY)"/>
-  <define name="wxRED" value="wxStockGDI::GetColour(wxStockGDI::COLOUR_RED)"/>
-  <define name="wxWHITE" value="wxStockGDI::GetColour(wxStockGDI::COLOUR_WHITE)"/>
+  <define name="wxNullColour" value="wxColour()"/>
+  <define name="wxTransparentColour" value="wxColour()"/>
+  <define name="wxBLACK" value="new wxColour()"/>
+  <define name="wxBLUE" value="new wxColour()"/>
+  <define name="wxCYAN" value="new wxColour()"/>
+  <define name="wxGREEN" value="new wxColour()"/>
+  <define name="wxYELLOW" value="new wxColour()"/>
+  <define name="wxLIGHT_GREY" value="new wxColour()"/>
+  <define name="wxRED" value="new wxColour()"/>
+  <define name="wxWHITE" value="new wxColour()"/>
   <define name="wxCROSS_CURSOR" value="wxStockGDI::GetCursor(wxStockGDI::CURSOR_CROSS)"/>
   <define name="wxHOURGLASS_CURSOR" value="wxStockGDI::GetCursor(wxStockGDI::CURSOR_HOURGLASS)"/>
   <define name="wxSTANDARD_CURSOR" value="wxStockGDI::GetCursor(wxStockGDI::CURSOR_STANDARD)"/>
+  <define name="wxS_IRUSR" value="00400"/>
+  <define name="wxS_IWUSR" value="00200"/>
+  <define name="wxS_IXUSR" value="00100"/>
+  <define name="wxS_IRGRP" value="00040"/>
+  <define name="wxS_IWGRP" value="00020"/>
+  <define name="wxS_IXGRP" value="00010"/>
+  <define name="wxS_IROTH" value="00004"/>
+  <define name="wxS_IWOTH" value="00002"/>
+  <define name="wxS_IXOTH" value="00001"/>
+  <define name="wxPOSIX_USER_READ" value="00400"/>
+  <define name="wxPOSIX_USER_WRITE" value="00200"/>
+  <define name="wxPOSIX_USER_EXECUTE" value="00100"/>
+  <define name="wxPOSIX_GROUP_READ" value="00040"/>
+  <define name="wxPOSIX_GROUP_WRITE" value="00020"/>
+  <define name="wxPOSIX_GROUP_EXECUTE" value="00010"/>
+  <define name="wxPOSIX_OTHERS_READ" value="00004"/>
+  <define name="wxPOSIX_OTHERS_WRITE" value="00002"/>
+  <define name="wxPOSIX_OTHERS_EXECUTE" value="00001"/>
+  <define name="wxS_DEFAULT" value="2"/>
+  <define name="wxS_DIR_DEFAULT" value="3"/>
   <define name="wxPG_INVALID_VALUE" value="INT_MAX"/>
   <define name="wxPG_DONT_RECURSE" value="0x00000000"/>
   <define name="wxPG_BASE_OCT" value="(long)8"/>
@@ -4318,7 +4853,7 @@
   <define name="wxPG_PROP_BEING_DELETED" value="0x00200000"/>
   <define name="wxPG_PROP_CLASS_SPECIFIC_3" value="0x00400000"/>
   <define name="wxPG_PROP_MAX" value="wxPG_PROP_AUTO_UNSPECIFIED"/>
-  <define name="wxNullProperty" value="((wxPGProperty*)NULL)"/>
+  <define name="wxNullProperty" value="((wxPGProperty*)nullptr)"/>
   <define name="wxPG_ATTR_DEFAULT_VALUE" value="wxS(&quot;DefaultValue&quot;)"/>
   <define name="wxPG_ATTR_MIN" value="wxS(&quot;Min&quot;)"/>
   <define name="wxPG_ATTR_MAX" value="wxS(&quot;Max&quot;)"/>
@@ -4575,20 +5110,42 @@
   <define name="wxLANGUAGE_ZULU" value="233"/>
   <define name="wxLANGUAGE_KABYLE" value="234"/>
   <define name="wxLANGUAGE_USER_DEFINED" value="235"/>
+  <define name="wxXML_NO_INDENTATION" value="(-1)"/>
+  <define name="wxXML_ELEMENT_NODE" value="1"/>
+  <define name="wxXML_ATTRIBUTE_NODE" value="2"/>
+  <define name="wxXML_TEXT_NODE" value="3"/>
+  <define name="wxXML_CDATA_SECTION_NODE" value="4"/>
+  <define name="wxXML_ENTITY_REF_NODE" value="5"/>
+  <define name="wxXML_ENTITY_NODE" value="6"/>
+  <define name="wxXML_PI_NODE" value="7"/>
+  <define name="wxXML_COMMENT_NODE" value="8"/>
+  <define name="wxXML_DOCUMENT_NODE" value="9"/>
+  <define name="wxXML_DOCUMENT_TYPE_NODE" value="10"/>
+  <define name="wxXML_DOCUMENT_FRAG_NODE" value="11"/>
+  <define name="wxXML_NOTATION_NODE" value="12"/>
+  <define name="wxXML_HTML_DOCUMENT_NODE" value="13"/>
+  <define name="wxXMLDOC_NONE" value="0"/>
+  <define name="wxXMLDOC_KEEP_WHITESPACE_NODES" value="1"/>
   <define name="wxInvalidOffset" value="-1"/>
-  <define name="wxPATH_NATIVE" value="0"/>
-  <define name="wxPATH_UNIX" value="1"/>
-  <define name="wxPATH_BEOS" value="1"/>
-  <define name="wxPATH_MAC" value="2"/>
-  <define name="wxPATH_DOS" value="3"/>
-  <define name="wxPATH_WIN" value="3"/>
-  <define name="wxPATH_OS2" value="3"/>
-  <define name="wxPATH_VMS" value="4"/>
-  <define name="wxPATH_MAX" value="5"/>
-  <define name="wxSHUTDOWN_FORCE" value="1"/>
-  <define name="wxSHUTDOWN_POWEROFF" value="2"/>
-  <define name="wxSHUTDOWN_REBOOT" value="4"/>
-  <define name="wxSHUTDOWN_LOGOFF" value="8"/>
+  <define name="wxEVENT_PROPAGATE_NONE" value="0"/>
+  <define name="wxEVENT_PROPAGATE_MAX" value="INT_MAX"/>
+  <define name="WXK_CATEGORY_ARROW" value="1"/>
+  <define name="WXK_CATEGORY_PAGING" value="2"/>
+  <define name="WXK_CATEGORY_JUMP" value="4"/>
+  <define name="WXK_CATEGORY_TAB" value="8"/>
+  <define name="WXK_CATEGORY_CUT" value="16"/>
+  <define name="WXK_CATEGORY_NAVIGATION" value="7"/>
+  <define name="wxIDLE_PROCESS_SPECIFIED" value="1"/>
+  <define name="wxIDLE_PROCESS_ALL" value="0"/>
+  <define name="wxEVT_CATEGORY_UI" value="1"/>
+  <define name="wxEVT_CATEGORY_USER_INPUT" value="2"/>
+  <define name="wxEVT_CATEGORY_SOCKET" value="4"/>
+  <define name="wxEVT_CATEGORY_TIMER" value="8"/>
+  <define name="wxEVT_CATEGORY_THREAD" value="16"/>
+  <define name="wxEVT_CATEGORY_UNKNOWN" value="32"/>
+  <define name="wxEVT_CATEGORY_CLIPBOARD" value="64"/>
+  <define name="wxEVT_CATEGORY_NATIVE_EVENTS" value="3"/>
+  <define name="wxEVT_CATEGORY_ALL" value="127"/>
   <define name="wxStrip_Mnemonics" value="1"/>
   <define name="wxStrip_Accel" value="2"/>
   <define name="wxStrip_All" value="3"/>
@@ -4656,10 +5213,18 @@
   <!-- typedef unsigned short wxDateTime_t; -->
   <podtype name="wxDateTime_t" sign="u"/>
   <podtype name="wxLogLevel"/>
+  <!-- https://docs.wxwidgets.org/latest/classwx_icon_bundle.html -->
+  <define name="FALLBACK_NONE" value="0"/>
+  <define name="FALLBACK_SYSTEM" value="1"/>
+  <define name="FALLBACK_NEAREST_LARGER" value="2"/>
   <!-- https://docs.wxwidgets.org/trunk/group__group__class__smartpointers.html -->
   <smart-pointer class-name="wxObjectDataPtr"/>
-  <smart-pointer class-name="wxScopedArray"/>
-  <smart-pointer class-name="wxScopedPtr"/>
+  <smart-pointer class-name="wxScopedArray">
+    <unique/>
+  </smart-pointer>
+  <smart-pointer class-name="wxScopedPtr">
+    <unique/>
+  </smart-pointer>
   <smart-pointer class-name="wxSharedPtr"/>
   <smart-pointer class-name="wxWeakRefDynamic"/>
   <smart-pointer class-name="wxWeakRef"/>
@@ -4675,10 +5240,10 @@
       <function name="clear" action="clear"/>
       <function name="Clear" action="clear"/>
       <function name="Empty" action="clear"/>
-      <function name="size" yields="size"/>
-      <function name="length" yields="size"/>
-      <function name="Length" yields="size"/>
-      <function name="Len" yields="size"/>
+      <function name="size" yields="size" returnType="std::size_t"/>
+      <function name="length" yields="size" returnType="std::size_t"/>
+      <function name="Length" yields="size" returnType="std::size_t"/>
+      <function name="Len" yields="size" returnType="std::size_t"/>
       <function name="empty" yields="empty"/>
       <function name="IsEmpty" yields="empty"/>
       <function name="IsNull" yields="empty"/>
@@ -4743,9 +5308,20 @@
     <leak-ignore/>
     <arg nr="1" direction="in"/>
     <arg nr="2" direction="in"/>
-    <arg nr="3" direction="in" default="bool">
+    <arg nr="3" direction="in" default="true">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxString::SetChar(size_t n, wxUniChar ch) -->
+  <function name="wxString::SetChar">
+    <returnValue type="size_t"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>0:</valid>
     </arg>
+    <arg nr="2" direction="in"/>
   </function>
   <!-- wxUniChar wxString::GetChar(size_t n) const -->
   <function name="wxString::GetChar">
@@ -4756,8 +5332,17 @@
     <const/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
+  <!-- bool wxPowerResourceBlocker::IsInEffect(void) const -->
+  <function name="wxPowerResourceBlocker::IsInEffect">
+    <returnValue type="bool"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+  </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_string.html#a9588b7f2684b9a6a924dc3746a2b2f8d -->
   <!-- int wxString::Printf(const wxString & format, ...) -->
   <function name="wxString::Printf">
@@ -4772,6 +5357,20 @@
       <not-bool/>
     </arg>
   </function>
+  <!-- void wxLogStatus(const char * format, ...) -->
+  <!-- void wxLogSysError(const char * format, ...) -->
+  <function name="wxLogStatus,wxLogSysError">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <formatstr/>
+    <arg nr="1" direction="in">
+      <formatstr/>
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
   <!--static wxString wxStandardPaths::MSWGetShellDir(int csidl)-->
   <function name="wxStandardPaths::MSWGetShellDir">
     <noreturn>false</noreturn>
@@ -4781,19 +5380,21 @@
     <pure/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!--#define wxSTRINGIZE_T(x) -->
   <!--#define wxSTRINGIZE(x) -->
   <!--These are defined as macros in wxWidgets. Non the less, this is configured as
       as function to catch unused return values. -->
-  <function name="wxSTRINGIZE_T,wxSTRINGSIZE">
+  <function name="wxSTRINGIZE_T,wxSTRINGIZE">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="wxString"/>
+    <returnValue type="wxString">"#arg1"</returnValue>
     <use-retval/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!--#define wxCONCAT(x1,x2) -->
@@ -4809,23 +5410,26 @@
     <use-retval/>
     <arg nr="any" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_string.html#ace32756bab999f8aae9be0cf981fc449 -->
-  <!-- bool wxString::IsEmpty() -->
+  <!-- bool wxString::IsEmpty() const -->
   <function name="wxString::IsEmpty">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="bool"/>
     <use-retval/>
+    <const/>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_string.html#ae0a2020695a6ecd9ee49c14fe7429176 -->
-  <!-- bool wxString::IsNull() -->
+  <!-- bool wxString::IsNull() const -->
   <function name="wxString::IsNull">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="bool"/>
     <use-retval/>
+    <const/>
     <warn severity="style">This is the same as 'wxString::IsEmpty' and is kept for wxWidgets 1.xx compatibility. You should not use it in new code.</warn>
   </function>
   <!-- bool wxString::Contains(const wxString & str) const-->
@@ -4845,6 +5449,7 @@
     <leak-ignore/>
     <returnValue type="bool"/>
     <use-retval/>
+    <warn severity="style">This is a wxWidgets 1.xx compatibility function; you should not use it in new code.</warn>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_string.html#a932ddb6b4786213596c3e41b1fa1f7c5 -->
   <!-- bool wxString::IsAscii() -->
@@ -4861,20 +5466,22 @@
     <leak-ignore/>
     <returnValue type="bool"/>
     <use-retval/>
+    <warn severity="style">This is a wxWidgets 1.xx compatibility function; you should not use it in new code.</warn>
   </function>
-  <!-- http://docs.wxwidgets.org/trunk/classwx_string.html#ab20a87ca731a52c36ec674dae2213ad8 -->
-  <!-- size_t wxString::Len () const -->
-  <!-- size_t wxString::length () const -->
-  <function name="wxString::Len,wxString::length">
+  <!-- wxUniChar     wxString::Last () const -->
+  <!-- wxUniCharRef  wxString::Last () const -->
+  <function name="wxString::Last">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <const/>
-    <returnValue type="size_t"/>
+    <returnValue type="wxUniChar"/>
     <use-retval/>
+    <warn severity="style">This is a wxWidgets 1.xx compatibility function; you should not use it in new code.</warn>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_string.html#ab20a87ca731a52c36ec674dae2213ad8 -->
   <!-- size_t wxString::Length () const -->
-  <function name="wxString::Length">
+  <!-- size_t wxString::length () const -->
+  <function name="wxString::Length,wxString::length">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <const/>
@@ -4896,7 +5503,6 @@
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="wxString &amp;"/>
-    <use-retval/>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_string.html#ab20a87ca731a52c36ec674dae2213ad8 -->
   <!-- wxString& wxString::MakeLower()-->
@@ -4904,7 +5510,6 @@
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="wxString &amp;"/>
-    <use-retval/>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_string.html#ab20a87ca731a52c36ec674dae2213ad8 -->
   <!-- wxString& wxString::MakeUpper()-->
@@ -4912,7 +5517,6 @@
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="wxString &amp;"/>
-    <use-retval/>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_string.html#ab20a87ca731a52c36ec674dae2213ad8 -->
   <!-- bool wxString::Matches(const wxString & mask) const -->
@@ -4924,13 +5528,6 @@
     <const/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- http://docs.wxwidgets.org/trunk/classwx_string.html#ab20a87ca731a52c36ec674dae2213ad8 -->
-  <!-- void wxString::LowerCase() -->
-  <function name="wxString::LowerCase">
-    <noreturn>false</noreturn>
-    <leak-ignore/>
-    <warn severity="style">This is the same as 'wxString::MakeLower' and is kept for wxWidgets 1.xx compatibility. You should not use it in new code.</warn>
-  </function>
   <!-- http://docs.wxwidgets.org/trunk/group__group__funcmacro__log.html#gaec3640fa3b46c970ff0c86fe354e59ff -->
   <!-- unsigned long wxSysErrorCode() -->
   <function name="wxSysErrorCode">
@@ -4977,6 +5574,18 @@
       <not-bool/>
     </arg>
   </function>
+  <!-- #define wxLogApiError(api, rc) -->
+  <function name="wxLogApiError">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- http://docs.wxwidgets.org/trunk/group__group__funcmacro__log.html#ga4ae39c06cbeaa5461cd1b5c293a31403 -->
   <!-- void wxLogFatalError(const char * formatString, ...) -->
   <function name="wxLogFatalError">
@@ -5075,18 +5684,30 @@
       <not-bool/>
     </arg>
   </function>
-  <!-- http://docs.wxwidgets.org/trunk/classwx_spin_ctrl.html#a1db15e6f350f71f2fcba821ce69a531c	-->
-  <!-- int wxSpinCtrl::GetMax() const	-->
-  <!-- int wxSpinCtrl::GetMin() const	-->
-  <!-- int wxSpinCtrl::GetBase() const	-->
-  <!-- int wxSpinCtrl::GetValue() const	-->
+  <!-- http://docs.wxwidgets.org/trunk/classwx_spin_ctrl.html#a1db15e6f350f71f2fcba821ce69a531c -->
+  <!-- int wxSpinCtrl::GetMax() const -->
+  <!-- int wxSpinCtrl::GetMin() const -->
+  <!-- int wxSpinCtrl::GetBase() const -->
+  <!-- int wxSpinCtrl::GetValue() const -->
   <function name="wxSpinCtrl::GetMax,wxSpinCtrl::GetMin,wxSpinCtrl::GetBase,wxSpinCtrl::GetValue">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <use-retval/>
+    <const/>
     <returnValue type="int"/>
   </function>
-  <!-- http://docs.wxwidgets.org/trunk/classwx_spin_ctrl.html#a1db15e6f350f71f2fcba821ce69a531c	-->
+  <!-- virtual bool wxCheckBox::GetValue( void ) const -->
+  <!--         bool wxCheckBox::IsChecked( void ) const -->
+  <!--         bool wxCheckBox::Is3State( void ) const -->
+  <!--         bool wxCheckBox::Is3rdStateAllowedForUser( void ) const -->
+  <function name="wxCheckBox::GetValue,wxCheckBox::IsChecked,wxCheckBox::Is3State,wxCheckBox::Is3rdStateAllowedForUser">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <returnValue type="bool"/>
+  </function>
+  <!-- http://docs.wxwidgets.org/trunk/classwx_spin_ctrl.html#a1db15e6f350f71f2fcba821ce69a531c -->
   <!-- bool wxSpinCtrl::SetBase (int base)-->
   <function name="wxSpinCtrl::SetBase">
     <noreturn>false</noreturn>
@@ -5099,6 +5720,14 @@
       <not-bool/>
     </arg>
   </function>
+  <!-- const wxColour & wxGridCellAttr::GetTextColour( void ) const -->
+  <function name="wxGridCellAttr::GetTextColour">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="const wxColour &amp;"/>
+      <use-retval/>
+      <const/>
+  </function>
   <!-- void wxGrid::HideRow(int row)-->
   <!-- void wxGrid::ShowRow(int row)-->
   <!-- void wxGrid::HideCol(int col)-->
@@ -5114,19 +5743,90 @@
       <not-bool/>
     </arg>
   </function>
-  <!-- http://docs.wxwidgets.org/3.1/classwx_spin_ctrl_double.html-->
-  <!-- unsigned int wxSpinCtrlDouble::GetDigits()	const-->
-  <function name="wxSpinCtrlDouble::GetDigits">
-    <noreturn>false</noreturn>
-    <leak-ignore/>
-    <use-retval/>
-    <returnValue type="unsigned int"/>
+  <!-- wxGridTableBase * wxGrid::GetTable( void ) const -->
+  <function name="wxGrid::GetTable">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxGridTableBase *"/>
+      <use-retval/>
+      <const/>
   </function>
-  <!-- http://docs.wxwidgets.org/3.1/classwx_spin_ctrl_double.html-->
-  <!-- double wxSpinCtrlDouble::GetIncrement()	const-->
-  <function name="wxSpinCtrlDouble::GetIncrement">
+  <!-- void wxGrid::EnableCellEditControl(bool enable=true )-->
+  <function name="wxGrid::EnableCellEditControl">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxGrid::DisableCellEditControl(void)-->
+  <!-- void wxGrid::ShowCellEditControl(void)-->
+  <!-- void wxGrid::HideCellEditControl(void)-->
+  <!-- void wxGrid::SaveEditControlValue(void)-->
+  <function name="wxGrid::DisableCellEditControl,wxGrid::ShowCellEditControl,wxGrid::HideCellEditControl,wxGrid::SaveEditControlValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- bool wxGrid::CanEnableCellControl(void) const-->
+  <!-- bool wxGrid::IsCellEditControlEnabled(void) const-->
+  <!-- bool wxGrid::IsEditable(void) const-->
+  <!-- bool wxGrid::IsCellEditControlShown(void) const-->
+  <!-- bool wxGrid::IsCurrentCellReadOnly(void) const-->
+  <function name="wxGrid::DisableCellEditControl,wxGrid::IsCellEditControlEnabled,wxGrid::IsCellEditControlShown,wxGrid::IsCurrentCellReadOnly,wxGrid::IsEditable">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <const/>
+    <use-retval/>
+    <returnValue type="bool"/>
+  </function>
+  <!-- virtual wxString wxListBox::GetString (unsigned int n) const-->
+  <!-- virtual wxString wxChoice::GetString (unsigned int n) const-->
+  <function name="wxListBox::GetString,wxChoice::GetString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <returnValue type="wxString"/>
+    <arg nr="1" direction="in">
+      <valid>0:</valid>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!--virtual int wxListBox::GetSelection(void) const-->
+  <function name="wxListBox::GetSelection">
+    <noreturn>false</noreturn>
+    <const/>
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="int"/>
+  </function>
+  <!--virtual int wxListBox::GetSelections(wxArrayInt & selections) const-->
+  <function name="wxListBox::GetSelections">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <const/>
+    <use-retval/>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- http://docs.wxwidgets.org/3.1/classwx_spin_ctrl_double.html-->
+  <!-- unsigned int wxSpinCtrlDouble::GetDigits() const-->
+  <function name="wxSpinCtrlDouble::GetDigits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <const/>
+    <use-retval/>
+    <returnValue type="unsigned int"/>
+  </function>
+  <!-- http://docs.wxwidgets.org/3.1/classwx_spin_ctrl_double.html-->
+  <!-- double wxSpinCtrlDouble::GetIncrement() const-->
+  <function name="wxSpinCtrlDouble::GetIncrement">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <const/>
     <use-retval/>
     <returnValue type="double"/>
   </function>
@@ -5143,6 +5843,7 @@
   <function name="wxSpinCtrlDouble::GetMin">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <const/>
     <use-retval/>
     <returnValue type="double"/>
   </function>
@@ -5151,6 +5852,7 @@
   <function name="wxSpinCtrlDouble::GetValue">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <const/>
     <use-retval/>
     <returnValue type="double"/>
   </function>
@@ -5161,6 +5863,7 @@
     <leak-ignore/>
     <arg nr="1" direction="in">
       <valid>0:</valid>
+      <not-bool/>
       <not-uninit/>
     </arg>
   </function>
@@ -5180,19 +5883,36 @@
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- bool wxItemContainerImmutable::SetStringSelection( const wxString & s ) -->
   <!-- bool wxChoice::SetStringSelection( const wxString & s ) -->
-  <function name="wxItemContainerImmutable::SetStringSelection,wxChoice::SetStringSelection">
+  <!-- bool wxComboBox::SetStringSelection( const wxString & s ) -->
+  <function name="wxItemContainerImmutable::SetStringSelection,wxChoice::SetStringSelection,wxComboBox::SetStringSelection">
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
   </function>
+  <!-- void wxItemContainerImmutable::Select( int n ) -->
+  <!-- void wxChoice::Select( int n ) -->
+  <!-- void wxComboBox::Select( int n ) -->
+  <!-- void wxRadioBox::Select( int n ) -->
+  <!-- void wxListBox::Select( int n ) -->
+  <function name="wxItemContainerImmutable::Select,wxChoice::Select,wxComboBox::Select,wxRadioBox::Select,wxListBox::Select">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
   <!-- http://docs.wxwidgets.org/3.1/classwx_spin_ctrl_double.html-->
   <!-- virtual void wxSpinCtrlDouble::SetValue(const wxString & text)-->
   <!-- void wxSpinCtrlDouble::SetValue(double value)-->
@@ -5201,64 +5921,69 @@
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- http://docs.wxwidgets.org/trunk/classwx_slider.html	-->
-  <!-- int wxSlider::GetLineSize () const	-->
-  <!-- int wxSlider::GetMax () const	-->
-  <!-- int wxSlider::GetMin () const	-->
-  <!-- int wxSlider::GetPageSize () const	-->
-  <!-- int wxSlider::GetSelEnd () const	-->
-  <!-- int wxSlider::GetSelStart () const	-->
-  <!-- int wxSlider::GetThumbLength () const	-->
-  <!-- int wxSlider::GetTickFreq () const	-->
-  <!-- int wxSlider::GetValue () const	-->
+  <!-- http://docs.wxwidgets.org/trunk/classwx_slider.html  -->
+  <!-- int wxSlider::GetLineSize () const   -->
+  <!-- int wxSlider::GetMax () const    -->
+  <!-- int wxSlider::GetMin () const    -->
+  <!-- int wxSlider::GetPageSize () const   -->
+  <!-- int wxSlider::GetSelEnd () const -->
+  <!-- int wxSlider::GetSelStart () const   -->
+  <!-- int wxSlider::GetThumbLength () const    -->
+  <!-- int wxSlider::GetTickFreq () const   -->
+  <!-- int wxSlider::GetValue () const  -->
   <function name="wxSlider::GetLineSize,wxSlider::GetMax,wxSlider::GetMin,wxSlider::GetPageSize,wxSlider::GetSelEnd,wxSlider::GetSelStart,wxSlider::GetThumbLength,wxSlider::GetTickFreq,wxSlider::GetValue">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <use-retval/>
+    <const/>
     <returnValue type="int"/>
   </function>
-  <!-- http://docs.wxwidgets.org/trunk/classwx_timer.html	-->
-  <!-- int wxTimer::GetId () const	-->
-  <!-- int wxTimer::GetInterval () const	-->
+  <!-- http://docs.wxwidgets.org/trunk/classwx_timer.html   -->
+  <!-- int wxTimer::GetId () const  -->
+  <!-- int wxTimer::GetInterval () const    -->
   <function name="wxTimer::GetId,wxTimer::GetInterval">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <use-retval/>
+    <const/>
     <returnValue type="int"/>
   </function>
-  <!-- static int wxLocale::GetSystemLanguage(void)	-->
+  <!-- static int wxLocale::GetSystemLanguage(void) -->
   <function name="wxLocale::GetSystemLanguage">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <use-retval/>
     <returnValue type="int"/>
   </function>
-  <!-- http://docs.wxwidgets.org/trunk/classwx_timer.html	-->
-  <!-- wxEvtHandler * 	GetOwner () const	-->
+  <!-- http://docs.wxwidgets.org/trunk/classwx_timer.html   -->
+  <!-- wxEvtHandler * GetOwner () const -->
   <function name="wxTimer::GetOwner">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <const/>
     <use-retval/>
     <returnValue type="wxEvtHandler *"/>
   </function>
-  <!-- http://docs.wxwidgets.org/trunk/classwx_timer.html	-->
-  <!-- bool 	IsOneShot () const -->
-  <!-- bool 	IsRunning () const -->
+  <!-- http://docs.wxwidgets.org/trunk/classwx_timer.html   -->
+  <!-- bool wxTimer::IsOneShot () const -->
+  <!-- bool wxTimer::IsRunning () const -->
   <function name="wxTimer::IsOneShot,wxTimer::IsRunning">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <use-retval/>
+    <const/>
     <returnValue type="bool"/>
   </function>
-  <!-- http://docs.wxwidgets.org/trunk/classwx_timer.html	-->
+  <!-- http://docs.wxwidgets.org/trunk/classwx_timer.html   -->
   <!-- virtual void Notify ()-->
   <function name="wxTimer::Notify">
     <noreturn>false</noreturn>
     <leak-ignore/>
   </function>
-  <!-- http://docs.wxwidgets.org/trunk/classwx_timer.html	-->
+  <!-- http://docs.wxwidgets.org/trunk/classwx_timer.html   -->
   <!-- void SetOwner (wxEvtHandler *owner, int id=-1)-->
   <function name="wxTimer::SetOwner">
     <noreturn>false</noreturn>
@@ -5269,39 +5994,43 @@
     </arg>
     <arg nr="2" direction="in" default="-1">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- http://docs.wxwidgets.org/trunk/classwx_timer.html	-->
-  <!-- virtual bool Start (int milliseconds=-1, bool oneShot=wxTIMER_CONTINUOUS) -->
+  <!-- http://docs.wxwidgets.org/trunk/classwx_timer.html   -->
+  <!-- virtual bool wxTimer::Start (int milliseconds=-1, bool oneShot=wxTIMER_CONTINUOUS) -->
   <function name="wxTimer::Start">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="bool"/>
     <arg nr="1" direction="in" default="-1">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in" default="wxTIMER_CONTINUOUS">
       <not-uninit/>
     </arg>
   </function>
-  <!-- http://docs.wxwidgets.org/trunk/classwx_timer.html	-->
-  <!-- bool StartOnce (int milliseconds=-1) -->
+  <!-- http://docs.wxwidgets.org/trunk/classwx_timer.html   -->
+  <!-- bool wxTimer::StartOnce (int milliseconds=-1) -->
   <function name="wxTimer::StartOnce">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="bool"/>
     <arg nr="1" direction="in" default="-1">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- http://docs.wxwidgets.org/trunk/classwx_timer.html	-->
-  <!-- virtual void Stop () -->
+  <!-- http://docs.wxwidgets.org/trunk/classwx_timer.html   -->
+  <!-- virtual void wxTimer::Stop () -->
   <function name="wxTimer::Stop">
     <noreturn>false</noreturn>
     <leak-ignore/>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_radio_box.html -->
-  <!-- virtual bool Enable (unsigned int n, bool enable=true) -->
+  <!-- virtual bool wxRadioBox::Enable (unsigned int n, bool enable=true) -->
+  <!-- virtual bool wxRadioBox::Enable (bool enable=true) -->
   <function name="wxRadioBox::Enable">
     <noreturn>false</noreturn>
     <leak-ignore/>
@@ -5313,8 +6042,42 @@
       <not-uninit/>
     </arg>
   </function>
+  <!-- void wxWindowBase::SetSizerAndFit (wxSizer * sizer, bool deleteOld = true) -->
+  <!-- void wxWindow::SetSizerAndFit (wxSizer * sizer, bool deleteOld = true) -->
+  <!-- void wxPanel::SetSizerAndFit (wxSizer * sizer, bool deleteOld = true) -->
+  <function name="wxWindow::SetSizerAndFit,wxPanel::SetSizerAndFit,wxWindowBase::SetSizerAndFit">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in" default="true">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- static void wxLog::SetVerbose(bool verbose=true) -->
+  <function name="wxLog::SetVerbose">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in" default="true">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- static wxString wxLocale::GetLanguageName(int lang) -->
+  <function name="wxLocale::GetLanguageName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_radio_box.html -->
-  <!-- virtual int 	FindString (const wxString &string, bool bCase=false) const -->
+  <!-- virtual int wxRadioBox::FindString (const wxString &string, bool bCase=false) const -->
   <function name="wxRadioBox::FindString">
     <noreturn>false</noreturn>
     <leak-ignore/>
@@ -5328,7 +6091,7 @@
     </arg>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_radio_box.html -->
-  <!-- unsigned int GetColumnCount () const -->
+  <!-- unsigned int wxRadioBox::GetColumnCount () const -->
   <function name="wxRadioBox::GetColumnCount">
     <noreturn>false</noreturn>
     <leak-ignore/>
@@ -5337,7 +6100,7 @@
     <use-retval/>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_radio_box.html -->
-  <!-- virtual int GetItemFromPoint (const wxPoint &pt) const -->
+  <!-- virtual int wxRadioBox::GetItemFromPoint (const wxPoint &pt) const -->
   <function name="wxRadioBox::GetItemFromPoint">
     <noreturn>false</noreturn>
     <leak-ignore/>
@@ -5358,6 +6121,7 @@
     <use-retval/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_radio_box.html -->
@@ -5370,6 +6134,7 @@
     <use-retval/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_radio_box.html -->
@@ -5390,10 +6155,11 @@
     <const/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_radio_box.html -->
-  <!-- virtual bool IsItemShown (unsigned int n) const -->
+  <!-- virtual bool wxRadioBox::IsItemShown (unsigned int n) const -->
   <function name="wxRadioBox::IsItemShown">
     <noreturn>false</noreturn>
     <leak-ignore/>
@@ -5402,41 +6168,103 @@
     <use-retval/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_radio_box.html -->
-  <!-- void SetItemHelpText (unsigned int item, const wxString &helptext) -->
+  <!-- void wxRadioBox::SetItemHelpText (unsigned int item, const wxString &helptext) -->
   <function name="wxRadioBox::SetItemHelpText">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
     </arg>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_radio_box.html -->
-  <!-- void SetItemToolTip (unsigned int item, const wxString &text) -->
+  <!-- void wxRadioBox::SetItemToolTip (unsigned int item, const wxString &text) -->
   <function name="wxRadioBox::SetItemToolTip">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
     </arg>
   </function>
+  <!-- wxMenuItem* wxMenu::AppendSubMenu(wxMenu * submenu, const wxString & text, const wxString & help = wxEmptyString) -->
+  <function name="wxMenu::AppendSubMenu">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxMenuItem*"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in" default="wxEmptyString"/>
+  </function>
   <!-- void wxMenu::Enable(int id, bool enable) -->
   <!-- void wxMenu::Check(int id, bool check) -->
   <function name="wxMenu::Enable,wxMenu::Check">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="void"/>
-    <arg nr="any" direction="in">
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- virtual void wxMenu::SetHelpString(int id, const wxString & helpString) -->
+  <function name="wxMenu::SetHelpString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxStringTokenizer::SetString(const wxString & str, const wxString & delims = wxDEFAULT_DELIMITERS, wxStringTokenizerMode mode = wxTOKEN_DEFAULT) -->
+  <function name="wxStringTokenizer::SetString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="wxDEFAULT_DELIMITERS"/>
+    <arg nr="3" direction="in" default="wxTOKEN_DEFAULT"/>
+  </function>
+  <!-- wxStringTokenizerMode wxStringTokenizer::GetMode( void ) const -->
+  <function name="wxStringTokenizer::GetMode">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxStringTokenizerMode"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- wxString wxStringTokenizer::GetNextToken( void ) -->
+  <function name="wxStringTokenizer::GetNextToken">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxString"/>
+      <use-retval/>
+  </function>
+  <!-- size_t wxStringTokenizer::GetPosition( void ) const -->
+  <function name="wxStringTokenizer::GetPosition">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="size_t"/>
+      <use-retval/>
+      <const/>
   </function>
   <!-- virtual void wxTextEntry::SetSelection (long from, long to) -->
   <!-- virtual void wxTextEntry::SetSelection (int n) -->
@@ -5445,11 +6273,42 @@
   <!-- virtual void wxSpinCtrl::SetSelection (long from, long to) -->
   <!-- virtual void wxComboBox::SetSelection (long from, long to) -->
   <!-- virtual void wxComboBox::SetSelection (int n) -->
-  <function name="wxTextEntry::SetSelection,wxTextCtrl::SetSelection,wxSpinCtrl::SetSelection,wxComboBox::SetSelection,wxRadioBox::SetSelection">
+  <!-- virtual void wxComboCtrl::SetSelection (long from, long to) -->
+  <!-- virtual void wxComboCtrl::SetSelection (int n) -->
+  <!-- virtual void wxOwnerDrawnComboBox::SetSelection (long from, long to) -->
+  <!-- virtual void wxOwnerDrawnComboBox::SetSelection (int n) -->
+  <function name="wxTextEntry::SetSelection,wxTextCtrl::SetSelection,wxSpinCtrl::SetSelection,wxComboBox::SetSelection,wxRadioBox::SetSelection,wxComboCtrl::SetSelection,wxOwnerDrawnComboBox::SetSelection">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="any" direction="in">
       <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxTextPos wxTextCtrl::GetLastPosition( void ) const -->
+  <function name="wxTextCtrl::GetLastPosition">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxTextPos"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- bool wxTextCtrl::IsModified( void ) const -->
+  <function name="wxTextCtrl::IsModified">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="bool"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- bool wxTextCtrl::SaveFile(const wxString & filename = wxEmptyString, int fileType = wxTEXT_TYPE_ANY )-->
+  <function name="wxTextCtrl::SaveFile">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in" default="wxEmptyString"/>
+    <arg nr="2" direction="in" default="wxTEXT_TYPE_ANY">
+      <not-uninit/>
     </arg>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_radio_box.html -->
@@ -5460,11 +6319,30 @@
     <returnValue type="bool"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in" default="true">
       <not-uninit/>
     </arg>
   </function>
+  <!-- long wxListCtrl::InsertItem(wxListItem & info) -->
+  <!-- long wxListCtrl::InsertItem(long index, const wxString & label) -->
+  <!-- long wxListCtrl::InsertItem(long index, int imageIndex)-->
+  <!-- long wxListCtrl::InsertItem(long index, const wxString & label, int imageIndex)-->
+  <!-- long wxListView::InsertItem(wxListItem & info) -->
+  <!-- long wxListView::InsertItem(long index, const wxString & label) -->
+  <!-- long wxListView::InsertItem(long index, int imageIndex)-->
+  <!-- long wxListView::InsertItem(long index, const wxString & label, int imageIndex)-->
+  <function name="wxListCtrl::InsertItem,wxListView::InsertItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="any" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- virtual bool wxTopLevelWindowBase::Show (bool show=true) -->
   <!-- virtual bool wxWindow::Show (bool show=true) -->
   <!-- virtual bool wxStaticText::Show (bool show=true) -->
   <!-- virtual bool wxButton::Show (bool show=true) -->
@@ -5473,7 +6351,15 @@
   <!-- virtual bool wxPopupTransientWindow::Show (bool show=true) -->
   <!-- virtual bool wxSpinCtrl::Show (bool show=true) -->
   <!-- virtual bool wxChoice::Show (bool show=true) -->
-  <function name="wxWindow::Show,wxStaticText::Show,wxButton::Show,wxStaticBitmap::Show,wxTextCtrl::Show,wxPopupTransientWindow::Show,wxSpinCtrl::Show,wxChoice::Show">
+  <!-- virtual bool wxBitmapButton::Show (bool show=true) -->
+  <!-- virtual bool wxCheckBox::Show (bool show=true) -->
+  <!-- virtual bool wxFrame::Show (bool show=true) -->
+  <!-- virtual bool wxSashLayoutWindow::Show (bool show=true) -->
+  <!-- virtual bool wxPreviewFrame::Show (bool show=true) -->
+  <!-- virtual bool wxMenuBar::Show (bool show=true) -->
+  <!-- virtual bool wxFilePickerCtrl::Show (bool show=true) -->
+  <!-- virtual bool wxGrid::Show (bool show=true) -->
+  <function name="wxGrid::Show,wxFilePickerCtrl::Show,wxTopLevelWindowBase::Show,wxMenuBar::Show,wxWindow::Show,wxFrame::Show,wxPreviewFrame::Show,wxStaticText::Show,wxSashLayoutWindow::Show,wxButton::Show,wxStaticBitmap::Show,wxTextCtrl::Show,wxPopupTransientWindow::Show,wxSpinCtrl::Show,wxChoice::Show,wxBitmapButton::Show,wxCheckBox::Show">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="bool"/>
@@ -5481,6 +6367,16 @@
       <not-uninit/>
     </arg>
   </function>
+  <!-- virtual void wxWindow::DragAcceptFiles(bool accept) -->
+  <!-- virtual void wxTextCtrl::DragAcceptFiles(bool accept) -->
+  <function name="wxWindow::DragAcceptFiles,wxTextCtrl::DragAcceptFiles">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- bool wxSizer::Show(wxWindow * window, bool show = true, bool recursive = false) -->
   <!-- bool wxSizer::Show(wxSizer * window, bool show = true, bool recursive = false) -->
   <!-- bool wxSizer::Show(size_t index, bool show = true) -->
@@ -5490,7 +6386,10 @@
   <!-- bool wxBoxSizer::Show(wxWindow * window, bool show = true, bool recursive = false) -->
   <!-- bool wxBoxSizer::Show(wxSizer * window, bool show = true, bool recursive = false) -->
   <!-- bool wxBoxSizer::Show(size_t index, bool show = true) -->
-  <function name="wxSizer::Show,wxStaticBoxSizer::Show,wxBoxSizer::Show">
+  <!-- bool wxFlexGridSizer::Show(wxWindow * window, bool show = true, bool recursive = false) -->
+  <!-- bool wxFlexGridSizer::Show(wxSizer * window, bool show = true, bool recursive = false) -->
+  <!-- bool wxFlexGridSizer::Show(size_t index, bool show = true) -->
+  <function name="wxSizer::Show,wxStaticBoxSizer::Show,wxBoxSizer::Show,wxFlexGridSizer::Show">
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
     <leak-ignore/>
@@ -5521,6 +6420,26 @@
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- static wxString wxFontMapper::GetEncodingDescription(wxFontEncoding encoding)-->
+  <function name="wxFontMapper::GetEncodingDescription">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="wxString"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxSashWindow::SetSashVisible(wxSashEdgePosition edge, bool visible) -->
+  <!-- void wxSashLayoutWindow::SetSashVisible(wxSashEdgePosition edge, bool visible) -->
+  <function name="wxSashWindow::SetSashVisible,wxSashLayoutWindow::SetSashVisible">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
     </arg>
   </function>
   <!-- virtual void wxFont::SetStrikethrough (bool show=true) -->
@@ -5580,6 +6499,7 @@
     <const/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_radio_box.html -->
@@ -5589,6 +6509,7 @@
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
@@ -5622,6 +6543,7 @@
     <use-retval/>
   </function>
   <!--virtual bool wxWindow::Enable(bool enable = true)-->
+  <!--virtual bool wxComboBox::Enable(bool enable = true)-->
   <!--virtual bool wxButton::Enable(bool enable = true)-->
   <!--virtual bool wxAnyButton::Enable(bool enable = true)-->
   <!--virtual bool wxBitmapButton::Enable(bool enable = true)-->
@@ -5631,7 +6553,15 @@
   <!--virtual bool wxCommandLinkButton::Enable(bool enable = true)-->
   <!--virtual bool wxPropertyGridManager::Enable(bool enable = true)-->
   <!--virtual bool wxFilePickerCtrl::Enable(bool enable = true)-->
-  <function name="wxWindow::Enable,wxButton::Enable,wxAnyButton::Enable,wxCommandLinkButton::Enable,wxToggleButton::Enable,wxBitmapToggleButton::Enable,wxContextHelpButton::Enable,wxBitmapButton::Enable,wxPropertyGridManager::Enable,wxFilePickerCtrl::Enable">
+  <!--virtual bool wxStaticBitmap::Enable(bool enable = true)-->
+  <!--virtual bool wxSpinCtrl::Enable(bool enable = true)-->
+  <!--virtual bool wxSlider::Enable(bool enable = true)-->
+  <!--virtual bool wxChoice::Enable(bool enable = true)-->
+  <!--virtual bool wxOwnerDrawnComboBox::Enable(bool enable = true)-->
+  <!--virtual bool wxPanel::Enable(bool enable = true)-->
+  <!--virtual bool wxListBox::Enable(bool enable = true)-->
+  <!--virtual bool wxCheckListBox::Enable(bool enable = true)-->
+  <function name="wxWindow::Enable,wxListBox::Enable,wxCheckListBox::Enable,wxPanel::Enable,wxSlider::Enable,wxChoice::Enable,wxComboBox::Enable,wxButton::Enable,wxStaticBitmap::Enable,wxSpinCtrl::Enable,wxAnyButton::Enable,wxCommandLinkButton::Enable,wxToggleButton::Enable,wxOwnerDrawnComboBox::Enable,wxBitmapToggleButton::Enable,wxContextHelpButton::Enable,wxBitmapButton::Enable,wxPropertyGridManager::Enable,wxFilePickerCtrl::Enable">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="bool"/>
@@ -5658,12 +6588,11 @@
   <!-- void wxControl::SetLabel (const wxString &label) -->
   <!-- void wxButton::SetLabel (const wxString &label) -->
   <!-- void wxRadioBox::SetLabel (const wxString &label) -->
-  <function name="wxControl::SetLabel,wxButton::SetLabel,wxRadioBox::SetLabel">
+  <!-- void wxStaticBox::SetLabel (const wxString &label) -->
+  <function name="wxControl::SetLabel,wxButton::SetLabel,wxRadioBox::SetLabel,wxStaticBox::SetLabel">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
+    <arg nr="1" direction="in"/>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_colour.html -->
   <!-- virtual unsigned char Alpha () const -->
@@ -5681,6 +6610,7 @@
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- virtual void wxStaticBitmap::SetBitmap(const wxBitmap & label) -->
@@ -5846,6 +6776,16 @@
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- virtual void wxSlider::SetLineSize (int n) -->
+  <function name="wxSlider::SetLineSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_text_file.html -->
@@ -5867,6 +6807,7 @@
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="in" default="typeDefault">
       <not-uninit/>
@@ -5888,6 +6829,7 @@
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
       <valid>1:</valid>
     </arg>
   </function>
@@ -5902,25 +6844,36 @@
     <const/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- http://docs.wxwidgets.org/3.1/classwx_box_sizer.html -->
   <!-- virtual wxSizerItem* wxBoxSizer::AddSpacer( int size )-->
   <!-- virtual wxSizerItem* wxSizer::AddSpacer( int size)-->
-  <function name="wxSizer::AddSpacer,wxBoxSizer::AddSpacer">
+  <!-- virtual wxSizerItem* wxGridSizer::AddSpacer( int size)-->
+  <!-- virtual wxSizerItem* wxFlexGridSizer::AddSpacer( int size)-->
+  <function name="wxSizer::AddSpacer,wxBoxSizer::AddSpacer,wxGridSizer::AddSpacer,wxFlexGridSizer::AddSpacer">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="wxSizerItem*"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
     </arg>
   </function>
-  <!-- wxSizerItem* wxSizer::Add ( wxWindow * window, int proportion = 0, int flag = 0, int border = 0, wxObject * 	userData = NULL) -->
+  <!-- wxSizerItem* wxSizer::Add (wxSizer * window, const wxSizerFlags &flags) -->
+  <!-- wxSizerItem* wxSizer::Add (wxWindow * window, const wxSizerFlags &flags) -->
+  <!-- wxSizerItem* wxSizer::Add (wxSizer * window, int proportion = 0, int flag = 0, int border = 0, wxObject * userData = NULL) -->
+  <!-- wxSizerItem* wxSizer::Add (wxWindow * window, int proportion = 0, int flag = 0, int border = 0, wxObject * userData = NULL) -->
+  <!-- wxSizerItem* wxSizer::Add (int width, int height, int proportion=0, int flag=0, int border=0, wxObject *userData=NULL) -->
+  <!-- wxSizerItem* wxSizer::Add (int width, int height, const wxSizerFlags &flags) -->
+  <!-- wxSizerItem* wxSizer::Add (wxSizerItem *item) -->
   <function name="wxSizer::Add,wxBoxSizer::Add,wxGridSizer::Add,wxStaticBoxSizer::Add,wxStdDialogButtonSizer::Add,wxWrapSizer::Add,wxFlexGridSizer::Add,wxGridBagSizer::Add">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="wxSizerItem*"/>
-    <arg nr="1" direction="in">
+    <arg nr="1">
       <!-- <not-null/> Deactivated due to FPs with overloaded function: wxSizerItem * Add (int width, int height, int proportion=0, int flag=0, int border=0, wxObject *userData=NULL) -->
       <not-uninit/>
     </arg>
@@ -5929,11 +6882,15 @@
     </arg>
     <arg nr="3" direction="in" default="0">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="4" direction="in" default="0">
       <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="inout" default="NULL">
+      <not-bool/>
     </arg>
-    <arg nr="5" direction="inout" default="NULL"/>
   </function>
   <!-- http://docs.wxwidgets.org/3.1/classwx_box_sizer.html#a58007d1fd88698b9f733ba651977ad55 -->
   <!-- virtual wxSize wxBoxSizer::CalcMin()-->
@@ -5960,10 +6917,56 @@
   <function name="wxBoxSizer::SetOrientation">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void wxIntegerValidator::SetMin(ValueType min) -->
+  <!-- void wxIntegerValidator::SetMax(ValueType max) -->
+  <!-- void wxIntegerValidator::SetStyle(int style) -->
+  <function name="wxIntegerValidator::SetMin,wxIntegerValidator::SetMax,wxIntegerValidator::SetStyle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSashWindow::SetExtraBorderSize(int width) -->
+  <!-- void wxSashLayoutWindow::SetExtraBorderSize(int width) -->
+  <!-- void wxSashWindow::SetMaximumSizeX(int max) -->
+  <!-- void wxSashWindow::SetMaximumSizeY(int max) -->
+  <!-- void wxSashWindow::SetMinimumSizeX(int min) -->
+  <!-- void wxSashWindow::SetMinimumSizeY(int min) -->
+  <function name="wxSashLayoutWindow::SetExtraBorderSize,wxSashWindow::SetExtraBorderSize,wxSashWindow::SetMaximumSizeX,wxSashWindow::SetMaximumSizeY,wxSashWindow::SetMinimumSizeX,wxSashWindow::SetMinimumSizeY">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
+  <!-- void wxSashLayoutWindow::SetOrientation(wxLayoutOrientation or)  -->
+  <!-- void wxSashLayoutWindow::SetAlignment(wxLayoutAlignment alignment)  -->
+  <function name="wxSashLayoutWindow::SetOrientation,wxSashLayoutWindow::SetAlignment">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxRect::SetTopLeft(const wxPoint &p)  -->
+  <!-- void wxRect::SetTopRight(const wxPoint &p)  -->
+  <!-- void wxRect::SetBottomLeft(const wxPoint &p)  -->
+  <!-- void wxRect::SetBottomRight(const wxPoint &p)  -->
+  <function name="wxRect::SetTopLeft,wxRect::SetTopRight,wxRect::SetBottomLeft,wxRect::SetBottomRight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
   <!-- http://docs.wxwidgets.org/3.1/classwx_static_box_sizer.html#a556686a3445d0f7f8aa1b12e962a7494 -->
   <!-- virtual wxSize wxStaticBoxSizer::CalcMin() -->
   <function name="wxStaticBoxSizer::CalcMin">
@@ -5993,6 +6996,7 @@
     <returnValue type="wxMenuItem *"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in" default="wxEmptyString"/>
     <arg nr="3" direction="in" default="wxEmptyString"/>
@@ -6011,6 +7015,7 @@
     </arg>
     <arg nr="2" direction="in" default="0">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- http://docs.wxwidgets.org/3.1/group__group__funcmacro__file.html#ga3e960a6805631320fede18bf1176f278 -->
@@ -6049,6 +7054,7 @@
     </arg>
     <arg nr="2" direction="in" default="1000">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <warn severity="style" reason="Obsolete" alternatives="wxGetCwd"/>
   </function>
@@ -6081,6 +7087,7 @@
     </arg>
     <arg nr="2" direction="in" default="wxS_DIR_DEFAULT">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- http://docs.wxwidgets.org/3.1/group__group__funcmacro__file.html#ga9ae2276737ad4fe72ea96c5f2d9bbfd3 -->
@@ -6089,11 +7096,10 @@
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
+    <arg nr="1" direction="in"/>
     <arg nr="2" direction="in" default="0">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- http://docs.wxwidgets.org/3.0/group__group__funcmacro__string.html#ga223e9aea5b1a2252c7e632613c7b9a74 -->
@@ -6105,36 +7111,278 @@
     <returnValue type="wxString &amp;"/>
     <use-retval/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in" default="wxEmptyString">
-      <not-uninit/>
-    </arg>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="wxEmptyString"/>
     <arg nr="3" direction="in" default="0">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="4" direction="in" default="wxEmptyString">
-      <not-uninit/>
-    </arg>
+    <arg nr="4" direction="in" default="wxEmptyString"/>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_app.html#a420a1cef557cfe2edaee6ffdaaa5f7fb -->
   <!-- virtual void wxApp::MacOpenFile (const wxString & fileName) -->
   <function name="wxApp::MacOpenFile">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
     <warn severity="style">This function is deprecated and kept mostly for backwards compatibility. Please override 'wxApp::MacOpenFiles' method instead in any new code.</warn>
   </function>
-  <!-- http://docs.wxwidgets.org/trunk/classwx_art_provider.html#ae6090f32579d782205dd247006e4c7de -->
-  <!-- static void wxArtProvider::Insert(wxArtProvider * provider)-->
-  <function name="wxArtProvider::Insert">
+  <!--  wxArchitecture wxPlatformInfo::GetArchitecture ( ) const  -->
+  <function name="wxPlatformInfo::GetArchitecture">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <returnValue type="wxArchitecture"/>
+    <warn severity="style">This function is deprecated, use 'wxPlatformInfo::GetBitness()' instead.</warn>
+  </function>
+  <!-- virtual size_t wxMBConv::MB2WC ( wchar_t * out, const char * in, size_t outLen) const -->
+  <function name="wwxMBConv::MB2WC">
+    <noreturn>false</noreturn>
+    <const/>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <arg nr="1" direction="out"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <warn severity="style">This function is deprecated, please use 'ToWChar()' instead.</warn>
+  </function>
+  <!-- virtual size_t wxMBConv::WC2MB( char * buf, const wchar_t * psz, size_t n ) const -->
+  <function name="wwxMBConv::WC2MB">
+    <noreturn>false</noreturn>
+    <const/>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <arg nr="1" direction="out"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <warn severity="style">This function is deprecated, please use 'FromWChar()' instead.</warn>
+  </function>
+  <!-- void wxMenuBar::SetLabelTop(int id, const wxString &label) -->
+  <function name="wxMenuBar::SetLabelTop">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+    <warn severity="style">This function has been deprecated in favour of 'wxMenuBar::SetMenuLabel()'.</warn>
+  </function>
+  <!-- virtual wxString wxLogFormatter::FormatTime(time_t time ) const -->
+  <function name="wxLogFormatter::FormatTime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <returnValue type="wxString"/>
+    <warn severity="style">This function only exists for compatibility, please override FormatTimeMS() in the new code.</warn>
+  </function>
+  <!-- wxString wxMenuBar::GetLabelTop (size_t pos) const -->
+  <function name="wxMenuBar::GetLabelTop">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <returnValue type="wxString"/>
+    <warn severity="style">This function is deprecated. Please use 'wxMenuItem::GetMenuLabel()' or 'wxMenuItem::GetMenuLabelText()' instead.</warn>
+  </function>
+  <!-- virtual wxString wxMenuItem::GetName (void) const -->
+  <function name="wxMenuItem::GetName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <returnValue type="wxString"/>
+    <warn severity="style">This function is deprecated. Please use 'wxMenuItem::GetItemLabel()' or 'wxMenuItem::GetItemLabelText()' instead.</warn>
+  </function>
+  <!-- const wxString& wxMenuItem::GetText (void) const -->
+  <function name="wxMenuItem::GetText">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <returnValue type="wxString&amp;"/>
+    <warn severity="style">This function is deprecated in favour of 'wxMenuItem::GetItemLabel()'.</warn>
+  </function>
+  <!-- static wxArchitecture wxPlatformInfo::GetArch (const wxString &arch )  -->
+  <function name="wxPlatformInfo::GetArch">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <returnValue type="wxArchitecture"/>
+    <warn severity="style">This function is deprecated, use 'wxPlatformInfo::GetBitness()' instead.</warn>
+  </function>
+  <!-- void wxPGProperty::AddChild ( wxPGProperty * prop)  -->
+  <function name="wxPGProperty::AddChild">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <returnValue type="void"/>
+    <warn severity="style">This function is deprecated, use 'wxPGProperty::AddPrivateChild()' instead.</warn>
+  </function>
+  <!-- wxWindowID wxNewId() -->
+  <function name="wxNewId">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="wxWindowID"/>
+    <warn severity="style">This function is deprecated. Ids generated by it can conflict with the Ids defined by the user code, use wxID_ANY to assign ids which are guaranteed to not conflict with the user-defined ids for the controls and menu items you create instead of using this function.</warn>
+  </function>
+  <!-- wxString wxPGProperty::GetValueString ( int argFlags = 0 ) const -->
+  <function name="wxPGProperty::GetValueString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in" default="0">
+      <not-uninit/>
+    </arg>
+    <returnValue type="wxString"/>
+    <warn severity="style">This function is deprecated, use 'wxPGProperty::GetValueAsString()' instead.</warn>
+  </function>
+  <!-- virtual wxVariant wxPGProperty::DoGetValue(void) const -->
+  <!--         wxVariant wxPGProperty::GetValue(void) const   -->
+  <function name="wxPGProperty::GetValue,wxPGProperty::DoGetValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <returnValue type="wxVariant"/>
+  </function>
+  <!-- wxString wxPGPropertyFlags::wxPGProperty::GetValueAsStringWithCheck( wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null ) const -->
+  <!-- wxString wxPGProperty::GetValueAsString( wxPGPropValFormatFlags flags = wxPGPropValFormatFlags::Null ) const -->
+  <function name="wxPGPropertyFlags::wxPGProperty::GetValueAsStringWithCheck,wxPGProperty::GetValueAsString">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxString"/>
+      <const/>
+      <arg nr="1" default="wxPGPropValFormatFlags::Null" direction="in">
+      </arg>
+  </function>
+  <!--        wxString wxPlatformInfo::GetArchName ( ) const  -->
+  <!-- Not possible to configure both functions:
+       static wxString wxPlatformInfo::GetArchName ( wxArchitecture  arch) -->
+  <function name="wxPlatformInfo::GetArchName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <returnValue type="wxString"/>
+    <warn severity="style">This function is deprecated, use 'wxPlatformInfo::GetBitnessName()' instead.</warn>
+  </function>
+  <!-- void wxPlatformInfo::SetArchitecture(wxArchitecture n)  -->
+  <function name="wxPlatformInfo::SetArchitecture">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <warn severity="style">This function is deprecated, use 'wxPlatformInfo::SetBitness()' instead.</warn>
+  </function>
+  <!-- virtual void wxMenuItem::SetText( const wxString & text ) -->
+  <function name="wxMenuItem::SetText">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <warn severity="style">This function is deprecated in favour of 'wxMenuItem::SetItemLabel()'.</warn>
+  </function>
+  <!-- void wxSplitPath(const wxString & fullname, wxString * path, wxString * name, wxString * ext) -->
+  <function name="wxSplitPath">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="out"/>
+    <arg nr="3" direction="out"/>
+    <arg nr="4" direction="out"/>
+    <warn severity="style">This function is deprecated, please use 'wxFileName::SplitPath()' instead.</warn>
+  </function>
+  <!-- virtual void wxToolBar::OnRightClick(int toolId, long x, long y) -->
+  <function name="wxToolBar::OnRightClick">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <warn severity="style">This function is deprecated. This is the old way of detecting tool right clicks, although it will still work, you should use the EVT_TOOL_RCLICKED() macro instead.</warn>
+  </function>
+  <!-- void wxPrintDialogData::SetSetupDialog(bool flag) -->
+  <function name="wxPrintDialogData::SetSetupDialog">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <warn severity="style">The setup dialog is deprecated, though retained for backward compatibility.</warn>
+  </function>
+  <!-- void wxPostDelete(wxObject * obj) -->
+  <function name="wxPostDelete">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <warn severity="style">This function has been deprecated, use 'wxWindow::Close()' instead.</warn>
+  </function>
+  <!-- virtual bool wxPrinter::Setup(wxWindow * parent) -->
+  <function name="wxPrinter::Setup">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
     <arg nr="1" direction="in">
       <not-null/>
+    </arg>
+    <warn severity="style">The setup dialog is deprecated, though retained for backward compatibility.</warn>
+  </function>
+  <!-- wxThreadError wxThreadHelper::Create (unsigned int stackSize = 0) -->
+  <function name="wxThreadHelper::Create">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <returnValue type="wxThreadError"/>
+    <arg nr="1" direction="in" default="0">
+      <not-uninit/>
+    </arg>
+    <warn severity="style">This function is deprecated use 'CreateThread()' instead.</warn>
+  </function>
+  <!-- bool wxShowEvent::GetShow( ) const -->
+  <function name="wxShowEvent::GetShow">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <warn severity="style">This function is deprecated in favour of 'IsShown()'.</warn>
+  </function>
+  <!-- static void wxArtProvider::Insert(wxArtProvider * provider)-->
+  <function name="wxArtProvider::Insert">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1">
+      <not-null/>
       <not-uninit/>
     </arg>
     <warn severity="style">This function is deprecated and kept mostly for backwards compatibility. Please override 'PushBack' method instead in any new code.</warn>
@@ -6144,20 +7392,182 @@
   <function name="wxCalendarCtrl::EnableYearChange">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="void"/>
     <arg nr="1" direction="in" default="true">
       <not-uninit/>
     </arg>
     <warn severity="style">This function should be used instead of changing 'wxCAL_NO_YEAR_CHANGE' style bit directly. It allows or disallows the user to change the year interactively. Only in generic 'wxCalendarCtrl'.</warn>
   </function>
+  <!-- void wxUnix2DosFilename (wxChar * s )-->
+  <function name="wxUnix2DosFilename">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <warn severity="style">This function is deprecated. Construct a wxFileName with wxPATH_UNIX and then use wxFileName::GetFullPath(wxPATH_DOS) instead.</warn>
+  </function>
+  <!-- void wxStyledTextCtrl::SetStyleBits(int bits )-->
+  <function name="wxStyledTextCtrl::SetStyleBits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <warn severity="style">This function is deprecated.</warn>
+  </function>
+  <!-- wxUint32 wxSocketBase::LastCount() const -->
+  <function name="wxSocketBase::LastCount">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <returnValue type="wxUint32"/>
+    <warn severity="style">This function is kept mostly for backwards compatibility. Use 'LastReadCount()' or 'LastWriteCount()' instead. 'LastCount()' is still needed for use with less commonly used functions: 'Discard()', 'Peek()', and 'Unread()'.</warn>
+  </function>
+  <!-- int wxStyledTextCtrl::GetStyleBits()const -->
+  <!-- int wxStyledTextCtrl::GetStyleBitsNeeded()const -->
+  <function name="wxStyledTextCtrl::GetStyleBitsNeeded,wxStyledTextCtrl::GetStyleBits">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <returnValue type="int"/>
+    <warn severity="style">This function is deprecated.</warn>
+  </function>
+  <!-- wxStreamBase* wxStreamBuffer::Stream() -->
+  <function name="wxStreamBuffer::Stream">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="wxStreamBase*"/>
+    <warn severity="style">This function is deprecated, use GetStream() instead</warn>
+  </function>
+  <!-- void wxUsleep (unsigned long milliseconds) -->
+  <function name="wxUsleep">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <warn severity="style">This function is deprecated because its name is misleading: notice that the argument is in milliseconds, not microseconds. Please use either 'wxMilliSleep()' or 'wxMicroSleep()' depending on the resolution you need.</warn>
+  </function>
+  <!-- static bool wxWebViewIE::MSWSetModernEmulationLevel(bool modernLevel = true) -->
+  <function name="wxWebViewIE::MSWSetModernEmulationLevel">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <pure/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in" default="true">
+      <not-uninit/>
+    </arg>
+    <warn severity="style">This function is kept mostly for backwards compatibility.</warn>
+  </function>
+  <!-- virtual void wxWindow::SetInitialBestSize(const wxSize & size)-->
+  <function name="wxWindow::SetInitialBestSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <warn severity="style">This function is deprecated, use 'wxWindow::SetInitialSize' instead.</warn>
+  </function>
+  <!-- wxString wxTextInputStream::ReadString() -->
+  <function name="wxTextInputStream::ReadString">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <warn severity="style">This function is deprecated, use 'wxTextInputStream::ReadLine()' or 'wxTextInputStream::ReadWord()' instead.</warn>
+  </function>
+  <!-- wxString wxStyledTextEvent::GetDragText() -->
+  <!-- wxString wxStyledTextEvent::GetText() -->
+  <function name="wxTextInputStream::ReadString,wxStyledTextEvent::GetDragText">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <warn severity="style">Use 'wxStyledTextEvent::GetString()' instead.</warn>
+  </function>
+  <!-- wxString wxToolbookEvent::GetString() const-->
+  <!-- wxString wxStyledTextEvent::GetString() const-->
+  <function name="wxStyledTextEvent::GetString,wxToolbookEvent::GetString">
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <const/>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+  </function>
+  <!-- int wxToolbookEvent::GetOldSelection( void ) const -->
+  <!-- int wxToolbookEvent::GetSelection( void ) const -->
+  <!-- int wxBookCtrlEvent::GetOldSelection( void ) const -->
+  <!-- int wxBookCtrlEvent::GetSelection( void ) const -->
+  <function name="wxBookCtrlEvent::GetOldSelection,wxBookCtrlEvent::GetSelection,wxToolbookEvent::GetOldSelection,wxToolbookEvent::GetSelection">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="int"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- void wxStyledTextEvent::SetText(const wxString & t) -->
+  <!-- void wxStyledTextEvent::SetDragText(const wxString & val) -->
+  <function name="wxStyledTextEvent::SetText,wxStyledTextEvent::SetDragText">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <warn severity="style">This function is deprecated.</warn>
+  </function>
+  <!-- int wxStyledTextEvent::GetFoldLevelNow( void ) const -->
+  <!-- int wxStyledTextEvent::GetFoldLevelPrev( void ) const -->
+  <!-- int wxStyledTextEvent::GetKey( void ) const -->
+  <!-- int wxStyledTextEvent::GetLParam( void ) const -->
+  <!-- int wxStyledTextEvent::GetLength( void ) const -->
+  <!-- int wxStyledTextEvent::GetLine( void ) const -->
+  <!-- int wxStyledTextEvent::GetLinesAdded( void ) const -->
+  <!-- int wxStyledTextEvent::GetListCompletionMethod( void ) const -->
+  <!-- int wxStyledTextEvent::GetListType( void ) const -->
+  <!-- int wxStyledTextEvent::GetMargin( void ) const -->
+  <!-- int wxStyledTextEvent::GetMessage( void ) const -->
+  <!-- int wxStyledTextEvent::GetModificationType( void ) const -->
+  <!-- int wxStyledTextEvent::GetModifiers( void ) const -->
+  <!-- int wxStyledTextEvent::GetPosition( void ) const -->
+  <function name="wxStyledTextEvent::GetFoldLevelNow,wxStyledTextEvent::GetFoldLevelPrev,wxStyledTextEvent::GetKey,wxStyledTextEvent::GetLParam,wxStyledTextEvent::GetLength,wxStyledTextEvent::GetLine,wxStyledTextEvent::GetLinesAdded,wxStyledTextEvent::GetListCompletionMethod,wxStyledTextEvent::GetListType,wxStyledTextEvent::GetMargin,wxStyledTextEvent::GetMessage,wxStyledTextEvent::GetModificationType,wxStyledTextEvent::GetModifiers,wxStyledTextEvent::GetPosition">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="int"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- void wxWindow::SetPalette(const wxPalette & pal) -->
+  <function name="wxWindow::SetPalette">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <warn severity="style">This function is deprecated, use 'wxDC::SetPalette' instead.</warn>
+  </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_combo_ctrl.html#ae38353a81954d02af302ba103e984cb73 -->
   <!-- wxCoord wxComboCtrl::GetTextIndent( ) const-->
   <function name="wxComboCtrl::GetTextIndent">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <use-retval/>
+    <const/>
     <returnValue type="wxCoord"/>
     <warn severity="style">This function is deprecated and kept mostly for backwards compatibility. Please override 'GetMargins()' method instead in any new code.</warn>
   </function>
+  <!-- wxPoint wxComboCtrl::GetMargins( ) const-->
+  <function name="wxComboCtrl::GetMargins">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <returnValue type="wxPoint"/>
+  </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_combo_ctrl.html#ae38353a81954d02af302ba103e984cb7 -->
   <!-- void wxComboCtrl::HidePopup (bool generateEvent=false)-->
   <function name="wxComboCtrl::HidePopup">
@@ -6182,11 +7592,12 @@
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <warn severity="style">This function is deprecated and kept mostly for backwards compatibility. Please override 'SetMargins()' method instead in any new code.</warn>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_data_view_custom_renderer.html#a242d0992df73be6830e66d74b211974d-->
-  <!-- virtual bool wxDataViewCustomRenderer::Activate (wxRect cell, wxDataViewModel * model, const wxDataViewItem & item, unsigned int col)	-->
+  <!-- virtual bool wxDataViewCustomRenderer::Activate (wxRect cell, wxDataViewModel * model, const wxDataViewItem & item, unsigned int col)    -->
   <function name="wxDataViewCustomRenderer::Activate">
     <noreturn>false</noreturn>
     <leak-ignore/>
@@ -6202,6 +7613,7 @@
     </arg>
     <arg nr="4" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <warn severity="style">This function is deprecated and kept mostly for backwards compatibility. Please override 'wxDataViewCustomRenderer::ActivateCell()' method instead in any new code.</warn>
   </function>
@@ -6225,6 +7637,7 @@
     </arg>
     <arg nr="5" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <warn severity="style">This function is deprecated and kept mostly for backwards compatibility. Please override 'wxDataViewCustomRenderer::ActivateCell()' method instead in any new code.</warn>
   </function>
@@ -6237,6 +7650,7 @@
     <const/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- wxCharBuffer wxString::mb_str( const wxMBConv & conv = wxConvLibc ) const -->
@@ -6264,6 +7678,7 @@
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <warn severity="style">This function is deprecated and is replaced by 'wxLog' functionality.</warn>
   </function>
@@ -6290,8 +7705,41 @@
     </arg>
     <warn severity="style">This function is deprecated. Please use 'wxFileName::SplitPath()' instead.</warn>
   </function>
-  <!-- http://docs.wxwidgets.org/trunk/classwx_sizer_item.html#a83baa6835015e9ccd71ba290883db4f5-->
-  <!-- void wxSizerItem::SetWindow(wxWindow * window)-->
+  <!-- wxString wxFileName::GetFullPath( wxPathFormat format = wxPATH_NATIVE ) const -->
+  <function name="wxFileName::GetFullPath">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxString"/>
+      <const/>
+      <arg nr="1" default="wxPATH_NATIVE" direction="in">
+      </arg>
+  </function>
+  <!-- bool wxControlBase::SetLabelMarkup( const wxString & markup ) -->
+  <!-- bool wxStaticText::SetLabelMarkup( const wxString & markup ) -->
+  <function name="wxControlBase::SetLabelMarkup,wxStaticText::SetLabelMarkup">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- static void wxFileName::SplitPath(const wxString & fullpath, wxString * volume, wxString * path, wxString * name, wxString * ext, bool * hasExt = NULL, wxPathFormat format = wxPATH_NATIVE ) -->
+  <!-- static void wxFileName::SplitPath(const wxString & fullpath, wxString * volume, wxString * path, wxString * name, wxString * ext, wxPathFormat format)-->
+  <!-- static void wxFileName::SplitPath(const wxString & fullpath, wxString * path  , wxString * name, wxString * ext , wxPathFormat format = wxPATH_NATIVE)-->
+  <function name="wxFileName::SplitPath">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="out"/>
+    <arg nr="3" direction="out"/>
+    <arg nr="4" direction="out"/>
+    <arg nr="5" default="wxPATH_NATIVE"/>
+    <arg nr="6" default="NULL"/>
+    <arg nr="7" default="wxPATH_NATIVE"/>
+  </function>
+  <!-- http://docs.wxwidgets.org/trunk/classwx_sizer_item.html#a83baa6835015e9ccd71ba290883db4f5-->
+  <!-- void wxSizerItem::SetWindow(wxWindow * window)-->
   <function name="wxSizerItem::SetWindow">
     <noreturn>false</noreturn>
     <leak-ignore/>
@@ -6301,6 +7749,26 @@
     </arg>
     <warn severity="style">This function is deprecated.</warn>
   </function>
+  <!-- void wxSizer::Remove(int index) -->
+  <!-- void wxSizer::Remove(wxWindow * window)-->
+  <!-- void wxSizer::Remove(wxWindow * window)-->
+  <function name="wxSizer::Remove">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSizer::SetVirtualSizeHints(wxWindow * window)-->
+  <function name="wxSizer::SetVirtualSizeHints">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <warn severity="style">This function is deprecated. This is exactly the same as 'FitInside()' in wxWidgets 2.9 and later, please replace calls to it with 'FitInside()'.</warn>
+  </function>
   <!-- void wxSizerItem::SetSizer(wxSizer * sizer)-->
   <function name="wxSizerItem::SetSizer">
     <noreturn>false</noreturn>
@@ -6311,6 +7779,19 @@
     </arg>
     <warn severity="style">This function is deprecated. This function does not free the old sizer which may result in memory leaks, use 'wxSizerItem::AssignSizer' which does free it instead.</warn>
   </function>
+  <!-- void wxSizerItem::SetInitSize(int x, int y)-->
+  <function name="wxSizerItem::SetInitSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <warn severity="style">This is identical to 'wxSizerItem::SetMinSize()', prefer to use the other function, as its name is more clear</warn>
+  </function>
   <!-- void wxSizer::SetSizeHints( wxWindow * window ) -->
   <!-- void wxBoxSizer::SetSizeHints( wxWindow * window ) -->
   <!-- void wxFlexGridSizer::SetSizeHints( wxWindow * window ) -->
@@ -6324,6 +7805,16 @@
       <not-null/>
     </arg>
   </function>
+  <!-- virtual void wxWindowBase::SetSizeHints(const wxSize & minSize, const wxSize & maxSize = wxDefaultSize, const wxSize & incSize = wxDefaultSize) -->
+  <!-- virtual void wxWindow::SetSizeHints(const wxSize & minSize, const wxSize & maxSize = wxDefaultSize, const wxSize & incSize = wxDefaultSize) -->
+  <function name="wxWindowBase::SetSizeHints,wxWindow::SetSizeHints">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="wxDefaultSize" direction="in"/>
+    <arg nr="3" default="wxDefaultSize" direction="in"/>
+  </function>
   <!-- void wxFlexGridSizer::SetFlexibleDirection(int direction)-->
   <function name="wxFlexGridSizer::SetFlexibleDirection">
     <noreturn>false</noreturn>
@@ -6331,6 +7822,7 @@
     <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- wxString wxString::FromAscii( const char * ascii ) -->
@@ -6343,6 +7835,7 @@
     <returnValue type="wxString"/>
     <arg nr="any">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- void wxUpdateUIEvent::Check( bool enable ) -->
@@ -6362,11 +7855,41 @@
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
     </arg>
   </function>
+  <!-- bool wxListCtrl::SetItem(wxListItem &info) -->
+  <!-- long wxListCtrl::SetItem(long index, int column, const wxString & label, int imageId = -1) -->
+  <!-- bool wxListView::SetItem(wxListItem &info) -->
+  <!-- long wxListView::SetItem(long index, int column, const wxString & label, int imageId = -1) -->
+  <function name="wxListCtrl::SetItem,wxListView::SetItem">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="any" direction="in">
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool wxMenuBar::IsChecked( int id ) const -->
+  <!-- bool wxMenuBar::IsEnabled( int id ) const -->
+  <function name="wxMenuBar::IsEnabled,wxMenuBar::IsChecked">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxMenuBar::IsAttached( void ) const -->
+  <function name="wxMenuBar::IsAttached">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <const/>
+    <returnValue type="bool"/>
+    <use-retval/>
+  </function>
   <!-- void wxMenuBar::Check(int id, bool check) -->
   <function name="wxMenuBar::Check">
     <noreturn>false</noreturn>
@@ -6374,50 +7897,87 @@
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
     </arg>
   </function>
+  <!-- void wxWindowBase::SetSizer(wxSizer * sizer, bool deleteOld = true)-->
   <!-- void wxWindow::SetSizer(wxSizer * sizer, bool deleteOld = true)-->
   <!-- void wxPanel::SetSizer(wxSizer * sizer, bool deleteOld = true)-->
   <!-- void wxFrame::SetSizer(wxSizer * sizer, bool deleteOld = true)-->
   <!-- void wxScrolledWindow::SetSizer(wxSizer * sizer, bool deleteOld = true)-->
-  <function name="wxWindow::SetSizer,wxPanel::SetSizer,wxScrolledWindow::SetSizer,wxFrame::SetSizer">
+  <function name="wxWindowBase::SetSizer,wxWindow::SetSizer,wxPanel::SetSizer,wxScrolledWindow::SetSizer,wxFrame::SetSizer">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="inout">
+    <arg nr="1" direction="in">
       <not-uninit/>
-      <not-null/>
     </arg>
     <arg nr="2" direction="in" default="true">
       <not-uninit/>
     </arg>
   </function>
+  <!-- void wxWindowBase::SetAutoLayout(bool autoLayout)-->
+  <!-- void wxWindow::SetAutoLayout(bool autoLayout)-->
+  <function name="wxWindowBase::SetAutoLayout,wxWindow::SetAutoLayout">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- virtual bool wxBookCtrlBase::DeletePage(size_t page) -->
+  <!--         bool wxNotebook::DeletePage(size_t page) -->
+  <function name="wxBookCtrlBase::DeletePage,wxNotebook::DeletePage">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- void wxWindowBase::SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO)-->
   <!-- void wxWindow::SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO)-->
+  <!-- void wxPanel::SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO)-->
   <!-- void wxStatusBar::SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO)-->
-  <function name="wxWindow::SetSize,wxStatusBar::SetSize">
+  <!-- void wxSpinButton::SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO)-->
+  <!-- void wxBitmapButton::SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO)-->
+  <!-- void wxCommandLinkButton::SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO)-->
+  <!-- void wxContextHelpButton::SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO)-->
+  <!-- void wxButton::SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO)-->
+  <!-- void wxStaticText::SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO)-->
+  <!-- void wxGauge::SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO)-->
+  <!-- void wxCheckBox::SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO)-->
+  <function name="wxWindowBase::SetSize,wxWindow::SetSize,wxPanel::SetSize,wxStatusBar::SetSize,wxContextHelpButton::SetSize,wxCommandLinkButton::SetSize,wxBitmapButton::SetSize,wxSpinButton::SetSize,wxButton::SetSize,wxStaticText::SetSize,wxGauge::SetSize,wxCheckBox::SetSize">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="4" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="5" direction="in" default="wxSIZE_AUTO">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- http://docs.wxwidgets.org/trunk/classwx_sizer_item.html#a83baa6835015e9ccd71ba290883db4f5-->
-  <!-- void wxSizerItem::SetSpacer(const wxSize & size)-->
+  <!-- void wxSizerItem::SetSpacer(const wxSize & size) -->
   <function name="wxSizerItem::SetSpacer">
     <noreturn>false</noreturn>
     <leak-ignore/>
@@ -6426,16 +7986,68 @@
     </arg>
     <warn severity="style">This function is deprecated. This function does not free the old sizer which may result in memory leaks, use 'wxSizerItem::AssignSpacer' which does free it instead.</warn>
   </function>
-  <!-- virtual void wxWindow::SetExtraStyle	(long exStyle) -->
+  <!-- virtual bool wxHelpControllerBase::DisplayBlock(long blockNo) -->
+  <function name="wxHelpControllerBase::DisplayBlock">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <warn severity="style">This function is for backward compatibility only, and applications should use 'wxHelpControllerBase::DisplaySection()' instead.</warn>
+  </function>
+  <!--  int wxHtmlTag::GetBeginPos( ) const -->
+  <!--  int wxHtmlTag::GetEndPos1( ) const -->
+  <!--  int wxHtmlTag::GetEndPos2( ) const -->
+  <function name="wxHtmlTag::GetBeginPos,wxHtmlTag::GetEndPos1,wxHtmlTag::GetEndPos2">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <const/>
+    <use-retval/>
+    <returnValue type="int"/>
+    <warn severity="style">This function is deprecated.</warn>
+  </function>
+  <!-- bool wxIconizeEvent::Iconized() const -->
+  <function name="wxIconizeEvent::Iconized">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <const/>
+    <use-retval/>
+    <returnValue type="bool"/>
+    <warn severity="style">This function is deprecated in favour of 'wxIconizeEvent::IsIconized()'.</warn>
+  </function>
+  <!-- int wxList< T >::Number() const -->
+  <function name="wxList::Number">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <const/>
+    <use-retval/>
+    <returnValue type="int"/>
+    <warn severity="style">This function is deprecated, use 'wxList::GetCount()' instead. Returns the number of elements in the list.</warn>
+  </function>
+  <!-- void wxIcon::SetWidth (int width ) -->
+  <!-- void wxIcon::SetHeight (int width ) -->
+  <!-- void wxIcon::SetDepth (int width ) -->
+  <function name="wxIcon::SetWidth,wxIcon::SetHeight,wxIcon::SetDepth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <warn severity="style">This function is deprecated since version 3.1.2, dimensions and depth can only be set at construction time.</warn>
+  </function>
+  <!-- virtual void wxWindow::SetExtraStyle (long exStyle) -->
   <!-- virtual void wxPropertyGridManager::SetExtraStyle(long exStyle) -->
   <function name="wxWindow::SetExtraStyle,wxPropertyGridManager::SetExtraStyle">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- wxPropertyGridPage* wxPropertyGridManager::AddPage(const wxString & label = wxEmptyString, const wxBitmap & 	bmp = wxPG_NULL_BITMAP, wxPropertyGridPage * pageObj = NULL) -->
+  <!-- wxPropertyGridPage* wxPropertyGridManager::AddPage(const wxString & label = wxEmptyString, const wxBitmap &  bmp = wxPG_NULL_BITMAP, wxPropertyGridPage * pageObj = NULL) -->
   <function name="wxPropertyGridManager::AddPage">
     <noreturn>false</noreturn>
     <leak-ignore/>
@@ -6460,21 +8072,154 @@
     </arg>
     <arg nr="4" direction="in" default="NO_IMAGE">
       <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- virtual wxString wxBookCtrlBase::GetPageText( size_t nPage) const -->
+  <!-- virtual wxString wxAuiNotebook::GetPageText( size_t nPage) const -->
+  <!-- virtual wxString wxNotebook::GetPageText( size_t nPage) const -->
+  <function name="wxBookCtrlBase::GetPageText,wxNotebook::GetPageText,wxAuiNotebook::GetPageText">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <const/>
+    <use-retval/>
+    <returnValue type="wxString"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!--         bool wxAuiNotebook::AddPage(wxWindow * page, const wxString & caption, bool select = false, const wxBitmap & bitmap = wxNullBitmap) -->
+  <!-- virtual bool wxAuiNotebook::AddPage(wxWindow * page, const wxString & text   , bool select, int imageId ) -->
+  <function name="wxAuiNotebook::AddPage">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in" default="false"/>
+    <arg nr="4" direction="in" default="wxNullBitmap"/>
+  </function>
+  <!-- wxWindow* wxFindWindowByLabel(const wxString & name, wxWindow * parent = NULL) -->
+  <function name="wxFindWindowByLabel">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="wxWindow *"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="out" default="NULL"/>
+    <warn severity="style">This function is deprecated, please use 'wxWindow::FindWindowByLabel()' instead.</warn>
+  </function>
+  <!-- wxWindow* wxFindWindowByName(const wxString & name, wxWindow * parent = NULL) -->
+  <function name="wxFindWindowByName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="wxWindow *"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="out" default="NULL"/>
+    <warn severity="style">This function is deprecated, please use 'wxWindow::FindWindowByName()' instead.</warn>
+  </function>
+  <!-- char* wxGetTempFileName(const wxString & prefix, char * buf = NULL) -->
+  <function name="wxGetTempFileName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="char *"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="out" default="NULL"/>
+    <warn severity="style">This function is deprecated, please use 'wxFileName::CreateTempFileName()' instead.</warn>
+  </function>
+  <!-- bool wxGetUserId(char * buf, int sz) -->
+  <function name="wxGetUserId">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="out">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <warn severity="style">This function is deprecated, use 'wxGetUserId()' with no arguments instead.</warn>
+  </function>
+  <!-- bool wxGetEmailAddress(char * buf, int sz) -->
+  <function name="wxGetEmailAddress">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="out">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <warn severity="style">This function is deprecated, use 'wxGetEmailAddress()' with no arguments instead.</warn>
+  </function>
+  <!-- bool wxGetHostName(char * buf, int sz) -->
+  <function name="wxGetHostName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="out">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <warn severity="style">This function is deprecated, use 'wxGetHostName()' with no arguments instead.</warn>
+  </function>
+  <!-- bool wxGetUserName(char * buf, int sz) -->
+  <function name="wxGetUserName">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="out">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <warn severity="style">This function is deprecated, use 'wxGetUserName()' with no arguments instead.</warn>
+  </function>
+  <!-- wxString wxGetWorkingDirectory(char * buf = NULL, int sz = 1000) -->
+  <function name="wxGetWorkingDirectory">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="wxString"/>
+    <arg nr="1" direction="in" default="NULL">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in" default="1000">
+      <not-uninit/>
+      <not-bool/>
     </arg>
+    <warn severity="style">This function is deprecated, use 'wxGetCwd()' instead.</warn>
   </function>
-  <!-- http://docs.wxwidgets.org/trunk/classwx_grid.html#a83774c9cbf840641cc6ffba25ce32059-->
   <!-- void wxGrid::SetCellAlignment(int align, int row, int col) -->
   <function name="wxGrid::SetCellAlignment">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <warn severity="style">This function is deprecated. Please use 'wxGrid::SetCellAlignment(row, col, horiz, vert)' instead.</warn>
   </function>
@@ -6484,9 +8229,11 @@
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="in"/>
   </function>
@@ -6496,9 +8243,11 @@
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- void wxGrid::AutoSizeColumns (bool setAsMin = true) -->
@@ -6519,12 +8268,15 @@
     <arg nr="3" direction="in"/>
     <arg nr="4" direction="in" default="wxALIGN_LEFT">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="5" direction="in" default="wxALIGN_TOP">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="6" direction="in" default="wxHORIZONTAL">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- wxString wxGrid::GetCellValue (int row, int col) const -->
@@ -6536,9 +8288,11 @@
     <const/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- wxColour wxGrid::GetCellTextColour(int row, int col) const -->
@@ -6550,9 +8304,11 @@
     <const/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- bool wxGrid::GetCellOverflow(int row, int col) const -->
@@ -6564,9 +8320,11 @@
     <const/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- void wxGrid::DrawTextRectangle(wxDC & dc,
@@ -6584,12 +8342,15 @@
     <arg nr="3" direction="in"/>
     <arg nr="4" direction="in" default="wxALIGN_LEFT">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="5" direction="in" default="wxALIGN_TOP">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="6" direction="in" default="wxHORIZONTAL">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
   <!-- bool wxGrid::CreateGrid(int numRows, int numCols, wxGridSelectionModes selmode = wxGridSelectCells) -->
@@ -6599,698 +8360,812 @@
     <returnValue type="bool"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="3" direction="in" default="wxGridSelectCells">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxGrid::SetMargins(int extraWidth, int extraHeight) -->
-  <function name="wxGrid::SetMargins">
+  <!-- bool wxPanel::Create(wxWindow *parent, wxWindowID id=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxTAB_TRAVERSAL, const wxString &name=wxPanelNameStr) -->
+  <function name="wxPanel::Create">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="bool"/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="2" direction="in">
+    <arg nr="2" default="wxID_ANY" direction="in">
       <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in" default="wxDefaultPosition"/>
+    <arg nr="4" direction="in" default="wxDefaultSize"/>
+    <arg nr="5" direction="in" default="wxTAB_TRAVERSAL">
+      <not-bool/>
     </arg>
+    <arg nr="6" direction="in" default="wxPanel"/>
   </function>
-  <!-- void wxGrid::SetRowLabelValue(int row, const wxString & value) -->
-  <!-- void wxGrid::SetColLabelValue(int col, const wxString & value) -->
-  <function name="wxGrid::SetRowLabelValue,wxGrid::SetColLabelValue">
+  <!-- bool wxFrame::Create(wxWindow *parent, wxWindowID id=wxID_ANY, const wxPoint &pos=wxDefaultPosition, const wxSize &size=wxDefaultSize, long style=wxDEFAULT_FRAME_STYLE, const wxString &name=wxFrameNameStr) -->
+  <function name="wxFrame::Create">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="bool"/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="2" direction="in"/>
-  </function>
-  <!-- void wxGrid::SetReadOnly(int row, int col, bool isReadOnly = true) -->
-  <function name="wxGrid::SetReadOnly">
-    <noreturn>false</noreturn>
-    <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="2" default="wxID_ANY" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
+    <arg nr="3" direction="in" default="wxDefaultPosition"/>
+    <arg nr="4" direction="in" default="wxDefaultSize"/>
+    <arg nr="5" direction="in" default="wxDEFAULT_FRAME_STYLE">
+      <not-bool/>
     </arg>
-    <arg nr="3" direction="in" default="true">
+    <arg nr="6" direction="in" default="wxFrame"/>
+  </function>
+  <!-- virtual bool wxImageList::GetSize(int index, int & width, int & height) const -->
+  <function name="wxImageList::GetSize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <const/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <!-- wxWidgets-docs: Currently, the index parameter is ignored as all images in the list have the same size. It should be 0.-->
+      <valid>0</valid>
     </arg>
+    <arg nr="2" direction="out"/>
+    <arg nr="3" direction="out"/>
   </function>
-  <!-- wxGridCellEditor* wxGrid::GetCellEditor(int row, int col) const -->
-  <function name="wxGrid::GetCellEditor">
+  <!-- bool wxPropertyGridManager::IsPropertySelected( wxPGPropArg id ) -->
+  <!-- bool wxPropertyGrid::IsPropertySelected( wxPGPropArg id ) -->
+  <function name="wxPropertyGridManager::IsPropertySelected,wxPropertyGrid::IsPropertySelected">
     <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <leak-ignore/>
     <const/>
-    <returnValue type="wxGridCellEditor *"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxPropertyGrid::ChangePropertyValue (wxPGPropArg id, wxVariant newValue) -->
+  <function name="wxPropertyGrid::ChangePropertyValue">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxWindow::ProcessWindowEvent(wxEvent & event) -->
+  <!-- bool wxWindow::ProcessWindowEventLocally(wxEvent & event) -->
+  <function name="wxWindow::ProcessWindowEvent,wxWindow::ProcessWindowEventLocally">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxFileName::MakeAbsolute(const wxString & pathBase = wxEmptyString, wxPathFormat format = wxPATH_NATIVE) -->
+  <!-- bool wxFileName::MakeRelativeTo(const wxString & pathBase = wxEmptyString, wxPathFormat format = wxPATH_NATIVE) -->
+  <function name="wxFileName::MakeRelativeTo,wxFileName::MakeAbsolute">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
     <use-retval/>
     <leak-ignore/>
+    <arg nr="1" default="wxEmptyString" direction="in"/>
+    <arg nr="2" default="wxPATH_NATIVE" direction="in"/>
+  </function>
+  <!-- bool wxButton::Create(wxWindow * parent, wxWindowID id, const wxString &label=wxEmptyString, const wxPoint & pos = wxDefaultPosition, const wxSize & size = wxDefaultSize, long style = 0, const wxValidator & validator = wxDefaultValidator, const wxString & name = wxControlNameStr) -->
+  <function name="wxButton::Create">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in" default="wxEmptyString"/>
+    <arg nr="4" direction="in" default="wxDefaultPosition"/>
+    <arg nr="5" direction="in" default="wxDefaultSize"/>
+    <arg nr="6" direction="in" default="0">
+      <not-bool/>
     </arg>
+    <arg nr="7" direction="in" default="wxDefaultValidator"/>
+    <arg nr="8" direction="in" default="wxButton"/>
   </function>
-  <!-- http://docs.wxwidgets.org/trunk/classwx_grid.html#adbcbd091140c6adf0f8d04ea1642b24d-->
-  <!-- void wxGrid::SetCellTextColour(const wxColour &val, int row, int col) -->
-  <function name="wxGrid::SetCellTextColour">
+  <!-- bool wxControl::Create(wxWindow * parent, wxWindowID id, const wxPoint & pos = wxDefaultPosition, const wxSize & size = wxDefaultSize, long style = 0, const wxValidator & validator = wxDefaultValidator, const wxString & name = wxControlNameStr) -->
+  <function name="wxControl::Create">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="bool"/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="3" direction="in">
-      <not-uninit/>
+    <arg nr="3" direction="in" default="wxDefaultPosition"/>
+    <arg nr="4" direction="in" default="wxDefaultSize"/>
+    <arg nr="5" direction="in" default="0">
+      <not-bool/>
     </arg>
+    <arg nr="6" direction="in" default="wxDefaultValidator"/>
+    <arg nr="7" direction="in" default="wxControl"/>
   </function>
-  <!-- void wxGrid::ClearSelection(void) -->
-  <function name="wxGrid::ClearSelection">
+  <!-- bool wxSlider::Create(wxWindow * parent, wxWindowID id, const wxPoint & pos = wxDefaultPosition, const wxSize & size = wxDefaultSize, long style = 0, const wxValidator & validator = wxDefaultValidator, const wxString & name = wxControlNameStr) -->
+  <function name="wxSlider::Create">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in" default="wxDefaultPosition"/>
+    <arg nr="4" direction="in" default="wxDefaultSize"/>
+    <arg nr="5" direction="in" default="0">
+      <not-bool/>
+    </arg>
+    <arg nr="6" direction="in" default="wxDefaultValidator"/>
+    <arg nr="7" direction="in" default="wxSlider"/>
   </function>
-  <!-- http://docs.wxwidgets.org/trunk/classwx_grid.html#adbcbd091140c6adf0f8d04ea1642b24d-->
-  <!-- void wxGrid::SetCellTextColour(wxColour &val) -->
-  <!-- @todo: This is an overloaded function of SetCellTextColour. Activate it once, overloaded functions are supported.
-  <function name="wxGrid::SetCellTextColour">
+  <!-- bool wxScrolledWindow::Create(wxWindow * parent, wxWindowID id, const wxPoint & pos = wxDefaultPosition, const wxSize & size = wxDefaultSize, long style = wxWANTS_CHARS, const wxString & name = wxControlNameStr) -->
+  <function name="wxScrolledWindow::Create">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1">
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <warn severity="style">This function is deprecated. Please use 'SetDefaultCellTextColour(colour)' instead.</warn>
-  </function>  -->
-  <!-- int wxEntry (HINSTANCE hInstance, HINSTANCE hPrevInstance = NULL,char * pCmdLine = NULL,int 	nCmdShow = SW_SHOWNORMAL) -->
-  <function name="wxEntry">
+    <arg nr="3" direction="in" default="wxDefaultPosition"/>
+    <arg nr="4" direction="in" default="wxDefaultSize"/>
+    <arg nr="5" direction="in" default="wxWANTS_CHARS">
+      <not-bool/>
+    </arg>
+    <arg nr="6" direction="in" default="wxScrolledWindow"/>
+  </function>
+  <!-- bool wxCheckBox::Create(wxWindow * parent, wxWindowID id, const wxString & label, const wxPoint & pos = wxDefaultPosition, const wxSize & size = wxDefaultSize, long style = 0, const wxString &     name = wxDialogNameStr) -->
+  <function name="wxCheckBox::Create">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="int"/>
-    <arg nr="1">
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="2" default="NULL"/>
-    <arg nr="3" default="NULL"/>
-    <arg nr="4" direction="in" default="SW_SHOWNORMAL">
+    <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in" default="wxDefaultPosition"/>
+    <arg nr="5" direction="in" default="wxDefaultSize"/>
+    <arg nr="6" direction="in" default="0">
+      <not-bool/>
     </arg>
+    <arg nr="7" direction="in" default="wxDefaultValidator"/>
+    <arg nr="8" direction="in" default="wxStaticTextNameStr"/>
   </function>
-  <!-- virtual bool wxWindow::SetBackgroundColour(const wxColour &c) -->
-  <!--         bool wxFrame::SetBackgroundColour(const wxColour &c) -->
-  <!--         bool wxTextCtrl::SetBackgroundColour(const wxColour &c) -->
-  <!--         bool wxPanel::SetBackgroundColour(const wxColour &c) -->
-  <!--         bool wxScrolledWindow::SetBackgroundColour(const wxColour &c) -->
-  <!--         bool wxStaticBitmap::SetBackgroundColour(const wxColour &c) -->
-  <function name="wxWindow::SetBackgroundColour,wxFrame::SetBackgroundColour,wxTextCtrl::SetBackgroundColour,wxPanel::SetBackgroundColour,wxScrolledWindow::SetBackgroundColour,wxStaticBitmap::SetBackgroundColour">
+  <!-- bool wxStaticText::Create(wxWindow * parent, wxWindowID id, const wxString & title, const wxPoint & pos = wxDefaultPosition, const wxSize & size = wxDefaultSize, long style = 0, const wxValidator & validator = wxDefaultValidator, const wxString & name = NameStr) -->
+  <function name="wxStaticText::Create">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="bool"/>
-    <arg nr="1" direction="in"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in" default="wxDefaultPosition"/>
+    <arg nr="5" direction="in" default="wxDefaultSize"/>
+    <arg nr="6" direction="in" default="0">
+      <not-bool/>
+    </arg>
+    <arg nr="7" direction="in" default="wxStaticTextNameStr"/>
   </function>
-  <!-- void wxTextAttr::SetBackgroundColour(const wxColour &c) -->
-  <function name="wxTextAttr::SetBackgroundColour">
+  <!-- bool wxDialog::Create(wxWindow * parent, wxWindowID id, const wxString & title, const wxPoint & pos = wxDefaultPosition, const wxSize & size = wxDefaultSize, long style = wxDEFAULT_DIALOG_STYLE, const wxString &  name = wxDialogNameStr) -->
+  <function name="wxDialog::Create">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in"/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in" default="wxDefaultPosition"/>
+    <arg nr="5" direction="in" default="wxDefaultSize"/>
+    <arg nr="6" direction="in" default="wxDEFAULT_DIALOG_STYLE">
+      <not-bool/>
+    </arg>
+    <arg nr="7" direction="in" default="wxDialog"/>
   </function>
-  <!-- virtual bool wxWindow::SetBackgroundStyle (wxBackgroundStyle style) -->
-  <function name="wxWindow::SetBackgroundStyle">
+  <!-- void wxGrid::SetMargins(int extraWidth, int extraHeight) -->
+  <function name="wxGrid::SetMargins">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="bool"/>
-    <arg nr="1" direction="in"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
-  <!-- void wxGridBagSizer::SetEmptyCellSize( const wxSize & sz ) -->
-  <function name="wxGridBagSizer::SetEmptyCellSize">
+  <!-- void wxGrid::SetRowLabelValue(int row, const wxString & value) -->
+  <!-- void wxGrid::SetColLabelValue(int col, const wxString & value) -->
+  <function name="wxGrid::SetRowLabelValue,wxGrid::SetColLabelValue">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
+    <arg nr="2" direction="in"/>
   </function>
-  <!-- FILE* wxFopen(const wxString & path, const wxString & mode) -->
-  <function name="wxFopen">
-    <use-retval/>
-    <returnValue type="FILE *"/>
+  <!-- bool wxCheckListBox::IsChecked( unsigned int uiIndex ) -->
+  <function name="wxCheckListBox::IsChecked">
     <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
     <arg nr="1" direction="in">
-      <not-null/>
-      <strz/>
-    </arg>
-    <arg nr="2" direction="in">
-      <not-null/>
+      <not-uninit/>
+      <valid>0:</valid>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxFileName::SetExt(const wxString & ext) -->
-  <!-- void wxFileName::SetFullName(const wxString & fullname) -->
-  <!-- void wxFileName::SetName(const wxString & name) -->
-  <function name="wxFileName::SetExt,wxFileName::SetFullName,wxFileName::SetName">
+  <!-- void wxFileName::Assign( const wxFileName & filepath ) -->
+  <function name="wxFileName::Assign">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- void wxEvent::SetId(int id)-->
-  <!-- void wxCommandEvent::SetId(int id)-->
-  <function name="wxEvent::SetId,wxCommandEvent::SetId">
+  <!-- bool wxFileName::AppendDir( const wxString & dir ) -->
+  <function name="wxFileName::AppendDir">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!-- void wxCommandEvent::SetInt(int intCommand) -->
-  <function name="wxCommandEvent::SetInt">
+  <!--        bool wxFileName::DirExists( void ) const -->
+  <!-- static bool wxFileName::DirExists( const wxString & dir ) -->
+  <function name="wxFileName::DirExists">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <use-retval/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in" default="wxEmptyString"/>
+  </function>
+  <!-- bool wxFileName::Normalize(int flags = wxPATH_NORM_ALL, const wxString & cwd = wxEmptyString, wxPathFormat format = wxPATH_NATIVE) -->
+  <function name="wxFileName::Normalize">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in" default="wxPATH_NORM_ALL">
       <not-uninit/>
     </arg>
+    <arg nr="2" direction="in" default="wxEmptyString"/>
+    <arg nr="3" direction="in" default="wxPATH_NATIVE"/>
   </function>
-  <!-- void wxStdDialogButtonSizer::AddButton(wxButton * button) -->
-  <function name="wxStdDialogButtonSizer::AddButton">
+  <!-- bool wxGetEnv( const wxString & var, wxString * value ) -->
+  <function name="wxGetEnv">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="inout">
-      <not-null/>
-    </arg>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="out"/>
   </function>
-  <!-- virtual void wxCheckBox::SetValue(bool state) -->
-  <function name="wxCheckBox::SetValue">
+  <!-- void wxCheckListBox::Check (unsigned int item, bool check = true ) -->
+  <function name="wxCheckListBox::Check">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" default="true" direction="in">
+      <not-uninit/>
     </arg>
   </function>
-  <!-- virtual void wxChoice::SetSelection(int n) -->
-  <function name="wxChoice::SetSelection">
+  <!-- void wxGrid::SetReadOnly(int row, int col, bool isReadOnly = true) -->
+  <function name="wxGrid::SetReadOnly">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-  </function>
-  <!-- virtual void wxChoice::SetColumns(int n = 1) -->
-  <function name="wxChoice::SetColumns">
-    <noreturn>false</noreturn>
-    <leak-ignore/>
-    <arg nr="1" direction="in" default="1">
+    <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-  </function>
-  <!-- virtual bool wxTextCtrl::Enable (bool enable=true) -->
-  <!-- virtual bool wxCheckBox::Enable (bool enable=true) -->
-  <function name="wxTextCtrl::Enable,wxCheckBox::Enable">
-    <noreturn>false</noreturn>
-    <leak-ignore/>
-    <arg nr="1" direction="in" default="true">
+    <arg nr="3" direction="in" default="true">
       <not-uninit/>
     </arg>
   </function>
-  <!-- bool wxEvtHandler::Disconnect(int id = wxID_ANY, wxEventType eventType = wxEVT_NULL, wxObjectEventFunction function = NULL, wxObject * userData = NULL, wxEvtHandler * eventSink = NULL) -->
-  <function name="wxEvtHandler::Disconnect,wxButton::Disconnect,wxCheckBox::Disconnect,wxComboBox::Disconnect">
+  <!-- wxGridCellEditor* wxGrid::GetCellEditor(int row, int col) const -->
+  <function name="wxGrid::GetCellEditor">
     <noreturn>false</noreturn>
+    <const/>
+    <returnValue type="wxGridCellEditor *"/>
+    <use-retval/>
     <leak-ignore/>
-    <returnValue type="bool"/>
-    <arg nr="1" direction="in" default="wxID_ANY">
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="2" direction="in" default="wxEVT_NULL"/>
-    <arg nr="3" direction="in" default="NULL">
+    <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="4" direction="inout" default="NULL">
+  </function>
+  <!-- wxGridCellRenderer* wxGrid::GetCellRenderer(int row, int col) const -->
+  <function name="wxGrid::GetCellRenderer">
+    <noreturn>false</noreturn>
+    <const/>
+    <returnValue type="wxGridCellRenderer *"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="5" direction="inout" default="NULL">
+    <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxWindow::SetToolTip(const wxString & tipString) -->
-  <!-- void wxCheckBox::SetToolTip(const wxString & tipString) -->
-  <!-- void wxButton::SetToolTip(const wxString & tipString) -->
-  <!-- void wxBitmapButton::SetToolTip(const wxString & tipString) -->
-  <!-- void wxTextCtrl::SetToolTip(const wxString & tipString) -->
-  <!-- void wxRadioBox::SetToolTip(const wxString & tipString) -->
-  <!-- void wxComboBox::SetToolTip(const wxString & tipString) -->
-  <function name="wxComboBox::SetToolTip,wxWindow::SetToolTip,wxCheckBox::SetToolTip,wxButton::SetToolTip,wxBitmapButton::SetToolTip,wxTextCtrl::SetToolTip,wxRadioBox::SetToolTip">
+  <!-- void wxGridCellRenderer::SetTextColoursAndFont(const wxGrid & grid, const wxGridCellAttr & attr, wxDC & dc, bool isSelected) -->
+  <!-- void wxGridCellStringRenderer::SetTextColoursAndFont(const wxGrid & grid, const wxGridCellAttr & attr, wxDC & dc, bool isSelected) -->
+  <function name="wxGridCellRenderer::SetTextColoursAndFont,wxGridCellStringRenderer::SetTextColoursAndFont">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
-  </function>
-  <!-- bool wxRegEx::Matches( const wxChar * text, int flags = 0 ) -->
-  <!-- bool wxRegEx::Matches( const wxChar * text, int flags, size_t len ) -->
-  <function name="wxRegEx::Matches">
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="out"/>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxRefCounter::DecRef(void) -->
+  <!-- void wxGridCellRenderer::DecRef(void) -->
+  <function name="wxRefCounter::DecRef,wxGridCellRenderer::DecRef">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+  </function>
+  <!-- http://docs.wxwidgets.org/trunk/classwx_grid.html#adbcbd091140c6adf0f8d04ea1642b24d-->
+  <!-- void wxGrid::SetCellTextColour(const wxColour &val, int row, int col) -->
+  <function name="wxGrid::SetCellTextColour">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <const/>
     <leak-ignore/>
-    <use-retval/>
     <arg nr="1" direction="in">
       <not-uninit/>
-      <not-null/>
     </arg>
-    <arg nr="2" default="0" direction="in">
+    <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="3" default="0" direction="in">
+    <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxBitmapToggleButton::SetBitmap( const wxBitmap & bitmap, wxDirection dir = wxLEFT ) -->
-  <!-- void wxCommandLinkButton::SetBitmap( const wxBitmap & bitmap, wxDirection dir = wxLEFT ) -->
-  <!-- void wxContextHelpButton::SetBitmap( const wxBitmap & bitmap, wxDirection dir = wxLEFT ) -->
-  <!-- void wxBitmapButton::SetBitmap( const wxBitmap & bitmap, wxDirection dir = wxLEFT ) -->
-  <function name="wxBitmapToggleButton::SetBitmap,wxCommandLinkButton::SetBitmap,wxContextHelpButton::SetBitmap,wxBitmapButton::SetBitmap">
-    <noreturn>false</noreturn>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" default="wxLEFT" direction="in"/>
-  </function>
-  <!-- void wxBitmapButton::SetBitmapLabel( const wxBitmap & bitmap ) -->
-  <function name="wxBitmapButton::SetBitmapLabel">
-    <noreturn>false</noreturn>
-    <leak-ignore/>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in"/>
-  </function>
-  <!-- void wxSearchCtrl::SetDescriptiveText(const wxString & text) -->
-  <function name="wxSearchCtrl::SetDescriptiveText">
+  <!-- void wxGrid::ClearSelection(void) -->
+  <function name="wxGrid::ClearSelection">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in"/>
   </function>
-  <!-- void wxFlexGridSizer::AddGrowableCol(size_t idx, int proportion = 0) -->
-  <!-- void wxFlexGridSizer::AddGrowableRow(size_t idx, int proportion = 0) -->
-  <!-- void wxGridBagSizer::AddGrowableCol(size_t idx, int proportion = 0) -->
-  <!-- void wxGridBagSizer::AddGrowableRow(size_t idx, int proportion = 0) -->
-  <function name="wxFlexGridSizer::AddGrowableCol,wxFlexGridSizer::AddGrowableRow,wxGridBagSizer::AddGrowableCol,wxGridBagSizer::AddGrowableRow">
+  <!-- http://docs.wxwidgets.org/trunk/classwx_grid.html#adbcbd091140c6adf0f8d04ea1642b24d-->
+  <!-- void wxGrid::SetCellTextColour(wxColour &val) -->
+  <!-- @todo: This is an overloaded function of SetCellTextColour. Activate it once, overloaded functions are supported.
+  <function name="wxGrid::SetCellTextColour">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in" default="0">
+    <arg nr="1">
       <not-uninit/>
     </arg>
-  </function>
-  <!-- wxSize wxSizer::Fit(wxWindow * window)-->
-  <!-- wxSize wxSizer::FitInside(wxWindow * window)-->
-  <!-- wxSize wxBoxSizer::Fit(wxWindow * window)-->
-  <!-- wxSize wxBoxSizer::FitInside(wxWindow * window)-->
-  <!-- wxSize wxFlexGridSizer::Fit(wxWindow * window)-->
-  <!-- wxSize wxFlexGridSizer::FitInside(wxWindow * window)-->
-  <function name="wxSizer::Fit,wxSizer::FitInside,wxBoxSizer::Fit,wxBoxSizer::FitInside,wxFlexGridSizer::Fit,wxFlexGridSizer::FitInside">
+    <warn severity="style">This function is deprecated. Please use 'SetDefaultCellTextColour(colour)' instead.</warn>
+  </function>  -->
+  <!-- int wxEntry (HINSTANCE hInstance, HINSTANCE hPrevInstance = NULL,char * pCmdLine = NULL,int  nCmdShow = SW_SHOWNORMAL) -->
+  <function name="wxEntry">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="wxSize"/>
-    <arg nr="1" direction="inout">
+    <returnValue type="int"/>
+    <arg nr="1">
       <not-uninit/>
-      <not-null/>
     </arg>
-  </function>
-  <!-- virtual void wxFrame::SetMenuBar (wxMenuBar *menuBar) -->
-  <function name="wxFrame::SetMenuBar">
-    <noreturn>false</noreturn>
-    <leak-ignore/>
-    <arg nr="1" direction="inout">
+    <arg nr="2" default="NULL"/>
+    <arg nr="3" default="NULL"/>
+    <arg nr="4" direction="in" default="SW_SHOWNORMAL">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- virtual bool wxMenuBar::Append(wxMenu * menu, const wxString & title) -->
-  <function name="wxMenuBar::Append">
+  <!-- virtual bool wxWindow::SetBackgroundColour(const wxColour &c) -->
+  <!--         bool wxFrame::SetBackgroundColour(const wxColour &c) -->
+  <!--         bool wxTextCtrl::SetBackgroundColour(const wxColour &c) -->
+  <!--         bool wxPanel::SetBackgroundColour(const wxColour &c) -->
+  <!--         bool wxScrolledWindow::SetBackgroundColour(const wxColour &c) -->
+  <!--         bool wxStaticBitmap::SetBackgroundColour(const wxColour &c) -->
+  <!--         bool wxBitmapButton::SetBackgroundColour(const wxColour &c) -->
+  <function name="wxWindow::SetBackgroundColour,wxFrame::SetBackgroundColour,wxBitmapButton::SetBackgroundColour,wxTextCtrl::SetBackgroundColour,wxPanel::SetBackgroundColour,wxScrolledWindow::SetBackgroundColour,wxStaticBitmap::SetBackgroundColour">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="bool"/>
-    <arg nr="1" direction="inout">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in"/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!-- int wxAtoi(const wxString & str)-->
-  <function name="wxAtoi">
+  <!-- wxTextCtrlHitTestResult wxTextCtrl::HitTest(const wxPoint & pt, long * pos) const -->
+  <!-- wxTextCtrlHitTestResult wxTextCtrl::HitTest(const wxPoint & pt, wxTextCoord * col, wxTextCoord *row) const -->
+  <function name="wxTextCtrl::HitTest">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="int"/>
+    <const/>
     <use-retval/>
+    <returnValue type="wxTextCtrlHitTestResult"/>
     <arg nr="1" direction="in"/>
+    <arg nr="2" direction="out"/>
+    <arg nr="3" direction="out" default="NULL"/>
   </function>
-  <!-- double wxAtof(const wxString & str)-->
-  <function name="wxAtof">
+  <!-- void wxGridCellAttr::SetBackgroundColour(const wxColour &c) -->
+  <function name="wxGridCellAttr::SetBackgroundColour">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="double"/>
-    <use-retval/>
+    <returnValue type="void"/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- long wxAtol(const wxString & str)-->
-  <function name="wxAtol">
+  <!-- void wxTextAttr::SetBackgroundColour(const wxColour &c) -->
+  <function name="wxTextAttr::SetBackgroundColour">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="long"/>
-    <use-retval/>
+    <returnValue type="void"/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- bool wxString::ToDouble(double * val) const -->
-  <!-- bool wxString::ToCDouble(double * val) const -->
-  <function name="wxString::ToDouble,wxString::ToCDouble">
+  <!-- virtual bool wxWindow::SetBackgroundStyle (wxBackgroundStyle style) -->
+  <function name="wxWindow::SetBackgroundStyle">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <const/>
     <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxGridBagSizer::SetEmptyCellSize( const wxSize & sz ) -->
+  <function name="wxGridBagSizer::SetEmptyCellSize">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
-      <not-null/>
+      <not-uninit/>
     </arg>
   </function>
-  <!-- wxString & wxString::Trim( bool bFromRight = true ) -->
-  <function name="wxString::Trim">
+  <!-- void wxDC::SetUserScale( double x, double y) -->
+  <!-- void wxGCDC::SetUserScale( double x, double y) -->
+  <function name="wxDC::SetUserScale,wxGCDC::SetUserScale">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
     <leak-ignore/>
-    <returnValue type="wxString &amp;"/>
-    <arg nr="1" direction="in" default="true">
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!-- wxString wxString::Strip (stripType s = trailing) const -->
-  <function name="wxString::Strip">
+  <!-- FILE* wxFopen(const wxString & path, const wxString & mode) -->
+  <function name="wxFopen">
+    <use-retval/>
+    <returnValue type="FILE *"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in">
+      <not-null/>
+      <strz/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- bool wxDynamicLibrary::Load(const wxString & name, int flags = wxDL_DEFAULT) -->
+  <function name="wxDynamicLibrary::Load">
+    <use-retval/>
+    <returnValue type="bool"/>
     <noreturn>false</noreturn>
-    <leak-ignore/>
-    <const/>
-    <returnValue type="wxString"/>
     <arg nr="1" direction="in"/>
-    <warn severity="style">This is the same as wxString::Trim() except that it doesn't change this string. This is a wxWidgets 1.xx compatibility function; you should not use it in new code.</warn>
+    <arg nr="2" default="wxDL_DEFAULT" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
-  <!-- int wxItemContainer::Append(const wxString & item) -->
-  <!-- int wxItemContainer::Append(const wxArrayString & items) -->
-  <!-- int wxItemContainer::Append(const std::vector< wxString > & items) -->
-  <!-- int wxItemContainer::Append(const wxString & item, void * clientData) -->
-  <!-- int wxItemContainer::Append(const wxString & item, wxClientData * clientData) -->
-  <!-- int wxComboBox::Append(const wxString & item) -->
-  <!-- int wxChoice::Append(const wxString & item) -->
-  <!-- int wxListBox::Append(const wxString & item) -->
-  <function name="wxItemContainer::Append,wxComboBox::Append,wxChoice::Append,wxListBox::Append">
+  <!-- void *wxDynamicLibrary::RawGetSymbol(wxDllType handle, const wxString& name) -->
+  <function name="wxDynamicLibrary::RawGetSymbol">
+    <use-retval/>
+    <returnValue type="void *"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxFileName::SetExt(const wxString & ext) -->
+  <!-- void wxFileName::SetFullName(const wxString & fullname) -->
+  <!-- void wxFileName::SetName(const wxString & name) -->
+  <function name="wxFileName::SetExt,wxFileName::SetFullName,wxFileName::SetName">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="int"/>
-    <arg nr="any" direction="in"/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!-- virtual void wxBitmap::SetDepth(int depth)  -->
-  <!-- virtual void wxBitmap::SetHeight(int height)-->
-  <!-- virtual void wxBitmap::SetWidth(int width)  -->
-  <function name="wxBitmap::SetDepth,wxBitmap::SetHeight,wxBitmap::SetWidth">
+  <!-- void wxEvent::SetId(int id)-->
+  <!-- void wxCommandEvent::SetId(int id)-->
+  <!-- void wxPropertyGridEvent::SetId(int id)-->
+  <function name="wxEvent::SetId,wxCommandEvent::SetId,wxPropertyGridEvent::SetId">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <warn severity="style">This function is deprecated since version 3.1.2, dimensions and depth can only be set at construction time.</warn>
   </function>
-  <!-- bool wxString::ToLong(long * val, int base = 10) const -->
-  <!-- bool wxString::ToCLong(long * val, int base = 10) const -->
-  <!-- bool wxString::ToLongLong(long long * val, int base = 10) const -->
-  <!-- bool wxString::ToULong(unsigned long * val, int base = 10) const -->
-  <!-- bool wxString::ToCULong(unsigned long * val, int base = 10) const -->
-  <!-- bool wxString::ToULongLong(unsigned long long * val, int base = 10) const -->
-  <function name="wxString::ToLong,wxString::ToCLong,wxString::ToLongLong,wxString::ToULong,wxString::ToCULong,wxString::ToULongLong">
+  <!-- bool wxFileName::Mkdir(int perm = wxS_DIR_DEFAULT, int flags = 0) const -->
+  <function name="wxFileName::Mkdir">
+    <use-retval/>
+    <returnValue type="bool"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <const/>
-    <returnValue type="bool"/>
-    <arg nr="1" direction="out">
-      <not-null/>
+    <arg nr="1" default="wxS_DIR_DEFAULT" direction="in">
+      <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="2" direction="in" default="10">
+    <arg nr="2" default="0" direction="in">
       <not-uninit/>
-      <valid>0,2:36</valid>
+      <not-bool/>
     </arg>
   </function>
-  <!-- bool wxUIActionSimulator::MouseDragDrop (long x1, long y1, long x2, long y2, int button = wxMOUSE_BTN_LEFT) -->
-  <function name="wxUIActionSimulator::MouseDragDrop">
+  <!-- void wxCommandEvent::SetInt(int intCommand) -->
+  <function name="wxCommandEvent::SetInt">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="bool"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="3" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="4" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="5" direction="in" default="wxMOUSE_BTN_LEFT">
-      <not-uninit/>
+  </function>
+  <!-- void wxStdDialogButtonSizer::AddButton(wxButton * button) -->
+  <function name="wxStdDialogButtonSizer::AddButton">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-null/>
     </arg>
   </function>
-  <!-- bool wxUIActionSimulator::MouseMove(long x,long y) -->
-  <function name="wxUIActionSimulator::MouseMove">
+  <!-- virtual void wxCheckBox::SetValue(bool state) -->
+  <!-- virtual void wxToggleButton::SetValue(bool state) -->
+  <function name="wxCheckBox::SetValue,wxToggleButton::SetValue">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="bool"/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
-    </arg>
   </function>
-  <!-- bool wxUIActionSimulator::KeyUp(int keycode, int modifiers = wxMOD_NONE)-->
-  <!-- bool wxUIActionSimulator::KeyDown(int keycode, int modifiers = wxMOD_NONE)-->
-  <!-- bool wxUIActionSimulator::Char(int keycode, int modifiers = wxMOD_NONE)-->
-  <function name="wxUIActionSimulator::KeyUp,wxUIActionSimulator::KeyDown,wxUIActionSimulator::Char">
+  <!-- virtual void wxChoice::SetSelection(int n) -->
+  <function name="wxChoice::SetSelection">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="bool"/>
     <arg nr="1" direction="in">
       <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in" default="wxMOD_NONE">
-      <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- bool wxUIActionSimulator::MouseMove(const wxPoint & point)-->
-  <function name="wxUIActionSimulator::MouseMove">
+  <!-- virtual void wxChoice::SetColumns(int n = 1) -->
+  <function name="wxChoice::SetColumns">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="bool"/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in" default="1">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- bool wxUIActionSimulator::MouseUp(int button = wxMOUSE_BTN_LEFT)-->
-  <!-- bool wxUIActionSimulator::MouseDblClick(int button = wxMOUSE_BTN_LEFT)-->
-  <!-- bool wxUIActionSimulator::MouseClick(int button = wxMOUSE_BTN_LEFT)-->
-  <function name="wxUIActionSimulator::MouseUp,wxUIActionSimulator::MouseDblClick,wxUIActionSimulator::MouseClick">
+  <!-- virtual bool wxTextCtrl::Enable (bool enable=true) -->
+  <!-- virtual bool wxCheckBox::Enable (bool enable=true) -->
+  <function name="wxTextCtrl::Enable,wxCheckBox::Enable">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="bool"/>
-    <arg nr="1" direction="in" default="wxMOUSE_BTN_LEFT">
+    <arg nr="1" direction="in" default="true">
       <not-uninit/>
     </arg>
   </function>
-  <!-- bool wxUIActionSimulator::MouseDown(int button = wxMOUSE_BTN_DOWN)-->
-  <function name="wxUIActionSimulator::MouseDown">
+  <!--  static wxString wxFileName::CreateTempFileName( const wxString & prefix, wxFile * fileTemp = NULL ) -->
+  <!--  static wxString wxFileName::CreateTempFileName( const wxString & prefix, wxFFile * fileTemp = NULL ) -->
+  <function name="wxFileName::CreateTempFileName">
     <noreturn>false</noreturn>
-    <leak-ignore/>
-    <returnValue type="bool"/>
-    <arg nr="1" direction="in" default="wxMOUSE_BTN_DOWN">
+    <returnValue type="wxString"/>
+    <pure/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="NULL">
       <not-uninit/>
     </arg>
   </function>
-  <!-- bool wxUIActionSimulator::Select(const wxString & text)-->
-  <!-- bool wxUIActionSimulator::Text(const wxString & text)-->
-  <function name="wxUIActionSimulator::Select,wxUIActionSimulator::Text">
-    <noreturn>false</noreturn>
-    <leak-ignore/>
-    <returnValue type="bool"/>
-    <arg nr="1" direction="in"/>
-  </function>
-  <!-- bool wxPGProperty::SetValueFromInt(long value, int flags = 0) -->
-  <!-- bool wxBoolProperty::SetValueFromInt(long value, int flags = 0) -->
-  <function name="wxPGProperty::SetValueFromInt,wxBoolProperty::SetValueFromInt">
+  <!-- bool wxEvtHandler::Disconnect(int id = wxID_ANY, wxEventType eventType = wxEVT_NULL, wxObjectEventFunction function = NULL, wxObject * userData = NULL, wxEvtHandler * eventSink = NULL) -->
+  <function name="wxEvtHandler::Disconnect,wxSlider::Disconnect,wxSpinCtrl::Disconnect,wxRadioBox::Disconnect,wxRadioButton::Disconnect,wxCheckListBox::Disconnect,wxListBox::Disconnect,wxStaticText::Disconnect,wxTextCtrl::Disconnect,wxButton::Disconnect,wxBitmapButton::Disconnect,wxCheckBox::Disconnect,wxComboBox::Disconnect,wxWindow::Disconnect,wxChoice::Disconnect">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="bool"/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in" default="wxID_ANY">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="2" direction="in" default="0">
+    <arg nr="2" direction="in" default="wxEVT_NULL"/>
+    <arg nr="3" direction="in" default="NULL">
       <not-uninit/>
     </arg>
-  </function>
-  <!-- void wxPGProperty::SetValue(wxVariant value, wxVariant * pList = NULL, int flags = wxPG_SETVAL_REFRESH_EDITOR) -->
-  <function name="wxPGProperty::SetValue">
-    <noreturn>false</noreturn>
-    <leak-ignore/>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in" default="0">
+    <arg nr="4" direction="inout" default="NULL">
       <not-uninit/>
     </arg>
-    <arg nr="3" direction="in" default="wxPG_SETVAL_REFRESH_EDITOR">
+    <arg nr="5" direction="inout" default="NULL">
       <not-uninit/>
     </arg>
   </function>
-  <!-- void wxPGProperty::SetExpanded(bool expanded) -->
-  <function name="wxPGProperty::SetExpanded">
+  <!-- void wxEvtHandler::Connect(int id, int lastId, wxEventType eventType, wxObjectEventFunction function, wxObject * userData = NULL, wxEvtHandler * eventSink = NULL) -->
+  <!-- void wxEvtHandler::Connect(int id, wxEventType eventType, wxObjectEventFunction function, wxObject * userData = NULL, wxEvtHandler * eventSink = NULL)-->
+  <!-- void wxEvtHandler::Connect(wxEventType eventType, wxObjectEventFunction function, wxObject * userData = NULL, wxEvtHandler * eventSink = NULL)-->
+  <function name="wxEvtHandler::Connect,wxSpinCtrl::Connect,wxRadioBox::Connect,wxRadioButton::Connect,wxStyledTextCtrl::Connect,wxCheckListBox::Connect,wxComboBox::Connect,wxStaticText::Connect,wxTextCtrl::Connect,wxStaticBitmap::Connect,wxButton::Connect,wxSlider::Connect,wxBitmapButton::Connect,wxCheckBox::Connect,wxWindow::Connect,wxChoice::Connect,wxListBox::Connect">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-  </function>
-  <!-- void wxPropertyGridInterface::SetPropertyReadOnly(wxPGPropArg id, bool set = true, int flags = wxPG_RECURSE)	 -->
-  <!-- void wxPropertyGridPage::SetPropertyReadOnly(wxPGPropArg id, bool set = true, int flags = wxPG_RECURSE)	 -->
-  <function name="wxPropertyGridInterface::SetPropertyReadOnly,wxPropertyGridPage::SetPropertyReadOnly">
-    <noreturn>false</noreturn>
-    <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="2" direction="in" default="true">
+    <arg nr="3" direction="in" default="NULL">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="3" direction="in" default="wxPG_RECURSE">
+    <arg nr="4" direction="inout" default="NULL">
       <not-uninit/>
+      <not-bool/>
     </arg>
-  </function>
-  <!-- wxPGProperty* wxPropertyGridInterface::AppendIn(wxPGPropArg id, wxPGProperty * newProperty)-->
-  <!-- wxPGProperty* wxPropertyGridPage::AppendIn(wxPGPropArg id, wxPGProperty * newProperty)-->
-  <function name="wxPropertyGridInterface::AppendIn,wxPropertyGridPage::AppendIn">
-    <noreturn>false</noreturn>
-    <leak-ignore/>
-    <returnValue type="wxPGProperty*"/>
-    <arg nr="1" direction="in">
+    <arg nr="5" direction="inout" default="NULL">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="2" direction="inout">
+    <arg nr="6" direction="inout" default="NULL">
       <not-uninit/>
-      <not-null/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxPGProperty::SetAttribute(const wxString & name, wxVariant value) -->
-  <!-- void wxBoolProperty::SetAttribute(const wxString & name, wxVariant value) -->
-  <!-- void wxFileProperty::SetAttribute(const wxString & name, wxVariant value) -->
-  <function name="wxPGProperty::SetAttribute,wxBoolProperty::SetAttribute,wxFileProperty::SetAttribute">
-    <noreturn>false</noreturn>
-    <leak-ignore/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in"/>
-  </function>
-  <!-- void wxFrame::SetStatusText( const wxString & text, int number = 0 ) -->
-  <function name="wxFrame::SetStatusText">
+  <!-- wxString& wxString::erase (wxString::size_type pos = 0, size_type n = wxString::npos) -->
+  <!-- wxString::iterator wxString::erase (wxString::iterator first, wxString::iterator last); -->
+  <!-- wxString::iterator wxString::erase (wxString::iterator first) -->
+  <function name="wxString::erase">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in" default="0">
+    <arg nr="1" direction="in" default="0">
       <not-uninit/>
+      <not-bool/>
     </arg>
-  </function>
-  <!-- bool wxString::StartsWith( const wxString & prefix, wxString * rest = NULL ) const -->
-  <!-- bool wxString::EndsWith( const wxString & suffix, wxString * rest = NULL ) const -->
-  <function name="wxString::StartsWith,wxString::EndsWith">
-    <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <const/>
-    <leak-ignore/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in" default="NULL">
+    <arg nr="2" direction="in" default="wxString::npos">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- wxPGProperty* wxStringProperty::AppendChild(wxPGProperty * childProperty) -->
-  <!-- wxPGProperty* wxPGProperty::AppendChild(wxPGProperty * childProperty) -->
-  <function name="wxPGProperty::AppendChild,wxStringProperty::AppendChild">
+  <!-- void wxBitmap::SetMask( wxMask * mask ) -->
+  <function name="wxBitmap::SetMask">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="wxPGProperty*"/>
-    <arg nr="1" direction="inout">
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
       <not-uninit/>
       <not-null/>
     </arg>
   </function>
-  <!-- void wxPropertyGridInterface::SetPropertyImage( wxPGPropArg id, wxBitmap & bmp ) -->
-  <!-- void wxPropertyGridManager::SetPropertyImage( wxPGPropArg id, wxBitmap & bmp ) -->
-  <function name="wxPropertyGridInterface::SetPropertyImage,wxPropertyGridManager::SetPropertyImage">
+  <!-- void wxWindow::SetToolTip(const wxString & tipString) -->
+  <!-- void wxCheckBox::SetToolTip(const wxString & tipString) -->
+  <!-- void wxButton::SetToolTip(const wxString & tipString) -->
+  <!-- void wxBitmapButton::SetToolTip(const wxString & tipString) -->
+  <!-- void wxRadioButton::SetToolTip(const wxString & tipString) -->
+  <!-- void wxTextCtrl::SetToolTip(const wxString & tipString) -->
+  <!-- void wxRadioBox::SetToolTip(const wxString & tipString) -->
+  <!-- void wxComboBox::SetToolTip(const wxString & tipString) -->
+  <!-- void wxStaticText::SetToolTip(const wxString & tipString) -->
+  <!-- void wxChoice::SetToolTip(const wxString & tipString) -->
+  <!-- void wxSpinCtrl::SetToolTip(const wxString & tipString) -->
+  <!-- void wxSlider::SetToolTip(const wxString & tipString) -->
+  <function name="wxComboBox::SetToolTip,wxRadioButton::SetToolTip,wxSlider::SetToolTip,wxSpinCtrl::SetToolTip,wxWindow::SetToolTip,wxChoice::SetToolTip,wxCheckBox::SetToolTip,wxButton::SetToolTip,wxBitmapButton::SetToolTip,wxTextCtrl::SetToolTip,wxRadioBox::SetToolTip,wxStaticText::SetToolTip">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
-    <arg nr="2" direction="inout"/>
   </function>
-  <!-- bool wxPGProperty::SetValueFromString(const wxString & text, int flags = wxPG_PROGRAMMATIC_VALUE) -->
-  <!-- bool wxFloatProperty::SetValueFromString(const wxString & text, int flags = wxPG_PROGRAMMATIC_VALUE) -->
-  <!-- bool wxBoolProperty::SetValueFromString(const wxString & text, int flags = wxPG_PROGRAMMATIC_VALUE) -->
-  <function name="wxPGProperty::SetValueFromString,wxFloatProperty::SetValueFromString,wxBoolProperty::SetValueFromString">
+  <!-- bool wxRegEx::Matches( const wxChar * text, int flags = 0 ) -->
+  <!-- bool wxRegEx::Matches( const wxChar * text, int flags, size_t len ) -->
+  <function name="wxRegEx::Matches">
     <noreturn>false</noreturn>
-    <leak-ignore/>
     <returnValue type="bool"/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in" default="wxPG_PROGRAMMATIC_VALUE">
+    <const/>
+    <leak-ignore/>
+    <use-retval/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-null/>
     </arg>
-  </function>
-  <!-- void wxPGProperty::SetTextColour(const wxColour & colour, int flags = wxPG_RECURSE)	-->
-  <function name="wxPGProperty::SetTextColour">
-    <noreturn>false</noreturn>
-    <leak-ignore/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in" default="wxPG_RECURSE">
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" default="0" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- virtual wxClassInfo * wxObject::GetClassInfo () const -->
-  <!-- and inherited classes -->
-  <function name="wxObject::GetClassInfo,wxAcceleratorTable::GetClassInfo,wxAccessible::GetClassInfo,wxAnimation::GetClassInfo,wxArchiveClassFactory::GetClassInfo,wxArchiveEntry::GetClassInfo,wxArtProvider::GetClassInfo,wxAutomationObject::GetClassInfo,wxBitmapHandler::GetClassInfo,wxClient::GetClassInfo,wxClipboard::GetClassInfo,wxColour::GetClassInfo,wxColourData::GetClassInfo,wxColourPropertyValue::GetClassInfo,wxCommand::GetClassInfo,wxCommandProcessor::GetClassInfo,wxConfigBase::GetClassInfo,wxConnection::GetClassInfo,wxConnectionBase::GetClassInfo,wxContextHelp::GetClassInfo,wxDataViewIconText::GetClassInfo,wxDataViewRenderer::GetClassInfo,wxDC::GetClassInfo,wxDDEClient::GetClassInfo,wxDocTemplate::GetClassInfo,wxDragImage::GetClassInfo,wxEncodingConverter::GetClassInfo,wxEvent::GetClassInfo,wxEvtHandler::GetClassInfo,wxFileHistory::GetClassInfo,wxFileSystem::GetClassInfo,wxFileSystemHandler::GetClassInfo,wxFilterClassFactory::GetClassInfo,wxFindReplaceData::GetClassInfo,wxFontData::GetClassInfo,wxFSFile::GetClassInfo,wxGDIObject::GetClassInfo,wxGLContext::GetClassInfo,wxGraphicsObject::GetClassInfo,wxGraphicsRenderer::GetClassInfo,wxGridTableBase::GetClassInfo,wxHashTable::GetClassInfo,wxHelpControllerBase::GetClassInfo,wxHtmlCell::GetClassInfo,wxHtmlDCRenderer::GetClassInfo,wxHtmlEasyPrinting::GetClassInfo,wxHtmlFilter::GetClassInfo,wxHtmlHelpData::GetClassInfo,wxHtmlLinkInfo::GetClassInfo,wxHtmlTagHandler::GetClassInfo,wxImage::GetClassInfo,wxImageHandler::GetClassInfo,wxImageList::GetClassInfo,wxIndividualLayoutConstraint::GetClassInfo,wxJoystick::GetClassInfo,wxLayoutAlgorithm::GetClassInfo,wxLayoutConstraints::GetClassInfo,wxListItem::GetClassInfo,wxMask::GetClassInfo,wxMenuItem::GetClassInfo,wxMetafile::GetClassInfo,wxModule::GetClassInfo,wxPageSetupDialog::GetClassInfo,wxPageSetupDialogData::GetClassInfo,wxPGCell::GetClassInfo,wxPGEditor::GetClassInfo,wxPGEditorDialogAdapter::GetClassInfo,wxPGProperty::GetClassInfo,wxPrintData::GetClassInfo,wxPrintDialog::GetClassInfo,wxPrintDialogData::GetClassInfo,wxPrinter::GetClassInfo,wxPrintout::GetClassInfo,wxPrintPreview::GetClassInfo,wxQuantize::GetClassInfo,wxRegionIterator::GetClassInfo,wxRichTextAction::GetClassInfo,wxRichTextDrawingContext::GetClassInfo,wxRichTextDrawingHandler::GetClassInfo,wxRichTextFieldType::GetClassInfo,wxRichTextFileHandler::GetClassInfo,wxRichTextFontTable::GetClassInfo,wxRichTextFormattingDialogFactory::GetClassInfo,wxRichTextHeaderFooterData::GetClassInfo,wxRichTextImageBlock::GetClassInfo,wxRichTextObject::GetClassInfo,wxRichTextPrinting::GetClassInfo,wxRichTextProperties::GetClassInfo,wxRichTextRenderer::GetClassInfo,wxRichTextStyleDefinition::GetClassInfo,wxRichTextStyleSheet::GetClassInfo,wxSizer::GetClassInfo,wxSizerItem::GetClassInfo,wxSockAddress::GetClassInfo,wxSocketBase::GetClassInfo,wxSound::GetClassInfo,wxStringTokenizer::GetClassInfo,wxSystemOptions::GetClassInfo,wxTCPClient::GetClassInfo,wxTCPConnection::GetClassInfo,wxTCPServer::GetClassInfo,wxToolBarToolBase::GetClassInfo,wxToolTip::GetClassInfo,wxURI::GetClassInfo,wxVariant::GetClassInfo,wxWebViewFactory::GetClassInfo,wxXmlDocument::GetClassInfo,wxXmlResource::GetClassInfo,wxXmlResourceHandler::GetClassInfo">
+  <!-- void wxBitmapToggleButton::SetBitmap( const wxBitmap & bitmap, wxDirection dir = wxLEFT ) -->
+  <!-- void wxCommandLinkButton::SetBitmap( const wxBitmap & bitmap, wxDirection dir = wxLEFT ) -->
+  <!-- void wxContextHelpButton::SetBitmap( const wxBitmap & bitmap, wxDirection dir = wxLEFT ) -->
+  <!-- void wxBitmapButton::SetBitmap( const wxBitmap & bitmap, wxDirection dir = wxLEFT ) -->
+  <function name="wxBitmapToggleButton::SetBitmap,wxCommandLinkButton::SetBitmap,wxContextHelpButton::SetBitmap,wxBitmapButton::SetBitmap">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <const/>
-    <returnValue type="wxClassInfo *"/>
-    <use-retval/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="wxLEFT" direction="in"/>
   </function>
-  <!-- void wxFilePickerCtrl::SetPath(const wxString & filename) -->
-  <function name="wxFilePickerCtrl::SetPath">
+  <!-- void wxBitmapButton::SetBitmapLabel( const wxBitmap & bitmap ) -->
+  <function name="wxBitmapButton::SetBitmapLabel">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="void"/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- void wxEvent::SetEventType(wxEventType type) -->
-  <!-- void wxCommandEvent::SetEventType(wxEventType type) -->
-  <function name="wxEvent::SetEventType,wxCommandEvent::SetEventType">
+  <!-- void wxCmdLineParser::AddOption(const wxString & name, const wxString & lng = wxEmptyString, const wxString & desc = wxEmptyString, wxCmdLineParamType type = wxCMD_LINE_VAL_STRING, int flags = 0) -->
+  <function name="wxCmdLineParser::AddOption">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="void"/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="wxEmptyString" direction="in"/>
+    <arg nr="3" default="wxEmptyString" direction="in"/>
+    <arg nr="4" direction="in" default="wxCMD_LINE_VAL_STRING">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" direction="in" default="0">
       <not-uninit/>
     </arg>
   </function>
-  <!-- virtual wxString wxColour::GetAsString(long flags = wxC2S_NAME|wxC2S_CSS_SYNTAX)	const -->
-  <function name="wxColour::GetAsString">
+  <!-- static void wxValidator::SuppressBellOnError(bool suppress = true) -->
+  <function name="wxValidator::SuppressBellOnError">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <const/>
-    <returnValue type="wxString"/>
-    <use-retval/>
-    <arg nr="1" direction="in" default="wxC2S_NAME|wxC2S_CSS_SYNTAX">
+    <returnValue type="void"/>
+    <arg nr="1" direction="in" default="true">
       <not-uninit/>
     </arg>
   </function>
-  <!-- void wxFlexGridSizer::SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode) -->
-  <function name="wxFlexGridSizer::SetNonFlexibleGrowMode">
+  <!-- void wxBitmapToggleButton::SetValue( bool state ) -->
+  <function name="wxBitmapToggleButton::SetValue">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="void"/>
@@ -7298,1776 +9173,5158 @@
       <not-uninit/>
     </arg>
   </function>
-  <!-- They are implemented as macros in wxWidgets, but its better to configure them as functions -->
-  <!-- const wxClassInfo * wxCLASSINFO(info) -->
-  <!-- const wxClassInfo *   CLASSINFO(info) -->
-  <function name="wxCLASSINFO,CLASSINFO">
+  <!-- void wxAnyButton::SetBitmapCurrent (const wxBitmap &bitmap) -->
+  <!-- void wxAnyButton::SetBitmapDisabled (const wxBitmap &bitmap) -->
+  <!-- void wxAnyButton::SetBitmapFocus (const wxBitmap &bitmap) -->
+  <!-- void wxAnyButton::SetBitmapLabel (const wxBitmap &bitmap) -->
+  <!-- void wxAnyButton::SetBitmapPressed (const wxBitmap &bitmap) -->
+  <!-- void wxBitmapToggleButton::SetBitmapCurrent (const wxBitmap &bitmap) -->
+  <!-- void wxBitmapToggleButton::SetBitmapDisabled (const wxBitmap &bitmap) -->
+  <!-- void wxBitmapToggleButton::SetBitmapFocus (const wxBitmap &bitmap) -->
+  <!-- void wxBitmapToggleButton::SetBitmapLabel (const wxBitmap &bitmap) -->
+  <!-- void wxBitmapToggleButton::SetBitmapPressed (const wxBitmap &bitmap) -->
+  <function name="wxAnyButton::SetBitmapCurrent,wxAnyButton::SetBitmapDisabled,wxAnyButton::SetBitmapFocus,wxAnyButton::SetBitmapLabel,wxAnyButton::SetBitmapPressed,wxAnyButton::SetBitmapPressed,wxBitmapToggleButton::SetBitmapCurrent,wxBitmapToggleButton::SetBitmapDisabled,wxBitmapToggleButton::SetBitmapFocus,wxBitmapToggleButton::SetBitmapLabel,wxBitmapToggleButton::SetBitmapPressed">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="const wxClassInfo *"/>
-    <use-retval/>
+    <returnValue type="void"/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- wxObjectRefData * wxObject::GetRefData () const -->
-  <!-- and inherited classes -->
-  <function name="wxObject::GetRefData,wxAcceleratorTable::GetRefData,wxAccessible::GetRefData,wxAnimation::GetRefData,wxArchiveClassFactory::GetRefData,wxArchiveEntry::GetRefData,wxArtProvider::GetRefData,wxAutomationObject::GetRefData,wxBitmapHandler::GetRefData,wxClient::GetRefData,wxClipboard::GetRefData,wxColour::GetRefData,wxColourData::GetRefData,wxColourPropertyValue::GetRefData,wxCommand::GetRefData,wxCommandProcessor::GetRefData,wxConfigBase::GetRefData,wxConnection::GetRefData,wxConnectionBase::GetRefData,wxContextHelp::GetRefData,wxDataViewIconText::GetRefData,wxDataViewRenderer::GetRefData,wxDC::GetRefData,wxDDEClient::GetRefData,wxDocTemplate::GetRefData,wxDragImage::GetRefData,wxEncodingConverter::GetRefData,wxEvent::GetRefData,wxEvtHandler::GetRefData,wxFileHistory::GetRefData,wxFileSystem::GetRefData,wxFileSystemHandler::GetRefData,wxFilterClassFactory::GetRefData,wxFindReplaceData::GetRefData,wxFontData::GetRefData,wxFSFile::GetRefData,wxGDIObject::GetRefData,wxGLContext::GetRefData,wxGraphicsObject::GetRefData,wxGraphicsRenderer::GetRefData,wxGridTableBase::GetRefData,wxHashTable::GetRefData,wxHelpControllerBase::GetRefData,wxHtmlCell::GetRefData,wxHtmlDCRenderer::GetRefData,wxHtmlEasyPrinting::GetRefData,wxHtmlFilter::GetRefData,wxHtmlHelpData::GetRefData,wxHtmlLinkInfo::GetRefData,wxHtmlTagHandler::GetRefData,wxImage::GetRefData,wxImageHandler::GetRefData,wxImageList::GetRefData,wxIndividualLayoutConstraint::GetRefData,wxJoystick::GetRefData,wxLayoutAlgorithm::GetRefData,wxLayoutConstraints::GetRefData,wxListItem::GetRefData,wxMask::GetRefData,wxMenuItem::GetRefData,wxMetafile::GetRefData,wxModule::GetRefData,wxPageSetupDialog::GetRefData,wxPageSetupDialogData::GetRefData,wxPGCell::GetRefData,wxPGEditor::GetRefData,wxPGEditorDialogAdapter::GetRefData,wxPGProperty::GetRefData,wxPrintData::GetRefData,wxPrintDialog::GetRefData,wxPrintDialogData::GetRefData,wxPrinter::GetRefData,wxPrintout::GetRefData,wxPrintPreview::GetRefData,wxQuantize::GetRefData,wxRegionIterator::GetRefData,wxRichTextAction::GetRefData,wxRichTextDrawingContext::GetRefData,wxRichTextDrawingHandler::GetRefData,wxRichTextFieldType::GetRefData,wxRichTextFileHandler::GetRefData,wxRichTextFontTable::GetRefData,wxRichTextFormattingDialogFactory::GetRefData,wxRichTextHeaderFooterData::GetRefData,wxRichTextImageBlock::GetRefData,wxRichTextObject::GetRefData,wxRichTextPrinting::GetRefData,wxRichTextProperties::GetRefData,wxRichTextRenderer::GetRefData,wxRichTextStyleDefinition::GetRefData,wxRichTextStyleSheet::GetRefData,wxSizer::GetRefData,wxSizerItem::GetRefData,wxSockAddress::GetRefData,wxSocketBase::GetRefData,wxSound::GetRefData,wxStringTokenizer::GetRefData,wxSystemOptions::GetRefData,wxTCPClient::GetRefData,wxTCPConnection::GetRefData,wxTCPServer::GetRefData,wxToolBarToolBase::GetRefData,wxToolTip::GetRefData,wxURI::GetRefData,wxVariant::GetRefData,wxWebViewFactory::GetRefData,wxXmlDocument::GetRefData,wxXmlResource::GetRefData,wxXmlResourceHandler::GetRefData">
+  <!-- bool wxBitmapToggleButton::GetValue( ) const -->
+  <function name="wxBitmapToggleButton::GetValue">
     <noreturn>false</noreturn>
-    <leak-ignore/>
     <const/>
-    <returnValue type="wxObjectRefData *"/>
-    <use-retval/>
-  </function>
-  <!-- bool IsKindOf (const wxClassInfo *info) const -->
-  <!-- and inherited classes -->
-  <function name="wxObject::IsKindOf,wxAcceleratorTable::IsKindOf,wxAccessible::IsKindOf,wxAnimation::IsKindOf,wxArchiveClassFactory::IsKindOf,wxArchiveEntry::IsKindOf,wxArtProvider::IsKindOf,wxAutomationObject::IsKindOf,wxBitmapHandler::IsKindOf,wxClient::IsKindOf,wxClipboard::IsKindOf,wxColour::IsKindOf,wxColourData::IsKindOf,wxColourPropertyValue::IsKindOf,wxCommand::IsKindOf,wxCommandProcessor::IsKindOf,wxConfigBase::IsKindOf,wxConnection::IsKindOf,wxConnectionBase::IsKindOf,wxContextHelp::IsKindOf,wxDataViewIconText::IsKindOf,wxDataViewRenderer::IsKindOf,wxDC::IsKindOf,wxDDEClient::IsKindOf,wxDocTemplate::IsKindOf,wxDragImage::IsKindOf,wxEncodingConverter::IsKindOf,wxEvent::IsKindOf,wxEvtHandler::IsKindOf,wxFileHistory::IsKindOf,wxFileSystem::IsKindOf,wxFileSystemHandler::IsKindOf,wxFilterClassFactory::IsKindOf,wxFindReplaceData::IsKindOf,wxFontData::IsKindOf,wxFSFile::IsKindOf,wxGDIObject::IsKindOf,wxGLContext::IsKindOf,wxGraphicsObject::IsKindOf,wxGraphicsRenderer::IsKindOf,wxGridTableBase::IsKindOf,wxHashTable::IsKindOf,wxHelpControllerBase::IsKindOf,wxHtmlCell::IsKindOf,wxHtmlDCRenderer::IsKindOf,wxHtmlEasyPrinting::IsKindOf,wxHtmlFilter::IsKindOf,wxHtmlHelpData::IsKindOf,wxHtmlLinkInfo::IsKindOf,wxHtmlTagHandler::IsKindOf,wxImage::IsKindOf,wxImageHandler::IsKindOf,wxImageList::IsKindOf,wxIndividualLayoutConstraint::IsKindOf,wxJoystick::IsKindOf,wxLayoutAlgorithm::IsKindOf,wxLayoutConstraints::IsKindOf,wxListItem::IsKindOf,wxMask::IsKindOf,wxMenuItem::IsKindOf,wxMetafile::IsKindOf,wxModule::IsKindOf,wxPageSetupDialog::IsKindOf,wxPageSetupDialogData::IsKindOf,wxPGCell::IsKindOf,wxPGEditor::IsKindOf,wxPGEditorDialogAdapter::IsKindOf,wxPGProperty::IsKindOf,wxPrintData::IsKindOf,wxPrintDialog::IsKindOf,wxPrintDialogData::IsKindOf,wxPrinter::IsKindOf,wxPrintout::IsKindOf,wxPrintPreview::IsKindOf,wxQuantize::IsKindOf,wxRegionIterator::IsKindOf,wxRichTextAction::IsKindOf,wxRichTextDrawingContext::IsKindOf,wxRichTextDrawingHandler::IsKindOf,wxRichTextFieldType::IsKindOf,wxRichTextFileHandler::IsKindOf,wxRichTextFontTable::IsKindOf,wxRichTextFormattingDialogFactory::IsKindOf,wxRichTextHeaderFooterData::IsKindOf,wxRichTextImageBlock::IsKindOf,wxRichTextObject::IsKindOf,wxRichTextPrinting::IsKindOf,wxRichTextProperties::IsKindOf,wxRichTextRenderer::IsKindOf,wxRichTextStyleDefinition::IsKindOf,wxRichTextStyleSheet::IsKindOf,wxSizer::IsKindOf,wxSizerItem::IsKindOf,wxSockAddress::IsKindOf,wxSocketBase::IsKindOf,wxSound::IsKindOf,wxStringTokenizer::IsKindOf,wxSystemOptions::IsKindOf,wxTCPClient::IsKindOf,wxTCPConnection::IsKindOf,wxTCPServer::IsKindOf,wxToolBarToolBase::IsKindOf,wxToolTip::IsKindOf,wxURI::IsKindOf,wxVariant::IsKindOf,wxWebViewFactory::IsKindOf,wxXmlDocument::IsKindOf,wxXmlResource::IsKindOf,wxXmlResourceHandler::IsKindOf">
-    <noreturn>false</noreturn>
     <leak-ignore/>
     <use-retval/>
-    <const/>
     <returnValue type="bool"/>
-    <arg nr="1" direction="in">
-      <not-null/>
-    </arg>
   </function>
-  <!-- bool IsSameAs (const wxObject &obj) const -->
-  <function name="wxObject::IsSameAs,wxAcceleratorTable::IsSameAs,wxBitmap::IsSameAs,wxAccessible::IsSameAs,wxAnimation::IsSameAs,wxArchiveClassFactory::IsSameAs,wxArchiveEntry::IsSameAs,wxArtProvider::IsSameAs,wxAutomationObject::IsSameAs,wxBitmapHandler::IsSameAs,wxClient::IsSameAs,wxClipboard::IsSameAs,wxColour::IsSameAs,wxColourData::IsSameAs,wxColourPropertyValue::IsSameAs,wxCommand::IsSameAs,wxCommandProcessor::IsSameAs,wxConfigBase::IsSameAs,wxConnection::IsSameAs,wxConnectionBase::IsSameAs,wxContextHelp::IsSameAs,wxDataViewIconText::IsSameAs,wxDataViewRenderer::IsSameAs,wxDC::IsSameAs,wxDDEClient::IsSameAs,wxDocTemplate::IsSameAs,wxDragImage::IsSameAs,wxEncodingConverter::IsSameAs,wxEvent::IsSameAs,wxEvtHandler::IsSameAs,wxFileHistory::IsSameAs,wxFileSystem::IsSameAs,wxFileSystemHandler::IsSameAs,wxFilterClassFactory::IsSameAs,wxFindReplaceData::IsSameAs,wxFontData::IsSameAs,wxFSFile::IsSameAs,wxGDIObject::IsSameAs,wxGLContext::IsSameAs,wxGraphicsObject::IsSameAs,wxGraphicsRenderer::IsSameAs,wxGridTableBase::IsSameAs,wxHashTable::IsSameAs,wxHelpControllerBase::IsSameAs,wxHtmlCell::IsSameAs,wxHtmlDCRenderer::IsSameAs,wxHtmlEasyPrinting::IsSameAs,wxHtmlFilter::IsSameAs,wxHtmlHelpData::IsSameAs,wxHtmlLinkInfo::IsSameAs,wxHtmlTagHandler::IsSameAs,wxImage::IsSameAs,wxImageHandler::IsSameAs,wxImageList::IsSameAs,wxIndividualLayoutConstraint::IsSameAs,wxJoystick::IsSameAs,wxLayoutAlgorithm::IsSameAs,wxLayoutConstraints::IsSameAs,wxListItem::IsSameAs,wxMask::IsSameAs,wxMenuItem::IsSameAs,wxMetafile::IsSameAs,wxModule::IsSameAs,wxPageSetupDialog::IsSameAs,wxPageSetupDialogData::IsSameAs,wxPGCell::IsSameAs,wxPGEditor::IsSameAs,wxPGEditorDialogAdapter::IsSameAs,wxPGProperty::IsSameAs,wxPrintData::IsSameAs,wxPrintDialog::IsSameAs,wxPrintDialogData::IsSameAs,wxPrinter::IsSameAs,wxPrintout::IsSameAs,wxPrintPreview::IsSameAs,wxQuantize::IsSameAs,wxRegionIterator::IsSameAs,wxRichTextAction::IsSameAs,wxRichTextDrawingContext::IsSameAs,wxRichTextDrawingHandler::IsSameAs,wxRichTextFieldType::IsSameAs,wxRichTextFileHandler::IsSameAs,wxRichTextFontTable::IsSameAs,wxRichTextFormattingDialogFactory::IsSameAs,wxRichTextHeaderFooterData::IsSameAs,wxRichTextImageBlock::IsSameAs,wxRichTextObject::IsSameAs,wxRichTextPrinting::IsSameAs,wxRichTextProperties::IsSameAs,wxRichTextRenderer::IsSameAs,wxRichTextStyleDefinition::IsSameAs,wxRichTextStyleSheet::IsSameAs,wxSizer::IsSameAs,wxSizerItem::IsSameAs,wxSockAddress::IsSameAs,wxSocketBase::IsSameAs,wxSound::IsSameAs,wxStringTokenizer::IsSameAs,wxSystemOptions::IsSameAs,wxTCPClient::IsSameAs,wxTCPConnection::IsSameAs,wxTCPServer::IsSameAs,wxToolBarToolBase::IsSameAs,wxToolTip::IsSameAs,wxURI::IsSameAs,wxVariant::IsSameAs,wxWebViewFactory::IsSameAs,wxXmlDocument::IsSameAs,wxXmlResource::IsSameAs,wxXmlResourceHandler::IsSameAs">
+  <!-- void wxSearchCtrl::SetDescriptiveText(const wxString & text) -->
+  <function name="wxSearchCtrl::SetDescriptiveText">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <use-retval/>
-    <const/>
-    <returnValue type="bool"/>
+    <returnValue type="void"/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- bool wxString::IsSameAs(const wxString & s, bool caseSensitive = true) const -->
-  <!-- bool wxString::IsSameAs(const wxUniChar ch, bool caseSensitive = true) const -->
-  <function name="wxString::IsSameAs">
+  <!-- void wxFlexGridSizer::AddGrowableCol(size_t idx, int proportion = 0) -->
+  <!-- void wxFlexGridSizer::AddGrowableRow(size_t idx, int proportion = 0) -->
+  <!-- void wxGridBagSizer::AddGrowableCol(size_t idx, int proportion = 0) -->
+  <!-- void wxGridBagSizer::AddGrowableRow(size_t idx, int proportion = 0) -->
+  <function name="wxFlexGridSizer::AddGrowableCol,wxFlexGridSizer::AddGrowableRow,wxGridBagSizer::AddGrowableCol,wxGridBagSizer::AddGrowableRow">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <use-retval/>
-    <const/>
-    <returnValue type="bool"/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in" default="true">
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in" default="0">
+      <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- wxMenuItem* wxMenu::AppendCheckItem(int id, const wxString & item, const wxString & 	help = wxEmptyString)-->
-  <!-- wxMenuItem* wxMenu::AppendRadioItem(int id, const wxString & item, const wxString & 	help = wxEmptyString)-->
-  <function name="wxMenu::AppendCheckItem,wxMenu::AppendRadioItem">
+  <!-- wxSize wxSizer::Fit(wxWindow * window)-->
+  <!-- wxSize wxSizer::FitInside(wxWindow * window)-->
+  <!-- wxSize wxBoxSizer::Fit(wxWindow * window)-->
+  <!-- wxSize wxBoxSizer::FitInside(wxWindow * window)-->
+  <!-- wxSize wxFlexGridSizer::Fit(wxWindow * window)-->
+  <!-- wxSize wxFlexGridSizer::FitInside(wxWindow * window)-->
+  <function name="wxSizer::Fit,wxSizer::FitInside,wxBoxSizer::Fit,wxBoxSizer::FitInside,wxFlexGridSizer::Fit,wxFlexGridSizer::FitInside">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="wxMenuItem*"/>
-    <arg nr="1" direction="in">
+    <returnValue type="wxSize"/>
+    <arg nr="1" direction="inout">
       <not-uninit/>
+      <not-null/>
     </arg>
-    <arg nr="2" direction="in"/>
-    <arg nr="3" direction="in" default="wxEmptyString"/>
   </function>
-  <!-- void Ref(const wxObject &clone) -->
-  <function name="wxObject::Ref,wxAcceleratorTable::Ref,wxAccessible::Ref,wxAnimation::Ref,wxArchiveClassFactory::Ref,wxArchiveEntry::Ref,wxArtProvider::Ref,wxAutomationObject::Ref,wxBitmapHandler::Ref,wxClient::Ref,wxClipboard::Ref,wxColour::Ref,wxColourData::Ref,wxColourPropertyValue::Ref,wxCommand::Ref,wxCommandProcessor::Ref,wxConfigBase::Ref,wxConnection::Ref,wxConnectionBase::Ref,wxContextHelp::Ref,wxDataViewIconText::Ref,wxDataViewRenderer::Ref,wxDC::Ref,wxDDEClient::Ref,wxDocTemplate::Ref,wxDragImage::Ref,wxEncodingConverter::Ref,wxEvent::Ref,wxEvtHandler::Ref,wxFileHistory::Ref,wxFileSystem::Ref,wxFileSystemHandler::Ref,wxFilterClassFactory::Ref,wxFindReplaceData::Ref,wxFontData::Ref,wxFSFile::Ref,wxGDIObject::Ref,wxGLContext::Ref,wxGraphicsObject::Ref,wxGraphicsRenderer::Ref,wxGridTableBase::Ref,wxHashTable::Ref,wxHelpControllerBase::Ref,wxHtmlCell::Ref,wxHtmlDCRenderer::Ref,wxHtmlEasyPrinting::Ref,wxHtmlFilter::Ref,wxHtmlHelpData::Ref,wxHtmlLinkInfo::Ref,wxHtmlTagHandler::Ref,wxImage::Ref,wxImageHandler::Ref,wxImageList::Ref,wxIndividualLayoutConstraint::Ref,wxJoystick::Ref,wxLayoutAlgorithm::Ref,wxLayoutConstraints::Ref,wxListItem::Ref,wxMask::Ref,wxMenuItem::Ref,wxMetafile::Ref,wxModule::Ref,wxPageSetupDialog::Ref,wxPageSetupDialogData::Ref,wxPGCell::Ref,wxPGEditor::Ref,wxPGEditorDialogAdapter::Ref,wxPGProperty::Ref,wxPrintData::Ref,wxPrintDialog::Ref,wxPrintDialogData::Ref,wxPrinter::Ref,wxPrintout::Ref,wxPrintPreview::Ref,wxQuantize::Ref,wxRegionIterator::Ref,wxRichTextAction::Ref,wxRichTextDrawingContext::Ref,wxRichTextDrawingHandler::Ref,wxRichTextFieldType::Ref,wxRichTextFileHandler::Ref,wxRichTextFontTable::Ref,wxRichTextFormattingDialogFactory::Ref,wxRichTextHeaderFooterData::Ref,wxRichTextImageBlock::Ref,wxRichTextObject::Ref,wxRichTextPrinting::Ref,wxRichTextProperties::Ref,wxRichTextRenderer::Ref,wxRichTextStyleDefinition::Ref,wxRichTextStyleSheet::Ref,wxSizer::Ref,wxSizerItem::Ref,wxSockAddress::Ref,wxSocketBase::Ref,wxSound::Ref,wxStringTokenizer::Ref,wxSystemOptions::Ref,wxTCPClient::Ref,wxTCPConnection::Ref,wxTCPServer::Ref,wxToolBarToolBase::Ref,wxToolTip::Ref,wxURI::Ref,wxVariant::Ref,wxWebViewFactory::Ref,wxXmlDocument::Ref,wxXmlResource::Ref,wxXmlResourceHandler::Ref">
+  <!-- virtual void wxFrame::SetMenuBar (wxMenuBar *menuBar) -->
+  <function name="wxFrame::SetMenuBar">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="in"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+    </arg>
   </function>
-  <!-- https://docs.wxwidgets.org/3.1/classwx_window.html -->
-  <!-- bool wxWindow::Close (bool force = false) -->
-  <function name="wxWindow::Close,wxBannerWindow::Close,wxControl::Close,wxGLCanvas::Close,wxHtmlHelpWindow::Close,wxMDIClientWindow::Close,wxMenuBar::Close,wxNativeWindow::Close,wxNonOwnedWindow::Close,wxPanel::Close,wxPGMultiButton::Close,wxSashWindow::Close,wxSplitterWindow::Close,wxTipWindow::Close,wxTreeListCtrl::Close,wxActiveXContainer::Close,wxActivityIndicator::Close,wxAnimationCtrl::Close,wxAnyButton::Close,wxAuiToolBar::Close,wxBookCtrlBase::Close,wxCalenderCtrl::Close,wxCheckBox::Close,wxChoice::Close,wxCollapsibleHeaderCtrl::Close,wxCollapsiblePane::Close,wxComboBox::Close,wxComboCtrl::Close,wxControlWithItems::Close,wxDataViewCtrl::Close,wxDatePickerCtrl::Close,wxFileCtrl::Close,wxGauge::Close,wxGenericDirCtrl::Close,wxHeaderCtrl::Close,wxHyperlinkCtrl::Close,wxInfoBar::Close,wxListBox::Close,wxListCtrl::Close,wxMediaCtrl::Close,wxPickerBase::Close,wxPropertyGrid::Close,wxRadioBox::Close,wxRadioButton::Close,wxRibbonControl::Close,wxRichTextCtrl::Close">
-    <noreturn>true</noreturn>
+  <!-- virtual bool wxMenuBar::Append(wxMenu * menu, const wxString & title) -->
+  <function name="wxMenuBar::Append">
+    <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="bool"/>
-    <arg nr="1" direction="in" default="false">
+    <arg nr="1" direction="inout">
       <not-uninit/>
     </arg>
+    <arg nr="2" direction="in"/>
   </function>
-  <!-- void wxStaticText::Wrap (int width ) -->
-  <function name="wxStaticText::Wrap">
+  <!-- size_t wxStrlen ( const wxCharBuffer & s) -->
+  <!-- size_t wxStrlen ( const wxWCharBuffer & s ) -->
+  <!-- size_t wxStrlen ( const wxString & s ) -->
+  <!-- size_t wxStrlen ( const wxCStrData & s) -->
+  <function name="wxStrlen">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
+    <returnValue type="size_t">strlen(arg1)</returnValue>
+    <use-retval/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!-- virtual void wxDialog::EndModal(int retCode) -->
-  <function name="wxDialog::EndModal">
+  <!-- int wxAtoi(const wxString & str)-->
+  <function name="wxAtoi">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
+    <returnValue type="int"/>
+    <use-retval/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!-- virtual void wxListBox::SetSelection(int n) -->
-  <function name="wxListBox::SetSelection">
+  <!-- double wxAtof(const wxString & str)-->
+  <function name="wxAtof">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
+    <returnValue type="double"/>
+    <use-retval/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!-- void wxWindow::SetPosition(const wxPoint & pt)
-       and derived classes -->
-  <function name="wxWindow::SetPosition,wxStaticText::SetPosition,wxButton::SetPosition,wxBannerWindow::SetPosition,wxControl::SetPosition,wxGLCanvas::SetPosition,wxHtmlHelpWindow::SetPosition,wxMDIClientWindow::SetPosition,wxMenuBar::SetPosition,wxNativeWindow::SetPosition,wxNonOwnedWindow::SetPosition,wxPanel::SetPosition,wxPGMultiButton::SetPosition,wxSashWindow::SetPosition,wxSplitterWindow::SetPosition,wxTipWindow::SetPosition,wxTreeListCtrl::SetPosition,wxActiveXContainer::SetPosition,wxActivityIndicator::SetPosition,wxAnimationCtrl::SetPosition,wxAnyButton::SetPosition,wxAuiToolBar::SetPosition,wxBookCtrlBase::SetPosition,wxCalenderCtrl::SetPosition,wxCheckBox::SetPosition,wxChoice::SetPosition,wxCollapsibleHeaderCtrl::SetPosition,wxCollapsiblePane::SetPosition,wxComboBox::SetPosition,wxComboCtrl::SetPosition,wxControlWithItems::SetPosition,wxDataViewCtrl::SetPosition,wxDatePickerCtrl::SetPosition,wxFileCtrl::SetPosition,wxGauge::SetPosition,wxGenericDirCtrl::SetPosition,wxHeaderCtrl::SetPosition,wxHyperlinkCtrl::SetPosition,wxInfoBar::SetPosition,wxListBox::SetPosition,wxListCtrl::SetPosition,wxMediaCtrl::SetPosition,wxPickerBase::SetPosition,wxPropertyGrid::SetPosition,wxRadioBox::SetPosition,wxRadioButton::SetPosition,wxRibbonCtrl::SetPosition,wxRichTextCtrl::SetPosition">
+  <!-- long wxAtol(const wxString & str)-->
+  <function name="wxAtol">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="void"/>
+    <returnValue type="long"/>
+    <use-retval/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- bool wxGrid::AppendCols( int numCols = 1, bool updateLabels = true ) -->
-  <!-- bool wxGrid::AppendRows( int numRows = 1, bool updateLabels = true ) -->
-  <function name="wxGrid::AppendCols,wxGrid::AppendRows">
+  <!-- bool wxString::ToDouble(double * val) const -->
+  <!-- bool wxString::ToCDouble(double * val) const -->
+  <function name="wxString::ToDouble,wxString::ToCDouble">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
     <leak-ignore/>
-    <arg nr="1" direction="in" default="1">
-      <not-uninit/>
+    <const/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="out">
+      <not-null/>
     </arg>
-    <arg nr="2" direction="in" default="true">
+  </function>
+  <!-- wxString & wxString::Trim( bool bFromRight = true ) -->
+  <function name="wxString::Trim">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString &amp;"/>
+    <arg nr="1" direction="in" default="true">
       <not-uninit/>
     </arg>
   </function>
-  <!-- virtual bool SetFont (const wxFont &font) 
-       and derived classes -->
-  <function name="wxSpinCtrl::SetFont,wxGrid::SetFont,wxStyledTextCtrl::SetFont,wxStaticBox::SetFont,wxButton::SetFont,wxDataViewTreeCtrl::SetFont,wxTextCtrl::SetFont,wxWindow::SetFont,wxPropertyGridManager::SetFont,wxPaintDC::SetFont,wxStaticText::SetFont,wxBannerWindow::SetFont,wxControl::SetFont,wxGLCanvas::SetFont,wxHtmlHelpWindow::SetFont,wxMDIClientWindow::SetFont,wxMenuBar::SetFont,wxNativeWindow::SetFont,wxNonOwnedWindow::SetFont,wxPanel::SetFont,wxPGMultiButton::SetFont,wxSashWindow::SetFont,wxSplitterWindow::SetFont,wxTipWindow::SetFont,wxTreeListCtrl::SetFont,wxActiveXContainer::SetFont,wxActivityIndicator::SetFont,wxAnimationCtrl::SetFont,wxAnyButton::SetFont,wxAuiToolBar::SetFont,wxBookCtrlBase::SetFont,wxCalenderCtrl::SetFont,wxCheckBox::SetFont,wxChoice::SetFont,wxCollapsibleHeaderCtrl::SetFont,wxCollapsiblePane::SetFont,wxComboBox::SetFont,wxComboCtrl::SetFont,wxControlWithItems::SetFont,wxDataViewCtrl::SetFont,wxDatePickerCtrl::SetFont,wxFileCtrl::SetFont,wxGauge::SetFont,wxGenericDirCtrl::SetFont,wxHeaderCtrl::SetFont,wxHyperlinkCtrl::SetFont,wxInfoBar::SetFont,wxListBox::SetFont,wxListCtrl::SetFont,wxMediaCtrl::SetFont,wxPickerBase::SetFont,wxPropertyGrid::SetFont,wxRadioBox::SetFont,wxRadioButton::SetFont,wxRibbonCtrl::SetFont,wxRichTextCtrl::SetFont">
+  <!-- wxString wxString::Strip (stripType s = trailing) const -->
+  <function name="wxString::Strip">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="bool"/>
+    <const/>
+    <returnValue type="wxString"/>
     <arg nr="1" direction="in"/>
+    <warn severity="style">This is the same as wxString::Trim() except that it doesn't change this string. This is a wxWidgets 1.xx compatibility function; you should not use it in new code.</warn>
   </function>
-  <!-- virtual void wxStaticText::SetLabel ( const wxString & label ) -->
-  <function name="wxStaticText::SetLabel">
+  <!-- int wxItemContainer::Append(const wxString & item) -->
+  <!-- int wxItemContainer::Append(const wxArrayString & items) -->
+  <!-- int wxItemContainer::Append(const std::vector< wxString > & items) -->
+  <!-- int wxItemContainer::Append(const wxString & item, void * clientData) -->
+  <!-- int wxItemContainer::Append(const wxString & item, wxClientData * clientData) -->
+  <!-- int wxComboBox::Append(const wxString & item) -->
+  <!-- int wxChoice::Append(const wxString & item) -->
+  <!-- int wxListBox::Append(const wxString & item) -->
+  <function name="wxItemContainer::Append,wxComboBox::Append,wxChoice::Append,wxListBox::Append">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="in"/>
+    <returnValue type="int"/>
+    <arg nr="any" direction="in"/>
   </function>
-  <!--virtual wxToolBarToolBase* wxToolBar::AddControl(wxControl * control, const wxString & label = wxEmptyString)-->
-  <function name="wxToolBar::AddControl">
+  <!-- virtual void wxBitmap::SetDepth(int depth)  -->
+  <!-- virtual void wxBitmap::SetHeight(int height)-->
+  <!-- virtual void wxBitmap::SetWidth(int width)  -->
+  <function name="wxBitmap::SetDepth,wxBitmap::SetHeight,wxBitmap::SetWidth">
     <noreturn>false</noreturn>
-    <returnValue type="wxToolBarToolBase *"/>
     <leak-ignore/>
-    <arg nr="1" direction="inout">
-      <not-null/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="2" direction="in" default="wxEmptyString"/>
+    <warn severity="style">This function is deprecated since version 3.1.2, dimensions and depth can only be set at construction time.</warn>
   </function>
-  <!-- void wxDC::DrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height ) -->
-  <!-- void wxMemoryDC::DrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height ) -->
-  <function name="wxDC::DrawEllipse,wxMemoryDC::DrawEllipse">
+  <!-- void wxItemContainer::Delete(unsigned int n) -->
+  <!-- void wxListBox::Delete(unsigned int n) -->
+  <function name="wxItemContainer::Delete,wxListBox::Delete">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
     <leak-ignore/>
-    <arg nr="any" direction="in">
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>0:</valid>
     </arg>
   </function>
-  <!-- void wxDC::DrawEllipticArc (wxCoord x, wxCoord y, wxCoord width, wxCoord height, double start, double end) -->
-  <!-- void wxDC::DrawEllipticArc (const wxPoint &pt, const wxSize &sz, double sa, double ea) -->
-  <function name="wxDC::DrawEllipticArc,wxGCDC::DrawEllipticArc,wxMemoryDC::DrawEllipticArc,wxBufferedDC::DrawEllipticArc,wxBufferedPaintDC::DrawEllipticArc,wxAutoBufferedPaintDC::DrawEllipticArc,wxMetafileDC::DrawEllipticArc,wxMirrorDC::DrawEllipticArc,wxPostScriptDC::DrawEllipticArc,wxPrinterDC::DrawEllipticArc,wxScreenDC::DrawEllipticArc,wxSVGFileDC::DrawEllipticArc,wxWindowDC::DrawEllipticArc,wxClientDC::DrawEllipticArc,wxPaintDC::DrawEllipticArc">
+  <!-- bool wxString::ToLong(long * val, int base = 10) const -->
+  <!-- bool wxString::ToCLong(long * val, int base = 10) const -->
+  <!-- bool wxString::ToLongLong(long long * val, int base = 10) const -->
+  <!-- bool wxString::ToULong(unsigned long * val, int base = 10) const -->
+  <!-- bool wxString::ToCULong(unsigned long * val, int base = 10) const -->
+  <!-- bool wxString::ToULongLong(unsigned long long * val, int base = 10) const -->
+  <function name="wxString::ToLong,wxString::ToCLong,wxString::ToLongLong,wxString::ToULong,wxString::ToCULong,wxString::ToULongLong">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
     <leak-ignore/>
-    <arg nr="any" direction="in">
+    <const/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in" default="10">
       <not-uninit/>
+      <not-bool/>
+      <valid>0,2:36</valid>
     </arg>
   </function>
-  <!-- void wxDC::DrawSpline (int n, const wxPoint points[]) -->
-  <!-- void wxDC::DrawSpline (const wxPointList *points) -->
-  <!-- void wxDC::DrawSpline (wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord x3, wxCoord y3) -->
-  <function name="wxDC::DrawSpline,wxMemoryDC::DrawSpline,wxBufferedDC::DrawSpline,wxBufferedPaintDC::DrawSpline,wxAutoBufferedPaintDC::DrawSpline,wxMetaFileDC::DrawSpline,wxMirrorDC::DrawSpline,wxPostScriptDC::DrawSpline,wxGCDC::DrawSpline,wxPrinterDC::DrawSpline,wxScreenDC::DrawSpline,wxSVGFileDC::DrawSpline,wxWindowDC::DrawSpline,wxClientDC::DrawSpline,wxPaintDC::DrawSpline">
+  <!-- bool wxUIActionSimulator::MouseDragDrop (long x1, long y1, long x2, long y2, int button = wxMOUSE_BTN_LEFT) -->
+  <function name="wxUIActionSimulator::MouseDragDrop">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
     <leak-ignore/>
-    <arg nr="any" direction="in">
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="in" default="wxMOUSE_BTN_LEFT">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- virtual void wxFont::SetWeight(wxFontWeight weight) -->
-  <function name="wxFont::SetWeight">
+  <!-- bool wxUIActionSimulator::MouseMove(long x,long y) -->
+  <function name="wxUIActionSimulator::MouseMove">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
     <leak-ignore/>
+    <returnValue type="bool"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- bool wxSizer::SetItemMinSize( wxWindow * window, int width, int height ) -->
-  <!-- bool wxBoxSizer::SetItemMinSize( wxWindow * window, int width, int height ) -->
-  <function name="wxSizer::SetItemMinSize,wxBoxSizer::SetItemMinSize">
+  <!-- bool wxUIActionSimulator::KeyUp(int keycode, int modifiers = wxMOD_NONE)-->
+  <!-- bool wxUIActionSimulator::KeyDown(int keycode, int modifiers = wxMOD_NONE)-->
+  <!-- bool wxUIActionSimulator::Char(int keycode, int modifiers = wxMOD_NONE)-->
+  <function name="wxUIActionSimulator::KeyUp,wxUIActionSimulator::KeyDown,wxUIActionSimulator::Char">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
     <leak-ignore/>
-    <arg nr="1" direction="inout">
-      <not-null/>
-    </arg>
-    <arg nr="2" direction="in">
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="3" direction="in">
+    <arg nr="2" direction="in" default="wxMOD_NONE">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- wxPoint wxRect::GetPosition() const -->
-  <function name="wxStaticText::GetPosition">
+  <!-- bool wxUIActionSimulator::MouseMove(const wxPoint & point)-->
+  <function name="wxUIActionSimulator::MouseMove">
     <noreturn>false</noreturn>
-    <returnValue type="wxPoint"/>
     <leak-ignore/>
-    <const/>
-    <use-retval/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
-  <!-- bool wxVariant::IsNull() const -->
-  <function name="wxVariant::IsNull">
+  <!-- bool wxUIActionSimulator::MouseUp(int button = wxMOUSE_BTN_LEFT)-->
+  <!-- bool wxUIActionSimulator::MouseDblClick(int button = wxMOUSE_BTN_LEFT)-->
+  <!-- bool wxUIActionSimulator::MouseClick(int button = wxMOUSE_BTN_LEFT)-->
+  <function name="wxUIActionSimulator::MouseUp,wxUIActionSimulator::MouseDblClick,wxUIActionSimulator::MouseClick">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
     <leak-ignore/>
-    <const/>
-    <use-retval/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in" default="wxMOUSE_BTN_LEFT">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
-  <!-- void wxVariant::MakeNull() -->
-  <function name="wxVariant::MakeNull">
+  <!-- bool wxUIActionSimulator::MouseDown(int button = wxMOUSE_BTN_DOWN)-->
+  <function name="wxUIActionSimulator::MouseDown">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
     <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in" default="wxMOUSE_BTN_DOWN">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
-  <!-- bool wxVariant::IsType() const -->
-  <function name="wxVariant::IsType">
+  <!-- bool wxUIActionSimulator::Select(const wxString & text)-->
+  <function name="wxUIActionSimulator::Select">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
     <leak-ignore/>
-    <const/>
-    <use-retval/>
+    <returnValue type="bool"/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- wxAny wxVariant::GetAny() const -->
-  <function name="wxVariant::GetAny">
+  <!-- bool wxUIActionSimulator::Text(const char *)-->
+  <function name="wxUIActionSimulator::Text">
     <noreturn>false</noreturn>
-    <returnValue type="wxAny"/>
     <leak-ignore/>
-    <const/>
-    <use-retval/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
-  <!-- wxArrayString wxVariant::GetArrayString() const -->
-  <function name="wxVariant::GetArrayString">
+  <!-- void wxPGProperty::SetFlagRecursively(wxPGPropertyFlags flag, bool set)-->
+  <function name="wxPGProperty::SetFlagRecursively">
     <noreturn>false</noreturn>
-    <returnValue type="wxArrayString"/>
     <leak-ignore/>
-    <const/>
-    <use-retval/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <valid>0,1</valid>
+    </arg>
   </function>
-  <!-- bool wxVariant::GetBool() const -->
-  <function name="wxVariant::GetBool">
+  <!-- bool wxPGProperty::Hide(bool hide, int flags = wxPG_RECURSE)-->
+  <function name="wxPGProperty::Hide">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
     <leak-ignore/>
-    <const/>
-    <use-retval/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in" default="wxPG_RECURSE">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
-  <!-- wxUniChar wxVariant::GetChar() const -->
-  <function name="wxVariant::GetChar">
+  <!-- virtual void wxPGSpinCtrlEditor::OnFocus (wxPGProperty *property, wxWindow *wnd) const-->
+  <!-- virtual void wxPGTextCtrlEditor::OnFocus (wxPGProperty *property, wxWindow *wnd) const-->
+  <!-- virtual void wxPGTextCtrlAndButtonEditor::OnFocus (wxPGProperty *property, wxWindow *wnd) const-->
+  <function name="wxPGSpinCtrlEditor::OnFocus,wxPGTextCtrlAndButtonEditor::OnFocus">
     <noreturn>false</noreturn>
-    <returnValue type="wxUniChar"/>
     <leak-ignore/>
     <const/>
-    <use-retval/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-null/>
+    </arg>
   </function>
-  <!-- wxVariantData * wxVariant::GetData () const-->
-  <function name="wxVariant::GetData">
+  <!-- bool wxPGProperty::SetValueFromInt(long value, int flags = 0) -->
+  <!-- bool wxBoolProperty::SetValueFromInt(long value, int flags = 0) -->
+  <!-- bool wxIntProperty::SetValueFromInt(long value, int flags = 0) -->
+  <!-- bool wxUIntProperty::SetValueFromInt(long value, int flags = 0) -->
+  <function name="wxPGProperty::SetValueFromInt,wxBoolProperty::SetValueFromInt,wxIntProperty::SetValueFromInt,wxUIntProperty::SetValueFromInt">
     <noreturn>false</noreturn>
-    <returnValue type="wxVariantData *"/>
     <leak-ignore/>
-    <const/>
-    <use-retval/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in" default="0">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
-  <!-- wxDateTime wxVariant::GetDateTime () const-->
-  <function name="wxVariant::GetDateTime">
+  <!-- void wxPGProperty::SetBackgroundColour(const wxColour &colour, int flags = wxPG_RECURSE) -->
+  <function name="wxPGProperty::SetBackgroundColour">
     <noreturn>false</noreturn>
-    <returnValue type="wxDateTime"/>
     <leak-ignore/>
-    <const/>
-    <use-retval/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="wxPG_RECURSE">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
-  <!-- double wxVariant::GetDouble () const-->
-  <function name="wxVariant::GetDouble">
+  <!-- const wxPGCell& wxPGProperty::GetCell(unsigned int column) const -->
+  <!--       wxPGCell& wxPGProperty::GetCell(unsigned int column) -->
+  <function name="wxPGProperty::GetCell">
     <noreturn>false</noreturn>
-    <returnValue type="double"/>
     <leak-ignore/>
-    <const/>
     <use-retval/>
+    <returnValue type="wxPGCell &amp;"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
-  <!-- long wxVariant::GetLong() const -->
-  <function name="wxVariant::GetLong">
+  <!-- void wxFocusEvent::SetWindow(wxWindow * win) -->
+  <function name="wxFocusEvent::SetWindow">
     <noreturn>false</noreturn>
-    <returnValue type="long"/>
     <leak-ignore/>
-    <const/>
-    <use-retval/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
-  <!-- wxLongLong wxVariant::GetLongLong() const -->
-  <function name="wxVariant::GetLongLong">
+  <!-- virtual void wxFileHistory::RemoveFileFromHistory(size_t i) -->
+  <function name="wxFileHistory::RemoveFileFromHistory">
     <noreturn>false</noreturn>
-    <returnValue type="wxLongLong"/>
     <leak-ignore/>
-    <const/>
-    <use-retval/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
-  <!-- const wxString & wxVariant::GetName () const-->
-  <function name="wxVariant::GetName">
+  <!-- void wxPGProperty::SetValue(wxVariant value, wxVariant * pList = NULL, int flags = wxPG_SETVAL_REFRESH_EDITOR) -->
+  <function name="wxPGProperty::SetValue">
     <noreturn>false</noreturn>
-    <returnValue type="wxString &amp;"/>
     <leak-ignore/>
-    <const/>
-    <use-retval/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="0">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in" default="wxPG_SETVAL_REFRESH_EDITOR">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
-  <!-- wxString wxVariant::GetString () const-->
-  <!-- wxString wxVariant::GetType () const-->
-  <function name="wxVariant::GetString,wxVariant::GetType">
+  <!-- void wxPGProperty::SetExpanded(bool expanded) -->
+  <!-- void wxStringProperty::SetExpanded(bool expanded) -->
+  <function name="wxPGProperty::SetExpanded,wxStringProperty::SetExpanded">
     <noreturn>false</noreturn>
-    <returnValue type="wxString"/>
     <leak-ignore/>
-    <const/>
-    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
-  <!-- wxULongLong wxVariant::GetULongLong() const -->
-  <function name="wxVariant::GetULongLong">
+  <!-- void wxPGProperty::SetEditor(const wxString &editorName) -->
+  <!-- void wxPGProperty::SetEditor(const wxPGEditor * editor) -->
+  <!-- void wxStringProperty::SetEditor(const wxString &editorName) -->
+  <!-- void wxStringProperty::SetEditor(const wxPGEditor * editor) -->
+  <function name="wxPGProperty::SetEditor,wxStringProperty::SetEditor">
     <noreturn>false</noreturn>
-    <returnValue type="wxULongLong"/>
     <leak-ignore/>
-    <const/>
-    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
-  <!-- void * wxVariant::GetVoidPtr() const -->
-  <function name="wxVariant::GetVoidPtr">
+  <!-- void wxSashLayoutWindow::SetDefaultSize(const wxSize & size) -->
+  <function name="wxSashLayoutWindow::SetDefaultSize">
     <noreturn>false</noreturn>
-    <returnValue type="void *"/>
     <leak-ignore/>
-    <const/>
-    <use-retval/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!-- wxObject * wxVariant::GetWxObjectPtr() const -->
-  <function name="wxVariant::GetWxObjectPtr">
+  <!-- void wxPropertyGridInterface::SetPropertyReadOnly(wxPGPropArg id, bool set = true, int flags = wxPG_RECURSE)  -->
+  <!-- void wxPropertyGridPage::SetPropertyReadOnly(wxPGPropArg id, bool set = true, int flags = wxPG_RECURSE)   -->
+  <!-- void wxPropertyGridManager::SetPropertyReadOnly(wxPGPropArg id, bool set = true, int flags = wxPG_RECURSE)    -->
+  <function name="wxPropertyGridInterface::SetPropertyReadOnly,wxPropertyGridPage::SetPropertyReadOnly,wxPropertyGridManager::SetPropertyReadOnly">
     <noreturn>false</noreturn>
-    <returnValue type="wxObject *"/>
     <leak-ignore/>
-    <const/>
-    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in" default="true">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in" default="wxPG_RECURSE">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
-  <!-- void wxSize::SetHeight(int height)-->
-  <!-- void wxSize::SetWidth(int width)-->
-  <function name="wxSize::SetHeight,wxSize::SetWidth">
+  <!-- wxPGProperty* wxPropertyGridInterface::AppendIn(wxPGPropArg id, wxPGProperty * newProperty)-->
+  <!-- wxPGProperty* wxPropertyGridPage::AppendIn(wxPGPropArg id, wxPGProperty * newProperty)-->
+  <function name="wxPropertyGridInterface::AppendIn,wxPropertyGridPage::AppendIn">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="wxPGProperty*"/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
+    <arg nr="2" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
   </function>
-  <!-- virtual void wxBrush::SetColour(const wxColour & colour)-->
-  <function name="wxBrush::SetColour">
+  <!-- void wxPGProperty::SetAttribute(const wxString & name, wxVariant value) -->
+  <!-- void wxBoolProperty::SetAttribute(const wxString & name, wxVariant value) -->
+  <!-- void wxFileProperty::SetAttribute(const wxString & name, wxVariant value) -->
+  <!-- void wxDirProperty::SetAttribute(const wxString & name, wxVariant value) -->
+  <function name="wxPGProperty::SetAttribute,wxBoolProperty::SetAttribute,wxFileProperty::SetAttribute,wxDirProperty::SetAttribute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxPGProperty::RefreshEditor() -->
+  <!-- void wxPGProperty::RefreshChildren() -->
+  <function name="wxPGProperty::RefreshEditor,wxPGProperty::RefreshChildren">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxPGProperty::SetAttributes(const wxPGAttributeStorage & attributes) -->
+  <function name="wxPGProperty::SetAttributes">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="void"/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- virtual void wxBrush::SetStyle (wxBrushStyle style)-->
-  <function name="wxBrush::SetStyle">
+  <!-- void wxFrame::SetStatusText( const wxString & text, int number = 0 ) -->
+  <function name="wxFrame::SetStatusText">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="void"/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="0">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- bool wxBitmap::LoadFile( const wxString & name, wxBitmapType type = wxBITMAP_DEFAULT_TYPE ) -->
-  <function name="wxBitmap::LoadFile">
+  <!-- bool wxString::StartsWith( const wxString & prefix, wxString * rest = NULL ) const -->
+  <!-- bool wxString::EndsWith( const wxString & suffix, wxString * rest = NULL ) const -->
+  <function name="wxString::StartsWith,wxString::EndsWith">
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
+    <const/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in" default="wxBITMAP_DEFAULT_TYPE">
-      <not-null/>
+    <arg nr="2" direction="in" default="NULL">
+      <not-uninit/>
     </arg>
   </function>
-  <!-- wxRect wxRect::CentreIn(const wxRect & r, int dir = wxBOTH) -->
-  <!-- wxRect wxRect::CenterIn(const wxRect & r, int dir = wxBOTH) -->
-  <function name="wxRect::CentreIn,wxRect::CenterIn">
+  <!-- wxPGProperty* wxStringProperty::AppendChild(wxPGProperty * childProperty) -->
+  <!-- wxPGProperty* wxPGProperty::AppendChild(wxPGProperty * childProperty) -->
+  <function name="wxPGProperty::AppendChild,wxStringProperty::AppendChild">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="wxRect"/>
-    <use-retval/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in" default="wxBOTH">
+    <returnValue type="wxPGProperty*"/>
+    <arg nr="1" direction="inout">
       <not-uninit/>
+      <not-null/>
     </arg>
   </function>
-  <!-- virtual void wxTextEntry::SetValue (const wxString & value)-->
-  <!-- virtual void wxTextCtrl::SetValue (const wxString & value)-->
-  <!-- virtual void wxComboBox::SetValue (const wxString & value)-->
-  <!-- virtual void wxStyledTextCtrl::SetValue (const wxString & value)-->
-  <function name="wxTextEntry::SetValue,wxTextCtrl::SetValue,wxComboBox::SetValue,wxStyledTextCtrl::SetValue">
+  <!-- void wxPropertyGridInterface::SetPropertyImage( wxPGPropArg id, wxBitmap & bmp ) -->
+  <!-- void wxPropertyGridManager::SetPropertyImage( wxPGPropArg id, wxBitmap & bmp ) -->
+  <function name="wxPropertyGridInterface::SetPropertyImage,wxPropertyGridManager::SetPropertyImage">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout"/>
   </function>
-  <!-- void wxLog::SetLogLevel( wxLogLevel logLevel ) -->
-  <!-- void wxLogGui::SetLogLevel( wxLogLevel logLevel ) -->
-  <function name="wxLog::SetLogLevel,wxLogGui::SetLogLevel">
+  <!-- bool wxPGProperty::SetValueFromString(const wxString & text, int flags = wxPG_PROGRAMMATIC_VALUE) -->
+  <!-- bool wxFloatProperty::SetValueFromString(const wxString & text, int flags = wxPG_PROGRAMMATIC_VALUE) -->
+  <!-- bool wxBoolProperty::SetValueFromString(const wxString & text, int flags = wxPG_PROGRAMMATIC_VALUE) -->
+  <!-- bool wxUIntProperty::SetValueFromString(const wxString & text, int flags = wxPG_PROGRAMMATIC_VALUE) -->
+  <!-- bool wxIntProperty::SetValueFromString(const wxString & text, int flags = wxPG_PROGRAMMATIC_VALUE) -->
+  <!-- bool wxEnumProperty::SetValueFromString(const wxString & text, int flags = wxPG_PROGRAMMATIC_VALUE) -->
+  <function name="wxPGProperty::SetValueFromString,wxFloatProperty::SetValueFromString,wxEnumProperty::SetValueFromString,wxBoolProperty::SetValueFromString,wxUIntProperty::SetValueFromString,wxIntProperty::SetValueFromString">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="wxPG_PROGRAMMATIC_VALUE">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- bool wxRect::Contains(const wxPoint & pt) const -->
-  <!-- bool wxRect::Contains(const wxRect & rect) const -->
-  <function name="wxRect::Contains">
+  <!-- void wxPGProperty::SetTextColour(const wxColour & colour, int flags = wxPG_RECURSE)-->
+  <!-- void wxFloatProperty::SetTextColour(const wxColour & colour, int flags = wxPG_RECURSE)-->
+  <!-- void wxUIntProperty::SetTextColour(const wxColour & colour, int flags = wxPG_RECURSE)-->
+  <function name="wxPGProperty::SetTextColour,wxFloatProperty::SetTextColour,wxUIntProperty::SetTextColour">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <const/>
-    <returnValue type="bool"/>
+    <returnValue type="void"/>
     <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="wxPG_RECURSE">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
-  <!-- bool wxListCtrl::SetColumnWidth( int col, int width ) -->
-  <!-- bool wxListView::SetColumnWidth( int col, int width ) -->
-  <function name="wxListCtrl::SetColumnWidth,wxListView::SetColumnWidth">
+  <!-- virtual bool wxBookCtrlBase::SetPageImage(size_t page, int image) -->
+  <!--         bool wxToolbook::SetPageImage(size_t page, int image) -->
+  <function name="wxBookCtrlBase::SetPageImage,wxToolbook::SetPageImage">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
     <leak-ignore/>
+    <returnValue type="bool"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
     </arg>
   </function>
-  <!-- wxLog * wxLog::SetActiveTarget( wxLog * logger ) -->
-  <!-- wxLog * wxLogGui::SetActiveTarget( wxLog * logger ) -->
-  <function name="wxLog::SetActiveTarget,wxLogGui::SetActiveTarget">
+  <!-- virtual bool wxBookCtrlBase::AddPage(wxWindow * page, const wxString & text, bool select = false, int imageId = NO_IMAGE) -->
+  <!--         bool wxToolbook::AddPage(wxWindow * page, const wxString & text, bool select = false, int imageId = NO_IMAGE) -->
+  <function name="wxBookCtrlBase::AddPage,wxToolbook::AddPage">
     <noreturn>false</noreturn>
-    <returnValue type="wxLog *"/>
     <leak-ignore/>
-    <arg nr="1" direction="inout"/>
-  </function>
-  <!-- bool wxIsSameDouble( double x, double y ) const -->
-  <function name="wxIsSameDouble">
-    <noreturn>false</noreturn>
     <returnValue type="bool"/>
-    <leak-ignore/>
-    <const/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-null/>
     </arg>
-    <arg nr="2" direction="in">
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in" default="false">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="in" default="NO_IMAGE">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- bool wxConfigBase::Write(const wxString &key, const wxString &value)-->
-  <!-- bool wxConfigBase::Write(const wxString &key, const long value)-->
-  <!-- bool wxConfigBase::Write(const wxString &key, const double value)-->
-  <!-- bool wxConfigBase::Write(const wxString &key, const bool value)-->
-  <function name="wxConfigBase::Write,wxConfig::Write,wxFileConfig::Write,wxRegConfig::Write">
+  <!-- virtual void wxFileDialog::SetFilterIndex(int filterIndex)-->
+  <function name="wxFileDialog::SetFilterIndex">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
     <leak-ignore/>
-    <use-retval/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in"/>
-  </function>
-  <!-- void wxGrid::SetCellFont( int row, int col, const wxFont &  ) -->
-  <function name="wxGrid::SetCellFont">
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <!-- Sets the default filter index, starting from zero. -->
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- virtual wxClassInfo * wxObject::GetClassInfo () const -->
+  <!-- and inherited classes -->
+  <function name="wxObject::GetClassInfo,wxAcceleratorTable::GetClassInfo,wxAccessible::GetClassInfo,wxAnimation::GetClassInfo,wxArchiveClassFactory::GetClassInfo,wxArchiveEntry::GetClassInfo,wxArtProvider::GetClassInfo,wxAutomationObject::GetClassInfo,wxBitmapHandler::GetClassInfo,wxClient::GetClassInfo,wxClipboard::GetClassInfo,wxColour::GetClassInfo,wxColourData::GetClassInfo,wxColourPropertyValue::GetClassInfo,wxCommand::GetClassInfo,wxCommandProcessor::GetClassInfo,wxConfigBase::GetClassInfo,wxConnection::GetClassInfo,wxConnectionBase::GetClassInfo,wxContextHelp::GetClassInfo,wxDataViewIconText::GetClassInfo,wxDataViewRenderer::GetClassInfo,wxDC::GetClassInfo,wxDDEClient::GetClassInfo,wxDocTemplate::GetClassInfo,wxDragImage::GetClassInfo,wxEncodingConverter::GetClassInfo,wxEvent::GetClassInfo,wxEvtHandler::GetClassInfo,wxFileHistory::GetClassInfo,wxFileSystem::GetClassInfo,wxFileSystemHandler::GetClassInfo,wxFilterClassFactory::GetClassInfo,wxFindReplaceData::GetClassInfo,wxFontData::GetClassInfo,wxFSFile::GetClassInfo,wxGDIObject::GetClassInfo,wxGLContext::GetClassInfo,wxGraphicsObject::GetClassInfo,wxGraphicsRenderer::GetClassInfo,wxGridTableBase::GetClassInfo,wxHashTable::GetClassInfo,wxHelpControllerBase::GetClassInfo,wxHtmlCell::GetClassInfo,wxHtmlDCRenderer::GetClassInfo,wxHtmlEasyPrinting::GetClassInfo,wxHtmlFilter::GetClassInfo,wxHtmlHelpData::GetClassInfo,wxHtmlLinkInfo::GetClassInfo,wxHtmlTagHandler::GetClassInfo,wxImage::GetClassInfo,wxImageHandler::GetClassInfo,wxImageList::GetClassInfo,wxIndividualLayoutConstraint::GetClassInfo,wxJoystick::GetClassInfo,wxLayoutAlgorithm::GetClassInfo,wxLayoutConstraints::GetClassInfo,wxListItem::GetClassInfo,wxMask::GetClassInfo,wxMenuItem::GetClassInfo,wxMetafile::GetClassInfo,wxModule::GetClassInfo,wxPageSetupDialog::GetClassInfo,wxPageSetupDialogData::GetClassInfo,wxPGCell::GetClassInfo,wxPGEditor::GetClassInfo,wxPGEditorDialogAdapter::GetClassInfo,wxPGProperty::GetClassInfo,wxPrintData::GetClassInfo,wxPrintDialog::GetClassInfo,wxPrintDialogData::GetClassInfo,wxPrinter::GetClassInfo,wxPrintout::GetClassInfo,wxPrintPreview::GetClassInfo,wxQuantize::GetClassInfo,wxRegionIterator::GetClassInfo,wxRichTextAction::GetClassInfo,wxRichTextDrawingContext::GetClassInfo,wxRichTextDrawingHandler::GetClassInfo,wxRichTextFieldType::GetClassInfo,wxRichTextFileHandler::GetClassInfo,wxRichTextFontTable::GetClassInfo,wxRichTextFormattingDialogFactory::GetClassInfo,wxRichTextHeaderFooterData::GetClassInfo,wxRichTextImageBlock::GetClassInfo,wxRichTextObject::GetClassInfo,wxRichTextPrinting::GetClassInfo,wxRichTextProperties::GetClassInfo,wxRichTextRenderer::GetClassInfo,wxRichTextStyleDefinition::GetClassInfo,wxRichTextStyleSheet::GetClassInfo,wxSizer::GetClassInfo,wxSizerItem::GetClassInfo,wxSockAddress::GetClassInfo,wxSocketBase::GetClassInfo,wxSound::GetClassInfo,wxStringTokenizer::GetClassInfo,wxSystemOptions::GetClassInfo,wxTCPClient::GetClassInfo,wxTCPConnection::GetClassInfo,wxTCPServer::GetClassInfo,wxToolBarToolBase::GetClassInfo,wxToolTip::GetClassInfo,wxURI::GetClassInfo,wxVariant::GetClassInfo,wxWebViewFactory::GetClassInfo,wxXmlDocument::GetClassInfo,wxXmlResource::GetClassInfo,wxXmlResourceHandler::GetClassInfo">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <const/>
+    <returnValue type="wxClassInfo *"/>
+    <use-retval/>
+  </function>
+  <!-- void wxFilePickerCtrl::SetPath(const wxString & filename) -->
+  <function name="wxFilePickerCtrl::SetPath">
+    <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxEvent::SetEventType(wxEventType type) -->
+  <!-- void wxCommandEvent::SetEventType(wxEventType type) -->
+  <function name="wxEvent::SetEventType,wxCommandEvent::SetEventType">
     <noreturn>false</noreturn>
+    <leak-ignore/>
     <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="3" direction="in"/>
   </function>
-  <!-- void wxSlider::SetMax( int maxValue ) -->
-  <!-- void wxSlider::SetMin( int minValue ) -->
-  <function name="wxSlider::SetMax,wxSlider::SetMin">
+  <!-- void wxColour::Set(unsigned char red, unsigned char green, unsigned char blue, unsigned char alpha=wxALPHA_OPAQUE) -->
+  <!-- void wxColour::Set(unsigned long RGB)-->
+  <!-- void wxColour::Set(const wxString &str)-->
+  <function name="wxColour::Set">
+    <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="any" direction="in"/>
+  </function>
+  <!-- void wxEvent::SetEventObject(wxObject *object) -->
+  <!-- void wxCommandEvent::SetEventObject(wxObject *object) -->
+  <!-- void wxNavigationKeyEvent::SetEventObject(wxObject *object) -->
+  <function name="wxEvent::SetEventObject,wxCommandEvent::SetEventObject,wxNavigationKeyEvent::SetEventObject">
     <noreturn>false</noreturn>
+    <leak-ignore/>
     <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-null/>
     </arg>
   </function>
-  <!-- virtual void wxTextEntry::SetInsertionPoint(long pos) -->
-  <!-- virtual void wxTextCtrl::SetInsertionPoint(long pos) -->
-  <function name="wxTextEntry::SetInsertionPoint,wxTextCtrl::SetInsertionPoint">
-    <leak-ignore/>
+  <!-- void wxNavigationKeyEvent::SetCurrentFocus(wxWindow * currentFocus) -->
+  <function name="wxNavigationKeyEvent::SetCurrentFocus">
     <noreturn>false</noreturn>
+    <leak-ignore/>
     <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-null/>
     </arg>
   </function>
-  <!--bool Read(const wxString &key, wxString *str) const -->
-  <!--bool Read(const wxString &key, double *d) const -->
-  <!--bool Read(const wxString &key, float *f) const -->
-  <!--bool Read(const wxString &key, bool *b) const -->
-  <!--bool Read(const wxString &key, wxMemoryBuffer *buf) const -->
-  <function name="wxConfigBase::Read,wxConfig::Read,wxFileConfig::Read,wxRegConfig::Read">
+  <!-- void wxCommandEvent::SetString(const wxString &sr) -->
+  <!-- void wxGridEvent::SetString(const wxString &sr) -->
+  <function name="wxCommandEvent::SetString,wxGridEvent::SetString">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxXmlNode::GetAttribute (const wxString & attrName, wxString * value) const -->
+  <!-- bool wxXmlNode::GetPropVal (const wxString & attrName, wxString * value) const -->
+  <function name="wxXmlNode::GetAttribute,wxXmlNode::GetPropVal">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
     <leak-ignore/>
-    <use-retval/>
     <const/>
+    <returnValue type="bool"/>
+    <use-retval/>
     <arg nr="1" direction="in"/>
-    <arg nr="2" direction="inout">
+    <arg nr="2" direction="out">
       <not-null/>
     </arg>
   </function>
-  <!-- void wxControl::SetLabelText(const wxString & text)
-     and derived classes -->
-  <function name="wxControl::SetLabelText,wxToggleButton::SetLabelText,wxButton::SetLabelText,wxActiveXContainer::SetLabelText,wxActivityIndicator::SetLabelText,wxAnimationCtrl::SetLabelText,wxAnyButton::SetLabelText,wxAuiToolBar::SetLabelText,wxBookCtrlBase::SetLabelText,wxCalendarCtrl::SetLabelText,wxCheckBox::SetLabelText,wxChoice::SetLabelText,wxCollapsibleHeaderCtrl::SetLabelText,wxCollapsiblePane::SetLabelText,wxComboBox::SetLabelText,wxComboCtrl::SetLabelText,wxControlWithItems::SetLabelText,wxDataViewCtrl::SetLabelText,wxDatePickerCtrl::SetLabelText,wxFileCtrl::SetLabelText,wxGauge::SetLabelText,wxGenericDirCtrl::SetLabelText,wxHeaderCtrl::SetLabelText,wxHyperlinkCtrl::SetLabelText,wxInfoBar::SetLabelText,wxListBox::SetLabelText,wxListCtrl::SetLabelText,wxMediaCtrl::SetLabelText,wxPickerBase::SetLabelText,wxPropertyGrid::SetLabelText,wxRadioBox::SetLabelText,wxRadioButton::SetLabelText,wxRibbonControl::SetLabelText,wxRichTextCtrl::SetLabelText,wxRichTextStyleListCtrl::SetLabelText,wxScrollBar::SetLabelText,wxSlider::SetLabelText,wxSpinButton::SetLabelText,wxSpinCtrl::SetLabelText,wxSpinCtrlDouble::SetLabelText,wxStaticBitmap::SetLabelText,wxStaticBox::SetLabelText,wxStaticLine::SetLabelText,wxStaticText::SetLabelText,wxStatusBar::SetLabelText,wxStyledTextCtrl::SetLabelText,wxTextCtrl::SetLabelText,wxTimePickerCtrl::SetLabelText,wxToolBar::SetLabelText,wxTreeCtrl::SetLabelText,wxWebKitCtrl::SetLabelText,wxWebView::SetLabelText">
+  <!-- wxString wxXmlNode::GetAttribute(const wxString & attrName, const wxString & defaultVal = wxEmptyString) const -->
+  <!-- wxString wxXmlNode::GetPropVal(const wxString & attrName, const wxString & defaultVal = wxEmptyString) const -->
+  <function name="wxXmlNode::GetAttribute,wxXmlNode::GetPropVal">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <const/>
+    <returnValue type="wxString"/>
+    <use-retval/>
     <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="wxEmptyString"/>
   </function>
-  <!-- void wxAboutDialogInfo::AddArtist (const wxString &artist)-->
-  <!-- void wxAboutDialogInfo::AddDeveloper (const wxString &developer)-->
-  <!-- void wxAboutDialogInfo::AddDocWriter (const wxString &docwriter)-->
-  <!-- void wxAboutDialogInfo::AddTranslator (const wxString &translator)-->
-  <!-- void wxAboutDialogInfo::SetArtists (const wxArrayString &artists)-->
-  <!-- void wxAboutDialogInfo::SetCopyright (const wxString &copyright)-->
-  <!-- void wxAboutDialogInfo::SetDescription (const wxString &description)-->
-  <!-- void wxAboutDialogInfo::SetName (const wxString &name)-->
-  <!-- void wxAboutDialogInfo::SetLicence (const wxString &l)-->
-  <!-- void wxAboutDialogInfo::SetLicense (const wxString &l)-->
-  <!-- void wxAboutDialogInfo::SetDevelopers (const wxArrayString &devs)-->
-  <!-- void wxAboutDialogInfo::SetDocWriters (const wxArrayString &docwriters)-->
-  <!-- void wxAboutDialogInfo::SetTranslators (const wxArrayString &translators)-->
-  <function name="wxAboutDialogInfo::AddArtist,wxAboutDialogInfo::AddDeveloper,wxAboutDialogInfo::SetTranslators,wxAboutDialogInfo::SetLicence,wxAboutDialogInfo::SetLicense,wxAboutDialogInfo::SetName,wxAboutDialogInfo::AddDocWriter,wxAboutDialogInfo::SetDevelopers,wxAboutDialogInfo::SetDocWriters,wxAboutDialogInfo::SetDescription,wxAboutDialogInfo::AddTranslator,wxAboutDialogInfo::SetArtists,wxAboutDialogInfo::SetCopyright">
+  <!-- virtual void wxXmlNode::AddAttribute( const wxString & name, const wxString & value ) -->
+  <function name="wxXmlNode::AddAttribute">
     <noreturn>false</noreturn>
-    <leak-ignore/>
+    <returnValue type="void"/>
     <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
   </function>
-  <!-- void wxAboutDialogInfo::SetVersion (const wxString &version, const wxString &longVersion=wxString())-->
-  <function name="wxAboutDialogInfo::SetVersion">
+  <!-- virtual void wxXmlNode::AddAttribute(wxXmlAttribute * attr ) -->
+  <!-- virtual void wxXmlNode::AddChild(wxXmlNode * child) -->
+  <function name="wxXmlNode::AddAttribute,wxXmlNode::AddChild">
     <noreturn>false</noreturn>
-    <leak-ignore/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in" default=""/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-null/>
+    </arg>
   </function>
-  <!-- void wxAboutDialogInfo::SetIcon (const wxIcon &)-->
-  <function name="wxAboutDialogInfo::SetIcon">
+  <!-- wxXmlAttribute * wxXmlNode::GetAttributes( void ) const -->
+  <function name="wxXmlNode::GetAttributes">
+    <noreturn>false</noreturn>
+    <returnValue type="wxXmlAttribute *"/>
+    <const/>
+    <use-retval/>
+  </function>
+  <!-- wxXmlNode * wxXmlNode::GetChildren( void ) const-->
+  <function name="wxXmlNode::GetChildren">
+    <noreturn>false</noreturn>
+    <const/>
+    <returnValue type="wxXmlNode *"/>
+    <use-retval/>
+  </function>
+  <!-- const wxString & wxXmlNode::GetContent( void ) const -->
+  <function name="wxXmlNode::GetContent">
+    <noreturn>false</noreturn>
+    <const/>
+    <returnValue type="const wxString &amp;"/>
+    <use-retval/>
+  </function>
+  <!-- int wxXmlNode::GetDepth( wxXmlNode * grandparent = NULL ) const -->
+  <function name="wxXmlNode::GetDepth">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <const/>
+    <arg nr="1" default="NULL" direction="inout"/>
+  </function>
+  <!-- int wxXmlNode::GetLineNumber( void ) const -->
+  <function name="wxXmlNode::GetLineNumber">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <const/>
+    <use-retval/>
+  </function>
+  <!-- virtual wxString wxColour::GetAsString(long flags = wxC2S_NAME|wxC2S_CSS_SYNTAX) const -->
+  <function name="wxColour::GetAsString">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <const/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <arg nr="1" direction="in" default="wxC2S_NAME|wxC2S_CSS_SYNTAX">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxGauge::SetValue(int pos)-->
-  <!-- void wxGauge::SetRange(int range)-->
-  <!-- void wxGauge::SetShadowWidth(int width)-->
-  <!-- void wxRadioButton::SetValue(bool value)-->
-  <function name="wxGauge::SetValue,wxGauge::SetRange,wxGauge::SetShadowWidth,wxRadioButton::SetValue">
+  <!-- void wxFlexGridSizer::SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode) -->
+  <function name="wxFlexGridSizer::SetNonFlexibleGrowMode">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!-- wxSize wxWindow::GetTextExtent(const wxString & string) const-->
-  <!-- wxSize wxTextCtrl::GetTextExtent(const wxString & string) const-->
-  <!-- wxSize wxStaticText::GetTextExtent(const wxString & string) const-->
-  <function name="wxWindow::GetTextExtent,wxTextCtrl::GetTextExtent,wxStaticText::GetTextExtent">
+  <!-- They are implemented as macros in wxWidgets, but its better to configure them as functions -->
+  <!-- const wxClassInfo * wxCLASSINFO(info) -->
+  <!-- const wxClassInfo *   CLASSINFO(info) -->
+  <function name="wxCLASSINFO,CLASSINFO">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <const/>
-    <returnValue type="wxSize"/>
+    <returnValue type="const wxClassInfo *"/>
+    <use-retval/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- virtual void wxSlider::SetRange(int minValue, int maxValue) -->
-  <function name="wxSlider::SetRange">
+  <!-- wxObjectRefData * wxObject::GetRefData () const -->
+  <!-- and inherited classes -->
+  <function name="wxObject::GetRefData,wxAcceleratorTable::GetRefData,wxAccessible::GetRefData,wxAnimation::GetRefData,wxArchiveClassFactory::GetRefData,wxArchiveEntry::GetRefData,wxArtProvider::GetRefData,wxAutomationObject::GetRefData,wxBitmapHandler::GetRefData,wxClient::GetRefData,wxClipboard::GetRefData,wxColour::GetRefData,wxColourData::GetRefData,wxColourPropertyValue::GetRefData,wxCommand::GetRefData,wxCommandProcessor::GetRefData,wxConfigBase::GetRefData,wxConnection::GetRefData,wxConnectionBase::GetRefData,wxContextHelp::GetRefData,wxDataViewIconText::GetRefData,wxDataViewRenderer::GetRefData,wxDC::GetRefData,wxDDEClient::GetRefData,wxDocTemplate::GetRefData,wxDragImage::GetRefData,wxEncodingConverter::GetRefData,wxEvent::GetRefData,wxEvtHandler::GetRefData,wxFileHistory::GetRefData,wxFileSystem::GetRefData,wxFileSystemHandler::GetRefData,wxFilterClassFactory::GetRefData,wxFindReplaceData::GetRefData,wxFontData::GetRefData,wxFSFile::GetRefData,wxGDIObject::GetRefData,wxGLContext::GetRefData,wxGraphicsObject::GetRefData,wxGraphicsRenderer::GetRefData,wxGridTableBase::GetRefData,wxHashTable::GetRefData,wxHelpControllerBase::GetRefData,wxHtmlCell::GetRefData,wxHtmlDCRenderer::GetRefData,wxHtmlEasyPrinting::GetRefData,wxHtmlFilter::GetRefData,wxHtmlHelpData::GetRefData,wxHtmlLinkInfo::GetRefData,wxHtmlTagHandler::GetRefData,wxImage::GetRefData,wxImageHandler::GetRefData,wxImageList::GetRefData,wxIndividualLayoutConstraint::GetRefData,wxJoystick::GetRefData,wxLayoutAlgorithm::GetRefData,wxLayoutConstraints::GetRefData,wxListItem::GetRefData,wxMask::GetRefData,wxMenuItem::GetRefData,wxMetafile::GetRefData,wxModule::GetRefData,wxPageSetupDialog::GetRefData,wxPageSetupDialogData::GetRefData,wxPGCell::GetRefData,wxPGEditor::GetRefData,wxPGEditorDialogAdapter::GetRefData,wxPGProperty::GetRefData,wxPrintData::GetRefData,wxPrintDialog::GetRefData,wxPrintDialogData::GetRefData,wxPrinter::GetRefData,wxPrintout::GetRefData,wxPrintPreview::GetRefData,wxQuantize::GetRefData,wxRegionIterator::GetRefData,wxRichTextAction::GetRefData,wxRichTextDrawingContext::GetRefData,wxRichTextDrawingHandler::GetRefData,wxRichTextFieldType::GetRefData,wxRichTextFileHandler::GetRefData,wxRichTextFontTable::GetRefData,wxRichTextFormattingDialogFactory::GetRefData,wxRichTextHeaderFooterData::GetRefData,wxRichTextImageBlock::GetRefData,wxRichTextObject::GetRefData,wxRichTextPrinting::GetRefData,wxRichTextProperties::GetRefData,wxRichTextRenderer::GetRefData,wxRichTextStyleDefinition::GetRefData,wxRichTextStyleSheet::GetRefData,wxSizer::GetRefData,wxSizerItem::GetRefData,wxSockAddress::GetRefData,wxSocketBase::GetRefData,wxSound::GetRefData,wxStringTokenizer::GetRefData,wxSystemOptions::GetRefData,wxTCPClient::GetRefData,wxTCPConnection::GetRefData,wxTCPServer::GetRefData,wxToolBarToolBase::GetRefData,wxToolTip::GetRefData,wxURI::GetRefData,wxVariant::GetRefData,wxWebViewFactory::GetRefData,wxXmlDocument::GetRefData,wxXmlResource::GetRefData,wxXmlResourceHandler::GetRefData">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
-    </arg>
+    <const/>
+    <returnValue type="wxObjectRefData *"/>
+    <use-retval/>
   </function>
-  <!-- bool wxFile::ReadAll(wxString * str, const wxMBConv & conv = wxConvAuto())	-->
-  <function name="wxFile::ReadAll">
+  <!-- bool IsKindOf (const wxClassInfo *info) const -->
+  <!-- and inherited classes -->
+  <function name="wxObject::IsKindOf,wxAcceleratorTable::IsKindOf,wxAccessible::IsKindOf,wxAnimation::IsKindOf,wxArchiveClassFactory::IsKindOf,wxArchiveEntry::IsKindOf,wxArtProvider::IsKindOf,wxAutomationObject::IsKindOf,wxBitmapHandler::IsKindOf,wxClient::IsKindOf,wxClipboard::IsKindOf,wxColour::IsKindOf,wxColourData::IsKindOf,wxColourPropertyValue::IsKindOf,wxCommand::IsKindOf,wxCommandProcessor::IsKindOf,wxConfigBase::IsKindOf,wxConnection::IsKindOf,wxConnectionBase::IsKindOf,wxContextHelp::IsKindOf,wxDataViewIconText::IsKindOf,wxDataViewRenderer::IsKindOf,wxDC::IsKindOf,wxDDEClient::IsKindOf,wxDocTemplate::IsKindOf,wxDragImage::IsKindOf,wxEncodingConverter::IsKindOf,wxEvent::IsKindOf,wxEvtHandler::IsKindOf,wxFileHistory::IsKindOf,wxFileSystem::IsKindOf,wxFileSystemHandler::IsKindOf,wxFilterClassFactory::IsKindOf,wxFindReplaceData::IsKindOf,wxFontData::IsKindOf,wxFSFile::IsKindOf,wxGDIObject::IsKindOf,wxGLContext::IsKindOf,wxGraphicsObject::IsKindOf,wxGraphicsRenderer::IsKindOf,wxGridTableBase::IsKindOf,wxHashTable::IsKindOf,wxHelpControllerBase::IsKindOf,wxHtmlCell::IsKindOf,wxHtmlDCRenderer::IsKindOf,wxHtmlEasyPrinting::IsKindOf,wxHtmlFilter::IsKindOf,wxHtmlHelpData::IsKindOf,wxHtmlLinkInfo::IsKindOf,wxHtmlTagHandler::IsKindOf,wxImage::IsKindOf,wxImageHandler::IsKindOf,wxImageList::IsKindOf,wxIndividualLayoutConstraint::IsKindOf,wxJoystick::IsKindOf,wxLayoutAlgorithm::IsKindOf,wxLayoutConstraints::IsKindOf,wxListItem::IsKindOf,wxMask::IsKindOf,wxMenuItem::IsKindOf,wxMetafile::IsKindOf,wxModule::IsKindOf,wxPageSetupDialog::IsKindOf,wxPageSetupDialogData::IsKindOf,wxPGCell::IsKindOf,wxPGEditor::IsKindOf,wxPGEditorDialogAdapter::IsKindOf,wxPGProperty::IsKindOf,wxPrintData::IsKindOf,wxPrintDialog::IsKindOf,wxPrintDialogData::IsKindOf,wxPrinter::IsKindOf,wxPrintout::IsKindOf,wxPrintPreview::IsKindOf,wxQuantize::IsKindOf,wxRegionIterator::IsKindOf,wxRichTextAction::IsKindOf,wxRichTextDrawingContext::IsKindOf,wxRichTextDrawingHandler::IsKindOf,wxRichTextFieldType::IsKindOf,wxRichTextFileHandler::IsKindOf,wxRichTextFontTable::IsKindOf,wxRichTextFormattingDialogFactory::IsKindOf,wxRichTextHeaderFooterData::IsKindOf,wxRichTextImageBlock::IsKindOf,wxRichTextObject::IsKindOf,wxRichTextPrinting::IsKindOf,wxRichTextProperties::IsKindOf,wxRichTextRenderer::IsKindOf,wxRichTextStyleDefinition::IsKindOf,wxRichTextStyleSheet::IsKindOf,wxSizer::IsKindOf,wxSizerItem::IsKindOf,wxSockAddress::IsKindOf,wxSocketBase::IsKindOf,wxSound::IsKindOf,wxStringTokenizer::IsKindOf,wxSystemOptions::IsKindOf,wxTCPClient::IsKindOf,wxTCPConnection::IsKindOf,wxTCPServer::IsKindOf,wxToolBarToolBase::IsKindOf,wxToolTip::IsKindOf,wxURI::IsKindOf,wxVariant::IsKindOf,wxWebViewFactory::IsKindOf,wxXmlDocument::IsKindOf,wxXmlResource::IsKindOf,wxXmlResourceHandler::IsKindOf">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <use-retval/>
+    <const/>
     <returnValue type="bool"/>
-    <arg nr="1" direction="out">
-      <not-uninit/>
+    <arg nr="1" direction="in">
       <not-null/>
     </arg>
-    <arg nr="2" direction="in" default="wxConvAuto()">
+  </function>
+  <!-- bool IsSameAs (const wxObject &obj) const -->
+  <function name="wxObject::IsSameAs,wxAcceleratorTable::IsSameAs,wxBitmap::IsSameAs,wxAccessible::IsSameAs,wxAnimation::IsSameAs,wxArchiveClassFactory::IsSameAs,wxArchiveEntry::IsSameAs,wxArtProvider::IsSameAs,wxAutomationObject::IsSameAs,wxBitmapHandler::IsSameAs,wxClient::IsSameAs,wxClipboard::IsSameAs,wxColour::IsSameAs,wxColourData::IsSameAs,wxColourPropertyValue::IsSameAs,wxCommand::IsSameAs,wxCommandProcessor::IsSameAs,wxConfigBase::IsSameAs,wxConnection::IsSameAs,wxConnectionBase::IsSameAs,wxContextHelp::IsSameAs,wxDataViewIconText::IsSameAs,wxDataViewRenderer::IsSameAs,wxDC::IsSameAs,wxDDEClient::IsSameAs,wxDocTemplate::IsSameAs,wxDragImage::IsSameAs,wxEncodingConverter::IsSameAs,wxEvent::IsSameAs,wxEvtHandler::IsSameAs,wxFileHistory::IsSameAs,wxFileSystem::IsSameAs,wxFileSystemHandler::IsSameAs,wxFilterClassFactory::IsSameAs,wxFindReplaceData::IsSameAs,wxFontData::IsSameAs,wxFSFile::IsSameAs,wxGDIObject::IsSameAs,wxGLContext::IsSameAs,wxGraphicsObject::IsSameAs,wxGraphicsRenderer::IsSameAs,wxGridTableBase::IsSameAs,wxHashTable::IsSameAs,wxHelpControllerBase::IsSameAs,wxHtmlCell::IsSameAs,wxHtmlDCRenderer::IsSameAs,wxHtmlEasyPrinting::IsSameAs,wxHtmlFilter::IsSameAs,wxHtmlHelpData::IsSameAs,wxHtmlLinkInfo::IsSameAs,wxHtmlTagHandler::IsSameAs,wxImage::IsSameAs,wxImageHandler::IsSameAs,wxImageList::IsSameAs,wxIndividualLayoutConstraint::IsSameAs,wxJoystick::IsSameAs,wxLayoutAlgorithm::IsSameAs,wxLayoutConstraints::IsSameAs,wxListItem::IsSameAs,wxMask::IsSameAs,wxMenuItem::IsSameAs,wxMetafile::IsSameAs,wxModule::IsSameAs,wxPageSetupDialog::IsSameAs,wxPageSetupDialogData::IsSameAs,wxPGCell::IsSameAs,wxPGEditor::IsSameAs,wxPGEditorDialogAdapter::IsSameAs,wxPGProperty::IsSameAs,wxPrintData::IsSameAs,wxPrintDialog::IsSameAs,wxPrintDialogData::IsSameAs,wxPrinter::IsSameAs,wxPrintout::IsSameAs,wxPrintPreview::IsSameAs,wxQuantize::IsSameAs,wxRegionIterator::IsSameAs,wxRichTextAction::IsSameAs,wxRichTextDrawingContext::IsSameAs,wxRichTextDrawingHandler::IsSameAs,wxRichTextFieldType::IsSameAs,wxRichTextFileHandler::IsSameAs,wxRichTextFontTable::IsSameAs,wxRichTextFormattingDialogFactory::IsSameAs,wxRichTextHeaderFooterData::IsSameAs,wxRichTextImageBlock::IsSameAs,wxRichTextObject::IsSameAs,wxRichTextPrinting::IsSameAs,wxRichTextProperties::IsSameAs,wxRichTextRenderer::IsSameAs,wxRichTextStyleDefinition::IsSameAs,wxRichTextStyleSheet::IsSameAs,wxSizer::IsSameAs,wxSizerItem::IsSameAs,wxSockAddress::IsSameAs,wxSocketBase::IsSameAs,wxSound::IsSameAs,wxStringTokenizer::IsSameAs,wxSystemOptions::IsSameAs,wxTCPClient::IsSameAs,wxTCPConnection::IsSameAs,wxTCPServer::IsSameAs,wxToolBarToolBase::IsSameAs,wxToolTip::IsSameAs,wxURI::IsSameAs,wxVariant::IsSameAs,wxWebViewFactory::IsSameAs,wxXmlDocument::IsSameAs,wxXmlResource::IsSameAs,wxXmlResourceHandler::IsSameAs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxString::IsSameAs(const wxString & s, bool caseSensitive = true) const -->
+  <!-- bool wxString::IsSameAs(const wxUniChar ch, bool caseSensitive = true) const -->
+  <function name="wxString::IsSameAs">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="true">
       <not-uninit/>
-      <valid>0:</valid>
     </arg>
   </function>
-  <!-- size_t wxFile::Write(const void * buffer, size_t count)-->
-  <function name="wxFile::Write">
+  <!-- void wxToolBar::ToggleTool( int toolid, bool toggle ) -->
+  <function name="wxToolBar::ToggleTool">
     <noreturn>false</noreturn>
-    <leak-ignore/>
-    <returnValue type="size_t"/>
+    <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
-      <not-null/>
-      <minsize type="argvalue" arg="2"/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
-      <valid>0:</valid>
     </arg>
   </function>
-  <!-- virtual void wxTextCtrl::SetMaxLength(unsigned long len)-->
-  <function name="wxTextEntry::SetMaxLength,wxTextCtrl::SetMaxLength">
+  <!-- wxMenuItem* wxMenu::AppendCheckItem(int id, const wxString & item, const wxString &  help = wxEmptyString)-->
+  <!-- wxMenuItem* wxMenu::AppendRadioItem(int id, const wxString & item, const wxString &  help = wxEmptyString)-->
+  <function name="wxMenu::AppendCheckItem,wxMenu::AppendRadioItem">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="wxMenuItem*"/>
     <arg nr="1" direction="in">
       <not-uninit/>
-      <valid>0:</valid>
+      <not-bool/>
     </arg>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in" default="wxEmptyString"/>
   </function>
-  <!-- void wxTextAttr::SetTextColour(const wxColour & colText) -->
-  <!-- void wxTextAttr::SetBackgroundColor(const wxColour & colBack) -->
-  <function name="wxTextAttr::SetTextColour,wxTextAttr::SetBackgroundColor">
+  <!-- virtual int wxMenu::FindItem(const wxString & itemString) const-->
+  <!-- wxMenuItem* wxMenu::FindItem(int id, wxMenu ** menu = NULL ) const -->
+  <function name="wxMenu::FindItem">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <const/>
     <leak-ignore/>
+    <use-retval/>
     <arg nr="1" direction="in"/>
+    <arg nr="2" direction="out" default="NULL"/>
   </function>
-  <!-- void wxTextCtrl::SetModified( void ) -->
-  <function name="wxTextCtrl::SetModified">
+  <!-- void Ref(const wxObject &clone) -->
+  <function name="wxObject::Ref,wxAcceleratorTable::Ref,wxAccessible::Ref,wxAnimation::Ref,wxArchiveClassFactory::Ref,wxArchiveEntry::Ref,wxArtProvider::Ref,wxAutomationObject::Ref,wxBitmapHandler::Ref,wxClient::Ref,wxClipboard::Ref,wxColour::Ref,wxColourData::Ref,wxColourPropertyValue::Ref,wxCommand::Ref,wxCommandProcessor::Ref,wxConfigBase::Ref,wxConnection::Ref,wxConnectionBase::Ref,wxContextHelp::Ref,wxDataViewIconText::Ref,wxDataViewRenderer::Ref,wxDC::Ref,wxDDEClient::Ref,wxDocTemplate::Ref,wxDragImage::Ref,wxEncodingConverter::Ref,wxEvent::Ref,wxEvtHandler::Ref,wxFileHistory::Ref,wxFileSystem::Ref,wxFileSystemHandler::Ref,wxFilterClassFactory::Ref,wxFindReplaceData::Ref,wxFontData::Ref,wxFSFile::Ref,wxGDIObject::Ref,wxGLContext::Ref,wxGraphicsObject::Ref,wxGraphicsRenderer::Ref,wxGridTableBase::Ref,wxHashTable::Ref,wxHelpControllerBase::Ref,wxHtmlCell::Ref,wxHtmlDCRenderer::Ref,wxHtmlEasyPrinting::Ref,wxHtmlFilter::Ref,wxHtmlHelpData::Ref,wxHtmlLinkInfo::Ref,wxHtmlTagHandler::Ref,wxImage::Ref,wxImageHandler::Ref,wxImageList::Ref,wxIndividualLayoutConstraint::Ref,wxJoystick::Ref,wxLayoutAlgorithm::Ref,wxLayoutConstraints::Ref,wxListItem::Ref,wxMask::Ref,wxMenuItem::Ref,wxMetafile::Ref,wxModule::Ref,wxPageSetupDialog::Ref,wxPageSetupDialogData::Ref,wxPGCell::Ref,wxPGEditor::Ref,wxPGEditorDialogAdapter::Ref,wxPGProperty::Ref,wxPrintData::Ref,wxPrintDialog::Ref,wxPrintDialogData::Ref,wxPrinter::Ref,wxPrintout::Ref,wxPrintPreview::Ref,wxQuantize::Ref,wxRegionIterator::Ref,wxRichTextAction::Ref,wxRichTextDrawingContext::Ref,wxRichTextDrawingHandler::Ref,wxRichTextFieldType::Ref,wxRichTextFileHandler::Ref,wxRichTextFontTable::Ref,wxRichTextFormattingDialogFactory::Ref,wxRichTextHeaderFooterData::Ref,wxRichTextImageBlock::Ref,wxRichTextObject::Ref,wxRichTextPrinting::Ref,wxRichTextProperties::Ref,wxRichTextRenderer::Ref,wxRichTextStyleDefinition::Ref,wxRichTextStyleSheet::Ref,wxSizer::Ref,wxSizerItem::Ref,wxSockAddress::Ref,wxSocketBase::Ref,wxSound::Ref,wxStringTokenizer::Ref,wxSystemOptions::Ref,wxTCPClient::Ref,wxTCPConnection::Ref,wxTCPServer::Ref,wxToolBarToolBase::Ref,wxToolTip::Ref,wxURI::Ref,wxVariant::Ref,wxWebViewFactory::Ref,wxXmlDocument::Ref,wxXmlResource::Ref,wxXmlResourceHandler::Ref">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
     <leak-ignore/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!-- wxTextAttr::SetTextColour-->
-  <!-- void wxTextCtrl::SetEditable( bool edit) -->
-  <function name="wxTextEntry::SetEditable,wxTextCtrl::SetEditable">
+  <!-- https://docs.wxwidgets.org/3.1/classwx_window.html -->
+  <!-- bool wxWindow::Close (bool force = false) -->
+  <function name="wxWindow::Close,wxBannerWindow::Close,wxControl::Close,wxGLCanvas::Close,wxHtmlHelpWindow::Close,wxMDIClientWindow::Close,wxMenuBar::Close,wxNativeWindow::Close,wxNonOwnedWindow::Close,wxPanel::Close,wxPGMultiButton::Close,wxSashWindow::Close,wxSplitterWindow::Close,wxTipWindow::Close,wxTreeListCtrl::Close,wxActiveXContainer::Close,wxActivityIndicator::Close,wxAnimationCtrl::Close,wxAnyButton::Close,wxAuiToolBar::Close,wxBookCtrlBase::Close,wxCalenderCtrl::Close,wxCheckBox::Close,wxChoice::Close,wxCollapsibleHeaderCtrl::Close,wxCollapsiblePane::Close,wxComboBox::Close,wxComboCtrl::Close,wxControlWithItems::Close,wxDataViewCtrl::Close,wxDatePickerCtrl::Close,wxFileCtrl::Close,wxGauge::Close,wxGenericDirCtrl::Close,wxHeaderCtrl::Close,wxHyperlinkCtrl::Close,wxInfoBar::Close,wxListBox::Close,wxListCtrl::Close,wxMediaCtrl::Close,wxPickerBase::Close,wxPropertyGrid::Close,wxRadioBox::Close,wxRadioButton::Close,wxRibbonControl::Close,wxRichTextCtrl::Close">
+    <noreturn>true</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in" default="false">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxStaticText::Wrap (int width ) -->
+  <function name="wxStaticText::Wrap">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
     <leak-ignore/>
+    <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxArrayString::Clear()-->
-  <!-- void wxArrayString::Empty()-->
-  <function name="wxArrayString::Clear,wxArrayString::Empty">
+  <!-- virtual void wxDialog::EndModal(int retCode) -->
+  <function name="wxDialog::EndModal">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
-  <!-- void wxArrayString::push_back(const wxString &s)-->
-  <function name="wxArrayString::push_back">
+  <!-- wxToolBarToolBase * wxToolBarBase::AddTool( wxToolBarToolBase * tool ) -->
+  <function name="wxToolBarBase::AddTool">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="wxToolBarToolBase *"/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- size_t wxArrayString::Add(const wxString & str, size_t copies = 1) -->
-  <function name="wxArrayString::Add">
+  <!-- void wxListBox::SetString( unsigned int n, const wxString & s ) -->
+  <function name="wxListBox::SetString">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="size_t"/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in" default="1">
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>0:</valid>
     </arg>
+    <arg nr="2" direction="in"/>
   </function>
-  <!--void wxArrayString::Sort(bool reverseOrder=false) -->
-  <function name="wxArrayString::Sort">
+  <!-- virtual int wxListBox::FindString( const wxString & s, bool bCase = false ) const -->
+  <function name="wxListBox::FindString">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in" default="false">
+    <use-retval/>
+    <returnValue type="int"/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="false" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!-- void wxArrayString::Shrink(void) -->
-  <function name="wxArrayString::Shrink">
+  <!-- void wxMenuBar::SetLabel(int id, const wxString &label) -->
+  <function name="wxMenuBar::SetLabel">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
   </function>
-  <!-- void wxArrayString::RemoveAt(int nIndex, size_t count = 1) -->
-  <function name="wxArrayString::RemoveAt">
+  <!-- virtual void wxListBox::SetSelection(int n) -->
+  <function name="wxListBox::SetSelection">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in" default="1">
-      <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- size_t wxArrayInt::Add(int i, size_t copies = 1) -->
-  <function name="wxArrayInt::Add">
+  <!-- void wxWindow::SetPosition(const wxPoint & pt)
+       and derived classes -->
+  <function name="wxWindow::SetPosition,wxStaticText::SetPosition,wxButton::SetPosition,wxBitmapButton::SetPosition,wxBannerWindow::SetPosition,wxControl::SetPosition,wxGLCanvas::SetPosition,wxHtmlHelpWindow::SetPosition,wxMDIClientWindow::SetPosition,wxMenuBar::SetPosition,wxNativeWindow::SetPosition,wxNonOwnedWindow::SetPosition,wxPanel::SetPosition,wxPGMultiButton::SetPosition,wxSashWindow::SetPosition,wxSplitterWindow::SetPosition,wxTipWindow::SetPosition,wxTreeListCtrl::SetPosition,wxActiveXContainer::SetPosition,wxActivityIndicator::SetPosition,wxAnimationCtrl::SetPosition,wxAnyButton::SetPosition,wxAuiToolBar::SetPosition,wxBookCtrlBase::SetPosition,wxCalenderCtrl::SetPosition,wxCheckBox::SetPosition,wxChoice::SetPosition,wxCollapsibleHeaderCtrl::SetPosition,wxCollapsiblePane::SetPosition,wxComboBox::SetPosition,wxComboCtrl::SetPosition,wxControlWithItems::SetPosition,wxDataViewCtrl::SetPosition,wxDatePickerCtrl::SetPosition,wxFileCtrl::SetPosition,wxGauge::SetPosition,wxGenericDirCtrl::SetPosition,wxHeaderCtrl::SetPosition,wxHyperlinkCtrl::SetPosition,wxInfoBar::SetPosition,wxListBox::SetPosition,wxListCtrl::SetPosition,wxMediaCtrl::SetPosition,wxPickerBase::SetPosition,wxPropertyGrid::SetPosition,wxRadioBox::SetPosition,wxRadioButton::SetPosition,wxRibbonCtrl::SetPosition,wxRichTextCtrl::SetPosition">
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="size_t"/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in" default="1">
-      <not-uninit/>
-    </arg>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!-- size_t wxArrayDouble::Add(double i, size_t copies = 1) -->
-  <function name="wxArrayDouble::Add">
+  <!-- bool wxGrid::AppendCols( int numCols = 1, bool updateLabels = true ) -->
+  <!-- bool wxGrid::AppendRows( int numRows = 1, bool updateLabels = true ) -->
+  <function name="wxGrid::AppendCols,wxGrid::AppendRows">
     <noreturn>false</noreturn>
+    <returnValue type="bool"/>
     <leak-ignore/>
-    <returnValue type="size_t"/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in" default="1">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="2" direction="in" default="1">
+    <arg nr="2" direction="in" default="true">
       <not-uninit/>
     </arg>
   </function>
-  <!-- wxString wxString::BeforeFirst( wxUniChar ch, wxString * rest = NULL) const -->
-  <!-- wxString wxString::BeforeLast( wxUniChar ch, wxString * rest = NULL) const -->
-  <function name="wxString::BeforeFirst,wxString::BeforeLast">
+  <!-- virtual bool SetFont (const wxFont &font)
+       and derived classes -->
+  <function name="wxToggleButton::SetFont,wxSpinCtrl::SetFont,wxGrid::SetFont,wxStyledTextCtrl::SetFont,wxStaticBox::SetFont,wxButton::SetFont,wxDataViewTreeCtrl::SetFont,wxTextCtrl::SetFont,wxWindow::SetFont,wxPropertyGridManager::SetFont,wxPaintDC::SetFont,wxStaticText::SetFont,wxBannerWindow::SetFont,wxControl::SetFont,wxGLCanvas::SetFont,wxHtmlHelpWindow::SetFont,wxMDIClientWindow::SetFont,wxMenuBar::SetFont,wxNativeWindow::SetFont,wxNonOwnedWindow::SetFont,wxPanel::SetFont,wxPGMultiButton::SetFont,wxSashWindow::SetFont,wxSplitterWindow::SetFont,wxTipWindow::SetFont,wxTreeListCtrl::SetFont,wxActiveXContainer::SetFont,wxActivityIndicator::SetFont,wxAnimationCtrl::SetFont,wxAnyButton::SetFont,wxAuiToolBar::SetFont,wxBookCtrlBase::SetFont,wxCalenderCtrl::SetFont,wxCheckBox::SetFont,wxChoice::SetFont,wxCollapsibleHeaderCtrl::SetFont,wxCollapsiblePane::SetFont,wxComboBox::SetFont,wxComboCtrl::SetFont,wxControlWithItems::SetFont,wxDataViewCtrl::SetFont,wxDatePickerCtrl::SetFont,wxFileCtrl::SetFont,wxGauge::SetFont,wxGenericDirCtrl::SetFont,wxHeaderCtrl::SetFont,wxHyperlinkCtrl::SetFont,wxInfoBar::SetFont,wxListBox::SetFont,wxListCtrl::SetFont,wxMediaCtrl::SetFont,wxPickerBase::SetFont,wxPropertyGrid::SetFont,wxRadioBox::SetFont,wxRadioButton::SetFont,wxRibbonCtrl::SetFont,wxRichTextCtrl::SetFont">
     <noreturn>false</noreturn>
-    <returnValue type="wxString"/>
-    <use-retval/>
-    <const/>
+    <leak-ignore/>
+    <returnValue type="bool"/>
     <arg nr="1" direction="in"/>
-    <arg nr="2" direction="inout" default="NULL">
+  </function>
+  <!-- virtual void wxStaticText::SetLabel ( const wxString & label ) -->
+  <function name="wxStaticText::SetLabel">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- virtual wxControl* wxToolBar::FindControl(int id) -->
+  <function name="wxToolBar::FindControl">
+    <noreturn>false</noreturn>
+    <returnValue type="wxControl*"/>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>0:</valid>
     </arg>
   </function>
-  <!-- bool wxDir::GetFirst(wxString * filename, const wxString & filespec = wxEmptyString, int flags = wxDIR_DEFAULT) const-->
-  <function name="wxDir::GetFirst">
+  <!--virtual wxToolBarToolBase* wxToolBar::AddControl(wxControl * control, const wxString & label = wxEmptyString)-->
+  <function name="wxToolBar::AddControl">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <const/>
+    <returnValue type="wxToolBarToolBase *"/>
     <leak-ignore/>
-    <use-retval/>
-    <arg nr="1" direction="out">
+    <arg nr="1" direction="inout">
       <not-null/>
     </arg>
     <arg nr="2" direction="in" default="wxEmptyString"/>
-    <arg nr="3" direction="in" default="wxDIR_DEFAULT">
+  </function>
+  <!-- void wxDC::DrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height ) -->
+  <!-- void wxMemoryDC::DrawEllipse( wxCoord x, wxCoord y, wxCoord width, wxCoord height ) -->
+  <function name="wxDC::DrawEllipse,wxMemoryDC::DrawEllipse">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="any" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!-- size_t wxDir::Traverse(wxDirTraverser & sink, const wxString & filespec = wxEmptyString, int flags = wxDIR_DEFAULT) const-->
-  <function name="wxDir::Traverse">
+  <!-- void wxDC::DrawEllipticArc (wxCoord x, wxCoord y, wxCoord width, wxCoord height, double start, double end) -->
+  <!-- void wxDC::DrawEllipticArc (const wxPoint &pt, const wxSize &sz, double sa, double ea) -->
+  <function name="wxDC::DrawEllipticArc,wxGCDC::DrawEllipticArc,wxMemoryDC::DrawEllipticArc,wxBufferedDC::DrawEllipticArc,wxBufferedPaintDC::DrawEllipticArc,wxAutoBufferedPaintDC::DrawEllipticArc,wxMetafileDC::DrawEllipticArc,wxMirrorDC::DrawEllipticArc,wxPostScriptDC::DrawEllipticArc,wxPrinterDC::DrawEllipticArc,wxScreenDC::DrawEllipticArc,wxSVGFileDC::DrawEllipticArc,wxWindowDC::DrawEllipticArc,wxClientDC::DrawEllipticArc,wxPaintDC::DrawEllipticArc">
     <noreturn>false</noreturn>
-    <returnValue type="size_t"/>
-    <const/>
+    <returnValue type="void"/>
     <leak-ignore/>
-    <arg nr="1" direction="out"/>
-    <arg nr="2" direction="in" default="wxEmptyString"/>
-    <arg nr="3" direction="in" default="wxDIR_DEFAULT">
+    <arg nr="any" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!--size_t wxArrayString::GetCount() const-->
-  <function name="wxArrayString::GetCount">
+  <!-- void wxDC::DrawSpline (int n, const wxPoint points[]) -->
+  <!-- void wxDC::DrawSpline (const wxPointList *points) -->
+  <!-- void wxDC::DrawSpline (wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2, wxCoord x3, wxCoord y3) -->
+  <function name="wxDC::DrawSpline,wxMemoryDC::DrawSpline,wxBufferedDC::DrawSpline,wxBufferedPaintDC::DrawSpline,wxAutoBufferedPaintDC::DrawSpline,wxMetaFileDC::DrawSpline,wxMirrorDC::DrawSpline,wxPostScriptDC::DrawSpline,wxGCDC::DrawSpline,wxPrinterDC::DrawSpline,wxScreenDC::DrawSpline,wxSVGFileDC::DrawSpline,wxWindowDC::DrawSpline,wxClientDC::DrawSpline,wxPaintDC::DrawSpline">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
     <leak-ignore/>
-    <returnValue type="size_t"/>
-    <use-retval/>
+    <arg nr="any" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
-  <!--wxString& wxArrayString::Item	(size_t nIndex) -->
-  <!--const wxString& wxArrayString::Item (size_t nIndex) const -->
-  <function name="wxArrayString::Item">
+  <!-- virtual void wxFont::SetWeight(wxFontWeight weight) -->
+  <function name="wxFont::SetWeight">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
     <leak-ignore/>
-    <returnValue type="wxString &amp;"/>
-    <use-retval/>
-    <const/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!-- void wxArrayString::Insert(wxString lItem, size_t nIndex, size_t copies = 1)	-->
-  <function name="wxArrayString::Insert">
+  <!-- bool wxSizer::SetItemMinSize( wxWindow * window, int width, int height ) -->
+  <!-- bool wxBoxSizer::SetItemMinSize( wxWindow * window, int width, int height ) -->
+  <function name="wxSizer::SetItemMinSize,wxBoxSizer::SetItemMinSize">
     <noreturn>false</noreturn>
+    <returnValue type="bool"/>
     <leak-ignore/>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in"/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+    </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="3" default="1" direction="in">
+    <arg nr="3" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- int wxArrayString::Index(const wxString & sz, bool bCase = true, bool bFromEnd = false) const -->
-  <function name="wxArrayString::Index">
+  <!-- bool wxVariant::IsNull() const -->
+  <function name="wxVariant::IsNull">
     <noreturn>false</noreturn>
+    <returnValue type="bool"/>
     <leak-ignore/>
-    <returnValue type="int"/>
-    <use-retval/>
     <const/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" default="true" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="3" default="false" direction="in">
-      <not-uninit/>
-    </arg>
+    <use-retval/>
   </function>
-  <!-- bool wxArrayString::IsEmpty()-->
-  <function name="wxArrayString::IsEmpty">
+  <!-- void wxVariant::MakeNull() -->
+  <function name="wxVariant::MakeNull">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
     <leak-ignore/>
+  </function>
+  <!-- bool wxVariant::IsType() const -->
+  <function name="wxVariant::IsType">
+    <noreturn>false</noreturn>
     <returnValue type="bool"/>
+    <leak-ignore/>
+    <const/>
     <use-retval/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!-- wxUniChar wxString::at(size_t n)const-->
-  <function name="wxArrayString::at">
+  <!-- wxAny wxVariant::GetAny() const -->
+  <function name="wxVariant::GetAny">
     <noreturn>false</noreturn>
+    <returnValue type="wxAny"/>
     <leak-ignore/>
-    <returnValue type="wxUniChar"/>
     <const/>
     <use-retval/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
   </function>
-  <!--wxPGProperty* wxPropertyGridInterface::Append(wxPGProperty * property)-->
-  <!--wxPGProperty* wxPropertyGridPage::Append(wxPGProperty * property)-->
-  <function name="wxPropertyGridInterface::Append,wxPropertyGridPage::Append">
+  <!-- wxArrayString wxVariant::GetArrayString() const -->
+  <function name="wxVariant::GetArrayString">
     <noreturn>false</noreturn>
+    <returnValue type="wxArrayString"/>
     <leak-ignore/>
-    <returnValue type="wxPGProperty*"/>
-    <arg nr="2" direction="in"/>
-    <arg nr="2" direction="inout">
-      <not-uninit/>
-      <not-null/>
-    </arg>
+    <const/>
+    <use-retval/>
   </function>
-  <!-- int wxRound(double x) -->
-  <function name="wxRound">
+  <!-- bool wxVariant::GetBool() const -->
+  <function name="wxVariant::GetBool">
     <noreturn>false</noreturn>
+    <returnValue type="bool"/>
     <leak-ignore/>
-    <returnValue type="int"/>
+    <const/>
     <use-retval/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
   </function>
-  <!-- double wxRadToDeg(double rad) -->
-  <!-- double wxDegToRad(double deg) -->
-  <function name="wxRadToDeg,wxDegToRad">
+  <!-- wxUniChar wxVariant::GetChar() const -->
+  <function name="wxVariant::GetChar">
     <noreturn>false</noreturn>
+    <returnValue type="wxUniChar"/>
     <leak-ignore/>
-    <returnValue type="double"/>
+    <const/>
     <use-retval/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
   </function>
-  <!-- bool wxIsNullDouble (double x)-->
-  <!-- bool wxIsNaN	(double x)-->
-  <!-- bool wxFinite (double x)-->
-  <function name="wxIsNullDouble,wxIsNaN,wxFinite">
+  <!-- wxVariantData * wxVariant::GetData () const-->
+  <function name="wxVariant::GetData">
     <noreturn>false</noreturn>
+    <returnValue type="wxVariantData *"/>
     <leak-ignore/>
-    <returnValue type="bool"/>
+    <const/>
     <use-retval/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
   </function>
-  <!-- unsigned int wxCTZ(wxUint32 x) -->
-  <function name="wxCTZ">
+  <!-- wxDateTime wxVariant::GetDateTime () const-->
+  <function name="wxVariant::GetDateTime">
     <noreturn>false</noreturn>
+    <returnValue type="wxDateTime"/>
     <leak-ignore/>
-    <returnValue type="unsigned int"/>
+    <const/>
     <use-retval/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
   </function>
-  <!-- bool wxIsSameDouble(double x, doubly y)-->
-  <function name="wxIsNullDouble">
+  <!-- double wxVariant::GetDouble () const-->
+  <function name="wxVariant::GetDouble">
     <noreturn>false</noreturn>
+    <returnValue type="double"/>
     <leak-ignore/>
-    <returnValue type="bool"/>
+    <const/>
     <use-retval/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
-    </arg>
   </function>
-  <!-- unsigned int wxGCD(unsigned int u, unsigned int v) -->
-  <function name="wxGCD">
+  <!-- long wxVariant::GetLong() const -->
+  <function name="wxVariant::GetLong">
     <noreturn>false</noreturn>
+    <returnValue type="long"/>
     <leak-ignore/>
-    <returnValue type="unsigned int"/>
+    <const/>
     <use-retval/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
-    </arg>
   </function>
-  <!-- static wxColour wxSystemSettings::GetColour(wxSystemColour index) -->
-  <function name="wxSystemSettings::GetColour">
+  <!-- wxLongLong wxVariant::GetLongLong() const -->
+  <function name="wxVariant::GetLongLong">
     <noreturn>false</noreturn>
+    <returnValue type="wxLongLong"/>
     <leak-ignore/>
-    <returnValue type="wxColour"/>
+    <const/>
     <use-retval/>
-    <pure/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
   </function>
-  <!-- void wxStatusBar::PopStatusText(int field = 0)-->
-  <function name="wxStatusBar::PopStatusText">
+  <!-- const wxString & wxVariant::GetName () const-->
+  <function name="wxVariant::GetName">
     <noreturn>false</noreturn>
+    <returnValue type="wxString &amp;"/>
     <leak-ignore/>
-    <returnValue type="void"/>
-    <arg nr="1" default="0" direction="in">
+    <const/>
+    <use-retval/>
+  </function>
+  <!-- wxString wxVariant::GetString () const-->
+  <!-- wxString wxVariant::GetType () const-->
+  <function name="wxVariant::GetString,wxVariant::GetType">
+    <noreturn>false</noreturn>
+    <returnValue type="wxString"/>
+    <leak-ignore/>
+    <const/>
+    <use-retval/>
+  </function>
+  <!-- wxULongLong wxVariant::GetULongLong() const -->
+  <function name="wxVariant::GetULongLong">
+    <noreturn>false</noreturn>
+    <returnValue type="wxULongLong"/>
+    <leak-ignore/>
+    <const/>
+    <use-retval/>
+  </function>
+  <!-- wxULongLong_t wxULongLong::GetValue() const  -->
+  <function name="wxULongLong::GetValue">
+    <noreturn>false</noreturn>
+    <returnValue type="wxULongLong_t"/>
+    <leak-ignore/>
+    <const/>
+    <use-retval/>
+  </function>
+  <!-- void * wxVariant::GetVoidPtr() const -->
+  <function name="wxVariant::GetVoidPtr">
+    <noreturn>false</noreturn>
+    <returnValue type="void *"/>
+    <leak-ignore/>
+    <const/>
+    <use-retval/>
+  </function>
+  <!-- wxObject * wxVariant::GetWxObjectPtr() const -->
+  <function name="wxVariant::GetWxObjectPtr">
+    <noreturn>false</noreturn>
+    <returnValue type="wxObject *"/>
+    <leak-ignore/>
+    <const/>
+    <use-retval/>
+  </function>
+  <!-- void wxSize::SetHeight(int height)-->
+  <!-- void wxSize::SetWidth(int width)-->
+  <function name="wxSize::SetHeight,wxSize::SetWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
       <not-uninit/>
-      <valid>0:</valid>
+      <not-bool/>
     </arg>
   </function>
-  <!-- virtual void wxStatusBar::PushStatusText	(const wxString & string, int field = 0) -->
-  <function name="wxStatusBar::PushStatusText">
+  <!-- int wxSize::GetHeight( void ) const -->
+  <!-- int wxSize::GetWidth( void ) const -->
+  <!-- int wxSize::GetX( void ) const -->
+  <!-- int wxSize::GetY( void ) const -->
+  <function name="wxSize::GetHeight,wxSize::GetWidth,wxSize::GetX,wxSize::GetY">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="int"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- virtual void wxBrush::SetColour(const wxColour & colour)-->
+  <function name="wxBrush::SetColour">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="void"/>
     <arg nr="1" direction="in"/>
-    <arg nr="2" default="0" direction="in">
+  </function>
+  <!-- void wxDC::SetClippingRegion (wxCoord x, wxCoord y, wxCoord width, wxCoord height)-->
+  <!-- void wxDC::SetClippingRegion (const wxPoint &pt, const wxSize &sz) -->
+  <!-- void wxDC::SetClippingRegion (const wxRect &rect) -->
+  <!-- void wxMemoryDC::SetClippingRegion (wxCoord x, wxCoord y, wxCoord width, wxCoord height)-->
+  <!-- void wxMemoryDC::SetClippingRegion (const wxPoint &pt, const wxSize &sz) -->
+  <!-- void wxMemoryDC::SetClippingRegion (const wxRect &rect) -->
+  <function name="wxDC::SetClippingRegion,wxMemoryDC::SetClippingRegion">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="any" direction="in"/>
+  </function>
+  <!-- virtual void wxBrush::SetStyle (wxBrushStyle style) -->
+  <function name="wxBrush::SetStyle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
       <not-uninit/>
-      <valid>0:</valid>
     </arg>
   </function>
-  <!-- virtual void wxStatusBar::SetFieldsCount	(int number = 1, const int * widths = NULL) -->
-  <function name="wxStatusBar::SetFieldsCount">
+  <!-- virtual void wxComboCtrl::SetValue(const wxString &value) -->
+  <!-- virtual void wxOwnerDrawnComboBox::SetValue(const wxString &value) -->
+  <!-- virtual void wxComboCtrl::SetValueByUser(const wxString &value) -->
+  <function name="wxComboCtrl::SetValue,wxOwnerDrawnComboBox::SetValue,wxComboCtrl::SetValueByUser">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <returnValue type="void"/>
-    <arg nr="1" default="1" direction="in">
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxBitmap::LoadFile( const wxString & name, wxBitmapType type = wxBITMAP_DEFAULT_TYPE ) -->
+  <function name="wxBitmap::LoadFile">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="wxBITMAP_DEFAULT_TYPE">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- wxRect wxRect::CentreIn(const wxRect & r, int dir = wxBOTH) -->
+  <!-- wxRect wxRect::CenterIn(const wxRect & r, int dir = wxBOTH) -->
+  <function name="wxRect::CentreIn,wxRect::CenterIn">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxRect"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
       <not-uninit/>
-      <valid>1:</valid>
     </arg>
-    <arg nr="2" default="NULL" direction="in">
+    <arg nr="2" direction="in" default="wxBOTH">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxDC::DrawLine (const wxPoint &pt1, const wxPoint &pt2) -->
-  <!-- void wxMemoryDC::DrawLine (const wxPoint &pt1, const wxPoint &pt2) -->
-  <!-- void wxBufferedDC::DrawLine (const wxPoint &pt1, const wxPoint &pt2) -->
-  <!-- void wxPaintDC::DrawLine (const wxPoint &pt1, const wxPoint &pt2) -->
-  <!-- void wxBufferedPaintDC::DrawLine (const wxPoint &pt1, const wxPoint &pt2) -->
-  <!-- void wxClientDC::DrawLine (const wxPoint &pt1, const wxPoint &pt2) -->
-  <function name="wxDC::DrawLine,wxMemoryDC::DrawLine,wxBufferedDC::DrawLine,wxPaintDC::DrawLine,wxBufferedPaintDC::DrawLine,wxClientDC::DrawLine">
+  <!-- virtual void wxTextEntry::SetValue (const wxString & value)-->
+  <!-- virtual void wxTextCtrl::SetValue (const wxString & value)-->
+  <!-- virtual void wxComboBox::SetValue (const wxString & value)-->
+  <!-- virtual void wxStyledTextCtrl::SetValue (const wxString & value)-->
+  <function name="wxTextEntry::SetValue,wxTextCtrl::SetValue,wxComboBox::SetValue,wxStyledTextCtrl::SetValue">
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in"/>
   </function>
-  <!-- void wxDC::DrawRectangle (const wxPoint & pt, const wxSize & sz) -->
-  <!-- void wxMemoryDC::DrawRectangle (const wxPoint & pt, const wxSize & sz) -->
-  <!-- void wxBufferedDC::DrawRectangle (const wxPoint & pt, const wxSize & sz) -->
-  <!-- void wxBufferedPaintDC::DrawRectangle (const wxPoint & pt, const wxSize & sz) -->
-  <!-- void wxClientDC::DrawRectangle (const wxPoint & pt, const wxSize & sz) -->
-  <!-- void wxPaintDC::DrawRectangle (const wxPoint & pt, const wxSize & sz) -->
-  <!-- void wxBufferedPaintDC::DrawRectangle (const wxPoint & pt, const wxSize & sz) -->
-  <function name="wxDC::DrawRectangle,wxMemoryDC::DrawRectangle,wxBufferedDC::DrawRectangle,wxBufferedPaintDC::DrawRectangle,wxClientDC::DrawRectangle,wxPaintDC::DrawRectangle,wxBufferedPaintDC::DrawRectangle">
+  <!-- void wxLog::SetLogLevel( wxLogLevel logLevel ) -->
+  <!-- void wxLogGui::SetLogLevel( wxLogLevel logLevel ) -->
+  <function name="wxLog::SetLogLevel,wxLogGui::SetLogLevel">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
     <leak-ignore/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
-  <!-- bool wxDC::Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height, wxDC * source, wxCoord xsrc, wxCoord ysrc, wxRasterOperationMode logicalFunc = wxCOPY,
-                       bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord) -->
-  <!-- bool wxMemoryDC::Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height, wxDC * source, wxCoord xsrc, wxCoord ysrc, wxRasterOperationMode logicalFunc = wxCOPY,
-                       bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord) -->
-  <!-- bool wxBufferedDC::Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height, wxDC * source, wxCoord xsrc, wxCoord ysrc, wxRasterOperationMode logicalFunc = wxCOPY,
-                       bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord) -->
-  <!-- bool wxBufferedPaintDC::Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height, wxDC * source, wxCoord xsrc, wxCoord ysrc, wxRasterOperationMode logicalFunc = wxCOPY,
-                       bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord) -->
-  <!-- bool wxGCDC::Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height, wxDC * source, wxCoord xsrc, wxCoord ysrc, wxRasterOperationMode logicalFunc = wxCOPY,
-                       bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord) -->
-  <!-- bool wxPaintDC::Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height, wxDC * source, wxCoord xsrc, wxCoord ysrc, wxRasterOperationMode logicalFunc = wxCOPY,
-                       bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord) -->
-  <function name="wxDC::Blit,wxMemoryDC::Blit,wxBufferedDC::Blit,wxBufferedPaintDC::Blit,wxGCDC::Blit,wxPaintDC::Blit">
+  <!-- bool wxRect::Contains(const wxPoint & pt) const -->
+  <!-- bool wxRect::Contains(const wxRect & rect) const -->
+  <function name="wxRect::Contains">
     <noreturn>false</noreturn>
+    <leak-ignore/>
+    <const/>
     <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxString wxListCtrl::GetItemText (long item, int col=0) const -->
+  <!-- wxString wxListView::GetItemText (long item, int col=0) const -->
+  <function name="wxListCtrl::GetItemText,wxListView::GetItemText">
+    <noreturn>false</noreturn>
+    <returnValue type="wxString"/>
     <leak-ignore/>
+    <const/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="2" direction="in">
+    <arg nr="2" direction="in" default="0">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="3" direction="in">
+  </function>
+  <!-- bool wxListCtrl::SetColumnWidth (int col, int width) -->
+  <!-- bool wxListView::SetColumnWidth (int col, int width) -->
+  <function name="wxListCtrl::SetColumnWidth,wxListView::SetColumnWidth">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="4" direction="in">
+    <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="5" direction="inout">
+  </function>
+  <!-- long wxListCtrl::InsertColumn(long col, const wxListItem & info) -->
+  <!-- long wxListCtrl::InsertColumn(long col, const wxString & heading, int format = wxLIST_FORMAT_LEFT, int width = wxLIST_AUTOSIZE) -->
+  <!-- long wxListView::InsertColumn(long col, const wxListItem & info) -->
+  <!-- long wxListView::InsertColumn(long col, const wxString & heading, int format = wxLIST_FORMAT_LEFT, int width = wxLIST_AUTOSIZE) -->
+  <function name="wxListCtrl::InsertColumn,wxListView::InsertColumn">
+    <noreturn>false</noreturn>
+    <returnValue type="long"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
       <not-uninit/>
-      <not-null/>
     </arg>
-    <arg nr="6" direction="in">
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in" default="wxLIST_FORMAT_LEFT">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="7" direction="in">
+    <arg nr="4" direction="in" default="wxLIST_AUTOSIZE">
       <not-uninit/>
     </arg>
-    <arg nr="8" direction="in" default="wxCOPY">
+  </function>
+  <!-- wxLog * wxLog::SetActiveTarget( wxLog * logger ) -->
+  <!-- wxLog * wxLogGui::SetActiveTarget( wxLog * logger ) -->
+  <function name="wxLog::SetActiveTarget,wxLogGui::SetActiveTarget">
+    <noreturn>false</noreturn>
+    <returnValue type="wxLog *"/>
+    <leak-ignore/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- bool wxIsSameDouble( double x, double y ) const -->
+  <function name="wxIsSameDouble">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <const/>
+    <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="9" direction="in" default="false">
+    <arg nr="2" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="10" direction="in" default="wxDefaultCoord">
+  </function>
+  <!-- bool wxConfigBase::Write(const wxString &key, const wxString &value)-->
+  <!-- bool wxConfigBase::Write(const wxString &key, const long value)-->
+  <!-- bool wxConfigBase::Write(const wxString &key, const double value)-->
+  <!-- bool wxConfigBase::Write(const wxString &key, const bool value)-->
+  <function name="wxConfigBase::Write,wxConfig::Write,wxFileConfig::Write,wxRegConfig::Write">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <use-retval/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxGrid::SetDefaultCellTextColour( const wxColour &colour ) -->
+  <!-- void wxGrid::SetDefaultCellBackgroundColour( const wxColour &colour ) -->
+  <!-- void wxGrid::SetDefaultCellFont( const wxFont &font ) -->
+  <function name="wxGrid::SetDefaultCellTextColour,wxGrid::SetDefaultCellBackgroundColour,wxGrid::SetDefaultCellFont">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxGrid::SetCellFont( int row, int col, const wxFont &  ) -->
+  <function name="wxGrid::SetCellFont">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="11" direction="in" default="wxDefaultCoord">
+    <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
+    <arg nr="3" direction="in"/>
   </function>
-  <!-- void wxDC::DrawPolygon(int n, const wxPoint points[], wxCoord xoffset = 0, wxCoord yoffset = 0, wxPolygonFillMode fill_style = wxODDEVEN_RULE) -->
-  <!-- void wxMemoryDC::DrawPolygon(int n, const wxPoint points[], wxCoord xoffset = 0, wxCoord yoffset = 0, wxPolygonFillMode fill_style = wxODDEVEN_RULE) -->
-  <!-- void wxBufferedDC::DrawPolygon(int n, const wxPoint points[], wxCoord xoffset = 0, wxCoord yoffset = 0, wxPolygonFillMode fill_style = wxODDEVEN_RULE) -->
-  <!-- void wxBufferedPaintDC::DrawPolygon(int n, const wxPoint points[], wxCoord xoffset = 0, wxCoord yoffset = 0, wxPolygonFillMode fill_style = wxODDEVEN_RULE) -->
-  <!-- void wxPaintDC::DrawPolygon(int n, const wxPoint points[], wxCoord xoffset = 0, wxCoord yoffset = 0, wxPolygonFillMode fill_style = wxODDEVEN_RULE) -->
-  <function name="wxDC::DrawPolygon,wxMemoryDC::DrawPolygon,wxBufferedDC::DrawPolygon,wxBufferedPaintDC::DrawPolygon,wxPaintDC::DrawPolygon">
+  <!-- void wxSlider::SetMax( int maxValue ) -->
+  <!-- void wxSlider::SetMin( int minValue ) -->
+  <function name="wxSlider::SetMax,wxSlider::SetMin">
+    <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- virtual void wxTextEntry::SetInsertionPoint(long pos) -->
+  <!-- virtual void wxTextCtrl::SetInsertionPoint(long pos) -->
+  <function name="wxTextEntry::SetInsertionPoint,wxTextCtrl::SetInsertionPoint">
     <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="2" direction="in">
+  </function>
+  <!-- void wxMemoryBuffer::AppendByte(char data) -->
+  <function name="wxMemoryBuffer::AppendByte">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
       <not-uninit/>
-      <not-null/>
+      <not-bool/>
     </arg>
-    <arg nr="3" direction="in" default="0">
+  </function>
+  <!-- void* wxMemoryBuffer::GetWriteBuf(size_t sizeNeeded) -->
+  <function name="wxMemoryBuffer::GetWriteBuf">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void*"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <valid>1:</valid>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void wxMemoryBuffer::UngetWriteBuf(size_t sizeNeeded) -->
+  <function name="wxMemoryBuffer::UngetWriteBuf">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <valid>1:</valid>
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!--bool Read(const wxString &key, wxString *str) const -->
+  <!--bool Read(const wxString &key, double *d) const -->
+  <!--bool Read(const wxString &key, float *f) const -->
+  <!--bool Read(const wxString &key, bool *b) const -->
+  <!--bool Read(const wxString &key, wxMemoryBuffer *buf) const -->
+  <function name="wxConfigBase::Read,wxConfig::Read,wxFileConfig::Read,wxRegConfig::Read">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- void wxControl::SetLabelText(const wxString & text)
+     and derived classes -->
+  <function name="wxControl::SetLabelText,wxToggleButton::SetLabelText,wxButton::SetLabelText,wxActiveXContainer::SetLabelText,wxActivityIndicator::SetLabelText,wxAnimationCtrl::SetLabelText,wxAnyButton::SetLabelText,wxAuiToolBar::SetLabelText,wxBookCtrlBase::SetLabelText,wxCalendarCtrl::SetLabelText,wxCheckBox::SetLabelText,wxChoice::SetLabelText,wxCollapsibleHeaderCtrl::SetLabelText,wxCollapsiblePane::SetLabelText,wxComboBox::SetLabelText,wxComboCtrl::SetLabelText,wxControlWithItems::SetLabelText,wxDataViewCtrl::SetLabelText,wxDatePickerCtrl::SetLabelText,wxFileCtrl::SetLabelText,wxGauge::SetLabelText,wxGenericDirCtrl::SetLabelText,wxHeaderCtrl::SetLabelText,wxHyperlinkCtrl::SetLabelText,wxInfoBar::SetLabelText,wxListBox::SetLabelText,wxListCtrl::SetLabelText,wxMediaCtrl::SetLabelText,wxPickerBase::SetLabelText,wxPropertyGrid::SetLabelText,wxRadioBox::SetLabelText,wxRadioButton::SetLabelText,wxRibbonControl::SetLabelText,wxRichTextCtrl::SetLabelText,wxRichTextStyleListCtrl::SetLabelText,wxScrollBar::SetLabelText,wxSlider::SetLabelText,wxSpinButton::SetLabelText,wxSpinCtrl::SetLabelText,wxSpinCtrlDouble::SetLabelText,wxStaticBitmap::SetLabelText,wxStaticBox::SetLabelText,wxStaticLine::SetLabelText,wxStaticText::SetLabelText,wxStatusBar::SetLabelText,wxStyledTextCtrl::SetLabelText,wxTextCtrl::SetLabelText,wxTimePickerCtrl::SetLabelText,wxToolBar::SetLabelText,wxTreeCtrl::SetLabelText,wxWebKitCtrl::SetLabelText,wxWebView::SetLabelText">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxAboutDialogInfo::AddArtist (const wxString &artist)-->
+  <!-- void wxAboutDialogInfo::AddDeveloper (const wxString &developer)-->
+  <!-- void wxAboutDialogInfo::AddDocWriter (const wxString &docwriter)-->
+  <!-- void wxAboutDialogInfo::AddTranslator (const wxString &translator)-->
+  <!-- void wxAboutDialogInfo::SetArtists (const wxArrayString &artists)-->
+  <!-- void wxAboutDialogInfo::SetCopyright (const wxString &copyright)-->
+  <!-- void wxAboutDialogInfo::SetDescription (const wxString &description)-->
+  <!-- void wxAboutDialogInfo::SetName (const wxString &name)-->
+  <!-- void wxAboutDialogInfo::SetLicence (const wxString &l)-->
+  <!-- void wxAboutDialogInfo::SetLicense (const wxString &l)-->
+  <!-- void wxAboutDialogInfo::SetDevelopers (const wxArrayString &devs)-->
+  <!-- void wxAboutDialogInfo::SetDocWriters (const wxArrayString &docwriters)-->
+  <!-- void wxAboutDialogInfo::SetTranslators (const wxArrayString &translators)-->
+  <function name="wxAboutDialogInfo::AddArtist,wxAboutDialogInfo::AddDeveloper,wxAboutDialogInfo::SetTranslators,wxAboutDialogInfo::SetLicence,wxAboutDialogInfo::SetLicense,wxAboutDialogInfo::SetName,wxAboutDialogInfo::AddDocWriter,wxAboutDialogInfo::SetDevelopers,wxAboutDialogInfo::SetDocWriters,wxAboutDialogInfo::SetDescription,wxAboutDialogInfo::AddTranslator,wxAboutDialogInfo::SetArtists,wxAboutDialogInfo::SetCopyright">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxAboutDialogInfo::SetVersion (const wxString &version, const wxString &longVersion=wxString())-->
+  <function name="wxAboutDialogInfo::SetVersion">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default=""/>
+  </function>
+  <!-- void wxAboutDialogInfo::SetIcon (const wxIcon &)-->
+  <function name="wxAboutDialogInfo::SetIcon">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxGauge::SetValue(int pos)-->
+  <!-- void wxGauge::SetRange(int range)-->
+  <!-- void wxGauge::SetShadowWidth(int width)-->
+  <function name="wxGauge::SetValue,wxGauge::SetRange,wxGauge::SetShadowWidth">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void wxRadioButton::SetValue(bool value)-->
+  <function name="wxRadioButton::SetValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxSize wxWindowBase::GetTextExtent(const wxString & string) const-->
+  <!-- wxSize wxWindow::GetTextExtent(const wxString & string) const-->
+  <!-- wxSize wxTextCtrl::GetTextExtent(const wxString & string) const-->
+  <!-- wxSize wxStaticText::GetTextExtent(const wxString & string) const-->
+  <function name="wxWindowBase::GetTextExtent,wxWindow::GetTextExtent,wxTextCtrl::GetTextExtent,wxStaticText::GetTextExtent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <const/>
+    <returnValue type="wxSize"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxWindowBase::Center(int direction=wxBOTH) -->
+  <!-- void wxWindowBase::CenterOnParent(int direction=wxBOTH) -->
+  <!-- void wxWindowBase::Centre(int direction=wxBOTH) -->
+  <!-- void wxWindowBase::CentreOnParent(int direction=wxBOTH) -->
+  <!-- void wxWindow::Center(int direction=wxBOTH) -->
+  <!-- void wxWindow::CenterOnParent(int direction=wxBOTH) -->
+  <!-- void wxWindow::Centre(int direction=wxBOTH) -->
+  <!-- void wxWindow::CentreOnParent(int direction=wxBOTH) -->
+  <!-- void wxPreviewFrame::Center(int direction=wxBOTH) -->
+  <!-- void wxPreviewFrame::CenterOnParent(int direction=wxBOTH) -->
+  <!-- void wxPreviewFrame::Centre(int direction=wxBOTH) -->
+  <!-- void wxPreviewFrame::CentreOnParent(int direction=wxBOTH) -->
+  <function name="wxPreviewFrame::CentreOnParent,wxPreviewFrame::Centre,wxPreviewFrame::CenterOnParent,wxPreviewFrame::Center,wxWindow::Center,wxWindow::CenterOnParent,wxWindow::Centre,wxWindow::CentreOnParent,wxWindowBase::Center,wxWindowBase::CenterOnParent,wxWindowBase::Centre,wxWindowBase::CentreOnParent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" default="wxBOTH" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- virtual void wxSlider::SetRange(int minValue, int maxValue) -->
+  <!-- virtual void wxIntegerValidator::SetRange(ValueType minValue, ValueType maxValue) -->
+  <!-- virtual void wxFloatingPointValidator::SetRange(ValueType minValue, ValueType maxValue) -->
+  <function name="wxSlider::SetRange,wxIntegerValidator::SetRange,wxFloatingPointValidator::SetRange">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool wxFile::ReadAll(wxString * str, const wxMBConv & conv = wxConvAuto())   -->
+  <function name="wxFile::ReadAll">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="out">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in" default="wxConvAuto()">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- size_t wxFile::Write(const void * buffer, size_t count)-->
+  <function name="wxFile::Write">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <minsize type="argvalue" arg="2"/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- virtual bool wxTextCtrl::EnableProofCheck ( const wxTextProofOptions & options = wxTextProofOptions::Default() ) -->
+  <function name="wxTextCtrl::EnableProofCheck">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" default="wxTextProofOptions::Default()" direction="in"/>
+  </function>
+  <!-- const wxColour& wxTextAttr::GetTextColour() const-->
+  <function name="wxTextAttr::GetTextColour">
+    <noreturn>false</noreturn>
+    <returnValue type="const wxColour &amp;"/>
+    <use-retval/>
+    <const/>
+    <leak-ignore/>
+  </function>
+  <!-- void wxInitAllImageHandlers( void ) -->
+  <function name="wxInitAllImageHandlers">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="void"/>
+  </function>
+  <!-- wxAppDerivedClass& wxGetApp( void )-->
+  <function name="wxGetApp">
+    <noreturn>false</noreturn>
+    <returnValue type="wxAppDerivedClass &amp;"/>
+    <use-retval/>
+    <const/>
+    <leak-ignore/>
+  </function>
+  <!-- virtual void wxTextCtrl::SetMaxLength(unsigned long len)-->
+  <function name="wxTextEntry::SetMaxLength,wxTextCtrl::SetMaxLength">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- void wxTextAttr::SetTextColour(const wxColour & colText) -->
+  <!-- void wxTextAttr::SetBackgroundColor(const wxColour & colBack) -->
+  <function name="wxTextAttr::SetTextColour,wxTextAttr::SetBackgroundColor">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxTextCtrl::SetModified( void ) -->
+  <function name="wxTextCtrl::SetModified">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+  </function>
+  <!-- void wxTextCtrl::SetEditable( bool edit) -->
+  <!-- void wxTextEntry::SetEditable( bool edit) -->
+  <function name="wxTextEntry::SetEditable,wxTextCtrl::SetEditable">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxFloatingPointValidator::SetPrecision(unsigned precision) -->
+  <function name="wxFloatingPointValidator::SetPrecision">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- void wxArrayString::Clear()-->
+  <!-- void wxArrayString::Empty()-->
+  <function name="wxArrayString::Clear,wxArrayString::Empty,std::vector::Clear,std::vector::Empty">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+  </function>
+  <!-- void wxArrayString::push_back(const wxString &s)-->
+  <function name="wxArrayString::push_back">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- size_t wxArrayString::Add(const wxString & str, size_t copies = 1) -->
+  <function name="wxArrayString::Add,std::vector::Add">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!--void wxArrayString::Sort(bool reverseOrder=false) -->
+  <function name="wxArrayString::Sort,std::vector::Sort">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in" default="false">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxArrayString::Shrink(void) -->
+  <function name="wxArrayString::Shrink,std::vector::Shrink">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+  </function>
+  <!-- void wxArrayString::RemoveAt(int nIndex, size_t count = 1) -->
+  <function name="wxArrayString::RemoveAt,std::vector::RemoveAt">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in" default="1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void wxArrayString::Remove(wxString &sz) -->
+  <function name="wxArrayString::Remove,std::vector::Remove">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- size_t wxArrayInt::Add(int i, size_t copies = 1) -->
+  <function name="wxArrayInt::Add,std::vector::Add">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in" default="1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- size_t wxArrayDouble::Add(double i, size_t copies = 1) -->
+  <function name="wxArrayDouble::Add">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in" default="1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxString wxString::BeforeFirst( wxUniChar ch, wxString * rest = NULL) const -->
+  <!-- wxString wxString::BeforeLast( wxUniChar ch, wxString * rest = NULL) const -->
+  <function name="wxString::BeforeFirst,wxString::BeforeLast">
+    <noreturn>false</noreturn>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="inout" default="NULL">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool wxDir::GetNext(wxString * filename) const -->
+  <function name="wxDir::GetNext">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <const/>
+    <leak-ignore/>
+    <use-retval/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- bool wxDir::GetFirst(wxString * filename, const wxString & filespec = wxEmptyString, int flags = wxDIR_DEFAULT) const-->
+  <function name="wxDir::GetFirst">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <const/>
+    <leak-ignore/>
+    <use-retval/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in" default="wxEmptyString"/>
+    <arg nr="3" direction="in" default="wxDIR_DEFAULT">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- size_t wxDir::Traverse(wxDirTraverser & sink, const wxString & filespec = wxEmptyString, int flags = wxDIR_DEFAULT) const-->
+  <function name="wxDir::Traverse">
+    <noreturn>false</noreturn>
+    <returnValue type="size_t"/>
+    <const/>
+    <leak-ignore/>
+    <arg nr="1" direction="out"/>
+    <arg nr="2" direction="in" default="wxEmptyString"/>
+    <arg nr="3" direction="in" default="wxDIR_DEFAULT">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!--size_t wxArrayString::GetCount() const-->
+  <function name="wxArrayString::GetCount,std::vector::GetCount">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="size_t"/>
+    <use-retval/>
+  </function>
+  <!--wxString& wxArrayString::Item (size_t nIndex) -->
+  <!--const wxString& wxArrayString::Item (size_t nIndex) const -->
+  <function name="wxArrayString::Item,std::vector::Item">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxString &amp;"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void wxArrayString::Insert(wxString lItem, size_t nIndex, size_t copies = 1) -->
+  <function name="wxArrayString::Insert,std::vector::Insert">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" default="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- "void wxArrayString::insert()" is identical to https://en.cppreference.com/w/cpp/container/vector/insert -->
+  <!-- Return value type is "iterator" or "void" depending on the overloaded function. -->
+  <function name="wxArrayString::insert">
+    <noreturn>false</noreturn>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" default="0">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" default="0">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- int wxArrayString::Index(const wxString & sz, bool bCase = true, bool bFromEnd = false) const -->
+  <function name="wxArrayString::Index,std::vector::Index">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool wxArrayString::IsEmpty() const-->
+  <!-- bool wxRegion::IsEmpty() const -->
+  <function name="wxArrayString::IsEmpty,std::vector::IsEmpty,wxRegion::IsEmpty">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxUniChar wxString::at(size_t n) const-->
+  <function name="wxArrayString::at">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxUniChar"/>
+    <const/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!--wxPGProperty* wxPropertyGridInterface::Append(wxPGProperty * property)-->
+  <!--wxPGProperty* wxPropertyGridPage::Append(wxPGProperty * property)-->
+  <!--wxPGProperty* wxPropertyGrid::Append(wxPGProperty * property)-->
+  <function name="wxPropertyGridInterface::Append,wxPropertyGridPage::Append,wxPropertyGrid::Append">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxPGProperty*"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="2" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
+  <!-- int wxRound(double x) -->
+  <function name="wxRound">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- double wxRadToDeg(double rad) -->
+  <!-- double wxDegToRad(double deg) -->
+  <function name="wxRadToDeg,wxDegToRad">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool wxIsNullDouble (double x)-->
+  <!-- bool wxIsNaN (double x)-->
+  <!-- bool wxFinite (double x)-->
+  <function name="wxIsNullDouble,wxIsNaN,wxFinite">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- unsigned int wxCTZ(wxUint32 x) -->
+  <function name="wxCTZ">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned int"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool wxIsSameDouble(double x, doubly y)-->
+  <function name="wxIsNullDouble">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- unsigned int wxGCD(unsigned int u, unsigned int v) -->
+  <function name="wxGCD">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="unsigned int"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- static wxColour wxSystemSettings::GetColour(wxSystemColour index) -->
+  <function name="wxSystemSettings::GetColour">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxColour"/>
+    <use-retval/>
+    <pure/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- virtual void wxStatusBar::SetStatusText (const wxstring &text, int n = 0) -->
+  <function name="wxStatusBar::SetStatusText">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="0">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- virtual void wxStatusBar::SetStatusStyles (int n, const int * styles)-->
+  <function name="wxStatusBar::SetStatusStyles">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
+  <!-- virtual void wxStatusBar::SetMinHeight(int height) -->
+  <function name="wxStatusBar::SetMinHeight">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- void wxStatusBar::PopStatusText(int field = 0)-->
+  <function name="wxStatusBar::PopStatusText">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- virtual void wxStatusBar::PushStatusText (const wxString & string, int field = 0) -->
+  <function name="wxStatusBar::PushStatusText">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- virtual void wxStatusBar::SetFieldsCount (int number = 1, const int * widths = NULL) -->
+  <function name="wxStatusBar::SetFieldsCount">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" default="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>1:</valid>
+    </arg>
+    <arg nr="2" default="NULL" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxDC::DrawLine (const wxPoint &pt1, const wxPoint &pt2) -->
+  <!-- void wxMemoryDC::DrawLine (const wxPoint &pt1, const wxPoint &pt2) -->
+  <!-- void wxBufferedDC::DrawLine (const wxPoint &pt1, const wxPoint &pt2) -->
+  <!-- void wxPaintDC::DrawLine (const wxPoint &pt1, const wxPoint &pt2) -->
+  <!-- void wxBufferedPaintDC::DrawLine (const wxPoint &pt1, const wxPoint &pt2) -->
+  <!-- void wxClientDC::DrawLine (const wxPoint &pt1, const wxPoint &pt2) -->
+  <function name="wxDC::DrawLine,wxMemoryDC::DrawLine,wxBufferedDC::DrawLine,wxPaintDC::DrawLine,wxBufferedPaintDC::DrawLine,wxClientDC::DrawLine">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- void wxDC::DrawRectangle (const wxPoint & pt, const wxSize & sz) -->
+  <!-- void wxMemoryDC::DrawRectangle (const wxPoint & pt, const wxSize & sz) -->
+  <!-- void wxBufferedDC::DrawRectangle (const wxPoint & pt, const wxSize & sz) -->
+  <!-- void wxBufferedPaintDC::DrawRectangle (const wxPoint & pt, const wxSize & sz) -->
+  <!-- void wxClientDC::DrawRectangle (const wxPoint & pt, const wxSize & sz) -->
+  <!-- void wxPaintDC::DrawRectangle (const wxPoint & pt, const wxSize & sz) -->
+  <!-- void wxBufferedPaintDC::DrawRectangle (const wxPoint & pt, const wxSize & sz) -->
+  <function name="wxDC::DrawRectangle,wxMemoryDC::DrawRectangle,wxBufferedDC::DrawRectangle,wxBufferedPaintDC::DrawRectangle,wxClientDC::DrawRectangle,wxPaintDC::DrawRectangle,wxBufferedPaintDC::DrawRectangle">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- bool wxDC::Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height, wxDC * source, wxCoord xsrc, wxCoord ysrc, wxRasterOperationMode logicalFunc = wxCOPY,
+                       bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord) -->
+  <!-- bool wxMemoryDC::Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height, wxDC * source, wxCoord xsrc, wxCoord ysrc, wxRasterOperationMode logicalFunc = wxCOPY,
+                       bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord) -->
+  <!-- bool wxBufferedDC::Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height, wxDC * source, wxCoord xsrc, wxCoord ysrc, wxRasterOperationMode logicalFunc = wxCOPY,
+                       bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord) -->
+  <!-- bool wxBufferedPaintDC::Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height, wxDC * source, wxCoord xsrc, wxCoord ysrc, wxRasterOperationMode logicalFunc = wxCOPY,
+                       bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord) -->
+  <!-- bool wxGCDC::Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height, wxDC * source, wxCoord xsrc, wxCoord ysrc, wxRasterOperationMode logicalFunc = wxCOPY,
+                       bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord) -->
+  <!-- bool wxPaintDC::Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height, wxDC * source, wxCoord xsrc, wxCoord ysrc, wxRasterOperationMode logicalFunc = wxCOPY,
+                       bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord) -->
+  <function name="wxDC::Blit,wxMemoryDC::Blit,wxBufferedDC::Blit,wxBufferedPaintDC::Blit,wxGCDC::Blit,wxPaintDC::Blit">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="7" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="8" direction="in" default="wxCOPY">
+      <not-uninit/>
+    </arg>
+    <arg nr="9" direction="in" default="false">
+      <not-uninit/>
+    </arg>
+    <arg nr="10" direction="in" default="wxDefaultCoord">
+      <not-uninit/>
+    </arg>
+    <arg nr="11" direction="in" default="wxDefaultCoord">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxDC::DrawPolygon(int n, const wxPoint points[], wxCoord xoffset = 0, wxCoord yoffset = 0, wxPolygonFillMode fill_style = wxODDEVEN_RULE) -->
+  <!-- void wxMemoryDC::DrawPolygon(int n, const wxPoint points[], wxCoord xoffset = 0, wxCoord yoffset = 0, wxPolygonFillMode fill_style = wxODDEVEN_RULE) -->
+  <!-- void wxBufferedDC::DrawPolygon(int n, const wxPoint points[], wxCoord xoffset = 0, wxCoord yoffset = 0, wxPolygonFillMode fill_style = wxODDEVEN_RULE) -->
+  <!-- void wxBufferedPaintDC::DrawPolygon(int n, const wxPoint points[], wxCoord xoffset = 0, wxCoord yoffset = 0, wxPolygonFillMode fill_style = wxODDEVEN_RULE) -->
+  <!-- void wxPaintDC::DrawPolygon(int n, const wxPoint points[], wxCoord xoffset = 0, wxCoord yoffset = 0, wxPolygonFillMode fill_style = wxODDEVEN_RULE) -->
+  <function name="wxDC::DrawPolygon,wxMemoryDC::DrawPolygon,wxBufferedDC::DrawPolygon,wxBufferedPaintDC::DrawPolygon,wxPaintDC::DrawPolygon">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in" default="0">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in" default="0">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="in" default="wxODDEVEN_RULE">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void wxDC::DrawLabel(const wxString & text, const wxRect & rect, int alignment = wxALIGN_LEFT|wxALIGN_TOP, int indexAccel = -1) -->
+  <!-- void wxMemoryDC::DrawLabel(const wxString & text, const wxRect & rect, int alignment = wxALIGN_LEFT|wxALIGN_TOP, int indexAccel = -1) -->
+  <!-- void wxBufferedDC::DrawLabel(const wxString & text, const wxRect & rect, int alignment = wxALIGN_LEFT|wxALIGN_TOP, int indexAccel = -1) -->
+  <!-- void wxBufferedPaintDC::DrawLabel(const wxString & text, const wxRect & rect, int alignment = wxALIGN_LEFT|wxALIGN_TOP, int indexAccel = -1) -->
+  <function name="wxDC::DrawLabel,wxMemoryDC::DrawLabel,wxBufferedDC::DrawLabel,wxBufferedPaintDC::DrawLabel">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" direction="in" default="wxALIGN_LEFT|wxALIGN_TOP">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="in" default="-1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxPropertyGrid* wxPropertyGridManager::GetGrid(void) -->
+  <function name="wxPropertyGridManager::GetGrid">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxPropertyGrid *"/>
+  </function>
+  <!-- wxPGProperty * wxPropertyGridInterface::Append( wxPGProperty * property ) -->
+  <!-- wxPGProperty * wxPropertyGridManager::Append( wxPGProperty * property ) -->
+  <function name="wxPropertyGridInterface::Append,wxPropertyGridManager::Append">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxPGProperty *"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
+  <!-- wxPGChoiceEntry & wxPGChoices::Add( const wxPGChoiceEntry & entry ) -->
+  <function name="wxPGChoices::Add">
+    <noreturn>false</noreturn>
+    <returnValue type="wxPGChoiceEntry &amp;"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxPGProperty* wxPropertyGridInterface::GetProperty(const wxString & name) const -->
+  <!-- wxPGProperty* wxPropertyGrid::GetProperty(const wxString & name) const -->
+  <function name="wxPropertyGridInterface::GetProperty,wxPropertyGrid::GetProperty">
+    <noreturn>false</noreturn>
+    <returnValue type="wxPGProperty*"/>
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxGraphicsContext::SetPen(const wxPen & pen) -->
+  <!-- void wxDC::SetPen(const wxPen & pen) -->
+  <!-- void wxDC::SetBrush(const wxBrush & pen) -->
+  <!-- void wxDC::SetFont(const wxFont & font) -->
+  <!-- void wxBufferedPaintDC::SetPen(const wxPen & pen) -->
+  <!-- void wxBufferedPaintDC::SetBrush(const wxBrush & pen) -->
+  <!-- void wxBufferedPaintDC::SetFont(const wxFont & font) -->
+  <!-- void wxPaintDC::SetPen(const wxPen & pen) -->
+  <!-- void wxPaintDC::SetBrush(const wxBrush & pen) -->
+  <!-- void wxPaintDC::SetFont(const wxFont & font) -->
+  <!-- void wxMemoryDC::SetPen(const wxPen & pen) -->
+  <!-- void wxMemoryDC::SetBrush(const wxBrush & pen) -->
+  <!-- void wxMemoryDC::SetFont(const wxFont & font) -->
+  <!-- void wxBufferedDC::SetPen(const wxPen & pen) -->
+  <!-- void wxBufferedDC::SetBrush(const wxBrush & pen) -->
+  <!-- void wxBufferedDC::SetFont(const wxFont & font) -->
+  <!-- void wxClientDC::SetPen(const wxPen & pen) -->
+  <!-- void wxClientDC::SetBrush(const wxBrush & pen) -->
+  <!-- void wxClientDC::SetFont(const wxFont & font) -->
+  <!-- void wxGCDC::SetPen(const wxPen & pen) -->
+  <!-- void wxGCDC::SetBrush(const wxBrush & pen) -->
+  <!-- void wxGCDC::SetFont(const wxFont & font) -->
+  <!-- void wxAutoBufferedPaintDC::SetPen(const wxPen & pen) -->
+  <!-- void wxAutoBufferedPaintDC::SetBrush(const wxBrush & pen) -->
+  <!-- void wxAutoBufferedPaintDC::SetFont(const wxFont & font) -->
+  <function name="wxAutoBufferedPaintDC::SetFont,wxAutoBufferedPaintDC::SetBrush,wxAutoBufferedPaintDC::SetPen,wxGCDC::SetFont,wxGCDC::SetBrush,wxGCDC::SetPen,wxBufferedPaintDC::SetFont,wxBufferedPaintDC::SetBrush,wxBufferedPaintDC::SetPen,wxClientDC::SetPen,wxClientDC::SetBrush,wxClientDC::SetFont,wxPaintDC::SetPen,wxPaintDC::SetBrush,wxPaintDC::SetFont,wxGraphicsContext::SetPen,wxDC::SetPen,wxDC::SetBrush,wxDC::SetFont,wxMemoryDC::SetPen,wxMemoryDC::SetBrush,wxMemoryDC::SetFont,wxBufferedDC::SetPen,wxBufferedDC::SetBrush,wxBufferedDC::SetFont">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- @todo: void DrawBitmap (const wxBitmap &bitmap, wxCoord x, wxCoord y, bool useMask=false) -->
+  <!-- void wxDC::DrawBitmap (const wxBitmap &bmp, const wxPoint &pt, bool useMask=false) -->
+  <!-- void wxPaintDC::DrawBitmap(const wxBitmap &bmp, const wxPoint &pt, bool useMask=false) -->
+  <!-- void wxClientDC::DrawBitmap(const wxBitmap &bmp, const wxPoint &pt, bool useMask=false) -->
+  <!-- void wxMemoryDC::DrawBitmap(const wxBitmap &bmp, const wxPoint &pt, bool useMask=false) -->
+  <!-- void wxAutoBufferedPaintDC::DrawBitmap(const wxBitmap &bmp, const wxPoint &pt, bool useMask=false) -->
+  <function name="wxDC::DrawBitmap,wxPaintDC::DrawBitmap,wxClientDC::DrawBitmap,wxAutoBufferedPaintDC::DrawBitmap,wxMemoryDC::DrawBitmap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in" default="false">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxSizerItem* wxSizer::AddStretchSpacer (int prop = 1) -->
+  <!-- wxSizerItem* wxBoxSizer::AddStretchSpacer (int prop = 1) -->
+  <!-- wxSizerItem* wxStaticBoxSizer::AddStretchSpacer (int prop = 1) -->
+  <function name="wxSizer::AddStretchSpacer,wxBoxSizer::AddStretchSpacer,wxStaticBoxSizer::AddStretchSpacer">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxSizerItem *"/>
+    <arg nr="1" direction="in" default="1">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- void wxTextAttr::SetFont(const wxFont & font, int flags = wxTEXT_ATTR_FONT &~wxTEXT_ATTR_FONT_PIXEL_SIZE) -->
+  <function name="wxTextAttr::SetFont">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="wxTEXT_ATTR_FONT &amp;~wxTEXT_ATTR_FONT_PIXEL_SIZE">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- virtual bool wxAnimation::Load(wxInputStream & stream, wxAnimationType type = wxANIMATION_TYPE_ANY) -->
+  <function name="wxAnimation::Load">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="in" default="wxANIMATION_TYPE_ANY">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- virtual wxInputStream& wxInputStream::Read (void * buffer, size_t size) -->
+  <!-- virtual wxInputStream& wxInputStream::ReadAll (void * buffer, size_t size) -->
+  <function name="wxInputStream::Read,wxInputStream::ReadAll">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxInputStream &amp;"/>
+    <arg nr="1" direction="out">
+      <not-null/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <minsize type="argvalue" arg="1"/>
+    </arg>
+  </function>
+  <!-- void wxPropertyGridManager::SetSplitterPosition(int pos, int column = 0) -->
+  <function name="wxPropertyGridManager::SetSplitterPosition">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in" default="0">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- virtual bool wxWindow::SetForegroundColour(const wxColour & colour) -->
+  <!-- virtual bool wxWindow::SetBackgroundColour(const wxColour & colour) -->
+  <!-- virtual bool wxControl::SetForegroundColour(const wxColour & colour) -->
+  <!-- virtual bool wxControl::SetBackgroundColour(const wxColour & colour) -->
+  <!-- virtual bool wxDataViewListCtrl::SetForegroundColour(const wxColour & colour) -->
+  <!-- virtual bool wxDataViewListCtrl::SetBackgroundColour(const wxColour & colour) -->
+  <!-- virtual bool wxStaticText::SetForegroundColour(const wxColour & colour) -->
+  <!-- virtual bool wxStaticText::SetBackgroundColour(const wxColour & colour) -->
+  <!-- virtual bool wxButton::SetForegroundColour(const wxColour & colour) -->
+  <!-- virtual bool wxButton::SetBackgroundColour(const wxColour & colour) -->
+  <!-- virtual bool wxBitmapButton::SetForegroundColour(const wxColour & colour) -->
+  <!-- virtual bool wxBitmapButton::SetBackgroundColour(const wxColour & colour) -->
+  <!-- virtual bool wxToggleButton::SetForegroundColour(const wxColour & colour) -->
+  <!-- virtual bool wxToggleButton::SetBackgroundColour(const wxColour & colour) -->
+  <!-- virtual bool wxTextCtrl::SetForegroundColour(const wxColour & colour) -->
+  <!-- virtual bool wxTextCtrl::SetBackgroundColour(const wxColour & colour) -->
+  <!-- virtual bool wxGrid::SetBackgroundColour(const wxColour & colour) -->
+  <function name="wxBitmapButton::SetBackgroundColour,wxBitmapButton::SetForegroundColour,wxDataViewListCtrl::SetBackgroundColour,wxDataViewListCtrl::SetForegroundColour,wxControl::SetBackgroundColour,wxControl::SetForegroundColour,wxToggleButton::SetBackgroundColour,wxToggleButton::SetForegroundColour,wxTextCtrl::SetForegroundColour,wxGrid::SetBackgroundColour,wxTextCtrl::SetBackgroundColour,wxWindow::SetForegroundColour,wxWindow::SetBackgroundColour,wxStaticText::SetForegroundColour,wxStaticText::SetBackgroundColour,wxButton::SetForegroundColour,wxButton::SetBackgroundColour">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxImage& wxImage::Rescale(int width, int height, wxImageResizeQuality quality = wxIMAGE_QUALITY_NORMAL) -->
+  <function name="wxImage::Rescale">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxImage &amp;"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in" default="wxIMAGE_QUALITY_NORMAL">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool wxGrid::DeleteRows( int pos = 0, int numRows = 1, bool updateLabels = true ) -->
+  <!-- bool wxGrid::DeleteCols( int pos = 0, int numCols = 1, bool updateLabels = true ) -->
+  <function name="wxGrid::DeleteRows,wxGrid::DeleteCols">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in" default="0">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in" default="1">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in" default="true">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxDC::DrawText( const wxString &amp; text, wxCoord x, wxCoord y ) -->
+  <!-- void wxPaintDC::DrawText( const wxString &amp; text, wxCoord x, wxCoord y ) -->
+  <!-- void wxClientDC::DrawText( const wxString &amp; text, wxCoord x, wxCoord y ) -->
+  <!-- void wxMemoryDC::DrawText( const wxString &amp; text, wxCoord x, wxCoord y ) -->
+  <function name="wxDC::DrawText,wxPaintDC::DrawText,wxClientDC::DrawText,wxMemoryDC::DrawText">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!--         void wxGraphicsContext::SetBrush(const wxBrush & brush) -->
+  <!-- virtual void wxGraphicsContext::SetBrush(const wxGraphicsBrush & brush) -->
+  <function name="wxGraphicsContext::SetBrush">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxGraphicsContext::DrawLines( size_t n, const wxPoint2DDouble * points, wxPolygonFillMode fillStyle = wxODDEVEN_RULE ) -->
+  <function name="wxGraphicsContext::DrawLines">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>1:</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="3" direction="in" default="wxODDEVEN_RULE">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void wxSpinCtrl::SetValue( const wxString & value ) -->
+  <!-- void wxSpinCtrl::SetValue( int value ) -->
+  <function name="wxSpinCtrl::SetValue">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSize wxDC::GetTextExtent( const wxString & string ) -->
+  <!-- wxSize wxPaintDC::GetTextExtent( const wxString & string ) -->
+  <!-- wxSize wxClientDC::GetTextExtent( const wxString & string ) -->
+  <!-- wxSize wxMemoryDC::GetTextExtent( const wxString & string ) -->
+  <function name="wxDC::GetTextExtent,wxPaintDC::GetTextExtent,wxClientDC::GetTextExtent,wxMemoryDC::GetTextExtent">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxSize"/>
+    <use-retval/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxString wxPathOnly(const wxString & path) -->
+  <function name="wxPathOnly">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSize wxBitmap::GetSize( void ) const -->
+  <!-- wxSize wxBitmap::GetLogicalSize( void ) const -->
+  <function name="wxBitmap::GetSize,wxBitmap::GetLogicalSize">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxSize"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- int wxBitmap::GetWidth( void ) const -->
+  <!-- int wxBitmap::GetHeight( void ) const -->
+  <function name="wxBitmap::GetWidth,wxBitmap::GetHeight">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="int"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- double wxBitmap::GetLogicalHeight( void ) const -->
+  <!-- double wxBitmap::GetLogicalWidth( void ) const -->
+  <!-- double wxBitmap::GetScaleFactor( void ) const -->
+  <function name="wxBitmap::GetLogicalHeight,wxBitmap::GetLogicalWidth,wxBitmap::GetScaleFactor">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="double"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- bool wxBitmap::HasAlpha( void ) const -->
+  <!-- bool wxBitmap::IsOk( void ) const -->
+  <!-- bool wxTreeListItem::IsOk( void ) const -->
+  <function name="wxBitmap::HasAlpha,wxBitmap::IsOk,wxTreeListItem::IsOk">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="bool"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- void wxGridCellAttr::GetAlignment( int * hAlign, int * vAlign ) -->
+  <function name="wxGridCellAttr::GetAlignment">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="out"/>
+    <arg nr="2" direction="out"/>
+  </function>
+  <!-- unsigned int wxPGChoices::GetCount( void ) const -->
+  <function name="wxPGChoices::GetCount">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="unsigned int"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- wxArrayString wxPGPropertyFlags::wxPGChoices::GetLabels( void ) const -->
+  <function name="wxPGPropertyFlags::wxPGChoices::GetLabels">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxArrayString"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- bool wxPGChoices::IsOk( void ) const -->
+  <function name="wxPGChoices::IsOk">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="bool"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- virtual void wxGridCellRenderer::Draw(wxGrid &grid, wxGridCellAttr &attr, wxDC &dc, const wxRect &rect, int row, int col, bool isSelected) -->
+  <!-- virtual void wxGridCellStringRenderer::Draw (wxGrid &grid, wxGridCellAttr &attr, wxDC &dc, const wxRect &rect, int row, int col, bool isSelected) -->
+  <!-- virtual void wxGridCellBoolRenderer::Draw (wxGrid &grid, wxGridCellAttr &attr, wxDC &dc, const wxRect &rect, int row, int col, bool isSelected) -->
+  <!-- virtual void wxGridCellAutoWrapStringRenderer::Draw (wxGrid &grid, wxGridCellAttr &attr, wxDC &dc, const wxRect &rect, int row, int col, bool isSelected) -->
+  <!-- virtual void wxGridCellEnumRenderer::Draw (wxGrid &grid, wxGridCellAttr &attr, wxDC &dc, const wxRect &rect, int row, int col, bool isSelected) -->
+  <!-- virtual void wxGridCellFloatRenderer::Draw (wxGrid &grid, wxGridCellAttr &attr, wxDC &dc, const wxRect &rect, int row, int col, bool isSelected) -->
+  <!-- virtual void wxGridCellNumberRenderer::Draw (wxGrid &grid, wxGridCellAttr &attr, wxDC &dc, const wxRect &rect, int row, int col, bool isSelected) -->
+  <function name="wxGridCellRenderer::Draw,wxGridCellStringRenderer::Draw,wxGridCellBoolRenderer::Draw,wxGridCellAutoWrapStringRenderer::Draw,wxGridCellEnumRenderer::Draw,wxGridCellFloatRenderer::Draw,wxGridCellNumberRenderer::Draw">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout"/>
+    <arg nr="2" direction="inout"/>
+    <arg nr="3" direction="inout"/>
+    <arg nr="4" direction="in"/>
+    <arg nr="5" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="6" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="7" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool wxGridCellEditor::IsAcceptedKey( wxKeyEvent & event ) -->
+  <function name="wxGridCellEditor::IsAcceptedKey">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <arg nr="1" direction="inout"/>
+  </function>
+  <!-- void wxDC::SetTextForeground( const wxColour & colour ) -->
+  <!-- void wxDC::SetTextBackground( const wxColour & colour ) -->
+  <!-- void wxBufferedPaintDC::SetTextForeground( const wxColour & colour ) -->
+  <!-- void wxBufferedPaintDC::SetTextBackground( const wxColour & colour ) -->
+  <!-- void wxPaintDC::SetTextForeground( const wxColour & colour ) -->
+  <!-- void wxPaintDC::SetTextBackground( const wxColour & colour ) -->
+  <!-- void wxAutoBufferedPaintDC::SetTextForeground( const wxColour & colour ) -->
+  <!-- void wxAutoBufferedPaintDC::SetTextBackground( const wxColour & colour ) -->
+  <!-- void wxMemoryDC::SetTextForeground( const wxColour & colour ) -->
+  <!-- void wxMemoryDC::SetTextBackground( const wxColour & colour ) -->
+  <function name="wxMemoryDC::SetTextBackground,wxMemoryDC::SetTextForeground,wxAutoBufferedPaintDC::SetTextBackground,wxAutoBufferedPaintDC::SetTextForeground,wxPaintDC::SetTextBackground,wxPaintDC::SetTextForeground,wxDC::SetTextForeground,wxDC::SetTextBackground,wxBufferedPaintDC::SetTextForeground,wxBufferedPaintDC::SetTextBackground">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxGridCellAttr::SetFont(const wxFont & font) -->
+  <function name="wxGridCellAttr::SetFont">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1"/>
+  </function>
+  <!-- void wxGridCellAttr::GetSize(int * num_rows, int * num_cols) const-->
+  <function name="wxGridCellAttr::GetSize">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <const/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- wxGridCellEditorPtr wxGridCellAttr::GetEditorPtr( const wxGrid * grid, int row, int col ) const -->
+  <function name="wxGridCellAttr::GetEditorPtr">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxGridCellEditorPtr"/>
+      <const/>
+      <arg nr="1" direction="inout">
+      </arg>
+      <arg nr="2" direction="in">
+          <not-uninit/>
+      </arg>
+      <arg nr="3" direction="in">
+          <not-uninit/>
+      </arg>
+  </function>
+  <!-- wxGridFitMode wxGridCellAttr::GetFitMode( void ) const -->
+  <function name="wxGridCellAttr::GetFitMode">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxGridFitMode"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- const wxFont & wxGridCellAttr::GetFont( void ) const -->
+  <!-- const wxFont & wxPropertyGrid::GetFont( void ) const -->
+  <function name="wxGridCellAttr::GetFont,wxPropertyGrid::GetFont">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="const wxFont &amp;"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- wxColour wxPropertyGrid::GetCellBackgroundColour( void ) const -->
+  <!-- wxColour wxPropertyGrid::GetCellDisabledTextColour( void ) const -->
+  <!-- wxColour wxPropertyGrid::GetCellTextColour( void ) const -->
+  <!-- wxColour wxPropertyGrid::GetSelectionBackgroundColour( void ) const -->
+  <function name="wxPropertyGrid::GetCellDisabledTextColour,wxPropertyGrid::GetCellTextColour,wxPropertyGrid::GetSelectionBackgroundColour,wxPropertyGrid::GetCellBackgroundColour">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxColour"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- wxAttrKind wxGridCellAttr::GetKind( void ) -->
+  <function name="wxGridCellAttr::GetKind">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxAttrKind"/>
+      <use-retval/>
+  </function>
+  <!-- void wxGridCellAttr::GetNonDefaultAlignment( int * hAlign, int * vAlign ) const -->
+  <function name="wxGridCellAttr::GetNonDefaultAlignment">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="void"/>
+      <const/>
+      <arg nr="1" direction="inout">
+      </arg>
+      <arg nr="2" direction="inout">
+      </arg>
+  </function>
+  <!-- bool wxGridCellAttr::GetOverflow( void ) const -->
+  <function name="wxGridCellAttr::GetOverflow">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="bool"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- wxGridCellRenderer * wxGridCellAttr::GetRenderer( const wxGrid * grid, int row, int col ) const -->
+  <function name="wxGridCellAttr::GetRenderer">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxGridCellRenderer *"/>
+      <const/>
+      <arg nr="1" direction="inout">
+      </arg>
+      <arg nr="2" direction="in">
+          <not-uninit/>
+      </arg>
+      <arg nr="3" direction="in">
+          <not-uninit/>
+      </arg>
+  </function>
+  <!-- wxGridCellRendererPtr wxGridCellAttr::GetRendererPtr( const wxGrid * grid, int row, int col ) const -->
+  <function name="wxGridCellAttr::GetRendererPtr">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxGridCellRendererPtr"/>
+      <const/>
+      <arg nr="1" direction="inout">
+      </arg>
+      <arg nr="2" direction="in">
+          <not-uninit/>
+      </arg>
+      <arg nr="3" direction="in">
+          <not-uninit/>
+      </arg>
+  </function>
+  <!-- virtual wxStatusBar* wxFrameBase::CreateStatusBar(int number = 1, long style = wxSTB_DEFAULT_STYLE, wxWindowID id = 0, const wxString & name = wxStatusBarNameStr)-->
+  <!-- virtual wxStatusBar* wxFrame::CreateStatusBar(int number = 1, long style = wxSTB_DEFAULT_STYLE, wxWindowID id = 0, const wxString & name = wxStatusBarNameStr)-->
+  <function name="wxFrameBase::CreateStatusBar,wxFrame::CreateStatusBar">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxStatusBar*"/>
+    <arg nr="1" default="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" default="wxSTB_DEFAULT_STYLE" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" default="wxStatusBarNameStr" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxMemoryDC::SelectObject( wxBitmap & bmp ) -->
+  <!-- void wxBufferedDC::SelectObject( wxBitmap & bmp ) -->
+  <function name="wxMemoryDC::SelectObject,wxBufferedDC::SelectObject">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxTextEntry::AppendText( const wxString & text ) -->
+  <!-- void wxTextEntry::WriteText( const wxString & text ) -->
+  <!-- void wxTextCtrl::AppendText( const wxString & text ) -->
+  <!-- void wxTextCtrl::WriteText( const wxString & text ) -->
+  <!-- void wxStyledTextCtrl::AppendText( const wxString & text ) -->
+  <function name="wxTextEntry::AppendText,wxTextEntry::WriteText,wxTextCtrl::AppendText,wxTextCtrl::WriteText,wxStyledTextCtrl::AppendText">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int wxString::Cmp(const wxString & s) const -->
+  <!-- int wxString::CmpNoCase( const wxString & s ) const -->
+  <function name="wxString::CmpNoCase,wxString::Cmp">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <const/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxGridCellCoords wxGrid::XYToCell(int x, int y) const -->
+  <function name="wxGrid::XYToCell">
+    <noreturn>false</noreturn>
+    <returnValue type="wxGridCellCoords"/>
+    <const/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- virtual void wxMenuItem::SetBitmap(const wxBitmap & bmp, bool checked = true) -->
+  <function name="wxMenuItem::SetBitmap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="true">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!--         bool wxMenuItem::IsCheck() const -->
+  <!--         bool wxMenuItem::IsCheckable() const -->
+  <!--         bool wxMenuItem::IsRadio() const -->
+  <!--         bool wxMenuItem::IsSeparator() const -->
+  <!--         bool wxMenuItem::IsSubMenu() const -->
+  <!-- virtual bool wxMenuItem::IsChecked() const -->
+  <!-- virtual bool wxMenuItem::IsEnabled() const -->
+  <function name="wxMenuItem::IsCheck,wxMenuItem::IsCheckable,wxMenuItem::IsRadio,wxMenuItem::IsSeparator,wxMenuItem::IsSubMenu,wxMenuItem::IsChecked,wxMenuItem::IsEnabled">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <const/>
+    <use-retval/>
+  </function>
+  <!-- bool wxTextCtrl::SetDefaultStyle( const wxTextAttr & style ) -->
+  <function name="wxTextCtrl::SetDefaultStyle">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <!-- const wxTextAttr & style -->
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxString wxString::BeforeFirst( wxUniChar ch, wxString * rest = NULL ) -->
+  <function name="wxString::BeforeFirst">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="out" default="NULL">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxPaintDC::DrawCircle( wxCoord x, wxCoord y, wxCoord radius ) -->
+  <!-- void wxDC::DrawCircle( wxCoord x, wxCoord y, wxCoord radius ) -->
+  <!-- void wxAutoBufferedPaintDC::DrawCircle( wxCoord x, wxCoord y, wxCoord radius ) -->
+  <!-- void wxMemoryDC::DrawCircle( wxCoord x, wxCoord y, wxCoord radius ) -->
+  <function name="wxAutoBufferedPaintDC::DrawCircle,wxDC::DrawCircle,wxPaintDC::DrawCircle,wxMemoryDC::DrawCircle">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxDC::DrawArc(wxCoord xStart, wxCoord yStart, wxCoord xEnd, wxCoord yEnd, wxCoord xc, wxCoord yc) -->
+  <!-- void wxPaintDC::DrawArc(wxCoord xStart, wxCoord yStart, wxCoord xEnd, wxCoord yEnd, wxCoord xc, wxCoord yc) -->
+  <!-- void wxAutoBufferedPaintDC::DrawArc(wxCoord xStart, wxCoord yStart, wxCoord xEnd, wxCoord yEnd, wxCoord xc, wxCoord yc) -->
+  <!-- void wxMemoryDC::DrawArc(wxCoord xStart, wxCoord yStart, wxCoord xEnd, wxCoord yEnd, wxCoord xc, wxCoord yc) -->
+  <function name="wxAutoBufferedPaintDC::DrawArc,wxDC::DrawArc,wxPaintDC::DrawArc,wxMemoryDC::DrawArc">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="any" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxPaintDC::DrawCheckMark(wxCoord x,wxCoord y, wxCoord width, wxCoord height) -->
+  <!-- void wxDC::DrawCheckMark(wxCoord x,wxCoord y, wxCoord width, wxCoord height) -->
+  <!-- void wxAutoBufferedPaintDC::DrawCheckMark(wxCoord x,wxCoord y, wxCoord width, wxCoord height) -->
+  <function name="wxAutoBufferedPaintDC::DrawCheckMark,wxDC::DrawCheckMark,wxPaintDC::DrawCheckMark">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="any" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- const wxColour & wxGrid::GetBackgroundColour( void ) const -->
+  <!-- const wxColour & wxGridCellAttr::GetBackgroundColour( void ) const -->
+  <function name="wxGridCellAttr::GetBackgroundColour,wxGrid::GetBackgroundColour">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="const wxColour &amp;"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- int wxGridCellCoords::GetCol( void ) const -->
+  <!-- int wxGridCellCoords::GetRow( void ) const -->
+  <function name="wxGridCellCoords::GetCol,wxGridCellCoords::GetRow">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="int"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- wxColour wxGrid::GetCellBackgroundColour (int row, int col) const -->
+  <!-- wxColour wxGrid::GetCellFont (int row, int col) const -->
+  <function name="wxGrid::GetCellBackgroundColour,wxGrid::GetCellFont">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxColour"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- int wxGrid::GetColSize(int col) const -->
+  <!-- int wxGrid::GetColLeft(int col) const -->
+  <!-- int wxGrid::GetColRight(int col) const -->
+  <!-- int wxGrid::GetColPos(int col) const -->
+  <!-- int wxGrid::GetColMinimalWidth(int col) const -->
+  <function name="wxGrid::GetColSize,wxGrid::GetColLeft,wxGrid::GetColRight,wxGrid::GetColPos,wxGrid::GetColMinimalWidth">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- bool wxGrid::IsColShown(int col) const -->
+  <!-- bool wxGrid::IsRowShown(int row) const -->
+  <function name="wxGrid::IsColShown,wxGrid::IsRowShown">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- wxGridSizesInfo wxGrid::GetColSizes(void) const -->
+  <function name="wxGrid::GetColSizes">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxGridSizesInfo"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- int wxGrid::GetColMinimalAcceptableWidth(void) const -->
+  <function name="wxGrid::GetColMinimalAcceptableWidth">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxString wxDataViewListCtrl::GetTextValue(unsigned int row, unsigned int col) const  -->
+  <function name="wxDataViewListCtrl::GetTextValue">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- bool wxDataViewListCtrl::GetToggleValue(unsigned int row, unsigned int col) const  -->
+  <function name="wxDataViewListCtrl::GetToggleValue">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- void wxDC::SetBackgroundMode(int mode) -->
+  <!-- void wxBufferedDC::SetBackgroundMode(int mode) -->
+  <!-- void wxGCDC::SetBackgroundMode(int mode) -->
+  <function name="wxDC::SetBackgroundMode,wxBufferedDC::SetBackgroundMode,wxGCDC::SetBackgroundMode">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- virtual void wxWindow::SetValidator(const wxValidator & validator) -->
+  <!-- virtual void wxTextCtrl::SetValidator(const wxValidator & validator) -->
+  <!-- virtual void wxGridCellTextEditor::SetValidator(const wxValidator & validator) -->
+  <!-- virtual void wxGridCellFloatEditor::SetValidator(const wxValidator & validator) -->
+  <!-- virtual void wxCheckBox::SetValidator(const wxValidator & validator) -->
+  <function name="wxWindow::SetValidator,wxTextCtrl::SetValidator,wxGridCellTextEditor::SetValidator,wxGridCellFloatEditor::SetValidator,wxCheckBox::SetValidator">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxInfoBar::ShowMessage(const wxString & msg, int flags = wxICON_INFORMATION)-->
+  <function name="wxInfoBar::ShowMessage">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="wxICON_INFORMATION">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- virtual void wxPen::SetColour(const wxColour & colour) -->
+  <!-- virtual void wxPen::SetColour(unsigned char red, unsigned char green, unsigned char blue) -->
+  <function name="wxPen::SetColour">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="any" direction="in"/>
+  </function>
+  <!-- void wxPen::SetWidth( int width ) -->
+  <function name="wxPen::SetWidth">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+  </function>
+  <!-- virtual int wxDialog::ShowModal( ) -->
+  <!-- virtual int wxColourDialog::ShowModal( ) -->
+  <!-- virtual int wxDirDialog::ShowModal( ) -->
+  <!-- virtual int wxFileDialog::ShowModal( ) -->
+  <!-- virtual int wxFindReplaceDialog::ShowModal( ) -->
+  <!-- virtual int wxFontDialog::ShowModal( ) -->
+  <!-- virtual int wxGenericProgressDialog::ShowModal( ) -->
+  <!-- virtual int wxProgressDialog::ShowModal( ) -->
+  <!-- virtual int wxHtmlDialog::ShowModal( ) -->
+  <!-- virtual int wxMessageDialog::ShowModal( ) -->
+  <!-- virtual int wxMultiChoiceDialog::ShowModal( ) -->
+  <!-- virtual int wxNumberEntryDialog::ShowModal( ) -->
+  <!-- virtual int wxPGArrayEditorDialog::ShowModal( ) -->
+  <!-- virtual int wxPGArrayStringEditorDialog::ShowModal( ) -->
+  <!-- virtual int wxPrintAbortDialog::ShowModal( ) -->
+  <!-- virtual int wxPropertySheetDialog::ShowModal( ) -->
+  <!-- virtual int wxRichTextFormattingDialog::ShowModal( ) -->
+  <!-- virtual int wxRearrangeDialog::ShowModal( ) -->
+  <!-- virtual int wxRichTextStyleOrganiserDialog::ShowModal( ) -->
+  <!-- virtual int wxSingleChoiceDialog::ShowModal( ) -->
+  <!-- virtual int wxSymbolPickerDialog::ShowModal( ) -->
+  <!-- virtual int wxTextEntryDialog::ShowModal( ) -->
+  <!-- virtual int wxPasswordEntryDialog::ShowModal( ) -->
+  <!-- virtual int wxWizard::ShowModal( ) -->
+  <function name="wxDialog::ShowModal,wxWizard::ShowModal,wxPasswordEntryDialog::ShowModal,wxTextEntryDialog::ShowModal,wxSymbolPickerDialog::ShowModal,wxSingleChoiceDialog::ShowModal,wxRichTextStyleOrganiserDialog::ShowModal,wxRearrangeDialog::ShowModal,wxRichTextFormattingDialog::ShowModal,wxPropertySheetDialog::ShowModal,wxPrintAbortDialog::ShowModal,wxPGArrayStringEditorDialog::ShowModal,wxPGArrayEditorDialog::ShowModal,wxNumberEntryDialog::ShowModal,wxMultiChoiceDialog::ShowModal,wxMessageDialog::ShowModal,wxHtmlDialog::ShowModal,wxProgressDialog::ShowModal,wxGenericProgressDialog::ShowModal,wxFontDialog::ShowModal,wxFindReplaceDialog::ShowModal,wxColourDialog::ShowModal,wxDirDialog::ShowModal,wxFileDialog::ShowModal">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <leak-ignore/>
+  </function>
+  <!-- void wxDC::SetBackground(const wxBrush & brush) -->
+  <!-- void wxBufferedDC::SetBackground(const wxBrush & brush) -->
+  <!-- void wxMemoryDC::SetBackground(const wxBrush & brush) -->
+  <!-- void wxGCDC::SetBackground(const wxBrush & brush) -->
+  <!-- void wxAutoBufferedPaintDC::SetBackground(const wxBrush & brush) -->
+  <function name="wxDC::SetBackground,wxBufferedDC::SetBackground,wxMemoryDC::SetBackground,wxGCDC::SetBackground,wxAutoBufferedPaintDC::SetBackground">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxPropertyGridManager::SetColumnTitle( int idx, const wxString & title ) -->
+  <function name="wxPropertyGridManager::SetColumnTitle">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxRect & wxRect::Inflate( const wxSize & d ) -->
+  <!-- wxRect & wxRect::Deflate( const wxSize & d ) -->
+  <function name="wxRect::Inflate,wxRect::Deflate">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxRect &amp;"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxStyledTextCtrl::StyleSetForeground( int style, const wxColour & fore ) -->
+  <function name="wxStyledTextCtrl::StyleSetForeground">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxString wxString::AfterFirst( wxUniChar ch ) const -->
+  <!-- wxString wxString::AfterLast( wxUniChar ch ) const -->
+  <function name="wxString::AfterFirst,wxString::AfterLast">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxString"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString & wxString::Append (const char *psz)                    -->
+  <!-- wxString & wxString::Append (const wchar_t *pwz)                 -->
+  <!-- wxString & wxString::Append (const char *psz, size_t nLen)    (*)-->
+  <!-- wxString & wxString::Append (const wchar_t *pwz, size_t nLen) (*)-->
+  <!-- wxString & wxString::Append (const wxString &s)               (+)-->
+  <!-- wxString & wxString::Append (wxUniChar ch, size_t count=1u)   (*)-->
+  <!-- wxString & wxString::append (const char *psz)                    -->
+  <!-- wxString & wxString::append (const wchar_t *pwz)                 -->
+  <!-- wxString & wxString::append (const char *psz, size_t nLen)    (*)-->
+  <!-- wxString & wxString::append (const wchar_t *pwz, size_t nLen) (*)-->
+  <!-- wxString & wxString::append (const wxString &s)               (+)-->
+  <!-- wxString & wxString::append (wxUniChar ch, size_t count=1u)   (*)-->
+  <!-- wxString & wxString::append (const_iterator first, const_iterator last) (*)-->
+  <function name="wxString::Append,wxString::append">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxString &amp;"/>
+    <arg nr="1" direction="in">
+      <!-- <not-uninit/> Avoid FPs (+)-->
+      <not-null/>
+    </arg>
+    <!--(*) 2.arg version not supported -->
+  </function>
+  <!-- wxWindow * wxWindowBase::FindWindow(long id) const -->
+  <!-- wxWindow * wxWindowBase::FindWindow(const wxString & name)  const -->
+  <!-- wxWindow * wxWindow::FindWindow(long id) const -->
+  <!-- wxWindow * wxWindow::FindWindow(const wxString & name)  const -->
+  <!-- wxWindow * wxDialog::FindWindow(long id) const -->
+  <!-- wxWindow * wxDialog::FindWindow(const wxString & name)  const -->
+  <function name="wxWindowBase::FindWindow,wxWindow::FindWindow,wxDialog::FindWindow">
+    <noreturn>false</noreturn>
+    <returnValue type="wxWindow *"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!--static wxWindow* wxWindow::FindWindowById(long id, const wxWindow * parent = 0) -->
+  <function name="wxWindow::FindWindowById">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxWindow*"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in" default="0">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxRect::SetX( int xx ) -->
+  <!-- void wxRect::SetY( int yy ) -->
+  <function name="wxRect::SetX,wxRect::SetY">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxDateTime& wxDateTime::SetMinute( unsigned short minute ) -->
+  <function name="wxDateTime::SetMinute">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxDateTime &amp;"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <!-- Minutes in 0...59 range -->
+      <valid>0:59</valid>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxDateTime& wxDateTime::SetSecond( unsigned short second ) -->
+  <function name="wxDateTime::SetSecond">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxDateTime &amp;"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <!-- Seconds in 0...59 (60 with leap seconds) range -->
+      <valid>0:60</valid>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxDateTime& wxDateTime::SetHour( unsigned short second ) -->
+  <function name="wxDateTime::SetHour">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxDateTime &amp;"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <!-- Hours since midnight 0...23 -->
+      <valid>0:23</valid>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxDateTime& wxDateTime::SetYear( int year ) -->
+  <function name="wxDateTime::SetYear">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxDateTime &amp;"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxDateTime& wxDateTime::SetMonth( Month month ) -->
+  <function name="wxDateTime::SetMonth">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxDateTime &amp;"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <valid>1:12</valid>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxDateTime& wxDateTime::SetDay (unsigned short day) -->
+  <function name="wxDateTime::SetDay">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxDateTime &amp;"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <!-- Day of month in 1..31 range -->
+      <valid>1:31</valid>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxString wxDateTime::FormatISODate( void ) const -->
+  <!-- wxString wxDateTime::FormatISOTime( void ) const -->
+  <!-- wxString wxDateTime::FormatTime( void ) const -->
+  <function name="wxDateTime::FormatISODate,wxDateTime::FormatISOTime,wxDateTime::FormatTime">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <const/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+  </function>
+  <!-- void wxListItem::SetText( const wxString & text ) -->
+  <!-- void wxListItem::SetTextColour( const wxColour & colText ) -->
+  <function name="wxListItem::SetText,wxListItem::SetTextColour">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxWindow * wxGetTopLevelParent( wxWindowBase * win ) -->
+  <function name="wxGetTopLevelParent">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="wxWindow *"/>
+    <use-retval/>
+    <!-- wxWindowBase * win -->
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
+  <!-- wxString wxDateTime::Format(const wxString & format = wxDefaultDateTimeFormat, const TimeZone & tz = Local ) const-->
+  <function name="wxDateTime::Format">
+    <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in" default="wxDefaultDateTimeFormat"/>
+    <arg nr="2" direction="in" default="Local"/>
+  </function>
+  <!-- wxString wxDateTime::FormatISOCombined(char sep = 'T') const -->
+  <function name="wxDateTime::FormatISOCombined">
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxString"/>
+    <arg nr="1" direction="in" default="T">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- virtual bool wxImageList::Draw(int index, wxDC & dc, int x, int y, int flags = wxIMAGELIST_DRAW_NORMAL, bool solidBackground = false) -->
+  <function name="wxImageList::Draw">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" direction="in" default="wxIMAGELIST_DRAW_NORMAL">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="6" direction="in" default="false">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- virtual void wxWindow::Refresh(bool eraseBackground = true, const wxRect * rect = NULL) -->
+  <!-- virtual void wxPropertyGridManager::Refresh(bool eraseBackground = true, const wxRect * rect = NULL) -->
+  <function name="wxWindow::Refresh,wxPropertyGridManager::Refresh">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in" default="true">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in" default="NULL"/>
+  </function>
+  <!-- int wxImageList::Add( const wxBitmap & bitmap, const wxBitmap & mask = wxNullBitmap ) -->
+  <function name="wxImageList::Add">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="wxNullBitmap"/>
+  </function>
+  <!-- virtual wxPGVIterator wxPropertyGridInterface::GetVIterator(int flags) const -->
+  <!-- virtual wxPGVIterator wxPropertyGrid::GetVIterator(int flags) const -->
+  <function name="wxPropertyGridInterface::GetVIterator,wxPropertyGrid::GetVIterator">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <const/>
+    <returnValue type="wxPGVIterator"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxArrayString wxStringTokenize(const wxString & str, const wxString & delims = wxDEFAULT_DELIMITERS, wxStringTokenizerMode mode = wxTOKEN_DEFAULT) -->
+  <function name="wxStringTokenize">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxArrayString"/>
+    <use-retval/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="wxDEFAULT_DELIMITERS"/>
+    <arg nr="3" direction="in" default="wxTOKEN_DEFAULT"/>
+  </function>
+  <!-- ssize_t wxFile::Read( void * pBuf, size_t nCount ) -->
+  <function name="wxFile::Read">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="ssize_t"/>
+    <use-retval/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>1:</valid>
+    </arg>
+  </function>
+  <!-- static bool wxFile::Exists(const wxString & filename)-->
+  <!-- static bool wxDir::Exists(const wxString & dirname)-->
+  <function name="wxFile::Exists,wxDir::Exists">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxFile::Eof( void ) const -->
+  <function name="wxFile::Eof">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- bool wxFile::Seek( wxFileOffset ofs, wxSeekMode mode = wxFromStart ) -->
+  <function name="wxFFile::Seek">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="wxFromStart" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool wxFFile::SeekEnd( wxFileOffset ofs = 0 ) -->
+  <function name="wxFFile::SeekEnd">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void wxGridTableBase::SetValueAsDouble( int row, int col, double value ) -->
+  <!-- void wxGridTableBase::SetValueAsBool( int row, int col, bool value ) -->
+  <!-- void wxGridTableBase::SetValueAsLong( int row, int col, longs value ) -->
+  <function name="wxGridTableBase::SetValueAsDouble,wxGridTableBase::SetValueAsDouble,wxGridTableBase::SetValueAsLong">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxGridTableBase::SetValueAsLong( int row, int col, const wxString &value ) -->
+  <function name="wxGridTableBase::SetValue">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- bool wxGridTableBase::GetValueAsBool( int row, int col ) -->
+  <function name="wxGridTableBase::GetValueAsBool">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- double wxGridTableBase::GetValueAsDouble( int row, int col ) -->
+  <function name="wxGridTableBase::GetValueAsDouble">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="double"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- long wxGridTableBase::GetValueAsLong( int row, int col ) -->
+  <function name="wxGridTableBase::GetValueAsLong">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="long"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxString wxGridTableBase::GetValue( int row, int col ) -->
+  <function name="wxGridTableBase::GetValue">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool wxGridTableBase::CanSetValueAs( int row, int col, const wxString & typeName ) -->
+  <!-- bool wxGridTableBase::CanGetValueAs( int row, int col, const wxString & typeName ) -->
+  <function name="wxGridTableBase::CanSetValueAs,wxGridTableBase::CanGetValueAs">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- void wxPen::SetCap( wxPenCap cap ) -->
+  <function name="wxPen::SetCap">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!--static wxString wxLocale::GetInfo(wxLocaleInfo index, wxLocaleCategory cat = wxLOCALE_CAT_DEFAULT) -->
+  <function name="wxLocale::GetInfo">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="wxLOCALE_CAT_DEFAULT"/>
+  </function>
+  <!-- bool wxLocale::AddCatalog( const wxString & domain ) -->
+  <!-- bool wxLocale::AddCatalog( const wxString & domain, wxLanguage msgIdLanguage ) -->
+  <!-- bool wxLocale::AddCatalog( const wxString & domain, wxLanguage msgIdLanguage, const wxString msgldCharset ) -->
+  <function name="wxLocale::AddCatalog">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="wxLANGUAGE_DEFAULT "/>
+    <arg nr="3" direction="in" default="wxEmptyString"/>
+  </function>
+  <!-- int wxItemContainer::Append( const wxString & item ) -->
+  <!-- int wxComboBox::Append( const wxString & item ) -->
+  <function name="wxItemContainer::AppendItems,wxComboBox::Append">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- virtual void wxSlider::SetValue(int value) -->
+  <function name="wxSlider::SetValue">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void wxPGProperty::SetLabel(const wxString & label) -->
+  <function name="wxPGProperty::SetLabel">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxSize wxDC::GetSize( void ) const -->
+  <!-- void GetSize (wxCoord *width, wxCoord *height) const -->
+  <!-- wxSize wxDC::GetSizeMM( void ) const -->
+  <!-- void GetSizeMM (wxCoord *width, wxCoord *height) const -->
+  <!-- Derived classes: -->
+  <!-- wxSize wxGCDC::GetSizeMM( void ) const -->
+  <!-- wxSize wxGCDC::GetSize( void ) const -->
+  <!-- wxSize wxClientDC::GetSize( void ) const-->
+  <!-- wxSize wxClientDC::GetSizeMM( void ) const-->
+  <!-- wxSize wxPaintDC::GetSize( void ) const -->
+  <!-- wxSize wxPaintDC::GetSizeMM( void ) const -->
+  <!-- wxSize wxBufferedPaintDC::GetSize( void ) const -->
+  <!-- wxSize wxBufferedPaintDC::GetSizeMM( void ) const -->
+  <!-- wxSize wxAutoBufferedPaintDC::GetSize( void ) const -->
+  <!-- wxSize wxAutoBufferedPaintDC::GetSizeMM( void ) const -->
+  <function name="wxDC::GetSizeMM,wxDC::GetSize,wxGCDC::GetSizeMM,wxGCDC::GetSize,wxClientDC::GetSize,wxClientDC::GetSizeMM,wxPaintDC::GetSize,wxPaintDC::GetSizeMM,wxBufferedPaintDC::GetSize,wxBufferedPaintDC::GetSizeMM,wxAutoBufferedPaintDC::GetSize,wxAutoBufferedPaintDC::GetSizeMM">
+    <noreturn>false</noreturn>
+    <const/>
+    <leak-ignore/>
+    <returnValue/>
+    <arg nr="1" default="0" direction="out"/>
+    <arg nr="2" default="0" direction="out"/>
+  </function>
+  <!-- wxDataViewColumn* wxDataViewListCtrl::AppendTextColumn(const wxString & label, wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT, int width = -1, wxAlignment align = wxALIGN_LEFT, int flags = wxDATAVIEW_COL_RESIZABLE) -->
+  <!-- wxDataViewColumn* wxDataViewListCtrl::AppendToggleColumn(const wxString & label, wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT, int width = -1, wxAlignment align = wxALIGN_LEFT, int flags = wxDATAVIEW_COL_RESIZABLE) -->
+  <!-- wxDataViewColumn* wxDataViewListCtrl::AppendProgressColumn(const wxString & label, wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT, int width = -1, wxAlignment align = wxALIGN_LEFT, int flags = wxDATAVIEW_COL_RESIZABLE) -->
+  <!-- wxDataViewColumn* wxDataViewListCtrl::AppendIconTextColumn(const wxString & label, wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT, int width = -1, wxAlignment align = wxALIGN_LEFT, int flags = wxDATAVIEW_COL_RESIZABLE) -->
+  <function name="wxDataViewListCtrl::AppendTextColumn,wxDataViewListCtrl::AppendToggleColumn,wxDataViewListCtrl::AppendProgressColumn,wxDataViewListCtrl::AppendIconTextColumn">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxDataViewColumn*"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="wxDATAVIEW_CELL_INERT" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" default="-1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="4" default="wxALIGN_LEFT" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="5" default="wxDATAVIEW_COL_RESIZABLE" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- virtual bool wxDataViewCtrl::AppendColumn(wxDataViewModel * model) -->
+  <function name="wxDataViewCtrl::AppendColumn">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
+  <!-- virtual bool wxDataViewCtrl::AssociateModel(wxDataViewModel * model) -->
+  <function name="wxDataViewCtrl::AssociateModel">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
+  <!-- void wxDataViewCtrl::SetExpanderColumn(wxDataViewColumn * col) -->
+  <function name="wxDataViewCtrl::SetExpanderColumn">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
+  <!-- void wxDataViewCtrl::SetIndent(int indent) -->
+  <function name="wxDataViewCtrl::SetIndent">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- static void wxMemoryFSHandler::AddFile( const wxString & filename, const wxString & textdata ) -->
+  <!-- static void wxMemoryFSHandler::AddFile( const wxString & filename, const void * binarydata, size_t size ) -->
+  <!-- static void wxMemoryFSHandler::AddFile( const wxString & filename, wxImage & image, wxBitmapType type) -->
+  <!-- static void wxMemoryFSHandler::AddFile( const wxString & filename, wxBitmap & bmp, wxBitmapType type) -->
+  <function name="wxMemoryFSHandler::AddFile">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="0"/>
+    <arg nr="3" direction="in" default="0"/>
+    <arg nr="4" direction="in" default="0"/>
+  </function>
+  <!-- void wxIcon::CopyFromBitmap( const wxBitmap & bmp ) -->
+  <function name="wxIcon::CopyFromBitmap">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- static void wxLog::AddTraceMask( const wxString & str ) -->
+  <function name="wxLog::AddTraceMask">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- virtual void wxTextOutputStream::WriteString( const wxString & string ) -->
+  <function name="wxTextOutputStream::WriteString">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxDataObjectComposite::Add( wxDataObjectSimple * dataObject, bool preferred = false ) -->
+  <function name="wxDataObjectComposite::Add">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSplitterWindow::SetSashGravity( double gravity ) -->
+  <function name="wxSplitterWindow::SetSashGravity">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <valid>0.0:1.0</valid>
+    </arg>
+  </function>
+  <!-- void wxFileSystem::AddHandler( wxFileSystemHandler * handler ) -->
+  <function name="wxFileSystem::AddHandler">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
+  <!-- virtual bool wxXmlDocument::Load(const wxString & filename, const wxString & encoding = "UTF-8", int flags = wxXMLDOC_NONE) -->
+  <!-- virtual bool wxXmlDocument::Load(wxInputStream & stream   , const wxString & encoding = "UTF-8", int flags = wxXMLDOC_NONE) -->
+  <function name="wxXmlDocument::Load">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="UTF-8" direction="in"/>
+    <arg nr="2" default="wxXMLDOC_NONE" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxFSFile * wxFileSystem::OpenFile( const wxString & location, int flags = wxFS_READ ) -->
+  <function name="wxFileSystem::OpenFile">
+    <noreturn>false</noreturn>
+    <returnValue type="wxFSFile *"/>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="wxFS_READ" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxSplitterWindow::SetSashPosition( int position, bool redraw = true ) -->
+  <function name="wxSplitterWindow::SetSashPosition">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!--void wxSplitterWindow::SetMinimumPaneSize( int min ) -->
+  <function name="wxSplitterWindow::SetMinimumPaneSize">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- virtual bool wxSplitterWindow::SplitHorizontally(wxWindow * window1, wxWindow * window2, int sashPosition = 0) -->
+  <!-- virtual bool wxSplitterWindow::SplitVertically(wxWindow * window1, wxWindow * window2, int sashPosition = 0) -->
+  <function name="wxSplitterWindow::SplitHorizontally,wxSplitterWindow::SplitVertically">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="3" default="0" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxVariant wxPropertyGridInterface::GetPropertyValue( wxPGPropArg id ) -->
+  <!-- wxVariant wxPropertyGridManager::GetPropertyValue( wxPGPropArg id ) -->
+  <function name="wxPropertyGridInterface::GetPropertyValue,wxPropertyGridManager::GetPropertyValue">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <use-retval/>
+    <returnValue type="wxVariant"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxListCtrl::SetItemState( long item, long state, long stateMask ) -->
+  <function name="wxListCtrl::SetItemState">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool wxConcatFiles( const wxString & src1, const wxString & src2, const wxString & dest ) -->
+  <function name="wxConcatFiles">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!-- bool wxCopyFile(const wxString & file1, const wxString & file2, bool overwrite = true ) -->
+  <function name="wxCopyFile">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in" default="true">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxTreeItemId wxTreeCtrl::AppendItem(const wxTreeItemId & parent, const wxString & text, int image = -1, int selImage = -1, wxTreeItemData * data = NULL)-->
+  <function name="wxTreeCtrl::AppendItem">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxTreeItemId"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" default="-1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" default="-1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" default="NULL" direction="in"/>
+  </function>
+  <!-- void wxDataViewListCtrl::AppendItem(const wxVector< wxVariant > & values, wxUIntPtr data = NULL) -->
+  <function name="wxDataViewListCtrl::AppendItem">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="NULL" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxGrid::SetColSize( int col, int width ) -->
+  <function name="wxGrid::SetColSize">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!--void wxGrid::SetCellBackgroundColour (int row, int col, const wxColour &colour) -->
+  <function name="wxGrid::SetCellBackgroundColour">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in"/>
+  </function>
+  <!--void wxHtmlPrintout::SetHtmlText(const wxString & html, const wxString & basepath = wxEmptyString, bool isdir = true)-->
+  <function name="wxHtmlPrintout::SetHtmlText">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="wxEmptyString" direction="in"/>
+    <arg nr="3" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!--void wxHtmlEasyPrinting::SetStandardFonts(int size = -1, const wxString & normal_face = wxEmptyString, const wxString & fixed_face = wxEmptyString ) -->
+  <function name="wxHtmlEasyPrinting::SetStandardFonts">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" default="-1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" default="wxEmptyString" direction="in"/>
+    <arg nr="3" default="wxEmptyString" direction="in"/>
+  </function>
+  <!--void wxGrid::SetCellHighlightColour (const wxColour &colour) -->
+  <function name="wxGrid::SetCellHighlightColour">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!--void wxGrid::SetCellEditor (int row, int col, wxGridCellEditor * editor) -->
+  <function name="wxGrid::SetCellEditor">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout">
+      <not-null/>
+    </arg>
+  </function>
+  <!--virtual void wxGridCellEditor::StartingKey(wxKeyEvent & event)-->
+  <!--virtual void wxGridCellTextEditor::StartingKey(wxKeyEvent & event)-->
+  <function name="wxGridCellEditor::StartingKey,wxGridCellTextEditor::StartingKey">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!--virtual void wxGridCellEditor::Create(wxWindow * parent, wxWindowID id, wxEvtHandler * evtHandler)-->
+  <!--virtual void wxGridCellBoolEditor::Create(wxWindow * parent, wxWindowID id, wxEvtHandler * evtHandler)-->
+  <!--virtual void wxGridCellChoiceEditor::Create(wxWindow * parent, wxWindowID id, wxEvtHandler * evtHandler)-->
+  <!--virtual void wxGridCellTextEditor::Create(wxWindow * parent, wxWindowID id, wxEvtHandler * evtHandler)-->
+  <!--virtual void wxGridCellEnumEditor::Create(wxWindow * parent, wxWindowID id, wxEvtHandler * evtHandler)-->
+  <!--virtual void wxGridCellAutoWrapStringEditor::Create(wxWindow * parent, wxWindowID id, wxEvtHandler * evtHandler)-->
+  <!--virtual void wxGridCellFloatEditor::Create(wxWindow * parent, wxWindowID id, wxEvtHandler * evtHandler)-->
+  <!--virtual void wxGridCellNumberEditor::Create(wxWindow * parent, wxWindowID id, wxEvtHandler * evtHandler)-->
+  <function name="wxGridCellEditor::Create,wxGridCellBoolEditor::Create,wxGridCellChoiceEditor::Create,wxGridCellNumberEditor::Create,wxGridCellTextEditor::Create,wxGridCellEnumEditor::Create,wxGridCellAutoWrapStringEditor::Create,wxGridCellFloatEditor::Create">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
+  <!-- virtual bool wxBitmap::Create (int width, int height, int depth = wxBITMAP_SCREEN_DEPTH) -->
+  <!-- virtual bool wxBitmap::Create (const wxSize& sz, int depth = wxBITMAP_SCREEN_DEPTH) -->
+  <function name="wxBitmap::Create">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <arg nr="any" direction="in"/>
+  </function>
+  <!-- virtual bool wxHtmlWindow::SetPage (const wxSize& source) -->
+  <function name="wxHtmlWindow::SetPage">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxToolBarToolBase* wxToolBar::AddTool(int toolId, const wxString & label, const wxBitmap & bitmap, const wxString & shortHelp = wxEmptyString, wxItemKind kind = wxITEM_NORMAL) -->
+  <function name="wxToolBar::AddTool">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxToolBarToolBase*"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in" default="wxEmptyString"/>
+    <arg nr="5" direction="in" default="wxITEM_NORMAL"/>
+  </function>
+  <!-- wxAuiToolBarItem* wxAuiToolBar::AddTool(int tool_id, const wxString & label, const wxBitmap & bitmap, const wxString & short_help_string = wxEmptyString,
+wxItemKind kind = wxITEM_NORMAL) -->
+  <function name="wxToolBar::AddTool">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxAuiToolBarItem*"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in" default="wxEmptyString"/>
+    <arg nr="5" direction="in" default="wxITEM_NORMAL"/>
+  </function>
+  <!-- wxString wxString::SubString( size_t from, size_t to ) const -->
+  <function name="wxString::SubString">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <warn severity="style">This is a wxWidgets 1.xx compatibility function. Use 'wxString::Mid' in new applications instead.</warn>
+  </function>
+  <!-- wxString wxString::substr(size_t nStart = 0, size_t nLen = npos) const -->
+  <function name="wxString::substr">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxString"/>
+    <const/>
+    <use-retval/>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="1" default="wxString::npos" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxString wxString::Mid( size_t first, size_t nCount=wxString::npos ) const -->
+  <function name="wxString::Mid">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in" default="wxString::npos">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void wxFont::SetPointSize( int pointsize ) -->
+  <function name="wxFont::SetPointSize">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- virtual bool wxNotebook::SetPageText(size_t page, const wxString & text) -->
+  <function name="wxNotebook::SetPageText">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- virtual bool wxNotebook::SetPageImage(size_t page, const int imageId) -->
+  <function name="wxNotebook::SetPageImage">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- virtual int wxBookCtrlBase::SetSelection( size_t nPage ) -->
+  <!-- virtual int wxToolbook::SetSelection( size_t nPage ) -->
+  <!-- virtual int wxNotebook::SetSelection( size_t nPage ) -->
+  <function name="wxBookCtrlBase::SetSelection,wxToolbook::SetSelection,wxNotebook::SetSelection">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- virtual wxMenuItem * wxMenuBar::FindItem( int id, wxMenu * menu = NULL ) const -->
+  <function name="wxMenuBar::FindItem">
+    <noreturn>false</noreturn>
+    <returnValue type="wxMenuItem *"/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" default="NULL" direction="inout"/>
+  </function>
+  <!-- virtual void wxWithImages::SetImageList(wxImageList * imageList) -->
+  <!-- virtual void wxWithImages::AssignImageList(wxImageList * imageList) -->
+  <!-- virtual void wxToolbook::SetImageList(wxImageList * imageList) -->
+  <!-- virtual void wxToolbook::AssignImageList(wxImageList * imageList) -->
+  <!-- virtual void wxTreeListCtrl::SetImageList(wxImageList * imageList) -->
+  <!-- virtual void wxTreeListCtrl::AssignImageList(wxImageList * imageList) -->
+  <!-- virtual void wxNotebook::SetImageList(wxImageList * imageList) -->
+  <!-- virtual void wxNotebook::AssignImageList(wxImageList * imageList) -->
+  <!-- virtual void wxDataViewTreeCtrl::SetImageList(wxImageList * imageList) -->
+  <!-- virtual void wxDataViewTreeCtrl::AssignImageList(wxImageList * imageList) -->
+  <function name="wxWithImages::SetImageList,wxWithImages::AssignImageList,wxDataViewTreeCtrl::SetImageList,wxDataViewTreeCtrl::AssignImageList,wxToolbook::SetImageList,wxToolbook::AssignImageList,wxTreeListCtrl::AssignImageList,wxNotebook::AssignImageList,wxTreeListCtrl::SetImageList,wxNotebook::SetImageList">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
+  <!-- void wxTreeListCtrl::CheckItem(wxTreeListItem item, wxCheckBoxState state = wxCHK_CHECKED) -->
+  <!-- void wxTreeListCtrl::CheckItemRecursively(wxTreeListItem item, wxCheckBoxState state = wxCHK_CHECKED) -->
+  <function name="wxTreeListCtrl::CheckItem,wxTreeListCtrl::CheckItemRecursively">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="wxCHK_CHECKED" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool wxTreeListCtrl::Create(wxWindow * parent, wxWindowID id, const wxPoint & pos = wxDefaultPosition, const wxSize & size = wxDefaultSize, long style = wxTL_DEFAULT_STYLE, const wxString & name = wxTreeListCtrlNameStr) -->
+  <function name="wxTreeListCtrl::Create">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" default="wxDefaultPosition" direction="in"/>
+    <arg nr="4" default="wxDefaultSize" direction="in"/>
+    <arg nr="5" default="wxTL_DEFAULT_STYLE" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="6" default="wxTreeListCtrlName" direction="in"/>
+  </function>
+  <!-- void wxTreeListCtrl::Collapse(wxTreeListItem item) -->
+  <!-- void wxTreeListCtrl::Expand(wxTreeListItem item) -->
+  <!-- void wxTreeListCtrl::EnsureVisible(wxTreeListItem item) -->
+  <!-- void wxTreeListCtrl::UncheckItem(wxTreeListItem item) -->
+  <!-- void wxTreeListCtrl::Unselect(wxTreeListItem item) -->
+  <!-- void wxTreeListCtrl::UpdateItemParentStateRecursively(wxTreeListItem item) -->
+  <function name="wxTreeListCtrl::Collapse,wxTreeListCtrl::Expand,wxTreeListCtrl::EnsureVisible,wxTreeListCtrl::UncheckItem,wxTreeListCtrl::Unselect,wxTreeListCtrl::UpdateItemParentStateRecursively">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxDataViewCtrl* wxTreeListCtrl::GetDataView() const -->
+  <function name="wxTreeListCtrl::GetDataView">
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxDataViewCtrl*"/>
+  </function>
+  <!-- unsigned wxTreeListCtrl::GetColumnCount() const -->
+  <function name="wxTreeListCtrl::GetColumnCount">
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <noreturn>false</noreturn>
+    <returnValue type="unsigned"/>
+  </function>
+  <!-- int wxTreeListCtrl::GetColumnWidth(unsigned col) const -->
+  <function name="wxTreeListCtrl::GetColumnWidth">
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- void wxTreeListCtrl::SetItemText(wxTreeListItem item, int col, const wxString & text) -->
+  <!-- void wxTreeListCtrl::SetItemText(wxTreeListItem item, const wxString & text) -->
+  <function name="wxTreeListCtrl::SetItemText">
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" default="" direction="in"/>
+  </function>
+  <!-- void wxTreeListCtrl::SetItemImage(wxTreeListItem item, int closed, int opened = -1) -->
+  <function name="wxTreeListCtrl::SetItemImage">
+    <leak-ignore/>
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- const wxString& wxTreeListCtrl::GetItemText(wxTreeListItem item, unsigned col = 0) const -->
+  <function name="wxTreeListCtrl::GetItemText">
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <returnValue type="const wxString &amp;"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="0" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxTreeListItem wxTreeListCtrl::GetFirstChild(wxTreeListItem item) const -->
+  <!-- wxTreeListItem wxTreeListCtrl::GetItemParent(wxTreeListItem item) const -->
+  <!-- wxTreeListItem wxTreeListCtrl::GetNextItem(wxTreeListItem item) const -->
+  <!-- wxTreeListItem wxTreeListCtrl::GetNextSibling(wxTreeListItem item) const -->
+  <function name="wxTreeListCtrl::GetFirstChild,wxTreeListCtrl::GetItemParent,wxTreeListCtrl::GetNextItem,wxTreeListCtrl::GetNextSibling">
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <returnValue type="wxTreeListItem"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- unsigned wxTreeListCtrl::GetSelections(wxTreeListItems & selections) const -->
+  <function name="wxTreeListCtrl::GetSelections">
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <returnValue type="unsigned"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="out"/>
+  </function>
+  <!-- wxTreeListItem wxTreeListCtrl::GetFirstItem() const -->
+  <!-- wxTreeListItem wxTreeListCtrl::GetRootItem() const -->
+  <!-- wxTreeListItem wxTreeListCtrl::GetSelection() const -->
+  <function name="wxTreeListCtrl::GetFirstItem,wxTreeListCtrl::GetRootItem,wxTreeListCtrl::GetSelection">
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <returnValue type="wxTreeListItem"/>
+    <noreturn>false</noreturn>
+  </function>
+  <!-- bool wxTreeListCtrl::IsExpanded(wxTreeListItem item ) const -->
+  <!-- bool wxTreeListCtrl::IsSelected(wxTreeListItem item ) const -->
+  <function name="wxTreeListCtrl::IsExpanded,wxTreeListCtrl::IsSelected">
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- FlagType wxPGProperty::HasFlag(wxPGPropertyFlags flag) const -->
+  <function name="wxPGProperty::HasFlag">
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <noreturn>false</noreturn>
+    <returnValue type="FlagType"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- bool wxWindow::HasFlag(int flag) const -->
+  <!-- bool wxTextCtrl::HasFlag(int flag) const -->
+  <!-- bool wxWindow::HasScrollbar(int orient) const -->
+  <function name="wxWindow::HasFlag,wxTextCtrl::HasFlag,wxWindow::HasScrollbar">
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- wxCheckBoxState wxTreeListCtrl::GetCheckedState(wxTreeListItem item) const -->
+  <function name="wxTreeListCtrl::GetCheckedState">
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxCheckBoxState"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- wxClientData* wxTreeListCtrl::GetItemData(wxTreeListItem item) const -->
+  <function name="wxTreeListCtrl::GetItemData">
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxClientData*"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int wxTreeListCtrl::AppendColumn(const wxString & title, int width = wxCOL_WIDTH_AUTOSIZE, wxAlignment align = wxALIGN_LEFT, int flags = wxCOL_RESIZABLE) -->
+  <function name="wxTreeListCtrl::AppendColumn">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="wxCOL_WIDTH_AUTOSIZE" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="4" direction="in" default="0">
+    <arg nr="3" default="wxALIGN_LEFT" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="5" direction="in" default="wxODDEVEN_RULE">
+    <arg nr="4" default="wxCOL_RESIZABLE" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxDC::DrawLabel(const wxString & text, const wxRect & rect, int alignment = wxALIGN_LEFT|wxALIGN_TOP, int indexAccel = -1) -->
-  <!-- void wxMemoryDC::DrawLabel(const wxString & text, const wxRect & rect, int alignment = wxALIGN_LEFT|wxALIGN_TOP, int indexAccel = -1) -->
-  <!-- void wxBufferedDC::DrawLabel(const wxString & text, const wxRect & rect, int alignment = wxALIGN_LEFT|wxALIGN_TOP, int indexAccel = -1) -->
-  <!-- void wxBufferedPaintDC::DrawLabel(const wxString & text, const wxRect & rect, int alignment = wxALIGN_LEFT|wxALIGN_TOP, int indexAccel = -1) -->
-  <function name="wxDC::DrawLabel,wxMemoryDC::DrawLabel,wxBufferedDC::DrawLabel,wxBufferedPaintDC::DrawLabel">
+  <!-- bool wxTreeListCtrl::AreAllChildrenInState(wxTreeListItem item, wxCheckBoxState state ) const -->
+  <function name="wxTreeListCtrl::AreAllChildrenInState">
+    <use-retval/>
+    <const/>
+    <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- wxTreeListItem wxTreeListCtrl::AppendItem(wxTreeListItem parent, const wxString & text, int imageClosed = -1, int imageOpened = -1, wxClientData * data = NULL) -->
+  <!-- wxTreeListItem wxTreeListCtrl::PrependItem(wxTreeListItem parent, const wxString & text, int imageClosed = -1, int imageOpened = -1, wxClientData * data = NULL) -->
+  <function name="wxTreeListCtrl::AppendItem,wxTreeListCtrl::PrependItem">
     <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxTreeListItem"/>
     <arg nr="1" direction="in"/>
     <arg nr="2" direction="in"/>
-    <arg nr="3" direction="in">
+    <arg nr="3" default="-1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="4" direction="in" default="wxALIGN_LEFT|wxALIGN_TOP">
+    <arg nr="4" default="-1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="5" direction="in" default="-1">
+    <arg nr="5" default="NULL" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- wxPGProperty * wxPropertyGridInterface::Append( wxPGProperty * property ) -->
-  <!-- wxPGProperty * wxPropertyGridManager::Append( wxPGProperty * property ) -->
-  <function name="wxPropertyGridInterface::Append,wxPropertyGridManager::Append">
-    <noreturn>false</noreturn>
+  <!-- bool wxTreeListCtrl::DeleteColumn(unsigned col) -->
+  <function name="wxTreeListCtrl::DeleteColumn">
     <leak-ignore/>
-    <returnValue type="wxPGProperty *"/>
-    <arg nr="1" direction="inout">
-      <not-uninit/>
-      <not-null/>
-    </arg>
-  </function>
-  <!-- wxPGChoiceEntry & wxPGChoices::Add( const wxPGChoiceEntry & entry ) -->
-  <function name="wxPGChoices::Add">
     <noreturn>false</noreturn>
-    <returnValue type="wxPGChoiceEntry &amp;"/>
-    <leak-ignore/>
+    <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- wxPGProperty* wxPropertyGridInterface::GetProperty(const wxString & name) const -->
-  <function name="wxPropertyGridInterface::GetProperty">
-    <noreturn>false</noreturn>
-    <returnValue type="wxPGProperty*"/>
+  <!-- void wxTreeListCtrl::ClearColumns() -->
+  <!-- void wxTreeListCtrl::DeleteAllItems() -->
+  <!-- void wxTreeListCtrl::UnselectAll() -->
+  <function name="wxTreeListCtrl::ClearColumns,wxTreeListCtrl::DeleteAllItems,wxTreeListCtrl::UnselectAll">
     <leak-ignore/>
-    <use-retval/>
-    <const/>
-    <arg nr="1" direction="in"/>
-  </function>
-  <!-- void wxGraphicsContext::SetPen(const wxPen & pen) -->
-  <!-- void wxDC::SetPen(const wxPen & pen) -->
-  <!-- void wxDC::SetBrush(const wxBrush & pen) -->
-  <!-- void wxDC::SetFont(const wxFont & font) -->
-  <!-- void wxBufferedPaintDC::SetPen(const wxPen & pen) -->
-  <!-- void wxBufferedPaintDC::SetBrush(const wxBrush & pen) -->
-  <!-- void wxBufferedPaintDC::SetFont(const wxFont & font) -->
-  <!-- void wxPaintDC::SetPen(const wxPen & pen) -->
-  <!-- void wxPaintDC::SetBrush(const wxBrush & pen) -->
-  <!-- void wxPaintDC::SetFont(const wxFont & font) -->
-  <!-- void wxMemoryDC::SetPen(const wxPen & pen) -->
-  <!-- void wxMemoryDC::SetBrush(const wxBrush & pen) -->
-  <!-- void wxMemoryDC::SetFont(const wxFont & font) -->
-  <!-- void wxBufferedDC::SetPen(const wxPen & pen) -->
-  <!-- void wxBufferedDC::SetBrush(const wxBrush & pen) -->
-  <!-- void wxBufferedDC::SetFont(const wxFont & font) -->
-  <!-- void wxClientDC::SetPen(const wxPen & pen) -->
-  <!-- void wxClientDC::SetBrush(const wxBrush & pen) -->
-  <!-- void wxClientDC::SetFont(const wxFont & font) -->
-  <!-- void wxGCDC::SetPen(const wxPen & pen) -->
-  <!-- void wxGCDC::SetBrush(const wxBrush & pen) -->
-  <!-- void wxGCDC::SetFont(const wxFont & font) -->
-  <function name="wxGCDC::SetFont,wxGCDC::SetBrush,wxGCDC::SetPen,wxBufferedPaintDC::SetFont,wxBufferedPaintDC::SetBrush,wxBufferedPaintDC::SetPen,wxClientDC::SetPen,wxClientDC::SetBrush,wxClientDC::SetFont,wxPaintDC::SetPen,wxPaintDC::SetBrush,wxPaintDC::SetFont,wxGraphicsContext::SetPen,wxDC::SetPen,wxDC::SetBrush,wxDC::SetFont,wxMemoryDC::SetPen,wxMemoryDC::SetBrush,wxMemoryDC::SetFont,wxBufferedDC::SetPen,wxBufferedDC::SetBrush,wxBufferedDC::SetFont">
     <noreturn>false</noreturn>
-    <leak-ignore/>
-    <arg nr="1" direction="in"/>
+    <returnValue type="void"/>
   </function>
-  <!-- @todo: void DrawBitmap (const wxBitmap &bitmap, wxCoord x, wxCoord y, bool useMask=false) -->
-  <!-- void wxDC::DrawBitmap (const wxBitmap &bmp, const wxPoint &pt, bool useMask=false) -->
-  <!-- void wxPaintDC::DrawBitmap(const wxBitmap &bmp, const wxPoint &pt, bool useMask=false) -->
-  <!-- void wxClientDC::DrawBitmap(const wxBitmap &bmp, const wxPoint &pt, bool useMask=false) -->
-  <!-- void wxAutoBufferedPaintDC::DrawBitmap(const wxBitmap &bmp, const wxPoint &pt, bool useMask=false) -->
-  <function name="wxDC::DrawBitmap,wxPaintDC::DrawBitmap,wxClientDC::DrawBitmap,wxAutoBufferedPaintDC::DrawBitmap">
-    <noreturn>false</noreturn>
+  <!-- void wxTextEntryDialog::SetTextValidator(const wxTextValidator & validator) -->
+  <!-- void wxTextEntryDialog::SetTextValidator(wxTextValidatorStyle style = wxFILTER_NONE) -->
+  <function name="wxTextEntryDialog::SetTextValidator">
     <leak-ignore/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in"/>
-    <arg nr="3" direction="in" default="false">
-      <not-uninit/>
-    </arg>
-  </function>
-  <!-- void wxTextAttr::SetFont(const wxFont & font, int flags = wxTEXT_ATTR_FONT &~wxTEXT_ATTR_FONT_PIXEL_SIZE) -->
-  <function name="wxTextAttr::SetFont">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in" default="wxFILTER_NONE"/>
+  </function>
+  <!-- static wxString wxString::FromUTF8( const char * utf8 )                   -->
+  <!-- static wxString wxString::FromUTF8Unchecked( const char * utf8 )          -->
+  <!-- static wxString wxString::FromUTF8Unchecked( const std::string & s ) (*)  -->
+  <function name="wxString::FromUTF8,wxString::FromUTF8Unchecked">
     <leak-ignore/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in" default="wxTEXT_ATTR_FONT &amp;~wxTEXT_ATTR_FONT_PIXEL_SIZE">
-      <not-uninit/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxString"/>
+    <pure/>
+    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-null/>
     </arg>
   </function>
-  <!-- virtual bool wxAnimation::Load(wxInputStream & stream, wxAnimationType type = wxANIMATION_TYPE_ANY) -->
-  <function name="wxAnimation::Load">
-    <noreturn>false</noreturn>
+  <!-- bool wxZipOutputStream::PutNextEntry(const wxString & name, const wxDateTime & dt = wxDateTime::Now(), wxFileOffset size = wxInvalidOffset) -->
+  <function name="wxZipOutputStream::PutNextEntry">
     <leak-ignore/>
+    <noreturn>false</noreturn>
     <returnValue type="bool"/>
-    <arg nr="1" direction="inout"/>
-    <arg nr="2" direction="in" default="wxANIMATION_TYPE_ANY">
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="wxDateTime::Now()"/>
+    <arg nr="3" direction="in" default="wxInvalidOffset">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxPropertyGridManager::SetSplitterPosition(int pos, int column = 0) -->
-  <function name="wxPropertyGridManager::SetSplitterPosition">
-    <noreturn>false</noreturn>
+  <!-- void wxStyledTextCtrl::MarkerSetForeground(int markerNumber, const wxColour & fore)-->
+  <!-- void wxStyledTextCtrl::MarkerSetBackground(int markerNumber, const wxColour & back)-->
+  <!-- void wxStyledTextCtrl::MarkerSetBackgroundSelected(int markerNumber, const wxColour & back)-->
+  <function name="wxStyledTextCtrl::MarkerSetForeground,wxStyledTextCtrl::MarkerSetBackground,wxStyledTextCtrl::MarkerSetBackgroundSelected">
     <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="2" direction="in" default="0">
-      <not-uninit/>
-    </arg>
+    <arg nr="2" direction="in"/>
   </function>
-  <!-- virtual bool wxWindow::SetForegroundColour(const wxColour & colour) -->
-  <!-- virtual bool wxWindow::SetBackgroundColour(const wxColour & colour) -->
-  <!-- virtual bool wxStaticText::SetForegroundColour(const wxColour & colour) -->
-  <!-- virtual bool wxStaticText::SetBackgroundColour(const wxColour & colour) -->
-  <!-- virtual bool wxButton::SetForegroundColour(const wxColour & colour) -->
-  <!-- virtual bool wxButton::SetBackgroundColour(const wxColour & colour) -->
-  <!-- virtual bool wxToggleButton::SetForegroundColour(const wxColour & colour) -->
-  <!-- virtual bool wxToggleButton::SetBackgroundColour(const wxColour & colour) -->
-  <!-- virtual bool wxTextCtrl::SetForegroundColour(const wxColour & colour) -->
-  <!-- virtual bool wxTextCtrl::SetBackgroundColour(const wxColour & colour) -->
-  <function name="wxToggleButton::SetBackgroundColour,wxToggleButton::SetForegroundColour,wxTextCtrl::SetForegroundColour,wxTextCtrl::SetBackgroundColour,wxWindow::SetForegroundColour,wxWindow::SetBackgroundColour,wxStaticText::SetForegroundColour,wxStaticText::SetBackgroundColour,wxButton::SetForegroundColour,wxButton::SetBackgroundColour">
-    <noreturn>false</noreturn>
+  <!--void wxPropertyGridInterface::SetPropertyAttribute(wxPGPropArg id, const wxString & attrName, wxVariant value, long argFlags = 0)-->
+  <!--void wxPropertyGridPage::SetPropertyAttribute(wxPGPropArg id, const wxString & attrName, wxVariant value, long argFlags = 0)-->
+  <!--void wxPropertyGridManager::SetPropertyAttribute(wxPGPropArg id, const wxString & attrName, wxVariant value, long argFlags = 0)-->
+  <!--void wxPropertyGrid::SetPropertyAttribute(wxPGPropArg id, const wxString & attrName, wxVariant value, long argFlags = 0)-->
+  <function name="wxPropertyGridInterface::SetPropertyAttribute,wxPropertyGridPage::SetPropertyAttribute,wxPropertyGridManager::SetPropertyAttribute,wxPropertyGrid::SetPropertyAttribute">
     <leak-ignore/>
-    <returnValue type="bool"/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
     <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in" default="0">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
-  <!-- wxImage& wxImage::Rescale(int width, int height, wxImageResizeQuality quality = wxIMAGE_QUALITY_NORMAL) -->
-  <function name="wxImage::Rescale">
+  <!--static wxPGEditor* wxPropertyGrid::RegisterEditorClass (wxPGEditor * editor, bool noDefCheck = false)-->
+  <function name="wxPropertyGrid::RegisterEditorClass">
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="wxImage &amp;"/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in">
+    <returnValue type="wxPGEditor*"/>
+    <arg nr="1" direction="inout">
       <not-uninit/>
+      <not-null/>
     </arg>
-    <arg nr="3" direction="in" default="wxIMAGE_QUALITY_NORMAL">
+    <arg nr="1" default="false" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!-- bool wxGrid::DeleteRows( int pos = 0, int numRows = 1, bool updateLabels = true ) -->
-  <!-- bool wxGrid::DeleteCols( int pos = 0, int numCols = 1, bool updateLabels = true ) -->
-  <function name="wxGrid::DeleteRows,wxGrid::DeleteCols">
+  <!-- virtual void wxGridCellEditor::BeginEdit(int row, int col, wxGrid * grid) -->
+  <!--         void wxGridCellBoolEditor::BeginEdit(int row, int col, wxGrid * grid) -->
+  <!--         void wxGridCellChoiceEditor::BeginEdit(int row, int col, wxGrid * grid) -->
+  <!--         void wxGridCellTextEditor::BeginEdit(int row, int col, wxGrid * grid) -->
+  <!--         void wxGridCellEnumEditor::BeginEdit(int row, int col, wxGrid * grid) -->
+  <!--         void wxGridCellAutoWrapStringEditor::BeginEdit(int row, int col, wxGrid * grid) -->
+  <!--         void wxGridCellFloatEditor::BeginEdit(int row, int col, wxGrid * grid) -->
+  <!--         void wxGridCellNumberEditor::BeginEdit(int row, int col, wxGrid * grid) -->
+  <function name="wxGridCellEditor::BeginEdit,wxGridCellBoolEditor::BeginEdit,wxGridCellNumberEditor::BeginEdit,wxGridCellChoiceEditor::BeginEdit,wxGridCellFloatEditor::BeginEdit,wxGridCellTextEditor::BeginEdit,wxGridCellEnumEditor::BeginEdit,wxGridCellAutoWrapStringEditor::BeginEdit">
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <arg nr="1" direction="in" default="0">
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="2" direction="in" default="1">
+    <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="3" direction="in" default="true">
-      <not-uninit/>
+    <arg nr="3" direction="inout">
+      <not-null/>
     </arg>
   </function>
-  <!-- void wxDC::DrawText( const wxString &amp; text, wxCoord x, wxCoord y ) -->
-  <!-- void wxPaintDC::DrawText( const wxString &amp; text, wxCoord x, wxCoord y ) -->
-  <!-- void wxClientDC::DrawText( const wxString &amp; text, wxCoord x, wxCoord y ) -->
-  <function name="wxDC::DrawText,wxPaintDC::DrawText,wxClientDC::DrawText">
+  <!-- void wxStyledTextCtrl::MarkerDefine(int markerNumber, int markerSymbol, const wxColour & foreground = wxNullColour, const wxColour & background = wxNullColour) -->
+  <function name="wxStyledTextCtrl::MarkerDefine">
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in">
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="3" direction="in">
+    <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
+    <arg nr="3" direction="in" default="wxNullColour"/>
+    <arg nr="4" direction="in" default="wxNullColour"/>
   </function>
-  <!--         void wxGraphicsContext::SetBrush(const wxBrush & brush) -->
-  <!-- virtual void wxGraphicsContext::SetBrush(const wxGraphicsBrush & brush) -->
-  <function name="wxGraphicsContext::SetBrush">
+  <!-- void wxSleep( int nSecs ) -->
+  <!-- void wxMilliSleep( unsigned long milliseconds ) -->
+  <!-- void wxMicroSleep( unsigned long ns ) -->
+  <function name="wxSleep,wxMilliSleep,wxMicroSleep">
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="in"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
-  <!-- void wxGraphicsContext::DrawLines( size_t n, const wxPoint2DDouble * points, wxPolygonFillMode fillStyle = wxODDEVEN_RULE ) -->
-  <function name="wxGraphicsContext::DrawLines">
-    <leak-ignore/>
+  <!-- void wxGrid::SetColFormatNumber( int col ) -->
+  <function name="wxGrid::SetColFormatNumber">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
-      <valid>1:</valid>
     </arg>
-    <arg nr="2" direction="in">
+  </function>
+  <!-- void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols = false ) -->
+  <function name="wxGrid::SetDefaultColSize">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
       <not-uninit/>
-      <not-null/>
+      <not-bool/>
     </arg>
-    <arg nr="3" direction="in" default="wxODDEVEN_RULE">
+    <arg nr="2" default="false" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!-- void wxSpinCtrl::SetValue( const wxString & value ) -->
-  <!-- void wxSpinCtrl::SetValue( int value ) -->
-  <function name="wxSpinCtrl::SetValue">
-    <leak-ignore/>
+  <!-- void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows = false ) -->
+  <function name="wxGrid::SetDefaultRowSize">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="in"/>
-  </function>
-  <!-- wxSize wxDC::GetTextExtent( const wxString & string ) -->
-  <!-- wxSize wxPaintDC::GetTextExtent( const wxString & string ) -->
-  <!-- wxSize wxClientDC::GetTextExtent( const wxString & string ) -->
-  <function name="wxDC::GetTextExtent,wxPaintDC::GetTextExtent,wxClientDC::GetTextExtent">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-    <returnValue type="wxSize"/>
-    <use-retval/>
-    <arg nr="1" direction="in"/>
-  </function>
-  <!-- void wxGridCellAttr::GetAlignment( int * hAlign, int * vAlign ) -->
-  <function name="wxGridCellAttr::GetAlignment">
     <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- void wxGrid::SetDefaultRenderer( wxGridCellRenderer * renderer ) -->
+  <function name="wxGrid::SetDefaultRenderer">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="out">
-      <not-null/>
-    </arg>
-    <arg nr="2" direction="out">
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
       <not-null/>
     </arg>
   </function>
-  <!-- virtual void wxGridCellRenderer::Draw(wxGrid &grid, wxGridCellAttr &attr, wxDC &dc, const wxRect &rect, int row, int col, bool isSelected) -->
-  <!-- virtual void wxGridCellStringRenderer::Draw (wxGrid &grid, wxGridCellAttr &attr, wxDC &dc, const wxRect &rect, int row, int col, bool isSelected) -->
-  <!-- virtual void wxGridCellBoolRenderer::Draw (wxGrid &grid, wxGridCellAttr &attr, wxDC &dc, const wxRect &rect, int row, int col, bool isSelected) -->
-  <!-- virtual void wxGridCellAutoWrapStringRenderer::Draw (wxGrid &grid, wxGridCellAttr &attr, wxDC &dc, const wxRect &rect, int row, int col, bool isSelected) -->
-  <!-- virtual void wxGridCellEnumRenderer::Draw (wxGrid &grid, wxGridCellAttr &attr, wxDC &dc, const wxRect &rect, int row, int col, bool isSelected) -->
-  <!-- virtual void wxGridCellFloatRenderer::Draw (wxGrid &grid, wxGridCellAttr &attr, wxDC &dc, const wxRect &rect, int row, int col, bool isSelected) -->
-  <!-- virtual void wxGridCellNumberRenderer::Draw (wxGrid &grid, wxGridCellAttr &attr, wxDC &dc, const wxRect &rect, int row, int col, bool isSelected) -->
-  <function name="wxGridCellRenderer::Draw,wxGridCellStringRenderer::Draw,wxGridCellBoolRenderer::Draw,wxGridCellAutoWrapStringRenderer::Draw,wxGridCellEnumRenderer::Draw,wxGridCellFloatRenderer::Draw,wxGridCellNumberRenderer::Draw">
+  <!-- void wxSizer::SetMinSize(const wxSize & size) -->
+  <!-- void wxSizer::SetMinSize(int width, int height) -->
+  <function name="wxSizer::SetMinSize">
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="inout"/>
-    <arg nr="2" direction="inout"/>
-    <arg nr="3" direction="inout"/>
-    <arg nr="4" direction="in"/>
-    <arg nr="5" direction="in">
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="0" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="6" direction="in">
+  </function>
+  <!-- void wxDC::SetDeviceOrigin(wxCoord x, wxCoord y) -->
+  <!-- void wxGCDC::SetDeviceOrigin(wxCoord x, wxCoord y) -->
+  <function name="wxDC::SetDeviceOrigin,wxGCDC::SetDeviceOrigin">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="7" direction="in">
+    <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- bool wxGridCellEditor::IsAcceptedKey( wxKeyEvent & event ) -->
-  <function name="wxGridCellEditor::IsAcceptedKey">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <use-retval/>
-    <arg nr="1" direction="inout"/>
-  </function>
-  <!-- void wxDC::SetTextForeground( const wxColour & colour ) -->
-  <!-- void wxDC::SetTextBackground( const wxColour & colour ) -->
-  <!-- void wxBufferedPaintDC::SetTextForeground( const wxColour & colour ) -->
-  <!-- void wxBufferedPaintDC::SetTextBackground( const wxColour & colour ) -->
-  <function name="wxDC::SetTextForeground,wxDC::SetTextBackground,wxBufferedPaintDC::SetTextForeground,wxBufferedPaintDC::SetTextBackground">
+  <!-- virtual void wxTopLevelWindow::SetMinSize(const wxSize & size) -->
+  <!-- virtual void wxTopLevelWindow::SetMaxSize(const wxSize & size) -->
+  <!-- virtual void wxTopLevelWindow::SetMinClientSize(const wxSize & size) -->
+  <!-- virtual void wxTopLevelWindow::SetMaxClientSize(const wxSize & size) -->
+  <!-- virtual void wxWindowBase::SetMinSize(const wxSize & size) -->
+  <!-- virtual void wxWindowBase::SetMaxSize(const wxSize & size) -->
+  <!-- virtual void wxWindowBase::SetMinClientSize(const wxSize & size) -->
+  <!-- virtual void wxWindowBase::SetMaxClientSize(const wxSize & size) -->
+  <!-- virtual void wxWindow::SetMinSize(const wxSize & size) -->
+  <!-- virtual void wxWindow::SetMaxSize(const wxSize & size) -->
+  <!-- virtual void wxWindow::SetMinClientSize(const wxSize & size) -->
+  <!-- virtual void wxWindow::SetMaxClientSize(const wxSize & size) -->
+  <!--         void wxTextCtrl::SetMinSize(const wxSize & size) -->
+  <!--         void wxTextCtrl::SetMaxSize(const wxSize & size) -->
+  <!--         void wxStaticText::SetMinSize(const wxSize & size) -->
+  <!--         void wxStaticText::SetMaxSize(const wxSize & size) -->
+  <!--         void wxButton::SetMinSize(const wxSize & size) -->
+  <!--         void wxButton::SetMaxSize(const wxSize & size) -->
+  <!--         void wxPropertyGridManager::SetMinSize(const wxSize & size) -->
+  <!--         void wxPropertyGridManager::SetMaxSize(const wxSize & size) -->
+  <!--         void wxComboBox::SetMinSize(const wxSize & size) -->
+  <!--         void wxComboBox::SetMaxSize(const wxSize & size) -->
+  <function name="wxTopLevelWindow::SetMaxClientSize,wxTopLevelWindow::SetMinClientSize,wxTopLevelWindow::SetMaxSize,wxTopLevelWindow::SetMinSize,wxWindowBase::SetMaxClientSize,wxWindowBase::SetMinClientSize,wxWindowBase::SetMaxSize,wxWindowBase::SetMinSize,wxWindow::SetMinSize,wxWindow::SetMaxSize,wxComboBox::SetMinSize,wxComboBox::SetMaxSize,wxWindow::SetMinClientSize,wxWindow::SetMaxClientSize,wxTextCtrl::SetMinSize,wxTextCtrl::SetMaxSize,wxStaticText::SetMinSize,wxStaticText::SetMaxSize,wxButton::SetMinSize,wxButton::SetMaxSize,wxPropertyGridManager::SetMinSize,wxPropertyGridManager::SetMaxSize">
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- void wxGridCellAttr::SetFont(const wxFont & font) -->
-  <function name="wxGridCellAttr::SetFont">
+  <!--void wxScrolledWindow::AdjustScrollbars(void) -->
+  <function name="wxScrolledWindow::AdjustScrollbars">
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1"/>
   </function>
-  <!-- void wxGridCellAttr::GetSize(int * num_rows, int * num_cols) const-->
-  <function name="wxGridCellAttr::GetSize">
+  <!--wxSize wxWindow::GetSize(void) const -->
+  <!--wxSize wxControl::GetSize(void) const -->
+  <!--wxSize wxSpinButton::GetSize(void) const -->
+  <function name="wxWindow::GetSize,wxControl::GetSize,wxSpinButton::GetSize">
     <leak-ignore/>
+    <const/>
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <use-retval/>
+    <returnValue type="wxSize"/>
+  </function>
+  <!--wxString wxControl::GetLabel () const -->
+  <!--wxString wxControl::GetLabelText () const -->
+  <function name="wxControl::GetLabel,wxControl::GetLabelText">
+    <leak-ignore/>
     <const/>
-    <arg nr="1" direction="out">
-      <not-null/>
-    </arg>
-    <arg nr="2" direction="out">
-      <not-null/>
-    </arg>
+    <noreturn>false</noreturn>
+    <use-retval/>
+    <returnValue type="wxString"/>
   </function>
-  <!-- virtual wxStatusBar* wxFrame::CreateStatusBar(int number = 1, long style = wxSTB_DEFAULT_STYLE, wxWindowID id = 0, const wxString & name = wxStatusBarNameStr)-->
-  <function name="wxFrame::CreateStatusBar">
+  <!--wxSizer* wxWindow::GetSizer(void) const -->
+  <function name="wxWindow::GetSizer">
     <leak-ignore/>
+    <const/>
     <noreturn>false</noreturn>
-    <returnValue type="wxStatusBar*"/>
-    <arg nr="1" default="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" default="wxSTB_DEFAULT_STYLE" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="3" default="0" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="4" default="wxStatusBarNameStr" direction="in">
-      <not-uninit/>
-    </arg>
+    <use-retval/>
+    <returnValue type="wxSizer*"/>
   </function>
-  <!-- void wxMemoryDC::SelectObject( wxBitmap & bmp ) -->
-  <!-- void wxBufferedDC::SelectObject( wxBitmap & bmp ) -->
-  <function name="wxMemoryDC::SelectObject,wxBufferedDC::SelectObject">
+  <!--void wxRect::SetPosition(const wxPoint & pos) -->
+  <function name="wxRect::SetPosition">
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- void wxTextEntry::AppendText( const wxString & text ) -->
-  <!-- void wxTextEntry::WriteText( const wxString & text ) -->
-  <!-- void wxTextCtrl::AppendText( const wxString & text ) -->
-  <!-- void wxTextCtrl::WriteText( const wxString & text ) -->
-  <!-- void wxStyledTextCtrl::AppendText( const wxString & text ) -->
-  <function name="wxTextEntry::AppendText,wxTextEntry::WriteText,wxTextCtrl::AppendText,wxTextCtrl::WriteText,wxStyledTextCtrl::AppendText">
+  <!-- void wxSpinCtrlDouble::Enable( bool enable = true ) -->
+  <!-- void wxToggleButton::Enable( bool enable = true ) -->
+  <!-- void wxStaticText::Enable( bool enable = true ) -->
+  <!-- void wxStaticBox::Enable( bool enable = true ) -->
+  <!-- void wxMenuItem::Enable( bool enable = true ) -->
+  <function name="wxSpinCtrlDouble::Enable,wxToggleButton::Enable,wxStaticText::Enable,wxStaticBox::Enable,wxMenuItem::Enable">
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="in"/>
+    <arg nr="1" direction="in" default="true">
+      <not-uninit/>
+    </arg>
   </function>
-  <!-- int wxString::Cmp(const wxString & s) const -->
-  <!-- int wxString::CmpNoCase( const wxString & s ) const -->
-  <function name="wxString::CmpNoCase,wxString::Cmp">
+  <!-- void wxMenuItem::Check( bool enable = true ) -->
+  <function name="wxMenuItem::Check">
+    <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="int"/>
-    <const/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in" default="true">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- bool wxPropertyGridInterface::ClearSelection(bool validation = false) -->
+  <!-- bool wxPropertyGridManager::ClearSelection(bool validation = false) -->
+  <function name="wxPropertyGridInterface::ClearSelection,wxPropertyGridManager::ClearSelection">
     <leak-ignore/>
-    <arg nr="1" direction="in"/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in" default="false">
+      <not-uninit/>
+    </arg>
   </function>
-  <!-- wxGridCellCoords wxGrid::XYToCell(int x, int y) const -->
-  <function name="wxGrid::XYToCell">
+  <!-- template <class T> const T wxMin(const T& a, const T& b); -->
+  <function name="wxMin">
+    <use-retval/>
     <noreturn>false</noreturn>
-    <returnValue type="wxGridCellCoords"/>
-    <const/>
     <leak-ignore/>
+    <returnValue>arg1&lt;arg2?arg1:arg2</returnValue>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
-      <not-bool/>
     </arg>
   </function>
-  <!-- virtual void wxMenuItem::SetBitmap(const wxBitmap & bmp, bool checked = true) -->
-  <function name="wxMenuItem::SetBitmap">
+  <!-- template <class T> const T& wxMax(const T& a, const T& b); -->
+  <function name="wxMax">
+    <use-retval/>
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in" default="true">
+    <returnValue>arg1&gt;arg2?arg1:arg2</returnValue>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!--         bool wxMenuItem::IsCheck() const -->
-  <!--         bool wxMenuItem::IsCheckable() const -->
-  <!--         bool wxMenuItem::IsRadio() const -->
-  <!--         bool wxMenuItem::IsSeparator() const -->
-  <!--         bool wxMenuItem::IsSubMenu() const -->
-  <!-- virtual bool wxMenuItem::IsChecked() const -->
-  <!-- virtual bool wxMenuItem::IsEnabled() const -->
-  <function name="wxMenuItem::IsCheck,wxMenuItem::IsCheckable,wxMenuItem::IsRadio,wxMenuItem::IsSeparator,wxMenuItem::IsSubMenu,wxMenuItem::IsChecked,wxMenuItem::IsEnabled">
-    <noreturn>false</noreturn>
+  <!-- virtual bool wxGenericProgressDialog::Update(int value, const wxString & newmsg = wxEmptyString, bool * skip = NULL ) -->
+  <!-- virtual bool wxProgressDialog::Update(int value, const wxString & newmsg = wxEmptyString, bool * skip = NULL ) -->
+  <function name="wxGenericProgressDialog::Update,wxProgressDialog::Update">
     <leak-ignore/>
+    <noreturn>false</noreturn>
     <returnValue type="bool"/>
-    <const/>
-    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in" default="wxEmptyString"/>
+    <arg nr="3" direction="inout" default="NULL">
+      <not-uninit/>
+    </arg>
   </function>
-  <!-- bool wxTextCtrl::SetDefaultStyle( const wxTextAttr & style ) -->
-  <function name="wxTextCtrl::SetDefaultStyle">
+  <!-- virtual bool wxGenericProgressDialog::Pulse(const wxString &msg=wxEmptyString, bool *skip=NULL ) -->
+  <!-- virtual bool wxProgressDialog::Pulse(const wxString &msg=wxEmptyString, bool *skip=NULL ) -->
+  <function name="wxGenericProgressDialog::Update,wxProgressDialog::Pulse">
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
-    <!-- const wxTextAttr & style -->
-    <arg nr="1" direction="in"/>
+    <arg nr="1" direction="in" default="wxEmptyString"/>
+    <arg nr="2" direction="in" default="NULL"/>
   </function>
-  <!-- wxString wxString::BeforeFirst( wxUniChar ch, wxString * rest = NULL ) -->
-  <function name="wxString::BeforeFirst">
+  <!-- bool wxGenericProgressDialog::WasCancelled() const -->
+  <function name="wxGenericProgressDialog::WasCancelled">
+    <const/>
     <leak-ignore/>
-    <noreturn>false</noreturn>
-    <returnValue type="wxString"/>
     <use-retval/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="out" default="NULL">
-      <not-uninit/>
-    </arg>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
   </function>
-  <!-- void wxPaintDC::DrawCircle( wxCoord x, wxCoord y, wxCoord radius ) -->
-  <!-- void wxDC::DrawCircle( wxCoord x, wxCoord y, wxCoord radius ) -->
-  <function name="wxDC::DrawCircle,wxPaintDC::DrawCircle">
+  <!-- void wxGrid::SetRowLabelSize( int width ) -->
+  <function name="wxGrid::SetRowLabelSize">
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="3" direction="in">
-      <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxDC::DrawArc(wxCoord xStart, wxCoord yStart, wxCoord xEnd, wxCoord yEnd, wxCoord xc, wxCoord yc) -->
-  <!-- void wxPaintDC::DrawArc(wxCoord xStart, wxCoord yStart, wxCoord xEnd, wxCoord yEnd, wxCoord xc, wxCoord yc) -->
-  <function name="wxDC::DrawArc,wxPaintDC::DrawArc">
+  <!--         void wxWindow::SetWindowStyle(long style)     -->
+  <!--         void wxTextCtrl::SetWindowStyle(long style)   -->
+  <!--         void wxStaticText::SetWindowStyle(long style) -->
+  <!--         void wxStaticLine::SetWindowStyle(long style) -->
+  <!-- virtual void wxWindow::SetWindowStyleFlag(long style) -->
+  <!-- virtual void wxTextCtrl::SetWindowStyleFlag(long style) -->
+  <function name="wxWindow::SetWindowStyle,wxWindow::SetWindowStyleFlag,wxTextCtrl::SetWindowStyle,wxStaticText::SetWindowStyle,wxStaticLine::SetWindowStyle,wxTextCtrl::SetWindowStyleFlag">
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="any" direction="in">
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxDC::DrawCheckMark(wxCoord x,wxCoord y, wxCoord width, wxCoord height) -->
-  <function name="wxDC::DrawCheckMark,wxPaintDC::DrawCheckMark">
+  <!-- void wxStyledTextCtrl::SetLexer(int lexer) -->
+  <!-- void wxStyledTextCtrl::SetMainSelection(int selection) -->
+  <!-- void wxStyledTextCtrl::SetMarginLeft(int l) -->
+  <!-- void wxStyledTextCtrl::SetMarginRight(int r) -->
+  <!-- void wxStyledTextCtrl::SetMarginOptions(int opt) -->
+  <!-- void wxStyledTextCtrl::SetModEventMask(int mask) -->
+  <function name="wxStyledTextCtrl::SetLexer,wxStyledTextCtrl::SetMainSelection,wxStyledTextCtrl::SetMarginLeft,wxStyledTextCtrl::SetMarginRight,wxStyledTextCtrl::SetMarginOptions,wxStyledTextCtrl::SetModEventMask">
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="any" direction="in">
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- wxColour wxGrid::GetCellBackgroundColour (int row, int col) const -->
-  <!-- wxColour wxGrid::GetCellFont (int row, int col) const -->
-  <function name="wxGrid::GetCellBackgroundColour,wxGrid::GetCellFont">
-    <leak-ignore/>
+  <!-- bool     wxRegEx::GetMatch(size_t * start, size_t * len, size_t index = 0) const -->
+  <!-- wxString wxRegEx::GetMatch(const wxString & text, size_t index = 0) const -->
+  <function name="wxRegEx::GetMatch">
     <noreturn>false</noreturn>
-    <returnValue type="wxColour"/>
-    <use-retval/>
     <const/>
-    <arg nr="1" direction="in">
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="out"/>
+    <arg nr="2" default="0" direction="out">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="2" direction="in">
+    <arg nr="3" default="0" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- wxString wxDataViewListCtrl::GetTextValue(unsigned int row, unsigned int col) const  -->
-  <function name="wxDataViewListCtrl::GetTextValue">
-    <leak-ignore/>
+  <!-- void wxStyledTextCtrl::SetMarginSensitive( int margin, bool sensitive ) -->
+  <function name="wxStyledTextCtrl::SetMarginSensitive">
     <noreturn>false</noreturn>
-    <returnValue type="wxString"/>
-    <use-retval/>
-    <const/>
+    <returnValue type="void"/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
-      <valid>0:</valid>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
-      <valid>0:</valid>
     </arg>
   </function>
-  <!-- bool wxDataViewListCtrl::GetToggleValue(unsigned int row, unsigned int col) const  -->
-  <function name="wxDataViewListCtrl::GetToggleValue">
-    <leak-ignore/>
+  <!-- void wxStyledTextCtrl::SetMarginMask( int margin, int mask ) -->
+  <function name="wxStyledTextCtrl::SetMarginMask">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <use-retval/>
-    <const/>
+    <returnValue type="void"/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
-      <valid>0:</valid>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
-      <valid>0:</valid>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxDC::SetBackgroundMode(int mode) -->
-  <!-- void wxBufferedDC::SetBackgroundMode(int mode) -->
-  <function name="wxDC::SetBackgroundMode,wxBufferedDC::SetBackgroundMode">
+  <!-- virtual void wxPen::SetStyle(wxPenStyle style) -->
+  <function name="wxPen::SetStyle">
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
+    <arg nr="1" direction="in"/>
   </function>
-  <!-- void wxInfoBar::ShowMessage(const wxString & msg, int flags = wxICON_INFORMATION)-->
-  <function name="wxInfoBar::ShowMessage">
+  <!-- template<typename EventTag , typename Class , typename EventArg , typename EventHandler >
+       void wxEvtHandler::Bind(const EventTag & eventType, void(Class::*)(EventArg &) method, EventHandler * handler, int id = wxID_ANY, int lastId = wxID_ANY, wxObject * userData = NULL) -->
+  <!-- void wxSpinCtrl::Bind(const EventTag & eventType, void(wxSpinCtrl::*)(EventArg &) method, EventHandler * handler, int id = wxID_ANY, int lastId = wxID_ANY, wxObject * userData = NULL) -->
+  <!-- void wxButton::Bind(const EventTag & eventType, void(wxSpinCtrl::*)(EventArg &) method, EventHandler * handler, int id = wxID_ANY, int lastId = wxID_ANY, wxObject * userData = NULL) -->
+  <!-- void wxRadioButton::Bind(const EventTag & eventType, void(wxSpinCtrl::*)(EventArg &) method, EventHandler * handler, int id = wxID_ANY, int lastId = wxID_ANY, wxObject * userData = NULL) -->
+  <function name="wxEvtHandler::Bind,wxSpinCtrl::Bind,wxButton::Bind,wxRadioButton::Bind">
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in" default="wxICON_INFORMATION">
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="inout">
+      <not-null/>
+    </arg>
+    <arg nr="4" direction="in" default="wxID_ANY">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" direction="in" default="wxID_ANY">
+      <not-uninit/>
+    </arg>
+    <arg nr="6" direction="inout" default="NULL">
       <not-uninit/>
     </arg>
   </function>
-  <!-- virtual void wxPen::SetColour(const wxColour & colour) -->
-  <!-- virtual void wxPen::SetColour(unsigned char red, unsigned char green, unsigned char blue) -->
-  <function name="wxPen::SetColour">
+  <!-- void wxStockGDI::DeleteAll( void ) -->
+  <function name="wxStockGDI::DeleteAll">
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="any" direction="in"/>
   </function>
-  <!-- void wxPen::SetWidth( int width ) -->
-  <function name="wxPen::SetWidth">
+  <!-- void wxStopWatch::Pause( void ) -->
+  <!-- void wxStopWatch::Resume( void ) -->
+  <function name="wxStopWatch::Pause,wxStopWatch::Resume">
+    <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
+  </function>
+  <!-- long wxStopWatch::Time(void) const -->
+  <function name="wxStopWatch::Time">
     <leak-ignore/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-      <valid>0:</valid>
-    </arg>
+    <noreturn>false</noreturn>
+    <returnValue type="long"/>
+    <use-retval/>
+    <const/>
   </function>
-  <!-- void wxDC::SetBackground(const wxBrush & brush) -->
-  <!-- void wxBufferedDC::SetBackground(const wxBrush & brush) -->
-  <!-- void wxMemoryDC::SetBackground(const wxBrush & brush) -->
-  <!-- void wxGCDC::SetBackground(const wxBrush & brush) -->
-  <function name="wxDC::SetBackground,wxBufferedDC::SetBackground,wxMemoryDC::SetBackground,wxGCDC::SetBackground">
+  <!-- wxLongLong wxStopWatch::TimeInMicro(void) const -->
+  <function name="wxStopWatch::TimeInMicro">
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in"/>
+    <returnValue type="wxLongLong"/>
+    <use-retval/>
+    <const/>
   </function>
-  <!-- void wxPropertyGridManager::SetColumnTitle( int idx, const wxString & title ) -->
-  <function name="wxPropertyGridManager::SetColumnTitle">
+  <!-- void wxStopWatch::Start(long milliseconds = 0) -->
+  <function name="wxStopWatch::Start">
+    <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
+    <arg nr="1" default="0" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxBrush * wxStockGDI::GetBrush( Item item ) -->
+  <function name="wxStockGDI::GetBrush">
     <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="wxBrush *"/>
+    <use-retval/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="2" direction="in"/>
   </function>
-  <!-- wxRect & wxRect::Inflate( const wxSize & d ) -->
-  <!-- wxRect & wxRect::Deflate( const wxSize & d ) -->
-  <function name="wxRect::Inflate,wxRect::Deflate">
+  <!-- wxColour * wxStockGDI::GetColour( Item item ) -->
+  <function name="wxStockGDI::GetColour">
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="wxRect &amp;"/>
+    <returnValue type="wxColour *"/>
+    <use-retval/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!-- void wxStyledTextCtrl::StyleSetForeground( int style, const wxColour & fore ) -->
-  <function name="wxStyledTextCtrl::StyleSetForeground">
+  <!-- wxCursor * wxStockGDI::GetCursor( Item item ) -->
+  <function name="wxStockGDI::GetCursor">
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="wxCursor *"/>
+    <use-retval/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="2" direction="in"/>
   </function>
-  <!-- wxString wxString::AfterFirst( wxUniChar ch ) const -->
-  <!-- wxString wxString::AfterLast( wxUniChar ch ) const -->
-  <function name="wxString::AfterFirst,wxString::AfterLast">
+  <!-- wxFont * wxStockGDI::GetFont( Item item ) -->
+  <function name="wxStockGDI::GetFont">
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="wxString"/>
-    <const/>
+    <returnValue type="wxFont *"/>
+    <use-retval/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!-- wxString & wxString::Append (const char *psz)                    -->
-  <!-- wxString & wxString::Append (const wchar_t *pwz)                 -->
-  <!-- wxString & wxString::Append (const char *psz, size_t nLen)    (*)-->
-  <!-- wxString & wxString::Append (const wchar_t *pwz, size_t nLen) (*)-->
-  <!-- wxString & wxString::Append (const wxString &s)               (+)-->
-  <!-- wxString & wxString::Append (wxUniChar ch, size_t count=1u)   (*)-->
-  <!-- wxString & wxString::append (const char *psz)                    -->
-  <!-- wxString & wxString::append (const wchar_t *pwz)                 -->
-  <!-- wxString & wxString::append (const char *psz, size_t nLen)    (*)-->
-  <!-- wxString & wxString::append (const wchar_t *pwz, size_t nLen) (*)-->
-  <!-- wxString & wxString::append (const wxString &s)               (+)-->
-  <!-- wxString & wxString::append (wxUniChar ch, size_t count=1u)   (*)-->
-  <!-- wxString & wxString::append (const_iterator first, const_iterator last) (*)-->
-  <function name="wxString::Append,wxString::append">
+  <!-- wxPen * wxStockGDI::GetPen( Item item ) -->
+  <function name="wxStockGDI::GetPen">
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="wxString &amp;"/>
+    <returnValue type="wxPen *"/>
+    <use-retval/>
     <arg nr="1" direction="in">
-      <!-- <not-uninit/> Avoid FPs (+)-->
-      <not-null/>
+      <not-uninit/>
     </arg>
-    <!--(*) 2.arg version not supported -->
   </function>
-  <!-- wxWindow * wxWindowBase::FindWindow(long id) const -->
-  <!-- wxWindow * wxWindowBase::FindWindow(const wxString & name)  const -->
-  <!-- wxWindow * wxWindow::FindWindow(long id) const -->
-  <!-- wxWindow * wxWindow::FindWindow(const wxString & name)  const -->
-  <!-- wxWindow * wxDialog::FindWindow(long id) const -->
-  <!-- wxWindow * wxDialog::FindWindow(const wxString & name)  const -->
-  <function name="wxWindowBase::FindWindow,wxWindow::FindWindow,wxDialog::FindWindow">
+  <!-- int wxRemove(const wxString &path); -->
+  <function name="wxRemove">
+    <returnValue type="int"/>
     <noreturn>false</noreturn>
-    <returnValue type="wxWindow *"/>
-    <use-retval/>
-    <const/>
+    <leak-ignore/>
     <arg nr="1" direction="in"/>
   </function>
-  <!--static wxWindow* wxWindow::FindWindowById(long id, const wxWindow * parent = 0) -->
-  <function name="wxWindow::FindWindowById">
+  <!-- wxStockGDI & wxStockGDI::instance( void ) -->
+  <function name="wxStockGDI::instance">
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="wxWindow*"/>
+    <returnValue type="wxStockGDI &amp;"/>
     <use-retval/>
-    <arg nr="1" direction="in">
+  </function>
+  <!-- bool wxRemoveFile( const wxString & file ) -->
+  <function name="wxRemoveFile">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxRenameFile( const wxString & oldpath, const wxString & newpath, bool overwrite = true ) -->
+  <function name="wxRenameFile">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in" default="true">
       <not-uninit/>
     </arg>
+  </function>
+  <!-- int wxRmDir( const wxString & path ) -->
+  <function name="wxRmDir">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxRmdir( const wxString & dir, int flags = 0 ) -->
+  <function name="wxRmdir">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
     <arg nr="2" direction="in" default="0">
       <not-uninit/>
     </arg>
   </function>
-  <!-- void wxRect::SetX( int xx ) -->
-  <!-- void wxRect::SetY( int yy ) -->
-  <function name="wxRect::SetX,wxRect::SetY">
+  <!-- bool wxSetWorkingDirectory( const wxString & d ) -->
+  <function name="wxSetWorkingDirectory">
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int wxPrintf(const char *format, ...); -->
+  <function name="wxPrintf">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <formatstr/>
     <arg nr="1" direction="in">
+      <formatstr/>
       <not-uninit/>
     </arg>
   </function>
-  <!-- int wxImageList::Add( const wxBitmap & bitmap, const wxBitmap & mask = wxNullBitmap ) -->
-  <function name="wxImageList::Add">
+  <!-- void wxBell( void ) -->
+  <function name="wxBell">
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="int"/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in" default="wxNullBitmap"/>
+    <returnValue type="void"/>
   </function>
-  <!-- virtual wxPGVIterator wxPropertyGridInterface::GetVIterator(int flags) const -->
-  <!-- virtual wxPGVIterator wxPropertyGrid::GetVIterator(int flags) const -->
-  <function name="wxPropertyGridInterface::GetVIterator,wxPropertyGrid::GetVIterator">
+  <!-- void wxPostEvent( wxEvtHandler * dest, const wxEvent & event ) -->
+  <function name="wxPostEvent">
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <const/>
-    <returnValue type="wxPGVIterator"/>
-    <use-retval/>
-    <arg nr="1" direction="in">
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
       <not-uninit/>
+      <not-null/>
     </arg>
+    <arg nr="2" direction="in"/>
   </function>
-  <!-- wxArrayString wxStringTokenize(const wxString & str, const wxString & delims = wxDEFAULT_DELIMITERS, wxStringTokenizerMode mode = wxTOKEN_DEFAULT) -->
-  <function name="wxStringTokenize">
+  <!-- void wxQueueEvent( wxEvtHandler * dest, wxEvent * event ) -->
+  <function name="wxQueueEvent">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+  </function>
+  <!-- bool wxIsupper( const wxUniChar & c ) -->
+  <!-- bool wxIsxdigit( const wxUniChar & c ) -->
+  <!-- bool wxIsspace( const wxUniChar & c ) -->
+  <!-- bool wxIspunct( const wxUniChar & c ) -->
+  <!-- bool wxIsprint( const wxUniChar & c ) -->
+  <!-- bool wxIslower( const wxUniChar & c ) -->
+  <!-- bool wxIsgraph( const wxUniChar & c ) -->
+  <!-- bool wxIsdigit( const wxUniChar & c ) -->
+  <!-- bool wxIscntrl( const wxUniChar & c ) -->
+  <!-- bool wxIsascii( const wxUniChar & c ) -->
+  <!-- bool wxIsalpha( const wxUniChar & c ) -->
+  <!-- bool wxIsalnum( const wxUniChar & c ) -->
+  <function name="wxIsupper,wxIsxdigit,wxIsspace,wxIspunct,wxIsprint,wxIslower,wxIsgraph,wxIsdigit,wxIsctrl,wxIscntrl,wxIsascii,wxIsalpha,wxIsalnum">
+    <use-retval/>
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="wxArrayString"/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- int wxIsctrl( const wxUniChar & c ) -->
+  <function name="wxIsctrl">
     <use-retval/>
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
     <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in" default="wxDEFAULT_DELIMITERS"/>
-    <arg nr="3" direction="in" default="wxTOKEN_DEFAULT"/>
   </function>
-  <!-- ssize_t wxFile::Read( void * pBuf, size_t nCount ) -->
-  <function name="wxFile::Read">
+  <!-- void wxGrid::SetCellRenderer( int row, int col, wxGridCellRenderer * renderer ) -->
+  <function name="wxGrid::SetCellRenderer">
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="ssize_t"/>
-    <use-retval/>
-    <arg nr="1" direction="inout">
-      <not-null/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
-      <valid>1:</valid>
     </arg>
-  </function>
-  <!-- bool wxFile::Eof( void ) const -->
-  <function name="wxFile::Eof">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <use-retval/>
-    <const/>
-  </function>
-  <!-- bool wxFile::Seek( wxFileOffset ofs, wxSeekMode mode = wxFromStart ) -->
-  <function name="wxFFile::Seek">
-    <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" default="wxFromStart" direction="in">
+    <arg nr="3" direction="inout">
       <not-uninit/>
+      <not-null/>
     </arg>
   </function>
-  <!-- bool wxFFile::SeekEnd( wxFileOffset ofs = 0 ) -->
-  <function name="wxFFile::SeekEnd">
+  <!-- void wxNavigationKeyEvent::SetWindowChange(bool windowChange) -->
+  <!-- void wxNavigationKeyEvent::SetFromTab(bool fromTab) -->
+  <!-- void wxNavigationKeyEvent::SetDirection(bool direction) -->
+  <!-- void wxNavigationKeyEvent::SetFlags(long flags) -->
+  <function name="wxNavigationKeyEvent::SetWindowChange,wxNavigationKeyEvent::SetFromTab,wxNavigationKeyEvent::SetFlags,wxNavigationKeyEvent::SetDirection">
+    <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <arg nr="1" default="0" direction="in">
+    <returnValue type="void"/>
+    <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!-- void wxGridTableBase::SetValueAsDouble( int row, int col, double value ) -->
-  <!-- void wxGridTableBase::SetValueAsBool( int row, int col, bool value ) -->
-  <!-- void wxGridTableBase::SetValueAsLong( int row, int col, longs value ) -->
-  <function name="wxGridTableBase::SetValueAsDouble,wxGridTableBase::SetValueAsDouble,wxGridTableBase::SetValueAsLong">
+  <!-- void wxGrid::SetDefaultCellAlignment( int horiz, int vert ) -->
+  <function name="wxGrid::SetDefaultCellAlignment">
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
@@ -9077,42 +14334,40 @@
     <arg nr="2" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="3" direction="in">
-      <not-uninit/>
-    </arg>
   </function>
-  <!-- void wxGridTableBase::SetValueAsLong( int row, int col, const wxString &value ) -->
-  <function name="wxGridTableBase::SetValue">
+  <!-- void wxGrid::SetColLabelSize( int height ) -->
+  <function name="wxGrid::SetColLabelSize">
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="2" direction="in">
+  </function>
+  <!-- void wxGrid::EnableGridLines( bool enable = true ) -->
+  <function name="wxGrid::EnableGridLines">
+    <leak-ignore/>
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in" default="true">
       <not-uninit/>
     </arg>
-    <arg nr="3" direction="in"/>
   </function>
-  <!-- bool wxGridTableBase::GetValueAsBool( int row, int col ) -->
-  <function name="wxGridTableBase::GetValueAsBool">
+  <!-- void wxGrid::EnableEditing( bool edit ) -->
+  <function name="wxGrid::EnableEditing">
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <use-retval/>
+    <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
-    </arg>
   </function>
-  <!-- double wxGridTableBase::GetValueAsDouble( int row, int col ) -->
-  <function name="wxGridTableBase::GetValueAsDouble">
+  <!-- void wxGrid::SetRowLabelAlignment( int horiz, int vert ) -->
+  <!-- void wxGrid::SetColLabelAlignment( int horiz, int vert ) -->
+  <function name="wxGrid::SetRowLabelAlignment,wxGrid::SetColLabelAlignment">
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="double"/>
-    <use-retval/>
+    <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
@@ -9120,1123 +14375,1357 @@
       <not-uninit/>
     </arg>
   </function>
-  <!-- long wxGridTableBase::GetValueAsLong( int row, int col ) -->
-  <function name="wxGridTableBase::GetValueAsLong">
+  <!-- void wxGrid::EnableDragRowSize( bool enable = true ) -->
+  <!-- void wxGrid::EnableDragGridSize( bool enable = true ) -->
+  <!-- void wxGrid::EnableDragColSize( bool enable = true ) -->
+  <!-- void wxGrid::EnableDragColMove( bool enable = true ) -->
+  <function name="wxGrid::EnableDragRowSize,wxGrid::EnableDragGridSize,wxGrid::EnableDragColSize,wxGrid::EnableDragColMove">
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="long"/>
-    <use-retval/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in">
+    <returnValue type="void"/>
+    <arg nr="1" direction="in" default="true">
       <not-uninit/>
     </arg>
   </function>
-  <!-- wxString wxGridTableBase::GetValue( int row, int col ) -->
-  <function name="wxGridTableBase::GetValue">
+  <!-- virtual bool wxDataViewCtrl::SetRowHeight(int rowHeight) -->
+  <!--         bool wxDataViewTreeCtrl::SetRowHeight(int rowHeight) -->
+  <!--         bool wxDataViewListCtrl::SetRowHeight(int rowHeight) -->
+  <function name="wxDataViewCtrl::SetRowHeight,wxDataViewTreeCtrl::SetRowHeight,wxDataViewListCtrl::SetRowHeight">
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="wxString"/>
-    <use-retval/>
+    <returnValue type="bool"/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
-    </arg>
   </function>
-  <!-- bool wxGridTableBase::CanSetValueAs( int row, int col, const wxString & typeName ) -->
-  <!-- bool wxGridTableBase::CanGetValueAs( int row, int col, const wxString & typeName ) -->
-  <function name="wxGridTableBase::CanSetValueAs,wxGridTableBase::CanGetValueAs">
+  <!-- void wxDC::DrawPoint( wxCoord x, wxCoord y ) -->
+  <function name="wxDC::DrawPoint">
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <use-retval/>
+    <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="3" direction="in"/>
   </function>
-  <!-- void wxPen::SetCap( wxPenCap cap ) -->
-  <function name="wxPen::SetCap">
+  <!-- virtual void wxDataViewCtrl::Expand(const wxDataViewItem & item) -->
+  <!--         void wxDataViewListCtrl::Expand(const wxDataViewItem & item) -->
+  <!--         void wxDataViewTreeCtrl::Expand(const wxDataViewItem & item) -->
+  <function name="wxDataViewCtrl::Expand,wxDataViewListCtrl::Expand,wxDataViewTreeCtrl::Expand">
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <arg nr="1" direction="in"/>
   </function>
-  <!--static wxString wxLocale::GetInfo(wxLocaleInfo index, wxLocaleCategory cat = wxLOCALE_CAT_DEFAULT) -->
-  <function name="wxLocale::GetInfo">
+  <!-- virtual void wxWindow::Update(void) -->
+  <function name="wxWindow::Update">
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="wxString"/>
-    <use-retval/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in" default="wxLOCALE_CAT_DEFAULT"/>
+    <returnValue type="void"/>
   </function>
-  <!-- int wxItemContainer::Append( const wxString & item ) -->
-  <!-- int wxComboBox::Append( const wxString & item ) -->
-  <function name="wxItemContainer::AppendItems,wxComboBox::Append">
+  <!-- virtual bool wxGenericProgressDialog::Update(int value, const wxString & newmsg = wxEmptyString, bool * skip = NULL) -->
+  <!--         bool wxProgressDialog::Update(int value, const wxString & newmsg = wxEmptyString, bool * skip = NULL) -->
+  <function name="wxGenericProgressDialog::Update,wxProgressDialog::Update">
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="int"/>
-    <arg nr="1" direction="in"/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in" default="wxEmptyString"/>
+    <arg nr="3" direction="inout" default="NULL">
+      <not-uninit/>
+    </arg>
   </function>
-  <!-- virtual void wxSlider::SetValue(int value) -->
-  <function name="wxSlider::SetValue">
+  <!-- wxCoord wxMouseEvent::GetX( void ) const -->
+  <!-- wxCoord wxMouseEvent::GetY( void ) const -->
+  <!-- wxCoord wxMouseState::GetX( void ) const -->
+  <!-- wxCoord wxMouseState::GetY( void ) const -->
+  <function name="wxMouseEvent::GetX,wxMouseEvent::GetY,wxMouseState::GetY,wxMouseState::GetX">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxCoord"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- virtual wxString wxComboCtrl::GetValue( void ) const -->
+  <!-- virtual wxString wxOwnerDrawnComboBox::GetValue( void ) const -->
+  <function name="wxComboCtrl::GetValue,wxOwnerDrawnComboBox::GetValue">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxString"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- bool wxGridCellAttr::CanOverflow( void ) const -->
+  <function name="wxGridCellAttr::CanOverflow">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="bool"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- wxGridCellAttr * wxGridCellAttr::Clone( void ) const -->
+  <function name="wxGridCellAttr::Clone">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxGridCellAttr *"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- wxPropertyGrid * wxPGProperty::GetGrid( void ) const -->
+  <function name="wxPGProperty::GetGrid">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxPropertyGrid *"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- int wxWithImages::GetImageCount( void ) const -->
+  <!-- int wxBookCtrlBase::GetImageCount( void ) const -->
+  <function name="wxWithImages::GetImageCount,wxBookCtrlBase::GetImageCount">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="int"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- wxImageList * wxWithImages::GetImageList( void ) const -->
+  <!-- wxImageList * wxBookCtrlBase::GetImageList( void ) const -->
+  <function name="wxWithImages::GetImageList,wxBookCtrlBase::GetImageList">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxImageList *"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- void wxFocusEvent::Skip(bool skip = true) -->
+  <!-- void wxSpinEvent::Skip(bool skip = true) -->
+  <!-- void wxEvent::Skip(bool skip = true) -->
+  <!-- void wxCommandEvent::Skip(bool skip = true) -->
+  <!-- void wxKeyEvent::Skip(bool skip = true) -->
+  <!-- void wxGridEvent::Skip(bool skip = true) -->
+  <!-- void wxMouseEvent::Skip(bool skip = true) -->
+  <function name="wxEvent::Skip,wxCommandEvent::Skip,wxKeyEvent::Skip,wxGridEvent::Skip,wxMouseEvent::Skip,wxFocusEvent::Skip,wxSpinEvent::Skip">
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="in">
+    <arg nr="1" default="true" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!-- void wxPGProperty::SetLabel(const wxString & label) -->
-  <function name="wxPGProperty::SetLabel">
+  <!-- virtual void wxPopupTransientWindow::OnDismiss ( void ) -->
+  <function name="wxPopupTransientWindow::OnDismiss">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="void"/>
+  </function>
+  <!-- void wxPropertyGridManager::SetColumnCount(int colCount, int page = -1) -->
+  <function name="wxPropertyGridManager::SetColumnCount">
     <leak-ignore/>
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="in"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <valid>1:</valid>
+    </arg>
+    <arg nr="2" default="-1" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
-  <!-- wxSize wxDC::GetSize( void ) const -->
-  <!-- wxSize wxDC::GetSizeMM( void ) const -->
-  <!-- wxSize wxGCDC::GetSizeMM( void ) const -->
-  <!-- wxSize wxGCDC::GetSize( void ) const -->
-  <!-- wxSize wxClientDC::GetSize( void ) const-->
-  <!-- wxSize wxClientDC::GetSizeMM( void ) const-->
-  <!-- wxSize wxPaintDC::GetSize( void ) const -->
-  <!-- wxSize wxPaintDC::GetSizeMM( void ) const -->
-  <!-- wxSize wxBufferedPaintDC::GetSize( void ) const -->
-  <!-- wxSize wxBufferedPaintDC::GetSizeMM( void ) const -->
-  <!-- wxSize wxAutoBufferedPaintDC::GetSize( void ) const -->
-  <!-- wxSize wxAutoBufferedPaintDC::GetSizeMM( void ) const -->
-  <function name="wxDC::GetSizeMM,wxDC::GetSize,wxGCDC::GetSizeMM,wxGCDC::GetSize,wxClientDC::GetSize,wxClientDC::GetSizeMM,wxPaintDC::GetSize,wxPaintDC::GetSizeMM,wxBufferedPaintDC::GetSize,wxBufferedPaintDC::GetSizeMM,wxAutoBufferedPaintDC::GetSize,wxAutoBufferedPaintDC::GetSizeMM">
+  <!-- virtual bool wxStatusBar::GetFieldRect( int i, wxRect & rect ) const -->
+  <function name="wxStatusBar::GetFieldRect">
+    <leak-ignore/>
     <noreturn>false</noreturn>
+    <returnValue type="bool"/>
     <const/>
-    <leak-ignore/>
-    <returnValue type="wxSize"/>
-    <use-retval/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="out"/>
   </function>
-  <!-- wxDataViewColumn* wxDataViewListCtrl::AppendTextColumn(const wxString & label, wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT, int width = -1, wxAlignment align = wxALIGN_LEFT, int flags = wxDATAVIEW_COL_RESIZABLE) -->
-  <!-- wxDataViewColumn* wxDataViewListCtrl::AppendToggleColumn(const wxString & label, wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT, int width = -1, wxAlignment align = wxALIGN_LEFT, int flags = wxDATAVIEW_COL_RESIZABLE) -->
-  <!-- wxDataViewColumn* wxDataViewListCtrl::AppendProgressColumn(const wxString & label, wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT, int width = -1, wxAlignment align = wxALIGN_LEFT, int flags = wxDATAVIEW_COL_RESIZABLE) -->
-  <!-- wxDataViewColumn* wxDataViewListCtrl::AppendIconTextColumn(const wxString & label, wxDataViewCellMode mode = wxDATAVIEW_CELL_INERT, int width = -1, wxAlignment align = wxALIGN_LEFT, int flags = wxDATAVIEW_COL_RESIZABLE) -->
-  <function name="wxDataViewListCtrl::AppendTextColumn,wxDataViewListCtrl::AppendToggleColumn,wxDataViewListCtrl::AppendProgressColumn,wxDataViewListCtrl::AppendIconTextColumn">
+  <!-- wxDataViewItem wxDataViewTreeCtrl::AppendContainer(const wxDataViewItem & parent, const wxString & text, int icon = -1, int expanded = -1, wxClientData * data = NULL) -->
+  <function name="wxDataViewTreeCtrl::AppendContainer">
     <leak-ignore/>
     <noreturn>false</noreturn>
-    <returnValue type="wxDataViewColumn*"/>
+    <returnValue type="wxDataViewItem"/>
     <arg nr="1" direction="in"/>
-    <arg nr="2" default="wxDATAVIEW_CELL_INERT" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="3" default="-1" direction="in">
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in" default="-1">
       <not-uninit/>
     </arg>
-    <arg nr="4" default="wxALIGN_LEFT" direction="in">
+    <arg nr="4" direction="in" default="-1">
       <not-uninit/>
     </arg>
-    <arg nr="5" default="wxDATAVIEW_COL_RESIZABLE" direction="in">
+    <arg nr="5" direction="out" default="NULL">
       <not-uninit/>
     </arg>
   </function>
-  <!-- void wxGrid::SetColSize( int col, int width ) -->
-  <function name="wxGrid::SetColSize">
+  <!-- int wxString::Find (wxUniChar ch, bool fromEnd=false) const -->
+  <!-- int wxString::Find (const wxString &sub) const -->
+  <function name="wxString::Find">
+    <use-retval/>
+    <const/>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <arg nr="any" direction="in"/>
+  </function>
+  <!-- int wxString::First (const wxUniChar ch) const -->
+  <!-- int wxString::First (const wxString &sub) const -->
+  <function name="wxString::First">
+    <use-retval/>
+    <const/>
     <leak-ignore/>
+    <returnValue type="int"/>
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
-    </arg>
+    <arg nr="any" direction="in"/>
+    <warn severity="style">This is a wxWidgets 1.xx compatibility function. Use 'wxString::Find' in new applications instead.</warn>
   </function>
-  <!--void wxGrid::SetCellBackgroundColour (int row, int col, const wxColour &colour) -->
-  <function name="wxGrid::SetCellBackgroundColour">
+  <!-- int wxString::Freq(wxUniChar ch) const -->
+  <function name="wxString::Freq">
+    <use-retval/>
+    <const/>
+    <leak-ignore/>
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <arg nr="any" direction="in"/>
+    <warn severity="style">This is a wxWidgets 1.xx compatibility function. You should not use it in new code.</warn>
+  </function>
+  <!-- size_t wxString::find(const wxString & str, size_t nStart = 0) const -->
+  <!-- size_t wxString::find(const char * sz     , size_t nStart = 0, size_t n = npos) const -->
+  <!-- size_t wxString::find(const wchar_t * sz  , size_t nStart = 0, size_t n = npos) const -->
+  <!-- size_t wxString::find(wxUniChar ch        , size_t nStart = 0,) const -->
+  <!-- size_t wxString::find_first_of(const wxString & str, size_t nStart = 0) const -->
+  <!-- size_t wxString::find_first_of(const char * sz     , size_t nStart = 0, size_t n = npos) const -->
+  <!-- size_t wxString::find_first_of(const wchar_t * sz  , size_t nStart = 0, size_t n = npos) const -->
+  <!-- size_t wxString::find_first_of(wxUniChar ch        , size_t nStart = 0,) const -->
+  <!-- size_t wxString::find_last_of(const wxString & str, size_t nStart = 0) const -->
+  <!-- size_t wxString::find_last_of(const char * sz     , size_t nStart = 0, size_t n = npos) const -->
+  <!-- size_t wxString::find_last_of(const wchar_t * sz  , size_t nStart = 0, size_t n = npos) const -->
+  <!-- size_t wxString::find_last_of(wxUniChar ch        , size_t nStart = 0,) const -->
+  <!-- size_t wxString::find_first_not_of(const wxString & str, size_t nStart = 0) const -->
+  <!-- size_t wxString::find_first_not_of(const char * sz     , size_t nStart = 0, size_t n = npos) const -->
+  <!-- size_t wxString::find_first_not_of(const wchar_t * sz  , size_t nStart = 0, size_t n = npos) const -->
+  <!-- size_t wxString::find_first_not_of(wxUniChar ch        , size_t nStart = 0,) const -->
+  <!-- size_t wxString::find_last_not_of (const wxString & str, size_t nStart = 0) const -->
+  <!-- size_t wxString::find_last_not_of (const char * sz     , size_t nStart = 0, size_t n = npos) const -->
+  <!-- size_t wxString::find_last_not_of (const wchar_t * sz  , size_t nStart = 0, size_t n = npos) const -->
+  <!-- size_t wxString::find_last_not_of (wxUniChar ch        , size_t nStart = 0,) const -->
+  <function name="wxString::find,wxString::find_last_of,wxString::find_first_of,wxString::find_first_not_of,wxString::find_last_not_of">
+    <use-retval/>
+    <const/>
     <leak-ignore/>
+    <returnValue type="std::size_t"/>
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="0">
       <not-uninit/>
     </arg>
-    <arg nr="2" direction="in">
+    <arg nr="3" direction="in" default="wxString::npos">
       <not-uninit/>
     </arg>
-    <arg nr="3" direction="in"/>
   </function>
-  <!--void wxGrid::SetCellEditor (int row, int col, wxGridCellEditor * editor) -->
-  <function name="wxGrid::SetCellEditor">
-    <leak-ignore/>
+  <!-- void wxDC::DrawRoundedRectangle( const wxRect & r, double radius ) -->
+  <!-- void wxPaintDC::DrawRoundedRectangle( const wxRect & r, double radius ) -->
+  <!-- void wxMemoryDC::DrawRoundedRectangle( const wxRect & r, double radius ) -->
+  <function name="wxDC::DrawRoundedRectangle,wxPaintDC::DrawRoundedRectangle,wxMemoryDC::DrawRoundedRectangle">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
     <arg nr="2" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="3" direction="inout">
-      <not-null/>
-    </arg>
   </function>
-  <!--virtual void wxGridCellEditor::StartingKey(wxKeyEvent & event)-->
-  <!--virtual void wxGridCellTextEditor::StartingKey(wxKeyEvent & event)-->
-  <function name="wxGridCellEditor::StartingKey,wxGridCellTextEditor::StartingKey">
-    <leak-ignore/>
+  <!-- void wxDC::DrawRotatedText( const wxString & text, wxCoord x, wxCoord y, double angle ) -->
+  <!-- void wxPaintDC::DrawRotatedText( const wxString & text, wxCoord x, wxCoord y, double angle ) -->
+  <!-- void wxMemoryDC::DrawRotatedText( const wxString & text, wxCoord x, wxCoord y, double angle ) -->
+  <function name="wxDC::DrawRotatedText,wxPaintDC::DrawRotatedText,wxMemoryDC::DrawRotatedText">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="in"/>
-  </function>
-  <!--virtual void wxGridCellEditor::Create(wxWindow * parent, wxWindowID id, wxEvtHandler * evtHandler)-->
-  <!--virtual void wxGridCellBoolEditor::Create(wxWindow * parent, wxWindowID id, wxEvtHandler * evtHandler)-->
-  <!--virtual void wxGridCellChoiceEditor::Create(wxWindow * parent, wxWindowID id, wxEvtHandler * evtHandler)-->
-  <!--virtual void wxGridCellTextEditor::Create(wxWindow * parent, wxWindowID id, wxEvtHandler * evtHandler)-->
-  <!--virtual void wxGridCellEnumEditor::Create(wxWindow * parent, wxWindowID id, wxEvtHandler * evtHandler)-->
-  <!--virtual void wxGridCellAutoWrapStringEditor::Create(wxWindow * parent, wxWindowID id, wxEvtHandler * evtHandler)-->
-  <!--virtual void wxGridCellFloatEditor::Create(wxWindow * parent, wxWindowID id, wxEvtHandler * evtHandler)-->
-  <!--virtual void wxGridCellNumberEditor::Create(wxWindow * parent, wxWindowID id, wxEvtHandler * evtHandler)-->
-  <function name="wxGridCellEditor::Create,wxGridCellBoolEditor::Create,wxGridCellChoiceEditor::Create,wxGridCellNumberEditor::Create,wxGridCellTextEditor::Create,wxGridCellEnumEditor::Create,wxGridCellAutoWrapStringEditor::Create,wxGridCellFloatEditor::Create">
     <leak-ignore/>
-    <noreturn>false</noreturn>
-    <returnValue type="void"/>
-    <arg nr="1" direction="inout">
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
       <not-uninit/>
-      <not-null/>
     </arg>
-    <arg nr="2" direction="in">
+    <arg nr="3" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="3" direction="inout">
+    <arg nr="4" direction="in">
       <not-uninit/>
-      <not-null/>
     </arg>
   </function>
-  <!-- wxToolBarToolBase* wxToolBar::AddTool(int toolId, const wxString & label, const wxBitmap & bitmap, const wxString & shortHelp = wxEmptyString, wxItemKind kind = wxITEM_NORMAL) -->
-  <function name="wxToolBar::AddTool">
-    <leak-ignore/>
+  <!-- void wxMenuBar::Enable(int id, bool enable)-->
+  <function name="wxMenuBar::Enable">
     <noreturn>false</noreturn>
-    <returnValue type="wxToolBarToolBase*"/>
-    <arg nr="1" direction="in">
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="any" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="2" direction="in"/>
-    <arg nr="3" direction="in"/>
-    <arg nr="4" direction="in" default="wxEmptyString"/>
-    <arg nr="5" direction="in" default="wxITEM_NORMAL"/>
   </function>
-  <!-- wxString wxString::SubString( size_t from, size_t to ) const -->
-  <function name="wxString::SubString">
+  <!-- void wxTextValidator::SetCharExcludes( const wxString & chars ) -->
+  <function name="wxTextValidator::SetCharExcludes">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
     <leak-ignore/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxStyledTextCtrl::ToggleFold( int line ) -->
+  <function name="wxStyledTextCtrl::ToggleFold">
     <noreturn>false</noreturn>
-    <returnValue type="wxString"/>
-    <use-retval/>
-    <const/>
+    <returnValue type="void"/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- wxString wxString::substr(size_t nStart = 0, size_t nLen = npos) const -->
-  <function name="wxString::substr">
-    <leak-ignore/>
+  <!-- void wxStyledTextCtrl::SetWrapMode( int wrapMode ) -->
+  <function name="wxStyledTextCtrl::SetWrapMode">
     <noreturn>false</noreturn>
-    <returnValue type="wxString"/>
-    <const/>
-    <use-retval/>
-    <arg nr="1" default="0" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="1" default="wxString::npos" direction="in">
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- wxString wxString::Mid( size_t first, size_t nCount=wxString::npos ) const -->
-  <function name="wxString::Mid">
-    <leak-ignore/>
+  <!-- int wxStyledTextCtrl::LineFromPosition( int pos ) const -->
+  <function name="wxStyledTextCtrl::LineFromPosition">
     <noreturn>false</noreturn>
-    <returnValue type="wxString"/>
+    <returnValue type="int"/>
     <use-retval/>
     <const/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in" default="wxString::npos">
-      <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxFont::SetPointSize( int pointsize ) -->
-  <function name="wxFont::SetPointSize">
-    <leak-ignore/>
+  <!-- int wxStyledTextCtrl::GetFoldLevel( int line ) const -->
+  <function name="wxStyledTextCtrl::GetFoldLevel">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <const/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- virtual bool wxNotebook::SetPageText(size_t page, const wxString & text) -->
-  <function name="wxNotebook::SetPageText">
-    <leak-ignore/>
+  <!-- void wxStyledTextCtrl::StyleSetFont( int styleNum, const wxFont & font ) -->
+  <function name="wxStyledTextCtrl::StyleSetFont">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
+    <returnValue type="void"/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in"/>
   </function>
-  <!-- virtual bool wxNotebook::SetPageImage(size_t page, const int imageId) -->
-  <function name="wxNotebook::SetPageImage">
-    <leak-ignore/>
+  <!-- void wxStyledTextCtrl::StyleSetBold( int style, bool bold ) -->
+  <!-- void wxStyledTextCtrl::SetMarginWidth(int margin, int pixelWidth) -->
+  <!-- void wxStyledTextCtrl::SetMarginType(int margin, int marginType) -->
+  <function name="wxStyledTextCtrl::StyleSetBold,wxStyledTextCtrl::SetMarginWidth,wxStyledTextCtrl::SetMarginType">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
+    <returnValue type="void"/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!-- virtual int wxNotebook::SetSelection( size_t nPage ) -->
-  <function name="wxNotebook::SetSelection">
-    <leak-ignore/>
+  <!-- void wxStyledTextCtrl::SetKeyWords( int keyWordSet, const wxString & keyWords ) -->
+  <function name="wxStyledTextCtrl::SetKeyWords">
     <noreturn>false</noreturn>
-    <returnValue type="int"/>
+    <returnValue type="void"/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
+    <arg nr="2" direction="in"/>
   </function>
-  <!-- static wxString wxString::FromUTF8( const char * utf8 )                   -->
-  <!-- static wxString wxString::FromUTF8Unchecked( const char * utf8 )          -->
-  <!-- static wxString wxString::FromUTF8Unchecked( const std::string & s ) (*)  -->
-  <function name="wxString::FromUTF8,wxString::FromUTF8Unchecked">
-    <leak-ignore/>
+  <!--void wxStyledTextCtrl::SetProperty(const wxString & key, const wxString & value) -->
+  <function name="wxStyledTextCtrl::SetProperty">
     <noreturn>false</noreturn>
-    <returnValue type="wxString"/>
-    <pure/>
-    <use-retval/>
-    <arg nr="1" direction="in">
-      <not-null/>
-    </arg>
-  </function>
-  <!-- bool wxZipOutputStream::PutNextEntry(const wxString & name, const wxDateTime & dt = wxDateTime::Now(), wxFileOffset 	size = wxInvalidOffset) -->
-  <function name="wxZipOutputStream::PutNextEntry">
+    <returnValue type="void"/>
     <leak-ignore/>
-    <noreturn>false</noreturn>
-    <returnValue type="bool"/>
     <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in" default="wxDateTime::Now()"/>
-    <arg nr="3" direction="in" default="wxInvalidOffset">
-      <not-uninit/>
-    </arg>
+    <arg nr="2" direction="in"/>
   </function>
-  <!-- void wxStyledTextCtrl::MarkerSetForeground(int markerNumber, const wxColour & fore)-->
-  <!-- void wxStyledTextCtrl::MarkerSetBackground(int markerNumber, const wxColour & back)-->
-  <!-- void wxStyledTextCtrl::MarkerSetBackgroundSelected(int markerNumber, const wxColour & back)-->
-  <function name="wxStyledTextCtrl::MarkerSetForeground,wxStyledTextCtrl::MarkerSetBackground,wxStyledTextCtrl::MarkerSetBackgroundSelected">
-    <leak-ignore/>
+  <!-- void wxStyledTextCtrl::StyleSetBackground( int style, const wxColour & back ) -->
+  <function name="wxStyledTextCtrl::StyleSetBackground">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in"/>
   </function>
-  <!--void wxPropertyGridInterface::SetPropertyAttribute(wxPGPropArg id, const wxString & attrName, wxVariant value, long argFlags = 0)-->
-  <!--void wxPropertyGridPage::SetPropertyAttribute(wxPGPropArg id, const wxString & attrName, wxVariant value, long argFlags = 0)-->
-  <!--void wxPropertyGridManager::SetPropertyAttribute(wxPGPropArg id, const wxString & attrName, wxVariant value, long argFlags = 0)-->
-  <function name="wxPropertyGridInterface::SetPropertyAttribute,wxPropertyGridPage::SetPropertyAttribute,wxPropertyGridManager::SetPropertyAttribute">
-    <leak-ignore/>
+  <!-- void wxGrid::UseNativeColHeader( bool native = true ) -->
+  <function name="wxGrid::UseNativeColHeader">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in"/>
-    <arg nr="3" direction="in"/>
-    <arg nr="4" direction="in" default="0">
+    <leak-ignore/>
+    <arg nr="1" default="true" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!-- virtual void wxGridCellEditor::BeginEdit(int row, int col, wxGrid * grid) -->
-  <!--         void wxGridCellBoolEditor::BeginEdit(int row, int col, wxGrid * grid) -->
-  <!--         void wxGridCellChoiceEditor::BeginEdit(int row, int col, wxGrid * grid) -->
-  <!--         void wxGridCellTextEditor::BeginEdit(int row, int col, wxGrid * grid) -->
-  <!--         void wxGridCellEnumEditor::BeginEdit(int row, int col, wxGrid * grid) -->
-  <!--         void wxGridCellAutoWrapStringEditor::BeginEdit(int row, int col, wxGrid * grid) -->
-  <!--         void wxGridCellFloatEditor::BeginEdit(int row, int col, wxGrid * grid) -->
-  <!--         void wxGridCellNumberEditor::BeginEdit(int row, int col, wxGrid * grid) -->
-  <function name="wxGridCellEditor::BeginEdit,wxGridCellBoolEditor::BeginEdit,wxGridCellNumberEditor::BeginEdit,wxGridCellChoiceEditor::BeginEdit,wxGridCellFloatEditor::BeginEdit,wxGridCellTextEditor::BeginEdit,wxGridCellEnumEditor::BeginEdit,wxGridCellAutoWrapStringEditor::BeginEdit">
-    <leak-ignore/>
+  <!-- bool wxGrid::SetTable(wxGridTableBase * table, bool takeOwnership = false, wxGridSelectionModes selmode = wxGridSelectCells) -->
+  <function name="wxGrid::SetTabler">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in">
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
       <not-uninit/>
-    </arg>
-    <arg nr="3" direction="inout">
       <not-null/>
     </arg>
-  </function>
-  <!-- void wxStyledTextCtrl::MarkerDefine(int markerNumber, int markerSymbol, const wxColour & foreground = wxNullColour, const wxColour & background = wxNullColour) -->
-  <function name="wxStyledTextCtrl::MarkerDefine">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in">
+    <arg nr="2" default="false" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="2" direction="in">
+    <arg nr="3" default="wxGridSelectCells" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="3" direction="in" default="wxNullColour"/>
-    <arg nr="4" direction="in" default="wxNullColour"/>
   </function>
-  <!-- void wxSleep( int nSecs ) -->
-  <!-- void wxMilliSleep( unsigned long milliseconds ) -->
-  <!-- void wxMicroSleep( unsigned long ns ) -->
-  <function name="wxSleep,wxMilliSleep,wxMicroSleep">
-    <leak-ignore/>
+  <!-- void wxGrid::SetTabBehaviour( TabBehaviour behaviour ) -->
+  <function name="wxGrid::SetTabBehaviour">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!-- void wxGrid::SetColFormatNumber( int col ) -->
-  <function name="wxGrid::SetColFormatNumber">
+  <!-- void wxPropertyGridInterface::SetPropertyValueString( wxPGPropArg id, const wxString & value ) -->
+  <!-- void wxPropertyGrid::SetPropertyValueString( wxPGPropArg id, const wxString & value ) -->
+  <function name="wxPropertyGridInterface::SetPropertyValueString,wxPropertyGrid::SetPropertyValueString">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
   </function>
-  <!-- void wxGrid::SetDefaultColSize( int width, bool resizeExistingCols = false ) -->
-  <function name="wxGrid::SetDefaultColSize">
+  <!-- void wxPropertyGridManager::SetSplitterPosition( int pos, int column = 0 ) -->
+  <!-- void wxPropertyGridPage::SetSplitterPosition( int pos, int column = 0 ) -->
+  <function name="wxPropertyGridManager::SetSplitterPosition,wxPropertyGridPage::SetSplitterPosition">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="2" default="false" direction="in">
+    <arg nr="2" default="0" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxGrid::SetDefaultRowSize( int height, bool resizeExistingRows = false ) -->
-  <function name="wxGrid::SetDefaultRowSize">
+  <!-- bool wxPropertyGridInterface::SetColumnProportion( unsigned int column, int proportion ) -->
+  <!-- bool wxPropertyGridPage::SetColumnProportion( unsigned int column, int proportion ) -->
+  <function name="wxPropertyGridInterface::SetColumnProportion,wxPropertyGridPage::SetColumnProportion">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="bool"/>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="2" default="false" direction="in">
+    <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxGrid::SetDefaultRenderer( wxGridCellRenderer * renderer ) -->
-  <function name="wxGrid::SetDefaultRenderer">
+  <!-- void wxPropertyGridManager::ShowHeader( bool show = true ) -->
+  <function name="wxPropertyGridManager::ShowHeader">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
-    <arg nr="1" direction="inout">
+    <arg nr="1" default="true" direction="in">
       <not-uninit/>
-      <not-null/>
     </arg>
   </function>
-  <!-- void wxSizer::SetMinSize(const wxSize & size) -->
-  <!-- void wxSizer::SetMinSize(int width, int height) -->
-  <function name="wxSizer::SetMinSize">
-    <leak-ignore/>
+  <!-- void wxRect::Offset( const wxPoint &pt ) -->
+  <!-- void wxRect::Offset( wxCoord dx, wxCoord dy ) -->
+  <function name="wxRect::Offset">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" default="0" direction="in">
-      <not-uninit/>
-    </arg>
-  </function>
-  <!-- void wxDC::SetDeviceOrigin(wxCoord x, wxCoord y) -->
-  <function name="wxDC::SetDeviceOrigin">
     <leak-ignore/>
-    <noreturn>false</noreturn>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
+    <arg nr="1" direction="in"/>
     <arg nr="2" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!-- virtual void wxWindow::SetMinSize(const wxSize & size) -->
-  <!-- virtual void wxWindow::SetMaxSize(const wxSize & size) -->
-  <!-- virtual void wxWindow::SetMinClientSize(const wxSize & size) -->
-  <!-- virtual void wxWindow::SetMaxClientSize(const wxSize & size) -->
-  <!--         void wxTextCtrl::SetMinSize(const wxSize & size) -->
-  <!--         void wxTextCtrl::SetMaxSize(const wxSize & size) -->
-  <!--         void wxStaticText::SetMinSize(const wxSize & size) -->
-  <!--         void wxStaticText::SetMaxSize(const wxSize & size) -->
-  <!--         void wxButton::SetMinSize(const wxSize & size) -->
-  <!--         void wxButton::SetMaxSize(const wxSize & size) -->
-  <function name="wxWindow::SetMinSize,wxWindow::SetMaxSize,wxWindow::SetMinClientSize,wxWindow::SetMaxClientSize,wxTextCtrl::SetMinSize,wxTextCtrl::SetMaxSize,wxStaticText::SetMinSize,wxStaticText::SetMaxSize,wxButton::SetMinSize,wxButton::SetMaxSize">
-    <leak-ignore/>
+  <!-- void wxPGProperty::SetHelpString(const wxString & helpString)-->
+  <function name="wxPGProperty::SetHelpString">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
+    <leak-ignore/>
     <arg nr="1" direction="in"/>
   </function>
-  <!--wxSize wxWindow::GetSize(void) const -->
-  <!--wxSize wxControl::GetSize(void) const -->
-  <function name="wxWindow::GetSize,wxControl::GetSize">
-    <leak-ignore/>
-    <const/>
+  <!-- wxRect wxRect::Intersect(const wxRect & rect) -->
+  <function name="wxRect::wxRect">
     <noreturn>false</noreturn>
+    <returnValue type="bool"/>
     <use-retval/>
-    <returnValue type="wxSize"/>
-  </function>
-  <!--wxSizer* wxWindow::GetSizer(void) const -->
-  <function name="wxWindow::GetSizer">
     <leak-ignore/>
-    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxRect::Intersects(const wxRect & rect) const -->
+  <function name="wxRect::Intersects">
     <noreturn>false</noreturn>
+    <returnValue type="bool"/>
     <use-retval/>
-    <returnValue type="wxSizer*"/>
-  </function>
-  <!--void wxRect::SetPosition(const wxPoint & pos) -->
-  <function name="wxRect::SetPosition">
     <leak-ignore/>
+    <const/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- void wxRect::SetLeftBottom( const wxPoint & p ) -->
+  <!-- void wxRect::SetLeftTop( const wxPoint & p ) -->
+  <!-- void wxRect::SetRightBottom( const wxPoint & p ) -->
+  <!-- void wxRect::SetRightTop( const wxPoint & p ) -->
+  <function name="wxRect::SetLeftBottom,wxRect::SetLeftTop,wxRect::SetRightBottom,wxRect::SetRightTop">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
+    <leak-ignore/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- void wxSpinCtrlDouble::Enable( bool enable = true ) -->
-  <!-- void wxToggleButton::Enable( bool enable = true ) -->
-  <!-- void wxStaticText::Enable( bool enable = true ) -->
-  <!-- void wxStaticBox::Enable( bool enable = true ) -->
-  <!-- void wxMenuItem::Enable( bool enable = true ) -->
-  <function name="wxSpinCtrlDouble::Enable,wxToggleButton::Enable,wxStaticText::Enable,wxStaticBox::Enable,wxMenuItem::Enable">
-    <leak-ignore/>
+  <!-- void wxRect::SetRight( int right ) -->
+  <!-- void wxRect::SetLeft( int left ) -->
+  <!-- void wxRect::SetWidth(int width)-->
+  <!-- void wxRect::SetHeight( int h ) -->
+  <function name="wxRect::SetRight,wxRect::SetLeft,wxRect::SetWidth,wxRect::SetHeight">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="in" default="true">
+    <leak-ignore/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxMenuItem::Check( bool enable = true ) -->
-  <function name="wxMenuItem::Check">
+  <!-- bool wxTextEntry::AutoComplete( wxTextCompleter * completer ) -->
+  <!-- bool wxTextEntry::AutoComplete( const wxArrayString & choices ) -->
+  <!-- bool wxSearchCtrl::AutoComplete( wxTextCompleter * completer ) -->
+  <!-- bool wxSearchCtrl::AutoComplete( const wxArrayString & choices ) -->
+  <function name="wxTextEntryBase::AutoComplete,wxSearchCtrl::AutoComplete">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- virtual bool wxTextEntry::SetHint (const wxString & hint) -->
+  <!-- virtual bool wxTextCtrl::SetHint (const wxString & hint) -->
+  <function name="wxTextEntry::SetHint,wxTextCtrl::SetHint">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
     <leak-ignore/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxTextCtrl::IsEmpty( void ) const -->
+  <function name="wxTextCtrl::IsEmpty">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="bool"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- void wxSearchCtrl::SetDescriptiveText(const wxString & text)-->
+  <function name="wxSearchCtrl::SetDescriptiveText">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="in" default="true">
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- virtual void wxSearchCtrl::ShowCancelButton(bool show) -->
+  <!-- virtual void wxSearchCtrl::ShowSearchButton(bool show) -->
+  <function name="wxSearchCtrl::ShowCancelButton">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!-- bool wxPropertyGridInterface::ClearSelection(bool validation = false) -->
-  <!-- bool wxPropertyGridManager::ClearSelection(bool validation = false) -->
-  <function name="wxPropertyGridInterface::ClearSelection,wxPropertyGridManager::ClearSelection">
-    <leak-ignore/>
+  <!-- bool wxPGProperty::SetChoices(wxPGChoices & choices) -->
+  <function name="wxPGProperty::SetChoices">
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
-    <arg nr="1" direction="in" default="false">
-      <not-uninit/>
-    </arg>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!-- template <class T> const T wxMin(const T& a, const T& b); -->
-  <function name="wxMin">
-    <use-retval/>
+  <!-- void wxPropertyGridInterface::SetPropertyHelpString(wxPGPropArg id, const wxString & helpString) -->
+  <!-- void wxPropertyGridPage::SetPropertyHelpString(wxPGPropArg id, const wxString & helpString) -->
+  <function name="wxPropertyGridInterface::SetPropertyHelpString,wxPropertyGridPage::SetPropertyHelpString">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
     <leak-ignore/>
-    <returnValue>arg1&lt;arg2?arg1:arg2</returnValue>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
-    </arg>
+    <arg nr="2" direction="in"/>
   </function>
-  <!-- template <class T> const T& wxMax(const T& a, const T& b); -->
-  <function name="wxMax">
-    <use-retval/>
+  <!-- void wxScrolledWindow::SetScrollRate( int xstep, int ystep ) -->
+  <function name="wxScrolledWindow::SetScrollRate">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
     <leak-ignore/>
-    <returnValue>arg1&gt;arg2?arg1:arg2</returnValue>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- virtual bool wxGenericProgressDialog::Update(int value, const wxString & newmsg = wxEmptyString, bool * skip = NULL ) -->
-  <function name="wxGenericProgressDialog::Update">
-    <leak-ignore/>
+  <!-- virtual wxGraphicsContext* wxGraphicsRenderer::CreateContext(wxWindow * window) -->
+  <!-- virtual wxGraphicsContext* wxGraphicsRenderer::CreateContext(const wxWindowDC &dc) -->
+  <!-- virtual wxGraphicsContext* wxGraphicsRenderer::CreateContext(const wxMemoryDC &dc) -->
+  <!-- virtual wxGraphicsContext* wxGraphicsRenderer::CreateContext(const wxPrinterDC &dc) -->
+  <!-- virtual wxGraphicsContext* wxGraphicsRenderer::CreateContext(const wxEnhMetaFileDC &dc) -->
+  <!-- static  wxGraphicsContext* wxGraphicsRenderer::CreateContextFromUnknownDC( const wxDC & dc ) -->
+  <function name="wxGraphicsRenderer::CreateContext,wxGraphicsRenderer::CreateContextFromUnknownDC">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in" default="wxEmptyString"/>
-    <arg nr="3" direction="inout" default="NULL">
-      <not-uninit/>
-    </arg>
+    <returnValue type="wxGraphicsContext *"/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!-- void wxGrid::SetRowLabelSize( int width ) -->
-  <function name="wxGrid::SetRowLabelSize">
-    <leak-ignore/>
+  <!-- virtual bool wxGraphicsContext::SetInterpolationQuality(wxInterpolationQuality interpolation) -->
+  <!-- virtual bool wxGraphicsContext::SetAntialiasMode(wxAntialiasMode antialias) -->
+  <function name="wxGraphicsContext::SetInterpolationQuality,wxGraphicsContext::SetAntialiasMode">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <leak-ignore/>
+    <returnValue type="bool"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!--         void wxWindow::SetWindowStyle(long style)     -->
-  <!--         void wxTextCtrl::SetWindowStyle(long style)   -->
-  <!--         void wxStaticText::SetWindowStyle(long style) -->
-  <!-- virtual void wxWindow::SetWindowStyleFlag(long style) -->
-  <function name="wxWindow::SetWindowStyle,wxWindow::SetWindowStyleFlag,wxTextCtrl::SetWindowStyle,wxStaticText::SetWindowStyle">
-    <leak-ignore/>
+  <!-- void wxGCDC::SetGraphicsContext( wxGraphicsContext * ctx ) -->
+  <function name="wxGCDC::SetGraphicsContext">
     <noreturn>false</noreturn>
+    <leak-ignore/>
     <returnValue type="void"/>
     <arg nr="1" direction="in">
-      <not-uninit/>
+      <not-null/>
     </arg>
   </function>
-  <!-- void wxStyledTextCtrl::SetLexer(int lexer) -->
-  <!-- void wxStyledTextCtrl::SetMainSelection(int selection) -->
-  <!-- void wxStyledTextCtrl::SetMarginLeft(int l) -->
-  <!-- void wxStyledTextCtrl::SetMarginRight(int r) -->
-  <!-- void wxStyledTextCtrl::SetMarginOptions(int opt) -->
-  <!-- void wxStyledTextCtrl::SetModEventMask(int mask) -->
-  <function name="wxStyledTextCtrl::SetLexer,wxStyledTextCtrl::SetMainSelection,wxStyledTextCtrl::SetMarginLeft,wxStyledTextCtrl::SetMarginRight,wxStyledTextCtrl::SetMarginOptions,wxStyledTextCtrl::SetModEventMask">
-    <leak-ignore/>
+  <!-- wxGraphicsContext * wxDC::GetGraphicsContext( void ) -->
+  <function name="wxGCDC::GetGraphicsContext">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
+    <returnValue type="wxGraphicsContext *"/>
+    <use-retval/>
   </function>
-  <!-- void wxStyledTextCtrl::SetMarginSensitive( int margin, bool sensitive ) -->
-  <!-- void wxStyledTextCtrl::SetMarginMask( int margin, int mask ) -->
-  <function name="wxStyledTextCtrl::SetMarginSensitive,wxStyledTextCtrl::SetMarginMask">
+  <!-- virtual wxOutputStream & wxOutputStream::Write( const void * buffer, size_t size ) -->
+  <!--         wxOutputStream & wxMemoryOutputStream::Write( const void * buffer, size_t size ) -->
+  <!-- virtual wxOutputStream & wxOutputStream::WriteAll( const void * buffer, size_t size ) -->
+  <!--         wxOutputStream & wxMemoryOutputStream::WriteAll( const void * buffer, size_t size ) -->
+  <function name="wxOutputStream::Write,wxOutputStream::WriteAll,wxMemoryOutputStream::Write,wxMemoryOutputStream::WriteAll">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
     <leak-ignore/>
+    <returnValue type="wxOutputStream &amp;"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-null/>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+  <!-- @todo: bool wxCmdLineParser::Found( const wxString & name) const -->
+  <!-- bool wxCmdLineParser::Found( const wxString & name, wxString * value ) const -->
+  <!-- bool wxCmdLineParser::Found( const wxString & name, long * value ) const -->
+  <!-- bool wxCmdLineParser::Found( const wxString & name, double * value ) const -->
+  <!-- bool wxCmdLineParser::Found( const wxString & name, wxDateTime * value ) const -->
+  <function name="wxCmdLineParser::Found">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="out">
+      <not-null/>
     </arg>
   </function>
-  <!-- virtual void wxPen::SetStyle(wxPenStyle style) -->
-  <function name="wxPen::SetStyle">
+  <!-- static wxString wxFileSystem::FileNameToURL( const wxFileName & filename ) -->
+  <function name="wxFileSystem::FileNameToURL">
+    <noreturn>false</noreturn>
+    <returnValue type="wxString"/>
+    <pure/>
+    <leak-ignore/>
+    <use-retval/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxFileName::FileExists() const -->
+  <function name="wxFileName::FileExists">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <const/>
+    <leak-ignore/>
+    <use-retval/>
+  </function>
+  <!-- wxColour wxColourPickerCtrl::GetColour() const -->
+  <function name="wxColourPickerCtrl::GetColour">
+    <noreturn>false</noreturn>
+    <returnValue type="wxColour"/>
+    <const/>
     <leak-ignore/>
+    <use-retval/>
+  </function>
+  <!--void  wxColourPickerCtrl::SetColour(const wxColour &c) -->
+  <!--void  wxColourPickerCtrl::SetColour(const wxString &colourStr) -->
+  <function name="wxColourPickerCtrl::SetColour">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
+    <leak-ignore/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- template<typename EventTag , typename Class , typename EventArg , typename EventHandler >
-       void wxEvtHandler::Bind(const EventTag & eventType, void(Class::*)(EventArg &) method, EventHandler * handler, int id = wxID_ANY, int lastId = wxID_ANY, wxObject * userData = NULL) -->
-  <!-- void wxSpinCtrl::Bind(const EventTag & eventType, void(wxSpinCtrl::*)(EventArg &) method, EventHandler * handler, int id = wxID_ANY, int lastId = wxID_ANY, wxObject * userData = NULL) -->
-  <!-- void wxButton::Bind(const EventTag & eventType, void(wxSpinCtrl::*)(EventArg &) method, EventHandler * handler, int id = wxID_ANY, int lastId = wxID_ANY, wxObject * userData = NULL) -->
-  <function name="wxEvtHandler::Bind,wxSpinCtrl::Bind,wxButton::Bind">
-    <leak-ignore/>
+  <!--wxString& wxString::Remove(size_t pos) -->
+  <!--wxString& wxString::Remove(size_t pos, size_t len) -->
+  <function name="wxString::Remove">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in"/>
-    <arg nr="3" direction="inout">
-      <not-null/>
-    </arg>
-    <arg nr="4" direction="in" default="wxID_ANY">
+    <returnValue type="wxString &amp;"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="5" direction="in" default="wxID_ANY">
+    <arg nr="2" default="0" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="6" direction="inout" default="NULL">
+    <warn severity="style">This is a wxWidgets 1.xx compatibility function. Use 'wxString::Truncate' in new applications instead.</warn>
+  </function>
+  <!--wxString& wxString::Truncate(size_t len) -->
+  <function name="wxString::Truncate">
+    <noreturn>false</noreturn>
+    <returnValue type="wxString &amp;"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxStockGDI::DeleteAll( void ) -->
-  <function name="wxStockGDI::DeleteAll">
-    <leak-ignore/>
+  <!--void wxString::UpperCase(void) -->
+  <function name="wxString::UpperCase">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-  </function>
-  <!-- void wxStopWatch::Pause( void ) -->
-  <!-- void wxStopWatch::Resume( void ) -->
-  <function name="wxStopWatch::Pause,wxStopWatch::Resume">
     <leak-ignore/>
+    <warn severity="style">This is a wxWidgets 1.xx compatibility function. Use 'wxString::MakeUpper' in new applications instead.</warn>
+  </function>
+  <!--void wxString::LowerCase(void) -->
+  <function name="wxString::LowerCase">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-  </function>
-  <!-- long wxStopWatch::Time(void)	const -->
-  <function name="wxStopWatch::Time">
     <leak-ignore/>
-    <noreturn>false</noreturn>
-    <returnValue type="long"/>
-    <use-retval/>
-    <const/>
+    <warn severity="style">This is a wxWidgets 1.xx compatibility function. Use 'wxString::MakeLower' in new applications instead.</warn>
   </function>
-  <!-- wxLongLong wxStopWatch::TimeInMicro(void) const -->
-  <function name="wxStopWatch::TimeInMicro">
-    <leak-ignore/>
+  <!-- static wxUniChar wxFileName::GetPathSeparator(wxPathFormat format = wxPATH_NATIVE) -->
+  <function name="wxFileName::GetPathSeparator">
     <noreturn>false</noreturn>
-    <returnValue type="wxLongLong"/>
-    <use-retval/>
-    <const/>
-  </function>
-  <!-- void wxStopWatch::Start(long milliseconds = 0) -->
-  <function name="wxStopWatch::Start">
+    <returnValue type="wxUniChar"/>
+    <pure/>
     <leak-ignore/>
-    <noreturn>false</noreturn>
-    <returnValue type="void"/>
-    <arg nr="1" default="0" direction="in">
+    <use-retval/>
+    <arg nr="1" default="wxPATH_NATIVE" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- wxBrush * wxStockGDI::GetBrush( Item item ) -->
-  <function name="wxStockGDI::GetBrush">
-    <leak-ignore/>
+  <!-- wxString wxFileName::GetPath(int flags = wxPATH_GET_VOLUME, wxPathFormat format = wxPATH_NATIVE) const -->
+  <function name="wxFileName::GetPath">
     <noreturn>false</noreturn>
-    <returnValue type="wxBrush *"/>
+    <returnValue type="wxString"/>
+    <const/>
+    <leak-ignore/>
     <use-retval/>
-    <arg nr="1" direction="in">
+    <arg nr="1" default="wxPATH_GET_VOLUME" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-  </function>
-  <!-- wxColour * wxStockGDI::GetColour( Item item ) -->
-  <function name="wxStockGDI::GetColour">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-    <returnValue type="wxColour *"/>
-    <use-retval/>
-    <arg nr="1" direction="in">
+    <arg nr="1" default="wxPATH_NATIVE" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- wxCursor * wxStockGDI::GetCursor( Item item ) -->
-  <function name="wxStockGDI::GetCursor">
+  <!-- void wxWindow::ClientToScreen(int * x, int * y) const -->
+  <function name="wxWindow::ClientToScreen">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <const/>
     <leak-ignore/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- virtual void wxToolBar::EnableTool(int toolId, bool enable)-->
+  <function name="wxToolBar::EnableTool">
     <noreturn>false</noreturn>
-    <returnValue type="wxCursor *"/>
-    <use-retval/>
+    <returnValue type="void"/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
     </arg>
   </function>
-  <!-- wxFont * wxStockGDI::GetFont( Item item ) -->
-  <function name="wxStockGDI::GetFont">
-    <leak-ignore/>
+  <!-- void wxImage::SetMaskColour( unsigned char r, unsigned char g, unsigned char b ) -->
+  <function name="wxImage::SetMaskColour">
     <noreturn>false</noreturn>
-    <returnValue type="wxFont *"/>
-    <use-retval/>
+    <leak-ignore/>
+    <returnValue type="void"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>0:255</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <valid>0:255</valid>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <valid>0:255</valid>
     </arg>
   </function>
-  <!-- wxPen * wxStockGDI::GetPen( Item item ) -->
-  <function name="wxStockGDI::GetPen">
-    <leak-ignore/>
+  <!-- void wxListItem::SetColumn(int col) -->
+  <!-- void wxListItem::SetId(long id) -->
+  <!-- void wxListItem::SetImage(int image) -->
+  <!-- void wxListItem::SetMask(long mask) -->
+  <!-- void wxListItem::SetStateMask(long stateMask) -->
+  <!-- void wxListItem::SetWidth(int width) -->
+  <function name="wxListItem::SetColumn,wxListItem::SetId,wxListItem::SetImage,wxListItem::SetMask,wxListItem::SetStateMask,wxListItem::SetWidth">
     <noreturn>false</noreturn>
-    <returnValue type="wxPen *"/>
-    <use-retval/>
+    <returnValue type="void"/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- wxStockGDI & wxStockGDI::instance( void ) -->
-  <function name="wxStockGDI::instance">
-    <leak-ignore/>
-    <noreturn>false</noreturn>
-    <returnValue type="wxStockGDI &amp;"/>
-    <use-retval/>
-  </function>
-  <!-- bool wxRemoveFile( const wxString & file ) -->
-  <function name="wxRemoveFile">
-    <leak-ignore/>
+  <!-- virtual bool wxPopupTransientWindow::ProcessLeftDown(wxMouseEvent & event) -->
+  <function name="wxPopupTransientWindow::ProcessLeftDown">
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
-    <arg nr="1" direction="in"/>
-  </function>
-  <!-- bool wxRenameFile( const wxString & oldpath, const wxString & newpath, bool overwrite = true ) -->
-  <function name="wxRenameFile">
     <leak-ignore/>
-    <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in"/>
-    <arg nr="3" direction="in" default="true">
-      <not-uninit/>
-    </arg>
+    <arg nr="1" direction="inout"/>
   </function>
-  <!-- int wxRmDir( const wxString & path ) -->
-  <function name="wxRmDir">
-    <leak-ignore/>
+  <!-- virtual void wxPopupTransientWindow::Popup(wxWindow * focus = NULL) -->
+  <function name="wxPopupTransientWindow::Popup">
     <noreturn>false</noreturn>
-    <returnValue type="int"/>
-    <arg nr="1" direction="in"/>
-  </function>
-  <!-- bool wxRmdir( const wxString & dir, int flags = 0 ) -->
-  <function name="wxRmdir">
+    <returnValue type="void"/>
     <leak-ignore/>
-    <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in" default="0">
+    <arg nr="1" default="0" direction="inout">
       <not-uninit/>
     </arg>
   </function>
-  <!-- bool wxSetWorkingDirectory( const wxString & d ) -->
-  <function name="wxSetWorkingDirectory">
-    <leak-ignore/>
+  <!-- wxPoint wxMouseEvent::GetLogicalPosition(const wxDC & dc) const -->
+  <function name="wxMouseEvent::GetLogicalPosition">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
+    <returnValue type="wxPoint"/>
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- int wxPrintf(const char *format, ...); -->
-  <function name="wxPrintf">
-    <returnValue type="int"/>
+  <!-- wxAuiPaneInfo& wxAuiManager::GetPane(wxWindow * window) -->
+  <!-- wxAuiPaneInfo& wxAuiManager::GetPane(const wxString & name) -->
+  <function name="wxAuiManager::GetPane">
     <noreturn>false</noreturn>
+    <returnValue type="wxAuiPaneInfo &amp;"/>
     <leak-ignore/>
-    <formatstr/>
-    <arg nr="1" direction="in">
-      <formatstr/>
-      <not-uninit/>
-    </arg>
+    <use-retval/>
+    <arg nr="1"/>
   </function>
-  <!-- void wxBell( void ) -->
-  <function name="wxBell">
-    <leak-ignore/>
+  <!-- bool wxAuiManager::AddPane(wxWindow * window, const wxAuiPaneInfo & pane_info)-->
+  <!-- bool wxAuiManager::AddPane(wxWindow * window, int direction = wxLEFT, const wxString & caption = wxEmptyString) -->
+  <!-- bool wxAuiManager::AddPane(wxWindow * window, const wxAuiPaneInfo & pane_info, const wxPoint & drop_pos) -->
+  <function name="wxAuiManager::AddPane">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
-  </function>
-  <!-- void wxPostEvent( wxEvtHandler * dest, const wxEvent & event ) -->
-  <function name="wxPostEvent">
+    <returnValue type="bool"/>
     <leak-ignore/>
-    <noreturn>false</noreturn>
-    <returnValue type="void"/>
-    <arg nr="1" direction="inout">
-      <not-uninit/>
-      <not-null/>
-    </arg>
-    <arg nr="2" direction="in"/>
+    <arg nr="1"/>
+    <arg nr="2" direction="in" default="wxLEFT"/>
+    <arg nr="3" direction="in" default="wxEmptyString"/>
   </function>
-  <!-- void wxQueueEvent( wxEvtHandler * dest, wxEvent * event ) -->
-  <function name="wxQueueEvent">
-    <leak-ignore/>
+  <!-- virtual void wxConfigBase::SetPath(const wxString &strPath) = 0 -->
+  <!-- virtual void wxConfig::SetPath(const wxString &strPath) -->
+  <!-- virtual void wxFileConfig::SetPath(const wxString &strPath)-->
+  <!-- virtual void wxRegConfig::SetPath(const wxString &strPath)-->
+  <function name="wxConfigBase::SetPath,wxConfig::SetPath,wxFileConfig::SetPath,wxRegConfig::SetPath">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="inout">
-      <not-uninit/>
-      <not-null/>
-    </arg>
-    <arg nr="2" direction="inout">
-      <not-uninit/>
-      <not-null/>
-    </arg>
-  </function>
-  <!-- bool wxIsupper( const wxUniChar & c ) -->
-  <!-- bool wxIsxdigit( const wxUniChar & c ) -->
-  <!-- bool wxIsspace( const wxUniChar & c ) -->
-  <!-- bool wxIspunct( const wxUniChar & c ) -->
-  <!-- bool wxIsprint( const wxUniChar & c ) -->
-  <!-- bool wxIslower( const wxUniChar & c ) -->
-  <!-- bool wxIsgraph( const wxUniChar & c ) -->
-  <!-- bool wxIsdigit( const wxUniChar & c ) -->
-  <!-- bool wxIscntrl( const wxUniChar & c ) -->
-  <!-- bool wxIsascii( const wxUniChar & c ) -->
-  <!-- bool wxIsalpha( const wxUniChar & c ) -->
-  <!-- bool wxIsalnum( const wxUniChar & c ) -->
-  <function name="wxIsupper,wxIsxdigit,wxIsspace,wxIspunct,wxIsprint,wxIslower,wxIsgraph,wxIsdigit,wxIsctrl,wxIscntrl,wxIsascii,wxIsalpha,wxIsalnum">
-    <use-retval/>
     <leak-ignore/>
-    <noreturn>false</noreturn>
-    <returnValue type="bool"/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- int wxIsctrl( const wxUniChar & c ) -->
-  <function name="wxIsctrl">
+  <!-- wxConfigBase * wxConfigBase::Set( wxConfigBase * pConfig ) -->
+  <function name="wxConfigBase::Set">
+    <noreturn>false</noreturn>
+    <returnValue type="wxConfigBase *"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- static wxWindow* wxWindow::FindWindowByName(const wxString & name, const wxWindow * parent = 0) -->
+  <!-- static wxWindow* wxWindow::FindWindowByLabel(const wxString & label, const wxWindow * parent = 0) -->
+  <function name="wxWindow::FindWindowByName,wxWindow::FindWindowByLabel">
+    <noreturn>false</noreturn>
+    <returnValue type="wxWindow *"/>
     <use-retval/>
     <leak-ignore/>
-    <noreturn>false</noreturn>
-    <returnValue type="int"/>
     <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in" default="0">
+      <not-uninit/>
+    </arg>
   </function>
-  <!-- void wxGrid::SetCellRenderer( int row, int col, wxGridCellRenderer * renderer ) -->
-  <function name="wxGrid::SetCellRenderer">
-    <leak-ignore/>
+  <!-- virtual void wxTextCtrl::GetSelection(long* from, long* to) const  -->
+  <function name="wxTextCtrl::GetSelection">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
+    <leak-ignore/>
+    <const/>
+    <arg nr="1" direction="out">
+      <not-null/>
+    </arg>
+    <arg nr="2" direction="out">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- long wxListCtrl::GetNextItem( long item, int geometry = wxLIST_NEXT_ALL, int state = wxLIST_STATE_DONTCARE ) const -->
+  <function name="wxListCtrl::GetNextItem">
+    <noreturn>false</noreturn>
+    <returnValue type="long"/>
+    <use-retval/>
+    <const/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="2" direction="in">
+    <arg nr="2" default="wxLIST_NEXT_ALL" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="3" direction="inout">
+    <arg nr="3" default="wxLIST_STATE_DONTCARE" direction="in">
       <not-uninit/>
-      <not-null/>
     </arg>
   </function>
-  <!-- void wxGrid::SetDefaultCellAlignment( int horiz, int vert ) -->
-  <function name="wxGrid::SetDefaultCellAlignment">
-    <leak-ignore/>
+  <!-- bool wxTextCtrl::SetStyle( long start, long end, const wxTextAttr & style ) -->
+  <function name="wxTextCtrl::SetStyle">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <leak-ignore/>
+    <returnValue type="bool"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <valid>1:</valid>
     </arg>
+    <arg nr="3" direction="in"/>
   </function>
-  <!-- void wxGrid::SetColLabelSize( int height ) -->
-  <function name="wxGrid::SetColLabelSize">
-    <leak-ignore/>
+  <!-- static wxWindow* wxWindow::FindWindowById(long id const wxWindow * parent = 0) -->
+  <function name="wxWindow::FindWindowById">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="wxWindow *"/>
+    <use-retval/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
+    <arg nr="2" direction="in" default="0">
+      <not-uninit/>
+    </arg>
   </function>
-  <!-- void wxGrid::EnableGridLines( bool enable = true ) -->
-  <function name="wxGrid::EnableGridLines">
-    <leak-ignore/>
+  <!--wxString wxString::Left(size_t count) const -->
+  <!--wxString wxString::Right(size_t count) const -->
+  <function name="wxString::Right,wxString::Left">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in" default="true">
+    <returnValue type="wxString"/>
+    <const/>
+    <leak-ignore/>
+    <use-retval/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>1:</valid>
     </arg>
   </function>
-  <!-- void wxGrid::EnableEditing( bool edit ) -->
-  <function name="wxGrid::EnableEditing">
-    <leak-ignore/>
+  <!--void wxDC::SetLogicalFunction(wxRasterOperationMode function)-->
+  <function name="wxDC::SetLogicalFunction">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!-- void wxGrid::SetRowLabelAlignment( int horiz, int vert ) -->
-  <!-- void wxGrid::SetColLabelAlignment( int horiz, int vert ) -->
-  <function name="wxGrid::SetRowLabelAlignment,wxGrid::SetColLabelAlignment">
-    <leak-ignore/>
+  <!--bool wxLayoutAlgorithm::LayoutFrame (wxFrame * frame, wxWindow * mainWindow = NULL) -->
+  <!--bool wxLayoutAlgorithm::LayoutMDIFrame (wxMDIParentFrame * frame, wxRect * rect = NULL) -->
+  <!--bool wxLayoutAlgorithm::LayoutWindow (wxWindow * frame, wxWindow * mainWindow = NULL) -->
+  <function name="wxLayoutAlgorithm::LayoutFrame,wxLayoutAlgorithm::LayoutMDIFrame,wxLayoutAlgorithm::LayoutWindow">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in">
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <arg nr="1" direction="inout">
       <not-uninit/>
+      <not-null/>
     </arg>
-    <arg nr="2" direction="in">
+    <arg nr="2" default="NULL" direction="inout">
       <not-uninit/>
     </arg>
   </function>
-  <!-- void wxGrid::EnableDragRowSize( bool enable = true ) -->
-  <!-- void wxGrid::EnableDragGridSize( bool enable = true ) -->
-  <!-- void wxGrid::EnableDragColSize( bool enable = true ) -->
-  <!-- void wxGrid::EnableDragColMove( bool enable = true ) -->
-  <function name="wxGrid::EnableDragRowSize,wxGrid::EnableDragGridSize,wxGrid::EnableDragColSize,wxGrid::EnableDragColMove">
-    <leak-ignore/>
+  <!--virtual wxPGCellRenderer* wxPGProperty::GetCellRenderer(int column) const -->
+  <function name="wxPGProperty::GetCellRenderer,wxEnumProperty::GetCellRenderer,wxStringProperty::GetCellRenderer">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in" default="true">
+    <returnValue type="wxPGCellRenderer*"/>
+    <leak-ignore/>
+    <const/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- virtual bool wxDataViewCtrl::SetRowHeight(int rowHeight) -->
-  <!--         bool wxDataViewTreeCtrl::SetRowHeight(int rowHeight) -->
-  <!--         bool wxDataViewListCtrl::SetRowHeight(int rowHeight) -->
-  <function name="wxDataViewCtrl::SetRowHeight,wxDataViewTreeCtrl::SetRowHeight,wxDataViewListCtrl::SetRowHeight">
-    <leak-ignore/>
+  <!--static void wxImage::AddHandler(wxImageHandler * handler)-->
+  <function name="wxImage::AddHandler">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
+    <returnValue type="void"/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-null/>
     </arg>
   </function>
-  <!-- void wxDC::DrawPoint( wxCoord x, wxCoord y ) -->
-  <function name="wxDC::DrawPoint">
+  <!--void wxGrid::SetGridLineColour(const wxColour & colour) -->
+  <!--void wxGrid::SetLabelBackgroundColour(const wxColour & colour) -->
+  <!--void wxGrid::SetLabelTextColour(const wxColour & colour) -->
+  <!--void wxGrid::SetLabelFont(const wxFont & font) -->
+  <function name="wxGrid::SetGridLineColour,wxGrid::SetLabelBackgroundColour,wxGrid::SetLabelTextColour,wxGrid::SetLabelFont">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!--bool wxShell(const wxString &command=wxEmptyString)-->
+  <function name="wxShell">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
     <leak-ignore/>
+    <arg nr="1" default="wxEmptyString" direction="in"/>
+  </function>
+  <!--void wxDC::SetLayoutDirection(wxLayoutDirection dir)-->
+  <function name="wxDC::SetLayoutDirection">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- virtual void wxDataViewCtrl::Expand(const wxDataViewItem & item) -->
-  <!--         void wxDataViewListCtrl::Expand(const wxDataViewItem & item) -->
-  <!--         void wxDataViewTreeCtrl::Expand(const wxDataViewItem & item) -->
-  <function name="wxDataViewCtrl::Expand,wxDataViewListCtrl::Expand,wxDataViewTreeCtrl::Expand">
+  <!--virtual bool wxImage::SaveFile(wxOutputStream & stream, const wxString & mimetype) const -->
+  <!--virtual bool wxImage::SaveFile(wxOutputStream & stream, wxBitmapType type) const -->
+  <!--virtual bool wxImage::SaveFile(const wxString & name, wxBitmapType type) const -->
+  <!--virtual bool wxImage::SaveFile(const wxString & name, const wxString & mimetype) const -->
+  <!--virtual bool wxImage::SaveFile(const wxString & name) const -->
+  <function name="wxImage::SaveFile">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <const/>
     <leak-ignore/>
+    <arg nr="1"/>
+    <arg nr="2" default="" direction="in"/>
+  </function>
+  <!--static void wxLog::SetTimestamp(const wxString & format) -->
+  <function name="wxLog::SetTimestamp">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
+    <pure/>
+    <leak-ignore/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- virtual void wxWindow::Update(void) -->
-  <function name="wxWindow::Update">
+  <!--virtual void wxTextEntry::ChangeValue(const wxString & value)-->
+  <!--virtual void wxTextCtrl::ChangeValue(const wxString & value)-->
+  <function name="wxTextEntry::ChangeValue,wxTextCtrl::ChangeValue">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
     <leak-ignore/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!--virtual void wxWindowBase::SetName(const wxString & name)-->
+  <!--virtual void wxWindow::SetName(const wxString & name)-->
+  <!--virtual void wxMessageDialog::SetName(const wxString & name)-->
+  <function name="wxWindowBase::SetName,wxWindow::SetName,wxMessageDialog::SetName">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!-- virtual bool wxGenericProgressDialog::Update(int value, const wxString & newmsg = wxEmptyString, bool * skip = NULL) -->
-  <!--         bool wxProgressDialog::Update(int value, const wxString & newmsg = wxEmptyString, bool * skip = NULL) -->
-  <function name="wxGenericProgressDialog::Update,wxProgressDialog::Update">
+  <!--virtual void wxWindowBase::PrepareDC(DC & dc)-->
+  <function name="wxWindowBase::PrepareDC">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
     <leak-ignore/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!--void wxWindowBase::SetClientSize(int width, int height)-->
+  <!--void wxWindowBase::SetClientSize(const wxSize &sz)-->
+  <!--void wxWindowBase::SetClientSize(const wxRect &rect)-->
+  <!--void wxWindow::SetClientSize(int width, int height)-->
+  <!--void wxWindow::SetClientSize(const wxSize &sz)-->
+  <!--void wxWindow::SetClientSize(const wxRect &rect)-->
+  <function name="wxWindowBase::SetClientSize,wxWindow::SetClientSize">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="any" direction="in"/>
+  </function>
+  <!--void wxCommandEvent::SetClientData(void * clientData)-->
+  <!--void wxCommandEvent::SetClientObject(void * clientObj)-->
+  <function name="wxCommandEvent::SetClientData,wxCommandEvent::SetClientObject">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in" default="wxEmptyString"/>
-    <arg nr="3" direction="inout" default="NULL">
-      <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxEvent::Skip(bool skip = true) -->
-  <!-- void wxCommandEvent::Skip(bool skip = true) -->
-  <function name="wxEvent::Skip,wxCommandEvent::Skip">
-    <leak-ignore/>
+  <!--virtual void wxWindow::SetMinClientSize(const wxSize & size)-->
+  <!--virtual void wxWindow::SetMinSize(const wxSize & size)-->
+  <!--virtual void wxGrid::SetMinClientSize(const wxSize & size)-->
+  <!--virtual void wxGrid::SetMinSize(const wxSize & size)-->
+  <function name="wxWindow::SetMinClientSize,wxWindow::SetMinSize,wxGrid::SetMinClientSize,wxGrid::SetMinSize">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" default="true" direction="in">
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!--bool wxShutdown(int flags = wxSHUTDOWN_POWEROFF) -->
+  <function name="wxShutdown">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <arg nr="1" default="wxSHUTDOWN_POWEROFF" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- virtual bool wxStatusBar::GetFieldRect( int i, wxRect & rect ) const -->
-  <function name="wxStatusBar::GetFieldRect">
+  <!--bool wxSizer::Hide(wxWindow * window, bool recursive = false) -->
+  <!--bool wxSizer::Hide(wxSizer * sizer, bool recursive = false)-->
+  <!--bool wxSizer::Hide(size_t index)-->
+  <function name="wxSizer::Hide,wxBoxSizer::Hide,wxStaticBoxSizer::Hide">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
     <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!--bool wxSizer::IsShown(wxWindow * window) const-->
+  <!--bool wxSizer::IsShown(wxSizer * sizer) const-->
+  <!--bool wxSizer::IsShown(size_t index) const-->
+  <function name="wxSizer::IsShown,wxBoxSizer::IsShown,wxStaticBoxSizer::IsShown">
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
+    <use-retval/>
+    <leak-ignore/>
     <const/>
     <arg nr="1" direction="in">
       <not-uninit/>
-      <valid>0:</valid>
+      <not-bool/>
     </arg>
-    <arg nr="2" direction="out"/>
   </function>
-  <!-- void wxTreeListCtrl::AssignImageList(wxImageList * imageList) -->
-  <!-- void wxDataViewTreeCtrl::AssignImageList(wxImageList * imageList) -->
-  <function name="wxTreeListCtrl::AssignImageList,wxDataViewTreeCtrl::AssignImageList">
+  <!--unsigned long wxGetProcessId(void)-->
+  <function name="wxGetProcessId">
+    <noreturn>false</noreturn>
+    <returnValue type="unsigned long"/>
+    <leak-ignore/>
+    <use-retval/>
+  </function>
+  <!-- const wxString& wxHtmlEasyPrinting::GetName( void )  const -->
+  <function name="wxHtmlEasyPrinting::GetName">
+    <noreturn>false</noreturn>
+    <returnValue type="wxString &amp;"/>
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- virtual int wxNotebook::GetSelection( void ) const -->
+  <function name="wxNotebook::GetSelection">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="int"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- wxMenuItem* wxMenu::AppendSeparator(void) -->
+  <function name="wxMenu::AppendSeparator">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxMenuItem *"/>
+      <use-retval/>
+  </function>
+  <!-- const wxScopedCharBuffer wxString::ToUTF8( void ) const -->
+  <function name="wxString::ToUTF8">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="const wxScopedCharBuffer"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- size_t wxNotebook::GetPageCount ( void ) const -->
+  <!-- size_t wxListbook::GetPageCount ( void ) const -->
+  <!-- size_t wxPropertyGridManager::GetPageCount ( void ) const -->
+  <!-- size_t wxToolbook::GetPageCount ( void ) const -->
+  <!-- size_t wxTreebook::GetPageCount ( void ) const -->
+  <!-- size_t wxSimplebook::GetPageCount ( void ) const -->
+  <!-- size_t wxRibbonBar::GetPageCount ( void ) const -->
+  <!-- size_t wxAuiTabContainer::GetPageCount ( void ) const -->
+  <!-- size_t wxBookCtrlBase::GetPageCount( void ) const -->
+  <function name="wxTreebook::GetPageCount,wxSimplebook::GetPageCount,wxAuiTabContainer::GetPageCount,wxRibbonBar::GetPageCount,wxToolbook::GetPageCount,wxPropertyGridManager::GetPageCount,wxListbook::GetPageCount,wxNotebook::GetPageCount,wxBookCtrlBase::GetPageCount">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="size_t"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- wxPageSetupDialogData * wxHtmlEasyPrinting::GetPageSetupData( void ) -->
+  <function name="wxHtmlEasyPrinting::GetPageSetupData">
+    <noreturn>false</noreturn>
+    <returnValue type="wxPageSetupDialogData *"/>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- wxWindow wxHtmlEasyPrinting::GetParentWindow( void )  const -->
+  <function name="wxHtmlEasyPrinting::GetParentWindow">
+    <noreturn>false</noreturn>
+    <returnValue type="wxWindow *"/>
+    <leak-ignore/>
+    <use-retval/>
+    <const/>
+  </function>
+  <!-- wxPrintData * wxHtmlEasyPrinting::GetPrintData( void ) -->
+  <function name="wxHtmlEasyPrinting::GetPrintData">
+    <noreturn>false</noreturn>
+    <returnValue type="wxPrintData *"/>
+    <use-retval/>
     <leak-ignore/>
+  </function>
+  <!-- void wxHtmlEasyPrinting::PageSetup( void ) -->
+  <function name="wxHtmlEasyPrinting::PageSetup">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <arg nr="1" direction="inout">
-      <not-uninit/>
-      <not-null/>
-    </arg>
-  </function>
-  <!-- wxDataViewItem wxDataViewTreeCtrl::AppendContainer(const wxDataViewItem & parent, const wxString & text, int icon = -1, int expanded = -1, wxClientData * data = NULL) -->
-  <function name="wxDataViewTreeCtrl::AppendContainer">
     <leak-ignore/>
+  </function>
+  <!-- bool wxHtmlEasyPrinting::PreviewFile( const wxString & htmlfile ) -->
+  <function name="wxHtmlEasyPrinting::PreviewFile">
     <noreturn>false</noreturn>
-    <returnValue type="wxDataViewItem"/>
+    <returnValue type="bool"/>
+    <leak-ignore/>
     <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in"/>
-    <arg nr="3" direction="in" default="-1">
-      <not-uninit/>
-    </arg>
-    <arg nr="4" direction="in" default="-1">
-      <not-uninit/>
-    </arg>
-    <arg nr="5" direction="out" default="NULL">
-      <not-uninit/>
-    </arg>
   </function>
-  <!-- int wxString::Find (wxUniChar ch, bool fromEnd=false) const -->
-  <!-- int wxString::Find (const wxString &sub) const -->
-  <!-- int wxString::First (const wxUniChar ch) const -->
-  <!-- int wxString::First (const wxString &sub) const -->
-  <function name="wxString::Find,wxString::First">
-    <use-retval/>
-    <const/>
-    <leak-ignore/>
-    <returnValue type="int"/>
+  <!-- bool wxHtmlEasyPrinting::PreviewText( const wxString & htmltext, const wxString & basepath = wxEmptyString ) -->
+  <function name="wxHtmlEasyPrinting::PreviewText">
     <noreturn>false</noreturn>
-    <arg nr="any" direction="in"/>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="wxEmptyString" direction="in"/>
   </function>
-  <!-- size_t wxString::find(const wxString & str, size_t nStart = 0) const -->
-  <!-- size_t wxString::find(const char * sz     , size_t nStart = 0, size_t n = npos) const -->
-  <!-- size_t wxString::find(const wchar_t * sz  , size_t nStart = 0, size_t n = npos) const -->
-  <!-- size_t wxString::find(wxUniChar ch        , size_t nStart = 0,) const -->
-  <function name="wxString::find">
-    <use-retval/>
-    <const/>
+  <!-- bool wxHtmlEasyPrinting::PrintFile( const wxString & htmlfile ) -->
+  <function name="wxHtmlEasyPrinting::PrintFile">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
     <leak-ignore/>
-    <returnValue type="std::size_t"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxHtmlEasyPrinting::PrintText( const wxString & htmltext, const wxString & basepath = wxEmptyString ) -->
+  <function name="wxHtmlEasyPrinting::PrintText">
     <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <leak-ignore/>
     <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in" default="0">
-      <not-uninit/>
-    </arg>
-    <arg nr="3" direction="in" default="std::wxString::npos">
-      <not-uninit/>
-    </arg>
+    <arg nr="2" default="wxEmptyString" direction="in"/>
   </function>
-  <!-- void wxDC::DrawRoundedRectangle( const wxRect & r, double radius ) -->
-  <!-- void wxPaintDC::DrawRoundedRectangle( const wxRect & r, double radius ) -->
-  <!-- void wxMemoryDC::DrawRoundedRectangle( const wxRect & r, double radius ) -->
-  <function name="wxDC::DrawRoundedRectangle,wxPaintDC::DrawRoundedRectangle,wxMemoryDC::DrawRoundedRectangle">
+  <!-- void wxHtmlEasyPrinting::SetFooter( const wxString & footer, int pg = wxPAGE_ALL ) -->
+  <function name="wxHtmlEasyPrinting::SetFooter">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in">
+    <arg nr="2" default="wxPAGE_ALL" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxDC::DrawRotatedText( const wxString & text, wxCoord x, wxCoord y, double angle ) -->
-  <!-- void wxPaintDC::DrawRotatedText( const wxString & text, wxCoord x, wxCoord y, double angle ) -->
-  <!-- void wxMemoryDC::DrawRotatedText( const wxString & text, wxCoord x, wxCoord y, double angle ) -->
-  <function name="wxDC::DrawRotatedText,wxPaintDC::DrawRotatedText,wxMemoryDC::DrawRotatedText">
+  <!-- void wxHtmlEasyPrinting::SetHeader( const wxString & header, int pg = wxPAGE_ALL ) -->
+  <function name="wxHtmlEasyPrinting::SetHeader">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="3" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="4" direction="in">
+    <arg nr="2" default="wxPAGE_ALL" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxMenuBar::Enable(int id, bool enable)-->
-  <function name="wxMenuBar::Enable">
+  <!-- void wxHtmlEasyPrinting::SetParentWindow(wxWindow *w) -->
+  <function name="wxHtmlEasyPrinting::SetParentWindow">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
-    <arg nr="any" direction="in">
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-null/>
     </arg>
   </function>
-  <!-- void wxTextValidator::SetCharExcludes( const wxString & chars ) -->
-  <function name="wxTextValidator::SetCharExcludes">
+  <!-- virtual void wxGridCellEnumRenderer::SetParameters (const wxString &params)-->
+  <function name="wxGridCellEnumRenderer::SetParameters">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- void wxStyledTextCtrl::ToggleFold( int line ) -->
-  <function name="wxStyledTextCtrl::ToggleFold">
+  <!-- bool wxGrid::SetTable(wxGridTableBase * table, bool takeOwnership = false, wxGridSelectionModes selmode = wxGridSelectCells) -->
+  <function name="wxGrid::SetTable">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="bool"/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1" direction="inout">
+      <not-uninit/>
+      <not-null/>
+    </arg>
+    <arg nr="2" default="false" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" default="wxGridSelectCells" direction="in">
       <not-uninit/>
       <not-bool/>
     </arg>
   </function>
-  <!-- void wxStyledTextCtrl::SetWrapMode( int wrapMode ) -->
-  <function name="wxStyledTextCtrl::SetWrapMode">
+  <!-- void wxGrid::SetColMinimalAcceptableWidth( int width ) -->
+  <function name="wxGrid::SetColMinimalAcceptableWidth">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
@@ -10245,32 +15734,22 @@
       <not-bool/>
     </arg>
   </function>
-  <!-- int wxStyledTextCtrl::LineFromPosition( int pos ) const -->
-  <function name="wxStyledTextCtrl::LineFromPosition">
+  <!-- void wxGrid::SetColMinimalWidth( int col, int width ) -->
+  <function name="wxGrid::SetColMinimalWidth">
     <noreturn>false</noreturn>
-    <returnValue type="int"/>
-    <use-retval/>
-    <const/>
+    <returnValue type="void"/>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
       <not-bool/>
     </arg>
-  </function>
-  <!-- int wxStyledTextCtrl::GetFoldLevel( int line ) const -->
-  <function name="wxStyledTextCtrl::GetFoldLevel">
-    <noreturn>false</noreturn>
-    <returnValue type="int"/>
-    <use-retval/>
-    <const/>
-    <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="2" direction="in">
       <not-uninit/>
       <not-bool/>
     </arg>
   </function>
-  <!-- void wxStyledTextCtrl::StyleSetFont( int styleNum, const wxFont & font ) -->
-  <function name="wxStyledTextCtrl::StyleSetFont">
+  <!-- void wxGrid::SelectRow(int row, bool addToSelected = false) -->
+  <function name="wxGrid::SelectRow">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
@@ -10278,1060 +15757,1557 @@
       <not-uninit/>
       <not-bool/>
     </arg>
-    <arg nr="2" direction="in"/>
+    <arg nr="2" default="false" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
-  <!-- void wxStyledTextCtrl::StyleSetBold( int style, bool bold ) -->
-  <!-- void wxStyledTextCtrl::SetMarginWidth(int margin, int pixelWidth) -->
-  <!-- void wxStyledTextCtrl::SetMarginType(int margin, int marginType) -->
-  <function name="wxStyledTextCtrl::StyleSetBold,wxStyledTextCtrl::SetMarginWidth,wxStyledTextCtrl::SetMarginType">
+  <!-- bool wxGrid::InsertCols(int pos = 0, int numCols = 1, bool updateLabels = true) -->
+  <!-- bool wxGrid::InsertRows(int pos = 0, int numCols = 1, bool updateLabels = true) -->
+  <function name="wxGrid::InsertCols,wxGrid::InsertRows">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="bool"/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1" default="0" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="2" direction="in">
+    <arg nr="2" default="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" default="true" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!-- void wxStyledTextCtrl::SetKeyWords( int keyWordSet, const wxString & keyWords ) -->
-  <function name="wxStyledTextCtrl::SetKeyWords">
+  <!-- void wxWindow::SetFocus( void ) -->
+  <!-- void wxSpinCtrl::SetFocus( void ) -->
+  <function name="wxWindow::SetFocus,wxSpinCtrl::SetFocus">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="void"/>
+  </function>
+  <!-- wxOperatingSystemId wxGetOsVersion(int * major = NULL, int * minor = NULL)-->
+  <function name="wxGetOsVersion">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="wxOperatingSystemId"/>
+    <use-retval/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in"/>
+    <arg nr="1" default="NULL" direction="out"/>
+    <arg nr="2" default="NULL" direction="out"/>
   </function>
-  <!--void wxStyledTextCtrl::SetProperty(const wxString & key, const wxString & value) -->
-  <function name="wxStyledTextCtrl::SetProperty">
+  <!-- int wxGrid::GetGridCursorRow() const  -->
+  <!-- int wxGrid::GetGridCursorCol() const  -->
+  <!-- int wxKeyEvent::GetKeyCode (void) const -->
+  <function name="wxGrid::GetGridCursorRow,wxGrid::GetGridCursorCol,wxKeyEvent::GetKeyCode">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="int"/>
+    <use-retval/>
     <leak-ignore/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in"/>
+    <const/>
   </function>
-  <!-- void wxStyledTextCtrl::StyleSetBackground( int style, const wxColour & back ) -->
-  <function name="wxStyledTextCtrl::StyleSetBackground">
+  <!-- virtual const wxGridCornerHeaderRenderer & wxGridCellAttrProvider::GetCornerRenderer( void ) -->
+  <function name="wxGridCellAttrProvider::GetCornerRenderer">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="const wxGridCornerHeaderRenderer &amp;"/>
+      <use-retval/>
+  </function>
+  <!-- virtual const wxGridColumnHeaderRenderer& wxGridCellAttrProvider::GetColumnHeaderRenderer( int col ) -->
+  <function name="wxGridCellAttrProvider::GetColumnHeaderRenderer">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="const wxGridColumnHeaderRenderer &amp;"/>
+      <arg nr="1" direction="in">
+          <not-uninit/>
+      </arg>
+  </function>
+  <!-- virtual const wxGridRowHeaderRenderer & wxGridCellAttrProvider::GetRowHeaderRenderer( int row ) -->
+  <function name="wxGridCellAttrProvider::GetRowHeaderRenderer">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="const wxGridRowHeaderRenderer &amp;"/>
+      <arg nr="1" direction="in">
+          <not-uninit/>
+      </arg>
+  </function>
+  <!-- bool wxColour::IsOk( void ) const -->
+  <!-- bool wxFont::IsOk( void ) const -->
+  <!-- bool wxIcon::IsOk( void ) const -->
+  <function name="wxColour::IsOk,wxFont::IsOk,wxIcon::IsOk">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="bool"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- const wxFont & wxDC::GetFont( void ) const -->
+  <function name="wxDC::GetFont">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="const wxFont &amp;"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- wxFont wxFont::Italic (void) const -->
+  <!-- wxFont wxFont::Larger (void) const -->
+  <function name="wxFont::Italic,wxFont::Larger">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxFont"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- wxColour wxGrid::GetGridLineColour() const  -->
+  <function name="wxGrid::GetGridLineColour">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="wxColour"/>
+    <use-retval/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in"/>
+    <const/>
   </function>
-  <!-- void wxGrid::UseNativeColHeader( bool native = true ) -->
-  <function name="wxGrid::UseNativeColHeader">
+  <!-- virtual int wxAnimation::GetDelay(unsigned int i) const -->
+  <function name="wxAnimation::GetDelay">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="int"/>
+    <const/>
+    <use-retval/>
     <leak-ignore/>
-    <arg nr="1" default="true" direction="in">
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- bool wxGrid::SetTable(wxGridTableBase * table, bool takeOwnership = false, wxGridSelectionModes selmode = wxGridSelectCells) -->
-  <function name="wxGrid::SetTabler">
+  <!-- wxImage wxImage::Rotate(double angle, const wxPoint & rotationCentre, bool interpolating = true, wxPoint * offsetAfterRotation = NULL) const -->
+  <function name="wxImage::Rotate">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
+    <returnValue type="wxImage"/>
+    <const/>
+    <use-retval/>
     <leak-ignore/>
-    <arg nr="1" direction="inout">
-      <not-uninit/>
-      <not-null/>
-    </arg>
-    <arg nr="2" default="false" direction="in">
+    <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="3" default="wxGridSelectCells" direction="in">
+    <arg nr="2" direction="in"/>
+    <arg nr="3" default="true" direction="in">
       <not-uninit/>
     </arg>
+    <arg nr="4" default="NULL" direction="out"/>
   </function>
-  <!-- void wxGrid::SetTabBehaviour( TabBehaviour behaviour ) -->
-  <function name="wxGrid::SetTabBehaviour">
+  <!-- void wxImage::RotateHue(double angle) -->
+  <function name="wxImage::RotateHue">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
-    <arg nr="1" direction="in"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
-  <!-- void wxPropertyGridInterface::SetPropertyValueString( wxPGPropArg id, const wxString & value ) -->
-  <!-- void wxPropertyGrid::SetPropertyValueString( wxPGPropArg id, const wxString & value ) -->
-  <function name="wxPropertyGridInterface::SetPropertyValueString,wxPropertyGrid::SetPropertyValueString">
+  <!-- wxImage wxImage::Rotate90(bool clockwise = true) const -->
+  <function name="wxImage::Rotate90">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="wxImage"/>
+    <const/>
+    <use-retval/>
     <leak-ignore/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
-  <!-- void wxPropertyGridManager::SetSplitterPosition( int pos, int column = 0 ) -->
-  <!-- void wxPropertyGridPage::SetSplitterPosition( int pos, int column = 0 ) -->
-  <function name="wxPropertyGridManager::SetSplitterPosition,wxPropertyGridPage::SetSplitterPosition">
+  <!-- wxImage wxImage::Rotate180() const -->
+  <function name="wxImage::Rotate180">
+    <noreturn>false</noreturn>
+    <returnValue type="wxImage"/>
+    <const/>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- virtual wxImage wxAnimation::GetFrame(unsigned int i) const -->
+  <function name="wxAnimation::GetFrame">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="wxImage"/>
+    <const/>
+    <use-retval/>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
-    </arg>
-    <arg nr="2" default="0" direction="in">
-      <not-uninit/>
+      <valid>0:</valid>
+      <not-bool/>
     </arg>
   </function>
-  <!-- bool wxPropertyGridInterface::SetColumnProportion( unsigned int column, int proportion ) -->
-  <!-- bool wxPropertyGridPage::SetColumnProportion( unsigned int column, int proportion ) -->
-  <function name="wxPropertyGridInterface::SetColumnProportion,wxPropertyGridPage::SetColumnProportion">
+  <!-- virtual unsigned int wxAnimation::GetFrameCount(void) const -->
+  <function name="wxAnimation::GetFrameCount">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
+    <returnValue type="unsigned int"/>
+    <const/>
+    <use-retval/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
-    </arg>
   </function>
-  <!-- void wxPropertyGridManager::ShowHeader( bool show = true ) -->
-  <function name="wxPropertyGridManager::ShowHeader">
+  <!-- virtual bool wxAnimation::Load(wxInputStream & stream, wxAnimationType type = wxANIMATION_TYPE_ANY) -->
+  <function name="wxAnimation::Load">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="bool"/>
     <leak-ignore/>
-    <arg nr="1" default="true" direction="in">
+    <arg nr="1" direction="out"/>
+    <arg nr="2" default="wxANIMATION_TYPE_ANY" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxRect::Offset( const wxPoint &pt ) -->
-  <!-- void wxRect::Offset( wxCoord dx, wxCoord dy ) -->
-  <function name="wxRect::Offset">
+  <!-- virtual bool wxAnimation::LoadFile(const wxString &name, wxAnimationType type = wxANIMATION_TYPE_ANY) -->
+  <function name="wxAnimation::LoadFile">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="bool"/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
-    <arg nr="2" direction="in">
+    <arg nr="2" default="wxANIMATION_TYPE_ANY" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- bool wxRect::Intersects(const wxRect & rect) const -->
-  <function name="wxRect::Intersects">
+  <!-- virtual wxSize wxAnimation::GetSize() const -->
+  <function name="wxAnimation::GetSize">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
+    <returnValue type="wxSize"/>
+    <const/>
     <use-retval/>
     <leak-ignore/>
-    <const/>
-    <arg nr="1" direction="in"/>
   </function>
-  <!-- void wxRect::SetLeftBottom( const wxPoint & p ) -->
-  <!-- void wxRect::SetLeftTop( const wxPoint & p ) -->
-  <!-- void wxRect::SetRightBottom( const wxPoint & p ) -->
-  <!-- void wxRect::SetRightTop( const wxPoint & p ) -->
-  <function name="wxRect::SetLeftBottom,wxRect::SetLeftBottom,wxRect::SetRightBottom,wxRect::SetRightTop">
+  <!-- virtual bool wxAnimation::IsOk() const -->
+  <function name="wxAnimation::IsOk">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="bool"/>
+    <const/>
+    <use-retval/>
     <leak-ignore/>
-    <arg nr="1" direction="in"/>
   </function>
-  <!-- void wxRect::SetRight( int right ) -->
-  <!-- void wxRect::SetLeft( int left ) -->
-  <!-- void wxRect::SetWidth(int width)-->
-  <!-- void wxRect::SetHeight( int h ) -->
-  <function name="wxRect::SetRight,wxRect::SetLeft,wxRect::SetWidth,wxRect::SetHeight">
+  <!-- const wxCharBuffer wxString::ToAscii( void ) const -->
+  <!-- const const char * wxString::ToAscii( void ) const -->
+  <function name="wxString::ToAscii">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <const/>
+    <use-retval/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
   </function>
-  <!-- bool wxTextEntry::AutoComplete( wxTextCompleter * completer ) -->
-  <!-- bool wxTextEntry::AutoComplete( const wxArrayString & choices ) -->
-  <!-- bool wxSearchCtrl::AutoComplete( wxTextCompleter * completer ) -->
-  <!-- bool wxSearchCtrl::AutoComplete( const wxArrayString & choices ) -->
-  <function name="wxTextEntryBase::AutoComplete,wxSearchCtrl::AutoComplete">
+  <!--        bool wxFileName::IsDir( void ) const -->
+  <!--        bool wxFileName::IsDirReadable( void ) const -->
+  <!-- static bool wxFileName::IsDirReadable( const wxString &path ) const -->
+  <!--        bool wxFileName::IsDirWritable( void ) const -->
+  <!-- static bool wxFileName::IsDirWritable( const wxString &path ) const -->
+  <!--        bool wxFileName::IsFileExecutable( void ) const -->
+  <!-- static bool wxFileName::IsFileExecutable( const wxString &file ) const -->
+  <!--        bool wxFileName::IsFileReadable( void ) const -->
+  <!-- static bool wxFileName::IsFileReadable( const wxString &file ) const -->
+  <!--        bool wxFileName::IsFileWritable( void ) const -->
+  <!-- static bool wxFileName::IsFileWritable( const wxString &file ) const -->
+  <!--      bool wxFileName::IsOk( void ) const -->
+  <function name="wxFileName::IsDirWritable,wxFileName::IsDir,wxFileName::IsDirReadable,wxFileName::IsFileExecutable,wxFileName::IsFileReadable,wxFileName::IsFileWritable,wxFileName::IsOk">
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
+    <use-retval/>
+    <const/>
     <leak-ignore/>
-    <arg nr="1" direction="in"/>
+    <arg nr="1" default="wxEmptyString" direction="in"/>
   </function>
-  <!-- void wxSearchCtrl::SetDescriptiveText(const wxString & text)-->
-  <function name="wxSearchCtrl::SetDescriptiveText">
+  <!-- void wxDC::CopyAttributes(const wxDC & dc) -->
+  <function name="wxDC::CopyAttributes">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- virtual void wxSearchCtrl::ShowCancelButton(bool show) -->
-  <!-- virtual void wxSearchCtrl::ShowSearchButton(bool show) -->
-  <function name="wxSearchCtrl::ShowCancelButton">
-    <noreturn>false</noreturn>
-    <returnValue type="void"/>
-    <leak-ignore/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-  </function>
-  <!-- bool wxPGProperty::SetChoices(wxPGChoices & choices) -->
-  <function name="wxPGProperty::SetChoices">
+  <!-- bool wxTextFile::Open(const wxString & strFile, const wxMBConv & conv = wxConvAuto()) -->
+  <function name="wxTextFile::Open">
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
+    <arg nr="2" default="wxConvAuto()" direction="in"/>
   </function>
-  <!-- void wxPropertyGridInterface::SetPropertyHelpString(wxPGPropArg id, const wxString & helpString) -->
-  <!-- void wxPropertyGridPage::SetPropertyHelpString(wxPGPropArg id, const wxString & helpString) -->
-  <function name="wxPropertyGridInterface::SetPropertyHelpString,wxPropertyGridPage::SetPropertyHelpString">
+  <!-- bool wxTextFile::Write(wxTextFileType typeNew = wxTextFileType_None, const wxMBConv & conv = wxConvAuto()) -->
+  <function name="wxTextFile::Write">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="bool"/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <arg nr="1" default="wxTextFileType_None" direction="in">
       <not-uninit/>
     </arg>
-    <arg nr="2" direction="in"/>
+    <arg nr="2" default="wxConvAuto()" direction="in"/>
   </function>
-  <!-- void wxScrolledWindow::SetScrollRate( int xstep, int ystep ) -->
-  <function name="wxScrolledWindow::SetScrollRate">
+  <!-- static wxString wxString::From8BitData(const char * buf) -->
+  <!-- static wxString wxString::From8BitData(const char * buf, size_t len) -->
+  <function name="wxString::From8BitData">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="wxString"/>
+    <use-retval/>
     <leak-ignore/>
     <arg nr="1" direction="in">
+      <not-null/>
       <not-uninit/>
+      <strz/>
+      <minsize type="argvalue" arg="2"/>
     </arg>
-    <arg nr="2" direction="in">
+    <arg nr="2" default="0" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
     </arg>
   </function>
-  <!-- virtual wxGraphicsContext* wxGraphicsRenderer::CreateContext(wxWindow * window) -->
-  <!-- virtual wxGraphicsContext* wxGraphicsRenderer::CreateContext(const wxWindowDC &dc) -->
-  <!-- virtual wxGraphicsContext* wxGraphicsRenderer::CreateContext(const wxMemoryDC &dc) -->
-  <!-- virtual wxGraphicsContext* wxGraphicsRenderer::CreateContext(const wxPrinterDC &dc) -->
-  <!-- virtual wxGraphicsContext* wxGraphicsRenderer::CreateContext(const wxEnhMetaFileDC &dc) -->
-  <!-- static  wxGraphicsContext* wxGraphicsRenderer::CreateContextFromUnknownDC( const wxDC & dc ) -->
-  <function name="wxGraphicsRenderer::CreateContext,wxGraphicsRenderer::CreateContextFromUnknownDC">
+  <!--wxPoint wxWindow::ConvertDialogToPixels(const wxPoint & pt) const -->
+  <!--wxSize wxWindow::ConvertDialogToPixels(const wxSize & sz) const -->
+  <!--wxPoint wxWindow::ConvertPixelsToDialog(const wxPoint & pt) const -->
+  <!--wxSize wxWindow::ConvertPixelsToDialog(const wxSize & sz) const -->
+  <function name="wxWindow::ConvertDialogToPixels,wxWindow::ConvertPixelsToDialog">
     <noreturn>false</noreturn>
-    <returnValue type="wxGraphicsContext *"/>
+    <leak-ignore/>
+    <const/>
+    <use-retval/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- virtual bool wxGraphicsContext::SetInterpolationQuality(wxInterpolationQuality interpolation) -->
-  <!-- virtual bool wxGraphicsContext::SetAntialiasMode(wxAntialiasMode antialias) -->
-  <function name="wxGraphicsContext::SetInterpolationQuality,wxGraphicsContext::SetAntialiasMode">
+  <!--wxSizerFlags& wxSizerFlags::Align(int direction)  -->
+  <function name="wxSizerFlags::Align">
     <noreturn>false</noreturn>
+    <returnValue type="wxSizerFlags &amp;"/>
     <leak-ignore/>
-    <returnValue type="bool"/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxGCDC::SetGraphicsContext( wxGraphicsContext * ctx ) -->
-  <function name="wxGCDC::SetGraphicsContext">
+  <!--wxSizerFlags& wxSizerFlags::Border(int direction = wxALL) -->
+  <!--wxSizerFlags& wxSizerFlags::Border(int direction, int borderinpixels) -->
+  <function name="wxSizerFlags::Border">
     <noreturn>false</noreturn>
+    <returnValue type="wxSizerFlags &amp;"/>
     <leak-ignore/>
-    <returnValue type="void"/>
-    <arg nr="1" direction="in">
-      <not-null/>
+    <arg nr="1" direction="in" default="wxALL">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in" default="0">
+      <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- wxGraphicsContext * wxDC::GetGraphicsContext( void ) -->
-  <function name="wxGCDC::GetGraphicsContext">
+  <!--       wxRect wxGrid::CellToRect(int row, int col) const -->
+  <!-- TODO: wxRect wxGrid::CellToRect(const wxGridCellCoords & coords) const -->
+  <function name="wxGrid::CellToRect">
     <noreturn>false</noreturn>
-    <returnValue type="wxGraphicsContext *"/>
+    <returnValue type="wxRect"/>
     <use-retval/>
-  </function>
-  <!-- virtual wxOutputStream & wxOutputStream::Write( const void * buffer, size_t size ) -->
-  <!--         wxOutputStream & wxMemoryOutputStream::Write( const void * buffer, size_t size ) -->
-  <!-- virtual wxOutputStream & wxOutputStream::WriteAll( const void * buffer, size_t size ) -->
-  <!--         wxOutputStream & wxMemoryOutputStream::WriteAll( const void * buffer, size_t size ) -->
-  <function name="wxOutputStream::Write,wxOutputStream::WriteAll,wxMemoryOutputStream::Write,wxMemoryOutputStream::WriteAll">
-    <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue type="wxOutputStream &amp;"/>
+    <const/>
     <arg nr="1" direction="in">
       <not-uninit/>
-      <not-null/>
+      <not-bool/>
+      <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
     </arg>
   </function>
-  <!-- @todo: bool wxCmdLineParser::Found( const wxString & name) const -->
-  <!-- bool wxCmdLineParser::Found( const wxString & name, wxString * value ) const -->
-  <!-- bool wxCmdLineParser::Found( const wxString & name, long * value ) const -->
-  <!-- bool wxCmdLineParser::Found( const wxString & name, double * value ) const -->
-  <!-- bool wxCmdLineParser::Found( const wxString & name, wxDateTime * value ) const -->
-  <function name="wxCmdLineParser::Found">
+  <!-- int wxGrid::GetRowLabelSize() const -->
+  <!-- int wxGrid::GetColLabelSize() const -->
+  <!-- int wxGrid::GetRowMinimalAcceptableHeight() const -->
+  <!-- int wxGrid::GetScrollLineX() const -->
+  <!-- int wxGrid::GetScrollLineY() const -->
+  <!-- int wxGrid::GetNumberRows() const -->
+  <!-- int wxGrid::GetNumberFrozenRows() const -->
+  <!-- int wxGrid::GetNumberFrozenCols() const -->
+  <!-- int wxGrid::GetNumberCols() const -->
+  <function name="wxGrid::GetRowLabelSize,wxGrid::GetColLabelSize,wxGrid::GetRowMinimalAcceptableHeight,wxGrid::GetScrollLineX,wxGrid::GetScrollLineY,wxGrid::GetNumberRows,wxGrid::GetNumberFrozenRows,wxGrid::GetNumberFrozenCols,wxGrid::GetNumberCols">
+    <noreturn>false</noreturn>
+    <returnValue type="int"/>
+    <use-retval/>
+    <leak-ignore/>
+    <const/>
+  </function>
+  <!-- wxPoint wxWindow::GetScreenPosition() const -->
+  <!-- wxPoint wxGrid::GetScreenPosition() const -->
+  <function name="wxWindow::GetScreenPosition,wxGrid::GetScreenPosition">
+    <noreturn>false</noreturn>
+    <returnValue type="wxPoint"/>
+    <use-retval/>
+    <leak-ignore/>
+    <const/>
+  </function>
+  <!-- unsigned int wxDataViewListCtrl::GetItemCount( )const -->
+  <function name="wxDataViewListCtrl::GetItemCount">
+    <noreturn>false</noreturn>
+    <returnValue type="unsigned int"/>
+    <use-retval/>
+    <leak-ignore/>
+    <const/>
+  </function>
+  <!-- static wxStandardPaths& wxStandardPaths::Get() -->
+  <function name="wxStandardPaths::Get">
+    <noreturn>false</noreturn>
+    <returnValue type="wxStandardPaths &amp;"/>
+    <use-retval/>
+    <leak-ignore/>
+  </function>
+  <!-- wxFont wxGrid::GetLabelFont() const -->
+  <function name="wxGrid::GetLabelFont">
+    <noreturn>false</noreturn>
+    <returnValue type="wxFont"/>
+    <use-retval/>
+    <leak-ignore/>
+    <const/>
+  </function>
+  <!-- int wxGridEvent::GetCol( void ) const -->
+  <!-- int wxGridEvent::GetRow( void ) const -->
+  <function name="wxGridEvent::GetCol,wxGridEvent::GetRow">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="int"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- wxPoint wxGridEvent::GetPosition( void ) const -->
+  <!-- wxPoint wxMouseEvent::GetPosition( void ) const -->
+  <!-- wxPoint wxMouseState::GetPosition( void ) const -->
+  <function name="wxGridEvent::GetPosition,wxMouseEvent::GetPosition,wxMouseState::GetPosition">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxPoint"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- wxColour wxGrid::GetLabelBackgroundColour() const -->
+  <!-- wxColour wxGrid::GetLabelTextColour() const -->
+  <function name="wxGrid::GetLabelTextColour,wxGrid::GetLabelBackgroundColour">
+    <noreturn>false</noreturn>
+    <returnValue type="wxColour"/>
+    <use-retval/>
+    <leak-ignore/>
+    <const/>
+  </function>
+  <!-- wxGridSizesInfo wxGrid::GetRowSizes() const -->
+  <function name="wxGrid::GetRowSizes">
     <noreturn>false</noreturn>
-    <leak-ignore/>
-    <returnValue type="bool"/>
+    <returnValue type="wxGridSizesInfo"/>
     <use-retval/>
+    <leak-ignore/>
     <const/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" direction="out">
-      <not-null/>
-    </arg>
   </function>
-  <!-- static wxString wxFileSystem::FileNameToURL( const wxFileName & filename ) -->
-  <function name="wxFileSystem::FileNameToURL">
+  <!-- wxString wxGrid::GetRowLabelValue(int row) const -->
+  <function name="wxGrid::GetRowLabelValue">
     <noreturn>false</noreturn>
     <returnValue type="wxString"/>
-    <pure/>
-    <leak-ignore/>
     <use-retval/>
-    <arg nr="1" direction="in"/>
-  </function>
-  <!-- static wxUniChar wxFileName::GetPathSeparator(wxPathFormat format = wxPATH_NATIVE) -->
-  <function name="wxFileName::GetPathSeparator">
-    <noreturn>false</noreturn>
-    <returnValue type="wxUniChar"/>
-    <pure/>
     <leak-ignore/>
-    <use-retval/>
-    <arg nr="1" default="wxPATH_NATIVE" direction="in">
+    <const/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
     </arg>
   </function>
-  <!-- void wxWindow::ClientToScreen(int * x, int * y) const -->
-  <function name="wxWindow::ClientToScreen">
+  <!-- int wxGrid::GetRowMinimalHeight(int col) const -->
+  <function name="wxGrid::GetRowMinimalHeight">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
-    <const/>
+    <returnValue type="int"/>
+    <use-retval/>
     <leak-ignore/>
-    <arg nr="1" direction="out">
-      <not-null/>
-    </arg>
-    <arg nr="2" direction="out">
-      <not-null/>
+    <const/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
     </arg>
   </function>
-  <!-- virtual void wxToolBar::EnableTool(int toolId, bool enable)-->
-  <function name="wxToolBar::EnableTool">
+  <!-- virtual wxString wxTextCtrl::GetLineText(long lineNo) const -->
+  <function name="wxTextCtrl::GetLineText">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="wxString"/>
+    <use-retval/>
     <leak-ignore/>
+    <const/>
     <arg nr="1" direction="in">
       <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
     </arg>
   </function>
-  <!-- void wxListItem::SetColumn(int col) -->
-  <!-- void wxListItem::SetId(long id) -->
-  <!-- void wxListItem::SetImage(int image) -->
-  <!-- void wxListItem::SetMask(long mask) -->
-  <!-- void wxListItem::SetStateMask(long stateMask) -->
-  <!-- void wxListItem::SetWidth(int width) -->
-  <function name="wxListItem::SetColumn,wxListItem::SetId,wxListItem::SetImage,wxListItem::SetMask,wxListItem::SetStateMask,wxListItem::SetWidth">
+  <!-- wxWindow* wxBookCtrlBase::GetPage(size_t page) const -->
+  <!-- wxWindow* wxNotebook::GetPage(size_t page) const -->
+  <function name="wxBookCtrlBase::GetPage,wxNotebook::GetPage">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="wxWindow *"/>
+    <use-retval/>
     <leak-ignore/>
+    <const/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
     </arg>
   </function>
-  <!-- virtual bool wxPopupTransientWindow::ProcessLeftDown(wxMouseEvent & event) -->
-  <function name="wxPopupTransientWindow::ProcessLeftDown">
+  <!-- void wxCmdLineParser::SetLogo (const wxString & logo) -->
+  <!-- void wxCmdLineParser::SetSwitchChars (const wxString & switchChars) -->
+  <!-- void wxCmdLineParser::SetCmdLine (const wxString & commandline) -->
+  <function name="wxCmdLineParser::SetSwitchChars,wxCmdLineParser::SetLogo,wxCmdLineParser::SetCmdLine">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
+    <returnValue type="void"/>
     <leak-ignore/>
-    <arg nr="1" direction="inout"/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!-- virtual void wxPopupTransientWindow::Popup(wxWindow * focus = NULL) -->
-  <function name="wxPopupTransientWindow::Popup">
+  <!-- void wxCmdLineParser::SetDesc(const wxCmdLineEntryDesc * desc) -->
+  <function name="wxCmdLineParser::SetDesc">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
-    <arg nr="1" default="0" direction="inout">
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <not-null/>
     </arg>
   </function>
-  <!-- wxPoint wxMouseEvent::GetLogicalPosition(const wxDC & dc) const -->
-  <function name="wxMouseEvent::GetLogicalPosition">
+  <!-- virtual void wxWebView::SetPage(const wxString & html, const wxString & baseUrl) -->
+  <!-- virtual void wxWebView::SetPage(wxInputStream & html, wxString baseUrl) -->
+  <function name="wxWebView::SetPage">
     <noreturn>false</noreturn>
-    <returnValue type="wxPoint"/>
+    <returnValue type="void"/>
     <leak-ignore/>
-    <use-retval/>
-    <const/>
     <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
   </function>
-  <!-- wxAuiPaneInfo& wxAuiManager::GetPane(wxWindow * window) -->
-  <!-- wxAuiPaneInfo& wxAuiManager::GetPane(const wxString & name) -->
-  <function name="wxAuiManager::GetPane">
+  <!-- static wxWebView* wxWebView::New (const wxString & backend = wxWebViewBackendDefault) -->
+  <!-- static wxWebView* wxWebView::New (wxWindow * parent, wxWindowID id, const wxString & url = wxWebViewDefaultURLStr, const wxPoint & pos = wxDefaultPosition, const wxSize & size = wxDefaultSize, const wxString & backend = wxWebViewBackendDefault, long style = 0, const wxString & name = wxWebViewNameStr) -->
+  <function name="wxWebView::New">
     <noreturn>false</noreturn>
-    <returnValue type="wxAuiPaneInfo &amp;"/>
+    <returnValue type="wxWebView*"/>
     <leak-ignore/>
     <use-retval/>
-    <arg nr="1"/>
+    <arg nr="any" direction="in"/>
   </function>
-  <!-- virtual void wxConfigBase::SetPath(const wxString &strPath) = 0 -->
-  <!-- virtual void wxConfig::SetPath(const wxString &strPath) -->
-  <!-- virtual void wxFileConfig::SetPath(const wxString &strPath)-->
-  <!-- virtual void wxRegConfig::SetPath(const wxString &strPath)-->
-  <function name="wxConfigBase::SetPath,wxConfig::SetPath,wxFileConfig::SetPath,wxRegConfig::SetPath">
+  <!-- void wxColourData::SetCustomColour(int i, const wxColour &c)  -->
+  <function name="wxColourData::SetCustomColour">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
-    <arg nr="1" direction="in"/>
-  </function>
-  <!--wxString wxString::Right(size_t count) const -->
-  <!--wxString wxString::Left(size_t count) const -->
-  <function name="wxString::Right,wxString::Left">
-    <noreturn>false</noreturn>
-    <returnValue type="wxString"/>
-    <const/>
-    <leak-ignore/>
-    <use-retval/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <!-- From wxWidgets-documentation: An integer between 0 and 15, being any of the 15 custom colours that the user has saved. -->
+      <valid>0:15</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
     </arg>
   </function>
-  <!--void wxDC::SetLogicalFunction(wxRasterOperationMode function)-->
-  <function name="wxDC::SetLogicalFunction">
+  <!-- wxColour wxColourData::GetCustomColour(int i) const -->
+  <function name="wxColourData::GetCustomColour">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="wxColour"/>
+    <use-retval/>
     <leak-ignore/>
+    <const/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <!-- From wxWidgets-documentation: An integer between 0 and 15, being any of the 15 custom colours that the user has saved. -->
+      <valid>0:15</valid>
     </arg>
   </function>
-  <!--bool wxLayoutAlgorithm::LayoutFrame (wxFrame * frame, wxWindow * mainWindow = NULL) -->
-  <!--bool wxLayoutAlgorithm::LayoutMDIFrame (wxMDIParentFrame * frame, wxRect * rect = NULL) -->
-  <!--bool wxLayoutAlgorithm::LayoutWindow (wxWindow * frame, wxWindow * mainWindow = NULL) -->
-  <function name="wxLayoutAlgorithm::LayoutFrame,wxLayoutAlgorithm::LayoutMDIFrame,wxLayoutAlgorithm::LayoutWindow">
+  <!-- bool wxDragImage::Move(const wxPoint & pt) -->
+  <function name="wxDragImage::Move">
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
     <leak-ignore/>
-    <arg nr="1" direction="inout">
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- bool wxDragImage::Show() -->
+  <function name="wxDragImage::Show">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+  </function>
+  <!-- bool wxDragImage::BeginDrag(const wxPoint & hotspot, wxWindow * window, bool fullScreen = false, wxRect * rect = NULL) -->
+  <!-- bool wxDragImage::BeginDrag(const wxPoint & hotspot, wxWindow * window, wxWindow * boundingWindow) -->
+  <function name="wxDragImage::BeginDrag">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
       <not-uninit/>
       <not-null/>
     </arg>
-    <arg nr="2" default="NULL" direction="inout">
+    <arg nr="3" default="false" direction="in"/>
+    <arg nr="4" default="NULL" direction="in">
       <not-uninit/>
     </arg>
   </function>
-  <!--virtual wxPGCellRenderer* wxPGProperty::GetCellRenderer(int column) const -->
-  <function name="wxPGProperty::GetCellRenderer,wxStringProperty::GetCellRenderer">
+  <!-- wxString & wxString::Prepend(const wxString &str); -->
+  <function name="wxString::Prepend">
     <noreturn>false</noreturn>
-    <returnValue type="wxPGCellRenderer*"/>
+    <returnValue type="wxString &amp;"/>
     <leak-ignore/>
-    <const/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
+    <arg nr="1" direction="in"/>
   </function>
-  <!--static void wxImage::AddHandler(wxImageHandler * handler)-->
-  <function name="wxImage::AddHandler">
+  <!-- virtual void wxFileDialog::SetMessage(const wxString &str); -->
+  <!-- virtual void wxFileDialog::SetPath(const wxString &str); -->
+  <!-- virtual void wxFileDialog::SetFilename(const wxString &str); -->
+  <!-- virtual void wxFileDialog::SetWildcard(const wxString &str); -->
+  <!-- virtual void wxFileDialog::SetDirectory(const wxString &str); -->
+  <function name="wxFileDialog::SetMessage,wxFileDialog::SetPath,wxFileDialog::SetFilename,wxFileDialog::SetWildcard,wxFileDialog::SetDirectory">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-      <not-null/>
-    </arg>
+    <arg nr="1" direction="in"/>
   </function>
-  <!--void wxGrid::SetGridLineColour(const wxColour & colour) -->
-  <!--void wxGrid::SetLabelBackgroundColour(const wxColour & colour) -->
-  <!--void wxGrid::SetLabelTextColour(const wxColour & colour) -->
-  <!--void wxGrid::SetLabelFont(const wxFont & font) -->
-  <function name="wxGrid::SetGridLineColour,wxGrid::SetLabelBackgroundColour,wxGrid::SetLabelTextColour,wxGrid::SetLabelFont">
+  <!-- virtual bool wxFont::SetFaceName(const wxString &str); -->
+  <function name="wxFont::SetFaceName">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="bool"/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
   </function>
-  <!--void wxDC::SetLayoutDirection(wxLayoutDirection dir)-->
-  <function name="wxDC::SetLayoutDirection">
+  <!-- static int wxSystemSettings::GetMetric(wxSystemMetric index, wxWindow * win = NULL) -->
+  <function name="wxSystemSettings::GetMetric">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="int"/>
+    <use-retval/>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
     </arg>
+    <arg nr="2" default="NULL" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
-  <!--virtual bool wxImage::SaveFile(wxOutputStream & stream, const wxString & mimetype) const -->
-  <!--virtual bool wxImage::SaveFile(wxOutputStream & stream, wxBitmapType type) const -->
-  <!--virtual bool wxImage::SaveFile(const wxString & name, wxBitmapType type) const -->
-  <!--virtual bool wxImage::SaveFile(const wxString & name, const wxString & mimetype) const -->
-  <!--virtual bool wxImage::SaveFile(const wxString & name) const -->
-  <function name="wxImage::SaveFile">
+  <!-- static wxString wxSystemOptions::GetOption(const wxString & name) -->
+  <function name="wxSystemOptions::GetOption">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <const/>
+    <returnValue type="wxString"/>
+    <use-retval/>
     <leak-ignore/>
-    <arg nr="1"/>
-    <arg nr="2" default="" direction="in"/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!--static void wxLog::SetTimestamp(const wxString & format) -->
-  <function name="wxLog::SetTimestamp">
+  <!-- static int wxSystemOptions::GetOptionInt(const wxString & name) -->
+  <function name="wxSystemOptions::GetOptionInt">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
-    <pure/>
+    <returnValue type="int"/>
+    <use-retval/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
   </function>
-  <!--virtual void wxTextEntry::ChangeValue(const wxString & value)-->
-  <!--virtual void wxTextCtrl::ChangeValue(const wxString & value)-->
-  <function name="wxTextEntry::ChangeValue,wxTextCtrl::ChangeValue">
+  <!-- static bool wxSystemOptions::HasOption(const wxString & name) -->
+  <!-- static bool wxSystemOptions::IsFalse(const wxString & name) -->
+  <function name="wxSystemOptions::HasOption,wxSystemOptions::IsFalse">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="bool"/>
+    <use-retval/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
   </function>
-  <!--virtual void wxWindow::SetName(const wxString & name)-->
-  <function name="wxWindow::SetName">
+  <!-- virtual int wxTextCtrl::GetNumberOfLines(void) const -->
+  <function name="wxTextCtrl::GetNumberOfLines">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="int"/>
+    <use-retval/>
+    <leak-ignore/>
+    <const/>
+  </function>
+  <!-- static wxFont wxSystemSettings::GetFont(wxSystemFont index) -->
+  <function name="wxSystemSettings::GetFont">
+    <noreturn>false</noreturn>
+    <returnValue type="wxFont"/>
+    <use-retval/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
   </function>
-  <!--virtual void wxWindow::SetMinClientSize(const wxSize & size)-->
-  <!--virtual void wxWindow::SetMinSize(const wxSize & size)-->
-  <!--virtual void wxGrid::SetMinClientSize(const wxSize & size)-->
-  <!--virtual void wxGrid::SetMinSize(const wxSize & size)-->
-  <function name="wxWindow::SetMinClientSize,wxWindow::SetMinSize,wxGrid::SetMinClientSize,wxGrid::SetMinSize">
+  <!-- long wxGetNumberFromUser(const wxString & message,
+     const wxString & prompt,
+     const wxString & caption,
+     long value,
+     long min = 0,
+     long max = 100,
+     wxWindow * parent = NULL,
+     const wxPoint & pos = wxDefaultPosition
+     )-->
+  <function name="wxGetNumberFromUser">
+    <noreturn>false</noreturn>
+    <returnValue type="long"/>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="inout">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" default="0" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="6" default="100" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="7" default="NULL" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="7" default="wxDefaultPosition" direction="in"/>
+  </function>
+  <!-- wxString wxGetPasswordFromUser (const wxString & message,
+                                       const wxString & caption = wxGetPasswordFromUserPromptStr,
+                                       const wxString & default_value = wxEmptyString,
+                                       wxWindow * parent = NULL,
+                                       int x = wxDefaultCoord,
+                                       int y = wxDefaultCoord,
+                                       bool centre = true) -->
+  <function name="wxGetPasswordFromUser">
+    <noreturn>false</noreturn>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="Enter Password" direction="in"/>
+    <arg nr="3" default="wxEmptyString" direction="in"/>
+    <arg nr="4" default="NULL" direction="inout">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" default="wxDefaultCoord" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="6" default="wxDefaultCoord" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="7" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- wxString wxGetTextFromUser(const wxString &message,
+                                   const wxString &caption=wxGetTextFromUserPromptStr,
+                                   const wxString &default_value=wxEmptyString,
+                                   wxWindow *parent=NULL,
+                                   int x=wxDefaultCoord,
+                                   int y=wxDefaultCoord,
+                                   bool centre=true) -->
+  <function name="wxGetTextFromUser">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="wxString"/>
+    <use-retval/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
+    <arg nr="2" default="Input Text" direction="in"/>
+    <arg nr="3" default="wxEmptyString" direction="in"/>
+    <arg nr="4" default="NULL" direction="inout">
+      <not-uninit/>
+    </arg>
+    <arg nr="5" default="wxDefaultCoord" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="6" default="wxDefaultCoord" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="7" default="true" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
-  <!--bool wxShutdown(int flags = wxSHUTDOWN_POWEROFF) -->
-  <function name="wxShutdown">
+  <!-- bool wxGetEnvMap (wxEnvVariableHashMap * map) -->
+  <function name="wxGetEnvMap">
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
     <leak-ignore/>
-    <arg nr="1" default="wxSHUTDOWN_POWEROFF" direction="in">
+    <arg nr="1" direction="out">
+      <not-null/>
       <not-uninit/>
     </arg>
   </function>
-  <!--unsigned long wxGetProcessId(void)-->
-  <function name="wxGetProcessId">
-    <noreturn>false</noreturn>
-    <returnValue type="unsigned long"/>
-    <leak-ignore/>
-    <use-retval/>
-  </function>
-  <!-- const wxString& wxHtmlEasyPrinting::GetName( void )  const -->
-  <function name="wxHtmlEasyPrinting::GetName">
-    <noreturn>false</noreturn>
-    <returnValue type="wxString &amp;"/>
-    <leak-ignore/>
-    <use-retval/>
-    <const/>
-  </function>
-  <!-- wxPageSetupDialogData * wxHtmlEasyPrinting::GetPageSetupData( void ) -->
-  <function name="wxHtmlEasyPrinting::GetPageSetupData">
+  <!-- virtual bool wxPrinter::Print(wxWindow * parent, wxPrintout * printout, bool prompt = true) -->
+  <function name="wxPrinter::Print">
     <noreturn>false</noreturn>
-    <returnValue type="wxPageSetupDialogData *"/>
-    <use-retval/>
+    <returnValue type="bool"/>
     <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="inout">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="3" default="true" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
-  <!-- wxWindow wxHtmlEasyPrinting::GetParentWindow( void )  const -->
-  <function name="wxHtmlEasyPrinting::GetParentWindow">
+  <!-- wxFont wxGetFontFromUser(wxWindow *parent, const wxFont & fontInit, const wxString & caption = wxEmptyString) -->
+  <function name="wxGetFontFromUser">
     <noreturn>false</noreturn>
-    <returnValue type="wxWindow *"/>
+    <returnValue type="wxFont"/>
     <leak-ignore/>
-    <use-retval/>
-    <const/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" default="wxEmptyString" direction="in"/>
   </function>
-  <!-- wxPrintData * wxHtmlEasyPrinting::GetPrintData( void ) -->
-  <function name="wxHtmlEasyPrinting::GetPrintData">
+  <!-- wxColour wxGetColourFromUser (wxWindow *parent, const wxColour &colInit, const wxString &caption=wxEmptyString, wxColourData *data=NULL) -->
+  <function name="wxGetColourFromUser">
     <noreturn>false</noreturn>
-    <returnValue type="wxPrintData *"/>
-    <use-retval/>
+    <returnValue type="wxColour"/>
     <leak-ignore/>
+    <arg nr="1" direction="inout">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" default="wxEmptyString" direction="in"/>
+    <arg nr="4" default="NULL" direction="out">
+      <not-uninit/>
+    </arg>
   </function>
-  <!-- void wxHtmlEasyPrinting::PageSetup( void ) -->
-  <function name="wxHtmlEasyPrinting::PageSetup">
+  <!-- void wxPropertyGridInterface::SetPropertyCell(wxPGPropArg id, int column, const wxString & text = wxEmptyString, const wxBitmap & bitmap = wxNullBitmap, const wxColour & fgCol = wxNullColour, const wxColour & bgCol = wxNullColour ) -->
+  <!-- void wxPropertyGrid::SetPropertyCell(wxPGPropArg id, int column, const wxString & text = wxEmptyString, const wxBitmap & bitmap = wxNullBitmap, const wxColour & fgCol = wxNullColour, const wxColour & bgCol = wxNullColour ) -->
+  <function name="wxPropertyGridInterface::SetPropertyCell,wxPropertyGrid::SetPropertyCell">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
-  </function>
-  <!-- bool wxHtmlEasyPrinting::PreviewFile( const wxString & htmlfile ) -->
-  <function name="wxHtmlEasyPrinting::PreviewFile">
-    <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <leak-ignore/>
     <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" default="wxEmptyString" direction="in"/>
+    <arg nr="4" default="wxNullBitmap" direction="in"/>
+    <arg nr="5" default="wxNullColour" direction="in"/>
+    <arg nr="6" default="wxNullColour" direction="in"/>
   </function>
-  <!-- bool wxHtmlEasyPrinting::PreviewText( const wxString & htmltext, const wxString & basepath = wxEmptyString ) -->
-  <function name="wxHtmlEasyPrinting::PreviewText">
+  <!-- bool wxPropertyGridInterface::HideProperty(wxPGPropArg id, bool hide = true, int flags = wxPG_RECURSE) -->
+  <!-- bool wxPropertyGridPage::HideProperty(wxPGPropArg id, bool hide = true, int flags = wxPG_RECURSE) -->
+  <function name="wxPropertyGridInterface::HideProperty,wxPropertyGridPage::HideProperty">
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
-    <arg nr="2" default="wxEmptyString" direction="in"/>
+    <arg nr="2" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="3" default="wxPG_RECURSE" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
   </function>
-  <!-- bool wxHtmlEasyPrinting::PrintFile( const wxString & htmlfile ) -->
-  <function name="wxHtmlEasyPrinting::PrintFile">
+  <!-- void wxColourData::SetColour(const wxColour & colour) -->
+  <function name="wxColourData::SetColour">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
+    <returnValue type="void"/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- bool wxHtmlEasyPrinting::PrintText( const wxString & htmltext, const wxString & basepath = wxEmptyString ) -->
-  <function name="wxHtmlEasyPrinting::PrintText">
+  <!-- int wxCmdLineParser::Parse(bool giveUsage = true) -->
+  <function name="wxCmdLineParser::Parse">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
+    <returnValue type="int"/>
     <leak-ignore/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" default="wxEmptyString" direction="in"/>
+    <arg nr="1" default="true" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
-  <!-- void wxHtmlEasyPrinting::SetFooter( const wxString & footer, int pg = wxPAGE_ALL ) -->
-  <function name="wxHtmlEasyPrinting::SetFooter">
+  <!-- void wxPGMultiButton::Add(const wxString & label, int id = -2) -->
+  <!-- void wxPGMultiButton::Add(const wxBitmap & bitmap, int id = -2) -->
+  <function name="wxPGMultiButton::Add">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
-    <arg nr="2" default="wxPAGE_ALL" direction="in">
+    <arg nr="2" default="-2" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxHtmlEasyPrinting::SetHeader( const wxString & header, int pg = wxPAGE_ALL ) -->
-  <function name="wxHtmlEasyPrinting::SetHeader">
+  <!-- int wxPGMultiButton::GetButtonId(unsigned int i) const -->
+  <function name="wxPGMultiButton::GetButtonId">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="int"/>
+    <use-retval/>
     <leak-ignore/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" default="wxPAGE_ALL" direction="in">
+    <const/>
+    <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>0:</valid>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxHtmlEasyPrinting::SetParentWindow(wxWindow *w) -->
-  <function name="wxHtmlEasyPrinting::SetParentWindow">
+  <!-- wxString wxCmdLineParser::GetParam(size_t n = 0) const -->
+  <function name="wxCmdLineParser::GetParam">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="wxString"/>
+    <use-retval/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <const/>
+    <arg nr="1" default="0" direction="in">
       <not-uninit/>
-      <not-null/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- bool wxGrid::SetTable(wxGridTableBase * table, bool takeOwnership = false, wxGridSelectionModes selmode = wxGridSelectCells) -->
-  <function name="wxGrid::SetTable">
+  <!-- void wxPropertyGridInterface::SetPropertyEditor(wxPGPropArg id, const wxPGEditor * editor) -->
+  <!-- void wxPropertyGridInterface::SetPropertyEditor(wxPGPropArg id, const wxString &name) -->
+  <!-- void wxPropertyGridPage::SetPropertyEditor(wxPGPropArg id, const wxPGEditor * editor) -->
+  <!-- void wxPropertyGridPage::SetPropertyEditor(wxPGPropArg id, const wxString &name) -->
+  <function name="wxPropertyGridInterface::SetPropertyEditor,wxPropertyGridPage::SetPropertyEditor">
+    <noreturn>false</noreturn>
+    <returnValue type="void"/>
+    <leak-ignore/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+  </function>
+  <!-- virtual bool wxPGProperty::OnEvent(wxPropertyGrid * propgrid, wxWindow * wnd_primary, wxEvent & event)-->
+  <!--         bool wxStringProperty::OnEvent(wxPropertyGrid * propgrid, wxWindow * wnd_primary, wxEvent & event)-->
+  <!--         bool wxPGTextCtrlEditor::OnEvent(wxPropertyGrid * propgrid, wxWindow * wnd_primary, wxEvent & event)-->
+  <function name="wxPGProperty::OnEvent,wxStringProperty::OnEvent,wxPGTextCtrlEditor::OnEvent">
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
     <leak-ignore/>
-    <arg nr="1" direction="inout">
+    <arg nr="1" direction="in">
       <not-uninit/>
       <not-null/>
     </arg>
-    <arg nr="2" default="false" direction="in">
+    <arg nr="2" direction="in">
       <not-uninit/>
+      <not-null/>
     </arg>
-    <arg nr="3" default="wxGridSelectCells" direction="in">
+    <arg nr="3" direction="inout"/>
+  </function>
+  <!-- wxString& wxString::insert(size_t nPos, const wxString & str) -->
+  <!-- wxString& wxString::insert(size_t nPos, const wxString & str, size_t nStart, size_t n)-->
+  <!-- wxString& wxString::insert(size_t nPos, const char * sz, size_t n ) -->
+  <!-- wxString& wxString::insert(size_t nPos, const wchar_t * sz, size_t n) -->
+  <!-- wxString& wxString::insert(size_t nPos, size_t n, wxUniChar ch) -->
+  <!-- iterator  wxString::insert(iterator it, wxUniChar ch) -->
+  <!-- void      wxString::insert(iterator it, const_iterator first, const_iterator last) -->
+  <!-- void      wxString::insert(iterator it, size_type n, wxUniChar ch)-->
+  <!-- Return value type is "iterator", "wxString&" or "void" depending on the overloaded function. -->
+  <function name="wxString::insert">
+    <noreturn>false</noreturn>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2" direction="in" default="0"/>
+    <arg nr="3" direction="in" default="0"/>
+    <arg nr="4" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
   </function>
-  <!-- void wxGrid::SetColMinimalAcceptableWidth( int width ) -->
-  <function name="wxGrid::SetColMinimalAcceptableWidth">
+  <!-- virtual bool wxPGProperty::StringToValue (wxVariant & variant, const wxString & text, int argFlags = 0) const -->
+  <function name="wxPGProperty::StringToValue">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="bool"/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
+    <const/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" default="0" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
     </arg>
   </function>
-  <!-- void wxGrid::SetColMinimalWidth( int col, int width ) -->
-  <function name="wxGrid::SetColMinimalWidth">
+  <!-- void wxArrayString:reserve(wxString::size_type new_capacity); -->
+  <function name="wxArrayString::reserve">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
-    <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in">
-      <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
     </arg>
   </function>
-  <!-- void wxGrid::SelectRow(int row, bool addToSelected = false) -->
-  <function name="wxGrid::SelectRow">
+  <!-- virtual wxTextPos wxTextEntry::GetLastPosition ( ) const -->
+  <!-- virtual wxTextPos wxStyledTextCtrl::GetLastPosition ( ) const -->
+  <!-- virtual wxTextPos wxComboCtrl::GetLastPosition ( ) const -->
+  <function name="wxTextEntry::GetLastPosition,wxStyledTextCtrl::GetLastPosition,wxComboCtrl::GetLastPosition">
     <noreturn>false</noreturn>
-    <returnValue type="void"/>
+    <returnValue type="wxTextPos"/>
+    <use-retval/>
+    <const/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" default="false" direction="in">
-      <not-uninit/>
-    </arg>
   </function>
-  <!-- wxOperatingSystemId wxGetOsVersion(int * major = NULL, int * minor = NULL)-->
-  <function name="wxGetOsVersion">
+  <!-- virtual wxString wxTextEntry::GetStringSelection ( ) const -->
+  <!-- virtual wxString wxTextEntry::GetValue ( ) const -->
+  <!-- virtual wxString wxTextCtrl::GetStringSelection ( ) const -->
+  <!-- virtual wxString wxTextCtrl::GetValue ( ) const -->
+  <!-- virtual wxString wxComboBox::GetStringSelection ( ) const -->
+  <function name="wxTextEntry::GetStringSelection,wxTextEntry::GetValue,wxTextCtrl::GetStringSelection,wxTextCtrl::GetValue,wxComboBox::GetStringSelection">
     <noreturn>false</noreturn>
-    <returnValue type="wxOperatingSystemId"/>
+    <returnValue type="wxString"/>
     <use-retval/>
+    <const/>
     <leak-ignore/>
-    <arg nr="1" default="NULL" direction="out"/>
-    <arg nr="2" default="NULL" direction="out"/>
   </function>
-  <!-- bool wxGrid::IsRowShown(int row) const  -->
-  <function name="wxGrid::IsRowShown">
+  <!-- virtual wxString wxTextCtrl::GetRange( long from, long to ) const -->
+  <!-- virtual wxString wxTextEntry::GetRange( long from, long to ) const -->
+  <function name="wxTextEntry::GetRange,wxTextCtrl::GetRange">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
+    <returnValue type="wxString"/>
     <use-retval/>
+    <const/>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+      <valid>1:</valid>
     </arg>
   </function>
-  <!-- virtual int wxAnimation::GetDelay(unsigned int i) const -->
-  <function name="wxAnimation::GetDelay">
+  <!-- virtual bool wxTextCtrl::GetStyle (long position, wxTextAttr & style) -->
+  <function name="wxTextCtrl::GetStyle">
     <noreturn>false</noreturn>
-    <returnValue type="int"/>
-    <const/>
-    <use-retval/>
+    <returnValue type="bool"/>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
+      <valid>0:</valid>
     </arg>
+    <arg nr="2" direction="out"/>
   </function>
-  <!-- wxImage wxImage::Rotate(double angle, const wxPoint & rotationCentre, bool interpolating = true, wxPoint * offsetAfterRotation = NULL) const -->
-  <function name="wxImage::Rotate">
+  <!-- void wxRichTextAttr:SetFlags(long flags); -->
+  <function name="wxRichTextAttr::SetFlags">
     <noreturn>false</noreturn>
-    <returnValue type="wxImage"/>
-    <const/>
-    <use-retval/>
+    <returnValue type="void"/>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <not-bool/>
     </arg>
-    <arg nr="2" direction="in"/>
-    <arg nr="3" default="true" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="4" default="NULL" direction="out"/>
   </function>
-  <!-- void wxImage::RotateHue(double angle) -->
-  <function name="wxImage::RotateHue">
+  <!-- virtual void wxWizard::SetPageSize(const wxSize & sizePage) -->
+  <function name="wxWizard::SetPageSize">
     <noreturn>false</noreturn>
+    <leak-ignore/>
     <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
+  </function>
+  <!-- long wxExecute (const wxString & command, int flags = wxEXEC_ASYNC, wxProcess * callback = NULL, const wxExecuteEnv * env = NULL) -->
+  <!-- long wxExecute (char ** argv            , int flags = wxEXEC_ASYNC, wxProcess * callback = NULL, const wxExecuteEnv * env = NULL) -->
+  <!-- long wxExecute (wchar_t ** argv         , int flags = wxEXEC_ASYNC, wxProcess * callback = NULL, const wxExecuteEnv * env = NULL) -->
+  <!-- long wxExecute (wxString &command       , wxArrayString &output   , int flags = 0              , const wxExecuteEnv * env = NULL) -->
+  <!-- long wxExecute(const wxString & command , wxArrayString & output  , wxArrayString & errors     , int flags = 0, const wxExecuteEnv * env = NULL) -->
+  <function name="wxExecute">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="4" default="0" direction="in"/>
+    <arg nr="5" default="NULL" direction="in"/>
+  </function>
+  <!-- bool wxImageList::Create (int width, int height, bool mask = true, int initialCount = 1) -->
+  <function name="wxImageList::Create">
+    <noreturn>false</noreturn>
+    <returnValue type="bool"/>
     <leak-ignore/>
     <arg nr="1" direction="in">
       <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
+    </arg>
+    <arg nr="3" default="true" direction="in">
+      <not-uninit/>
+    </arg>
+    <arg nr="4" default="1" direction="in">
+      <not-uninit/>
+      <valid>0:</valid>
     </arg>
   </function>
-  <!-- wxImage wxImage::Rotate90(bool clockwise = true) const -->
-  <function name="wxImage::Rotate90">
+  <!-- wxPen* wxPenList::FindOrCreatePen(const wxColour & colour, int width = 1, wxPenStyle style = wxPENSTYLE_SOLID) -->
+  <!-- wxPen* wxThePenList::FindOrCreatePen(const wxColour & colour, int width = 1, wxPenStyle style = wxPENSTYLE_SOLID) -->
+  <function name="wxPenList::FindOrCreatePen,wxThePenList::FindOrCreatePen">
     <noreturn>false</noreturn>
-    <returnValue type="wxImage"/>
-    <const/>
     <use-retval/>
-    <leak-ignore/>
-    <arg nr="1" default="true" direction="in">
+    <returnValue type="wxPen*"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="1" direction="in">
       <not-uninit/>
     </arg>
+    <arg nr="3" default="wxPENSTYLE_SOLID" direction="in"/>
   </function>
-  <!-- wxImage wxImage::Rotate180() const -->
-  <function name="wxImage::Rotate180">
+  <!-- wxBrush* wxBrushList::FindOrCreateBrush(const wxColour & colour, wxBrushStyle style = wxBRUSHSTYLE_SOLID) -->
+  <!-- wxBrush* wxTheBrushList::FindOrCreateBrush(const wxColour & colour, wxBrushStyle style = wxBRUSHSTYLE_SOLID) -->
+  <function name="wxBrushList::FindOrCreateBrush,wxTheBrushList::FindOrCreateBrush">
     <noreturn>false</noreturn>
-    <returnValue type="wxImage"/>
-    <const/>
     <use-retval/>
-    <leak-ignore/>
+    <returnValue type="wxBrush*"/>
+    <arg nr="1" direction="in"/>
+    <arg nr="2" default="wxBRUSHSTYLE_SOLID" direction="in"/>
   </function>
-  <!-- virtual wxImage wxAnimation::GetFrame(unsigned int i) const -->
-  <function name="wxAnimation::GetFrame">
+  <!-- virtual bool wxClipboard::IsSupported(const wxDataFormat & format)-->
+  <function name="wxClipboard::IsSupported,wxTheClipboard::IsSupported">
     <noreturn>false</noreturn>
-    <returnValue type="wxImage"/>
-    <const/>
     <use-retval/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!-- virtual unsigned int wxAnimation::GetFrameCount(unsigned int i) const -->
-  <function name="wxAnimation::GetFrameCount">
+  <!-- virtual bool wxClipboard::GetData(wxDataObject & data)-->
+  <function name="wxClipboard::GetData,wxTheClipboard::GetData">
     <noreturn>false</noreturn>
-    <returnValue type="unsigned int"/>
-    <const/>
-    <use-retval/>
     <leak-ignore/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-  </function>
-  <!-- virtual bool wxAnimation::Load(wxInputStream & stream, wxAnimationType type = wxANIMATION_TYPE_ANY) -->
-  <function name="wxAnimation::Load">
-    <noreturn>false</noreturn>
     <returnValue type="bool"/>
-    <leak-ignore/>
     <arg nr="1" direction="out"/>
-    <arg nr="2" default="wxANIMATION_TYPE_ANY" direction="in">
-      <not-uninit/>
-    </arg>
   </function>
-  <!-- virtual bool wxAnimation::LoadFile(const wxString &name wxAnimationType type = wxANIMATION_TYPE_ANY) -->
-  <function name="xAnimation::LoadFile">
+  <!-- virtual bool wxClipboard::SetData(wxDataObject * data)-->
+  <function name="wxClipboard::SetData,wxTheClipboard::SetData">
     <noreturn>false</noreturn>
     <returnValue type="bool"/>
-    <leak-ignore/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" default="wxANIMATION_TYPE_ANY" direction="in">
+    <arg nr="1" direction="in">
+      <not-null/>
       <not-uninit/>
     </arg>
   </function>
-  <!-- virtual wxSize wxAnimation::GetSize() const -->
-  <function name="wxAnimation::GetSize">
+  <!-- wxColour wxColourDatabase::Find(const wxString & colourName) const -->
+  <function name="wxColourDatabase::Find,wxTheColourDatabase::Find">
     <noreturn>false</noreturn>
-    <returnValue type="wxSize"/>
     <const/>
-    <use-retval/>
     <leak-ignore/>
-  </function>
-  <!-- virtual bool wxAnimation::IsOk() const -->
-  <function name="wxAnimation::IsOk">
-    <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <const/>
+    <returnValue type="wxColour"/>
     <use-retval/>
-    <leak-ignore/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!-- const wxCharBuffer wxString::ToAscii( void ) const -->
-  <!-- const const char * wxString::ToAscii( void ) const -->
-  <function name="wxString::ToAscii">
+  <!-- wxString wxColourDatabase::FindName(const wxColour & colour) const -->
+  <function name="wxColourDatabase::FindName,wxTheColourDatabase::FindName">
     <noreturn>false</noreturn>
     <const/>
-    <use-retval/>
     <leak-ignore/>
+    <returnValue type="wxString"/>
+    <use-retval/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!--        bool wxFileName::IsDir( void ) const -->
-  <!--        bool wxFileName::IsDirReadable( void ) const -->
-  <!-- static bool wxFileName::IsDirReadable( const wxString &path ) const -->
-  <!--        bool wxFileName::IsDirWritable( void ) const -->
-  <!-- static bool wxFileName::IsDirWritable( const wxString &path ) const -->
-  <!--        bool wxFileName::IsFileExecutable( void ) const -->
-  <!-- static bool wxFileName::IsFileExecutable( const wxString &file ) const -->
-  <!--        bool wxFileName::IsFileReadable( void ) const -->
-  <!-- static bool wxFileName::IsFileReadable( const wxString &file ) const -->
-  <!--        bool wxFileName::IsFileWritable( void ) const -->
-  <!-- static bool wxFileName::IsFileWritable( const wxString &file ) const -->
-  <!--      bool wxFileName::IsOk( void ) const -->
-  <function name="wxFileName::IsDirWritable,wxFileName::IsDir,wxFileName::IsDirReadable,wxFileName::IsFileExecutable,wxFileName::IsFileReadable,wxFileName::IsFileWritable,wxFileName::IsOk">
+  <!-- void wxCommandEvent::SetExtraLong( long extraLong ) -->
+  <function name="wxCommandEvent::SetExtraLong">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
-    <use-retval/>
-    <const/>
+    <returnValue type="void"/>
     <leak-ignore/>
-    <arg nr="1" default="wxEmptyString" direction="in"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
   </function>
-  <!-- void wxDC::CopyAttributes(const wxDC & dc) -->
-  <function name="wxDC::CopyAttributes">
+  <!-- void wxEvtHandler::AddPendingEvent( const wxEvent & event ) -->
+  <function name="wxEvtHandler::AddPendingEvent">
     <noreturn>false</noreturn>
     <returnValue type="void"/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
   </function>
-  <!-- bool wxTextFile::Open(const wxString & strFile, const wxMBConv & conv = wxConvAuto()) -->
-  <function name="wxTextFile::Open">
+  <!-- void wxTreeCtrl::SelectItem( const wxTreeItemId & item ) -->
+  <function name="wxTreeCtrl::SelectItem">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
+    <returnValue type="void"/>
     <leak-ignore/>
     <arg nr="1" direction="in"/>
-    <arg nr="2" default="wxConvAuto()" direction="in"/>
   </function>
-  <!-- bool wxTextFile::Write(wxTextFileType typeNew = wxTextFileType_None, const wxMBConv & conv = wxConvAuto()) -->
-  <function name="wxTextFile::Write">
+  <!-- wxTreeItemData * wxTreeCtrl::GetItemData( const wxTreeItemId & item ) const -->
+  <function name="wxTreeCtrl::GetItemData">
     <noreturn>false</noreturn>
-    <returnValue type="bool"/>
+    <returnValue type="wxTreeItemData *"/>
+    <const/>
     <leak-ignore/>
-    <arg nr="1" default="wxTextFileType_None" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" default="wxConvAuto()" direction="in"/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!-- static wxString wxString::From8BitData(const char * buf) -->
-  <!-- static wxString wxString::From8BitData(const char * buf, size_t len) -->
-  <function name="wxString::From8BitData">
+  <!-- wxFont* wxFontList::FindOrCreateFont(int point_size,
+       wxFontFamily family,
+       wxFontStyle style,
+       wxFontWeight weight,
+       bool underline = false,
+       const wxString & facename = wxEmptyString,
+       wxFontEncoding encoding = wxFONTENCODING_DEFAULT
+  )-->
+  <function name="wxFontList::FindOrCreateFont,wxTheFontList::FindOrCreateFont">
     <noreturn>false</noreturn>
-    <returnValue type="wxString"/>
-    <use-retval/>
+    <returnValue type="wxFont*"/>
     <leak-ignore/>
     <arg nr="1" direction="in">
-      <not-null/>
-      <not-uninit/>
-      <strz/>
-      <minsize type="argvalue" arg="2"/>
-    </arg>
-    <arg nr="2" default="0" direction="in">
       <not-uninit/>
-      <valid>0:</valid>
     </arg>
+    <arg nr="2" direction="in"/>
+    <arg nr="3" direction="in"/>
+    <arg nr="4" direction="in"/>
+    <arg nr="5" direction="in" default="false"/>
+    <arg nr="6" direction="in" default="wxEmptyString"/>
+    <arg nr="7" direction="in" default="wxFONTENCODING_DEFAULT"/>
   </function>
-  <!--wxPoint wxWindow::ConvertDialogToPixels(const wxPoint & pt) const -->
-  <!--wxSize wxWindow::ConvertDialogToPixels(const wxSize & sz) const -->
-  <!--wxPoint wxWindow::ConvertPixelsToDialog(const wxPoint & pt) const -->
-  <!--wxSize wxWindow::ConvertPixelsToDialog(const wxSize & sz) const -->
-  <function name="wxWindow::ConvertDialogToPixels,wxWindow::ConvertPixelsToDialog">
+  <!-- void wxCmdLineParser::AddSwitch(const wxString & name,
+            const wxString & lng = wxEmptyString,
+            const wxString & desc = wxEmptyString,
+            int flags = 0
+    )-->
+  <function name="wxCmdLineParser::AddSwitch">
     <noreturn>false</noreturn>
+    <returnValue type="void"/>
     <leak-ignore/>
-    <const/>
-    <use-retval/>
     <arg nr="1" direction="in"/>
-  </function>
-  <!--wxSizerFlags& wxSizerFlags::Border(int direction, int borderinpixels)	-->
-  <function name="wxSizerFlags::Border">
-    <noreturn>false</noreturn>
-    <returnValue type="wxSizerFlags &amp;"/>
-    <leak-ignore/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="2" direction="in">
+    <arg nr="2" direction="in" default="wxEmptyString"/>
+    <arg nr="3" direction="in" default="wxEmptyString"/>
+    <arg nr="4" direction="in" default="0">
       <not-uninit/>
     </arg>
   </function>
-  <!--       wxRect wxGrid::CellToRect(int row, int col) const -->
-  <!-- TODO: wxRect wxGrid::CellToRect(const wxGridCellCoords & coords) const -->
-  <function name="wxGrid::CellToRect">
+  <!-- wxImage wxImage::Scale(
+               int width,
+               int height,
+               wxImageResizeQuality quality = wxIMAGE_QUALITY_NORMAL
+       ) const-->
+  <function name="wxImage::Scale">
     <noreturn>false</noreturn>
-    <returnValue type="wxRect"/>
+    <returnValue type="wxImage"/>
     <use-retval/>
     <leak-ignore/>
     <const/>
     <arg nr="1" direction="in">
       <not-uninit/>
-      <valid>0:</valid>
     </arg>
     <arg nr="2" direction="in">
       <not-uninit/>
-      <valid>0:</valid>
     </arg>
+    <arg nr="3" direction="in" default="wxIMAGE_QUALITY_NORMAL"/>
   </function>
-  <!-- int wxGrid::GetRowLabelSize() const -->
-  <!-- int wxGrid::GetColLabelSize() const -->
-  <!-- int wxGrid::GetRowMinimalAcceptableHeight() const -->
-  <!-- int wxGrid::GetScrollLineX() const -->
-  <!-- int wxGrid::GetScrollLineY() const -->
-  <!-- int wxGrid::GetNumberRows() const -->
-  <!-- int wxGrid::GetNumberFrozenRows() const -->
-  <!-- int wxGrid::GetNumberFrozenCols() const -->
-  <!-- int wxGrid::GetNumberCols() const -->
-  <function name="wxGrid::GetRowLabelSize,wxGrid::GetColLabelSize,wxGrid::GetRowMinimalAcceptableHeight,wxGrid::GetScrollLineX,wxGrid::GetScrollLineY,wxGrid::GetNumberRows,wxGrid::GetNumberFrozenRows,wxGrid::GetNumberFrozenCols,wxGrid::wxGrid::GetNumberCols">
+  <!-- bool wxString::Alloc( size_t nLen ) -->
+  <function name="wxString::Alloc">
     <noreturn>false</noreturn>
-    <returnValue type="int"/>
-    <use-retval/>
-    <leak-ignore/>
-    <const/>
+    <returnValue type="bool"/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+    </arg>
+    <warn severity="style">Please note that this method does the same thing as the standard 'reserve()' one and should not be used in new code.</warn>
   </function>
-  <!-- wxFont wxGrid::GetLabelFont() const -->
-  <function name="wxGrid::GetLabelFont">
+  <!-- virtual void wxFileHistory::AddFileToHistory( const wxString & file ) -->
+  <!--          void wxDocManager::AddFileToHistory( const wxString & file ) -->
+  <function name="wxFileHistory::AddFileToHistory,wxDocManager::AddFileToHistory">
     <noreturn>false</noreturn>
-    <returnValue type="wxFont"/>
-    <use-retval/>
     <leak-ignore/>
-    <const/>
+    <returnValue type="void"/>
+    <arg nr="1" direction="in"/>
   </function>
-  <!-- wxColour wxGrid::GetLabelBackgroundColour() const -->
-  <!-- wxColour wxGrid::GetLabelTextColour() const -->
-  <function name="wxGrid::GetLabelTextColour,wxGrid::GetLabelBackgroundColour">
+  <!-- virtual void wxFileHistory::AddFilesToMenu( wxMenu * menu ) -->
+  <!-- virtual void wxFileHistory::AddFilesToMenu( void ) -->
+  <function name="wxFileHistory::AddFilesToMenu">
     <noreturn>false</noreturn>
-    <returnValue type="wxColour"/>
-    <use-retval/>
     <leak-ignore/>
-    <const/>
+    <returnValue type="void"/>
+    <arg nr="1" default="NULL" direction="in"/>
   </function>
-  <!-- wxGridSizesInfo wxGrid::GetRowSizes() const -->
-  <function name="wxGrid::GetRowSizes">
+  <!-- virtual size_t wxFileHistory::GetCount( void ) const -->
+  <function name="wxFileHistory::GetCount">
     <noreturn>false</noreturn>
-    <returnValue type="wxGridSizesInfo"/>
-    <use-retval/>
     <leak-ignore/>
     <const/>
-  </function>
-  <!-- wxString wxGrid::GetRowLabelValue(int row) const -->
-  <function name="wxGrid::GetRowLabelValue">
-    <noreturn>false</noreturn>
-    <returnValue type="wxString"/>
+    <returnValue type="size_t"/>
     <use-retval/>
-    <leak-ignore/>
-    <const/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-      <valid>0:</valid>
-    </arg>
   </function>
-  <!-- int wxGrid::GetRowMinimalHeight(int col) const -->
-  <function name="wxGrid::GetRowMinimalHeight">
+  <!-- virtual wxString wxFileHistory::GetHistoryFile( size_t i ) -->
+  <function name="wxFileHistory::GetHistoryFile">
     <noreturn>false</noreturn>
-    <returnValue type="int"/>
-    <use-retval/>
     <leak-ignore/>
-    <const/>
-    <arg nr="1" direction="in">
-      <not-uninit/>
-      <valid>0:</valid>
-    </arg>
-  </function>
-  <!-- virtual wxString wxTextCtrl::GetLineText(long lineNo) const -->
-  <function name="wxTextCtrl::GetLineText">
-    <noreturn>false</noreturn>
     <returnValue type="wxString"/>
     <use-retval/>
-    <leak-ignore/>
-    <const/>
     <arg nr="1" direction="in">
       <not-uninit/>
       <valid>0:</valid>
     </arg>
   </function>
-  <!-- virtual int wxTextCtrl::GetNumberOfLines(void) const -->
-  <function name="wxTextCtrl::GetNumberOfLines">
-    <noreturn>false</noreturn>
-    <returnValue type="int"/>
-    <use-retval/>
-    <leak-ignore/>
-    <const/>
-  </function>
-  <!-- wxString wxGetPasswordFromUser (const wxString & message,
-                                       const wxString & caption = wxGetPasswordFromUserPromptStr,
-                                       const wxString & default_value = wxEmptyString,
-                                       wxWindow * parent = NULL,
-                                       int x = wxDefaultCoord,
-                                       int y = wxDefaultCoord,
-                                       bool centre = true) -->
-  <function name="wxGetPasswordFromUser">
+  <!-- virtual bool wxApp::OnInit() -->
+  <!-- virtual bool wxAppConsole::OnInit() -->
+  <function name="wxApp::OnInit,wxAppConsole::OnInit">
     <noreturn>false</noreturn>
-    <returnValue type="wxString"/>
+    <returnValue type="bool"/>
     <use-retval/>
     <leak-ignore/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" default="Enter Password" direction="in"/>
-    <arg nr="3" default="wxEmptyString" direction="in"/>
-    <arg nr="4" default="NULL" direction="inout">
-      <not-uninit/>
-    </arg>
-    <arg nr="5" default="wxDefaultCoord" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="6" default="wxDefaultCoord" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="7" default="true" direction="in">
-      <not-uninit/>
-    </arg>
   </function>
-  <!-- wxString wxGetTextFromUser(const wxString &message, 
-                                   const wxString &caption=wxGetTextFromUserPromptStr, 
-                                   const wxString &default_value=wxEmptyString, 
-                                   wxWindow *parent=NULL, 
-                                   int x=wxDefaultCoord, 
-                                   int y=wxDefaultCoord, 
-                                   bool centre=true)	 -->
-  <function name="wxGetTextFromUser">
-    <noreturn>false</noreturn>
-    <returnValue type="wxString"/>
-    <use-retval/>
-    <leak-ignore/>
-    <arg nr="1" direction="in"/>
-    <arg nr="2" default="Input Text" direction="in"/>
-    <arg nr="3" default="wxEmptyString" direction="in"/>
-    <arg nr="4" default="NULL" direction="inout">
-      <not-uninit/>
-    </arg>
-    <arg nr="5" default="wxDefaultCoord" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="6" default="wxDefaultCoord" direction="in">
-      <not-uninit/>
-    </arg>
-    <arg nr="7" default="true" direction="in">
-      <not-uninit/>
-    </arg>
+  <!-- bool wxDC::IsOk( void ) const -->
+  <function name="wxDC::IsOk">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="bool"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- int wxRect::GetWidth( void ) const -->
+  <!-- int wxRect::GetHeight( void ) const -->
+  <!-- int wxRect::GetX( void ) const -->
+  <!-- int wxRect::GetY( void ) const -->
+  <!-- int wxRect::GetLeft(void ) const -->
+  <!-- int wxRect::GetRight( void ) const -->
+  <!-- int wxRect::GetTop( void ) const -->
+  <!-- int wxRect::GetBottom( void ) const -->
+  <function name="wxRect::GetWidth,wxRect::GetHeight,wxRect::GetX,wxRect::GetY,wxRect::GetLeft,wxRect::GetRight,wxRect::GetTop,wxRect::GetBottom">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="int"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- int wxToolbookEvent::GetId( void ) const -->
+  <!-- int wxEvent::GetId( void ) const -->
+  <!-- int wxGrid::GetId( void ) const -->
+  <!-- int wxGridEvent::GetId( void ) const -->
+  <!-- int wxCommandEvent::GetId( void ) const -->
+  <!-- int wxBookCtrlEvent::GetId( void ) const -->
+  <!-- int wxTreeListEvent::GetId( void ) const -->
+  <!-- int wxDataViewItem::GetID( void ) const -->
+  <!-- int wxPropertyGridEvent::GetId( void ) const -->
+  <!-- int wxSpinEvent::GetId( void ) const -->
+  <!-- int wxMouseEvent::GetId( void ) const -->
+  <!-- int wxFileDirPickerEvent::GetId( void ) const -->
+  <!-- int wxTimerEvent::GetId( void ) const -->
+  <!-- int wxColourPickerEvent::GetId( void ) const -->
+  <!-- int wxScrollEvent::GetId( void ) const -->
+  <!-- int wxStyledTextEvent::GetId( void ) const -->
+  <!-- int wxSashEvent::GetId( void ) const -->
+  <function name="wxEvent::GetId,wxCommandEvent::GetId,wxToolbookEvent::GetId,wxGrid::GetId,wxGridEvent::GetId,wxBookCtrlEvent::GetId,wxTreeListEvent::GetId,wxDataViewItem::GetID,wxPropertyGridEvent::GetId,wxSpinEvent::GetId,wxMouseEvent::GetId,wxFileDirPickerEvent::GetId,wxTimerEvent::GetId,wxColourPickerEvent::GetId,wxScrollEvent::GetId,wxStyledTextEvent::GetId,wxSashEvent::GetId">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="int"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- bool wxFrame::Layout( void ) -->
+  <!-- bool wxWindow::Layout( void ) -->
+  <!-- bool wxWindowBase::Layout( void ) -->
+  <!-- bool wxGrid::Layout( void ) -->
+  <function name="wxWindow::Layout,wxWindowBase::Layout,wxFrame::Layout,wxGrid::Layout">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="bool"/>
+      <use-retval/>
+  </function>  
+  <!-- bool wxPanel::Layout( void ) -->
+  <function name="wxPanel::Layout">
+      <noreturn>false</noreturn>
+      <returnValue type="bool"/>
+  </function>
+  <!-- void wxSizer::Layout( void ) -->
+  <!-- void wxBoxSizer::Layout( void ) -->
+  <!-- void wxGridSizer::Layout( void ) -->
+  <!-- void wxStaticBoxSizer::Layout( void ) -->
+  <function name="wxSizer::Layout,wxBoxSizer::Layout,wxGridSizer::Layout,wxStaticBoxSizer::Layout">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="void"/>
+  </function>
+  <!-- void wxTextEntry::Clear( void ) -->
+  <!-- void wxTextCtrl::Clear( void ) -->
+  <!-- void wxRegion::Clear( void ) -->
+  <function name="wxTextCtrl::Clear,wxTextEntry::Clear,wxRegion::Clear">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="void"/>
+  </function>
+  <!-- static const wxString & wxLog::GetTimestamp( void ) -->
+  <function name="wxLog::GetTimestamp">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="const wxString &amp;"/>
+      <use-retval/>
+      <pure/>
+  </function>
+  <!-- static void wxLog::FlushActive( void ) -->
+  <!-- static void wxLog::DisableTimestamp( void ) -->
+  <function name="wxLog::FlushActive,wxLog::DisableTimestamp">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="void"/>
+      <pure/>
+  </function>
+  <!-- static bool wxLog::GetVerbose( void ) -->
+  <!-- static bool wxLogGui::GetVerbose( void ) -->
+  <!-- static bool wxLog::IsEnabled( void ) -->
+  <!-- static bool wxLogGui::IsEnabled( void ) -->
+  <function name="wxLog::GetVerbose,wxLog::IsEnabled,wxLogGui::IsEnabled,wxLogGui::GetVerbose">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="bool"/>
+      <use-retval/>
+      <pure/>
+  </function>
+  <!-- wxSize wxRect::GetSize( void ) const -->
+  <function name="wxRect::GetSize">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxSize"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- wxPoint wxRect::GetTopLeft( void ) const -->
+  <!-- wxPoint wxRect::GetTopRight( void ) const -->
+  <!-- wxPoint wxRect::GetBottomLeft( void ) const -->
+  <!-- wxPoint wxRect::GetBottomRight( void ) const -->
+  <!-- wxPoint wxRect::GetRightTop( void ) const -->
+  <!-- wxPoint wxRect::GetLeftTop( void ) const -->
+  <!-- wxPoint wxRect::GetPosition( void ) const -->
+  <!-- wxPoint wxStaticText::GetPosition( void ) const -->
+  <function name="wxRect::GetTopRight,wxRect::GetBottomLeft,wxRect::GetBottomRight,wxRect::GetTopLeft,wxRect::GetRightTop,wxRect::GetLeftTop,wxStaticText::GetPosition,wxRect::GetPosition">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxPoint"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- wxTextProofOptions wxTextProofOptions::Default( void ) -->
+  <function name="wxTextProofOptions::Default">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxTextProofOptions"/>
+      <use-retval/>
+      <pure/>
+  </function>
+  <!-- wxTextProofOptions wxTextProofOptions::Disable( void ) -->
+  <function name="wxTextProofOptions::Disable">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxTextProofOptions"/>
+      <use-retval/>
+      <pure/>
+  </function>
+  <!-- bool wxLogGui::EnableLogging( bool enable = true ) -->
+  <!-- bool wxLog::EnableLogging( bool enable = true ) -->
+  <function name="wxLog::EnableLogging,wxLogGui::EnableLogging">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="bool"/>
+      <use-retval/>
+      <pure/>
+      <arg nr="1" default="true" direction="in">
+          <not-uninit/>
+      </arg>
+  </function>
+  <!-- wxRegionContain wxRegion::Contains(const wxPoint & pt) const -->
+  <function name="wxRegion::Contains">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxRegionContain"/>
+      <use-retval/>
+      <const/>
+      <arg nr="1" default="true" direction="in"/>
+  </function>
+  <!-- bool wxLog::IsLevelEnabled( wxLogLevel level, const wxString & component ) -->
+  <!-- bool wxLogGui::IsLevelEnabled( wxLogLevel level, const wxString & component ) -->
+  <function name="wxLog::IsLevelEnabled,wxLogGui::IsLevelEnabled">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="bool"/>
+      <use-retval/>
+      <pure/>
+      <arg nr="1" direction="in">
+      </arg>
+      <arg nr="2" direction="in">
+      </arg>
+  </function>
+  <!-- bool wxVersionInfo::AtLeast( int major, int minor = 0, int micro = 0 ) const -->
+  <function name="wxVersionInfo::AtLeast">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="bool"/>
+      <const/>
+      <arg nr="1" direction="in">
+          <not-uninit/>
+      </arg>
+      <arg nr="2" default="0" direction="in">
+          <not-uninit/>
+      </arg>
+      <arg nr="3" default="0" direction="in">
+          <not-uninit/>
+      </arg>
+  </function>
+  <!-- const wxString & wxVersionInfo::GetCopyright( void ) const -->
+  <function name="wxVersionInfo::GetCopyright">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="const wxString &amp;"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- const wxString & wxVersionInfo::GetDescription( void ) const -->
+  <function name="wxVersionInfo::GetDescription">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="const wxString &amp;"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- int wxVersionInfo::GetMajor( void ) const -->
+  <function name="wxVersionInfo::GetMajor">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="int"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- int wxVersionInfo::GetMicro( void ) const -->
+  <function name="wxVersionInfo::GetMicro">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="int"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- int wxVersionInfo::GetMinor( void ) const -->
+  <function name="wxVersionInfo::GetMinor">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="int"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- const wxString & wxVersionInfo::GetName( void ) const -->
+  <function name="wxVersionInfo::GetName">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="const wxString &amp;"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- int wxVersionInfo::GetRevision( void ) const -->
+  <function name="wxVersionInfo::GetRevision">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="int"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- wxString wxVersionInfo::GetVersionString( void ) const -->
+  <function name="wxVersionInfo::GetVersionString">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxString"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- bool wxVersionInfo::HasCopyright( void ) const -->
+  <function name="wxVersionInfo::HasCopyright">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="bool"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- bool wxVersionInfo::HasDescription( void ) const -->
+  <function name="wxVersionInfo::HasDescription">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="bool"/>
+      <use-retval/>
+      <const/>
+  </function>
+  <!-- wxString wxVersionInfo::ToString( void ) const -->
+  <function name="wxVersionInfo::ToString">
+      <noreturn>false</noreturn>
+      <leak-ignore/>
+      <returnValue type="wxString"/>
+      <use-retval/>
+      <const/>
   </function>
 </def>
diff --git a/cfg/zephyr.cfg b/cfg/zephyr.cfg
new file mode 100644
index 00000000000..999de4ea1b5
--- /dev/null
+++ b/cfg/zephyr.cfg
@@ -0,0 +1,113 @@
+<?xml version="1.0"?>
+<def format="2">
+
+  <function name="device_is_ready">
+    <returnValue type="bool"/>
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <not-bool/>
+    </arg>
+  </function>
+
+  <function name="gpio_init_callback">
+    <returnValue type="void"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <not-bool/>
+    </arg>
+    <arg nr="3" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+
+  <function name="gpio_add_callback">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <not-bool/>
+    </arg>
+  </function>
+
+  <function name="gpio_pin_configure_dt,gpio_pin_interrupt_configure_dt">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <not-bool/>
+    </arg>
+    <arg nr="2" direction="in">
+      <not-uninit/>
+      <not-bool/>
+    </arg>
+  </function>
+
+  <function name="gpio_pin_toggle_dt">
+    <returnValue type="int"/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <not-null/>
+      <not-bool/>
+    </arg>
+  </function>
+
+  <function name="k_msleep">
+    <returnValue type="int32_t"/>
+    <noreturn>false</noreturn>
+    <arg nr="1" direction="in">
+      <not-uninit/>
+      <valid>0:2147483647</valid>
+	</arg>
+  </function>
+
+  <function name="printk">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <formatstr/>
+    <arg nr="1" direction="in">
+      <formatstr/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+  </function>
+
+  <define name="KERN_EMERG" value="&quot;0&quot;"/>
+  <define name="KERN_ALERT" value="&quot;1&quot;"/>
+  <define name="KERN_CRIT" value="&quot;2&quot;"/>
+  <define name="KERN_ERR" value="&quot;3&quot;"/>
+  <define name="KERN_WARNING" value="&quot;4&quot;"/>
+  <define name="KERN_NOTICE" value="&quot;5&quot;"/>
+  <define name="KERN_INFO" value="&quot;6&quot;"/>
+  <define name="KERN_DEBUG" value="&quot;7&quot;"/>
+  <define name="KERN_DEFAULT" value="&quot;&quot;"/>
+  <define name="KERN_CONT" value="&quot;c&quot;"/>
+
+  <define name="ARRAY_SIZE(array)" value="(sizeof(array) / sizeof((array)[0]))"/>
+  <define name="BIT(x)" value="(1UL&lt;&lt;x)"/>
+  <define name="IS_ENABLED(flag)" value="flag"/>
+</def>
diff --git a/clang-tidy.md b/clang-tidy.md
new file mode 100644
index 00000000000..e6180b53d62
--- /dev/null
+++ b/clang-tidy.md
@@ -0,0 +1,221 @@
+# clang-tidy
+
+Below are the reasoning why certain checks are (currently) disabled for out code base
+
+## Externals
+
+We do not perform static analysis of the source of the external libraries. `simplecpp` has its own CI with a clang-tidy workflow.
+
+## Disabled Checks
+
+`abseil-*`<br/>
+`altera-*`<br/>
+`android-*`<br/>
+`boost-*`<br/>
+`darwin-*`<br/>
+`fuchsia-*`<br/>
+`linuxkernel-*`<br/>
+`llvm-*`<br/>
+`llvmlibc-*`<br/>
+`mpi-*`<br/>
+`objc-*`<br/>
+`openmp-*`<br/>
+`zircon-*`<br/>
+
+These are disabled since the platforms/libraries in question are not targeted by us.
+
+`cert-*`<br/>
+`cppcoreguidelines-*`<br/>
+`google-*`<br/>
+`hicpp-*`<br/>
+
+These are coding guidelines we do not follow. Some of the checks might be explicitly enabled though.
+
+`readability-braces-around-statements`<br/>
+`readability-isolate-declaration`<br/>
+`readability-uppercase-literal-suffix`<br/>
+`readability-identifier-length`<br/>
+
+These do not reflect the style we are (currently) enforcing.
+
+`readability-function-size`<br/>
+`readability-function-cognitive-complexity`<br/>
+
+We are not interested in the size/complexity of a function.
+
+`readability-magic-numbers`<br/>
+
+These do not (always) increase readability.
+
+`bugprone-macro-parentheses`<br/>
+
+To be documented.
+
+`readability-implicit-bool-conversion`<br/>
+
+This does not appear to be useful as it is reported on very common code.
+
+`bugprone-narrowing-conversions`<br/>
+`performance-no-automatic-move`<br/>
+
+It was decided not to apply these.
+
+`modernize-loop-convert`<br/>
+
+These might change the behavior of code which might not be intended (need to file an upstream issue)
+
+`modernize-raw-string-literal`<br/>
+
+This leads to a mismatch of raw string literals and regular ones and does reduce the readability.
+
+`-clang-analyzer-*`<br/>
+
+Disabled because of false positives (need to file upstream bug reports). The checks are also quite time consuming.
+
+`misc-non-private-member-variables-in-classes`<br/>
+
+We intentionally use this.
+
+`misc-no-recursion`<br/>
+
+Leads to lots of "false positives". This seem to enforce a coding guidelines of certain codebases.
+
+`bugprone-easily-swappable-parameters`<br/>
+
+This produces a lot of noise and they are not fixable that easily.
+
+`readability-container-data-pointer`<br/>
+
+Disable because of false positives and inconsistent warnings (need to file an upstream bug report).
+
+`misc-const-correctness`<br/>
+
+Work in progress.
+
+`bugprone-assignment-in-if-condition`<br/>
+
+Is reported for valid patterns we are using.
+
+`readability-suspicious-call-argument`<br/>
+
+Produces a lot of false positives since it is too vague in its analysis.
+
+`performance-inefficient-string-concatenation`<br/>
+
+Produces warnings which might be considered false positives starting with C++11 - see https://github.com/llvm/llvm-project/issues/54526.
+
+`modernize-avoid-c-arrays`<br/>
+
+Produces warnings when `const char[]` is being used which is quite common in our code. Does not make sense to enable before C++17 when `std::string_view` becomes available.
+Also reports a false positive about templates which deduce the array length: https://github.com/llvm/llvm-project/issues/60053.
+
+`misc-include-cleaner`<br/>
+
+We run this separately via `clang-include-cleaner` in the `iwyu.yml` workflow as the findings of the include checkers still need to be reviewed manually before applying them.
+
+`readability-use-concise-preprocessor-directives`<br/>
+
+Does not improve the readability.
+
+`bugprone-branch-clone`<br/>
+`modernize-return-braced-init-list`<br/>
+`misc-throw-by-value-catch-by-reference`<br/>
+`bugprone-signed-char-misuse`<br/>
+`concurrency-mt-unsafe`<br/>
+`misc-use-anonymous-namespace`<br/>
+`performance-avoid-endl`<br/>
+`bugprone-switch-missing-default-case`<br/>
+`bugprone-empty-catch`<br/>
+`readability-avoid-nested-conditional-operator`<br/>
+`modernize-use-designated-initializers`<br/>
+`readability-enum-initial-value`<br/>
+`modernize-use-trailing-return-type`<br/>
+`misc-unconventional-assign-operator`<br/>
+`bugprone-throwing-static-initialization`<br/>
+`bugprone-command-processor`<br/>
+`misc-multiple-inheritance`<br/>
+
+To be evaluated (need to remove exclusion).
+
+`cppcoreguidelines-missing-std-forward`<br/>
+`cppcoreguidelines-avoid-const-or-ref-data-members`<br/>
+`cppcoreguidelines-macro-usage`<br/>
+`cppcoreguidelines-pro-type-member-init`<br/>
+`cppcoreguidelines-prefer-member-initializer`<br/>
+`cppcoreguidelines-misleading-capture-default-by-value`<br/>
+`bugprone-argument-comment.CommentBoolLiterals`<br/>
+`cert-err33-c`<br/>
+`google-readability-namespace-comments`<br/>
+`cppcoreguidelines-special-member-functions`<br/>
+
+To be evaluated (need to enable explicitly).
+
+`modernize-type-traits`<br/>
+`modernize-use-nodiscard`<br/>
+`modernize-use-scoped-lock`<br/>
+
+These apply to codebases which use later standards then C++11 (C++17 is used when building with Qt6) so we cannot simply apply them.
+
+`portability-avoid-pragma-once`<br/>
+
+We are not interested in this.
+
+`readability-redundant-parentheses`<br/>
+
+Reports false positives - see https://github.com/llvm/llvm-project/issues/164125.
+
+`readability-inconsistent-ifelse-braces`<br/>
+
+The suggestions are too intrusive.
+
+`modernize-avoid-c-style-cast`<br/>
+
+Currently flags functional casts - see https://github.com/llvm/llvm-project/issues/186784.
+
+`misc-use-internal-linkage.AnalyzeTypes`<br/>
+
+Adding anonymous namespaces requires identation which is too instrusive right now. Would require changes to our fomatting configuration.
+
+### Disabled for performance reasons
+
+`portability-std-allocator-const`<br/>
+
+Only necessary for code which is exclusively compiled with `libc++`. Also disabled for performance reasons - see https://github.com/llvm/llvm-project/issues/57527#issuecomment-1237935132.
+
+`modernize-deprecated-ios-base-aliases`<br/>
+
+Warns about aliases which are removed in C++20. Also disabled for performance reasons - see https://github.com/llvm/llvm-project/issues/57527#issuecomment-1237935132.
+
+`bugprone-unchecked-optional-access`<br/>
+
+We are not using any `optional` implementation. Also disabled for performance reasons - see https://github.com/llvm/llvm-project/issues/57527#issuecomment-1237935132.
+
+`modernize-replace-auto-ptr`<br/>
+
+Still available until C++17. It is unlikely such code will ever be introduced. Also disabled for performance reasons - see https://github.com/llvm/llvm-project/issues/57527#issuecomment-1237935132.
+
+`readability-identifier-naming`<br/>
+
+We are currently using our own `naming.json` to enforce naming schemes. Also disabled for performance reasons - see https://github.com/llvm/llvm-project/issues/57527#issuecomment-1237935132.
+
+`portability-simd-intrinsics`<br/>
+
+We are not using SIMD instructions and it suggests to use `std::experiemental::` features which might not be commonly available. Also disabled for performance reasons - see https://github.com/llvm/llvm-project/issues/57527#issuecomment-1237935132.
+
+`modernize-macro-to-enum`<br/>
+
+It does not seem to produce any warnings for us (needs to be investigated) and it is one of the more expensive checks.
+
+`misc-unused-using-decls`<br/>
+
+This is the most expensive check for several files and it is providing much in terms of code quality. Reported upstream as https://github.com/llvm/llvm-project/issues/72300.
+
+### Disabled for GUI only
+
+`readability-convert-member-functions-to-static`<br/>
+
+Disabled because of false positives with Qt `slot` methods (see https://github.com/llvm/llvm-project/issues/57520).
+
+`readability-redundant-access-specifiers`<br/>
+
+Reports warning with the Qt `<access-specifier> slots:` syntax in class declarations - see https://github.com/llvm/llvm-project/issues/60055.
diff --git a/cli/CMakeLists.txt b/cli/CMakeLists.txt
index 16991d0e927..f63f3291849 100644
--- a/cli/CMakeLists.txt
+++ b/cli/CMakeLists.txt
@@ -1,37 +1,66 @@
-include_directories(${PROJECT_SOURCE_DIR}/lib/)
-include_directories(SYSTEM ${PROJECT_SOURCE_DIR}/externals/tinyxml/)
-include_directories(${PROJECT_SOURCE_DIR}/externals/simplecpp/)
-
 file(GLOB hdrs "*.h")
 file(GLOB srcs "*.cpp")
 file(GLOB mainfile "main.cpp")
 list(REMOVE_ITEM srcs ${mainfile})
 
-add_library(cli_objs OBJECT ${hdrs} ${srcs}) 
-add_executable(cppcheck ${hdrs} ${mainfile} $<TARGET_OBJECTS:cli_objs> $<TARGET_OBJECTS:lib_objs> $<TARGET_OBJECTS:tinyxml_objs> $<TARGET_OBJECTS:simplecpp_objs>)
-if (HAVE_RULES)
-    find_library(PCRE_LIBRARY pcre)
-    target_link_libraries(cppcheck ${PCRE_LIBRARY})
-    find_path(PCRE_INCLUDE pcre.h)
-    target_include_directories(cppcheck PUBLIC ${PCRE_INCLUDE})
+add_library(cli ${hdrs} ${srcs})
+target_include_directories(cli PUBLIC .)
+target_link_libraries(cli PRIVATE cppcheck-core frontend tinyxml2 simplecpp picojson)
+if (NOT CMAKE_DISABLE_PRECOMPILE_HEADERS)
+    target_precompile_headers(cli PRIVATE precompiled.h)
 endif()
-if (WIN32 AND NOT BORLAND)
-    target_link_libraries(cppcheck Shlwapi.lib)
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 13)
+    # false positive warning in Clang 13 - caused by FD_ZERO macro
+    set_source_files_properties(processexecutor.cpp PROPERTIES COMPILE_FLAGS -Wno-reserved-identifier)
 endif()
 
-install(TARGETS cppcheck
-    RUNTIME DESTINATION ${CMAKE_INSTALL_FULL_BINDIR}
-    COMPONENT applications)
+if (BUILD_CLI)
+    list(APPEND cppcheck_SOURCES ${hdrs} ${mainfile})
+    if (WIN32)
+        list(APPEND cppcheck_SOURCES version.rc)
+    endif()
+
+    add_executable(cppcheck ${cppcheck_SOURCES})
+    target_link_libraries(cppcheck cppcheck-core cli tinyxml2 simplecpp)
+    if (WIN32 AND NOT BORLAND)
+        if(NOT MINGW)
+            target_link_libraries(cppcheck Shlwapi.lib)
+        else()
+            target_link_libraries(cppcheck shlwapi)
+        endif()
+    endif()
+    target_link_libraries(cppcheck ${CMAKE_THREAD_LIBS_INIT})
+
+    add_dependencies(cppcheck copy_cfg)
+    add_dependencies(cppcheck copy_addons)
+    add_dependencies(cppcheck copy_platforms)
+    if (NOT DISABLE_DMAKE)
+        add_dependencies(cppcheck run-dmake)
+    endif()
 
-install(FILES ${addons}
-   DESTINATION ${FILESDIR}/addons
-   COMPONENT headers)
+    install(TARGETS cppcheck
+        RUNTIME DESTINATION ${CMAKE_INSTALL_FULL_BINDIR}
+        COMPONENT applications)
 
-install(FILES ${cfgs}
-   DESTINATION ${FILESDIR}/cfg
-   COMPONENT headers)
+    install(PROGRAMS ${CMAKE_SOURCE_DIR}/htmlreport/cppcheck-htmlreport
+        DESTINATION ${CMAKE_INSTALL_FULL_BINDIR}
+        COMPONENT applications)
 
-install(FILES ${platforms}
-   DESTINATION ${FILESDIR}/platforms
-   COMPONENT headers)
+    install(FILES ${addons_py}
+       DESTINATION ${FILESDIR_DEF}/addons
+       COMPONENT headers)
 
+    install(FILES ${addons_json}
+       DESTINATION ${FILESDIR_DEF}/addons
+       COMPONENT headers)
+
+    install(FILES ${cfgs}
+       DESTINATION ${FILESDIR_DEF}/cfg
+       COMPONENT headers)
+
+    install(FILES ${platforms}
+       DESTINATION ${FILESDIR_DEF}/platforms
+       COMPONENT headers)
+
+endif()
diff --git a/cli/cli.vcxproj b/cli/cli.vcxproj
index e3522421577..05d1cf2916d 100644
--- a/cli/cli.vcxproj
+++ b/cli/cli.vcxproj
@@ -1,429 +1,262 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug-PCRE|Win32">
-      <Configuration>Debug-PCRE</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug-PCRE|x64">
-      <Configuration>Debug-PCRE</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release-PCRE|Win32">
-      <Configuration>Release-PCRE</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release-PCRE|x64">
-      <Configuration>Release-PCRE</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{35CBDF51-2456-3EC3-99ED-113C30858883}</ProjectGuid>
-    <RootNamespace>cli</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings" />
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">..\bin\debug\</OutDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|Win32'">..\bin\debug\</OutDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">..\bin\debug\</OutDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">..\bin\debug\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">temp\$(Configuration)_$(PlatformName)\</IntDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|Win32'">temp\$(Configuration)_$(PlatformName)\</IntDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">cppcheck</TargetName>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|Win32'">cppcheck</TargetName>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">cppcheck</TargetName>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">cppcheck</TargetName>
-    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</IgnoreImportLibrary>
-    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|Win32'">true</IgnoreImportLibrary>
-    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</IgnoreImportLibrary>
-    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">true</IgnoreImportLibrary>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">..\bin\</OutDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|Win32'">..\bin\</OutDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">..\bin\</OutDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">..\bin\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">temp\$(Configuration)_$(PlatformName)\</IntDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|Win32'">temp\$(Configuration)_$(PlatformName)\</IntDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">cppcheck</TargetName>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|Win32'">cppcheck</TargetName>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Release|x64'">cppcheck</TargetName>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">cppcheck</TargetName>
-    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</IgnoreImportLibrary>
-    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|Win32'">true</IgnoreImportLibrary>
-    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</IgnoreImportLibrary>
-    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">true</IgnoreImportLibrary>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|Win32'">true</LinkIncremental>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</LinkIncremental>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">true</LinkIncremental>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>..\lib;..\externals\..\externals\simplecpp;..\externals\tinyxml;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <BrowseInformation>false</BrowseInformation>
-      <BufferSecurityCheck>true</BufferSecurityCheck>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>CPPCHECKLIB_IMPORT;WIN32;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <WarningLevel>Level4</WarningLevel>
-      <DisableSpecificWarnings>4251;4482;4512</DisableSpecificWarnings>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
-      <LanguageStandard>stdcpplatest</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <SubSystem>Console</SubSystem>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <ProgramDatabaseFile>$(TargetDir)cli.pdb</ProgramDatabaseFile>
-      <LargeAddressAware>true</LargeAddressAware>
-      <StackReserveSize>8000000</StackReserveSize>
-      <StackCommitSize>8000000</StackCommitSize>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|Win32'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>..\lib;..\externals\..\externals\simplecpp;..\externals\tinyxml;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <BrowseInformation>false</BrowseInformation>
-      <BufferSecurityCheck>true</BufferSecurityCheck>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>CPPCHECKLIB_IMPORT;TINYXML2_IMPORT;WIN32;HAVE_RULES;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;TIXML_USE_STL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <WarningLevel>Level4</WarningLevel>
-      <DisableSpecificWarnings>4251;4482;4512</DisableSpecificWarnings>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
-      <LanguageStandard>stdcpplatest</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <SubSystem>Console</SubSystem>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <LargeAddressAware>true</LargeAddressAware>
-      <StackReserveSize>8000000</StackReserveSize>
-      <StackCommitSize>8000000</StackCommitSize>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>..\lib;..\externals\..\externals\simplecpp;..\externals\tinyxml;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <BufferSecurityCheck>true</BufferSecurityCheck>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>CPPCHECKLIB_IMPORT;WIN32;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;_WIN64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <WarningLevel>Level4</WarningLevel>
-      <DisableSpecificWarnings>4251;4482;4512</DisableSpecificWarnings>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
-      <LanguageStandard>stdcpplatest</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <SubSystem>Console</SubSystem>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <StackReserveSize>8000000</StackReserveSize>
-      <StackCommitSize>8000000</StackCommitSize>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>..\lib;..\externals\..\externals\simplecpp;..\externals\tinyxml;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <BufferSecurityCheck>true</BufferSecurityCheck>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>CPPCHECKLIB_IMPORT;TINYXML2_IMPORT;WIN32;HAVE_RULES;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;_WIN64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <WarningLevel>Level4</WarningLevel>
-      <DisableSpecificWarnings>4251;4482;4512</DisableSpecificWarnings>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
-      <LanguageStandard>stdcpplatest</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <SubSystem>Console</SubSystem>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <StackReserveSize>8000000</StackReserveSize>
-      <StackCommitSize>8000000</StackCommitSize>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>..\lib;..\externals\..\externals\simplecpp;..\externals\tinyxml;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <BufferSecurityCheck>false</BufferSecurityCheck>
-      <Optimization>MaxSpeed</Optimization>
-      <PreprocessorDefinitions>CPPCHECKLIB_IMPORT;NDEBUG;WIN32;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <WarningLevel>Level4</WarningLevel>
-      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
-      <OmitFramePointers>true</OmitFramePointers>
-      <StringPooling>true</StringPooling>
-      <DisableSpecificWarnings>4251;4482;4512</DisableSpecificWarnings>
-      <DebugInformationFormat>
-      </DebugInformationFormat>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <AdditionalOptions>/Zc:inline /Zc:throwingNew %(AdditionalOptions)</AdditionalOptions>
-      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
-      <LanguageStandard>stdcpplatest</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <SubSystem>Console</SubSystem>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <OptimizeReferences>true</OptimizeReferences>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <SetChecksum>true</SetChecksum>
-      <LargeAddressAware>true</LargeAddressAware>
-      <StackReserveSize>8000000</StackReserveSize>
-      <StackCommitSize>8000000</StackCommitSize>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|Win32'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>..\lib;..\externals\..\externals\simplecpp;..\externals\tinyxml;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <BufferSecurityCheck>false</BufferSecurityCheck>
-      <Optimization>MaxSpeed</Optimization>
-      <PreprocessorDefinitions>CPPCHECKLIB_IMPORT;TINYXML2_IMPORT;NDEBUG;WIN32;HAVE_RULES;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;TIXML_USE_STL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <WarningLevel>Level4</WarningLevel>
-      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
-      <OmitFramePointers>true</OmitFramePointers>
-      <StringPooling>true</StringPooling>
-      <DisableSpecificWarnings>4251;4482;4512</DisableSpecificWarnings>
-      <DebugInformationFormat>
-      </DebugInformationFormat>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <AdditionalOptions>/Zc:inline /Zc:throwingNew %(AdditionalOptions)</AdditionalOptions>
-      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
-      <LanguageStandard>stdcpplatest</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <SubSystem>Console</SubSystem>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <OptimizeReferences>true</OptimizeReferences>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <SetChecksum>true</SetChecksum>
-      <LargeAddressAware>true</LargeAddressAware>
-      <StackReserveSize>8000000</StackReserveSize>
-      <StackCommitSize>8000000</StackCommitSize>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>..\lib;..\externals\..\externals\simplecpp;..\externals\tinyxml;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <BufferSecurityCheck>false</BufferSecurityCheck>
-      <Optimization>MaxSpeed</Optimization>
-      <PreprocessorDefinitions>CPPCHECKLIB_IMPORT;NDEBUG;WIN32;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;_WIN64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <WarningLevel>Level4</WarningLevel>
-      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
-      <OmitFramePointers>true</OmitFramePointers>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <StringPooling>true</StringPooling>
-      <DisableSpecificWarnings>4251;4482;4512</DisableSpecificWarnings>
-      <DebugInformationFormat>
-      </DebugInformationFormat>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <AdditionalOptions>/Zc:inline /Zc:throwingNew %(AdditionalOptions)</AdditionalOptions>
-      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
-      <LanguageStandard>stdcpplatest</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <SubSystem>Console</SubSystem>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <OptimizeReferences>true</OptimizeReferences>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <SetChecksum>true</SetChecksum>
-      <StackReserveSize>8000000</StackReserveSize>
-      <StackCommitSize>8000000</StackCommitSize>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>..\lib;..\externals\..\externals\simplecpp;..\externals\tinyxml;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <BufferSecurityCheck>false</BufferSecurityCheck>
-      <Optimization>MaxSpeed</Optimization>
-      <PreprocessorDefinitions>CPPCHECKLIB_IMPORT;TINYXML2_IMPORT;NDEBUG;WIN32;HAVE_RULES;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;_WIN64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <WarningLevel>Level4</WarningLevel>
-      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
-      <OmitFramePointers>true</OmitFramePointers>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <StringPooling>true</StringPooling>
-      <DisableSpecificWarnings>4251;4482;4512</DisableSpecificWarnings>
-      <DebugInformationFormat>
-      </DebugInformationFormat>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <AdditionalOptions>/Zc:inline /Zc:throwingNew %(AdditionalOptions)</AdditionalOptions>
-      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
-      <LanguageStandard>stdcpplatest</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <SubSystem>Console</SubSystem>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <OptimizeReferences>true</OptimizeReferences>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <SetChecksum>true</SetChecksum>
-      <StackReserveSize>8000000</StackReserveSize>
-      <StackCommitSize>8000000</StackCommitSize>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ResourceCompile Include="version.rc" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="..\lib\config.h" />
-    <ClInclude Include="cmdlineparser.h" />
-    <ClInclude Include="cppcheckexecutor.h" />
-    <ClInclude Include="filelister.h" />
-    <ClInclude Include="threadexecutor.h" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\lib\cppcheck.vcxproj">
-      <Project>{c183db5b-ad6c-423d-80ca-1f9549555a1a}</Project>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="cmdlineparser.cpp" />
-    <ClCompile Include="cppcheckexecutor.cpp" />
-    <ClCompile Include="filelister.cpp" />
-    <ClCompile Include="main.cpp" />
-    <ClCompile Include="threadexecutor.cpp" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets" />
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug-PCRE|x64">
+      <Configuration>Debug-PCRE</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release-PCRE|x64">
+      <Configuration>Release-PCRE</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{35CBDF51-2456-3EC3-99ED-113C30858883}</ProjectGuid>
+    <RootNamespace>cli</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings" />
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(SolutionDir)bin\debug\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">$(SolutionDir)bin\debug\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
+    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">cppcheck</TargetName>
+    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">cppcheck</TargetName>
+    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</IgnoreImportLibrary>
+    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">true</IgnoreImportLibrary>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(SolutionDir)bin\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">$(SolutionDir)bin\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
+    <TargetName Condition="'$(Configuration)|$(Platform)'=='Release|x64'">cppcheck</TargetName>
+    <TargetName Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">cppcheck</TargetName>
+    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</IgnoreImportLibrary>
+    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">true</IgnoreImportLibrary>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</LinkIncremental>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">true</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>..\lib;..\frontend;..\externals;..\externals\picojson;..\externals\simplecpp;..\externals\tinyxml2;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <BufferSecurityCheck>true</BufferSecurityCheck>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>CPPCHECKLIB_IMPORT;TINYXML2_IMPORT;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <WarningLevel>Level4</WarningLevel>
+      <DisableSpecificWarnings>4018;4127;4146;4244;4251;4267;4389;4701;4706;4800;4805</DisableSpecificWarnings>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>precompiled.h</PrecompiledHeaderFile>
+      <ForcedIncludeFiles>precompiled.h</ForcedIncludeFiles>
+      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
+      <LanguageStandard>stdcpp14</LanguageStandard>
+      <AdditionalOptions>/Zc:throwingNew /Zc:__cplusplus %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <StackReserveSize>8000000</StackReserveSize>
+      <StackCommitSize>8000000</StackCommitSize>
+      <LargeAddressAware>true</LargeAddressAware>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>..\lib;..\frontend;..\externals;..\externals\picojson;..\externals\simplecpp;..\externals\tinyxml2;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <BufferSecurityCheck>true</BufferSecurityCheck>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>CPPCHECKLIB_IMPORT;TINYXML2_IMPORT;HAVE_RULES;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <WarningLevel>Level4</WarningLevel>
+      <DisableSpecificWarnings>4018;4127;4146;4244;4251;4267;4389;4701;4706;4800;4805</DisableSpecificWarnings>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>precompiled.h</PrecompiledHeaderFile>
+      <ForcedIncludeFiles>precompiled.h</ForcedIncludeFiles>
+      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
+      <LanguageStandard>stdcpp14</LanguageStandard>
+      <AdditionalOptions>/Zc:throwingNew /Zc:__cplusplus %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <StackReserveSize>8000000</StackReserveSize>
+      <StackCommitSize>8000000</StackCommitSize>
+      <LargeAddressAware>true</LargeAddressAware>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>..\lib;..\frontend;..\externals;..\externals\picojson;..\externals\simplecpp;..\externals\tinyxml2;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <Optimization>MaxSpeed</Optimization>
+      <PreprocessorDefinitions>CPPCHECKLIB_IMPORT;TINYXML2_IMPORT;NDEBUG;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <WarningLevel>Level4</WarningLevel>
+      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <StringPooling>true</StringPooling>
+      <DisableSpecificWarnings>4018;4127;4146;4244;4251;4267;4389;4701;4706;4800;4805</DisableSpecificWarnings>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>precompiled.h</PrecompiledHeaderFile>
+      <ForcedIncludeFiles>precompiled.h</ForcedIncludeFiles>
+      <AdditionalOptions>/Zc:throwingNew /Zc:__cplusplus %(AdditionalOptions)</AdditionalOptions>
+      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
+      <LanguageStandard>stdcpp14</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <SetChecksum>true</SetChecksum>
+      <StackReserveSize>8000000</StackReserveSize>
+      <StackCommitSize>8000000</StackCommitSize>
+      <LargeAddressAware>true</LargeAddressAware>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>..\lib;..\frontend;..\externals;..\externals\picojson;..\externals\simplecpp;..\externals\tinyxml2;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <Optimization>MaxSpeed</Optimization>
+      <PreprocessorDefinitions>CPPCHECKLIB_IMPORT;TINYXML2_IMPORT;NDEBUG;HAVE_RULES;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <WarningLevel>Level4</WarningLevel>
+      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <StringPooling>true</StringPooling>
+      <DisableSpecificWarnings>4018;4127;4146;4244;4251;4267;4389;4701;4706;4800;4805</DisableSpecificWarnings>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>precompiled.h</PrecompiledHeaderFile>
+      <ForcedIncludeFiles>precompiled.h</ForcedIncludeFiles>
+      <AdditionalOptions>/Zc:throwingNew /Zc:__cplusplus %(AdditionalOptions)</AdditionalOptions>
+      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
+      <LanguageStandard>stdcpp14</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <SetChecksum>true</SetChecksum>
+      <StackReserveSize>8000000</StackReserveSize>
+      <StackCommitSize>8000000</StackCommitSize>
+      <LargeAddressAware>true</LargeAddressAware>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ResourceCompile Include="version.rc" />
+  </ItemGroup>
+  <ItemGroup Label="HeaderFiles">
+    <ClInclude Include="cmdlineparser.h" />
+    <ClInclude Include="cppcheckexecutor.h" />
+    <ClInclude Include="executor.h" />
+    <ClInclude Include="filelister.h" />
+    <ClInclude Include="processexecutor.h" />
+    <ClInclude Include="sehwrapper.h" />
+    <ClInclude Include="signalhandler.h" />
+    <ClInclude Include="singleexecutor.h" />
+    <ClInclude Include="stacktrace.h" />
+    <ClInclude Include="threadexecutor.h" />
+    <ClInclude Include="..\frontend\frontend.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\lib\cppcheck.vcxproj">
+      <Project>{c183db5b-ad6c-423d-80ca-1f9549555a1a}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup Label="SourceFiles">
+    <ClCompile Include="cmdlineparser.cpp" />
+    <ClCompile Include="cppcheckexecutor.cpp" />
+    <ClCompile Include="executor.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="filelister.cpp" />
+    <ClCompile Include="main.cpp" />
+    <ClCompile Include="processexecutor.cpp" />
+    <ClCompile Include="sehwrapper.cpp" />
+    <ClCompile Include="signalhandler.cpp" />
+    <ClCompile Include="singleexecutor.cpp" />
+    <ClCompile Include="stacktrace.cpp" />
+    <ClCompile Include="threadexecutor.cpp" />
+    <ClCompile Include="..\frontend\frontend.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets" />
 </Project>
\ No newline at end of file
diff --git a/cli/cli.vcxproj.filters b/cli/cli.vcxproj.filters
index f95e472bbdc..5d3bd1c86cc 100644
--- a/cli/cli.vcxproj.filters
+++ b/cli/cli.vcxproj.filters
@@ -1,55 +1,94 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
-    </Filter>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Resource Files">
-      <UniqueIdentifier>{6d3be647-edb6-43e6-a7eb-3031a2c7b655}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="..\lib\config.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="cmdlineparser.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="threadexecutor.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="cppcheckexecutor.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="filelister.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="main.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="threadexecutor.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="cppcheckexecutor.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="filelister.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="cmdlineparser.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-  </ItemGroup>
-  <ItemGroup>
-    <ResourceCompile Include="version.rc">
-      <Filter>Resource Files</Filter>
-    </ResourceCompile>
-  </ItemGroup>
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{6d3be647-edb6-43e6-a7eb-3031a2c7b655}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup Label="HeaderFiles">
+    <ClInclude Include="cmdlineparser.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="threadexecutor.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="cppcheckexecutor.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="signalhandler.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="executor.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="filelister.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="processexecutor.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="stacktrace.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="singleexecutor.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="sehwrapper.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\frontend\frontend.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup Label="SourceFiles">
+    <ClCompile Include="main.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="threadexecutor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="cppcheckexecutor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="signalhandler.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="executor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="filelister.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="cmdlineparser.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="processexecutor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="stacktrace.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="singleexecutor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="sehwrapper.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\frontend\frontend.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="version.rc">
+      <Filter>Resource Files</Filter>
+    </ResourceCompile>
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/cli/cmdlinelogger.h b/cli/cmdlinelogger.h
new file mode 100644
index 00000000000..75981c028cd
--- /dev/null
+++ b/cli/cmdlinelogger.h
@@ -0,0 +1,37 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMD_LINE_LOGGER_H
+#define CMD_LINE_LOGGER_H
+
+#include <string>
+
+class CmdLineLogger
+{
+public:
+    virtual ~CmdLineLogger() = default;
+
+    /** print a regular message */
+    virtual void printMessage(const std::string &message) = 0;
+    /** print an error message */
+    virtual void printError(const std::string &message) = 0;
+    /** print to the output */
+    virtual void printRaw(const std::string &message) = 0;
+};
+
+#endif // CMD_LINE_LOGGER_H
diff --git a/cli/cmdlineparser.cpp b/cli/cmdlineparser.cpp
index c7cb826f44d..11f735e1ae5 100644
--- a/cli/cmdlineparser.cpp
+++ b/cli/cmdlineparser.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,68 +18,91 @@
 
 #include "cmdlineparser.h"
 
+#include "addoninfo.h"
 #include "check.h"
-#include "cppcheckexecutor.h"
+#include "checkers.h"
+#include "color.h"
+#include "config.h"
+#include "cppcheck.h"
+#include "errorlogger.h"
+#include "errortypes.h"
 #include "filelister.h"
+#include "filesettings.h"
 #include "importproject.h"
+#include "library.h"
 #include "path.h"
+#include "pathmatch.h"
 #include "platform.h"
 #include "settings.h"
 #include "standards.h"
 #include "suppressions.h"
-#include "threadexecutor.h" // Threading model
 #include "timer.h"
 #include "utils.h"
 
+#include "frontend.h"
+
 #include <algorithm>
+#include <cassert>
 #include <cstdio>
 #include <cstdlib> // EXIT_FAILURE
 #include <cstring>
+#include <fstream>
 #include <iostream>
+#include <iterator>
 #include <list>
+#include <memory>
 #include <set>
+#include <sstream>
+#include <unordered_set>
+#include <utility>
 
 #ifdef HAVE_RULES
+#include "regex.h"
+
 // xml is used for rules
-#include <tinyxml2.h>
+#include "xml.h"
 #endif
 
-static void addFilesToList(const std::string& FileList, std::vector<std::string>& PathNames)
+static bool addFilesToList(const std::string& fileList, std::vector<std::string>& pathNames)
 {
-    // To keep things initially simple, if the file can't be opened, just be silent and move on.
-    std::istream *Files;
-    std::ifstream Infile;
-    if (FileList == "-") { // read from stdin
-        Files = &std::cin;
+    std::istream *files;
+    std::ifstream infile;
+    if (fileList == "-") { // read from stdin
+        files = &std::cin;
     } else {
-        Infile.open(FileList);
-        Files = &Infile;
+        infile.open(fileList);
+        if (!infile.is_open())
+            return false;
+        files = &infile;
     }
-    if (Files && *Files) {
-        std::string FileName;
-        while (std::getline(*Files, FileName)) { // next line
-            if (!FileName.empty()) {
-                PathNames.push_back(FileName);
-            }
+    std::string fileName;
+    // cppcheck-suppress accessMoved - FP
+    while (std::getline(*files, fileName)) { // next line
+        // cppcheck-suppress accessMoved - FP
+        if (!fileName.empty()) {
+            pathNames.emplace_back(std::move(fileName));
         }
     }
+
+    return true;
 }
 
-static bool addIncludePathsToList(const std::string& FileList, std::list<std::string>* PathNames)
+static bool addIncludePathsToList(const std::string& fileList, std::list<std::string>& pathNames)
 {
-    std::ifstream Files(FileList);
-    if (Files) {
-        std::string PathName;
-        while (std::getline(Files, PathName)) { // next line
-            if (!PathName.empty()) {
-                PathName = Path::removeQuotationMarks(PathName);
-                PathName = Path::fromNativeSeparators(PathName);
+    std::ifstream files(fileList);
+    if (files) {
+        std::string pathName;
+        // cppcheck-suppress accessMoved - FP
+        while (std::getline(files, pathName)) { // next line
+            if (!pathName.empty()) {
+                pathName = Path::removeQuotationMarks(std::move(pathName));
+                pathName = Path::fromNativeSeparators(std::move(pathName));
 
                 // If path doesn't end with / or \, add it
-                if (!endsWith(PathName, '/'))
-                    PathName += '/';
+                if (!endsWith(pathName, '/'))
+                    pathName += '/';
 
-                PathNames->push_back(PathName);
+                pathNames.emplace_back(std::move(pathName));
             }
         }
         return true;
@@ -87,1118 +110,2112 @@ static bool addIncludePathsToList(const std::string& FileList, std::list<std::st
     return false;
 }
 
-static bool addPathsToSet(const std::string& FileName, std::set<std::string>* set)
+static bool addPathsToSet(const std::string& fileName, std::set<std::string>& set)
 {
     std::list<std::string> templist;
-    if (!addIncludePathsToList(FileName, &templist))
+    if (!addIncludePathsToList(fileName, templist))
         return false;
-    set->insert(templist.begin(), templist.end());
+    set.insert(templist.cbegin(), templist.cend());
     return true;
 }
 
-CmdLineParser::CmdLineParser(Settings *settings)
-    : mSettings(settings)
-    , mShowHelp(false)
-    , mShowVersion(false)
-    , mShowErrorMessages(false)
-    , mExitAfterPrint(false)
-{
-}
+namespace {
+    class XMLErrorMessagesLogger : public ErrorLogger
+    {
+        void reportOut(const std::string & outmsg, Color /*c*/ = Color::Reset) override
+        {
+            std::cout << outmsg << std::endl;
+        }
 
-void CmdLineParser::printMessage(const std::string &message)
-{
-    std::cout << message << std::endl;
+        void reportErr(const ErrorMessage &msg) override
+        {
+            reportOut(msg.toXML());
+        }
+
+        void reportMetric(const std::string &metric) override
+        {
+            /* Not used here */
+            (void) metric;
+        }
+
+        void reportProgress(const std::string & /*filename*/, const char /*stage*/[], const std::size_t /*value*/) override
+        {}
+    };
 }
 
-void CmdLineParser::printMessage(const char* message)
+CmdLineParser::CmdLineParser(CmdLineLogger &logger, Settings &settings, Suppressions &suppressions)
+    : mLogger(logger)
+    , mSettings(settings)
+    , mSuppressions(suppressions)
+{}
+
+bool CmdLineParser::fillSettingsFromArgs(int argc, const char* const argv[])
 {
-    std::cout << message << std::endl;
+    const Result result = parseFromArgs(argc, argv);
+
+    switch (result) {
+    case Result::Success:
+        break;
+    case Result::Exit:
+        Settings::terminate();
+        return true;
+    case Result::Fail:
+        return false;
+    }
+
+    // Libraries must be loaded before FileLister is executed to ensure markup files will be
+    // listed properly.
+    if (!loadLibraries(mSettings))
+        return false;
+
+    if (!loadAddons(mSettings))
+        return false;
+
+    // Check that all include paths exist
+    {
+        for (auto iter = mSettings.includePaths.cbegin();
+             iter != mSettings.includePaths.cend();
+             ) {
+            const std::string path(Path::toNativeSeparators(*iter));
+            if (Path::isDirectory(path))
+                ++iter;
+            else {
+                // TODO: this bypasses the template format and other settings
+                // If the include path is not found, warn user and remove the non-existing path from the list.
+                if (mSettings.severity.isEnabled(Severity::information))
+                    std::cout << "(information) Couldn't find path given by -I '" << path << '\'' << std::endl;
+                iter = mSettings.includePaths.erase(iter);
+            }
+        }
+    }
+
+    // Output a warning for the user if he tries to exclude headers
+    const std::vector<std::string>& ignored = mIgnoredPaths;
+    const bool warn = std::any_of(ignored.cbegin(), ignored.cend(), [](const std::string& i) {
+        return Path::isHeader(i);
+    });
+    if (warn) {
+        mLogger.printMessage("filename exclusion does not apply to header (.h and .hpp) files.");
+        mLogger.printMessage("Please use --suppress for ignoring results from the header files.");
+    }
+
+    const std::vector<std::string>& pathnamesRef = mPathNames;
+    const std::list<FileSettings>& fileSettingsRef = mFileSettings;
+
+    // the inputs can only be used exclusively - CmdLineParser should already handle this
+    assert(!(!pathnamesRef.empty() && !fileSettingsRef.empty()));
+
+    if (!fileSettingsRef.empty()) {
+        std::list<FileSettings> fileSettings;
+        if (!mSettings.fileFilters.empty()) {
+            // filter only for the selected filenames from all project files
+            PathMatch filtermatcher(mSettings.fileFilters, Path::getCurrentPath());
+            std::copy_if(fileSettingsRef.cbegin(), fileSettingsRef.cend(), std::back_inserter(fileSettings), [&](const FileSettings &fs) {
+                return filtermatcher.match(fs.filename());
+            });
+            if (fileSettings.empty()) {
+                for (const std::string& f: mSettings.fileFilters)
+                    mLogger.printError("could not find any files matching the filter:" + f);
+                return false;
+            }
+        }
+        else {
+            fileSettings = fileSettingsRef;
+        }
+
+        // TODO: de-duplicate
+
+        mFileSettings.clear();
+
+        frontend::applyLang(fileSettings, mSettings, mEnforcedLang);
+
+        // sort the markup last
+        std::copy_if(fileSettings.cbegin(), fileSettings.cend(), std::back_inserter(mFileSettings), [&](const FileSettings &fs) {
+            return !mSettings.library.markupFile(fs.filename()) || !mSettings.library.processMarkupAfterCode(fs.filename());
+        });
+
+        std::copy_if(fileSettings.cbegin(), fileSettings.cend(), std::back_inserter(mFileSettings), [&](const FileSettings &fs) {
+            return mSettings.library.markupFile(fs.filename()) && mSettings.library.processMarkupAfterCode(fs.filename());
+        });
+
+        if (mFileSettings.empty()) {
+            mLogger.printError("could not find or open any of the paths given.");
+            return false;
+        }
+    }
+
+    if (!pathnamesRef.empty()) {
+        std::list<FileWithDetails> filesResolved;
+        // Execute recursiveAddFiles() to each given file parameter
+        // TODO: verbose log which files were ignored?
+        const PathMatch matcher(ignored, Path::getCurrentPath());
+        for (const std::string &pathname : pathnamesRef) {
+            const std::string err = FileLister::recursiveAddFiles(filesResolved, Path::toNativeSeparators(pathname), mSettings.library.markupExtensions(), matcher, mSettings.debugignore);
+            if (!err.empty()) {
+                // TODO: bail out?
+                mLogger.printMessage(err);
+            }
+        }
+
+        if (filesResolved.empty()) {
+            mLogger.printError("could not find or open any of the paths given.");
+            // TODO: PathMatch should provide the information if files were ignored
+            if (!ignored.empty())
+                mLogger.printMessage("Maybe all paths were ignored?");
+            return false;
+        }
+
+        std::list<FileWithDetails> files;
+        if (!mSettings.fileFilters.empty()) {
+            files = filterFiles(mSettings.fileFilters, filesResolved);
+            if (files.empty()) {
+                for (const std::string& f: mSettings.fileFilters)
+                    mLogger.printError("could not find any files matching the filter:" + f);
+                return false;
+            }
+        }
+        else {
+            files = std::move(filesResolved);
+        }
+
+        // de-duplicate files
+        {
+            auto it = files.begin();
+            while (it != files.end()) {
+                const std::string& absname = it->abspath();
+                // TODO: log if duplicated files were dropped
+                files.erase(std::remove_if(std::next(it), files.end(), [&](const FileWithDetails& entry) {
+                    return entry.abspath() == absname;
+                }), files.end());
+                ++it;
+            }
+        }
+
+        frontend::applyLang(files, mSettings, mEnforcedLang);
+
+        // sort the markup last
+        std::copy_if(files.cbegin(), files.cend(), std::inserter(mFiles, mFiles.end()), [&](const FileWithDetails& entry) {
+            return !mSettings.library.markupFile(entry.path()) || !mSettings.library.processMarkupAfterCode(entry.path());
+        });
+
+        std::copy_if(files.cbegin(), files.cend(), std::inserter(mFiles, mFiles.end()), [&](const FileWithDetails& entry) {
+            return mSettings.library.markupFile(entry.path()) && mSettings.library.processMarkupAfterCode(entry.path());
+        });
+
+        if (mFiles.empty()) {
+            mLogger.printError("could not find or open any of the paths given.");
+            return false;
+        }
+    }
+
+    return true;
 }
 
-bool CmdLineParser::parseFromArgs(int argc, const char* const argv[])
+// TODO: normalize/simplify/native all path parameters
+// TODO: error out on all missing given files/paths
+CmdLineParser::Result CmdLineParser::parseFromArgs(int argc, const char* const argv[])
 {
-    bool def = false;
-    bool maxconfigs = false;
+    mSettings.exename = Path::getCurrentExecutablePath(argv[0]);
 
-    mSettings->exename = argv[0];
+    bool xmlOptionProvided = false;
+    bool outputFormatOptionProvided = false;
 
+    // default to --check-level=normal from CLI for now
+    mSettings.setCheckLevel(Settings::CheckLevel::normal);
+
+    // read --debug-lookup early so the option is available for the cppcheck.cfg loading
     for (int i = 1; i < argc; i++) {
-        if (argv[i][0] == '-') {
-            if (std::strcmp(argv[i], "--version") == 0) {
-                mShowVersion = true;
-                mExitAfterPrint = true;
-                return true;
-            }
-
-            else if (std::strncmp(argv[i], "--addon=", 8) == 0)
-                mSettings->addons.emplace_back(argv[i]+8);
-
-            else if (std::strncmp(argv[i], "--cppcheck-build-dir=", 21) == 0) {
-                mSettings->buildDir = Path::fromNativeSeparators(argv[i] + 21);
-                if (endsWith(mSettings->buildDir, '/'))
-                    mSettings->buildDir.erase(mSettings->buildDir.size() - 1U);
-            }
-
-            // Flag used for various purposes during debugging
-            else if (std::strcmp(argv[i], "--debug-simplified") == 0)
-                mSettings->debugSimplified = true;
-
-            // Show --debug output after the first simplifications
-            else if (std::strcmp(argv[i], "--debug") == 0 ||
-                     std::strcmp(argv[i], "--debug-normal") == 0)
-                mSettings->debugnormal = true;
-
-            // Show debug warnings
-            else if (std::strcmp(argv[i], "--debug-warnings") == 0)
-                mSettings->debugwarnings = true;
-
-            // Show template information
-            else if (std::strcmp(argv[i], "--debug-template") == 0)
-                mSettings->debugtemplate = true;
-
-            // dump cppcheck data
-            else if (std::strcmp(argv[i], "--dump") == 0)
-                mSettings->dump = true;
-
-            // max ctu depth
-            else if (std::strncmp(argv[i], "--max-ctu-depth=", 16) == 0)
-                mSettings->maxCtuDepth = std::atoi(argv[i] + 16);
-
-            else if (std::strcmp(argv[i], "--experimental-fast") == 0)
-                // TODO: Reomve this flag!
-                ;
-
-            // (Experimental) exception handling inside cppcheck client
-            else if (std::strcmp(argv[i], "--exception-handling") == 0)
-                mSettings->exceptionHandling = true;
-            else if (std::strncmp(argv[i], "--exception-handling=", 21) == 0) {
-                mSettings->exceptionHandling = true;
-                const std::string exceptionOutfilename = &(argv[i][21]);
-                CppCheckExecutor::setExceptionOutput((exceptionOutfilename=="stderr") ? stderr : stdout);
-            }
-
-            // Inconclusive checking
-            else if (std::strcmp(argv[i], "--inconclusive") == 0)
-                mSettings->inconclusive = true;
-
-            // Experimental: Safe checking
-            else if (std::strcmp(argv[i], "--safe-classes") == 0)
-                mSettings->safeChecks.classes = true;
-
-            // Experimental: Safe checking
-            else if (std::strcmp(argv[i], "--safe-functions") == 0)
-                mSettings->safeChecks.externalFunctions = mSettings->safeChecks.internalFunctions = true;
-
-            // Experimental: Verify
-            else if (std::strcmp(argv[i], "--verify") == 0)
-                mSettings->verification = true;
-            else if (std::strcmp(argv[i], "--debug-verify") == 0)
-                mSettings->debugVerification = true;
-
-            // Enforce language (--language=, -x)
-            else if (std::strncmp(argv[i], "--language=", 11) == 0 || std::strcmp(argv[i], "-x") == 0) {
-                std::string str;
-                if (argv[i][2]) {
-                    str = argv[i]+11;
-                } else {
-                    i++;
-                    if (i >= argc || argv[i][0] == '-') {
-                        printMessage("cppcheck: No language given to '-x' option.");
-                        return false;
-                    }
-                    str = argv[i];
-                }
+        // Show debug warnings for lookup for configuration files
+        if (std::strcmp(argv[i], "--debug-lookup") == 0)
+            mSettings.debuglookup = true;
+
+        else if (std::strncmp(argv[i], "--debug-lookup=", 15) == 0) {
+            const std::string lookup = argv[i] + 15;
+            if (lookup == "all")
+                mSettings.debuglookup = true;
+            else if (lookup == "addon")
+                mSettings.debuglookupAddon = true;
+            else if (lookup == "config")
+                mSettings.debuglookupConfig = true;
+            else if (lookup == "library")
+                mSettings.debuglookupLibrary = true;
+            else if (lookup == "platform")
+                mSettings.debuglookupPlatform = true;
+            else
+            {
+                mLogger.printError("unknown lookup '" + lookup + "'");
+                return Result::Fail;
+            }
+        }
+    }
 
-                if (str == "c")
-                    mSettings->enforcedLang = Settings::C;
-                else if (str == "c++")
-                    mSettings->enforcedLang = Settings::CPP;
-                else {
-                    printMessage("cppcheck: Unknown language '" + str + "' enforced.");
-                    return false;
-                }
+    if (!loadCppcheckCfg())
+        return Result::Fail;
+
+    if (argc <= 1) {
+        printHelp();
+        return Result::Exit;
+    }
+
+    // check for exclusive options
+    for (int i = 1; i < argc; i++) {
+        // documentation..
+        if (std::strcmp(argv[i], "--doc") == 0) {
+            std::ostringstream doc;
+            // Get documentation..
+            for (const Check * it : Check::instances()) {
+                const std::string& name(it->name());
+                const std::string info(it->classInfo());
+                if (!name.empty() && !info.empty())
+                    doc << "## " << name << " ##\n"
+                        << info << "\n";
             }
 
-            // Filter errors
-            else if (std::strncmp(argv[i], "--exitcode-suppressions=", 24) == 0) {
-                // exitcode-suppressions=filename.txt
-                std::string filename = 24 + argv[i];
+            mLogger.printRaw(doc.str());
+            return Result::Exit;
+        }
 
-                std::ifstream f(filename);
-                if (!f.is_open()) {
-                    printMessage("cppcheck: Couldn't open the file: \"" + filename + "\".");
-                    return false;
-                }
-                const std::string errmsg(mSettings->nofail.parseFile(f));
-                if (!errmsg.empty()) {
-                    printMessage(errmsg);
-                    return false;
-                }
+        // print all possible error messages..
+        if (std::strcmp(argv[i], "--errorlist") == 0) {
+            {
+                XMLErrorMessagesLogger xmlLogger;
+                std::cout << ErrorMessage::getXMLHeader(mSettings.cppcheckCfgProductName, 2);
+                CppCheck::getErrorMessages(xmlLogger);
+                std::cout << ErrorMessage::getXMLFooter(2) << std::endl;
             }
+            return Result::Exit;
+        }
 
-            // Filter errors
-            else if (std::strncmp(argv[i], "--suppressions-list=", 20) == 0) {
-                std::string filename = argv[i]+20;
-                std::ifstream f(filename);
-                if (!f.is_open()) {
-                    std::string message("cppcheck: Couldn't open the file: \"");
-                    message += filename;
-                    message += "\".";
-                    if (std::count(filename.begin(), filename.end(), ',') > 0 ||
-                        std::count(filename.begin(), filename.end(), '.') > 1) {
-                        // If user tried to pass multiple files (we can only guess that)
-                        // e.g. like this: --suppressions-list=a.txt,b.txt
-                        // print more detailed error message to tell user how he can solve the problem
-                        message += "\nIf you want to pass two files, you can do it e.g. like this:";
-                        message += "\n    cppcheck --suppressions-list=a.txt --suppressions-list=b.txt file.cpp";
-                    }
+        // Print help
+        if (std::strcmp(argv[i], "-h") == 0 || std::strcmp(argv[i], "--help") == 0) {
+            printHelp();
+            return Result::Exit;
+        }
 
-                    printMessage(message);
-                    return false;
-                }
-                const std::string errmsg(mSettings->nomsg.parseFile(f));
-                if (!errmsg.empty()) {
-                    printMessage(errmsg);
-                    return false;
+        if (std::strcmp(argv[i], "--filesdir") == 0) {
+#ifdef FILESDIR
+            mLogger.printRaw(FILESDIR); // TODO: should not include newline
+#endif
+            return Result::Exit;
+        }
+
+        if (std::strcmp(argv[i], "--version") == 0) {
+            const std::string version = getVersion();
+            mLogger.printRaw(version); // TODO: should not include newline
+            return Result::Exit;
+        }
+    }
+
+    bool debug = false;
+    bool inputAsFilter = false; // set by: --file-filter=+
+
+    ImportProject::Type projectType = ImportProject::Type::NONE;
+    ImportProject project;
+    std::string vsConfig;
+
+    std::string platform;
+    char defaultSign = '\0';
+
+    std::vector<std::string> lookupPaths{
+        Path::getCurrentPath(), // TODO: do we want to look in CWD?
+        Path::getPathFromFilename(mSettings.exename),
+    };
+
+    bool executorAuto = true;
+
+    for (int i = 1; i < argc; i++) {
+        if (argv[i][0] != '-') {
+            mPathNames.emplace_back(Path::fromNativeSeparators(Path::removeQuotationMarks(argv[i])));
+        }
+
+        // User define
+        else if (std::strncmp(argv[i], "-D", 2) == 0) {
+            std::string define;
+
+            // "-D define"
+            if (std::strcmp(argv[i], "-D") == 0) {
+                ++i;
+                if (i >= argc || argv[i][0] == '-') {
+                    mLogger.printError("argument to '-D' is missing.");
+                    return Result::Fail;
                 }
+
+                define = argv[i];
+            }
+            // "-Ddefine"
+            else {
+                define = 2 + argv[i];
             }
 
-            else if (std::strncmp(argv[i], "--suppress-xml=", 15) == 0) {
-                const char * filename = argv[i] + 15;
-                const std::string errmsg(mSettings->nomsg.parseXmlFile(filename));
-                if (!errmsg.empty()) {
-                    printMessage(errmsg);
-                    return false;
+            // No "=", append a "=1"
+            if (define.find('=') == std::string::npos)
+                define += "=1";
+
+            if (!mSettings.userDefines.empty())
+                mSettings.userDefines += ";";
+            mSettings.userDefines += define;
+        }
+
+        // -E
+        else if (std::strcmp(argv[i], "-E") == 0) {
+            mSettings.preprocessOnly = true;
+            mSettings.quiet = true;
+        }
+
+        // Include paths
+        else if (std::strncmp(argv[i], "-I", 2) == 0) {
+            std::string path;
+
+            // "-I path/"
+            if (std::strcmp(argv[i], "-I") == 0) {
+                ++i;
+                if (i >= argc || argv[i][0] == '-') {
+                    mLogger.printError("argument to '-I' is missing.");
+                    return Result::Fail;
                 }
+                path = argv[i];
             }
 
-            else if (std::strncmp(argv[i], "--suppress=", 11) == 0) {
-                const std::string suppression = argv[i]+11;
-                const std::string errmsg(mSettings->nomsg.addSuppressionLine(suppression));
-                if (!errmsg.empty()) {
-                    printMessage(errmsg);
-                    return false;
-                }
+            // "-Ipath/"
+            else {
+                path = 2 + argv[i];
             }
+            path = Path::removeQuotationMarks(std::move(path));
+            path = Path::fromNativeSeparators(std::move(path));
 
-            // Enables inline suppressions.
-            else if (std::strcmp(argv[i], "--inline-suppr") == 0)
-                mSettings->inlineSuppressions = true;
-
-            // Verbose error messages (configuration info)
-            else if (std::strcmp(argv[i], "-v") == 0 || std::strcmp(argv[i], "--verbose") == 0)
-                mSettings->verbose = true;
-
-            // Force checking of files that have "too many" configurations
-            else if (std::strcmp(argv[i], "-f") == 0 || std::strcmp(argv[i], "--force") == 0)
-                mSettings->force = true;
-
-            // Output relative paths
-            else if (std::strcmp(argv[i], "-rp") == 0 || std::strcmp(argv[i], "--relative-paths") == 0)
-                mSettings->relativePaths = true;
-            else if (std::strncmp(argv[i], "-rp=", 4) == 0 || std::strncmp(argv[i], "--relative-paths=", 17) == 0) {
-                mSettings->relativePaths = true;
-                if (argv[i][argv[i][3]=='='?4:17] != 0) {
-                    std::string paths = argv[i]+(argv[i][3]=='='?4:17);
-                    for (;;) {
-                        const std::string::size_type pos = paths.find(';');
-                        if (pos == std::string::npos) {
-                            mSettings->basePaths.push_back(Path::fromNativeSeparators(paths));
-                            break;
-                        }
-                        mSettings->basePaths.push_back(Path::fromNativeSeparators(paths.substr(0, pos)));
-                        paths.erase(0, pos + 1);
-                    }
-                } else {
-                    printMessage("cppcheck: No paths specified for the '" + std::string(argv[i]) + "' option.");
-                    return false;
+            // If path doesn't end with / or \, add it
+            if (!endsWith(path,'/'))
+                path += '/';
+
+            mSettings.includePaths.emplace_back(std::move(path));
+        }
+
+        // User undef
+        else if (std::strncmp(argv[i], "-U", 2) == 0) {
+            std::string undef;
+
+            // "-U undef"
+            if (std::strcmp(argv[i], "-U") == 0) {
+                ++i;
+                if (i >= argc || argv[i][0] == '-') {
+                    mLogger.printError("argument to '-U' is missing.");
+                    return Result::Fail;
                 }
+
+                undef = argv[i];
+            }
+            // "-Uundef"
+            else {
+                undef = 2 + argv[i];
             }
 
-            // Write results in file
-            else if (std::strncmp(argv[i], "--output-file=", 14) == 0)
-                mSettings->outputFile = Path::simplifyPath(Path::fromNativeSeparators(argv[i] + 14));
+            mSettings.userUndefs.insert(std::move(undef));
+        }
+
+        else if (std::strncmp(argv[i], "--addon=", 8) == 0)
+            mSettings.addons.emplace(argv[i]+8);
+
+        else if (std::strncmp(argv[i],"--addon-python=", 15) == 0)
+            mSettings.addonPython.assign(argv[i]+15);
 
-            // Write results in results.plist
-            else if (std::strncmp(argv[i], "--plist-output=", 15) == 0) {
-                mSettings->plistOutput = Path::simplifyPath(Path::fromNativeSeparators(argv[i] + 15));
-                if (mSettings->plistOutput.empty())
-                    mSettings->plistOutput = "./";
-                else if (!endsWith(mSettings->plistOutput,'/'))
-                    mSettings->plistOutput += '/';
+        else if (std::strcmp(argv[i],"--analyze-all-vs-configs") == 0) {
+            mSettings.analyzeAllVsConfigs = true;
+            mAnalyzeAllVsConfigsSetOnCmdLine = true;
+        }
+
+        // Check configuration
+        else if (std::strcmp(argv[i], "--check-config") == 0)
+            mSettings.checkConfiguration = true;
+
+        else if (std::strcmp(argv[i], "--check-headers") == 0)
+            mSettings.checkHeaders = true;
+
+        // Check level
+        else if (std::strncmp(argv[i], "--check-level=", 14) == 0) {
+            Settings::CheckLevel level = Settings::CheckLevel::normal;
+            const std::string level_s(argv[i] + 14);
+            if (level_s == "reduced")
+                level = Settings::CheckLevel::reduced;
+            else if (level_s == "normal")
+                level = Settings::CheckLevel::normal;
+            else if (level_s == "exhaustive")
+                level = Settings::CheckLevel::exhaustive;
+            else {
+                mLogger.printError("unknown '--check-level' value '" + level_s + "'.");
+                return Result::Fail;
             }
 
-            // Write results in results.xml
-            else if (std::strcmp(argv[i], "--xml") == 0)
-                mSettings->xml = true;
+            mSettings.setCheckLevel(level);
+        }
 
-            // Define the XML file version (and enable XML output)
-            else if (std::strncmp(argv[i], "--xml-version=", 14) == 0) {
-                const std::string numberString(argv[i]+14);
+        // Check library definitions
+        else if (std::strcmp(argv[i], "--check-library") == 0) {
+            mSettings.checkLibrary = true;
+        }
 
-                std::istringstream iss(numberString);
-                if (!(iss >> mSettings->xml_version)) {
-                    printMessage("cppcheck: argument to '--xml-version' is not a number.");
-                    return false;
-                }
+        else if (std::strcmp(argv[i], "--check-unused-templates") == 0)
+            mSettings.checkUnusedTemplates = true;
+
+        else if (std::strncmp(argv[i], "--check-version=", 16) == 0) {
+            if (!loadCppcheckCfg())
+                return Result::Fail;
+            const std::string actualVersion = getVersion();
+            const std::string wantedVersion = argv[i] + 16;
+            if (actualVersion != wantedVersion) {
+                mLogger.printError("--check-version check failed. Aborting.");
+                return Result::Fail;
+            }
+        }
 
-                if (mSettings->xml_version != 2) {
-                    // We only have xml version 2
-                    printMessage("cppcheck: '--xml-version' can only be 2.");
-                    return false;
-                }
+        else if (std::strncmp(argv[i], "--checkers-report=", 18) == 0)
+            mSettings.checkersReportFilename = argv[i] + 18;
+
+        else if (std::strncmp(argv[i], "--checks-max-time=", 18) == 0) {
+            if (!parseNumberArg(argv[i], 18, mSettings.checksMaxTime, true))
+                return Result::Fail;
+        }
+
+        else if (std::strcmp(argv[i], "--clang") == 0) {
+            mSettings.clang = true;
+        }
+
+        else if (std::strncmp(argv[i], "--clang=", 8) == 0) {
+            mSettings.clang = true;
+            mSettings.clangExecutable = argv[i] + 8;
+        }
+
+        else if (std::strcmp(argv[i], "--clang-tidy") == 0) {
+            mSettings.clangTidy = true;
+        }
+
+        else if (std::strncmp(argv[i], "--clang-tidy=", 13) == 0) {
+            mSettings.clangTidy = true;
+            mSettings.clangTidyExecutable = argv[i] + 13;
+        }
 
-                // Enable also XML if version is set
-                mSettings->xml = true;
+        else if (std::strncmp(argv[i], "--config-exclude=",17) ==0) {
+            mSettings.configExcludePaths.insert(Path::fromNativeSeparators(argv[i] + 17));
+        }
+
+        else if (std::strncmp(argv[i], "--config-excludes-file=", 23) == 0) {
+            // open this file and read every input file (1 file name per line)
+            const std::string cfgExcludesFile(23 + argv[i]);
+            if (!addPathsToSet(cfgExcludesFile, mSettings.configExcludePaths)) {
+                mLogger.printError("unable to open config excludes file at '" + cfgExcludesFile + "'");
+                return Result::Fail;
+            }
+        }
+
+        else if (std::strncmp(argv[i], "--cppcheck-build-dir=", 21) == 0) {
+            std::string path = Path::fromNativeSeparators(argv[i] + 21);
+            if (path.empty()) {
+                mLogger.printError("no path has been specified for --cppcheck-build-dir");
+                return Result::Fail;
             }
+            if (endsWith(path, '/'))
+                path.pop_back();
+            mSettings.buildDir = std::move(path);
+        }
+
+        else if (std::strcmp(argv[i], "--cpp-header-probe") == 0) {
+            mSettings.cppHeaderProbe = true;
+        }
+
+        else if (std::strcmp(argv[i], "--debug-analyzerinfo") == 0)
+            mSettings.debugainfo = true;
+
+        else if (std::strcmp(argv[i], "--debug-ast") == 0)
+            mSettings.debugast = true;
+
+        // Show debug warnings for lookup for configuration files
+        else if (std::strcmp(argv[i], "--debug-clang-output") == 0)
+            mSettings.debugClangOutput = true;
+
+        // Show debug messages for ignored files
+        else if (std::strcmp(argv[i], "--debug-ignore") == 0)
+            mSettings.debugignore = true;
 
-            // Only print something when there are errors
-            else if (std::strcmp(argv[i], "-q") == 0 || std::strcmp(argv[i], "--quiet") == 0)
-                mSettings->quiet = true;
+        // Show --debug output after the first simplifications
+        else if (std::strcmp(argv[i], "--debug") == 0 ||
+                 std::strcmp(argv[i], "--debug-normal") == 0)
+            debug = true;
 
-            // Check configuration
-            else if (std::strcmp(argv[i], "--check-config") == 0) {
-                mSettings->checkConfiguration = true;
+        else if (std::strcmp(argv[i], "--debug-lookup") == 0)
+            continue; // already handled above
+
+        else if (std::strncmp(argv[i], "--debug-lookup=", 15) == 0)
+            continue; // already handled above
+
+        // Flag used for various purposes during debugging
+        else if (std::strcmp(argv[i], "--debug-simplified") == 0)
+            mSettings.debugSimplified = true;
+
+        else if (std::strcmp(argv[i], "--debug-symdb") == 0)
+            mSettings.debugsymdb = true;
+
+        // Show template information
+        else if (std::strcmp(argv[i], "--debug-template") == 0)
+            mSettings.debugtemplate = true;
+
+        else if (std::strcmp(argv[i], "--debug-valueflow") == 0)
+            mSettings.debugvalueflow = true;
+
+        // Show debug warnings
+        else if (std::strcmp(argv[i], "--debug-warnings") == 0)
+            mSettings.debugwarnings = true;
+
+        else if (std::strncmp(argv[i], "--disable=", 10) == 0) {
+            const std::string errmsg = mSettings.removeEnabled(argv[i] + 10);
+            if (!errmsg.empty()) {
+                mLogger.printError(errmsg);
+                return Result::Fail;
             }
+        }
+
+        // dump cppcheck data
+        else if (std::strcmp(argv[i], "--dump") == 0)
+            mSettings.dump = true;
+
+        else if (std::strcmp(argv[i], "--emit-duplicates") == 0)
+            mSettings.emitDuplicates = true;
 
-            // Check library definitions
-            else if (std::strcmp(argv[i], "--check-library") == 0) {
-                mSettings->checkLibrary = true;
+        else if (std::strncmp(argv[i], "--enable=", 9) == 0) {
+            const std::string enable_arg = argv[i] + 9;
+            const std::string errmsg = mSettings.addEnabled(enable_arg);
+            if (!errmsg.empty()) {
+                mLogger.printError(errmsg);
+                return Result::Fail;
             }
+            // when "style" is enabled, also enable "warning", "performance" and "portability"
+            if (enable_arg.find("style") != std::string::npos) {
+                mSettings.addEnabled("warning");
+                mSettings.addEnabled("performance");
+                mSettings.addEnabled("portability");
+            }
+        }
 
-            else if (std::strncmp(argv[i], "--enable=", 9) == 0) {
-                const std::string errmsg = mSettings->addEnabled(argv[i] + 9);
-                if (!errmsg.empty()) {
-                    printMessage(errmsg);
-                    return false;
-                }
-                // when "style" is enabled, also enable "warning", "performance" and "portability"
-                if (mSettings->isEnabled(Settings::STYLE)) {
-                    mSettings->addEnabled("warning");
-                    mSettings->addEnabled("performance");
-                    mSettings->addEnabled("portability");
-                }
+        // --error-exitcode=1
+        else if (std::strncmp(argv[i], "--error-exitcode=", 17) == 0) {
+            if (!parseNumberArg(argv[i], 17, mSettings.exitCode))
+                return Result::Fail;
+        }
+
+        // Exception handling inside cppcheck client
+        else if (std::strcmp(argv[i], "--exception-handling") == 0) {
+#if defined(USE_WINDOWS_SEH) || defined(USE_UNIX_SIGNAL_HANDLING)
+            mSettings.exceptionHandling = true;
+#else
+            mLogger.printError("Option --exception-handling is not supported since Cppcheck has not been built with any exception handling enabled.");
+            return Result::Fail;
+#endif
+        }
+
+        // Exception handling inside cppcheck client
+        else if (std::strncmp(argv[i], "--exception-handling=", 21) == 0) {
+#if defined(USE_WINDOWS_SEH) || defined(USE_UNIX_SIGNAL_HANDLING)
+            const std::string exceptionOutfilename = argv[i] + 21;
+            if (exceptionOutfilename != "stderr" && exceptionOutfilename != "stdout") {
+                mLogger.printError("invalid '--exception-handling' argument");
+                return Result::Fail;
             }
+            mSettings.exceptionHandling = true;
+            mSettings.exceptionOutput = (exceptionOutfilename == "stderr") ? stderr : stdout;
+#else
+            mLogger.printError("Option --exception-handling is not supported since Cppcheck has not been built with any exception handling enabled.");
+            return Result::Fail;
+#endif
+        }
 
-            // --error-exitcode=1
-            else if (std::strncmp(argv[i], "--error-exitcode=", 17) == 0) {
-                const std::string temp = argv[i]+17;
-                std::istringstream iss(temp);
-                if (!(iss >> mSettings->exitCode)) {
-                    mSettings->exitCode = 0;
-                    printMessage("cppcheck: Argument must be an integer. Try something like '--error-exitcode=1'.");
-                    return false;
-                }
+        else if (std::strncmp(argv[i], "--executor=", 11) == 0) {
+            const std::string type = 11 + argv[i];
+            if (type == "auto") {
+                executorAuto = true;
+                mSettings.executor = Settings::defaultExecutor();
+            }
+            else if (type == "thread") {
+#if defined(HAS_THREADING_MODEL_THREAD)
+                executorAuto = false;
+                mSettings.executor = Settings::ExecutorType::Thread;
+#else
+                mLogger.printError("executor type 'thread' cannot be used as Cppcheck has not been built with a respective threading model.");
+                return Result::Fail;
+#endif
+            }
+            else if (type == "process") {
+#if defined(HAS_THREADING_MODEL_FORK)
+                executorAuto = false;
+                mSettings.executor = Settings::ExecutorType::Process;
+#else
+                mLogger.printError("executor type 'process' cannot be used as Cppcheck has not been built with a respective threading model.");
+                return Result::Fail;
+#endif
             }
+            else {
+                mLogger.printError("unknown executor: '" + type + "'.");
+                return Result::Fail;
+            }
+        }
 
-            // User define
-            else if (std::strncmp(argv[i], "-D", 2) == 0) {
-                std::string define;
+        // Filter errors
+        else if (std::strncmp(argv[i], "--exitcode-suppressions=", 24) == 0) {
+            // exitcode-suppressions=filename.txt
+            std::string filename = 24 + argv[i];
 
-                // "-D define"
-                if (std::strcmp(argv[i], "-D") == 0) {
-                    ++i;
-                    if (i >= argc || argv[i][0] == '-') {
-                        printMessage("cppcheck: argument to '-D' is missing.");
-                        return false;
-                    }
+            std::ifstream f(filename);
+            if (!f.is_open()) {
+                mLogger.printError("couldn't open the file: \"" + filename + "\".");
+                return Result::Fail;
+            }
+            const std::string errmsg(mSuppressions.nofail.parseFile(f));
+            if (!errmsg.empty()) {
+                mLogger.printError(errmsg);
+                return Result::Fail;
+            }
+        }
 
-                    define = argv[i];
-                }
-                // "-Ddefine"
-                else {
-                    define = 2 + argv[i];
+        // use a file filter
+        else if (std::strncmp(argv[i], "--file-filter=", 14) == 0) {
+            const char *filter = argv[i] + 14;
+            if (std::strcmp(filter, "-") == 0) {
+                if (!addFilesToList(filter, mSettings.fileFilters)) {
+                    mLogger.printError("Failed: --file-filter=-");
+                    return Result::Fail;
                 }
+            } else if (std::strcmp(filter, "+") == 0) {
+                inputAsFilter = true;
+            } else {
+                mSettings.fileFilters.emplace_back(filter);
+            }
+        }
 
-                // No "=", append a "=1"
-                if (define.find('=') == std::string::npos)
-                    define += "=1";
+        // file list specified
+        else if (std::strncmp(argv[i], "--file-list=", 12) == 0) {
+            // open this file and read every input file (1 file name per line)
+            const std::string fileList = argv[i] + 12;
+            if (!addFilesToList(fileList, mPathNames)) {
+                mLogger.printError("couldn't open the file: \"" + fileList + "\".");
+                return Result::Fail;
+            }
+        }
 
-                if (!mSettings->userDefines.empty())
-                    mSettings->userDefines += ";";
-                mSettings->userDefines += define;
+        // Force checking of files that have "too many" configurations
+        else if (std::strcmp(argv[i], "-f") == 0 || std::strcmp(argv[i], "--force") == 0) {
+            mSettings.force = true;
+            mSettings.maxConfigsOption = Settings::maxConfigsNotAssigned;
+        }
 
-                def = true;
-            }
-            // User undef
-            else if (std::strncmp(argv[i], "-U", 2) == 0) {
-                std::string undef;
+        else if (std::strcmp(argv[i], "--fsigned-char") == 0)
+            defaultSign = 's';
 
-                // "-U undef"
-                if (std::strcmp(argv[i], "-U") == 0) {
-                    ++i;
-                    if (i >= argc || argv[i][0] == '-') {
-                        printMessage("cppcheck: argument to '-U' is missing.");
-                        return false;
-                    }
+        else if (std::strcmp(argv[i], "--funsigned-char") == 0)
+            defaultSign = 'u';
 
-                    undef = argv[i];
-                }
-                // "-Uundef"
-                else {
-                    undef = 2 + argv[i];
+        // Ignored paths
+        else if (std::strncmp(argv[i], "-i", 2) == 0) {
+            std::string path;
+
+            // "-i path/"
+            if (std::strcmp(argv[i], "-i") == 0) {
+                ++i;
+                if (i >= argc || argv[i][0] == '-') {
+                    mLogger.printError("argument to '-i' is missing.");
+                    return Result::Fail;
                 }
+                path = argv[i];
+            }
 
-                mSettings->userUndefs.insert(undef);
+            // "-ipath/"
+            else {
+                path = 2 + argv[i];
             }
 
-            // -E
-            else if (std::strcmp(argv[i], "-E") == 0) {
-                mSettings->preprocessOnly = true;
-                mSettings->quiet = true;
+            if (!path.empty()) {
+                mIgnoredPaths.emplace_back(std::move(path));
             }
+        }
 
-            // Include paths
-            else if (std::strncmp(argv[i], "-I", 2) == 0) {
-                std::string path;
+        else if (std::strncmp(argv[i], "--include=", 10) == 0) {
+            mSettings.userIncludes.emplace_back(Path::fromNativeSeparators(argv[i] + 10));
+        }
 
-                // "-I path/"
-                if (std::strcmp(argv[i], "-I") == 0) {
-                    ++i;
-                    if (i >= argc || argv[i][0] == '-') {
-                        printMessage("cppcheck: argument to '-I' is missing.");
-                        return false;
-                    }
-                    path = argv[i];
-                }
+        else if (std::strncmp(argv[i], "--includes-file=", 16) == 0) {
+            // open this file and read every input file (1 file name per line)
+            const std::string includesFile(16 + argv[i]);
+            if (!addIncludePathsToList(includesFile, mSettings.includePaths)) {
+                mLogger.printError("unable to open includes file at '" + includesFile + "'");
+                return Result::Fail;
+            }
+        }
 
-                // "-Ipath/"
-                else {
-                    path = 2 + argv[i];
-                }
-                path = Path::removeQuotationMarks(path);
-                path = Path::fromNativeSeparators(path);
+        // Inconclusive checking
+        else if (std::strcmp(argv[i], "--inconclusive") == 0)
+            mSettings.certainty.enable(Certainty::inconclusive);
 
-                // If path doesn't end with / or \, add it
-                if (!endsWith(path,'/'))
-                    path += '/';
-
-                mSettings->includePaths.push_back(path);
-            } else if (std::strncmp(argv[i], "--include=", 10) == 0) {
-                std::string path = argv[i] + 10;
-
-                path = Path::fromNativeSeparators(path);
-
-                mSettings->userIncludes.push_back(path);
-            } else if (std::strncmp(argv[i], "--includes-file=", 16) == 0) {
-                // open this file and read every input file (1 file name per line)
-                const std::string includesFile(16 + argv[i]);
-                if (!addIncludePathsToList(includesFile, &mSettings->includePaths)) {
-                    printMessage("Cppcheck: unable to open includes file at '" + includesFile + "'");
-                    return false;
-                }
-            } else if (std::strncmp(argv[i], "--config-exclude=",17) ==0) {
-                std::string path = argv[i] + 17;
-                path = Path::fromNativeSeparators(path);
-                mSettings->configExcludePaths.insert(path);
-            } else if (std::strncmp(argv[i], "--config-excludes-file=", 23) == 0) {
-                // open this file and read every input file (1 file name per line)
-                const std::string cfgExcludesFile(23 + argv[i]);
-                if (!addPathsToSet(cfgExcludesFile, &mSettings->configExcludePaths)) {
-                    printMessage("Cppcheck: unable to open config excludes file at '" + cfgExcludesFile + "'");
-                    return false;
+        // Enables inline suppressions.
+        else if (std::strcmp(argv[i], "--inline-suppr") == 0)
+            mSettings.inlineSuppressions = true;
+
+        // Checking threads
+        else if (std::strncmp(argv[i], "-j", 2) == 0) {
+            std::string numberString;
+
+            // "-j 3"
+            if (std::strcmp(argv[i], "-j") == 0) {
+                ++i;
+                if (i >= argc || argv[i][0] == '-') {
+                    mLogger.printError("argument to '-j' is missing.");
+                    return Result::Fail;
                 }
+
+                numberString = argv[i];
             }
 
-            // file list specified
-            else if (std::strncmp(argv[i], "--file-list=", 12) == 0) {
-                // open this file and read every input file (1 file name per line)
-                addFilesToList(12 + argv[i], mPathNames);
+            // "-j3"
+            else
+                numberString = argv[i]+2;
+
+            unsigned int tmp;
+            std::string err;
+            if (!strToInt(numberString, tmp, &err)) {
+                mLogger.printError("argument to '-j' is not valid - " +  err + ".");
+                return Result::Fail;
             }
+            if (tmp == 0) {
+                // TODO: implement get CPU logical core count and use that.
+                // Usually, -j 0 would mean "use all available cores," but
+                // if we get a 0, we just stall and don't do any work.
+                mLogger.printError("argument for '-j' must be greater than 0.");
+                return Result::Fail;
+            }
+            if (tmp > 1024) {
+                // Almost nobody has 1024 logical cores, but somebody out
+                // there does.
+                mLogger.printError("argument for '-j' is allowed to be 1024 at max.");
+                return Result::Fail;
+            }
+            mSettings.jobs = tmp;
+        }
 
-            // Ignored paths
-            else if (std::strncmp(argv[i], "-i", 2) == 0) {
-                std::string path;
+        else if (std::strncmp(argv[i], "-l", 2) == 0) {
+#ifdef HAS_THREADING_MODEL_FORK
+            std::string numberString;
 
-                // "-i path/"
-                if (std::strcmp(argv[i], "-i") == 0) {
-                    ++i;
-                    if (i >= argc || argv[i][0] == '-') {
-                        printMessage("cppcheck: argument to '-i' is missing.");
-                        return false;
-                    }
-                    path = argv[i];
+            // "-l 3"
+            if (std::strcmp(argv[i], "-l") == 0) {
+                ++i;
+                if (i >= argc || argv[i][0] == '-') {
+                    mLogger.printError("argument to '-l' is missing.");
+                    return Result::Fail;
                 }
 
-                // "-ipath/"
-                else {
-                    path = 2 + argv[i];
-                }
+                numberString = argv[i];
+            }
 
-                if (!path.empty()) {
-                    path = Path::removeQuotationMarks(path);
-                    path = Path::fromNativeSeparators(path);
-                    path = Path::simplifyPath(path);
+            // "-l3"
+            else
+                numberString = argv[i]+2;
 
-                    if (FileLister::isDirectory(path)) {
-                        // If directory name doesn't end with / or \, add it
-                        if (!endsWith(path, '/'))
-                            path += '/';
-                    }
-                    mIgnoredPaths.push_back(path);
+            int tmp;
+            std::string err;
+            if (!strToInt(numberString, tmp, &err)) {
+                mLogger.printError("argument to '-l' is not valid - " + err + ".");
+                return Result::Fail;
+            }
+            mSettings.loadAverage = tmp;
+#else
+            mLogger.printError("Option -l cannot be used as Cppcheck has not been built with fork threading model.");
+            return Result::Fail;
+#endif
+        }
+
+        // Enforce language (--language=, -x)
+        else if (std::strncmp(argv[i], "--language=", 11) == 0 || std::strcmp(argv[i], "-x") == 0) {
+            std::string str;
+            if (argv[i][2]) {
+                str = argv[i]+11;
+            } else {
+                i++;
+                if (i >= argc || argv[i][0] == '-') {
+                    mLogger.printError("no language given to '-x' option.");
+                    return Result::Fail;
                 }
+                str = argv[i];
             }
 
-            // --library
-            else if (std::strncmp(argv[i], "--library=", 10) == 0) {
-                std::string lib(argv[i] + 10);
-                mSettings->libraries.push_back(lib);
-            }
-
-            // --project
-            else if (std::strncmp(argv[i], "--project=", 10) == 0) {
-                const std::string projectFile = argv[i]+10;
-                ImportProject::Type projType = mSettings->project.import(projectFile, mSettings);
-                if (projType == ImportProject::Type::CPPCHECK_GUI) {
-                    mPathNames = mSettings->project.guiProject.pathNames;
-                    for (const std::string &lib : mSettings->project.guiProject.libraries)
-                        mSettings->libraries.push_back(lib);
-
-                    for (const std::string &ignorePath : mSettings->project.guiProject.excludedPaths)
-                        mIgnoredPaths.emplace_back(ignorePath);
-
-                    const std::string platform(mSettings->project.guiProject.platform);
-
-                    if (platform == "win32A")
-                        mSettings->platform(Settings::Win32A);
-                    else if (platform == "win32W")
-                        mSettings->platform(Settings::Win32W);
-                    else if (platform == "win64")
-                        mSettings->platform(Settings::Win64);
-                    else if (platform == "unix32")
-                        mSettings->platform(Settings::Unix32);
-                    else if (platform == "unix64")
-                        mSettings->platform(Settings::Unix64);
-                    else if (platform == "native")
-                        mSettings->platform(Settings::Native);
-                    else if (platform == "unspecified" || platform == "Unspecified" || platform == "")
-                        ;
-                    else if (!mSettings->loadPlatformFile(argv[0], platform)) {
-                        std::string message("cppcheck: error: unrecognized platform: \"");
-                        message += platform;
-                        message += "\".";
-                        printMessage(message);
-                        return false;
-                    }
+            if (str == "c")
+                mEnforcedLang = Standards::Language::C;
+            else if (str == "c++")
+                mEnforcedLang = Standards::Language::CPP;
+            else {
+                mLogger.printError("unknown language '" + str + "' enforced.");
+                return Result::Fail;
+            }
+        }
 
-                    if (!mSettings->project.guiProject.projectFile.empty())
-                        projType = mSettings->project.import(mSettings->project.guiProject.projectFile, mSettings);
-                }
-                if (projType == ImportProject::Type::VS_SLN || projType == ImportProject::Type::VS_VCXPROJ) {
-                    if (mSettings->project.guiProject.analyzeAllVsConfigs == "false")
-                        mSettings->project.selectOneVsConfig(mSettings->platformType);
-                    if (!CppCheckExecutor::tryLoadLibrary(mSettings->library, argv[0], "windows.cfg")) {
-                        // This shouldn't happen normally.
-                        printMessage("cppcheck: Failed to load 'windows.cfg'. Your Cppcheck installation is broken. Please re-install.");
-                        return false;
-                    }
-                }
-                if (projType == ImportProject::Type::MISSING) {
-                    printMessage("cppcheck: Failed to open project '" + projectFile + "'.");
-                    return false;
-                }
-                if (projType == ImportProject::Type::UNKNOWN) {
-                    printMessage("cppcheck: Failed to load project '" + projectFile + "'. The format is unknown.");
-                    return false;
+        // --library
+        else if (std::strncmp(argv[i], "--library=", 10) == 0) {
+            std::vector<std::string> libs = splitString(argv[i] + 10, ',');
+            for (auto& l : libs) {
+                if (l.empty()) {
+                    mLogger.printError("empty library specified.");
+                    return Result::Fail;
                 }
+                mSettings.libraries.emplace_back(std::move(l));
             }
+        }
 
-            // Report progress
-            else if (std::strcmp(argv[i], "--report-progress") == 0) {
-                mSettings->reportProgress = true;
-            }
-
-            // --std
-            else if (std::strcmp(argv[i], "--std=posix") == 0) {
-                printMessage("cppcheck: Option --std=posix is deprecated and will be removed in 1.95.");
-            } else if (std::strcmp(argv[i], "--std=c89") == 0) {
-                mSettings->standards.c = Standards::C89;
-            } else if (std::strcmp(argv[i], "--std=c99") == 0) {
-                mSettings->standards.c = Standards::C99;
-            } else if (std::strcmp(argv[i], "--std=c11") == 0) {
-                mSettings->standards.c = Standards::C11;
-            } else if (std::strcmp(argv[i], "--std=c++03") == 0) {
-                mSettings->standards.cpp = Standards::CPP03;
-            } else if (std::strcmp(argv[i], "--std=c++11") == 0) {
-                mSettings->standards.cpp = Standards::CPP11;
-            } else if (std::strcmp(argv[i], "--std=c++14") == 0) {
-                mSettings->standards.cpp = Standards::CPP14;
-            } else if (std::strcmp(argv[i], "--std=c++17") == 0) {
-                mSettings->standards.cpp = Standards::CPP17;
-            } else if (std::strcmp(argv[i], "--std=c++20") == 0) {
-                mSettings->standards.cpp = Standards::CPP20;
-            }
-
-            // Output formatter
-            else if (std::strcmp(argv[i], "--template") == 0 ||
-                     std::strncmp(argv[i], "--template=", 11) == 0) {
-                // "--template format"
-                if (argv[i][10] == '=')
-                    mSettings->templateFormat = argv[i] + 11;
-                else if ((i+1) < argc && argv[i+1][0] != '-') {
-                    ++i;
-                    mSettings->templateFormat = argv[i];
-                } else {
-                    printMessage("cppcheck: argument to '--template' is missing.");
-                    return false;
-                }
+        // Set maximum number of #ifdef configurations to check
+        else if (std::strncmp(argv[i], "--max-configs=", 14) == 0) {
+            int tmp;
+            if (!parseNumberArg(argv[i], 14, tmp))
+                return Result::Fail;
+            if (tmp < 1) {
+                mLogger.printError("argument to '--max-configs=' must be greater than 0.");
+                return Result::Fail;
+            }
 
-                if (mSettings->templateFormat == "gcc") {
-                    mSettings->templateFormat = "{file}:{line}:{column}: warning: {message} [{id}]\\n{code}";
-                    mSettings->templateLocation = "{file}:{line}:{column}: note: {info}\\n{code}";
-                } else if (mSettings->templateFormat == "daca2") {
-                    mSettings->templateFormat = "{file}:{line}:{column}: {severity}: {message} [{id}]";
-                    mSettings->templateLocation = "{file}:{line}:{column}: note: {info}";
-                } else if (mSettings->templateFormat == "vs")
-                    mSettings->templateFormat = "{file}({line}): {severity}: {message}";
-                else if (mSettings->templateFormat == "edit")
-                    mSettings->templateFormat = "{file} +{line}: {severity}: {message}";
-                else if (mSettings->templateFormat == "cppcheck1")
-                    mSettings->templateFormat = "{callstack}: ({severity}{inconclusive:, inconclusive}) {message}";
-            }
-
-            else if (std::strcmp(argv[i], "--template-location") == 0 ||
-                     std::strncmp(argv[i], "--template-location=", 20) == 0) {
-                // "--template-location format"
-                if (argv[i][19] == '=')
-                    mSettings->templateLocation = argv[i] + 20;
-                else if ((i+1) < argc && argv[i+1][0] != '-') {
-                    ++i;
-                    mSettings->templateLocation = argv[i];
-                } else {
-                    printMessage("cppcheck: argument to '--template' is missing.");
-                    return false;
-                }
+            mSettings.maxConfigsOption = tmp;
+            mSettings.force = false;
+        }
+
+        // max ctu depth
+        else if (std::strncmp(argv[i], "--max-ctu-depth=", 16) == 0) {
+            int temp = 0;
+            if (!parseNumberArg(argv[i], 16, temp))
+                return Result::Fail;
+            if (temp > 10) {
+                mLogger.printMessage("--max-ctu-depth is being capped at 10. This limitation will be removed in a future Cppcheck version.");
+                temp = 10;
             }
+            mSettings.maxCtuDepth = temp;
+        }
 
-            // Checking threads
-            else if (std::strncmp(argv[i], "-j", 2) == 0) {
-                std::string numberString;
+        else if (std::strncmp(argv[i], "--max-template-recursion=", 25) == 0) {
+            if (!parseNumberArg(argv[i], 25, mSettings.maxTemplateRecursion))
+                return Result::Fail;
+        }
 
-                // "-j 3"
-                if (std::strcmp(argv[i], "-j") == 0) {
-                    ++i;
-                    if (i >= argc || argv[i][0] == '-') {
-                        printMessage("cppcheck: argument to '-j' is missing.");
-                        return false;
-                    }
+        else if (std::strcmp(argv[i],"--no-analyze-all-vs-configs") == 0) {
+            mSettings.analyzeAllVsConfigs = false;
+            mAnalyzeAllVsConfigsSetOnCmdLine = true;
+        }
 
-                    numberString = argv[i];
-                }
+        else if (std::strcmp(argv[i], "--no-check-headers") == 0)
+            mSettings.checkHeaders = false;
 
-                // "-j3"
-                else
-                    numberString = argv[i]+2;
+        else if (std::strcmp(argv[i], "--no-check-unused-templates") == 0)
+            mSettings.checkUnusedTemplates = false;
 
-                std::istringstream iss(numberString);
-                if (!(iss >> mSettings->jobs)) {
-                    printMessage("cppcheck: argument to '-j' is not a number.");
-                    return false;
-                }
+        // undocumented option for usage in Python tests to indicate that no build dir should be injected
+        else if (std::strcmp(argv[i], "--no-cppcheck-build-dir") == 0) {
+            mSettings.buildDir.clear();
+        }
 
-                if (mSettings->jobs > 10000) {
-                    // This limit is here just to catch typos. If someone has
-                    // need for more jobs, this value should be increased.
-                    printMessage("cppcheck: argument for '-j' is allowed to be 10000 at max.");
-                    return false;
-                }
-            } else if (std::strncmp(argv[i], "-l", 2) == 0) {
-                std::string numberString;
-
-                // "-l 3"
-                if (std::strcmp(argv[i], "-l") == 0) {
-                    ++i;
-                    if (i >= argc || argv[i][0] == '-') {
-                        printMessage("cppcheck: argument to '-l' is missing.");
-                        return false;
-                    }
+        else if (std::strcmp(argv[i], "--no-cpp-header-probe") == 0) {
+            mSettings.cppHeaderProbe = false;
+        }
 
-                    numberString = argv[i];
-                }
+        else if (std::strcmp(argv[i], "--no-safety") == 0)
+            mSettings.safety = false;
 
-                // "-l3"
-                else
-                    numberString = argv[i]+2;
+        // Write results in file
+        else if (std::strncmp(argv[i], "--output-file=", 14) == 0)
+            mSettings.outputFile = Path::simplifyPath(argv[i] + 14);
 
-                std::istringstream iss(numberString);
-                if (!(iss >> mSettings->loadAverage)) {
-                    printMessage("cppcheck: argument to '-l' is not a number.");
-                    return false;
-                }
+        else if (std::strncmp(argv[i], "--output-format=", 16) == 0) {
+            if (xmlOptionProvided) {
+                outputFormatOptionMixingError();
+                return Result::Fail;
+            }
+            const std::string format = argv[i] + 16;
+            // plist can not be handled here because it requires additional data
+            if (format == "text")
+                mSettings.outputFormat = Settings::OutputFormat::text;
+            else if (format == "sarif")
+                mSettings.outputFormat = Settings::OutputFormat::sarif;
+            else if (format == "xml")
+                mSettings.outputFormat = Settings::OutputFormat::xml;
+            else if (format == "xmlv2") {
+                mSettings.outputFormat = Settings::OutputFormat::xml;
+                mSettings.xml_version = 2;
+            } else if (format == "xmlv3") {
+                mSettings.outputFormat = Settings::OutputFormat::xml;
+                mSettings.xml_version = 3;
+            } else {
+                mLogger.printError("argument to '--output-format=' must be 'text', 'sarif', 'xml' (deprecated), 'xmlv2' or 'xmlv3'.");
+                return Result::Fail;
             }
+            mSettings.plistOutput = "";
+            outputFormatOptionProvided = true;
+        }
 
-            // print all possible error messages..
-            else if (std::strcmp(argv[i], "--errorlist") == 0) {
-                mShowErrorMessages = true;
-                mSettings->xml = true;
-                mExitAfterPrint = true;
+
+        // Experimental: limit execution time for extended valueflow analysis. basic valueflow analysis
+        // is always executed.
+        else if (std::strncmp(argv[i], "--performance-valueflow-max-time=", 33) == 0) {
+            if (!parseNumberArg(argv[i], 33, mSettings.vfOptions.maxTime, true))
+                return Result::Fail;
+        }
+
+        else if (std::strncmp(argv[i], "--performance-valueflow-max-if-count=", 37) == 0) {
+            if (!parseNumberArg(argv[i], 37, mSettings.vfOptions.maxIfCount, true))
+                return Result::Fail;
+        }
+
+        else if (std::strncmp(argv[i], "--performance-valueflow-max-iterations=", 39) == 0) {
+            if (!parseNumberArg(argv[i], 39, mSettings.vfOptions.maxIterations, true))
+                return Result::Fail;
+        }
+
+        // Specify platform
+        else if (std::strncmp(argv[i], "--platform=", 11) == 0) {
+            std::string p = 11 + argv[i];
+            if (p.empty()) {
+                mLogger.printError("empty platform specified.");
+                return Result::Fail;
+            }
+            platform = std::move(p);
+        }
+
+        // Write results in results.plist
+        else if (std::strncmp(argv[i], "--plist-output=", 15) == 0) {
+            std::string path = Path::simplifyPath(argv[i] + 15);
+            if (path.empty())
+                path = ".";
+
+            const std::string plistOutput = Path::toNativeSeparators(path);
+            if (!Path::isDirectory(plistOutput)) {
+                std::string message("plist folder does not exist: '");
+                message += plistOutput;
+                message += "'.";
+                mLogger.printError(message);
+                return Result::Fail;
+            }
+
+            if (!endsWith(path,'/'))
+                path += '/';
+
+            mSettings.outputFormat = Settings::OutputFormat::plist;
+            mSettings.plistOutput = std::move(path);
+        }
+
+        // Special Cppcheck Premium options
+        else if ((std::strncmp(argv[i], "--premium=", 10) == 0 || std::strncmp(argv[i], "--premium-", 10) == 0) && mSettings.premium) {
+            // valid options --premium=..
+            const std::set<std::string> valid{
+                "autosar",
+                "cert-c-2016",
+                "cert-c++-2016",
+                "cert-cpp-2016",
+                "cert-c",
+                "cert-c++",
+                "metrics",
+                "misra-c-2012",
+                "misra-c-2023",
+                "misra-c-2025",
+                "misra-c++-2008",
+                "misra-cpp-2008",
+                "misra-c++-2023",
+                "misra-cpp-2023",
+                "bughunting",
+                "safety",  // TODO: deprecate in favor of the regular --safety/--no-safety
+                "safety-profiles",
+                "debug-progress"};
+            // valid options --premium-..=
+            const std::set<std::string> valid2{
+                "cert-c-int-precision",
+                "license-file"
+            };
+
+            if (std::strcmp(argv[i], "--premium=safety-off") == 0) {
+                mSettings.safety = false;
+                continue;
+            }
+            if (std::strcmp(argv[i], "--premium=safety") == 0)
+                mSettings.safety = true;
+            if (!mSettings.premiumArgs.empty())
+                mSettings.premiumArgs += " ";
+            const std::string p(argv[i] + 10);
+            const std::string p2(p.find('=') != std::string::npos ? p.substr(0, p.find('=')) : "");
+            const bool isCodingStandard = startsWith(p, "autosar") || startsWith(p,"cert-") || startsWith(p,"misra-") || p == "safety-profiles";
+            const std::string p3(endsWith(p,":all") && isCodingStandard ? p.substr(0,p.rfind(':')) : p);
+            if (!valid.count(p3) && !valid2.count(p2)) {
+                mLogger.printError("invalid --premium option '" + (p2.empty() ? p : p2) + "'.");
+                return Result::Fail;
+            }
+            mSettings.premiumArgs += "--" + p;
+            if (isCodingStandard) {
+                // All checkers related to the coding standard should be enabled. The coding standards
+                // do not all undefined behavior or portability issues.
+                mSettings.addEnabled("warning");
+                mSettings.addEnabled("portability");
+            }
+        }
+
+        // --project
+        else if (std::strncmp(argv[i], "--project=", 10) == 0) {
+            if (projectType != ImportProject::Type::NONE)
+            {
+                mLogger.printError("multiple --project options are not supported.");
+                return Result::Fail;
             }
 
-            // documentation..
-            else if (std::strcmp(argv[i], "--doc") == 0) {
-                std::ostringstream doc;
-                // Get documentation..
-                for (const Check * it : Check::instances()) {
-                    const std::string& name(it->name());
-                    const std::string info(it->classInfo());
-                    if (!name.empty() && !info.empty())
-                        doc << "## " << name << " ##\n"
-                            << info << "\n";
+            std::string projectFile = argv[i]+10;
+            projectType = project.import(projectFile, &mSettings, &mSuppressions);
+            if (projectType == ImportProject::Type::CPPCHECK_GUI) {
+                for (const std::string &lib : project.guiProject.libraries)
+                    mSettings.libraries.emplace_back(lib);
+
+                const auto& excludedPaths = project.guiProject.excludedPaths;
+                std::copy(excludedPaths.cbegin(), excludedPaths.cend(), std::back_inserter(mIgnoredPaths));
+
+                if (!project.guiProject.platform.empty())
+                    platform = project.guiProject.platform;
+
+                // look for external files relative to project first
+                lookupPaths.insert(lookupPaths.cbegin(), Path::getPathFromFilename(projectFile));
+
+                const auto& projectFileGui = project.guiProject.projectFile;
+                if (!projectFileGui.empty()) {
+                    // read underlying project
+                    projectFile = projectFileGui;
+                    projectType = project.import(projectFileGui, &mSettings, &mSuppressions);
+                    if (projectType == ImportProject::Type::CPPCHECK_GUI) {
+                        mLogger.printError("nested Cppcheck GUI projects are not supported.");
+                        return Result::Fail;
+                    }
                 }
+            }
+            if (projectType == ImportProject::Type::COMPILE_DB)
+                mSettings.maxConfigsProject = 1;
+            if (projectType == ImportProject::Type::VS_SLN || projectType == ImportProject::Type::VS_VCXPROJ) {
+                mSettings.libraries.emplace_back("windows");
+            }
+            for (const auto &error : project.errors)
+                mLogger.printError(error);
+            if (projectType == ImportProject::Type::MISSING) {
+                mLogger.printError("failed to open project '" + projectFile + "'. The file does not exist.");
+                return Result::Fail;
+            }
+            if (projectType == ImportProject::Type::UNKNOWN) {
+                mLogger.printError("failed to load project '" + projectFile + "'. The format is unknown.");
+                return Result::Fail;
+            }
+            if (projectType == ImportProject::Type::FAILURE) {
+                mLogger.printError("failed to load project '" + projectFile + "'. An error occurred.");
+                return Result::Fail;
+            }
+        }
+
+        // --project-configuration
+        else if (std::strncmp(argv[i], "--project-configuration=", 24) == 0) {
+            vsConfig = argv[i] + 24;
+            if (vsConfig.empty()) {
+                mLogger.printError("--project-configuration parameter is empty.");
+                return Result::Fail;
+            }
+            if (projectType != ImportProject::Type::VS_SLN && projectType != ImportProject::Type::VS_VCXPROJ) {
+                mLogger.printError("--project-configuration has no effect - no Visual Studio project provided.");
+                return Result::Fail;
+            }
+        }
 
-                std::cout << doc.str();
-                mExitAfterPrint = true;
-                return true;
-            }
-
-            // show timing information..
-            else if (std::strncmp(argv[i], "--showtime=", 11) == 0) {
-                const std::string showtimeMode = argv[i] + 11;
-                if (showtimeMode == "file")
-                    mSettings->showtime = SHOWTIME_MODES::SHOWTIME_FILE;
-                else if (showtimeMode == "summary")
-                    mSettings->showtime = SHOWTIME_MODES::SHOWTIME_SUMMARY;
-                else if (showtimeMode == "top5")
-                    mSettings->showtime = SHOWTIME_MODES::SHOWTIME_TOP5;
-                else if (showtimeMode.empty())
-                    mSettings->showtime = SHOWTIME_MODES::SHOWTIME_NONE;
-                else {
-                    std::string message("cppcheck: error: unrecognized showtime mode: \"");
-                    message += showtimeMode;
-                    message += "\". Supported modes: file, summary, top5.";
-                    printMessage(message);
-                    return false;
+        // Only print something when there are errors
+        else if (std::strcmp(argv[i], "-q") == 0 || std::strcmp(argv[i], "--quiet") == 0)
+            mSettings.quiet = true;
+
+        // Output relative paths
+        else if (std::strcmp(argv[i], "-rp") == 0 || std::strcmp(argv[i], "--relative-paths") == 0)
+            mSettings.relativePaths = true;
+        else if (std::strncmp(argv[i], "-rp=", 4) == 0 || std::strncmp(argv[i], "--relative-paths=", 17) == 0) {
+            mSettings.relativePaths = true;
+            if (argv[i][argv[i][3]=='='?4:17] != 0) {
+                std::string paths = argv[i]+(argv[i][3]=='='?4:17);
+                for (;;) {
+                    const std::string::size_type pos = paths.find(';');
+                    if (pos == std::string::npos) {
+                        mSettings.basePaths.emplace_back(Path::fromNativeSeparators(std::move(paths)));
+                        break;
+                    }
+                    mSettings.basePaths.emplace_back(Path::fromNativeSeparators(paths.substr(0, pos)));
+                    paths.erase(0, pos + 1);
                 }
+            } else {
+                mLogger.printError("no paths specified for the '" + std::string(argv[i]) + "' option.");
+                return Result::Fail;
             }
+        }
+
+        // Report progress
+        else if (std::strcmp(argv[i], "--report-progress") == 0) {
+            mSettings.reportProgress = 10;
+        }
 
+        else if (std::strncmp(argv[i], "--report-progress=", 18) == 0) {
+            if (!parseNumberArg(argv[i], 18, mSettings.reportProgress, true))
+                return Result::Fail;
+        }
+
+        else if (std::strncmp(argv[i], "--report-type=", 14) == 0) {
+            const std::string typeStr = argv[i] + 14;
+            if (typeStr == "normal") {
+                mSettings.reportType = ReportType::normal;
+            } else if (typeStr == "autosar") {
+                mSettings.reportType = ReportType::autosar;
+            } else if (typeStr == "cert-c-2016") {
+                mSettings.reportType = ReportType::certC;
+            } else if (typeStr == "cert-cpp-2016") {
+                mSettings.reportType = ReportType::certCpp;
+            } else if (typeStr == "misra-c-2012") {
+                mSettings.reportType = ReportType::misraC2012;
+            } else if (typeStr == "misra-c-2023") {
+                mSettings.reportType = ReportType::misraC2023;
+            } else if (typeStr == "misra-c-2025") {
+                mSettings.reportType = ReportType::misraC2025;
+            } else if (typeStr == "misra-cpp-2008") {
+                mSettings.reportType = ReportType::misraCpp2008;
+            } else if (typeStr == "misra-cpp-2023") {
+                mSettings.reportType = ReportType::misraCpp2023;
+            } else {
+                mLogger.printError("Unknown report type \'" + typeStr + "\'");
+                return Result::Fail;
+            }
+        }
+
+        // Rule given at command line
+        else if (std::strncmp(argv[i], "--rule=", 7) == 0) {
 #ifdef HAVE_RULES
-            // Rule given at command line
-            else if (std::strncmp(argv[i], "--rule=", 7) == 0) {
-                Settings::Rule rule;
-                rule.pattern = 7 + argv[i];
-                mSettings->rules.push_back(rule);
-            }
-
-            // Rule file
-            else if (std::strncmp(argv[i], "--rule-file=", 12) == 0) {
-                tinyxml2::XMLDocument doc;
-                if (doc.LoadFile(12+argv[i]) == tinyxml2::XML_SUCCESS) {
-                    tinyxml2::XMLElement *node = doc.FirstChildElement();
-                    for (; node && strcmp(node->Value(), "rule") == 0; node = node->NextSiblingElement()) {
-                        Settings::Rule rule;
-
-                        tinyxml2::XMLElement *tokenlist = node->FirstChildElement("tokenlist");
-                        if (tokenlist)
-                            rule.tokenlist = tokenlist->GetText();
-
-                        tinyxml2::XMLElement *pattern = node->FirstChildElement("pattern");
-                        if (pattern) {
-                            rule.pattern = pattern->GetText();
-                        }
+            Settings::Rule rule;
+            rule.pattern = 7 + argv[i];
 
-                        tinyxml2::XMLElement *message = node->FirstChildElement("message");
-                        if (message) {
-                            tinyxml2::XMLElement *severity = message->FirstChildElement("severity");
-                            if (severity)
-                                rule.severity = Severity::fromString(severity->GetText());
+            if (rule.pattern.empty()) {
+                mLogger.printError("no rule pattern provided.");
+                return Result::Fail;
+            }
 
-                            tinyxml2::XMLElement *id = message->FirstChildElement("id");
-                            if (id)
-                                rule.id = id->GetText();
+            std::string regex_err;
+            auto regex = Regex::create(rule.pattern, regex_err);
+            if (!regex) {
+                mLogger.printError("failed to compile rule pattern '" + rule.pattern + "' (" + regex_err + ").");
+                return Result::Fail;
+            }
+            rule.regex = std::move(regex);
+            mSettings.rules.emplace_back(std::move(rule));
+#else
+            mLogger.printError("Option --rule cannot be used as Cppcheck has not been built with rules support.");
+            return Result::Fail;
+#endif
+        }
 
-                            tinyxml2::XMLElement *summary = message->FirstChildElement("summary");
-                            if (summary)
-                                rule.summary = summary->GetText() ? summary->GetText() : "";
+        // Rule file
+        else if (std::strncmp(argv[i], "--rule-file=", 12) == 0) {
+#ifdef HAVE_RULES
+            // TODO: improved error handling - wrong root node, etc.
+            // TODO: consume unused "version" attribute
+            const std::string ruleFile = argv[i] + 12;
+            tinyxml2::XMLDocument doc;
+            const tinyxml2::XMLError err = doc.LoadFile(ruleFile.c_str());
+            if (err == tinyxml2::XML_SUCCESS) {
+                const tinyxml2::XMLElement *node = doc.FirstChildElement();
+                // check if it is a single or multi rule configuration
+                if (node && strcmp(node->Value(), "rules") == 0)
+                    node = node->FirstChildElement("rule");
+                for (; node && strcmp(node->Value(), "rule") == 0; node = node->NextSiblingElement()) {
+                    Settings::Rule rule;
+
+                    for (const tinyxml2::XMLElement *subnode = node->FirstChildElement(); subnode; subnode = subnode->NextSiblingElement()) {
+                        const char * const subname = subnode->Name();
+                        const char * const subtext = subnode->GetText();
+                        if (std::strcmp(subname, "tokenlist") == 0) {
+                            rule.tokenlist = empty_if_null(subtext);
+                        }
+                        else if (std::strcmp(subname, "pattern") == 0) {
+                            rule.pattern = empty_if_null(subtext);
+                        }
+                        else if (std::strcmp(subname, "message") == 0) {
+                            for (const tinyxml2::XMLElement *msgnode = subnode->FirstChildElement(); msgnode; msgnode = msgnode->NextSiblingElement()) {
+                                const char * const msgname = msgnode->Name();
+                                const char * const msgtext = msgnode->GetText();
+                                if (std::strcmp(msgname, "severity") == 0) {
+                                    rule.severity = severityFromString(empty_if_null(msgtext));
+                                }
+                                else if (std::strcmp(msgname, "id") == 0) {
+                                    rule.id = empty_if_null(msgtext);
+                                }
+                                else if (std::strcmp(msgname, "summary") == 0) {
+                                    rule.summary = empty_if_null(msgtext);
+                                }
+                                else {
+                                    mLogger.printError("unable to load rule-file '" + ruleFile + "' - unknown element '" + msgname + "' encountered in 'message'.");
+                                    return Result::Fail;
+                                }
+                            }
                         }
+                        else {
+                            mLogger.printError("unable to load rule-file '" + ruleFile + "' - unknown element '" + subname + "' encountered in 'rule'.");
+                            return Result::Fail;
+                        }
+                    }
+
+                    if (rule.pattern.empty()) {
+                        mLogger.printError("unable to load rule-file '" + ruleFile + "' - a rule is lacking a pattern.");
+                        return Result::Fail;
+                    }
+
+                    if (rule.id.empty()) {
+                        mLogger.printError("unable to load rule-file '" + ruleFile + "' - a rule is lacking an id.");
+                        return Result::Fail;
+                    }
 
-                        if (!rule.pattern.empty())
-                            mSettings->rules.push_back(rule);
+                    if (rule.tokenlist.empty()) {
+                        mLogger.printError("unable to load rule-file '" + ruleFile + "' - a rule is lacking a tokenlist.");
+                        return Result::Fail;
                     }
-                } else {
-                    printMessage("cppcheck: error: unable to load rule-file: " + std::string(12+argv[i]));
-                    return false;
+
+                    if (rule.tokenlist != "normal" && rule.tokenlist != "define" && rule.tokenlist != "raw") {
+                        mLogger.printError("unable to load rule-file '" + ruleFile + "' - a rule is using the unsupported tokenlist '" + rule.tokenlist + "'.");
+                        return Result::Fail;
+                    }
+
+                    std::string regex_err;
+                    auto regex = Regex::create(rule.pattern, regex_err);
+                    if (!regex) {
+                        mLogger.printError("unable to load rule-file '" + ruleFile + "' - pattern '" + rule.pattern + "' failed to compile (" + regex_err + ").");
+                        return Result::Fail;
+                    }
+                    rule.regex = std::move(regex);
+
+                    if (rule.severity == Severity::none) {
+                        mLogger.printError("unable to load rule-file '" + ruleFile + "' - a rule has an invalid severity.");
+                        return Result::Fail;
+                    }
+
+                    mSettings.rules.emplace_back(std::move(rule));
                 }
+            } else {
+                mLogger.printError("unable to load rule-file '" + ruleFile + "' (" + tinyxml2::XMLDocument::ErrorIDToName(err) + ").");
+                return Result::Fail;
             }
+#else
+            mLogger.printError("Option --rule-file cannot be used as Cppcheck has not been built with rules support.");
+            return Result::Fail;
 #endif
+        }
 
-            // Specify platform
-            else if (std::strncmp(argv[i], "--platform=", 11) == 0) {
-                const std::string platform(11+argv[i]);
-
-                if (platform == "win32A")
-                    mSettings->platform(Settings::Win32A);
-                else if (platform == "win32W")
-                    mSettings->platform(Settings::Win32W);
-                else if (platform == "win64")
-                    mSettings->platform(Settings::Win64);
-                else if (platform == "unix32")
-                    mSettings->platform(Settings::Unix32);
-                else if (platform == "unix64")
-                    mSettings->platform(Settings::Unix64);
-                else if (platform == "native")
-                    mSettings->platform(Settings::Native);
-                else if (platform == "unspecified")
-                    mSettings->platform(Settings::Unspecified);
-                else if (!mSettings->loadPlatformFile(argv[0], platform)) {
-                    std::string message("cppcheck: error: unrecognized platform: \"");
-                    message += platform;
-                    message += "\".";
-                    printMessage(message);
-                    return false;
-                }
+        // Safety certified behavior
+        else if (std::strcmp(argv[i], "--safety") == 0)
+            mSettings.safety = true;
+
+        // show timing information..
+        else if (std::strncmp(argv[i], "--showtime=", 11) == 0) {
+            const std::string showtimeMode = argv[i] + 11;
+            if (showtimeMode == "file")
+                mSettings.showtime = ShowTime::FILE;
+            else if (showtimeMode == "file-total")
+                mSettings.showtime = ShowTime::FILE_TOTAL;
+            else if (showtimeMode == "summary")
+                mSettings.showtime = ShowTime::SUMMARY;
+            else if (showtimeMode == "top5_file")
+                mSettings.showtime = ShowTime::TOP5_FILE;
+            else if (showtimeMode == "top5_summary")
+                mSettings.showtime = ShowTime::TOP5_SUMMARY;
+            else if (showtimeMode == "none")
+                mSettings.showtime = ShowTime::NONE;
+            else if (showtimeMode.empty()) {
+                mLogger.printError("no mode provided for --showtime");
+                return Result::Fail;
             }
+            else {
+                mLogger.printError("unrecognized --showtime mode: '" + showtimeMode + "'. Supported modes: file, file-total, summary, top5_file, top5_summary.");
+                return Result::Fail;
+            }
+        }
 
-            // Set maximum number of #ifdef configurations to check
-            else if (std::strncmp(argv[i], "--max-configs=", 14) == 0) {
-                mSettings->force = false;
+        // --std
+        else if (std::strncmp(argv[i], "--std=", 6) == 0) {
+            const std::string std = argv[i] + 6;
+            if (!mSettings.standards.setStd(std)) {
+                mLogger.printError("unknown --std value '" + std + "'");
+                return Result::Fail;
+            }
+        }
 
-                std::istringstream iss(14+argv[i]);
-                if (!(iss >> mSettings->maxConfigs)) {
-                    printMessage("cppcheck: argument to '--max-configs=' is not a number.");
-                    return false;
-                }
+        else if (std::strncmp(argv[i], "--suppress=", 11) == 0) {
+            const std::string suppression = argv[i]+11;
+            const std::string errmsg(mSuppressions.nomsg.addSuppressionLine(suppression));
+            if (!errmsg.empty()) {
+                mLogger.printError(errmsg);
+                return Result::Fail;
+            }
+        }
 
-                if (mSettings->maxConfigs < 1) {
-                    printMessage("cppcheck: argument to '--max-configs=' must be greater than 0.");
-                    return false;
+        // Filter errors
+        else if (std::strncmp(argv[i], "--suppressions-list=", 20) == 0) {
+            std::string filename = argv[i]+20;
+            std::ifstream f(filename);
+            if (!f.is_open()) {
+                std::string message("couldn't open the file: \"");
+                message += filename;
+                message += "\".";
+                if (std::count(filename.cbegin(), filename.cend(), ',') > 0 ||
+                    std::count(filename.cbegin(), filename.cend(), '.') > 1) {
+                    // If user tried to pass multiple files (we can only guess that)
+                    // e.g. like this: --suppressions-list=a.txt,b.txt
+                    // print more detailed error message to tell user how he can solve the problem
+                    message += "\nIf you want to pass two files, you can do it e.g. like this:";
+                    message += "\n    cppcheck --suppressions-list=a.txt --suppressions-list=b.txt file.cpp";
                 }
 
-                maxconfigs = true;
+                mLogger.printError(message);
+                return Result::Fail;
             }
+            const std::string errmsg(mSuppressions.nomsg.parseFile(f));
+            if (!errmsg.empty()) {
+                mLogger.printError(errmsg);
+                return Result::Fail;
+            }
+        }
 
-            // Print help
-            else if (std::strcmp(argv[i], "-h") == 0 || std::strcmp(argv[i], "--help") == 0) {
-                mPathNames.clear();
-                mShowHelp = true;
-                mExitAfterPrint = true;
-                break;
+        else if (std::strncmp(argv[i], "--suppress-xml=", 15) == 0) {
+            const char * filename = argv[i] + 15;
+            const std::string errmsg(mSuppressions.nomsg.parseXmlFile(filename));
+            if (!errmsg.empty()) {
+                mLogger.printError(errmsg);
+                return Result::Fail;
             }
+        }
 
-            else {
-                std::string message("cppcheck: error: unrecognized command line option: \"");
-                message += argv[i];
-                message += "\".";
-                printMessage(message);
-                return false;
+        // Output formatter
+        else if (std::strncmp(argv[i], "--template=", 11) == 0) {
+            mSettings.templateFormat = argv[i] + 11;
+            // TODO: bail out when no template is provided?
+
+            if (mSettings.templateFormat == "gcc") {
+                mSettings.templateFormat = "{bold}{file}:{line}:{column}: {magenta}warning:{default} {message} [{id}]{reset}\\n{code}";
+                mSettings.templateLocation = "{bold}{file}:{line}:{column}: {dim}note:{reset} {info}\\n{code}";
+            } else if (mSettings.templateFormat == "daca2") {
+                mSettings.daca = true;
+                mSettings.templateFormat = "{file}:{line}:{column}: {severity}:{inconclusive:inconclusive:} {message} [{id}]";
+                mSettings.templateLocation = "{file}:{line}:{column}: note: {info}";
+            } else if (mSettings.templateFormat == "vs")
+                mSettings.templateFormat = "{file}({line}): {severity}: {message}";
+            else if (mSettings.templateFormat == "edit")
+                mSettings.templateFormat = "{file} +{line}: {severity}: {message}";
+            else if (mSettings.templateFormat == "cppcheck1")
+                mSettings.templateFormat = "{callstack}: ({severity}{inconclusive:, inconclusive}) {message}";
+            else if (mSettings.templateFormat == "selfcheck") {
+                mSettings.templateFormat = "{file}:{line}:{column}: {severity}:{inconclusive:inconclusive:} {message} [{id}]\\n{code}";
+                mSettings.templateLocation = "{file}:{line}:{column}: note: {info}\\n{code}";
+                mSettings.daca = true;
+            } else if (mSettings.templateFormat == "simple") {
+                mSettings.templateFormat = "{file}:{line}:{column}: {severity}:{inconclusive:inconclusive:} {message} [{id}]";
+                mSettings.templateLocation = "";
             }
+            // TODO: bail out when no placeholders are found?
+        }
+
+        else if (std::strncmp(argv[i], "--template-location=", 20) == 0) {
+            mSettings.templateLocation = argv[i] + 20;
+            // TODO: bail out when no template is provided?
+            // TODO: bail out when no placeholders are found?
+        }
+
+        else if (std::strncmp(argv[i], "--template-max-time=", 20) == 0) {
+            if (!parseNumberArg(argv[i], 20, mSettings.templateMaxTime))
+                return Result::Fail;
+        }
+
+        else if (std::strncmp(argv[i], "--typedef-max-time=", 19) == 0) {
+            if (!parseNumberArg(argv[i], 19, mSettings.typedefMaxTime))
+                return Result::Fail;
+        }
+
+        else if (std::strncmp(argv[i], "--valueflow-max-iterations=", 27) == 0) {
+            if (!parseNumberArg(argv[i], 27, mSettings.vfOptions.maxIterations))
+                return Result::Fail;
+        }
+
+        else if (std::strcmp(argv[i], "-v") == 0 || std::strcmp(argv[i], "--verbose") == 0)
+            mSettings.verbose = true;
+
+        // Write results in results.xml
+        else if (std::strcmp(argv[i], "--xml") == 0) {
+            if (outputFormatOptionProvided) {
+                outputFormatOptionMixingError();
+                return Result::Fail;
+            }
+            mSettings.outputFormat = Settings::OutputFormat::xml;
+            xmlOptionProvided = true;
+        }
+
+        // Define the XML file version (and enable XML output)
+        else if (std::strncmp(argv[i], "--xml-version=", 14) == 0) {
+            if (outputFormatOptionProvided) {
+                outputFormatOptionMixingError();
+                return Result::Fail;
+            }
+            int tmp;
+            if (!parseNumberArg(argv[i], 14, tmp))
+                return Result::Fail;
+            if (tmp != 2 && tmp != 3) {
+                // We only have xml version 2 and 3
+                mLogger.printError("'--xml-version' can only be 2 or 3.");
+                return Result::Fail;
+            }
+
+            mSettings.xml_version = tmp;
+            // Enable also XML if version is set
+            mSettings.outputFormat = Settings::OutputFormat::xml;
+            xmlOptionProvided = true;
         }
 
         else {
-            std::string path = Path::removeQuotationMarks(argv[i]);
-            path = Path::fromNativeSeparators(path);
-            mPathNames.push_back(path);
+            std::string message("unrecognized command line option: \"");
+            message += argv[i];
+            message += "\".";
+            mLogger.printError(message);
+            return Result::Fail;
         }
     }
 
+    // TODO: bail out?
+    if (!executorAuto && mSettings.useSingleJob())
+        mLogger.printMessage("'--executor' has no effect as only a single job will be used.");
+
     // Default template format..
-    if (mSettings->templateFormat.empty()) {
-        mSettings->templateFormat = "{file}:{line}:{column}: {severity}:{inconclusive:inconclusive:} {message} [{id}]\\n{code}";
-        if (mSettings->templateLocation.empty())
-            mSettings->templateLocation = "{file}:{line}:{column}: note: {info}\\n{code}";
+    if (mSettings.templateFormat.empty()) {
+        mSettings.templateFormat = "{bold}{file}:{line}:{column}: {red}{inconclusive:{magenta}}{severity}:{inconclusive: inconclusive:}{default} {message} [{id}]{reset}\\n{code}";
+        if (mSettings.templateLocation.empty())
+            mSettings.templateLocation = "{bold}{file}:{line}:{column}: {dim}note:{reset} {info}\\n{code}";
+    }
+    // replace static parts of the templates
+    substituteTemplateFormatStatic(mSettings.templateFormat, !mSettings.outputFile.empty());
+    substituteTemplateLocationStatic(mSettings.templateLocation, !mSettings.outputFile.empty());
+
+    if (debug) {
+        mSettings.debugnormal = true;
+        mSettings.debugvalueflow = true;
+        if (mSettings.verbose) {
+            mSettings.debugast = true;
+            mSettings.debugsymdb = true;
+        }
     }
 
-    mSettings->project.ignorePaths(mIgnoredPaths);
+    if (mSettings.jobs > 1 && mSettings.buildDir.empty()) {
+        // TODO: bail out instead?
+        if (mSettings.checks.isEnabled(Checks::unusedFunction))
+        {
+            mLogger.printMessage("unusedFunction check requires --cppcheck-build-dir to be active with -j.");
+            mSettings.checks.disable(Checks::unusedFunction);
+            // TODO: is there some later logic to remove?
+        }
+        // TODO: enable
+        //mLogger.printMessage("whole program analysis requires --cppcheck-build-dir to be active with -j.");
+    }
 
-    if (mSettings->force)
-        mSettings->maxConfigs = ~0U;
+    if (!mSettings.checks.isEnabled(Checks::unusedFunction))
+        mSettings.unmatchedSuppressionFilters.emplace_back("unusedFunction");
+    if (!mSettings.addons.count("misra"))
+        mSettings.unmatchedSuppressionFilters.emplace_back("misra-*");
+    if (!mSettings.premium)
+        mSettings.unmatchedSuppressionFilters.emplace_back("premium-*");
 
-    else if ((def || mSettings->preprocessOnly) && !maxconfigs)
-        mSettings->maxConfigs = 1U;
+    if (inputAsFilter) {
+        mSettings.fileFilters.insert(mSettings.fileFilters.end(), mPathNames.cbegin(), mPathNames.cend());
+        mPathNames.clear();
+    }
 
-    if (mSettings->isEnabled(Settings::UNUSED_FUNCTION) && mSettings->jobs > 1) {
-        printMessage("cppcheck: unusedFunction check can't be used with '-j' option. Disabling unusedFunction check.");
+    if (!mPathNames.empty() && projectType != ImportProject::Type::NONE) {
+        mLogger.printError("--project cannot be used in conjunction with source files.");
+        return Result::Fail;
     }
 
-    if (argc <= 1) {
-        mShowHelp = true;
-        mExitAfterPrint = true;
+    // TODO: conflicts with analyzeAllVsConfigs
+    if (!vsConfig.empty()) {
+        // TODO: bail out when this does nothing
+        project.ignoreOtherConfigs(vsConfig);
     }
 
-    if (mShowHelp) {
-        printHelp();
-        return true;
+    if (!platform.empty())
+    {
+        std::string errstr;
+        if (!mSettings.platform.set(platform, errstr, lookupPaths, mSettings.debuglookup || mSettings.debuglookupPlatform)) {
+            mLogger.printError(errstr);
+            return Result::Fail;
+        }
+    }
+
+    if (defaultSign != '\0')
+        mSettings.platform.defaultSign = defaultSign;
+
+    if (!mSettings.analyzeAllVsConfigs) {
+        if (projectType != ImportProject::Type::VS_SLN && projectType != ImportProject::Type::VS_VCXPROJ) {
+            if (mAnalyzeAllVsConfigsSetOnCmdLine) {
+                mLogger.printError("--no-analyze-all-vs-configs has no effect - no Visual Studio project provided.");
+                return Result::Fail;
+            }
+        } else {
+            // TODO: bail out when this does nothing
+            project.selectOneVsConfig(mSettings.platform.type);
+        }
+    }
+
+    if (!mSettings.buildDir.empty() && !Path::isDirectory(mSettings.buildDir)) {
+        mLogger.printError("Directory '" + mSettings.buildDir + "' specified by --cppcheck-build-dir argument has to be existent.");
+        return Result::Fail;
     }
 
     // Print error only if we have "real" command and expect files
-    if (!mExitAfterPrint && mPathNames.empty() && mSettings->project.fileSettings.empty()) {
-        printMessage("cppcheck: No C or C++ source files found.");
-        return false;
+    if (mPathNames.empty() && project.guiProject.pathNames.empty() && project.fileSettings.empty()) {
+        // TODO: this message differs from the one reported in fillSettingsFromArgs()
+        mLogger.printError("no C or C++ source files found.");
+        return Result::Fail;
+    }
+
+    for (auto& path : mIgnoredPaths)
+    {
+        path = Path::removeQuotationMarks(std::move(path));
+        path = Path::fromNativeSeparators(std::move(path));
+    }
+
+    if (!project.guiProject.pathNames.empty())
+        mPathNames = project.guiProject.pathNames;
+
+    if (!project.fileSettings.empty()) {
+        project.ignorePaths(mIgnoredPaths, mSettings.debugignore);
+        if (project.fileSettings.empty()) {
+            mLogger.printError("no C or C++ source files found.");
+            mLogger.printMessage("all paths were ignored"); // TODO: log this differently?
+            return Result::Fail;
+        }
+        mFileSettings = project.fileSettings;
+    }
+
+    if (mSettings.debugnormal && mSettings.outputFormat == Settings::OutputFormat::xml && (mPathNames.size() > 1 || mFileSettings.size() > 1))
+    {
+        mLogger.printError("printing debug output in XML format does not support multiple input files.");
+        return Result::Fail;
     }
 
     // Use paths _pathnames if no base paths for relative path output are given
-    if (mSettings->basePaths.empty() && mSettings->relativePaths)
-        mSettings->basePaths = mPathNames;
+    if (mSettings.basePaths.empty() && mSettings.relativePaths)
+        mSettings.basePaths = mPathNames;
 
+    return Result::Success;
+}
+
+void CmdLineParser::printHelp() const
+{
+    std::ostringstream oss;
+    // TODO: display product name
+    oss << "Cppcheck - A tool for static C/C++ code analysis\n"
+        "\n"
+        "Syntax:\n"
+        "    cppcheck [OPTIONS] [files or paths]\n"
+        "\n"
+        "If a directory is given instead of a filename, *.cpp, *.cxx, *.cc, *.c++, *.c, *.ipp,\n"
+        "*.ixx, *.tpp, and *.txx files are checked recursively from the given directory.\n\n"
+        "Options:\n"
+        "    --addon=<addon>\n"
+        "                         Execute addon. i.e. --addon=misra. If options must be\n"
+        "                         provided a json configuration is needed.\n"
+        "    --addon-python=<python interpreter>\n"
+        "                         You can specify the python interpreter either in the\n"
+        "                         addon json files or through this command line option.\n"
+        "                         If not present, Cppcheck will try \"python3\" first and\n"
+        "                         then \"python\".\n"
+        "    --cppcheck-build-dir=<dir>\n"
+        "                         Cppcheck work folder. Advantages:\n"
+        "                          * whole program analysis\n"
+        "                          * faster analysis; Cppcheck will reuse the results if\n"
+        "                            the hash for a file is unchanged.\n"
+        "                          * some useful debug information, i.e. commands used to\n"
+        "                            execute clang/clang-tidy/addons.\n"
+        "    --check-config       Check cppcheck configuration. The normal code\n"
+        "                         analysis is disabled by this flag.\n"
+        "    --check-level=<level>\n"
+        "                         Configure how much valueflow analysis you want:\n"
+        "                          * reduced: Reduce valueflow to finish checking quickly.\n"
+        "                          * normal: Cppcheck uses some compromises in the analysis so\n"
+        "                            the checking will finish in reasonable time.\n"
+        "                          * exhaustive: deeper analysis that you choose when you can\n"
+        "                            wait.\n"
+        "                         The default choice is 'normal'.\n"
+        "    --check-library      Show information messages when library files have\n"
+        "                         incomplete info.\n"
+        "    --checkers-report=<file>\n"
+        "                         Write a report of all the active checkers to the given file.\n"
+        "    --clang=<path>       Experimental: Use Clang parser instead of the builtin Cppcheck\n"
+        "                         parser. Takes the executable as optional parameter and\n"
+        "                         defaults to `clang`. Cppcheck will run the given Clang\n"
+        "                         executable, import the Clang AST and convert it into\n"
+        "                         Cppcheck data. After that the normal Cppcheck analysis is\n"
+        "                         used. You must have the executable in PATH if no path is\n"
+        "                         given.\n"
+        "    --config-exclude=<dir>\n"
+        "                         Path (prefix) to be excluded from configuration\n"
+        "                         checking. Preprocessor configurations defined in\n"
+        "                         headers (but not sources) matching the prefix will not\n"
+        "                         be considered for evaluation.\n"
+        "    --config-excludes-file=<file>\n"
+        "                         A file that contains a list of config-excludes\n"
+        "    --disable=<severity> Disable checks with the given severity.\n"
+        "                         Please refer to the documentation of --enable for\n"
+        "                         further details.\n"
+        "    --dump               Dump xml data for each translation unit. The dump\n"
+        "                         files have the extension .dump and contain ast,\n"
+        "                         tokenlist, symboldatabase, valueflow.\n"
+        "    -D<ID>               Define preprocessor symbol. Unless --max-configs or\n"
+        "                         --force is used, Cppcheck will only check the given\n"
+        "                         configuration when -D is used.\n"
+        "                         Example: '-DDEBUG=1 -D__cplusplus'.\n"
+        "    -E                   Print preprocessor output on stdout and don't do any\n"
+        "                         further processing.\n"
+        "    --enable=<severity>  Enable additional checks grouped by severity. The available\n"
+        "                         severities are:\n"
+        "                          * warning\n"
+        "                          * performance\n"
+        "                          * portability\n"
+        "                          * information\n"
+        "                          * style\n"
+        "                                  Enable checks with severities 'style', 'warning',\n"
+        "                                  'performance' and 'portability'.\n"
+        "                          * unusedFunction\n"
+        "                                  Check for unused functions. It is recommended\n"
+        "                                  to only enable this when the whole program is\n"
+        "                                  scanned.\n"
+        "                          * missingInclude\n"
+        "                                  Check for missing include files.\n"
+        "                          * all\n"
+        "                                  Enable all checks.\n"
+        "                         Pass multiple severities as a comma-separated list.\n"
+        "    --error-exitcode=<n> If errors are found, integer [n] is returned instead of\n"
+        "                         the default '0'. '" << EXIT_FAILURE << "' is returned\n"
+        "                         if arguments are not valid or if no input files are\n"
+        "                         provided. Note that your operating system can modify\n"
+        "                         this value, e.g. '256' can become '0'.\n"
+        "    --errorlist          Print a list of all the error messages in XML format.\n"
+        "    --exitcode-suppressions=<file>\n"
+        "                         Used when certain messages should be displayed but\n"
+        "                         should not cause a non-zero exitcode.\n"
+        "    --file-filter=<str>  Analyze only those files matching the given filter str.\n"
+        "                         Can be used multiple times. When str is '-', the file\n"
+        "                         filter will be read from standard input. When str is '+',\n"
+        "                         given files on CLI will be treated as file filters.\n"
+        "                         Example: --file-filter=*bar.cpp analyzes only files\n"
+        "                         that end with bar.cpp.\n"
+        "    --file-list=<file>   Specify the files to check in a text file. Add one\n"
+        "                         filename per line. When file is '-,' the file list will\n"
+        "                         be read from standard input.\n"
+        "    -f, --force          Force checking of all configurations in files. If used\n"
+        "                         together with '--max-configs=', the last option is the\n"
+        "                         one that is effective.\n"
+        "    --fsigned-char       Treat char type as signed.\n"
+        "    --funsigned-char     Treat char type as unsigned.\n"
+        "    -h, --help           Print this help.\n"
+        "    -I <dir>             Give path to search for include files. Give several -I\n"
+        "                         parameters to give several paths. First given path is\n"
+        "                         searched for contained header files first. If paths are\n"
+        "                         relative to source files, this is not needed.\n"
+        "    --includes-file=<file>\n"
+        "                         Specify directory paths to search for included header\n"
+        "                         files in a text file. Add one include path per line.\n"
+        "                         First given path is searched for contained header\n"
+        "                         files first. If paths are relative to source files,\n"
+        "                         this is not needed.\n"
+        "    --include=<file>\n"
+        "                         Force inclusion of a file before the checked file.\n"
+        "    -i <str>             Ignore files that match <str>. <str> can be a filename\n"
+        "                         or directory and can contain *,**,?. A file that is\n"
+        "                         ignored will not be checked directly (the whole\n"
+        "                         translation unit is skipped completely). Header files\n"
+        "                         are checked indirectly when they are #include'd.\n"
+        "                         Note: If you want to prevent warnings in some headers,\n"
+        "                         use suppressions instead.\n"
+        "    --inconclusive       Allow that Cppcheck reports even though the analysis is\n"
+        "                         inconclusive.\n"
+        "                         There are false positives with this option. Each result\n"
+        "                         must be carefully investigated before you know if it is\n"
+        "                         good or bad.\n"
+        "    --inline-suppr       Enable inline suppressions. Use them by placing one or\n"
+        "                         more comments, like: '// cppcheck-suppress warningId'\n"
+        "                         on the lines before the warning to suppress.\n"
+        "    -j <jobs>            Start <jobs> threads to do the checking simultaneously.\n"
+        "    -l <load>            Specifies that no new threads should be started if\n"
+        "                         there are other threads running and the load average is\n"
+        "                         at least <load>.\n"
+        "    --language=<language>, -x <language>\n"
+        "                         Forces cppcheck to check all files as the given\n"
+        "                         language. Valid values are: c, c++\n"
+        "    --library=<cfg>      Load file <cfg> that contains information about types\n"
+        "                         and functions. With such information Cppcheck\n"
+        "                         understands your code better and therefore you\n"
+        "                         get better results. The std.cfg file that is\n"
+        "                         distributed with Cppcheck is loaded automatically.\n"
+        "                         For more information about library files, read the\n"
+        "                         manual.\n"
+        "    --max-configs=<limit>\n"
+        "                         Maximum number of configurations to check in a file\n"
+        "                         before skipping it. Default is '12'. If used together\n"
+        "                         with '--force', the last option is the one that is\n"
+        "                         effective.\n"
+        "    --max-ctu-depth=N    Max depth in whole program analysis. The default value\n"
+        "                         is 2. A larger value will mean more errors can be found\n"
+        "                         but also means the analysis will be slower.\n"
+        "    --output-file=<file> Write results to file, rather than standard error.\n"
+        "    --output-format=<format>\n"
+        "                        Specify the output format. The available formats are:\n"
+        "                          * text\n"
+        "                          * sarif\n"
+        "                          * xml (deprecated)\n"
+        "                          * xmlv2\n"
+        "                          * xmlv3\n"
+        "    --platform=<type>, --platform=<file>\n"
+        "                         Specifies platform specific types and sizes. The\n"
+        "                         available builtin platforms are:\n"
+        "                          * unix32\n"
+        "                                 32 bit unix variant\n"
+        "                          * unix64\n"
+        "                                 64 bit unix variant\n"
+        "                          * win32A\n"
+        "                                 32 bit Windows ASCII character encoding\n"
+        "                          * win32W\n"
+        "                                 32 bit Windows UNICODE character encoding\n"
+        "                          * win64\n"
+        "                                 64 bit Windows\n"
+        "                          * avr8\n"
+        "                                 8 bit AVR microcontrollers\n"
+        "                          * elbrus-e1cp\n"
+        "                                 Elbrus e1c+ architecture\n"
+        "                          * pic8\n"
+        "                                 8 bit PIC microcontrollers\n"
+        "                                 Baseline and mid-range architectures\n"
+        "                          * pic8-enhanced\n"
+        "                                 8 bit PIC microcontrollers\n"
+        "                                 Enhanced mid-range and high end (PIC18) architectures\n"
+        "                          * pic16\n"
+        "                                 16 bit PIC microcontrollers\n"
+        "                          * mips32\n"
+        "                                 32 bit MIPS microcontrollers\n"
+        "                          * native\n"
+        "                                 Type sizes of host system are assumed, but no\n"
+        "                                 further assumptions.\n"
+        "                          * unspecified\n"
+        "                                 Unknown type sizes\n"
+        "    --plist-output=<path>\n"
+        "                         Generate Clang-plist output files in folder.\n";
+
+    if (mSettings.premium) {
+        oss <<
+            "    --premium=<option>\n"
+            "                         Coding standards:\n"
+            "                          * autosar           Autosar (partial)\n"
+            "                          * cert-c            Cert C checking\n"
+            "                          * cert-c++          Cert C++ checking\n"
+            "                          * misra-c-2012      Misra C 2012\n"
+            "                          * misra-c-2023      Misra C 2023\n"
+            "                          * misra-c-2025      Misra C 2025\n"
+            "                          * misra-c++-2008    Misra C++ 2008\n"
+            "                          * misra-c++-2023    Misra C++ 2023\n"
+            "                         By default 'Misra/Cert C' only checks C files.\n"
+            "                         By default 'Autosar/Misra/Cert C++' only checks C++ files.\n"
+            "                         To check all files, append \":all\" i.e. --premium=misra-c++-2023:all.\n"
+            "                         Other:\n"
+            "                          * bughunting        Soundy analysis\n"
+            "                          * metrics           Calculate metrics. Metrics are only reported in xmlv3 output.\n"
+            "                          * safety            Turn on safety certified behavior (ON by default)\n"
+            "                          * safety-off        Turn off safety certified behavior\n"
+            "    --premium-cert-c-int-precision=BITS\n"
+            "                         Integer precision to use in Cert C analysis. Only needed if precision of 'int' is\n"
+            "                         less than the size of 'int'. BITS shall be a positive value that is less than the\n"
+            "                         size of 'int'. This precision is used for INT35-C checking.\n"
+            "    --premium-license-file=<path>\n"
+            "                         Provide license file path with argument.\n";
+    }
+
+    oss <<
+        "    --project=<file>     Run Cppcheck on project. The <file> can be a Visual\n"
+        "                         Studio Solution (*.sln), Visual Studio Project\n"
+        "                         (*.vcxproj), compile database (compile_commands.json),\n"
+        "                         or Borland C++ Builder 6 (*.bpr). The files to analyse,\n"
+        "                         include paths, defines, platform and undefines in\n"
+        "                         the specified file will be used.\n"
+        "    --project-configuration=<config>\n"
+        "                         If used together with a Visual Studio Solution (*.sln)\n"
+        "                         or Visual Studio Project (*.vcxproj) you can limit\n"
+        "                         the configuration cppcheck should check.\n"
+        "                         For example: '--project-configuration=Release|Win32'\n"
+        "    -q, --quiet          Do not show progress reports.\n"
+        "                         Note that this option is not mutually exclusive with --verbose.\n"
+        "    -rp=<paths>, --relative-paths=<paths>\n"
+        "                         Use relative paths in output. When given, <paths> are\n"
+        "                         used as base. You can separate multiple paths by ';'.\n"
+        "                         Otherwise path where source files are searched is used.\n"
+        "                         We use string comparison to create relative paths, so\n"
+        "                         using e.g. ~ for home folder does not work. It is\n"
+        "                         currently only possible to apply the base paths to\n"
+        "                         files that are on a lower level in the directory tree.\n"
+        "    --report-progress    Report progress messages while checking a file (single job only).\n"
+        "    --report-type=<type> Add guideline and classification fields for specified coding standard.\n"
+        "                         The available report types are:\n"
+        "                          * normal           Default, only show cppcheck error ID and severity\n"
+        "                          * autosar          Autosar\n"
+        "                          * cert-c-2016      Cert C 2016\n"
+        "                          * cert-cpp-2016    Cert C++ 2016\n"
+        "                          * misra-c-2012     Misra C 2012\n"
+        "                          * misra-c-2023     Misra C 2023\n"
+        "                          * misra-c-2025     Misra C 2025\n"
+        "                          * misra-cpp-2008   Misra C++ 2008\n"
+        "                          * misra-cpp-2023   Misra C++ 2023\n"
+        "    --rule=<rule>        Match regular expression.\n"
+        "    --rule-file=<file>   Use given rule file. For more information, see:\n"
+        "                         http://sourceforge.net/projects/cppcheck/files/Articles/\n"
+        "    --safety             Enable safety-certified checking mode: display checker summary, enforce\n"
+        "                         stricter checks for critical errors, and return a non-zero exit code\n"
+        "                         if such errors occur.\n"
+        "    --showtime=<mode>    Show timing information.\n"
+        "                         The available modes are:\n"
+        "                          * none\n"
+        "                                 Show nothing (default)\n"
+        "                          * file\n"
+        "                                 Show for each processed file\n"
+        "                          * file-total\n"
+        "                                 Show total time only for each processed file\n"
+        "                          * summary\n"
+        "                                 Show a summary at the end\n"
+        "                          * top5_file\n"
+        "                                 Show the top 5 for each processed file\n"
+        "                          * top5_summary\n"
+        "                                 Show the top 5 summary at the end\n"
+        "    --std=<id>           Set standard.\n"
+        "                         The available options are:\n"
+        "                          * c89\n"
+        "                                 C code is C89 compatible\n"
+        "                          * c99\n"
+        "                                 C code is C99 compatible\n"
+        "                          * c11\n"
+        "                                 C code is C11 compatible (default)\n"
+        "                          * c++03\n"
+        "                                 C++ code is C++03 compatible\n"
+        "                          * c++11\n"
+        "                                 C++ code is C++11 compatible\n"
+        "                          * c++14\n"
+        "                                 C++ code is C++14 compatible\n"
+        "                          * c++17\n"
+        "                                 C++ code is C++17 compatible\n"
+        "                          * c++20\n"
+        "                                 C++ code is C++20 compatible (default)\n"
+        "    --suppress=<spec>    Suppress warnings that match <spec>. The format of\n"
+        "                         <spec> is:\n"
+        "                         [error id]:[filename]:[line]\n"
+        "                         The [filename] and [line] are optional. If [error id]\n"
+        "                         is a wildcard '*', all error ids match.\n"
+        "    --suppressions-list=<file>\n"
+        "                         Suppress warnings listed in the file. Each suppression\n"
+        "                         is in the same format as <spec> above.\n"
+        "    --suppress-xml=<file>\n"
+        "                         Suppress warnings listed in a xml file. XML file should\n"
+        "                         follow the manual.pdf format specified in section.\n"
+        "                         `6.4 XML suppressions` .\n"
+        "    --template='<text>'  Format the error messages. Available fields:\n"
+        "                           {file}              file name\n"
+        "                           {line}              line number\n"
+        "                           {column}            column number\n"
+        "                           {callstack}         show a callstack. Example:\n"
+        "                                                 [file.c:1] -> [file.c:100]\n"
+        "                           {inconclusive:text} if warning is inconclusive, text\n"
+        "                                               is written\n"
+        "                           {severity}          severity\n"
+        "                           {message}           warning message\n"
+        "                           {id}                warning id\n"
+        "                           {cwe}               CWE id (Common Weakness Enumeration)\n"
+        "                           {code}              show the real code\n"
+        "                           \\t                 insert tab\n"
+        "                           \\n                 insert newline\n"
+        "                           \\r                 insert carriage return\n"
+        "                         Example formats:\n"
+        "                         '{file}:{line},{severity},{id},{message}' or\n"
+        "                         '{file}({line}):({severity}) {message}' or\n"
+        "                         '{callstack} {message}'\n"
+        "                         Pre-defined templates: gcc (default), cppcheck1 (old default), vs, edit.\n"
+        // Note: template daca2 also exists, but is for internal use (cppcheck scripts).
+        "    --template-location='<text>'\n"
+        "                         Format error message location. If this is not provided\n"
+        "                         then no extra location info is shown.\n"
+        "                         Available fields:\n"
+        "                           {file}      file name\n"
+        "                           {line}      line number\n"
+        "                           {column}    column number\n"
+        "                           {info}      location info\n"
+        "                           {code}      show the real code\n"
+        "                           \\t         insert tab\n"
+        "                           \\n         insert newline\n"
+        "                           \\r         insert carriage return\n"
+        "                         Example format (gcc-like):\n"
+        "                         '{file}:{line}:{column}: note: {info}\\n{code}'\n"
+        "    -U<ID>               Undefine preprocessor symbol. Use -U to explicitly\n"
+        "                         hide certain #ifdef <ID> code paths from checking.\n"
+        "                         Example: '-UDEBUG'\n"
+        "    -v, --verbose        Output more detailed error information.\n"
+        "                         Note that this option is not mutually exclusive with --quiet.\n"
+        "    --version            Print out version number.\n"
+        "    --xml                Write results in xml format to error stream (stderr).\n"
+        "\n"
+        "Example usage:\n"
+        "  # Recursively check the current folder. Print the progress on the screen and\n"
+        "  # write errors to a file:\n"
+        "  cppcheck . 2> err.txt\n"
+        "\n"
+        "  # Recursively check ../myproject/ and don't print progress:\n"
+        "  cppcheck --quiet ../myproject/\n"
+        "\n"
+        "  # Check test.cpp, enable all checks:\n"
+        "  cppcheck --enable=all --inconclusive --library=posix test.cpp\n"
+        "\n"
+        "  # Check f.cpp and search include files from inc1/ and inc2/:\n"
+        "  cppcheck -I inc1/ -I inc2/ f.cpp\n"
+        "\n"
+        "For more information:\n"
+        "    " << mSettings.manualUrl << "\n"
+        "\n"
+        "Many thanks to the 3rd party libraries we use:\n"
+        " * tinyxml2 -- loading project/library/ctu files.\n"
+        " * picojson -- loading compile database.\n"
+        " * pcre -- rules.\n"
+        " * qt -- used in GUI\n";
+
+    mLogger.printRaw(oss.str());
+}
+
+std::string CmdLineParser::getVersion() const {
+    // TODO: this should not contain the version - it should set the extraVersion
+    if (!mSettings.cppcheckCfgProductName.empty())
+        return mSettings.cppcheckCfgProductName;
+    const char * const extraVersion = CppCheck::extraVersion();
+    if (*extraVersion != '\0')
+        return std::string("Cppcheck ") + CppCheck::version() + " ("+ extraVersion + ')';
+    return std::string("Cppcheck ") + CppCheck::version();
+}
+
+bool CmdLineParser::tryLoadLibrary(Library& destination, const std::string& basepath, const char* filename, bool debug)
+{
+    const Library::Error err = destination.load(basepath.c_str(), filename, debug);
+
+    if (err.errorcode == Library::ErrorCode::UNKNOWN_ELEMENT)
+        mLogger.printMessage("Found unknown elements in configuration file '" + std::string(filename) + "': " + err.reason); // TODO: print as errors
+    else if (err.errorcode != Library::ErrorCode::OK) {
+        std::string msg = "Failed to load library configuration file '" + std::string(filename) + "'. ";
+        switch (err.errorcode) {
+        case Library::ErrorCode::OK:
+            break;
+        case Library::ErrorCode::FILE_NOT_FOUND:
+            msg += "File not found";
+            break;
+        case Library::ErrorCode::BAD_XML:
+            msg += "Bad XML";
+            break;
+        case Library::ErrorCode::UNKNOWN_ELEMENT:
+            msg += "Unexpected element";
+            break;
+        case Library::ErrorCode::MISSING_ATTRIBUTE:
+            msg +="Missing attribute";
+            break;
+        case Library::ErrorCode::BAD_ATTRIBUTE_VALUE:
+            msg += "Bad attribute value";
+            break;
+        case Library::ErrorCode::UNSUPPORTED_FORMAT:
+            msg += "File is of unsupported format version";
+            break;
+        case Library::ErrorCode::DUPLICATE_PLATFORM_TYPE:
+            msg += "Duplicate platform type";
+            break;
+        case Library::ErrorCode::PLATFORM_TYPE_REDEFINED:
+            msg += "Platform type redefined";
+            break;
+        case Library::ErrorCode::DUPLICATE_DEFINE:
+            msg += "Duplicate define";
+            break;
+        }
+        if (!err.reason.empty())
+            msg += " '" + err.reason + "'";
+        mLogger.printMessage(msg); // TODO: print as errors
+        return false;
+    }
     return true;
 }
 
-void CmdLineParser::printHelp()
+bool CmdLineParser::loadLibraries(Settings& settings)
 {
-    std::cout << "Cppcheck - A tool for static C/C++ code analysis\n"
-              "\n"
-              "Syntax:\n"
-              "    cppcheck [OPTIONS] [files or paths]\n"
-              "\n"
-              "If a directory is given instead of a filename, *.cpp, *.cxx, *.cc, *.c++, *.c,\n"
-              "*.tpp, and *.txx files are checked recursively from the given directory.\n\n"
-              "Options:\n"
-              "    --addon=<addon>\n"
-              "                         Execute addon. i.e. cert.\n"
-              "    --cppcheck-build-dir=<dir>\n"
-              "                         Analysis output directory. Useful for various data.\n"
-              "                         Some possible usages are; whole program analysis,\n"
-              "                         incremental analysis, distributed analysis.\n"
-              "    --check-config       Check cppcheck configuration. The normal code\n"
-              "                         analysis is disabled by this flag.\n"
-              "    --check-library      Show information messages when library files have\n"
-              "                         incomplete info.\n"
-              "    --config-exclude=<dir>\n"
-              "                         Path (prefix) to be excluded from configuration\n"
-              "                         checking. Preprocessor configurations defined in\n"
-              "                         headers (but not sources) matching the prefix will not\n"
-              "                         be considered for evaluation.\n"
-              "    --config-excludes-file=<file>\n"
-              "                         A file that contains a list of config-excludes\n"
-              "    --doc                Print a list of all available checks.\n"
-              "    --dump               Dump xml data for each translation unit. The dump\n"
-              "                         files have the extension .dump and contain ast,\n"
-              "                         tokenlist, symboldatabase, valueflow.\n"
-              "    -D<ID>               Define preprocessor symbol. Unless --max-configs or\n"
-              "                         --force is used, Cppcheck will only check the given\n"
-              "                         configuration when -D is used.\n"
-              "                         Example: '-DDEBUG=1 -D__cplusplus'.\n"
-              "    -U<ID>               Undefine preprocessor symbol. Use -U to explicitly\n"
-              "                         hide certain #ifdef <ID> code paths from checking.\n"
-              "                         Example: '-UDEBUG'\n"
-              "    -E                   Print preprocessor output on stdout and don't do any\n"
-              "                         further processing.\n"
-              "    --enable=<id>        Enable additional checks. The available ids are:\n"
-              "                          * all\n"
-              "                                  Enable all checks. It is recommended to only\n"
-              "                                  use --enable=all when the whole program is\n"
-              "                                  scanned, because this enables unusedFunction.\n"
-              "                          * warning\n"
-              "                                  Enable warning messages\n"
-              "                          * style\n"
-              "                                  Enable all coding style checks. All messages\n"
-              "                                  with the severities 'style', 'performance' and\n"
-              "                                  'portability' are enabled.\n"
-              "                          * performance\n"
-              "                                  Enable performance messages\n"
-              "                          * portability\n"
-              "                                  Enable portability messages\n"
-              "                          * information\n"
-              "                                  Enable information messages\n"
-              "                          * unusedFunction\n"
-              "                                  Check for unused functions. It is recommend\n"
-              "                                  to only enable this when the whole program is\n"
-              "                                  scanned.\n"
-              "                          * missingInclude\n"
-              "                                  Warn if there are missing includes. For\n"
-              "                                  detailed information, use '--check-config'.\n"
-              "                         Several ids can be given if you separate them with\n"
-              "                         commas. See also --std\n"
-              "    --error-exitcode=<n> If errors are found, integer [n] is returned instead of\n"
-              "                         the default '0'. '" << EXIT_FAILURE << "' is returned\n"
-              "                         if arguments are not valid or if no input files are\n"
-              "                         provided. Note that your operating system can modify\n"
-              "                         this value, e.g. '256' can become '0'.\n"
-              "    --errorlist          Print a list of all the error messages in XML format.\n"
-              "    --exitcode-suppressions=<file>\n"
-              "                         Used when certain messages should be displayed but\n"
-              "                         should not cause a non-zero exitcode.\n"
-              "    --file-list=<file>   Specify the files to check in a text file. Add one\n"
-              "                         filename per line. When file is '-,' the file list will\n"
-              "                         be read from standard input.\n"
-              "    -f, --force          Force checking of all configurations in files. If used\n"
-              "                         together with '--max-configs=', the last option is the\n"
-              "                         one that is effective.\n"
-              "    -h, --help           Print this help.\n"
-              "    -I <dir>             Give path to search for include files. Give several -I\n"
-              "                         parameters to give several paths. First given path is\n"
-              "                         searched for contained header files first. If paths are\n"
-              "                         relative to source files, this is not needed.\n"
-              "    --includes-file=<file>\n"
-              "                         Specify directory paths to search for included header\n"
-              "                         files in a text file. Add one include path per line.\n"
-              "                         First given path is searched for contained header\n"
-              "                         files first. If paths are relative to source files,\n"
-              "                         this is not needed.\n"
-              "    --include=<file>\n"
-              "                         Force inclusion of a file before the checked file. Can\n"
-              "                         be used for example when checking the Linux kernel,\n"
-              "                         where autoconf.h needs to be included for every file\n"
-              "                         compiled. Works the same way as the GCC -include\n"
-              "                         option.\n"
-              "    -i <dir or file>     Give a source file or source file directory to exclude\n"
-              "                         from the check. This applies only to source files so\n"
-              "                         header files included by source files are not matched.\n"
-              "                         Directory name is matched to all parts of the path.\n"
-              "    --inconclusive       Allow that Cppcheck reports even though the analysis is\n"
-              "                         inconclusive.\n"
-              "                         There are false positives with this option. Each result\n"
-              "                         must be carefully investigated before you know if it is\n"
-              "                         good or bad.\n"
-              "    --inline-suppr       Enable inline suppressions. Use them by placing one or\n"
-              "                         more comments, like: '// cppcheck-suppress warningId'\n"
-              "                         on the lines before the warning to suppress.\n"
-              "    -j <jobs>            Start <jobs> threads to do the checking simultaneously.\n"
-#ifdef THREADING_MODEL_FORK
-              "    -l <load>            Specifies that no new threads should be started if\n"
-              "                         there are other threads running and the load average is\n"
-              "                         at least <load>.\n"
+    if (!tryLoadLibrary(settings.library, settings.exename, "std.cfg", settings.debuglookup || settings.debuglookupLibrary)) {
+        const std::string msg("Failed to load std.cfg. Your Cppcheck installation is broken, please re-install.");
+#ifdef FILESDIR
+        const std::string details("The Cppcheck binary was compiled with FILESDIR set to \""
+                                  FILESDIR "\" and will therefore search for "
+                                  "std.cfg in " FILESDIR "/cfg.");
+#else
+        const std::string cfgfolder(Path::fromNativeSeparators(Path::getPathFromFilename(settings.exename)) + "cfg");
+        const std::string details("The Cppcheck binary was compiled without FILESDIR set. Either the "
+                                  "std.cfg should be available in " + cfgfolder + " or the FILESDIR "
+                                  "should be configured.");
 #endif
-              "    --language=<language>, -x <language>\n"
-              "                         Forces cppcheck to check all files as the given\n"
-              "                         language. Valid values are: c, c++\n"
-              "    --library=<cfg>      Load file <cfg> that contains information about types\n"
-              "                         and functions. With such information Cppcheck\n"
-              "                         understands your code better and therefore you\n"
-              "                         get better results. The std.cfg file that is\n"
-              "                         distributed with Cppcheck is loaded automatically.\n"
-              "                         For more information about library files, read the\n"
-              "                         manual.\n"
-              "    --max-ctu-depth=N    Max depth in whole program analysis. The default value\n"
-              "                         is 2. A larger value will mean more errors can be found\n"
-              "                         but also means the analysis will be slower.\n"
-              "    --output-file=<file> Write results to file, rather than standard error.\n"
-              "    --project=<file>     Run Cppcheck on project. The <file> can be a Visual\n"
-              "                         Studio Solution (*.sln), Visual Studio Project\n"
-              "                         (*.vcxproj), compile database (compile_commands.json),\n"
-              "                         or Borland C++ Builder 6 (*.bpr). The files to analyse,\n"
-              "                         include paths, defines, platform and undefines in\n"
-              "                         the specified file will be used.\n"
-              "    --max-configs=<limit>\n"
-              "                         Maximum number of configurations to check in a file\n"
-              "                         before skipping it. Default is '12'. If used together\n"
-              "                         with '--force', the last option is the one that is\n"
-              "                         effective.\n"
-              "    --platform=<type>, --platform=<file>\n"
-              "                         Specifies platform specific types and sizes. The\n"
-              "                         available builtin platforms are:\n"
-              "                          * unix32\n"
-              "                                 32 bit unix variant\n"
-              "                          * unix64\n"
-              "                                 64 bit unix variant\n"
-              "                          * win32A\n"
-              "                                 32 bit Windows ASCII character encoding\n"
-              "                          * win32W\n"
-              "                                 32 bit Windows UNICODE character encoding\n"
-              "                          * win64\n"
-              "                                 64 bit Windows\n"
-              "                          * avr8\n"
-              "                                 8 bit AVR microcontrollers\n"
-              "                          * native\n"
-              "                                 Type sizes of host system are assumed, but no\n"
-              "                                 further assumptions.\n"
-              "                          * unspecified\n"
-              "                                 Unknown type sizes\n"
-              "    --plist-output=<path>\n"
-              "                         Generate Clang-plist output files in folder.\n"
-              "    -q, --quiet          Do not show progress reports.\n"
-              "    -rp, --relative-paths\n"
-              "    -rp=<paths>, --relative-paths=<paths>\n"
-              "                         Use relative paths in output. When given, <paths> are\n"
-              "                         used as base. You can separate multiple paths by ';'.\n"
-              "                         Otherwise path where source files are searched is used.\n"
-              "                         We use string comparison to create relative paths, so\n"
-              "                         using e.g. ~ for home folder does not work. It is\n"
-              "                         currently only possible to apply the base paths to\n"
-              "                         files that are on a lower level in the directory tree.\n"
-              "    --report-progress    Report progress messages while checking a file.\n"
-#ifdef HAVE_RULES
-              "    --rule=<rule>        Match regular expression.\n"
-              "    --rule-file=<file>   Use given rule file. For more information, see: \n"
-              "                         http://sourceforge.net/projects/cppcheck/files/Articles/\n"
-#endif
-              "    --std=<id>           Set standard.\n"
-              "                         The available options are:\n"
-              "                          * c89\n"
-              "                                 C code is C89 compatible\n"
-              "                          * c99\n"
-              "                                 C code is C99 compatible\n"
-              "                          * c11\n"
-              "                                 C code is C11 compatible (default)\n"
-              "                          * c++03\n"
-              "                                 C++ code is C++03 compatible\n"
-              "                          * c++11\n"
-              "                                 C++ code is C++11 compatible\n"
-              "                          * c++14\n"
-              "                                 C++ code is C++14 compatible\n"
-              "                          * c++17\n"
-              "                                 C++ code is C++17 compatible\n"
-              "                          * c++20\n"
-              "                                 C++ code is C++20 compatible (default)\n"
-              "    --suppress=<spec>    Suppress warnings that match <spec>. The format of\n"
-              "                         <spec> is:\n"
-              "                         [error id]:[filename]:[line]\n"
-              "                         The [filename] and [line] are optional. If [error id]\n"
-              "                         is a wildcard '*', all error ids match.\n"
-              "    --suppressions-list=<file>\n"
-              "                         Suppress warnings listed in the file. Each suppression\n"
-              "                         is in the same format as <spec> above.\n"
-              "    --template='<text>'  Format the error messages. Available fields:\n"
-              "                           {file}              file name\n"
-              "                           {line}              line number\n"
-              "                           {column}            column number\n"
-              "                           {callstack}         show a callstack. Example:\n"
-              "                                                 [file.c:1] -> [file.c:100]\n"
-              "                           {inconclusive:text} if warning is inconclusive, text\n"
-              "                                               is written\n"
-              "                           {severity}          severity\n"
-              "                           {message}           warning message\n"
-              "                           {id}                warning id\n"
-              "                           {cwe}               CWE id (Common Weakness Enumeration)\n"
-              "                           {code}              show the real code\n"
-              "                           \\t                 insert tab\n"
-              "                           \\n                 insert newline\n"
-              "                           \\r                 insert carriage return\n"
-              "                         Example formats:\n"
-              "                         '{file}:{line},{severity},{id},{message}' or\n"
-              "                         '{file}({line}):({severity}) {message}' or\n"
-              "                         '{callstack} {message}'\n"
-              "                         Pre-defined templates: gcc, vs, edit, cppcheck1\n"
-              "                         The default format is 'gcc'.\n"
-              "    --template-location='<text>'\n"
-              "                         Format error message location. If this is not provided\n"
-              "                         then no extra location info is shown.\n"
-              "                         Available fields:\n"
-              "                           {file}      file name\n"
-              "                           {line}      line number\n"
-              "                           {column}    column number\n"
-              "                           {info}      location info\n"
-              "                           {code}      show the real code\n"
-              "                           \\t         insert tab\n"
-              "                           \\n         insert newline\n"
-              "                           \\r         insert carriage return\n"
-              "                         Example format (gcc-like):\n"
-              "                         '{file}:{line}:{column}: note: {info}\\n{code}'\n"
-              "    -v, --verbose        Output more detailed error information.\n"
-              "    --version            Print out version number.\n"
-              "    --xml                Write results in xml format to error stream (stderr).\n"
-              "    --xml-version=<version>\n"
-              "                         Select the XML file version. Currently only versions 2 is available."
-              "\n"
-              "Example usage:\n"
-              "  # Recursively check the current folder. Print the progress on the screen and\n"
-              "  # write errors to a file:\n"
-              "  cppcheck . 2> err.txt\n"
-              "\n"
-              "  # Recursively check ../myproject/ and don't print progress:\n"
-              "  cppcheck --quiet ../myproject/\n"
-              "\n"
-              "  # Check test.cpp, enable all checks:\n"
-              "  cppcheck --enable=all --inconclusive --std=posix test.cpp\n"
-              "\n"
-              "  # Check f.cpp and search include files from inc1/ and inc2/:\n"
-              "  cppcheck -I inc1/ -I inc2/ f.cpp\n"
-              "\n"
-              "For more information:\n"
-              "    http://cppcheck.net/manual.pdf\n"
-              "\n"
-              "Many thanks to the 3rd party libraries we use:\n"
-              " * tinyxml2 -- loading project/library/ctu files.\n"
-              " * picojson -- loading compile database.\n"
-              " * pcre -- rules.\n"
-              " * qt -- used in GUI\n";
+        mLogger.printRaw(msg + " " + details); // TODO: do not print as raw?
+        return false;
+    }
+
+    bool result = true;
+    for (const auto& lib : settings.libraries) {
+        if (!tryLoadLibrary(settings.library, settings.exename, lib.c_str(), settings.debuglookup || settings.debuglookupLibrary)) {
+            result = false;
+        }
+    }
+    return result;
+}
+
+bool CmdLineParser::loadAddons(Settings& settings)
+{
+    bool result = true;
+    for (const std::string &addon: settings.addons) {
+        AddonInfo addonInfo;
+        const std::string failedToGetAddonInfo = addonInfo.getAddonInfo(addon, settings.exename, settings.debuglookup || settings.debuglookupAddon);
+        if (!failedToGetAddonInfo.empty()) {
+            mLogger.printRaw(failedToGetAddonInfo); // TODO: do not print as raw
+            result = false;
+            continue;
+        }
+        settings.addonInfos.emplace_back(std::move(addonInfo));
+    }
+    return result;
+}
+
+bool CmdLineParser::loadCppcheckCfg()
+{
+    if (!mSettings.settingsFiles.empty())
+    {
+        // should never happen - programming error
+        mLogger.printError("cppcheck.cfg has already been loaded from " + mSettings.settingsFiles[0]);
+        return false;
+    }
+    const std::string cfgErr = Settings::loadCppcheckCfg(mSettings, mSuppressions, mSettings.debuglookup || mSettings.debuglookupConfig);
+    if (!cfgErr.empty()) {
+        // TODO: log full path
+        mLogger.printError("could not load cppcheck.cfg - " + cfgErr);
+        return false;
+    }
+    mSettings.premium = startsWith(mSettings.cppcheckCfgProductName, "Cppcheck Premium");
+    return true;
+}
+
+std::list<FileWithDetails> CmdLineParser::filterFiles(const std::vector<std::string>& fileFilters,
+                                                      const std::list<FileWithDetails>& filesResolved) {
+    std::list<FileWithDetails> files;
+    PathMatch filtermatcher(fileFilters, Path::getCurrentPath());
+    std::copy_if(filesResolved.cbegin(), filesResolved.cend(), std::inserter(files, files.end()), [&](const FileWithDetails& entry) {
+        return filtermatcher.match(entry.path());
+    });
+    return files;
+}
+
+void CmdLineParser::outputFormatOptionMixingError() const
+{
+    mLogger.printError("'--output-format' and '--xml...' may not be used in conjunction.");
 }
diff --git a/cli/cmdlineparser.h b/cli/cmdlineparser.h
index dc977f4183a..54e7ae4b0aa 100644
--- a/cli/cmdlineparser.h
+++ b/cli/cmdlineparser.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,10 +19,20 @@
 #ifndef CMDLINE_PARSER_H
 #define CMDLINE_PARSER_H
 
+#include <cstddef>
+#include <cstdint>
+#include <list>
 #include <string>
 #include <vector>
 
+#include "cmdlinelogger.h"
+#include "filesettings.h"
+#include "standards.h"
+#include "utils.h"
+
 class Settings;
+struct Suppressions;
+class Library;
 
 /// @addtogroup CLI
 /// @{
@@ -40,80 +50,121 @@ class CmdLineParser {
 public:
     /**
      * The constructor.
+     * @param logger The logger instance to log messages through
      * @param settings Settings instance that will be modified according to
      * options user has given.
+     * @param suppressions Suppressions instance that keeps the suppressions
      */
-    explicit CmdLineParser(Settings *settings);
+    CmdLineParser(CmdLineLogger &logger, Settings &settings, Suppressions &suppressions);
+
+    enum class Result : std::uint8_t { Success, Exit, Fail };
 
     /**
-     * Parse given command line.
-     * @return true if command line was ok, false if there was an error.
+     * @brief Parse command line args and fill settings and file lists
+     * from there.
+     *
+     * @param argc argc from main()
+     * @param argv argv from main()
+     * @return false when errors are found in the input
      */
-    bool parseFromArgs(int argc, const char* const argv[]);
+    bool fillSettingsFromArgs(int argc, const char* const argv[]);
 
     /**
-     * Return if user wanted to see program version.
+     * @brief Filter files
+     *
+     * @param fileFilters file filters
+     * @param filesResolved all the files in project
+     * @return the files in filesResolved that match filters
      */
-    bool getShowVersion() const {
-        return mShowVersion;
-    }
+    static std::list<FileWithDetails> filterFiles(const std::vector<std::string>& fileFilters,
+                                                  const std::list<FileWithDetails>& filesResolved);
 
     /**
-     * Return if user wanted to see list of error messages.
+     * Return the files user gave to command line.
      */
-    bool getShowErrorMessages() const {
-        return mShowErrorMessages;
+    const std::list<FileWithDetails>& getFiles() const {
+        return mFiles;
     }
 
     /**
-     * Return the path names user gave to command line.
+     * Return the file settings read from command line.
      */
-    const std::vector<std::string>& getPathNames() const {
-        return mPathNames;
+    const std::list<FileSettings>& getFileSettings() const {
+        return mFileSettings;
     }
 
+protected:
     /**
-     * Return if help is shown to user.
+     * Parse given command line.
+     * @return true if command line was ok, false if there was an error.
      */
-    bool getShowHelp() const {
-        return mShowHelp;
-    }
+    Result parseFromArgs(int argc, const char* const argv[]);
 
     /**
-     * Return if we should exit after printing version, help etc.
+     * Get Cppcheck version
      */
-    bool exitAfterPrinting() const {
-        return mExitAfterPrint;
-    }
+    std::string getVersion() const;
 
+private:
     /**
-     * Return a list of paths user wants to ignore.
+     * Print help text to the console.
      */
-    const std::vector<std::string>& getIgnoredPaths() const {
-        return mIgnoredPaths;
+    void printHelp() const;
+
+    template<typename T>
+    bool parseNumberArg(const char* const arg, std::size_t offset, T& num, bool mustBePositive = false)
+    {
+        T tmp;
+        std::string err;
+        if (!strToInt(arg + offset, tmp, &err)) {
+            mLogger.printError("argument to '" + std::string(arg, offset) + "' is not valid - " + err + ".");
+            return false;
+        }
+        if (mustBePositive && tmp < 0) {
+            mLogger.printError("argument to '" + std::string(arg, offset) + "' needs to be a positive integer.");
+            return false;
+        }
+        num = tmp;
+        return true;
     }
 
-protected:
+    /**
+     * Tries to load a library and prints warning/error messages
+     * @return false, if an error occurred (except unknown XML elements)
+     */
+    bool tryLoadLibrary(Library& destination, const std::string& basepath, const char* filename, bool debug);
 
     /**
-     * Print help text to the console.
+     * @brief Load libraries
+     * @param settings Settings
+     * @return Returns true if successful
      */
-    static void printHelp();
+    bool loadLibraries(Settings& settings);
 
     /**
-     * Print message (to console?).
+     * @brief Load addons
+     * @param settings Settings
+     * @return Returns true if successful
      */
-    static void printMessage(const std::string &message);
-    static void printMessage(const char* message);
+    bool loadAddons(Settings& settings);
 
-private:
+    bool loadCppcheckCfg();
+
+    void outputFormatOptionMixingError() const;
+
+    CmdLineLogger &mLogger;
+
+    Settings &mSettings;
+    Suppressions &mSuppressions;
+
+protected:
     std::vector<std::string> mPathNames;
+    std::list<FileWithDetails> mFiles;
+    std::list<FileSettings> mFileSettings;
     std::vector<std::string> mIgnoredPaths;
-    Settings *mSettings;
-    bool mShowHelp;
-    bool mShowVersion;
-    bool mShowErrorMessages;
-    bool mExitAfterPrint;
+    bool mAnalyzeAllVsConfigsSetOnCmdLine = false;
+    /** @brief Name of the language that is enforced. Empty per default. */
+    Standards::Language mEnforcedLang{Standards::Language::None};
 };
 
 /// @}
diff --git a/cli/cppcheckexecutor.cpp b/cli/cppcheckexecutor.cpp
index c632775eb8f..d5980db6f70 100644
--- a/cli/cppcheckexecutor.cpp
+++ b/cli/cppcheckexecutor.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,957 +16,541 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#if defined(__CYGWIN__)
+#define _BSD_SOURCE // required to have popen() and pclose()
+#endif
+
 #include "cppcheckexecutor.h"
 
 #include "analyzerinfo.h"
+#include "checkersreport.h"
+#include "cmdlinelogger.h"
 #include "cmdlineparser.h"
+#include "color.h"
 #include "config.h"
 #include "cppcheck.h"
-#include "filelister.h"
-#include "importproject.h"
-#include "library.h"
+#include "errorlogger.h"
+#include "errortypes.h"
+#include "filesettings.h"
 #include "path.h"
-#include "pathmatch.h"
-#include "preprocessor.h"
+#include "sarifreport.h"
 #include "settings.h"
-#include "standards.h"
+#include "singleexecutor.h"
 #include "suppressions.h"
-#include "threadexecutor.h"
+#include "timer.h"
 #include "utils.h"
-#include "checkunusedfunctions.h"
 
-#include <csignal>
+#if defined(HAS_THREADING_MODEL_THREAD)
+#include "threadexecutor.h"
+#endif
+#if defined(HAS_THREADING_MODEL_FORK)
+#include "processexecutor.h"
+#endif
+
+#include <algorithm>
+#include <cassert>
 #include <cstdio>
 #include <cstdlib> // EXIT_SUCCESS and EXIT_FAILURE
-#include <cstring>
+#include <ctime>
+#include <fstream>
 #include <iostream>
 #include <list>
+#include <map>
+#include <set>
+#include <sstream>
+#include <unordered_set>
 #include <utility>
 #include <vector>
 
-#if !defined(NO_UNIX_SIGNAL_HANDLING) && defined(__GNUC__) && !defined(__MINGW32__) && !defined(__OS2__)
-#define USE_UNIX_SIGNAL_HANDLING
-#include <unistd.h>
-#if defined(__APPLE__)
-#   define _XOPEN_SOURCE // ucontext.h APIs can only be used on Mac OSX >= 10.7 if _XOPEN_SOURCE is defined
-#   include <ucontext.h>
-
-#   undef _XOPEN_SOURCE
-#elif !defined(__OpenBSD__)
-#   include <ucontext.h>
-#endif
-#ifdef __linux__
-#include <sys/syscall.h>
-#include <sys/types.h>
+#ifdef USE_UNIX_SIGNAL_HANDLING
+#include "signalhandler.h"
 #endif
+
+#ifdef USE_WINDOWS_SEH
+#include "sehwrapper.h"
 #endif
 
-#if !defined(NO_UNIX_BACKTRACE_SUPPORT) && defined(USE_UNIX_SIGNAL_HANDLING) && defined(__GNUC__) && defined(__GLIBC__) && !defined(__CYGWIN__) && !defined(__MINGW32__) && !defined(__NetBSD__) && !defined(__SVR4) && !defined(__QNX__)
-#define USE_UNIX_BACKTRACE_SUPPORT
-#include <cxxabi.h>
-#include <execinfo.h>
+#ifdef _WIN32
+#include <windows.h>
 #endif
 
-#if defined(_MSC_VER)
-#define USE_WINDOWS_SEH
-#include <DbgHelp.h>
-#include <TCHAR.H>
-#include <Windows.h>
-#include <excpt.h>
+#if !defined(_WIN32) && !defined(__MINGW32__)
+#include <sys/wait.h> // WIFEXITED and friends
 #endif
 
+namespace {
+    class CmdLineLoggerStd : public CmdLineLogger
+    {
+    public:
+        CmdLineLoggerStd() = default;
 
-/*static*/ FILE* CppCheckExecutor::mExceptionOutput = stdout;
+        void printMessage(const std::string &message) override
+        {
+            printRaw("cppcheck: " + message);
+        }
 
-CppCheckExecutor::CppCheckExecutor()
-    : mSettings(nullptr), mLatestProgressOutputTime(0), mErrorOutput(nullptr), mShowAllErrors(false)
-{
-}
+        void printError(const std::string &message) override
+        {
+            printMessage("error: " + message);
+        }
 
-CppCheckExecutor::~CppCheckExecutor()
-{
-    delete mErrorOutput;
-}
+        void printRaw(const std::string &message) override
+        {
+            std::cout << message << std::endl; // TODO: should not append newline
+        }
+    };
 
-bool CppCheckExecutor::parseFromArgs(CppCheck *cppcheck, int argc, const char* const argv[])
-{
-    Settings& settings = cppcheck->settings();
-    CmdLineParser parser(&settings);
-    const bool success = parser.parseFromArgs(argc, argv);
-
-    if (success) {
-        if (parser.getShowVersion() && !parser.getShowErrorMessages()) {
-            const char * const extraVersion = CppCheck::extraVersion();
-            if (*extraVersion != 0)
-                std::cout << "Cppcheck " << CppCheck::version() << " ("
-                          << extraVersion << ')' << std::endl;
-            else
-                std::cout << "Cppcheck " << CppCheck::version() << std::endl;
+    class StdLogger : public ErrorLogger
+    {
+    public:
+        explicit StdLogger(const Settings& settings)
+            : mSettings(settings)
+            , mGuidelineMapping(createGuidelineMapping(settings.reportType))
+        {
+            if (!mSettings.outputFile.empty()) {
+                mErrorOutput = new std::ofstream(settings.outputFile);
+            }
+            if (!mSettings.buildDir.empty()) {
+                mCheckersFile = Path::join(settings.buildDir, "checkers.txt");
+            }
         }
 
-        if (parser.getShowErrorMessages()) {
-            mShowAllErrors = true;
-            std::cout << ErrorLogger::ErrorMessage::getXMLHeader();
-            cppcheck->getErrorMessages();
-            std::cout << ErrorLogger::ErrorMessage::getXMLFooter() << std::endl;
+        ~StdLogger() override {
+            if (mSettings.outputFormat == Settings::OutputFormat::sarif) {
+                reportErr(mSarifReport.serialize(mSettings.cppcheckCfgProductName));
+            }
+            delete mErrorOutput;
         }
 
-        if (parser.exitAfterPrinting()) {
-            Settings::terminate();
-            return true;
+        StdLogger(const StdLogger&) = delete;
+        StdLogger& operator=(const SingleExecutor &) = delete;
+
+        void resetLatestProgressOutputTime() {
+            mLatestProgressOutputTime = std::time(nullptr);
         }
-    } else {
-        return false;
-    }
 
-    // Check that all include paths exist
-    {
-        for (std::list<std::string>::iterator iter = settings.includePaths.begin();
-             iter != settings.includePaths.end();
-            ) {
-            const std::string path(Path::toNativeSeparators(*iter));
-            if (FileLister::isDirectory(path))
-                ++iter;
-            else {
-                // If the include path is not found, warn user and remove the non-existing path from the list.
-                if (settings.isEnabled(Settings::INFORMATION))
-                    std::cout << "(information) Couldn't find path given by -I '" << path << '\'' << std::endl;
-                iter = settings.includePaths.erase(iter);
+        /**
+         * Helper function to print out errors. Appends a line change.
+         * @param errmsg String printed to error stream
+         */
+        void reportErr(const std::string &errmsg);
+
+        void reportMetric(const std::string &metric) override
+        {
+            mFileMetrics.push_back(metric);
+        }
+
+        void reportMetrics()
+        {
+            if (!mFileMetrics.empty()) {
+                auto &out = mErrorOutput ? *mErrorOutput : std::cerr;
+                out << "    <metrics>" << std::endl;
+                for (const auto &metric : mFileMetrics) {
+                    out << "        " << metric << std::endl;
+                }
+                out << "    </metrics>" << std::endl;
             }
         }
-    }
 
-    // Output a warning for the user if he tries to exclude headers
-    bool warn = false;
-    const std::vector<std::string>& ignored = parser.getIgnoredPaths();
-    for (const std::string &i : ignored) {
-        if (Path::isHeader(i)) {
-            warn = true;
-            break;
+        /**
+         * @brief Write the checkers report
+         */
+        void writeCheckersReport(const Suppressions& supprs);
+
+        bool hasCriticalErrors() const {
+            return !mCriticalErrors.empty();
         }
-    }
-    if (warn) {
-        std::cout << "cppcheck: filename exclusion does not apply to header (.h and .hpp) files." << std::endl;
-        std::cout << "cppcheck: Please use --suppress for ignoring results from the header files." << std::endl;
-    }
 
-    const std::vector<std::string>& pathnames = parser.getPathNames();
+        const std::string& getCtuInfo() const {
+            return mCtuInfo;
+        }
 
-#if defined(_WIN32)
-    // For Windows we want case-insensitive path matching
-    const bool caseSensitive = false;
-#else
-    const bool caseSensitive = true;
-#endif
-    if (!pathnames.empty()) {
-        // Execute recursiveAddFiles() to each given file parameter
-        const PathMatch matcher(ignored, caseSensitive);
-        for (const std::string &pathname : pathnames)
-            FileLister::recursiveAddFiles(mFiles, Path::toNativeSeparators(pathname), mSettings->library.markupExtensions(), matcher);
-    }
+        void readActiveCheckers() {
+            if (mCheckersFile.empty())
+                return;
+
+            std::ifstream fin(mCheckersFile);
+            if (fin.is_open())
+            {
+                std::set<std::string> activeCheckers;
+                std::string line;
+                // cppcheck-suppress accessMoved - FP
+                while (std::getline(fin, line))
+                {
+                    // cppcheck-suppress accessMoved - FP
+                    activeCheckers.emplace(std::move(line));
+                }
+                mActiveCheckers = std::move(activeCheckers);
+            }
+        }
 
-    if (mFiles.empty() && settings.project.fileSettings.empty()) {
-        std::cout << "cppcheck: error: could not find or open any of the paths given." << std::endl;
-        if (!ignored.empty())
-            std::cout << "cppcheck: Maybe all paths were ignored?" << std::endl;
-        return false;
-    }
-    return true;
+    private:
+        /**
+         * Information about progress is directed here. This should be
+         * called by the CppCheck class only.
+         *
+         * @param outmsg Progress message e.g. "Checking main.cpp..."
+         */
+        void reportOut(const std::string &outmsg, Color c = Color::Reset) override;
+
+        /** xml output of errors */
+        void reportErr(const ErrorMessage &msg) override;
+
+        void reportProgress(const std::string &filename, const char stage[], std::size_t value) override;
+
+        /**
+         * Reference to current settings; set while check() is running for reportError().
+         */
+        const Settings& mSettings;
+
+        /**
+         * Used to filter out duplicate error messages.
+         */
+        // TODO: store hashes instead of the full messages
+        std::unordered_set<std::string> mShownErrors;
+
+        /**
+         * Report progress time
+         */
+        std::time_t mLatestProgressOutputTime{};
+
+        /**
+         * Error output
+         */
+        std::ofstream* mErrorOutput{};
+
+        /**
+         * Checkers that has been executed
+         */
+        std::set<std::string> mActiveCheckers;
+
+        /**
+         * List of critical errors
+         */
+        std::string mCriticalErrors;
+
+        /**
+         * CTU information
+         */
+        std::string mCtuInfo;
+
+        /**
+         * SARIF report generator
+         */
+        SarifReport mSarifReport;
+
+        /**
+         * Coding standard guideline mapping
+         */
+        std::map<std::string, std::string> mGuidelineMapping;
+
+        /**
+         * File metrics
+         */
+        std::vector<std::string> mFileMetrics;
+
+        /**
+         * The file the cached active checkers are stored in
+         */
+        std::string mCheckersFile;
+    };
 }
 
 int CppCheckExecutor::check(int argc, const char* const argv[])
 {
-    Preprocessor::missingIncludeFlag = false;
-    Preprocessor::missingSystemIncludeFlag = false;
-
-    CheckUnusedFunctions::clear();
-
-    CppCheck cppCheck(*this, true);
-
-    const Settings& settings = cppCheck.settings();
-    mSettings = &settings;
-
-    if (!parseFromArgs(&cppCheck, argc, argv)) {
+    Settings settings;
+    CmdLineLoggerStd logger;
+    Suppressions supprs;
+    CmdLineParser parser(logger, settings, supprs);
+    if (!parser.fillSettingsFromArgs(argc, argv)) {
         return EXIT_FAILURE;
     }
     if (Settings::terminated()) {
         return EXIT_SUCCESS;
     }
-    if (cppCheck.settings().exceptionHandling) {
-        return check_wrapper(cppCheck, argc, argv);
-    }
-    return check_internal(cppCheck, argc, argv);
-}
 
-void CppCheckExecutor::setSettings(const Settings &settings)
-{
-    mSettings = &settings;
-}
+    Timer realTimeClock("", settings.showtime, nullptr, Timer::Type::OVERALL);
 
-/**
- *  Simple helper function:
- * \return size of array
- * */
-template<typename T, int size>
-std::size_t GetArrayLength(const T(&)[size])
-{
-    return size;
-}
+    settings.loadSummaries();
 
+    mFiles = parser.getFiles();
+    mFileSettings = parser.getFileSettings();
 
-#if defined(USE_UNIX_SIGNAL_HANDLING)
-/*
- * Try to print the callstack.
- * That is very sensitive to the operating system, hardware, compiler and runtime.
- * The code is not meant for production environment!
- * One reason is named first: it's using functions not whitelisted for usage in a signal handler function.
- */
-static void print_stacktrace(FILE* output, bool demangling, int maxdepth, bool lowMem)
+    const int ret = check_wrapper(settings, supprs);
+
+    return ret;
+}
+
+int CppCheckExecutor::check_wrapper(const Settings& settings, Suppressions& supprs)
 {
-#if defined(USE_UNIX_BACKTRACE_SUPPORT)
-// 32 vs. 64bit
-#define ADDRESSDISPLAYLENGTH ((sizeof(long)==8)?12:8)
-    const int fd = fileno(output);
-    void *callstackArray[32]= {nullptr}; // the less resources the better...
-    const int currentdepth = backtrace(callstackArray, (int)GetArrayLength(callstackArray));
-    const int offset=2; // some entries on top are within our own exception handling code or libc
-    if (maxdepth<0)
-        maxdepth=currentdepth-offset;
-    else
-        maxdepth = std::min(maxdepth, currentdepth);
-    if (lowMem) {
-        fputs("Callstack (symbols only):\n", output);
-        backtrace_symbols_fd(callstackArray+offset, maxdepth, fd);
-    } else {
-        char **symbolStringList = backtrace_symbols(callstackArray, currentdepth);
-        if (symbolStringList) {
-            fputs("Callstack:\n", output);
-            for (int i = offset; i < maxdepth; ++i) {
-                const char * const symbolString = symbolStringList[i];
-                char * realnameString = nullptr;
-                const char * const firstBracketName     = strchr(symbolString, '(');
-                const char * const firstBracketAddress  = strchr(symbolString, '[');
-                const char * const secondBracketAddress = strchr(firstBracketAddress, ']');
-                const char * const beginAddress         = firstBracketAddress+3;
-                const int addressLen = int(secondBracketAddress-beginAddress);
-                const int padLen     = int(ADDRESSDISPLAYLENGTH-addressLen);
-                if (demangling && firstBracketName) {
-                    const char * const plus = strchr(firstBracketName, '+');
-                    if (plus && (plus>(firstBracketName+1))) {
-                        char input_buffer[1024]= {0};
-                        strncpy(input_buffer, firstBracketName+1, plus-firstBracketName-1);
-                        char output_buffer[2048]= {0};
-                        size_t length = GetArrayLength(output_buffer);
-                        int status=0;
-                        // We're violating the specification - passing stack address instead of malloc'ed heap.
-                        // Benefit is that no further heap is required, while there is sufficient stack...
-                        realnameString = abi::__cxa_demangle(input_buffer, output_buffer, &length, &status); // non-NULL on success
-                    }
-                }
-                const int ordinal=i-offset;
-                fprintf(output, "#%-2d 0x",
-                        ordinal);
-                if (padLen>0)
-                    fprintf(output, "%0*d",
-                            padLen, 0);
-                if (realnameString) {
-                    fprintf(output, "%.*s in %s\n",
-                            (int)(secondBracketAddress-firstBracketAddress-3), firstBracketAddress+3,
-                            realnameString);
-                } else {
-                    fprintf(output, "%.*s in %.*s\n",
-                            (int)(secondBracketAddress-firstBracketAddress-3), firstBracketAddress+3,
-                            (int)(firstBracketAddress-symbolString), symbolString);
-                }
-            }
-            free(symbolStringList);
-        } else {
-            fputs("Callstack could not be obtained\n", output);
-        }
+#ifdef USE_WINDOWS_SEH
+    if (settings.exceptionHandling) {
+        CALL_WITH_SEH_WRAPPER(check_internal(settings, supprs));
     }
-#undef ADDRESSDISPLAYLENGTH
-#else
-    UNUSED(output);
-    UNUSED(demangling);
-    UNUSED(maxdepth);
-    UNUSED(lowMem);
+#elif defined(USE_UNIX_SIGNAL_HANDLING)
+    if (settings.exceptionHandling)
+        register_signal_handler(settings.exceptionOutput);
 #endif
+    return check_internal(settings, supprs);
 }
 
-static const size_t MYSTACKSIZE = 16*1024+SIGSTKSZ; // wild guess about a reasonable buffer
-static char mytstack[MYSTACKSIZE]= {0}; // alternative stack for signal handler
-static bool bStackBelowHeap=false; // lame attempt to locate heap vs. stack address space. See CppCheckExecutor::check_wrapper()
-
 /**
- * \param[in] ptr address to be examined.
- * \return true if address is supposed to be on stack (contrary to heap). If ptr is 0 false will be returned.
- * If unknown better return false.
+ * Get list of unmatchedSuppression errors
+ * @param unmatched list of unmatched suppressions
+ * @param filters a list of (globbed) IDs to filter out
+ * @return vector of unmatchedSuppression errors
  */
-static bool IsAddressOnStack(const void* ptr)
+static std::vector<ErrorMessage> getUnmatchedSuppressions(const std::list<SuppressionList::Suppression> &unmatched, const std::vector<std::string>& filters)
 {
-    if (nullptr==ptr)
-        return false;
-    char a;
-    if (bStackBelowHeap)
-        return ptr < &a;
-    else
-        return ptr > &a;
-}
+    std::vector<ErrorMessage> errors;
+
+    // Report unmatched suppressions
+    for (const SuppressionList::Suppression &s : unmatched) {
+        // check if this unmatched suppression is suppressed
+        bool suppressed = false;
+        for (const SuppressionList::Suppression &s2 : unmatched) {
+            if (s2.errorId == "unmatchedSuppression") {
+                if ((s2.fileName.empty() || s2.fileName == "*" || s2.fileName == s.fileName) &&
+                    (s2.lineNumber == SuppressionList::Suppression::NO_LINE || s2.lineNumber == s.lineNumber)) {
+                    suppressed = true;
+                    break;
+                }
+            }
+        }
 
-/* (declare this list here, so it may be used in signal handlers in addition to main())
- * A list of signals available in ISO C
- * Check out http://pubs.opengroup.org/onlinepubs/009695399/basedefs/signal.h.html
- * For now we only want to detect abnormal behaviour for a few selected signals:
- */
+        if (suppressed)
+            continue;
 
-#define DECLARE_SIGNAL(x) std::make_pair(x, #x)
-typedef std::map<int, std::string> Signalmap_t;
-static const Signalmap_t listofsignals = {
-    DECLARE_SIGNAL(SIGABRT),
-    DECLARE_SIGNAL(SIGBUS),
-    DECLARE_SIGNAL(SIGFPE),
-    DECLARE_SIGNAL(SIGILL),
-    DECLARE_SIGNAL(SIGINT),
-    DECLARE_SIGNAL(SIGQUIT),
-    DECLARE_SIGNAL(SIGSEGV),
-    DECLARE_SIGNAL(SIGSYS),
-    // don't care: SIGTERM
-    DECLARE_SIGNAL(SIGUSR1),
-    //DECLARE_SIGNAL(SIGUSR2) no usage currently
-};
-#undef DECLARE_SIGNAL
-/*
- * Entry pointer for signal handlers
- * It uses functions which are not safe to be called from a signal handler,
- * (http://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html#tag_15_04 has a whitelist)
- * but when ending up here something went terribly wrong anyway.
- * And all which is left is just printing some information and terminate.
- */
-static void CppcheckSignalHandler(int signo, siginfo_t * info, void * context)
-{
-    int type = -1;
-    pid_t killid;
-#if defined(__linux__) && defined(REG_ERR)
-    const ucontext_t* const uc = reinterpret_cast<const ucontext_t*>(context);
-    killid = (pid_t) syscall(SYS_gettid);
-    if (uc) {
-        type = (int)uc->uc_mcontext.gregs[REG_ERR] & 2;
-    }
-#else
-    UNUSED(context);
-    killid = getpid();
-#endif
+        const bool skip = std::any_of(filters.cbegin(), filters.cend(), [&s](const std::string& filter) {
+            return matchglob(filter, s.errorId);
+        });
+        if (skip)
+            continue;
 
-    const Signalmap_t::const_iterator it=listofsignals.find(signo);
-    const char * const signame = (it==listofsignals.end()) ? "unknown" : it->second.c_str();
-    bool printCallstack=true; // try to print a callstack?
-    bool lowMem=false; // was low-memory condition detected? Be careful then! Avoid allocating much more memory then.
-    bool unexpectedSignal=true; // unexpected indicates program failure
-    bool terminate=true; // exit process/thread
-    const bool isAddressOnStack = IsAddressOnStack(info->si_addr);
-    FILE* output = CppCheckExecutor::getExceptionOutput();
-    switch (signo) {
-    case SIGABRT:
-        fputs("Internal error: cppcheck received signal ", output);
-        fputs(signame, output);
-        fputs(
-#ifdef NDEBUG
-            " - out of memory?\n",
-#else
-            " - out of memory or assertion?\n",
-#endif
-            output);
-        lowMem=true; // educated guess
-        break;
-    case SIGBUS:
-        fputs("Internal error: cppcheck received signal ", output);
-        fputs(signame, output);
-        switch (info->si_code) {
-        case BUS_ADRALN: // invalid address alignment
-            fputs(" - BUS_ADRALN", output);
-            break;
-        case BUS_ADRERR: // nonexistent physical address
-            fputs(" - BUS_ADRERR", output);
-            break;
-        case BUS_OBJERR: // object-specific hardware error
-            fputs(" - BUS_OBJERR", output);
-            break;
-#ifdef BUS_MCEERR_AR
-        case BUS_MCEERR_AR: // Hardware memory error consumed on a machine check;
-            fputs(" - BUS_MCEERR_AR", output);
-            break;
-#endif
-#ifdef BUS_MCEERR_AO
-        case BUS_MCEERR_AO: // Hardware memory error detected in process but not consumed
-            fputs(" - BUS_MCEERR_AO", output);
-            break;
-#endif
-        default:
-            break;
+        std::list<ErrorMessage::FileLocation> callStack;
+        if (!s.fileName.empty()) {
+            callStack.emplace_back(s.fileName, s.lineNumber == -1 ? 0 : s.lineNumber, 0); // TODO: set column - see #13810 / get rid of s.lineNumber == -1 hack
         }
-        fprintf(output, " (at 0x%lx).\n",
-                (unsigned long)info->si_addr);
-        break;
-    case SIGFPE:
-        fputs("Internal error: cppcheck received signal ", output);
-        fputs(signame, output);
-        switch (info->si_code) {
-        case FPE_INTDIV: //     integer divide by zero
-            fputs(" - FPE_INTDIV", output);
-            break;
-        case FPE_INTOVF: //     integer overflow
-            fputs(" - FPE_INTOVF", output);
-            break;
-        case FPE_FLTDIV: //     floating-point divide by zero
-            fputs(" - FPE_FLTDIV", output);
-            break;
-        case FPE_FLTOVF: //     floating-point overflow
-            fputs(" - FPE_FLTOVF", output);
-            break;
-        case FPE_FLTUND: //     floating-point underflow
-            fputs(" - FPE_FLTUND", output);
-            break;
-        case FPE_FLTRES: //     floating-point inexact result
-            fputs(" - FPE_FLTRES", output);
-            break;
-        case FPE_FLTINV: //     floating-point invalid operation
-            fputs(" - FPE_FLTINV", output);
-            break;
-        case FPE_FLTSUB: //     subscript out of range
-            fputs(" - FPE_FLTSUB", output);
-            break;
-        default:
-            break;
-        }
-        fprintf(output, " (at 0x%lx).\n",
-                (unsigned long)info->si_addr);
-        break;
-    case SIGILL:
-        fputs("Internal error: cppcheck received signal ", output);
-        fputs(signame, output);
-        switch (info->si_code) {
-        case ILL_ILLOPC: //     illegal opcode
-            fputs(" - ILL_ILLOPC", output);
-            break;
-        case ILL_ILLOPN: //    illegal operand
-            fputs(" - ILL_ILLOPN", output);
-            break;
-        case ILL_ILLADR: //    illegal addressing mode
-            fputs(" - ILL_ILLADR", output);
-            break;
-        case ILL_ILLTRP: //    illegal trap
-            fputs(" - ILL_ILLTRP", output);
-            break;
-        case ILL_PRVOPC: //    privileged opcode
-            fputs(" - ILL_PRVOPC", output);
-            break;
-        case ILL_PRVREG: //    privileged register
-            fputs(" - ILL_PRVREG", output);
-            break;
-        case ILL_COPROC: //    coprocessor error
-            fputs(" - ILL_COPROC", output);
-            break;
-        case ILL_BADSTK: //    internal stack error
-            fputs(" - ILL_BADSTK", output);
-            break;
-        default:
-            break;
-        }
-        fprintf(output, " (at 0x%lx).%s\n",
-                (unsigned long)info->si_addr,
-                (isAddressOnStack)?" Stackoverflow?":"");
-        break;
-    case SIGINT:
-        unexpectedSignal=false; // legal usage: interrupt application via CTRL-C
-        fputs("cppcheck received signal ", output);
-        fputs(signame, output);
-        printCallstack=true;
-        fputs(".\n", output);
-        break;
-    case SIGSEGV:
-        fputs("Internal error: cppcheck received signal ", output);
-        fputs(signame, output);
-        switch (info->si_code) {
-        case SEGV_MAPERR: //    address not mapped to object
-            fputs(" - SEGV_MAPERR", output);
-            break;
-        case SEGV_ACCERR: //    invalid permissions for mapped object
-            fputs(" - SEGV_ACCERR", output);
-            break;
-        default:
-            break;
-        }
-        fprintf(output, " (%sat 0x%lx).%s\n",
-                // cppcheck-suppress knownConditionTrueFalse ; FP
-                (type==-1)? "" :
-                (type==0) ? "reading " : "writing ",
-                (unsigned long)info->si_addr,
-                (isAddressOnStack)?" Stackoverflow?":""
-               );
-        break;
-    case SIGUSR1:
-        fputs("cppcheck received signal ", output);
-        fputs(signame, output);
-        fputs(".\n", output);
-        terminate=false;
-        break;
-    default:
-        fputs("Internal error: cppcheck received signal ", output);
-        fputs(signame, output);
-        fputs(".\n", output);
-        break;
-    }
-    if (printCallstack) {
-        print_stacktrace(output, true, -1, lowMem);
-    }
-    if (unexpectedSignal) {
-        fputs("\nPlease report this to the cppcheck developers!\n", output);
-    }
-    fflush(output);
-
-    if (terminate) {
-        // now let things proceed, shutdown and hopefully dump core for post-mortem analysis
-        struct sigaction act;
-        memset(&act, 0, sizeof(act));
-        act.sa_handler=SIG_DFL;
-        sigaction(signo, &act, nullptr);
-        kill(killid, signo);
+        const std::string unmatchedSuppressionId = s.isPolyspace ? "unmatchedPolyspaceSuppression" : "unmatchedSuppression";
+        errors.emplace_back(std::move(callStack), "", Severity::information, "Unmatched suppression: " + s.errorId, unmatchedSuppressionId, Certainty::normal);
     }
+
+    return errors;
 }
-#endif
 
-#ifdef USE_WINDOWS_SEH
-namespace {
-    const ULONG maxnamelength = 512;
-    struct IMAGEHLP_SYMBOL64_EXT : public IMAGEHLP_SYMBOL64 {
-        TCHAR NameExt[maxnamelength]; // actually no need to worry about character encoding here
-    };
-    typedef BOOL (WINAPI *fpStackWalk64)(DWORD, HANDLE, HANDLE, LPSTACKFRAME64, PVOID, PREAD_PROCESS_MEMORY_ROUTINE64, PFUNCTION_TABLE_ACCESS_ROUTINE64, PGET_MODULE_BASE_ROUTINE64, PTRANSLATE_ADDRESS_ROUTINE64);
-    fpStackWalk64 pStackWalk64;
-    typedef DWORD64(WINAPI *fpSymGetModuleBase64)(HANDLE, DWORD64);
-    fpSymGetModuleBase64 pSymGetModuleBase64;
-    typedef BOOL (WINAPI *fpSymGetSymFromAddr64)(HANDLE, DWORD64, PDWORD64, PIMAGEHLP_SYMBOL64);
-    fpSymGetSymFromAddr64 pSymGetSymFromAddr64;
-    typedef BOOL (WINAPI *fpSymGetLineFromAddr64)(HANDLE, DWORD64, PDWORD, PIMAGEHLP_LINE64);
-    fpSymGetLineFromAddr64 pSymGetLineFromAddr64;
-    typedef DWORD (WINAPI *fpUnDecorateSymbolName)(const TCHAR*, PTSTR, DWORD, DWORD) ;
-    fpUnDecorateSymbolName pUnDecorateSymbolName;
-    typedef PVOID(WINAPI *fpSymFunctionTableAccess64)(HANDLE, DWORD64);
-    fpSymFunctionTableAccess64 pSymFunctionTableAccess64;
-    typedef BOOL (WINAPI *fpSymInitialize)(HANDLE, PCSTR, BOOL);
-    fpSymInitialize pSymInitialize;
-
-    HMODULE hLibDbgHelp;
-// avoid explicit dependency on Dbghelp.dll
-    bool loadDbgHelp()
+bool CppCheckExecutor::reportUnmatchedSuppressions(const Settings &settings, const SuppressionList& suppressions, const std::list<FileWithDetails> &files, const std::list<FileSettings>& fileSettings, ErrorLogger& errorLogger) {
+    // the two inputs may only be used exclusively
+    assert(!(!files.empty() && !fileSettings.empty()));
+
+    // bail out if there is a suppression of unmatchedSuppression which matches any file
+    auto suppr = suppressions.getSuppressions();
+    if (std::any_of(suppr.cbegin(), suppr.cend(), [](const SuppressionList::Suppression& s) {
+        return s.errorId == "unmatchedSuppression" && (s.fileName.empty() || s.fileName == "*") && s.lineNumber == SuppressionList::Suppression::NO_LINE;
+    }))
+        return false;
+
+    SuppressionList supprlist;
+
+    const bool doUnusedFunctionOnly = Settings::unusedFunctionOnly();
+    // ignore all other suppressions if we use the unusedFunction hack
+    for (auto&& s : suppr)
     {
-        hLibDbgHelp = ::LoadLibraryW(L"Dbghelp.dll");
-        if (!hLibDbgHelp)
-            return false;
-        pStackWalk64 = (fpStackWalk64) ::GetProcAddress(hLibDbgHelp, "StackWalk64");
-        pSymGetModuleBase64 = (fpSymGetModuleBase64) ::GetProcAddress(hLibDbgHelp, "SymGetModuleBase64");
-        pSymGetSymFromAddr64 = (fpSymGetSymFromAddr64) ::GetProcAddress(hLibDbgHelp, "SymGetSymFromAddr64");
-        pSymGetLineFromAddr64 = (fpSymGetLineFromAddr64)::GetProcAddress(hLibDbgHelp, "SymGetLineFromAddr64");
-        pSymFunctionTableAccess64 = (fpSymFunctionTableAccess64)::GetProcAddress(hLibDbgHelp, "SymFunctionTableAccess64");
-        pSymInitialize = (fpSymInitialize) ::GetProcAddress(hLibDbgHelp, "SymInitialize");
-        pUnDecorateSymbolName = (fpUnDecorateSymbolName)::GetProcAddress(hLibDbgHelp, "UnDecorateSymbolName");
-        return true;
+        // TODO: checkersReport should not be reported - see #13387
+        if (doUnusedFunctionOnly && s.errorId != "unusedFunction" && s.errorId != "checkersReport")
+            continue;
+        supprlist.addSuppression(std::move(s));
     }
 
+    const auto reportErrorsFn = [&](const std::string& sourcefile, std::size_t fsFileId, const std::vector<ErrorMessage>& errors) -> bool {
+        if (errors.empty())
+            return false;
 
-    void PrintCallstack(FILE* outputFile, PEXCEPTION_POINTERS ex)
-    {
-        if (!loadDbgHelp())
-            return;
-        const HANDLE hProcess   = GetCurrentProcess();
-        const HANDLE hThread    = GetCurrentThread();
-        pSymInitialize(
-            hProcess,
-            nullptr,
-            TRUE
-        );
-        CONTEXT             context = *(ex->ContextRecord);
-        STACKFRAME64        stack= {0};
-#ifdef _M_IX86
-        stack.AddrPC.Offset    = context.Eip;
-        stack.AddrPC.Mode      = AddrModeFlat;
-        stack.AddrStack.Offset = context.Esp;
-        stack.AddrStack.Mode   = AddrModeFlat;
-        stack.AddrFrame.Offset = context.Ebp;
-        stack.AddrFrame.Mode   = AddrModeFlat;
-#else
-        stack.AddrPC.Offset    = context.Rip;
-        stack.AddrPC.Mode      = AddrModeFlat;
-        stack.AddrStack.Offset = context.Rsp;
-        stack.AddrStack.Mode   = AddrModeFlat;
-        stack.AddrFrame.Offset = context.Rsp;
-        stack.AddrFrame.Mode   = AddrModeFlat;
-#endif
-        IMAGEHLP_SYMBOL64_EXT symbol;
-        symbol.SizeOfStruct  = sizeof(IMAGEHLP_SYMBOL64);
-        symbol.MaxNameLength = maxnamelength;
-        DWORD64 displacement   = 0;
-        int beyond_main=-1; // emergency exit, see below
-        for (ULONG frame = 0; ; frame++) {
-            BOOL result = pStackWalk64
-                          (
-#ifdef _M_IX86
-                              IMAGE_FILE_MACHINE_I386,
-#else
-                              IMAGE_FILE_MACHINE_AMD64,
-#endif
-                              hProcess,
-                              hThread,
-                              &stack,
-                              &context,
-                              nullptr,
-                              pSymFunctionTableAccess64,
-                              pSymGetModuleBase64,
-                              nullptr
-                          );
-            if (!result)  // official end...
-                break;
-            pSymGetSymFromAddr64(hProcess, (ULONG64)stack.AddrPC.Offset, &displacement, &symbol);
-            TCHAR undname[maxnamelength]= {0};
-            pUnDecorateSymbolName((const TCHAR*)symbol.Name, (PTSTR)undname, (DWORD)GetArrayLength(undname), UNDNAME_COMPLETE);
-            if (beyond_main>=0)
-                ++beyond_main;
-            if (_tcscmp(undname, _T("main"))==0)
-                beyond_main=0;
-            fprintf(outputFile,
-                    "%lu. 0x%08I64X in ",
-                    frame, (ULONG64)stack.AddrPC.Offset);
-            fputs((const char *)undname, outputFile);
-            fputc('\n', outputFile);
-            if (0==stack.AddrReturn.Offset || beyond_main>2) // StackWalk64() sometimes doesn't reach any end...
-                break;
+        // TODO: what if sourcefile is empty?
+
+        AnalyzerInformation analyzerInfo;
+        // FIXME: this is a horrible hack
+        // we need to "re-open" the file so we can add the unmatchedSuppression findings.
+        // we cannot keep it open conditionally because the whole program analysis reads the XML.
+        // re-ordering the code is also not an option because the unmatched suppression reporting needs to be run after all other checks.
+        analyzerInfo.reopen(settings.buildDir, sourcefile, /*cfgname*/ "", fsFileId);
+
+        for (const auto& errmsg : errors) {
+            analyzerInfo.reportErr(errmsg);
+            errorLogger.reportErr(errmsg);
         }
+        return true;
+    };
 
-        FreeLibrary(hLibDbgHelp);
-        hLibDbgHelp=nullptr;
+    bool err = false;
+
+    for (auto i = files.cbegin(); i != files.cend(); ++i) {
+        const std::vector<ErrorMessage> errors = getUnmatchedSuppressions(supprlist.getUnmatchedLocalSuppressions(*i), settings.unmatchedSuppressionFilters);
+        err |= reportErrorsFn(i->spath(), i->fsFileId(), errors);
     }
 
-    void writeMemoryErrorDetails(FILE* outputFile, PEXCEPTION_POINTERS ex, const char* description)
-    {
-        fputs(description, outputFile);
-        fprintf(outputFile, " (instruction: 0x%p) ", ex->ExceptionRecord->ExceptionAddress);
-        // Using %p for ULONG_PTR later on, so it must have size identical to size of pointer
-        // This is not the universally portable solution but good enough for Win32/64
-        C_ASSERT(sizeof(void*) == sizeof(ex->ExceptionRecord->ExceptionInformation[1]));
-        switch (ex->ExceptionRecord->ExceptionInformation[0]) {
-        case 0:
-            fprintf(outputFile, "reading from 0x%p",
-                    reinterpret_cast<void*>(ex->ExceptionRecord->ExceptionInformation[1]));
-            break;
-        case 1:
-            fprintf(outputFile, "writing to 0x%p",
-                    reinterpret_cast<void*>(ex->ExceptionRecord->ExceptionInformation[1]));
-            break;
-        case 8:
-            fprintf(outputFile, "data execution prevention at 0x%p",
-                    reinterpret_cast<void*>(ex->ExceptionRecord->ExceptionInformation[1]));
-            break;
-        default:
-            break;
-        }
+    for (auto i = fileSettings.cbegin(); i != fileSettings.cend(); ++i) {
+        const std::vector<ErrorMessage> errors = getUnmatchedSuppressions(supprlist.getUnmatchedLocalSuppressions(i->file), settings.unmatchedSuppressionFilters);
+        err |= reportErrorsFn(i->file.spath(), i->file.fsFileId(), errors);
     }
 
-    /*
-     * Any evaluation of the exception needs to be done here!
-     */
-    int filterException(int code, PEXCEPTION_POINTERS ex)
-    {
-        FILE *outputFile = stdout;
-        fputs("Internal error: ", outputFile);
-        switch (ex->ExceptionRecord->ExceptionCode) {
-        case EXCEPTION_ACCESS_VIOLATION:
-            writeMemoryErrorDetails(outputFile, ex, "Access violation");
-            break;
-        case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
-            fputs("Out of array bounds", outputFile);
-            break;
-        case EXCEPTION_BREAKPOINT:
-            fputs("Breakpoint", outputFile);
-            break;
-        case EXCEPTION_DATATYPE_MISALIGNMENT:
-            fputs("Misaligned data", outputFile);
-            break;
-        case EXCEPTION_FLT_DENORMAL_OPERAND:
-            fputs("Denormalized floating-point value", outputFile);
-            break;
-        case EXCEPTION_FLT_DIVIDE_BY_ZERO:
-            fputs("Floating-point divide-by-zero", outputFile);
-            break;
-        case EXCEPTION_FLT_INEXACT_RESULT:
-            fputs("Inexact floating-point value", outputFile);
-            break;
-        case EXCEPTION_FLT_INVALID_OPERATION:
-            fputs("Invalid floating-point operation", outputFile);
-            break;
-        case EXCEPTION_FLT_OVERFLOW:
-            fputs("Floating-point overflow", outputFile);
-            break;
-        case EXCEPTION_FLT_STACK_CHECK:
-            fputs("Floating-point stack overflow", outputFile);
-            break;
-        case EXCEPTION_FLT_UNDERFLOW:
-            fputs("Floating-point underflow", outputFile);
-            break;
-        case EXCEPTION_GUARD_PAGE:
-            fputs("Page-guard access", outputFile);
-            break;
-        case EXCEPTION_ILLEGAL_INSTRUCTION:
-            fputs("Illegal instruction", outputFile);
-            break;
-        case EXCEPTION_IN_PAGE_ERROR:
-            writeMemoryErrorDetails(outputFile, ex, "Invalid page access");
-            break;
-        case EXCEPTION_INT_DIVIDE_BY_ZERO:
-            fputs("Integer divide-by-zero", outputFile);
-            break;
-        case EXCEPTION_INT_OVERFLOW:
-            fputs("Integer overflow", outputFile);
-            break;
-        case EXCEPTION_INVALID_DISPOSITION:
-            fputs("Invalid exception dispatcher", outputFile);
-            break;
-        case EXCEPTION_INVALID_HANDLE:
-            fputs("Invalid handle", outputFile);
-            break;
-        case EXCEPTION_NONCONTINUABLE_EXCEPTION:
-            fputs("Non-continuable exception", outputFile);
-            break;
-        case EXCEPTION_PRIV_INSTRUCTION:
-            fputs("Invalid instruction", outputFile);
-            break;
-        case EXCEPTION_SINGLE_STEP:
-            fputs("Single instruction step", outputFile);
-            break;
-        case EXCEPTION_STACK_OVERFLOW:
-            fputs("Stack overflow", outputFile);
-            break;
-        default:
-            fprintf(outputFile, "Unknown exception (%d)\n",
-                    code);
-            break;
+    if (settings.inlineSuppressions) {
+        const std::vector<ErrorMessage> errors = getUnmatchedSuppressions(supprlist.getUnmatchedInlineSuppressions(), settings.unmatchedSuppressionFilters);
+        for (const auto& errmsg : errors) {
+            std::string sourcefile;
+            if (!errmsg.callStack.empty())
+                sourcefile = errmsg.callStack.cbegin()->getfile(false); // TODO: simplify path?
+            err |= reportErrorsFn(sourcefile, 0, {errmsg});
         }
-        fputc('\n', outputFile);
-        PrintCallstack(outputFile, ex);
-        fflush(outputFile);
-        return EXCEPTION_EXECUTE_HANDLER;
     }
-}
-#endif
 
-/**
- * Signal/SEH handling
- * Has to be clean for using with SEH on windows, i.e. no construction of C++ object instances is allowed!
- * TODO Check for multi-threading issues!
- *
- */
-int CppCheckExecutor::check_wrapper(CppCheck& cppcheck, int argc, const char* const argv[])
-{
-#ifdef USE_WINDOWS_SEH
-    FILE *outputFile = stdout;
-    __try {
-        return check_internal(cppcheck, argc, argv);
-    } __except (filterException(GetExceptionCode(), GetExceptionInformation())) {
-        // reporting to stdout may not be helpful within a GUI application...
-        fputs("Please report this to the cppcheck developers!\n", outputFile);
-        return -1;
+    const std::vector<ErrorMessage> errors = getUnmatchedSuppressions(supprlist.getUnmatchedGlobalSuppressions(), settings.unmatchedSuppressionFilters);
+    for (const auto& errmsg : errors) {
+        std::string sourcefile;
+        if (!errmsg.callStack.empty())
+            sourcefile = errmsg.callStack.cbegin()->getfile(false); // TODO: simplify path?
+        err |= reportErrorsFn(sourcefile, 0, {errmsg});
     }
-#elif defined(USE_UNIX_SIGNAL_HANDLING)
-    // determine stack vs. heap
-    char stackVariable;
-    char *heapVariable=(char*)malloc(1);
-    bStackBelowHeap = &stackVariable < heapVariable;
-    free(heapVariable);
-
-    // set up alternative stack for signal handler
-    stack_t segv_stack;
-    segv_stack.ss_sp = mytstack;
-    segv_stack.ss_flags = 0;
-    segv_stack.ss_size = MYSTACKSIZE;
-    sigaltstack(&segv_stack, nullptr);
-
-    // install signal handler
-    struct sigaction act;
-    memset(&act, 0, sizeof(act));
-    act.sa_flags=SA_SIGINFO|SA_ONSTACK;
-    act.sa_sigaction=CppcheckSignalHandler;
-    for (std::map<int, std::string>::const_iterator sig=listofsignals.begin(); sig!=listofsignals.end(); ++sig) {
-        sigaction(sig->first, &act, nullptr);
-    }
-    return check_internal(cppcheck, argc, argv);
-#else
-    return check_internal(cppcheck, argc, argv);
-#endif
+    return err;
 }
 
 /*
  * That is a method which gets called from check_wrapper
  * */
-int CppCheckExecutor::check_internal(CppCheck& cppcheck, int /*argc*/, const char* const argv[])
+int CppCheckExecutor::check_internal(const Settings& settings, Suppressions& supprs) const
 {
-    Settings& settings = cppcheck.settings();
-    mSettings = &settings;
-    const bool std = tryLoadLibrary(settings.library, argv[0], "std.cfg");
-
-    for (const std::string &lib : settings.libraries) {
-        if (!tryLoadLibrary(settings.library, argv[0], lib.c_str())) {
-            const std::string msg("Failed to load the library " + lib);
-            const std::list<ErrorLogger::ErrorMessage::FileLocation> callstack;
-            ErrorLogger::ErrorMessage errmsg(callstack, emptyString, Severity::information, msg, "failedToLoadCfg", false);
-            reportErr(errmsg);
-            return EXIT_FAILURE;
-        }
-    }
-
-    bool posix = true;
-    if (settings.posix())
-        posix = tryLoadLibrary(settings.library, argv[0], "posix.cfg");
-    bool windows = true;
-    if (settings.isWindowsPlatform())
-        windows = tryLoadLibrary(settings.library, argv[0], "windows.cfg");
-
-    if (!std || !posix || !windows) {
-        const std::list<ErrorLogger::ErrorMessage::FileLocation> callstack;
-        const std::string msg("Failed to load " + std::string(!std ? "std.cfg" : !posix ? "posix.cfg" : "windows.cfg") + ". Your Cppcheck installation is broken, please re-install.");
-#ifdef FILESDIR
-        const std::string details("The Cppcheck binary was compiled with FILESDIR set to \""
-                                  FILESDIR "\" and will therefore search for "
-                                  "std.cfg in " FILESDIR "/cfg.");
-#else
-        const std::string cfgfolder(Path::fromNativeSeparators(Path::getPathFromFilename(argv[0])) + "cfg");
-        const std::string details("The Cppcheck binary was compiled without FILESDIR set. Either the "
-                                  "std.cfg should be available in " + cfgfolder + " or the FILESDIR "
-                                  "should be configured.");
-#endif
-        ErrorLogger::ErrorMessage errmsg(callstack, emptyString, Severity::information, msg+" "+details, "failedToLoadCfg", false);
-        reportErr(errmsg);
-        return EXIT_FAILURE;
-    }
+    StdLogger stdLogger(settings);
+    TimerResults timerResults;
 
-    if (settings.reportProgress)
-        mLatestProgressOutputTime = std::time(nullptr);
+    if (settings.reportProgress >= 0)
+        stdLogger.resetLatestProgressOutputTime();
 
-    if (!settings.outputFile.empty()) {
-        mErrorOutput = new std::ofstream(settings.outputFile);
-    }
-
-    if (settings.xml) {
-        reportErr(ErrorLogger::ErrorMessage::getXMLHeader());
+    if (settings.outputFormat == Settings::OutputFormat::xml) {
+        stdLogger.reportErr(ErrorMessage::getXMLHeader(settings.cppcheckCfgProductName, settings.xml_version));
     }
 
     if (!settings.buildDir.empty()) {
         std::list<std::string> fileNames;
-        for (std::map<std::string, std::size_t>::const_iterator i = mFiles.begin(); i != mFiles.end(); ++i)
-            fileNames.push_back(i->first);
-        AnalyzerInformation::writeFilesTxt(settings.buildDir, fileNames, settings.project.fileSettings);
+        for (auto i = mFiles.cbegin(); i != mFiles.cend(); ++i)
+            fileNames.emplace_back(i->path());
+        AnalyzerInformation::writeFilesTxt(settings.buildDir, fileNames, mFileSettings);
+
+        stdLogger.readActiveCheckers();
     }
 
-    unsigned int returnValue = 0;
-    if (settings.jobs == 1) {
-        // Single process
-        settings.jointSuppressionReport = true;
+    if (!settings.checkersReportFilename.empty())
+        std::remove(settings.checkersReportFilename.c_str());
 
-        std::size_t totalfilesize = 0;
-        for (std::map<std::string, std::size_t>::const_iterator i = mFiles.begin(); i != mFiles.end(); ++i) {
-            totalfilesize += i->second;
-        }
+    CppCheck cppcheck(settings, supprs, stdLogger, &timerResults, true, executeCommand);
 
-        std::size_t processedsize = 0;
-        unsigned int c = 0;
-        if (settings.project.fileSettings.empty()) {
-            for (std::map<std::string, std::size_t>::const_iterator i = mFiles.begin(); i != mFiles.end(); ++i) {
-                if (!mSettings->library.markupFile(i->first)
-                    || !mSettings->library.processMarkupAfterCode(i->first)) {
-                    returnValue += cppcheck.check(i->first);
-                    processedsize += i->second;
-                    if (!settings.quiet)
-                        reportStatus(c + 1, mFiles.size(), processedsize, totalfilesize);
-                    c++;
-                }
-            }
-        } else {
-
-            // filesettings
-            c = 0;
-            for (const ImportProject::FileSettings &fs : settings.project.fileSettings) {
-                returnValue += cppcheck.check(fs);
-                ++c;
-                if (!settings.quiet)
-                    reportStatus(c, settings.project.fileSettings.size(), c, settings.project.fileSettings.size());
-            }
+    unsigned int returnValue = 0;
+    if (settings.useSingleJob()) {
+        // Single process
+        SingleExecutor executor(cppcheck, mFiles, mFileSettings, settings, supprs, stdLogger, &timerResults);
+        returnValue = executor.check();
+    } else {
+#if defined(HAS_THREADING_MODEL_THREAD)
+        if (settings.executor == Settings::ExecutorType::Thread) {
+            ThreadExecutor executor(mFiles, mFileSettings, settings, supprs, stdLogger, &timerResults, CppCheckExecutor::executeCommand);
+            returnValue = executor.check();
         }
-
-        // second loop to parse all markup files which may not work until all
-        // c/cpp files have been parsed and checked
-        for (std::map<std::string, std::size_t>::const_iterator i = mFiles.begin(); i != mFiles.end(); ++i) {
-            if (mSettings->library.markupFile(i->first) && mSettings->library.processMarkupAfterCode(i->first)) {
-                returnValue += cppcheck.check(i->first);
-                processedsize += i->second;
-                if (!settings.quiet)
-                    reportStatus(c + 1, mFiles.size(), processedsize, totalfilesize);
-                c++;
-            }
+#endif
+#if defined(HAS_THREADING_MODEL_FORK)
+        if (settings.executor == Settings::ExecutorType::Process) {
+            ProcessExecutor executor(mFiles, mFileSettings, settings, supprs, stdLogger, &timerResults, CppCheckExecutor::executeCommand);
+            returnValue = executor.check();
         }
-        if (cppcheck.analyseWholeProgram())
-            returnValue++;
-    } else if (!ThreadExecutor::isEnabled()) {
-        std::cout << "No thread support yet implemented for this platform." << std::endl;
-    } else {
-        // Multiple processes
-        ThreadExecutor executor(mFiles, settings, *this);
-        returnValue = executor.check();
+#endif
     }
 
-    cppcheck.analyseWholeProgram(mSettings->buildDir, mFiles);
-
-    if (settings.isEnabled(Settings::INFORMATION) || settings.checkConfiguration) {
-        const bool enableUnusedFunctionCheck = cppcheck.isUnusedFunctionCheckEnabled();
-
-        if (settings.jointSuppressionReport) {
-            for (std::map<std::string, std::size_t>::const_iterator i = mFiles.begin(); i != mFiles.end(); ++i) {
-                const bool err = reportUnmatchedSuppressions(settings.nomsg.getUnmatchedLocalSuppressions(i->first, enableUnusedFunctionCheck));
-                if (err && returnValue == 0)
-                    returnValue = settings.exitCode;
-            }
-        }
+    // TODO: is this run again instead of using previously cached results?
+    returnValue |= cppcheck.analyseWholeProgram(settings.buildDir, mFiles, mFileSettings, stdLogger.getCtuInfo());
 
-        const bool err = reportUnmatchedSuppressions(settings.nomsg.getUnmatchedGlobalSuppressions(enableUnusedFunctionCheck));
+    if ((settings.severity.isEnabled(Severity::information) || settings.checkConfiguration) && !supprs.nomsg.getSuppressions().empty()) {
+        const bool err = reportUnmatchedSuppressions(settings, supprs.nomsg, mFiles, mFileSettings, stdLogger);
         if (err && returnValue == 0)
             returnValue = settings.exitCode;
     }
 
-    if (!settings.checkConfiguration) {
-        cppcheck.tooManyConfigsError("",0U);
-
-        if (settings.isEnabled(Settings::MISSING_INCLUDE) && (Preprocessor::missingIncludeFlag || Preprocessor::missingSystemIncludeFlag)) {
-            const std::list<ErrorLogger::ErrorMessage::FileLocation> callStack;
-            ErrorLogger::ErrorMessage msg(callStack,
-                                          emptyString,
-                                          Severity::information,
-                                          "Cppcheck cannot find all the include files (use --check-config for details)\n"
-                                          "Cppcheck cannot find all the include files. Cppcheck can check the code without the "
-                                          "include files found. But the results will probably be more accurate if all the include "
-                                          "files are found. Please check your project's include directories and add all of them "
-                                          "as include directories for Cppcheck. To see what files Cppcheck cannot find use "
-                                          "--check-config.",
-                                          Preprocessor::missingIncludeFlag ? "missingInclude" : "missingIncludeSystem",
-                                          false);
-            reportInfo(msg);
-        }
-    }
+    stdLogger.writeCheckersReport(supprs);
 
-    if (settings.xml) {
-        reportErr(ErrorLogger::ErrorMessage::getXMLFooter());
+    if (settings.outputFormat == Settings::OutputFormat::xml) {
+        if (settings.xml_version == 3)
+            stdLogger.reportMetrics();
+        stdLogger.reportErr(ErrorMessage::getXMLFooter(settings.xml_version));
     }
 
-    mSettings = nullptr;
+    if (settings.safety && stdLogger.hasCriticalErrors())
+        return EXIT_FAILURE;
+
     if (returnValue)
         return settings.exitCode;
-    return 0;
+    return EXIT_SUCCESS;
+}
+
+void StdLogger::writeCheckersReport(const Suppressions& supprs)
+{
+    if (!mCheckersFile.empty())
+    {
+        std::ofstream fout(mCheckersFile);
+        for (const auto& c : mActiveCheckers)
+        {
+            fout << c << std::endl;
+        }
+    }
+
+    const bool summary = mSettings.safety || mSettings.severity.isEnabled(Severity::information);
+    const bool xmlReport = mSettings.outputFormat == Settings::OutputFormat::xml && mSettings.xml_version == 3;
+    const bool textReport = !mSettings.checkersReportFilename.empty();
+
+    if (!summary && !xmlReport && !textReport)
+        return;
+
+    CheckersReport checkersReport(mSettings, mActiveCheckers);
+
+    const auto& suppressions = supprs.nomsg.getSuppressions();
+    const bool summarySuppressed = std::any_of(suppressions.cbegin(), suppressions.cend(), [](const SuppressionList::Suppression& s) {
+        return s.errorId == "checkersReport";
+    });
+
+    if (summary && !summarySuppressed) {
+        ErrorMessage msg;
+        msg.severity = Severity::information;
+        msg.id = "checkersReport";
+
+        const int activeCheckers = checkersReport.getActiveCheckersCount();
+        const int totalCheckers = checkersReport.getAllCheckersCount();
+
+        std::string what;
+        if (mCriticalErrors.empty())
+            what = std::to_string(activeCheckers) + "/" + std::to_string(totalCheckers);
+        else
+            what = "There was critical errors";
+        if (!xmlReport && !textReport)
+            what += " (use --checkers-report=<filename> to see details)";
+        msg.setmsg("Active checkers: " + what);
+
+        reportErr(msg);
+    }
+
+    if (textReport) {
+        std::ofstream fout(mSettings.checkersReportFilename);
+        if (fout.is_open())
+            fout << checkersReport.getReport(mCriticalErrors);
+    }
+
+    if (xmlReport) {
+        reportErr("    </errors>\n");
+        if (mSettings.safety)
+            reportErr("    <safety/>\n");
+        if (mSettings.inlineSuppressions)
+            reportErr("    <inline-suppr/>\n");
+        if (!suppressions.empty()) {
+            std::ostringstream suppressionsXml;
+            supprs.nomsg.dump(suppressionsXml);
+            reportErr(suppressionsXml.str());
+        }
+        reportErr(checkersReport.getXmlReport(mCriticalErrors));
+    }
 }
 
 #ifdef _WIN32
@@ -982,7 +566,7 @@ static inline std::string ansiToOEM(const std::string &msg, bool doConvert)
         // ansi code page characters to wide characters
         MultiByteToWideChar(CP_ACP, 0, msg.data(), msglength, wcContainer.data(), msglength);
         // wide characters to oem codepage characters
-        WideCharToMultiByte(CP_OEMCP, 0, wcContainer.data(), msglength, const_cast<char *>(result.data()), msglength, nullptr, nullptr);
+        WideCharToMultiByte(CP_OEMCP, 0, wcContainer.data(), msglength, &result[0], msglength, nullptr, nullptr);
 
         return result; // hope for return value optimization
     }
@@ -993,35 +577,35 @@ static inline std::string ansiToOEM(const std::string &msg, bool doConvert)
 #define ansiToOEM(msg, doConvert) (msg)
 #endif
 
-void CppCheckExecutor::reportErr(const std::string &errmsg)
+void StdLogger::reportErr(const std::string &errmsg)
 {
-    // Alert only about unique errors
-    if (mShownErrors.find(errmsg) != mShownErrors.end())
-        return;
-
-    mShownErrors.insert(errmsg);
     if (mErrorOutput)
         *mErrorOutput << errmsg << std::endl;
     else {
-        std::cerr << ansiToOEM(errmsg, (mSettings == nullptr) ? true : !mSettings->xml) << std::endl;
+        std::cerr << ansiToOEM(errmsg, mSettings.outputFormat != Settings::OutputFormat::xml) << std::endl;
     }
 }
 
-void CppCheckExecutor::reportOut(const std::string &outmsg)
+void StdLogger::reportOut(const std::string &outmsg, Color c)
 {
-    std::cout << ansiToOEM(outmsg, true) << std::endl;
+    if (c == Color::Reset)
+        std::cout << ansiToOEM(outmsg, true) << std::endl;
+    else
+        std::cout << c << ansiToOEM(outmsg, true) << Color::Reset << std::endl;
 }
 
-void CppCheckExecutor::reportProgress(const std::string &filename, const char stage[], const std::size_t value)
+// TODO: remove filename parameter?
+void StdLogger::reportProgress(const std::string &filename, const char stage[], const std::size_t value)
 {
     (void)filename;
 
     if (!mLatestProgressOutputTime)
         return;
 
-    // Report progress messages every 10 seconds
+    // Report progress messages every x seconds
     const std::time_t currentTime = std::time(nullptr);
-    if (currentTime >= (mLatestProgressOutputTime + 10)) {
+    if (currentTime >= (mLatestProgressOutputTime + mSettings.reportProgress))
+    {
         mLatestProgressOutputTime = currentTime;
 
         // format a progress message
@@ -1035,84 +619,118 @@ void CppCheckExecutor::reportProgress(const std::string &filename, const char st
     }
 }
 
-void CppCheckExecutor::reportInfo(const ErrorLogger::ErrorMessage &msg)
+void StdLogger::reportErr(const ErrorMessage &msg)
 {
-    reportErr(msg);
-}
+    if (msg.severity == Severity::internal && (msg.id == "logChecker" || endsWith(msg.id, "-logChecker"))) {
+        const std::string& checker = msg.shortMessage();
+        mActiveCheckers.emplace(checker);
+        return;
+    }
 
-void CppCheckExecutor::reportStatus(std::size_t fileindex, std::size_t filecount, std::size_t sizedone, std::size_t sizetotal)
-{
-    if (filecount > 1) {
-        std::ostringstream oss;
-        const long percentDone = (sizetotal > 0) ? static_cast<long>(static_cast<long double>(sizedone) / sizetotal * 100) : 0;
-        oss << fileindex << '/' << filecount
-            << " files checked " << percentDone
-            << "% done";
-        std::cout << oss.str() << std::endl;
+    if (msg.severity == Severity::internal && msg.id == "ctuinfo") {
+        mCtuInfo += msg.shortMessage() + "\n";
+        return;
     }
-}
 
-void CppCheckExecutor::reportErr(const ErrorLogger::ErrorMessage &msg)
-{
-    if (mShowAllErrors) {
-        reportOut(msg.toXML());
-    } else if (mSettings->xml) {
-        reportErr(msg.toXML());
+    if (ErrorLogger::isCriticalErrorId(msg.id) && mCriticalErrors.find(msg.id) == std::string::npos) {
+        if (!mCriticalErrors.empty())
+            mCriticalErrors += ", ";
+        mCriticalErrors += msg.id;
+        if (msg.severity == Severity::internal)
+            mCriticalErrors += " (suppressed)";
+    }
+
+    if (msg.severity == Severity::internal)
+        return;
+
+    ErrorMessage msgCopy = msg;
+    msgCopy.guideline = getGuideline(msgCopy.id, mSettings.reportType,
+                                     mGuidelineMapping, msgCopy.severity);
+    msgCopy.classification = getClassification(msgCopy.guideline, mSettings.reportType);
+
+    // TODO: there should be no need for verbose and default messages here
+    const std::string msgStr =
+        msgCopy.toString(mSettings.verbose, mSettings.templateFormat, mSettings.templateLocation);
+
+    // Alert only about unique errors
+    if (!mSettings.emitDuplicates && !mShownErrors.insert(msgStr).second)
+        return;
+
+    if (mSettings.outputFormat == Settings::OutputFormat::sarif) {
+        mSarifReport.addFinding(std::move(msgCopy));
+    } else if (mSettings.outputFormat == Settings::OutputFormat::xml) {
+        reportErr(msgCopy.toXML());
     } else {
-        reportErr(msg.toString(mSettings->verbose, mSettings->templateFormat, mSettings->templateLocation));
+        reportErr(msgStr);
     }
 }
 
-void CppCheckExecutor::setExceptionOutput(FILE* exceptionOutput)
+/**
+ * Execute a shell command and read the output from it. Returns true if command terminated successfully.
+ */
+// cppcheck-suppress passedByValueCallback - used as callback so we need to preserve the signature
+// NOLINTNEXTLINE(performance-unnecessary-value-param) - used as callback so we need to preserve the signature
+int CppCheckExecutor::executeCommand(std::string exe, std::vector<std::string> args, std::string redirect, std::string &output_)
 {
-    mExceptionOutput = exceptionOutput;
-}
+    output_.clear();
 
-FILE* CppCheckExecutor::getExceptionOutput()
-{
-    return mExceptionOutput;
-}
+#ifdef _WIN32
+    // Extra quoutes are needed in windows if filename has space
+    if (exe.find(" ") != std::string::npos)
+        exe = "\"" + exe + "\"";
+#endif
 
-bool CppCheckExecutor::tryLoadLibrary(Library& destination, const char* basepath, const char* filename)
-{
-    const Library::Error err = destination.load(basepath, filename);
-
-    if (err.errorcode == Library::UNKNOWN_ELEMENT)
-        std::cout << "cppcheck: Found unknown elements in configuration file '" << filename << "': " << err.reason << std::endl;
-    else if (err.errorcode != Library::OK) {
-        std::string errmsg;
-        switch (err.errorcode) {
-        case Library::OK:
-            break;
-        case Library::FILE_NOT_FOUND:
-            errmsg = "File not found";
-            break;
-        case Library::BAD_XML:
-            errmsg = "Bad XML";
-            break;
-        case Library::UNKNOWN_ELEMENT:
-            errmsg = "Unexpected element";
-            break;
-        case Library::MISSING_ATTRIBUTE:
-            errmsg = "Missing attribute";
-            break;
-        case Library::BAD_ATTRIBUTE_VALUE:
-            errmsg = "Bad attribute value";
-            break;
-        case Library::UNSUPPORTED_FORMAT:
-            errmsg = "File is of unsupported format version";
-            break;
-        case Library::DUPLICATE_PLATFORM_TYPE:
-            errmsg = "Duplicate platform type";
-            break;
-        case Library::PLATFORM_TYPE_REDEFINED:
-            errmsg = "Platform type redefined";
-            break;
-        }
-        if (!err.reason.empty())
-            errmsg += " '" + err.reason + "'";
-        std::cout << "cppcheck: Failed to load library configuration file '" << filename << "'. " << errmsg << std::endl;
-        return false;
+    std::string joinedArgs;
+    for (const std::string &arg : args) {
+        if (!joinedArgs.empty())
+            joinedArgs += " ";
+        if (arg.find(' ') != std::string::npos)
+            joinedArgs += '"' + arg + '"';
+        else
+            joinedArgs += arg;
+    }
+
+    std::string cmd = exe + " " + joinedArgs + " " + redirect;
+
+#ifdef _WIN32
+    cmd = "\"" + cmd + "\"";
+    FILE* p = _popen(cmd.c_str(), "r");
+#else
+    FILE *p = popen(cmd.c_str(), "r");
+#endif
+    //std::cout << "invoking command '" << cmd << "'" << std::endl;
+    if (!p) {
+        // TODO: how to provide to caller?
+        //const int err = errno;
+        //std::cout << "popen() errno " << std::to_string(err) << std::endl;
+        return -1;
+    }
+    char buffer[1024];
+    while (fgets(buffer, sizeof(buffer), p) != nullptr)
+        output_ += buffer;
+
+#ifdef _WIN32
+    const int res = _pclose(p);
+#elif defined(__APPLE__) && defined(__MACH__)
+    // the W* macros cast to int* on macOS
+    int res = pclose(p);
+#else
+    const int res = pclose(p);
+#endif
+    if (res == -1) { // error occurred
+        // TODO: how to provide to caller?
+        //const int err = errno;
+        //std::cout << "pclose() errno " << std::to_string(err) << std::endl;
+        return res;
+    }
+#if !defined(_WIN32) && !defined(__MINGW32__)
+    if (WIFEXITED(res)) {
+        return WEXITSTATUS(res);
     }
-    return true;
+    if (WIFSIGNALED(res)) {
+        return WTERMSIG(res);
+    }
+#endif
+    return res;
 }
+
diff --git a/cli/cppcheckexecutor.h b/cli/cppcheckexecutor.h
index bd307e81c69..a1b35280597 100644
--- a/cli/cppcheckexecutor.h
+++ b/cli/cppcheckexecutor.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,17 +19,16 @@
 #ifndef CPPCHECKEXECUTOR_H
 #define CPPCHECKEXECUTOR_H
 
-#include "errorlogger.h"
+#include "filesettings.h"
 
-#include <cstdio>
-#include <ctime>
-#include <map>
-#include <set>
+#include <list>
 #include <string>
+#include <vector>
 
-class CppCheck;
-class Library;
 class Settings;
+class ErrorLogger;
+class SuppressionList;
+struct Suppressions;
 
 /**
  * This class works as an example of how CppCheck can be used in external
@@ -38,17 +37,14 @@ class Settings;
  * just rewrite this class for your needs and possibly use other methods
  * from CppCheck class instead the ones used here.
  */
-class CppCheckExecutor : public ErrorLogger {
+class CppCheckExecutor {
 public:
     /**
      * Constructor
      */
-    CppCheckExecutor();
-
-    /**
-     * Destructor
-     */
-    ~CppCheckExecutor() OVERRIDE;
+    CppCheckExecutor() = default;
+    CppCheckExecutor(const CppCheckExecutor &) = delete;
+    CppCheckExecutor& operator=(const CppCheckExecutor&) = delete;
 
     /**
      * Starts the checking.
@@ -63,134 +59,44 @@ class CppCheckExecutor : public ErrorLogger {
      */
     int check(int argc, const char* const argv[]);
 
-    /**
-     * Information about progress is directed here. This should be
-     * called by the CppCheck class only.
-     *
-     * @param outmsg Progress message e.g. "Checking main.cpp..."
-     */
-    void reportOut(const std::string &outmsg) OVERRIDE;
-
-    /** xml output of errors */
-    void reportErr(const ErrorLogger::ErrorMessage &msg) OVERRIDE;
-
-    void reportProgress(const std::string &filename, const char stage[], const std::size_t value) OVERRIDE;
-
-    /**
-     * Output information messages.
-     */
-    void reportInfo(const ErrorLogger::ErrorMessage &msg) OVERRIDE;
-
-    /**
-     * Information about how many files have been checked
-     *
-     * @param fileindex This many files have been checked.
-     * @param filecount This many files there are in total.
-     * @param sizedone The sum of sizes of the files checked.
-     * @param sizetotal The total sizes of the files.
-     */
-    static void reportStatus(std::size_t fileindex, std::size_t filecount, std::size_t sizedone, std::size_t sizetotal);
-
-    /**
-     * @param exception_output Output file
-     */
-    static void setExceptionOutput(FILE* exceptionOutput);
-    /**
-    * @return file name to be used for output from exception handler. Has to be either "stdout" or "stderr".
-    */
-    static FILE* getExceptionOutput();
-
-    /**
-    * Tries to load a library and prints warning/error messages
-    * @return false, if an error occurred (except unknown XML elements)
-    */
-    static bool tryLoadLibrary(Library& destination, const char* basepath, const char* filename);
-
 protected:
 
     /**
-     * Helper function to print out errors. Appends a line change.
-     * @param errmsg String printed to error stream
-     */
-    void reportErr(const std::string &errmsg);
-
-    /**
-     * @brief Parse command line args and get settings and file lists
-     * from there.
-     *
-     * @param cppcheck cppcheck instance
-     * @param argc argc from main()
-     * @param argv argv from main()
-     * @return false when errors are found in the input
+     * Execute a shell command and read the output from it. Returns exitcode of the executed command,.
      */
-    bool parseFromArgs(CppCheck *cppcheck, int argc, const char* const argv[]);
+    static int executeCommand(std::string exe, std::vector<std::string> args, std::string redirect, std::string &output_);
 
-    /**
-     * Helper function to supply settings. This can be used for testing.
-     * @param settings Reference to an Settings instance
-     */
-    void setSettings(const Settings &settings);
+    static bool reportUnmatchedSuppressions(const Settings &settings, const SuppressionList& suppressions, const std::list<FileWithDetails> &files, const std::list<FileSettings>& fileSettings, ErrorLogger& errorLogger);
 
 private:
-
     /**
      * Wrapper around check_internal
      *   - installs optional platform dependent signal handling
      *
-     * @param cppcheck cppcheck instance
-     * @param argc from main()
-     * @param argv from main()
+     * @param settings the settings
+     * @param supprs the suppressions
      **/
-    int check_wrapper(CppCheck& cppcheck, int argc, const char* const argv[]);
-
-    /**
-    * Starts the checking.
-    *
-    * @param cppcheck cppcheck instance
-    * @param argc from main()
-    * @param argv from main()
-    * @return EXIT_FAILURE if arguments are invalid or no input files
-    *         were found.
-    *         If errors are found and --error-exitcode is used,
-    *         given value is returned instead of default 0.
-    *         If no errors are found, 0 is returned.
-    */
-    int check_internal(CppCheck& cppcheck, int argc, const char* const argv[]);
-
-    /**
-     * Pointer to current settings; set while check() is running.
-     */
-    const Settings* mSettings;
+    int check_wrapper(const Settings& settings, Suppressions& supprs);
 
     /**
-     * Used to filter out duplicate error messages.
+     * Starts the checking.
+     *
+     * @param settings the settings
+     * @param supprs the suppressions
+     * @return EXIT_FAILURE if arguments are invalid or no input files
+     *         were found.
+     *         If errors are found and --error-exitcode is used,
+     *         given value is returned instead of default 0.
+     *         If no errors are found, 0 is returned.
      */
-    std::set<std::string> mShownErrors;
+    int check_internal(const Settings& settings, Suppressions& supprs) const;
 
     /**
      * Filename associated with size of file
      */
-    std::map<std::string, std::size_t> mFiles;
+    std::list<FileWithDetails> mFiles;
 
-    /**
-     * Report progress time
-     */
-    std::time_t mLatestProgressOutputTime;
-
-    /**
-     * Output file name for exception handler
-     */
-    static FILE* mExceptionOutput;
-
-    /**
-     * Error output
-     */
-    std::ofstream *mErrorOutput;
-
-    /**
-     * Has --errorlist been given?
-     */
-    bool mShowAllErrors;
+    std::list<FileSettings> mFileSettings;
 };
 
 #endif // CPPCHECKEXECUTOR_H
diff --git a/cli/executor.cpp b/cli/executor.cpp
new file mode 100644
index 00000000000..d0a05eda5f7
--- /dev/null
+++ b/cli/executor.cpp
@@ -0,0 +1,75 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "executor.h"
+
+#include "color.h"
+#include "errorlogger.h"
+#include "errortypes.h"
+#include "settings.h"
+#include "suppressions.h"
+
+#include <cassert>
+#include <sstream>
+#include <utility>
+
+struct FileSettings;
+
+Executor::Executor(const std::list<FileWithDetails> &files, const std::list<FileSettings>& fileSettings, const Settings &settings, Suppressions &suppressions, ErrorLogger &errorLogger, TimerResults* timerResults)
+    : mFiles(files), mFileSettings(fileSettings), mSettings(settings), mSuppressions(suppressions), mErrorLogger(errorLogger), mTimerResults(timerResults)
+{
+    // the two inputs may only be used exclusively
+    assert(!(!files.empty() && !fileSettings.empty()));
+}
+
+// TODO: this logic is duplicated in CppCheck::reportErr()
+bool Executor::hasToLog(const ErrorMessage &msg)
+{
+    if (msg.severity == Severity::internal)
+        return true;
+
+    if (!mSuppressions.nomsg.isSuppressed(msg, {}))
+    {
+        // TODO: there should be no need for verbose and default messages here
+        std::string errmsg = msg.toString(mSettings.verbose, mSettings.templateFormat, mSettings.templateLocation);
+        if (errmsg.empty())
+            return false;
+
+        if (mSettings.emitDuplicates)
+            return true;
+
+        std::lock_guard<std::mutex> lg(mErrorListSync);
+        if (mErrorList.emplace(std::move(errmsg)).second) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void Executor::reportStatus(std::size_t fileindex, std::size_t filecount, std::size_t sizedone, std::size_t sizetotal)
+{
+    if (filecount > 1) {
+        std::ostringstream oss;
+        const unsigned long percentDone = (sizetotal > 0) ? (100 * sizedone) / sizetotal : (100 * fileindex / filecount);
+        oss << fileindex << '/' << filecount
+            << " files checked " << percentDone
+            << "% done";
+        mErrorLogger.reportOut(oss.str(), Color::FgBlue);
+    }
+}
+
diff --git a/cli/executor.h b/cli/executor.h
new file mode 100644
index 00000000000..7e6fb83eeba
--- /dev/null
+++ b/cli/executor.h
@@ -0,0 +1,86 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef EXECUTOR_H
+#define EXECUTOR_H
+
+#include <cstddef>
+#include <list>
+#include <mutex>
+#include <string>
+#include <unordered_set>
+
+class Settings;
+class ErrorLogger;
+class ErrorMessage;
+struct Suppressions;
+struct FileSettings;
+class FileWithDetails;
+class TimerResults;
+
+/// @addtogroup CLI
+/// @{
+
+/**
+ * This class will take a list of filenames and settings and check then
+ * all files using threads.
+ */
+class Executor {
+public:
+    Executor(const std::list<FileWithDetails> &files, const std::list<FileSettings>& fileSettings, const Settings &settings, Suppressions &suppressions, ErrorLogger &errorLogger, TimerResults* timerResults);
+    virtual ~Executor() = default;
+
+    Executor(const Executor &) = delete;
+    Executor& operator=(const Executor &) = delete;
+
+    virtual unsigned int check() = 0;
+
+    /**
+     * Information about how many files have been checked
+     *
+     * @param fileindex This many files have been checked.
+     * @param filecount This many files there are in total.
+     * @param sizedone The sum of sizes of the files checked.
+     * @param sizetotal The total sizes of the files.
+     */
+    void reportStatus(std::size_t fileindex, std::size_t filecount, std::size_t sizedone, std::size_t sizetotal);
+
+protected:
+    /**
+     * @brief Check if message is being suppressed and unique.
+     * @param msg the message to check
+     * @return true if message is not suppressed and unique
+     */
+    bool hasToLog(const ErrorMessage &msg);
+
+    const std::list<FileWithDetails> &mFiles;
+    const std::list<FileSettings>& mFileSettings;
+    const Settings &mSettings;
+    Suppressions &mSuppressions;
+    ErrorLogger &mErrorLogger;
+    TimerResults *mTimerResults;
+
+private:
+    std::mutex mErrorListSync;
+    // TODO: store hashes instead of the full messages
+    std::unordered_set<std::string> mErrorList;
+};
+
+/// @}
+
+#endif // EXECUTOR_H
diff --git a/cli/filelister.cpp b/cli/filelister.cpp
index 51a5f210651..24acc186818 100644
--- a/cli/filelister.cpp
+++ b/cli/filelister.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,14 +16,22 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#if defined(__CYGWIN__)
+#define _BSD_SOURCE // required to have DT_DIR and DT_UNKNOWN
+#endif
+
 #include "filelister.h"
 
+#include "filesettings.h"
 #include "path.h"
 #include "pathmatch.h"
+#include "standards.h"
 #include "utils.h"
 
-#include <cstddef>
 #include <cstring>
+#include <iostream>
+#include <iterator>
+#include <memory>
 
 #ifdef _WIN32
 
@@ -32,49 +40,13 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #include <windows.h>
-#ifndef __BORLANDC__
 #include <shlwapi.h>
-#endif
 
 // Here is the catch: cppcheck core is Ansi code (using char type).
 // When compiling Unicode targets WinAPI automatically uses *W Unicode versions
 // of called functions. Thus, we explicitly call *A versions of the functions.
 
-static BOOL MyIsDirectory(const std::string& path)
-{
-#ifdef __BORLANDC__
-    return (GetFileAttributes(path.c_str()) & FILE_ATTRIBUTE_DIRECTORY);
-#else
-// See http://msdn.microsoft.com/en-us/library/bb773621(VS.85).aspx
-    return PathIsDirectoryA(path.c_str());
-#endif
-}
-
-static HANDLE MyFindFirstFile(const std::string& path, LPWIN32_FIND_DATAA findData)
-{
-    HANDLE hFind = FindFirstFileA(path.c_str(), findData);
-    return hFind;
-}
-
-static BOOL MyFileExists(const std::string& path)
-{
-#ifdef __BORLANDC__
-    DWORD fa = GetFileAttributes(path.c_str());
-    BOOL result = FALSE;
-    if (fa != INVALID_FILE_ATTRIBUTES && !(fa & FILE_ATTRIBUTE_DIRECTORY))
-        result = TRUE;
-#else
-    const BOOL result = PathFileExistsA(path.c_str());
-#endif
-    return result;
-}
-
-void FileLister::recursiveAddFiles(std::map<std::string, std::size_t> &files, const std::string &path, const std::set<std::string> &extra, const PathMatch& ignored)
-{
-    addFiles(files, path, extra, true, ignored);
-}
-
-void FileLister::addFiles(std::map<std::string, std::size_t> &files, const std::string &path, const std::set<std::string> &extra, bool recursive, const PathMatch& ignored)
+static std::string addFiles2(std::list<FileWithDetails>&files, const std::string &path, const std::set<std::string> &extra, bool recursive, const PathMatch& ignored, bool debug = false)
 {
     const std::string cleanedPath = Path::toNativeSeparators(path);
 
@@ -86,7 +58,7 @@ void FileLister::addFiles(std::map<std::string, std::size_t> &files, const std::
     std::string searchPattern = cleanedPath;
 
     // The user wants to check all files in a dir
-    const bool checkAllFilesInDir = (MyIsDirectory(cleanedPath) != FALSE);
+    const bool checkAllFilesInDir = Path::isDirectory(cleanedPath);
 
     if (checkAllFilesInDir) {
         const char c = cleanedPath.back();
@@ -111,55 +83,103 @@ void FileLister::addFiles(std::map<std::string, std::size_t> &files, const std::
     }
 
     WIN32_FIND_DATAA ffd;
-    HANDLE hFind = MyFindFirstFile(searchPattern, &ffd);
-    if (INVALID_HANDLE_VALUE == hFind)
-        return;
+    HANDLE hFind = FindFirstFileA(searchPattern.c_str(), &ffd);
+    if (INVALID_HANDLE_VALUE == hFind) {
+        const DWORD err = GetLastError();
+        if (err == ERROR_FILE_NOT_FOUND || // the pattern did not match anything
+            err == ERROR_PATH_NOT_FOUND)   // the given search path does not exist
+        {
+            return "";
+        }
+        return "finding files failed. Search pattern: '" + searchPattern + "'. (error: " + std::to_string(err) + ")";
+    }
+    std::unique_ptr<void, decltype(&FindClose)> hFind_deleter(hFind, FindClose);
 
     do {
-        if (ffd.cFileName[0] == '.' || ffd.cFileName[0] == '\0')
-            continue;
-
-        const char* ansiFfd = ffd.cFileName;
-        if (std::strchr(ansiFfd,'?')) {
-            ansiFfd = ffd.cAlternateFileName;
-        }
+        if (ffd.cFileName[0] != '.' && ffd.cFileName[0] != '\0')
+        {
+            const char* ansiFfd = ffd.cFileName;
+            if (std::strchr(ansiFfd,'?')) {
+                ansiFfd = ffd.cAlternateFileName;
+            }
 
-        const std::string fname(basedir + ansiFfd);
+            const std::string fname(basedir + ansiFfd);
 
-        if ((ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
-            // File
-            if ((!checkAllFilesInDir || Path::acceptFile(fname, extra)) && !ignored.match(fname)) {
-                const std::string nativename = Path::fromNativeSeparators(fname);
+            if ((ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
+                // File
+                Standards::Language lang = Standards::Language::None;
+                if ((!checkAllFilesInDir || Path::acceptFile(fname, extra, &lang))) {
+                    if (!ignored.match(fname)) {
+                        std::string nativename = Path::fromNativeSeparators(fname);
 
-                // Limitation: file sizes are assumed to fit in a 'size_t'
+                        // Limitation: file sizes are assumed to fit in a 'size_t'
 #ifdef _WIN64
-                files[nativename] = (static_cast<std::size_t>(ffd.nFileSizeHigh) << 32) | ffd.nFileSizeLow;
+                        const std::size_t filesize = (static_cast<std::size_t>(ffd.nFileSizeHigh) << 32) | ffd.nFileSizeLow;
 #else
-                files[nativename] = ffd.nFileSizeLow;
+                        const std::size_t filesize = ffd.nFileSizeLow;
+
 #endif
-            }
-        } else {
-            // Directory
-            if (recursive) {
-                if (!ignored.match(fname))
-                    FileLister::recursiveAddFiles(files, fname, extra, ignored);
+                        files.emplace_back(std::move(nativename), lang, filesize);
+                    }
+                    else if (debug)
+                    {
+                        std::cout << "ignored path: " << fname << std::endl;
+                    }
+                }
+            } else {
+                // Directory
+                if (recursive) {
+                    if (!ignored.match(fname, PathMatch::Filemode::directory)) {
+                        std::list<FileWithDetails> filesSorted;
+
+                        std::string err = addFiles2(filesSorted, fname, extra, recursive, ignored);
+                        if (!err.empty())
+                            return err;
+
+                        // files inside directories need to be sorted as the filesystem doesn't provide a stable order
+                        filesSorted.sort([](const FileWithDetails& a, const FileWithDetails& b) {
+                            return a.path() < b.path();
+                        });
+
+                        files.insert(files.end(), std::make_move_iterator(filesSorted.begin()), std::make_move_iterator(filesSorted.end()));
+                    }
+                    else if (debug)
+                    {
+                        std::cout << "ignored path: " << fname << std::endl;
+                    }
+                }
             }
         }
-    } while (FindNextFileA(hFind, &ffd) != FALSE);
 
-    FindClose(hFind);
-}
+        if (!FindNextFileA(hFind, &ffd)) {
+            const DWORD err = GetLastError();
+            // no more files matched
+            if (err != ERROR_NO_MORE_FILES)
+                return "failed to get next file (error: " + std::to_string(err) + ")";
+            break;
+        }
+    } while (true);
 
-bool FileLister::isDirectory(const std::string &path)
-{
-    return (MyIsDirectory(path) != FALSE);
+    return "";
 }
 
-bool FileLister::fileExists(const std::string &path)
+std::string FileLister::addFiles(std::list<FileWithDetails> &files, const std::string &path, const std::set<std::string> &extra, bool recursive, const PathMatch& ignored, bool debug)
 {
-    return (MyFileExists(path) != FALSE);
-}
+    if (path.empty())
+        return "no path specified";
+
+    std::list<FileWithDetails> filesSorted;
+
+    std::string err = addFiles2(filesSorted, path, extra, recursive, ignored, debug);
+
+    // files need to be sorted as the filesystems dosn't provide a stable order
+    filesSorted.sort([](const FileWithDetails& a, const FileWithDetails& b) {
+        return a.path() < b.path();
+    });
+    files.insert(files.end(), std::make_move_iterator(filesSorted.begin()), std::make_move_iterator(filesSorted.end()));
 
+    return err;
+}
 
 #else
 
@@ -167,89 +187,124 @@ bool FileLister::fileExists(const std::string &path)
 ////// This code is POSIX-style systems ///////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
 
-#if defined(__CYGWIN__)
-#undef __STRICT_ANSI__
-#endif
-
 #include <dirent.h>
 #include <sys/stat.h>
+#include <cerrno>
 
-
-static void addFiles2(std::map<std::string, std::size_t> &files,
-                      const std::string &path,
-                      const std::set<std::string> &extra,
-                      bool recursive,
-                      const PathMatch& ignored
-                     )
+struct closedir_deleter {
+    void operator()(DIR* d) const {
+        closedir(d);
+    }
+};
+
+static std::string addFiles2(std::list<FileWithDetails> &files,
+                             const std::string &path,
+                             const std::set<std::string> &extra,
+                             bool recursive,
+                             const PathMatch& ignored,
+                             bool debug)
 {
+    if (ignored.match(path))
+    {
+        if (debug)
+            std::cout << "ignored path: " << path << std::endl;
+        return "";
+    }
+
     struct stat file_stat;
-    if (stat(path.c_str(), &file_stat) != -1) {
-        if ((file_stat.st_mode & S_IFMT) == S_IFDIR) {
-            DIR * dir = opendir(path.c_str());
-            if (!dir)
-                return;
+    if (stat(path.c_str(), &file_stat) == -1)
+        return ""; // TODO: return error?
+    if ((file_stat.st_mode & S_IFMT) != S_IFDIR)
+    {
+        files.emplace_back(path, Standards::Language::None, file_stat.st_size);
+        return "";
+    }
 
-            dirent entry;
-            dirent * dir_result;
-            std::string new_path;
-            new_path.reserve(path.length() + 100);// prealloc some memory to avoid constant new/deletes in loop
+    // process directory entry
 
-            while ((readdir_r(dir, &entry, &dir_result) == 0) && (dir_result != nullptr)) {
+    DIR * dir = opendir(path.c_str());
+    if (!dir) {
+        const int err = errno;
+        return "could not open directory '" + path + "' (errno: " + std::to_string(err) + ")";
+    }
+    std::unique_ptr<DIR, closedir_deleter> dir_deleter(dir);
 
-                if ((std::strcmp(dir_result->d_name, ".") == 0) ||
-                    (std::strcmp(dir_result->d_name, "..") == 0))
-                    continue;
+    std::string new_path = path;
+    new_path += '/';
 
-                new_path = path + '/' + dir_result->d_name;
+    while (const dirent* dir_result = readdir(dir)) {
+        if ((std::strcmp(dir_result->d_name, ".") == 0) ||
+            (std::strcmp(dir_result->d_name, "..") == 0))
+            continue;
+
+        new_path.erase(path.length() + 1);
+        new_path += dir_result->d_name;
 
-#if defined(_DIRENT_HAVE_D_TYPE) || defined(_BSD_SOURCE)
-                bool path_is_directory = (dir_result->d_type == DT_DIR || (dir_result->d_type == DT_UNKNOWN && FileLister::isDirectory(new_path)));
+#if defined(_DIRENT_HAVE_D_TYPE)
+        const bool path_is_directory = (dir_result->d_type == DT_DIR || (dir_result->d_type == DT_UNKNOWN && Path::isDirectory(new_path)));
 #else
-                bool path_is_directory = FileLister::isDirectory(new_path);
+        const bool path_is_directory = Path::isDirectory(new_path);
 #endif
-                if (path_is_directory) {
-                    if (recursive && !ignored.match(new_path)) {
-                        addFiles2(files, new_path, extra, recursive, ignored);
+        if (path_is_directory) {
+            if (recursive) {
+                if (!ignored.match(new_path, PathMatch::Filemode::directory)) {
+                    std::string err = addFiles2(files, new_path, extra, recursive, ignored, debug);
+                    if (!err.empty()) {
+                        return err;
                     }
-                } else {
-                    if (Path::acceptFile(new_path, extra) && !ignored.match(new_path)) {
-                        stat(new_path.c_str(), &file_stat);
-                        files[new_path] = file_stat.st_size;
+                }
+                else if (debug)
+                {
+                    std::cout << "ignored path: " << new_path << std::endl;
+                }
+            }
+        } else {
+            Standards::Language lang = Standards::Language::None;
+            if (Path::acceptFile(new_path, extra, &lang)) {
+                if (!ignored.match(new_path))
+                {
+                    if (stat(new_path.c_str(), &file_stat) == -1) {
+                        const int err = errno;
+                        return "could not stat file '" + new_path + "' (errno: " + std::to_string(err) + ")";
                     }
+                    files.emplace_back(new_path, lang, file_stat.st_size);
+                }
+                else if (debug)
+                {
+                    std::cout << "ignored path: " << new_path << std::endl;
                 }
             }
-            closedir(dir);
-        } else
-            files[path] = file_stat.st_size;
+        }
     }
-}
 
-void FileLister::recursiveAddFiles(std::map<std::string, std::size_t> &files, const std::string &path, const std::set<std::string> &extra, const PathMatch& ignored)
-{
-    addFiles(files, path, extra, true, ignored);
+    return "";
 }
 
-void FileLister::addFiles(std::map<std::string, std::size_t> &files, const std::string &path, const std::set<std::string> &extra, bool recursive, const PathMatch& ignored)
+std::string FileLister::addFiles(std::list<FileWithDetails> &files, const std::string &path, const std::set<std::string> &extra, bool recursive, const PathMatch& ignored, bool debug)
 {
-    if (!path.empty()) {
-        std::string corrected_path = path;
-        if (endsWith(corrected_path, '/'))
-            corrected_path.erase(corrected_path.end() - 1);
+    if (path.empty())
+        return "no path specified";
 
-        addFiles2(files, corrected_path, extra, recursive, ignored);
-    }
-}
+    std::string corrected_path = path;
+    if (endsWith(corrected_path, '/'))
+        corrected_path.erase(corrected_path.end() - 1);
 
-bool FileLister::isDirectory(const std::string &path)
-{
-    struct stat file_stat;
-    return (stat(path.c_str(), &file_stat) != -1 && (file_stat.st_mode & S_IFMT) == S_IFDIR);
-}
+    std::list<FileWithDetails> filesSorted;
 
-bool FileLister::fileExists(const std::string &path)
-{
-    struct stat file_stat;
-    return (stat(path.c_str(), &file_stat) != -1 && (file_stat.st_mode & S_IFMT) == S_IFREG);
+    std::string err = addFiles2(filesSorted, corrected_path, extra, recursive, ignored, debug);
+
+    // files need to be sorted as the filesystems dosn't provide a stable order
+    filesSorted.sort([](const FileWithDetails& a, const FileWithDetails& b) {
+        return a.path() < b.path();
+    });
+    files.insert(files.end(), std::make_move_iterator(filesSorted.begin()), std::make_move_iterator(filesSorted.end()));
+
+    return err;
 }
 
 #endif
+
+std::string FileLister::recursiveAddFiles(std::list<FileWithDetails> &files, const std::string &path, const std::set<std::string> &extra, const PathMatch& ignored, bool debug)
+{
+    return addFiles(files, path, extra, true, ignored, debug);
+}
diff --git a/cli/filelister.h b/cli/filelister.h
index 9b0e9ecda6d..12b8ddeed7e 100644
--- a/cli/filelister.h
+++ b/cli/filelister.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2017 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,12 +19,12 @@
 #ifndef filelisterH
 #define filelisterH
 
-#include <cstddef>
-#include <map>
+#include <list>
 #include <set>
 #include <string>
 
 class PathMatch;
+class FileWithDetails;
 
 /// @addtogroup CLI
 /// @{
@@ -37,51 +37,29 @@ class FileLister {
      * Add source files from given directory and all subdirectries to the
      * given map. Only files with accepted extensions
      * (*.c;*.cpp;*.cxx;*.c++;*.cc;*.txx) are added.
-     * @param files output map that associates the size of each file with its name
-     * @param path root path
-     * @param ignored ignored paths
-     */
-    static void recursiveAddFiles(std::map<std::string, std::size_t> &files, const std::string &path, const PathMatch& ignored) {
-        const std::set<std::string> extra;
-        recursiveAddFiles(files, path, extra, ignored);
-    }
-
-    /**
-     * @brief Recursively add source files to a map.
-     * Add source files from given directory and all subdirectries to the
-     * given map. Only files with accepted extensions
-     * (*.c;*.cpp;*.cxx;*.c++;*.cc;*.txx) are added.
-     * @param files output map that associates the size of each file with its name
+     * @param files output list that associates the size of each file with its name
      * @param path root path
      * @param extra Extra file extensions
      * @param ignored ignored paths
+     * @param debug log if path was ignored
+     * @return On success, an empty string is returned. On error, a error message is returned.
      */
-    static void recursiveAddFiles(std::map<std::string, std::size_t> &files, const std::string &path, const std::set<std::string> &extra, const PathMatch& ignored);
+    static std::string recursiveAddFiles(std::list<FileWithDetails> &files, const std::string &path, const std::set<std::string> &extra, const PathMatch& ignored, bool debug = false);
 
     /**
      * @brief (Recursively) add source files to a map.
      * Add source files from given directory and all subdirectries to the
      * given map. Only files with accepted extensions
      * (*.c;*.cpp;*.cxx;*.c++;*.cc;*.txx) are added.
-     * @param files output map that associates the size of each file with its name
+     * @param files output list that associates the size of each file with its name
      * @param path root path
      * @param extra Extra file extensions
      * @param recursive Enable recursion
      * @param ignored ignored paths
+     * @param debug log when a path was ignored
+     * @return On success, an empty string is returned. On error, a error message is returned.
      */
-    static void addFiles(std::map<std::string, std::size_t> &files, const std::string &path, const std::set<std::string> &extra, bool recursive, const PathMatch& ignored);
-
-    /**
-     * @brief Is given path a directory?
-     * @return returns true if the path is a directory
-     */
-    static bool isDirectory(const std::string &path);
-
-    /**
-      * @brief Check if the given path is a file and if it exists?
-      * @return true if path points to file and the file exists.
-      */
-    static bool fileExists(const std::string &path);
+    static std::string addFiles(std::list<FileWithDetails> &files, const std::string &path, const std::set<std::string> &extra, bool recursive, const PathMatch& ignored, bool debug = false);
 };
 
 /// @}
diff --git a/cli/main.cpp b/cli/main.cpp
index 44e6adbef66..9bea4336c84 100644
--- a/cli/main.cpp
+++ b/cli/main.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,7 +20,7 @@
 /**
  *
  * @mainpage Cppcheck
- * @version 1.89.99
+ * @version 2.20.99
  *
  * @section overview_sec Overview
  * Cppcheck is a simple tool for static analysis of C/C++ code.
@@ -52,23 +52,12 @@
  *   - Macros are expanded
  * -# Tokenize the file (see Tokenizer)
  * -# Run the runChecks of all check classes.
- * -# Simplify the tokenlist (Tokenizer::simplifyTokenList2)
- * -# Run the runSimplifiedChecks of all check classes
  *
  * When errors are found, they are reported back to the CppCheckExecutor through the ErrorLogger interface.
  */
 
-
 #include "cppcheckexecutor.h"
 
-#include <iostream>
-
-#ifdef _WIN32
-#include <windows.h>
-
-static char exename[1024] = {0};
-#endif
-
 /**
  * Main function of cppcheck
  *
@@ -78,45 +67,6 @@ static char exename[1024] = {0};
  */
 int main(int argc, char* argv[])
 {
-    // MS Visual C++ memory leak debug tracing
-#if defined(_MSC_VER) && defined(_DEBUG)
-    _CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | _CRTDBG_LEAK_CHECK_DF);
-#endif
-
     CppCheckExecutor exec;
-#ifdef _WIN32
-    GetModuleFileNameA(nullptr, exename, sizeof(exename)/sizeof(exename[0])-1);
-    argv[0] = exename;
-#endif
-
-#ifdef NDEBUG
-    try {
-#endif
-        return exec.check(argc, argv);
-#ifdef NDEBUG
-    } catch (const InternalError& e) {
-        std::cout << e.errorMessage << std::endl;
-    } catch (const std::exception& error) {
-        std::cout << error.what() << std::endl;
-    } catch (...) {
-        std::cout << "Unknown exception" << std::endl;
-    }
-    return EXIT_FAILURE;
-#endif
+    return exec.check(argc, argv);
 }
-
-
-// Warn about deprecated compilers
-#ifdef __clang__
-#   if ( __clang_major__ < 2 || ( __clang_major__  == 2 && __clang_minor__ < 9))
-#       warning "Using Clang 2.8 or earlier. Support for this version has been removed."
-#   endif
-#elif defined(__GNUC__)
-#   if (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 6))
-#       warning "Using GCC 4.5 or earlier. Support for this version has been removed."
-#   endif
-#elif defined(_MSC_VER)
-#   if (_MSC_VER < 1800)
-#       pragma message("WARNING: Using Visual Studio 2012 or earlier. Support for this version has been removed.")
-#   endif
-#endif
diff --git a/cli/precompiled.h b/cli/precompiled.h
new file mode 100644
index 00000000000..3795bd206cf
--- /dev/null
+++ b/cli/precompiled.h
@@ -0,0 +1,25 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+// IWYU pragma: begin_keep
+#include "config.h"
+#include "cppcheck.h"
+#include "settings.h"
+// IWYU pragma: end_keep
diff --git a/cli/processexecutor.cpp b/cli/processexecutor.cpp
new file mode 100644
index 00000000000..7b750fdc26b
--- /dev/null
+++ b/cli/processexecutor.cpp
@@ -0,0 +1,474 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(__CYGWIN__)
+#define _BSD_SOURCE // required to have getloadavg()
+#endif
+
+#include "processexecutor.h"
+
+#ifdef HAS_THREADING_MODEL_FORK
+
+#include "cppcheck.h"
+#include "errorlogger.h"
+#include "errortypes.h"
+#include "filesettings.h"
+#include "settings.h"
+#include "suppressions.h"
+#include "timer.h"
+#include "utils.h"
+
+#include <algorithm>
+#include <numeric>
+#include <cassert>
+#include <cerrno>
+#include <csignal>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <list>
+#include <map>
+#include <sstream>
+#include <sys/select.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <utility>
+#include <fcntl.h>
+
+
+#ifdef __SVR4  // Solaris
+#include <sys/loadavg.h>
+#endif
+
+#if defined(__linux__)
+#include <sys/prctl.h>
+#endif
+
+enum class Color : std::uint8_t;
+
+// NOLINTNEXTLINE(misc-unused-using-decls) - required for FD_ZERO
+using std::memset;
+
+
+ProcessExecutor::ProcessExecutor(const std::list<FileWithDetails> &files, const std::list<FileSettings>& fileSettings, const Settings &settings, Suppressions &suppressions, ErrorLogger &errorLogger, TimerResults* timerResults, CppCheck::ExecuteCmdFn executeCommand)
+    : Executor(files, fileSettings, settings, suppressions, errorLogger, timerResults)
+    , mExecuteCommand(std::move(executeCommand))
+{
+    assert(mSettings.jobs > 1);
+}
+
+namespace {
+    class PipeWriter : public ErrorLogger {
+    public:
+        enum PipeSignal : std::uint8_t {REPORT_OUT='1',REPORT_ERROR='2',REPORT_SUPPR_INLINE='3',REPORT_SUPPR='4',CHILD_END='5',REPORT_METRIC='6'};
+
+        explicit PipeWriter(int pipe) : mWpipe(pipe) {}
+
+        void reportOut(const std::string &outmsg, Color c) override {
+            writeToPipe(REPORT_OUT, static_cast<char>(c) + outmsg);
+        }
+
+        void reportErr(const ErrorMessage &msg) override {
+            writeToPipe(REPORT_ERROR, msg.serialize());
+        }
+
+        void writeSuppr(const SuppressionList &supprs) const {
+            for (const auto& suppr : supprs.getSuppressions())
+            {
+                if (suppr.isInline)
+                    writeToPipe(REPORT_SUPPR_INLINE, suppressionToString(suppr));
+                else if (suppr.checked)
+                    writeToPipe(REPORT_SUPPR, suppressionToString(suppr));
+            }
+        }
+
+        void reportMetric(const std::string &metric) override {
+            writeToPipe(REPORT_METRIC, metric);
+        }
+
+        void writeEnd(const std::string& str) const {
+            writeToPipe(CHILD_END, str);
+        }
+
+    private:
+        static std::string suppressionToString(const SuppressionList::Suppression &suppr)
+        {
+            std::string suppr_str = suppr.toString();
+            suppr_str += ";";
+            suppr_str += suppr.checked ? "1" : "0";
+            suppr_str += ";";
+            suppr_str += suppr.matched ? "1" : "0";
+            suppr_str += ";";
+            suppr_str += suppr.extraComment;
+            return suppr_str;
+        }
+
+        // TODO: how to log file name in error?
+        void writeToPipeInternal(PipeSignal type, const void* data, std::size_t to_write) const
+        {
+            const ssize_t bytes_written = write(mWpipe, data, to_write);
+            if (bytes_written <= 0) {
+                const int err = errno;
+                std::cerr << "#### ThreadExecutor::writeToPipeInternal() error for type " << static_cast<unsigned char>(type) << ": " << std::strerror(err) << std::endl;
+                std::exit(EXIT_FAILURE);
+            }
+            // TODO: write until everything is written
+            if (bytes_written != to_write) {
+                std::cerr << "#### ThreadExecutor::writeToPipeInternal() error for type " << static_cast<unsigned char>(type) << ": insufficient data written (expected: " << to_write << " / got: " << bytes_written << ")" << std::endl;
+                std::exit(EXIT_FAILURE);
+            }
+        }
+
+        void writeToPipe(PipeSignal type, const std::string &data) const
+        {
+            {
+                const auto t = static_cast<char>(type);
+                writeToPipeInternal(type, &t, 1);
+            }
+
+            const auto len = static_cast<unsigned int>(data.length());
+            {
+                static constexpr std::size_t l_size = sizeof(unsigned int);
+                writeToPipeInternal(type, &len, l_size);
+            }
+
+            if (len > 0) // TODO: unexpected - write a warning?
+                writeToPipeInternal(type, data.c_str(), len);
+        }
+
+        const int mWpipe;
+    };
+}
+
+bool ProcessExecutor::handleRead(int rpipe, unsigned int &result, const std::string& filename)
+{
+    std::size_t bytes_to_read;
+    ssize_t bytes_read;
+
+    char type = 0;
+    bytes_to_read = sizeof(char);
+    bytes_read = read(rpipe, &type, bytes_to_read);
+    if (bytes_read <= 0) {
+        if (errno == EAGAIN)
+            return true;
+
+        // TODO: log details about failure
+
+        // need to increment so a missing pipe (i.e. premature exit of forked process) results in an error exitcode
+        ++result;
+        return false;
+    }
+    if (bytes_read != bytes_to_read) {
+        std::cerr << "#### ThreadExecutor::handleRead(" << filename << ") error (type): insufficient data read (expected: " << bytes_to_read << " / got: " << bytes_read << ")" << std::endl;
+        std::exit(EXIT_FAILURE);
+    }
+
+    if (type != PipeWriter::REPORT_OUT &&
+        type != PipeWriter::REPORT_ERROR &&
+        type != PipeWriter::REPORT_SUPPR_INLINE &&
+        type != PipeWriter::REPORT_SUPPR &&
+        type != PipeWriter::CHILD_END &&
+        type != PipeWriter::REPORT_METRIC) {
+        std::cerr << "#### ThreadExecutor::handleRead(" << filename << ") invalid type " << int(type) << std::endl;
+        std::exit(EXIT_FAILURE);
+    }
+
+    unsigned int len = 0;
+    bytes_to_read = sizeof(len);
+    bytes_read = read(rpipe, &len, bytes_to_read);
+    if (bytes_read <= 0) {
+        const int err = errno;
+        std::cerr << "#### ThreadExecutor::handleRead(" << filename << ") error (len) for type " << int(type) << ": " << std::strerror(err) << std::endl;
+        std::exit(EXIT_FAILURE);
+    }
+    if (bytes_read != bytes_to_read) {
+        std::cerr << "#### ThreadExecutor::handleRead(" << filename << ") error (len) for type" << int(type) << ": insufficient data read (expected: " << bytes_to_read << " / got: " << bytes_read << ")"  << std::endl;
+        std::exit(EXIT_FAILURE);
+    }
+
+    std::string buf(len, '\0');
+    if (len > 0) { // TODO: unexpected - write a warning?
+        char *data_start = &buf[0];
+        bytes_to_read = len;
+        do {
+            bytes_read = read(rpipe, data_start, bytes_to_read);
+            if (bytes_read <= 0) {
+                const int err = errno;
+                std::cerr << "#### ThreadExecutor::handleRead(" << filename << ") error (buf) for type" << int(type) << ": " << std::strerror(err) << std::endl;
+                std::exit(EXIT_FAILURE);
+            }
+            bytes_to_read -= bytes_read;
+            data_start += bytes_read;
+        } while (bytes_to_read != 0);
+    }
+
+    bool res = true;
+    if (type == PipeWriter::REPORT_OUT) {
+        // the first character is the color
+        const auto c = static_cast<Color>(buf[0]);
+        // TODO: avoid string copy
+        mErrorLogger.reportOut(buf.substr(1), c);
+    } else if (type == PipeWriter::REPORT_ERROR) {
+        ErrorMessage msg;
+        try {
+            msg.deserialize(buf);
+        } catch (const InternalError& e) {
+            std::cerr << "#### ThreadExecutor::handleRead(" << filename << ") internal error: " << e.errorMessage << std::endl;
+            std::exit(EXIT_FAILURE);
+        }
+
+        if (hasToLog(msg))
+            mErrorLogger.reportErr(msg);
+    } else if (type == PipeWriter::REPORT_SUPPR_INLINE || type == PipeWriter::REPORT_SUPPR) {
+        if (!buf.empty()) {
+            // TODO: avoid string splitting
+            auto parts = splitString(buf, ';');
+            if (parts.size() < 4)
+            {
+                // TODO: make this non-fatal
+                std::cerr << "#### ThreadExecutor::handleRead(" << filename << ") adding of inline suppression failed - insufficient data" << std::endl;
+                std::exit(EXIT_FAILURE);
+            }
+            auto suppr = SuppressionList::parseLine(parts[0]);
+            suppr.isInline = (type == PipeWriter::REPORT_SUPPR_INLINE);
+            suppr.checked = parts[1] == "1";
+            suppr.matched = parts[2] == "1";
+            suppr.extraComment = parts[3];
+            for (std::size_t i = 4; i < parts.size(); i++) {
+                suppr.extraComment += ";" + parts[i];
+            }
+            const std::string err = mSuppressions.nomsg.addSuppression(suppr);
+            if (!err.empty()) {
+                // TODO: only update state if it doesn't exist - otherwise propagate error
+                mSuppressions.nomsg.updateSuppressionState(suppr); // TODO: check result
+                // TODO: make this non-fatal
+                //std::cerr << "#### ThreadExecutor::handleRead(" << filename << ") adding of inline suppression failed - " << err << std::endl;
+                //std::exit(EXIT_FAILURE);
+            }
+        }
+    } else if (type == PipeWriter::CHILD_END) {
+        result += std::stoi(buf);
+        res = false;
+    } else if (type == PipeWriter::REPORT_METRIC) {
+        mErrorLogger.reportMetric(buf);
+    }
+
+    return res;
+}
+
+bool ProcessExecutor::checkLoadAverage(size_t nchildren)
+{
+#if defined(__QNX__) || defined(__HAIKU__) || defined(_AIX) // getloadavg() is unsupported on Qnx, Haiku, AIX.
+    (void)nchildren;
+    return true;
+#else
+    if (!nchildren || !mSettings.loadAverage) {
+        return true;
+    }
+
+    double sample(0);
+    if (getloadavg(&sample, 1) != 1) {
+        // disable load average checking on getloadavg error
+        return true;
+    }
+    if (sample < mSettings.loadAverage) {
+        return true;
+    }
+    return false;
+#endif
+}
+
+unsigned int ProcessExecutor::check()
+{
+    unsigned int fileCount = 0;
+    unsigned int result = 0;
+
+    const std::size_t totalfilesize = std::accumulate(mFiles.cbegin(), mFiles.cend(), std::size_t(0), [](std::size_t v, const FileWithDetails& p) {
+        return v + p.size();
+    });
+
+    std::list<int> rpipes;
+    std::map<pid_t, std::string> childFile;
+    std::map<int, std::string> pipeFile;
+    std::size_t processedsize = 0;
+    auto iFile = mFiles.cbegin();
+    auto iFileSettings = mFileSettings.cbegin();
+    for (;;) {
+        // Start a new child
+        const size_t nchildren = childFile.size();
+        if ((iFile != mFiles.cend() || iFileSettings != mFileSettings.cend()) && nchildren < mSettings.jobs && checkLoadAverage(nchildren)) {
+            int pipes[2];
+            if (pipe(pipes) == -1) {
+                std::cerr << "#### ThreadExecutor::check, pipe() failed: "<< std::strerror(errno) << std::endl;
+                std::exit(EXIT_FAILURE);
+            }
+
+            const int flags = fcntl(pipes[0], F_GETFL, 0);
+            if (flags < 0) {
+                std::cerr << "#### ThreadExecutor::check, fcntl(F_GETFL) failed: "<< std::strerror(errno) << std::endl;
+                std::exit(EXIT_FAILURE);
+            }
+
+            if (fcntl(pipes[0], F_SETFL, flags) < 0) {
+                std::cerr << "#### ThreadExecutor::check, fcntl(F_SETFL) failed: "<< std::strerror(errno) << std::endl;
+                std::exit(EXIT_FAILURE);
+            }
+
+            const pid_t pid = fork();
+            if (pid < 0) {
+                // Error
+                std::cerr << "#### ThreadExecutor::check, Failed to create child process: "<< std::strerror(errno) << std::endl;
+                std::exit(EXIT_FAILURE);
+            } else if (pid == 0) {
+#if defined(__linux__)
+                prctl(PR_SET_PDEATHSIG, SIGHUP);
+#endif
+                close(pipes[0]);
+
+                PipeWriter pipewriter(pipes[1]);
+                CppCheck fileChecker(mSettings, mSuppressions, pipewriter, mTimerResults, false, mExecuteCommand);
+                unsigned int resultOfCheck = 0;
+
+                if (iFileSettings != mFileSettings.end()) {
+                    resultOfCheck = fileChecker.check(*iFileSettings);
+                } else {
+                    // Read file from a file
+                    resultOfCheck = fileChecker.check(*iFile);
+                }
+
+                pipewriter.writeSuppr(mSuppressions.nomsg);
+
+                pipewriter.writeEnd(std::to_string(resultOfCheck));
+                std::exit(EXIT_SUCCESS);
+            }
+
+            close(pipes[1]);
+            rpipes.push_back(pipes[0]);
+            if (iFileSettings != mFileSettings.end()) {
+                childFile[pid] = iFileSettings->filename() + ' ' + iFileSettings->cfg;
+                pipeFile[pipes[0]] = iFileSettings->filename() + ' ' + iFileSettings->cfg;
+                ++iFileSettings;
+            } else {
+                childFile[pid] = iFile->path();
+                pipeFile[pipes[0]] = iFile->path();
+                ++iFile;
+            }
+        }
+        if (!rpipes.empty()) {
+            fd_set rfds;
+            FD_ZERO(&rfds);
+            for (auto rp = rpipes.cbegin(); rp != rpipes.cend(); ++rp)
+                FD_SET(*rp, &rfds);
+            timeval tv; // for every second polling of load average condition
+            tv.tv_sec = 1;
+            tv.tv_usec = 0;
+            const int r = select(*std::max_element(rpipes.cbegin(), rpipes.cend()) + 1, &rfds, nullptr, nullptr, &tv);
+
+            if (r > 0) {
+                auto rp = rpipes.cbegin();
+                while (rp != rpipes.cend()) {
+                    if (FD_ISSET(*rp, &rfds)) {
+                        std::string name;
+                        const auto p = utils::as_const(pipeFile).find(*rp);
+                        if (p != pipeFile.cend()) {
+                            name = p->second;
+                        }
+                        const bool readRes = handleRead(*rp, result, name);
+                        if (!readRes) {
+                            std::size_t size = 0;
+                            if (p != pipeFile.cend()) {
+                                pipeFile.erase(p);
+                                const auto fs = std::find_if(mFiles.cbegin(), mFiles.cend(), [&name](const FileWithDetails& entry) {
+                                    return entry.path() == name;
+                                });
+                                if (fs != mFiles.end()) {
+                                    size = fs->size();
+                                }
+                            }
+
+                            fileCount++;
+                            processedsize += size;
+                            if (!mSettings.quiet)
+                                Executor::reportStatus(fileCount, mFiles.size() + mFileSettings.size(), processedsize, totalfilesize);
+
+                            close(*rp);
+                            rp = rpipes.erase(rp);
+                        } else
+                            ++rp;
+                    } else
+                        ++rp;
+                }
+            }
+        }
+        if (!childFile.empty()) {
+            int stat = 0;
+            const pid_t child = waitpid(0, &stat, WNOHANG);
+            if (child > 0) {
+                std::string childname;
+                const auto c = utils::as_const(childFile).find(child);
+                if (c != childFile.cend()) {
+                    childname = c->second;
+                    childFile.erase(c);
+                }
+
+                if (WIFEXITED(stat)) {
+                    const int exitstatus = WEXITSTATUS(stat);
+                    if (exitstatus != EXIT_SUCCESS) {
+                        std::ostringstream oss;
+                        oss << "Child process exited with " << exitstatus;
+                        reportInternalChildErr(childname, oss.str());
+                    }
+                } else if (WIFSIGNALED(stat)) {
+                    std::ostringstream oss;
+                    oss << "Child process crashed with signal " << WTERMSIG(stat);
+                    reportInternalChildErr(childname, oss.str());
+                }
+            }
+        }
+        if (iFile == mFiles.end() && iFileSettings == mFileSettings.end() && rpipes.empty() && childFile.empty()) {
+            // All done
+            break;
+        }
+    }
+
+    // TODO: wee need to get the timing information from the subprocess
+    if (mTimerResults && (mSettings.showtime == ShowTime::SUMMARY || mSettings.showtime == ShowTime::TOP5_SUMMARY))
+        mTimerResults->showResults(mSettings.showtime);
+
+    return result;
+}
+
+void ProcessExecutor::reportInternalChildErr(const std::string &childname, const std::string &msg)
+{
+    std::list<ErrorMessage::FileLocation> locations;
+    locations.emplace_back(childname, 0, 0);
+    const ErrorMessage errmsg(std::move(locations),
+                              "",
+                              Severity::error,
+                              "Internal error: " + msg,
+                              "cppcheckError",
+                              Certainty::normal);
+
+    if (!mSuppressions.nomsg.isSuppressed(errmsg, {}))
+        mErrorLogger.reportErr(errmsg);
+}
+
+#endif // HAS_THREADING_MODEL_FORK
diff --git a/cli/processexecutor.h b/cli/processexecutor.h
new file mode 100644
index 00000000000..6c590da4072
--- /dev/null
+++ b/cli/processexecutor.h
@@ -0,0 +1,82 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef PROCESSEXECUTOR_H
+#define PROCESSEXECUTOR_H
+
+#include "config.h"
+
+#ifdef HAS_THREADING_MODEL_FORK
+
+#include "cppcheck.h"
+#include "executor.h"
+
+#include <cstddef>
+#include <list>
+#include <string>
+
+class Settings;
+class ErrorLogger;
+struct Suppressions;
+struct FileSettings;
+class FileWithDetails;
+class TimerResults;
+
+/// @addtogroup CLI
+/// @{
+
+/**
+ * This class will take a list of filenames and settings and check then
+ * all files using threads.
+ */
+class ProcessExecutor : public Executor {
+public:
+    ProcessExecutor(const std::list<FileWithDetails> &files, const std::list<FileSettings>& fileSettings, const Settings &settings, Suppressions &suppressions, ErrorLogger &errorLogger, TimerResults* timerResults, CppCheck::ExecuteCmdFn executeCommand);
+    ProcessExecutor(const ProcessExecutor &) = delete;
+    ProcessExecutor& operator=(const ProcessExecutor &) = delete;
+
+    unsigned int check() override;
+
+private:
+    /**
+     * Read from the pipe, parse and handle what ever is in there.
+     * @return False in case of an recoverable error - will exit process on others
+     */
+    bool handleRead(int rpipe, unsigned int &result, const std::string& filename);
+
+    /**
+     * @brief Check load average condition
+     * @param nchildren - count of currently ran children
+     * @return true - if new process can be started
+     */
+    bool checkLoadAverage(size_t nchildren);
+
+    /**
+     * @brief Reports internal errors related to child processes
+     * @param msg The error message
+     */
+    void reportInternalChildErr(const std::string &childname, const std::string &msg);
+
+    CppCheck::ExecuteCmdFn mExecuteCommand;
+};
+
+/// @}
+
+#endif // HAS_THREADING_MODEL_FORK
+
+#endif // PROCESSEXECUTOR_H
diff --git a/cli/sehwrapper.cpp b/cli/sehwrapper.cpp
new file mode 100644
index 00000000000..c14278d99fd
--- /dev/null
+++ b/cli/sehwrapper.cpp
@@ -0,0 +1,270 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "sehwrapper.h"
+
+#ifdef USE_WINDOWS_SEH
+
+#include "utils.h"
+
+#include <windows.h>
+#include <dbghelp.h>
+#include <tchar.h>
+
+static FILE* sehOutput = stdout;
+
+void set_seh_output(FILE* f)
+{
+    sehOutput = f;
+}
+
+namespace {
+    const ULONG maxnamelength = 512;
+    struct IMAGEHLP_SYMBOL64_EXT : public IMAGEHLP_SYMBOL64 {
+        TCHAR nameExt[maxnamelength]; // actually no need to worry about character encoding here
+    };
+    typedef BOOL (WINAPI *fpStackWalk64)(DWORD, HANDLE, HANDLE, LPSTACKFRAME64, PVOID, PREAD_PROCESS_MEMORY_ROUTINE64, PFUNCTION_TABLE_ACCESS_ROUTINE64, PGET_MODULE_BASE_ROUTINE64, PTRANSLATE_ADDRESS_ROUTINE64);
+    fpStackWalk64 pStackWalk64;
+    typedef DWORD64 (WINAPI *fpSymGetModuleBase64)(HANDLE, DWORD64);
+    fpSymGetModuleBase64 pSymGetModuleBase64;
+    typedef BOOL (WINAPI *fpSymGetSymFromAddr64)(HANDLE, DWORD64, PDWORD64, PIMAGEHLP_SYMBOL64);
+    fpSymGetSymFromAddr64 pSymGetSymFromAddr64;
+    typedef BOOL (WINAPI *fpSymGetLineFromAddr64)(HANDLE, DWORD64, PDWORD, PIMAGEHLP_LINE64);
+    fpSymGetLineFromAddr64 pSymGetLineFromAddr64;
+    typedef DWORD (WINAPI *fpUnDecorateSymbolName)(const TCHAR*, PTSTR, DWORD, DWORD);
+    fpUnDecorateSymbolName pUnDecorateSymbolName;
+    typedef PVOID (WINAPI *fpSymFunctionTableAccess64)(HANDLE, DWORD64);
+    fpSymFunctionTableAccess64 pSymFunctionTableAccess64;
+    typedef BOOL (WINAPI *fpSymInitialize)(HANDLE, PCSTR, BOOL);
+    fpSymInitialize pSymInitialize;
+
+    HMODULE hLibDbgHelp;
+// avoid explicit dependency on Dbghelp.dll
+    bool loadDbgHelp()
+    {
+        hLibDbgHelp = ::LoadLibraryW(L"Dbghelp.dll");
+        if (!hLibDbgHelp)
+            return false;
+        pStackWalk64 = (fpStackWalk64) ::GetProcAddress(hLibDbgHelp, "StackWalk64");
+        pSymGetModuleBase64 = (fpSymGetModuleBase64) ::GetProcAddress(hLibDbgHelp, "SymGetModuleBase64");
+        pSymGetSymFromAddr64 = (fpSymGetSymFromAddr64) ::GetProcAddress(hLibDbgHelp, "SymGetSymFromAddr64");
+        pSymGetLineFromAddr64 = (fpSymGetLineFromAddr64)::GetProcAddress(hLibDbgHelp, "SymGetLineFromAddr64");
+        pSymFunctionTableAccess64 = (fpSymFunctionTableAccess64)::GetProcAddress(hLibDbgHelp, "SymFunctionTableAccess64");
+        pSymInitialize = (fpSymInitialize) ::GetProcAddress(hLibDbgHelp, "SymInitialize");
+        pUnDecorateSymbolName = (fpUnDecorateSymbolName)::GetProcAddress(hLibDbgHelp, "UnDecorateSymbolName");
+        return true;
+    }
+
+
+    void printCallstack(FILE* outputFile, PEXCEPTION_POINTERS ex)
+    {
+        if (!loadDbgHelp())
+            return;
+        const HANDLE hProcess   = GetCurrentProcess();
+        const HANDLE hThread    = GetCurrentThread();
+        pSymInitialize(
+            hProcess,
+            nullptr,
+            TRUE
+            );
+        CONTEXT context = *(ex->ContextRecord);
+        STACKFRAME64 stack= {0};
+        stack.AddrPC.Mode    = AddrModeFlat;
+        stack.AddrStack.Mode = AddrModeFlat;
+        stack.AddrFrame.Mode = AddrModeFlat;
+#if defined(_M_IX86)
+        stack.AddrPC.Offset    = context.Eip;
+        stack.AddrStack.Offset = context.Esp;
+        stack.AddrFrame.Offset = context.Ebp;
+#elif defined(_M_AMD64)
+        stack.AddrPC.Offset    = context.Rip;
+        stack.AddrStack.Offset = context.Rsp;
+        stack.AddrFrame.Offset = context.Rsp;
+#elif defined(_M_ARM64)
+        stack.AddrPC.Offset    = context.Pc;
+        stack.AddrStack.Offset = context.Sp;
+        stack.AddrFrame.Offset = context.Fp;
+#else
+#error Platform not supported!
+#endif
+        IMAGEHLP_SYMBOL64_EXT symbol;
+        symbol.SizeOfStruct  = sizeof(IMAGEHLP_SYMBOL64);
+        symbol.MaxNameLength = maxnamelength;
+        DWORD64 displacement   = 0;
+        int beyond_main=-1; // emergency exit, see below
+        for (ULONG frame = 0; ; frame++) {
+            BOOL result = pStackWalk64
+                          (
+#if defined(_M_IX86)
+                IMAGE_FILE_MACHINE_I386,
+#elif defined(_M_AMD64)
+                IMAGE_FILE_MACHINE_AMD64,
+#elif defined(_M_ARM64)
+                IMAGE_FILE_MACHINE_ARM64,
+#endif
+                hProcess,
+                hThread,
+                &stack,
+                &context,
+                nullptr,
+                pSymFunctionTableAccess64,
+                pSymGetModuleBase64,
+                nullptr
+                          );
+            if (!result)  // official end...
+                break;
+            pSymGetSymFromAddr64(hProcess, (ULONG64)stack.AddrPC.Offset, &displacement, &symbol);
+            TCHAR undname[maxnamelength]= {0};
+            pUnDecorateSymbolName((const TCHAR*)symbol.Name, (PTSTR)undname, (DWORD)getArrayLength(undname), UNDNAME_COMPLETE);
+            if (beyond_main>=0)
+                ++beyond_main;
+            if (_tcscmp(undname, _T("main"))==0)
+                beyond_main=0;
+            fprintf(outputFile,
+                    "%lu. 0x%08I64X in ",
+                    frame, (ULONG64)stack.AddrPC.Offset);
+            fputs((const char *)undname, outputFile);
+            fputc('\n', outputFile);
+            if (0==stack.AddrReturn.Offset || beyond_main>2) // StackWalk64() sometimes doesn't reach any end...
+                break;
+        }
+
+        FreeLibrary(hLibDbgHelp);
+        hLibDbgHelp=nullptr;
+    }
+
+    void writeMemoryErrorDetails(FILE* outputFile, PEXCEPTION_POINTERS ex, const char* description)
+    {
+        fputs(description, outputFile);
+        fprintf(outputFile, " (instruction: 0x%p) ", ex->ExceptionRecord->ExceptionAddress);
+        // Using %p for ULONG_PTR later on, so it must have size identical to size of pointer
+        // This is not the universally portable solution but good enough for Win32/64
+        C_ASSERT(sizeof(void*) == sizeof(ex->ExceptionRecord->ExceptionInformation[1]));
+        switch (ex->ExceptionRecord->ExceptionInformation[0]) {
+        case 0:
+            fprintf(outputFile, "reading from 0x%p",
+                    reinterpret_cast<void*>(ex->ExceptionRecord->ExceptionInformation[1]));
+            break;
+        case 1:
+            fprintf(outputFile, "writing to 0x%p",
+                    reinterpret_cast<void*>(ex->ExceptionRecord->ExceptionInformation[1]));
+            break;
+        case 8:
+            fprintf(outputFile, "data execution prevention at 0x%p",
+                    reinterpret_cast<void*>(ex->ExceptionRecord->ExceptionInformation[1]));
+            break;
+        default:
+            break;
+        }
+    }
+
+    /*
+     * Any evaluation of the exception needs to be done here!
+     */
+    int filterException(FILE *outputFile, int code, PEXCEPTION_POINTERS ex)
+    {
+        fputs("Internal error: ", outputFile);
+        switch (ex->ExceptionRecord->ExceptionCode) {
+        case EXCEPTION_ACCESS_VIOLATION:
+            writeMemoryErrorDetails(outputFile, ex, "Access violation");
+            break;
+        case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
+            fputs("Out of array bounds", outputFile);
+            break;
+        case EXCEPTION_BREAKPOINT:
+            fputs("Breakpoint", outputFile);
+            break;
+        case EXCEPTION_DATATYPE_MISALIGNMENT:
+            fputs("Misaligned data", outputFile);
+            break;
+        case EXCEPTION_FLT_DENORMAL_OPERAND:
+            fputs("Denormalized floating-point value", outputFile);
+            break;
+        case EXCEPTION_FLT_DIVIDE_BY_ZERO:
+            fputs("Floating-point divide-by-zero", outputFile);
+            break;
+        case EXCEPTION_FLT_INEXACT_RESULT:
+            fputs("Inexact floating-point value", outputFile);
+            break;
+        case EXCEPTION_FLT_INVALID_OPERATION:
+            fputs("Invalid floating-point operation", outputFile);
+            break;
+        case EXCEPTION_FLT_OVERFLOW:
+            fputs("Floating-point overflow", outputFile);
+            break;
+        case EXCEPTION_FLT_STACK_CHECK:
+            fputs("Floating-point stack overflow", outputFile);
+            break;
+        case EXCEPTION_FLT_UNDERFLOW:
+            fputs("Floating-point underflow", outputFile);
+            break;
+        case EXCEPTION_GUARD_PAGE:
+            fputs("Page-guard access", outputFile);
+            break;
+        case EXCEPTION_ILLEGAL_INSTRUCTION:
+            fputs("Illegal instruction", outputFile);
+            break;
+        case EXCEPTION_IN_PAGE_ERROR:
+            writeMemoryErrorDetails(outputFile, ex, "Invalid page access");
+            break;
+        case EXCEPTION_INT_DIVIDE_BY_ZERO:
+            fputs("Integer divide-by-zero", outputFile);
+            break;
+        case EXCEPTION_INT_OVERFLOW:
+            fputs("Integer overflow", outputFile);
+            break;
+        case EXCEPTION_INVALID_DISPOSITION:
+            fputs("Invalid exception dispatcher", outputFile);
+            break;
+        case EXCEPTION_INVALID_HANDLE:
+            fputs("Invalid handle", outputFile);
+            break;
+        case EXCEPTION_NONCONTINUABLE_EXCEPTION:
+            fputs("Non-continuable exception", outputFile);
+            break;
+        case EXCEPTION_PRIV_INSTRUCTION:
+            fputs("Invalid instruction", outputFile);
+            break;
+        case EXCEPTION_SINGLE_STEP:
+            fputs("Single instruction step", outputFile);
+            break;
+        case EXCEPTION_STACK_OVERFLOW:
+            fputs("Stack overflow", outputFile);
+            break;
+        default:
+            fprintf(outputFile, "Unknown exception (%d)\n",
+                    code);
+            break;
+        }
+        fputc('\n', outputFile);
+        printCallstack(outputFile, ex);
+        fputs("Please report this to the cppcheck developers!\n", outputFile);
+        fflush(outputFile);
+        return EXCEPTION_EXECUTE_HANDLER;
+    }
+}
+
+namespace internal
+{
+    int filter_seh_exeception(int code, void* ex)
+    {
+        return filterException(sehOutput, code, static_cast<PEXCEPTION_POINTERS>(ex));
+    }
+}
+
+#endif
diff --git a/cli/sehwrapper.h b/cli/sehwrapper.h
new file mode 100644
index 00000000000..9a7e25f9454
--- /dev/null
+++ b/cli/sehwrapper.h
@@ -0,0 +1,51 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CPPCHECKEXECUTORSEH_H
+#define CPPCHECKEXECUTORSEH_H
+
+#include "config.h" // IWYU pragma: keep
+
+#ifdef USE_WINDOWS_SEH
+
+#include <cstdio>
+
+/**
+ * @param f Output file
+ */
+void set_seh_output(FILE* f);
+
+namespace internal
+{
+    int filter_seh_exeception(int code, void* ex);
+}
+
+/**
+ * Signal/SEH handling
+ * Has to be clean for using with SEH on windows, i.e. no construction of C++ object instances is allowed!
+ */
+#define CALL_WITH_SEH_WRAPPER(f) \
+    __try {                      \
+        return (f);              \
+    } __except (internal::filter_seh_exeception(GetExceptionCode(), GetExceptionInformation())) { \
+        return -1; \
+    }
+
+#endif
+
+#endif // CPPCHECKEXECUTORSEH_H
diff --git a/cli/signalhandler.cpp b/cli/signalhandler.cpp
new file mode 100644
index 00000000000..f8fd5a4e0a0
--- /dev/null
+++ b/cli/signalhandler.cpp
@@ -0,0 +1,331 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if defined(__CYGWIN__)
+#define _BSD_SOURCE // required to have siginfo_t, SIGSTKSZ, kill(), sigaction and others
+#endif
+
+#include "signalhandler.h"
+
+#if defined(USE_UNIX_SIGNAL_HANDLING)
+
+#ifdef USE_UNIX_BACKTRACE_SUPPORT
+#include "stacktrace.h"
+#endif
+
+#include <csignal>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+//#include <features.h> // __USE_DYNAMIC_STACK_SIZE
+#include <map>
+#include <string>
+#include <sys/types.h>
+#include <unistd.h>
+#include <utility>
+
+#if defined(__linux__) && defined(REG_ERR)
+#include <sys/syscall.h>
+#endif
+
+#if defined(__APPLE__)
+#   define _XOPEN_SOURCE // ucontext.h APIs can only be used on Mac OSX >= 10.7 if _XOPEN_SOURCE is defined
+#   include <ucontext.h>
+
+#   undef _XOPEN_SOURCE
+#elif !defined(__OpenBSD__) && !defined(__HAIKU__)
+#   include <ucontext.h>
+#endif
+
+// TODO: __USE_DYNAMIC_STACK_SIZE is dependent on the features.h include and not a built-in compiler define, so it might be problematic to depend on it
+#ifdef __USE_DYNAMIC_STACK_SIZE
+static constexpr size_t MYSTACKSIZE = (16*1024)+32768; // wild guess about a reasonable buffer
+#else
+static constexpr size_t MYSTACKSIZE = (16*1024)+SIGSTKSZ; // wild guess about a reasonable buffer
+#endif
+static char mytstack[MYSTACKSIZE]= {0}; // alternative stack for signal handler
+static bool bStackBelowHeap=false; // lame attempt to locate heap vs. stack address space. See CppCheckExecutor::check_wrapper()
+static FILE* signalOutput = stdout; // TODO: get rid of this
+
+/**
+ * \param[in] ptr address to be examined.
+ * \return true if address is supposed to be on stack (contrary to heap). If ptr is 0 false will be returned.
+ * If unknown better return false.
+ */
+static bool IsAddressOnStack(const void* ptr)
+{
+    if (nullptr==ptr)
+        return false;
+    char a;
+    if (bStackBelowHeap)
+        return ptr < &a;
+    return ptr > &a;
+}
+
+/* (declare this list here, so it may be used in signal handlers in addition to main())
+ * A list of signals available in ISO C
+ * Check out http://pubs.opengroup.org/onlinepubs/009695399/basedefs/signal.h.html
+ * For now we only want to detect abnormal behaviour for a few selected signals:
+ */
+
+#define DECLARE_SIGNAL(x) std::make_pair(x, #x)
+using Signalmap_t = std::map<int, std::string>;
+static const Signalmap_t listofsignals = {
+    DECLARE_SIGNAL(SIGABRT),
+    DECLARE_SIGNAL(SIGBUS),
+    DECLARE_SIGNAL(SIGFPE),
+    DECLARE_SIGNAL(SIGILL),
+    DECLARE_SIGNAL(SIGINT),
+    DECLARE_SIGNAL(SIGQUIT),
+    DECLARE_SIGNAL(SIGSEGV),
+    DECLARE_SIGNAL(SIGSYS),
+    // don't care: SIGTERM
+    DECLARE_SIGNAL(SIGUSR1),
+    //DECLARE_SIGNAL(SIGUSR2) no usage currently
+};
+#undef DECLARE_SIGNAL
+/*
+ * Entry pointer for signal handlers
+ * It uses functions which are not safe to be called from a signal handler,
+ * (http://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html#tag_15_04 has a whitelist)
+ * but when ending up here something went terribly wrong anyway.
+ * And all which is left is just printing some information and terminate.
+ */
+static void CppcheckSignalHandler(int signo, siginfo_t * info, void * context) // cppcheck-suppress constParameterCallback - info can be const
+{
+    int type = -1;
+    pid_t killid;
+    // TODO: separate these two defines
+#if defined(__linux__) && defined(REG_ERR)
+    const auto* const uc = reinterpret_cast<const ucontext_t*>(context);
+    killid = static_cast<pid_t>(syscall(SYS_gettid));
+    if (uc) {
+        type = static_cast<int>(uc->uc_mcontext.gregs[REG_ERR]) & 2;
+    }
+#else
+    (void)context;
+    killid = getpid();
+#endif
+
+    const auto it = listofsignals.find(signo);
+    const char * const signame = (it==listofsignals.end()) ? "unknown" : it->second.c_str();
+    bool unexpectedSignal=true; // unexpected indicates program failure
+    bool terminate=true; // exit process/thread
+    const bool isAddressOnStack = IsAddressOnStack(info->si_addr);
+    FILE * const output = signalOutput;
+    switch (signo) {
+    case SIGABRT:
+        fputs("Internal error: cppcheck received signal ", output);
+        fputs(signame, output);
+        fputs(
+#ifdef NDEBUG
+            " - abort\n",
+#else
+            " - abort or assertion\n",
+#endif
+            output);
+        break;
+    case SIGBUS:
+        fputs("Internal error: cppcheck received signal ", output);
+        fputs(signame, output);
+        switch (info->si_code) {
+        case BUS_ADRALN:         // invalid address alignment
+            fputs(" - BUS_ADRALN", output);
+            break;
+        case BUS_ADRERR:         // nonexistent physical address
+            fputs(" - BUS_ADRERR", output);
+            break;
+        case BUS_OBJERR:         // object-specific hardware error
+            fputs(" - BUS_OBJERR", output);
+            break;
+#ifdef BUS_MCEERR_AR
+        case BUS_MCEERR_AR:             // Hardware memory error consumed on a machine check;
+            fputs(" - BUS_MCEERR_AR", output);
+            break;
+#endif
+#ifdef BUS_MCEERR_AO
+        case BUS_MCEERR_AO:             // Hardware memory error detected in process but not consumed
+            fputs(" - BUS_MCEERR_AO", output);
+            break;
+#endif
+        default:
+            break;
+        }
+        fprintf(output, " (at 0x%lx).\n",
+                reinterpret_cast<unsigned long>(info->si_addr));
+        break;
+    case SIGFPE:
+        fputs("Internal error: cppcheck received signal ", output);
+        fputs(signame, output);
+        switch (info->si_code) {
+        case FPE_INTDIV:         //     integer divide by zero
+            fputs(" - FPE_INTDIV", output);
+            break;
+        case FPE_INTOVF:         //     integer overflow
+            fputs(" - FPE_INTOVF", output);
+            break;
+        case FPE_FLTDIV:         //     floating-point divide by zero
+            fputs(" - FPE_FLTDIV", output);
+            break;
+        case FPE_FLTOVF:         //     floating-point overflow
+            fputs(" - FPE_FLTOVF", output);
+            break;
+        case FPE_FLTUND:         //     floating-point underflow
+            fputs(" - FPE_FLTUND", output);
+            break;
+        case FPE_FLTRES:         //     floating-point inexact result
+            fputs(" - FPE_FLTRES", output);
+            break;
+        case FPE_FLTINV:         //     floating-point invalid operation
+            fputs(" - FPE_FLTINV", output);
+            break;
+        case FPE_FLTSUB:         //     subscript out of range
+            fputs(" - FPE_FLTSUB", output);
+            break;
+        default:
+            break;
+        }
+        fprintf(output, " (at 0x%lx).\n",
+                reinterpret_cast<unsigned long>(info->si_addr));
+        break;
+    case SIGILL:
+        fputs("Internal error: cppcheck received signal ", output);
+        fputs(signame, output);
+        switch (info->si_code) {
+        case ILL_ILLOPC:         //     illegal opcode
+            fputs(" - ILL_ILLOPC", output);
+            break;
+        case ILL_ILLOPN:         //    illegal operand
+            fputs(" - ILL_ILLOPN", output);
+            break;
+        case ILL_ILLADR:         //    illegal addressing mode
+            fputs(" - ILL_ILLADR", output);
+            break;
+        case ILL_ILLTRP:         //    illegal trap
+            fputs(" - ILL_ILLTRP", output);
+            break;
+        case ILL_PRVOPC:         //    privileged opcode
+            fputs(" - ILL_PRVOPC", output);
+            break;
+        case ILL_PRVREG:         //    privileged register
+            fputs(" - ILL_PRVREG", output);
+            break;
+        case ILL_COPROC:         //    coprocessor error
+            fputs(" - ILL_COPROC", output);
+            break;
+        case ILL_BADSTK:         //    internal stack error
+            fputs(" - ILL_BADSTK", output);
+            break;
+        default:
+            break;
+        }
+        fprintf(output, " (at 0x%lx).%s\n",
+                reinterpret_cast<unsigned long>(info->si_addr),
+                isAddressOnStack ? " Stackoverflow?" : "");
+        break;
+    case SIGINT:
+        unexpectedSignal=false;     // legal usage: interrupt application via CTRL-C
+        fputs("cppcheck received signal ", output);
+        fputs(signame, output);
+        fputs(".\n", output);
+        break;
+    case SIGSEGV:
+        fputs("Internal error: cppcheck received signal ", output);
+        fputs(signame, output);
+        switch (info->si_code) {
+        case SEGV_MAPERR:         //    address not mapped to object
+            fputs(" - SEGV_MAPERR", output);
+            break;
+        case SEGV_ACCERR:         //    invalid permissions for mapped object
+            fputs(" - SEGV_ACCERR", output);
+            break;
+        default:
+            break;
+        }
+        fprintf(output, " (%sat 0x%lx).%s\n",
+                // cppcheck-suppress knownConditionTrueFalse ; FP
+                (type==-1)? "" :
+                (type==0) ? "reading " : "writing ",
+                reinterpret_cast<unsigned long>(info->si_addr),
+                isAddressOnStack ? " Stackoverflow?" : ""
+                );
+        break;
+    case SIGUSR1:
+        fputs("cppcheck received signal ", output);
+        fputs(signame, output);
+        fputs(".\n", output);
+        terminate=false;
+        break;
+    default:
+        fputs("Internal error: cppcheck received signal ", output);
+        fputs(signame, output);
+        fputs(".\n", output);
+        break;
+    }
+#ifdef USE_UNIX_BACKTRACE_SUPPORT
+    // flush otherwise the trace might be printed earlier
+    fflush(output);
+    print_stacktrace(output, 1, true, -1, true);
+#endif
+    if (unexpectedSignal) {
+        fputs("\nPlease report this to the cppcheck developers!\n", output);
+    }
+    fflush(output);
+
+    if (terminate) {
+        // now let things proceed, shutdown and hopefully dump core for post-mortem analysis
+        struct sigaction act;
+        memset(&act, 0, sizeof(act));
+        act.sa_handler=SIG_DFL;
+        sigaction(signo, &act, nullptr);
+        kill(killid, signo);
+    }
+}
+
+void register_signal_handler(FILE * const output)
+{
+    signalOutput = output;
+
+    // determine stack vs. heap
+    char stackVariable;
+    char *heapVariable=static_cast<char*>(malloc(1));
+    bStackBelowHeap = &stackVariable < heapVariable;
+    free(heapVariable);
+
+    // set up alternative stack for signal handler
+    stack_t segv_stack;
+    segv_stack.ss_sp = mytstack;
+    segv_stack.ss_flags = 0;
+    segv_stack.ss_size = MYSTACKSIZE;
+    if (sigaltstack(&segv_stack, nullptr) != 0) {
+        // TODO: log errno
+        fputs("could not set alternate signal stack context.\n", output);
+        std::exit(EXIT_FAILURE);
+    }
+
+    // install signal handler
+    struct sigaction act;
+    memset(&act, 0, sizeof(act));
+    act.sa_flags=SA_SIGINFO|SA_ONSTACK;
+    act.sa_sigaction=CppcheckSignalHandler;
+    for (auto sig=listofsignals.cbegin(); sig!=listofsignals.cend(); ++sig) {
+        sigaction(sig->first, &act, nullptr);
+    }
+}
+
+#endif
diff --git a/cli/signalhandler.h b/cli/signalhandler.h
new file mode 100644
index 00000000000..df5a6120fe8
--- /dev/null
+++ b/cli/signalhandler.h
@@ -0,0 +1,32 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SIGNALHANDLER_H
+#define SIGNALHANDLER_H
+
+#include "config.h"
+
+#if defined(USE_UNIX_SIGNAL_HANDLING)
+
+#include <cstdio>
+
+void register_signal_handler(FILE* output);
+
+#endif // USE_UNIX_SIGNAL_HANDLING
+
+#endif // SIGNALHANDLER_H
diff --git a/cli/singleexecutor.cpp b/cli/singleexecutor.cpp
new file mode 100644
index 00000000000..b84aa70772e
--- /dev/null
+++ b/cli/singleexecutor.cpp
@@ -0,0 +1,78 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "singleexecutor.h"
+
+#include "cppcheck.h"
+#include "filesettings.h"
+#include "settings.h"
+#include "timer.h"
+
+#include <cassert>
+#include <cstddef>
+#include <list>
+#include <numeric>
+
+class ErrorLogger;
+
+SingleExecutor::SingleExecutor(CppCheck &cppcheck, const std::list<FileWithDetails> &files, const std::list<FileSettings>& fileSettings, const Settings &settings, Suppressions &suppressions, ErrorLogger &errorLogger, TimerResults* timerResults)
+    : Executor(files, fileSettings, settings, suppressions, errorLogger, timerResults)
+    , mCppcheck(cppcheck)
+{
+    assert(mSettings.jobs == 1);
+}
+
+// TODO: markup handling is not performed with multiple jobs
+unsigned int SingleExecutor::check()
+{
+    unsigned int result = 0;
+
+    const std::size_t totalfilesize = std::accumulate(mFiles.cbegin(), mFiles.cend(), std::size_t(0), [](std::size_t v, const FileWithDetails& f) {
+        return v + f.size();
+    });
+
+    std::size_t processedsize = 0;
+    unsigned int c = 0;
+
+    for (auto i = mFiles.cbegin(); i != mFiles.cend(); ++i) {
+        result += mCppcheck.check(*i);
+        processedsize += i->size();
+        ++c;
+        if (!mSettings.quiet)
+            reportStatus(c, mFiles.size(), processedsize, totalfilesize);
+        // TODO: call analyseClangTidy()?
+    }
+
+    // filesettings
+    // check all files of the project
+    for (const FileSettings &fs : mFileSettings) {
+        result += mCppcheck.check(fs);
+        ++c;
+        if (!mSettings.quiet)
+            reportStatus(c, mFileSettings.size(), c, mFileSettings.size());
+    }
+
+    // TODO: CppCheckExecutor::check_internal() is also invoking the whole program analysis - is it run twice?
+    if (mCppcheck.analyseWholeProgram())
+        result++;
+
+    if (mTimerResults && (mSettings.showtime == ShowTime::SUMMARY || mSettings.showtime == ShowTime::TOP5_SUMMARY))
+        mTimerResults->showResults(mSettings.showtime);
+
+    return result;
+}
diff --git a/cli/singleexecutor.h b/cli/singleexecutor.h
new file mode 100644
index 00000000000..8b908bd6c4e
--- /dev/null
+++ b/cli/singleexecutor.h
@@ -0,0 +1,47 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SINGLEEXECUTOR_H
+#define SINGLEEXECUTOR_H
+
+#include "executor.h"
+
+#include <list>
+
+class ErrorLogger;
+class Settings;
+class CppCheck;
+struct Suppressions;
+struct FileSettings;
+class FileWithDetails;
+class TimerResults;
+
+class SingleExecutor : public Executor
+{
+public:
+    SingleExecutor(CppCheck &cppcheck, const std::list<FileWithDetails> &files, const std::list<FileSettings>& fileSettings, const Settings &settings, Suppressions &suppressions, ErrorLogger &errorLogger, TimerResults* timerResults);
+    SingleExecutor(const SingleExecutor &) = delete;
+    SingleExecutor& operator=(const SingleExecutor &) = delete;
+
+    unsigned int check() override;
+
+private:
+    CppCheck &mCppcheck;
+};
+
+#endif // SINGLEEXECUTOR_H
diff --git a/cli/stacktrace.cpp b/cli/stacktrace.cpp
new file mode 100644
index 00000000000..dbcbed448bb
--- /dev/null
+++ b/cli/stacktrace.cpp
@@ -0,0 +1,142 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "stacktrace.h"
+
+#ifdef USE_UNIX_BACKTRACE_SUPPORT
+
+#include "utils.h"
+
+#include <algorithm>
+#include <cstdlib>
+#include <cstring>
+#include <cxxabi.h>
+#include <execinfo.h>
+
+void print_stacktrace(FILE* output, int start_idx, bool demangling, int maxdepth, bool omit_above_own)
+{
+    // 32 vs. 64bit
+    static constexpr auto ADDRESSDISPLAYLENGTH = (sizeof(long) == 8) ? 12 : 8;
+
+    void *callstackArray[32]= {nullptr}; // the less resources the better...
+    const int currentdepth = backtrace(callstackArray, static_cast<int>(getArrayLength(callstackArray)));
+    if (currentdepth == 0) {
+        fputs("Callstack could not be obtained (backtrace)\n", output);
+        return;
+    }
+    if (currentdepth == getArrayLength(callstackArray)) {
+        fputs("Callstack might be truncated\n", output);
+    }
+    // set offset to 1 to omit the printing function itself
+    int offset=start_idx+1; // some entries on top are within our own exception handling code or libc
+    if (maxdepth<0)
+        maxdepth=currentdepth-offset;
+    else
+        maxdepth = std::min(maxdepth, currentdepth);
+
+    char **symbolStringList = backtrace_symbols(callstackArray, currentdepth);
+    if (!symbolStringList) {
+        fputs("Callstack could not be obtained (backtrace_symbols)\n", output);
+        return;
+    }
+
+    fputs("Callstack:\n", output);
+    bool own_code = false;
+    char demangle_buffer[2048]= {0};
+    bool no_address = false;
+    for (int i = offset; i < maxdepth; ++i) {
+        const char * const symbolString = symbolStringList[i];
+        // TODO: implement parsing for __APPLE__
+        // 0   test-signalhandler                  0x0000000100dbf42c _Z16print_stacktraceP7__sFILEibib + 124
+
+        /*
+         * examples:
+         * ./test-signalhandler(_Z16print_stacktraceP8_IO_FILEibib+0xa1) [0x55cb65e41464]
+         * ./test-signalhandler(+0xf9d9) [0x55cb65e3c9d9]
+         */
+
+        // skip all leading libc symbols so the first symbol is our code
+        if (omit_above_own && !own_code) {
+            if (strstr(symbolString, "/libc.so.6") != nullptr)
+                continue;
+            own_code = true;
+            offset = i; // make sure the numbering is continuous if we omit frames
+        }
+        const char * realnameString = nullptr;
+        if (demangling) {
+            const char * const firstBracketName = strchr(symbolString, '(');
+            if (firstBracketName) {
+                const char * const plus = strchr(firstBracketName, '+');
+                if (plus && (plus>(firstBracketName+1))) {
+                    char input_buffer[1024]= {0};
+                    strncpy(input_buffer, firstBracketName+1, plus-firstBracketName-1);
+                    size_t length = getArrayLength(demangle_buffer);
+                    int status=0;
+                    // We're violating the specification - passing stack address instead of malloc'ed heap.
+                    // Benefit is that no further heap is required, while there is sufficient stack...
+                    realnameString = abi::__cxa_demangle(input_buffer, demangle_buffer, &length, &status); // non-NULL on success
+                }
+            }
+        }
+
+        const char * const firstBracketAddress = strchr(symbolString, '[');
+        if (!firstBracketAddress) {
+            no_address = true;
+            break;
+        }
+        const char * const secondBracketAddress = strchr(firstBracketAddress, ']');
+        if (!secondBracketAddress) {
+            no_address = true;
+            break;
+        }
+
+        const int ordinal=i-offset;
+        fprintf(output, "#%-2d 0x",
+                ordinal);
+        const int padLen = [&]() {
+            const char * const beginAddress = firstBracketAddress+3;
+            const int addressLen = int(secondBracketAddress-beginAddress);
+            return (ADDRESSDISPLAYLENGTH-addressLen);
+        }();
+        if (padLen>0)
+            fprintf(output, "%0*d",
+                    padLen,
+                    0);
+        if (realnameString) {
+            fprintf(output, "%.*s in %s\n",
+                    static_cast<int>(secondBracketAddress - firstBracketAddress - 3),
+                    firstBracketAddress+3,
+                    realnameString);
+        } else {
+            fprintf(output, "%.*s in %.*s\n",
+                    static_cast<int>(secondBracketAddress - firstBracketAddress - 3),
+                    firstBracketAddress+3,
+                    static_cast<int>(firstBracketAddress - symbolString),
+                    symbolString);
+        }
+    }
+    // NOLINTNEXTLINE(bugprone-multi-level-implicit-pointer-conversion) - code matches the documented usage
+    free(symbolStringList);
+
+    if (no_address) {
+        fputs("Callstack could not be obtained (no address)\n", output);
+        return;
+    }
+}
+
+#endif // USE_UNIX_BACKTRACE_SUPPORT
diff --git a/cli/stacktrace.h b/cli/stacktrace.h
new file mode 100644
index 00000000000..1e98d55ebc0
--- /dev/null
+++ b/cli/stacktrace.h
@@ -0,0 +1,44 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef STACKTRACE_H
+#define STACKTRACE_H
+
+#include "config.h"
+
+#ifdef USE_UNIX_BACKTRACE_SUPPORT
+
+#include <cstdio>
+
+/*
+ * Try to print the callstack.
+ * That is very sensitive to the operating system, hardware, compiler and runtime.
+ * The code is not meant for production environment!
+ * One reason is named first: it's using functions not whitelisted for usage in a signal handler function.
+ *
+ * @param output the descriptor to write the trace to
+ * @param start_idx the frame index to start with
+ * @param demangling controls demangling of symbols
+ * @param maxdepth the maximum number of frames to list (32 at most or if -1)
+ * @param omit_above_own omit top frames which are above our own code (i.e. libc symbols)
+ */
+void print_stacktrace(FILE* output, int start_idx, bool demangling, int maxdepth, bool omit_above_own);
+
+#endif
+
+#endif // STACKTRACE_H
diff --git a/cli/threadexecutor.cpp b/cli/threadexecutor.cpp
index 86276f96a33..8e8893e72cb 100644
--- a/cli/threadexecutor.cpp
+++ b/cli/threadexecutor.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,537 +18,208 @@
 
 #include "threadexecutor.h"
 
+#ifdef HAS_THREADING_MODEL_THREAD
+
 #include "config.h"
 #include "cppcheck.h"
-#include "cppcheckexecutor.h"
-#include "importproject.h"
+#include "errorlogger.h"
+#include "filesettings.h"
 #include "settings.h"
 #include "suppressions.h"
+#include "timer.h"
 
-#include <algorithm>
-#include <cerrno>
+#include <cassert>
 #include <cstdlib>
-#include <cstring>
+#include <future>
 #include <iostream>
+#include <list>
+#include <numeric>
+#include <mutex>
+#include <string>
+#include <system_error>
 #include <utility>
+#include <vector>
 
-#ifdef __SVR4  // Solaris
-#include <sys/loadavg.h>
-#endif
-#ifdef THREADING_MODEL_FORK
-#include <sys/select.h>
-#include <sys/wait.h>
-#include <fcntl.h>
-#include <unistd.h>
-#endif
-#ifdef THREADING_MODEL_WIN
-#include <process.h>
-#include <windows.h>
-#endif
-
-// required for FD_ZERO
-using std::memset;
-
-ThreadExecutor::ThreadExecutor(const std::map<std::string, std::size_t> &files, Settings &settings, ErrorLogger &errorLogger)
-    : mFiles(files), mSettings(settings), mErrorLogger(errorLogger), mFileCount(0)
-      // Not initialized mFileSync, mErrorSync, mReportSync
-{
-#if defined(THREADING_MODEL_FORK)
-    mWpipe = 0;
-#elif defined(THREADING_MODEL_WIN)
-    mProcessedFiles = 0;
-    mTotalFiles = 0;
-    mProcessedSize = 0;
-    mTotalFileSize = 0;
-#endif
-}
-
-ThreadExecutor::~ThreadExecutor()
+ThreadExecutor::ThreadExecutor(const std::list<FileWithDetails> &files, const std::list<FileSettings>& fileSettings, const Settings &settings, Suppressions &suppressions, ErrorLogger &errorLogger, TimerResults* timerResults, CppCheck::ExecuteCmdFn executeCommand)
+    : Executor(files, fileSettings, settings, suppressions, errorLogger, timerResults)
+    , mExecuteCommand(std::move(executeCommand))
 {
-    //dtor
+    assert(mSettings.jobs > 1);
 }
 
-
-///////////////////////////////////////////////////////////////////////////////
-////// This code is for platforms that support fork() only ////////////////////
-///////////////////////////////////////////////////////////////////////////////
-
-#if defined(THREADING_MODEL_FORK)
-
-void ThreadExecutor::addFileContent(const std::string &path, const std::string &content)
+class SyncLogForwarder : public ErrorLogger
 {
-    mFileContents[ path ] = content;
-}
+public:
+    explicit SyncLogForwarder(ThreadExecutor &threadExecutor, ErrorLogger &errorLogger)
+        : mThreadExecutor(threadExecutor), mErrorLogger(errorLogger) {}
 
-int ThreadExecutor::handleRead(int rpipe, unsigned int &result)
-{
-    char type = 0;
-    if (read(rpipe, &type, 1) <= 0) {
-        if (errno == EAGAIN)
-            return 0;
+    void reportOut(const std::string &outmsg, Color c) override
+    {
+        std::lock_guard<std::mutex> lg(mReportSync);
 
-        return -1;
+        mErrorLogger.reportOut(outmsg, c);
     }
 
-    if (type != REPORT_OUT && type != REPORT_ERROR && type != REPORT_INFO && type != CHILD_END) {
-        std::cerr << "#### ThreadExecutor::handleRead error, type was:" << type << std::endl;
-        std::exit(0);
-    }
+    void reportErr(const ErrorMessage &msg) override {
+        if (!mThreadExecutor.hasToLog(msg))
+            return;
 
-    unsigned int len = 0;
-    if (read(rpipe, &len, sizeof(len)) <= 0) {
-        std::cerr << "#### ThreadExecutor::handleRead error, type was:" << type << std::endl;
-        std::exit(0);
+        std::lock_guard<std::mutex> lg(mReportSync);
+        mErrorLogger.reportErr(msg);
     }
 
-    // Don't rely on incoming data being null-terminated.
-    // Allocate +1 element and null-terminate the buffer.
-    char *buf = new char[len + 1];
-    const ssize_t readIntoBuf = read(rpipe, buf, len);
-    if (readIntoBuf <= 0) {
-        std::cerr << "#### ThreadExecutor::handleRead error, type was:" << type << std::endl;
-        std::exit(0);
-    }
-    buf[readIntoBuf] = 0;
-
-    if (type == REPORT_OUT) {
-        mErrorLogger.reportOut(buf);
-    } else if (type == REPORT_ERROR || type == REPORT_INFO) {
-        ErrorLogger::ErrorMessage msg;
-        msg.deserialize(buf);
-
-        if (!mSettings.nomsg.isSuppressed(msg.toSuppressionsErrorMessage())) {
-            // Alert only about unique errors
-            std::string errmsg = msg.toString(mSettings.verbose);
-            if (std::find(mErrorList.begin(), mErrorList.end(), errmsg) == mErrorList.end()) {
-                mErrorList.push_back(errmsg);
-                if (type == REPORT_ERROR)
-                    mErrorLogger.reportErr(msg);
-                else
-                    mErrorLogger.reportInfo(msg);
-            }
-        }
-    } else if (type == CHILD_END) {
-        std::istringstream iss(buf);
-        unsigned int fileResult = 0;
-        iss >> fileResult;
-        result += fileResult;
-        delete [] buf;
-        return -1;
+    void reportMetric(const std::string &metric) override {
+        std::lock_guard<std::mutex> lg(mReportSync);
+        mErrorLogger.reportMetric(metric);
     }
 
-    delete [] buf;
-    return 1;
-}
-
-bool ThreadExecutor::checkLoadAverage(size_t nchildren)
-{
-#if defined(__CYGWIN__) || defined(__QNX__)  // getloadavg() is unsupported on Cygwin, Qnx.
-    return true;
-#else
-    if (!nchildren || !mSettings.loadAverage) {
-        return true;
+    void reportStatus(std::size_t fileindex, std::size_t filecount, std::size_t sizedone, std::size_t sizetotal) {
+        std::lock_guard<std::mutex> lg(mReportSync);
+        mThreadExecutor.reportStatus(fileindex, filecount, sizedone, sizetotal);
     }
 
-    double sample(0);
-    if (getloadavg(&sample, 1) != 1) {
-        // disable load average checking on getloadavg error
-        return true;
-    } else if (sample < mSettings.loadAverage) {
-        return true;
-    }
-    return false;
-#endif
-}
+private:
+    std::mutex mReportSync;
+    ThreadExecutor &mThreadExecutor;
+    ErrorLogger &mErrorLogger;
+};
 
-unsigned int ThreadExecutor::check()
+class ThreadData
 {
-    mFileCount = 0;
-    unsigned int result = 0;
+public:
+    ThreadData(ThreadExecutor &threadExecutor, ErrorLogger &errorLogger, TimerResults *timerResults, const Settings &settings, Suppressions& supprs, const std::list<FileWithDetails> &files, const std::list<FileSettings> &fileSettings, CppCheck::ExecuteCmdFn executeCommand)
+        : mFiles(files), mFileSettings(fileSettings), mTimerResults(timerResults), mSettings(settings), mSuppressions(supprs), mExecuteCommand(std::move(executeCommand)), mLogForwarder(threadExecutor, errorLogger)
+    {
+        mItNextFile = mFiles.begin();
+        mItNextFileSettings = mFileSettings.begin();
 
-    std::size_t totalfilesize = 0;
-    for (std::map<std::string, std::size_t>::const_iterator i = mFiles.begin(); i != mFiles.end(); ++i) {
-        totalfilesize += i->second;
+        mTotalFiles = mFiles.size() + mFileSettings.size();
+        mTotalFileSize = std::accumulate(mFiles.cbegin(), mFiles.cend(), std::size_t(0), [](std::size_t v, const FileWithDetails& p) {
+            return v + p.size();
+        });
     }
 
-    std::list<int> rpipes;
-    std::map<pid_t, std::string> childFile;
-    std::map<int, std::string> pipeFile;
-    std::size_t processedsize = 0;
-    std::map<std::string, std::size_t>::const_iterator iFile = mFiles.begin();
-    std::list<ImportProject::FileSettings>::const_iterator iFileSettings = mSettings.project.fileSettings.begin();
-    for (;;) {
-        // Start a new child
-        size_t nchildren = rpipes.size();
-        if ((iFile != mFiles.end() || iFileSettings != mSettings.project.fileSettings.end()) && nchildren < mSettings.jobs && checkLoadAverage(nchildren)) {
-            int pipes[2];
-            if (pipe(pipes) == -1) {
-                std::cerr << "#### ThreadExecutor::check, pipe() failed: "<< std::strerror(errno) << std::endl;
-                std::exit(EXIT_FAILURE);
-            }
-
-            int flags = 0;
-            if ((flags = fcntl(pipes[0], F_GETFL, 0)) < 0) {
-                std::cerr << "#### ThreadExecutor::check, fcntl(F_GETFL) failed: "<< std::strerror(errno) << std::endl;
-                std::exit(EXIT_FAILURE);
-            }
-
-            if (fcntl(pipes[0], F_SETFL, flags | O_NONBLOCK) < 0) {
-                std::cerr << "#### ThreadExecutor::check, fcntl(F_SETFL) failed: "<< std::strerror(errno) << std::endl;
-                std::exit(EXIT_FAILURE);
-            }
+    bool next(const FileWithDetails *&file, const FileSettings *&fs, std::size_t &fileSize) {
+        std::lock_guard<std::mutex> l(mFileSync);
+        if (mItNextFile != mFiles.end()) {
+            file = &(*mItNextFile);
+            fs = nullptr;
+            fileSize = mItNextFile->size();
+            ++mItNextFile;
+            return true;
+        }
+        if (mItNextFileSettings != mFileSettings.end()) {
+            file = nullptr;
+            fs = &(*mItNextFileSettings);
+            fileSize = 0;
+            ++mItNextFileSettings;
+            return true;
+        }
 
-            pid_t pid = fork();
-            if (pid < 0) {
-                // Error
-                std::cerr << "#### ThreadExecutor::check, Failed to create child process: "<< std::strerror(errno) << std::endl;
-                std::exit(EXIT_FAILURE);
-            } else if (pid == 0) {
-                close(pipes[0]);
-                mWpipe = pipes[1];
-
-                CppCheck fileChecker(*this, false);
-                fileChecker.settings() = mSettings;
-                unsigned int resultOfCheck = 0;
-
-                if (iFileSettings != mSettings.project.fileSettings.end()) {
-                    resultOfCheck = fileChecker.check(*iFileSettings);
-                } else if (!mFileContents.empty() && mFileContents.find(iFile->first) != mFileContents.end()) {
-                    // File content was given as a string
-                    resultOfCheck = fileChecker.check(iFile->first, mFileContents[ iFile->first ]);
-                } else {
-                    // Read file from a file
-                    resultOfCheck = fileChecker.check(iFile->first);
-                }
+        return false;
+    }
 
-                std::ostringstream oss;
-                oss << resultOfCheck;
-                writeToPipe(CHILD_END, oss.str());
-                std::exit(0);
-            }
+    unsigned int check(const FileWithDetails *file, const FileSettings *fs) {
+        CppCheck fileChecker(mSettings, mSuppressions, mLogForwarder, mTimerResults, false, mExecuteCommand);
 
-            close(pipes[1]);
-            rpipes.push_back(pipes[0]);
-            if (iFileSettings != mSettings.project.fileSettings.end()) {
-                childFile[pid] = iFileSettings->filename + ' ' + iFileSettings->cfg;
-                pipeFile[pipes[0]] = iFileSettings->filename + ' ' + iFileSettings->cfg;
-                ++iFileSettings;
-            } else {
-                childFile[pid] = iFile->first;
-                pipeFile[pipes[0]] = iFile->first;
-                ++iFile;
-            }
-        } else if (!rpipes.empty()) {
-            fd_set rfds;
-            FD_ZERO(&rfds);
-            for (std::list<int>::const_iterator rp = rpipes.begin(); rp != rpipes.end(); ++rp)
-                FD_SET(*rp, &rfds);
-            struct timeval tv; // for every second polling of load average condition
-            tv.tv_sec = 1;
-            tv.tv_usec = 0;
-            int r = select(*std::max_element(rpipes.begin(), rpipes.end()) + 1, &rfds, nullptr, nullptr, &tv);
-
-            if (r > 0) {
-                std::list<int>::iterator rp = rpipes.begin();
-                while (rp != rpipes.end()) {
-                    if (FD_ISSET(*rp, &rfds)) {
-                        int readRes = handleRead(*rp, result);
-                        if (readRes == -1) {
-                            std::size_t size = 0;
-                            std::map<int, std::string>::iterator p = pipeFile.find(*rp);
-                            if (p != pipeFile.end()) {
-                                std::string name = p->second;
-                                pipeFile.erase(p);
-                                std::map<std::string, std::size_t>::const_iterator fs = mFiles.find(name);
-                                if (fs != mFiles.end()) {
-                                    size = fs->second;
-                                }
-                            }
-
-                            mFileCount++;
-                            processedsize += size;
-                            if (!mSettings.quiet)
-                                CppCheckExecutor::reportStatus(mFileCount, mFiles.size() + mSettings.project.fileSettings.size(), processedsize, totalfilesize);
-
-                            close(*rp);
-                            rp = rpipes.erase(rp);
-                        } else
-                            ++rp;
-                    } else
-                        ++rp;
+        unsigned int result;
+        if (fs) {
+            // file settings..
+            result = fileChecker.check(*fs);
+        } else {
+            // Read file from a file
+            result = fileChecker.check(*file);
+        }
+        for (const auto& suppr : mSuppressions.nomsg.getSuppressions()) {
+            // need to transfer all inline suppressions because these are used later on
+            if (suppr.isInline) {
+                const std::string err = mSuppressions.nomsg.addSuppression(suppr);
+                if (!err.empty()) {
+                    // TODO: only update state if it doesn't exist - otherwise propagate error
+                    mSuppressions.nomsg.updateSuppressionState(suppr); // TODO: check result
                 }
+                continue;
             }
 
-            int stat = 0;
-            pid_t child = waitpid(0, &stat, WNOHANG);
-            if (child > 0) {
-                std::string childname;
-                std::map<pid_t, std::string>::iterator c = childFile.find(child);
-                if (c != childFile.end()) {
-                    childname = c->second;
-                    childFile.erase(c);
-                }
-
-                if (WIFSIGNALED(stat)) {
-                    std::ostringstream oss;
-                    oss << "Internal error: Child process crashed with signal " << WTERMSIG(stat);
-
-                    std::list<ErrorLogger::ErrorMessage::FileLocation> locations;
-                    locations.emplace_back(childname, 0, 0);
-                    const ErrorLogger::ErrorMessage errmsg(locations,
-                                                           emptyString,
-                                                           Severity::error,
-                                                           oss.str(),
-                                                           "cppcheckError",
-                                                           false);
-
-                    if (!mSettings.nomsg.isSuppressed(errmsg.toSuppressionsErrorMessage()))
-                        mErrorLogger.reportErr(errmsg);
-                }
+            // propagate state of global suppressions
+            if (!suppr.isLocal()) {
+                mSuppressions.nomsg.updateSuppressionState(suppr); // TODO: check result
+                continue;
             }
-        } else {
-            // All done
-            break;
         }
+        return result;
     }
 
-
-    return result;
-}
-
-void ThreadExecutor::writeToPipe(PipeSignal type, const std::string &data)
-{
-    unsigned int len = static_cast<unsigned int>(data.length() + 1);
-    char *out = new char[ len + 1 + sizeof(len)];
-    out[0] = static_cast<char>(type);
-    std::memcpy(&(out[1]), &len, sizeof(len));
-    std::memcpy(&(out[1+sizeof(len)]), data.c_str(), len);
-    if (write(mWpipe, out, len + 1 + sizeof(len)) <= 0) {
-        delete [] out;
-        out = nullptr;
-        std::cerr << "#### ThreadExecutor::writeToPipe, Failed to write to pipe" << std::endl;
-        std::exit(0);
+    void status(std::size_t fileSize) {
+        std::lock_guard<std::mutex> l(mFileSync);
+        mProcessedSize += fileSize;
+        mProcessedFiles++;
+        if (!mSettings.quiet)
+            mLogForwarder.reportStatus(mProcessedFiles, mTotalFiles, mProcessedSize, mTotalFileSize);
     }
 
-    delete [] out;
-}
+private:
+    const std::list<FileWithDetails> &mFiles;
+    std::list<FileWithDetails>::const_iterator mItNextFile;
+    const std::list<FileSettings> &mFileSettings;
+    std::list<FileSettings>::const_iterator mItNextFileSettings;
 
-void ThreadExecutor::reportOut(const std::string &outmsg)
-{
-    writeToPipe(REPORT_OUT, outmsg);
-}
+    std::size_t mProcessedFiles{};
+    std::size_t mTotalFiles{};
+    std::size_t mProcessedSize{};
+    std::size_t mTotalFileSize{};
 
-void ThreadExecutor::reportErr(const ErrorLogger::ErrorMessage &msg)
-{
-    writeToPipe(REPORT_ERROR, msg.serialize());
-}
+    std::mutex mFileSync;
+    TimerResults *mTimerResults;
+    const Settings &mSettings;
+    Suppressions &mSuppressions;
+    CppCheck::ExecuteCmdFn mExecuteCommand;
 
-void ThreadExecutor::reportInfo(const ErrorLogger::ErrorMessage &msg)
-{
-    writeToPipe(REPORT_INFO, msg.serialize());
-}
-
-#elif defined(THREADING_MODEL_WIN)
-
-void ThreadExecutor::addFileContent(const std::string &path, const std::string &content)
-{
-    mFileContents[path] = content;
-}
+    SyncLogForwarder mLogForwarder;
+};
 
-unsigned int ThreadExecutor::check()
+static unsigned int STDCALL threadProc(ThreadData *data)
 {
-    HANDLE *threadHandles = new HANDLE[mSettings.jobs];
-
-    mItNextFile = mFiles.begin();
-    mItNextFileSettings = mSettings.project.fileSettings.begin();
-
-    mProcessedFiles = 0;
-    mProcessedSize = 0;
-    mTotalFiles = mFiles.size() + mSettings.project.fileSettings.size();
-    mTotalFileSize = 0;
-    for (std::map<std::string, std::size_t>::const_iterator i = mFiles.begin(); i != mFiles.end(); ++i) {
-        mTotalFileSize += i->second;
-    }
-
-    InitializeCriticalSection(&mFileSync);
-    InitializeCriticalSection(&mErrorSync);
-    InitializeCriticalSection(&mReportSync);
-
-    for (unsigned int i = 0; i < mSettings.jobs; ++i) {
-        threadHandles[i] = (HANDLE)_beginthreadex(nullptr, 0, threadProc, this, 0, nullptr);
-        if (!threadHandles[i]) {
-            std::cerr << "#### ThreadExecutor::check error, errno :" << errno << std::endl;
-            exit(EXIT_FAILURE);
-        }
-    }
-
-    const DWORD waitResult = WaitForMultipleObjects(mSettings.jobs, threadHandles, TRUE, INFINITE);
-    if (waitResult != WAIT_OBJECT_0) {
-        if (waitResult == WAIT_FAILED) {
-            std::cerr << "#### ThreadExecutor::check wait failed, result: " << waitResult << " error: " << GetLastError() << std::endl;
-            exit(EXIT_FAILURE);
-        } else {
-            std::cerr << "#### ThreadExecutor::check wait failed, result: " << waitResult << std::endl;
-            exit(EXIT_FAILURE);
-        }
-    }
-
     unsigned int result = 0;
-    for (unsigned int i = 0; i < mSettings.jobs; ++i) {
-        DWORD exitCode;
 
-        if (!GetExitCodeThread(threadHandles[i], &exitCode)) {
-            std::cerr << "#### ThreadExecutor::check get exit code failed, error:" << GetLastError() << std::endl;
-            exit(EXIT_FAILURE);
-        }
+    const FileWithDetails *file;
+    const FileSettings *fs;
+    std::size_t fileSize;
 
-        result += exitCode;
+    while (data->next(file, fs, fileSize)) {
+        result += data->check(file, fs);
 
-        if (!CloseHandle(threadHandles[i])) {
-            std::cerr << "#### ThreadExecutor::check close handle failed, error:" << GetLastError() << std::endl;
-            exit(EXIT_FAILURE);
-        }
+        data->status(fileSize);
     }
 
-    DeleteCriticalSection(&mFileSync);
-    DeleteCriticalSection(&mErrorSync);
-    DeleteCriticalSection(&mReportSync);
-
-    delete[] threadHandles;
-
     return result;
 }
 
-unsigned int __stdcall ThreadExecutor::threadProc(void *args)
+unsigned int ThreadExecutor::check()
 {
-    unsigned int result = 0;
+    std::vector<std::future<unsigned int>> threadFutures;
+    threadFutures.reserve(mSettings.jobs);
 
-    ThreadExecutor *threadExecutor = static_cast<ThreadExecutor*>(args);
-    std::map<std::string, std::size_t>::const_iterator &itFile = threadExecutor->mItNextFile;
-    std::list<ImportProject::FileSettings>::const_iterator &itFileSettings = threadExecutor->mItNextFileSettings;
+    ThreadData data(*this, mErrorLogger, mTimerResults, mSettings, mSuppressions, mFiles, mFileSettings, mExecuteCommand);
 
-    // guard static members of CppCheck against concurrent access
-    EnterCriticalSection(&threadExecutor->mFileSync);
-
-    CppCheck fileChecker(*threadExecutor, false);
-    fileChecker.settings() = threadExecutor->mSettings;
-
-    for (;;) {
-        if (itFile == threadExecutor->mFiles.end() && itFileSettings == threadExecutor->mSettings.project.fileSettings.end()) {
-            LeaveCriticalSection(&threadExecutor->mFileSync);
-            break;
-        }
-
-        std::size_t fileSize = 0;
-        if (itFile != threadExecutor->mFiles.end()) {
-            const std::string &file = itFile->first;
-            fileSize = itFile->second;
-            ++itFile;
-
-            LeaveCriticalSection(&threadExecutor->mFileSync);
-
-            const std::map<std::string, std::string>::const_iterator fileContent = threadExecutor->mFileContents.find(file);
-            if (fileContent != threadExecutor->mFileContents.end()) {
-                // File content was given as a string
-                result += fileChecker.check(file, fileContent->second);
-            } else {
-                // Read file from a file
-                result += fileChecker.check(file);
-            }
-        } else { // file settings..
-            const ImportProject::FileSettings &fs = *itFileSettings;
-            ++itFileSettings;
-            LeaveCriticalSection(&threadExecutor->mFileSync);
-            result += fileChecker.check(fs);
-        }
-
-        EnterCriticalSection(&threadExecutor->mFileSync);
-
-        threadExecutor->mProcessedSize += fileSize;
-        threadExecutor->mProcessedFiles++;
-        if (!threadExecutor->mSettings.quiet) {
-            EnterCriticalSection(&threadExecutor->mReportSync);
-            CppCheckExecutor::reportStatus(threadExecutor->mProcessedFiles, threadExecutor->mTotalFiles, threadExecutor->mProcessedSize, threadExecutor->mTotalFileSize);
-            LeaveCriticalSection(&threadExecutor->mReportSync);
+    for (unsigned int i = 0; i < mSettings.jobs; ++i) {
+        try {
+            threadFutures.emplace_back(std::async(std::launch::async, &threadProc, &data));
         }
-    }
-    return result;
-}
-
-void ThreadExecutor::reportOut(const std::string &outmsg)
-{
-    EnterCriticalSection(&mReportSync);
-
-    mErrorLogger.reportOut(outmsg);
-
-    LeaveCriticalSection(&mReportSync);
-}
-void ThreadExecutor::reportErr(const ErrorLogger::ErrorMessage &msg)
-{
-    report(msg, MessageType::REPORT_ERROR);
-}
-
-void ThreadExecutor::reportInfo(const ErrorLogger::ErrorMessage &msg)
-{
-    report(msg, MessageType::REPORT_INFO);
-}
-
-void ThreadExecutor::report(const ErrorLogger::ErrorMessage &msg, MessageType msgType)
-{
-    if (mSettings.nomsg.isSuppressed(msg.toSuppressionsErrorMessage()))
-        return;
-
-    // Alert only about unique errors
-    bool reportError = false;
-    const std::string errmsg = msg.toString(mSettings.verbose);
-
-    EnterCriticalSection(&mErrorSync);
-    if (std::find(mErrorList.begin(), mErrorList.end(), errmsg) == mErrorList.end()) {
-        mErrorList.push_back(errmsg);
-        reportError = true;
-    }
-    LeaveCriticalSection(&mErrorSync);
-
-    if (reportError) {
-        EnterCriticalSection(&mReportSync);
-
-        switch (msgType) {
-        case MessageType::REPORT_ERROR:
-            mErrorLogger.reportErr(msg);
-            break;
-        case MessageType::REPORT_INFO:
-            mErrorLogger.reportInfo(msg);
-            break;
+        catch (const std::system_error &e) {
+            std::cerr << "#### ThreadExecutor::check exception :" << e.what() << std::endl;
+            exit(EXIT_FAILURE);
         }
-
-        LeaveCriticalSection(&mReportSync);
     }
-}
 
-#else
+    unsigned int result = std::accumulate(threadFutures.begin(), threadFutures.end(), 0U, [](unsigned int v, std::future<unsigned int>& f) {
+        return v + f.get();
+    });
 
-void ThreadExecutor::addFileContent(const std::string &/*path*/, const std::string &/*content*/)
-{
-
-}
-
-unsigned int ThreadExecutor::check()
-{
-    return 0;
-}
-
-void ThreadExecutor::reportOut(const std::string &/*outmsg*/)
-{
-
-}
-void ThreadExecutor::reportErr(const ErrorLogger::ErrorMessage &/*msg*/)
-{
-
-}
-
-void ThreadExecutor::reportInfo(const ErrorLogger::ErrorMessage &/*msg*/)
-{
+    if (mTimerResults && (mSettings.showtime == ShowTime::SUMMARY || mSettings.showtime == ShowTime::TOP5_SUMMARY))
+        mTimerResults->showResults(mSettings.showtime);
 
+    return result;
 }
 
-#endif
+#endif // HAS_THREADING_MODEL_THREAD
diff --git a/cli/threadexecutor.h b/cli/threadexecutor.h
index f8f4b8b0dde..a0ab4933573 100644
--- a/cli/threadexecutor.h
+++ b/cli/threadexecutor.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,22 +19,21 @@
 #ifndef THREADEXECUTOR_H
 #define THREADEXECUTOR_H
 
-#include "errorlogger.h"
-#include "importproject.h"
+#include "config.h"
 
-#include <cstddef>
-#include <list>
-#include <map>
-#include <string>
+#ifdef HAS_THREADING_MODEL_THREAD
+
+#include "cppcheck.h"
+#include "executor.h"
 
-#if (defined(__GNUC__) || defined(__sun)) && !defined(__MINGW32__) && !defined(__CYGWIN__)
-#define THREADING_MODEL_FORK
-#elif defined(_WIN32)
-#define THREADING_MODEL_WIN
-#include <windows.h>
-#endif
+#include <list>
 
 class Settings;
+class ErrorLogger;
+struct Suppressions;
+struct FileSettings;
+class FileWithDetails;
+class TimerResults;
 
 /// @addtogroup CLI
 /// @{
@@ -43,111 +42,21 @@ class Settings;
  * This class will take a list of filenames and settings and check then
  * all files using threads.
  */
-class ThreadExecutor : public ErrorLogger {
-public:
-    ThreadExecutor(const std::map<std::string, std::size_t> &files, Settings &settings, ErrorLogger &errorLogger);
-    ThreadExecutor(const ThreadExecutor &) = delete;
-    ~ThreadExecutor() OVERRIDE;
-    void operator=(const ThreadExecutor &) = delete;
-    unsigned int check();
-
-    void reportOut(const std::string &outmsg) OVERRIDE;
-    void reportErr(const ErrorLogger::ErrorMessage &msg) OVERRIDE;
-    void reportInfo(const ErrorLogger::ErrorMessage &msg) OVERRIDE;
-
-    /**
-     * @brief Add content to a file, to be used in unit testing.
-     *
-     * @param path File name (used as a key to link with real file).
-     * @param content If the file would be a real file, this should be
-     * the content of the file.
-     */
-    void addFileContent(const std::string &path, const std::string &content);
-
-private:
-    const std::map<std::string, std::size_t> &mFiles;
-    Settings &mSettings;
-    ErrorLogger &mErrorLogger;
-    unsigned int mFileCount;
-
-#if defined(THREADING_MODEL_FORK)
-
-    /** @brief Key is file name, and value is the content of the file */
-    std::map<std::string, std::string> mFileContents;
-private:
-    enum PipeSignal {REPORT_OUT='1',REPORT_ERROR='2', REPORT_INFO='3', CHILD_END='4'};
-
-    /**
-     * Read from the pipe, parse and handle what ever is in there.
-     *@return -1 in case of error
-     *         0 if there is nothing in the pipe to be read
-     *         1 if we did read something
-     */
-    int handleRead(int rpipe, unsigned int &result);
-    void writeToPipe(PipeSignal type, const std::string &data);
-    /**
-     * Write end of status pipe, different for each child.
-     * Not used in master process.
-     */
-    std::list<std::string> mErrorList;
-    int mWpipe;
-
-    /**
-     * @brief Check load average condition
-     * @param nchildren - count of currently ran children
-     * @return true - if new process can be started
-     */
-    bool checkLoadAverage(size_t nchildren);
+class ThreadExecutor : public Executor {
+    friend class SyncLogForwarder;
 
 public:
-    /**
-     * @return true if support for threads exist.
-     */
-    static bool isEnabled() {
-        return true;
-    }
-
-#elif defined(THREADING_MODEL_WIN)
-
-private:
-    enum class MessageType {REPORT_ERROR, REPORT_INFO};
-
-    std::map<std::string, std::string> mFileContents;
-    std::map<std::string, std::size_t>::const_iterator mItNextFile;
-    std::list<ImportProject::FileSettings>::const_iterator mItNextFileSettings;
-    std::size_t mProcessedFiles;
-    std::size_t mTotalFiles;
-    std::size_t mProcessedSize;
-    std::size_t mTotalFileSize;
-    CRITICAL_SECTION mFileSync;
-
-    std::list<std::string> mErrorList;
-    CRITICAL_SECTION mErrorSync;
-
-    CRITICAL_SECTION mReportSync;
-
-    void report(const ErrorLogger::ErrorMessage &msg, MessageType msgType);
+    ThreadExecutor(const std::list<FileWithDetails> &files, const std::list<FileSettings>& fileSettings, const Settings &settings, Suppressions &suppressions, ErrorLogger &errorLogger, TimerResults* timerResults, CppCheck::ExecuteCmdFn executeCommand);
+    ThreadExecutor(const ThreadExecutor &) = delete;
+    ThreadExecutor& operator=(const ThreadExecutor &) = delete;
 
-    static unsigned __stdcall threadProc(void*);
+    unsigned int check() override;
 
-public:
-    /**
-     * @return true if support for threads exist.
-     */
-    static bool isEnabled() {
-        return true;
-    }
-#else
-public:
-    /**
-     * @return true if support for threads exist.
-     */
-    static bool isEnabled() {
-        return false;
-    }
-#endif
+    CppCheck::ExecuteCmdFn mExecuteCommand;
 };
 
 /// @}
 
+#endif // HAS_THREADING_MODEL_THREAD
+
 #endif // THREADEXECUTOR_H
diff --git a/cli/version.rc b/cli/version.rc
index 5b61c69c192..dd5dc3feeb6 100644
--- a/cli/version.rc
+++ b/cli/version.rc
@@ -1,34 +1,34 @@
-#include "../lib/version.h"
-#include "winresrc.h"
-
-VS_VERSION_INFO VERSIONINFO
- FILEVERSION CPPCHECK_VERSION
- PRODUCTVERSION CPPCHECK_VERSION
- FILEFLAGSMASK 0x17L
-#ifdef _DEBUG
- FILEFLAGS (0x1L|VS_FF_PRERELEASE)
-#else
- FILEFLAGS (0x0L|VS_FF_PRERELEASE)
-#endif
- FILEOS VOS__WINDOWS32
- FILETYPE VFT_APP
- FILESUBTYPE VFT2_UNKNOWN
-BEGIN
-    BLOCK "StringFileInfo"
-    BEGIN
-        BLOCK "040904b0"
-        BEGIN
-            VALUE "FileDescription", "cppcheck Application"
-            VALUE "FileVersion", CPPCHECK_VERSION_STRING
-            VALUE "InternalName", "cppcheck"
-            VALUE "LegalCopyright", LEGALCOPYRIGHT
-            VALUE "OriginalFilename", "cppcheck.exe"
-            VALUE "ProductName", "cppcheck Application"
-            VALUE "ProductVersion", CPPCHECK_VERSION_STRING
-        END
-    END
-    BLOCK "VarFileInfo"
-    BEGIN
-        VALUE "Translation", 0x409, 1200
-    END
-END
+#include "../lib/version.h"
+#include "winresrc.h"
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION CPPCHECK_VERSION
+ PRODUCTVERSION CPPCHECK_VERSION
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS (0x1L|VS_FF_PRERELEASE)
+#else
+ FILEFLAGS (0x0L|VS_FF_PRERELEASE)
+#endif
+ FILEOS VOS__WINDOWS32
+ FILETYPE VFT_APP
+ FILESUBTYPE VFT2_UNKNOWN
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "FileDescription", "cppcheck Application"
+            VALUE "FileVersion", CPPCHECK_VERSION_STRING
+            VALUE "InternalName", "cppcheck"
+            VALUE "LegalCopyright", LEGALCOPYRIGHT
+            VALUE "OriginalFilename", "cppcheck.exe"
+            VALUE "ProductName", "cppcheck Application"
+            VALUE "ProductVersion", CPPCHECK_VERSION_STRING
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
diff --git a/cmake/clang_tidy.cmake b/cmake/clang_tidy.cmake
new file mode 100644
index 00000000000..f8324b98d21
--- /dev/null
+++ b/cmake/clang_tidy.cmake
@@ -0,0 +1,69 @@
+# TODO: bail out when Python_EXECUTABLE is not set
+
+if(NOT CMAKE_DISABLE_PRECOMPILE_HEADERS)
+    # clang-tidy and clang need to have the same version when precompiled headers are being used
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        string(REGEX MATCHALL "[0-9]+" _clang_ver_parts "${CMAKE_CXX_COMPILER_VERSION}")
+        LIST(GET _clang_ver_parts 0 _clang_major)
+        set(RUN_CLANG_TIDY_NAMES "run-clang-tidy-${_clang_major}")
+        message(STATUS "Clang and clang-tidy version need to match when precompiled headers are enabled - limiting search to '${RUN_CLANG_TIDY_NAMES}'")
+    else()
+        message(STATUS "Cannot use non-Clang compiler with clang-tidy when precompiled headers are enabled - skipping 'run-clang-tidy'/'run-clang-tidy-csa' target generation")
+    endif()
+else()
+    set(RUN_CLANG_TIDY_NAMES run-clang-tidy run-clang-tidy-22 run-clang-tidy-21 run-clang-tidy-20 run-clang-tidy-19 run-clang-tidy-18 run-clang-tidy-17 run-clang-tidy-16 run-clang-tidy-15 run-clang-tidy-14 run-clang-tidy-13 run-clang-tidy-12 run-clang-tidy-11 run-clang-tidy-10 run-clang-tidy-9 run-clang-tidy-8)
+endif()
+
+if(RUN_CLANG_TIDY_NAMES)
+    find_program(RUN_CLANG_TIDY NAMES ${RUN_CLANG_TIDY_NAMES})
+    message(STATUS "RUN_CLANG_TIDY=${RUN_CLANG_TIDY}")
+    if(RUN_CLANG_TIDY)
+        include(ProcessorCount)
+        ProcessorCount(NPROC)
+        if(NPROC EQUAL 0)
+            message(FATAL_ERROR "could not get processor count")
+        endif()
+        message(STATUS "NPROC=${NPROC}")
+
+        if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 22)
+            set(CLANG_TIDY_CONFIG "-enable-check-profile")
+        else()
+            set(CLANG_TIDY_CONFIG "")
+        endif()
+
+        # most of these are disabled because they are too noisy in our code
+        # clang-analyzer-core.CallAndMessage
+        # clang-analyzer-core.NonNullParamChecker
+        # clang-analyzer-cplusplus.NewDeleteLeaks
+        # clang-analyzer-cplusplus.NewDelete
+        # clang-analyzer-core.NullDereference
+        # clang-analyzer-unix.Stream
+        # clang-analyzer-alpha.clone.CloneChecker
+        # clang-analyzer-alpha.webkit.* - we are not interested in these
+        set(CLANG_TIDY_CSA_CONFIG "-config={InheritParentConfig: true, Checks: '-*,clang-analyzer-*,-clang-analyzer-core.CallAndMessage,-clang-analyzer-core.NonNullParamChecker,-clang-analyzer-cplusplus.NewDeleteLeaks,-clang-analyzer-cplusplus.NewDelete,-clang-analyzer-core.NullDereference,-clang-analyzer-unix.Stream,-clang-analyzer-alpha.clone.CloneChecker,-clang-analyzer-alpha.webkit.*'}")
+        if (ENABLE_CSA_ALPHA)
+            set(CLANG_TIDY_CSA_ALPHA_OPTS "-allow-enabling-alpha-checkers" "-extra-arg=-Xclang" "-extra-arg=-analyzer-config" "-extra-arg=-Xclang" "-extra-arg=aggressive-binary-operation-simplification=true")
+        else()
+            set(CLANG_TIDY_CSA_ALPHA_OPTS "")
+        endif()
+
+        # TODO: exclude moc_*.cpp
+        # TODO: exclude mocs_compilation.cpp
+        add_custom_target(run-clang-tidy
+                ${Python_EXECUTABLE} ${RUN_CLANG_TIDY} -p=${CMAKE_BINARY_DIR} -j ${NPROC} -quiet ${CLANG_TIDY_CONFIG}
+                USES_TERMINAL
+                VERBATIM)
+        add_custom_target(run-clang-tidy-csa
+                ${Python_EXECUTABLE} ${RUN_CLANG_TIDY} -p=${CMAKE_BINARY_DIR} -j ${NPROC} -quiet ${CLANG_TIDY_CONFIG} ${CLANG_TIDY_CSA_ALPHA_OPTS} ${CLANG_TIDY_CSA_CONFIG}
+                USES_TERMINAL
+                VERBATIM)
+        if(BUILD_GUI)
+            add_dependencies(run-clang-tidy gui-build-deps)
+            add_dependencies(run-clang-tidy-csa gui-build-deps)
+            if(BUILD_TRIAGE)
+                add_dependencies(run-clang-tidy triage-build-ui-deps)
+                add_dependencies(run-clang-tidy-csa triage-build-ui-deps)
+            endif()
+        endif()
+    endif()
+endif()
diff --git a/cmake/compilerCheck.cmake b/cmake/compilerCheck.cmake
new file mode 100644
index 00000000000..c26bf9e336e
--- /dev/null
+++ b/cmake/compilerCheck.cmake
@@ -0,0 +1,19 @@
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.1)
+        message(ERROR "GCC >= 5.1 required - detected ${CMAKE_CXX_COMPILER_VERSION} not supported")
+    endif()
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.5)
+        message(ERROR "Clang >= 3.5 required - detected ${CMAKE_CXX_COMPILER_VERSION} not supported")
+    endif()
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.0)
+        message(ERROR "AppleClang >= 6.0 required - detected ${CMAKE_CXX_COMPILER_VERSION} not supported")
+    endif()
+elseif(MSVC)
+    if(MSVC_VERSION VERSION_LESS 1900)
+        message(ERROR "Visual Studio >= 2015 (19.0) required - detected ${MSVC_VERSION} not supported")
+    endif()
+else()
+    message(WARNING "Unknown compiler ${CMAKE_CXX_COMPILER_ID}")
+endif()
diff --git a/cmake/compilerDefinitions.cmake b/cmake/compilerDefinitions.cmake
index 80f336b83f8..5f03b83dcee 100644
--- a/cmake/compilerDefinitions.cmake
+++ b/cmake/compilerDefinitions.cmake
@@ -1,9 +1,80 @@
-if (UNIX)
-    if (${CMAKE_BUILD_TYPE} STREQUAL "Debug")
+if(MSVC)
+    # add_compile_definitions() requires CMake 3.12
+
+    # Visual Studio only sets _DEBUG
+    add_compile_definitions($<$<CONFIG:Debug>:DEBUG>)
+
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+    add_definitions(-DWIN32_LEAN_MEAN)
+endif()
+
+# libstdc++-specific flags
+if(CMAKE_CXX_COMPILER_ID MATCHES "GNU" OR (NOT USE_LIBCXX AND CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
+    if(CPPCHK_GLIBCXX_DEBUG AND CMAKE_BUILD_TYPE STREQUAL "Debug")
         add_definitions(-D_GLIBCXX_DEBUG)
     endif()
-    if (HAVE_RULES)
-        add_definitions(-DHAVE_RULES -DTIXML_USE_STL)
+endif()
+
+# TODO: what about clang-cl?
+# libc++-specific flags - AppleClang only has libc++
+if ((USE_LIBCXX AND CMAKE_CXX_COMPILER_ID MATCHES "Clang") OR CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+    if(CPPCHK_GLIBCXX_DEBUG AND CMAKE_BUILD_TYPE STREQUAL "Debug")
+        # TODO: determine proper version for AppleClang - current value is based on the oldest version avaialble in CI
+        if((CMAKE_CXX_COMPILER_ID STREQUALS "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 18) OR
+           (CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 17))
+            add_definitions(-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_DEBUG)
+        else()
+            add_definitions(-D_LIBCPP_ENABLE_ASSERTIONS=1)
+        endif()
+        # TODO: also add _LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS?
+    else()
+        # TODO: check if this can be enabled again for Clang - also done in Makefile
+        add_definitions(-D_GLIBCXX_DEBUG)
     endif()
-    add_definitions(-DFILESDIR="${FILESDIR}")
+
+    add_definitions(-D_LIBCPP_REMOVE_TRANSITIVE_INCLUDES)
+endif()
+
+if(HAVE_RULES)
+    add_definitions(-DHAVE_RULES)
+endif()
+
+if(Boost_FOUND)
+    add_definitions(-DHAVE_BOOST)
+    if(USE_BOOST_INT128)
+        add_definitions(-DHAVE_BOOST_INT128)
+    endif()
+endif()
+
+if(ENABLE_CHECK_INTERNAL)
+    add_definitions(-DCHECK_INTERNAL)
+endif()
+
+if(DISALLOW_THREAD_EXECUTOR)
+    add_definitions(-DDISALLOW_THREAD_EXECUTOR)
+endif()
+
+if(DISALLOW_PROCESS_EXECUTOR)
+    add_definitions(-DDISALLOW_PROCESS_EXECUTOR)
+endif()
+
+if(NO_UNIX_SIGNAL_HANDLING)
+    add_definitions(-DNO_UNIX_SIGNAL_HANDLING)
+endif()
+
+if(NO_UNIX_BACKTRACE_SUPPORT)
+    add_definitions(-DNO_UNIX_BACKTRACE_SUPPORT)
+endif()
+
+if(NO_WINDOWS_SEH)
+    add_definitions(-DNO_WINDOWS_SEH)
+endif()
+
+if(NOT MSVC)
+    add_definitions(-DHAVE_EXECINFO_H=${HAVE_EXECINFO_H})
+endif()
+
+if(FILESDIR_DEF)
+    file(TO_CMAKE_PATH "${FILESDIR_DEF}" _filesdir)
+    add_definitions(-DFILESDIR="${_filesdir}")
 endif()
diff --git a/cmake/compileroptions.cmake b/cmake/compileroptions.cmake
index 17c8c287f00..aa7deb8552c 100644
--- a/cmake/compileroptions.cmake
+++ b/cmake/compileroptions.cmake
@@ -1,143 +1,277 @@
-set(EXTRA_C_FLAGS "")
-set(EXTRA_C_FLAGS_RELEASE "-DNDEBUG")
-set(EXTRA_C_FLAGS_DEBUG "-DDEBUG")
-
-if (USE_CLANG)
-    set (CMAKE_C_COMPILER_ID            "Clang")
-    set (CMAKE_CXX_COMPILER_ID          "Clang")
-    set (CMAKE_C_COMPILER               "/usr/bin/clang")
-    set (CMAKE_CXX_COMPILER             "/usr/bin/clang++")
-
-    set (CMAKE_C_FLAGS                  "-std=c99")
-    set (CMAKE_C_FLAGS_DEBUG            "-g")
-    set (CMAKE_C_FLAGS_RELEASE          "-O2")
-
-    set (CMAKE_CXX_FLAGS                "")
-    set (CMAKE_CXX_FLAGS_DEBUG          "-g")
-    set (CMAKE_CXX_FLAGS_RELEASE        "-O2")
-endif()
+include(CheckCXXCompilerFlag)
+
+function(add_compile_options_safe FLAG)
+    string(MAKE_C_IDENTIFIER "HAS_CXX_FLAG${FLAG}" mangled_flag)
+    check_cxx_compiler_flag(${FLAG} ${mangled_flag})
+    if(${mangled_flag})
+        add_compile_options(${FLAG})
+    endif()
+endfunction()
 
-if (USE_ANALYZE)
-    set (CMAKE_C_COMPILER_ID            "ccc-analyzer")
-    set (CMAKE_CXX_COMPILER_ID          "c++-analyzer")
-    set (CMAKE_C_COMPILER               "/usr/share/clang/scan-build/ccc-analyzer")
-    set (CMAKE_CXX_COMPILER             "/usr/share/clang/scan-build/c++-analyzer")
+function(target_compile_options_safe TARGET FLAG)
+    string(MAKE_C_IDENTIFIER "HAS_CXX_FLAG${FLAG}" mangled_flag)
+    check_cxx_compiler_flag(${FLAG} ${mangled_flag})
+    if(${mangled_flag})
+        target_compile_options(${TARGET} PRIVATE ${FLAG})
+    endif()
+endfunction()
 
-    set (CMAKE_C_FLAGS                  "-Wall -std=c99")
-    set (CMAKE_C_FLAGS_DEBUG            "-g")
-    set (CMAKE_C_FLAGS_RELEASE          "-O2")
+function(target_externals_include_directories TARGET)
+    if(EXTERNALS_AS_SYSTEM)
+        target_include_directories(${TARGET} SYSTEM ${ARGN})
+    else()
+        target_include_directories(${TARGET} ${ARGN})
+    endif()
+endfunction()
 
-    set (CMAKE_CXX_FLAGS                "-Wall")
-    set (CMAKE_CXX_FLAGS_DEBUG          "-g")
-    set (CMAKE_CXX_FLAGS_RELEASE        "-O2")
+function(target_dll_compile_definitions TARGET)
+    set(options)
+    set(oneValueArgs IMPORT EXPORT)
+    set(multiValueArgs)
+
+    cmake_parse_arguments(PARSE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+    if(PARSE_UNPARSED_ARGUMENTS)
+        message(
+            FATAL_ERROR "Unknown keywords given to target_dll_compile_definitions(): \"${PARSE_UNPARSED_ARGUMENTS}\"")
+    endif()
+
+
+    if (BUILD_SHARED_LIBS AND MSVC)
+        if(PARSE_EXPORT)
+            target_compile_definitions(${TARGET} PRIVATE ${PARSE_EXPORT})
+        endif()
+        if(PARSE_IMPORT)
+            target_compile_definitions(${TARGET} INTERFACE ${PARSE_IMPORT})
+        endif()
+    endif()
+endfunction()
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    add_compile_options(-Weverything)
 endif()
 
-set(CMAKE_CXX_FLAGS_ASAN "-g -fsanitize=address,undefined -fno-sanitize-recover=all"
-    CACHE STRING "Compiler flags in asan build"
-    FORCE)
-
-if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
-    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
-    if (NOT (GCC_VERSION VERSION_GREATER 4.6 OR GCC_VERSION VERSION_EQUAL 4.6))
-        message(FATAL_ERROR "${PROJECT_NAME} c++11 support requires g++ 4.6 or greater, but it is ${GCC_VERSION}")
-    endif ()
-
-    set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wcast-qual")                # Cast for removing type qualifiers
-    set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-conversion")            # Implicit conversions that may alter a value
-    set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wfloat-equal")              # Floating values used in equality comparisons
-    set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Winline")                   # If a inline declared function couldn't be inlined
-    set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wmissing-declarations")     # If a global function is defined without a previous declaration
-    set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wmissing-format-attribute") # 
-    set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Woverloaded-virtual")       # when a function declaration hides virtual functions from a base class
-    set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wpacked")                   # 
-    set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wredundant-decls")          # if anything is declared more than once in the same scope
-    set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-shadow")                # whenever a local variable or type declaration shadows another one
-    set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-sign-promo")            #
-    set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-missing-field-initializers")
-    set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-missing-braces")
-    set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-sign-compare")
-
-    if(WARNINGS_ANSI_ISO)
-#        set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Werror=return-type")        # 
-#        set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wstrict-aliasing=3")
-    else()
-        set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-narrowing")
-        set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-delete-non-virtual-dtor")
-        set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-unnamed-type-template-args")
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    if(CMAKE_BUILD_TYPE STREQUAL "Release")
+        # "Release" uses -O3 by default
+        add_compile_options(-O2)
+    endif()
+    if(CMAKE_COMPILE_WARNING_AS_ERROR)
+        add_compile_options(-Werror)
     endif()
+    add_compile_options(-pedantic) # TODO: is this implied by -Weverything?
+endif()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    add_compile_options(-Wall)
+    add_compile_options(-Wextra)
+    add_compile_options(-Wcast-qual)                # Cast for removing type qualifiers
+    add_compile_options(-Wfloat-equal)              # Floating values used in equality comparisons
+    add_compile_options(-Wmissing-declarations)     # If a global function is defined without a previous declaration
+    add_compile_options(-Wmissing-format-attribute) #
+    add_compile_options(-Wno-long-long)
+    add_compile_options(-Wpacked)                   #
+    add_compile_options(-Wredundant-decls)          # if anything is declared more than once in the same scope
+    add_compile_options(-Wundef)
+    add_compile_options(-Wno-sign-compare)
+    add_compile_options(-Wno-multichar)
+    add_compile_options(-Woverloaded-virtual)       # when a function declaration hides virtual functions from a base class
 
-elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+    # TODO: evaluate
+    #add_compile_options(-Wconversion)  # danmar: gives fp. for instance: unsigned int sizeof_pointer = sizeof(void *);
+    #add_compile_options(-Wlogical-op) # doesn't work on older GCC
+    #add_compile_options(-Wsign-conversion) # too many warnings
+    #add_compile_options(-Wunreachable-code) # some GCC versions report lots of warnings
+    #add_compile_options(-Wsign-promo)
 
-   if(NOT EXISTS ${CMAKE_CXX_COMPILER})
-      MESSAGE( FATAL_ERROR "Clang++ not found. " )
-   endif()
+    # use pipes instead of temporary files - greatly reduces I/O usage
+    add_compile_options(-pipe)
 
-   set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-four-char-constants")
-   set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-missing-braces")
-   set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-missing-field-initializers")
-   set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-multichar")
-   set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-sign-compare")
-   set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-unused-function")
+    add_compile_options(-Wsuggest-attribute=noreturn)
+    add_compile_options_safe(-Wuseless-cast)
+    # add_compile_options_safe(-Wsuggest-attribute=returns_nonnull) # reports the warning even if the attribute is set
 
-   if(ENABLE_COVERAGE OR ENABLE_COVERAGE_XML)
-      MESSAGE(FATAL_ERROR "Not use clang for generate code coverage. Use gcc. ")
-   endif()
+    # TODO: evaluate
+    #add_compile_options_safe(-Wduplicated-branches)
+    #add_compile_options_safe(-Wduplicated-cond)
+    #add_compile_options_safe(-Wformat=2)
+    #add_compile_options_safe(-Wformat-overflow=2)
+    #add_compile_options_safe(-Wformat-signedness)
+    #add_compile_options_safe(-Wnull-dereference)
+    #add_compile_options_safe(-Wnrvo)
+    #add_compile_options_safe(-Wimplicit-fallthrough=5)
+    #add_compile_options_safe(-Wmissing-include-dirs)
+    #add_compile_options_safe(-Wunused)
+    #add_compile_options_safe(-Wunused-const-variable)
+    #add_compile_options_safe(-Wuninitialized)
+    #add_compile_options_safe(-Wsuggest-attribute=pure)
+    #add_compile_options_safe(-Wsuggest-attribute=const)
+    #add_compile_options_safe(-Wunused-macros)
+    #add_compile_options_safe(-Wpedantic)
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 14)
+        # TODO: verify this regression still exists in clang-15
+        if(CMAKE_BUILD_TYPE STREQUAL "Release" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
+            # work around performance regression - see https://github.com/llvm/llvm-project/issues/53555
+            check_cxx_compiler_flag("-mllvm -inline-deferral" _has_mllvm_inline_deferral)
+            if(_has_mllvm_inline_deferral)
+                add_compile_options(-mllvm -inline-deferral)
+            endif()
+        endif()
 
-elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "c++-analyzer")
+        # use force DWARF 4 debug format since not all tools might be able to handle DWARF 5 yet - e.g. valgrind on ubuntu 20.04
+        add_compile_options(-gdwarf-4)
+    endif()
 
-   if(NOT EXISTS ${CMAKE_CXX_COMPILER})
-      MESSAGE( FATAL_ERROR "c++-analyzer not found. " )
-   endif()
+    if (CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+        add_compile_options(-Wno-poison-system-directories)
+    endif()
 
-   if(ENABLE_COVERAGE)
-      MESSAGE(FATAL_ERROR "Not use c++-analyzer for generate code coverage. Use gcc. ")
-   endif()
+    if(USE_LIBCXX)
+        add_compile_options(-stdlib=libc++)
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -lc++")
+    endif()
 
-endif()
+    # TODO: fix and enable these warnings - or move to suppression list below
+    add_compile_options_safe(-Wno-sign-conversion)
+    add_compile_options_safe(-Wno-shadow-field-in-constructor)
+    add_compile_options_safe(-Wno-shorten-64-to-32)
+    add_compile_options_safe(-Wno-implicit-int-conversion)
+    add_compile_options_safe(-Wno-double-promotion)
+    add_compile_options_safe(-Wno-shadow-field)
+    add_compile_options_safe(-Wno-shadow-uncaptured-local)
+    add_compile_options_safe(-Wno-implicit-float-conversion)
+    add_compile_options_safe(-Wno-switch-enum)
+    add_compile_options_safe(-Wno-date-time)
+    add_compile_options(-Wno-disabled-macro-expansion)
+    add_compile_options(-Wno-sign-compare)
+    add_compile_options_safe(-Wno-ms-bitfield-padding) # TODO: fix this
 
-if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR
-    "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" OR
-    "${CMAKE_CXX_COMPILER_ID}" STREQUAL "c++-analyzer" )
+    # these cannot be fixed properly without adopting later C++ standards
+    add_compile_options_safe(-Wno-unsafe-buffer-usage)
+    add_compile_options_safe(-Wno-global-constructors)
+    add_compile_options_safe(-Wno-exit-time-destructors)
 
-   if(WARNINGS_ANSI_ISO)
-           set(EXTRA_C_FLAGS "-Wextra -pedantic ${EXTRA_C_FLAGS}")
-#           set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wlogical-op")
-           set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-long-long") # Don't warn about long long usage.
-   endif()
+    # can only be partially addressed
+    add_compile_options(-Wno-padded)
+    add_compile_options_safe(-Wno-nrvo)
 
-   if(WARNINGS_ARE_ERRORS)
-      set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Werror")
-   endif()
+    # no need for C++98 compatibility
+    add_compile_options(-Wno-c++98-compat)
+    add_compile_options(-Wno-c++98-compat-pedantic)
 
-   set(EXTRA_C_FLAGS "-Wall ${EXTRA_C_FLAGS}")
-   
-   set(EXTRA_C_FLAGS_DEBUG "${EXTRA_C_FLAGS_DEBUG} -O0")
+    # only needs to be addressed to work around issues in older compilers
+    add_compile_options_safe(-Wno-return-std-move-in-c++11)
 
-endif()
+    # this is reported even when it is unnecessary i.e. -Wswitch-enum warnings have been mitigated
+    add_compile_options_safe(-Wno-switch-default)
 
-if ("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux" AND
-    "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+    # warnings we are currently not interested in
+    add_compile_options(-Wno-four-char-constants)
+    add_compile_options(-Wno-weak-vtables)
+    add_compile_options(-Wno-multichar)
 
-    set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -U_GLIBCXX_DEBUG")
+    # FIXME: only reported when running clang-tidy
+    # /home/runner/work/cppcheck/cppcheck/tools/triage/mainwindow.cpp:19:10: error: multiple candidates for header 'mainwindow.h' found; directory '/home/runner/work/cppcheck/cppcheck/tools/triage' chosen, ignoring others including '/home/runner/work/cppcheck/cppcheck/gui' [clang-diagnostic-shadow-header]
+    # 19 | #include "mainwindow.h"
+    # |          ^
+    add_compile_options_safe(-Wno-shadow-header)
+
+    if(ENABLE_COVERAGE OR ENABLE_COVERAGE_XML)
+      message(FATAL_ERROR "Do not use clang to generate code coverage. Use GCC instead.")
+    endif()
 endif()
 
-if (MSVC)
-	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /STACK:8000000")
+if(MSVC)
+    # add_link_options() requires CMake 3.13
+
+    # General
+    add_compile_options(/W4) # Warning Level
+    add_compile_options(/Zi) # Debug Information Format - Program Database
+    if(CMAKE_COMPILE_WARNING_AS_ERROR)
+        add_compile_options(/WX) # Treat Warning As Errors
+    endif()
+    add_compile_options(/MP) # Multi-processor Compilation
+
+    # Advanced
+    # Character Set - Use Unicode Character Set
+    # No Whole Program Optimization
+
+    # C/C++ - Optimization
+    add_compile_options($<$<NOT:$<CONFIG:Debug>>:/O2>) # Optimization - Maximum Optimization (Favor Speed)
+    add_compile_options($<$<NOT:$<CONFIG:Debug>>:/Ob2>) # Inline Function Expansion - Any Suitable
+    add_compile_options($<$<NOT:$<CONFIG:Debug>>:/Oi>) # Enable Intrinsic Functions
+    add_compile_options($<$<NOT:$<CONFIG:Debug>>:/Ot>) # Favor fast code
+    add_compile_options($<$<NOT:$<CONFIG:Debug>>:/Oy>) # Omit Frame Pointers
+    add_compile_options($<$<CONFIG:Debug>:/Od>) # Optimization - Disabled
+
+    # C/C++ - Code Generation
+    add_compile_options($<$<NOT:$<CONFIG:Debug>>:/GF>) # Enable String Pooling
+    add_compile_options($<$<NOT:$<CONFIG:Debug>>:/MD>) # Runtime Library - Multi-threaded DLL
+    add_compile_options($<$<NOT:$<CONFIG:Debug>>:/GS->) # Disable Security Check
+    add_compile_options($<$<NOT:$<CONFIG:Debug>>:/Gy>) # Enable Function-Level Linking
+    add_compile_options($<$<CONFIG:Debug>:/MDd>) # Runtime Library - Multi-threaded Debug DLL
+    add_compile_options($<$<CONFIG:Debug>:/GS>) # Enable Security Check
+
+    # C/C++ - Language
+    add_compile_options(/Zc:rvalueCast) # Enforce type conversion rules
+    #add_compile_options(/std:c++14) # C++ Language Standard - ISO C++14 Standard
+
+    # C/C++ - Browse Information
+    # Enable Browse Information - No
+
+    # C/C++ - Advanced
+    add_compile_options(/wd4018) # warning C4018: '>': signed/unsigned mismatch
+    add_compile_options(/wd4127) # warning C4127: conditional expression is constant
+    add_compile_options(/wd4146) # warning C4146: unary minus operator applied to unsigned type, result still unsigned
+    add_compile_options(/wd4244) # warning C4244: 'initializing': conversion from 'int' to 'char', possible loss of data
+    add_compile_options(/wd4251) # warning C4251: 'x': class 'y' needs to have dll-interface to be used by clients of struct 'u'
+    # Clang: -Wshorten-64-to-32 -Wimplicit-int-conversion
+    add_compile_options(/wd4267) # warning C4267: 'return': conversion from 'size_t' to 'int', possible loss of data
+    add_compile_options(/wd4389) # warning C4389: '==': signed/unsigned mismatch
+    add_compile_options(/wd4701) # warning C4701: potentially uninitialized local variable 'err' used
+    add_compile_options(/wd4706) # warning C4706: assignment within conditional expression
+    add_compile_options(/wd4800) # warning C4800: 'const SymbolDatabase *' : forcing value to bool 'true' or 'false' (performance warning)
+    add_compile_options(/wd4805) # warning C4805: '==' : unsafe mix of type 'bool' and type 'long long' in operation
+
+    # C/C++ - All Options
+    add_compile_options(/Zc:throwingNew /Zc:__cplusplus) # Additional Options
+
+    # Linker - General
+    add_link_options($<$<CONFIG:Debug>:/INCREMENTAL>) # Enable Incremental Linking - Yes
+
+    add_link_options(/NOLOGO) # Suppress Startup Banner - Yes
+    # Ignore Import Library - Yes
+
+    # Linker - Debugging
+    add_link_options(/DEBUG) # Generate Debug Information
+
+    # Linker - System
+    # Stack Reserve Size - 8000000
+    # Stack Commit Size - 8000000
+    add_link_options(/LARGEADDRESSAWARE) # Enable Large Addresses - Yes
+
+    # Linker - Optimization
+    add_link_options(/OPT:REF) # References - Yes
+    add_link_options(/OPT:ICF) # Enable COMDAT Folding - Yes
+
+    # Linker - Advanced
+    add_link_options($<$<NOT:$<CONFIG:Debug>>:/RELEASE>) # Set Checksum - Yes
 endif()
 
-include(cmake/dynamic_analyzer_options.cmake    REQUIRED)
+# TODO: check if this can be enabled again - also done in Makefile
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux" AND
+    CMAKE_CXX_COMPILER_ID MATCHES "Clang")
 
-# Add user supplied extra options (optimization, etc...)
-# ==========================================================
-set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS}" CACHE INTERNAL "Extra compiler options")
-set(EXTRA_C_FLAGS_RELEASE "${EXTRA_C_FLAGS_RELEASE}" CACHE INTERNAL "Extra compiler options for Release build")
-set(EXTRA_C_FLAGS_DEBUG "${EXTRA_C_FLAGS_DEBUG}" CACHE INTERNAL "Extra compiler options for Debug build")
+    add_compile_options(-U_GLIBCXX_DEBUG)
+endif()
 
-#combine all "extra" options
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_C_FLAGS}")
-set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${EXTRA_C_FLAGS_DEBUG}")
-set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${EXTRA_C_FLAGS_RELEASE}")
+if(MSVC)
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /STACK:8000000")
+endif()
+
+if(CYGWIN)
+    # TODO: this is a linker flag - not a compiler flag
+    add_compile_options(-Wl,--stack,8388608)
+endif()
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_C_FLAGS}")
-set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}  ${EXTRA_C_FLAGS_RELEASE}")
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${EXTRA_C_FLAGS_DEBUG}")
+include(cmake/dynamic_analyzer_options.cmake)
diff --git a/cmake/cxx11.cmake b/cmake/cxx11.cmake
index 1fa112a1695..99e94ea4d23 100644
--- a/cmake/cxx11.cmake
+++ b/cmake/cxx11.cmake
@@ -1,14 +1,14 @@
 macro(use_cxx11)
-  if (CMAKE_VERSION VERSION_LESS "3.1")
-    if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-      set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
-    elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
-      set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
-    endif ()
-  else ()
-    set (CMAKE_CXX_STANDARD 11)
-    if (POLICY CMP0025)
-      cmake_policy(SET CMP0025 NEW)
-    endif ()
-  endif ()
-endmacro(use_cxx11)
+  if(CMAKE_CXX_STANDARD EQUAL 98)
+    message(FATAL_ERROR "C++ standard was set to ${CMAKE_CXX_STANDARD} but 11 is required as minimum")
+  endif()
+  if(USE_BOOST AND USE_BOOST_INT128)
+    # Boost.Math requires C++14
+    if(CMAKE_CXX_STANDARD LESS 14)
+      message(FATAL_ERROR "C++ standard was set to ${CMAKE_CXX_STANDARD} but 14 is required as minimum")
+    endif()
+    set(CMAKE_CXX_STANDARD 14 CACHE STRING "C++ standard to use")
+  else()
+    set(CMAKE_CXX_STANDARD 11 CACHE STRING "C++ standard to use")
+  endif()
+endmacro()
diff --git a/cmake/dynamic_analyzer_options.cmake b/cmake/dynamic_analyzer_options.cmake
index d808c57595c..45d4674c3a3 100644
--- a/cmake/dynamic_analyzer_options.cmake
+++ b/cmake/dynamic_analyzer_options.cmake
@@ -1,31 +1,39 @@
-IF (USE_CLANG)
-   SET(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -fdiagnostics-show-category=name")
-ENDIF()
-
-IF(ANALYZE_MEMORY)
-
-   SET(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -fsanitize=memory")
-   SET(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -fsanitize-memory-track-origins=2")
-   SET(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -fno-omit-frame-pointer")
-   # NOTE: tail call elimination -fno-optimize-sibling-calls
-
-ELSEIF(ANALYZE_ADDRESS)
-
-   SET(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -fsanitize=address")
-   SET(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -fno-omit-frame-pointer")
-
-ELSEIF(ANALYZE_THREAD)
-
-   SET(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -fsanitize=thread")
-
-ENDIF()
-
-IF(ANALYZE_UNDEFINED)
-   SET(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -fsanitize=undefined-trap")
-   SET(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -fsanitize-undefined-trap-on-error")
-   SET(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -fno-sanitize-recover")
-ENDIF()
-
-IF(ANALYZE_DATAFLOW)
-   SET(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -fsanitize=dataflow")
-ENDIF()
+if(ANALYZE_MEMORY)
+    add_compile_options(-fsanitize=memory)
+    add_compile_options(-fsanitize-memory-track-origins=2)
+    add_compile_options(-fno-omit-frame-pointer)
+    add_compile_options(-fno-optimize-sibling-calls)
+
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=memory")
+elseif(ANALYZE_ADDRESS)
+    add_compile_options(-fsanitize=address)
+    add_compile_options(-fno-omit-frame-pointer)
+    add_compile_options(-fno-optimize-sibling-calls)
+
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address")
+elseif(ANALYZE_THREAD)
+    add_compile_options(-fsanitize=thread)
+
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=thread")
+endif()
+
+if(ANALYZE_UNDEFINED)
+    # TODO: enable signed-integer-overflow
+    add_compile_options(-fsanitize=undefined -fno-sanitize=signed-integer-overflow)
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        add_compile_options(-fsanitize=nullability)
+    endif()
+    add_compile_options(-fno-sanitize-recover=all)
+    add_compile_options(-fno-omit-frame-pointer)
+
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=undefined -fno-sanitize=signed-integer-overflow")
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=nullability")
+    endif()
+endif()
+
+if(ANALYZE_TYPE)
+    add_compile_options(-fsanitize=type)
+
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=type")
+endif()
diff --git a/cmake/findDependencies.cmake b/cmake/findDependencies.cmake
index 8599e1b814d..b1f6571504d 100644
--- a/cmake/findDependencies.cmake
+++ b/cmake/findDependencies.cmake
@@ -1,25 +1,107 @@
-if (BUILD_GUI)
-    if (NOT WITH_QCHART)
-        find_package(Qt5 COMPONENTS Core Gui Widgets PrintSupport LinguistTools REQUIRED)
-    else()
-        find_package(Qt5 COMPONENTS Core Gui Widgets PrintSupport LinguistTools Charts REQUIRED)
+if(BUILD_GUI)
+    list(APPEND qt_components Core Gui Widgets PrintSupport LinguistTools Help Network)
+    if(WITH_QCHART)
+        list(APPEND qt_components Charts)
+    endif()
+    if(BUILD_TESTING)
+        list(APPEND qt_components Test)
+    endif()
+    find_package(Qt6 COMPONENTS ${qt_components} REQUIRED)
+    set(QT_VERSION "${Qt6Core_VERSION}")
+    if(NOT QT_VERSION)
+        # TODO: remove fallback
+        message(WARNING "'Qt6Core_VERSION' is not set - using 6.0.0 as fallback")
+        set(QT_VERSION "6.0.0")
+    endif()
+
+    if(BUILD_ONLINE_HELP)
+        find_program(QHELPGENERATOR qhelpgenerator)
+        if(NOT QHELPGENERATOR)
+            # TODO: how to properly get the Qt binary folder?
+            # piggy-back off Qt::qmake for now as it should be in the same folder as the binary we are looking for
+            get_target_property(_qmake_executable Qt::qmake IMPORTED_LOCATION)
+            get_filename_component(_qt_bin_dir ${_qmake_executable} DIRECTORY)
+            message(STATUS "qhelpgenerator not found in PATH - trying ${_qt_bin_dir}")
+            # cannot be mandatory since qhelpgenerator is missing from the official qttools Linux package - https://bugreports.qt.io/browse/QTBUG-116168
+            find_program(QHELPGENERATOR qhelpgenerator HINTS ${_qt_bin_dir} REQUIRED)
+        endif()
     endif()
 endif()
 
-if (HAVE_RULES)
-    find_library(PCRE pcre)
-    if (NOT PCRE)
+if(HAVE_RULES)
+    find_path(PCRE_INCLUDE pcre.h)
+    find_library(PCRE_LIBRARY NAMES pcre pcred)
+    if(NOT PCRE_LIBRARY OR NOT PCRE_INCLUDE)
         message(FATAL_ERROR "pcre dependency for RULES has not been found")
     endif()
+else()
+    set(PCRE_LIBRARY "")
 endif()
 
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
-set(CMAKE_AUTOMOC OFF)
 
-if (NOT ${USE_MATCHCOMPILER_OPT} STREQUAL "Off")
-    find_package(PythonInterp)
-    if (NOT ${PYTHONINTERP_FOUND})
-        message(WARNING "No python interpreter found. Therefore, the match compiler is switched off.")
+find_package(Python COMPONENTS Interpreter)
+
+if(NOT Python_Interpreter_FOUND)
+    if(NOT USE_MATCHCOMPILER_OPT STREQUAL "Off")
+        message(WARNING "No python interpreter found - disabling matchcompiler.")
+        set(USE_MATCHCOMPILER_OPT "Off")
+    endif()
+else()
+    if(${Python_VERSION} VERSION_LESS 3.7)
+        message(WARNING "The minimum supported Python version is 3.7, found ${Python_VERSION} - disabling matchcompiler.")
         set(USE_MATCHCOMPILER_OPT "Off")
     endif()
 endif()
+
+if(NOT USE_BUNDLED_TINYXML2)
+    add_library(tinyxml2 INTERFACE)
+    find_package(tinyxml2 QUIET)
+    if(TARGET tinyxml2::tinyxml2)
+        target_link_libraries(tinyxml2 INTERFACE tinyxml2::tinyxml2)
+    else()
+        find_library(tinyxml2_LIBRARIES tinyxml2)
+        find_path(tinyxml2_INCLUDE_DIRS tinyxml2.h)
+        if(NOT tinyxml2_LIBRARIES AND NOT tinyxml2_INCLUDE_DIRS)
+            message(FATAL_ERROR "tinyxml2 has not been found")
+        else()
+            set(tinyxml2_FOUND 1)
+        endif()
+        target_link_libraries(tinyxml2 INTERFACE ${tinyxml2_LIBRARIES})
+        target_include_directories(tinyxml2 INTERFACE ${tinyxml2_INCLUDE_DIRS})
+    endif()
+endif()
+
+find_package(Threads REQUIRED)
+if(NOT DEFINED CMAKE_THREAD_LIBS_INIT)
+    set(CMAKE_THREAD_LIBS_INIT "")
+endif()
+
+if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.30")
+    # avoid legacy warning about Boost lookup in CMake
+    cmake_policy(SET CMP0167 NEW)
+endif()
+
+if(USE_BOOST)
+    # with Visual Studio Boost is not detected by CMake unless you provide a full release even if only used header-only.
+    # to work around this we allow to externally set BOOST_INCLUDEDIR.
+    # see https://trac.cppcheck.net/ticket/13822 for more details.
+    if(BOOST_INCLUDEDIR)
+        if(NOT MSVC)
+            message(FATAL_ERROR "BOOST_INCLUDEDIR hack only allowed for Visual Studio")
+        endif()
+        message(STATUS "Using BOOST_INCLUDEDIR hack for Visual Studio")
+        if(NOT IS_READABLE "${BOOST_INCLUDEDIR}/boost/container/small_vector.hpp")
+            message(FATAL_ERROR "Provided BOOST_INCLUDEDIR does not appear to contain Boost includes")
+        endif()
+        set(Boost_FOUND ON)
+        set(Boost_INCLUDE_DIRS "${BOOST_INCLUDEDIR}")
+        set(Boost_VERSION_STRING "")  # TODO: set proper value
+    elseif(USE_BOOST STREQUAL "Auto")
+        find_package(Boost)
+    else()
+        find_package(Boost REQUIRED)
+    endif()
+endif()
+
+find_program(LIBXML2_XMLLINT_EXECUTABLE xmllint)
diff --git a/cmake/includechecks.cmake b/cmake/includechecks.cmake
new file mode 100644
index 00000000000..b9cbbd03183
--- /dev/null
+++ b/cmake/includechecks.cmake
@@ -0,0 +1,8 @@
+include(CheckIncludeFileCXX)
+
+if(NOT MSVC)
+    check_include_file_cxx(execinfo.h HAVE_EXECINFO_H)
+    if(NOT HAVE_EXECINFO_H)
+        set(HAVE_EXECINFO_H 0)
+    endif()
+endif()
\ No newline at end of file
diff --git a/cmake/options.cmake b/cmake/options.cmake
index 0d83383641d..e728d809220 100644
--- a/cmake/options.cmake
+++ b/cmake/options.cmake
@@ -1,45 +1,138 @@
-#------------------------------------------------------
 # Build type
 #------------------------------------------------------
 set(CMAKE_CONFIGURATION_TYPES "Debug;Release;RelWithDebInfo;MinSizeRel" CACHE STRING "Configs" FORCE)
 if(DEFINED CMAKE_BUILD_TYPE)
-   SET_PROPERTY(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS ${CMAKE_CONFIGURATION_TYPES})
+  SET_PROPERTY(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS ${CMAKE_CONFIGURATION_TYPES})
 endif()
 
 if(NOT CMAKE_BUILD_TYPE)
-   set(CMAKE_BUILD_TYPE "Debug")
+  message(STATUS "No build type set - defaulting to Debug")
+  set(CMAKE_BUILD_TYPE "Debug")
 endif()
 
 # ----------------------------------------------------------------------------
 #   PROJECT CONFIGURATION
 # ----------------------------------------------------------------------------
-option(USE_CLANG            "Use Clang compiler"                                            OFF)
-option(USE_ANALYZE          "Use Clang compiler with analyze mode"                          OFF)
-option(ANALYZE_MEMORY       "Clang dynamic analyzer: detector of uninitialized reads."      OFF)
-option(ANALYZE_ADDRESS      "Clang dynamic analyzer: fast memory error detector. "          OFF)
-option(ANALYZE_THREAD       "Clang dynamic analyzer: tool that detects data races. "        OFF)
-option(ANALYZE_UNDEFINED    "Clang dynamic analyzer: undefined behavior checker. "          OFF)
-option(ANALYZE_DATAFLOW     "Clang dynamic analyzer: general dynamic dataflow analysis."    OFF)
+option(ANALYZE_MEMORY       "Build with MemorySanitizer to detect usage of uninitialized memory" OFF)
+if(ANALYZE_MEMORY)
+    message(STATUS "MemorySanitzer requires an instrumented libc++")
+endif()
+option(ANALYZE_ADDRESS      "Build with AddressSanitzer to detect memory error"             OFF)
+option(ANALYZE_THREAD       "Build with ThreadSanitizer to detect data races"               OFF)
+option(ANALYZE_UNDEFINED    "Build with UndefinedBehaviorSanitizer to detect undefined behavior" OFF)
+option(ANALYZE_TYPE         "Build with TypeSanitizer to detect aliasing issues"            OFF)
+
 option(WARNINGS_ARE_ERRORS  "Treat warnings as errors"                                      OFF)
-option(WARNINGS_ANSI_ISO    "Issue all the mandatory diagnostics Listed in C standard"      ON)
+if(WARNINGS_ARE_ERRORS)
+    if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.24")
+        message(DEPRECATION "WARNINGS_ARE_ERRORS is deprecated - please use CMAKE_COMPILE_WARNING_AS_ERROR instead")
+    endif()
+    set(CMAKE_COMPILE_WARNING_AS_ERROR On)
+endif()
+option(EXTERNALS_AS_SYSTEM  "Treat externals as system includes"                            OFF)
 
+# we are only using the header-only "container" Boost component so we can unconditionally search for it by default
 set(USE_MATCHCOMPILER "Auto" CACHE STRING "Usage of match compiler")
-set_property(CACHE USE_MATCHCOMPILER PROPERTY STRINGS Auto Off On Verify) 
-if (USE_MATCHCOMPILER STREQUAL "Auto")
-    if (NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
-        set(USE_MATCHCOMPILER_OPT "On")
+set_property(CACHE USE_MATCHCOMPILER PROPERTY STRINGS Auto Off On Verify)
+if(USE_MATCHCOMPILER)
+    if(USE_MATCHCOMPILER STREQUAL "Auto")
+        if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+            message(STATUS "Non-debug build detected - enabling matchcompiler")
+            set(USE_MATCHCOMPILER_OPT "On")
+        else()
+            message(STATUS "Debug build detected - disabling matchcompiler")
+            set(USE_MATCHCOMPILER_OPT "Off")
+        endif()
+    elseif(USE_MATCHCOMPILER STREQUAL "Verify")
+        set(USE_MATCHCOMPILER_OPT "Verify")
     else()
-        set(USE_MATCHCOMPILER_OPT "Off")
+        set(USE_MATCHCOMPILER_OPT "On")
     endif()
 else()
-    set(USE_MATCHCOMPILER_OPT ${USE_MATCHCOMPILER})
+    set(USE_MATCHCOMPILER_OPT "Off")
 endif()
 
+option(BUILD_CORE_DLL       "Build lib as cppcheck-core.dll with Visual Studio"             OFF)
+if(BUILD_CORE_DLL AND NOT MSVC)
+    message(FATAL_ERROR "Building of lib as DLL is only supported with Visual Studio")
+endif()
+# need to check before the option() specifying it or it will be defined
+if(DEFINED BUILD_TESTS)
+    message(DEPRECATION "BUILD_TESTS has been deprecated and will be removed in Cppcheck 2.22 - please use BUILD_TESTING instead")
+    if(DEFINED BUILD_TESTING)
+        message(AUTHOR_WARNING "BUILD_TESTS and BUILD_TESTING have been defined at the same time - ignoring BUILD_TESTS")
+    else()
+        set(BUILD_TESTING "${BUILD_TESTS}")
+    endif()
+elseif(NOT DEFINED BUILD_TESTING)
+    # disable tests by default - TODO: remove this
+    set(BUILD_TESTING OFF)
+endif()
 option(BUILD_TESTS          "Build tests"                                                   OFF)
+option(REGISTER_TESTS       "Register tests in CTest"                                       ON)
+option(ENABLE_CHECK_INTERNAL "Enable internal checks"                                       OFF)
+option(DISABLE_DMAKE        "Disable run-dmake dependencies"                                OFF)
+option(BUILD_MANPAGE        "Enable man target to build manpage"                            OFF)
+
+option(BUILD_CLI            "Build the CLI application"                                     ON)
+if(NOT BUILD_CLI AND BUILD_TESTING)
+    message(FATAL_ERROR "Building the tests requires the CLI to be build as well")
+endif()
+
 option(BUILD_GUI            "Build the qt application"                                      OFF)
-option(WITH_QCHART          "When building GUI(need BUILD_GUI=ON), use Qt5 Charts"          OFF)
+option(WITH_QCHART          "Enable QtCharts usage in the GUI"                              OFF)
+option(REGISTER_GUI_TESTS   "Register GUI tests in CTest"                                   ON)
+option(BUILD_ONLINE_HELP    "Build online help"                                             OFF)
+option(BUILD_TRIAGE         "Build triage UI tool"                                          OFF)
+
+if(NOT BUILD_GUI)
+    if(BUILD_ONLINE_HELP)
+        message(FATAL_ERROR "BUILD_ONLINE_HELP requires BUILD_GUI to be enabled")
+    endif()
+    if(BUILD_TRIAGE)
+        message(FATAL_ERROR "BUILD_TRIAGE requires BUILD_GUI to be enabled")
+    endif()
+endif()
 
 option(HAVE_RULES           "Usage of rules (needs PCRE library and headers)"               OFF)
+option(USE_BUNDLED_TINYXML2 "Usage of bundled TinyXML2 library"                             ON)
+if(BUILD_CORE_DLL AND NOT USE_BUNDLED_TINYXML2)
+    message(FATAL_ERROR "Cannot use external TinyXML2 library when building lib as DLL")
+endif()
+option(CPPCHK_GLIBCXX_DEBUG "Usage of STL debug checks in Debug build"                      ON)
+option(DISALLOW_THREAD_EXECUTOR "Disallow usage of ThreadExecutor for -j"                   OFF)
+if(DISALLOW_THREAD_EXECUTOR AND WIN32)
+    message(FATAL_ERROR "Cannot disable usage of ThreadExecutor on Windows as no other executor implementation is currently available")
+endif()
+option(DISALLOW_PROCESS_EXECUTOR "Disallow usage of ProcessExecutor for -j"                   OFF)
+if(DISALLOW_THREAD_EXECUTOR AND DISALLOW_PROCESS_EXECUTOR)
+    message(FATAL_ERROR "Cannot disable both ThreadExecutor and ProcessExecutor")
+endif()
+set(USE_BOOST "Auto" CACHE STRING "Usage of Boost")
+set_property(CACHE USE_BOOST PROPERTY STRINGS Auto Off On)
+option(USE_BOOST_INT128     "Usage of Boost.Multiprecision 128-bit integer for Mathlib"     OFF)
+if (NOT USE_BOOST AND USE_BOOST_INT128)
+    message(FATAL_ERROR "USE_BOOST_INT128 requires USE_BOOST to be enabled")
+endif()
+option(USE_LIBCXX           "Use libc++ instead of libstdc++"                               OFF)
+
+if(USE_LIBCXX AND NOT CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    message(FATAL_ERROR "libc++ can only be used with a Clang-based compiler")
+endif()
+
+option(NO_UNIX_SIGNAL_HANDLING "Disable usage of Unix Signal Handling"                      OFF)
+option(NO_UNIX_BACKTRACE_SUPPORT "Disable usage of Unix Backtrace support"                  OFF)
+option(NO_WINDOWS_SEH       "Disable usage of Windows SEH"                                  OFF)
+
+option(ENABLE_CSA_ALPHA     "Enable Clang Static Analyzer alpha checkers for run-clang-tidy-csa target"  OFF)
+
+# TODO: disable by default like make build?
+option(FILESDIR "Hard-coded directory for files to load from"                               OFF)
+
+set(CMAKE_DISABLE_PRECOMPILE_HEADERS Off CACHE BOOL "Disable precompiled headers")
+# need to disable the prologue or it will be treated like a system header and not emit any warnings
+# see https://gitlab.kitware.com/cmake/cmake/-/issues/21219
+set(CMAKE_PCH_PROLOGUE "")
 
 set(CMAKE_INCLUDE_DIRS_CONFIGCMAKE ${CMAKE_INSTALL_PREFIX}/include      CACHE PATH "Output directory for headers")
 set(CMAKE_LIB_DIRS_CONFIGCMAKE     ${CMAKE_INSTALL_PREFIX}/lib          CACHE PATH "Output directory for libraries")
@@ -48,5 +141,11 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
 set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
 
-set(FILESDIR                       ${CMAKE_INSTALL_PREFIX}/share/${PROJECT_NAME} CACHE STRING "Cppcheck files directory")
-
+string(LENGTH "${FILESDIR}" _filesdir_len)
+# override FILESDIR if it is set or empty
+if(FILESDIR OR ${_filesdir_len} EQUAL 0)
+# TODO: verify that it is an abolute path?
+    set(FILESDIR_DEF                   ${FILESDIR})
+else()
+    set(FILESDIR_DEF                   ${CMAKE_INSTALL_PREFIX}/share/${PROJECT_NAME} CACHE STRING "Cppcheck files directory")
+endif()
diff --git a/cmake/printInfo.cmake b/cmake/printInfo.cmake
index 8e3ea18ed20..87c7e41f284 100644
--- a/cmake/printInfo.cmake
+++ b/cmake/printInfo.cmake
@@ -1,55 +1,119 @@
-message( STATUS "------------------ General configuration for ${PROJECT_NAME} ${VERSION} -----------------")
-message( STATUS )
-message( STATUS "CMake Generator =       ${CMAKE_GENERATOR}")
-message( STATUS "Compiler =              ${CMAKE_CXX_COMPILER_ID}")
-message( STATUS "Build type =            ${CMAKE_BUILD_TYPE}")
-message( STATUS "CMAKE_INSTALL_PREFIX =  ${CMAKE_INSTALL_PREFIX}" )
-message( STATUS "C++ flags (General) =   ${CMAKE_CXX_FLAGS}")
-message( STATUS "C++ flags (Release) =   ${CMAKE_CXX_FLAGS_RELEASE}")
-message( STATUS "C++ flags (Debug) =     ${CMAKE_CXX_FLAGS_DEBUG}")
-get_directory_property( DirDefs DIRECTORY ${CMAKE_SOURCE_DIR} COMPILE_DEFINITIONS )
-foreach( d ${DirDefs} )
-    message( STATUS "Found Define: " ${d} )
-endforeach()
-message( STATUS )
-message( STATUS "---------------------------------------------------------" )
-message( STATUS "USE_CLANG =             ${USE_CLANG}" )
-message( STATUS "USE_ANALYZE =           ${USE_ANALYZE}" )
-message( STATUS "ANALYZE_MEMORY =        ${ANALYZE_MEMORY}" )
-message( STATUS "ANALYZE_ADDRESS =       ${ANALYZE_ADDRESS}" )
-message( STATUS "ANALYZE_THREAD =        ${ANALYZE_THREAD}" )
-message( STATUS "ANALYZE_UNDEFINED =     ${ANALYZE_UNDEFINED}" )
-message( STATUS "ANALYZE_DATAFLOW =      ${ANALYZE_DATAFLOW}" )
-message( STATUS "WARNINGS_ANSI_ISO =     ${WARNINGS_ANSI_ISO}" )
-message( STATUS "WARNINGS_ARE_ERRORS =   ${WARNINGS_ARE_ERRORS}" )
-message( STATUS )
-message( STATUS "USE_MATCHCOMPILER =     ${USE_MATCHCOMPILER}" )
-message( STATUS "USE_MATCHCOMPILER_OPT = ${USE_MATCHCOMPILER_OPT}" )
-message( STATUS )
+message(STATUS "------------------ General configuration for ${PROJECT_NAME} ${PROJECT_VERSION} -----------------")
+message(STATUS)
+message(STATUS "CMake Version =         ${CMAKE_VERSION}")
+message(STATUS "CMake Generator =       ${CMAKE_GENERATOR}")
+message(STATUS)
+message(STATUS "Compiler =              ${CMAKE_CXX_COMPILER_ID}")
+message(STATUS "Compiler Version =      ${CMAKE_CXX_COMPILER_VERSION}")
+message(STATUS "Build type =            ${CMAKE_BUILD_TYPE}")
+message(STATUS "CMake C++ Standard =    ${CMAKE_CXX_STANDARD}")
+message(STATUS "CMAKE_INSTALL_PREFIX =  ${CMAKE_INSTALL_PREFIX}")
+message(STATUS "CMAKE_DISABLE_PRECOMPILE_HEADERS = ${CMAKE_DISABLE_PRECOMPILE_HEADERS}")
+message(STATUS "C++ flags (General) =   ${CMAKE_CXX_FLAGS}")
+message(STATUS "C++ flags (Release) =   ${CMAKE_CXX_FLAGS_RELEASE}")
+message(STATUS "C++ flags (RelWithDebInfo) = ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
+message(STATUS "C++ flags (Debug) =     ${CMAKE_CXX_FLAGS_DEBUG}")
+message(STATUS "CMAKE_EXE_LINKER_FLAGS = ${CMAKE_EXE_LINKER_FLAGS}")
+message(STATUS "CPPCHK_GLIBCXX_DEBUG =  ${CPPCHK_GLIBCXX_DEBUG}")
+if(DEFINED HAVE_EXECINFO_H)
+    message(STATUS "HAVE_EXECINFO_H =       ${HAVE_EXECINFO_H}")
+endif()
+get_directory_property(DirCompileDefs DIRECTORY ${CMAKE_SOURCE_DIR} COMPILE_DEFINITIONS)
+message(STATUS "COMPILE_DEFINITIONS (global) =  ${DirCompileDefs}")
+get_directory_property(DirCompileOptions DIRECTORY ${CMAKE_SOURCE_DIR} COMPILE_OPTIONS)
+message(STATUS "COMPILE_OPTIONS (global) =  ${DirCompileOptions}")
+message(STATUS)
+if(Python_Interpreter_FOUND)
+    message(STATUS "Python_VERSION =        ${Python_VERSION}")
+    message(STATUS "Python_EXECUTABLE =     ${Python_EXECUTABLE}")
+endif()
+message(STATUS)
+message(STATUS "---------------------------------------------------------")
+message(STATUS "ANALYZE_MEMORY =        ${ANALYZE_MEMORY}")
+message(STATUS "ANALYZE_ADDRESS =       ${ANALYZE_ADDRESS}")
+message(STATUS "ANALYZE_THREAD =        ${ANALYZE_THREAD}")
+message(STATUS "ANALYZE_UNDEFINED =     ${ANALYZE_UNDEFINED}")
+message(STATUS "ANALYZE_TYPE =          ${ANALYZE_TYPE}")
+message(STATUS)
+message(STATUS "WARNINGS_ARE_ERRORS =   ${WARNINGS_ARE_ERRORS}")
+message(STATUS "EXTERNALS_AS_SYSTEM =   ${EXTERNALS_AS_SYSTEM}")
+message(STATUS)
+message(STATUS "USE_MATCHCOMPILER =     ${USE_MATCHCOMPILER}")
+message(STATUS "USE_MATCHCOMPILER_OPT = ${USE_MATCHCOMPILER_OPT}")
+message(STATUS)
+message(STATUS "NO_UNIX_SIGNAL_HANDLING = ${NO_UNIX_SIGNAL_HANDLING}")
+message(STATUS "NO_UNIX_BACKTRACE_SUPPORT = ${NO_UNIX_BACKTRACE_SUPPORT}")
+message(STATUS "NO_WINDOWS_SEH =        ${NO_WINDOWS_SEH}")
+message(STATUS)
+message(STATUS "ENABLE_CSA_ALPHA =      ${ENABLE_CSA_ALPHA}")
+message(STATUS)
 if(NOT DEFINED BUILD_SHARED_LIBS)
-    message( STATUS "BUILD_SHARED_LIBS =     OFF" )
+    message(STATUS "BUILD_SHARED_LIBS =     OFF")
 else()
-    message( STATUS "BUILD_SHARED_LIBS =     ${BUILD_SHARED_LIBS}" )
-endif(NOT DEFINED BUILD_SHARED_LIBS)
-message( STATUS "BUILD_TESTS =           ${BUILD_TESTS}" )
-message( STATUS "BUILD_GUI =             ${BUILD_GUI}" )
-message( STATUS "WITH_QCHART =           ${WITH_QCHART}" )
-message( STATUS )
-message( STATUS "HAVE_RULES =            ${HAVE_RULES}" )
-message( STATUS )
-message( STATUS "Change a value with: cmake -D<Variable>=<Value>" )
-message( STATUS )
-if(${USE_ANALYZE})
-   message( STATUS "------------------- Run static analyzer ----------------------" )
-   message( STATUS "##############################")
-   message( STATUS "RUN: scan-build make" )
-   message( STATUS "##############################")
-   message( STATUS )
+    message(STATUS "BUILD_SHARED_LIBS =     ${BUILD_SHARED_LIBS}")
+endif()
+message(STATUS "LIBXML2_XMLLINT_EXECUTABLE = ${LIBXML2_XMLLINT_EXECUTABLE}")
+message(STATUS "BUILD_CORE_DLL =        ${BUILD_CORE_DLL}")
+message(STATUS "BUILD_TESTS =           ${BUILD_TESTS}")
+message(STATUS "BUILD_TESTING =         ${BUILD_TESTING}")
+if(BUILD_TESTING)
+    message(STATUS "REGISTER_TESTS =        ${REGISTER_TESTS}")
+endif()
+message(STATUS "ENABLE_CHECK_INTERNAL = ${ENABLE_CHECK_INTERNAL}")
+message(STATUS "DISABLE_DMAKE =         ${DISABLE_DMAKE}")
+message(STATUS "BUILD_MANPAGE =         ${BUILD_MANPAGE}")
+message(STATUS)
+message(STATUS "BUILD_CLI =             ${BUILD_CLI}")
+message(STATUS)
+message(STATUS "BUILD_GUI =             ${BUILD_GUI}")
+if(BUILD_GUI)
+    message(STATUS "REGISTER_GUI_TESTS =    ${REGISTER_GUI_TESTS}")
+    message(STATUS "WITH_QCHART =           ${WITH_QCHART}")
+    message(STATUS "QT_VERSION =            ${QT_VERSION}")
+    message(STATUS "Qt6Core_LIBRARIES =     ${Qt6Core_LIBRARIES}")
+    message(STATUS "Qt6Core_INCLUDE_DIRS =  ${Qt6Core_INCLUDE_DIRS}")
+    if(BUILD_ONLINE_HELP)
+        message(STATUS "QHELPGENERATOR =        ${QHELPGENERATOR}")
+    endif()
+endif()
+message(STATUS)
+message(STATUS "HAVE_RULES =            ${HAVE_RULES}")
+if(HAVE_RULES)
+    message(STATUS "PCRE_LIBRARY =          ${PCRE_LIBRARY}")
+endif()
+message(STATUS)
+message(STATUS "DISALLOW_THREAD_EXECUTOR = ${DISALLOW_THREAD_EXECUTOR}")
+message(STATUS "DISALLOW_PROCESS_EXECUTOR = ${DISALLOW_PROCESS_EXECUTOR}")
+message(STATUS "CMAKE_THREAD_LIBS_INIT = ${CMAKE_THREAD_LIBS_INIT}")
+message(STATUS)
+message(STATUS "USE_BUNDLED_TINYXML2 =  ${USE_BUNDLED_TINYXML2}")
+if(NOT USE_BUNDLED_TINYXML2)
+    if(TARGET tinyxml2::tinyxml2)
+        # TODO: print libraries and include dirs
+    else()
+        message(STATUS "tinyxml2_LIBRARIES =    ${tinyxml2_LIBRARIES}")
+        message(STATUS "tinyxml2_INCLUDE_DIRS = ${tinyxml2_INCLUDE_DIRS}")
+    endif()
+endif()
+message(STATUS)
+message(STATUS "USE_BOOST =             ${USE_BOOST}")
+if(USE_BOOST)
+    message(STATUS "Boost_FOUND =           ${Boost_FOUND}")
+    if(Boost_FOUND)
+        message(STATUS "Boost_VERSION_STRING =  ${Boost_VERSION_STRING}")
+        message(STATUS "Boost_INCLUDE_DIRS =    ${Boost_INCLUDE_DIRS}")
+        message(STATUS "USE_BOOST_INT128 =      ${USE_BOOST_INT128}")
+    endif()
 endif()
+message(STATUS)
+message(STATUS "USE_LIBCXX =            ${USE_LIBCXX}")
+message(STATUS)
+message(STATUS "FILESDIR =              ${FILESDIR}")
+message(STATUS "FILESDIR_DEF =          ${FILESDIR_DEF}")
+message(STATUS)
 
 if(${ANALYZE_ADDRESS})
-   message("##########################################################")
-   message(STATUS "For better visualization change environment variable: ASAN_SYMBOLIZER_PATH=/path/to/llvm-symbolizer")
-   message(STATUS "Detect memory leaks, change environment variable: ASAN_OPTIONS=\"detect_leaks=1\"")
-   message("##########################################################")
+  message("##########################################################")
+  message(STATUS "For better visualization change environment variable: ASAN_SYMBOLIZER_PATH=/path/to/llvm-symbolizer")
+  message("##########################################################")
 endif()
diff --git a/cmake/qtCompat.cmake b/cmake/qtCompat.cmake
new file mode 100644
index 00000000000..bc3e3851440
--- /dev/null
+++ b/cmake/qtCompat.cmake
@@ -0,0 +1,10 @@
+# use "versionless" targets - no need for wrapper functions
+
+set(QT_CORE_LIB Qt::Core)
+set(QT_TEST_LIB Qt::Test)
+set(QT_WIDGETS_LIB Qt::Widgets)
+set(QT_GUI_LIB Qt::Gui)
+set(QT_HELP_LIB Qt::Help)
+set(QT_PRINTSUPPORT_LIB Qt::PrintSupport)
+set(QT_CHARTS_LIB Qt::Charts)
+set(QT_NETWORK_LIB Qt::Network)
diff --git a/cmake/versions.cmake b/cmake/versions.cmake
index b46f97fa6ce..3ff979ecb8f 100644
--- a/cmake/versions.cmake
+++ b/cmake/versions.cmake
@@ -1,10 +1,6 @@
 # Version for libraries CPP
-SET(VERSION "1.89.99")
-STRING(REGEX MATCHALL "[0-9]" VERSION_PARTS "${VERSION}")
-LIST(GET VERSION_PARTS 0 VERSION_MAJOR)
-LIST(GET VERSION_PARTS 1 VERSION_MINOR)
-LIST(GET VERSION_PARTS 2 VERSION_PATCH)
-SET(SOVERSION "${VERSION_MAJOR}.${VERSION_MINOR}")
+# Version string must have 3 "parts". https://sourceforge.net/p/cppcheck/discussion/development/thread/e57efb2b62/
+SET(SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}")
 
 # Postfix of so's:
 SET(DLLVERSION "")
diff --git a/codecov.yml b/codecov.yml
new file mode 100644
index 00000000000..d23dac61ee6
--- /dev/null
+++ b/codecov.yml
@@ -0,0 +1,5 @@
+comment: false
+coverage:
+  status:
+    project: off
+    patch: off
\ No newline at end of file
diff --git a/console_common.pri b/console_common.pri
deleted file mode 100644
index 9937ae5d06f..00000000000
--- a/console_common.pri
+++ /dev/null
@@ -1,23 +0,0 @@
-# console_common.pri
-# These are common definitions for console builds.
-
-win32 {
-    CONFIG += embed_manifest_exe console
-    DEFINES += _CRT_SECURE_NO_WARNINGS
-    LIBS += -lshlwapi
-}
-
-# Add more strict compiling flags for GCC
-contains(QMAKE_CXX, g++) {
-    QMAKE_CXXFLAGS_WARN_ON += -Wextra -pedantic -Wfloat-equal -Wcast-qual -Wlogical-op -Wno-long-long
-}
-
-# Change Visual Studio compiler (CL) warning level to W4
-contains(QMAKE_CXX, cl) {
-    QMAKE_CXXFLAGS_WARN_ON -= -W3
-    QMAKE_CXXFLAGS_WARN_ON += -W4
-}
-
-CONFIG(release, debug|release) {
-    DEFINES += NDEBUG
-}
diff --git a/cppcheck-errors.rng b/cppcheck-errors.rng
index f30945b84a1..ed20228c988 100644
--- a/cppcheck-errors.rng
+++ b/cppcheck-errors.rng
@@ -3,23 +3,20 @@
   <start>
     <element name="results">
       <attribute name="version">
-        <data type="integer"/>
+        <choice>
+          <value type="string">2</value>
+        </choice>
       </attribute>
       <element name="cppcheck">
         <attribute name="version">
-          <data type="string"/>
+          <data type="string">
+            <param name="pattern">[1-9]\.[0-9]+.*</param>
+          </data>
         </attribute>
       </element>
       <element name="errors">
         <zeroOrMore>
           <element name="error">
-            <optional>
-              <attribute name="cwe">
-                <data type="integer">
-                  <param name="minExclusive">0</param>
-                </data>
-              </attribute>
-            </optional>
             <attribute name="id">
               <data type="NCName"/>
             </attribute>
@@ -32,18 +29,39 @@
               <data type="string"/>
             </attribute>
             <attribute name="severity">
-              <data type="NCName"/>
+              <choice>
+                <value type="string">error</value>
+                <value type="string">information</value>
+                <value type="string">performance</value>
+                <value type="string">portability</value>
+                <value type="string">style</value>
+                <value type="string">warning</value>
+              </choice>
             </attribute>
             <attribute name="verbose">
               <data type="string"/>
             </attribute>
+            <optional>
+              <attribute name="file0">
+                <data type="string"/>
+              </attribute>
+            </optional>
+            <optional>
+              <attribute name="cwe">
+                <data type="integer">
+                  <param name="minExclusive">0</param>
+                </data>
+              </attribute>
+            </optional>
+            <optional>
+              <attribute name="hash">
+                <data type="integer">
+                  <param name="minExclusive">1</param>
+                </data>
+              </attribute>
+            </optional>
             <zeroOrMore>
               <element name="location">
-                <optional>
-                  <attribute name="file0">
-                    <data type="string"/>
-                  </attribute>
-                </optional>
                 <attribute name="file">
                   <data type="string"/>
                 </attribute>
diff --git a/cppcheck.cbp b/cppcheck.cbp
deleted file mode 100644
index 041957fa8bc..00000000000
--- a/cppcheck.cbp
+++ /dev/null
@@ -1,222 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
-<CodeBlocks_project_file>
-	<FileVersion major="1" minor="6" />
-	<Project>
-		<Option title="cppcheck" />
-		<Option makefile_is_custom="1" />
-		<Option pch_mode="2" />
-		<Option compiler="gcc" />
-		<Build>
-			<Target title="cppcheck">
-				<Option output="cppcheck" prefix_auto="1" extension_auto="1" />
-				<Option type="1" />
-				<Option compiler="gcc" />
-				<Option parameters="p.cpp --debug --enable=all" />
-				<Compiler>
-					<Add option="-g" />
-				</Compiler>
-			</Target>
-			<Target title="testrunner">
-				<Option output="testrunner" prefix_auto="1" extension_auto="1" />
-				<Option type="1" />
-				<Option compiler="gcc" />
-				<Compiler>
-					<Add option="-g" />
-				</Compiler>
-			</Target>
-		</Build>
-		<Compiler>
-			<Add option="-Wall" />
-			<Add option="-fexceptions" />
-		</Compiler>
-		<Unit filename="cli/cmdlineparser.cpp" />
-		<Unit filename="cli/cmdlineparser.h" />
-		<Unit filename="cli/cppcheckexecutor.cpp" />
-		<Unit filename="cli/cppcheckexecutor.h" />
-		<Unit filename="cli/filelister.cpp" />
-		<Unit filename="cli/filelister.h" />
-		<Unit filename="cli/main.cpp" />
-		<Unit filename="cli/pathmatch.cpp" />
-		<Unit filename="cli/pathmatch.h" />
-		<Unit filename="cli/resource.h" />
-		<Unit filename="cli/threadexecutor.cpp" />
-		<Unit filename="cli/threadexecutor.h" />
-		<Unit filename="gui/aboutdialog.cpp" />
-		<Unit filename="gui/aboutdialog.h" />
-		<Unit filename="gui/application.cpp" />
-		<Unit filename="gui/application.h" />
-		<Unit filename="gui/applicationdialog.cpp" />
-		<Unit filename="gui/applicationdialog.h" />
-		<Unit filename="gui/applicationlist.cpp" />
-		<Unit filename="gui/applicationlist.h" />
-		<Unit filename="gui/checkstatistics.cpp" />
-		<Unit filename="gui/checkstatistics.h" />
-		<Unit filename="gui/checkthread.cpp" />
-		<Unit filename="gui/checkthread.h" />
-		<Unit filename="gui/common.h" />
-		<Unit filename="gui/csvreport.cpp" />
-		<Unit filename="gui/csvreport.h" />
-		<Unit filename="gui/erroritem.cpp" />
-		<Unit filename="gui/erroritem.h" />
-		<Unit filename="gui/filelist.cpp" />
-		<Unit filename="gui/filelist.h" />
-		<Unit filename="gui/fileviewdialog.cpp" />
-		<Unit filename="gui/fileviewdialog.h" />
-		<Unit filename="gui/logview.cpp" />
-		<Unit filename="gui/logview.h" />
-		<Unit filename="gui/main.cpp" />
-		<Unit filename="gui/mainwindow.cpp" />
-		<Unit filename="gui/mainwindow.h" />
-		<Unit filename="gui/platforms.cpp" />
-		<Unit filename="gui/platforms.h" />
-		<Unit filename="gui/project.cpp" />
-		<Unit filename="gui/project.h" />
-		<Unit filename="gui/projectfile.cpp" />
-		<Unit filename="gui/projectfile.h" />
-		<Unit filename="gui/projectfiledialog.cpp" />
-		<Unit filename="gui/projectfiledialog.h" />
-		<Unit filename="gui/report.cpp" />
-		<Unit filename="gui/report.h" />
-		<Unit filename="gui/resultstree.cpp" />
-		<Unit filename="gui/resultstree.h" />
-		<Unit filename="gui/resultsview.cpp" />
-		<Unit filename="gui/resultsview.h" />
-		<Unit filename="gui/settingsdialog.cpp" />
-		<Unit filename="gui/settingsdialog.h" />
-		<Unit filename="gui/showtypes.cpp" />
-		<Unit filename="gui/showtypes.h" />
-		<Unit filename="gui/statsdialog.cpp" />
-		<Unit filename="gui/statsdialog.h" />
-		<Unit filename="gui/test/testtranslationhandler.h" />
-		<Unit filename="gui/test/testxmlreport.h" />
-		<Unit filename="gui/test/testxmlreportv1.h" />
-		<Unit filename="gui/test/testxmlreportv2.h" />
-		<Unit filename="gui/threadhandler.cpp" />
-		<Unit filename="gui/threadhandler.h" />
-		<Unit filename="gui/threadresult.cpp" />
-		<Unit filename="gui/threadresult.h" />
-		<Unit filename="gui/translationhandler.cpp" />
-		<Unit filename="gui/translationhandler.h" />
-		<Unit filename="gui/txtreport.cpp" />
-		<Unit filename="gui/txtreport.h" />
-		<Unit filename="gui/xmlreport.cpp" />
-		<Unit filename="gui/xmlreport.h" />
-		<Unit filename="gui/xmlreportv1.cpp" />
-		<Unit filename="gui/xmlreportv1.h" />
-		<Unit filename="gui/xmlreportv2.cpp" />
-		<Unit filename="gui/xmlreportv2.h" />
-		<Unit filename="lib/check.h" />
-		<Unit filename="lib/check64bit.cpp" />
-		<Unit filename="lib/check64bit.h" />
-		<Unit filename="lib/checkassignif.cpp" />
-		<Unit filename="lib/checkassignif.h" />
-		<Unit filename="lib/checkautovariables.cpp" />
-		<Unit filename="lib/checkautovariables.h" />
-		<Unit filename="lib/checkboost.cpp" />
-		<Unit filename="lib/checkboost.h" />
-		<Unit filename="lib/checkbufferoverrun.cpp" />
-		<Unit filename="lib/checkbufferoverrun.h" />
-		<Unit filename="lib/checkclass.cpp" />
-		<Unit filename="lib/checkclass.h" />
-		<Unit filename="lib/checkexceptionsafety.cpp" />
-		<Unit filename="lib/checkexceptionsafety.h" />
-		<Unit filename="lib/checkmemoryleak.cpp" />
-		<Unit filename="lib/checkmemoryleak.h" />
-		<Unit filename="lib/checknonreentrantfunctions.cpp" />
-		<Unit filename="lib/checknonreentrantfunctions.h" />
-		<Unit filename="lib/checknullpointer.cpp" />
-		<Unit filename="lib/checknullpointer.h" />
-		<Unit filename="lib/checkobsolescentfunctions.cpp" />
-		<Unit filename="lib/checkobsolescentfunctions.h" />
-		<Unit filename="lib/checkother.cpp" />
-		<Unit filename="lib/checkother.h" />
-		<Unit filename="lib/checkpostfixoperator.cpp" />
-		<Unit filename="lib/checkpostfixoperator.h" />
-		<Unit filename="lib/checkstl.cpp" />
-		<Unit filename="lib/checkstl.h" />
-		<Unit filename="lib/checkuninitvar.cpp" />
-		<Unit filename="lib/checkuninitvar.h" />
-		<Unit filename="lib/checkunusedfunctions.cpp" />
-		<Unit filename="lib/checkunusedfunctions.h" />
-		<Unit filename="lib/checkunusedvar.cpp" />
-		<Unit filename="lib/checkunusedvar.h" />
-		<Unit filename="lib/cppcheck.cpp" />
-		<Unit filename="lib/cppcheck.h" />
-		<Unit filename="lib/errorlogger.cpp" />
-		<Unit filename="lib/errorlogger.h" />
-		<Unit filename="lib/mathlib.cpp" />
-		<Unit filename="lib/mathlib.h" />
-		<Unit filename="lib/path.cpp" />
-		<Unit filename="lib/path.h" />
-		<Unit filename="lib/preprocessor.cpp" />
-		<Unit filename="lib/preprocessor.h" />
-		<Unit filename="lib/settings.cpp" />
-		<Unit filename="lib/settings.h" />
-		<Unit filename="lib/standards.h" />
-		<Unit filename="lib/suppressions.cpp" />
-		<Unit filename="lib/suppressions.h" />
-		<Unit filename="lib/symboldatabase.cpp" />
-		<Unit filename="lib/symboldatabase.h" />
-		<Unit filename="lib/templatesimplifier.cpp" />
-		<Unit filename="lib/templatesimplifier.h" />
-		<Unit filename="lib/timer.cpp" />
-		<Unit filename="lib/timer.h" />
-		<Unit filename="lib/token.cpp" />
-		<Unit filename="lib/token.h" />
-		<Unit filename="lib/tokenize.cpp" />
-		<Unit filename="lib/tokenize.h" />
-		<Unit filename="test/options.cpp" />
-		<Unit filename="test/options.h" />
-		<Unit filename="test/redirect.h" />
-		<Unit filename="test/test.cxx" />
-		<Unit filename="test/test64bit.cpp" />
-		<Unit filename="test/testassignif.cpp" />
-		<Unit filename="test/testautovariables.cpp" />
-		<Unit filename="test/testboost.cpp" />
-		<Unit filename="test/testbufferoverrun.cpp" />
-		<Unit filename="test/testcharvar.cpp" />
-		<Unit filename="test/testclass.cpp" />
-		<Unit filename="test/testcmdlineparser.cpp" />
-		<Unit filename="test/testconstructors.cpp" />
-		<Unit filename="test/testcppcheck.cpp" />
-		<Unit filename="test/testdivision.cpp" />
-		<Unit filename="test/testerrorlogger.cpp" />
-		<Unit filename="test/testexceptionsafety.cpp" />
-		<Unit filename="test/testfilelister.cpp" />
-		<Unit filename="test/testfilelister_unix.cpp" />
-		<Unit filename="test/testincompletestatement.cpp" />
-		<Unit filename="test/testmathlib.cpp" />
-		<Unit filename="test/testmemleak.cpp" />
-		<Unit filename="test/testnonreentrantfunctions.cpp" />
-		<Unit filename="test/testnullpointer.cpp" />
-		<Unit filename="test/testobsolescentfunctions.cpp" />
-		<Unit filename="test/testoptions.cpp" />
-		<Unit filename="test/testother.cpp" />
-		<Unit filename="test/testpath.cpp" />
-		<Unit filename="test/testpathmatch.cpp" />
-		<Unit filename="test/testpostfixoperator.cpp" />
-		<Unit filename="test/testpreprocessor.cpp" />
-		<Unit filename="test/testrunner.cpp" />
-		<Unit filename="test/testsimplifytokens.cpp" />
-		<Unit filename="test/teststl.cpp" />
-		<Unit filename="test/testsuite.cpp" />
-		<Unit filename="test/testsuite.h" />
-		<Unit filename="test/testsuppressions.cpp" />
-		<Unit filename="test/testsymboldatabase.cpp" />
-		<Unit filename="test/testthreadexecutor.cpp" />
-		<Unit filename="test/testtoken.cpp" />
-		<Unit filename="test/testtokenize.cpp" />
-		<Unit filename="test/testuninitvar.cpp" />
-		<Unit filename="test/testunusedfunctions.cpp" />
-		<Unit filename="test/testunusedprivfunc.cpp" />
-		<Unit filename="test/testunusedvar.cpp" />
-		<Unit filename="test/testutils.h" />
-		<Unit filename="tools/dmake.cpp" />
-		<Unit filename="tools/extracttests.cpp" />
-		<Extensions>
-			<code_completion />
-			<debugger />
-			<envvars />
-		</Extensions>
-	</Project>
-</CodeBlocks_project_file>
diff --git a/cppcheck.cppcheck b/cppcheck.cppcheck
index 61c38609268..5285223e1b5 100644
--- a/cppcheck.cppcheck
+++ b/cppcheck.cppcheck
@@ -18,6 +18,5 @@
     </paths>
     <exclude>
         <path name="gui/temp/"/>
-        <path name="test/test.cxx"/>
     </exclude>
 </project>
diff --git a/cppcheck.sln b/cppcheck.sln
index a4f55d91896..ca26e06f2bd 100644
--- a/cppcheck.sln
+++ b/cppcheck.sln
@@ -1,82 +1,57 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.29020.237
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cli", "cli\cli.vcxproj", "{35CBDF51-2456-3EC3-99ED-113C30858883}"
-	ProjectSection(ProjectDependencies) = postProject
-		{C183DB5B-AD6C-423D-80CA-1F9549555A1A} = {C183DB5B-AD6C-423D-80CA-1F9549555A1A}
-	EndProjectSection
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testrunner", "test\testrunner.vcxproj", "{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}"
-	ProjectSection(ProjectDependencies) = postProject
-		{C183DB5B-AD6C-423D-80CA-1F9549555A1A} = {C183DB5B-AD6C-423D-80CA-1F9549555A1A}
-	EndProjectSection
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cppcheck", "lib\cppcheck.vcxproj", "{C183DB5B-AD6C-423D-80CA-1F9549555A1A}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
-		Debug|x64 = Debug|x64
-		Debug-PCRE|Win32 = Debug-PCRE|Win32
-		Debug-PCRE|x64 = Debug-PCRE|x64
-		Release|Win32 = Release|Win32
-		Release|x64 = Release|x64
-		Release-PCRE|Win32 = Release-PCRE|Win32
-		Release-PCRE|x64 = Release-PCRE|x64
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{35CBDF51-2456-3EC3-99ED-113C30858883}.Debug|Win32.ActiveCfg = Debug|Win32
-		{35CBDF51-2456-3EC3-99ED-113C30858883}.Debug|Win32.Build.0 = Debug|Win32
-		{35CBDF51-2456-3EC3-99ED-113C30858883}.Debug|x64.ActiveCfg = Debug|x64
-		{35CBDF51-2456-3EC3-99ED-113C30858883}.Debug|x64.Build.0 = Debug|x64
-		{35CBDF51-2456-3EC3-99ED-113C30858883}.Debug-PCRE|Win32.ActiveCfg = Debug-PCRE|Win32
-		{35CBDF51-2456-3EC3-99ED-113C30858883}.Debug-PCRE|Win32.Build.0 = Debug-PCRE|Win32
-		{35CBDF51-2456-3EC3-99ED-113C30858883}.Debug-PCRE|x64.ActiveCfg = Debug-PCRE|x64
-		{35CBDF51-2456-3EC3-99ED-113C30858883}.Debug-PCRE|x64.Build.0 = Debug-PCRE|x64
-		{35CBDF51-2456-3EC3-99ED-113C30858883}.Release|Win32.ActiveCfg = Release|Win32
-		{35CBDF51-2456-3EC3-99ED-113C30858883}.Release|Win32.Build.0 = Release|Win32
-		{35CBDF51-2456-3EC3-99ED-113C30858883}.Release|x64.ActiveCfg = Release|x64
-		{35CBDF51-2456-3EC3-99ED-113C30858883}.Release|x64.Build.0 = Release|x64
-		{35CBDF51-2456-3EC3-99ED-113C30858883}.Release-PCRE|Win32.ActiveCfg = Release-PCRE|Win32
-		{35CBDF51-2456-3EC3-99ED-113C30858883}.Release-PCRE|Win32.Build.0 = Release-PCRE|Win32
-		{35CBDF51-2456-3EC3-99ED-113C30858883}.Release-PCRE|x64.ActiveCfg = Release-PCRE|x64
-		{35CBDF51-2456-3EC3-99ED-113C30858883}.Release-PCRE|x64.Build.0 = Release-PCRE|x64
-		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Debug|Win32.ActiveCfg = Debug|Win32
-		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Debug|Win32.Build.0 = Debug|Win32
-		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Debug|x64.ActiveCfg = Debug|x64
-		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Debug|x64.Build.0 = Debug|x64
-		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Debug-PCRE|Win32.ActiveCfg = Debug|Win32
-		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Debug-PCRE|Win32.Build.0 = Debug|Win32
-		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Debug-PCRE|x64.ActiveCfg = Debug|x64
-		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Debug-PCRE|x64.Build.0 = Debug|x64
-		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Release|Win32.ActiveCfg = Release|Win32
-		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Release|Win32.Build.0 = Release|Win32
-		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Release|x64.ActiveCfg = Release|x64
-		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Release|x64.Build.0 = Release|x64
-		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Release-PCRE|Win32.ActiveCfg = Release|Win32
-		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Release-PCRE|Win32.Build.0 = Release|Win32
-		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Release-PCRE|x64.ActiveCfg = Release|x64
-		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Release-PCRE|x64.Build.0 = Release|x64
-		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Debug|Win32.ActiveCfg = Debug|Win32
-		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Debug|Win32.Build.0 = Debug|Win32
-		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Debug|x64.ActiveCfg = Debug|x64
-		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Debug|x64.Build.0 = Debug|x64
-		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Debug-PCRE|Win32.ActiveCfg = Debug-PCRE|Win32
-		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Debug-PCRE|Win32.Build.0 = Debug-PCRE|Win32
-		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Debug-PCRE|x64.ActiveCfg = Debug-PCRE|x64
-		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Debug-PCRE|x64.Build.0 = Debug-PCRE|x64
-		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Release|Win32.ActiveCfg = Release|Win32
-		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Release|Win32.Build.0 = Release|Win32
-		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Release|x64.ActiveCfg = Release|x64
-		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Release|x64.Build.0 = Release|x64
-		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Release-PCRE|Win32.ActiveCfg = Release-PCRE|Win32
-		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Release-PCRE|Win32.Build.0 = Release-PCRE|Win32
-		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Release-PCRE|x64.ActiveCfg = Release-PCRE|x64
-		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Release-PCRE|x64.Build.0 = Release-PCRE|x64
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.12.35506.116 d17.12
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cli", "cli\cli.vcxproj", "{35CBDF51-2456-3EC3-99ED-113C30858883}"
+	ProjectSection(ProjectDependencies) = postProject
+		{C183DB5B-AD6C-423D-80CA-1F9549555A1A} = {C183DB5B-AD6C-423D-80CA-1F9549555A1A}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testrunner", "test\testrunner.vcxproj", "{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}"
+	ProjectSection(ProjectDependencies) = postProject
+		{C183DB5B-AD6C-423D-80CA-1F9549555A1A} = {C183DB5B-AD6C-423D-80CA-1F9549555A1A}
+	EndProjectSection
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cppcheck", "lib\cppcheck.vcxproj", "{C183DB5B-AD6C-423D-80CA-1F9549555A1A}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug-PCRE|x64 = Debug-PCRE|x64
+		Release|x64 = Release|x64
+		Release-PCRE|x64 = Release-PCRE|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{35CBDF51-2456-3EC3-99ED-113C30858883}.Debug|x64.ActiveCfg = Debug|x64
+		{35CBDF51-2456-3EC3-99ED-113C30858883}.Debug|x64.Build.0 = Debug|x64
+		{35CBDF51-2456-3EC3-99ED-113C30858883}.Debug-PCRE|x64.ActiveCfg = Debug-PCRE|x64
+		{35CBDF51-2456-3EC3-99ED-113C30858883}.Debug-PCRE|x64.Build.0 = Debug-PCRE|x64
+		{35CBDF51-2456-3EC3-99ED-113C30858883}.Release|x64.ActiveCfg = Release|x64
+		{35CBDF51-2456-3EC3-99ED-113C30858883}.Release|x64.Build.0 = Release|x64
+		{35CBDF51-2456-3EC3-99ED-113C30858883}.Release-PCRE|x64.ActiveCfg = Release-PCRE|x64
+		{35CBDF51-2456-3EC3-99ED-113C30858883}.Release-PCRE|x64.Build.0 = Release-PCRE|x64
+		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Debug|x64.ActiveCfg = Debug|x64
+		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Debug|x64.Build.0 = Debug|x64
+		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Debug-PCRE|x64.ActiveCfg = Debug-PCRE|x64
+		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Debug-PCRE|x64.Build.0 = Debug-PCRE|x64
+		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Release|x64.ActiveCfg = Release|x64
+		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Release|x64.Build.0 = Release|x64
+		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Release-PCRE|x64.ActiveCfg = Release-PCRE|x64
+		{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}.Release-PCRE|x64.Build.0 = Release-PCRE|x64
+		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Debug|x64.ActiveCfg = Debug|x64
+		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Debug|x64.Build.0 = Debug|x64
+		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Debug-PCRE|x64.ActiveCfg = Debug-PCRE|x64
+		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Debug-PCRE|x64.Build.0 = Debug-PCRE|x64
+		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Release|x64.ActiveCfg = Release|x64
+		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Release|x64.Build.0 = Release|x64
+		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Release-PCRE|x64.ActiveCfg = Release-PCRE|x64
+		{C183DB5B-AD6C-423D-80CA-1F9549555A1A}.Release-PCRE|x64.Build.0 = Release-PCRE|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {8CB50DEA-06DB-48E8-9C7B-F917494480A1}
+	EndGlobalSection
+EndGlobal
diff --git a/cppcheckpremium-suppressions b/cppcheckpremium-suppressions
new file mode 100644
index 00000000000..6d3f16782bc
--- /dev/null
+++ b/cppcheckpremium-suppressions
@@ -0,0 +1,267 @@
+
+# open source warnings are handled by the selfcheck.yml
+noExplicitConstructor
+postfixOperator
+shadowFunction
+useStlAlgorithm
+normalCheckLevelMaxBranches
+
+###########################################################################################################################
+# Cert C++
+###########################################################################################################################
+
+# False positives for (a?b:c)&=true;
+premium-cert-exp35-c
+# False positives for initializations
+premium-cert-exp45-c
+# False positives when casting to uintptr
+premium-cert-int36-c
+
+# too picky
+premium-cert-arr30-c
+premium-cert-int32-c
+premium-cert-str34-c
+
+# we intentionally pass structs
+premium-cert-dcl39-c-*
+
+# we don't want to check the return values of fclose/sprintf/etc
+premium-cert-err33-c
+
+# TODO: Is there unsafe allocations, in case of exceptions) in cppcheck
+# we have global objects
+premium-cert-err58-cpp
+
+# TODO: Exception objects must be nothrow copy constructible.
+premium-cert-err60-cpp
+
+# TODO should we throw Token?
+premium-cert-err61-cpp
+
+# TODO: Detect errors when converting a string to a number. The library function 'atoi()' shall not be used.
+premium-cert-err62-cpp
+
+# TODO: Can we reduce some const_cast?
+premium-cert-exp55-cpp
+
+
+###########################################################################################################################
+# Misra C++ 2023
+###########################################################################################################################
+
+# There are false positives
+premium-misra-cpp-2023-6.5.1:lib/symboldatabase.cpp
+premium-misra-cpp-2023-6.7.2
+premium-misra-cpp-2023-8.18.2
+# False positives: #13004
+premium-misra-cpp-2023-8.2.7:lib/valueflow.cpp
+premium-misra-cpp-2023-8.2.7:lib/checkclass.cpp
+
+
+# ignored function return value (emplace etc)
+premium-misra-cpp-2023-0.1.2
+
+# TODO use named function arguments
+premium-misra-cpp-2023-0.2.2
+
+# we comment out code by intention in some cases
+premium-misra-cpp-2023-5.7.2
+
+# TODO should we use this rule?
+premium-misra-cpp-2023-5.10.1
+
+# we use octal by intention in lib/color.cpp
+premium-misra-cpp-2023-5.13.2:lib/color.cpp
+
+# we intentionally write numeric constants without suffixes
+premium-misra-cpp-2023-5.13.4
+
+# we declare variables, functions, etc in global namespace by intention
+premium-misra-cpp-2023-6.0.3
+
+# TODO use inline for template functions?
+premium-misra-cpp-2023-6.2.4
+
+# TODO ensure we don't conceal methods in derived classes
+premium-misra-cpp-2023-6.4.2
+
+# Internal linkage using "static" keyword
+premium-misra-cpp-2023-6.5.2
+
+# we use local static variables by intention
+premium-misra-cpp-2023-6.7.1
+
+# Could write good warnings but also has a warning about safe code
+premium-misra-cpp-2023-6.8.3
+
+# FIXME enforce proper ref qualifications
+premium-misra-cpp-2023-6.8.4
+
+# We intentionally use the standard integer types
+premium-misra-cpp-2023-6.9.2
+
+# we have conversion from bool to int by intention
+premium-misra-cpp-2023-7.0.1
+
+# we convert integer to bool by intention
+premium-misra-cpp-2023-7.0.2
+
+# Misra C++ is too pedantic about using character values
+premium-misra-cpp-2023-7.0.3
+
+# signed integer expression in bitwise rhs by intention
+premium-misra-cpp-2023-7.0.4
+
+# integer promotions
+premium-misra-cpp-2023-7.0.5
+
+# sign conversions in assignments by intention
+premium-misra-cpp-2023-7.0.6
+
+# we intentionally have array-to-pointer decay in some function calls
+premium-misra-cpp-2023-7.11.2
+
+# warns when we use callbacks
+premium-misra-cpp-2023-7.11.3
+
+# too picky about operator precedence.
+premium-misra-cpp-2023-8.0.1
+
+# TODO review lambda captures
+premium-misra-cpp-2023-8.1.1
+
+# TODO should we use this rule?
+premium-misra-cpp-2023-8.1.2
+
+# TODO use strchr instead of memchr?
+premium-misra-cpp-2023-8.2.6
+
+# intentional pointer to int conversion in lib/utils.h to output dump files
+premium-misra-cpp-2023-8.2.7:lib/utils.h
+
+# TODO check ellipsis usage
+premium-misra-cpp-2023-8.2.11
+
+# we call functions etc by intention in && || RHS
+premium-misra-cpp-2023-8.14.1
+
+# we use c-style casts by intention
+premium-misra-cpp-2023-8.2.2
+
+# we use const_cast by intention
+premium-misra-cpp-2023-8.2.3
+
+# we use recursion by intention
+premium-misra-cpp-2023-8.2.10
+
+# we separate variable declarations by intention with comma
+premium-misra-cpp-2023-8.19.1
+
+# we leave out {} sometimes
+premium-misra-cpp-2023-9.3.1
+
+# we leave out "else" by intention
+premium-misra-cpp-2023-9.4.1
+
+# looping through linked lists by intention
+premium-misra-cpp-2023-9.5.1
+
+# I believe it warns in some cases where we don't have UB
+premium-misra-cpp-2023-9.5.2
+
+# cppcheck does not understand that __builtin_unreachable() is noreturn
+premium-misra-cpp-2023-9.6.4:lib/utils.h
+
+# we declare multiple variables by intention
+premium-misra-cpp-2023-10.0.1
+
+# we do not define enum type explicitly by intention
+premium-misra-cpp-2023-10.2.1
+
+# TODO we have unscoped enums
+premium-misra-cpp-2023-10.2.2
+
+# we use arrays by intention
+premium-misra-cpp-2023-11.3.1
+
+# we dont initialize variables directly by intention
+premium-misra-cpp-2023-11.6.1
+
+# we have enums where only last constant is initialized by intention
+premium-misra-cpp-2023-11.6.3
+
+# we use unions by intention
+premium-misra-cpp-2023-12.3.1
+
+# TODO ensure overrides match
+premium-misra-cpp-2023-13.3.2
+
+# TODO use the same parameter names in overriden methods.
+premium-misra-cpp-2023-13.3.3
+
+# we sometimes use both public/private data members by intention
+premium-misra-cpp-2023-14.1.1
+
+# TODO should we use this rule?
+premium-misra-cpp-2023-15.0.1
+
+# seems too picky (explicitly calling InferModel and Analyzer base class constructors even though they are defaulted).
+premium-misra-cpp-2023-15.1.2
+
+# TODO use explicit for conversion operator
+premium-misra-cpp-2023-15.1.3
+
+# TODO: should we use this rule?
+premium-misra-cpp-2023-16.6.1
+
+# TODO: should we use this rule?
+premium-misra-cpp-2023-17.8.1
+
+# TODO: should we throw token pointers?
+premium-misra-cpp-2023-18.1.1
+
+# TODO do not throw token pointer?
+premium-misra-cpp-2023-18.3.2:lib/tokenize.cpp
+
+# in smallvector we intentionally put a constant above some preprocessor includes
+premium-misra-cpp-2023-19.0.3:lib/smallvector.h
+
+# code is intentional, should cppcheck premium understand __has_cpp_attribute and compiler defines better?
+premium-misra-cpp-2023-19.1.3:lib/config.h
+
+# we use #/## by intention in some cases
+premium-misra-cpp-2023-19.3.1
+
+# We use #pragma by intention
+premium-misra-cpp-2023-19.6.1
+
+# We use atoi by intention
+premium-misra-cpp-2023-21.2.1
+
+# We use <cstring> functions by intention
+premium-misra-cpp-2023-21.2.2
+
+# We have limited use of std::getenv by intention
+premium-misra-cpp-2023-21.2.3
+
+# Dynamic memory usage in std::string etc
+premium-misra-cpp-2023-21.6.1
+
+# We use new/delete by intention sometimes
+premium-misra-cpp-2023-21.6.2
+
+# TODO use std::make_unique when we require C++14
+premium-misra-cpp-2023-23.11.1
+
+# we use <cctype> by intention
+premium-misra-cpp-2023-24.5.1
+
+# we use std::vector<bool> by intention in lib/infer.cpp but in general it should be avoided
+premium-misra-cpp-2023-26.3.1:lib/infer.cpp
+
+# TODO review that std::move is used properly
+premium-misra-cpp-2023-28.6.1
+
+# we use cstdio by intention
+premium-misra-cpp-2023-30.0.1
+
diff --git a/createrelease b/createrelease
index 1843ba11f43..9dd79333119 100755
--- a/createrelease
+++ b/createrelease
@@ -2,71 +2,133 @@
 #
 # A script for creating release packages. The release packages are create in the home directory.
 #
-# self check:
-# ./cppcheck -D__CPPCHECK__ --library=cppcheck-lib --enable=style --inconclusive --suppress=bitwiseOnBoolean --suppress=shadowFunction --suppress=useStlAlgorithm --suppress=*:externals/picojson.h cli gui/*.cpp lib
-#
-# Update translations
-#   lupdate gui.pro
-#
-# Update copyright year
-# git diff 1.86 | grep '^diff --git a/' | sed 's|.* b/||' | xargs sed -i 's/Copyright (C) 2007-201./Copyright (C) 2007-2019/'
+# Create release candidate
+# ========================
+#
+# Review trac roadmap, are tickets closed properly?
+# Only tickets that should be retargeted should be open.
+#
+# update cppcheck used in premium addon CI
+# create jira issue "CI: update cppcheck binary"
+# cd ~/cppchecksolutions/addon/tools && python3 ci-update-cppcheck.py
+#
+# update mappings..
+# cd ~/cppchecksolutions/addon/coverage
+# CPPCHECK_REPO=~/cppchecksolutions/cppcheck python3 coverage.py --code
+#
+# check every isPremiumEnabled call: TODO write helper script
+# - every id should be in --errorlist
+#   git grep 'isPremiumEnabled[(]"' | sed 's/.*isPremiumEnabled[(]"//' | sed 's/".*//' | sort | uniq > ids1.txt
+#   ./cppcheck --errorlist | grep ' id="' | sed 's/.* id="//' | sed 's/".*//' | sort | uniq > ids2.txt
+#   diff -y ids1.txt ids2.txt
+# - premiumaddon: check coverage.py
+#   python3 coverage.py --id ; sort ids-*.txt | uniq > ~/cppcheck/ids3.txt
+#   diff -y ids2.txt ids3.txt
+#
+# Windows installer:
+# - ensure latest build was successful
+# - ensure cfg files etc are included (win_installer/cppcheck.wxs)
+#
+# self check, fix critical issues:
+# make clean && make CXXOPTS=-O2 MATCHCOMPILER=yes -j4
+# ./cppcheck -D__CPPCHECK__ -D__GNUC__ -DCHECK_INTERNAL -DHAVE_RULES --std=c++11 --library=cppcheck-lib --library=qt --enable=style --inconclusive --inline-suppr --suppress=bitwiseOnBoolean --suppress=shadowFunction --suppress=useStlAlgorithm --suppress=*:externals/picojson.h --suppress=functionConst --suppress=functionStatic --suppress=normalCheckLevelMaxBranches --xml cli gui/*.cpp lib 2> selfcheck.xml
+#
+# Generate lib/checkers.cpp (TODO the premium checkers should not be statically coded)
+# cd ~/cppchecksolutions/cppcheck && python3 tools/get_checkers.py > lib/checkers.cpp
+#
+# Update copyright year TODO release script
+# git diff 2.8 -- */*.cpp */*.h | grep '^diff --git a/' | sed 's|.* b/||' | xargs sed -i 's/Copyright (C) 2007-20[12]./Copyright (C) 2007-2022/'
 # git diff | grep '^diff --git a/'
 #
-# Make sure "cppcheck --errorlist" works. For example with:
-# make test
-# ./cppcheck --errorlist > errlist.xml && xmllint --noout errlist.xml
+# Make sure "cppcheck --errorlist" works:
+# make clean && make -j4 && ./cppcheck --errorlist > errlist.xml && xmllint --noout errlist.xml
 #
 # Update AUTHORS using output from:
-# git log --format='%aN' 1.81..HEAD | sort -u > AUTHORS2 && diff -y AUTHORS AUTHORS2 | less
+# git log --format='%aN' 2.7..HEAD | sort -u > AUTHORS2 && diff -y AUTHORS AUTHORS2 | less
+#
+# Update GUI translations
+# lupdate gui.pro
+#
+# Create 2.18.x branch
+# git checkout -b 2.18.x ; git push -u origin 2.18.x
+# in fork:
+#  * add upstream: git remote add upstream git@github.com:danmar/cppcheck.git
+#  * add branch:   git fetch upstream 2.19.x
+#
+# Release notes:
+# - ensure safety critical issues are listed properly
+# - empty the releasenotes.txt in main branch
 #
 # Update version numbers in:
-# sed -i "s/1.[0-9][0-9].99/1.89/" cli/main.cpp
-# sed -i "s/1.[0-9][0-9].99/1.89/" cmake/versions.cmake
-# sed -i "s/MINOR [0-9][0-9]/MINOR 89/" lib/version.h
-# sed -i "s/1.[0-9][0-9] dev/1.89/" win_installer/productInfo.wxi
-# sed -i "s/1.[0-9][0-9].99/1.89/" win_installer/productInfo.wxi
-# sed -i "s/Version 1.[0-9][0-9]/Version 1.89/" */*.md
+# python3 tools/release-set-version.py 2.19.0
 # Verify:
 # grep '\.99' */*.[ch]* && grep '[0-9][0-9] dev' */*.[ch]*
-# git commit -a -m "1.43: Set versions"
+# egrep "2\.[0-9]+" */*.h */*.cpp man/*.md | grep -v "test/test" | less
+# git commit -a -m "2.8: Set versions"
+#
+# Build and test the windows installer
 #
 # Update the Makefile:
 # make dmake && ./dmake --release
-# git commit -a -m "1.43: Updated Makefile"
+# git commit -a -m "2.8: Updated Makefile"
 #
-# Build and test the windows installer
+# Ensure that CI is happy
 #
 # Tag:
-# git tag 1.43
+# git tag 2.8-rc1
 # git push --tags
 #
+# Release
+# =======
+#
+# Remove "-rc1" from versions. Test: git grep "\-rc[0-9]"
+#
 # Create a release folder on sourceforge:
 # https://sourceforge.net/projects/cppcheck/files/cppcheck/
 #
-# Create release:
-# ./createrelease 1.43
+# git tag 2.8 ; git push --tags
+# ./createrelease 2.8
 #
-# Restore the Makefile:
-# make dmake && ./dmake
-# git commit -a -m "Makefile: Set debug mode"
+# copy msi from release-windows, install and test cppcheck
+# copy manual from build-manual
 #
 # Update download link on index.php main page
 #
+# Trac:
+# 1. Create ticket "2.18 safety cosmetic changes"
+#    git log --format=oneline 2.17.0..HEAD | egrep -v "^[0-9a-f]*[ ][ ]*([Ff]ix|fixed|Fixup|Fixes|refs)?[ ]*#*[0-9]+"
+# 2. Check priorities for all tickets in milestone. Should be: safety-*
+# 3. Create new milestone
+# 4. Close old milestone
 #
 # write a news
 #
-# save "cppcheck --doc" output on wiki, write new release date on wikis
+# save "cppcheck --doc" output on wiki
 #
 # compile new democlient:
 # ssh -t danielmarjamaki,cppcheck@shell.sourceforge.net create
-# ./build-cppcheck.sh 1.43
+# ./build-cppcheck.sh
+#
+# create a ticket with data from http://cppcheck1.osuosl.org:8000/time_gt.html for performance tracking
+# (example: https://trac.cppcheck.net/ticket/13715)
+# - type: defect
+# - component: Performance
+# - summary: [meta] performance regressions in 2.x
 #
 # run daca with new release
-# 1. edit OLD_VERSION
-# 2. scp tools/donate-cpu-server.py danielmarjamaki@cppcheck.osuosl.org:daca@home/
+# 1. edit tools/donate-cpu-server.py. Update OLD_VERSION and SERVER_VERSION
+# 2. scp -i ~/.ssh/osuosl_id_rsa tools/donate-cpu-server.py danielmarjamaki@cppcheck1.osuosl.org:/var/daca@home/
+#
+# Backup:
+# * trac: cd /var && nice tar -cJf ~/trac.tar.xz trac-cppcheck/db/trac.db
+# * daca: cd /var && nice tar -cJf ~/daca.tar.xz daca@home
+# * git: git checkout -f && git checkout main && git pull && tar -cJf git.tar.xz .git
+# * git log 2.16.0..2.17.0 > Changelog
+# * mkdir out && python3 ~/cppchecksolutions/release/getWorkflowAndIssueLogs.py -r danmar/cppcheck -t 2.15.0 -p out
 
-# Tag to use
-tag=$1
+# Folder/tag to use
+folder=$1
+tag=$folder.0
 
 # Name of release
 releasename=cppcheck-$tag
@@ -75,32 +137,39 @@ set -e
 
 cd ~/cppcheck
 
-mkdir upload
+git checkout $tag
 
-# Create archives..
-git archive --format=tar --prefix=$releasename/ $tag | gzip > upload/$releasename.tar.gz
-git archive --format=tar --prefix=$releasename/ $tag | bzip2 > upload/$releasename.tar.bz2
-git archive --format=zip -9 --prefix=$releasename/ $tag > upload/$releasename.zip
-cd upload
-wget https://www.pkeus.de/~philipp/Temp/$releasename-x64-Setup.msi
-#wget https://www.pkeus.de/~philipp/Temp/$releasename-x86-Setup.msi
-scp $releasename.* danielmarjamaki,cppcheck@frs.sourceforge.net:/home/frs/project/c/cp/cppcheck/cppcheck/$tag/
-rm $releasename.*
-cd ..
+rm -rf upload
+mkdir -p upload/htdocs upload/frs
 
-# Generate the manual.pdf, manual.html and version.txt
-make -j4
-./cppcheck --version > upload/version.txt
-cd ~/cppcheck/man
-./buildman.sh
-mv manual.pdf ../upload/
-mv manual.html ../upload/
-mv reference-cfg-format.pdf ../upload/
-mv reference-cfg-format.html ../upload/
+# htdocs
+make clean
+make -j12
+rm -f cppcheck.cfg
+./cppcheck --version > upload/htdocs/version.txt
+# TODO manual, update version on webpage
 
-cd ~/cppcheck/upload
-scp * danielmarjamaki,cppcheck@web.sourceforge.net:htdocs/
+# frs
+git archive --format=tar --prefix=$releasename/ $tag | gzip > upload/frs/$releasename.tar.gz
+git archive --format=tar --prefix=$releasename/ $tag | bzip2 > upload/frs/$releasename.tar.bz2
+git archive --format=zip -9 --prefix=$releasename/ $tag > upload/frs/$releasename.zip
+cp releasenotes.txt upload/frs/README.md
+# TODO msi
 
-cd ~/cppcheck
+cd upload
+scp frs/* danielmarjamaki,cppcheck@frs.sourceforge.net:/home/frs/project/c/cp/cppcheck/cppcheck/$folder/
+scp htdocs/* danielmarjamaki,cppcheck@web.sourceforge.net:htdocs/
+cd ..
 rm -rf upload
 
+# Local cppcheck binary
+mkdir -p ~/.cppcheck/$tag
+cd ~/.cppcheck/$tag
+cp -R ~/cppcheck/cfg .
+cp -R ~/cppcheck/addons .
+cp -R ~/cppcheck/platforms .
+cd ~/cppcheck
+make clean ; make -j12 FILESDIR=~/.cppcheck/$tag MATCHCOMPILER=yes CXXOPTS=-O2
+mv cppcheck ~/.cppcheck/cppcheck-$tag
+
+git checkout main
diff --git a/cve-test-suite/cve-2018-1000618.cpp b/cve-test-suite/cve-2018-1000618.cpp
deleted file mode 100644
index 50c7f0e8beb..00000000000
--- a/cve-test-suite/cve-2018-1000618.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-
-// Reduced source code. Inspired by this fix:
-// https://github.com/EOSIO/eos/pull/4112/commits/ef62761c5e388880e8bb1bb41e8b512a5187f255
-
-#include <set>
-
-class C
-{
-    std::set<int> typedefs;
-    bool is_type(int type) const
-    {
-        if (typedefs.find(type) != typedefs.end())
-            return is_type(type); // BUG: endless recursion
-        return false;
-    }
-};
diff --git a/cve-test-suite/cve-2018-11360.c b/cve-test-suite/cve-2018-11360.c
deleted file mode 100644
index c7de11b10a0..00000000000
--- a/cve-test-suite/cve-2018-11360.c
+++ /dev/null
@@ -1,15 +0,0 @@
-
-// CVE: CVE-2018-6836
-// This is a simplified code example based on CVE-2018-11360.
-
-void *malloc(unsigned long);
-void free(void *);
-
-void f(int size)
-{
-    char *ia5_string = malloc(size); // Hint: Off by one
-    for (int i = 0; i <= size; i++)
-        ia5_string[i]=0; // BUG
-    free(ia5_string);
-}
-
diff --git a/cve-test-suite/cve-2018-5334.c b/cve-test-suite/cve-2018-5334.c
deleted file mode 100644
index 82f3eff4a39..00000000000
--- a/cve-test-suite/cve-2018-5334.c
+++ /dev/null
@@ -1,9 +0,0 @@
-
-// CVE-2018-5334
-
-#define LEN  100
-
-void f(const int *m_ptr, int sig_off, int rec_size)
-{
-  if (m_ptr[sig_off] == 0xdd && (sig_off + 15 <= (rec_size - LEN))) {}
-}
diff --git a/cve-test-suite/cve-2018-6836.c b/cve-test-suite/cve-2018-6836.c
deleted file mode 100644
index 5331e131d88..00000000000
--- a/cve-test-suite/cve-2018-6836.c
+++ /dev/null
@@ -1,30 +0,0 @@
-// Bug: free uninitialized pointer
-// Fix: https://code.wireshark.org/review/gitweb?p=wireshark.git;a=commit;h=28960d79cca262ac6b974f339697b299a1e28fef
-
-void *malloc(unsigned long);
-void free(void *);
-
-struct comment {
-  int *data;
-};
-
-struct table {
-  struct comment *com;
-};
-
-void destroy_table(struct table *comment_table)
-{
-    free(comment_table->com->data);
-    free(comment_table->com);
-    free(comment_table);
-}
-
-void f()
-{
-    struct table *comment_table = (struct table *)malloc(sizeof(struct table));
-    struct comment *comment_rec = (struct comment *)malloc(sizeof(struct comment));
-    comment_table->com = comment_rec;
-    destroy_table(comment_table);
-}
-
-
diff --git a/cve-test-suite/download.sh b/cve-test-suite/download.sh
deleted file mode 100755
index 8e6e4ff4e43..00000000000
--- a/cve-test-suite/download.sh
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/bin/bash
-# Fetch CVE issues that are interesting to look at
-
-echo "CVE" > cve.txt
-
-for i in `seq 1 20`;
-do
-  echo "page $i"
-  # CVE 119 issues:
-  # https://www.cvedetails.com/vulnerability-list/cweid-119/vulnerabilities.html
-  # Use curl to get page $i:
-  curl -s "https://www.cvedetails.com/vulnerability-list.php?vendor_id=0&product_id=0&version_id=0&page=$i&hasexp=0&opdos=0&opec=0&opov=0&opcsrf=0&opgpriv=0&opsqli=0&opxss=0&opdirt=0&opmemc=0&ophttprs=0&opbyp=0&opfileinc=0&opginf=0&cvssscoremin=0&cvssscoremax=0&year=0&month=0&cweid=119&order=1&trc=11185&sha=a76f56dbb935840fc028b135d550322223547356" > v.html
-
-  # for each cve:
-  for cve in $(grep /cve/CVE-2018- v.html | sed 's|.*/cve/CVE-2018-\([0-9]*\).*|CVE-2018-\1|'); do
-    echo "$cve" >> cve.txt
-    curl -s "https://www.cvedetails.com/cve/$cve/" > download-cve
-    # cve type
-    cat download-cve | grep '>Overflow<' >> cve.txt
-    # is there a code reference?
-    cat download-cve | grep 'https*://.*[a-f0-9]\{30,50\}' | sed 's|.*\(https*://[^ ]*[a-f0-9]\{30,\}\).*|\1|' >> cve.txt
-    # is there a pull request reference?
-    cat download-cve | grep 'https*://github.com/[^ ]*/pull/' | sed 's|.*\(https*://github.com/[^ ]*\).*|\1|' >> cve.txt
-  done
-done
-
-rm v.html
-rm download-cve
-
-
-
diff --git a/cve-test-suite/readme.txt b/cve-test-suite/readme.txt
deleted file mode 100644
index 479b11dbafb..00000000000
--- a/cve-test-suite/readme.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-
-Background
-==========
-The CVE database contains known vulnerabilities in various source code projects. For instance, to list known "overflow" vulnerabilities, this link can be used:
-https://www.cvedetails.com/vulnerability-list/cweid-119/vulnerabilities.html
-
-Many issues in the CVE database are "out of reach" for static analysis because of required domain knowledge etc.
-
-However there are also issues that could be "possible" to detect with static analysis.
-
-For each such issue that we see that we think is "possible" to detect with static analysis, we can create a file in this folder. The filename is the CVE id. The contents of the file should contain this info:
- * Recommended: URL that can be used to download source code, file with bug
- * Description
- * Reduced example code. The code should be plain C/C++ without dependencies.
-
-Possible usages:
-================
-The test cases can inspire future Cppcheck development.
-
-These files could be used for a quick and easy tool evaluation. For Cppcheck and other tools. Because only plain C/C++ is used, tools should have all info they need, so hopefully no extra configuration is needed.
-
-An extended tool evaluation can use the real source code. It's possible to lookup the real source code using the CWE id. However in such tool evaluation, the tools must be configured properly.
diff --git a/democlient/build.sh b/democlient/build.sh
index 86f2ac35cbb..51364fe069e 100755
--- a/democlient/build.sh
+++ b/democlient/build.sh
@@ -16,7 +16,7 @@ rm cppcheck-$1.tar.bz2
 rm cppcheck-$1/Changelog
 
 echo Building...
-g++ -O2 -o democlient-$1.cgi -I$cppchecklib -Icppcheck-$1/externals/tinyxml cppcheck-$1/democlient/democlient.cpp $cppchecklib/*.cpp cppcheck-$1/externals/tinyxml/tinyxml2.cpp
+g++ -O2 -o democlient-$1.cgi -I$cppchecklib -Icppcheck-$1/externals/tinyxml2 cppcheck-$1/democlient/democlient.cpp $cppchecklib/*.cpp cppcheck-$1/externals/tinyxml2/tinyxml2.cpp
 
 echo Copy cgi to webspace...
 cp democlient-$1.cgi /home/project-web/cppcheck/cgi-bin/democlient.cgi
diff --git a/democlient/democlient.cpp b/democlient/democlient.cpp
index 6308e407375..8560596f4f3 100644
--- a/democlient/democlient.cpp
+++ b/democlient/democlient.cpp
@@ -1,11 +1,39 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "cppcheck.h"
+#include "errorlogger.h"
+#include "errortypes.h"
+#include "filesettings.h"
+#include "settings.h"
+#include "suppressions.h"
+#include "version.h"
+
+#include <algorithm>
 #include <ctime>
+#include <cstdint>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <iostream>
+#include <string>
 
-#include "cppcheck.h"
-#include "version.h"
+enum class Color : std::uint8_t;
 
 static void unencode(const char *src, char *dest)
 {
@@ -29,37 +57,38 @@ static FILE *logfile = nullptr;
 class CppcheckExecutor : public ErrorLogger {
 private:
     const std::time_t stoptime;
+    Suppressions supprs;
     CppCheck cppcheck;
 
 public:
-    CppcheckExecutor()
-        : ErrorLogger()
-        , stoptime(std::time(nullptr)+2U)
-        , cppcheck(*this, false) {
-        cppcheck.settings().addEnabled("all");
-        cppcheck.settings().inconclusive = true;
-    }
+    CppcheckExecutor(const Settings& settings)
+        : stoptime(std::time(nullptr)+2U)
+        , cppcheck(settings, supprs, *this, nullptr, false, nullptr)
+    {}
 
-    void run(const char code[]) {
-        cppcheck.check("test.cpp", code);
+    void run(const char* code) {
+        cppcheck.checkBuffer(FileWithDetails("test.cpp", Standards::Language::CPP, 0), code, strlen(code));
     }
 
-    void reportOut(const std::string &outmsg) override { }
-    void reportErr(const ErrorLogger::ErrorMessage &msg) override {
-        const std::string s = msg.toString(true);
+    void reportOut(const std::string & /*outmsg*/, Color /*c*/) override {}
+    void reportErr(const ErrorMessage &msg) override {
+        static const std::string templateFormat = "{bold}{file}:{line}:{column}: {red}{inconclusive:{magenta}}{severity}:{inconclusive: inconclusive:}{default} {message} [{id}]{reset}\\n{code}";
+        static const std::string templateLocation = "{bold}{file}:{line}:{column}: {dim}note:{reset} {info}\\n{code}";
+        const std::string s = msg.toString(true, templateFormat, templateLocation);
 
         std::cout << s << std::endl;
 
         if (logfile != nullptr)
             std::fprintf(logfile, "%s\n", s.c_str());
     }
+    void reportMetric(const std::string & /*metric*/) override {}
 
-    void reportProgress(const std::string& filename,
-                        const char stage[],
-                        const std::size_t value) override {
+    void reportProgress(const std::string& /*filename*/,
+                        const char /*stage*/[],
+                        const std::size_t /*value*/) override {
         if (std::time(nullptr) >= stoptime) {
             std::cout << "Time to analyse the code exceeded 2 seconds. Terminating.\n\n";
-            cppcheck.terminate();
+            Settings::terminate();
         }
     }
 };
@@ -100,7 +129,10 @@ int main()
 
     std::cout << "<html><body>Cppcheck " CPPCHECK_VERSION_STRING "<pre>";
 
-    CppcheckExecutor cppcheckExecutor;
+    Settings s;
+    s.addEnabled("all");
+    s.certainty.enable(Certainty::inconclusive);
+    CppcheckExecutor cppcheckExecutor(s);
     cppcheckExecutor.run(code);
 
     std::fclose(logfile);
diff --git a/externals/.clang-tidy b/externals/.clang-tidy
new file mode 100644
index 00000000000..45892f90258
--- /dev/null
+++ b/externals/.clang-tidy
@@ -0,0 +1,5 @@
+---
+Checks:          '-*,misc-definitions-in-headers'
+WarningsAsErrors: '*'
+CheckOptions:
+  - { key: HeaderFileExtensions,          value: "x" }
diff --git a/externals/externals.pri b/externals/externals.pri
deleted file mode 100644
index 7f0be8de3a9..00000000000
--- a/externals/externals.pri
+++ /dev/null
@@ -1,9 +0,0 @@
-INCLUDEPATH += $${PWD} \
-               $${PWD}/simplecpp \
-               $${PWD}/tinyxml
-
-HEADERS += $${PWD}/simplecpp/simplecpp.h \
-           $${PWD}/tinyxml/tinyxml2.h
-
-SOURCES += $${PWD}/simplecpp/simplecpp.cpp \
-           $${PWD}/tinyxml/tinyxml2.cpp
diff --git a/externals/pcre.patch b/externals/pcre.patch
new file mode 100644
index 00000000000..bf23435c934
--- /dev/null
+++ b/externals/pcre.patch
@@ -0,0 +1,12 @@
+diff -urN pcre/CMakeLists.txt pcre-8.45/CMakeLists.txt
+--- pcre/CMakeLists.txt	2021-11-05 13:28:16.000000000 +0100
++++ pcre-8.45/CMakeLists.txt	2025-04-02 10:18:49.636009900 +0200
+@@ -77,7 +77,7 @@
+ # CMP0026 to avoid warnings for the use of LOCATION in GET_TARGET_PROPERTY.
+ 
+ CMAKE_MINIMUM_REQUIRED(VERSION 2.8.5)
+-CMAKE_POLICY(SET CMP0026 OLD)
++#CMAKE_POLICY(SET CMP0026 OLD)
+ 
+ # For FindReadline.cmake. This was changed to allow setting CMAKE_MODULE_PATH
+ # on the command line.
diff --git a/externals/picojson.h b/externals/picojson.h
deleted file mode 100644
index 48bb64e6723..00000000000
--- a/externals/picojson.h
+++ /dev/null
@@ -1,1010 +0,0 @@
-/*
- * Copyright 2009-2010 Cybozu Labs, Inc.
- * Copyright 2011-2014 Kazuho Oku
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- *    this list of conditions and the following disclaimer in the documentation
- *    and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-#ifndef picojson_h
-#define picojson_h
-
-#include <algorithm>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-#include <iterator>
-#include <limits>
-#include <map>
-#include <stdexcept>
-#include <string>
-#include <vector>
-
-// for isnan/isinf
-#if __cplusplus>=201103L
-# include <cmath>
-#else
-extern "C" {
-# ifdef _MSC_VER
-#  include <float.h>
-# elif defined(__INTEL_COMPILER)
-#  include <mathimf.h>
-# else
-#  include <math.h>
-# endif
-}
-#endif
-
-// experimental support for int64_t (see README.mkdn for detail)
-#ifdef PICOJSON_USE_INT64
-# define __STDC_FORMAT_MACROS
-# include <errno.h>
-# include <inttypes.h>
-#endif
-
-// to disable the use of localeconv(3), set PICOJSON_USE_LOCALE to 0
-#ifndef PICOJSON_USE_LOCALE
-# define PICOJSON_USE_LOCALE 1
-#endif
-#if PICOJSON_USE_LOCALE
-extern "C" {
-# include <locale.h>
-}
-#endif
-
-#ifndef PICOJSON_ASSERT
-# define PICOJSON_ASSERT(e) do { if (! (e)) throw std::runtime_error(#e); } while (0)
-#endif
-
-#ifdef _MSC_VER
-    #define SNPRINTF _snprintf_s
-    #pragma warning(push)
-    #pragma warning(disable : 4244) // conversion from int to char
-    #pragma warning(disable : 4127) // conditional expression is constant
-    #pragma warning(disable : 4702) // unreachable code
-#else
-    #define SNPRINTF snprintf
-#endif
-
-namespace picojson {
-  
-  enum {
-    null_type,
-    boolean_type,
-    number_type,
-    string_type,
-    array_type,
-    object_type
-#ifdef PICOJSON_USE_INT64
-    , int64_type
-#endif
-  };
-  
-  enum {
-    INDENT_WIDTH = 2
-  };
-
-  struct null {};
-  
-  class value {
-  public:
-    typedef std::vector<value> array;
-    typedef std::map<std::string, value> object;
-    union _storage {
-      bool boolean_;
-      double number_;
-#ifdef PICOJSON_USE_INT64
-      int64_t int64_;
-#endif
-      std::string* string_;
-      array* array_;
-      object* object_;
-    };
-  protected:
-    int type_;
-    _storage u_;
-  public:
-    value();
-    value(int type, bool);
-    explicit value(bool b);
-#ifdef PICOJSON_USE_INT64
-    explicit value(int64_t i);
-#endif
-    explicit value(double n);
-    explicit value(const std::string& s);
-    explicit value(const array& a);
-    explicit value(const object& o);
-    explicit value(const char* s);
-    value(const char* s, size_t len);
-    ~value();
-    value(const value& x);
-    value& operator=(const value& x);
-    void swap(value& x);
-    template <typename T> bool is() const;
-    template <typename T> const T& get() const;
-    template <typename T> T& get();
-    bool evaluate_as_boolean() const;
-    const value& get(size_t idx) const;
-    const value& get(const std::string& key) const;
-    value& get(size_t idx);
-    value& get(const std::string& key);
-
-    bool contains(size_t idx) const;
-    bool contains(const std::string& key) const;
-    std::string to_str() const;
-    template <typename Iter> void serialize(Iter os, bool prettify = false) const;
-    std::string serialize(bool prettify = false) const;
-  private:
-    template <typename T> value(const T*); // intentionally defined to block implicit conversion of pointer to bool
-    template <typename Iter> static void _indent(Iter os, int indent);
-    template <typename Iter> void _serialize(Iter os, int indent) const;
-    std::string _serialize(int indent) const;
-  };
-  
-  typedef value::array array;
-  typedef value::object object;
-  
-  inline value::value() : type_(null_type) {}
-  
-  inline value::value(int type, bool) : type_(type) {
-    switch (type) {
-#define INIT(p, v) case p##type: u_.p = v; break
-      INIT(boolean_, false);
-      INIT(number_, 0.0);
-#ifdef PICOJSON_USE_INT64
-      INIT(int64_, 0);
-#endif
-      INIT(string_, new std::string());
-      INIT(array_, new array());
-      INIT(object_, new object());
-#undef INIT
-    default: break;
-    }
-  }
-  
-  inline value::value(bool b) : type_(boolean_type) {
-    u_.boolean_ = b;
-  }
-
-#ifdef PICOJSON_USE_INT64
-  inline value::value(int64_t i) : type_(int64_type) {
-    u_.int64_ = i;
-  }
-#endif
-
-  inline value::value(double n) : type_(number_type) {
-    if (
-#ifdef _MSC_VER
-        ! _finite(n)
-#elif __cplusplus>=201103L || !(defined(isnan) && defined(isinf))
-		std::isnan(n) || std::isinf(n)
-#else
-        isnan(n) || isinf(n)
-#endif
-        ) {
-      throw std::overflow_error("");
-    }
-    u_.number_ = n;
-  }
-  
-  inline value::value(const std::string& s) : type_(string_type) {
-    u_.string_ = new std::string(s);
-  }
-  
-  inline value::value(const array& a) : type_(array_type) {
-    u_.array_ = new array(a);
-  }
-  
-  inline value::value(const object& o) : type_(object_type) {
-    u_.object_ = new object(o);
-  }
-  
-  inline value::value(const char* s) : type_(string_type) {
-    u_.string_ = new std::string(s);
-  }
-  
-  inline value::value(const char* s, size_t len) : type_(string_type) {
-    u_.string_ = new std::string(s, len);
-  }
-  
-  inline value::~value() {
-    switch (type_) {
-#define DEINIT(p) case p##type: delete u_.p; break
-      DEINIT(string_);
-      DEINIT(array_);
-      DEINIT(object_);
-#undef DEINIT
-    default: break;
-    }
-  }
-  
-  inline value::value(const value& x) : type_(x.type_) {
-    switch (type_) {
-#define INIT(p, v) case p##type: u_.p = v; break
-      INIT(string_, new std::string(*x.u_.string_));
-      INIT(array_, new array(*x.u_.array_));
-      INIT(object_, new object(*x.u_.object_));
-#undef INIT
-    default:
-      u_ = x.u_;
-      break;
-    }
-  }
-  
-  inline value& value::operator=(const value& x) {
-    if (this != &x) {
-      value t(x);
-      swap(t);
-    }
-    return *this;
-  }
-  
-  inline void value::swap(value& x) {
-    std::swap(type_, x.type_);
-    std::swap(u_, x.u_);
-  }
-  
-#define IS(ctype, jtype)			     \
-  template <> inline bool value::is<ctype>() const { \
-    return type_ == jtype##_type;		     \
-  }
-  IS(null, null)
-  IS(bool, boolean)
-#ifdef PICOJSON_USE_INT64
-  IS(int64_t, int64)
-#endif
-  IS(std::string, string)
-  IS(array, array)
-  IS(object, object)
-#undef IS
-  template <> inline bool value::is<double>() const {
-    return type_ == number_type
-#ifdef PICOJSON_USE_INT64
-      || type_ == int64_type
-#endif
-      ;
-  }
-  
-#define GET(ctype, var)						\
-  template <> inline const ctype& value::get<ctype>() const {	\
-    PICOJSON_ASSERT("type mismatch! call is<type>() before get<type>()" \
-	   && is<ctype>());				        \
-    return var;							\
-  }								\
-  template <> inline ctype& value::get<ctype>() {		\
-    PICOJSON_ASSERT("type mismatch! call is<type>() before get<type>()"	\
-	   && is<ctype>());					\
-    return var;							\
-  }
-  GET(bool, u_.boolean_)
-  GET(std::string, *u_.string_)
-  GET(array, *u_.array_)
-  GET(object, *u_.object_)
-#ifdef PICOJSON_USE_INT64
-  GET(double, (type_ == int64_type && (const_cast<value*>(this)->type_ = number_type, const_cast<value*>(this)->u_.number_ = u_.int64_), u_.number_))
-  GET(int64_t, u_.int64_)
-#else
-  GET(double, u_.number_)
-#endif
-#undef GET
-  
-  inline bool value::evaluate_as_boolean() const {
-    switch (type_) {
-    case null_type:
-      return false;
-    case boolean_type:
-      return u_.boolean_;
-    case number_type:
-      return u_.number_ != 0;
-    case string_type:
-      return ! u_.string_->empty();
-    default:
-      return true;
-    }
-  }
-  
-  inline const value& value::get(size_t idx) const {
-    static value s_null;
-    PICOJSON_ASSERT(is<array>());
-    return idx < u_.array_->size() ? (*u_.array_)[idx] : s_null;
-  }
-
-  inline value& value::get(size_t idx) {
-    static value s_null;
-    PICOJSON_ASSERT(is<array>());
-    return idx < u_.array_->size() ? (*u_.array_)[idx] : s_null;
-  }
-
-  inline const value& value::get(const std::string& key) const {
-    static value s_null;
-    PICOJSON_ASSERT(is<object>());
-    object::const_iterator i = u_.object_->find(key);
-    return i != u_.object_->end() ? i->second : s_null;
-  }
-
-  inline value& value::get(const std::string& key) {
-    static value s_null;
-    PICOJSON_ASSERT(is<object>());
-    object::iterator i = u_.object_->find(key);
-    return i != u_.object_->end() ? i->second : s_null;
-  }
-
-  inline bool value::contains(size_t idx) const {
-    PICOJSON_ASSERT(is<array>());
-    return idx < u_.array_->size();
-  }
-
-  inline bool value::contains(const std::string& key) const {
-    PICOJSON_ASSERT(is<object>());
-    object::const_iterator i = u_.object_->find(key);
-    return i != u_.object_->end();
-  }
-  
-  inline std::string value::to_str() const {
-    switch (type_) {
-    case null_type:      return "null";
-    case boolean_type:   return u_.boolean_ ? "true" : "false";
-#ifdef PICOJSON_USE_INT64
-    case int64_type: {
-      char buf[sizeof("-9223372036854775808")];
-      SNPRINTF(buf, sizeof(buf), "%" PRId64, u_.int64_);
-      return buf;
-    }
-#endif
-    case number_type:    {
-      char buf[256];
-      double tmp;
-      SNPRINTF(buf, sizeof(buf), fabs(u_.number_) < (1ULL << 53) && modf(u_.number_, &tmp) == 0 ? "%.f" : "%.17g", u_.number_);
-#if PICOJSON_USE_LOCALE
-      char *decimal_point = localeconv()->decimal_point;
-      if (strcmp(decimal_point, ".") != 0) {
-        size_t decimal_point_len = strlen(decimal_point);
-        for (char *p = buf; *p != '\0'; ++p) {
-          if (strncmp(p, decimal_point, decimal_point_len) == 0) {
-            return std::string(buf, p) + "." + (p + decimal_point_len);
-          }
-        }
-      }
-#endif
-      return buf;
-    }
-    case string_type:    return *u_.string_;
-    case array_type:     return "array";
-    case object_type:    return "object";
-    default:             PICOJSON_ASSERT(0);
-#ifdef _MSC_VER
-      __assume(0);
-#endif
-    }
-    return std::string();
-  }
-  
-  template <typename Iter> void copy(const std::string& s, Iter oi) {
-    std::copy(s.begin(), s.end(), oi);
-  }
-  
-  template <typename Iter> void serialize_str(const std::string& s, Iter oi) {
-    *oi++ = '"';
-    for (std::string::const_iterator i = s.begin(); i != s.end(); ++i) {
-      switch (*i) {
-#define MAP(val, sym) case val: copy(sym, oi); break
-	MAP('"', "\\\"");
-	MAP('\\', "\\\\");
-	MAP('/', "\\/");
-	MAP('\b', "\\b");
-	MAP('\f', "\\f");
-	MAP('\n', "\\n");
-	MAP('\r', "\\r");
-	MAP('\t', "\\t");
-#undef MAP
-      default:
-	if (static_cast<unsigned char>(*i) < 0x20 || *i == 0x7f) {
-	  char buf[7];
-	  SNPRINTF(buf, sizeof(buf), "\\u%04x", *i & 0xff);
-	  copy(buf, buf + 6, oi);
-	  } else {
-	  *oi++ = *i;
-	}
-	break;
-      }
-    }
-    *oi++ = '"';
-  }
-
-  template <typename Iter> void value::serialize(Iter oi, bool prettify) const {
-    return _serialize(oi, prettify ? 0 : -1);
-  }
-  
-  inline std::string value::serialize(bool prettify) const {
-    return _serialize(prettify ? 0 : -1);
-  }
-
-  template <typename Iter> void value::_indent(Iter oi, int indent) {
-    *oi++ = '\n';
-    for (int i = 0; i < indent * INDENT_WIDTH; ++i) {
-      *oi++ = ' ';
-    }
-  }
-
-  template <typename Iter> void value::_serialize(Iter oi, int indent) const {
-    switch (type_) {
-    case string_type:
-      serialize_str(*u_.string_, oi);
-      break;
-    case array_type: {
-      *oi++ = '[';
-      if (indent != -1) {
-        ++indent;
-      }
-      for (array::const_iterator i = u_.array_->begin();
-           i != u_.array_->end();
-           ++i) {
-	if (i != u_.array_->begin()) {
-	  *oi++ = ',';
-	}
-        if (indent != -1) {
-          _indent(oi, indent);
-        }
-	i->_serialize(oi, indent);
-      }
-      if (indent != -1) {
-        --indent;
-        if (! u_.array_->empty()) {
-          _indent(oi, indent);
-        }
-      }
-      *oi++ = ']';
-      break;
-    }
-    case object_type: {
-      *oi++ = '{';
-      if (indent != -1) {
-        ++indent;
-      }
-      for (object::const_iterator i = u_.object_->begin();
-	   i != u_.object_->end();
-	   ++i) {
-	if (i != u_.object_->begin()) {
-	  *oi++ = ',';
-	}
-        if (indent != -1) {
-          _indent(oi, indent);
-        }
-	serialize_str(i->first, oi);
-	*oi++ = ':';
-        if (indent != -1) {
-          *oi++ = ' ';
-        }
-        i->second._serialize(oi, indent);
-      }
-      if (indent != -1) {
-        --indent;
-        if (! u_.object_->empty()) {
-          _indent(oi, indent);
-        }
-      }
-      *oi++ = '}';
-      break;
-    }
-    default:
-      copy(to_str(), oi);
-      break;
-    }
-    if (indent == 0) {
-      *oi++ = '\n';
-    }
-  }
-  
-  inline std::string value::_serialize(int indent) const {
-    std::string s;
-    _serialize(std::back_inserter(s), indent);
-    return s;
-  }
-  
-  template <typename Iter> class input {
-  protected:
-    Iter cur_, end_;
-    int last_ch_;
-    bool ungot_;
-    int line_;
-  public:
-    input(const Iter& first, const Iter& last) : cur_(first), end_(last), last_ch_(-1), ungot_(false), line_(1) {}
-    int getc() {
-      if (ungot_) {
-	ungot_ = false;
-	return last_ch_;
-      }
-      if (cur_ == end_) {
-	last_ch_ = -1;
-	return -1;
-      }
-      if (last_ch_ == '\n') {
-	line_++;
-      }
-      last_ch_ = *cur_ & 0xff;
-      ++cur_;
-      return last_ch_;
-    }
-    void ungetc() {
-      if (last_ch_ != -1) {
-	PICOJSON_ASSERT(! ungot_);
-	ungot_ = true;
-      }
-    }
-    Iter cur() const { return cur_; }
-    int line() const { return line_; }
-    void skip_ws() {
-      while (1) {
-	int ch = getc();
-	if (! (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r')) {
-	  ungetc();
-	  break;
-	}
-      }
-    }
-    bool expect(int expect) {
-      skip_ws();
-      if (getc() != expect) {
-	ungetc();
-	return false;
-      }
-      return true;
-    }
-    bool match(const std::string& pattern) {
-      for (std::string::const_iterator pi(pattern.begin());
-	   pi != pattern.end();
-	   ++pi) {
-	if (getc() != *pi) {
-	  ungetc();
-	  return false;
-	}
-      }
-      return true;
-    }
-  };
-  
-  template<typename Iter> inline int _parse_quadhex(input<Iter> &in) {
-    int uni_ch = 0, hex;
-    for (int i = 0; i < 4; i++) {
-      if ((hex = in.getc()) == -1) {
-	return -1;
-      }
-      if ('0' <= hex && hex <= '9') {
-	hex -= '0';
-      } else if ('A' <= hex && hex <= 'F') {
-	hex -= 'A' - 0xa;
-      } else if ('a' <= hex && hex <= 'f') {
-	hex -= 'a' - 0xa;
-      } else {
-	in.ungetc();
-	return -1;
-      }
-      uni_ch = uni_ch * 16 + hex;
-    }
-    return uni_ch;
-  }
-  
-  template<typename String, typename Iter> inline bool _parse_codepoint(String& out, input<Iter>& in) {
-    int uni_ch;
-    if ((uni_ch = _parse_quadhex(in)) == -1) {
-      return false;
-    }
-    if (0xd800 <= uni_ch && uni_ch <= 0xdfff) {
-      if (0xdc00 <= uni_ch) {
-	// a second 16-bit of a surrogate pair appeared
-	return false;
-      }
-      // first 16-bit of surrogate pair, get the next one
-      if (in.getc() != '\\' || in.getc() != 'u') {
-	in.ungetc();
-	return false;
-      }
-      int second = _parse_quadhex(in);
-      if (! (0xdc00 <= second && second <= 0xdfff)) {
-	return false;
-      }
-      uni_ch = ((uni_ch - 0xd800) << 10) | ((second - 0xdc00) & 0x3ff);
-      uni_ch += 0x10000;
-    }
-    if (uni_ch < 0x80) {
-      out.push_back(uni_ch);
-    } else {
-      if (uni_ch < 0x800) {
-	out.push_back(0xc0 | (uni_ch >> 6));
-      } else {
-	if (uni_ch < 0x10000) {
-	  out.push_back(0xe0 | (uni_ch >> 12));
-	} else {
-	  out.push_back(0xf0 | (uni_ch >> 18));
-	  out.push_back(0x80 | ((uni_ch >> 12) & 0x3f));
-	}
-	out.push_back(0x80 | ((uni_ch >> 6) & 0x3f));
-      }
-      out.push_back(0x80 | (uni_ch & 0x3f));
-    }
-    return true;
-  }
-  
-  template<typename String, typename Iter> inline bool _parse_string(String& out, input<Iter>& in) {
-    while (1) {
-      int ch = in.getc();
-      if (ch < ' ') {
-	in.ungetc();
-	return false;
-      } else if (ch == '"') {
-	return true;
-      } else if (ch == '\\') {
-	if ((ch = in.getc()) == -1) {
-	  return false;
-	}
-	switch (ch) {
-#define MAP(sym, val) case sym: out.push_back(val); break
-	  MAP('"', '\"');
-	  MAP('\\', '\\');
-	  MAP('/', '/');
-	  MAP('b', '\b');
-	  MAP('f', '\f');
-	  MAP('n', '\n');
-	  MAP('r', '\r');
-	  MAP('t', '\t');
-#undef MAP
-	case 'u':
-	  if (! _parse_codepoint(out, in)) {
-	    return false;
-	  }
-	  break;
-	default:
-	  return false;
-	}
-      } else {
-	out.push_back(ch);
-      }
-    }
-    return false;
-  }
-  
-  template <typename Context, typename Iter> inline bool _parse_array(Context& ctx, input<Iter>& in) {
-    if (! ctx.parse_array_start()) {
-      return false;
-    }
-    size_t idx = 0;
-    if (in.expect(']')) {
-      return ctx.parse_array_stop(idx);
-    }
-    do {
-      if (! ctx.parse_array_item(in, idx)) {
-	return false;
-      }
-      idx++;
-    } while (in.expect(','));
-    return in.expect(']') && ctx.parse_array_stop(idx);
-  }
-  
-  template <typename Context, typename Iter> inline bool _parse_object(Context& ctx, input<Iter>& in) {
-    if (! ctx.parse_object_start()) {
-      return false;
-    }
-    if (in.expect('}')) {
-      return true;
-    }
-    do {
-      std::string key;
-      if (! in.expect('"')
-	  || ! _parse_string(key, in)
-	  || ! in.expect(':')) {
-	return false;
-      }
-      if (! ctx.parse_object_item(in, key)) {
-	return false;
-      }
-    } while (in.expect(','));
-    return in.expect('}');
-  }
-  
-  template <typename Iter> inline std::string _parse_number(input<Iter>& in) {
-    std::string num_str;
-    while (1) {
-      int ch = in.getc();
-      if (('0' <= ch && ch <= '9') || ch == '+' || ch == '-'
-          || ch == 'e' || ch == 'E') {
-        num_str.push_back(ch);
-      } else if (ch == '.') {
-#if PICOJSON_USE_LOCALE
-        num_str += localeconv()->decimal_point;
-#else
-        num_str.push_back('.');
-#endif
-      } else {
-	in.ungetc();
-	break;
-      }
-    }
-    return num_str;
-  }
-  
-  template <typename Context, typename Iter> inline bool _parse(Context& ctx, input<Iter>& in) {
-    in.skip_ws();
-    int ch = in.getc();
-    switch (ch) {
-#define IS(ch, text, op) case ch: \
-      if (in.match(text) && op) { \
-	return true; \
-      } else { \
-	return false; \
-      }
-      IS('n', "ull", ctx.set_null());
-      IS('f', "alse", ctx.set_bool(false));
-      IS('t', "rue", ctx.set_bool(true));
-#undef IS
-    case '"':
-      return ctx.parse_string(in);
-    case '[':
-      return _parse_array(ctx, in);
-    case '{':
-      return _parse_object(ctx, in);
-    default:
-      if (('0' <= ch && ch <= '9') || ch == '-') {
-        double f;
-        char *endp;
-	in.ungetc();
-        std::string num_str = _parse_number(in);
-        if (num_str.empty()) {
-          return false;
-        }
-#ifdef PICOJSON_USE_INT64
-        {
-          errno = 0;
-          intmax_t ival = strtoimax(num_str.c_str(), &endp, 10);
-          if (errno == 0
-              && std::numeric_limits<int64_t>::min() <= ival
-              && ival <= std::numeric_limits<int64_t>::max()
-              && endp == num_str.c_str() + num_str.size()) {
-            ctx.set_int64(ival);
-            return true;
-          }
-        }
-#endif
-        f = strtod(num_str.c_str(), &endp);
-        if (endp == num_str.c_str() + num_str.size()) {
-          ctx.set_number(f);
-          return true;
-        }
-        return false;
-      }
-      break;
-    }
-    in.ungetc();
-    return false;
-  }
-  
-  class deny_parse_context {
-  public:
-    bool set_null() { return false; }
-    bool set_bool(bool) { return false; }
-#ifdef PICOJSON_USE_INT64
-    bool set_int64(int64_t) { return false; }
-#endif
-    bool set_number(double) { return false; }
-    template <typename Iter> bool parse_string(input<Iter>&) { return false; }
-    bool parse_array_start() { return false; }
-    template <typename Iter> bool parse_array_item(input<Iter>&, size_t) {
-      return false;
-    }
-    bool parse_array_stop(size_t) { return false; }
-    bool parse_object_start() { return false; }
-    template <typename Iter> bool parse_object_item(input<Iter>&, const std::string&) {
-      return false;
-    }
-  };
-  
-  class default_parse_context {
-  protected:
-    value* out_;
-  public:
-    default_parse_context(value* out) : out_(out) {}
-    bool set_null() {
-      *out_ = value();
-      return true;
-    }
-    bool set_bool(bool b) {
-      *out_ = value(b);
-      return true;
-    }
-#ifdef PICOJSON_USE_INT64
-    bool set_int64(int64_t i) {
-      *out_ = value(i);
-      return true;
-    }
-#endif
-    bool set_number(double f) {
-      *out_ = value(f);
-      return true;
-    }
-    template<typename Iter> bool parse_string(input<Iter>& in) {
-      *out_ = value(string_type, false);
-      return _parse_string(out_->get<std::string>(), in);
-    }
-    bool parse_array_start() {
-      *out_ = value(array_type, false);
-      return true;
-    }
-    template <typename Iter> bool parse_array_item(input<Iter>& in, size_t) {
-      array& a = out_->get<array>();
-      a.push_back(value());
-      default_parse_context ctx(&a.back());
-      return _parse(ctx, in);
-    }
-    bool parse_array_stop(size_t) { return true; }
-    bool parse_object_start() {
-      *out_ = value(object_type, false);
-      return true;
-    }
-    template <typename Iter> bool parse_object_item(input<Iter>& in, const std::string& key) {
-      object& o = out_->get<object>();
-      default_parse_context ctx(&o[key]);
-      return _parse(ctx, in);
-    }
-  private:
-    default_parse_context(const default_parse_context&);
-    default_parse_context& operator=(const default_parse_context&);
-  };
-
-  class null_parse_context {
-  public:
-    struct dummy_str {
-      void push_back(int) {}
-    };
-  public:
-    null_parse_context() {}
-    bool set_null() { return true; }
-    bool set_bool(bool) { return true; }
-#ifdef PICOJSON_USE_INT64
-    bool set_int64(int64_t) { return true; }
-#endif
-    bool set_number(double) { return true; }
-    template <typename Iter> bool parse_string(input<Iter>& in) {
-      dummy_str s;
-      return _parse_string(s, in);
-    }
-    bool parse_array_start() { return true; }
-    template <typename Iter> bool parse_array_item(input<Iter>& in, size_t) {
-      return _parse(*this, in);
-    }
-    bool parse_array_stop(size_t) { return true; }
-    bool parse_object_start() { return true; }
-    template <typename Iter> bool parse_object_item(input<Iter>& in, const std::string&) {
-      return _parse(*this, in);
-    }
-  private:
-    null_parse_context(const null_parse_context&);
-    null_parse_context& operator=(const null_parse_context&);
-  };
-  
-  // obsolete, use the version below
-  template <typename Iter> inline std::string parse(value& out, Iter& pos, const Iter& last) {
-    std::string err;
-    pos = parse(out, pos, last, &err);
-    return err;
-  }
-  
-  template <typename Context, typename Iter> inline Iter _parse(Context& ctx, const Iter& first, const Iter& last, std::string* err) {
-    input<Iter> in(first, last);
-    if (! _parse(ctx, in) && err != NULL) {
-      char buf[64];
-      SNPRINTF(buf, sizeof(buf), "syntax error at line %d near: ", in.line());
-      *err = buf;
-      while (1) {
-	int ch = in.getc();
-	if (ch == -1 || ch == '\n') {
-	  break;
-	} else if (ch >= ' ') {
-	  err->push_back(ch);
-	}
-      }
-    }
-    return in.cur();
-  }
-  
-  template <typename Iter> inline Iter parse(value& out, const Iter& first, const Iter& last, std::string* err) {
-    default_parse_context ctx(&out);
-    return _parse(ctx, first, last, err);
-  }
-  
-  inline std::string parse(value& out, const std::string& s) {
-    std::string err;
-    parse(out, s.begin(), s.end(), &err);
-    return err;
-  }
-
-  inline std::string parse(value& out, std::istream& is) {
-    std::string err;
-    parse(out, std::istreambuf_iterator<char>(is.rdbuf()),
-	  std::istreambuf_iterator<char>(), &err);
-    return err;
-  }
-  
-  template <typename T> struct last_error_t {
-    static std::string s;
-  };
-  template <typename T> std::string last_error_t<T>::s;
-  
-  inline void set_last_error(const std::string& s) {
-    last_error_t<bool>::s = s;
-  }
-  
-  inline const std::string& get_last_error() {
-    return last_error_t<bool>::s;
-  }
-
-  inline bool operator==(const value& x, const value& y) {
-    if (x.is<null>())
-      return y.is<null>();
-#define PICOJSON_CMP(type)					\
-    if (x.is<type>())						\
-      return y.is<type>() && x.get<type>() == y.get<type>()
-    PICOJSON_CMP(bool);
-    PICOJSON_CMP(double);
-    PICOJSON_CMP(std::string);
-    PICOJSON_CMP(array);
-    PICOJSON_CMP(object);
-#undef PICOJSON_CMP
-    PICOJSON_ASSERT(0);
-#ifdef _MSC_VER
-    __assume(0);
-#endif
-    return false;
-  }
-  
-  inline bool operator!=(const value& x, const value& y) {
-    return ! (x == y);
-  }
-}
-
-namespace std {
-  template<> inline void swap(picojson::value& x, picojson::value& y)
-    {
-      x.swap(y);
-    }
-}
-
-inline std::istream& operator>>(std::istream& is, picojson::value& x)
-{
-  picojson::set_last_error(std::string());
-  std::string err = picojson::parse(x, is);
-  if (! err.empty()) {
-    picojson::set_last_error(err);
-    is.setstate(std::ios::failbit);
-  }
-  return is;
-}
-
-inline std::ostream& operator<<(std::ostream& os, const picojson::value& x)
-{
-  x.serialize(std::ostream_iterator<char>(os));
-  return os;
-}
-#ifdef _MSC_VER
-    #pragma warning(pop)
-#endif
-
-#endif
diff --git a/externals/picojson/CMakeLists.txt b/externals/picojson/CMakeLists.txt
new file mode 100644
index 00000000000..937a89c12b3
--- /dev/null
+++ b/externals/picojson/CMakeLists.txt
@@ -0,0 +1,4 @@
+
+add_library(picojson INTERFACE)
+target_externals_include_directories(picojson INTERFACE .)
+
diff --git a/externals/picojson/LICENSE b/externals/picojson/LICENSE
new file mode 100644
index 00000000000..72f35539111
--- /dev/null
+++ b/externals/picojson/LICENSE
@@ -0,0 +1,25 @@
+Copyright 2009-2010 Cybozu Labs, Inc.
+Copyright 2011-2014 Kazuho Oku
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
diff --git a/externals/picojson/picojson.h b/externals/picojson/picojson.h
new file mode 100644
index 00000000000..76742fe06ac
--- /dev/null
+++ b/externals/picojson/picojson.h
@@ -0,0 +1,1200 @@
+/*
+ * Copyright 2009-2010 Cybozu Labs, Inc.
+ * Copyright 2011-2014 Kazuho Oku
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef picojson_h
+#define picojson_h
+
+#include <algorithm>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cstddef>
+#include <iostream>
+#include <iterator>
+#include <limits>
+#include <map>
+#include <stdexcept>
+#include <string>
+#include <vector>
+#include <utility>
+
+// for isnan/isinf
+#if __cplusplus >= 201103L
+#include <cmath>
+#else
+extern "C" {
+#ifdef _MSC_VER
+#include <float.h>
+#elif defined(__INTEL_COMPILER)
+#include <mathimf.h>
+#else
+#include <math.h>
+#endif
+}
+#endif
+
+#ifndef PICOJSON_USE_RVALUE_REFERENCE
+#if (defined(__cpp_rvalue_references) && __cpp_rvalue_references >= 200610) || (defined(_MSC_VER) && _MSC_VER >= 1600)
+#define PICOJSON_USE_RVALUE_REFERENCE 1
+#else
+#define PICOJSON_USE_RVALUE_REFERENCE 0
+#endif
+#endif // PICOJSON_USE_RVALUE_REFERENCE
+
+#ifndef PICOJSON_NOEXCEPT
+#if PICOJSON_USE_RVALUE_REFERENCE
+#define PICOJSON_NOEXCEPT noexcept
+#else
+#define PICOJSON_NOEXCEPT throw()
+#endif
+#endif
+
+// experimental support for int64_t (see README.mkdn for detail)
+#ifdef PICOJSON_USE_INT64
+#define __STDC_FORMAT_MACROS
+#include <cerrno>
+#if __cplusplus >= 201103L
+#include <cinttypes>
+#else
+extern "C" {
+#include <inttypes.h>
+}
+#endif
+#endif
+
+// to disable the use of localeconv(3), set PICOJSON_USE_LOCALE to 0
+#ifndef PICOJSON_USE_LOCALE
+#define PICOJSON_USE_LOCALE 1
+#endif
+#if PICOJSON_USE_LOCALE
+extern "C" {
+#include <locale.h>
+}
+#endif
+
+#ifndef PICOJSON_ASSERT
+#define PICOJSON_ASSERT(e)                                                                                                         \
+  do {                                                                                                                             \
+    if (!(e))                                                                                                                      \
+      throw std::runtime_error(#e);                                                                                                \
+  } while (0)
+#endif
+
+#ifdef _MSC_VER
+#define SNPRINTF _snprintf_s
+#pragma warning(push)
+#pragma warning(disable : 4244) // conversion from int to char
+#pragma warning(disable : 4127) // conditional expression is constant
+#pragma warning(disable : 4702) // unreachable code
+#pragma warning(disable : 4706) // assignment within conditional expression
+#else
+#define SNPRINTF snprintf
+#endif
+
+namespace picojson {
+
+enum {
+  null_type,
+  boolean_type,
+  number_type,
+  string_type,
+  array_type,
+  object_type
+#ifdef PICOJSON_USE_INT64
+  ,
+  int64_type
+#endif
+};
+
+enum { INDENT_WIDTH = 2, DEFAULT_MAX_DEPTHS = 100 };
+
+struct null {};
+
+class value {
+public:
+  typedef std::vector<value> array;
+  typedef std::map<std::string, value> object;
+  union _storage {
+    bool boolean_;
+    double number_;
+#ifdef PICOJSON_USE_INT64
+    int64_t int64_;
+#endif
+    std::string *string_;
+    array *array_;
+    object *object_;
+  };
+
+protected:
+  int type_;
+  _storage u_;
+
+public:
+  value();
+  value(int type, bool);
+  explicit value(bool b);
+#ifdef PICOJSON_USE_INT64
+  explicit value(int64_t i);
+#endif
+  explicit value(double n);
+  explicit value(const std::string &s);
+  explicit value(const array &a);
+  explicit value(const object &o);
+#if PICOJSON_USE_RVALUE_REFERENCE
+  explicit value(std::string &&s);
+  explicit value(array &&a);
+  explicit value(object &&o);
+#endif
+  explicit value(const char *s);
+  value(const char *s, size_t len);
+  ~value();
+  value(const value &x);
+  value &operator=(const value &x);
+#if PICOJSON_USE_RVALUE_REFERENCE
+  value(value &&x) PICOJSON_NOEXCEPT;
+  value &operator=(value &&x) PICOJSON_NOEXCEPT;
+#endif
+  void swap(value &x) PICOJSON_NOEXCEPT;
+  template <typename T> bool is() const;
+  template <typename T> const T &get() const;
+  template <typename T> T &get();
+  template <typename T> void set(const T &);
+#if PICOJSON_USE_RVALUE_REFERENCE
+  template <typename T> void set(T &&);
+#endif
+  bool evaluate_as_boolean() const;
+  const value &get(const size_t idx) const;
+  const value &get(const std::string &key) const;
+  value &get(const size_t idx);
+  value &get(const std::string &key);
+
+  bool contains(const size_t idx) const;
+  bool contains(const std::string &key) const;
+  std::string to_str() const;
+  template <typename Iter> void serialize(Iter os, bool prettify = false) const;
+  std::string serialize(bool prettify = false) const;
+
+private:
+  template <typename T> value(const T *); // intentionally defined to block implicit conversion of pointer to bool
+  template <typename Iter> static void _indent(Iter os, int indent);
+  template <typename Iter> void _serialize(Iter os, int indent) const;
+  std::string _serialize(int indent) const;
+  void clear();
+};
+
+typedef value::array array;
+typedef value::object object;
+
+inline value::value() : type_(null_type), u_() {
+}
+
+inline value::value(int type, bool) : type_(type), u_() {
+  switch (type) {
+#define INIT(p, v)                                                                                                                 \
+  case p##type:                                                                                                                    \
+    u_.p = v;                                                                                                                      \
+    break
+    INIT(boolean_, false);
+    INIT(number_, 0.0);
+#ifdef PICOJSON_USE_INT64
+    INIT(int64_, 0);
+#endif
+    INIT(string_, new std::string());
+    INIT(array_, new array());
+    INIT(object_, new object());
+#undef INIT
+  default:
+    break;
+  }
+}
+
+inline value::value(bool b) : type_(boolean_type), u_() {
+  u_.boolean_ = b;
+}
+
+#ifdef PICOJSON_USE_INT64
+inline value::value(int64_t i) : type_(int64_type), u_() {
+  u_.int64_ = i;
+}
+#endif
+
+inline value::value(double n) : type_(number_type), u_() {
+  if (
+#ifdef _MSC_VER
+      !_finite(n)
+#elif __cplusplus >= 201103L
+      std::isnan(n) || std::isinf(n)
+#else
+      isnan(n) || isinf(n)
+#endif
+          ) {
+    throw std::overflow_error("");
+  }
+  u_.number_ = n;
+}
+
+inline value::value(const std::string &s) : type_(string_type), u_() {
+  u_.string_ = new std::string(s);
+}
+
+inline value::value(const array &a) : type_(array_type), u_() {
+  u_.array_ = new array(a);
+}
+
+inline value::value(const object &o) : type_(object_type), u_() {
+  u_.object_ = new object(o);
+}
+
+#if PICOJSON_USE_RVALUE_REFERENCE
+inline value::value(std::string &&s) : type_(string_type), u_() {
+  u_.string_ = new std::string(std::move(s));
+}
+
+inline value::value(array &&a) : type_(array_type), u_() {
+  u_.array_ = new array(std::move(a));
+}
+
+inline value::value(object &&o) : type_(object_type), u_() {
+  u_.object_ = new object(std::move(o));
+}
+#endif
+
+inline value::value(const char *s) : type_(string_type), u_() {
+  u_.string_ = new std::string(s);
+}
+
+inline value::value(const char *s, size_t len) : type_(string_type), u_() {
+  u_.string_ = new std::string(s, len);
+}
+
+inline void value::clear() {
+  switch (type_) {
+#define DEINIT(p)                                                                                                                  \
+  case p##type:                                                                                                                    \
+    delete u_.p;                                                                                                                   \
+    break
+    DEINIT(string_);
+    DEINIT(array_);
+    DEINIT(object_);
+#undef DEINIT
+  default:
+    break;
+  }
+}
+
+inline value::~value() {
+  clear();
+}
+
+inline value::value(const value &x) : type_(x.type_), u_() {
+  switch (type_) {
+#define INIT(p, v)                                                                                                                 \
+  case p##type:                                                                                                                    \
+    u_.p = v;                                                                                                                      \
+    break
+    INIT(string_, new std::string(*x.u_.string_));
+    INIT(array_, new array(*x.u_.array_));
+    INIT(object_, new object(*x.u_.object_));
+#undef INIT
+  default:
+    u_ = x.u_;
+    break;
+  }
+}
+
+inline value &value::operator=(const value &x) {
+  if (this != &x) {
+    value t(x);
+    swap(t);
+  }
+  return *this;
+}
+
+#if PICOJSON_USE_RVALUE_REFERENCE
+inline value::value(value &&x) PICOJSON_NOEXCEPT : type_(null_type), u_() {
+  swap(x);
+}
+inline value &value::operator=(value &&x) PICOJSON_NOEXCEPT {
+  swap(x);
+  return *this;
+}
+#endif
+inline void value::swap(value &x) PICOJSON_NOEXCEPT {
+  std::swap(type_, x.type_);
+  std::swap(u_, x.u_);
+}
+
+#define IS(ctype, jtype)                                                                                                           \
+  template <> inline bool value::is<ctype>() const {                                                                               \
+    return type_ == jtype##_type;                                                                                                  \
+  }
+IS(null, null)
+IS(bool, boolean)
+#ifdef PICOJSON_USE_INT64
+IS(int64_t, int64)
+#endif
+IS(std::string, string)
+IS(array, array)
+IS(object, object)
+#undef IS
+template <> inline bool value::is<double>() const {
+  return type_ == number_type
+#ifdef PICOJSON_USE_INT64
+         || type_ == int64_type
+#endif
+      ;
+}
+
+#define GET(ctype, var)                                                                                                            \
+  template <> inline const ctype &value::get<ctype>() const {                                                                      \
+    PICOJSON_ASSERT("type mismatch! call is<type>() before get<type>()" && is<ctype>());                                           \
+    return var;                                                                                                                    \
+  }                                                                                                                                \
+  template <> inline ctype &value::get<ctype>() {                                                                                  \
+    PICOJSON_ASSERT("type mismatch! call is<type>() before get<type>()" && is<ctype>());                                           \
+    return var;                                                                                                                    \
+  }
+GET(bool, u_.boolean_)
+GET(std::string, *u_.string_)
+GET(array, *u_.array_)
+GET(object, *u_.object_)
+#ifdef PICOJSON_USE_INT64
+GET(double,
+    (type_ == int64_type && (const_cast<value *>(this)->type_ = number_type, (const_cast<value *>(this)->u_.number_ = u_.int64_)),
+     u_.number_))
+GET(int64_t, u_.int64_)
+#else
+GET(double, u_.number_)
+#endif
+#undef GET
+
+#define SET(ctype, jtype, setter)                                                                                                  \
+  template <> inline void value::set<ctype>(const ctype &_val) {                                                                   \
+    clear();                                                                                                                       \
+    type_ = jtype##_type;                                                                                                          \
+    setter                                                                                                                         \
+  }
+SET(bool, boolean, u_.boolean_ = _val;)
+SET(std::string, string, u_.string_ = new std::string(_val);)
+SET(array, array, u_.array_ = new array(_val);)
+SET(object, object, u_.object_ = new object(_val);)
+SET(double, number, u_.number_ = _val;)
+#ifdef PICOJSON_USE_INT64
+SET(int64_t, int64, u_.int64_ = _val;)
+#endif
+#undef SET
+
+#if PICOJSON_USE_RVALUE_REFERENCE
+#define MOVESET(ctype, jtype, setter)                                                                                              \
+  template <> inline void value::set<ctype>(ctype && _val) {                                                                       \
+    clear();                                                                                                                       \
+    type_ = jtype##_type;                                                                                                          \
+    setter                                                                                                                         \
+  }
+MOVESET(std::string, string, u_.string_ = new std::string(std::move(_val));)
+MOVESET(array, array, u_.array_ = new array(std::move(_val));)
+MOVESET(object, object, u_.object_ = new object(std::move(_val));)
+#undef MOVESET
+#endif
+
+inline bool value::evaluate_as_boolean() const {
+  switch (type_) {
+  case null_type:
+    return false;
+  case boolean_type:
+    return u_.boolean_;
+  case number_type:
+    return u_.number_ != 0;
+#ifdef PICOJSON_USE_INT64
+  case int64_type:
+    return u_.int64_ != 0;
+#endif
+  case string_type:
+    return !u_.string_->empty();
+  default:
+    return true;
+  }
+}
+
+inline const value &value::get(const size_t idx) const {
+  static value s_null;
+  PICOJSON_ASSERT(is<array>());
+  return idx < u_.array_->size() ? (*u_.array_)[idx] : s_null;
+}
+
+inline value &value::get(const size_t idx) {
+  static value s_null;
+  PICOJSON_ASSERT(is<array>());
+  return idx < u_.array_->size() ? (*u_.array_)[idx] : s_null;
+}
+
+inline const value &value::get(const std::string &key) const {
+  static value s_null;
+  PICOJSON_ASSERT(is<object>());
+  object::const_iterator i = u_.object_->find(key);
+  return i != u_.object_->end() ? i->second : s_null;
+}
+
+inline value &value::get(const std::string &key) {
+  static value s_null;
+  PICOJSON_ASSERT(is<object>());
+  object::iterator i = u_.object_->find(key);
+  return i != u_.object_->end() ? i->second : s_null;
+}
+
+inline bool value::contains(const size_t idx) const {
+  PICOJSON_ASSERT(is<array>());
+  return idx < u_.array_->size();
+}
+
+inline bool value::contains(const std::string &key) const {
+  PICOJSON_ASSERT(is<object>());
+  object::const_iterator i = u_.object_->find(key);
+  return i != u_.object_->end();
+}
+
+inline std::string value::to_str() const {
+  switch (type_) {
+  case null_type:
+    return "null";
+  case boolean_type:
+    return u_.boolean_ ? "true" : "false";
+#ifdef PICOJSON_USE_INT64
+  case int64_type: {
+    char buf[sizeof("-9223372036854775808")];
+    SNPRINTF(buf, sizeof(buf), "%" PRId64, u_.int64_);
+    return buf;
+  }
+#endif
+  case number_type: {
+    char buf[256];
+    double tmp;
+    SNPRINTF(buf, sizeof(buf), fabs(u_.number_) < (1ULL << 53) && modf(u_.number_, &tmp) == 0 ? "%.f" : "%.17g", u_.number_);
+#if PICOJSON_USE_LOCALE
+    char *decimal_point = localeconv()->decimal_point;
+    if (strcmp(decimal_point, ".") != 0) {
+      size_t decimal_point_len = strlen(decimal_point);
+      for (char *p = buf; *p != '\0'; ++p) {
+        if (strncmp(p, decimal_point, decimal_point_len) == 0) {
+          return std::string(buf, p) + "." + (p + decimal_point_len);
+        }
+      }
+    }
+#endif
+    return buf;
+  }
+  case string_type:
+    return *u_.string_;
+  case array_type:
+    return "array";
+  case object_type:
+    return "object";
+  default:
+    PICOJSON_ASSERT(0);
+#ifdef _MSC_VER
+    __assume(0);
+#endif
+  }
+  return std::string();
+}
+
+template <typename Iter> void copy(const std::string &s, Iter oi) {
+  std::copy(s.begin(), s.end(), oi);
+}
+
+template <typename Iter> struct serialize_str_char {
+  Iter oi;
+  void operator()(char c) {
+    switch (c) {
+#define MAP(val, sym)                                                                                                              \
+  case val:                                                                                                                        \
+    copy(sym, oi);                                                                                                                 \
+    break
+      MAP('"', "\\\"");
+      MAP('\\', "\\\\");
+      MAP('/', "\\/");
+      MAP('\b', "\\b");
+      MAP('\f', "\\f");
+      MAP('\n', "\\n");
+      MAP('\r', "\\r");
+      MAP('\t', "\\t");
+#undef MAP
+    default:
+      if (static_cast<unsigned char>(c) < 0x20 || c == 0x7f) {
+        char buf[7];
+        SNPRINTF(buf, sizeof(buf), "\\u%04x", c & 0xff);
+        copy(buf, buf + 6, oi);
+      } else {
+        *oi++ = c;
+      }
+      break;
+    }
+  }
+};
+
+template <typename Iter> void serialize_str(const std::string &s, Iter oi) {
+  *oi++ = '"';
+  serialize_str_char<Iter> process_char = {oi};
+  std::for_each(s.begin(), s.end(), process_char);
+  *oi++ = '"';
+}
+
+template <typename Iter> void value::serialize(Iter oi, bool prettify) const {
+  return _serialize(oi, prettify ? 0 : -1);
+}
+
+inline std::string value::serialize(bool prettify) const {
+  return _serialize(prettify ? 0 : -1);
+}
+
+template <typename Iter> void value::_indent(Iter oi, int indent) {
+  *oi++ = '\n';
+  for (int i = 0; i < indent * INDENT_WIDTH; ++i) {
+    *oi++ = ' ';
+  }
+}
+
+template <typename Iter> void value::_serialize(Iter oi, int indent) const {
+  switch (type_) {
+  case string_type:
+    serialize_str(*u_.string_, oi);
+    break;
+  case array_type: {
+    *oi++ = '[';
+    if (indent != -1) {
+      ++indent;
+    }
+    for (array::const_iterator i = u_.array_->begin(); i != u_.array_->end(); ++i) {
+      if (i != u_.array_->begin()) {
+        *oi++ = ',';
+      }
+      if (indent != -1) {
+        _indent(oi, indent);
+      }
+      i->_serialize(oi, indent);
+    }
+    if (indent != -1) {
+      --indent;
+      if (!u_.array_->empty()) {
+        _indent(oi, indent);
+      }
+    }
+    *oi++ = ']';
+    break;
+  }
+  case object_type: {
+    *oi++ = '{';
+    if (indent != -1) {
+      ++indent;
+    }
+    for (object::const_iterator i = u_.object_->begin(); i != u_.object_->end(); ++i) {
+      if (i != u_.object_->begin()) {
+        *oi++ = ',';
+      }
+      if (indent != -1) {
+        _indent(oi, indent);
+      }
+      serialize_str(i->first, oi);
+      *oi++ = ':';
+      if (indent != -1) {
+        *oi++ = ' ';
+      }
+      i->second._serialize(oi, indent);
+    }
+    if (indent != -1) {
+      --indent;
+      if (!u_.object_->empty()) {
+        _indent(oi, indent);
+      }
+    }
+    *oi++ = '}';
+    break;
+  }
+  default:
+    copy(to_str(), oi);
+    break;
+  }
+  if (indent == 0) {
+    *oi++ = '\n';
+  }
+}
+
+inline std::string value::_serialize(int indent) const {
+  std::string s;
+  _serialize(std::back_inserter(s), indent);
+  return s;
+}
+
+template <typename Iter> class input {
+protected:
+  Iter cur_, end_;
+  bool consumed_;
+  int line_;
+
+public:
+  input(const Iter &first, const Iter &last) : cur_(first), end_(last), consumed_(false), line_(1) {
+  }
+  int getc() {
+    if (consumed_) {
+      if (*cur_ == '\n') {
+        ++line_;
+      }
+      ++cur_;
+    }
+    if (cur_ == end_) {
+      consumed_ = false;
+      return -1;
+    }
+    consumed_ = true;
+    return *cur_ & 0xff;
+  }
+  void ungetc() {
+    consumed_ = false;
+  }
+  Iter cur() const {
+    if (consumed_) {
+      input<Iter> *self = const_cast<input<Iter> *>(this);
+      self->consumed_ = false;
+      ++self->cur_;
+    }
+    return cur_;
+  }
+  int line() const {
+    return line_;
+  }
+  void skip_ws() {
+    while (1) {
+      int ch = getc();
+      if (!(ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r')) {
+        ungetc();
+        break;
+      }
+    }
+  }
+  bool expect(const int expected) {
+    skip_ws();
+    if (getc() != expected) {
+      ungetc();
+      return false;
+    }
+    return true;
+  }
+  bool match(const std::string &pattern) {
+    for (std::string::const_iterator pi(pattern.begin()); pi != pattern.end(); ++pi) {
+      if (getc() != *pi) {
+        ungetc();
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+template <typename Iter> inline int _parse_quadhex(input<Iter> &in) {
+  int uni_ch = 0, hex;
+  for (int i = 0; i < 4; i++) {
+    if ((hex = in.getc()) == -1) {
+      return -1;
+    }
+    if ('0' <= hex && hex <= '9') {
+      hex -= '0';
+    } else if ('A' <= hex && hex <= 'F') {
+      hex -= 'A' - 0xa;
+    } else if ('a' <= hex && hex <= 'f') {
+      hex -= 'a' - 0xa;
+    } else {
+      in.ungetc();
+      return -1;
+    }
+    uni_ch = uni_ch * 16 + hex;
+  }
+  return uni_ch;
+}
+
+template <typename String, typename Iter> inline bool _parse_codepoint(String &out, input<Iter> &in) {
+  int uni_ch;
+  if ((uni_ch = _parse_quadhex(in)) == -1) {
+    return false;
+  }
+  if (0xd800 <= uni_ch && uni_ch <= 0xdfff) {
+    if (0xdc00 <= uni_ch) {
+      // a second 16-bit of a surrogate pair appeared
+      return false;
+    }
+    // first 16-bit of surrogate pair, get the next one
+    if (in.getc() != '\\' || in.getc() != 'u') {
+      in.ungetc();
+      return false;
+    }
+    int second = _parse_quadhex(in);
+    if (!(0xdc00 <= second && second <= 0xdfff)) {
+      return false;
+    }
+    uni_ch = ((uni_ch - 0xd800) << 10) | ((second - 0xdc00) & 0x3ff);
+    uni_ch += 0x10000;
+  }
+  if (uni_ch < 0x80) {
+    out.push_back(static_cast<char>(uni_ch));
+  } else {
+    if (uni_ch < 0x800) {
+      out.push_back(static_cast<char>(0xc0 | (uni_ch >> 6)));
+    } else {
+      if (uni_ch < 0x10000) {
+        out.push_back(static_cast<char>(0xe0 | (uni_ch >> 12)));
+      } else {
+        out.push_back(static_cast<char>(0xf0 | (uni_ch >> 18)));
+        out.push_back(static_cast<char>(0x80 | ((uni_ch >> 12) & 0x3f)));
+      }
+      out.push_back(static_cast<char>(0x80 | ((uni_ch >> 6) & 0x3f)));
+    }
+    out.push_back(static_cast<char>(0x80 | (uni_ch & 0x3f)));
+  }
+  return true;
+}
+
+template <typename String, typename Iter> inline bool _parse_string(String &out, input<Iter> &in) {
+  while (1) {
+    int ch = in.getc();
+    if (ch < ' ') {
+      in.ungetc();
+      return false;
+    } else if (ch == '"') {
+      return true;
+    } else if (ch == '\\') {
+      if ((ch = in.getc()) == -1) {
+        return false;
+      }
+      switch (ch) {
+#define MAP(sym, val)                                                                                                              \
+  case sym:                                                                                                                        \
+    out.push_back(val);                                                                                                            \
+    break
+        MAP('"', '\"');
+        MAP('\\', '\\');
+        MAP('/', '/');
+        MAP('b', '\b');
+        MAP('f', '\f');
+        MAP('n', '\n');
+        MAP('r', '\r');
+        MAP('t', '\t');
+#undef MAP
+      case 'u':
+        if (!_parse_codepoint(out, in)) {
+          return false;
+        }
+        break;
+      default:
+        return false;
+      }
+    } else {
+      out.push_back(static_cast<char>(ch));
+    }
+  }
+  return false;
+}
+
+template <typename Context, typename Iter> inline bool _parse_array(Context &ctx, input<Iter> &in) {
+  if (!ctx.parse_array_start()) {
+    return false;
+  }
+  size_t idx = 0;
+  if (in.expect(']')) {
+    return ctx.parse_array_stop(idx);
+  }
+  do {
+    if (!ctx.parse_array_item(in, idx)) {
+      return false;
+    }
+    idx++;
+  } while (in.expect(','));
+  return in.expect(']') && ctx.parse_array_stop(idx);
+}
+
+template <typename Context, typename Iter> inline bool _parse_object(Context &ctx, input<Iter> &in) {
+  if (!ctx.parse_object_start()) {
+    return false;
+  }
+  if (in.expect('}')) {
+    return ctx.parse_object_stop();
+  }
+  do {
+    std::string key;
+    if (!in.expect('"') || !_parse_string(key, in) || !in.expect(':')) {
+      return false;
+    }
+    if (!ctx.parse_object_item(in, key)) {
+      return false;
+    }
+  } while (in.expect(','));
+  return in.expect('}') && ctx.parse_object_stop();
+}
+
+template <typename Iter> inline std::string _parse_number(input<Iter> &in) {
+  std::string num_str;
+  while (1) {
+    int ch = in.getc();
+    if (('0' <= ch && ch <= '9') || ch == '+' || ch == '-' || ch == 'e' || ch == 'E') {
+      num_str.push_back(static_cast<char>(ch));
+    } else if (ch == '.') {
+#if PICOJSON_USE_LOCALE
+      num_str += localeconv()->decimal_point;
+#else
+      num_str.push_back('.');
+#endif
+    } else {
+      in.ungetc();
+      break;
+    }
+  }
+  return num_str;
+}
+
+template <typename Context, typename Iter> inline bool _parse(Context &ctx, input<Iter> &in) {
+  in.skip_ws();
+  int ch = in.getc();
+  switch (ch) {
+#define IS(ch, text, op)                                                                                                           \
+  case ch:                                                                                                                         \
+    if (in.match(text) && op) {                                                                                                    \
+      return true;                                                                                                                 \
+    } else {                                                                                                                       \
+      return false;                                                                                                                \
+    }
+    IS('n', "ull", ctx.set_null());
+    IS('f', "alse", ctx.set_bool(false));
+    IS('t', "rue", ctx.set_bool(true));
+#undef IS
+  case '"':
+    return ctx.parse_string(in);
+  case '[':
+    return _parse_array(ctx, in);
+  case '{':
+    return _parse_object(ctx, in);
+  default:
+    if (('0' <= ch && ch <= '9') || ch == '-') {
+      double f;
+      char *endp;
+      in.ungetc();
+      std::string num_str(_parse_number(in));
+      if (num_str.empty()) {
+        return false;
+      }
+#ifdef PICOJSON_USE_INT64
+      {
+        errno = 0;
+        intmax_t ival = strtoimax(num_str.c_str(), &endp, 10);
+        if (errno == 0 && std::numeric_limits<int64_t>::min() <= ival && ival <= std::numeric_limits<int64_t>::max() &&
+            endp == num_str.c_str() + num_str.size()) {
+          ctx.set_int64(ival);
+          return true;
+        }
+      }
+#endif
+      f = strtod(num_str.c_str(), &endp);
+      if (endp == num_str.c_str() + num_str.size()) {
+        ctx.set_number(f);
+        return true;
+      }
+      return false;
+    }
+    break;
+  }
+  in.ungetc();
+  return false;
+}
+
+class deny_parse_context {
+public:
+  bool set_null() {
+    return false;
+  }
+  bool set_bool(bool) {
+    return false;
+  }
+#ifdef PICOJSON_USE_INT64
+  bool set_int64(int64_t) {
+    return false;
+  }
+#endif
+  bool set_number(double) {
+    return false;
+  }
+  template <typename Iter> bool parse_string(input<Iter> &) {
+    return false;
+  }
+  bool parse_array_start() {
+    return false;
+  }
+  template <typename Iter> bool parse_array_item(input<Iter> &, size_t) {
+    return false;
+  }
+  bool parse_array_stop(size_t) {
+    return false;
+  }
+  bool parse_object_start() {
+    return false;
+  }
+  template <typename Iter> bool parse_object_item(input<Iter> &, const std::string &) {
+    return false;
+  }
+};
+
+class default_parse_context {
+protected:
+  value *out_;
+  size_t depths_;
+
+public:
+  default_parse_context(value *out, size_t depths = DEFAULT_MAX_DEPTHS) : out_(out), depths_(depths) {
+  }
+  bool set_null() {
+    *out_ = value();
+    return true;
+  }
+  bool set_bool(bool b) {
+    *out_ = value(b);
+    return true;
+  }
+#ifdef PICOJSON_USE_INT64
+  bool set_int64(int64_t i) {
+    *out_ = value(i);
+    return true;
+  }
+#endif
+  bool set_number(double f) {
+    *out_ = value(f);
+    return true;
+  }
+  template <typename Iter> bool parse_string(input<Iter> &in) {
+    *out_ = value(string_type, false);
+    return _parse_string(out_->get<std::string>(), in);
+  }
+  bool parse_array_start() {
+    if (depths_ == 0)
+      return false;
+    --depths_;
+    *out_ = value(array_type, false);
+    return true;
+  }
+  template <typename Iter> bool parse_array_item(input<Iter> &in, size_t) {
+    array &a = out_->get<array>();
+    a.push_back(value());
+    default_parse_context ctx(&a.back(), depths_);
+    return _parse(ctx, in);
+  }
+  bool parse_array_stop(size_t) {
+    ++depths_;
+    return true;
+  }
+  bool parse_object_start() {
+    if (depths_ == 0)
+      return false;
+    *out_ = value(object_type, false);
+    return true;
+  }
+  template <typename Iter> bool parse_object_item(input<Iter> &in, const std::string &key) {
+    object &o = out_->get<object>();
+    default_parse_context ctx(&o[key], depths_);
+    return _parse(ctx, in);
+  }
+  bool parse_object_stop() {
+    ++depths_;
+    return true;
+  }
+
+private:
+  default_parse_context(const default_parse_context &);
+  default_parse_context &operator=(const default_parse_context &);
+};
+
+class null_parse_context {
+protected:
+  size_t depths_;
+
+public:
+  struct dummy_str {
+    void push_back(int) {
+    }
+  };
+
+public:
+  null_parse_context(size_t depths = DEFAULT_MAX_DEPTHS) : depths_(depths) {
+  }
+  bool set_null() {
+    return true;
+  }
+  bool set_bool(bool) {
+    return true;
+  }
+#ifdef PICOJSON_USE_INT64
+  bool set_int64(int64_t) {
+    return true;
+  }
+#endif
+  bool set_number(double) {
+    return true;
+  }
+  template <typename Iter> bool parse_string(input<Iter> &in) {
+    dummy_str s;
+    return _parse_string(s, in);
+  }
+  bool parse_array_start() {
+    if (depths_ == 0)
+      return false;
+    --depths_;
+    return true;
+  }
+  template <typename Iter> bool parse_array_item(input<Iter> &in, size_t) {
+    return _parse(*this, in);
+  }
+  bool parse_array_stop(size_t) {
+    ++depths_;
+    return true;
+  }
+  bool parse_object_start() {
+    if (depths_ == 0)
+      return false;
+    --depths_;
+    return true;
+  }
+  template <typename Iter> bool parse_object_item(input<Iter> &in, const std::string &) {
+    ++depths_;
+    return _parse(*this, in);
+  }
+  bool parse_object_stop() {
+    return true;
+  }
+
+private:
+  null_parse_context(const null_parse_context &);
+  null_parse_context &operator=(const null_parse_context &);
+};
+
+// obsolete, use the version below
+template <typename Iter> inline std::string parse(value &out, Iter &pos, const Iter &last) {
+  std::string err;
+  pos = parse(out, pos, last, &err);
+  return err;
+}
+
+template <typename Context, typename Iter> inline Iter _parse(Context &ctx, const Iter &first, const Iter &last, std::string *err) {
+  input<Iter> in(first, last);
+  if (!_parse(ctx, in) && err != NULL) {
+    char buf[64];
+    SNPRINTF(buf, sizeof(buf), "syntax error at line %d near: ", in.line());
+    *err = buf;
+    while (1) {
+      int ch = in.getc();
+      if (ch == -1 || ch == '\n') {
+        break;
+      } else if (ch >= ' ') {
+        err->push_back(static_cast<char>(ch));
+      }
+    }
+  }
+  return in.cur();
+}
+
+template <typename Iter> inline Iter parse(value &out, const Iter &first, const Iter &last, std::string *err) {
+  default_parse_context ctx(&out);
+  return _parse(ctx, first, last, err);
+}
+
+inline std::string parse(value &out, const std::string &s) {
+  std::string err;
+  parse(out, s.begin(), s.end(), &err);
+  return err;
+}
+
+inline std::string parse(value &out, std::istream &is) {
+  std::string err;
+  parse(out, std::istreambuf_iterator<char>(is.rdbuf()), std::istreambuf_iterator<char>(), &err);
+  return err;
+}
+
+template <typename T> struct last_error_t { static std::string s; };
+template <typename T> std::string last_error_t<T>::s;
+
+inline void set_last_error(const std::string &s) {
+  last_error_t<bool>::s = s;
+}
+
+inline const std::string &get_last_error() {
+  return last_error_t<bool>::s;
+}
+
+inline bool operator==(const value &x, const value &y) {
+  if (x.is<null>())
+    return y.is<null>();
+#define PICOJSON_CMP(type)                                                                                                         \
+  if (x.is<type>())                                                                                                                \
+  return y.is<type>() && x.get<type>() == y.get<type>()
+  PICOJSON_CMP(bool);
+  PICOJSON_CMP(double);
+  PICOJSON_CMP(std::string);
+  PICOJSON_CMP(array);
+  PICOJSON_CMP(object);
+#undef PICOJSON_CMP
+  PICOJSON_ASSERT(0);
+#ifdef _MSC_VER
+  __assume(0);
+#endif
+  return false;
+}
+
+inline bool operator!=(const value &x, const value &y) {
+  return !(x == y);
+}
+}
+
+#if !PICOJSON_USE_RVALUE_REFERENCE
+namespace std {
+template <> inline void swap(picojson::value &x, picojson::value &y) {
+  x.swap(y);
+}
+}
+#endif
+
+inline std::istream &operator>>(std::istream &is, picojson::value &x) {
+  picojson::set_last_error(std::string());
+  const std::string err(picojson::parse(x, is));
+  if (!err.empty()) {
+    picojson::set_last_error(err);
+    is.setstate(std::ios::failbit);
+  }
+  return is;
+}
+
+inline std::ostream &operator<<(std::ostream &os, const picojson::value &x) {
+  x.serialize(std::ostream_iterator<char>(os));
+  return os;
+}
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/externals/simplecpp/CMakeLists.txt b/externals/simplecpp/CMakeLists.txt
index 90d22f77f7e..50f139739a7 100644
--- a/externals/simplecpp/CMakeLists.txt
+++ b/externals/simplecpp/CMakeLists.txt
@@ -1,6 +1,11 @@
 file(GLOB hdrs "*.h")
 file(GLOB srcs "*.cpp")
 
-add_library(simplecpp_objs OBJECT ${srcs} ${hdrs})
+add_library(simplecpp ${srcs} ${hdrs})
+target_dll_compile_definitions(simplecpp EXPORT SIMPLECPP_EXPORT IMPORT SIMPLECPP_IMPORT)
 
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    target_compile_options_safe(simplecpp -Wno-zero-as-null-pointer-constant)
+endif()
 
+target_externals_include_directories(simplecpp PUBLIC .)
diff --git a/externals/simplecpp/LICENSE b/externals/simplecpp/LICENSE
index 341c30bda44..b1f013e92fa 100644
--- a/externals/simplecpp/LICENSE
+++ b/externals/simplecpp/LICENSE
@@ -1,166 +1,14 @@
-                   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
+BSD Zero Clause License
 
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
+Copyright (c) 2023 simplecpp team
 
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
 
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
-  0. Additional Definitions.
-
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
-  1. Exception to Section 3 of the GNU GPL.
-
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
-  2. Conveying Modified Versions.
-
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
-
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.
-
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
diff --git a/externals/simplecpp/simplecpp.cpp b/externals/simplecpp/simplecpp.cpp
index f94710b357a..7afc17ab735 100644
--- a/externals/simplecpp/simplecpp.cpp
+++ b/externals/simplecpp/simplecpp.cpp
@@ -1,43 +1,60 @@
 /*
  * simplecpp - A simple and high-fidelity C/C++ preprocessor library
- * Copyright (C) 2016 Daniel Marjamäki.
- *
- * This library is free software: you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation, either
- * version 3 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ * Copyright (C) 2016-2023 simplecpp team
  */
 
-#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)
-#define SIMPLECPP_WINDOWS
-#define NOMINMAX
+#if defined(_WIN32)
+#  ifndef _WIN32_WINNT
+#    define _WIN32_WINNT 0x0602
+#  endif
+#  ifndef NOMINMAX
+#    define NOMINMAX
+#  endif
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#  undef ERROR
 #endif
+
 #include "simplecpp.h"
 
+#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)
+#  define SIMPLECPP_WINDOWS
+#endif
+
 #include <algorithm>
+#include <cassert>
+#include <cctype>
+#include <climits>
+#include <cstddef> // IWYU pragma: keep
+#include <cstdint>
+#include <cstdio>
 #include <cstdlib>
 #include <cstring>
-#include <exception>
+#include <ctime>
 #include <fstream>
 #include <iostream>
+#include <istream>
 #include <limits>
+#include <list>
+#include <map>
+#include <set>
 #include <sstream>
 #include <stack>
 #include <stdexcept>
+#include <string>
+#ifdef SIMPLECPP_WINDOWS
+#  include <mutex>
+#endif
+#include <unordered_map>
 #include <utility>
+#include <vector>
 
-#ifdef SIMPLECPP_WINDOWS
-#include <windows.h>
-#undef ERROR
-#undef TRUE
+#ifdef _WIN32
+#  include <direct.h>
+#else
+#  include <sys/stat.h>
 #endif
 
 static bool isHex(const std::string &s)
@@ -50,6 +67,17 @@ static bool isOct(const std::string &s)
     return s.size()>1 && (s[0]=='0') && (s[1] >= '0') && (s[1] < '8');
 }
 
+static bool isStringLiteral(const std::string &s)
+{
+    return s.size() > 1 && (s[0]=='\"') && (*s.rbegin()=='\"');
+}
+
+static bool isCharLiteral(const std::string &s)
+{
+    // char literal patterns can include 'a', '\t', '\000', '\xff', 'abcd', and maybe ''
+    // This only checks for the surrounding '' but doesn't parse the content.
+    return s.size() > 1 && (s[0]=='\'') && (*s.rbegin()=='\'');
+}
 
 static const simplecpp::TokenString DEFINE("define");
 static const simplecpp::TokenString UNDEF("undef");
@@ -70,13 +98,25 @@ static const simplecpp::TokenString ENDIF("endif");
 static const simplecpp::TokenString PRAGMA("pragma");
 static const simplecpp::TokenString ONCE("once");
 
+static const simplecpp::TokenString HAS_INCLUDE("__has_include");
+
 template<class T> static std::string toString(T t)
 {
+    // NOLINTNEXTLINE(misc-const-correctness) - false positive
     std::ostringstream ostr;
     ostr << t;
     return ostr.str();
 }
 
+#ifdef SIMPLECPP_DEBUG_MACRO_EXPANSION
+static std::string locstring(const simplecpp::Location &loc)
+{
+    std::ostringstream ostr;
+    ostr << '[' << loc.file() << ':' << loc.line << ':' << loc.col << ']';
+    return ostr.str();
+}
+#endif
+
 static long long stringToLL(const std::string &s)
 {
     long long ret;
@@ -105,14 +145,9 @@ static unsigned long long stringToULL(const std::string &s)
     return ret;
 }
 
-static bool startsWith(const std::string &str, const std::string &s)
-{
-    return (str.size() >= s.size() && str.compare(0, s.size(), s) == 0);
-}
-
 static bool endsWith(const std::string &s, const std::string &e)
 {
-    return (s.size() >= e.size() && s.compare(s.size() - e.size(), e.size(), e) == 0);
+    return (s.size() >= e.size()) && std::equal(e.rbegin(), e.rend(), s.rbegin());
 }
 
 static bool sameline(const simplecpp::Token *tok1, const simplecpp::Token *tok2)
@@ -137,12 +172,16 @@ static bool isAlternativeUnaryOp(const simplecpp::Token *tok, const std::string
             (tok->next && (tok->next->name || tok->next->number)));
 }
 
-
-const std::string simplecpp::Location::emptyFileName;
+static std::string replaceAll(std::string s, const std::string& from, const std::string& to)
+{
+    for (size_t pos = s.find(from); pos != std::string::npos; pos = s.find(from, pos + to.size()))
+        s.replace(pos, from.size(), to);
+    return s;
+}
 
 void simplecpp::Location::adjust(const std::string &str)
 {
-    if (str.find_first_of("\r\n") == std::string::npos) {
+    if (strpbrk(str.c_str(), "\r\n") == nullptr) {
         col += str.size();
         return;
     }
@@ -160,17 +199,17 @@ void simplecpp::Location::adjust(const std::string &str)
 
 bool simplecpp::Token::isOneOf(const char ops[]) const
 {
-    return (op != '\0') && (std::strchr(ops, op) != NULL);
+    return (op != '\0') && (std::strchr(ops, op) != nullptr);
 }
 
 bool simplecpp::Token::startsWithOneOf(const char c[]) const
 {
-    return std::strchr(c, string[0]) != NULL;
+    return std::strchr(c, string[0]) != nullptr;
 }
 
 bool simplecpp::Token::endsWithOneOf(const char c[]) const
 {
-    return std::strchr(c, string[string.size() - 1U]) != NULL;
+    return std::strchr(c, string[string.size() - 1U]) != nullptr;
 }
 
 void simplecpp::Token::printAll() const
@@ -198,25 +237,273 @@ void simplecpp::Token::printOut() const
     std::cout << std::endl;
 }
 
-simplecpp::TokenList::TokenList(std::vector<std::string> &filenames) : frontToken(NULL), backToken(NULL), files(filenames) {}
+// cppcheck-suppress noConstructor - we call init() in the inherited to initialize the private members
+class simplecpp::TokenList::Stream {
+public:
+    virtual ~Stream() = default;
+
+    virtual int get() = 0;
+    virtual int peek() = 0;
+    virtual void unget() = 0;
+    virtual bool good() = 0;
+
+    unsigned char readChar() {
+        auto ch = static_cast<unsigned char>(get());
+
+        // For UTF-16 encoded files the BOM is 0xfeff/0xfffe. If the
+        // character is non-ASCII character then replace it with 0xff
+        if (isUtf16) {
+            const auto ch2 = static_cast<unsigned char>(get());
+            const int ch16 = makeUtf16Char(ch, ch2);
+            ch = static_cast<unsigned char>(((ch16 >= 0x80) ? 0xff : ch16));
+        }
+
+        // Handling of newlines..
+        if (ch == '\r') {
+            ch = '\n';
+
+            int ch2 = get();
+            if (isUtf16) {
+                const int c2 = get();
+                ch2 = makeUtf16Char(ch2, c2);
+            }
+
+            if (ch2 != '\n')
+                ungetChar();
+        }
+
+        return ch;
+    }
+
+    unsigned char peekChar() {
+        auto ch = static_cast<unsigned char>(peek());
+
+        // For UTF-16 encoded files the BOM is 0xfeff/0xfffe. If the
+        // character is non-ASCII character then replace it with 0xff
+        if (isUtf16) {
+            (void)get();
+            const auto ch2 = static_cast<unsigned char>(peek());
+            unget();
+            const int ch16 = makeUtf16Char(ch, ch2);
+            ch = static_cast<unsigned char>(((ch16 >= 0x80) ? 0xff : ch16));
+        }
+
+        // Handling of newlines..
+        if (ch == '\r')
+            ch = '\n';
+
+        return ch;
+    }
+
+    void ungetChar() {
+        unget();
+        if (isUtf16)
+            unget();
+    }
+
+protected:
+    void init() {
+        // initialize since we use peek() in getAndSkipBOM()
+        isUtf16 = false;
+        bom = getAndSkipBOM();
+        isUtf16 = (bom == 0xfeff || bom == 0xfffe);
+    }
+
+private:
+    inline int makeUtf16Char(const unsigned char ch, const unsigned char ch2) const {
+        return (bom == 0xfeff) ? (ch<<8 | ch2) : (ch2<<8 | ch);
+    }
+
+    unsigned short getAndSkipBOM() {
+        const int ch1 = peek();
+
+        // The UTF-16 BOM is 0xfffe or 0xfeff.
+        if (ch1 >= 0xfe) {
+            (void)get();
+            const unsigned short byte = (static_cast<unsigned char>(ch1) << 8);
+            if (peek() >= 0xfe)
+                return byte | static_cast<unsigned char>(get());
+            unget();
+            return 0;
+        }
+
+        // Skip UTF-8 BOM 0xefbbbf
+        if (ch1 == 0xef) {
+            (void)get();
+            if (peek() == 0xbb) {
+                (void)get();
+                if (peek() == 0xbf) {
+                    (void)get();
+                    return 0;
+                }
+                unget();
+            }
+            unget();
+        }
+
+        return 0;
+    }
+
+    unsigned short bom;
+protected:
+    bool isUtf16;
+};
+
+namespace {
+    class StdIStream : public simplecpp::TokenList::Stream {
+    public:
+        // cppcheck-suppress uninitDerivedMemberVar - we call Stream::init() to initialize the private members
+        explicit StdIStream(std::istream &istr)
+            : istr(istr) {
+            assert(istr.good());
+            init();
+        }
+
+        int get() override {
+            return istr.get();
+        }
+        int peek() override {
+            return istr.peek();
+        }
+        void unget() override {
+            istr.unget();
+        }
+        bool good() override {
+            return istr.good();
+        }
+
+    private:
+        std::istream &istr;
+    };
+
+    class StdCharBufStream : public simplecpp::TokenList::Stream {
+    public:
+        // cppcheck-suppress uninitDerivedMemberVar - we call Stream::init() to initialize the private members
+        StdCharBufStream(const unsigned char* str, std::size_t size)
+            : str(str)
+            , size(size)
+        {
+            init();
+        }
+
+        int get() override {
+            if (pos >= size)
+                return lastStatus = EOF;
+            return str[pos++];
+        }
+        int peek() override {
+            if (pos >= size)
+                return lastStatus = EOF;
+            return str[pos];
+        }
+        void unget() override {
+            --pos;
+        }
+        bool good() override {
+            return lastStatus != EOF;
+        }
+
+    private:
+        const unsigned char *str;
+        const std::size_t size;
+        std::size_t pos{};
+        int lastStatus{};
+    };
+
+    class FileStream : public simplecpp::TokenList::Stream {
+    public:
+        /**
+         * @throws simplecpp::Output thrown if file is not found
+         */
+        // cppcheck-suppress uninitDerivedMemberVar - we call Stream::init() to initialize the private members
+        explicit FileStream(const std::string &filename, std::vector<std::string> &files)
+            : file(fopen(filename.c_str(), "rb"))
+        {
+            if (!file) {
+                files.emplace_back(filename);
+                throw simplecpp::Output(simplecpp::Output::FILE_NOT_FOUND, {}, "File is missing: " + filename);
+            }
+            init();
+        }
+
+        FileStream(const FileStream&) = delete;
+        FileStream &operator=(const FileStream&) = delete;
+
+        ~FileStream() override {
+            fclose(file);
+            file = nullptr;
+        }
+
+        int get() override {
+            lastStatus = lastCh = fgetc(file);
+            return lastCh;
+        }
+        int peek() override {
+            // keep lastCh intact
+            const int ch = fgetc(file);
+            unget_internal(ch);
+            return ch;
+        }
+        void unget() override {
+            unget_internal(lastCh);
+        }
+        bool good() override {
+            return lastStatus != EOF;
+        }
+
+    private:
+        void unget_internal(int ch) {
+            if (isUtf16) {
+                // TODO: use ungetc() as well
+                // UTF-16 has subsequent unget() calls
+                fseek(file, -1, SEEK_CUR);
+            } else {
+                ungetc(ch, file);
+            }
+        }
+
+        FILE *file;
+        int lastCh{};
+        int lastStatus{};
+    };
+}
+
+simplecpp::TokenList::TokenList(std::vector<std::string> &filenames) : frontToken(nullptr), backToken(nullptr), files(filenames) {}
 
 simplecpp::TokenList::TokenList(std::istream &istr, std::vector<std::string> &filenames, const std::string &filename, OutputList *outputList)
-    : frontToken(NULL), backToken(NULL), files(filenames)
+    : frontToken(nullptr), backToken(nullptr), files(filenames)
+{
+    StdIStream stream(istr);
+    readfile(stream,filename,outputList);
+}
+
+simplecpp::TokenList::TokenList(const unsigned char* data, std::size_t size, std::vector<std::string> &filenames, const std::string &filename, OutputList *outputList, int /*unused*/)
+    : frontToken(nullptr), backToken(nullptr), files(filenames)
 {
-    readfile(istr,filename,outputList);
+    StdCharBufStream stream(data, size);
+    readfile(stream,filename,outputList);
+}
+
+simplecpp::TokenList::TokenList(const std::string &filename, std::vector<std::string> &filenames, OutputList *outputList)
+    : frontToken(nullptr), backToken(nullptr), files(filenames)
+{
+    try {
+        FileStream stream(filename, filenames);
+        readfile(stream,filename,outputList);
+    } catch (const simplecpp::Output & e) {
+        outputList->emplace_back(e);
+    }
 }
 
-simplecpp::TokenList::TokenList(const TokenList &other) : frontToken(NULL), backToken(NULL), files(other.files)
+simplecpp::TokenList::TokenList(const TokenList &other) : frontToken(nullptr), backToken(nullptr), files(other.files)
 {
     *this = other;
 }
 
-#if __cplusplus >= 201103L
-simplecpp::TokenList::TokenList(TokenList &&other) : frontToken(NULL), backToken(NULL), files(other.files)
+simplecpp::TokenList::TokenList(TokenList &&other) : frontToken(nullptr), backToken(nullptr), files(other.files)
 {
     *this = std::move(other);
 }
-#endif
 
 simplecpp::TokenList::~TokenList()
 {
@@ -227,6 +514,7 @@ simplecpp::TokenList &simplecpp::TokenList::operator=(const TokenList &other)
 {
     if (this != &other) {
         clear();
+        files = other.files;
         for (const Token *tok = other.cfront(); tok; tok = tok->next)
             push_back(new Token(*tok));
         sizeOfType = other.sizeOfType;
@@ -234,26 +522,25 @@ simplecpp::TokenList &simplecpp::TokenList::operator=(const TokenList &other)
     return *this;
 }
 
-#if __cplusplus >= 201103L
 simplecpp::TokenList &simplecpp::TokenList::operator=(TokenList &&other)
 {
     if (this != &other) {
         clear();
-        backToken = other.backToken;
-        other.backToken = NULL;
         frontToken = other.frontToken;
-        other.frontToken = NULL;
+        other.frontToken = nullptr;
+        backToken = other.backToken;
+        other.backToken = nullptr;
+        files = other.files;
         sizeOfType = std::move(other.sizeOfType);
     }
     return *this;
 }
-#endif
 
 void simplecpp::TokenList::clear()
 {
-    backToken = NULL;
+    backToken = nullptr;
     while (frontToken) {
-        Token *next = frontToken->next;
+        Token * const next = frontToken->next;
         delete frontToken;
         frontToken = next;
     }
@@ -270,24 +557,34 @@ void simplecpp::TokenList::push_back(Token *tok)
     backToken = tok;
 }
 
-void simplecpp::TokenList::dump() const
+void simplecpp::TokenList::dump(bool linenrs) const
 {
-    std::cout << stringify() << std::endl;
+    std::cout << stringify(linenrs) << std::endl;
 }
 
-std::string simplecpp::TokenList::stringify() const
+std::string simplecpp::TokenList::stringify(bool linenrs) const
 {
     std::ostringstream ret;
-    Location loc(files);
+    Location loc;
+    loc.line = 1;
+    bool filechg = true;
     for (const Token *tok = cfront(); tok; tok = tok->next) {
         if (tok->location.line < loc.line || tok->location.fileIndex != loc.fileIndex) {
-            ret << "\n#line " << tok->location.line << " \"" << tok->location.file() << "\"\n";
+            ret << "\n#line " << tok->location.line << " \"" << file(tok->location) << "\"\n";
             loc = tok->location;
+            filechg = true;
+        }
+
+        if (linenrs && filechg) {
+            ret << loc.line << ": ";
+            filechg = false;
         }
 
         while (tok->location.line > loc.line) {
             ret << '\n';
             loc.line++;
+            if (linenrs)
+                ret << loc.line << ": ";
         }
 
         if (sameline(tok->previous, tok))
@@ -301,92 +598,6 @@ std::string simplecpp::TokenList::stringify() const
     return ret.str();
 }
 
-static unsigned char readChar(std::istream &istr, unsigned int bom)
-{
-    unsigned char ch = (unsigned char)istr.get();
-
-    // For UTF-16 encoded files the BOM is 0xfeff/0xfffe. If the
-    // character is non-ASCII character then replace it with 0xff
-    if (bom == 0xfeff || bom == 0xfffe) {
-        const unsigned char ch2 = (unsigned char)istr.get();
-        const int ch16 = (bom == 0xfeff) ? (ch<<8 | ch2) : (ch2<<8 | ch);
-        ch = (unsigned char)((ch16 >= 0x80) ? 0xff : ch16);
-    }
-
-    // Handling of newlines..
-    if (ch == '\r') {
-        ch = '\n';
-        if (bom == 0 && (char)istr.peek() == '\n')
-            (void)istr.get();
-        else if (bom == 0xfeff || bom == 0xfffe) {
-            int c1 = istr.get();
-            int c2 = istr.get();
-            int ch16 = (bom == 0xfeff) ? (c1<<8 | c2) : (c2<<8 | c1);
-            if (ch16 != '\n') {
-                istr.unget();
-                istr.unget();
-            }
-        }
-    }
-
-    return ch;
-}
-
-static unsigned char peekChar(std::istream &istr, unsigned int bom)
-{
-    unsigned char ch = (unsigned char)istr.peek();
-
-    // For UTF-16 encoded files the BOM is 0xfeff/0xfffe. If the
-    // character is non-ASCII character then replace it with 0xff
-    if (bom == 0xfeff || bom == 0xfffe) {
-        (void)istr.get();
-        const unsigned char ch2 = (unsigned char)istr.peek();
-        istr.unget();
-        const int ch16 = (bom == 0xfeff) ? (ch<<8 | ch2) : (ch2<<8 | ch);
-        ch = (unsigned char)((ch16 >= 0x80) ? 0xff : ch16);
-    }
-
-    // Handling of newlines..
-    if (ch == '\r')
-        ch = '\n';
-
-    return ch;
-}
-
-static void ungetChar(std::istream &istr, unsigned int bom)
-{
-    istr.unget();
-    if (bom == 0xfeff || bom == 0xfffe)
-        istr.unget();
-}
-
-static unsigned short getAndSkipBOM(std::istream &istr)
-{
-    const int ch1 = istr.peek();
-
-    // The UTF-16 BOM is 0xfffe or 0xfeff.
-    if (ch1 >= 0xfe) {
-        unsigned short bom = ((unsigned char)istr.get() << 8);
-        if (istr.peek() >= 0xfe)
-            return bom | (unsigned char)istr.get();
-        istr.unget();
-        return 0;
-    }
-
-    // Skip UTF-8 BOM 0xefbbbf
-    if (ch1 == 0xef) {
-        (void)istr.get();
-        if (istr.get() == 0xbb && istr.peek() == 0xbf) {
-            (void)istr.get();
-        } else {
-            istr.unget();
-            istr.unget();
-        }
-    }
-
-    return 0;
-}
-
 static bool isNameChar(unsigned char ch)
 {
     return std::isalnum(ch) || ch == '_' || ch == '$';
@@ -397,7 +608,7 @@ static std::string escapeString(const std::string &str)
     std::ostringstream ostr;
     ostr << '\"';
     for (std::size_t i = 1U; i < str.size() - 1; ++i) {
-        char c = str[i];
+        const char c = str[i];
         if (c == '\\' || c == '\"' || c == '\'')
             ostr << '\\';
         ostr << c;
@@ -406,15 +617,16 @@ static std::string escapeString(const std::string &str)
     return ostr.str();
 }
 
-static void portabilityBackslash(simplecpp::OutputList *outputList, const std::vector<std::string> &files, const simplecpp::Location &location)
+static void portabilityBackslash(simplecpp::OutputList *outputList, const simplecpp::Location &location)
 {
     if (!outputList)
         return;
-    simplecpp::Output err(files);
-    err.type = simplecpp::Output::PORTABILITY_BACKSLASH;
-    err.location = location;
-    err.msg = "Combination 'backslash space newline' is not portable.";
-    outputList->push_back(err);
+    simplecpp::Output err{
+        simplecpp::Output::PORTABILITY_BACKSLASH,
+        location,
+        "Combination 'backslash space newline' is not portable."
+    };
+    outputList->emplace_back(std::move(err));
 }
 
 static bool isStringLiteralPrefix(const std::string &str)
@@ -423,16 +635,16 @@ static bool isStringLiteralPrefix(const std::string &str)
            str == "R" || str == "uR" || str == "UR" || str == "LR" || str == "u8R";
 }
 
-void simplecpp::TokenList::lineDirective(unsigned int fileIndex, unsigned int line, Location *location)
+void simplecpp::TokenList::lineDirective(unsigned int fileIndex, unsigned int line, Location &location)
 {
-    if (fileIndex != location->fileIndex || line >= location->line) {
-        location->fileIndex = fileIndex;
-        location->line = line;
+    if (fileIndex != location.fileIndex || line >= location.line) {
+        location.fileIndex = fileIndex;
+        location.line = line;
         return;
     }
 
-    if (line + 2 >= location->line) {
-        location->line = line;
+    if (line + 2 >= location.line) {
+        location.line = line;
         while (cback()->op != '#')
             deleteToken(back());
         deleteToken(back());
@@ -440,36 +652,30 @@ void simplecpp::TokenList::lineDirective(unsigned int fileIndex, unsigned int li
     }
 }
 
-void simplecpp::TokenList::readfile(std::istream &istr, const std::string &filename, OutputList *outputList)
+static const std::string COMMENT_END("*/");
+
+void simplecpp::TokenList::readfile(Stream &stream, const std::string &filename, OutputList *outputList)
 {
     std::stack<simplecpp::Location> loc;
 
     unsigned int multiline = 0U;
 
-    const Token *oldLastToken = NULL;
-
-    const unsigned short bom = getAndSkipBOM(istr);
+    const Token *oldLastToken = nullptr;
 
-    Location location(files);
-    location.fileIndex = fileIndex(filename);
-    location.line = 1U;
-    location.col  = 1U;
-    while (istr.good()) {
-        unsigned char ch = readChar(istr,bom);
-        if (!istr.good())
+    Location location(fileIndex(filename), 1, 1);
+    while (stream.good()) {
+        unsigned char ch = stream.readChar();
+        if (!stream.good())
             break;
-        if (ch < ' ' && ch != '\t' && ch != '\n' && ch != '\r')
-            ch = ' ';
 
         if (ch >= 0x80) {
             if (outputList) {
-                simplecpp::Output err(files);
-                err.type = simplecpp::Output::UNHANDLED_CHAR_ERROR;
-                err.location = location;
-                std::ostringstream s;
-                s << (int)ch;
-                err.msg = "The code contains unhandled character(s) (character code=" + s.str() + "). Neither unicode nor extended ascii is supported.";
-                outputList->push_back(err);
+                simplecpp::Output err{
+                    simplecpp::Output::UNHANDLED_CHAR_ERROR,
+                    location,
+                    "The code contains unhandled character(s) (character code=" + std::to_string(static_cast<int>(ch)) + "). Neither unicode nor extended ascii is supported."
+                };
+                outputList->emplace_back(std::move(err));
             }
             clear();
             return;
@@ -478,7 +684,7 @@ void simplecpp::TokenList::readfile(std::istream &istr, const std::string &filen
         if (ch == '\n') {
             if (cback() && cback()->op == '\\') {
                 if (location.col > cback()->location.col + 1U)
-                    portabilityBackslash(outputList, files, cback()->location);
+                    portabilityBackslash(outputList, cback()->location);
                 ++multiline;
                 deleteToken(back());
             } else {
@@ -490,19 +696,56 @@ void simplecpp::TokenList::readfile(std::istream &istr, const std::string &filen
 
             if (oldLastToken != cback()) {
                 oldLastToken = cback();
-                const std::string lastline(lastLine());
-                if (lastline == "# file %str%") {
-                    loc.push(location);
-                    location.fileIndex = fileIndex(cback()->str().substr(1U, cback()->str().size() - 2U));
-                    location.line = 1U;
-                } else if (lastline == "# line %num%") {
-                    lineDirective(location.fileIndex, std::atol(cback()->str().c_str()), &location);
-                } else if (lastline == "# %num% %str%" || lastline == "# line %num% %str%") {
-                    lineDirective(fileIndex(cback()->str().substr(1U, cback()->str().size() - 2U)),
-                                  std::atol(cback()->previous->str().c_str()), &location);
+                const Token * const llTok = isLastLinePreprocessor();
+                if (!llTok)
+                    continue;
+                const Token * const llNextToken = llTok->next;
+                if (!llTok->next)
+                    continue;
+                if (llNextToken->next) {
+                    // #file "file.c"
+                    if (llNextToken->str() == "file" &&
+                        llNextToken->next->str()[0] == '\"')
+                    {
+                        const Token *strtok = cback();
+                        while (strtok->comment)
+                            strtok = strtok->previous;
+                        loc.push(location);
+                        location.fileIndex = fileIndex(strtok->str().substr(1U, strtok->str().size() - 2U));
+                        location.line = 1U;
+                    }
+                    // TODO: add support for "# 3"
+                    // #3 "file.c"
+                    // #line 3 "file.c"
+                    else if ((llNextToken->number &&
+                              llNextToken->next->str()[0] == '\"') ||
+                             (llNextToken->str() == "line" &&
+                              llNextToken->next->number &&
+                              llNextToken->next->next &&
+                              llNextToken->next->next->str()[0] == '\"'))
+                    {
+                        const Token *strtok = cback();
+                        while (strtok->comment)
+                            strtok = strtok->previous;
+                        const Token *numtok = strtok->previous;
+                        while (numtok->comment)
+                            numtok = numtok->previous;
+                        lineDirective(fileIndex(replaceAll(strtok->str().substr(1U, strtok->str().size() - 2U),"\\\\","\\")),
+                                      std::atol(numtok->str().c_str()), location);
+                    }
+                    // #line 3
+                    else if (llNextToken->str() == "line" &&
+                             llNextToken->next->number)
+                    {
+                        const Token *numtok = cback();
+                        while (numtok->comment)
+                            numtok = numtok->previous;
+                        lineDirective(location.fileIndex, std::atol(numtok->str().c_str()), location);
+                    }
                 }
                 // #endfile
-                else if (lastline == "# endfile" && !loc.empty()) {
+                else if (llNextToken->str() == "endfile" && !loc.empty())
+                {
                     location = loc.top();
                     loc.pop();
                 }
@@ -511,66 +754,87 @@ void simplecpp::TokenList::readfile(std::istream &istr, const std::string &filen
             continue;
         }
 
-        if (std::isspace(ch)) {
+        if (ch <= ' ') {
             location.col++;
             continue;
         }
 
         TokenString currentToken;
 
-        if (cback() && cback()->location.line == location.line && cback()->previous && cback()->previous->op == '#' && (lastLine() == "# error" || lastLine() == "# warning")) {
-            char prev = ' ';
-            while (istr.good() && (prev == '\\' || (ch != '\r' && ch != '\n'))) {
-                currentToken += ch;
-                prev = ch;
-                ch = readChar(istr, bom);
+        if (cback() && cback()->location.line == location.line && cback()->previous && cback()->previous->op == '#') {
+            const Token* const ppTok = cback()->previous;
+            if (ppTok->next && (ppTok->next->str() == "error" || ppTok->next->str() == "warning")) {
+                char prev = ' ';
+                while (stream.good() && (prev == '\\' || (ch != '\r' && ch != '\n'))) {
+                    currentToken += ch;
+                    prev = ch;
+                    ch = stream.readChar();
+                }
+                stream.ungetChar();
+                push_back(new Token(currentToken, location));
+                location.adjust(currentToken);
+                continue;
             }
-            ungetChar(istr, bom);
-            push_back(new Token(currentToken, location));
-            location.adjust(currentToken);
-            continue;
         }
 
         // number or name
         if (isNameChar(ch)) {
-            const bool num = std::isdigit(ch);
-            while (istr.good() && isNameChar(ch)) {
+            const bool num = !!std::isdigit(ch);
+            while (stream.good() && isNameChar(ch)) {
                 currentToken += ch;
-                ch = readChar(istr,bom);
-                if (num && ch=='\'' && isNameChar(peekChar(istr,bom)))
-                    ch = readChar(istr,bom);
+                ch = stream.readChar();
+                if (num && ch=='\'' && isNameChar(stream.peekChar()))
+                    ch = stream.readChar();
             }
 
-            ungetChar(istr,bom);
+            stream.ungetChar();
         }
 
         // comment
-        else if (ch == '/' && peekChar(istr,bom) == '/') {
-            while (istr.good() && ch != '\r' && ch != '\n') {
+        else if (ch == '/' && stream.peekChar() == '/') {
+            while (stream.good() && ch != '\n') {
                 currentToken += ch;
-                ch = readChar(istr, bom);
+                ch = stream.readChar();
+                if (ch == '\\') {
+                    TokenString tmp;
+                    char tmp_ch = ch;
+                    while ((stream.good()) && (tmp_ch == '\\' || tmp_ch == ' ' || tmp_ch == '\t')) {
+                        tmp += tmp_ch;
+                        tmp_ch = stream.readChar();
+                    }
+                    if (!stream.good()) {
+                        break;
+                    }
+
+                    if (tmp_ch != '\n') {
+                        currentToken += tmp;
+                    } else {
+                        const TokenString check_portability = currentToken + tmp;
+                        const std::string::size_type pos = check_portability.find_last_not_of(" \t");
+                        if (pos < check_portability.size() - 1U && check_portability[pos] == '\\')
+                            portabilityBackslash(outputList, location);
+                        ++multiline;
+                        tmp_ch = stream.readChar();
+                        currentToken += '\n';
+                    }
+                    ch = tmp_ch;
+                }
             }
-            const std::string::size_type pos = currentToken.find_last_not_of(" \t");
-            if (pos < currentToken.size() - 1U && currentToken[pos] == '\\')
-                portabilityBackslash(outputList, files, location);
-            if (currentToken[currentToken.size() - 1U] == '\\') {
-                ++multiline;
-                currentToken.erase(currentToken.size() - 1U);
-            } else {
-                ungetChar(istr, bom);
+            if (ch == '\n') {
+                stream.ungetChar();
             }
         }
 
         // comment
-        else if (ch == '/' && peekChar(istr,bom) == '*') {
+        else if (ch == '/' && stream.peekChar() == '*') {
             currentToken = "/*";
-            (void)readChar(istr,bom);
-            ch = readChar(istr,bom);
-            while (istr.good()) {
+            (void)stream.readChar();
+            ch = stream.readChar();
+            while (stream.good()) {
                 currentToken += ch;
-                if (currentToken.size() >= 4U && endsWith(currentToken, "*/"))
+                if (currentToken.size() >= 4U && endsWith(currentToken, COMMENT_END))
                     break;
-                ch = readChar(istr,bom);
+                ch = stream.readChar();
             }
             // multiline..
 
@@ -579,7 +843,7 @@ void simplecpp::TokenList::readfile(std::istream &istr, const std::string &filen
                 currentToken.erase(pos,2);
                 ++multiline;
             }
-            if (multiline || startsWith(lastLine(10),"# ")) {
+            if (multiline || isLastLinePreprocessor()) {
                 pos = 0;
                 while ((pos = currentToken.find('\n',pos)) != std::string::npos) {
                     currentToken.erase(pos,1);
@@ -601,31 +865,33 @@ void simplecpp::TokenList::readfile(std::istream &istr, const std::string &filen
                 std::string delim;
                 currentToken = ch;
                 prefix.resize(prefix.size() - 1);
-                ch = readChar(istr,bom);
-                while (istr.good() && ch != '(' && ch != '\n') {
+                ch = stream.readChar();
+                while (stream.good() && ch != '(' && ch != '\n') {
                     delim += ch;
-                    ch = readChar(istr,bom);
+                    ch = stream.readChar();
                 }
-                if (!istr.good() || ch == '\n') {
+                if (!stream.good() || ch == '\n') {
                     if (outputList) {
-                        Output err(files);
-                        err.type = Output::SYNTAX_ERROR;
-                        err.location = location;
-                        err.msg = "Invalid newline in raw string delimiter.";
-                        outputList->push_back(err);
+                        Output err{
+                            Output::SYNTAX_ERROR,
+                            location,
+                            "Invalid newline in raw string delimiter."
+                        };
+                        outputList->emplace_back(std::move(err));
                     }
                     return;
                 }
                 const std::string endOfRawString(')' + delim + currentToken);
-                while (istr.good() && !(endsWith(currentToken, endOfRawString) && currentToken.size() > 1))
-                    currentToken += readChar(istr,bom);
+                while (stream.good() && (!endsWith(currentToken, endOfRawString) || currentToken.size() <= 1))
+                    currentToken += stream.readChar();
                 if (!endsWith(currentToken, endOfRawString)) {
                     if (outputList) {
-                        Output err(files);
-                        err.type = Output::SYNTAX_ERROR;
-                        err.location = location;
-                        err.msg = "Raw string missing terminating delimiter.";
-                        outputList->push_back(err);
+                        Output err{
+                            Output::SYNTAX_ERROR,
+                            location,
+                            "Raw string missing terminating delimiter."
+                        };
+                        outputList->emplace_back(std::move(err));
                     }
                     return;
                 }
@@ -635,14 +901,14 @@ void simplecpp::TokenList::readfile(std::istream &istr, const std::string &filen
                 back()->setstr(currentToken);
                 location.adjust(currentToken);
                 if (currentToken.find_first_of("\r\n") == std::string::npos)
-                    location.col += 2 + 2 * delim.size();
+                    location.col += 2 + (2 * delim.size());
                 else
                     location.col += 1 + delim.size();
 
                 continue;
             }
 
-            currentToken = readUntil(istr,location,ch,ch,outputList,bom);
+            currentToken = readUntil(stream,location,ch,ch,outputList);
             if (currentToken.size() < 2U)
                 // Error is reported by readUntil()
                 return;
@@ -656,16 +922,20 @@ void simplecpp::TokenList::readfile(std::istream &istr, const std::string &filen
             }
 
             if (prefix.empty())
-                push_back(new Token(s, location)); // push string without newlines
+                push_back(new Token(s, location, !!std::isspace(stream.peekChar()))); // push string without newlines
             else
                 back()->setstr(prefix + s);
 
-            if (newlines > 0 && lastLine().compare(0,9,"# define ") == 0) {
-                multiline += newlines;
-                location.adjust(s);
-            } else {
-                location.adjust(currentToken);
+            if (newlines > 0) {
+                const Token * const llTok = lastLineTok();
+                if (llTok && llTok->op == '#' && llTok->next && (llTok->next->str() == "define" || llTok->next->str() == "pragma") && llTok->next->next) {
+                    multiline += newlines;
+                    location.adjust(s);
+                    continue;
+                }
             }
+
+            location.adjust(currentToken);
             continue;
         }
 
@@ -673,13 +943,16 @@ void simplecpp::TokenList::readfile(std::istream &istr, const std::string &filen
             currentToken += ch;
         }
 
-        if (currentToken == "<" && lastLine() == "# include") {
-            currentToken = readUntil(istr, location, '<', '>', outputList, bom);
-            if (currentToken.size() < 2U)
-                return;
+        if (*currentToken.begin() == '<') {
+            const Token * const llTok = lastLineTok();
+            if (llTok && llTok->op == '#' && llTok->next && llTok->next->str() == "include") {
+                currentToken = readUntil(stream, location, '<', '>', outputList);
+                if (currentToken.size() < 2U)
+                    return;
+            }
         }
 
-        push_back(new Token(currentToken, location));
+        push_back(new Token(currentToken, location, !!std::isspace(stream.peekChar())));
 
         if (multiline)
             location.col += currentToken.size();
@@ -710,7 +983,7 @@ void simplecpp::TokenList::constFold()
         constFoldComparison(tok);
         constFoldBitwise(tok);
         constFoldLogicalOp(tok);
-        constFoldQuestionOp(&tok);
+        constFoldQuestionOp(tok);
 
         // If there is no '(' we are done with the constant folding
         if (tok->op != '(')
@@ -733,6 +1006,14 @@ static bool isFloatSuffix(const simplecpp::Token *tok)
     return c == 'f' || c == 'l';
 }
 
+static const std::string AND("and");
+static const std::string BITAND("bitand");
+static const std::string BITOR("bitor");
+static bool isAlternativeAndBitandBitor(const simplecpp::Token* tok)
+{
+    return isAlternativeBinaryOp(tok, AND) || isAlternativeBinaryOp(tok, BITAND) || isAlternativeBinaryOp(tok, BITOR);
+}
+
 void simplecpp::TokenList::combineOperators()
 {
     std::stack<bool> executableScope;
@@ -765,10 +1046,10 @@ void simplecpp::TokenList::combineOperators()
                 continue;
             }
             // float literals..
-            if (tok->previous && tok->previous->number) {
+            if (tok->previous && tok->previous->number && sameline(tok->previous, tok) && tok->previous->str().find_first_of("._") == std::string::npos) {
                 tok->setstr(tok->previous->str() + '.');
                 deleteToken(tok->previous);
-                if (isFloatSuffix(tok->next) || (tok->next && tok->next->startsWithOneOf("Ee"))) {
+                if (sameline(tok, tok->next) && (isFloatSuffix(tok->next) || (tok->next && tok->next->startsWithOneOf("AaBbCcDdEeFfPp") && !isAlternativeAndBitandBitor(tok->next)))) {
                     tok->setstr(tok->str() + tok->next->str());
                     deleteToken(tok->next);
                 }
@@ -780,7 +1061,10 @@ void simplecpp::TokenList::combineOperators()
         }
         // match: [0-9.]+E [+-] [0-9]+
         const char lastChar = tok->str()[tok->str().size() - 1];
-        if (tok->number && !isHex(tok->str()) && !isOct(tok->str()) && (lastChar == 'E' || lastChar == 'e') && tok->next && tok->next->isOneOf("+-") && tok->next->next && tok->next->next->number) {
+        if (tok->number && !isOct(tok->str()) &&
+            ((!isHex(tok->str()) && (lastChar == 'E' || lastChar == 'e')) ||
+             (isHex(tok->str()) && (lastChar == 'P' || lastChar == 'p'))) &&
+            tok->next && tok->next->isOneOf("+-") && tok->next->next && tok->next->next->number) {
             tok->setstr(tok->str() + tok->next->op + tok->next->next->str());
             deleteToken(tok->next);
             deleteToken(tok->next);
@@ -809,7 +1093,7 @@ void simplecpp::TokenList::combineOperators()
                     start = start->previous;
                 }
                 if (indentlevel == -1 && start) {
-                    const Token *ftok = start;
+                    const Token * const ftok = start;
                     bool isFuncDecl = ftok->name;
                     while (isFuncDecl) {
                         if (!start->name && start->str() != "::" && start->op != '*' && start->op != '&')
@@ -904,21 +1188,23 @@ void simplecpp::TokenList::constFoldMulDivRem(Token *tok)
             continue;
 
         long long result;
-        if (tok->op == '*')
+        if (tok->op == '*') {
             result = (stringToLL(tok->previous->str()) * stringToLL(tok->next->str()));
+        }
         else if (tok->op == '/' || tok->op == '%') {
-            long long rhs = stringToLL(tok->next->str());
+            const long long rhs = stringToLL(tok->next->str());
             if (rhs == 0)
                 throw std::overflow_error("division/modulo by zero");
-            long long lhs = stringToLL(tok->previous->str());
+            const long long lhs = stringToLL(tok->previous->str());
             if (rhs == -1 && lhs == std::numeric_limits<long long>::min())
                 throw std::overflow_error("division overflow");
             if (tok->op == '/')
                 result = (lhs / rhs);
             else
                 result = (lhs % rhs);
-        } else
+        } else {
             continue;
+        }
 
         tok = tok->previous;
         tok->setstr(toString(result));
@@ -1010,22 +1296,20 @@ void simplecpp::TokenList::constFoldComparison(Token *tok)
     }
 }
 
-static const std::string BITAND("bitand");
-static const std::string BITOR("bitor");
 static const std::string XOR("xor");
 void simplecpp::TokenList::constFoldBitwise(Token *tok)
 {
     Token * const tok1 = tok;
     for (const char *op = "&^|"; *op; op++) {
-        const std::string* altop;
+        const std::string* alternativeOp;
         if (*op == '&')
-            altop = &BITAND;
+            alternativeOp = &BITAND;
         else if (*op == '|')
-            altop = &BITOR;
+            alternativeOp = &BITOR;
         else
-            altop = &XOR;
+            alternativeOp = &XOR;
         for (tok = tok1; tok && tok->op != ')'; tok = tok->next) {
-            if (tok->op != *op && !isAlternativeBinaryOp(tok, *altop))
+            if (tok->op != *op && !isAlternativeBinaryOp(tok, *alternativeOp))
                 continue;
             if (!tok->previous || !tok->previous->number)
                 continue;
@@ -1046,7 +1330,6 @@ void simplecpp::TokenList::constFoldBitwise(Token *tok)
     }
 }
 
-static const std::string AND("and");
 static const std::string OR("or");
 void simplecpp::TokenList::constFoldLogicalOp(Token *tok)
 {
@@ -1077,10 +1360,11 @@ void simplecpp::TokenList::constFoldLogicalOp(Token *tok)
     }
 }
 
-void simplecpp::TokenList::constFoldQuestionOp(Token **tok1)
+void simplecpp::TokenList::constFoldQuestionOp(Token *&tok1)
 {
     bool gotoTok1 = false;
-    for (Token *tok = *tok1; tok && tok->op != ')'; tok =  gotoTok1 ? *tok1 : tok->next) {
+    // NOLINTNEXTLINE(misc-const-correctness) - technically correct but used to access non-const data
+    for (Token *tok = tok1; tok && tok->op != ')'; tok =  gotoTok1 ? tok1 : tok->next) {
         gotoTok1 = false;
         if (tok->str() != "?")
             continue;
@@ -1095,8 +1379,8 @@ void simplecpp::TokenList::constFoldQuestionOp(Token **tok1)
         Token * const falseTok = trueTok->next->next;
         if (!falseTok)
             throw std::runtime_error("invalid expression");
-        if (condTok == *tok1)
-            *tok1 = (condTok->str() != "0" ? trueTok : falseTok);
+        if (condTok == tok1)
+            tok1 = (condTok->str() != "0" ? trueTok : falseTok);
         deleteToken(condTok->next); // ?
         deleteToken(trueTok->next); // :
         deleteToken(condTok->str() == "0" ? trueTok : falseTok);
@@ -1109,22 +1393,22 @@ void simplecpp::TokenList::removeComments()
 {
     Token *tok = frontToken;
     while (tok) {
-        Token *tok1 = tok;
+        Token * const tok1 = tok;
         tok = tok->next;
         if (tok1->comment)
             deleteToken(tok1);
     }
 }
 
-std::string simplecpp::TokenList::readUntil(std::istream &istr, const Location &location, const char start, const char end, OutputList *outputList, unsigned int bom)
+std::string simplecpp::TokenList::readUntil(Stream &stream, const Location &location, const char start, const char end, OutputList *outputList)
 {
     std::string ret;
     ret += start;
 
     bool backslash = false;
     char ch = 0;
-    while (ch != end && ch != '\r' && ch != '\n' && istr.good()) {
-        ch = readChar(istr, bom);
+    while (ch != end && ch != '\r' && ch != '\n' && stream.good()) {
+        ch = stream.readChar();
         if (backslash && ch == '\n') {
             ch = 0;
             backslash = false;
@@ -1133,23 +1417,33 @@ std::string simplecpp::TokenList::readUntil(std::istream &istr, const Location &
         backslash = false;
         ret += ch;
         if (ch == '\\') {
-            const char next = readChar(istr, bom);
-            if (next == '\r' || next == '\n') {
-                ret.erase(ret.size()-1U);
-                backslash = (next == '\r');
-            }
-            ret += next;
+            bool update_ch = false;
+            char next = 0;
+            do {
+                next = stream.readChar();
+                if (next == '\r' || next == '\n') {
+                    ret.erase(ret.size()-1U);
+                    backslash = (next == '\r');
+                    update_ch = false;
+                } else if (next == '\\') {
+                    update_ch = !update_ch;
+                }
+                ret += next;
+            } while (next == '\\');
+            if (update_ch)
+                ch = next;
         }
     }
 
-    if (!istr.good() || ch != end) {
+    if (!stream.good() || ch != end) {
         clear();
         if (outputList) {
-            Output err(files);
-            err.type = Output::SYNTAX_ERROR;
-            err.location = location;
-            err.msg = std::string("No pair for character (") + start + "). Can't process file. File is either invalid or unicode, which is currently not supported.";
-            outputList->push_back(err);
+            Output err{
+                Output::SYNTAX_ERROR,
+                location,
+                std::string("No pair for character (") + start + "). Can't process file. File is either invalid or unicode, which is currently not supported."
+            };
+            outputList->emplace_back(std::move(err));
         }
         return "";
     }
@@ -1157,21 +1451,28 @@ std::string simplecpp::TokenList::readUntil(std::istream &istr, const Location &
     return ret;
 }
 
-std::string simplecpp::TokenList::lastLine(int maxsize) const
+const simplecpp::Token* simplecpp::TokenList::lastLineTok(int maxsize) const
 {
-    std::string ret;
+    const Token* prevTok = nullptr;
     int count = 0;
-    for (const Token *tok = cback(); sameline(tok,cback()); tok = tok->previous) {
+    for (const Token *tok = cback(); ; tok = tok->previous) {
+        if (!sameline(tok, cback()))
+            break;
         if (tok->comment)
             continue;
-        if (!ret.empty())
-            ret.insert(0, 1, ' ');
-        ret.insert(0, tok->str()[0] == '\"' ? std::string("%str%")
-                   : tok->number ? std::string("%num%") : tok->str());
         if (++count > maxsize)
-            return "";
+            return nullptr;
+        prevTok = tok;
     }
-    return ret;
+    return prevTok;
+}
+
+const simplecpp::Token* simplecpp::TokenList::isLastLinePreprocessor(int maxsize) const
+{
+    const Token * const prevTok = lastLineTok(maxsize);
+    if (prevTok && prevTok->op == '#')
+        return prevTok;
+    return nullptr;
 }
 
 unsigned int simplecpp::TokenList::fileIndex(const std::string &filename)
@@ -1180,18 +1481,30 @@ unsigned int simplecpp::TokenList::fileIndex(const std::string &filename)
         if (files[i] == filename)
             return i;
     }
-    files.push_back(filename);
+    files.emplace_back(filename);
     return files.size() - 1U;
 }
 
+const std::string& simplecpp::TokenList::file(const Location& loc) const
+{
+    static const std::string s_emptyFileName;
+    return loc.fileIndex < files.size() ? files[loc.fileIndex] : s_emptyFileName;
+}
+
 
 namespace simplecpp {
+    class Macro;
+    using MacroMap = std::unordered_map<TokenString,Macro>;
+
     class Macro {
     public:
-        explicit Macro(std::vector<std::string> &f) : nameTokDef(NULL), variadic(false), valueToken(NULL), endToken(NULL), files(f), tokenListDefine(f), valueDefinedInCode_(false) {}
+        explicit Macro(std::vector<std::string> &f) : nameTokDef(nullptr), valueToken(nullptr), endToken(nullptr), files(f), tokenListDefine(f), variadic(false), variadicOpt(false), valueDefinedInCode_(false) {}
 
-        Macro(const Token *tok, std::vector<std::string> &f) : nameTokDef(NULL), files(f), tokenListDefine(f), valueDefinedInCode_(true) {
-            if (sameline(tok->previous, tok))
+        /**
+         * @throws std::runtime_error thrown on bad macro syntax
+         */
+        Macro(const Token *tok, std::vector<std::string> &f) : nameTokDef(nullptr), files(f), tokenListDefine(f), valueDefinedInCode_(true) {
+            if (sameline(tok->previousSkipComments(), tok))
                 throw std::runtime_error("bad macro syntax");
             if (tok->op != '#')
                 throw std::runtime_error("bad macro syntax");
@@ -1206,28 +1519,45 @@ namespace simplecpp {
                 throw std::runtime_error("bad macro syntax");
         }
 
-        Macro(const std::string &name, const std::string &value, std::vector<std::string> &f) : nameTokDef(NULL), files(f), tokenListDefine(f), valueDefinedInCode_(false) {
+        /**
+         * @throws std::runtime_error thrown on bad macro syntax
+         */
+        Macro(const std::string &name, const std::string &value, std::vector<std::string> &f) : nameTokDef(nullptr), files(f), tokenListDefine(f), valueDefinedInCode_(false) {
             const std::string def(name + ' ' + value);
-            std::istringstream istr(def);
-            tokenListDefine.readfile(istr);
+            StdCharBufStream stream(reinterpret_cast<const unsigned char*>(def.data()), def.size());
+            tokenListDefine.readfile(stream);
             if (!parseDefine(tokenListDefine.cfront()))
                 throw std::runtime_error("bad macro syntax. macroname=" + name + " value=" + value);
         }
 
-        Macro(const Macro &macro) : nameTokDef(NULL), files(macro.files), tokenListDefine(macro.files), valueDefinedInCode_(macro.valueDefinedInCode_) {
-            *this = macro;
+        Macro(const Macro &other) : nameTokDef(nullptr), files(other.files), tokenListDefine(other.files), valueDefinedInCode_(other.valueDefinedInCode_) {
+            // TODO: remove the try-catch - see #537
+            // avoid bugprone-exception-escape clang-tidy warning
+            try {
+                *this = other;
+            }
+            catch (const Error&) {} // NOLINT(bugprone-empty-catch)
+        }
+
+        ~Macro() {
+            delete optExpandValue;
+            delete optNoExpandValue;
         }
 
-        void operator=(const Macro &macro) {
-            if (this != &macro) {
-                valueDefinedInCode_ = macro.valueDefinedInCode_;
-                if (macro.tokenListDefine.empty())
-                    parseDefine(macro.nameTokDef);
+        Macro &operator=(const Macro &other) {
+            if (this != &other) {
+                files = other.files;
+                valueDefinedInCode_ = other.valueDefinedInCode_;
+                if (other.tokenListDefine.empty()) {
+                    parseDefine(other.nameTokDef);
+                }
                 else {
-                    tokenListDefine = macro.tokenListDefine;
+                    tokenListDefine = other.tokenListDefine;
                     parseDefine(tokenListDefine.cfront());
                 }
+                usageList = other.usageList;
             }
+            return *this;
         }
 
         bool valueDefinedInCode() const {
@@ -1241,23 +1571,29 @@ namespace simplecpp {
          * @param macros     list of macros
          * @param inputFiles the input files
          * @return token after macro
-         * @throw Can throw wrongNumberOfParameters or invalidHashHash
+         * @throws Error thrown on missing or invalid preprocessor directives
+         * @throws wrongNumberOfParameters thrown on invalid number of parameters
+         * @throws invalidHashHash thrown on invalid ## usage
          */
-        const Token * expand(TokenList * const output,
+        const Token * expand(TokenList & output,
                              const Token * rawtok,
-                             const std::map<TokenString,Macro> &macros,
+                             const MacroMap &macros,
                              std::vector<std::string> &inputFiles) const {
             std::set<TokenString> expandedmacros;
 
+#ifdef SIMPLECPP_DEBUG_MACRO_EXPANSION
+            std::cout << "expand " << name() << " " << locstring(rawtok->location) << std::endl;
+#endif
+
             TokenList output2(inputFiles);
 
             if (functionLike() && rawtok->next && rawtok->next->op == '(') {
                 // Copy macro call to a new tokenlist with no linebreaks
                 const Token * const rawtok1 = rawtok;
                 TokenList rawtokens2(inputFiles);
-                rawtokens2.push_back(new Token(rawtok->str(), rawtok1->location));
+                rawtokens2.push_back(new Token(rawtok->str(), rawtok1->location, rawtok->whitespaceahead));
                 rawtok = rawtok->next;
-                rawtokens2.push_back(new Token(rawtok->str(), rawtok1->location));
+                rawtokens2.push_back(new Token(rawtok->str(), rawtok1->location, rawtok->whitespaceahead));
                 rawtok = rawtok->next;
                 int par = 1;
                 while (rawtok && par > 0) {
@@ -1267,13 +1603,13 @@ namespace simplecpp {
                         --par;
                     else if (rawtok->op == '#' && !sameline(rawtok->previous, rawtok))
                         throw Error(rawtok->location, "it is invalid to use a preprocessor directive as macro parameter");
-                    rawtokens2.push_back(new Token(rawtok->str(), rawtok1->location));
+                    rawtokens2.push_back(new Token(rawtok->str(), rawtok1->location, rawtok->whitespaceahead));
                     rawtok = rawtok->next;
                 }
-                if (expand(&output2, rawtok1->location, rawtokens2.cfront(), macros, expandedmacros))
+                if (expand(output2, rawtok1->location, rawtokens2.cfront(), macros, expandedmacros))
                     rawtok = rawtok1->next;
             } else {
-                rawtok = expand(&output2, rawtok->location, rawtok, macros, expandedmacros);
+                rawtok = expand(output2, rawtok->location, rawtok, macros, expandedmacros);
             }
             while (output2.cback() && rawtok) {
                 unsigned int par = 0;
@@ -1283,26 +1619,28 @@ namespace simplecpp {
                         if (par==0)
                             break;
                         --par;
-                    } else if (macro2tok->op == ')')
+                    } else if (macro2tok->op == ')') {
                         ++par;
+                    }
                     macro2tok = macro2tok->previous;
                 }
                 if (macro2tok) { // macro2tok->op == '('
                     macro2tok = macro2tok->previous;
                     expandedmacros.insert(name());
-                } else if (rawtok->op == '(')
+                } else if (rawtok->op == '(') {
                     macro2tok = output2.back();
+                }
                 if (!macro2tok || !macro2tok->name)
                     break;
                 if (output2.cfront() != output2.cback() && macro2tok->str() == this->name())
                     break;
-                const std::map<TokenString,Macro>::const_iterator macro = macros.find(macro2tok->str());
+                const MacroMap::const_iterator macro = macros.find(macro2tok->str());
                 if (macro == macros.end() || !macro->second.functionLike())
                     break;
                 TokenList rawtokens2(inputFiles);
                 const Location loc(macro2tok->location);
                 while (macro2tok) {
-                    Token *next = macro2tok->next;
+                    Token * const next = macro2tok->next;
                     rawtokens2.push_back(new Token(macro2tok->str(), loc));
                     output2.deleteToken(macro2tok);
                     macro2tok = next;
@@ -1311,8 +1649,9 @@ namespace simplecpp {
                 const Token *rawtok2 = rawtok;
                 for (; rawtok2; rawtok2 = rawtok2->next) {
                     rawtokens2.push_back(new Token(rawtok2->str(), loc));
-                    if (rawtok2->op == '(')
+                    if (rawtok2->op == '(') {
                         ++par;
+                    }
                     else if (rawtok2->op == ')') {
                         if (par <= 1U)
                             break;
@@ -1321,11 +1660,11 @@ namespace simplecpp {
                 }
                 if (!rawtok2 || par != 1U)
                     break;
-                if (macro->second.expand(&output2, rawtok->location, rawtokens2.cfront(), macros, expandedmacros) != NULL)
+                if (macro->second.expand(output2, rawtok->location, rawtokens2.cfront(), macros, expandedmacros) != nullptr)
                     break;
                 rawtok = rawtok2->next;
             }
-            output->takeTokens(output2);
+            output.takeTokens(output2);
             return rawtok;
         }
 
@@ -1355,8 +1694,8 @@ namespace simplecpp {
         /** base class for errors */
         struct Error {
             Error(const Location &loc, const std::string &s) : location(loc), what(s) {}
-            Location location;
-            std::string what;
+            const Location location;
+            const std::string what;
         };
 
         /** Struct that is thrown when macro is expanded with wrong number of parameters */
@@ -1366,22 +1705,50 @@ namespace simplecpp {
 
         /** Struct that is thrown when there is invalid ## usage */
         struct invalidHashHash : public Error {
-            invalidHashHash(const Location &loc, const std::string &macroName) : Error(loc, "Invalid ## usage when expanding \'" + macroName + "\'.") {}
+            static inline std::string format(const std::string &macroName, const std::string &message) {
+                return "Invalid ## usage when expanding \'" + macroName + "\': " + message;
+            }
+
+            invalidHashHash(const Location &loc, const std::string &macroName, const std::string &message)
+                : Error(loc, format(macroName, message)) {}
+
+            static inline invalidHashHash unexpectedToken(const Location &loc, const std::string &macroName, const Token *tokenA) {
+                return {loc, macroName, "Unexpected token '"+ tokenA->str()+"'"};
+            }
+
+            static inline invalidHashHash cannotCombine(const Location &loc, const std::string &macroName, const Token *tokenA, const Token *tokenB) {
+                return {loc, macroName, "Combining '"+ tokenA->str()+ "' and '"+ tokenB->str() + "' yields an invalid token."};
+            }
+
+            static inline invalidHashHash unexpectedNewline(const Location &loc, const std::string &macroName) {
+                return {loc, macroName, "Unexpected newline"};
+            }
+
+            static inline invalidHashHash universalCharacterUB(const Location &loc, const std::string &macroName, const Token* tokenA, const std::string& strAB) {
+                return {loc, macroName, "Combining '\\"+ tokenA->str()+ "' and '"+ strAB.substr(tokenA->str().size()) + "' yields universal character '\\" + strAB + "'. This is undefined behavior according to C standard chapter 5.1.1.2, paragraph 4."};
+            }
         };
     private:
         /** Create new token where Token::macro is set for replaced tokens */
-        Token *newMacroToken(const TokenString &str, const Location &loc, bool replaced) const {
-            Token *tok = new Token(str,loc);
+        Token *newMacroToken(const TokenString &str, const Location &loc, bool replaced, const Token *expandedFromToken=nullptr) const {
+            auto *tok = new Token(str,loc);
             if (replaced)
                 tok->macro = nameTokDef->str();
+            if (expandedFromToken)
+                tok->setExpandedFrom(expandedFromToken, this);
             return tok;
         }
 
         bool parseDefine(const Token *nametoken) {
             nameTokDef = nametoken;
             variadic = false;
+            variadicOpt = false;
+            delete optExpandValue;
+            optExpandValue = nullptr;
+            delete optNoExpandValue;
+            optNoExpandValue = nullptr;
             if (!nameTokDef) {
-                valueToken = endToken = NULL;
+                valueToken = endToken = nullptr;
                 args.clear();
                 return false;
             }
@@ -1395,30 +1762,71 @@ namespace simplecpp {
                         argtok->next && argtok->next->op == ')') {
                         variadic = true;
                         if (!argtok->previous->name)
-                            args.push_back("__VA_ARGS__");
+                            args.emplace_back("__VA_ARGS__");
                         argtok = argtok->next; // goto ')'
                         break;
                     }
                     if (argtok->op != ',')
-                        args.push_back(argtok->str());
+                        args.emplace_back(argtok->str());
                     argtok = argtok->next;
                 }
                 if (!sameline(nametoken, argtok)) {
                     endToken = argtok ? argtok->previous : argtok;
-                    valueToken = NULL;
+                    valueToken = nullptr;
                     return false;
                 }
-                valueToken = argtok ? argtok->next : NULL;
+                valueToken = argtok ? argtok->next : nullptr;
             } else {
                 args.clear();
                 valueToken = nameTokDef->next;
             }
 
             if (!sameline(valueToken, nameTokDef))
-                valueToken = NULL;
+                valueToken = nullptr;
             endToken = valueToken;
-            while (sameline(endToken, nameTokDef))
+            while (sameline(endToken, nameTokDef)) {
+                if (variadic && endToken->str() == "__VA_OPT__")
+                    variadicOpt = true;
                 endToken = endToken->next;
+            }
+
+            if (variadicOpt) {
+                TokenList expandValue(files);
+                TokenList noExpandValue(files);
+                for (const Token *tok = valueToken; tok && tok != endToken;) {
+                    if (tok->str() == "__VA_OPT__") {
+                        if (!sameline(tok, tok->next) || tok->next->op != '(')
+                            throw Error(tok->location, "In definition of '" + nameTokDef->str() + "': Missing opening parenthesis for __VA_OPT__");
+                        tok = tok->next->next;
+                        int par = 1;
+                        while (tok && tok != endToken) {
+                            if (tok->op == '(')
+                                par++;
+                            else if (tok->op == ')')
+                                par--;
+                            else if (tok->str() == "__VA_OPT__")
+                                throw Error(tok->location, "In definition of '" + nameTokDef->str() + "': __VA_OPT__ cannot be nested");
+                            if (par == 0) {
+                                tok = tok->next;
+                                break;
+                            }
+                            expandValue.push_back(new Token(*tok));
+                            tok = tok->next;
+                        }
+                        if (par != 0) {
+                            const Token *const lastTok = expandValue.back() ? expandValue.back() : valueToken->next;
+                            throw Error(lastTok->location, "In definition of '" + nameTokDef->str() + "': Missing closing parenthesis for __VA_OPT__");
+                        }
+                    } else {
+                        expandValue.push_back(new Token(*tok));
+                        noExpandValue.push_back(new Token(*tok));
+                        tok = tok->next;
+                    }
+                }
+                optExpandValue = new TokenList(std::move(expandValue));
+                optNoExpandValue = new TokenList(std::move(noExpandValue));
+            }
+
             return true;
         }
 
@@ -1434,58 +1842,54 @@ namespace simplecpp {
 
         std::vector<const Token *> getMacroParameters(const Token *nameTokInst, bool calledInDefine) const {
             if (!nameTokInst->next || nameTokInst->next->op != '(' || !functionLike())
-                return std::vector<const Token *>();
+                return {};
 
             std::vector<const Token *> parametertokens;
-            parametertokens.push_back(nameTokInst->next);
+            parametertokens.emplace_back(nameTokInst->next);
             unsigned int par = 0U;
-            for (const Token *tok = nameTokInst->next->next; calledInDefine ? sameline(tok, nameTokInst) : (tok != NULL); tok = tok->next) {
-                if (tok->op == '(')
+            for (const Token *tok = nameTokInst->next->next; calledInDefine ? sameline(tok, nameTokInst) : (tok != nullptr); tok = tok->next) {
+                if (tok->op == '(') {
                     ++par;
+                }
                 else if (tok->op == ')') {
                     if (par == 0U) {
-                        parametertokens.push_back(tok);
+                        parametertokens.emplace_back(tok);
                         break;
                     }
                     --par;
-                } else if (par == 0U && tok->op == ',' && (!variadic || parametertokens.size() < args.size()))
-                    parametertokens.push_back(tok);
+                } else if (par == 0U && tok->op == ',' && (!variadic || parametertokens.size() < args.size())) {
+                    parametertokens.emplace_back(tok);
+                }
             }
             return parametertokens;
         }
 
-        const Token *appendTokens(TokenList *tokens,
-                                  const Token *lpar,
-                                  const std::map<TokenString,Macro> &macros,
+        const Token *appendTokens(TokenList &tokens,
+                                  const Location &rawloc,
+                                  const Token * const lpar,
+                                  const MacroMap &macros,
                                   const std::set<TokenString> &expandedmacros,
                                   const std::vector<const Token*> &parametertokens) const {
             if (!lpar || lpar->op != '(')
-                return NULL;
+                return nullptr;
             unsigned int par = 0;
             const Token *tok = lpar;
             while (sameline(lpar, tok)) {
                 if (tok->op == '#' && sameline(tok,tok->next) && tok->next->op == '#' && sameline(tok,tok->next->next)) {
                     // A##B => AB
-                    tok = expandHashHash(tokens, tok->location, tok, macros, expandedmacros, parametertokens);
+                    tok = expandHashHash(tokens, rawloc, tok, macros, expandedmacros, parametertokens, false);
                 } else if (tok->op == '#' && sameline(tok, tok->next) && tok->next->op != '#') {
-                    tok = expandHash(tokens, tok->location, tok, macros, expandedmacros, parametertokens);
+                    tok = expandHash(tokens, rawloc, tok, expandedmacros, parametertokens);
                 } else {
-                    if (!expandArg(tokens, tok, tok->location, macros, expandedmacros, parametertokens)) {
-                        bool expanded = false;
-                        const std::map<TokenString, Macro>::const_iterator it = macros.find(tok->str());
-                        if (it != macros.end() && expandedmacros.find(tok->str()) == expandedmacros.end()) {
-                            const Macro &m = it->second;
-                            if (!m.functionLike()) {
-                                m.expand(tokens, tok->location, tok, macros, expandedmacros);
-                                expanded = true;
-                            }
-                        }
-                        if (!expanded)
-                            tokens->push_back(new Token(*tok));
+                    if (!expandArg(tokens, tok, rawloc, macros, expandedmacros, parametertokens)) {
+                        tokens.push_back(new Token(*tok));
+                        if (tok->macro.empty() && (par > 0 || tok->str() != "("))
+                            tokens.back()->macro = name();
                     }
 
-                    if (tok->op == '(')
+                    if (tok->op == '(') {
                         ++par;
+                    }
                     else if (tok->op == ')') {
                         --par;
                         if (par == 0U)
@@ -1494,24 +1898,30 @@ namespace simplecpp {
                     tok = tok->next;
                 }
             }
-            return sameline(lpar,tok) ? tok : NULL;
+            for (Token *tok2 = tokens.front(); tok2; tok2 = tok2->next)
+                tok2->location = lpar->location;
+            return sameline(lpar,tok) ? tok : nullptr;
         }
 
-        const Token * expand(TokenList * const output, const Location &loc, const Token * const nameTokInst, const std::map<TokenString,Macro> &macros, std::set<TokenString> expandedmacros) const {
+        const Token * expand(TokenList & output, const Location &loc, const Token * const nameTokInst, const MacroMap &macros, std::set<TokenString> expandedmacros) const {
             expandedmacros.insert(nameTokInst->str());
 
-            usageList.push_back(loc);
+#ifdef SIMPLECPP_DEBUG_MACRO_EXPANSION
+            std::cout << "  expand " << name() << " " << locstring(defineLocation()) << std::endl;
+#endif
+
+            usageList.emplace_back(loc);
 
             if (nameTokInst->str() == "__FILE__") {
-                output->push_back(new Token('\"'+loc.file()+'\"', loc));
+                output.push_back(new Token('\"'+output.file(loc)+'\"', loc));
                 return nameTokInst->next;
             }
             if (nameTokInst->str() == "__LINE__") {
-                output->push_back(new Token(toString(loc.line), loc));
+                output.push_back(new Token(toString(loc.line), loc));
                 return nameTokInst->next;
             }
             if (nameTokInst->str() == "__COUNTER__") {
-                output->push_back(new Token(toString(usageList.size()-1U), loc));
+                output.push_back(new Token(toString(usageList.size()-1U), loc));
                 return nameTokInst->next;
             }
 
@@ -1523,7 +1933,7 @@ namespace simplecpp {
             if (functionLike()) {
                 // No arguments => not macro expansion
                 if (nameTokInst->next && nameTokInst->next->op != '(') {
-                    output->push_back(new Token(nameTokInst->str(), loc));
+                    output.push_back(new Token(nameTokInst->str(), loc));
                     return nameTokInst->next;
                 }
 
@@ -1550,21 +1960,22 @@ namespace simplecpp {
                     }
                 }
 
-                const std::map<TokenString,Macro>::const_iterator m = macros.find("__COUNTER__");
+                const MacroMap::const_iterator m = macros.find("__COUNTER__");
 
-                if (!counter || m == macros.end())
+                if (!counter || m == macros.end()) {
                     parametertokens2.swap(parametertokens1);
+                }
                 else {
                     const Macro &counterMacro = m->second;
                     unsigned int par = 0;
                     for (const Token *tok = parametertokens1[0]; tok && par < parametertokens1.size(); tok = tok->next) {
                         if (tok->str() == "__COUNTER__") {
                             tokensparams.push_back(new Token(toString(counterMacro.usageList.size()), tok->location));
-                            counterMacro.usageList.push_back(tok->location);
+                            counterMacro.usageList.emplace_back(tok->location);
                         } else {
                             tokensparams.push_back(new Token(*tok));
                             if (tok == parametertokens1[par]) {
-                                parametertokens2.push_back(tokensparams.cback());
+                                parametertokens2.emplace_back(tokensparams.cback());
                                 par++;
                             }
                         }
@@ -1572,16 +1983,46 @@ namespace simplecpp {
                 }
             }
 
-            Token * const output_end_1 = output->back();
+            // NOLINTNEXTLINE(misc-const-correctness) - technically correct but used to access non-const data
+            Token * const output_end_1 = output.back();
 
-            // expand
-            for (const Token *tok = valueToken; tok != endToken;) {
-                if (tok->op != '#') {
-                    // A##B => AB
+            const Token *valueToken2;
+            const Token *endToken2;
+
+            if (variadicOpt) {
+                if (parametertokens2.size() > args.size() && parametertokens2[args.size() - 1]->next->op != ')')
+                    valueToken2 = optExpandValue->cfront();
+                else
+                    valueToken2 = optNoExpandValue->cfront();
+                endToken2 = nullptr;
+            } else {
+                valueToken2 = valueToken;
+                endToken2 = endToken;
+            }
+
+            // expand
+            for (const Token *tok = valueToken2; tok != endToken2;) {
+                if (tok->op != '#') {
+                    // A##B => AB
                     if (sameline(tok, tok->next) && tok->next && tok->next->op == '#' && tok->next->next && tok->next->next->op == '#') {
                         if (!sameline(tok, tok->next->next->next))
-                            throw invalidHashHash(tok->location, name());
-                        output->push_back(newMacroToken(expandArgStr(tok, parametertokens2), loc, isReplaced(expandedmacros)));
+                            throw invalidHashHash::unexpectedNewline(tok->location, name());
+                        if (variadic && tok->op == ',' && tok->next->next->next->str() == args.back()) {
+                            Token *const comma = newMacroToken(tok->str(), loc, isReplaced(expandedmacros), tok);
+                            output.push_back(comma);
+                            tok = expandToken(output, loc, tok->next->next->next, macros, expandedmacros, parametertokens2);
+                            if (output.back() == comma)
+                                output.deleteToken(comma);
+                            continue;
+                        }
+                        TokenList new_output(files);
+                        if (!expandArg(new_output, tok, parametertokens2))
+                            output.push_back(newMacroToken(tok->str(), loc, isReplaced(expandedmacros), tok));
+                        else if (new_output.empty()) // placemarker token
+                            output.push_back(newMacroToken("", loc, isReplaced(expandedmacros)));
+                        else
+                            for (const Token *tok2 = new_output.cfront(); tok2; tok2 = tok2->next)
+                                output.push_back(newMacroToken(tok2->str(), loc, isReplaced(expandedmacros), tok2));
                         tok = tok->next;
                     } else {
                         tok = expandToken(output, loc, tok, macros, expandedmacros, parametertokens2);
@@ -1595,16 +2036,28 @@ namespace simplecpp {
                     hashToken = hashToken->next;
                     ++numberOfHash;
                 }
-                if (numberOfHash == 4) {
+                if (numberOfHash == 4 && tok->next->location.col + 1 == tok->next->next->location.col) {
                     // # ## #  => ##
-                    output->push_back(newMacroToken("##", loc, isReplaced(expandedmacros)));
+                    output.push_back(newMacroToken("##", loc, isReplaced(expandedmacros)));
                     tok = hashToken;
                     continue;
                 }
 
+                if (numberOfHash >= 2 && tok->location.col + 1 < tok->next->location.col) {
+                    output.push_back(new Token(*tok));
+                    tok = tok->next;
+                    continue;
+                }
+
                 tok = tok->next;
-                if (tok == endToken) {
-                    output->push_back(new Token(*tok->previous));
+                if (tok == endToken2) {
+                    if (tok) {
+                        output.push_back(new Token(*tok->previous));
+                    }
+                    else {
+                        output.push_back(new Token(*nameTokInst));
+                        output.back()->setstr("\"\"");
+                    }
                     break;
                 }
                 if (tok->op == '#') {
@@ -1612,12 +2065,12 @@ namespace simplecpp {
                     tok = expandHashHash(output, loc, tok->previous, macros, expandedmacros, parametertokens2);
                 } else {
                     // #123 => "123"
-                    tok = expandHash(output, loc, tok->previous, macros, expandedmacros, parametertokens2);
+                    tok = expandHash(output, loc, tok->previous, expandedmacros, parametertokens2);
                 }
             }
 
             if (!functionLike()) {
-                for (Token *tok = output_end_1 ? output_end_1->next : output->front(); tok; tok = tok->next) {
+                for (Token *tok = output_end_1 ? output_end_1->next : output.front(); tok; tok = tok->next) {
                     tok->macro = nameTokInst->str();
                 }
             }
@@ -1628,81 +2081,101 @@ namespace simplecpp {
             return functionLike() ? parametertokens2.back()->next : nameTokInst->next;
         }
 
-        const Token *expandToken(TokenList *output, const Location &loc, const Token *tok, const std::map<TokenString,Macro> &macros, const std::set<TokenString> &expandedmacros, const std::vector<const Token*> &parametertokens) const {
-            // Not name..
-            if (!tok->name) {
-                output->push_back(newMacroToken(tok->str(), loc, true));
+        const Token *recursiveExpandToken(TokenList &output, TokenList &temp, const Location &loc, const Token *tok, const MacroMap &macros, const std::set<TokenString> &expandedmacros, const std::vector<const Token*> &parametertokens) const {
+            if (!temp.cback() || !temp.cback()->name || !tok->next || tok->next->op != '(') {
+                output.takeTokens(temp);
                 return tok->next;
             }
 
-            // Macro parameter..
-            {
-                TokenList temp(files);
-                if (expandArg(&temp, tok, loc, macros, expandedmacros, parametertokens)) {
-                    if (!(temp.cback() && temp.cback()->name && tok->next && tok->next->op == '(')) {
-                        output->takeTokens(temp);
-                        return tok->next;
-                    }
-
-                    if (!sameline(tok, tok->next)) {
-                        output->takeTokens(temp);
-                        return tok->next;
-                    }
+            if (!sameline(tok, tok->next)) {
+                output.takeTokens(temp);
+                return tok->next;
+            }
 
-                    const std::map<TokenString, Macro>::const_iterator it = macros.find(temp.cback()->str());
-                    if (it == macros.end() || expandedmacros.find(temp.cback()->str()) != expandedmacros.end()) {
-                        output->takeTokens(temp);
-                        return tok->next;
-                    }
+            const MacroMap::const_iterator it = macros.find(temp.cback()->str());
+            if (it == macros.end() || expandedmacros.find(temp.cback()->str()) != expandedmacros.end()) {
+                output.takeTokens(temp);
+                return tok->next;
+            }
 
-                    const Macro &calledMacro = it->second;
-                    if (!calledMacro.functionLike()) {
-                        output->takeTokens(temp);
-                        return tok->next;
-                    }
+            const Macro &calledMacro = it->second;
+            if (!calledMacro.functionLike()) {
+                output.takeTokens(temp);
+                return tok->next;
+            }
 
-                    TokenList temp2(files);
-                    temp2.push_back(new Token(temp.cback()->str(), tok->location));
+            TokenList temp2(files);
+            temp2.push_back(new Token(temp.cback()->str(), tok->location));
 
-                    const Token *tok2 = appendTokens(&temp2, tok->next, macros, expandedmacros, parametertokens);
-                    if (!tok2)
-                        return tok->next;
+            const Token * const tok2 = appendTokens(temp2, loc, tok->next, macros, expandedmacros, parametertokens);
+            if (!tok2)
+                return tok->next;
+            output.takeTokens(temp);
+            output.deleteToken(output.back());
+            calledMacro.expand(output, loc, temp2.cfront(), macros, expandedmacros);
+            return tok2->next;
+        }
 
-                    output->takeTokens(temp);
-                    output->deleteToken(output->back());
-                    calledMacro.expand(output, loc, temp2.cfront(), macros, expandedmacros);
+        const Token *expandToken(TokenList &output, const Location &loc, const Token *tok, const MacroMap &macros, const std::set<TokenString> &expandedmacros, const std::vector<const Token*> &parametertokens) const {
+            // Not name..
+            if (!tok->name) {
+                output.push_back(newMacroToken(tok->str(), loc, true, tok));
+                return tok->next;
+            }
 
-                    return tok2->next;
+            // Macro parameter..
+            {
+                TokenList temp(files);
+                if (expandArg(temp, tok, loc, macros, expandedmacros, parametertokens)) {
+                    if (tok->str() == "__VA_ARGS__" && temp.empty() && output.cback() && output.cback()->str() == "," &&
+                        tok->nextSkipComments() && tok->nextSkipComments()->str() == ")")
+                        output.deleteToken(output.back());
+                    return recursiveExpandToken(output, temp, loc, tok, macros, expandedmacros, parametertokens);
                 }
             }
 
             // Macro..
-            const std::map<TokenString, Macro>::const_iterator it = macros.find(tok->str());
+            const MacroMap::const_iterator it = macros.find(tok->str());
             if (it != macros.end() && expandedmacros.find(tok->str()) == expandedmacros.end()) {
+                std::set<std::string> expandedmacros2(expandedmacros);
+                expandedmacros2.insert(tok->str());
+
                 const Macro &calledMacro = it->second;
-                if (!calledMacro.functionLike())
-                    return calledMacro.expand(output, loc, tok, macros, expandedmacros);
-                if (!sameline(tok, tok->next) || tok->next->op != '(') {
-                    output->push_back(newMacroToken(tok->str(), loc, true));
+                if (!calledMacro.functionLike()) {
+                    TokenList temp(files);
+                    calledMacro.expand(temp, loc, tok, macros, expandedmacros);
+                    return recursiveExpandToken(output, temp, loc, tok, macros, expandedmacros2, parametertokens);
+                }
+                if (!sameline(tok, tok->next)) {
+                    output.push_back(newMacroToken(tok->str(), loc, true, tok));
                     return tok->next;
                 }
                 TokenList tokens(files);
                 tokens.push_back(new Token(*tok));
-                const Token *tok2 = appendTokens(&tokens, tok->next, macros, expandedmacros, parametertokens);
+                const Token * tok2 = nullptr;
+                if (tok->next->op == '(') {
+                    tok2 = appendTokens(tokens, loc, tok->next, macros, expandedmacros, parametertokens);
+                }
+                else if (expandArg(tokens, tok->next, loc, macros, expandedmacros, parametertokens)) {
+                    tokens.front()->location = loc;
+                    if (tokens.cfront()->next && tokens.cfront()->next->op == '(')
+                        tok2 = tok->next;
+                }
                 if (!tok2) {
-                    output->push_back(newMacroToken(tok->str(), loc, true));
+                    output.push_back(newMacroToken(tok->str(), loc, true, tok));
                     return tok->next;
                 }
-                calledMacro.expand(output, loc, tokens.cfront(), macros, expandedmacros);
-                return tok2->next;
+                TokenList temp(files);
+                calledMacro.expand(temp, loc, tokens.cfront(), macros, expandedmacros);
+                return recursiveExpandToken(output, temp, loc, tok2, macros, expandedmacros, parametertokens);
             }
 
-            else if (tok->str() == DEFINED) {
-                const Token *tok2 = tok->next;
-                const Token *tok3 = tok2 ? tok2->next : NULL;
-                const Token *tok4 = tok3 ? tok3->next : NULL;
-                const Token *defToken = NULL;
-                const Token *lastToken = NULL;
+            if (tok->str() == DEFINED) {
+                const Token * const tok2 = tok->next;
+                const Token * const tok3 = tok2 ? tok2->next : nullptr;
+                const Token * const tok4 = tok3 ? tok3->next : nullptr;
+                const Token *defToken = nullptr;
+                const Token *lastToken = nullptr;
                 if (sameline(tok, tok4) && tok2->op == '(' && tok3->name && tok4->op == ')') {
                     defToken = tok3;
                     lastToken = tok4;
@@ -1710,17 +2183,28 @@ namespace simplecpp {
                     defToken = lastToken = tok2;
                 }
                 if (defToken) {
-                    const bool def = (macros.find(defToken->str()) != macros.end());
-                    output->push_back(newMacroToken(def ? "1" : "0", loc, true));
+                    std::string macroName = defToken->str();
+                    if (defToken->next && defToken->next->op == '#' && defToken->next->next && defToken->next->next->op == '#' && defToken->next->next->next && defToken->next->next->next->name && sameline(defToken,defToken->next->next->next)) {
+                        TokenList temp(files);
+                        if (expandArg(temp, defToken, parametertokens))
+                            macroName = temp.cback()->str();
+                        if (expandArg(temp, defToken->next->next->next, parametertokens))
+                            macroName += temp.cback() ? temp.cback()->str() : "";
+                        else
+                            macroName += defToken->next->next->next->str();
+                        lastToken = defToken->next->next->next;
+                    }
+                    const bool def = (macros.find(macroName) != macros.end());
+                    output.push_back(newMacroToken(def ? "1" : "0", loc, true));
                     return lastToken->next;
                 }
             }
 
-            output->push_back(newMacroToken(tok->str(), loc, true));
+            output.push_back(newMacroToken(tok->str(), loc, true, tok));
             return tok->next;
         }
 
-        bool expandArg(TokenList *output, const Token *tok, const std::vector<const Token*> &parametertokens) const {
+        bool expandArg(TokenList &output, const Token *tok, const std::vector<const Token*> &parametertokens) const {
             if (!tok->name)
                 return false;
 
@@ -1733,12 +2217,12 @@ namespace simplecpp {
                 return true;
 
             for (const Token *partok = parametertokens[argnr]->next; partok != parametertokens[argnr + 1U]; partok = partok->next)
-                output->push_back(new Token(*partok));
+                output.push_back(new Token(*partok));
 
             return true;
         }
 
-        bool expandArg(TokenList *output, const Token *tok, const Location &loc, const std::map<TokenString, Macro> &macros, const std::set<TokenString> &expandedmacros, const std::vector<const Token*> &parametertokens) const {
+        bool expandArg(TokenList &output, const Token *tok, const Location &loc, const MacroMap &macros, const std::set<TokenString> &expandedmacros, const std::vector<const Token*> &parametertokens) const {
             if (!tok->name)
                 return false;
             const unsigned int argnr = getArgNum(tok->str());
@@ -1747,53 +2231,45 @@ namespace simplecpp {
             if (variadic && argnr + 1U >= parametertokens.size()) // empty variadic parameter
                 return true;
             for (const Token *partok = parametertokens[argnr]->next; partok != parametertokens[argnr + 1U];) {
-                const std::map<TokenString, Macro>::const_iterator it = macros.find(partok->str());
-                if (it != macros.end() && (partok->str() == name() || expandedmacros.find(partok->str()) == expandedmacros.end()))
-                    partok = it->second.expand(output, loc, partok, macros, expandedmacros);
-                else {
-                    output->push_back(newMacroToken(partok->str(), loc, isReplaced(expandedmacros)));
+                const MacroMap::const_iterator it = macros.find(partok->str());
+                if (it != macros.end() && !partok->isExpandedFrom(&it->second) && (partok->str() == name() || expandedmacros.find(partok->str()) == expandedmacros.end())) {
+                    std::set<TokenString> expandedmacros2(expandedmacros); // temporary amnesia to allow reexpansion of currently expanding macros during argument evaluation
+                    expandedmacros2.erase(name());
+                    partok = it->second.expand(output, loc, partok, macros, std::move(expandedmacros2));
+                } else {
+                    output.push_back(newMacroToken(partok->str(), loc, isReplaced(expandedmacros), partok));
+                    output.back()->macro = partok->macro;
                     partok = partok->next;
                 }
             }
+            if (tok->whitespaceahead && output.back())
+                output.back()->whitespaceahead = true;
             return true;
         }
 
-        /**
-         * Get string for token. If token is argument, the expanded string is returned.
-         * @param tok              The token
-         * @param parametertokens  parameters given when expanding this macro
-         * @return string
-         */
-        std::string expandArgStr(const Token *tok, const std::vector<const Token *> &parametertokens) const {
-            TokenList tokens(files);
-            if (expandArg(&tokens, tok, parametertokens)) {
-                std::string s;
-                for (const Token *tok2 = tokens.cfront(); tok2; tok2 = tok2->next)
-                    s += tok2->str();
-                return s;
-            }
-            return tok->str();
-        }
-
         /**
          * Expand #X => "X"
          * @param output  destination tokenlist
          * @param loc     location for expanded token
          * @param tok     The # token
-         * @param macros  all macros
          * @param expandedmacros   set with expanded macros, with this macro
          * @param parametertokens  parameters given when expanding this macro
          * @return token after the X
          */
-        const Token *expandHash(TokenList *output, const Location &loc, const Token *tok, const std::map<TokenString, Macro> &macros, const std::set<TokenString> &expandedmacros, const std::vector<const Token*> &parametertokens) const {
+        const Token *expandHash(TokenList &output, const Location &loc, const Token *tok, const std::set<TokenString> &expandedmacros, const std::vector<const Token*> &parametertokens) const {
             TokenList tokenListHash(files);
-            tok = expandToken(&tokenListHash, loc, tok->next, macros, expandedmacros, parametertokens);
+            const MacroMap macros2; // temporarily bypass macro expansion
+            tok = expandToken(tokenListHash, loc, tok->next, macros2, expandedmacros, parametertokens);
             std::ostringstream ostr;
             ostr << '\"';
-            for (const Token *hashtok = tokenListHash.cfront(); hashtok; hashtok = hashtok->next)
+            for (const Token *hashtok = tokenListHash.cfront(), *next; hashtok; hashtok = next) {
+                next = hashtok->next;
                 ostr << hashtok->str();
+                if (next && hashtok->whitespaceahead)
+                    ostr << ' ';
+            }
             ostr << '\"';
-            output->push_back(newMacroToken(escapeString(ostr.str()), loc, isReplaced(expandedmacros)));
+            output.push_back(newMacroToken(escapeString(ostr.str()), loc, isReplaced(expandedmacros)));
             return tok;
         }
 
@@ -1806,71 +2282,117 @@ namespace simplecpp {
          * @param macros  all macros
          * @param expandedmacros   set with expanded macros, with this macro
          * @param parametertokens  parameters given when expanding this macro
+         * @param expandResult     expand ## result i.e. "AB"?
          * @return token after B
          */
-        const Token *expandHashHash(TokenList *output, const Location &loc, const Token *tok, const std::map<TokenString, Macro> &macros, const std::set<TokenString> &expandedmacros, const std::vector<const Token*> &parametertokens) const {
-            Token *A = output->back();
+        const Token *expandHashHash(TokenList &output, const Location &loc, const Token *tok, const MacroMap &macros, const std::set<TokenString> &expandedmacros, const std::vector<const Token*> &parametertokens, bool expandResult=true) const {
+            Token *A = output.back();
             if (!A)
-                throw invalidHashHash(tok->location, name());
+                throw invalidHashHash(tok->location, name(), "Missing first argument");
             if (!sameline(tok, tok->next) || !sameline(tok, tok->next->next))
-                throw invalidHashHash(tok->location, name());
+                throw invalidHashHash::unexpectedNewline(tok->location, name());
 
-            bool canBeConcatenatedWithEqual = A->isOneOf("+-*/%&|^") || A->str() == "<<" || A->str() == ">>";
-            if (!A->name && !A->number && A->op != ',' && !A->str().empty() && !canBeConcatenatedWithEqual)
-                throw invalidHashHash(tok->location, name());
+            const bool canBeConcatenatedWithEqual = A->isOneOf("+-*/%&|^") || A->str() == "<<" || A->str() == ">>";
+            const bool canBeConcatenatedStringOrChar = isStringLiteral(A->str()) || isCharLiteral(A->str());
+            const bool unexpectedA = (!A->name && !A->number && !A->str().empty() && !canBeConcatenatedWithEqual && !canBeConcatenatedStringOrChar);
 
-            Token *B = tok->next->next;
+            const Token * const B = tok->next->next;
             if (!B->name && !B->number && B->op && !B->isOneOf("#="))
-                throw invalidHashHash(tok->location, name());
+                throw invalidHashHash::unexpectedToken(tok->location, name(), B);
 
             if ((canBeConcatenatedWithEqual && B->op != '=') ||
                 (!canBeConcatenatedWithEqual && B->op == '='))
-                throw invalidHashHash(tok->location, name());
-
-            std::string strAB;
+                throw invalidHashHash::cannotCombine(tok->location, name(), A, B);
 
-            const bool varargs = variadic && args.size() >= 1U && B->str() == args[args.size()-1U];
+            // Superficial check; more in-depth would in theory be possible _after_ expandArg
+            if (canBeConcatenatedStringOrChar && (B->number || !B->name))
+                throw invalidHashHash::cannotCombine(tok->location, name(), A, B);
 
             TokenList tokensB(files);
-            if (expandArg(&tokensB, B, parametertokens)) {
-                if (tokensB.empty())
-                    strAB = A->str();
-                else if (varargs && A->op == ',') {
-                    strAB = ",";
+            const Token *nextTok = B->next;
+
+            if (canBeConcatenatedStringOrChar) {
+                if (unexpectedA)
+                    throw invalidHashHash::unexpectedToken(tok->location, name(), A);
+
+                // It seems clearer to handle this case separately even though the code is similar-ish, but we don't want to merge here.
+                // TODO The question is whether the ## or varargs may still apply, and how to provoke?
+                if (expandArg(tokensB, B, parametertokens)) {
+                    for (Token *b = tokensB.front(); b; b = b->next)
+                        b->location = loc;
                 } else {
-                    strAB = A->str() + tokensB.cfront()->str();
-                    tokensB.deleteToken(tokensB.front());
+                    tokensB.push_back(new Token(*B));
+                    tokensB.back()->location = loc;
                 }
+                output.takeTokens(tokensB);
             } else {
-                strAB = A->str() + B->str();
-            }
+                std::string strAB;
 
-            const Token *nextTok = B->next;
+                const bool varargs = variadic && !args.empty() && B->str() == args[args.size()-1U];
 
-            if (varargs && tokensB.empty() && tok->previous->str() == ",")
-                output->deleteToken(A);
-            else if (strAB != "," && macros.find(strAB) == macros.end()) {
-                A->setstr(strAB);
-                for (Token *b = tokensB.front(); b; b = b->next)
-                    b->location = loc;
-                output->takeTokens(tokensB);
-            } else {
-                output->deleteToken(A);
-                TokenList tokens(files);
-                tokens.push_back(new Token(strAB, tok->location));
-                // for function like macros, push the (...)
-                if (tokensB.empty() && sameline(B,B->next) && B->next->op=='(') {
-                    const std::map<TokenString,Macro>::const_iterator it = macros.find(strAB);
-                    if (it != macros.end() && expandedmacros.find(strAB) == expandedmacros.end() && it->second.functionLike()) {
-                        const Token *tok2 = appendTokens(&tokens, B->next, macros, expandedmacros, parametertokens);
-                        if (tok2)
-                            nextTok = tok2->next;
+                if (expandArg(tokensB, B, parametertokens)) {
+                    if (tokensB.empty()) {
+                        strAB = A->str();
+                    }
+                    else if (varargs && A->op == ',') {
+                        strAB = ",";
                     }
+                    else if (varargs && unexpectedA) {
+                        throw invalidHashHash::unexpectedToken(tok->location, name(), A);
+                    }
+                    else {
+                        strAB = A->str() + tokensB.cfront()->str();
+                        tokensB.deleteToken(tokensB.front());
+                    }
+                } else {
+                    if (unexpectedA)
+                        throw invalidHashHash::unexpectedToken(tok->location, name(), A);
+                    strAB = A->str() + B->str();
+                }
+
+                // producing universal character is undefined behavior
+                if (A->previous && A->previous->str() == "\\") {
+                    if (strAB[0] == 'u' && strAB.size() == 5)
+                        throw invalidHashHash::universalCharacterUB(tok->location, name(), A, strAB);
+                    if (strAB[0] == 'U' && strAB.size() == 9)
+                        throw invalidHashHash::universalCharacterUB(tok->location, name(), A, strAB);
+                }
+
+                if (varargs && tokensB.empty() && tok->previous->str() == ",") {
+                    output.deleteToken(A);
+                }
+                else if (strAB != "," && macros.find(strAB) == macros.end()) {
+                    A->setstr(strAB);
+                    for (Token *b = tokensB.front(); b; b = b->next)
+                        b->location = loc;
+                    output.takeTokens(tokensB);
+                } else if (sameline(B, nextTok) && sameline(B, nextTok->next) && nextTok->op == '#' && nextTok->next->op == '#') {
+                    TokenList output2(files);
+                    output2.push_back(new Token(strAB, tok->location));
+                    nextTok = expandHashHash(output2, loc, nextTok, macros, expandedmacros, parametertokens);
+                    output.deleteToken(A);
+                    output.takeTokens(output2);
+                } else {
+                    output.deleteToken(A);
+                    TokenList tokens(files);
+                    tokens.push_back(new Token(strAB, tok->location));
+                    // for function like macros, push the (...)
+                    if (tokensB.empty() && sameline(B,B->next) && B->next->op=='(') {
+                        const MacroMap::const_iterator it = macros.find(strAB);
+                        if (it != macros.end() && expandedmacros.find(strAB) == expandedmacros.end() && it->second.functionLike()) {
+                            const Token * const tok2 = appendTokens(tokens, loc, B->next, macros, expandedmacros, parametertokens);
+                            if (tok2)
+                                nextTok = tok2->next;
+                        }
+                    }
+                    if (expandResult)
+                        expandToken(output, loc, tokens.cfront(), macros, expandedmacros, parametertokens);
+                    else
+                        output.takeTokens(tokens);
+                    for (Token *b = tokensB.front(); b; b = b->next)
+                        b->location = loc;
+                    output.takeTokens(tokensB);
                 }
-                expandToken(output, loc, tokens.cfront(), macros, expandedmacros, parametertokens);
-                for (Token *b = tokensB.front(); b; b = b->next)
-                    b->location = loc;
-                output->takeTokens(tokensB);
             }
 
             return nextTok;
@@ -1878,11 +2400,11 @@ namespace simplecpp {
 
         static bool isReplaced(const std::set<std::string> &expandedmacros) {
             // return true if size > 1
-            std::set<std::string>::const_iterator it = expandedmacros.begin();
-            if (it == expandedmacros.end())
+            auto it = expandedmacros.cbegin();
+            if (it == expandedmacros.cend())
                 return false;
             ++it;
-            return (it != expandedmacros.end());
+            return (it != expandedmacros.cend());
         }
 
         /** name token in definition */
@@ -1891,9 +2413,6 @@ namespace simplecpp {
         /** arguments for macro */
         std::vector<TokenString> args;
 
-        /** is macro variadic? */
-        bool variadic;
-
         /** first token in replacement string */
         const Token *valueToken;
 
@@ -1909,6 +2428,16 @@ namespace simplecpp {
         /** usage of this macro */
         mutable std::list<Location> usageList;
 
+        /** is macro variadic? */
+        bool variadic;
+
+        /** does the macro expansion have __VA_OPT__? */
+        bool variadicOpt;
+
+        /** Expansion value for varadic macros with __VA_OPT__ expanded and discarded respectively */
+        const TokenList *optExpandValue{};
+        const TokenList *optNoExpandValue{};
+
         /** was the value of this macro actually defined in the code? */
         bool valueDefinedInCode_;
     };
@@ -1916,13 +2445,19 @@ namespace simplecpp {
 
 namespace simplecpp {
 
+#ifdef __CYGWIN__
+    static bool startsWith(const std::string &s, const std::string &p)
+    {
+        return (s.size() >= p.size()) && std::equal(p.begin(), p.end(), s.begin());
+    }
+
     std::string convertCygwinToWindowsPath(const std::string &cygwinPath)
     {
         std::string windowsPath;
 
         std::string::size_type pos = 0;
         if (cygwinPath.size() >= 11 && startsWith(cygwinPath, "/cygdrive/")) {
-            unsigned char driveLetter = cygwinPath[10];
+            const unsigned char driveLetter = cygwinPath[10];
             if (std::isalpha(driveLetter)) {
                 if (cygwinPath.size() == 11) {
                     windowsPath = toupper(driveLetter);
@@ -1945,169 +2480,27 @@ namespace simplecpp {
 
         return windowsPath;
     }
-}
+#endif
 
+    bool isAbsolutePath(const std::string &path)
+    {
 #ifdef SIMPLECPP_WINDOWS
-
-class ScopedLock {
-public:
-    explicit ScopedLock(CRITICAL_SECTION& criticalSection)
-        : m_criticalSection(criticalSection) {
-        EnterCriticalSection(&m_criticalSection);
-    }
-
-    ~ScopedLock() {
-        LeaveCriticalSection(&m_criticalSection);
-    }
-
-private:
-    ScopedLock& operator=(const ScopedLock&);
-    ScopedLock(const ScopedLock&);
-
-    CRITICAL_SECTION& m_criticalSection;
-};
-
-class RealFileNameMap {
-public:
-    RealFileNameMap() {
-        InitializeCriticalSection(&m_criticalSection);
-    }
-
-    ~RealFileNameMap() {
-        DeleteCriticalSection(&m_criticalSection);
-    }
-
-    bool getCacheEntry(const std::string& path, std::string* returnPath) {
-        ScopedLock lock(m_criticalSection);
-
-        std::map<std::string, std::string>::iterator it = m_fileMap.find(path);
-        if (it != m_fileMap.end()) {
-            *returnPath = it->second;
+        // C:\\path\\file
+        // C:/path/file
+        if (path.length() >= 3 && std::isalpha(path[0]) && path[1] == ':' && (path[2] == '\\' || path[2] == '/'))
             return true;
-        }
-        return false;
-    }
-
-    void addToCache(const std::string& path, const std::string& actualPath) {
-        ScopedLock lock(m_criticalSection);
-        m_fileMap[path] = actualPath;
-    }
-
-private:
-    std::map<std::string, std::string> m_fileMap;
-    CRITICAL_SECTION m_criticalSection;
-};
 
-static RealFileNameMap realFileNameMap;
-
-static bool realFileName(const std::string &f, std::string *result)
-{
-    // are there alpha characters in last subpath?
-    bool alpha = false;
-    for (std::string::size_type pos = 1; pos <= f.size(); ++pos) {
-        unsigned char c = f[f.size() - pos];
-        if (c == '/' || c == '\\')
-            break;
-        if (std::isalpha(c)) {
-            alpha = true;
-            break;
-        }
-    }
+        // \\host\path\file
+        // //host/path/file
+        if (path.length() >= 2 && (path[0] == '\\' || path[0] == '/') && (path[1] == '\\' || path[1] == '/'))
+            return true;
 
-    // do not convert this path if there are no alpha characters (either pointless or cause wrong results for . and ..)
-    if (!alpha)
         return false;
-
-    // Lookup filename or foldername on file system
-    if (!realFileNameMap.getCacheEntry(f, result)) {
-
-        WIN32_FIND_DATAA FindFileData;
-
-#ifdef __CYGWIN__
-        std::string fConverted = simplecpp::convertCygwinToWindowsPath(f);
-        HANDLE hFind = FindFirstFileExA(fConverted.c_str(), FindExInfoBasic, &FindFileData, FindExSearchNameMatch, NULL, 0);
 #else
-        HANDLE hFind = FindFirstFileExA(f.c_str(), FindExInfoBasic, &FindFileData, FindExSearchNameMatch, NULL, 0);
+        return !path.empty() && path[0] == '/';
 #endif
-
-        if (INVALID_HANDLE_VALUE == hFind)
-            return false;
-        *result = FindFileData.cFileName;
-        realFileNameMap.addToCache(f, *result);
-        FindClose(hFind);
-    }
-    return true;
-}
-
-static RealFileNameMap realFilePathMap;
-
-/** Change case in given path to match filesystem */
-static std::string realFilename(const std::string &f)
-{
-    std::string ret;
-    ret.reserve(f.size()); // this will be the final size
-    if (realFilePathMap.getCacheEntry(f, &ret))
-        return ret;
-
-    // Current subpath
-    std::string subpath;
-
-    for (std::string::size_type pos = 0; pos < f.size(); ++pos) {
-        unsigned char c = f[pos];
-
-        // Separator.. add subpath and separator
-        if (c == '/' || c == '\\') {
-            // if subpath is empty just add separator
-            if (subpath.empty()) {
-                ret += c;
-                continue;
-            }
-
-            bool isDriveSpecification =
-                (pos == 2 && subpath.size() == 2 && std::isalpha(subpath[0]) && subpath[1] == ':');
-
-            // Append real filename (proper case)
-            std::string f2;
-            if (!isDriveSpecification && realFileName(f.substr(0, pos), &f2))
-                ret += f2;
-            else
-                ret += subpath;
-
-            subpath.clear();
-
-            // Append separator
-            ret += c;
-        } else {
-            subpath += c;
-        }
     }
-
-    if (!subpath.empty()) {
-        std::string f2;
-        if (realFileName(f,&f2))
-            ret += f2;
-        else
-            ret += subpath;
-    }
-
-    realFilePathMap.addToCache(f, ret);
-    return ret;
-}
-
-static bool isAbsolutePath(const std::string &path)
-{
-    if (path.length() >= 3 && path[0] > 0 && std::isalpha(path[0]) && path[1] == ':' && (path[2] == '\\' || path[2] == '/'))
-        return true;
-    return path.length() > 1U && (path[0] == '/' || path[0] == '\\');
-}
-#else
-#define realFilename(f)  f
-
-static bool isAbsolutePath(const std::string &path)
-{
-    return path.length() > 1U && path[0] == '/';
 }
-#endif
 
 namespace simplecpp {
     /**
@@ -2153,14 +2546,19 @@ namespace simplecpp {
                 continue;
             }
             // get previous subpath
-            const std::string::size_type pos1 = path.rfind('/', pos - 1U) + 1U;
-            const std::string previousSubPath = path.substr(pos1, pos-pos1);
+            std::string::size_type pos1 = path.rfind('/', pos - 1U);
+            if (pos1 == std::string::npos) {
+                pos1 = 0;
+            } else {
+                pos1 += 1U;
+            }
+            const std::string previousSubPath = path.substr(pos1, pos - pos1);
             if (previousSubPath == "..") {
                 // don't simplify
                 ++pos;
             } else {
                 // remove previous subpath and ".."
-                path.erase(pos1,pos-pos1+4);
+                path.erase(pos1, pos - pos1 + 4);
                 if (path.empty())
                     path = ".";
                 // update pos
@@ -2175,21 +2573,23 @@ namespace simplecpp {
         if (unc)
             path = '/' + path;
 
-        return path.find_first_of("*?") == std::string::npos ? realFilename(path) : path;
+        return path;
     }
 }
 
-/** Evaluate sizeof(type) */
+/** Evaluate sizeof(type)
+ * @throws std::runtime_error thrown on missing arguments or invalid expression
+ */
 static void simplifySizeof(simplecpp::TokenList &expr, const std::map<std::string, std::size_t> &sizeOfType)
 {
     for (simplecpp::Token *tok = expr.front(); tok; tok = tok->next) {
         if (tok->str() != "sizeof")
             continue;
-        simplecpp::Token *tok1 = tok->next;
+        const simplecpp::Token *tok1 = tok->next;
         if (!tok1) {
             throw std::runtime_error("missing sizeof argument");
         }
-        simplecpp::Token *tok2 = tok1->next;
+        const simplecpp::Token *tok2 = tok1->next;
         if (!tok2) {
             throw std::runtime_error("missing sizeof argument");
         }
@@ -2204,7 +2604,7 @@ static void simplifySizeof(simplecpp::TokenList &expr, const std::map<std::strin
         }
 
         std::string type;
-        for (simplecpp::Token *typeToken = tok1; typeToken != tok2; typeToken = typeToken->next) {
+        for (const simplecpp::Token *typeToken = tok1; typeToken != tok2; typeToken = typeToken->next) {
             if ((typeToken->str() == "unsigned" || typeToken->str() == "signed") && typeToken->next->name)
                 continue;
             if (typeToken->str() == "*" && type.find('*') != std::string::npos)
@@ -2226,12 +2626,95 @@ static void simplifySizeof(simplecpp::TokenList &expr, const std::map<std::strin
     }
 }
 
-static const char * const altopData[] = {"and","or","bitand","bitor","compl","not","not_eq","xor"};
-static const std::set<std::string> altop(&altopData[0], &altopData[8]);
+static bool isCpp17OrLater(const simplecpp::DUI &dui)
+{
+    const std::string std_ver = simplecpp::getCppStdString(dui.std);
+    return std_ver.empty() || (std_ver >= "201703L");
+}
+
+static bool isGnu(const simplecpp::DUI &dui)
+{
+    return dui.std.rfind("gnu", 0) != std::string::npos;
+}
+
+static std::string dirPath(const std::string& path, bool withTrailingSlash=true)
+{
+    const std::size_t lastSlash = path.find_last_of("\\/");
+    if (lastSlash == std::string::npos) {
+        return "";
+    }
+    return path.substr(0, lastSlash + (withTrailingSlash ? 1U : 0U));
+}
+
+static std::string openHeader(std::ifstream &f, const simplecpp::DUI &dui, const std::string &sourcefile, const std::string &header, bool systemheader);
+
+/** Evaluate __has_include(include)
+ * @throws std::runtime_error thrown on missing arguments or invalid expression
+ */
+static void simplifyHasInclude(simplecpp::TokenList &expr, const simplecpp::DUI &dui)
+{
+    if (!isCpp17OrLater(dui) && !isGnu(dui))
+        return;
+
+    for (simplecpp::Token *tok = expr.front(); tok; tok = tok->next) {
+        if (tok->str() != HAS_INCLUDE)
+            continue;
+        const simplecpp::Token *tok1 = tok->next;
+        if (!tok1) {
+            throw std::runtime_error("missing __has_include argument");
+        }
+        const simplecpp::Token *tok2 = tok1->next;
+        if (!tok2) {
+            throw std::runtime_error("missing __has_include argument");
+        }
+        if (tok1->op == '(') {
+            tok1 = tok1->next;
+            while (tok2->op != ')') {
+                tok2 = tok2->next;
+                if (!tok2) {
+                    throw std::runtime_error("invalid __has_include expression");
+                }
+            }
+        }
+
+        const std::string &sourcefile = expr.file(tok->location);
+        const bool systemheader = (tok1 && tok1->op == '<');
+        std::string header;
+        if (systemheader) {
+            const simplecpp::Token *tok3 = tok1->next;
+            if (!tok3) {
+                throw std::runtime_error("missing __has_include closing angular bracket");
+            }
+            while (tok3->op != '>') {
+                tok3 = tok3->next;
+                if (!tok3) {
+                    throw std::runtime_error("invalid __has_include expression");
+                }
+            }
+
+            for (const simplecpp::Token *headerToken = tok1->next; headerToken != tok3; headerToken = headerToken->next)
+                header += headerToken->str();
+        } else {
+            header = tok1->str().substr(1U, tok1->str().size() - 2U);
+        }
+        std::ifstream f;
+        const std::string header2 = openHeader(f,dui,sourcefile,header,systemheader);
+        tok->setstr(header2.empty() ? "0" : "1");
+
+        tok2 = tok2->next;
+        while (tok->next != tok2)
+            expr.deleteToken(tok->next);
+    }
+}
+
+/** Evaluate name
+ * @throws std::runtime_error thrown on undefined function-like macro
+ */
 static void simplifyName(simplecpp::TokenList &expr)
 {
     for (simplecpp::Token *tok = expr.front(); tok; tok = tok->next) {
         if (tok->name) {
+            static const std::set<std::string> altop{"and","or","bitand","bitor","compl","not","not_eq","xor"};
             if (altop.find(tok->str()) != altop.end()) {
                 bool alt;
                 if (tok->str() == "not" || tok->str() == "compl") {
@@ -2242,11 +2725,236 @@ static void simplifyName(simplecpp::TokenList &expr)
                 if (alt)
                     continue;
             }
+            if (tok->next && tok->next->str() == "(")
+                throw std::runtime_error("undefined function-like macro invocation: " + tok->str() + "( ... )");
             tok->setstr("0");
         }
     }
 }
 
+/*
+ * Reads at least minlen and at most maxlen digits (inc. prefix) in base base
+ * from s starting at position pos and converts them to a
+ * unsigned long long value, updating pos to point to the first
+ * unused element of s.
+ * Returns ULLONG_MAX if the result is not representable and
+ * @throws std::runtime_error thrown if the above requirements were not possible to satisfy.
+ */
+static unsigned long long stringToULLbounded(
+    const std::string& s,
+    std::size_t& pos,
+    int base = 0,
+    std::ptrdiff_t minlen = 1,
+    std::size_t maxlen = std::string::npos
+    )
+{
+    const std::string sub = s.substr(pos, maxlen);
+    const char * const start = sub.c_str();
+    char* end;
+    const unsigned long long value = std::strtoull(start, &end, base);
+    pos += end - start;
+    if (end - start < minlen)
+        throw std::runtime_error("expected digit");
+    return value;
+}
+
+long long simplecpp::characterLiteralToLL(const std::string& str)
+{
+    // default is wide/utf32
+    bool narrow = false;
+    bool utf8 = false;
+    bool utf16 = false;
+
+    std::size_t pos;
+
+    if (!str.empty() && str[0] == '\'') {
+        narrow = true;
+        pos = 1;
+    } else if (str.size() >= 2 && str[0] == 'u' && str[1] == '\'') {
+        utf16 = true;
+        pos = 2;
+    } else if (str.size() >= 3 && str[0] == 'u' && str[1] == '8' && str[2] == '\'') {
+        utf8 = true;
+        pos = 3;
+    } else if (str.size() >= 2 && (str[0] == 'L' || str[0] == 'U') && str[1] == '\'') {
+        pos = 2;
+    } else {
+        throw std::runtime_error("expected a character literal");
+    }
+
+    unsigned long long multivalue = 0;
+
+    std::size_t nbytes = 0;
+
+    while (pos + 1 < str.size()) {
+        if (str[pos] == '\'' || str[pos] == '\n')
+            throw std::runtime_error("raw single quotes and newlines not allowed in character literals");
+
+        if (nbytes >= 1 && !narrow)
+            throw std::runtime_error("multiple characters only supported in narrow character literals");
+
+        unsigned long long value;
+
+        if (str[pos] == '\\') {
+            pos++;
+            const char escape = str[pos++];
+
+            if (pos >= str.size())
+                throw std::runtime_error("unexpected end of character literal");
+
+            switch (escape) {
+            // obscure GCC extensions
+            case '%':
+            case '(':
+            case '[':
+            case '{':
+            // standard escape sequences
+            case '\'':
+            case '"':
+            case '?':
+            case '\\':
+                value = static_cast<unsigned char>(escape);
+                break;
+
+            case 'a':
+                value = static_cast<unsigned char>('\a');
+                break;
+            case 'b':
+                value = static_cast<unsigned char>('\b');
+                break;
+            case 'f':
+                value = static_cast<unsigned char>('\f');
+                break;
+            case 'n':
+                value = static_cast<unsigned char>('\n');
+                break;
+            case 'r':
+                value = static_cast<unsigned char>('\r');
+                break;
+            case 't':
+                value = static_cast<unsigned char>('\t');
+                break;
+            case 'v':
+                value = static_cast<unsigned char>('\v');
+                break;
+
+            // GCC extension for ESC character
+            case 'e':
+            case 'E':
+                value = static_cast<unsigned char>('\x1b');
+                break;
+
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+                // octal escape sequences consist of 1 to 3 digits
+                value = stringToULLbounded(str, --pos, 8, 1, 3);
+                break;
+
+            case 'x':
+                // hexadecimal escape sequences consist of at least 1 digit
+                value = stringToULLbounded(str, pos, 16);
+                break;
+
+            case 'u':
+            case 'U': {
+                // universal character names have exactly 4 or 8 digits
+                const std::size_t ndigits = (escape == 'u' ? 4 : 8);
+                value = stringToULLbounded(str, pos, 16, ndigits, ndigits);
+
+                // UTF-8 encodes code points above 0x7f in multiple code units
+                // code points above 0x10ffff are not allowed
+                if (((narrow || utf8) && value > 0x7f) || (utf16 && value > 0xffff) || value > 0x10ffff)
+                    throw std::runtime_error("code point too large");
+
+                if (value >= 0xd800 && value <= 0xdfff)
+                    throw std::runtime_error("surrogate code points not allowed in universal character names");
+
+                break;
+            }
+
+            default:
+                throw std::runtime_error("invalid escape sequence");
+            }
+        } else {
+            value = static_cast<unsigned char>(str[pos++]);
+
+            if (!narrow && value >= 0x80) {
+                // Assuming this is a UTF-8 encoded code point.
+                // This decoder may not completely validate the input.
+                // Noncharacters are neither rejected nor replaced.
+
+                int additional_bytes;
+                if (value >= 0xf5)  // higher values would result in code points above 0x10ffff
+                    throw std::runtime_error("assumed UTF-8 encoded source, but sequence is invalid");
+                if (value >= 0xf0)
+                    additional_bytes = 3;
+                else if (value >= 0xe0)
+                    additional_bytes = 2;
+                else if (value >= 0xc2) // 0xc0 and 0xc1 are always overlong 2-bytes encodings
+                    additional_bytes = 1;
+                else
+                    throw std::runtime_error("assumed UTF-8 encoded source, but sequence is invalid");
+
+                value &= (1 << (6 - additional_bytes)) - 1;
+
+                while (additional_bytes--) {
+                    if (pos + 1 >= str.size())
+                        throw std::runtime_error("assumed UTF-8 encoded source, but character literal ends unexpectedly");
+
+                    const unsigned char c = str[pos++];
+
+                    if (((c >> 6) != 2)    // ensure c has form 0xb10xxxxxx
+                        || (!value && additional_bytes == 1 && c < 0xa0)    // overlong 3-bytes encoding
+                        || (!value && additional_bytes == 2 && c < 0x90))   // overlong 4-bytes encoding
+                        throw std::runtime_error("assumed UTF-8 encoded source, but sequence is invalid");
+
+                    value = (value << 6) | (c & ((1 << 7) - 1));
+                }
+
+                if (value >= 0xd800 && value <= 0xdfff)
+                    throw std::runtime_error("assumed UTF-8 encoded source, but sequence is invalid");
+
+                if ((utf8 && value > 0x7f) || (utf16 && value > 0xffff) || value > 0x10ffff)
+                    throw std::runtime_error("code point too large");
+            }
+        }
+
+        if (((narrow || utf8) && value > std::numeric_limits<unsigned char>::max()) || (utf16 && value >> 16) || value >> 32)
+            throw std::runtime_error("numeric escape sequence too large");
+
+        multivalue <<= CHAR_BIT;
+        multivalue |= value;
+        nbytes++;
+    }
+
+    if (pos + 1 != str.size() || str[pos] != '\'')
+        throw std::runtime_error("missing closing quote in character literal");
+
+    if (!nbytes)
+        throw std::runtime_error("empty character literal");
+
+    // ordinary narrow character literal's value is determined by (possibly signed) char
+    if (narrow && nbytes == 1)
+        return static_cast<char>(multivalue);
+
+    // while multi-character literal's value is determined by (signed) int
+    if (narrow)
+        return static_cast<int>(multivalue);
+
+    // All other cases are unsigned. Since long long is at least 64bit wide,
+    // while the literals at most 32bit wide, the conversion preserves all values.
+    return multivalue;
+}
+
+/**
+ * @throws std::runtime_error thrown on invalid literal
+ */
 static void simplifyNumbers(simplecpp::TokenList &expr)
 {
     for (simplecpp::Token *tok = expr.front(); tok; tok = tok->next) {
@@ -2254,14 +2962,31 @@ static void simplifyNumbers(simplecpp::TokenList &expr)
             continue;
         if (tok->str().compare(0,2,"0x") == 0)
             tok->setstr(toString(stringToULL(tok->str())));
-        else if (tok->str()[0] == '\'')
-            tok->setstr(toString(tok->str()[1] & 0xffU));
+        else if (!tok->number && tok->str().find('\'') != std::string::npos)
+            tok->setstr(toString(simplecpp::characterLiteralToLL(tok->str())));
+    }
+}
+
+static void simplifyComments(simplecpp::TokenList &expr)
+{
+    for (simplecpp::Token *tok = expr.front(); tok;) {
+        simplecpp::Token * const d = tok;
+        tok = tok->next;
+        if (d->comment)
+            expr.deleteToken(d);
     }
 }
 
-static long long evaluate(simplecpp::TokenList &expr, const std::map<std::string, std::size_t> &sizeOfType)
+/**
+ * @throws std::runtime_error thrown on invalid literals, missing sizeof arguments or invalid expressions,
+ * missing __has_include() arguments or expressions, undefined function-like macros, invalid number literals
+ * @throws std::overflow_error thrown on overflow or division by zero
+ */
+static long long evaluate(simplecpp::TokenList &expr, const simplecpp::DUI &dui, const std::map<std::string, std::size_t> &sizeOfType)
 {
+    simplifyComments(expr);
     simplifySizeof(expr, sizeOfType);
+    simplifyHasInclude(expr, dui);
     simplifyName(expr);
     simplifyNumbers(expr);
     expr.constFold();
@@ -2282,154 +3007,224 @@ static const simplecpp::Token *gotoNextLine(const simplecpp::Token *tok)
 
 class NonExistingFilesCache {
 public:
-    NonExistingFilesCache() {
-        InitializeCriticalSection(&m_criticalSection);
-    }
-
-    ~NonExistingFilesCache() {
-        DeleteCriticalSection(&m_criticalSection);
-    }
+    NonExistingFilesCache() {}
 
     bool contains(const std::string& path) {
-        ScopedLock lock(m_criticalSection);
+        std::lock_guard<std::mutex> lock(m_mutex);
         return (m_pathSet.find(path) != m_pathSet.end());
     }
 
     void add(const std::string& path) {
-        ScopedLock lock(m_criticalSection);
+        std::lock_guard<std::mutex> lock(m_mutex);
         m_pathSet.insert(path);
     }
 
+    void clear() {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_pathSet.clear();
+    }
+
 private:
     std::set<std::string> m_pathSet;
-    CRITICAL_SECTION m_criticalSection;
+    std::mutex m_mutex;
 };
 
 static NonExistingFilesCache nonExistingFilesCache;
 
 #endif
 
-static std::string _openHeader(std::ifstream &f, const std::string &path)
+static std::string openHeaderDirect(std::ifstream &f, const std::string &path)
 {
 #ifdef SIMPLECPP_WINDOWS
-    std::string simplePath = simplecpp::simplifyPath(path);
-    if (nonExistingFilesCache.contains(simplePath))
+    if (nonExistingFilesCache.contains(path))
         return "";  // file is known not to exist, skip expensive file open call
-
-    f.open(simplePath.c_str());
-    if (f.is_open())
-        return simplePath;
-    else {
-        nonExistingFilesCache.add(simplePath);
-        return "";
-    }
-#else
+#endif
     f.open(path.c_str());
-    return f.is_open() ? simplecpp::simplifyPath(path) : "";
+    if (f.is_open())
+        return path;
+#ifdef SIMPLECPP_WINDOWS
+    nonExistingFilesCache.add(path);
 #endif
+    return "";
 }
 
 static std::string openHeader(std::ifstream &f, const simplecpp::DUI &dui, const std::string &sourcefile, const std::string &header, bool systemheader)
 {
-    if (isAbsolutePath(header)) {
-        return _openHeader(f, header);
-    }
+    if (simplecpp::isAbsolutePath(header))
+        return openHeaderDirect(f, simplecpp::simplifyPath(header));
 
+    // prefer first to search the header relatively to source file if found, when not a system header
     if (!systemheader) {
-        if (sourcefile.find_first_of("\\/") != std::string::npos) {
-            const std::string s = sourcefile.substr(0, sourcefile.find_last_of("\\/") + 1U) + header;
-            std::string simplePath = _openHeader(f, s);
-            if (!simplePath.empty())
-                return simplePath;
-        } else {
-            std::string simplePath = _openHeader(f, header);
-            if (!simplePath.empty())
-                return simplePath;
+        std::string path = openHeaderDirect(f, simplecpp::simplifyPath(dirPath(sourcefile) + header));
+        if (!path.empty()) {
+            return path;
         }
     }
 
-    for (std::list<std::string>::const_iterator it = dui.includePaths.begin(); it != dui.includePaths.end(); ++it) {
-        std::string s = *it;
-        if (!s.empty() && s[s.size()-1U]!='/' && s[s.size()-1U]!='\\')
-            s += '/';
-        s += header;
-
-        std::string simplePath = _openHeader(f, s);
-        if (!simplePath.empty())
-            return simplePath;
+    // search the header on the include paths (provided by the flags "-I...")
+    for (const auto &includePath : dui.includePaths) {
+        std::string path = openHeaderDirect(f, simplecpp::simplifyPath(includePath + "/" + header));
+        if (!path.empty())
+            return path;
     }
-
     return "";
 }
 
-static std::string getFileName(const std::map<std::string, simplecpp::TokenList *> &filedata, const std::string &sourcefile, const std::string &header, const simplecpp::DUI &dui, bool systemheader)
+std::pair<simplecpp::FileData *, bool> simplecpp::FileDataCache::tryload(FileDataCache::name_map_type::iterator &name_it, const simplecpp::DUI &dui, std::vector<std::string> &filenames, simplecpp::OutputList *outputList)
 {
-    if (filedata.empty()) {
-        return "";
+    const std::string &path = name_it->first;
+    FileID fileId;
+
+    if (!getFileId(path, fileId))
+        return {nullptr, false};
+
+    const auto id_it = mIdMap.find(fileId);
+    if (id_it != mIdMap.end()) {
+        name_it->second = id_it->second;
+        return {id_it->second, false};
     }
+
+    auto *const data = new FileData {path, TokenList(path, filenames, outputList)};
+
+    if (dui.removeComments)
+        data->tokens.removeComments();
+
+    name_it->second = data;
+    mIdMap.emplace(fileId, data);
+    mData.emplace_back(data);
+
+    return {data, true};
+}
+
+std::pair<simplecpp::FileData *, bool> simplecpp::FileDataCache::get(const std::string &sourcefile, const std::string &header, const simplecpp::DUI &dui, bool systemheader, std::vector<std::string> &filenames, simplecpp::OutputList *outputList)
+{
     if (isAbsolutePath(header)) {
-        return (filedata.find(header) != filedata.end()) ? simplecpp::simplifyPath(header) : "";
+        auto ins = mNameMap.emplace(simplecpp::simplifyPath(header), nullptr);
+
+        if (ins.second) {
+            const auto ret = tryload(ins.first, dui, filenames, outputList);
+            if (ret.first != nullptr) {
+                return ret;
+            }
+        } else {
+            return {ins.first->second, false};
+        }
+
+        return {nullptr, false};
     }
 
     if (!systemheader) {
-        if (sourcefile.find_first_of("\\/") != std::string::npos) {
-            const std::string s(simplecpp::simplifyPath(sourcefile.substr(0, sourcefile.find_last_of("\\/") + 1U) + header));
-            if (filedata.find(s) != filedata.end())
-                return s;
-        } else {
-            std::string s = simplecpp::simplifyPath(header);
-            if (filedata.find(s) != filedata.end())
-                return s;
+        auto ins = mNameMap.emplace(simplecpp::simplifyPath(dirPath(sourcefile) + header), nullptr);
+
+        if (ins.second) {
+            const auto ret = tryload(ins.first, dui, filenames, outputList);
+            if (ret.first != nullptr) {
+                return ret;
+            }
+        } else if (ins.first->second != nullptr) {
+            return {ins.first->second, false};
         }
     }
 
-    for (std::list<std::string>::const_iterator it = dui.includePaths.begin(); it != dui.includePaths.end(); ++it) {
-        std::string s = *it;
-        if (!s.empty() && s[s.size()-1U]!='/' && s[s.size()-1U]!='\\')
-            s += '/';
-        s += header;
-        s = simplecpp::simplifyPath(s);
-        if (filedata.find(s) != filedata.end())
-            return s;
+    for (const auto &includePath : dui.includePaths) {
+        auto ins = mNameMap.emplace(simplecpp::simplifyPath(includePath + "/" + header), nullptr);
+
+        if (ins.second) {
+            const auto ret = tryload(ins.first, dui, filenames, outputList);
+            if (ret.first != nullptr) {
+                return ret;
+            }
+        } else if (ins.first->second != nullptr) {
+            return {ins.first->second, false};
+        }
     }
 
-    return "";
+    return {nullptr, false};
 }
 
-static bool hasFile(const std::map<std::string, simplecpp::TokenList *> &filedata, const std::string &sourcefile, const std::string &header, const simplecpp::DUI &dui, bool systemheader)
+bool simplecpp::FileDataCache::getFileId(const std::string &path, FileID &id)
 {
-    return !getFileName(filedata, sourcefile, header, dui, systemheader).empty();
+#ifdef _WIN32
+    HANDLE hFile = CreateFileA(path.c_str(), 0, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
+
+    if (hFile == INVALID_HANDLE_VALUE)
+        return false;
+
+    BOOL ret = GetFileInformationByHandleEx(hFile, FileIdInfo, &id.fileIdInfo, sizeof(id.fileIdInfo));
+    if (!ret) {
+        const DWORD err = GetLastError();
+        if (err == ERROR_INVALID_PARAMETER || // encountered when using a non-NTFS filesystem e.g. exFAT
+            err == ERROR_NOT_SUPPORTED) // encountered on Windows Server Core (used as a Docker container)
+        {
+            BY_HANDLE_FILE_INFORMATION fileInfo;
+            ret = GetFileInformationByHandle(hFile, &fileInfo);
+            if (ret) {
+                id.fileIdInfo.VolumeSerialNumber = static_cast<std::uint64_t>(fileInfo.dwVolumeSerialNumber);
+                id.fileIdInfo.FileId.IdentifierHi = static_cast<std::uint64_t>(fileInfo.nFileIndexHigh);
+                id.fileIdInfo.FileId.IdentifierLo = static_cast<std::uint64_t>(fileInfo.nFileIndexLow);
+            }
+        }
+    }
+
+    CloseHandle(hFile);
+
+    return ret == TRUE;
+#else
+    struct stat statbuf;
+
+    if (stat(path.c_str(), &statbuf) != 0)
+        return false;
+
+    id.dev = statbuf.st_dev;
+    id.ino = statbuf.st_ino;
+
+    return true;
+#endif
 }
 
-std::map<std::string, simplecpp::TokenList*> simplecpp::load(const simplecpp::TokenList &rawtokens, std::vector<std::string> &fileNumbers, const simplecpp::DUI &dui, simplecpp::OutputList *outputList)
+simplecpp::FileDataCache simplecpp::load(const simplecpp::TokenList &rawtokens, std::vector<std::string> &filenames, const simplecpp::DUI &dui, simplecpp::OutputList *outputList, FileDataCache cache)
 {
-    std::map<std::string, simplecpp::TokenList*> ret;
+#ifdef SIMPLECPP_WINDOWS
+    if (dui.clearIncludeCache)
+        nonExistingFilesCache.clear();
+#endif
 
     std::list<const Token *> filelist;
 
     // -include files
-    for (std::list<std::string>::const_iterator it = dui.includes.begin(); it != dui.includes.end(); ++it) {
-        const std::string &filename = realFilename(*it);
+    for (auto it = dui.includes.cbegin(); it != dui.includes.cend(); ++it) {
+        const std::string &filename = *it;
 
-        if (ret.find(filename) != ret.end())
+        const auto loadResult = cache.get("", filename, dui, false, filenames, outputList);
+        const bool loaded = loadResult.second;
+        FileData *const filedata = loadResult.first;
+
+        if (filedata == nullptr) {
+            if (outputList) {
+                simplecpp::Output err{
+                    simplecpp::Output::EXPLICIT_INCLUDE_NOT_FOUND,
+                    {},
+                    "Can not open include file '" + filename + "' that is explicitly included."
+                };
+                outputList->emplace_back(std::move(err));
+            }
             continue;
+        }
 
-        std::ifstream fin(filename.c_str());
-        if (!fin.is_open())
+        if (!loaded)
             continue;
 
-        TokenList *tokenlist = new TokenList(fin, fileNumbers, filename, outputList);
-        if (!tokenlist->front()) {
-            delete tokenlist;
+        if (!filedata->tokens.front())
             continue;
-        }
 
-        ret[filename] = tokenlist;
-        filelist.push_back(tokenlist->front());
+        if (dui.removeComments)
+            filedata->tokens.removeComments();
+
+        filelist.emplace_back(filedata->tokens.front());
     }
 
-    for (const Token *rawtok = rawtokens.cfront(); rawtok || !filelist.empty(); rawtok = rawtok ? rawtok->next : NULL) {
-        if (rawtok == NULL) {
+    for (const Token *rawtok = rawtokens.cfront(); rawtok || !filelist.empty(); rawtok = rawtok ? rawtok->next : nullptr) {
+        if (rawtok == nullptr) {
             rawtok = filelist.back();
             filelist.pop_back();
         }
@@ -2441,47 +3236,51 @@ std::map<std::string, simplecpp::TokenList*> simplecpp::load(const simplecpp::To
         if (!rawtok || rawtok->str() != INCLUDE)
             continue;
 
-        const std::string &sourcefile = rawtok->location.file();
+        const std::string &sourcefile = rawtokens.file(rawtok->location);
 
-        const Token *htok = rawtok->nextSkipComments();
+        const Token * const htok = rawtok->nextSkipComments();
         if (!sameline(rawtok, htok))
             continue;
 
-        bool systemheader = (htok->str()[0] == '<');
+        const bool systemheader = (htok->str()[0] == '<');
+        const std::string header(htok->str().substr(1U, htok->str().size() - 2U));
+
+        const auto loadResult = cache.get(sourcefile, header, dui, systemheader, filenames, outputList);
+        const bool loaded = loadResult.second;
 
-        const std::string header(realFilename(htok->str().substr(1U, htok->str().size() - 2U)));
-        if (hasFile(ret, sourcefile, header, dui, systemheader))
+        if (!loaded)
             continue;
 
-        std::ifstream f;
-        const std::string header2 = openHeader(f,dui,sourcefile,header,systemheader);
-        if (!f.is_open())
+        FileData *const filedata = loadResult.first;
+
+        if (!filedata->tokens.front())
             continue;
 
-        TokenList *tokens = new TokenList(f, fileNumbers, header2, outputList);
-        ret[header2] = tokens;
-        if (tokens->front())
-            filelist.push_back(tokens->front());
+        if (dui.removeComments)
+            filedata->tokens.removeComments();
+
+        filelist.emplace_back(filedata->tokens.front());
     }
 
-    return ret;
+    return cache;
 }
 
-static bool preprocessToken(simplecpp::TokenList &output, const simplecpp::Token **tok1, std::map<std::string, simplecpp::Macro> &macros, std::vector<std::string> &files, simplecpp::OutputList *outputList)
+static bool preprocessToken(simplecpp::TokenList &output, const simplecpp::Token *&tok1, simplecpp::MacroMap &macros, std::vector<std::string> &files, simplecpp::OutputList *outputList)
 {
-    const simplecpp::Token *tok = *tok1;
-    const std::map<std::string,simplecpp::Macro>::const_iterator it = macros.find(tok->str());
+    const simplecpp::Token * const tok = tok1;
+    const simplecpp::MacroMap::const_iterator it = tok->name ? macros.find(tok->str()) : macros.end();
     if (it != macros.end()) {
         simplecpp::TokenList value(files);
         try {
-            *tok1 = it->second.expand(&value, tok, macros, files);
-        } catch (simplecpp::Macro::Error &err) {
+            tok1 = it->second.expand(value, tok, macros, files);
+        } catch (const simplecpp::Macro::Error &err) {
             if (outputList) {
-                simplecpp::Output out(files);
-                out.type = simplecpp::Output::SYNTAX_ERROR;
-                out.location = err.location;
-                out.msg = "failed to expand \'" + tok->str() + "\', " + err.what;
-                outputList->push_back(out);
+                simplecpp::Output out{
+                    simplecpp::Output::SYNTAX_ERROR,
+                    err.location,
+                    "failed to expand \'" + tok->str() + "\', " + err.what
+                };
+                outputList->emplace_back(std::move(out));
             }
             return false;
         }
@@ -2489,13 +3288,44 @@ static bool preprocessToken(simplecpp::TokenList &output, const simplecpp::Token
     } else {
         if (!tok->comment)
             output.push_back(new simplecpp::Token(*tok));
-        *tok1 = tok->next;
+        tok1 = tok->next;
     }
     return true;
 }
 
-void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenList &rawtokens, std::vector<std::string> &files, std::map<std::string, simplecpp::TokenList *> &filedata, const simplecpp::DUI &dui, simplecpp::OutputList *outputList, std::list<simplecpp::MacroUsage> *macroUsage)
+static void getLocaltime(struct tm &ltime)
+{
+    time_t t;
+    time(&t);
+#ifndef _WIN32
+    // NOLINTNEXTLINE(misc-include-cleaner) - false positive
+    localtime_r(&t, &ltime);
+#else
+    localtime_s(&ltime, &t);
+#endif
+}
+
+static std::string getDateDefine(const struct tm *timep)
+{
+    char buf[] = "??? ?? ????";
+    strftime(buf, sizeof(buf), "%b %d %Y", timep);
+    return std::string("\"").append(buf).append("\"");
+}
+
+static std::string getTimeDefine(const struct tm *timep)
 {
+    char buf[] = "??:??:??";
+    strftime(buf, sizeof(buf), "%H:%M:%S", timep);
+    return std::string("\"").append(buf).append("\"");
+}
+
+void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenList &rawtokens, std::vector<std::string> &files, simplecpp::FileDataCache &cache, const simplecpp::DUI &dui, simplecpp::OutputList *outputList, std::list<simplecpp::MacroUsage> *macroUsage, std::list<simplecpp::IfCond> *ifCond)
+{
+#ifdef SIMPLECPP_WINDOWS
+    if (dui.clearIncludeCache)
+        nonExistingFilesCache.clear();
+#endif
+
     std::map<std::string, std::size_t> sizeOfType(rawtokens.sizeOfType);
     sizeOfType.insert(std::make_pair("char", sizeof(char)));
     sizeOfType.insert(std::make_pair("short", sizeof(short)));
@@ -2518,50 +3348,107 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
     sizeOfType.insert(std::make_pair("double *", sizeof(double *)));
     sizeOfType.insert(std::make_pair("long double *", sizeof(long double *)));
 
-    std::map<TokenString, Macro> macros;
-    for (std::list<std::string>::const_iterator it = dui.defines.begin(); it != dui.defines.end(); ++it) {
+    // use a dummy vector for the macros because as this is not part of the file and would add an empty entry - e.g. /usr/include/poll.h
+    std::vector<std::string> dummy;
+
+    const bool hasInclude = isCpp17OrLater(dui) || isGnu(dui);
+    MacroMap macros;
+    bool strictAnsiDefined = false;
+    for (auto it = dui.defines.cbegin(); it != dui.defines.cend(); ++it) {
         const std::string &macrostr = *it;
         const std::string::size_type eq = macrostr.find('=');
         const std::string::size_type par = macrostr.find('(');
         const std::string macroname = macrostr.substr(0, std::min(eq,par));
+        if (macroname == "__STRICT_ANSI__")
+            strictAnsiDefined = true;
         if (dui.undefined.find(macroname) != dui.undefined.end())
             continue;
         const std::string lhs(macrostr.substr(0,eq));
         const std::string rhs(eq==std::string::npos ? std::string("1") : macrostr.substr(eq+1));
-        const Macro macro(lhs, rhs, files);
-        macros.insert(std::pair<TokenString,Macro>(macro.name(), macro));
+        try {
+            const Macro macro(lhs, rhs, dummy);
+            macros.insert(std::pair<TokenString,Macro>(macro.name(), macro));
+        } catch (const std::runtime_error& e) {
+            if (outputList) {
+                simplecpp::Output err{
+                    Output::DUI_ERROR,
+                    {},
+                    e.what()
+                };
+                outputList->emplace_back(std::move(err));
+            }
+            output.clear();
+            return;
+        }
     }
 
-    macros.insert(std::make_pair("__FILE__", Macro("__FILE__", "__FILE__", files)));
-    macros.insert(std::make_pair("__LINE__", Macro("__LINE__", "__LINE__", files)));
-    macros.insert(std::make_pair("__COUNTER__", Macro("__COUNTER__", "__COUNTER__", files)));
+    const bool strictAnsiUndefined = dui.undefined.find("__STRICT_ANSI__") != dui.undefined.cend();
+    if (!isGnu(dui) && !strictAnsiDefined && !strictAnsiUndefined)
+        macros.insert(std::pair<TokenString, Macro>("__STRICT_ANSI__", Macro("__STRICT_ANSI__", "1", dummy)));
+
+    macros.insert(std::make_pair("__FILE__", Macro("__FILE__", "__FILE__", dummy)));
+    macros.insert(std::make_pair("__LINE__", Macro("__LINE__", "__LINE__", dummy)));
+    macros.insert(std::make_pair("__COUNTER__", Macro("__COUNTER__", "__COUNTER__", dummy)));
+    struct tm ltime {};
+    getLocaltime(ltime);
+    macros.insert(std::make_pair("__DATE__", Macro("__DATE__", getDateDefine(&ltime), dummy)));
+    macros.insert(std::make_pair("__TIME__", Macro("__TIME__", getTimeDefine(&ltime), dummy)));
+
+    if (!dui.std.empty()) {
+        const cstd_t c_std = simplecpp::getCStd(dui.std);
+        if (c_std != CUnknown) {
+            const std::string std_def = simplecpp::getCStdString(c_std);
+            if (!std_def.empty())
+                macros.insert(std::make_pair("__STDC_VERSION__", Macro("__STDC_VERSION__", std_def, dummy)));
+        } else {
+            const cppstd_t cpp_std = simplecpp::getCppStd(dui.std);
+            if (cpp_std == CPPUnknown) {
+                if (outputList) {
+                    simplecpp::Output err{
+                        Output::DUI_ERROR,
+                        {},
+                        "unknown standard specified: '" + dui.std + "'"
+                    };
+                    outputList->emplace_back(std::move(err));
+                }
+                output.clear();
+                return;
+            }
+            const std::string std_def = simplecpp::getCppStdString(cpp_std);
+            if (!std_def.empty())
+                macros.insert(std::make_pair("__cplusplus", Macro("__cplusplus", std_def, dummy)));
+        }
+    }
 
-    // TRUE => code in current #if block should be kept
-    // ELSE_IS_TRUE => code in current #if block should be dropped. the code in the #else should be kept.
-    // ALWAYS_FALSE => drop all code in #if and #else
-    enum IfState { TRUE, ELSE_IS_TRUE, ALWAYS_FALSE };
+    // True => code in current #if block should be kept
+    // ElseIsTrue => code in current #if block should be dropped. the code in the #else should be kept.
+    // AlwaysFalse => drop all code in #if and #else
+    enum IfState : std::uint8_t { True, ElseIsTrue, AlwaysFalse };
     std::stack<int> ifstates;
-    ifstates.push(TRUE);
+    std::stack<const Token *> iftokens;
+    ifstates.push(True);
 
     std::stack<const Token *> includetokenstack;
 
     std::set<std::string> pragmaOnce;
 
     includetokenstack.push(rawtokens.cfront());
-    for (std::list<std::string>::const_iterator it = dui.includes.begin(); it != dui.includes.end(); ++it) {
-        const std::map<std::string, TokenList*>::const_iterator f = filedata.find(*it);
-        if (f != filedata.end())
-            includetokenstack.push(f->second->cfront());
+    for (auto it = dui.includes.cbegin(); it != dui.includes.cend(); ++it) {
+        const FileData *const filedata = cache.get("", *it, dui, false, files, outputList).first;
+        if (filedata != nullptr && filedata->tokens.cfront() != nullptr)
+            includetokenstack.push(filedata->tokens.cfront());
     }
 
-    for (const Token *rawtok = NULL; rawtok || !includetokenstack.empty();) {
-        if (rawtok == NULL) {
+    std::map<std::string, std::list<Location>> maybeUsedMacros;
+
+    for (const Token *rawtok = nullptr; rawtok || !includetokenstack.empty();) {
+        if (rawtok == nullptr) {
             rawtok = includetokenstack.top();
             includetokenstack.pop();
             continue;
         }
 
-        if (rawtok->op == '#' && !sameline(rawtok->previous, rawtok)) {
+        if (rawtok->op == '#' && !sameline(rawtok->previousSkipComments(), rawtok)) {
             if (!sameline(rawtok, rawtok->next)) {
                 rawtok = rawtok->next;
                 continue;
@@ -2574,28 +3461,33 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
 
             if (ifstates.size() <= 1U && (rawtok->str() == ELIF || rawtok->str() == ELSE || rawtok->str() == ENDIF)) {
                 if (outputList) {
-                    simplecpp::Output err(files);
-                    err.type = Output::SYNTAX_ERROR;
-                    err.location = rawtok->location;
-                    err.msg = "#" + rawtok->str() + " without #if";
-                    outputList->push_back(err);
+                    simplecpp::Output err{
+                        Output::SYNTAX_ERROR,
+                        rawtok->location,
+                        "#" + rawtok->str() + " without #if"
+                    };
+                    outputList->emplace_back(std::move(err));
                 }
                 output.clear();
                 return;
             }
 
-            if (ifstates.top() == TRUE && (rawtok->str() == ERROR || rawtok->str() == WARNING)) {
+            if (ifstates.top() == True && (rawtok->str() == ERROR || rawtok->str() == WARNING)) {
                 if (outputList) {
-                    simplecpp::Output err(rawtok->location.files);
-                    err.type = rawtok->str() == ERROR ? Output::ERROR : Output::WARNING;
-                    err.location = rawtok->location;
+                    std::string msg;
                     for (const Token *tok = rawtok->next; tok && sameline(rawtok,tok); tok = tok->next) {
-                        if (!err.msg.empty() && isNameChar(tok->str()[0]))
-                            err.msg += ' ';
-                        err.msg += tok->str();
+                        if (!msg.empty() && isNameChar(tok->str()[0]))
+                            msg += ' ';
+                        msg += tok->str();
                     }
-                    err.msg = '#' + rawtok->str() + ' ' + err.msg;
-                    outputList->push_back(err);
+                    msg = '#' + rawtok->str() + ' ' + msg;
+                    simplecpp::Output err{
+                        rawtok->str() == ERROR ? Output::ERROR : Output::WARNING,
+                        rawtok->location,
+                        std::move(msg)
+                    };
+
+                    outputList->emplace_back(std::move(err));
                 }
                 if (rawtok->str() == ERROR) {
                     output.clear();
@@ -2604,12 +3496,12 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
             }
 
             if (rawtok->str() == DEFINE) {
-                if (ifstates.top() != TRUE)
+                if (ifstates.top() != True)
                     continue;
                 try {
                     const Macro &macro = Macro(rawtok->previous, files);
                     if (dui.undefined.find(macro.name()) == dui.undefined.end()) {
-                        std::map<TokenString, Macro>::iterator it = macros.find(macro.name());
+                        const MacroMap::iterator it = macros.find(macro.name());
                         if (it == macros.end())
                             macros.insert(std::pair<TokenString, Macro>(macro.name(), macro));
                         else
@@ -2617,16 +3509,28 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                     }
                 } catch (const std::runtime_error &) {
                     if (outputList) {
-                        simplecpp::Output err(files);
-                        err.type = Output::SYNTAX_ERROR;
-                        err.location = rawtok->location;
-                        err.msg = "Failed to parse #define";
-                        outputList->push_back(err);
+                        simplecpp::Output err{
+                            Output::SYNTAX_ERROR,
+                            rawtok->location,
+                            "Failed to parse #define"
+                        };
+                        outputList->emplace_back(std::move(err));
+                    }
+                    output.clear();
+                    return;
+                } catch (const simplecpp::Macro::Error &err) {
+                    if (outputList) {
+                        simplecpp::Output out{
+                            simplecpp::Output::SYNTAX_ERROR,
+                            err.location,
+                            "Failed to parse #define, " + err.what
+                        };
+                        outputList->emplace_back(std::move(out));
                     }
                     output.clear();
                     return;
                 }
-            } else if (ifstates.top() == TRUE && rawtok->str() == INCLUDE) {
+            } else if (ifstates.top() == True && rawtok->str() == INCLUDE) {
                 TokenList inc1(files);
                 for (const Token *inctok = rawtok->next; sameline(rawtok,inctok); inctok = inctok->next) {
                     if (!inctok->comment)
@@ -2635,7 +3539,7 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                 TokenList inc2(files);
                 if (!inc1.empty() && inc1.cfront()->name) {
                     const Token *inctok = inc1.cfront();
-                    if (!preprocessToken(inc2, &inctok, macros, files, outputList)) {
+                    if (!preprocessToken(inc2, inctok, macros, files, outputList)) {
                         output.clear();
                         return;
                     }
@@ -2643,7 +3547,7 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                     inc2.takeTokens(inc1);
                 }
 
-                if (!inc2.empty() && inc2.cfront()->op == '<' && inc2.cback()->op == '>') {
+                if (!inc1.empty() && !inc2.empty() && inc2.cfront()->op == '<' && inc2.cback()->op == '>') {
                     TokenString hdr;
                     // TODO: Sometimes spaces must be added in the string
                     // Somehow preprocessToken etc must be told that the location should be source location not destination location
@@ -2657,73 +3561,70 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
 
                 if (inc2.empty() || inc2.cfront()->str().size() <= 2U) {
                     if (outputList) {
-                        simplecpp::Output err(files);
-                        err.type = Output::SYNTAX_ERROR;
-                        err.location = rawtok->location;
-                        err.msg = "No header in #include";
-                        outputList->push_back(err);
+                        simplecpp::Output err{
+                            Output::SYNTAX_ERROR,
+                            rawtok->location,
+                            "No header in #include"
+                        };
+                        outputList->emplace_back(std::move(err));
                     }
                     output.clear();
                     return;
                 }
 
-                const Token *inctok = inc2.cfront();
+                const Token * const inctok = inc2.cfront();
 
-                const bool systemheader = (inctok->op == '<');
-                const std::string header(realFilename(inctok->str().substr(1U, inctok->str().size() - 2U)));
-                std::string header2 = getFileName(filedata, rawtok->location.file(), header, dui, systemheader);
-                if (header2.empty()) {
-                    // try to load file..
-                    std::ifstream f;
-                    header2 = openHeader(f, dui, rawtok->location.file(), header, systemheader);
-                    if (f.is_open()) {
-                        TokenList *tokens = new TokenList(f, files, header2, outputList);
-                        filedata[header2] = tokens;
-                    }
-                }
-                if (header2.empty()) {
+                const bool systemheader = (inctok->str()[0] == '<');
+                const std::string header(inctok->str().substr(1U, inctok->str().size() - 2U));
+                const FileData *const filedata = cache.get(rawtokens.file(rawtok->location), header, dui, systemheader, files, outputList).first;
+                if (filedata == nullptr) {
                     if (outputList) {
-                        simplecpp::Output out(files);
-                        out.type = Output::MISSING_HEADER;
-                        out.location = rawtok->location;
-                        out.msg = "Header not found: " + inctok->str();
-                        outputList->push_back(out);
+                        simplecpp::Output out{
+                            simplecpp::Output::MISSING_HEADER,
+                            rawtok->location,
+                            "Header not found: " + inctok->str()
+                        };
+                        outputList->emplace_back(std::move(out));
                     }
                 } else if (includetokenstack.size() >= 400) {
                     if (outputList) {
-                        simplecpp::Output out(files);
-                        out.type = Output::INCLUDE_NESTED_TOO_DEEPLY;
-                        out.location = rawtok->location;
-                        out.msg = "#include nested too deeply";
-                        outputList->push_back(out);
+                        simplecpp::Output out{
+                            simplecpp::Output::INCLUDE_NESTED_TOO_DEEPLY,
+                            rawtok->location,
+                            "#include nested too deeply"
+                        };
+                        outputList->emplace_back(std::move(out));
                     }
-                } else if (pragmaOnce.find(header2) == pragmaOnce.end()) {
+                } else if (pragmaOnce.find(filedata->filename) == pragmaOnce.end()) {
                     includetokenstack.push(gotoNextLine(rawtok));
-                    const TokenList *includetokens = filedata.find(header2)->second;
-                    rawtok = includetokens ? includetokens->cfront() : NULL;
+                    rawtok = filedata->tokens.cfront();
                     continue;
                 }
             } else if (rawtok->str() == IF || rawtok->str() == IFDEF || rawtok->str() == IFNDEF || rawtok->str() == ELIF) {
                 if (!sameline(rawtok,rawtok->next)) {
                     if (outputList) {
-                        simplecpp::Output out(files);
-                        out.type = Output::SYNTAX_ERROR;
-                        out.location = rawtok->location;
-                        out.msg = "Syntax error in #" + rawtok->str();
-                        outputList->push_back(out);
+                        simplecpp::Output out{
+                            simplecpp::Output::SYNTAX_ERROR,
+                            rawtok->location,
+                            "Syntax error in #" + rawtok->str()
+                        };
+                        outputList->emplace_back(std::move(out));
                     }
                     output.clear();
                     return;
                 }
 
                 bool conditionIsTrue;
-                if (ifstates.top() == ALWAYS_FALSE || (ifstates.top() == ELSE_IS_TRUE && rawtok->str() != ELIF))
+                if (ifstates.top() == AlwaysFalse || (ifstates.top() == ElseIsTrue && rawtok->str() != ELIF)) {
                     conditionIsTrue = false;
-                else if (rawtok->str() == IFDEF)
-                    conditionIsTrue = (macros.find(rawtok->next->str()) != macros.end());
-                else if (rawtok->str() == IFNDEF)
-                    conditionIsTrue = (macros.find(rawtok->next->str()) == macros.end());
-                else { /*if (rawtok->str() == IF || rawtok->str() == ELIF)*/
+                }
+                else if (rawtok->str() == IFDEF) {
+                    conditionIsTrue = (macros.find(rawtok->next->str()) != macros.end() || (hasInclude && rawtok->next->str() == HAS_INCLUDE));
+                    maybeUsedMacros[rawtok->next->str()].emplace_back(rawtok->next->location);
+                } else if (rawtok->str() == IFNDEF) {
+                    conditionIsTrue = (macros.find(rawtok->next->str()) == macros.end() && !(hasInclude && rawtok->next->str() == HAS_INCLUDE));
+                    maybeUsedMacros[rawtok->next->str()].emplace_back(rawtok->next->location);
+                } else { /*if (rawtok->str() == IF || rawtok->str() == ELIF)*/
                     TokenList expr(files);
                     for (const Token *tok = rawtok->next; tok && tok->location.sameline(rawtok->location); tok = tok->next) {
                         if (!tok->name) {
@@ -2736,21 +3637,68 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                             const bool par = (tok && tok->op == '(');
                             if (par)
                                 tok = tok->next;
+                            maybeUsedMacros[rawtok->next->str()].emplace_back(rawtok->next->location);
                             if (tok) {
                                 if (macros.find(tok->str()) != macros.end())
                                     expr.push_back(new Token("1", tok->location));
+                                else if (hasInclude && tok->str() == HAS_INCLUDE)
+                                    expr.push_back(new Token("1", tok->location));
                                 else
                                     expr.push_back(new Token("0", tok->location));
                             }
                             if (par)
-                                tok = tok ? tok->next : NULL;
+                                tok = tok ? tok->next : nullptr;
                             if (!tok || !sameline(rawtok,tok) || (par && tok->op != ')')) {
                                 if (outputList) {
-                                    Output out(rawtok->location.files);
-                                    out.type = Output::SYNTAX_ERROR;
-                                    out.location = rawtok->location;
-                                    out.msg = "failed to evaluate " + std::string(rawtok->str() == IF ? "#if" : "#elif") + " condition";
-                                    outputList->push_back(out);
+                                    Output out{
+                                        Output::SYNTAX_ERROR,
+                                        rawtok->location,
+                                        "failed to evaluate " + std::string(rawtok->str() == IF ? "#if" : "#elif") + " condition"
+                                    };
+                                    outputList->emplace_back(std::move(out));
+                                }
+                                output.clear();
+                                return;
+                            }
+                            continue;
+                        }
+
+                        if (hasInclude && tok->str() == HAS_INCLUDE) {
+                            tok = tok->next;
+                            const bool par = (tok && tok->op == '(');
+                            if (par)
+                                tok = tok->next;
+                            bool closingAngularBracket = false;
+                            if (tok) {
+                                const std::string &sourcefile = rawtokens.file(rawtok->location);
+                                const bool systemheader = (tok && tok->op == '<');
+                                std::string header;
+
+                                if (systemheader) {
+                                    while ((tok = tok->next) && tok->op != '>')
+                                        header += tok->str();
+                                    if (tok && tok->op == '>')
+                                        closingAngularBracket = true;
+                                } else {
+                                    header = tok->str().substr(1U, tok->str().size() - 2U);
+                                    closingAngularBracket = true;
+                                }
+                                if (tok) {
+                                    std::ifstream f;
+                                    const std::string header2 = openHeader(f,dui,sourcefile,header,systemheader);
+                                    expr.push_back(new Token(header2.empty() ? "0" : "1", tok->location));
+                                }
+                            }
+                            if (par)
+                                tok = tok ? tok->next : nullptr;
+                            if (!tok || !sameline(rawtok,tok) || (par && tok->op != ')') || (!closingAngularBracket)) {
+                                if (outputList) {
+                                    Output out{
+                                        Output::SYNTAX_ERROR,
+                                        rawtok->location,
+                                        "failed to evaluate " + std::string(rawtok->str() == IF ? "#if" : "#elif") + " condition"
+                                    };
+                                    outputList->emplace_back(std::move(out));
                                 }
                                 output.clear();
                                 return;
@@ -2758,8 +3706,10 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                             continue;
                         }
 
+                        maybeUsedMacros[rawtok->next->str()].emplace_back(rawtok->next->location);
+
                         const Token *tmp = tok;
-                        if (!preprocessToken(expr, &tmp, macros, files, outputList)) {
+                        if (!preprocessToken(expr, tmp, macros, files, outputList)) {
                             output.clear();
                             return;
                         }
@@ -2768,16 +3718,28 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
                         tok = tmp->previous;
                     }
                     try {
-                        conditionIsTrue = (evaluate(expr, sizeOfType) != 0);
-                    } catch (const std::exception &e) {
+                        if (ifCond) {
+                            std::string E;
+                            for (const simplecpp::Token *tok = expr.cfront(); tok; tok = tok->next)
+                                E += (E.empty() ? "" : " ") + tok->str();
+                            const long long result = evaluate(expr, dui, sizeOfType);
+                            conditionIsTrue = (result != 0);
+                            ifCond->emplace_back(rawtok->location, E, result);
+                        } else {
+                            const long long result = evaluate(expr, dui, sizeOfType);
+                            conditionIsTrue = (result != 0);
+                        }
+                    } catch (const std::runtime_error &e) {
                         if (outputList) {
-                            Output out(rawtok->location.files);
-                            out.type = Output::SYNTAX_ERROR;
-                            out.location = rawtok->location;
-                            out.msg = "failed to evaluate " + std::string(rawtok->str() == IF ? "#if" : "#elif") + " condition";
+                            std::string msg = "failed to evaluate " + std::string(rawtok->str() == IF ? "#if" : "#elif") + " condition";
                             if (e.what() && *e.what())
-                                out.msg += std::string(", ") + e.what();
-                            outputList->push_back(out);
+                                msg += std::string(", ") + e.what();
+                            Output out{
+                                Output::SYNTAX_ERROR,
+                                rawtok->location,
+                                std::move(msg)
+                            };
+                            outputList->emplace_back(std::move(out));
                         }
                         output.clear();
                         return;
@@ -2786,35 +3748,46 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
 
                 if (rawtok->str() != ELIF) {
                     // push a new ifstate..
-                    if (ifstates.top() != TRUE)
-                        ifstates.push(ALWAYS_FALSE);
+                    if (ifstates.top() != True)
+                        ifstates.push(AlwaysFalse);
                     else
-                        ifstates.push(conditionIsTrue ? TRUE : ELSE_IS_TRUE);
-                } else if (ifstates.top() == TRUE) {
-                    ifstates.top() = ALWAYS_FALSE;
-                } else if (ifstates.top() == ELSE_IS_TRUE && conditionIsTrue) {
-                    ifstates.top() = TRUE;
+                        ifstates.push(conditionIsTrue ? True : ElseIsTrue);
+                    iftokens.push(rawtok);
+                } else {
+                    if (ifstates.top() == True)
+                        ifstates.top() = AlwaysFalse;
+                    else if (ifstates.top() == ElseIsTrue && conditionIsTrue)
+                        ifstates.top() = True;
+                    iftokens.top()->nextcond = rawtok;
+                    iftokens.top() = rawtok;
                 }
             } else if (rawtok->str() == ELSE) {
-                ifstates.top() = (ifstates.top() == ELSE_IS_TRUE) ? TRUE : ALWAYS_FALSE;
+                ifstates.top() = (ifstates.top() == ElseIsTrue) ? True : AlwaysFalse;
+                iftokens.top()->nextcond = rawtok;
+                iftokens.top() = rawtok;
             } else if (rawtok->str() == ENDIF) {
                 ifstates.pop();
+                iftokens.top()->nextcond = rawtok;
+                iftokens.pop();
             } else if (rawtok->str() == UNDEF) {
-                if (ifstates.top() == TRUE) {
+                if (ifstates.top() == True) {
                     const Token *tok = rawtok->next;
                     while (sameline(rawtok,tok) && tok->comment)
                         tok = tok->next;
                     if (sameline(rawtok, tok))
                         macros.erase(tok->str());
                 }
-            } else if (ifstates.top() == TRUE && rawtok->str() == PRAGMA && rawtok->next && rawtok->next->str() == ONCE && sameline(rawtok,rawtok->next)) {
-                pragmaOnce.insert(rawtok->location.file());
+            } else if (ifstates.top() == True && rawtok->str() == PRAGMA && rawtok->next && rawtok->next->str() == ONCE && sameline(rawtok,rawtok->next)) {
+                pragmaOnce.insert(rawtokens.file(rawtok->location));
             }
-            rawtok = gotoNextLine(rawtok);
+            if (ifstates.top() != True && rawtok->nextcond)
+                rawtok = rawtok->nextcond->previous;
+            else
+                rawtok = gotoNextLine(rawtok);
             continue;
         }
 
-        if (ifstates.top() != TRUE) {
+        if (ifstates.top() != True) {
             // drop code
             rawtok = gotoNextLine(rawtok);
             continue;
@@ -2834,7 +3807,7 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
         const Location loc(rawtok->location);
         TokenList tokens(files);
 
-        if (!preprocessToken(tokens, &rawtok, macros, files, outputList)) {
+        if (!preprocessToken(tokens, rawtok, macros, files, outputList)) {
             output.clear();
             return;
         }
@@ -2855,23 +3828,126 @@ void simplecpp::preprocess(simplecpp::TokenList &output, const simplecpp::TokenL
     }
 
     if (macroUsage) {
-        for (std::map<TokenString, simplecpp::Macro>::const_iterator macroIt = macros.begin(); macroIt != macros.end(); ++macroIt) {
+        for (simplecpp::MacroMap::const_iterator macroIt = macros.begin(); macroIt != macros.end(); ++macroIt) {
             const Macro &macro = macroIt->second;
-            const std::list<Location> &usage = macro.usage();
+            std::list<Location> usage = macro.usage();
+            const std::list<Location>& temp = maybeUsedMacros[macro.name()];
+            usage.insert(usage.end(), temp.begin(), temp.end());
             for (std::list<Location>::const_iterator usageIt = usage.begin(); usageIt != usage.end(); ++usageIt) {
-                MacroUsage mu(usageIt->files, macro.valueDefinedInCode());
+                MacroUsage mu(macro.valueDefinedInCode());
                 mu.macroName = macro.name();
                 mu.macroLocation = macro.defineLocation();
                 mu.useLocation = *usageIt;
-                macroUsage->push_back(mu);
+                macroUsage->emplace_back(std::move(mu));
             }
         }
     }
 }
 
-void simplecpp::cleanup(std::map<std::string, TokenList*> &filedata)
+void simplecpp::cleanup(FileDataCache &cache)
+{
+    cache.clear();
+}
+
+simplecpp::cstd_t simplecpp::getCStd(const std::string &std)
+{
+    if (std == "c90" || std == "c89" || std == "iso9899:1990" || std == "iso9899:199409" || std == "gnu90" || std == "gnu89")
+        return C89;
+    if (std == "c99" || std == "c9x" || std == "iso9899:1999" || std == "iso9899:199x" || std == "gnu99" || std == "gnu9x")
+        return C99;
+    if (std == "c11" || std == "c1x" || std == "iso9899:2011" || std == "gnu11" || std == "gnu1x")
+        return C11;
+    if (std == "c17" || std == "c18" || std == "iso9899:2017" || std == "iso9899:2018" || std == "gnu17" || std == "gnu18")
+        return C17;
+    if (std == "c23" || std == "gnu23" || std == "c2x" || std == "gnu2x")
+        return C23;
+    if (std == "c2y" || std == "gnu2y")
+        return C2Y;
+    return CUnknown;
+}
+
+std::string simplecpp::getCStdString(cstd_t std)
+{
+    switch (std) {
+    case C89:
+        // __STDC_VERSION__ is not set for C90 although the macro was added in the 1994 amendments
+        return "";
+    case C99:
+        return "199901L";
+    case C11:
+        return "201112L";
+    case C17:
+        return "201710L";
+    case C23:
+        // supported by GCC 9+ and Clang 9+
+        // Clang 9, 10, 11, 12, 13 return "201710L"
+        // Clang 14, 15, 16, 17 return "202000L"
+        // Clang 9, 10, 11, 12, 13, 14, 15, 16, 17 do not support "c23" and "gnu23"
+        return "202311L";
+    case C2Y:
+        // supported by GCC 15+ and Clang 19+
+        // Clang 19, 20, 21, 22 return "202400L"
+        return "202500L";
+    case CUnknown:
+        return "";
+    }
+    return "";
+}
+
+std::string simplecpp::getCStdString(const std::string &std)
+{
+    return getCStdString(getCStd(std));
+}
+
+simplecpp::cppstd_t simplecpp::getCppStd(const std::string &std)
+{
+    if (std == "c++98" || std == "c++03" || std == "gnu++98" || std == "gnu++03")
+        return CPP03;
+    if (std == "c++11" || std == "gnu++11" || std == "c++0x" || std == "gnu++0x")
+        return CPP11;
+    if (std == "c++14" || std == "c++1y" || std == "gnu++14" || std == "gnu++1y")
+        return CPP14;
+    if (std == "c++17" || std == "c++1z" || std == "gnu++17" || std == "gnu++1z")
+        return CPP17;
+    if (std == "c++20" || std == "c++2a" || std == "gnu++20" || std == "gnu++2a")
+        return CPP20;
+    if (std == "c++23" || std == "c++2b" || std == "gnu++23" || std == "gnu++2b")
+        return CPP23;
+    if (std == "c++26" || std == "c++2c" || std == "gnu++26" || std == "gnu++2c")
+        return CPP26;
+    return CPPUnknown;
+}
+
+std::string simplecpp::getCppStdString(cppstd_t std)
+{
+    switch (std) {
+    case CPP03:
+        return "199711L";
+    case CPP11:
+        return "201103L";
+    case CPP14:
+        return "201402L";
+    case CPP17:
+        return "201703L";
+    case CPP20:
+        // GCC 10 returns "201703L" - correct in 11+
+        return "202002L";
+    case CPP23:
+        // supported by GCC 11+ and Clang 12+
+        // GCC 11, 12, 13 return "202100L"
+        // Clang 12, 13, 14, 15, 16 do not support "c++23" and "gnu++23" and return "202101L"
+        // Clang 17, 18 return "202302L"
+        return "202302L";
+    case CPP26:
+        // supported by GCC 14+ and Clang 17+
+        return "202400L";
+    case CPPUnknown:
+        return "";
+    }
+    return "";
+}
+
+std::string simplecpp::getCppStdString(const std::string &std)
 {
-    for (std::map<std::string, TokenList*>::iterator it = filedata.begin(); it != filedata.end(); ++it)
-        delete it->second;
-    filedata.clear();
+    return getCppStdString(getCppStd(std));
 }
diff --git a/externals/simplecpp/simplecpp.h b/externals/simplecpp/simplecpp.h
index 7f44d308719..54f6a90c053 100644
--- a/externals/simplecpp/simplecpp.h
+++ b/externals/simplecpp/simplecpp.h
@@ -1,32 +1,33 @@
-/*
+/* -*- C++ -*-
  * simplecpp - A simple and high-fidelity C/C++ preprocessor library
- * Copyright (C) 2016 Daniel Marjamäki.
- *
- * This library is free software: you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation, either
- * version 3 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library.  If not, see <http://www.gnu.org/licenses/>.
+ * Copyright (C) 2016-2023 simplecpp team
  */
 
 #ifndef simplecppH
 #define simplecppH
 
 #include <cctype>
-#include <cstddef>
-#include <istream>
+#include <cstdint>
+#include <cstring>
+#include <iosfwd>
 #include <list>
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
+#include <unordered_map>
+#include <utility>
 #include <vector>
+#if __cplusplus >= 202002L
+#  include <version>
+#endif
+
+#if defined(__cpp_lib_string_view) && !defined(__cpp_lib_span)
+#include <string_view>
+#endif
+#ifdef __cpp_lib_span
+#include <span>
+#endif
 
 #ifdef _WIN32
 #  ifdef SIMPLECPP_EXPORT
@@ -40,28 +41,91 @@
 #  define SIMPLECPP_LIB
 #endif
 
+#ifndef _WIN32
+#  include <sys/types.h>
+#endif
+
+#if defined(_MSC_VER)
+#  pragma warning(push)
+// suppress warnings about "conversion from 'type1' to 'type2', possible loss of data"
+#  pragma warning(disable : 4267)
+#  pragma warning(disable : 4244)
+#endif
+
+// provide legacy (i.e. raw pointer) API for TokenList
+// note: std::istream has an overhead compared to raw pointers
+#ifndef SIMPLECPP_TOKENLIST_ALLOW_PTR
+// still provide the legacy API in case we lack the performant wrappers
+#  if !defined(__cpp_lib_string_view) && !defined(__cpp_lib_span)
+#    define SIMPLECPP_TOKENLIST_ALLOW_PTR 1
+#  else
+#    define SIMPLECPP_TOKENLIST_ALLOW_PTR 0
+#  endif
+#endif
 
 namespace simplecpp {
+    /** C code standard */
+    enum cstd_t : std::int8_t { CUnknown=-1, C89, C99, C11, C17, C23, C2Y };
+
+    /** C++ code standard */
+    enum cppstd_t : std::int8_t { CPPUnknown=-1, CPP03, CPP11, CPP14, CPP17, CPP20, CPP23, CPP26 };
 
-    typedef std::string TokenString;
+    using TokenString = std::string;
+
+#if defined(__cpp_lib_string_view) && !defined(__cpp_lib_span)
+    using View = std::string_view;
+#else
+    struct View
+    {
+        // cppcheck-suppress noExplicitConstructor
+        View(const char* data)
+            : mData(data)
+            , mSize(strlen(data))
+        {}
+
+        // only provide when std::span is not available so using untyped initilization won't use View
+#if !defined(__cpp_lib_span)
+        View(const char* data, std::size_t size)
+            : mData(data)
+            , mSize(size)
+        {}
+
+        // cppcheck-suppress noExplicitConstructor
+        View(const std::string& str)
+            : mData(str.data())
+            , mSize(str.size())
+        {}
+#endif // !defined(__cpp_lib_span)
+
+        const char* data() const {
+            return mData;
+        }
+
+        std::size_t size() const {
+            return mSize;
+        }
+
+    private:
+        const char* mData;
+        std::size_t mSize;
+    };
+#endif // defined(__cpp_lib_string_view) && !defined(__cpp_lib_span)
+
+    class Macro;
 
     /**
      * Location in source code
      */
-    class SIMPLECPP_LIB Location {
-    public:
-        explicit Location(const std::vector<std::string> &f) : files(f), fileIndex(0), line(1U), col(0U) {}
+    struct SIMPLECPP_LIB Location {
+        Location() = default;
+        Location(unsigned int fileIndex, unsigned int line, unsigned int col)
+            : fileIndex(fileIndex)
+            , line(line)
+            , col(col)
+        {}
 
-        Location(const Location &loc) : files(loc.files), fileIndex(loc.fileIndex), line(loc.line), col(loc.col) {}
-
-        Location &operator=(const Location &other) {
-            if (this != &other) {
-                fileIndex = other.fileIndex;
-                line = other.line;
-                col  = other.col;
-            }
-            return *this;
-        }
+        Location(const Location &loc) = default;
+        Location &operator=(const Location &other) = default;
 
         /** increment this location by string */
         void adjust(const std::string &str);
@@ -78,16 +142,9 @@ namespace simplecpp {
             return fileIndex == other.fileIndex && line == other.line;
         }
 
-        const std::string& file() const {
-            return fileIndex < files.size() ? files[fileIndex] : emptyFileName;
-        }
-
-        const std::vector<std::string> &files;
-        unsigned int fileIndex;
-        unsigned int line;
-        unsigned int col;
-    private:
-        static const std::string emptyFileName;
+        unsigned int fileIndex{};
+        unsigned int line{};
+        unsigned int col{};
     };
 
     /**
@@ -96,22 +153,15 @@ namespace simplecpp {
      */
     class SIMPLECPP_LIB Token {
     public:
-        Token(const TokenString &s, const Location &loc) :
-            location(loc), previous(NULL), next(NULL), string(s) {
+        Token(const TokenString &s, const Location &loc, bool wsahead = false) :
+            whitespaceahead(wsahead), location(loc), string(s) {
             flags();
         }
 
         Token(const Token &tok) :
-            macro(tok.macro), location(tok.location), previous(NULL), next(NULL), string(tok.string) {
-            flags();
-        }
+            macro(tok.macro), op(tok.op), comment(tok.comment), name(tok.name), number(tok.number), whitespaceahead(tok.whitespaceahead), location(tok.location), string(tok.string), mExpandedFrom(tok.mExpandedFrom) {}
 
-        void flags() {
-            name = (std::isalpha((unsigned char)string[0]) || string[0] == '_' || string[0] == '$');
-            comment = string.size() > 1U && string[0] == '/' && (string[1] == '/' || string[1] == '*');
-            number = std::isdigit((unsigned char)string[0]) || (string.size() > 1U && string[0] == '-' && std::isdigit((unsigned char)string[1]));
-            op = (string.size() == 1U) ? string[0] : '\0';
-        }
+        Token &operator=(const Token &tok) = delete;
 
         const TokenString& str() const {
             return string;
@@ -124,15 +174,21 @@ namespace simplecpp {
         bool isOneOf(const char ops[]) const;
         bool startsWithOneOf(const char c[]) const;
         bool endsWithOneOf(const char c[]) const;
+        static bool isNumberLike(const std::string& str) {
+            return std::isdigit(static_cast<unsigned char>(str[0])) ||
+                   (str.size() > 1U && (str[0] == '-' || str[0] == '+') && std::isdigit(static_cast<unsigned char>(str[1])));
+        }
 
         TokenString macro;
         char op;
         bool comment;
         bool name;
         bool number;
+        bool whitespaceahead;
         Location location;
-        Token *previous;
-        Token *next;
+        Token *previous{};
+        Token *next{};
+        mutable const Token *nextcond{};
 
         const Token *previousSkipComments() const {
             const Token *tok = this->previous;
@@ -148,47 +204,104 @@ namespace simplecpp {
             return tok;
         }
 
+        void setExpandedFrom(const Token *tok, const Macro* m) {
+            mExpandedFrom = tok->mExpandedFrom;
+            mExpandedFrom.insert(m);
+            if (tok->whitespaceahead)
+                whitespaceahead = true;
+        }
+        bool isExpandedFrom(const Macro* m) const {
+            return mExpandedFrom.find(m) != mExpandedFrom.end();
+        }
+
         void printAll() const;
         void printOut() const;
     private:
+        void flags() {
+            name = (std::isalpha(static_cast<unsigned char>(string[0])) || string[0] == '_' || string[0] == '$')
+                   && (std::memchr(string.c_str(), '\'', string.size()) == nullptr);
+            comment = string.size() > 1U && string[0] == '/' && (string[1] == '/' || string[1] == '*');
+            number = isNumberLike(string);
+            op = (string.size() == 1U && !name && !comment && !number) ? string[0] : '\0';
+        }
+
         TokenString string;
 
-        // Not implemented - prevent assignment
-        Token &operator=(const Token &tok);
+        std::set<const Macro*> mExpandedFrom;
     };
 
     /** Output from preprocessor */
     struct SIMPLECPP_LIB Output {
-        explicit Output(const std::vector<std::string> &files) : type(ERROR), location(files) {}
-        enum Type {
+        enum Type : std::uint8_t {
             ERROR, /* #error */
             WARNING, /* #warning */
             MISSING_HEADER,
             INCLUDE_NESTED_TOO_DEEPLY,
             SYNTAX_ERROR,
             PORTABILITY_BACKSLASH,
-            UNHANDLED_CHAR_ERROR
+            UNHANDLED_CHAR_ERROR,
+            EXPLICIT_INCLUDE_NOT_FOUND,
+            FILE_NOT_FOUND,
+            DUI_ERROR
         } type;
+        Output(Type type, const Location& loc, std::string msg) : type(type), location(loc), msg(std::move(msg)) {}
         Location location;
         std::string msg;
     };
 
-    typedef std::list<Output> OutputList;
+    using OutputList = std::list<Output>;
 
     /** List of tokens. */
     class SIMPLECPP_LIB TokenList {
     public:
+        class Stream;
+
         explicit TokenList(std::vector<std::string> &filenames);
-        TokenList(std::istream &istr, std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = NULL);
+        /** generates a token list from the given std::istream parameter */
+        TokenList(std::istream &istr, std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr);
+        /** generates a token list from the given buffer */
+        template<size_t size>
+        TokenList(const char (&data)[size], std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr)
+            : TokenList(reinterpret_cast<const unsigned char*>(data), size-1, filenames, filename, outputList, 0)
+        {}
+        /** generates a token list from the given buffer */
+        template<size_t size>
+        TokenList(const unsigned char (&data)[size], std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr)
+            : TokenList(data, size-1, filenames, filename, outputList, 0)
+        {}
+#if SIMPLECPP_TOKENLIST_ALLOW_PTR
+        /** generates a token list from the given buffer */
+        TokenList(const unsigned char* data, std::size_t size, std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr)
+            : TokenList(data, size, filenames, filename, outputList, 0)
+        {}
+        /** generates a token list from the given buffer */
+        TokenList(const char* data, std::size_t size, std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr)
+            : TokenList(reinterpret_cast<const unsigned char*>(data), size, filenames, filename, outputList, 0)
+        {}
+#endif // SIMPLECPP_TOKENLIST_ALLOW_PTR
+        /** generates a token list from the given buffer */
+        TokenList(View data, std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr)
+            : TokenList(reinterpret_cast<const unsigned char*>(data.data()), data.size(), filenames, filename, outputList, 0)
+        {}
+#ifdef __cpp_lib_span
+        /** generates a token list from the given buffer */
+        TokenList(std::span<const char> data, std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr)
+            : TokenList(reinterpret_cast<const unsigned char*>(data.data()), data.size(), filenames, filename, outputList, 0)
+        {}
+
+        /** generates a token list from the given buffer */
+        TokenList(std::span<const unsigned char> data, std::vector<std::string> &filenames, const std::string &filename=std::string(), OutputList *outputList = nullptr)
+            : TokenList(data.data(), data.size(), filenames, filename, outputList, 0)
+        {}
+#endif // __cpp_lib_span
+
+        /** generates a token list from the given filename parameter */
+        TokenList(const std::string &filename, std::vector<std::string> &filenames, OutputList *outputList = nullptr);
         TokenList(const TokenList &other);
-#if __cplusplus >= 201103L
         TokenList(TokenList &&other);
-#endif
         ~TokenList();
         TokenList &operator=(const TokenList &other);
-#if __cplusplus >= 201103L
         TokenList &operator=(TokenList &&other);
-#endif
 
         void clear();
         bool empty() const {
@@ -196,10 +309,14 @@ namespace simplecpp {
         }
         void push_back(Token *tok);
 
-        void dump() const;
-        std::string stringify() const;
+        void dump(bool linenrs = false) const;
+        std::string stringify(bool linenrs = false) const;
 
-        void readfile(std::istream &istr, const std::string &filename=std::string(), OutputList *outputList = NULL);
+        void readfile(Stream &stream, const std::string &filename=std::string(), OutputList *outputList = nullptr);
+        /**
+         * @throws std::overflow_error thrown on overflow or division by zero
+         * @throws std::runtime_error thrown on invalid expressions
+         */
         void constFold();
 
         void removeComments();
@@ -223,8 +340,8 @@ namespace simplecpp {
         void deleteToken(Token *tok) {
             if (!tok)
                 return;
-            Token *prev = tok->previous;
-            Token *next = tok->next;
+            Token * const prev = tok->previous;
+            Token * const next = tok->next;
             if (prev)
                 prev->next = next;
             if (next)
@@ -246,28 +363,43 @@ namespace simplecpp {
                 other.frontToken->previous = backToken;
             }
             backToken = other.backToken;
-            other.frontToken = other.backToken = NULL;
+            other.frontToken = other.backToken = nullptr;
         }
 
         /** sizeof(T) */
         std::map<std::string, std::size_t> sizeOfType;
 
+        const std::vector<std::string>& getFiles() const {
+            return files;
+        }
+
+        const std::string& file(const Location& loc) const;
+
     private:
+        TokenList(const unsigned char* data, std::size_t size, std::vector<std::string> &filenames, const std::string &filename, OutputList *outputList, int unused);
+
         void combineOperators();
 
         void constFoldUnaryNotPosNeg(Token *tok);
+        /**
+         * @throws std::overflow_error thrown on overflow or division by zero
+         */
         void constFoldMulDivRem(Token *tok);
         void constFoldAddSub(Token *tok);
         void constFoldShift(Token *tok);
         void constFoldComparison(Token *tok);
         void constFoldBitwise(Token *tok);
         void constFoldLogicalOp(Token *tok);
-        void constFoldQuestionOp(Token **tok1);
+        /**
+         * @throws std::runtime_error thrown on invalid expressions
+         */
+        void constFoldQuestionOp(Token *&tok1);
 
-        std::string readUntil(std::istream &istr, const Location &location, char start, char end, OutputList *outputList, unsigned int bom);
-        void lineDirective(unsigned int fileIndex, unsigned int line, Location *location);
+        std::string readUntil(Stream &stream, const Location &location, char start, char end, OutputList *outputList);
+        void lineDirective(unsigned int fileIndex, unsigned int line, Location &location);
 
-        std::string lastLine(int maxsize=100000) const;
+        const Token* lastLineTok(int maxsize=1000) const;
+        const Token* isLastLinePreprocessor(int maxsize=1000) const;
 
         unsigned int fileIndex(const std::string &filename);
 
@@ -278,26 +410,177 @@ namespace simplecpp {
 
     /** Tracking how macros are used */
     struct SIMPLECPP_LIB MacroUsage {
-        explicit MacroUsage(const std::vector<std::string> &f, bool macroValueKnown_) : macroLocation(f), useLocation(f), macroValueKnown(macroValueKnown_) {}
+        explicit MacroUsage(bool macroValueKnown_) : macroValueKnown(macroValueKnown_) {}
         std::string macroName;
-        Location    macroLocation;
-        Location    useLocation;
-        bool        macroValueKnown;
+        Location macroLocation;
+        Location useLocation;
+        bool macroValueKnown;
+    };
+
+    /** Tracking #if/#elif expressions */
+    struct SIMPLECPP_LIB IfCond {
+        explicit IfCond(const Location& location, const std::string &E, long long result) : location(location), E(E), result(result) {}
+        Location location; // location of #if/#elif
+        std::string E; // preprocessed condition
+        long long result; // condition result
     };
 
     /**
      * Command line preprocessor settings.
-     * On the command line these are configured by -D, -U, -I, --include
+     * On the command line these are configured by -D, -U, -I, --include, -std
      */
     struct SIMPLECPP_LIB DUI {
-        DUI() {}
+        DUI() = default;
         std::list<std::string> defines;
         std::set<std::string> undefined;
         std::list<std::string> includePaths;
         std::list<std::string> includes;
+        std::string std;
+        bool clearIncludeCache{};
+        bool removeComments{}; /** remove comment tokens from included files */
+    };
+
+    struct SIMPLECPP_LIB FileData {
+        /** The canonical filename associated with this data */
+        std::string filename;
+        /** The tokens associated with this file */
+        TokenList tokens;
     };
 
-    SIMPLECPP_LIB std::map<std::string, TokenList*> load(const TokenList &rawtokens, std::vector<std::string> &filenames, const DUI &dui, OutputList *outputList = NULL);
+    class SIMPLECPP_LIB FileDataCache {
+    public:
+        FileDataCache() = default;
+
+        FileDataCache(const FileDataCache &) = delete;
+        FileDataCache(FileDataCache &&) = default;
+
+        FileDataCache &operator=(const FileDataCache &) = delete;
+        FileDataCache &operator=(FileDataCache &&) = default;
+
+        /** Get the cached data for a file, or load and then return it if it isn't cached.
+         *  returns the file data and true if the file was loaded, false if it was cached. */
+        std::pair<FileData *, bool> get(const std::string &sourcefile, const std::string &header, const DUI &dui, bool systemheader, std::vector<std::string> &filenames, OutputList *outputList);
+
+        void insert(FileData data) {
+            // NOLINTNEXTLINE(misc-const-correctness) - FP
+            auto *const newdata = new FileData(std::move(data));
+
+            mData.emplace_back(newdata);
+            mNameMap.emplace(newdata->filename, newdata);
+        }
+
+        void clear() {
+            mNameMap.clear();
+            mIdMap.clear();
+            mData.clear();
+        }
+
+        using container_type = std::vector<std::unique_ptr<FileData>>;
+        using iterator = container_type::iterator;
+        using const_iterator = container_type::const_iterator;
+        using size_type = container_type::size_type;
+
+        size_type size() const {
+            return mData.size();
+        }
+        iterator begin() {
+            return mData.begin();
+        }
+        iterator end() {
+            return mData.end();
+        }
+        const_iterator begin() const {
+            return mData.begin();
+        }
+        const_iterator end() const {
+            return mData.end();
+        }
+        const_iterator cbegin() const {
+            return mData.cbegin();
+        }
+        const_iterator cend() const {
+            return mData.cend();
+        }
+
+    private:
+        struct FileID {
+#ifdef _WIN32
+            struct {
+                std::uint64_t VolumeSerialNumber;
+                struct {
+                    std::uint64_t IdentifierHi;
+                    std::uint64_t IdentifierLo;
+                } FileId;
+            } fileIdInfo;
+
+            bool operator==(const FileID &that) const noexcept {
+                return fileIdInfo.VolumeSerialNumber == that.fileIdInfo.VolumeSerialNumber &&
+                       fileIdInfo.FileId.IdentifierHi == that.fileIdInfo.FileId.IdentifierHi &&
+                       fileIdInfo.FileId.IdentifierLo == that.fileIdInfo.FileId.IdentifierLo;
+            }
+#else
+            dev_t dev;
+            ino_t ino;
+
+            bool operator==(const FileID& that) const noexcept {
+                return dev == that.dev && ino == that.ino;
+            }
+#endif
+            struct Hasher {
+                std::size_t operator()(const FileID &id) const {
+#ifdef _WIN32
+                    return static_cast<std::size_t>(id.fileIdInfo.FileId.IdentifierHi ^ id.fileIdInfo.FileId.IdentifierLo ^
+                                                    id.fileIdInfo.VolumeSerialNumber);
+#else
+                    return static_cast<std::size_t>(id.dev) ^ static_cast<std::size_t>(id.ino);
+#endif
+                }
+            };
+        };
+
+        using name_map_type = std::unordered_map<std::string, FileData *>;
+        using id_map_type = std::unordered_map<FileID, FileData *, FileID::Hasher>;
+
+        static bool getFileId(const std::string &path, FileID &id);
+
+        std::pair<FileData *, bool> tryload(name_map_type::iterator &name_it, const DUI &dui, std::vector<std::string> &filenames, OutputList *outputList);
+
+        container_type mData;
+        name_map_type mNameMap;
+        id_map_type mIdMap;
+    };
+
+    /** Converts character literal (including prefix, but not ud-suffix) to long long value.
+     *
+     * Assumes ASCII-compatible single-byte encoded str for narrow literals
+     * and UTF-8 otherwise.
+     *
+     * For target assumes
+     * - execution character set encoding matching str
+     * - UTF-32 execution wide-character set encoding
+     * - requirements for __STDC_UTF_16__, __STDC_UTF_32__ and __STDC_ISO_10646__ satisfied
+     * - char16_t is 16bit wide
+     * - char32_t is 32bit wide
+     * - wchar_t is 32bit wide and unsigned
+     * - matching char signedness to host
+     * - matching sizeof(int) to host
+     *
+     * For host assumes
+     * - ASCII-compatible execution character set
+     *
+     * For host and target assumes
+     * - CHAR_BIT == 8
+     * - two's complement
+     *
+     * Implements multi-character narrow literals according to GCC's behavior,
+     * except multi code unit universal character names are not supported.
+     * Multi-character wide literals are not supported.
+     * Limited support of universal character names for non-UTF-8 execution character set encodings.
+     * @throws std::runtime_error thrown on invalid literal
+     */
+    SIMPLECPP_LIB long long characterLiteralToLL(const std::string& str);
+
+    SIMPLECPP_LIB FileDataCache load(const TokenList &rawtokens, std::vector<std::string> &filenames, const DUI &dui, OutputList *outputList = nullptr, FileDataCache cache = {});
 
     /**
      * Preprocess
@@ -305,23 +588,49 @@ namespace simplecpp {
      * @param output TokenList that receives the preprocessing output
      * @param rawtokens Raw tokenlist for top sourcefile
      * @param files internal data of simplecpp
-     * @param filedata output from simplecpp::load()
+     * @param cache output from simplecpp::load()
      * @param dui defines, undefs, and include paths
      * @param outputList output: list that will receive output messages
      * @param macroUsage output: macro usage
+     * @param ifCond output: #if/#elif expressions
      */
-    SIMPLECPP_LIB void preprocess(TokenList &output, const TokenList &rawtokens, std::vector<std::string> &files, std::map<std::string, TokenList*> &filedata, const DUI &dui, OutputList *outputList = NULL, std::list<MacroUsage> *macroUsage = NULL);
+    SIMPLECPP_LIB void preprocess(TokenList &output, const TokenList &rawtokens, std::vector<std::string> &files, FileDataCache &cache, const DUI &dui, OutputList *outputList = nullptr, std::list<MacroUsage> *macroUsage = nullptr, std::list<IfCond> *ifCond = nullptr);
 
     /**
      * Deallocate data
      */
-    SIMPLECPP_LIB void cleanup(std::map<std::string, TokenList*> &filedata);
+    SIMPLECPP_LIB void cleanup(FileDataCache &cache);
 
     /** Simplify path */
     SIMPLECPP_LIB std::string simplifyPath(std::string path);
 
     /** Convert Cygwin path to Windows path */
     SIMPLECPP_LIB std::string convertCygwinToWindowsPath(const std::string &cygwinPath);
+
+    /** Returns the C version a given standard */
+    SIMPLECPP_LIB cstd_t getCStd(const std::string &std);
+
+    /** Returns the C++ version a given standard */
+    SIMPLECPP_LIB cppstd_t getCppStd(const std::string &std);
+
+    /** Returns the __STDC_VERSION__ value for a given standard */
+    SIMPLECPP_LIB std::string getCStdString(const std::string &std);
+    SIMPLECPP_LIB std::string getCStdString(cstd_t std);
+
+    /** Returns the __cplusplus value for a given standard */
+    SIMPLECPP_LIB std::string getCppStdString(const std::string &std);
+    SIMPLECPP_LIB std::string getCppStdString(cppstd_t std);
+
+    /** Checks if given path is absolute */
+    SIMPLECPP_LIB bool isAbsolutePath(const std::string &path);
 }
 
+#undef SIMPLECPP_TOKENLIST_ALLOW_PTR
+
+#if defined(_MSC_VER)
+#  pragma warning(pop)
+#endif
+
+#undef SIMPLECPP_LIB
+
 #endif
diff --git a/externals/tinyxml/CMakeLists.txt b/externals/tinyxml/CMakeLists.txt
deleted file mode 100644
index 7f05d80ac30..00000000000
--- a/externals/tinyxml/CMakeLists.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-file(GLOB hdrs "*.h")
-file(GLOB srcs "*.cpp")
-
-add_library(tinyxml_objs OBJECT ${srcs} ${hdrs})
-
-
diff --git a/externals/tinyxml2/CMakeLists.txt b/externals/tinyxml2/CMakeLists.txt
new file mode 100644
index 00000000000..2e1aa036b81
--- /dev/null
+++ b/externals/tinyxml2/CMakeLists.txt
@@ -0,0 +1,26 @@
+file(GLOB hdrs "*.h")
+file(GLOB srcs "*.cpp")
+
+add_library(tinyxml2 ${srcs} ${hdrs})
+target_dll_compile_definitions(tinyxml2 EXPORT TINYXML2_EXPORT IMPORT TINYXML2_IMPORT)
+
+# TODO: needs to be fixed upstream
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    target_compile_options(tinyxml2 PRIVATE -Wno-suggest-attribute=format)
+    target_compile_options(tinyxml2 PRIVATE -Wno-useless-cast)
+endif()
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    target_compile_options_safe(tinyxml2 -Wno-implicit-fallthrough)
+    target_compile_options_safe(tinyxml2 -Wno-suggest-destructor-override)
+    target_compile_options_safe(tinyxml2 -Wno-zero-as-null-pointer-constant)
+    target_compile_options_safe(tinyxml2 -Wno-format-nonliteral)
+    target_compile_options_safe(tinyxml2 -Wno-inconsistent-missing-destructor-override)
+    target_compile_options_safe(tinyxml2 -Wno-sign-conversion)
+    target_compile_options_safe(tinyxml2 -Wno-double-promotion)
+endif()
+if(CYGWIN)
+    target_compile_definitions(-D_LARGEFILE_SOURCE)  # required for fseeko() and ftello()
+endif()
+
+target_externals_include_directories(tinyxml2 PUBLIC .)
+
diff --git a/externals/tinyxml2/LICENSE b/externals/tinyxml2/LICENSE
new file mode 100644
index 00000000000..85a6a36f0dd
--- /dev/null
+++ b/externals/tinyxml2/LICENSE
@@ -0,0 +1,18 @@
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any
+damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any
+purpose, including commercial applications, and to alter it and
+redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must
+not claim that you wrote the original software. If you use this
+software in a product, an acknowledgment in the product documentation
+would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and
+must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution.
diff --git a/externals/tinyxml/tinyxml2.cpp b/externals/tinyxml2/tinyxml2.cpp
similarity index 82%
rename from externals/tinyxml/tinyxml2.cpp
rename to externals/tinyxml2/tinyxml2.cpp
index 05c164f713e..8bb963582ec 100644
--- a/externals/tinyxml/tinyxml2.cpp
+++ b/externals/tinyxml2/tinyxml2.cpp
@@ -1,2805 +1,3019 @@
-/*
-Original code by Lee Thomason (www.grinninglizard.com)
-
-This software is provided 'as-is', without any express or implied
-warranty. In no event will the authors be held liable for any
-damages arising from the use of this software.
-
-Permission is granted to anyone to use this software for any
-purpose, including commercial applications, and to alter it and
-redistribute it freely, subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must
-not claim that you wrote the original software. If you use this
-software in a product, an acknowledgment in the product documentation
-would be appreciated but is not required.
-
-2. Altered source versions must be plainly marked as such, and
-must not be misrepresented as being the original software.
-
-3. This notice may not be removed or altered from any source
-distribution.
-*/
-
-#include "tinyxml2.h"
-
-#include <new>		// yes, this one new style header, is in the Android SDK.
-#if defined(ANDROID_NDK) || defined(__BORLANDC__) || defined(__QNXNTO__)
-#   include <stddef.h>
-#   include <stdarg.h>
-#else
-#   include <cstddef>
-#   include <cstdarg>
-#endif
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1400 ) && (!defined WINCE)
-	// Microsoft Visual Studio, version 2005 and higher. Not WinCE.
-	/*int _snprintf_s(
-	   char *buffer,
-	   size_t sizeOfBuffer,
-	   size_t count,
-	   const char *format [,
-		  argument] ...
-	);*/
-	static inline int TIXML_SNPRINTF( char* buffer, size_t size, const char* format, ... )
-	{
-		va_list va;
-		va_start( va, format );
-		int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );
-		va_end( va );
-		return result;
-	}
-
-	static inline int TIXML_VSNPRINTF( char* buffer, size_t size, const char* format, va_list va )
-	{
-		int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );
-		return result;
-	}
-
-	#define TIXML_VSCPRINTF	_vscprintf
-	#define TIXML_SSCANF	sscanf_s
-#elif defined _MSC_VER
-	// Microsoft Visual Studio 2003 and earlier or WinCE
-	#define TIXML_SNPRINTF	_snprintf
-	#define TIXML_VSNPRINTF _vsnprintf
-	#define TIXML_SSCANF	sscanf
-	#if (_MSC_VER < 1400 ) && (!defined WINCE)
-		// Microsoft Visual Studio 2003 and not WinCE.
-		#define TIXML_VSCPRINTF   _vscprintf // VS2003's C runtime has this, but VC6 C runtime or WinCE SDK doesn't have.
-	#else
-		// Microsoft Visual Studio 2003 and earlier or WinCE.
-		static inline int TIXML_VSCPRINTF( const char* format, va_list va )
-		{
-			int len = 512;
-			for (;;) {
-				len = len*2;
-				char* str = new char[len]();
-				const int required = _vsnprintf(str, len, format, va);
-				delete[] str;
-				if ( required != -1 ) {
-					TIXMLASSERT( required >= 0 );
-					len = required;
-					break;
-				}
-			}
-			TIXMLASSERT( len >= 0 );
-			return len;
-		}
-	#endif
-#else
-	// GCC version 3 and higher
-	//#warning( "Using sn* functions." )
-	#define TIXML_SNPRINTF	snprintf
-	#define TIXML_VSNPRINTF	vsnprintf
-	static inline int TIXML_VSCPRINTF( const char* format, va_list va )
-	{
-		int len = vsnprintf( 0, 0, format, va );
-		TIXMLASSERT( len >= 0 );
-		return len;
-	}
-	#define TIXML_SSCANF   sscanf
-#endif
-
-
-static const char LINE_FEED				= (char)0x0a;			// all line endings are normalized to LF
-static const char LF = LINE_FEED;
-static const char CARRIAGE_RETURN		= (char)0x0d;			// CR gets filtered out
-static const char CR = CARRIAGE_RETURN;
-static const char SINGLE_QUOTE			= '\'';
-static const char DOUBLE_QUOTE			= '\"';
-
-// Bunch of unicode info at:
-//		http://www.unicode.org/faq/utf_bom.html
-//	ef bb bf (Microsoft "lead bytes") - designates UTF-8
-
-static const unsigned char TIXML_UTF_LEAD_0 = 0xefU;
-static const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;
-static const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;
-
-namespace tinyxml2
-{
-
-struct Entity {
-    const char* pattern;
-    int length;
-    char value;
-};
-
-static const int NUM_ENTITIES = 5;
-static const Entity entities[NUM_ENTITIES] = {
-    { "quot", 4,	DOUBLE_QUOTE },
-    { "amp", 3,		'&'  },
-    { "apos", 4,	SINGLE_QUOTE },
-    { "lt",	2, 		'<'	 },
-    { "gt",	2,		'>'	 }
-};
-
-
-StrPair::~StrPair()
-{
-    Reset();
-}
-
-
-void StrPair::TransferTo( StrPair* other )
-{
-    if ( this == other ) {
-        return;
-    }
-    // This in effect implements the assignment operator by "moving"
-    // ownership (as in auto_ptr).
-
-    TIXMLASSERT( other != 0 );
-    TIXMLASSERT( other->_flags == 0 );
-    TIXMLASSERT( other->_start == 0 );
-    TIXMLASSERT( other->_end == 0 );
-
-    other->Reset();
-
-    other->_flags = _flags;
-    other->_start = _start;
-    other->_end = _end;
-
-    _flags = 0;
-    _start = 0;
-    _end = 0;
-}
-
-
-void StrPair::Reset()
-{
-    if ( _flags & NEEDS_DELETE ) {
-        delete [] _start;
-    }
-    _flags = 0;
-    _start = 0;
-    _end = 0;
-}
-
-
-void StrPair::SetStr( const char* str, int flags )
-{
-    TIXMLASSERT( str );
-    Reset();
-    size_t len = strlen( str );
-    TIXMLASSERT( _start == 0 );
-    _start = new char[ len+1 ];
-    memcpy( _start, str, len+1 );
-    _end = _start + len;
-    _flags = flags | NEEDS_DELETE;
-}
-
-
-char* StrPair::ParseText( char* p, const char* endTag, int strFlags, int* curLineNumPtr )
-{
-    TIXMLASSERT( p );
-    TIXMLASSERT( endTag && *endTag );
-	TIXMLASSERT(curLineNumPtr);
-
-    char* start = p;
-    char  endChar = *endTag;
-    size_t length = strlen( endTag );
-
-    // Inner loop of text parsing.
-    while ( *p ) {
-        if ( *p == endChar && strncmp( p, endTag, length ) == 0 ) {
-            Set( start, p, strFlags );
-            return p + length;
-        } else if (*p == '\n') {
-            ++(*curLineNumPtr);
-        }
-        ++p;
-        TIXMLASSERT( p );
-    }
-    return 0;
-}
-
-
-char* StrPair::ParseName( char* p )
-{
-    if ( !p || !(*p) ) {
-        return 0;
-    }
-    if ( !XMLUtil::IsNameStartChar( *p ) ) {
-        return 0;
-    }
-
-    char* const start = p;
-    ++p;
-    while ( *p && XMLUtil::IsNameChar( *p ) ) {
-        ++p;
-    }
-
-    Set( start, p, 0 );
-    return p;
-}
-
-
-void StrPair::CollapseWhitespace()
-{
-    // Adjusting _start would cause undefined behavior on delete[]
-    TIXMLASSERT( ( _flags & NEEDS_DELETE ) == 0 );
-    // Trim leading space.
-    _start = XMLUtil::SkipWhiteSpace( _start, 0 );
-
-    if ( *_start ) {
-        const char* p = _start;	// the read pointer
-        char* q = _start;	// the write pointer
-
-        while( *p ) {
-            if ( XMLUtil::IsWhiteSpace( *p )) {
-                p = XMLUtil::SkipWhiteSpace( p, 0 );
-                if ( *p == 0 ) {
-                    break;    // don't write to q; this trims the trailing space.
-                }
-                *q = ' ';
-                ++q;
-            }
-            *q = *p;
-            ++q;
-            ++p;
-        }
-        *q = 0;
-    }
-}
-
-
-const char* StrPair::GetStr()
-{
-    TIXMLASSERT( _start );
-    TIXMLASSERT( _end );
-    if ( _flags & NEEDS_FLUSH ) {
-        *_end = 0;
-        _flags ^= NEEDS_FLUSH;
-
-        if ( _flags ) {
-            const char* p = _start;	// the read pointer
-            char* q = _start;	// the write pointer
-
-            while( p < _end ) {
-                if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == CR ) {
-                    // CR-LF pair becomes LF
-                    // CR alone becomes LF
-                    // LF-CR becomes LF
-                    if ( *(p+1) == LF ) {
-                        p += 2;
-                    }
-                    else {
-                        ++p;
-                    }
-                    *q = LF;
-                    ++q;
-                }
-                else if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == LF ) {
-                    if ( *(p+1) == CR ) {
-                        p += 2;
-                    }
-                    else {
-                        ++p;
-                    }
-                    *q = LF;
-                    ++q;
-                }
-                else if ( (_flags & NEEDS_ENTITY_PROCESSING) && *p == '&' ) {
-                    // Entities handled by tinyXML2:
-                    // - special entities in the entity table [in/out]
-                    // - numeric character reference [in]
-                    //   &#20013; or &#x4e2d;
-
-                    if ( *(p+1) == '#' ) {
-                        const int buflen = 10;
-                        char buf[buflen] = { 0 };
-                        int len = 0;
-                        char* adjusted = const_cast<char*>( XMLUtil::GetCharacterRef( p, buf, &len ) );
-                        if ( adjusted == 0 ) {
-                            *q = *p;
-                            ++p;
-                            ++q;
-                        }
-                        else {
-                            TIXMLASSERT( 0 <= len && len <= buflen );
-                            TIXMLASSERT( q + len <= adjusted );
-                            p = adjusted;
-                            memcpy( q, buf, len );
-                            q += len;
-                        }
-                    }
-                    else {
-                        bool entityFound = false;
-                        for( int i = 0; i < NUM_ENTITIES; ++i ) {
-                            const Entity& entity = entities[i];
-                            if ( strncmp( p + 1, entity.pattern, entity.length ) == 0
-                                    && *( p + entity.length + 1 ) == ';' ) {
-                                // Found an entity - convert.
-                                *q = entity.value;
-                                ++q;
-                                p += entity.length + 2;
-                                entityFound = true;
-                                break;
-                            }
-                        }
-                        if ( !entityFound ) {
-                            // fixme: treat as error?
-                            ++p;
-                            ++q;
-                        }
-                    }
-                }
-                else {
-                    *q = *p;
-                    ++p;
-                    ++q;
-                }
-            }
-            *q = 0;
-        }
-        // The loop below has plenty going on, and this
-        // is a less useful mode. Break it out.
-        if ( _flags & NEEDS_WHITESPACE_COLLAPSING ) {
-            CollapseWhitespace();
-        }
-        _flags = (_flags & NEEDS_DELETE);
-    }
-    TIXMLASSERT( _start );
-    return _start;
-}
-
-
-
-
-// --------- XMLUtil ----------- //
-
-const char* XMLUtil::writeBoolTrue  = "true";
-const char* XMLUtil::writeBoolFalse = "false";
-
-void XMLUtil::SetBoolSerialization(const char* writeTrue, const char* writeFalse)
-{
-	static const char* defTrue  = "true";
-	static const char* defFalse = "false";
-
-	writeBoolTrue = (writeTrue) ? writeTrue : defTrue;
-	writeBoolFalse = (writeFalse) ? writeFalse : defFalse;
-}
-
-
-const char* XMLUtil::ReadBOM( const char* p, bool* bom )
-{
-    TIXMLASSERT( p );
-    TIXMLASSERT( bom );
-    *bom = false;
-    const unsigned char* pu = reinterpret_cast<const unsigned char*>(p);
-    // Check for BOM:
-    if (    *(pu+0) == TIXML_UTF_LEAD_0
-            && *(pu+1) == TIXML_UTF_LEAD_1
-            && *(pu+2) == TIXML_UTF_LEAD_2 ) {
-        *bom = true;
-        p += 3;
-    }
-    TIXMLASSERT( p );
-    return p;
-}
-
-
-void XMLUtil::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length )
-{
-    const unsigned long BYTE_MASK = 0xBF;
-    const unsigned long BYTE_MARK = 0x80;
-    const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
-
-    if (input < 0x80) {
-        *length = 1;
-    }
-    else if ( input < 0x800 ) {
-        *length = 2;
-    }
-    else if ( input < 0x10000 ) {
-        *length = 3;
-    }
-    else if ( input < 0x200000 ) {
-        *length = 4;
-    }
-    else {
-        *length = 0;    // This code won't convert this correctly anyway.
-        return;
-    }
-
-    output += *length;
-
-    // Scary scary fall throughs are annotated with carefully designed comments
-    // to suppress compiler warnings such as -Wimplicit-fallthrough in gcc
-    switch (*length) {
-        case 4:
-            --output;
-            *output = (char)((input | BYTE_MARK) & BYTE_MASK);
-            input >>= 6;
-            //fall through
-        case 3:
-            --output;
-            *output = (char)((input | BYTE_MARK) & BYTE_MASK);
-            input >>= 6;
-            //fall through
-        case 2:
-            --output;
-            *output = (char)((input | BYTE_MARK) & BYTE_MASK);
-            input >>= 6;
-            //fall through
-        case 1:
-            --output;
-            *output = (char)(input | FIRST_BYTE_MARK[*length]);
-            break;
-        default:
-            TIXMLASSERT( false );
-    }
-}
-
-
-const char* XMLUtil::GetCharacterRef( const char* p, char* value, int* length )
-{
-    // Presume an entity, and pull it out.
-    *length = 0;
-
-    if ( *(p+1) == '#' && *(p+2) ) {
-        unsigned long ucs = 0;
-        TIXMLASSERT( sizeof( ucs ) >= 4 );
-        ptrdiff_t delta = 0;
-        unsigned mult = 1;
-        static const char SEMICOLON = ';';
-
-        if ( *(p+2) == 'x' ) {
-            // Hexadecimal.
-            const char* q = p+3;
-            if ( !(*q) ) {
-                return 0;
-            }
-
-            q = strchr( q, SEMICOLON );
-
-            if ( !q ) {
-                return 0;
-            }
-            TIXMLASSERT( *q == SEMICOLON );
-
-            delta = q-p;
-            --q;
-
-            while ( *q != 'x' ) {
-                unsigned int digit = 0;
-
-                if ( *q >= '0' && *q <= '9' ) {
-                    digit = *q - '0';
-                }
-                else if ( *q >= 'a' && *q <= 'f' ) {
-                    digit = *q - 'a' + 10;
-                }
-                else if ( *q >= 'A' && *q <= 'F' ) {
-                    digit = *q - 'A' + 10;
-                }
-                else {
-                    return 0;
-                }
-                TIXMLASSERT( digit < 16 );
-                TIXMLASSERT( digit == 0 || mult <= UINT_MAX / digit );
-                const unsigned int digitScaled = mult * digit;
-                TIXMLASSERT( ucs <= ULONG_MAX - digitScaled );
-                ucs += digitScaled;
-                TIXMLASSERT( mult <= UINT_MAX / 16 );
-                mult *= 16;
-                --q;
-            }
-        }
-        else {
-            // Decimal.
-            const char* q = p+2;
-            if ( !(*q) ) {
-                return 0;
-            }
-
-            q = strchr( q, SEMICOLON );
-
-            if ( !q ) {
-                return 0;
-            }
-            TIXMLASSERT( *q == SEMICOLON );
-
-            delta = q-p;
-            --q;
-
-            while ( *q != '#' ) {
-                if ( *q >= '0' && *q <= '9' ) {
-                    const unsigned int digit = *q - '0';
-                    TIXMLASSERT( digit < 10 );
-                    TIXMLASSERT( digit == 0 || mult <= UINT_MAX / digit );
-                    const unsigned int digitScaled = mult * digit;
-                    TIXMLASSERT( ucs <= ULONG_MAX - digitScaled );
-                    ucs += digitScaled;
-                }
-                else {
-                    return 0;
-                }
-                TIXMLASSERT( mult <= UINT_MAX / 10 );
-                mult *= 10;
-                --q;
-            }
-        }
-        // convert the UCS to UTF-8
-        ConvertUTF32ToUTF8( ucs, value, length );
-        return p + delta + 1;
-    }
-    return p+1;
-}
-
-
-void XMLUtil::ToStr( int v, char* buffer, int bufferSize )
-{
-    TIXML_SNPRINTF( buffer, bufferSize, "%d", v );
-}
-
-
-void XMLUtil::ToStr( unsigned v, char* buffer, int bufferSize )
-{
-    TIXML_SNPRINTF( buffer, bufferSize, "%u", v );
-}
-
-
-void XMLUtil::ToStr( bool v, char* buffer, int bufferSize )
-{
-    TIXML_SNPRINTF( buffer, bufferSize, "%s", v ? writeBoolTrue : writeBoolFalse);
-}
-
-/*
-	ToStr() of a number is a very tricky topic.
-	https://github.com/leethomason/tinyxml2/issues/106
-*/
-void XMLUtil::ToStr( float v, char* buffer, int bufferSize )
-{
-    TIXML_SNPRINTF( buffer, bufferSize, "%.8g", v );
-}
-
-
-void XMLUtil::ToStr( double v, char* buffer, int bufferSize )
-{
-    TIXML_SNPRINTF( buffer, bufferSize, "%.17g", v );
-}
-
-
-void XMLUtil::ToStr(int64_t v, char* buffer, int bufferSize)
-{
-	// horrible syntax trick to make the compiler happy about %lld
-	TIXML_SNPRINTF(buffer, bufferSize, "%lld", (long long)v);
-}
-
-
-bool XMLUtil::ToInt( const char* str, int* value )
-{
-    if ( TIXML_SSCANF( str, "%d", value ) == 1 ) {
-        return true;
-    }
-    return false;
-}
-
-bool XMLUtil::ToUnsigned( const char* str, unsigned *value )
-{
-    if ( TIXML_SSCANF( str, "%u", value ) == 1 ) {
-        return true;
-    }
-    return false;
-}
-
-bool XMLUtil::ToBool( const char* str, bool* value )
-{
-    int ival = 0;
-    if ( ToInt( str, &ival )) {
-        *value = (ival==0) ? false : true;
-        return true;
-    }
-    if ( StringEqual( str, "true" ) ) {
-        *value = true;
-        return true;
-    }
-    else if ( StringEqual( str, "false" ) ) {
-        *value = false;
-        return true;
-    }
-    return false;
-}
-
-
-bool XMLUtil::ToFloat( const char* str, float* value )
-{
-    if ( TIXML_SSCANF( str, "%f", value ) == 1 ) {
-        return true;
-    }
-    return false;
-}
-
-
-bool XMLUtil::ToDouble( const char* str, double* value )
-{
-    if ( TIXML_SSCANF( str, "%lf", value ) == 1 ) {
-        return true;
-    }
-    return false;
-}
-
-
-bool XMLUtil::ToInt64(const char* str, int64_t* value)
-{
-	long long v = 0;	// horrible syntax trick to make the compiler happy about %lld
-	if (TIXML_SSCANF(str, "%lld", &v) == 1) {
-		*value = (int64_t)v;
-		return true;
-	}
-	return false;
-}
-
-
-char* XMLDocument::Identify( char* p, XMLNode** node )
-{
-    TIXMLASSERT( node );
-    TIXMLASSERT( p );
-    char* const start = p;
-    int const startLine = _parseCurLineNum;
-    p = XMLUtil::SkipWhiteSpace( p, &_parseCurLineNum );
-    if( !*p ) {
-        *node = 0;
-        TIXMLASSERT( p );
-        return p;
-    }
-
-    // These strings define the matching patterns:
-    static const char* xmlHeader		= { "<?" };
-    static const char* commentHeader	= { "<!--" };
-    static const char* cdataHeader		= { "<![CDATA[" };
-    static const char* dtdHeader		= { "<!" };
-    static const char* elementHeader	= { "<" };	// and a header for everything else; check last.
-
-    static const int xmlHeaderLen		= 2;
-    static const int commentHeaderLen	= 4;
-    static const int cdataHeaderLen		= 9;
-    static const int dtdHeaderLen		= 2;
-    static const int elementHeaderLen	= 1;
-
-    TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLUnknown ) );		// use same memory pool
-    TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLDeclaration ) );	// use same memory pool
-    XMLNode* returnNode = 0;
-    if ( XMLUtil::StringEqual( p, xmlHeader, xmlHeaderLen ) ) {
-        returnNode = CreateUnlinkedNode<XMLDeclaration>( _commentPool );
-        returnNode->_parseLineNum = _parseCurLineNum;
-        p += xmlHeaderLen;
-    }
-    else if ( XMLUtil::StringEqual( p, commentHeader, commentHeaderLen ) ) {
-        returnNode = CreateUnlinkedNode<XMLComment>( _commentPool );
-        returnNode->_parseLineNum = _parseCurLineNum;
-        p += commentHeaderLen;
-    }
-    else if ( XMLUtil::StringEqual( p, cdataHeader, cdataHeaderLen ) ) {
-        XMLText* text = CreateUnlinkedNode<XMLText>( _textPool );
-        returnNode = text;
-        returnNode->_parseLineNum = _parseCurLineNum;
-        p += cdataHeaderLen;
-        text->SetCData( true );
-    }
-    else if ( XMLUtil::StringEqual( p, dtdHeader, dtdHeaderLen ) ) {
-        returnNode = CreateUnlinkedNode<XMLUnknown>( _commentPool );
-        returnNode->_parseLineNum = _parseCurLineNum;
-        p += dtdHeaderLen;
-    }
-    else if ( XMLUtil::StringEqual( p, elementHeader, elementHeaderLen ) ) {
-        returnNode =  CreateUnlinkedNode<XMLElement>( _elementPool );
-        returnNode->_parseLineNum = _parseCurLineNum;
-        p += elementHeaderLen;
-    }
-    else {
-        returnNode = CreateUnlinkedNode<XMLText>( _textPool );
-        returnNode->_parseLineNum = _parseCurLineNum; // Report line of first non-whitespace character
-        p = start;	// Back it up, all the text counts.
-        _parseCurLineNum = startLine;
-    }
-
-    TIXMLASSERT( returnNode );
-    TIXMLASSERT( p );
-    *node = returnNode;
-    return p;
-}
-
-
-bool XMLDocument::Accept( XMLVisitor* visitor ) const
-{
-    TIXMLASSERT( visitor );
-    if ( visitor->VisitEnter( *this ) ) {
-        for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
-            if ( !node->Accept( visitor ) ) {
-                break;
-            }
-        }
-    }
-    return visitor->VisitExit( *this );
-}
-
-
-// --------- XMLNode ----------- //
-
-XMLNode::XMLNode( XMLDocument* doc ) :
-    _document( doc ),
-    _parent( 0 ),
-    _value(),
-    _parseLineNum( 0 ),
-    _firstChild( 0 ), _lastChild( 0 ),
-    _prev( 0 ), _next( 0 ),
-	_userData( 0 ),
-    _memPool( 0 )
-{
-}
-
-
-XMLNode::~XMLNode()
-{
-    DeleteChildren();
-    if ( _parent ) {
-        _parent->Unlink( this );
-    }
-}
-
-const char* XMLNode::Value() const
-{
-    // Edge case: XMLDocuments don't have a Value. Return null.
-    if ( this->ToDocument() )
-        return 0;
-    return _value.GetStr();
-}
-
-void XMLNode::SetValue( const char* str, bool staticMem )
-{
-    if ( staticMem ) {
-        _value.SetInternedStr( str );
-    }
-    else {
-        _value.SetStr( str );
-    }
-}
-
-XMLNode* XMLNode::DeepClone(XMLDocument* target) const
-{
-	XMLNode* clone = this->ShallowClone(target);
-	if (!clone) return 0;
-
-	for (const XMLNode* child = this->FirstChild(); child; child = child->NextSibling()) {
-		XMLNode* childClone = child->DeepClone(target);
-		TIXMLASSERT(childClone);
-		clone->InsertEndChild(childClone);
-	}
-	return clone;
-}
-
-void XMLNode::DeleteChildren()
-{
-    while( _firstChild ) {
-        TIXMLASSERT( _lastChild );
-        DeleteChild( _firstChild );
-    }
-    _firstChild = _lastChild = 0;
-}
-
-
-void XMLNode::Unlink( XMLNode* child )
-{
-    TIXMLASSERT( child );
-    TIXMLASSERT( child->_document == _document );
-    TIXMLASSERT( child->_parent == this );
-    if ( child == _firstChild ) {
-        _firstChild = _firstChild->_next;
-    }
-    if ( child == _lastChild ) {
-        _lastChild = _lastChild->_prev;
-    }
-
-    if ( child->_prev ) {
-        child->_prev->_next = child->_next;
-    }
-    if ( child->_next ) {
-        child->_next->_prev = child->_prev;
-    }
-	child->_next = 0;
-	child->_prev = 0;
-	child->_parent = 0;
-}
-
-
-void XMLNode::DeleteChild( XMLNode* node )
-{
-    TIXMLASSERT( node );
-    TIXMLASSERT( node->_document == _document );
-    TIXMLASSERT( node->_parent == this );
-    Unlink( node );
-	TIXMLASSERT(node->_prev == 0);
-	TIXMLASSERT(node->_next == 0);
-	TIXMLASSERT(node->_parent == 0);
-    DeleteNode( node );
-}
-
-
-XMLNode* XMLNode::InsertEndChild( XMLNode* addThis )
-{
-    TIXMLASSERT( addThis );
-    if ( addThis->_document != _document ) {
-        TIXMLASSERT( false );
-        return 0;
-    }
-    InsertChildPreamble( addThis );
-
-    if ( _lastChild ) {
-        TIXMLASSERT( _firstChild );
-        TIXMLASSERT( _lastChild->_next == 0 );
-        _lastChild->_next = addThis;
-        addThis->_prev = _lastChild;
-        _lastChild = addThis;
-
-        addThis->_next = 0;
-    }
-    else {
-        TIXMLASSERT( _firstChild == 0 );
-        _firstChild = _lastChild = addThis;
-
-        addThis->_prev = 0;
-        addThis->_next = 0;
-    }
-    addThis->_parent = this;
-    return addThis;
-}
-
-
-XMLNode* XMLNode::InsertFirstChild( XMLNode* addThis )
-{
-    TIXMLASSERT( addThis );
-    if ( addThis->_document != _document ) {
-        TIXMLASSERT( false );
-        return 0;
-    }
-    InsertChildPreamble( addThis );
-
-    if ( _firstChild ) {
-        TIXMLASSERT( _lastChild );
-        TIXMLASSERT( _firstChild->_prev == 0 );
-
-        _firstChild->_prev = addThis;
-        addThis->_next = _firstChild;
-        _firstChild = addThis;
-
-        addThis->_prev = 0;
-    }
-    else {
-        TIXMLASSERT( _lastChild == 0 );
-        _firstChild = _lastChild = addThis;
-
-        addThis->_prev = 0;
-        addThis->_next = 0;
-    }
-    addThis->_parent = this;
-    return addThis;
-}
-
-
-XMLNode* XMLNode::InsertAfterChild( XMLNode* afterThis, XMLNode* addThis )
-{
-    TIXMLASSERT( addThis );
-    if ( addThis->_document != _document ) {
-        TIXMLASSERT( false );
-        return 0;
-    }
-
-    TIXMLASSERT( afterThis );
-
-    if ( afterThis->_parent != this ) {
-        TIXMLASSERT( false );
-        return 0;
-    }
-    if ( afterThis == addThis ) {
-        // Current state: BeforeThis -> AddThis -> OneAfterAddThis
-        // Now AddThis must disappear from it's location and then
-        // reappear between BeforeThis and OneAfterAddThis.
-        // So just leave it where it is.
-        return addThis;
-    }
-
-    if ( afterThis->_next == 0 ) {
-        // The last node or the only node.
-        return InsertEndChild( addThis );
-    }
-    InsertChildPreamble( addThis );
-    addThis->_prev = afterThis;
-    addThis->_next = afterThis->_next;
-    afterThis->_next->_prev = addThis;
-    afterThis->_next = addThis;
-    addThis->_parent = this;
-    return addThis;
-}
-
-
-
-
-const XMLElement* XMLNode::FirstChildElement( const char* name ) const
-{
-    for( const XMLNode* node = _firstChild; node; node = node->_next ) {
-        const XMLElement* element = node->ToElementWithName( name );
-        if ( element ) {
-            return element;
-        }
-    }
-    return 0;
-}
-
-
-const XMLElement* XMLNode::LastChildElement( const char* name ) const
-{
-    for( const XMLNode* node = _lastChild; node; node = node->_prev ) {
-        const XMLElement* element = node->ToElementWithName( name );
-        if ( element ) {
-            return element;
-        }
-    }
-    return 0;
-}
-
-
-const XMLElement* XMLNode::NextSiblingElement( const char* name ) const
-{
-    for( const XMLNode* node = _next; node; node = node->_next ) {
-        const XMLElement* element = node->ToElementWithName( name );
-        if ( element ) {
-            return element;
-        }
-    }
-    return 0;
-}
-
-
-const XMLElement* XMLNode::PreviousSiblingElement( const char* name ) const
-{
-    for( const XMLNode* node = _prev; node; node = node->_prev ) {
-        const XMLElement* element = node->ToElementWithName( name );
-        if ( element ) {
-            return element;
-        }
-    }
-    return 0;
-}
-
-
-char* XMLNode::ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr )
-{
-    // This is a recursive method, but thinking about it "at the current level"
-    // it is a pretty simple flat list:
-    //		<foo/>
-    //		<!-- comment -->
-    //
-    // With a special case:
-    //		<foo>
-    //		</foo>
-    //		<!-- comment -->
-    //
-    // Where the closing element (/foo) *must* be the next thing after the opening
-    // element, and the names must match. BUT the tricky bit is that the closing
-    // element will be read by the child.
-    //
-    // 'endTag' is the end tag for this node, it is returned by a call to a child.
-    // 'parentEnd' is the end tag for the parent, which is filled in and returned.
-
-    while( p && *p ) {
-        XMLNode* node = 0;
-
-        p = _document->Identify( p, &node );
-        TIXMLASSERT( p );
-        if ( node == 0 ) {
-            break;
-        }
-
-        int initialLineNum = node->_parseLineNum;
-
-        StrPair endTag;
-        p = node->ParseDeep( p, &endTag, curLineNumPtr );
-        if ( !p ) {
-            DeleteNode( node );
-            if ( !_document->Error() ) {
-                _document->SetError( XML_ERROR_PARSING, initialLineNum, 0);
-            }
-            break;
-        }
-
-        XMLDeclaration* decl = node->ToDeclaration();
-        if ( decl ) {
-            // Declarations are only allowed at document level
-            bool wellLocated = ( ToDocument() != 0 );
-            if ( wellLocated ) {
-                // Multiple declarations are allowed but all declarations
-                // must occur before anything else
-                for ( const XMLNode* existingNode = _document->FirstChild(); existingNode; existingNode = existingNode->NextSibling() ) {
-                    if ( !existingNode->ToDeclaration() ) {
-                        wellLocated = false;
-                        break;
-                    }
-                }
-            }
-            if ( !wellLocated ) {
-                _document->SetError( XML_ERROR_PARSING_DECLARATION, initialLineNum, "XMLDeclaration value=%s", decl->Value());
-                DeleteNode( node );
-                break;
-            }
-        }
-
-        XMLElement* ele = node->ToElement();
-        if ( ele ) {
-            // We read the end tag. Return it to the parent.
-            if ( ele->ClosingType() == XMLElement::CLOSING ) {
-                if ( parentEndTag ) {
-                    ele->_value.TransferTo( parentEndTag );
-                }
-                node->_memPool->SetTracked();   // created and then immediately deleted.
-                DeleteNode( node );
-                return p;
-            }
-
-            // Handle an end tag returned to this level.
-            // And handle a bunch of annoying errors.
-            bool mismatch = false;
-            if ( endTag.Empty() ) {
-                if ( ele->ClosingType() == XMLElement::OPEN ) {
-                    mismatch = true;
-                }
-            }
-            else {
-                if ( ele->ClosingType() != XMLElement::OPEN ) {
-                    mismatch = true;
-                }
-                else if ( !XMLUtil::StringEqual( endTag.GetStr(), ele->Name() ) ) {
-                    mismatch = true;
-                }
-            }
-            if ( mismatch ) {
-                _document->SetError( XML_ERROR_MISMATCHED_ELEMENT, initialLineNum, "XMLElement name=%s", ele->Name());
-                DeleteNode( node );
-                break;
-            }
-        }
-        InsertEndChild( node );
-    }
-    return 0;
-}
-
-/*static*/ void XMLNode::DeleteNode( XMLNode* node )
-{
-    if ( node == 0 ) {
-        return;
-    }
-	TIXMLASSERT(node->_document);
-	if (!node->ToDocument()) {
-		node->_document->MarkInUse(node);
-	}
-
-    MemPool* pool = node->_memPool;
-    node->~XMLNode();
-    pool->Free( node );
-}
-
-void XMLNode::InsertChildPreamble( XMLNode* insertThis ) const
-{
-    TIXMLASSERT( insertThis );
-    TIXMLASSERT( insertThis->_document == _document );
-
-	if (insertThis->_parent) {
-        insertThis->_parent->Unlink( insertThis );
-	}
-	else {
-		insertThis->_document->MarkInUse(insertThis);
-        insertThis->_memPool->SetTracked();
-	}
-}
-
-const XMLElement* XMLNode::ToElementWithName( const char* name ) const
-{
-    const XMLElement* element = this->ToElement();
-    if ( element == 0 ) {
-        return 0;
-    }
-    if ( name == 0 ) {
-        return element;
-    }
-    if ( XMLUtil::StringEqual( element->Name(), name ) ) {
-       return element;
-    }
-    return 0;
-}
-
-// --------- XMLText ---------- //
-char* XMLText::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
-{
-    if ( this->CData() ) {
-        p = _value.ParseText( p, "]]>", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr );
-        if ( !p ) {
-            _document->SetError( XML_ERROR_PARSING_CDATA, _parseLineNum, 0 );
-        }
-        return p;
-    }
-    else {
-        int flags = _document->ProcessEntities() ? StrPair::TEXT_ELEMENT : StrPair::TEXT_ELEMENT_LEAVE_ENTITIES;
-        if ( _document->WhitespaceMode() == COLLAPSE_WHITESPACE ) {
-            flags |= StrPair::NEEDS_WHITESPACE_COLLAPSING;
-        }
-
-        p = _value.ParseText( p, "<", flags, curLineNumPtr );
-        if ( p && *p ) {
-            return p-1;
-        }
-        if ( !p ) {
-            _document->SetError( XML_ERROR_PARSING_TEXT, _parseLineNum, 0 );
-        }
-    }
-    return 0;
-}
-
-
-XMLNode* XMLText::ShallowClone( XMLDocument* doc ) const
-{
-    if ( !doc ) {
-        doc = _document;
-    }
-    XMLText* text = doc->NewText( Value() );	// fixme: this will always allocate memory. Intern?
-    text->SetCData( this->CData() );
-    return text;
-}
-
-
-bool XMLText::ShallowEqual( const XMLNode* compare ) const
-{
-    TIXMLASSERT( compare );
-    const XMLText* text = compare->ToText();
-    return ( text && XMLUtil::StringEqual( text->Value(), Value() ) );
-}
-
-
-bool XMLText::Accept( XMLVisitor* visitor ) const
-{
-    TIXMLASSERT( visitor );
-    return visitor->Visit( *this );
-}
-
-
-// --------- XMLComment ---------- //
-
-XMLComment::XMLComment( XMLDocument* doc ) : XMLNode( doc )
-{
-}
-
-
-XMLComment::~XMLComment()
-{
-}
-
-
-char* XMLComment::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
-{
-    // Comment parses as text.
-    p = _value.ParseText( p, "-->", StrPair::COMMENT, curLineNumPtr );
-    if ( p == 0 ) {
-        _document->SetError( XML_ERROR_PARSING_COMMENT, _parseLineNum, 0 );
-    }
-    return p;
-}
-
-
-XMLNode* XMLComment::ShallowClone( XMLDocument* doc ) const
-{
-    if ( !doc ) {
-        doc = _document;
-    }
-    XMLComment* comment = doc->NewComment( Value() );	// fixme: this will always allocate memory. Intern?
-    return comment;
-}
-
-
-bool XMLComment::ShallowEqual( const XMLNode* compare ) const
-{
-    TIXMLASSERT( compare );
-    const XMLComment* comment = compare->ToComment();
-    return ( comment && XMLUtil::StringEqual( comment->Value(), Value() ));
-}
-
-
-bool XMLComment::Accept( XMLVisitor* visitor ) const
-{
-    TIXMLASSERT( visitor );
-    return visitor->Visit( *this );
-}
-
-
-// --------- XMLDeclaration ---------- //
-
-XMLDeclaration::XMLDeclaration( XMLDocument* doc ) : XMLNode( doc )
-{
-}
-
-
-XMLDeclaration::~XMLDeclaration()
-{
-    //printf( "~XMLDeclaration\n" );
-}
-
-
-char* XMLDeclaration::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
-{
-    // Declaration parses as text.
-    p = _value.ParseText( p, "?>", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr );
-    if ( p == 0 ) {
-        _document->SetError( XML_ERROR_PARSING_DECLARATION, _parseLineNum, 0 );
-    }
-    return p;
-}
-
-
-XMLNode* XMLDeclaration::ShallowClone( XMLDocument* doc ) const
-{
-    if ( !doc ) {
-        doc = _document;
-    }
-    XMLDeclaration* dec = doc->NewDeclaration( Value() );	// fixme: this will always allocate memory. Intern?
-    return dec;
-}
-
-
-bool XMLDeclaration::ShallowEqual( const XMLNode* compare ) const
-{
-    TIXMLASSERT( compare );
-    const XMLDeclaration* declaration = compare->ToDeclaration();
-    return ( declaration && XMLUtil::StringEqual( declaration->Value(), Value() ));
-}
-
-
-
-bool XMLDeclaration::Accept( XMLVisitor* visitor ) const
-{
-    TIXMLASSERT( visitor );
-    return visitor->Visit( *this );
-}
-
-// --------- XMLUnknown ---------- //
-
-XMLUnknown::XMLUnknown( XMLDocument* doc ) : XMLNode( doc )
-{
-}
-
-
-XMLUnknown::~XMLUnknown()
-{
-}
-
-
-char* XMLUnknown::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
-{
-    // Unknown parses as text.
-    p = _value.ParseText( p, ">", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr );
-    if ( !p ) {
-        _document->SetError( XML_ERROR_PARSING_UNKNOWN, _parseLineNum, 0 );
-    }
-    return p;
-}
-
-
-XMLNode* XMLUnknown::ShallowClone( XMLDocument* doc ) const
-{
-    if ( !doc ) {
-        doc = _document;
-    }
-    XMLUnknown* text = doc->NewUnknown( Value() );	// fixme: this will always allocate memory. Intern?
-    return text;
-}
-
-
-bool XMLUnknown::ShallowEqual( const XMLNode* compare ) const
-{
-    TIXMLASSERT( compare );
-    const XMLUnknown* unknown = compare->ToUnknown();
-    return ( unknown && XMLUtil::StringEqual( unknown->Value(), Value() ));
-}
-
-
-bool XMLUnknown::Accept( XMLVisitor* visitor ) const
-{
-    TIXMLASSERT( visitor );
-    return visitor->Visit( *this );
-}
-
-// --------- XMLAttribute ---------- //
-
-const char* XMLAttribute::Name() const
-{
-    return _name.GetStr();
-}
-
-const char* XMLAttribute::Value() const
-{
-    return _value.GetStr();
-}
-
-char* XMLAttribute::ParseDeep( char* p, bool processEntities, int* curLineNumPtr )
-{
-    // Parse using the name rules: bug fix, was using ParseText before
-    p = _name.ParseName( p );
-    if ( !p || !*p ) {
-        return 0;
-    }
-
-    // Skip white space before =
-    p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
-    if ( *p != '=' ) {
-        return 0;
-    }
-
-    ++p;	// move up to opening quote
-    p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
-    if ( *p != '\"' && *p != '\'' ) {
-        return 0;
-    }
-
-    char endTag[2] = { *p, 0 };
-    ++p;	// move past opening quote
-
-    p = _value.ParseText( p, endTag, processEntities ? StrPair::ATTRIBUTE_VALUE : StrPair::ATTRIBUTE_VALUE_LEAVE_ENTITIES, curLineNumPtr );
-    return p;
-}
-
-
-void XMLAttribute::SetName( const char* n )
-{
-    _name.SetStr( n );
-}
-
-
-XMLError XMLAttribute::QueryIntValue( int* value ) const
-{
-    if ( XMLUtil::ToInt( Value(), value )) {
-        return XML_SUCCESS;
-    }
-    return XML_WRONG_ATTRIBUTE_TYPE;
-}
-
-
-XMLError XMLAttribute::QueryUnsignedValue( unsigned int* value ) const
-{
-    if ( XMLUtil::ToUnsigned( Value(), value )) {
-        return XML_SUCCESS;
-    }
-    return XML_WRONG_ATTRIBUTE_TYPE;
-}
-
-
-XMLError XMLAttribute::QueryInt64Value(int64_t* value) const
-{
-	if (XMLUtil::ToInt64(Value(), value)) {
-		return XML_SUCCESS;
-	}
-	return XML_WRONG_ATTRIBUTE_TYPE;
-}
-
-
-XMLError XMLAttribute::QueryBoolValue( bool* value ) const
-{
-    if ( XMLUtil::ToBool( Value(), value )) {
-        return XML_SUCCESS;
-    }
-    return XML_WRONG_ATTRIBUTE_TYPE;
-}
-
-
-XMLError XMLAttribute::QueryFloatValue( float* value ) const
-{
-    if ( XMLUtil::ToFloat( Value(), value )) {
-        return XML_SUCCESS;
-    }
-    return XML_WRONG_ATTRIBUTE_TYPE;
-}
-
-
-XMLError XMLAttribute::QueryDoubleValue( double* value ) const
-{
-    if ( XMLUtil::ToDouble( Value(), value )) {
-        return XML_SUCCESS;
-    }
-    return XML_WRONG_ATTRIBUTE_TYPE;
-}
-
-
-void XMLAttribute::SetAttribute( const char* v )
-{
-    _value.SetStr( v );
-}
-
-
-void XMLAttribute::SetAttribute( int v )
-{
-    char buf[BUF_SIZE];
-    XMLUtil::ToStr( v, buf, BUF_SIZE );
-    _value.SetStr( buf );
-}
-
-
-void XMLAttribute::SetAttribute( unsigned v )
-{
-    char buf[BUF_SIZE];
-    XMLUtil::ToStr( v, buf, BUF_SIZE );
-    _value.SetStr( buf );
-}
-
-
-void XMLAttribute::SetAttribute(int64_t v)
-{
-	char buf[BUF_SIZE];
-	XMLUtil::ToStr(v, buf, BUF_SIZE);
-	_value.SetStr(buf);
-}
-
-
-
-void XMLAttribute::SetAttribute( bool v )
-{
-    char buf[BUF_SIZE];
-    XMLUtil::ToStr( v, buf, BUF_SIZE );
-    _value.SetStr( buf );
-}
-
-void XMLAttribute::SetAttribute( double v )
-{
-    char buf[BUF_SIZE];
-    XMLUtil::ToStr( v, buf, BUF_SIZE );
-    _value.SetStr( buf );
-}
-
-void XMLAttribute::SetAttribute( float v )
-{
-    char buf[BUF_SIZE];
-    XMLUtil::ToStr( v, buf, BUF_SIZE );
-    _value.SetStr( buf );
-}
-
-
-// --------- XMLElement ---------- //
-XMLElement::XMLElement( XMLDocument* doc ) : XMLNode( doc ),
-    _closingType( OPEN ),
-    _rootAttribute( 0 )
-{
-}
-
-
-XMLElement::~XMLElement()
-{
-    while( _rootAttribute ) {
-        XMLAttribute* next = _rootAttribute->_next;
-        DeleteAttribute( _rootAttribute );
-        _rootAttribute = next;
-    }
-}
-
-
-const XMLAttribute* XMLElement::FindAttribute( const char* name ) const
-{
-    for( XMLAttribute* a = _rootAttribute; a; a = a->_next ) {
-        if ( XMLUtil::StringEqual( a->Name(), name ) ) {
-            return a;
-        }
-    }
-    return 0;
-}
-
-
-const char* XMLElement::Attribute( const char* name, const char* value ) const
-{
-    const XMLAttribute* a = FindAttribute( name );
-    if ( !a ) {
-        return 0;
-    }
-    if ( !value || XMLUtil::StringEqual( a->Value(), value )) {
-        return a->Value();
-    }
-    return 0;
-}
-
-int XMLElement::IntAttribute(const char* name, int defaultValue) const
-{
-	int i = defaultValue;
-	QueryIntAttribute(name, &i);
-	return i;
-}
-
-unsigned XMLElement::UnsignedAttribute(const char* name, unsigned defaultValue) const
-{
-	unsigned i = defaultValue;
-	QueryUnsignedAttribute(name, &i);
-	return i;
-}
-
-int64_t XMLElement::Int64Attribute(const char* name, int64_t defaultValue) const
-{
-	int64_t i = defaultValue;
-	QueryInt64Attribute(name, &i);
-	return i;
-}
-
-bool XMLElement::BoolAttribute(const char* name, bool defaultValue) const
-{
-	bool b = defaultValue;
-	QueryBoolAttribute(name, &b);
-	return b;
-}
-
-double XMLElement::DoubleAttribute(const char* name, double defaultValue) const
-{
-	double d = defaultValue;
-	QueryDoubleAttribute(name, &d);
-	return d;
-}
-
-float XMLElement::FloatAttribute(const char* name, float defaultValue) const
-{
-	float f = defaultValue;
-	QueryFloatAttribute(name, &f);
-	return f;
-}
-
-const char* XMLElement::GetText() const
-{
-    if ( FirstChild() && FirstChild()->ToText() ) {
-        return FirstChild()->Value();
-    }
-    return 0;
-}
-
-
-void	XMLElement::SetText( const char* inText )
-{
-	if ( FirstChild() && FirstChild()->ToText() )
-		FirstChild()->SetValue( inText );
-	else {
-		XMLText*	theText = GetDocument()->NewText( inText );
-		InsertFirstChild( theText );
-	}
-}
-
-
-void XMLElement::SetText( int v )
-{
-    char buf[BUF_SIZE];
-    XMLUtil::ToStr( v, buf, BUF_SIZE );
-    SetText( buf );
-}
-
-
-void XMLElement::SetText( unsigned v )
-{
-    char buf[BUF_SIZE];
-    XMLUtil::ToStr( v, buf, BUF_SIZE );
-    SetText( buf );
-}
-
-
-void XMLElement::SetText(int64_t v)
-{
-	char buf[BUF_SIZE];
-	XMLUtil::ToStr(v, buf, BUF_SIZE);
-	SetText(buf);
-}
-
-
-void XMLElement::SetText( bool v )
-{
-    char buf[BUF_SIZE];
-    XMLUtil::ToStr( v, buf, BUF_SIZE );
-    SetText( buf );
-}
-
-
-void XMLElement::SetText( float v )
-{
-    char buf[BUF_SIZE];
-    XMLUtil::ToStr( v, buf, BUF_SIZE );
-    SetText( buf );
-}
-
-
-void XMLElement::SetText( double v )
-{
-    char buf[BUF_SIZE];
-    XMLUtil::ToStr( v, buf, BUF_SIZE );
-    SetText( buf );
-}
-
-
-XMLError XMLElement::QueryIntText( int* ival ) const
-{
-    if ( FirstChild() && FirstChild()->ToText() ) {
-        const char* t = FirstChild()->Value();
-        if ( XMLUtil::ToInt( t, ival ) ) {
-            return XML_SUCCESS;
-        }
-        return XML_CAN_NOT_CONVERT_TEXT;
-    }
-    return XML_NO_TEXT_NODE;
-}
-
-
-XMLError XMLElement::QueryUnsignedText( unsigned* uval ) const
-{
-    if ( FirstChild() && FirstChild()->ToText() ) {
-        const char* t = FirstChild()->Value();
-        if ( XMLUtil::ToUnsigned( t, uval ) ) {
-            return XML_SUCCESS;
-        }
-        return XML_CAN_NOT_CONVERT_TEXT;
-    }
-    return XML_NO_TEXT_NODE;
-}
-
-
-XMLError XMLElement::QueryInt64Text(int64_t* ival) const
-{
-	if (FirstChild() && FirstChild()->ToText()) {
-		const char* t = FirstChild()->Value();
-		if (XMLUtil::ToInt64(t, ival)) {
-			return XML_SUCCESS;
-		}
-		return XML_CAN_NOT_CONVERT_TEXT;
-	}
-	return XML_NO_TEXT_NODE;
-}
-
-
-XMLError XMLElement::QueryBoolText( bool* bval ) const
-{
-    if ( FirstChild() && FirstChild()->ToText() ) {
-        const char* t = FirstChild()->Value();
-        if ( XMLUtil::ToBool( t, bval ) ) {
-            return XML_SUCCESS;
-        }
-        return XML_CAN_NOT_CONVERT_TEXT;
-    }
-    return XML_NO_TEXT_NODE;
-}
-
-
-XMLError XMLElement::QueryDoubleText( double* dval ) const
-{
-    if ( FirstChild() && FirstChild()->ToText() ) {
-        const char* t = FirstChild()->Value();
-        if ( XMLUtil::ToDouble( t, dval ) ) {
-            return XML_SUCCESS;
-        }
-        return XML_CAN_NOT_CONVERT_TEXT;
-    }
-    return XML_NO_TEXT_NODE;
-}
-
-
-XMLError XMLElement::QueryFloatText( float* fval ) const
-{
-    if ( FirstChild() && FirstChild()->ToText() ) {
-        const char* t = FirstChild()->Value();
-        if ( XMLUtil::ToFloat( t, fval ) ) {
-            return XML_SUCCESS;
-        }
-        return XML_CAN_NOT_CONVERT_TEXT;
-    }
-    return XML_NO_TEXT_NODE;
-}
-
-int XMLElement::IntText(int defaultValue) const
-{
-	int i = defaultValue;
-	QueryIntText(&i);
-	return i;
-}
-
-unsigned XMLElement::UnsignedText(unsigned defaultValue) const
-{
-	unsigned i = defaultValue;
-	QueryUnsignedText(&i);
-	return i;
-}
-
-int64_t XMLElement::Int64Text(int64_t defaultValue) const
-{
-	int64_t i = defaultValue;
-	QueryInt64Text(&i);
-	return i;
-}
-
-bool XMLElement::BoolText(bool defaultValue) const
-{
-	bool b = defaultValue;
-	QueryBoolText(&b);
-	return b;
-}
-
-double XMLElement::DoubleText(double defaultValue) const
-{
-	double d = defaultValue;
-	QueryDoubleText(&d);
-	return d;
-}
-
-float XMLElement::FloatText(float defaultValue) const
-{
-	float f = defaultValue;
-	QueryFloatText(&f);
-	return f;
-}
-
-
-XMLAttribute* XMLElement::FindOrCreateAttribute( const char* name )
-{
-    XMLAttribute* last = 0;
-    XMLAttribute* attrib = 0;
-    for( attrib = _rootAttribute;
-            attrib;
-            last = attrib, attrib = attrib->_next ) {
-        if ( XMLUtil::StringEqual( attrib->Name(), name ) ) {
-            break;
-        }
-    }
-    if ( !attrib ) {
-        attrib = CreateAttribute();
-        TIXMLASSERT( attrib );
-        if ( last ) {
-            TIXMLASSERT( last->_next == 0 );
-            last->_next = attrib;
-        }
-        else {
-            TIXMLASSERT( _rootAttribute == 0 );
-            _rootAttribute = attrib;
-        }
-        attrib->SetName( name );
-    }
-    return attrib;
-}
-
-
-void XMLElement::DeleteAttribute( const char* name )
-{
-    XMLAttribute* prev = 0;
-    for( XMLAttribute* a=_rootAttribute; a; a=a->_next ) {
-        if ( XMLUtil::StringEqual( name, a->Name() ) ) {
-            if ( prev ) {
-                prev->_next = a->_next;
-            }
-            else {
-                _rootAttribute = a->_next;
-            }
-            DeleteAttribute( a );
-            break;
-        }
-        prev = a;
-    }
-}
-
-
-char* XMLElement::ParseAttributes( char* p, int* curLineNumPtr )
-{
-    XMLAttribute* prevAttribute = 0;
-
-    // Read the attributes.
-    while( p ) {
-        p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
-        if ( !(*p) ) {
-            _document->SetError( XML_ERROR_PARSING_ELEMENT, _parseLineNum, "XMLElement name=%s", Name() );
-            return 0;
-        }
-
-        // attribute.
-        if (XMLUtil::IsNameStartChar( *p ) ) {
-            XMLAttribute* attrib = CreateAttribute();
-            TIXMLASSERT( attrib );
-            attrib->_parseLineNum = _document->_parseCurLineNum;
-
-            int attrLineNum = attrib->_parseLineNum;
-
-            p = attrib->ParseDeep( p, _document->ProcessEntities(), curLineNumPtr );
-            if ( !p || Attribute( attrib->Name() ) ) {
-                DeleteAttribute( attrib );
-                _document->SetError( XML_ERROR_PARSING_ATTRIBUTE, attrLineNum, "XMLElement name=%s", Name() );
-                return 0;
-            }
-            // There is a minor bug here: if the attribute in the source xml
-            // document is duplicated, it will not be detected and the
-            // attribute will be doubly added. However, tracking the 'prevAttribute'
-            // avoids re-scanning the attribute list. Preferring performance for
-            // now, may reconsider in the future.
-            if ( prevAttribute ) {
-                TIXMLASSERT( prevAttribute->_next == 0 );
-                prevAttribute->_next = attrib;
-            }
-            else {
-                TIXMLASSERT( _rootAttribute == 0 );
-                _rootAttribute = attrib;
-            }
-            prevAttribute = attrib;
-        }
-        // end of the tag
-        else if ( *p == '>' ) {
-            ++p;
-            break;
-        }
-        // end of the tag
-        else if ( *p == '/' && *(p+1) == '>' ) {
-            _closingType = CLOSED;
-            return p+2;	// done; sealed element.
-        }
-        else {
-            _document->SetError( XML_ERROR_PARSING_ELEMENT, _parseLineNum, 0 );
-            return 0;
-        }
-    }
-    return p;
-}
-
-void XMLElement::DeleteAttribute( XMLAttribute* attribute )
-{
-    if ( attribute == 0 ) {
-        return;
-    }
-    MemPool* pool = attribute->_memPool;
-    attribute->~XMLAttribute();
-    pool->Free( attribute );
-}
-
-XMLAttribute* XMLElement::CreateAttribute()
-{
-    TIXMLASSERT( sizeof( XMLAttribute ) == _document->_attributePool.ItemSize() );
-    XMLAttribute* attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();
-    TIXMLASSERT( attrib );
-    attrib->_memPool = &_document->_attributePool;
-    attrib->_memPool->SetTracked();
-    return attrib;
-}
-
-//
-//	<ele></ele>
-//	<ele>foo<b>bar</b></ele>
-//
-char* XMLElement::ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr )
-{
-    // Read the element name.
-    p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
-
-    // The closing element is the </element> form. It is
-    // parsed just like a regular element then deleted from
-    // the DOM.
-    if ( *p == '/' ) {
-        _closingType = CLOSING;
-        ++p;
-    }
-
-    p = _value.ParseName( p );
-    if ( _value.Empty() ) {
-        return 0;
-    }
-
-    p = ParseAttributes( p, curLineNumPtr );
-    if ( !p || !*p || _closingType != OPEN ) {
-        return p;
-    }
-
-    p = XMLNode::ParseDeep( p, parentEndTag, curLineNumPtr );
-    return p;
-}
-
-
-
-XMLNode* XMLElement::ShallowClone( XMLDocument* doc ) const
-{
-    if ( !doc ) {
-        doc = _document;
-    }
-    XMLElement* element = doc->NewElement( Value() );					// fixme: this will always allocate memory. Intern?
-    for( const XMLAttribute* a=FirstAttribute(); a; a=a->Next() ) {
-        element->SetAttribute( a->Name(), a->Value() );					// fixme: this will always allocate memory. Intern?
-    }
-    return element;
-}
-
-
-bool XMLElement::ShallowEqual( const XMLNode* compare ) const
-{
-    TIXMLASSERT( compare );
-    const XMLElement* other = compare->ToElement();
-    if ( other && XMLUtil::StringEqual( other->Name(), Name() )) {
-
-        const XMLAttribute* a=FirstAttribute();
-        const XMLAttribute* b=other->FirstAttribute();
-
-        while ( a && b ) {
-            if ( !XMLUtil::StringEqual( a->Value(), b->Value() ) ) {
-                return false;
-            }
-            a = a->Next();
-            b = b->Next();
-        }
-        if ( a || b ) {
-            // different count
-            return false;
-        }
-        return true;
-    }
-    return false;
-}
-
-
-bool XMLElement::Accept( XMLVisitor* visitor ) const
-{
-    TIXMLASSERT( visitor );
-    if ( visitor->VisitEnter( *this, _rootAttribute ) ) {
-        for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
-            if ( !node->Accept( visitor ) ) {
-                break;
-            }
-        }
-    }
-    return visitor->VisitExit( *this );
-}
-
-
-// --------- XMLDocument ----------- //
-
-// Warning: List must match 'enum XMLError'
-const char* XMLDocument::_errorNames[XML_ERROR_COUNT] = {
-    "XML_SUCCESS",
-    "XML_NO_ATTRIBUTE",
-    "XML_WRONG_ATTRIBUTE_TYPE",
-    "XML_ERROR_FILE_NOT_FOUND",
-    "XML_ERROR_FILE_COULD_NOT_BE_OPENED",
-    "XML_ERROR_FILE_READ_ERROR",
-    "UNUSED_XML_ERROR_ELEMENT_MISMATCH",
-    "XML_ERROR_PARSING_ELEMENT",
-    "XML_ERROR_PARSING_ATTRIBUTE",
-    "UNUSED_XML_ERROR_IDENTIFYING_TAG",
-    "XML_ERROR_PARSING_TEXT",
-    "XML_ERROR_PARSING_CDATA",
-    "XML_ERROR_PARSING_COMMENT",
-    "XML_ERROR_PARSING_DECLARATION",
-    "XML_ERROR_PARSING_UNKNOWN",
-    "XML_ERROR_EMPTY_DOCUMENT",
-    "XML_ERROR_MISMATCHED_ELEMENT",
-    "XML_ERROR_PARSING",
-    "XML_CAN_NOT_CONVERT_TEXT",
-    "XML_NO_TEXT_NODE"
-};
-
-
-XMLDocument::XMLDocument( bool processEntities, Whitespace whitespaceMode ) :
-    XMLNode( 0 ),
-    _writeBOM( false ),
-    _processEntities( processEntities ),
-    _errorID(XML_SUCCESS),
-    _whitespaceMode( whitespaceMode ),
-    _errorStr(),
-    _errorLineNum( 0 ),
-    _charBuffer( 0 ),
-    _parseCurLineNum( 0 ),
-    _unlinked(),
-    _elementPool(),
-    _attributePool(),
-    _textPool(),
-    _commentPool()
-{
-    // avoid VC++ C4355 warning about 'this' in initializer list (C4355 is off by default in VS2012+)
-    _document = this;
-}
-
-
-XMLDocument::~XMLDocument()
-{
-    Clear();
-}
-
-
-void XMLDocument::MarkInUse(XMLNode* node)
-{
-	TIXMLASSERT(node);
-	TIXMLASSERT(node->_parent == 0);
-
-	for (int i = 0; i < _unlinked.Size(); ++i) {
-		if (node == _unlinked[i]) {
-			_unlinked.SwapRemove(i);
-			break;
-		}
-	}
-}
-
-void XMLDocument::Clear()
-{
-    DeleteChildren();
-	while( _unlinked.Size()) {
-		DeleteNode(_unlinked[0]);	// Will remove from _unlinked as part of delete.
-	}
-
-#ifdef TINYXML2_DEBUG
-    const bool hadError = Error();
-#endif
-    ClearError();
-
-    delete [] _charBuffer;
-    _charBuffer = 0;
-
-#if 0
-    _textPool.Trace( "text" );
-    _elementPool.Trace( "element" );
-    _commentPool.Trace( "comment" );
-    _attributePool.Trace( "attribute" );
-#endif
-
-#ifdef TINYXML2_DEBUG
-    if ( !hadError ) {
-        TIXMLASSERT( _elementPool.CurrentAllocs()   == _elementPool.Untracked() );
-        TIXMLASSERT( _attributePool.CurrentAllocs() == _attributePool.Untracked() );
-        TIXMLASSERT( _textPool.CurrentAllocs()      == _textPool.Untracked() );
-        TIXMLASSERT( _commentPool.CurrentAllocs()   == _commentPool.Untracked() );
-    }
-#endif
-}
-
-
-void XMLDocument::DeepCopy(XMLDocument* target) const
-{
-	TIXMLASSERT(target);
-    if (target == this) {
-        return; // technically success - a no-op.
-    }
-
-	target->Clear();
-	for (const XMLNode* node = this->FirstChild(); node; node = node->NextSibling()) {
-		target->InsertEndChild(node->DeepClone(target));
-	}
-}
-
-XMLElement* XMLDocument::NewElement( const char* name )
-{
-    XMLElement* ele = CreateUnlinkedNode<XMLElement>( _elementPool );
-    ele->SetName( name );
-    return ele;
-}
-
-
-XMLComment* XMLDocument::NewComment( const char* str )
-{
-    XMLComment* comment = CreateUnlinkedNode<XMLComment>( _commentPool );
-    comment->SetValue( str );
-    return comment;
-}
-
-
-XMLText* XMLDocument::NewText( const char* str )
-{
-    XMLText* text = CreateUnlinkedNode<XMLText>( _textPool );
-    text->SetValue( str );
-    return text;
-}
-
-
-XMLDeclaration* XMLDocument::NewDeclaration( const char* str )
-{
-    XMLDeclaration* dec = CreateUnlinkedNode<XMLDeclaration>( _commentPool );
-    dec->SetValue( str ? str : "xml version=\"1.0\" encoding=\"UTF-8\"" );
-    return dec;
-}
-
-
-XMLUnknown* XMLDocument::NewUnknown( const char* str )
-{
-    XMLUnknown* unk = CreateUnlinkedNode<XMLUnknown>( _commentPool );
-    unk->SetValue( str );
-    return unk;
-}
-
-static FILE* callfopen( const char* filepath, const char* mode )
-{
-    TIXMLASSERT( filepath );
-    TIXMLASSERT( mode );
-#if defined(_MSC_VER) && (_MSC_VER >= 1400 ) && (!defined WINCE)
-    FILE* fp = 0;
-    errno_t err = fopen_s( &fp, filepath, mode );
-    if ( err ) {
-        return 0;
-    }
-#else
-    FILE* fp = fopen( filepath, mode );
-#endif
-    return fp;
-}
-
-void XMLDocument::DeleteNode( XMLNode* node )	{
-    TIXMLASSERT( node );
-    TIXMLASSERT(node->_document == this );
-    if (node->_parent) {
-        node->_parent->DeleteChild( node );
-    }
-    else {
-        // Isn't in the tree.
-        // Use the parent delete.
-        // Also, we need to mark it tracked: we 'know'
-        // it was never used.
-        node->_memPool->SetTracked();
-        // Call the static XMLNode version:
-        XMLNode::DeleteNode(node);
-    }
-}
-
-
-XMLError XMLDocument::LoadFile( const char* filename )
-{
-    if ( !filename ) {
-        TIXMLASSERT( false );
-        SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=<null>" );
-        return _errorID;
-    }
-
-    Clear();
-    FILE* fp = callfopen( filename, "rb" );
-    if ( !fp ) {
-        SetError( XML_ERROR_FILE_NOT_FOUND, 0, "filename=%s", filename );
-        return _errorID;
-    }
-    LoadFile( fp );
-    fclose( fp );
-    return _errorID;
-}
-
-// This is likely overengineered template art to have a check that unsigned long value incremented
-// by one still fits into size_t. If size_t type is larger than unsigned long type
-// (x86_64-w64-mingw32 target) then the check is redundant and gcc and clang emit
-// -Wtype-limits warning. This piece makes the compiler select code with a check when a check
-// is useful and code with no check when a check is redundant depending on how size_t and unsigned long
-// types sizes relate to each other.
-template
-<bool = (sizeof(unsigned long) >= sizeof(size_t))>
-struct LongFitsIntoSizeTMinusOne {
-    static bool Fits( unsigned long value )
-    {
-        return value < (size_t)-1;
-    }
-};
-
-template <>
-struct LongFitsIntoSizeTMinusOne<false> {
-    static bool Fits( unsigned long )
-    {
-        return true;
-    }
-};
-
-XMLError XMLDocument::LoadFile( FILE* fp )
-{
-    Clear();
-
-    fseek( fp, 0, SEEK_SET );
-    if ( fgetc( fp ) == EOF && ferror( fp ) != 0 ) {
-        SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
-        return _errorID;
-    }
-
-    fseek( fp, 0, SEEK_END );
-    const long filelength = ftell( fp );
-    fseek( fp, 0, SEEK_SET );
-    if ( filelength == -1L ) {
-        SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
-        return _errorID;
-    }
-    TIXMLASSERT( filelength >= 0 );
-
-    if ( !LongFitsIntoSizeTMinusOne<>::Fits( filelength ) ) {
-        // Cannot handle files which won't fit in buffer together with null terminator
-        SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
-        return _errorID;
-    }
-
-    if ( filelength == 0 ) {
-        SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
-        return _errorID;
-    }
-
-    const size_t size = filelength;
-    TIXMLASSERT( _charBuffer == 0 );
-    _charBuffer = new char[size+1];
-    size_t read = fread( _charBuffer, 1, size, fp );
-    if ( read != size ) {
-        SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
-        return _errorID;
-    }
-
-    _charBuffer[size] = 0;
-
-    Parse();
-    return _errorID;
-}
-
-
-XMLError XMLDocument::SaveFile( const char* filename, bool compact )
-{
-    if ( !filename ) {
-        TIXMLASSERT( false );
-        SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=<null>" );
-        return _errorID;
-    }
-
-    FILE* fp = callfopen( filename, "w" );
-    if ( !fp ) {
-        SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=%s", filename );
-        return _errorID;
-    }
-    SaveFile(fp, compact);
-    fclose( fp );
-    return _errorID;
-}
-
-
-XMLError XMLDocument::SaveFile( FILE* fp, bool compact )
-{
-    // Clear any error from the last save, otherwise it will get reported
-    // for *this* call.
-    ClearError();
-    XMLPrinter stream( fp, compact );
-    Print( &stream );
-    return _errorID;
-}
-
-
-XMLError XMLDocument::Parse( const char* p, size_t len )
-{
-    Clear();
-
-    if ( len == 0 || !p || !*p ) {
-        SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
-        return _errorID;
-    }
-    if ( len == (size_t)(-1) ) {
-        len = strlen( p );
-    }
-    TIXMLASSERT( _charBuffer == 0 );
-    _charBuffer = new char[ len+1 ];
-    memcpy( _charBuffer, p, len );
-    _charBuffer[len] = 0;
-
-    Parse();
-    if ( Error() ) {
-        // clean up now essentially dangling memory.
-        // and the parse fail can put objects in the
-        // pools that are dead and inaccessible.
-        DeleteChildren();
-        _elementPool.Clear();
-        _attributePool.Clear();
-        _textPool.Clear();
-        _commentPool.Clear();
-    }
-    return _errorID;
-}
-
-
-void XMLDocument::Print( XMLPrinter* streamer ) const
-{
-    if ( streamer ) {
-        Accept( streamer );
-    }
-    else {
-        XMLPrinter stdoutStreamer( stdout );
-        Accept( &stdoutStreamer );
-    }
-}
-
-
-void XMLDocument::SetError( XMLError error, int lineNum, const char* format, ... )
-{
-    TIXMLASSERT( error >= 0 && error < XML_ERROR_COUNT );
-    _errorID = error;
-    _errorLineNum = lineNum;
-	_errorStr.Reset();
-
-    size_t BUFFER_SIZE = 1000;
-    char* buffer = new char[BUFFER_SIZE];
-
-    TIXML_SNPRINTF(buffer, BUFFER_SIZE, "Error=%s ErrorID=%d (0x%x) Line number=%d", ErrorIDToName(error), int(error), int(error), lineNum);
-
-	if (format) {
-		size_t len = strlen(buffer);
-		TIXML_SNPRINTF(buffer + len, BUFFER_SIZE - len, ": ");
-		len = strlen(buffer);
-
-		va_list va;
-		va_start(va, format);
-		TIXML_VSNPRINTF(buffer + len, BUFFER_SIZE - len, format, va);
-		va_end(va);
-	}
-	_errorStr.SetStr(buffer);
-	delete[] buffer;
-}
-
-
-/*static*/ const char* XMLDocument::ErrorIDToName(XMLError errorID)
-{
-	TIXMLASSERT( errorID >= 0 && errorID < XML_ERROR_COUNT );
-    const char* errorName = _errorNames[errorID];
-    TIXMLASSERT( errorName && errorName[0] );
-    return errorName;
-}
-
-const char* XMLDocument::ErrorStr() const
-{
-	return _errorStr.Empty() ? "" : _errorStr.GetStr();
-}
-
-
-void XMLDocument::PrintError() const
-{
-    printf("%s\n", ErrorStr());
-}
-
-const char* XMLDocument::ErrorName() const
-{
-    return ErrorIDToName(_errorID);
-}
-
-void XMLDocument::Parse()
-{
-    TIXMLASSERT( NoChildren() ); // Clear() must have been called previously
-    TIXMLASSERT( _charBuffer );
-    _parseCurLineNum = 1;
-    _parseLineNum = 1;
-    char* p = _charBuffer;
-    p = XMLUtil::SkipWhiteSpace( p, &_parseCurLineNum );
-    p = const_cast<char*>( XMLUtil::ReadBOM( p, &_writeBOM ) );
-    if ( !*p ) {
-        SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
-        return;
-    }
-    ParseDeep(p, 0, &_parseCurLineNum );
-}
-
-XMLPrinter::XMLPrinter( FILE* file, bool compact, int depth ) :
-    _elementJustOpened( false ),
-    _stack(),
-    _firstElement( true ),
-    _fp( file ),
-    _depth( depth ),
-    _textDepth( -1 ),
-    _processEntities( true ),
-    _compactMode( compact ),
-    _buffer()
-{
-    for( int i=0; i<ENTITY_RANGE; ++i ) {
-        _entityFlag[i] = false;
-        _restrictedEntityFlag[i] = false;
-    }
-    for( int i=0; i<NUM_ENTITIES; ++i ) {
-        const char entityValue = entities[i].value;
-        const unsigned char flagIndex = (unsigned char)entityValue;
-        TIXMLASSERT( flagIndex < ENTITY_RANGE );
-        _entityFlag[flagIndex] = true;
-    }
-    _restrictedEntityFlag[(unsigned char)'&'] = true;
-    _restrictedEntityFlag[(unsigned char)'<'] = true;
-    _restrictedEntityFlag[(unsigned char)'>'] = true;	// not required, but consistency is nice
-    _buffer.Push( 0 );
-}
-
-
-void XMLPrinter::Print( const char* format, ... )
-{
-    va_list     va;
-    va_start( va, format );
-
-    if ( _fp ) {
-        vfprintf( _fp, format, va );
-    }
-    else {
-        const int len = TIXML_VSCPRINTF( format, va );
-        // Close out and re-start the va-args
-        va_end( va );
-        TIXMLASSERT( len >= 0 );
-        va_start( va, format );
-        TIXMLASSERT( _buffer.Size() > 0 && _buffer[_buffer.Size() - 1] == 0 );
-        char* p = _buffer.PushArr( len ) - 1;	// back up over the null terminator.
-		TIXML_VSNPRINTF( p, len+1, format, va );
-    }
-    va_end( va );
-}
-
-
-void XMLPrinter::Write( const char* data, size_t size )
-{
-    if ( _fp ) {
-        fwrite ( data , sizeof(char), size, _fp);
-    }
-    else {
-        char* p = _buffer.PushArr( static_cast<int>(size) ) - 1;   // back up over the null terminator.
-        memcpy( p, data, size );
-        p[size] = 0;
-    }
-}
-
-
-void XMLPrinter::Putc( char ch )
-{
-    if ( _fp ) {
-        fputc ( ch, _fp);
-    }
-    else {
-        char* p = _buffer.PushArr( sizeof(char) ) - 1;   // back up over the null terminator.
-        p[0] = ch;
-        p[1] = 0;
-    }
-}
-
-
-void XMLPrinter::PrintSpace( int depth )
-{
-    for( int i=0; i<depth; ++i ) {
-        Write( "    " );
-    }
-}
-
-
-void XMLPrinter::PrintString( const char* p, bool restricted )
-{
-    // Look for runs of bytes between entities to print.
-    const char* q = p;
-
-    if ( _processEntities ) {
-        const bool* flag = restricted ? _restrictedEntityFlag : _entityFlag;
-        while ( *q ) {
-            TIXMLASSERT( p <= q );
-            // Remember, char is sometimes signed. (How many times has that bitten me?)
-            if ( *q > 0 && *q < ENTITY_RANGE ) {
-                // Check for entities. If one is found, flush
-                // the stream up until the entity, write the
-                // entity, and keep looking.
-                if ( flag[(unsigned char)(*q)] ) {
-                    while ( p < q ) {
-                        const size_t delta = q - p;
-                        const int toPrint = ( INT_MAX < delta ) ? INT_MAX : (int)delta;
-                        Write( p, toPrint );
-                        p += toPrint;
-                    }
-                    bool entityPatternPrinted = false;
-                    for( int i=0; i<NUM_ENTITIES; ++i ) {
-                        if ( entities[i].value == *q ) {
-                            Putc( '&' );
-                            Write( entities[i].pattern, entities[i].length );
-                            Putc( ';' );
-                            entityPatternPrinted = true;
-                            break;
-                        }
-                    }
-                    if ( !entityPatternPrinted ) {
-                        // TIXMLASSERT( entityPatternPrinted ) causes gcc -Wunused-but-set-variable in release
-                        TIXMLASSERT( false );
-                    }
-                    ++p;
-                }
-            }
-            ++q;
-            TIXMLASSERT( p <= q );
-        }
-    }
-    // Flush the remaining string. This will be the entire
-    // string if an entity wasn't found.
-    TIXMLASSERT( p <= q );
-    if ( !_processEntities || ( p < q ) ) {
-        const size_t delta = q - p;
-        const int toPrint = ( INT_MAX < delta ) ? INT_MAX : (int)delta;
-        Write( p, toPrint );
-    }
-}
-
-
-void XMLPrinter::PushHeader( bool writeBOM, bool writeDec )
-{
-    if ( writeBOM ) {
-        static const unsigned char bom[] = { TIXML_UTF_LEAD_0, TIXML_UTF_LEAD_1, TIXML_UTF_LEAD_2, 0 };
-        Write( reinterpret_cast< const char* >( bom ) );
-    }
-    if ( writeDec ) {
-        PushDeclaration( "xml version=\"1.0\"" );
-    }
-}
-
-
-void XMLPrinter::OpenElement( const char* name, bool compactMode )
-{
-    SealElementIfJustOpened();
-    _stack.Push( name );
-
-    if ( _textDepth < 0 && !_firstElement && !compactMode ) {
-        Putc( '\n' );
-    }
-    if ( !compactMode ) {
-        PrintSpace( _depth );
-    }
-
-    Write ( "<" );
-    Write ( name );
-
-    _elementJustOpened = true;
-    _firstElement = false;
-    ++_depth;
-}
-
-
-void XMLPrinter::PushAttribute( const char* name, const char* value )
-{
-    TIXMLASSERT( _elementJustOpened );
-    Putc ( ' ' );
-    Write( name );
-    Write( "=\"" );
-    PrintString( value, false );
-    Putc ( '\"' );
-}
-
-
-void XMLPrinter::PushAttribute( const char* name, int v )
-{
-    char buf[BUF_SIZE];
-    XMLUtil::ToStr( v, buf, BUF_SIZE );
-    PushAttribute( name, buf );
-}
-
-
-void XMLPrinter::PushAttribute( const char* name, unsigned v )
-{
-    char buf[BUF_SIZE];
-    XMLUtil::ToStr( v, buf, BUF_SIZE );
-    PushAttribute( name, buf );
-}
-
-
-void XMLPrinter::PushAttribute(const char* name, int64_t v)
-{
-	char buf[BUF_SIZE];
-	XMLUtil::ToStr(v, buf, BUF_SIZE);
-	PushAttribute(name, buf);
-}
-
-
-void XMLPrinter::PushAttribute( const char* name, bool v )
-{
-    char buf[BUF_SIZE];
-    XMLUtil::ToStr( v, buf, BUF_SIZE );
-    PushAttribute( name, buf );
-}
-
-
-void XMLPrinter::PushAttribute( const char* name, double v )
-{
-    char buf[BUF_SIZE];
-    XMLUtil::ToStr( v, buf, BUF_SIZE );
-    PushAttribute( name, buf );
-}
-
-
-void XMLPrinter::CloseElement( bool compactMode )
-{
-    --_depth;
-    const char* name = _stack.Pop();
-
-    if ( _elementJustOpened ) {
-        Write( "/>" );
-    }
-    else {
-        if ( _textDepth < 0 && !compactMode) {
-            Putc( '\n' );
-            PrintSpace( _depth );
-        }
-        Write ( "</" );
-        Write ( name );
-        Write ( ">" );
-    }
-
-    if ( _textDepth == _depth ) {
-        _textDepth = -1;
-    }
-    if ( _depth == 0 && !compactMode) {
-        Putc( '\n' );
-    }
-    _elementJustOpened = false;
-}
-
-
-void XMLPrinter::SealElementIfJustOpened()
-{
-    if ( !_elementJustOpened ) {
-        return;
-    }
-    _elementJustOpened = false;
-    Putc( '>' );
-}
-
-
-void XMLPrinter::PushText( const char* text, bool cdata )
-{
-    _textDepth = _depth-1;
-
-    SealElementIfJustOpened();
-    if ( cdata ) {
-        Write( "<![CDATA[" );
-        Write( text );
-        Write( "]]>" );
-    }
-    else {
-        PrintString( text, true );
-    }
-}
-
-void XMLPrinter::PushText( int64_t value )
-{
-    char buf[BUF_SIZE];
-    XMLUtil::ToStr( value, buf, BUF_SIZE );
-    PushText( buf, false );
-}
-
-void XMLPrinter::PushText( int value )
-{
-    char buf[BUF_SIZE];
-    XMLUtil::ToStr( value, buf, BUF_SIZE );
-    PushText( buf, false );
-}
-
-
-void XMLPrinter::PushText( unsigned value )
-{
-    char buf[BUF_SIZE];
-    XMLUtil::ToStr( value, buf, BUF_SIZE );
-    PushText( buf, false );
-}
-
-
-void XMLPrinter::PushText( bool value )
-{
-    char buf[BUF_SIZE];
-    XMLUtil::ToStr( value, buf, BUF_SIZE );
-    PushText( buf, false );
-}
-
-
-void XMLPrinter::PushText( float value )
-{
-    char buf[BUF_SIZE];
-    XMLUtil::ToStr( value, buf, BUF_SIZE );
-    PushText( buf, false );
-}
-
-
-void XMLPrinter::PushText( double value )
-{
-    char buf[BUF_SIZE];
-    XMLUtil::ToStr( value, buf, BUF_SIZE );
-    PushText( buf, false );
-}
-
-
-void XMLPrinter::PushComment( const char* comment )
-{
-    SealElementIfJustOpened();
-    if ( _textDepth < 0 && !_firstElement && !_compactMode) {
-        Putc( '\n' );
-        PrintSpace( _depth );
-    }
-    _firstElement = false;
-
-    Write( "<!--" );
-    Write( comment );
-    Write( "-->" );
-}
-
-
-void XMLPrinter::PushDeclaration( const char* value )
-{
-    SealElementIfJustOpened();
-    if ( _textDepth < 0 && !_firstElement && !_compactMode) {
-        Putc( '\n' );
-        PrintSpace( _depth );
-    }
-    _firstElement = false;
-
-    Write( "<?" );
-    Write( value );
-    Write( "?>" );
-}
-
-
-void XMLPrinter::PushUnknown( const char* value )
-{
-    SealElementIfJustOpened();
-    if ( _textDepth < 0 && !_firstElement && !_compactMode) {
-        Putc( '\n' );
-        PrintSpace( _depth );
-    }
-    _firstElement = false;
-
-    Write( "<!" );
-    Write( value );
-    Putc( '>' );
-}
-
-
-bool XMLPrinter::VisitEnter( const XMLDocument& doc )
-{
-    _processEntities = doc.ProcessEntities();
-    if ( doc.HasBOM() ) {
-        PushHeader( true, false );
-    }
-    return true;
-}
-
-
-bool XMLPrinter::VisitEnter( const XMLElement& element, const XMLAttribute* attribute )
-{
-    const XMLElement* parentElem = 0;
-    if ( element.Parent() ) {
-        parentElem = element.Parent()->ToElement();
-    }
-    const bool compactMode = parentElem ? CompactMode( *parentElem ) : _compactMode;
-    OpenElement( element.Name(), compactMode );
-    while ( attribute ) {
-        PushAttribute( attribute->Name(), attribute->Value() );
-        attribute = attribute->Next();
-    }
-    return true;
-}
-
-
-bool XMLPrinter::VisitExit( const XMLElement& element )
-{
-    CloseElement( CompactMode(element) );
-    return true;
-}
-
-
-bool XMLPrinter::Visit( const XMLText& text )
-{
-    PushText( text.Value(), text.CData() );
-    return true;
-}
-
-
-bool XMLPrinter::Visit( const XMLComment& comment )
-{
-    PushComment( comment.Value() );
-    return true;
-}
-
-bool XMLPrinter::Visit( const XMLDeclaration& declaration )
-{
-    PushDeclaration( declaration.Value() );
-    return true;
-}
-
-
-bool XMLPrinter::Visit( const XMLUnknown& unknown )
-{
-    PushUnknown( unknown.Value() );
-    return true;
-}
-
-}   // namespace tinyxml2
+/*
+Original code by Lee Thomason (www.grinninglizard.com)
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any
+damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any
+purpose, including commercial applications, and to alter it and
+redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must
+not claim that you wrote the original software. If you use this
+software in a product, an acknowledgment in the product documentation
+would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and
+must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution.
+*/
+
+#include "tinyxml2.h"
+
+#include <new>		// yes, this one new style header, is in the Android SDK.
+#if defined(ANDROID_NDK) || defined(__BORLANDC__) || defined(__QNXNTO__) || defined(__CC_ARM)
+#   include <stddef.h>
+#   include <stdarg.h>
+#else
+#   include <cstddef>
+#   include <cstdarg>
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1400 ) && (!defined WINCE)
+	// Microsoft Visual Studio, version 2005 and higher. Not WinCE.
+	/*int _snprintf_s(
+	   char *buffer,
+	   size_t sizeOfBuffer,
+	   size_t count,
+	   const char *format [,
+		  argument] ...
+	);*/
+	static inline int TIXML_SNPRINTF( char* buffer, size_t size, const char* format, ... )
+	{
+		va_list va;
+		va_start( va, format );
+		const int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );
+		va_end( va );
+		return result;
+	}
+
+	static inline int TIXML_VSNPRINTF( char* buffer, size_t size, const char* format, va_list va )
+	{
+		const int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );
+		return result;
+	}
+
+	#define TIXML_VSCPRINTF	_vscprintf
+	#define TIXML_SSCANF	sscanf_s
+#elif defined _MSC_VER
+	// Microsoft Visual Studio 2003 and earlier or WinCE
+	#define TIXML_SNPRINTF	_snprintf
+	#define TIXML_VSNPRINTF _vsnprintf
+	#define TIXML_SSCANF	sscanf
+	#if (_MSC_VER < 1400 ) && (!defined WINCE)
+		// Microsoft Visual Studio 2003 and not WinCE.
+		#define TIXML_VSCPRINTF   _vscprintf // VS2003's C runtime has this, but VC6 C runtime or WinCE SDK doesn't have.
+	#else
+		// Microsoft Visual Studio 2003 and earlier or WinCE.
+		static inline int TIXML_VSCPRINTF( const char* format, va_list va )
+		{
+			int len = 512;
+			for (;;) {
+				len = len*2;
+				char* str = new char[len]();
+				const int required = _vsnprintf(str, len, format, va);
+				delete[] str;
+				if ( required != -1 ) {
+					TIXMLASSERT( required >= 0 );
+					len = required;
+					break;
+				}
+			}
+			TIXMLASSERT( len >= 0 );
+			return len;
+		}
+	#endif
+#else
+	// GCC version 3 and higher
+	//#warning( "Using sn* functions." )
+	#define TIXML_SNPRINTF	snprintf
+	#define TIXML_VSNPRINTF	vsnprintf
+	static inline int TIXML_VSCPRINTF( const char* format, va_list va )
+	{
+		int len = vsnprintf( 0, 0, format, va );
+		TIXMLASSERT( len >= 0 );
+		return len;
+	}
+	#define TIXML_SSCANF   sscanf
+#endif
+
+#if defined(_WIN64)
+	#define TIXML_FSEEK _fseeki64
+	#define TIXML_FTELL _ftelli64
+#elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__DragonFly__) || defined(__CYGWIN__)
+	#define TIXML_FSEEK fseeko
+	#define TIXML_FTELL ftello
+#elif defined(__ANDROID__) && __ANDROID_API__ > 24
+	#define TIXML_FSEEK fseeko64
+	#define TIXML_FTELL ftello64
+#else
+	#define TIXML_FSEEK fseek
+	#define TIXML_FTELL ftell
+#endif
+
+
+static const char LINE_FEED				= static_cast<char>(0x0a);			// all line endings are normalized to LF
+static const char LF = LINE_FEED;
+static const char CARRIAGE_RETURN		= static_cast<char>(0x0d);			// CR gets filtered out
+static const char CR = CARRIAGE_RETURN;
+static const char SINGLE_QUOTE			= '\'';
+static const char DOUBLE_QUOTE			= '\"';
+
+// Bunch of unicode info at:
+//		http://www.unicode.org/faq/utf_bom.html
+//	ef bb bf (Microsoft "lead bytes") - designates UTF-8
+
+static const unsigned char TIXML_UTF_LEAD_0 = 0xefU;
+static const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;
+static const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;
+
+namespace tinyxml2
+{
+
+struct Entity {
+    const char* pattern;
+    int length;
+    char value;
+};
+
+static const int NUM_ENTITIES = 5;
+static const Entity entities[NUM_ENTITIES] = {
+    { "quot", 4,	DOUBLE_QUOTE },
+    { "amp", 3,		'&'  },
+    { "apos", 4,	SINGLE_QUOTE },
+    { "lt",	2, 		'<'	 },
+    { "gt",	2,		'>'	 }
+};
+
+
+StrPair::~StrPair()
+{
+    Reset();
+}
+
+
+void StrPair::TransferTo( StrPair* other )
+{
+    if ( this == other ) {
+        return;
+    }
+    // This in effect implements the assignment operator by "moving"
+    // ownership (as in auto_ptr).
+
+    TIXMLASSERT( other != 0 );
+    TIXMLASSERT( other->_flags == 0 );
+    TIXMLASSERT( other->_start == 0 );
+    TIXMLASSERT( other->_end == 0 );
+
+    other->Reset();
+
+    other->_flags = _flags;
+    other->_start = _start;
+    other->_end = _end;
+
+    _flags = 0;
+    _start = 0;
+    _end = 0;
+}
+
+
+void StrPair::Reset()
+{
+    if ( _flags & NEEDS_DELETE ) {
+        delete [] _start;
+    }
+    _flags = 0;
+    _start = 0;
+    _end = 0;
+}
+
+
+void StrPair::SetStr( const char* str, int flags )
+{
+    TIXMLASSERT( str );
+    Reset();
+    size_t len = strlen( str );
+    TIXMLASSERT( _start == 0 );
+    _start = new char[ len+1 ];
+    memcpy( _start, str, len+1 );
+    _end = _start + len;
+    _flags = flags | NEEDS_DELETE;
+}
+
+
+char* StrPair::ParseText( char* p, const char* endTag, int strFlags, int* curLineNumPtr )
+{
+    TIXMLASSERT( p );
+    TIXMLASSERT( endTag && *endTag );
+	TIXMLASSERT(curLineNumPtr);
+
+    char* start = p;
+    const char  endChar = *endTag;
+    size_t length = strlen( endTag );
+
+    // Inner loop of text parsing.
+    while ( *p ) {
+        if ( *p == endChar && strncmp( p, endTag, length ) == 0 ) {
+            Set( start, p, strFlags );
+            return p + length;
+        } else if (*p == '\n') {
+            ++(*curLineNumPtr);
+        }
+        ++p;
+        TIXMLASSERT( p );
+    }
+    return 0;
+}
+
+
+char* StrPair::ParseName( char* p )
+{
+    if ( !p || !(*p) ) {
+        return 0;
+    }
+    if ( !XMLUtil::IsNameStartChar( static_cast<unsigned char>(*p) ) ) {
+        return 0;
+    }
+
+    char* const start = p;
+    ++p;
+    while ( *p && XMLUtil::IsNameChar( static_cast<unsigned char>(*p) ) ) {
+        ++p;
+    }
+
+    Set( start, p, 0 );
+    return p;
+}
+
+
+void StrPair::CollapseWhitespace()
+{
+    // Adjusting _start would cause undefined behavior on delete[]
+    TIXMLASSERT( ( _flags & NEEDS_DELETE ) == 0 );
+    // Trim leading space.
+    _start = XMLUtil::SkipWhiteSpace( _start, 0 );
+
+    if ( *_start ) {
+        const char* p = _start;	// the read pointer
+        char* q = _start;	// the write pointer
+
+        while( *p ) {
+            if ( XMLUtil::IsWhiteSpace( *p )) {
+                p = XMLUtil::SkipWhiteSpace( p, 0 );
+                if ( *p == 0 ) {
+                    break;    // don't write to q; this trims the trailing space.
+                }
+                *q = ' ';
+                ++q;
+            }
+            *q = *p;
+            ++q;
+            ++p;
+        }
+        *q = 0;
+    }
+}
+
+
+const char* StrPair::GetStr()
+{
+    TIXMLASSERT( _start );
+    TIXMLASSERT( _end );
+    if ( _flags & NEEDS_FLUSH ) {
+        *_end = 0;
+        _flags ^= NEEDS_FLUSH;
+
+        if ( _flags ) {
+            const char* p = _start;	// the read pointer
+            char* q = _start;	// the write pointer
+
+            while( p < _end ) {
+                if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == CR ) {
+                    // CR-LF pair becomes LF
+                    // CR alone becomes LF
+                    // LF-CR becomes LF
+                    if ( *(p+1) == LF ) {
+                        p += 2;
+                    }
+                    else {
+                        ++p;
+                    }
+                    *q = LF;
+                    ++q;
+                }
+                else if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == LF ) {
+                    if ( *(p+1) == CR ) {
+                        p += 2;
+                    }
+                    else {
+                        ++p;
+                    }
+                    *q = LF;
+                    ++q;
+                }
+                else if ( (_flags & NEEDS_ENTITY_PROCESSING) && *p == '&' ) {
+                    // Entities handled by tinyXML2:
+                    // - special entities in the entity table [in/out]
+                    // - numeric character reference [in]
+                    //   &#20013; or &#x4e2d;
+
+                    if ( *(p+1) == '#' ) {
+                        const int buflen = 10;
+                        char buf[buflen] = { 0 };
+                        int len = 0;
+                        const char* adjusted = const_cast<char*>( XMLUtil::GetCharacterRef( p, buf, &len ) );
+                        if ( adjusted == 0 ) {
+                            *q = *p;
+                            ++p;
+                            ++q;
+                        }
+                        else {
+                            TIXMLASSERT( 0 <= len && len <= buflen );
+                            TIXMLASSERT( q + len <= adjusted );
+                            p = adjusted;
+                            memcpy( q, buf, len );
+                            q += len;
+                        }
+                    }
+                    else {
+                        bool entityFound = false;
+                        for( int i = 0; i < NUM_ENTITIES; ++i ) {
+                            const Entity& entity = entities[i];
+                            if ( strncmp( p + 1, entity.pattern, entity.length ) == 0
+                                    && *( p + entity.length + 1 ) == ';' ) {
+                                // Found an entity - convert.
+                                *q = entity.value;
+                                ++q;
+                                p += entity.length + 2;
+                                entityFound = true;
+                                break;
+                            }
+                        }
+                        if ( !entityFound ) {
+                            // fixme: treat as error?
+                            ++p;
+                            ++q;
+                        }
+                    }
+                }
+                else {
+                    *q = *p;
+                    ++p;
+                    ++q;
+                }
+            }
+            *q = 0;
+        }
+        // The loop below has plenty going on, and this
+        // is a less useful mode. Break it out.
+        if ( _flags & NEEDS_WHITESPACE_COLLAPSING ) {
+            CollapseWhitespace();
+        }
+        _flags = (_flags & NEEDS_DELETE);
+    }
+    TIXMLASSERT( _start );
+    return _start;
+}
+
+
+
+
+// --------- XMLUtil ----------- //
+
+const char* XMLUtil::writeBoolTrue  = "true";
+const char* XMLUtil::writeBoolFalse = "false";
+
+void XMLUtil::SetBoolSerialization(const char* writeTrue, const char* writeFalse)
+{
+	static const char* defTrue  = "true";
+	static const char* defFalse = "false";
+
+	writeBoolTrue = (writeTrue) ? writeTrue : defTrue;
+	writeBoolFalse = (writeFalse) ? writeFalse : defFalse;
+}
+
+
+const char* XMLUtil::ReadBOM( const char* p, bool* bom )
+{
+    TIXMLASSERT( p );
+    TIXMLASSERT( bom );
+    *bom = false;
+    const unsigned char* pu = reinterpret_cast<const unsigned char*>(p);
+    // Check for BOM:
+    if (    *(pu+0) == TIXML_UTF_LEAD_0
+            && *(pu+1) == TIXML_UTF_LEAD_1
+            && *(pu+2) == TIXML_UTF_LEAD_2 ) {
+        *bom = true;
+        p += 3;
+    }
+    TIXMLASSERT( p );
+    return p;
+}
+
+
+void XMLUtil::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length )
+{
+    const unsigned long BYTE_MASK = 0xBF;
+    const unsigned long BYTE_MARK = 0x80;
+    const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
+
+    if (input < 0x80) {
+        *length = 1;
+    }
+    else if ( input < 0x800 ) {
+        *length = 2;
+    }
+    else if ( input < 0x10000 ) {
+        *length = 3;
+    }
+    else if ( input < 0x200000 ) {
+        *length = 4;
+    }
+    else {
+        *length = 0;    // This code won't convert this correctly anyway.
+        return;
+    }
+
+    output += *length;
+
+    // Scary scary fall throughs are annotated with carefully designed comments
+    // to suppress compiler warnings such as -Wimplicit-fallthrough in gcc
+    switch (*length) {
+        case 4:
+            --output;
+            *output = static_cast<char>((input | BYTE_MARK) & BYTE_MASK);
+            input >>= 6;
+            //fall through
+        case 3:
+            --output;
+            *output = static_cast<char>((input | BYTE_MARK) & BYTE_MASK);
+            input >>= 6;
+            //fall through
+        case 2:
+            --output;
+            *output = static_cast<char>((input | BYTE_MARK) & BYTE_MASK);
+            input >>= 6;
+            //fall through
+        case 1:
+            --output;
+            *output = static_cast<char>(input | FIRST_BYTE_MARK[*length]);
+            break;
+        default:
+            TIXMLASSERT( false );
+    }
+}
+
+
+const char* XMLUtil::GetCharacterRef(const char* p, char* value, int* length)
+{
+    // Assume an entity, and pull it out.
+    *length = 0;
+
+    static const uint32_t MAX_CODE_POINT = 0x10FFFF;
+
+    if (*(p + 1) == '#' && *(p + 2)) {
+        uint32_t ucs = 0;
+        ptrdiff_t delta = 0;
+        uint32_t mult = 1;
+        static const char SEMICOLON = ';';
+
+        bool hex = false;
+        uint32_t radix = 10;
+        const char* q = 0;
+        char terminator = '#';
+
+        if (*(p + 2) == 'x') {
+            // Hexadecimal.
+            hex = true;
+            radix = 16;
+            terminator = 'x';
+
+            q = p + 3;
+        }
+        else {
+            // Decimal.
+            q = p + 2;
+        }
+        if (!(*q)) {
+            return 0;
+        }
+
+        q = strchr(q, SEMICOLON);
+        if (!q) {
+            return 0;
+        }
+        TIXMLASSERT(*q == SEMICOLON);
+
+        delta = q - p;
+        --q;
+
+        while (*q != terminator) {
+            uint32_t digit = 0;
+
+            if (*q >= '0' && *q <= '9') {
+                digit = *q - '0';
+            }
+            else if (hex && (*q >= 'a' && *q <= 'f')) {
+                digit = *q - 'a' + 10;
+            }
+            else if (hex && (*q >= 'A' && *q <= 'F')) {
+                digit = *q - 'A' + 10;
+            }
+            else {
+                return 0;
+            }
+            TIXMLASSERT(digit < radix);
+
+            const unsigned int digitScaled = mult * digit;
+            ucs += digitScaled;
+            mult *= radix;       
+            
+            // Security check: could a value exist that is out of range?
+            // Easily; limit to the MAX_CODE_POINT, which also allows for a
+            // bunch of leading zeroes.
+            if (mult > MAX_CODE_POINT) {
+                mult = MAX_CODE_POINT;
+            }
+            --q;
+        }
+        // Out of range:
+        if (ucs > MAX_CODE_POINT) {
+            return 0;
+        }
+        // convert the UCS to UTF-8
+        ConvertUTF32ToUTF8(ucs, value, length);
+		if (length == 0) {
+            // If length is 0, there was an error. (Security? Bad input?)
+            // Fail safely.
+			return 0;
+		}
+        return p + delta + 1;
+    }
+    return p + 1;
+}
+
+void XMLUtil::ToStr( int v, char* buffer, int bufferSize )
+{
+    TIXML_SNPRINTF( buffer, bufferSize, "%d", v );
+}
+
+
+void XMLUtil::ToStr( unsigned v, char* buffer, int bufferSize )
+{
+    TIXML_SNPRINTF( buffer, bufferSize, "%u", v );
+}
+
+
+void XMLUtil::ToStr( bool v, char* buffer, int bufferSize )
+{
+    TIXML_SNPRINTF( buffer, bufferSize, "%s", v ? writeBoolTrue : writeBoolFalse);
+}
+
+/*
+	ToStr() of a number is a very tricky topic.
+	https://github.com/leethomason/tinyxml2/issues/106
+*/
+void XMLUtil::ToStr( float v, char* buffer, int bufferSize )
+{
+    TIXML_SNPRINTF( buffer, bufferSize, "%.8g", v );
+}
+
+
+void XMLUtil::ToStr( double v, char* buffer, int bufferSize )
+{
+    TIXML_SNPRINTF( buffer, bufferSize, "%.17g", v );
+}
+
+
+void XMLUtil::ToStr( int64_t v, char* buffer, int bufferSize )
+{
+	// horrible syntax trick to make the compiler happy about %lld
+	TIXML_SNPRINTF(buffer, bufferSize, "%lld", static_cast<long long>(v));
+}
+
+void XMLUtil::ToStr( uint64_t v, char* buffer, int bufferSize )
+{
+    // horrible syntax trick to make the compiler happy about %llu
+    TIXML_SNPRINTF(buffer, bufferSize, "%llu", static_cast<unsigned long long>(v));
+}
+
+bool XMLUtil::ToInt(const char* str, int* value)
+{
+    if (IsPrefixHex(str)) {
+        unsigned v;
+        if (TIXML_SSCANF(str, "%x", &v) == 1) {
+            *value = static_cast<int>(v);
+            return true;
+        }
+    }
+    else {
+        if (TIXML_SSCANF(str, "%d", value) == 1) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool XMLUtil::ToUnsigned(const char* str, unsigned* value)
+{
+    if (TIXML_SSCANF(str, IsPrefixHex(str) ? "%x" : "%u", value) == 1) {
+        return true;
+    }
+    return false;
+}
+
+bool XMLUtil::ToBool( const char* str, bool* value )
+{
+    int ival = 0;
+    if ( ToInt( str, &ival )) {
+        *value = (ival==0) ? false : true;
+        return true;
+    }
+    static const char* TRUE_VALS[] = { "true", "True", "TRUE", 0 };
+    static const char* FALSE_VALS[] = { "false", "False", "FALSE", 0 };
+
+    for (int i = 0; TRUE_VALS[i]; ++i) {
+        if (StringEqual(str, TRUE_VALS[i])) {
+            *value = true;
+            return true;
+        }
+    }
+    for (int i = 0; FALSE_VALS[i]; ++i) {
+        if (StringEqual(str, FALSE_VALS[i])) {
+            *value = false;
+            return true;
+        }
+    }
+    return false;
+}
+
+
+bool XMLUtil::ToFloat( const char* str, float* value )
+{
+    if ( TIXML_SSCANF( str, "%f", value ) == 1 ) {
+        return true;
+    }
+    return false;
+}
+
+
+bool XMLUtil::ToDouble( const char* str, double* value )
+{
+    if ( TIXML_SSCANF( str, "%lf", value ) == 1 ) {
+        return true;
+    }
+    return false;
+}
+
+
+bool XMLUtil::ToInt64(const char* str, int64_t* value)
+{
+    if (IsPrefixHex(str)) {
+        unsigned long long v = 0;	// horrible syntax trick to make the compiler happy about %llx
+        if (TIXML_SSCANF(str, "%llx", &v) == 1) {
+            *value = static_cast<int64_t>(v);
+            return true;
+        }
+    }
+    else {
+        long long v = 0;	// horrible syntax trick to make the compiler happy about %lld
+        if (TIXML_SSCANF(str, "%lld", &v) == 1) {
+            *value = static_cast<int64_t>(v);
+            return true;
+        }
+    }
+	return false;
+}
+
+
+bool XMLUtil::ToUnsigned64(const char* str, uint64_t* value) {
+    unsigned long long v = 0;	// horrible syntax trick to make the compiler happy about %llu
+    if(TIXML_SSCANF(str, IsPrefixHex(str) ? "%llx" : "%llu", &v) == 1) {
+        *value = static_cast<uint64_t>(v);
+        return true;
+    }
+    return false;
+}
+
+
+char* XMLDocument::Identify( char* p, XMLNode** node, bool first )
+{
+    TIXMLASSERT( node );
+    TIXMLASSERT( p );
+    char* const start = p;
+    int const startLine = _parseCurLineNum;
+    p = XMLUtil::SkipWhiteSpace( p, &_parseCurLineNum );
+    if( !*p ) {
+        *node = 0;
+        TIXMLASSERT( p );
+        return p;
+    }
+
+    // These strings define the matching patterns:
+    static const char* xmlHeader		= { "<?" };
+    static const char* commentHeader	= { "<!--" };
+    static const char* cdataHeader		= { "<![CDATA[" };
+    static const char* dtdHeader		= { "<!" };
+    static const char* elementHeader	= { "<" };	// and a header for everything else; check last.
+
+    static const int xmlHeaderLen		= 2;
+    static const int commentHeaderLen	= 4;
+    static const int cdataHeaderLen		= 9;
+    static const int dtdHeaderLen		= 2;
+    static const int elementHeaderLen	= 1;
+
+    TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLUnknown ) );		// use same memory pool
+    TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLDeclaration ) );	// use same memory pool
+    XMLNode* returnNode = 0;
+    if ( XMLUtil::StringEqual( p, xmlHeader, xmlHeaderLen ) ) {
+        returnNode = CreateUnlinkedNode<XMLDeclaration>( _commentPool );
+        returnNode->_parseLineNum = _parseCurLineNum;
+        p += xmlHeaderLen;
+    }
+    else if ( XMLUtil::StringEqual( p, commentHeader, commentHeaderLen ) ) {
+        returnNode = CreateUnlinkedNode<XMLComment>( _commentPool );
+        returnNode->_parseLineNum = _parseCurLineNum;
+        p += commentHeaderLen;
+    }
+    else if ( XMLUtil::StringEqual( p, cdataHeader, cdataHeaderLen ) ) {
+        XMLText* text = CreateUnlinkedNode<XMLText>( _textPool );
+        returnNode = text;
+        returnNode->_parseLineNum = _parseCurLineNum;
+        p += cdataHeaderLen;
+        text->SetCData( true );
+    }
+    else if ( XMLUtil::StringEqual( p, dtdHeader, dtdHeaderLen ) ) {
+        returnNode = CreateUnlinkedNode<XMLUnknown>( _commentPool );
+        returnNode->_parseLineNum = _parseCurLineNum;
+        p += dtdHeaderLen;
+    }
+    else if ( XMLUtil::StringEqual( p, elementHeader, elementHeaderLen ) ) {
+
+        // Preserve whitespace pedantically before closing tag, when it's immediately after opening tag
+        if (WhitespaceMode() == PEDANTIC_WHITESPACE && first && p != start && *(p + elementHeaderLen) == '/') {
+            returnNode = CreateUnlinkedNode<XMLText>(_textPool);
+            returnNode->_parseLineNum = startLine;
+            p = start;	// Back it up, all the text counts.
+            _parseCurLineNum = startLine;
+        }
+        else {
+            returnNode = CreateUnlinkedNode<XMLElement>(_elementPool);
+            returnNode->_parseLineNum = _parseCurLineNum;
+            p += elementHeaderLen;
+        }
+    }
+    else {
+        returnNode = CreateUnlinkedNode<XMLText>( _textPool );
+        returnNode->_parseLineNum = _parseCurLineNum; // Report line of first non-whitespace character
+        p = start;	// Back it up, all the text counts.
+        _parseCurLineNum = startLine;
+    }
+
+    TIXMLASSERT( returnNode );
+    TIXMLASSERT( p );
+    *node = returnNode;
+    return p;
+}
+
+
+bool XMLDocument::Accept( XMLVisitor* visitor ) const
+{
+    TIXMLASSERT( visitor );
+    if ( visitor->VisitEnter( *this ) ) {
+        for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
+            if ( !node->Accept( visitor ) ) {
+                break;
+            }
+        }
+    }
+    return visitor->VisitExit( *this );
+}
+
+
+// --------- XMLNode ----------- //
+
+XMLNode::XMLNode( XMLDocument* doc ) :
+    _document( doc ),
+    _parent( 0 ),
+    _value(),
+    _parseLineNum( 0 ),
+    _firstChild( 0 ), _lastChild( 0 ),
+    _prev( 0 ), _next( 0 ),
+	_userData( 0 ),
+    _memPool( 0 )
+{
+}
+
+
+XMLNode::~XMLNode()
+{
+    DeleteChildren();
+    if ( _parent ) {
+        _parent->Unlink( this );
+    }
+}
+
+// ChildElementCount was originally suggested by msteiger on the sourceforge page for TinyXML and modified by KB1SPH for TinyXML-2.
+
+int XMLNode::ChildElementCount(const char *value) const {
+	int count = 0;
+
+	const XMLElement *e = FirstChildElement(value);
+
+	while (e) {
+		e = e->NextSiblingElement(value);
+		count++;
+	}
+
+	return count;
+}
+
+int XMLNode::ChildElementCount() const {
+	int count = 0;
+
+	const XMLElement *e = FirstChildElement();
+
+	while (e) {
+		e = e->NextSiblingElement();
+		count++;
+	}
+
+	return count;
+}
+
+const char* XMLNode::Value() const
+{
+    // Edge case: XMLDocuments don't have a Value. Return null.
+    if ( this->ToDocument() )
+        return 0;
+    return _value.GetStr();
+}
+
+void XMLNode::SetValue( const char* str, bool staticMem )
+{
+    if ( staticMem ) {
+        _value.SetInternedStr( str );
+    }
+    else {
+        _value.SetStr( str );
+    }
+}
+
+XMLNode* XMLNode::DeepClone(XMLDocument* target) const
+{
+	XMLNode* clone = this->ShallowClone(target);
+	if (!clone) return 0;
+
+	for (const XMLNode* child = this->FirstChild(); child; child = child->NextSibling()) {
+		XMLNode* childClone = child->DeepClone(target);
+		TIXMLASSERT(childClone);
+		clone->InsertEndChild(childClone);
+	}
+	return clone;
+}
+
+void XMLNode::DeleteChildren()
+{
+    while( _firstChild ) {
+        TIXMLASSERT( _lastChild );
+        DeleteChild( _firstChild );
+    }
+    _firstChild = _lastChild = 0;
+}
+
+
+void XMLNode::Unlink( XMLNode* child )
+{
+    TIXMLASSERT( child );
+    TIXMLASSERT( child->_document == _document );
+    TIXMLASSERT( child->_parent == this );
+    if ( child == _firstChild ) {
+        _firstChild = _firstChild->_next;
+    }
+    if ( child == _lastChild ) {
+        _lastChild = _lastChild->_prev;
+    }
+
+    if ( child->_prev ) {
+        child->_prev->_next = child->_next;
+    }
+    if ( child->_next ) {
+        child->_next->_prev = child->_prev;
+    }
+	child->_next = 0;
+	child->_prev = 0;
+	child->_parent = 0;
+}
+
+
+void XMLNode::DeleteChild( XMLNode* node )
+{
+    TIXMLASSERT( node );
+    TIXMLASSERT( node->_document == _document );
+    TIXMLASSERT( node->_parent == this );
+    Unlink( node );
+	TIXMLASSERT(node->_prev == 0);
+	TIXMLASSERT(node->_next == 0);
+	TIXMLASSERT(node->_parent == 0);
+    DeleteNode( node );
+}
+
+
+XMLNode* XMLNode::InsertEndChild( XMLNode* addThis )
+{
+    TIXMLASSERT( addThis );
+    if ( addThis->_document != _document ) {
+        TIXMLASSERT( false );
+        return 0;
+    }
+    InsertChildPreamble( addThis );
+
+    if ( _lastChild ) {
+        TIXMLASSERT( _firstChild );
+        TIXMLASSERT( _lastChild->_next == 0 );
+        _lastChild->_next = addThis;
+        addThis->_prev = _lastChild;
+        _lastChild = addThis;
+
+        addThis->_next = 0;
+    }
+    else {
+        TIXMLASSERT( _firstChild == 0 );
+        _firstChild = _lastChild = addThis;
+
+        addThis->_prev = 0;
+        addThis->_next = 0;
+    }
+    addThis->_parent = this;
+    return addThis;
+}
+
+
+XMLNode* XMLNode::InsertFirstChild( XMLNode* addThis )
+{
+    TIXMLASSERT( addThis );
+    if ( addThis->_document != _document ) {
+        TIXMLASSERT( false );
+        return 0;
+    }
+    InsertChildPreamble( addThis );
+
+    if ( _firstChild ) {
+        TIXMLASSERT( _lastChild );
+        TIXMLASSERT( _firstChild->_prev == 0 );
+
+        _firstChild->_prev = addThis;
+        addThis->_next = _firstChild;
+        _firstChild = addThis;
+
+        addThis->_prev = 0;
+    }
+    else {
+        TIXMLASSERT( _lastChild == 0 );
+        _firstChild = _lastChild = addThis;
+
+        addThis->_prev = 0;
+        addThis->_next = 0;
+    }
+    addThis->_parent = this;
+    return addThis;
+}
+
+
+XMLNode* XMLNode::InsertAfterChild( XMLNode* afterThis, XMLNode* addThis )
+{
+    TIXMLASSERT( addThis );
+    if ( addThis->_document != _document ) {
+        TIXMLASSERT( false );
+        return 0;
+    }
+
+    TIXMLASSERT( afterThis );
+
+    if ( afterThis->_parent != this ) {
+        TIXMLASSERT( false );
+        return 0;
+    }
+    if ( afterThis == addThis ) {
+        // Current state: BeforeThis -> AddThis -> OneAfterAddThis
+        // Now AddThis must disappear from it's location and then
+        // reappear between BeforeThis and OneAfterAddThis.
+        // So just leave it where it is.
+        return addThis;
+    }
+
+    if ( afterThis->_next == 0 ) {
+        // The last node or the only node.
+        return InsertEndChild( addThis );
+    }
+    InsertChildPreamble( addThis );
+    addThis->_prev = afterThis;
+    addThis->_next = afterThis->_next;
+    afterThis->_next->_prev = addThis;
+    afterThis->_next = addThis;
+    addThis->_parent = this;
+    return addThis;
+}
+
+
+
+
+const XMLElement* XMLNode::FirstChildElement( const char* name ) const
+{
+    for( const XMLNode* node = _firstChild; node; node = node->_next ) {
+        const XMLElement* element = node->ToElementWithName( name );
+        if ( element ) {
+            return element;
+        }
+    }
+    return 0;
+}
+
+
+const XMLElement* XMLNode::LastChildElement( const char* name ) const
+{
+    for( const XMLNode* node = _lastChild; node; node = node->_prev ) {
+        const XMLElement* element = node->ToElementWithName( name );
+        if ( element ) {
+            return element;
+        }
+    }
+    return 0;
+}
+
+
+const XMLElement* XMLNode::NextSiblingElement( const char* name ) const
+{
+    for( const XMLNode* node = _next; node; node = node->_next ) {
+        const XMLElement* element = node->ToElementWithName( name );
+        if ( element ) {
+            return element;
+        }
+    }
+    return 0;
+}
+
+
+const XMLElement* XMLNode::PreviousSiblingElement( const char* name ) const
+{
+    for( const XMLNode* node = _prev; node; node = node->_prev ) {
+        const XMLElement* element = node->ToElementWithName( name );
+        if ( element ) {
+            return element;
+        }
+    }
+    return 0;
+}
+
+
+char* XMLNode::ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr )
+{
+    // This is a recursive method, but thinking about it "at the current level"
+    // it is a pretty simple flat list:
+    //		<foo/>
+    //		<!-- comment -->
+    //
+    // With a special case:
+    //		<foo>
+    //		</foo>
+    //		<!-- comment -->
+    //
+    // Where the closing element (/foo) *must* be the next thing after the opening
+    // element, and the names must match. BUT the tricky bit is that the closing
+    // element will be read by the child.
+    //
+    // 'endTag' is the end tag for this node, it is returned by a call to a child.
+    // 'parentEnd' is the end tag for the parent, which is filled in and returned.
+
+	XMLDocument::DepthTracker tracker(_document);
+	if (_document->Error())
+		return 0;
+
+	bool first = true;
+	while( p && *p ) {
+        XMLNode* node = 0;
+
+        p = _document->Identify( p, &node, first );
+        TIXMLASSERT( p );
+        if ( node == 0 ) {
+            break;
+        }
+        first = false;
+
+       const int initialLineNum = node->_parseLineNum;
+
+        StrPair endTag;
+        p = node->ParseDeep( p, &endTag, curLineNumPtr );
+        if ( !p ) {
+            _document->DeleteNode( node );
+            if ( !_document->Error() ) {
+                _document->SetError( XML_ERROR_PARSING, initialLineNum, 0);
+            }
+            break;
+        }
+
+        const XMLDeclaration* const decl = node->ToDeclaration();
+        if ( decl ) {
+            // Declarations are only allowed at document level
+            //
+            // Multiple declarations are allowed but all declarations
+            // must occur before anything else. 
+            //
+            // Optimized due to a security test case. If the first node is 
+            // a declaration, and the last node is a declaration, then only 
+            // declarations have so far been added.
+            bool wellLocated = false;
+
+            if (ToDocument()) {
+                if (FirstChild()) {
+                    wellLocated =
+                        FirstChild() &&
+                        FirstChild()->ToDeclaration() &&
+                        LastChild() &&
+                        LastChild()->ToDeclaration();
+                }
+                else {
+                    wellLocated = true;
+                }
+            }
+            if ( !wellLocated ) {
+                _document->SetError( XML_ERROR_PARSING_DECLARATION, initialLineNum, "XMLDeclaration value=%s", decl->Value());
+                _document->DeleteNode( node );
+                break;
+            }
+        }
+
+        XMLElement* ele = node->ToElement();
+        if ( ele ) {
+            // We read the end tag. Return it to the parent.
+            if ( ele->ClosingType() == XMLElement::CLOSING ) {
+                if ( parentEndTag ) {
+                    ele->_value.TransferTo( parentEndTag );
+                }
+                node->_memPool->SetTracked();   // created and then immediately deleted.
+                DeleteNode( node );
+                return p;
+            }
+
+            // Handle an end tag returned to this level.
+            // And handle a bunch of annoying errors.
+            bool mismatch = false;
+            if ( endTag.Empty() ) {
+                if ( ele->ClosingType() == XMLElement::OPEN ) {
+                    mismatch = true;
+                }
+            }
+            else {
+                if ( ele->ClosingType() != XMLElement::OPEN ) {
+                    mismatch = true;
+                }
+                else if ( !XMLUtil::StringEqual( endTag.GetStr(), ele->Name() ) ) {
+                    mismatch = true;
+                }
+            }
+            if ( mismatch ) {
+                _document->SetError( XML_ERROR_MISMATCHED_ELEMENT, initialLineNum, "XMLElement name=%s", ele->Name());
+                _document->DeleteNode( node );
+                break;
+            }
+        }
+        InsertEndChild( node );
+    }
+    return 0;
+}
+
+/*static*/ void XMLNode::DeleteNode( XMLNode* node )
+{
+    if ( node == 0 ) {
+        return;
+    }
+	TIXMLASSERT(node->_document);
+	if (!node->ToDocument()) {
+		node->_document->MarkInUse(node);
+	}
+
+    MemPool* pool = node->_memPool;
+    node->~XMLNode();
+    pool->Free( node );
+}
+
+void XMLNode::InsertChildPreamble( XMLNode* insertThis ) const
+{
+    TIXMLASSERT( insertThis );
+    TIXMLASSERT( insertThis->_document == _document );
+
+	if (insertThis->_parent) {
+        insertThis->_parent->Unlink( insertThis );
+	}
+	else {
+		insertThis->_document->MarkInUse(insertThis);
+        insertThis->_memPool->SetTracked();
+	}
+}
+
+const XMLElement* XMLNode::ToElementWithName( const char* name ) const
+{
+    const XMLElement* element = this->ToElement();
+    if ( element == 0 ) {
+        return 0;
+    }
+    if ( name == 0 ) {
+        return element;
+    }
+    if ( XMLUtil::StringEqual( element->Name(), name ) ) {
+       return element;
+    }
+    return 0;
+}
+
+// --------- XMLText ---------- //
+char* XMLText::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
+{
+    if ( this->CData() ) {
+        p = _value.ParseText( p, "]]>", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr );
+        if ( !p ) {
+            _document->SetError( XML_ERROR_PARSING_CDATA, _parseLineNum, 0 );
+        }
+        return p;
+    }
+    else {
+        int flags = _document->ProcessEntities() ? StrPair::TEXT_ELEMENT : StrPair::TEXT_ELEMENT_LEAVE_ENTITIES;
+        if ( _document->WhitespaceMode() == COLLAPSE_WHITESPACE ) {
+            flags |= StrPair::NEEDS_WHITESPACE_COLLAPSING;
+        }
+
+        p = _value.ParseText( p, "<", flags, curLineNumPtr );
+        if ( p && *p ) {
+            return p-1;
+        }
+        if ( !p ) {
+            _document->SetError( XML_ERROR_PARSING_TEXT, _parseLineNum, 0 );
+        }
+    }
+    return 0;
+}
+
+
+XMLNode* XMLText::ShallowClone( XMLDocument* doc ) const
+{
+    if ( !doc ) {
+        doc = _document;
+    }
+    XMLText* text = doc->NewText( Value() );	// fixme: this will always allocate memory. Intern?
+    text->SetCData( this->CData() );
+    return text;
+}
+
+
+bool XMLText::ShallowEqual( const XMLNode* compare ) const
+{
+    TIXMLASSERT( compare );
+    const XMLText* text = compare->ToText();
+    return ( text && XMLUtil::StringEqual( text->Value(), Value() ) );
+}
+
+
+bool XMLText::Accept( XMLVisitor* visitor ) const
+{
+    TIXMLASSERT( visitor );
+    return visitor->Visit( *this );
+}
+
+
+// --------- XMLComment ---------- //
+
+XMLComment::XMLComment( XMLDocument* doc ) : XMLNode( doc )
+{
+}
+
+
+XMLComment::~XMLComment()
+{
+}
+
+
+char* XMLComment::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
+{
+    // Comment parses as text.
+    p = _value.ParseText( p, "-->", StrPair::COMMENT, curLineNumPtr );
+    if ( p == 0 ) {
+        _document->SetError( XML_ERROR_PARSING_COMMENT, _parseLineNum, 0 );
+    }
+    return p;
+}
+
+
+XMLNode* XMLComment::ShallowClone( XMLDocument* doc ) const
+{
+    if ( !doc ) {
+        doc = _document;
+    }
+    XMLComment* comment = doc->NewComment( Value() );	// fixme: this will always allocate memory. Intern?
+    return comment;
+}
+
+
+bool XMLComment::ShallowEqual( const XMLNode* compare ) const
+{
+    TIXMLASSERT( compare );
+    const XMLComment* comment = compare->ToComment();
+    return ( comment && XMLUtil::StringEqual( comment->Value(), Value() ));
+}
+
+
+bool XMLComment::Accept( XMLVisitor* visitor ) const
+{
+    TIXMLASSERT( visitor );
+    return visitor->Visit( *this );
+}
+
+
+// --------- XMLDeclaration ---------- //
+
+XMLDeclaration::XMLDeclaration( XMLDocument* doc ) : XMLNode( doc )
+{
+}
+
+
+XMLDeclaration::~XMLDeclaration()
+{
+    //printf( "~XMLDeclaration\n" );
+}
+
+
+char* XMLDeclaration::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
+{
+    // Declaration parses as text.
+    p = _value.ParseText( p, "?>", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr );
+    if ( p == 0 ) {
+        _document->SetError( XML_ERROR_PARSING_DECLARATION, _parseLineNum, 0 );
+    }
+    return p;
+}
+
+
+XMLNode* XMLDeclaration::ShallowClone( XMLDocument* doc ) const
+{
+    if ( !doc ) {
+        doc = _document;
+    }
+    XMLDeclaration* dec = doc->NewDeclaration( Value() );	// fixme: this will always allocate memory. Intern?
+    return dec;
+}
+
+
+bool XMLDeclaration::ShallowEqual( const XMLNode* compare ) const
+{
+    TIXMLASSERT( compare );
+    const XMLDeclaration* declaration = compare->ToDeclaration();
+    return ( declaration && XMLUtil::StringEqual( declaration->Value(), Value() ));
+}
+
+
+
+bool XMLDeclaration::Accept( XMLVisitor* visitor ) const
+{
+    TIXMLASSERT( visitor );
+    return visitor->Visit( *this );
+}
+
+// --------- XMLUnknown ---------- //
+
+XMLUnknown::XMLUnknown( XMLDocument* doc ) : XMLNode( doc )
+{
+}
+
+
+XMLUnknown::~XMLUnknown()
+{
+}
+
+
+char* XMLUnknown::ParseDeep( char* p, StrPair*, int* curLineNumPtr )
+{
+    // Unknown parses as text.
+    p = _value.ParseText( p, ">", StrPair::NEEDS_NEWLINE_NORMALIZATION, curLineNumPtr );
+    if ( !p ) {
+        _document->SetError( XML_ERROR_PARSING_UNKNOWN, _parseLineNum, 0 );
+    }
+    return p;
+}
+
+
+XMLNode* XMLUnknown::ShallowClone( XMLDocument* doc ) const
+{
+    if ( !doc ) {
+        doc = _document;
+    }
+    XMLUnknown* text = doc->NewUnknown( Value() );	// fixme: this will always allocate memory. Intern?
+    return text;
+}
+
+
+bool XMLUnknown::ShallowEqual( const XMLNode* compare ) const
+{
+    TIXMLASSERT( compare );
+    const XMLUnknown* unknown = compare->ToUnknown();
+    return ( unknown && XMLUtil::StringEqual( unknown->Value(), Value() ));
+}
+
+
+bool XMLUnknown::Accept( XMLVisitor* visitor ) const
+{
+    TIXMLASSERT( visitor );
+    return visitor->Visit( *this );
+}
+
+// --------- XMLAttribute ---------- //
+
+const char* XMLAttribute::Name() const
+{
+    return _name.GetStr();
+}
+
+const char* XMLAttribute::Value() const
+{
+    return _value.GetStr();
+}
+
+char* XMLAttribute::ParseDeep( char* p, bool processEntities, int* curLineNumPtr )
+{
+    // Parse using the name rules: bug fix, was using ParseText before
+    p = _name.ParseName( p );
+    if ( !p || !*p ) {
+        return 0;
+    }
+
+    // Skip white space before =
+    p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
+    if ( *p != '=' ) {
+        return 0;
+    }
+
+    ++p;	// move up to opening quote
+    p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
+    if ( *p != '\"' && *p != '\'' ) {
+        return 0;
+    }
+
+    const char endTag[2] = { *p, 0 };
+    ++p;	// move past opening quote
+
+    p = _value.ParseText( p, endTag, processEntities ? StrPair::ATTRIBUTE_VALUE : StrPair::ATTRIBUTE_VALUE_LEAVE_ENTITIES, curLineNumPtr );
+    return p;
+}
+
+
+void XMLAttribute::SetName( const char* n )
+{
+    _name.SetStr( n );
+}
+
+
+XMLError XMLAttribute::QueryIntValue( int* value ) const
+{
+    if ( XMLUtil::ToInt( Value(), value )) {
+        return XML_SUCCESS;
+    }
+    return XML_WRONG_ATTRIBUTE_TYPE;
+}
+
+
+XMLError XMLAttribute::QueryUnsignedValue( unsigned int* value ) const
+{
+    if ( XMLUtil::ToUnsigned( Value(), value )) {
+        return XML_SUCCESS;
+    }
+    return XML_WRONG_ATTRIBUTE_TYPE;
+}
+
+
+XMLError XMLAttribute::QueryInt64Value(int64_t* value) const
+{
+	if (XMLUtil::ToInt64(Value(), value)) {
+		return XML_SUCCESS;
+	}
+	return XML_WRONG_ATTRIBUTE_TYPE;
+}
+
+
+XMLError XMLAttribute::QueryUnsigned64Value(uint64_t* value) const
+{
+    if(XMLUtil::ToUnsigned64(Value(), value)) {
+        return XML_SUCCESS;
+    }
+    return XML_WRONG_ATTRIBUTE_TYPE;
+}
+
+
+XMLError XMLAttribute::QueryBoolValue( bool* value ) const
+{
+    if ( XMLUtil::ToBool( Value(), value )) {
+        return XML_SUCCESS;
+    }
+    return XML_WRONG_ATTRIBUTE_TYPE;
+}
+
+
+XMLError XMLAttribute::QueryFloatValue( float* value ) const
+{
+    if ( XMLUtil::ToFloat( Value(), value )) {
+        return XML_SUCCESS;
+    }
+    return XML_WRONG_ATTRIBUTE_TYPE;
+}
+
+
+XMLError XMLAttribute::QueryDoubleValue( double* value ) const
+{
+    if ( XMLUtil::ToDouble( Value(), value )) {
+        return XML_SUCCESS;
+    }
+    return XML_WRONG_ATTRIBUTE_TYPE;
+}
+
+
+void XMLAttribute::SetAttribute( const char* v )
+{
+    _value.SetStr( v );
+}
+
+
+void XMLAttribute::SetAttribute( int v )
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( v, buf, BUF_SIZE );
+    _value.SetStr( buf );
+}
+
+
+void XMLAttribute::SetAttribute( unsigned v )
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( v, buf, BUF_SIZE );
+    _value.SetStr( buf );
+}
+
+
+void XMLAttribute::SetAttribute(int64_t v)
+{
+	char buf[BUF_SIZE];
+	XMLUtil::ToStr(v, buf, BUF_SIZE);
+	_value.SetStr(buf);
+}
+
+void XMLAttribute::SetAttribute(uint64_t v)
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    _value.SetStr(buf);
+}
+
+
+void XMLAttribute::SetAttribute( bool v )
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( v, buf, BUF_SIZE );
+    _value.SetStr( buf );
+}
+
+void XMLAttribute::SetAttribute( double v )
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( v, buf, BUF_SIZE );
+    _value.SetStr( buf );
+}
+
+void XMLAttribute::SetAttribute( float v )
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( v, buf, BUF_SIZE );
+    _value.SetStr( buf );
+}
+
+
+// --------- XMLElement ---------- //
+XMLElement::XMLElement( XMLDocument* doc ) : XMLNode( doc ),
+    _closingType( OPEN ),
+    _rootAttribute( 0 )
+{
+}
+
+
+XMLElement::~XMLElement()
+{
+    while( _rootAttribute ) {
+        XMLAttribute* next = _rootAttribute->_next;
+        DeleteAttribute( _rootAttribute );
+        _rootAttribute = next;
+    }
+}
+
+
+const XMLAttribute* XMLElement::FindAttribute( const char* name ) const
+{
+    for( XMLAttribute* a = _rootAttribute; a; a = a->_next ) {
+        if ( XMLUtil::StringEqual( a->Name(), name ) ) {
+            return a;
+        }
+    }
+    return 0;
+}
+
+
+const char* XMLElement::Attribute( const char* name, const char* value ) const
+{
+    const XMLAttribute* a = FindAttribute( name );
+    if ( !a ) {
+        return 0;
+    }
+    if ( !value || XMLUtil::StringEqual( a->Value(), value )) {
+        return a->Value();
+    }
+    return 0;
+}
+
+int XMLElement::IntAttribute(const char* name, int defaultValue) const
+{
+	int i = defaultValue;
+	QueryIntAttribute(name, &i);
+	return i;
+}
+
+unsigned XMLElement::UnsignedAttribute(const char* name, unsigned defaultValue) const
+{
+	unsigned i = defaultValue;
+	QueryUnsignedAttribute(name, &i);
+	return i;
+}
+
+int64_t XMLElement::Int64Attribute(const char* name, int64_t defaultValue) const
+{
+	int64_t i = defaultValue;
+	QueryInt64Attribute(name, &i);
+	return i;
+}
+
+uint64_t XMLElement::Unsigned64Attribute(const char* name, uint64_t defaultValue) const
+{
+	uint64_t i = defaultValue;
+	QueryUnsigned64Attribute(name, &i);
+	return i;
+}
+
+bool XMLElement::BoolAttribute(const char* name, bool defaultValue) const
+{
+	bool b = defaultValue;
+	QueryBoolAttribute(name, &b);
+	return b;
+}
+
+double XMLElement::DoubleAttribute(const char* name, double defaultValue) const
+{
+	double d = defaultValue;
+	QueryDoubleAttribute(name, &d);
+	return d;
+}
+
+float XMLElement::FloatAttribute(const char* name, float defaultValue) const
+{
+	float f = defaultValue;
+	QueryFloatAttribute(name, &f);
+	return f;
+}
+
+const char* XMLElement::GetText() const
+{
+    /* skip comment node */
+    const XMLNode* node = FirstChild();
+    while (node) {
+        if (node->ToComment()) {
+            node = node->NextSibling();
+            continue;
+        }
+        break;
+    }
+
+    if ( node && node->ToText() ) {
+        return node->Value();
+    }
+    return 0;
+}
+
+
+void	XMLElement::SetText( const char* inText )
+{
+	if ( FirstChild() && FirstChild()->ToText() )
+		FirstChild()->SetValue( inText );
+	else {
+		XMLText*	theText = GetDocument()->NewText( inText );
+		InsertFirstChild( theText );
+	}
+}
+
+
+void XMLElement::SetText( int v )
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( v, buf, BUF_SIZE );
+    SetText( buf );
+}
+
+
+void XMLElement::SetText( unsigned v )
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( v, buf, BUF_SIZE );
+    SetText( buf );
+}
+
+
+void XMLElement::SetText(int64_t v)
+{
+	char buf[BUF_SIZE];
+	XMLUtil::ToStr(v, buf, BUF_SIZE);
+	SetText(buf);
+}
+
+void XMLElement::SetText(uint64_t v) {
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr(v, buf, BUF_SIZE);
+    SetText(buf);
+}
+
+
+void XMLElement::SetText( bool v )
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( v, buf, BUF_SIZE );
+    SetText( buf );
+}
+
+
+void XMLElement::SetText( float v )
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( v, buf, BUF_SIZE );
+    SetText( buf );
+}
+
+
+void XMLElement::SetText( double v )
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( v, buf, BUF_SIZE );
+    SetText( buf );
+}
+
+
+XMLError XMLElement::QueryIntText( int* ival ) const
+{
+    if ( FirstChild() && FirstChild()->ToText() ) {
+        const char* t = FirstChild()->Value();
+        if ( XMLUtil::ToInt( t, ival ) ) {
+            return XML_SUCCESS;
+        }
+        return XML_CAN_NOT_CONVERT_TEXT;
+    }
+    return XML_NO_TEXT_NODE;
+}
+
+
+XMLError XMLElement::QueryUnsignedText( unsigned* uval ) const
+{
+    if ( FirstChild() && FirstChild()->ToText() ) {
+        const char* t = FirstChild()->Value();
+        if ( XMLUtil::ToUnsigned( t, uval ) ) {
+            return XML_SUCCESS;
+        }
+        return XML_CAN_NOT_CONVERT_TEXT;
+    }
+    return XML_NO_TEXT_NODE;
+}
+
+
+XMLError XMLElement::QueryInt64Text(int64_t* ival) const
+{
+	if (FirstChild() && FirstChild()->ToText()) {
+		const char* t = FirstChild()->Value();
+		if (XMLUtil::ToInt64(t, ival)) {
+			return XML_SUCCESS;
+		}
+		return XML_CAN_NOT_CONVERT_TEXT;
+	}
+	return XML_NO_TEXT_NODE;
+}
+
+
+XMLError XMLElement::QueryUnsigned64Text(uint64_t* uval) const
+{
+    if(FirstChild() && FirstChild()->ToText()) {
+        const char* t = FirstChild()->Value();
+        if(XMLUtil::ToUnsigned64(t, uval)) {
+            return XML_SUCCESS;
+        }
+        return XML_CAN_NOT_CONVERT_TEXT;
+    }
+    return XML_NO_TEXT_NODE;
+}
+
+
+XMLError XMLElement::QueryBoolText( bool* bval ) const
+{
+    if ( FirstChild() && FirstChild()->ToText() ) {
+        const char* t = FirstChild()->Value();
+        if ( XMLUtil::ToBool( t, bval ) ) {
+            return XML_SUCCESS;
+        }
+        return XML_CAN_NOT_CONVERT_TEXT;
+    }
+    return XML_NO_TEXT_NODE;
+}
+
+
+XMLError XMLElement::QueryDoubleText( double* dval ) const
+{
+    if ( FirstChild() && FirstChild()->ToText() ) {
+        const char* t = FirstChild()->Value();
+        if ( XMLUtil::ToDouble( t, dval ) ) {
+            return XML_SUCCESS;
+        }
+        return XML_CAN_NOT_CONVERT_TEXT;
+    }
+    return XML_NO_TEXT_NODE;
+}
+
+
+XMLError XMLElement::QueryFloatText( float* fval ) const
+{
+    if ( FirstChild() && FirstChild()->ToText() ) {
+        const char* t = FirstChild()->Value();
+        if ( XMLUtil::ToFloat( t, fval ) ) {
+            return XML_SUCCESS;
+        }
+        return XML_CAN_NOT_CONVERT_TEXT;
+    }
+    return XML_NO_TEXT_NODE;
+}
+
+int XMLElement::IntText(int defaultValue) const
+{
+	int i = defaultValue;
+	QueryIntText(&i);
+	return i;
+}
+
+unsigned XMLElement::UnsignedText(unsigned defaultValue) const
+{
+	unsigned i = defaultValue;
+	QueryUnsignedText(&i);
+	return i;
+}
+
+int64_t XMLElement::Int64Text(int64_t defaultValue) const
+{
+	int64_t i = defaultValue;
+	QueryInt64Text(&i);
+	return i;
+}
+
+uint64_t XMLElement::Unsigned64Text(uint64_t defaultValue) const
+{
+	uint64_t i = defaultValue;
+	QueryUnsigned64Text(&i);
+	return i;
+}
+
+bool XMLElement::BoolText(bool defaultValue) const
+{
+	bool b = defaultValue;
+	QueryBoolText(&b);
+	return b;
+}
+
+double XMLElement::DoubleText(double defaultValue) const
+{
+	double d = defaultValue;
+	QueryDoubleText(&d);
+	return d;
+}
+
+float XMLElement::FloatText(float defaultValue) const
+{
+	float f = defaultValue;
+	QueryFloatText(&f);
+	return f;
+}
+
+
+XMLAttribute* XMLElement::FindOrCreateAttribute( const char* name )
+{
+    XMLAttribute* last = 0;
+    XMLAttribute* attrib = 0;
+    for( attrib = _rootAttribute;
+            attrib;
+            last = attrib, attrib = attrib->_next ) {
+        if ( XMLUtil::StringEqual( attrib->Name(), name ) ) {
+            break;
+        }
+    }
+    if ( !attrib ) {
+        attrib = CreateAttribute();
+        TIXMLASSERT( attrib );
+        if ( last ) {
+            TIXMLASSERT( last->_next == 0 );
+            last->_next = attrib;
+        }
+        else {
+            TIXMLASSERT( _rootAttribute == 0 );
+            _rootAttribute = attrib;
+        }
+        attrib->SetName( name );
+    }
+    return attrib;
+}
+
+
+void XMLElement::DeleteAttribute( const char* name )
+{
+    XMLAttribute* prev = 0;
+    for( XMLAttribute* a=_rootAttribute; a; a=a->_next ) {
+        if ( XMLUtil::StringEqual( name, a->Name() ) ) {
+            if ( prev ) {
+                prev->_next = a->_next;
+            }
+            else {
+                _rootAttribute = a->_next;
+            }
+            DeleteAttribute( a );
+            break;
+        }
+        prev = a;
+    }
+}
+
+
+char* XMLElement::ParseAttributes( char* p, int* curLineNumPtr )
+{
+    XMLAttribute* prevAttribute = 0;
+
+    // Read the attributes.
+    while( p ) {
+        p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
+        if ( !(*p) ) {
+            _document->SetError( XML_ERROR_PARSING_ELEMENT, _parseLineNum, "XMLElement name=%s", Name() );
+            return 0;
+        }
+
+        // attribute.
+        if (XMLUtil::IsNameStartChar( static_cast<unsigned char>(*p) ) ) {
+            XMLAttribute* attrib = CreateAttribute();
+            TIXMLASSERT( attrib );
+            attrib->_parseLineNum = _document->_parseCurLineNum;
+
+            const int attrLineNum = attrib->_parseLineNum;
+
+            p = attrib->ParseDeep( p, _document->ProcessEntities(), curLineNumPtr );
+            if ( !p || Attribute( attrib->Name() ) ) {
+                DeleteAttribute( attrib );
+                _document->SetError( XML_ERROR_PARSING_ATTRIBUTE, attrLineNum, "XMLElement name=%s", Name() );
+                return 0;
+            }
+            // There is a minor bug here: if the attribute in the source xml
+            // document is duplicated, it will not be detected and the
+            // attribute will be doubly added. However, tracking the 'prevAttribute'
+            // avoids re-scanning the attribute list. Preferring performance for
+            // now, may reconsider in the future.
+            if ( prevAttribute ) {
+                TIXMLASSERT( prevAttribute->_next == 0 );
+                prevAttribute->_next = attrib;
+            }
+            else {
+                TIXMLASSERT( _rootAttribute == 0 );
+                _rootAttribute = attrib;
+            }
+            prevAttribute = attrib;
+        }
+        // end of the tag
+        else if ( *p == '>' ) {
+            ++p;
+            break;
+        }
+        // end of the tag
+        else if ( *p == '/' && *(p+1) == '>' ) {
+            _closingType = CLOSED;
+            return p+2;	// done; sealed element.
+        }
+        else {
+            _document->SetError( XML_ERROR_PARSING_ELEMENT, _parseLineNum, 0 );
+            return 0;
+        }
+    }
+    return p;
+}
+
+void XMLElement::DeleteAttribute( XMLAttribute* attribute )
+{
+    if ( attribute == 0 ) {
+        return;
+    }
+    MemPool* pool = attribute->_memPool;
+    attribute->~XMLAttribute();
+    pool->Free( attribute );
+}
+
+XMLAttribute* XMLElement::CreateAttribute()
+{
+    TIXMLASSERT( sizeof( XMLAttribute ) == _document->_attributePool.ItemSize() );
+    XMLAttribute* attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();
+    TIXMLASSERT( attrib );
+    attrib->_memPool = &_document->_attributePool;
+    attrib->_memPool->SetTracked();
+    return attrib;
+}
+
+
+XMLElement* XMLElement::InsertNewChildElement(const char* name)
+{
+    XMLElement* node = _document->NewElement(name);
+    return InsertEndChild(node) ? node : 0;
+}
+
+XMLComment* XMLElement::InsertNewComment(const char* comment)
+{
+    XMLComment* node = _document->NewComment(comment);
+    return InsertEndChild(node) ? node : 0;
+}
+
+XMLText* XMLElement::InsertNewText(const char* text)
+{
+    XMLText* node = _document->NewText(text);
+    return InsertEndChild(node) ? node : 0;
+}
+
+XMLDeclaration* XMLElement::InsertNewDeclaration(const char* text)
+{
+    XMLDeclaration* node = _document->NewDeclaration(text);
+    return InsertEndChild(node) ? node : 0;
+}
+
+XMLUnknown* XMLElement::InsertNewUnknown(const char* text)
+{
+    XMLUnknown* node = _document->NewUnknown(text);
+    return InsertEndChild(node) ? node : 0;
+}
+
+
+
+//
+//	<ele></ele>
+//	<ele>foo<b>bar</b></ele>
+//
+char* XMLElement::ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr )
+{
+    // Read the element name.
+    p = XMLUtil::SkipWhiteSpace( p, curLineNumPtr );
+
+    // The closing element is the </element> form. It is
+    // parsed just like a regular element then deleted from
+    // the DOM.
+    if ( *p == '/' ) {
+        _closingType = CLOSING;
+        ++p;
+    }
+
+    p = _value.ParseName( p );
+    if ( _value.Empty() ) {
+        return 0;
+    }
+
+    p = ParseAttributes( p, curLineNumPtr );
+    if ( !p || !*p || _closingType != OPEN ) {
+        return p;
+    }
+
+    p = XMLNode::ParseDeep( p, parentEndTag, curLineNumPtr );
+    return p;
+}
+
+
+
+XMLNode* XMLElement::ShallowClone( XMLDocument* doc ) const
+{
+    if ( !doc ) {
+        doc = _document;
+    }
+    XMLElement* element = doc->NewElement( Value() );					// fixme: this will always allocate memory. Intern?
+    for( const XMLAttribute* a=FirstAttribute(); a; a=a->Next() ) {
+        element->SetAttribute( a->Name(), a->Value() );					// fixme: this will always allocate memory. Intern?
+    }
+    return element;
+}
+
+
+bool XMLElement::ShallowEqual( const XMLNode* compare ) const
+{
+    TIXMLASSERT( compare );
+    const XMLElement* other = compare->ToElement();
+    if ( other && XMLUtil::StringEqual( other->Name(), Name() )) {
+
+        const XMLAttribute* a=FirstAttribute();
+        const XMLAttribute* b=other->FirstAttribute();
+
+        while ( a && b ) {
+            if ( !XMLUtil::StringEqual( a->Value(), b->Value() ) ) {
+                return false;
+            }
+            a = a->Next();
+            b = b->Next();
+        }
+        if ( a || b ) {
+            // different count
+            return false;
+        }
+        return true;
+    }
+    return false;
+}
+
+
+bool XMLElement::Accept( XMLVisitor* visitor ) const
+{
+    TIXMLASSERT( visitor );
+    if ( visitor->VisitEnter( *this, _rootAttribute ) ) {
+        for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
+            if ( !node->Accept( visitor ) ) {
+                break;
+            }
+        }
+    }
+    return visitor->VisitExit( *this );
+}
+
+
+// --------- XMLDocument ----------- //
+
+// Warning: List must match 'enum XMLError'
+const char* XMLDocument::_errorNames[XML_ERROR_COUNT] = {
+    "XML_SUCCESS",
+    "XML_NO_ATTRIBUTE",
+    "XML_WRONG_ATTRIBUTE_TYPE",
+    "XML_ERROR_FILE_NOT_FOUND",
+    "XML_ERROR_FILE_COULD_NOT_BE_OPENED",
+    "XML_ERROR_FILE_READ_ERROR",
+    "XML_ERROR_PARSING_ELEMENT",
+    "XML_ERROR_PARSING_ATTRIBUTE",
+    "XML_ERROR_PARSING_TEXT",
+    "XML_ERROR_PARSING_CDATA",
+    "XML_ERROR_PARSING_COMMENT",
+    "XML_ERROR_PARSING_DECLARATION",
+    "XML_ERROR_PARSING_UNKNOWN",
+    "XML_ERROR_EMPTY_DOCUMENT",
+    "XML_ERROR_MISMATCHED_ELEMENT",
+    "XML_ERROR_PARSING",
+    "XML_CAN_NOT_CONVERT_TEXT",
+    "XML_NO_TEXT_NODE",
+	"XML_ELEMENT_DEPTH_EXCEEDED"
+};
+
+
+XMLDocument::XMLDocument( bool processEntities, Whitespace whitespaceMode ) :
+    XMLNode( 0 ),
+    _writeBOM( false ),
+    _processEntities( processEntities ),
+    _errorID(XML_SUCCESS),
+    _whitespaceMode( whitespaceMode ),
+    _errorStr(),
+    _errorLineNum( 0 ),
+    _charBuffer( 0 ),
+    _parseCurLineNum( 0 ),
+	_parsingDepth(0),
+    _unlinked(),
+    _elementPool(),
+    _attributePool(),
+    _textPool(),
+    _commentPool()
+{
+    // avoid VC++ C4355 warning about 'this' in initializer list (C4355 is off by default in VS2012+)
+    _document = this;
+}
+
+
+XMLDocument::~XMLDocument()
+{
+    Clear();
+}
+
+
+void XMLDocument::MarkInUse(const XMLNode* const node)
+{
+	TIXMLASSERT(node);
+	TIXMLASSERT(node->_parent == 0);
+
+	for (size_t i = 0; i < _unlinked.Size(); ++i) {
+		if (node == _unlinked[i]) {
+			_unlinked.SwapRemove(i);
+			break;
+		}
+	}
+}
+
+void XMLDocument::Clear()
+{
+    DeleteChildren();
+	while( _unlinked.Size()) {
+		DeleteNode(_unlinked[0]);	// Will remove from _unlinked as part of delete.
+	}
+
+#ifdef TINYXML2_DEBUG
+    const bool hadError = Error();
+#endif
+    ClearError();
+
+    delete [] _charBuffer;
+    _charBuffer = 0;
+	_parsingDepth = 0;
+
+#if 0
+    _textPool.Trace( "text" );
+    _elementPool.Trace( "element" );
+    _commentPool.Trace( "comment" );
+    _attributePool.Trace( "attribute" );
+#endif
+
+#ifdef TINYXML2_DEBUG
+    if ( !hadError ) {
+        TIXMLASSERT( _elementPool.CurrentAllocs()   == _elementPool.Untracked() );
+        TIXMLASSERT( _attributePool.CurrentAllocs() == _attributePool.Untracked() );
+        TIXMLASSERT( _textPool.CurrentAllocs()      == _textPool.Untracked() );
+        TIXMLASSERT( _commentPool.CurrentAllocs()   == _commentPool.Untracked() );
+    }
+#endif
+}
+
+
+void XMLDocument::DeepCopy(XMLDocument* target) const
+{
+	TIXMLASSERT(target);
+    if (target == this) {
+        return; // technically success - a no-op.
+    }
+
+	target->Clear();
+	for (const XMLNode* node = this->FirstChild(); node; node = node->NextSibling()) {
+		target->InsertEndChild(node->DeepClone(target));
+	}
+}
+
+XMLElement* XMLDocument::NewElement( const char* name )
+{
+    XMLElement* ele = CreateUnlinkedNode<XMLElement>( _elementPool );
+    ele->SetName( name );
+    return ele;
+}
+
+
+XMLComment* XMLDocument::NewComment( const char* str )
+{
+    XMLComment* comment = CreateUnlinkedNode<XMLComment>( _commentPool );
+    comment->SetValue( str );
+    return comment;
+}
+
+
+XMLText* XMLDocument::NewText( const char* str )
+{
+    XMLText* text = CreateUnlinkedNode<XMLText>( _textPool );
+    text->SetValue( str );
+    return text;
+}
+
+
+XMLDeclaration* XMLDocument::NewDeclaration( const char* str )
+{
+    XMLDeclaration* dec = CreateUnlinkedNode<XMLDeclaration>( _commentPool );
+    dec->SetValue( str ? str : "xml version=\"1.0\" encoding=\"UTF-8\"" );
+    return dec;
+}
+
+
+XMLUnknown* XMLDocument::NewUnknown( const char* str )
+{
+    XMLUnknown* unk = CreateUnlinkedNode<XMLUnknown>( _commentPool );
+    unk->SetValue( str );
+    return unk;
+}
+
+static FILE* callfopen( const char* filepath, const char* mode )
+{
+    TIXMLASSERT( filepath );
+    TIXMLASSERT( mode );
+#if defined(_MSC_VER) && (_MSC_VER >= 1400 ) && (!defined WINCE)
+    FILE* fp = 0;
+    const errno_t err = fopen_s( &fp, filepath, mode );
+    if ( err ) {
+        return 0;
+    }
+#else
+    FILE* fp = fopen( filepath, mode );
+#endif
+    return fp;
+}
+
+void XMLDocument::DeleteNode( XMLNode* node )	{
+    TIXMLASSERT( node );
+    TIXMLASSERT(node->_document == this );
+    if (node->_parent) {
+        node->_parent->DeleteChild( node );
+    }
+    else {
+        // Isn't in the tree.
+        // Use the parent delete.
+        // Also, we need to mark it tracked: we 'know'
+        // it was never used.
+        node->_memPool->SetTracked();
+        // Call the static XMLNode version:
+        XMLNode::DeleteNode(node);
+    }
+}
+
+
+XMLError XMLDocument::LoadFile( const char* filename )
+{
+    if ( !filename ) {
+        TIXMLASSERT( false );
+        SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=<null>" );
+        return _errorID;
+    }
+
+    Clear();
+    FILE* fp = callfopen( filename, "rb" );
+    if ( !fp ) {
+        SetError( XML_ERROR_FILE_NOT_FOUND, 0, "filename=%s", filename );
+        return _errorID;
+    }
+    LoadFile( fp );
+    fclose( fp );
+    return _errorID;
+}
+
+XMLError XMLDocument::LoadFile( FILE* fp )
+{
+    Clear();
+
+    TIXML_FSEEK( fp, 0, SEEK_SET );
+    if ( fgetc( fp ) == EOF && ferror( fp ) != 0 ) {
+        SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
+        return _errorID;
+    }
+
+    TIXML_FSEEK( fp, 0, SEEK_END );
+
+    unsigned long long filelength;
+    {
+        const long long fileLengthSigned = TIXML_FTELL( fp );
+        TIXML_FSEEK( fp, 0, SEEK_SET );
+        if ( fileLengthSigned == -1L ) {
+            SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
+            return _errorID;
+        }
+        TIXMLASSERT( fileLengthSigned >= 0 );
+        filelength = static_cast<unsigned long long>(fileLengthSigned);
+    }
+
+    const size_t maxSizeT = static_cast<size_t>(-1);
+    // We'll do the comparison as an unsigned long long, because that's guaranteed to be at
+    // least 8 bytes, even on a 32-bit platform.
+    if ( filelength >= static_cast<unsigned long long>(maxSizeT) ) {
+        // Cannot handle files which won't fit in buffer together with null terminator
+        SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
+        return _errorID;
+    }
+
+    if ( filelength == 0 ) {
+        SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
+        return _errorID;
+    }
+
+    const size_t size = static_cast<size_t>(filelength);
+    TIXMLASSERT( _charBuffer == 0 );
+    _charBuffer = new char[size+1];
+    const size_t read = fread( _charBuffer, 1, size, fp );
+    if ( read != size ) {
+        SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
+        return _errorID;
+    }
+
+    _charBuffer[size] = 0;
+
+    Parse();
+    return _errorID;
+}
+
+
+XMLError XMLDocument::SaveFile( const char* filename, bool compact )
+{
+    if ( !filename ) {
+        TIXMLASSERT( false );
+        SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=<null>" );
+        return _errorID;
+    }
+
+    FILE* fp = callfopen( filename, "w" );
+    if ( !fp ) {
+        SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, 0, "filename=%s", filename );
+        return _errorID;
+    }
+    SaveFile(fp, compact);
+    fclose( fp );
+    return _errorID;
+}
+
+
+XMLError XMLDocument::SaveFile( FILE* fp, bool compact )
+{
+    // Clear any error from the last save, otherwise it will get reported
+    // for *this* call.
+    ClearError();
+    XMLPrinter stream( fp, compact );
+    Print( &stream );
+    return _errorID;
+}
+
+
+XMLError XMLDocument::Parse( const char* xml, size_t nBytes )
+{
+    Clear();
+
+    if ( nBytes == 0 || !xml || !*xml ) {
+        SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
+        return _errorID;
+    }
+    if ( nBytes == static_cast<size_t>(-1) ) {
+        nBytes = strlen( xml );
+    }
+    TIXMLASSERT( _charBuffer == 0 );
+    _charBuffer = new char[ nBytes+1 ];
+    memcpy( _charBuffer, xml, nBytes );
+    _charBuffer[nBytes] = 0;
+
+    Parse();
+    if ( Error() ) {
+        // clean up now essentially dangling memory.
+        // and the parse fail can put objects in the
+        // pools that are dead and inaccessible.
+        DeleteChildren();
+        _elementPool.Clear();
+        _attributePool.Clear();
+        _textPool.Clear();
+        _commentPool.Clear();
+    }
+    return _errorID;
+}
+
+
+void XMLDocument::Print( XMLPrinter* streamer ) const
+{
+    if ( streamer ) {
+        Accept( streamer );
+    }
+    else {
+        XMLPrinter stdoutStreamer( stdout );
+        Accept( &stdoutStreamer );
+    }
+}
+
+
+void XMLDocument::ClearError() {
+    _errorID = XML_SUCCESS;
+    _errorLineNum = 0;
+    _errorStr.Reset();
+}
+
+
+void XMLDocument::SetError( XMLError error, int lineNum, const char* format, ... )
+{
+    TIXMLASSERT(error >= 0 && error < XML_ERROR_COUNT);
+    _errorID = error;
+    _errorLineNum = lineNum;
+	_errorStr.Reset();
+
+    const size_t BUFFER_SIZE = 1000;
+    char* buffer = new char[BUFFER_SIZE];
+
+    TIXMLASSERT(sizeof(error) <= sizeof(int));
+    TIXML_SNPRINTF(buffer, BUFFER_SIZE, "Error=%s ErrorID=%d (0x%x) Line number=%d",
+        ErrorIDToName(error), static_cast<int>(error), static_cast<unsigned int>(error), lineNum);
+
+	if (format) {
+		size_t len = strlen(buffer);
+		TIXML_SNPRINTF(buffer + len, BUFFER_SIZE - len, ": ");
+		len = strlen(buffer);
+
+		va_list va;
+		va_start(va, format);
+		TIXML_VSNPRINTF(buffer + len, BUFFER_SIZE - len, format, va);
+		va_end(va);
+	}
+	_errorStr.SetStr(buffer);
+	delete[] buffer;
+}
+
+
+/*static*/ const char* XMLDocument::ErrorIDToName(XMLError errorID)
+{
+	TIXMLASSERT( errorID >= 0 && errorID < XML_ERROR_COUNT );
+    const char* errorName = _errorNames[errorID];
+    TIXMLASSERT( errorName && errorName[0] );
+    return errorName;
+}
+
+const char* XMLDocument::ErrorStr() const
+{
+	return _errorStr.Empty() ? "" : _errorStr.GetStr();
+}
+
+
+void XMLDocument::PrintError() const
+{
+    printf("%s\n", ErrorStr());
+}
+
+const char* XMLDocument::ErrorName() const
+{
+    return ErrorIDToName(_errorID);
+}
+
+void XMLDocument::Parse()
+{
+    TIXMLASSERT( NoChildren() ); // Clear() must have been called previously
+    TIXMLASSERT( _charBuffer );
+    _parseCurLineNum = 1;
+    _parseLineNum = 1;
+    char* p = _charBuffer;
+    p = XMLUtil::SkipWhiteSpace( p, &_parseCurLineNum );
+    p = const_cast<char*>( XMLUtil::ReadBOM( p, &_writeBOM ) );
+    if ( !*p ) {
+        SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
+        return;
+    }
+    ParseDeep(p, 0, &_parseCurLineNum );
+}
+
+void XMLDocument::PushDepth()
+{
+	_parsingDepth++;
+	if (_parsingDepth == TINYXML2_MAX_ELEMENT_DEPTH) {
+		SetError(XML_ELEMENT_DEPTH_EXCEEDED, _parseCurLineNum, "Element nesting is too deep." );
+	}
+}
+
+void XMLDocument::PopDepth()
+{
+	TIXMLASSERT(_parsingDepth > 0);
+	--_parsingDepth;
+}
+
+XMLPrinter::XMLPrinter( FILE* file, bool compact, int depth ) :
+    _elementJustOpened( false ),
+    _stack(),
+    _firstElement( true ),
+    _fp( file ),
+    _depth( depth ),
+    _textDepth( -1 ),
+    _processEntities( true ),
+    _compactMode( compact ),
+    _buffer()
+{
+    for( int i=0; i<ENTITY_RANGE; ++i ) {
+        _entityFlag[i] = false;
+        _restrictedEntityFlag[i] = false;
+    }
+    for( int i=0; i<NUM_ENTITIES; ++i ) {
+        const char entityValue = entities[i].value;
+        const unsigned char flagIndex = static_cast<unsigned char>(entityValue);
+        TIXMLASSERT( flagIndex < ENTITY_RANGE );
+        _entityFlag[flagIndex] = true;
+    }
+    _restrictedEntityFlag[static_cast<unsigned char>('&')] = true;
+    _restrictedEntityFlag[static_cast<unsigned char>('<')] = true;
+    _restrictedEntityFlag[static_cast<unsigned char>('>')] = true;	// not required, but consistency is nice
+    _buffer.Push( 0 );
+}
+
+
+void XMLPrinter::Print( const char* format, ... )
+{
+    va_list     va;
+    va_start( va, format );
+
+    if ( _fp ) {
+        vfprintf( _fp, format, va );
+    }
+    else {
+        const int len = TIXML_VSCPRINTF( format, va );
+        // Close out and re-start the va-args
+        va_end( va );
+        TIXMLASSERT( len >= 0 );
+        va_start( va, format );
+        TIXMLASSERT( _buffer.Size() > 0 && _buffer[_buffer.Size() - 1] == 0 );
+        char* p = _buffer.PushArr( len ) - 1;	// back up over the null terminator.
+		TIXML_VSNPRINTF( p, len+1, format, va );
+    }
+    va_end( va );
+}
+
+
+void XMLPrinter::Write( const char* data, size_t size )
+{
+    if ( _fp ) {
+        fwrite ( data , sizeof(char), size, _fp);
+    }
+    else {
+        char* p = _buffer.PushArr( static_cast<int>(size) ) - 1;   // back up over the null terminator.
+        memcpy( p, data, size );
+        p[size] = 0;
+    }
+}
+
+
+void XMLPrinter::Putc( char ch )
+{
+    if ( _fp ) {
+        fputc ( ch, _fp);
+    }
+    else {
+        char* p = _buffer.PushArr( sizeof(char) ) - 1;   // back up over the null terminator.
+        p[0] = ch;
+        p[1] = 0;
+    }
+}
+
+
+void XMLPrinter::PrintSpace( int depth )
+{
+    for( int i=0; i<depth; ++i ) {
+        Write( "    " );
+    }
+}
+
+
+void XMLPrinter::PrintString( const char* p, bool restricted )
+{
+    // Look for runs of bytes between entities to print.
+    const char* q = p;
+
+    if ( _processEntities ) {
+        const bool* flag = restricted ? _restrictedEntityFlag : _entityFlag;
+        while ( *q ) {
+            TIXMLASSERT( p <= q );
+            // Remember, char is sometimes signed. (How many times has that bitten me?)
+            if ( *q > 0 && *q < ENTITY_RANGE ) {
+                // Check for entities. If one is found, flush
+                // the stream up until the entity, write the
+                // entity, and keep looking.
+                if ( flag[static_cast<unsigned char>(*q)] ) {
+                    while ( p < q ) {
+                        const size_t delta = q - p;
+                        const int toPrint = ( INT_MAX < delta ) ? INT_MAX : static_cast<int>(delta);
+                        Write( p, toPrint );
+                        p += toPrint;
+                    }
+                    bool entityPatternPrinted = false;
+                    for( int i=0; i<NUM_ENTITIES; ++i ) {
+                        if ( entities[i].value == *q ) {
+                            Putc( '&' );
+                            Write( entities[i].pattern, entities[i].length );
+                            Putc( ';' );
+                            entityPatternPrinted = true;
+                            break;
+                        }
+                    }
+                    if ( !entityPatternPrinted ) {
+                        // TIXMLASSERT( entityPatternPrinted ) causes gcc -Wunused-but-set-variable in release
+                        TIXMLASSERT( false );
+                    }
+                    ++p;
+                }
+            }
+            ++q;
+            TIXMLASSERT( p <= q );
+        }
+        // Flush the remaining string. This will be the entire
+        // string if an entity wasn't found.
+        if ( p < q ) {
+            const size_t delta = q - p;
+            const int toPrint = ( INT_MAX < delta ) ? INT_MAX : static_cast<int>(delta);
+            Write( p, toPrint );
+        }
+    }
+    else {
+        Write( p );
+    }
+}
+
+
+void XMLPrinter::PushHeader( bool writeBOM, bool writeDec )
+{
+    if ( writeBOM ) {
+        static const unsigned char bom[] = { TIXML_UTF_LEAD_0, TIXML_UTF_LEAD_1, TIXML_UTF_LEAD_2, 0 };
+        Write( reinterpret_cast< const char* >( bom ) );
+    }
+    if ( writeDec ) {
+        PushDeclaration( "xml version=\"1.0\"" );
+    }
+}
+
+void XMLPrinter::PrepareForNewNode( bool compactMode )
+{
+    SealElementIfJustOpened();
+
+    if ( compactMode ) {
+        return;
+    }
+
+    if ( _firstElement ) {
+        PrintSpace (_depth);
+    } else if ( _textDepth < 0) {
+        Putc( '\n' );
+        PrintSpace( _depth );
+    }
+
+    _firstElement = false;
+}
+
+void XMLPrinter::OpenElement( const char* name, bool compactMode )
+{
+    PrepareForNewNode( compactMode );
+    _stack.Push( name );
+
+    Write ( "<" );
+    Write ( name );
+
+    _elementJustOpened = true;
+    ++_depth;
+}
+
+
+void XMLPrinter::PushAttribute( const char* name, const char* value )
+{
+    TIXMLASSERT( _elementJustOpened );
+    Putc ( ' ' );
+    Write( name );
+    Write( "=\"" );
+    PrintString( value, false );
+    Putc ( '\"' );
+}
+
+
+void XMLPrinter::PushAttribute( const char* name, int v )
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( v, buf, BUF_SIZE );
+    PushAttribute( name, buf );
+}
+
+
+void XMLPrinter::PushAttribute( const char* name, unsigned v )
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( v, buf, BUF_SIZE );
+    PushAttribute( name, buf );
+}
+
+
+void XMLPrinter::PushAttribute(const char* name, int64_t v)
+{
+	char buf[BUF_SIZE];
+	XMLUtil::ToStr(v, buf, BUF_SIZE);
+	PushAttribute(name, buf);
+}
+
+
+void XMLPrinter::PushAttribute(const char* name, uint64_t v)
+{
+	char buf[BUF_SIZE];
+	XMLUtil::ToStr(v, buf, BUF_SIZE);
+	PushAttribute(name, buf);
+}
+
+
+void XMLPrinter::PushAttribute( const char* name, bool v )
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( v, buf, BUF_SIZE );
+    PushAttribute( name, buf );
+}
+
+
+void XMLPrinter::PushAttribute( const char* name, double v )
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( v, buf, BUF_SIZE );
+    PushAttribute( name, buf );
+}
+
+
+void XMLPrinter::CloseElement( bool compactMode )
+{
+    --_depth;
+    const char* name = _stack.Pop();
+
+    if ( _elementJustOpened ) {
+        Write( "/>" );
+    }
+    else {
+        if ( _textDepth < 0 && !compactMode) {
+            Putc( '\n' );
+            PrintSpace( _depth );
+        }
+        Write ( "</" );
+        Write ( name );
+        Write ( ">" );
+    }
+
+    if ( _textDepth == _depth ) {
+        _textDepth = -1;
+    }
+    if ( _depth == 0 && !compactMode) {
+        Putc( '\n' );
+    }
+    _elementJustOpened = false;
+}
+
+
+void XMLPrinter::SealElementIfJustOpened()
+{
+    if ( !_elementJustOpened ) {
+        return;
+    }
+    _elementJustOpened = false;
+    Putc( '>' );
+}
+
+
+void XMLPrinter::PushText( const char* text, bool cdata )
+{
+    _textDepth = _depth-1;
+
+    SealElementIfJustOpened();
+    if ( cdata ) {
+        Write( "<![CDATA[" );
+        Write( text );
+        Write( "]]>" );
+    }
+    else {
+        PrintString( text, true );
+    }
+}
+
+
+void XMLPrinter::PushText( int64_t value )
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( value, buf, BUF_SIZE );
+    PushText( buf, false );
+}
+
+
+void XMLPrinter::PushText( uint64_t value )
+{
+	char buf[BUF_SIZE];
+	XMLUtil::ToStr(value, buf, BUF_SIZE);
+	PushText(buf, false);
+}
+
+
+void XMLPrinter::PushText( int value )
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( value, buf, BUF_SIZE );
+    PushText( buf, false );
+}
+
+
+void XMLPrinter::PushText( unsigned value )
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( value, buf, BUF_SIZE );
+    PushText( buf, false );
+}
+
+
+void XMLPrinter::PushText( bool value )
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( value, buf, BUF_SIZE );
+    PushText( buf, false );
+}
+
+
+void XMLPrinter::PushText( float value )
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( value, buf, BUF_SIZE );
+    PushText( buf, false );
+}
+
+
+void XMLPrinter::PushText( double value )
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( value, buf, BUF_SIZE );
+    PushText( buf, false );
+}
+
+
+void XMLPrinter::PushComment( const char* comment )
+{
+    PrepareForNewNode( _compactMode );
+
+    Write( "<!--" );
+    Write( comment );
+    Write( "-->" );
+}
+
+
+void XMLPrinter::PushDeclaration( const char* value )
+{
+    PrepareForNewNode( _compactMode );
+
+    Write( "<?" );
+    Write( value );
+    Write( "?>" );
+}
+
+
+void XMLPrinter::PushUnknown( const char* value )
+{
+    PrepareForNewNode( _compactMode );
+
+    Write( "<!" );
+    Write( value );
+    Putc( '>' );
+}
+
+
+bool XMLPrinter::VisitEnter( const XMLDocument& doc )
+{
+    _processEntities = doc.ProcessEntities();
+    if ( doc.HasBOM() ) {
+        PushHeader( true, false );
+    }
+    return true;
+}
+
+
+bool XMLPrinter::VisitEnter( const XMLElement& element, const XMLAttribute* attribute )
+{
+    const XMLElement* parentElem = 0;
+    if ( element.Parent() ) {
+        parentElem = element.Parent()->ToElement();
+    }
+    const bool compactMode = parentElem ? CompactMode( *parentElem ) : _compactMode;
+    OpenElement( element.Name(), compactMode );
+    while ( attribute ) {
+        PushAttribute( attribute->Name(), attribute->Value() );
+        attribute = attribute->Next();
+    }
+    return true;
+}
+
+
+bool XMLPrinter::VisitExit( const XMLElement& element )
+{
+    CloseElement( CompactMode(element) );
+    return true;
+}
+
+
+bool XMLPrinter::Visit( const XMLText& text )
+{
+    PushText( text.Value(), text.CData() );
+    return true;
+}
+
+
+bool XMLPrinter::Visit( const XMLComment& comment )
+{
+    PushComment( comment.Value() );
+    return true;
+}
+
+bool XMLPrinter::Visit( const XMLDeclaration& declaration )
+{
+    PushDeclaration( declaration.Value() );
+    return true;
+}
+
+
+bool XMLPrinter::Visit( const XMLUnknown& unknown )
+{
+    PushUnknown( unknown.Value() );
+    return true;
+}
+
+}   // namespace tinyxml2
diff --git a/externals/tinyxml/tinyxml2.h b/externals/tinyxml2/tinyxml2.h
similarity index 85%
rename from externals/tinyxml/tinyxml2.h
rename to externals/tinyxml2/tinyxml2.h
index a22f791d64b..9626be8a0f1 100644
--- a/externals/tinyxml/tinyxml2.h
+++ b/externals/tinyxml2/tinyxml2.h
@@ -1,2287 +1,2383 @@
-/*
-Original code by Lee Thomason (www.grinninglizard.com)
-
-This software is provided 'as-is', without any express or implied
-warranty. In no event will the authors be held liable for any
-damages arising from the use of this software.
-
-Permission is granted to anyone to use this software for any
-purpose, including commercial applications, and to alter it and
-redistribute it freely, subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must
-not claim that you wrote the original software. If you use this
-software in a product, an acknowledgment in the product documentation
-would be appreciated but is not required.
-
-2. Altered source versions must be plainly marked as such, and
-must not be misrepresented as being the original software.
-
-3. This notice may not be removed or altered from any source
-distribution.
-*/
-
-#ifndef TINYXML2_INCLUDED
-#define TINYXML2_INCLUDED
-
-#if defined(ANDROID_NDK) || defined(__BORLANDC__) || defined(__QNXNTO__)
-#   include <ctype.h>
-#   include <limits.h>
-#   include <stdio.h>
-#   include <stdlib.h>
-#   include <string.h>
-#	if defined(__PS3__)
-#		include <stddef.h>
-#	endif
-#else
-#   include <cctype>
-#   include <climits>
-#   include <cstdio>
-#   include <cstdlib>
-#   include <cstring>
-#endif
-#include <stdint.h>
-
-/*
-   TODO: intern strings instead of allocation.
-*/
-/*
-	gcc:
-        g++ -Wall -DTINYXML2_DEBUG tinyxml2.cpp xmltest.cpp -o gccxmltest.exe
-
-    Formatting, Artistic Style:
-        AStyle.exe --style=1tbs --indent-switches --break-closing-brackets --indent-preprocessor tinyxml2.cpp tinyxml2.h
-*/
-
-#if defined( _DEBUG ) || defined (__DEBUG__)
-#   ifndef TINYXML2_DEBUG
-#       define TINYXML2_DEBUG
-#   endif
-#endif
-
-#ifdef _MSC_VER
-#   pragma warning(push)
-#   pragma warning(disable: 4251)
-#endif
-
-#ifdef _WIN32
-#   ifdef TINYXML2_EXPORT
-#       define TINYXML2_LIB __declspec(dllexport)
-#   elif defined(TINYXML2_IMPORT)
-#       define TINYXML2_LIB __declspec(dllimport)
-#   else
-#       define TINYXML2_LIB
-#   endif
-#elif __GNUC__ >= 4
-#   define TINYXML2_LIB __attribute__((visibility("default")))
-#else
-#   define TINYXML2_LIB
-#endif
-
-
-#if defined(TINYXML2_DEBUG)
-#   if defined(_MSC_VER)
-#       // "(void)0," is for suppressing C4127 warning in "assert(false)", "assert(true)" and the like
-#       define TIXMLASSERT( x )           if ( !((void)0,(x))) { __debugbreak(); }
-#   elif defined (ANDROID_NDK)
-#       include <android/log.h>
-#       define TIXMLASSERT( x )           if ( !(x)) { __android_log_assert( "assert", "grinliz", "ASSERT in '%s' at %d.", __FILE__, __LINE__ ); }
-#   else
-#       include <assert.h>
-#       define TIXMLASSERT                assert
-#   endif
-#else
-#   define TIXMLASSERT( x )               {}
-#endif
-
-
-/* Versioning, past 1.0.14:
-	http://semver.org/
-*/
-static const int TIXML2_MAJOR_VERSION = 6;
-static const int TIXML2_MINOR_VERSION = 1;
-static const int TIXML2_PATCH_VERSION = 0;
-
-#define TINYXML2_MAJOR_VERSION 6
-#define TINYXML2_MINOR_VERSION 1
-#define TINYXML2_PATCH_VERSION 0
-
-namespace tinyxml2
-{
-class XMLDocument;
-class XMLElement;
-class XMLAttribute;
-class XMLComment;
-class XMLText;
-class XMLDeclaration;
-class XMLUnknown;
-class XMLPrinter;
-
-/*
-	A class that wraps strings. Normally stores the start and end
-	pointers into the XML file itself, and will apply normalization
-	and entity translation if actually read. Can also store (and memory
-	manage) a traditional char[]
-*/
-class StrPair
-{
-public:
-    enum {
-        NEEDS_ENTITY_PROCESSING			= 0x01,
-        NEEDS_NEWLINE_NORMALIZATION		= 0x02,
-        NEEDS_WHITESPACE_COLLAPSING     = 0x04,
-
-        TEXT_ELEMENT		            = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
-        TEXT_ELEMENT_LEAVE_ENTITIES		= NEEDS_NEWLINE_NORMALIZATION,
-        ATTRIBUTE_NAME		            = 0,
-        ATTRIBUTE_VALUE		            = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
-        ATTRIBUTE_VALUE_LEAVE_ENTITIES  = NEEDS_NEWLINE_NORMALIZATION,
-        COMMENT							= NEEDS_NEWLINE_NORMALIZATION
-    };
-
-    StrPair() : _flags( 0 ), _start( 0 ), _end( 0 ) {}
-    ~StrPair();
-
-    void Set( char* start, char* end, int flags ) {
-        TIXMLASSERT( start );
-        TIXMLASSERT( end );
-        Reset();
-        _start  = start;
-        _end    = end;
-        _flags  = flags | NEEDS_FLUSH;
-    }
-
-    const char* GetStr();
-
-    bool Empty() const {
-        return _start == _end;
-    }
-
-    void SetInternedStr( const char* str ) {
-        Reset();
-        _start = const_cast<char*>(str);
-    }
-
-    void SetStr( const char* str, int flags=0 );
-
-    char* ParseText( char* in, const char* endTag, int strFlags, int* curLineNumPtr );
-    char* ParseName( char* in );
-
-    void TransferTo( StrPair* other );
-	void Reset();
-
-private:
-    void CollapseWhitespace();
-
-    enum {
-        NEEDS_FLUSH = 0x100,
-        NEEDS_DELETE = 0x200
-    };
-
-    int     _flags;
-    char*   _start;
-    char*   _end;
-
-    StrPair( const StrPair& other );	// not supported
-    void operator=( StrPair& other );	// not supported, use TransferTo()
-};
-
-
-/*
-	A dynamic array of Plain Old Data. Doesn't support constructors, etc.
-	Has a small initial memory pool, so that low or no usage will not
-	cause a call to new/delete
-*/
-template <class T, int INITIAL_SIZE>
-class DynArray
-{
-public:
-    DynArray() :
-        _mem( _pool ),
-        _allocated( INITIAL_SIZE ),
-        _size( 0 )
-    {
-    }
-
-    ~DynArray() {
-        if ( _mem != _pool ) {
-            delete [] _mem;
-        }
-    }
-
-    void Clear() {
-        _size = 0;
-    }
-
-    void Push( T t ) {
-        TIXMLASSERT( _size < INT_MAX );
-        EnsureCapacity( _size+1 );
-        _mem[_size] = t;
-        ++_size;
-    }
-
-    T* PushArr( int count ) {
-        TIXMLASSERT( count >= 0 );
-        TIXMLASSERT( _size <= INT_MAX - count );
-        EnsureCapacity( _size+count );
-        T* ret = &_mem[_size];
-        _size += count;
-        return ret;
-    }
-
-    T Pop() {
-        TIXMLASSERT( _size > 0 );
-        --_size;
-        return _mem[_size];
-    }
-
-    void PopArr( int count ) {
-        TIXMLASSERT( _size >= count );
-        _size -= count;
-    }
-
-    bool Empty() const					{
-        return _size == 0;
-    }
-
-    T& operator[](int i)				{
-        TIXMLASSERT( i>= 0 && i < _size );
-        return _mem[i];
-    }
-
-    const T& operator[](int i) const	{
-        TIXMLASSERT( i>= 0 && i < _size );
-        return _mem[i];
-    }
-
-    const T& PeekTop() const            {
-        TIXMLASSERT( _size > 0 );
-        return _mem[ _size - 1];
-    }
-
-    int Size() const					{
-        TIXMLASSERT( _size >= 0 );
-        return _size;
-    }
-
-    int Capacity() const				{
-        TIXMLASSERT( _allocated >= INITIAL_SIZE );
-        return _allocated;
-    }
-
-	void SwapRemove(int i) {
-		TIXMLASSERT(i >= 0 && i < _size);
-		TIXMLASSERT(_size > 0);
-		_mem[i] = _mem[_size - 1];
-		--_size;
-	}
-
-    const T* Mem() const				{
-        TIXMLASSERT( _mem );
-        return _mem;
-    }
-
-    T* Mem()							{
-        TIXMLASSERT( _mem );
-        return _mem;
-    }
-
-private:
-    DynArray( const DynArray& ); // not supported
-    void operator=( const DynArray& ); // not supported
-
-    void EnsureCapacity( int cap ) {
-        TIXMLASSERT( cap > 0 );
-        if ( cap > _allocated ) {
-            TIXMLASSERT( cap <= INT_MAX / 2 );
-            int newAllocated = cap * 2;
-            T* newMem = new T[newAllocated];
-            TIXMLASSERT( newAllocated >= _size );
-            memcpy( newMem, _mem, sizeof(T)*_size );	// warning: not using constructors, only works for PODs
-            if ( _mem != _pool ) {
-                delete [] _mem;
-            }
-            _mem = newMem;
-            _allocated = newAllocated;
-        }
-    }
-
-    T*  _mem;
-    T   _pool[INITIAL_SIZE];
-    int _allocated;		// objects allocated
-    int _size;			// number objects in use
-};
-
-
-/*
-	Parent virtual class of a pool for fast allocation
-	and deallocation of objects.
-*/
-class MemPool
-{
-public:
-    MemPool() {}
-    virtual ~MemPool() {}
-
-    virtual int ItemSize() const = 0;
-    virtual void* Alloc() = 0;
-    virtual void Free( void* ) = 0;
-    virtual void SetTracked() = 0;
-    virtual void Clear() = 0;
-};
-
-
-/*
-	Template child class to create pools of the correct type.
-*/
-template< int ITEM_SIZE >
-class MemPoolT : public MemPool
-{
-public:
-    MemPoolT() : _blockPtrs(), _root(0), _currentAllocs(0), _nAllocs(0), _maxAllocs(0), _nUntracked(0)	{}
-    ~MemPoolT() {
-        Clear();
-    }
-    
-    void Clear() {
-        // Delete the blocks.
-        while( !_blockPtrs.Empty()) {
-            Block* lastBlock = _blockPtrs.Pop();
-            delete lastBlock;
-        }
-        _root = 0;
-        _currentAllocs = 0;
-        _nAllocs = 0;
-        _maxAllocs = 0;
-        _nUntracked = 0;
-    }
-
-    virtual int ItemSize() const	{
-        return ITEM_SIZE;
-    }
-    int CurrentAllocs() const		{
-        return _currentAllocs;
-    }
-
-    virtual void* Alloc() {
-        if ( !_root ) {
-            // Need a new block.
-            Block* block = new Block();
-            _blockPtrs.Push( block );
-
-            Item* blockItems = block->items;
-            for( int i = 0; i < ITEMS_PER_BLOCK - 1; ++i ) {
-                blockItems[i].next = &(blockItems[i + 1]);
-            }
-            blockItems[ITEMS_PER_BLOCK - 1].next = 0;
-            _root = blockItems;
-        }
-        Item* const result = _root;
-        TIXMLASSERT( result != 0 );
-        _root = _root->next;
-
-        ++_currentAllocs;
-        if ( _currentAllocs > _maxAllocs ) {
-            _maxAllocs = _currentAllocs;
-        }
-        ++_nAllocs;
-        ++_nUntracked;
-        return result;
-    }
-    
-    virtual void Free( void* mem ) {
-        if ( !mem ) {
-            return;
-        }
-        --_currentAllocs;
-        Item* item = static_cast<Item*>( mem );
-#ifdef TINYXML2_DEBUG
-        memset( item, 0xfe, sizeof( *item ) );
-#endif
-        item->next = _root;
-        _root = item;
-    }
-    void Trace( const char* name ) {
-        printf( "Mempool %s watermark=%d [%dk] current=%d size=%d nAlloc=%d blocks=%d\n",
-                name, _maxAllocs, _maxAllocs * ITEM_SIZE / 1024, _currentAllocs,
-                ITEM_SIZE, _nAllocs, _blockPtrs.Size() );
-    }
-
-    void SetTracked() {
-        --_nUntracked;
-    }
-
-    int Untracked() const {
-        return _nUntracked;
-    }
-
-	// This number is perf sensitive. 4k seems like a good tradeoff on my machine.
-	// The test file is large, 170k.
-	// Release:		VS2010 gcc(no opt)
-	//		1k:		4000
-	//		2k:		4000
-	//		4k:		3900	21000
-	//		16k:	5200
-	//		32k:	4300
-	//		64k:	4000	21000
-    // Declared public because some compilers do not accept to use ITEMS_PER_BLOCK
-    // in private part if ITEMS_PER_BLOCK is private
-    enum { ITEMS_PER_BLOCK = (4 * 1024) / ITEM_SIZE };
-
-private:
-    MemPoolT( const MemPoolT& ); // not supported
-    void operator=( const MemPoolT& ); // not supported
-
-    union Item {
-        Item*   next;
-        char    itemData[ITEM_SIZE];
-    };
-    struct Block {
-        Item items[ITEMS_PER_BLOCK];
-    };
-    DynArray< Block*, 10 > _blockPtrs;
-    Item* _root;
-
-    int _currentAllocs;
-    int _nAllocs;
-    int _maxAllocs;
-    int _nUntracked;
-};
-
-
-
-/**
-	Implements the interface to the "Visitor pattern" (see the Accept() method.)
-	If you call the Accept() method, it requires being passed a XMLVisitor
-	class to handle callbacks. For nodes that contain other nodes (Document, Element)
-	you will get called with a VisitEnter/VisitExit pair. Nodes that are always leafs
-	are simply called with Visit().
-
-	If you return 'true' from a Visit method, recursive parsing will continue. If you return
-	false, <b>no children of this node or its siblings</b> will be visited.
-
-	All flavors of Visit methods have a default implementation that returns 'true' (continue
-	visiting). You need to only override methods that are interesting to you.
-
-	Generally Accept() is called on the XMLDocument, although all nodes support visiting.
-
-	You should never change the document from a callback.
-
-	@sa XMLNode::Accept()
-*/
-class TINYXML2_LIB XMLVisitor
-{
-public:
-    virtual ~XMLVisitor() {}
-
-    /// Visit a document.
-    virtual bool VisitEnter( const XMLDocument& /*doc*/ )			{
-        return true;
-    }
-    /// Visit a document.
-    virtual bool VisitExit( const XMLDocument& /*doc*/ )			{
-        return true;
-    }
-
-    /// Visit an element.
-    virtual bool VisitEnter( const XMLElement& /*element*/, const XMLAttribute* /*firstAttribute*/ )	{
-        return true;
-    }
-    /// Visit an element.
-    virtual bool VisitExit( const XMLElement& /*element*/ )			{
-        return true;
-    }
-
-    /// Visit a declaration.
-    virtual bool Visit( const XMLDeclaration& /*declaration*/ )		{
-        return true;
-    }
-    /// Visit a text node.
-    virtual bool Visit( const XMLText& /*text*/ )					{
-        return true;
-    }
-    /// Visit a comment node.
-    virtual bool Visit( const XMLComment& /*comment*/ )				{
-        return true;
-    }
-    /// Visit an unknown node.
-    virtual bool Visit( const XMLUnknown& /*unknown*/ )				{
-        return true;
-    }
-};
-
-// WARNING: must match XMLDocument::_errorNames[]
-enum XMLError {
-    XML_SUCCESS = 0,
-    XML_NO_ATTRIBUTE,
-    XML_WRONG_ATTRIBUTE_TYPE,
-    XML_ERROR_FILE_NOT_FOUND,
-    XML_ERROR_FILE_COULD_NOT_BE_OPENED,
-    XML_ERROR_FILE_READ_ERROR,
-    UNUSED_XML_ERROR_ELEMENT_MISMATCH,	// remove at next major version
-    XML_ERROR_PARSING_ELEMENT,
-    XML_ERROR_PARSING_ATTRIBUTE,
-    UNUSED_XML_ERROR_IDENTIFYING_TAG,	// remove at next major version
-    XML_ERROR_PARSING_TEXT,
-    XML_ERROR_PARSING_CDATA,
-    XML_ERROR_PARSING_COMMENT,
-    XML_ERROR_PARSING_DECLARATION,
-    XML_ERROR_PARSING_UNKNOWN,
-    XML_ERROR_EMPTY_DOCUMENT,
-    XML_ERROR_MISMATCHED_ELEMENT,
-    XML_ERROR_PARSING,
-    XML_CAN_NOT_CONVERT_TEXT,
-    XML_NO_TEXT_NODE,
-
-	XML_ERROR_COUNT
-};
-
-
-/*
-	Utility functionality.
-*/
-class TINYXML2_LIB XMLUtil
-{
-public:
-    static const char* SkipWhiteSpace( const char* p, int* curLineNumPtr )	{
-        TIXMLASSERT( p );
-
-        while( IsWhiteSpace(*p) ) {
-            if (curLineNumPtr && *p == '\n') {
-                ++(*curLineNumPtr);
-            }
-            ++p;
-        }
-        TIXMLASSERT( p );
-        return p;
-    }
-    static char* SkipWhiteSpace( char* p, int* curLineNumPtr )				{
-        return const_cast<char*>( SkipWhiteSpace( const_cast<const char*>(p), curLineNumPtr ) );
-    }
-
-    // Anything in the high order range of UTF-8 is assumed to not be whitespace. This isn't
-    // correct, but simple, and usually works.
-    static bool IsWhiteSpace( char p )					{
-        return !IsUTF8Continuation(p) && isspace( static_cast<unsigned char>(p) );
-    }
-    
-    inline static bool IsNameStartChar( unsigned char ch ) {
-        if ( ch >= 128 ) {
-            // This is a heuristic guess in attempt to not implement Unicode-aware isalpha()
-            return true;
-        }
-        if ( isalpha( ch ) ) {
-            return true;
-        }
-        return ch == ':' || ch == '_';
-    }
-    
-    inline static bool IsNameChar( unsigned char ch ) {
-        return IsNameStartChar( ch )
-               || isdigit( ch )
-               || ch == '.'
-               || ch == '-';
-    }
-
-    inline static bool StringEqual( const char* p, const char* q, int nChar=INT_MAX )  {
-        if ( p == q ) {
-            return true;
-        }
-        TIXMLASSERT( p );
-        TIXMLASSERT( q );
-        TIXMLASSERT( nChar >= 0 );
-        return strncmp( p, q, nChar ) == 0;
-    }
-    
-    inline static bool IsUTF8Continuation( char p ) {
-        return ( p & 0x80 ) != 0;
-    }
-
-    static const char* ReadBOM( const char* p, bool* hasBOM );
-    // p is the starting location,
-    // the UTF-8 value of the entity will be placed in value, and length filled in.
-    static const char* GetCharacterRef( const char* p, char* value, int* length );
-    static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );
-
-    // converts primitive types to strings
-    static void ToStr( int v, char* buffer, int bufferSize );
-    static void ToStr( unsigned v, char* buffer, int bufferSize );
-    static void ToStr( bool v, char* buffer, int bufferSize );
-    static void ToStr( float v, char* buffer, int bufferSize );
-    static void ToStr( double v, char* buffer, int bufferSize );
-	static void ToStr(int64_t v, char* buffer, int bufferSize);
-
-    // converts strings to primitive types
-    static bool	ToInt( const char* str, int* value );
-    static bool ToUnsigned( const char* str, unsigned* value );
-    static bool	ToBool( const char* str, bool* value );
-    static bool	ToFloat( const char* str, float* value );
-    static bool ToDouble( const char* str, double* value );
-	static bool ToInt64(const char* str, int64_t* value);
-
-	// Changes what is serialized for a boolean value.
-	// Default to "true" and "false". Shouldn't be changed
-	// unless you have a special testing or compatibility need.
-	// Be careful: static, global, & not thread safe.
-	// Be sure to set static const memory as parameters.
-	static void SetBoolSerialization(const char* writeTrue, const char* writeFalse);
-
-private:
-	static const char* writeBoolTrue;
-	static const char* writeBoolFalse;
-};
-
-
-/** XMLNode is a base class for every object that is in the
-	XML Document Object Model (DOM), except XMLAttributes.
-	Nodes have siblings, a parent, and children which can
-	be navigated. A node is always in a XMLDocument.
-	The type of a XMLNode can be queried, and it can
-	be cast to its more defined type.
-
-	A XMLDocument allocates memory for all its Nodes.
-	When the XMLDocument gets deleted, all its Nodes
-	will also be deleted.
-
-	@verbatim
-	A Document can contain:	Element	(container or leaf)
-							Comment (leaf)
-							Unknown (leaf)
-							Declaration( leaf )
-
-	An Element can contain:	Element (container or leaf)
-							Text	(leaf)
-							Attributes (not on tree)
-							Comment (leaf)
-							Unknown (leaf)
-
-	@endverbatim
-*/
-class TINYXML2_LIB XMLNode
-{
-    friend class XMLDocument;
-    friend class XMLElement;
-public:
-
-    /// Get the XMLDocument that owns this XMLNode.
-    const XMLDocument* GetDocument() const	{
-        TIXMLASSERT( _document );
-        return _document;
-    }
-    /// Get the XMLDocument that owns this XMLNode.
-    XMLDocument* GetDocument()				{
-        TIXMLASSERT( _document );
-        return _document;
-    }
-
-    /// Safely cast to an Element, or null.
-    virtual XMLElement*		ToElement()		{
-        return 0;
-    }
-    /// Safely cast to Text, or null.
-    virtual XMLText*		ToText()		{
-        return 0;
-    }
-    /// Safely cast to a Comment, or null.
-    virtual XMLComment*		ToComment()		{
-        return 0;
-    }
-    /// Safely cast to a Document, or null.
-    virtual XMLDocument*	ToDocument()	{
-        return 0;
-    }
-    /// Safely cast to a Declaration, or null.
-    virtual XMLDeclaration*	ToDeclaration()	{
-        return 0;
-    }
-    /// Safely cast to an Unknown, or null.
-    virtual XMLUnknown*		ToUnknown()		{
-        return 0;
-    }
-
-    virtual const XMLElement*		ToElement() const		{
-        return 0;
-    }
-    virtual const XMLText*			ToText() const			{
-        return 0;
-    }
-    virtual const XMLComment*		ToComment() const		{
-        return 0;
-    }
-    virtual const XMLDocument*		ToDocument() const		{
-        return 0;
-    }
-    virtual const XMLDeclaration*	ToDeclaration() const	{
-        return 0;
-    }
-    virtual const XMLUnknown*		ToUnknown() const		{
-        return 0;
-    }
-
-    /** The meaning of 'value' changes for the specific type.
-    	@verbatim
-    	Document:	empty (NULL is returned, not an empty string)
-    	Element:	name of the element
-    	Comment:	the comment text
-    	Unknown:	the tag contents
-    	Text:		the text string
-    	@endverbatim
-    */
-    const char* Value() const;
-
-    /** Set the Value of an XML node.
-    	@sa Value()
-    */
-    void SetValue( const char* val, bool staticMem=false );
-
-    /// Gets the line number the node is in, if the document was parsed from a file.
-    int GetLineNum() const { return _parseLineNum; }
-
-    /// Get the parent of this node on the DOM.
-    const XMLNode*	Parent() const			{
-        return _parent;
-    }
-
-    XMLNode* Parent()						{
-        return _parent;
-    }
-
-    /// Returns true if this node has no children.
-    bool NoChildren() const					{
-        return !_firstChild;
-    }
-
-    /// Get the first child node, or null if none exists.
-    const XMLNode*  FirstChild() const		{
-        return _firstChild;
-    }
-
-    XMLNode*		FirstChild()			{
-        return _firstChild;
-    }
-
-    /** Get the first child element, or optionally the first child
-        element with the specified name.
-    */
-    const XMLElement* FirstChildElement( const char* name = 0 ) const;
-
-    XMLElement* FirstChildElement( const char* name = 0 )	{
-        return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->FirstChildElement( name ));
-    }
-
-    /// Get the last child node, or null if none exists.
-    const XMLNode*	LastChild() const						{
-        return _lastChild;
-    }
-
-    XMLNode*		LastChild()								{
-        return _lastChild;
-    }
-
-    /** Get the last child element or optionally the last child
-        element with the specified name.
-    */
-    const XMLElement* LastChildElement( const char* name = 0 ) const;
-
-    XMLElement* LastChildElement( const char* name = 0 )	{
-        return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->LastChildElement(name) );
-    }
-
-    /// Get the previous (left) sibling node of this node.
-    const XMLNode*	PreviousSibling() const					{
-        return _prev;
-    }
-
-    XMLNode*	PreviousSibling()							{
-        return _prev;
-    }
-
-    /// Get the previous (left) sibling element of this node, with an optionally supplied name.
-    const XMLElement*	PreviousSiblingElement( const char* name = 0 ) const ;
-
-    XMLElement*	PreviousSiblingElement( const char* name = 0 ) {
-        return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->PreviousSiblingElement( name ) );
-    }
-
-    /// Get the next (right) sibling node of this node.
-    const XMLNode*	NextSibling() const						{
-        return _next;
-    }
-
-    XMLNode*	NextSibling()								{
-        return _next;
-    }
-
-    /// Get the next (right) sibling element of this node, with an optionally supplied name.
-    const XMLElement*	NextSiblingElement( const char* name = 0 ) const;
-
-    XMLElement*	NextSiblingElement( const char* name = 0 )	{
-        return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->NextSiblingElement( name ) );
-    }
-
-    /**
-    	Add a child node as the last (right) child.
-		If the child node is already part of the document,
-		it is moved from its old location to the new location.
-		Returns the addThis argument or 0 if the node does not
-		belong to the same document.
-    */
-    XMLNode* InsertEndChild( XMLNode* addThis );
-
-    XMLNode* LinkEndChild( XMLNode* addThis )	{
-        return InsertEndChild( addThis );
-    }
-    /**
-    	Add a child node as the first (left) child.
-		If the child node is already part of the document,
-		it is moved from its old location to the new location.
-		Returns the addThis argument or 0 if the node does not
-		belong to the same document.
-    */
-    XMLNode* InsertFirstChild( XMLNode* addThis );
-    /**
-    	Add a node after the specified child node.
-		If the child node is already part of the document,
-		it is moved from its old location to the new location.
-		Returns the addThis argument or 0 if the afterThis node
-		is not a child of this node, or if the node does not
-		belong to the same document.
-    */
-    XMLNode* InsertAfterChild( XMLNode* afterThis, XMLNode* addThis );
-
-    /**
-    	Delete all the children of this node.
-    */
-    void DeleteChildren();
-
-    /**
-    	Delete a child of this node.
-    */
-    void DeleteChild( XMLNode* node );
-
-    /**
-    	Make a copy of this node, but not its children.
-    	You may pass in a Document pointer that will be
-    	the owner of the new Node. If the 'document' is
-    	null, then the node returned will be allocated
-    	from the current Document. (this->GetDocument())
-
-    	Note: if called on a XMLDocument, this will return null.
-    */
-    virtual XMLNode* ShallowClone( XMLDocument* document ) const = 0;
-
-	/**
-		Make a copy of this node and all its children.
-
-		If the 'target' is null, then the nodes will
-		be allocated in the current document. If 'target' 
-        is specified, the memory will be allocated is the 
-        specified XMLDocument.
-
-		NOTE: This is probably not the correct tool to 
-		copy a document, since XMLDocuments can have multiple
-		top level XMLNodes. You probably want to use
-        XMLDocument::DeepCopy()
-	*/
-	XMLNode* DeepClone( XMLDocument* target ) const;
-
-    /**
-    	Test if 2 nodes are the same, but don't test children.
-    	The 2 nodes do not need to be in the same Document.
-
-    	Note: if called on a XMLDocument, this will return false.
-    */
-    virtual bool ShallowEqual( const XMLNode* compare ) const = 0;
-
-    /** Accept a hierarchical visit of the nodes in the TinyXML-2 DOM. Every node in the
-    	XML tree will be conditionally visited and the host will be called back
-    	via the XMLVisitor interface.
-
-    	This is essentially a SAX interface for TinyXML-2. (Note however it doesn't re-parse
-    	the XML for the callbacks, so the performance of TinyXML-2 is unchanged by using this
-    	interface versus any other.)
-
-    	The interface has been based on ideas from:
-
-    	- http://www.saxproject.org/
-    	- http://c2.com/cgi/wiki?HierarchicalVisitorPattern
-
-    	Which are both good references for "visiting".
-
-    	An example of using Accept():
-    	@verbatim
-    	XMLPrinter printer;
-    	tinyxmlDoc.Accept( &printer );
-    	const char* xmlcstr = printer.CStr();
-    	@endverbatim
-    */
-    virtual bool Accept( XMLVisitor* visitor ) const = 0;
-
-	/** 
-		Set user data into the XMLNode. TinyXML-2 in 
-		no way processes or interprets user data.
-		It is initially 0.
-	*/
-	void SetUserData(void* userData)	{ _userData = userData; }
-
-	/**
-		Get user data set into the XMLNode. TinyXML-2 in
-		no way processes or interprets user data.
-		It is initially 0.
-	*/
-	void* GetUserData() const			{ return _userData; }
-
-protected:
-    XMLNode( XMLDocument* );
-    virtual ~XMLNode();
-
-    virtual char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr);
-
-    XMLDocument*	_document;
-    XMLNode*		_parent;
-    mutable StrPair	_value;
-    int             _parseLineNum;
-
-    XMLNode*		_firstChild;
-    XMLNode*		_lastChild;
-
-    XMLNode*		_prev;
-    XMLNode*		_next;
-
-	void*			_userData;
-
-private:
-    MemPool*		_memPool;
-    void Unlink( XMLNode* child );
-    static void DeleteNode( XMLNode* node );
-    void InsertChildPreamble( XMLNode* insertThis ) const;
-    const XMLElement* ToElementWithName( const char* name ) const;
-
-    XMLNode( const XMLNode& );	// not supported
-    XMLNode& operator=( const XMLNode& );	// not supported
-};
-
-
-/** XML text.
-
-	Note that a text node can have child element nodes, for example:
-	@verbatim
-	<root>This is <b>bold</b></root>
-	@endverbatim
-
-	A text node can have 2 ways to output the next. "normal" output
-	and CDATA. It will default to the mode it was parsed from the XML file and
-	you generally want to leave it alone, but you can change the output mode with
-	SetCData() and query it with CData().
-*/
-class TINYXML2_LIB XMLText : public XMLNode
-{
-    friend class XMLDocument;
-public:
-    virtual bool Accept( XMLVisitor* visitor ) const;
-
-    virtual XMLText* ToText()			{
-        return this;
-    }
-    virtual const XMLText* ToText() const	{
-        return this;
-    }
-
-    /// Declare whether this should be CDATA or standard text.
-    void SetCData( bool isCData )			{
-        _isCData = isCData;
-    }
-    /// Returns true if this is a CDATA text element.
-    bool CData() const						{
-        return _isCData;
-    }
-
-    virtual XMLNode* ShallowClone( XMLDocument* document ) const;
-    virtual bool ShallowEqual( const XMLNode* compare ) const;
-
-protected:
-    XMLText( XMLDocument* doc )	: XMLNode( doc ), _isCData( false )	{}
-    virtual ~XMLText()												{}
-
-    char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr );
-
-private:
-    bool _isCData;
-
-    XMLText( const XMLText& );	// not supported
-    XMLText& operator=( const XMLText& );	// not supported
-};
-
-
-/** An XML Comment. */
-class TINYXML2_LIB XMLComment : public XMLNode
-{
-    friend class XMLDocument;
-public:
-    virtual XMLComment*	ToComment()					{
-        return this;
-    }
-    virtual const XMLComment* ToComment() const		{
-        return this;
-    }
-
-    virtual bool Accept( XMLVisitor* visitor ) const;
-
-    virtual XMLNode* ShallowClone( XMLDocument* document ) const;
-    virtual bool ShallowEqual( const XMLNode* compare ) const;
-
-protected:
-    XMLComment( XMLDocument* doc );
-    virtual ~XMLComment();
-
-    char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr);
-
-private:
-    XMLComment( const XMLComment& );	// not supported
-    XMLComment& operator=( const XMLComment& );	// not supported
-};
-
-
-/** In correct XML the declaration is the first entry in the file.
-	@verbatim
-		<?xml version="1.0" standalone="yes"?>
-	@endverbatim
-
-	TinyXML-2 will happily read or write files without a declaration,
-	however.
-
-	The text of the declaration isn't interpreted. It is parsed
-	and written as a string.
-*/
-class TINYXML2_LIB XMLDeclaration : public XMLNode
-{
-    friend class XMLDocument;
-public:
-    virtual XMLDeclaration*	ToDeclaration()					{
-        return this;
-    }
-    virtual const XMLDeclaration* ToDeclaration() const		{
-        return this;
-    }
-
-    virtual bool Accept( XMLVisitor* visitor ) const;
-
-    virtual XMLNode* ShallowClone( XMLDocument* document ) const;
-    virtual bool ShallowEqual( const XMLNode* compare ) const;
-
-protected:
-    XMLDeclaration( XMLDocument* doc );
-    virtual ~XMLDeclaration();
-
-    char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr );
-
-private:
-    XMLDeclaration( const XMLDeclaration& );	// not supported
-    XMLDeclaration& operator=( const XMLDeclaration& );	// not supported
-};
-
-
-/** Any tag that TinyXML-2 doesn't recognize is saved as an
-	unknown. It is a tag of text, but should not be modified.
-	It will be written back to the XML, unchanged, when the file
-	is saved.
-
-	DTD tags get thrown into XMLUnknowns.
-*/
-class TINYXML2_LIB XMLUnknown : public XMLNode
-{
-    friend class XMLDocument;
-public:
-    virtual XMLUnknown*	ToUnknown()					{
-        return this;
-    }
-    virtual const XMLUnknown* ToUnknown() const		{
-        return this;
-    }
-
-    virtual bool Accept( XMLVisitor* visitor ) const;
-
-    virtual XMLNode* ShallowClone( XMLDocument* document ) const;
-    virtual bool ShallowEqual( const XMLNode* compare ) const;
-
-protected:
-    XMLUnknown( XMLDocument* doc );
-    virtual ~XMLUnknown();
-
-    char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr );
-
-private:
-    XMLUnknown( const XMLUnknown& );	// not supported
-    XMLUnknown& operator=( const XMLUnknown& );	// not supported
-};
-
-
-
-/** An attribute is a name-value pair. Elements have an arbitrary
-	number of attributes, each with a unique name.
-
-	@note The attributes are not XMLNodes. You may only query the
-	Next() attribute in a list.
-*/
-class TINYXML2_LIB XMLAttribute
-{
-    friend class XMLElement;
-public:
-    /// The name of the attribute.
-    const char* Name() const;
-
-    /// The value of the attribute.
-    const char* Value() const;
-
-    /// Gets the line number the attribute is in, if the document was parsed from a file.
-    int GetLineNum() const { return _parseLineNum; }
-
-    /// The next attribute in the list.
-    const XMLAttribute* Next() const {
-        return _next;
-    }
-
-    /** IntValue interprets the attribute as an integer, and returns the value.
-        If the value isn't an integer, 0 will be returned. There is no error checking;
-    	use QueryIntValue() if you need error checking.
-    */
-	int	IntValue() const {
-		int i = 0;
-		QueryIntValue(&i);
-		return i;
-	}
-
-	int64_t Int64Value() const {
-		int64_t i = 0;
-		QueryInt64Value(&i);
-		return i;
-	}
-
-    /// Query as an unsigned integer. See IntValue()
-    unsigned UnsignedValue() const			{
-        unsigned i=0;
-        QueryUnsignedValue( &i );
-        return i;
-    }
-    /// Query as a boolean. See IntValue()
-    bool	 BoolValue() const				{
-        bool b=false;
-        QueryBoolValue( &b );
-        return b;
-    }
-    /// Query as a double. See IntValue()
-    double 	 DoubleValue() const			{
-        double d=0;
-        QueryDoubleValue( &d );
-        return d;
-    }
-    /// Query as a float. See IntValue()
-    float	 FloatValue() const				{
-        float f=0;
-        QueryFloatValue( &f );
-        return f;
-    }
-
-    /** QueryIntValue interprets the attribute as an integer, and returns the value
-    	in the provided parameter. The function will return XML_SUCCESS on success,
-    	and XML_WRONG_ATTRIBUTE_TYPE if the conversion is not successful.
-    */
-    XMLError QueryIntValue( int* value ) const;
-    /// See QueryIntValue
-    XMLError QueryUnsignedValue( unsigned int* value ) const;
-	/// See QueryIntValue
-	XMLError QueryInt64Value(int64_t* value) const;
-	/// See QueryIntValue
-    XMLError QueryBoolValue( bool* value ) const;
-    /// See QueryIntValue
-    XMLError QueryDoubleValue( double* value ) const;
-    /// See QueryIntValue
-    XMLError QueryFloatValue( float* value ) const;
-
-    /// Set the attribute to a string value.
-    void SetAttribute( const char* value );
-    /// Set the attribute to value.
-    void SetAttribute( int value );
-    /// Set the attribute to value.
-    void SetAttribute( unsigned value );
-	/// Set the attribute to value.
-	void SetAttribute(int64_t value);
-	/// Set the attribute to value.
-    void SetAttribute( bool value );
-    /// Set the attribute to value.
-    void SetAttribute( double value );
-    /// Set the attribute to value.
-    void SetAttribute( float value );
-
-private:
-    enum { BUF_SIZE = 200 };
-
-    XMLAttribute() : _name(), _value(),_parseLineNum( 0 ), _next( 0 ), _memPool( 0 ) {}
-    virtual ~XMLAttribute()	{}
-
-    XMLAttribute( const XMLAttribute& );	// not supported
-    void operator=( const XMLAttribute& );	// not supported
-    void SetName( const char* name );
-
-    char* ParseDeep( char* p, bool processEntities, int* curLineNumPtr );
-
-    mutable StrPair _name;
-    mutable StrPair _value;
-    int             _parseLineNum;
-    XMLAttribute*   _next;
-    MemPool*        _memPool;
-};
-
-
-/** The element is a container class. It has a value, the element name,
-	and can contain other elements, text, comments, and unknowns.
-	Elements also contain an arbitrary number of attributes.
-*/
-class TINYXML2_LIB XMLElement : public XMLNode
-{
-    friend class XMLDocument;
-public:
-    /// Get the name of an element (which is the Value() of the node.)
-    const char* Name() const		{
-        return Value();
-    }
-    /// Set the name of the element.
-    void SetName( const char* str, bool staticMem=false )	{
-        SetValue( str, staticMem );
-    }
-
-    virtual XMLElement* ToElement()				{
-        return this;
-    }
-    virtual const XMLElement* ToElement() const {
-        return this;
-    }
-    virtual bool Accept( XMLVisitor* visitor ) const;
-
-    /** Given an attribute name, Attribute() returns the value
-    	for the attribute of that name, or null if none
-    	exists. For example:
-
-    	@verbatim
-    	const char* value = ele->Attribute( "foo" );
-    	@endverbatim
-
-    	The 'value' parameter is normally null. However, if specified,
-    	the attribute will only be returned if the 'name' and 'value'
-    	match. This allow you to write code:
-
-    	@verbatim
-    	if ( ele->Attribute( "foo", "bar" ) ) callFooIsBar();
-    	@endverbatim
-
-    	rather than:
-    	@verbatim
-    	if ( ele->Attribute( "foo" ) ) {
-    		if ( strcmp( ele->Attribute( "foo" ), "bar" ) == 0 ) callFooIsBar();
-    	}
-    	@endverbatim
-    */
-    const char* Attribute( const char* name, const char* value=0 ) const;
-
-    /** Given an attribute name, IntAttribute() returns the value
-    	of the attribute interpreted as an integer. The default
-        value will be returned if the attribute isn't present,
-        or if there is an error. (For a method with error
-    	checking, see QueryIntAttribute()).
-    */
-	int IntAttribute(const char* name, int defaultValue = 0) const;
-    /// See IntAttribute()
-	unsigned UnsignedAttribute(const char* name, unsigned defaultValue = 0) const;
-	/// See IntAttribute()
-	int64_t Int64Attribute(const char* name, int64_t defaultValue = 0) const;
-	/// See IntAttribute()
-	bool BoolAttribute(const char* name, bool defaultValue = false) const;
-    /// See IntAttribute()
-	double DoubleAttribute(const char* name, double defaultValue = 0) const;
-    /// See IntAttribute()
-	float FloatAttribute(const char* name, float defaultValue = 0) const;
-
-    /** Given an attribute name, QueryIntAttribute() returns
-    	XML_SUCCESS, XML_WRONG_ATTRIBUTE_TYPE if the conversion
-    	can't be performed, or XML_NO_ATTRIBUTE if the attribute
-    	doesn't exist. If successful, the result of the conversion
-    	will be written to 'value'. If not successful, nothing will
-    	be written to 'value'. This allows you to provide default
-    	value:
-
-    	@verbatim
-    	int value = 10;
-    	QueryIntAttribute( "foo", &value );		// if "foo" isn't found, value will still be 10
-    	@endverbatim
-    */
-    XMLError QueryIntAttribute( const char* name, int* value ) const				{
-        const XMLAttribute* a = FindAttribute( name );
-        if ( !a ) {
-            return XML_NO_ATTRIBUTE;
-        }
-        return a->QueryIntValue( value );
-    }
-
-	/// See QueryIntAttribute()
-    XMLError QueryUnsignedAttribute( const char* name, unsigned int* value ) const	{
-        const XMLAttribute* a = FindAttribute( name );
-        if ( !a ) {
-            return XML_NO_ATTRIBUTE;
-        }
-        return a->QueryUnsignedValue( value );
-    }
-
-	/// See QueryIntAttribute()
-	XMLError QueryInt64Attribute(const char* name, int64_t* value) const {
-		const XMLAttribute* a = FindAttribute(name);
-		if (!a) {
-			return XML_NO_ATTRIBUTE;
-		}
-		return a->QueryInt64Value(value);
-	}
-
-	/// See QueryIntAttribute()
-    XMLError QueryBoolAttribute( const char* name, bool* value ) const				{
-        const XMLAttribute* a = FindAttribute( name );
-        if ( !a ) {
-            return XML_NO_ATTRIBUTE;
-        }
-        return a->QueryBoolValue( value );
-    }
-    /// See QueryIntAttribute()
-    XMLError QueryDoubleAttribute( const char* name, double* value ) const			{
-        const XMLAttribute* a = FindAttribute( name );
-        if ( !a ) {
-            return XML_NO_ATTRIBUTE;
-        }
-        return a->QueryDoubleValue( value );
-    }
-    /// See QueryIntAttribute()
-    XMLError QueryFloatAttribute( const char* name, float* value ) const			{
-        const XMLAttribute* a = FindAttribute( name );
-        if ( !a ) {
-            return XML_NO_ATTRIBUTE;
-        }
-        return a->QueryFloatValue( value );
-    }
-
-	/// See QueryIntAttribute()
-	XMLError QueryStringAttribute(const char* name, const char** value) const {
-		const XMLAttribute* a = FindAttribute(name);
-		if (!a) {
-			return XML_NO_ATTRIBUTE;
-		}
-		*value = a->Value();
-		return XML_SUCCESS;
-	}
-
-
-	
-    /** Given an attribute name, QueryAttribute() returns
-    	XML_SUCCESS, XML_WRONG_ATTRIBUTE_TYPE if the conversion
-    	can't be performed, or XML_NO_ATTRIBUTE if the attribute
-    	doesn't exist. It is overloaded for the primitive types,
-		and is a generally more convenient replacement of
-		QueryIntAttribute() and related functions.
-		
-		If successful, the result of the conversion
-    	will be written to 'value'. If not successful, nothing will
-    	be written to 'value'. This allows you to provide default
-    	value:
-
-    	@verbatim
-    	int value = 10;
-    	QueryAttribute( "foo", &value );		// if "foo" isn't found, value will still be 10
-    	@endverbatim
-    */
-	int QueryAttribute( const char* name, int* value ) const {
-		return QueryIntAttribute( name, value );
-	}
-
-	int QueryAttribute( const char* name, unsigned int* value ) const {
-		return QueryUnsignedAttribute( name, value );
-	}
-
-	int QueryAttribute(const char* name, int64_t* value) const {
-		return QueryInt64Attribute(name, value);
-	}
-
-	int QueryAttribute( const char* name, bool* value ) const {
-		return QueryBoolAttribute( name, value );
-	}
-
-	int QueryAttribute( const char* name, double* value ) const {
-		return QueryDoubleAttribute( name, value );
-	}
-
-	int QueryAttribute( const char* name, float* value ) const {
-		return QueryFloatAttribute( name, value );
-	}
-
-	/// Sets the named attribute to value.
-    void SetAttribute( const char* name, const char* value )	{
-        XMLAttribute* a = FindOrCreateAttribute( name );
-        a->SetAttribute( value );
-    }
-    /// Sets the named attribute to value.
-    void SetAttribute( const char* name, int value )			{
-        XMLAttribute* a = FindOrCreateAttribute( name );
-        a->SetAttribute( value );
-    }
-    /// Sets the named attribute to value.
-    void SetAttribute( const char* name, unsigned value )		{
-        XMLAttribute* a = FindOrCreateAttribute( name );
-        a->SetAttribute( value );
-    }
-
-	/// Sets the named attribute to value.
-	void SetAttribute(const char* name, int64_t value) {
-		XMLAttribute* a = FindOrCreateAttribute(name);
-		a->SetAttribute(value);
-	}
-
-	/// Sets the named attribute to value.
-    void SetAttribute( const char* name, bool value )			{
-        XMLAttribute* a = FindOrCreateAttribute( name );
-        a->SetAttribute( value );
-    }
-    /// Sets the named attribute to value.
-    void SetAttribute( const char* name, double value )		{
-        XMLAttribute* a = FindOrCreateAttribute( name );
-        a->SetAttribute( value );
-    }
-    /// Sets the named attribute to value.
-    void SetAttribute( const char* name, float value )		{
-        XMLAttribute* a = FindOrCreateAttribute( name );
-        a->SetAttribute( value );
-    }
-
-    /**
-    	Delete an attribute.
-    */
-    void DeleteAttribute( const char* name );
-
-    /// Return the first attribute in the list.
-    const XMLAttribute* FirstAttribute() const {
-        return _rootAttribute;
-    }
-    /// Query a specific attribute in the list.
-    const XMLAttribute* FindAttribute( const char* name ) const;
-
-    /** Convenience function for easy access to the text inside an element. Although easy
-    	and concise, GetText() is limited compared to getting the XMLText child
-    	and accessing it directly.
-
-    	If the first child of 'this' is a XMLText, the GetText()
-    	returns the character string of the Text node, else null is returned.
-
-    	This is a convenient method for getting the text of simple contained text:
-    	@verbatim
-    	<foo>This is text</foo>
-    		const char* str = fooElement->GetText();
-    	@endverbatim
-
-    	'str' will be a pointer to "This is text".
-
-    	Note that this function can be misleading. If the element foo was created from
-    	this XML:
-    	@verbatim
-    		<foo><b>This is text</b></foo>
-    	@endverbatim
-
-    	then the value of str would be null. The first child node isn't a text node, it is
-    	another element. From this XML:
-    	@verbatim
-    		<foo>This is <b>text</b></foo>
-    	@endverbatim
-    	GetText() will return "This is ".
-    */
-    const char* GetText() const;
-
-    /** Convenience function for easy access to the text inside an element. Although easy
-    	and concise, SetText() is limited compared to creating an XMLText child
-    	and mutating it directly.
-
-    	If the first child of 'this' is a XMLText, SetText() sets its value to
-		the given string, otherwise it will create a first child that is an XMLText.
-
-    	This is a convenient method for setting the text of simple contained text:
-    	@verbatim
-    	<foo>This is text</foo>
-    		fooElement->SetText( "Hullaballoo!" );
-     	<foo>Hullaballoo!</foo>
-		@endverbatim
-
-    	Note that this function can be misleading. If the element foo was created from
-    	this XML:
-    	@verbatim
-    		<foo><b>This is text</b></foo>
-    	@endverbatim
-
-    	then it will not change "This is text", but rather prefix it with a text element:
-    	@verbatim
-    		<foo>Hullaballoo!<b>This is text</b></foo>
-    	@endverbatim
-		
-		For this XML:
-    	@verbatim
-    		<foo />
-    	@endverbatim
-    	SetText() will generate
-    	@verbatim
-    		<foo>Hullaballoo!</foo>
-    	@endverbatim
-    */
-	void SetText( const char* inText );
-    /// Convenience method for setting text inside an element. See SetText() for important limitations.
-    void SetText( int value );
-    /// Convenience method for setting text inside an element. See SetText() for important limitations.
-    void SetText( unsigned value );  
-	/// Convenience method for setting text inside an element. See SetText() for important limitations.
-	void SetText(int64_t value);
-	/// Convenience method for setting text inside an element. See SetText() for important limitations.
-    void SetText( bool value );  
-    /// Convenience method for setting text inside an element. See SetText() for important limitations.
-    void SetText( double value );  
-    /// Convenience method for setting text inside an element. See SetText() for important limitations.
-    void SetText( float value );  
-
-    /**
-    	Convenience method to query the value of a child text node. This is probably best
-    	shown by example. Given you have a document is this form:
-    	@verbatim
-    		<point>
-    			<x>1</x>
-    			<y>1.4</y>
-    		</point>
-    	@endverbatim
-
-    	The QueryIntText() and similar functions provide a safe and easier way to get to the
-    	"value" of x and y.
-
-    	@verbatim
-    		int x = 0;
-    		float y = 0;	// types of x and y are contrived for example
-    		const XMLElement* xElement = pointElement->FirstChildElement( "x" );
-    		const XMLElement* yElement = pointElement->FirstChildElement( "y" );
-    		xElement->QueryIntText( &x );
-    		yElement->QueryFloatText( &y );
-    	@endverbatim
-
-    	@returns XML_SUCCESS (0) on success, XML_CAN_NOT_CONVERT_TEXT if the text cannot be converted
-    			 to the requested type, and XML_NO_TEXT_NODE if there is no child text to query.
-
-    */
-    XMLError QueryIntText( int* ival ) const;
-    /// See QueryIntText()
-    XMLError QueryUnsignedText( unsigned* uval ) const;
-	/// See QueryIntText()
-	XMLError QueryInt64Text(int64_t* uval) const;
-	/// See QueryIntText()
-    XMLError QueryBoolText( bool* bval ) const;
-    /// See QueryIntText()
-    XMLError QueryDoubleText( double* dval ) const;
-    /// See QueryIntText()
-    XMLError QueryFloatText( float* fval ) const;
-
-	int IntText(int defaultValue = 0) const;
-
-	/// See QueryIntText()
-	unsigned UnsignedText(unsigned defaultValue = 0) const;
-	/// See QueryIntText()
-	int64_t Int64Text(int64_t defaultValue = 0) const;
-	/// See QueryIntText()
-	bool BoolText(bool defaultValue = false) const;
-	/// See QueryIntText()
-	double DoubleText(double defaultValue = 0) const;
-	/// See QueryIntText()
-	float FloatText(float defaultValue = 0) const;
-
-    // internal:
-    enum ElementClosingType {
-        OPEN,		// <foo>
-        CLOSED,		// <foo/>
-        CLOSING		// </foo>
-    };
-    ElementClosingType ClosingType() const {
-        return _closingType;
-    }
-    virtual XMLNode* ShallowClone( XMLDocument* document ) const;
-    virtual bool ShallowEqual( const XMLNode* compare ) const;
-
-protected:
-    char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr );
-
-private:
-    XMLElement( XMLDocument* doc );
-    virtual ~XMLElement();
-    XMLElement( const XMLElement& );	// not supported
-    void operator=( const XMLElement& );	// not supported
-
-    XMLAttribute* FindAttribute( const char* name ) {
-        return const_cast<XMLAttribute*>(const_cast<const XMLElement*>(this)->FindAttribute( name ));
-    }
-    XMLAttribute* FindOrCreateAttribute( const char* name );
-    //void LinkAttribute( XMLAttribute* attrib );
-    char* ParseAttributes( char* p, int* curLineNumPtr );
-    static void DeleteAttribute( XMLAttribute* attribute );
-    XMLAttribute* CreateAttribute();
-
-    enum { BUF_SIZE = 200 };
-    ElementClosingType _closingType;
-    // The attribute list is ordered; there is no 'lastAttribute'
-    // because the list needs to be scanned for dupes before adding
-    // a new attribute.
-    XMLAttribute* _rootAttribute;
-};
-
-
-enum Whitespace {
-    PRESERVE_WHITESPACE,
-    COLLAPSE_WHITESPACE
-};
-
-
-/** A Document binds together all the functionality.
-	It can be saved, loaded, and printed to the screen.
-	All Nodes are connected and allocated to a Document.
-	If the Document is deleted, all its Nodes are also deleted.
-*/
-class TINYXML2_LIB XMLDocument : public XMLNode
-{
-    friend class XMLElement;
-    // Gives access to SetError, but over-access for everything else.
-    // Wishing C++ had "internal" scope.
-    friend class XMLNode;       
-    friend class XMLText;
-    friend class XMLComment;
-    friend class XMLDeclaration;
-    friend class XMLUnknown;
-public:
-    /// constructor
-    XMLDocument( bool processEntities = true, Whitespace whitespaceMode = PRESERVE_WHITESPACE );
-    ~XMLDocument();
-
-    virtual XMLDocument* ToDocument()				{
-        TIXMLASSERT( this == _document );
-        return this;
-    }
-    virtual const XMLDocument* ToDocument() const	{
-        TIXMLASSERT( this == _document );
-        return this;
-    }
-
-    /**
-    	Parse an XML file from a character string.
-    	Returns XML_SUCCESS (0) on success, or
-    	an errorID.
-
-    	You may optionally pass in the 'nBytes', which is
-    	the number of bytes which will be parsed. If not
-    	specified, TinyXML-2 will assume 'xml' points to a
-    	null terminated string.
-    */
-    XMLError Parse( const char* xml, size_t nBytes=(size_t)(-1) );
-
-    /**
-    	Load an XML file from disk.
-    	Returns XML_SUCCESS (0) on success, or
-    	an errorID.
-    */
-    XMLError LoadFile( const char* filename );
-
-    /**
-    	Load an XML file from disk. You are responsible
-    	for providing and closing the FILE*. 
-     
-        NOTE: The file should be opened as binary ("rb")
-        not text in order for TinyXML-2 to correctly
-        do newline normalization.
-
-    	Returns XML_SUCCESS (0) on success, or
-    	an errorID.
-    */
-    XMLError LoadFile( FILE* );
-
-    /**
-    	Save the XML file to disk.
-    	Returns XML_SUCCESS (0) on success, or
-    	an errorID.
-    */
-    XMLError SaveFile( const char* filename, bool compact = false );
-
-    /**
-    	Save the XML file to disk. You are responsible
-    	for providing and closing the FILE*.
-
-    	Returns XML_SUCCESS (0) on success, or
-    	an errorID.
-    */
-    XMLError SaveFile( FILE* fp, bool compact = false );
-
-    bool ProcessEntities() const		{
-        return _processEntities;
-    }
-    Whitespace WhitespaceMode() const	{
-        return _whitespaceMode;
-    }
-
-    /**
-    	Returns true if this document has a leading Byte Order Mark of UTF8.
-    */
-    bool HasBOM() const {
-        return _writeBOM;
-    }
-    /** Sets whether to write the BOM when writing the file.
-    */
-    void SetBOM( bool useBOM ) {
-        _writeBOM = useBOM;
-    }
-
-    /** Return the root element of DOM. Equivalent to FirstChildElement().
-        To get the first node, use FirstChild().
-    */
-    XMLElement* RootElement()				{
-        return FirstChildElement();
-    }
-    const XMLElement* RootElement() const	{
-        return FirstChildElement();
-    }
-
-    /** Print the Document. If the Printer is not provided, it will
-        print to stdout. If you provide Printer, this can print to a file:
-    	@verbatim
-    	XMLPrinter printer( fp );
-    	doc.Print( &printer );
-    	@endverbatim
-
-    	Or you can use a printer to print to memory:
-    	@verbatim
-    	XMLPrinter printer;
-    	doc.Print( &printer );
-    	// printer.CStr() has a const char* to the XML
-    	@endverbatim
-    */
-    void Print( XMLPrinter* streamer=0 ) const;
-    virtual bool Accept( XMLVisitor* visitor ) const;
-
-    /**
-    	Create a new Element associated with
-    	this Document. The memory for the Element
-    	is managed by the Document.
-    */
-    XMLElement* NewElement( const char* name );
-    /**
-    	Create a new Comment associated with
-    	this Document. The memory for the Comment
-    	is managed by the Document.
-    */
-    XMLComment* NewComment( const char* comment );
-    /**
-    	Create a new Text associated with
-    	this Document. The memory for the Text
-    	is managed by the Document.
-    */
-    XMLText* NewText( const char* text );
-    /**
-    	Create a new Declaration associated with
-    	this Document. The memory for the object
-    	is managed by the Document.
-
-    	If the 'text' param is null, the standard
-    	declaration is used.:
-    	@verbatim
-    		<?xml version="1.0" encoding="UTF-8"?>
-    	@endverbatim
-    */
-    XMLDeclaration* NewDeclaration( const char* text=0 );
-    /**
-    	Create a new Unknown associated with
-    	this Document. The memory for the object
-    	is managed by the Document.
-    */
-    XMLUnknown* NewUnknown( const char* text );
-
-    /**
-    	Delete a node associated with this document.
-    	It will be unlinked from the DOM.
-    */
-    void DeleteNode( XMLNode* node );
-
-    void ClearError() {
-        SetError(XML_SUCCESS, 0, 0);
-    }
-
-    /// Return true if there was an error parsing the document.
-    bool Error() const {
-        return _errorID != XML_SUCCESS;
-    }
-    /// Return the errorID.
-    XMLError  ErrorID() const {
-        return _errorID;
-    }
-	const char* ErrorName() const;
-    static const char* ErrorIDToName(XMLError errorID);
-
-    /** Returns a "long form" error description. A hopefully helpful 
-        diagnostic with location, line number, and/or additional info.
-    */
-	const char* ErrorStr() const;
-
-    /// A (trivial) utility function that prints the ErrorStr() to stdout.
-    void PrintError() const;
-
-    /// Return the line where the error occurred, or zero if unknown.
-    int ErrorLineNum() const
-    {
-        return _errorLineNum;
-    }
-    
-    /// Clear the document, resetting it to the initial state.
-    void Clear();
-
-	/**
-		Copies this document to a target document.
-		The target will be completely cleared before the copy.
-		If you want to copy a sub-tree, see XMLNode::DeepClone().
-
-		NOTE: that the 'target' must be non-null.
-	*/
-	void DeepCopy(XMLDocument* target) const;
-
-	// internal
-    char* Identify( char* p, XMLNode** node );
-
-	// internal
-	void MarkInUse(XMLNode*);
-
-    virtual XMLNode* ShallowClone( XMLDocument* /*document*/ ) const	{
-        return 0;
-    }
-    virtual bool ShallowEqual( const XMLNode* /*compare*/ ) const	{
-        return false;
-    }
-
-private:
-    XMLDocument( const XMLDocument& );	// not supported
-    void operator=( const XMLDocument& );	// not supported
-
-    bool			_writeBOM;
-    bool			_processEntities;
-    XMLError		_errorID;
-    Whitespace		_whitespaceMode;
-    mutable StrPair	_errorStr;
-    int             _errorLineNum;
-    char*			_charBuffer;
-    int				_parseCurLineNum;
-	// Memory tracking does add some overhead.
-	// However, the code assumes that you don't
-	// have a bunch of unlinked nodes around.
-	// Therefore it takes less memory to track
-	// in the document vs. a linked list in the XMLNode,
-	// and the performance is the same.
-	DynArray<XMLNode*, 10> _unlinked;
-
-    MemPoolT< sizeof(XMLElement) >	 _elementPool;
-    MemPoolT< sizeof(XMLAttribute) > _attributePool;
-    MemPoolT< sizeof(XMLText) >		 _textPool;
-    MemPoolT< sizeof(XMLComment) >	 _commentPool;
-
-	static const char* _errorNames[XML_ERROR_COUNT];
-
-    void Parse();
-
-    void SetError( XMLError error, int lineNum, const char* format, ... );
-
-    template<class NodeType, int PoolElementSize>
-    NodeType* CreateUnlinkedNode( MemPoolT<PoolElementSize>& pool );
-};
-
-template<class NodeType, int PoolElementSize>
-inline NodeType* XMLDocument::CreateUnlinkedNode( MemPoolT<PoolElementSize>& pool )
-{
-    TIXMLASSERT( sizeof( NodeType ) == PoolElementSize );
-    TIXMLASSERT( sizeof( NodeType ) == pool.ItemSize() );
-    NodeType* returnNode = new (pool.Alloc()) NodeType( this );
-    TIXMLASSERT( returnNode );
-    returnNode->_memPool = &pool;
-
-	_unlinked.Push(returnNode);
-    return returnNode;
-}
-
-/**
-	A XMLHandle is a class that wraps a node pointer with null checks; this is
-	an incredibly useful thing. Note that XMLHandle is not part of the TinyXML-2
-	DOM structure. It is a separate utility class.
-
-	Take an example:
-	@verbatim
-	<Document>
-		<Element attributeA = "valueA">
-			<Child attributeB = "value1" />
-			<Child attributeB = "value2" />
-		</Element>
-	</Document>
-	@endverbatim
-
-	Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very
-	easy to write a *lot* of code that looks like:
-
-	@verbatim
-	XMLElement* root = document.FirstChildElement( "Document" );
-	if ( root )
-	{
-		XMLElement* element = root->FirstChildElement( "Element" );
-		if ( element )
-		{
-			XMLElement* child = element->FirstChildElement( "Child" );
-			if ( child )
-			{
-				XMLElement* child2 = child->NextSiblingElement( "Child" );
-				if ( child2 )
-				{
-					// Finally do something useful.
-	@endverbatim
-
-	And that doesn't even cover "else" cases. XMLHandle addresses the verbosity
-	of such code. A XMLHandle checks for null pointers so it is perfectly safe
-	and correct to use:
-
-	@verbatim
-	XMLHandle docHandle( &document );
-	XMLElement* child2 = docHandle.FirstChildElement( "Document" ).FirstChildElement( "Element" ).FirstChildElement().NextSiblingElement();
-	if ( child2 )
-	{
-		// do something useful
-	@endverbatim
-
-	Which is MUCH more concise and useful.
-
-	It is also safe to copy handles - internally they are nothing more than node pointers.
-	@verbatim
-	XMLHandle handleCopy = handle;
-	@endverbatim
-
-	See also XMLConstHandle, which is the same as XMLHandle, but operates on const objects.
-*/
-class TINYXML2_LIB XMLHandle
-{
-public:
-    /// Create a handle from any node (at any depth of the tree.) This can be a null pointer.
-    XMLHandle( XMLNode* node ) : _node( node ) {
-    }
-    /// Create a handle from a node.
-    XMLHandle( XMLNode& node ) : _node( &node ) {
-    }
-    /// Copy constructor
-    XMLHandle( const XMLHandle& ref ) : _node( ref._node ) {
-    }
-    /// Assignment
-    XMLHandle& operator=( const XMLHandle& ref )							{
-        _node = ref._node;
-        return *this;
-    }
-
-    /// Get the first child of this handle.
-    XMLHandle FirstChild() 													{
-        return XMLHandle( _node ? _node->FirstChild() : 0 );
-    }
-    /// Get the first child element of this handle.
-    XMLHandle FirstChildElement( const char* name = 0 )						{
-        return XMLHandle( _node ? _node->FirstChildElement( name ) : 0 );
-    }
-    /// Get the last child of this handle.
-    XMLHandle LastChild()													{
-        return XMLHandle( _node ? _node->LastChild() : 0 );
-    }
-    /// Get the last child element of this handle.
-    XMLHandle LastChildElement( const char* name = 0 )						{
-        return XMLHandle( _node ? _node->LastChildElement( name ) : 0 );
-    }
-    /// Get the previous sibling of this handle.
-    XMLHandle PreviousSibling()												{
-        return XMLHandle( _node ? _node->PreviousSibling() : 0 );
-    }
-    /// Get the previous sibling element of this handle.
-    XMLHandle PreviousSiblingElement( const char* name = 0 )				{
-        return XMLHandle( _node ? _node->PreviousSiblingElement( name ) : 0 );
-    }
-    /// Get the next sibling of this handle.
-    XMLHandle NextSibling()													{
-        return XMLHandle( _node ? _node->NextSibling() : 0 );
-    }
-    /// Get the next sibling element of this handle.
-    XMLHandle NextSiblingElement( const char* name = 0 )					{
-        return XMLHandle( _node ? _node->NextSiblingElement( name ) : 0 );
-    }
-
-    /// Safe cast to XMLNode. This can return null.
-    XMLNode* ToNode()							{
-        return _node;
-    }
-    /// Safe cast to XMLElement. This can return null.
-    XMLElement* ToElement() 					{
-        return ( _node ? _node->ToElement() : 0 );
-    }
-    /// Safe cast to XMLText. This can return null.
-    XMLText* ToText() 							{
-        return ( _node ? _node->ToText() : 0 );
-    }
-    /// Safe cast to XMLUnknown. This can return null.
-    XMLUnknown* ToUnknown() 					{
-        return ( _node ? _node->ToUnknown() : 0 );
-    }
-    /// Safe cast to XMLDeclaration. This can return null.
-    XMLDeclaration* ToDeclaration() 			{
-        return ( _node ? _node->ToDeclaration() : 0 );
-    }
-
-private:
-    XMLNode* _node;
-};
-
-
-/**
-	A variant of the XMLHandle class for working with const XMLNodes and Documents. It is the
-	same in all regards, except for the 'const' qualifiers. See XMLHandle for API.
-*/
-class TINYXML2_LIB XMLConstHandle
-{
-public:
-    XMLConstHandle( const XMLNode* node ) : _node( node ) {
-    }
-    XMLConstHandle( const XMLNode& node ) : _node( &node ) {
-    }
-    XMLConstHandle( const XMLConstHandle& ref ) : _node( ref._node ) {
-    }
-
-    XMLConstHandle& operator=( const XMLConstHandle& ref )							{
-        _node = ref._node;
-        return *this;
-    }
-
-    const XMLConstHandle FirstChild() const											{
-        return XMLConstHandle( _node ? _node->FirstChild() : 0 );
-    }
-    const XMLConstHandle FirstChildElement( const char* name = 0 ) const				{
-        return XMLConstHandle( _node ? _node->FirstChildElement( name ) : 0 );
-    }
-    const XMLConstHandle LastChild()	const										{
-        return XMLConstHandle( _node ? _node->LastChild() : 0 );
-    }
-    const XMLConstHandle LastChildElement( const char* name = 0 ) const				{
-        return XMLConstHandle( _node ? _node->LastChildElement( name ) : 0 );
-    }
-    const XMLConstHandle PreviousSibling() const									{
-        return XMLConstHandle( _node ? _node->PreviousSibling() : 0 );
-    }
-    const XMLConstHandle PreviousSiblingElement( const char* name = 0 ) const		{
-        return XMLConstHandle( _node ? _node->PreviousSiblingElement( name ) : 0 );
-    }
-    const XMLConstHandle NextSibling() const										{
-        return XMLConstHandle( _node ? _node->NextSibling() : 0 );
-    }
-    const XMLConstHandle NextSiblingElement( const char* name = 0 ) const			{
-        return XMLConstHandle( _node ? _node->NextSiblingElement( name ) : 0 );
-    }
-
-
-    const XMLNode* ToNode() const				{
-        return _node;
-    }
-    const XMLElement* ToElement() const			{
-        return ( _node ? _node->ToElement() : 0 );
-    }
-    const XMLText* ToText() const				{
-        return ( _node ? _node->ToText() : 0 );
-    }
-    const XMLUnknown* ToUnknown() const			{
-        return ( _node ? _node->ToUnknown() : 0 );
-    }
-    const XMLDeclaration* ToDeclaration() const	{
-        return ( _node ? _node->ToDeclaration() : 0 );
-    }
-
-private:
-    const XMLNode* _node;
-};
-
-
-/**
-	Printing functionality. The XMLPrinter gives you more
-	options than the XMLDocument::Print() method.
-
-	It can:
-	-# Print to memory.
-	-# Print to a file you provide.
-	-# Print XML without a XMLDocument.
-
-	Print to Memory
-
-	@verbatim
-	XMLPrinter printer;
-	doc.Print( &printer );
-	SomeFunction( printer.CStr() );
-	@endverbatim
-
-	Print to a File
-
-	You provide the file pointer.
-	@verbatim
-	XMLPrinter printer( fp );
-	doc.Print( &printer );
-	@endverbatim
-
-	Print without a XMLDocument
-
-	When loading, an XML parser is very useful. However, sometimes
-	when saving, it just gets in the way. The code is often set up
-	for streaming, and constructing the DOM is just overhead.
-
-	The Printer supports the streaming case. The following code
-	prints out a trivially simple XML file without ever creating
-	an XML document.
-
-	@verbatim
-	XMLPrinter printer( fp );
-	printer.OpenElement( "foo" );
-	printer.PushAttribute( "foo", "bar" );
-	printer.CloseElement();
-	@endverbatim
-*/
-class TINYXML2_LIB XMLPrinter : public XMLVisitor
-{
-public:
-    /** Construct the printer. If the FILE* is specified,
-    	this will print to the FILE. Else it will print
-    	to memory, and the result is available in CStr().
-    	If 'compact' is set to true, then output is created
-    	with only required whitespace and newlines.
-    */
-    XMLPrinter( FILE* file=0, bool compact = false, int depth = 0 );
-    virtual ~XMLPrinter()	{}
-
-    /** If streaming, write the BOM and declaration. */
-    void PushHeader( bool writeBOM, bool writeDeclaration );
-    /** If streaming, start writing an element.
-        The element must be closed with CloseElement()
-    */
-    void OpenElement( const char* name, bool compactMode=false );
-    /// If streaming, add an attribute to an open element.
-    void PushAttribute( const char* name, const char* value );
-    void PushAttribute( const char* name, int value );
-    void PushAttribute( const char* name, unsigned value );
-	void PushAttribute(const char* name, int64_t value);
-	void PushAttribute( const char* name, bool value );
-    void PushAttribute( const char* name, double value );
-    /// If streaming, close the Element.
-    virtual void CloseElement( bool compactMode=false );
-
-    /// Add a text node.
-    void PushText( const char* text, bool cdata=false );
-    /// Add a text node from an integer.
-    void PushText( int value );
-    /// Add a text node from an unsigned.
-    void PushText( unsigned value );
-	/// Add a text node from an unsigned.
-	void PushText(int64_t value);
-	/// Add a text node from a bool.
-    void PushText( bool value );
-    /// Add a text node from a float.
-    void PushText( float value );
-    /// Add a text node from a double.
-    void PushText( double value );
-
-    /// Add a comment
-    void PushComment( const char* comment );
-
-    void PushDeclaration( const char* value );
-    void PushUnknown( const char* value );
-
-    virtual bool VisitEnter( const XMLDocument& /*doc*/ );
-    virtual bool VisitExit( const XMLDocument& /*doc*/ )			{
-        return true;
-    }
-
-    virtual bool VisitEnter( const XMLElement& element, const XMLAttribute* attribute );
-    virtual bool VisitExit( const XMLElement& element );
-
-    virtual bool Visit( const XMLText& text );
-    virtual bool Visit( const XMLComment& comment );
-    virtual bool Visit( const XMLDeclaration& declaration );
-    virtual bool Visit( const XMLUnknown& unknown );
-
-    /**
-    	If in print to memory mode, return a pointer to
-    	the XML file in memory.
-    */
-    const char* CStr() const {
-        return _buffer.Mem();
-    }
-    /**
-    	If in print to memory mode, return the size
-    	of the XML file in memory. (Note the size returned
-    	includes the terminating null.)
-    */
-    int CStrSize() const {
-        return _buffer.Size();
-    }
-    /**
-    	If in print to memory mode, reset the buffer to the
-    	beginning.
-    */
-    void ClearBuffer() {
-        _buffer.Clear();
-        _buffer.Push(0);
-		_firstElement = true;
-    }
-
-protected:
-	virtual bool CompactMode( const XMLElement& )	{ return _compactMode; }
-
-	/** Prints out the space before an element. You may override to change
-	    the space and tabs used. A PrintSpace() override should call Print().
-	*/
-    virtual void PrintSpace( int depth );
-    void Print( const char* format, ... );
-    void Write( const char* data, size_t size );
-    inline void Write( const char* data )           { Write( data, strlen( data ) ); }
-    void Putc( char ch );
-
-    void SealElementIfJustOpened();
-    bool _elementJustOpened;
-    DynArray< const char*, 10 > _stack;
-
-private:
-    void PrintString( const char*, bool restrictedEntitySet );	// prints out, after detecting entities.
-
-    bool _firstElement;
-    FILE* _fp;
-    int _depth;
-    int _textDepth;
-    bool _processEntities;
-	bool _compactMode;
-
-    enum {
-        ENTITY_RANGE = 64,
-        BUF_SIZE = 200
-    };
-    bool _entityFlag[ENTITY_RANGE];
-    bool _restrictedEntityFlag[ENTITY_RANGE];
-
-    DynArray< char, 20 > _buffer;
-
-    // Prohibit cloning, intentionally not implemented
-    XMLPrinter( const XMLPrinter& );
-    XMLPrinter& operator=( const XMLPrinter& );
-};
-
-
-}	// tinyxml2
-
-#if defined(_MSC_VER)
-#   pragma warning(pop)
-#endif
-
-#endif // TINYXML2_INCLUDED
+/*
+Original code by Lee Thomason (www.grinninglizard.com)
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any
+damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any
+purpose, including commercial applications, and to alter it and
+redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must
+not claim that you wrote the original software. If you use this
+software in a product, an acknowledgment in the product documentation
+would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and
+must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution.
+*/
+
+#ifndef TINYXML2_INCLUDED
+#define TINYXML2_INCLUDED
+
+#if defined(ANDROID_NDK) || defined(__BORLANDC__) || defined(__QNXNTO__)
+#   include <ctype.h>
+#   include <limits.h>
+#   include <stdio.h>
+#   include <stdlib.h>
+#   include <string.h>
+#	if defined(__PS3__)
+#		include <stddef.h>
+#	endif
+#else
+#   include <cctype>
+#   include <climits>
+#   include <cstdio>
+#   include <cstdlib>
+#   include <cstring>
+#endif
+#include <stdint.h>
+
+/*
+	gcc:
+        g++ -Wall -DTINYXML2_DEBUG tinyxml2.cpp xmltest.cpp -o gccxmltest.exe
+
+    Formatting, Artistic Style:
+        AStyle.exe --style=1tbs --indent-switches --break-closing-brackets --indent-preprocessor tinyxml2.cpp tinyxml2.h
+*/
+
+#if defined( _DEBUG ) || defined (__DEBUG__)
+#   ifndef TINYXML2_DEBUG
+#       define TINYXML2_DEBUG
+#   endif
+#endif
+
+#ifdef _MSC_VER
+#   pragma warning(push)
+#   pragma warning(disable: 4251)
+#endif
+
+#ifdef _MSC_VER
+#   ifdef TINYXML2_EXPORT
+#       define TINYXML2_LIB __declspec(dllexport)
+#   elif defined(TINYXML2_IMPORT)
+#       define TINYXML2_LIB __declspec(dllimport)
+#   else
+#       define TINYXML2_LIB
+#   endif
+#elif __GNUC__ >= 4
+#   define TINYXML2_LIB __attribute__((visibility("default")))
+#else
+#   define TINYXML2_LIB
+#endif
+
+
+#if !defined(TIXMLASSERT)
+#if defined(TINYXML2_DEBUG)
+#   if defined(_MSC_VER)
+#       // "(void)0," is for suppressing C4127 warning in "assert(false)", "assert(true)" and the like
+#       define TIXMLASSERT( x )           do { if ( !((void)0,(x))) { __debugbreak(); } } while(false)
+#   elif defined (ANDROID_NDK)
+#       include <android/log.h>
+#       define TIXMLASSERT( x )           do { if ( !(x)) { __android_log_assert( "assert", "grinliz", "ASSERT in '%s' at %d.", __FILE__, __LINE__ ); } } while(false)
+#   else
+#       include <assert.h>
+#       define TIXMLASSERT                assert
+#   endif
+#else
+#   define TIXMLASSERT( x )               do {} while(false)
+#endif
+#endif
+
+/* Versioning, past 1.0.14:
+	http://semver.org/
+*/
+static const int TIXML2_MAJOR_VERSION = 11;
+static const int TIXML2_MINOR_VERSION = 0;
+static const int TIXML2_PATCH_VERSION = 0;
+
+#define TINYXML2_MAJOR_VERSION 11
+#define TINYXML2_MINOR_VERSION 0
+#define TINYXML2_PATCH_VERSION 0
+
+// A fixed element depth limit is problematic. There needs to be a
+// limit to avoid a stack overflow. However, that limit varies per
+// system, and the capacity of the stack. On the other hand, it's a trivial
+// attack that can result from ill, malicious, or even correctly formed XML,
+// so there needs to be a limit in place.
+static const int TINYXML2_MAX_ELEMENT_DEPTH = 500;
+
+namespace tinyxml2
+{
+class XMLDocument;
+class XMLElement;
+class XMLAttribute;
+class XMLComment;
+class XMLText;
+class XMLDeclaration;
+class XMLUnknown;
+class XMLPrinter;
+
+/*
+	A class that wraps strings. Normally stores the start and end
+	pointers into the XML file itself, and will apply normalization
+	and entity translation if actually read. Can also store (and memory
+	manage) a traditional char[]
+
+    Isn't clear why TINYXML2_LIB is needed; but seems to fix #719
+*/
+class TINYXML2_LIB StrPair
+{
+public:
+    enum Mode {
+        NEEDS_ENTITY_PROCESSING			= 0x01,
+        NEEDS_NEWLINE_NORMALIZATION		= 0x02,
+        NEEDS_WHITESPACE_COLLAPSING     = 0x04,
+
+        TEXT_ELEMENT		            = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
+        TEXT_ELEMENT_LEAVE_ENTITIES		= NEEDS_NEWLINE_NORMALIZATION,
+        ATTRIBUTE_NAME		            = 0,
+        ATTRIBUTE_VALUE		            = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
+        ATTRIBUTE_VALUE_LEAVE_ENTITIES  = NEEDS_NEWLINE_NORMALIZATION,
+        COMMENT							= NEEDS_NEWLINE_NORMALIZATION
+    };
+
+    StrPair() : _flags( 0 ), _start( 0 ), _end( 0 ) {}
+    ~StrPair();
+
+    void Set( char* start, char* end, int flags ) {
+        TIXMLASSERT( start );
+        TIXMLASSERT( end );
+        Reset();
+        _start  = start;
+        _end    = end;
+        _flags  = flags | NEEDS_FLUSH;
+    }
+
+    const char* GetStr();
+
+    bool Empty() const {
+        return _start == _end;
+    }
+
+    void SetInternedStr( const char* str ) {
+        Reset();
+        _start = const_cast<char*>(str);
+    }
+
+    void SetStr( const char* str, int flags=0 );
+
+    char* ParseText( char* in, const char* endTag, int strFlags, int* curLineNumPtr );
+    char* ParseName( char* in );
+
+    void TransferTo( StrPair* other );
+	void Reset();
+
+private:
+    void CollapseWhitespace();
+
+    enum {
+        NEEDS_FLUSH = 0x100,
+        NEEDS_DELETE = 0x200
+    };
+
+    int     _flags;
+    char*   _start;
+    char*   _end;
+
+    StrPair( const StrPair& other );	// not supported
+    void operator=( const StrPair& other );	// not supported, use TransferTo()
+};
+
+
+/*
+	A dynamic array of Plain Old Data. Doesn't support constructors, etc.
+	Has a small initial memory pool, so that low or no usage will not
+	cause a call to new/delete
+*/
+template <class T, size_t INITIAL_SIZE>
+class DynArray
+{
+public:
+    DynArray() :
+        _mem( _pool ),
+        _allocated( INITIAL_SIZE ),
+        _size( 0 )
+    {
+    }
+
+    ~DynArray() {
+        if ( _mem != _pool ) {
+            delete [] _mem;
+        }
+    }
+
+    void Clear() {
+        _size = 0;
+    }
+
+    void Push( T t ) {
+        TIXMLASSERT( _size < INT_MAX );
+        EnsureCapacity( _size+1 );
+        _mem[_size] = t;
+        ++_size;
+    }
+
+    T* PushArr( size_t count ) {
+        TIXMLASSERT( _size <= SIZE_MAX - count );
+        EnsureCapacity( _size+count );
+        T* ret = &_mem[_size];
+        _size += count;
+        return ret;
+    }
+
+    T Pop() {
+        TIXMLASSERT( _size > 0 );
+        --_size;
+        return _mem[_size];
+    }
+
+    void PopArr( size_t count ) {
+        TIXMLASSERT( _size >= count );
+        _size -= count;
+    }
+
+    bool Empty() const					{
+        return _size == 0;
+    }
+
+    T& operator[](size_t i) {
+        TIXMLASSERT( i < _size );
+        return _mem[i];
+    }
+
+    const T& operator[](size_t i) const {
+        TIXMLASSERT( i < _size );
+        return _mem[i];
+    }
+
+    const T& PeekTop() const            {
+        TIXMLASSERT( _size > 0 );
+        return _mem[ _size - 1];
+    }
+
+    size_t Size() const {
+        TIXMLASSERT( _size >= 0 );
+        return _size;
+    }
+
+    size_t Capacity() const {
+        TIXMLASSERT( _allocated >= INITIAL_SIZE );
+        return _allocated;
+    }
+
+	void SwapRemove(size_t i) {
+		TIXMLASSERT(i < _size);
+		TIXMLASSERT(_size > 0);
+		_mem[i] = _mem[_size - 1];
+		--_size;
+	}
+
+    const T* Mem() const				{
+        TIXMLASSERT( _mem );
+        return _mem;
+    }
+
+    T* Mem() {
+        TIXMLASSERT( _mem );
+        return _mem;
+    }
+
+private:
+    DynArray( const DynArray& ); // not supported
+    void operator=( const DynArray& ); // not supported
+
+    void EnsureCapacity( size_t cap ) {
+        TIXMLASSERT( cap > 0 );
+        if ( cap > _allocated ) {
+            TIXMLASSERT( cap <= SIZE_MAX / 2 / sizeof(T));
+            const size_t newAllocated = cap * 2;
+            T* newMem = new T[newAllocated];
+            TIXMLASSERT( newAllocated >= _size );
+            memcpy( newMem, _mem, sizeof(T) * _size );	// warning: not using constructors, only works for PODs
+            if ( _mem != _pool ) {
+                delete [] _mem;
+            }
+            _mem = newMem;
+            _allocated = newAllocated;
+        }
+    }
+
+    T*  _mem;
+    T   _pool[INITIAL_SIZE];
+    size_t _allocated;		// objects allocated
+    size_t _size;			// number objects in use
+};
+
+
+/*
+	Parent virtual class of a pool for fast allocation
+	and deallocation of objects.
+*/
+class MemPool
+{
+public:
+    MemPool() {}
+    virtual ~MemPool() {}
+
+    virtual size_t ItemSize() const = 0;
+    virtual void* Alloc() = 0;
+    virtual void Free( void* ) = 0;
+    virtual void SetTracked() = 0;
+};
+
+
+/*
+	Template child class to create pools of the correct type.
+*/
+template< size_t ITEM_SIZE >
+class MemPoolT : public MemPool
+{
+public:
+    MemPoolT() : _blockPtrs(), _root(0), _currentAllocs(0), _nAllocs(0), _maxAllocs(0), _nUntracked(0)	{}
+    ~MemPoolT() {
+        MemPoolT< ITEM_SIZE >::Clear();
+    }
+
+    void Clear() {
+        // Delete the blocks.
+        while( !_blockPtrs.Empty()) {
+            Block* lastBlock = _blockPtrs.Pop();
+            delete lastBlock;
+        }
+        _root = 0;
+        _currentAllocs = 0;
+        _nAllocs = 0;
+        _maxAllocs = 0;
+        _nUntracked = 0;
+    }
+
+    virtual size_t ItemSize() const override {
+        return ITEM_SIZE;
+    }
+    size_t CurrentAllocs() const {
+        return _currentAllocs;
+    }
+
+    virtual void* Alloc() override{
+        if ( !_root ) {
+            // Need a new block.
+            Block* block = new Block;
+            _blockPtrs.Push( block );
+
+            Item* blockItems = block->items;
+            for( size_t i = 0; i < ITEMS_PER_BLOCK - 1; ++i ) {
+                blockItems[i].next = &(blockItems[i + 1]);
+            }
+            blockItems[ITEMS_PER_BLOCK - 1].next = 0;
+            _root = blockItems;
+        }
+        Item* const result = _root;
+        TIXMLASSERT( result != 0 );
+        _root = _root->next;
+
+        ++_currentAllocs;
+        if ( _currentAllocs > _maxAllocs ) {
+            _maxAllocs = _currentAllocs;
+        }
+        ++_nAllocs;
+        ++_nUntracked;
+        return result;
+    }
+
+    virtual void Free( void* mem ) override {
+        if ( !mem ) {
+            return;
+        }
+        --_currentAllocs;
+        Item* item = static_cast<Item*>( mem );
+#ifdef TINYXML2_DEBUG
+        memset( item, 0xfe, sizeof( *item ) );
+#endif
+        item->next = _root;
+        _root = item;
+    }
+    void Trace( const char* name ) {
+        printf( "Mempool %s watermark=%d [%dk] current=%d size=%d nAlloc=%d blocks=%d\n",
+                name, _maxAllocs, _maxAllocs * ITEM_SIZE / 1024, _currentAllocs,
+                ITEM_SIZE, _nAllocs, _blockPtrs.Size() );
+    }
+
+    void SetTracked() override {
+        --_nUntracked;
+    }
+
+    size_t Untracked() const {
+        return _nUntracked;
+    }
+
+	// This number is perf sensitive. 4k seems like a good tradeoff on my machine.
+	// The test file is large, 170k.
+	// Release:		VS2010 gcc(no opt)
+	//		1k:		4000
+	//		2k:		4000
+	//		4k:		3900	21000
+	//		16k:	5200
+	//		32k:	4300
+	//		64k:	4000	21000
+    // Declared public because some compilers do not accept to use ITEMS_PER_BLOCK
+    // in private part if ITEMS_PER_BLOCK is private
+    enum { ITEMS_PER_BLOCK = (4 * 1024) / ITEM_SIZE };
+
+private:
+    MemPoolT( const MemPoolT& ); // not supported
+    void operator=( const MemPoolT& ); // not supported
+
+    union Item {
+        Item*   next;
+        char    itemData[static_cast<size_t>(ITEM_SIZE)];
+    };
+    struct Block {
+        Item items[ITEMS_PER_BLOCK];
+    };
+    DynArray< Block*, 10 > _blockPtrs;
+    Item* _root;
+
+    size_t _currentAllocs;
+    size_t _nAllocs;
+    size_t _maxAllocs;
+    size_t _nUntracked;
+};
+
+
+
+/**
+	Implements the interface to the "Visitor pattern" (see the Accept() method.)
+	If you call the Accept() method, it requires being passed a XMLVisitor
+	class to handle callbacks. For nodes that contain other nodes (Document, Element)
+	you will get called with a VisitEnter/VisitExit pair. Nodes that are always leafs
+	are simply called with Visit().
+
+	If you return 'true' from a Visit method, recursive parsing will continue. If you return
+	false, <b>no children of this node or its siblings</b> will be visited.
+
+	All flavors of Visit methods have a default implementation that returns 'true' (continue
+	visiting). You need to only override methods that are interesting to you.
+
+	Generally Accept() is called on the XMLDocument, although all nodes support visiting.
+
+	You should never change the document from a callback.
+
+	@sa XMLNode::Accept()
+*/
+class TINYXML2_LIB XMLVisitor
+{
+public:
+    virtual ~XMLVisitor() {}
+
+    /// Visit a document.
+    virtual bool VisitEnter( const XMLDocument& /*doc*/ )			{
+        return true;
+    }
+    /// Visit a document.
+    virtual bool VisitExit( const XMLDocument& /*doc*/ )			{
+        return true;
+    }
+
+    /// Visit an element.
+    virtual bool VisitEnter( const XMLElement& /*element*/, const XMLAttribute* /*firstAttribute*/ )	{
+        return true;
+    }
+    /// Visit an element.
+    virtual bool VisitExit( const XMLElement& /*element*/ )			{
+        return true;
+    }
+
+    /// Visit a declaration.
+    virtual bool Visit( const XMLDeclaration& /*declaration*/ )		{
+        return true;
+    }
+    /// Visit a text node.
+    virtual bool Visit( const XMLText& /*text*/ )					{
+        return true;
+    }
+    /// Visit a comment node.
+    virtual bool Visit( const XMLComment& /*comment*/ )				{
+        return true;
+    }
+    /// Visit an unknown node.
+    virtual bool Visit( const XMLUnknown& /*unknown*/ )				{
+        return true;
+    }
+};
+
+// WARNING: must match XMLDocument::_errorNames[]
+enum XMLError {
+    XML_SUCCESS = 0,
+    XML_NO_ATTRIBUTE,
+    XML_WRONG_ATTRIBUTE_TYPE,
+    XML_ERROR_FILE_NOT_FOUND,
+    XML_ERROR_FILE_COULD_NOT_BE_OPENED,
+    XML_ERROR_FILE_READ_ERROR,
+    XML_ERROR_PARSING_ELEMENT,
+    XML_ERROR_PARSING_ATTRIBUTE,
+    XML_ERROR_PARSING_TEXT,
+    XML_ERROR_PARSING_CDATA,
+    XML_ERROR_PARSING_COMMENT,
+    XML_ERROR_PARSING_DECLARATION,
+    XML_ERROR_PARSING_UNKNOWN,
+    XML_ERROR_EMPTY_DOCUMENT,
+    XML_ERROR_MISMATCHED_ELEMENT,
+    XML_ERROR_PARSING,
+    XML_CAN_NOT_CONVERT_TEXT,
+    XML_NO_TEXT_NODE,
+	XML_ELEMENT_DEPTH_EXCEEDED,
+
+	XML_ERROR_COUNT
+};
+
+
+/*
+	Utility functionality.
+*/
+class TINYXML2_LIB XMLUtil
+{
+public:
+    static const char* SkipWhiteSpace( const char* p, int* curLineNumPtr )	{
+        TIXMLASSERT( p );
+
+        while( IsWhiteSpace(*p) ) {
+            if (curLineNumPtr && *p == '\n') {
+                ++(*curLineNumPtr);
+            }
+            ++p;
+        }
+        TIXMLASSERT( p );
+        return p;
+    }
+    static char* SkipWhiteSpace( char* const p, int* curLineNumPtr ) {
+        return const_cast<char*>( SkipWhiteSpace( const_cast<const char*>(p), curLineNumPtr ) );
+    }
+
+    // Anything in the high order range of UTF-8 is assumed to not be whitespace. This isn't
+    // correct, but simple, and usually works.
+    static bool IsWhiteSpace( char p )					{
+        return !IsUTF8Continuation(p) && isspace( static_cast<unsigned char>(p) );
+    }
+
+    inline static bool IsNameStartChar( unsigned char ch ) {
+        if ( ch >= 128 ) {
+            // This is a heuristic guess in attempt to not implement Unicode-aware isalpha()
+            return true;
+        }
+        if ( isalpha( ch ) ) {
+            return true;
+        }
+        return ch == ':' || ch == '_';
+    }
+
+    inline static bool IsNameChar( unsigned char ch ) {
+        return IsNameStartChar( ch )
+               || isdigit( ch )
+               || ch == '.'
+               || ch == '-';
+    }
+
+    inline static bool IsPrefixHex( const char* p) {
+        p = SkipWhiteSpace(p, 0);
+        return p && *p == '0' && ( *(p + 1) == 'x' || *(p + 1) == 'X');
+    }
+
+    inline static bool StringEqual( const char* p, const char* q, int nChar=INT_MAX )  {
+        if ( p == q ) {
+            return true;
+        }
+        TIXMLASSERT( p );
+        TIXMLASSERT( q );
+        TIXMLASSERT( nChar >= 0 );
+        return strncmp( p, q, static_cast<size_t>(nChar) ) == 0;
+    }
+
+    inline static bool IsUTF8Continuation( const char p ) {
+        return ( p & 0x80 ) != 0;
+    }
+
+    static const char* ReadBOM( const char* p, bool* hasBOM );
+    // p is the starting location,
+    // the UTF-8 value of the entity will be placed in value, and length filled in.
+    static const char* GetCharacterRef( const char* p, char* value, int* length );
+    static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );
+
+    // converts primitive types to strings
+    static void ToStr( int v, char* buffer, int bufferSize );
+    static void ToStr( unsigned v, char* buffer, int bufferSize );
+    static void ToStr( bool v, char* buffer, int bufferSize );
+    static void ToStr( float v, char* buffer, int bufferSize );
+    static void ToStr( double v, char* buffer, int bufferSize );
+	static void ToStr(int64_t v, char* buffer, int bufferSize);
+    static void ToStr(uint64_t v, char* buffer, int bufferSize);
+
+    // converts strings to primitive types
+    static bool	ToInt( const char* str, int* value );
+    static bool ToUnsigned( const char* str, unsigned* value );
+    static bool	ToBool( const char* str, bool* value );
+    static bool	ToFloat( const char* str, float* value );
+    static bool ToDouble( const char* str, double* value );
+	static bool ToInt64(const char* str, int64_t* value);
+    static bool ToUnsigned64(const char* str, uint64_t* value);
+	// Changes what is serialized for a boolean value.
+	// Default to "true" and "false". Shouldn't be changed
+	// unless you have a special testing or compatibility need.
+	// Be careful: static, global, & not thread safe.
+	// Be sure to set static const memory as parameters.
+	static void SetBoolSerialization(const char* writeTrue, const char* writeFalse);
+
+private:
+	static const char* writeBoolTrue;
+	static const char* writeBoolFalse;
+};
+
+
+/** XMLNode is a base class for every object that is in the
+	XML Document Object Model (DOM), except XMLAttributes.
+	Nodes have siblings, a parent, and children which can
+	be navigated. A node is always in a XMLDocument.
+	The type of a XMLNode can be queried, and it can
+	be cast to its more defined type.
+
+	A XMLDocument allocates memory for all its Nodes.
+	When the XMLDocument gets deleted, all its Nodes
+	will also be deleted.
+
+	@verbatim
+	A Document can contain:	Element	(container or leaf)
+							Comment (leaf)
+							Unknown (leaf)
+							Declaration( leaf )
+
+	An Element can contain:	Element (container or leaf)
+							Text	(leaf)
+							Attributes (not on tree)
+							Comment (leaf)
+							Unknown (leaf)
+
+	@endverbatim
+*/
+class TINYXML2_LIB XMLNode
+{
+    friend class XMLDocument;
+    friend class XMLElement;
+public:
+
+    /// Get the XMLDocument that owns this XMLNode.
+    const XMLDocument* GetDocument() const	{
+        TIXMLASSERT( _document );
+        return _document;
+    }
+    /// Get the XMLDocument that owns this XMLNode.
+    XMLDocument* GetDocument()				{
+        TIXMLASSERT( _document );
+        return _document;
+    }
+
+    /// Safely cast to an Element, or null.
+    virtual XMLElement*		ToElement()		{
+        return 0;
+    }
+    /// Safely cast to Text, or null.
+    virtual XMLText*		ToText()		{
+        return 0;
+    }
+    /// Safely cast to a Comment, or null.
+    virtual XMLComment*		ToComment()		{
+        return 0;
+    }
+    /// Safely cast to a Document, or null.
+    virtual XMLDocument*	ToDocument()	{
+        return 0;
+    }
+    /// Safely cast to a Declaration, or null.
+    virtual XMLDeclaration*	ToDeclaration()	{
+        return 0;
+    }
+    /// Safely cast to an Unknown, or null.
+    virtual XMLUnknown*		ToUnknown()		{
+        return 0;
+    }
+
+    virtual const XMLElement*		ToElement() const		{
+        return 0;
+    }
+    virtual const XMLText*			ToText() const			{
+        return 0;
+    }
+    virtual const XMLComment*		ToComment() const		{
+        return 0;
+    }
+    virtual const XMLDocument*		ToDocument() const		{
+        return 0;
+    }
+    virtual const XMLDeclaration*	ToDeclaration() const	{
+        return 0;
+    }
+    virtual const XMLUnknown*		ToUnknown() const		{
+        return 0;
+    }
+
+    // ChildElementCount was originally suggested by msteiger on the sourceforge page for TinyXML and modified by KB1SPH for TinyXML-2.
+
+    int ChildElementCount(const char *value) const;
+
+    int ChildElementCount() const;
+
+    /** The meaning of 'value' changes for the specific type.
+    	@verbatim
+    	Document:	empty (NULL is returned, not an empty string)
+    	Element:	name of the element
+    	Comment:	the comment text
+    	Unknown:	the tag contents
+    	Text:		the text string
+    	@endverbatim
+    */
+    const char* Value() const;
+
+    /** Set the Value of an XML node.
+    	@sa Value()
+    */
+    void SetValue( const char* val, bool staticMem=false );
+
+    /// Gets the line number the node is in, if the document was parsed from a file.
+    int GetLineNum() const { return _parseLineNum; }
+
+    /// Get the parent of this node on the DOM.
+    const XMLNode*	Parent() const			{
+        return _parent;
+    }
+
+    XMLNode* Parent()						{
+        return _parent;
+    }
+
+    /// Returns true if this node has no children.
+    bool NoChildren() const					{
+        return !_firstChild;
+    }
+
+    /// Get the first child node, or null if none exists.
+    const XMLNode*  FirstChild() const		{
+        return _firstChild;
+    }
+
+    XMLNode*		FirstChild()			{
+        return _firstChild;
+    }
+
+    /** Get the first child element, or optionally the first child
+        element with the specified name.
+    */
+    const XMLElement* FirstChildElement( const char* name = 0 ) const;
+
+    XMLElement* FirstChildElement( const char* name = 0 )	{
+        return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->FirstChildElement( name ));
+    }
+
+    /// Get the last child node, or null if none exists.
+    const XMLNode*	LastChild() const						{
+        return _lastChild;
+    }
+
+    XMLNode*		LastChild()								{
+        return _lastChild;
+    }
+
+    /** Get the last child element or optionally the last child
+        element with the specified name.
+    */
+    const XMLElement* LastChildElement( const char* name = 0 ) const;
+
+    XMLElement* LastChildElement( const char* name = 0 )	{
+        return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->LastChildElement(name) );
+    }
+
+    /// Get the previous (left) sibling node of this node.
+    const XMLNode*	PreviousSibling() const					{
+        return _prev;
+    }
+
+    XMLNode*	PreviousSibling()							{
+        return _prev;
+    }
+
+    /// Get the previous (left) sibling element of this node, with an optionally supplied name.
+    const XMLElement*	PreviousSiblingElement( const char* name = 0 ) const ;
+
+    XMLElement*	PreviousSiblingElement( const char* name = 0 ) {
+        return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->PreviousSiblingElement( name ) );
+    }
+
+    /// Get the next (right) sibling node of this node.
+    const XMLNode*	NextSibling() const						{
+        return _next;
+    }
+
+    XMLNode*	NextSibling()								{
+        return _next;
+    }
+
+    /// Get the next (right) sibling element of this node, with an optionally supplied name.
+    const XMLElement*	NextSiblingElement( const char* name = 0 ) const;
+
+    XMLElement*	NextSiblingElement( const char* name = 0 )	{
+        return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->NextSiblingElement( name ) );
+    }
+
+    /**
+    	Add a child node as the last (right) child.
+		If the child node is already part of the document,
+		it is moved from its old location to the new location.
+		Returns the addThis argument or 0 if the node does not
+		belong to the same document.
+    */
+    XMLNode* InsertEndChild( XMLNode* addThis );
+
+    XMLNode* LinkEndChild( XMLNode* addThis )	{
+        return InsertEndChild( addThis );
+    }
+    /**
+    	Add a child node as the first (left) child.
+		If the child node is already part of the document,
+		it is moved from its old location to the new location.
+		Returns the addThis argument or 0 if the node does not
+		belong to the same document.
+    */
+    XMLNode* InsertFirstChild( XMLNode* addThis );
+    /**
+    	Add a node after the specified child node.
+		If the child node is already part of the document,
+		it is moved from its old location to the new location.
+		Returns the addThis argument or 0 if the afterThis node
+		is not a child of this node, or if the node does not
+		belong to the same document.
+    */
+    XMLNode* InsertAfterChild( XMLNode* afterThis, XMLNode* addThis );
+
+    /**
+    	Delete all the children of this node.
+    */
+    void DeleteChildren();
+
+    /**
+    	Delete a child of this node.
+    */
+    void DeleteChild( XMLNode* node );
+
+    /**
+    	Make a copy of this node, but not its children.
+    	You may pass in a Document pointer that will be
+    	the owner of the new Node. If the 'document' is
+    	null, then the node returned will be allocated
+    	from the current Document. (this->GetDocument())
+
+    	Note: if called on a XMLDocument, this will return null.
+    */
+    virtual XMLNode* ShallowClone( XMLDocument* document ) const = 0;
+
+	/**
+		Make a copy of this node and all its children.
+
+		If the 'target' is null, then the nodes will
+		be allocated in the current document. If 'target'
+        is specified, the memory will be allocated in the
+        specified XMLDocument.
+
+		NOTE: This is probably not the correct tool to
+		copy a document, since XMLDocuments can have multiple
+		top level XMLNodes. You probably want to use
+        XMLDocument::DeepCopy()
+	*/
+	XMLNode* DeepClone( XMLDocument* target ) const;
+
+    /**
+    	Test if 2 nodes are the same, but don't test children.
+    	The 2 nodes do not need to be in the same Document.
+
+    	Note: if called on a XMLDocument, this will return false.
+    */
+    virtual bool ShallowEqual( const XMLNode* compare ) const = 0;
+
+    /** Accept a hierarchical visit of the nodes in the TinyXML-2 DOM. Every node in the
+    	XML tree will be conditionally visited and the host will be called back
+    	via the XMLVisitor interface.
+
+    	This is essentially a SAX interface for TinyXML-2. (Note however it doesn't re-parse
+    	the XML for the callbacks, so the performance of TinyXML-2 is unchanged by using this
+    	interface versus any other.)
+
+    	The interface has been based on ideas from:
+
+    	- http://www.saxproject.org/
+    	- http://c2.com/cgi/wiki?HierarchicalVisitorPattern
+
+    	Which are both good references for "visiting".
+
+    	An example of using Accept():
+    	@verbatim
+    	XMLPrinter printer;
+    	tinyxmlDoc.Accept( &printer );
+    	const char* xmlcstr = printer.CStr();
+    	@endverbatim
+    */
+    virtual bool Accept( XMLVisitor* visitor ) const = 0;
+
+	/**
+		Set user data into the XMLNode. TinyXML-2 in
+		no way processes or interprets user data.
+		It is initially 0.
+	*/
+	void SetUserData(void* userData)	{ _userData = userData; }
+
+	/**
+		Get user data set into the XMLNode. TinyXML-2 in
+		no way processes or interprets user data.
+		It is initially 0.
+	*/
+	void* GetUserData() const			{ return _userData; }
+
+protected:
+    explicit XMLNode( XMLDocument* );
+    virtual ~XMLNode();
+
+    virtual char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr);
+
+    XMLDocument*	_document;
+    XMLNode*		_parent;
+    mutable StrPair	_value;
+    int             _parseLineNum;
+
+    XMLNode*		_firstChild;
+    XMLNode*		_lastChild;
+
+    XMLNode*		_prev;
+    XMLNode*		_next;
+
+	void*			_userData;
+
+private:
+    MemPool*		_memPool;
+    void Unlink( XMLNode* child );
+    static void DeleteNode( XMLNode* node );
+    void InsertChildPreamble( XMLNode* insertThis ) const;
+    const XMLElement* ToElementWithName( const char* name ) const;
+
+    XMLNode( const XMLNode& );	// not supported
+    XMLNode& operator=( const XMLNode& );	// not supported
+};
+
+
+/** XML text.
+
+	Note that a text node can have child element nodes, for example:
+	@verbatim
+	<root>This is <b>bold</b></root>
+	@endverbatim
+
+	A text node can have 2 ways to output the next. "normal" output
+	and CDATA. It will default to the mode it was parsed from the XML file and
+	you generally want to leave it alone, but you can change the output mode with
+	SetCData() and query it with CData().
+*/
+class TINYXML2_LIB XMLText : public XMLNode
+{
+    friend class XMLDocument;
+public:
+    virtual bool Accept( XMLVisitor* visitor ) const override;
+
+    virtual XMLText* ToText() override		{
+        return this;
+    }
+    virtual const XMLText* ToText() const override {
+        return this;
+    }
+
+    /// Declare whether this should be CDATA or standard text.
+    void SetCData( bool isCData )			{
+        _isCData = isCData;
+    }
+    /// Returns true if this is a CDATA text element.
+    bool CData() const						{
+        return _isCData;
+    }
+
+    virtual XMLNode* ShallowClone( XMLDocument* document ) const override;
+    virtual bool ShallowEqual( const XMLNode* compare ) const override;
+
+protected:
+    explicit XMLText( XMLDocument* doc )	: XMLNode( doc ), _isCData( false )	{}
+    virtual ~XMLText()												{}
+
+    char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr ) override;
+
+private:
+    bool _isCData;
+
+    XMLText( const XMLText& );	// not supported
+    XMLText& operator=( const XMLText& );	// not supported
+};
+
+
+/** An XML Comment. */
+class TINYXML2_LIB XMLComment : public XMLNode
+{
+    friend class XMLDocument;
+public:
+    virtual XMLComment*	ToComment() override		{
+        return this;
+    }
+    virtual const XMLComment* ToComment() const override {
+        return this;
+    }
+
+    virtual bool Accept( XMLVisitor* visitor ) const override;
+
+    virtual XMLNode* ShallowClone( XMLDocument* document ) const override;
+    virtual bool ShallowEqual( const XMLNode* compare ) const override;
+
+protected:
+    explicit XMLComment( XMLDocument* doc );
+    virtual ~XMLComment();
+
+    char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr) override;
+
+private:
+    XMLComment( const XMLComment& );	// not supported
+    XMLComment& operator=( const XMLComment& );	// not supported
+};
+
+
+/** In correct XML the declaration is the first entry in the file.
+	@verbatim
+		<?xml version="1.0" standalone="yes"?>
+	@endverbatim
+
+	TinyXML-2 will happily read or write files without a declaration,
+	however.
+
+	The text of the declaration isn't interpreted. It is parsed
+	and written as a string.
+*/
+class TINYXML2_LIB XMLDeclaration : public XMLNode
+{
+    friend class XMLDocument;
+public:
+    virtual XMLDeclaration*	ToDeclaration() override		{
+        return this;
+    }
+    virtual const XMLDeclaration* ToDeclaration() const override {
+        return this;
+    }
+
+    virtual bool Accept( XMLVisitor* visitor ) const override;
+
+    virtual XMLNode* ShallowClone( XMLDocument* document ) const override;
+    virtual bool ShallowEqual( const XMLNode* compare ) const override;
+
+protected:
+    explicit XMLDeclaration( XMLDocument* doc );
+    virtual ~XMLDeclaration();
+
+    char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr ) override;
+
+private:
+    XMLDeclaration( const XMLDeclaration& );	// not supported
+    XMLDeclaration& operator=( const XMLDeclaration& );	// not supported
+};
+
+
+/** Any tag that TinyXML-2 doesn't recognize is saved as an
+	unknown. It is a tag of text, but should not be modified.
+	It will be written back to the XML, unchanged, when the file
+	is saved.
+
+	DTD tags get thrown into XMLUnknowns.
+*/
+class TINYXML2_LIB XMLUnknown : public XMLNode
+{
+    friend class XMLDocument;
+public:
+    virtual XMLUnknown*	ToUnknown() override		{
+        return this;
+    }
+    virtual const XMLUnknown* ToUnknown() const override {
+        return this;
+    }
+
+    virtual bool Accept( XMLVisitor* visitor ) const override;
+
+    virtual XMLNode* ShallowClone( XMLDocument* document ) const override;
+    virtual bool ShallowEqual( const XMLNode* compare ) const override;
+
+protected:
+    explicit XMLUnknown( XMLDocument* doc );
+    virtual ~XMLUnknown();
+
+    char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr ) override;
+
+private:
+    XMLUnknown( const XMLUnknown& );	// not supported
+    XMLUnknown& operator=( const XMLUnknown& );	// not supported
+};
+
+
+
+/** An attribute is a name-value pair. Elements have an arbitrary
+	number of attributes, each with a unique name.
+
+	@note The attributes are not XMLNodes. You may only query the
+	Next() attribute in a list.
+*/
+class TINYXML2_LIB XMLAttribute
+{
+    friend class XMLElement;
+public:
+    /// The name of the attribute.
+    const char* Name() const;
+
+    /// The value of the attribute.
+    const char* Value() const;
+
+    /// Gets the line number the attribute is in, if the document was parsed from a file.
+    int GetLineNum() const { return _parseLineNum; }
+
+    /// The next attribute in the list.
+    const XMLAttribute* Next() const {
+        return _next;
+    }
+
+    /** IntValue interprets the attribute as an integer, and returns the value.
+        If the value isn't an integer, 0 will be returned. There is no error checking;
+    	use QueryIntValue() if you need error checking.
+    */
+	int	IntValue() const {
+		int i = 0;
+		QueryIntValue(&i);
+		return i;
+	}
+
+	int64_t Int64Value() const {
+		int64_t i = 0;
+		QueryInt64Value(&i);
+		return i;
+	}
+
+    uint64_t Unsigned64Value() const {
+        uint64_t i = 0;
+        QueryUnsigned64Value(&i);
+        return i;
+    }
+
+    /// Query as an unsigned integer. See IntValue()
+    unsigned UnsignedValue() const			{
+        unsigned i=0;
+        QueryUnsignedValue( &i );
+        return i;
+    }
+    /// Query as a boolean. See IntValue()
+    bool	 BoolValue() const				{
+        bool b=false;
+        QueryBoolValue( &b );
+        return b;
+    }
+    /// Query as a double. See IntValue()
+    double 	 DoubleValue() const			{
+        double d=0;
+        QueryDoubleValue( &d );
+        return d;
+    }
+    /// Query as a float. See IntValue()
+    float	 FloatValue() const				{
+        float f=0;
+        QueryFloatValue( &f );
+        return f;
+    }
+
+    /** QueryIntValue interprets the attribute as an integer, and returns the value
+    	in the provided parameter. The function will return XML_SUCCESS on success,
+    	and XML_WRONG_ATTRIBUTE_TYPE if the conversion is not successful.
+    */
+    XMLError QueryIntValue( int* value ) const;
+    /// See QueryIntValue
+    XMLError QueryUnsignedValue( unsigned int* value ) const;
+	/// See QueryIntValue
+	XMLError QueryInt64Value(int64_t* value) const;
+    /// See QueryIntValue
+    XMLError QueryUnsigned64Value(uint64_t* value) const;
+	/// See QueryIntValue
+    XMLError QueryBoolValue( bool* value ) const;
+    /// See QueryIntValue
+    XMLError QueryDoubleValue( double* value ) const;
+    /// See QueryIntValue
+    XMLError QueryFloatValue( float* value ) const;
+
+    /// Set the attribute to a string value.
+    void SetAttribute( const char* value );
+    /// Set the attribute to value.
+    void SetAttribute( int value );
+    /// Set the attribute to value.
+    void SetAttribute( unsigned value );
+	/// Set the attribute to value.
+	void SetAttribute(int64_t value);
+    /// Set the attribute to value.
+    void SetAttribute(uint64_t value);
+    /// Set the attribute to value.
+    void SetAttribute( bool value );
+    /// Set the attribute to value.
+    void SetAttribute( double value );
+    /// Set the attribute to value.
+    void SetAttribute( float value );
+
+private:
+    enum { BUF_SIZE = 200 };
+
+    XMLAttribute() : _name(), _value(),_parseLineNum( 0 ), _next( 0 ), _memPool( 0 ) {}
+    virtual ~XMLAttribute()	{}
+
+    XMLAttribute( const XMLAttribute& );	// not supported
+    void operator=( const XMLAttribute& );	// not supported
+    void SetName( const char* name );
+
+    char* ParseDeep( char* p, bool processEntities, int* curLineNumPtr );
+
+    mutable StrPair _name;
+    mutable StrPair _value;
+    int             _parseLineNum;
+    XMLAttribute*   _next;
+    MemPool*        _memPool;
+};
+
+
+/** The element is a container class. It has a value, the element name,
+	and can contain other elements, text, comments, and unknowns.
+	Elements also contain an arbitrary number of attributes.
+*/
+class TINYXML2_LIB XMLElement : public XMLNode
+{
+    friend class XMLDocument;
+public:
+    /// Get the name of an element (which is the Value() of the node.)
+    const char* Name() const		{
+        return Value();
+    }
+    /// Set the name of the element.
+    void SetName( const char* str, bool staticMem=false )	{
+        SetValue( str, staticMem );
+    }
+
+    virtual XMLElement* ToElement() override	{
+        return this;
+    }
+    virtual const XMLElement* ToElement() const override {
+        return this;
+    }
+    virtual bool Accept( XMLVisitor* visitor ) const override;
+
+    /** Given an attribute name, Attribute() returns the value
+    	for the attribute of that name, or null if none
+    	exists. For example:
+
+    	@verbatim
+    	const char* value = ele->Attribute( "foo" );
+    	@endverbatim
+
+    	The 'value' parameter is normally null. However, if specified,
+    	the attribute will only be returned if the 'name' and 'value'
+    	match. This allow you to write code:
+
+    	@verbatim
+    	if ( ele->Attribute( "foo", "bar" ) ) callFooIsBar();
+    	@endverbatim
+
+    	rather than:
+    	@verbatim
+    	if ( ele->Attribute( "foo" ) ) {
+    		if ( strcmp( ele->Attribute( "foo" ), "bar" ) == 0 ) callFooIsBar();
+    	}
+    	@endverbatim
+    */
+    const char* Attribute( const char* name, const char* value=0 ) const;
+
+    /** Given an attribute name, IntAttribute() returns the value
+    	of the attribute interpreted as an integer. The default
+        value will be returned if the attribute isn't present,
+        or if there is an error. (For a method with error
+    	checking, see QueryIntAttribute()).
+    */
+	int IntAttribute(const char* name, int defaultValue = 0) const;
+    /// See IntAttribute()
+	unsigned UnsignedAttribute(const char* name, unsigned defaultValue = 0) const;
+	/// See IntAttribute()
+	int64_t Int64Attribute(const char* name, int64_t defaultValue = 0) const;
+    /// See IntAttribute()
+    uint64_t Unsigned64Attribute(const char* name, uint64_t defaultValue = 0) const;
+	/// See IntAttribute()
+	bool BoolAttribute(const char* name, bool defaultValue = false) const;
+    /// See IntAttribute()
+	double DoubleAttribute(const char* name, double defaultValue = 0) const;
+    /// See IntAttribute()
+	float FloatAttribute(const char* name, float defaultValue = 0) const;
+
+    /** Given an attribute name, QueryIntAttribute() returns
+    	XML_SUCCESS, XML_WRONG_ATTRIBUTE_TYPE if the conversion
+    	can't be performed, or XML_NO_ATTRIBUTE if the attribute
+    	doesn't exist. If successful, the result of the conversion
+    	will be written to 'value'. If not successful, nothing will
+    	be written to 'value'. This allows you to provide default
+    	value:
+
+    	@verbatim
+    	int value = 10;
+    	QueryIntAttribute( "foo", &value );		// if "foo" isn't found, value will still be 10
+    	@endverbatim
+    */
+    XMLError QueryIntAttribute( const char* name, int* value ) const				{
+        const XMLAttribute* a = FindAttribute( name );
+        if ( !a ) {
+            return XML_NO_ATTRIBUTE;
+        }
+        return a->QueryIntValue( value );
+    }
+
+	/// See QueryIntAttribute()
+    XMLError QueryUnsignedAttribute( const char* name, unsigned int* value ) const	{
+        const XMLAttribute* a = FindAttribute( name );
+        if ( !a ) {
+            return XML_NO_ATTRIBUTE;
+        }
+        return a->QueryUnsignedValue( value );
+    }
+
+	/// See QueryIntAttribute()
+	XMLError QueryInt64Attribute(const char* name, int64_t* value) const {
+		const XMLAttribute* a = FindAttribute(name);
+		if (!a) {
+			return XML_NO_ATTRIBUTE;
+		}
+		return a->QueryInt64Value(value);
+	}
+
+    /// See QueryIntAttribute()
+    XMLError QueryUnsigned64Attribute(const char* name, uint64_t* value) const {
+        const XMLAttribute* a = FindAttribute(name);
+        if(!a) {
+            return XML_NO_ATTRIBUTE;
+        }
+        return a->QueryUnsigned64Value(value);
+    }
+
+	/// See QueryIntAttribute()
+    XMLError QueryBoolAttribute( const char* name, bool* value ) const				{
+        const XMLAttribute* a = FindAttribute( name );
+        if ( !a ) {
+            return XML_NO_ATTRIBUTE;
+        }
+        return a->QueryBoolValue( value );
+    }
+    /// See QueryIntAttribute()
+    XMLError QueryDoubleAttribute( const char* name, double* value ) const			{
+        const XMLAttribute* a = FindAttribute( name );
+        if ( !a ) {
+            return XML_NO_ATTRIBUTE;
+        }
+        return a->QueryDoubleValue( value );
+    }
+    /// See QueryIntAttribute()
+    XMLError QueryFloatAttribute( const char* name, float* value ) const			{
+        const XMLAttribute* a = FindAttribute( name );
+        if ( !a ) {
+            return XML_NO_ATTRIBUTE;
+        }
+        return a->QueryFloatValue( value );
+    }
+
+	/// See QueryIntAttribute()
+	XMLError QueryStringAttribute(const char* name, const char** value) const {
+		const XMLAttribute* a = FindAttribute(name);
+		if (!a) {
+			return XML_NO_ATTRIBUTE;
+		}
+		*value = a->Value();
+		return XML_SUCCESS;
+	}
+
+
+
+    /** Given an attribute name, QueryAttribute() returns
+    	XML_SUCCESS, XML_WRONG_ATTRIBUTE_TYPE if the conversion
+    	can't be performed, or XML_NO_ATTRIBUTE if the attribute
+    	doesn't exist. It is overloaded for the primitive types,
+		and is a generally more convenient replacement of
+		QueryIntAttribute() and related functions.
+
+		If successful, the result of the conversion
+    	will be written to 'value'. If not successful, nothing will
+    	be written to 'value'. This allows you to provide default
+    	value:
+
+    	@verbatim
+    	int value = 10;
+    	QueryAttribute( "foo", &value );		// if "foo" isn't found, value will still be 10
+    	@endverbatim
+    */
+	XMLError QueryAttribute( const char* name, int* value ) const {
+		return QueryIntAttribute( name, value );
+	}
+
+	XMLError QueryAttribute( const char* name, unsigned int* value ) const {
+		return QueryUnsignedAttribute( name, value );
+	}
+
+	XMLError QueryAttribute(const char* name, int64_t* value) const {
+		return QueryInt64Attribute(name, value);
+	}
+
+    XMLError QueryAttribute(const char* name, uint64_t* value) const {
+        return QueryUnsigned64Attribute(name, value);
+    }
+
+    XMLError QueryAttribute( const char* name, bool* value ) const {
+		return QueryBoolAttribute( name, value );
+	}
+
+	XMLError QueryAttribute( const char* name, double* value ) const {
+		return QueryDoubleAttribute( name, value );
+	}
+
+	XMLError QueryAttribute( const char* name, float* value ) const {
+		return QueryFloatAttribute( name, value );
+	}
+
+	XMLError QueryAttribute(const char* name, const char** value) const {
+		return QueryStringAttribute(name, value);
+	}
+
+	/// Sets the named attribute to value.
+    void SetAttribute( const char* name, const char* value )	{
+        XMLAttribute* a = FindOrCreateAttribute( name );
+        a->SetAttribute( value );
+    }
+    /// Sets the named attribute to value.
+    void SetAttribute( const char* name, int value )			{
+        XMLAttribute* a = FindOrCreateAttribute( name );
+        a->SetAttribute( value );
+    }
+    /// Sets the named attribute to value.
+    void SetAttribute( const char* name, unsigned value )		{
+        XMLAttribute* a = FindOrCreateAttribute( name );
+        a->SetAttribute( value );
+    }
+
+	/// Sets the named attribute to value.
+	void SetAttribute(const char* name, int64_t value) {
+		XMLAttribute* a = FindOrCreateAttribute(name);
+		a->SetAttribute(value);
+	}
+
+    /// Sets the named attribute to value.
+    void SetAttribute(const char* name, uint64_t value) {
+        XMLAttribute* a = FindOrCreateAttribute(name);
+        a->SetAttribute(value);
+    }
+
+    /// Sets the named attribute to value.
+    void SetAttribute( const char* name, bool value )			{
+        XMLAttribute* a = FindOrCreateAttribute( name );
+        a->SetAttribute( value );
+    }
+    /// Sets the named attribute to value.
+    void SetAttribute( const char* name, double value )		{
+        XMLAttribute* a = FindOrCreateAttribute( name );
+        a->SetAttribute( value );
+    }
+    /// Sets the named attribute to value.
+    void SetAttribute( const char* name, float value )		{
+        XMLAttribute* a = FindOrCreateAttribute( name );
+        a->SetAttribute( value );
+    }
+
+    /**
+    	Delete an attribute.
+    */
+    void DeleteAttribute( const char* name );
+
+    /// Return the first attribute in the list.
+    const XMLAttribute* FirstAttribute() const {
+        return _rootAttribute;
+    }
+    /// Query a specific attribute in the list.
+    const XMLAttribute* FindAttribute( const char* name ) const;
+
+    /** Convenience function for easy access to the text inside an element. Although easy
+    	and concise, GetText() is limited compared to getting the XMLText child
+    	and accessing it directly.
+
+    	If the first child of 'this' is a XMLText, the GetText()
+    	returns the character string of the Text node, else null is returned.
+
+    	This is a convenient method for getting the text of simple contained text:
+    	@verbatim
+    	<foo>This is text</foo>
+    		const char* str = fooElement->GetText();
+    	@endverbatim
+
+    	'str' will be a pointer to "This is text".
+
+    	Note that this function can be misleading. If the element foo was created from
+    	this XML:
+    	@verbatim
+    		<foo><b>This is text</b></foo>
+    	@endverbatim
+
+    	then the value of str would be null. The first child node isn't a text node, it is
+    	another element. From this XML:
+    	@verbatim
+    		<foo>This is <b>text</b></foo>
+    	@endverbatim
+    	GetText() will return "This is ".
+    */
+    const char* GetText() const;
+
+    /** Convenience function for easy access to the text inside an element. Although easy
+    	and concise, SetText() is limited compared to creating an XMLText child
+    	and mutating it directly.
+
+    	If the first child of 'this' is a XMLText, SetText() sets its value to
+		the given string, otherwise it will create a first child that is an XMLText.
+
+    	This is a convenient method for setting the text of simple contained text:
+    	@verbatim
+    	<foo>This is text</foo>
+    		fooElement->SetText( "Hullaballoo!" );
+     	<foo>Hullaballoo!</foo>
+		@endverbatim
+
+    	Note that this function can be misleading. If the element foo was created from
+    	this XML:
+    	@verbatim
+    		<foo><b>This is text</b></foo>
+    	@endverbatim
+
+    	then it will not change "This is text", but rather prefix it with a text element:
+    	@verbatim
+    		<foo>Hullaballoo!<b>This is text</b></foo>
+    	@endverbatim
+
+		For this XML:
+    	@verbatim
+    		<foo />
+    	@endverbatim
+    	SetText() will generate
+    	@verbatim
+    		<foo>Hullaballoo!</foo>
+    	@endverbatim
+    */
+	void SetText( const char* inText );
+    /// Convenience method for setting text inside an element. See SetText() for important limitations.
+    void SetText( int value );
+    /// Convenience method for setting text inside an element. See SetText() for important limitations.
+    void SetText( unsigned value );
+	/// Convenience method for setting text inside an element. See SetText() for important limitations.
+	void SetText(int64_t value);
+    /// Convenience method for setting text inside an element. See SetText() for important limitations.
+    void SetText(uint64_t value);
+	/// Convenience method for setting text inside an element. See SetText() for important limitations.
+    void SetText( bool value );
+    /// Convenience method for setting text inside an element. See SetText() for important limitations.
+    void SetText( double value );
+    /// Convenience method for setting text inside an element. See SetText() for important limitations.
+    void SetText( float value );
+
+    /**
+    	Convenience method to query the value of a child text node. This is probably best
+    	shown by example. Given you have a document is this form:
+    	@verbatim
+    		<point>
+    			<x>1</x>
+    			<y>1.4</y>
+    		</point>
+    	@endverbatim
+
+    	The QueryIntText() and similar functions provide a safe and easier way to get to the
+    	"value" of x and y.
+
+    	@verbatim
+    		int x = 0;
+    		float y = 0;	// types of x and y are contrived for example
+    		const XMLElement* xElement = pointElement->FirstChildElement( "x" );
+    		const XMLElement* yElement = pointElement->FirstChildElement( "y" );
+    		xElement->QueryIntText( &x );
+    		yElement->QueryFloatText( &y );
+    	@endverbatim
+
+    	@returns XML_SUCCESS (0) on success, XML_CAN_NOT_CONVERT_TEXT if the text cannot be converted
+    			 to the requested type, and XML_NO_TEXT_NODE if there is no child text to query.
+
+    */
+    XMLError QueryIntText( int* ival ) const;
+    /// See QueryIntText()
+    XMLError QueryUnsignedText( unsigned* uval ) const;
+	/// See QueryIntText()
+	XMLError QueryInt64Text(int64_t* uval) const;
+	/// See QueryIntText()
+	XMLError QueryUnsigned64Text(uint64_t* uval) const;
+	/// See QueryIntText()
+    XMLError QueryBoolText( bool* bval ) const;
+    /// See QueryIntText()
+    XMLError QueryDoubleText( double* dval ) const;
+    /// See QueryIntText()
+    XMLError QueryFloatText( float* fval ) const;
+
+	int IntText(int defaultValue = 0) const;
+
+	/// See QueryIntText()
+	unsigned UnsignedText(unsigned defaultValue = 0) const;
+	/// See QueryIntText()
+	int64_t Int64Text(int64_t defaultValue = 0) const;
+    /// See QueryIntText()
+    uint64_t Unsigned64Text(uint64_t defaultValue = 0) const;
+	/// See QueryIntText()
+	bool BoolText(bool defaultValue = false) const;
+	/// See QueryIntText()
+	double DoubleText(double defaultValue = 0) const;
+	/// See QueryIntText()
+    float FloatText(float defaultValue = 0) const;
+
+    /**
+        Convenience method to create a new XMLElement and add it as last (right)
+        child of this node. Returns the created and inserted element.
+    */
+    XMLElement* InsertNewChildElement(const char* name);
+    /// See InsertNewChildElement()
+    XMLComment* InsertNewComment(const char* comment);
+    /// See InsertNewChildElement()
+    XMLText* InsertNewText(const char* text);
+    /// See InsertNewChildElement()
+    XMLDeclaration* InsertNewDeclaration(const char* text);
+    /// See InsertNewChildElement()
+    XMLUnknown* InsertNewUnknown(const char* text);
+
+
+    // internal:
+    enum ElementClosingType {
+        OPEN,		// <foo>
+        CLOSED,		// <foo/>
+        CLOSING		// </foo>
+    };
+    ElementClosingType ClosingType() const {
+        return _closingType;
+    }
+    virtual XMLNode* ShallowClone( XMLDocument* document ) const override;
+    virtual bool ShallowEqual( const XMLNode* compare ) const override;
+
+protected:
+    char* ParseDeep( char* p, StrPair* parentEndTag, int* curLineNumPtr ) override;
+
+private:
+    XMLElement( XMLDocument* doc );
+    virtual ~XMLElement();
+    XMLElement( const XMLElement& );	// not supported
+    void operator=( const XMLElement& );	// not supported
+
+    XMLAttribute* FindOrCreateAttribute( const char* name );
+    char* ParseAttributes( char* p, int* curLineNumPtr );
+    static void DeleteAttribute( XMLAttribute* attribute );
+    XMLAttribute* CreateAttribute();
+
+    enum { BUF_SIZE = 200 };
+    ElementClosingType _closingType;
+    // The attribute list is ordered; there is no 'lastAttribute'
+    // because the list needs to be scanned for dupes before adding
+    // a new attribute.
+    XMLAttribute* _rootAttribute;
+};
+
+
+enum Whitespace {
+    PRESERVE_WHITESPACE,
+    COLLAPSE_WHITESPACE,
+    PEDANTIC_WHITESPACE
+};
+
+
+/** A Document binds together all the functionality.
+	It can be saved, loaded, and printed to the screen.
+	All Nodes are connected and allocated to a Document.
+	If the Document is deleted, all its Nodes are also deleted.
+*/
+class TINYXML2_LIB XMLDocument : public XMLNode
+{
+    friend class XMLElement;
+    // Gives access to SetError and Push/PopDepth, but over-access for everything else.
+    // Wishing C++ had "internal" scope.
+    friend class XMLNode;
+    friend class XMLText;
+    friend class XMLComment;
+    friend class XMLDeclaration;
+    friend class XMLUnknown;
+public:
+    /// constructor
+    XMLDocument( bool processEntities = true, Whitespace whitespaceMode = PRESERVE_WHITESPACE );
+    ~XMLDocument();
+
+    virtual XMLDocument* ToDocument() override		{
+        TIXMLASSERT( this == _document );
+        return this;
+    }
+    virtual const XMLDocument* ToDocument() const override {
+        TIXMLASSERT( this == _document );
+        return this;
+    }
+
+    /**
+    	Parse an XML file from a character string.
+    	Returns XML_SUCCESS (0) on success, or
+    	an errorID.
+
+    	You may optionally pass in the 'nBytes', which is
+    	the number of bytes which will be parsed. If not
+    	specified, TinyXML-2 will assume 'xml' points to a
+    	null terminated string.
+    */
+    XMLError Parse( const char* xml, size_t nBytes=static_cast<size_t>(-1) );
+
+    /**
+    	Load an XML file from disk.
+    	Returns XML_SUCCESS (0) on success, or
+    	an errorID.
+    */
+    XMLError LoadFile( const char* filename );
+
+    /**
+    	Load an XML file from disk. You are responsible
+    	for providing and closing the FILE*.
+
+        NOTE: The file should be opened as binary ("rb")
+        not text in order for TinyXML-2 to correctly
+        do newline normalization.
+
+    	Returns XML_SUCCESS (0) on success, or
+    	an errorID.
+    */
+    XMLError LoadFile( FILE* );
+
+    /**
+    	Save the XML file to disk.
+    	Returns XML_SUCCESS (0) on success, or
+    	an errorID.
+    */
+    XMLError SaveFile( const char* filename, bool compact = false );
+
+    /**
+    	Save the XML file to disk. You are responsible
+    	for providing and closing the FILE*.
+
+    	Returns XML_SUCCESS (0) on success, or
+    	an errorID.
+    */
+    XMLError SaveFile( FILE* fp, bool compact = false );
+
+    bool ProcessEntities() const		{
+        return _processEntities;
+    }
+    Whitespace WhitespaceMode() const	{
+        return _whitespaceMode;
+    }
+
+    /**
+    	Returns true if this document has a leading Byte Order Mark of UTF8.
+    */
+    bool HasBOM() const {
+        return _writeBOM;
+    }
+    /** Sets whether to write the BOM when writing the file.
+    */
+    void SetBOM( bool useBOM ) {
+        _writeBOM = useBOM;
+    }
+
+    /** Return the root element of DOM. Equivalent to FirstChildElement().
+        To get the first node, use FirstChild().
+    */
+    XMLElement* RootElement()				{
+        return FirstChildElement();
+    }
+    const XMLElement* RootElement() const	{
+        return FirstChildElement();
+    }
+
+    /** Print the Document. If the Printer is not provided, it will
+        print to stdout. If you provide Printer, this can print to a file:
+    	@verbatim
+    	XMLPrinter printer( fp );
+    	doc.Print( &printer );
+    	@endverbatim
+
+    	Or you can use a printer to print to memory:
+    	@verbatim
+    	XMLPrinter printer;
+    	doc.Print( &printer );
+    	// printer.CStr() has a const char* to the XML
+    	@endverbatim
+    */
+    void Print( XMLPrinter* streamer=0 ) const;
+    virtual bool Accept( XMLVisitor* visitor ) const override;
+
+    /**
+    	Create a new Element associated with
+    	this Document. The memory for the Element
+    	is managed by the Document.
+    */
+    XMLElement* NewElement( const char* name );
+    /**
+    	Create a new Comment associated with
+    	this Document. The memory for the Comment
+    	is managed by the Document.
+    */
+    XMLComment* NewComment( const char* comment );
+    /**
+    	Create a new Text associated with
+    	this Document. The memory for the Text
+    	is managed by the Document.
+    */
+    XMLText* NewText( const char* text );
+    /**
+    	Create a new Declaration associated with
+    	this Document. The memory for the object
+    	is managed by the Document.
+
+    	If the 'text' param is null, the standard
+    	declaration is used.:
+    	@verbatim
+    		<?xml version="1.0" encoding="UTF-8"?>
+    	@endverbatim
+    */
+    XMLDeclaration* NewDeclaration( const char* text=0 );
+    /**
+    	Create a new Unknown associated with
+    	this Document. The memory for the object
+    	is managed by the Document.
+    */
+    XMLUnknown* NewUnknown( const char* text );
+
+    /**
+    	Delete a node associated with this document.
+    	It will be unlinked from the DOM.
+    */
+    void DeleteNode( XMLNode* node );
+
+    /// Clears the error flags.
+    void ClearError();
+
+    /// Return true if there was an error parsing the document.
+    bool Error() const {
+        return _errorID != XML_SUCCESS;
+    }
+    /// Return the errorID.
+    XMLError  ErrorID() const {
+        return _errorID;
+    }
+	const char* ErrorName() const;
+    static const char* ErrorIDToName(XMLError errorID);
+
+    /** Returns a "long form" error description. A hopefully helpful
+        diagnostic with location, line number, and/or additional info.
+    */
+	const char* ErrorStr() const;
+
+    /// A (trivial) utility function that prints the ErrorStr() to stdout.
+    void PrintError() const;
+
+    /// Return the line where the error occurred, or zero if unknown.
+    int ErrorLineNum() const
+    {
+        return _errorLineNum;
+    }
+
+    /// Clear the document, resetting it to the initial state.
+    void Clear();
+
+	/**
+		Copies this document to a target document.
+		The target will be completely cleared before the copy.
+		If you want to copy a sub-tree, see XMLNode::DeepClone().
+
+		NOTE: that the 'target' must be non-null.
+	*/
+	void DeepCopy(XMLDocument* target) const;
+
+	// internal
+    char* Identify( char* p, XMLNode** node, bool first );
+
+	// internal
+	void MarkInUse(const XMLNode* const);
+
+    virtual XMLNode* ShallowClone( XMLDocument* /*document*/ ) const override{
+        return 0;
+    }
+    virtual bool ShallowEqual( const XMLNode* /*compare*/ ) const override{
+        return false;
+    }
+
+private:
+    XMLDocument( const XMLDocument& );	// not supported
+    void operator=( const XMLDocument& );	// not supported
+
+    bool			_writeBOM;
+    bool			_processEntities;
+    XMLError		_errorID;
+    Whitespace		_whitespaceMode;
+    mutable StrPair	_errorStr;
+    int             _errorLineNum;
+    char*			_charBuffer;
+    int				_parseCurLineNum;
+	int				_parsingDepth;
+	// Memory tracking does add some overhead.
+	// However, the code assumes that you don't
+	// have a bunch of unlinked nodes around.
+	// Therefore it takes less memory to track
+	// in the document vs. a linked list in the XMLNode,
+	// and the performance is the same.
+	DynArray<XMLNode*, 10> _unlinked;
+
+    MemPoolT< sizeof(XMLElement) >	 _elementPool;
+    MemPoolT< sizeof(XMLAttribute) > _attributePool;
+    MemPoolT< sizeof(XMLText) >		 _textPool;
+    MemPoolT< sizeof(XMLComment) >	 _commentPool;
+
+	static const char* _errorNames[XML_ERROR_COUNT];
+
+    void Parse();
+
+    void SetError( XMLError error, int lineNum, const char* format, ... );
+
+	// Something of an obvious security hole, once it was discovered.
+	// Either an ill-formed XML or an excessively deep one can overflow
+	// the stack. Track stack depth, and error out if needed.
+	class DepthTracker {
+	public:
+		explicit DepthTracker(XMLDocument * document) {
+			this->_document = document;
+			document->PushDepth();
+		}
+		~DepthTracker() {
+			_document->PopDepth();
+		}
+	private:
+		XMLDocument * _document;
+	};
+	void PushDepth();
+	void PopDepth();
+
+    template<class NodeType, size_t PoolElementSize>
+    NodeType* CreateUnlinkedNode( MemPoolT<PoolElementSize>& pool );
+};
+
+template<class NodeType, size_t PoolElementSize>
+inline NodeType* XMLDocument::CreateUnlinkedNode( MemPoolT<PoolElementSize>& pool )
+{
+    TIXMLASSERT( sizeof( NodeType ) == PoolElementSize );
+    TIXMLASSERT( sizeof( NodeType ) == pool.ItemSize() );
+    NodeType* returnNode = new (pool.Alloc()) NodeType( this );
+    TIXMLASSERT( returnNode );
+    returnNode->_memPool = &pool;
+
+	_unlinked.Push(returnNode);
+    return returnNode;
+}
+
+/**
+	A XMLHandle is a class that wraps a node pointer with null checks; this is
+	an incredibly useful thing. Note that XMLHandle is not part of the TinyXML-2
+	DOM structure. It is a separate utility class.
+
+	Take an example:
+	@verbatim
+	<Document>
+		<Element attributeA = "valueA">
+			<Child attributeB = "value1" />
+			<Child attributeB = "value2" />
+		</Element>
+	</Document>
+	@endverbatim
+
+	Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very
+	easy to write a *lot* of code that looks like:
+
+	@verbatim
+	XMLElement* root = document.FirstChildElement( "Document" );
+	if ( root )
+	{
+		XMLElement* element = root->FirstChildElement( "Element" );
+		if ( element )
+		{
+			XMLElement* child = element->FirstChildElement( "Child" );
+			if ( child )
+			{
+				XMLElement* child2 = child->NextSiblingElement( "Child" );
+				if ( child2 )
+				{
+					// Finally do something useful.
+	@endverbatim
+
+	And that doesn't even cover "else" cases. XMLHandle addresses the verbosity
+	of such code. A XMLHandle checks for null pointers so it is perfectly safe
+	and correct to use:
+
+	@verbatim
+	XMLHandle docHandle( &document );
+	XMLElement* child2 = docHandle.FirstChildElement( "Document" ).FirstChildElement( "Element" ).FirstChildElement().NextSiblingElement();
+	if ( child2 )
+	{
+		// do something useful
+	@endverbatim
+
+	Which is MUCH more concise and useful.
+
+	It is also safe to copy handles - internally they are nothing more than node pointers.
+	@verbatim
+	XMLHandle handleCopy = handle;
+	@endverbatim
+
+	See also XMLConstHandle, which is the same as XMLHandle, but operates on const objects.
+*/
+class TINYXML2_LIB XMLHandle
+{
+public:
+    /// Create a handle from any node (at any depth of the tree.) This can be a null pointer.
+    explicit XMLHandle( XMLNode* node ) : _node( node ) {
+    }
+    /// Create a handle from a node.
+    explicit XMLHandle( XMLNode& node ) : _node( &node ) {
+    }
+    /// Copy constructor
+    XMLHandle( const XMLHandle& ref ) : _node( ref._node ) {
+    }
+    /// Assignment
+    XMLHandle& operator=( const XMLHandle& ref )							{
+        _node = ref._node;
+        return *this;
+    }
+
+    /// Get the first child of this handle.
+    XMLHandle FirstChild() 													{
+        return XMLHandle( _node ? _node->FirstChild() : 0 );
+    }
+    /// Get the first child element of this handle.
+    XMLHandle FirstChildElement( const char* name = 0 )						{
+        return XMLHandle( _node ? _node->FirstChildElement( name ) : 0 );
+    }
+    /// Get the last child of this handle.
+    XMLHandle LastChild()													{
+        return XMLHandle( _node ? _node->LastChild() : 0 );
+    }
+    /// Get the last child element of this handle.
+    XMLHandle LastChildElement( const char* name = 0 )						{
+        return XMLHandle( _node ? _node->LastChildElement( name ) : 0 );
+    }
+    /// Get the previous sibling of this handle.
+    XMLHandle PreviousSibling()												{
+        return XMLHandle( _node ? _node->PreviousSibling() : 0 );
+    }
+    /// Get the previous sibling element of this handle.
+    XMLHandle PreviousSiblingElement( const char* name = 0 )				{
+        return XMLHandle( _node ? _node->PreviousSiblingElement( name ) : 0 );
+    }
+    /// Get the next sibling of this handle.
+    XMLHandle NextSibling()													{
+        return XMLHandle( _node ? _node->NextSibling() : 0 );
+    }
+    /// Get the next sibling element of this handle.
+    XMLHandle NextSiblingElement( const char* name = 0 )					{
+        return XMLHandle( _node ? _node->NextSiblingElement( name ) : 0 );
+    }
+
+    /// Safe cast to XMLNode. This can return null.
+    XMLNode* ToNode()							{
+        return _node;
+    }
+    /// Safe cast to XMLElement. This can return null.
+    XMLElement* ToElement() 					{
+        return ( _node ? _node->ToElement() : 0 );
+    }
+    /// Safe cast to XMLText. This can return null.
+    XMLText* ToText() 							{
+        return ( _node ? _node->ToText() : 0 );
+    }
+    /// Safe cast to XMLUnknown. This can return null.
+    XMLUnknown* ToUnknown() 					{
+        return ( _node ? _node->ToUnknown() : 0 );
+    }
+    /// Safe cast to XMLDeclaration. This can return null.
+    XMLDeclaration* ToDeclaration() 			{
+        return ( _node ? _node->ToDeclaration() : 0 );
+    }
+
+private:
+    XMLNode* _node;
+};
+
+
+/**
+	A variant of the XMLHandle class for working with const XMLNodes and Documents. It is the
+	same in all regards, except for the 'const' qualifiers. See XMLHandle for API.
+*/
+class TINYXML2_LIB XMLConstHandle
+{
+public:
+    explicit XMLConstHandle( const XMLNode* node ) : _node( node ) {
+    }
+    explicit XMLConstHandle( const XMLNode& node ) : _node( &node ) {
+    }
+    XMLConstHandle( const XMLConstHandle& ref ) : _node( ref._node ) {
+    }
+
+    XMLConstHandle& operator=( const XMLConstHandle& ref )							{
+        _node = ref._node;
+        return *this;
+    }
+
+    const XMLConstHandle FirstChild() const											{
+        return XMLConstHandle( _node ? _node->FirstChild() : 0 );
+    }
+    const XMLConstHandle FirstChildElement( const char* name = 0 ) const				{
+        return XMLConstHandle( _node ? _node->FirstChildElement( name ) : 0 );
+    }
+    const XMLConstHandle LastChild()	const										{
+        return XMLConstHandle( _node ? _node->LastChild() : 0 );
+    }
+    const XMLConstHandle LastChildElement( const char* name = 0 ) const				{
+        return XMLConstHandle( _node ? _node->LastChildElement( name ) : 0 );
+    }
+    const XMLConstHandle PreviousSibling() const									{
+        return XMLConstHandle( _node ? _node->PreviousSibling() : 0 );
+    }
+    const XMLConstHandle PreviousSiblingElement( const char* name = 0 ) const		{
+        return XMLConstHandle( _node ? _node->PreviousSiblingElement( name ) : 0 );
+    }
+    const XMLConstHandle NextSibling() const										{
+        return XMLConstHandle( _node ? _node->NextSibling() : 0 );
+    }
+    const XMLConstHandle NextSiblingElement( const char* name = 0 ) const			{
+        return XMLConstHandle( _node ? _node->NextSiblingElement( name ) : 0 );
+    }
+
+
+    const XMLNode* ToNode() const				{
+        return _node;
+    }
+    const XMLElement* ToElement() const			{
+        return ( _node ? _node->ToElement() : 0 );
+    }
+    const XMLText* ToText() const				{
+        return ( _node ? _node->ToText() : 0 );
+    }
+    const XMLUnknown* ToUnknown() const			{
+        return ( _node ? _node->ToUnknown() : 0 );
+    }
+    const XMLDeclaration* ToDeclaration() const	{
+        return ( _node ? _node->ToDeclaration() : 0 );
+    }
+
+private:
+    const XMLNode* _node;
+};
+
+
+/**
+	Printing functionality. The XMLPrinter gives you more
+	options than the XMLDocument::Print() method.
+
+	It can:
+	-# Print to memory.
+	-# Print to a file you provide.
+	-# Print XML without a XMLDocument.
+
+	Print to Memory
+
+	@verbatim
+	XMLPrinter printer;
+	doc.Print( &printer );
+	SomeFunction( printer.CStr() );
+	@endverbatim
+
+	Print to a File
+
+	You provide the file pointer.
+	@verbatim
+	XMLPrinter printer( fp );
+	doc.Print( &printer );
+	@endverbatim
+
+	Print without a XMLDocument
+
+	When loading, an XML parser is very useful. However, sometimes
+	when saving, it just gets in the way. The code is often set up
+	for streaming, and constructing the DOM is just overhead.
+
+	The Printer supports the streaming case. The following code
+	prints out a trivially simple XML file without ever creating
+	an XML document.
+
+	@verbatim
+	XMLPrinter printer( fp );
+	printer.OpenElement( "foo" );
+	printer.PushAttribute( "foo", "bar" );
+	printer.CloseElement();
+	@endverbatim
+*/
+class TINYXML2_LIB XMLPrinter : public XMLVisitor
+{
+public:
+    /** Construct the printer. If the FILE* is specified,
+    	this will print to the FILE. Else it will print
+    	to memory, and the result is available in CStr().
+    	If 'compact' is set to true, then output is created
+    	with only required whitespace and newlines.
+    */
+    XMLPrinter( FILE* file=0, bool compact = false, int depth = 0 );
+    virtual ~XMLPrinter()	{}
+
+    /** If streaming, write the BOM and declaration. */
+    void PushHeader( bool writeBOM, bool writeDeclaration );
+    /** If streaming, start writing an element.
+        The element must be closed with CloseElement()
+    */
+    void OpenElement( const char* name, bool compactMode=false );
+    /// If streaming, add an attribute to an open element.
+    void PushAttribute( const char* name, const char* value );
+    void PushAttribute( const char* name, int value );
+    void PushAttribute( const char* name, unsigned value );
+	void PushAttribute( const char* name, int64_t value );
+	void PushAttribute( const char* name, uint64_t value );
+	void PushAttribute( const char* name, bool value );
+    void PushAttribute( const char* name, double value );
+    /// If streaming, close the Element.
+    virtual void CloseElement( bool compactMode=false );
+
+    /// Add a text node.
+    void PushText( const char* text, bool cdata=false );
+    /// Add a text node from an integer.
+    void PushText( int value );
+    /// Add a text node from an unsigned.
+    void PushText( unsigned value );
+	/// Add a text node from a signed 64bit integer.
+	void PushText( int64_t value );
+	/// Add a text node from an unsigned 64bit integer.
+	void PushText( uint64_t value );
+	/// Add a text node from a bool.
+    void PushText( bool value );
+    /// Add a text node from a float.
+    void PushText( float value );
+    /// Add a text node from a double.
+    void PushText( double value );
+
+    /// Add a comment
+    void PushComment( const char* comment );
+
+    void PushDeclaration( const char* value );
+    void PushUnknown( const char* value );
+
+    virtual bool VisitEnter( const XMLDocument& /*doc*/ ) override;
+    virtual bool VisitExit( const XMLDocument& /*doc*/ ) override	{
+        return true;
+    }
+
+    virtual bool VisitEnter( const XMLElement& element, const XMLAttribute* attribute ) override;
+    virtual bool VisitExit( const XMLElement& element ) override;
+
+    virtual bool Visit( const XMLText& text ) override;
+    virtual bool Visit( const XMLComment& comment ) override;
+    virtual bool Visit( const XMLDeclaration& declaration ) override;
+    virtual bool Visit( const XMLUnknown& unknown ) override;
+
+    /**
+    	If in print to memory mode, return a pointer to
+    	the XML file in memory.
+    */
+    const char* CStr() const {
+        return _buffer.Mem();
+    }
+    /**
+    	If in print to memory mode, return the size
+    	of the XML file in memory. (Note the size returned
+    	includes the terminating null.)
+    */
+    size_t CStrSize() const {
+        return _buffer.Size();
+    }
+    /**
+    	If in print to memory mode, reset the buffer to the
+    	beginning.
+    */
+    void ClearBuffer( bool resetToFirstElement = true ) {
+        _buffer.Clear();
+        _buffer.Push(0);
+		_firstElement = resetToFirstElement;
+    }
+
+protected:
+	virtual bool CompactMode( const XMLElement& )	{ return _compactMode; }
+
+	/** Prints out the space before an element. You may override to change
+	    the space and tabs used. A PrintSpace() override should call Print().
+	*/
+    virtual void PrintSpace( int depth );
+    virtual void Print( const char* format, ... );
+    virtual void Write( const char* data, size_t size );
+    virtual void Putc( char ch );
+
+    inline void Write(const char* data) { Write(data, strlen(data)); }
+
+    void SealElementIfJustOpened();
+    bool _elementJustOpened;
+    DynArray< const char*, 10 > _stack;
+
+private:
+    /**
+       Prepares to write a new node. This includes sealing an element that was
+       just opened, and writing any whitespace necessary if not in compact mode.
+     */
+    void PrepareForNewNode( bool compactMode );
+    void PrintString( const char*, bool restrictedEntitySet );	// prints out, after detecting entities.
+
+    bool _firstElement;
+    FILE* _fp;
+    int _depth;
+    int _textDepth;
+    bool _processEntities;
+	bool _compactMode;
+
+    enum {
+        ENTITY_RANGE = 64,
+        BUF_SIZE = 200
+    };
+    bool _entityFlag[ENTITY_RANGE];
+    bool _restrictedEntityFlag[ENTITY_RANGE];
+
+    DynArray< char, 20 > _buffer;
+
+    // Prohibit cloning, intentionally not implemented
+    XMLPrinter( const XMLPrinter& );
+    XMLPrinter& operator=( const XMLPrinter& );
+};
+
+
+} // namespace tinyxml2
+
+#if defined(_MSC_VER)
+#   pragma warning(pop)
+#endif
+
+#endif // TINYXML2_INCLUDED
diff --git a/frontend/CMakeLists.txt b/frontend/CMakeLists.txt
new file mode 100644
index 00000000000..17d10bb4f00
--- /dev/null
+++ b/frontend/CMakeLists.txt
@@ -0,0 +1,6 @@
+file(GLOB hdrs "*.h")
+file(GLOB srcs "*.cpp")
+
+add_library(frontend ${hdrs} ${srcs})
+target_include_directories(frontend PUBLIC .)
+target_link_libraries(frontend PRIVATE cppcheck-core)
diff --git a/frontend/frontend.cpp b/frontend/frontend.cpp
new file mode 100644
index 00000000000..bd95488a9a5
--- /dev/null
+++ b/frontend/frontend.cpp
@@ -0,0 +1,104 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "frontend.h"
+
+#include "filesettings.h"
+#include "library.h"
+#include "path.h"
+#include "settings.h"
+
+#include <cassert>
+
+namespace frontend {
+    void applyLang(std::list<FileSettings>& fileSettings, const Settings& settings, Standards::Language enforcedLang)
+    {
+        if (enforcedLang != Standards::Language::None)
+        {
+            // apply enforced language
+            for (auto& fs : fileSettings)
+            {
+                if (settings.library.markupFile(fs.filename()))
+                    continue;
+                fs.file.setLang(enforcedLang);
+            }
+        }
+        else
+        {
+            // identify files
+            for (auto& fs : fileSettings)
+            {
+                if (settings.library.markupFile(fs.filename()))
+                    continue;
+                assert(fs.file.lang() == Standards::Language::None);
+                bool header = false;
+                fs.file.setLang(Path::identify(fs.filename(), settings.cppHeaderProbe, &header));
+                // unknown extensions default to C++
+                if (!header && fs.file.lang() == Standards::Language::None)
+                    fs.file.setLang(Standards::Language::CPP);
+            }
+        }
+
+        // enforce the language since markup files are special and do not adhere to the enforced language
+        for (auto& fs : fileSettings)
+        {
+            if (settings.library.markupFile(fs.filename())) {
+                assert(fs.file.lang() == Standards::Language::None);
+                fs.file.setLang(Standards::Language::C);
+            }
+        }
+    }
+
+    void applyLang(std::list<FileWithDetails>& files, const Settings& settings, Standards::Language enforcedLang)
+    {
+        if (enforcedLang != Standards::Language::None)
+        {
+            // apply enforced language
+            for (auto& f : files)
+            {
+                if (settings.library.markupFile(f.path()))
+                    continue;
+                f.setLang(enforcedLang);
+            }
+        }
+        else
+        {
+            // identify remaining files
+            for (auto& f : files)
+            {
+                if (f.lang() != Standards::Language::None)
+                    continue;
+                if (settings.library.markupFile(f.path()))
+                    continue;
+                bool header = false;
+                f.setLang(Path::identify(f.path(), settings.cppHeaderProbe, &header));
+                // unknown extensions default to C++
+                if (!header && f.lang() == Standards::Language::None)
+                    f.setLang(Standards::Language::CPP);
+            }
+        }
+
+        // enforce the language since markup files are special and do not adhere to the enforced language
+        for (auto& f : files)
+        {
+            if (settings.library.markupFile(f.path())) {
+                f.setLang(Standards::Language::C);
+            }
+        }
+    }
+}
diff --git a/frontend/frontend.h b/frontend/frontend.h
new file mode 100644
index 00000000000..71af18b3b3f
--- /dev/null
+++ b/frontend/frontend.h
@@ -0,0 +1,39 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef FRONTEND_H
+#define FRONTEND_H
+
+#include "standards.h"
+
+#include <list>
+
+struct FileSettings;
+class Settings;
+class FileWithDetails;
+
+namespace frontend
+{
+    /**
+        Applies the enforced language as all as identifying remaining files - also taking markup files into consideration.
+     */
+    void applyLang(std::list<FileSettings> &fileSettings, const Settings &settings, Standards::Language enforcedLang);
+    void applyLang(std::list<FileWithDetails> &files, const Settings &settings, Standards::Language enforcedLang);
+}
+
+#endif // FRONTEND_H
diff --git a/generate_coverage_report b/generate_coverage_report
deleted file mode 100755
index 69766de3f77..00000000000
--- a/generate_coverage_report
+++ /dev/null
@@ -1,20 +0,0 @@
-#!/bin/bash
-set -e
-make clean
-rm -rf coverage_report
-make test CXXFLAGS="-g -fprofile-arcs -ftest-coverage"
-test/cfg/runtests.sh
-gcov lib/*.cpp -o lib/
-lcov --directory ./ --capture --output-file lcov_tmp.info -b ./
-lcov --extract lcov_tmp.info "$(pwd)/*" --output-file lcov.info
-genhtml lcov.info -o coverage_report --frame --legend --demangle-cpp
-rm cli/*.gcda
-rm cli/*.gcno
-rm lib/*.gcda
-rm lib/*.gcno
-rm test/*.gcda
-rm test/*.gcno
-rm externals/tinyxml/*.gcda
-rm externals/tinyxml/*.gcno
-rm lcov.info lcov_tmp.info
-make clean
diff --git a/gui/.clang-tidy b/gui/.clang-tidy
new file mode 100644
index 00000000000..8a62240d85a
--- /dev/null
+++ b/gui/.clang-tidy
@@ -0,0 +1,5 @@
+---
+Checks: >
+        -readability-convert-member-functions-to-static,
+        -readability-redundant-access-specifiers
+InheritParentConfig: true
diff --git a/gui/CMakeLists.txt b/gui/CMakeLists.txt
index 1678dbbe109..d640c341458 100644
--- a/gui/CMakeLists.txt
+++ b/gui/CMakeLists.txt
@@ -1,33 +1,74 @@
 if (BUILD_GUI)
 
-    set(CMAKE_AUTOMOC ON)
-    if (${CMAKE_BUILD_TYPE} STREQUAL "Release")
-        add_definitions(-DQT_NO_DEBUG)
-        add_definitions(-DQT_NO_DEBUG_OUTPUT)
-        add_definitions(-DQT_NO_WARNING_OUTPUT)
-    else()
-        add_definitions(-DQT_DEBUG)
-    endif()
-
-    include_directories(${PROJECT_SOURCE_DIR}/lib/)
-    include_directories(SYSTEM ${PROJECT_SOURCE_DIR}/externals/tinyxml/)
+    # disable all clang-tidy checks for Qt generated files
+    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/.clang-tidy"
+"---
+Checks:          '-*,misc-definitions-in-headers'
+WarningsAsErrors: '*'
+CheckOptions:
+  - { key: HeaderFileExtensions,          value: 'x' }
+")
 
     file(GLOB hdrs "*.h")
     file(GLOB srcs "*.cpp")
     file(GLOB uis  "*.ui")
     file(GLOB tss  "*.ts")
-    QT5_WRAP_UI(uis_hdrs ${uis})
-    QT5_ADD_RESOURCES(resources "gui.qrc")
-    QT5_ADD_TRANSLATION(qms ${tss})
+    QT_WRAP_UI(uis_hdrs ${uis})
+    QT_ADD_RESOURCES(resources "gui.qrc")
+    # TODO: passing "-no-obsolete" here breaks the translations
+    QT_CREATE_TRANSLATION(qms ${CMAKE_CURRENT_SOURCE_DIR} ${tss})
+    list(APPEND cppcheck-gui-deps ${hdrs} ${uis_hdrs} ${resources} ${qms})
+    add_custom_target(gui-build-deps SOURCES ${cppcheck-gui-deps})
+
+    list(APPEND cppcheck-gui_SOURCES ${srcs})
+    if (WIN32)
+        list(APPEND cppcheck-gui_SOURCES cppcheck-gui.rc)
+    endif()
 
-    add_executable(cppcheck-gui ${hdrs} ${srcs} ${uis_hdrs} ${resources} ${qms} $<TARGET_OBJECTS:lib_objs> $<TARGET_OBJECTS:tinyxml_objs> $<TARGET_OBJECTS:simplecpp_objs>)
+    add_executable(cppcheck-gui ${cppcheck-gui-deps} ${cppcheck-gui_SOURCES})
+    target_link_libraries(cppcheck-gui cppcheck-core simplecpp tinyxml2 picojson frontend)
+
+    set_target_properties(cppcheck-gui PROPERTIES AUTOMOC ON)
+    set_target_properties(cppcheck-gui PROPERTIES WIN32_EXECUTABLE ON)
+    if (NOT CMAKE_DISABLE_PRECOMPILE_HEADERS)
+        target_precompile_headers(cppcheck-gui PRIVATE precompiled.h)
+    endif()
     if (HAVE_RULES)
-        target_link_libraries(cppcheck-gui pcre)
+        target_link_libraries(cppcheck-gui ${PCRE_LIBRARY})
     endif()
-    target_link_libraries(cppcheck-gui Qt5::Core Qt5::Gui Qt5::Widgets Qt5::PrintSupport)
+    target_link_libraries(cppcheck-gui ${QT_CORE_LIB} ${QT_GUI_LIB} ${QT_WIDGETS_LIB} ${QT_PRINTSUPPORT_LIB} ${QT_HELP_LIB} ${QT_NETWORK_LIB})
     if(WITH_QCHART)
-        target_compile_definitions (cppcheck-gui PRIVATE HAVE_QCHART )
-        target_link_libraries(cppcheck-gui Qt5::Charts)
+        target_link_libraries(cppcheck-gui ${QT_CHARTS_LIB})
+    endif()
+    if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        if(QT_VERSION VERSION_LESS "6.4.0")
+            # caused by Qt generated moc code - see https://bugreports.qt.io/browse/QTBUG-100915
+            target_compile_options_safe(cppcheck-gui -Wno-redundant-parens)
+        endif()
+        if(QT_VERSION VERSION_GREATER_EQUAL "6.9.0")
+            # caused by Qt generated moc code starting with 6.9.0 - see https://bugreports.qt.io/browse/QTBUG-135638
+            target_compile_options_safe(cppcheck-gui -Wno-ctad-maybe-unsupported)
+        endif()
+    elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        # caused by mocs
+        target_compile_options_safe(cppcheck-gui -Wno-useless-cast)
+    endif()
+    if(QT_VERSION VERSION_GREATER_EQUAL "6.9.2")
+        # QBrush fails to compile before 6.9.0 - see https://bugreports.qt.io/browse/QTBUG-134038
+        # QtCharts/qxyseries.h fails to compile in 6.9.0 and 6.9.1 - see https://bugreports.qt.io/browse/QTBUG-135637
+        #target_compile_definitions(cppcheck-gui PRIVATE -DQT_NO_QPAIR)
+    endif()
+    target_compile_definitions(cppcheck-gui PRIVATE -DQT_NO_FOREACH)
+
+    target_compile_definitions(cppcheck-gui PRIVATE $<$<NOT:$<CONFIG:Debug>>:QT_NO_DEBUG>)
+    target_compile_definitions(cppcheck-gui PRIVATE $<$<NOT:$<CONFIG:Debug>>:QT_NO_DEBUG_OUTPUT>)
+    target_compile_definitions(cppcheck-gui PRIVATE $<$<NOT:$<CONFIG:Debug>>:QT_NO_WARNING_OUTPUT>)
+    target_compile_definitions(cppcheck-gui PRIVATE $<$<CONFIG:Debug>:QT_DEBUG>)
+
+    if (QHELPGENERATOR)
+        # TODO: generate in CMAKE_BINARY_DIR folder
+        add_custom_target(online-help.qhc ${QHELPGENERATOR} ${CMAKE_CURRENT_SOURCE_DIR}/help/online-help.qhcp -o ${CMAKE_CURRENT_SOURCE_DIR}/help/online-help.qhc)
+        add_dependencies(cppcheck-gui online-help.qhc)
     endif()
 
     install(TARGETS cppcheck-gui RUNTIME DESTINATION ${CMAKE_INSTALL_FULL_BINDIR} COMPONENT applications)
@@ -39,6 +80,14 @@ if (BUILD_GUI)
     install(FILES cppcheck-gui.svg DESTINATION ${CMAKE_INSTALL_DATADIR}/icons/hicolor/scalable/apps)
     install(FILES cppcheck-gui.png DESTINATION ${CMAKE_INSTALL_DATADIR}/icons/hicolor/64x64/apps)
 
-    set(CMAKE_AUTOMOC OFF)
+    add_dependencies(cppcheck-gui copy_cfg)
+    add_dependencies(cppcheck-gui copy_addons)
+    add_dependencies(cppcheck-gui copy_platforms)
+    if (NOT DISABLE_DMAKE)
+        add_dependencies(cppcheck-gui run-dmake)
+    endif()
 
+    if (BUILD_TESTING)
+        add_subdirectory(test)
+    endif()
 endif()
diff --git a/gui/about.ui b/gui/about.ui
index b1fca7de6fa..72cec833b1b 100644
--- a/gui/about.ui
+++ b/gui/about.ui
@@ -78,7 +78,7 @@
        <item>
         <widget class="QLabel" name="mCopyright">
          <property name="text">
-          <string>Copyright © 2007-2019 Cppcheck team.</string>
+          <string>Copyright © 2007-%1 Cppcheck team.</string>
          </property>
          <property name="wordWrap">
           <bool>true</bool>
@@ -112,12 +112,7 @@ of the GNU General Public License version 3</string>
        <item>
         <widget class="QLabel" name="mUsedLibs">
          <property name="text">
-          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
-&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul&gt;
-&lt;li&gt;tinyxml2&lt;/li&gt;
-&lt;li&gt;picojson&lt;/li&gt;
-&lt;li&gt;pcre&lt;/li&gt;
-&lt;li&gt;qt&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</string>
+          <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PCRE&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PicoJSON&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;TinyXML2&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Boost&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</string>
          </property>
         </widget>
        </item>
diff --git a/gui/aboutdialog.cpp b/gui/aboutdialog.cpp
index 71a3047bac8..d93d8e8a32f 100644
--- a/gui/aboutdialog.cpp
+++ b/gui/aboutdialog.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2017 Cppcheck team.
+ * Copyright (C) 2007-2022 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,22 +16,32 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QDialog>
-#include <QWidget>
-#include <QString>
 #include "aboutdialog.h"
 
+#include "ui_about.h"
+
+#include <QDialogButtonBox>
+#include <QLabel>
+
 AboutDialog::AboutDialog(const QString &version, const QString &extraVersion, QWidget *parent)
     : QDialog(parent)
+    , mUI(new Ui::About)
 {
-    mUI.setupUi(this);
+    mUI->setupUi(this);
 
     QString fmtVersion(version);
     if (!extraVersion.isEmpty()) {
         fmtVersion += " (" + extraVersion + ")";
     }
-    mUI.mVersion->setText(mUI.mVersion->text().arg(fmtVersion));
-    QString url = "<a href=\"http://cppcheck.net/\">http://cppcheck.net/</a>";
-    mUI.mHomepage->setText(mUI.mHomepage->text().arg(url));
-    connect(mUI.mButtons, &QDialogButtonBox::accepted, this, &AboutDialog::accept);
+    mUI->mVersion->setText(mUI->mVersion->text().arg(fmtVersion));
+    QString date = __DATE__;
+    mUI->mCopyright->setText(mUI->mCopyright->text().arg(date.right(4)));
+    QString url = "<a href=\"https://cppcheck.sourceforge.io/\">https://cppcheck.sourceforge.io/</a>";
+    mUI->mHomepage->setText(mUI->mHomepage->text().arg(url));
+    connect(mUI->mButtons, &QDialogButtonBox::accepted, this, &AboutDialog::accept);
+}
+
+AboutDialog::~AboutDialog()
+{
+    delete mUI;
 }
diff --git a/gui/aboutdialog.h b/gui/aboutdialog.h
index 18a225e3f51..2ce51c0930b 100644
--- a/gui/aboutdialog.h
+++ b/gui/aboutdialog.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,18 +20,21 @@
 #define ABOUT_DIALOG_H
 
 #include <QDialog>
+#include <QObject>
 #include <QString>
-#include "ui_about.h"
 
 class QWidget;
+namespace Ui {
+    class About;
+}
 
 /// @addtogroup GUI
 /// @{
 
 /**
-* @brief About dialog
-*
-*/
+ * @brief About dialog
+ *
+ */
 class AboutDialog : public QDialog {
     Q_OBJECT
 public:
@@ -39,8 +42,10 @@ class AboutDialog : public QDialog {
                 const QString &extraVersion,
                 QWidget *parent = nullptr);
 
+    ~AboutDialog() override;
+
 private:
-    Ui::About mUI;
+    Ui::About* mUI;
 };
 /// @}
 #endif // ABOUT_DIALOG_H
diff --git a/gui/application.cpp b/gui/application.cpp
index 69c3e8fc843..e3cc7b9957b 100644
--- a/gui/application.cpp
+++ b/gui/application.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2016 Cppcheck team.
+ * Copyright (C) 2007-2023 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -9,7 +9,7 @@
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
@@ -18,10 +18,11 @@
 
 #include "application.h"
 
-Application::Application(const QString &name, const QString &path,
-                         const QString &params)
-    : mName(name)
-    , mPath(path)
-    , mParameters(params)
-{
-}
+#include <utility>
+
+Application::Application(QString name, QString path,
+                         QString params)
+    : mName(std::move(name))
+    , mPath(std::move(path))
+    , mParameters(std::move(params))
+{}
diff --git a/gui/application.h b/gui/application.h
index 6539d328388..a7ffd34ffe9 100644
--- a/gui/application.h
+++ b/gui/application.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2016 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,73 +22,73 @@
 #include <QString>
 
 /**
-* @brief A class containing information of the application to execute.
-*
-* Each application has a name and a path. Name is displayed to the user
-* and has no other meaning. It isn't used to start the application.
-* Path contains the full path to the application containing the executable name.
-* Parameters contains the command line arguments for the executable.
-*
-* User can also specify certain predefined strings to parameters. These strings
-* will be replaced with appropriate values concerning the error. Strings are:
-* (file) - Filename containing the error
-* (line) - Line number containing the error
-* (message) - Error message
-* (severity) - Error severity
-*
-* Example opening a file with Kate and make Kate scroll to the correct line.
-* Executable: kate
-* Parameters: -l(line) (file)
-*/
+ * @brief A class containing information of the application to execute.
+ *
+ * Each application has a name and a path. Name is displayed to the user
+ * and has no other meaning. It isn't used to start the application.
+ * Path contains the full path to the application containing the executable name.
+ * Parameters contains the command line arguments for the executable.
+ *
+ * User can also specify certain predefined strings to parameters. These strings
+ * will be replaced with appropriate values concerning the error. Strings are:
+ * (file) - Filename containing the error
+ * (line) - Line number containing the error
+ * (message) - Error message
+ * (severity) - Error severity
+ *
+ * Example opening a file with Kate and make Kate scroll to the correct line.
+ * Executable: kate
+ * Parameters: -l(line) (file)
+ */
 class Application {
 public:
-    Application() { }
-    Application(const QString &name, const QString &path, const QString &params);
+    Application() = default;
+    Application(QString name, QString path, QString params);
 
     /**
-    * @brief Get application name.
-    * @return Application name.
-    */
-    QString getName() const {
+     * @brief Get application name.
+     * @return Application name.
+     */
+    const QString& getName() const {
         return mName;
     }
 
     /**
-    * @brief Get application path.
-    * @return Application path.
-    */
-    QString getPath() const {
+     * @brief Get application path.
+     * @return Application path.
+     */
+    const QString& getPath() const {
         return mPath;
     }
 
     /**
-    * @brief Get application command line parameters.
-    * @return Application command line parameters.
-    */
-    QString getParameters() const {
+     * @brief Get application command line parameters.
+     * @return Application command line parameters.
+     */
+    const QString& getParameters() const {
         return mParameters;
     }
 
     /**
-    * @brief Set application name.
-    * @param name Application name.
-    */
+     * @brief Set application name.
+     * @param name Application name.
+     */
     void setName(const QString &name) {
         mName = name;
     }
 
     /**
-    * @brief Set application path.
-    * @param path Application path.
-    */
+     * @brief Set application path.
+     * @param path Application path.
+     */
     void setPath(const QString &path) {
         mPath = path;
     }
 
     /**
-    * @brief Set application command line parameters.
-    * @param parameters Application command line parameters.
-    */
+     * @brief Set application command line parameters.
+     * @param parameters Application command line parameters.
+     */
     void setParameters(const QString &parameters) {
         mParameters = parameters;
     }
@@ -96,18 +96,18 @@ class Application {
 private:
 
     /**
-    * @brief Application's name
-    */
+     * @brief Application's name
+     */
     QString mName;
 
     /**
-    * @brief Application's path
-    */
+     * @brief Application's path
+     */
     QString mPath;
 
     /**
-    * @brief Application's parameters
-    */
+     * @brief Application's parameters
+     */
     QString mParameters;
 };
 
diff --git a/gui/applicationdialog.cpp b/gui/applicationdialog.cpp
index d5b983dabbb..bc8804d6f97 100644
--- a/gui/applicationdialog.cpp
+++ b/gui/applicationdialog.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2017 Cppcheck team.
+ * Copyright (C) 2007-2023 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,30 +16,36 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QString>
-#include <QWidget>
-#include <QDialog>
-#include <QFileDialog>
-#include <QMessageBox>
 #include "applicationdialog.h"
+
 #include "application.h"
 #include "common.h"
 
+#include "ui_applicationdialog.h"
+
+#include <QDialogButtonBox>
+#include <QDir>
+#include <QFileDialog>
+#include <QLineEdit>
+#include <QMessageBox>
+#include <QPushButton>
+
 
 ApplicationDialog::ApplicationDialog(const QString &title,
                                      Application &app,
                                      QWidget *parent) :
     QDialog(parent),
+    mUI(new Ui::ApplicationDialog),
     mApplication(app)
 {
-    mUI.setupUi(this);
+    mUI->setupUi(this);
 
-    connect(mUI.mButtonBrowse, &QPushButton::clicked, this, &ApplicationDialog::browse);
-    connect(mUI.mButtons, &QDialogButtonBox::accepted, this, &ApplicationDialog::ok);
-    connect(mUI.mButtons, &QDialogButtonBox::rejected, this, &ApplicationDialog::reject);
-    mUI.mPath->setText(app.getPath());
-    mUI.mName->setText(app.getName());
-    mUI.mParameters->setText(app.getParameters());
+    connect(mUI->mButtonBrowse, &QPushButton::clicked, this, &ApplicationDialog::browse);
+    connect(mUI->mButtons, &QDialogButtonBox::accepted, this, &ApplicationDialog::ok);
+    connect(mUI->mButtons, &QDialogButtonBox::rejected, this, &ApplicationDialog::reject);
+    mUI->mPath->setText(app.getPath());
+    mUI->mName->setText(app.getName());
+    mUI->mParameters->setText(app.getParameters());
     setWindowTitle(title);
     adjustSize();
 }
@@ -47,7 +53,7 @@ ApplicationDialog::ApplicationDialog(const QString &title,
 
 ApplicationDialog::~ApplicationDialog()
 {
-    //dtor
+    delete mUI;
 }
 
 void ApplicationDialog::browse()
@@ -59,20 +65,20 @@ void ApplicationDialog::browse()
     filter += tr("Executable files (*.exe);;All files(*.*)");
 #endif // Q_OS_WIN
     QString selectedFile = QFileDialog::getOpenFileName(this,
-                           tr("Select viewer application"),
-                           getPath(SETTINGS_LAST_APP_PATH),
-                           filter);
+                                                        tr("Select viewer application"),
+                                                        getPath(SETTINGS_LAST_APP_PATH),
+                                                        filter);
 
     if (!selectedFile.isEmpty()) {
         setPath(SETTINGS_LAST_APP_PATH, selectedFile);
         QString path(QDir::toNativeSeparators(selectedFile));
-        mUI.mPath->setText(path);
+        mUI->mPath->setText(path);
     }
 }
 
 void ApplicationDialog::ok()
 {
-    if (mUI.mName->text().isEmpty() || mUI.mPath->text().isEmpty()) {
+    if (mUI->mName->text().isEmpty() || mUI->mPath->text().isEmpty()) {
         QMessageBox msg(QMessageBox::Warning,
                         tr("Cppcheck"),
                         tr("You must specify a name, a path and optionally parameters for the application!"),
@@ -84,9 +90,9 @@ void ApplicationDialog::ok()
         reject();
     } else {
         // Convert possible native (Windows) path to internal presentation format
-        mApplication.setName(mUI.mName->text());
-        mApplication.setPath(QDir::fromNativeSeparators(mUI.mPath->text()));
-        mApplication.setParameters(mUI.mParameters->text());
+        mApplication.setName(mUI->mName->text());
+        mApplication.setPath(QDir::fromNativeSeparators(mUI->mPath->text()));
+        mApplication.setParameters(mUI->mParameters->text());
 
         accept();
     }
diff --git a/gui/applicationdialog.h b/gui/applicationdialog.h
index ad45ac2a94f..49b9df70668 100644
--- a/gui/applicationdialog.h
+++ b/gui/applicationdialog.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,59 +20,62 @@
 #define APPLICATIONDIALOG_H
 
 #include <QDialog>
+#include <QObject>
 #include <QString>
-#include "application.h"
-#include "ui_application.h"
 
 class QWidget;
+class Application;
+namespace Ui {
+    class ApplicationDialog;
+}
 
 /// @addtogroup GUI
 /// @{
 
 /**
-* @brief Dialog to edit a startable application.
-* User can open errors with user specified applications. This is a dialog
-* to modify/add an application to open errors with.
-*
-*/
+ * @brief Dialog to edit a startable application.
+ * User can open errors with user specified applications. This is a dialog
+ * to modify/add an application to open errors with.
+ *
+ */
 class ApplicationDialog : public QDialog {
     Q_OBJECT
 
 public:
     /**
-    * @brief Constructor.
-    * @param title Title for the dialog.
-    * @param app Application definition.
-    * @param parent Parent widget.
-    */
+     * @brief Constructor.
+     * @param title Title for the dialog.
+     * @param app Application definition.
+     * @param parent Parent widget.
+     */
     ApplicationDialog(const QString &title,
                       Application &app,
                       QWidget *parent = nullptr);
-    virtual ~ApplicationDialog();
+    ~ApplicationDialog() override;
 
 protected slots:
 
     void ok();
 
     /**
-    * @brief Slot to browse for an application
-    *
-    */
+     * @brief Slot to browse for an application
+     *
+     */
     void browse();
 
 protected:
 
     /**
-    * @brief UI from the Qt designer
-    *
-    */
-    Ui::ApplicationDialog mUI;
+     * @brief UI from the Qt designer
+     *
+     */
+    Ui::ApplicationDialog* mUI;
 
 private:
 
     /**
-    * @brief Underlying Application
-    */
+     * @brief Underlying Application
+     */
     Application& mApplication;
 };
 /// @}
diff --git a/gui/application.ui b/gui/applicationdialog.ui
similarity index 100%
rename from gui/application.ui
rename to gui/applicationdialog.ui
diff --git a/gui/applicationlist.cpp b/gui/applicationlist.cpp
index 03e8e02fecb..80efbddbb0e 100644
--- a/gui/applicationlist.cpp
+++ b/gui/applicationlist.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2023 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,20 +16,18 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QFileInfo>
-#include <QObject>
-#include <QSettings>
-#include <QStringList>
-
-#include "common.h"
 #include "applicationlist.h"
+
 #include "application.h"
+#include "common.h"
 
-#include <cstdlib>
+#include <QFileInfo>
+#include <QSettings>
+#include <QStringList>
+#include <QVariant>
 
 ApplicationList::ApplicationList(QObject *parent) :
-    QObject(parent),
-    mDefaultApplicationIndex(-1)
+    QObject(parent)
 {
     //ctor
 }
@@ -185,9 +183,9 @@ void ApplicationList::clear()
     mDefaultApplicationIndex = -1;
 }
 
-bool ApplicationList::checkAndAddApplication(QString appPath, QString name, QString parameters)
+bool ApplicationList::checkAndAddApplication(const QString& appPath, const QString& name, const QString& parameters)
 {
-    if (QFileInfo(appPath).exists() && QFileInfo(appPath).isExecutable()) {
+    if (QFileInfo::exists(appPath) && QFileInfo(appPath).isExecutable()) {
         Application app;
         app.setName(name);
         app.setPath("\"" + appPath + "\"");
@@ -198,6 +196,7 @@ bool ApplicationList::checkAndAddApplication(QString appPath, QString name, QStr
     return false;
 }
 
+#ifdef _WIN32
 bool ApplicationList::findDefaultWindowsEditor()
 {
     bool foundOne = false;
@@ -264,3 +263,4 @@ bool ApplicationList::findDefaultWindowsEditor()
 
     return foundOne;
 }
+#endif
diff --git a/gui/applicationlist.h b/gui/applicationlist.h
index 019b7a53bbc..660fb0e1a46 100644
--- a/gui/applicationlist.h
+++ b/gui/applicationlist.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,116 +19,121 @@
 #ifndef APPLICATIONLIST_H
 #define APPLICATIONLIST_H
 
-#include <QObject>
 #include "application.h"
 
+#include <QList>
+#include <QObject>
+#include <QString>
+
 /// @addtogroup GUI
 /// @{
 
 
 /**
-* @brief List of applications user has specified to open errors with.
-*/
+ * @brief List of applications user has specified to open errors with.
+ */
 class ApplicationList : public QObject {
     Q_OBJECT
 public:
 
     explicit ApplicationList(QObject *parent = nullptr);
-    virtual ~ApplicationList();
+    ~ApplicationList() override;
 
     /**
-    * @brief Load all applications
-    *
-    * @return true if loading succeeded, false if there is problem with
-    *  application list. Most probably because of older version settings need
-    *  to be upgraded.
-    */
+     * @brief Load all applications
+     *
+     * @return true if loading succeeded, false if there is problem with
+     *  application list. Most probably because of older version settings need
+     *  to be upgraded.
+     */
     bool loadSettings();
 
     /**
-    * @brief Save all applications
-    */
+     * @brief Save all applications
+     */
     void saveSettings() const;
 
     /**
-    * @brief Get the amount of applications in the list
-    * @return The count of applications
-    */
+     * @brief Get the amount of applications in the list
+     * @return The count of applications
+     */
     int getApplicationCount() const;
 
     /**
-    * @brief Get specific application's name
-    *
-    * @param index Index of the application whose name to get
-    * @return Name of the application
-    */
-    const Application& getApplication(const int index) const;
-    Application& getApplication(const int index);
+     * @brief Get specific application's name
+     *
+     * @param index Index of the application whose name to get
+     * @return Name of the application
+     */
+    const Application& getApplication(int index) const;
+    Application& getApplication(int index);
 
     /**
-    * @brief Return the default application.
-    * @return Index of the default application.
-    */
+     * @brief Return the default application.
+     * @return Index of the default application.
+     */
     int getDefaultApplication() const {
         return mDefaultApplicationIndex;
     }
 
     /**
-    * @brief Add a new application
-    *
-    * @param app Application to add.
-    */
+     * @brief Add a new application
+     *
+     * @param app Application to add.
+     */
     void addApplication(const Application &app);
 
     /**
-    * @brief Remove an application from the list
-    *
-    * @param index Index of the application to remove.
-    */
-    void removeApplication(const int index);
+     * @brief Remove an application from the list
+     *
+     * @param index Index of the application to remove.
+     */
+    void removeApplication(int index);
 
     /**
-    * @brief Set application as default application.
-    * @param index Index of the application to make the default one
-    */
-    void setDefault(const int index);
+     * @brief Set application as default application.
+     * @param index Index of the application to make the default one
+     */
+    void setDefault(int index);
 
     /**
-    * @brief Remove all applications from this list and copy all applications from
-    * list given as a parameter.
-    * @param list Copying source
-    */
+     * @brief Remove all applications from this list and copy all applications from
+     * list given as a parameter.
+     * @param list Copying source
+     */
     void copy(const ApplicationList *list);
 
 protected:
 
     /**
-    * @brief Clear the list
-    *
-    */
+     * @brief Clear the list
+     *
+     */
     void clear();
 
+#ifdef _WIN32
     /**
-    * @brief Find editor used by default in Windows.
-    * Check if Notepad++ is installed and use it. If not, use Notepad.
-    */
+     * @brief Find editor used by default in Windows.
+     * Check if Notepad++ is installed and use it. If not, use Notepad.
+     */
     bool findDefaultWindowsEditor();
+#endif
 
 private:
 
-    bool checkAndAddApplication(QString appPath, QString name, QString parameters);
+    bool checkAndAddApplication(const QString& appPath, const QString& name, const QString& parameters);
 
     /**
-    * @brief List of applications
-    *
-    */
+     * @brief List of applications
+     *
+     */
     QList<Application> mApplications;
 
     /**
-    * @brief Index of the default application.
-    *
-    */
-    int mDefaultApplicationIndex;
+     * @brief Index of the default application.
+     *
+     */
+    int mDefaultApplicationIndex = -1;
 };
 /// @}
 #endif // APPLICATIONLIST_H
diff --git a/gui/checkstatistics.cpp b/gui/checkstatistics.cpp
index 20eb5182d1b..612e79da63b 100644
--- a/gui/checkstatistics.cpp
+++ b/gui/checkstatistics.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2017 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,10 +16,17 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QDebug>
-#include <QStringList>
 #include "checkstatistics.h"
 
+#include "utils.h"
+
+#include <QDebug>
+#include <QList>
+#include <QSet>
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 5, 0))
+#include <QtLogging>
+#endif
+
 CheckStatistics::CheckStatistics(QObject *parent)
     : QObject(parent)
 {
@@ -28,10 +35,7 @@ CheckStatistics::CheckStatistics(QObject *parent)
 
 static void addItem(QMap<QString,unsigned> &m, const QString &key)
 {
-    if (m.contains(key))
-        m[key]++;
-    else
-        m[key] = 0;
+    m[key]++;
 }
 
 void CheckStatistics::addItem(const QString &tool, ShowTypes::ShowType type)
@@ -39,30 +43,34 @@ void CheckStatistics::addItem(const QString &tool, ShowTypes::ShowType type)
     const QString lower = tool.toLower();
     switch (type) {
     case ShowTypes::ShowStyle:
-        ::addItem(mStyle, tool);
+        ::addItem(mStyle, lower);
         break;
     case ShowTypes::ShowWarnings:
-        ::addItem(mWarning, tool);
+        ::addItem(mWarning, lower);
         break;
     case ShowTypes::ShowPerformance:
-        ::addItem(mPerformance, tool);
+        ::addItem(mPerformance, lower);
         break;
     case ShowTypes::ShowPortability:
-        ::addItem(mPortability, tool);
+        ::addItem(mPortability, lower);
         break;
     case ShowTypes::ShowErrors:
-        ::addItem(mError, tool);
+        ::addItem(mError, lower);
         break;
     case ShowTypes::ShowInformation:
-        ::addItem(mInformation, tool);
+        ::addItem(mInformation, lower);
         break;
     case ShowTypes::ShowNone:
-    default:
         qDebug() << "Unknown error type - not added to statistics.";
         break;
     }
 }
 
+void CheckStatistics::addChecker(const QString &checker)
+{
+    mActiveCheckers.insert(checker.toStdString());
+}
+
 void CheckStatistics::clear()
 {
     mStyle.clear();
@@ -71,6 +79,8 @@ void CheckStatistics::clear()
     mPortability.clear();
     mInformation.clear();
     mError.clear();
+    mActiveCheckers.clear();
+    mCheckersReport.clear();
 }
 
 unsigned CheckStatistics::getCount(const QString &tool, ShowTypes::ShowType type) const
@@ -90,19 +100,19 @@ unsigned CheckStatistics::getCount(const QString &tool, ShowTypes::ShowType type
     case ShowTypes::ShowInformation:
         return mInformation.value(lower,0);
     case ShowTypes::ShowNone:
-    default:
         qDebug() << "Unknown error type - returning zero statistics.";
         return 0;
     }
+    cppcheck::unreachable();
 }
 
 QStringList CheckStatistics::getTools() const
 {
     QSet<QString> ret;
-    foreach (QString tool, mStyle.keys()) ret.insert(tool);
-    foreach (QString tool, mWarning.keys()) ret.insert(tool);
-    foreach (QString tool, mPerformance.keys()) ret.insert(tool);
-    foreach (QString tool, mPortability.keys()) ret.insert(tool);
-    foreach (QString tool, mError.keys()) ret.insert(tool);
-    return QStringList(ret.toList());
+    for (const QString& tool: mStyle.keys()) ret.insert(tool);
+    for (const QString& tool: mWarning.keys()) ret.insert(tool);
+    for (const QString& tool: mPerformance.keys()) ret.insert(tool);
+    for (const QString& tool: mPortability.keys()) ret.insert(tool);
+    for (const QString& tool: mError.keys()) ret.insert(tool);
+    return ret.values();
 }
diff --git a/gui/checkstatistics.h b/gui/checkstatistics.h
index c28d897b0b3..5998c1f6b0c 100644
--- a/gui/checkstatistics.h
+++ b/gui/checkstatistics.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,9 +19,17 @@
 #ifndef CHECKSTATISTICS_H
 #define CHECKSTATISTICS_H
 
-#include <QObject>
 #include "showtypes.h"
 
+#include <QMap>
+#include <QObject>
+#include <QString>
+#include <QStringList>
+
+#include <set>
+#include <string>
+#include <utility>
+
 /// @addtogroup GUI
 /// @{
 
@@ -33,31 +41,51 @@ class CheckStatistics : public QObject {
     explicit CheckStatistics(QObject *parent = nullptr);
 
     /**
-    * @brief Add new checked item to statistics.
-    *
-    * @param tool Tool.
-    * @param type Type of the item to add.
-    */
+     * @brief Add new checked item to statistics.
+     *
+     * @param tool Tool.
+     * @param type Type of the item to add.
+     */
     void addItem(const QString &tool, ShowTypes::ShowType type);
 
     /**
-    * @brief Clear the statistics.
-    *
-    */
+     * @brief Add checker to statistics
+     */
+    void addChecker(const QString& checker);
+
+    /**
+     * @brief Clear the statistics.
+     *
+     */
     void clear();
 
     /**
-    * @brief Return statistics for given type.
-    *
-    * @param tool Tool.
-    * @param type Type for which the statistics are returned.
-    * @return Number of items of given type.
-    */
+     * @brief Return statistics for given type.
+     *
+     * @param tool Tool.
+     * @param type Type for which the statistics are returned.
+     * @return Number of items of given type.
+     */
     unsigned getCount(const QString &tool, ShowTypes::ShowType type) const;
 
+    const std::set<std::string>& getActiveCheckers() const {
+        return mActiveCheckers;
+    }
+
+    int getNumberOfActiveCheckers() const {
+        return mActiveCheckers.size();
+    }
+
     /** Get tools with results */
     QStringList getTools() const;
 
+    void setCheckersReport(QString report) {
+        mCheckersReport = std::move(report);
+    }
+    const QString& getCheckersReport() const {
+        return mCheckersReport;
+    }
+
 private:
     QMap<QString, unsigned> mStyle;
     QMap<QString, unsigned> mWarning;
@@ -65,6 +93,8 @@ class CheckStatistics : public QObject {
     QMap<QString, unsigned> mPortability;
     QMap<QString, unsigned> mInformation;
     QMap<QString, unsigned> mError;
+    std::set<std::string> mActiveCheckers;
+    QString mCheckersReport;
 };
 
 /// @}
diff --git a/gui/checkthread.cpp b/gui/checkthread.cpp
index 31703812aa9..07ca4e77ed2 100644
--- a/gui/checkthread.cpp
+++ b/gui/checkthread.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,46 +16,112 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QApplication>
-#include <QString>
+#include "checkthread.h"
+
+#include "analyzerinfo.h"
+#include "common.h"
+#include "cppcheck.h"
+#include "erroritem.h"
+#include "errorlogger.h"
+#include "errortypes.h"
+#include "filesettings.h"
+#include "settings.h"
+#include "standards.h"
+#include "threadresult.h"
+#include "utils.h"
+
+#include <algorithm>
+#include <fstream>
+#include <iterator>
+#include <list>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <QByteArray>
+#include <QChar>
 #include <QDebug>
 #include <QDir>
-#include <QFileInfo>
-#include <QJsonDocument>
-#include <QJsonObject>
+#include <QFile>
+#include <QIODevice>
 #include <QProcess>
+#include <QRegularExpression>
 #include <QSettings>
-#include "checkthread.h"
-#include "erroritem.h"
-#include "threadresult.h"
-#include "cppcheck.h"
-#include "common.h"
+#include <QTextStream>
+#include <QVariant>
 
-CheckThread::CheckThread(ThreadResult &result) :
-    mState(Ready),
-    mResult(result),
-    mCppcheck(result, true),
-    mAnalyseWholeProgram(false)
-{
-    //ctor
+static QString unquote(QString s) {
+    if (s.startsWith("\""))
+        s = s.mid(1, s.size() - 2);
+    return s;
 }
 
-CheckThread::~CheckThread()
+// NOLINTNEXTLINE(performance-unnecessary-value-param) - used as callback so we need to preserve the signature
+int CheckThread::executeCommand(std::string exe, std::vector<std::string> args, std::string redirect, std::string &output) // cppcheck-suppress passedByValueCallback
 {
-    //dtor
+    output.clear();
+
+    QStringList args2;
+    for (const std::string &arg: args)
+        args2 << QString::fromStdString(arg);
+
+    QProcess process;
+
+    QString e = unquote(QString::fromStdString(exe));
+
+    if (e.toLower().replace("\\", "/").endsWith("/python.exe") && !args.empty()) {
+        const QString path = e.left(e.size()-11);
+        QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
+        env.insert("PYTHONPATH", path + "/Lib/site-packages");
+        env.insert("PYTHONHOME", path);
+        process.setProcessEnvironment(env);
+
+        const QString pythonScript = unquote(args2[0]);
+        if (pythonScript.endsWith(".py")) {
+            const QString path2 = pythonScript.left(QString(pythonScript).replace('\\', '/').lastIndexOf("/"));
+            process.setWorkingDirectory(path2);
+        }
+    }
+
+    process.start(e, args2);
+    while (!Settings::terminated() && !process.waitForFinished(1000)) {
+        if (process.state() == QProcess::ProcessState::NotRunning)
+            break;
+    }
+
+    if (redirect == "2>&1") {
+        QString s1 = process.readAllStandardOutput();
+        QString s2 = process.readAllStandardError();
+        output = (s1 + "\n" + s2).toStdString();
+    } else
+        output = process.readAllStandardOutput().toStdString();
+
+    if (startsWith(redirect, "2> ")) {
+        std::ofstream fout(redirect.substr(3));
+        fout << process.readAllStandardError().toStdString();
+    }
+    return process.exitCode();
 }
 
-void CheckThread::check(const Settings &settings)
+
+CheckThread::CheckThread(ThreadResult &result, int threadIndex)
+    : mResult(result)
+    , mThreadIndex(threadIndex)
+{}
+
+void CheckThread::setSettings(const Settings &settings, std::shared_ptr<Suppressions> supprs)
 {
     mFiles.clear();
-    mCppcheck.settings() = settings;
-    start();
+    mSettings = settings; // this is a copy
+    mSuppressions = std::move(supprs);
 }
 
-void CheckThread::analyseWholeProgram(const QStringList &files)
+void CheckThread::analyseWholeProgram(const std::list<FileWithDetails> &files, const std::string& ctuInfo)
 {
     mFiles = files;
     mAnalyseWholeProgram = true;
+    mCtuInfo = ctuInfo;
     start();
 }
 
@@ -63,42 +129,55 @@ void CheckThread::run()
 {
     mState = Running;
 
-    if (!mFiles.isEmpty() || mAnalyseWholeProgram) {
+    CppCheck cppcheck(mSettings, *mSuppressions, mResult, nullptr, true, executeCommand);
+
+    if (!mFiles.empty() || mAnalyseWholeProgram) {
         mAnalyseWholeProgram = false;
+        std::string ctuInfo;
+        ctuInfo.swap(mCtuInfo);
         qDebug() << "Whole program analysis";
-        const std::string &buildDir = mCppcheck.settings().buildDir;
-        if (!buildDir.empty()) {
-            std::map<std::string,std::size_t> files2;
-            for (QString file : mFiles)
-                files2[file.toStdString()] = 0;
-            mCppcheck.analyseWholeProgram(buildDir, files2);
-        }
+        cppcheck.analyseWholeProgram(mSettings.buildDir, mFiles, {}, ctuInfo);
         mFiles.clear();
         emit done();
         return;
     }
 
-    QString file = mResult.getNextFile();
-    while (!file.isEmpty() && mState == Running) {
-        qDebug() << "Checking file" << file;
-        mCppcheck.check(file.toStdString());
-        runAddonsAndTools(nullptr, file);
-        emit fileChecked(file);
+    // TODO: apply enforcedLanguage
+    const FileWithDetails* file = nullptr;
+    mResult.getNextFile(file);
+    while (file && mState == Running) {
+        const std::string& fname = file->spath();
+        qDebug() << "Checking file" << QString::fromStdString(fname);
+
+        const Details details{ mThreadIndex, QString::fromStdString(fname), QTime::currentTime(), };
+        emit startCheck(details);
+
+        cppcheck.check(*file);
+        runAddonsAndTools(mSettings, nullptr, QString::fromStdString(fname));
+
+        emit finishCheck(details);
 
         if (mState == Running)
-            file = mResult.getNextFile();
+            mResult.getNextFile(file);
     }
 
-    ImportProject::FileSettings fileSettings = mResult.getNextFileSettings();
-    while (!fileSettings.filename.empty() && mState == Running) {
-        file = QString::fromStdString(fileSettings.filename);
-        qDebug() << "Checking file" << file;
-        mCppcheck.check(fileSettings);
-        runAddonsAndTools(&fileSettings, QString::fromStdString(fileSettings.filename));
-        emit fileChecked(file);
+    const FileSettings* fileSettings = nullptr;
+    mResult.getNextFileSettings(fileSettings);
+    while (fileSettings && mState == Running) {
+        const std::string& fname = fileSettings->filename();
+        qDebug() << "Checking file" << QString::fromStdString(fname);
+
+        const Details details{ mThreadIndex, QString::fromStdString(fname), QTime::currentTime(), };
+        emit startCheck(details);
+
+        cppcheck.check(*fileSettings);
+        runAddonsAndTools(mSettings, fileSettings, QString::fromStdString(fname));
+
+        emit finishCheck(details);
+
 
         if (mState == Running)
-            fileSettings = mResult.getNextFileSettings();
+            mResult.getNextFileSettings(fileSettings);
     }
 
     if (mState == Running)
@@ -109,34 +188,32 @@ void CheckThread::run()
     emit done();
 }
 
-void CheckThread::runAddonsAndTools(const ImportProject::FileSettings *fileSettings, const QString &fileName)
+void CheckThread::runAddonsAndTools(const Settings& settings, const FileSettings *fileSettings, const QString &fileName)
 {
-    QString dumpFile;
-
-    foreach (const QString addon, mAddonsAndTools) {
+    for (const QString& addon : utils::as_const(mAddonsAndTools)) {
         if (addon == CLANG_ANALYZER || addon == CLANG_TIDY) {
             if (!fileSettings)
                 continue;
 
-            if (!fileSettings->cfg.empty() && fileSettings->cfg.compare(0,5,"Debug") != 0)
+            if (!fileSettings->cfg.empty() && !startsWith(fileSettings->cfg,"Debug"))
                 continue;
 
             QStringList args;
-            for (std::list<std::string>::const_iterator I = fileSettings->includePaths.begin(); I != fileSettings->includePaths.end(); ++I)
-                args << ("-I" + QString::fromStdString(*I));
-            for (std::list<std::string>::const_iterator i = fileSettings->systemIncludePaths.begin(); i != fileSettings->systemIncludePaths.end(); ++i)
+            for (auto incIt = fileSettings->includePaths.cbegin(); incIt != fileSettings->includePaths.cend(); ++incIt)
+                args << ("-I" + QString::fromStdString(*incIt));
+            for (auto i = fileSettings->systemIncludePaths.cbegin(); i != fileSettings->systemIncludePaths.cend(); ++i)
                 args << "-isystem" << QString::fromStdString(*i);
-            foreach (QString D, QString::fromStdString(fileSettings->defines).split(";")) {
-                args << ("-D" + D);
+            for (const QString& def : QString::fromStdString(fileSettings->defines).split(";")) {
+                args << ("-D" + def);
             }
-            foreach (const std::string& U, fileSettings->undefs) {
+            for (const std::string& U : fileSettings->undefs) {
                 args << QString::fromStdString("-U" + U);
             }
 
             const QString clangPath = CheckThread::clangTidyCmd();
             if (!clangPath.isEmpty()) {
                 QDir dir(clangPath + "/../lib/clang");
-                foreach (QString ver, dir.entryList()) {
+                for (const QString& ver : dir.entryList()) {
                     QString includePath = dir.absolutePath() + '/' + ver + "/include";
                     if (ver[0] != '.' && QDir(includePath).exists()) {
                         args << "-isystem" << includePath;
@@ -149,7 +226,7 @@ void CheckThread::runAddonsAndTools(const ImportProject::FileSettings *fileSetti
             // To create compile_commands.json in windows see:
             // https://bitsmaker.gitlab.io/post/clang-tidy-from-vs2015/
 
-            foreach (QString includePath, mClangIncludePaths) {
+            for (QString includePath : mClangIncludePaths) {
                 if (!includePath.isEmpty()) {
                     includePath.replace("\\", "/");
                     args << "-isystem" << includePath.trimmed();
@@ -162,30 +239,18 @@ void CheckThread::runAddonsAndTools(const ImportProject::FileSettings *fileSetti
             if (!fileSettings->standard.empty())
                 args << ("-std=" + QString::fromStdString(fileSettings->standard));
             else {
-                switch (mCppcheck.settings().standards.cpp) {
-                case Standards::CPP03:
-                    args << "-std=c++03";
-                    break;
-                case Standards::CPP11:
-                    args << "-std=c++11";
-                    break;
-                case Standards::CPP14:
-                    args << "-std=c++14";
-                    break;
-                case Standards::CPP17:
-                    args << "-std=c++17";
-                    break;
-                case Standards::CPP20:
-                    args << "-std=c++20";
-                    break;
-                };
+                // TODO: pass C or C++ standard based on file type
+                const std::string std = settings.standards.getCPP();
+                if (!std.empty()) {
+                    args << ("-std=" + QString::fromStdString(std));
+                }
             }
 
             QString analyzerInfoFile;
 
-            const std::string &buildDir = mCppcheck.settings().buildDir;
+            const std::string &buildDir = settings.buildDir;
             if (!buildDir.empty()) {
-                analyzerInfoFile = QString::fromStdString(AnalyzerInformation::getAnalyzerInfoFile(buildDir, fileSettings->filename, fileSettings->cfg));
+                analyzerInfoFile = QString::fromStdString(AnalyzerInformation::getAnalyzerInfoFile(buildDir, fileSettings->sfilename(), fileSettings->cfg, fileSettings->file.fsFileId()));
 
                 QStringList args2(args);
                 args2.insert(0,"-E");
@@ -194,7 +259,7 @@ void CheckThread::runAddonsAndTools(const ImportProject::FileSettings *fileSetti
                 process.start(clangCmd(),args2);
                 process.waitForFinished();
                 const QByteArray &ba = process.readAllStandardOutput();
-                const quint16 chksum = qChecksum(ba.data(), ba.length());
+                const quint16 chksum = qChecksum(QByteArrayView(ba));
 
                 QFile f1(analyzerInfoFile + '.' + addon + "-E");
                 if (f1.open(QIODevice::ReadOnly | QIODevice::Text)) {
@@ -210,7 +275,7 @@ void CheckThread::runAddonsAndTools(const ImportProject::FileSettings *fileSetti
                     }
                     f1.close();
                 }
-                f1.open(QIODevice::WriteOnly | QIODevice::Text);
+                (void)f1.open(QIODevice::WriteOnly | QIODevice::Text); // TODO: check result
                 QTextStream out1(&f1);
                 out1 << chksum;
 
@@ -219,12 +284,12 @@ void CheckThread::runAddonsAndTools(const ImportProject::FileSettings *fileSetti
 
             if (addon == CLANG_ANALYZER) {
                 /*
-                // Using clang
-                args.insert(0,"--analyze");
-                args.insert(1, "-Xanalyzer");
-                args.insert(2, "-analyzer-output=text");
-                args << fileName;
-                */
+                   // Using clang
+                   args.insert(0,"--analyze");
+                   args.insert(1, "-Xanalyzer");
+                   args.insert(2, "-analyzer-output=text");
+                   args << fileName;
+                 */
                 // Using clang-tidy
                 args.insert(0,"-checks=-*,clang-analyzer-*");
                 args.insert(1, fileName);
@@ -238,7 +303,7 @@ void CheckThread::runAddonsAndTools(const ImportProject::FileSettings *fileSetti
             {
                 const QString cmd(clangTidyCmd());
                 QString debug(cmd.contains(" ") ? ('\"' + cmd + '\"') : cmd);
-                foreach (QString arg, args) {
+                for (const QString& arg : utils::as_const(args)) {
                     if (arg.contains(" "))
                         debug += " \"" + arg + '\"';
                     else
@@ -268,60 +333,6 @@ void CheckThread::runAddonsAndTools(const ImportProject::FileSettings *fileSetti
             }
 
             parseClangErrors(addon, fileName, errout);
-        } else {
-            const QString python = CheckThread::pythonCmd();
-            if (python.isEmpty())
-                continue;
-
-            const QString addonFilePath = CheckThread::getAddonFilePath(mDataDir, addon + ".py");
-            if (addonFilePath.isEmpty())
-                continue;
-
-            if (dumpFile.isEmpty()) {
-                const std::string buildDir = mCppcheck.settings().buildDir;
-                mCppcheck.settings().buildDir.clear();
-                mCppcheck.settings().dump = true;
-                if (!buildDir.empty()) {
-                    mCppcheck.settings().dumpFile = AnalyzerInformation::getAnalyzerInfoFile(buildDir, fileName.toStdString(), fileSettings ? fileSettings->cfg : std::string()) + ".dump";
-                    dumpFile = QString::fromStdString(mCppcheck.settings().dumpFile);
-                } else {
-                    dumpFile = fileName + ".dump";
-                }
-                if (fileSettings)
-                    mCppcheck.check(*fileSettings);
-                else
-                    mCppcheck.check(fileName.toStdString());
-                mCppcheck.settings().dump = false;
-                mCppcheck.settings().dumpFile.clear();
-                mCppcheck.settings().buildDir = buildDir;
-            }
-
-            QStringList args;
-            args << addonFilePath << "--cli" << dumpFile;
-            if (addon == "misra" && !mMisraFile.isEmpty() && QFileInfo(mMisraFile).exists()) {
-                if (mMisraFile.endsWith(".pdf", Qt::CaseInsensitive))
-                    args << "--misra-pdf=" + mMisraFile;
-                else
-                    args << "--rule-texts=" + mMisraFile;
-            }
-            qDebug() << python << args;
-
-            QProcess process;
-            QProcessEnvironment env = process.processEnvironment();
-            if (!env.contains("PYTHONHOME") && !python.startsWith("python")) {
-                env.insert("PYTHONHOME", QFileInfo(python).canonicalPath());
-                process.setProcessEnvironment(env);
-            }
-            process.start(python, args);
-            process.waitForFinished();
-            const QString output(process.readAllStandardOutput());
-            QFile f(dumpFile + '-' + addon + "-results");
-            if (f.open(QIODevice::WriteOnly | QIODevice::Text)) {
-                QTextStream out(&f);
-                out << output;
-                f.close();
-            }
-            parseAddonErrors(output, addon);
         }
     }
 }
@@ -329,56 +340,15 @@ void CheckThread::runAddonsAndTools(const ImportProject::FileSettings *fileSetti
 void CheckThread::stop()
 {
     mState = Stopping;
-    mCppcheck.terminate();
-}
-
-void CheckThread::parseAddonErrors(QString err, const QString &tool)
-{
-    Q_UNUSED(tool);
-    QTextStream in(&err, QIODevice::ReadOnly);
-    while (!in.atEnd()) {
-        QString line = in.readLine();
-        if (!line.startsWith("{"))
-            continue;
-
-        const QJsonDocument doc = QJsonDocument::fromJson(line.toLocal8Bit());
-        const QJsonObject obj = doc.object();
-
-        /*
-        msg = { 'file': location.file,
-                'linenr': location.linenr,
-                'column': location.column,
-                'severity': severity,
-                'message': message,
-                'addon': addon,
-                'errorId': errorId,
-                'extra': extra}
-        */
-
-        const std::string &filename = obj["file"].toString().toStdString();
-        const int lineNumber = obj["linenr"].toInt();
-        const int column = obj["column"].toInt();
-        const std::string severity = obj["severity"].toString().toStdString();
-        const std::string message = obj["message"].toString().toStdString();
-        const std::string id = (obj["addon"].toString() + "-" + obj["errorId"].toString()).toStdString();
-
-        std::list<ErrorLogger::ErrorMessage::FileLocation> callstack;
-        callstack.push_back(ErrorLogger::ErrorMessage::FileLocation(filename, lineNumber, column));
-        ErrorLogger::ErrorMessage errmsg(callstack, filename, Severity::fromString(severity), message, id, false);
-
-        if (isSuppressed(errmsg.toSuppressionsErrorMessage()))
-            continue;
-
-        mResult.reportErr(errmsg);
-    }
+    Settings::terminate();
 }
 
 void CheckThread::parseClangErrors(const QString &tool, const QString &file0, QString err)
 {
     QList<ErrorItem> errorItems;
     ErrorItem errorItem;
-    QRegExp r1("(.+):([0-9]+):([0-9]+): (note|warning|error|fatal error): (.*)");
-    QRegExp r2("(.*)\\[([a-zA-Z0-9\\-_\\.]+)\\]");
+    static const QRegularExpression r1("^(.+):([0-9]+):([0-9]+): (note|warning|error|fatal error): (.*)$");
+    static const QRegularExpression r2("^(.*)\\[([a-zA-Z0-9\\-_\\.]+)\\]$");
     QTextStream in(&err, QIODevice::ReadOnly);
     while (!in.atEnd()) {
         QString line = in.readLine();
@@ -397,43 +367,45 @@ void CheckThread::parseClangErrors(const QString &tool, const QString &file0, QS
             continue;
         }
 
-        if (!r1.exactMatch(line))
+        const QRegularExpressionMatch r1MatchRes = r1.match(line);
+        if (!r1MatchRes.hasMatch())
             continue;
-        if (r1.cap(4) != "note") {
+        if (r1MatchRes.captured(4) != "note") {
             errorItems.append(errorItem);
             errorItem = ErrorItem();
-            errorItem.file0 = r1.cap(1);
+            errorItem.file0 = r1MatchRes.captured(1);
         }
 
         errorItem.errorPath.append(QErrorPathItem());
-        errorItem.errorPath.last().file = r1.cap(1);
-        errorItem.errorPath.last().line = r1.cap(2).toInt();
-        errorItem.errorPath.last().column = r1.cap(3).toInt();
-        if (r1.cap(4) == "warning")
-            errorItem.severity = Severity::SeverityType::warning;
-        else if (r1.cap(4) == "error" || r1.cap(4) == "fatal error")
-            errorItem.severity = Severity::SeverityType::error;
+        errorItem.errorPath.last().file = r1MatchRes.captured(1);
+        errorItem.errorPath.last().line = r1MatchRes.captured(2).toInt();
+        errorItem.errorPath.last().column = r1MatchRes.captured(3).toInt();
+        if (r1MatchRes.captured(4) == "warning")
+            errorItem.severity = Severity::warning;
+        else if (r1MatchRes.captured(4) == "error" || r1MatchRes.captured(4) == "fatal error")
+            errorItem.severity = Severity::error;
 
         QString message,id;
-        if (r2.exactMatch(r1.cap(5))) {
-            message = r2.cap(1);
-            const QString id1(r2.cap(2));
+        const QRegularExpressionMatch r2MatchRes = r2.match(r1MatchRes.captured(5));
+        if (r2MatchRes.hasMatch()) {
+            message = r2MatchRes.captured(1);
+            const QString id1(r2MatchRes.captured(2));
             if (id1.startsWith("clang"))
                 id = id1;
             else
-                id = tool + '-' + r2.cap(2);
+                id = tool + '-' + r2MatchRes.captured(2);
             if (tool == CLANG_TIDY) {
                 if (id1.startsWith("performance"))
-                    errorItem.severity = Severity::SeverityType::performance;
+                    errorItem.severity = Severity::performance;
                 else if (id1.startsWith("portability"))
-                    errorItem.severity = Severity::SeverityType::portability;
-                else if (id1.startsWith("cert") || (id1.startsWith("misc") && !id1.contains("unused")))
-                    errorItem.severity = Severity::SeverityType::warning;
+                    errorItem.severity = Severity::portability;
+                else if (id1.startsWith("misc") && !id1.contains("unused"))
+                    errorItem.severity = Severity::warning;
                 else
-                    errorItem.severity = Severity::SeverityType::style;
+                    errorItem.severity = Severity::style;
             }
         } else {
-            message = r1.cap(5);
+            message = r1MatchRes.captured(5);
             id = CLANG_ANALYZER;
         }
 
@@ -446,10 +418,10 @@ void CheckThread::parseClangErrors(const QString &tool, const QString &file0, QS
     }
     errorItems.append(errorItem);
 
-    foreach (const ErrorItem &e, errorItems) {
+    for (const ErrorItem &e : errorItems) {
         if (e.errorPath.isEmpty())
             continue;
-        Suppressions::ErrorMessage errorMessage;
+        SuppressionList::ErrorMessage errorMessage;
         errorMessage.setFileName(e.errorPath.back().file.toStdString());
         errorMessage.lineNumber = e.errorPath.back().line;
         errorMessage.errorId = e.errorId.toStdString();
@@ -458,25 +430,23 @@ void CheckThread::parseClangErrors(const QString &tool, const QString &file0, QS
         if (isSuppressed(errorMessage))
             continue;
 
-        std::list<ErrorLogger::ErrorMessage::FileLocation> callstack;
-        foreach (const QErrorPathItem &path, e.errorPath) {
-            callstack.push_back(ErrorLogger::ErrorMessage::FileLocation(path.file.toStdString(), path.info.toStdString(), path.line, path.column));
-        }
+        std::list<ErrorMessage::FileLocation> callstack;
+        std::transform(e.errorPath.cbegin(), e.errorPath.cend(), std::back_inserter(callstack), [](const QErrorPathItem& path) {
+            return ErrorMessage::FileLocation(path.file.toStdString(), path.info.toStdString(), path.line, path.column);
+        });
         const std::string f0 = file0.toStdString();
         const std::string msg = e.message.toStdString();
         const std::string id = e.errorId.toStdString();
-        ErrorLogger::ErrorMessage errmsg(callstack, f0, e.severity, msg, id, false);
+        ErrorMessage errmsg(std::move(callstack), f0, e.severity, msg, id, Certainty::normal);
         mResult.reportErr(errmsg);
     }
 }
 
-bool CheckThread::isSuppressed(const Suppressions::ErrorMessage &errorMessage) const
+bool CheckThread::isSuppressed(const SuppressionList::ErrorMessage &errorMessage) const
 {
-    foreach (const Suppressions::Suppression &suppression, mSuppressions) {
-        if (suppression.isSuppressed(errorMessage))
-            return true;
-    }
-    return false;
+    return std::any_of(mSuppressionsUi.cbegin(), mSuppressionsUi.cend(), [&](const SuppressionList::Suppression& s) -> bool {
+        return s.isSuppressed(errorMessage) == SuppressionList::Suppression::Result::Matched;
+    });
 }
 
 QString CheckThread::clangCmd()
@@ -529,44 +499,3 @@ QString CheckThread::clangTidyCmd()
     return QString();
 }
 
-QString CheckThread::pythonCmd()
-{
-    QString path = QSettings().value(SETTINGS_PYTHON_PATH).toString();
-    if (!path.isEmpty())
-        return path;
-
-    path = "python";
-#ifdef Q_OS_WIN
-    path += ".exe";
-#endif
-
-    QProcess process;
-    process.start(path, QStringList() << "--version");
-    process.waitForFinished();
-    if (process.exitCode() == 0)
-        return path;
-
-    return QString();
-}
-
-QString CheckThread::getAddonFilePath(const QString &dataDir, const QString &addonFile)
-{
-    const QStringList paths = QStringList() << "/" << "/addons/" << "/../addons/";
-
-    if (!dataDir.isEmpty()) {
-        foreach (const QString p, paths) {
-            const QString filePath(dataDir + p + addonFile);
-            if (QFileInfo(filePath).exists())
-                return filePath;
-        }
-    }
-
-    const QString appPath = QApplication::applicationDirPath();
-    foreach (const QString p, paths) {
-        const QString filePath(appPath + p + addonFile);
-        if (QFileInfo(filePath).exists())
-            return filePath;
-    }
-
-    return QString();
-}
diff --git a/gui/checkthread.h b/gui/checkthread.h
index c92ff2d4af1..a630ef7fc13 100644
--- a/gui/checkthread.h
+++ b/gui/checkthread.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,65 +20,72 @@
 #ifndef CHECKTHREAD_H
 #define CHECKTHREAD_H
 
-#include <QThread>
-#include "cppcheck.h"
-#include "threadresult.h"
+#include "filesettings.h"
+#include "settings.h"
 #include "suppressions.h"
 
-class Settings;
+#include <atomic>
+#include <cstdint>
+#include <list>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <QList>
+#include <QObject>
+#include <QString>
+#include <QStringList>
+#include <QThread>
+#include <QTime>
+
+class ThreadResult;
 
 /// @addtogroup GUI
 /// @{
 
 /**
-* @brief Thread to run cppcheck
-*
-*/
+ * @brief Thread to run cppcheck
+ *
+ */
 class CheckThread : public QThread {
     Q_OBJECT
 public:
-    explicit CheckThread(ThreadResult &result);
-    virtual ~CheckThread();
+    struct Details {
+        int threadIndex;
+        QString file;
+        QTime startTime;
+    };
+
+public:
+    CheckThread(ThreadResult &result, int threadIndex);
 
     /**
-    * @brief Set settings for cppcheck
-    *
-    * @param settings settings for cppcheck
-    */
-    void check(const Settings &settings);
+     * @brief Set settings for cppcheck
+     *
+     * @param settings settings for cppcheck
+     * @param supprs suppressions for cppcheck
+     */
+    void setSettings(const Settings &settings, std::shared_ptr<Suppressions> supprs);
 
     /**
-    * @brief Run whole program analysis
-    * @param files    All files
-    */
-    void analyseWholeProgram(const QStringList &files);
+     * @brief Run whole program analysis
+     * @param files    All files
+     * @param ctuInfo  Ctu info for addons
+     */
+    void analyseWholeProgram(const std::list<FileWithDetails> &files, const std::string& ctuInfo);
 
     void setAddonsAndTools(const QStringList &addonsAndTools) {
         mAddonsAndTools = addonsAndTools;
     }
 
-    void setMisraFile(const QString &misraFile) {
-        mMisraFile = misraFile;
-    }
-
-    void setDataDir(const QString &dataDir) {
-        mDataDir = dataDir;
-    }
-
     void setClangIncludePaths(const QStringList &s) {
         mClangIncludePaths = s;
     }
 
-    void setSuppressions(const QList<Suppressions::Suppression> &s) {
-        mSuppressions = s;
+    void setSuppressions(const QList<SuppressionList::Suppression> &s) {
+        mSuppressionsUi = s;
     }
 
-    /**
-    * @brief method that is run in a thread
-    *
-    */
-    void run();
-
     void stop();
 
     /**
@@ -93,37 +100,28 @@ class CheckThread : public QThread {
      */
     static QString clangTidyCmd();
 
-    /**
-     * Determine command to run python
-     * \return Command to run python, empty if it is not found
-     */
-    static QString pythonCmd();
-
-    /**
-     * Look for addon and return path
-     * \return path to addon if found, empty if it is not found
-     */
-    static QString getAddonFilePath(const QString &dataDir, const QString &addonFile);
+    static int executeCommand(std::string exe, std::vector<std::string> args, std::string redirect, std::string &output);
 
 signals:
 
     /**
-    * @brief cpp checking is done
-    *
-    */
+     * @brief cpp checking is done
+     *
+     */
     void done();
 
-    void fileChecked(const QString &file);
+    void startCheck(CheckThread::Details details);
+    void finishCheck(CheckThread::Details details);
 protected:
 
     /**
-    * @brief States for the check thread.
-    * Whole purpose of these states is to allow stopping of the checking. When
-    * stopping we say for the thread (Stopping) that stop when current check
-    * has been completed. Thread must be stopped cleanly, just terminating thread
-    * likely causes unpredictable side-effects.
-    */
-    enum State {
+     * @brief States for the check thread.
+     * Whole purpose of these states is to allow stopping of the checking. When
+     * stopping we say for the thread (Stopping) that stop when current check
+     * has been completed. Thread must be stopped cleanly, just terminating thread
+     * likely causes unpredictable side-effects.
+     */
+    enum State : std::uint8_t {
         Running, /**< The thread is checking. */
         Stopping, /**< The thread will stop after current work. */
         Stopped, /**< The thread has been stopped. */
@@ -131,31 +129,36 @@ class CheckThread : public QThread {
     };
 
     /**
-    * @brief Thread's current execution state.
-    */
-    State mState;
+     * @brief Thread's current execution state. Can be changed from outside
+     */
+    std::atomic<State> mState{Ready};
 
     ThreadResult &mResult;
-    /**
-    * @brief Cppcheck itself
-    */
-    CppCheck mCppcheck;
+    int mThreadIndex{};
+
+    Settings mSettings;
+    std::shared_ptr<Suppressions> mSuppressions;
 
 private:
-    void runAddonsAndTools(const ImportProject::FileSettings *fileSettings, const QString &fileName);
+    /**
+     * @brief method that is run in a thread
+     *
+     */
+    void run() override;
+
+    void runAddonsAndTools(const Settings& settings, const FileSettings *fileSettings, const QString &fileName);
 
-    void parseAddonErrors(QString err, const QString &tool);
     void parseClangErrors(const QString &tool, const QString &file0, QString err);
 
-    bool isSuppressed(const Suppressions::ErrorMessage &errorMessage) const;
+    bool isSuppressed(const SuppressionList::ErrorMessage &errorMessage) const;
 
-    QStringList mFiles;
-    bool mAnalyseWholeProgram;
+    std::list<FileWithDetails> mFiles;
+    bool mAnalyseWholeProgram{};
+    std::string mCtuInfo;
     QStringList mAddonsAndTools;
-    QString mDataDir;
     QStringList mClangIncludePaths;
-    QList<Suppressions::Suppression> mSuppressions;
-    QString mMisraFile;
+    QList<SuppressionList::Suppression> mSuppressionsUi;
 };
+Q_DECLARE_METATYPE(CheckThread::Details);
 /// @}
 #endif // CHECKTHREAD_H
diff --git a/gui/codeeditor.cpp b/gui/codeeditor.cpp
index 9219008b602..d6c8c1c4071 100644
--- a/gui/codeeditor.cpp
+++ b/gui/codeeditor.cpp
@@ -1,7 +1,45 @@
-#include <QtWidgets>
-#include <QShortcut>
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #include "codeeditor.h"
 
+#include "codeeditorstyle.h"
+#include "utils.h"
+
+#include <QChar>
+#include <QColor>
+#include <QFont>
+#include <QFontMetrics>
+#include <QKeySequence>
+#include <QLatin1Char>
+#include <QList>
+#include <QPainter>
+#include <QPaintEvent>
+#include <QRect>
+#include <QRegularExpressionMatchIterator>
+#include <QShortcut>
+#include <QTextBlock>
+#include <QTextCursor>
+#include <QTextEdit>
+#include <QTextFormat>
+
+class QTextDocument;
+
 
 Highlighter::Highlighter(QTextDocument *parent,
                          CodeEditorStyle *widgetStyle) :
@@ -13,47 +51,90 @@ Highlighter::Highlighter(QTextDocument *parent,
     mKeywordFormat.setForeground(mWidgetStyle->keywordColor);
     mKeywordFormat.setFontWeight(mWidgetStyle->keywordWeight);
     QStringList keywordPatterns;
-    keywordPatterns << "bool"
+    // TODO: use Keywords::getX()
+    keywordPatterns << "alignas"
+                    << "alignof"
+                    << "asm"
+                    << "auto"
+                    << "bool"
                     << "break"
                     << "case"
+                    << "catch"
                     << "char"
+                    << "char8_t"
+                    << "char16_t"
+                    << "char32_t"
                     << "class"
+                    << "concept"
                     << "const"
+                    << "consteval"
+                    << "constexpr"
+                    << "constinit"
+                    << "const_cast"
                     << "continue"
+                    << "co_await"
+                    << "co_return"
+                    << "co_yield"
+                    << "decltype"
                     << "default"
+                    << "delete"
                     << "do"
                     << "double"
+                    << "dynamic_cast"
                     << "else"
                     << "enum"
                     << "explicit"
+                    << "export"
+                    << "extern"
+                    << "false"
+                    << "final"
+                    << "float"
                     << "for"
                     << "friend"
+                    << "goto"
                     << "if"
+                    << "import"
                     << "inline"
                     << "int"
                     << "long"
+                    << "module"
+                    << "mutable"
                     << "namespace"
+                    << "new"
+                    << "noexcept"
+                    << "nullptr"
                     << "operator"
+                    << "override"
                     << "private"
                     << "protected"
                     << "public"
+                    << "reinterpret_cast"
+                    << "requires"
                     << "return"
                     << "short"
                     << "signed"
                     << "static"
+                    << "static_assert"
+                    << "static_cast"
                     << "struct"
                     << "switch"
                     << "template"
+                    << "this"
+                    << "thread_local"
                     << "throw"
+                    << "true"
+                    << "try"
                     << "typedef"
+                    << "typeid"
                     << "typename"
                     << "union"
                     << "unsigned"
                     << "virtual"
                     << "void"
                     << "volatile"
+                    << "wchar_t"
                     << "while";
-    foreach (const QString &pattern, keywordPatterns) {
+    for (const QString &pattern : utils::as_const(keywordPatterns)) {
         rule.pattern = QRegularExpression("\\b" + pattern + "\\b");
         rule.format = mKeywordFormat;
         rule.ruleRole = RuleRole::Keyword;
@@ -69,7 +150,9 @@ Highlighter::Highlighter(QTextDocument *parent,
 
     mQuotationFormat.setForeground(mWidgetStyle->quoteColor);
     mQuotationFormat.setFontWeight(mWidgetStyle->quoteWeight);
-    rule.pattern = QRegularExpression("\".*\"");
+    // We use lazy `*?` instead greed `*` quantifier to find the real end of the c-string.
+    // We use negative lookbehind assertion `(?<!\)` to ignore `\"` sequence in the c-string.
+    rule.pattern = QRegularExpression("\".*?(?<!\\\\)\"");
     rule.format = mQuotationFormat;
     rule.ruleRole = RuleRole::Quote;
     mHighlightingRules.append(rule);
@@ -90,14 +173,16 @@ Highlighter::Highlighter(QTextDocument *parent,
     mSymbolFormat.setBackground(mWidgetStyle->symbolBGColor);
     mSymbolFormat.setFontWeight(mWidgetStyle->symbolWeight);
 
-    mCommentStartExpression = QRegularExpression("/\\*");
+    // We use negative lookbehind assertion `(?<!/)`
+    // to ignore case: single line comment and line of asterisk
+    mCommentStartExpression = QRegularExpression("(?<!/)/\\*");
     mCommentEndExpression = QRegularExpression("\\*/");
 }
 
 void Highlighter::setSymbols(const QStringList &symbols)
 {
     mHighlightingRulesWithSymbols = mHighlightingRules;
-    foreach (const QString &sym, symbols) {
+    for (const QString &sym : symbols) {
         HighlightingRule rule;
         rule.pattern = QRegularExpression("\\b" + sym + "\\b");
         rule.format = mSymbolFormat;
@@ -132,7 +217,7 @@ void Highlighter::setStyle(const CodeEditorStyle &newStyle)
 
 void Highlighter::highlightBlock(const QString &text)
 {
-    foreach (const HighlightingRule &rule, mHighlightingRulesWithSymbols) {
+    for (const HighlightingRule &rule : utils::as_const(mHighlightingRulesWithSymbols)) {
         QRegularExpressionMatchIterator matchIterator = rule.pattern.globalMatch(text);
         while (matchIterator.hasNext()) {
             QRegularExpressionMatch match = matchIterator.next();
@@ -148,7 +233,7 @@ void Highlighter::highlightBlock(const QString &text)
 
     while (startIndex >= 0) {
         QRegularExpressionMatch match = mCommentEndExpression.match(text, startIndex);
-        int endIndex = match.capturedStart();
+        const int endIndex = match.capturedStart();
         int commentLength = 0;
         if (endIndex == -1) {
             setCurrentBlockState(1);
@@ -162,7 +247,7 @@ void Highlighter::highlightBlock(const QString &text)
     }
 }
 
-void Highlighter::applyFormat(HighlightingRule &rule)
+void Highlighter::applyFormat(HighlightingRule &rule) const
 {
     switch (rule.ruleRole) {
     case RuleRole::Keyword:
@@ -200,8 +285,8 @@ CodeEditor::CodeEditor(QWidget *parent) :
     setObjectName("CodeEditor");
     setStyleSheet(generateStyleString());
 
-    QShortcut *copyText = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_C),this);
-    QShortcut *allText = new QShortcut(QKeySequence(Qt::CTRL + Qt::Key_A),this);
+    auto *copyText = new QShortcut(QKeySequence(Qt::CTRL | Qt::Key_C),this);
+    auto *allText = new QShortcut(QKeySequence(Qt::CTRL | Qt::Key_A),this);
 
     connect(this, SIGNAL(blockCountChanged(int)), this, SLOT(updateLineNumberAreaWidth(int)));
     connect(this, SIGNAL(updateRequest(QRect,int)), this, SLOT(updateLineNumberArea(QRect,int)));
@@ -256,6 +341,19 @@ void CodeEditor::setError(const QString &code, int errorLine, const QStringList
     highlightErrorLine();
 }
 
+void CodeEditor::setError(int errorLine, const QStringList &symbols)
+{
+    mHighlighter->setSymbols(symbols);
+
+    mErrorPosition = getPos(toPlainText(), errorLine);
+    QTextCursor tc = textCursor();
+    tc.setPosition(mErrorPosition);
+    setTextCursor(tc);
+    centerCursor();
+
+    highlightErrorLine();
+}
+
 int CodeEditor::lineNumberAreaWidth()
 {
     int digits = 1;
@@ -265,7 +363,7 @@ int CodeEditor::lineNumberAreaWidth()
         ++digits;
     }
 
-    int space = 3 + fontMetrics().width(QLatin1Char('9')) * digits;
+    const int space = 3 + (fontMetrics().horizontalAdvance(QLatin1Char('9')) * digits);
     return space;
 }
 
@@ -312,15 +410,15 @@ void CodeEditor::highlightErrorLine()
     setExtraSelections(extraSelections);
 }
 
-void CodeEditor::lineNumberAreaPaintEvent(QPaintEvent *event)
+void CodeEditor::lineNumberAreaPaintEvent(const QPaintEvent *event)
 {
     QPainter painter(mLineNumberArea);
     painter.fillRect(event->rect(), mWidgetStyle->lineNumBGColor);
 
     QTextBlock block = firstVisibleBlock();
     int blockNumber = block.blockNumber();
-    int top = (int) blockBoundingGeometry(block).translated(contentOffset()).top();
-    int bottom = top + (int) blockBoundingRect(block).height();
+    int top = static_cast<int>(blockBoundingGeometry(block).translated(contentOffset()).top());
+    int bottom = top + static_cast<int>(blockBoundingRect(block).height());
 
     while (block.isValid() && top <= event->rect().bottom()) {
         if (block.isVisible() && bottom >= event->rect().top()) {
@@ -332,7 +430,7 @@ void CodeEditor::lineNumberAreaPaintEvent(QPaintEvent *event)
 
         block = block.next();
         top = bottom;
-        bottom = top + (int) blockBoundingRect(block).height();
+        bottom = top + static_cast<int>(blockBoundingRect(block).height());
         ++blockNumber;
     }
 }
diff --git a/gui/codeeditor.h b/gui/codeeditor.h
index 3f4f2b92cfd..4dfbaa66047 100644
--- a/gui/codeeditor.h
+++ b/gui/codeeditor.h
@@ -1,19 +1,41 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #ifndef CODEEDITOR_H
 #define CODEEDITOR_H
 
-#include <QSyntaxHighlighter>
-#include <QPlainTextEdit>
+#include <cstdint>
+
+#include <QList>
 #include <QObject>
+#include <QPlainTextEdit>
 #include <QRegularExpression>
-#include "codeeditorstyle.h"
+#include <QSize>
+#include <QString>
+#include <QStringList>
+#include <QSyntaxHighlighter>
+#include <QTextCharFormat>
+#include <QWidget>
 
+class CodeEditorStyle;
 class QPaintEvent;
-class QResizeEvent;
-class QSize;
-class QWidget;
-
-class LineNumberArea;
-
+class QRect;
+class QTextDocument;
 
 class Highlighter : public QSyntaxHighlighter {
     Q_OBJECT
@@ -30,7 +52,7 @@ class Highlighter : public QSyntaxHighlighter {
     void highlightBlock(const QString &text) override;
 
 private:
-    enum RuleRole {
+    enum RuleRole : std::uint8_t {
         Keyword = 1,
         Class   = 2,
         Comment = 3,
@@ -43,10 +65,10 @@ class Highlighter : public QSyntaxHighlighter {
         RuleRole ruleRole;
     };
 
-    void applyFormat(HighlightingRule &rule);
+    void applyFormat(HighlightingRule &rule) const;
 
-    QVector<HighlightingRule> mHighlightingRules;
-    QVector<HighlightingRule> mHighlightingRulesWithSymbols;
+    QList<HighlightingRule> mHighlightingRules;
+    QList<HighlightingRule> mHighlightingRulesWithSymbols;
 
     QRegularExpression mCommentStartExpression;
     QRegularExpression mCommentEndExpression;
@@ -68,9 +90,9 @@ class CodeEditor : public QPlainTextEdit {
     explicit CodeEditor(QWidget *parent);
     CodeEditor(const CodeEditor &) = delete;
     CodeEditor &operator=(const CodeEditor &) = delete;
-    ~CodeEditor();
+    ~CodeEditor() override;
 
-    void lineNumberAreaPaintEvent(QPaintEvent *event);
+    void lineNumberAreaPaintEvent(const QPaintEvent *event);
     int lineNumberAreaWidth();
     void setStyle(const CodeEditorStyle& newStyle);
 
@@ -82,13 +104,34 @@ class CodeEditor : public QPlainTextEdit {
      */
     void setError(const QString &code, int errorLine, const QStringList &symbols);
 
+    /**
+     * Goto another error in existing source file
+     * \param errorLine    line number
+     * \param symbols      the related symbols, these are marked
+     */
+    void setError(int errorLine, const QStringList &symbols);
+
+    void setFileName(const QString &fileName) {
+        mFileName = fileName;
+    }
+
+    const QString& getFileName() const {
+        return mFileName;
+    }
+
+    // NOLINTNEXTLINE(bugprone-derived-method-shadowing-base-method) - TODO: fix this
+    void clear() {
+        mFileName.clear();
+        setPlainText(QString());
+    }
+
 protected:
     void resizeEvent(QResizeEvent *event) override;
 
 private slots:
     void updateLineNumberAreaWidth(int newBlockCount);
     void highlightErrorLine();
-    void updateLineNumberArea(const QRect &, int);
+    void updateLineNumberArea(const QRect & /*rect*/, int /*dy*/);
 
 private:
     QString generateStyleString();
@@ -98,6 +141,7 @@ private slots:
     Highlighter *mHighlighter;
     CodeEditorStyle *mWidgetStyle;
     int mErrorPosition;
+    QString mFileName;
 };
 
 
diff --git a/gui/codeeditorstyle.cpp b/gui/codeeditorstyle.cpp
index 9d78b6e7035..6d7a15fb2f8 100644
--- a/gui/codeeditorstyle.cpp
+++ b/gui/codeeditorstyle.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,35 +17,37 @@
  */
 
 #include "codeeditorstyle.h"
+
+#include <QList>
 #include <QSettings>
+#include <QVariant>
 
 CodeEditorStyle::CodeEditorStyle(
-    const QColor& CtrlFGColor, const QColor& CtrlBGColor,
-    const QColor& HiLiBGColor,
-    const QColor& LnNumFGColor, const QColor& LnNumBGColor,
-    const QColor& KeyWdFGColor, const QFont::Weight& KeyWdWeight,
-    const QColor& ClsFGColor, const QFont::Weight& ClsWeight,
-    const QColor& QteFGColor, const QFont::Weight& QteWeight,
-    const QColor& CmtFGColor, const QFont::Weight& CmtWeight,
-    const QColor& SymbFGColor, const QColor& SymbBGColor,
-    const QFont::Weight& SymbWeight) :
-    mSystemTheme(false),
-    widgetFGColor(CtrlFGColor),
-    widgetBGColor(CtrlBGColor),
-    highlightBGColor(HiLiBGColor),
-    lineNumFGColor(LnNumFGColor),
-    lineNumBGColor(LnNumBGColor),
-    keywordColor(KeyWdFGColor),
-    keywordWeight(KeyWdWeight),
-    classColor(ClsFGColor),
-    classWeight(ClsWeight),
-    quoteColor(QteFGColor),
-    quoteWeight(QteWeight),
-    commentColor(CmtFGColor),
-    commentWeight(CmtWeight),
-    symbolFGColor(SymbFGColor),
-    symbolBGColor(SymbBGColor),
-    symbolWeight(SymbWeight)
+    QColor ctrlFGColor, QColor ctrlBGColor,
+    QColor hiLiBGColor,
+    QColor lnNumFGColor, QColor lnNumBGColor,
+    QColor keyWdFGColor, QFont::Weight keyWdWeight,
+    QColor clsFGColor, QFont::Weight clsWeight,
+    QColor qteFGColor, QFont::Weight qteWeight,
+    QColor cmtFGColor, QFont::Weight cmtWeight,
+    QColor symbFGColor, QColor symbBGColor,
+    QFont::Weight symbWeight) :
+    widgetFGColor(ctrlFGColor),
+    widgetBGColor(ctrlBGColor),
+    highlightBGColor(hiLiBGColor),
+    lineNumFGColor(lnNumFGColor),
+    lineNumBGColor(lnNumBGColor),
+    keywordColor(keyWdFGColor),
+    keywordWeight(keyWdWeight),
+    classColor(clsFGColor),
+    classWeight(clsWeight),
+    quoteColor(qteFGColor),
+    quoteWeight(qteWeight),
+    commentColor(cmtFGColor),
+    commentWeight(cmtWeight),
+    symbolFGColor(symbFGColor),
+    symbolBGColor(symbBGColor),
+    symbolWeight(symbWeight)
 {}
 
 bool CodeEditorStyle::operator==(const CodeEditorStyle& rhs) const
@@ -94,9 +96,9 @@ CodeEditorStyle CodeEditorStyle::loadSettings(QSettings *settings)
     // style section exists - load values
     settings->beginGroup(SETTINGS_STYLE_GROUP);
     QString type = settings->value(
-                       SETTINGS_STYLE_TYPE,
-                       QVariant(SETTINGS_STYLE_TYPE_LIGHT)
-                   ).toString();
+        SETTINGS_STYLE_TYPE,
+        QVariant(SETTINGS_STYLE_TYPE_LIGHT)
+        ).toString();
     if (type == SETTINGS_STYLE_TYPE_LIGHT) {
         settings->endGroup();
         return theStyle;
@@ -108,53 +110,53 @@ CodeEditorStyle CodeEditorStyle::loadSettings(QSettings *settings)
     }
     if (type == SETTINGS_STYLE_TYPE_CUSTOM) {
         theStyle.widgetFGColor = settings->value(
-                                     SETTINGS_STYLE_WIDGETFG,
-                                     QVariant(defaultStyleLight.widgetFGColor)).value<QColor>();
+            SETTINGS_STYLE_WIDGETFG,
+            QVariant(defaultStyleLight.widgetFGColor)).value<QColor>();
         theStyle.widgetBGColor = settings->value(
-                                     SETTINGS_STYLE_WIDGETBG,
-                                     QVariant(defaultStyleLight.widgetBGColor)).value<QColor>();
+            SETTINGS_STYLE_WIDGETBG,
+            QVariant(defaultStyleLight.widgetBGColor)).value<QColor>();
         theStyle.highlightBGColor = settings->value(
-                                        SETTINGS_STYLE_HILIFG,
-                                        QVariant(defaultStyleLight.highlightBGColor)).value<QColor>();
+            SETTINGS_STYLE_HILIFG,
+            QVariant(defaultStyleLight.highlightBGColor)).value<QColor>();
         theStyle.lineNumFGColor = settings->value(
-                                      SETTINGS_STYLE_LINENUMFG,
-                                      QVariant(defaultStyleLight.lineNumFGColor)).value<QColor>();
+            SETTINGS_STYLE_LINENUMFG,
+            QVariant(defaultStyleLight.lineNumFGColor)).value<QColor>();
         theStyle.lineNumBGColor = settings->value(
-                                      SETTINGS_STYLE_LINENUMBG,
-                                      QVariant(defaultStyleLight.lineNumBGColor)).value<QColor>();
+            SETTINGS_STYLE_LINENUMBG,
+            QVariant(defaultStyleLight.lineNumBGColor)).value<QColor>();
         theStyle.keywordColor = settings->value(
-                                    SETTINGS_STYLE_KEYWORDFG,
-                                    QVariant(defaultStyleLight.keywordColor)).value<QColor>();
+            SETTINGS_STYLE_KEYWORDFG,
+            QVariant(defaultStyleLight.keywordColor)).value<QColor>();
         QVariant defKeyWWt(static_cast<int>(defaultStyleLight.keywordWeight));
         theStyle.keywordWeight = static_cast<QFont::Weight>(
-                                     settings->value(SETTINGS_STYLE_KEYWORDWT, defKeyWWt).toInt());
+            settings->value(SETTINGS_STYLE_KEYWORDWT, defKeyWWt).toInt());
         theStyle.classColor = settings->value(
-                                  SETTINGS_STYLE_CLASSFG,
-                                  QVariant(defaultStyleLight.classColor)).value<QColor>();
+            SETTINGS_STYLE_CLASSFG,
+            QVariant(defaultStyleLight.classColor)).value<QColor>();
         QVariant defClsWt(static_cast<int>(defaultStyleLight.classWeight));
         theStyle.classWeight = static_cast<QFont::Weight>(
-                                   settings->value(SETTINGS_STYLE_CLASSWT, defClsWt).toInt());
+            settings->value(SETTINGS_STYLE_CLASSWT, defClsWt).toInt());
         theStyle.quoteColor = settings->value(
-                                  SETTINGS_STYLE_QUOTEFG,
-                                  QVariant(defaultStyleLight.quoteColor)).value<QColor>();
+            SETTINGS_STYLE_QUOTEFG,
+            QVariant(defaultStyleLight.quoteColor)).value<QColor>();
         QVariant defQteWt(static_cast<int>(defaultStyleLight.quoteWeight));
         theStyle.quoteWeight = static_cast<QFont::Weight>(
-                                   settings->value(SETTINGS_STYLE_QUOTEWT, defQteWt).toInt());
+            settings->value(SETTINGS_STYLE_QUOTEWT, defQteWt).toInt());
         theStyle.commentColor = settings->value(
-                                    SETTINGS_STYLE_COMMENTFG,
-                                    QVariant(defaultStyleLight.commentColor)).value<QColor>();
+            SETTINGS_STYLE_COMMENTFG,
+            QVariant(defaultStyleLight.commentColor)).value<QColor>();
         QVariant defCmtWt(static_cast<int>(defaultStyleLight.commentWeight));
         theStyle.commentWeight = static_cast<QFont::Weight>(
-                                     settings->value(SETTINGS_STYLE_COMMENTWT, defCmtWt).toInt());
+            settings->value(SETTINGS_STYLE_COMMENTWT, defCmtWt).toInt());
         theStyle.symbolFGColor = settings->value(
-                                     SETTINGS_STYLE_SYMBOLFG,
-                                     QVariant(defaultStyleLight.symbolFGColor)).value<QColor>();
+            SETTINGS_STYLE_SYMBOLFG,
+            QVariant(defaultStyleLight.symbolFGColor)).value<QColor>();
         theStyle.symbolBGColor = settings->value(
-                                     SETTINGS_STYLE_SYMBOLBG,
-                                     QVariant(defaultStyleLight.symbolBGColor)).value<QColor>();
+            SETTINGS_STYLE_SYMBOLBG,
+            QVariant(defaultStyleLight.symbolBGColor)).value<QColor>();
         QVariant defSymWt(static_cast<int>(defaultStyleLight.symbolWeight));
         theStyle.symbolWeight = static_cast<QFont::Weight>(
-                                    settings->value(SETTINGS_STYLE_SYMBOLWT, defSymWt).toInt());
+            settings->value(SETTINGS_STYLE_SYMBOLWT, defSymWt).toInt());
     }
     settings->endGroup();
     return theStyle;
@@ -173,8 +175,8 @@ void CodeEditorStyle::saveSettings(QSettings *settings,
     }
 
     settings->beginGroup(SETTINGS_STYLE_GROUP);
-    bool isDefaultLight = (defaultStyleLight == theStyle);
-    bool isDefaultDark = (defaultStyleDark == theStyle);
+    const bool isDefaultLight = (defaultStyleLight == theStyle);
+    const bool isDefaultDark = (defaultStyleDark == theStyle);
     if (isDefaultLight && !isDefaultDark) {
         settings->setValue(SETTINGS_STYLE_TYPE,
                            SETTINGS_STYLE_TYPE_LIGHT);
diff --git a/gui/codeeditorstyle.h b/gui/codeeditorstyle.h
index 53b2ef5e41b..8ce43bccd35 100644
--- a/gui/codeeditorstyle.h
+++ b/gui/codeeditorstyle.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,9 +19,10 @@
 #ifndef CODEEDITORSTYLE_H
 #define CODEEDITORSTYLE_H
 
-#include <QString>
 #include <QColor>
 #include <QFont>
+#include <QString>
+#include <Qt>
 
 const QString SETTINGS_STYLE_GROUP("EditorStyle");
 const QString SETTINGS_STYLE_TYPE("StyleType");
@@ -50,16 +51,15 @@ class QSettings;
 class CodeEditorStyle {
 public:
     explicit CodeEditorStyle(
-        const QColor& CtrlFGColor, const QColor& CtrlBGColor,
-        const QColor& HiLiBGColor,
-        const QColor& LnNumFGColor, const QColor& LnNumBGColor,
-        const QColor& KeyWdFGColor, const QFont::Weight& KeyWdWeight,
-        const QColor& ClsFGColor, const QFont::Weight& ClsWeight,
-        const QColor& QteFGColor, const QFont::Weight& QteWeight,
-        const QColor& CmtFGColor, const QFont::Weight& CmtWeight,
-        const QColor& SymbFGColor, const QColor& SymbBGColor,
-        const QFont::Weight& SymbWeight);
-    ~CodeEditorStyle() {}
+        QColor ctrlFGColor, QColor ctrlBGColor,
+        QColor hiLiBGColor,
+        QColor lnNumFGColor, QColor lnNumBGColor,
+        QColor keyWdFGColor, QFont::Weight keyWdWeight,
+        QColor clsFGColor, QFont::Weight clsWeight,
+        QColor qteFGColor, QFont::Weight qteWeight,
+        QColor cmtFGColor, QFont::Weight cmtWeight,
+        QColor symbFGColor, QColor symbBGColor,
+        QFont::Weight symbWeight);
 
     bool operator==(const CodeEditorStyle& rhs) const;
     bool operator!=(const CodeEditorStyle& rhs) const;
@@ -73,47 +73,47 @@ class CodeEditorStyle {
     static void saveSettings(QSettings *settings, const CodeEditorStyle& theStyle);
 
 public:
-    bool            mSystemTheme;
-    QColor          widgetFGColor;
-    QColor          widgetBGColor;
-    QColor          highlightBGColor;
-    QColor          lineNumFGColor;
-    QColor          lineNumBGColor;
-    QColor          keywordColor;
-    QFont::Weight   keywordWeight;
-    QColor          classColor;
-    QFont::Weight   classWeight;
-    QColor          quoteColor;
-    QFont::Weight   quoteWeight;
-    QColor          commentColor;
-    QFont::Weight   commentWeight;
-    QColor          symbolFGColor;
-    QColor          symbolBGColor;
-    QFont::Weight   symbolWeight;
+    bool mSystemTheme{};
+    QColor widgetFGColor;
+    QColor widgetBGColor;
+    QColor highlightBGColor;
+    QColor lineNumFGColor;
+    QColor lineNumBGColor;
+    QColor keywordColor;
+    QFont::Weight keywordWeight;
+    QColor classColor;
+    QFont::Weight classWeight;
+    QColor quoteColor;
+    QFont::Weight quoteWeight;
+    QColor commentColor;
+    QFont::Weight commentWeight;
+    QColor symbolFGColor;
+    QColor symbolBGColor;
+    QFont::Weight symbolWeight;
 };
 
 static const CodeEditorStyle defaultStyleLight(
-    /* editor FG/BG */          Qt::black, QColor(240, 240, 240),
-    /* highlight BG */          QColor(255, 220, 220),
-    /* line number FG/BG */     Qt::black, QColor(240, 240, 240),
-    /* keyword FG/Weight */     Qt::darkBlue, QFont::Bold,
-    /* class FG/Weight */       Qt::darkMagenta, QFont::Bold,
-    /* quote FG/Weight */       Qt::darkGreen, QFont::Normal,
-    /* comment FG/Weight */     Qt::gray, QFont::Normal,
-    /* Symbol FG/BG/Weight */   Qt::red, QColor(220, 220, 255), QFont::Normal
-);
+    /* editor FG/BG */ Qt::black, QColor(240, 240, 240),
+    /* highlight BG */ QColor(255, 220, 220),
+    /* line number FG/BG */ Qt::black, QColor(240, 240, 240),
+    /* keyword FG/Weight */ Qt::darkBlue, QFont::Bold,
+    /* class FG/Weight */ Qt::darkMagenta, QFont::Bold,
+    /* quote FG/Weight */ Qt::darkGreen, QFont::Normal,
+    /* comment FG/Weight */ Qt::gray, QFont::Normal,
+    /* Symbol FG/BG/Weight */ Qt::red, QColor(220, 220, 255), QFont::Normal
+    );
 
 // Styling derived from Eclipse Color Theme - 'RecognEyes'
 // http://www.eclipsecolorthemes.org/?view=theme&id=30
 static const CodeEditorStyle defaultStyleDark(
-    /* editor FG/BG */          QColor(218, 218, 218), QColor(16, 16, 32),
-    /* highlight BG */          QColor(64, 64, 64),
-    /* line number FG/BG */     QColor(43, 145, 175), QColor(16, 16, 32),
-    /* keyword FG/Weight */     QColor(0, 204, 204), QFont::Bold,
-    /* class FG/Weight */       QColor(218, 0, 218), QFont::Bold,
-    /* quote FG/Weight */       QColor(0, 204, 0), QFont::Normal,
-    /* comment FG/Weight */     QColor(180, 180, 180), QFont::Normal,
-    /* Symbol FG/BG/Weight */   QColor(218, 32, 32), QColor(32, 32, 108), QFont::Normal
-);
+    /* editor FG/BG */ QColor(218, 218, 218), QColor(16, 16, 32),
+    /* highlight BG */ QColor(64, 64, 64),
+    /* line number FG/BG */ QColor(43, 145, 175), QColor(16, 16, 32),
+    /* keyword FG/Weight */ QColor(0, 204, 204), QFont::Bold,
+    /* class FG/Weight */ QColor(218, 0, 218), QFont::Bold,
+    /* quote FG/Weight */ QColor(0, 204, 0), QFont::Normal,
+    /* comment FG/Weight */ QColor(180, 180, 180), QFont::Normal,
+    /* Symbol FG/BG/Weight */ QColor(218, 32, 32), QColor(32, 32, 108), QFont::Normal
+    );
 
 #endif /* CODEEDITORSTYLE_H */
diff --git a/gui/codeeditstylecontrols.cpp b/gui/codeeditstylecontrols.cpp
index 303281aba3b..1623d75a68a 100644
--- a/gui/codeeditstylecontrols.cpp
+++ b/gui/codeeditstylecontrols.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,7 +17,14 @@
  */
 
 #include "codeeditstylecontrols.h"
+
 #include <QColorDialog>
+#include <QDialog>
+#include <QObject>
+#include <QString>
+#include <QVariant>
+
+class QWidget;
 
 SelectColorButton::SelectColorButton(QWidget* parent) :
     QPushButton(parent),
@@ -30,9 +37,9 @@ SelectColorButton::SelectColorButton(QWidget* parent) :
 void SelectColorButton::updateColor()
 {
     QString btnColorStyle = QString(
-                                "background-color:rgb(%1,%2,%3);"
-                                "border-style:outset;"
-                                "border-width: 1px;")
+        "background-color:rgb(%1,%2,%3);"
+        "border-style:outset;"
+        "border-width: 1px;")
                             .arg(mColor.red())
                             .arg(mColor.green())
                             .arg(mColor.blue());
@@ -44,7 +51,7 @@ void SelectColorButton::changeColor()
 {
     QColorDialog pDlg(mColor);
     pDlg.setModal(true);
-    int nResult = pDlg.exec();
+    const int nResult = pDlg.exec();
     if (nResult == QDialog::Accepted) {
         setColor(pDlg.selectedColor());
         emit colorChanged(mColor);
@@ -57,14 +64,14 @@ void SelectColorButton::setColor(const QColor& color)
     updateColor();
 }
 
-const QColor& SelectColorButton::getColor()
+// cppcheck-suppress unusedFunction
+const QColor& SelectColorButton::getColor() const
 {
     return mColor;
 }
 
 SelectFontWeightCombo::SelectFontWeightCombo(QWidget* parent) :
-    QComboBox(parent),
-    mWeight(QFont::Normal)
+    QComboBox(parent)
 {
     addItem(QObject::tr("Thin"),
             QVariant(static_cast<int>(QFont::Thin)));
@@ -91,7 +98,7 @@ SelectFontWeightCombo::SelectFontWeightCombo(QWidget* parent) :
 
 void SelectFontWeightCombo::updateWeight()
 {
-    int nResult = findData(QVariant(static_cast<int>(mWeight)));
+    const int nResult = findData(QVariant(static_cast<int>(mWeight)));
 
     if (nResult != -1) {
         setCurrentIndex(nResult);
@@ -108,13 +115,14 @@ void SelectFontWeightCombo::changeWeight(int index)
     }
 }
 
-void SelectFontWeightCombo::setWeight(const QFont::Weight& weight)
+void SelectFontWeightCombo::setWeight(QFont::Weight weight)
 {
     mWeight = weight;
     updateWeight();
 }
 
-const QFont::Weight& SelectFontWeightCombo::getWeight()
+// cppcheck-suppress unusedFunction
+const QFont::Weight& SelectFontWeightCombo::getWeight() const
 {
     return mWeight;
 }
diff --git a/gui/codeeditstylecontrols.h b/gui/codeeditstylecontrols.h
index ef2ded1c83e..e40746a77a3 100644
--- a/gui/codeeditstylecontrols.h
+++ b/gui/codeeditstylecontrols.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,21 +22,24 @@
 #ifndef CODEEDITORSTYLECONTROLS_H
 #define CODEEDITORSTYLECONTROLS_H
 
-#include <QPushButton>
-#include <QComboBox>
 #include <QColor>
+#include <QComboBox>
 #include <QFont>
+#include <QObject>
+#include <QPushButton>
+
+class QWidget;
 
 class SelectColorButton : public QPushButton {
     Q_OBJECT
 public:
     explicit SelectColorButton(QWidget* parent);
-    virtual ~SelectColorButton() {}
 
     void setColor(const QColor& color);
-    const QColor& getColor();
+    const QColor& getColor() const;
 
 signals:
+    // NOLINTNEXTLINE(readability-inconsistent-declaration-parameter-name) - caused by generated MOC code
     void colorChanged(const QColor& newColor);
 
 public slots:
@@ -52,20 +55,20 @@ class SelectFontWeightCombo : public QComboBox {
     Q_OBJECT
 public:
     explicit SelectFontWeightCombo(QWidget* parent);
-    virtual ~SelectFontWeightCombo() {}
 
-    void setWeight(const QFont::Weight& weight);
-    const QFont::Weight& getWeight();
+    void setWeight(QFont::Weight weight);
+    const QFont::Weight& getWeight() const;
 
 signals:
-    void weightChanged(const QFont::Weight& newWeight);
+    // NOLINTNEXTLINE(readability-inconsistent-declaration-parameter-name) - caused by generated MOC code
+    void weightChanged(QFont::Weight newWeight);
 
 public slots:
     void updateWeight();
     void changeWeight(int index);
 
 private:
-    QFont::Weight mWeight;
+    QFont::Weight mWeight = QFont::Normal;
 };
 
 #endif  //CODEEDITORSTYLECONTROLS_H
diff --git a/gui/codeeditstyledialog.cpp b/gui/codeeditstyledialog.cpp
index 0e1701f52f2..44304ddddc1 100644
--- a/gui/codeeditstyledialog.cpp
+++ b/gui/codeeditstyledialog.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,10 +17,21 @@
  */
 
 #include "codeeditstyledialog.h"
+
+#include "codeeditor.h"
+#include "codeeditstylecontrols.h"
+
+#include <QDialogButtonBox>
+#include <QFlags>
+#include <QFontMetrics>
+#include <QFormLayout>
 #include <QHBoxLayout>
+#include <QPushButton>
+#include <QString>
 #include <QVBoxLayout>
-#include <QFormLayout>
-#include <QDialogButtonBox>
+#include <QtGlobal>
+
+class QWidget;
 
 const QString StyleEditDialog::mSampleDocument(
     "/*****\n"
@@ -49,10 +60,10 @@ const QString StyleEditDialog::mSampleDocument(
     "}\n");
 
 const QStringList StyleEditDialog::mErrSymbolsList = (
-            QStringList(QStringList()
-                        << "nLife"
-                        << "dValue"
-                        << "nValue"));
+    QStringList(QStringList()
+                << "nLife"
+                << "dValue"
+                << "nValue"));
 const int StyleEditDialog::mErrLineNum = 16;
 
 StyleEditDialog::StyleEditDialog(const CodeEditorStyle& newStyle,
@@ -61,10 +72,10 @@ StyleEditDialog::StyleEditDialog(const CodeEditorStyle& newStyle,
     mStyleIncoming(newStyle),
     mStyleOutgoing(newStyle)
 {
-    QVBoxLayout *vboxMain = new QVBoxLayout(this);
-    QHBoxLayout *hboxEdit = new QHBoxLayout();
+    auto *vboxMain = new QVBoxLayout(this);
+    auto *hboxEdit = new QHBoxLayout();
     // Color/Weight controls
-    QFormLayout *flEditControls = new QFormLayout();
+    auto *flEditControls = new QFormLayout();
     mBtnWidgetColorFG = new SelectColorButton(this);
     flEditControls->addRow(QObject::tr("Editor Foreground Color"),
                            mBtnWidgetColorFG);
@@ -118,7 +129,7 @@ StyleEditDialog::StyleEditDialog(const CodeEditorStyle& newStyle,
     mSampleEditor = new CodeEditor(this);
     QFont sampleFont("Monospace");
     QFontMetrics fm(sampleFont);
-    mSampleEditor->setMinimumWidth(fm.width(QString(40, 'W')));
+    mSampleEditor->setMinimumWidth(fm.horizontalAdvance(QString(40, 'W')));
     // designate highlight, errors, and symbols
     mSampleEditor->setError(mSampleDocument, mErrLineNum, mErrSymbolsList);
     // End Controls
@@ -126,7 +137,7 @@ StyleEditDialog::StyleEditDialog(const CodeEditorStyle& newStyle,
     vboxMain->addLayout(hboxEdit);
 
     // Default Controls
-    QHBoxLayout *hboxDefaultControls = new QHBoxLayout();
+    auto *hboxDefaultControls = new QHBoxLayout();
     mBtnDefaultLight = new QPushButton(QObject::tr("Set to Default Light"),
                                        this);
     mBtnDefaultDark  = new QPushButton(QObject::tr("Set to Default Dark"),
@@ -138,7 +149,7 @@ StyleEditDialog::StyleEditDialog(const CodeEditorStyle& newStyle,
     vboxMain->addLayout(hboxDefaultControls);
     vboxMain->addStretch(2);
     // dialog controls
-    QDialogButtonBox *dBtnBox = new QDialogButtonBox(
+    auto *dBtnBox = new QDialogButtonBox(
         QDialogButtonBox::Cancel |
         QDialogButtonBox::Ok |
         QDialogButtonBox::Reset);
@@ -157,38 +168,38 @@ StyleEditDialog::StyleEditDialog(const CodeEditorStyle& newStyle,
             this, SLOT(setStyleDefaultLight()));
     connect(mBtnDefaultDark, SIGNAL(clicked()),
             this, SLOT(setStyleDefaultDark()));
-    connect(mBtnWidgetColorFG, SIGNAL(colorChanged(const QColor&)),
-            this, SLOT(colorChangedWidgetFG(const QColor&)));
-    connect(mBtnWidgetColorBG, SIGNAL(colorChanged(const QColor&)),
-            this, SLOT(colorChangedWidgetBG(const QColor&)));
-    connect(mBtnHighlightBG, SIGNAL(colorChanged(const QColor&)),
-            this, SLOT(colorChangedHighlightBG(const QColor&)));
-    connect(mBtnLineNumFG, SIGNAL(colorChanged(const QColor&)),
-            this, SLOT(colorChangedLineNumFG(const QColor&)));
-    connect(mBtnLineNumBG, SIGNAL(colorChanged(const QColor&)),
-            this, SLOT(colorChangedLineNumBG(const QColor&)));
-    connect(mBtnKeywordFG, SIGNAL(colorChanged(const QColor&)),
-            this, SLOT(colorChangedKeywordFG(const QColor&)));
-    connect(mCBKeywordWeight, SIGNAL(weightChanged(const QFont::Weight&)),
-            this, SLOT(weightChangedKeyword(const QFont::Weight&)));
-    connect(mBtnClassFG, SIGNAL(colorChanged(const QColor&)),
-            this, SLOT(colorChangedClassFG(const QColor&)));
-    connect(mCBClassWeight, SIGNAL(weightChanged(const QFont::Weight&)),
-            this, SLOT(weightChangedClass(const QFont::Weight&)));
-    connect(mBtnQuoteFG, SIGNAL(colorChanged(const QColor&)),
-            this, SLOT(colorChangedQuoteFG(const QColor&)));
-    connect(mCBQuoteWeight, SIGNAL(weightChanged(const QFont::Weight&)),
-            this, SLOT(weightChangedQuote(const QFont::Weight&)));
-    connect(mBtnCommentFG, SIGNAL(colorChanged(const QColor&)),
-            this, SLOT(colorChangedCommentFG(const QColor&)));
-    connect(mCBCommentWeight, SIGNAL(weightChanged(const QFont::Weight&)),
-            this, SLOT(weightChangedComment(const QFont::Weight&)));
-    connect(mBtnSymbolFG, SIGNAL(colorChanged(const QColor&)),
-            this, SLOT(colorChangedSymbolFG(const QColor&)));
-    connect(mBtnSymbolBG, SIGNAL(colorChanged(const QColor&)),
-            this, SLOT(colorChangedSymbolBG(const QColor&)));
-    connect(mCBSymbolWeight, SIGNAL(weightChanged(const QFont::Weight&)),
-            this, SLOT(weightChangedSymbol(const QFont::Weight&)));
+    connect(mBtnWidgetColorFG, SIGNAL(colorChanged(QColor)),
+            this, SLOT(colorChangedWidgetFG(QColor)));
+    connect(mBtnWidgetColorBG, SIGNAL(colorChanged(QColor)),
+            this, SLOT(colorChangedWidgetBG(QColor)));
+    connect(mBtnHighlightBG, SIGNAL(colorChanged(QColor)),
+            this, SLOT(colorChangedHighlightBG(QColor)));
+    connect(mBtnLineNumFG, SIGNAL(colorChanged(QColor)),
+            this, SLOT(colorChangedLineNumFG(QColor)));
+    connect(mBtnLineNumBG, SIGNAL(colorChanged(QColor)),
+            this, SLOT(colorChangedLineNumBG(QColor)));
+    connect(mBtnKeywordFG, SIGNAL(colorChanged(QColor)),
+            this, SLOT(colorChangedKeywordFG(QColor)));
+    connect(mCBKeywordWeight, SIGNAL(weightChanged(QFont::Weight)),
+            this, SLOT(weightChangedKeyword(QFont::Weight)));
+    connect(mBtnClassFG, SIGNAL(colorChanged(QColor)),
+            this, SLOT(colorChangedClassFG(QColor)));
+    connect(mCBClassWeight, SIGNAL(weightChanged(QFont::Weight)),
+            this, SLOT(weightChangedClass(QFont::Weight)));
+    connect(mBtnQuoteFG, SIGNAL(colorChanged(QColor)),
+            this, SLOT(colorChangedQuoteFG(QColor)));
+    connect(mCBQuoteWeight, SIGNAL(weightChanged(QFont::Weight)),
+            this, SLOT(weightChangedQuote(QFont::Weight)));
+    connect(mBtnCommentFG, SIGNAL(colorChanged(QColor)),
+            this, SLOT(colorChangedCommentFG(QColor)));
+    connect(mCBCommentWeight, SIGNAL(weightChanged(QFont::Weight)),
+            this, SLOT(weightChangedComment(QFont::Weight)));
+    connect(mBtnSymbolFG, SIGNAL(colorChanged(QColor)),
+            this, SLOT(colorChangedSymbolFG(QColor)));
+    connect(mBtnSymbolBG, SIGNAL(colorChanged(QColor)),
+            this, SLOT(colorChangedSymbolBG(QColor)));
+    connect(mCBSymbolWeight, SIGNAL(weightChanged(QFont::Weight)),
+            this, SLOT(weightChangedSymbol(QFont::Weight)));
 }
 
 void StyleEditDialog::updateControls()
@@ -219,7 +230,7 @@ void StyleEditDialog::updateStyle()
     mSampleEditor->setStyle(mStyleOutgoing);
 }
 
-CodeEditorStyle StyleEditDialog::getStyle()
+CodeEditorStyle StyleEditDialog::getStyle() const
 {
     return mStyleOutgoing;
 }
@@ -281,7 +292,7 @@ void StyleEditDialog::colorChangedKeywordFG(const QColor& newColor)
     updateStyle();
 }
 
-void StyleEditDialog::weightChangedKeyword(const QFont::Weight& newWeight)
+void StyleEditDialog::weightChangedKeyword(QFont::Weight newWeight)
 {
     mStyleOutgoing.keywordWeight = newWeight;
     updateStyle();
@@ -293,7 +304,7 @@ void StyleEditDialog::colorChangedClassFG(const QColor& newColor)
     updateStyle();
 }
 
-void StyleEditDialog::weightChangedClass(const QFont::Weight& newWeight)
+void StyleEditDialog::weightChangedClass(QFont::Weight newWeight)
 {
     mStyleOutgoing.classWeight = newWeight;
     updateStyle();
@@ -305,7 +316,7 @@ void StyleEditDialog::colorChangedQuoteFG(const QColor& newColor)
     updateStyle();
 }
 
-void StyleEditDialog::weightChangedQuote(const QFont::Weight& newWeight)
+void StyleEditDialog::weightChangedQuote(QFont::Weight newWeight)
 {
     mStyleOutgoing.quoteWeight = newWeight;
     updateStyle();
@@ -317,7 +328,7 @@ void StyleEditDialog::colorChangedCommentFG(const QColor& newColor)
     updateStyle();
 }
 
-void StyleEditDialog::weightChangedComment(const QFont::Weight& newWeight)
+void StyleEditDialog::weightChangedComment(QFont::Weight newWeight)
 {
     mStyleOutgoing.commentWeight = newWeight;
     updateStyle();
@@ -335,7 +346,7 @@ void StyleEditDialog::colorChangedSymbolBG(const QColor& newColor)
     updateStyle();
 }
 
-void StyleEditDialog::weightChangedSymbol(const QFont::Weight& newWeight)
+void StyleEditDialog::weightChangedSymbol(QFont::Weight newWeight)
 {
     mStyleOutgoing.symbolWeight = newWeight;
     updateStyle();
diff --git a/gui/codeeditstyledialog.h b/gui/codeeditstyledialog.h
index dfe424de1d2..763372cbef6 100644
--- a/gui/codeeditstyledialog.h
+++ b/gui/codeeditstyledialog.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,20 +19,28 @@
 #ifndef CODEEDITSTYLEDIALOG_H
 #define CODEEDITSTYLEDIALOG_H
 
-#include <QDialog>
-#include <QPushButton>
-#include "codeeditstylecontrols.h"
-#include "codeeditor.h"
 #include "codeeditorstyle.h"
 
+#include <QColor>
+#include <QDialog>
+#include <QFont>
+#include <QObject>
+#include <QStringList>
+
+class CodeEditor;
+class SelectColorButton;
+class SelectFontWeightCombo;
+class QPushButton;
+class QWidget;
+class QString;
+
 class StyleEditDialog : public QDialog {
     Q_OBJECT
 public:
     explicit StyleEditDialog(const CodeEditorStyle& newStyle,
                              QWidget *parent = nullptr);
-    virtual ~StyleEditDialog() {}
 
-    CodeEditorStyle getStyle();
+    CodeEditorStyle getStyle() const;
 
 private:
     void updateControls();
@@ -48,20 +56,20 @@ public slots:
     void colorChangedLineNumFG(const QColor& newColor);
     void colorChangedLineNumBG(const QColor& newColor);
     void colorChangedKeywordFG(const QColor& newColor);
-    void weightChangedKeyword(const QFont::Weight& newWeight);
+    void weightChangedKeyword(QFont::Weight newWeight);
     void colorChangedClassFG(const QColor& newColor);
-    void weightChangedClass(const QFont::Weight& newWeight);
+    void weightChangedClass(QFont::Weight newWeight);
     void colorChangedQuoteFG(const QColor& newColor);
-    void weightChangedQuote(const QFont::Weight& newWeight);
+    void weightChangedQuote(QFont::Weight newWeight);
     void colorChangedCommentFG(const QColor& newColor);
-    void weightChangedComment(const QFont::Weight& newWeight);
+    void weightChangedComment(QFont::Weight newWeight);
     void colorChangedSymbolFG(const QColor& newColor);
     void colorChangedSymbolBG(const QColor& newColor);
-    void weightChangedSymbol(const QFont::Weight& newWeight);
+    void weightChangedSymbol(QFont::Weight newWeight);
 
 private:
-    CodeEditorStyle         mStyleIncoming;
-    CodeEditorStyle         mStyleOutgoing;
+    CodeEditorStyle mStyleIncoming;
+    CodeEditorStyle mStyleOutgoing;
 
     CodeEditor              *mSampleEditor;
 
@@ -85,9 +93,9 @@ public slots:
     QPushButton             *mBtnDefaultLight;
     QPushButton             *mBtnDefaultDark;
 
-    static const QString     mSampleDocument;
+    static const QString mSampleDocument;
     static const QStringList mErrSymbolsList;
-    static const int         mErrLineNum;
+    static const int mErrLineNum;
 };
 
 #endif  //CODEEDITSTYLEDIALOG_H
diff --git a/gui/common.cpp b/gui/common.cpp
index ccb95909f22..8e6272a754f 100644
--- a/gui/common.cpp
+++ b/gui/common.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,10 +18,16 @@
 
 
 #include "common.h"
+
 #include <QCoreApplication>
-#include <QSettings>
-#include <QFileInfo>
 #include <QDir>
+#include <QFileInfo>
+#include <QList>
+#include <QMap>
+#include <QSettings>
+#include <QStringList>
+#include <QVariant>
+#include <Qt>
 
 
 QString getPath(const QString &type)
@@ -50,7 +56,7 @@ QString toFilterString(const QMap<QString,QString>& filters, bool addAllSupporte
 
     if (addAllSupported) {
         entries << QCoreApplication::translate("toFilterString", "All supported files (%1)")
-                .arg(QStringList(filters.values()).join(" "));
+            .arg(filters.values().join(" "));
     }
 
     if (addAll) {
@@ -60,9 +66,23 @@ QString toFilterString(const QMap<QString,QString>& filters, bool addAllSupporte
     // We're using the description of the filters as the map keys, the file
     // name patterns are our values. The generated filter string list will
     // thus be sorted alphabetically over the descriptions.
-    for (auto k: filters.keys()) {
+    for (const auto& k: filters.keys()) {
         entries << QString("%1 (%2)").arg(k).arg(filters.value(k));
     }
 
     return entries.join(";;");
 }
+
+QString getDataDir()
+{
+    QSettings settings;
+    const QString dataDir = settings.value("DATADIR", QString()).toString();
+    if (!dataDir.isEmpty())
+        return dataDir;
+    const QString appPath = QFileInfo(QCoreApplication::applicationFilePath()).canonicalPath();
+    if (QFileInfo::exists(appPath + "/std.cfg"))
+        return appPath;
+    if (appPath.indexOf("/cppcheck/", 0, Qt::CaseInsensitive) > 0)
+        return appPath.left(appPath.indexOf("/cppcheck/", 0, Qt::CaseInsensitive) + 9);
+    return appPath;
+}
diff --git a/gui/common.h b/gui/common.h
index 9a566fbc765..60c41f928eb 100644
--- a/gui/common.h
+++ b/gui/common.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -29,15 +29,13 @@
 #define CLANG_TIDY       "clang-tidy"
 
 /**
-* QSetting value names
-*/
+ * QSetting value names
+ */
 
 // Window/dialog sizes
 #define SETTINGS_WINDOW_MAXIMIZED       "Window maximized"
 #define SETTINGS_WINDOW_WIDTH           "Window width"
 #define SETTINGS_WINDOW_HEIGHT          "Window height"
-#define SETTINGS_LOG_VIEW_WIDTH         "Log/View width"
-#define SETTINGS_LOG_VIEW_HEIGHT        "Log/View height"
 #define SETTINGS_MAINWND_SPLITTER_STATE "Mainwindow/Vertical splitter state"
 #define SETTINGS_CHECK_DIALOG_WIDTH     "Check dialog width"
 #define SETTINGS_CHECK_DIALOG_HEIGHT    "Check dialog height"
@@ -50,6 +48,9 @@
 #define SETTINGS_TOOLBARS_VIEW_SHOW     "Toolbars/ShowView"
 #define SETTINGS_TOOLBARS_FILTER_SHOW   "Toolbars/ShowFilter"
 
+// Report type
+#define SETTINGS_REPORT_TYPE            "Report type"
+
 // Show * states
 #define SETTINGS_SHOW_STYLE             "Show style"
 #define SETTINGS_SHOW_ERRORS            "Show errors"
@@ -89,6 +90,8 @@
 #define SETTINGS_SHOW_ERROR_ID          "Show error Id"
 #define SETTINGS_SHOW_STATISTICS        "Show statistics"
 #define SETTINGS_OPEN_PROJECT           "Open Project"
+#define SETTINGS_CHECK_VERSION          "Check Version"
+#define SETTINGS_CHECK_FOR_UPDATES      "Check for updates"
 
 // The maximum value for the progress bar
 #define PROGRESS_MAX                    1024.0
@@ -99,7 +102,6 @@
 #define SETTINGS_LAST_PROJECT_PATH      "Last project path"
 #define SETTINGS_LAST_RESULT_PATH       "Last result path"
 #define SETTINGS_LAST_SOURCE_PATH       "Last source path"
-#define SETTINGS_LAST_INCLUDE_PATH      "Last include path"
 #define SETTINGS_LAST_APP_PATH          "Last application path"
 
 #define SETTINGS_LAST_ANALYZE_FILES_FILTER  "Last analyze files filter"
@@ -147,5 +149,10 @@ void setPath(const QString &type, const QString &value);
  */
 QString toFilterString(const QMap<QString,QString>& filters, bool addAllSupported=true, bool addAll=true);
 
+/**
+ * Get configured data dir. If not configured then it will try to determine that from exe path.
+ */
+QString getDataDir();
+
 /// @}
 #endif
diff --git a/gui/compliancereportdialog.cpp b/gui/compliancereportdialog.cpp
new file mode 100644
index 00000000000..c61299e6e3c
--- /dev/null
+++ b/gui/compliancereportdialog.cpp
@@ -0,0 +1,246 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "compliancereportdialog.h"
+
+#include "ui_compliancereportdialog.h"
+
+#include "errortypes.h"
+#include "filelist.h"
+#include "filesettings.h"
+#include "importproject.h"
+#include "projectfile.h"
+#include "utils.h"
+
+#include <algorithm>
+#include <iterator>
+#include <list>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <QByteArray>
+#include <QCheckBox>
+#include <QComboBox>
+#include <QCoreApplication>
+#include <QCryptographicHash>
+#include <QDialogButtonBox>
+#include <QDir>
+#include <QFile>
+#include <QFileDialog>
+#include <QFileInfo>
+#include <QIODevice>
+#include <QLineEdit>
+#include <QList>
+#include <QMessageBox>
+#include <QProcess>
+#include <QRegularExpression>
+#include <QSet>
+#include <QStringList>
+#include <QTemporaryFile>
+#include <QTextStream>
+
+static void addHeaders(const QString& file1, QSet<QString> &allFiles) {
+    if (allFiles.contains(file1))
+        return;
+    QFile file(file1);
+    if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
+        return;
+    allFiles << file1;
+    const QRegularExpression re("^#include[ ]*\"([^\">]+)\".*");
+    QTextStream in(&file);
+    QString line = in.readLine();
+    while (!in.atEnd()) {
+        if (line.startsWith("#include")) {
+            const QRegularExpressionMatch match = re.match(line);
+            if (match.hasMatch()) {
+                QString hfile = match.captured(1);
+                if (file1.contains("/"))
+                    hfile = file1.mid(0,file1.lastIndexOf("/") + 1) + hfile;
+                addHeaders(hfile, allFiles);
+            }
+        }
+        line = in.readLine();
+    }
+}
+
+static std::vector<std::string> toStdStringList(const QStringList& from) {
+    std::vector<std::string> ret;
+    std::transform(from.cbegin(), from.cend(), std::back_inserter(ret), [](const QString& e) {
+        return e.toStdString();
+    });
+    return ret;
+}
+
+ComplianceReportDialog::ComplianceReportDialog(ProjectFile* projectFile, QString resultsFile, QString checkersReport)
+    : QDialog(nullptr),
+    mUI(new Ui::ComplianceReportDialog),
+    mProjectFile(projectFile),
+    mResultsFile(std::move(resultsFile)),
+    mCheckersReport(std::move(checkersReport))
+{
+    mUI->setupUi(this);
+    mUI->mEditProjectName->setText(projectFile->getProjectName());
+    connect(mUI->buttonBox, &QDialogButtonBox::clicked, this, &ComplianceReportDialog::buttonClicked);
+    mUI->mCodingStandard->clear();
+    if (!projectFile->getCodingStandards().contains("misra-c-2023") && projectFile->getAddons().contains("misra"))
+        mUI->mCodingStandard->addItem("Misra C 2012");
+    for (QString std: projectFile->getCodingStandards()) {
+        std[0] = std[0].toUpper();
+        std = std.replace("-", " ").replace(" c ", " C ").replace(" cpp ", " C++ ").replace(" c++ ", " C++ ");
+        mUI->mCodingStandard->addItem(std);
+    }
+}
+
+ComplianceReportDialog::~ComplianceReportDialog()
+{
+    delete mUI;
+}
+
+void ComplianceReportDialog::buttonClicked(QAbstractButton* button)
+{
+    switch (mUI->buttonBox->standardButton(button)) {
+    case QDialogButtonBox::StandardButton::Save:
+        save();
+        break;
+    case QDialogButtonBox::StandardButton::Close:
+        close();
+        break;
+    default:
+        break;
+    }
+}
+
+void ComplianceReportDialog::save()
+{
+    const QString std(mUI->mCodingStandard->currentText().toLower().replace(" ", "-"));
+
+    const QString outFile = QFileDialog::getSaveFileName(this,
+                                                         tr("Compliance report"),
+                                                         QDir::homePath() + "/" + std + "-compliance-report.html",
+                                                         tr("HTML files (*.html)"));
+    if (outFile.isEmpty())
+        return;
+
+    close();
+
+    const QString& projectName = mUI->mEditProjectName->text();
+    const QString& projectVersion = mUI->mEditProjectVersion->text();
+    const bool files = mUI->mCheckFiles->isChecked();
+
+    if (projectName != mProjectFile->getProjectName()) {
+        mProjectFile->setProjectName(projectName);
+        mProjectFile->write();
+    }
+
+    QTemporaryFile tempCheckersReport;
+    if (tempCheckersReport.open()) {
+        QTextStream out(&tempCheckersReport);
+        out << mCheckersReport << "\n";
+        tempCheckersReport.close();
+    }
+
+    QTemporaryFile tempFiles;
+    if (files && tempFiles.open()) {
+        QTextStream out(&tempFiles);
+        FileList fileList;
+        fileList.addPathList(mProjectFile->getCheckPaths());
+        if (!mProjectFile->getImportProject().isEmpty()) {
+            QFileInfo inf(mProjectFile->getFilename());
+
+            QString prjfile;
+            if (QFileInfo(mProjectFile->getImportProject()).isAbsolute())
+                prjfile = mProjectFile->getImportProject();
+            else
+                prjfile = inf.canonicalPath() + '/' + mProjectFile->getImportProject();
+
+            ImportProject p;
+            try {
+                p.import(prjfile.toStdString());
+            } catch (InternalError &e) {
+                QMessageBox msg(QMessageBox::Critical,
+                                tr("Save compliance report"),
+                                tr("Failed to import '%1' (%2), can not show files in compliance report").arg(prjfile).arg(QString::fromStdString(e.errorMessage)),
+                                QMessageBox::Ok,
+                                this);
+                msg.exec();
+                return;
+            }
+
+            p.ignorePaths(toStdStringList(mProjectFile->getExcludedPaths()));
+
+            QDir dir(inf.absoluteDir());
+            for (const FileSettings& fs: p.fileSettings)
+                fileList.addFile(dir.relativeFilePath(QString::fromStdString(fs.filename())));
+        }
+
+        QSet<QString> allFiles;
+        for (const QString &sourcefile: fileList.getFileList())
+            addHeaders(sourcefile, allFiles);
+        for (const QString& fileName: utils::as_const(allFiles)) {
+            QFile f(fileName);
+            if (f.open(QFile::ReadOnly)) {
+                QCryptographicHash hash(QCryptographicHash::Algorithm::Md5);
+                if (hash.addData(&f)) {
+                    for (auto b: hash.result())
+                        out << QString::number(static_cast<unsigned char>(b),16);
+                    out << " " << fileName << "\n";
+                }
+            }
+        }
+        tempFiles.close();
+    }
+
+    QStringList suppressions;
+    for (const auto& suppression: mProjectFile->getSuppressions()) {
+        if (!suppression.errorId.empty())
+            suppressions.append(QString::fromStdString(suppression.errorId));
+    }
+
+    QStringList args{"--project-name=" + projectName,
+                     "--project-version=" + projectVersion,
+                     "--output-file=" + outFile,
+                     "--checkers-report=" + tempCheckersReport.fileName()};
+    if (!suppressions.isEmpty())
+        args << "--suppressions=" + suppressions.join(",");
+
+    args << ("--" + std);
+
+    if (files)
+        args << "--files=" + tempFiles.fileName();
+    args << mResultsFile;
+
+    const QString appPath = QFileInfo(QCoreApplication::applicationFilePath()).canonicalPath();
+
+    QProcess process;
+#ifdef Q_OS_WIN
+    process.start(appPath + "/compliance-report.exe", args);
+#else
+    process.start(appPath + "/compliance-report", args);
+#endif
+    process.waitForFinished();
+    const QString output = process.readAll();
+    if (!output.isEmpty()) {
+        QMessageBox msg(QMessageBox::Critical,
+                        tr("Save compliance report"),
+                        output,
+                        QMessageBox::Ok,
+                        this);
+        msg.exec();
+    }
+}
diff --git a/gui/compliancereportdialog.h b/gui/compliancereportdialog.h
new file mode 100644
index 00000000000..c7ef27f1cc5
--- /dev/null
+++ b/gui/compliancereportdialog.h
@@ -0,0 +1,53 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef COMPLIANCEREPORTDIALOG_H
+#define COMPLIANCEREPORTDIALOG_H
+
+#include <QDialog>
+#include <QObject>
+#include <QString>
+
+namespace Ui {
+    class ComplianceReportDialog;
+}
+
+class ProjectFile;
+class QAbstractButton;
+
+class ComplianceReportDialog final : public QDialog
+{
+    Q_OBJECT
+
+public:
+    explicit ComplianceReportDialog(ProjectFile* projectFile, QString resultsFile, QString checkersReport);
+    ~ComplianceReportDialog() final;
+
+private slots:
+    void buttonClicked(QAbstractButton* button);
+
+private:
+    void save();
+
+    Ui::ComplianceReportDialog *mUI;
+    ProjectFile* mProjectFile;
+    const QString mResultsFile;
+    const QString mCheckersReport;
+};
+
+#endif // COMPLIANCEREPORTDIALOG_H
diff --git a/gui/compliancereportdialog.ui b/gui/compliancereportdialog.ui
new file mode 100644
index 00000000000..b756ec7eab5
--- /dev/null
+++ b/gui/compliancereportdialog.ui
@@ -0,0 +1,104 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ComplianceReportDialog</class>
+ <widget class="QDialog" name="ComplianceReportDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>403</width>
+    <height>199</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Compliance Report</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <layout class="QGridLayout" name="gridLayout">
+     <item row="2" column="0">
+      <widget class="QLabel" name="label_2">
+       <property name="text">
+        <string>Project version</string>
+       </property>
+      </widget>
+     </item>
+     <item row="1" column="0">
+      <widget class="QLabel" name="label">
+       <property name="text">
+        <string>Project name</string>
+       </property>
+      </widget>
+     </item>
+     <item row="1" column="1">
+      <widget class="QLineEdit" name="mEditProjectName"/>
+     </item>
+     <item row="2" column="1">
+      <widget class="QLineEdit" name="mEditProjectVersion"/>
+     </item>
+     <item row="0" column="0">
+      <widget class="QLabel" name="label_3">
+       <property name="text">
+        <string>Coding Standard</string>
+       </property>
+      </widget>
+     </item>
+     <item row="0" column="1">
+      <widget class="QComboBox" name="mCodingStandard">
+       <item>
+        <property name="text">
+         <string>Misra C</string>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>Cert C</string>
+        </property>
+       </item>
+       <item>
+        <property name="text">
+         <string>Cert C++</string>
+        </property>
+       </item>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <widget class="QCheckBox" name="mCheckFiles">
+     <property name="text">
+      <string>List of files with md5 checksums</string>
+     </property>
+     <property name="checked">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <spacer name="verticalSpacer">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>20</width>
+       <height>40</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item>
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Close|QDialogButtonBox::Save</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/gui/cppcheck-gui.rc b/gui/cppcheck-gui.rc
index 570ce2f5983..28f74f9ffef 100644
--- a/gui/cppcheck-gui.rc
+++ b/gui/cppcheck-gui.rc
@@ -1,5 +1,5 @@
-// Include command line program's resource file containing version info
-#include "../cli/version.rc"
-
-// GUI Icon
-IDI_ICON1               ICON    DISCARDABLE     "cppcheck.ico"
+// Include command line program's resource file containing version info
+#include "../cli/version.rc"
+
+// GUI Icon
+IDI_ICON1               ICON    DISCARDABLE     "cppcheck.ico"
diff --git a/gui/cppcheck_de.ts b/gui/cppcheck_de.ts
index 7f22a0993a6..c0d68ed6d8a 100644
--- a/gui/cppcheck_de.ts
+++ b/gui/cppcheck_de.ts
@@ -20,8 +20,9 @@
     </message>
     <message>
         <location filename="about.ui" line="81"/>
-        <source>Copyright © 2007-2019 Cppcheck team.</source>
-        <translation>Copyright © 2007-2019 Cppcheck-Team.</translation>
+        <source>Copyright © 2007-%1 Cppcheck team.</source>
+        <oldsource>Copyright © 2007-2021 Cppcheck team.</oldsource>
+        <translation>Copyright © 2007-%1 Cppcheck-Team.</translation>
     </message>
     <message>
         <location filename="about.ui" line="91"/>
@@ -37,29 +38,20 @@ der GNU General Public License Version 3 lizenziert</translation>
     </message>
     <message>
         <location filename="about.ui" line="115"/>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
-&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul&gt;
-&lt;li&gt;tinyxml2&lt;/li&gt;
-&lt;li&gt;picojson&lt;/li&gt;
-&lt;li&gt;pcre&lt;/li&gt;
-&lt;li&gt;qt&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
-        <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
-&lt;p&gt;Vielen Dank für die von uns genutzten Bibliotheken:&lt;/p&gt;&lt;ul&gt;
-&lt;li&gt;tinyxml2&lt;/li&gt;
-&lt;li&gt;picojson&lt;/li&gt;
-&lt;li&gt;pcre&lt;/li&gt;
-&lt;li&gt;qt&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</translation>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PCRE&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PicoJSON&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;TinyXML2&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Boost&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <oldsource>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;pcre&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;picojson&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;tinyxml2&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</oldsource>
+        <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Vielen Dank den Bibliotheken die wir nutzen:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PCRE&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PicoJSON&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;TinyXML2&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Boost&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
 </context>
 <context>
     <name>ApplicationDialog</name>
     <message>
-        <location filename="application.ui" line="23"/>
+        <location filename="applicationdialog.ui" line="23"/>
         <source>Add an application</source>
         <translation>Anwendung hinzufügen</translation>
     </message>
     <message>
-        <location filename="application.ui" line="41"/>
+        <location filename="applicationdialog.ui" line="41"/>
         <source>Here you can add an application that can open error files. Specify a name for the application, the application executable and command line parameters for the application.
 
 The following texts in parameters are replaced with appropriate values when application is executed:
@@ -71,7 +63,7 @@ The following texts in parameters are replaced with appropriate values when appl
 Example opening a file with Kate and make Kate scroll to the correct line:
 Executable: kate
 Parameters: -l(line) (file)</source>
-        <translation>Hier können Sie Anwendungen hinzufügen, die Codedateien öffnen können. Geben Sie den Namen der Anwendung, deren ausführbare Datei und Kommandozeilenparameter für die Ausführung an.
+        <translation>Hier können Sie Anwendungen hinzufügen, die Codedateien öffnen können. Geben Sie den Namen der Anwendung, deren ausführbare Datei und Kommandozeilenparameter für die Ausführung, an.
 
 Die folgenden Texte in Parametern werden durch die passenden Werte ersetzt, wenn die Anwendung ausgeführt wird:
 (file) - Name der Datei, die den Fehler enthält
@@ -85,65 +77,157 @@ Parameter: -l(line) (file)
 </translation>
     </message>
     <message>
-        <location filename="application.ui" line="76"/>
+        <location filename="applicationdialog.ui" line="76"/>
         <source>&amp;Name:</source>
         <translation>&amp;Name:</translation>
     </message>
     <message>
-        <location filename="application.ui" line="86"/>
+        <location filename="applicationdialog.ui" line="86"/>
         <source>&amp;Executable:</source>
         <translation>&amp;Ausführbare Datei:</translation>
     </message>
     <message>
-        <location filename="application.ui" line="96"/>
+        <location filename="applicationdialog.ui" line="96"/>
         <source>&amp;Parameters:</source>
         <translation>&amp;Parameter:</translation>
     </message>
     <message>
-        <location filename="application.ui" line="138"/>
+        <location filename="applicationdialog.ui" line="138"/>
         <source>Browse</source>
         <translation>Suchen</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="59"/>
+        <location filename="applicationdialog.cpp" line="65"/>
         <source>Executable files (*.exe);;All files(*.*)</source>
         <translation>Ausführbare Dateien (*.exe);;Alle Dateien(*.*)</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="62"/>
+        <location filename="applicationdialog.cpp" line="68"/>
         <source>Select viewer application</source>
         <translation>Anzeigeanwendung auswählen</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="77"/>
+        <location filename="applicationdialog.cpp" line="83"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="78"/>
+        <location filename="applicationdialog.cpp" line="84"/>
         <source>You must specify a name, a path and optionally parameters for the application!</source>
         <translation>Sie müssen einen Namen, einen Pfad und ggf. Parameter für die Anwendung angeben!</translation>
     </message>
 </context>
+<context>
+    <name>ComplianceReportDialog</name>
+    <message>
+        <location filename="compliancereportdialog.ui" line="14"/>
+        <source>Compliance Report</source>
+        <translation>Compliance-Report</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="29"/>
+        <source>Project name</source>
+        <translation>Projektname</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="22"/>
+        <source>Project version</source>
+        <translation>Projekt-Version</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="42"/>
+        <source>Coding Standard</source>
+        <translation>Programmierstandards</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="50"/>
+        <source>Misra C</source>
+        <translation>Misra C</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="55"/>
+        <source>Cert C</source>
+        <translation>Cert C</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="60"/>
+        <source>Cert C++</source>
+        <translation>Cert C++</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="70"/>
+        <source>List of files with md5 checksums</source>
+        <translation>Datei-Listen mit MD5-Prüfsummen</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="133"/>
+        <source>Compliance report</source>
+        <translation>Compliance-Report</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="135"/>
+        <source>HTML files (*.html)</source>
+        <translation>HTML-Dateien (*.html)</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="176"/>
+        <location filename="compliancereportdialog.cpp" line="239"/>
+        <source>Save compliance report</source>
+        <translation>Compliance-Report speichern</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="177"/>
+        <source>Failed to import &apos;%1&apos; (%2), can not show files in compliance report</source>
+        <translation>Import von &apos;%1&apos; (%2) fehlgeschlagen, Compliance-Report kann nicht angezeigt werden</translation>
+    </message>
+</context>
 <context>
     <name>FileViewDialog</name>
     <message>
-        <location filename="fileviewdialog.cpp" line="42"/>
+        <location filename="fileviewdialog.cpp" line="53"/>
         <source>Could not find the file: %1</source>
         <translation>Konnte die Datei nicht finden: %1</translation>
     </message>
     <message>
-        <location filename="fileviewdialog.cpp" line="46"/>
-        <location filename="fileviewdialog.cpp" line="60"/>
+        <location filename="fileviewdialog.cpp" line="57"/>
+        <location filename="fileviewdialog.cpp" line="71"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="fileviewdialog.cpp" line="56"/>
+        <location filename="fileviewdialog.cpp" line="67"/>
         <source>Could not read the file: %1</source>
         <translation>Konnte die Datei nicht lesen: %1</translation>
     </message>
 </context>
+<context>
+    <name>HelpDialog</name>
+    <message>
+        <location filename="helpdialog.ui" line="14"/>
+        <source>Cppcheck GUI help</source>
+        <translation>Cppcheck GUI Hilfe</translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="34"/>
+        <source>Contents</source>
+        <translation>Inhalt</translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="44"/>
+        <source>Index</source>
+        <translation>Index</translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="84"/>
+        <source>Helpfile &apos;%1&apos; was not found</source>
+        <translation>Hilfedatei &apos;%1&apos; nicht gefunden</translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="86"/>
+        <source>Cppcheck</source>
+        <translation>Cppcheck</translation>
+    </message>
+</context>
 <context>
     <name>LibraryAddFunctionDialog</name>
     <message>
@@ -250,40 +334,40 @@ Parameter: -l(line) (file)
         <translation>Bearbeiten</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="82"/>
-        <location filename="librarydialog.cpp" line="154"/>
+        <location filename="librarydialog.cpp" line="97"/>
+        <location filename="librarydialog.cpp" line="169"/>
         <source>Library files (*.cfg)</source>
         <translation>Bibliotheksdateien (*.cfg)</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="84"/>
+        <location filename="librarydialog.cpp" line="99"/>
         <source>Open library file</source>
         <translation>Bibliothek öffnen</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="95"/>
-        <location filename="librarydialog.cpp" line="107"/>
-        <location filename="librarydialog.cpp" line="144"/>
+        <location filename="librarydialog.cpp" line="110"/>
+        <location filename="librarydialog.cpp" line="122"/>
+        <location filename="librarydialog.cpp" line="159"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="96"/>
+        <location filename="librarydialog.cpp" line="111"/>
         <source>Cannot open file %1.</source>
         <translation>Datei %1 kann nicht geöffnet werden.</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="108"/>
+        <location filename="librarydialog.cpp" line="123"/>
         <source>Failed to load %1. %2.</source>
         <translation>%1 kann nicht geladen werden. %2.</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="145"/>
+        <location filename="librarydialog.cpp" line="160"/>
         <source>Cannot save file %1.</source>
         <translation>Datei %1 kann nicht gespeichert werden.</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="157"/>
+        <location filename="librarydialog.cpp" line="172"/>
         <source>Save the library as</source>
         <translation>Speichere Bibliothek unter</translation>
     </message>
@@ -412,527 +496,617 @@ Parameter: -l(line) (file)
     <name>MainWindow</name>
     <message>
         <location filename="mainwindow.ui" line="26"/>
-        <location filename="mainwindow.ui" line="595"/>
-        <location filename="mainwindow.cpp" line="328"/>
-        <location filename="mainwindow.cpp" line="480"/>
-        <location filename="mainwindow.cpp" line="553"/>
-        <location filename="mainwindow.cpp" line="658"/>
-        <location filename="mainwindow.cpp" line="680"/>
-        <location filename="mainwindow.cpp" line="1113"/>
-        <location filename="mainwindow.cpp" line="1238"/>
-        <location filename="mainwindow.cpp" line="1359"/>
-        <location filename="mainwindow.cpp" line="1499"/>
-        <location filename="mainwindow.cpp" line="1522"/>
-        <location filename="mainwindow.cpp" line="1593"/>
-        <location filename="mainwindow.cpp" line="1667"/>
+        <location filename="mainwindow.ui" line="688"/>
+        <location filename="mainwindow.cpp" line="466"/>
+        <location filename="mainwindow.cpp" line="670"/>
+        <location filename="mainwindow.cpp" line="755"/>
+        <location filename="mainwindow.cpp" line="860"/>
+        <location filename="mainwindow.cpp" line="882"/>
+        <location filename="mainwindow.cpp" line="1467"/>
+        <location filename="mainwindow.cpp" line="1596"/>
+        <location filename="mainwindow.cpp" line="1937"/>
+        <location filename="mainwindow.cpp" line="1945"/>
+        <location filename="mainwindow.cpp" line="1999"/>
+        <location filename="mainwindow.cpp" line="2008"/>
+        <location filename="mainwindow.cpp" line="2080"/>
+        <location filename="mainwindow.cpp" line="2168"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="183"/>
+        <location filename="mainwindow.ui" line="267"/>
         <source>Standard</source>
         <translation>Standard</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="70"/>
+        <location filename="mainwindow.ui" line="132"/>
         <source>&amp;File</source>
         <translation>&amp;Datei</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="89"/>
+        <location filename="mainwindow.ui" line="152"/>
         <source>&amp;View</source>
         <translation>&amp;Ansicht</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="93"/>
+        <location filename="mainwindow.ui" line="156"/>
         <source>&amp;Toolbars</source>
         <translation>&amp;Symbolleisten</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="131"/>
+        <location filename="mainwindow.ui" line="210"/>
         <source>A&amp;nalyze</source>
         <translation>A&amp;nalysieren</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="135"/>
+        <location filename="mainwindow.ui" line="214"/>
         <source>C++ standard</source>
         <translation>C++-Standard</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="145"/>
+        <location filename="mainwindow.ui" line="226"/>
         <source>&amp;C standard</source>
         <translation>&amp;C-Standard</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="170"/>
+        <location filename="mainwindow.ui" line="254"/>
         <source>&amp;Edit</source>
         <translation>&amp;Bearbeiten</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="231"/>
+        <location filename="mainwindow.ui" line="315"/>
         <source>&amp;License...</source>
         <translation>&amp;Lizenz...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="236"/>
+        <location filename="mainwindow.ui" line="320"/>
         <source>A&amp;uthors...</source>
         <translation>&amp;Autoren...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="245"/>
+        <location filename="mainwindow.ui" line="329"/>
         <source>&amp;About...</source>
         <translation>Ü&amp;ber...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="250"/>
+        <location filename="mainwindow.ui" line="334"/>
         <source>&amp;Files...</source>
         <translation>&amp;Dateien...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="253"/>
-        <location filename="mainwindow.ui" line="256"/>
+        <location filename="mainwindow.ui" line="337"/>
+        <location filename="mainwindow.ui" line="340"/>
         <source>Analyze files</source>
         <translation>Analysiere Dateien</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="259"/>
+        <location filename="mainwindow.ui" line="343"/>
         <source>Ctrl+F</source>
         <translation>Strg+F</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="268"/>
+        <location filename="mainwindow.ui" line="352"/>
         <source>&amp;Directory...</source>
         <translation>&amp;Verzeichnis...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="271"/>
-        <location filename="mainwindow.ui" line="274"/>
+        <location filename="mainwindow.ui" line="355"/>
+        <location filename="mainwindow.ui" line="358"/>
         <source>Analyze directory</source>
         <translation>Analysiere Verzeichnis</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="277"/>
+        <location filename="mainwindow.ui" line="361"/>
         <source>Ctrl+D</source>
         <translation>Strg+D</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="289"/>
+        <location filename="mainwindow.ui" line="373"/>
         <source>Ctrl+R</source>
         <translation>Strg+R</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="307"/>
+        <location filename="mainwindow.ui" line="391"/>
         <source>&amp;Stop</source>
         <translation>&amp;Stoppen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="310"/>
-        <location filename="mainwindow.ui" line="313"/>
+        <location filename="mainwindow.ui" line="394"/>
+        <location filename="mainwindow.ui" line="397"/>
         <source>Stop analysis</source>
         <translation>Analyse abbrechen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="316"/>
+        <location filename="mainwindow.ui" line="400"/>
         <source>Esc</source>
         <translation>Esc</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="325"/>
+        <location filename="mainwindow.ui" line="409"/>
         <source>&amp;Save results to file...</source>
         <translation>&amp;Ergebnisse in Datei speichern...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="328"/>
+        <location filename="mainwindow.ui" line="412"/>
         <source>Ctrl+S</source>
         <translation>Strg+S</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="333"/>
+        <location filename="mainwindow.ui" line="417"/>
         <source>&amp;Quit</source>
         <translation>&amp;Beenden</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="342"/>
+        <location filename="mainwindow.ui" line="429"/>
         <source>&amp;Clear results</source>
         <translation>Ergebnisse &amp;löschen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="351"/>
+        <location filename="mainwindow.ui" line="438"/>
         <source>&amp;Preferences</source>
         <translation>&amp;Einstellungen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="384"/>
-        <location filename="mainwindow.ui" line="387"/>
+        <location filename="mainwindow.ui" line="471"/>
+        <location filename="mainwindow.ui" line="474"/>
+        <location filename="mainwindow.cpp" line="2394"/>
         <source>Show errors</source>
         <translation>Zeige Fehler</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="524"/>
-        <location filename="mainwindow.ui" line="527"/>
+        <location filename="mainwindow.ui" line="617"/>
+        <location filename="mainwindow.ui" line="620"/>
+        <location filename="mainwindow.cpp" line="2395"/>
         <source>Show warnings</source>
         <translation>Zeige Warnungen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="542"/>
-        <location filename="mainwindow.ui" line="545"/>
+        <location filename="mainwindow.ui" line="635"/>
+        <location filename="mainwindow.ui" line="638"/>
         <source>Show performance warnings</source>
         <translation>Zeige Performance-Warnungen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="553"/>
+        <location filename="mainwindow.ui" line="646"/>
         <source>Show &amp;hidden</source>
         <translation>Zeige &amp;versteckte</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="769"/>
-        <location filename="mainwindow.cpp" line="807"/>
+        <location filename="mainwindow.cpp" line="986"/>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Information</source>
         <translation>Information</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="568"/>
+        <location filename="mainwindow.ui" line="661"/>
         <source>Show information messages</source>
         <translation>Zeige Informationsmeldungen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="583"/>
+        <location filename="mainwindow.ui" line="676"/>
         <source>Show portability warnings</source>
         <translation>Zeige Portabilitätswarnungen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="598"/>
+        <location filename="mainwindow.ui" line="691"/>
         <source>Show Cppcheck results</source>
         <translation>Zeige Cppcheck-Ergebnisse</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="610"/>
+        <location filename="mainwindow.ui" line="703"/>
         <source>Clang</source>
         <translation>Clang</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="613"/>
+        <location filename="mainwindow.ui" line="706"/>
         <source>Show Clang results</source>
         <translation>Zeige Clang-Ergebnisse</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="621"/>
+        <location filename="mainwindow.ui" line="714"/>
         <source>&amp;Filter</source>
         <translation>&amp;Filter</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="624"/>
+        <location filename="mainwindow.ui" line="717"/>
         <source>Filter results</source>
         <translation>Gefilterte Ergebnisse</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="640"/>
+        <location filename="mainwindow.ui" line="733"/>
         <source>Windows 32-bit ANSI</source>
         <translation>Windows 32-bit, ANSI</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="648"/>
+        <location filename="mainwindow.ui" line="741"/>
         <source>Windows 32-bit Unicode</source>
         <translation>Windows 32-bit, Unicode</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="656"/>
+        <location filename="mainwindow.ui" line="749"/>
         <source>Unix 32-bit</source>
         <translation>Unix 32-bit</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="664"/>
+        <location filename="mainwindow.ui" line="757"/>
         <source>Unix 64-bit</source>
         <translation>Unix 64-bit</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="672"/>
+        <location filename="mainwindow.ui" line="765"/>
         <source>Windows 64-bit</source>
         <translation>Windows 64-bit</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="742"/>
+        <location filename="mainwindow.ui" line="859"/>
         <source>&amp;Print...</source>
         <translation>Drucken...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="745"/>
+        <location filename="mainwindow.ui" line="862"/>
         <source>Print the Current Report</source>
         <translation>Aktuellen Bericht ausdrucken</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="750"/>
+        <location filename="mainwindow.ui" line="867"/>
         <source>Print Pre&amp;view...</source>
         <translation>Druckvorschau</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="753"/>
+        <location filename="mainwindow.ui" line="870"/>
         <source>Open a Print Preview Dialog for the Current Results</source>
         <translation>Druckvorschaudialog für aktuelle Ergebnisse öffnen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="761"/>
+        <location filename="mainwindow.ui" line="878"/>
         <source>Open library editor</source>
         <translation>Bibliothekseditor öffnen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="392"/>
+        <location filename="mainwindow.ui" line="479"/>
         <source>&amp;Check all</source>
         <translation>Alle &amp;auswählen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="220"/>
+        <location filename="mainwindow.ui" line="84"/>
+        <source>Checking for updates</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="100"/>
+        <source>Hide</source>
+        <translation type="unfinished">Verstecken</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="164"/>
+        <location filename="mainwindow.ui" line="980"/>
+        <source>Report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="304"/>
         <source>Filter</source>
         <translation>Filter</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="286"/>
+        <location filename="mainwindow.ui" line="370"/>
         <source>&amp;Reanalyze modified files</source>
         <translation>Veränderte Dateien neu analysieren</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="298"/>
+        <location filename="mainwindow.ui" line="382"/>
         <source>Reanal&amp;yze all files</source>
         <translation>Alle Dateien erneut anal&amp;ysieren</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="363"/>
+        <location filename="mainwindow.ui" line="420"/>
+        <source>Ctrl+Q</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="450"/>
         <source>Style war&amp;nings</source>
         <translation>Stilwar&amp;nungen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="381"/>
+        <location filename="mainwindow.ui" line="468"/>
         <source>E&amp;rrors</source>
         <translation>F&amp;ehler</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="397"/>
+        <location filename="mainwindow.ui" line="484"/>
         <source>&amp;Uncheck all</source>
         <translation>Alle a&amp;bwählen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="402"/>
+        <location filename="mainwindow.ui" line="489"/>
         <source>Collapse &amp;all</source>
         <translation>Alle &amp;reduzieren</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="407"/>
+        <location filename="mainwindow.ui" line="494"/>
         <source>&amp;Expand all</source>
         <translation>Alle &amp;erweitern</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="415"/>
+        <location filename="mainwindow.ui" line="502"/>
         <source>&amp;Standard</source>
         <translation>&amp;Standard</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="418"/>
+        <location filename="mainwindow.ui" line="505"/>
         <source>Standard items</source>
         <translation>Standardeinträge</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="434"/>
+        <location filename="mainwindow.ui" line="521"/>
         <source>Toolbar</source>
         <translation>Symbolleiste</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="442"/>
+        <location filename="mainwindow.ui" line="529"/>
         <source>&amp;Categories</source>
         <translation>&amp;Kategorien</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="445"/>
+        <location filename="mainwindow.ui" line="532"/>
         <source>Error categories</source>
         <translation>Fehler-Kategorien</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="450"/>
+        <location filename="mainwindow.ui" line="537"/>
         <source>&amp;Open XML...</source>
         <translation>Öffne &amp;XML...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="459"/>
+        <location filename="mainwindow.ui" line="546"/>
         <source>Open P&amp;roject File...</source>
         <translation>Pr&amp;ojektdatei öffnen...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="468"/>
+        <location filename="mainwindow.ui" line="549"/>
+        <source>Ctrl+Shift+O</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="558"/>
         <source>Sh&amp;ow Scratchpad...</source>
         <translation>&amp;Zeige Schmierzettel...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="473"/>
+        <location filename="mainwindow.ui" line="563"/>
         <source>&amp;New Project File...</source>
         <translation>&amp;Neue Projektdatei...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="478"/>
+        <location filename="mainwindow.ui" line="566"/>
+        <source>Ctrl+Shift+N</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="571"/>
         <source>&amp;Log View</source>
         <translation>&amp;Loganzeige</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="481"/>
+        <location filename="mainwindow.ui" line="574"/>
         <source>Log View</source>
         <translation>Loganzeige</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="489"/>
+        <location filename="mainwindow.ui" line="582"/>
         <source>C&amp;lose Project File</source>
         <translation>Projektdatei &amp;schließen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="497"/>
+        <location filename="mainwindow.ui" line="590"/>
         <source>&amp;Edit Project File...</source>
         <translation>Projektdatei &amp;bearbeiten...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="509"/>
+        <location filename="mainwindow.ui" line="602"/>
         <source>&amp;Statistics</source>
         <translation>&amp;Statistik</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="521"/>
+        <location filename="mainwindow.ui" line="614"/>
         <source>&amp;Warnings</source>
         <translation>&amp;Warnungen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="539"/>
+        <location filename="mainwindow.ui" line="632"/>
         <source>Per&amp;formance warnings</source>
         <translation>Per&amp;formance-Warnungen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="565"/>
+        <location filename="mainwindow.ui" line="658"/>
         <source>&amp;Information</source>
         <translation>&amp;Information</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="580"/>
+        <location filename="mainwindow.ui" line="673"/>
         <source>&amp;Portability</source>
         <translation>&amp;Portabilität</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="680"/>
+        <location filename="mainwindow.ui" line="773"/>
         <source>P&amp;latforms</source>
         <translation>P&amp;lattformen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="694"/>
+        <location filename="mainwindow.ui" line="787"/>
         <source>C++&amp;11</source>
         <translation>C++&amp;11</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="705"/>
+        <location filename="mainwindow.ui" line="798"/>
         <source>C&amp;99</source>
         <translation>C&amp;99</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="713"/>
+        <location filename="mainwindow.ui" line="806"/>
         <source>&amp;Posix</source>
         <translation>Posix</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="721"/>
+        <location filename="mainwindow.ui" line="814"/>
         <source>C&amp;11</source>
         <translation>C&amp;11</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="729"/>
+        <location filename="mainwindow.ui" line="846"/>
         <source>&amp;C89</source>
         <translation>&amp;C89</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="737"/>
+        <location filename="mainwindow.ui" line="854"/>
         <source>&amp;C++03</source>
         <translation>&amp;C++03</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="758"/>
+        <location filename="mainwindow.ui" line="875"/>
         <source>&amp;Library Editor...</source>
         <translation>&amp;Bibliothekseditor</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="769"/>
+        <location filename="mainwindow.ui" line="886"/>
         <source>&amp;Auto-detect language</source>
         <translation>Sprache &amp;automatisch erkennen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="777"/>
+        <location filename="mainwindow.ui" line="894"/>
         <source>&amp;Enforce C++</source>
         <translation>C++ &amp;erzwingen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="785"/>
+        <location filename="mainwindow.ui" line="902"/>
         <source>E&amp;nforce C</source>
         <translation>C e&amp;rzwingen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="796"/>
+        <location filename="mainwindow.ui" line="913"/>
         <source>C++14</source>
         <translation>C++14</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="804"/>
+        <location filename="mainwindow.ui" line="921"/>
         <source>Reanalyze and check library</source>
         <translation>Neu analysieren und Bibliothek prüfen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="812"/>
+        <location filename="mainwindow.ui" line="929"/>
         <source>Check configuration (defines, includes)</source>
         <translation>Prüfe Konfiguration (Definitionen, Includes)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="820"/>
+        <location filename="mainwindow.ui" line="937"/>
         <source>C++17</source>
         <translation>C++17</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="831"/>
+        <location filename="mainwindow.ui" line="948"/>
         <source>C++20</source>
         <translation>C++20</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="423"/>
+        <location filename="mainwindow.ui" line="975"/>
+        <source>Compliance report...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="988"/>
+        <source>Normal</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="996"/>
+        <source>Misra C</source>
+        <translation>Misra C</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1004"/>
+        <source>Misra C++ 2008</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1012"/>
+        <source>Cert C</source>
+        <translation>Cert C</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1020"/>
+        <source>Cert C++</source>
+        <translation>Cert C++</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1028"/>
+        <source>Misra C++ 2023</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1036"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1041"/>
+        <source>EULA...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1046"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1049"/>
+        <source>Show thread details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="510"/>
         <source>&amp;Contents</source>
         <translation>&amp;Inhalte</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="201"/>
+        <location filename="mainwindow.ui" line="285"/>
         <source>Categories</source>
         <translation>Kategorien</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="366"/>
-        <location filename="mainwindow.ui" line="369"/>
+        <location filename="mainwindow.ui" line="453"/>
+        <location filename="mainwindow.ui" line="456"/>
         <source>Show style warnings</source>
         <translation>Zeige Stilwarnungen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="426"/>
+        <location filename="mainwindow.ui" line="513"/>
         <source>Open the help contents</source>
         <translation>Öffnet die Hilfe-Inhalte</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="429"/>
+        <location filename="mainwindow.ui" line="516"/>
         <source>F1</source>
         <translation>F1</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="121"/>
+        <location filename="mainwindow.ui" line="199"/>
         <source>&amp;Help</source>
         <translation>&amp;Hilfe</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="87"/>
+        <location filename="mainwindow.cpp" line="157"/>
+        <location filename="mainwindow.cpp" line="1782"/>
         <source>Quick Filter:</source>
         <translation>Schnellfilter:</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="629"/>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select configuration</source>
         <translation>Konfiguration wählen</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="659"/>
+        <location filename="mainwindow.cpp" line="861"/>
         <source>Found project file: %1
 
 Do you want to load this project file instead?</source>
@@ -941,65 +1115,102 @@ Do you want to load this project file instead?</source>
 Möchten Sie stattdessen diese öffnen?</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="778"/>
+        <location filename="mainwindow.cpp" line="995"/>
         <source>File not found</source>
         <translation>Datei nicht gefunden</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="781"/>
+        <location filename="mainwindow.cpp" line="998"/>
         <source>Bad XML</source>
         <translation>Fehlerhaftes XML</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="784"/>
+        <location filename="mainwindow.cpp" line="1001"/>
         <source>Missing attribute</source>
         <translation>Fehlendes Attribut</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="787"/>
+        <location filename="mainwindow.cpp" line="1004"/>
         <source>Bad attribute value</source>
         <translation>Falscher Attributwert</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="793"/>
+        <location filename="mainwindow.cpp" line="1010"/>
         <source>Duplicate platform type</source>
         <translation>Plattformtyp doppelt</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="796"/>
+        <location filename="mainwindow.cpp" line="1013"/>
         <source>Platform type redefined</source>
         <translation>Plattformtyp neu definiert</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="807"/>
+        <location filename="mainwindow.cpp" line="1016"/>
+        <source>Duplicate define</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Failed to load the selected library &apos;%1&apos;.
 %2</source>
         <translation>Laden der ausgewählten Bibliothek &apos;%1&apos; schlug fehl.
 %2</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1280"/>
+        <location filename="mainwindow.cpp" line="1035"/>
+        <source>File not found: &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1058"/>
+        <source>Failed to load/setup addon %1: %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <source>Failed to load %1 - %2
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
+        <source>%1
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1648"/>
         <source>License</source>
         <translation>Lizenz</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1287"/>
+        <location filename="mainwindow.cpp" line="1655"/>
         <source>Authors</source>
         <translation>Autoren</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1302"/>
+        <location filename="mainwindow.cpp" line="1675"/>
         <source>Save the report file</source>
         <translation>Speichert die Berichtdatei</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1129"/>
-        <location filename="mainwindow.cpp" line="1309"/>
+        <location filename="mainwindow.cpp" line="1483"/>
+        <location filename="mainwindow.cpp" line="1682"/>
         <source>XML files (*.xml)</source>
         <translation>XML-Dateien (*.xml)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="323"/>
+        <location filename="mainwindow.cpp" line="461"/>
         <source>There was a problem with loading the editor application settings.
 
 This is probably because the settings were changed between the Cppcheck versions. Please check (and fix) the editor application settings, otherwise the editor program might not start correctly.</source>
@@ -1008,129 +1219,120 @@ This is probably because the settings were changed between the Cppcheck versions
 Dies wurde vermutlich durch einen Wechsel der Cppcheck-Version hervorgerufen. Bitte prüfen (und korrigieren) Sie die Einstellungen, andernfalls könnte die Editor-Anwendung nicht korrekt starten.</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="554"/>
+        <location filename="mainwindow.cpp" line="756"/>
         <source>You must close the project file before selecting new files or directories!</source>
         <translation>Sie müssen die Projektdatei schließen, bevor Sie neue Dateien oder Verzeichnisse auswählen!</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="769"/>
+        <location filename="mainwindow.cpp" line="986"/>
         <source>The library &apos;%1&apos; contains unknown elements:
 %2</source>
         <translation>Die Bibliothek &apos;%1&apos; enthält unbekannte Elemente:
 %2</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="790"/>
+        <location filename="mainwindow.cpp" line="1007"/>
         <source>Unsupported format</source>
         <translation>Nicht unterstütztes Format</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="799"/>
+        <location filename="mainwindow.cpp" line="1019"/>
         <source>Unknown element</source>
         <translation>Unbekanntes Element</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="802"/>
-        <source>Unknown issue</source>
-        <translation>Unbekannter Fehler</translation>
+        <location filename="mainwindow.cpp" line="1019"/>
+        <source>Unknown element</source>
+        <oldsource>Unknown issue</oldsource>
+        <translation type="unfinished">Unbekannter Fehler</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="828"/>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
         <source>Error</source>
         <translation>Fehler</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="828"/>
         <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.</source>
-        <translation>Laden von %1 fehlgeschlagen. Ihre Cppcheck-Installation ist defekt. Sie können --data-dir=&lt;Verzeichnis&gt; als Kommandozeilenparameter verwenden, um anzugeben, wo die Datei sich befindet. Bitte beachten Sie, dass --data-dir in Installationsroutinen genutzt werden soll, und die GUI bei dessen Nutzung nicht startet, sondern die Einstellungen konfiguriert.</translation>
+        <translation type="vanished">Laden von %1 fehlgeschlagen. Ihre Cppcheck-Installation ist defekt. Sie können --data-dir=&lt;Verzeichnis&gt; als Kommandozeilenparameter verwenden, um anzugeben, wo die Datei sich befindet. Bitte beachten Sie, dass --data-dir in Installationsroutinen genutzt werden soll, und die GUI bei dessen Nutzung nicht startet, sondern die Einstellungen konfiguriert.</translation>
     </message>
     <message>
-        <source>Current results will be cleared.
-
-Opening a new XML file will clear current results.Do you want to proceed?</source>
-        <translation type="vanished">Aktuelle Ergebnisse werden gelöscht.
-
-          Das Einlesen einer XML-Datei löscht die aktuellen Ergebnisse. Fortfahren?</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1131"/>
+        <location filename="mainwindow.cpp" line="1485"/>
         <source>Open the report file</source>
         <translation>Berichtdatei öffnen</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1313"/>
+        <location filename="mainwindow.cpp" line="1686"/>
         <source>Text files (*.txt)</source>
         <translation>Textdateien (*.txt)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1317"/>
+        <location filename="mainwindow.cpp" line="1690"/>
         <source>CSV files (*.csv)</source>
         <translation>CSV-Dateien (*.csv)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1361"/>
-        <source>Cppcheck - %1</source>
-        <translation>Cppcheck - %1</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1407"/>
+        <location filename="mainwindow.cpp" line="1820"/>
         <source>Project files (*.cppcheck);;All files(*.*)</source>
         <translation>Projektdateien (*.cppcheck);;Alle Dateien(*.*)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1409"/>
+        <location filename="mainwindow.cpp" line="1822"/>
         <source>Select Project File</source>
         <translation>Projektdatei auswählen</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="159"/>
-        <location filename="mainwindow.cpp" line="1437"/>
-        <location filename="mainwindow.cpp" line="1562"/>
+        <location filename="mainwindow.cpp" line="242"/>
+        <location filename="mainwindow.cpp" line="1784"/>
+        <location filename="mainwindow.cpp" line="1850"/>
+        <location filename="mainwindow.cpp" line="2048"/>
         <source>Project:</source>
         <translation>Projekt:</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="481"/>
+        <location filename="mainwindow.cpp" line="671"/>
         <source>No suitable files found to analyze!</source>
         <translation>Keine passenden Dateien für Analyse gefunden!</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="568"/>
+        <location filename="mainwindow.cpp" line="770"/>
         <source>C/C++ Source</source>
         <translation>C/C++-Quellcode</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="569"/>
+        <location filename="mainwindow.cpp" line="771"/>
         <source>Compile database</source>
         <translation>Compilerdatenbank</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="570"/>
+        <location filename="mainwindow.cpp" line="772"/>
         <source>Visual Studio</source>
         <translation>Visual Studio</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="571"/>
+        <location filename="mainwindow.cpp" line="773"/>
         <source>Borland C++ Builder 6</source>
         <translation>Borland C++-Builder 6</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="574"/>
+        <location filename="mainwindow.cpp" line="776"/>
         <source>Select files to analyze</source>
         <translation>Dateien für Analyse auswählen</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="589"/>
+        <location filename="mainwindow.cpp" line="791"/>
         <source>Select directory to analyze</source>
         <translation>Verzeichnis für Analyse auswählen</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="629"/>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select the configuration that will be analyzed</source>
         <translation>Zu analysierende Konfiguration auswählen</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="681"/>
+        <location filename="mainwindow.cpp" line="883"/>
         <source>Found project files from the directory.
 
 Do you want to proceed analysis without using any of these project files?</source>
@@ -1139,7 +1341,7 @@ Do you want to proceed analysis without using any of these project files?</sourc
 Wollen sie fortfahren, ohne diese Projektdateien zu nutzen?</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1114"/>
+        <location filename="mainwindow.cpp" line="1468"/>
         <source>Current results will be cleared.
 
 Opening a new XML file will clear current results.
@@ -1150,7 +1352,7 @@ Eine neue XML-Datei zu öffnen wird die aktuellen Ergebnisse löschen
 Möchten sie fortfahren?</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1234"/>
+        <location filename="mainwindow.cpp" line="1592"/>
         <source>Analyzer is running.
 
 Do you want to stop the analysis and exit Cppcheck?</source>
@@ -1159,37 +1361,133 @@ Do you want to stop the analysis and exit Cppcheck?</source>
 Wollen sie die Analyse abbrechen und Cppcheck beenden?</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1300"/>
+        <location filename="mainwindow.cpp" line="1634"/>
+        <source>About</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1673"/>
         <source>XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
         <translation>XML-Dateien (*.xml);;Textdateien (*.txt);;CSV-Dateien (*.csv)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1500"/>
+        <location filename="mainwindow.cpp" line="1713"/>
+        <source>Cannot generate a compliance report right now, an analysis must finish successfully. Try to reanalyze the code and ensure there are no critical errors.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1938"/>
         <source>Build dir &apos;%1&apos; does not exist, create it?</source>
         <translation>Erstellungsverzeichnis &apos;%1&apos; existiert nicht. Erstellen?</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1523"/>
+        <location filename="mainwindow.cpp" line="1946"/>
+        <source>To check the project using addons, you need a build directory.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1978"/>
+        <source>Failed to open file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1981"/>
+        <source>Unknown project file format</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1984"/>
+        <source>Failed to import project file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2000"/>
+        <source>Failed to import &apos;%1&apos;: %2
+
+Analysis is stopped.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2009"/>
+        <source>Failed to import &apos;%1&apos; (%2), analysis is stopped</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2367"/>
+        <source>Show Mandatory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2368"/>
+        <source>Show Required</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2369"/>
+        <source>Show Advisory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2370"/>
+        <source>Show Document</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2387"/>
+        <source>Show L1</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2388"/>
+        <source>Show L2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2389"/>
+        <source>Show L3</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2396"/>
+        <source>Show style</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2397"/>
+        <source>Show portability</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2398"/>
+        <source>Show performance</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2399"/>
+        <source>Show information</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
         <source>Failed to import &apos;%1&apos;, analysis is stopped</source>
-        <translation>Import von &apos;%1&apos; fehlgeschlagen; Analyse wurde abgebrochen.</translation>
+        <translation type="vanished">Import von &apos;%1&apos; fehlgeschlagen; Analyse wurde abgebrochen.</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1547"/>
+        <location filename="mainwindow.cpp" line="2033"/>
         <source>Project files (*.cppcheck)</source>
         <translation>Projektdateien (*.cppcheck)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1549"/>
+        <location filename="mainwindow.cpp" line="2035"/>
         <source>Select Project Filename</source>
         <translation>Projektnamen auswählen</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1594"/>
+        <location filename="mainwindow.cpp" line="2081"/>
         <source>No project file loaded</source>
         <translation>Keine Projektdatei geladen</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1662"/>
+        <location filename="mainwindow.cpp" line="2163"/>
         <source>The project file
 
 %1
@@ -1206,7 +1504,17 @@ Do you want to remove the file from the recently used projects -list?</source>
 Möchten Sie die Datei von der Liste der zuletzt benutzten Projekte entfernen?</translation>
     </message>
     <message>
-        <location filename="main.cpp" line="106"/>
+        <location filename="mainwindow.cpp" line="2325"/>
+        <source>Install</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2329"/>
+        <source>New version available: %1. %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="main.cpp" line="100"/>
         <source>Cppcheck GUI.
 
 Syntax:
@@ -1237,7 +1545,7 @@ Options:
         </translation>
     </message>
     <message>
-        <location filename="main.cpp" line="121"/>
+        <location filename="main.cpp" line="115"/>
         <source>Cppcheck GUI - Command line parameters</source>
         <translation>Cppcheck GUI - Kommandozeilenparameter</translation>
     </message>
@@ -1270,7 +1578,7 @@ Options:
         <translation>Symbolname</translation>
     </message>
     <message>
-        <location filename="newsuppressiondialog.cpp" line="52"/>
+        <location filename="newsuppressiondialog.cpp" line="83"/>
         <source>Edit suppression</source>
         <translation>Fehlerunterdrückung bearbeiten</translation>
     </message>
@@ -1278,32 +1586,32 @@ Options:
 <context>
     <name>Platforms</name>
     <message>
-        <location filename="platforms.cpp" line="37"/>
+        <location filename="platforms.cpp" line="38"/>
         <source>Native</source>
         <translation>Nativ</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="38"/>
+        <location filename="platforms.cpp" line="39"/>
         <source>Unix 32-bit</source>
         <translation>Unix 32-bit</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="39"/>
+        <location filename="platforms.cpp" line="40"/>
         <source>Unix 64-bit</source>
         <translation>Unix 64-bit</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="40"/>
+        <location filename="platforms.cpp" line="41"/>
         <source>Windows 32-bit ANSI</source>
         <translation>Windows 32-bit, ANSI</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="41"/>
+        <location filename="platforms.cpp" line="42"/>
         <source>Windows 32-bit Unicode</source>
         <translation>Windows 32-bit, Unicode</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="42"/>
+        <location filename="platforms.cpp" line="43"/>
         <source>Windows 64-bit</source>
         <translation>Windows 64-bit</translation>
     </message>
@@ -1311,235 +1619,393 @@ Options:
 <context>
     <name>ProjectFile</name>
     <message>
-        <location filename="projectfiledialog.ui" line="14"/>
+        <location filename="projectfile.ui" line="14"/>
         <source>Project File</source>
         <translation>Projektdatei</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="24"/>
+        <location filename="projectfile.ui" line="24"/>
         <source>Paths and Defines</source>
         <translation>Pfade und Definitionen</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="30"/>
+        <location filename="projectfile.ui" line="30"/>
         <source>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</source>
         <translation>Importiere Projekt (Visual Studio / Compile-Datenbank / Borland C++-Builder 6)</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="163"/>
+        <location filename="projectfile.ui" line="231"/>
         <source>Defines must be separated by a semicolon. Example: DEF1;DEF2=5;DEF3=int</source>
         <translation>Definitionen müssen mit einem Semikolon getrennt werden. Beispiel: DEF1;DEF2=5;DEF3=int</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="393"/>
+        <location filename="projectfile.ui" line="389"/>
         <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
         <translation>Hinweis: Legen Sie eigene .cfg-Dateien in den Ordner der Projektdatei. Dann sollten sie oben sichtbar werden.</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="557"/>
-        <source>Addons and tools</source>
-        <translation>Addons und Werkzeuge</translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="597"/>
         <source>MISRA C 2012</source>
-        <translation>MISRA C 2012</translation>
+        <translation type="vanished">MISRA C 2012</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="606"/>
-        <source>Misra rule texts</source>
-        <translation>Misra-Regeltexte</translation>
+        <location filename="projectfile.ui" line="876"/>
+        <source>MISRA rule texts</source>
+        <translation>MISRA-Regeltexte</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="613"/>
+        <location filename="projectfile.ui" line="883"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Text aus Anhang A &amp;quot;Summary of guidelines&amp;quot; aus der MISRA-C-2012-PDF in eine Textdatei einfügen.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="620"/>
+        <location filename="projectfile.ui" line="890"/>
         <source>...</source>
         <translation>...</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="69"/>
+        <location filename="projectfile.ui" line="73"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;You have a choice:&lt;/p&gt;&lt;p&gt; * Analyze all Debug and Release configurations&lt;/p&gt;&lt;p&gt; * Only analyze the first matching Debug configuration&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Sie haben die Auswahl:&lt;/p&gt;&lt;p&gt; * Alle Debug- und Release-Konfigurationen analysieren&lt;/p&gt;&lt;p&gt; * Nur die erste passende Debug-Konfiguration analysieren&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="60"/>
-        <location filename="projectfiledialog.ui" line="309"/>
+        <location filename="projectfile.ui" line="60"/>
+        <location filename="projectfile.ui" line="422"/>
+        <location filename="projectfile.ui" line="616"/>
         <source>Browse...</source>
         <translation>Durchsuchen...</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="72"/>
+        <location filename="projectfile.ui" line="76"/>
         <source>Analyze all Visual Studio configurations</source>
         <translation>Alle Visual-Studio-Konfigurationen analysieren</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="86"/>
+        <location filename="projectfile.ui" line="113"/>
+        <source>Selected VS Configurations</source>
+        <translation>Ausgewählte VS-Konfiguration</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="147"/>
         <source>Paths:</source>
         <translation>Pfade:</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="113"/>
-        <location filename="projectfiledialog.ui" line="228"/>
-        <location filename="projectfiledialog.ui" line="461"/>
+        <location filename="projectfile.ui" line="181"/>
+        <location filename="projectfile.ui" line="296"/>
         <source>Add...</source>
         <translation>Hinzufügen...</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="120"/>
-        <location filename="projectfiledialog.ui" line="235"/>
-        <location filename="projectfiledialog.ui" line="468"/>
+        <location filename="projectfile.ui" line="188"/>
+        <location filename="projectfile.ui" line="303"/>
+        <location filename="projectfile.ui" line="690"/>
         <source>Edit</source>
         <translation>Bearbeiten</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="127"/>
-        <location filename="projectfiledialog.ui" line="242"/>
-        <location filename="projectfiledialog.ui" line="475"/>
-        <location filename="projectfiledialog.ui" line="518"/>
+        <location filename="projectfile.ui" line="195"/>
+        <location filename="projectfile.ui" line="310"/>
+        <location filename="projectfile.ui" line="697"/>
+        <location filename="projectfile.ui" line="740"/>
         <source>Remove</source>
         <translation>Entfernen</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="174"/>
+        <location filename="projectfile.ui" line="242"/>
         <source>Undefines:</source>
         <translation>Un-Definitionen:</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="184"/>
+        <location filename="projectfile.ui" line="252"/>
         <source>Undefines must be separated by a semicolon. Example: UNDEF1;UNDEF2;UNDEF3</source>
         <translation>Un-Definitionen müssen Semikolon-getrennt sein. Beispiel: UNDEF1;UNDEF2;UNDEF3</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="197"/>
+        <location filename="projectfile.ui" line="265"/>
         <source>Include Paths:</source>
         <translation>Includepfade:</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="262"/>
+        <location filename="projectfile.ui" line="330"/>
         <source>Up</source>
         <translation>Auf</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="269"/>
+        <location filename="projectfile.ui" line="337"/>
         <source>Down</source>
         <translation>Ab</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="294"/>
-        <source>Checking</source>
-        <translation>Prüfung</translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="319"/>
+        <location filename="projectfile.ui" line="368"/>
         <source>Platform</source>
         <translation>Plattform</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="331"/>
+        <location filename="projectfile.ui" line="403"/>
+        <location filename="projectfile.ui" line="488"/>
         <source>Analysis</source>
         <translation>Analyse</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="337"/>
-        <source>Check code in headers  (slower analysis, more results)</source>
-        <translation>Prüfe Code in Headern (langsamere Analyse, mehr Ergebnisse)</translation>
+        <location filename="projectfile.ui" line="415"/>
+        <source>This is a workfolder that Cppcheck will use for various purposes.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="347"/>
-        <source>Check code in unused templates  (slower and less accurate analysis)</source>
-        <translation>Prüfe Code in ungenutzten Templates (langsamere und weniger genaue Analyse)</translation>
+        <location filename="projectfile.ui" line="448"/>
+        <source>Clang (experimental)</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="356"/>
+        <location filename="projectfile.ui" line="458"/>
+        <source>Check level</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="464"/>
+        <source>Reduced -- meant for usage where developer wants results directly. Limited and faster analysis with fewer results.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="471"/>
+        <source>Normal -- meant for normal analysis in CI. Analysis should finish in reasonable time.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="478"/>
+        <source>Exhaustive -- meant for nightly builds etc. Analysis time can be longer (10x slower than compilation is OK).</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="494"/>
+        <source>If you want to design your classes to be as flexible and robust as possible then the public interface must be very robust. Cppcheck will asumme that arguments can take *any* value.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="529"/>
+        <source>Check code in unused templates (should be ON normally, however in theory you can safely ignore warnings in unused templates)</source>
+        <oldsource>Check code in unused templates  (slower and less accurate analysis)</oldsource>
+        <translation>Prüfe Code in ungenutzten Templates (normalerweise AN, theoretisch können Warnungen in ungenutzten Templates gefahrlos ignoriert werden)</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="541"/>
         <source>Max CTU depth</source>
         <translation>Maximale CTU-Tiefe</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="420"/>
+        <location filename="projectfile.ui" line="572"/>
+        <source>Max recursion in template instantiation</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="607"/>
+        <source>Premium License</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="627"/>
         <source>Warning options</source>
         <translation>Warnoptionen</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="426"/>
+        <location filename="projectfile.ui" line="633"/>
         <source>Root path:</source>
         <translation>Wurzelverzeichnis:</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="438"/>
+        <location filename="projectfile.ui" line="639"/>
+        <source>Filepaths in warnings will be relative to this path</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="649"/>
         <source>Warning tags (separated by semicolon)</source>
         <translation>Warnungs-Tags (Semikolon-getrennt)</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="450"/>
-        <source>Exclude source files in paths</source>
-        <translation>Quelldateien in Pfaden ausschließen</translation>
+        <location filename="projectfile.ui" line="765"/>
+        <source>Enable inline suppressions</source>
+        <translation>Inline-Fehlerunterdrückung aktivieren</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="851"/>
+        <source>2025</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="901"/>
+        <source>Misra C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="909"/>
+        <source>2008</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="937"/>
+        <source>Cert C</source>
+        <translation>Cert C</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="946"/>
+        <source>CERT-INT35-C:  int precision (if size equals precision, you can leave empty)</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="632"/>
+        <location filename="projectfile.ui" line="965"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="972"/>
+        <source>Safety profiles (defined in C++ core guidelines)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="988"/>
+        <source>Bug hunting</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="998"/>
         <source>External tools</source>
         <translation>Externe Werkzeuge</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="300"/>
+        <location filename="projectfile.ui" line="409"/>
         <source>Cppcheck build dir (whole program analysis, incremental analysis, statistics, etc)</source>
         <translation>Cppcheck-Arbeitsverzeichnis (Vollständige Programmanalyse, inkrementelle Analyse, Statistiken, etc.)</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="384"/>
+        <location filename="projectfile.ui" line="362"/>
+        <source>Types and Functions</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="380"/>
         <source>Libraries</source>
         <translation>Bibliotheken</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="500"/>
+        <location filename="projectfile.ui" line="432"/>
+        <source>Parser</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="438"/>
+        <source>Cppcheck (built in)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="497"/>
+        <source>Check that each class has a safe public interface</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="513"/>
+        <source>Limit analysis</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="519"/>
+        <source>Check code in headers  (should be ON normally. if you want a limited quick analysis then turn this OFF)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="655"/>
+        <source>If tags are added, you will be able to right click on warnings and set one of these tags. You can manually categorize warnings.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="665"/>
+        <source>Exclude source files</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="676"/>
+        <source>Exclude folder...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="683"/>
+        <source>Exclude file...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="722"/>
         <source>Suppressions</source>
         <translation>Fehlerunterdrückungen</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="511"/>
+        <location filename="projectfile.ui" line="733"/>
         <source>Add</source>
         <translation>Hinzufügen</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="563"/>
+        <location filename="projectfile.ui" line="786"/>
+        <location filename="projectfile.ui" line="792"/>
         <source>Addons</source>
         <translation>Add-Ons</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="569"/>
+        <location filename="projectfile.ui" line="798"/>
+        <source>Note: Addons require &lt;a href=&quot;https://www.python.org/&quot;&gt;Python&lt;/a&gt; being installed.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="808"/>
         <source>Y2038</source>
         <translation>Y2038</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="576"/>
+        <location filename="projectfile.ui" line="815"/>
         <source>Thread safety</source>
         <translation>Threadsicherheit</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="583"/>
+        <location filename="projectfile.ui" line="825"/>
         <source>Coding standards</source>
         <translation>Programmierstandards</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="590"/>
-        <source>Cert</source>
-        <translation>Cert</translation>
+        <location filename="projectfile.ui" line="833"/>
+        <source>Misra C</source>
+        <translation>Misra C</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="841"/>
+        <source>2012</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="846"/>
+        <location filename="projectfile.ui" line="914"/>
+        <source>2023</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="958"/>
+        <source>Cert C++</source>
+        <translation>Cert C++</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="645"/>
+        <location filename="projectfile.ui" line="982"/>
+        <source>Bug hunting (Premium)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="1011"/>
         <source>Clang analyzer</source>
         <translation>Clang-Analyzer</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="638"/>
+        <location filename="projectfile.ui" line="1004"/>
         <source>Clang-tidy</source>
         <translation>Clang-Tidy</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="153"/>
+        <location filename="projectfile.ui" line="221"/>
         <source>Defines:</source>
         <translation>Definitionen:</translation>
     </message>
@@ -1547,276 +2013,338 @@ Options:
 <context>
     <name>ProjectFileDialog</name>
     <message>
-        <location filename="projectfiledialog.cpp" line="71"/>
+        <location filename="projectfiledialog.cpp" line="138"/>
         <source>Project file: %1</source>
         <translation>Projektdatei: %1</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="409"/>
+        <location filename="projectfiledialog.cpp" line="590"/>
         <source>Select Cppcheck build dir</source>
         <translation>Wähle Cppcheck-Erstellungsverzeichnis</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="637"/>
+        <location filename="projectfiledialog.cpp" line="851"/>
         <source>Select include directory</source>
         <translation>Wähle Include-Verzeichnisse</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="617"/>
+        <location filename="projectfiledialog.cpp" line="831"/>
         <source>Select a directory to check</source>
         <translation>Wähle zu prüfendes Verzeichnis</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="305"/>
-        <source>(no rule texts file)</source>
-        <translation>(keine Regeltexte)</translation>
+        <location filename="projectfiledialog.cpp" line="396"/>
+        <source>Note: Open source Cppcheck does not fully implement Misra C 2012</source>
+        <translation>Hinweis: Open-Source Cppcheck implementiert Misra C 2012 nicht vollständig</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="311"/>
+        <location filename="projectfiledialog.cpp" line="461"/>
         <source>Clang-tidy (not found)</source>
         <translation>Clang-tidy (nicht gefunden)</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="445"/>
+        <location filename="projectfiledialog.cpp" line="629"/>
         <source>Visual Studio</source>
         <translation>Visual Studio</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="446"/>
+        <location filename="projectfiledialog.cpp" line="630"/>
         <source>Compile database</source>
         <translation>Compilerdatenbank</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="447"/>
+        <location filename="projectfiledialog.cpp" line="631"/>
         <source>Borland C++ Builder 6</source>
         <translation>Borland C++-Builder 6</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="448"/>
+        <location filename="projectfiledialog.cpp" line="632"/>
         <source>Import Project</source>
         <translation>Projekt importieren</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="657"/>
+        <location filename="projectfiledialog.cpp" line="871"/>
         <source>Select directory to ignore</source>
         <translation>Wähle zu ignorierendes Verzeichnis</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="742"/>
-        <source>Select MISRA rule texts file</source>
-        <translation>Wähle MISRA-Regeltext-Datei</translation>
+        <location filename="projectfiledialog.cpp" line="879"/>
+        <source>Source files</source>
+        <translation>Quelltext-Dateien</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="742"/>
-        <source>Misra rule texts file (%1)</source>
-        <translation>MISRA-Regeltext-Datei</translation>
+        <location filename="projectfiledialog.cpp" line="880"/>
+        <source>All files</source>
+        <translation>Alle Dateien</translation>
     </message>
-</context>
-<context>
-    <name>QDialogButtonBox</name>
     <message>
-        <location filename="translationhandler.cpp" line="34"/>
-        <source>OK</source>
-        <translation>OK</translation>
+        <location filename="projectfiledialog.cpp" line="881"/>
+        <source>Exclude file</source>
+        <translation>Datei ausschließen</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="35"/>
-        <source>Cancel</source>
-        <translation>Abbrechen</translation>
-    </message>
-    <message>
-        <location filename="translationhandler.cpp" line="36"/>
-        <source>Close</source>
-        <translation>Schließen</translation>
+        <location filename="projectfiledialog.cpp" line="964"/>
+        <source>Select MISRA rule texts file</source>
+        <translation>Wähle MISRA-Regeltext-Datei</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="37"/>
-        <source>Save</source>
-        <translation>Speichern</translation>
+        <location filename="projectfiledialog.cpp" line="966"/>
+        <source>MISRA rule texts file (%1)</source>
+        <translation>MISRA-Regeltext-Datei (%1)</translation>
     </message>
 </context>
 <context>
     <name>QObject</name>
     <message>
-        <location filename="translationhandler.cpp" line="104"/>
+        <location filename="translationhandler.cpp" line="91"/>
         <source>Unknown language specified!</source>
         <translation>Unbekannte Sprache angegeben!</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="132"/>
+        <location filename="translationhandler.cpp" line="117"/>
         <source>Language file %1 not found!</source>
         <translation>Sprachdatei %1 nicht gefunden!</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="138"/>
+        <location filename="translationhandler.cpp" line="122"/>
         <source>Failed to load translation for language %1 from file %2</source>
         <translation>Die Übersetzungen der Sprache %1 konnten nicht aus der Datei %2 geladen werden</translation>
     </message>
     <message>
-        <location filename="cppchecklibrarydata.cpp" line="33"/>
+        <location filename="cppchecklibrarydata.cpp" line="38"/>
         <source>line %1: Unhandled element %2</source>
         <translation>Zeile %1: Nicht behandeltes Element %2</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="226"/>
+        <location filename="cppchecklibrarydata.cpp" line="43"/>
+        <source>line %1: Mandatory attribute &apos;%2&apos; missing in &apos;%3&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="284"/>
         <source> (Not found)</source>
         <translation> (nicht gefunden)</translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="69"/>
+        <location filename="codeeditstylecontrols.cpp" line="76"/>
         <source>Thin</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="71"/>
+        <location filename="codeeditstylecontrols.cpp" line="78"/>
         <source>ExtraLight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="73"/>
+        <location filename="codeeditstylecontrols.cpp" line="80"/>
         <source>Light</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="75"/>
+        <location filename="codeeditstylecontrols.cpp" line="82"/>
         <source>Normal</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="77"/>
+        <location filename="codeeditstylecontrols.cpp" line="84"/>
         <source>Medium</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="79"/>
+        <location filename="codeeditstylecontrols.cpp" line="86"/>
         <source>DemiBold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="81"/>
+        <location filename="codeeditstylecontrols.cpp" line="88"/>
         <source>Bold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="83"/>
+        <location filename="codeeditstylecontrols.cpp" line="90"/>
         <source>ExtraBold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="85"/>
+        <location filename="codeeditstylecontrols.cpp" line="92"/>
         <source>Black</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="69"/>
+        <location filename="codeeditstyledialog.cpp" line="80"/>
         <source>Editor Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="72"/>
+        <location filename="codeeditstyledialog.cpp" line="83"/>
         <source>Editor Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="75"/>
+        <location filename="codeeditstyledialog.cpp" line="86"/>
         <source>Highlight Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="78"/>
+        <location filename="codeeditstyledialog.cpp" line="89"/>
         <source>Line Number Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="81"/>
+        <location filename="codeeditstyledialog.cpp" line="92"/>
         <source>Line Number Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="84"/>
+        <location filename="codeeditstyledialog.cpp" line="95"/>
         <source>Keyword Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="87"/>
+        <location filename="codeeditstyledialog.cpp" line="98"/>
         <source>Keyword Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="90"/>
+        <location filename="codeeditstyledialog.cpp" line="101"/>
         <source>Class Foreground Color</source>
         <translation>Klassen-Vordergrundfarbe</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="93"/>
+        <location filename="codeeditstyledialog.cpp" line="104"/>
         <source>Class Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="96"/>
+        <location filename="codeeditstyledialog.cpp" line="107"/>
         <source>Quote Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="99"/>
+        <location filename="codeeditstyledialog.cpp" line="110"/>
         <source>Quote Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="102"/>
+        <location filename="codeeditstyledialog.cpp" line="113"/>
         <source>Comment Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="105"/>
+        <location filename="codeeditstyledialog.cpp" line="116"/>
         <source>Comment Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="108"/>
+        <location filename="codeeditstyledialog.cpp" line="119"/>
         <source>Symbol Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="111"/>
+        <location filename="codeeditstyledialog.cpp" line="122"/>
         <source>Symbol Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="114"/>
+        <location filename="codeeditstyledialog.cpp" line="125"/>
         <source>Symbol Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="130"/>
+        <location filename="codeeditstyledialog.cpp" line="141"/>
         <source>Set to Default Light</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="132"/>
+        <location filename="codeeditstyledialog.cpp" line="143"/>
         <source>Set to Default Dark</source>
         <translation type="unfinished"></translation>
     </message>
+    <message>
+        <location filename="resultstree.cpp" line="113"/>
+        <source>File</source>
+        <translation type="unfinished">Datei</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="114"/>
+        <source>Line</source>
+        <translation type="unfinished">Zeile</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="115"/>
+        <source>Severity</source>
+        <translation type="unfinished">Schweregrad</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="116"/>
+        <source>Classification</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="117"/>
+        <source>Level</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="118"/>
+        <source>Inconclusive</source>
+        <translation type="unfinished">Unklar</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="119"/>
+        <source>Summary</source>
+        <translation type="unfinished">Zusammenfassung</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="120"/>
+        <source>Id</source>
+        <translation type="unfinished">Id</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="121"/>
+        <source>Guideline</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="122"/>
+        <source>Rule</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="123"/>
+        <source>Since date</source>
+        <translation type="unfinished">Seit Datum</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="124"/>
+        <source>Tags</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="125"/>
+        <source>CWE</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>QPlatformTheme</name>
     <message>
-        <location filename="translationhandler.cpp" line="39"/>
+        <location filename="translationhandler.cpp" line="41"/>
         <source>OK</source>
         <translation>OK</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="40"/>
+        <location filename="translationhandler.cpp" line="42"/>
         <source>Cancel</source>
         <translation>Abbrechen</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="41"/>
+        <location filename="translationhandler.cpp" line="43"/>
         <source>Close</source>
         <translation>Schließen</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="42"/>
+        <location filename="translationhandler.cpp" line="44"/>
         <source>Save</source>
         <translation>Speichern</translation>
     </message>
@@ -1824,109 +2352,108 @@ Options:
 <context>
     <name>ResultsTree</name>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>File</source>
-        <translation>Datei</translation>
+        <translation type="vanished">Datei</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Severity</source>
-        <translation>Schweregrad</translation>
+        <translation type="vanished">Schweregrad</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Line</source>
-        <translation>Zeile</translation>
+        <translation type="vanished">Zeile</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Summary</source>
-        <translation>Zusammenfassung</translation>
+        <translation type="vanished">Zusammenfassung</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="136"/>
         <source>Undefined file</source>
-        <translation>Undefinierte Datei</translation>
+        <translation type="vanished">Undefinierte Datei</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="614"/>
+        <location filename="resultstree.cpp" line="668"/>
         <source>Copy</source>
         <translation>Kopieren</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="797"/>
+        <location filename="resultstree.cpp" line="836"/>
         <source>Could not find file:</source>
         <translation>Kann Datei nicht finden:</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="801"/>
+        <location filename="resultstree.cpp" line="840"/>
         <source>Please select the folder &apos;%1&apos;</source>
         <translation>Bitte wählen Sie den Ordner &apos;%1&apos;</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="802"/>
+        <location filename="resultstree.cpp" line="841"/>
         <source>Select Directory &apos;%1&apos;</source>
         <translation>Wähle Verzeichnis &apos;%1&apos;</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="804"/>
+        <location filename="resultstree.cpp" line="843"/>
         <source>Please select the directory where file is located.</source>
-        <translation>Bitte wählen Sie das Verzeichnis, wo sich die Datei befindet</translation>
+        <translation>Bitte wählen Sie das Verzeichnis, in dem sich die Datei befindet.</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="312"/>
+        <location filename="resultstree.cpp" line="373"/>
         <source>debug</source>
         <translation>Debug</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="249"/>
+        <location filename="resultstree.cpp" line="307"/>
         <source>note</source>
         <translation>Anmerkung</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="613"/>
-        <source>Recheck</source>
-        <translation>Erneut prüfen</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="615"/>
-        <source>Hide</source>
-        <translation>Verstecken</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="616"/>
+        <location filename="resultstree.cpp" line="670"/>
         <source>Hide all with id</source>
         <translation>Verstecke alle mit gleicher ID</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="617"/>
+        <location filename="resultstree.cpp" line="692"/>
         <source>Suppress selected id(s)</source>
         <translation>Ausgewählte ID(s) unterdrücken</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="618"/>
+        <location filename="resultstree.cpp" line="671"/>
         <source>Open containing folder</source>
         <translation>Übergeordneten Ordner öffnen</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="648"/>
-        <location filename="resultstree.cpp" line="1343"/>
+        <location filename="resultstree.cpp" line="376"/>
+        <source>internal</source>
+        <translation>Intern</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="667"/>
+        <source>Recheck %1 file(s)</source>
+        <translation>Erneut %1 Datei(en) prüfen</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="669"/>
+        <source>Hide %1 result(s)</source>
+        <translation>Verstecke %1 Ergebnis(se)</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="712"/>
         <source>Tag</source>
         <translation>Tag</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="650"/>
+        <location filename="resultstree.cpp" line="714"/>
         <source>No tag</source>
         <translation>Kein Tag</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="693"/>
-        <location filename="resultstree.cpp" line="707"/>
+        <location filename="resultstree.cpp" line="744"/>
+        <location filename="resultstree.cpp" line="758"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="694"/>
+        <location filename="resultstree.cpp" line="745"/>
         <source>No editor application configured.
 
 Configure the editor application for Cppcheck in preferences/Applications.</source>
@@ -1935,7 +2462,7 @@ Configure the editor application for Cppcheck in preferences/Applications.</sour
 Konfigurieren Sie diese unter Einstellungen/Anwendungen.</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="708"/>
+        <location filename="resultstree.cpp" line="759"/>
         <source>No default editor application selected.
 
 Please select the default editor application in preferences/Applications.</source>
@@ -1944,12 +2471,12 @@ Please select the default editor application in preferences/Applications.</sourc
  Bitte wählen Sie eine Standardanwendung unter Einstellungen/Anwendungen.</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="737"/>
+        <location filename="resultstree.cpp" line="779"/>
         <source>Could not find the file!</source>
         <translation>Datei konnte nicht gefunden werden!</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="783"/>
+        <location filename="resultstree.cpp" line="822"/>
         <source>Could not start %1
 
 Please check the application path and parameters are correct.</source>
@@ -1958,52 +2485,37 @@ Please check the application path and parameters are correct.</source>
 Bitte überprüfen Sie ob der Pfad und die Parameter der Anwendung richtig eingestellt sind.</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="805"/>
+        <location filename="resultstree.cpp" line="844"/>
         <source>Select Directory</source>
         <translation>Wähle Verzeichnis</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
-        <source>Id</source>
-        <translation>Id</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="1343"/>
-        <source>Inconclusive</source>
-        <translation>Unklar</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="1343"/>
-        <source>Since date</source>
-        <translation>Seit Datum</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="294"/>
+        <location filename="resultstree.cpp" line="355"/>
         <source>style</source>
         <translation>Stil</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="297"/>
+        <location filename="resultstree.cpp" line="358"/>
         <source>error</source>
         <translation>Fehler</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="300"/>
+        <location filename="resultstree.cpp" line="361"/>
         <source>warning</source>
         <translation>Warnung</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="303"/>
+        <location filename="resultstree.cpp" line="364"/>
         <source>performance</source>
         <translation>Performance</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="306"/>
+        <location filename="resultstree.cpp" line="367"/>
         <source>portability</source>
         <translation>Portabilität</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="309"/>
+        <location filename="resultstree.cpp" line="370"/>
         <source>information</source>
         <translation>Information</translation>
     </message>
@@ -2011,82 +2523,102 @@ Bitte überprüfen Sie ob der Pfad und die Parameter der Anwendung richtig einge
 <context>
     <name>ResultsView</name>
     <message>
-        <location filename="resultsview.cpp" line="201"/>
+        <location filename="resultsview.cpp" line="255"/>
         <source>Print Report</source>
         <translation>Bericht drucken</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="220"/>
+        <location filename="resultsview.cpp" line="274"/>
         <source>No errors found, nothing to print.</source>
         <translation>Keine Funde, nichts zu drucken.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="264"/>
+        <location filename="resultsview.cpp" line="326"/>
         <source>%p% (%1 of %2 files checked)</source>
         <translation>%p% (%1 von %2 Dateien geprüft)</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="277"/>
-        <location filename="resultsview.cpp" line="288"/>
+        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="361"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="278"/>
+        <location filename="resultsview.cpp" line="351"/>
         <source>No errors found.</source>
         <translation>Keine Fehler gefunden.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="285"/>
+        <location filename="resultsview.cpp" line="358"/>
         <source>Errors were found, but they are configured to be hidden.
 To toggle what kind of errors are shown, open view menu.</source>
         <translation>Es wurden Fehler gefunden, aber sie sind so konfiguriert, ausgeblendet zu werden.
 Legen Sie unter dem Menü Ansicht fest, welche Arten von Fehlern angezeigt werden sollen.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="331"/>
-        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="421"/>
         <source>Failed to read the report.</source>
         <translation>Lesen des Berichts fehlgeschlagen.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="338"/>
+        <location filename="resultsview.cpp" line="409"/>
         <source>XML format version 1 is no longer supported.</source>
         <translation>XML-Format-Version 1 wird nicht länger unterstützt.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="399"/>
+        <location filename="resultsview.cpp" line="460"/>
         <source>First included by</source>
         <translation>Zuerst inkludiert von</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="465"/>
         <source>Id</source>
         <translation>Id</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="471"/>
+        <location filename="resultsview.cpp" line="539"/>
         <source>Clear Log</source>
         <translation>Protokoll leeren</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="472"/>
+        <location filename="resultsview.cpp" line="540"/>
         <source>Copy this Log entry</source>
         <translation>Diesen Protokolleintrag kopieren</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="473"/>
+        <location filename="resultsview.cpp" line="541"/>
         <source>Copy complete Log</source>
         <translation>Gesamtes Protokoll kopieren</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="159"/>
-        <source>No errors found, nothing to save.</source>
-        <translation>Keine Fehler gefunden, nichts zu speichern.</translation>
+        <location filename="resultsview.cpp" line="549"/>
+        <source>Analysis was stopped</source>
+        <translation>Analyse wurde gestoppt</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="183"/>
-        <location filename="resultsview.cpp" line="191"/>
+        <location filename="resultsview.cpp" line="563"/>
+        <source>There was a critical error with id &apos;%1&apos;</source>
+        <translation>Kritischer Fehler mit ID &apos;%1&apos; aufgetreten</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="565"/>
+        <source>when checking %1</source>
+        <translation>beim Prüfen von %1</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="567"/>
+        <source>when checking a file</source>
+        <translation>beim Prüfen einer Datei</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="568"/>
+        <source>Analysis was aborted.</source>
+        <translation>Analyse abgebrochen.</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="237"/>
+        <location filename="resultsview.cpp" line="245"/>
         <source>Failed to save the report.</source>
         <translation>Der Bericht konnte nicht speichern werden.</translation>
     </message>
@@ -2096,12 +2628,17 @@ Legen Sie unter dem Menü Ansicht fest, welche Arten von Fehlern angezeigt werde
         <translation>Berichte</translation>
     </message>
     <message>
-        <location filename="resultsview.ui" line="82"/>
+        <location filename="resultsview.ui" line="60"/>
+        <source>Critical errors</source>
+        <translation>Kritische Fehler</translation>
+    </message>
+    <message>
+        <location filename="resultsview.ui" line="92"/>
         <source>Analysis Log</source>
         <translation>Analyseprotokoll</translation>
     </message>
     <message>
-        <location filename="resultsview.ui" line="104"/>
+        <location filename="resultsview.ui" line="114"/>
         <source>Warning Details</source>
         <translation>Warnungs-Details</translation>
     </message>
@@ -2121,7 +2658,7 @@ Legen Sie unter dem Menü Ansicht fest, welche Arten von Fehlern angezeigt werde
     <message>
         <location filename="scratchpad.ui" line="37"/>
         <source>Optionally enter a filename (mainly for automatic language detection) and click on &quot;Check&quot;:</source>
-        <translation>Optional einen Dateinamen (hauptsächlich für automatische Spracherkennung) eingeben und auf &quot;Check&quot; klicken:</translation>
+        <translation>Optional einen Dateinamen (hauptsächlich für automatische Spracherkennung) eingeben und auf &quot;Prüfe&quot; klicken:</translation>
     </message>
     <message>
         <location filename="scratchpad.ui" line="71"/>
@@ -2147,7 +2684,7 @@ Legen Sie unter dem Menü Ansicht fest, welche Arten von Fehlern angezeigt werde
         <translation>Allgemein</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="195"/>
+        <location filename="settings.ui" line="196"/>
         <source>Add...</source>
         <translation>Hinzufügen...</translation>
     </message>
@@ -2157,170 +2694,179 @@ Legen Sie unter dem Menü Ansicht fest, welche Arten von Fehlern angezeigt werde
         <translation>Anzahl der Threads: </translation>
     </message>
     <message>
-        <location filename="settings.ui" line="85"/>
         <source>Ideal count:</source>
-        <translation>Ideale Anzahl:</translation>
+        <translation type="vanished">Ideale Anzahl:</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="114"/>
+        <location filename="settings.ui" line="108"/>
         <source>Force checking all #ifdef configurations</source>
         <translation>Erzwinge Prüfung aller #ifdef-Konfigurationen</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="121"/>
+        <location filename="settings.ui" line="115"/>
         <source>Show full path of files</source>
         <translation>Vollständigen Dateipfad anzeigen</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="128"/>
+        <location filename="settings.ui" line="122"/>
         <source>Show &quot;No errors found&quot; message when no errors found</source>
         <translation>&quot;Keine Fehler gefunden&quot;-Meldung anzeigen, wenn keine Fehler gefunden werden</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="135"/>
+        <location filename="settings.ui" line="129"/>
         <source>Display error Id in column &quot;Id&quot;</source>
         <translation>Zeige Meldungs-Id in Spalte &quot;Id&quot;</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="142"/>
+        <location filename="settings.ui" line="136"/>
         <source>Enable inline suppressions</source>
         <translation>Inline-Fehlerunterdrückung aktivieren</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="149"/>
+        <location filename="settings.ui" line="143"/>
         <source>Check for inconclusive errors also</source>
         <translation>Auch nach unklaren Fehlern suchen</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="156"/>
+        <location filename="settings.ui" line="150"/>
         <source>Show statistics on check completion</source>
         <translation>Zeige Statistiken nach Prüfungsabschluss</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="176"/>
+        <location filename="settings.ui" line="157"/>
+        <source>Check for updates</source>
+        <translation>Auf Updates prüfen</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="177"/>
         <source>Show internal warnings in log</source>
         <translation>Interne Warnungen im Log anzeigen</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="287"/>
+        <location filename="settings.ui" line="288"/>
         <source>Addons</source>
         <translation>Add-Ons</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="293"/>
+        <location filename="settings.ui" line="294"/>
         <source>Python binary (leave this empty to use python in the PATH)</source>
         <translation>Python-Binärdatei (Python aus PATH wird genutzt, wenn leer)</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="302"/>
-        <location filename="settings.ui" line="334"/>
-        <location filename="settings.ui" line="379"/>
+        <location filename="settings.ui" line="305"/>
+        <location filename="settings.ui" line="346"/>
+        <location filename="settings.ui" line="391"/>
         <source>...</source>
         <translation>...</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="312"/>
-        <source>Misra addon</source>
+        <location filename="settings.ui" line="324"/>
+        <source>MISRA addon</source>
         <translation>MISRA-Addon</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="320"/>
-        <source>Misra rule texts file</source>
+        <location filename="settings.ui" line="332"/>
+        <source>MISRA rule texts file</source>
         <translation>MISRA-Regeltext-Datei</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="327"/>
+        <location filename="settings.ui" line="339"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Text aus Anhang A &amp;quot;Summary of guidelines&amp;quot; aus der MISRA-C-2012-PDF in eine Textdatei einfügen.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="360"/>
+        <location filename="settings.ui" line="372"/>
         <source>Clang</source>
         <translation>Clang</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="366"/>
+        <location filename="settings.ui" line="378"/>
         <source>Clang path (leave empty to use system PATH)</source>
         <translation>Clang-Verzeichnis (PATH wird genutzt, wenn leer)</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="389"/>
+        <location filename="settings.ui" line="401"/>
         <source>Visual Studio headers</source>
         <translation>Visual-Studio-Header</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="395"/>
+        <location filename="settings.ui" line="407"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Paths to Visual Studio headers, separated by semicolon &apos;;&apos;.&lt;/p&gt;&lt;p&gt;You can open a Visual Studio command prompt, write &amp;quot;SET INCLUDE&amp;quot;. Then copy/paste the paths.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Pfade zu Visual-Studio-Headern, Semikolon-getrennt.&lt;/p&gt;&lt;p&gt;Sie können eine Visual-Studio-Kommandozeile öffnen, &amp;quot;SET INCLUDE&amp;quot; eingeben und dann die Pfade hier reinkopieren.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="425"/>
+        <location filename="settings.ui" line="437"/>
         <source>Code Editor</source>
         <translation>Code-Editor</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="431"/>
+        <location filename="settings.ui" line="443"/>
         <source>Code Editor Style</source>
         <translation>Code-Editor-Stil</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="437"/>
+        <location filename="settings.ui" line="449"/>
         <source>System Style</source>
         <translation>Systemstil</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="444"/>
+        <location filename="settings.ui" line="456"/>
         <source>Default Light Style</source>
         <translation>Heller Standardstil</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="451"/>
+        <location filename="settings.ui" line="463"/>
         <source>Default Dark Style</source>
         <translation>Dunkler Standardstil</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="460"/>
+        <location filename="settings.ui" line="472"/>
         <source>Custom</source>
         <translation>Benutzerdefiniert</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="209"/>
+        <location filename="settings.ui" line="210"/>
         <source>Remove</source>
         <translation>Entfernen</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="184"/>
+        <location filename="settings.ui" line="79"/>
+        <source>Max count:</source>
+        <translation>Maximalzahl:</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="185"/>
         <source>Applications</source>
         <translation>Anwendungen</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="202"/>
-        <location filename="settings.ui" line="467"/>
+        <location filename="settings.ui" line="203"/>
+        <location filename="settings.ui" line="479"/>
         <source>Edit...</source>
         <translation>Bearbeiten...</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="216"/>
+        <location filename="settings.ui" line="217"/>
         <source>Set as default</source>
         <translation>Als Standard festlegen</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="239"/>
+        <location filename="settings.ui" line="240"/>
         <source>Reports</source>
         <translation>Berichte</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="245"/>
+        <location filename="settings.ui" line="246"/>
         <source>Save all errors when creating report</source>
         <translation>Alle Fehler beim Erstellen von Berichten speichern</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="252"/>
+        <location filename="settings.ui" line="253"/>
         <source>Save full path to files in reports</source>
         <translation>Vollständigen Dateipfad in Berichten speichern</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="273"/>
+        <location filename="settings.ui" line="274"/>
         <source>Language</source>
         <translation>Sprache</translation>
     </message>
@@ -2328,42 +2874,46 @@ Legen Sie unter dem Menü Ansicht fest, welche Arten von Fehlern angezeigt werde
 <context>
     <name>SettingsDialog</name>
     <message>
-        <location filename="settingsdialog.cpp" line="100"/>
         <source>N/A</source>
-        <translation>kA</translation>
+        <translation type="vanished">kA</translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="232"/>
+        <source>The executable file &quot;%1&quot; is not available</source>
+        <translation>Die ausführbare Datei &quot;%1&quot; ist nicht verfügbar</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="200"/>
+        <location filename="settingsdialog.cpp" line="243"/>
         <source>Add a new application</source>
         <translation>Neue Anwendung hinzufügen</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="233"/>
+        <location filename="settingsdialog.cpp" line="273"/>
         <source>Modify an application</source>
         <translation>Anwendung ändern</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="238"/>
+        <location filename="settingsdialog.cpp" line="278"/>
         <source> [Default]</source>
         <translation> [Standard]</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="263"/>
+        <location filename="settingsdialog.cpp" line="303"/>
         <source>[Default]</source>
         <translation>[Standard]</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="318"/>
+        <location filename="settingsdialog.cpp" line="358"/>
         <source>Select python binary</source>
         <translation>Python-Binärdatei auswählen</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="325"/>
+        <location filename="settingsdialog.cpp" line="365"/>
         <source>Select MISRA File</source>
         <translation>Wähle MISRA-Datei</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="356"/>
+        <location filename="settingsdialog.cpp" line="396"/>
         <source>Select clang path</source>
         <translation>Clang-Verzeichnis auswählen</translation>
     </message>
@@ -2371,261 +2921,279 @@ Legen Sie unter dem Menü Ansicht fest, welche Arten von Fehlern angezeigt werde
 <context>
     <name>StatsDialog</name>
     <message>
-        <location filename="stats.ui" line="14"/>
-        <location filename="stats.ui" line="248"/>
-        <location filename="statsdialog.cpp" line="137"/>
-        <location filename="statsdialog.cpp" line="184"/>
+        <location filename="statsdialog.ui" line="14"/>
+        <location filename="statsdialog.ui" line="248"/>
+        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="230"/>
         <source>Statistics</source>
         <translation>Statistik</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="27"/>
-        <location filename="statsdialog.cpp" line="175"/>
+        <location filename="statsdialog.ui" line="27"/>
+        <location filename="statsdialog.cpp" line="221"/>
         <source>Project</source>
         <translation>Projekt</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="33"/>
+        <location filename="statsdialog.ui" line="33"/>
         <source>Project:</source>
         <translation>Projekt:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="53"/>
+        <location filename="statsdialog.ui" line="53"/>
         <source>Paths:</source>
         <translation>Pfade:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="85"/>
+        <location filename="statsdialog.ui" line="85"/>
         <source>Include paths:</source>
         <translation>Include-Pfade:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="108"/>
+        <location filename="statsdialog.ui" line="108"/>
         <source>Defines:</source>
         <translation>Definitionen:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="131"/>
+        <location filename="statsdialog.ui" line="131"/>
         <source>Undefines:</source>
         <translation>Un-Definitionen:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="165"/>
-        <location filename="statsdialog.cpp" line="180"/>
+        <location filename="statsdialog.ui" line="165"/>
+        <location filename="statsdialog.cpp" line="226"/>
         <source>Previous Scan</source>
         <translation>Vorherige Prüfung</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="171"/>
+        <location filename="statsdialog.ui" line="171"/>
         <source>Path Selected:</source>
         <translation>Ausgewählte Pfade:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="181"/>
+        <location filename="statsdialog.ui" line="181"/>
         <source>Number of Files Scanned:</source>
         <translation>Anzahl der geprüften Dateien:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="201"/>
+        <location filename="statsdialog.ui" line="201"/>
         <source>Scan Duration:</source>
         <translation>Prüfungsdauer:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="256"/>
+        <location filename="statsdialog.ui" line="254"/>
         <source>Errors:</source>
         <translation>Fehler:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="274"/>
+        <location filename="statsdialog.ui" line="271"/>
         <source>Warnings:</source>
         <translation>Warnungen:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="292"/>
+        <location filename="statsdialog.ui" line="288"/>
         <source>Stylistic warnings:</source>
         <translation>Stilwarnungen:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="310"/>
+        <location filename="statsdialog.ui" line="305"/>
         <source>Portability warnings:</source>
         <translation>Portabilitätswarnungen:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="328"/>
+        <location filename="statsdialog.ui" line="322"/>
         <source>Performance issues:</source>
         <translation>Performance-Probleme:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="346"/>
+        <location filename="statsdialog.ui" line="339"/>
         <source>Information messages:</source>
         <translation>Informationsmeldungen:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="363"/>
+        <location filename="statsdialog.ui" line="356"/>
+        <source>Active checkers:</source>
+        <translation>Aktive Checker:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="374"/>
+        <source>Checkers</source>
+        <translation>Checker</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="399"/>
         <source>History</source>
         <translation>Verlauf</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="369"/>
+        <location filename="statsdialog.ui" line="405"/>
         <source>File:</source>
         <translation>Datei:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="407"/>
+        <location filename="statsdialog.ui" line="443"/>
         <source>Copy to Clipboard</source>
         <translation>In die Zwischenablage kopieren</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="414"/>
+        <location filename="statsdialog.ui" line="450"/>
         <source>Pdf Export</source>
         <translation>PDF-Export</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="113"/>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>1 day</source>
         <translation>1 Tag</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="113"/>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>%1 days</source>
         <translation>%1 Tage</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="115"/>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>1 hour</source>
         <translation>1 Stunde</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="115"/>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>%1 hours</source>
         <translation>%1 Stunden</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="117"/>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>1 minute</source>
         <translation>1 Minute</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="117"/>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>%1 minutes</source>
         <translation>%1 Minuten</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="119"/>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>1 second</source>
         <translation>1 Sekunde</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="119"/>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>%1 seconds</source>
         <translation>%1 Sekunden</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="123"/>
+        <location filename="statsdialog.cpp" line="169"/>
         <source>0.%1 seconds</source>
         <translation>0,%1 Sekunden</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="125"/>
+        <location filename="statsdialog.cpp" line="171"/>
         <source> and </source>
         <translation> und </translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="152"/>
+        <location filename="statsdialog.cpp" line="198"/>
         <source>Export PDF</source>
         <translation>Exportiere PDF</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="174"/>
+        <location filename="statsdialog.cpp" line="220"/>
         <source>Project Settings</source>
         <translation>Projekteinstellungen</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="176"/>
+        <location filename="statsdialog.cpp" line="222"/>
         <source>Paths</source>
         <translation>Pfade</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="177"/>
+        <location filename="statsdialog.cpp" line="223"/>
         <source>Include paths</source>
         <translation>Include-Pfade</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="178"/>
+        <location filename="statsdialog.cpp" line="224"/>
         <source>Defines</source>
         <translation>Definitionen</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="179"/>
+        <location filename="statsdialog.cpp" line="225"/>
         <source>Undefines</source>
         <translation>Un-Definitionen</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="181"/>
+        <location filename="statsdialog.cpp" line="227"/>
         <source>Path selected</source>
         <translation>Gewählte Pfade</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="182"/>
+        <location filename="statsdialog.cpp" line="228"/>
         <source>Number of files scanned</source>
         <translation>Anzahl geprüfter Dateien</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="229"/>
         <source>Scan duration</source>
         <translation>Prüfungsdauer</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="139"/>
         <location filename="statsdialog.cpp" line="185"/>
+        <location filename="statsdialog.cpp" line="231"/>
         <source>Errors</source>
         <translation>Fehler</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="65"/>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>File: </source>
         <translation>Datei: </translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="65"/>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>No cppcheck build dir</source>
         <translation>Kein Cppcheck-Analyseverzeichnis</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="141"/>
-        <location filename="statsdialog.cpp" line="186"/>
+        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="232"/>
         <source>Warnings</source>
         <translation>Warnungen</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="143"/>
-        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="233"/>
         <source>Style warnings</source>
         <translation>Stilwarnungen</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="145"/>
-        <location filename="statsdialog.cpp" line="188"/>
+        <location filename="statsdialog.cpp" line="191"/>
+        <location filename="statsdialog.cpp" line="234"/>
         <source>Portability warnings</source>
         <translation>Portabilitätswarnungen</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="147"/>
-        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="193"/>
+        <location filename="statsdialog.cpp" line="235"/>
         <source>Performance warnings</source>
         <translation>Performance-Warnungen</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="149"/>
-        <location filename="statsdialog.cpp" line="190"/>
+        <location filename="statsdialog.cpp" line="195"/>
+        <location filename="statsdialog.cpp" line="236"/>
         <source>Information messages</source>
         <translation>Informationsmeldungen</translation>
     </message>
 </context>
+<context>
+    <name>ThreadDetails</name>
+    <message>
+        <location filename="threaddetails.ui" line="14"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>ThreadResult</name>
     <message>
-        <location filename="threadresult.cpp" line="54"/>
+        <location filename="threadresult.cpp" line="47"/>
         <source>%1 of %2 files checked</source>
         <translation>%1 von %2 Dateien geprüft</translation>
     </message>
@@ -2633,7 +3201,7 @@ Legen Sie unter dem Menü Ansicht fest, welche Arten von Fehlern angezeigt werde
 <context>
     <name>TranslationHandler</name>
     <message>
-        <location filename="translationhandler.cpp" line="145"/>
+        <location filename="translationhandler.cpp" line="130"/>
         <source>Failed to change the user interface language:
 
 %1
@@ -2646,7 +3214,7 @@ The user interface language has been reset to English. Open the Preferences-dial
 Die Sprache wurde auf Englisch zurückgesetzt. Öffnen Sie den Einstellungen-Dialog um eine verfügbare Sprache auszuwählen.</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="151"/>
+        <location filename="translationhandler.cpp" line="136"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
@@ -2654,7 +3222,7 @@ Die Sprache wurde auf Englisch zurückgesetzt. Öffnen Sie den Einstellungen-Dia
 <context>
     <name>TxtReport</name>
     <message>
-        <location filename="txtreport.cpp" line="73"/>
+        <location filename="txtreport.cpp" line="74"/>
         <source>inconclusive</source>
         <translation>unklar</translation>
     </message>
@@ -2662,12 +3230,12 @@ Die Sprache wurde auf Englisch zurückgesetzt. Öffnen Sie den Einstellungen-Dia
 <context>
     <name>toFilterString</name>
     <message>
-        <location filename="common.cpp" line="52"/>
+        <location filename="common.cpp" line="58"/>
         <source>All supported files (%1)</source>
         <translation>Alle unterstützten Dateien (%1)</translation>
     </message>
     <message>
-        <location filename="common.cpp" line="57"/>
+        <location filename="common.cpp" line="63"/>
         <source>All files (%1)</source>
         <translation>Alle Dateien (%1)</translation>
     </message>
diff --git a/gui/cppcheck_es.ts b/gui/cppcheck_es.ts
index b9773d3028f..927a56e05e5 100644
--- a/gui/cppcheck_es.ts
+++ b/gui/cppcheck_es.ts
@@ -20,8 +20,9 @@
     </message>
     <message>
         <location filename="about.ui" line="81"/>
-        <source>Copyright © 2007-2019 Cppcheck team.</source>
-        <translation>Copyright © 2007-2019 el equipo de cppcheck.</translation>
+        <source>Copyright © 2007-%1 Cppcheck team.</source>
+        <oldsource>Copyright © 2007-2021 Cppcheck team.</oldsource>
+        <translation type="unfinished">Copyright © 2007-2021 el equipo de cppcheck.</translation>
     </message>
     <message>
         <location filename="about.ui" line="91"/>
@@ -36,24 +37,20 @@ of the GNU General Public License version 3</source>
     </message>
     <message>
         <location filename="about.ui" line="115"/>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
-&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul&gt;
-&lt;li&gt;tinyxml2&lt;/li&gt;
-&lt;li&gt;picojson&lt;/li&gt;
-&lt;li&gt;pcre&lt;/li&gt;
-&lt;li&gt;qt&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PCRE&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PicoJSON&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;TinyXML2&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Boost&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <oldsource>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;pcre&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;picojson&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;tinyxml2&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</oldsource>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>ApplicationDialog</name>
     <message>
-        <location filename="application.ui" line="23"/>
+        <location filename="applicationdialog.ui" line="23"/>
         <source>Add an application</source>
         <translation>Añade una aplicación</translation>
     </message>
     <message>
-        <location filename="application.ui" line="41"/>
+        <location filename="applicationdialog.ui" line="41"/>
         <source>Here you can add an application that can open error files. Specify a name for the application, the application executable and command line parameters for the application.
 
 The following texts in parameters are replaced with appropriate values when application is executed:
@@ -68,65 +65,157 @@ Parameters: -l(line) (file)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="application.ui" line="76"/>
+        <location filename="applicationdialog.ui" line="76"/>
         <source>&amp;Name:</source>
         <translation>&amp;Nombre:</translation>
     </message>
     <message>
-        <location filename="application.ui" line="86"/>
+        <location filename="applicationdialog.ui" line="86"/>
         <source>&amp;Executable:</source>
         <translation>&amp;Ejecutable:</translation>
     </message>
     <message>
-        <location filename="application.ui" line="96"/>
+        <location filename="applicationdialog.ui" line="96"/>
         <source>&amp;Parameters:</source>
         <translation>&amp;Parámetros:</translation>
     </message>
     <message>
-        <location filename="application.ui" line="138"/>
+        <location filename="applicationdialog.ui" line="138"/>
         <source>Browse</source>
         <translation>Buscar</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="59"/>
+        <location filename="applicationdialog.cpp" line="65"/>
         <source>Executable files (*.exe);;All files(*.*)</source>
         <translation>Archivos ejecutables (*.exe);;Todos los archivos(*.*)</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="62"/>
+        <location filename="applicationdialog.cpp" line="68"/>
         <source>Select viewer application</source>
         <translation>Selecciona la aplicación para visualizar</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="77"/>
+        <location filename="applicationdialog.cpp" line="83"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="78"/>
+        <location filename="applicationdialog.cpp" line="84"/>
         <source>You must specify a name, a path and optionally parameters for the application!</source>
         <translation>¡Debes especificar el nombre, la ruta y opcionalmente los parámetros para la aplicación!</translation>
     </message>
 </context>
+<context>
+    <name>ComplianceReportDialog</name>
+    <message>
+        <location filename="compliancereportdialog.ui" line="14"/>
+        <source>Compliance Report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="29"/>
+        <source>Project name</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="22"/>
+        <source>Project version</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="42"/>
+        <source>Coding Standard</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="50"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="55"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="60"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="70"/>
+        <source>List of files with md5 checksums</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="133"/>
+        <source>Compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="135"/>
+        <source>HTML files (*.html)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="176"/>
+        <location filename="compliancereportdialog.cpp" line="239"/>
+        <source>Save compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="177"/>
+        <source>Failed to import &apos;%1&apos; (%2), can not show files in compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>FileViewDialog</name>
     <message>
-        <location filename="fileviewdialog.cpp" line="42"/>
+        <location filename="fileviewdialog.cpp" line="53"/>
         <source>Could not find the file: %1</source>
         <translation>No se ha encontrado el fichero: %1</translation>
     </message>
     <message>
-        <location filename="fileviewdialog.cpp" line="46"/>
-        <location filename="fileviewdialog.cpp" line="60"/>
+        <location filename="fileviewdialog.cpp" line="57"/>
+        <location filename="fileviewdialog.cpp" line="71"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="fileviewdialog.cpp" line="56"/>
+        <location filename="fileviewdialog.cpp" line="67"/>
         <source>Could not read the file: %1</source>
         <translation>No se ha podido leer el fichero: %1</translation>
     </message>
 </context>
+<context>
+    <name>HelpDialog</name>
+    <message>
+        <location filename="helpdialog.ui" line="14"/>
+        <source>Cppcheck GUI help</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="34"/>
+        <source>Contents</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="44"/>
+        <source>Index</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="84"/>
+        <source>Helpfile &apos;%1&apos; was not found</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="86"/>
+        <source>Cppcheck</source>
+        <translation type="unfinished">Cppcheck</translation>
+    </message>
+</context>
 <context>
     <name>LibraryAddFunctionDialog</name>
     <message>
@@ -233,42 +322,42 @@ Parameters: -l(line) (file)</source>
         <translation>Editar</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="82"/>
-        <location filename="librarydialog.cpp" line="154"/>
+        <location filename="librarydialog.cpp" line="97"/>
+        <location filename="librarydialog.cpp" line="169"/>
         <source>Library files (*.cfg)</source>
         <translation>Archivos de biblioteca (*.cfg)</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="84"/>
+        <location filename="librarydialog.cpp" line="99"/>
         <source>Open library file</source>
         <translation>Abrir archivo de biblioteca</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="95"/>
-        <location filename="librarydialog.cpp" line="107"/>
-        <location filename="librarydialog.cpp" line="144"/>
+        <location filename="librarydialog.cpp" line="110"/>
+        <location filename="librarydialog.cpp" line="122"/>
+        <location filename="librarydialog.cpp" line="159"/>
         <source>Cppcheck</source>
         <translation type="unfinished">Cppcheck</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="96"/>
+        <location filename="librarydialog.cpp" line="111"/>
         <source>Cannot open file %1.</source>
         <oldsource>Can not open file %1.</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="108"/>
+        <location filename="librarydialog.cpp" line="123"/>
         <source>Failed to load %1. %2.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="145"/>
+        <location filename="librarydialog.cpp" line="160"/>
         <source>Cannot save file %1.</source>
         <oldsource>Can not save file %1.</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="157"/>
+        <location filename="librarydialog.cpp" line="172"/>
         <source>Save the library as</source>
         <translation type="unfinished"></translation>
     </message>
@@ -383,720 +472,732 @@ Parameters: -l(line) (file)</source>
         <translation>Valores válidos</translation>
     </message>
 </context>
-<context>
-    <name>LogView</name>
-    <message>
-        <source>Checking Log</source>
-        <translation type="obsolete">Comprobando el log</translation>
-    </message>
-    <message>
-        <source>Clear</source>
-        <translation type="obsolete">Limpiar</translation>
-    </message>
-    <message>
-        <source>Save Log</source>
-        <translation type="obsolete">Guardar el log</translation>
-    </message>
-    <message>
-        <source>Text files (*.txt *.log);;All files (*.*)</source>
-        <translation type="obsolete">Archivos de texto (*.txt *.log);;Todos los archivos(*.*)</translation>
-    </message>
-    <message>
-        <source>Cppcheck</source>
-        <translation type="obsolete">Cppcheck</translation>
-    </message>
-    <message>
-        <source>Could not open file for writing: &quot;%1&quot;</source>
-        <translation type="obsolete">No se pudo abrir el fichero para escritura: &quot;%1&quot;</translation>
-    </message>
-</context>
 <context>
     <name>MainWindow</name>
     <message>
         <location filename="mainwindow.ui" line="26"/>
-        <location filename="mainwindow.ui" line="595"/>
-        <location filename="mainwindow.cpp" line="328"/>
-        <location filename="mainwindow.cpp" line="480"/>
-        <location filename="mainwindow.cpp" line="553"/>
-        <location filename="mainwindow.cpp" line="658"/>
-        <location filename="mainwindow.cpp" line="680"/>
-        <location filename="mainwindow.cpp" line="1113"/>
-        <location filename="mainwindow.cpp" line="1238"/>
-        <location filename="mainwindow.cpp" line="1359"/>
-        <location filename="mainwindow.cpp" line="1499"/>
-        <location filename="mainwindow.cpp" line="1522"/>
-        <location filename="mainwindow.cpp" line="1593"/>
-        <location filename="mainwindow.cpp" line="1667"/>
+        <location filename="mainwindow.ui" line="688"/>
+        <location filename="mainwindow.cpp" line="466"/>
+        <location filename="mainwindow.cpp" line="670"/>
+        <location filename="mainwindow.cpp" line="755"/>
+        <location filename="mainwindow.cpp" line="860"/>
+        <location filename="mainwindow.cpp" line="882"/>
+        <location filename="mainwindow.cpp" line="1467"/>
+        <location filename="mainwindow.cpp" line="1596"/>
+        <location filename="mainwindow.cpp" line="1937"/>
+        <location filename="mainwindow.cpp" line="1945"/>
+        <location filename="mainwindow.cpp" line="1999"/>
+        <location filename="mainwindow.cpp" line="2008"/>
+        <location filename="mainwindow.cpp" line="2080"/>
+        <location filename="mainwindow.cpp" line="2168"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="70"/>
+        <location filename="mainwindow.ui" line="132"/>
         <source>&amp;File</source>
         <translation>&amp;Archivo</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="89"/>
+        <location filename="mainwindow.ui" line="152"/>
         <source>&amp;View</source>
         <translation>&amp;Ver</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="93"/>
+        <location filename="mainwindow.ui" line="156"/>
         <source>&amp;Toolbars</source>
         <translation>&amp;Herramientas</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="121"/>
+        <location filename="mainwindow.ui" line="199"/>
         <source>&amp;Help</source>
         <translation>&amp;Ayuda</translation>
     </message>
     <message>
-        <source>&amp;Check</source>
-        <translation type="obsolete">&amp;Comprobar</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="135"/>
+        <location filename="mainwindow.ui" line="214"/>
         <source>C++ standard</source>
         <translation>C++ estándar</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="145"/>
+        <location filename="mainwindow.ui" line="226"/>
         <source>&amp;C standard</source>
         <oldsource>C standard</oldsource>
         <translation type="unfinished">C estándar</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="170"/>
+        <location filename="mainwindow.ui" line="254"/>
         <source>&amp;Edit</source>
         <translation>&amp;Editar</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="183"/>
+        <location filename="mainwindow.ui" line="267"/>
         <source>Standard</source>
         <translation>Estándar</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="201"/>
+        <location filename="mainwindow.ui" line="285"/>
         <source>Categories</source>
         <translation>Categorías</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="231"/>
+        <location filename="mainwindow.ui" line="315"/>
         <source>&amp;License...</source>
         <translation>&amp;Licencia...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="236"/>
+        <location filename="mainwindow.ui" line="320"/>
         <source>A&amp;uthors...</source>
         <translation>A&amp;utores...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="245"/>
+        <location filename="mainwindow.ui" line="329"/>
         <source>&amp;About...</source>
         <translation>&amp;Acerca de...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="250"/>
+        <location filename="mainwindow.ui" line="334"/>
         <source>&amp;Files...</source>
         <translation>&amp;Ficheros...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="253"/>
-        <location filename="mainwindow.ui" line="256"/>
+        <location filename="mainwindow.ui" line="337"/>
+        <location filename="mainwindow.ui" line="340"/>
         <source>Analyze files</source>
         <oldsource>Check files</oldsource>
         <translation type="unfinished">Comprobar archivos</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="259"/>
+        <location filename="mainwindow.ui" line="343"/>
         <source>Ctrl+F</source>
         <translation>Ctrl+F</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="268"/>
+        <location filename="mainwindow.ui" line="352"/>
         <source>&amp;Directory...</source>
         <translation>&amp;Carpeta...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="271"/>
-        <location filename="mainwindow.ui" line="274"/>
+        <location filename="mainwindow.ui" line="355"/>
+        <location filename="mainwindow.ui" line="358"/>
         <source>Analyze directory</source>
         <oldsource>Check directory</oldsource>
         <translation type="unfinished">Comprobar carpeta</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="277"/>
+        <location filename="mainwindow.ui" line="361"/>
         <source>Ctrl+D</source>
         <translation>Ctrl+D</translation>
     </message>
     <message>
-        <source>&amp;Recheck files</source>
-        <translation type="obsolete">&amp;Volver a revisar ficheros</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="289"/>
+        <location filename="mainwindow.ui" line="373"/>
         <source>Ctrl+R</source>
         <translation>Ctrl+R</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="307"/>
+        <location filename="mainwindow.ui" line="391"/>
         <source>&amp;Stop</source>
         <translation>&amp;Detener</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="310"/>
-        <location filename="mainwindow.ui" line="313"/>
+        <location filename="mainwindow.ui" line="394"/>
+        <location filename="mainwindow.ui" line="397"/>
         <source>Stop analysis</source>
         <oldsource>Stop checking</oldsource>
         <translation type="unfinished">Detener comprobación</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="316"/>
+        <location filename="mainwindow.ui" line="400"/>
         <source>Esc</source>
         <translation>Esc</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="325"/>
+        <location filename="mainwindow.ui" line="409"/>
         <source>&amp;Save results to file...</source>
         <translation>&amp;Guardar los resultados en el fichero...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="328"/>
+        <location filename="mainwindow.ui" line="412"/>
         <source>Ctrl+S</source>
         <translation>Ctrl+S</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="333"/>
+        <location filename="mainwindow.ui" line="417"/>
         <source>&amp;Quit</source>
         <translation>&amp;Salir</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="342"/>
+        <location filename="mainwindow.ui" line="429"/>
         <source>&amp;Clear results</source>
         <translation>&amp;Limpiar resultados</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="351"/>
+        <location filename="mainwindow.ui" line="438"/>
         <source>&amp;Preferences</source>
         <translation>&amp;Preferencias</translation>
     </message>
     <message>
-        <source>Style warnings</source>
-        <translation type="obsolete">Advertencias de estilo</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="366"/>
-        <location filename="mainwindow.ui" line="369"/>
+        <location filename="mainwindow.ui" line="453"/>
+        <location filename="mainwindow.ui" line="456"/>
         <source>Show style warnings</source>
         <translation>Mostrar advertencias de estilo</translation>
     </message>
     <message>
-        <source>Errors</source>
-        <translation type="obsolete">Errores</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="384"/>
-        <location filename="mainwindow.ui" line="387"/>
+        <location filename="mainwindow.ui" line="471"/>
+        <location filename="mainwindow.ui" line="474"/>
+        <location filename="mainwindow.cpp" line="2394"/>
         <source>Show errors</source>
         <translation>Mostrar errores</translation>
     </message>
     <message>
-        <source>Show S&amp;cratchpad...</source>
-        <translation type="obsolete">Mostrar S&amp;cratchpad...</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="769"/>
-        <location filename="mainwindow.cpp" line="807"/>
+        <location filename="mainwindow.cpp" line="986"/>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Information</source>
         <translation>Información</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="568"/>
+        <location filename="mainwindow.ui" line="661"/>
         <source>Show information messages</source>
         <translation>Mostrar mensajes de información</translation>
     </message>
     <message>
-        <source>Portability</source>
-        <translation type="obsolete">Portabilidad</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="583"/>
+        <location filename="mainwindow.ui" line="676"/>
         <source>Show portability warnings</source>
         <translation>Mostrar advertencias de portabilidad</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="598"/>
+        <location filename="mainwindow.ui" line="691"/>
         <source>Show Cppcheck results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="610"/>
+        <location filename="mainwindow.ui" line="703"/>
         <source>Clang</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="613"/>
+        <location filename="mainwindow.ui" line="706"/>
         <source>Show Clang results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="621"/>
+        <location filename="mainwindow.ui" line="714"/>
         <source>&amp;Filter</source>
         <translation>&amp;Filtro</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="624"/>
+        <location filename="mainwindow.ui" line="717"/>
         <source>Filter results</source>
         <translation>Resultados del filtro</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="640"/>
+        <location filename="mainwindow.ui" line="733"/>
         <source>Windows 32-bit ANSI</source>
         <translation>Windows 32-bit ANSI</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="648"/>
+        <location filename="mainwindow.ui" line="741"/>
         <source>Windows 32-bit Unicode</source>
         <translation>Windows 32-bit Unicode</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="656"/>
+        <location filename="mainwindow.ui" line="749"/>
         <source>Unix 32-bit</source>
         <translation>Unix 32-bit</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="664"/>
+        <location filename="mainwindow.ui" line="757"/>
         <source>Unix 64-bit</source>
         <translation>Unix 64-bit</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="672"/>
+        <location filename="mainwindow.ui" line="765"/>
         <source>Windows 64-bit</source>
         <translation>Windows 64-bit</translation>
     </message>
     <message>
-        <source>Platforms</source>
-        <translation type="obsolete">Plataformas</translation>
-    </message>
-    <message>
-        <source>C++11</source>
-        <translation type="obsolete">C++11</translation>
-    </message>
-    <message>
-        <source>C99</source>
-        <translation type="obsolete">C99</translation>
-    </message>
-    <message>
-        <source>Posix</source>
-        <translation type="obsolete">Posix</translation>
-    </message>
-    <message>
-        <source>C11</source>
-        <translation type="obsolete">C11</translation>
-    </message>
-    <message>
-        <source>C89</source>
-        <translation type="obsolete">C89</translation>
-    </message>
-    <message>
-        <source>C++03</source>
-        <translation type="obsolete">C++03</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="742"/>
+        <location filename="mainwindow.ui" line="859"/>
         <source>&amp;Print...</source>
         <translation>Im&amp;primir...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="745"/>
+        <location filename="mainwindow.ui" line="862"/>
         <source>Print the Current Report</source>
         <translation>Imprimir el informe actual</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="750"/>
+        <location filename="mainwindow.ui" line="867"/>
         <source>Print Pre&amp;view...</source>
         <translation>Pre&amp;visualización de impresión...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="753"/>
+        <location filename="mainwindow.ui" line="870"/>
         <source>Open a Print Preview Dialog for the Current Results</source>
         <translation>Abre el diálogo de previsualización de impresión para el informe actual</translation>
     </message>
     <message>
-        <source>Library Editor...</source>
-        <translation type="obsolete">Editor de bibliotecas...</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="761"/>
+        <location filename="mainwindow.ui" line="878"/>
         <source>Open library editor</source>
         <translation>Abrir el editor de bibliotecas</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="392"/>
+        <location filename="mainwindow.ui" line="479"/>
         <source>&amp;Check all</source>
         <translation>&amp;Seleccionar todo</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="131"/>
+        <location filename="mainwindow.ui" line="84"/>
+        <source>Checking for updates</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="100"/>
+        <source>Hide</source>
+        <translation type="unfinished">Ocultar</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="164"/>
+        <location filename="mainwindow.ui" line="980"/>
+        <source>Report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="210"/>
         <source>A&amp;nalyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="220"/>
+        <location filename="mainwindow.ui" line="304"/>
         <source>Filter</source>
         <translation>Filtro</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="286"/>
+        <location filename="mainwindow.ui" line="370"/>
         <source>&amp;Reanalyze modified files</source>
         <oldsource>&amp;Recheck modified files</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="298"/>
+        <location filename="mainwindow.ui" line="382"/>
         <source>Reanal&amp;yze all files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="363"/>
+        <location filename="mainwindow.ui" line="420"/>
+        <source>Ctrl+Q</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="450"/>
         <source>Style war&amp;nings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="381"/>
+        <location filename="mainwindow.ui" line="468"/>
         <source>E&amp;rrors</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="397"/>
+        <location filename="mainwindow.ui" line="484"/>
         <source>&amp;Uncheck all</source>
         <translation>&amp;Deseleccionar todo</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="402"/>
+        <location filename="mainwindow.ui" line="489"/>
         <source>Collapse &amp;all</source>
         <translation>Contraer &amp;todo</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="407"/>
+        <location filename="mainwindow.ui" line="494"/>
         <source>&amp;Expand all</source>
         <translation>&amp;Expandir todo</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="415"/>
+        <location filename="mainwindow.ui" line="502"/>
         <source>&amp;Standard</source>
         <translation>&amp;Estándar</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="418"/>
+        <location filename="mainwindow.ui" line="505"/>
         <source>Standard items</source>
         <translation>Elementos estándar</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="423"/>
+        <location filename="mainwindow.ui" line="510"/>
         <source>&amp;Contents</source>
         <translation>&amp;Contenidos</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="426"/>
+        <location filename="mainwindow.ui" line="513"/>
         <source>Open the help contents</source>
         <translation>Abrir la ayuda de contenidos</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="429"/>
+        <location filename="mainwindow.ui" line="516"/>
         <source>F1</source>
         <translation>F1</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="434"/>
+        <location filename="mainwindow.ui" line="521"/>
         <source>Toolbar</source>
         <translation>Barra de herramientas</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="442"/>
+        <location filename="mainwindow.ui" line="529"/>
         <source>&amp;Categories</source>
         <translation>&amp;Categorías</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="445"/>
+        <location filename="mainwindow.ui" line="532"/>
         <source>Error categories</source>
         <translation>Categorías de error</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="450"/>
+        <location filename="mainwindow.ui" line="537"/>
         <source>&amp;Open XML...</source>
         <translation>&amp;Abrir XML...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="459"/>
+        <location filename="mainwindow.ui" line="546"/>
         <source>Open P&amp;roject File...</source>
         <translation>Abrir P&amp;royecto...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="468"/>
+        <location filename="mainwindow.ui" line="549"/>
+        <source>Ctrl+Shift+O</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="558"/>
         <source>Sh&amp;ow Scratchpad...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="473"/>
+        <location filename="mainwindow.ui" line="563"/>
         <source>&amp;New Project File...</source>
         <translation>&amp;Nuevo Proyecto...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="478"/>
+        <location filename="mainwindow.ui" line="566"/>
+        <source>Ctrl+Shift+N</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="571"/>
         <source>&amp;Log View</source>
         <translation>&amp;Visor del log</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="481"/>
+        <location filename="mainwindow.ui" line="574"/>
         <source>Log View</source>
         <translation>Visor del log</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="489"/>
+        <location filename="mainwindow.ui" line="582"/>
         <source>C&amp;lose Project File</source>
         <translation>C&amp;errar Proyecto</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="497"/>
+        <location filename="mainwindow.ui" line="590"/>
         <source>&amp;Edit Project File...</source>
         <translation>&amp;Editar Proyecto...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="509"/>
+        <location filename="mainwindow.ui" line="602"/>
         <source>&amp;Statistics</source>
         <translation>&amp;Estadísticas</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="521"/>
+        <location filename="mainwindow.ui" line="614"/>
         <source>&amp;Warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="539"/>
+        <location filename="mainwindow.ui" line="632"/>
         <source>Per&amp;formance warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="565"/>
+        <location filename="mainwindow.ui" line="658"/>
         <source>&amp;Information</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="580"/>
+        <location filename="mainwindow.ui" line="673"/>
         <source>&amp;Portability</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="680"/>
+        <location filename="mainwindow.ui" line="773"/>
         <source>P&amp;latforms</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="694"/>
+        <location filename="mainwindow.ui" line="787"/>
         <source>C++&amp;11</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="705"/>
+        <location filename="mainwindow.ui" line="798"/>
         <source>C&amp;99</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="713"/>
+        <location filename="mainwindow.ui" line="806"/>
         <source>&amp;Posix</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="721"/>
+        <location filename="mainwindow.ui" line="814"/>
         <source>C&amp;11</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="729"/>
+        <location filename="mainwindow.ui" line="846"/>
         <source>&amp;C89</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="737"/>
+        <location filename="mainwindow.ui" line="854"/>
         <source>&amp;C++03</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="758"/>
+        <location filename="mainwindow.ui" line="875"/>
         <source>&amp;Library Editor...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="769"/>
+        <location filename="mainwindow.ui" line="886"/>
         <source>&amp;Auto-detect language</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="777"/>
+        <location filename="mainwindow.ui" line="894"/>
         <source>&amp;Enforce C++</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="785"/>
+        <location filename="mainwindow.ui" line="902"/>
         <source>E&amp;nforce C</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="796"/>
+        <location filename="mainwindow.ui" line="913"/>
         <source>C++14</source>
         <translation type="unfinished">C++14</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="804"/>
+        <location filename="mainwindow.ui" line="921"/>
         <source>Reanalyze and check library</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="812"/>
+        <location filename="mainwindow.ui" line="929"/>
         <source>Check configuration (defines, includes)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="820"/>
+        <location filename="mainwindow.ui" line="937"/>
         <source>C++17</source>
         <translation type="unfinished">C++17</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="831"/>
+        <location filename="mainwindow.ui" line="948"/>
         <source>C++20</source>
         <translation type="unfinished">C++20</translation>
     </message>
     <message>
-        <source>Warnings</source>
-        <translation type="obsolete">Advertencias</translation>
+        <location filename="mainwindow.ui" line="975"/>
+        <source>Compliance report...</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="524"/>
-        <location filename="mainwindow.ui" line="527"/>
-        <source>Show warnings</source>
-        <translation>Mostrar advertencias</translation>
+        <location filename="mainwindow.ui" line="988"/>
+        <source>Normal</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Performance warnings</source>
-        <translation type="obsolete">Advertencias de rendimiento</translation>
+        <location filename="mainwindow.ui" line="996"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1004"/>
+        <source>Misra C++ 2008</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1012"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1020"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1028"/>
+        <source>Misra C++ 2023</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1036"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1041"/>
+        <source>EULA...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1046"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="542"/>
-        <location filename="mainwindow.ui" line="545"/>
+        <location filename="mainwindow.ui" line="1049"/>
+        <source>Show thread details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="617"/>
+        <location filename="mainwindow.ui" line="620"/>
+        <location filename="mainwindow.cpp" line="2395"/>
+        <source>Show warnings</source>
+        <translation>Mostrar advertencias</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="635"/>
+        <location filename="mainwindow.ui" line="638"/>
         <source>Show performance warnings</source>
         <translation>Mostrar advertencias de rendimiento</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="553"/>
+        <location filename="mainwindow.ui" line="646"/>
         <source>Show &amp;hidden</source>
         <translation>Mostrar &amp;ocultos</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="323"/>
+        <location filename="mainwindow.cpp" line="461"/>
         <source>There was a problem with loading the editor application settings.
 
 This is probably because the settings were changed between the Cppcheck versions. Please check (and fix) the editor application settings, otherwise the editor program might not start correctly.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>No suitable files found to check!</source>
-        <translation type="obsolete">¡No se han encontrado ficheros para comprobar!</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="554"/>
+        <location filename="mainwindow.cpp" line="756"/>
         <source>You must close the project file before selecting new files or directories!</source>
         <translation>¡Tienes que cerrar el proyecto antes de seleccionar nuevos ficheros o carpetas!</translation>
     </message>
     <message>
-        <source>Select directory to check</source>
-        <translation type="obsolete">Selecciona una carpeta para comprobar</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="629"/>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select configuration</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="778"/>
+        <location filename="mainwindow.cpp" line="995"/>
         <source>File not found</source>
         <translation>Archivo no encontrado</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="781"/>
+        <location filename="mainwindow.cpp" line="998"/>
         <source>Bad XML</source>
         <translation type="unfinished">XML malformado</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="784"/>
+        <location filename="mainwindow.cpp" line="1001"/>
         <source>Missing attribute</source>
         <translation type="unfinished">Falta el atributo</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="787"/>
+        <location filename="mainwindow.cpp" line="1004"/>
         <source>Bad attribute value</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="790"/>
+        <location filename="mainwindow.cpp" line="1007"/>
         <source>Unsupported format</source>
         <translation>Formato no soportado</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="807"/>
+        <location filename="mainwindow.cpp" line="1016"/>
+        <source>Duplicate define</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Failed to load the selected library &apos;%1&apos;.
 %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1129"/>
-        <location filename="mainwindow.cpp" line="1309"/>
-        <source>XML files (*.xml)</source>
-        <translation>Archivos XML (*.xml)</translation>
+        <location filename="mainwindow.cpp" line="1035"/>
+        <source>File not found: &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1131"/>
-        <source>Open the report file</source>
-        <translation>Abrir informe</translation>
+        <location filename="mainwindow.cpp" line="1058"/>
+        <source>Failed to load/setup addon %1: %2</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Checking is running.
+        <location filename="mainwindow.cpp" line="1081"/>
+        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.
 
-Do you want to stop the checking and exit Cppcheck?</source>
-        <translation type="obsolete">El proceso de comprobación está en curso.
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <source>Failed to load %1 - %2
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
+        <source>%1
 
-¿Quieres parar la comprobación y salir del Cppcheck?</translation>
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1280"/>
+        <location filename="mainwindow.cpp" line="1483"/>
+        <location filename="mainwindow.cpp" line="1682"/>
+        <source>XML files (*.xml)</source>
+        <translation>Archivos XML (*.xml)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1485"/>
+        <source>Open the report file</source>
+        <translation>Abrir informe</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1648"/>
         <source>License</source>
         <translation>Licencia</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1287"/>
+        <location filename="mainwindow.cpp" line="1655"/>
         <source>Authors</source>
         <translation>Autores</translation>
     </message>
     <message>
-        <source>XML files version 2 (*.xml);;XML files version 1 (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
-        <translation type="obsolete">Archivos XML versión 2 (*.xml);;Archivos XML versión 1 (*.xml);;Archivos de texto (*.txt);;Archivos CSV (*.csv)</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1302"/>
+        <location filename="mainwindow.cpp" line="1675"/>
         <source>Save the report file</source>
         <translation>Guardar informe</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="87"/>
+        <location filename="mainwindow.cpp" line="157"/>
+        <location filename="mainwindow.cpp" line="1782"/>
         <source>Quick Filter:</source>
         <translation>Filtro rápido:</translation>
     </message>
     <message>
-        <source>Select files to check</source>
-        <translation type="obsolete">Selecciona los archivos a comprobar</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="659"/>
+        <location filename="mainwindow.cpp" line="861"/>
         <source>Found project file: %1
 
 Do you want to load this project file instead?</source>
@@ -1105,147 +1206,118 @@ Do you want to load this project file instead?</source>
 ¿Quiere cargar este fichero de proyecto en su lugar?</translation>
     </message>
     <message>
-        <source>Found project files from the directory.
-
-Do you want to proceed checking without using any of these project files?</source>
-        <translation type="obsolete">Se encontraron ficheros de proyecto en el directorio.
-
-¿Quiere proceder a comprobar sin utilizar ninguno de estos ficheros de proyecto?</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="769"/>
+        <location filename="mainwindow.cpp" line="986"/>
         <source>The library &apos;%1&apos; contains unknown elements:
 %2</source>
         <translation>La biblioteca &apos;%1&apos; contiene elementos deconocidos:
 %2</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="793"/>
+        <location filename="mainwindow.cpp" line="1010"/>
         <source>Duplicate platform type</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="796"/>
+        <location filename="mainwindow.cpp" line="1013"/>
         <source>Platform type redefined</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="799"/>
+        <location filename="mainwindow.cpp" line="1019"/>
         <source>Unknown element</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="802"/>
-        <source>Unknown issue</source>
+        <location filename="mainwindow.cpp" line="1019"/>
+        <source>Unknown element</source>
+        <oldsource>Unknown issue</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="828"/>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
         <source>Error</source>
         <translation>Error</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="828"/>
-        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <source>Current results will be cleared.
-
-Opening a new XML file will clear current results.Do you want to proceed?</source>
-        <translation type="vanished">Los resultados actuales serán eliminados.
-
-Abrir un nuevo fichero XML eliminará los resultados actuales. ¿Desea continuar?</translation>
-    </message>
-    <message>
-        <source>XML files version 1 (*.xml)</source>
-        <translation type="obsolete">Archivos XML versión 1 (*.xml)</translation>
-    </message>
-    <message>
-        <source>XML files version 2 (*.xml)</source>
-        <translation type="obsolete">Archivos XML versión 2 (*.xml)</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1313"/>
+        <location filename="mainwindow.cpp" line="1686"/>
         <source>Text files (*.txt)</source>
         <translation>Ficheros de texto (*.txt)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1317"/>
+        <location filename="mainwindow.cpp" line="1690"/>
         <source>CSV files (*.csv)</source>
         <translation>Ficheros CVS (*.cvs)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1361"/>
-        <source>Cppcheck - %1</source>
-        <translation>Cppcheck - %1</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1407"/>
+        <location filename="mainwindow.cpp" line="1820"/>
         <source>Project files (*.cppcheck);;All files(*.*)</source>
         <translation>Ficheros de proyecto (*.cppcheck;;Todos los ficheros (*.*)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1409"/>
+        <location filename="mainwindow.cpp" line="1822"/>
         <source>Select Project File</source>
         <translation>Selecciona el archivo de proyecto</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="159"/>
-        <location filename="mainwindow.cpp" line="1437"/>
-        <location filename="mainwindow.cpp" line="1562"/>
+        <location filename="mainwindow.cpp" line="242"/>
+        <location filename="mainwindow.cpp" line="1784"/>
+        <location filename="mainwindow.cpp" line="1850"/>
+        <location filename="mainwindow.cpp" line="2048"/>
         <source>Project:</source>
         <translation>Proyecto:</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="481"/>
+        <location filename="mainwindow.cpp" line="671"/>
         <source>No suitable files found to analyze!</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="568"/>
+        <location filename="mainwindow.cpp" line="770"/>
         <source>C/C++ Source</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="569"/>
+        <location filename="mainwindow.cpp" line="771"/>
         <source>Compile database</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="570"/>
+        <location filename="mainwindow.cpp" line="772"/>
         <source>Visual Studio</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="571"/>
+        <location filename="mainwindow.cpp" line="773"/>
         <source>Borland C++ Builder 6</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="574"/>
+        <location filename="mainwindow.cpp" line="776"/>
         <source>Select files to analyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="589"/>
+        <location filename="mainwindow.cpp" line="791"/>
         <source>Select directory to analyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="629"/>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select the configuration that will be analyzed</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="681"/>
+        <location filename="mainwindow.cpp" line="883"/>
         <source>Found project files from the directory.
 
 Do you want to proceed analysis without using any of these project files?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1114"/>
+        <location filename="mainwindow.cpp" line="1468"/>
         <source>Current results will be cleared.
 
 Opening a new XML file will clear current results.
@@ -1253,44 +1325,81 @@ Do you want to proceed?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1234"/>
+        <location filename="mainwindow.cpp" line="1592"/>
         <source>Analyzer is running.
 
 Do you want to stop the analysis and exit Cppcheck?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1300"/>
+        <location filename="mainwindow.cpp" line="1634"/>
+        <source>About</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1673"/>
         <source>XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1500"/>
+        <location filename="mainwindow.cpp" line="1713"/>
+        <source>Cannot generate a compliance report right now, an analysis must finish successfully. Try to reanalyze the code and ensure there are no critical errors.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1938"/>
         <source>Build dir &apos;%1&apos; does not exist, create it?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1523"/>
-        <source>Failed to import &apos;%1&apos;, analysis is stopped</source>
+        <location filename="mainwindow.cpp" line="1946"/>
+        <source>To check the project using addons, you need a build directory.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1547"/>
+        <location filename="mainwindow.cpp" line="1978"/>
+        <source>Failed to open file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1981"/>
+        <source>Unknown project file format</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1984"/>
+        <source>Failed to import project file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2000"/>
+        <source>Failed to import &apos;%1&apos;: %2
+
+Analysis is stopped.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2009"/>
+        <source>Failed to import &apos;%1&apos; (%2), analysis is stopped</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2033"/>
         <source>Project files (*.cppcheck)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1549"/>
+        <location filename="mainwindow.cpp" line="2035"/>
         <source>Select Project Filename</source>
         <translation>Selecciona el nombre del proyecto</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1594"/>
+        <location filename="mainwindow.cpp" line="2081"/>
         <source>No project file loaded</source>
         <translation>No hay ningún proyecto cargado</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1662"/>
+        <location filename="mainwindow.cpp" line="2163"/>
         <source>The project file
 
 %1
@@ -1307,7 +1416,72 @@ Do you want to remove the file from the recently used projects -list?</source>
 ¿Quiere eliminar el fichero de la lista de proyectos recientes?</translation>
     </message>
     <message>
-        <location filename="main.cpp" line="106"/>
+        <location filename="mainwindow.cpp" line="2325"/>
+        <source>Install</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2329"/>
+        <source>New version available: %1. %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2367"/>
+        <source>Show Mandatory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2368"/>
+        <source>Show Required</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2369"/>
+        <source>Show Advisory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2370"/>
+        <source>Show Document</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2387"/>
+        <source>Show L1</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2388"/>
+        <source>Show L2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2389"/>
+        <source>Show L3</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2396"/>
+        <source>Show style</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2397"/>
+        <source>Show portability</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2398"/>
+        <source>Show performance</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2399"/>
+        <source>Show information</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="main.cpp" line="100"/>
         <source>Cppcheck GUI.
 
 Syntax:
@@ -1337,7 +1511,7 @@ Options:
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="main.cpp" line="121"/>
+        <location filename="main.cpp" line="115"/>
         <source>Cppcheck GUI - Command line parameters</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1370,7 +1544,7 @@ Options:
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="newsuppressiondialog.cpp" line="52"/>
+        <location filename="newsuppressiondialog.cpp" line="83"/>
         <source>Edit suppression</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1378,318 +1552,424 @@ Options:
 <context>
     <name>Platforms</name>
     <message>
-        <source>Built-in</source>
-        <translation type="obsolete">Built-in</translation>
-    </message>
-    <message>
-        <location filename="platforms.cpp" line="37"/>
+        <location filename="platforms.cpp" line="38"/>
         <source>Native</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="38"/>
+        <location filename="platforms.cpp" line="39"/>
         <source>Unix 32-bit</source>
         <translation>Unix 32-bit</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="39"/>
+        <location filename="platforms.cpp" line="40"/>
         <source>Unix 64-bit</source>
         <translation>Unix 64-bit</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="40"/>
+        <location filename="platforms.cpp" line="41"/>
         <source>Windows 32-bit ANSI</source>
         <translation>Windows 32-bit ANSI</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="41"/>
+        <location filename="platforms.cpp" line="42"/>
         <source>Windows 32-bit Unicode</source>
         <translation>Windows 32-bit Unicode</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="42"/>
+        <location filename="platforms.cpp" line="43"/>
         <source>Windows 64-bit</source>
         <translation>Windows 64-bit</translation>
     </message>
 </context>
 <context>
-    <name>Project</name>
+    <name>ProjectFile</name>
     <message>
-        <source>Cppcheck</source>
-        <translation type="obsolete">Cppcheck</translation>
+        <location filename="projectfile.ui" line="14"/>
+        <source>Project File</source>
+        <translation>Archivo de proyecto</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="24"/>
+        <source>Paths and Defines</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="30"/>
+        <source>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</source>
+        <oldsource>Import Project (Visual studio / compile database)</oldsource>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="231"/>
+        <source>Defines must be separated by a semicolon. Example: DEF1;DEF2=5;DEF3=int</source>
+        <oldsource>Defines must be separated by a semicolon &apos;;&apos;</oldsource>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="389"/>
+        <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
+        <translation>Nota: Ponga sus propios archivos .cfg en la misma carpeta que el proyecto. Debería verlos arriba.</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="655"/>
+        <source>If tags are added, you will be able to right click on warnings and set one of these tags. You can manually categorize warnings.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="665"/>
+        <source>Exclude source files</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="676"/>
+        <source>Exclude folder...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="683"/>
+        <source>Exclude file...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="833"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="841"/>
+        <source>2012</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="846"/>
+        <location filename="projectfile.ui" line="914"/>
+        <source>2023</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="876"/>
+        <source>MISRA rule texts</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="883"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="890"/>
+        <source>...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="73"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;You have a choice:&lt;/p&gt;&lt;p&gt; * Analyze all Debug and Release configurations&lt;/p&gt;&lt;p&gt; * Only analyze the first matching Debug configuration&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="60"/>
+        <location filename="projectfile.ui" line="422"/>
+        <location filename="projectfile.ui" line="616"/>
+        <source>Browse...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="76"/>
+        <source>Analyze all Visual Studio configurations</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="113"/>
+        <source>Selected VS Configurations</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="147"/>
+        <source>Paths:</source>
+        <translation>Rutas:</translation>
     </message>
     <message>
-        <source>Could not read the project file.</source>
-        <translation type="obsolete">No se ha podido leer el fichero.</translation>
+        <location filename="projectfile.ui" line="181"/>
+        <location filename="projectfile.ui" line="296"/>
+        <source>Add...</source>
+        <translation>Añadir...</translation>
     </message>
     <message>
-        <source>Could not write the project file.</source>
-        <translation type="obsolete">No se ha podido escribir el fichero de proyecto.</translation>
+        <location filename="projectfile.ui" line="188"/>
+        <location filename="projectfile.ui" line="303"/>
+        <location filename="projectfile.ui" line="690"/>
+        <source>Edit</source>
+        <translation>Editar</translation>
     </message>
-</context>
-<context>
-    <name>ProjectFile</name>
     <message>
-        <location filename="projectfiledialog.ui" line="14"/>
-        <source>Project File</source>
-        <translation>Archivo de proyecto</translation>
+        <location filename="projectfile.ui" line="195"/>
+        <location filename="projectfile.ui" line="310"/>
+        <location filename="projectfile.ui" line="697"/>
+        <location filename="projectfile.ui" line="740"/>
+        <source>Remove</source>
+        <translation>Eliminar</translation>
     </message>
     <message>
-        <source>Project</source>
-        <translation type="obsolete">Proyecto</translation>
+        <location filename="projectfile.ui" line="242"/>
+        <source>Undefines:</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="24"/>
-        <source>Paths and Defines</source>
+        <location filename="projectfile.ui" line="252"/>
+        <source>Undefines must be separated by a semicolon. Example: UNDEF1;UNDEF2;UNDEF3</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="30"/>
-        <source>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</source>
-        <oldsource>Import Project (Visual studio / compile database)</oldsource>
+        <location filename="projectfile.ui" line="265"/>
+        <source>Include Paths:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="163"/>
-        <source>Defines must be separated by a semicolon. Example: DEF1;DEF2=5;DEF3=int</source>
-        <oldsource>Defines must be separated by a semicolon &apos;;&apos;</oldsource>
+        <location filename="projectfile.ui" line="362"/>
+        <source>Types and Functions</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>&amp;Root:</source>
-        <oldsource>Root:</oldsource>
-        <translation type="obsolete">Raíz:</translation>
+        <location filename="projectfile.ui" line="403"/>
+        <location filename="projectfile.ui" line="488"/>
+        <source>Analysis</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Libraries:</source>
-        <translation type="obsolete">Bibliotecas:</translation>
+        <location filename="projectfile.ui" line="415"/>
+        <source>This is a workfolder that Cppcheck will use for various purposes.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="393"/>
-        <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
-        <translation>Nota: Ponga sus propios archivos .cfg en la misma carpeta que el proyecto. Debería verlos arriba.</translation>
+        <location filename="projectfile.ui" line="432"/>
+        <source>Parser</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="597"/>
-        <source>MISRA C 2012</source>
+        <location filename="projectfile.ui" line="438"/>
+        <source>Cppcheck (built in)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="606"/>
-        <source>Misra rule texts</source>
+        <location filename="projectfile.ui" line="458"/>
+        <source>Check level</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="613"/>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <location filename="projectfile.ui" line="464"/>
+        <source>Reduced -- meant for usage where developer wants results directly. Limited and faster analysis with fewer results.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="620"/>
-        <source>...</source>
+        <location filename="projectfile.ui" line="471"/>
+        <source>Normal -- meant for normal analysis in CI. Analysis should finish in reasonable time.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="69"/>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;You have a choice:&lt;/p&gt;&lt;p&gt; * Analyze all Debug and Release configurations&lt;/p&gt;&lt;p&gt; * Only analyze the first matching Debug configuration&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <location filename="projectfile.ui" line="478"/>
+        <source>Exhaustive -- meant for nightly builds etc. Analysis time can be longer (10x slower than compilation is OK).</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="60"/>
-        <location filename="projectfiledialog.ui" line="309"/>
-        <source>Browse...</source>
+        <location filename="projectfile.ui" line="497"/>
+        <source>Check that each class has a safe public interface</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="72"/>
-        <source>Analyze all Visual Studio configurations</source>
+        <location filename="projectfile.ui" line="513"/>
+        <source>Limit analysis</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="86"/>
-        <source>Paths:</source>
-        <translation>Rutas:</translation>
+        <location filename="projectfile.ui" line="529"/>
+        <source>Check code in unused templates (should be ON normally, however in theory you can safely ignore warnings in unused templates)</source>
+        <oldsource>Check code in unused templates  (slower and less accurate analysis)</oldsource>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="113"/>
-        <location filename="projectfiledialog.ui" line="228"/>
-        <location filename="projectfiledialog.ui" line="461"/>
-        <source>Add...</source>
-        <translation>Añadir...</translation>
+        <location filename="projectfile.ui" line="541"/>
+        <source>Max CTU depth</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="120"/>
-        <location filename="projectfiledialog.ui" line="235"/>
-        <location filename="projectfiledialog.ui" line="468"/>
-        <source>Edit</source>
-        <translation>Editar</translation>
+        <location filename="projectfile.ui" line="607"/>
+        <source>Premium License</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="127"/>
-        <location filename="projectfiledialog.ui" line="242"/>
-        <location filename="projectfiledialog.ui" line="475"/>
-        <location filename="projectfiledialog.ui" line="518"/>
-        <source>Remove</source>
-        <translation>Eliminar</translation>
+        <location filename="projectfile.ui" line="765"/>
+        <source>Enable inline suppressions</source>
+        <translation type="unfinished">Habilitar supresiones inline</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="174"/>
-        <source>Undefines:</source>
+        <location filename="projectfile.ui" line="851"/>
+        <source>2025</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="184"/>
-        <source>Undefines must be separated by a semicolon. Example: UNDEF1;UNDEF2;UNDEF3</source>
+        <location filename="projectfile.ui" line="901"/>
+        <source>Misra C++</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="197"/>
-        <source>Include Paths:</source>
+        <location filename="projectfile.ui" line="909"/>
+        <source>2008</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="331"/>
-        <source>Analysis</source>
+        <location filename="projectfile.ui" line="937"/>
+        <source>Cert C</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="337"/>
-        <source>Check code in headers  (slower analysis, more results)</source>
+        <location filename="projectfile.ui" line="946"/>
+        <source>CERT-INT35-C:  int precision (if size equals precision, you can leave empty)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="347"/>
-        <source>Check code in unused templates  (slower and less accurate analysis)</source>
+        <location filename="projectfile.ui" line="965"/>
+        <source>Autosar</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="356"/>
-        <source>Max CTU depth</source>
+        <location filename="projectfile.ui" line="972"/>
+        <source>Safety profiles (defined in C++ core guidelines)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="450"/>
-        <source>Exclude source files in paths</source>
+        <location filename="projectfile.ui" line="988"/>
+        <source>Bug hunting</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="632"/>
+        <location filename="projectfile.ui" line="998"/>
         <source>External tools</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Includes</source>
-        <translation type="obsolete">Incluir</translation>
-    </message>
-    <message>
-        <source>Include directories:</source>
-        <translation type="obsolete">Incluir los directorios:</translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="262"/>
+        <location filename="projectfile.ui" line="330"/>
         <source>Up</source>
         <translation>Subir</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="269"/>
+        <location filename="projectfile.ui" line="337"/>
         <source>Down</source>
         <translation>Bajar</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="294"/>
-        <source>Checking</source>
+        <location filename="projectfile.ui" line="368"/>
+        <source>Platform</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="319"/>
-        <source>Platform</source>
+        <location filename="projectfile.ui" line="448"/>
+        <source>Clang (experimental)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="494"/>
+        <source>If you want to design your classes to be as flexible and robust as possible then the public interface must be very robust. Cppcheck will asumme that arguments can take *any* value.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="519"/>
+        <source>Check code in headers  (should be ON normally. if you want a limited quick analysis then turn this OFF)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="420"/>
+        <location filename="projectfile.ui" line="572"/>
+        <source>Max recursion in template instantiation</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="627"/>
         <source>Warning options</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="426"/>
+        <location filename="projectfile.ui" line="633"/>
         <source>Root path:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="438"/>
+        <location filename="projectfile.ui" line="639"/>
+        <source>Filepaths in warnings will be relative to this path</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="649"/>
         <source>Warning tags (separated by semicolon)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="300"/>
+        <location filename="projectfile.ui" line="409"/>
         <source>Cppcheck build dir (whole program analysis, incremental analysis, statistics, etc)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="384"/>
+        <location filename="projectfile.ui" line="380"/>
         <source>Libraries</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Exclude</source>
-        <translation type="obsolete">Excluir</translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="500"/>
+        <location filename="projectfile.ui" line="722"/>
         <source>Suppressions</source>
         <translation type="unfinished">Supresiones</translation>
     </message>
     <message>
-        <source>Suppression list:</source>
-        <translation type="obsolete">Lista de supresiones:</translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="511"/>
+        <location filename="projectfile.ui" line="733"/>
         <source>Add</source>
         <translation>Añadir</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="557"/>
-        <source>Addons and tools</source>
+        <location filename="projectfile.ui" line="786"/>
+        <location filename="projectfile.ui" line="792"/>
+        <source>Addons</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="563"/>
-        <source>Addons</source>
+        <location filename="projectfile.ui" line="798"/>
+        <source>Note: Addons require &lt;a href=&quot;https://www.python.org/&quot;&gt;Python&lt;/a&gt; being installed.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="569"/>
+        <location filename="projectfile.ui" line="808"/>
         <source>Y2038</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="576"/>
+        <location filename="projectfile.ui" line="815"/>
         <source>Thread safety</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="583"/>
+        <location filename="projectfile.ui" line="825"/>
         <source>Coding standards</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="590"/>
-        <source>Cert</source>
+        <location filename="projectfile.ui" line="958"/>
+        <source>Cert C++</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="645"/>
+        <location filename="projectfile.ui" line="982"/>
+        <source>Bug hunting (Premium)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="1011"/>
         <source>Clang analyzer</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="638"/>
+        <location filename="projectfile.ui" line="1004"/>
         <source>Clang-tidy</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="153"/>
+        <location filename="projectfile.ui" line="221"/>
         <source>Defines:</source>
         <translation>Definiciones:</translation>
     </message>
@@ -1697,281 +1977,339 @@ Options:
 <context>
     <name>ProjectFileDialog</name>
     <message>
-        <location filename="projectfiledialog.cpp" line="71"/>
+        <location filename="projectfiledialog.cpp" line="138"/>
         <source>Project file: %1</source>
         <translation>Archivo de proyecto: %1</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="409"/>
+        <location filename="projectfiledialog.cpp" line="590"/>
         <source>Select Cppcheck build dir</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="637"/>
+        <location filename="projectfiledialog.cpp" line="851"/>
         <source>Select include directory</source>
         <translation>Selecciona una carpeta para incluir</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="617"/>
+        <location filename="projectfiledialog.cpp" line="831"/>
         <source>Select a directory to check</source>
         <translation>Selecciona la carpeta a comprobar</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="305"/>
-        <source>(no rule texts file)</source>
+        <location filename="projectfiledialog.cpp" line="396"/>
+        <source>Note: Open source Cppcheck does not fully implement Misra C 2012</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="311"/>
+        <location filename="projectfiledialog.cpp" line="461"/>
         <source>Clang-tidy (not found)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="445"/>
+        <location filename="projectfiledialog.cpp" line="629"/>
         <source>Visual Studio</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="446"/>
+        <location filename="projectfiledialog.cpp" line="630"/>
         <source>Compile database</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="447"/>
+        <location filename="projectfiledialog.cpp" line="631"/>
         <source>Borland C++ Builder 6</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="448"/>
+        <location filename="projectfiledialog.cpp" line="632"/>
         <source>Import Project</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="657"/>
+        <location filename="projectfiledialog.cpp" line="871"/>
         <source>Select directory to ignore</source>
         <translation>Selecciona la carpeta a ignorar</translation>
     </message>
     <message>
-        <source>Add Suppression</source>
-        <translation type="obsolete">Añadir supresión</translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.cpp" line="742"/>
-        <source>Select MISRA rule texts file</source>
+        <location filename="projectfiledialog.cpp" line="879"/>
+        <source>Source files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="742"/>
-        <source>Misra rule texts file (%1)</source>
+        <location filename="projectfiledialog.cpp" line="880"/>
+        <source>All files</source>
         <translation type="unfinished"></translation>
     </message>
-</context>
-<context>
-    <name>QDialogButtonBox</name>
-    <message>
-        <location filename="translationhandler.cpp" line="34"/>
-        <source>OK</source>
-        <translation>Aceptar</translation>
-    </message>
     <message>
-        <location filename="translationhandler.cpp" line="35"/>
-        <source>Cancel</source>
-        <translation>Cancelar</translation>
+        <location filename="projectfiledialog.cpp" line="881"/>
+        <source>Exclude file</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="36"/>
-        <source>Close</source>
-        <translation>Cerrar</translation>
+        <location filename="projectfiledialog.cpp" line="964"/>
+        <source>Select MISRA rule texts file</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="37"/>
-        <source>Save</source>
-        <translation>Guardar</translation>
+        <location filename="projectfiledialog.cpp" line="966"/>
+        <source>MISRA rule texts file (%1)</source>
+        <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>QObject</name>
     <message>
-        <location filename="translationhandler.cpp" line="104"/>
+        <location filename="translationhandler.cpp" line="91"/>
         <source>Unknown language specified!</source>
         <translation>¡Idioma especificado desconocido!</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="132"/>
+        <location filename="translationhandler.cpp" line="117"/>
         <source>Language file %1 not found!</source>
         <translation>¡Fichero de idioma %1 no encontrado!</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="138"/>
+        <location filename="translationhandler.cpp" line="122"/>
         <source>Failed to load translation for language %1 from file %2</source>
         <translation>Fallo al cargar la traducción para el idioma %1 desde el fichero %2</translation>
     </message>
     <message>
-        <location filename="cppchecklibrarydata.cpp" line="33"/>
+        <location filename="cppchecklibrarydata.cpp" line="38"/>
         <source>line %1: Unhandled element %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="226"/>
+        <location filename="cppchecklibrarydata.cpp" line="43"/>
+        <source>line %1: Mandatory attribute &apos;%2&apos; missing in &apos;%3&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="284"/>
         <source> (Not found)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="69"/>
+        <location filename="codeeditstylecontrols.cpp" line="76"/>
         <source>Thin</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="71"/>
+        <location filename="codeeditstylecontrols.cpp" line="78"/>
         <source>ExtraLight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="73"/>
+        <location filename="codeeditstylecontrols.cpp" line="80"/>
         <source>Light</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="75"/>
+        <location filename="codeeditstylecontrols.cpp" line="82"/>
         <source>Normal</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="77"/>
+        <location filename="codeeditstylecontrols.cpp" line="84"/>
         <source>Medium</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="79"/>
+        <location filename="codeeditstylecontrols.cpp" line="86"/>
         <source>DemiBold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="81"/>
+        <location filename="codeeditstylecontrols.cpp" line="88"/>
         <source>Bold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="83"/>
+        <location filename="codeeditstylecontrols.cpp" line="90"/>
         <source>ExtraBold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="85"/>
+        <location filename="codeeditstylecontrols.cpp" line="92"/>
         <source>Black</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="69"/>
+        <location filename="codeeditstyledialog.cpp" line="80"/>
         <source>Editor Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="72"/>
+        <location filename="codeeditstyledialog.cpp" line="83"/>
         <source>Editor Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="75"/>
+        <location filename="codeeditstyledialog.cpp" line="86"/>
         <source>Highlight Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="78"/>
+        <location filename="codeeditstyledialog.cpp" line="89"/>
         <source>Line Number Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="81"/>
+        <location filename="codeeditstyledialog.cpp" line="92"/>
         <source>Line Number Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="84"/>
+        <location filename="codeeditstyledialog.cpp" line="95"/>
         <source>Keyword Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="87"/>
+        <location filename="codeeditstyledialog.cpp" line="98"/>
         <source>Keyword Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="90"/>
+        <location filename="codeeditstyledialog.cpp" line="101"/>
         <source>Class Foreground Color</source>
         <oldsource>Class ForegroundColor</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="93"/>
+        <location filename="codeeditstyledialog.cpp" line="104"/>
         <source>Class Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="96"/>
+        <location filename="codeeditstyledialog.cpp" line="107"/>
         <source>Quote Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="99"/>
+        <location filename="codeeditstyledialog.cpp" line="110"/>
         <source>Quote Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="102"/>
+        <location filename="codeeditstyledialog.cpp" line="113"/>
         <source>Comment Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="105"/>
+        <location filename="codeeditstyledialog.cpp" line="116"/>
         <source>Comment Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="108"/>
+        <location filename="codeeditstyledialog.cpp" line="119"/>
         <source>Symbol Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="111"/>
+        <location filename="codeeditstyledialog.cpp" line="122"/>
         <source>Symbol Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="114"/>
+        <location filename="codeeditstyledialog.cpp" line="125"/>
         <source>Symbol Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="130"/>
+        <location filename="codeeditstyledialog.cpp" line="141"/>
         <source>Set to Default Light</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="132"/>
+        <location filename="codeeditstyledialog.cpp" line="143"/>
         <source>Set to Default Dark</source>
         <translation type="unfinished"></translation>
     </message>
+    <message>
+        <location filename="resultstree.cpp" line="113"/>
+        <source>File</source>
+        <translation type="unfinished">Archivo</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="114"/>
+        <source>Line</source>
+        <translation type="unfinished">Línea</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="115"/>
+        <source>Severity</source>
+        <translation type="unfinished">Severidad</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="116"/>
+        <source>Classification</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="117"/>
+        <source>Level</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="118"/>
+        <source>Inconclusive</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="119"/>
+        <source>Summary</source>
+        <translation type="unfinished">Resumen</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="120"/>
+        <source>Id</source>
+        <translation type="unfinished">Id</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="121"/>
+        <source>Guideline</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="122"/>
+        <source>Rule</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="123"/>
+        <source>Since date</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="124"/>
+        <source>Tags</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="125"/>
+        <source>CWE</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>QPlatformTheme</name>
     <message>
-        <location filename="translationhandler.cpp" line="39"/>
+        <location filename="translationhandler.cpp" line="41"/>
         <source>OK</source>
         <translation>Aceptar</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="40"/>
+        <location filename="translationhandler.cpp" line="42"/>
         <source>Cancel</source>
         <translation>Cancelar</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="41"/>
+        <location filename="translationhandler.cpp" line="43"/>
         <source>Close</source>
         <translation>Cerrar</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="42"/>
+        <location filename="translationhandler.cpp" line="44"/>
         <source>Save</source>
         <translation>Guardar</translation>
     </message>
@@ -1979,139 +2317,122 @@ Options:
 <context>
     <name>ResultsTree</name>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>File</source>
-        <translation>Archivo</translation>
+        <translation type="vanished">Archivo</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Severity</source>
-        <translation>Severidad</translation>
+        <translation type="vanished">Severidad</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Line</source>
-        <translation>Línea</translation>
+        <translation type="vanished">Línea</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Summary</source>
-        <translation>Resumen</translation>
+        <translation type="vanished">Resumen</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="136"/>
         <source>Undefined file</source>
-        <translation>Fichero no definido</translation>
+        <translation type="vanished">Fichero no definido</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="614"/>
+        <location filename="resultstree.cpp" line="668"/>
         <source>Copy</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="797"/>
+        <location filename="resultstree.cpp" line="836"/>
         <source>Could not find file:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="801"/>
+        <location filename="resultstree.cpp" line="840"/>
         <source>Please select the folder &apos;%1&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="802"/>
+        <location filename="resultstree.cpp" line="841"/>
         <source>Select Directory &apos;%1&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="804"/>
+        <location filename="resultstree.cpp" line="843"/>
         <source>Please select the directory where file is located.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>[Inconclusive]</source>
-        <translation type="obsolete">[No concluyente]</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="306"/>
+        <location filename="resultstree.cpp" line="367"/>
         <source>portability</source>
         <translation>portabilidad</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="249"/>
+        <location filename="resultstree.cpp" line="307"/>
         <source>note</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="309"/>
+        <location filename="resultstree.cpp" line="370"/>
         <source>information</source>
         <translation>información</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="312"/>
+        <location filename="resultstree.cpp" line="373"/>
         <source>debug</source>
         <translation>depuración</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="613"/>
-        <source>Recheck</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <source>Copy filename</source>
-        <translation type="obsolete">Copiar nombre del archivo</translation>
-    </message>
-    <message>
-        <source>Copy full path</source>
-        <translation type="obsolete">Copiar ruta completa</translation>
-    </message>
-    <message>
-        <source>Copy message</source>
-        <translation type="obsolete">Copiar mensaje</translation>
-    </message>
-    <message>
-        <source>Copy message id</source>
-        <translation type="obsolete">Copiar id del mensaje</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="615"/>
         <source>Hide</source>
-        <translation>Ocultar</translation>
+        <translation type="vanished">Ocultar</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="616"/>
+        <location filename="resultstree.cpp" line="670"/>
         <source>Hide all with id</source>
         <translation>Ocultar todos con el mismo id</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="617"/>
+        <location filename="resultstree.cpp" line="692"/>
         <source>Suppress selected id(s)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="618"/>
+        <location filename="resultstree.cpp" line="671"/>
         <source>Open containing folder</source>
         <translation>Abrir carpeta contenedora</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="648"/>
-        <location filename="resultstree.cpp" line="1343"/>
+        <location filename="resultstree.cpp" line="376"/>
+        <source>internal</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="667"/>
+        <source>Recheck %1 file(s)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="669"/>
+        <source>Hide %1 result(s)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="712"/>
         <source>Tag</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="650"/>
+        <location filename="resultstree.cpp" line="714"/>
         <source>No tag</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="693"/>
-        <location filename="resultstree.cpp" line="707"/>
+        <location filename="resultstree.cpp" line="744"/>
+        <location filename="resultstree.cpp" line="758"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="694"/>
+        <location filename="resultstree.cpp" line="745"/>
         <source>No editor application configured.
 
 Configure the editor application for Cppcheck in preferences/Applications.</source>
@@ -2121,7 +2442,7 @@ Configure the editor application for Cppcheck in preferences/Applications.</sour
 Configura el programa para editar en Preferencias/Aplicaciones.</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="708"/>
+        <location filename="resultstree.cpp" line="759"/>
         <source>No default editor application selected.
 
 Please select the default editor application in preferences/Applications.</source>
@@ -2130,12 +2451,12 @@ Please select the default editor application in preferences/Applications.</sourc
 Configura el programa para editar por defecto en Preferencias/Aplicaciones.</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="737"/>
+        <location filename="resultstree.cpp" line="779"/>
         <source>Could not find the file!</source>
         <translation>¡No se ha encontrado el fichero!</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="783"/>
+        <location filename="resultstree.cpp" line="822"/>
         <source>Could not start %1
 
 Please check the application path and parameters are correct.</source>
@@ -2144,50 +2465,31 @@ Please check the application path and parameters are correct.</source>
 Por favor comprueba que la ruta a la aplicación y los parámetros son correctos.</translation>
     </message>
     <message>
-        <source>Could not find file:
-%1
-Please select the directory where file is located.</source>
-        <translation type="obsolete">No se ha encontrado el fichero:
-%1
-Por favor selecciona la carpeta donde se encuentra.</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="805"/>
+        <location filename="resultstree.cpp" line="844"/>
         <source>Select Directory</source>
         <translation>Selecciona carpeta</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Id</source>
-        <translation>Id</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="1343"/>
-        <source>Inconclusive</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="1343"/>
-        <source>Since date</source>
-        <translation type="unfinished"></translation>
+        <translation type="vanished">Id</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="294"/>
+        <location filename="resultstree.cpp" line="355"/>
         <source>style</source>
         <translation>estilo</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="297"/>
+        <location filename="resultstree.cpp" line="358"/>
         <source>error</source>
         <translation>error</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="300"/>
+        <location filename="resultstree.cpp" line="361"/>
         <source>warning</source>
         <translation>advertencia</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="303"/>
+        <location filename="resultstree.cpp" line="364"/>
         <source>performance</source>
         <translation>ajuste</translation>
     </message>
@@ -2200,103 +2502,120 @@ Por favor selecciona la carpeta donde se encuentra.</translation>
         <translation>Resultados</translation>
     </message>
     <message>
-        <location filename="resultsview.ui" line="82"/>
-        <source>Analysis Log</source>
+        <location filename="resultsview.ui" line="60"/>
+        <source>Critical errors</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.ui" line="104"/>
-        <source>Warning Details</source>
+        <location filename="resultsview.ui" line="92"/>
+        <source>Analysis Log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="159"/>
-        <source>No errors found, nothing to save.</source>
-        <translation>No se han encontrado errores, nada que guardar.</translation>
+        <location filename="resultsview.ui" line="114"/>
+        <source>Warning Details</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="183"/>
-        <location filename="resultsview.cpp" line="191"/>
+        <location filename="resultsview.cpp" line="237"/>
+        <location filename="resultsview.cpp" line="245"/>
         <source>Failed to save the report.</source>
         <translation>Error al guardar el informe.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="201"/>
+        <location filename="resultsview.cpp" line="255"/>
         <source>Print Report</source>
         <translation>Imprimir informe</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="220"/>
+        <location filename="resultsview.cpp" line="274"/>
         <source>No errors found, nothing to print.</source>
         <translation>No se encontraron errores, nada que imprimir.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="264"/>
+        <location filename="resultsview.cpp" line="326"/>
         <source>%p% (%1 of %2 files checked)</source>
         <translation>%p% (%1 of %2 archivos comprobados)</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="277"/>
-        <location filename="resultsview.cpp" line="288"/>
+        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="361"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="278"/>
+        <location filename="resultsview.cpp" line="351"/>
         <source>No errors found.</source>
         <translation>No se han encontrado errores.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="285"/>
+        <location filename="resultsview.cpp" line="358"/>
         <source>Errors were found, but they are configured to be hidden.
 To toggle what kind of errors are shown, open view menu.</source>
         <translation>Se han encontrado errores, pero están configurados para que no se muestren.
 Para cambiar el tipo de comportamiento, abra el menú Ver.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="331"/>
-        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="421"/>
         <source>Failed to read the report.</source>
         <translation>Error al leer el informe.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="338"/>
+        <location filename="resultsview.cpp" line="409"/>
         <source>XML format version 1 is no longer supported.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Summary</source>
-        <translation type="obsolete">Resumen</translation>
-    </message>
-    <message>
-        <source>Message</source>
-        <translation type="obsolete">Mensaje</translation>
-    </message>
-    <message>
-        <location filename="resultsview.cpp" line="399"/>
+        <location filename="resultsview.cpp" line="460"/>
         <source>First included by</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="465"/>
         <source>Id</source>
         <translation>Id</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="471"/>
+        <location filename="resultsview.cpp" line="539"/>
         <source>Clear Log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="472"/>
+        <location filename="resultsview.cpp" line="540"/>
         <source>Copy this Log entry</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="473"/>
+        <location filename="resultsview.cpp" line="541"/>
         <source>Copy complete Log</source>
         <translation type="unfinished"></translation>
     </message>
+    <message>
+        <location filename="resultsview.cpp" line="549"/>
+        <source>Analysis was stopped</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="563"/>
+        <source>There was a critical error with id &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="565"/>
+        <source>when checking %1</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="567"/>
+        <source>when checking a file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="568"/>
+        <source>Analysis was aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>ScratchPad</name>
@@ -2339,204 +2658,189 @@ Para cambiar el tipo de comportamiento, abra el menú Ver.</translation>
         <translation>General</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="85"/>
         <source>Ideal count:</source>
-        <translation>Cantidad ideal:</translation>
+        <translation type="vanished">Cantidad ideal:</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="114"/>
+        <location filename="settings.ui" line="108"/>
         <source>Force checking all #ifdef configurations</source>
         <translation>Forzar comprobación de todas las configuraciones #ifdef</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="135"/>
+        <location filename="settings.ui" line="129"/>
         <source>Display error Id in column &quot;Id&quot;</source>
         <translation>Mostrar el Id del error en la columna &quot;Id&quot;</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="142"/>
+        <location filename="settings.ui" line="136"/>
         <source>Enable inline suppressions</source>
         <translation>Habilitar supresiones inline</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="149"/>
+        <location filename="settings.ui" line="143"/>
         <source>Check for inconclusive errors also</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="156"/>
+        <location filename="settings.ui" line="150"/>
         <source>Show statistics on check completion</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="176"/>
+        <location filename="settings.ui" line="157"/>
+        <source>Check for updates</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="177"/>
         <source>Show internal warnings in log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="287"/>
+        <location filename="settings.ui" line="288"/>
         <source>Addons</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="293"/>
+        <location filename="settings.ui" line="294"/>
         <source>Python binary (leave this empty to use python in the PATH)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="302"/>
-        <location filename="settings.ui" line="334"/>
-        <location filename="settings.ui" line="379"/>
+        <location filename="settings.ui" line="305"/>
+        <location filename="settings.ui" line="346"/>
+        <location filename="settings.ui" line="391"/>
         <source>...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="312"/>
-        <source>Misra addon</source>
+        <location filename="settings.ui" line="324"/>
+        <source>MISRA addon</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="320"/>
-        <source>Misra rule texts file</source>
+        <location filename="settings.ui" line="332"/>
+        <source>MISRA rule texts file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="327"/>
+        <location filename="settings.ui" line="339"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="360"/>
+        <location filename="settings.ui" line="372"/>
         <source>Clang</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="366"/>
+        <location filename="settings.ui" line="378"/>
         <source>Clang path (leave empty to use system PATH)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="389"/>
+        <location filename="settings.ui" line="401"/>
         <source>Visual Studio headers</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="395"/>
+        <location filename="settings.ui" line="407"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Paths to Visual Studio headers, separated by semicolon &apos;;&apos;.&lt;/p&gt;&lt;p&gt;You can open a Visual Studio command prompt, write &amp;quot;SET INCLUDE&amp;quot;. Then copy/paste the paths.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="425"/>
+        <location filename="settings.ui" line="437"/>
         <source>Code Editor</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="431"/>
+        <location filename="settings.ui" line="443"/>
         <source>Code Editor Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="437"/>
+        <location filename="settings.ui" line="449"/>
         <source>System Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="444"/>
+        <location filename="settings.ui" line="456"/>
         <source>Default Light Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="451"/>
+        <location filename="settings.ui" line="463"/>
         <source>Default Dark Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="460"/>
+        <location filename="settings.ui" line="472"/>
         <source>Custom</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Paths</source>
-        <translation type="obsolete">Rutas</translation>
-    </message>
-    <message>
-        <source>Include paths:</source>
-        <translation type="obsolete">Rutas incluidas:</translation>
-    </message>
-    <message>
-        <location filename="settings.ui" line="195"/>
+        <location filename="settings.ui" line="196"/>
         <source>Add...</source>
         <translation>Añadir...</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="202"/>
-        <location filename="settings.ui" line="467"/>
+        <location filename="settings.ui" line="79"/>
+        <source>Max count:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="203"/>
+        <location filename="settings.ui" line="479"/>
         <source>Edit...</source>
         <translation>Editar...</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="216"/>
+        <location filename="settings.ui" line="217"/>
         <source>Set as default</source>
         <translation>Definir por defecto</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="273"/>
+        <location filename="settings.ui" line="274"/>
         <source>Language</source>
         <translation>Idioma</translation>
     </message>
-    <message>
-        <source>Advanced</source>
-        <translation type="obsolete">Avanzado</translation>
-    </message>
-    <message>
-        <source>&amp;Show inconclusive errors</source>
-        <translation type="obsolete">&amp;Mostrar errores no concluyentes</translation>
-    </message>
-    <message>
-        <source>S&amp;how internal warnings in log</source>
-        <translation type="obsolete">M&amp;ostrar advertencias internas en el log</translation>
-    </message>
     <message>
         <location filename="settings.ui" line="41"/>
         <source>Number of threads: </source>
         <translation>Número de hilos:</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="121"/>
+        <location filename="settings.ui" line="115"/>
         <source>Show full path of files</source>
         <translation>Mostrar la ruta completa de los ficheros</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="128"/>
+        <location filename="settings.ui" line="122"/>
         <source>Show &quot;No errors found&quot; message when no errors found</source>
         <translation>Mostrar el mensaje &quot;No se han encontrado errores&quot;</translation>
     </message>
     <message>
-        <source>Edit</source>
-        <translation type="obsolete">Editar</translation>
-    </message>
-    <message>
-        <location filename="settings.ui" line="209"/>
+        <location filename="settings.ui" line="210"/>
         <source>Remove</source>
         <translation>Eliminar</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="184"/>
+        <location filename="settings.ui" line="185"/>
         <source>Applications</source>
         <translation>Aplicaciones</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="239"/>
+        <location filename="settings.ui" line="240"/>
         <source>Reports</source>
         <translation>Informes</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="245"/>
+        <location filename="settings.ui" line="246"/>
         <source>Save all errors when creating report</source>
         <translation>Guardar todos los errores cuando se cree el informe</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="252"/>
+        <location filename="settings.ui" line="253"/>
         <source>Save full path to files in reports</source>
         <translation>Guardar la ruta completa en los ficheros de informes</translation>
     </message>
@@ -2544,308 +2848,326 @@ Para cambiar el tipo de comportamiento, abra el menú Ver.</translation>
 <context>
     <name>SettingsDialog</name>
     <message>
-        <location filename="settingsdialog.cpp" line="100"/>
         <source>N/A</source>
-        <translation>N/A</translation>
+        <translation type="vanished">N/A</translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="232"/>
+        <source>The executable file &quot;%1&quot; is not available</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="200"/>
+        <location filename="settingsdialog.cpp" line="243"/>
         <source>Add a new application</source>
         <translation>Añadir una nueva aplicación</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="233"/>
+        <location filename="settingsdialog.cpp" line="273"/>
         <source>Modify an application</source>
         <translation>Modificar  una aplicación</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="238"/>
+        <location filename="settingsdialog.cpp" line="278"/>
         <source> [Default]</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="263"/>
+        <location filename="settingsdialog.cpp" line="303"/>
         <source>[Default]</source>
         <translation>[Predeterminada]</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="318"/>
+        <location filename="settingsdialog.cpp" line="358"/>
         <source>Select python binary</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="325"/>
+        <location filename="settingsdialog.cpp" line="365"/>
         <source>Select MISRA File</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="356"/>
+        <location filename="settingsdialog.cpp" line="396"/>
         <source>Select clang path</source>
         <translation type="unfinished"></translation>
     </message>
-    <message>
-        <source>Select include directory</source>
-        <translation type="obsolete">Seleccionar carpeta a incluir</translation>
-    </message>
 </context>
 <context>
     <name>StatsDialog</name>
     <message>
-        <location filename="stats.ui" line="14"/>
-        <location filename="stats.ui" line="248"/>
-        <location filename="statsdialog.cpp" line="137"/>
-        <location filename="statsdialog.cpp" line="184"/>
+        <location filename="statsdialog.ui" line="14"/>
+        <location filename="statsdialog.ui" line="248"/>
+        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="230"/>
         <source>Statistics</source>
         <translation>Estadísticas</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="27"/>
-        <location filename="statsdialog.cpp" line="175"/>
+        <location filename="statsdialog.ui" line="27"/>
+        <location filename="statsdialog.cpp" line="221"/>
         <source>Project</source>
         <translation>Proyecto</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="33"/>
+        <location filename="statsdialog.ui" line="33"/>
         <source>Project:</source>
         <translation>Proyecto:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="53"/>
+        <location filename="statsdialog.ui" line="53"/>
         <source>Paths:</source>
         <translation>Rutas:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="85"/>
+        <location filename="statsdialog.ui" line="85"/>
         <source>Include paths:</source>
         <translation type="unfinished">Incluye las rutas:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="108"/>
+        <location filename="statsdialog.ui" line="108"/>
         <source>Defines:</source>
         <translation type="unfinished">Definiciones:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="131"/>
+        <location filename="statsdialog.ui" line="131"/>
         <source>Undefines:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="165"/>
-        <location filename="statsdialog.cpp" line="180"/>
+        <location filename="statsdialog.ui" line="165"/>
+        <location filename="statsdialog.cpp" line="226"/>
         <source>Previous Scan</source>
         <translation type="unfinished">Análisis anterior</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="171"/>
+        <location filename="statsdialog.ui" line="171"/>
         <source>Path Selected:</source>
         <translation>Ruta seleccionada:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="181"/>
+        <location filename="statsdialog.ui" line="181"/>
         <source>Number of Files Scanned:</source>
         <translation type="unfinished">Número de archivos analizados:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="201"/>
+        <location filename="statsdialog.ui" line="201"/>
         <source>Scan Duration:</source>
         <translation type="unfinished">Duración del análisis:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="256"/>
+        <location filename="statsdialog.ui" line="254"/>
         <source>Errors:</source>
         <translation>Errores:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="274"/>
+        <location filename="statsdialog.ui" line="271"/>
         <source>Warnings:</source>
         <translation>Advertencias:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="292"/>
+        <location filename="statsdialog.ui" line="288"/>
         <source>Stylistic warnings:</source>
         <translation>Advertencias de estilo:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="310"/>
+        <location filename="statsdialog.ui" line="305"/>
         <source>Portability warnings:</source>
         <translation>Advertencias de portabilidad:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="328"/>
+        <location filename="statsdialog.ui" line="322"/>
         <source>Performance issues:</source>
         <translation>Problemas de rendimiento:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="346"/>
+        <location filename="statsdialog.ui" line="339"/>
         <source>Information messages:</source>
         <translation>Mensajes de información:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="363"/>
+        <location filename="statsdialog.ui" line="356"/>
+        <source>Active checkers:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="374"/>
+        <source>Checkers</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="399"/>
         <source>History</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="369"/>
+        <location filename="statsdialog.ui" line="405"/>
         <source>File:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="407"/>
+        <location filename="statsdialog.ui" line="443"/>
         <source>Copy to Clipboard</source>
         <translation>Copiar al portapapeles</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="414"/>
+        <location filename="statsdialog.ui" line="450"/>
         <source>Pdf Export</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="113"/>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>1 day</source>
         <translation>1 día</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="113"/>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>%1 days</source>
         <translation>%1 días</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="115"/>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>1 hour</source>
         <translation>1 hora</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="115"/>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>%1 hours</source>
         <translation>%1 horas</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="117"/>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>1 minute</source>
         <translation>1 minuto</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="117"/>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>%1 minutes</source>
         <translation>%1 minutos</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="119"/>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>1 second</source>
         <translation>1 segundo</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="119"/>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>%1 seconds</source>
         <translation>%1 segundos</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="123"/>
+        <location filename="statsdialog.cpp" line="169"/>
         <source>0.%1 seconds</source>
         <translation>0.%1 segundos</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="125"/>
+        <location filename="statsdialog.cpp" line="171"/>
         <source> and </source>
         <translation> y </translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="152"/>
+        <location filename="statsdialog.cpp" line="198"/>
         <source>Export PDF</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="174"/>
+        <location filename="statsdialog.cpp" line="220"/>
         <source>Project Settings</source>
         <translation>Preferencias del proyecto</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="176"/>
+        <location filename="statsdialog.cpp" line="222"/>
         <source>Paths</source>
         <translation>Rutas</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="177"/>
+        <location filename="statsdialog.cpp" line="223"/>
         <source>Include paths</source>
         <translation type="unfinished">Incluye las rutas</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="178"/>
+        <location filename="statsdialog.cpp" line="224"/>
         <source>Defines</source>
         <translation type="unfinished">Definiciones</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="179"/>
+        <location filename="statsdialog.cpp" line="225"/>
         <source>Undefines</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="181"/>
+        <location filename="statsdialog.cpp" line="227"/>
         <source>Path selected</source>
         <translation>Ruta seleccionada</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="182"/>
+        <location filename="statsdialog.cpp" line="228"/>
         <source>Number of files scanned</source>
         <translation type="unfinished">Número de archivos analizados</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="229"/>
         <source>Scan duration</source>
         <translation type="unfinished">Duración del análisis</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="139"/>
         <location filename="statsdialog.cpp" line="185"/>
+        <location filename="statsdialog.cpp" line="231"/>
         <source>Errors</source>
         <translation>Errores</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="65"/>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>File: </source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="65"/>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>No cppcheck build dir</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="141"/>
-        <location filename="statsdialog.cpp" line="186"/>
+        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="232"/>
         <source>Warnings</source>
         <translation>Advertencias</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="143"/>
-        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="233"/>
         <source>Style warnings</source>
         <translation>Advertencias de estilo</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="145"/>
-        <location filename="statsdialog.cpp" line="188"/>
+        <location filename="statsdialog.cpp" line="191"/>
+        <location filename="statsdialog.cpp" line="234"/>
         <source>Portability warnings</source>
         <translation>Advertencias de portabilidad</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="147"/>
-        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="193"/>
+        <location filename="statsdialog.cpp" line="235"/>
         <source>Performance warnings</source>
         <translation>Advertencias de rendimiento</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="149"/>
-        <location filename="statsdialog.cpp" line="190"/>
+        <location filename="statsdialog.cpp" line="195"/>
+        <location filename="statsdialog.cpp" line="236"/>
         <source>Information messages</source>
         <translation>Mensajes de información</translation>
     </message>
 </context>
+<context>
+    <name>ThreadDetails</name>
+    <message>
+        <location filename="threaddetails.ui" line="14"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>ThreadResult</name>
     <message>
-        <location filename="threadresult.cpp" line="54"/>
+        <location filename="threadresult.cpp" line="47"/>
         <source>%1 of %2 files checked</source>
         <translation>%1 de %2 archivos comprobados</translation>
     </message>
@@ -2853,7 +3175,7 @@ Para cambiar el tipo de comportamiento, abra el menú Ver.</translation>
 <context>
     <name>TranslationHandler</name>
     <message>
-        <location filename="translationhandler.cpp" line="145"/>
+        <location filename="translationhandler.cpp" line="130"/>
         <source>Failed to change the user interface language:
 
 %1
@@ -2866,7 +3188,7 @@ The user interface language has been reset to English. Open the Preferences-dial
 El idioma de la interfaz gráfica ha sido cambiado a Inglés. Abra la ventana de Preferencias para seleccionar alguno de los idiomas disponibles.</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="151"/>
+        <location filename="translationhandler.cpp" line="136"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
@@ -2874,7 +3196,7 @@ El idioma de la interfaz gráfica ha sido cambiado a Inglés. Abra la ventana de
 <context>
     <name>TxtReport</name>
     <message>
-        <location filename="txtreport.cpp" line="73"/>
+        <location filename="txtreport.cpp" line="74"/>
         <source>inconclusive</source>
         <translation>no concluyente</translation>
     </message>
@@ -2882,12 +3204,12 @@ El idioma de la interfaz gráfica ha sido cambiado a Inglés. Abra la ventana de
 <context>
     <name>toFilterString</name>
     <message>
-        <location filename="common.cpp" line="52"/>
+        <location filename="common.cpp" line="58"/>
         <source>All supported files (%1)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="common.cpp" line="57"/>
+        <location filename="common.cpp" line="63"/>
         <source>All files (%1)</source>
         <translation type="unfinished"></translation>
     </message>
diff --git a/gui/cppcheck_fi.ts b/gui/cppcheck_fi.ts
index 1d14f3936a0..f6c959aa099 100644
--- a/gui/cppcheck_fi.ts
+++ b/gui/cppcheck_fi.ts
@@ -20,9 +20,9 @@
     </message>
     <message>
         <location filename="about.ui" line="81"/>
-        <source>Copyright © 2007-2019 Cppcheck team.</source>
-        <oldsource>Copyright © 2007-2018 Cppcheck team.</oldsource>
-        <translation type="unfinished">Copyright (C) 2007-2019 Daniel Marjamäki ja cppcheck tiimi.</translation>
+        <source>Copyright © 2007-%1 Cppcheck team.</source>
+        <oldsource>Copyright © 2007-2021 Cppcheck team.</oldsource>
+        <translation type="unfinished">Copyright (C) 2007-2021 Daniel Marjamäki ja cppcheck tiimi.</translation>
     </message>
     <message>
         <location filename="about.ui" line="91"/>
@@ -38,24 +38,20 @@ Public lisenssin version 3 alaisuuteen</translation>
     </message>
     <message>
         <location filename="about.ui" line="115"/>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
-&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul&gt;
-&lt;li&gt;tinyxml2&lt;/li&gt;
-&lt;li&gt;picojson&lt;/li&gt;
-&lt;li&gt;pcre&lt;/li&gt;
-&lt;li&gt;qt&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PCRE&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PicoJSON&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;TinyXML2&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Boost&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <oldsource>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;pcre&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;picojson&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;tinyxml2&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</oldsource>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>ApplicationDialog</name>
     <message>
-        <location filename="application.ui" line="23"/>
+        <location filename="applicationdialog.ui" line="23"/>
         <source>Add an application</source>
         <translation>Lisää uusi ohjelma</translation>
     </message>
     <message>
-        <location filename="application.ui" line="41"/>
+        <location filename="applicationdialog.ui" line="41"/>
         <source>Here you can add an application that can open error files. Specify a name for the application, the application executable and command line parameters for the application.
 
 The following texts in parameters are replaced with appropriate values when application is executed:
@@ -70,67 +66,159 @@ Parameters: -l(line) (file)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="application.ui" line="76"/>
+        <location filename="applicationdialog.ui" line="76"/>
         <source>&amp;Name:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="application.ui" line="86"/>
+        <location filename="applicationdialog.ui" line="86"/>
         <source>&amp;Executable:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="application.ui" line="96"/>
+        <location filename="applicationdialog.ui" line="96"/>
         <source>&amp;Parameters:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="application.ui" line="138"/>
+        <location filename="applicationdialog.ui" line="138"/>
         <source>Browse</source>
         <translation>Selaa</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="59"/>
+        <location filename="applicationdialog.cpp" line="65"/>
         <source>Executable files (*.exe);;All files(*.*)</source>
         <translation>Suoritettavat tiedostot (*.exe);;Kaikki tiedostot(*.*)</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="62"/>
+        <location filename="applicationdialog.cpp" line="68"/>
         <source>Select viewer application</source>
         <translation>Valitse ohjelma jolla avata virhetiedosto</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="77"/>
+        <location filename="applicationdialog.cpp" line="83"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="78"/>
+        <location filename="applicationdialog.cpp" line="84"/>
         <source>You must specify a name, a path and optionally parameters for the application!</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
+<context>
+    <name>ComplianceReportDialog</name>
+    <message>
+        <location filename="compliancereportdialog.ui" line="14"/>
+        <source>Compliance Report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="29"/>
+        <source>Project name</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="22"/>
+        <source>Project version</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="42"/>
+        <source>Coding Standard</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="50"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="55"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="60"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="70"/>
+        <source>List of files with md5 checksums</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="133"/>
+        <source>Compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="135"/>
+        <source>HTML files (*.html)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="176"/>
+        <location filename="compliancereportdialog.cpp" line="239"/>
+        <source>Save compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="177"/>
+        <source>Failed to import &apos;%1&apos; (%2), can not show files in compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>FileViewDialog</name>
     <message>
-        <location filename="fileviewdialog.cpp" line="42"/>
+        <location filename="fileviewdialog.cpp" line="53"/>
         <source>Could not find the file: %1</source>
         <oldsource>Could not find the file:
 </oldsource>
         <translation>Tiedostoa %1 ei löytynyt</translation>
     </message>
     <message>
-        <location filename="fileviewdialog.cpp" line="46"/>
-        <location filename="fileviewdialog.cpp" line="60"/>
+        <location filename="fileviewdialog.cpp" line="57"/>
+        <location filename="fileviewdialog.cpp" line="71"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="fileviewdialog.cpp" line="56"/>
+        <location filename="fileviewdialog.cpp" line="67"/>
         <source>Could not read the file: %1</source>
         <translation>Tiedoston %1 lukeminen epäonnistui</translation>
     </message>
 </context>
+<context>
+    <name>HelpDialog</name>
+    <message>
+        <location filename="helpdialog.ui" line="14"/>
+        <source>Cppcheck GUI help</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="34"/>
+        <source>Contents</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="44"/>
+        <source>Index</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="84"/>
+        <source>Helpfile &apos;%1&apos; was not found</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="86"/>
+        <source>Cppcheck</source>
+        <translation type="unfinished">Cppcheck</translation>
+    </message>
+</context>
 <context>
     <name>LibraryAddFunctionDialog</name>
     <message>
@@ -237,42 +325,42 @@ Parameters: -l(line) (file)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="82"/>
-        <location filename="librarydialog.cpp" line="154"/>
+        <location filename="librarydialog.cpp" line="97"/>
+        <location filename="librarydialog.cpp" line="169"/>
         <source>Library files (*.cfg)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="84"/>
+        <location filename="librarydialog.cpp" line="99"/>
         <source>Open library file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="95"/>
-        <location filename="librarydialog.cpp" line="107"/>
-        <location filename="librarydialog.cpp" line="144"/>
+        <location filename="librarydialog.cpp" line="110"/>
+        <location filename="librarydialog.cpp" line="122"/>
+        <location filename="librarydialog.cpp" line="159"/>
         <source>Cppcheck</source>
         <translation type="unfinished">Cppcheck</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="96"/>
+        <location filename="librarydialog.cpp" line="111"/>
         <source>Cannot open file %1.</source>
         <oldsource>Can not open file %1.</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="108"/>
+        <location filename="librarydialog.cpp" line="123"/>
         <source>Failed to load %1. %2.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="145"/>
+        <location filename="librarydialog.cpp" line="160"/>
         <source>Cannot save file %1.</source>
         <oldsource>Can not save file %1.</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="157"/>
+        <location filename="librarydialog.cpp" line="172"/>
         <source>Save the library as</source>
         <translation type="unfinished"></translation>
     </message>
@@ -387,759 +475,849 @@ Parameters: -l(line) (file)</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
-<context>
-    <name>LogView</name>
-    <message>
-        <source>Cppcheck</source>
-        <translation type="obsolete">Cppcheck</translation>
-    </message>
-</context>
 <context>
     <name>MainWindow</name>
     <message>
         <location filename="mainwindow.ui" line="26"/>
-        <location filename="mainwindow.ui" line="595"/>
-        <location filename="mainwindow.cpp" line="328"/>
-        <location filename="mainwindow.cpp" line="480"/>
-        <location filename="mainwindow.cpp" line="553"/>
-        <location filename="mainwindow.cpp" line="658"/>
-        <location filename="mainwindow.cpp" line="680"/>
-        <location filename="mainwindow.cpp" line="1113"/>
-        <location filename="mainwindow.cpp" line="1238"/>
-        <location filename="mainwindow.cpp" line="1359"/>
-        <location filename="mainwindow.cpp" line="1499"/>
-        <location filename="mainwindow.cpp" line="1522"/>
-        <location filename="mainwindow.cpp" line="1593"/>
-        <location filename="mainwindow.cpp" line="1667"/>
+        <location filename="mainwindow.ui" line="688"/>
+        <location filename="mainwindow.cpp" line="466"/>
+        <location filename="mainwindow.cpp" line="670"/>
+        <location filename="mainwindow.cpp" line="755"/>
+        <location filename="mainwindow.cpp" line="860"/>
+        <location filename="mainwindow.cpp" line="882"/>
+        <location filename="mainwindow.cpp" line="1467"/>
+        <location filename="mainwindow.cpp" line="1596"/>
+        <location filename="mainwindow.cpp" line="1937"/>
+        <location filename="mainwindow.cpp" line="1945"/>
+        <location filename="mainwindow.cpp" line="1999"/>
+        <location filename="mainwindow.cpp" line="2008"/>
+        <location filename="mainwindow.cpp" line="2080"/>
+        <location filename="mainwindow.cpp" line="2168"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="131"/>
+        <location filename="mainwindow.ui" line="210"/>
         <source>A&amp;nalyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="183"/>
+        <location filename="mainwindow.ui" line="267"/>
         <source>Standard</source>
         <translation>Vakio</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="70"/>
+        <location filename="mainwindow.ui" line="132"/>
         <source>&amp;File</source>
         <translation>&amp;Tiedosto</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="89"/>
+        <location filename="mainwindow.ui" line="152"/>
         <source>&amp;View</source>
         <translation>&amp;Näytä</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="93"/>
+        <location filename="mainwindow.ui" line="156"/>
         <source>&amp;Toolbars</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>&amp;Check</source>
-        <translation type="obsolete">&amp;Tarkista</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="135"/>
+        <location filename="mainwindow.ui" line="214"/>
         <source>C++ standard</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="145"/>
+        <location filename="mainwindow.ui" line="226"/>
         <source>&amp;C standard</source>
         <oldsource>C standard</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="170"/>
+        <location filename="mainwindow.ui" line="254"/>
         <source>&amp;Edit</source>
         <translation>&amp;Muokkaa</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="231"/>
+        <location filename="mainwindow.ui" line="315"/>
         <source>&amp;License...</source>
         <translation>&amp;Lisenssi...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="236"/>
+        <location filename="mainwindow.ui" line="320"/>
         <source>A&amp;uthors...</source>
         <translation>&amp;Tekijät...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="245"/>
+        <location filename="mainwindow.ui" line="329"/>
         <source>&amp;About...</source>
         <translation>&amp;Tietoa ohjelmasta Cppcheck...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="250"/>
+        <location filename="mainwindow.ui" line="334"/>
         <source>&amp;Files...</source>
         <translation>&amp;Tiedostot...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="253"/>
-        <location filename="mainwindow.ui" line="256"/>
+        <location filename="mainwindow.ui" line="337"/>
+        <location filename="mainwindow.ui" line="340"/>
         <source>Analyze files</source>
         <oldsource>Check files</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="259"/>
+        <location filename="mainwindow.ui" line="343"/>
         <source>Ctrl+F</source>
         <translation>Ctrl+F</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="268"/>
+        <location filename="mainwindow.ui" line="352"/>
         <source>&amp;Directory...</source>
         <translation>&amp;Hakemisto...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="271"/>
-        <location filename="mainwindow.ui" line="274"/>
+        <location filename="mainwindow.ui" line="355"/>
+        <location filename="mainwindow.ui" line="358"/>
         <source>Analyze directory</source>
         <oldsource>Check directory</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="277"/>
+        <location filename="mainwindow.ui" line="361"/>
         <source>Ctrl+D</source>
         <translation>Ctrl+D</translation>
     </message>
     <message>
-        <source>&amp;Recheck files</source>
-        <translation type="obsolete">Tarkista tiedostot &amp;uudelleen</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="289"/>
+        <location filename="mainwindow.ui" line="373"/>
         <source>Ctrl+R</source>
         <translation>Ctrl+R</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="307"/>
+        <location filename="mainwindow.ui" line="391"/>
         <source>&amp;Stop</source>
         <translation>&amp;Pysäytä</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="310"/>
-        <location filename="mainwindow.ui" line="313"/>
+        <location filename="mainwindow.ui" line="394"/>
+        <location filename="mainwindow.ui" line="397"/>
         <source>Stop analysis</source>
         <oldsource>Stop checking</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="316"/>
+        <location filename="mainwindow.ui" line="400"/>
         <source>Esc</source>
         <translation>Esc</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="325"/>
+        <location filename="mainwindow.ui" line="409"/>
         <source>&amp;Save results to file...</source>
         <translation>&amp;Tallenna tulokset tiedostoon...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="328"/>
+        <location filename="mainwindow.ui" line="412"/>
         <source>Ctrl+S</source>
         <translation>Ctrl+S</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="333"/>
+        <location filename="mainwindow.ui" line="417"/>
         <source>&amp;Quit</source>
         <translation>&amp;Lopeta</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="342"/>
+        <location filename="mainwindow.ui" line="429"/>
         <source>&amp;Clear results</source>
         <translation>&amp;Tyhjennä tulokset</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="351"/>
+        <location filename="mainwindow.ui" line="438"/>
         <source>&amp;Preferences</source>
         <translation>&amp;Asetukset</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="384"/>
-        <location filename="mainwindow.ui" line="387"/>
+        <location filename="mainwindow.ui" line="471"/>
+        <location filename="mainwindow.ui" line="474"/>
+        <location filename="mainwindow.cpp" line="2394"/>
         <source>Show errors</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="524"/>
-        <location filename="mainwindow.ui" line="527"/>
+        <location filename="mainwindow.ui" line="617"/>
+        <location filename="mainwindow.ui" line="620"/>
+        <location filename="mainwindow.cpp" line="2395"/>
         <source>Show warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="542"/>
-        <location filename="mainwindow.ui" line="545"/>
+        <location filename="mainwindow.ui" line="635"/>
+        <location filename="mainwindow.ui" line="638"/>
         <source>Show performance warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="553"/>
+        <location filename="mainwindow.ui" line="646"/>
         <source>Show &amp;hidden</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="769"/>
-        <location filename="mainwindow.cpp" line="807"/>
+        <location filename="mainwindow.cpp" line="986"/>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Information</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="568"/>
+        <location filename="mainwindow.ui" line="661"/>
         <source>Show information messages</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="583"/>
+        <location filename="mainwindow.ui" line="676"/>
         <source>Show portability warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="598"/>
+        <location filename="mainwindow.ui" line="691"/>
         <source>Show Cppcheck results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="610"/>
+        <location filename="mainwindow.ui" line="703"/>
         <source>Clang</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="613"/>
+        <location filename="mainwindow.ui" line="706"/>
         <source>Show Clang results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="621"/>
+        <location filename="mainwindow.ui" line="714"/>
         <source>&amp;Filter</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="624"/>
+        <location filename="mainwindow.ui" line="717"/>
         <source>Filter results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="640"/>
+        <location filename="mainwindow.ui" line="733"/>
         <source>Windows 32-bit ANSI</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="648"/>
+        <location filename="mainwindow.ui" line="741"/>
         <source>Windows 32-bit Unicode</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="656"/>
+        <location filename="mainwindow.ui" line="749"/>
         <source>Unix 32-bit</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="664"/>
+        <location filename="mainwindow.ui" line="757"/>
         <source>Unix 64-bit</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="672"/>
+        <location filename="mainwindow.ui" line="765"/>
         <source>Windows 64-bit</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="742"/>
+        <location filename="mainwindow.ui" line="859"/>
         <source>&amp;Print...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="745"/>
+        <location filename="mainwindow.ui" line="862"/>
         <source>Print the Current Report</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="750"/>
+        <location filename="mainwindow.ui" line="867"/>
         <source>Print Pre&amp;view...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="753"/>
+        <location filename="mainwindow.ui" line="870"/>
         <source>Open a Print Preview Dialog for the Current Results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="761"/>
+        <location filename="mainwindow.ui" line="878"/>
         <source>Open library editor</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="392"/>
+        <location filename="mainwindow.ui" line="479"/>
         <source>&amp;Check all</source>
         <translation>&amp;Valitse kaikki</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="220"/>
+        <location filename="mainwindow.ui" line="84"/>
+        <source>Checking for updates</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="100"/>
+        <source>Hide</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="164"/>
+        <location filename="mainwindow.ui" line="980"/>
+        <source>Report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="304"/>
         <source>Filter</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="286"/>
+        <location filename="mainwindow.ui" line="370"/>
         <source>&amp;Reanalyze modified files</source>
         <oldsource>&amp;Recheck modified files</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="298"/>
+        <location filename="mainwindow.ui" line="382"/>
         <source>Reanal&amp;yze all files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="363"/>
+        <location filename="mainwindow.ui" line="420"/>
+        <source>Ctrl+Q</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="450"/>
         <source>Style war&amp;nings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="381"/>
+        <location filename="mainwindow.ui" line="468"/>
         <source>E&amp;rrors</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="397"/>
+        <location filename="mainwindow.ui" line="484"/>
         <source>&amp;Uncheck all</source>
         <translation>&amp;Poista kaikista valinta</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="402"/>
+        <location filename="mainwindow.ui" line="489"/>
         <source>Collapse &amp;all</source>
         <translation>&amp;Pienennä kaikki</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="407"/>
+        <location filename="mainwindow.ui" line="494"/>
         <source>&amp;Expand all</source>
         <translation>&amp;Laajenna kaikki</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="415"/>
+        <location filename="mainwindow.ui" line="502"/>
         <source>&amp;Standard</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="418"/>
+        <location filename="mainwindow.ui" line="505"/>
         <source>Standard items</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="434"/>
+        <location filename="mainwindow.ui" line="521"/>
         <source>Toolbar</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="442"/>
+        <location filename="mainwindow.ui" line="529"/>
         <source>&amp;Categories</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="445"/>
+        <location filename="mainwindow.ui" line="532"/>
         <source>Error categories</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="450"/>
+        <location filename="mainwindow.ui" line="537"/>
         <source>&amp;Open XML...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="459"/>
+        <location filename="mainwindow.ui" line="546"/>
         <source>Open P&amp;roject File...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="468"/>
+        <location filename="mainwindow.ui" line="549"/>
+        <source>Ctrl+Shift+O</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="558"/>
         <source>Sh&amp;ow Scratchpad...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="473"/>
+        <location filename="mainwindow.ui" line="563"/>
         <source>&amp;New Project File...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="478"/>
+        <location filename="mainwindow.ui" line="566"/>
+        <source>Ctrl+Shift+N</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="571"/>
         <source>&amp;Log View</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="481"/>
+        <location filename="mainwindow.ui" line="574"/>
         <source>Log View</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="489"/>
+        <location filename="mainwindow.ui" line="582"/>
         <source>C&amp;lose Project File</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="497"/>
+        <location filename="mainwindow.ui" line="590"/>
         <source>&amp;Edit Project File...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="509"/>
+        <location filename="mainwindow.ui" line="602"/>
         <source>&amp;Statistics</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="521"/>
+        <location filename="mainwindow.ui" line="614"/>
         <source>&amp;Warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="539"/>
+        <location filename="mainwindow.ui" line="632"/>
         <source>Per&amp;formance warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="565"/>
+        <location filename="mainwindow.ui" line="658"/>
         <source>&amp;Information</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="580"/>
+        <location filename="mainwindow.ui" line="673"/>
         <source>&amp;Portability</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="680"/>
+        <location filename="mainwindow.ui" line="773"/>
         <source>P&amp;latforms</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="694"/>
+        <location filename="mainwindow.ui" line="787"/>
         <source>C++&amp;11</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="705"/>
+        <location filename="mainwindow.ui" line="798"/>
         <source>C&amp;99</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="713"/>
+        <location filename="mainwindow.ui" line="806"/>
         <source>&amp;Posix</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="721"/>
+        <location filename="mainwindow.ui" line="814"/>
         <source>C&amp;11</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="729"/>
+        <location filename="mainwindow.ui" line="846"/>
         <source>&amp;C89</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="737"/>
+        <location filename="mainwindow.ui" line="854"/>
         <source>&amp;C++03</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="758"/>
+        <location filename="mainwindow.ui" line="875"/>
         <source>&amp;Library Editor...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="769"/>
+        <location filename="mainwindow.ui" line="886"/>
         <source>&amp;Auto-detect language</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="777"/>
+        <location filename="mainwindow.ui" line="894"/>
         <source>&amp;Enforce C++</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="785"/>
+        <location filename="mainwindow.ui" line="902"/>
         <source>E&amp;nforce C</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="796"/>
+        <location filename="mainwindow.ui" line="913"/>
         <source>C++14</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="804"/>
+        <location filename="mainwindow.ui" line="921"/>
         <source>Reanalyze and check library</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="812"/>
+        <location filename="mainwindow.ui" line="929"/>
         <source>Check configuration (defines, includes)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="820"/>
+        <location filename="mainwindow.ui" line="937"/>
         <source>C++17</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="831"/>
+        <location filename="mainwindow.ui" line="948"/>
         <source>C++20</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="423"/>
+        <location filename="mainwindow.ui" line="975"/>
+        <source>Compliance report...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="988"/>
+        <source>Normal</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="996"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1004"/>
+        <source>Misra C++ 2008</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1012"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1020"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1028"/>
+        <source>Misra C++ 2023</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1036"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1041"/>
+        <source>EULA...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1046"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1049"/>
+        <source>Show thread details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="510"/>
         <source>&amp;Contents</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="201"/>
+        <location filename="mainwindow.ui" line="285"/>
         <source>Categories</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="366"/>
-        <location filename="mainwindow.ui" line="369"/>
+        <location filename="mainwindow.ui" line="453"/>
+        <location filename="mainwindow.ui" line="456"/>
         <source>Show style warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="426"/>
+        <location filename="mainwindow.ui" line="513"/>
         <source>Open the help contents</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="429"/>
+        <location filename="mainwindow.ui" line="516"/>
         <source>F1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="121"/>
+        <location filename="mainwindow.ui" line="199"/>
         <source>&amp;Help</source>
         <translation>&amp;Ohje</translation>
     </message>
     <message>
-        <source>Select directory to check</source>
-        <translation type="obsolete">Valitse tarkistettava hakemisto</translation>
-    </message>
-    <message>
-        <source>No suitable files found to check!</source>
-        <translation type="obsolete">Tarkistettavaksi sopivia tiedostoja ei löytynyt!</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="87"/>
+        <location filename="mainwindow.cpp" line="157"/>
+        <location filename="mainwindow.cpp" line="1782"/>
         <source>Quick Filter:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="629"/>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select configuration</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="659"/>
+        <location filename="mainwindow.cpp" line="861"/>
         <source>Found project file: %1
 
 Do you want to load this project file instead?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="778"/>
+        <location filename="mainwindow.cpp" line="995"/>
         <source>File not found</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="781"/>
+        <location filename="mainwindow.cpp" line="998"/>
         <source>Bad XML</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="784"/>
+        <location filename="mainwindow.cpp" line="1001"/>
         <source>Missing attribute</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="787"/>
+        <location filename="mainwindow.cpp" line="1004"/>
         <source>Bad attribute value</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="807"/>
+        <location filename="mainwindow.cpp" line="1016"/>
+        <source>Duplicate define</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Failed to load the selected library &apos;%1&apos;.
 %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1280"/>
+        <location filename="mainwindow.cpp" line="1035"/>
+        <source>File not found: &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1058"/>
+        <source>Failed to load/setup addon %1: %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <source>Failed to load %1 - %2
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
+        <source>%1
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1648"/>
         <source>License</source>
         <translation>Lisenssi</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1287"/>
+        <location filename="mainwindow.cpp" line="1655"/>
         <source>Authors</source>
         <translation>Tekijät</translation>
     </message>
     <message>
-        <source>XML files version 2 (*.xml);;XML files version 1 (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
-        <oldsource>XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</oldsource>
-        <translation type="obsolete">XML-tiedostot (*.xml);;Tekstitiedostot (*.txt);;CSV-tiedostot (*.csv)</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1302"/>
+        <location filename="mainwindow.cpp" line="1675"/>
         <source>Save the report file</source>
         <translation>Tallenna raportti</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1129"/>
-        <location filename="mainwindow.cpp" line="1309"/>
+        <location filename="mainwindow.cpp" line="1483"/>
+        <location filename="mainwindow.cpp" line="1682"/>
         <source>XML files (*.xml)</source>
         <translation>XML-tiedostot (*xml)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="323"/>
+        <location filename="mainwindow.cpp" line="461"/>
         <source>There was a problem with loading the editor application settings.
 
 This is probably because the settings were changed between the Cppcheck versions. Please check (and fix) the editor application settings, otherwise the editor program might not start correctly.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="554"/>
+        <location filename="mainwindow.cpp" line="756"/>
         <source>You must close the project file before selecting new files or directories!</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Select files to check</source>
-        <translation type="obsolete">Valitse tarkistettavat tiedostot</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="769"/>
+        <location filename="mainwindow.cpp" line="986"/>
         <source>The library &apos;%1&apos; contains unknown elements:
 %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="790"/>
+        <location filename="mainwindow.cpp" line="1007"/>
         <source>Unsupported format</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="793"/>
+        <location filename="mainwindow.cpp" line="1010"/>
         <source>Duplicate platform type</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="796"/>
+        <location filename="mainwindow.cpp" line="1013"/>
         <source>Platform type redefined</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="799"/>
+        <location filename="mainwindow.cpp" line="1019"/>
         <source>Unknown element</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="802"/>
-        <source>Unknown issue</source>
+        <location filename="mainwindow.cpp" line="1019"/>
+        <source>Unknown element</source>
+        <oldsource>Unknown issue</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="828"/>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
         <source>Error</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="828"/>
-        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1131"/>
+        <location filename="mainwindow.cpp" line="1485"/>
         <source>Open the report file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1313"/>
+        <location filename="mainwindow.cpp" line="1686"/>
         <source>Text files (*.txt)</source>
         <translation>Tekstitiedostot (*.txt)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1317"/>
+        <location filename="mainwindow.cpp" line="1690"/>
         <source>CSV files (*.csv)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1361"/>
-        <source>Cppcheck - %1</source>
-        <translation>Cppcheck - %1</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1407"/>
+        <location filename="mainwindow.cpp" line="1820"/>
         <source>Project files (*.cppcheck);;All files(*.*)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1409"/>
+        <location filename="mainwindow.cpp" line="1822"/>
         <source>Select Project File</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="159"/>
-        <location filename="mainwindow.cpp" line="1437"/>
-        <location filename="mainwindow.cpp" line="1562"/>
+        <location filename="mainwindow.cpp" line="242"/>
+        <location filename="mainwindow.cpp" line="1784"/>
+        <location filename="mainwindow.cpp" line="1850"/>
+        <location filename="mainwindow.cpp" line="2048"/>
         <source>Project:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="481"/>
+        <location filename="mainwindow.cpp" line="671"/>
         <source>No suitable files found to analyze!</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="568"/>
+        <location filename="mainwindow.cpp" line="770"/>
         <source>C/C++ Source</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="569"/>
+        <location filename="mainwindow.cpp" line="771"/>
         <source>Compile database</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="570"/>
+        <location filename="mainwindow.cpp" line="772"/>
         <source>Visual Studio</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="571"/>
+        <location filename="mainwindow.cpp" line="773"/>
         <source>Borland C++ Builder 6</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="574"/>
+        <location filename="mainwindow.cpp" line="776"/>
         <source>Select files to analyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="589"/>
+        <location filename="mainwindow.cpp" line="791"/>
         <source>Select directory to analyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="629"/>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select the configuration that will be analyzed</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="681"/>
+        <location filename="mainwindow.cpp" line="883"/>
         <source>Found project files from the directory.
 
 Do you want to proceed analysis without using any of these project files?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1114"/>
+        <location filename="mainwindow.cpp" line="1468"/>
         <source>Current results will be cleared.
 
 Opening a new XML file will clear current results.
@@ -1147,44 +1325,81 @@ Do you want to proceed?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1234"/>
+        <location filename="mainwindow.cpp" line="1592"/>
         <source>Analyzer is running.
 
 Do you want to stop the analysis and exit Cppcheck?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1300"/>
+        <location filename="mainwindow.cpp" line="1634"/>
+        <source>About</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1673"/>
         <source>XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1500"/>
+        <location filename="mainwindow.cpp" line="1713"/>
+        <source>Cannot generate a compliance report right now, an analysis must finish successfully. Try to reanalyze the code and ensure there are no critical errors.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1938"/>
         <source>Build dir &apos;%1&apos; does not exist, create it?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1523"/>
-        <source>Failed to import &apos;%1&apos;, analysis is stopped</source>
+        <location filename="mainwindow.cpp" line="1946"/>
+        <source>To check the project using addons, you need a build directory.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1978"/>
+        <source>Failed to open file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1547"/>
+        <location filename="mainwindow.cpp" line="1981"/>
+        <source>Unknown project file format</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1984"/>
+        <source>Failed to import project file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2000"/>
+        <source>Failed to import &apos;%1&apos;: %2
+
+Analysis is stopped.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2009"/>
+        <source>Failed to import &apos;%1&apos; (%2), analysis is stopped</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2033"/>
         <source>Project files (*.cppcheck)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1549"/>
+        <location filename="mainwindow.cpp" line="2035"/>
         <source>Select Project Filename</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1594"/>
+        <location filename="mainwindow.cpp" line="2081"/>
         <source>No project file loaded</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1662"/>
+        <location filename="mainwindow.cpp" line="2163"/>
         <source>The project file
 
 %1
@@ -1195,7 +1410,72 @@ Do you want to remove the file from the recently used projects -list?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="main.cpp" line="106"/>
+        <location filename="mainwindow.cpp" line="2325"/>
+        <source>Install</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2329"/>
+        <source>New version available: %1. %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2367"/>
+        <source>Show Mandatory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2368"/>
+        <source>Show Required</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2369"/>
+        <source>Show Advisory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2370"/>
+        <source>Show Document</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2387"/>
+        <source>Show L1</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2388"/>
+        <source>Show L2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2389"/>
+        <source>Show L3</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2396"/>
+        <source>Show style</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2397"/>
+        <source>Show portability</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2398"/>
+        <source>Show performance</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2399"/>
+        <source>Show information</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="main.cpp" line="100"/>
         <source>Cppcheck GUI.
 
 Syntax:
@@ -1225,7 +1505,7 @@ Options:
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="main.cpp" line="121"/>
+        <location filename="main.cpp" line="115"/>
         <source>Cppcheck GUI - Command line parameters</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1258,7 +1538,7 @@ Options:
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="newsuppressiondialog.cpp" line="52"/>
+        <location filename="newsuppressiondialog.cpp" line="83"/>
         <source>Edit suppression</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1266,277 +1546,424 @@ Options:
 <context>
     <name>Platforms</name>
     <message>
-        <location filename="platforms.cpp" line="37"/>
+        <location filename="platforms.cpp" line="38"/>
         <source>Native</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="38"/>
+        <location filename="platforms.cpp" line="39"/>
         <source>Unix 32-bit</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="39"/>
+        <location filename="platforms.cpp" line="40"/>
         <source>Unix 64-bit</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="40"/>
+        <location filename="platforms.cpp" line="41"/>
         <source>Windows 32-bit ANSI</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="41"/>
+        <location filename="platforms.cpp" line="42"/>
         <source>Windows 32-bit Unicode</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="42"/>
+        <location filename="platforms.cpp" line="43"/>
         <source>Windows 64-bit</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
-<context>
-    <name>Project</name>
-    <message>
-        <source>Cppcheck</source>
-        <translation type="obsolete">Cppcheck</translation>
-    </message>
-</context>
 <context>
     <name>ProjectFile</name>
     <message>
-        <location filename="projectfiledialog.ui" line="14"/>
+        <location filename="projectfile.ui" line="14"/>
         <source>Project File</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="24"/>
+        <location filename="projectfile.ui" line="24"/>
         <source>Paths and Defines</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="30"/>
+        <location filename="projectfile.ui" line="30"/>
         <source>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</source>
         <oldsource>Import Project (Visual studio / compile database)</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="163"/>
+        <location filename="projectfile.ui" line="231"/>
         <source>Defines must be separated by a semicolon. Example: DEF1;DEF2=5;DEF3=int</source>
         <oldsource>Defines must be separated by a semicolon &apos;;&apos;</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="393"/>
+        <location filename="projectfile.ui" line="389"/>
         <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="557"/>
-        <source>Addons and tools</source>
+        <location filename="projectfile.ui" line="876"/>
+        <source>MISRA rule texts</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="597"/>
-        <source>MISRA C 2012</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="606"/>
-        <source>Misra rule texts</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="613"/>
+        <location filename="projectfile.ui" line="883"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="620"/>
+        <location filename="projectfile.ui" line="890"/>
         <source>...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="69"/>
+        <location filename="projectfile.ui" line="73"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;You have a choice:&lt;/p&gt;&lt;p&gt; * Analyze all Debug and Release configurations&lt;/p&gt;&lt;p&gt; * Only analyze the first matching Debug configuration&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="60"/>
-        <location filename="projectfiledialog.ui" line="309"/>
+        <location filename="projectfile.ui" line="60"/>
+        <location filename="projectfile.ui" line="422"/>
+        <location filename="projectfile.ui" line="616"/>
         <source>Browse...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="72"/>
+        <location filename="projectfile.ui" line="76"/>
         <source>Analyze all Visual Studio configurations</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="86"/>
+        <location filename="projectfile.ui" line="113"/>
+        <source>Selected VS Configurations</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="147"/>
         <source>Paths:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="113"/>
-        <location filename="projectfiledialog.ui" line="228"/>
-        <location filename="projectfiledialog.ui" line="461"/>
+        <location filename="projectfile.ui" line="181"/>
+        <location filename="projectfile.ui" line="296"/>
         <source>Add...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="120"/>
-        <location filename="projectfiledialog.ui" line="235"/>
-        <location filename="projectfiledialog.ui" line="468"/>
+        <location filename="projectfile.ui" line="188"/>
+        <location filename="projectfile.ui" line="303"/>
+        <location filename="projectfile.ui" line="690"/>
         <source>Edit</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="127"/>
-        <location filename="projectfiledialog.ui" line="242"/>
-        <location filename="projectfiledialog.ui" line="475"/>
-        <location filename="projectfiledialog.ui" line="518"/>
+        <location filename="projectfile.ui" line="195"/>
+        <location filename="projectfile.ui" line="310"/>
+        <location filename="projectfile.ui" line="697"/>
+        <location filename="projectfile.ui" line="740"/>
         <source>Remove</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="174"/>
+        <location filename="projectfile.ui" line="242"/>
         <source>Undefines:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="184"/>
+        <location filename="projectfile.ui" line="252"/>
         <source>Undefines must be separated by a semicolon. Example: UNDEF1;UNDEF2;UNDEF3</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="197"/>
+        <location filename="projectfile.ui" line="265"/>
         <source>Include Paths:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="262"/>
+        <location filename="projectfile.ui" line="330"/>
         <source>Up</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="269"/>
+        <location filename="projectfile.ui" line="337"/>
         <source>Down</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="294"/>
-        <source>Checking</source>
+        <location filename="projectfile.ui" line="368"/>
+        <source>Platform</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="319"/>
-        <source>Platform</source>
+        <location filename="projectfile.ui" line="403"/>
+        <location filename="projectfile.ui" line="488"/>
+        <source>Analysis</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="331"/>
-        <source>Analysis</source>
+        <location filename="projectfile.ui" line="415"/>
+        <source>This is a workfolder that Cppcheck will use for various purposes.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="448"/>
+        <source>Clang (experimental)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="337"/>
-        <source>Check code in headers  (slower analysis, more results)</source>
+        <location filename="projectfile.ui" line="458"/>
+        <source>Check level</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="347"/>
-        <source>Check code in unused templates  (slower and less accurate analysis)</source>
+        <location filename="projectfile.ui" line="464"/>
+        <source>Reduced -- meant for usage where developer wants results directly. Limited and faster analysis with fewer results.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="356"/>
+        <location filename="projectfile.ui" line="471"/>
+        <source>Normal -- meant for normal analysis in CI. Analysis should finish in reasonable time.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="478"/>
+        <source>Exhaustive -- meant for nightly builds etc. Analysis time can be longer (10x slower than compilation is OK).</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="494"/>
+        <source>If you want to design your classes to be as flexible and robust as possible then the public interface must be very robust. Cppcheck will asumme that arguments can take *any* value.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="529"/>
+        <source>Check code in unused templates (should be ON normally, however in theory you can safely ignore warnings in unused templates)</source>
+        <oldsource>Check code in unused templates  (slower and less accurate analysis)</oldsource>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="541"/>
         <source>Max CTU depth</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="420"/>
+        <location filename="projectfile.ui" line="572"/>
+        <source>Max recursion in template instantiation</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="607"/>
+        <source>Premium License</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="627"/>
         <source>Warning options</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="426"/>
+        <location filename="projectfile.ui" line="633"/>
         <source>Root path:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="438"/>
+        <location filename="projectfile.ui" line="639"/>
+        <source>Filepaths in warnings will be relative to this path</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="649"/>
         <source>Warning tags (separated by semicolon)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="450"/>
-        <source>Exclude source files in paths</source>
+        <location filename="projectfile.ui" line="765"/>
+        <source>Enable inline suppressions</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="851"/>
+        <source>2025</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="901"/>
+        <source>Misra C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="909"/>
+        <source>2008</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="937"/>
+        <source>Cert C</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="632"/>
+        <location filename="projectfile.ui" line="946"/>
+        <source>CERT-INT35-C:  int precision (if size equals precision, you can leave empty)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="965"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="972"/>
+        <source>Safety profiles (defined in C++ core guidelines)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="988"/>
+        <source>Bug hunting</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="998"/>
         <source>External tools</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="300"/>
+        <location filename="projectfile.ui" line="409"/>
         <source>Cppcheck build dir (whole program analysis, incremental analysis, statistics, etc)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="384"/>
+        <location filename="projectfile.ui" line="362"/>
+        <source>Types and Functions</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="380"/>
         <source>Libraries</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="500"/>
+        <location filename="projectfile.ui" line="432"/>
+        <source>Parser</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="438"/>
+        <source>Cppcheck (built in)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="497"/>
+        <source>Check that each class has a safe public interface</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="513"/>
+        <source>Limit analysis</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="519"/>
+        <source>Check code in headers  (should be ON normally. if you want a limited quick analysis then turn this OFF)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="655"/>
+        <source>If tags are added, you will be able to right click on warnings and set one of these tags. You can manually categorize warnings.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="665"/>
+        <source>Exclude source files</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="676"/>
+        <source>Exclude folder...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="683"/>
+        <source>Exclude file...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="722"/>
         <source>Suppressions</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="511"/>
+        <location filename="projectfile.ui" line="733"/>
         <source>Add</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="563"/>
+        <location filename="projectfile.ui" line="786"/>
+        <location filename="projectfile.ui" line="792"/>
         <source>Addons</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="569"/>
+        <location filename="projectfile.ui" line="798"/>
+        <source>Note: Addons require &lt;a href=&quot;https://www.python.org/&quot;&gt;Python&lt;/a&gt; being installed.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="808"/>
         <source>Y2038</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="576"/>
+        <location filename="projectfile.ui" line="815"/>
         <source>Thread safety</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="583"/>
+        <location filename="projectfile.ui" line="825"/>
         <source>Coding standards</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="590"/>
-        <source>Cert</source>
+        <location filename="projectfile.ui" line="833"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="841"/>
+        <source>2012</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="846"/>
+        <location filename="projectfile.ui" line="914"/>
+        <source>2023</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="958"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="982"/>
+        <source>Bug hunting (Premium)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="645"/>
+        <location filename="projectfile.ui" line="1011"/>
         <source>Clang analyzer</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="638"/>
+        <location filename="projectfile.ui" line="1004"/>
         <source>Clang-tidy</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="153"/>
+        <location filename="projectfile.ui" line="221"/>
         <source>Defines:</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1544,279 +1971,341 @@ Options:
 <context>
     <name>ProjectFileDialog</name>
     <message>
-        <location filename="projectfiledialog.cpp" line="71"/>
+        <location filename="projectfiledialog.cpp" line="138"/>
         <source>Project file: %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="409"/>
+        <location filename="projectfiledialog.cpp" line="590"/>
         <source>Select Cppcheck build dir</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="637"/>
+        <location filename="projectfiledialog.cpp" line="851"/>
         <source>Select include directory</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="617"/>
+        <location filename="projectfiledialog.cpp" line="831"/>
         <source>Select a directory to check</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="305"/>
-        <source>(no rule texts file)</source>
+        <location filename="projectfiledialog.cpp" line="396"/>
+        <source>Note: Open source Cppcheck does not fully implement Misra C 2012</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="311"/>
+        <location filename="projectfiledialog.cpp" line="461"/>
         <source>Clang-tidy (not found)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="445"/>
+        <location filename="projectfiledialog.cpp" line="629"/>
         <source>Visual Studio</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="446"/>
+        <location filename="projectfiledialog.cpp" line="630"/>
         <source>Compile database</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="447"/>
+        <location filename="projectfiledialog.cpp" line="631"/>
         <source>Borland C++ Builder 6</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="448"/>
+        <location filename="projectfiledialog.cpp" line="632"/>
         <source>Import Project</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="657"/>
+        <location filename="projectfiledialog.cpp" line="871"/>
         <source>Select directory to ignore</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="742"/>
-        <source>Select MISRA rule texts file</source>
+        <location filename="projectfiledialog.cpp" line="879"/>
+        <source>Source files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="742"/>
-        <source>Misra rule texts file (%1)</source>
+        <location filename="projectfiledialog.cpp" line="880"/>
+        <source>All files</source>
         <translation type="unfinished"></translation>
     </message>
-</context>
-<context>
-    <name>QDialogButtonBox</name>
     <message>
-        <location filename="translationhandler.cpp" line="34"/>
-        <source>OK</source>
+        <location filename="projectfiledialog.cpp" line="881"/>
+        <source>Exclude file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="35"/>
-        <source>Cancel</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="translationhandler.cpp" line="36"/>
-        <source>Close</source>
+        <location filename="projectfiledialog.cpp" line="964"/>
+        <source>Select MISRA rule texts file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="37"/>
-        <source>Save</source>
+        <location filename="projectfiledialog.cpp" line="966"/>
+        <source>MISRA rule texts file (%1)</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>QObject</name>
     <message>
-        <location filename="translationhandler.cpp" line="104"/>
+        <location filename="translationhandler.cpp" line="91"/>
         <source>Unknown language specified!</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="132"/>
+        <location filename="translationhandler.cpp" line="117"/>
         <source>Language file %1 not found!</source>
         <oldsource>Language file %1.qm not found!</oldsource>
         <translation>Käännöstiedostoa %1 ei löytynyt!</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="138"/>
+        <location filename="translationhandler.cpp" line="122"/>
         <source>Failed to load translation for language %1 from file %2</source>
         <oldsource>Failed to load translation for language %1 from file %2.qm</oldsource>
         <translation>Käänöksen lataaminen kielelle %1 tiedostosta %2 epäonnistui</translation>
     </message>
     <message>
-        <location filename="cppchecklibrarydata.cpp" line="33"/>
+        <location filename="cppchecklibrarydata.cpp" line="38"/>
         <source>line %1: Unhandled element %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="226"/>
+        <location filename="cppchecklibrarydata.cpp" line="43"/>
+        <source>line %1: Mandatory attribute &apos;%2&apos; missing in &apos;%3&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="284"/>
         <source> (Not found)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="69"/>
+        <location filename="codeeditstylecontrols.cpp" line="76"/>
         <source>Thin</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="71"/>
+        <location filename="codeeditstylecontrols.cpp" line="78"/>
         <source>ExtraLight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="73"/>
+        <location filename="codeeditstylecontrols.cpp" line="80"/>
         <source>Light</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="75"/>
+        <location filename="codeeditstylecontrols.cpp" line="82"/>
         <source>Normal</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="77"/>
+        <location filename="codeeditstylecontrols.cpp" line="84"/>
         <source>Medium</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="79"/>
+        <location filename="codeeditstylecontrols.cpp" line="86"/>
         <source>DemiBold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="81"/>
+        <location filename="codeeditstylecontrols.cpp" line="88"/>
         <source>Bold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="83"/>
+        <location filename="codeeditstylecontrols.cpp" line="90"/>
         <source>ExtraBold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="85"/>
+        <location filename="codeeditstylecontrols.cpp" line="92"/>
         <source>Black</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="69"/>
+        <location filename="codeeditstyledialog.cpp" line="80"/>
         <source>Editor Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="72"/>
+        <location filename="codeeditstyledialog.cpp" line="83"/>
         <source>Editor Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="75"/>
+        <location filename="codeeditstyledialog.cpp" line="86"/>
         <source>Highlight Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="78"/>
+        <location filename="codeeditstyledialog.cpp" line="89"/>
         <source>Line Number Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="81"/>
+        <location filename="codeeditstyledialog.cpp" line="92"/>
         <source>Line Number Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="84"/>
+        <location filename="codeeditstyledialog.cpp" line="95"/>
         <source>Keyword Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="87"/>
+        <location filename="codeeditstyledialog.cpp" line="98"/>
         <source>Keyword Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="90"/>
+        <location filename="codeeditstyledialog.cpp" line="101"/>
         <source>Class Foreground Color</source>
         <oldsource>Class ForegroundColor</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="93"/>
+        <location filename="codeeditstyledialog.cpp" line="104"/>
         <source>Class Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="96"/>
+        <location filename="codeeditstyledialog.cpp" line="107"/>
         <source>Quote Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="99"/>
+        <location filename="codeeditstyledialog.cpp" line="110"/>
         <source>Quote Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="102"/>
+        <location filename="codeeditstyledialog.cpp" line="113"/>
         <source>Comment Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="105"/>
+        <location filename="codeeditstyledialog.cpp" line="116"/>
         <source>Comment Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="108"/>
+        <location filename="codeeditstyledialog.cpp" line="119"/>
         <source>Symbol Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="111"/>
+        <location filename="codeeditstyledialog.cpp" line="122"/>
         <source>Symbol Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="114"/>
+        <location filename="codeeditstyledialog.cpp" line="125"/>
         <source>Symbol Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="130"/>
+        <location filename="codeeditstyledialog.cpp" line="141"/>
         <source>Set to Default Light</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="132"/>
+        <location filename="codeeditstyledialog.cpp" line="143"/>
         <source>Set to Default Dark</source>
         <translation type="unfinished"></translation>
     </message>
+    <message>
+        <location filename="resultstree.cpp" line="113"/>
+        <source>File</source>
+        <translation type="unfinished">Tiedosto</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="114"/>
+        <source>Line</source>
+        <translation type="unfinished">Rivi</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="115"/>
+        <source>Severity</source>
+        <translation type="unfinished">Tyyppi</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="116"/>
+        <source>Classification</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="117"/>
+        <source>Level</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="118"/>
+        <source>Inconclusive</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="119"/>
+        <source>Summary</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="120"/>
+        <source>Id</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="121"/>
+        <source>Guideline</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="122"/>
+        <source>Rule</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="123"/>
+        <source>Since date</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="124"/>
+        <source>Tags</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="125"/>
+        <source>CWE</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>QPlatformTheme</name>
     <message>
-        <location filename="translationhandler.cpp" line="39"/>
+        <location filename="translationhandler.cpp" line="41"/>
         <source>OK</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="40"/>
+        <location filename="translationhandler.cpp" line="42"/>
         <source>Cancel</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="41"/>
+        <location filename="translationhandler.cpp" line="43"/>
         <source>Close</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="42"/>
+        <location filename="translationhandler.cpp" line="44"/>
         <source>Save</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1824,117 +2313,104 @@ Options:
 <context>
     <name>ResultsTree</name>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>File</source>
-        <translation>Tiedosto</translation>
+        <translation type="vanished">Tiedosto</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Severity</source>
-        <translation>Tyyppi</translation>
+        <translation type="vanished">Tyyppi</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Line</source>
-        <translation>Rivi</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="1343"/>
-        <source>Summary</source>
-        <translation type="unfinished"></translation>
+        <translation type="vanished">Rivi</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="136"/>
         <source>Undefined file</source>
-        <translation>Määrittelemätön tiedosto</translation>
+        <translation type="vanished">Määrittelemätön tiedosto</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="614"/>
+        <location filename="resultstree.cpp" line="668"/>
         <source>Copy</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="797"/>
+        <location filename="resultstree.cpp" line="836"/>
         <source>Could not find file:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="801"/>
+        <location filename="resultstree.cpp" line="840"/>
         <source>Please select the folder &apos;%1&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="802"/>
+        <location filename="resultstree.cpp" line="841"/>
         <source>Select Directory &apos;%1&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="804"/>
+        <location filename="resultstree.cpp" line="843"/>
         <source>Please select the directory where file is located.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="312"/>
+        <location filename="resultstree.cpp" line="373"/>
         <source>debug</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="249"/>
+        <location filename="resultstree.cpp" line="307"/>
         <source>note</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="613"/>
-        <source>Recheck</source>
+        <location filename="resultstree.cpp" line="670"/>
+        <source>Hide all with id</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Copy filename</source>
-        <translation type="obsolete">Kopioi tiedostonimi</translation>
-    </message>
-    <message>
-        <source>Copy full path</source>
-        <translation type="obsolete">Kopioi tiedoston koko polku</translation>
+        <location filename="resultstree.cpp" line="692"/>
+        <source>Suppress selected id(s)</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="615"/>
-        <source>Hide</source>
+        <location filename="resultstree.cpp" line="671"/>
+        <source>Open containing folder</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="616"/>
-        <source>Hide all with id</source>
+        <location filename="resultstree.cpp" line="376"/>
+        <source>internal</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="617"/>
-        <source>Suppress selected id(s)</source>
+        <location filename="resultstree.cpp" line="667"/>
+        <source>Recheck %1 file(s)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="618"/>
-        <source>Open containing folder</source>
+        <location filename="resultstree.cpp" line="669"/>
+        <source>Hide %1 result(s)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="648"/>
-        <location filename="resultstree.cpp" line="1343"/>
+        <location filename="resultstree.cpp" line="712"/>
         <source>Tag</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="650"/>
+        <location filename="resultstree.cpp" line="714"/>
         <source>No tag</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="693"/>
-        <location filename="resultstree.cpp" line="707"/>
+        <location filename="resultstree.cpp" line="744"/>
+        <location filename="resultstree.cpp" line="758"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="694"/>
+        <location filename="resultstree.cpp" line="745"/>
         <source>No editor application configured.
 
 Configure the editor application for Cppcheck in preferences/Applications.</source>
@@ -1942,19 +2418,19 @@ Configure the editor application for Cppcheck in preferences/Applications.</sour
         <translation type="unfinished">Voit asetuksista määritellä muita ohjelmia joilla avata tämän virheen sisältävän tiedoston.</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="708"/>
+        <location filename="resultstree.cpp" line="759"/>
         <source>No default editor application selected.
 
 Please select the default editor application in preferences/Applications.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="737"/>
+        <location filename="resultstree.cpp" line="779"/>
         <source>Could not find the file!</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="783"/>
+        <location filename="resultstree.cpp" line="822"/>
         <source>Could not start %1
 
 Please check the application path and parameters are correct.</source>
@@ -1963,52 +2439,37 @@ Please check the application path and parameters are correct.</source>
 Tarkista että ohjelman polku ja parametrit ovat oikeat.</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="805"/>
+        <location filename="resultstree.cpp" line="844"/>
         <source>Select Directory</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
-        <source>Id</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="1343"/>
-        <source>Inconclusive</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="1343"/>
-        <source>Since date</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="294"/>
+        <location filename="resultstree.cpp" line="355"/>
         <source>style</source>
         <translation>Tyyli</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="297"/>
+        <location filename="resultstree.cpp" line="358"/>
         <source>error</source>
         <translation>Yleinen</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="300"/>
+        <location filename="resultstree.cpp" line="361"/>
         <source>warning</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="303"/>
+        <location filename="resultstree.cpp" line="364"/>
         <source>performance</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="306"/>
+        <location filename="resultstree.cpp" line="367"/>
         <source>portability</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="309"/>
+        <location filename="resultstree.cpp" line="370"/>
         <source>information</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2016,82 +2477,102 @@ Tarkista että ohjelman polku ja parametrit ovat oikeat.</translation>
 <context>
     <name>ResultsView</name>
     <message>
-        <location filename="resultsview.cpp" line="201"/>
+        <location filename="resultsview.cpp" line="255"/>
         <source>Print Report</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="220"/>
+        <location filename="resultsview.cpp" line="274"/>
         <source>No errors found, nothing to print.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="264"/>
+        <location filename="resultsview.cpp" line="326"/>
         <source>%p% (%1 of %2 files checked)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="277"/>
-        <location filename="resultsview.cpp" line="288"/>
+        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="361"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="278"/>
+        <location filename="resultsview.cpp" line="351"/>
         <source>No errors found.</source>
         <translation>Virheitä ei löytynyt.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="285"/>
+        <location filename="resultsview.cpp" line="358"/>
         <source>Errors were found, but they are configured to be hidden.
 To toggle what kind of errors are shown, open view menu.</source>
         <translation>Virheitä löytyi, mutta asetuksissa kyseiset virheet on määritelty piilotettavaksi.
 Määrittääksesi minkä tyyppisiä virheitä näytetään, avaa näkymä valikko.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="331"/>
-        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="421"/>
         <source>Failed to read the report.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="338"/>
+        <location filename="resultsview.cpp" line="409"/>
         <source>XML format version 1 is no longer supported.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="399"/>
+        <location filename="resultsview.cpp" line="460"/>
         <source>First included by</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="465"/>
         <source>Id</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="471"/>
+        <location filename="resultsview.cpp" line="539"/>
         <source>Clear Log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="472"/>
+        <location filename="resultsview.cpp" line="540"/>
         <source>Copy this Log entry</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="473"/>
+        <location filename="resultsview.cpp" line="541"/>
         <source>Copy complete Log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="159"/>
-        <source>No errors found, nothing to save.</source>
-        <translation>Virheitä ei löytynyt, ei mitään tallennettavaa.</translation>
+        <location filename="resultsview.cpp" line="549"/>
+        <source>Analysis was stopped</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="563"/>
+        <source>There was a critical error with id &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="565"/>
+        <source>when checking %1</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="183"/>
-        <location filename="resultsview.cpp" line="191"/>
+        <location filename="resultsview.cpp" line="567"/>
+        <source>when checking a file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="568"/>
+        <source>Analysis was aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="237"/>
+        <location filename="resultsview.cpp" line="245"/>
         <source>Failed to save the report.</source>
         <translation>Raportin tallentaminen epäonnistui.</translation>
     </message>
@@ -2101,12 +2582,17 @@ Määrittääksesi minkä tyyppisiä virheitä näytetään, avaa näkymä valik
         <translation>Tulokset</translation>
     </message>
     <message>
-        <location filename="resultsview.ui" line="82"/>
+        <location filename="resultsview.ui" line="60"/>
+        <source>Critical errors</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.ui" line="92"/>
         <source>Analysis Log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.ui" line="104"/>
+        <location filename="resultsview.ui" line="114"/>
         <source>Warning Details</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2152,7 +2638,7 @@ Määrittääksesi minkä tyyppisiä virheitä näytetään, avaa näkymä valik
         <translation>Yleiset</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="195"/>
+        <location filename="settings.ui" line="196"/>
         <source>Add...</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2162,171 +2648,176 @@ Määrittääksesi minkä tyyppisiä virheitä näytetään, avaa näkymä valik
         <translation>Säikeiden lukumäärä: </translation>
     </message>
     <message>
-        <location filename="settings.ui" line="85"/>
-        <source>Ideal count:</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="settings.ui" line="114"/>
+        <location filename="settings.ui" line="108"/>
         <source>Force checking all #ifdef configurations</source>
         <oldsource>Check all #ifdef configurations</oldsource>
         <translation type="unfinished">Tarkista kaikki #ifdef kombinaatiot</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="121"/>
+        <location filename="settings.ui" line="115"/>
         <source>Show full path of files</source>
         <translation>Näytä tiedostojen täysi polku</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="128"/>
+        <location filename="settings.ui" line="122"/>
         <source>Show &quot;No errors found&quot; message when no errors found</source>
         <translation>Näytä &quot;virheitä ei löytynyt&quot;-viesti jos virheitä ei löydy</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="135"/>
+        <location filename="settings.ui" line="129"/>
         <source>Display error Id in column &quot;Id&quot;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="142"/>
+        <location filename="settings.ui" line="136"/>
         <source>Enable inline suppressions</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="149"/>
+        <location filename="settings.ui" line="143"/>
         <source>Check for inconclusive errors also</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="156"/>
+        <location filename="settings.ui" line="150"/>
         <source>Show statistics on check completion</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="176"/>
+        <location filename="settings.ui" line="157"/>
+        <source>Check for updates</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="177"/>
         <source>Show internal warnings in log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="287"/>
+        <location filename="settings.ui" line="288"/>
         <source>Addons</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="293"/>
+        <location filename="settings.ui" line="294"/>
         <source>Python binary (leave this empty to use python in the PATH)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="302"/>
-        <location filename="settings.ui" line="334"/>
-        <location filename="settings.ui" line="379"/>
+        <location filename="settings.ui" line="305"/>
+        <location filename="settings.ui" line="346"/>
+        <location filename="settings.ui" line="391"/>
         <source>...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="312"/>
-        <source>Misra addon</source>
+        <location filename="settings.ui" line="324"/>
+        <source>MISRA addon</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="320"/>
-        <source>Misra rule texts file</source>
+        <location filename="settings.ui" line="332"/>
+        <source>MISRA rule texts file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="327"/>
+        <location filename="settings.ui" line="339"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="360"/>
+        <location filename="settings.ui" line="372"/>
         <source>Clang</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="366"/>
+        <location filename="settings.ui" line="378"/>
         <source>Clang path (leave empty to use system PATH)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="389"/>
+        <location filename="settings.ui" line="401"/>
         <source>Visual Studio headers</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="395"/>
+        <location filename="settings.ui" line="407"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Paths to Visual Studio headers, separated by semicolon &apos;;&apos;.&lt;/p&gt;&lt;p&gt;You can open a Visual Studio command prompt, write &amp;quot;SET INCLUDE&amp;quot;. Then copy/paste the paths.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="425"/>
+        <location filename="settings.ui" line="437"/>
         <source>Code Editor</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="431"/>
+        <location filename="settings.ui" line="443"/>
         <source>Code Editor Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="437"/>
+        <location filename="settings.ui" line="449"/>
         <source>System Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="444"/>
+        <location filename="settings.ui" line="456"/>
         <source>Default Light Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="451"/>
+        <location filename="settings.ui" line="463"/>
         <source>Default Dark Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="460"/>
+        <location filename="settings.ui" line="472"/>
         <source>Custom</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="209"/>
+        <location filename="settings.ui" line="210"/>
         <source>Remove</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="184"/>
+        <location filename="settings.ui" line="79"/>
+        <source>Max count:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="185"/>
         <source>Applications</source>
         <translation>Ohjelmat</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="202"/>
-        <location filename="settings.ui" line="467"/>
+        <location filename="settings.ui" line="203"/>
+        <location filename="settings.ui" line="479"/>
         <source>Edit...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="216"/>
+        <location filename="settings.ui" line="217"/>
         <source>Set as default</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="239"/>
+        <location filename="settings.ui" line="240"/>
         <source>Reports</source>
         <translation>Raportit</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="245"/>
+        <location filename="settings.ui" line="246"/>
         <source>Save all errors when creating report</source>
         <translation>Tallenna kaikki virheet raporttia luodessa</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="252"/>
+        <location filename="settings.ui" line="253"/>
         <source>Save full path to files in reports</source>
         <translation>Tallenna tiedostojen koko polku raportteihin</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="273"/>
+        <location filename="settings.ui" line="274"/>
         <source>Language</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2334,42 +2825,42 @@ Määrittääksesi minkä tyyppisiä virheitä näytetään, avaa näkymä valik
 <context>
     <name>SettingsDialog</name>
     <message>
-        <location filename="settingsdialog.cpp" line="100"/>
-        <source>N/A</source>
+        <location filename="settingsdialog.cpp" line="232"/>
+        <source>The executable file &quot;%1&quot; is not available</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="200"/>
+        <location filename="settingsdialog.cpp" line="243"/>
         <source>Add a new application</source>
         <translation>Lisää uusi ohjelma</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="233"/>
+        <location filename="settingsdialog.cpp" line="273"/>
         <source>Modify an application</source>
         <translation>Muokkaa ohjelmaa</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="238"/>
+        <location filename="settingsdialog.cpp" line="278"/>
         <source> [Default]</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="263"/>
+        <location filename="settingsdialog.cpp" line="303"/>
         <source>[Default]</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="318"/>
+        <location filename="settingsdialog.cpp" line="358"/>
         <source>Select python binary</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="325"/>
+        <location filename="settingsdialog.cpp" line="365"/>
         <source>Select MISRA File</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="356"/>
+        <location filename="settingsdialog.cpp" line="396"/>
         <source>Select clang path</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2377,261 +2868,279 @@ Määrittääksesi minkä tyyppisiä virheitä näytetään, avaa näkymä valik
 <context>
     <name>StatsDialog</name>
     <message>
-        <location filename="stats.ui" line="14"/>
-        <location filename="stats.ui" line="248"/>
-        <location filename="statsdialog.cpp" line="137"/>
-        <location filename="statsdialog.cpp" line="184"/>
+        <location filename="statsdialog.ui" line="14"/>
+        <location filename="statsdialog.ui" line="248"/>
+        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="230"/>
         <source>Statistics</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="27"/>
-        <location filename="statsdialog.cpp" line="175"/>
+        <location filename="statsdialog.ui" line="27"/>
+        <location filename="statsdialog.cpp" line="221"/>
         <source>Project</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="33"/>
+        <location filename="statsdialog.ui" line="33"/>
         <source>Project:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="53"/>
+        <location filename="statsdialog.ui" line="53"/>
         <source>Paths:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="85"/>
+        <location filename="statsdialog.ui" line="85"/>
         <source>Include paths:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="108"/>
+        <location filename="statsdialog.ui" line="108"/>
         <source>Defines:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="131"/>
+        <location filename="statsdialog.ui" line="131"/>
         <source>Undefines:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="165"/>
-        <location filename="statsdialog.cpp" line="180"/>
+        <location filename="statsdialog.ui" line="165"/>
+        <location filename="statsdialog.cpp" line="226"/>
         <source>Previous Scan</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="171"/>
+        <location filename="statsdialog.ui" line="171"/>
         <source>Path Selected:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="181"/>
+        <location filename="statsdialog.ui" line="181"/>
         <source>Number of Files Scanned:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="201"/>
+        <location filename="statsdialog.ui" line="201"/>
         <source>Scan Duration:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="256"/>
+        <location filename="statsdialog.ui" line="254"/>
         <source>Errors:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="274"/>
+        <location filename="statsdialog.ui" line="271"/>
         <source>Warnings:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="292"/>
+        <location filename="statsdialog.ui" line="288"/>
         <source>Stylistic warnings:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="310"/>
+        <location filename="statsdialog.ui" line="305"/>
         <source>Portability warnings:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="328"/>
+        <location filename="statsdialog.ui" line="322"/>
         <source>Performance issues:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="346"/>
+        <location filename="statsdialog.ui" line="339"/>
         <source>Information messages:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="363"/>
+        <location filename="statsdialog.ui" line="356"/>
+        <source>Active checkers:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="374"/>
+        <source>Checkers</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="399"/>
         <source>History</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="369"/>
+        <location filename="statsdialog.ui" line="405"/>
         <source>File:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="407"/>
+        <location filename="statsdialog.ui" line="443"/>
         <source>Copy to Clipboard</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="414"/>
+        <location filename="statsdialog.ui" line="450"/>
         <source>Pdf Export</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="113"/>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>1 day</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="113"/>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>%1 days</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="115"/>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>1 hour</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="115"/>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>%1 hours</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="117"/>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>1 minute</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="117"/>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>%1 minutes</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="119"/>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>1 second</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="119"/>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>%1 seconds</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="123"/>
+        <location filename="statsdialog.cpp" line="169"/>
         <source>0.%1 seconds</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="125"/>
+        <location filename="statsdialog.cpp" line="171"/>
         <source> and </source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="152"/>
+        <location filename="statsdialog.cpp" line="198"/>
         <source>Export PDF</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="174"/>
+        <location filename="statsdialog.cpp" line="220"/>
         <source>Project Settings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="176"/>
+        <location filename="statsdialog.cpp" line="222"/>
         <source>Paths</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="177"/>
+        <location filename="statsdialog.cpp" line="223"/>
         <source>Include paths</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="178"/>
+        <location filename="statsdialog.cpp" line="224"/>
         <source>Defines</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="179"/>
+        <location filename="statsdialog.cpp" line="225"/>
         <source>Undefines</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="181"/>
+        <location filename="statsdialog.cpp" line="227"/>
         <source>Path selected</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="182"/>
+        <location filename="statsdialog.cpp" line="228"/>
         <source>Number of files scanned</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="229"/>
         <source>Scan duration</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="139"/>
         <location filename="statsdialog.cpp" line="185"/>
+        <location filename="statsdialog.cpp" line="231"/>
         <source>Errors</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="65"/>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>File: </source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="65"/>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>No cppcheck build dir</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="141"/>
-        <location filename="statsdialog.cpp" line="186"/>
+        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="232"/>
         <source>Warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="143"/>
-        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="233"/>
         <source>Style warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="145"/>
-        <location filename="statsdialog.cpp" line="188"/>
+        <location filename="statsdialog.cpp" line="191"/>
+        <location filename="statsdialog.cpp" line="234"/>
         <source>Portability warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="147"/>
-        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="193"/>
+        <location filename="statsdialog.cpp" line="235"/>
         <source>Performance warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="149"/>
-        <location filename="statsdialog.cpp" line="190"/>
+        <location filename="statsdialog.cpp" line="195"/>
+        <location filename="statsdialog.cpp" line="236"/>
         <source>Information messages</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
+<context>
+    <name>ThreadDetails</name>
+    <message>
+        <location filename="threaddetails.ui" line="14"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>ThreadResult</name>
     <message>
-        <location filename="threadresult.cpp" line="54"/>
+        <location filename="threadresult.cpp" line="47"/>
         <source>%1 of %2 files checked</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2639,7 +3148,7 @@ Määrittääksesi minkä tyyppisiä virheitä näytetään, avaa näkymä valik
 <context>
     <name>TranslationHandler</name>
     <message>
-        <location filename="translationhandler.cpp" line="145"/>
+        <location filename="translationhandler.cpp" line="130"/>
         <source>Failed to change the user interface language:
 
 %1
@@ -2648,7 +3157,7 @@ The user interface language has been reset to English. Open the Preferences-dial
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="151"/>
+        <location filename="translationhandler.cpp" line="136"/>
         <source>Cppcheck</source>
         <translation type="unfinished">Cppcheck</translation>
     </message>
@@ -2656,7 +3165,7 @@ The user interface language has been reset to English. Open the Preferences-dial
 <context>
     <name>TxtReport</name>
     <message>
-        <location filename="txtreport.cpp" line="73"/>
+        <location filename="txtreport.cpp" line="74"/>
         <source>inconclusive</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2664,12 +3173,12 @@ The user interface language has been reset to English. Open the Preferences-dial
 <context>
     <name>toFilterString</name>
     <message>
-        <location filename="common.cpp" line="52"/>
+        <location filename="common.cpp" line="58"/>
         <source>All supported files (%1)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="common.cpp" line="57"/>
+        <location filename="common.cpp" line="63"/>
         <source>All files (%1)</source>
         <translation type="unfinished"></translation>
     </message>
diff --git a/gui/cppcheck_fr.ts b/gui/cppcheck_fr.ts
index e9d3603954c..82e0ea2bf74 100644
--- a/gui/cppcheck_fr.ts
+++ b/gui/cppcheck_fr.ts
@@ -1,75 +1,87 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE TS>
-<TS version="2.1" language="fr_FR" sourcelanguage="en_GB">
+<TS version="2.1" language="fr_FR">
 <context>
     <name>About</name>
     <message>
+        <location filename="about.ui" line="14"/>
         <source>About Cppcheck</source>
         <translation>A propos</translation>
     </message>
     <message>
+        <location filename="about.ui" line="64"/>
         <source>Version %1</source>
         <translation>Version %1</translation>
     </message>
     <message>
+        <location filename="about.ui" line="71"/>
         <source>Cppcheck - A tool for static C/C++ code analysis.</source>
         <translation>Cppcheck - Un outil d&apos;analyse statique de code C/C++.</translation>
     </message>
     <message>
+        <location filename="about.ui" line="91"/>
         <source>This program is licensed under the terms
 of the GNU General Public License version 3</source>
         <translation>Ce programme est sous licence GNU
 General Public License version 3</translation>
     </message>
     <message>
+        <location filename="about.ui" line="102"/>
         <source>Visit Cppcheck homepage at %1</source>
         <translation>Visitez le site Cppcheck : %1</translation>
     </message>
     <message>
-        <source>Copyright © 2007-2019 Cppcheck team.</source>
+        <location filename="about.ui" line="115"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PCRE&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PicoJSON&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;TinyXML2&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Boost&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <oldsource>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;pcre&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;picojson&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;tinyxml2&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
-&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul&gt;
-&lt;li&gt;tinyxml2&lt;/li&gt;
-&lt;li&gt;picojson&lt;/li&gt;
-&lt;li&gt;pcre&lt;/li&gt;
-&lt;li&gt;qt&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <location filename="about.ui" line="81"/>
+        <source>Copyright © 2007-%1 Cppcheck team.</source>
+        <oldsource>Copyright © 2007-2021 Cppcheck team.</oldsource>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>ApplicationDialog</name>
     <message>
+        <location filename="applicationdialog.ui" line="23"/>
         <source>Add an application</source>
         <translation>Ajouter une application</translation>
     </message>
     <message>
+        <location filename="applicationdialog.ui" line="138"/>
         <source>Browse</source>
         <translation>Parcourir</translation>
     </message>
     <message>
+        <location filename="applicationdialog.cpp" line="65"/>
         <source>Executable files (*.exe);;All files(*.*)</source>
         <translation>Fichier exécutable (*.exe);;Tous les fichiers(*.*)</translation>
     </message>
     <message>
+        <location filename="applicationdialog.cpp" line="68"/>
         <source>Select viewer application</source>
         <translation>Sélection de l&apos;application</translation>
     </message>
     <message>
+        <location filename="applicationdialog.cpp" line="83"/>
         <source>Cppcheck</source>
         <translation></translation>
     </message>
     <message>
+        <location filename="applicationdialog.ui" line="86"/>
         <source>&amp;Executable:</source>
         <translation>&amp;Exécutable : </translation>
     </message>
     <message>
+        <location filename="applicationdialog.ui" line="96"/>
         <source>&amp;Parameters:</source>
         <translation>&amp;Paramètres : </translation>
     </message>
     <message>
+        <location filename="applicationdialog.ui" line="41"/>
         <source>Here you can add an application that can open error files. Specify a name for the application, the application executable and command line parameters for the application.
 
 The following texts in parameters are replaced with appropriate values when application is executed:
@@ -94,40 +106,141 @@ Exécutable : kate
 Paramètres : -l(ligne) (fichier)</translation>
     </message>
     <message>
+        <location filename="applicationdialog.ui" line="76"/>
         <source>&amp;Name:</source>
         <translation>&amp;Nom : </translation>
     </message>
     <message>
+        <location filename="applicationdialog.cpp" line="84"/>
         <source>You must specify a name, a path and optionally parameters for the application!</source>
         <translation>Vous devez spécifier un nom, un chemin, et eventuellement des paramètres en option à l&apos;application !</translation>
     </message>
 </context>
+<context>
+    <name>ComplianceReportDialog</name>
+    <message>
+        <location filename="compliancereportdialog.ui" line="14"/>
+        <source>Compliance Report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="29"/>
+        <source>Project name</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="22"/>
+        <source>Project version</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="42"/>
+        <source>Coding Standard</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="50"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="55"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="60"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="70"/>
+        <source>List of files with md5 checksums</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="133"/>
+        <source>Compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="135"/>
+        <source>HTML files (*.html)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="176"/>
+        <location filename="compliancereportdialog.cpp" line="239"/>
+        <source>Save compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="177"/>
+        <source>Failed to import &apos;%1&apos; (%2), can not show files in compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>FileViewDialog</name>
     <message>
+        <location filename="fileviewdialog.cpp" line="53"/>
         <source>Could not find the file: %1</source>
         <translation>Ne trouve pas le fichier : %1</translation>
     </message>
     <message>
+        <location filename="fileviewdialog.cpp" line="57"/>
+        <location filename="fileviewdialog.cpp" line="71"/>
         <source>Cppcheck</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="fileviewdialog.cpp" line="67"/>
         <source>Could not read the file: %1</source>
         <translation>Ne peut pas lire le fichier : %1</translation>
     </message>
 </context>
+<context>
+    <name>HelpDialog</name>
+    <message>
+        <location filename="helpdialog.ui" line="14"/>
+        <source>Cppcheck GUI help</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="34"/>
+        <source>Contents</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="44"/>
+        <source>Index</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="84"/>
+        <source>Helpfile &apos;%1&apos; was not found</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="86"/>
+        <source>Cppcheck</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>LibraryAddFunctionDialog</name>
     <message>
+        <location filename="libraryaddfunctiondialog.ui" line="23"/>
         <source>Add function</source>
         <translation>Ajouter une fonction</translation>
     </message>
     <message>
+        <location filename="libraryaddfunctiondialog.ui" line="34"/>
         <source>Function name(s)</source>
         <translation>Nom(s) de la fonction</translation>
     </message>
     <message>
+        <location filename="libraryaddfunctiondialog.ui" line="44"/>
         <source>Number of arguments</source>
         <translation>Nombre d&apos;arguments</translation>
     </message>
@@ -135,98 +248,125 @@ Paramètres : -l(ligne) (fichier)</translation>
 <context>
     <name>LibraryDialog</name>
     <message>
+        <location filename="librarydialog.ui" line="14"/>
         <source>Library Editor</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="22"/>
         <source>Open</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="29"/>
         <source>Save</source>
         <translation type="unfinished">Sauvegarder</translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="62"/>
         <source>Functions</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="111"/>
         <source>Add</source>
         <translation type="unfinished">Ajouter</translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="204"/>
         <source>noreturn</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="212"/>
         <source>False</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="217"/>
         <source>True</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="222"/>
         <source>Unknown</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="232"/>
         <source>return value must be used</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="239"/>
         <source>ignore function in leaks checking</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="246"/>
         <source>Arguments</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="258"/>
         <source>Edit</source>
         <translation type="unfinished">Editer</translation>
     </message>
     <message>
+        <location filename="librarydialog.cpp" line="97"/>
+        <location filename="librarydialog.cpp" line="169"/>
         <source>Library files (*.cfg)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.cpp" line="99"/>
         <source>Open library file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="71"/>
         <source>Sort</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="131"/>
         <source>Filter:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="164"/>
         <source>Comments</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="36"/>
         <source>Save as</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.cpp" line="110"/>
+        <location filename="librarydialog.cpp" line="122"/>
+        <location filename="librarydialog.cpp" line="159"/>
         <source>Cppcheck</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.cpp" line="172"/>
         <source>Save the library as</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.cpp" line="123"/>
         <source>Failed to load %1. %2.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.cpp" line="111"/>
         <source>Cannot open file %1.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.cpp" line="160"/>
         <source>Cannot save file %1.</source>
         <translation type="unfinished"></translation>
     </message>
@@ -234,10 +374,12 @@ Paramètres : -l(ligne) (fichier)</translation>
 <context>
     <name>LibraryEditArgDialog</name>
     <message>
+        <location filename="libraryeditargdialog.ui" line="14"/>
         <source>Edit argument</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="20"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
 &lt;p&gt;Is bool value allowed? For instance result from comparison or from &apos;!&apos; operator.&lt;/p&gt;
 &lt;p&gt;Typically, set this if the argument is a pointer, size, etc.&lt;/p&gt;
@@ -247,10 +389,12 @@ Paramètres : -l(ligne) (fichier)</translation>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="28"/>
         <source>Not bool</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="35"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
 &lt;p&gt;Is a null parameter value allowed?&lt;/p&gt;
 &lt;p&gt;Typically this should be used on any pointer parameter that does not allow null.&lt;/p&gt;
@@ -260,58 +404,79 @@ Paramètres : -l(ligne) (fichier)</translation>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="43"/>
         <source>Not null</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="50"/>
         <source>Not uninit</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="57"/>
         <source>String</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="70"/>
         <source>Format string</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="92"/>
         <source>Min size of buffer</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="101"/>
+        <location filename="libraryeditargdialog.ui" line="203"/>
         <source>Type</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="109"/>
+        <location filename="libraryeditargdialog.ui" line="214"/>
         <source>None</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="114"/>
+        <location filename="libraryeditargdialog.ui" line="219"/>
         <source>argvalue</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="119"/>
+        <location filename="libraryeditargdialog.ui" line="224"/>
         <source>mul</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="124"/>
+        <location filename="libraryeditargdialog.ui" line="229"/>
         <source>strlen</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="132"/>
+        <location filename="libraryeditargdialog.ui" line="237"/>
         <source>Arg</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="159"/>
+        <location filename="libraryeditargdialog.ui" line="264"/>
         <source>Arg2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="194"/>
         <source>and</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="310"/>
         <source>Valid values</source>
         <translation type="unfinished"></translation>
     </message>
@@ -319,346 +484,560 @@ Paramètres : -l(ligne) (fichier)</translation>
 <context>
     <name>MainWindow</name>
     <message>
+        <location filename="mainwindow.ui" line="26"/>
+        <location filename="mainwindow.ui" line="688"/>
+        <location filename="mainwindow.cpp" line="466"/>
+        <location filename="mainwindow.cpp" line="670"/>
+        <location filename="mainwindow.cpp" line="755"/>
+        <location filename="mainwindow.cpp" line="860"/>
+        <location filename="mainwindow.cpp" line="882"/>
+        <location filename="mainwindow.cpp" line="1467"/>
+        <location filename="mainwindow.cpp" line="1596"/>
+        <location filename="mainwindow.cpp" line="1937"/>
+        <location filename="mainwindow.cpp" line="1945"/>
+        <location filename="mainwindow.cpp" line="1999"/>
+        <location filename="mainwindow.cpp" line="2008"/>
+        <location filename="mainwindow.cpp" line="2080"/>
+        <location filename="mainwindow.cpp" line="2168"/>
         <source>Cppcheck</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="84"/>
+        <source>Checking for updates</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="100"/>
+        <source>Hide</source>
+        <translation type="unfinished">Cacher</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="132"/>
         <source>&amp;File</source>
         <translation>&amp;Fichier</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="152"/>
         <source>&amp;View</source>
         <translation>&amp;Affichage</translation>
     </message>
     <message>
-        <source>&amp;Help</source>
-        <translation>&amp;Aide</translation>
+        <location filename="mainwindow.ui" line="164"/>
+        <location filename="mainwindow.ui" line="980"/>
+        <source>Report</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>&amp;Check</source>
-        <translation type="obsolete">&amp;Vérifier</translation>
+        <location filename="mainwindow.ui" line="199"/>
+        <source>&amp;Help</source>
+        <translation>&amp;Aide</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="254"/>
         <source>&amp;Edit</source>
         <translation>&amp;Édition</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="267"/>
         <source>Standard</source>
         <translation>Standard</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="315"/>
         <source>&amp;License...</source>
         <translation>&amp;Licence...</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="320"/>
         <source>A&amp;uthors...</source>
         <translation>A&amp;uteurs...</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="329"/>
         <source>&amp;About...</source>
         <translation>À &amp;Propos...</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="334"/>
         <source>&amp;Files...</source>
         <translation>&amp;Fichiers...</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="343"/>
         <source>Ctrl+F</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="352"/>
         <source>&amp;Directory...</source>
         <translation>&amp;Répertoires...</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="361"/>
         <source>Ctrl+D</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>&amp;Recheck files</source>
-        <translation type="obsolete">&amp;Revérifier les fichiers</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.ui" line="373"/>
         <source>Ctrl+R</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="391"/>
         <source>&amp;Stop</source>
         <translation>&amp;Arrêter</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="400"/>
         <source>Esc</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="409"/>
         <source>&amp;Save results to file...</source>
         <translation>&amp;Sauvegarder les résultats dans un fichier...</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="412"/>
         <source>Ctrl+S</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="417"/>
         <source>&amp;Quit</source>
         <translation>&amp;Quitter</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="429"/>
         <source>&amp;Clear results</source>
         <translation>&amp;Effacer les résultats</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="438"/>
         <source>&amp;Preferences</source>
         <translation>&amp;Préférences</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="479"/>
         <source>&amp;Check all</source>
         <translation>&amp;Tout cocher</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="484"/>
         <source>&amp;Uncheck all</source>
         <translation>&amp;Tout décocher</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="489"/>
         <source>Collapse &amp;all</source>
         <translation>&amp;Tout réduire</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="494"/>
         <source>&amp;Expand all</source>
         <translation>&amp;Tout dérouler</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="510"/>
         <source>&amp;Contents</source>
         <translation>&amp;Contenus</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="513"/>
         <source>Open the help contents</source>
         <translation>Ouvir l&apos;aide</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="516"/>
         <source>F1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>No suitable files found to check!</source>
-        <translation type="obsolete">Pas de fichiers trouvés à vérifier !</translation>
+        <location filename="mainwindow.ui" line="975"/>
+        <source>Compliance report...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="988"/>
+        <source>Normal</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="996"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1004"/>
+        <source>Misra C++ 2008</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1012"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1020"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1028"/>
+        <source>Misra C++ 2023</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1036"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1041"/>
+        <source>EULA...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1046"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Select directory to check</source>
-        <translation type="obsolete">Sélectionner le répertoire à vérifier</translation>
+        <location filename="mainwindow.ui" line="1049"/>
+        <source>Show thread details</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1648"/>
         <source>License</source>
         <translation>Licence</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1655"/>
         <source>Authors</source>
         <translation>Auteurs</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1675"/>
         <source>Save the report file</source>
         <translation>Sauvegarder le rapport</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1483"/>
+        <location filename="mainwindow.cpp" line="1682"/>
         <source>XML files (*.xml)</source>
         <translation>Fichiers XML (*.xml)</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1634"/>
+        <source>About</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1686"/>
         <source>Text files (*.txt)</source>
         <translation>Fichiers Texte (*.txt)</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1690"/>
         <source>CSV files (*.csv)</source>
         <translation>Fichiers CSV (*.csv)</translation>
     </message>
     <message>
-        <source>Cppcheck - %1</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
+        <location filename="mainwindow.ui" line="156"/>
         <source>&amp;Toolbars</source>
         <translation>&amp;Boite à outils</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="285"/>
         <source>Categories</source>
         <translation>Catégories</translation>
     </message>
     <message>
-        <source>Check files</source>
-        <translation type="obsolete">Vérifier les fichiers</translation>
-    </message>
-    <message>
-        <source>Check directory</source>
-        <translation type="obsolete">Vérifier un répertoire</translation>
-    </message>
-    <message>
-        <source>Stop checking</source>
-        <translation type="obsolete">Arrêter la vérification</translation>
-    </message>
-    <message>
-        <source>Style warnings</source>
-        <translation type="obsolete">Avertissement de style</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.ui" line="453"/>
+        <location filename="mainwindow.ui" line="456"/>
         <source>Show style warnings</source>
         <translation>Afficher les avertissements de style</translation>
     </message>
     <message>
-        <source>Errors</source>
-        <translation type="obsolete">Erreurs</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.ui" line="471"/>
+        <location filename="mainwindow.ui" line="474"/>
+        <location filename="mainwindow.cpp" line="2394"/>
         <source>Show errors</source>
         <translation>Afficher les erreurs</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="502"/>
         <source>&amp;Standard</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="505"/>
         <source>Standard items</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="521"/>
         <source>Toolbar</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="529"/>
         <source>&amp;Categories</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="532"/>
         <source>Error categories</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="537"/>
         <source>&amp;Open XML...</source>
         <translation>&amp;Ouvrir un fichier XML...</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="546"/>
         <source>Open P&amp;roject File...</source>
         <translation>Ouvrir un P&amp;rojet...</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="563"/>
         <source>&amp;New Project File...</source>
         <translation>&amp;Nouveau Projet...</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="571"/>
         <source>&amp;Log View</source>
         <translation>&amp;Journal</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="574"/>
         <source>Log View</source>
         <translation>Journal</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="582"/>
         <source>C&amp;lose Project File</source>
         <translation>F&amp;ermer le projet</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="590"/>
         <source>&amp;Edit Project File...</source>
         <translation>&amp;Editer le projet</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="602"/>
         <source>&amp;Statistics</source>
         <translation>Statistiques</translation>
     </message>
     <message>
-        <source>Warnings</source>
-        <translation type="obsolete">Avertissements</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.ui" line="617"/>
+        <location filename="mainwindow.ui" line="620"/>
+        <location filename="mainwindow.cpp" line="2395"/>
         <source>Show warnings</source>
         <translation>Afficher les avertissements</translation>
     </message>
     <message>
-        <source>Performance warnings</source>
-        <translation type="obsolete">Avertissements de performance</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.ui" line="635"/>
+        <location filename="mainwindow.ui" line="638"/>
         <source>Show performance warnings</source>
         <translation>Afficher les avertissements de performance</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="646"/>
         <source>Show &amp;hidden</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="986"/>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Information</source>
         <translation>Information</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="661"/>
         <source>Show information messages</source>
         <translation>Afficher les messages d&apos;information</translation>
     </message>
     <message>
-        <source>Portability</source>
-        <translation type="obsolete">Portabilité</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.ui" line="676"/>
         <source>Show portability warnings</source>
         <translation>Afficher les problèmes de portabilité</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="756"/>
         <source>You must close the project file before selecting new files or directories!</source>
         <translation>Vous devez d&apos;abord fermer le projet avant de choisir des fichiers/répertoires</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1485"/>
         <source>Open the report file</source>
         <translation>Ouvrir le rapport</translation>
     </message>
     <message>
-        <source>Checking is running.
-
-Do you want to stop the checking and exit Cppcheck?</source>
-        <translation type="obsolete">Vérification en cours.
-
-Voulez-vous arrêter la vérification et quitter CppCheck ?</translation>
+        <location filename="mainwindow.cpp" line="1713"/>
+        <source>Cannot generate a compliance report right now, an analysis must finish successfully. Try to reanalyze the code and ensure there are no critical errors.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1820"/>
         <source>Project files (*.cppcheck);;All files(*.*)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1822"/>
         <source>Select Project File</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1946"/>
+        <source>To check the project using addons, you need a build directory.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1978"/>
+        <source>Failed to open file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1981"/>
+        <source>Unknown project file format</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1984"/>
+        <source>Failed to import project file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2000"/>
+        <source>Failed to import &apos;%1&apos;: %2
+
+Analysis is stopped.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2009"/>
+        <source>Failed to import &apos;%1&apos; (%2), analysis is stopped</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2035"/>
         <source>Select Project Filename</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="2081"/>
         <source>No project file loaded</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="2325"/>
+        <source>Install</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2329"/>
+        <source>New version available: %1. %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2367"/>
+        <source>Show Mandatory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2368"/>
+        <source>Show Required</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2369"/>
+        <source>Show Advisory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2370"/>
+        <source>Show Document</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2387"/>
+        <source>Show L1</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2388"/>
+        <source>Show L2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2389"/>
+        <source>Show L3</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2396"/>
+        <source>Show style</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2397"/>
+        <source>Show portability</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2398"/>
+        <source>Show performance</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2399"/>
+        <source>Show information</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="461"/>
         <source>There was a problem with loading the editor application settings.
 
 This is probably because the settings were changed between the Cppcheck versions. Please check (and fix) the editor application settings, otherwise the editor program might not start correctly.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="714"/>
         <source>&amp;Filter</source>
         <translation>&amp;Filtre</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="717"/>
         <source>Filter results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="157"/>
+        <location filename="mainwindow.cpp" line="1782"/>
         <source>Quick Filter:</source>
         <translation>Filtre rapide : </translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="861"/>
         <source>Found project file: %1
 
 Do you want to load this project file instead?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="242"/>
+        <location filename="mainwindow.cpp" line="1784"/>
+        <location filename="mainwindow.cpp" line="1850"/>
+        <location filename="mainwindow.cpp" line="2048"/>
         <source>Project:</source>
         <translation>Projet : </translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="2163"/>
         <source>The project file
 
 %1
@@ -669,138 +1048,145 @@ Do you want to remove the file from the recently used projects -list?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="304"/>
         <source>Filter</source>
         <translation>Filtre</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="733"/>
         <source>Windows 32-bit ANSI</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="741"/>
         <source>Windows 32-bit Unicode</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="749"/>
         <source>Unix 32-bit</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="757"/>
         <source>Unix 64-bit</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="765"/>
         <source>Windows 64-bit</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Current results will be cleared.
-
-Opening a new XML file will clear current results.Do you want to proceed?</source>
-        <translation type="vanished">Les résultats courant seront effacés.
-
-L&apos;ouverture d&apos;un nouveau fichier XML effacera les resultats. Voulez-vous confirmar l&apos;opération ?</translation>
-    </message>
-    <message>
-        <source>Select files to check</source>
-        <translation type="obsolete">Sélectionner les fichiers à vérifier</translation>
-    </message>
-    <message>
+        <location filename="main.cpp" line="115"/>
         <source>Cppcheck GUI - Command line parameters</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="214"/>
         <source>C++ standard</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
         <source>Error</source>
         <translation>Erreur</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="995"/>
         <source>File not found</source>
         <translation>Fichier introuvable</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="998"/>
         <source>Bad XML</source>
         <translation>Mauvais fichier XML</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1001"/>
         <source>Missing attribute</source>
         <translation>Attribut manquant</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1004"/>
         <source>Bad attribute value</source>
         <translation>Mauvaise valeur d&apos;attribut</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Failed to load the selected library &apos;%1&apos;.
 %2</source>
         <translation>Echec lors du chargement de la bibliothèque &apos;%1&apos;.
 %2</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1007"/>
         <source>Unsupported format</source>
         <translation>Format non supporté</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="986"/>
         <source>The library &apos;%1&apos; contains unknown elements:
 %2</source>
         <translation>La bibliothèque &apos;%1&apos; contient des éléments inconnus:
 %2</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1010"/>
         <source>Duplicate platform type</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1013"/>
         <source>Platform type redefined</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="859"/>
         <source>&amp;Print...</source>
         <translation> &amp;Imprimer...</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="862"/>
         <source>Print the Current Report</source>
         <translation>Imprimer le rapport</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="867"/>
         <source>Print Pre&amp;view...</source>
         <translation>Apercu d&apos;impression...</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="870"/>
         <source>Open a Print Preview Dialog for the Current Results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="878"/>
         <source>Open library editor</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Auto-detect language</source>
-        <translation type="obsolete">Auto-detection du langage</translation>
-    </message>
-    <message>
-        <source>&amp;Recheck modified files</source>
-        <translation type="obsolete">&amp;Revérifier les fichiers modifiés</translation>
-    </message>
-    <message>
-        <source>&amp;Recheck all files</source>
-        <translation type="obsolete">&amp;Revérifier tous les fichiers</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.cpp" line="1019"/>
         <source>Unknown element</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Unknown issue</source>
+        <location filename="mainwindow.cpp" line="1019"/>
+        <source>Unknown element</source>
+        <oldsource>Unknown issue</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select configuration</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="main.cpp" line="100"/>
         <source>Cppcheck GUI.
 
 Syntax:
@@ -818,202 +1204,296 @@ Options:
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
+        <location filename="mainwindow.cpp" line="1938"/>
         <source>Build dir &apos;%1&apos; does not exist, create it?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="337"/>
+        <location filename="mainwindow.ui" line="340"/>
         <source>Analyze files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="355"/>
+        <location filename="mainwindow.ui" line="358"/>
         <source>Analyze directory</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="370"/>
         <source>&amp;Reanalyze modified files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="394"/>
+        <location filename="mainwindow.ui" line="397"/>
         <source>Stop analysis</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1673"/>
         <source>XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="671"/>
         <source>No suitable files found to analyze!</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="776"/>
         <source>Select files to analyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="791"/>
         <source>Select directory to analyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select the configuration that will be analyzed</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="883"/>
         <source>Found project files from the directory.
 
 Do you want to proceed analysis without using any of these project files?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1016"/>
+        <source>Duplicate define</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1035"/>
+        <source>File not found: &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1058"/>
+        <source>Failed to load/setup addon %1: %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <source>Failed to load %1 - %2
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
+        <source>%1
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1592"/>
         <source>Analyzer is running.
 
 Do you want to stop the analysis and exit Cppcheck?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="210"/>
         <source>A&amp;nalyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="226"/>
         <source>&amp;C standard</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="382"/>
         <source>Reanal&amp;yze all files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="420"/>
+        <source>Ctrl+Q</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="450"/>
         <source>Style war&amp;nings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="468"/>
         <source>E&amp;rrors</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="549"/>
+        <source>Ctrl+Shift+O</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="558"/>
         <source>Sh&amp;ow Scratchpad...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="566"/>
+        <source>Ctrl+Shift+N</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="614"/>
         <source>&amp;Warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="632"/>
         <source>Per&amp;formance warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="658"/>
         <source>&amp;Information</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="673"/>
         <source>&amp;Portability</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="691"/>
         <source>Show Cppcheck results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="703"/>
         <source>Clang</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="706"/>
         <source>Show Clang results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="773"/>
         <source>P&amp;latforms</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="787"/>
         <source>C++&amp;11</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="798"/>
         <source>C&amp;99</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="806"/>
         <source>&amp;Posix</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="814"/>
         <source>C&amp;11</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="846"/>
         <source>&amp;C89</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="854"/>
         <source>&amp;C++03</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="875"/>
         <source>&amp;Library Editor...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="886"/>
         <source>&amp;Auto-detect language</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="894"/>
         <source>&amp;Enforce C++</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="902"/>
         <source>E&amp;nforce C</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="913"/>
         <source>C++14</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Failed to import &apos;%1&apos;, analysis is stopped</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
+        <location filename="mainwindow.cpp" line="2033"/>
         <source>Project files (*.cppcheck)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="921"/>
         <source>Reanalyze and check library</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="929"/>
         <source>Check configuration (defines, includes)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="937"/>
         <source>C++17</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="948"/>
         <source>C++20</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="770"/>
         <source>C/C++ Source</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="771"/>
         <source>Compile database</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="772"/>
         <source>Visual Studio</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="773"/>
         <source>Borland C++ Builder 6</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1468"/>
         <source>Current results will be cleared.
 
 Opening a new XML file will clear current results.
@@ -1024,26 +1504,32 @@ Do you want to proceed?</source>
 <context>
     <name>NewSuppressionDialog</name>
     <message>
+        <location filename="newsuppressiondialog.ui" line="17"/>
         <source>New suppression</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="newsuppressiondialog.ui" line="25"/>
         <source>Error ID</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="newsuppressiondialog.ui" line="32"/>
         <source>File name</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="newsuppressiondialog.ui" line="42"/>
         <source>Line number</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="newsuppressiondialog.ui" line="52"/>
         <source>Symbol name</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="newsuppressiondialog.cpp" line="83"/>
         <source>Edit suppression</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1051,472 +1537,761 @@ Do you want to proceed?</source>
 <context>
     <name>Platforms</name>
     <message>
+        <location filename="platforms.cpp" line="39"/>
         <source>Unix 32-bit</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="platforms.cpp" line="40"/>
         <source>Unix 64-bit</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="platforms.cpp" line="41"/>
         <source>Windows 32-bit ANSI</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="platforms.cpp" line="42"/>
         <source>Windows 32-bit Unicode</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="platforms.cpp" line="43"/>
         <source>Windows 64-bit</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="platforms.cpp" line="38"/>
         <source>Native</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
-<context>
-    <name>Project</name>
-    <message>
-        <source>Could not read the project file.</source>
-        <translation type="obsolete">Impossible de lire le fichier projet.</translation>
-    </message>
-    <message>
-        <source>Could not write the project file.</source>
-        <translation type="obsolete">Impossible d&apos;écrire dans le fichier projet.</translation>
-    </message>
-</context>
 <context>
     <name>ProjectFile</name>
     <message>
+        <location filename="projectfile.ui" line="14"/>
         <source>Project File</source>
         <translation>Fichier Projet</translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="147"/>
         <source>Paths:</source>
         <translation>Chemins : </translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="221"/>
         <source>Defines:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Project</source>
-        <translation type="obsolete">Projet</translation>
-    </message>
-    <message>
+        <location filename="projectfile.ui" line="181"/>
+        <location filename="projectfile.ui" line="296"/>
         <source>Add...</source>
         <translation>Ajouter...</translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="188"/>
+        <location filename="projectfile.ui" line="303"/>
+        <location filename="projectfile.ui" line="690"/>
         <source>Edit</source>
         <translation>Editer</translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="195"/>
+        <location filename="projectfile.ui" line="310"/>
+        <location filename="projectfile.ui" line="697"/>
+        <location filename="projectfile.ui" line="740"/>
         <source>Remove</source>
         <translation>Supprimer</translation>
     </message>
     <message>
-        <source>Includes</source>
-        <translation type="obsolete">Inclusions</translation>
-    </message>
-    <message>
-        <source>Include directories:</source>
-        <translation type="obsolete">Inclure les répertoires</translation>
-    </message>
-    <message>
-        <source>Root:</source>
-        <translation type="obsolete">Répertoire racine</translation>
-    </message>
-    <message>
+        <location filename="projectfile.ui" line="330"/>
         <source>Up</source>
         <translation>Monter</translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="337"/>
         <source>Down</source>
         <translation>Descendre</translation>
     </message>
     <message>
-        <source>Exclude</source>
-        <translation type="obsolete">Exclure</translation>
-    </message>
-    <message>
-        <source>Libraries:</source>
-        <translation type="obsolete">Bibliothèques</translation>
-    </message>
-    <message>
+        <location filename="projectfile.ui" line="722"/>
         <source>Suppressions</source>
         <translation>Suppressions</translation>
     </message>
     <message>
-        <source>Suppression list:</source>
-        <translation type="obsolete">Liste de suppressions</translation>
-    </message>
-    <message>
+        <location filename="projectfile.ui" line="733"/>
         <source>Add</source>
         <translation>Ajouter</translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="389"/>
         <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="890"/>
         <source>...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="265"/>
         <source>Include Paths:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="24"/>
         <source>Paths and Defines</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="73"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;You have a choice:&lt;/p&gt;&lt;p&gt; * Analyze all Debug and Release configurations&lt;/p&gt;&lt;p&gt; * Only analyze the first matching Debug configuration&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="76"/>
         <source>Analyze all Visual Studio configurations</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="633"/>
         <source>Root path:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="649"/>
         <source>Warning tags (separated by semicolon)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="409"/>
         <source>Cppcheck build dir (whole program analysis, incremental analysis, statistics, etc)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="113"/>
+        <source>Selected VS Configurations</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="362"/>
+        <source>Types and Functions</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="380"/>
         <source>Libraries</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="432"/>
+        <source>Parser</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="438"/>
+        <source>Cppcheck (built in)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="497"/>
+        <source>Check that each class has a safe public interface</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="513"/>
+        <source>Limit analysis</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="786"/>
+        <location filename="projectfile.ui" line="792"/>
         <source>Addons</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="798"/>
+        <source>Note: Addons require &lt;a href=&quot;https://www.python.org/&quot;&gt;Python&lt;/a&gt; being installed.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="808"/>
         <source>Y2038</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="815"/>
         <source>Thread safety</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="825"/>
         <source>Coding standards</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Cert</source>
+        <location filename="projectfile.ui" line="937"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="946"/>
+        <source>CERT-INT35-C:  int precision (if size equals precision, you can leave empty)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="965"/>
+        <source>Autosar</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="988"/>
+        <source>Bug hunting</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="1011"/>
         <source>Clang analyzer</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="1004"/>
         <source>Clang-tidy</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="60"/>
+        <location filename="projectfile.ui" line="422"/>
+        <location filename="projectfile.ui" line="616"/>
         <source>Browse...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="231"/>
         <source>Defines must be separated by a semicolon. Example: DEF1;DEF2=5;DEF3=int</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Checking</source>
+        <location filename="projectfile.ui" line="368"/>
+        <source>Platform</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="415"/>
+        <source>This is a workfolder that Cppcheck will use for various purposes.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Platform</source>
+        <location filename="projectfile.ui" line="448"/>
+        <source>Clang (experimental)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="458"/>
+        <source>Check level</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="464"/>
+        <source>Reduced -- meant for usage where developer wants results directly. Limited and faster analysis with fewer results.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="471"/>
+        <source>Normal -- meant for normal analysis in CI. Analysis should finish in reasonable time.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="478"/>
+        <source>Exhaustive -- meant for nightly builds etc. Analysis time can be longer (10x slower than compilation is OK).</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="494"/>
+        <source>If you want to design your classes to be as flexible and robust as possible then the public interface must be very robust. Cppcheck will asumme that arguments can take *any* value.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="519"/>
+        <source>Check code in headers  (should be ON normally. if you want a limited quick analysis then turn this OFF)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="572"/>
+        <source>Max recursion in template instantiation</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="607"/>
+        <source>Premium License</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="627"/>
         <source>Warning options</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Addons and tools</source>
+        <location filename="projectfile.ui" line="639"/>
+        <source>Filepaths in warnings will be relative to this path</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="655"/>
+        <source>If tags are added, you will be able to right click on warnings and set one of these tags. You can manually categorize warnings.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="665"/>
+        <source>Exclude source files</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="676"/>
+        <source>Exclude folder...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="683"/>
+        <source>Exclude file...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="765"/>
+        <source>Enable inline suppressions</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="833"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="841"/>
+        <source>2012</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>MISRA C 2012</source>
+        <location filename="projectfile.ui" line="846"/>
+        <location filename="projectfile.ui" line="914"/>
+        <source>2023</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Misra rule texts</source>
+        <location filename="projectfile.ui" line="851"/>
+        <source>2025</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="876"/>
+        <source>MISRA rule texts</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="883"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>External tools</source>
+        <location filename="projectfile.ui" line="901"/>
+        <source>Misra C++</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</source>
+        <location filename="projectfile.ui" line="909"/>
+        <source>2008</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Undefines:</source>
+        <location filename="projectfile.ui" line="958"/>
+        <source>Cert C++</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Undefines must be separated by a semicolon. Example: UNDEF1;UNDEF2;UNDEF3</source>
+        <location filename="projectfile.ui" line="972"/>
+        <source>Safety profiles (defined in C++ core guidelines)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Analysis</source>
+        <location filename="projectfile.ui" line="982"/>
+        <source>Bug hunting (Premium)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Check code in headers  (slower analysis, more results)</source>
+        <location filename="projectfile.ui" line="998"/>
+        <source>External tools</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Check code in unused templates  (slower and less accurate analysis)</source>
+        <location filename="projectfile.ui" line="30"/>
+        <source>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Max CTU depth</source>
+        <location filename="projectfile.ui" line="242"/>
+        <source>Undefines:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="252"/>
+        <source>Undefines must be separated by a semicolon. Example: UNDEF1;UNDEF2;UNDEF3</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Exclude source files in paths</source>
+        <location filename="projectfile.ui" line="403"/>
+        <location filename="projectfile.ui" line="488"/>
+        <source>Analysis</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="529"/>
+        <source>Check code in unused templates (should be ON normally, however in theory you can safely ignore warnings in unused templates)</source>
+        <oldsource>Check code in unused templates  (slower and less accurate analysis)</oldsource>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="541"/>
+        <source>Max CTU depth</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>ProjectFileDialog</name>
     <message>
+        <location filename="projectfiledialog.cpp" line="138"/>
         <source>Project file: %1</source>
         <translation>Fichier projet : %1</translation>
     </message>
     <message>
+        <location filename="projectfiledialog.cpp" line="851"/>
         <source>Select include directory</source>
         <translation>Selectionner un répertoire à inclure</translation>
     </message>
     <message>
+        <location filename="projectfiledialog.cpp" line="871"/>
         <source>Select directory to ignore</source>
         <translation>Selectionner un répertoire à ignorer</translation>
     </message>
     <message>
+        <location filename="projectfiledialog.cpp" line="831"/>
         <source>Select a directory to check</source>
         <translation>Selectionner un répertoire à vérifier</translation>
     </message>
     <message>
+        <location filename="projectfiledialog.cpp" line="590"/>
         <source>Select Cppcheck build dir</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfiledialog.cpp" line="632"/>
         <source>Import Project</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfiledialog.cpp" line="461"/>
         <source>Clang-tidy (not found)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>(no rule texts file)</source>
+        <location filename="projectfiledialog.cpp" line="396"/>
+        <source>Note: Open source Cppcheck does not fully implement Misra C 2012</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Select MISRA rule texts file</source>
+        <location filename="projectfiledialog.cpp" line="879"/>
+        <source>Source files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Misra rule texts file (%1)</source>
+        <location filename="projectfiledialog.cpp" line="880"/>
+        <source>All files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Visual Studio</source>
+        <location filename="projectfiledialog.cpp" line="881"/>
+        <source>Exclude file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Compile database</source>
+        <location filename="projectfiledialog.cpp" line="964"/>
+        <source>Select MISRA rule texts file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Borland C++ Builder 6</source>
+        <location filename="projectfiledialog.cpp" line="966"/>
+        <source>MISRA rule texts file (%1)</source>
         <translation type="unfinished"></translation>
     </message>
-</context>
-<context>
-    <name>QDialogButtonBox</name>
     <message>
-        <source>OK</source>
-        <translation>OK</translation>
-    </message>
-    <message>
-        <source>Cancel</source>
-        <translation>Annuler</translation>
+        <location filename="projectfiledialog.cpp" line="629"/>
+        <source>Visual Studio</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Close</source>
-        <translation>Fermer</translation>
+        <location filename="projectfiledialog.cpp" line="630"/>
+        <source>Compile database</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Save</source>
-        <translation>Sauvegarder</translation>
+        <location filename="projectfiledialog.cpp" line="631"/>
+        <source>Borland C++ Builder 6</source>
+        <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>QObject</name>
     <message>
+        <location filename="translationhandler.cpp" line="117"/>
         <source>Language file %1 not found!</source>
         <translation>Fichier de langue %1 non trouvé !</translation>
     </message>
     <message>
+        <location filename="translationhandler.cpp" line="122"/>
         <source>Failed to load translation for language %1 from file %2</source>
         <translation>Erreur lors du chargement de la langue %1 depuis le fichier %2</translation>
     </message>
     <message>
+        <location filename="translationhandler.cpp" line="91"/>
         <source>Unknown language specified!</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="cppchecklibrarydata.cpp" line="38"/>
         <source>line %1: Unhandled element %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="cppchecklibrarydata.cpp" line="43"/>
+        <source>line %1: Mandatory attribute &apos;%2&apos; missing in &apos;%3&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="284"/>
         <source> (Not found)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstylecontrols.cpp" line="76"/>
         <source>Thin</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstylecontrols.cpp" line="78"/>
         <source>ExtraLight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstylecontrols.cpp" line="80"/>
         <source>Light</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstylecontrols.cpp" line="82"/>
         <source>Normal</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstylecontrols.cpp" line="84"/>
         <source>Medium</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstylecontrols.cpp" line="86"/>
         <source>DemiBold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstylecontrols.cpp" line="88"/>
         <source>Bold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstylecontrols.cpp" line="90"/>
         <source>ExtraBold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstylecontrols.cpp" line="92"/>
         <source>Black</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="80"/>
         <source>Editor Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="83"/>
         <source>Editor Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="86"/>
         <source>Highlight Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="89"/>
         <source>Line Number Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="92"/>
         <source>Line Number Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="95"/>
         <source>Keyword Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="98"/>
         <source>Keyword Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="104"/>
         <source>Class Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="107"/>
         <source>Quote Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="110"/>
         <source>Quote Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="113"/>
         <source>Comment Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="116"/>
         <source>Comment Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="119"/>
         <source>Symbol Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="122"/>
         <source>Symbol Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="125"/>
         <source>Symbol Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="141"/>
         <source>Set to Default Light</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="143"/>
         <source>Set to Default Dark</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="101"/>
         <source>Class Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
+    <message>
+        <location filename="resultstree.cpp" line="113"/>
+        <source>File</source>
+        <translation type="unfinished">Fichier</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="114"/>
+        <source>Line</source>
+        <translation type="unfinished">Ligne</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="115"/>
+        <source>Severity</source>
+        <translation type="unfinished">Sévérité</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="116"/>
+        <source>Classification</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="117"/>
+        <source>Level</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="118"/>
+        <source>Inconclusive</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="119"/>
+        <source>Summary</source>
+        <translation type="unfinished">Résumé</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="120"/>
+        <source>Id</source>
+        <translation type="unfinished">Id</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="121"/>
+        <source>Guideline</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="122"/>
+        <source>Rule</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="123"/>
+        <source>Since date</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="124"/>
+        <source>Tags</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="125"/>
+        <source>CWE</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>QPlatformTheme</name>
     <message>
+        <location filename="translationhandler.cpp" line="41"/>
         <source>OK</source>
         <translation type="unfinished">OK</translation>
     </message>
     <message>
+        <location filename="translationhandler.cpp" line="42"/>
         <source>Cancel</source>
         <translation type="unfinished">Annuler</translation>
     </message>
     <message>
+        <location filename="translationhandler.cpp" line="43"/>
         <source>Close</source>
         <translation type="unfinished">Fermer</translation>
     </message>
     <message>
+        <location filename="translationhandler.cpp" line="44"/>
         <source>Save</source>
         <translation type="unfinished">Sauvegarder</translation>
     </message>
@@ -1525,37 +2300,28 @@ Do you want to proceed?</source>
     <name>ResultsTree</name>
     <message>
         <source>File</source>
-        <translation type="unfinished">Fichier</translation>
+        <translation type="obsolete">Fichier</translation>
     </message>
     <message>
         <source>Severity</source>
-        <translation type="unfinished">Sévérité</translation>
+        <translation type="obsolete">Sévérité</translation>
     </message>
     <message>
         <source>Line</source>
-        <translation type="unfinished">Ligne</translation>
+        <translation type="obsolete">Ligne</translation>
     </message>
     <message>
         <source>Undefined file</source>
-        <translation>Fichier indéterminé</translation>
-    </message>
-    <message>
-        <source>Copy filename</source>
-        <translation type="obsolete">Copier le nom du fichier</translation>
-    </message>
-    <message>
-        <source>Copy full path</source>
-        <translation type="obsolete">Copier le chemin complet</translation>
-    </message>
-    <message>
-        <source>Copy message</source>
-        <translation type="obsolete">Copier le message</translation>
+        <translation type="vanished">Fichier indéterminé</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="744"/>
+        <location filename="resultstree.cpp" line="758"/>
         <source>Cppcheck</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="822"/>
         <source>Could not start %1
 
 Please check the application path and parameters are correct.</source>
@@ -1564,64 +2330,82 @@ Please check the application path and parameters are correct.</source>
 Merci de vérifier que le chemin de l&apos;application et que les paramètres sont corrects.</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="355"/>
         <source>style</source>
         <translation>erreur de style</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="358"/>
         <source>error</source>
         <translation>erreur</translation>
     </message>
     <message>
         <source>Summary</source>
-        <translation>Résumé</translation>
+        <translation type="vanished">Résumé</translation>
     </message>
     <message>
         <source>Hide</source>
-        <translation>Cacher</translation>
+        <translation type="vanished">Cacher</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="779"/>
         <source>Could not find the file!</source>
         <translation>Fichier introuvable !</translation>
     </message>
     <message>
-        <source>Could not find file:
-%1
-Please select the directory where file is located.</source>
-        <translation type="obsolete">Fichier introuvable:
-%1
-Veuillez sélectionner le répertoire où est situé le fichier.</translation>
-    </message>
-    <message>
+        <location filename="resultstree.cpp" line="844"/>
         <source>Select Directory</source>
         <translation>Selectionner dossier</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="361"/>
         <source>warning</source>
         <translation>avertissement</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="364"/>
         <source>performance</source>
         <translation>performance</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="367"/>
         <source>portability</source>
         <translation>portabilité</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="370"/>
         <source>information</source>
         <translation>information</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="373"/>
         <source>debug</source>
         <translation>débogage</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="376"/>
+        <source>internal</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="667"/>
+        <source>Recheck %1 file(s)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="669"/>
+        <source>Hide %1 result(s)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="745"/>
         <source>No editor application configured.
 
 Configure the editor application for Cppcheck in preferences/Applications.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="759"/>
         <source>No default editor application selected.
 
 Please select the default editor application in preferences/Applications.</source>
@@ -1629,65 +2413,64 @@ Please select the default editor application in preferences/Applications.</sourc
     </message>
     <message>
         <source>Id</source>
-        <translation>Id</translation>
-    </message>
-    <message>
-        <source>Copy message id</source>
-        <translation type="obsolete">Copier l&apos;identifiant du message</translation>
+        <translation type="vanished">Id</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="670"/>
         <source>Hide all with id</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="671"/>
         <source>Open containing folder</source>
         <translation>Ouvrir l&apos;emplacement du fichier</translation>
     </message>
-    <message>
-        <source>Inconclusive</source>
-        <translation type="unfinished"></translation>
-    </message>
     <message>
         <source>Recheck</source>
-        <translation>Revérifier</translation>
+        <translation type="vanished">Revérifier</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="307"/>
         <source>note</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="692"/>
         <source>Suppress selected id(s)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="712"/>
         <source>Tag</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="714"/>
         <source>No tag</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Since date</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
+        <location filename="resultstree.cpp" line="836"/>
         <source>Could not find file:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="840"/>
         <source>Please select the folder &apos;%1&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="841"/>
         <source>Select Directory &apos;%1&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="843"/>
         <source>Please select the directory where file is located.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="668"/>
         <source>Copy</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1695,84 +2478,122 @@ Please select the default editor application in preferences/Applications.</sourc
 <context>
     <name>ResultsView</name>
     <message>
+        <location filename="resultsview.ui" line="26"/>
         <source>Results</source>
         <translation>Résultats</translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="361"/>
         <source>Cppcheck</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="351"/>
         <source>No errors found.</source>
         <translation>Pas d&apos;erreurs trouvées.</translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="358"/>
         <source>Errors were found, but they are configured to be hidden.
 To toggle what kind of errors are shown, open view menu.</source>
         <translation>Des erreurs ont été trouvées mais sont configurées pour rester cachées.
 Pour configurer les erreurs affichées, ouvrez le menu d&apos;affichage.</translation>
     </message>
     <message>
-        <source>No errors found, nothing to save.</source>
-        <translation>Pas d&apos;erreurs trouvées, rien à sauvegarder.</translation>
+        <location filename="resultsview.cpp" line="549"/>
+        <source>Analysis was stopped</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Failed to save the report.</source>
-        <translation>Erreur lors de la sauvegarde du rapport.</translation>
+        <location filename="resultsview.cpp" line="563"/>
+        <source>There was a critical error with id &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Failed to read the report.</source>
-        <translation>Erreur lors de la lecture du rapport</translation>
+        <location filename="resultsview.cpp" line="565"/>
+        <source>when checking %1</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Summary</source>
-        <translation type="obsolete">Résumé</translation>
+        <location filename="resultsview.cpp" line="567"/>
+        <source>when checking a file</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Message</source>
-        <translation type="obsolete">Message</translation>
+        <location filename="resultsview.cpp" line="568"/>
+        <source>Analysis was aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="237"/>
+        <location filename="resultsview.cpp" line="245"/>
+        <source>Failed to save the report.</source>
+        <translation>Erreur lors de la sauvegarde du rapport.</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="421"/>
+        <source>Failed to read the report.</source>
+        <translation>Erreur lors de la lecture du rapport</translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="326"/>
         <source>%p% (%1 of %2 files checked)</source>
         <translation>%p% (%1 fichiers sur %2 vérifiés)</translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="465"/>
         <source>Id</source>
         <translation>Id</translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="255"/>
         <source>Print Report</source>
         <translation>Imprimer le rapport</translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="274"/>
         <source>No errors found, nothing to print.</source>
         <translation>Aucune erreur trouvée. Il n&apos;y a rien à imprimer</translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="460"/>
         <source>First included by</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="409"/>
         <source>XML format version 1 is no longer supported.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultsview.ui" line="60"/>
+        <source>Critical errors</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.ui" line="92"/>
         <source>Analysis Log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultsview.ui" line="114"/>
         <source>Warning Details</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="539"/>
         <source>Clear Log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="540"/>
         <source>Copy this Log entry</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="541"/>
         <source>Copy complete Log</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1780,22 +2601,27 @@ Pour configurer les erreurs affichées, ouvrez le menu d&apos;affichage.</transl
 <context>
     <name>ScratchPad</name>
     <message>
+        <location filename="scratchpad.ui" line="14"/>
         <source>Scratchpad</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="scratchpad.ui" line="71"/>
         <source>filename</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="scratchpad.ui" line="78"/>
         <source>Check</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="scratchpad.ui" line="20"/>
         <source>Copy or write some C/C++ code here:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="scratchpad.ui" line="37"/>
         <source>Optionally enter a filename (mainly for automatic language detection) and click on &quot;Check&quot;:</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1803,162 +2629,195 @@ Pour configurer les erreurs affichées, ouvrez le menu d&apos;affichage.</transl
 <context>
     <name>Settings</name>
     <message>
+        <location filename="settings.ui" line="14"/>
         <source>Preferences</source>
         <translation>Préférences</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="24"/>
         <source>General</source>
         <translation>Général</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="41"/>
         <source>Number of threads: </source>
         <translation>Nombre de fils : </translation>
     </message>
     <message>
+        <location filename="settings.ui" line="79"/>
+        <source>Max count:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="115"/>
         <source>Show full path of files</source>
         <translation>Montrer le chemin complet des fichiers</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="122"/>
         <source>Show &quot;No errors found&quot; message when no errors found</source>
         <translation>Afficher un message &quot;Pas d&apos;erreur trouvée&quot; lorsque aucune erreur est trouvée</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="157"/>
+        <source>Check for updates</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="185"/>
         <source>Applications</source>
         <translation>Applications</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="240"/>
         <source>Reports</source>
         <translation>Rapports</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="246"/>
         <source>Save all errors when creating report</source>
         <translation>Sauvegarder toutes les erreurs lorsqu&apos;un rapport est créé</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="253"/>
         <source>Save full path to files in reports</source>
         <translation>Sauvegarder le chemin complet des fichiers dans les rapports</translation>
     </message>
     <message>
-        <source>Include paths:</source>
-        <translation type="obsolete">Inclure les chemins</translation>
-    </message>
-    <message>
+        <location filename="settings.ui" line="196"/>
         <source>Add...</source>
         <translation>Ajouter...</translation>
     </message>
     <message>
-        <source>Ideal count:</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
+        <location filename="settings.ui" line="108"/>
         <source>Force checking all #ifdef configurations</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="136"/>
         <source>Enable inline suppressions</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="274"/>
         <source>Language</source>
         <translation>Langue</translation>
     </message>
     <message>
-        <source>Paths</source>
-        <translation type="obsolete">Chemins</translation>
-    </message>
-    <message>
-        <source>Edit</source>
-        <translation type="obsolete">Editer</translation>
-    </message>
-    <message>
+        <location filename="settings.ui" line="210"/>
         <source>Remove</source>
         <translation>Supprimer</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="203"/>
+        <location filename="settings.ui" line="479"/>
         <source>Edit...</source>
         <translation>Editer...</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="217"/>
         <source>Set as default</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="129"/>
         <source>Display error Id in column &quot;Id&quot;</source>
         <translation>Afficher l&apos;identifiant d&apos;erreur Id dans la colonne &quot;Id&quot;</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="143"/>
         <source>Check for inconclusive errors also</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="177"/>
         <source>Show internal warnings in log</source>
         <translation>Montrer les avertissements internes dans le journal</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="150"/>
         <source>Show statistics on check completion</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="288"/>
         <source>Addons</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="294"/>
         <source>Python binary (leave this empty to use python in the PATH)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="305"/>
+        <location filename="settings.ui" line="346"/>
+        <location filename="settings.ui" line="391"/>
         <source>...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="372"/>
         <source>Clang</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="378"/>
         <source>Clang path (leave empty to use system PATH)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="401"/>
         <source>Visual Studio headers</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="407"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Paths to Visual Studio headers, separated by semicolon &apos;;&apos;.&lt;/p&gt;&lt;p&gt;You can open a Visual Studio command prompt, write &amp;quot;SET INCLUDE&amp;quot;. Then copy/paste the paths.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Misra addon</source>
+        <location filename="settings.ui" line="324"/>
+        <source>MISRA addon</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Misra rule texts file</source>
+        <location filename="settings.ui" line="332"/>
+        <source>MISRA rule texts file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="339"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="437"/>
         <source>Code Editor</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="443"/>
         <source>Code Editor Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="456"/>
         <source>Default Light Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="463"/>
         <source>Default Dark Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="472"/>
         <source>Custom</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="449"/>
         <source>System Style</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1966,38 +2825,42 @@ Pour configurer les erreurs affichées, ouvrez le menu d&apos;affichage.</transl
 <context>
     <name>SettingsDialog</name>
     <message>
+        <location filename="settingsdialog.cpp" line="243"/>
         <source>Add a new application</source>
         <translation>Ajouter une nouvelle application</translation>
     </message>
     <message>
+        <location filename="settingsdialog.cpp" line="273"/>
         <source>Modify an application</source>
         <translation>Modifier une application</translation>
     </message>
     <message>
-        <source>N/A</source>
+        <location filename="settingsdialog.cpp" line="303"/>
+        <source>[Default]</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Select include directory</source>
-        <translation type="obsolete">Selectionner un répertoire à inclure</translation>
-    </message>
-    <message>
-        <source>[Default]</source>
+        <location filename="settingsdialog.cpp" line="278"/>
+        <source> [Default]</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source> [Default]</source>
+        <location filename="settingsdialog.cpp" line="232"/>
+        <source>The executable file &quot;%1&quot; is not available</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settingsdialog.cpp" line="358"/>
         <source>Select python binary</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settingsdialog.cpp" line="396"/>
         <source>Select clang path</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settingsdialog.cpp" line="365"/>
         <source>Select MISRA File</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2005,201 +2868,279 @@ Pour configurer les erreurs affichées, ouvrez le menu d&apos;affichage.</transl
 <context>
     <name>StatsDialog</name>
     <message>
+        <location filename="statsdialog.ui" line="14"/>
+        <location filename="statsdialog.ui" line="248"/>
+        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="230"/>
         <source>Statistics</source>
         <translation>Statistiques</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="27"/>
+        <location filename="statsdialog.cpp" line="221"/>
         <source>Project</source>
         <translation>Projet</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="33"/>
         <source>Project:</source>
         <translation>Projet :</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="53"/>
         <source>Paths:</source>
         <translation>Chemins :</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="85"/>
         <source>Include paths:</source>
         <translation>Inclure les chemins :</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="108"/>
         <source>Defines:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="165"/>
+        <location filename="statsdialog.cpp" line="226"/>
         <source>Previous Scan</source>
         <translation>Analyse précédente</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="171"/>
         <source>Path Selected:</source>
         <translation>Chemin sélectionné :</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="181"/>
         <source>Number of Files Scanned:</source>
         <translation>Nombre de fichiers analysés :</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="201"/>
         <source>Scan Duration:</source>
         <translation>Durée de l&apos;analyse :</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="254"/>
         <source>Errors:</source>
         <translation>Erreurs :</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="271"/>
         <source>Warnings:</source>
         <translation>Avertissements</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="288"/>
         <source>Stylistic warnings:</source>
         <translation>Avertissements de style</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="305"/>
         <source>Portability warnings:</source>
         <translation>Avertissements de portabilité</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="322"/>
         <source>Performance issues:</source>
         <translation>Problème de performance</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="339"/>
         <source>Information messages:</source>
         <translation>Messages d&apos;information :</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="356"/>
+        <source>Active checkers:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="374"/>
+        <source>Checkers</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="443"/>
         <source>Copy to Clipboard</source>
         <translation>Copier vers le presse-papier</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>1 day</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>%1 days</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>1 hour</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>%1 hours</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>1 minute</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>%1 minutes</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>1 second</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>%1 seconds</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="169"/>
         <source>0.%1 seconds</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="171"/>
         <source> and </source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="220"/>
         <source>Project Settings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="222"/>
         <source>Paths</source>
         <translation type="unfinished">Chemins</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="223"/>
         <source>Include paths</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="224"/>
         <source>Defines</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="227"/>
         <source>Path selected</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="228"/>
         <source>Number of files scanned</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="229"/>
         <source>Scan duration</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="185"/>
+        <location filename="statsdialog.cpp" line="231"/>
         <source>Errors</source>
         <translation type="unfinished">Erreurs</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="232"/>
         <source>Warnings</source>
         <translation type="unfinished">Avertissements</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="233"/>
         <source>Style warnings</source>
         <translation type="unfinished">Avertissement de style</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="191"/>
+        <location filename="statsdialog.cpp" line="234"/>
         <source>Portability warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="193"/>
+        <location filename="statsdialog.cpp" line="235"/>
         <source>Performance warnings</source>
         <translation type="unfinished">Avertissements de performance</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="195"/>
+        <location filename="statsdialog.cpp" line="236"/>
         <source>Information messages</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="450"/>
         <source>Pdf Export</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="198"/>
         <source>Export PDF</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="399"/>
         <source>History</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="405"/>
         <source>File:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>File: </source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>No cppcheck build dir</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="131"/>
         <source>Undefines:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="225"/>
         <source>Undefines</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
+<context>
+    <name>ThreadDetails</name>
+    <message>
+        <location filename="threaddetails.ui" line="14"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>ThreadResult</name>
     <message>
+        <location filename="threadresult.cpp" line="47"/>
         <source>%1 of %2 files checked</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2207,6 +3148,7 @@ Pour configurer les erreurs affichées, ouvrez le menu d&apos;affichage.</transl
 <context>
     <name>TranslationHandler</name>
     <message>
+        <location filename="translationhandler.cpp" line="130"/>
         <source>Failed to change the user interface language:
 
 %1
@@ -2215,6 +3157,7 @@ The user interface language has been reset to English. Open the Preferences-dial
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="translationhandler.cpp" line="136"/>
         <source>Cppcheck</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2222,6 +3165,7 @@ The user interface language has been reset to English. Open the Preferences-dial
 <context>
     <name>TxtReport</name>
     <message>
+        <location filename="txtreport.cpp" line="74"/>
         <source>inconclusive</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2229,10 +3173,12 @@ The user interface language has been reset to English. Open the Preferences-dial
 <context>
     <name>toFilterString</name>
     <message>
+        <location filename="common.cpp" line="58"/>
         <source>All supported files (%1)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="common.cpp" line="63"/>
         <source>All files (%1)</source>
         <translation type="unfinished"></translation>
     </message>
diff --git a/gui/cppcheck_it.ts b/gui/cppcheck_it.ts
index 21833684329..1c8829bb198 100644
--- a/gui/cppcheck_it.ts
+++ b/gui/cppcheck_it.ts
@@ -20,8 +20,9 @@
     </message>
     <message>
         <location filename="about.ui" line="81"/>
-        <source>Copyright © 2007-2019 Cppcheck team.</source>
-        <translation>Copyright © 2007-2019 il team Cppcheck.</translation>
+        <source>Copyright © 2007-%1 Cppcheck team.</source>
+        <oldsource>Copyright © 2007-2021 Cppcheck team.</oldsource>
+        <translation type="unfinished">Copyright © 2007-2021 il team Cppcheck.</translation>
     </message>
     <message>
         <location filename="about.ui" line="91"/>
@@ -37,24 +38,20 @@ della GNU General Public License versione 3</translation>
     </message>
     <message>
         <location filename="about.ui" line="115"/>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
-&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul&gt;
-&lt;li&gt;tinyxml2&lt;/li&gt;
-&lt;li&gt;picojson&lt;/li&gt;
-&lt;li&gt;pcre&lt;/li&gt;
-&lt;li&gt;qt&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PCRE&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PicoJSON&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;TinyXML2&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Boost&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <oldsource>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;pcre&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;picojson&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;tinyxml2&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</oldsource>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>ApplicationDialog</name>
     <message>
-        <location filename="application.ui" line="23"/>
+        <location filename="applicationdialog.ui" line="23"/>
         <source>Add an application</source>
         <translation>Aggiungi un&apos;applicazione</translation>
     </message>
     <message>
-        <location filename="application.ui" line="41"/>
+        <location filename="applicationdialog.ui" line="41"/>
         <source>Here you can add an application that can open error files. Specify a name for the application, the application executable and command line parameters for the application.
 
 The following texts in parameters are replaced with appropriate values when application is executed:
@@ -80,65 +77,157 @@ Parametri: -l(line) (file)
 </translation>
     </message>
     <message>
-        <location filename="application.ui" line="76"/>
+        <location filename="applicationdialog.ui" line="76"/>
         <source>&amp;Name:</source>
         <translation>&amp;Nome:</translation>
     </message>
     <message>
-        <location filename="application.ui" line="86"/>
+        <location filename="applicationdialog.ui" line="86"/>
         <source>&amp;Executable:</source>
         <translation>&amp;Eseguibile:</translation>
     </message>
     <message>
-        <location filename="application.ui" line="96"/>
+        <location filename="applicationdialog.ui" line="96"/>
         <source>&amp;Parameters:</source>
         <translation>&amp;Parametri:</translation>
     </message>
     <message>
-        <location filename="application.ui" line="138"/>
+        <location filename="applicationdialog.ui" line="138"/>
         <source>Browse</source>
         <translation>Esplora</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="59"/>
+        <location filename="applicationdialog.cpp" line="65"/>
         <source>Executable files (*.exe);;All files(*.*)</source>
         <translation>File di esecuzione (*.exe);;Tutti i file(*.*)</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="62"/>
+        <location filename="applicationdialog.cpp" line="68"/>
         <source>Select viewer application</source>
         <translation>Seleziona l&apos;applicazione di lettura</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="77"/>
+        <location filename="applicationdialog.cpp" line="83"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="78"/>
+        <location filename="applicationdialog.cpp" line="84"/>
         <source>You must specify a name, a path and optionally parameters for the application!</source>
         <translation>Devi specificare un nome, un percorso ed, opzionalmente, i parametri per l&apos;applicazione!</translation>
     </message>
 </context>
+<context>
+    <name>ComplianceReportDialog</name>
+    <message>
+        <location filename="compliancereportdialog.ui" line="14"/>
+        <source>Compliance Report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="29"/>
+        <source>Project name</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="22"/>
+        <source>Project version</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="42"/>
+        <source>Coding Standard</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="50"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="55"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="60"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="70"/>
+        <source>List of files with md5 checksums</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="133"/>
+        <source>Compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="135"/>
+        <source>HTML files (*.html)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="176"/>
+        <location filename="compliancereportdialog.cpp" line="239"/>
+        <source>Save compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="177"/>
+        <source>Failed to import &apos;%1&apos; (%2), can not show files in compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>FileViewDialog</name>
     <message>
-        <location filename="fileviewdialog.cpp" line="42"/>
+        <location filename="fileviewdialog.cpp" line="53"/>
         <source>Could not find the file: %1</source>
         <translation>File non trovato: %1</translation>
     </message>
     <message>
-        <location filename="fileviewdialog.cpp" line="46"/>
-        <location filename="fileviewdialog.cpp" line="60"/>
+        <location filename="fileviewdialog.cpp" line="57"/>
+        <location filename="fileviewdialog.cpp" line="71"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="fileviewdialog.cpp" line="56"/>
+        <location filename="fileviewdialog.cpp" line="67"/>
         <source>Could not read the file: %1</source>
         <translation>Non è stato possibile leggere il file: %1</translation>
     </message>
 </context>
+<context>
+    <name>HelpDialog</name>
+    <message>
+        <location filename="helpdialog.ui" line="14"/>
+        <source>Cppcheck GUI help</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="34"/>
+        <source>Contents</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="44"/>
+        <source>Index</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="84"/>
+        <source>Helpfile &apos;%1&apos; was not found</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="86"/>
+        <source>Cppcheck</source>
+        <translation type="unfinished">Cppcheck</translation>
+    </message>
+</context>
 <context>
     <name>LibraryAddFunctionDialog</name>
     <message>
@@ -245,42 +334,42 @@ Parametri: -l(line) (file)
         <translation type="unfinished">Modifica</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="82"/>
-        <location filename="librarydialog.cpp" line="154"/>
+        <location filename="librarydialog.cpp" line="97"/>
+        <location filename="librarydialog.cpp" line="169"/>
         <source>Library files (*.cfg)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="84"/>
+        <location filename="librarydialog.cpp" line="99"/>
         <source>Open library file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="95"/>
-        <location filename="librarydialog.cpp" line="107"/>
-        <location filename="librarydialog.cpp" line="144"/>
+        <location filename="librarydialog.cpp" line="110"/>
+        <location filename="librarydialog.cpp" line="122"/>
+        <location filename="librarydialog.cpp" line="159"/>
         <source>Cppcheck</source>
         <translation type="unfinished">Cppcheck</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="96"/>
+        <location filename="librarydialog.cpp" line="111"/>
         <source>Cannot open file %1.</source>
         <oldsource>Can not open file %1.</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="108"/>
+        <location filename="librarydialog.cpp" line="123"/>
         <source>Failed to load %1. %2.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="145"/>
+        <location filename="librarydialog.cpp" line="160"/>
         <source>Cannot save file %1.</source>
         <oldsource>Can not save file %1.</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="157"/>
+        <location filename="librarydialog.cpp" line="172"/>
         <source>Save the library as</source>
         <translation type="unfinished"></translation>
     </message>
@@ -395,631 +484,626 @@ Parametri: -l(line) (file)
         <translation type="unfinished"></translation>
     </message>
 </context>
-<context>
-    <name>LogView</name>
-    <message>
-        <source>Checking Log</source>
-        <translation type="obsolete">Log sulla scansione</translation>
-    </message>
-    <message>
-        <source>Clear</source>
-        <translation type="obsolete">Cancella</translation>
-    </message>
-    <message>
-        <source>Save Log</source>
-        <translation type="obsolete">Salva il rapporto</translation>
-    </message>
-    <message>
-        <source>Text files (*.txt *.log);;All files (*.*)</source>
-        <translation type="obsolete">File di testo (*.txt *.log);;Tutti i files(*.*)</translation>
-    </message>
-    <message>
-        <source>Cppcheck</source>
-        <translation type="obsolete">Cppcheck</translation>
-    </message>
-    <message>
-        <source>Could not open file for writing: &quot;%1&quot;</source>
-        <translation type="obsolete">Non è stato possibile aprire il file per la scrittura: &quot;%1&quot;</translation>
-    </message>
-</context>
 <context>
     <name>MainWindow</name>
     <message>
         <location filename="mainwindow.ui" line="26"/>
-        <location filename="mainwindow.ui" line="595"/>
-        <location filename="mainwindow.cpp" line="328"/>
-        <location filename="mainwindow.cpp" line="480"/>
-        <location filename="mainwindow.cpp" line="553"/>
-        <location filename="mainwindow.cpp" line="658"/>
-        <location filename="mainwindow.cpp" line="680"/>
-        <location filename="mainwindow.cpp" line="1113"/>
-        <location filename="mainwindow.cpp" line="1238"/>
-        <location filename="mainwindow.cpp" line="1359"/>
-        <location filename="mainwindow.cpp" line="1499"/>
-        <location filename="mainwindow.cpp" line="1522"/>
-        <location filename="mainwindow.cpp" line="1593"/>
-        <location filename="mainwindow.cpp" line="1667"/>
+        <location filename="mainwindow.ui" line="688"/>
+        <location filename="mainwindow.cpp" line="466"/>
+        <location filename="mainwindow.cpp" line="670"/>
+        <location filename="mainwindow.cpp" line="755"/>
+        <location filename="mainwindow.cpp" line="860"/>
+        <location filename="mainwindow.cpp" line="882"/>
+        <location filename="mainwindow.cpp" line="1467"/>
+        <location filename="mainwindow.cpp" line="1596"/>
+        <location filename="mainwindow.cpp" line="1937"/>
+        <location filename="mainwindow.cpp" line="1945"/>
+        <location filename="mainwindow.cpp" line="1999"/>
+        <location filename="mainwindow.cpp" line="2008"/>
+        <location filename="mainwindow.cpp" line="2080"/>
+        <location filename="mainwindow.cpp" line="2168"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="131"/>
+        <location filename="mainwindow.ui" line="210"/>
         <source>A&amp;nalyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="183"/>
+        <location filename="mainwindow.ui" line="267"/>
         <source>Standard</source>
         <translation>Standard</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="70"/>
+        <location filename="mainwindow.ui" line="132"/>
         <source>&amp;File</source>
         <translation>&amp;File</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="89"/>
+        <location filename="mainwindow.ui" line="152"/>
         <source>&amp;View</source>
         <translation>&amp;Visualizza</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="93"/>
+        <location filename="mainwindow.ui" line="156"/>
         <source>&amp;Toolbars</source>
         <translation>&amp;Barre degli strumenti</translation>
     </message>
     <message>
-        <source>&amp;Check</source>
-        <translation type="obsolete">&amp;Scansiona</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="135"/>
+        <location filename="mainwindow.ui" line="214"/>
         <source>C++ standard</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="145"/>
+        <location filename="mainwindow.ui" line="226"/>
         <source>&amp;C standard</source>
         <oldsource>C standard</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="170"/>
+        <location filename="mainwindow.ui" line="254"/>
         <source>&amp;Edit</source>
         <translation>&amp;Modifica</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="231"/>
+        <location filename="mainwindow.ui" line="315"/>
         <source>&amp;License...</source>
         <translation>&amp;Licenza...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="236"/>
+        <location filename="mainwindow.ui" line="320"/>
         <source>A&amp;uthors...</source>
         <translation>A&amp;utori...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="245"/>
+        <location filename="mainwindow.ui" line="329"/>
         <source>&amp;About...</source>
         <translation>I&amp;nformazioni su...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="250"/>
+        <location filename="mainwindow.ui" line="334"/>
         <source>&amp;Files...</source>
         <translation>&amp;File...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="253"/>
-        <location filename="mainwindow.ui" line="256"/>
+        <location filename="mainwindow.ui" line="337"/>
+        <location filename="mainwindow.ui" line="340"/>
         <source>Analyze files</source>
         <oldsource>Check files</oldsource>
         <translation type="unfinished">Scansiona i file</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="259"/>
+        <location filename="mainwindow.ui" line="343"/>
         <source>Ctrl+F</source>
         <translation>Ctrl+F</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="268"/>
+        <location filename="mainwindow.ui" line="352"/>
         <source>&amp;Directory...</source>
         <translation>&amp;Cartella...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="271"/>
-        <location filename="mainwindow.ui" line="274"/>
+        <location filename="mainwindow.ui" line="355"/>
+        <location filename="mainwindow.ui" line="358"/>
         <source>Analyze directory</source>
         <oldsource>Check directory</oldsource>
         <translation type="unfinished">Scansiona la cartella</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="277"/>
+        <location filename="mainwindow.ui" line="361"/>
         <source>Ctrl+D</source>
         <translation>Ctrl+D</translation>
     </message>
     <message>
-        <source>&amp;Recheck files</source>
-        <translation type="obsolete">&amp;Riscansiona i file</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="289"/>
+        <location filename="mainwindow.ui" line="373"/>
         <source>Ctrl+R</source>
         <translation>Ctrl+R</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="307"/>
+        <location filename="mainwindow.ui" line="391"/>
         <source>&amp;Stop</source>
         <translation>&amp;Ferma</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="310"/>
-        <location filename="mainwindow.ui" line="313"/>
+        <location filename="mainwindow.ui" line="394"/>
+        <location filename="mainwindow.ui" line="397"/>
         <source>Stop analysis</source>
         <oldsource>Stop checking</oldsource>
         <translation type="unfinished">Ferma la scansione</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="316"/>
+        <location filename="mainwindow.ui" line="400"/>
         <source>Esc</source>
         <translation>Esc</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="325"/>
+        <location filename="mainwindow.ui" line="409"/>
         <source>&amp;Save results to file...</source>
         <translation>&amp;Salva i risultati nel file...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="328"/>
+        <location filename="mainwindow.ui" line="412"/>
         <source>Ctrl+S</source>
         <translation>Ctrl+S</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="333"/>
+        <location filename="mainwindow.ui" line="417"/>
         <source>&amp;Quit</source>
         <translation>&amp;Esci</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="342"/>
+        <location filename="mainwindow.ui" line="429"/>
         <source>&amp;Clear results</source>
         <translation>&amp;Cancella i risultati</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="351"/>
+        <location filename="mainwindow.ui" line="438"/>
         <source>&amp;Preferences</source>
         <translation>&amp;Preferenze</translation>
     </message>
     <message>
-        <source>Errors</source>
-        <translation type="obsolete">Errori</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="384"/>
-        <location filename="mainwindow.ui" line="387"/>
+        <location filename="mainwindow.ui" line="471"/>
+        <location filename="mainwindow.ui" line="474"/>
+        <location filename="mainwindow.cpp" line="2394"/>
         <source>Show errors</source>
         <translation>Mostra gli errori</translation>
     </message>
     <message>
-        <source>Show S&amp;cratchpad...</source>
-        <translation type="obsolete">Mostra il blocchetto per appunti...</translation>
-    </message>
-    <message>
-        <source>Warnings</source>
-        <translation type="obsolete">Avvisi</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="524"/>
-        <location filename="mainwindow.ui" line="527"/>
+        <location filename="mainwindow.ui" line="617"/>
+        <location filename="mainwindow.ui" line="620"/>
+        <location filename="mainwindow.cpp" line="2395"/>
         <source>Show warnings</source>
         <translation>Mostra gli avvisi</translation>
     </message>
     <message>
-        <source>Performance warnings</source>
-        <translation type="obsolete">Avvisi sulle prestazioni</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="542"/>
-        <location filename="mainwindow.ui" line="545"/>
+        <location filename="mainwindow.ui" line="635"/>
+        <location filename="mainwindow.ui" line="638"/>
         <source>Show performance warnings</source>
         <translation>Mostra gli avvisi sulle prestazioni</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="553"/>
+        <location filename="mainwindow.ui" line="646"/>
         <source>Show &amp;hidden</source>
         <translation>Mostra &amp;i nascosti</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="769"/>
-        <location filename="mainwindow.cpp" line="807"/>
+        <location filename="mainwindow.cpp" line="986"/>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Information</source>
         <translation>Informazione</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="568"/>
+        <location filename="mainwindow.ui" line="661"/>
         <source>Show information messages</source>
         <translation>Mostra messaggi di informazione</translation>
     </message>
     <message>
-        <source>Portability</source>
-        <translation type="obsolete">Portabilità</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="583"/>
+        <location filename="mainwindow.ui" line="676"/>
         <source>Show portability warnings</source>
         <translation>Mostra gli avvisi sulla portabilità</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="598"/>
+        <location filename="mainwindow.ui" line="691"/>
         <source>Show Cppcheck results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="610"/>
+        <location filename="mainwindow.ui" line="703"/>
         <source>Clang</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="613"/>
+        <location filename="mainwindow.ui" line="706"/>
         <source>Show Clang results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="621"/>
+        <location filename="mainwindow.ui" line="714"/>
         <source>&amp;Filter</source>
         <translation>&amp;Filtro</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="624"/>
+        <location filename="mainwindow.ui" line="717"/>
         <source>Filter results</source>
         <translation>Filtra i risultati</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="640"/>
+        <location filename="mainwindow.ui" line="733"/>
         <source>Windows 32-bit ANSI</source>
         <translation>Windows 32-bit, ANSI</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="648"/>
+        <location filename="mainwindow.ui" line="741"/>
         <source>Windows 32-bit Unicode</source>
         <translation>Windows 32-bit, Unicode</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="656"/>
+        <location filename="mainwindow.ui" line="749"/>
         <source>Unix 32-bit</source>
         <translation>Unix 32-bit</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="664"/>
+        <location filename="mainwindow.ui" line="757"/>
         <source>Unix 64-bit</source>
         <translation>Unix 64-bit</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="672"/>
+        <location filename="mainwindow.ui" line="765"/>
         <source>Windows 64-bit</source>
         <translation>Windows 64-bit</translation>
     </message>
     <message>
-        <source>Platforms</source>
-        <translation type="obsolete">Piattaforme</translation>
-    </message>
-    <message>
-        <source>C++11</source>
-        <translation type="obsolete">C++11</translation>
-    </message>
-    <message>
-        <source>C99</source>
-        <translation type="obsolete">C99</translation>
-    </message>
-    <message>
-        <source>Posix</source>
-        <translation type="obsolete">Posix</translation>
-    </message>
-    <message>
-        <source>C11</source>
-        <translation type="obsolete">C11</translation>
-    </message>
-    <message>
-        <source>C89</source>
-        <translation type="obsolete">C89</translation>
-    </message>
-    <message>
-        <source>C++03</source>
-        <translation type="obsolete">C++03</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="742"/>
+        <location filename="mainwindow.ui" line="859"/>
         <source>&amp;Print...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="745"/>
+        <location filename="mainwindow.ui" line="862"/>
         <source>Print the Current Report</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="750"/>
+        <location filename="mainwindow.ui" line="867"/>
         <source>Print Pre&amp;view...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="753"/>
+        <location filename="mainwindow.ui" line="870"/>
         <source>Open a Print Preview Dialog for the Current Results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="761"/>
+        <location filename="mainwindow.ui" line="878"/>
         <source>Open library editor</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="392"/>
+        <location filename="mainwindow.ui" line="479"/>
         <source>&amp;Check all</source>
         <translation>&amp;Seleziona tutto</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="220"/>
+        <location filename="mainwindow.ui" line="84"/>
+        <source>Checking for updates</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="100"/>
+        <source>Hide</source>
+        <translation type="unfinished">Nascondi</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="164"/>
+        <location filename="mainwindow.ui" line="980"/>
+        <source>Report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="304"/>
         <source>Filter</source>
         <translation>Filtro</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="286"/>
+        <location filename="mainwindow.ui" line="370"/>
         <source>&amp;Reanalyze modified files</source>
         <oldsource>&amp;Recheck modified files</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="298"/>
+        <location filename="mainwindow.ui" line="382"/>
         <source>Reanal&amp;yze all files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="363"/>
+        <location filename="mainwindow.ui" line="420"/>
+        <source>Ctrl+Q</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="450"/>
         <source>Style war&amp;nings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="381"/>
+        <location filename="mainwindow.ui" line="468"/>
         <source>E&amp;rrors</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="397"/>
+        <location filename="mainwindow.ui" line="484"/>
         <source>&amp;Uncheck all</source>
         <translation>&amp;Deseleziona tutto</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="402"/>
+        <location filename="mainwindow.ui" line="489"/>
         <source>Collapse &amp;all</source>
         <translation>Riduci &amp;tutto</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="407"/>
+        <location filename="mainwindow.ui" line="494"/>
         <source>&amp;Expand all</source>
         <translation>&amp;Espandi tutto</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="415"/>
+        <location filename="mainwindow.ui" line="502"/>
         <source>&amp;Standard</source>
         <translation>&amp;Standard</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="418"/>
+        <location filename="mainwindow.ui" line="505"/>
         <source>Standard items</source>
         <translation>Oggetti standard</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="434"/>
+        <location filename="mainwindow.ui" line="521"/>
         <source>Toolbar</source>
         <translation>Barra degli strumenti</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="442"/>
+        <location filename="mainwindow.ui" line="529"/>
         <source>&amp;Categories</source>
         <translation>&amp;Categorie</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="445"/>
+        <location filename="mainwindow.ui" line="532"/>
         <source>Error categories</source>
         <translation>Categorie di errore</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="450"/>
+        <location filename="mainwindow.ui" line="537"/>
         <source>&amp;Open XML...</source>
         <translation>&amp;Apri XML...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="459"/>
+        <location filename="mainwindow.ui" line="546"/>
         <source>Open P&amp;roject File...</source>
         <translation>Apri file di p&amp;rogetto...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="468"/>
+        <location filename="mainwindow.ui" line="549"/>
+        <source>Ctrl+Shift+O</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="558"/>
         <source>Sh&amp;ow Scratchpad...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="473"/>
+        <location filename="mainwindow.ui" line="563"/>
         <source>&amp;New Project File...</source>
         <translation>&amp;Nuovo file di progetto...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="478"/>
+        <location filename="mainwindow.ui" line="566"/>
+        <source>Ctrl+Shift+N</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="571"/>
         <source>&amp;Log View</source>
         <translation>&amp;Visualizza il rapporto</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="481"/>
+        <location filename="mainwindow.ui" line="574"/>
         <source>Log View</source>
         <translation>Visualizza il rapporto</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="489"/>
+        <location filename="mainwindow.ui" line="582"/>
         <source>C&amp;lose Project File</source>
         <translation>C&amp;hiudi il file di progetto</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="497"/>
+        <location filename="mainwindow.ui" line="590"/>
         <source>&amp;Edit Project File...</source>
         <translation>&amp;Modifica il file di progetto...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="509"/>
+        <location filename="mainwindow.ui" line="602"/>
         <source>&amp;Statistics</source>
         <translation>&amp;Statistiche</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="521"/>
+        <location filename="mainwindow.ui" line="614"/>
         <source>&amp;Warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="539"/>
+        <location filename="mainwindow.ui" line="632"/>
         <source>Per&amp;formance warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="565"/>
+        <location filename="mainwindow.ui" line="658"/>
         <source>&amp;Information</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="580"/>
+        <location filename="mainwindow.ui" line="673"/>
         <source>&amp;Portability</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="680"/>
+        <location filename="mainwindow.ui" line="773"/>
         <source>P&amp;latforms</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="694"/>
+        <location filename="mainwindow.ui" line="787"/>
         <source>C++&amp;11</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="705"/>
+        <location filename="mainwindow.ui" line="798"/>
         <source>C&amp;99</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="713"/>
+        <location filename="mainwindow.ui" line="806"/>
         <source>&amp;Posix</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="721"/>
+        <location filename="mainwindow.ui" line="814"/>
         <source>C&amp;11</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="729"/>
+        <location filename="mainwindow.ui" line="846"/>
         <source>&amp;C89</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="737"/>
+        <location filename="mainwindow.ui" line="854"/>
         <source>&amp;C++03</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="758"/>
+        <location filename="mainwindow.ui" line="875"/>
         <source>&amp;Library Editor...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="769"/>
+        <location filename="mainwindow.ui" line="886"/>
         <source>&amp;Auto-detect language</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="777"/>
+        <location filename="mainwindow.ui" line="894"/>
         <source>&amp;Enforce C++</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="785"/>
+        <location filename="mainwindow.ui" line="902"/>
         <source>E&amp;nforce C</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="796"/>
+        <location filename="mainwindow.ui" line="913"/>
         <source>C++14</source>
         <translation type="unfinished">C++14</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="804"/>
+        <location filename="mainwindow.ui" line="921"/>
         <source>Reanalyze and check library</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="812"/>
+        <location filename="mainwindow.ui" line="929"/>
         <source>Check configuration (defines, includes)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="820"/>
+        <location filename="mainwindow.ui" line="937"/>
         <source>C++17</source>
         <translation type="unfinished">C++17</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="831"/>
+        <location filename="mainwindow.ui" line="948"/>
         <source>C++20</source>
         <translation type="unfinished">C++20</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="423"/>
+        <location filename="mainwindow.ui" line="975"/>
+        <source>Compliance report...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="988"/>
+        <source>Normal</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="996"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1004"/>
+        <source>Misra C++ 2008</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1012"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1020"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1028"/>
+        <source>Misra C++ 2023</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1036"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1041"/>
+        <source>EULA...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1046"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1049"/>
+        <source>Show thread details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="510"/>
         <source>&amp;Contents</source>
         <translation>&amp;Contenuti</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="201"/>
+        <location filename="mainwindow.ui" line="285"/>
         <source>Categories</source>
         <translation>Categorie</translation>
     </message>
     <message>
-        <source>Style warnings</source>
-        <translation type="obsolete">Avvisi sullo stile</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="366"/>
-        <location filename="mainwindow.ui" line="369"/>
+        <location filename="mainwindow.ui" line="453"/>
+        <location filename="mainwindow.ui" line="456"/>
         <source>Show style warnings</source>
         <translation>Mostra gli avvisi sullo stile</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="426"/>
+        <location filename="mainwindow.ui" line="513"/>
         <source>Open the help contents</source>
         <translation>Apri i contenuti di aiuto</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="429"/>
+        <location filename="mainwindow.ui" line="516"/>
         <source>F1</source>
         <translation>F1</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="121"/>
+        <location filename="mainwindow.ui" line="199"/>
         <source>&amp;Help</source>
         <translation>&amp;Aiuto</translation>
     </message>
     <message>
-        <source>Select directory to check</source>
-        <translation type="obsolete">Seleziona una cartella da scansionare</translation>
-    </message>
-    <message>
-        <source>No suitable files found to check!</source>
-        <translation type="obsolete">Nessun file trovato idoneo alla scansione!</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="87"/>
+        <location filename="mainwindow.cpp" line="157"/>
+        <location filename="mainwindow.cpp" line="1782"/>
         <source>Quick Filter:</source>
         <translation>Rapido filtro:</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="629"/>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select configuration</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="659"/>
+        <location filename="mainwindow.cpp" line="861"/>
         <source>Found project file: %1
 
 Do you want to load this project file instead?</source>
@@ -1028,71 +1112,96 @@ Do you want to load this project file instead?</source>
 Vuoi piuttosto caricare questo file di progetto?</translation>
     </message>
     <message>
-        <source>Found project files from the directory.
-
-Do you want to proceed checking without using any of these project files?</source>
-        <translation type="obsolete">Trovati file di progetto dalla directory.
-
-Vuoi procedere alla scansione senza usare qualcuno di questi file di progetto?</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="778"/>
+        <location filename="mainwindow.cpp" line="995"/>
         <source>File not found</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="781"/>
+        <location filename="mainwindow.cpp" line="998"/>
         <source>Bad XML</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="784"/>
+        <location filename="mainwindow.cpp" line="1001"/>
         <source>Missing attribute</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="787"/>
+        <location filename="mainwindow.cpp" line="1004"/>
         <source>Bad attribute value</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="790"/>
+        <location filename="mainwindow.cpp" line="1007"/>
         <source>Unsupported format</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="807"/>
+        <location filename="mainwindow.cpp" line="1016"/>
+        <source>Duplicate define</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Failed to load the selected library &apos;%1&apos;.
 %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1280"/>
+        <location filename="mainwindow.cpp" line="1035"/>
+        <source>File not found: &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1058"/>
+        <source>Failed to load/setup addon %1: %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <source>Failed to load %1 - %2
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
+        <source>%1
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1648"/>
         <source>License</source>
         <translation>Licenza</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1287"/>
+        <location filename="mainwindow.cpp" line="1655"/>
         <source>Authors</source>
         <translation>Autori</translation>
     </message>
     <message>
-        <source>XML files version 2 (*.xml);;XML files version 1 (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
-        <translation type="obsolete">File XML Versione 2 (*.xml);;File XML Versione 1 (*.xml);;File di testo (*.txt);;File CSV (*.csv)</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1302"/>
+        <location filename="mainwindow.cpp" line="1675"/>
         <source>Save the report file</source>
         <translation>Salva il file di rapporto</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1129"/>
-        <location filename="mainwindow.cpp" line="1309"/>
+        <location filename="mainwindow.cpp" line="1483"/>
+        <location filename="mainwindow.cpp" line="1682"/>
         <source>XML files (*.xml)</source>
         <translation>File XML (*.xml)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="323"/>
+        <location filename="mainwindow.cpp" line="461"/>
         <source>There was a problem with loading the editor application settings.
 
 This is probably because the settings were changed between the Cppcheck versions. Please check (and fix) the editor application settings, otherwise the editor program might not start correctly.</source>
@@ -1101,172 +1210,127 @@ This is probably because the settings were changed between the Cppcheck versions
 Probabilmente ciò è avvenuto perché le impostazioni sono state modificate tra le versioni di Cppcheck. Per favore controlla (e sistema) le impostazioni delle applicazioni editor, altrimenti il programma editor può non partire correttamente.</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="554"/>
+        <location filename="mainwindow.cpp" line="756"/>
         <source>You must close the project file before selecting new files or directories!</source>
         <translation>Devi chiudere il file di progetto prima di selezionare nuovi file o cartelle!</translation>
     </message>
     <message>
-        <source>Select files to check</source>
-        <translation type="obsolete">Seleziona i file da scansionare</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="769"/>
+        <location filename="mainwindow.cpp" line="986"/>
         <source>The library &apos;%1&apos; contains unknown elements:
 %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="793"/>
+        <location filename="mainwindow.cpp" line="1010"/>
         <source>Duplicate platform type</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="796"/>
+        <location filename="mainwindow.cpp" line="1013"/>
         <source>Platform type redefined</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="799"/>
+        <location filename="mainwindow.cpp" line="1019"/>
         <source>Unknown element</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="802"/>
-        <source>Unknown issue</source>
+        <location filename="mainwindow.cpp" line="1019"/>
+        <source>Unknown element</source>
+        <oldsource>Unknown issue</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="828"/>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
         <source>Error</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="828"/>
-        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <source>Current results will be cleared.
-
-Opening a new XML file will clear current results.Do you want to proceed?</source>
-        <translation type="vanished">I risultati correnti verranno ripuliti.
-
-L&apos;apertura di un nuovo file XML ripulirà i risultati correnti. Vuoi procedere?</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1131"/>
+        <location filename="mainwindow.cpp" line="1485"/>
         <source>Open the report file</source>
         <translation>Apri il file di rapporto</translation>
     </message>
     <message>
-        <source>Checking is running.
-
-Do you want to stop the checking and exit Cppcheck?</source>
-        <translation type="obsolete">La scansione è in esecuzione.
-
-Vuoi fermare la scansione ed uscire da Cppcheck?</translation>
-    </message>
-    <message>
-        <source>XML files version 1 (*.xml)</source>
-        <translation type="obsolete">Files XML versione 1 (*.xml)</translation>
-    </message>
-    <message>
-        <source>XML files version 2 (*.xml)</source>
-        <translation type="obsolete">Files XML versione 2 (*.xml)</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1313"/>
+        <location filename="mainwindow.cpp" line="1686"/>
         <source>Text files (*.txt)</source>
         <translation>File di testo (*.txt)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1317"/>
+        <location filename="mainwindow.cpp" line="1690"/>
         <source>CSV files (*.csv)</source>
         <translation>Files CSV (*.csv)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1361"/>
-        <source>Cppcheck - %1</source>
-        <translation>Cppcheck - %1</translation>
-    </message>
-    <message>
-        <source>Failed to change the user interface language:
-
-%1
-
-The user interface language has been reset to English. Open the Preferences-dialog to select any of the available languages.</source>
-        <translation type="obsolete">Fallito il tentativo di cambio della lingua dell&apos;interfaccia utente:
-
-%1
-
-L&apos;interfaccia utente è stata risettata in Inglese. Apri la finestra di dialogo Preferenze per selezionare una qualunque lingua a disposizione.</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1407"/>
+        <location filename="mainwindow.cpp" line="1820"/>
         <source>Project files (*.cppcheck);;All files(*.*)</source>
         <translation>Files di progetto (*.cppcheck);;Tutti i files(*.*)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1409"/>
+        <location filename="mainwindow.cpp" line="1822"/>
         <source>Select Project File</source>
         <translation>Seleziona il file di progetto</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="159"/>
-        <location filename="mainwindow.cpp" line="1437"/>
-        <location filename="mainwindow.cpp" line="1562"/>
+        <location filename="mainwindow.cpp" line="242"/>
+        <location filename="mainwindow.cpp" line="1784"/>
+        <location filename="mainwindow.cpp" line="1850"/>
+        <location filename="mainwindow.cpp" line="2048"/>
         <source>Project:</source>
         <translation>Progetto:</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="481"/>
+        <location filename="mainwindow.cpp" line="671"/>
         <source>No suitable files found to analyze!</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="568"/>
+        <location filename="mainwindow.cpp" line="770"/>
         <source>C/C++ Source</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="569"/>
+        <location filename="mainwindow.cpp" line="771"/>
         <source>Compile database</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="570"/>
+        <location filename="mainwindow.cpp" line="772"/>
         <source>Visual Studio</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="571"/>
+        <location filename="mainwindow.cpp" line="773"/>
         <source>Borland C++ Builder 6</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="574"/>
+        <location filename="mainwindow.cpp" line="776"/>
         <source>Select files to analyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="589"/>
+        <location filename="mainwindow.cpp" line="791"/>
         <source>Select directory to analyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="629"/>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select the configuration that will be analyzed</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="681"/>
+        <location filename="mainwindow.cpp" line="883"/>
         <source>Found project files from the directory.
 
 Do you want to proceed analysis without using any of these project files?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1114"/>
+        <location filename="mainwindow.cpp" line="1468"/>
         <source>Current results will be cleared.
 
 Opening a new XML file will clear current results.
@@ -1274,44 +1338,81 @@ Do you want to proceed?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1234"/>
+        <location filename="mainwindow.cpp" line="1592"/>
         <source>Analyzer is running.
 
 Do you want to stop the analysis and exit Cppcheck?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1300"/>
+        <location filename="mainwindow.cpp" line="1634"/>
+        <source>About</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1673"/>
         <source>XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1500"/>
+        <location filename="mainwindow.cpp" line="1713"/>
+        <source>Cannot generate a compliance report right now, an analysis must finish successfully. Try to reanalyze the code and ensure there are no critical errors.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1938"/>
         <source>Build dir &apos;%1&apos; does not exist, create it?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1523"/>
-        <source>Failed to import &apos;%1&apos;, analysis is stopped</source>
+        <location filename="mainwindow.cpp" line="1946"/>
+        <source>To check the project using addons, you need a build directory.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1978"/>
+        <source>Failed to open file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1981"/>
+        <source>Unknown project file format</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1984"/>
+        <source>Failed to import project file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1547"/>
+        <location filename="mainwindow.cpp" line="2000"/>
+        <source>Failed to import &apos;%1&apos;: %2
+
+Analysis is stopped.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2009"/>
+        <source>Failed to import &apos;%1&apos; (%2), analysis is stopped</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2033"/>
         <source>Project files (*.cppcheck)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1549"/>
+        <location filename="mainwindow.cpp" line="2035"/>
         <source>Select Project Filename</source>
         <translation>Seleziona il nome del file di progetto</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1594"/>
+        <location filename="mainwindow.cpp" line="2081"/>
         <source>No project file loaded</source>
         <translation>Nessun file di progetto caricato</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1662"/>
+        <location filename="mainwindow.cpp" line="2163"/>
         <source>The project file
 
 %1
@@ -1328,7 +1429,72 @@ Do you want to remove the file from the recently used projects -list?</source>
 Vuoi rimuovere il file dalla lista dei progetti recentemente usati?</translation>
     </message>
     <message>
-        <location filename="main.cpp" line="106"/>
+        <location filename="mainwindow.cpp" line="2325"/>
+        <source>Install</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2329"/>
+        <source>New version available: %1. %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2367"/>
+        <source>Show Mandatory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2368"/>
+        <source>Show Required</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2369"/>
+        <source>Show Advisory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2370"/>
+        <source>Show Document</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2387"/>
+        <source>Show L1</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2388"/>
+        <source>Show L2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2389"/>
+        <source>Show L3</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2396"/>
+        <source>Show style</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2397"/>
+        <source>Show portability</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2398"/>
+        <source>Show performance</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2399"/>
+        <source>Show information</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="main.cpp" line="100"/>
         <source>Cppcheck GUI.
 
 Syntax:
@@ -1358,7 +1524,7 @@ Options:
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="main.cpp" line="121"/>
+        <location filename="main.cpp" line="115"/>
         <source>Cppcheck GUI - Command line parameters</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1391,7 +1557,7 @@ Options:
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="newsuppressiondialog.cpp" line="52"/>
+        <location filename="newsuppressiondialog.cpp" line="83"/>
         <source>Edit suppression</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1399,310 +1565,424 @@ Options:
 <context>
     <name>Platforms</name>
     <message>
-        <source>Built-in</source>
-        <translation type="obsolete">Built-in</translation>
-    </message>
-    <message>
-        <location filename="platforms.cpp" line="37"/>
+        <location filename="platforms.cpp" line="38"/>
         <source>Native</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="38"/>
+        <location filename="platforms.cpp" line="39"/>
         <source>Unix 32-bit</source>
         <translation>Unix 32-bit</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="39"/>
+        <location filename="platforms.cpp" line="40"/>
         <source>Unix 64-bit</source>
         <translation>Unix 64-bit</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="40"/>
+        <location filename="platforms.cpp" line="41"/>
         <source>Windows 32-bit ANSI</source>
         <translation>Windows 32-bit, ANSI</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="41"/>
+        <location filename="platforms.cpp" line="42"/>
         <source>Windows 32-bit Unicode</source>
         <translation>Windows 32-bit, Unicode</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="42"/>
+        <location filename="platforms.cpp" line="43"/>
         <source>Windows 64-bit</source>
         <translation>Windows 64-bit</translation>
     </message>
 </context>
 <context>
-    <name>Project</name>
+    <name>ProjectFile</name>
     <message>
-        <source>Cppcheck</source>
-        <translation type="obsolete">Cppcheck</translation>
+        <location filename="projectfile.ui" line="14"/>
+        <source>Project File</source>
+        <translation>File di progetto</translation>
     </message>
     <message>
-        <source>Could not read the project file.</source>
-        <translation type="obsolete">Non è stato possibile leggere il file di progetto.</translation>
+        <location filename="projectfile.ui" line="24"/>
+        <source>Paths and Defines</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="30"/>
+        <source>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</source>
+        <oldsource>Import Project (Visual studio / compile database)</oldsource>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Could not write the project file.</source>
-        <translation type="obsolete">Non è stato possibile scrivere il file di progetto.</translation>
+        <location filename="projectfile.ui" line="231"/>
+        <source>Defines must be separated by a semicolon. Example: DEF1;DEF2=5;DEF3=int</source>
+        <oldsource>Defines must be separated by a semicolon &apos;;&apos;</oldsource>
+        <translation type="unfinished"></translation>
     </message>
-</context>
-<context>
-    <name>ProjectFile</name>
     <message>
-        <location filename="projectfiledialog.ui" line="14"/>
-        <source>Project File</source>
-        <translation>File di progetto</translation>
+        <location filename="projectfile.ui" line="389"/>
+        <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Project</source>
-        <translation type="obsolete">Progetto</translation>
+        <location filename="projectfile.ui" line="655"/>
+        <source>If tags are added, you will be able to right click on warnings and set one of these tags. You can manually categorize warnings.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="24"/>
-        <source>Paths and Defines</source>
+        <location filename="projectfile.ui" line="665"/>
+        <source>Exclude source files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="30"/>
-        <source>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</source>
-        <oldsource>Import Project (Visual studio / compile database)</oldsource>
+        <location filename="projectfile.ui" line="676"/>
+        <source>Exclude folder...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="163"/>
-        <source>Defines must be separated by a semicolon. Example: DEF1;DEF2=5;DEF3=int</source>
-        <oldsource>Defines must be separated by a semicolon &apos;;&apos;</oldsource>
+        <location filename="projectfile.ui" line="683"/>
+        <source>Exclude file...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>&amp;Root:</source>
-        <oldsource>Root:</oldsource>
-        <translation type="obsolete">Root:</translation>
+        <location filename="projectfile.ui" line="833"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="393"/>
-        <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
+        <location filename="projectfile.ui" line="841"/>
+        <source>2012</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="597"/>
-        <source>MISRA C 2012</source>
+        <location filename="projectfile.ui" line="846"/>
+        <location filename="projectfile.ui" line="914"/>
+        <source>2023</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="606"/>
-        <source>Misra rule texts</source>
+        <location filename="projectfile.ui" line="876"/>
+        <source>MISRA rule texts</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="613"/>
+        <location filename="projectfile.ui" line="883"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="620"/>
+        <location filename="projectfile.ui" line="890"/>
         <source>...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="69"/>
+        <location filename="projectfile.ui" line="73"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;You have a choice:&lt;/p&gt;&lt;p&gt; * Analyze all Debug and Release configurations&lt;/p&gt;&lt;p&gt; * Only analyze the first matching Debug configuration&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="60"/>
-        <location filename="projectfiledialog.ui" line="309"/>
+        <location filename="projectfile.ui" line="60"/>
+        <location filename="projectfile.ui" line="422"/>
+        <location filename="projectfile.ui" line="616"/>
         <source>Browse...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="72"/>
+        <location filename="projectfile.ui" line="76"/>
         <source>Analyze all Visual Studio configurations</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="86"/>
+        <location filename="projectfile.ui" line="113"/>
+        <source>Selected VS Configurations</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="147"/>
         <source>Paths:</source>
         <translation>Percorsi:</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="113"/>
-        <location filename="projectfiledialog.ui" line="228"/>
-        <location filename="projectfiledialog.ui" line="461"/>
+        <location filename="projectfile.ui" line="181"/>
+        <location filename="projectfile.ui" line="296"/>
         <source>Add...</source>
         <translation>Aggiungi...</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="120"/>
-        <location filename="projectfiledialog.ui" line="235"/>
-        <location filename="projectfiledialog.ui" line="468"/>
+        <location filename="projectfile.ui" line="188"/>
+        <location filename="projectfile.ui" line="303"/>
+        <location filename="projectfile.ui" line="690"/>
         <source>Edit</source>
         <translation>Modifica</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="127"/>
-        <location filename="projectfiledialog.ui" line="242"/>
-        <location filename="projectfiledialog.ui" line="475"/>
-        <location filename="projectfiledialog.ui" line="518"/>
+        <location filename="projectfile.ui" line="195"/>
+        <location filename="projectfile.ui" line="310"/>
+        <location filename="projectfile.ui" line="697"/>
+        <location filename="projectfile.ui" line="740"/>
         <source>Remove</source>
         <translation>Rimuovi</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="174"/>
+        <location filename="projectfile.ui" line="242"/>
         <source>Undefines:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="184"/>
+        <location filename="projectfile.ui" line="252"/>
         <source>Undefines must be separated by a semicolon. Example: UNDEF1;UNDEF2;UNDEF3</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="197"/>
+        <location filename="projectfile.ui" line="265"/>
         <source>Include Paths:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="331"/>
+        <location filename="projectfile.ui" line="362"/>
+        <source>Types and Functions</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="403"/>
+        <location filename="projectfile.ui" line="488"/>
         <source>Analysis</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="337"/>
-        <source>Check code in headers  (slower analysis, more results)</source>
+        <location filename="projectfile.ui" line="415"/>
+        <source>This is a workfolder that Cppcheck will use for various purposes.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="432"/>
+        <source>Parser</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="438"/>
+        <source>Cppcheck (built in)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="458"/>
+        <source>Check level</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="464"/>
+        <source>Reduced -- meant for usage where developer wants results directly. Limited and faster analysis with fewer results.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="471"/>
+        <source>Normal -- meant for normal analysis in CI. Analysis should finish in reasonable time.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="478"/>
+        <source>Exhaustive -- meant for nightly builds etc. Analysis time can be longer (10x slower than compilation is OK).</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="497"/>
+        <source>Check that each class has a safe public interface</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="513"/>
+        <source>Limit analysis</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="347"/>
-        <source>Check code in unused templates  (slower and less accurate analysis)</source>
+        <location filename="projectfile.ui" line="529"/>
+        <source>Check code in unused templates (should be ON normally, however in theory you can safely ignore warnings in unused templates)</source>
+        <oldsource>Check code in unused templates  (slower and less accurate analysis)</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="356"/>
+        <location filename="projectfile.ui" line="541"/>
         <source>Max CTU depth</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="450"/>
-        <source>Exclude source files in paths</source>
+        <location filename="projectfile.ui" line="607"/>
+        <source>Premium License</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="632"/>
-        <source>External tools</source>
+        <location filename="projectfile.ui" line="765"/>
+        <source>Enable inline suppressions</source>
+        <translation type="unfinished">Abilita le soppressioni</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="851"/>
+        <source>2025</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="901"/>
+        <source>Misra C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="909"/>
+        <source>2008</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="937"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="946"/>
+        <source>CERT-INT35-C:  int precision (if size equals precision, you can leave empty)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="965"/>
+        <source>Autosar</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Includes</source>
-        <translation type="obsolete">Inclusioni</translation>
+        <location filename="projectfile.ui" line="972"/>
+        <source>Safety profiles (defined in C++ core guidelines)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="988"/>
+        <source>Bug hunting</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Include directories:</source>
-        <translation type="obsolete">Cartelle di inclusione:</translation>
+        <location filename="projectfile.ui" line="998"/>
+        <source>External tools</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="262"/>
+        <location filename="projectfile.ui" line="330"/>
         <source>Up</source>
         <translation>Su</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="269"/>
+        <location filename="projectfile.ui" line="337"/>
         <source>Down</source>
         <translation>Giù</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="294"/>
-        <source>Checking</source>
+        <location filename="projectfile.ui" line="368"/>
+        <source>Platform</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="319"/>
-        <source>Platform</source>
+        <location filename="projectfile.ui" line="448"/>
+        <source>Clang (experimental)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="494"/>
+        <source>If you want to design your classes to be as flexible and robust as possible then the public interface must be very robust. Cppcheck will asumme that arguments can take *any* value.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="519"/>
+        <source>Check code in headers  (should be ON normally. if you want a limited quick analysis then turn this OFF)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="572"/>
+        <source>Max recursion in template instantiation</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="420"/>
+        <location filename="projectfile.ui" line="627"/>
         <source>Warning options</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="426"/>
+        <location filename="projectfile.ui" line="633"/>
         <source>Root path:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="438"/>
+        <location filename="projectfile.ui" line="639"/>
+        <source>Filepaths in warnings will be relative to this path</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="649"/>
         <source>Warning tags (separated by semicolon)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="300"/>
+        <location filename="projectfile.ui" line="409"/>
         <source>Cppcheck build dir (whole program analysis, incremental analysis, statistics, etc)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="384"/>
+        <location filename="projectfile.ui" line="380"/>
         <source>Libraries</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Exclude</source>
-        <translation type="obsolete">Escludi</translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="500"/>
+        <location filename="projectfile.ui" line="722"/>
         <source>Suppressions</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="511"/>
+        <location filename="projectfile.ui" line="733"/>
         <source>Add</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="557"/>
-        <source>Addons and tools</source>
+        <location filename="projectfile.ui" line="786"/>
+        <location filename="projectfile.ui" line="792"/>
+        <source>Addons</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="563"/>
-        <source>Addons</source>
+        <location filename="projectfile.ui" line="798"/>
+        <source>Note: Addons require &lt;a href=&quot;https://www.python.org/&quot;&gt;Python&lt;/a&gt; being installed.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="569"/>
+        <location filename="projectfile.ui" line="808"/>
         <source>Y2038</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="576"/>
+        <location filename="projectfile.ui" line="815"/>
         <source>Thread safety</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="583"/>
+        <location filename="projectfile.ui" line="825"/>
         <source>Coding standards</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="590"/>
-        <source>Cert</source>
+        <location filename="projectfile.ui" line="958"/>
+        <source>Cert C++</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="645"/>
+        <location filename="projectfile.ui" line="982"/>
+        <source>Bug hunting (Premium)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="1011"/>
         <source>Clang analyzer</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="638"/>
+        <location filename="projectfile.ui" line="1004"/>
         <source>Clang-tidy</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="153"/>
+        <location filename="projectfile.ui" line="221"/>
         <source>Defines:</source>
         <translation>Definizioni:</translation>
     </message>
@@ -1710,277 +1990,339 @@ Options:
 <context>
     <name>ProjectFileDialog</name>
     <message>
-        <location filename="projectfiledialog.cpp" line="71"/>
+        <location filename="projectfiledialog.cpp" line="138"/>
         <source>Project file: %1</source>
         <translation>File di progetto: %1</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="409"/>
+        <location filename="projectfiledialog.cpp" line="590"/>
         <source>Select Cppcheck build dir</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="637"/>
+        <location filename="projectfiledialog.cpp" line="851"/>
         <source>Select include directory</source>
         <translation>Seleziona la cartella da includere</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="617"/>
+        <location filename="projectfiledialog.cpp" line="831"/>
         <source>Select a directory to check</source>
         <translation>Seleziona una cartella da scansionare</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="305"/>
-        <source>(no rule texts file)</source>
+        <location filename="projectfiledialog.cpp" line="396"/>
+        <source>Note: Open source Cppcheck does not fully implement Misra C 2012</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="311"/>
+        <location filename="projectfiledialog.cpp" line="461"/>
         <source>Clang-tidy (not found)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="445"/>
+        <location filename="projectfiledialog.cpp" line="629"/>
         <source>Visual Studio</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="446"/>
+        <location filename="projectfiledialog.cpp" line="630"/>
         <source>Compile database</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="447"/>
+        <location filename="projectfiledialog.cpp" line="631"/>
         <source>Borland C++ Builder 6</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="448"/>
+        <location filename="projectfiledialog.cpp" line="632"/>
         <source>Import Project</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="657"/>
+        <location filename="projectfiledialog.cpp" line="871"/>
         <source>Select directory to ignore</source>
         <translation>Seleziona la cartella da ignorare</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="742"/>
-        <source>Select MISRA rule texts file</source>
+        <location filename="projectfiledialog.cpp" line="879"/>
+        <source>Source files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="742"/>
-        <source>Misra rule texts file (%1)</source>
+        <location filename="projectfiledialog.cpp" line="880"/>
+        <source>All files</source>
         <translation type="unfinished"></translation>
     </message>
-</context>
-<context>
-    <name>QDialogButtonBox</name>
     <message>
-        <location filename="translationhandler.cpp" line="34"/>
-        <source>OK</source>
+        <location filename="projectfiledialog.cpp" line="881"/>
+        <source>Exclude file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="35"/>
-        <source>Cancel</source>
+        <location filename="projectfiledialog.cpp" line="964"/>
+        <source>Select MISRA rule texts file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="36"/>
-        <source>Close</source>
-        <translation type="unfinished">Chiudi</translation>
-    </message>
-    <message>
-        <location filename="translationhandler.cpp" line="37"/>
-        <source>Save</source>
+        <location filename="projectfiledialog.cpp" line="966"/>
+        <source>MISRA rule texts file (%1)</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>QObject</name>
     <message>
-        <location filename="translationhandler.cpp" line="104"/>
+        <location filename="translationhandler.cpp" line="91"/>
         <source>Unknown language specified!</source>
         <translation>Lingua specificata sconosciuta!</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="132"/>
+        <location filename="translationhandler.cpp" line="117"/>
         <source>Language file %1 not found!</source>
         <translation>Il file di lingua %1 non trovato!</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="138"/>
+        <location filename="translationhandler.cpp" line="122"/>
         <source>Failed to load translation for language %1 from file %2</source>
         <translation>Fallito il tentativo di aprire la traduzione per la lingua %1 dal file %2</translation>
     </message>
     <message>
-        <location filename="cppchecklibrarydata.cpp" line="33"/>
+        <location filename="cppchecklibrarydata.cpp" line="38"/>
         <source>line %1: Unhandled element %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="226"/>
+        <location filename="cppchecklibrarydata.cpp" line="43"/>
+        <source>line %1: Mandatory attribute &apos;%2&apos; missing in &apos;%3&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="284"/>
         <source> (Not found)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="69"/>
+        <location filename="codeeditstylecontrols.cpp" line="76"/>
         <source>Thin</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="71"/>
+        <location filename="codeeditstylecontrols.cpp" line="78"/>
         <source>ExtraLight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="73"/>
+        <location filename="codeeditstylecontrols.cpp" line="80"/>
         <source>Light</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="75"/>
+        <location filename="codeeditstylecontrols.cpp" line="82"/>
         <source>Normal</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="77"/>
+        <location filename="codeeditstylecontrols.cpp" line="84"/>
         <source>Medium</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="79"/>
+        <location filename="codeeditstylecontrols.cpp" line="86"/>
         <source>DemiBold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="81"/>
+        <location filename="codeeditstylecontrols.cpp" line="88"/>
         <source>Bold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="83"/>
+        <location filename="codeeditstylecontrols.cpp" line="90"/>
         <source>ExtraBold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="85"/>
+        <location filename="codeeditstylecontrols.cpp" line="92"/>
         <source>Black</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="69"/>
+        <location filename="codeeditstyledialog.cpp" line="80"/>
         <source>Editor Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="72"/>
+        <location filename="codeeditstyledialog.cpp" line="83"/>
         <source>Editor Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="75"/>
+        <location filename="codeeditstyledialog.cpp" line="86"/>
         <source>Highlight Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="78"/>
+        <location filename="codeeditstyledialog.cpp" line="89"/>
         <source>Line Number Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="81"/>
+        <location filename="codeeditstyledialog.cpp" line="92"/>
         <source>Line Number Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="84"/>
+        <location filename="codeeditstyledialog.cpp" line="95"/>
         <source>Keyword Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="87"/>
+        <location filename="codeeditstyledialog.cpp" line="98"/>
         <source>Keyword Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="90"/>
+        <location filename="codeeditstyledialog.cpp" line="101"/>
         <source>Class Foreground Color</source>
         <oldsource>Class ForegroundColor</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="93"/>
+        <location filename="codeeditstyledialog.cpp" line="104"/>
         <source>Class Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="96"/>
+        <location filename="codeeditstyledialog.cpp" line="107"/>
         <source>Quote Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="99"/>
+        <location filename="codeeditstyledialog.cpp" line="110"/>
         <source>Quote Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="102"/>
+        <location filename="codeeditstyledialog.cpp" line="113"/>
         <source>Comment Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="105"/>
+        <location filename="codeeditstyledialog.cpp" line="116"/>
         <source>Comment Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="108"/>
+        <location filename="codeeditstyledialog.cpp" line="119"/>
         <source>Symbol Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="111"/>
+        <location filename="codeeditstyledialog.cpp" line="122"/>
         <source>Symbol Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="114"/>
+        <location filename="codeeditstyledialog.cpp" line="125"/>
         <source>Symbol Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="130"/>
+        <location filename="codeeditstyledialog.cpp" line="141"/>
         <source>Set to Default Light</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="132"/>
+        <location filename="codeeditstyledialog.cpp" line="143"/>
         <source>Set to Default Dark</source>
         <translation type="unfinished"></translation>
     </message>
+    <message>
+        <location filename="resultstree.cpp" line="113"/>
+        <source>File</source>
+        <translation type="unfinished">File</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="114"/>
+        <source>Line</source>
+        <translation type="unfinished">Linea</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="115"/>
+        <source>Severity</source>
+        <translation type="unfinished">Severità</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="116"/>
+        <source>Classification</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="117"/>
+        <source>Level</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="118"/>
+        <source>Inconclusive</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="119"/>
+        <source>Summary</source>
+        <translation type="unfinished">Riassunto</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="120"/>
+        <source>Id</source>
+        <translation type="unfinished">Id</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="121"/>
+        <source>Guideline</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="122"/>
+        <source>Rule</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="123"/>
+        <source>Since date</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="124"/>
+        <source>Tags</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="125"/>
+        <source>CWE</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>QPlatformTheme</name>
     <message>
-        <location filename="translationhandler.cpp" line="39"/>
+        <location filename="translationhandler.cpp" line="41"/>
         <source>OK</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="40"/>
+        <location filename="translationhandler.cpp" line="42"/>
         <source>Cancel</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="41"/>
+        <location filename="translationhandler.cpp" line="43"/>
         <source>Close</source>
         <translation type="unfinished">Chiudi</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="42"/>
+        <location filename="translationhandler.cpp" line="44"/>
         <source>Save</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1988,129 +2330,112 @@ Options:
 <context>
     <name>ResultsTree</name>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>File</source>
-        <translation>File</translation>
+        <translation type="vanished">File</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Severity</source>
-        <translation>Severità</translation>
+        <translation type="vanished">Severità</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Line</source>
-        <translation>Linea</translation>
+        <translation type="vanished">Linea</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Summary</source>
-        <translation>Riassunto</translation>
+        <translation type="vanished">Riassunto</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="136"/>
         <source>Undefined file</source>
-        <translation>File indefinito</translation>
+        <translation type="vanished">File indefinito</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="614"/>
+        <location filename="resultstree.cpp" line="668"/>
         <source>Copy</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="797"/>
+        <location filename="resultstree.cpp" line="836"/>
         <source>Could not find file:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="801"/>
+        <location filename="resultstree.cpp" line="840"/>
         <source>Please select the folder &apos;%1&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="802"/>
+        <location filename="resultstree.cpp" line="841"/>
         <source>Select Directory &apos;%1&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="804"/>
+        <location filename="resultstree.cpp" line="843"/>
         <source>Please select the directory where file is located.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>[Inconclusive]</source>
-        <translation type="obsolete">[Inconcludente]</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="312"/>
+        <location filename="resultstree.cpp" line="373"/>
         <source>debug</source>
         <translation>debug</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="249"/>
+        <location filename="resultstree.cpp" line="307"/>
         <source>note</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="613"/>
-        <source>Recheck</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <source>Copy filename</source>
-        <translation type="obsolete">Copia nome file</translation>
-    </message>
-    <message>
-        <source>Copy full path</source>
-        <translation type="obsolete">Copia tutto il percorso</translation>
+        <source>Hide</source>
+        <translation type="vanished">Nascondi</translation>
     </message>
     <message>
-        <source>Copy message</source>
-        <translation type="obsolete">Copia messaggio</translation>
+        <location filename="resultstree.cpp" line="670"/>
+        <source>Hide all with id</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Copy message id</source>
-        <translation type="obsolete">Copia id del messaggio</translation>
+        <location filename="resultstree.cpp" line="692"/>
+        <source>Suppress selected id(s)</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="615"/>
-        <source>Hide</source>
-        <translation>Nascondi</translation>
+        <location filename="resultstree.cpp" line="671"/>
+        <source>Open containing folder</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="616"/>
-        <source>Hide all with id</source>
+        <location filename="resultstree.cpp" line="376"/>
+        <source>internal</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="617"/>
-        <source>Suppress selected id(s)</source>
+        <location filename="resultstree.cpp" line="667"/>
+        <source>Recheck %1 file(s)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="618"/>
-        <source>Open containing folder</source>
+        <location filename="resultstree.cpp" line="669"/>
+        <source>Hide %1 result(s)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="648"/>
-        <location filename="resultstree.cpp" line="1343"/>
+        <location filename="resultstree.cpp" line="712"/>
         <source>Tag</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="650"/>
+        <location filename="resultstree.cpp" line="714"/>
         <source>No tag</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="693"/>
-        <location filename="resultstree.cpp" line="707"/>
+        <location filename="resultstree.cpp" line="744"/>
+        <location filename="resultstree.cpp" line="758"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="694"/>
+        <location filename="resultstree.cpp" line="745"/>
         <source>No editor application configured.
 
 Configure the editor application for Cppcheck in preferences/Applications.</source>
@@ -2119,7 +2444,7 @@ Configure the editor application for Cppcheck in preferences/Applications.</sour
 Configura l&apos;applicazione di scrittura per Cppcheck in Preferenze/Applicazioni.</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="708"/>
+        <location filename="resultstree.cpp" line="759"/>
         <source>No default editor application selected.
 
 Please select the default editor application in preferences/Applications.</source>
@@ -2128,12 +2453,12 @@ Please select the default editor application in preferences/Applications.</sourc
 Per favore seleziona l&apos;applicazione di scrittura predefinito in Preferenze/Applicazioni.</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="737"/>
+        <location filename="resultstree.cpp" line="779"/>
         <source>Could not find the file!</source>
         <translation>Non è stato possibile trovare il file!</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="783"/>
+        <location filename="resultstree.cpp" line="822"/>
         <source>Could not start %1
 
 Please check the application path and parameters are correct.</source>
@@ -2142,60 +2467,41 @@ Please check the application path and parameters are correct.</source>
 Per favore verifica che il percorso dell&apos;applicazione e i parametri siano corretti.</translation>
     </message>
     <message>
-        <source>Could not find file:
-%1
-Please select the directory where file is located.</source>
-        <translation type="obsolete">Non è stato possibile trovare il file:
-%1
-Per favore selezioa la cartella dove il file è posizionato.</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="805"/>
+        <location filename="resultstree.cpp" line="844"/>
         <source>Select Directory</source>
         <translation>Seleziona Cartella</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Id</source>
-        <translation>Id</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="1343"/>
-        <source>Inconclusive</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="1343"/>
-        <source>Since date</source>
-        <translation type="unfinished"></translation>
+        <translation type="vanished">Id</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="294"/>
+        <location filename="resultstree.cpp" line="355"/>
         <source>style</source>
         <translation>stile</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="297"/>
+        <location filename="resultstree.cpp" line="358"/>
         <source>error</source>
         <translation>errore</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="300"/>
+        <location filename="resultstree.cpp" line="361"/>
         <source>warning</source>
         <translation>avviso</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="303"/>
+        <location filename="resultstree.cpp" line="364"/>
         <source>performance</source>
         <translation>performance</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="306"/>
+        <location filename="resultstree.cpp" line="367"/>
         <source>portability</source>
         <translation>portabilità</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="309"/>
+        <location filename="resultstree.cpp" line="370"/>
         <source>information</source>
         <translation>Informazione</translation>
     </message>
@@ -2203,90 +2509,102 @@ Per favore selezioa la cartella dove il file è posizionato.</translation>
 <context>
     <name>ResultsView</name>
     <message>
-        <location filename="resultsview.cpp" line="201"/>
+        <location filename="resultsview.cpp" line="255"/>
         <source>Print Report</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="220"/>
+        <location filename="resultsview.cpp" line="274"/>
         <source>No errors found, nothing to print.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="264"/>
+        <location filename="resultsview.cpp" line="326"/>
         <source>%p% (%1 of %2 files checked)</source>
         <translation>%p% (%1 su %2 file scansionati)</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="277"/>
-        <location filename="resultsview.cpp" line="288"/>
+        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="361"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="278"/>
+        <location filename="resultsview.cpp" line="351"/>
         <source>No errors found.</source>
         <translation>Nessun errore trovato.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="285"/>
+        <location filename="resultsview.cpp" line="358"/>
         <source>Errors were found, but they are configured to be hidden.
 To toggle what kind of errors are shown, open view menu.</source>
         <translation>Sono stati trovati errori, ma sono stati configurati per essere nascosti.
 Per vedere il tipo di errori che sono mostrati, apri il menu Visualizza.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="331"/>
-        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="421"/>
         <source>Failed to read the report.</source>
         <translation>Apertura del report fallito.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="338"/>
+        <location filename="resultsview.cpp" line="409"/>
         <source>XML format version 1 is no longer supported.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Summary</source>
-        <translation type="obsolete">Riassunto</translation>
-    </message>
-    <message>
-        <source>Message</source>
-        <translation type="obsolete">Messaggio</translation>
-    </message>
-    <message>
-        <location filename="resultsview.cpp" line="399"/>
+        <location filename="resultsview.cpp" line="460"/>
         <source>First included by</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="465"/>
         <source>Id</source>
         <translation>Id</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="471"/>
+        <location filename="resultsview.cpp" line="539"/>
         <source>Clear Log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="472"/>
+        <location filename="resultsview.cpp" line="540"/>
         <source>Copy this Log entry</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="473"/>
+        <location filename="resultsview.cpp" line="541"/>
         <source>Copy complete Log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="159"/>
-        <source>No errors found, nothing to save.</source>
-        <translation>Nessun errore trovato, nulla da salvare.</translation>
+        <location filename="resultsview.cpp" line="549"/>
+        <source>Analysis was stopped</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="563"/>
+        <source>There was a critical error with id &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="565"/>
+        <source>when checking %1</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="567"/>
+        <source>when checking a file</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="183"/>
-        <location filename="resultsview.cpp" line="191"/>
+        <location filename="resultsview.cpp" line="568"/>
+        <source>Analysis was aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="237"/>
+        <location filename="resultsview.cpp" line="245"/>
         <source>Failed to save the report.</source>
         <translation>Salvataggio del report fallito.</translation>
     </message>
@@ -2296,12 +2614,17 @@ Per vedere il tipo di errori che sono mostrati, apri il menu Visualizza.</transl
         <translation>Risultati</translation>
     </message>
     <message>
-        <location filename="resultsview.ui" line="82"/>
+        <location filename="resultsview.ui" line="60"/>
+        <source>Critical errors</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.ui" line="92"/>
         <source>Analysis Log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.ui" line="104"/>
+        <location filename="resultsview.ui" line="114"/>
         <source>Warning Details</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2347,11 +2670,7 @@ Per vedere il tipo di errori che sono mostrati, apri il menu Visualizza.</transl
         <translation>Generale</translation>
     </message>
     <message>
-        <source>Include paths:</source>
-        <translation type="obsolete">Percorsi d&apos;inclusione:</translation>
-    </message>
-    <message>
-        <location filename="settings.ui" line="195"/>
+        <location filename="settings.ui" line="196"/>
         <source>Add...</source>
         <translation>Aggiungi...</translation>
     </message>
@@ -2361,499 +2680,506 @@ Per vedere il tipo di errori che sono mostrati, apri il menu Visualizza.</transl
         <translation>Numero di threads: </translation>
     </message>
     <message>
-        <location filename="settings.ui" line="85"/>
         <source>Ideal count:</source>
-        <translation>Numero ideale:</translation>
+        <translation type="vanished">Numero ideale:</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="114"/>
+        <location filename="settings.ui" line="108"/>
         <source>Force checking all #ifdef configurations</source>
         <translation>Forza la scansione di tutte le configurazioni #ifdef</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="121"/>
+        <location filename="settings.ui" line="115"/>
         <source>Show full path of files</source>
         <translation>Mostra tutto il percorso dei files</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="128"/>
+        <location filename="settings.ui" line="122"/>
         <source>Show &quot;No errors found&quot; message when no errors found</source>
         <translation>Mostra il messaggio &quot;Nessun errore trovato&quot; quando nessun errore è stato trovato</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="135"/>
+        <location filename="settings.ui" line="129"/>
         <source>Display error Id in column &quot;Id&quot;</source>
         <translation>Mostra l&apos;id dell&apos;errore nella colonna &quot;Id&quot;</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="142"/>
+        <location filename="settings.ui" line="136"/>
         <source>Enable inline suppressions</source>
         <translation>Abilita le soppressioni</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="149"/>
+        <location filename="settings.ui" line="143"/>
         <source>Check for inconclusive errors also</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="156"/>
+        <location filename="settings.ui" line="150"/>
         <source>Show statistics on check completion</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="176"/>
+        <location filename="settings.ui" line="157"/>
+        <source>Check for updates</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="177"/>
         <source>Show internal warnings in log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="287"/>
+        <location filename="settings.ui" line="288"/>
         <source>Addons</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="293"/>
+        <location filename="settings.ui" line="294"/>
         <source>Python binary (leave this empty to use python in the PATH)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="302"/>
-        <location filename="settings.ui" line="334"/>
-        <location filename="settings.ui" line="379"/>
+        <location filename="settings.ui" line="305"/>
+        <location filename="settings.ui" line="346"/>
+        <location filename="settings.ui" line="391"/>
         <source>...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="312"/>
-        <source>Misra addon</source>
+        <location filename="settings.ui" line="324"/>
+        <source>MISRA addon</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="320"/>
-        <source>Misra rule texts file</source>
+        <location filename="settings.ui" line="332"/>
+        <source>MISRA rule texts file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="327"/>
+        <location filename="settings.ui" line="339"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="360"/>
+        <location filename="settings.ui" line="372"/>
         <source>Clang</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="366"/>
+        <location filename="settings.ui" line="378"/>
         <source>Clang path (leave empty to use system PATH)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="389"/>
+        <location filename="settings.ui" line="401"/>
         <source>Visual Studio headers</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="395"/>
+        <location filename="settings.ui" line="407"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Paths to Visual Studio headers, separated by semicolon &apos;;&apos;.&lt;/p&gt;&lt;p&gt;You can open a Visual Studio command prompt, write &amp;quot;SET INCLUDE&amp;quot;. Then copy/paste the paths.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="425"/>
+        <location filename="settings.ui" line="437"/>
         <source>Code Editor</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="431"/>
+        <location filename="settings.ui" line="443"/>
         <source>Code Editor Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="437"/>
+        <location filename="settings.ui" line="449"/>
         <source>System Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="444"/>
+        <location filename="settings.ui" line="456"/>
         <source>Default Light Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="451"/>
+        <location filename="settings.ui" line="463"/>
         <source>Default Dark Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="460"/>
+        <location filename="settings.ui" line="472"/>
         <source>Custom</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Paths</source>
-        <translation type="obsolete">Percorsi</translation>
-    </message>
-    <message>
-        <source>Edit</source>
-        <translation type="obsolete">Modifica</translation>
-    </message>
-    <message>
-        <location filename="settings.ui" line="209"/>
+        <location filename="settings.ui" line="210"/>
         <source>Remove</source>
         <translation>Rimuovi</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="184"/>
+        <location filename="settings.ui" line="79"/>
+        <source>Max count:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="185"/>
         <source>Applications</source>
         <translation>Applicazioni</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="202"/>
-        <location filename="settings.ui" line="467"/>
+        <location filename="settings.ui" line="203"/>
+        <location filename="settings.ui" line="479"/>
         <source>Edit...</source>
         <translation>Modifica...</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="216"/>
+        <location filename="settings.ui" line="217"/>
         <source>Set as default</source>
         <translation>Imposta come predefinito</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="239"/>
+        <location filename="settings.ui" line="240"/>
         <source>Reports</source>
         <translation>Rapporti</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="245"/>
+        <location filename="settings.ui" line="246"/>
         <source>Save all errors when creating report</source>
         <translation>Salva tutti gli errori quando viene creato il rapporto</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="252"/>
+        <location filename="settings.ui" line="253"/>
         <source>Save full path to files in reports</source>
         <translation>Salva tutto il percorso ai files nei rapporti</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="273"/>
+        <location filename="settings.ui" line="274"/>
         <source>Language</source>
         <translation>Lingua</translation>
     </message>
-    <message>
-        <source>Advanced</source>
-        <translation type="obsolete">Avanzate</translation>
-    </message>
-    <message>
-        <source>&amp;Show inconclusive errors</source>
-        <translation type="obsolete">&amp;Mostra errori inconcludenti</translation>
-    </message>
-    <message>
-        <source>S&amp;how internal warnings in log</source>
-        <translation type="obsolete">&amp;Mostra avvisi interni nel log</translation>
-    </message>
 </context>
 <context>
     <name>SettingsDialog</name>
     <message>
-        <location filename="settingsdialog.cpp" line="100"/>
         <source>N/A</source>
-        <translation>N/A</translation>
+        <translation type="vanished">N/A</translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="232"/>
+        <source>The executable file &quot;%1&quot; is not available</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="200"/>
+        <location filename="settingsdialog.cpp" line="243"/>
         <source>Add a new application</source>
         <translation>Aggiungi una nuova applicazione</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="233"/>
+        <location filename="settingsdialog.cpp" line="273"/>
         <source>Modify an application</source>
         <translation>Modifica un&apos;applicazione</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="238"/>
+        <location filename="settingsdialog.cpp" line="278"/>
         <source> [Default]</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="263"/>
+        <location filename="settingsdialog.cpp" line="303"/>
         <source>[Default]</source>
         <translation>[Predefinito]</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="318"/>
+        <location filename="settingsdialog.cpp" line="358"/>
         <source>Select python binary</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="325"/>
+        <location filename="settingsdialog.cpp" line="365"/>
         <source>Select MISRA File</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="356"/>
+        <location filename="settingsdialog.cpp" line="396"/>
         <source>Select clang path</source>
         <translation type="unfinished"></translation>
     </message>
-    <message>
-        <source>Select include directory</source>
-        <translation type="obsolete">Seleziona la cartella da includere</translation>
-    </message>
 </context>
 <context>
     <name>StatsDialog</name>
     <message>
-        <location filename="stats.ui" line="14"/>
-        <location filename="stats.ui" line="248"/>
-        <location filename="statsdialog.cpp" line="137"/>
-        <location filename="statsdialog.cpp" line="184"/>
+        <location filename="statsdialog.ui" line="14"/>
+        <location filename="statsdialog.ui" line="248"/>
+        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="230"/>
         <source>Statistics</source>
         <translation>Statistiche</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="27"/>
-        <location filename="statsdialog.cpp" line="175"/>
+        <location filename="statsdialog.ui" line="27"/>
+        <location filename="statsdialog.cpp" line="221"/>
         <source>Project</source>
         <translation>Progetto</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="33"/>
+        <location filename="statsdialog.ui" line="33"/>
         <source>Project:</source>
         <translation>Progetto:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="53"/>
+        <location filename="statsdialog.ui" line="53"/>
         <source>Paths:</source>
         <translation>Percorsi:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="85"/>
+        <location filename="statsdialog.ui" line="85"/>
         <source>Include paths:</source>
         <translation>Percorsi di inclusione:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="108"/>
+        <location filename="statsdialog.ui" line="108"/>
         <source>Defines:</source>
         <translation>Definizioni:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="131"/>
+        <location filename="statsdialog.ui" line="131"/>
         <source>Undefines:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="165"/>
-        <location filename="statsdialog.cpp" line="180"/>
+        <location filename="statsdialog.ui" line="165"/>
+        <location filename="statsdialog.cpp" line="226"/>
         <source>Previous Scan</source>
         <translation>Precedente Scansione</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="171"/>
+        <location filename="statsdialog.ui" line="171"/>
         <source>Path Selected:</source>
         <translation>Selezionato percorso:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="181"/>
+        <location filename="statsdialog.ui" line="181"/>
         <source>Number of Files Scanned:</source>
         <translation>Numero di Files Scansionati:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="201"/>
+        <location filename="statsdialog.ui" line="201"/>
         <source>Scan Duration:</source>
         <translation>Durata della scansione:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="256"/>
+        <location filename="statsdialog.ui" line="254"/>
         <source>Errors:</source>
         <translation>Errori:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="274"/>
+        <location filename="statsdialog.ui" line="271"/>
         <source>Warnings:</source>
         <translation>Avvisi:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="292"/>
+        <location filename="statsdialog.ui" line="288"/>
         <source>Stylistic warnings:</source>
         <translation>Avvisi sullo stile:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="310"/>
+        <location filename="statsdialog.ui" line="305"/>
         <source>Portability warnings:</source>
         <translation>Avvisi sulla portabilità:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="328"/>
+        <location filename="statsdialog.ui" line="322"/>
         <source>Performance issues:</source>
         <translation>Casi sulla performance:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="346"/>
+        <location filename="statsdialog.ui" line="339"/>
         <source>Information messages:</source>
         <translation>Messaggi di informazione:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="363"/>
+        <location filename="statsdialog.ui" line="356"/>
+        <source>Active checkers:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="374"/>
+        <source>Checkers</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="399"/>
         <source>History</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="369"/>
+        <location filename="statsdialog.ui" line="405"/>
         <source>File:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="407"/>
+        <location filename="statsdialog.ui" line="443"/>
         <source>Copy to Clipboard</source>
         <translation>Copia negli Appunti</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="414"/>
+        <location filename="statsdialog.ui" line="450"/>
         <source>Pdf Export</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="113"/>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>1 day</source>
         <translation>1 giorno</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="113"/>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>%1 days</source>
         <translation>%1 giorni</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="115"/>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>1 hour</source>
         <translation>1 ora</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="115"/>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>%1 hours</source>
         <translation>%1 ore</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="117"/>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>1 minute</source>
         <translation>1 minuto</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="117"/>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>%1 minutes</source>
         <translation>%1 minuti</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="119"/>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>1 second</source>
         <translation>1 secondo</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="119"/>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>%1 seconds</source>
         <translation>%1 secondi</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="123"/>
+        <location filename="statsdialog.cpp" line="169"/>
         <source>0.%1 seconds</source>
         <translation>0,%1 secondi</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="125"/>
+        <location filename="statsdialog.cpp" line="171"/>
         <source> and </source>
         <translation> e </translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="152"/>
+        <location filename="statsdialog.cpp" line="198"/>
         <source>Export PDF</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="174"/>
+        <location filename="statsdialog.cpp" line="220"/>
         <source>Project Settings</source>
         <translation>Impostazioni progetto</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="176"/>
+        <location filename="statsdialog.cpp" line="222"/>
         <source>Paths</source>
         <translation>Percorsi</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="177"/>
+        <location filename="statsdialog.cpp" line="223"/>
         <source>Include paths</source>
         <translation>Percorsi di inclusione</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="178"/>
+        <location filename="statsdialog.cpp" line="224"/>
         <source>Defines</source>
         <translation>Definizioni</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="179"/>
+        <location filename="statsdialog.cpp" line="225"/>
         <source>Undefines</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="181"/>
+        <location filename="statsdialog.cpp" line="227"/>
         <source>Path selected</source>
         <translation>Selezionato percorso</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="182"/>
+        <location filename="statsdialog.cpp" line="228"/>
         <source>Number of files scanned</source>
         <translation>Numero di file scansionati</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="229"/>
         <source>Scan duration</source>
         <translation>Durata della scansione</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="139"/>
         <location filename="statsdialog.cpp" line="185"/>
+        <location filename="statsdialog.cpp" line="231"/>
         <source>Errors</source>
         <translation>Errori</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="65"/>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>File: </source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="65"/>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>No cppcheck build dir</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="141"/>
-        <location filename="statsdialog.cpp" line="186"/>
+        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="232"/>
         <source>Warnings</source>
         <translation>Avvisi</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="143"/>
-        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="233"/>
         <source>Style warnings</source>
         <translation>Stilwarnungen</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="145"/>
-        <location filename="statsdialog.cpp" line="188"/>
+        <location filename="statsdialog.cpp" line="191"/>
+        <location filename="statsdialog.cpp" line="234"/>
         <source>Portability warnings</source>
         <translation>Avvisi sulla portabilità</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="147"/>
-        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="193"/>
+        <location filename="statsdialog.cpp" line="235"/>
         <source>Performance warnings</source>
         <translation>Avvisi sulle performance</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="149"/>
-        <location filename="statsdialog.cpp" line="190"/>
+        <location filename="statsdialog.cpp" line="195"/>
+        <location filename="statsdialog.cpp" line="236"/>
         <source>Information messages</source>
         <translation>Messaggi di informazione</translation>
     </message>
 </context>
+<context>
+    <name>ThreadDetails</name>
+    <message>
+        <location filename="threaddetails.ui" line="14"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>ThreadResult</name>
     <message>
-        <location filename="threadresult.cpp" line="54"/>
+        <location filename="threadresult.cpp" line="47"/>
         <source>%1 of %2 files checked</source>
         <translation>%1 su %2 file scansionati</translation>
     </message>
@@ -2861,7 +3187,7 @@ Per vedere il tipo di errori che sono mostrati, apri il menu Visualizza.</transl
 <context>
     <name>TranslationHandler</name>
     <message>
-        <location filename="translationhandler.cpp" line="145"/>
+        <location filename="translationhandler.cpp" line="130"/>
         <source>Failed to change the user interface language:
 
 %1
@@ -2874,7 +3200,7 @@ The user interface language has been reset to English. Open the Preferences-dial
 L&apos;interfaccia utente è stata risettata in Inglese. Apri la finestra di dialogo Preferenze per selezionare una qualunque lingua a disposizione.</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="151"/>
+        <location filename="translationhandler.cpp" line="136"/>
         <source>Cppcheck</source>
         <translation type="unfinished">Cppcheck</translation>
     </message>
@@ -2882,7 +3208,7 @@ L&apos;interfaccia utente è stata risettata in Inglese. Apri la finestra di dia
 <context>
     <name>TxtReport</name>
     <message>
-        <location filename="txtreport.cpp" line="73"/>
+        <location filename="txtreport.cpp" line="74"/>
         <source>inconclusive</source>
         <translation>inconcludente</translation>
     </message>
@@ -2890,12 +3216,12 @@ L&apos;interfaccia utente è stata risettata in Inglese. Apri la finestra di dia
 <context>
     <name>toFilterString</name>
     <message>
-        <location filename="common.cpp" line="52"/>
+        <location filename="common.cpp" line="58"/>
         <source>All supported files (%1)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="common.cpp" line="57"/>
+        <location filename="common.cpp" line="63"/>
         <source>All files (%1)</source>
         <translation type="unfinished"></translation>
     </message>
diff --git a/gui/cppcheck_ja.ts b/gui/cppcheck_ja.ts
index 90657ffc59a..4c0cc7a95f2 100644
--- a/gui/cppcheck_ja.ts
+++ b/gui/cppcheck_ja.ts
@@ -20,8 +20,9 @@
     </message>
     <message>
         <location filename="about.ui" line="81"/>
-        <source>Copyright © 2007-2019 Cppcheck team.</source>
-        <translation>Copyright © 2007-2019 Cppcheck team.</translation>
+        <source>Copyright © 2007-%1 Cppcheck team.</source>
+        <oldsource>Copyright © 2007-2021 Cppcheck team.</oldsource>
+        <translation>Copyright © 2007-%1 Cppcheck team.</translation>
     </message>
     <message>
         <location filename="about.ui" line="91"/>
@@ -36,29 +37,20 @@ of the GNU General Public License version 3</source>
     </message>
     <message>
         <location filename="about.ui" line="115"/>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
-&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul&gt;
-&lt;li&gt;tinyxml2&lt;/li&gt;
-&lt;li&gt;picojson&lt;/li&gt;
-&lt;li&gt;pcre&lt;/li&gt;
-&lt;li&gt;qt&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
-        <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
-&lt;p&gt;私達は以下のライブラリを使用しています。ここで感謝の意を表明します。&lt;/p&gt;&lt;ul&gt;
-&lt;li&gt;tinyxml2&lt;/li&gt;
-&lt;li&gt;picojson&lt;/li&gt;
-&lt;li&gt;pcre&lt;/li&gt;
-&lt;li&gt;qt&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</translation>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PCRE&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PicoJSON&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;TinyXML2&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Boost&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <oldsource>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;pcre&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;picojson&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;tinyxml2&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</oldsource>
+        <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;ライブラリの開発者に感謝を捧げます:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PCRE&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PicoJSON&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;TinyXML2&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Boost&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
 </context>
 <context>
     <name>ApplicationDialog</name>
     <message>
-        <location filename="application.ui" line="23"/>
+        <location filename="applicationdialog.ui" line="23"/>
         <source>Add an application</source>
         <translation>アプリケーションの追加</translation>
     </message>
     <message>
-        <location filename="application.ui" line="41"/>
+        <location filename="applicationdialog.ui" line="41"/>
         <source>Here you can add an application that can open error files. Specify a name for the application, the application executable and command line parameters for the application.
 
 The following texts in parameters are replaced with appropriate values when application is executed:
@@ -84,65 +76,161 @@ Executable: kate
 Parameters: -l(line) (file)</translation>
     </message>
     <message>
-        <location filename="application.ui" line="76"/>
+        <location filename="applicationdialog.ui" line="76"/>
         <source>&amp;Name:</source>
         <translation>表示名(&amp;N):</translation>
     </message>
     <message>
-        <location filename="application.ui" line="86"/>
+        <location filename="applicationdialog.ui" line="86"/>
         <source>&amp;Executable:</source>
         <translation>実行ファイルのパス(&amp;E):</translation>
     </message>
     <message>
-        <location filename="application.ui" line="96"/>
+        <location filename="applicationdialog.ui" line="96"/>
         <source>&amp;Parameters:</source>
         <translation>パラメータ(&amp;P):</translation>
     </message>
     <message>
-        <location filename="application.ui" line="138"/>
+        <location filename="applicationdialog.ui" line="138"/>
         <source>Browse</source>
         <translation>参照</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="59"/>
+        <location filename="applicationdialog.cpp" line="65"/>
         <source>Executable files (*.exe);;All files(*.*)</source>
         <translation>実行ファイル (*.exe);;すべてのファイル(*.*)</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="62"/>
+        <location filename="applicationdialog.cpp" line="68"/>
         <source>Select viewer application</source>
         <translation>表示アプリケーションの選択</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="77"/>
+        <location filename="applicationdialog.cpp" line="83"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="78"/>
+        <location filename="applicationdialog.cpp" line="84"/>
         <source>You must specify a name, a path and optionally parameters for the application!</source>
         <translation>アプリケーションの表示名と実行ファイルのパスと(オプションの)引数を指定してください!</translation>
     </message>
 </context>
+<context>
+    <name>ComplianceReportDialog</name>
+    <message>
+        <location filename="compliancereportdialog.ui" line="14"/>
+        <source>Compliance Report</source>
+        <translation>コンプライアンスレポート</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="29"/>
+        <source>Project name</source>
+        <translation>プロジェクト名</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="22"/>
+        <source>Project version</source>
+        <translation>プロジェクトバージョン</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="42"/>
+        <source>Coding Standard</source>
+        <translation>コーディング標準</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="50"/>
+        <source>Misra C</source>
+        <translation>MISRA C</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="55"/>
+        <source>Cert C</source>
+        <translation>CERT C</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="60"/>
+        <source>Cert C++</source>
+        <translation>Cert C++</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="70"/>
+        <source>List of files with md5 checksums</source>
+        <translation>md5チェックサムつきファイルリスト</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="133"/>
+        <source>Compliance report</source>
+        <translation>コンプライアンスレポート</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="135"/>
+        <source>HTML files (*.html)</source>
+        <translation>HTMLファイル(*.html)</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="176"/>
+        <location filename="compliancereportdialog.cpp" line="239"/>
+        <source>Save compliance report</source>
+        <translation>コンプライアンスレポートの保存</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="177"/>
+        <source>Failed to import &apos;%1&apos; (%2), can not show files in compliance report</source>
+        <translation>&apos;%1&apos; (%2)のインポートに失敗しました。コンプライアンスレポートに表示できません</translation>
+    </message>
+    <message>
+        <source>Failed to import &apos;%1&apos;, can not show files in compliance report</source>
+        <translation type="vanished">&apos;%1&apos;のインポートに失敗しました、コンプライアンスレポートでファイルを表示できません</translation>
+    </message>
+</context>
 <context>
     <name>FileViewDialog</name>
     <message>
-        <location filename="fileviewdialog.cpp" line="42"/>
+        <location filename="fileviewdialog.cpp" line="53"/>
         <source>Could not find the file: %1</source>
         <translation>ファイル：%1 が見つかりません</translation>
     </message>
     <message>
-        <location filename="fileviewdialog.cpp" line="46"/>
-        <location filename="fileviewdialog.cpp" line="60"/>
+        <location filename="fileviewdialog.cpp" line="57"/>
+        <location filename="fileviewdialog.cpp" line="71"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="fileviewdialog.cpp" line="56"/>
+        <location filename="fileviewdialog.cpp" line="67"/>
         <source>Could not read the file: %1</source>
         <translation>ファイル：%1 が読み込めません</translation>
     </message>
 </context>
+<context>
+    <name>HelpDialog</name>
+    <message>
+        <location filename="helpdialog.ui" line="14"/>
+        <source>Cppcheck GUI help</source>
+        <translation>Cppcheck GUI ヘルプ</translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="34"/>
+        <source>Contents</source>
+        <translation>目次</translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="44"/>
+        <source>Index</source>
+        <translation>インデックス</translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="84"/>
+        <source>Helpfile &apos;%1&apos; was not found</source>
+        <translation>ヘルプファイル &apos;%1&apos; が見つかりません</translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="86"/>
+        <source>Cppcheck</source>
+        <translation>Cppcheck</translation>
+    </message>
+</context>
 <context>
     <name>LibraryAddFunctionDialog</name>
     <message>
@@ -249,42 +337,42 @@ Parameters: -l(line) (file)</translation>
         <translation>編集</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="82"/>
-        <location filename="librarydialog.cpp" line="154"/>
+        <location filename="librarydialog.cpp" line="97"/>
+        <location filename="librarydialog.cpp" line="169"/>
         <source>Library files (*.cfg)</source>
         <translation>ライブラリファイル(*.cfg)</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="84"/>
+        <location filename="librarydialog.cpp" line="99"/>
         <source>Open library file</source>
         <translation>ライブラリファイルを開く</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="95"/>
-        <location filename="librarydialog.cpp" line="107"/>
-        <location filename="librarydialog.cpp" line="144"/>
+        <location filename="librarydialog.cpp" line="110"/>
+        <location filename="librarydialog.cpp" line="122"/>
+        <location filename="librarydialog.cpp" line="159"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="96"/>
+        <location filename="librarydialog.cpp" line="111"/>
         <source>Cannot open file %1.</source>
         <oldsource>Can not open file %1.</oldsource>
         <translation>ファイルが見つかりません %1。</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="108"/>
+        <location filename="librarydialog.cpp" line="123"/>
         <source>Failed to load %1. %2.</source>
         <translation>読み込みに失敗しました(%1.%2)。</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="145"/>
+        <location filename="librarydialog.cpp" line="160"/>
         <source>Cannot save file %1.</source>
         <oldsource>Can not save file %1.</oldsource>
         <translation>ファイルが保存できません %1。</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="157"/>
+        <location filename="librarydialog.cpp" line="172"/>
         <source>Save the library as</source>
         <translation>このライブラリに名前をつけて保存する</translation>
     </message>
@@ -375,10 +463,6 @@ Parameters: -l(line) (file)</translation>
         <source>argvalue</source>
         <translation>argvalue(引数の値)</translation>
     </message>
-    <message>
-        <source>constant</source>
-        <translation type="obsolete">constant(定数)</translation>
-    </message>
     <message>
         <location filename="libraryeditargdialog.ui" line="119"/>
         <location filename="libraryeditargdialog.ui" line="224"/>
@@ -414,670 +498,640 @@ Parameters: -l(line) (file)</translation>
         <translation>妥当な値</translation>
     </message>
 </context>
-<context>
-    <name>LogView</name>
-    <message>
-        <source>Checking Log</source>
-        <translation type="obsolete">Cppcheck ログ</translation>
-    </message>
-    <message>
-        <source>Clear</source>
-        <translation type="obsolete">消去</translation>
-    </message>
-    <message>
-        <source>Save Log</source>
-        <translation type="obsolete">ログ保存</translation>
-    </message>
-    <message>
-        <source>Text files (*.txt *.log);;All files (*.*)</source>
-        <translation type="obsolete">テキストファイル (*.txt *.log);;すべてのファイル(*.*)</translation>
-    </message>
-    <message>
-        <source>Cppcheck</source>
-        <translation type="obsolete">Cppcheck</translation>
-    </message>
-    <message>
-        <source>Could not open file for writing: &quot;%1&quot;</source>
-        <translation type="obsolete">ファイルを書き込みできない</translation>
-    </message>
-</context>
 <context>
     <name>MainWindow</name>
     <message>
         <location filename="mainwindow.ui" line="26"/>
-        <location filename="mainwindow.ui" line="595"/>
-        <location filename="mainwindow.cpp" line="328"/>
-        <location filename="mainwindow.cpp" line="480"/>
-        <location filename="mainwindow.cpp" line="553"/>
-        <location filename="mainwindow.cpp" line="658"/>
-        <location filename="mainwindow.cpp" line="680"/>
-        <location filename="mainwindow.cpp" line="1113"/>
-        <location filename="mainwindow.cpp" line="1238"/>
-        <location filename="mainwindow.cpp" line="1359"/>
-        <location filename="mainwindow.cpp" line="1499"/>
-        <location filename="mainwindow.cpp" line="1522"/>
-        <location filename="mainwindow.cpp" line="1593"/>
-        <location filename="mainwindow.cpp" line="1667"/>
+        <location filename="mainwindow.ui" line="688"/>
+        <location filename="mainwindow.cpp" line="466"/>
+        <location filename="mainwindow.cpp" line="670"/>
+        <location filename="mainwindow.cpp" line="755"/>
+        <location filename="mainwindow.cpp" line="860"/>
+        <location filename="mainwindow.cpp" line="882"/>
+        <location filename="mainwindow.cpp" line="1467"/>
+        <location filename="mainwindow.cpp" line="1596"/>
+        <location filename="mainwindow.cpp" line="1937"/>
+        <location filename="mainwindow.cpp" line="1945"/>
+        <location filename="mainwindow.cpp" line="1999"/>
+        <location filename="mainwindow.cpp" line="2008"/>
+        <location filename="mainwindow.cpp" line="2080"/>
+        <location filename="mainwindow.cpp" line="2168"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="70"/>
+        <location filename="mainwindow.ui" line="132"/>
         <source>&amp;File</source>
         <translation>ファイル(&amp;F)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="89"/>
+        <location filename="mainwindow.ui" line="152"/>
         <source>&amp;View</source>
         <translation>表示(&amp;V)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="93"/>
+        <location filename="mainwindow.ui" line="156"/>
         <source>&amp;Toolbars</source>
         <translation>ツールバー(&amp;T)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="121"/>
+        <location filename="mainwindow.ui" line="199"/>
         <source>&amp;Help</source>
         <translation>ヘルプ(&amp;H)</translation>
     </message>
     <message>
-        <source>&amp;Check</source>
-        <translation type="obsolete">解析(&amp;A)</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="135"/>
+        <location filename="mainwindow.ui" line="214"/>
         <source>C++ standard</source>
         <translation>C++標準</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="145"/>
+        <location filename="mainwindow.ui" line="226"/>
         <source>&amp;C standard</source>
         <oldsource>C standard</oldsource>
         <translation>&amp;C標準</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="170"/>
+        <location filename="mainwindow.ui" line="254"/>
         <source>&amp;Edit</source>
         <translation>編集(&amp;E)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="183"/>
+        <location filename="mainwindow.ui" line="267"/>
         <source>Standard</source>
         <translation>言語規格</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="201"/>
+        <location filename="mainwindow.ui" line="285"/>
         <source>Categories</source>
         <translation>カテゴリ</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="231"/>
+        <location filename="mainwindow.ui" line="315"/>
         <source>&amp;License...</source>
         <translation>ライセンス(&amp;L)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="236"/>
+        <location filename="mainwindow.ui" line="320"/>
         <source>A&amp;uthors...</source>
         <translation>作者(&amp;u)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="245"/>
+        <location filename="mainwindow.ui" line="329"/>
         <source>&amp;About...</source>
         <translation>Cppcheckについて(&amp;A)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="250"/>
+        <location filename="mainwindow.ui" line="334"/>
         <source>&amp;Files...</source>
         <translation>ファイル選択(&amp;F)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="253"/>
-        <location filename="mainwindow.ui" line="256"/>
+        <location filename="mainwindow.ui" line="337"/>
+        <location filename="mainwindow.ui" line="340"/>
         <source>Analyze files</source>
         <oldsource>Check files</oldsource>
         <translation>ファイルをチェックする</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="259"/>
+        <location filename="mainwindow.ui" line="343"/>
         <source>Ctrl+F</source>
         <translation>Ctrl+F</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="268"/>
+        <location filename="mainwindow.ui" line="352"/>
         <source>&amp;Directory...</source>
         <translation>ディレクトリ選択(&amp;D)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="271"/>
-        <location filename="mainwindow.ui" line="274"/>
+        <location filename="mainwindow.ui" line="355"/>
+        <location filename="mainwindow.ui" line="358"/>
         <source>Analyze directory</source>
         <oldsource>Check directory</oldsource>
         <translation>ディレクトリをチェックする</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="277"/>
+        <location filename="mainwindow.ui" line="361"/>
         <source>Ctrl+D</source>
         <translation>Ctrl+D</translation>
     </message>
     <message>
-        <source>&amp;Recheck files</source>
-        <translation type="obsolete">再チェック(&amp;R)</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="289"/>
+        <location filename="mainwindow.ui" line="373"/>
         <source>Ctrl+R</source>
         <translation>Ctrl+R</translation>
     </message>
     <message>
-        <source>&amp;Reanalyze all files</source>
-        <oldsource>&amp;Recheck all files</oldsource>
-        <translation type="obsolete">全ファイル再チェック</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="307"/>
+        <location filename="mainwindow.ui" line="391"/>
         <source>&amp;Stop</source>
         <translation>停止(&amp;S)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="310"/>
-        <location filename="mainwindow.ui" line="313"/>
+        <location filename="mainwindow.ui" line="394"/>
+        <location filename="mainwindow.ui" line="397"/>
         <source>Stop analysis</source>
         <oldsource>Stop checking</oldsource>
         <translation>チェックを停止する</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="316"/>
+        <location filename="mainwindow.ui" line="400"/>
         <source>Esc</source>
         <translation>Esc</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="325"/>
+        <location filename="mainwindow.ui" line="409"/>
         <source>&amp;Save results to file...</source>
         <translation>結果をファイルに保存(&amp;S)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="328"/>
+        <location filename="mainwindow.ui" line="412"/>
         <source>Ctrl+S</source>
         <translation>Ctrl+S</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="333"/>
+        <location filename="mainwindow.ui" line="417"/>
         <source>&amp;Quit</source>
         <translation>終了(&amp;Q)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="342"/>
+        <location filename="mainwindow.ui" line="429"/>
         <source>&amp;Clear results</source>
         <translation>結果をクリア(&amp;C)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="351"/>
+        <location filename="mainwindow.ui" line="438"/>
         <source>&amp;Preferences</source>
         <translation>設定(&amp;P)</translation>
     </message>
     <message>
-        <source>Style warnings</source>
-        <translation type="obsolete">スタイル警告</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="366"/>
-        <location filename="mainwindow.ui" line="369"/>
+        <location filename="mainwindow.ui" line="453"/>
+        <location filename="mainwindow.ui" line="456"/>
         <source>Show style warnings</source>
         <translation>スタイル警告を表示</translation>
     </message>
     <message>
-        <source>Errors</source>
-        <translation type="obsolete">エラー</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="384"/>
-        <location filename="mainwindow.ui" line="387"/>
+        <location filename="mainwindow.ui" line="471"/>
+        <location filename="mainwindow.ui" line="474"/>
+        <location filename="mainwindow.cpp" line="2394"/>
         <source>Show errors</source>
         <translation>エラーを表示</translation>
     </message>
     <message>
-        <source>Show S&amp;cratchpad...</source>
-        <translation type="obsolete">スクラッチパッドを表示</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="769"/>
-        <location filename="mainwindow.cpp" line="807"/>
+        <location filename="mainwindow.cpp" line="986"/>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Information</source>
         <translation>情報</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="568"/>
+        <location filename="mainwindow.ui" line="661"/>
         <source>Show information messages</source>
         <translation>情報メッセージを表示</translation>
     </message>
     <message>
-        <source>Portability</source>
-        <translation type="obsolete">移植可能性</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="583"/>
+        <location filename="mainwindow.ui" line="676"/>
         <source>Show portability warnings</source>
         <translation>移植可能性の問題を表示</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="598"/>
+        <location filename="mainwindow.ui" line="691"/>
         <source>Show Cppcheck results</source>
         <translation>Cppcheck結果を表示する</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="610"/>
+        <location filename="mainwindow.ui" line="703"/>
         <source>Clang</source>
         <translation>Clang</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="613"/>
+        <location filename="mainwindow.ui" line="706"/>
         <source>Show Clang results</source>
         <translation>Clangの結果を表示</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="621"/>
+        <location filename="mainwindow.ui" line="714"/>
         <source>&amp;Filter</source>
         <translation>フィルター(&amp;F)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="624"/>
+        <location filename="mainwindow.ui" line="717"/>
         <source>Filter results</source>
         <translation>フィルタ結果</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="640"/>
+        <location filename="mainwindow.ui" line="733"/>
         <source>Windows 32-bit ANSI</source>
         <translation>Windows 32-bit ANSIエンコード</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="648"/>
+        <location filename="mainwindow.ui" line="741"/>
         <source>Windows 32-bit Unicode</source>
         <translation>Windows 32-bit Unicode</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="656"/>
+        <location filename="mainwindow.ui" line="749"/>
         <source>Unix 32-bit</source>
         <translation>Unix 32-bit</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="664"/>
+        <location filename="mainwindow.ui" line="757"/>
         <source>Unix 64-bit</source>
         <translation>Unix 64-bit</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="672"/>
+        <location filename="mainwindow.ui" line="765"/>
         <source>Windows 64-bit</source>
         <translation>Windows 64-bit</translation>
     </message>
     <message>
-        <source>Platforms</source>
-        <translation type="obsolete">プラットフォーム</translation>
-    </message>
-    <message>
-        <source>C++11</source>
-        <translation type="obsolete">C++11</translation>
-    </message>
-    <message>
-        <source>C99</source>
-        <translation type="obsolete">C99</translation>
-    </message>
-    <message>
-        <source>Posix</source>
-        <translation type="obsolete">Posix</translation>
-    </message>
-    <message>
-        <source>C11</source>
-        <translation type="obsolete">C11</translation>
-    </message>
-    <message>
-        <source>C89</source>
-        <translation type="obsolete">C89</translation>
-    </message>
-    <message>
-        <source>C++03</source>
-        <translation type="obsolete">C++03</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="742"/>
+        <location filename="mainwindow.ui" line="859"/>
         <source>&amp;Print...</source>
         <translation>印刷(&amp;P)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="745"/>
+        <location filename="mainwindow.ui" line="862"/>
         <source>Print the Current Report</source>
         <translation>現在のレポートを印刷</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="750"/>
+        <location filename="mainwindow.ui" line="867"/>
         <source>Print Pre&amp;view...</source>
         <translation>印刷プレビュー(&amp;v)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="753"/>
+        <location filename="mainwindow.ui" line="870"/>
         <source>Open a Print Preview Dialog for the Current Results</source>
         <translation>現在のレポートをプレビュー表示</translation>
     </message>
     <message>
-        <source>Library Editor...</source>
-        <translation type="obsolete">ライブラリの編集</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="761"/>
+        <location filename="mainwindow.ui" line="878"/>
         <source>Open library editor</source>
         <translation>ライブラリエディタを開く</translation>
     </message>
     <message>
-        <source>Auto-detect language</source>
-        <translation type="obsolete">言語を自動検出</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="489"/>
+        <location filename="mainwindow.ui" line="582"/>
         <source>C&amp;lose Project File</source>
         <translation>プロジェクトを閉じる(&amp;l)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="497"/>
+        <location filename="mainwindow.ui" line="590"/>
         <source>&amp;Edit Project File...</source>
         <translation>プロジェクトの編集(&amp;E)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="509"/>
+        <location filename="mainwindow.ui" line="602"/>
         <source>&amp;Statistics</source>
         <translation>統計情報(&amp;S)</translation>
     </message>
     <message>
-        <source>Warnings</source>
-        <translation type="obsolete">警告</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="524"/>
-        <location filename="mainwindow.ui" line="527"/>
+        <location filename="mainwindow.ui" line="617"/>
+        <location filename="mainwindow.ui" line="620"/>
+        <location filename="mainwindow.cpp" line="2395"/>
         <source>Show warnings</source>
         <translation>警告を表示</translation>
     </message>
     <message>
-        <source>Performance warnings</source>
-        <translation type="obsolete">パフォーマンス警告</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="542"/>
-        <location filename="mainwindow.ui" line="545"/>
+        <location filename="mainwindow.ui" line="635"/>
+        <location filename="mainwindow.ui" line="638"/>
         <source>Show performance warnings</source>
         <translation>パフォーマンス警告を表示</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="553"/>
+        <location filename="mainwindow.ui" line="646"/>
         <source>Show &amp;hidden</source>
         <translation>非表示を表示(&amp;h)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="392"/>
+        <location filename="mainwindow.ui" line="479"/>
         <source>&amp;Check all</source>
         <translation>すべてのエラーを表示(&amp;C)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="131"/>
+        <location filename="mainwindow.ui" line="84"/>
+        <source>Checking for updates</source>
+        <translation>更新の確認</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="100"/>
+        <source>Hide</source>
+        <translation>非表示</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="164"/>
+        <location filename="mainwindow.ui" line="980"/>
+        <source>Report</source>
+        <translation>レポート</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="210"/>
         <source>A&amp;nalyze</source>
         <translation>チェック(&amp;n)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="220"/>
+        <location filename="mainwindow.ui" line="304"/>
         <source>Filter</source>
         <translation>フィルター</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="286"/>
+        <location filename="mainwindow.ui" line="370"/>
         <source>&amp;Reanalyze modified files</source>
         <oldsource>&amp;Recheck modified files</oldsource>
         <translation>変更ありファイルを再解析(&amp;R)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="298"/>
+        <location filename="mainwindow.ui" line="382"/>
         <source>Reanal&amp;yze all files</source>
         <translation>全ファイル再解析(&amp;y)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="363"/>
+        <location filename="mainwindow.ui" line="420"/>
+        <source>Ctrl+Q</source>
+        <translation>Ctrl+Q</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="450"/>
         <source>Style war&amp;nings</source>
         <translation>スタイル警告(&amp;n)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="381"/>
+        <location filename="mainwindow.ui" line="468"/>
         <source>E&amp;rrors</source>
         <translation>エラー(&amp;r)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="397"/>
+        <location filename="mainwindow.ui" line="484"/>
         <source>&amp;Uncheck all</source>
         <translation>すべてのエラーを非表示(&amp;U)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="402"/>
+        <location filename="mainwindow.ui" line="489"/>
         <source>Collapse &amp;all</source>
         <translation>ツリーを折り畳む(&amp;a)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="407"/>
+        <location filename="mainwindow.ui" line="494"/>
         <source>&amp;Expand all</source>
         <translation>ツリーを展開(&amp;E)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="415"/>
+        <location filename="mainwindow.ui" line="502"/>
         <source>&amp;Standard</source>
         <translation>言語規格(&amp;S)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="418"/>
+        <location filename="mainwindow.ui" line="505"/>
         <source>Standard items</source>
         <translation>標準項目</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="423"/>
+        <location filename="mainwindow.ui" line="510"/>
         <source>&amp;Contents</source>
         <translation>コンテンツ(&amp;C)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="426"/>
+        <location filename="mainwindow.ui" line="513"/>
         <source>Open the help contents</source>
         <translation>ヘルプファイルを開く</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="429"/>
+        <location filename="mainwindow.ui" line="516"/>
         <source>F1</source>
         <translation>F1</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="434"/>
+        <location filename="mainwindow.ui" line="521"/>
         <source>Toolbar</source>
         <translation>ツールバー</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="442"/>
+        <location filename="mainwindow.ui" line="529"/>
         <source>&amp;Categories</source>
         <translation>カテゴリ(&amp;C)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="445"/>
+        <location filename="mainwindow.ui" line="532"/>
         <source>Error categories</source>
         <translation>エラーカテゴリ</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="450"/>
+        <location filename="mainwindow.ui" line="537"/>
         <source>&amp;Open XML...</source>
         <translation>XMLを開く(&amp;O)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="459"/>
+        <location filename="mainwindow.ui" line="546"/>
         <source>Open P&amp;roject File...</source>
         <translation>プロジェクトを開く(&amp;R)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="468"/>
+        <location filename="mainwindow.ui" line="549"/>
+        <source>Ctrl+Shift+O</source>
+        <translation>Ctrl+Shift+O</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="558"/>
         <source>Sh&amp;ow Scratchpad...</source>
         <translation>スクラッチパッドを表示(&amp;o)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="473"/>
+        <location filename="mainwindow.ui" line="563"/>
         <source>&amp;New Project File...</source>
         <translation>新規プロジェクト(&amp;N)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="478"/>
+        <location filename="mainwindow.ui" line="566"/>
+        <source>Ctrl+Shift+N</source>
+        <translation>Ctrl+Shift+N</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="571"/>
         <source>&amp;Log View</source>
         <translation>ログを表示(&amp;L)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="481"/>
+        <location filename="mainwindow.ui" line="574"/>
         <source>Log View</source>
         <translation>ログ表示</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="521"/>
+        <location filename="mainwindow.ui" line="614"/>
         <source>&amp;Warnings</source>
         <translation>警告(&amp;W)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="539"/>
+        <location filename="mainwindow.ui" line="632"/>
         <source>Per&amp;formance warnings</source>
         <translation>パフォーマンス警告(&amp;f)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="565"/>
+        <location filename="mainwindow.ui" line="658"/>
         <source>&amp;Information</source>
         <translation>情報(&amp;I)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="580"/>
+        <location filename="mainwindow.ui" line="673"/>
         <source>&amp;Portability</source>
         <translation>移植可能性(&amp;P)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="680"/>
+        <location filename="mainwindow.ui" line="773"/>
         <source>P&amp;latforms</source>
         <translation>プラットフォーム(&amp;l)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="694"/>
+        <location filename="mainwindow.ui" line="787"/>
         <source>C++&amp;11</source>
         <translation>C++11(&amp;1)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="705"/>
+        <location filename="mainwindow.ui" line="798"/>
         <source>C&amp;99</source>
         <translation>C99(&amp;9)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="713"/>
+        <location filename="mainwindow.ui" line="806"/>
         <source>&amp;Posix</source>
         <translation>Posix(&amp;P)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="721"/>
+        <location filename="mainwindow.ui" line="814"/>
         <source>C&amp;11</source>
         <translation>C11(&amp;1)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="729"/>
+        <location filename="mainwindow.ui" line="846"/>
         <source>&amp;C89</source>
         <translation>C89(&amp;C)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="737"/>
+        <location filename="mainwindow.ui" line="854"/>
         <source>&amp;C++03</source>
         <translation>C++03(&amp;C)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="758"/>
+        <location filename="mainwindow.ui" line="875"/>
         <source>&amp;Library Editor...</source>
         <translation>ライブラリエディタ(&amp;L)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="769"/>
+        <location filename="mainwindow.ui" line="886"/>
         <source>&amp;Auto-detect language</source>
         <translation>自動言語検出(&amp;A)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="777"/>
+        <location filename="mainwindow.ui" line="894"/>
         <source>&amp;Enforce C++</source>
         <translation>C++ 強制(&amp;E)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="785"/>
+        <location filename="mainwindow.ui" line="902"/>
         <source>E&amp;nforce C</source>
         <translation>C 強制(&amp;n)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="796"/>
+        <location filename="mainwindow.ui" line="913"/>
         <source>C++14</source>
         <translation>C++14</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="804"/>
+        <location filename="mainwindow.ui" line="921"/>
         <source>Reanalyze and check library</source>
         <translation>ライブラリを再チェックする</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="812"/>
+        <location filename="mainwindow.ui" line="929"/>
         <source>Check configuration (defines, includes)</source>
         <translation>チェックの設定(define、インクルード)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="820"/>
+        <location filename="mainwindow.ui" line="937"/>
         <source>C++17</source>
         <translation>C++17</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="831"/>
+        <location filename="mainwindow.ui" line="948"/>
         <source>C++20</source>
         <translation>C++20</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="323"/>
-        <source>There was a problem with loading the editor application settings.
-
-This is probably because the settings were changed between the Cppcheck versions. Please check (and fix) the editor application settings, otherwise the editor program might not start correctly.</source>
-        <translation>エディタアプリの設定の読み込みで問題が発生しました。
-
-Cppcheckの古いバージョンの設定には互換性がありません。エディタアプリケーションの設定を確認して修正してください、そうしないと正しく起動できないかもしれません。</translation>
+        <location filename="mainwindow.ui" line="975"/>
+        <source>Compliance report...</source>
+        <translation>コンプライアンスレポート...</translation>
     </message>
     <message>
-        <source>No suitable files found to check!</source>
-        <translation type="obsolete">解析可能なファイルではありません</translation>
+        <location filename="mainwindow.ui" line="988"/>
+        <source>Normal</source>
+        <translation>ノーマル</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="554"/>
-        <source>You must close the project file before selecting new files or directories!</source>
-        <translation>新しいファイル／ディレクトリをチェックするには現在のプロジェクトを閉じてください!</translation>
+        <location filename="mainwindow.ui" line="996"/>
+        <source>Misra C</source>
+        <translation>MISRA C</translation>
     </message>
     <message>
-        <source>C/C++ Source, Compile database, Visual Studio (%1 %2 *.sln *.vcxproj)</source>
-        <translation type="obsolete">C/C++ソースコード、プロジェクトファイル、Visual Studioソリューション(%1 %2 *.sln *.vcxproj)</translation>
+        <location filename="mainwindow.ui" line="1004"/>
+        <source>Misra C++ 2008</source>
+        <translation>MISRA C++ 2008</translation>
     </message>
     <message>
-        <source>Select directory to check</source>
-        <translation type="obsolete">チェック対象のディレクトリを選択</translation>
+        <location filename="mainwindow.ui" line="1012"/>
+        <source>Cert C</source>
+        <translation>CERT C</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="87"/>
-        <source>Quick Filter:</source>
-        <translation>クイックフィルタ：</translation>
+        <location filename="mainwindow.ui" line="1020"/>
+        <source>Cert C++</source>
+        <translation>Cert C++</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1028"/>
+        <source>Misra C++ 2023</source>
+        <translation>MISRA C++ 2023</translation>
     </message>
     <message>
-        <source>Select files to check</source>
-        <translation type="obsolete">チェック対象のファイルを選択</translation>
+        <location filename="mainwindow.ui" line="1036"/>
+        <source>Autosar</source>
+        <translation>AUTOSAR</translation>
     </message>
     <message>
-        <source>C/C++ Source (%1)</source>
-        <translation type="obsolete">C/C++ ソース (%1)</translation>
+        <location filename="mainwindow.ui" line="1041"/>
+        <source>EULA...</source>
+        <translation>EULA...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1046"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1049"/>
+        <source>Show thread details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="461"/>
+        <source>There was a problem with loading the editor application settings.
+
+This is probably because the settings were changed between the Cppcheck versions. Please check (and fix) the editor application settings, otherwise the editor program might not start correctly.</source>
+        <translation>エディタアプリの設定の読み込みで問題が発生しました。
+
+Cppcheckの古いバージョンの設定には互換性がありません。エディタアプリケーションの設定を確認して修正してください、そうしないと正しく起動できないかもしれません。</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="756"/>
+        <source>You must close the project file before selecting new files or directories!</source>
+        <translation>新しいファイル／ディレクトリをチェックするには現在のプロジェクトを閉じてください!</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="629"/>
+        <location filename="mainwindow.cpp" line="157"/>
+        <location filename="mainwindow.cpp" line="1782"/>
+        <source>Quick Filter:</source>
+        <translation>クイックフィルタ：</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select configuration</source>
         <translation>コンフィグレーションの選択</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="659"/>
+        <location filename="mainwindow.cpp" line="861"/>
         <source>Found project file: %1
 
 Do you want to load this project file instead?</source>
@@ -1086,216 +1140,221 @@ Do you want to load this project file instead?</source>
 現在のプロジェクトの代わりにこのプロジェクトファイルを読み込んでもかまいませんか？</translation>
     </message>
     <message>
-        <source>Found project files from the directory.
-
-Do you want to proceed checking without using any of these project files?</source>
-        <translation type="obsolete">ディレクトリからプロジェクトファイルが検出されました。
-
-これらのプロジェクトファイルを使用せずに解析を進めてもかまいませんか？
-</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="769"/>
+        <location filename="mainwindow.cpp" line="986"/>
         <source>The library &apos;%1&apos; contains unknown elements:
 %2</source>
         <translation>このライブラリ &apos;%1&apos; には次の不明な要素が含まれています。
 %2</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="778"/>
+        <location filename="mainwindow.cpp" line="995"/>
         <source>File not found</source>
         <translation>ファイルがありません</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="781"/>
+        <location filename="mainwindow.cpp" line="998"/>
         <source>Bad XML</source>
         <translation>不正なXML</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="784"/>
+        <location filename="mainwindow.cpp" line="1001"/>
         <source>Missing attribute</source>
         <translation>属性がありません</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="787"/>
+        <location filename="mainwindow.cpp" line="1004"/>
         <source>Bad attribute value</source>
         <translation>不正な属性があります</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="790"/>
+        <location filename="mainwindow.cpp" line="1007"/>
         <source>Unsupported format</source>
         <translation>サポートされていないフォーマット</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="793"/>
+        <location filename="mainwindow.cpp" line="1010"/>
         <source>Duplicate platform type</source>
         <translation>プラットフォームの種類が重複しています</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="796"/>
+        <location filename="mainwindow.cpp" line="1013"/>
         <source>Platform type redefined</source>
         <translation>プラットフォームの種類が再定義されました</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="799"/>
+        <location filename="mainwindow.cpp" line="1019"/>
         <source>Unknown element</source>
         <translation>不明な要素</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="802"/>
-        <source>Unknown issue</source>
-        <translation>不明な課題</translation>
+        <location filename="mainwindow.cpp" line="1019"/>
+        <source>Unknown element</source>
+        <oldsource>Unknown issue</oldsource>
+        <translation type="unfinished">不明な課題</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="807"/>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Failed to load the selected library &apos;%1&apos;.
 %2</source>
         <translation>選択したライブラリの読み込みに失敗しました &apos;%1&apos;
 %2</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="828"/>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
         <source>Error</source>
         <translation>エラー</translation>
     </message>
     <message>
-        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located.</source>
-        <translation type="obsolete">%1の読み込みに失敗しました。CppCheckのインストールに失敗しています。コマンドライン引数に --data-dir=&lt;directory&gt; を指定して、このファイルの場所を指定してください。 </translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="828"/>
         <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.</source>
-        <translation>%1のロードに失敗しました。あなたの Cppcheck は正しくインストールされていません。あなたは --data-dir=&lt;directory&gt; コマンドラインオプションでロードするファイルの場所を指定できます。ただし、この --data-dir はインストールスクリプトによってサポートされており、GUI版ではサポートされていません。全ての設定は調整済みでなければなりません。</translation>
+        <translation type="vanished">%1のロードに失敗しました。あなたの Cppcheck は正しくインストールされていません。あなたは --data-dir=&lt;directory&gt; コマンドラインオプションでロードするファイルの場所を指定できます。ただし、この --data-dir はインストールスクリプトによってサポートされており、GUI版ではサポートされていません。全ての設定は調整済みでなければなりません。</translation>
     </message>
     <message>
-        <source>Current results will be cleared.
-
-Opening a new XML file will clear current results.Do you want to proceed?</source>
-        <translation type="vanished">現在の結果を作成します。
-
-新しくXMLファイルを開くと現在の結果が削除されます。実行しますか？</translation>
+        <source>Failed to load %1 - %2</source>
+        <translation type="vanished">%1 - %2 の読み込みに失敗</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1129"/>
-        <location filename="mainwindow.cpp" line="1309"/>
+        <location filename="mainwindow.cpp" line="1483"/>
+        <location filename="mainwindow.cpp" line="1682"/>
         <source>XML files (*.xml)</source>
         <translation>XML ファイル (*.xml)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1131"/>
+        <location filename="mainwindow.cpp" line="1485"/>
         <source>Open the report file</source>
         <translation>レポートを開く</translation>
     </message>
     <message>
-        <source>Checking is running.
-
-Do you want to stop the checking and exit Cppcheck?</source>
-        <translation type="obsolete">解析中です.
-
-解析を停止してCppcheckを終了しますか？.</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1280"/>
+        <location filename="mainwindow.cpp" line="1648"/>
         <source>License</source>
         <translation>ライセンス</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1287"/>
+        <location filename="mainwindow.cpp" line="1655"/>
         <source>Authors</source>
         <translation>作者</translation>
     </message>
     <message>
-        <source>XML files version 2 (*.xml);;XML files version 1 (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
-        <oldsource>XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</oldsource>
-        <translation type="obsolete">XML ファイル (*.xml);;テキストファイル (*.txt);;CSV形式ファイル (*.csv)</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1302"/>
+        <location filename="mainwindow.cpp" line="1675"/>
         <source>Save the report file</source>
         <translation>レポートを保存</translation>
     </message>
     <message>
-        <source>XML files version 1 (*.xml)</source>
-        <translation type="obsolete">XMLファイルのバージョン1</translation>
-    </message>
-    <message>
-        <source>XML files version 2 (*.xml)</source>
-        <translation type="obsolete">XMLファイルのバージョン2</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1313"/>
+        <location filename="mainwindow.cpp" line="1686"/>
         <source>Text files (*.txt)</source>
         <translation>テキストファイル (*.txt)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1317"/>
+        <location filename="mainwindow.cpp" line="1690"/>
         <source>CSV files (*.csv)</source>
         <translation>CSV形式ファイル (*.csv)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1361"/>
-        <source>Cppcheck - %1</source>
-        <translation>Cppcheck - %1</translation>
+        <location filename="mainwindow.cpp" line="1713"/>
+        <source>Cannot generate a compliance report right now, an analysis must finish successfully. Try to reanalyze the code and ensure there are no critical errors.</source>
+        <translation>コンプライアンスレポートをすぐに生成できません。解析が完了し成功していなければなりません。コードを再解析して、致命的なエラーがないことを確認してください。</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1407"/>
+        <location filename="mainwindow.cpp" line="1820"/>
         <source>Project files (*.cppcheck);;All files(*.*)</source>
         <translation>プロジェクトファイル (*.cppcheck);;すべてのファイル(*.*)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1409"/>
+        <location filename="mainwindow.cpp" line="1822"/>
         <source>Select Project File</source>
         <translation>プロジェクトファイルを選択</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="159"/>
-        <location filename="mainwindow.cpp" line="1437"/>
-        <location filename="mainwindow.cpp" line="1562"/>
+        <location filename="mainwindow.cpp" line="1978"/>
+        <source>Failed to open file</source>
+        <translation>ファイルを開くのに失敗しました</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1981"/>
+        <source>Unknown project file format</source>
+        <translation>プロジェクトファイルの形式が不明です</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1984"/>
+        <source>Failed to import project file</source>
+        <translation>プロジェクトファイルのインポートに失敗しました</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2000"/>
+        <source>Failed to import &apos;%1&apos;: %2
+
+Analysis is stopped.</source>
+        <translation>インポートに失敗&apos;%1&apos;: %2
+
+解析を停止しました。</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2009"/>
+        <source>Failed to import &apos;%1&apos; (%2), analysis is stopped</source>
+        <translation>&apos;%1&apos; (%2) のインポートに失敗しました。解析は停止</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2325"/>
+        <source>Install</source>
+        <translation>インストール</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2329"/>
+        <source>New version available: %1. %2</source>
+        <translation>新しいバージョンが利用可能です。: %1. %2</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="242"/>
+        <location filename="mainwindow.cpp" line="1784"/>
+        <location filename="mainwindow.cpp" line="1850"/>
+        <location filename="mainwindow.cpp" line="2048"/>
         <source>Project:</source>
         <translation>プロジェクト:</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="481"/>
+        <location filename="mainwindow.cpp" line="671"/>
         <source>No suitable files found to analyze!</source>
         <translation>チェック対象のファイルがみつかりません!</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="568"/>
+        <location filename="mainwindow.cpp" line="770"/>
         <source>C/C++ Source</source>
         <translation>C/C++のソースコード</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="569"/>
+        <location filename="mainwindow.cpp" line="771"/>
         <source>Compile database</source>
         <translation>コンパイルデータベース</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="570"/>
+        <location filename="mainwindow.cpp" line="772"/>
         <source>Visual Studio</source>
         <translation>Visual Studio</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="571"/>
+        <location filename="mainwindow.cpp" line="773"/>
         <source>Borland C++ Builder 6</source>
         <translation>Borland C++ Builder 6</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="574"/>
+        <location filename="mainwindow.cpp" line="776"/>
         <source>Select files to analyze</source>
         <translation>チェック対象のファイルを選択</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="589"/>
+        <location filename="mainwindow.cpp" line="791"/>
         <source>Select directory to analyze</source>
         <translation>チェックするディレクトリを選択してください</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="629"/>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select the configuration that will be analyzed</source>
         <translation>チェックの設定を選択</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="681"/>
+        <location filename="mainwindow.cpp" line="883"/>
         <source>Found project files from the directory.
 
 Do you want to proceed analysis without using any of these project files?</source>
@@ -1304,7 +1363,46 @@ Do you want to proceed analysis without using any of these project files?</sourc
 みつかったプロジェクトファイルを使用せずにチェックしますか?</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1114"/>
+        <location filename="mainwindow.cpp" line="1016"/>
+        <source>Duplicate define</source>
+        <translation>重複した定義</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1035"/>
+        <source>File not found: &apos;%1&apos;</source>
+        <translation>ファイルがありません: &apos;%1&apos;</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1058"/>
+        <source>Failed to load/setup addon %1: %2</source>
+        <translation>アドオンの読み込みまたは設定に失敗 %1 - %2</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.
+
+Analysis is aborted.</source>
+        <translation>%1のロードに失敗しました。あなたの Cppcheck は正しくインストールされていません。あなたは --data-dir=&lt;directory&gt; コマンドラインオプションを使ってこのファイルの場所を指定できます。ただし、この --data-dir はインストールスクリプトによって使用されていなければなりません。またGUI版はこれを使用しません。さらに、全ての設定は調整済みでなければなりません。</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <source>Failed to load %1 - %2
+
+Analysis is aborted.</source>
+        <translation>読み込みに失敗 %1 - %2</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
+        <source>%1
+
+Analysis is aborted.</source>
+        <translation>%1
+
+解析は中止した。</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1468"/>
         <source>Current results will be cleared.
 
 Opening a new XML file will clear current results.
@@ -1314,7 +1412,7 @@ Do you want to proceed?</source>
 新しくXMLファイルを開くと現在の結果が削除されます。実行しますか？</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1234"/>
+        <location filename="mainwindow.cpp" line="1592"/>
         <source>Analyzer is running.
 
 Do you want to stop the analysis and exit Cppcheck?</source>
@@ -1323,37 +1421,101 @@ Do you want to stop the analysis and exit Cppcheck?</source>
 チェックを中断して、Cppcheckを終了しますか?</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1300"/>
+        <location filename="mainwindow.cpp" line="1634"/>
+        <source>About</source>
+        <translation>CppCheckについて</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1673"/>
         <source>XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
         <translation>XML ファイル (*.xml);;テキストファイル (*.txt);;CSVファイル (*.csv)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1500"/>
+        <location filename="mainwindow.cpp" line="1938"/>
         <source>Build dir &apos;%1&apos; does not exist, create it?</source>
         <translation>ビルドディレクトリ&apos;%1&apos;がありません。作成しますか?</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1523"/>
+        <location filename="mainwindow.cpp" line="1946"/>
+        <source>To check the project using addons, you need a build directory.</source>
+        <translation>アドオンを使用してプロジェクトをチェックするためには、ビルドディレクトリが必要です。</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2367"/>
+        <source>Show Mandatory</source>
+        <translation>必須を表示</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2368"/>
+        <source>Show Required</source>
+        <translation>要求を表示</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2369"/>
+        <source>Show Advisory</source>
+        <translation>推奨を表示</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2370"/>
+        <source>Show Document</source>
+        <translation>ドキュメントを表示</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2387"/>
+        <source>Show L1</source>
+        <translation>L1を表示</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2388"/>
+        <source>Show L2</source>
+        <translation>L2を表示</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2389"/>
+        <source>Show L3</source>
+        <translation>L3を表示</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2396"/>
+        <source>Show style</source>
+        <translation>スタイルを表示</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2397"/>
+        <source>Show portability</source>
+        <translation>移植可能性を表示</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2398"/>
+        <source>Show performance</source>
+        <translation>パフォーマンスを表示</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2399"/>
+        <source>Show information</source>
+        <translation>情報を表示</translation>
+    </message>
+    <message>
         <source>Failed to import &apos;%1&apos;, analysis is stopped</source>
-        <translation>&apos;%1&apos;のインポートに失敗しました。(チェック中断)</translation>
+        <translation type="vanished">&apos;%1&apos;のインポートに失敗しました。(チェック中断)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1547"/>
+        <location filename="mainwindow.cpp" line="2033"/>
         <source>Project files (*.cppcheck)</source>
         <translation>プロジェクトファイル (*.cppcheck)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1549"/>
+        <location filename="mainwindow.cpp" line="2035"/>
         <source>Select Project Filename</source>
         <translation>プロジェクトファイル名を選択</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1594"/>
+        <location filename="mainwindow.cpp" line="2081"/>
         <source>No project file loaded</source>
         <translation>プロジェクトファイルが読み込まれていません</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1662"/>
+        <location filename="mainwindow.cpp" line="2163"/>
         <source>The project file
 
 %1
@@ -1365,7 +1527,7 @@ Do you want to remove the file from the recently used projects -list?</source>
 最近使用したプロジェクトのリストからこのファイルを取り除きますか？</translation>
     </message>
     <message>
-        <location filename="main.cpp" line="106"/>
+        <location filename="main.cpp" line="100"/>
         <source>Cppcheck GUI.
 
 Syntax:
@@ -1406,7 +1568,7 @@ Options:
     --data-dir=&lt;directory&gt;  GUI のデータファイル(翻訳やcfg)のあるディレクトリを指定する。このオプションを指定した場合、GUIで起動しません。</translation>
     </message>
     <message>
-        <location filename="main.cpp" line="121"/>
+        <location filename="main.cpp" line="115"/>
         <source>Cppcheck GUI - Command line parameters</source>
         <translation>Cppcheck GUI - コマンドラインパラメータ</translation>
     </message>
@@ -1439,7 +1601,7 @@ Options:
         <translation>シンボル名</translation>
     </message>
     <message>
-        <location filename="newsuppressiondialog.cpp" line="52"/>
+        <location filename="newsuppressiondialog.cpp" line="83"/>
         <source>Edit suppression</source>
         <translation>抑制の編集</translation>
     </message>
@@ -1447,330 +1609,436 @@ Options:
 <context>
     <name>Platforms</name>
     <message>
-        <source>Built-in</source>
-        <translation type="obsolete">ビルトイン</translation>
-    </message>
-    <message>
-        <location filename="platforms.cpp" line="37"/>
+        <location filename="platforms.cpp" line="38"/>
         <source>Native</source>
         <translation>ネイティブ</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="38"/>
+        <location filename="platforms.cpp" line="39"/>
         <source>Unix 32-bit</source>
         <translation>Unix 32-bit</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="39"/>
+        <location filename="platforms.cpp" line="40"/>
         <source>Unix 64-bit</source>
         <translation>Unix 64-bit</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="40"/>
+        <location filename="platforms.cpp" line="41"/>
         <source>Windows 32-bit ANSI</source>
         <translation>Windows 32-bit ANSIエンコード</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="41"/>
+        <location filename="platforms.cpp" line="42"/>
         <source>Windows 32-bit Unicode</source>
         <translation>Windows 32-bit Unicode</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="42"/>
+        <location filename="platforms.cpp" line="43"/>
         <source>Windows 64-bit</source>
         <translation>Windows 64-bit</translation>
     </message>
 </context>
-<context>
-    <name>Project</name>
-    <message>
-        <source>Cppcheck</source>
-        <translation type="obsolete">Cppcheck</translation>
-    </message>
-    <message>
-        <source>Could not read the project file.</source>
-        <translation type="obsolete">プロジェクトファイルが読み込めませんでした</translation>
-    </message>
-    <message>
-        <source>Could not write the project file.</source>
-        <translation type="obsolete">プロジェクトファイルが保存できませんでした</translation>
-    </message>
-</context>
 <context>
     <name>ProjectFile</name>
     <message>
-        <location filename="projectfiledialog.ui" line="14"/>
+        <location filename="projectfile.ui" line="14"/>
         <source>Project File</source>
         <translation>プロジェクトファイル</translation>
     </message>
     <message>
-        <source>Project</source>
-        <translation type="obsolete">プロジェクト</translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="24"/>
+        <location filename="projectfile.ui" line="24"/>
         <source>Paths and Defines</source>
         <translation>パスと定義</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="30"/>
+        <location filename="projectfile.ui" line="30"/>
         <source>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</source>
         <oldsource>Import Project (Visual studio / compile database)</oldsource>
         <translation>プロジェクトのインポート(Visual studio / compile database Borland C++ Builder 6))</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="163"/>
+        <location filename="projectfile.ui" line="231"/>
         <source>Defines must be separated by a semicolon. Example: DEF1;DEF2=5;DEF3=int</source>
         <oldsource>Defines must be separated by a semicolon &apos;;&apos;</oldsource>
         <translation>定義(Define)はセミコロン&apos;;&apos;で区切る必要があります。 例: DEF1;DEF2=5;DEF3=int</translation>
     </message>
     <message>
-        <source>&amp;Root:</source>
-        <oldsource>Root:</oldsource>
-        <translation type="obsolete">ルート：</translation>
-    </message>
-    <message>
-        <source>Libraries:</source>
-        <translation type="obsolete">ライブラリ</translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="393"/>
+        <location filename="projectfile.ui" line="389"/>
         <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
         <translation>カスタマイズした cfgファイルを同じフォルダにプロジェクトファイルとして保存してください。ここに表示できるようになります。</translation>
     </message>
     <message>
-        <source>Exclude paths</source>
-        <translation type="obsolete">除外するパス</translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="597"/>
         <source>MISRA C 2012</source>
-        <translation>MISRA C 2012</translation>
+        <translation type="vanished">MISRA C 2012</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="606"/>
-        <source>Misra rule texts</source>
-        <translation>Misra ルールテキスト</translation>
+        <location filename="projectfile.ui" line="876"/>
+        <source>MISRA rule texts</source>
+        <translation>MISRA ルールテキスト</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="613"/>
+        <location filename="projectfile.ui" line="883"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;MISRA C 2012 pdfのAppendix A &amp;quot;Summary of guidelines&amp;quot; からテキストをコピーペーストしてください。&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="620"/>
+        <location filename="projectfile.ui" line="890"/>
         <source>...</source>
         <translation>...</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="69"/>
+        <location filename="projectfile.ui" line="73"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;You have a choice:&lt;/p&gt;&lt;p&gt; * Analyze all Debug and Release configurations&lt;/p&gt;&lt;p&gt; * Only analyze the first matching Debug configuration&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;選択済み:&lt;/p&gt;&lt;p&gt; * 全Debug と Release設定をチェックする&lt;/p&gt;&lt;p&gt; * 最初にマッチした Debug 設定のみチェックする&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="60"/>
-        <location filename="projectfiledialog.ui" line="309"/>
+        <location filename="projectfile.ui" line="60"/>
+        <location filename="projectfile.ui" line="422"/>
+        <location filename="projectfile.ui" line="616"/>
         <source>Browse...</source>
         <translation>参照...</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="72"/>
+        <location filename="projectfile.ui" line="76"/>
         <source>Analyze all Visual Studio configurations</source>
         <translation>Visual Studioの全ての設定をチェックする</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="86"/>
+        <location filename="projectfile.ui" line="113"/>
+        <source>Selected VS Configurations</source>
+        <translation>選択したVS設定</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="147"/>
         <source>Paths:</source>
         <translation>パス:</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="113"/>
-        <location filename="projectfiledialog.ui" line="228"/>
-        <location filename="projectfiledialog.ui" line="461"/>
+        <location filename="projectfile.ui" line="181"/>
+        <location filename="projectfile.ui" line="296"/>
         <source>Add...</source>
         <translation>追加...</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="120"/>
-        <location filename="projectfiledialog.ui" line="235"/>
-        <location filename="projectfiledialog.ui" line="468"/>
+        <location filename="projectfile.ui" line="188"/>
+        <location filename="projectfile.ui" line="303"/>
+        <location filename="projectfile.ui" line="690"/>
         <source>Edit</source>
         <translation>編集</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="127"/>
-        <location filename="projectfiledialog.ui" line="242"/>
-        <location filename="projectfiledialog.ui" line="475"/>
-        <location filename="projectfiledialog.ui" line="518"/>
+        <location filename="projectfile.ui" line="195"/>
+        <location filename="projectfile.ui" line="310"/>
+        <location filename="projectfile.ui" line="697"/>
+        <location filename="projectfile.ui" line="740"/>
         <source>Remove</source>
         <translation>取り除く</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="174"/>
+        <location filename="projectfile.ui" line="242"/>
         <source>Undefines:</source>
         <translation>定義取り消し(Undefines):</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="184"/>
+        <location filename="projectfile.ui" line="252"/>
         <source>Undefines must be separated by a semicolon. Example: UNDEF1;UNDEF2;UNDEF3</source>
         <translation>定義の取り消しはセミコロンで区切ります。例: UNDEF1;UNDEF2;UNDEF3</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="197"/>
+        <location filename="projectfile.ui" line="265"/>
         <source>Include Paths:</source>
         <translation>インクルードパス:</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="331"/>
+        <location filename="projectfile.ui" line="362"/>
+        <source>Types and Functions</source>
+        <translation>型と関数</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="403"/>
+        <location filename="projectfile.ui" line="488"/>
         <source>Analysis</source>
         <translation>チェック</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="337"/>
-        <source>Check code in headers  (slower analysis, more results)</source>
-        <translation>ヘッダファイルのコードもチェック(解析に時間がかかりますが結果は増えます)</translation>
+        <location filename="projectfile.ui" line="415"/>
+        <source>This is a workfolder that Cppcheck will use for various purposes.</source>
+        <translation>Cppcheckがさまざまな目的で使用するワークディレクトリ。</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="432"/>
+        <source>Parser</source>
+        <translation>パーサー</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="438"/>
+        <source>Cppcheck (built in)</source>
+        <translation>Cppcheckビルトイン</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="458"/>
+        <source>Check level</source>
+        <translation>チェックレベル</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="464"/>
+        <source>Reduced -- meant for usage where developer wants results directly. Limited and faster analysis with fewer results.</source>
+        <translation>#R 限定的 -- 開発者が直接的に結果を得るための解析を意味します。解析は限定的で高速ですがより少ない結果になります。</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="347"/>
-        <source>Check code in unused templates  (slower and less accurate analysis)</source>
+        <location filename="projectfile.ui" line="471"/>
+        <source>Normal -- meant for normal analysis in CI. Analysis should finish in reasonable time.</source>
+        <translation>#N 通常 -- CIでの通常の解析を意味します。解析が合理的な時間内に完了すべきです。</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="478"/>
+        <source>Exhaustive -- meant for nightly builds etc. Analysis time can be longer (10x slower than compilation is OK).</source>
+        <translation>#E 徹底的 -- ナイトリービルド等を意味します。解析時間はより長くなることがあります (コンパイルの10倍以上時間がかかってもよい)。</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="519"/>
+        <source>Check code in headers  (should be ON normally. if you want a limited quick analysis then turn this OFF)</source>
+        <translation>ヘッダファイルのコードもチェック  (通常はONにしてください、制限するときのみOFF)</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="607"/>
+        <source>Premium License</source>
+        <translation>プレミアムライセンス</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="655"/>
+        <source>If tags are added, you will be able to right click on warnings and set one of these tags. You can manually categorize warnings.</source>
+        <translation>タグが追加された場合、警告上で右クリックしてそれらのタグの中の一つを設定できます。警告を分類できます。</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="665"/>
+        <source>Exclude source files</source>
+        <translation>除外するソースファイル</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="676"/>
+        <source>Exclude folder...</source>
+        <translation>フォルダで除外...</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="683"/>
+        <source>Exclude file...</source>
+        <translation>ファイルで除外...</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="497"/>
+        <source>Check that each class has a safe public interface</source>
+        <translation>クラスが安全で公開されたインターフェースをもっているか確認</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="513"/>
+        <source>Limit analysis</source>
+        <translation>解析の制限</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="529"/>
+        <source>Check code in unused templates (should be ON normally, however in theory you can safely ignore warnings in unused templates)</source>
+        <oldsource>Check code in unused templates  (slower and less accurate analysis)</oldsource>
         <translation>未使用テンプレートのコードもチェック (解析に時間がかかり、また正確性は低い)</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="356"/>
+        <location filename="projectfile.ui" line="541"/>
         <source>Max CTU depth</source>
         <translation>CTUの最大深さ</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="450"/>
-        <source>Exclude source files in paths</source>
-        <translation>除外するソースファイルのPATH</translation>
+        <location filename="projectfile.ui" line="765"/>
+        <source>Enable inline suppressions</source>
+        <translation>inline抑制を有効にする</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="632"/>
-        <source>External tools</source>
-        <translation>外部ツール</translation>
+        <location filename="projectfile.ui" line="833"/>
+        <source>Misra C</source>
+        <translation>MISRA C</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="841"/>
+        <source>2012</source>
+        <translation>2012</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="846"/>
+        <location filename="projectfile.ui" line="914"/>
+        <source>2023</source>
+        <translation>2023</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="851"/>
+        <source>2025</source>
+        <translation>2025</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="901"/>
+        <source>Misra C++</source>
+        <translation>MISRA C++</translation>
     </message>
     <message>
-        <source>Includes</source>
-        <translation type="obsolete">インクルード</translation>
+        <location filename="projectfile.ui" line="909"/>
+        <source>2008</source>
+        <translation>2008</translation>
     </message>
     <message>
-        <source>Include directories:</source>
-        <translation type="obsolete">インクルードディレクトリ:</translation>
+        <location filename="projectfile.ui" line="958"/>
+        <source>Cert C++</source>
+        <translation>Cert C++</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="262"/>
+        <location filename="projectfile.ui" line="972"/>
+        <source>Safety profiles (defined in C++ core guidelines)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="982"/>
+        <source>Bug hunting (Premium)</source>
+        <translation>バグハンティング(プレミアム)</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="998"/>
+        <source>External tools</source>
+        <translation>外部ツール</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="330"/>
         <source>Up</source>
         <translation>上</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="269"/>
+        <location filename="projectfile.ui" line="337"/>
         <source>Down</source>
         <translation>下</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="294"/>
-        <source>Checking</source>
-        <translation>チェック</translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="319"/>
+        <location filename="projectfile.ui" line="368"/>
         <source>Platform</source>
         <translation>プラットフォーム</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="420"/>
+        <location filename="projectfile.ui" line="448"/>
+        <source>Clang (experimental)</source>
+        <translation>Clang (実験的)</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="494"/>
+        <source>If you want to design your classes to be as flexible and robust as possible then the public interface must be very robust. Cppcheck will asumme that arguments can take *any* value.</source>
+        <translation>可能な限りクラスが柔軟であり堅牢であることを望む場合、公開されたインターフェースが非常に堅牢です。Cppcheckは引数があらゆる値をとりうると仮定します。</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="572"/>
+        <source>Max recursion in template instantiation</source>
+        <translation>テンプレートインスタンス化の最大再帰回数</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="627"/>
         <source>Warning options</source>
         <translation>警告オプション</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="426"/>
+        <location filename="projectfile.ui" line="633"/>
         <source>Root path:</source>
         <translation>ルートパス:</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="438"/>
+        <location filename="projectfile.ui" line="639"/>
+        <source>Filepaths in warnings will be relative to this path</source>
+        <translation>警告中のファイルパスはこのパスからの相対パスになります</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="649"/>
         <source>Warning tags (separated by semicolon)</source>
         <translation>警告タグ(セミコロン区切り)</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="300"/>
+        <location filename="projectfile.ui" line="409"/>
         <source>Cppcheck build dir (whole program analysis, incremental analysis, statistics, etc)</source>
         <translation>Cppcheck ビルドディレクトリ (全プログラムチェック, 差分チェック, 統計等)</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="384"/>
+        <location filename="projectfile.ui" line="380"/>
         <source>Libraries</source>
         <translation>ライブラリ</translation>
     </message>
     <message>
-        <source>Exclude</source>
-        <translation type="obsolete">除外する</translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="500"/>
+        <location filename="projectfile.ui" line="722"/>
         <source>Suppressions</source>
         <translation>指摘の抑制</translation>
     </message>
     <message>
-        <source>Suppression list:</source>
-        <translation type="obsolete">抑制リスト</translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="511"/>
+        <location filename="projectfile.ui" line="733"/>
         <source>Add</source>
         <translation>追加</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="557"/>
-        <source>Addons and tools</source>
-        <translation>アドオンとツール</translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="563"/>
+        <location filename="projectfile.ui" line="786"/>
+        <location filename="projectfile.ui" line="792"/>
         <source>Addons</source>
         <translation>アドオン</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="569"/>
+        <location filename="projectfile.ui" line="798"/>
+        <source>Note: Addons require &lt;a href=&quot;https://www.python.org/&quot;&gt;Python&lt;/a&gt; being installed.</source>
+        <translation>注意: アドオンには&lt;a href=&quot;https://www.python.org/&quot;&gt;Python&lt;/a&gt;が必要です。</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="808"/>
         <source>Y2038</source>
         <translation>Y2038</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="576"/>
+        <location filename="projectfile.ui" line="815"/>
         <source>Thread safety</source>
         <translation>スレッドセーフ</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="583"/>
+        <location filename="projectfile.ui" line="825"/>
         <source>Coding standards</source>
         <translation>コーディング標準</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="590"/>
-        <source>Cert</source>
-        <translation>CERT</translation>
+        <source>Misra C 2012</source>
+        <translation type="vanished">MISRA C 2012</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="937"/>
+        <source>Cert C</source>
+        <translation>CERT C</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="946"/>
+        <source>CERT-INT35-C:  int precision (if size equals precision, you can leave empty)</source>
+        <translation>CERT-INT35-C:  int型の精度 (もしサイズが精度と一致する場合空のままにしてください)</translation>
     </message>
     <message>
-        <source>Extra Tools</source>
-        <translation type="obsolete">エクストラツール</translation>
+        <source>Misra C++ 2008</source>
+        <translation type="vanished">MISRA C++ 2008</translation>
     </message>
     <message>
-        <source>It is common best practice to use several tools.</source>
-        <translation type="obsolete">複数ツールの併用はよい結果を生みます。</translation>
+        <location filename="projectfile.ui" line="965"/>
+        <source>Autosar</source>
+        <translation>AUTOSAR</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="645"/>
+        <location filename="projectfile.ui" line="988"/>
+        <source>Bug hunting</source>
+        <translation>バグハント</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="1011"/>
         <source>Clang analyzer</source>
         <translation>Clang Analyzer</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="638"/>
+        <location filename="projectfile.ui" line="1004"/>
         <source>Clang-tidy</source>
         <translation>Clang-tidy</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="153"/>
+        <location filename="projectfile.ui" line="221"/>
         <source>Defines:</source>
         <translation>定義(Defines):</translation>
     </message>
@@ -1778,289 +2046,347 @@ Options:
 <context>
     <name>ProjectFileDialog</name>
     <message>
-        <location filename="projectfiledialog.cpp" line="71"/>
+        <location filename="projectfiledialog.cpp" line="138"/>
         <source>Project file: %1</source>
         <translation>プロジェクトファイル:%1</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="409"/>
+        <location filename="projectfiledialog.cpp" line="590"/>
         <source>Select Cppcheck build dir</source>
         <translation>Cppcheckビルドディレクトリ</translation>
     </message>
     <message>
-        <source>Visual Studio (*.sln *.vcxproj);;Compile database (compile_commands.json)</source>
-        <translation type="obsolete">Visual Studio (*.sln *.vcxproj);;コンパイルデータベース (compile_commands.json)</translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.cpp" line="637"/>
+        <location filename="projectfiledialog.cpp" line="851"/>
         <source>Select include directory</source>
         <translation>includeディレクトリを選択</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="617"/>
+        <location filename="projectfiledialog.cpp" line="831"/>
         <source>Select a directory to check</source>
         <translation>チェックするディレクトリを選択してください</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="305"/>
-        <source>(no rule texts file)</source>
-        <translation>(ルールテキストファイルがない)</translation>
+        <location filename="projectfiledialog.cpp" line="396"/>
+        <source>Note: Open source Cppcheck does not fully implement Misra C 2012</source>
+        <translation>注意: オープンソースのCppcheckはMisra C 2012を完全にサポートしていません。</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="311"/>
+        <location filename="projectfiledialog.cpp" line="461"/>
         <source>Clang-tidy (not found)</source>
         <translation>Clang-tidy (みつかりません)</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="445"/>
+        <location filename="projectfiledialog.cpp" line="629"/>
         <source>Visual Studio</source>
         <translation>Visual Studio</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="446"/>
+        <location filename="projectfiledialog.cpp" line="630"/>
         <source>Compile database</source>
         <translation>コンパイルデータベース</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="447"/>
+        <location filename="projectfiledialog.cpp" line="631"/>
         <source>Borland C++ Builder 6</source>
         <translation>Borland C++ Builder 6</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="448"/>
+        <location filename="projectfiledialog.cpp" line="632"/>
         <source>Import Project</source>
         <translation>プロジェクトのインポート</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="657"/>
+        <location filename="projectfiledialog.cpp" line="871"/>
         <source>Select directory to ignore</source>
         <translation>除外するディレクトリを選択してください</translation>
     </message>
     <message>
-        <source>Add Suppression</source>
-        <translation type="obsolete">抑制する指摘を追加</translation>
+        <location filename="projectfiledialog.cpp" line="879"/>
+        <source>Source files</source>
+        <translation>ソースファイル</translation>
     </message>
     <message>
-        <source>Select error id suppress:</source>
-        <translation type="obsolete">抑制するエラーID(error id)を選択してください</translation>
+        <location filename="projectfiledialog.cpp" line="880"/>
+        <source>All files</source>
+        <translation>全ファイル</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="742"/>
-        <source>Select MISRA rule texts file</source>
-        <translation>MISRAルールテキストファイルを選択</translation>
+        <location filename="projectfiledialog.cpp" line="881"/>
+        <source>Exclude file</source>
+        <translation>除外ファイル</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="742"/>
-        <source>Misra rule texts file (%1)</source>
-        <translation>Misraルールテキストファイル (%1)</translation>
+        <location filename="projectfiledialog.cpp" line="964"/>
+        <source>Select MISRA rule texts file</source>
+        <translation>MISRAルールテキストファイルを選択</translation>
     </message>
-</context>
-<context>
-    <name>QDialogButtonBox</name>
     <message>
-        <location filename="translationhandler.cpp" line="34"/>
-        <source>OK</source>
-        <translation>OK</translation>
+        <location filename="projectfiledialog.cpp" line="966"/>
+        <source>MISRA rule texts file (%1)</source>
+        <translation>MISRAルールテキストファイル (%1)</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="35"/>
-        <source>Cancel</source>
-        <translation>キャンセル</translation>
+        <source>Select license file</source>
+        <translation type="vanished">ライセンスファイルの選択</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="36"/>
-        <source>Close</source>
-        <translation>閉じる</translation>
-    </message>
-    <message>
-        <location filename="translationhandler.cpp" line="37"/>
-        <source>Save</source>
-        <translation>保存する</translation>
+        <source>License file (%1)</source>
+        <translation type="vanished">ライセンスファイル (%1)</translation>
     </message>
 </context>
 <context>
     <name>QObject</name>
     <message>
-        <location filename="translationhandler.cpp" line="104"/>
+        <location filename="translationhandler.cpp" line="91"/>
         <source>Unknown language specified!</source>
         <translation>未知の言語が指定されました!</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="132"/>
+        <location filename="translationhandler.cpp" line="117"/>
         <source>Language file %1 not found!</source>
         <translation>言語ファイル %1 が見つかりません!</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="138"/>
+        <location filename="translationhandler.cpp" line="122"/>
         <source>Failed to load translation for language %1 from file %2</source>
         <translation>言語 %2 から %1 への翻訳ファイルの読み込みに失敗</translation>
     </message>
     <message>
-        <location filename="cppchecklibrarydata.cpp" line="33"/>
+        <location filename="cppchecklibrarydata.cpp" line="38"/>
         <source>line %1: Unhandled element %2</source>
         <translation>行 %1: 扱われていない要素(Unhandled element) %2</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="226"/>
+        <location filename="cppchecklibrarydata.cpp" line="43"/>
+        <source>line %1: Mandatory attribute &apos;%2&apos; missing in &apos;%3&apos;</source>
+        <translation>行 %1: 必須の属性 &apos;%2&apos; が &apos;%3&apos;にない</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="284"/>
         <source> (Not found)</source>
         <translation> (見つかりません)</translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="69"/>
+        <location filename="codeeditstylecontrols.cpp" line="76"/>
         <source>Thin</source>
         <translation>シン(細)</translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="71"/>
+        <location filename="codeeditstylecontrols.cpp" line="78"/>
         <source>ExtraLight</source>
         <translation>エクストラライト</translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="73"/>
+        <location filename="codeeditstylecontrols.cpp" line="80"/>
         <source>Light</source>
         <translation>ライト</translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="75"/>
+        <location filename="codeeditstylecontrols.cpp" line="82"/>
         <source>Normal</source>
         <translation>ノーマル</translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="77"/>
+        <location filename="codeeditstylecontrols.cpp" line="84"/>
         <source>Medium</source>
         <translation>メディウム</translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="79"/>
+        <location filename="codeeditstylecontrols.cpp" line="86"/>
         <source>DemiBold</source>
         <translation>デミボールト</translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="81"/>
+        <location filename="codeeditstylecontrols.cpp" line="88"/>
         <source>Bold</source>
         <translation>ボールド</translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="83"/>
+        <location filename="codeeditstylecontrols.cpp" line="90"/>
         <source>ExtraBold</source>
         <translation>エクストラボールド</translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="85"/>
+        <location filename="codeeditstylecontrols.cpp" line="92"/>
         <source>Black</source>
         <translation>黒</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="69"/>
+        <location filename="codeeditstyledialog.cpp" line="80"/>
         <source>Editor Foreground Color</source>
         <translation>エディタの前景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="72"/>
+        <location filename="codeeditstyledialog.cpp" line="83"/>
         <source>Editor Background Color</source>
         <translation>エディタの背景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="75"/>
+        <location filename="codeeditstyledialog.cpp" line="86"/>
         <source>Highlight Background Color</source>
         <translation>ハイライトの背景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="78"/>
+        <location filename="codeeditstyledialog.cpp" line="89"/>
         <source>Line Number Foreground Color</source>
         <translation>行番号の前景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="81"/>
+        <location filename="codeeditstyledialog.cpp" line="92"/>
         <source>Line Number Background Color</source>
         <translation>行番号の背景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="84"/>
+        <location filename="codeeditstyledialog.cpp" line="95"/>
         <source>Keyword Foreground Color</source>
         <translation>キーワードの前景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="87"/>
+        <location filename="codeeditstyledialog.cpp" line="98"/>
         <source>Keyword Font Weight</source>
         <translation>キーワードのフォントのウェイト</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="90"/>
+        <location filename="codeeditstyledialog.cpp" line="101"/>
         <source>Class Foreground Color</source>
         <oldsource>Class ForegroundColor</oldsource>
         <translation>クラスの前景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="93"/>
+        <location filename="codeeditstyledialog.cpp" line="104"/>
         <source>Class Font Weight</source>
         <translation>クラスフォントのウェイト</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="96"/>
+        <location filename="codeeditstyledialog.cpp" line="107"/>
         <source>Quote Foreground Color</source>
         <translation>クォートの前景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="99"/>
+        <location filename="codeeditstyledialog.cpp" line="110"/>
         <source>Quote Font Weight</source>
         <translation>クォートのフォントウェイト</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="102"/>
+        <location filename="codeeditstyledialog.cpp" line="113"/>
         <source>Comment Foreground Color</source>
         <translation>コメントの前景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="105"/>
+        <location filename="codeeditstyledialog.cpp" line="116"/>
         <source>Comment Font Weight</source>
         <translation>コメントフォントのウェイト</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="108"/>
+        <location filename="codeeditstyledialog.cpp" line="119"/>
         <source>Symbol Foreground Color</source>
         <translation>シンボルの前景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="111"/>
+        <location filename="codeeditstyledialog.cpp" line="122"/>
         <source>Symbol Background Color</source>
         <translation>シンボルの背景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="114"/>
+        <location filename="codeeditstyledialog.cpp" line="125"/>
         <source>Symbol Font Weight</source>
         <translation>シンボルのフォントウェイト</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="130"/>
+        <location filename="codeeditstyledialog.cpp" line="141"/>
         <source>Set to Default Light</source>
         <translation>デフォルトをライトに設定</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="132"/>
+        <location filename="codeeditstyledialog.cpp" line="143"/>
         <source>Set to Default Dark</source>
         <translation>デフォルトをダークに設定</translation>
     </message>
+    <message>
+        <location filename="resultstree.cpp" line="113"/>
+        <source>File</source>
+        <translation>ファイル</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="114"/>
+        <source>Line</source>
+        <translation>行</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="115"/>
+        <source>Severity</source>
+        <translation>警告の種別</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="116"/>
+        <source>Classification</source>
+        <translation>分類</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="117"/>
+        <source>Level</source>
+        <translation>レベル</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="118"/>
+        <source>Inconclusive</source>
+        <translation>結論のでない</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="119"/>
+        <source>Summary</source>
+        <translation>要約</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="120"/>
+        <source>Id</source>
+        <translation>Id</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="121"/>
+        <source>Guideline</source>
+        <translation>ガイドライン</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="122"/>
+        <source>Rule</source>
+        <translation>ルール</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="123"/>
+        <source>Since date</source>
+        <translation>日付</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="124"/>
+        <source>Tags</source>
+        <translation>タグ</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="125"/>
+        <source>CWE</source>
+        <translation>CWE</translation>
+    </message>
 </context>
 <context>
     <name>QPlatformTheme</name>
     <message>
-        <location filename="translationhandler.cpp" line="39"/>
+        <location filename="translationhandler.cpp" line="41"/>
         <source>OK</source>
         <translation>OK</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="40"/>
+        <location filename="translationhandler.cpp" line="42"/>
         <source>Cancel</source>
         <translation>キャンセル</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="41"/>
+        <location filename="translationhandler.cpp" line="43"/>
         <source>Close</source>
         <translation>閉じる</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="42"/>
+        <location filename="translationhandler.cpp" line="44"/>
         <source>Save</source>
         <translation>保存する</translation>
     </message>
@@ -2068,129 +2394,116 @@ Options:
 <context>
     <name>ResultsTree</name>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>File</source>
-        <translation>ファイル</translation>
+        <translation type="vanished">ファイル</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Severity</source>
-        <translation>警告の種別</translation>
+        <translation type="vanished">警告の種別</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Line</source>
-        <translation>行</translation>
+        <translation type="vanished">行</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Summary</source>
-        <translation>要約</translation>
+        <translation type="vanished">要約</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="136"/>
         <source>Undefined file</source>
-        <translation>未定義ファイル</translation>
+        <translation type="vanished">未定義ファイル</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="614"/>
+        <location filename="resultstree.cpp" line="668"/>
         <source>Copy</source>
         <translation>コピー</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="797"/>
+        <location filename="resultstree.cpp" line="836"/>
         <source>Could not find file:</source>
         <translation>ファイルが見つかりません:</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="801"/>
+        <location filename="resultstree.cpp" line="840"/>
         <source>Please select the folder &apos;%1&apos;</source>
         <translation>フォルダ &apos;%1&apos; を選択してください</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="802"/>
+        <location filename="resultstree.cpp" line="841"/>
         <source>Select Directory &apos;%1&apos;</source>
         <translation>ディレクトリ &apos;%1&apos; 選択</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="804"/>
+        <location filename="resultstree.cpp" line="843"/>
         <source>Please select the directory where file is located.</source>
         <translation>ファイルのあるディレクトリを選択してください。</translation>
     </message>
     <message>
-        <source>[Inconclusive]</source>
-        <translation type="obsolete">[結論の出ない]</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="312"/>
+        <location filename="resultstree.cpp" line="373"/>
         <source>debug</source>
         <translation>デバッグ</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="249"/>
+        <location filename="resultstree.cpp" line="307"/>
         <source>note</source>
         <translation>注意</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="613"/>
         <source>Recheck</source>
-        <translation>再チェック</translation>
-    </message>
-    <message>
-        <source>Copy filename</source>
-        <translation type="obsolete">ファイル名をコピー</translation>
-    </message>
-    <message>
-        <source>Copy full path</source>
-        <translation type="obsolete">フルパスをコピー</translation>
-    </message>
-    <message>
-        <source>Copy message</source>
-        <translation type="obsolete">メッセージをコピー</translation>
+        <translation type="vanished">再チェック</translation>
     </message>
     <message>
-        <source>Copy message id</source>
-        <translation type="obsolete">メッセージidをコピー</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="615"/>
         <source>Hide</source>
-        <translation>非表示</translation>
+        <translation type="vanished">非表示</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="616"/>
+        <location filename="resultstree.cpp" line="670"/>
         <source>Hide all with id</source>
         <translation>IDで非表示を指定</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="617"/>
+        <location filename="resultstree.cpp" line="692"/>
         <source>Suppress selected id(s)</source>
         <translation>選択したidを抑制</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="618"/>
+        <location filename="resultstree.cpp" line="671"/>
         <source>Open containing folder</source>
         <translation>含まれるフォルダを開く</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="648"/>
-        <location filename="resultstree.cpp" line="1343"/>
+        <location filename="resultstree.cpp" line="376"/>
+        <source>internal</source>
+        <translation>内部</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="667"/>
+        <source>Recheck %1 file(s)</source>
+        <translation>再チェック %1 件のファイル</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="669"/>
+        <source>Hide %1 result(s)</source>
+        <translation>非表示 %1 件の結果</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="712"/>
         <source>Tag</source>
         <translation>タグ</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="650"/>
+        <location filename="resultstree.cpp" line="714"/>
         <source>No tag</source>
         <translation>タグなし</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="693"/>
-        <location filename="resultstree.cpp" line="707"/>
+        <location filename="resultstree.cpp" line="744"/>
+        <location filename="resultstree.cpp" line="758"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="694"/>
+        <location filename="resultstree.cpp" line="745"/>
         <source>No editor application configured.
 
 Configure the editor application for Cppcheck in preferences/Applications.</source>
@@ -2200,7 +2513,7 @@ Configure the editor application for Cppcheck in preferences/Applications.</sour
 Cppcheckの「設定」からテキストファイルを編集するアプリケーションを設定してください。</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="708"/>
+        <location filename="resultstree.cpp" line="759"/>
         <source>No default editor application selected.
 
 Please select the default editor application in preferences/Applications.</source>
@@ -2209,12 +2522,12 @@ Please select the default editor application in preferences/Applications.</sourc
 設定からデフォルトのエディタアプリケーションを設定してください。</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="737"/>
+        <location filename="resultstree.cpp" line="779"/>
         <source>Could not find the file!</source>
         <translation>ファイルが見つかりません!</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="783"/>
+        <location filename="resultstree.cpp" line="822"/>
         <source>Could not start %1
 
 Please check the application path and parameters are correct.</source>
@@ -2223,60 +2536,49 @@ Please check the application path and parameters are correct.</source>
 実行ファイルパスや引数の設定を確認してください。</translation>
     </message>
     <message>
-        <source>Could not find file:
-%1
-Please select the directory where file is located.</source>
-        <translation type="obsolete">ファイルが見つかりません:
-%1
-ディレクトリにファイルが存在するか確認してください。</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="805"/>
+        <location filename="resultstree.cpp" line="844"/>
         <source>Select Directory</source>
         <translation>ディレクトリを選択</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Id</source>
-        <translation>Id</translation>
+        <translation type="vanished">Id</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Inconclusive</source>
-        <translation>結論のでない</translation>
+        <translation type="vanished">結論のでない</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Since date</source>
-        <translation>日付</translation>
+        <translation type="vanished">日付</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="294"/>
+        <location filename="resultstree.cpp" line="355"/>
         <source>style</source>
         <translation>スタイル</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="297"/>
+        <location filename="resultstree.cpp" line="358"/>
         <source>error</source>
         <translation>エラー</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="300"/>
+        <location filename="resultstree.cpp" line="361"/>
         <source>warning</source>
         <translation>警告</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="303"/>
+        <location filename="resultstree.cpp" line="364"/>
         <source>performance</source>
         <translation>パフォーマンス</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="306"/>
+        <location filename="resultstree.cpp" line="367"/>
         <source>portability</source>
         <translation>移植可能性</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="309"/>
+        <location filename="resultstree.cpp" line="370"/>
         <source>information</source>
         <translation>情報</translation>
     </message>
@@ -2289,102 +2591,123 @@ Please select the directory where file is located.</source>
         <translation>結果</translation>
     </message>
     <message>
-        <location filename="resultsview.ui" line="82"/>
+        <location filename="resultsview.ui" line="60"/>
+        <source>Critical errors</source>
+        <translation>致命的なエラー</translation>
+    </message>
+    <message>
+        <location filename="resultsview.ui" line="92"/>
         <source>Analysis Log</source>
         <translation>チェックログ</translation>
     </message>
     <message>
-        <location filename="resultsview.ui" line="104"/>
+        <location filename="resultsview.ui" line="114"/>
         <source>Warning Details</source>
         <translation>警告の詳細</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="159"/>
-        <source>No errors found, nothing to save.</source>
-        <translation>警告/エラーが見つからなかったため、保存しません。</translation>
-    </message>
-    <message>
-        <location filename="resultsview.cpp" line="183"/>
-        <location filename="resultsview.cpp" line="191"/>
+        <location filename="resultsview.cpp" line="237"/>
+        <location filename="resultsview.cpp" line="245"/>
         <source>Failed to save the report.</source>
         <translation>レポートの保存に失敗しました。</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="201"/>
+        <location filename="resultsview.cpp" line="255"/>
         <source>Print Report</source>
         <translation>レポートの印刷</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="220"/>
+        <location filename="resultsview.cpp" line="274"/>
         <source>No errors found, nothing to print.</source>
         <translation>指摘がないため、印刷するものがありません。</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="264"/>
+        <location filename="resultsview.cpp" line="326"/>
         <source>%p% (%1 of %2 files checked)</source>
         <translation>%p% (%1 / %2 :ファイル数)</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="277"/>
-        <location filename="resultsview.cpp" line="288"/>
+        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="361"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="278"/>
+        <location filename="resultsview.cpp" line="351"/>
         <source>No errors found.</source>
         <translation>警告/エラーは見つかりませんでした。</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="285"/>
+        <location filename="resultsview.cpp" line="358"/>
         <source>Errors were found, but they are configured to be hidden.
 To toggle what kind of errors are shown, open view menu.</source>
         <translation>警告/エラーが見つかりましたが、非表示設定になっています。</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="331"/>
-        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="421"/>
         <source>Failed to read the report.</source>
         <translation>レポートの読み込みに失敗.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="338"/>
+        <location filename="resultsview.cpp" line="409"/>
         <source>XML format version 1 is no longer supported.</source>
         <translation>XML フォーマットバージョン 1 はもうサポートされていません。</translation>
     </message>
     <message>
-        <source>Summary</source>
-        <translation type="obsolete">内容</translation>
-    </message>
-    <message>
-        <source>Message</source>
-        <translation type="obsolete">メッセージ</translation>
-    </message>
-    <message>
-        <location filename="resultsview.cpp" line="399"/>
+        <location filename="resultsview.cpp" line="460"/>
         <source>First included by</source>
         <translation>は次のものが最初にインクルードしました</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="465"/>
         <source>Id</source>
         <translation>ID</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="471"/>
+        <source>Bug hunting analysis is incomplete</source>
+        <translation type="vanished">バグハントの解析は不完全です</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="539"/>
         <source>Clear Log</source>
         <translation>ログの消去</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="472"/>
+        <location filename="resultsview.cpp" line="540"/>
         <source>Copy this Log entry</source>
         <translation>このログ項目をコピー</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="473"/>
+        <location filename="resultsview.cpp" line="541"/>
         <source>Copy complete Log</source>
         <translation>ログ全体をコピー</translation>
     </message>
+    <message>
+        <location filename="resultsview.cpp" line="549"/>
+        <source>Analysis was stopped</source>
+        <translation>解析は停止しした</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="563"/>
+        <source>There was a critical error with id &apos;%1&apos;</source>
+        <translation>id &apos;%1&apos;の致命的なエラーがあります</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="565"/>
+        <source>when checking %1</source>
+        <translation>%1 をチェックするとき</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="567"/>
+        <source>when checking a file</source>
+        <translation>ファイルをチェックするとき</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="568"/>
+        <source>Analysis was aborted.</source>
+        <translation>解析は中止した。</translation>
+    </message>
 </context>
 <context>
     <name>ScratchPad</name>
@@ -2427,11 +2750,7 @@ To toggle what kind of errors are shown, open view menu.</source>
         <translation>全般</translation>
     </message>
     <message>
-        <source>Include paths:</source>
-        <translation type="obsolete">Include ディレクトリ:</translation>
-    </message>
-    <message>
-        <location filename="settings.ui" line="195"/>
+        <location filename="settings.ui" line="196"/>
         <source>Add...</source>
         <translation>追加...</translation>
     </message>
@@ -2441,496 +2760,507 @@ To toggle what kind of errors are shown, open view menu.</source>
         <translation>解析用のスレッド数: </translation>
     </message>
     <message>
-        <location filename="settings.ui" line="85"/>
         <source>Ideal count:</source>
-        <translation>理想的な数：</translation>
+        <translation type="vanished">理想的な数：</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="114"/>
+        <location filename="settings.ui" line="108"/>
         <source>Force checking all #ifdef configurations</source>
         <oldsource>Check all #ifdef configurations</oldsource>
         <translation>すべての #ifdef をチェックする</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="121"/>
+        <location filename="settings.ui" line="115"/>
         <source>Show full path of files</source>
         <translation>ファイルのフルパスを表示</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="128"/>
+        <location filename="settings.ui" line="122"/>
         <source>Show &quot;No errors found&quot; message when no errors found</source>
         <translation>エラーが無いときは&quot;エラーなし&quot;を表示</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="135"/>
+        <location filename="settings.ui" line="129"/>
         <source>Display error Id in column &quot;Id&quot;</source>
         <translation>エラーIDを &quot;Id&quot; に表示する</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="142"/>
+        <location filename="settings.ui" line="136"/>
         <source>Enable inline suppressions</source>
         <translation>inline抑制を有効にする</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="149"/>
+        <location filename="settings.ui" line="143"/>
         <source>Check for inconclusive errors also</source>
         <translation>結論のでない指摘もチェックする</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="156"/>
+        <location filename="settings.ui" line="150"/>
         <source>Show statistics on check completion</source>
         <translation>チェック完了時に統計情報を表示する</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="176"/>
+        <location filename="settings.ui" line="157"/>
+        <source>Check for updates</source>
+        <translation>更新の確認</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="177"/>
         <source>Show internal warnings in log</source>
         <translation>ログの内部警告も表示する</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="287"/>
+        <location filename="settings.ui" line="288"/>
         <source>Addons</source>
         <translation>アドオン</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="293"/>
+        <location filename="settings.ui" line="294"/>
         <source>Python binary (leave this empty to use python in the PATH)</source>
         <translation>Pythonインタプリタの場所(空白の場合システムのPATHから検索)</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="302"/>
-        <location filename="settings.ui" line="334"/>
-        <location filename="settings.ui" line="379"/>
+        <location filename="settings.ui" line="305"/>
+        <location filename="settings.ui" line="346"/>
+        <location filename="settings.ui" line="391"/>
         <source>...</source>
         <translation>...</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="312"/>
-        <source>Misra addon</source>
-        <translation>Misraアドオン</translation>
+        <location filename="settings.ui" line="324"/>
+        <source>MISRA addon</source>
+        <translation>MISRAアドオン</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="320"/>
-        <source>Misra rule texts file</source>
-        <translation>Misra ルールテキストファイル</translation>
+        <location filename="settings.ui" line="332"/>
+        <source>MISRA rule texts file</source>
+        <translation>MISRA ルールテキストファイル</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="327"/>
+        <location filename="settings.ui" line="339"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdfのテキストをテキストファイルにコピー&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="360"/>
+        <location filename="settings.ui" line="372"/>
         <source>Clang</source>
         <translation>Clang</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="366"/>
+        <location filename="settings.ui" line="378"/>
         <source>Clang path (leave empty to use system PATH)</source>
         <translation>Clangの場所(空白の場合システムのPATHから検索)</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="389"/>
+        <location filename="settings.ui" line="401"/>
         <source>Visual Studio headers</source>
         <translation>Visual Studioのヘッダ</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="395"/>
+        <location filename="settings.ui" line="407"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Paths to Visual Studio headers, separated by semicolon &apos;;&apos;.&lt;/p&gt;&lt;p&gt;You can open a Visual Studio command prompt, write &amp;quot;SET INCLUDE&amp;quot;. Then copy/paste the paths.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Visual Studioのヘッダーファイル(セミコロン区切り&apos;;&apos;)。&lt;/p&gt;&lt;p&gt;Visual Studio コマンドプロンプトを開き、 &amp;quot;SET INCLUDE&amp;quot;. と入力後、そのパスをコピーペーストしてください。&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="425"/>
+        <location filename="settings.ui" line="437"/>
         <source>Code Editor</source>
         <translation>コードエディタ</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="431"/>
+        <location filename="settings.ui" line="443"/>
         <source>Code Editor Style</source>
         <translation>コードエディタスタイル</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="437"/>
+        <location filename="settings.ui" line="449"/>
         <source>System Style</source>
         <translation>システムのデフォルトのスタイル</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="444"/>
+        <location filename="settings.ui" line="456"/>
         <source>Default Light Style</source>
         <translation>ライトスタイルをデフォルトに</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="451"/>
+        <location filename="settings.ui" line="463"/>
         <source>Default Dark Style</source>
         <translation>ダークスタイルをデフォルトに</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="460"/>
+        <location filename="settings.ui" line="472"/>
         <source>Custom</source>
         <translation>カスタム</translation>
     </message>
     <message>
-        <source>Paths</source>
-        <translation type="obsolete">パス</translation>
-    </message>
-    <message>
-        <source>Edit</source>
-        <translation type="obsolete">編集</translation>
-    </message>
-    <message>
-        <location filename="settings.ui" line="209"/>
+        <location filename="settings.ui" line="210"/>
         <source>Remove</source>
         <translation>削除</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="184"/>
+        <location filename="settings.ui" line="79"/>
+        <source>Max count:</source>
+        <translation>#M 最大数:</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="185"/>
         <source>Applications</source>
         <translation>アプリケーション</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="202"/>
-        <location filename="settings.ui" line="467"/>
+        <location filename="settings.ui" line="203"/>
+        <location filename="settings.ui" line="479"/>
         <source>Edit...</source>
         <translation>編集...</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="216"/>
+        <location filename="settings.ui" line="217"/>
         <source>Set as default</source>
         <translation>デフォルトとして設定</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="239"/>
+        <location filename="settings.ui" line="240"/>
         <source>Reports</source>
         <translation>レポート</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="245"/>
+        <location filename="settings.ui" line="246"/>
         <source>Save all errors when creating report</source>
         <translation>レポート作成時にすべての警告/エラーを保存</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="252"/>
+        <location filename="settings.ui" line="253"/>
         <source>Save full path to files in reports</source>
         <translation>レポートにファイルのフルパスを保存</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="273"/>
+        <location filename="settings.ui" line="274"/>
         <source>Language</source>
         <translation>言語</translation>
     </message>
-    <message>
-        <source>Advanced</source>
-        <translation type="obsolete">高度</translation>
-    </message>
-    <message>
-        <source>&amp;Show inconclusive errors</source>
-        <translation type="obsolete">結論の出ないのエラーを表示</translation>
-    </message>
 </context>
 <context>
     <name>SettingsDialog</name>
     <message>
-        <location filename="settingsdialog.cpp" line="100"/>
         <source>N/A</source>
-        <translation>N/A</translation>
+        <translation type="vanished">N/A</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="200"/>
+        <location filename="settingsdialog.cpp" line="232"/>
+        <source>The executable file &quot;%1&quot; is not available</source>
+        <translation>実行ファイル &quot;%1&quot; が利用できません</translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="243"/>
         <source>Add a new application</source>
         <translation>新しいアプリケーションの追加</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="233"/>
+        <location filename="settingsdialog.cpp" line="273"/>
         <source>Modify an application</source>
         <translation>アプリケーションの変更</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="238"/>
+        <location filename="settingsdialog.cpp" line="278"/>
         <source> [Default]</source>
         <translation> [デフォルト]</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="263"/>
+        <location filename="settingsdialog.cpp" line="303"/>
         <source>[Default]</source>
         <translation>[デフォルト]</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="318"/>
+        <location filename="settingsdialog.cpp" line="358"/>
         <source>Select python binary</source>
         <translation>pythonの場所の選択</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="325"/>
+        <location filename="settingsdialog.cpp" line="365"/>
         <source>Select MISRA File</source>
         <translation>MISRAファイルの選択</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="356"/>
+        <location filename="settingsdialog.cpp" line="396"/>
         <source>Select clang path</source>
         <translation>clangのパスの選択</translation>
     </message>
-    <message>
-        <source>Select include directory</source>
-        <translation type="obsolete">include ディレクトリを選択</translation>
-    </message>
 </context>
 <context>
     <name>StatsDialog</name>
     <message>
-        <location filename="stats.ui" line="14"/>
-        <location filename="stats.ui" line="248"/>
-        <location filename="statsdialog.cpp" line="137"/>
-        <location filename="statsdialog.cpp" line="184"/>
+        <location filename="statsdialog.ui" line="14"/>
+        <location filename="statsdialog.ui" line="248"/>
+        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="230"/>
         <source>Statistics</source>
         <translation>統計情報</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="27"/>
-        <location filename="statsdialog.cpp" line="175"/>
+        <location filename="statsdialog.ui" line="27"/>
+        <location filename="statsdialog.cpp" line="221"/>
         <source>Project</source>
         <translation>プロジェクト</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="33"/>
+        <location filename="statsdialog.ui" line="33"/>
         <source>Project:</source>
         <translation>プロジェクト:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="53"/>
+        <location filename="statsdialog.ui" line="53"/>
         <source>Paths:</source>
         <translation>パス:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="85"/>
+        <location filename="statsdialog.ui" line="85"/>
         <source>Include paths:</source>
         <translation>インクルードパス:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="108"/>
+        <location filename="statsdialog.ui" line="108"/>
         <source>Defines:</source>
         <translation>定義(define):</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="131"/>
+        <location filename="statsdialog.ui" line="131"/>
         <source>Undefines:</source>
         <translation>定義取り消し(undef):</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="165"/>
-        <location filename="statsdialog.cpp" line="180"/>
+        <location filename="statsdialog.ui" line="165"/>
+        <location filename="statsdialog.cpp" line="226"/>
         <source>Previous Scan</source>
         <translation>前回の解析</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="171"/>
+        <location filename="statsdialog.ui" line="171"/>
         <source>Path Selected:</source>
         <translation>ディレクトリ選択:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="181"/>
+        <location filename="statsdialog.ui" line="181"/>
         <source>Number of Files Scanned:</source>
         <translation>解析済みファイル数:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="201"/>
+        <location filename="statsdialog.ui" line="201"/>
         <source>Scan Duration:</source>
         <translation>解析にかかった時間:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="256"/>
+        <location filename="statsdialog.ui" line="254"/>
         <source>Errors:</source>
         <translation>エラー:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="274"/>
+        <location filename="statsdialog.ui" line="271"/>
         <source>Warnings:</source>
         <translation>警告:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="292"/>
+        <location filename="statsdialog.ui" line="288"/>
         <source>Stylistic warnings:</source>
         <translation>スタイル警告:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="310"/>
+        <location filename="statsdialog.ui" line="305"/>
         <source>Portability warnings:</source>
         <translation>移植可能性の警告:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="328"/>
+        <location filename="statsdialog.ui" line="322"/>
         <source>Performance issues:</source>
         <translation>パフォーマンス警告:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="346"/>
+        <location filename="statsdialog.ui" line="339"/>
         <source>Information messages:</source>
         <translation>情報メッセージ:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="363"/>
+        <location filename="statsdialog.ui" line="356"/>
+        <source>Active checkers:</source>
+        <translation>有効なチェッカー:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="374"/>
+        <source>Checkers</source>
+        <translation>チェッカー</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="399"/>
         <source>History</source>
         <translation>ヒストリー</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="369"/>
+        <location filename="statsdialog.ui" line="405"/>
         <source>File:</source>
         <translation>ファイル:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="407"/>
+        <location filename="statsdialog.ui" line="443"/>
         <source>Copy to Clipboard</source>
         <translation>クリップボードにコピー</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="414"/>
+        <location filename="statsdialog.ui" line="450"/>
         <source>Pdf Export</source>
         <translation>PDF エクスポート</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="113"/>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>1 day</source>
         <translation>一日</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="113"/>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>%1 days</source>
         <translation>%1日</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="115"/>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>1 hour</source>
         <translation>一時間</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="115"/>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>%1 hours</source>
         <translation>%1時間</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="117"/>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>1 minute</source>
         <translation>一分</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="117"/>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>%1 minutes</source>
         <translation>%1分</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="119"/>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>1 second</source>
         <translation>一秒</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="119"/>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>%1 seconds</source>
         <translation>%1秒</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="123"/>
+        <location filename="statsdialog.cpp" line="169"/>
         <source>0.%1 seconds</source>
         <translation>0.%1秒</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="125"/>
+        <location filename="statsdialog.cpp" line="171"/>
         <source> and </source>
-        <translation></translation>
+        <translation> と </translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="152"/>
+        <location filename="statsdialog.cpp" line="198"/>
         <source>Export PDF</source>
         <translation>PDF エクスポート</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="174"/>
+        <location filename="statsdialog.cpp" line="220"/>
         <source>Project Settings</source>
         <translation>プロジェクトの設定</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="176"/>
+        <location filename="statsdialog.cpp" line="222"/>
         <source>Paths</source>
         <translation>パス</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="177"/>
+        <location filename="statsdialog.cpp" line="223"/>
         <source>Include paths</source>
         <translation>インクルードパス</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="178"/>
+        <location filename="statsdialog.cpp" line="224"/>
         <source>Defines</source>
         <translation>定義(define)</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="179"/>
+        <location filename="statsdialog.cpp" line="225"/>
         <source>Undefines</source>
         <translation>定義取り消し(Undef)</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="181"/>
+        <location filename="statsdialog.cpp" line="227"/>
         <source>Path selected</source>
         <translation>選択されたパス</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="182"/>
+        <location filename="statsdialog.cpp" line="228"/>
         <source>Number of files scanned</source>
         <translation>スキャンしたファイルの数</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="229"/>
         <source>Scan duration</source>
         <translation>スキャン期間</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="139"/>
         <location filename="statsdialog.cpp" line="185"/>
+        <location filename="statsdialog.cpp" line="231"/>
         <source>Errors</source>
         <translation>エラー</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="65"/>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>File: </source>
         <translation>ファイル: </translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="65"/>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>No cppcheck build dir</source>
         <translation>cppcheckビルドディレクトリがありません</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="141"/>
-        <location filename="statsdialog.cpp" line="186"/>
+        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="232"/>
         <source>Warnings</source>
         <translation>警告</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="143"/>
-        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="233"/>
         <source>Style warnings</source>
         <translation>スタイル警告</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="145"/>
-        <location filename="statsdialog.cpp" line="188"/>
+        <location filename="statsdialog.cpp" line="191"/>
+        <location filename="statsdialog.cpp" line="234"/>
         <source>Portability warnings</source>
         <translation>移植可能性警告</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="147"/>
-        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="193"/>
+        <location filename="statsdialog.cpp" line="235"/>
         <source>Performance warnings</source>
         <translation>パフォーマンス警告</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="149"/>
-        <location filename="statsdialog.cpp" line="190"/>
+        <location filename="statsdialog.cpp" line="195"/>
+        <location filename="statsdialog.cpp" line="236"/>
         <source>Information messages</source>
         <translation>情報メッセージ</translation>
     </message>
 </context>
+<context>
+    <name>ThreadDetails</name>
+    <message>
+        <location filename="threaddetails.ui" line="14"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>ThreadResult</name>
     <message>
-        <location filename="threadresult.cpp" line="54"/>
+        <location filename="threadresult.cpp" line="47"/>
         <source>%1 of %2 files checked</source>
         <translation>チェック: %1 / %2 (ファイル数)</translation>
     </message>
@@ -2938,7 +3268,7 @@ To toggle what kind of errors are shown, open view menu.</source>
 <context>
     <name>TranslationHandler</name>
     <message>
-        <location filename="translationhandler.cpp" line="145"/>
+        <location filename="translationhandler.cpp" line="130"/>
         <source>Failed to change the user interface language:
 
 %1
@@ -2949,7 +3279,7 @@ The user interface language has been reset to English. Open the Preferences-dial
 そのため言語を 英語にリセットします。設定ダイアログから利用可能な言語を選択してください。</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="151"/>
+        <location filename="translationhandler.cpp" line="136"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
@@ -2957,7 +3287,7 @@ The user interface language has been reset to English. Open the Preferences-dial
 <context>
     <name>TxtReport</name>
     <message>
-        <location filename="txtreport.cpp" line="73"/>
+        <location filename="txtreport.cpp" line="74"/>
         <source>inconclusive</source>
         <translation>結論の出ない</translation>
     </message>
@@ -2965,12 +3295,12 @@ The user interface language has been reset to English. Open the Preferences-dial
 <context>
     <name>toFilterString</name>
     <message>
-        <location filename="common.cpp" line="52"/>
+        <location filename="common.cpp" line="58"/>
         <source>All supported files (%1)</source>
         <translation>全サポートファイル (%1)</translation>
     </message>
     <message>
-        <location filename="common.cpp" line="57"/>
+        <location filename="common.cpp" line="63"/>
         <source>All files (%1)</source>
         <translation>全ファイル(%1)</translation>
     </message>
diff --git a/gui/cppcheck_ka.ts b/gui/cppcheck_ka.ts
new file mode 100644
index 00000000000..ecc47d7d090
--- /dev/null
+++ b/gui/cppcheck_ka.ts
@@ -0,0 +1,3265 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE TS>
+<TS version="2.1" language="ka_GE">
+<context>
+    <name>About</name>
+    <message>
+        <location filename="about.ui" line="14"/>
+        <source>About Cppcheck</source>
+        <translation>Cppcheck-ის შესახებ</translation>
+    </message>
+    <message>
+        <location filename="about.ui" line="64"/>
+        <source>Version %1</source>
+        <translation>ვერსია %1</translation>
+    </message>
+    <message>
+        <location filename="about.ui" line="71"/>
+        <source>Cppcheck - A tool for static C/C++ code analysis.</source>
+        <translation>Cppcheck - ხელსაწყო სტატიკური C/C++ კოდის ანალიზისთვის.</translation>
+    </message>
+    <message>
+        <location filename="about.ui" line="81"/>
+        <source>Copyright © 2007-%1 Cppcheck team.</source>
+        <oldsource>Copyright © 2007-2021 Cppcheck team.</oldsource>
+        <translation>Copyright © 2007-%1 Cppcheck-ის გუნდი. ყველა უფლება დაცულია.</translation>
+    </message>
+    <message>
+        <location filename="about.ui" line="91"/>
+        <source>This program is licensed under the terms
+of the GNU General Public License version 3</source>
+        <translation>ვრცელდება GNU-ის საჯარო ლიცენზიის,
+ვერსია 3, პირობებით</translation>
+    </message>
+    <message>
+        <location filename="about.ui" line="102"/>
+        <source>Visit Cppcheck homepage at %1</source>
+        <translation>ეწვიეთ Cppcheck-ის ვებგვერდს მისამართზე %1</translation>
+    </message>
+    <message>
+        <location filename="about.ui" line="115"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PCRE&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PicoJSON&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;TinyXML2&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Boost&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <oldsource>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;pcre&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;picojson&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;tinyxml2&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</oldsource>
+        <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;დიდი მადლობა ამ ბიბლიოთეკებს, რომლებსაც ვიყენებთ::&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PCRE&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PicoJSON&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;TinyXML2&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Boost&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</translation>
+    </message>
+</context>
+<context>
+    <name>ApplicationDialog</name>
+    <message>
+        <location filename="applicationdialog.ui" line="23"/>
+        <source>Add an application</source>
+        <translation>აპლიკაციის დამატება</translation>
+    </message>
+    <message>
+        <location filename="applicationdialog.ui" line="41"/>
+        <source>Here you can add an application that can open error files. Specify a name for the application, the application executable and command line parameters for the application.
+
+The following texts in parameters are replaced with appropriate values when application is executed:
+(file) - Filename containing the error
+(line) - Line number containing the error
+(message) - Error message
+(severity) - Error severity
+
+Example opening a file with Kate and make Kate scroll to the correct line:
+Executable: kate
+Parameters: -l(line) (file)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="applicationdialog.ui" line="76"/>
+        <source>&amp;Name:</source>
+        <translation>&amp;სახელი:</translation>
+    </message>
+    <message>
+        <location filename="applicationdialog.ui" line="86"/>
+        <source>&amp;Executable:</source>
+        <translation>&amp;გამშვები ფაილი:</translation>
+    </message>
+    <message>
+        <location filename="applicationdialog.ui" line="96"/>
+        <source>&amp;Parameters:</source>
+        <translation>&amp;პარამეტრები:</translation>
+    </message>
+    <message>
+        <location filename="applicationdialog.ui" line="138"/>
+        <source>Browse</source>
+        <translation>დათვალიერება</translation>
+    </message>
+    <message>
+        <location filename="applicationdialog.cpp" line="65"/>
+        <source>Executable files (*.exe);;All files(*.*)</source>
+        <translation>შესრულებადი ფაილები (*.exe);;ყველა ფაილი(*.*)</translation>
+    </message>
+    <message>
+        <location filename="applicationdialog.cpp" line="68"/>
+        <source>Select viewer application</source>
+        <translation>აირჩიეთ აპლიკაცია</translation>
+    </message>
+    <message>
+        <location filename="applicationdialog.cpp" line="83"/>
+        <source>Cppcheck</source>
+        <translation>Cppcheck</translation>
+    </message>
+    <message>
+        <location filename="applicationdialog.cpp" line="84"/>
+        <source>You must specify a name, a path and optionally parameters for the application!</source>
+        <translation>აპლიკაციისთვის უნდა მიუთითოთ სახელი, ბილიკი და არასავალდებულო პარამეტრები!</translation>
+    </message>
+</context>
+<context>
+    <name>ComplianceReportDialog</name>
+    <message>
+        <location filename="compliancereportdialog.ui" line="14"/>
+        <source>Compliance Report</source>
+        <translation>შესაბამისობის ანგარიში</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="29"/>
+        <source>Project name</source>
+        <translation>პროექტის სახელი</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="22"/>
+        <source>Project version</source>
+        <translation>პროექტის ვერსია</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="42"/>
+        <source>Coding Standard</source>
+        <translation>კოდირების სტანდარტი</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="50"/>
+        <source>Misra C</source>
+        <translation>Misra C</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="55"/>
+        <source>Cert C</source>
+        <translation>Cert C</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="60"/>
+        <source>Cert C++</source>
+        <translation>Cert C++</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="70"/>
+        <source>List of files with md5 checksums</source>
+        <translation>MD5 საკონტროლო ჯამების მქონე ფაილების სია</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="133"/>
+        <source>Compliance report</source>
+        <translation>შესაბამისობის ანგარიში</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="135"/>
+        <source>HTML files (*.html)</source>
+        <translation>HTML ფაილები (*.html)</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="176"/>
+        <location filename="compliancereportdialog.cpp" line="239"/>
+        <source>Save compliance report</source>
+        <translation>შესაბამისობის ანგარიშის შენახვა</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="177"/>
+        <source>Failed to import &apos;%1&apos; (%2), can not show files in compliance report</source>
+        <translation>&apos;%1&apos;-ის (%2) შემოტანა ჩავარდა. შესაბამისობის ანგარიშში ფაილებს ვერ ვაჩვენებ</translation>
+    </message>
+</context>
+<context>
+    <name>FileViewDialog</name>
+    <message>
+        <location filename="fileviewdialog.cpp" line="53"/>
+        <source>Could not find the file: %1</source>
+        <oldsource>Could not find the file:
+</oldsource>
+        <translation>ვერ ვიპოვე ფაილი: %1</translation>
+    </message>
+    <message>
+        <location filename="fileviewdialog.cpp" line="57"/>
+        <location filename="fileviewdialog.cpp" line="71"/>
+        <source>Cppcheck</source>
+        <translation>Cppcheck</translation>
+    </message>
+    <message>
+        <location filename="fileviewdialog.cpp" line="67"/>
+        <source>Could not read the file: %1</source>
+        <translation>ვერ წავიკითხე ფაილი: %1</translation>
+    </message>
+</context>
+<context>
+    <name>HelpDialog</name>
+    <message>
+        <location filename="helpdialog.ui" line="14"/>
+        <source>Cppcheck GUI help</source>
+        <translation>Cppcheck-ის გრაფიკული ინტერფეისის დახმარება</translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="34"/>
+        <source>Contents</source>
+        <translation>შემცველობა</translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="44"/>
+        <source>Index</source>
+        <translation>ინდექსი</translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="84"/>
+        <source>Helpfile &apos;%1&apos; was not found</source>
+        <translation>დახმარების ფაილი &apos;%1&apos; ვერ ვიპოვე</translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="86"/>
+        <source>Cppcheck</source>
+        <translation>Cppcheck</translation>
+    </message>
+</context>
+<context>
+    <name>LibraryAddFunctionDialog</name>
+    <message>
+        <location filename="libraryaddfunctiondialog.ui" line="23"/>
+        <source>Add function</source>
+        <translation>ფუნქციის დამატება</translation>
+    </message>
+    <message>
+        <location filename="libraryaddfunctiondialog.ui" line="34"/>
+        <source>Function name(s)</source>
+        <translation>ფუნქციის სახელ(ებ)-ი</translation>
+    </message>
+    <message>
+        <location filename="libraryaddfunctiondialog.ui" line="44"/>
+        <source>Number of arguments</source>
+        <translation>არგუმენტების რაოდენობა</translation>
+    </message>
+</context>
+<context>
+    <name>LibraryDialog</name>
+    <message>
+        <location filename="librarydialog.ui" line="14"/>
+        <source>Library Editor</source>
+        <translation>ბიბლიოთეკის რედაქტორი</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="22"/>
+        <source>Open</source>
+        <translation>გახსნა</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="29"/>
+        <source>Save</source>
+        <translation>შენახვა</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="36"/>
+        <source>Save as</source>
+        <translation>შენახვა, როგორც</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="62"/>
+        <source>Functions</source>
+        <translation>ფუნქციები</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="71"/>
+        <source>Sort</source>
+        <translation>დალაგება</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="111"/>
+        <source>Add</source>
+        <translation>დამატება</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="131"/>
+        <source>Filter:</source>
+        <translation>ფილტრი:</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="164"/>
+        <source>Comments</source>
+        <translation>კომენტარები</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="204"/>
+        <source>noreturn</source>
+        <translation>noreturn</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="212"/>
+        <source>False</source>
+        <translation>მცდარი</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="217"/>
+        <source>True</source>
+        <translation>სიმართლე</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="222"/>
+        <source>Unknown</source>
+        <translation>უცნობი</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="232"/>
+        <source>return value must be used</source>
+        <translation>უნდა გამოიყენოთ დაბრუნებული მნიშვნელობა</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="239"/>
+        <source>ignore function in leaks checking</source>
+        <translation>ფუნქციების გამოტოვება გაჟონვები შემოწმებისას</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="246"/>
+        <source>Arguments</source>
+        <translation>არგუმენტები</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="258"/>
+        <source>Edit</source>
+        <translation>ჩასწორება</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.cpp" line="97"/>
+        <location filename="librarydialog.cpp" line="169"/>
+        <source>Library files (*.cfg)</source>
+        <translation>ბიბლიოთეკის ფაილები (*.cfg)</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.cpp" line="99"/>
+        <source>Open library file</source>
+        <translation>ბიბლიოთეკის ფაილის გახსნა</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.cpp" line="110"/>
+        <location filename="librarydialog.cpp" line="122"/>
+        <location filename="librarydialog.cpp" line="159"/>
+        <source>Cppcheck</source>
+        <translation>Cppcheck</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.cpp" line="111"/>
+        <source>Cannot open file %1.</source>
+        <oldsource>Can not open file %1.</oldsource>
+        <translation>ფაილის &apos;%1&apos; გახსნის შეცდომა.</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.cpp" line="123"/>
+        <source>Failed to load %1. %2.</source>
+        <translation>%1-ის ჩატვირთვის შეცდომა. %2.</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.cpp" line="160"/>
+        <source>Cannot save file %1.</source>
+        <translation>ფაილის შენახვის შეცდომა: %1 .</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.cpp" line="172"/>
+        <source>Save the library as</source>
+        <translation>ბიბლიოთეკის შენახვა, როგორც</translation>
+    </message>
+</context>
+<context>
+    <name>LibraryEditArgDialog</name>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="14"/>
+        <source>Edit argument</source>
+        <translation>არგუმენტის ჩასწორება</translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="20"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
+&lt;p&gt;Is bool value allowed? For instance result from comparison or from &apos;!&apos; operator.&lt;/p&gt;
+&lt;p&gt;Typically, set this if the argument is a pointer, size, etc.&lt;/p&gt;
+&lt;p&gt;Example:&lt;/p&gt;
+&lt;pre&gt;    memcmp(x, y, i == 123);   // last argument should not have a bool value&lt;/pre&gt;
+&lt;/body&gt;&lt;/html&gt;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="28"/>
+        <source>Not bool</source>
+        <translation>ლოგიკური მნ. არაა</translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="35"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
+&lt;p&gt;Is a null parameter value allowed?&lt;/p&gt;
+&lt;p&gt;Typically this should be used on any pointer parameter that does not allow null.&lt;/p&gt;
+&lt;p&gt;Example:&lt;/p&gt;
+&lt;pre&gt;    strcpy(x,y); // neither x or y is allowed to be null.&lt;/pre&gt;
+&lt;/body&gt;&lt;/html&gt;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="43"/>
+        <source>Not null</source>
+        <translation>ნულოვანი არაა</translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="50"/>
+        <source>Not uninit</source>
+        <translation>Uninit არაა</translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="57"/>
+        <source>String</source>
+        <translation>სტრიქონი</translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="70"/>
+        <source>Format string</source>
+        <translation>სტრიქონის ფორმატი</translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="92"/>
+        <source>Min size of buffer</source>
+        <translation>ბუფერის მინ. ზომა</translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="101"/>
+        <location filename="libraryeditargdialog.ui" line="203"/>
+        <source>Type</source>
+        <translation>ტიპი</translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="109"/>
+        <location filename="libraryeditargdialog.ui" line="214"/>
+        <source>None</source>
+        <translation>არაფერი</translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="114"/>
+        <location filename="libraryeditargdialog.ui" line="219"/>
+        <source>argvalue</source>
+        <translation>argvalue</translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="119"/>
+        <location filename="libraryeditargdialog.ui" line="224"/>
+        <source>mul</source>
+        <translation>mul</translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="124"/>
+        <location filename="libraryeditargdialog.ui" line="229"/>
+        <source>strlen</source>
+        <translation>strlen</translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="132"/>
+        <location filename="libraryeditargdialog.ui" line="237"/>
+        <source>Arg</source>
+        <translation>არგ</translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="159"/>
+        <location filename="libraryeditargdialog.ui" line="264"/>
+        <source>Arg2</source>
+        <translation>Arg2</translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="194"/>
+        <source>and</source>
+        <translation>და</translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="310"/>
+        <source>Valid values</source>
+        <translation>სწორი მნიშვნელობები</translation>
+    </message>
+</context>
+<context>
+    <name>MainWindow</name>
+    <message>
+        <location filename="mainwindow.ui" line="26"/>
+        <location filename="mainwindow.ui" line="688"/>
+        <location filename="mainwindow.cpp" line="466"/>
+        <location filename="mainwindow.cpp" line="670"/>
+        <location filename="mainwindow.cpp" line="755"/>
+        <location filename="mainwindow.cpp" line="860"/>
+        <location filename="mainwindow.cpp" line="882"/>
+        <location filename="mainwindow.cpp" line="1467"/>
+        <location filename="mainwindow.cpp" line="1596"/>
+        <location filename="mainwindow.cpp" line="1937"/>
+        <location filename="mainwindow.cpp" line="1945"/>
+        <location filename="mainwindow.cpp" line="1999"/>
+        <location filename="mainwindow.cpp" line="2008"/>
+        <location filename="mainwindow.cpp" line="2080"/>
+        <location filename="mainwindow.cpp" line="2168"/>
+        <source>Cppcheck</source>
+        <translation>Cppcheck</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="210"/>
+        <source>A&amp;nalyze</source>
+        <translation>ა&amp;ნალიზი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="267"/>
+        <source>Standard</source>
+        <translation>სტანდარტული</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="132"/>
+        <source>&amp;File</source>
+        <translation>&amp;ფაილი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="152"/>
+        <source>&amp;View</source>
+        <translation>&amp;ხედი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="156"/>
+        <source>&amp;Toolbars</source>
+        <translation>&amp;ხელსაწყოთა ზოლები</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="214"/>
+        <source>C++ standard</source>
+        <translation>C++-ის სტანდარტი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="226"/>
+        <source>&amp;C standard</source>
+        <oldsource>C standard</oldsource>
+        <translation>&amp;C-ის სტანდარტი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="254"/>
+        <source>&amp;Edit</source>
+        <translation>&amp;ჩასწორება</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="315"/>
+        <source>&amp;License...</source>
+        <translation>&amp;ლიცენზია...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="320"/>
+        <source>A&amp;uthors...</source>
+        <translation>&amp;ავტორები...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="329"/>
+        <source>&amp;About...</source>
+        <translation>&amp;შესახებ...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="334"/>
+        <source>&amp;Files...</source>
+        <translation>ფაილ&amp;ები...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="337"/>
+        <location filename="mainwindow.ui" line="340"/>
+        <source>Analyze files</source>
+        <oldsource>Check files</oldsource>
+        <translation>ფაილების ანალიზი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="343"/>
+        <source>Ctrl+F</source>
+        <translation>Ctrl+F</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="352"/>
+        <source>&amp;Directory...</source>
+        <translation>&amp;საქაღალდე....</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="355"/>
+        <location filename="mainwindow.ui" line="358"/>
+        <source>Analyze directory</source>
+        <oldsource>Check directory</oldsource>
+        <translation>საქაღალდის ანალიზი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="361"/>
+        <source>Ctrl+D</source>
+        <translation>Ctrl+D</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="373"/>
+        <source>Ctrl+R</source>
+        <translation>Ctrl+R</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="391"/>
+        <source>&amp;Stop</source>
+        <translation>&amp;გაჩერება</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="394"/>
+        <location filename="mainwindow.ui" line="397"/>
+        <source>Stop analysis</source>
+        <oldsource>Stop checking</oldsource>
+        <translation>ანალიზის გაჩერება</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="400"/>
+        <source>Esc</source>
+        <translation>Esc</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="409"/>
+        <source>&amp;Save results to file...</source>
+        <translation>შედეგები&amp;ს შენახვა ფაილში....</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="412"/>
+        <source>Ctrl+S</source>
+        <translation>Ctrl+S</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="417"/>
+        <source>&amp;Quit</source>
+        <translation>გამოსვლა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="429"/>
+        <source>&amp;Clear results</source>
+        <translation>შედეგების &amp;გასუფთავება</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="438"/>
+        <source>&amp;Preferences</source>
+        <translation>&amp;გამართვა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="471"/>
+        <location filename="mainwindow.ui" line="474"/>
+        <location filename="mainwindow.cpp" line="2394"/>
+        <source>Show errors</source>
+        <translation>შეცდომების ჩვენება</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="617"/>
+        <location filename="mainwindow.ui" line="620"/>
+        <location filename="mainwindow.cpp" line="2395"/>
+        <source>Show warnings</source>
+        <translation>გაფრთხილების ჩვენება</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="635"/>
+        <location filename="mainwindow.ui" line="638"/>
+        <source>Show performance warnings</source>
+        <translation>წარმადობის გაფრთხილებების ჩვენება</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="646"/>
+        <source>Show &amp;hidden</source>
+        <translation>დამალულის &amp;ჩვენება</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="986"/>
+        <location filename="mainwindow.cpp" line="1024"/>
+        <source>Information</source>
+        <translation>ინფორმაცია</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="661"/>
+        <source>Show information messages</source>
+        <translation>ინფორმაციის შეტყობინებების ჩვენება</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="676"/>
+        <source>Show portability warnings</source>
+        <translation>გადატანადობის გაფრთხილებების ჩვენება</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="691"/>
+        <source>Show Cppcheck results</source>
+        <translation>Cppcheck-ის შედეგები ჩვენება</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="703"/>
+        <source>Clang</source>
+        <translation>Clang</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="706"/>
+        <source>Show Clang results</source>
+        <translation>Clang-ის შედეგები ჩვენება</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="714"/>
+        <source>&amp;Filter</source>
+        <translation>&amp;ფილტრი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="717"/>
+        <source>Filter results</source>
+        <translation>შედეგების გაფილტვრა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="733"/>
+        <source>Windows 32-bit ANSI</source>
+        <translation>Windows 32-bit ANSI</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="741"/>
+        <source>Windows 32-bit Unicode</source>
+        <translation>Windows 32-bit Unicode</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="749"/>
+        <source>Unix 32-bit</source>
+        <translation>Unix 32-bit</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="757"/>
+        <source>Unix 64-bit</source>
+        <translation>Unix 64-bit</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="765"/>
+        <source>Windows 64-bit</source>
+        <translation>Windows 64-bit</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="859"/>
+        <source>&amp;Print...</source>
+        <translation>&amp;ბეჭდვა…</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="862"/>
+        <source>Print the Current Report</source>
+        <translation>მიმდინარე ანგარიშის დაბეჭდვა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="867"/>
+        <source>Print Pre&amp;view...</source>
+        <translation>საბეჭდის &amp;გადახედვა...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="870"/>
+        <source>Open a Print Preview Dialog for the Current Results</source>
+        <translation>მიმდინარე შედეგების დაბეჭდვის მინიატურის დიალოგის ჩვენება</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="878"/>
+        <source>Open library editor</source>
+        <translation>ბიბლიოთეკის რედაქტორის გახსნა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="479"/>
+        <source>&amp;Check all</source>
+        <translation>&amp;ყველას ჩართვა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="84"/>
+        <source>Checking for updates</source>
+        <translation>განახლებების შემოწმება</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="100"/>
+        <source>Hide</source>
+        <translation>დამალვა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="164"/>
+        <location filename="mainwindow.ui" line="980"/>
+        <source>Report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="304"/>
+        <source>Filter</source>
+        <translation>ფილტრი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="370"/>
+        <source>&amp;Reanalyze modified files</source>
+        <oldsource>&amp;Recheck modified files</oldsource>
+        <translation>ყველა შეცვლილი ფაილის თავიდან ანალი&amp;ზი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="382"/>
+        <source>Reanal&amp;yze all files</source>
+        <translation>&amp;ყველა ფაილის თავიდან ანალიზი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="420"/>
+        <source>Ctrl+Q</source>
+        <translation>Ctrl+Q</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="450"/>
+        <source>Style war&amp;nings</source>
+        <translation>ს&amp;ტილის გაფრთხილებები</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="468"/>
+        <source>E&amp;rrors</source>
+        <translation>&amp;შეცდომები</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="484"/>
+        <source>&amp;Uncheck all</source>
+        <translation>ყველას ჩამოყ&amp;რა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="489"/>
+        <source>Collapse &amp;all</source>
+        <translation>ყველას ჩაკეცვ&amp;ა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="494"/>
+        <source>&amp;Expand all</source>
+        <translation>&amp;ყველას ამოკეცვა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="502"/>
+        <source>&amp;Standard</source>
+        <translation>&amp;სტანდარტული</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="505"/>
+        <source>Standard items</source>
+        <translation>სტანდარტული ელემენტები</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="521"/>
+        <source>Toolbar</source>
+        <translation>ხელსაწყოთა ზოლი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="529"/>
+        <source>&amp;Categories</source>
+        <translation>&amp;კატეგორიები</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="532"/>
+        <source>Error categories</source>
+        <translation>შეცდომის კატეგორიები</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="537"/>
+        <source>&amp;Open XML...</source>
+        <translation>&amp;XML-ის გახსნა...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="546"/>
+        <source>Open P&amp;roject File...</source>
+        <translation>პ&amp;პროექტის ფაილის გახსნა...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="549"/>
+        <source>Ctrl+Shift+O</source>
+        <translation>Ctrl+Shift+O</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="558"/>
+        <source>Sh&amp;ow Scratchpad...</source>
+        <translation>ბლ&amp;ოკნოტის ჩვენება...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="563"/>
+        <source>&amp;New Project File...</source>
+        <translation>&amp;ახალი პროექტის ფაილი...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="566"/>
+        <source>Ctrl+Shift+N</source>
+        <translation>Ctrl+Shift+N</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="571"/>
+        <source>&amp;Log View</source>
+        <translation>ჟურნა&amp;ლის ხედი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="574"/>
+        <source>Log View</source>
+        <translation>ჟურნალის ხედი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="582"/>
+        <source>C&amp;lose Project File</source>
+        <translation>პროექტის ფაი&amp;ლის დახურვა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="590"/>
+        <source>&amp;Edit Project File...</source>
+        <translation>პროექტის ფაილის ჩასწორ&amp;ება...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="602"/>
+        <source>&amp;Statistics</source>
+        <translation>&amp;სტატისტიკა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="614"/>
+        <source>&amp;Warnings</source>
+        <translation>&amp;გაფრთხილებები</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="632"/>
+        <source>Per&amp;formance warnings</source>
+        <translation>წარმატების გა&amp;ფრთხილებები</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="658"/>
+        <source>&amp;Information</source>
+        <translation>&amp;ინფორმაცია</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="673"/>
+        <source>&amp;Portability</source>
+        <translation>&amp;გადატანადობა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="773"/>
+        <source>P&amp;latforms</source>
+        <translation>პ&amp;ლატფორმები</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="787"/>
+        <source>C++&amp;11</source>
+        <translation>C++&amp;11</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="798"/>
+        <source>C&amp;99</source>
+        <translation>C&amp;99</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="806"/>
+        <source>&amp;Posix</source>
+        <translation>&amp;Posix</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="814"/>
+        <source>C&amp;11</source>
+        <translation>C&amp;11</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="846"/>
+        <source>&amp;C89</source>
+        <translation>&amp;C89</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="854"/>
+        <source>&amp;C++03</source>
+        <translation>&amp;C++03</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="875"/>
+        <source>&amp;Library Editor...</source>
+        <translation>ბიბ&amp;ლიოთეკის რედაქტორი...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="886"/>
+        <source>&amp;Auto-detect language</source>
+        <translation>ენის &amp;ავტოდადგენა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="894"/>
+        <source>&amp;Enforce C++</source>
+        <translation>ძ&amp;ალით C++</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="902"/>
+        <source>E&amp;nforce C</source>
+        <translation>ძა&amp;ლით C</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="913"/>
+        <source>C++14</source>
+        <translation>C++14</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="921"/>
+        <source>Reanalyze and check library</source>
+        <translation>ბიბლიოთეკის თავიდან ანალიზი და შემოწმება</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="929"/>
+        <source>Check configuration (defines, includes)</source>
+        <translation>კონფიგურაციის შემოწმება (defines, includes)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="937"/>
+        <source>C++17</source>
+        <translation>C++17</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="948"/>
+        <source>C++20</source>
+        <translation>C++20</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="975"/>
+        <source>Compliance report...</source>
+        <translation>შესაბამისობის ანგარიში...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="988"/>
+        <source>Normal</source>
+        <translation type="unfinished">ნორმალური</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="996"/>
+        <source>Misra C</source>
+        <translation type="unfinished">Misra C</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1004"/>
+        <source>Misra C++ 2008</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1012"/>
+        <source>Cert C</source>
+        <translation type="unfinished">Cert C</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1020"/>
+        <source>Cert C++</source>
+        <translation type="unfinished">Cert C++</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1028"/>
+        <source>Misra C++ 2023</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1036"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1041"/>
+        <source>EULA...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1046"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1049"/>
+        <source>Show thread details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="510"/>
+        <source>&amp;Contents</source>
+        <translation>&amp;შემცველობა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="285"/>
+        <source>Categories</source>
+        <translation>კატეგორიები</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="453"/>
+        <location filename="mainwindow.ui" line="456"/>
+        <source>Show style warnings</source>
+        <translation>სტილის გაფრთხილების ჩვენება</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="513"/>
+        <source>Open the help contents</source>
+        <translation>დახმარების შემცველობის გახსნა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="516"/>
+        <source>F1</source>
+        <translation>F1</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="199"/>
+        <source>&amp;Help</source>
+        <translation>&amp;დახმარება</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="157"/>
+        <location filename="mainwindow.cpp" line="1782"/>
+        <source>Quick Filter:</source>
+        <translation>სწრაფი ფილტრი:</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="831"/>
+        <source>Select configuration</source>
+        <translation>აირჩიეთ კონფიგურაცია</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="861"/>
+        <source>Found project file: %1
+
+Do you want to load this project file instead?</source>
+        <translation>ვიპოვე პროექტის ფაილი: %1
+
+გნებავთ, სამაგიეროდ, ეს პროექტის ფაილი ჩატვირთოთ?</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="995"/>
+        <source>File not found</source>
+        <translation>ფაილი ნაპოვნი არაა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="998"/>
+        <source>Bad XML</source>
+        <translation>არასწორი XML</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1001"/>
+        <source>Missing attribute</source>
+        <translation>აკლია ატრიბუტი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1004"/>
+        <source>Bad attribute value</source>
+        <translation>არასწორი ატრიბუტის მნიშვნელობა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1007"/>
+        <source>Unsupported format</source>
+        <translation>მხარდაუჭერელი ფორმატი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1016"/>
+        <source>Duplicate define</source>
+        <translation>გამეორებული აღწერა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1024"/>
+        <source>Failed to load the selected library &apos;%1&apos;.
+%2</source>
+        <translation>ჩავარდა ჩატვირთვა მონიშნული ბიბლიოთეკისთვის &apos;%1&apos;.
+%2</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1035"/>
+        <source>File not found: &apos;%1&apos;</source>
+        <translation>ფაილი ვერ ვიპოვე: &apos;%1&apos;</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1058"/>
+        <source>Failed to load/setup addon %1: %2</source>
+        <translation>დამატების (%1) ჩატვირთვა/მორგება ჩავარდა: %2</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <source>Failed to load %1 - %2
+
+Analysis is aborted.</source>
+        <translation>%1-ის ჩატვირთვა ჩავარდა - %2
+
+ანალიზი შეწყდა.</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
+        <source>%1
+
+Analysis is aborted.</source>
+        <translation>%1
+
+ანალიზი შეწყვეტილია.</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1648"/>
+        <source>License</source>
+        <translation>ლიცენზია</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1655"/>
+        <source>Authors</source>
+        <translation>ავტორები</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1675"/>
+        <source>Save the report file</source>
+        <translation>ანგარიშის ფაილში ჩაწერა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1483"/>
+        <location filename="mainwindow.cpp" line="1682"/>
+        <source>XML files (*.xml)</source>
+        <translation>XML ფაილები (*.xml)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="461"/>
+        <source>There was a problem with loading the editor application settings.
+
+This is probably because the settings were changed between the Cppcheck versions. Please check (and fix) the editor application settings, otherwise the editor program might not start correctly.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="756"/>
+        <source>You must close the project file before selecting new files or directories!</source>
+        <translation>ახალი ფაილების ან საქაღალდეების არჩევამდე პრორექტის ფაილი უნდა დახუროთ!</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="986"/>
+        <source>The library &apos;%1&apos; contains unknown elements:
+%2</source>
+        <translation>ბიბლიოთეკა &apos;%1&apos; უცნობ ელემენტებს შეიცავს:
+%2</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1010"/>
+        <source>Duplicate platform type</source>
+        <translation>გამეორებული პლატფორმის ტიპი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1013"/>
+        <source>Platform type redefined</source>
+        <translation>პლატფორმის ტიპი თავდან აღიწერა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1019"/>
+        <source>Unknown element</source>
+        <translation>უცნობი ელემენტი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1019"/>
+        <source>Unknown element</source>
+        <oldsource>Unknown issue</oldsource>
+        <translation type="unfinished">უცნობი პრობლემა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
+        <source>Error</source>
+        <translation>შეცდომა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1485"/>
+        <source>Open the report file</source>
+        <translation>ანგარიშის ფაილის გახსნა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1686"/>
+        <source>Text files (*.txt)</source>
+        <translation>ტექსტური ფაილები (*.txt)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1690"/>
+        <source>CSV files (*.csv)</source>
+        <translation>CSV ფაილები (*.csv)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1820"/>
+        <source>Project files (*.cppcheck);;All files(*.*)</source>
+        <translation>პროექტის ფაილები (*.cppcheck);;ყველა ფაილი(*.*)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1822"/>
+        <source>Select Project File</source>
+        <translation>აირჩიეთ პროექტის ფაილი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="242"/>
+        <location filename="mainwindow.cpp" line="1784"/>
+        <location filename="mainwindow.cpp" line="1850"/>
+        <location filename="mainwindow.cpp" line="2048"/>
+        <source>Project:</source>
+        <translation>პროექტი:</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="671"/>
+        <source>No suitable files found to analyze!</source>
+        <translation>ანალიზისათვის შესაფერისი ფაილები აღმოჩენილი არაა!</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="770"/>
+        <source>C/C++ Source</source>
+        <translation>C/C++ საწყისი კოდი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="771"/>
+        <source>Compile database</source>
+        <translation>მონაცემთა ბაზის კომპილაცია</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="772"/>
+        <source>Visual Studio</source>
+        <translation>Visual Studio</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="773"/>
+        <source>Borland C++ Builder 6</source>
+        <translation>Borland C++ Builder 6</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="776"/>
+        <source>Select files to analyze</source>
+        <translation>აირჩეთ ფაილები ანალიზისთვის</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="791"/>
+        <source>Select directory to analyze</source>
+        <translation>აირჩიეთ საქაღალდე ანალიზისთვის</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="831"/>
+        <source>Select the configuration that will be analyzed</source>
+        <translation>აირჩიეთ კონფიგურაცია ანალიზისთვის</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="883"/>
+        <source>Found project files from the directory.
+
+Do you want to proceed analysis without using any of these project files?</source>
+        <translation>აღმოჩენილია პროექტის ფაილები საქაღალდიდან.
+
+გნებავთ, გააგრძელოთ ანალიზი ამ პროექტის ფაილების გამოყენების გარეშე?</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1468"/>
+        <source>Current results will be cleared.
+
+Opening a new XML file will clear current results.
+Do you want to proceed?</source>
+        <translation>მიმდინარე შედეგები გასუფთავდება.
+
+ახალი XML ფაილის გახსნა მიმდინარე შედეგებს გაასუფთავებს.
+გნებავთ, გააგრძელოთ?</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1592"/>
+        <source>Analyzer is running.
+
+Do you want to stop the analysis and exit Cppcheck?</source>
+        <translation>ანალიზატორი გაშვებულია.
+
+გნებავთ, გააჩეროთ ანალიზი და გახვიდეთ Cppcheck-დან?</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1634"/>
+        <source>About</source>
+        <translation>შესახებ</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1673"/>
+        <source>XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
+        <translation>XML ფაილები (*.xml);;ტექსტური ფაილები (*.txt);;CSV ფაილები (*.csv)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1713"/>
+        <source>Cannot generate a compliance report right now, an analysis must finish successfully. Try to reanalyze the code and ensure there are no critical errors.</source>
+        <translation>შესაბამისობის ანგარიშის გენერაცია ახლა შეუძლებელია, რადგან ჯერ ანალიზი წარმატებით უნდა დასრულდეს. სცადეთ, კოდის ანალიზი თავიდან გაუშვათ და დარწმუნდეთ, რომ კრიტიკული შეცდომები არ არსებობს.</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1938"/>
+        <source>Build dir &apos;%1&apos; does not exist, create it?</source>
+        <translation>აგების საქაღალდე (%1) არ არსებობს. შევქმნა?</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1946"/>
+        <source>To check the project using addons, you need a build directory.</source>
+        <translation>პროექტის დამატებებით შესამოწმებლად აგების საქაღალდე გჭირდებათ.</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1978"/>
+        <source>Failed to open file</source>
+        <translation>ფაილის გახსნის შეცდომა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1981"/>
+        <source>Unknown project file format</source>
+        <translation>უცნობი პროექტის ფაილის ფორმატი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1984"/>
+        <source>Failed to import project file</source>
+        <translation>პროექტის ფაილის შემოტანა ჩავარდა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2000"/>
+        <source>Failed to import &apos;%1&apos;: %2
+
+Analysis is stopped.</source>
+        <translation>&apos;%1&apos;-ის შემოტანა ჩავარდა: %2
+
+ანალიზი შეწყდა.</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2009"/>
+        <source>Failed to import &apos;%1&apos; (%2), analysis is stopped</source>
+        <translation>&apos;%1&apos;-ის (%2) შემოტანა ჩავარდა. ანალიზი შეწყდა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2033"/>
+        <source>Project files (*.cppcheck)</source>
+        <translation>პროექტის ფაილები (*.cppcheck)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2035"/>
+        <source>Select Project Filename</source>
+        <translation>აირჩიეთ პროექტის ფაილის სახელი</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2081"/>
+        <source>No project file loaded</source>
+        <translation>პროექტის ფაილი ჩატვირთული არაა</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2163"/>
+        <source>The project file
+
+%1
+
+ could not be found!
+
+Do you want to remove the file from the recently used projects -list?</source>
+        <translation>პროექტის ფაილი
+
+%1
+
+ვერ ვიპოვე!
+
+გნებავთ წაშალოთ ეს ფაილი ახლახან გამოყენებული პროექტების სიიდან?</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2325"/>
+        <source>Install</source>
+        <translation>დაყენება</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2329"/>
+        <source>New version available: %1. %2</source>
+        <translation>ხელმისაწვდომია ახალი ვერსია: %1. %2</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2367"/>
+        <source>Show Mandatory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2368"/>
+        <source>Show Required</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2369"/>
+        <source>Show Advisory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2370"/>
+        <source>Show Document</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2387"/>
+        <source>Show L1</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2388"/>
+        <source>Show L2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2389"/>
+        <source>Show L3</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2396"/>
+        <source>Show style</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2397"/>
+        <source>Show portability</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2398"/>
+        <source>Show performance</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2399"/>
+        <source>Show information</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="main.cpp" line="100"/>
+        <source>Cppcheck GUI.
+
+Syntax:
+    cppcheck-gui [OPTIONS] [files or paths]
+
+Options:
+    -h, --help              Print this help
+    -p &lt;file&gt;               Open given project file and start checking it
+    -l &lt;file&gt;               Open given results xml file
+    -d &lt;directory&gt;          Specify the directory that was checked to generate the results xml specified with -l
+    -v, --version           Show program version
+    --data-dir=&lt;directory&gt;  This option is for installation scripts so they can configure the directory where
+                            datafiles are located (translations, cfg). The GUI is not started when this option
+                            is used.</source>
+        <oldsource>Cppcheck GUI.
+
+Syntax:
+    cppcheck-gui [OPTIONS] [files or paths]
+
+Options:
+    -h, --help              Print this help
+    -p &lt;file&gt;               Open given project file and start checking it
+    -l &lt;file&gt;               Open given results xml file
+    -d &lt;directory&gt;          Specify the directory that was checked to generate the results xml specified with -l
+    -v, --version           Show program version
+    --data-dir=&lt;directory&gt;  Specify directory where GUI datafiles are located (translations, cfg)</oldsource>
+        <translation>Cppcheck GUI.
+
+სინტაქსი:
+    cppcheck-gui [პარამეტრები] [ფაილები ან ბილიკები]
+
+პარამეტრები:
+    -h, --help              ამ დახმარების დაბეჭდვა
+    -p &lt;file&gt;               მითითებული პროექტის გახსნა და შემოწმების დაწყება
+    -l &lt;file&gt;               მითითებული შედეგების xml ფაილის გახსნა
+    -d &lt;directory&gt;          მიუთითეთ საქაღალდე, რომელიც შემოწმებული იყო, -l-ით მითითებული xml ფაილის გენერაცისთვის
+    -v, --version           პროგრამის ვერსიის ჩვენება
+    --data-dir=&lt;directory&gt;  ეს პარამეტრი დაყენების სკრიპტებისთვისაა, რომ დააყენონ საქაღალდე, სადაა
+                            მონაცემები (თარგმანები, კონფიგურაცია) მოთავსებული. როცა ეს პარამეტრი მითითებულია, გრაფიკული ინტერფეისი
+                            არ გამოიყენება.</translation>
+    </message>
+    <message>
+        <location filename="main.cpp" line="115"/>
+        <source>Cppcheck GUI - Command line parameters</source>
+        <translation>Cppcheck GUI - ბრძანების სტრიქონის პარამეტრები</translation>
+    </message>
+</context>
+<context>
+    <name>NewSuppressionDialog</name>
+    <message>
+        <location filename="newsuppressiondialog.ui" line="17"/>
+        <source>New suppression</source>
+        <translation>ახალი ჩახშობა</translation>
+    </message>
+    <message>
+        <location filename="newsuppressiondialog.ui" line="25"/>
+        <source>Error ID</source>
+        <translation>შეცდომის ID</translation>
+    </message>
+    <message>
+        <location filename="newsuppressiondialog.ui" line="32"/>
+        <source>File name</source>
+        <translation>ფაილის სახელი</translation>
+    </message>
+    <message>
+        <location filename="newsuppressiondialog.ui" line="42"/>
+        <source>Line number</source>
+        <translation>ხაზის ნომერი</translation>
+    </message>
+    <message>
+        <location filename="newsuppressiondialog.ui" line="52"/>
+        <source>Symbol name</source>
+        <translation>სიმბოლოს სახელი</translation>
+    </message>
+    <message>
+        <location filename="newsuppressiondialog.cpp" line="83"/>
+        <source>Edit suppression</source>
+        <translation>ჩახშობის ჩასწორება</translation>
+    </message>
+</context>
+<context>
+    <name>Platforms</name>
+    <message>
+        <location filename="platforms.cpp" line="38"/>
+        <source>Native</source>
+        <translation>საკუთარი</translation>
+    </message>
+    <message>
+        <location filename="platforms.cpp" line="39"/>
+        <source>Unix 32-bit</source>
+        <translation>Unix 32-bit</translation>
+    </message>
+    <message>
+        <location filename="platforms.cpp" line="40"/>
+        <source>Unix 64-bit</source>
+        <translation>Unix 64-bit</translation>
+    </message>
+    <message>
+        <location filename="platforms.cpp" line="41"/>
+        <source>Windows 32-bit ANSI</source>
+        <translation>Windows 32-bit ANSI</translation>
+    </message>
+    <message>
+        <location filename="platforms.cpp" line="42"/>
+        <source>Windows 32-bit Unicode</source>
+        <translation>Windows 32-bit Unicode</translation>
+    </message>
+    <message>
+        <location filename="platforms.cpp" line="43"/>
+        <source>Windows 64-bit</source>
+        <translation>Windows 64-bit</translation>
+    </message>
+</context>
+<context>
+    <name>ProjectFile</name>
+    <message>
+        <location filename="projectfile.ui" line="14"/>
+        <source>Project File</source>
+        <translation>პროექტის ფაილი</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="24"/>
+        <source>Paths and Defines</source>
+        <translation>ბილიკები და აღწერები</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="30"/>
+        <source>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</source>
+        <oldsource>Import Project (Visual studio / compile database)</oldsource>
+        <translation>პროექტის შემოტანა (Visual studio / მონაცემთა ბაზი კომპილაცია / Borland C++ Builder 6)</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="231"/>
+        <source>Defines must be separated by a semicolon. Example: DEF1;DEF2=5;DEF3=int</source>
+        <oldsource>Defines must be separated by a semicolon &apos;;&apos;</oldsource>
+        <translation>აღწერები წერტილმძიმით უნდა იყოს გამოყოფილი. მაგ: DEF1;DEF2=5;DEF3=int</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="389"/>
+        <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
+        <translation>შენიშვნა: ჩადეთ თქვენი .cfg ფაილები იგივე საქაღალდეში, სადაც პროექტის ფაილია. მათ ზემოთ დაინახავთ.</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="448"/>
+        <source>Clang (experimental)</source>
+        <translation>Clang (ექსპერიმენტული)</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="494"/>
+        <source>If you want to design your classes to be as flexible and robust as possible then the public interface must be very robust. Cppcheck will asumme that arguments can take *any* value.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="519"/>
+        <source>Check code in headers  (should be ON normally. if you want a limited quick analysis then turn this OFF)</source>
+        <translation>თავსართის ფაილებში არსებული კოდის შეწმება  (ნაგულისხმევად, ეს ჩართულია. თუ გნებავთ შეზღუდული სწრაფი ანალიზი, მაშინ გამორთეთ ეს)</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="572"/>
+        <source>Max recursion in template instantiation</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="639"/>
+        <source>Filepaths in warnings will be relative to this path</source>
+        <translation>ფაილის ბილიკები ამ ბილიკის ფარდობითი იქნება</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="655"/>
+        <source>If tags are added, you will be able to right click on warnings and set one of these tags. You can manually categorize warnings.</source>
+        <translation>თუ ჭდეები დამატებულია, შეგიძლიათ, გაფრთხილებებზე მარჯვენა ღილაკით დააწკაპუნოთ და დააყენოთ ერთ-ერთი ჭდე. გაფრთხილებების კატეგორიებად დალაგება ხელით შეგიძლიათ.</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="665"/>
+        <source>Exclude source files</source>
+        <translation>კოდის ფაილების ამოღება</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="676"/>
+        <source>Exclude folder...</source>
+        <translation>საქაღალდის ამოღება...</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="683"/>
+        <source>Exclude file...</source>
+        <translation>ფაილის ამოღება...</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="876"/>
+        <source>MISRA rule texts</source>
+        <translation>MISRA-ის წესის ტექსტები</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="883"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="890"/>
+        <source>...</source>
+        <translation>...</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="73"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;You have a choice:&lt;/p&gt;&lt;p&gt; * Analyze all Debug and Release configurations&lt;/p&gt;&lt;p&gt; * Only analyze the first matching Debug configuration&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="60"/>
+        <location filename="projectfile.ui" line="422"/>
+        <location filename="projectfile.ui" line="616"/>
+        <source>Browse...</source>
+        <translation>ნუსხა...</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="76"/>
+        <source>Analyze all Visual Studio configurations</source>
+        <translation>ყველა Visual Studio-ის კონფიგურაციის ანალიზი</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="113"/>
+        <source>Selected VS Configurations</source>
+        <translation>არჩეული VS-ის კონფიგურაციები</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="147"/>
+        <source>Paths:</source>
+        <translation>ბილიკები:</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="181"/>
+        <location filename="projectfile.ui" line="296"/>
+        <source>Add...</source>
+        <translation>დამატება...</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="188"/>
+        <location filename="projectfile.ui" line="303"/>
+        <location filename="projectfile.ui" line="690"/>
+        <source>Edit</source>
+        <translation>ჩასწორება</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="195"/>
+        <location filename="projectfile.ui" line="310"/>
+        <location filename="projectfile.ui" line="697"/>
+        <location filename="projectfile.ui" line="740"/>
+        <source>Remove</source>
+        <translation>წაშლა</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="242"/>
+        <source>Undefines:</source>
+        <translation>წაშლილი მაკროაღწერები:</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="252"/>
+        <source>Undefines must be separated by a semicolon. Example: UNDEF1;UNDEF2;UNDEF3</source>
+        <translation>წაშლილი მაკროაღწერები წერტილმძიმით უნდა იყოს გამოყოფილი. მაგ: UNDEF1;UNDEF2;UNDEF3</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="265"/>
+        <source>Include Paths:</source>
+        <translation>ჩასმის ბილიკები:</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="362"/>
+        <source>Types and Functions</source>
+        <translation>ტიპები და ფუნქციები</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="403"/>
+        <location filename="projectfile.ui" line="488"/>
+        <source>Analysis</source>
+        <translation>ანალიზი</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="415"/>
+        <source>This is a workfolder that Cppcheck will use for various purposes.</source>
+        <translation>ეს სამუშაო საქაღალდეა, რომელსაც Cppcheck სხვადასხვა მიზნებისთვის გამოიყენებს.</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="432"/>
+        <source>Parser</source>
+        <translation>ანალიზატორი</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="438"/>
+        <source>Cppcheck (built in)</source>
+        <translation>Cppcheck (ჩაშენებული)</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="458"/>
+        <source>Check level</source>
+        <translation>შემოწმების დონე</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="464"/>
+        <source>Reduced -- meant for usage where developer wants results directly. Limited and faster analysis with fewer results.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="471"/>
+        <source>Normal -- meant for normal analysis in CI. Analysis should finish in reasonable time.</source>
+        <translation>ნორმალური -- ნიშნავს ნორმალურ ანალიზს CI-ში. ანალიზი მისაღებ დროში დასრულდება.</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="478"/>
+        <source>Exhaustive -- meant for nightly builds etc. Analysis time can be longer (10x slower than compilation is OK).</source>
+        <translation>ამომწურავი -- განკუთვნილია ღამის აგებებისთვის და ა.შ. ანალიზის დრო, შეიძლება, უფრო მეტიც იყოს (კომპილაციაზე 10x მეტი დრო ჩვეულებრივი ამბავია).</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="497"/>
+        <source>Check that each class has a safe public interface</source>
+        <translation>შემოწმება, აქვს თუ არა ყველა კლასს უსაფრთხო საჯარო ინტერფეისი</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="513"/>
+        <source>Limit analysis</source>
+        <translation>ანალიზის შეზღუდვა</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="529"/>
+        <source>Check code in unused templates (should be ON normally, however in theory you can safely ignore warnings in unused templates)</source>
+        <oldsource>Check code in unused templates  (slower and less accurate analysis)</oldsource>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="541"/>
+        <source>Max CTU depth</source>
+        <translation>CTU-ის მაქსიმალური სიღრმე</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="607"/>
+        <source>Premium License</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="765"/>
+        <source>Enable inline suppressions</source>
+        <translation>შეცდომების ხაზშივე ჩახშობის ჩართვა</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="851"/>
+        <source>2025</source>
+        <translation type="unfinished">2025</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="901"/>
+        <source>Misra C++</source>
+        <translation>Misra C++</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="909"/>
+        <source>2008</source>
+        <translation>2008</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="937"/>
+        <source>Cert C</source>
+        <translation>Cert C</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="946"/>
+        <source>CERT-INT35-C:  int precision (if size equals precision, you can leave empty)</source>
+        <translation>CERT-INT35-C:  მთელი რიცხვის სიზუსტე (თუ ზომა სიზუსტეს ემთხვევა, შეგიძლიათ, ცარიელი დატოვოთ)</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="965"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="972"/>
+        <source>Safety profiles (defined in C++ core guidelines)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="988"/>
+        <source>Bug hunting</source>
+        <translation>შეცდომებზე ნადირობა</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="998"/>
+        <source>External tools</source>
+        <translation>გარე ხელსაწყოები</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="330"/>
+        <source>Up</source>
+        <translation>მაღლა</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="337"/>
+        <source>Down</source>
+        <translation>ქვემოთ</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="368"/>
+        <source>Platform</source>
+        <translation>პლატფორმა</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="627"/>
+        <source>Warning options</source>
+        <translation>გაფრთხილების მორგება</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="633"/>
+        <source>Root path:</source>
+        <translation>Root ბილიკი:</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="649"/>
+        <source>Warning tags (separated by semicolon)</source>
+        <translation>გაფრთხილების ჭდეები (წერტილმძიმით გამოყოფილი)</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="409"/>
+        <source>Cppcheck build dir (whole program analysis, incremental analysis, statistics, etc)</source>
+        <translation>Cppcheck-ის აგების საქაღალდე (მთელი პროგრამის ანალიზი, ინკრემენტული ანალიზი, სტატისტიკა და ა.შ.)</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="380"/>
+        <source>Libraries</source>
+        <translation>ბიბლიოთეკები</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="722"/>
+        <source>Suppressions</source>
+        <translation>ჩახშობები</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="733"/>
+        <source>Add</source>
+        <translation>დამატება</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="786"/>
+        <location filename="projectfile.ui" line="792"/>
+        <source>Addons</source>
+        <translation>დამატებები</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="798"/>
+        <source>Note: Addons require &lt;a href=&quot;https://www.python.org/&quot;&gt;Python&lt;/a&gt; being installed.</source>
+        <translation>შენიშვნა: დამატებას დაყენებული &lt;a href=&quot;https://www.python.org/&quot;&gt;Python&lt;/a&gt; სჭირდება.</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="808"/>
+        <source>Y2038</source>
+        <translation>Y2038</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="815"/>
+        <source>Thread safety</source>
+        <translation>ნაკადების უსაფრთხოება</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="825"/>
+        <source>Coding standards</source>
+        <translation>კოდირების სტანდარტები</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="833"/>
+        <source>Misra C</source>
+        <translation>Misra C</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="841"/>
+        <source>2012</source>
+        <translation>2012</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="846"/>
+        <location filename="projectfile.ui" line="914"/>
+        <source>2023</source>
+        <translation>2023</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="958"/>
+        <source>Cert C++</source>
+        <translation>Cert C++</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="982"/>
+        <source>Bug hunting (Premium)</source>
+        <translation>შეცდომებზე ნადირობა (ფასიანი)</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="1011"/>
+        <source>Clang analyzer</source>
+        <translation>Clang-ის ანალიზატორი</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="1004"/>
+        <source>Clang-tidy</source>
+        <translation>Clang-tidy</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="221"/>
+        <source>Defines:</source>
+        <translation>მაკროაღწრები:</translation>
+    </message>
+</context>
+<context>
+    <name>ProjectFileDialog</name>
+    <message>
+        <location filename="projectfiledialog.cpp" line="138"/>
+        <source>Project file: %1</source>
+        <translation>პროექტის ფაილი: %1</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="590"/>
+        <source>Select Cppcheck build dir</source>
+        <translation>აირჩიეთ Cppcheck-ის აგების საქაღალდე</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="851"/>
+        <source>Select include directory</source>
+        <translation>აირჩიეთ ჩასასმელი საქაღალდე</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="831"/>
+        <source>Select a directory to check</source>
+        <translation>აირჩიეთ შესამოწმებელი საქაღალდე</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="396"/>
+        <source>Note: Open source Cppcheck does not fully implement Misra C 2012</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="461"/>
+        <source>Clang-tidy (not found)</source>
+        <translation>Clang-tidy (ვერ ვიპოვე)</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="629"/>
+        <source>Visual Studio</source>
+        <translation>Visual Studio</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="630"/>
+        <source>Compile database</source>
+        <translation>მონაცემთა ბაზის კომპილაცია</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="631"/>
+        <source>Borland C++ Builder 6</source>
+        <translation>Borland C++ Builder 6</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="632"/>
+        <source>Import Project</source>
+        <translation>პროექტის შემოტანა</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="871"/>
+        <source>Select directory to ignore</source>
+        <translation>აირჩიეთ გამოსატოვებელი საქაღალდე</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="879"/>
+        <source>Source files</source>
+        <translation>კოდის ფაილები</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="880"/>
+        <source>All files</source>
+        <translation>ყველა ფაილი</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="881"/>
+        <source>Exclude file</source>
+        <translation>ფაილის ამოღება</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="964"/>
+        <source>Select MISRA rule texts file</source>
+        <translation>აირჩიეთ MISRA-ის წესების ტექსტის ფაილი</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="966"/>
+        <source>MISRA rule texts file (%1)</source>
+        <translation>MISRA-ის წესის ტექსტების ფაილი (%1)</translation>
+    </message>
+</context>
+<context>
+    <name>QObject</name>
+    <message>
+        <location filename="translationhandler.cpp" line="91"/>
+        <source>Unknown language specified!</source>
+        <translation>მითითებული ენა უცნობია!</translation>
+    </message>
+    <message>
+        <location filename="translationhandler.cpp" line="117"/>
+        <source>Language file %1 not found!</source>
+        <oldsource>Language file %1.qm not found!</oldsource>
+        <translation>ენის ფაილი %1 ვერ ვიპოვე!</translation>
+    </message>
+    <message>
+        <location filename="translationhandler.cpp" line="122"/>
+        <source>Failed to load translation for language %1 from file %2</source>
+        <oldsource>Failed to load translation for language %1 from file %2.qm</oldsource>
+        <translation>ჩავარდა თარგმანის ჩატვირთვა ენისთვის %1 ფაილიდან %2</translation>
+    </message>
+    <message>
+        <location filename="cppchecklibrarydata.cpp" line="38"/>
+        <source>line %1: Unhandled element %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="cppchecklibrarydata.cpp" line="43"/>
+        <source>line %1: Mandatory attribute &apos;%2&apos; missing in &apos;%3&apos;</source>
+        <translation>ხაზი %1: აუცილებელი ატრიბუტი &apos;%2&apos; &apos;%3&apos;-ში აღმოჩენილი არაა</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="284"/>
+        <source> (Not found)</source>
+        <translation> (ვერ ვიპოვე)</translation>
+    </message>
+    <message>
+        <location filename="codeeditstylecontrols.cpp" line="76"/>
+        <source>Thin</source>
+        <translation>თხელი</translation>
+    </message>
+    <message>
+        <location filename="codeeditstylecontrols.cpp" line="78"/>
+        <source>ExtraLight</source>
+        <translation>ძალიან მსუბუქი</translation>
+    </message>
+    <message>
+        <location filename="codeeditstylecontrols.cpp" line="80"/>
+        <source>Light</source>
+        <translation>ღია</translation>
+    </message>
+    <message>
+        <location filename="codeeditstylecontrols.cpp" line="82"/>
+        <source>Normal</source>
+        <translation>ნორმალური</translation>
+    </message>
+    <message>
+        <location filename="codeeditstylecontrols.cpp" line="84"/>
+        <source>Medium</source>
+        <translation>საშუალო</translation>
+    </message>
+    <message>
+        <location filename="codeeditstylecontrols.cpp" line="86"/>
+        <source>DemiBold</source>
+        <translation>საშუალოდ სქელი</translation>
+    </message>
+    <message>
+        <location filename="codeeditstylecontrols.cpp" line="88"/>
+        <source>Bold</source>
+        <translation>გასქელება</translation>
+    </message>
+    <message>
+        <location filename="codeeditstylecontrols.cpp" line="90"/>
+        <source>ExtraBold</source>
+        <translation>ძალიან სქელი</translation>
+    </message>
+    <message>
+        <location filename="codeeditstylecontrols.cpp" line="92"/>
+        <source>Black</source>
+        <translation>შავი</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="80"/>
+        <source>Editor Foreground Color</source>
+        <translation>რედაქტორის წინა პლანის ფერი</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="83"/>
+        <source>Editor Background Color</source>
+        <translation>რედაქტორის ფონის ფერი</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="86"/>
+        <source>Highlight Background Color</source>
+        <translation>ფონის ფერის გაოკვეთა</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="89"/>
+        <source>Line Number Foreground Color</source>
+        <translation>ხაზის ნომრის წინა პლანის ფერი</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="92"/>
+        <source>Line Number Background Color</source>
+        <translation>ხაზის ნომრის ფონის ფერი</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="95"/>
+        <source>Keyword Foreground Color</source>
+        <translation>საკვანძო სიტყვის წინა პლანის ფერი</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="98"/>
+        <source>Keyword Font Weight</source>
+        <translation>საკვანძო სიტყვის ფონტის სიმძიმე</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="101"/>
+        <source>Class Foreground Color</source>
+        <oldsource>Class ForegroundColor</oldsource>
+        <translation>კლასის წინა პლანის ფერი</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="104"/>
+        <source>Class Font Weight</source>
+        <translation>კლასის ფონტის სიმძიმე</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="107"/>
+        <source>Quote Foreground Color</source>
+        <translation>ციტატის წინა პლანის ფერი</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="110"/>
+        <source>Quote Font Weight</source>
+        <translation>ციტატის ფონტის სიმძიმე</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="113"/>
+        <source>Comment Foreground Color</source>
+        <translation>კომენტარის წინა პლანს ფერი</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="116"/>
+        <source>Comment Font Weight</source>
+        <translation>კომენტარის ფონტის სიმძიმე</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="119"/>
+        <source>Symbol Foreground Color</source>
+        <translation>სიმბოლოს წინა პლანის ფერი</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="122"/>
+        <source>Symbol Background Color</source>
+        <translation>სიმბოლოს ფონის ფერი</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="125"/>
+        <source>Symbol Font Weight</source>
+        <translation>სიმბოლოს ფონტის სიმძიმე</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="141"/>
+        <source>Set to Default Light</source>
+        <translation>ნაგულისხმევად ღიას დაყენება</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="143"/>
+        <source>Set to Default Dark</source>
+        <translation>ნაგულისხმევად მუქის დაყენება</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="113"/>
+        <source>File</source>
+        <translation type="unfinished">ფაილი</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="114"/>
+        <source>Line</source>
+        <translation type="unfinished">ხაზი</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="115"/>
+        <source>Severity</source>
+        <translation type="unfinished">სიმძიმე</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="116"/>
+        <source>Classification</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="117"/>
+        <source>Level</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="118"/>
+        <source>Inconclusive</source>
+        <translation type="unfinished">არადამაჯერებელი</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="119"/>
+        <source>Summary</source>
+        <translation type="unfinished">შეჯამება</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="120"/>
+        <source>Id</source>
+        <translation type="unfinished">Id</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="121"/>
+        <source>Guideline</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="122"/>
+        <source>Rule</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="123"/>
+        <source>Since date</source>
+        <translation type="unfinished">თარიღიდან</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="124"/>
+        <source>Tags</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="125"/>
+        <source>CWE</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
+<context>
+    <name>QPlatformTheme</name>
+    <message>
+        <location filename="translationhandler.cpp" line="41"/>
+        <source>OK</source>
+        <translation>დიახ</translation>
+    </message>
+    <message>
+        <location filename="translationhandler.cpp" line="42"/>
+        <source>Cancel</source>
+        <translation>შეწყვეტა</translation>
+    </message>
+    <message>
+        <location filename="translationhandler.cpp" line="43"/>
+        <source>Close</source>
+        <translation>დახურვა</translation>
+    </message>
+    <message>
+        <location filename="translationhandler.cpp" line="44"/>
+        <source>Save</source>
+        <translation>შენახვა</translation>
+    </message>
+</context>
+<context>
+    <name>ResultsTree</name>
+    <message>
+        <source>File</source>
+        <translation type="vanished">ფაილი</translation>
+    </message>
+    <message>
+        <source>Severity</source>
+        <translation type="vanished">სიმძიმე</translation>
+    </message>
+    <message>
+        <source>Line</source>
+        <translation type="vanished">ხაზი</translation>
+    </message>
+    <message>
+        <source>Summary</source>
+        <translation type="vanished">შეჯამება</translation>
+    </message>
+    <message>
+        <source>Undefined file</source>
+        <translation type="vanished">გაურკვეველი ფაილი</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="668"/>
+        <source>Copy</source>
+        <translation>კოპირება</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="836"/>
+        <source>Could not find file:</source>
+        <translation>ვერ ვიპოვე ფაილი:</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="840"/>
+        <source>Please select the folder &apos;%1&apos;</source>
+        <translation>აირჩიეთ საქაღალდე &apos;%1&apos;</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="841"/>
+        <source>Select Directory &apos;%1&apos;</source>
+        <translation>აირჩიეთ საქაღალდე &apos;%1&apos;</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="843"/>
+        <source>Please select the directory where file is located.</source>
+        <translation>აირჩიეთ საქაღალდე, სადაც ფაილია მოთავსებული.</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="373"/>
+        <source>debug</source>
+        <translation>შეცდომების მოძებნა</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="307"/>
+        <source>note</source>
+        <translation>ნოტა</translation>
+    </message>
+    <message>
+        <source>Recheck</source>
+        <translation type="vanished">თავიდან შემოწმება</translation>
+    </message>
+    <message>
+        <source>Hide</source>
+        <translation type="vanished">დამალვა</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="670"/>
+        <source>Hide all with id</source>
+        <translation>დამალვა ყველასი id-ით</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="692"/>
+        <source>Suppress selected id(s)</source>
+        <translation>მონიშნული id(ებ)-ის ჩახშობა</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="671"/>
+        <source>Open containing folder</source>
+        <translation>შემცველი საქაღალდის გახსნა</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="376"/>
+        <source>internal</source>
+        <translation>შიდა</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="667"/>
+        <source>Recheck %1 file(s)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="669"/>
+        <source>Hide %1 result(s)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="712"/>
+        <source>Tag</source>
+        <translation>იარლიყი</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="714"/>
+        <source>No tag</source>
+        <translation>ჭდის გარეშე</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="744"/>
+        <location filename="resultstree.cpp" line="758"/>
+        <source>Cppcheck</source>
+        <translation>Cppcheck</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="745"/>
+        <source>No editor application configured.
+
+Configure the editor application for Cppcheck in preferences/Applications.</source>
+        <oldsource>Configure the text file viewer program in Cppcheck preferences/Applications.</oldsource>
+        <translation>რედაქტორის აპლიკაცია მითითებული არაა.
+
+მიუთითეთ რედაქტორის აპლიკაცია Cppcheck-სთვის მენიუში მორგება/აპლიკაციები.</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="759"/>
+        <source>No default editor application selected.
+
+Please select the default editor application in preferences/Applications.</source>
+        <translation>ნაგულისხმევი რედაქტორის აპლიკაცია არჩეული არაა.
+
+აირჩიეთ ნაგულისხმევი რედაქტორის აპლიკაცია მენიუში მორგება/აპლიკაციები.</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="779"/>
+        <source>Could not find the file!</source>
+        <translation>ფაილი ვერ ვიპოვე!</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="822"/>
+        <source>Could not start %1
+
+Please check the application path and parameters are correct.</source>
+        <translation>%1 ვერ გავუშვი
+
+შეამოწმეთ, სწორია, თუ არა აპლიკაციის ბილიკი და მისი პარამეტრები.</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="844"/>
+        <source>Select Directory</source>
+        <translation>აირჩიეთ საქაღალდე</translation>
+    </message>
+    <message>
+        <source>Id</source>
+        <translation type="vanished">Id</translation>
+    </message>
+    <message>
+        <source>Inconclusive</source>
+        <translation type="vanished">არადამაჯერებელი</translation>
+    </message>
+    <message>
+        <source>Since date</source>
+        <translation type="vanished">თარიღიდან</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="355"/>
+        <source>style</source>
+        <translation>სტილი</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="358"/>
+        <source>error</source>
+        <translation>შეცდომა</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="361"/>
+        <source>warning</source>
+        <translation>გაფრთხილება</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="364"/>
+        <source>performance</source>
+        <translation>წარმადობა</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="367"/>
+        <source>portability</source>
+        <translation>გადატანადობა</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="370"/>
+        <source>information</source>
+        <translation>ინფორმაცია</translation>
+    </message>
+</context>
+<context>
+    <name>ResultsView</name>
+    <message>
+        <location filename="resultsview.cpp" line="255"/>
+        <source>Print Report</source>
+        <translation>ანგარიშის დაბეჭდვა</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="274"/>
+        <source>No errors found, nothing to print.</source>
+        <translation>შეცდომები ვერ ვიპოვე. დასაბეჭდი არაფერია.</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="326"/>
+        <source>%p% (%1 of %2 files checked)</source>
+        <translation>%p% (შემოწმებულია %1 ფაილი %2-დან)</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="361"/>
+        <source>Cppcheck</source>
+        <translation>Cppcheck</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="351"/>
+        <source>No errors found.</source>
+        <translation>შეცდომების გარეშე.</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="358"/>
+        <source>Errors were found, but they are configured to be hidden.
+To toggle what kind of errors are shown, open view menu.</source>
+        <translation>აღმოჩენილია შეცდომები, მაგრამ მითითებულია, რომ ისინი დაიმალოს.
+იმისათვის, რომ გადართოთ, რა სახის შეცდომებია ნაჩვენები, გახსენით მენიუ &apos;ხედი&apos;.</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="421"/>
+        <source>Failed to read the report.</source>
+        <translation>ანგარიშის წაკითხვა ჩავარდა.</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="409"/>
+        <source>XML format version 1 is no longer supported.</source>
+        <translation>XML-ის ფორმატის პირველი ვერსია მხარდაჭერილი აღარაა.</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="460"/>
+        <source>First included by</source>
+        <translation>პირველად ჩასმულია ფაილში</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="465"/>
+        <source>Id</source>
+        <translation>Id</translation>
+    </message>
+    <message>
+        <source>Bug hunting analysis is incomplete</source>
+        <translation type="vanished">შეცდომებზე ნადირობის ანალიზი დაუსრულებელია</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="539"/>
+        <source>Clear Log</source>
+        <translation>ჟურნალის გასუფთავება</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="540"/>
+        <source>Copy this Log entry</source>
+        <translation>ამ ჟურნალის ჩანაწერის კოპირება</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="541"/>
+        <source>Copy complete Log</source>
+        <translation>სრული ჟურნალის კოპირება</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="549"/>
+        <source>Analysis was stopped</source>
+        <translation>ანალიზი გაუქმებულია</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="563"/>
+        <source>There was a critical error with id &apos;%1&apos;</source>
+        <translation>აღმოჩენილია კრიტიკული შეცდომა id-ით &apos;%1&apos;</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="565"/>
+        <source>when checking %1</source>
+        <translation>%1-ის შემოწმებისას</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="567"/>
+        <source>when checking a file</source>
+        <translation>ფაილის შემოწმებისას</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="568"/>
+        <source>Analysis was aborted.</source>
+        <translation>ანალიზი შეწყვეტილია.</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="237"/>
+        <location filename="resultsview.cpp" line="245"/>
+        <source>Failed to save the report.</source>
+        <translation>ანგარიშის შენახვა ჩავარდა.</translation>
+    </message>
+    <message>
+        <location filename="resultsview.ui" line="26"/>
+        <source>Results</source>
+        <translation>შედეგები</translation>
+    </message>
+    <message>
+        <location filename="resultsview.ui" line="60"/>
+        <source>Critical errors</source>
+        <translation>კრიტიკული შეცდომები</translation>
+    </message>
+    <message>
+        <location filename="resultsview.ui" line="92"/>
+        <source>Analysis Log</source>
+        <translation>ანალიზის ჟურნალი</translation>
+    </message>
+    <message>
+        <location filename="resultsview.ui" line="114"/>
+        <source>Warning Details</source>
+        <translation>გაფრთხილების დეტალები</translation>
+    </message>
+</context>
+<context>
+    <name>ScratchPad</name>
+    <message>
+        <location filename="scratchpad.ui" line="14"/>
+        <source>Scratchpad</source>
+        <translation>მონახაზი</translation>
+    </message>
+    <message>
+        <location filename="scratchpad.ui" line="20"/>
+        <source>Copy or write some C/C++ code here:</source>
+        <translation>დააკოპირეთ ან დაწერეთ C/C++ კოდი აქ:</translation>
+    </message>
+    <message>
+        <location filename="scratchpad.ui" line="37"/>
+        <source>Optionally enter a filename (mainly for automatic language detection) and click on &quot;Check&quot;:</source>
+        <translation>შეიყვანეთ არასავალდებულო ფაილის სახელი (ძირითადად ავტომატური ენის დადგენისთვის) და დააწკაპუნეთ ღილაკზე &quot;შემოწმება&quot;:</translation>
+    </message>
+    <message>
+        <location filename="scratchpad.ui" line="71"/>
+        <source>filename</source>
+        <translation>ფაილის სახელი</translation>
+    </message>
+    <message>
+        <location filename="scratchpad.ui" line="78"/>
+        <source>Check</source>
+        <translation>შემოწმება</translation>
+    </message>
+</context>
+<context>
+    <name>Settings</name>
+    <message>
+        <location filename="settings.ui" line="14"/>
+        <source>Preferences</source>
+        <translation>მორგება</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="24"/>
+        <source>General</source>
+        <translation>ზოგადი</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="196"/>
+        <source>Add...</source>
+        <translation>დამატება...</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="41"/>
+        <source>Number of threads: </source>
+        <translation>ნაკადების რაოდენობა: </translation>
+    </message>
+    <message>
+        <source>Ideal count:</source>
+        <translation type="vanished">რეკომენდებული მნიშვნელობა:</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="108"/>
+        <source>Force checking all #ifdef configurations</source>
+        <oldsource>Check all #ifdef configurations</oldsource>
+        <translation>ყველა #ifdef კონფიგურაციის ნაძალადევი შემოწმება</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="115"/>
+        <source>Show full path of files</source>
+        <translation>ფაილების სრული ბილიკის ჩვენება</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="122"/>
+        <source>Show &quot;No errors found&quot; message when no errors found</source>
+        <translation>&quot;შეცდომები ნაპოვნი არაა&quot; შეტყობინების ჩვენება, როცა შეცდომები აღმოჩენილი არა</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="129"/>
+        <source>Display error Id in column &quot;Id&quot;</source>
+        <translation>სვეტში &quot;Id&quot; შეცდომის Id-ის ჩვენება</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="136"/>
+        <source>Enable inline suppressions</source>
+        <translation>შეცდომების ხაზშივე ჩახშობის ჩართვა</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="143"/>
+        <source>Check for inconclusive errors also</source>
+        <translation>ასევე, ნაჩვენები იქნება საკამათო შეცდომებიც</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="150"/>
+        <source>Show statistics on check completion</source>
+        <translation>სტატისტიკის ჩვენება შემოწმების დასრულებისას</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="157"/>
+        <source>Check for updates</source>
+        <translation>განახლებების შემოწმება</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="177"/>
+        <source>Show internal warnings in log</source>
+        <translation>ჟურნალში შიდა გაფრთხილებების ჩვენება</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="288"/>
+        <source>Addons</source>
+        <translation>დამატებები</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="294"/>
+        <source>Python binary (leave this empty to use python in the PATH)</source>
+        <translation>ბილიკი python-ის ინტერპრეტატორამდე. (PATH-ში არსებული python-ის გამოსაყენებლად ცარიელი დატოვეთ)</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="305"/>
+        <location filename="settings.ui" line="346"/>
+        <location filename="settings.ui" line="391"/>
+        <source>...</source>
+        <translation>...</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="324"/>
+        <source>MISRA addon</source>
+        <translation>MISRA-ის დამატება</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="332"/>
+        <source>MISRA rule texts file</source>
+        <translation>MISRA-ის წესის ტექსტების ფაილი</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="339"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="372"/>
+        <source>Clang</source>
+        <translation>Clang</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="378"/>
+        <source>Clang path (leave empty to use system PATH)</source>
+        <translation>ბილიკი Clang-ის ინტერპრეტატორამდე. (PATH-ში არსებულის გამოსაყენებლად ცარიელი დატოვეთ)</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="401"/>
+        <source>Visual Studio headers</source>
+        <translation>Visual Studio-ის თავსართები</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="407"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Paths to Visual Studio headers, separated by semicolon &apos;;&apos;.&lt;/p&gt;&lt;p&gt;You can open a Visual Studio command prompt, write &amp;quot;SET INCLUDE&amp;quot;. Then copy/paste the paths.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="437"/>
+        <source>Code Editor</source>
+        <translation>კოდის რედაქტორი</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="443"/>
+        <source>Code Editor Style</source>
+        <translation>კოდის რედაქტორის სტილი</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="449"/>
+        <source>System Style</source>
+        <translation>სისტემის მიყოლა</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="456"/>
+        <source>Default Light Style</source>
+        <translation>ნაგულისხმევი ღია სტილი</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="463"/>
+        <source>Default Dark Style</source>
+        <translation>ნაგულისხმევი მუქი სტილი</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="472"/>
+        <source>Custom</source>
+        <translation>მომხმარებლის</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="210"/>
+        <source>Remove</source>
+        <translation>წაშლა</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="79"/>
+        <source>Max count:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="185"/>
+        <source>Applications</source>
+        <translation>აპლიკაციები</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="203"/>
+        <location filename="settings.ui" line="479"/>
+        <source>Edit...</source>
+        <translation>რედაქტირება...</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="217"/>
+        <source>Set as default</source>
+        <translation>ნაგულისხმებად დაყენება</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="240"/>
+        <source>Reports</source>
+        <translation>ანგარიში</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="246"/>
+        <source>Save all errors when creating report</source>
+        <translation>ყველა შეცდომის შენახვა ანგარიშის შექმნისას</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="253"/>
+        <source>Save full path to files in reports</source>
+        <translation>ფაილების სრული ბილიკის ჩვენება ანგარიშებში</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="274"/>
+        <source>Language</source>
+        <translation>ენა</translation>
+    </message>
+</context>
+<context>
+    <name>SettingsDialog</name>
+    <message>
+        <source>N/A</source>
+        <translation type="vanished">N/A</translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="232"/>
+        <source>The executable file &quot;%1&quot; is not available</source>
+        <translation>გამშვები ფაილი &quot;%1&quot; ხელმისაწვდომი არაა</translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="243"/>
+        <source>Add a new application</source>
+        <translation>ახალი აპლიკაციის დამატება</translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="273"/>
+        <source>Modify an application</source>
+        <translation>აპლიკაციის შეცვლა</translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="278"/>
+        <source> [Default]</source>
+        <translation> [ნაგულისხმევი]</translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="303"/>
+        <source>[Default]</source>
+        <translation>[ნაგულისხმევი]</translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="358"/>
+        <source>Select python binary</source>
+        <translation>აირჩიეთ python-ის გამშვები ფაილი</translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="365"/>
+        <source>Select MISRA File</source>
+        <translation>აირჩიეთ MISA ფაილი</translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="396"/>
+        <source>Select clang path</source>
+        <translation>აირჩიეთ clang-ის ბილიკი</translation>
+    </message>
+</context>
+<context>
+    <name>StatsDialog</name>
+    <message>
+        <location filename="statsdialog.ui" line="14"/>
+        <location filename="statsdialog.ui" line="248"/>
+        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="230"/>
+        <source>Statistics</source>
+        <translation>სტატისტიკა</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="27"/>
+        <location filename="statsdialog.cpp" line="221"/>
+        <source>Project</source>
+        <translation>პროექტი</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="33"/>
+        <source>Project:</source>
+        <translation>პროექტი:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="53"/>
+        <source>Paths:</source>
+        <translation>ბილიკები:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="85"/>
+        <source>Include paths:</source>
+        <translation>თავსართის ფაილის ბილიკები:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="108"/>
+        <source>Defines:</source>
+        <translation>მაკროაღწრები:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="131"/>
+        <source>Undefines:</source>
+        <translation>წაშლილი მაკროაღწერები:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="165"/>
+        <location filename="statsdialog.cpp" line="226"/>
+        <source>Previous Scan</source>
+        <translation>წინა სკანირება</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="171"/>
+        <source>Path Selected:</source>
+        <translation>არჩეული ბილიკი:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="181"/>
+        <source>Number of Files Scanned:</source>
+        <translation>დასკანერებულია ფაილების რაოდენობა:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="201"/>
+        <source>Scan Duration:</source>
+        <translation>სკანირების ხანგრძლივობა:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="254"/>
+        <source>Errors:</source>
+        <translation>შეცდომები:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="271"/>
+        <source>Warnings:</source>
+        <translation>გაფრთხილებები:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="288"/>
+        <source>Stylistic warnings:</source>
+        <translation>სტილისტური გაფრთხილებები:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="305"/>
+        <source>Portability warnings:</source>
+        <translation>გადატანადობის გაფრთხილებები:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="322"/>
+        <source>Performance issues:</source>
+        <translation>წარმადობის პრობლემები:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="339"/>
+        <source>Information messages:</source>
+        <translation>ინფორმაციის შეტყობინებები:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="356"/>
+        <source>Active checkers:</source>
+        <translation>აქტიური შემმოწმებლები:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="374"/>
+        <source>Checkers</source>
+        <translation>შაში</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="399"/>
+        <source>History</source>
+        <translation>ისტორია</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="405"/>
+        <source>File:</source>
+        <translation>ფაილი:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="443"/>
+        <source>Copy to Clipboard</source>
+        <translation>ბუფერში კოპირება</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="450"/>
+        <source>Pdf Export</source>
+        <translation>PDF-ად გატანა</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="159"/>
+        <source>1 day</source>
+        <translation>1 დღე</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="159"/>
+        <source>%1 days</source>
+        <translation>%1 დღე</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="161"/>
+        <source>1 hour</source>
+        <translation>%1 საათი</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="161"/>
+        <source>%1 hours</source>
+        <translation>%1 საათი</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="163"/>
+        <source>1 minute</source>
+        <translation>%1 წუთი</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="163"/>
+        <source>%1 minutes</source>
+        <translation>%1 წთ</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="165"/>
+        <source>1 second</source>
+        <translation>1 წამი</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="165"/>
+        <source>%1 seconds</source>
+        <translation>%1 წამი</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="169"/>
+        <source>0.%1 seconds</source>
+        <translation>0.%1 წამი</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="171"/>
+        <source> and </source>
+        <translation> და </translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="198"/>
+        <source>Export PDF</source>
+        <translation>PDF-ში გატანა</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="220"/>
+        <source>Project Settings</source>
+        <translation>პროექტის პარამეტრები</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="222"/>
+        <source>Paths</source>
+        <translation>ბილიკები</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="223"/>
+        <source>Include paths</source>
+        <translation>ჩასმის ბილიკები</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="224"/>
+        <source>Defines</source>
+        <translation>აღწერები</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="225"/>
+        <source>Undefines</source>
+        <translation>წაშლილი მაკროაღწერები</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="227"/>
+        <source>Path selected</source>
+        <translation>არჩეული ბილიკი</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="228"/>
+        <source>Number of files scanned</source>
+        <translation>დასკანერებულია ფაილების რაოდენობა</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="229"/>
+        <source>Scan duration</source>
+        <translation>სკანირების ხანგრძლივობა</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="185"/>
+        <location filename="statsdialog.cpp" line="231"/>
+        <source>Errors</source>
+        <translation>შედომები</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="112"/>
+        <source>File: </source>
+        <translation>ფაილი: </translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="112"/>
+        <source>No cppcheck build dir</source>
+        <translation>Cppcheck-ის აგების საქაღალდის გარეშე</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="232"/>
+        <source>Warnings</source>
+        <translation>გაფრთხილებები</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="233"/>
+        <source>Style warnings</source>
+        <translation>სტილის გაფრთხილებები</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="191"/>
+        <location filename="statsdialog.cpp" line="234"/>
+        <source>Portability warnings</source>
+        <translation>გადატანადობის გაფრთხილებები</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="193"/>
+        <location filename="statsdialog.cpp" line="235"/>
+        <source>Performance warnings</source>
+        <translation>წარმადობის გაფრთხილებები</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="195"/>
+        <location filename="statsdialog.cpp" line="236"/>
+        <source>Information messages</source>
+        <translation>საინფორმაციო შეტყობინებები</translation>
+    </message>
+</context>
+<context>
+    <name>ThreadDetails</name>
+    <message>
+        <location filename="threaddetails.ui" line="14"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
+<context>
+    <name>ThreadResult</name>
+    <message>
+        <location filename="threadresult.cpp" line="47"/>
+        <source>%1 of %2 files checked</source>
+        <translation>შემოწმებულია %1 ფაილი %2-დან</translation>
+    </message>
+</context>
+<context>
+    <name>TranslationHandler</name>
+    <message>
+        <location filename="translationhandler.cpp" line="130"/>
+        <source>Failed to change the user interface language:
+
+%1
+
+The user interface language has been reset to English. Open the Preferences-dialog to select any of the available languages.</source>
+        <translation>ჩავარდა მომხმარებლის ინტერფეისის ენის გარდართვა ენაზე:
+
+%1
+
+მომხმარებლის ინტერფეისი ინგლისურზე გადაირთო. გახსენით მორგების დიალოგი, რომ ხელმისაწვდომი ენებიდან სასურველი აირჩიოთ.</translation>
+    </message>
+    <message>
+        <location filename="translationhandler.cpp" line="136"/>
+        <source>Cppcheck</source>
+        <translation>Cppcheck</translation>
+    </message>
+</context>
+<context>
+    <name>TxtReport</name>
+    <message>
+        <location filename="txtreport.cpp" line="74"/>
+        <source>inconclusive</source>
+        <translation>არადამაჯერებელი</translation>
+    </message>
+</context>
+<context>
+    <name>toFilterString</name>
+    <message>
+        <location filename="common.cpp" line="58"/>
+        <source>All supported files (%1)</source>
+        <translation>ყველა მხარდაჭერილი ფაილი (%1)</translation>
+    </message>
+    <message>
+        <location filename="common.cpp" line="63"/>
+        <source>All files (%1)</source>
+        <translation>ყველა ფაილი (%1)</translation>
+    </message>
+</context>
+</TS>
diff --git a/gui/cppcheck_ko.ts b/gui/cppcheck_ko.ts
index 7e6af3586e5..da6bac85bb7 100644
--- a/gui/cppcheck_ko.ts
+++ b/gui/cppcheck_ko.ts
@@ -1,51 +1,57 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE TS>
-<TS version="2.1">
+<TS version="2.1" language="ko_KR">
 <context>
     <name>About</name>
     <message>
+        <location filename="about.ui" line="14"/>
         <source>About Cppcheck</source>
         <translation>Cppcheck 정보</translation>
     </message>
     <message>
+        <location filename="about.ui" line="64"/>
         <source>Version %1</source>
         <translation>버전 %1</translation>
     </message>
     <message>
+        <location filename="about.ui" line="71"/>
         <source>Cppcheck - A tool for static C/C++ code analysis.</source>
         <translation>Cppcheck - 정적 C/C++ 코드 분석 도구.</translation>
     </message>
     <message>
+        <location filename="about.ui" line="91"/>
         <source>This program is licensed under the terms
 of the GNU General Public License version 3</source>
         <translation>이 프로그램은 GNU General Public License version 3을
 준수합니다</translation>
     </message>
     <message>
+        <location filename="about.ui" line="102"/>
         <source>Visit Cppcheck homepage at %1</source>
         <translation>Cppcheck 홈페이지(%1)를 방문해보세요</translation>
     </message>
     <message>
-        <source>Copyright © 2007-2019 Cppcheck team.</source>
+        <location filename="about.ui" line="115"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PCRE&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PicoJSON&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;TinyXML2&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Boost&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <oldsource>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;pcre&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;picojson&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;tinyxml2&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
-&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul&gt;
-&lt;li&gt;tinyxml2&lt;/li&gt;
-&lt;li&gt;picojson&lt;/li&gt;
-&lt;li&gt;pcre&lt;/li&gt;
-&lt;li&gt;qt&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <location filename="about.ui" line="81"/>
+        <source>Copyright © 2007-%1 Cppcheck team.</source>
+        <oldsource>Copyright © 2007-2021 Cppcheck team.</oldsource>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>ApplicationDialog</name>
     <message>
+        <location filename="applicationdialog.ui" line="23"/>
         <source>Add an application</source>
         <translation>응용 프로그램 추가</translation>
     </message>
     <message>
+        <location filename="applicationdialog.ui" line="41"/>
         <source>Here you can add an application that can open error files. Specify a name for the application, the application executable and command line parameters for the application.
 
 The following texts in parameters are replaced with appropriate values when application is executed:
@@ -70,68 +76,171 @@ Kate로 파일을 열고, 해당 행으로 이동하는 예제:
 인자: -l(line) (file)</translation>
     </message>
     <message>
+        <location filename="applicationdialog.ui" line="76"/>
         <source>&amp;Name:</source>
         <translation>이름(&amp;N):</translation>
     </message>
     <message>
+        <location filename="applicationdialog.ui" line="86"/>
         <source>&amp;Executable:</source>
         <translation>실행 파일(&amp;E):</translation>
     </message>
     <message>
+        <location filename="applicationdialog.ui" line="96"/>
         <source>&amp;Parameters:</source>
         <translation>명령행 인자(&amp;P):</translation>
     </message>
     <message>
+        <location filename="applicationdialog.ui" line="138"/>
         <source>Browse</source>
         <translation>찾기</translation>
     </message>
     <message>
+        <location filename="applicationdialog.cpp" line="65"/>
         <source>Executable files (*.exe);;All files(*.*)</source>
         <translation>실행 파일(*.exe);;모든 파일(*.*)</translation>
     </message>
     <message>
+        <location filename="applicationdialog.cpp" line="68"/>
         <source>Select viewer application</source>
         <translation>뷰어 프로그램 선택</translation>
     </message>
     <message>
+        <location filename="applicationdialog.cpp" line="83"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <source>You must specify a name, a path and parameters for the application!</source>
-        <translation type="obsolete">응용 프로그램의 이름, 경로 및 인자를 명시해야 합니다!</translation>
+        <location filename="applicationdialog.cpp" line="84"/>
+        <source>You must specify a name, a path and optionally parameters for the application!</source>
+        <translation type="unfinished"></translation>
     </message>
+</context>
+<context>
+    <name>ComplianceReportDialog</name>
     <message>
-        <source>You must specify a name, a path and optionally parameters for the application!</source>
+        <location filename="compliancereportdialog.ui" line="14"/>
+        <source>Compliance Report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="29"/>
+        <source>Project name</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="22"/>
+        <source>Project version</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="42"/>
+        <source>Coding Standard</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="50"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="55"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="60"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="70"/>
+        <source>List of files with md5 checksums</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="133"/>
+        <source>Compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="135"/>
+        <source>HTML files (*.html)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="176"/>
+        <location filename="compliancereportdialog.cpp" line="239"/>
+        <source>Save compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="177"/>
+        <source>Failed to import &apos;%1&apos; (%2), can not show files in compliance report</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>FileViewDialog</name>
     <message>
+        <location filename="fileviewdialog.cpp" line="53"/>
         <source>Could not find the file: %1</source>
         <translation>파일 찾기 실패: %1</translation>
     </message>
     <message>
+        <location filename="fileviewdialog.cpp" line="57"/>
+        <location filename="fileviewdialog.cpp" line="71"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
+        <location filename="fileviewdialog.cpp" line="67"/>
         <source>Could not read the file: %1</source>
         <translation>파일 읽기 실패: %1</translation>
     </message>
 </context>
+<context>
+    <name>HelpDialog</name>
+    <message>
+        <location filename="helpdialog.ui" line="14"/>
+        <source>Cppcheck GUI help</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="34"/>
+        <source>Contents</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="44"/>
+        <source>Index</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="84"/>
+        <source>Helpfile &apos;%1&apos; was not found</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="86"/>
+        <source>Cppcheck</source>
+        <translation type="unfinished">Cppcheck</translation>
+    </message>
+</context>
 <context>
     <name>LibraryAddFunctionDialog</name>
     <message>
+        <location filename="libraryaddfunctiondialog.ui" line="23"/>
         <source>Add function</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryaddfunctiondialog.ui" line="34"/>
         <source>Function name(s)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryaddfunctiondialog.ui" line="44"/>
         <source>Number of arguments</source>
         <translation type="unfinished"></translation>
     </message>
@@ -139,109 +248,138 @@ Kate로 파일을 열고, 해당 행으로 이동하는 예제:
 <context>
     <name>LibraryDialog</name>
     <message>
+        <location filename="librarydialog.ui" line="14"/>
         <source>Library Editor</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="22"/>
         <source>Open</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="29"/>
         <source>Save</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="62"/>
         <source>Functions</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="111"/>
         <source>Add</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="204"/>
         <source>noreturn</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="212"/>
         <source>False</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="217"/>
         <source>True</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="222"/>
         <source>Unknown</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="232"/>
         <source>return value must be used</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="239"/>
         <source>ignore function in leaks checking</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="246"/>
         <source>Arguments</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="258"/>
         <source>Edit</source>
         <translation type="unfinished">편집</translation>
     </message>
     <message>
+        <location filename="librarydialog.cpp" line="97"/>
+        <location filename="librarydialog.cpp" line="169"/>
         <source>Library files (*.cfg)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.cpp" line="99"/>
         <source>Open library file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="71"/>
         <source>Sort</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="131"/>
         <source>Filter:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="164"/>
         <source>Comments</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.ui" line="36"/>
         <source>Save as</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="librarydialog.cpp" line="110"/>
+        <location filename="librarydialog.cpp" line="122"/>
+        <location filename="librarydialog.cpp" line="159"/>
         <source>Cppcheck</source>
         <translation type="unfinished">Cppcheck</translation>
     </message>
     <message>
-        <source>Can not open file %1.</source>
+        <location filename="librarydialog.cpp" line="172"/>
+        <source>Save the library as</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Can not save file %1.</source>
+        <location filename="librarydialog.cpp" line="123"/>
+        <source>Failed to load %1. %2.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Save the library as</source>
+        <location filename="librarydialog.cpp" line="111"/>
+        <source>Cannot open file %1.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Failed to load %1. %2.</source>
+        <location filename="librarydialog.cpp" line="160"/>
+        <source>Cannot save file %1.</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>LibraryEditArgDialog</name>
     <message>
+        <location filename="libraryeditargdialog.ui" line="14"/>
         <source>Edit argument</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="20"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
 &lt;p&gt;Is bool value allowed? For instance result from comparison or from &apos;!&apos; operator.&lt;/p&gt;
 &lt;p&gt;Typically, set this if the argument is a pointer, size, etc.&lt;/p&gt;
@@ -251,10 +389,12 @@ Kate로 파일을 열고, 해당 행으로 이동하는 예제:
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="28"/>
         <source>Not bool</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="35"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
 &lt;p&gt;Is a null parameter value allowed?&lt;/p&gt;
 &lt;p&gt;Typically this should be used on any pointer parameter that does not allow null.&lt;/p&gt;
@@ -264,388 +404,480 @@ Kate로 파일을 열고, 해당 행으로 이동하는 예제:
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="43"/>
         <source>Not null</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="50"/>
         <source>Not uninit</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="57"/>
         <source>String</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="70"/>
         <source>Format string</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="92"/>
         <source>Min size of buffer</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="101"/>
+        <location filename="libraryeditargdialog.ui" line="203"/>
         <source>Type</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="109"/>
+        <location filename="libraryeditargdialog.ui" line="214"/>
         <source>None</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="114"/>
+        <location filename="libraryeditargdialog.ui" line="219"/>
         <source>argvalue</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="119"/>
+        <location filename="libraryeditargdialog.ui" line="224"/>
         <source>mul</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="124"/>
+        <location filename="libraryeditargdialog.ui" line="229"/>
         <source>strlen</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="132"/>
+        <location filename="libraryeditargdialog.ui" line="237"/>
         <source>Arg</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="159"/>
+        <location filename="libraryeditargdialog.ui" line="264"/>
         <source>Arg2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="194"/>
         <source>and</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="libraryeditargdialog.ui" line="310"/>
         <source>Valid values</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
-    <name>LogView</name>
-    <message>
-        <source>Checking Log</source>
-        <translation type="obsolete">로그 확인</translation>
-    </message>
-    <message>
-        <source>Clear</source>
-        <translation type="obsolete">지우기</translation>
-    </message>
-    <message>
-        <source>Save Log</source>
-        <translation type="obsolete">로그 저장</translation>
-    </message>
-    <message>
-        <source>Text files (*.txt *.log);;All files (*.*)</source>
-        <translation type="obsolete">텍스트 파일 (*.txt *.log);;모든 파일 (*.*)</translation>
-    </message>
+    <name>MainWindow</name>
     <message>
+        <location filename="mainwindow.ui" line="26"/>
+        <location filename="mainwindow.ui" line="688"/>
+        <location filename="mainwindow.cpp" line="466"/>
+        <location filename="mainwindow.cpp" line="670"/>
+        <location filename="mainwindow.cpp" line="755"/>
+        <location filename="mainwindow.cpp" line="860"/>
+        <location filename="mainwindow.cpp" line="882"/>
+        <location filename="mainwindow.cpp" line="1467"/>
+        <location filename="mainwindow.cpp" line="1596"/>
+        <location filename="mainwindow.cpp" line="1937"/>
+        <location filename="mainwindow.cpp" line="1945"/>
+        <location filename="mainwindow.cpp" line="1999"/>
+        <location filename="mainwindow.cpp" line="2008"/>
+        <location filename="mainwindow.cpp" line="2080"/>
+        <location filename="mainwindow.cpp" line="2168"/>
         <source>Cppcheck</source>
-        <translation type="obsolete">Cppcheck</translation>
+        <translation>Cppcheck</translation>
     </message>
     <message>
-        <source>Could not open file for writing: &quot;%1&quot;</source>
-        <translation type="obsolete">기록할 파일 열기 실패: &quot;%1&quot;</translation>
+        <location filename="mainwindow.ui" line="84"/>
+        <source>Checking for updates</source>
+        <translation type="unfinished"></translation>
     </message>
-</context>
-<context>
-    <name>MainWindow</name>
     <message>
-        <source>Cppcheck</source>
-        <translation>Cppcheck</translation>
+        <location filename="mainwindow.ui" line="100"/>
+        <source>Hide</source>
+        <translation type="unfinished">숨기기</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="132"/>
         <source>&amp;File</source>
         <translation>파일(&amp;F)</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="152"/>
         <source>&amp;View</source>
         <translation>보기(&amp;V)</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="156"/>
         <source>&amp;Toolbars</source>
         <translation>도구바(&amp;T)</translation>
     </message>
     <message>
-        <source>&amp;Help</source>
-        <translation>도움말(&amp;H)</translation>
+        <location filename="mainwindow.ui" line="164"/>
+        <location filename="mainwindow.ui" line="980"/>
+        <source>Report</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>&amp;Check</source>
-        <translation type="obsolete">검사(&amp;C)</translation>
+        <location filename="mainwindow.ui" line="199"/>
+        <source>&amp;Help</source>
+        <translation>도움말(&amp;H)</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="254"/>
         <source>&amp;Edit</source>
         <translation>편집(&amp;E)</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="267"/>
         <source>Standard</source>
         <translation>표준 도구</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="285"/>
         <source>Categories</source>
         <translation>분류 도구</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="304"/>
         <source>Filter</source>
         <translation>필터 도구</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="315"/>
         <source>&amp;License...</source>
         <translation>저작권(&amp;L)...</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="320"/>
         <source>A&amp;uthors...</source>
         <translation>제작자(&amp;u)...</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="329"/>
         <source>&amp;About...</source>
         <translation>정보(&amp;A)...</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="334"/>
         <source>&amp;Files...</source>
         <translation>파일(&amp;F)...</translation>
     </message>
     <message>
-        <source>Check files</source>
-        <translation type="obsolete">파일 검사</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.ui" line="343"/>
         <source>Ctrl+F</source>
         <translation>Ctrl+F</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="352"/>
         <source>&amp;Directory...</source>
         <translation>디렉토리(&amp;D)...</translation>
     </message>
     <message>
-        <source>Check directory</source>
-        <translation type="obsolete">디렉토리 검사</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.ui" line="361"/>
         <source>Ctrl+D</source>
         <translation>Ctrl+D</translation>
     </message>
     <message>
-        <source>&amp;Recheck files</source>
-        <translation type="obsolete">파일 재검사(&amp;R)</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.ui" line="373"/>
         <source>Ctrl+R</source>
         <translation>Ctrl+R</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="391"/>
         <source>&amp;Stop</source>
         <translation>중지(&amp;S)</translation>
     </message>
     <message>
-        <source>Stop checking</source>
-        <translation type="obsolete">검사 중지</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.ui" line="400"/>
         <source>Esc</source>
         <translation>Esc</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="409"/>
         <source>&amp;Save results to file...</source>
         <translation>결과를 파일에 저장(&amp;S)...</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="412"/>
         <source>Ctrl+S</source>
         <translation>Ctrl+S</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="417"/>
         <source>&amp;Quit</source>
         <translation>종료(&amp;Q)</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="429"/>
         <source>&amp;Clear results</source>
         <translation>결과 지우기(&amp;C)</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="438"/>
         <source>&amp;Preferences</source>
         <translation>설정(&amp;P)</translation>
     </message>
     <message>
-        <source>Style warnings</source>
-        <translation type="obsolete">스타일 경고</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.ui" line="453"/>
+        <location filename="mainwindow.ui" line="456"/>
         <source>Show style warnings</source>
         <translation>스타일 경고 표시</translation>
     </message>
     <message>
-        <source>Errors</source>
-        <translation type="obsolete">에러</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.ui" line="471"/>
+        <location filename="mainwindow.ui" line="474"/>
+        <location filename="mainwindow.cpp" line="2394"/>
         <source>Show errors</source>
         <translation>애러 표시</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="479"/>
         <source>&amp;Check all</source>
         <translation>전체 선택(&amp;C)</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="484"/>
         <source>&amp;Uncheck all</source>
         <translation>전체 해제(&amp;U)</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="489"/>
         <source>Collapse &amp;all</source>
         <translation>전체 접기(&amp;A)</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="494"/>
         <source>&amp;Expand all</source>
         <translation>전체 펼치기(&amp;E)</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="502"/>
         <source>&amp;Standard</source>
         <translation>표준 도구(&amp;S)</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="505"/>
         <source>Standard items</source>
         <translation>표준 아이템</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="510"/>
         <source>&amp;Contents</source>
         <translation>내용(&amp;C)</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="513"/>
         <source>Open the help contents</source>
         <translation>도움말을 엽니다</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="516"/>
         <source>F1</source>
         <translation>F1</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="521"/>
         <source>Toolbar</source>
         <translation>도구바</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="529"/>
         <source>&amp;Categories</source>
         <translation>분류 도구(&amp;C)</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="532"/>
         <source>Error categories</source>
         <translation>에러 종류</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="537"/>
         <source>&amp;Open XML...</source>
         <translation>XML 열기(&amp;O)...</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="546"/>
         <source>Open P&amp;roject File...</source>
         <translation>프로젝트 파일 열기(&amp;R)...</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="563"/>
         <source>&amp;New Project File...</source>
         <translation>새 프로젝트 파일(&amp;N)...</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="571"/>
         <source>&amp;Log View</source>
         <translation>로그 보기(&amp;L)</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="574"/>
         <source>Log View</source>
         <translation>로그 보기</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="582"/>
         <source>C&amp;lose Project File</source>
         <translation>프로젝트 파일 닫기(&amp;L)</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="590"/>
         <source>&amp;Edit Project File...</source>
         <translation>프로젝트 파일 편집(&amp;E)...</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="602"/>
         <source>&amp;Statistics</source>
         <translation>통계 보기(&amp;S)</translation>
     </message>
     <message>
-        <source>Warnings</source>
-        <translation type="obsolete">경고</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.ui" line="617"/>
+        <location filename="mainwindow.ui" line="620"/>
+        <location filename="mainwindow.cpp" line="2395"/>
         <source>Show warnings</source>
         <translation>경고 표시</translation>
     </message>
     <message>
-        <source>Performance warnings</source>
-        <translation type="obsolete">성능 경고</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.ui" line="635"/>
+        <location filename="mainwindow.ui" line="638"/>
         <source>Show performance warnings</source>
         <translation>성능 경고 표시</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="646"/>
         <source>Show &amp;hidden</source>
         <translation>숨기기 보기(&amp;H)</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="975"/>
+        <source>Compliance report...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="988"/>
+        <source>Normal</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="996"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1004"/>
+        <source>Misra C++ 2008</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1012"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1020"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1028"/>
+        <source>Misra C++ 2023</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1036"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1041"/>
+        <source>EULA...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1046"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1049"/>
+        <source>Show thread details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="986"/>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Information</source>
         <translation>정보</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="661"/>
         <source>Show information messages</source>
         <translation>정보 표시</translation>
     </message>
     <message>
-        <source>Portability</source>
-        <translation type="obsolete">이식성 경고</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.ui" line="676"/>
         <source>Show portability warnings</source>
         <translation>이식성 경고 표시</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="714"/>
         <source>&amp;Filter</source>
         <translation>필터 도구(&amp;F)</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="717"/>
         <source>Filter results</source>
         <translation>필터링 결과</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="733"/>
         <source>Windows 32-bit ANSI</source>
         <translation>Windows 32-bit ANSI</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="741"/>
         <source>Windows 32-bit Unicode</source>
         <translation>Windows 32-bit Unicode</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="749"/>
         <source>Unix 32-bit</source>
         <translation>Unix 32-bit</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="757"/>
         <source>Unix 64-bit</source>
         <translation>Unix 64-bit</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="765"/>
         <source>Windows 64-bit</source>
         <translation>Windows 64-bit</translation>
     </message>
     <message>
-        <source>Platforms</source>
-        <translation type="obsolete">플랫폼</translation>
-    </message>
-    <message>
-        <source>C++11</source>
-        <translation type="obsolete">C++11</translation>
-    </message>
-    <message>
-        <source>C99</source>
-        <translation type="obsolete">C99</translation>
-    </message>
-    <message>
-        <source>Posix</source>
-        <translation type="obsolete">Posix</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.cpp" line="157"/>
+        <location filename="mainwindow.cpp" line="1782"/>
         <source>Quick Filter:</source>
         <translation>빠른 필터:</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="461"/>
         <source>There was a problem with loading the editor application settings.
 
 This is probably because the settings were changed between the Cppcheck versions. Please check (and fix) the editor application settings, otherwise the editor program might not start correctly.</source>
@@ -654,18 +886,12 @@ This is probably because the settings were changed between the Cppcheck versions
 Cppcheck 버전간 설정 방법 차이때문인 것으로 보입니다. 편집기 설정을 검사(및 수정)해주세요, 그렇지 않으면 편집기가 제대로 시작하지 않습니다.</translation>
     </message>
     <message>
-        <source>No suitable files found to check!</source>
-        <translation type="obsolete">검사할 수 있는 파일이 없습니다!</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.cpp" line="756"/>
         <source>You must close the project file before selecting new files or directories!</source>
         <translation>새로운 파일이나 디렉토리를 선택하기 전에 프로젝트 파일을 닫으세요!</translation>
     </message>
     <message>
-        <source>Select directory to check</source>
-        <translation type="obsolete">검사할 디렉토리 선택</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.cpp" line="861"/>
         <source>Found project file: %1
 
 Do you want to load this project file instead?</source>
@@ -674,98 +900,215 @@ Do you want to load this project file instead?</source>
 이 프로젝트 파일을 불러오겠습니까?</translation>
     </message>
     <message>
-        <source>Found project files from the directory.
-
-Do you want to proceed checking without using any of these project files?</source>
-        <translation type="obsolete">디렉토리에 프로젝트 파일 존재.
-
-이 프로젝트 파일을 사용하지 않고 검사를 계속하시겠습니까?</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.cpp" line="1483"/>
+        <location filename="mainwindow.cpp" line="1682"/>
         <source>XML files (*.xml)</source>
         <translation>XML 파일 (*.xml)</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1485"/>
         <source>Open the report file</source>
         <translation>보고서 파일 열기</translation>
     </message>
     <message>
-        <source>Checking is running.
-
-Do you want to stop the checking and exit Cppcheck?</source>
-        <translation type="obsolete">검사 중.
-
-검사를 중지하고 Cppcheck을 종료하시겠습니까?</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.cpp" line="1648"/>
         <source>License</source>
         <translation>저작권</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1655"/>
         <source>Authors</source>
         <translation>제작자</translation>
     </message>
     <message>
-        <source>XML files version 2 (*.xml);;XML files version 1 (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
-        <translation type="obsolete">XML 파일 버전 2 (*.xml);;XML 파일 버전 1 (*.xml);;텍스트 파일 (*.txt);;CSV 파일 (*.csv)</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.cpp" line="1675"/>
         <source>Save the report file</source>
         <translation>보고서 파일 저장</translation>
     </message>
     <message>
-        <source>XML files version 1 (*.xml)</source>
-        <translation type="obsolete">XML 파일 버전 1 (*.xml)</translation>
-    </message>
-    <message>
-        <source>XML files version 2 (*.xml)</source>
-        <translation type="obsolete">XML 파일 버전 2 (*.xml)</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.cpp" line="1686"/>
         <source>Text files (*.txt)</source>
         <translation>텍스트 파일 (*.txt)</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1690"/>
         <source>CSV files (*.csv)</source>
         <translation>CSV 파일 (*.csv)</translation>
     </message>
     <message>
-        <source>Cppcheck - %1</source>
-        <translation>Cppcheck - %1</translation>
-    </message>
-    <message>
-        <source>Failed to change the user interface language:
-
-%1
-
-The user interface language has been reset to English. Open the Preferences-dialog to select any of the available languages.</source>
-        <translation type="obsolete">언어 변경 실패:
-
-%1
-
-언어가 영어로 초기화 됐습니다. 설정창을 열어서 설정 가능한 언어를 선택하세요.</translation>
+        <location filename="mainwindow.cpp" line="1713"/>
+        <source>Cannot generate a compliance report right now, an analysis must finish successfully. Try to reanalyze the code and ensure there are no critical errors.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1820"/>
         <source>Project files (*.cppcheck);;All files(*.*)</source>
         <translation>프로젝트 파일 (*.cppcheck);;모든 파일(*.*)</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1822"/>
         <source>Select Project File</source>
         <translation>프로젝트 파일 선택</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1978"/>
+        <source>Failed to open file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1981"/>
+        <source>Unknown project file format</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1984"/>
+        <source>Failed to import project file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2000"/>
+        <source>Failed to import &apos;%1&apos;: %2
+
+Analysis is stopped.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2009"/>
+        <source>Failed to import &apos;%1&apos; (%2), analysis is stopped</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2325"/>
+        <source>Install</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2329"/>
+        <source>New version available: %1. %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2367"/>
+        <source>Show Mandatory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2368"/>
+        <source>Show Required</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2369"/>
+        <source>Show Advisory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2370"/>
+        <source>Show Document</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2387"/>
+        <source>Show L1</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2388"/>
+        <source>Show L2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2389"/>
+        <source>Show L3</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2396"/>
+        <source>Show style</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2397"/>
+        <source>Show portability</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2398"/>
+        <source>Show performance</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2399"/>
+        <source>Show information</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="242"/>
+        <location filename="mainwindow.cpp" line="1784"/>
+        <location filename="mainwindow.cpp" line="1850"/>
+        <location filename="mainwindow.cpp" line="2048"/>
         <source>Project:</source>
         <translation>프로젝트:</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1016"/>
+        <source>Duplicate define</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1035"/>
+        <source>File not found: &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1058"/>
+        <source>Failed to load/setup addon %1: %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <source>Failed to load %1 - %2
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
+        <source>%1
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1634"/>
+        <source>About</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1946"/>
+        <source>To check the project using addons, you need a build directory.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2035"/>
         <source>Select Project Filename</source>
         <translation>프로젝트 파일이름 선택</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="2081"/>
         <source>No project file loaded</source>
         <translation>프로젝트 파일 불러오기 실패</translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="2163"/>
         <source>The project file
 
 %1
@@ -782,110 +1125,113 @@ Do you want to remove the file from the recently used projects -list?</source>
 최근 프로젝트 목록에서 파일을 제거하시겠습니까?</translation>
     </message>
     <message>
-        <source>Current results will be cleared.
-
-Opening a new XML file will clear current results.Do you want to proceed?</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <source>Select files to check</source>
-        <translation type="obsolete">검사할 파일 선택</translation>
-    </message>
-    <message>
+        <location filename="main.cpp" line="115"/>
         <source>Cppcheck GUI - Command line parameters</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="214"/>
         <source>C++ standard</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>C11</source>
-        <translation type="obsolete">C11</translation>
-    </message>
-    <message>
-        <source>C89</source>
-        <translation type="obsolete">C89</translation>
-    </message>
-    <message>
-        <source>C++03</source>
-        <translation type="obsolete">C++03</translation>
-    </message>
-    <message>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
         <source>Error</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="995"/>
         <source>File not found</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="998"/>
         <source>Bad XML</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1001"/>
         <source>Missing attribute</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1004"/>
         <source>Bad attribute value</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Failed to load the selected library &apos;%1&apos;.
 %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1007"/>
         <source>Unsupported format</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="986"/>
         <source>The library &apos;%1&apos; contains unknown elements:
 %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1010"/>
         <source>Duplicate platform type</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1013"/>
         <source>Platform type redefined</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="859"/>
         <source>&amp;Print...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="862"/>
         <source>Print the Current Report</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="867"/>
         <source>Print Pre&amp;view...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="870"/>
         <source>Open a Print Preview Dialog for the Current Results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="878"/>
         <source>Open library editor</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1019"/>
         <source>Unknown element</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Unknown issue</source>
+        <location filename="mainwindow.cpp" line="1019"/>
+        <source>Unknown element</source>
+        <oldsource>Unknown issue</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select configuration</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="main.cpp" line="100"/>
         <source>Cppcheck GUI.
 
 Syntax:
@@ -903,670 +1249,1057 @@ Options:
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
+        <location filename="mainwindow.cpp" line="1938"/>
         <source>Build dir &apos;%1&apos; does not exist, create it?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="337"/>
+        <location filename="mainwindow.ui" line="340"/>
         <source>Analyze files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="355"/>
+        <location filename="mainwindow.ui" line="358"/>
         <source>Analyze directory</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="370"/>
         <source>&amp;Reanalyze modified files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="394"/>
+        <location filename="mainwindow.ui" line="397"/>
         <source>Stop analysis</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1673"/>
         <source>XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="671"/>
         <source>No suitable files found to analyze!</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="776"/>
         <source>Select files to analyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="791"/>
         <source>Select directory to analyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select the configuration that will be analyzed</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="883"/>
         <source>Found project files from the directory.
 
 Do you want to proceed analysis without using any of these project files?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.cpp" line="1592"/>
         <source>Analyzer is running.
 
 Do you want to stop the analysis and exit Cppcheck?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="210"/>
         <source>A&amp;nalyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="226"/>
         <source>&amp;C standard</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="382"/>
         <source>Reanal&amp;yze all files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="420"/>
+        <source>Ctrl+Q</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="450"/>
         <source>Style war&amp;nings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="468"/>
         <source>E&amp;rrors</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="549"/>
+        <source>Ctrl+Shift+O</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="558"/>
         <source>Sh&amp;ow Scratchpad...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="566"/>
+        <source>Ctrl+Shift+N</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="614"/>
         <source>&amp;Warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="632"/>
         <source>Per&amp;formance warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="658"/>
         <source>&amp;Information</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="673"/>
         <source>&amp;Portability</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="691"/>
         <source>Show Cppcheck results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="703"/>
         <source>Clang</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="706"/>
         <source>Show Clang results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="773"/>
         <source>P&amp;latforms</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="787"/>
         <source>C++&amp;11</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="798"/>
         <source>C&amp;99</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="806"/>
         <source>&amp;Posix</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="814"/>
         <source>C&amp;11</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="846"/>
         <source>&amp;C89</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="854"/>
         <source>&amp;C++03</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="875"/>
         <source>&amp;Library Editor...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="886"/>
         <source>&amp;Auto-detect language</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="894"/>
         <source>&amp;Enforce C++</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="902"/>
         <source>E&amp;nforce C</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="913"/>
         <source>C++14</source>
         <translation type="unfinished">C++14</translation>
     </message>
     <message>
-        <source>Failed to import &apos;%1&apos;, analysis is stopped</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
+        <location filename="mainwindow.cpp" line="2033"/>
         <source>Project files (*.cppcheck)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="921"/>
         <source>Reanalyze and check library</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="929"/>
         <source>Check configuration (defines, includes)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="937"/>
         <source>C++17</source>
         <translation type="unfinished">C++17</translation>
     </message>
     <message>
+        <location filename="mainwindow.ui" line="948"/>
         <source>C++20</source>
         <translation type="unfinished">C++20</translation>
     </message>
+    <message>
+        <location filename="mainwindow.cpp" line="770"/>
+        <source>C/C++ Source</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="771"/>
+        <source>Compile database</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="772"/>
+        <source>Visual Studio</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="773"/>
+        <source>Borland C++ Builder 6</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1468"/>
+        <source>Current results will be cleared.
+
+Opening a new XML file will clear current results.
+Do you want to proceed?</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>NewSuppressionDialog</name>
     <message>
+        <location filename="newsuppressiondialog.ui" line="17"/>
         <source>New suppression</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="newsuppressiondialog.ui" line="25"/>
         <source>Error ID</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>File name</source>
+        <location filename="newsuppressiondialog.ui" line="32"/>
+        <source>File name</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="newsuppressiondialog.ui" line="42"/>
+        <source>Line number</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="newsuppressiondialog.ui" line="52"/>
+        <source>Symbol name</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="newsuppressiondialog.cpp" line="83"/>
+        <source>Edit suppression</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
+<context>
+    <name>Platforms</name>
+    <message>
+        <location filename="platforms.cpp" line="39"/>
+        <source>Unix 32-bit</source>
+        <translation>Unix 32-bit</translation>
+    </message>
+    <message>
+        <location filename="platforms.cpp" line="40"/>
+        <source>Unix 64-bit</source>
+        <translation>Unix 64-bit</translation>
+    </message>
+    <message>
+        <location filename="platforms.cpp" line="41"/>
+        <source>Windows 32-bit ANSI</source>
+        <translation>Windows 32-bit ANSI</translation>
+    </message>
+    <message>
+        <location filename="platforms.cpp" line="42"/>
+        <source>Windows 32-bit Unicode</source>
+        <translation>Windows 32-bit Unicode</translation>
+    </message>
+    <message>
+        <location filename="platforms.cpp" line="43"/>
+        <source>Windows 64-bit</source>
+        <translation>Windows 64-bit</translation>
+    </message>
+    <message>
+        <location filename="platforms.cpp" line="38"/>
+        <source>Native</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
+<context>
+    <name>ProjectFile</name>
+    <message>
+        <location filename="projectfile.ui" line="14"/>
+        <source>Project File</source>
+        <translation>프로젝트 파일</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="221"/>
+        <source>Defines:</source>
+        <translation>Defines:</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="147"/>
+        <source>Paths:</source>
+        <translation>경로:</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="181"/>
+        <location filename="projectfile.ui" line="296"/>
+        <source>Add...</source>
+        <translation>추가...</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="188"/>
+        <location filename="projectfile.ui" line="303"/>
+        <location filename="projectfile.ui" line="690"/>
+        <source>Edit</source>
+        <translation>편집</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="195"/>
+        <location filename="projectfile.ui" line="310"/>
+        <location filename="projectfile.ui" line="697"/>
+        <location filename="projectfile.ui" line="740"/>
+        <source>Remove</source>
+        <translation>제거</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="330"/>
+        <source>Up</source>
+        <translation>위로</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="337"/>
+        <source>Down</source>
+        <translation>아래로</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="722"/>
+        <source>Suppressions</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="733"/>
+        <source>Add</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="389"/>
+        <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="890"/>
+        <source>...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="265"/>
+        <source>Include Paths:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="24"/>
+        <source>Paths and Defines</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Line number</source>
+        <location filename="projectfile.ui" line="73"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;You have a choice:&lt;/p&gt;&lt;p&gt; * Analyze all Debug and Release configurations&lt;/p&gt;&lt;p&gt; * Only analyze the first matching Debug configuration&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Symbol name</source>
+        <location filename="projectfile.ui" line="76"/>
+        <source>Analyze all Visual Studio configurations</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Edit suppression</source>
+        <location filename="projectfile.ui" line="633"/>
+        <source>Root path:</source>
         <translation type="unfinished"></translation>
     </message>
-</context>
-<context>
-    <name>Platforms</name>
     <message>
-        <source>Unix 32-bit</source>
-        <translation>Unix 32-bit</translation>
+        <location filename="projectfile.ui" line="649"/>
+        <source>Warning tags (separated by semicolon)</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Unix 64-bit</source>
-        <translation>Unix 64-bit</translation>
+        <location filename="projectfile.ui" line="409"/>
+        <source>Cppcheck build dir (whole program analysis, incremental analysis, statistics, etc)</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Windows 32-bit ANSI</source>
-        <translation>Windows 32-bit ANSI</translation>
+        <location filename="projectfile.ui" line="113"/>
+        <source>Selected VS Configurations</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Windows 32-bit Unicode</source>
-        <translation>Windows 32-bit Unicode</translation>
+        <location filename="projectfile.ui" line="362"/>
+        <source>Types and Functions</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Windows 64-bit</source>
-        <translation>Windows 64-bit</translation>
+        <location filename="projectfile.ui" line="380"/>
+        <source>Libraries</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Built-in</source>
-        <translation type="obsolete">내장 방식</translation>
+        <location filename="projectfile.ui" line="432"/>
+        <source>Parser</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Native</source>
+        <location filename="projectfile.ui" line="438"/>
+        <source>Cppcheck (built in)</source>
         <translation type="unfinished"></translation>
     </message>
-</context>
-<context>
-    <name>Project</name>
     <message>
-        <source>Cppcheck</source>
-        <translation type="obsolete">Cppcheck</translation>
+        <location filename="projectfile.ui" line="497"/>
+        <source>Check that each class has a safe public interface</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Could not read the project file.</source>
-        <translation type="obsolete">프로젝트 파일을 읽을 수 없습니다.</translation>
+        <location filename="projectfile.ui" line="513"/>
+        <source>Limit analysis</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Could not write the project file.</source>
-        <translation type="obsolete">프로젝트 파일에 쓸 수 없습니다.</translation>
+        <location filename="projectfile.ui" line="786"/>
+        <location filename="projectfile.ui" line="792"/>
+        <source>Addons</source>
+        <translation type="unfinished"></translation>
     </message>
-</context>
-<context>
-    <name>ProjectFile</name>
     <message>
-        <source>Project File</source>
-        <translation>프로젝트 파일</translation>
+        <location filename="projectfile.ui" line="798"/>
+        <source>Note: Addons require &lt;a href=&quot;https://www.python.org/&quot;&gt;Python&lt;/a&gt; being installed.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Project</source>
-        <translation type="obsolete">프로젝트</translation>
+        <location filename="projectfile.ui" line="808"/>
+        <source>Y2038</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Defines:</source>
-        <translation>Defines:</translation>
+        <location filename="projectfile.ui" line="815"/>
+        <source>Thread safety</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Root:</source>
-        <translation type="obsolete">Root:</translation>
+        <location filename="projectfile.ui" line="825"/>
+        <source>Coding standards</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Paths:</source>
-        <translation>경로:</translation>
+        <location filename="projectfile.ui" line="937"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Add...</source>
-        <translation>추가...</translation>
+        <location filename="projectfile.ui" line="946"/>
+        <source>CERT-INT35-C:  int precision (if size equals precision, you can leave empty)</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Edit</source>
-        <translation>편집</translation>
+        <location filename="projectfile.ui" line="965"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Remove</source>
-        <translation>제거</translation>
+        <location filename="projectfile.ui" line="988"/>
+        <source>Bug hunting</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Includes</source>
-        <translation type="obsolete">Includes</translation>
+        <location filename="projectfile.ui" line="1011"/>
+        <source>Clang analyzer</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Include directories:</source>
-        <translation type="obsolete">Include 디렉토리:</translation>
+        <location filename="projectfile.ui" line="1004"/>
+        <source>Clang-tidy</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Up</source>
-        <translation>위로</translation>
+        <location filename="projectfile.ui" line="60"/>
+        <location filename="projectfile.ui" line="422"/>
+        <location filename="projectfile.ui" line="616"/>
+        <source>Browse...</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Down</source>
-        <translation>아래로</translation>
+        <location filename="projectfile.ui" line="231"/>
+        <source>Defines must be separated by a semicolon. Example: DEF1;DEF2=5;DEF3=int</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Exclude</source>
-        <translation type="obsolete">Exclude</translation>
+        <location filename="projectfile.ui" line="368"/>
+        <source>Platform</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Suppressions</source>
+        <location filename="projectfile.ui" line="415"/>
+        <source>This is a workfolder that Cppcheck will use for various purposes.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Add</source>
+        <location filename="projectfile.ui" line="448"/>
+        <source>Clang (experimental)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
+        <location filename="projectfile.ui" line="458"/>
+        <source>Check level</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>...</source>
+        <location filename="projectfile.ui" line="464"/>
+        <source>Reduced -- meant for usage where developer wants results directly. Limited and faster analysis with fewer results.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Include Paths:</source>
+        <location filename="projectfile.ui" line="471"/>
+        <source>Normal -- meant for normal analysis in CI. Analysis should finish in reasonable time.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Paths and Defines</source>
+        <location filename="projectfile.ui" line="478"/>
+        <source>Exhaustive -- meant for nightly builds etc. Analysis time can be longer (10x slower than compilation is OK).</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;You have a choice:&lt;/p&gt;&lt;p&gt; * Analyze all Debug and Release configurations&lt;/p&gt;&lt;p&gt; * Only analyze the first matching Debug configuration&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <location filename="projectfile.ui" line="494"/>
+        <source>If you want to design your classes to be as flexible and robust as possible then the public interface must be very robust. Cppcheck will asumme that arguments can take *any* value.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Analyze all Visual Studio configurations</source>
+        <location filename="projectfile.ui" line="519"/>
+        <source>Check code in headers  (should be ON normally. if you want a limited quick analysis then turn this OFF)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Root path:</source>
+        <location filename="projectfile.ui" line="572"/>
+        <source>Max recursion in template instantiation</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Warning tags (separated by semicolon)</source>
+        <location filename="projectfile.ui" line="607"/>
+        <source>Premium License</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Cppcheck build dir (whole program analysis, incremental analysis, statistics, etc)</source>
+        <location filename="projectfile.ui" line="627"/>
+        <source>Warning options</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Libraries</source>
+        <location filename="projectfile.ui" line="639"/>
+        <source>Filepaths in warnings will be relative to this path</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Addons</source>
+        <location filename="projectfile.ui" line="655"/>
+        <source>If tags are added, you will be able to right click on warnings and set one of these tags. You can manually categorize warnings.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Y2038</source>
+        <location filename="projectfile.ui" line="665"/>
+        <source>Exclude source files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Thread safety</source>
+        <location filename="projectfile.ui" line="676"/>
+        <source>Exclude folder...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Coding standards</source>
+        <location filename="projectfile.ui" line="683"/>
+        <source>Exclude file...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Cert</source>
-        <translation type="unfinished"></translation>
+        <location filename="projectfile.ui" line="765"/>
+        <source>Enable inline suppressions</source>
+        <translation type="unfinished">Inline suppression 사용</translation>
     </message>
     <message>
-        <source>Clang analyzer</source>
+        <location filename="projectfile.ui" line="833"/>
+        <source>Misra C</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Clang-tidy</source>
+        <location filename="projectfile.ui" line="841"/>
+        <source>2012</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Browse...</source>
+        <location filename="projectfile.ui" line="846"/>
+        <location filename="projectfile.ui" line="914"/>
+        <source>2023</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Defines must be separated by a semicolon. Example: DEF1;DEF2=5;DEF3=int</source>
+        <location filename="projectfile.ui" line="851"/>
+        <source>2025</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Checking</source>
+        <location filename="projectfile.ui" line="876"/>
+        <source>MISRA rule texts</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Platform</source>
+        <location filename="projectfile.ui" line="883"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Warning options</source>
+        <location filename="projectfile.ui" line="901"/>
+        <source>Misra C++</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Addons and tools</source>
+        <location filename="projectfile.ui" line="909"/>
+        <source>2008</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>MISRA C 2012</source>
+        <location filename="projectfile.ui" line="958"/>
+        <source>Cert C++</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Misra rule texts</source>
+        <location filename="projectfile.ui" line="972"/>
+        <source>Safety profiles (defined in C++ core guidelines)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <location filename="projectfile.ui" line="982"/>
+        <source>Bug hunting (Premium)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="998"/>
         <source>External tools</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="30"/>
         <source>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="242"/>
         <source>Undefines:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="252"/>
         <source>Undefines must be separated by a semicolon. Example: UNDEF1;UNDEF2;UNDEF3</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="403"/>
+        <location filename="projectfile.ui" line="488"/>
         <source>Analysis</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Check code in headers  (slower analysis, more results)</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <source>Check code in unused templates  (slower and less accurate analysis)</source>
+        <location filename="projectfile.ui" line="529"/>
+        <source>Check code in unused templates (should be ON normally, however in theory you can safely ignore warnings in unused templates)</source>
+        <oldsource>Check code in unused templates  (slower and less accurate analysis)</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfile.ui" line="541"/>
         <source>Max CTU depth</source>
         <translation type="unfinished"></translation>
     </message>
-    <message>
-        <source>Exclude source files in paths</source>
-        <translation type="unfinished"></translation>
-    </message>
 </context>
 <context>
     <name>ProjectFileDialog</name>
     <message>
+        <location filename="projectfiledialog.cpp" line="138"/>
         <source>Project file: %1</source>
         <translation>프로젝트 파일: %1</translation>
     </message>
     <message>
+        <location filename="projectfiledialog.cpp" line="851"/>
         <source>Select include directory</source>
         <translation>Include 디렉토리 선택</translation>
     </message>
     <message>
+        <location filename="projectfiledialog.cpp" line="831"/>
         <source>Select a directory to check</source>
         <translation>검사할 디렉토리 선택</translation>
     </message>
     <message>
+        <location filename="projectfiledialog.cpp" line="871"/>
         <source>Select directory to ignore</source>
         <translation>무시할 디렉토리 선택</translation>
     </message>
     <message>
+        <location filename="projectfiledialog.cpp" line="590"/>
         <source>Select Cppcheck build dir</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfiledialog.cpp" line="632"/>
         <source>Import Project</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="projectfiledialog.cpp" line="461"/>
         <source>Clang-tidy (not found)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>(no rule texts file)</source>
+        <location filename="projectfiledialog.cpp" line="396"/>
+        <source>Note: Open source Cppcheck does not fully implement Misra C 2012</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Select MISRA rule texts file</source>
+        <location filename="projectfiledialog.cpp" line="879"/>
+        <source>Source files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Misra rule texts file (%1)</source>
+        <location filename="projectfiledialog.cpp" line="880"/>
+        <source>All files</source>
         <translation type="unfinished"></translation>
     </message>
-</context>
-<context>
-    <name>QDialogButtonBox</name>
     <message>
-        <source>OK</source>
+        <location filename="projectfiledialog.cpp" line="881"/>
+        <source>Exclude file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Cancel</source>
+        <location filename="projectfiledialog.cpp" line="964"/>
+        <source>Select MISRA rule texts file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Close</source>
-        <translation type="unfinished">닫기</translation>
+        <location filename="projectfiledialog.cpp" line="966"/>
+        <source>MISRA rule texts file (%1)</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Save</source>
+        <location filename="projectfiledialog.cpp" line="629"/>
+        <source>Visual Studio</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="630"/>
+        <source>Compile database</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="631"/>
+        <source>Borland C++ Builder 6</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>QObject</name>
     <message>
+        <location filename="translationhandler.cpp" line="91"/>
         <source>Unknown language specified!</source>
         <translation>알 수 없는 언어입니다!</translation>
     </message>
     <message>
+        <location filename="translationhandler.cpp" line="117"/>
         <source>Language file %1 not found!</source>
         <translation>언어 파일(%1)이 없습니다!</translation>
     </message>
     <message>
+        <location filename="translationhandler.cpp" line="122"/>
         <source>Failed to load translation for language %1 from file %2</source>
         <translation>파일(%2)로부터 언어(%1) 불러오기 실패</translation>
     </message>
     <message>
+        <location filename="cppchecklibrarydata.cpp" line="38"/>
         <source>line %1: Unhandled element %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="cppchecklibrarydata.cpp" line="43"/>
+        <source>line %1: Mandatory attribute &apos;%2&apos; missing in &apos;%3&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="284"/>
         <source> (Not found)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstylecontrols.cpp" line="76"/>
         <source>Thin</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstylecontrols.cpp" line="78"/>
         <source>ExtraLight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstylecontrols.cpp" line="80"/>
         <source>Light</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstylecontrols.cpp" line="82"/>
         <source>Normal</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstylecontrols.cpp" line="84"/>
         <source>Medium</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstylecontrols.cpp" line="86"/>
         <source>DemiBold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstylecontrols.cpp" line="88"/>
         <source>Bold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstylecontrols.cpp" line="90"/>
         <source>ExtraBold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstylecontrols.cpp" line="92"/>
         <source>Black</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="80"/>
         <source>Editor Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="83"/>
         <source>Editor Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="86"/>
         <source>Highlight Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="89"/>
         <source>Line Number Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="92"/>
         <source>Line Number Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="95"/>
         <source>Keyword Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="98"/>
         <source>Keyword Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Class ForegroundColor</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
+        <location filename="codeeditstyledialog.cpp" line="104"/>
         <source>Class Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="107"/>
         <source>Quote Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="110"/>
         <source>Quote Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="113"/>
         <source>Comment Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="116"/>
         <source>Comment Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="119"/>
         <source>Symbol Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="122"/>
         <source>Symbol Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="125"/>
         <source>Symbol Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="141"/>
         <source>Set to Default Light</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="codeeditstyledialog.cpp" line="143"/>
         <source>Set to Default Dark</source>
         <translation type="unfinished"></translation>
     </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="101"/>
+        <source>Class Foreground Color</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="113"/>
+        <source>File</source>
+        <translation type="unfinished">파일</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="114"/>
+        <source>Line</source>
+        <translation type="unfinished">행</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="115"/>
+        <source>Severity</source>
+        <translation type="unfinished">분류</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="116"/>
+        <source>Classification</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="117"/>
+        <source>Level</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="118"/>
+        <source>Inconclusive</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="119"/>
+        <source>Summary</source>
+        <translation type="unfinished">요약</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="120"/>
+        <source>Id</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="121"/>
+        <source>Guideline</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="122"/>
+        <source>Rule</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="123"/>
+        <source>Since date</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="124"/>
+        <source>Tags</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="125"/>
+        <source>CWE</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>QPlatformTheme</name>
     <message>
+        <location filename="translationhandler.cpp" line="41"/>
         <source>OK</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="translationhandler.cpp" line="42"/>
         <source>Cancel</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="translationhandler.cpp" line="43"/>
         <source>Close</source>
         <translation type="unfinished">닫기</translation>
     </message>
     <message>
+        <location filename="translationhandler.cpp" line="44"/>
         <source>Save</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1575,77 +2308,76 @@ Do you want to stop the analysis and exit Cppcheck?</source>
     <name>ResultsTree</name>
     <message>
         <source>File</source>
-        <translation>파일</translation>
+        <translation type="vanished">파일</translation>
     </message>
     <message>
         <source>Severity</source>
-        <translation>분류</translation>
+        <translation type="vanished">분류</translation>
     </message>
     <message>
         <source>Line</source>
-        <translation>행</translation>
+        <translation type="vanished">행</translation>
     </message>
     <message>
         <source>Summary</source>
-        <translation>요약</translation>
+        <translation type="vanished">요약</translation>
     </message>
     <message>
         <source>Undefined file</source>
-        <translation>미정의된 파일</translation>
-    </message>
-    <message>
-        <source>[Inconclusive]</source>
-        <translation type="obsolete">[불확실]</translation>
+        <translation type="vanished">미정의된 파일</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="355"/>
         <source>style</source>
         <translation>스타일</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="358"/>
         <source>error</source>
         <translation>에러</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="361"/>
         <source>warning</source>
         <translation>경고</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="364"/>
         <source>performance</source>
         <translation>성능</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="367"/>
         <source>portability</source>
         <translation>이식성</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="370"/>
         <source>information</source>
         <translation>정보</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="373"/>
         <source>debug</source>
         <translation>디버그</translation>
     </message>
     <message>
-        <source>Copy filename</source>
-        <translation type="obsolete">파일이름 복사</translation>
-    </message>
-    <message>
-        <source>Copy full path</source>
-        <translation type="obsolete">전체 경로 복사</translation>
-    </message>
-    <message>
-        <source>Copy message</source>
-        <translation type="obsolete">메시지 복사</translation>
+        <location filename="resultstree.cpp" line="376"/>
+        <source>internal</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
         <source>Hide</source>
-        <translation>숨기기</translation>
+        <translation type="vanished">숨기기</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="744"/>
+        <location filename="resultstree.cpp" line="758"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="745"/>
         <source>No editor application configured.
 
 Configure the editor application for Cppcheck in preferences/Applications.</source>
@@ -1654,6 +2386,7 @@ Configure the editor application for Cppcheck in preferences/Applications.</sour
 [설정 - 응용 프로그램]에서 편집기를 설정하세요.</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="759"/>
         <source>No default editor application selected.
 
 Please select the default editor application in preferences/Applications.</source>
@@ -1662,10 +2395,12 @@ Please select the default editor application in preferences/Applications.</sourc
 [설정 - 응용 프로그램]에서 기본 편집기를 선택하세요.</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="779"/>
         <source>Could not find the file!</source>
         <translation>파일을 찾을 수 없습니다!</translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="822"/>
         <source>Could not start %1
 
 Please check the application path and parameters are correct.</source>
@@ -1674,74 +2409,72 @@ Please check the application path and parameters are correct.</source>
 경로와 인자가 정확한지 확인하세요.</translation>
     </message>
     <message>
-        <source>Could not find file:
-%1
-Please select the directory where file is located.</source>
-        <translation type="obsolete">파일 찾기 실패:
-%1
-파일이 위치한 디렉토리를 선택하세요.</translation>
-    </message>
-    <message>
+        <location filename="resultstree.cpp" line="844"/>
         <source>Select Directory</source>
         <translation>디렉토리 선택</translation>
     </message>
     <message>
-        <source>Id</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
+        <location filename="resultstree.cpp" line="670"/>
         <source>Hide all with id</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="671"/>
         <source>Open containing folder</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Inconclusive</source>
+        <location filename="resultstree.cpp" line="307"/>
+        <source>note</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Recheck</source>
+        <location filename="resultstree.cpp" line="667"/>
+        <source>Recheck %1 file(s)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>note</source>
+        <location filename="resultstree.cpp" line="669"/>
+        <source>Hide %1 result(s)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="692"/>
         <source>Suppress selected id(s)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="712"/>
         <source>Tag</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="714"/>
         <source>No tag</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Since date</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
+        <location filename="resultstree.cpp" line="836"/>
         <source>Could not find file:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="840"/>
         <source>Please select the folder &apos;%1&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="841"/>
         <source>Select Directory &apos;%1&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="843"/>
         <source>Please select the directory where file is located.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultstree.cpp" line="668"/>
         <source>Copy</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1749,84 +2482,122 @@ Please select the directory where file is located.</source>
 <context>
     <name>ResultsView</name>
     <message>
+        <location filename="resultsview.ui" line="26"/>
         <source>Results</source>
         <translation>결과</translation>
     </message>
     <message>
-        <source>No errors found, nothing to save.</source>
-        <translation>에러가 발견되지 않았고, 저장할 내용이 없습니다.</translation>
-    </message>
-    <message>
+        <location filename="resultsview.cpp" line="237"/>
+        <location filename="resultsview.cpp" line="245"/>
         <source>Failed to save the report.</source>
         <translation>결과 저장 실패.</translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="326"/>
         <source>%p% (%1 of %2 files checked)</source>
         <translation>%p% (%2 중 %1 파일 검사됨)</translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="361"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="351"/>
         <source>No errors found.</source>
         <translation>에러가 발견되지 않았습니다.</translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="358"/>
         <source>Errors were found, but they are configured to be hidden.
 To toggle what kind of errors are shown, open view menu.</source>
         <translation>에러가 발견되었지만, 감추도록 설정되어 있습니다.
 에러 종류를 표시하도록 설정하려면, 보기 메뉴를 선택하세요.</translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="421"/>
         <source>Failed to read the report.</source>
         <translation>결과 불러오기 실패.</translation>
     </message>
     <message>
-        <source>Summary</source>
-        <translation type="obsolete">요약</translation>
+        <location filename="resultsview.cpp" line="549"/>
+        <source>Analysis was stopped</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="563"/>
+        <source>There was a critical error with id &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="565"/>
+        <source>when checking %1</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Message</source>
-        <translation type="obsolete">내용</translation>
+        <location filename="resultsview.cpp" line="567"/>
+        <source>when checking a file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="568"/>
+        <source>Analysis was aborted.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="465"/>
         <source>Id</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="255"/>
         <source>Print Report</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="274"/>
         <source>No errors found, nothing to print.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="460"/>
         <source>First included by</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="409"/>
         <source>XML format version 1 is no longer supported.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultsview.ui" line="60"/>
+        <source>Critical errors</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.ui" line="92"/>
         <source>Analysis Log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultsview.ui" line="114"/>
         <source>Warning Details</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="539"/>
         <source>Clear Log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="540"/>
         <source>Copy this Log entry</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="resultsview.cpp" line="541"/>
         <source>Copy complete Log</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1834,22 +2605,27 @@ To toggle what kind of errors are shown, open view menu.</source>
 <context>
     <name>ScratchPad</name>
     <message>
+        <location filename="scratchpad.ui" line="14"/>
         <source>Scratchpad</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="scratchpad.ui" line="71"/>
         <source>filename</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="scratchpad.ui" line="78"/>
         <source>Check</source>
         <translation type="unfinished">검사</translation>
     </message>
     <message>
+        <location filename="scratchpad.ui" line="20"/>
         <source>Copy or write some C/C++ code here:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="scratchpad.ui" line="37"/>
         <source>Optionally enter a filename (mainly for automatic language detection) and click on &quot;Check&quot;:</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1857,209 +2633,246 @@ To toggle what kind of errors are shown, open view menu.</source>
 <context>
     <name>Settings</name>
     <message>
+        <location filename="settings.ui" line="14"/>
         <source>Preferences</source>
         <translation>설정</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="24"/>
         <source>General</source>
         <translation>일반</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="41"/>
         <source>Number of threads: </source>
         <translation>쓰레드 수: </translation>
     </message>
     <message>
         <source>Ideal count:</source>
-        <translation>최적 값:</translation>
+        <translation type="vanished">최적 값:</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="108"/>
         <source>Force checking all #ifdef configurations</source>
         <translation>모든 #ifdef 설정을 강제로 검사</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="115"/>
         <source>Show full path of files</source>
         <translation>파일의 전체 경로 표시</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="122"/>
         <source>Show &quot;No errors found&quot; message when no errors found</source>
         <translation>에러가 발견되지 않는 경우 &quot;에러가 없습니다.&quot; 메시지 표시</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="136"/>
         <source>Enable inline suppressions</source>
         <translation>Inline suppression 사용</translation>
     </message>
     <message>
-        <source>Paths</source>
-        <translation type="obsolete">경로</translation>
-    </message>
-    <message>
-        <source>Include paths:</source>
-        <translation type="obsolete">Include 경로:</translation>
+        <location filename="settings.ui" line="157"/>
+        <source>Check for updates</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="196"/>
         <source>Add...</source>
         <translation>추가...</translation>
     </message>
     <message>
-        <source>Edit</source>
-        <translation type="obsolete">편집</translation>
-    </message>
-    <message>
+        <location filename="settings.ui" line="210"/>
         <source>Remove</source>
         <translation>제거</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="185"/>
         <source>Applications</source>
         <translation>응용 프로그램</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="203"/>
+        <location filename="settings.ui" line="479"/>
         <source>Edit...</source>
         <translation>편집...</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="217"/>
         <source>Set as default</source>
         <translation>기본으로 지정</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="240"/>
         <source>Reports</source>
         <translation>보고서</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="246"/>
         <source>Save all errors when creating report</source>
         <translation>보고서 생성 시 모든 에러 저장</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="253"/>
         <source>Save full path to files in reports</source>
         <translation>보고서에 파일의 전체 경로 저장</translation>
     </message>
     <message>
+        <location filename="settings.ui" line="274"/>
         <source>Language</source>
         <translation>언어</translation>
     </message>
     <message>
-        <source>Advanced</source>
-        <translation type="obsolete">고급</translation>
-    </message>
-    <message>
-        <source>&amp;Show inconclusive errors</source>
-        <translation type="obsolete">불확실한 에러 표시(&amp;S)</translation>
-    </message>
-    <message>
-        <source>S&amp;how internal warnings in log</source>
-        <translation type="obsolete">로그에 내부 경고 표시(&amp;H)</translation>
-    </message>
-    <message>
+        <location filename="settings.ui" line="129"/>
         <source>Display error Id in column &quot;Id&quot;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="143"/>
         <source>Check for inconclusive errors also</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="177"/>
         <source>Show internal warnings in log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="150"/>
         <source>Show statistics on check completion</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="79"/>
+        <source>Max count:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="288"/>
         <source>Addons</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="294"/>
         <source>Python binary (leave this empty to use python in the PATH)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="305"/>
+        <location filename="settings.ui" line="346"/>
+        <location filename="settings.ui" line="391"/>
         <source>...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="372"/>
         <source>Clang</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="378"/>
         <source>Clang path (leave empty to use system PATH)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="401"/>
         <source>Visual Studio headers</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="407"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Paths to Visual Studio headers, separated by semicolon &apos;;&apos;.&lt;/p&gt;&lt;p&gt;You can open a Visual Studio command prompt, write &amp;quot;SET INCLUDE&amp;quot;. Then copy/paste the paths.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Misra addon</source>
+        <location filename="settings.ui" line="324"/>
+        <source>MISRA addon</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Misra rule texts file</source>
+        <location filename="settings.ui" line="332"/>
+        <source>MISRA rule texts file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="339"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="437"/>
         <source>Code Editor</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="443"/>
         <source>Code Editor Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="456"/>
         <source>Default Light Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="463"/>
         <source>Default Dark Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settings.ui" line="472"/>
         <source>Custom</source>
         <translation type="unfinished"></translation>
     </message>
+    <message>
+        <location filename="settings.ui" line="449"/>
+        <source>System Style</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>SettingsDialog</name>
     <message>
         <source>N/A</source>
-        <translation>N/A</translation>
+        <translation type="vanished">N/A</translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="232"/>
+        <source>The executable file &quot;%1&quot; is not available</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settingsdialog.cpp" line="243"/>
         <source>Add a new application</source>
         <translation>새 응용 프로그램 추가</translation>
     </message>
     <message>
+        <location filename="settingsdialog.cpp" line="273"/>
         <source>Modify an application</source>
         <translation>응용 프로그램 편집</translation>
     </message>
     <message>
+        <location filename="settingsdialog.cpp" line="303"/>
         <source>[Default]</source>
         <translation>[기본]</translation>
     </message>
     <message>
-        <source>Select include directory</source>
-        <translation type="obsolete">Include 디렉토리 선택</translation>
-    </message>
-    <message>
+        <location filename="settingsdialog.cpp" line="278"/>
         <source> [Default]</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settingsdialog.cpp" line="358"/>
         <source>Select python binary</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settingsdialog.cpp" line="396"/>
         <source>Select clang path</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="settingsdialog.cpp" line="365"/>
         <source>Select MISRA File</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2067,201 +2880,279 @@ To toggle what kind of errors are shown, open view menu.</source>
 <context>
     <name>StatsDialog</name>
     <message>
+        <location filename="statsdialog.ui" line="14"/>
+        <location filename="statsdialog.ui" line="248"/>
+        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="230"/>
         <source>Statistics</source>
         <translation>통계</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="27"/>
+        <location filename="statsdialog.cpp" line="221"/>
         <source>Project</source>
         <translation>프로젝트</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="33"/>
         <source>Project:</source>
         <translation>프로젝트:</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="53"/>
         <source>Paths:</source>
         <translation>경로:</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="85"/>
         <source>Include paths:</source>
         <translation>Include 경로:</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="108"/>
         <source>Defines:</source>
         <translation>Defines:</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="165"/>
+        <location filename="statsdialog.cpp" line="226"/>
         <source>Previous Scan</source>
         <translation>직전 검사</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="171"/>
         <source>Path Selected:</source>
         <translation>선택된 경로:</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="181"/>
         <source>Number of Files Scanned:</source>
         <translation>검사된 파일 수:</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="201"/>
         <source>Scan Duration:</source>
         <translation>검사 시간:</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="254"/>
         <source>Errors:</source>
         <translation>에러:</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="271"/>
         <source>Warnings:</source>
         <translation>경고:</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="288"/>
         <source>Stylistic warnings:</source>
         <translation>스타일 경고:</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="305"/>
         <source>Portability warnings:</source>
         <translation>이식성 경고:</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="322"/>
         <source>Performance issues:</source>
         <translation>성능 경고:</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="339"/>
         <source>Information messages:</source>
         <translation>정보 메시지:</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="356"/>
+        <source>Active checkers:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="374"/>
+        <source>Checkers</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="443"/>
         <source>Copy to Clipboard</source>
         <translation>클립보드에 복사</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>1 day</source>
         <translation>1일</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>%1 days</source>
         <translation>%1일</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>1 hour</source>
         <translation>1시간</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>%1 hours</source>
         <translation>%1시간</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>1 minute</source>
         <translation>1분</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>%1 minutes</source>
         <translation>%1분</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>1 second</source>
         <translation>1초</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>%1 seconds</source>
         <translation>%1초</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="169"/>
         <source>0.%1 seconds</source>
         <translation>0.%1초</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="171"/>
         <source> and </source>
         <translation> 및 </translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="220"/>
         <source>Project Settings</source>
         <translation>프로젝트 설정</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="222"/>
         <source>Paths</source>
         <translation>경로</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="223"/>
         <source>Include paths</source>
         <translation>Include 경로</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="224"/>
         <source>Defines</source>
         <translation>Defines</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="227"/>
         <source>Path selected</source>
         <translation>선택된 경로</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="228"/>
         <source>Number of files scanned</source>
         <translation>검사된 파일 수</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="229"/>
         <source>Scan duration</source>
         <translation>검사 시간</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="185"/>
+        <location filename="statsdialog.cpp" line="231"/>
         <source>Errors</source>
         <translation>에러</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="232"/>
         <source>Warnings</source>
         <translation>경고</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="233"/>
         <source>Style warnings</source>
         <translation>스타일 경고</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="191"/>
+        <location filename="statsdialog.cpp" line="234"/>
         <source>Portability warnings</source>
         <translation>이식성 경고</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="193"/>
+        <location filename="statsdialog.cpp" line="235"/>
         <source>Performance warnings</source>
         <translation>성능 경고</translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="195"/>
+        <location filename="statsdialog.cpp" line="236"/>
         <source>Information messages</source>
         <translation>정보 메시지</translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="450"/>
         <source>Pdf Export</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="198"/>
         <source>Export PDF</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="399"/>
         <source>History</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="405"/>
         <source>File:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>File: </source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>No cppcheck build dir</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.ui" line="131"/>
         <source>Undefines:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="statsdialog.cpp" line="225"/>
         <source>Undefines</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
+<context>
+    <name>ThreadDetails</name>
+    <message>
+        <location filename="threaddetails.ui" line="14"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>ThreadResult</name>
     <message>
+        <location filename="threadresult.cpp" line="47"/>
         <source>%1 of %2 files checked</source>
         <translation>%2 중 %1 파일 검사됨</translation>
     </message>
@@ -2269,6 +3160,7 @@ To toggle what kind of errors are shown, open view menu.</source>
 <context>
     <name>TranslationHandler</name>
     <message>
+        <location filename="translationhandler.cpp" line="130"/>
         <source>Failed to change the user interface language:
 
 %1
@@ -2281,6 +3173,7 @@ The user interface language has been reset to English. Open the Preferences-dial
 언어가 영어로 초기화 됐습니다. 설정창을 열어서 설정 가능한 언어를 선택하세요.</translation>
     </message>
     <message>
+        <location filename="translationhandler.cpp" line="136"/>
         <source>Cppcheck</source>
         <translation type="unfinished">Cppcheck</translation>
     </message>
@@ -2288,6 +3181,7 @@ The user interface language has been reset to English. Open the Preferences-dial
 <context>
     <name>TxtReport</name>
     <message>
+        <location filename="txtreport.cpp" line="74"/>
         <source>inconclusive</source>
         <translation>불확실</translation>
     </message>
@@ -2295,10 +3189,12 @@ The user interface language has been reset to English. Open the Preferences-dial
 <context>
     <name>toFilterString</name>
     <message>
+        <location filename="common.cpp" line="58"/>
         <source>All supported files (%1)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="common.cpp" line="63"/>
         <source>All files (%1)</source>
         <translation type="unfinished"></translation>
     </message>
diff --git a/gui/cppcheck_nl.ts b/gui/cppcheck_nl.ts
index 94ed55ce65a..2d3149d2f0a 100644
--- a/gui/cppcheck_nl.ts
+++ b/gui/cppcheck_nl.ts
@@ -20,8 +20,9 @@
     </message>
     <message>
         <location filename="about.ui" line="81"/>
-        <source>Copyright © 2007-2019 Cppcheck team.</source>
-        <translation>Copyright © 2007-2019 het cppcheck team.</translation>
+        <source>Copyright © 2007-%1 Cppcheck team.</source>
+        <oldsource>Copyright © 2007-2021 Cppcheck team.</oldsource>
+        <translation type="unfinished">Copyright © 2007-2021 het cppcheck team.</translation>
     </message>
     <message>
         <location filename="about.ui" line="91"/>
@@ -37,24 +38,20 @@ van de GNU General Public License versie 3</translation>
     </message>
     <message>
         <location filename="about.ui" line="115"/>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
-&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul&gt;
-&lt;li&gt;tinyxml2&lt;/li&gt;
-&lt;li&gt;picojson&lt;/li&gt;
-&lt;li&gt;pcre&lt;/li&gt;
-&lt;li&gt;qt&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PCRE&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PicoJSON&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;TinyXML2&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Boost&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <oldsource>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;pcre&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;picojson&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;tinyxml2&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</oldsource>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>ApplicationDialog</name>
     <message>
-        <location filename="application.ui" line="23"/>
+        <location filename="applicationdialog.ui" line="23"/>
         <source>Add an application</source>
         <translation>Voeg een nieuwe applicatie toe</translation>
     </message>
     <message>
-        <location filename="application.ui" line="41"/>
+        <location filename="applicationdialog.ui" line="41"/>
         <source>Here you can add an application that can open error files. Specify a name for the application, the application executable and command line parameters for the application.
 
 The following texts in parameters are replaced with appropriate values when application is executed:
@@ -79,67 +76,159 @@ Uitvoerbaar: KonOs2
 Parameters: -l(lijn) (bestand)</translation>
     </message>
     <message>
-        <location filename="application.ui" line="76"/>
+        <location filename="applicationdialog.ui" line="76"/>
         <source>&amp;Name:</source>
         <translation>&amp;Naam:</translation>
     </message>
     <message>
-        <location filename="application.ui" line="86"/>
+        <location filename="applicationdialog.ui" line="86"/>
         <source>&amp;Executable:</source>
         <translation>&amp;Uitvoerbaar:</translation>
     </message>
     <message>
-        <location filename="application.ui" line="96"/>
+        <location filename="applicationdialog.ui" line="96"/>
         <source>&amp;Parameters:</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="application.ui" line="138"/>
+        <location filename="applicationdialog.ui" line="138"/>
         <source>Browse</source>
         <translation>Bladeren</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="59"/>
+        <location filename="applicationdialog.cpp" line="65"/>
         <source>Executable files (*.exe);;All files(*.*)</source>
         <translation>Uitvoerbare bestanden (*.exe);;Alle bestanden(*.*)</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="62"/>
+        <location filename="applicationdialog.cpp" line="68"/>
         <source>Select viewer application</source>
         <translation>Selecteer applicatie</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="77"/>
+        <location filename="applicationdialog.cpp" line="83"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="78"/>
+        <location filename="applicationdialog.cpp" line="84"/>
         <source>You must specify a name, a path and optionally parameters for the application!</source>
         <translation>Geef een naam op, een pad en eventueel parameters voor de toepassing!</translation>
     </message>
 </context>
+<context>
+    <name>ComplianceReportDialog</name>
+    <message>
+        <location filename="compliancereportdialog.ui" line="14"/>
+        <source>Compliance Report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="29"/>
+        <source>Project name</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="22"/>
+        <source>Project version</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="42"/>
+        <source>Coding Standard</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="50"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="55"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="60"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="70"/>
+        <source>List of files with md5 checksums</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="133"/>
+        <source>Compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="135"/>
+        <source>HTML files (*.html)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="176"/>
+        <location filename="compliancereportdialog.cpp" line="239"/>
+        <source>Save compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="177"/>
+        <source>Failed to import &apos;%1&apos; (%2), can not show files in compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>FileViewDialog</name>
     <message>
-        <location filename="fileviewdialog.cpp" line="42"/>
+        <location filename="fileviewdialog.cpp" line="53"/>
         <source>Could not find the file: %1</source>
         <oldsource>Could not find the file:
 </oldsource>
         <translation>Kon het bestand niet vinden: %1</translation>
     </message>
     <message>
-        <location filename="fileviewdialog.cpp" line="46"/>
-        <location filename="fileviewdialog.cpp" line="60"/>
+        <location filename="fileviewdialog.cpp" line="57"/>
+        <location filename="fileviewdialog.cpp" line="71"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="fileviewdialog.cpp" line="56"/>
+        <location filename="fileviewdialog.cpp" line="67"/>
         <source>Could not read the file: %1</source>
         <translation>Kon het bestand niet lezen: %1</translation>
     </message>
 </context>
+<context>
+    <name>HelpDialog</name>
+    <message>
+        <location filename="helpdialog.ui" line="14"/>
+        <source>Cppcheck GUI help</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="34"/>
+        <source>Contents</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="44"/>
+        <source>Index</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="84"/>
+        <source>Helpfile &apos;%1&apos; was not found</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="86"/>
+        <source>Cppcheck</source>
+        <translation type="unfinished">Cppcheck</translation>
+    </message>
+</context>
 <context>
     <name>LibraryAddFunctionDialog</name>
     <message>
@@ -246,42 +335,42 @@ Parameters: -l(lijn) (bestand)</translation>
         <translation type="unfinished">Bewerk</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="82"/>
-        <location filename="librarydialog.cpp" line="154"/>
+        <location filename="librarydialog.cpp" line="97"/>
+        <location filename="librarydialog.cpp" line="169"/>
         <source>Library files (*.cfg)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="84"/>
+        <location filename="librarydialog.cpp" line="99"/>
         <source>Open library file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="95"/>
-        <location filename="librarydialog.cpp" line="107"/>
-        <location filename="librarydialog.cpp" line="144"/>
+        <location filename="librarydialog.cpp" line="110"/>
+        <location filename="librarydialog.cpp" line="122"/>
+        <location filename="librarydialog.cpp" line="159"/>
         <source>Cppcheck</source>
         <translation type="unfinished">Cppcheck</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="96"/>
+        <location filename="librarydialog.cpp" line="111"/>
         <source>Cannot open file %1.</source>
         <oldsource>Can not open file %1.</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="108"/>
+        <location filename="librarydialog.cpp" line="123"/>
         <source>Failed to load %1. %2.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="145"/>
+        <location filename="librarydialog.cpp" line="160"/>
         <source>Cannot save file %1.</source>
         <oldsource>Can not save file %1.</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="157"/>
+        <location filename="librarydialog.cpp" line="172"/>
         <source>Save the library as</source>
         <translation type="unfinished"></translation>
     </message>
@@ -396,603 +485,626 @@ Parameters: -l(lijn) (bestand)</translation>
         <translation type="unfinished"></translation>
     </message>
 </context>
-<context>
-    <name>LogView</name>
-    <message>
-        <source>Checking Log</source>
-        <translation type="obsolete">Controleer log</translation>
-    </message>
-    <message>
-        <source>Clear</source>
-        <translation type="obsolete">Wis</translation>
-    </message>
-    <message>
-        <source>Save Log</source>
-        <translation type="obsolete">Opslaan log</translation>
-    </message>
-    <message>
-        <source>Text files (*.txt *.log);;All files (*.*)</source>
-        <translation type="obsolete">Tekst bestanden (*.txt *.log);;Alle bestanden(*.*)</translation>
-    </message>
-    <message>
-        <source>Cppcheck</source>
-        <translation type="obsolete">Cppcheck</translation>
-    </message>
-    <message>
-        <source>Could not open file for writing: &quot;%1&quot;</source>
-        <translation type="obsolete">Kan bestand: &quot;%1&quot; niet openen om te schrijven</translation>
-    </message>
-</context>
 <context>
     <name>MainWindow</name>
     <message>
         <location filename="mainwindow.ui" line="26"/>
-        <location filename="mainwindow.ui" line="595"/>
-        <location filename="mainwindow.cpp" line="328"/>
-        <location filename="mainwindow.cpp" line="480"/>
-        <location filename="mainwindow.cpp" line="553"/>
-        <location filename="mainwindow.cpp" line="658"/>
-        <location filename="mainwindow.cpp" line="680"/>
-        <location filename="mainwindow.cpp" line="1113"/>
-        <location filename="mainwindow.cpp" line="1238"/>
-        <location filename="mainwindow.cpp" line="1359"/>
-        <location filename="mainwindow.cpp" line="1499"/>
-        <location filename="mainwindow.cpp" line="1522"/>
-        <location filename="mainwindow.cpp" line="1593"/>
-        <location filename="mainwindow.cpp" line="1667"/>
+        <location filename="mainwindow.ui" line="688"/>
+        <location filename="mainwindow.cpp" line="466"/>
+        <location filename="mainwindow.cpp" line="670"/>
+        <location filename="mainwindow.cpp" line="755"/>
+        <location filename="mainwindow.cpp" line="860"/>
+        <location filename="mainwindow.cpp" line="882"/>
+        <location filename="mainwindow.cpp" line="1467"/>
+        <location filename="mainwindow.cpp" line="1596"/>
+        <location filename="mainwindow.cpp" line="1937"/>
+        <location filename="mainwindow.cpp" line="1945"/>
+        <location filename="mainwindow.cpp" line="1999"/>
+        <location filename="mainwindow.cpp" line="2008"/>
+        <location filename="mainwindow.cpp" line="2080"/>
+        <location filename="mainwindow.cpp" line="2168"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="131"/>
+        <location filename="mainwindow.ui" line="210"/>
         <source>A&amp;nalyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="183"/>
+        <location filename="mainwindow.ui" line="267"/>
         <source>Standard</source>
         <translation>Standaard</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="70"/>
+        <location filename="mainwindow.ui" line="132"/>
         <source>&amp;File</source>
         <translation>&amp;Bestand</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="89"/>
+        <location filename="mainwindow.ui" line="152"/>
         <source>&amp;View</source>
         <translation>&amp;Weergave</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="93"/>
+        <location filename="mainwindow.ui" line="156"/>
         <source>&amp;Toolbars</source>
         <translation>&amp;Werkbalken</translation>
     </message>
     <message>
-        <source>&amp;Check</source>
-        <translation type="obsolete">&amp;Controleer</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="135"/>
+        <location filename="mainwindow.ui" line="214"/>
         <source>C++ standard</source>
         <translation>C++standaard</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="145"/>
+        <location filename="mainwindow.ui" line="226"/>
         <source>&amp;C standard</source>
         <oldsource>C standard</oldsource>
         <translation type="unfinished">C standaard</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="170"/>
+        <location filename="mainwindow.ui" line="254"/>
         <source>&amp;Edit</source>
         <translation>Be&amp;werken</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="231"/>
+        <location filename="mainwindow.ui" line="315"/>
         <source>&amp;License...</source>
         <translation>&amp;Licentie...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="236"/>
+        <location filename="mainwindow.ui" line="320"/>
         <source>A&amp;uthors...</source>
         <translation>A&amp;uteurs...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="245"/>
+        <location filename="mainwindow.ui" line="329"/>
         <source>&amp;About...</source>
         <translation>&amp;Over...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="250"/>
+        <location filename="mainwindow.ui" line="334"/>
         <source>&amp;Files...</source>
         <translation>&amp;Bestanden...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="253"/>
-        <location filename="mainwindow.ui" line="256"/>
+        <location filename="mainwindow.ui" line="337"/>
+        <location filename="mainwindow.ui" line="340"/>
         <source>Analyze files</source>
         <oldsource>Check files</oldsource>
         <translation type="unfinished">Controleer bestanden</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="259"/>
+        <location filename="mainwindow.ui" line="343"/>
         <source>Ctrl+F</source>
         <translation>Ctrl+F</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="268"/>
+        <location filename="mainwindow.ui" line="352"/>
         <source>&amp;Directory...</source>
         <translation>&amp;Mappen...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="271"/>
-        <location filename="mainwindow.ui" line="274"/>
+        <location filename="mainwindow.ui" line="355"/>
+        <location filename="mainwindow.ui" line="358"/>
         <source>Analyze directory</source>
         <oldsource>Check directory</oldsource>
         <translation type="unfinished">Controleer Map</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="277"/>
+        <location filename="mainwindow.ui" line="361"/>
         <source>Ctrl+D</source>
         <translation>Ctrl+D</translation>
     </message>
     <message>
-        <source>&amp;Recheck files</source>
-        <translation type="obsolete">&amp;Opnieuw controleren</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="289"/>
+        <location filename="mainwindow.ui" line="373"/>
         <source>Ctrl+R</source>
         <translation>Ctrl+R</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="307"/>
+        <location filename="mainwindow.ui" line="391"/>
         <source>&amp;Stop</source>
         <translation>&amp;Stop</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="310"/>
-        <location filename="mainwindow.ui" line="313"/>
+        <location filename="mainwindow.ui" line="394"/>
+        <location filename="mainwindow.ui" line="397"/>
         <source>Stop analysis</source>
         <oldsource>Stop checking</oldsource>
         <translation type="unfinished">Stop controle</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="316"/>
+        <location filename="mainwindow.ui" line="400"/>
         <source>Esc</source>
         <translation>Esc</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="325"/>
+        <location filename="mainwindow.ui" line="409"/>
         <source>&amp;Save results to file...</source>
         <translation>&amp;Resultaten opslaan...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="328"/>
+        <location filename="mainwindow.ui" line="412"/>
         <source>Ctrl+S</source>
         <translation>Ctrl+S</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="333"/>
+        <location filename="mainwindow.ui" line="417"/>
         <source>&amp;Quit</source>
         <translation>&amp;Afsluiten</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="342"/>
+        <location filename="mainwindow.ui" line="429"/>
         <source>&amp;Clear results</source>
         <translation>&amp;Resultaten wissen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="351"/>
+        <location filename="mainwindow.ui" line="438"/>
         <source>&amp;Preferences</source>
         <translation>&amp;Voorkeuren</translation>
     </message>
     <message>
-        <source>Errors</source>
-        <translation type="obsolete">Fouten</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="384"/>
-        <location filename="mainwindow.ui" line="387"/>
+        <location filename="mainwindow.ui" line="471"/>
+        <location filename="mainwindow.ui" line="474"/>
+        <location filename="mainwindow.cpp" line="2394"/>
         <source>Show errors</source>
         <translation>Toon fouten</translation>
     </message>
     <message>
-        <source>Show S&amp;cratchpad...</source>
-        <translation type="obsolete">Toon S&amp;cratchpad...</translation>
-    </message>
-    <message>
-        <source>Warnings</source>
-        <translation type="obsolete">Waarschuwingen</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="524"/>
-        <location filename="mainwindow.ui" line="527"/>
+        <location filename="mainwindow.ui" line="617"/>
+        <location filename="mainwindow.ui" line="620"/>
+        <location filename="mainwindow.cpp" line="2395"/>
         <source>Show warnings</source>
         <translation>Toon waarschuwingen</translation>
     </message>
     <message>
-        <source>Performance warnings</source>
-        <translation type="obsolete">Presentatie waarschuwingen</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="542"/>
-        <location filename="mainwindow.ui" line="545"/>
+        <location filename="mainwindow.ui" line="635"/>
+        <location filename="mainwindow.ui" line="638"/>
         <source>Show performance warnings</source>
         <translation>Toon presentatie waarschuwingen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="553"/>
+        <location filename="mainwindow.ui" line="646"/>
         <source>Show &amp;hidden</source>
         <translation>Toon &amp;verborgen</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="769"/>
-        <location filename="mainwindow.cpp" line="807"/>
+        <location filename="mainwindow.cpp" line="986"/>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Information</source>
         <translation>Informatie</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="568"/>
+        <location filename="mainwindow.ui" line="661"/>
         <source>Show information messages</source>
         <translation>Toon informatie bericht</translation>
     </message>
     <message>
-        <source>Portability</source>
-        <translation type="obsolete">Portabiliteit</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="583"/>
+        <location filename="mainwindow.ui" line="676"/>
         <source>Show portability warnings</source>
         <translation>Toon portabiliteit waarschuwingen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="598"/>
+        <location filename="mainwindow.ui" line="691"/>
         <source>Show Cppcheck results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="610"/>
+        <location filename="mainwindow.ui" line="703"/>
         <source>Clang</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="613"/>
+        <location filename="mainwindow.ui" line="706"/>
         <source>Show Clang results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="621"/>
+        <location filename="mainwindow.ui" line="714"/>
         <source>&amp;Filter</source>
         <translation>&amp;Filter</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="624"/>
+        <location filename="mainwindow.ui" line="717"/>
         <source>Filter results</source>
         <translation>Filter resultaten</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="640"/>
+        <location filename="mainwindow.ui" line="733"/>
         <source>Windows 32-bit ANSI</source>
         <translation>Windows 32-bit ANSI</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="648"/>
+        <location filename="mainwindow.ui" line="741"/>
         <source>Windows 32-bit Unicode</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="656"/>
+        <location filename="mainwindow.ui" line="749"/>
         <source>Unix 32-bit</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="664"/>
+        <location filename="mainwindow.ui" line="757"/>
         <source>Unix 64-bit</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="672"/>
+        <location filename="mainwindow.ui" line="765"/>
         <source>Windows 64-bit</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="742"/>
+        <location filename="mainwindow.ui" line="859"/>
         <source>&amp;Print...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="745"/>
+        <location filename="mainwindow.ui" line="862"/>
         <source>Print the Current Report</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="750"/>
+        <location filename="mainwindow.ui" line="867"/>
         <source>Print Pre&amp;view...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="753"/>
+        <location filename="mainwindow.ui" line="870"/>
         <source>Open a Print Preview Dialog for the Current Results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="761"/>
+        <location filename="mainwindow.ui" line="878"/>
         <source>Open library editor</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="392"/>
+        <location filename="mainwindow.ui" line="479"/>
         <source>&amp;Check all</source>
         <translation>&amp;Controleer alles</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="220"/>
+        <location filename="mainwindow.ui" line="84"/>
+        <source>Checking for updates</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="100"/>
+        <source>Hide</source>
+        <translation type="unfinished">Verberg</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="164"/>
+        <location filename="mainwindow.ui" line="980"/>
+        <source>Report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="304"/>
         <source>Filter</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="286"/>
+        <location filename="mainwindow.ui" line="370"/>
         <source>&amp;Reanalyze modified files</source>
         <oldsource>&amp;Recheck modified files</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="298"/>
+        <location filename="mainwindow.ui" line="382"/>
         <source>Reanal&amp;yze all files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="363"/>
+        <location filename="mainwindow.ui" line="420"/>
+        <source>Ctrl+Q</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="450"/>
         <source>Style war&amp;nings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="381"/>
+        <location filename="mainwindow.ui" line="468"/>
         <source>E&amp;rrors</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="397"/>
+        <location filename="mainwindow.ui" line="484"/>
         <source>&amp;Uncheck all</source>
         <translation>Selecteer &amp;niets</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="402"/>
+        <location filename="mainwindow.ui" line="489"/>
         <source>Collapse &amp;all</source>
         <translation>Alles Inkl&amp;appen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="407"/>
+        <location filename="mainwindow.ui" line="494"/>
         <source>&amp;Expand all</source>
         <translation>Alles &amp;Uitklappen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="415"/>
+        <location filename="mainwindow.ui" line="502"/>
         <source>&amp;Standard</source>
         <translation>&amp;Standaard</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="418"/>
+        <location filename="mainwindow.ui" line="505"/>
         <source>Standard items</source>
         <translation>Standaard items</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="434"/>
+        <location filename="mainwindow.ui" line="521"/>
         <source>Toolbar</source>
         <translation>Werkbalk</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="442"/>
+        <location filename="mainwindow.ui" line="529"/>
         <source>&amp;Categories</source>
         <translation>&amp;Categorieën</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="445"/>
+        <location filename="mainwindow.ui" line="532"/>
         <source>Error categories</source>
         <translation>Foute Categorieën</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="450"/>
+        <location filename="mainwindow.ui" line="537"/>
         <source>&amp;Open XML...</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="459"/>
+        <location filename="mainwindow.ui" line="546"/>
         <source>Open P&amp;roject File...</source>
         <translation>Open P&amp;oject bestand...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="468"/>
+        <location filename="mainwindow.ui" line="549"/>
+        <source>Ctrl+Shift+O</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="558"/>
         <source>Sh&amp;ow Scratchpad...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="473"/>
+        <location filename="mainwindow.ui" line="563"/>
         <source>&amp;New Project File...</source>
         <translation>&amp;Nieuw Project Bestand...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="478"/>
+        <location filename="mainwindow.ui" line="566"/>
+        <source>Ctrl+Shift+N</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="571"/>
         <source>&amp;Log View</source>
         <translation>&amp;Log weergave</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="481"/>
+        <location filename="mainwindow.ui" line="574"/>
         <source>Log View</source>
         <translation>Log weergave</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="489"/>
+        <location filename="mainwindow.ui" line="582"/>
         <source>C&amp;lose Project File</source>
         <translation>&amp;Sluit Project Bestand</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="497"/>
+        <location filename="mainwindow.ui" line="590"/>
         <source>&amp;Edit Project File...</source>
         <translation>&amp;Bewerk Project Bestand...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="509"/>
+        <location filename="mainwindow.ui" line="602"/>
         <source>&amp;Statistics</source>
         <translation>&amp;Statistieken</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="521"/>
+        <location filename="mainwindow.ui" line="614"/>
         <source>&amp;Warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="539"/>
+        <location filename="mainwindow.ui" line="632"/>
         <source>Per&amp;formance warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="565"/>
+        <location filename="mainwindow.ui" line="658"/>
         <source>&amp;Information</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="580"/>
+        <location filename="mainwindow.ui" line="673"/>
         <source>&amp;Portability</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="680"/>
+        <location filename="mainwindow.ui" line="773"/>
         <source>P&amp;latforms</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="694"/>
+        <location filename="mainwindow.ui" line="787"/>
         <source>C++&amp;11</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="705"/>
+        <location filename="mainwindow.ui" line="798"/>
         <source>C&amp;99</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="713"/>
+        <location filename="mainwindow.ui" line="806"/>
         <source>&amp;Posix</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="721"/>
+        <location filename="mainwindow.ui" line="814"/>
         <source>C&amp;11</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="729"/>
+        <location filename="mainwindow.ui" line="846"/>
         <source>&amp;C89</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="737"/>
+        <location filename="mainwindow.ui" line="854"/>
         <source>&amp;C++03</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="758"/>
+        <location filename="mainwindow.ui" line="875"/>
         <source>&amp;Library Editor...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="769"/>
+        <location filename="mainwindow.ui" line="886"/>
         <source>&amp;Auto-detect language</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="777"/>
+        <location filename="mainwindow.ui" line="894"/>
         <source>&amp;Enforce C++</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="785"/>
+        <location filename="mainwindow.ui" line="902"/>
         <source>E&amp;nforce C</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="796"/>
+        <location filename="mainwindow.ui" line="913"/>
         <source>C++14</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="804"/>
+        <location filename="mainwindow.ui" line="921"/>
         <source>Reanalyze and check library</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="812"/>
+        <location filename="mainwindow.ui" line="929"/>
         <source>Check configuration (defines, includes)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="820"/>
+        <location filename="mainwindow.ui" line="937"/>
         <source>C++17</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="831"/>
+        <location filename="mainwindow.ui" line="948"/>
         <source>C++20</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="423"/>
+        <location filename="mainwindow.ui" line="975"/>
+        <source>Compliance report...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="988"/>
+        <source>Normal</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="996"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1004"/>
+        <source>Misra C++ 2008</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1012"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1020"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1028"/>
+        <source>Misra C++ 2023</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1036"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1041"/>
+        <source>EULA...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1046"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1049"/>
+        <source>Show thread details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="510"/>
         <source>&amp;Contents</source>
         <translation>&amp;Inhoud</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="201"/>
+        <location filename="mainwindow.ui" line="285"/>
         <source>Categories</source>
         <translation>Categorieën</translation>
     </message>
     <message>
-        <source>Style warnings</source>
-        <translation type="obsolete">Stijl waarschuwingen</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="366"/>
-        <location filename="mainwindow.ui" line="369"/>
+        <location filename="mainwindow.ui" line="453"/>
+        <location filename="mainwindow.ui" line="456"/>
         <source>Show style warnings</source>
         <translation>Toon stijl waarschuwingen</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="426"/>
+        <location filename="mainwindow.ui" line="513"/>
         <source>Open the help contents</source>
         <translation>Open de help inhoud</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="429"/>
+        <location filename="mainwindow.ui" line="516"/>
         <source>F1</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="121"/>
+        <location filename="mainwindow.ui" line="199"/>
         <source>&amp;Help</source>
         <translation>&amp;Help</translation>
     </message>
     <message>
-        <source>Select directory to check</source>
-        <translation type="obsolete">Selecteer een map om te controleren</translation>
-    </message>
-    <message>
-        <source>No suitable files found to check!</source>
-        <translation type="obsolete">Geen geschikte bestanden gevonden om te controleren!</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="87"/>
+        <location filename="mainwindow.cpp" line="157"/>
+        <location filename="mainwindow.cpp" line="1782"/>
         <source>Quick Filter:</source>
         <translation>Snel Filter:</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="629"/>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select configuration</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="659"/>
+        <location filename="mainwindow.cpp" line="861"/>
         <source>Found project file: %1
 
 Do you want to load this project file instead?</source>
@@ -1000,66 +1112,91 @@ Do you want to load this project file instead?</source>
 Wilt u dit project laden in plaats van?</translation>
     </message>
     <message>
-        <source>Found project files from the directory.
-
-Do you want to proceed checking without using any of these project files?</source>
-        <translation type="obsolete">Project bestanden gevonden in de map.
-Wil je verder wilt gaan zonder controle van deze project bestanden?</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="778"/>
+        <location filename="mainwindow.cpp" line="995"/>
         <source>File not found</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="781"/>
+        <location filename="mainwindow.cpp" line="998"/>
         <source>Bad XML</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="784"/>
+        <location filename="mainwindow.cpp" line="1001"/>
         <source>Missing attribute</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="787"/>
+        <location filename="mainwindow.cpp" line="1004"/>
         <source>Bad attribute value</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="807"/>
+        <location filename="mainwindow.cpp" line="1016"/>
+        <source>Duplicate define</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Failed to load the selected library &apos;%1&apos;.
 %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1280"/>
+        <location filename="mainwindow.cpp" line="1035"/>
+        <source>File not found: &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1058"/>
+        <source>Failed to load/setup addon %1: %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <source>Failed to load %1 - %2
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
+        <source>%1
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1648"/>
         <source>License</source>
         <translation>Licentie</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1287"/>
+        <location filename="mainwindow.cpp" line="1655"/>
         <source>Authors</source>
         <translation>Auteurs</translation>
     </message>
     <message>
-        <source>XML files version 2 (*.xml);;XML files version 1 (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
-        <oldsource>XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</oldsource>
-        <translation type="obsolete">XML bestanden (*.xml);;Tekst bestanden (*.txt);;CSV bestanden (*.csv)</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1302"/>
+        <location filename="mainwindow.cpp" line="1675"/>
         <source>Save the report file</source>
         <translation>Rapport opslaan </translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1129"/>
-        <location filename="mainwindow.cpp" line="1309"/>
+        <location filename="mainwindow.cpp" line="1483"/>
+        <location filename="mainwindow.cpp" line="1682"/>
         <source>XML files (*.xml)</source>
         <translation>XML bestanden (*.xml)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="323"/>
+        <location filename="mainwindow.cpp" line="461"/>
         <source>There was a problem with loading the editor application settings.
 
 This is probably because the settings were changed between the Cppcheck versions. Please check (and fix) the editor application settings, otherwise the editor program might not start correctly.</source>
@@ -1068,165 +1205,132 @@ This is probably because the settings were changed between the Cppcheck versions
 Dit is waarschijnlijk omdat de instellingen zijn gewijzigd tussen de versies van cppcheck. Controleer (en maak) de bewerker instellingen, anders zal de bewerker niet correct starten.</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="554"/>
+        <location filename="mainwindow.cpp" line="756"/>
         <source>You must close the project file before selecting new files or directories!</source>
         <translation>Je moet project bestanden sluiten voordat je nieuwe bestanden of mappen selekteerd!</translation>
     </message>
     <message>
-        <source>Select files to check</source>
-        <translation type="obsolete">Selecteer bestanden om te controleren</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="769"/>
+        <location filename="mainwindow.cpp" line="986"/>
         <source>The library &apos;%1&apos; contains unknown elements:
 %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="790"/>
+        <location filename="mainwindow.cpp" line="1007"/>
         <source>Unsupported format</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="793"/>
+        <location filename="mainwindow.cpp" line="1010"/>
         <source>Duplicate platform type</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="796"/>
+        <location filename="mainwindow.cpp" line="1013"/>
         <source>Platform type redefined</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="799"/>
+        <location filename="mainwindow.cpp" line="1019"/>
         <source>Unknown element</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="802"/>
-        <source>Unknown issue</source>
+        <location filename="mainwindow.cpp" line="1019"/>
+        <source>Unknown element</source>
+        <oldsource>Unknown issue</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="828"/>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
         <source>Error</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="828"/>
-        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <source>Current results will be cleared.
-
-Opening a new XML file will clear current results.Do you want to proceed?</source>
-        <translation type="vanished">Huidige resultaten zullen worden gewist
-
-Een nieuw XML-bestand openen zal de huidige resultaten wissen Wilt u verder gaan?</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1131"/>
+        <location filename="mainwindow.cpp" line="1485"/>
         <source>Open the report file</source>
         <translation>Open het rapport bestand</translation>
     </message>
     <message>
-        <source>Checking is running.
-
-Do you want to stop the checking and exit Cppcheck?</source>
-        <translation type="obsolete">Het controleren loopt.
-
-Wil je het controleren stoppen en Cppcheck sluiten?</translation>
-    </message>
-    <message>
-        <source>XML files version 1 (*.xml)</source>
-        <translation type="obsolete">XML files version 1 (*.xml)</translation>
-    </message>
-    <message>
-        <source>XML files version 2 (*.xml)</source>
-        <translation type="obsolete">XML files version 2 (*.xml)</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1313"/>
+        <location filename="mainwindow.cpp" line="1686"/>
         <source>Text files (*.txt)</source>
         <translation>Tekst bestanden (*.txt)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1317"/>
+        <location filename="mainwindow.cpp" line="1690"/>
         <source>CSV files (*.csv)</source>
         <translation>CSV bestanden (*.csv)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1361"/>
-        <source>Cppcheck - %1</source>
-        <translation>Cppcheck - %1</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1407"/>
+        <location filename="mainwindow.cpp" line="1820"/>
         <source>Project files (*.cppcheck);;All files(*.*)</source>
         <translation>Project bestanden (*.cppcheck);;Alle bestanden(*.*)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1409"/>
+        <location filename="mainwindow.cpp" line="1822"/>
         <source>Select Project File</source>
         <translation>Selecteer project bestand</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="159"/>
-        <location filename="mainwindow.cpp" line="1437"/>
-        <location filename="mainwindow.cpp" line="1562"/>
+        <location filename="mainwindow.cpp" line="242"/>
+        <location filename="mainwindow.cpp" line="1784"/>
+        <location filename="mainwindow.cpp" line="1850"/>
+        <location filename="mainwindow.cpp" line="2048"/>
         <source>Project:</source>
         <translation>Project:</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="481"/>
+        <location filename="mainwindow.cpp" line="671"/>
         <source>No suitable files found to analyze!</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="568"/>
+        <location filename="mainwindow.cpp" line="770"/>
         <source>C/C++ Source</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="569"/>
+        <location filename="mainwindow.cpp" line="771"/>
         <source>Compile database</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="570"/>
+        <location filename="mainwindow.cpp" line="772"/>
         <source>Visual Studio</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="571"/>
+        <location filename="mainwindow.cpp" line="773"/>
         <source>Borland C++ Builder 6</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="574"/>
+        <location filename="mainwindow.cpp" line="776"/>
         <source>Select files to analyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="589"/>
+        <location filename="mainwindow.cpp" line="791"/>
         <source>Select directory to analyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="629"/>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select the configuration that will be analyzed</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="681"/>
+        <location filename="mainwindow.cpp" line="883"/>
         <source>Found project files from the directory.
 
 Do you want to proceed analysis without using any of these project files?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1114"/>
+        <location filename="mainwindow.cpp" line="1468"/>
         <source>Current results will be cleared.
 
 Opening a new XML file will clear current results.
@@ -1234,44 +1338,81 @@ Do you want to proceed?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1234"/>
+        <location filename="mainwindow.cpp" line="1592"/>
         <source>Analyzer is running.
 
 Do you want to stop the analysis and exit Cppcheck?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1300"/>
+        <location filename="mainwindow.cpp" line="1634"/>
+        <source>About</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1673"/>
         <source>XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1500"/>
+        <location filename="mainwindow.cpp" line="1713"/>
+        <source>Cannot generate a compliance report right now, an analysis must finish successfully. Try to reanalyze the code and ensure there are no critical errors.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1938"/>
         <source>Build dir &apos;%1&apos; does not exist, create it?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1523"/>
-        <source>Failed to import &apos;%1&apos;, analysis is stopped</source>
+        <location filename="mainwindow.cpp" line="1946"/>
+        <source>To check the project using addons, you need a build directory.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1978"/>
+        <source>Failed to open file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1981"/>
+        <source>Unknown project file format</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1984"/>
+        <source>Failed to import project file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2000"/>
+        <source>Failed to import &apos;%1&apos;: %2
+
+Analysis is stopped.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1547"/>
+        <location filename="mainwindow.cpp" line="2009"/>
+        <source>Failed to import &apos;%1&apos; (%2), analysis is stopped</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2033"/>
         <source>Project files (*.cppcheck)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1549"/>
+        <location filename="mainwindow.cpp" line="2035"/>
         <source>Select Project Filename</source>
         <translation>Selecteer project bestandsnaam</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1594"/>
+        <location filename="mainwindow.cpp" line="2081"/>
         <source>No project file loaded</source>
         <translation>Geen project bestand geladen</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1662"/>
+        <location filename="mainwindow.cpp" line="2163"/>
         <source>The project file
 
 %1
@@ -1287,30 +1428,72 @@ Kan niet worden gevonden!
 Wilt u het bestand van de onlangs gebruikte project verwijderen -lijst?</translation>
     </message>
     <message>
-        <source>Cppcheck GUI.
-
-Syntax:
-    cppcheck-gui [OPTIONS] [files or paths]
-
-Options:
-    -h, --help     Print this help
-    -p &lt;file&gt;      Open given project file and start checking it
-    -l &lt;file&gt;      Open given results xml file
-    -d &lt;directory&gt; Specify the directory that was checked to generate the results xml specified with -l
-    -v, --version  Show program version</source>
-        <translation type="obsolete">Cppcheck GUI.
-Syntax:
-....cppcheck-gui [Opies] [bestanden of paden]
-
-Opties:
-.....-h, --help     Print deze help
-.....-p &lt;bestand&gt;......Open project bestand en start de controle
-.....-l &lt;bestand&gt;......Open gegeven resultaten xml bestand
-.....-d &lt;map&gt; Geef de map aan wat gecontroleerd werd om de xml resultaten te genereren met gespecificeerde -l
-.....-v,.--versie  Toon versie van programma</translation>
+        <location filename="mainwindow.cpp" line="2325"/>
+        <source>Install</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2329"/>
+        <source>New version available: %1. %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2367"/>
+        <source>Show Mandatory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2368"/>
+        <source>Show Required</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2369"/>
+        <source>Show Advisory</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="main.cpp" line="106"/>
+        <location filename="mainwindow.cpp" line="2370"/>
+        <source>Show Document</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2387"/>
+        <source>Show L1</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2388"/>
+        <source>Show L2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2389"/>
+        <source>Show L3</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2396"/>
+        <source>Show style</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2397"/>
+        <source>Show portability</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2398"/>
+        <source>Show performance</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2399"/>
+        <source>Show information</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="main.cpp" line="100"/>
         <source>Cppcheck GUI.
 
 Syntax:
@@ -1340,7 +1523,7 @@ Options:
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="main.cpp" line="121"/>
+        <location filename="main.cpp" line="115"/>
         <source>Cppcheck GUI - Command line parameters</source>
         <translation>Cppcheck GUI - Command lijn parameters</translation>
     </message>
@@ -1373,7 +1556,7 @@ Options:
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="newsuppressiondialog.cpp" line="52"/>
+        <location filename="newsuppressiondialog.cpp" line="83"/>
         <source>Edit suppression</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1381,310 +1564,424 @@ Options:
 <context>
     <name>Platforms</name>
     <message>
-        <source>Built-in</source>
-        <translation type="obsolete">Gemaakt in</translation>
-    </message>
-    <message>
-        <location filename="platforms.cpp" line="37"/>
+        <location filename="platforms.cpp" line="38"/>
         <source>Native</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="38"/>
+        <location filename="platforms.cpp" line="39"/>
         <source>Unix 32-bit</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="39"/>
+        <location filename="platforms.cpp" line="40"/>
         <source>Unix 64-bit</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="40"/>
+        <location filename="platforms.cpp" line="41"/>
         <source>Windows 32-bit ANSI</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="41"/>
+        <location filename="platforms.cpp" line="42"/>
         <source>Windows 32-bit Unicode</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="42"/>
+        <location filename="platforms.cpp" line="43"/>
         <source>Windows 64-bit</source>
         <translation></translation>
     </message>
 </context>
 <context>
-    <name>Project</name>
+    <name>ProjectFile</name>
     <message>
-        <source>Cppcheck</source>
-        <translation type="obsolete">Cppcheck</translation>
+        <location filename="projectfile.ui" line="14"/>
+        <source>Project File</source>
+        <translation>Project Bestand</translation>
     </message>
     <message>
-        <source>Could not read the project file.</source>
-        <translation type="obsolete">Kon project bestand niet lezen.</translation>
+        <location filename="projectfile.ui" line="24"/>
+        <source>Paths and Defines</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Could not write the project file.</source>
-        <translation type="obsolete">Kon niet naar project bestand schrijven.</translation>
+        <location filename="projectfile.ui" line="30"/>
+        <source>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</source>
+        <oldsource>Import Project (Visual studio / compile database)</oldsource>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="231"/>
+        <source>Defines must be separated by a semicolon. Example: DEF1;DEF2=5;DEF3=int</source>
+        <oldsource>Defines must be separated by a semicolon &apos;;&apos;</oldsource>
+        <translation type="unfinished"></translation>
     </message>
-</context>
-<context>
-    <name>ProjectFile</name>
     <message>
-        <location filename="projectfiledialog.ui" line="14"/>
-        <source>Project File</source>
-        <translation>Project Bestand</translation>
+        <location filename="projectfile.ui" line="389"/>
+        <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Project</source>
-        <translation type="obsolete">Project</translation>
+        <location filename="projectfile.ui" line="655"/>
+        <source>If tags are added, you will be able to right click on warnings and set one of these tags. You can manually categorize warnings.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="24"/>
-        <source>Paths and Defines</source>
+        <location filename="projectfile.ui" line="665"/>
+        <source>Exclude source files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="30"/>
-        <source>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</source>
-        <oldsource>Import Project (Visual studio / compile database)</oldsource>
+        <location filename="projectfile.ui" line="676"/>
+        <source>Exclude folder...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="163"/>
-        <source>Defines must be separated by a semicolon. Example: DEF1;DEF2=5;DEF3=int</source>
-        <oldsource>Defines must be separated by a semicolon &apos;;&apos;</oldsource>
+        <location filename="projectfile.ui" line="683"/>
+        <source>Exclude file...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>&amp;Root:</source>
-        <oldsource>Root:</oldsource>
-        <translation type="obsolete">Hoofdmap:</translation>
+        <location filename="projectfile.ui" line="833"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="393"/>
-        <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
+        <location filename="projectfile.ui" line="841"/>
+        <source>2012</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="597"/>
-        <source>MISRA C 2012</source>
+        <location filename="projectfile.ui" line="846"/>
+        <location filename="projectfile.ui" line="914"/>
+        <source>2023</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="606"/>
-        <source>Misra rule texts</source>
+        <location filename="projectfile.ui" line="876"/>
+        <source>MISRA rule texts</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="613"/>
+        <location filename="projectfile.ui" line="883"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="620"/>
+        <location filename="projectfile.ui" line="890"/>
         <source>...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="69"/>
+        <location filename="projectfile.ui" line="73"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;You have a choice:&lt;/p&gt;&lt;p&gt; * Analyze all Debug and Release configurations&lt;/p&gt;&lt;p&gt; * Only analyze the first matching Debug configuration&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="60"/>
-        <location filename="projectfiledialog.ui" line="309"/>
+        <location filename="projectfile.ui" line="60"/>
+        <location filename="projectfile.ui" line="422"/>
+        <location filename="projectfile.ui" line="616"/>
         <source>Browse...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="72"/>
+        <location filename="projectfile.ui" line="76"/>
         <source>Analyze all Visual Studio configurations</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="86"/>
+        <location filename="projectfile.ui" line="113"/>
+        <source>Selected VS Configurations</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="147"/>
         <source>Paths:</source>
         <translation>Paden:</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="113"/>
-        <location filename="projectfiledialog.ui" line="228"/>
-        <location filename="projectfiledialog.ui" line="461"/>
+        <location filename="projectfile.ui" line="181"/>
+        <location filename="projectfile.ui" line="296"/>
         <source>Add...</source>
         <translation>Toevoegen...</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="120"/>
-        <location filename="projectfiledialog.ui" line="235"/>
-        <location filename="projectfiledialog.ui" line="468"/>
+        <location filename="projectfile.ui" line="188"/>
+        <location filename="projectfile.ui" line="303"/>
+        <location filename="projectfile.ui" line="690"/>
         <source>Edit</source>
         <translation>Bewerk</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="127"/>
-        <location filename="projectfiledialog.ui" line="242"/>
-        <location filename="projectfiledialog.ui" line="475"/>
-        <location filename="projectfiledialog.ui" line="518"/>
+        <location filename="projectfile.ui" line="195"/>
+        <location filename="projectfile.ui" line="310"/>
+        <location filename="projectfile.ui" line="697"/>
+        <location filename="projectfile.ui" line="740"/>
         <source>Remove</source>
         <translation>Verwijder</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="174"/>
+        <location filename="projectfile.ui" line="242"/>
         <source>Undefines:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="184"/>
+        <location filename="projectfile.ui" line="252"/>
         <source>Undefines must be separated by a semicolon. Example: UNDEF1;UNDEF2;UNDEF3</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="197"/>
+        <location filename="projectfile.ui" line="265"/>
         <source>Include Paths:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="331"/>
+        <location filename="projectfile.ui" line="362"/>
+        <source>Types and Functions</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="403"/>
+        <location filename="projectfile.ui" line="488"/>
         <source>Analysis</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="337"/>
-        <source>Check code in headers  (slower analysis, more results)</source>
+        <location filename="projectfile.ui" line="415"/>
+        <source>This is a workfolder that Cppcheck will use for various purposes.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="432"/>
+        <source>Parser</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="438"/>
+        <source>Cppcheck (built in)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="458"/>
+        <source>Check level</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="464"/>
+        <source>Reduced -- meant for usage where developer wants results directly. Limited and faster analysis with fewer results.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="471"/>
+        <source>Normal -- meant for normal analysis in CI. Analysis should finish in reasonable time.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="478"/>
+        <source>Exhaustive -- meant for nightly builds etc. Analysis time can be longer (10x slower than compilation is OK).</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="497"/>
+        <source>Check that each class has a safe public interface</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="513"/>
+        <source>Limit analysis</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="347"/>
-        <source>Check code in unused templates  (slower and less accurate analysis)</source>
+        <location filename="projectfile.ui" line="529"/>
+        <source>Check code in unused templates (should be ON normally, however in theory you can safely ignore warnings in unused templates)</source>
+        <oldsource>Check code in unused templates  (slower and less accurate analysis)</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="356"/>
+        <location filename="projectfile.ui" line="541"/>
         <source>Max CTU depth</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="450"/>
-        <source>Exclude source files in paths</source>
+        <location filename="projectfile.ui" line="607"/>
+        <source>Premium License</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="632"/>
-        <source>External tools</source>
+        <location filename="projectfile.ui" line="765"/>
+        <source>Enable inline suppressions</source>
+        <translation type="unfinished">Schakel inline suppressies in</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="851"/>
+        <source>2025</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="901"/>
+        <source>Misra C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="909"/>
+        <source>2008</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="937"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="946"/>
+        <source>CERT-INT35-C:  int precision (if size equals precision, you can leave empty)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="965"/>
+        <source>Autosar</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Includes</source>
-        <translation type="obsolete">Inclusief</translation>
+        <location filename="projectfile.ui" line="972"/>
+        <source>Safety profiles (defined in C++ core guidelines)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="988"/>
+        <source>Bug hunting</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Include directories:</source>
-        <translation type="obsolete">Include mappen:</translation>
+        <location filename="projectfile.ui" line="998"/>
+        <source>External tools</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="262"/>
+        <location filename="projectfile.ui" line="330"/>
         <source>Up</source>
         <translation>Omhoog</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="269"/>
+        <location filename="projectfile.ui" line="337"/>
         <source>Down</source>
         <translation>Omlaag</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="294"/>
-        <source>Checking</source>
+        <location filename="projectfile.ui" line="368"/>
+        <source>Platform</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="319"/>
-        <source>Platform</source>
+        <location filename="projectfile.ui" line="448"/>
+        <source>Clang (experimental)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="494"/>
+        <source>If you want to design your classes to be as flexible and robust as possible then the public interface must be very robust. Cppcheck will asumme that arguments can take *any* value.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="519"/>
+        <source>Check code in headers  (should be ON normally. if you want a limited quick analysis then turn this OFF)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="572"/>
+        <source>Max recursion in template instantiation</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="420"/>
+        <location filename="projectfile.ui" line="627"/>
         <source>Warning options</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="426"/>
+        <location filename="projectfile.ui" line="633"/>
         <source>Root path:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="438"/>
+        <location filename="projectfile.ui" line="639"/>
+        <source>Filepaths in warnings will be relative to this path</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="649"/>
         <source>Warning tags (separated by semicolon)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="300"/>
+        <location filename="projectfile.ui" line="409"/>
         <source>Cppcheck build dir (whole program analysis, incremental analysis, statistics, etc)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="384"/>
+        <location filename="projectfile.ui" line="380"/>
         <source>Libraries</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Exclude</source>
-        <translation type="obsolete">Exclusief</translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="500"/>
+        <location filename="projectfile.ui" line="722"/>
         <source>Suppressions</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="511"/>
+        <location filename="projectfile.ui" line="733"/>
         <source>Add</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="557"/>
-        <source>Addons and tools</source>
+        <location filename="projectfile.ui" line="786"/>
+        <location filename="projectfile.ui" line="792"/>
+        <source>Addons</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="563"/>
-        <source>Addons</source>
+        <location filename="projectfile.ui" line="798"/>
+        <source>Note: Addons require &lt;a href=&quot;https://www.python.org/&quot;&gt;Python&lt;/a&gt; being installed.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="569"/>
+        <location filename="projectfile.ui" line="808"/>
         <source>Y2038</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="576"/>
+        <location filename="projectfile.ui" line="815"/>
         <source>Thread safety</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="583"/>
+        <location filename="projectfile.ui" line="825"/>
         <source>Coding standards</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="590"/>
-        <source>Cert</source>
+        <location filename="projectfile.ui" line="958"/>
+        <source>Cert C++</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="645"/>
+        <location filename="projectfile.ui" line="982"/>
+        <source>Bug hunting (Premium)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="1011"/>
         <source>Clang analyzer</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="638"/>
+        <location filename="projectfile.ui" line="1004"/>
         <source>Clang-tidy</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="153"/>
+        <location filename="projectfile.ui" line="221"/>
         <source>Defines:</source>
         <translation>Omschrijft:</translation>
     </message>
@@ -1692,279 +1989,341 @@ Options:
 <context>
     <name>ProjectFileDialog</name>
     <message>
-        <location filename="projectfiledialog.cpp" line="71"/>
+        <location filename="projectfiledialog.cpp" line="138"/>
         <source>Project file: %1</source>
         <translation>Project Bestand %1</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="409"/>
+        <location filename="projectfiledialog.cpp" line="590"/>
         <source>Select Cppcheck build dir</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="637"/>
+        <location filename="projectfiledialog.cpp" line="851"/>
         <source>Select include directory</source>
         <translation>Selecteer include map</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="617"/>
+        <location filename="projectfiledialog.cpp" line="831"/>
         <source>Select a directory to check</source>
         <translation>Selecteer een map om te controleren</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="305"/>
-        <source>(no rule texts file)</source>
+        <location filename="projectfiledialog.cpp" line="396"/>
+        <source>Note: Open source Cppcheck does not fully implement Misra C 2012</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="311"/>
+        <location filename="projectfiledialog.cpp" line="461"/>
         <source>Clang-tidy (not found)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="445"/>
+        <location filename="projectfiledialog.cpp" line="629"/>
         <source>Visual Studio</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="446"/>
+        <location filename="projectfiledialog.cpp" line="630"/>
         <source>Compile database</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="447"/>
+        <location filename="projectfiledialog.cpp" line="631"/>
         <source>Borland C++ Builder 6</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="448"/>
+        <location filename="projectfiledialog.cpp" line="632"/>
         <source>Import Project</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="657"/>
+        <location filename="projectfiledialog.cpp" line="871"/>
         <source>Select directory to ignore</source>
         <translation>Selecteer een map om te negeren</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="742"/>
-        <source>Select MISRA rule texts file</source>
+        <location filename="projectfiledialog.cpp" line="879"/>
+        <source>Source files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="742"/>
-        <source>Misra rule texts file (%1)</source>
+        <location filename="projectfiledialog.cpp" line="880"/>
+        <source>All files</source>
         <translation type="unfinished"></translation>
     </message>
-</context>
-<context>
-    <name>QDialogButtonBox</name>
     <message>
-        <location filename="translationhandler.cpp" line="34"/>
-        <source>OK</source>
+        <location filename="projectfiledialog.cpp" line="881"/>
+        <source>Exclude file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="35"/>
-        <source>Cancel</source>
-        <translation>Annuleer</translation>
-    </message>
-    <message>
-        <location filename="translationhandler.cpp" line="36"/>
-        <source>Close</source>
-        <translation>Sluit</translation>
+        <location filename="projectfiledialog.cpp" line="964"/>
+        <source>Select MISRA rule texts file</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="37"/>
-        <source>Save</source>
-        <translation>Opslaan</translation>
+        <location filename="projectfiledialog.cpp" line="966"/>
+        <source>MISRA rule texts file (%1)</source>
+        <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>QObject</name>
     <message>
-        <location filename="translationhandler.cpp" line="104"/>
+        <location filename="translationhandler.cpp" line="91"/>
         <source>Unknown language specified!</source>
         <translation>Onbekende taal gekozen!</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="132"/>
+        <location filename="translationhandler.cpp" line="117"/>
         <source>Language file %1 not found!</source>
         <oldsource>Language file %1.qm not found!</oldsource>
         <translation>Kon het taalbestand niet vinden: %1!</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="138"/>
+        <location filename="translationhandler.cpp" line="122"/>
         <source>Failed to load translation for language %1 from file %2</source>
         <oldsource>Failed to load translation for language %1 from file %2.qm</oldsource>
         <translation>Kon de vertaling voor taal %1 in bestand %2 niet laden</translation>
     </message>
     <message>
-        <location filename="cppchecklibrarydata.cpp" line="33"/>
+        <location filename="cppchecklibrarydata.cpp" line="38"/>
         <source>line %1: Unhandled element %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="226"/>
+        <location filename="cppchecklibrarydata.cpp" line="43"/>
+        <source>line %1: Mandatory attribute &apos;%2&apos; missing in &apos;%3&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="284"/>
         <source> (Not found)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="69"/>
+        <location filename="codeeditstylecontrols.cpp" line="76"/>
         <source>Thin</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="71"/>
+        <location filename="codeeditstylecontrols.cpp" line="78"/>
         <source>ExtraLight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="73"/>
+        <location filename="codeeditstylecontrols.cpp" line="80"/>
         <source>Light</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="75"/>
+        <location filename="codeeditstylecontrols.cpp" line="82"/>
         <source>Normal</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="77"/>
+        <location filename="codeeditstylecontrols.cpp" line="84"/>
         <source>Medium</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="79"/>
+        <location filename="codeeditstylecontrols.cpp" line="86"/>
         <source>DemiBold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="81"/>
+        <location filename="codeeditstylecontrols.cpp" line="88"/>
         <source>Bold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="83"/>
+        <location filename="codeeditstylecontrols.cpp" line="90"/>
         <source>ExtraBold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="85"/>
+        <location filename="codeeditstylecontrols.cpp" line="92"/>
         <source>Black</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="69"/>
+        <location filename="codeeditstyledialog.cpp" line="80"/>
         <source>Editor Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="72"/>
+        <location filename="codeeditstyledialog.cpp" line="83"/>
         <source>Editor Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="75"/>
+        <location filename="codeeditstyledialog.cpp" line="86"/>
         <source>Highlight Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="78"/>
+        <location filename="codeeditstyledialog.cpp" line="89"/>
         <source>Line Number Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="81"/>
+        <location filename="codeeditstyledialog.cpp" line="92"/>
         <source>Line Number Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="84"/>
+        <location filename="codeeditstyledialog.cpp" line="95"/>
         <source>Keyword Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="87"/>
+        <location filename="codeeditstyledialog.cpp" line="98"/>
         <source>Keyword Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="90"/>
+        <location filename="codeeditstyledialog.cpp" line="101"/>
         <source>Class Foreground Color</source>
         <oldsource>Class ForegroundColor</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="93"/>
+        <location filename="codeeditstyledialog.cpp" line="104"/>
         <source>Class Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="96"/>
+        <location filename="codeeditstyledialog.cpp" line="107"/>
         <source>Quote Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="99"/>
+        <location filename="codeeditstyledialog.cpp" line="110"/>
         <source>Quote Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="102"/>
+        <location filename="codeeditstyledialog.cpp" line="113"/>
         <source>Comment Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="105"/>
+        <location filename="codeeditstyledialog.cpp" line="116"/>
         <source>Comment Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="108"/>
+        <location filename="codeeditstyledialog.cpp" line="119"/>
         <source>Symbol Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="111"/>
+        <location filename="codeeditstyledialog.cpp" line="122"/>
         <source>Symbol Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="114"/>
+        <location filename="codeeditstyledialog.cpp" line="125"/>
         <source>Symbol Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="130"/>
+        <location filename="codeeditstyledialog.cpp" line="141"/>
         <source>Set to Default Light</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="132"/>
+        <location filename="codeeditstyledialog.cpp" line="143"/>
         <source>Set to Default Dark</source>
         <translation type="unfinished"></translation>
     </message>
+    <message>
+        <location filename="resultstree.cpp" line="113"/>
+        <source>File</source>
+        <translation type="unfinished">Bestand</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="114"/>
+        <source>Line</source>
+        <translation type="unfinished">Regel</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="115"/>
+        <source>Severity</source>
+        <translation type="unfinished">Ernst</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="116"/>
+        <source>Classification</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="117"/>
+        <source>Level</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="118"/>
+        <source>Inconclusive</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="119"/>
+        <source>Summary</source>
+        <translation type="unfinished">Overzicht</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="120"/>
+        <source>Id</source>
+        <translation type="unfinished">Id</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="121"/>
+        <source>Guideline</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="122"/>
+        <source>Rule</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="123"/>
+        <source>Since date</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="124"/>
+        <source>Tags</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="125"/>
+        <source>CWE</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>QPlatformTheme</name>
     <message>
-        <location filename="translationhandler.cpp" line="39"/>
+        <location filename="translationhandler.cpp" line="41"/>
         <source>OK</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="40"/>
+        <location filename="translationhandler.cpp" line="42"/>
         <source>Cancel</source>
         <translation>Annuleer</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="41"/>
+        <location filename="translationhandler.cpp" line="43"/>
         <source>Close</source>
         <translation>Sluit</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="42"/>
+        <location filename="translationhandler.cpp" line="44"/>
         <source>Save</source>
         <translation>Opslaan</translation>
     </message>
@@ -1972,129 +2331,112 @@ Options:
 <context>
     <name>ResultsTree</name>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>File</source>
-        <translation>Bestand</translation>
+        <translation type="vanished">Bestand</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Severity</source>
-        <translation>Ernst</translation>
+        <translation type="vanished">Ernst</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Line</source>
-        <translation>Regel</translation>
+        <translation type="vanished">Regel</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Summary</source>
-        <translation>Overzicht</translation>
+        <translation type="vanished">Overzicht</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="136"/>
         <source>Undefined file</source>
-        <translation>Niet gedefinieerd bestand</translation>
+        <translation type="vanished">Niet gedefinieerd bestand</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="614"/>
+        <location filename="resultstree.cpp" line="668"/>
         <source>Copy</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="797"/>
+        <location filename="resultstree.cpp" line="836"/>
         <source>Could not find file:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="801"/>
+        <location filename="resultstree.cpp" line="840"/>
         <source>Please select the folder &apos;%1&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="802"/>
+        <location filename="resultstree.cpp" line="841"/>
         <source>Select Directory &apos;%1&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="804"/>
+        <location filename="resultstree.cpp" line="843"/>
         <source>Please select the directory where file is located.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>[Inconclusive]</source>
-        <translation type="obsolete">[Onduidelijk]</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="312"/>
+        <location filename="resultstree.cpp" line="373"/>
         <source>debug</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="249"/>
+        <location filename="resultstree.cpp" line="307"/>
         <source>note</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="613"/>
-        <source>Recheck</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <source>Copy filename</source>
-        <translation type="obsolete">Kopier bestandsnaam</translation>
-    </message>
-    <message>
-        <source>Copy full path</source>
-        <translation type="obsolete">Kopieer volledig pad</translation>
+        <source>Hide</source>
+        <translation type="vanished">Verberg</translation>
     </message>
     <message>
-        <source>Copy message</source>
-        <translation type="obsolete">Kopieer bericht</translation>
+        <location filename="resultstree.cpp" line="670"/>
+        <source>Hide all with id</source>
+        <translation>Verberg alles met id</translation>
     </message>
     <message>
-        <source>Copy message id</source>
-        <translation type="obsolete">Kopieer bericht id</translation>
+        <location filename="resultstree.cpp" line="692"/>
+        <source>Suppress selected id(s)</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="615"/>
-        <source>Hide</source>
-        <translation>Verberg</translation>
+        <location filename="resultstree.cpp" line="671"/>
+        <source>Open containing folder</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="616"/>
-        <source>Hide all with id</source>
-        <translation>Verberg alles met id</translation>
+        <location filename="resultstree.cpp" line="376"/>
+        <source>internal</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="617"/>
-        <source>Suppress selected id(s)</source>
+        <location filename="resultstree.cpp" line="667"/>
+        <source>Recheck %1 file(s)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="618"/>
-        <source>Open containing folder</source>
+        <location filename="resultstree.cpp" line="669"/>
+        <source>Hide %1 result(s)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="648"/>
-        <location filename="resultstree.cpp" line="1343"/>
+        <location filename="resultstree.cpp" line="712"/>
         <source>Tag</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="650"/>
+        <location filename="resultstree.cpp" line="714"/>
         <source>No tag</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="693"/>
-        <location filename="resultstree.cpp" line="707"/>
+        <location filename="resultstree.cpp" line="744"/>
+        <location filename="resultstree.cpp" line="758"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="694"/>
+        <location filename="resultstree.cpp" line="745"/>
         <source>No editor application configured.
 
 Configure the editor application for Cppcheck in preferences/Applications.</source>
@@ -2104,7 +2446,7 @@ Configure the editor application for Cppcheck in preferences/Applications.</sour
 Configureer de bewerker toepassing voor cppcheck in voorkeuren/Applicaties.</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="708"/>
+        <location filename="resultstree.cpp" line="759"/>
         <source>No default editor application selected.
 
 Please select the default editor application in preferences/Applications.</source>
@@ -2112,12 +2454,12 @@ Please select the default editor application in preferences/Applications.</sourc
 Selecteer de standaard bewerker in voorkeuren/Applicaties.</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="737"/>
+        <location filename="resultstree.cpp" line="779"/>
         <source>Could not find the file!</source>
         <translation>Kon het bestand niet vinden!</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="783"/>
+        <location filename="resultstree.cpp" line="822"/>
         <source>Could not start %1
 
 Please check the application path and parameters are correct.</source>
@@ -2126,59 +2468,41 @@ Please check the application path and parameters are correct.</source>
 Gelieve te controleren of de het pad en de parameters correct zijn.</translation>
     </message>
     <message>
-        <source>Could not find file:
-%1
-Please select the directory where file is located.</source>
-        <translation type="obsolete">%1
-Selecteer de map waarin het bestand zich bevindt.</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="805"/>
+        <location filename="resultstree.cpp" line="844"/>
         <source>Select Directory</source>
         <translation>Selecteer map</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Id</source>
-        <translation>Id</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="1343"/>
-        <source>Inconclusive</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="1343"/>
-        <source>Since date</source>
-        <translation type="unfinished"></translation>
+        <translation type="vanished">Id</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="294"/>
+        <location filename="resultstree.cpp" line="355"/>
         <source>style</source>
         <translation>Stijlfouten</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="297"/>
+        <location filename="resultstree.cpp" line="358"/>
         <source>error</source>
         <translation>Fouten</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="300"/>
+        <location filename="resultstree.cpp" line="361"/>
         <source>warning</source>
         <translation>Waarschuwing</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="303"/>
+        <location filename="resultstree.cpp" line="364"/>
         <source>performance</source>
         <translation>Presentatie</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="306"/>
+        <location filename="resultstree.cpp" line="367"/>
         <source>portability</source>
         <translation>Portabiliteit</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="309"/>
+        <location filename="resultstree.cpp" line="370"/>
         <source>information</source>
         <translation>Informatie</translation>
     </message>
@@ -2186,90 +2510,102 @@ Selecteer de map waarin het bestand zich bevindt.</translation>
 <context>
     <name>ResultsView</name>
     <message>
-        <location filename="resultsview.cpp" line="201"/>
+        <location filename="resultsview.cpp" line="255"/>
         <source>Print Report</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="220"/>
+        <location filename="resultsview.cpp" line="274"/>
         <source>No errors found, nothing to print.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="264"/>
+        <location filename="resultsview.cpp" line="326"/>
         <source>%p% (%1 of %2 files checked)</source>
         <translation>%p% (%1 van %2 bestanden gecontroleerd)</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="277"/>
-        <location filename="resultsview.cpp" line="288"/>
+        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="361"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="278"/>
+        <location filename="resultsview.cpp" line="351"/>
         <source>No errors found.</source>
         <translation>Geen fouten gevonden.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="285"/>
+        <location filename="resultsview.cpp" line="358"/>
         <source>Errors were found, but they are configured to be hidden.
 To toggle what kind of errors are shown, open view menu.</source>
         <translation>Fouten werden gevonden, maar volgens de configuratie zijn deze verborgen.
 Gebruik het uitzicht menu om te selecteren welke fouten getoond worden.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="331"/>
-        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="421"/>
         <source>Failed to read the report.</source>
         <translation>Kon rapport niet lezen.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="338"/>
+        <location filename="resultsview.cpp" line="409"/>
         <source>XML format version 1 is no longer supported.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Summary</source>
-        <translation type="obsolete">Overzicht</translation>
-    </message>
-    <message>
-        <source>Message</source>
-        <translation type="obsolete">Bericht</translation>
-    </message>
-    <message>
-        <location filename="resultsview.cpp" line="399"/>
+        <location filename="resultsview.cpp" line="460"/>
         <source>First included by</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="465"/>
         <source>Id</source>
         <translation>Id</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="471"/>
+        <location filename="resultsview.cpp" line="539"/>
         <source>Clear Log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="472"/>
+        <location filename="resultsview.cpp" line="540"/>
         <source>Copy this Log entry</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="473"/>
+        <location filename="resultsview.cpp" line="541"/>
         <source>Copy complete Log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="159"/>
-        <source>No errors found, nothing to save.</source>
-        <translation>Geen fouten gevonden; geen data om op te slaan.</translation>
+        <location filename="resultsview.cpp" line="549"/>
+        <source>Analysis was stopped</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="563"/>
+        <source>There was a critical error with id &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="565"/>
+        <source>when checking %1</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="567"/>
+        <source>when checking a file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="568"/>
+        <source>Analysis was aborted.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="183"/>
-        <location filename="resultsview.cpp" line="191"/>
+        <location filename="resultsview.cpp" line="237"/>
+        <location filename="resultsview.cpp" line="245"/>
         <source>Failed to save the report.</source>
         <translation>Kon het rapport niet opslaan.</translation>
     </message>
@@ -2279,12 +2615,17 @@ Gebruik het uitzicht menu om te selecteren welke fouten getoond worden.</transla
         <translation>Resultaten</translation>
     </message>
     <message>
-        <location filename="resultsview.ui" line="82"/>
+        <location filename="resultsview.ui" line="60"/>
+        <source>Critical errors</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.ui" line="92"/>
         <source>Analysis Log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.ui" line="104"/>
+        <location filename="resultsview.ui" line="114"/>
         <source>Warning Details</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2330,11 +2671,7 @@ Gebruik het uitzicht menu om te selecteren welke fouten getoond worden.</transla
         <translation>Algemeen</translation>
     </message>
     <message>
-        <source>Include paths:</source>
-        <translation type="obsolete">Include paden:</translation>
-    </message>
-    <message>
-        <location filename="settings.ui" line="195"/>
+        <location filename="settings.ui" line="196"/>
         <source>Add...</source>
         <translation>Toevoegen...</translation>
     </message>
@@ -2344,500 +2681,503 @@ Gebruik het uitzicht menu om te selecteren welke fouten getoond worden.</transla
         <translation>Aantal threads: </translation>
     </message>
     <message>
-        <location filename="settings.ui" line="85"/>
         <source>Ideal count:</source>
-        <translation>Ideale telling:</translation>
+        <translation type="vanished">Ideale telling:</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="114"/>
+        <location filename="settings.ui" line="108"/>
         <source>Force checking all #ifdef configurations</source>
         <oldsource>Check all #ifdef configurations</oldsource>
         <translation>Controleer alle #ifdef combinaties</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="121"/>
+        <location filename="settings.ui" line="115"/>
         <source>Show full path of files</source>
         <translation>Toon het volledige pad van bestanden</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="128"/>
+        <location filename="settings.ui" line="122"/>
         <source>Show &quot;No errors found&quot; message when no errors found</source>
         <translation>Toon &quot;Geen fouten gevonden&quot; indien geen fouten gevonden werden</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="135"/>
+        <location filename="settings.ui" line="129"/>
         <source>Display error Id in column &quot;Id&quot;</source>
         <translation>Toon fout ld in kolom &quot;Id&quot;</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="142"/>
+        <location filename="settings.ui" line="136"/>
         <source>Enable inline suppressions</source>
         <translation>Schakel inline suppressies in</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="149"/>
+        <location filename="settings.ui" line="143"/>
         <source>Check for inconclusive errors also</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="156"/>
+        <location filename="settings.ui" line="150"/>
         <source>Show statistics on check completion</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="176"/>
+        <location filename="settings.ui" line="157"/>
+        <source>Check for updates</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="177"/>
         <source>Show internal warnings in log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="287"/>
+        <location filename="settings.ui" line="288"/>
         <source>Addons</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="293"/>
+        <location filename="settings.ui" line="294"/>
         <source>Python binary (leave this empty to use python in the PATH)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="302"/>
-        <location filename="settings.ui" line="334"/>
-        <location filename="settings.ui" line="379"/>
+        <location filename="settings.ui" line="305"/>
+        <location filename="settings.ui" line="346"/>
+        <location filename="settings.ui" line="391"/>
         <source>...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="312"/>
-        <source>Misra addon</source>
+        <location filename="settings.ui" line="324"/>
+        <source>MISRA addon</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="320"/>
-        <source>Misra rule texts file</source>
+        <location filename="settings.ui" line="332"/>
+        <source>MISRA rule texts file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="327"/>
+        <location filename="settings.ui" line="339"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="360"/>
+        <location filename="settings.ui" line="372"/>
         <source>Clang</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="366"/>
+        <location filename="settings.ui" line="378"/>
         <source>Clang path (leave empty to use system PATH)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="389"/>
+        <location filename="settings.ui" line="401"/>
         <source>Visual Studio headers</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="395"/>
+        <location filename="settings.ui" line="407"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Paths to Visual Studio headers, separated by semicolon &apos;;&apos;.&lt;/p&gt;&lt;p&gt;You can open a Visual Studio command prompt, write &amp;quot;SET INCLUDE&amp;quot;. Then copy/paste the paths.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="425"/>
+        <location filename="settings.ui" line="437"/>
         <source>Code Editor</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="431"/>
+        <location filename="settings.ui" line="443"/>
         <source>Code Editor Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="437"/>
+        <location filename="settings.ui" line="449"/>
         <source>System Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="444"/>
+        <location filename="settings.ui" line="456"/>
         <source>Default Light Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="451"/>
+        <location filename="settings.ui" line="463"/>
         <source>Default Dark Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="460"/>
+        <location filename="settings.ui" line="472"/>
         <source>Custom</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Paths</source>
-        <translation type="obsolete">Paden</translation>
-    </message>
-    <message>
-        <source>Edit</source>
-        <translation type="obsolete">Bewerk</translation>
-    </message>
-    <message>
-        <location filename="settings.ui" line="209"/>
+        <location filename="settings.ui" line="210"/>
         <source>Remove</source>
         <translation>Verwijder</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="184"/>
+        <location filename="settings.ui" line="79"/>
+        <source>Max count:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="185"/>
         <source>Applications</source>
         <translation>Applicaties</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="202"/>
-        <location filename="settings.ui" line="467"/>
+        <location filename="settings.ui" line="203"/>
+        <location filename="settings.ui" line="479"/>
         <source>Edit...</source>
         <translation>Bewerk...</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="216"/>
+        <location filename="settings.ui" line="217"/>
         <source>Set as default</source>
         <translation>Instellen als standaard</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="239"/>
+        <location filename="settings.ui" line="240"/>
         <source>Reports</source>
         <translation>Rapporten</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="245"/>
+        <location filename="settings.ui" line="246"/>
         <source>Save all errors when creating report</source>
         <translation>Alle fouten opslaan</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="252"/>
+        <location filename="settings.ui" line="253"/>
         <source>Save full path to files in reports</source>
         <translation>Volledig pad opslaan</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="273"/>
+        <location filename="settings.ui" line="274"/>
         <source>Language</source>
         <translation>Taal</translation>
     </message>
-    <message>
-        <source>Advanced</source>
-        <translation type="obsolete">Geavanceerd</translation>
-    </message>
-    <message>
-        <source>&amp;Show inconclusive errors</source>
-        <translation type="obsolete">&amp;Toon onduidelijke fouten</translation>
-    </message>
-    <message>
-        <source>S&amp;how internal warnings in log</source>
-        <translation type="obsolete">T&amp;oon interne waarschuwingen in log</translation>
-    </message>
 </context>
 <context>
     <name>SettingsDialog</name>
     <message>
-        <location filename="settingsdialog.cpp" line="100"/>
-        <source>N/A</source>
-        <translation></translation>
+        <location filename="settingsdialog.cpp" line="232"/>
+        <source>The executable file &quot;%1&quot; is not available</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="200"/>
+        <location filename="settingsdialog.cpp" line="243"/>
         <source>Add a new application</source>
         <translation>Nieuwe applicatie toevoegen</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="233"/>
+        <location filename="settingsdialog.cpp" line="273"/>
         <source>Modify an application</source>
         <translation>Applicatie wijzigen</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="238"/>
+        <location filename="settingsdialog.cpp" line="278"/>
         <source> [Default]</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="263"/>
+        <location filename="settingsdialog.cpp" line="303"/>
         <source>[Default]</source>
         <translation>[Standaard]</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="318"/>
+        <location filename="settingsdialog.cpp" line="358"/>
         <source>Select python binary</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="325"/>
+        <location filename="settingsdialog.cpp" line="365"/>
         <source>Select MISRA File</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="356"/>
+        <location filename="settingsdialog.cpp" line="396"/>
         <source>Select clang path</source>
         <translation type="unfinished"></translation>
     </message>
-    <message>
-        <source>Select include directory</source>
-        <translation type="obsolete">Selecteer include map</translation>
-    </message>
 </context>
 <context>
     <name>StatsDialog</name>
     <message>
-        <location filename="stats.ui" line="14"/>
-        <location filename="stats.ui" line="248"/>
-        <location filename="statsdialog.cpp" line="137"/>
-        <location filename="statsdialog.cpp" line="184"/>
+        <location filename="statsdialog.ui" line="14"/>
+        <location filename="statsdialog.ui" line="248"/>
+        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="230"/>
         <source>Statistics</source>
         <translation>Statistieken</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="27"/>
-        <location filename="statsdialog.cpp" line="175"/>
+        <location filename="statsdialog.ui" line="27"/>
+        <location filename="statsdialog.cpp" line="221"/>
         <source>Project</source>
         <translation>Project</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="33"/>
+        <location filename="statsdialog.ui" line="33"/>
         <source>Project:</source>
         <translation>Project:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="53"/>
+        <location filename="statsdialog.ui" line="53"/>
         <source>Paths:</source>
         <translation>Paden:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="85"/>
+        <location filename="statsdialog.ui" line="85"/>
         <source>Include paths:</source>
         <translation>Bevat paden:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="108"/>
+        <location filename="statsdialog.ui" line="108"/>
         <source>Defines:</source>
         <translation>Omschrijft:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="131"/>
+        <location filename="statsdialog.ui" line="131"/>
         <source>Undefines:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="165"/>
-        <location filename="statsdialog.cpp" line="180"/>
+        <location filename="statsdialog.ui" line="165"/>
+        <location filename="statsdialog.cpp" line="226"/>
         <source>Previous Scan</source>
         <translation>Vorige scan</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="171"/>
+        <location filename="statsdialog.ui" line="171"/>
         <source>Path Selected:</source>
         <translation>Pad Geselekteerd:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="181"/>
+        <location filename="statsdialog.ui" line="181"/>
         <source>Number of Files Scanned:</source>
         <translation>Aantal bestanden gescanned:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="201"/>
+        <location filename="statsdialog.ui" line="201"/>
         <source>Scan Duration:</source>
         <translation>Scan tijd:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="256"/>
+        <location filename="statsdialog.ui" line="254"/>
         <source>Errors:</source>
         <translation>Fouten:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="274"/>
+        <location filename="statsdialog.ui" line="271"/>
         <source>Warnings:</source>
         <translation>Waarschuwingen:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="292"/>
+        <location filename="statsdialog.ui" line="288"/>
         <source>Stylistic warnings:</source>
         <translation>Stilistisch waarschuwingen:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="310"/>
+        <location filename="statsdialog.ui" line="305"/>
         <source>Portability warnings:</source>
         <translation>Portabiliteit waarschuwingen:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="328"/>
+        <location filename="statsdialog.ui" line="322"/>
         <source>Performance issues:</source>
         <translation>Presentatie problemen:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="346"/>
+        <location filename="statsdialog.ui" line="339"/>
         <source>Information messages:</source>
         <translation>Informatie bericht:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="363"/>
+        <location filename="statsdialog.ui" line="356"/>
+        <source>Active checkers:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="374"/>
+        <source>Checkers</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="399"/>
         <source>History</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="369"/>
+        <location filename="statsdialog.ui" line="405"/>
         <source>File:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="407"/>
+        <location filename="statsdialog.ui" line="443"/>
         <source>Copy to Clipboard</source>
         <translation>Kopieer naar Clipbord</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="414"/>
+        <location filename="statsdialog.ui" line="450"/>
         <source>Pdf Export</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="113"/>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>1 day</source>
         <translation>1 dag</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="113"/>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>%1 days</source>
         <translation>%1 dagen</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="115"/>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>1 hour</source>
         <translation>1 uur</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="115"/>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>%1 hours</source>
         <translation>%1 uren</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="117"/>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>1 minute</source>
         <translation>1 minuut</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="117"/>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>%1 minutes</source>
         <translation>%1 minuten</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="119"/>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>1 second</source>
         <translation>1 seconde</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="119"/>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>%1 seconds</source>
         <translation>%1 secondes</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="123"/>
+        <location filename="statsdialog.cpp" line="169"/>
         <source>0.%1 seconds</source>
         <translation>0.%1 secondes</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="125"/>
+        <location filename="statsdialog.cpp" line="171"/>
         <source> and </source>
         <translation> en </translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="152"/>
+        <location filename="statsdialog.cpp" line="198"/>
         <source>Export PDF</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="174"/>
+        <location filename="statsdialog.cpp" line="220"/>
         <source>Project Settings</source>
         <translation>Project instellingen</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="176"/>
+        <location filename="statsdialog.cpp" line="222"/>
         <source>Paths</source>
         <translation>Paden</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="177"/>
+        <location filename="statsdialog.cpp" line="223"/>
         <source>Include paths</source>
         <translation>Bevat paden</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="178"/>
+        <location filename="statsdialog.cpp" line="224"/>
         <source>Defines</source>
         <translation>Omschrijft</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="179"/>
+        <location filename="statsdialog.cpp" line="225"/>
         <source>Undefines</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="181"/>
+        <location filename="statsdialog.cpp" line="227"/>
         <source>Path selected</source>
         <translation>Pad Geselekteerd</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="182"/>
+        <location filename="statsdialog.cpp" line="228"/>
         <source>Number of files scanned</source>
         <translation>Aantal bestanden gescanned</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="229"/>
         <source>Scan duration</source>
         <translation>Scan tijd</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="139"/>
         <location filename="statsdialog.cpp" line="185"/>
+        <location filename="statsdialog.cpp" line="231"/>
         <source>Errors</source>
         <translation>Fouten</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="65"/>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>File: </source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="65"/>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>No cppcheck build dir</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="141"/>
-        <location filename="statsdialog.cpp" line="186"/>
+        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="232"/>
         <source>Warnings</source>
         <translation>Waarschuwingen</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="143"/>
-        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="233"/>
         <source>Style warnings</source>
         <translation>Stijl waarschuwingen</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="145"/>
-        <location filename="statsdialog.cpp" line="188"/>
+        <location filename="statsdialog.cpp" line="191"/>
+        <location filename="statsdialog.cpp" line="234"/>
         <source>Portability warnings</source>
         <translation>Portabiliteit waarschuwingen</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="147"/>
-        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="193"/>
+        <location filename="statsdialog.cpp" line="235"/>
         <source>Performance warnings</source>
         <translation>Presentatie waarschuwingen</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="149"/>
-        <location filename="statsdialog.cpp" line="190"/>
+        <location filename="statsdialog.cpp" line="195"/>
+        <location filename="statsdialog.cpp" line="236"/>
         <source>Information messages</source>
         <translation>Informatie bericht</translation>
     </message>
 </context>
+<context>
+    <name>ThreadDetails</name>
+    <message>
+        <location filename="threaddetails.ui" line="14"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>ThreadResult</name>
     <message>
-        <location filename="threadresult.cpp" line="54"/>
+        <location filename="threadresult.cpp" line="47"/>
         <source>%1 of %2 files checked</source>
         <translation>%1 van %2 bestanden gecontroleerd</translation>
     </message>
@@ -2845,7 +3185,7 @@ Gebruik het uitzicht menu om te selecteren welke fouten getoond worden.</transla
 <context>
     <name>TranslationHandler</name>
     <message>
-        <location filename="translationhandler.cpp" line="145"/>
+        <location filename="translationhandler.cpp" line="130"/>
         <source>Failed to change the user interface language:
 
 %1
@@ -2858,7 +3198,7 @@ The user interface language has been reset to English. Open the Preferences-dial
 De gebruikerstaal is gereset naar Engels. Open het dialoogvenster om een van de beschikbare talen te selecteren.</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="151"/>
+        <location filename="translationhandler.cpp" line="136"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
@@ -2866,7 +3206,7 @@ De gebruikerstaal is gereset naar Engels. Open het dialoogvenster om een van de
 <context>
     <name>TxtReport</name>
     <message>
-        <location filename="txtreport.cpp" line="73"/>
+        <location filename="txtreport.cpp" line="74"/>
         <source>inconclusive</source>
         <translation>Onduidelijk</translation>
     </message>
@@ -2874,12 +3214,12 @@ De gebruikerstaal is gereset naar Engels. Open het dialoogvenster om een van de
 <context>
     <name>toFilterString</name>
     <message>
-        <location filename="common.cpp" line="52"/>
+        <location filename="common.cpp" line="58"/>
         <source>All supported files (%1)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="common.cpp" line="57"/>
+        <location filename="common.cpp" line="63"/>
         <source>All files (%1)</source>
         <translation type="unfinished"></translation>
     </message>
diff --git a/gui/cppcheck_ru.ts b/gui/cppcheck_ru.ts
index 266c414e379..124e4d783aa 100644
--- a/gui/cppcheck_ru.ts
+++ b/gui/cppcheck_ru.ts
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!DOCTYPE TS>
-<TS version="2.1" language="ru_RU" sourcelanguage="ru_RU">
+<TS version="2.1" language="ru_RU">
 <context>
     <name>About</name>
     <message>
@@ -20,9 +20,9 @@
     </message>
     <message>
         <location filename="about.ui" line="81"/>
-        <source>Copyright © 2007-2019 Cppcheck team.</source>
-        <oldsource>Copyright © 2007-2018 Cppcheck team.</oldsource>
-        <translation type="unfinished"></translation>
+        <source>Copyright © 2007-%1 Cppcheck team.</source>
+        <oldsource>Copyright © 2007-2021 Cppcheck team.</oldsource>
+        <translation type="unfinished">Copyright © 2007-2021 Cppcheck team.</translation>
     </message>
     <message>
         <location filename="about.ui" line="91"/>
@@ -38,24 +38,20 @@ of the GNU General Public License version 3</source>
     </message>
     <message>
         <location filename="about.ui" line="115"/>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
-&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul&gt;
-&lt;li&gt;tinyxml2&lt;/li&gt;
-&lt;li&gt;picojson&lt;/li&gt;
-&lt;li&gt;pcre&lt;/li&gt;
-&lt;li&gt;qt&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PCRE&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PicoJSON&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;TinyXML2&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Boost&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <oldsource>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;pcre&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;picojson&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;tinyxml2&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</oldsource>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>ApplicationDialog</name>
     <message>
-        <location filename="application.ui" line="23"/>
+        <location filename="applicationdialog.ui" line="23"/>
         <source>Add an application</source>
         <translation>Добавление приложения</translation>
     </message>
     <message>
-        <location filename="application.ui" line="41"/>
+        <location filename="applicationdialog.ui" line="41"/>
         <source>Here you can add an application that can open error files. Specify a name for the application, the application executable and command line parameters for the application.
 
 The following texts in parameters are replaced with appropriate values when application is executed:
@@ -80,67 +76,159 @@ Parameters: -l(line) (file)</source>
 Параметры: -l(line) (file)</translation>
     </message>
     <message>
-        <location filename="application.ui" line="76"/>
+        <location filename="applicationdialog.ui" line="76"/>
         <source>&amp;Name:</source>
         <translation>&amp;Название:</translation>
     </message>
     <message>
-        <location filename="application.ui" line="86"/>
+        <location filename="applicationdialog.ui" line="86"/>
         <source>&amp;Executable:</source>
         <translation>&amp;Программа:</translation>
     </message>
     <message>
-        <location filename="application.ui" line="96"/>
+        <location filename="applicationdialog.ui" line="96"/>
         <source>&amp;Parameters:</source>
         <translation>&amp;Параметры:</translation>
     </message>
     <message>
-        <location filename="application.ui" line="138"/>
+        <location filename="applicationdialog.ui" line="138"/>
         <source>Browse</source>
         <translation>Просмотреть</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="59"/>
+        <location filename="applicationdialog.cpp" line="65"/>
         <source>Executable files (*.exe);;All files(*.*)</source>
         <translation>Выполняемые файлы  (*.exe);;Все файлы(*.*)</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="62"/>
+        <location filename="applicationdialog.cpp" line="68"/>
         <source>Select viewer application</source>
         <translation>Выберите приложение</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="77"/>
+        <location filename="applicationdialog.cpp" line="83"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="78"/>
+        <location filename="applicationdialog.cpp" line="84"/>
         <source>You must specify a name, a path and optionally parameters for the application!</source>
         <translation>Вы должны задать название и путь к приложению!</translation>
     </message>
 </context>
+<context>
+    <name>ComplianceReportDialog</name>
+    <message>
+        <location filename="compliancereportdialog.ui" line="14"/>
+        <source>Compliance Report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="29"/>
+        <source>Project name</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="22"/>
+        <source>Project version</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="42"/>
+        <source>Coding Standard</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="50"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="55"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="60"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="70"/>
+        <source>List of files with md5 checksums</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="133"/>
+        <source>Compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="135"/>
+        <source>HTML files (*.html)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="176"/>
+        <location filename="compliancereportdialog.cpp" line="239"/>
+        <source>Save compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="177"/>
+        <source>Failed to import &apos;%1&apos; (%2), can not show files in compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>FileViewDialog</name>
     <message>
-        <location filename="fileviewdialog.cpp" line="42"/>
+        <location filename="fileviewdialog.cpp" line="53"/>
         <source>Could not find the file: %1</source>
         <oldsource>Could not find the file:
 </oldsource>
         <translation>Невозможно найти файл: %1</translation>
     </message>
     <message>
-        <location filename="fileviewdialog.cpp" line="46"/>
-        <location filename="fileviewdialog.cpp" line="60"/>
+        <location filename="fileviewdialog.cpp" line="57"/>
+        <location filename="fileviewdialog.cpp" line="71"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="fileviewdialog.cpp" line="56"/>
+        <location filename="fileviewdialog.cpp" line="67"/>
         <source>Could not read the file: %1</source>
         <translation>Невозможно прочитать файл: %1</translation>
     </message>
 </context>
+<context>
+    <name>HelpDialog</name>
+    <message>
+        <location filename="helpdialog.ui" line="14"/>
+        <source>Cppcheck GUI help</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="34"/>
+        <source>Contents</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="44"/>
+        <source>Index</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="84"/>
+        <source>Helpfile &apos;%1&apos; was not found</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="86"/>
+        <source>Cppcheck</source>
+        <translation type="unfinished">Cppcheck</translation>
+    </message>
+</context>
 <context>
     <name>LibraryAddFunctionDialog</name>
     <message>
@@ -247,42 +335,42 @@ Parameters: -l(line) (file)</source>
         <translation>Изменить</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="82"/>
-        <location filename="librarydialog.cpp" line="154"/>
+        <location filename="librarydialog.cpp" line="97"/>
+        <location filename="librarydialog.cpp" line="169"/>
         <source>Library files (*.cfg)</source>
         <translation>Файлы библиотек (*.cfg)</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="84"/>
+        <location filename="librarydialog.cpp" line="99"/>
         <source>Open library file</source>
         <translation>Открыть файл библиотеки</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="95"/>
-        <location filename="librarydialog.cpp" line="107"/>
-        <location filename="librarydialog.cpp" line="144"/>
+        <location filename="librarydialog.cpp" line="110"/>
+        <location filename="librarydialog.cpp" line="122"/>
+        <location filename="librarydialog.cpp" line="159"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="96"/>
+        <location filename="librarydialog.cpp" line="111"/>
         <source>Cannot open file %1.</source>
         <oldsource>Can not open file %1.</oldsource>
-        <translation type="unfinished">Невозможно открыть файл %1.</translation>
+        <translation>Невозможно открыть файл %1.</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="108"/>
+        <location filename="librarydialog.cpp" line="123"/>
         <source>Failed to load %1. %2.</source>
-        <translation type="unfinished"></translation>
+        <translation>Ошибка загрузки %1. %2.</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="145"/>
+        <location filename="librarydialog.cpp" line="160"/>
         <source>Cannot save file %1.</source>
         <oldsource>Can not save file %1.</oldsource>
-        <translation type="unfinished">Невозможно сохранить файл %1.</translation>
+        <translation>Невозможно сохранить файл %1.</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="157"/>
+        <location filename="librarydialog.cpp" line="172"/>
         <source>Save the library as</source>
         <translation>Сохранить библиотеку как</translation>
     </message>
@@ -397,652 +485,626 @@ Parameters: -l(line) (file)</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
-<context>
-    <name>LogView</name>
-    <message>
-        <source>Checking Log</source>
-        <translation type="obsolete">Лог проверки</translation>
-    </message>
-    <message>
-        <source>Clear</source>
-        <translation type="obsolete">Очистить</translation>
-    </message>
-    <message>
-        <source>Save Log</source>
-        <translation type="obsolete">Сохранить</translation>
-    </message>
-    <message>
-        <source>Text files (*.txt *.log);;All files (*.*)</source>
-        <translation type="obsolete">Текстовые файлы (*.txt *.log);;Все файлы (*.*)</translation>
-    </message>
-    <message>
-        <source>Cppcheck</source>
-        <translation type="obsolete">Cppcheck</translation>
-    </message>
-    <message>
-        <source>Could not open file for writing: &quot;%1&quot;</source>
-        <translation type="obsolete">Не удалось записать в файл: &quot;%1&quot;</translation>
-    </message>
-</context>
 <context>
     <name>MainWindow</name>
     <message>
         <location filename="mainwindow.ui" line="26"/>
-        <location filename="mainwindow.ui" line="595"/>
-        <location filename="mainwindow.cpp" line="328"/>
-        <location filename="mainwindow.cpp" line="480"/>
-        <location filename="mainwindow.cpp" line="553"/>
-        <location filename="mainwindow.cpp" line="658"/>
-        <location filename="mainwindow.cpp" line="680"/>
-        <location filename="mainwindow.cpp" line="1113"/>
-        <location filename="mainwindow.cpp" line="1238"/>
-        <location filename="mainwindow.cpp" line="1359"/>
-        <location filename="mainwindow.cpp" line="1499"/>
-        <location filename="mainwindow.cpp" line="1522"/>
-        <location filename="mainwindow.cpp" line="1593"/>
-        <location filename="mainwindow.cpp" line="1667"/>
+        <location filename="mainwindow.ui" line="688"/>
+        <location filename="mainwindow.cpp" line="466"/>
+        <location filename="mainwindow.cpp" line="670"/>
+        <location filename="mainwindow.cpp" line="755"/>
+        <location filename="mainwindow.cpp" line="860"/>
+        <location filename="mainwindow.cpp" line="882"/>
+        <location filename="mainwindow.cpp" line="1467"/>
+        <location filename="mainwindow.cpp" line="1596"/>
+        <location filename="mainwindow.cpp" line="1937"/>
+        <location filename="mainwindow.cpp" line="1945"/>
+        <location filename="mainwindow.cpp" line="1999"/>
+        <location filename="mainwindow.cpp" line="2008"/>
+        <location filename="mainwindow.cpp" line="2080"/>
+        <location filename="mainwindow.cpp" line="2168"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="131"/>
+        <location filename="mainwindow.ui" line="210"/>
         <source>A&amp;nalyze</source>
-        <translation type="unfinished"></translation>
+        <translation>Анализ</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="183"/>
+        <location filename="mainwindow.ui" line="267"/>
         <source>Standard</source>
         <translation>Стандартные</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="70"/>
+        <location filename="mainwindow.ui" line="132"/>
         <source>&amp;File</source>
         <translation>&amp;Файл</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="89"/>
+        <location filename="mainwindow.ui" line="152"/>
         <source>&amp;View</source>
         <translation>&amp;Вид</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="93"/>
+        <location filename="mainwindow.ui" line="156"/>
         <source>&amp;Toolbars</source>
         <translation>&amp;Панель инструментов</translation>
     </message>
     <message>
-        <source>&amp;Check</source>
-        <translation type="obsolete">&amp;Проверить</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="135"/>
+        <location filename="mainwindow.ui" line="214"/>
         <source>C++ standard</source>
         <translation>Стандарт C++</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="145"/>
+        <location filename="mainwindow.ui" line="226"/>
         <source>&amp;C standard</source>
         <oldsource>C standard</oldsource>
-        <translation type="unfinished">Стандарт C</translation>
+        <translation>&amp;Стандарт C</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="170"/>
+        <location filename="mainwindow.ui" line="254"/>
         <source>&amp;Edit</source>
         <translation>&amp;Правка</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="231"/>
+        <location filename="mainwindow.ui" line="315"/>
         <source>&amp;License...</source>
         <translation>&amp;Лицензия...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="236"/>
+        <location filename="mainwindow.ui" line="320"/>
         <source>A&amp;uthors...</source>
         <translation>&amp;Авторы...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="245"/>
+        <location filename="mainwindow.ui" line="329"/>
         <source>&amp;About...</source>
         <translation>&amp;О программе...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="250"/>
+        <location filename="mainwindow.ui" line="334"/>
         <source>&amp;Files...</source>
         <translation>&amp;Файлы...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="253"/>
-        <location filename="mainwindow.ui" line="256"/>
+        <location filename="mainwindow.ui" line="337"/>
+        <location filename="mainwindow.ui" line="340"/>
         <source>Analyze files</source>
         <oldsource>Check files</oldsource>
-        <translation type="unfinished">Проверить файлы</translation>
+        <translation>Проверить файлы</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="259"/>
+        <location filename="mainwindow.ui" line="343"/>
         <source>Ctrl+F</source>
         <translation>Ctrl+F</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="268"/>
+        <location filename="mainwindow.ui" line="352"/>
         <source>&amp;Directory...</source>
         <translation>&amp;Каталог...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="271"/>
-        <location filename="mainwindow.ui" line="274"/>
+        <location filename="mainwindow.ui" line="355"/>
+        <location filename="mainwindow.ui" line="358"/>
         <source>Analyze directory</source>
         <oldsource>Check directory</oldsource>
-        <translation type="unfinished">Проверка директории</translation>
+        <translation>Проверка каталога</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="277"/>
+        <location filename="mainwindow.ui" line="361"/>
         <source>Ctrl+D</source>
         <translation>Ctrl+D</translation>
     </message>
     <message>
-        <source>&amp;Recheck files</source>
-        <translation type="obsolete">&amp;Перепроверить файлы</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="289"/>
+        <location filename="mainwindow.ui" line="373"/>
         <source>Ctrl+R</source>
         <translation>Ctrl+R</translation>
     </message>
     <message>
-        <source>&amp;Reanalyze all files</source>
-        <oldsource>&amp;Recheck all files</oldsource>
-        <translation type="obsolete">Заново проверить все файлы</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="307"/>
+        <location filename="mainwindow.ui" line="391"/>
         <source>&amp;Stop</source>
         <translation>Остановить</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="310"/>
-        <location filename="mainwindow.ui" line="313"/>
+        <location filename="mainwindow.ui" line="394"/>
+        <location filename="mainwindow.ui" line="397"/>
         <source>Stop analysis</source>
         <oldsource>Stop checking</oldsource>
-        <translation type="unfinished">Остановить проверку</translation>
+        <translation>Остановить проверку</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="316"/>
+        <location filename="mainwindow.ui" line="400"/>
         <source>Esc</source>
         <translation>Esc</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="325"/>
+        <location filename="mainwindow.ui" line="409"/>
         <source>&amp;Save results to file...</source>
         <translation>Сохранить отчёт в файл...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="328"/>
+        <location filename="mainwindow.ui" line="412"/>
         <source>Ctrl+S</source>
         <translation>Ctrl+S</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="333"/>
+        <location filename="mainwindow.ui" line="417"/>
         <source>&amp;Quit</source>
         <translation>Выход</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="342"/>
+        <location filename="mainwindow.ui" line="429"/>
         <source>&amp;Clear results</source>
         <translation>Очистить отчёт</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="351"/>
+        <location filename="mainwindow.ui" line="438"/>
         <source>&amp;Preferences</source>
         <translation>Параметры</translation>
     </message>
     <message>
-        <source>Errors</source>
-        <translation type="obsolete">Ошибки</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="384"/>
-        <location filename="mainwindow.ui" line="387"/>
+        <location filename="mainwindow.ui" line="471"/>
+        <location filename="mainwindow.ui" line="474"/>
+        <location filename="mainwindow.cpp" line="2394"/>
         <source>Show errors</source>
         <translation>Показать ошибки</translation>
     </message>
     <message>
-        <source>Show S&amp;cratchpad...</source>
-        <translation type="obsolete">Показать блокнот</translation>
-    </message>
-    <message>
-        <source>Warnings</source>
-        <translation type="obsolete">Предупреждения</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="524"/>
-        <location filename="mainwindow.ui" line="527"/>
+        <location filename="mainwindow.ui" line="617"/>
+        <location filename="mainwindow.ui" line="620"/>
+        <location filename="mainwindow.cpp" line="2395"/>
         <source>Show warnings</source>
         <translation>Показать предупреждения</translation>
     </message>
     <message>
-        <source>Performance warnings</source>
-        <translation type="obsolete">Предупреждения производительности</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="542"/>
-        <location filename="mainwindow.ui" line="545"/>
+        <location filename="mainwindow.ui" line="635"/>
+        <location filename="mainwindow.ui" line="638"/>
         <source>Show performance warnings</source>
         <translation>Показать предупреждения производительности</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="553"/>
+        <location filename="mainwindow.ui" line="646"/>
         <source>Show &amp;hidden</source>
         <translation>Показать скрытые</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="769"/>
-        <location filename="mainwindow.cpp" line="807"/>
+        <location filename="mainwindow.cpp" line="986"/>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Information</source>
         <translation>Информационные сообщения</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="568"/>
+        <location filename="mainwindow.ui" line="661"/>
         <source>Show information messages</source>
         <translation>Показать информационные сообщения</translation>
     </message>
     <message>
-        <source>Portability</source>
-        <translation type="obsolete">Переносимость</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="583"/>
+        <location filename="mainwindow.ui" line="676"/>
         <source>Show portability warnings</source>
         <translation>Показать предупреждения переносимости</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="598"/>
+        <location filename="mainwindow.ui" line="691"/>
         <source>Show Cppcheck results</source>
-        <translation type="unfinished"></translation>
+        <translation>Просмотр результатов Cppcheck</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="610"/>
+        <location filename="mainwindow.ui" line="703"/>
         <source>Clang</source>
-        <translation type="unfinished"></translation>
+        <translation>Clang</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="613"/>
+        <location filename="mainwindow.ui" line="706"/>
         <source>Show Clang results</source>
-        <translation type="unfinished"></translation>
+        <translation>Просмотр результатов Clang</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="621"/>
+        <location filename="mainwindow.ui" line="714"/>
         <source>&amp;Filter</source>
         <translation>Фильтр</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="624"/>
+        <location filename="mainwindow.ui" line="717"/>
         <source>Filter results</source>
         <translation>Результаты фильтрации</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="640"/>
+        <location filename="mainwindow.ui" line="733"/>
         <source>Windows 32-bit ANSI</source>
         <translation>Windows 32-bit ANSI</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="648"/>
+        <location filename="mainwindow.ui" line="741"/>
         <source>Windows 32-bit Unicode</source>
         <translation>Windows 32-bit Unicode</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="656"/>
+        <location filename="mainwindow.ui" line="749"/>
         <source>Unix 32-bit</source>
         <translation>Unix 32-bit</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="664"/>
+        <location filename="mainwindow.ui" line="757"/>
         <source>Unix 64-bit</source>
         <translation>Unix 64-bit</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="672"/>
+        <location filename="mainwindow.ui" line="765"/>
         <source>Windows 64-bit</source>
         <translation>Windows 64-bit</translation>
     </message>
     <message>
-        <source>Platforms</source>
-        <translation type="obsolete">Платформы</translation>
-    </message>
-    <message>
-        <source>C++11</source>
-        <translation type="obsolete">C++11</translation>
-    </message>
-    <message>
-        <source>C99</source>
-        <translation type="obsolete">C99</translation>
-    </message>
-    <message>
-        <source>Posix</source>
-        <translation type="obsolete">Posix</translation>
-    </message>
-    <message>
-        <source>C11</source>
-        <translation type="obsolete">C11</translation>
-    </message>
-    <message>
-        <source>C89</source>
-        <translation type="obsolete">C89</translation>
-    </message>
-    <message>
-        <source>C++03</source>
-        <translation type="obsolete">C++03</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="742"/>
+        <location filename="mainwindow.ui" line="859"/>
         <source>&amp;Print...</source>
         <translation>Печать...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="745"/>
+        <location filename="mainwindow.ui" line="862"/>
         <source>Print the Current Report</source>
         <translation>Напечатать текущий отчет</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="750"/>
+        <location filename="mainwindow.ui" line="867"/>
         <source>Print Pre&amp;view...</source>
         <translation>Предварительный просмотр...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="753"/>
+        <location filename="mainwindow.ui" line="870"/>
         <source>Open a Print Preview Dialog for the Current Results</source>
         <translation>Открыть диалог печати для текущих результатов</translation>
     </message>
     <message>
-        <source>Library Editor...</source>
-        <translation type="obsolete">Редактор библиотек...</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="761"/>
+        <location filename="mainwindow.ui" line="878"/>
         <source>Open library editor</source>
         <translation>Открыть редактор библиотек</translation>
     </message>
     <message>
-        <source>Auto-detect language</source>
-        <translation type="obsolete">Автоопределение языка</translation>
+        <location filename="mainwindow.ui" line="479"/>
+        <source>&amp;Check all</source>
+        <translation>Отметить все</translation>
     </message>
     <message>
-        <source>Enforce C++</source>
-        <translation type="obsolete">Принудительно C++</translation>
+        <location filename="mainwindow.ui" line="84"/>
+        <source>Checking for updates</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Enforce C</source>
-        <translation type="obsolete">Принудительно C</translation>
+        <location filename="mainwindow.ui" line="100"/>
+        <source>Hide</source>
+        <translation type="unfinished">Скрыть</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="392"/>
-        <source>&amp;Check all</source>
-        <translation>Отметить все</translation>
+        <location filename="mainwindow.ui" line="164"/>
+        <location filename="mainwindow.ui" line="980"/>
+        <source>Report</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="220"/>
+        <location filename="mainwindow.ui" line="304"/>
         <source>Filter</source>
         <translation>Фильтр</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="286"/>
+        <location filename="mainwindow.ui" line="370"/>
         <source>&amp;Reanalyze modified files</source>
         <oldsource>&amp;Recheck modified files</oldsource>
-        <translation type="unfinished">Заново проверить измененные файлы</translation>
+        <translation>Заново проверить измененные файлы</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="298"/>
+        <location filename="mainwindow.ui" line="382"/>
         <source>Reanal&amp;yze all files</source>
+        <translation>Заново проверить все файлы</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="420"/>
+        <source>Ctrl+Q</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="363"/>
+        <location filename="mainwindow.ui" line="450"/>
         <source>Style war&amp;nings</source>
-        <translation type="unfinished"></translation>
+        <translation>Стилистические предупреждения</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="381"/>
+        <location filename="mainwindow.ui" line="468"/>
         <source>E&amp;rrors</source>
-        <translation type="unfinished"></translation>
+        <translation>Ошибки</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="397"/>
+        <location filename="mainwindow.ui" line="484"/>
         <source>&amp;Uncheck all</source>
         <translation>Сбросить все</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="402"/>
+        <location filename="mainwindow.ui" line="489"/>
         <source>Collapse &amp;all</source>
         <translation>Свернуть все</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="407"/>
+        <location filename="mainwindow.ui" line="494"/>
         <source>&amp;Expand all</source>
         <translation>Развернуть все</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="415"/>
+        <location filename="mainwindow.ui" line="502"/>
         <source>&amp;Standard</source>
         <translation>Стандартные</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="418"/>
+        <location filename="mainwindow.ui" line="505"/>
         <source>Standard items</source>
         <translation>Стандартные элементы</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="434"/>
+        <location filename="mainwindow.ui" line="521"/>
         <source>Toolbar</source>
         <translation>Панель инструментов</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="442"/>
+        <location filename="mainwindow.ui" line="529"/>
         <source>&amp;Categories</source>
         <translation>Категории</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="445"/>
+        <location filename="mainwindow.ui" line="532"/>
         <source>Error categories</source>
         <translation>Категории ошибок</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="450"/>
+        <location filename="mainwindow.ui" line="537"/>
         <source>&amp;Open XML...</source>
         <translation>&amp;Открыть XML...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="459"/>
+        <location filename="mainwindow.ui" line="546"/>
         <source>Open P&amp;roject File...</source>
         <translation>Открыть файл &amp;проекта...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="468"/>
-        <source>Sh&amp;ow Scratchpad...</source>
+        <location filename="mainwindow.ui" line="549"/>
+        <source>Ctrl+Shift+O</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="473"/>
+        <location filename="mainwindow.ui" line="558"/>
+        <source>Sh&amp;ow Scratchpad...</source>
+        <translation>Показать Блокнот</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="563"/>
         <source>&amp;New Project File...</source>
         <translation>&amp;Новый файл проекта...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="478"/>
+        <location filename="mainwindow.ui" line="566"/>
+        <source>Ctrl+Shift+N</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="571"/>
         <source>&amp;Log View</source>
         <translation>Посмотреть &amp;лог</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="481"/>
+        <location filename="mainwindow.ui" line="574"/>
         <source>Log View</source>
         <translation>Посмотреть лог</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="489"/>
+        <location filename="mainwindow.ui" line="582"/>
         <source>C&amp;lose Project File</source>
         <translation>&amp;Закрыть файл проекта</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="497"/>
+        <location filename="mainwindow.ui" line="590"/>
         <source>&amp;Edit Project File...</source>
         <translation>&amp;Изменить файл проекта...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="509"/>
+        <location filename="mainwindow.ui" line="602"/>
         <source>&amp;Statistics</source>
         <translation>&amp;Статистика</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="521"/>
+        <location filename="mainwindow.ui" line="614"/>
         <source>&amp;Warnings</source>
-        <translation type="unfinished"></translation>
+        <translation>Предупреждения</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="539"/>
+        <location filename="mainwindow.ui" line="632"/>
         <source>Per&amp;formance warnings</source>
-        <translation type="unfinished"></translation>
+        <translation>Предупреждения производительности</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="565"/>
+        <location filename="mainwindow.ui" line="658"/>
         <source>&amp;Information</source>
-        <translation type="unfinished"></translation>
+        <translation>Информационные предупреждения</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="580"/>
+        <location filename="mainwindow.ui" line="673"/>
         <source>&amp;Portability</source>
-        <translation type="unfinished"></translation>
+        <translation>Предупреждения переносимости</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="680"/>
+        <location filename="mainwindow.ui" line="773"/>
         <source>P&amp;latforms</source>
-        <translation type="unfinished"></translation>
+        <translation>Платформы</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="694"/>
+        <location filename="mainwindow.ui" line="787"/>
         <source>C++&amp;11</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="705"/>
+        <location filename="mainwindow.ui" line="798"/>
         <source>C&amp;99</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="713"/>
+        <location filename="mainwindow.ui" line="806"/>
         <source>&amp;Posix</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="721"/>
+        <location filename="mainwindow.ui" line="814"/>
         <source>C&amp;11</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="729"/>
+        <location filename="mainwindow.ui" line="846"/>
         <source>&amp;C89</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="737"/>
+        <location filename="mainwindow.ui" line="854"/>
         <source>&amp;C++03</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="758"/>
+        <location filename="mainwindow.ui" line="875"/>
         <source>&amp;Library Editor...</source>
-        <translation type="unfinished"></translation>
+        <translation>Редактор библиотеки</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="769"/>
+        <location filename="mainwindow.ui" line="886"/>
         <source>&amp;Auto-detect language</source>
-        <translation type="unfinished"></translation>
+        <translation>Автоматическое определение языка</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="777"/>
+        <location filename="mainwindow.ui" line="894"/>
         <source>&amp;Enforce C++</source>
-        <translation type="unfinished"></translation>
+        <translation>Принудительно C++</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="785"/>
+        <location filename="mainwindow.ui" line="902"/>
         <source>E&amp;nforce C</source>
-        <translation type="unfinished"></translation>
+        <translation>Принудительно C</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="796"/>
+        <location filename="mainwindow.ui" line="913"/>
         <source>C++14</source>
-        <translation type="unfinished">C++14</translation>
+        <translation>C++14</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="804"/>
+        <location filename="mainwindow.ui" line="921"/>
         <source>Reanalyze and check library</source>
-        <translation type="unfinished"></translation>
+        <translation>Повторный анализ библиотеки</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="812"/>
+        <location filename="mainwindow.ui" line="929"/>
         <source>Check configuration (defines, includes)</source>
-        <translation type="unfinished"></translation>
+        <translation>Проверить конфигурацию (defines, includes)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="820"/>
+        <location filename="mainwindow.ui" line="937"/>
         <source>C++17</source>
-        <translation type="unfinished">C++17</translation>
+        <translation>C++17</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="831"/>
+        <location filename="mainwindow.ui" line="948"/>
         <source>C++20</source>
-        <translation type="unfinished">C++20</translation>
+        <translation>C++20</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="975"/>
+        <source>Compliance report...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="988"/>
+        <source>Normal</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="996"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1004"/>
+        <source>Misra C++ 2008</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="423"/>
+        <location filename="mainwindow.ui" line="1012"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1020"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1028"/>
+        <source>Misra C++ 2023</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1036"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1041"/>
+        <source>EULA...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1046"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1049"/>
+        <source>Show thread details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="510"/>
         <source>&amp;Contents</source>
         <translation>Помощь</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="201"/>
+        <location filename="mainwindow.ui" line="285"/>
         <source>Categories</source>
         <translation>Категории</translation>
     </message>
     <message>
-        <source>Style warnings</source>
-        <translation type="obsolete">Стилистические предупреждения</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="366"/>
-        <location filename="mainwindow.ui" line="369"/>
+        <location filename="mainwindow.ui" line="453"/>
+        <location filename="mainwindow.ui" line="456"/>
         <source>Show style warnings</source>
         <translation>Показать стилистические предупреждения</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="426"/>
+        <location filename="mainwindow.ui" line="513"/>
         <source>Open the help contents</source>
         <translation>Открыть помощь</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="429"/>
+        <location filename="mainwindow.ui" line="516"/>
         <source>F1</source>
         <translation>F1</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="121"/>
+        <location filename="mainwindow.ui" line="199"/>
         <source>&amp;Help</source>
         <translation>Помощь</translation>
     </message>
     <message>
-        <source>Select directory to check</source>
-        <translation type="obsolete">Выберите каталог для проверки</translation>
-    </message>
-    <message>
-        <source>No suitable files found to check!</source>
-        <translation type="obsolete">Не найдено подходящих файлов для проверки!</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="87"/>
+        <location filename="mainwindow.cpp" line="157"/>
+        <location filename="mainwindow.cpp" line="1782"/>
         <source>Quick Filter:</source>
         <translation>Быстрый фильтр:</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="629"/>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select configuration</source>
-        <translation type="unfinished"></translation>
+        <translation>Выбор конфигурации</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="659"/>
+        <location filename="mainwindow.cpp" line="861"/>
         <source>Found project file: %1
 
 Do you want to load this project file instead?</source>
@@ -1051,76 +1113,97 @@ Do you want to load this project file instead?</source>
 Вы хотите загрузить этот проект?</translation>
     </message>
     <message>
-        <source>Found project files from the directory.
-
-Do you want to proceed checking without using any of these project files?</source>
-        <translation type="obsolete">Найдены файлы проекта из каталога.
-Вы хотите продолжить проверку, не используя ни одного из этих файлов проекта?</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="778"/>
+        <location filename="mainwindow.cpp" line="995"/>
         <source>File not found</source>
         <translation>Файл не найден</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="781"/>
+        <location filename="mainwindow.cpp" line="998"/>
         <source>Bad XML</source>
         <translation>Некорректный XML</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="784"/>
+        <location filename="mainwindow.cpp" line="1001"/>
         <source>Missing attribute</source>
         <translation>Пропущен атрибут</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="787"/>
+        <location filename="mainwindow.cpp" line="1004"/>
         <source>Bad attribute value</source>
         <translation>Некорректное значение атрибута</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="790"/>
+        <location filename="mainwindow.cpp" line="1007"/>
         <source>Unsupported format</source>
         <translation>Неподдерживаемый формат</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="807"/>
+        <location filename="mainwindow.cpp" line="1016"/>
+        <source>Duplicate define</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Failed to load the selected library &apos;%1&apos;.
 %2</source>
         <translation>Не удалось загрузить выбранную библиотеку &apos;%1&apos;.
 %2</translation>
     </message>
     <message>
-        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located.</source>
-        <translation type="obsolete">Не удалось загрузить %1. Установленный Cppcheck поврежден. Вы можете использовать ключ --data-dir=&lt;directory&gt; в командной строке, чтобы указать, где расположен этот файл.</translation>
+        <location filename="mainwindow.cpp" line="1035"/>
+        <source>File not found: &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1058"/>
+        <source>Failed to load/setup addon %1: %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <source>Failed to load %1 - %2
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
+        <source>%1
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1280"/>
+        <location filename="mainwindow.cpp" line="1648"/>
         <source>License</source>
         <translation>Лицензия</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1287"/>
+        <location filename="mainwindow.cpp" line="1655"/>
         <source>Authors</source>
         <translation>Авторы</translation>
     </message>
     <message>
-        <source>XML files version 2 (*.xml);;XML files version 1 (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
-        <oldsource>XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</oldsource>
-        <translation type="obsolete">XML файлы версии 2 (*.xml);;XML файлы версии 1 (*.xml);;Текстовые файлы  (*.txt);;CSV файлы (*.csv)</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1302"/>
+        <location filename="mainwindow.cpp" line="1675"/>
         <source>Save the report file</source>
         <translation>Сохранить файл с отчетом</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1129"/>
-        <location filename="mainwindow.cpp" line="1309"/>
+        <location filename="mainwindow.cpp" line="1483"/>
+        <location filename="mainwindow.cpp" line="1682"/>
         <source>XML files (*.xml)</source>
         <translation>XML-файлы (*.xml)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="323"/>
+        <location filename="mainwindow.cpp" line="461"/>
         <source>There was a problem with loading the editor application settings.
 
 This is probably because the settings were changed between the Cppcheck versions. Please check (and fix) the editor application settings, otherwise the editor program might not start correctly.</source>
@@ -1129,218 +1212,280 @@ This is probably because the settings were changed between the Cppcheck versions
 Возможно, это связано с изменениями в версии программы. Пожалуйста, проверьте (и исправьте) настройки приложения.</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="554"/>
+        <location filename="mainwindow.cpp" line="756"/>
         <source>You must close the project file before selecting new files or directories!</source>
-        <translation>Вы должны закрыть проект перед выбором новых файлов или директорий!</translation>
+        <translation>Вы должны закрыть проект перед выбором новых файлов или каталогов!</translation>
     </message>
     <message>
-        <source>Select files to check</source>
-        <translation type="obsolete">Выберите файлы для проверки</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="769"/>
+        <location filename="mainwindow.cpp" line="986"/>
         <source>The library &apos;%1&apos; contains unknown elements:
 %2</source>
         <translation>Библиотека &apos;%1&apos; содержит неизвестные элементы:
 %2</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="793"/>
+        <location filename="mainwindow.cpp" line="1010"/>
         <source>Duplicate platform type</source>
-        <translation type="unfinished"></translation>
+        <translation>Дубликат типа платформы</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="796"/>
+        <location filename="mainwindow.cpp" line="1013"/>
         <source>Platform type redefined</source>
-        <translation type="unfinished"></translation>
+        <translation>Переобъявление типа платформы</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="799"/>
+        <location filename="mainwindow.cpp" line="1019"/>
         <source>Unknown element</source>
-        <translation type="unfinished"></translation>
+        <translation>Неизвестный элемент</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="802"/>
-        <source>Unknown issue</source>
-        <translation type="unfinished"></translation>
+        <location filename="mainwindow.cpp" line="1019"/>
+        <source>Unknown element</source>
+        <oldsource>Unknown issue</oldsource>
+        <translation type="unfinished">Неизвестная проблема</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="828"/>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
         <source>Error</source>
-        <translation type="unfinished"></translation>
+        <translation>Ошибка</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="828"/>
         <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.</source>
-        <translation type="unfinished"></translation>
+        <translation type="vanished">Невозможно загрузить %1. Cppcheck установлен некорректно. Вы можете использовать --data-dir=&lt;directory&gt; в командной строке для указания расположения файлов конфигурации. Обратите внимание, что --data-dir предназначен для использования сценариями установки. При включении данной опции, графический интерфейс пользователя не запускается.</translation>
     </message>
     <message>
-        <source>Current results will be cleared.
-
-Opening a new XML file will clear current results.Do you want to proceed?</source>
-        <translation type="vanished">Текущие результаты будут очищены.
-
-Открытые нового XML файла приведет к очистке текущих результатов. Продолжить?</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1131"/>
+        <location filename="mainwindow.cpp" line="1485"/>
         <source>Open the report file</source>
         <translation>Открыть файл с отчетом</translation>
     </message>
     <message>
-        <source>Checking is running.
-
-Do you want to stop the checking and exit Cppcheck?</source>
-        <translation type="obsolete">Идет проверка.
-
-Вы хотите завершить проверку и выйти?</translation>
-    </message>
-    <message>
-        <source>XML files version 1 (*.xml)</source>
-        <translation type="obsolete">XML файлы версии 1 (*.xml)</translation>
-    </message>
-    <message>
-        <source>XML files version 2 (*.xml)</source>
-        <translation type="obsolete">XML файлы версии 2 (*.xml)</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1313"/>
+        <location filename="mainwindow.cpp" line="1686"/>
         <source>Text files (*.txt)</source>
         <translation>Текстовые файлы (*.txt)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1317"/>
+        <location filename="mainwindow.cpp" line="1690"/>
         <source>CSV files (*.csv)</source>
         <translation>CSV файлы(*.csv)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1361"/>
-        <source>Cppcheck - %1</source>
-        <translation>Cppcheck - %1</translation>
-    </message>
-    <message>
-        <source>Failed to change the user interface language:
-
-%1
-
-The user interface language has been reset to English. Open the Preferences-dialog to select any of the available languages.</source>
-        <translation type="obsolete">Failed to change the user interface language:
-
-%1
-
-The user interface language has been reset to English. Open the Preferences-dialog to select any of the available languages.</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1407"/>
+        <location filename="mainwindow.cpp" line="1820"/>
         <source>Project files (*.cppcheck);;All files(*.*)</source>
         <translation>Файлы проекта (*.cppcheck);;Все файлы(*.*)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1409"/>
+        <location filename="mainwindow.cpp" line="1822"/>
         <source>Select Project File</source>
         <translation>Выберите файл проекта</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="159"/>
-        <location filename="mainwindow.cpp" line="1437"/>
-        <location filename="mainwindow.cpp" line="1562"/>
+        <location filename="mainwindow.cpp" line="242"/>
+        <location filename="mainwindow.cpp" line="1784"/>
+        <location filename="mainwindow.cpp" line="1850"/>
+        <location filename="mainwindow.cpp" line="2048"/>
         <source>Project:</source>
         <translation>Проект:</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="481"/>
+        <location filename="mainwindow.cpp" line="671"/>
         <source>No suitable files found to analyze!</source>
-        <translation type="unfinished"></translation>
+        <translation>Не найдено подходящих файлов для анализа</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="568"/>
+        <location filename="mainwindow.cpp" line="770"/>
         <source>C/C++ Source</source>
-        <translation type="unfinished"></translation>
+        <translation>Исходный код C/C++</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="569"/>
+        <location filename="mainwindow.cpp" line="771"/>
         <source>Compile database</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="570"/>
+        <location filename="mainwindow.cpp" line="772"/>
         <source>Visual Studio</source>
-        <translation type="unfinished"></translation>
+        <translation type="unfinished">Visual Studio</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="571"/>
+        <location filename="mainwindow.cpp" line="773"/>
         <source>Borland C++ Builder 6</source>
-        <translation type="unfinished"></translation>
+        <translation type="unfinished">Borland C++ Builder 6</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="574"/>
+        <location filename="mainwindow.cpp" line="776"/>
         <source>Select files to analyze</source>
-        <translation type="unfinished"></translation>
+        <translation>Выбор файлов для анализа</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="589"/>
+        <location filename="mainwindow.cpp" line="791"/>
         <source>Select directory to analyze</source>
-        <translation type="unfinished"></translation>
+        <translation>Выбор каталога для анализа</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="629"/>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select the configuration that will be analyzed</source>
-        <translation type="unfinished"></translation>
+        <translation>Выбор используемой конфигурации</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="681"/>
+        <location filename="mainwindow.cpp" line="883"/>
         <source>Found project files from the directory.
 
 Do you want to proceed analysis without using any of these project files?</source>
-        <translation type="unfinished"></translation>
+        <translation>Обнаружены файлы проекты из каталога.
+
+Вы хотите продолжить анализ без использования этих файлов проекта?</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1114"/>
+        <location filename="mainwindow.cpp" line="1468"/>
         <source>Current results will be cleared.
 
 Opening a new XML file will clear current results.
 Do you want to proceed?</source>
-        <translation type="unfinished"></translation>
+        <translation>Текущие результаты будут очищены.
+
+Открытие нового XML-файла приведет к очистке текущих результатов.
+Вы хотите продолжить?</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1234"/>
+        <location filename="mainwindow.cpp" line="1592"/>
         <source>Analyzer is running.
 
 Do you want to stop the analysis and exit Cppcheck?</source>
+        <translation>Анализатор запущен.
+
+Вы хотите остановить анализ и выйти из Cppcheck?</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1634"/>
+        <source>About</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1300"/>
+        <location filename="mainwindow.cpp" line="1673"/>
         <source>XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
+        <translation>XML файлы (*.xml);;Текстовые файлы (*.txt);;CSV файлы (*.csv)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1713"/>
+        <source>Cannot generate a compliance report right now, an analysis must finish successfully. Try to reanalyze the code and ensure there are no critical errors.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1500"/>
+        <location filename="mainwindow.cpp" line="1938"/>
         <source>Build dir &apos;%1&apos; does not exist, create it?</source>
+        <translation>Директория для сборки &apos;%1&apos; не существует, создать?</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1946"/>
+        <source>To check the project using addons, you need a build directory.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1523"/>
-        <source>Failed to import &apos;%1&apos;, analysis is stopped</source>
+        <location filename="mainwindow.cpp" line="1978"/>
+        <source>Failed to open file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1547"/>
-        <source>Project files (*.cppcheck)</source>
+        <location filename="mainwindow.cpp" line="1981"/>
+        <source>Unknown project file format</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1549"/>
+        <location filename="mainwindow.cpp" line="1984"/>
+        <source>Failed to import project file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2000"/>
+        <source>Failed to import &apos;%1&apos;: %2
+
+Analysis is stopped.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2009"/>
+        <source>Failed to import &apos;%1&apos; (%2), analysis is stopped</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2367"/>
+        <source>Show Mandatory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2368"/>
+        <source>Show Required</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2369"/>
+        <source>Show Advisory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2370"/>
+        <source>Show Document</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2387"/>
+        <source>Show L1</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2388"/>
+        <source>Show L2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2389"/>
+        <source>Show L3</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2396"/>
+        <source>Show style</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2397"/>
+        <source>Show portability</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2398"/>
+        <source>Show performance</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2399"/>
+        <source>Show information</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <source>Failed to import &apos;%1&apos;, analysis is stopped</source>
+        <translation type="vanished">Невозможно импортировать &apos;%1&apos;, анализ остановлен</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2033"/>
+        <source>Project files (*.cppcheck)</source>
+        <translation>Файлы проекта (*.cppcheck)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2035"/>
         <source>Select Project Filename</source>
         <translation>Выберите имя файла для проекта</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1594"/>
+        <location filename="mainwindow.cpp" line="2081"/>
         <source>No project file loaded</source>
         <translation>Файл с проектом не загружен</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1662"/>
+        <location filename="mainwindow.cpp" line="2163"/>
         <source>The project file
 
 %1
@@ -1356,31 +1501,17 @@ Do you want to remove the file from the recently used projects -list?</source>
 Хотите удалить его из списка проектов?</translation>
     </message>
     <message>
-        <source>Cppcheck GUI.
-
-Syntax:
-    cppcheck-gui [OPTIONS] [files or paths]
-
-Options:
-    -h, --help     Print this help
-    -p &lt;file&gt;      Open given project file and start checking it
-    -l &lt;file&gt;      Open given results xml file
-    -d &lt;directory&gt; Specify the directory that was checked to generate the results xml specified with -l
-    -v, --version  Show program version</source>
-        <translation type="obsolete">Cppcheck Графический Интерфейс Пользователя .
-
-Синтаксис:
-     cppcheck-gui [ОПЦИИ] [файлы или пути]
-	 
-Опции:
-	 -h, --help     Показать эту справку
-	 -p &lt;file&gt;     Откройте данный файл проекта и начните проверять его
-	 -l &lt;file&gt;     Откройте данные результаты xml файл
-	 -d &lt;directory&gt;   Укажите каталог, который был проверен, чтобы генерировать результаты xml определенный с -l
-	 -v, --version Показать версию программы</translation>
+        <location filename="mainwindow.cpp" line="2325"/>
+        <source>Install</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="main.cpp" line="106"/>
+        <location filename="mainwindow.cpp" line="2329"/>
+        <source>New version available: %1. %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="main.cpp" line="100"/>
         <source>Cppcheck GUI.
 
 Syntax:
@@ -1407,10 +1538,23 @@ Options:
     -d &lt;directory&gt;          Specify the directory that was checked to generate the results xml specified with -l
     -v, --version           Show program version
     --data-dir=&lt;directory&gt;  Specify directory where GUI datafiles are located (translations, cfg)</oldsource>
-        <translation type="unfinished"></translation>
+        <translation>Cppcheck GUI.
+
+Синтаксис:
+    cppcheck-gui [ОПЦИИ] [файлы или пути]
+
+Опции:
+    -h, --help              Выдать подсказку на стандартный вывод и успешно завершиться.
+    -p &lt;file&gt;               Открыть указанный файл проекта и начать проверку
+    -l &lt;file&gt;               Открыть xml-файл с полученными результатами
+    -d &lt;directory&gt;          Указать каталог, который был проверен для создания результатов xml, указанных с помощью -l
+    -v, --version           Выдать информацию о версии на стандартный вывод и успешно завершиться.
+    --data-dir=&lt;directory&gt;  Этот параметр предназначен для сценариев установки, чтобы они могли
+                            настроить каталог, в котором расположены файлы данных (конфигурация, переводы).
+                            Графический интерфейс пользователя не будет запущен, если указана эта опция.</translation>
     </message>
     <message>
-        <location filename="main.cpp" line="121"/>
+        <location filename="main.cpp" line="115"/>
         <source>Cppcheck GUI - Command line parameters</source>
         <translation>Cppcheck GUI - параметры Командной строки</translation>
     </message>
@@ -1420,625 +1564,801 @@ Options:
     <message>
         <location filename="newsuppressiondialog.ui" line="17"/>
         <source>New suppression</source>
-        <translation type="unfinished"></translation>
+        <translation>Новое подавление</translation>
     </message>
     <message>
         <location filename="newsuppressiondialog.ui" line="25"/>
         <source>Error ID</source>
-        <translation type="unfinished"></translation>
+        <translation>ID</translation>
     </message>
     <message>
         <location filename="newsuppressiondialog.ui" line="32"/>
         <source>File name</source>
-        <translation type="unfinished"></translation>
+        <translation>Имя файла</translation>
     </message>
     <message>
         <location filename="newsuppressiondialog.ui" line="42"/>
         <source>Line number</source>
-        <translation type="unfinished"></translation>
+        <translation>Номер строки</translation>
     </message>
     <message>
         <location filename="newsuppressiondialog.ui" line="52"/>
         <source>Symbol name</source>
-        <translation type="unfinished"></translation>
+        <translation>Имя символа</translation>
     </message>
     <message>
-        <location filename="newsuppressiondialog.cpp" line="52"/>
+        <location filename="newsuppressiondialog.cpp" line="83"/>
         <source>Edit suppression</source>
-        <translation type="unfinished"></translation>
+        <translation>Редактировать подавление</translation>
     </message>
 </context>
 <context>
     <name>Platforms</name>
     <message>
-        <source>Built-in</source>
-        <translation type="obsolete">Встроенная</translation>
-    </message>
-    <message>
-        <location filename="platforms.cpp" line="37"/>
+        <location filename="platforms.cpp" line="38"/>
         <source>Native</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="38"/>
+        <location filename="platforms.cpp" line="39"/>
         <source>Unix 32-bit</source>
         <translation>Unix 32-bit</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="39"/>
+        <location filename="platforms.cpp" line="40"/>
         <source>Unix 64-bit</source>
         <translation>Unix 64-bit</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="40"/>
+        <location filename="platforms.cpp" line="41"/>
         <source>Windows 32-bit ANSI</source>
         <translation>Windows 32-bit ANSI</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="41"/>
+        <location filename="platforms.cpp" line="42"/>
         <source>Windows 32-bit Unicode</source>
         <translation>Windows 32-bit Unicode</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="42"/>
+        <location filename="platforms.cpp" line="43"/>
         <source>Windows 64-bit</source>
         <translation>Windows 64-bit</translation>
     </message>
 </context>
 <context>
-    <name>Project</name>
+    <name>ProjectFile</name>
     <message>
-        <source>Cppcheck</source>
-        <translation type="obsolete">Cppcheck</translation>
+        <location filename="projectfile.ui" line="14"/>
+        <source>Project File</source>
+        <translation>Файл проекта</translation>
     </message>
     <message>
-        <source>Could not read the project file.</source>
-        <translation type="obsolete">Не удалось прочитать файл проекта.</translation>
+        <location filename="projectfile.ui" line="24"/>
+        <source>Paths and Defines</source>
+        <translation>Каталоги и определения</translation>
     </message>
     <message>
-        <source>Could not write the project file.</source>
-        <translation type="obsolete">Не удалось записать файл проекта.</translation>
+        <location filename="projectfile.ui" line="30"/>
+        <source>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</source>
+        <oldsource>Import Project (Visual studio / compile database)</oldsource>
+        <translation>Импорт проекта (Visual studio / compile database/ Borland C++ Builder 6)</translation>
     </message>
-</context>
-<context>
-    <name>ProjectFile</name>
     <message>
-        <location filename="projectfiledialog.ui" line="14"/>
-        <source>Project File</source>
-        <translation>Файл проекта</translation>
+        <location filename="projectfile.ui" line="231"/>
+        <source>Defines must be separated by a semicolon. Example: DEF1;DEF2=5;DEF3=int</source>
+        <oldsource>Defines must be separated by a semicolon &apos;;&apos;</oldsource>
+        <translation>Defines должны быть разделены точкой с запятой &apos;;&apos;</translation>
     </message>
     <message>
-        <source>Project</source>
-        <translation type="obsolete">Проект</translation>
+        <location filename="projectfile.ui" line="389"/>
+        <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
+        <translation>Положите свои .cfg-файлы в один каталог с файлом проекта. Вы увидите их сверху.</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="24"/>
-        <source>Paths and Defines</source>
+        <location filename="projectfile.ui" line="448"/>
+        <source>Clang (experimental)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="30"/>
-        <source>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</source>
-        <oldsource>Import Project (Visual studio / compile database)</oldsource>
+        <location filename="projectfile.ui" line="494"/>
+        <source>If you want to design your classes to be as flexible and robust as possible then the public interface must be very robust. Cppcheck will asumme that arguments can take *any* value.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="163"/>
-        <source>Defines must be separated by a semicolon. Example: DEF1;DEF2=5;DEF3=int</source>
-        <oldsource>Defines must be separated by a semicolon &apos;;&apos;</oldsource>
-        <translation type="unfinished">Defines должны быть разделены точкой с запятой &apos;;&apos;</translation>
+        <location filename="projectfile.ui" line="519"/>
+        <source>Check code in headers  (should be ON normally. if you want a limited quick analysis then turn this OFF)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="572"/>
+        <source>Max recursion in template instantiation</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="639"/>
+        <source>Filepaths in warnings will be relative to this path</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="655"/>
+        <source>If tags are added, you will be able to right click on warnings and set one of these tags. You can manually categorize warnings.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>&amp;Root:</source>
-        <oldsource>Root:</oldsource>
-        <translation type="obsolete">Корневая директория:</translation>
+        <location filename="projectfile.ui" line="665"/>
+        <source>Exclude source files</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="676"/>
+        <source>Exclude folder...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="683"/>
+        <source>Exclude file...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <source>MISRA C 2012</source>
+        <translation type="vanished">MISRA C 2012</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="876"/>
+        <source>MISRA rule texts</source>
+        <translation>Файл с текстами правил MISRA</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="883"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Скопируйте текст из Appendix A &amp;quot;Summary of guidelines&amp;quot; из фала правил MISRA C 2012 pdf в текстовый файл.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="890"/>
+        <source>...</source>
+        <translation>...</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="73"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;You have a choice:&lt;/p&gt;&lt;p&gt; * Analyze all Debug and Release configurations&lt;/p&gt;&lt;p&gt; * Only analyze the first matching Debug configuration&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Выберите:&lt;/p&gt;&lt;p&gt; * Анализ всех конфигураций Debug и Release&lt;/p&gt;&lt;p&gt; * Анализ только первой подходящей конфигурации Debug&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="60"/>
+        <location filename="projectfile.ui" line="422"/>
+        <location filename="projectfile.ui" line="616"/>
+        <source>Browse...</source>
+        <translation>Обзор...</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="76"/>
+        <source>Analyze all Visual Studio configurations</source>
+        <translation>Анализировать все конфигурации Visual Studio</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="113"/>
+        <source>Selected VS Configurations</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="147"/>
+        <source>Paths:</source>
+        <translation>Пути:</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="181"/>
+        <location filename="projectfile.ui" line="296"/>
+        <source>Add...</source>
+        <translation>Добавить...</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="188"/>
+        <location filename="projectfile.ui" line="303"/>
+        <location filename="projectfile.ui" line="690"/>
+        <source>Edit</source>
+        <translation>Изменить</translation>
     </message>
     <message>
-        <source>Libraries:</source>
-        <translation type="obsolete">Библиотеки:</translation>
+        <location filename="projectfile.ui" line="195"/>
+        <location filename="projectfile.ui" line="310"/>
+        <location filename="projectfile.ui" line="697"/>
+        <location filename="projectfile.ui" line="740"/>
+        <source>Remove</source>
+        <translation>Удалить</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="242"/>
+        <source>Undefines:</source>
+        <translation>Удаленные макроопределения:</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="252"/>
+        <source>Undefines must be separated by a semicolon. Example: UNDEF1;UNDEF2;UNDEF3</source>
+        <translation>Удаленные макроопределения должны быть разделены точкой с запятой, например: UNDEF1;UNDEF2;UNDEF3</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="265"/>
+        <source>Include Paths:</source>
+        <translation>Пути заголовочных файлов:</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="362"/>
+        <source>Types and Functions</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="393"/>
-        <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
-        <translation>Note: Положите свои .cfg-файлы в одну директорию с файлом проекта. Вы увидите их сверху.</translation>
+        <location filename="projectfile.ui" line="403"/>
+        <location filename="projectfile.ui" line="488"/>
+        <source>Analysis</source>
+        <translation>Анализ</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="597"/>
-        <source>MISRA C 2012</source>
+        <location filename="projectfile.ui" line="415"/>
+        <source>This is a workfolder that Cppcheck will use for various purposes.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="606"/>
-        <source>Misra rule texts</source>
+        <location filename="projectfile.ui" line="432"/>
+        <source>Parser</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="613"/>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <location filename="projectfile.ui" line="438"/>
+        <source>Cppcheck (built in)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="620"/>
-        <source>...</source>
+        <location filename="projectfile.ui" line="458"/>
+        <source>Check level</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="69"/>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;You have a choice:&lt;/p&gt;&lt;p&gt; * Analyze all Debug and Release configurations&lt;/p&gt;&lt;p&gt; * Only analyze the first matching Debug configuration&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <location filename="projectfile.ui" line="464"/>
+        <source>Reduced -- meant for usage where developer wants results directly. Limited and faster analysis with fewer results.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="60"/>
-        <location filename="projectfiledialog.ui" line="309"/>
-        <source>Browse...</source>
+        <location filename="projectfile.ui" line="471"/>
+        <source>Normal -- meant for normal analysis in CI. Analysis should finish in reasonable time.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="72"/>
-        <source>Analyze all Visual Studio configurations</source>
+        <location filename="projectfile.ui" line="478"/>
+        <source>Exhaustive -- meant for nightly builds etc. Analysis time can be longer (10x slower than compilation is OK).</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="86"/>
-        <source>Paths:</source>
-        <translation>Пути:</translation>
+        <location filename="projectfile.ui" line="497"/>
+        <source>Check that each class has a safe public interface</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="113"/>
-        <location filename="projectfiledialog.ui" line="228"/>
-        <location filename="projectfiledialog.ui" line="461"/>
-        <source>Add...</source>
-        <translation>Добавить...</translation>
+        <location filename="projectfile.ui" line="513"/>
+        <source>Limit analysis</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="120"/>
-        <location filename="projectfiledialog.ui" line="235"/>
-        <location filename="projectfiledialog.ui" line="468"/>
-        <source>Edit</source>
-        <translation>Изменить</translation>
+        <location filename="projectfile.ui" line="529"/>
+        <source>Check code in unused templates (should be ON normally, however in theory you can safely ignore warnings in unused templates)</source>
+        <oldsource>Check code in unused templates  (slower and less accurate analysis)</oldsource>
+        <translation type="unfinished">Проверить код в неиспользуемых шаблонах</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="127"/>
-        <location filename="projectfiledialog.ui" line="242"/>
-        <location filename="projectfiledialog.ui" line="475"/>
-        <location filename="projectfiledialog.ui" line="518"/>
-        <source>Remove</source>
-        <translation>Удалить</translation>
+        <location filename="projectfile.ui" line="541"/>
+        <source>Max CTU depth</source>
+        <translation>Максимальная глубина CTU</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="174"/>
-        <source>Undefines:</source>
+        <location filename="projectfile.ui" line="607"/>
+        <source>Premium License</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="184"/>
-        <source>Undefines must be separated by a semicolon. Example: UNDEF1;UNDEF2;UNDEF3</source>
-        <translation type="unfinished"></translation>
+        <location filename="projectfile.ui" line="765"/>
+        <source>Enable inline suppressions</source>
+        <translation type="unfinished">Включить inline-подавление ошибок</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="197"/>
-        <source>Include Paths:</source>
+        <location filename="projectfile.ui" line="851"/>
+        <source>2025</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="331"/>
-        <source>Analysis</source>
+        <location filename="projectfile.ui" line="901"/>
+        <source>Misra C++</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="337"/>
-        <source>Check code in headers  (slower analysis, more results)</source>
+        <location filename="projectfile.ui" line="909"/>
+        <source>2008</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="347"/>
-        <source>Check code in unused templates  (slower and less accurate analysis)</source>
+        <location filename="projectfile.ui" line="937"/>
+        <source>Cert C</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="356"/>
-        <source>Max CTU depth</source>
+        <location filename="projectfile.ui" line="946"/>
+        <source>CERT-INT35-C:  int precision (if size equals precision, you can leave empty)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="450"/>
-        <source>Exclude source files in paths</source>
+        <location filename="projectfile.ui" line="965"/>
+        <source>Autosar</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="632"/>
-        <source>External tools</source>
+        <location filename="projectfile.ui" line="972"/>
+        <source>Safety profiles (defined in C++ core guidelines)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Includes</source>
-        <translation type="obsolete">Пути для заголовочных файлов</translation>
+        <location filename="projectfile.ui" line="988"/>
+        <source>Bug hunting</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Include directories:</source>
-        <translation type="obsolete">Пути для поиска заголовочных файлов:</translation>
+        <location filename="projectfile.ui" line="998"/>
+        <source>External tools</source>
+        <translation>Внешние инструменты</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="262"/>
+        <location filename="projectfile.ui" line="330"/>
         <source>Up</source>
         <translation>Вверх</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="269"/>
+        <location filename="projectfile.ui" line="337"/>
         <source>Down</source>
         <translation>Вниз</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="294"/>
-        <source>Checking</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="319"/>
+        <location filename="projectfile.ui" line="368"/>
         <source>Platform</source>
-        <translation type="unfinished"></translation>
+        <translation>Платформа</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="420"/>
+        <location filename="projectfile.ui" line="627"/>
         <source>Warning options</source>
-        <translation type="unfinished"></translation>
+        <translation>Опции предупреждений</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="426"/>
+        <location filename="projectfile.ui" line="633"/>
         <source>Root path:</source>
-        <translation type="unfinished"></translation>
+        <translation>Корневой каталог:</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="438"/>
+        <location filename="projectfile.ui" line="649"/>
         <source>Warning tags (separated by semicolon)</source>
-        <translation type="unfinished"></translation>
+        <translation>Теги предупреждений (через &apos;;&apos;)</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="300"/>
+        <location filename="projectfile.ui" line="409"/>
         <source>Cppcheck build dir (whole program analysis, incremental analysis, statistics, etc)</source>
-        <translation type="unfinished"></translation>
+        <translation>Каталог сборки Cppcheck</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="384"/>
+        <location filename="projectfile.ui" line="380"/>
         <source>Libraries</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <source>Exclude</source>
-        <translation type="obsolete">Исключенные пути</translation>
+        <translation>Библиотеки</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="500"/>
+        <location filename="projectfile.ui" line="722"/>
         <source>Suppressions</source>
-        <translation type="unfinished"></translation>
+        <translation>Подавления</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="511"/>
+        <location filename="projectfile.ui" line="733"/>
         <source>Add</source>
         <translation>Добавить</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="557"/>
-        <source>Addons and tools</source>
-        <translation type="unfinished"></translation>
+        <location filename="projectfile.ui" line="786"/>
+        <location filename="projectfile.ui" line="792"/>
+        <source>Addons</source>
+        <translation>Дополнения</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="563"/>
-        <source>Addons</source>
+        <location filename="projectfile.ui" line="798"/>
+        <source>Note: Addons require &lt;a href=&quot;https://www.python.org/&quot;&gt;Python&lt;/a&gt; being installed.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="569"/>
+        <location filename="projectfile.ui" line="808"/>
         <source>Y2038</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="576"/>
+        <location filename="projectfile.ui" line="815"/>
         <source>Thread safety</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="583"/>
+        <location filename="projectfile.ui" line="825"/>
         <source>Coding standards</source>
+        <translation>Стандарты кодирования</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="833"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="841"/>
+        <source>2012</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="846"/>
+        <location filename="projectfile.ui" line="914"/>
+        <source>2023</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="590"/>
-        <source>Cert</source>
+        <location filename="projectfile.ui" line="958"/>
+        <source>Cert C++</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="645"/>
+        <location filename="projectfile.ui" line="982"/>
+        <source>Bug hunting (Premium)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="1011"/>
         <source>Clang analyzer</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="638"/>
+        <location filename="projectfile.ui" line="1004"/>
         <source>Clang-tidy</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="153"/>
+        <location filename="projectfile.ui" line="221"/>
         <source>Defines:</source>
-        <translation>Макросы:</translation>
+        <translation>Объявленные макроопределения:</translation>
     </message>
 </context>
 <context>
     <name>ProjectFileDialog</name>
     <message>
-        <location filename="projectfiledialog.cpp" line="71"/>
+        <location filename="projectfiledialog.cpp" line="138"/>
         <source>Project file: %1</source>
         <translation>Файл проекта: %1</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="409"/>
+        <location filename="projectfiledialog.cpp" line="590"/>
         <source>Select Cppcheck build dir</source>
-        <translation type="unfinished"></translation>
+        <translation>Выбрать директорию сборки Cppcheck</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="637"/>
+        <location filename="projectfiledialog.cpp" line="851"/>
         <source>Select include directory</source>
         <translation>Выберите директорию для поиска заголовочных файлов</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="617"/>
+        <location filename="projectfiledialog.cpp" line="831"/>
         <source>Select a directory to check</source>
         <translation>Выберите директорию для проверки</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="305"/>
-        <source>(no rule texts file)</source>
+        <location filename="projectfiledialog.cpp" line="396"/>
+        <source>Note: Open source Cppcheck does not fully implement Misra C 2012</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="311"/>
+        <location filename="projectfiledialog.cpp" line="461"/>
         <source>Clang-tidy (not found)</source>
-        <translation type="unfinished"></translation>
+        <translation>Clang-tidy (не найден)</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="445"/>
+        <location filename="projectfiledialog.cpp" line="629"/>
         <source>Visual Studio</source>
-        <translation type="unfinished"></translation>
+        <translation>Visual Studio</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="446"/>
+        <location filename="projectfiledialog.cpp" line="630"/>
         <source>Compile database</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="447"/>
+        <location filename="projectfiledialog.cpp" line="631"/>
         <source>Borland C++ Builder 6</source>
-        <translation type="unfinished"></translation>
+        <translation>Borland C++ Builder 6</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="448"/>
+        <location filename="projectfiledialog.cpp" line="632"/>
         <source>Import Project</source>
-        <translation type="unfinished"></translation>
+        <translation>Импорт проекта</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="657"/>
+        <location filename="projectfiledialog.cpp" line="871"/>
         <source>Select directory to ignore</source>
         <translation>Выберите директорию, которую надо проигнорировать</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="742"/>
-        <source>Select MISRA rule texts file</source>
+        <location filename="projectfiledialog.cpp" line="879"/>
+        <source>Source files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="742"/>
-        <source>Misra rule texts file (%1)</source>
+        <location filename="projectfiledialog.cpp" line="880"/>
+        <source>All files</source>
         <translation type="unfinished"></translation>
     </message>
-</context>
-<context>
-    <name>QDialogButtonBox</name>
-    <message>
-        <location filename="translationhandler.cpp" line="34"/>
-        <source>OK</source>
-        <translation>OK</translation>
-    </message>
     <message>
-        <location filename="translationhandler.cpp" line="35"/>
-        <source>Cancel</source>
-        <translation>Отмена</translation>
+        <location filename="projectfiledialog.cpp" line="881"/>
+        <source>Exclude file</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="36"/>
-        <source>Close</source>
-        <translation>Закрыть</translation>
+        <location filename="projectfiledialog.cpp" line="964"/>
+        <source>Select MISRA rule texts file</source>
+        <translation>Выбрать файл текстов правил MISRA</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="37"/>
-        <source>Save</source>
-        <translation>Сохранить</translation>
+        <location filename="projectfiledialog.cpp" line="966"/>
+        <source>MISRA rule texts file (%1)</source>
+        <translation>Файл текстов правил MISRA (%1)</translation>
     </message>
 </context>
 <context>
     <name>QObject</name>
     <message>
-        <location filename="translationhandler.cpp" line="104"/>
+        <location filename="translationhandler.cpp" line="91"/>
         <source>Unknown language specified!</source>
         <translation>Неизвестный язык!</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="132"/>
+        <location filename="translationhandler.cpp" line="117"/>
         <source>Language file %1 not found!</source>
         <oldsource>Language file %1.qm not found!</oldsource>
         <translation>Языковой файл %1 не найден!</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="138"/>
+        <location filename="translationhandler.cpp" line="122"/>
         <source>Failed to load translation for language %1 from file %2</source>
         <oldsource>Failed to load translation for language %1 from file %2.qm</oldsource>
         <translation>Ошибка загрузки переводов для языка %1 из файла %2</translation>
     </message>
     <message>
-        <location filename="cppchecklibrarydata.cpp" line="33"/>
+        <location filename="cppchecklibrarydata.cpp" line="38"/>
         <source>line %1: Unhandled element %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="226"/>
-        <source> (Not found)</source>
+        <location filename="cppchecklibrarydata.cpp" line="43"/>
+        <source>line %1: Mandatory attribute &apos;%2&apos; missing in &apos;%3&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="69"/>
+        <location filename="projectfiledialog.cpp" line="284"/>
+        <source> (Not found)</source>
+        <translation> (Недоступно)</translation>
+    </message>
+    <message>
+        <location filename="codeeditstylecontrols.cpp" line="76"/>
         <source>Thin</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="71"/>
+        <location filename="codeeditstylecontrols.cpp" line="78"/>
         <source>ExtraLight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="73"/>
+        <location filename="codeeditstylecontrols.cpp" line="80"/>
         <source>Light</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="75"/>
+        <location filename="codeeditstylecontrols.cpp" line="82"/>
         <source>Normal</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="77"/>
+        <location filename="codeeditstylecontrols.cpp" line="84"/>
         <source>Medium</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="79"/>
+        <location filename="codeeditstylecontrols.cpp" line="86"/>
         <source>DemiBold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="81"/>
+        <location filename="codeeditstylecontrols.cpp" line="88"/>
         <source>Bold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="83"/>
+        <location filename="codeeditstylecontrols.cpp" line="90"/>
         <source>ExtraBold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="85"/>
+        <location filename="codeeditstylecontrols.cpp" line="92"/>
         <source>Black</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="69"/>
+        <location filename="codeeditstyledialog.cpp" line="80"/>
         <source>Editor Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="72"/>
+        <location filename="codeeditstyledialog.cpp" line="83"/>
         <source>Editor Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="75"/>
+        <location filename="codeeditstyledialog.cpp" line="86"/>
         <source>Highlight Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="78"/>
+        <location filename="codeeditstyledialog.cpp" line="89"/>
         <source>Line Number Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="81"/>
+        <location filename="codeeditstyledialog.cpp" line="92"/>
         <source>Line Number Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="84"/>
+        <location filename="codeeditstyledialog.cpp" line="95"/>
         <source>Keyword Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="87"/>
+        <location filename="codeeditstyledialog.cpp" line="98"/>
         <source>Keyword Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="90"/>
+        <location filename="codeeditstyledialog.cpp" line="101"/>
         <source>Class Foreground Color</source>
         <oldsource>Class ForegroundColor</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="93"/>
+        <location filename="codeeditstyledialog.cpp" line="104"/>
         <source>Class Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="96"/>
+        <location filename="codeeditstyledialog.cpp" line="107"/>
         <source>Quote Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="99"/>
+        <location filename="codeeditstyledialog.cpp" line="110"/>
         <source>Quote Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="102"/>
+        <location filename="codeeditstyledialog.cpp" line="113"/>
         <source>Comment Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="105"/>
+        <location filename="codeeditstyledialog.cpp" line="116"/>
         <source>Comment Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="108"/>
+        <location filename="codeeditstyledialog.cpp" line="119"/>
         <source>Symbol Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="111"/>
+        <location filename="codeeditstyledialog.cpp" line="122"/>
         <source>Symbol Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="114"/>
+        <location filename="codeeditstyledialog.cpp" line="125"/>
         <source>Symbol Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="130"/>
+        <location filename="codeeditstyledialog.cpp" line="141"/>
         <source>Set to Default Light</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="132"/>
+        <location filename="codeeditstyledialog.cpp" line="143"/>
         <source>Set to Default Dark</source>
         <translation type="unfinished"></translation>
     </message>
+    <message>
+        <location filename="resultstree.cpp" line="113"/>
+        <source>File</source>
+        <translation type="unfinished">Файл</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="114"/>
+        <source>Line</source>
+        <translation type="unfinished">Строка</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="115"/>
+        <source>Severity</source>
+        <translation type="unfinished">Важность</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="116"/>
+        <source>Classification</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="117"/>
+        <source>Level</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="118"/>
+        <source>Inconclusive</source>
+        <translation type="unfinished">Спорное</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="119"/>
+        <source>Summary</source>
+        <translation type="unfinished">Кратко</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="120"/>
+        <source>Id</source>
+        <translation type="unfinished">Id</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="121"/>
+        <source>Guideline</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="122"/>
+        <source>Rule</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="123"/>
+        <source>Since date</source>
+        <translation type="unfinished">Начиная с даты</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="124"/>
+        <source>Tags</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="125"/>
+        <source>CWE</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>QPlatformTheme</name>
     <message>
-        <location filename="translationhandler.cpp" line="39"/>
+        <location filename="translationhandler.cpp" line="41"/>
         <source>OK</source>
         <translation>OK</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="40"/>
+        <location filename="translationhandler.cpp" line="42"/>
         <source>Cancel</source>
         <translation>Отмена</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="41"/>
+        <location filename="translationhandler.cpp" line="43"/>
         <source>Close</source>
         <translation>Закрыть</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="42"/>
+        <location filename="translationhandler.cpp" line="44"/>
         <source>Save</source>
         <translation>Сохранить</translation>
     </message>
@@ -2046,129 +2366,116 @@ Options:
 <context>
     <name>ResultsTree</name>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>File</source>
-        <translation>Файл</translation>
+        <translation type="vanished">Файл</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Severity</source>
-        <translation>Важность</translation>
+        <translation type="vanished">Важность</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Line</source>
-        <translation>Строка</translation>
+        <translation type="vanished">Строка</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Summary</source>
-        <translation>Кратко</translation>
+        <translation type="vanished">Кратко</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="136"/>
         <source>Undefined file</source>
-        <translation>Неопределенный файл</translation>
+        <translation type="vanished">Неопределенный файл</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="614"/>
+        <location filename="resultstree.cpp" line="668"/>
         <source>Copy</source>
-        <translation type="unfinished"></translation>
+        <translation>Копировать</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="797"/>
+        <location filename="resultstree.cpp" line="836"/>
         <source>Could not find file:</source>
-        <translation type="unfinished"></translation>
+        <translation>Невозможно найти файл:</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="801"/>
+        <location filename="resultstree.cpp" line="840"/>
         <source>Please select the folder &apos;%1&apos;</source>
-        <translation type="unfinished"></translation>
+        <translation>Выберите каталог &apos;%1&apos;</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="802"/>
+        <location filename="resultstree.cpp" line="841"/>
         <source>Select Directory &apos;%1&apos;</source>
-        <translation type="unfinished"></translation>
+        <translation>Выбрать каталог &apos;%1&apos;</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="804"/>
+        <location filename="resultstree.cpp" line="843"/>
         <source>Please select the directory where file is located.</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <source>[Inconclusive]</source>
-        <translation type="obsolete">[Неубедительный]</translation>
+        <translation>Укажите каталог с расположением файла.</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="312"/>
+        <location filename="resultstree.cpp" line="373"/>
         <source>debug</source>
         <translation>отлаживать</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="249"/>
+        <location filename="resultstree.cpp" line="307"/>
         <source>note</source>
-        <translation type="unfinished"></translation>
+        <translation>заметка</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="613"/>
         <source>Recheck</source>
-        <translation>Проверить заново</translation>
-    </message>
-    <message>
-        <source>Copy filename</source>
-        <translation type="obsolete">Скопировать имя файла</translation>
+        <translation type="vanished">Проверить заново</translation>
     </message>
     <message>
-        <source>Copy full path</source>
-        <translation type="obsolete">Скопировать полный путь</translation>
+        <source>Hide</source>
+        <translation type="vanished">Скрыть</translation>
     </message>
     <message>
-        <source>Copy message</source>
-        <translation type="obsolete">Скопировать сообщение</translation>
+        <location filename="resultstree.cpp" line="670"/>
+        <source>Hide all with id</source>
+        <translation>Скрыть все с id</translation>
     </message>
     <message>
-        <source>Copy message id</source>
-        <translation type="obsolete">Скопировать номер сообщения</translation>
+        <location filename="resultstree.cpp" line="692"/>
+        <source>Suppress selected id(s)</source>
+        <translation>Подавить выбранные id</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="615"/>
-        <source>Hide</source>
-        <translation>Скрыть</translation>
+        <location filename="resultstree.cpp" line="671"/>
+        <source>Open containing folder</source>
+        <translation>Открыть содержащую папку</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="616"/>
-        <source>Hide all with id</source>
-        <translation>Скрыть все с id</translation>
+        <location filename="resultstree.cpp" line="376"/>
+        <source>internal</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="617"/>
-        <source>Suppress selected id(s)</source>
+        <location filename="resultstree.cpp" line="667"/>
+        <source>Recheck %1 file(s)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="618"/>
-        <source>Open containing folder</source>
-        <translation>Открыть содержащую папку</translation>
+        <location filename="resultstree.cpp" line="669"/>
+        <source>Hide %1 result(s)</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="648"/>
-        <location filename="resultstree.cpp" line="1343"/>
+        <location filename="resultstree.cpp" line="712"/>
         <source>Tag</source>
-        <translation type="unfinished"></translation>
+        <translation>Тег</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="650"/>
+        <location filename="resultstree.cpp" line="714"/>
         <source>No tag</source>
-        <translation type="unfinished"></translation>
+        <translation>Тег отсутствует</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="693"/>
-        <location filename="resultstree.cpp" line="707"/>
+        <location filename="resultstree.cpp" line="744"/>
+        <location filename="resultstree.cpp" line="758"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="694"/>
+        <location filename="resultstree.cpp" line="745"/>
         <source>No editor application configured.
 
 Configure the editor application for Cppcheck in preferences/Applications.</source>
@@ -2177,7 +2484,7 @@ Configure the editor application for Cppcheck in preferences/Applications.</sour
 Сконфигурируйте приложение редактора для Cppcheck в предпочтениях/Приложениях.</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="708"/>
+        <location filename="resultstree.cpp" line="759"/>
         <source>No default editor application selected.
 
 Please select the default editor application in preferences/Applications.</source>
@@ -2185,12 +2492,12 @@ Please select the default editor application in preferences/Applications.</sourc
 Выберите приложение редактора по умолчанию в предпочтениях/Приложениях.</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="737"/>
+        <location filename="resultstree.cpp" line="779"/>
         <source>Could not find the file!</source>
         <translation>Не удается найти файл!</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="783"/>
+        <location filename="resultstree.cpp" line="822"/>
         <source>Could not start %1
 
 Please check the application path and parameters are correct.</source>
@@ -2198,60 +2505,49 @@ Please check the application path and parameters are correct.</source>
 Пожалуйста, проверьте путь приложения, и верны ли параметры.</translation>
     </message>
     <message>
-        <source>Could not find file:
-%1
-Please select the directory where file is located.</source>
-        <translation type="obsolete">Не удается найти файл:
-%1		
-Пожалуйста, выберите каталог, в котором находится файл.</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="805"/>
+        <location filename="resultstree.cpp" line="844"/>
         <source>Select Directory</source>
         <translation>Выберите директорию</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Id</source>
-        <translation>Id</translation>
+        <translation type="vanished">Id</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Inconclusive</source>
-        <translation>Спорное</translation>
+        <translation type="vanished">Спорное</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Since date</source>
-        <translation type="unfinished"></translation>
+        <translation type="vanished">Начиная с даты</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="294"/>
+        <location filename="resultstree.cpp" line="355"/>
         <source>style</source>
         <translation>стиль</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="297"/>
+        <location filename="resultstree.cpp" line="358"/>
         <source>error</source>
         <translation>ошибка</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="300"/>
+        <location filename="resultstree.cpp" line="361"/>
         <source>warning</source>
         <translation>предупреждение</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="303"/>
+        <location filename="resultstree.cpp" line="364"/>
         <source>performance</source>
         <translation>производительность</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="306"/>
+        <location filename="resultstree.cpp" line="367"/>
         <source>portability</source>
         <translation>переносимость</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="309"/>
+        <location filename="resultstree.cpp" line="370"/>
         <source>information</source>
         <translation>информация</translation>
     </message>
@@ -2259,90 +2555,102 @@ Please select the directory where file is located.</source>
 <context>
     <name>ResultsView</name>
     <message>
-        <location filename="resultsview.cpp" line="201"/>
+        <location filename="resultsview.cpp" line="255"/>
         <source>Print Report</source>
         <translation>Распечатать отчет</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="220"/>
+        <location filename="resultsview.cpp" line="274"/>
         <source>No errors found, nothing to print.</source>
         <translation>Ошибок не найдено, нечего распечатывать.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="264"/>
+        <location filename="resultsview.cpp" line="326"/>
         <source>%p% (%1 of %2 files checked)</source>
         <translation>%p% (%1 из %2 файлов проверено)</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="277"/>
-        <location filename="resultsview.cpp" line="288"/>
+        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="361"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="278"/>
+        <location filename="resultsview.cpp" line="351"/>
         <source>No errors found.</source>
         <translation>Ошибок не найдено.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="285"/>
+        <location filename="resultsview.cpp" line="358"/>
         <source>Errors were found, but they are configured to be hidden.
 To toggle what kind of errors are shown, open view menu.</source>
         <translation>Были обнаружены ошибки, но они настроены быть скрыты.
 Для переключения какие ошибки отображаются, откройте меню представления.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="331"/>
-        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="421"/>
         <source>Failed to read the report.</source>
         <translation>Не удалось прочитать отчет.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="338"/>
+        <location filename="resultsview.cpp" line="409"/>
         <source>XML format version 1 is no longer supported.</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <source>Summary</source>
-        <translation type="obsolete">Кратко</translation>
+        <translation>XML формат версии 1 больше не поддерживается.</translation>
     </message>
     <message>
-        <source>Message</source>
-        <translation type="obsolete">Сообщение</translation>
-    </message>
-    <message>
-        <location filename="resultsview.cpp" line="399"/>
+        <location filename="resultsview.cpp" line="460"/>
         <source>First included by</source>
-        <translation type="unfinished"></translation>
+        <translation>Только первый включенный</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="465"/>
         <source>Id</source>
         <translation>Id</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="471"/>
+        <location filename="resultsview.cpp" line="539"/>
         <source>Clear Log</source>
-        <translation type="unfinished"></translation>
+        <translation>Очистить лог</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="472"/>
+        <location filename="resultsview.cpp" line="540"/>
         <source>Copy this Log entry</source>
-        <translation type="unfinished"></translation>
+        <translation>Скопировать данную запись</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="473"/>
+        <location filename="resultsview.cpp" line="541"/>
         <source>Copy complete Log</source>
+        <translation>Скопировать полный лог</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="549"/>
+        <source>Analysis was stopped</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="563"/>
+        <source>There was a critical error with id &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="565"/>
+        <source>when checking %1</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="567"/>
+        <source>when checking a file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="159"/>
-        <source>No errors found, nothing to save.</source>
-        <translation>Ошибки не найдены, нечего сохранять.</translation>
+        <location filename="resultsview.cpp" line="568"/>
+        <source>Analysis was aborted.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="183"/>
-        <location filename="resultsview.cpp" line="191"/>
+        <location filename="resultsview.cpp" line="237"/>
+        <location filename="resultsview.cpp" line="245"/>
         <source>Failed to save the report.</source>
         <translation>Не удалось сохранить отчет.</translation>
     </message>
@@ -2352,14 +2660,19 @@ To toggle what kind of errors are shown, open view menu.</source>
         <translation>Результаты</translation>
     </message>
     <message>
-        <location filename="resultsview.ui" line="82"/>
-        <source>Analysis Log</source>
+        <location filename="resultsview.ui" line="60"/>
+        <source>Critical errors</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.ui" line="104"/>
+        <location filename="resultsview.ui" line="92"/>
+        <source>Analysis Log</source>
+        <translation>Лог анализа</translation>
+    </message>
+    <message>
+        <location filename="resultsview.ui" line="114"/>
         <source>Warning Details</source>
-        <translation type="unfinished"></translation>
+        <translation>Детали предупреждения</translation>
     </message>
 </context>
 <context>
@@ -2372,12 +2685,12 @@ To toggle what kind of errors are shown, open view menu.</source>
     <message>
         <location filename="scratchpad.ui" line="20"/>
         <source>Copy or write some C/C++ code here:</source>
-        <translation type="unfinished"></translation>
+        <translation>Исходный код C/C++:</translation>
     </message>
     <message>
         <location filename="scratchpad.ui" line="37"/>
         <source>Optionally enter a filename (mainly for automatic language detection) and click on &quot;Check&quot;:</source>
-        <translation type="unfinished"></translation>
+        <translation>При необходимости введите имя файла и нажмите &quot;Проверить&quot;:</translation>
     </message>
     <message>
         <location filename="scratchpad.ui" line="71"/>
@@ -2403,11 +2716,7 @@ To toggle what kind of errors are shown, open view menu.</source>
         <translation>Общие</translation>
     </message>
     <message>
-        <source>Include paths:</source>
-        <translation type="obsolete">Пути для поиска заголовочных файлов:</translation>
-    </message>
-    <message>
-        <location filename="settings.ui" line="195"/>
+        <location filename="settings.ui" line="196"/>
         <source>Add...</source>
         <translation>Добавить...</translation>
     </message>
@@ -2417,500 +2726,507 @@ To toggle what kind of errors are shown, open view menu.</source>
         <translation>Количество потоков исполнения:</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="85"/>
         <source>Ideal count:</source>
-        <translation>Рекомендуемое значение:</translation>
+        <translation type="vanished">Рекомендуемое значение:</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="114"/>
+        <location filename="settings.ui" line="108"/>
         <source>Force checking all #ifdef configurations</source>
         <oldsource>Check all #ifdef configurations</oldsource>
         <translation>Проверять все варианты #ifdef конфигураций</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="121"/>
+        <location filename="settings.ui" line="115"/>
         <source>Show full path of files</source>
         <translation>Показывать полные пути к файлам</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="128"/>
+        <location filename="settings.ui" line="122"/>
         <source>Show &quot;No errors found&quot; message when no errors found</source>
         <translation>Показывать сообщение, если ошибок не найдено</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="135"/>
+        <location filename="settings.ui" line="129"/>
         <source>Display error Id in column &quot;Id&quot;</source>
         <translation>Отображать номер ошибки в колонке &quot;id&quot;</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="142"/>
+        <location filename="settings.ui" line="136"/>
         <source>Enable inline suppressions</source>
         <translation>Включить inline-подавление ошибок</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="149"/>
+        <location filename="settings.ui" line="143"/>
         <source>Check for inconclusive errors also</source>
         <translation>Показывать также спорные ошибки</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="156"/>
+        <location filename="settings.ui" line="150"/>
         <source>Show statistics on check completion</source>
         <translation>Показывать статистику после завершения проверки</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="176"/>
+        <location filename="settings.ui" line="157"/>
+        <source>Check for updates</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="177"/>
         <source>Show internal warnings in log</source>
         <translation>Показывать внутренние предупреждения в логе</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="287"/>
+        <location filename="settings.ui" line="288"/>
         <source>Addons</source>
-        <translation type="unfinished"></translation>
+        <translation>Дополнения</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="293"/>
+        <location filename="settings.ui" line="294"/>
         <source>Python binary (leave this empty to use python in the PATH)</source>
-        <translation type="unfinished"></translation>
+        <translation>Python (оставьте пустым для использования python из PATH)</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="302"/>
-        <location filename="settings.ui" line="334"/>
-        <location filename="settings.ui" line="379"/>
+        <location filename="settings.ui" line="305"/>
+        <location filename="settings.ui" line="346"/>
+        <location filename="settings.ui" line="391"/>
         <source>...</source>
-        <translation type="unfinished"></translation>
+        <translation>...</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="312"/>
-        <source>Misra addon</source>
-        <translation type="unfinished"></translation>
+        <location filename="settings.ui" line="324"/>
+        <source>MISRA addon</source>
+        <translation>Дополнение MISRA</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="320"/>
-        <source>Misra rule texts file</source>
-        <translation type="unfinished"></translation>
+        <location filename="settings.ui" line="332"/>
+        <source>MISRA rule texts file</source>
+        <translation>Файл с текстами правил MISRA: </translation>
     </message>
     <message>
-        <location filename="settings.ui" line="327"/>
+        <location filename="settings.ui" line="339"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
-        <translation type="unfinished"></translation>
+        <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Скопируйте текст из Appendix A &amp;quot;Summary of guidelines&amp;quot; из фала правил MISRA C 2012 pdf в текстовый файл.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="360"/>
+        <location filename="settings.ui" line="372"/>
         <source>Clang</source>
-        <translation type="unfinished"></translation>
+        <translation>Clang</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="366"/>
+        <location filename="settings.ui" line="378"/>
         <source>Clang path (leave empty to use system PATH)</source>
-        <translation type="unfinished"></translation>
+        <translation>Clang (оставьте пустым для использования clang из PATH)</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="389"/>
+        <location filename="settings.ui" line="401"/>
         <source>Visual Studio headers</source>
-        <translation type="unfinished"></translation>
+        <translation>Заголовочные файлы Visual Studio</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="395"/>
+        <location filename="settings.ui" line="407"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Paths to Visual Studio headers, separated by semicolon &apos;;&apos;.&lt;/p&gt;&lt;p&gt;You can open a Visual Studio command prompt, write &amp;quot;SET INCLUDE&amp;quot;. Then copy/paste the paths.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
-        <translation type="unfinished"></translation>
+        <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Путь до заголовочных файлов Visual Studio headers, разделенных символом &apos;;&apos;.&lt;/p&gt;&lt;p&gt;Вы можете открыть командную строку Visual Studio, ввести &amp;quot;SET INCLUDE&amp;quot; и скопировать пути.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="425"/>
+        <location filename="settings.ui" line="437"/>
         <source>Code Editor</source>
-        <translation type="unfinished"></translation>
+        <translation>Редактор</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="431"/>
+        <location filename="settings.ui" line="443"/>
         <source>Code Editor Style</source>
-        <translation type="unfinished"></translation>
+        <translation>Оформление</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="437"/>
+        <location filename="settings.ui" line="449"/>
         <source>System Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="444"/>
+        <location filename="settings.ui" line="456"/>
         <source>Default Light Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="451"/>
+        <location filename="settings.ui" line="463"/>
         <source>Default Dark Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="460"/>
+        <location filename="settings.ui" line="472"/>
         <source>Custom</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Paths</source>
-        <translation type="obsolete">Пути</translation>
-    </message>
-    <message>
-        <source>Edit</source>
-        <translation type="obsolete">Изменить</translation>
-    </message>
-    <message>
-        <location filename="settings.ui" line="209"/>
+        <location filename="settings.ui" line="210"/>
         <source>Remove</source>
         <translation>Удалить</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="184"/>
+        <location filename="settings.ui" line="79"/>
+        <source>Max count:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="185"/>
         <source>Applications</source>
         <translation>Приложения</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="202"/>
-        <location filename="settings.ui" line="467"/>
+        <location filename="settings.ui" line="203"/>
+        <location filename="settings.ui" line="479"/>
         <source>Edit...</source>
         <translation>Изменить...</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="216"/>
+        <location filename="settings.ui" line="217"/>
         <source>Set as default</source>
         <translation>Установить по умолчанию</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="239"/>
+        <location filename="settings.ui" line="240"/>
         <source>Reports</source>
         <translation>Отчёты</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="245"/>
+        <location filename="settings.ui" line="246"/>
         <source>Save all errors when creating report</source>
         <translation>Сохранять все ошибки при создании отчёта</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="252"/>
+        <location filename="settings.ui" line="253"/>
         <source>Save full path to files in reports</source>
         <translation>Сохранять полные пути к файлам в отчётах</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="273"/>
+        <location filename="settings.ui" line="274"/>
         <source>Language</source>
         <translation>Язык</translation>
     </message>
-    <message>
-        <source>Advanced</source>
-        <translation type="obsolete">Прочие</translation>
-    </message>
-    <message>
-        <source>&amp;Show inconclusive errors</source>
-        <translation type="obsolete">&amp;Показывать незначительные ошибки</translation>
-    </message>
-    <message>
-        <source>S&amp;how internal warnings in log</source>
-        <translation type="obsolete">&amp;Записывать внутренние предупреждения в лог</translation>
-    </message>
 </context>
 <context>
     <name>SettingsDialog</name>
     <message>
-        <location filename="settingsdialog.cpp" line="100"/>
         <source>N/A</source>
-        <translation>Нет данных</translation>
+        <translation type="vanished">Нет данных</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="200"/>
+        <location filename="settingsdialog.cpp" line="232"/>
+        <source>The executable file &quot;%1&quot; is not available</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="243"/>
         <source>Add a new application</source>
         <translation>Добавить новое приложение</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="233"/>
+        <location filename="settingsdialog.cpp" line="273"/>
         <source>Modify an application</source>
         <translation>Изменить приложение</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="238"/>
+        <location filename="settingsdialog.cpp" line="278"/>
         <source> [Default]</source>
         <translation> [По умолчанию]</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="263"/>
+        <location filename="settingsdialog.cpp" line="303"/>
         <source>[Default]</source>
         <translation>[По умолчанию]</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="318"/>
+        <location filename="settingsdialog.cpp" line="358"/>
         <source>Select python binary</source>
-        <translation type="unfinished"></translation>
+        <translation>Выберите исполняемый файл python</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="325"/>
+        <location filename="settingsdialog.cpp" line="365"/>
         <source>Select MISRA File</source>
-        <translation type="unfinished"></translation>
+        <translation>Выберите файл текстов правил MISRA</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="356"/>
+        <location filename="settingsdialog.cpp" line="396"/>
         <source>Select clang path</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <source>Select include directory</source>
-        <translation type="obsolete">Выберите директорию</translation>
+        <translation>Выберите исполняемый файл clang</translation>
     </message>
 </context>
 <context>
     <name>StatsDialog</name>
     <message>
-        <location filename="stats.ui" line="14"/>
-        <location filename="stats.ui" line="248"/>
-        <location filename="statsdialog.cpp" line="137"/>
-        <location filename="statsdialog.cpp" line="184"/>
+        <location filename="statsdialog.ui" line="14"/>
+        <location filename="statsdialog.ui" line="248"/>
+        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="230"/>
         <source>Statistics</source>
         <translation>Статистика</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="27"/>
-        <location filename="statsdialog.cpp" line="175"/>
+        <location filename="statsdialog.ui" line="27"/>
+        <location filename="statsdialog.cpp" line="221"/>
         <source>Project</source>
         <translation>Проект</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="33"/>
+        <location filename="statsdialog.ui" line="33"/>
         <source>Project:</source>
         <translation>Проект:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="53"/>
+        <location filename="statsdialog.ui" line="53"/>
         <source>Paths:</source>
         <translation>Пути:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="85"/>
+        <location filename="statsdialog.ui" line="85"/>
         <source>Include paths:</source>
         <translation>Включенные пути:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="108"/>
+        <location filename="statsdialog.ui" line="108"/>
         <source>Defines:</source>
-        <translation>Макросы:</translation>
+        <translation>Объявленные макроопределения:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="131"/>
+        <location filename="statsdialog.ui" line="131"/>
         <source>Undefines:</source>
-        <translation type="unfinished"></translation>
+        <translation>Удаленные макроопределения:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="165"/>
-        <location filename="statsdialog.cpp" line="180"/>
+        <location filename="statsdialog.ui" line="165"/>
+        <location filename="statsdialog.cpp" line="226"/>
         <source>Previous Scan</source>
         <translation>Последнее сканирование</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="171"/>
+        <location filename="statsdialog.ui" line="171"/>
         <source>Path Selected:</source>
         <translation>Выбранный путь:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="181"/>
+        <location filename="statsdialog.ui" line="181"/>
         <source>Number of Files Scanned:</source>
         <translation>Количество просканированных файлов:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="201"/>
+        <location filename="statsdialog.ui" line="201"/>
         <source>Scan Duration:</source>
         <translation>Продолжительность сканирования:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="256"/>
+        <location filename="statsdialog.ui" line="254"/>
         <source>Errors:</source>
         <translation>Ошибки:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="274"/>
+        <location filename="statsdialog.ui" line="271"/>
         <source>Warnings:</source>
         <translation>Предупреждения:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="292"/>
+        <location filename="statsdialog.ui" line="288"/>
         <source>Stylistic warnings:</source>
         <translation>Стилистические предупреждения:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="310"/>
+        <location filename="statsdialog.ui" line="305"/>
         <source>Portability warnings:</source>
         <translation>Предупреждения переносимости:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="328"/>
+        <location filename="statsdialog.ui" line="322"/>
         <source>Performance issues:</source>
         <translation>Проблемы с производительностью:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="346"/>
+        <location filename="statsdialog.ui" line="339"/>
         <source>Information messages:</source>
         <translation>Информационные сообщения:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="363"/>
-        <source>History</source>
+        <location filename="statsdialog.ui" line="356"/>
+        <source>Active checkers:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="369"/>
-        <source>File:</source>
+        <location filename="statsdialog.ui" line="374"/>
+        <source>Checkers</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="407"/>
+        <location filename="statsdialog.ui" line="399"/>
+        <source>History</source>
+        <translation>История</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="405"/>
+        <source>File:</source>
+        <translation>Файл:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="443"/>
         <source>Copy to Clipboard</source>
         <translation>Скопировать в буфер обмена</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="414"/>
+        <location filename="statsdialog.ui" line="450"/>
         <source>Pdf Export</source>
-        <translation type="unfinished"></translation>
+        <translation>Экспорт PDF</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="113"/>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>1 day</source>
         <translation>1 день</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="113"/>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>%1 days</source>
         <translation>%1 дней</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="115"/>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>1 hour</source>
         <translation>1 час</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="115"/>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>%1 hours</source>
         <translation>%1 часов</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="117"/>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>1 minute</source>
         <translation>1 минута</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="117"/>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>%1 minutes</source>
         <translation>%1 минут</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="119"/>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>1 second</source>
         <translation>1 секунда</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="119"/>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>%1 seconds</source>
         <translation>%1 секунд</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="123"/>
+        <location filename="statsdialog.cpp" line="169"/>
         <source>0.%1 seconds</source>
         <translation>0.1%1 секунд</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="125"/>
+        <location filename="statsdialog.cpp" line="171"/>
         <source> and </source>
         <translation>и</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="152"/>
+        <location filename="statsdialog.cpp" line="198"/>
         <source>Export PDF</source>
-        <translation type="unfinished"></translation>
+        <translation>Экспорт PDF</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="174"/>
+        <location filename="statsdialog.cpp" line="220"/>
         <source>Project Settings</source>
         <translation>Настройки проекта</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="176"/>
+        <location filename="statsdialog.cpp" line="222"/>
         <source>Paths</source>
         <translation>Пути</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="177"/>
+        <location filename="statsdialog.cpp" line="223"/>
         <source>Include paths</source>
         <translation>Включенные пути</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="178"/>
+        <location filename="statsdialog.cpp" line="224"/>
         <source>Defines</source>
-        <translation>Макросы</translation>
+        <translation>Объявленные макроопределения:</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="179"/>
+        <location filename="statsdialog.cpp" line="225"/>
         <source>Undefines</source>
-        <translation type="unfinished"></translation>
+        <translation>Удаленные макроопределения:</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="181"/>
+        <location filename="statsdialog.cpp" line="227"/>
         <source>Path selected</source>
         <translation>Выбранные пути</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="182"/>
+        <location filename="statsdialog.cpp" line="228"/>
         <source>Number of files scanned</source>
         <translation>Количество просканированных файлов</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="229"/>
         <source>Scan duration</source>
         <translation>Продолжительность сканирования</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="139"/>
         <location filename="statsdialog.cpp" line="185"/>
+        <location filename="statsdialog.cpp" line="231"/>
         <source>Errors</source>
         <translation>Ошибки</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="65"/>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>File: </source>
-        <translation type="unfinished"></translation>
+        <translation>Файл: </translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="65"/>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>No cppcheck build dir</source>
-        <translation type="unfinished"></translation>
+        <translation>Не задана директория сборки</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="141"/>
-        <location filename="statsdialog.cpp" line="186"/>
+        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="232"/>
         <source>Warnings</source>
         <translation>Предупреждения</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="143"/>
-        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="233"/>
         <source>Style warnings</source>
         <translation>Стилистические предупреждения</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="145"/>
-        <location filename="statsdialog.cpp" line="188"/>
+        <location filename="statsdialog.cpp" line="191"/>
+        <location filename="statsdialog.cpp" line="234"/>
         <source>Portability warnings</source>
         <translation>Предупреждения переносимости</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="147"/>
-        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="193"/>
+        <location filename="statsdialog.cpp" line="235"/>
         <source>Performance warnings</source>
         <translation>Предупреждения производительности</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="149"/>
-        <location filename="statsdialog.cpp" line="190"/>
+        <location filename="statsdialog.cpp" line="195"/>
+        <location filename="statsdialog.cpp" line="236"/>
         <source>Information messages</source>
         <translation>Информационные сообщения</translation>
     </message>
 </context>
+<context>
+    <name>ThreadDetails</name>
+    <message>
+        <location filename="threaddetails.ui" line="14"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>ThreadResult</name>
     <message>
-        <location filename="threadresult.cpp" line="54"/>
+        <location filename="threadresult.cpp" line="47"/>
         <source>%1 of %2 files checked</source>
         <translation>%1 из %2 файлов проверены</translation>
     </message>
@@ -2918,7 +3234,7 @@ To toggle what kind of errors are shown, open view menu.</source>
 <context>
     <name>TranslationHandler</name>
     <message>
-        <location filename="translationhandler.cpp" line="145"/>
+        <location filename="translationhandler.cpp" line="130"/>
         <source>Failed to change the user interface language:
 
 %1
@@ -2931,7 +3247,7 @@ The user interface language has been reset to English. Open the Preferences-dial
 Язык пользовательского интерфейса был сброшен на английский. Откройте Настройки-диалог для выбора любого из доступных языков.</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="151"/>
+        <location filename="translationhandler.cpp" line="136"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
@@ -2939,7 +3255,7 @@ The user interface language has been reset to English. Open the Preferences-dial
 <context>
     <name>TxtReport</name>
     <message>
-        <location filename="txtreport.cpp" line="73"/>
+        <location filename="txtreport.cpp" line="74"/>
         <source>inconclusive</source>
         <translation>незначительная</translation>
     </message>
@@ -2947,14 +3263,14 @@ The user interface language has been reset to English. Open the Preferences-dial
 <context>
     <name>toFilterString</name>
     <message>
-        <location filename="common.cpp" line="52"/>
+        <location filename="common.cpp" line="58"/>
         <source>All supported files (%1)</source>
-        <translation type="unfinished"></translation>
+        <translation>Все поддерживаемые файлы (%1)</translation>
     </message>
     <message>
-        <location filename="common.cpp" line="57"/>
+        <location filename="common.cpp" line="63"/>
         <source>All files (%1)</source>
-        <translation type="unfinished"></translation>
+        <translation>Все файлы (%1)</translation>
     </message>
 </context>
 </TS>
diff --git a/gui/cppcheck_sr.ts b/gui/cppcheck_sr.ts
index d9ca4ea6429..70b04dd196f 100644
--- a/gui/cppcheck_sr.ts
+++ b/gui/cppcheck_sr.ts
@@ -20,8 +20,8 @@
     </message>
     <message>
         <location filename="about.ui" line="81"/>
-        <source>Copyright © 2007-2019 Cppcheck team.</source>
-        <oldsource>Copyright © 2007-2018 Cppcheck team.</oldsource>
+        <source>Copyright © 2007-%1 Cppcheck team.</source>
+        <oldsource>Copyright © 2007-2021 Cppcheck team.</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
@@ -38,24 +38,20 @@ of the GNU General Public License version 3</translation>
     </message>
     <message>
         <location filename="about.ui" line="115"/>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
-&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul&gt;
-&lt;li&gt;tinyxml2&lt;/li&gt;
-&lt;li&gt;picojson&lt;/li&gt;
-&lt;li&gt;pcre&lt;/li&gt;
-&lt;li&gt;qt&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PCRE&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PicoJSON&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;TinyXML2&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Boost&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <oldsource>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;pcre&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;picojson&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;tinyxml2&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</oldsource>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>ApplicationDialog</name>
     <message>
-        <location filename="application.ui" line="23"/>
+        <location filename="applicationdialog.ui" line="23"/>
         <source>Add an application</source>
         <translation type="unfinished">Add a new application</translation>
     </message>
     <message>
-        <location filename="application.ui" line="41"/>
+        <location filename="applicationdialog.ui" line="41"/>
         <source>Here you can add an application that can open error files. Specify a name for the application, the application executable and command line parameters for the application.
 
 The following texts in parameters are replaced with appropriate values when application is executed:
@@ -70,65 +66,157 @@ Parameters: -l(line) (file)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="application.ui" line="76"/>
+        <location filename="applicationdialog.ui" line="76"/>
         <source>&amp;Name:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="application.ui" line="86"/>
+        <location filename="applicationdialog.ui" line="86"/>
         <source>&amp;Executable:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="application.ui" line="96"/>
+        <location filename="applicationdialog.ui" line="96"/>
         <source>&amp;Parameters:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="application.ui" line="138"/>
+        <location filename="applicationdialog.ui" line="138"/>
         <source>Browse</source>
         <translation type="unfinished">Browse</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="59"/>
+        <location filename="applicationdialog.cpp" line="65"/>
         <source>Executable files (*.exe);;All files(*.*)</source>
         <translation type="unfinished">Executable files (*.exe);;All files(*.*)</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="62"/>
+        <location filename="applicationdialog.cpp" line="68"/>
         <source>Select viewer application</source>
         <translation type="unfinished">Select viewer application</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="77"/>
+        <location filename="applicationdialog.cpp" line="83"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="78"/>
+        <location filename="applicationdialog.cpp" line="84"/>
         <source>You must specify a name, a path and optionally parameters for the application!</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
+<context>
+    <name>ComplianceReportDialog</name>
+    <message>
+        <location filename="compliancereportdialog.ui" line="14"/>
+        <source>Compliance Report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="29"/>
+        <source>Project name</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="22"/>
+        <source>Project version</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="42"/>
+        <source>Coding Standard</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="50"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="55"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="60"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="70"/>
+        <source>List of files with md5 checksums</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="133"/>
+        <source>Compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="135"/>
+        <source>HTML files (*.html)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="176"/>
+        <location filename="compliancereportdialog.cpp" line="239"/>
+        <source>Save compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="177"/>
+        <source>Failed to import &apos;%1&apos; (%2), can not show files in compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>FileViewDialog</name>
     <message>
-        <location filename="fileviewdialog.cpp" line="42"/>
+        <location filename="fileviewdialog.cpp" line="53"/>
         <source>Could not find the file: %1</source>
         <translation type="unfinished">Could not find the file: %1</translation>
     </message>
     <message>
-        <location filename="fileviewdialog.cpp" line="46"/>
-        <location filename="fileviewdialog.cpp" line="60"/>
+        <location filename="fileviewdialog.cpp" line="57"/>
+        <location filename="fileviewdialog.cpp" line="71"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="fileviewdialog.cpp" line="56"/>
+        <location filename="fileviewdialog.cpp" line="67"/>
         <source>Could not read the file: %1</source>
         <translation type="unfinished">Could not read the file: %1</translation>
     </message>
 </context>
+<context>
+    <name>HelpDialog</name>
+    <message>
+        <location filename="helpdialog.ui" line="14"/>
+        <source>Cppcheck GUI help</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="34"/>
+        <source>Contents</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="44"/>
+        <source>Index</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="84"/>
+        <source>Helpfile &apos;%1&apos; was not found</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="86"/>
+        <source>Cppcheck</source>
+        <translation type="unfinished">Cppcheck</translation>
+    </message>
+</context>
 <context>
     <name>LibraryAddFunctionDialog</name>
     <message>
@@ -235,42 +323,42 @@ Parameters: -l(line) (file)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="82"/>
-        <location filename="librarydialog.cpp" line="154"/>
+        <location filename="librarydialog.cpp" line="97"/>
+        <location filename="librarydialog.cpp" line="169"/>
         <source>Library files (*.cfg)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="84"/>
+        <location filename="librarydialog.cpp" line="99"/>
         <source>Open library file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="95"/>
-        <location filename="librarydialog.cpp" line="107"/>
-        <location filename="librarydialog.cpp" line="144"/>
+        <location filename="librarydialog.cpp" line="110"/>
+        <location filename="librarydialog.cpp" line="122"/>
+        <location filename="librarydialog.cpp" line="159"/>
         <source>Cppcheck</source>
         <translation type="unfinished">Cppcheck</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="96"/>
+        <location filename="librarydialog.cpp" line="111"/>
         <source>Cannot open file %1.</source>
         <oldsource>Can not open file %1.</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="108"/>
+        <location filename="librarydialog.cpp" line="123"/>
         <source>Failed to load %1. %2.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="145"/>
+        <location filename="librarydialog.cpp" line="160"/>
         <source>Cannot save file %1.</source>
         <oldsource>Can not save file %1.</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="157"/>
+        <location filename="librarydialog.cpp" line="172"/>
         <source>Save the library as</source>
         <translation type="unfinished"></translation>
     </message>
@@ -385,786 +473,849 @@ Parameters: -l(line) (file)</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
-<context>
-    <name>LogView</name>
-    <message>
-        <source>Cppcheck</source>
-        <translation type="obsolete">Cppcheck</translation>
-    </message>
-</context>
 <context>
     <name>MainWindow</name>
     <message>
         <location filename="mainwindow.ui" line="26"/>
-        <location filename="mainwindow.ui" line="595"/>
-        <location filename="mainwindow.cpp" line="328"/>
-        <location filename="mainwindow.cpp" line="480"/>
-        <location filename="mainwindow.cpp" line="553"/>
-        <location filename="mainwindow.cpp" line="658"/>
-        <location filename="mainwindow.cpp" line="680"/>
-        <location filename="mainwindow.cpp" line="1113"/>
-        <location filename="mainwindow.cpp" line="1238"/>
-        <location filename="mainwindow.cpp" line="1359"/>
-        <location filename="mainwindow.cpp" line="1499"/>
-        <location filename="mainwindow.cpp" line="1522"/>
-        <location filename="mainwindow.cpp" line="1593"/>
-        <location filename="mainwindow.cpp" line="1667"/>
+        <location filename="mainwindow.ui" line="688"/>
+        <location filename="mainwindow.cpp" line="466"/>
+        <location filename="mainwindow.cpp" line="670"/>
+        <location filename="mainwindow.cpp" line="755"/>
+        <location filename="mainwindow.cpp" line="860"/>
+        <location filename="mainwindow.cpp" line="882"/>
+        <location filename="mainwindow.cpp" line="1467"/>
+        <location filename="mainwindow.cpp" line="1596"/>
+        <location filename="mainwindow.cpp" line="1937"/>
+        <location filename="mainwindow.cpp" line="1945"/>
+        <location filename="mainwindow.cpp" line="1999"/>
+        <location filename="mainwindow.cpp" line="2008"/>
+        <location filename="mainwindow.cpp" line="2080"/>
+        <location filename="mainwindow.cpp" line="2168"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="131"/>
+        <location filename="mainwindow.ui" line="210"/>
         <source>A&amp;nalyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="183"/>
+        <location filename="mainwindow.ui" line="267"/>
         <source>Standard</source>
         <translation type="unfinished">Standard</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="70"/>
+        <location filename="mainwindow.ui" line="132"/>
         <source>&amp;File</source>
         <translation type="unfinished">&amp;File</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="89"/>
+        <location filename="mainwindow.ui" line="152"/>
         <source>&amp;View</source>
         <translation type="unfinished">&amp;View</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="93"/>
+        <location filename="mainwindow.ui" line="156"/>
         <source>&amp;Toolbars</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>&amp;Check</source>
-        <translation type="obsolete">&amp;Check</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="135"/>
+        <location filename="mainwindow.ui" line="214"/>
         <source>C++ standard</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="145"/>
+        <location filename="mainwindow.ui" line="226"/>
         <source>&amp;C standard</source>
         <oldsource>C standard</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="170"/>
+        <location filename="mainwindow.ui" line="254"/>
         <source>&amp;Edit</source>
         <translation type="unfinished">&amp;Edit</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="231"/>
+        <location filename="mainwindow.ui" line="315"/>
         <source>&amp;License...</source>
         <translation type="unfinished">&amp;License...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="236"/>
+        <location filename="mainwindow.ui" line="320"/>
         <source>A&amp;uthors...</source>
         <translation type="unfinished">A&amp;uthors...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="245"/>
+        <location filename="mainwindow.ui" line="329"/>
         <source>&amp;About...</source>
         <translation type="unfinished">&amp;About...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="250"/>
+        <location filename="mainwindow.ui" line="334"/>
         <source>&amp;Files...</source>
         <translation type="unfinished">&amp;Files...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="253"/>
-        <location filename="mainwindow.ui" line="256"/>
+        <location filename="mainwindow.ui" line="337"/>
+        <location filename="mainwindow.ui" line="340"/>
         <source>Analyze files</source>
         <oldsource>Check files</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="259"/>
+        <location filename="mainwindow.ui" line="343"/>
         <source>Ctrl+F</source>
         <translation type="unfinished">Ctrl+F</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="268"/>
+        <location filename="mainwindow.ui" line="352"/>
         <source>&amp;Directory...</source>
         <translation type="unfinished">&amp;Directory...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="271"/>
-        <location filename="mainwindow.ui" line="274"/>
+        <location filename="mainwindow.ui" line="355"/>
+        <location filename="mainwindow.ui" line="358"/>
         <source>Analyze directory</source>
         <oldsource>Check directory</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="277"/>
+        <location filename="mainwindow.ui" line="361"/>
         <source>Ctrl+D</source>
         <translation type="unfinished">Ctrl+D</translation>
     </message>
     <message>
-        <source>&amp;Recheck files</source>
-        <translation type="obsolete">&amp;Recheck files</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="289"/>
+        <location filename="mainwindow.ui" line="373"/>
         <source>Ctrl+R</source>
         <translation type="unfinished">Ctrl+R</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="307"/>
+        <location filename="mainwindow.ui" line="391"/>
         <source>&amp;Stop</source>
         <translation type="unfinished">&amp;Stop</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="310"/>
-        <location filename="mainwindow.ui" line="313"/>
+        <location filename="mainwindow.ui" line="394"/>
+        <location filename="mainwindow.ui" line="397"/>
         <source>Stop analysis</source>
         <oldsource>Stop checking</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="316"/>
+        <location filename="mainwindow.ui" line="400"/>
         <source>Esc</source>
         <translation type="unfinished">Esc</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="325"/>
+        <location filename="mainwindow.ui" line="409"/>
         <source>&amp;Save results to file...</source>
         <translation type="unfinished">&amp;Save results to file...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="328"/>
+        <location filename="mainwindow.ui" line="412"/>
         <source>Ctrl+S</source>
         <translation type="unfinished">Ctrl+S</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="333"/>
+        <location filename="mainwindow.ui" line="417"/>
         <source>&amp;Quit</source>
         <translation type="unfinished">&amp;Quit</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="342"/>
+        <location filename="mainwindow.ui" line="429"/>
         <source>&amp;Clear results</source>
         <translation type="unfinished">&amp;Clear results</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="351"/>
+        <location filename="mainwindow.ui" line="438"/>
         <source>&amp;Preferences</source>
         <translation type="unfinished">&amp;Preferences</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="384"/>
-        <location filename="mainwindow.ui" line="387"/>
+        <location filename="mainwindow.ui" line="471"/>
+        <location filename="mainwindow.ui" line="474"/>
+        <location filename="mainwindow.cpp" line="2394"/>
         <source>Show errors</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="524"/>
-        <location filename="mainwindow.ui" line="527"/>
+        <location filename="mainwindow.ui" line="617"/>
+        <location filename="mainwindow.ui" line="620"/>
+        <location filename="mainwindow.cpp" line="2395"/>
         <source>Show warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="542"/>
-        <location filename="mainwindow.ui" line="545"/>
+        <location filename="mainwindow.ui" line="635"/>
+        <location filename="mainwindow.ui" line="638"/>
         <source>Show performance warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="553"/>
+        <location filename="mainwindow.ui" line="646"/>
         <source>Show &amp;hidden</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="769"/>
-        <location filename="mainwindow.cpp" line="807"/>
+        <location filename="mainwindow.cpp" line="986"/>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Information</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="568"/>
+        <location filename="mainwindow.ui" line="661"/>
         <source>Show information messages</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="583"/>
+        <location filename="mainwindow.ui" line="676"/>
         <source>Show portability warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="598"/>
+        <location filename="mainwindow.ui" line="691"/>
         <source>Show Cppcheck results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="610"/>
+        <location filename="mainwindow.ui" line="703"/>
         <source>Clang</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="613"/>
+        <location filename="mainwindow.ui" line="706"/>
         <source>Show Clang results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="621"/>
+        <location filename="mainwindow.ui" line="714"/>
         <source>&amp;Filter</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="624"/>
+        <location filename="mainwindow.ui" line="717"/>
         <source>Filter results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="640"/>
+        <location filename="mainwindow.ui" line="733"/>
         <source>Windows 32-bit ANSI</source>
         <translation>Windows 32-bit ANSI</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="648"/>
+        <location filename="mainwindow.ui" line="741"/>
         <source>Windows 32-bit Unicode</source>
         <translation>Windows 32-bit Unicode</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="656"/>
+        <location filename="mainwindow.ui" line="749"/>
         <source>Unix 32-bit</source>
         <translation>Unix 32-bit</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="664"/>
+        <location filename="mainwindow.ui" line="757"/>
         <source>Unix 64-bit</source>
         <translation>Unix 64-bit</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="672"/>
+        <location filename="mainwindow.ui" line="765"/>
         <source>Windows 64-bit</source>
         <translation>Windows 64-bit</translation>
     </message>
     <message>
-        <source>C++11</source>
-        <translation type="obsolete">C++11</translation>
-    </message>
-    <message>
-        <source>C99</source>
-        <translation type="obsolete">C99</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="742"/>
+        <location filename="mainwindow.ui" line="859"/>
         <source>&amp;Print...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="745"/>
+        <location filename="mainwindow.ui" line="862"/>
         <source>Print the Current Report</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="750"/>
+        <location filename="mainwindow.ui" line="867"/>
         <source>Print Pre&amp;view...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="753"/>
+        <location filename="mainwindow.ui" line="870"/>
         <source>Open a Print Preview Dialog for the Current Results</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="761"/>
+        <location filename="mainwindow.ui" line="878"/>
         <source>Open library editor</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Gtk</source>
-        <translation type="obsolete">Gtk</translation>
-    </message>
-    <message>
-        <source>Posix</source>
-        <translation type="obsolete">Posix</translation>
-    </message>
-    <message>
-        <source>C11</source>
-        <translation type="obsolete">C11</translation>
+        <location filename="mainwindow.ui" line="479"/>
+        <source>&amp;Check all</source>
+        <translation type="unfinished">&amp;Check all</translation>
     </message>
     <message>
-        <source>C89</source>
-        <translation type="obsolete">C89</translation>
+        <location filename="mainwindow.ui" line="84"/>
+        <source>Checking for updates</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>C++03</source>
-        <translation type="obsolete">C++03</translation>
+        <location filename="mainwindow.ui" line="100"/>
+        <source>Hide</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="392"/>
-        <source>&amp;Check all</source>
-        <translation type="unfinished">&amp;Check all</translation>
+        <location filename="mainwindow.ui" line="164"/>
+        <location filename="mainwindow.ui" line="980"/>
+        <source>Report</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="220"/>
+        <location filename="mainwindow.ui" line="304"/>
         <source>Filter</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="286"/>
+        <location filename="mainwindow.ui" line="370"/>
         <source>&amp;Reanalyze modified files</source>
         <oldsource>&amp;Recheck modified files</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="298"/>
+        <location filename="mainwindow.ui" line="382"/>
         <source>Reanal&amp;yze all files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="363"/>
+        <location filename="mainwindow.ui" line="420"/>
+        <source>Ctrl+Q</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="450"/>
         <source>Style war&amp;nings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="381"/>
+        <location filename="mainwindow.ui" line="468"/>
         <source>E&amp;rrors</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="397"/>
+        <location filename="mainwindow.ui" line="484"/>
         <source>&amp;Uncheck all</source>
         <translation type="unfinished">&amp;Uncheck all</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="402"/>
+        <location filename="mainwindow.ui" line="489"/>
         <source>Collapse &amp;all</source>
         <translation type="unfinished">Collapse &amp;all</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="407"/>
+        <location filename="mainwindow.ui" line="494"/>
         <source>&amp;Expand all</source>
         <translation type="unfinished">&amp;Expand all</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="415"/>
+        <location filename="mainwindow.ui" line="502"/>
         <source>&amp;Standard</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="418"/>
+        <location filename="mainwindow.ui" line="505"/>
         <source>Standard items</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="434"/>
+        <location filename="mainwindow.ui" line="521"/>
         <source>Toolbar</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="442"/>
+        <location filename="mainwindow.ui" line="529"/>
         <source>&amp;Categories</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="445"/>
+        <location filename="mainwindow.ui" line="532"/>
         <source>Error categories</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="450"/>
+        <location filename="mainwindow.ui" line="537"/>
         <source>&amp;Open XML...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="459"/>
+        <location filename="mainwindow.ui" line="546"/>
         <source>Open P&amp;roject File...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="468"/>
+        <location filename="mainwindow.ui" line="549"/>
+        <source>Ctrl+Shift+O</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="558"/>
         <source>Sh&amp;ow Scratchpad...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="473"/>
+        <location filename="mainwindow.ui" line="563"/>
         <source>&amp;New Project File...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="478"/>
+        <location filename="mainwindow.ui" line="566"/>
+        <source>Ctrl+Shift+N</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="571"/>
         <source>&amp;Log View</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="481"/>
+        <location filename="mainwindow.ui" line="574"/>
         <source>Log View</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="489"/>
+        <location filename="mainwindow.ui" line="582"/>
         <source>C&amp;lose Project File</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="497"/>
+        <location filename="mainwindow.ui" line="590"/>
         <source>&amp;Edit Project File...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="509"/>
+        <location filename="mainwindow.ui" line="602"/>
         <source>&amp;Statistics</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="521"/>
+        <location filename="mainwindow.ui" line="614"/>
         <source>&amp;Warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="539"/>
+        <location filename="mainwindow.ui" line="632"/>
         <source>Per&amp;formance warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="565"/>
+        <location filename="mainwindow.ui" line="658"/>
         <source>&amp;Information</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="580"/>
+        <location filename="mainwindow.ui" line="673"/>
         <source>&amp;Portability</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="680"/>
+        <location filename="mainwindow.ui" line="773"/>
         <source>P&amp;latforms</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="694"/>
+        <location filename="mainwindow.ui" line="787"/>
         <source>C++&amp;11</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="705"/>
+        <location filename="mainwindow.ui" line="798"/>
         <source>C&amp;99</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="713"/>
+        <location filename="mainwindow.ui" line="806"/>
         <source>&amp;Posix</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="721"/>
+        <location filename="mainwindow.ui" line="814"/>
         <source>C&amp;11</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="729"/>
+        <location filename="mainwindow.ui" line="846"/>
         <source>&amp;C89</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="737"/>
+        <location filename="mainwindow.ui" line="854"/>
         <source>&amp;C++03</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="758"/>
+        <location filename="mainwindow.ui" line="875"/>
         <source>&amp;Library Editor...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="769"/>
+        <location filename="mainwindow.ui" line="886"/>
         <source>&amp;Auto-detect language</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="777"/>
+        <location filename="mainwindow.ui" line="894"/>
         <source>&amp;Enforce C++</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="785"/>
+        <location filename="mainwindow.ui" line="902"/>
         <source>E&amp;nforce C</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="796"/>
+        <location filename="mainwindow.ui" line="913"/>
         <source>C++14</source>
         <translation type="unfinished">C++14</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="804"/>
+        <location filename="mainwindow.ui" line="921"/>
         <source>Reanalyze and check library</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="812"/>
+        <location filename="mainwindow.ui" line="929"/>
         <source>Check configuration (defines, includes)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="820"/>
+        <location filename="mainwindow.ui" line="937"/>
         <source>C++17</source>
         <translation type="unfinished">C++17</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="831"/>
+        <location filename="mainwindow.ui" line="948"/>
         <source>C++20</source>
         <translation type="unfinished">C++20</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="423"/>
+        <location filename="mainwindow.ui" line="975"/>
+        <source>Compliance report...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="988"/>
+        <source>Normal</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="996"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1004"/>
+        <source>Misra C++ 2008</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1012"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1020"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1028"/>
+        <source>Misra C++ 2023</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1036"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1041"/>
+        <source>EULA...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1046"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1049"/>
+        <source>Show thread details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="510"/>
         <source>&amp;Contents</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="201"/>
+        <location filename="mainwindow.ui" line="285"/>
         <source>Categories</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="366"/>
-        <location filename="mainwindow.ui" line="369"/>
+        <location filename="mainwindow.ui" line="453"/>
+        <location filename="mainwindow.ui" line="456"/>
         <source>Show style warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="426"/>
+        <location filename="mainwindow.ui" line="513"/>
         <source>Open the help contents</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="429"/>
+        <location filename="mainwindow.ui" line="516"/>
         <source>F1</source>
         <translation>F1</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="121"/>
+        <location filename="mainwindow.ui" line="199"/>
         <source>&amp;Help</source>
         <translation type="unfinished">&amp;Help</translation>
     </message>
     <message>
-        <source>Select directory to check</source>
-        <translation type="obsolete">Select directory to check</translation>
-    </message>
-    <message>
-        <source>No suitable files found to check!</source>
-        <translation type="obsolete">No suitable files found to check!</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="87"/>
+        <location filename="mainwindow.cpp" line="157"/>
+        <location filename="mainwindow.cpp" line="1782"/>
         <source>Quick Filter:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="629"/>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select configuration</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="659"/>
+        <location filename="mainwindow.cpp" line="861"/>
         <source>Found project file: %1
 
 Do you want to load this project file instead?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="778"/>
+        <location filename="mainwindow.cpp" line="995"/>
         <source>File not found</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="781"/>
+        <location filename="mainwindow.cpp" line="998"/>
         <source>Bad XML</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="784"/>
+        <location filename="mainwindow.cpp" line="1001"/>
         <source>Missing attribute</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="787"/>
+        <location filename="mainwindow.cpp" line="1004"/>
         <source>Bad attribute value</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="807"/>
+        <location filename="mainwindow.cpp" line="1016"/>
+        <source>Duplicate define</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Failed to load the selected library &apos;%1&apos;.
 %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1280"/>
+        <location filename="mainwindow.cpp" line="1035"/>
+        <source>File not found: &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1058"/>
+        <source>Failed to load/setup addon %1: %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <source>Failed to load %1 - %2
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
+        <source>%1
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1648"/>
         <source>License</source>
         <translation type="unfinished">License</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1287"/>
+        <location filename="mainwindow.cpp" line="1655"/>
         <source>Authors</source>
         <translation type="unfinished">Authors</translation>
     </message>
     <message>
-        <source>XML files version 2 (*.xml);;XML files version 1 (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
-        <translation type="obsolete">XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1302"/>
+        <location filename="mainwindow.cpp" line="1675"/>
         <source>Save the report file</source>
         <translation type="unfinished">Save the report file</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1129"/>
-        <location filename="mainwindow.cpp" line="1309"/>
+        <location filename="mainwindow.cpp" line="1483"/>
+        <location filename="mainwindow.cpp" line="1682"/>
         <source>XML files (*.xml)</source>
         <translation type="unfinished">XML files (*.xml)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="323"/>
+        <location filename="mainwindow.cpp" line="461"/>
         <source>There was a problem with loading the editor application settings.
 
 This is probably because the settings were changed between the Cppcheck versions. Please check (and fix) the editor application settings, otherwise the editor program might not start correctly.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="554"/>
+        <location filename="mainwindow.cpp" line="756"/>
         <source>You must close the project file before selecting new files or directories!</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Select files to check</source>
-        <translation type="obsolete">Select files to check</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="769"/>
+        <location filename="mainwindow.cpp" line="986"/>
         <source>The library &apos;%1&apos; contains unknown elements:
 %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="790"/>
+        <location filename="mainwindow.cpp" line="1007"/>
         <source>Unsupported format</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="793"/>
+        <location filename="mainwindow.cpp" line="1010"/>
         <source>Duplicate platform type</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="796"/>
+        <location filename="mainwindow.cpp" line="1013"/>
         <source>Platform type redefined</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="799"/>
+        <location filename="mainwindow.cpp" line="1019"/>
         <source>Unknown element</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="802"/>
-        <source>Unknown issue</source>
+        <location filename="mainwindow.cpp" line="1019"/>
+        <source>Unknown element</source>
+        <oldsource>Unknown issue</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="828"/>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
         <source>Error</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="828"/>
-        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1131"/>
+        <location filename="mainwindow.cpp" line="1485"/>
         <source>Open the report file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1313"/>
+        <location filename="mainwindow.cpp" line="1686"/>
         <source>Text files (*.txt)</source>
         <translation type="unfinished">Text files (*.txt)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1317"/>
+        <location filename="mainwindow.cpp" line="1690"/>
         <source>CSV files (*.csv)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1361"/>
-        <source>Cppcheck - %1</source>
-        <translation>Cppcheck - %1</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1407"/>
+        <location filename="mainwindow.cpp" line="1820"/>
         <source>Project files (*.cppcheck);;All files(*.*)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1409"/>
+        <location filename="mainwindow.cpp" line="1822"/>
         <source>Select Project File</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="159"/>
-        <location filename="mainwindow.cpp" line="1437"/>
-        <location filename="mainwindow.cpp" line="1562"/>
+        <location filename="mainwindow.cpp" line="242"/>
+        <location filename="mainwindow.cpp" line="1784"/>
+        <location filename="mainwindow.cpp" line="1850"/>
+        <location filename="mainwindow.cpp" line="2048"/>
         <source>Project:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="481"/>
+        <location filename="mainwindow.cpp" line="671"/>
         <source>No suitable files found to analyze!</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="568"/>
+        <location filename="mainwindow.cpp" line="770"/>
         <source>C/C++ Source</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="569"/>
+        <location filename="mainwindow.cpp" line="771"/>
         <source>Compile database</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="570"/>
+        <location filename="mainwindow.cpp" line="772"/>
         <source>Visual Studio</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="571"/>
+        <location filename="mainwindow.cpp" line="773"/>
         <source>Borland C++ Builder 6</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="574"/>
+        <location filename="mainwindow.cpp" line="776"/>
         <source>Select files to analyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="589"/>
+        <location filename="mainwindow.cpp" line="791"/>
         <source>Select directory to analyze</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="629"/>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select the configuration that will be analyzed</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="681"/>
+        <location filename="mainwindow.cpp" line="883"/>
         <source>Found project files from the directory.
 
 Do you want to proceed analysis without using any of these project files?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1114"/>
+        <location filename="mainwindow.cpp" line="1468"/>
         <source>Current results will be cleared.
 
 Opening a new XML file will clear current results.
@@ -1172,44 +1323,81 @@ Do you want to proceed?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1234"/>
+        <location filename="mainwindow.cpp" line="1592"/>
         <source>Analyzer is running.
 
 Do you want to stop the analysis and exit Cppcheck?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1300"/>
+        <location filename="mainwindow.cpp" line="1634"/>
+        <source>About</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1673"/>
         <source>XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1500"/>
+        <location filename="mainwindow.cpp" line="1713"/>
+        <source>Cannot generate a compliance report right now, an analysis must finish successfully. Try to reanalyze the code and ensure there are no critical errors.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1938"/>
         <source>Build dir &apos;%1&apos; does not exist, create it?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1523"/>
-        <source>Failed to import &apos;%1&apos;, analysis is stopped</source>
+        <location filename="mainwindow.cpp" line="1946"/>
+        <source>To check the project using addons, you need a build directory.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1978"/>
+        <source>Failed to open file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1981"/>
+        <source>Unknown project file format</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1984"/>
+        <source>Failed to import project file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2000"/>
+        <source>Failed to import &apos;%1&apos;: %2
+
+Analysis is stopped.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2009"/>
+        <source>Failed to import &apos;%1&apos; (%2), analysis is stopped</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1547"/>
+        <location filename="mainwindow.cpp" line="2033"/>
         <source>Project files (*.cppcheck)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1549"/>
+        <location filename="mainwindow.cpp" line="2035"/>
         <source>Select Project Filename</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1594"/>
+        <location filename="mainwindow.cpp" line="2081"/>
         <source>No project file loaded</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1662"/>
+        <location filename="mainwindow.cpp" line="2163"/>
         <source>The project file
 
 %1
@@ -1220,7 +1408,72 @@ Do you want to remove the file from the recently used projects -list?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="main.cpp" line="106"/>
+        <location filename="mainwindow.cpp" line="2325"/>
+        <source>Install</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2329"/>
+        <source>New version available: %1. %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2367"/>
+        <source>Show Mandatory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2368"/>
+        <source>Show Required</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2369"/>
+        <source>Show Advisory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2370"/>
+        <source>Show Document</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2387"/>
+        <source>Show L1</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2388"/>
+        <source>Show L2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2389"/>
+        <source>Show L3</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2396"/>
+        <source>Show style</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2397"/>
+        <source>Show portability</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2398"/>
+        <source>Show performance</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2399"/>
+        <source>Show information</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="main.cpp" line="100"/>
         <source>Cppcheck GUI.
 
 Syntax:
@@ -1250,7 +1503,7 @@ Options:
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="main.cpp" line="121"/>
+        <location filename="main.cpp" line="115"/>
         <source>Cppcheck GUI - Command line parameters</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1283,7 +1536,7 @@ Options:
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="newsuppressiondialog.cpp" line="52"/>
+        <location filename="newsuppressiondialog.cpp" line="83"/>
         <source>Edit suppression</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1291,277 +1544,424 @@ Options:
 <context>
     <name>Platforms</name>
     <message>
-        <location filename="platforms.cpp" line="37"/>
+        <location filename="platforms.cpp" line="38"/>
         <source>Native</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="38"/>
+        <location filename="platforms.cpp" line="39"/>
         <source>Unix 32-bit</source>
         <translation>Unix 32-bit</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="39"/>
+        <location filename="platforms.cpp" line="40"/>
         <source>Unix 64-bit</source>
         <translation>Unix 64-bit</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="40"/>
+        <location filename="platforms.cpp" line="41"/>
         <source>Windows 32-bit ANSI</source>
         <translation>Windows 32-bit ANSI</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="41"/>
+        <location filename="platforms.cpp" line="42"/>
         <source>Windows 32-bit Unicode</source>
         <translation>Windows 32-bit Unicode</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="42"/>
+        <location filename="platforms.cpp" line="43"/>
         <source>Windows 64-bit</source>
         <translation>Windows 64-bit</translation>
     </message>
 </context>
-<context>
-    <name>Project</name>
-    <message>
-        <source>Cppcheck</source>
-        <translation type="obsolete">Cppcheck</translation>
-    </message>
-</context>
 <context>
     <name>ProjectFile</name>
     <message>
-        <location filename="projectfiledialog.ui" line="14"/>
+        <location filename="projectfile.ui" line="14"/>
         <source>Project File</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="24"/>
+        <location filename="projectfile.ui" line="24"/>
         <source>Paths and Defines</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="30"/>
+        <location filename="projectfile.ui" line="30"/>
         <source>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</source>
         <oldsource>Import Project (Visual studio / compile database)</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="163"/>
+        <location filename="projectfile.ui" line="231"/>
         <source>Defines must be separated by a semicolon. Example: DEF1;DEF2=5;DEF3=int</source>
         <oldsource>Defines must be separated by a semicolon &apos;;&apos;</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="393"/>
+        <location filename="projectfile.ui" line="389"/>
         <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="557"/>
-        <source>Addons and tools</source>
+        <location filename="projectfile.ui" line="876"/>
+        <source>MISRA rule texts</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="597"/>
-        <source>MISRA C 2012</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="606"/>
-        <source>Misra rule texts</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="613"/>
+        <location filename="projectfile.ui" line="883"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="620"/>
+        <location filename="projectfile.ui" line="890"/>
         <source>...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="69"/>
+        <location filename="projectfile.ui" line="73"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;You have a choice:&lt;/p&gt;&lt;p&gt; * Analyze all Debug and Release configurations&lt;/p&gt;&lt;p&gt; * Only analyze the first matching Debug configuration&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="60"/>
-        <location filename="projectfiledialog.ui" line="309"/>
+        <location filename="projectfile.ui" line="60"/>
+        <location filename="projectfile.ui" line="422"/>
+        <location filename="projectfile.ui" line="616"/>
         <source>Browse...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="72"/>
+        <location filename="projectfile.ui" line="76"/>
         <source>Analyze all Visual Studio configurations</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="86"/>
+        <location filename="projectfile.ui" line="113"/>
+        <source>Selected VS Configurations</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="147"/>
         <source>Paths:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="113"/>
-        <location filename="projectfiledialog.ui" line="228"/>
-        <location filename="projectfiledialog.ui" line="461"/>
+        <location filename="projectfile.ui" line="181"/>
+        <location filename="projectfile.ui" line="296"/>
         <source>Add...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="120"/>
-        <location filename="projectfiledialog.ui" line="235"/>
-        <location filename="projectfiledialog.ui" line="468"/>
+        <location filename="projectfile.ui" line="188"/>
+        <location filename="projectfile.ui" line="303"/>
+        <location filename="projectfile.ui" line="690"/>
         <source>Edit</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="127"/>
-        <location filename="projectfiledialog.ui" line="242"/>
-        <location filename="projectfiledialog.ui" line="475"/>
-        <location filename="projectfiledialog.ui" line="518"/>
+        <location filename="projectfile.ui" line="195"/>
+        <location filename="projectfile.ui" line="310"/>
+        <location filename="projectfile.ui" line="697"/>
+        <location filename="projectfile.ui" line="740"/>
         <source>Remove</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="174"/>
+        <location filename="projectfile.ui" line="242"/>
         <source>Undefines:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="184"/>
+        <location filename="projectfile.ui" line="252"/>
         <source>Undefines must be separated by a semicolon. Example: UNDEF1;UNDEF2;UNDEF3</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="197"/>
+        <location filename="projectfile.ui" line="265"/>
         <source>Include Paths:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="262"/>
+        <location filename="projectfile.ui" line="330"/>
         <source>Up</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="269"/>
+        <location filename="projectfile.ui" line="337"/>
         <source>Down</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="294"/>
-        <source>Checking</source>
+        <location filename="projectfile.ui" line="368"/>
+        <source>Platform</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="319"/>
-        <source>Platform</source>
+        <location filename="projectfile.ui" line="403"/>
+        <location filename="projectfile.ui" line="488"/>
+        <source>Analysis</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="331"/>
-        <source>Analysis</source>
+        <location filename="projectfile.ui" line="415"/>
+        <source>This is a workfolder that Cppcheck will use for various purposes.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="448"/>
+        <source>Clang (experimental)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="337"/>
-        <source>Check code in headers  (slower analysis, more results)</source>
+        <location filename="projectfile.ui" line="458"/>
+        <source>Check level</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="347"/>
-        <source>Check code in unused templates  (slower and less accurate analysis)</source>
+        <location filename="projectfile.ui" line="464"/>
+        <source>Reduced -- meant for usage where developer wants results directly. Limited and faster analysis with fewer results.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="356"/>
+        <location filename="projectfile.ui" line="471"/>
+        <source>Normal -- meant for normal analysis in CI. Analysis should finish in reasonable time.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="478"/>
+        <source>Exhaustive -- meant for nightly builds etc. Analysis time can be longer (10x slower than compilation is OK).</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="494"/>
+        <source>If you want to design your classes to be as flexible and robust as possible then the public interface must be very robust. Cppcheck will asumme that arguments can take *any* value.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="529"/>
+        <source>Check code in unused templates (should be ON normally, however in theory you can safely ignore warnings in unused templates)</source>
+        <oldsource>Check code in unused templates  (slower and less accurate analysis)</oldsource>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="541"/>
         <source>Max CTU depth</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="420"/>
+        <location filename="projectfile.ui" line="572"/>
+        <source>Max recursion in template instantiation</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="607"/>
+        <source>Premium License</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="627"/>
         <source>Warning options</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="426"/>
+        <location filename="projectfile.ui" line="633"/>
         <source>Root path:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="438"/>
+        <location filename="projectfile.ui" line="639"/>
+        <source>Filepaths in warnings will be relative to this path</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="649"/>
         <source>Warning tags (separated by semicolon)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="450"/>
-        <source>Exclude source files in paths</source>
+        <location filename="projectfile.ui" line="765"/>
+        <source>Enable inline suppressions</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="851"/>
+        <source>2025</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="901"/>
+        <source>Misra C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="909"/>
+        <source>2008</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="937"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="946"/>
+        <source>CERT-INT35-C:  int precision (if size equals precision, you can leave empty)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="965"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="972"/>
+        <source>Safety profiles (defined in C++ core guidelines)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="988"/>
+        <source>Bug hunting</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="632"/>
+        <location filename="projectfile.ui" line="998"/>
         <source>External tools</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="300"/>
+        <location filename="projectfile.ui" line="409"/>
         <source>Cppcheck build dir (whole program analysis, incremental analysis, statistics, etc)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="384"/>
+        <location filename="projectfile.ui" line="362"/>
+        <source>Types and Functions</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="380"/>
         <source>Libraries</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="500"/>
+        <location filename="projectfile.ui" line="432"/>
+        <source>Parser</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="438"/>
+        <source>Cppcheck (built in)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="497"/>
+        <source>Check that each class has a safe public interface</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="513"/>
+        <source>Limit analysis</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="519"/>
+        <source>Check code in headers  (should be ON normally. if you want a limited quick analysis then turn this OFF)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="655"/>
+        <source>If tags are added, you will be able to right click on warnings and set one of these tags. You can manually categorize warnings.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="665"/>
+        <source>Exclude source files</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="676"/>
+        <source>Exclude folder...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="683"/>
+        <source>Exclude file...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="722"/>
         <source>Suppressions</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="511"/>
+        <location filename="projectfile.ui" line="733"/>
         <source>Add</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="563"/>
+        <location filename="projectfile.ui" line="786"/>
+        <location filename="projectfile.ui" line="792"/>
         <source>Addons</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="569"/>
+        <location filename="projectfile.ui" line="798"/>
+        <source>Note: Addons require &lt;a href=&quot;https://www.python.org/&quot;&gt;Python&lt;/a&gt; being installed.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="808"/>
         <source>Y2038</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="576"/>
+        <location filename="projectfile.ui" line="815"/>
         <source>Thread safety</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="583"/>
+        <location filename="projectfile.ui" line="825"/>
         <source>Coding standards</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="590"/>
-        <source>Cert</source>
+        <location filename="projectfile.ui" line="833"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="841"/>
+        <source>2012</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="846"/>
+        <location filename="projectfile.ui" line="914"/>
+        <source>2023</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="645"/>
+        <location filename="projectfile.ui" line="958"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="982"/>
+        <source>Bug hunting (Premium)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="1011"/>
         <source>Clang analyzer</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="638"/>
+        <location filename="projectfile.ui" line="1004"/>
         <source>Clang-tidy</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="153"/>
+        <location filename="projectfile.ui" line="221"/>
         <source>Defines:</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1569,277 +1969,339 @@ Options:
 <context>
     <name>ProjectFileDialog</name>
     <message>
-        <location filename="projectfiledialog.cpp" line="71"/>
+        <location filename="projectfiledialog.cpp" line="138"/>
         <source>Project file: %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="409"/>
+        <location filename="projectfiledialog.cpp" line="590"/>
         <source>Select Cppcheck build dir</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="637"/>
+        <location filename="projectfiledialog.cpp" line="851"/>
         <source>Select include directory</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="617"/>
+        <location filename="projectfiledialog.cpp" line="831"/>
         <source>Select a directory to check</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="305"/>
-        <source>(no rule texts file)</source>
+        <location filename="projectfiledialog.cpp" line="396"/>
+        <source>Note: Open source Cppcheck does not fully implement Misra C 2012</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="311"/>
+        <location filename="projectfiledialog.cpp" line="461"/>
         <source>Clang-tidy (not found)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="445"/>
+        <location filename="projectfiledialog.cpp" line="629"/>
         <source>Visual Studio</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="446"/>
+        <location filename="projectfiledialog.cpp" line="630"/>
         <source>Compile database</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="447"/>
+        <location filename="projectfiledialog.cpp" line="631"/>
         <source>Borland C++ Builder 6</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="448"/>
+        <location filename="projectfiledialog.cpp" line="632"/>
         <source>Import Project</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="657"/>
+        <location filename="projectfiledialog.cpp" line="871"/>
         <source>Select directory to ignore</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="742"/>
-        <source>Select MISRA rule texts file</source>
+        <location filename="projectfiledialog.cpp" line="879"/>
+        <source>Source files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="742"/>
-        <source>Misra rule texts file (%1)</source>
+        <location filename="projectfiledialog.cpp" line="880"/>
+        <source>All files</source>
         <translation type="unfinished"></translation>
     </message>
-</context>
-<context>
-    <name>QDialogButtonBox</name>
     <message>
-        <location filename="translationhandler.cpp" line="34"/>
-        <source>OK</source>
+        <location filename="projectfiledialog.cpp" line="881"/>
+        <source>Exclude file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="35"/>
-        <source>Cancel</source>
+        <location filename="projectfiledialog.cpp" line="964"/>
+        <source>Select MISRA rule texts file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="36"/>
-        <source>Close</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="translationhandler.cpp" line="37"/>
-        <source>Save</source>
+        <location filename="projectfiledialog.cpp" line="966"/>
+        <source>MISRA rule texts file (%1)</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>QObject</name>
     <message>
-        <location filename="translationhandler.cpp" line="104"/>
+        <location filename="translationhandler.cpp" line="91"/>
         <source>Unknown language specified!</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="132"/>
+        <location filename="translationhandler.cpp" line="117"/>
         <source>Language file %1 not found!</source>
         <translation type="unfinished">Could not find the file: %1!</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="138"/>
+        <location filename="translationhandler.cpp" line="122"/>
         <source>Failed to load translation for language %1 from file %2</source>
         <translation type="unfinished">Failed to load translation for language %1 from file %2</translation>
     </message>
     <message>
-        <location filename="cppchecklibrarydata.cpp" line="33"/>
+        <location filename="cppchecklibrarydata.cpp" line="38"/>
         <source>line %1: Unhandled element %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="226"/>
+        <location filename="cppchecklibrarydata.cpp" line="43"/>
+        <source>line %1: Mandatory attribute &apos;%2&apos; missing in &apos;%3&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="284"/>
         <source> (Not found)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="69"/>
+        <location filename="codeeditstylecontrols.cpp" line="76"/>
         <source>Thin</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="71"/>
+        <location filename="codeeditstylecontrols.cpp" line="78"/>
         <source>ExtraLight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="73"/>
+        <location filename="codeeditstylecontrols.cpp" line="80"/>
         <source>Light</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="75"/>
+        <location filename="codeeditstylecontrols.cpp" line="82"/>
         <source>Normal</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="77"/>
+        <location filename="codeeditstylecontrols.cpp" line="84"/>
         <source>Medium</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="79"/>
+        <location filename="codeeditstylecontrols.cpp" line="86"/>
         <source>DemiBold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="81"/>
+        <location filename="codeeditstylecontrols.cpp" line="88"/>
         <source>Bold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="83"/>
+        <location filename="codeeditstylecontrols.cpp" line="90"/>
         <source>ExtraBold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="85"/>
+        <location filename="codeeditstylecontrols.cpp" line="92"/>
         <source>Black</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="69"/>
+        <location filename="codeeditstyledialog.cpp" line="80"/>
         <source>Editor Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="72"/>
+        <location filename="codeeditstyledialog.cpp" line="83"/>
         <source>Editor Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="75"/>
+        <location filename="codeeditstyledialog.cpp" line="86"/>
         <source>Highlight Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="78"/>
+        <location filename="codeeditstyledialog.cpp" line="89"/>
         <source>Line Number Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="81"/>
+        <location filename="codeeditstyledialog.cpp" line="92"/>
         <source>Line Number Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="84"/>
+        <location filename="codeeditstyledialog.cpp" line="95"/>
         <source>Keyword Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="87"/>
+        <location filename="codeeditstyledialog.cpp" line="98"/>
         <source>Keyword Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="90"/>
+        <location filename="codeeditstyledialog.cpp" line="101"/>
         <source>Class Foreground Color</source>
         <oldsource>Class ForegroundColor</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="93"/>
+        <location filename="codeeditstyledialog.cpp" line="104"/>
         <source>Class Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="96"/>
+        <location filename="codeeditstyledialog.cpp" line="107"/>
         <source>Quote Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="99"/>
+        <location filename="codeeditstyledialog.cpp" line="110"/>
         <source>Quote Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="102"/>
+        <location filename="codeeditstyledialog.cpp" line="113"/>
         <source>Comment Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="105"/>
+        <location filename="codeeditstyledialog.cpp" line="116"/>
         <source>Comment Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="108"/>
+        <location filename="codeeditstyledialog.cpp" line="119"/>
         <source>Symbol Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="111"/>
+        <location filename="codeeditstyledialog.cpp" line="122"/>
         <source>Symbol Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="114"/>
+        <location filename="codeeditstyledialog.cpp" line="125"/>
         <source>Symbol Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="130"/>
+        <location filename="codeeditstyledialog.cpp" line="141"/>
         <source>Set to Default Light</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="132"/>
+        <location filename="codeeditstyledialog.cpp" line="143"/>
         <source>Set to Default Dark</source>
         <translation type="unfinished"></translation>
     </message>
+    <message>
+        <location filename="resultstree.cpp" line="113"/>
+        <source>File</source>
+        <translation type="unfinished">File</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="114"/>
+        <source>Line</source>
+        <translation type="unfinished">Line</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="115"/>
+        <source>Severity</source>
+        <translation type="unfinished">Severity</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="116"/>
+        <source>Classification</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="117"/>
+        <source>Level</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="118"/>
+        <source>Inconclusive</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="119"/>
+        <source>Summary</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="120"/>
+        <source>Id</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="121"/>
+        <source>Guideline</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="122"/>
+        <source>Rule</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="123"/>
+        <source>Since date</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="124"/>
+        <source>Tags</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="125"/>
+        <source>CWE</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>QPlatformTheme</name>
     <message>
-        <location filename="translationhandler.cpp" line="39"/>
+        <location filename="translationhandler.cpp" line="41"/>
         <source>OK</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="40"/>
+        <location filename="translationhandler.cpp" line="42"/>
         <source>Cancel</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="41"/>
+        <location filename="translationhandler.cpp" line="43"/>
         <source>Close</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="42"/>
+        <location filename="translationhandler.cpp" line="44"/>
         <source>Save</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1847,136 +2309,123 @@ Options:
 <context>
     <name>ResultsTree</name>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>File</source>
-        <translation type="unfinished">File</translation>
+        <translation type="obsolete">File</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Severity</source>
-        <translation type="unfinished">Severity</translation>
+        <translation type="obsolete">Severity</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Line</source>
-        <translation type="unfinished">Line</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="1343"/>
-        <source>Summary</source>
-        <translation type="unfinished"></translation>
+        <translation type="obsolete">Line</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="136"/>
         <source>Undefined file</source>
-        <translation type="unfinished">Undefined file</translation>
+        <translation type="obsolete">Undefined file</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="614"/>
+        <location filename="resultstree.cpp" line="668"/>
         <source>Copy</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="797"/>
+        <location filename="resultstree.cpp" line="836"/>
         <source>Could not find file:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="801"/>
+        <location filename="resultstree.cpp" line="840"/>
         <source>Please select the folder &apos;%1&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="802"/>
+        <location filename="resultstree.cpp" line="841"/>
         <source>Select Directory &apos;%1&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="804"/>
+        <location filename="resultstree.cpp" line="843"/>
         <source>Please select the directory where file is located.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="312"/>
+        <location filename="resultstree.cpp" line="373"/>
         <source>debug</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="249"/>
+        <location filename="resultstree.cpp" line="307"/>
         <source>note</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="613"/>
-        <source>Recheck</source>
+        <location filename="resultstree.cpp" line="670"/>
+        <source>Hide all with id</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Copy filename</source>
-        <translation type="obsolete">Copy filename</translation>
-    </message>
-    <message>
-        <source>Copy full path</source>
-        <translation type="obsolete">Copy full path</translation>
+        <location filename="resultstree.cpp" line="692"/>
+        <source>Suppress selected id(s)</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="615"/>
-        <source>Hide</source>
+        <location filename="resultstree.cpp" line="671"/>
+        <source>Open containing folder</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="616"/>
-        <source>Hide all with id</source>
+        <location filename="resultstree.cpp" line="376"/>
+        <source>internal</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="617"/>
-        <source>Suppress selected id(s)</source>
+        <location filename="resultstree.cpp" line="667"/>
+        <source>Recheck %1 file(s)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="618"/>
-        <source>Open containing folder</source>
+        <location filename="resultstree.cpp" line="669"/>
+        <source>Hide %1 result(s)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="648"/>
-        <location filename="resultstree.cpp" line="1343"/>
+        <location filename="resultstree.cpp" line="712"/>
         <source>Tag</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="650"/>
+        <location filename="resultstree.cpp" line="714"/>
         <source>No tag</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="693"/>
-        <location filename="resultstree.cpp" line="707"/>
+        <location filename="resultstree.cpp" line="744"/>
+        <location filename="resultstree.cpp" line="758"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="694"/>
+        <location filename="resultstree.cpp" line="745"/>
         <source>No editor application configured.
 
 Configure the editor application for Cppcheck in preferences/Applications.</source>
         <translation type="unfinished">You can open this error by specifying applications in program&apos;s settings.</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="708"/>
+        <location filename="resultstree.cpp" line="759"/>
         <source>No default editor application selected.
 
 Please select the default editor application in preferences/Applications.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="737"/>
+        <location filename="resultstree.cpp" line="779"/>
         <source>Could not find the file!</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="783"/>
+        <location filename="resultstree.cpp" line="822"/>
         <source>Could not start %1
 
 Please check the application path and parameters are correct.</source>
@@ -1985,52 +2434,37 @@ Please check the application path and parameters are correct.</source>
 Please check the application path and parameters are correct.</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="805"/>
+        <location filename="resultstree.cpp" line="844"/>
         <source>Select Directory</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
-        <source>Id</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="1343"/>
-        <source>Inconclusive</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="1343"/>
-        <source>Since date</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="294"/>
+        <location filename="resultstree.cpp" line="355"/>
         <source>style</source>
         <translation type="unfinished">Style</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="297"/>
+        <location filename="resultstree.cpp" line="358"/>
         <source>error</source>
         <translation type="unfinished">Error</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="300"/>
+        <location filename="resultstree.cpp" line="361"/>
         <source>warning</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="303"/>
+        <location filename="resultstree.cpp" line="364"/>
         <source>performance</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="306"/>
+        <location filename="resultstree.cpp" line="367"/>
         <source>portability</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="309"/>
+        <location filename="resultstree.cpp" line="370"/>
         <source>information</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2038,82 +2472,102 @@ Please check the application path and parameters are correct.</translation>
 <context>
     <name>ResultsView</name>
     <message>
-        <location filename="resultsview.cpp" line="201"/>
+        <location filename="resultsview.cpp" line="255"/>
         <source>Print Report</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="220"/>
+        <location filename="resultsview.cpp" line="274"/>
         <source>No errors found, nothing to print.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="264"/>
+        <location filename="resultsview.cpp" line="326"/>
         <source>%p% (%1 of %2 files checked)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="277"/>
-        <location filename="resultsview.cpp" line="288"/>
+        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="361"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="278"/>
+        <location filename="resultsview.cpp" line="351"/>
         <source>No errors found.</source>
         <translation type="unfinished">No errors found.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="285"/>
+        <location filename="resultsview.cpp" line="358"/>
         <source>Errors were found, but they are configured to be hidden.
 To toggle what kind of errors are shown, open view menu.</source>
         <translation type="unfinished">Errors were found, but they are configured to be hidden.
 To toggle what kind of errors are shown, open view menu.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="331"/>
-        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="421"/>
         <source>Failed to read the report.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="338"/>
+        <location filename="resultsview.cpp" line="409"/>
         <source>XML format version 1 is no longer supported.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="399"/>
+        <location filename="resultsview.cpp" line="460"/>
         <source>First included by</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="465"/>
         <source>Id</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="471"/>
+        <location filename="resultsview.cpp" line="539"/>
         <source>Clear Log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="472"/>
+        <location filename="resultsview.cpp" line="540"/>
         <source>Copy this Log entry</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="473"/>
+        <location filename="resultsview.cpp" line="541"/>
         <source>Copy complete Log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="159"/>
-        <source>No errors found, nothing to save.</source>
-        <translation type="unfinished">No errors found, nothing to save.</translation>
+        <location filename="resultsview.cpp" line="549"/>
+        <source>Analysis was stopped</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="563"/>
+        <source>There was a critical error with id &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="565"/>
+        <source>when checking %1</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="567"/>
+        <source>when checking a file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="568"/>
+        <source>Analysis was aborted.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="183"/>
-        <location filename="resultsview.cpp" line="191"/>
+        <location filename="resultsview.cpp" line="237"/>
+        <location filename="resultsview.cpp" line="245"/>
         <source>Failed to save the report.</source>
         <translation type="unfinished">Failed to save the report.</translation>
     </message>
@@ -2123,12 +2577,17 @@ To toggle what kind of errors are shown, open view menu.</translation>
         <translation type="unfinished">Results</translation>
     </message>
     <message>
-        <location filename="resultsview.ui" line="82"/>
+        <location filename="resultsview.ui" line="60"/>
+        <source>Critical errors</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.ui" line="92"/>
         <source>Analysis Log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.ui" line="104"/>
+        <location filename="resultsview.ui" line="114"/>
         <source>Warning Details</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2174,7 +2633,7 @@ To toggle what kind of errors are shown, open view menu.</translation>
         <translation type="unfinished">General</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="195"/>
+        <location filename="settings.ui" line="196"/>
         <source>Add...</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2184,170 +2643,175 @@ To toggle what kind of errors are shown, open view menu.</translation>
         <translation type="unfinished">Number of threads: </translation>
     </message>
     <message>
-        <location filename="settings.ui" line="85"/>
-        <source>Ideal count:</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="settings.ui" line="114"/>
+        <location filename="settings.ui" line="108"/>
         <source>Force checking all #ifdef configurations</source>
         <translation type="unfinished">Check all #ifdef configurations</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="121"/>
+        <location filename="settings.ui" line="115"/>
         <source>Show full path of files</source>
         <translation type="unfinished">Show full path of files</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="128"/>
+        <location filename="settings.ui" line="122"/>
         <source>Show &quot;No errors found&quot; message when no errors found</source>
         <translation type="unfinished">Show &quot;No errors found&quot; message when no errors found</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="135"/>
+        <location filename="settings.ui" line="129"/>
         <source>Display error Id in column &quot;Id&quot;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="142"/>
+        <location filename="settings.ui" line="136"/>
         <source>Enable inline suppressions</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="149"/>
+        <location filename="settings.ui" line="143"/>
         <source>Check for inconclusive errors also</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="156"/>
+        <location filename="settings.ui" line="150"/>
         <source>Show statistics on check completion</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="176"/>
+        <location filename="settings.ui" line="157"/>
+        <source>Check for updates</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="177"/>
         <source>Show internal warnings in log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="287"/>
+        <location filename="settings.ui" line="288"/>
         <source>Addons</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="293"/>
+        <location filename="settings.ui" line="294"/>
         <source>Python binary (leave this empty to use python in the PATH)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="302"/>
-        <location filename="settings.ui" line="334"/>
-        <location filename="settings.ui" line="379"/>
+        <location filename="settings.ui" line="305"/>
+        <location filename="settings.ui" line="346"/>
+        <location filename="settings.ui" line="391"/>
         <source>...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="312"/>
-        <source>Misra addon</source>
+        <location filename="settings.ui" line="324"/>
+        <source>MISRA addon</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="320"/>
-        <source>Misra rule texts file</source>
+        <location filename="settings.ui" line="332"/>
+        <source>MISRA rule texts file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="327"/>
+        <location filename="settings.ui" line="339"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="360"/>
+        <location filename="settings.ui" line="372"/>
         <source>Clang</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="366"/>
+        <location filename="settings.ui" line="378"/>
         <source>Clang path (leave empty to use system PATH)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="389"/>
+        <location filename="settings.ui" line="401"/>
         <source>Visual Studio headers</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="395"/>
+        <location filename="settings.ui" line="407"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Paths to Visual Studio headers, separated by semicolon &apos;;&apos;.&lt;/p&gt;&lt;p&gt;You can open a Visual Studio command prompt, write &amp;quot;SET INCLUDE&amp;quot;. Then copy/paste the paths.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="425"/>
+        <location filename="settings.ui" line="437"/>
         <source>Code Editor</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="431"/>
+        <location filename="settings.ui" line="443"/>
         <source>Code Editor Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="437"/>
+        <location filename="settings.ui" line="449"/>
         <source>System Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="444"/>
+        <location filename="settings.ui" line="456"/>
         <source>Default Light Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="451"/>
+        <location filename="settings.ui" line="463"/>
         <source>Default Dark Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="460"/>
+        <location filename="settings.ui" line="472"/>
         <source>Custom</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="209"/>
+        <location filename="settings.ui" line="210"/>
         <source>Remove</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="184"/>
+        <location filename="settings.ui" line="79"/>
+        <source>Max count:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="185"/>
         <source>Applications</source>
         <translation type="unfinished">Applications</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="202"/>
-        <location filename="settings.ui" line="467"/>
+        <location filename="settings.ui" line="203"/>
+        <location filename="settings.ui" line="479"/>
         <source>Edit...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="216"/>
+        <location filename="settings.ui" line="217"/>
         <source>Set as default</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="239"/>
+        <location filename="settings.ui" line="240"/>
         <source>Reports</source>
         <translation type="unfinished">Reports</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="245"/>
+        <location filename="settings.ui" line="246"/>
         <source>Save all errors when creating report</source>
         <translation type="unfinished">Save all errors when creating report</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="252"/>
+        <location filename="settings.ui" line="253"/>
         <source>Save full path to files in reports</source>
         <translation type="unfinished">Save full path to files in reports</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="273"/>
+        <location filename="settings.ui" line="274"/>
         <source>Language</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2355,42 +2819,42 @@ To toggle what kind of errors are shown, open view menu.</translation>
 <context>
     <name>SettingsDialog</name>
     <message>
-        <location filename="settingsdialog.cpp" line="100"/>
-        <source>N/A</source>
+        <location filename="settingsdialog.cpp" line="232"/>
+        <source>The executable file &quot;%1&quot; is not available</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="200"/>
+        <location filename="settingsdialog.cpp" line="243"/>
         <source>Add a new application</source>
         <translation type="unfinished">Add a new application</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="233"/>
+        <location filename="settingsdialog.cpp" line="273"/>
         <source>Modify an application</source>
         <translation type="unfinished">Modify an application</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="238"/>
+        <location filename="settingsdialog.cpp" line="278"/>
         <source> [Default]</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="263"/>
+        <location filename="settingsdialog.cpp" line="303"/>
         <source>[Default]</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="318"/>
+        <location filename="settingsdialog.cpp" line="358"/>
         <source>Select python binary</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="325"/>
+        <location filename="settingsdialog.cpp" line="365"/>
         <source>Select MISRA File</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="356"/>
+        <location filename="settingsdialog.cpp" line="396"/>
         <source>Select clang path</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2398,261 +2862,279 @@ To toggle what kind of errors are shown, open view menu.</translation>
 <context>
     <name>StatsDialog</name>
     <message>
-        <location filename="stats.ui" line="14"/>
-        <location filename="stats.ui" line="248"/>
-        <location filename="statsdialog.cpp" line="137"/>
-        <location filename="statsdialog.cpp" line="184"/>
+        <location filename="statsdialog.ui" line="14"/>
+        <location filename="statsdialog.ui" line="248"/>
+        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="230"/>
         <source>Statistics</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="27"/>
-        <location filename="statsdialog.cpp" line="175"/>
+        <location filename="statsdialog.ui" line="27"/>
+        <location filename="statsdialog.cpp" line="221"/>
         <source>Project</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="33"/>
+        <location filename="statsdialog.ui" line="33"/>
         <source>Project:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="53"/>
+        <location filename="statsdialog.ui" line="53"/>
         <source>Paths:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="85"/>
+        <location filename="statsdialog.ui" line="85"/>
         <source>Include paths:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="108"/>
+        <location filename="statsdialog.ui" line="108"/>
         <source>Defines:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="131"/>
+        <location filename="statsdialog.ui" line="131"/>
         <source>Undefines:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="165"/>
-        <location filename="statsdialog.cpp" line="180"/>
+        <location filename="statsdialog.ui" line="165"/>
+        <location filename="statsdialog.cpp" line="226"/>
         <source>Previous Scan</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="171"/>
+        <location filename="statsdialog.ui" line="171"/>
         <source>Path Selected:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="181"/>
+        <location filename="statsdialog.ui" line="181"/>
         <source>Number of Files Scanned:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="201"/>
+        <location filename="statsdialog.ui" line="201"/>
         <source>Scan Duration:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="256"/>
+        <location filename="statsdialog.ui" line="254"/>
         <source>Errors:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="274"/>
+        <location filename="statsdialog.ui" line="271"/>
         <source>Warnings:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="292"/>
+        <location filename="statsdialog.ui" line="288"/>
         <source>Stylistic warnings:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="310"/>
+        <location filename="statsdialog.ui" line="305"/>
         <source>Portability warnings:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="328"/>
+        <location filename="statsdialog.ui" line="322"/>
         <source>Performance issues:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="346"/>
+        <location filename="statsdialog.ui" line="339"/>
         <source>Information messages:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="363"/>
+        <location filename="statsdialog.ui" line="356"/>
+        <source>Active checkers:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="374"/>
+        <source>Checkers</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="399"/>
         <source>History</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="369"/>
+        <location filename="statsdialog.ui" line="405"/>
         <source>File:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="407"/>
+        <location filename="statsdialog.ui" line="443"/>
         <source>Copy to Clipboard</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="414"/>
+        <location filename="statsdialog.ui" line="450"/>
         <source>Pdf Export</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="113"/>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>1 day</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="113"/>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>%1 days</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="115"/>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>1 hour</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="115"/>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>%1 hours</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="117"/>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>1 minute</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="117"/>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>%1 minutes</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="119"/>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>1 second</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="119"/>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>%1 seconds</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="123"/>
+        <location filename="statsdialog.cpp" line="169"/>
         <source>0.%1 seconds</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="125"/>
+        <location filename="statsdialog.cpp" line="171"/>
         <source> and </source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="152"/>
+        <location filename="statsdialog.cpp" line="198"/>
         <source>Export PDF</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="174"/>
+        <location filename="statsdialog.cpp" line="220"/>
         <source>Project Settings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="176"/>
+        <location filename="statsdialog.cpp" line="222"/>
         <source>Paths</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="177"/>
+        <location filename="statsdialog.cpp" line="223"/>
         <source>Include paths</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="178"/>
+        <location filename="statsdialog.cpp" line="224"/>
         <source>Defines</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="179"/>
+        <location filename="statsdialog.cpp" line="225"/>
         <source>Undefines</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="181"/>
+        <location filename="statsdialog.cpp" line="227"/>
         <source>Path selected</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="182"/>
+        <location filename="statsdialog.cpp" line="228"/>
         <source>Number of files scanned</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="229"/>
         <source>Scan duration</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="139"/>
         <location filename="statsdialog.cpp" line="185"/>
+        <location filename="statsdialog.cpp" line="231"/>
         <source>Errors</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="65"/>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>File: </source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="65"/>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>No cppcheck build dir</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="141"/>
-        <location filename="statsdialog.cpp" line="186"/>
+        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="232"/>
         <source>Warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="143"/>
-        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="233"/>
         <source>Style warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="145"/>
-        <location filename="statsdialog.cpp" line="188"/>
+        <location filename="statsdialog.cpp" line="191"/>
+        <location filename="statsdialog.cpp" line="234"/>
         <source>Portability warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="147"/>
-        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="193"/>
+        <location filename="statsdialog.cpp" line="235"/>
         <source>Performance warnings</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="149"/>
-        <location filename="statsdialog.cpp" line="190"/>
+        <location filename="statsdialog.cpp" line="195"/>
+        <location filename="statsdialog.cpp" line="236"/>
         <source>Information messages</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
+<context>
+    <name>ThreadDetails</name>
+    <message>
+        <location filename="threaddetails.ui" line="14"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>ThreadResult</name>
     <message>
-        <location filename="threadresult.cpp" line="54"/>
+        <location filename="threadresult.cpp" line="47"/>
         <source>%1 of %2 files checked</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2660,7 +3142,7 @@ To toggle what kind of errors are shown, open view menu.</translation>
 <context>
     <name>TranslationHandler</name>
     <message>
-        <location filename="translationhandler.cpp" line="145"/>
+        <location filename="translationhandler.cpp" line="130"/>
         <source>Failed to change the user interface language:
 
 %1
@@ -2669,7 +3151,7 @@ The user interface language has been reset to English. Open the Preferences-dial
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="151"/>
+        <location filename="translationhandler.cpp" line="136"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
@@ -2677,7 +3159,7 @@ The user interface language has been reset to English. Open the Preferences-dial
 <context>
     <name>TxtReport</name>
     <message>
-        <location filename="txtreport.cpp" line="73"/>
+        <location filename="txtreport.cpp" line="74"/>
         <source>inconclusive</source>
         <translation type="unfinished"></translation>
     </message>
@@ -2685,12 +3167,12 @@ The user interface language has been reset to English. Open the Preferences-dial
 <context>
     <name>toFilterString</name>
     <message>
-        <location filename="common.cpp" line="52"/>
+        <location filename="common.cpp" line="58"/>
         <source>All supported files (%1)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="common.cpp" line="57"/>
+        <location filename="common.cpp" line="63"/>
         <source>All files (%1)</source>
         <translation type="unfinished"></translation>
     </message>
diff --git a/gui/cppcheck_sv.ts b/gui/cppcheck_sv.ts
index 2bc83c9b7f4..f37121c2f2f 100644
--- a/gui/cppcheck_sv.ts
+++ b/gui/cppcheck_sv.ts
@@ -20,8 +20,9 @@
     </message>
     <message>
         <location filename="about.ui" line="81"/>
-        <source>Copyright © 2007-2019 Cppcheck team.</source>
-        <translation>Copyright © 2007-2019 Cppcheck team.</translation>
+        <source>Copyright © 2007-%1 Cppcheck team.</source>
+        <oldsource>Copyright © 2007-2021 Cppcheck team.</oldsource>
+        <translation type="unfinished">Copyright © 2007-2021 Cppcheck team.</translation>
     </message>
     <message>
         <location filename="about.ui" line="91"/>
@@ -37,24 +38,20 @@ of the GNU General Public License version 3</translation>
     </message>
     <message>
         <location filename="about.ui" line="115"/>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
-&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul&gt;
-&lt;li&gt;tinyxml2&lt;/li&gt;
-&lt;li&gt;picojson&lt;/li&gt;
-&lt;li&gt;pcre&lt;/li&gt;
-&lt;li&gt;qt&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PCRE&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PicoJSON&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;TinyXML2&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Boost&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <oldsource>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;pcre&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;picojson&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;tinyxml2&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</oldsource>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>ApplicationDialog</name>
     <message>
-        <location filename="application.ui" line="23"/>
+        <location filename="applicationdialog.ui" line="23"/>
         <source>Add an application</source>
         <translation>Lägg till program</translation>
     </message>
     <message>
-        <location filename="application.ui" line="41"/>
+        <location filename="applicationdialog.ui" line="41"/>
         <source>Here you can add an application that can open error files. Specify a name for the application, the application executable and command line parameters for the application.
 
 The following texts in parameters are replaced with appropriate values when application is executed:
@@ -79,71 +76,159 @@ Körbar fil: kate
 Parametrar: -l(line) (file)</translation>
     </message>
     <message>
-        <location filename="application.ui" line="76"/>
+        <location filename="applicationdialog.ui" line="76"/>
         <source>&amp;Name:</source>
         <translation>Namn:</translation>
     </message>
     <message>
-        <location filename="application.ui" line="86"/>
+        <location filename="applicationdialog.ui" line="86"/>
         <source>&amp;Executable:</source>
         <translation>Körbar fil:</translation>
     </message>
     <message>
-        <location filename="application.ui" line="96"/>
+        <location filename="applicationdialog.ui" line="96"/>
         <source>&amp;Parameters:</source>
         <translation>Parametrar:</translation>
     </message>
     <message>
-        <location filename="application.ui" line="138"/>
+        <location filename="applicationdialog.ui" line="138"/>
         <source>Browse</source>
         <translation>Bläddra</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="59"/>
+        <location filename="applicationdialog.cpp" line="65"/>
         <source>Executable files (*.exe);;All files(*.*)</source>
         <translation>Exekverbara filer (*.exe);;Alla filer(*.*)</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="62"/>
+        <location filename="applicationdialog.cpp" line="68"/>
         <source>Select viewer application</source>
         <translation>Välj program</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="77"/>
+        <location filename="applicationdialog.cpp" line="83"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="78"/>
+        <location filename="applicationdialog.cpp" line="84"/>
         <source>You must specify a name, a path and optionally parameters for the application!</source>
         <translation>Du måste ange namn, sökväg samt eventuellt parametrar för applikationen!</translation>
     </message>
+</context>
+<context>
+    <name>ComplianceReportDialog</name>
+    <message>
+        <location filename="compliancereportdialog.ui" line="14"/>
+        <source>Compliance Report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="29"/>
+        <source>Project name</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="22"/>
+        <source>Project version</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="42"/>
+        <source>Coding Standard</source>
+        <translation type="unfinished"></translation>
+    </message>
     <message>
-        <source>You must specify a name, a path and parameters for the application!</source>
-        <translation type="obsolete">Du måste ange ett namn, en sökväg samt parametrar för programmet!</translation>
+        <location filename="compliancereportdialog.ui" line="50"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="55"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="60"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="70"/>
+        <source>List of files with md5 checksums</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="133"/>
+        <source>Compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="135"/>
+        <source>HTML files (*.html)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="176"/>
+        <location filename="compliancereportdialog.cpp" line="239"/>
+        <source>Save compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="177"/>
+        <source>Failed to import &apos;%1&apos; (%2), can not show files in compliance report</source>
+        <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>FileViewDialog</name>
     <message>
-        <location filename="fileviewdialog.cpp" line="42"/>
+        <location filename="fileviewdialog.cpp" line="53"/>
         <source>Could not find the file: %1</source>
         <oldsource>Could not find the file:
 </oldsource>
         <translation>Kunde inte hitta filen: %1</translation>
     </message>
     <message>
-        <location filename="fileviewdialog.cpp" line="46"/>
-        <location filename="fileviewdialog.cpp" line="60"/>
+        <location filename="fileviewdialog.cpp" line="57"/>
+        <location filename="fileviewdialog.cpp" line="71"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="fileviewdialog.cpp" line="56"/>
+        <location filename="fileviewdialog.cpp" line="67"/>
         <source>Could not read the file: %1</source>
         <translation>Kunde inte läsa filen: %1</translation>
     </message>
 </context>
+<context>
+    <name>HelpDialog</name>
+    <message>
+        <location filename="helpdialog.ui" line="14"/>
+        <source>Cppcheck GUI help</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="34"/>
+        <source>Contents</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="44"/>
+        <source>Index</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="84"/>
+        <source>Helpfile &apos;%1&apos; was not found</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="86"/>
+        <source>Cppcheck</source>
+        <translation type="unfinished">Cppcheck</translation>
+    </message>
+</context>
 <context>
     <name>LibraryAddFunctionDialog</name>
     <message>
@@ -250,42 +335,42 @@ Parametrar: -l(line) (file)</translation>
         <translation>Redigera</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="82"/>
-        <location filename="librarydialog.cpp" line="154"/>
+        <location filename="librarydialog.cpp" line="97"/>
+        <location filename="librarydialog.cpp" line="169"/>
         <source>Library files (*.cfg)</source>
         <translation>Library fil (*.cfg)</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="84"/>
+        <location filename="librarydialog.cpp" line="99"/>
         <source>Open library file</source>
         <translation>Öppna Library fil</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="95"/>
-        <location filename="librarydialog.cpp" line="107"/>
-        <location filename="librarydialog.cpp" line="144"/>
+        <location filename="librarydialog.cpp" line="110"/>
+        <location filename="librarydialog.cpp" line="122"/>
+        <location filename="librarydialog.cpp" line="159"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="96"/>
+        <location filename="librarydialog.cpp" line="111"/>
         <source>Cannot open file %1.</source>
         <oldsource>Can not open file %1.</oldsource>
         <translation type="unfinished">Kunde ej öppna filen %1.</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="108"/>
+        <location filename="librarydialog.cpp" line="123"/>
         <source>Failed to load %1. %2.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="145"/>
+        <location filename="librarydialog.cpp" line="160"/>
         <source>Cannot save file %1.</source>
         <oldsource>Can not save file %1.</oldsource>
         <translation type="unfinished">Kunde ej spara filen %1.</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="157"/>
+        <location filename="librarydialog.cpp" line="172"/>
         <source>Save the library as</source>
         <translation>Spara library som</translation>
     </message>
@@ -371,10 +456,6 @@ Exempel:
         <source>argvalue</source>
         <translation>argvalue</translation>
     </message>
-    <message>
-        <source>constant</source>
-        <translation type="obsolete">constant</translation>
-    </message>
     <message>
         <location filename="libraryeditargdialog.ui" line="119"/>
         <location filename="libraryeditargdialog.ui" line="224"/>
@@ -410,669 +491,627 @@ Exempel:
         <translation>Tillåtna värden</translation>
     </message>
 </context>
-<context>
-    <name>LogView</name>
-    <message>
-        <source>Checking Log</source>
-        <translation type="obsolete">Analys logg</translation>
-    </message>
-    <message>
-        <source>&amp;Save</source>
-        <translation type="obsolete">&amp;Spara</translation>
-    </message>
-    <message>
-        <source>Clear</source>
-        <translation type="obsolete">Töm</translation>
-    </message>
-    <message>
-        <source>Close</source>
-        <translation type="obsolete">Stäng</translation>
-    </message>
-    <message>
-        <source>Save Log</source>
-        <translation type="obsolete">Spara logg</translation>
-    </message>
-    <message>
-        <source>Text files (*.txt *.log);;All files (*.*)</source>
-        <translation type="obsolete">Text filer (*.txt *.log);;Alla filer (*.*)</translation>
-    </message>
-    <message>
-        <source>Cppcheck</source>
-        <translation type="obsolete">Cppcheck</translation>
-    </message>
-    <message>
-        <source>Could not open file for writing: &quot;%1&quot;</source>
-        <translation type="obsolete">Kunde ej öppna fil för skrivning: &quot;%1&quot;</translation>
-    </message>
-</context>
 <context>
     <name>MainWindow</name>
     <message>
         <location filename="mainwindow.ui" line="26"/>
-        <location filename="mainwindow.ui" line="595"/>
-        <location filename="mainwindow.cpp" line="328"/>
-        <location filename="mainwindow.cpp" line="480"/>
-        <location filename="mainwindow.cpp" line="553"/>
-        <location filename="mainwindow.cpp" line="658"/>
-        <location filename="mainwindow.cpp" line="680"/>
-        <location filename="mainwindow.cpp" line="1113"/>
-        <location filename="mainwindow.cpp" line="1238"/>
-        <location filename="mainwindow.cpp" line="1359"/>
-        <location filename="mainwindow.cpp" line="1499"/>
-        <location filename="mainwindow.cpp" line="1522"/>
-        <location filename="mainwindow.cpp" line="1593"/>
-        <location filename="mainwindow.cpp" line="1667"/>
+        <location filename="mainwindow.ui" line="688"/>
+        <location filename="mainwindow.cpp" line="466"/>
+        <location filename="mainwindow.cpp" line="670"/>
+        <location filename="mainwindow.cpp" line="755"/>
+        <location filename="mainwindow.cpp" line="860"/>
+        <location filename="mainwindow.cpp" line="882"/>
+        <location filename="mainwindow.cpp" line="1467"/>
+        <location filename="mainwindow.cpp" line="1596"/>
+        <location filename="mainwindow.cpp" line="1937"/>
+        <location filename="mainwindow.cpp" line="1945"/>
+        <location filename="mainwindow.cpp" line="1999"/>
+        <location filename="mainwindow.cpp" line="2008"/>
+        <location filename="mainwindow.cpp" line="2080"/>
+        <location filename="mainwindow.cpp" line="2168"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="131"/>
+        <location filename="mainwindow.ui" line="210"/>
         <source>A&amp;nalyze</source>
         <translation>Analysera</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="183"/>
+        <location filename="mainwindow.ui" line="267"/>
         <source>Standard</source>
         <translation>Standard</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="70"/>
+        <location filename="mainwindow.ui" line="132"/>
         <source>&amp;File</source>
         <translation>&amp;Arkiv</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="89"/>
+        <location filename="mainwindow.ui" line="152"/>
         <source>&amp;View</source>
         <translation>&amp;Visa</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="93"/>
+        <location filename="mainwindow.ui" line="156"/>
         <source>&amp;Toolbars</source>
         <translation>Verktygsfält</translation>
     </message>
     <message>
-        <source>&amp;Check</source>
-        <translation type="obsolete">&amp;Check</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="135"/>
+        <location filename="mainwindow.ui" line="214"/>
         <source>C++ standard</source>
         <translation>C++ standard</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="145"/>
+        <location filename="mainwindow.ui" line="226"/>
         <source>&amp;C standard</source>
         <oldsource>C standard</oldsource>
         <translation>C standard</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="170"/>
+        <location filename="mainwindow.ui" line="254"/>
         <source>&amp;Edit</source>
         <translation>&amp;Redigera</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="231"/>
+        <location filename="mainwindow.ui" line="315"/>
         <source>&amp;License...</source>
         <translation>&amp;Licens...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="236"/>
+        <location filename="mainwindow.ui" line="320"/>
         <source>A&amp;uthors...</source>
         <translation>&amp;Utvecklat av...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="245"/>
+        <location filename="mainwindow.ui" line="329"/>
         <source>&amp;About...</source>
         <translation>&amp;Om...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="250"/>
+        <location filename="mainwindow.ui" line="334"/>
         <source>&amp;Files...</source>
         <translation>&amp;Filer...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="253"/>
-        <location filename="mainwindow.ui" line="256"/>
+        <location filename="mainwindow.ui" line="337"/>
+        <location filename="mainwindow.ui" line="340"/>
         <source>Analyze files</source>
         <oldsource>Check files</oldsource>
         <translation>Analysera filer</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="259"/>
+        <location filename="mainwindow.ui" line="343"/>
         <source>Ctrl+F</source>
         <translation>Ctrl+F</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="268"/>
+        <location filename="mainwindow.ui" line="352"/>
         <source>&amp;Directory...</source>
         <translation>&amp;Katalog...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="271"/>
-        <location filename="mainwindow.ui" line="274"/>
+        <location filename="mainwindow.ui" line="355"/>
+        <location filename="mainwindow.ui" line="358"/>
         <source>Analyze directory</source>
         <oldsource>Check directory</oldsource>
         <translation>Analysera mapp</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="277"/>
+        <location filename="mainwindow.ui" line="361"/>
         <source>Ctrl+D</source>
         <translation>Ctrl+D</translation>
     </message>
     <message>
-        <source>&amp;Recheck files</source>
-        <translation type="obsolete">Starta &amp;om check</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="289"/>
+        <location filename="mainwindow.ui" line="373"/>
         <source>Ctrl+R</source>
         <translation>Ctrl+R</translation>
     </message>
     <message>
-        <source>&amp;Reanalyze all files</source>
-        <oldsource>&amp;Recheck all files</oldsource>
-        <translation type="obsolete">Analysera om alla filer</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="307"/>
+        <location filename="mainwindow.ui" line="391"/>
         <source>&amp;Stop</source>
         <translation>&amp;Stoppa</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="310"/>
-        <location filename="mainwindow.ui" line="313"/>
+        <location filename="mainwindow.ui" line="394"/>
+        <location filename="mainwindow.ui" line="397"/>
         <source>Stop analysis</source>
         <oldsource>Stop checking</oldsource>
         <translation>Stoppa analys</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="316"/>
+        <location filename="mainwindow.ui" line="400"/>
         <source>Esc</source>
         <translation>Esc</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="325"/>
+        <location filename="mainwindow.ui" line="409"/>
         <source>&amp;Save results to file...</source>
         <translation>&amp;Spara resultat till fil...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="328"/>
+        <location filename="mainwindow.ui" line="412"/>
         <source>Ctrl+S</source>
         <translation>Ctrl+S</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="333"/>
+        <location filename="mainwindow.ui" line="417"/>
         <source>&amp;Quit</source>
         <translation>&amp;Avsluta</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="342"/>
+        <location filename="mainwindow.ui" line="429"/>
         <source>&amp;Clear results</source>
         <translation>&amp;Töm resultat</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="351"/>
+        <location filename="mainwindow.ui" line="438"/>
         <source>&amp;Preferences</source>
         <translation>&amp;Inställningar</translation>
     </message>
     <message>
-        <source>Errors</source>
-        <translation type="obsolete">Fel</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="384"/>
-        <location filename="mainwindow.ui" line="387"/>
+        <location filename="mainwindow.ui" line="471"/>
+        <location filename="mainwindow.ui" line="474"/>
+        <location filename="mainwindow.cpp" line="2394"/>
         <source>Show errors</source>
         <translation>Visa fel</translation>
     </message>
     <message>
-        <source>Show S&amp;cratchpad...</source>
-        <translation type="obsolete">Visa s&amp;cratchpad...</translation>
-    </message>
-    <message>
-        <source>Warnings</source>
-        <translation type="obsolete">Varningar</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="524"/>
-        <location filename="mainwindow.ui" line="527"/>
+        <location filename="mainwindow.ui" line="617"/>
+        <location filename="mainwindow.ui" line="620"/>
+        <location filename="mainwindow.cpp" line="2395"/>
         <source>Show warnings</source>
         <translation>Visa varningar</translation>
     </message>
     <message>
-        <source>Performance warnings</source>
-        <translation type="obsolete">Prestanda varningar</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="542"/>
-        <location filename="mainwindow.ui" line="545"/>
+        <location filename="mainwindow.ui" line="635"/>
+        <location filename="mainwindow.ui" line="638"/>
         <source>Show performance warnings</source>
         <translation>Visa prestanda varningar</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="553"/>
+        <location filename="mainwindow.ui" line="646"/>
         <source>Show &amp;hidden</source>
         <translation>Visa dolda</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="769"/>
-        <location filename="mainwindow.cpp" line="807"/>
+        <location filename="mainwindow.cpp" line="986"/>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Information</source>
         <translation>Information</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="568"/>
+        <location filename="mainwindow.ui" line="661"/>
         <source>Show information messages</source>
         <translation>Visa informations meddelanden</translation>
     </message>
     <message>
-        <source>Portability</source>
-        <translation type="obsolete">Portabilitet</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="583"/>
+        <location filename="mainwindow.ui" line="676"/>
         <source>Show portability warnings</source>
         <translation>Visa portabilitets varningar</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="598"/>
+        <location filename="mainwindow.ui" line="691"/>
         <source>Show Cppcheck results</source>
         <translation>Visa Cppcheck resultat</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="610"/>
+        <location filename="mainwindow.ui" line="703"/>
         <source>Clang</source>
         <translation>Clang</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="613"/>
+        <location filename="mainwindow.ui" line="706"/>
         <source>Show Clang results</source>
         <translation>Visa Clang resultat</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="621"/>
+        <location filename="mainwindow.ui" line="714"/>
         <source>&amp;Filter</source>
         <translation>&amp;Filter</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="624"/>
+        <location filename="mainwindow.ui" line="717"/>
         <source>Filter results</source>
         <translation>Filtrera resultat</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="640"/>
+        <location filename="mainwindow.ui" line="733"/>
         <source>Windows 32-bit ANSI</source>
         <translation>Windows 32-bit ANSI</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="648"/>
+        <location filename="mainwindow.ui" line="741"/>
         <source>Windows 32-bit Unicode</source>
         <translation>Windows 32-bit Unicode</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="656"/>
+        <location filename="mainwindow.ui" line="749"/>
         <source>Unix 32-bit</source>
         <translation>Unix 32-bit</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="664"/>
+        <location filename="mainwindow.ui" line="757"/>
         <source>Unix 64-bit</source>
         <translation>Unix 64-bit</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="672"/>
+        <location filename="mainwindow.ui" line="765"/>
         <source>Windows 64-bit</source>
         <translation>Windows 64-bit</translation>
     </message>
     <message>
-        <source>Platforms</source>
-        <translation type="obsolete">Plattformar</translation>
-    </message>
-    <message>
-        <source>C++11</source>
-        <translation type="obsolete">C++11</translation>
-    </message>
-    <message>
-        <source>C99</source>
-        <translation type="obsolete">C99</translation>
-    </message>
-    <message>
-        <source>Posix</source>
-        <translation type="obsolete">Posix</translation>
-    </message>
-    <message>
-        <source>C11</source>
-        <translation type="obsolete">C11</translation>
-    </message>
-    <message>
-        <source>C89</source>
-        <translation type="obsolete">C89</translation>
-    </message>
-    <message>
-        <source>C++03</source>
-        <translation type="obsolete">C++03</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="742"/>
+        <location filename="mainwindow.ui" line="859"/>
         <source>&amp;Print...</source>
         <translation>Skriv ut...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="745"/>
+        <location filename="mainwindow.ui" line="862"/>
         <source>Print the Current Report</source>
         <translation>Skriv ut aktuell rapport</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="750"/>
+        <location filename="mainwindow.ui" line="867"/>
         <source>Print Pre&amp;view...</source>
         <translation>Förhandsgranska utskrift...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="753"/>
+        <location filename="mainwindow.ui" line="870"/>
         <source>Open a Print Preview Dialog for the Current Results</source>
         <translation>Öppnar förhandsgranskning för nuvarande resultat</translation>
     </message>
     <message>
-        <source>Library Editor...</source>
-        <translation type="obsolete">Library Editor...</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="761"/>
+        <location filename="mainwindow.ui" line="878"/>
         <source>Open library editor</source>
         <translation>Öppna library editor</translation>
     </message>
     <message>
-        <source>Auto-detect language</source>
-        <translation type="obsolete">Välj språk automatiskt</translation>
+        <location filename="mainwindow.ui" line="479"/>
+        <source>&amp;Check all</source>
+        <translation>&amp;Kryssa alla</translation>
     </message>
     <message>
-        <source>Enforce C++</source>
-        <translation type="obsolete">C++</translation>
+        <location filename="mainwindow.ui" line="84"/>
+        <source>Checking for updates</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Enforce C</source>
-        <translation type="obsolete">C</translation>
+        <location filename="mainwindow.ui" line="100"/>
+        <source>Hide</source>
+        <translation type="unfinished">Dölj</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="392"/>
-        <source>&amp;Check all</source>
-        <translation>&amp;Kryssa alla</translation>
+        <location filename="mainwindow.ui" line="164"/>
+        <location filename="mainwindow.ui" line="980"/>
+        <source>Report</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="220"/>
+        <location filename="mainwindow.ui" line="304"/>
         <source>Filter</source>
         <translation>Filter</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="286"/>
+        <location filename="mainwindow.ui" line="370"/>
         <source>&amp;Reanalyze modified files</source>
         <oldsource>&amp;Recheck modified files</oldsource>
         <translation>Analysera om ändrade filer</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="298"/>
+        <location filename="mainwindow.ui" line="382"/>
         <source>Reanal&amp;yze all files</source>
         <translation>Analysera om alla filer</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="363"/>
+        <location filename="mainwindow.ui" line="420"/>
+        <source>Ctrl+Q</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="450"/>
         <source>Style war&amp;nings</source>
         <translation>Style varningar</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="381"/>
+        <location filename="mainwindow.ui" line="468"/>
         <source>E&amp;rrors</source>
         <translation>Fel</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="397"/>
+        <location filename="mainwindow.ui" line="484"/>
         <source>&amp;Uncheck all</source>
         <translation>Kryssa &amp;ur alla</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="402"/>
+        <location filename="mainwindow.ui" line="489"/>
         <source>Collapse &amp;all</source>
         <translatorcomment>Ingen bra översättning!</translatorcomment>
         <translation>&amp;Fäll ihop alla</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="407"/>
+        <location filename="mainwindow.ui" line="494"/>
         <source>&amp;Expand all</source>
         <translation>&amp;Expandera alla</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="415"/>
+        <location filename="mainwindow.ui" line="502"/>
         <source>&amp;Standard</source>
         <translation>&amp;Standard</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="418"/>
+        <location filename="mainwindow.ui" line="505"/>
         <source>Standard items</source>
         <translation>Standard poster</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="434"/>
+        <location filename="mainwindow.ui" line="521"/>
         <source>Toolbar</source>
         <translation>Verktygsfält</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="442"/>
+        <location filename="mainwindow.ui" line="529"/>
         <source>&amp;Categories</source>
         <translation>&amp;Kategorier</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="445"/>
+        <location filename="mainwindow.ui" line="532"/>
         <source>Error categories</source>
         <translation>Fel kategorier</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="450"/>
+        <location filename="mainwindow.ui" line="537"/>
         <source>&amp;Open XML...</source>
         <translation>&amp;Öppna XML...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="459"/>
+        <location filename="mainwindow.ui" line="546"/>
         <source>Open P&amp;roject File...</source>
         <translation>Öppna Projektfil...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="468"/>
+        <location filename="mainwindow.ui" line="549"/>
+        <source>Ctrl+Shift+O</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="558"/>
         <source>Sh&amp;ow Scratchpad...</source>
         <translation>Visa Scratchpad...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="473"/>
+        <location filename="mainwindow.ui" line="563"/>
         <source>&amp;New Project File...</source>
         <translation>Ny projektfil...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="478"/>
+        <location filename="mainwindow.ui" line="566"/>
+        <source>Ctrl+Shift+N</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="571"/>
         <source>&amp;Log View</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="481"/>
+        <location filename="mainwindow.ui" line="574"/>
         <source>Log View</source>
         <translation>Logg vy</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="489"/>
+        <location filename="mainwindow.ui" line="582"/>
         <source>C&amp;lose Project File</source>
         <translation>Stäng projektfil</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="497"/>
+        <location filename="mainwindow.ui" line="590"/>
         <source>&amp;Edit Project File...</source>
         <translation>Redigera projektfil...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="509"/>
+        <location filename="mainwindow.ui" line="602"/>
         <source>&amp;Statistics</source>
         <translation>Statistik</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="521"/>
+        <location filename="mainwindow.ui" line="614"/>
         <source>&amp;Warnings</source>
         <translation>Varningar</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="539"/>
+        <location filename="mainwindow.ui" line="632"/>
         <source>Per&amp;formance warnings</source>
         <translation>Optimerings varningar</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="565"/>
+        <location filename="mainwindow.ui" line="658"/>
         <source>&amp;Information</source>
         <translation>Information</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="580"/>
+        <location filename="mainwindow.ui" line="673"/>
         <source>&amp;Portability</source>
         <translation>Portabilitet</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="680"/>
+        <location filename="mainwindow.ui" line="773"/>
         <source>P&amp;latforms</source>
         <translation>Plattformar</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="694"/>
+        <location filename="mainwindow.ui" line="787"/>
         <source>C++&amp;11</source>
         <translation>C++11</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="705"/>
+        <location filename="mainwindow.ui" line="798"/>
         <source>C&amp;99</source>
         <translation>C99</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="713"/>
+        <location filename="mainwindow.ui" line="806"/>
         <source>&amp;Posix</source>
         <translation>Posix</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="721"/>
+        <location filename="mainwindow.ui" line="814"/>
         <source>C&amp;11</source>
         <translation>C11</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="729"/>
+        <location filename="mainwindow.ui" line="846"/>
         <source>&amp;C89</source>
         <translation>C89</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="737"/>
+        <location filename="mainwindow.ui" line="854"/>
         <source>&amp;C++03</source>
         <translation>C++03</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="758"/>
+        <location filename="mainwindow.ui" line="875"/>
         <source>&amp;Library Editor...</source>
         <translation>Library Editor...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="769"/>
+        <location filename="mainwindow.ui" line="886"/>
         <source>&amp;Auto-detect language</source>
         <translation>Detektera språk automatiskt</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="777"/>
+        <location filename="mainwindow.ui" line="894"/>
         <source>&amp;Enforce C++</source>
         <translation>Tvinga C++</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="785"/>
+        <location filename="mainwindow.ui" line="902"/>
         <source>E&amp;nforce C</source>
         <translation>Tvinga C</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="796"/>
+        <location filename="mainwindow.ui" line="913"/>
         <source>C++14</source>
         <translation>C++14</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="804"/>
+        <location filename="mainwindow.ui" line="921"/>
         <source>Reanalyze and check library</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="812"/>
+        <location filename="mainwindow.ui" line="929"/>
         <source>Check configuration (defines, includes)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="820"/>
+        <location filename="mainwindow.ui" line="937"/>
         <source>C++17</source>
         <translation type="unfinished">C++17</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="831"/>
+        <location filename="mainwindow.ui" line="948"/>
         <source>C++20</source>
         <translation type="unfinished">C++20</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="423"/>
+        <location filename="mainwindow.ui" line="975"/>
+        <source>Compliance report...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="988"/>
+        <source>Normal</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="996"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1004"/>
+        <source>Misra C++ 2008</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1012"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1020"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1028"/>
+        <source>Misra C++ 2023</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1036"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1041"/>
+        <source>EULA...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1046"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1049"/>
+        <source>Show thread details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="510"/>
         <source>&amp;Contents</source>
         <translation>&amp;Innehåll</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="201"/>
+        <location filename="mainwindow.ui" line="285"/>
         <source>Categories</source>
         <translation>Kategorier</translation>
     </message>
     <message>
-        <source>Style warnings</source>
-        <translation type="obsolete">Stil varningar</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="366"/>
-        <location filename="mainwindow.ui" line="369"/>
+        <location filename="mainwindow.ui" line="453"/>
+        <location filename="mainwindow.ui" line="456"/>
         <source>Show style warnings</source>
         <translation>Visa stil varningar</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="426"/>
+        <location filename="mainwindow.ui" line="513"/>
         <source>Open the help contents</source>
         <translation>Öppna hjälp</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="429"/>
+        <location filename="mainwindow.ui" line="516"/>
         <source>F1</source>
         <translation>F1</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="121"/>
+        <location filename="mainwindow.ui" line="199"/>
         <source>&amp;Help</source>
         <translation>&amp;Hjälp</translation>
     </message>
     <message>
-        <source>Select directory to check</source>
-        <translation type="obsolete">Välj katalog som skall kontrolleras</translation>
-    </message>
-    <message>
-        <source>No suitable files found to check!</source>
-        <translation type="obsolete">Inga lämpliga filer hittades!</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="87"/>
+        <location filename="mainwindow.cpp" line="157"/>
+        <location filename="mainwindow.cpp" line="1782"/>
         <source>Quick Filter:</source>
         <translation>Snabbfilter:</translation>
     </message>
     <message>
-        <source>C/C++ Source, Compile database, Visual Studio (%1 %2 *.sln *.vcxproj)</source>
-        <translation type="obsolete">C/C++ källkod, Compile database, Visual Studio (%1 %2 *.sln *.vcxproj)</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="629"/>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select configuration</source>
         <translation>Välj konfiguration</translation>
     </message>
     <message>
-        <source>Select the configuration that will be checked</source>
-        <translation type="obsolete">Välj konfiguration som kommer analyseras</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="659"/>
+        <location filename="mainwindow.cpp" line="861"/>
         <source>Found project file: %1
 
 Do you want to load this project file instead?</source>
@@ -1081,73 +1120,97 @@ Do you want to load this project file instead?</source>
 Vill du ladda denna projektfil istället?</translation>
     </message>
     <message>
-        <source>Found project files from the directory.
-
-Do you want to proceed checking without using any of these project files?</source>
-        <translation type="obsolete">Hittade projektfil(er) i mappen.
-
-Vill du fortsätta analysen utan att använda någon av dessa projektfiler?</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="778"/>
+        <location filename="mainwindow.cpp" line="995"/>
         <source>File not found</source>
         <translation>Filen hittades ej</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="781"/>
+        <location filename="mainwindow.cpp" line="998"/>
         <source>Bad XML</source>
         <translation>Ogiltig XML</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="784"/>
+        <location filename="mainwindow.cpp" line="1001"/>
         <source>Missing attribute</source>
         <translation>Attribut finns ej</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="787"/>
+        <location filename="mainwindow.cpp" line="1004"/>
         <source>Bad attribute value</source>
         <translation>Ogiltigt attribut värde</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="790"/>
+        <location filename="mainwindow.cpp" line="1007"/>
         <source>Unsupported format</source>
         <translation>Format stöds ej</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="807"/>
+        <location filename="mainwindow.cpp" line="1016"/>
+        <source>Duplicate define</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Failed to load the selected library &apos;%1&apos;.
 %2</source>
         <translation>Misslyckades att ladda valda library &apos;%1&apos;.
 %2</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1280"/>
+        <location filename="mainwindow.cpp" line="1035"/>
+        <source>File not found: &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1058"/>
+        <source>Failed to load/setup addon %1: %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <source>Failed to load %1 - %2
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
+        <source>%1
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1648"/>
         <source>License</source>
         <translation>Licens</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1287"/>
+        <location filename="mainwindow.cpp" line="1655"/>
         <source>Authors</source>
         <translation>Utvecklare</translation>
     </message>
     <message>
-        <source>XML files version 2 (*.xml);;XML files version 1 (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
-        <oldsource>XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</oldsource>
-        <translation type="obsolete">XML filer version 2 (*.xml);;XML filer version 1 (*.xml);;Text filer (*.txt);;CSV filer (*.csv)</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1302"/>
+        <location filename="mainwindow.cpp" line="1675"/>
         <source>Save the report file</source>
         <translation>Spara rapport</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1129"/>
-        <location filename="mainwindow.cpp" line="1309"/>
+        <location filename="mainwindow.cpp" line="1483"/>
+        <location filename="mainwindow.cpp" line="1682"/>
         <source>XML files (*.xml)</source>
         <translation>XML filer (*.xml)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="323"/>
+        <location filename="mainwindow.cpp" line="461"/>
         <source>There was a problem with loading the editor application settings.
 
 This is probably because the settings were changed between the Cppcheck versions. Please check (and fix) the editor application settings, otherwise the editor program might not start correctly.</source>
@@ -1156,174 +1219,125 @@ This is probably because the settings were changed between the Cppcheck versions
 En trolig orsak är att inställningarna ändrats för olika Cppcheck versioner. Kontrollera programinställningarna.</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="554"/>
+        <location filename="mainwindow.cpp" line="756"/>
         <source>You must close the project file before selecting new files or directories!</source>
         <translation>Du måste stänga projektfilen innan nya filer eller sökvägar kan väljas!</translation>
     </message>
     <message>
-        <source>Select files to check</source>
-        <translation type="obsolete">Välj filer att kontrollera</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="769"/>
+        <location filename="mainwindow.cpp" line="986"/>
         <source>The library &apos;%1&apos; contains unknown elements:
 %2</source>
         <translation>Library filen &apos;%1&apos; har element som ej hanteras:
 %2</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="793"/>
+        <location filename="mainwindow.cpp" line="1010"/>
         <source>Duplicate platform type</source>
         <translation>Dubbel plattformstyp</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="796"/>
+        <location filename="mainwindow.cpp" line="1013"/>
         <source>Platform type redefined</source>
         <translation>Plattformstyp definieras igen</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="799"/>
+        <location filename="mainwindow.cpp" line="1019"/>
         <source>Unknown element</source>
         <translation>Element hanteras ej</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="802"/>
-        <source>Unknown issue</source>
-        <translation>Något problem</translation>
+        <location filename="mainwindow.cpp" line="1019"/>
+        <source>Unknown element</source>
+        <oldsource>Unknown issue</oldsource>
+        <translation type="unfinished">Något problem</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="828"/>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
         <source>Error</source>
         <translation>Fel</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="828"/>
         <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.</source>
-        <translation>Misslyckades att ladda %1. Din Cppcheck installation är ej komplett. Du kan använda --data-dir&lt;directory&gt; på kommandoraden för att specificera var denna fil finns. Det är meningen att --data-dir kommandot skall köras under installationen,så GUIt kommer ej visas när --data-dir används allt som händer är att en inställning görs.</translation>
-    </message>
-    <message>
-        <source>Current results will be cleared.
-
-Opening a new XML file will clear current results.Do you want to proceed?</source>
-        <translation type="vanished">Nuvarande resultat kommer rensas bort.
-
-När en ny XML fil öppnas så tas alla nuvarande resultat bort. Vill du fortsätta?</translation>
+        <translation type="vanished">Misslyckades att ladda %1. Din Cppcheck installation är ej komplett. Du kan använda --data-dir&lt;directory&gt; på kommandoraden för att specificera var denna fil finns. Det är meningen att --data-dir kommandot skall köras under installationen,så GUIt kommer ej visas när --data-dir används allt som händer är att en inställning görs.</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1131"/>
+        <location filename="mainwindow.cpp" line="1485"/>
         <source>Open the report file</source>
         <translation>Öppna rapportfilen</translation>
     </message>
     <message>
-        <source>Checking is running.
-
-Do you want to stop the checking and exit Cppcheck?</source>
-        <translation type="obsolete">Cppcheck kör.
-
-Vill du stoppa analysen och avsluta Cppcheck?</translation>
-    </message>
-    <message>
-        <source>XML files version 1 (*.xml)</source>
-        <translation type="obsolete">XML filer version 1 (*.xml)</translation>
-    </message>
-    <message>
-        <source>Deprecated XML format</source>
-        <translation type="obsolete">Gammalt XML format</translation>
-    </message>
-    <message>
-        <source>XML format 1 is deprecated and will be removed in cppcheck 1.81.</source>
-        <translation type="obsolete">XML format 1 är gammalt och stödet kommer tas bort i Cppcheck 1.81</translation>
-    </message>
-    <message>
-        <source>XML files version 2 (*.xml)</source>
-        <translation type="obsolete">XML filer version 2 (*.xml)</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1313"/>
+        <location filename="mainwindow.cpp" line="1686"/>
         <source>Text files (*.txt)</source>
         <translation>Text filer (*.txt)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1317"/>
+        <location filename="mainwindow.cpp" line="1690"/>
         <source>CSV files (*.csv)</source>
         <translation>CSV filer (*.csv)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1361"/>
-        <source>Cppcheck - %1</source>
-        <translation>Cppcheck - %1</translation>
-    </message>
-    <message>
-        <source>Failed to change the user interface language:
-
-%1
-
-The user interface language has been reset to English. Open the Preferences-dialog to select any of the available languages.</source>
-        <translation type="obsolete">Misslyckades att ändra språk:
-
-%1
-
-Språket har nollställts till Engelska. Öppna Preferences och välj något av de tillgängliga språken.</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1407"/>
+        <location filename="mainwindow.cpp" line="1820"/>
         <source>Project files (*.cppcheck);;All files(*.*)</source>
         <translation>Projektfiler (*.cppcheck);;Alla filer(*.*)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1409"/>
+        <location filename="mainwindow.cpp" line="1822"/>
         <source>Select Project File</source>
         <translation>Välj projektfil</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="159"/>
-        <location filename="mainwindow.cpp" line="1437"/>
-        <location filename="mainwindow.cpp" line="1562"/>
+        <location filename="mainwindow.cpp" line="242"/>
+        <location filename="mainwindow.cpp" line="1784"/>
+        <location filename="mainwindow.cpp" line="1850"/>
+        <location filename="mainwindow.cpp" line="2048"/>
         <source>Project:</source>
         <translation>Projekt:</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="481"/>
+        <location filename="mainwindow.cpp" line="671"/>
         <source>No suitable files found to analyze!</source>
         <translation>Inga filer hittades att analysera!</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="568"/>
+        <location filename="mainwindow.cpp" line="770"/>
         <source>C/C++ Source</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="569"/>
+        <location filename="mainwindow.cpp" line="771"/>
         <source>Compile database</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="570"/>
+        <location filename="mainwindow.cpp" line="772"/>
         <source>Visual Studio</source>
         <translation type="unfinished">Visual Studio</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="571"/>
+        <location filename="mainwindow.cpp" line="773"/>
         <source>Borland C++ Builder 6</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="574"/>
+        <location filename="mainwindow.cpp" line="776"/>
         <source>Select files to analyze</source>
         <translation>Välj filer att analysera</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="589"/>
+        <location filename="mainwindow.cpp" line="791"/>
         <source>Select directory to analyze</source>
         <translation>Välj mapp att analysera</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="629"/>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select the configuration that will be analyzed</source>
         <translation>Välj konfiguration som kommer analyseras</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="681"/>
+        <location filename="mainwindow.cpp" line="883"/>
         <source>Found project files from the directory.
 
 Do you want to proceed analysis without using any of these project files?</source>
@@ -1332,7 +1346,7 @@ Do you want to proceed analysis without using any of these project files?</sourc
 Vill du fortsätta analysen utan att använda någon av dessa projekt filer?</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1114"/>
+        <location filename="mainwindow.cpp" line="1468"/>
         <source>Current results will be cleared.
 
 Opening a new XML file will clear current results.
@@ -1340,7 +1354,7 @@ Do you want to proceed?</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1234"/>
+        <location filename="mainwindow.cpp" line="1592"/>
         <source>Analyzer is running.
 
 Do you want to stop the analysis and exit Cppcheck?</source>
@@ -1349,37 +1363,133 @@ Do you want to stop the analysis and exit Cppcheck?</source>
 Vill du stoppa analysen och avsluta Cppcheck?</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1300"/>
+        <location filename="mainwindow.cpp" line="1634"/>
+        <source>About</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1673"/>
         <source>XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
         <translation>XML filer (*.xml);;Text filer (*.txt);;CSV filer (*.csv)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1500"/>
+        <location filename="mainwindow.cpp" line="1713"/>
+        <source>Cannot generate a compliance report right now, an analysis must finish successfully. Try to reanalyze the code and ensure there are no critical errors.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1938"/>
         <source>Build dir &apos;%1&apos; does not exist, create it?</source>
         <translation>Build dir &apos;%1&apos; existerar ej, skapa den?</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1523"/>
+        <location filename="mainwindow.cpp" line="1946"/>
+        <source>To check the project using addons, you need a build directory.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1978"/>
+        <source>Failed to open file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1981"/>
+        <source>Unknown project file format</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1984"/>
+        <source>Failed to import project file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2000"/>
+        <source>Failed to import &apos;%1&apos;: %2
+
+Analysis is stopped.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2009"/>
+        <source>Failed to import &apos;%1&apos; (%2), analysis is stopped</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2367"/>
+        <source>Show Mandatory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2368"/>
+        <source>Show Required</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2369"/>
+        <source>Show Advisory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2370"/>
+        <source>Show Document</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2387"/>
+        <source>Show L1</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2388"/>
+        <source>Show L2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2389"/>
+        <source>Show L3</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2396"/>
+        <source>Show style</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2397"/>
+        <source>Show portability</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2398"/>
+        <source>Show performance</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2399"/>
+        <source>Show information</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
         <source>Failed to import &apos;%1&apos;, analysis is stopped</source>
-        <translation>Misslyckades att importera &apos;%1&apos;, analysen stoppas</translation>
+        <translation type="vanished">Misslyckades att importera &apos;%1&apos;, analysen stoppas</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1547"/>
+        <location filename="mainwindow.cpp" line="2033"/>
         <source>Project files (*.cppcheck)</source>
         <translation>Projekt filer (*.cppcheck)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1549"/>
+        <location filename="mainwindow.cpp" line="2035"/>
         <source>Select Project Filename</source>
         <translation>Välj Projektfil</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1594"/>
+        <location filename="mainwindow.cpp" line="2081"/>
         <source>No project file loaded</source>
         <translation>Inget projekt laddat</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1662"/>
+        <location filename="mainwindow.cpp" line="2163"/>
         <source>The project file
 
 %1
@@ -1396,31 +1506,17 @@ Do you want to remove the file from the recently used projects -list?</source>
 Vill du ta bort filen från &apos;senast använda projekt&apos;-listan?</translation>
     </message>
     <message>
-        <source>Cppcheck GUI.
-
-Syntax:
-    cppcheck-gui [OPTIONS] [files or paths]
-
-Options:
-    -h, --help     Print this help
-    -p &lt;file&gt;      Open given project file and start checking it
-    -l &lt;file&gt;      Open given results xml file
-    -d &lt;directory&gt; Specify the directory that was checked to generate the results xml specified with -l
-    -v, --version  Show program version</source>
-        <translation type="obsolete">Cppcheck GUI.
-
-Syntax:
-    cppcheck-gui [OPTIONS] [files or paths]
-
-Options:
-    -h, --help     Print this help
-    -p &lt;file&gt;      Open given project file and start checking it
-    -l &lt;file&gt;      Open given results xml file
-    -d &lt;directory&gt; Specify the directory that was checked to generate the results xml specified with -l
-    -v, --version  Show program version</translation>
+        <location filename="mainwindow.cpp" line="2325"/>
+        <source>Install</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2329"/>
+        <source>New version available: %1. %2</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="main.cpp" line="106"/>
+        <location filename="main.cpp" line="100"/>
         <source>Cppcheck GUI.
 
 Syntax:
@@ -1463,7 +1559,7 @@ Options:
                             is used.</translation>
     </message>
     <message>
-        <location filename="main.cpp" line="121"/>
+        <location filename="main.cpp" line="115"/>
         <source>Cppcheck GUI - Command line parameters</source>
         <translation>Cppcheck GUI - Command line parameters</translation>
     </message>
@@ -1496,7 +1592,7 @@ Options:
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="newsuppressiondialog.cpp" line="52"/>
+        <location filename="newsuppressiondialog.cpp" line="83"/>
         <source>Edit suppression</source>
         <translation type="unfinished"></translation>
     </message>
@@ -1504,345 +1600,424 @@ Options:
 <context>
     <name>Platforms</name>
     <message>
-        <source>Built-in</source>
-        <translation type="obsolete">Generell</translation>
-    </message>
-    <message>
-        <location filename="platforms.cpp" line="37"/>
+        <location filename="platforms.cpp" line="38"/>
         <source>Native</source>
         <translation>Native</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="38"/>
+        <location filename="platforms.cpp" line="39"/>
         <source>Unix 32-bit</source>
         <translation>Unix 32-bit</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="39"/>
+        <location filename="platforms.cpp" line="40"/>
         <source>Unix 64-bit</source>
         <translation>Unix 64-bit</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="40"/>
+        <location filename="platforms.cpp" line="41"/>
         <source>Windows 32-bit ANSI</source>
         <translation>Windows 32-bit ANSI</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="41"/>
+        <location filename="platforms.cpp" line="42"/>
         <source>Windows 32-bit Unicode</source>
         <translation>Windows 32-bit Unicode</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="42"/>
+        <location filename="platforms.cpp" line="43"/>
         <source>Windows 64-bit</source>
         <translation>Windows 64-bit</translation>
     </message>
 </context>
 <context>
-    <name>Project</name>
+    <name>ProjectFile</name>
     <message>
-        <source>Cppcheck</source>
-        <translation type="obsolete">Cppcheck</translation>
+        <location filename="projectfile.ui" line="14"/>
+        <source>Project File</source>
+        <translation>Projektfil</translation>
     </message>
     <message>
-        <source>Could not read the project file.</source>
-        <translation type="obsolete">Kunde ej läsa projektfilen.</translation>
+        <location filename="projectfile.ui" line="24"/>
+        <source>Paths and Defines</source>
+        <translation>Sökvägar och defines</translation>
     </message>
     <message>
-        <source>Could not write the project file.</source>
-        <translation type="obsolete">Kunde ej skriva projektfilen</translation>
+        <location filename="projectfile.ui" line="30"/>
+        <source>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</source>
+        <oldsource>Import Project (Visual studio / compile database)</oldsource>
+        <translation type="unfinished">Importera Projekt (Visual Studio / compile database)</translation>
     </message>
-</context>
-<context>
-    <name>ProjectFile</name>
     <message>
-        <location filename="projectfiledialog.ui" line="14"/>
-        <source>Project File</source>
-        <translation>Projektfil</translation>
+        <location filename="projectfile.ui" line="231"/>
+        <source>Defines must be separated by a semicolon. Example: DEF1;DEF2=5;DEF3=int</source>
+        <oldsource>Defines must be separated by a semicolon &apos;;&apos;</oldsource>
+        <translation type="unfinished">Defines separeras med semicolon &apos;;&apos;</translation>
     </message>
     <message>
-        <source>Project</source>
-        <translation type="obsolete">Projekt</translation>
+        <location filename="projectfile.ui" line="389"/>
+        <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
+        <translation>Obs: Lägg dina egna .cfg filer i samma folder som projekt filen. De skall isåfall visas ovan.</translation>
     </message>
     <message>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;In the build dir, cppcheck stores data about each translation unit.&lt;/p&gt;&lt;p&gt;With a build dir you get whole program analysis.&lt;/p&gt;&lt;p&gt;Unchanged files will be analyzed much faster; Cppcheck skip the analysis of these files and reuse their old data.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
-        <translation type="obsolete">I build dir sparar Cppcheck information för varje translation unit.
-Med build dir får du whole program analys.
-Omodifierade filer analyseras mycket fortare, Cppcheck hoppar över analysen och återanvänder den gamla informationen</translation>
+        <location filename="projectfile.ui" line="890"/>
+        <source>...</source>
+        <translation>...</translation>
     </message>
     <message>
-        <source>Cppcheck build dir (whole program analysis, faster analysis for unchanged files)</source>
-        <translation type="obsolete">Cppcheck build dir (whole program analys, snabbare analys för omodifierade filer)</translation>
+        <location filename="projectfile.ui" line="73"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;You have a choice:&lt;/p&gt;&lt;p&gt; * Analyze all Debug and Release configurations&lt;/p&gt;&lt;p&gt; * Only analyze the first matching Debug configuration&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Du har ett val:&lt;/p&gt;&lt;p&gt; * Analysera alla Debug och Release konfigurationer&lt;/p&gt;&lt;p&gt; * Analysera bara den första matchande Debug konfigurationen&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="24"/>
-        <source>Paths and Defines</source>
-        <translation>Sökvägar och defines</translation>
+        <location filename="projectfile.ui" line="60"/>
+        <location filename="projectfile.ui" line="422"/>
+        <location filename="projectfile.ui" line="616"/>
+        <source>Browse...</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Cppcheck can import Visual studio solutions (*.sln), Visual studio projects (*.vcxproj) or compile databases.&lt;/p&gt;&lt;p&gt;Files to check, defines, include paths are imported.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
-        <translation type="obsolete">Cppcheck kan importera Visual studio solutions (*.sln), Visual studio projekt (*.vcxproj) eller compile databases.
-Sökvägar och defines importeras.</translation>
+        <location filename="projectfile.ui" line="76"/>
+        <source>Analyze all Visual Studio configurations</source>
+        <translation>Analysera alla Visual Studio konfigurationer</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="30"/>
-        <source>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</source>
-        <oldsource>Import Project (Visual studio / compile database)</oldsource>
-        <translation type="unfinished">Importera Projekt (Visual Studio / compile database)</translation>
+        <location filename="projectfile.ui" line="113"/>
+        <source>Selected VS Configurations</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="147"/>
+        <source>Paths:</source>
+        <translation>Sökvägar:</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="181"/>
+        <location filename="projectfile.ui" line="296"/>
+        <source>Add...</source>
+        <translation>Lägg till...</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="188"/>
+        <location filename="projectfile.ui" line="303"/>
+        <location filename="projectfile.ui" line="690"/>
+        <source>Edit</source>
+        <translation>Redigera</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="195"/>
+        <location filename="projectfile.ui" line="310"/>
+        <location filename="projectfile.ui" line="697"/>
+        <location filename="projectfile.ui" line="740"/>
+        <source>Remove</source>
+        <translation>Ta bort</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="242"/>
+        <source>Undefines:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="252"/>
+        <source>Undefines must be separated by a semicolon. Example: UNDEF1;UNDEF2;UNDEF3</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="265"/>
+        <source>Include Paths:</source>
+        <translation>Include sökvägar:</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="415"/>
+        <source>This is a workfolder that Cppcheck will use for various purposes.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="448"/>
+        <source>Clang (experimental)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="458"/>
+        <source>Check level</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="464"/>
+        <source>Reduced -- meant for usage where developer wants results directly. Limited and faster analysis with fewer results.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="471"/>
+        <source>Normal -- meant for normal analysis in CI. Analysis should finish in reasonable time.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="163"/>
-        <source>Defines must be separated by a semicolon. Example: DEF1;DEF2=5;DEF3=int</source>
-        <oldsource>Defines must be separated by a semicolon &apos;;&apos;</oldsource>
-        <translation type="unfinished">Defines separeras med semicolon &apos;;&apos;</translation>
+        <location filename="projectfile.ui" line="478"/>
+        <source>Exhaustive -- meant for nightly builds etc. Analysis time can be longer (10x slower than compilation is OK).</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>&amp;Root:</source>
-        <oldsource>Root:</oldsource>
-        <translation type="obsolete">Rot:</translation>
+        <location filename="projectfile.ui" line="494"/>
+        <source>If you want to design your classes to be as flexible and robust as possible then the public interface must be very robust. Cppcheck will asumme that arguments can take *any* value.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Libraries:</source>
-        <translation type="obsolete">Libraries:</translation>
+        <location filename="projectfile.ui" line="519"/>
+        <source>Check code in headers  (should be ON normally. if you want a limited quick analysis then turn this OFF)</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="393"/>
-        <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
-        <translation>Obs: Lägg dina egna .cfg filer i samma folder som projekt filen. De skall isåfall visas ovan.</translation>
+        <location filename="projectfile.ui" line="572"/>
+        <source>Max recursion in template instantiation</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Visual Studio</source>
-        <translation type="obsolete">Visual Studio</translation>
+        <location filename="projectfile.ui" line="607"/>
+        <source>Premium License</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="620"/>
-        <source>...</source>
-        <translation>...</translation>
+        <location filename="projectfile.ui" line="639"/>
+        <source>Filepaths in warnings will be relative to this path</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="69"/>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;You have a choice:&lt;/p&gt;&lt;p&gt; * Analyze all Debug and Release configurations&lt;/p&gt;&lt;p&gt; * Only analyze the first matching Debug configuration&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
-        <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Du har ett val:&lt;/p&gt;&lt;p&gt; * Analysera alla Debug och Release konfigurationer&lt;/p&gt;&lt;p&gt; * Analysera bara den första matchande Debug konfigurationen&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
+        <location filename="projectfile.ui" line="655"/>
+        <source>If tags are added, you will be able to right click on warnings and set one of these tags. You can manually categorize warnings.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="60"/>
-        <location filename="projectfiledialog.ui" line="309"/>
-        <source>Browse...</source>
+        <location filename="projectfile.ui" line="665"/>
+        <source>Exclude source files</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="72"/>
-        <source>Analyze all Visual Studio configurations</source>
-        <translation>Analysera alla Visual Studio konfigurationer</translation>
+        <location filename="projectfile.ui" line="676"/>
+        <source>Exclude folder...</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="86"/>
-        <source>Paths:</source>
-        <translation>Sökvägar:</translation>
+        <location filename="projectfile.ui" line="683"/>
+        <source>Exclude file...</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="113"/>
-        <location filename="projectfiledialog.ui" line="228"/>
-        <location filename="projectfiledialog.ui" line="461"/>
-        <source>Add...</source>
-        <translation>Lägg till...</translation>
+        <location filename="projectfile.ui" line="765"/>
+        <source>Enable inline suppressions</source>
+        <translation type="unfinished">Använd inline suppressions</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="120"/>
-        <location filename="projectfiledialog.ui" line="235"/>
-        <location filename="projectfiledialog.ui" line="468"/>
-        <source>Edit</source>
-        <translation>Redigera</translation>
+        <location filename="projectfile.ui" line="833"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="127"/>
-        <location filename="projectfiledialog.ui" line="242"/>
-        <location filename="projectfiledialog.ui" line="475"/>
-        <location filename="projectfiledialog.ui" line="518"/>
-        <source>Remove</source>
-        <translation>Ta bort</translation>
+        <location filename="projectfile.ui" line="841"/>
+        <source>2012</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="174"/>
-        <source>Undefines:</source>
+        <location filename="projectfile.ui" line="846"/>
+        <location filename="projectfile.ui" line="914"/>
+        <source>2023</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="184"/>
-        <source>Undefines must be separated by a semicolon. Example: UNDEF1;UNDEF2;UNDEF3</source>
+        <location filename="projectfile.ui" line="851"/>
+        <source>2025</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="197"/>
-        <source>Include Paths:</source>
-        <translation>Include sökvägar:</translation>
+        <location filename="projectfile.ui" line="876"/>
+        <source>MISRA rule texts</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="597"/>
-        <source>MISRA C 2012</source>
+        <location filename="projectfile.ui" line="883"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="606"/>
-        <source>Misra rule texts</source>
+        <location filename="projectfile.ui" line="901"/>
+        <source>Misra C++</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="613"/>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <location filename="projectfile.ui" line="909"/>
+        <source>2008</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="632"/>
-        <source>External tools</source>
+        <location filename="projectfile.ui" line="958"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="972"/>
+        <source>Safety profiles (defined in C++ core guidelines)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Includes</source>
-        <translation type="obsolete">Include</translation>
+        <location filename="projectfile.ui" line="982"/>
+        <source>Bug hunting (Premium)</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Include directories:</source>
-        <translation type="obsolete">Include sökvägar</translation>
+        <location filename="projectfile.ui" line="998"/>
+        <source>External tools</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="262"/>
+        <location filename="projectfile.ui" line="330"/>
         <source>Up</source>
         <translation>Upp</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="269"/>
+        <location filename="projectfile.ui" line="337"/>
         <source>Down</source>
         <translation>Ned</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="294"/>
-        <source>Checking</source>
+        <location filename="projectfile.ui" line="368"/>
+        <source>Platform</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="403"/>
+        <location filename="projectfile.ui" line="488"/>
+        <source>Analysis</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="319"/>
-        <source>Platform</source>
+        <location filename="projectfile.ui" line="432"/>
+        <source>Parser</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="331"/>
-        <source>Analysis</source>
+        <location filename="projectfile.ui" line="438"/>
+        <source>Cppcheck (built in)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="497"/>
+        <source>Check that each class has a safe public interface</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="337"/>
-        <source>Check code in headers  (slower analysis, more results)</source>
+        <location filename="projectfile.ui" line="513"/>
+        <source>Limit analysis</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="347"/>
-        <source>Check code in unused templates  (slower and less accurate analysis)</source>
+        <location filename="projectfile.ui" line="529"/>
+        <source>Check code in unused templates (should be ON normally, however in theory you can safely ignore warnings in unused templates)</source>
+        <oldsource>Check code in unused templates  (slower and less accurate analysis)</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="356"/>
+        <location filename="projectfile.ui" line="541"/>
         <source>Max CTU depth</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="420"/>
+        <location filename="projectfile.ui" line="627"/>
         <source>Warning options</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="426"/>
+        <location filename="projectfile.ui" line="633"/>
         <source>Root path:</source>
         <translation>Bas sökväg:</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="438"/>
+        <location filename="projectfile.ui" line="649"/>
         <source>Warning tags (separated by semicolon)</source>
         <translation>Varnings taggar (separerade med semikolon)</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="450"/>
-        <source>Exclude source files in paths</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="300"/>
+        <location filename="projectfile.ui" line="409"/>
         <source>Cppcheck build dir (whole program analysis, incremental analysis, statistics, etc)</source>
         <translation>Cppcheck build dir (whole program analys, incremental analys, statistik, etc)</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="384"/>
-        <source>Libraries</source>
-        <translation>Libraries</translation>
+        <location filename="projectfile.ui" line="362"/>
+        <source>Types and Functions</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Exclude</source>
-        <translation type="obsolete">Exkludera</translation>
+        <location filename="projectfile.ui" line="380"/>
+        <source>Libraries</source>
+        <translation>Libraries</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="500"/>
+        <location filename="projectfile.ui" line="722"/>
         <source>Suppressions</source>
         <translation>Suppressions</translation>
     </message>
     <message>
-        <source>Suppression list:</source>
-        <translation type="obsolete">Suppression-list:</translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="511"/>
+        <location filename="projectfile.ui" line="733"/>
         <source>Add</source>
         <translation>Lägg till</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="557"/>
-        <source>Addons and tools</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="563"/>
+        <location filename="projectfile.ui" line="786"/>
+        <location filename="projectfile.ui" line="792"/>
         <source>Addons</source>
         <translation>Addons</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="569"/>
+        <location filename="projectfile.ui" line="798"/>
+        <source>Note: Addons require &lt;a href=&quot;https://www.python.org/&quot;&gt;Python&lt;/a&gt; being installed.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="808"/>
         <source>Y2038</source>
         <translation>Y2038</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="576"/>
+        <location filename="projectfile.ui" line="815"/>
         <source>Thread safety</source>
         <translation>Tråd säkerhet</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="583"/>
+        <location filename="projectfile.ui" line="825"/>
         <source>Coding standards</source>
         <translation>Kodstandarder</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="590"/>
-        <source>Cert</source>
-        <translation>Cert</translation>
+        <location filename="projectfile.ui" line="937"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="946"/>
+        <source>CERT-INT35-C:  int precision (if size equals precision, you can leave empty)</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Extra Tools</source>
-        <translation type="obsolete">Extra verktyg</translation>
+        <location filename="projectfile.ui" line="965"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>It is common best practice to use several tools.</source>
-        <translation type="obsolete">Best practice är att använda flera verktyg</translation>
+        <location filename="projectfile.ui" line="988"/>
+        <source>Bug hunting</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="645"/>
+        <location filename="projectfile.ui" line="1011"/>
         <source>Clang analyzer</source>
         <translation>Clang analyzer</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="638"/>
+        <location filename="projectfile.ui" line="1004"/>
         <source>Clang-tidy</source>
         <translation>Clang-tidy</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="153"/>
+        <location filename="projectfile.ui" line="221"/>
         <source>Defines:</source>
         <translation>Defines:</translation>
     </message>
@@ -1850,295 +2025,341 @@ Sökvägar och defines importeras.</translation>
 <context>
     <name>ProjectFileDialog</name>
     <message>
-        <location filename="projectfiledialog.cpp" line="71"/>
+        <location filename="projectfiledialog.cpp" line="138"/>
         <source>Project file: %1</source>
         <translation>Projektfil: %1</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="305"/>
-        <source>(no rule texts file)</source>
+        <location filename="projectfiledialog.cpp" line="396"/>
+        <source>Note: Open source Cppcheck does not fully implement Misra C 2012</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="311"/>
+        <location filename="projectfiledialog.cpp" line="461"/>
         <source>Clang-tidy (not found)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="409"/>
+        <location filename="projectfiledialog.cpp" line="590"/>
         <source>Select Cppcheck build dir</source>
         <translation>Välj Cppcheck build dir</translation>
     </message>
     <message>
-        <source>Visual Studio (*.sln *.vcxproj);;Compile database (compile_commands.json)</source>
-        <translation type="obsolete">Visual Studio (*.sln *.vcxproj);;Compile database (compile_commands.json)</translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.cpp" line="637"/>
+        <location filename="projectfiledialog.cpp" line="851"/>
         <source>Select include directory</source>
         <translation>Välj include sökväg</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="742"/>
+        <location filename="projectfiledialog.cpp" line="879"/>
+        <source>Source files</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="880"/>
+        <source>All files</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="881"/>
+        <source>Exclude file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="964"/>
         <source>Select MISRA rule texts file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="742"/>
-        <source>Misra rule texts file (%1)</source>
+        <location filename="projectfiledialog.cpp" line="966"/>
+        <source>MISRA rule texts file (%1)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="617"/>
+        <location filename="projectfiledialog.cpp" line="831"/>
         <source>Select a directory to check</source>
         <translation>Välj mapp att analysera</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="445"/>
+        <location filename="projectfiledialog.cpp" line="629"/>
         <source>Visual Studio</source>
         <translation type="unfinished">Visual Studio</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="446"/>
+        <location filename="projectfiledialog.cpp" line="630"/>
         <source>Compile database</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="447"/>
+        <location filename="projectfiledialog.cpp" line="631"/>
         <source>Borland C++ Builder 6</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="448"/>
+        <location filename="projectfiledialog.cpp" line="632"/>
         <source>Import Project</source>
         <translation>Importera Projekt</translation>
     </message>
     <message>
-        <source>Visual Studio (*.sln *.vcxproj);;Compile database (compile_database.json)</source>
-        <translation type="obsolete">Visual Studio (*.sln *.vcxproj);;Compile database (compile_database.json)</translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.cpp" line="657"/>
+        <location filename="projectfiledialog.cpp" line="871"/>
         <source>Select directory to ignore</source>
         <translation>Välj sökväg att ignorera</translation>
     </message>
-    <message>
-        <source>Add Suppression</source>
-        <translation type="obsolete">Lägg till Suppression</translation>
-    </message>
-    <message>
-        <source>Select error id suppress:</source>
-        <translation type="obsolete">Välj error Id suppress:</translation>
-    </message>
-</context>
-<context>
-    <name>QDialogButtonBox</name>
-    <message>
-        <location filename="translationhandler.cpp" line="34"/>
-        <source>OK</source>
-        <translation>OK</translation>
-    </message>
-    <message>
-        <location filename="translationhandler.cpp" line="35"/>
-        <source>Cancel</source>
-        <translation>Avbryt</translation>
-    </message>
-    <message>
-        <location filename="translationhandler.cpp" line="36"/>
-        <source>Close</source>
-        <translation>Stäng</translation>
-    </message>
-    <message>
-        <location filename="translationhandler.cpp" line="37"/>
-        <source>Save</source>
-        <translation>Spara</translation>
-    </message>
 </context>
 <context>
     <name>QObject</name>
     <message>
-        <location filename="translationhandler.cpp" line="104"/>
+        <location filename="translationhandler.cpp" line="91"/>
         <source>Unknown language specified!</source>
         <translation>Okänt språk valt!</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="132"/>
+        <location filename="translationhandler.cpp" line="117"/>
         <source>Language file %1 not found!</source>
         <oldsource>Language file %1.qm not found!</oldsource>
         <translation>Språk filen %1 hittades ej!</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="138"/>
+        <location filename="translationhandler.cpp" line="122"/>
         <source>Failed to load translation for language %1 from file %2</source>
         <oldsource>Failed to load translation for language %1 from file %2.qm</oldsource>
         <translation>Misslyckades med att ladda översättningen för %1 från filen %2</translation>
     </message>
     <message>
-        <location filename="cppchecklibrarydata.cpp" line="33"/>
+        <location filename="cppchecklibrarydata.cpp" line="38"/>
         <source>line %1: Unhandled element %2</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="226"/>
+        <location filename="cppchecklibrarydata.cpp" line="43"/>
+        <source>line %1: Mandatory attribute &apos;%2&apos; missing in &apos;%3&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="284"/>
         <source> (Not found)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="69"/>
+        <location filename="codeeditstylecontrols.cpp" line="76"/>
         <source>Thin</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="71"/>
+        <location filename="codeeditstylecontrols.cpp" line="78"/>
         <source>ExtraLight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="73"/>
+        <location filename="codeeditstylecontrols.cpp" line="80"/>
         <source>Light</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="75"/>
+        <location filename="codeeditstylecontrols.cpp" line="82"/>
         <source>Normal</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="77"/>
+        <location filename="codeeditstylecontrols.cpp" line="84"/>
         <source>Medium</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="79"/>
+        <location filename="codeeditstylecontrols.cpp" line="86"/>
         <source>DemiBold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="81"/>
+        <location filename="codeeditstylecontrols.cpp" line="88"/>
         <source>Bold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="83"/>
+        <location filename="codeeditstylecontrols.cpp" line="90"/>
         <source>ExtraBold</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="85"/>
+        <location filename="codeeditstylecontrols.cpp" line="92"/>
         <source>Black</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="69"/>
+        <location filename="codeeditstyledialog.cpp" line="80"/>
         <source>Editor Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="72"/>
+        <location filename="codeeditstyledialog.cpp" line="83"/>
         <source>Editor Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="75"/>
+        <location filename="codeeditstyledialog.cpp" line="86"/>
         <source>Highlight Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="78"/>
+        <location filename="codeeditstyledialog.cpp" line="89"/>
         <source>Line Number Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="81"/>
+        <location filename="codeeditstyledialog.cpp" line="92"/>
         <source>Line Number Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="84"/>
+        <location filename="codeeditstyledialog.cpp" line="95"/>
         <source>Keyword Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="87"/>
+        <location filename="codeeditstyledialog.cpp" line="98"/>
         <source>Keyword Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="90"/>
+        <location filename="codeeditstyledialog.cpp" line="101"/>
         <source>Class Foreground Color</source>
         <oldsource>Class ForegroundColor</oldsource>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="93"/>
+        <location filename="codeeditstyledialog.cpp" line="104"/>
         <source>Class Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="96"/>
+        <location filename="codeeditstyledialog.cpp" line="107"/>
         <source>Quote Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="99"/>
+        <location filename="codeeditstyledialog.cpp" line="110"/>
         <source>Quote Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="102"/>
+        <location filename="codeeditstyledialog.cpp" line="113"/>
         <source>Comment Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="105"/>
+        <location filename="codeeditstyledialog.cpp" line="116"/>
         <source>Comment Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="108"/>
+        <location filename="codeeditstyledialog.cpp" line="119"/>
         <source>Symbol Foreground Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="111"/>
+        <location filename="codeeditstyledialog.cpp" line="122"/>
         <source>Symbol Background Color</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="114"/>
+        <location filename="codeeditstyledialog.cpp" line="125"/>
         <source>Symbol Font Weight</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="130"/>
+        <location filename="codeeditstyledialog.cpp" line="141"/>
         <source>Set to Default Light</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="132"/>
+        <location filename="codeeditstyledialog.cpp" line="143"/>
         <source>Set to Default Dark</source>
         <translation type="unfinished"></translation>
     </message>
+    <message>
+        <location filename="resultstree.cpp" line="113"/>
+        <source>File</source>
+        <translation type="unfinished">Fil</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="114"/>
+        <source>Line</source>
+        <translation type="unfinished">Rad</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="115"/>
+        <source>Severity</source>
+        <translation type="unfinished">Typ</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="116"/>
+        <source>Classification</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="117"/>
+        <source>Level</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="118"/>
+        <source>Inconclusive</source>
+        <translation type="unfinished">Inconclusive</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="119"/>
+        <source>Summary</source>
+        <translation type="unfinished">Sammanfattning</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="120"/>
+        <source>Id</source>
+        <translation type="unfinished">Id</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="121"/>
+        <source>Guideline</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="122"/>
+        <source>Rule</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="123"/>
+        <source>Since date</source>
+        <translation type="unfinished">Sedan datum</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="124"/>
+        <source>Tags</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="125"/>
+        <source>CWE</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>QPlatformTheme</name>
     <message>
-        <location filename="translationhandler.cpp" line="39"/>
+        <location filename="translationhandler.cpp" line="41"/>
         <source>OK</source>
         <translation>OK</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="40"/>
+        <location filename="translationhandler.cpp" line="42"/>
         <source>Cancel</source>
         <translation>Avbryt</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="41"/>
+        <location filename="translationhandler.cpp" line="43"/>
         <source>Close</source>
         <translation>Stäng</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="42"/>
+        <location filename="translationhandler.cpp" line="44"/>
         <source>Save</source>
         <translation>Spara</translation>
     </message>
@@ -2146,129 +2367,116 @@ Sökvägar och defines importeras.</translation>
 <context>
     <name>ResultsTree</name>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>File</source>
-        <translation>Fil</translation>
+        <translation type="vanished">Fil</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Severity</source>
-        <translation>Typ</translation>
+        <translation type="vanished">Typ</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Line</source>
-        <translation>Rad</translation>
+        <translation type="vanished">Rad</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Summary</source>
-        <translation>Sammanfattning</translation>
+        <translation type="vanished">Sammanfattning</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="136"/>
         <source>Undefined file</source>
-        <translation>Odefinierad fil</translation>
+        <translation type="vanished">Odefinierad fil</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="614"/>
+        <location filename="resultstree.cpp" line="668"/>
         <source>Copy</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="797"/>
+        <location filename="resultstree.cpp" line="836"/>
         <source>Could not find file:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="801"/>
+        <location filename="resultstree.cpp" line="840"/>
         <source>Please select the folder &apos;%1&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="802"/>
+        <location filename="resultstree.cpp" line="841"/>
         <source>Select Directory &apos;%1&apos;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="804"/>
+        <location filename="resultstree.cpp" line="843"/>
         <source>Please select the directory where file is located.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>[Inconclusive]</source>
-        <translation type="obsolete">[Inconclusive]</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="312"/>
+        <location filename="resultstree.cpp" line="373"/>
         <source>debug</source>
         <translation>debug</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="249"/>
+        <location filename="resultstree.cpp" line="307"/>
         <source>note</source>
         <translation>note</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="613"/>
         <source>Recheck</source>
-        <translation>Analysera om</translation>
-    </message>
-    <message>
-        <source>Copy filename</source>
-        <translation type="obsolete">Kopiera filnamn</translation>
-    </message>
-    <message>
-        <source>Copy full path</source>
-        <translation type="obsolete">Kopiera full sökväg</translation>
-    </message>
-    <message>
-        <source>Copy message</source>
-        <translation type="obsolete">Kopiera meddelande</translation>
-    </message>
-    <message>
-        <source>Copy message id</source>
-        <translation type="obsolete">Kopiera meddelande id</translation>
+        <translation type="vanished">Analysera om</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="615"/>
         <source>Hide</source>
-        <translation>Dölj</translation>
+        <translation type="vanished">Dölj</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="616"/>
+        <location filename="resultstree.cpp" line="670"/>
         <source>Hide all with id</source>
         <translation>Dölj alla med id</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="617"/>
+        <location filename="resultstree.cpp" line="692"/>
         <source>Suppress selected id(s)</source>
         <translation>Stäng av valda id</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="618"/>
+        <location filename="resultstree.cpp" line="671"/>
         <source>Open containing folder</source>
         <translation>Öppna mapp</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="648"/>
-        <location filename="resultstree.cpp" line="1343"/>
+        <location filename="resultstree.cpp" line="376"/>
+        <source>internal</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="667"/>
+        <source>Recheck %1 file(s)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="669"/>
+        <source>Hide %1 result(s)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="712"/>
         <source>Tag</source>
         <translation>Tag</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="650"/>
+        <location filename="resultstree.cpp" line="714"/>
         <source>No tag</source>
         <translation>Ingen tag</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="693"/>
-        <location filename="resultstree.cpp" line="707"/>
+        <location filename="resultstree.cpp" line="744"/>
+        <location filename="resultstree.cpp" line="758"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="694"/>
+        <location filename="resultstree.cpp" line="745"/>
         <source>No editor application configured.
 
 Configure the editor application for Cppcheck in preferences/Applications.</source>
@@ -2278,7 +2486,7 @@ Configure the editor application for Cppcheck in preferences/Applications.</sour
 Konfigurera program i inställningar/program.</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="708"/>
+        <location filename="resultstree.cpp" line="759"/>
         <source>No default editor application selected.
 
 Please select the default editor application in preferences/Applications.</source>
@@ -2287,12 +2495,12 @@ Please select the default editor application in preferences/Applications.</sourc
 Vänligen välj standard editor i inställningar/Program.</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="737"/>
+        <location filename="resultstree.cpp" line="779"/>
         <source>Could not find the file!</source>
         <translation>Kunde inte hitta filen!</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="783"/>
+        <location filename="resultstree.cpp" line="822"/>
         <source>Could not start %1
 
 Please check the application path and parameters are correct.</source>
@@ -2301,60 +2509,49 @@ Please check the application path and parameters are correct.</source>
 Kontrollera att sökvägen och parametrarna är korrekta.</translation>
     </message>
     <message>
-        <source>Could not find file:
-%1
-Please select the directory where file is located.</source>
-        <translation type="obsolete">Kunde inte hitta filen:
-%1
-Välj mappen där filen finns.</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="805"/>
+        <location filename="resultstree.cpp" line="844"/>
         <source>Select Directory</source>
         <translation>Välj mapp</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Id</source>
-        <translation>Id</translation>
+        <translation type="vanished">Id</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Inconclusive</source>
-        <translation>Inconclusive</translation>
+        <translation type="vanished">Inconclusive</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Since date</source>
-        <translation>Sedan datum</translation>
+        <translation type="vanished">Sedan datum</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="294"/>
+        <location filename="resultstree.cpp" line="355"/>
         <source>style</source>
         <translation>stil</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="297"/>
+        <location filename="resultstree.cpp" line="358"/>
         <source>error</source>
         <translation>fel</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="300"/>
+        <location filename="resultstree.cpp" line="361"/>
         <source>warning</source>
         <translation>varning</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="303"/>
+        <location filename="resultstree.cpp" line="364"/>
         <source>performance</source>
         <translation>prestanda</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="306"/>
+        <location filename="resultstree.cpp" line="367"/>
         <source>portability</source>
         <translation>portabilitet</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="309"/>
+        <location filename="resultstree.cpp" line="370"/>
         <source>information</source>
         <translation>information</translation>
     </message>
@@ -2362,90 +2559,102 @@ Välj mappen där filen finns.</translation>
 <context>
     <name>ResultsView</name>
     <message>
-        <location filename="resultsview.cpp" line="201"/>
+        <location filename="resultsview.cpp" line="255"/>
         <source>Print Report</source>
         <translation>Skriv ut rapport</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="220"/>
+        <location filename="resultsview.cpp" line="274"/>
         <source>No errors found, nothing to print.</source>
         <translation>Inga fel hittades, inget att skriva ut.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="264"/>
+        <location filename="resultsview.cpp" line="326"/>
         <source>%p% (%1 of %2 files checked)</source>
         <translation>%p% (%1 av %2 filer analyserade)</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="277"/>
-        <location filename="resultsview.cpp" line="288"/>
+        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="361"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="278"/>
+        <location filename="resultsview.cpp" line="351"/>
         <source>No errors found.</source>
         <translation>Inga fel hittades.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="285"/>
+        <location filename="resultsview.cpp" line="358"/>
         <source>Errors were found, but they are configured to be hidden.
 To toggle what kind of errors are shown, open view menu.</source>
         <translation>Fel hittades, men de visas ej.
 För att ställa in vilka fel som skall visas använd visa menyn.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="331"/>
-        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="421"/>
         <source>Failed to read the report.</source>
         <translation>Misslyckades att läsa rapporten.</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="338"/>
+        <location filename="resultsview.cpp" line="409"/>
         <source>XML format version 1 is no longer supported.</source>
         <translation>XML format version 1 stöds ej längre.</translation>
     </message>
     <message>
-        <source>Summary</source>
-        <translation type="obsolete">Sammanfattning</translation>
-    </message>
-    <message>
-        <source>Message</source>
-        <translation type="obsolete">Meddelande</translation>
-    </message>
-    <message>
-        <location filename="resultsview.cpp" line="399"/>
+        <location filename="resultsview.cpp" line="460"/>
         <source>First included by</source>
         <translation>Först inkluderad av</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="465"/>
         <source>Id</source>
         <translation>Id</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="471"/>
+        <location filename="resultsview.cpp" line="539"/>
         <source>Clear Log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="472"/>
+        <location filename="resultsview.cpp" line="540"/>
         <source>Copy this Log entry</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="473"/>
+        <location filename="resultsview.cpp" line="541"/>
         <source>Copy complete Log</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="159"/>
-        <source>No errors found, nothing to save.</source>
-        <translation>Inga fel hittades, ingenting att spara.</translation>
+        <location filename="resultsview.cpp" line="549"/>
+        <source>Analysis was stopped</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="563"/>
+        <source>There was a critical error with id &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="565"/>
+        <source>when checking %1</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="567"/>
+        <source>when checking a file</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="183"/>
-        <location filename="resultsview.cpp" line="191"/>
+        <location filename="resultsview.cpp" line="568"/>
+        <source>Analysis was aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="237"/>
+        <location filename="resultsview.cpp" line="245"/>
         <source>Failed to save the report.</source>
         <translation>Misslyckades med att spara rapporten.</translation>
     </message>
@@ -2455,12 +2664,17 @@ För att ställa in vilka fel som skall visas använd visa menyn.</translation>
         <translation>Resultat</translation>
     </message>
     <message>
-        <location filename="resultsview.ui" line="82"/>
+        <location filename="resultsview.ui" line="60"/>
+        <source>Critical errors</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.ui" line="92"/>
         <source>Analysis Log</source>
         <translation>Analys Log</translation>
     </message>
     <message>
-        <location filename="resultsview.ui" line="104"/>
+        <location filename="resultsview.ui" line="114"/>
         <source>Warning Details</source>
         <translation>Varningsdetaljer</translation>
     </message>
@@ -2506,11 +2720,7 @@ För att ställa in vilka fel som skall visas använd visa menyn.</translation>
         <translation>Allmänt</translation>
     </message>
     <message>
-        <source>Include paths:</source>
-        <translation type="obsolete">Include sökvägar:</translation>
-    </message>
-    <message>
-        <location filename="settings.ui" line="195"/>
+        <location filename="settings.ui" line="196"/>
         <source>Add...</source>
         <translation>Lägg till...</translation>
     </message>
@@ -2520,500 +2730,507 @@ För att ställa in vilka fel som skall visas använd visa menyn.</translation>
         <translation>Antal trådar:</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="85"/>
         <source>Ideal count:</source>
-        <translation>Optimalt värde:</translation>
+        <translation type="vanished">Optimalt värde:</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="114"/>
+        <location filename="settings.ui" line="108"/>
         <source>Force checking all #ifdef configurations</source>
         <oldsource>Check all #ifdef configurations</oldsource>
         <translation>Kontrollera alla #ifdef konfigurationer</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="121"/>
+        <location filename="settings.ui" line="115"/>
         <source>Show full path of files</source>
         <translation>Visa den fulla sökvägen för filer</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="128"/>
+        <location filename="settings.ui" line="122"/>
         <source>Show &quot;No errors found&quot; message when no errors found</source>
         <translation>Visa &quot;Inga fel hittades&quot; meddelande när inga fel hittas</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="135"/>
+        <location filename="settings.ui" line="129"/>
         <source>Display error Id in column &quot;Id&quot;</source>
         <translation>Visa meddelande id i kolumn &quot;Id&quot;</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="142"/>
+        <location filename="settings.ui" line="136"/>
         <source>Enable inline suppressions</source>
         <translation>Använd inline suppressions</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="149"/>
+        <location filename="settings.ui" line="143"/>
         <source>Check for inconclusive errors also</source>
         <translation>Kör inconclusive analys</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="156"/>
+        <location filename="settings.ui" line="150"/>
         <source>Show statistics on check completion</source>
         <translation>Visa statistik när analys är klar</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="176"/>
+        <location filename="settings.ui" line="157"/>
+        <source>Check for updates</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="177"/>
         <source>Show internal warnings in log</source>
         <translation>Visa interna fel i loggen</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="287"/>
+        <location filename="settings.ui" line="288"/>
         <source>Addons</source>
         <translation>Addons</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="293"/>
+        <location filename="settings.ui" line="294"/>
         <source>Python binary (leave this empty to use python in the PATH)</source>
         <translation>Python binär fil (lämna tom för att använda python i PATH)</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="302"/>
-        <location filename="settings.ui" line="334"/>
-        <location filename="settings.ui" line="379"/>
+        <location filename="settings.ui" line="305"/>
+        <location filename="settings.ui" line="346"/>
+        <location filename="settings.ui" line="391"/>
         <source>...</source>
         <translation>...</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="312"/>
-        <source>Misra addon</source>
+        <location filename="settings.ui" line="324"/>
+        <source>MISRA addon</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="320"/>
-        <source>Misra rule texts file</source>
+        <location filename="settings.ui" line="332"/>
+        <source>MISRA rule texts file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="327"/>
+        <location filename="settings.ui" line="339"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="360"/>
+        <location filename="settings.ui" line="372"/>
         <source>Clang</source>
         <translation>Clang</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="366"/>
+        <location filename="settings.ui" line="378"/>
         <source>Clang path (leave empty to use system PATH)</source>
         <translation>Clang sökväg (lämna tom för att använda PATH)</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="389"/>
+        <location filename="settings.ui" line="401"/>
         <source>Visual Studio headers</source>
         <translation>Visual Studio headers</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="395"/>
+        <location filename="settings.ui" line="407"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Paths to Visual Studio headers, separated by semicolon &apos;;&apos;.&lt;/p&gt;&lt;p&gt;You can open a Visual Studio command prompt, write &amp;quot;SET INCLUDE&amp;quot;. Then copy/paste the paths.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
         <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Sökvägar till Visual Studio headers, separerade med semikolon &apos;;&apos;.&lt;/p&gt;&lt;p&gt;Du kan öppna en Visual Studio command prompt, och skriva &amp;quot;SET INCLUDE&amp;quot;. Sedan kopiera och klistra in sökvägarna.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="425"/>
+        <location filename="settings.ui" line="437"/>
         <source>Code Editor</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="431"/>
+        <location filename="settings.ui" line="443"/>
         <source>Code Editor Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="437"/>
+        <location filename="settings.ui" line="449"/>
         <source>System Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="444"/>
+        <location filename="settings.ui" line="456"/>
         <source>Default Light Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="451"/>
+        <location filename="settings.ui" line="463"/>
         <source>Default Dark Style</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="460"/>
+        <location filename="settings.ui" line="472"/>
         <source>Custom</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Paths</source>
-        <translation type="obsolete">Sökvägar</translation>
-    </message>
-    <message>
-        <source>Edit</source>
-        <translation type="obsolete">Redigera</translation>
-    </message>
-    <message>
-        <location filename="settings.ui" line="209"/>
+        <location filename="settings.ui" line="210"/>
         <source>Remove</source>
         <translation>Ta bort</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="184"/>
+        <location filename="settings.ui" line="79"/>
+        <source>Max count:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="185"/>
         <source>Applications</source>
         <translation>Program</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="202"/>
-        <location filename="settings.ui" line="467"/>
+        <location filename="settings.ui" line="203"/>
+        <location filename="settings.ui" line="479"/>
         <source>Edit...</source>
         <translation>Redigera...</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="216"/>
+        <location filename="settings.ui" line="217"/>
         <source>Set as default</source>
         <translation>Sätt förvald</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="239"/>
+        <location filename="settings.ui" line="240"/>
         <source>Reports</source>
         <translation>Rapporter</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="245"/>
+        <location filename="settings.ui" line="246"/>
         <source>Save all errors when creating report</source>
         <translation>Spara alla fel</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="252"/>
+        <location filename="settings.ui" line="253"/>
         <source>Save full path to files in reports</source>
         <translation>Spara fulla sökvägar</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="273"/>
+        <location filename="settings.ui" line="274"/>
         <source>Language</source>
         <translation>Språk</translation>
     </message>
-    <message>
-        <source>Advanced</source>
-        <translation type="obsolete">Avancerade</translation>
-    </message>
-    <message>
-        <source>&amp;Show inconclusive errors</source>
-        <translation type="obsolete">Visa inconclusive meddelanden</translation>
-    </message>
-    <message>
-        <source>S&amp;how internal warnings in log</source>
-        <translation type="obsolete">Visa interna fel i loggen</translation>
-    </message>
 </context>
 <context>
     <name>SettingsDialog</name>
     <message>
-        <location filename="settingsdialog.cpp" line="100"/>
         <source>N/A</source>
-        <translation>Ej tillgängligt</translation>
+        <translation type="vanished">Ej tillgängligt</translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="232"/>
+        <source>The executable file &quot;%1&quot; is not available</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="200"/>
+        <location filename="settingsdialog.cpp" line="243"/>
         <source>Add a new application</source>
         <translation>Lägg till program</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="233"/>
+        <location filename="settingsdialog.cpp" line="273"/>
         <source>Modify an application</source>
         <translation>Ändra program</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="238"/>
+        <location filename="settingsdialog.cpp" line="278"/>
         <source> [Default]</source>
         <translation> [Vald]</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="263"/>
+        <location filename="settingsdialog.cpp" line="303"/>
         <source>[Default]</source>
         <translation>[Förvald]</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="318"/>
+        <location filename="settingsdialog.cpp" line="358"/>
         <source>Select python binary</source>
         <translation>Välj python binär</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="325"/>
+        <location filename="settingsdialog.cpp" line="365"/>
         <source>Select MISRA File</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="356"/>
+        <location filename="settingsdialog.cpp" line="396"/>
         <source>Select clang path</source>
         <translation>Välj Clang sökväg</translation>
     </message>
-    <message>
-        <source>Select include directory</source>
-        <translation type="obsolete">Välj include mapp</translation>
-    </message>
 </context>
 <context>
     <name>StatsDialog</name>
     <message>
-        <location filename="stats.ui" line="14"/>
-        <location filename="stats.ui" line="248"/>
-        <location filename="statsdialog.cpp" line="137"/>
-        <location filename="statsdialog.cpp" line="184"/>
+        <location filename="statsdialog.ui" line="14"/>
+        <location filename="statsdialog.ui" line="248"/>
+        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="230"/>
         <source>Statistics</source>
         <translation>Statistik</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="27"/>
-        <location filename="statsdialog.cpp" line="175"/>
+        <location filename="statsdialog.ui" line="27"/>
+        <location filename="statsdialog.cpp" line="221"/>
         <source>Project</source>
         <translation>Projekt</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="33"/>
+        <location filename="statsdialog.ui" line="33"/>
         <source>Project:</source>
         <translation>Projekt:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="53"/>
+        <location filename="statsdialog.ui" line="53"/>
         <source>Paths:</source>
         <translation>Sökvägar:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="85"/>
+        <location filename="statsdialog.ui" line="85"/>
         <source>Include paths:</source>
         <translation>Include sökvägar:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="108"/>
+        <location filename="statsdialog.ui" line="108"/>
         <source>Defines:</source>
         <translation>Defines:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="131"/>
+        <location filename="statsdialog.ui" line="131"/>
         <source>Undefines:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="165"/>
-        <location filename="statsdialog.cpp" line="180"/>
+        <location filename="statsdialog.ui" line="165"/>
+        <location filename="statsdialog.cpp" line="226"/>
         <source>Previous Scan</source>
         <translation>Föregående analys</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="171"/>
+        <location filename="statsdialog.ui" line="171"/>
         <source>Path Selected:</source>
         <translation>Vald sökväg:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="181"/>
+        <location filename="statsdialog.ui" line="181"/>
         <source>Number of Files Scanned:</source>
         <translation>Antal analyserade filer:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="201"/>
+        <location filename="statsdialog.ui" line="201"/>
         <source>Scan Duration:</source>
         <translation>Analys tid:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="256"/>
+        <location filename="statsdialog.ui" line="254"/>
         <source>Errors:</source>
         <translation>Fel:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="274"/>
+        <location filename="statsdialog.ui" line="271"/>
         <source>Warnings:</source>
         <translation>Varningar:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="292"/>
+        <location filename="statsdialog.ui" line="288"/>
         <source>Stylistic warnings:</source>
         <translation>Stil varningar:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="310"/>
+        <location filename="statsdialog.ui" line="305"/>
         <source>Portability warnings:</source>
         <translation>Portabilitets varningar:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="328"/>
+        <location filename="statsdialog.ui" line="322"/>
         <source>Performance issues:</source>
         <translation>Prestanda varningar:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="346"/>
+        <location filename="statsdialog.ui" line="339"/>
         <source>Information messages:</source>
         <translation>Informations meddelanden:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="363"/>
+        <location filename="statsdialog.ui" line="356"/>
+        <source>Active checkers:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="374"/>
+        <source>Checkers</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="399"/>
         <source>History</source>
         <translation>Historik</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="369"/>
+        <location filename="statsdialog.ui" line="405"/>
         <source>File:</source>
         <translation>Fil:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="407"/>
+        <location filename="statsdialog.ui" line="443"/>
         <source>Copy to Clipboard</source>
         <translation>Kopiera</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="414"/>
+        <location filename="statsdialog.ui" line="450"/>
         <source>Pdf Export</source>
         <translation>Pdf Export</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="113"/>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>1 day</source>
         <translation>1 dag</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="113"/>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>%1 days</source>
         <translation>%1 dagar</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="115"/>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>1 hour</source>
         <translation>1 timme</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="115"/>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>%1 hours</source>
         <translation>%1 timmar</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="117"/>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>1 minute</source>
         <translation>1 minut</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="117"/>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>%1 minutes</source>
         <translation>%1 minuter</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="119"/>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>1 second</source>
         <translation>1 sekund</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="119"/>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>%1 seconds</source>
         <translation>%1 sekunder</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="123"/>
+        <location filename="statsdialog.cpp" line="169"/>
         <source>0.%1 seconds</source>
         <translation>0.%1 sekunder</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="125"/>
+        <location filename="statsdialog.cpp" line="171"/>
         <source> and </source>
         <translation> och </translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="152"/>
+        <location filename="statsdialog.cpp" line="198"/>
         <source>Export PDF</source>
         <translation>Exportera PDF</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="174"/>
+        <location filename="statsdialog.cpp" line="220"/>
         <source>Project Settings</source>
         <translation>Projekt inställningar</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="176"/>
+        <location filename="statsdialog.cpp" line="222"/>
         <source>Paths</source>
         <translation>Sökvägar</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="177"/>
+        <location filename="statsdialog.cpp" line="223"/>
         <source>Include paths</source>
         <translation>Include sökvägar</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="178"/>
+        <location filename="statsdialog.cpp" line="224"/>
         <source>Defines</source>
         <translation>Definitioner</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="179"/>
+        <location filename="statsdialog.cpp" line="225"/>
         <source>Undefines</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="181"/>
+        <location filename="statsdialog.cpp" line="227"/>
         <source>Path selected</source>
         <translation>Vald sökväg</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="182"/>
+        <location filename="statsdialog.cpp" line="228"/>
         <source>Number of files scanned</source>
         <translation>Antal analyserade filer</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="229"/>
         <source>Scan duration</source>
         <translation>Tid</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="139"/>
         <location filename="statsdialog.cpp" line="185"/>
+        <location filename="statsdialog.cpp" line="231"/>
         <source>Errors</source>
         <translation>Fel</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="65"/>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>File: </source>
         <translation>Fil:</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="65"/>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>No cppcheck build dir</source>
         <translation>Ingen Cppcheck build dir</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="141"/>
-        <location filename="statsdialog.cpp" line="186"/>
+        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="232"/>
         <source>Warnings</source>
         <translation>Varningar</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="143"/>
-        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="233"/>
         <source>Style warnings</source>
         <translation>Stil varningar</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="145"/>
-        <location filename="statsdialog.cpp" line="188"/>
+        <location filename="statsdialog.cpp" line="191"/>
+        <location filename="statsdialog.cpp" line="234"/>
         <source>Portability warnings</source>
         <translation>Portabilitetsvarningar</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="147"/>
-        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="193"/>
+        <location filename="statsdialog.cpp" line="235"/>
         <source>Performance warnings</source>
         <translation>Prestanda varningar</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="149"/>
-        <location filename="statsdialog.cpp" line="190"/>
+        <location filename="statsdialog.cpp" line="195"/>
+        <location filename="statsdialog.cpp" line="236"/>
         <source>Information messages</source>
         <translation>Informationsmeddelanden</translation>
     </message>
 </context>
+<context>
+    <name>ThreadDetails</name>
+    <message>
+        <location filename="threaddetails.ui" line="14"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>ThreadResult</name>
     <message>
-        <location filename="threadresult.cpp" line="54"/>
+        <location filename="threadresult.cpp" line="47"/>
         <source>%1 of %2 files checked</source>
         <translation>%1 av %2 filer analyserade</translation>
     </message>
@@ -3021,7 +3238,7 @@ För att ställa in vilka fel som skall visas använd visa menyn.</translation>
 <context>
     <name>TranslationHandler</name>
     <message>
-        <location filename="translationhandler.cpp" line="145"/>
+        <location filename="translationhandler.cpp" line="130"/>
         <source>Failed to change the user interface language:
 
 %1
@@ -3034,7 +3251,7 @@ The user interface language has been reset to English. Open the Preferences-dial
 Språket har nollställts till Engelska. Öppna Preferences och välj något av de tillgängliga språken.</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="151"/>
+        <location filename="translationhandler.cpp" line="136"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
@@ -3042,7 +3259,7 @@ Språket har nollställts till Engelska. Öppna Preferences och välj något av
 <context>
     <name>TxtReport</name>
     <message>
-        <location filename="txtreport.cpp" line="73"/>
+        <location filename="txtreport.cpp" line="74"/>
         <source>inconclusive</source>
         <translation>inconclusive</translation>
     </message>
@@ -3050,12 +3267,12 @@ Språket har nollställts till Engelska. Öppna Preferences och välj något av
 <context>
     <name>toFilterString</name>
     <message>
-        <location filename="common.cpp" line="52"/>
+        <location filename="common.cpp" line="58"/>
         <source>All supported files (%1)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="common.cpp" line="57"/>
+        <location filename="common.cpp" line="63"/>
         <source>All files (%1)</source>
         <translation type="unfinished"></translation>
     </message>
diff --git a/gui/cppcheck_zh_CN.ts b/gui/cppcheck_zh_CN.ts
index b072c12cc0a..02477e72e81 100644
--- a/gui/cppcheck_zh_CN.ts
+++ b/gui/cppcheck_zh_CN.ts
@@ -20,9 +20,9 @@
     </message>
     <message>
         <location filename="about.ui" line="81"/>
-        <source>Copyright © 2007-2019 Cppcheck team.</source>
-        <oldsource>Copyright © 2007-2018 Cppcheck team.</oldsource>
-        <translation type="unfinished">版权所有 © 2007-2018 Daniel Marjamäki 与 Cppcheck 团队。</translation>
+        <source>Copyright © 2007-%1 Cppcheck team.</source>
+        <oldsource>Copyright © 2007-2021 Cppcheck team.</oldsource>
+        <translation>版权所有 © 2007-%1 Cppcheck 团队。</translation>
     </message>
     <message>
         <location filename="about.ui" line="91"/>
@@ -37,24 +37,20 @@ of the GNU General Public License version 3</source>
     </message>
     <message>
         <location filename="about.ui" line="115"/>
-        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
-&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul&gt;
-&lt;li&gt;tinyxml2&lt;/li&gt;
-&lt;li&gt;picojson&lt;/li&gt;
-&lt;li&gt;pcre&lt;/li&gt;
-&lt;li&gt;qt&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PCRE&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PicoJSON&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;TinyXML2&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Boost&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <oldsource>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;pcre&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;picojson&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;tinyxml2&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</oldsource>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>ApplicationDialog</name>
     <message>
-        <location filename="application.ui" line="23"/>
+        <location filename="applicationdialog.ui" line="23"/>
         <source>Add an application</source>
         <translation>添加应用程序</translation>
     </message>
     <message>
-        <location filename="application.ui" line="41"/>
+        <location filename="applicationdialog.ui" line="41"/>
         <source>Here you can add an application that can open error files. Specify a name for the application, the application executable and command line parameters for the application.
 
 The following texts in parameters are replaced with appropriate values when application is executed:
@@ -79,81 +75,173 @@ Parameters: -l(line) (file)</source>
 参数: -l(line) (file)</translation>
     </message>
     <message>
-        <location filename="application.ui" line="76"/>
+        <location filename="applicationdialog.ui" line="76"/>
         <source>&amp;Name:</source>
         <translation>名称(&amp;N):</translation>
     </message>
     <message>
-        <location filename="application.ui" line="86"/>
+        <location filename="applicationdialog.ui" line="86"/>
         <source>&amp;Executable:</source>
         <translation>可执行文件(&amp;E):</translation>
     </message>
     <message>
-        <location filename="application.ui" line="96"/>
+        <location filename="applicationdialog.ui" line="96"/>
         <source>&amp;Parameters:</source>
         <translation>参数(&amp;P):</translation>
     </message>
     <message>
-        <location filename="application.ui" line="138"/>
+        <location filename="applicationdialog.ui" line="138"/>
         <source>Browse</source>
         <translation>浏览</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="59"/>
+        <location filename="applicationdialog.cpp" line="65"/>
         <source>Executable files (*.exe);;All files(*.*)</source>
         <translation>可执行文件(*.exe);;所有文件(*.*)</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="62"/>
+        <location filename="applicationdialog.cpp" line="68"/>
         <source>Select viewer application</source>
         <translation>选择查看应用程序</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="77"/>
+        <location filename="applicationdialog.cpp" line="83"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="applicationdialog.cpp" line="78"/>
+        <location filename="applicationdialog.cpp" line="84"/>
         <source>You must specify a name, a path and optionally parameters for the application!</source>
         <translation>你必须为应用程序指定名称、路径以及可选参数！</translation>
     </message>
 </context>
+<context>
+    <name>ComplianceReportDialog</name>
+    <message>
+        <location filename="compliancereportdialog.ui" line="14"/>
+        <source>Compliance Report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="29"/>
+        <source>Project name</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="22"/>
+        <source>Project version</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="42"/>
+        <source>Coding Standard</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="50"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="55"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="60"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="70"/>
+        <source>List of files with md5 checksums</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="133"/>
+        <source>Compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="135"/>
+        <source>HTML files (*.html)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="176"/>
+        <location filename="compliancereportdialog.cpp" line="239"/>
+        <source>Save compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="177"/>
+        <source>Failed to import &apos;%1&apos; (%2), can not show files in compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>FileViewDialog</name>
     <message>
-        <location filename="fileviewdialog.cpp" line="42"/>
+        <location filename="fileviewdialog.cpp" line="53"/>
         <source>Could not find the file: %1</source>
         <translation>无法找到文件: %1</translation>
     </message>
     <message>
-        <location filename="fileviewdialog.cpp" line="46"/>
-        <location filename="fileviewdialog.cpp" line="60"/>
+        <location filename="fileviewdialog.cpp" line="57"/>
+        <location filename="fileviewdialog.cpp" line="71"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="fileviewdialog.cpp" line="56"/>
+        <location filename="fileviewdialog.cpp" line="67"/>
         <source>Could not read the file: %1</source>
         <translation>无法读取文件: %1</translation>
     </message>
 </context>
+<context>
+    <name>HelpDialog</name>
+    <message>
+        <location filename="helpdialog.ui" line="14"/>
+        <source>Cppcheck GUI help</source>
+        <translation>Cppcheck GUI 帮助</translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="34"/>
+        <source>Contents</source>
+        <translation>内容</translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="44"/>
+        <source>Index</source>
+        <translation>索引</translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="84"/>
+        <source>Helpfile &apos;%1&apos; was not found</source>
+        <translation>帮助文件 &apos;%1&apos; 未找到</translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="86"/>
+        <source>Cppcheck</source>
+        <translation>Cppcheck</translation>
+    </message>
+</context>
 <context>
     <name>LibraryAddFunctionDialog</name>
     <message>
         <location filename="libraryaddfunctiondialog.ui" line="23"/>
         <source>Add function</source>
-        <translation type="unfinished"></translation>
+        <translation>添加函数</translation>
     </message>
     <message>
         <location filename="libraryaddfunctiondialog.ui" line="34"/>
         <source>Function name(s)</source>
-        <translation type="unfinished"></translation>
+        <translation>函数名</translation>
     </message>
     <message>
         <location filename="libraryaddfunctiondialog.ui" line="44"/>
         <source>Number of arguments</source>
-        <translation type="unfinished"></translation>
+        <translation>参数个数</translation>
     </message>
 </context>
 <context>
@@ -161,127 +249,127 @@ Parameters: -l(line) (file)</source>
     <message>
         <location filename="librarydialog.ui" line="14"/>
         <source>Library Editor</source>
-        <translation type="unfinished"></translation>
+        <translation>库编辑器</translation>
     </message>
     <message>
         <location filename="librarydialog.ui" line="22"/>
         <source>Open</source>
-        <translation type="unfinished"></translation>
+        <translation>打开</translation>
     </message>
     <message>
         <location filename="librarydialog.ui" line="29"/>
         <source>Save</source>
-        <translation type="unfinished"></translation>
+        <translation>保存</translation>
     </message>
     <message>
         <location filename="librarydialog.ui" line="36"/>
         <source>Save as</source>
-        <translation type="unfinished"></translation>
+        <translation>另存为</translation>
     </message>
     <message>
         <location filename="librarydialog.ui" line="62"/>
         <source>Functions</source>
-        <translation type="unfinished"></translation>
+        <translation>函数</translation>
     </message>
     <message>
         <location filename="librarydialog.ui" line="71"/>
         <source>Sort</source>
-        <translation type="unfinished"></translation>
+        <translation>排序</translation>
     </message>
     <message>
         <location filename="librarydialog.ui" line="111"/>
         <source>Add</source>
-        <translation type="unfinished"></translation>
+        <translation>添加</translation>
     </message>
     <message>
         <location filename="librarydialog.ui" line="131"/>
         <source>Filter:</source>
-        <translation type="unfinished"></translation>
+        <translation>过滤：</translation>
     </message>
     <message>
         <location filename="librarydialog.ui" line="164"/>
         <source>Comments</source>
-        <translation type="unfinished"></translation>
+        <translation>注释</translation>
     </message>
     <message>
         <location filename="librarydialog.ui" line="204"/>
         <source>noreturn</source>
-        <translation type="unfinished"></translation>
+        <translation>无返回</translation>
     </message>
     <message>
         <location filename="librarydialog.ui" line="212"/>
         <source>False</source>
-        <translation type="unfinished"></translation>
+        <translation>否</translation>
     </message>
     <message>
         <location filename="librarydialog.ui" line="217"/>
         <source>True</source>
-        <translation type="unfinished"></translation>
+        <translation>是</translation>
     </message>
     <message>
         <location filename="librarydialog.ui" line="222"/>
         <source>Unknown</source>
-        <translation type="unfinished"></translation>
+        <translation>未知</translation>
     </message>
     <message>
         <location filename="librarydialog.ui" line="232"/>
         <source>return value must be used</source>
-        <translation type="unfinished"></translation>
+        <translation>返回值必须被使用</translation>
     </message>
     <message>
         <location filename="librarydialog.ui" line="239"/>
         <source>ignore function in leaks checking</source>
-        <translation type="unfinished"></translation>
+        <translation>在泄漏检查中忽略函数</translation>
     </message>
     <message>
         <location filename="librarydialog.ui" line="246"/>
         <source>Arguments</source>
-        <translation type="unfinished"></translation>
+        <translation>参数</translation>
     </message>
     <message>
         <location filename="librarydialog.ui" line="258"/>
         <source>Edit</source>
-        <translation type="unfinished">编辑</translation>
+        <translation>编辑</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="82"/>
-        <location filename="librarydialog.cpp" line="154"/>
+        <location filename="librarydialog.cpp" line="97"/>
+        <location filename="librarydialog.cpp" line="169"/>
         <source>Library files (*.cfg)</source>
-        <translation type="unfinished"></translation>
+        <translation>库文件 (*.cfg)</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="84"/>
+        <location filename="librarydialog.cpp" line="99"/>
         <source>Open library file</source>
-        <translation type="unfinished"></translation>
+        <translation>打开库文件</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="95"/>
-        <location filename="librarydialog.cpp" line="107"/>
-        <location filename="librarydialog.cpp" line="144"/>
+        <location filename="librarydialog.cpp" line="110"/>
+        <location filename="librarydialog.cpp" line="122"/>
+        <location filename="librarydialog.cpp" line="159"/>
         <source>Cppcheck</source>
-        <translation type="unfinished">Cppcheck</translation>
+        <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="96"/>
+        <location filename="librarydialog.cpp" line="111"/>
         <source>Cannot open file %1.</source>
         <oldsource>Can not open file %1.</oldsource>
-        <translation type="unfinished"></translation>
+        <translation>无法打开文件 %1。</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="108"/>
+        <location filename="librarydialog.cpp" line="123"/>
         <source>Failed to load %1. %2.</source>
-        <translation type="unfinished"></translation>
+        <translation>加载文件 %1 失败。%2。</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="145"/>
+        <location filename="librarydialog.cpp" line="160"/>
         <source>Cannot save file %1.</source>
         <oldsource>Can not save file %1.</oldsource>
-        <translation type="unfinished"></translation>
+        <translation>无法保存文件 %1。</translation>
     </message>
     <message>
-        <location filename="librarydialog.cpp" line="157"/>
+        <location filename="librarydialog.cpp" line="172"/>
         <source>Save the library as</source>
-        <translation type="unfinished"></translation>
+        <translation>库另存为</translation>
     </message>
 </context>
 <context>
@@ -289,7 +377,7 @@ Parameters: -l(line) (file)</source>
     <message>
         <location filename="libraryeditargdialog.ui" line="14"/>
         <source>Edit argument</source>
-        <translation type="unfinished"></translation>
+        <translation>编辑参数</translation>
     </message>
     <message>
         <location filename="libraryeditargdialog.ui" line="20"/>
@@ -299,12 +387,17 @@ Parameters: -l(line) (file)</source>
 &lt;p&gt;Example:&lt;/p&gt;
 &lt;pre&gt;    memcmp(x, y, i == 123);   // last argument should not have a bool value&lt;/pre&gt;
 &lt;/body&gt;&lt;/html&gt;</source>
-        <translation type="unfinished"></translation>
+        <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
+&lt;p&gt;是否允许布尔值？ 例如，来自比较结果或来自 &apos;!&apos; 操作符。&lt;/p&gt;
+&lt;p&gt;通常，如果参数是指针、大小等，则设置此参数。&lt;/p&gt;
+&lt;p&gt;例子：&lt;/p&gt;
+&lt;pre&gt;    memcmp(x, y, i == 123);   // 最后一个参数不应该有bool值&lt;/pre&gt;
+&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
     <message>
         <location filename="libraryeditargdialog.ui" line="28"/>
         <source>Not bool</source>
-        <translation type="unfinished"></translation>
+        <translation>非布尔值</translation>
     </message>
     <message>
         <location filename="libraryeditargdialog.ui" line="35"/>
@@ -314,693 +407,700 @@ Parameters: -l(line) (file)</source>
 &lt;p&gt;Example:&lt;/p&gt;
 &lt;pre&gt;    strcpy(x,y); // neither x or y is allowed to be null.&lt;/pre&gt;
 &lt;/body&gt;&lt;/html&gt;</source>
-        <translation type="unfinished"></translation>
+        <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
+&lt;p&gt;是否允许空参数值?&lt;/p&gt;
+&lt;p&gt;通常这应该用于任何不允许空指针的参数。&lt;/p&gt;
+&lt;p&gt;例子：&lt;/p&gt;
+&lt;pre&gt;    strcpy(x,y); // 无论 x 或 y 都不允许为空。&lt;/pre&gt;
+&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
     <message>
         <location filename="libraryeditargdialog.ui" line="43"/>
         <source>Not null</source>
-        <translation type="unfinished"></translation>
+        <translation>非空</translation>
     </message>
     <message>
         <location filename="libraryeditargdialog.ui" line="50"/>
         <source>Not uninit</source>
-        <translation type="unfinished"></translation>
+        <translation>非未初始化</translation>
     </message>
     <message>
         <location filename="libraryeditargdialog.ui" line="57"/>
         <source>String</source>
-        <translation type="unfinished"></translation>
+        <translation>字符串</translation>
     </message>
     <message>
         <location filename="libraryeditargdialog.ui" line="70"/>
         <source>Format string</source>
-        <translation type="unfinished"></translation>
+        <translation>格式化字符串</translation>
     </message>
     <message>
         <location filename="libraryeditargdialog.ui" line="92"/>
         <source>Min size of buffer</source>
-        <translation type="unfinished"></translation>
+        <translation>最小缓冲区大小</translation>
     </message>
     <message>
         <location filename="libraryeditargdialog.ui" line="101"/>
         <location filename="libraryeditargdialog.ui" line="203"/>
         <source>Type</source>
-        <translation type="unfinished"></translation>
+        <translation>类型</translation>
     </message>
     <message>
         <location filename="libraryeditargdialog.ui" line="109"/>
         <location filename="libraryeditargdialog.ui" line="214"/>
         <source>None</source>
-        <translation type="unfinished"></translation>
+        <translation>无</translation>
     </message>
     <message>
         <location filename="libraryeditargdialog.ui" line="114"/>
         <location filename="libraryeditargdialog.ui" line="219"/>
         <source>argvalue</source>
-        <translation type="unfinished"></translation>
+        <translation>argvalue</translation>
     </message>
     <message>
         <location filename="libraryeditargdialog.ui" line="119"/>
         <location filename="libraryeditargdialog.ui" line="224"/>
         <source>mul</source>
-        <translation type="unfinished"></translation>
+        <translation>mul</translation>
     </message>
     <message>
         <location filename="libraryeditargdialog.ui" line="124"/>
         <location filename="libraryeditargdialog.ui" line="229"/>
         <source>strlen</source>
-        <translation type="unfinished"></translation>
+        <translation>strlen</translation>
     </message>
     <message>
         <location filename="libraryeditargdialog.ui" line="132"/>
         <location filename="libraryeditargdialog.ui" line="237"/>
         <source>Arg</source>
-        <translation type="unfinished"></translation>
+        <translation>参数1</translation>
     </message>
     <message>
         <location filename="libraryeditargdialog.ui" line="159"/>
         <location filename="libraryeditargdialog.ui" line="264"/>
         <source>Arg2</source>
-        <translation type="unfinished"></translation>
+        <translation>参数2</translation>
     </message>
     <message>
         <location filename="libraryeditargdialog.ui" line="194"/>
         <source>and</source>
-        <translation type="unfinished"></translation>
+        <translation>并且</translation>
     </message>
     <message>
         <location filename="libraryeditargdialog.ui" line="310"/>
         <source>Valid values</source>
-        <translation type="unfinished"></translation>
-    </message>
-</context>
-<context>
-    <name>LogView</name>
-    <message>
-        <source>Checking Log</source>
-        <translation type="obsolete">正在检查记录</translation>
-    </message>
-    <message>
-        <source>Clear</source>
-        <translation type="obsolete">清空</translation>
-    </message>
-    <message>
-        <source>Save Log</source>
-        <translation type="obsolete">保存记录</translation>
-    </message>
-    <message>
-        <source>Text files (*.txt *.log);;All files (*.*)</source>
-        <translation type="obsolete">文本文件(*.txt *.log);;所有文件(*.*)</translation>
-    </message>
-    <message>
-        <source>Cppcheck</source>
-        <translation type="obsolete">Cppcheck</translation>
-    </message>
-    <message>
-        <source>Could not open file for writing: &quot;%1&quot;</source>
-        <translation type="obsolete">无法打开并写入文件: “%1”</translation>
+        <translation>有效值</translation>
     </message>
 </context>
 <context>
     <name>MainWindow</name>
     <message>
         <location filename="mainwindow.ui" line="26"/>
-        <location filename="mainwindow.ui" line="595"/>
-        <location filename="mainwindow.cpp" line="328"/>
-        <location filename="mainwindow.cpp" line="480"/>
-        <location filename="mainwindow.cpp" line="553"/>
-        <location filename="mainwindow.cpp" line="658"/>
-        <location filename="mainwindow.cpp" line="680"/>
-        <location filename="mainwindow.cpp" line="1113"/>
-        <location filename="mainwindow.cpp" line="1238"/>
-        <location filename="mainwindow.cpp" line="1359"/>
-        <location filename="mainwindow.cpp" line="1499"/>
-        <location filename="mainwindow.cpp" line="1522"/>
-        <location filename="mainwindow.cpp" line="1593"/>
-        <location filename="mainwindow.cpp" line="1667"/>
+        <location filename="mainwindow.ui" line="688"/>
+        <location filename="mainwindow.cpp" line="466"/>
+        <location filename="mainwindow.cpp" line="670"/>
+        <location filename="mainwindow.cpp" line="755"/>
+        <location filename="mainwindow.cpp" line="860"/>
+        <location filename="mainwindow.cpp" line="882"/>
+        <location filename="mainwindow.cpp" line="1467"/>
+        <location filename="mainwindow.cpp" line="1596"/>
+        <location filename="mainwindow.cpp" line="1937"/>
+        <location filename="mainwindow.cpp" line="1945"/>
+        <location filename="mainwindow.cpp" line="1999"/>
+        <location filename="mainwindow.cpp" line="2008"/>
+        <location filename="mainwindow.cpp" line="2080"/>
+        <location filename="mainwindow.cpp" line="2168"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="70"/>
+        <location filename="mainwindow.ui" line="132"/>
         <source>&amp;File</source>
         <translation>文件(&amp;F)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="89"/>
+        <location filename="mainwindow.ui" line="152"/>
         <source>&amp;View</source>
         <translation>查看(&amp;V)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="93"/>
+        <location filename="mainwindow.ui" line="156"/>
         <source>&amp;Toolbars</source>
         <translation>工具栏(&amp;T)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="121"/>
+        <location filename="mainwindow.ui" line="199"/>
         <source>&amp;Help</source>
         <translation>帮助(&amp;H)</translation>
     </message>
     <message>
-        <source>&amp;Check</source>
-        <translation type="obsolete">检查(&amp;C)</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="135"/>
+        <location filename="mainwindow.ui" line="214"/>
         <source>C++ standard</source>
-        <translation type="unfinished"></translation>
+        <translation>C++ 标准</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="145"/>
+        <location filename="mainwindow.ui" line="226"/>
         <source>&amp;C standard</source>
         <oldsource>C standard</oldsource>
-        <translation type="unfinished"></translation>
+        <translation>&amp;C 标准</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="170"/>
+        <location filename="mainwindow.ui" line="254"/>
         <source>&amp;Edit</source>
         <translation>编辑(&amp;E)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="183"/>
+        <location filename="mainwindow.ui" line="267"/>
         <source>Standard</source>
         <translation>标准</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="201"/>
+        <location filename="mainwindow.ui" line="285"/>
         <source>Categories</source>
         <translation>分类</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="231"/>
+        <location filename="mainwindow.ui" line="315"/>
         <source>&amp;License...</source>
         <translation>许可证(&amp;L)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="236"/>
+        <location filename="mainwindow.ui" line="320"/>
         <source>A&amp;uthors...</source>
         <translation>作者(&amp;U)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="245"/>
+        <location filename="mainwindow.ui" line="329"/>
         <source>&amp;About...</source>
         <translation>关于(&amp;A)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="250"/>
+        <location filename="mainwindow.ui" line="334"/>
         <source>&amp;Files...</source>
         <translation>文件(&amp;F)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="253"/>
-        <location filename="mainwindow.ui" line="256"/>
+        <location filename="mainwindow.ui" line="337"/>
+        <location filename="mainwindow.ui" line="340"/>
         <source>Analyze files</source>
         <oldsource>Check files</oldsource>
-        <translation type="unfinished">检查文件</translation>
+        <translation>分析文件</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="259"/>
+        <location filename="mainwindow.ui" line="343"/>
         <source>Ctrl+F</source>
         <translation>Ctrl+F</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="268"/>
+        <location filename="mainwindow.ui" line="352"/>
         <source>&amp;Directory...</source>
         <translation>目录(&amp;D)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="271"/>
-        <location filename="mainwindow.ui" line="274"/>
+        <location filename="mainwindow.ui" line="355"/>
+        <location filename="mainwindow.ui" line="358"/>
         <source>Analyze directory</source>
         <oldsource>Check directory</oldsource>
-        <translation type="unfinished">检查目录</translation>
+        <translation>分析目录</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="277"/>
+        <location filename="mainwindow.ui" line="361"/>
         <source>Ctrl+D</source>
         <translation>Ctrl+D</translation>
     </message>
     <message>
-        <source>&amp;Recheck files</source>
-        <translation type="obsolete">重新检查文件(&amp;R)</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="289"/>
+        <location filename="mainwindow.ui" line="373"/>
         <source>Ctrl+R</source>
         <translation>Ctrl+R</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="307"/>
+        <location filename="mainwindow.ui" line="391"/>
         <source>&amp;Stop</source>
         <translation>停止(&amp;S)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="310"/>
-        <location filename="mainwindow.ui" line="313"/>
+        <location filename="mainwindow.ui" line="394"/>
+        <location filename="mainwindow.ui" line="397"/>
         <source>Stop analysis</source>
         <oldsource>Stop checking</oldsource>
-        <translation type="unfinished">停止检查</translation>
+        <translation>停止分析</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="316"/>
+        <location filename="mainwindow.ui" line="400"/>
         <source>Esc</source>
         <translation>Esc</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="325"/>
+        <location filename="mainwindow.ui" line="409"/>
         <source>&amp;Save results to file...</source>
         <translation>保存结果到文件(&amp;S)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="328"/>
+        <location filename="mainwindow.ui" line="412"/>
         <source>Ctrl+S</source>
         <translation>Ctrl+S</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="333"/>
+        <location filename="mainwindow.ui" line="417"/>
         <source>&amp;Quit</source>
         <translation>退出(&amp;Q)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="342"/>
+        <location filename="mainwindow.ui" line="429"/>
         <source>&amp;Clear results</source>
         <translation>清空结果(&amp;C)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="351"/>
+        <location filename="mainwindow.ui" line="438"/>
         <source>&amp;Preferences</source>
         <translation>首选项(&amp;P)</translation>
     </message>
     <message>
-        <source>Style warnings</source>
-        <translation type="obsolete">风格警告</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="366"/>
-        <location filename="mainwindow.ui" line="369"/>
+        <location filename="mainwindow.ui" line="453"/>
+        <location filename="mainwindow.ui" line="456"/>
         <source>Show style warnings</source>
         <translation>显示风格警告</translation>
     </message>
     <message>
-        <source>Errors</source>
-        <translation type="obsolete">错误</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="384"/>
-        <location filename="mainwindow.ui" line="387"/>
+        <location filename="mainwindow.ui" line="471"/>
+        <location filename="mainwindow.ui" line="474"/>
+        <location filename="mainwindow.cpp" line="2394"/>
         <source>Show errors</source>
         <translation>显示错误</translation>
     </message>
     <message>
-        <source>Show S&amp;cratchpad...</source>
-        <translation type="obsolete">显示便条(&amp;C)...</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="769"/>
-        <location filename="mainwindow.cpp" line="807"/>
+        <location filename="mainwindow.cpp" line="986"/>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Information</source>
         <translation>信息</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="568"/>
+        <location filename="mainwindow.ui" line="661"/>
         <source>Show information messages</source>
         <translation>显示信息消息</translation>
     </message>
     <message>
-        <source>Portability</source>
-        <translation type="obsolete">移植可能性</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="583"/>
+        <location filename="mainwindow.ui" line="676"/>
         <source>Show portability warnings</source>
         <translation>显示可移植性警告</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="598"/>
+        <location filename="mainwindow.ui" line="691"/>
         <source>Show Cppcheck results</source>
-        <translation type="unfinished"></translation>
+        <translation>显示 Cppcheck 结果</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="610"/>
+        <location filename="mainwindow.ui" line="703"/>
         <source>Clang</source>
-        <translation type="unfinished"></translation>
+        <translation>Clang</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="613"/>
+        <location filename="mainwindow.ui" line="706"/>
         <source>Show Clang results</source>
-        <translation type="unfinished"></translation>
+        <translation>显示 Clang 结果</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="621"/>
+        <location filename="mainwindow.ui" line="714"/>
         <source>&amp;Filter</source>
         <translation>滤器(&amp;F)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="624"/>
+        <location filename="mainwindow.ui" line="717"/>
         <source>Filter results</source>
         <translation>过滤结果</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="640"/>
+        <location filename="mainwindow.ui" line="733"/>
         <source>Windows 32-bit ANSI</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="648"/>
+        <location filename="mainwindow.ui" line="741"/>
         <source>Windows 32-bit Unicode</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="656"/>
+        <location filename="mainwindow.ui" line="749"/>
         <source>Unix 32-bit</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="664"/>
+        <location filename="mainwindow.ui" line="757"/>
         <source>Unix 64-bit</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="672"/>
+        <location filename="mainwindow.ui" line="765"/>
         <source>Windows 64-bit</source>
         <translation></translation>
     </message>
     <message>
-        <source>Platforms</source>
-        <translation type="obsolete">平台</translation>
-    </message>
-    <message>
-        <source>C++11</source>
-        <translation type="obsolete">C++11</translation>
-    </message>
-    <message>
-        <source>C99</source>
-        <translation type="obsolete">C99</translation>
-    </message>
-    <message>
-        <source>Posix</source>
-        <translation type="obsolete">Posix</translation>
-    </message>
-    <message>
-        <source>C11</source>
-        <translation type="obsolete">C11</translation>
-    </message>
-    <message>
-        <source>C89</source>
-        <translation type="obsolete">C89</translation>
-    </message>
-    <message>
-        <source>C++03</source>
-        <translation type="obsolete">C++03</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="742"/>
+        <location filename="mainwindow.ui" line="859"/>
         <source>&amp;Print...</source>
-        <translation type="unfinished"></translation>
+        <translation>打印(&amp;P)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="745"/>
+        <location filename="mainwindow.ui" line="862"/>
         <source>Print the Current Report</source>
-        <translation type="unfinished"></translation>
+        <translation>打印当前报告</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="750"/>
+        <location filename="mainwindow.ui" line="867"/>
         <source>Print Pre&amp;view...</source>
-        <translation type="unfinished"></translation>
+        <translation>打印预览(&amp;v)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="753"/>
+        <location filename="mainwindow.ui" line="870"/>
         <source>Open a Print Preview Dialog for the Current Results</source>
-        <translation type="unfinished"></translation>
+        <translation>打开当前结果的打印预览窗口</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="761"/>
+        <location filename="mainwindow.ui" line="878"/>
         <source>Open library editor</source>
-        <translation type="unfinished"></translation>
+        <translation>打开库编辑器</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="489"/>
+        <location filename="mainwindow.ui" line="582"/>
         <source>C&amp;lose Project File</source>
         <translation>关闭项目文件(&amp;L)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="497"/>
+        <location filename="mainwindow.ui" line="590"/>
         <source>&amp;Edit Project File...</source>
         <translation>编辑项目文件(&amp;E)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="509"/>
+        <location filename="mainwindow.ui" line="602"/>
         <source>&amp;Statistics</source>
         <translation>统计(&amp;S)</translation>
     </message>
     <message>
-        <source>Warnings</source>
-        <translation type="obsolete">警告</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="524"/>
-        <location filename="mainwindow.ui" line="527"/>
+        <location filename="mainwindow.ui" line="617"/>
+        <location filename="mainwindow.ui" line="620"/>
+        <location filename="mainwindow.cpp" line="2395"/>
         <source>Show warnings</source>
         <translation>显示警告</translation>
     </message>
     <message>
-        <source>Performance warnings</source>
-        <translation type="obsolete">性能警告</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.ui" line="542"/>
-        <location filename="mainwindow.ui" line="545"/>
+        <location filename="mainwindow.ui" line="635"/>
+        <location filename="mainwindow.ui" line="638"/>
         <source>Show performance warnings</source>
         <translation>显示性能警告</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="553"/>
+        <location filename="mainwindow.ui" line="646"/>
         <source>Show &amp;hidden</source>
         <translation>显示隐藏项(&amp;H)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="392"/>
+        <location filename="mainwindow.ui" line="479"/>
         <source>&amp;Check all</source>
         <translation>全部选中(&amp;C)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="131"/>
-        <source>A&amp;nalyze</source>
+        <location filename="mainwindow.ui" line="84"/>
+        <source>Checking for updates</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="100"/>
+        <source>Hide</source>
+        <translation type="unfinished">隐藏</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="164"/>
+        <location filename="mainwindow.ui" line="980"/>
+        <source>Report</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="220"/>
+        <location filename="mainwindow.ui" line="210"/>
+        <source>A&amp;nalyze</source>
+        <translation>分析(&amp;A)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="304"/>
         <source>Filter</source>
         <translation>滤器</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="286"/>
+        <location filename="mainwindow.ui" line="370"/>
         <source>&amp;Reanalyze modified files</source>
         <oldsource>&amp;Recheck modified files</oldsource>
-        <translation type="unfinished"></translation>
+        <translation>重新分析已修改的文件(&amp;R)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="298"/>
+        <location filename="mainwindow.ui" line="382"/>
         <source>Reanal&amp;yze all files</source>
-        <translation type="unfinished"></translation>
+        <translation>重新分析全部文件(&amp;y)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="363"/>
+        <location filename="mainwindow.ui" line="420"/>
+        <source>Ctrl+Q</source>
+        <translation>Ctrl+Q</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="450"/>
         <source>Style war&amp;nings</source>
-        <translation type="unfinished"></translation>
+        <translation>风格警告(&amp;n)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="381"/>
+        <location filename="mainwindow.ui" line="468"/>
         <source>E&amp;rrors</source>
-        <translation type="unfinished"></translation>
+        <translation>编辑(&amp;r)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="397"/>
+        <location filename="mainwindow.ui" line="484"/>
         <source>&amp;Uncheck all</source>
         <translation>全部取消选中(&amp;U)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="402"/>
+        <location filename="mainwindow.ui" line="489"/>
         <source>Collapse &amp;all</source>
         <translation>全部折叠(&amp;A)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="407"/>
+        <location filename="mainwindow.ui" line="494"/>
         <source>&amp;Expand all</source>
         <translation>全部展开(&amp;E)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="415"/>
+        <location filename="mainwindow.ui" line="502"/>
         <source>&amp;Standard</source>
         <translation>标准(&amp;S)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="418"/>
+        <location filename="mainwindow.ui" line="505"/>
         <source>Standard items</source>
         <translation>标准项</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="423"/>
+        <location filename="mainwindow.ui" line="510"/>
         <source>&amp;Contents</source>
         <translation>内容(&amp;C)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="426"/>
+        <location filename="mainwindow.ui" line="513"/>
         <source>Open the help contents</source>
         <translation>打开帮助内容</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="429"/>
+        <location filename="mainwindow.ui" line="516"/>
         <source>F1</source>
         <translation>F1</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="434"/>
+        <location filename="mainwindow.ui" line="521"/>
         <source>Toolbar</source>
         <translation>工具栏</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="442"/>
+        <location filename="mainwindow.ui" line="529"/>
         <source>&amp;Categories</source>
         <translation>分类(&amp;C)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="445"/>
+        <location filename="mainwindow.ui" line="532"/>
         <source>Error categories</source>
         <translation>错误分类</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="450"/>
+        <location filename="mainwindow.ui" line="537"/>
         <source>&amp;Open XML...</source>
         <translation>打开 XML (&amp;O)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="459"/>
+        <location filename="mainwindow.ui" line="546"/>
         <source>Open P&amp;roject File...</source>
         <translation>打开项目文件(&amp;R)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="468"/>
+        <location filename="mainwindow.ui" line="549"/>
+        <source>Ctrl+Shift+O</source>
+        <translation>Ctrl+Shift+O</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="558"/>
         <source>Sh&amp;ow Scratchpad...</source>
-        <translation type="unfinished"></translation>
+        <translation>显示便条(&amp;o)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="473"/>
+        <location filename="mainwindow.ui" line="563"/>
         <source>&amp;New Project File...</source>
         <translation>新建项目文件(&amp;N)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="478"/>
+        <location filename="mainwindow.ui" line="566"/>
+        <source>Ctrl+Shift+N</source>
+        <translation>Ctrl+Shift+N</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="571"/>
         <source>&amp;Log View</source>
         <translation>日志视图(&amp;L)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="481"/>
+        <location filename="mainwindow.ui" line="574"/>
         <source>Log View</source>
         <translation>日志视图</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="521"/>
+        <location filename="mainwindow.ui" line="614"/>
         <source>&amp;Warnings</source>
-        <translation type="unfinished"></translation>
+        <translation>警告(&amp;W)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="539"/>
+        <location filename="mainwindow.ui" line="632"/>
         <source>Per&amp;formance warnings</source>
-        <translation type="unfinished"></translation>
+        <translation>性能警告(&amp;f)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="565"/>
+        <location filename="mainwindow.ui" line="658"/>
         <source>&amp;Information</source>
-        <translation type="unfinished"></translation>
+        <translation>信息(&amp;I)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="580"/>
+        <location filename="mainwindow.ui" line="673"/>
         <source>&amp;Portability</source>
-        <translation type="unfinished"></translation>
+        <translation>可移植性(&amp;P)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="680"/>
+        <location filename="mainwindow.ui" line="773"/>
         <source>P&amp;latforms</source>
-        <translation type="unfinished"></translation>
+        <translation>平台(&amp;l)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="694"/>
+        <location filename="mainwindow.ui" line="787"/>
         <source>C++&amp;11</source>
-        <translation type="unfinished"></translation>
+        <translation>C++&amp;11</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="705"/>
+        <location filename="mainwindow.ui" line="798"/>
         <source>C&amp;99</source>
-        <translation type="unfinished"></translation>
+        <translation>C&amp;99</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="713"/>
+        <location filename="mainwindow.ui" line="806"/>
         <source>&amp;Posix</source>
-        <translation type="unfinished"></translation>
+        <translation>&amp;Posix</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="721"/>
+        <location filename="mainwindow.ui" line="814"/>
         <source>C&amp;11</source>
-        <translation type="unfinished"></translation>
+        <translation>C&amp;11</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="729"/>
+        <location filename="mainwindow.ui" line="846"/>
         <source>&amp;C89</source>
-        <translation type="unfinished"></translation>
+        <translation>&amp;C89</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="737"/>
+        <location filename="mainwindow.ui" line="854"/>
         <source>&amp;C++03</source>
-        <translation type="unfinished"></translation>
+        <translation>&amp;C++03</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="758"/>
+        <location filename="mainwindow.ui" line="875"/>
         <source>&amp;Library Editor...</source>
-        <translation type="unfinished"></translation>
+        <translation>库编辑器(&amp;L)...</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="769"/>
+        <location filename="mainwindow.ui" line="886"/>
         <source>&amp;Auto-detect language</source>
-        <translation type="unfinished"></translation>
+        <translation>自动检测语言(&amp;A)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="777"/>
+        <location filename="mainwindow.ui" line="894"/>
         <source>&amp;Enforce C++</source>
-        <translation type="unfinished"></translation>
+        <translation>&amp;Enforce C++</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="785"/>
+        <location filename="mainwindow.ui" line="902"/>
         <source>E&amp;nforce C</source>
-        <translation type="unfinished"></translation>
+        <translation>E&amp;nforce C</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="796"/>
+        <location filename="mainwindow.ui" line="913"/>
         <source>C++14</source>
-        <translation type="unfinished">C++14</translation>
+        <translation>C++14</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="804"/>
+        <location filename="mainwindow.ui" line="921"/>
         <source>Reanalyze and check library</source>
-        <translation type="unfinished"></translation>
+        <translation>重新分析并检查库</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="812"/>
+        <location filename="mainwindow.ui" line="929"/>
         <source>Check configuration (defines, includes)</source>
-        <translation type="unfinished"></translation>
+        <translation>检查配置(defines, includes)</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="820"/>
+        <location filename="mainwindow.ui" line="937"/>
         <source>C++17</source>
-        <translation type="unfinished">C++17</translation>
+        <translation>C++17</translation>
     </message>
     <message>
-        <location filename="mainwindow.ui" line="831"/>
+        <location filename="mainwindow.ui" line="948"/>
         <source>C++20</source>
-        <translation type="unfinished">C++20</translation>
+        <translation>C++20</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="975"/>
+        <source>Compliance report...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="988"/>
+        <source>Normal</source>
+        <translation type="unfinished">常规</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="996"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1004"/>
+        <source>Misra C++ 2008</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1012"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1020"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1028"/>
+        <source>Misra C++ 2023</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1036"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1041"/>
+        <source>EULA...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1046"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1049"/>
+        <source>Show thread details</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="323"/>
+        <location filename="mainwindow.cpp" line="461"/>
         <source>There was a problem with loading the editor application settings.
 
 This is probably because the settings were changed between the Cppcheck versions. Please check (and fix) the editor application settings, otherwise the editor program might not start correctly.</source>
@@ -1009,34 +1109,23 @@ This is probably because the settings were changed between the Cppcheck versions
 这可能是因为 Cppcheck 不同版本间的设置有所不同。请检查(并修复)编辑器应用程序设置，否则编辑器程序可能不会正确启动。</translation>
     </message>
     <message>
-        <source>No suitable files found to check!</source>
-        <translation type="obsolete">未发现适合检查的文件！</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="554"/>
+        <location filename="mainwindow.cpp" line="756"/>
         <source>You must close the project file before selecting new files or directories!</source>
         <translation>在选择新的文件或目录之前，你必须先关闭此项目文件！</translation>
     </message>
     <message>
-        <source>Select directory to check</source>
-        <translation type="obsolete">选择目录来检查</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="87"/>
+        <location filename="mainwindow.cpp" line="157"/>
+        <location filename="mainwindow.cpp" line="1782"/>
         <source>Quick Filter:</source>
         <translation>快速滤器:</translation>
     </message>
     <message>
-        <source>Select files to check</source>
-        <translation type="obsolete">选择要检查的文件</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="629"/>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select configuration</source>
-        <translation type="unfinished"></translation>
+        <translation>选择配置</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="659"/>
+        <location filename="mainwindow.cpp" line="861"/>
         <source>Found project file: %1
 
 Do you want to load this project file instead?</source>
@@ -1045,273 +1134,375 @@ Do you want to load this project file instead?</source>
 你是否想加载该项目文件？</translation>
     </message>
     <message>
-        <source>Found project files from the directory.
-
-Do you want to proceed checking without using any of these project files?</source>
-        <translation type="obsolete">在目录中找到项目文件。
-
-你是否想在不使用这些项目文件的情况下，执行检查？</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="769"/>
+        <location filename="mainwindow.cpp" line="986"/>
         <source>The library &apos;%1&apos; contains unknown elements:
 %2</source>
-        <translation type="unfinished"></translation>
+        <translation>库 &apos;%1&apos; 包含未知元素：
+%2</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="778"/>
+        <location filename="mainwindow.cpp" line="995"/>
         <source>File not found</source>
-        <translation type="unfinished"></translation>
+        <translation>文件未找到</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="781"/>
+        <location filename="mainwindow.cpp" line="998"/>
         <source>Bad XML</source>
-        <translation type="unfinished"></translation>
+        <translation>无效的 XML</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="784"/>
+        <location filename="mainwindow.cpp" line="1001"/>
         <source>Missing attribute</source>
-        <translation type="unfinished"></translation>
+        <translation>缺失属性</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="787"/>
+        <location filename="mainwindow.cpp" line="1004"/>
         <source>Bad attribute value</source>
-        <translation type="unfinished"></translation>
+        <translation>无效的属性值</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="790"/>
+        <location filename="mainwindow.cpp" line="1007"/>
         <source>Unsupported format</source>
-        <translation type="unfinished"></translation>
+        <translation>不支持的格式</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="793"/>
+        <location filename="mainwindow.cpp" line="1010"/>
         <source>Duplicate platform type</source>
-        <translation type="unfinished"></translation>
+        <translation>重复的平台类型</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="796"/>
+        <location filename="mainwindow.cpp" line="1013"/>
         <source>Platform type redefined</source>
-        <translation type="unfinished"></translation>
+        <translation>平台类型重定义</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="799"/>
+        <location filename="mainwindow.cpp" line="1019"/>
         <source>Unknown element</source>
-        <translation type="unfinished"></translation>
+        <translation>位置元素</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="802"/>
-        <source>Unknown issue</source>
-        <translation type="unfinished"></translation>
+        <location filename="mainwindow.cpp" line="1019"/>
+        <source>Unknown element</source>
+        <oldsource>Unknown issue</oldsource>
+        <translation type="unfinished">未知问题</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="807"/>
+        <location filename="mainwindow.cpp" line="1024"/>
         <source>Failed to load the selected library &apos;%1&apos;.
 %2</source>
-        <translation type="unfinished"></translation>
+        <translation>选择的库 &apos;%1&apos; 加载失败。
+%2</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="828"/>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
         <source>Error</source>
-        <translation type="unfinished"></translation>
+        <translation>错误</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="828"/>
         <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <source>Current results will be cleared.
-
-Opening a new XML file will clear current results.Do you want to proceed?</source>
-        <translation type="vanished">当前结果将被清空。
-
-打开一个新的 XML 文件将会清空当前结果。你要继续吗？</translation>
+        <translation type="vanished">加载 %1 失败。您的 Cppcheck 安装已损坏。您可以在命令行添加 --data-dir=&lt;目录&gt; 参数来指定文件位置。请注意，&apos;--data-dir&apos; 参数应当由安装脚本使用，因此，当使用此参数时，GUI不会启动，所发生的一切只是配置了设置。</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1129"/>
-        <location filename="mainwindow.cpp" line="1309"/>
+        <location filename="mainwindow.cpp" line="1483"/>
+        <location filename="mainwindow.cpp" line="1682"/>
         <source>XML files (*.xml)</source>
         <translation>XML 文件(*.xml)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1131"/>
+        <location filename="mainwindow.cpp" line="1485"/>
         <source>Open the report file</source>
         <translation>打开报告文件</translation>
     </message>
     <message>
-        <source>Checking is running.
-
-Do you want to stop the checking and exit Cppcheck?</source>
-        <translation type="obsolete">检查正在执行。
-
-你是否需要停止检查并退出 Cppcheck？</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1280"/>
+        <location filename="mainwindow.cpp" line="1648"/>
         <source>License</source>
         <translation>许可证</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1287"/>
+        <location filename="mainwindow.cpp" line="1655"/>
         <source>Authors</source>
         <translation>作者</translation>
     </message>
     <message>
-        <source>XML files version 2 (*.xml);;XML files version 1 (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
-        <oldsource>XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</oldsource>
-        <translation type="obsolete">XML 文件版本 2 (*.xml);;XML 文件版本 1 (*.xml);; 文本文件(*.txt);; CSV 文件(*.csv)</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1302"/>
+        <location filename="mainwindow.cpp" line="1675"/>
         <source>Save the report file</source>
         <translation>保存报告文件</translation>
     </message>
     <message>
-        <source>XML files version 1 (*.xml)</source>
-        <translation type="obsolete">XML 文件版本 1 (*.xml)</translation>
-    </message>
-    <message>
-        <source>XML files version 2 (*.xml)</source>
-        <translation type="obsolete">XML 文件版本 2 (*.xml)</translation>
-    </message>
-    <message>
-        <location filename="mainwindow.cpp" line="1313"/>
+        <location filename="mainwindow.cpp" line="1686"/>
         <source>Text files (*.txt)</source>
         <translation>文本文件(*.txt)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1317"/>
+        <location filename="mainwindow.cpp" line="1690"/>
         <source>CSV files (*.csv)</source>
         <translation>CSV 文件(*.csv)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1361"/>
-        <source>Cppcheck - %1</source>
-        <translation>Cppcheck - %1</translation>
-    </message>
-    <message>
-        <source>Failed to change the user interface language:
-
-%1
-
-The user interface language has been reset to English. Open the Preferences-dialog to select any of the available languages.</source>
-        <translation type="obsolete">更改用户界面语言失败:
-
-%1
-
-用户界面语言已被重置为英语。打开“首选项”对话框，选择任何可用的语言。</translation>
+        <location filename="mainwindow.cpp" line="1713"/>
+        <source>Cannot generate a compliance report right now, an analysis must finish successfully. Try to reanalyze the code and ensure there are no critical errors.</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1407"/>
+        <location filename="mainwindow.cpp" line="1820"/>
         <source>Project files (*.cppcheck);;All files(*.*)</source>
         <translation>项目文件(*.cppcheck);;所有文件(*.*)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1409"/>
+        <location filename="mainwindow.cpp" line="1822"/>
         <source>Select Project File</source>
         <translation>选择项目文件</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="159"/>
-        <location filename="mainwindow.cpp" line="1437"/>
-        <location filename="mainwindow.cpp" line="1562"/>
+        <location filename="mainwindow.cpp" line="1978"/>
+        <source>Failed to open file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1981"/>
+        <source>Unknown project file format</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1984"/>
+        <source>Failed to import project file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2000"/>
+        <source>Failed to import &apos;%1&apos;: %2
+
+Analysis is stopped.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2009"/>
+        <source>Failed to import &apos;%1&apos; (%2), analysis is stopped</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2325"/>
+        <source>Install</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2329"/>
+        <source>New version available: %1. %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="242"/>
+        <location filename="mainwindow.cpp" line="1784"/>
+        <location filename="mainwindow.cpp" line="1850"/>
+        <location filename="mainwindow.cpp" line="2048"/>
         <source>Project:</source>
         <translation>项目:</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="481"/>
+        <location filename="mainwindow.cpp" line="671"/>
         <source>No suitable files found to analyze!</source>
-        <translation type="unfinished"></translation>
+        <translation>没有找到合适的文件来分析!</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="568"/>
+        <location filename="mainwindow.cpp" line="770"/>
         <source>C/C++ Source</source>
-        <translation type="unfinished"></translation>
+        <translation>C/C++ 源码</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="569"/>
+        <location filename="mainwindow.cpp" line="771"/>
         <source>Compile database</source>
-        <translation type="unfinished"></translation>
+        <translation>Compile database</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="570"/>
+        <location filename="mainwindow.cpp" line="772"/>
         <source>Visual Studio</source>
-        <translation type="unfinished"></translation>
+        <translation>Visual Studio</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="571"/>
+        <location filename="mainwindow.cpp" line="773"/>
         <source>Borland C++ Builder 6</source>
-        <translation type="unfinished"></translation>
+        <translation>Borland C++ Builder 6</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="574"/>
+        <location filename="mainwindow.cpp" line="776"/>
         <source>Select files to analyze</source>
-        <translation type="unfinished"></translation>
+        <translation>选择要分析的文件</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="589"/>
+        <location filename="mainwindow.cpp" line="791"/>
         <source>Select directory to analyze</source>
-        <translation type="unfinished"></translation>
+        <translation>选择要分析的目录</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="629"/>
+        <location filename="mainwindow.cpp" line="831"/>
         <source>Select the configuration that will be analyzed</source>
-        <translation type="unfinished"></translation>
+        <translation>选择要分析的配置</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="681"/>
+        <location filename="mainwindow.cpp" line="883"/>
         <source>Found project files from the directory.
 
 Do you want to proceed analysis without using any of these project files?</source>
+        <translation>在目录中发现项目文件。
+
+您想在不使用这些项目文件的情况下进行分析吗？</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1016"/>
+        <source>Duplicate define</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1035"/>
+        <source>File not found: &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1058"/>
+        <source>Failed to load/setup addon %1: %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.
+
+Analysis is aborted.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1114"/>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <source>Failed to load %1 - %2
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
+        <source>%1
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1468"/>
         <source>Current results will be cleared.
 
 Opening a new XML file will clear current results.
 Do you want to proceed?</source>
-        <translation type="unfinished"></translation>
+        <translation>当前结果将被清除。
+
+打开一个新的XML文件将清除当前的结果。
+你想继续吗?</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1234"/>
+        <location filename="mainwindow.cpp" line="1592"/>
         <source>Analyzer is running.
 
 Do you want to stop the analysis and exit Cppcheck?</source>
+        <translation>分析正在运行。
+
+您想停止分析并退出 Cppcheck 吗？</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1634"/>
+        <source>About</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1300"/>
+        <location filename="mainwindow.cpp" line="1673"/>
         <source>XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
-        <translation type="unfinished"></translation>
+        <translation>XML 文件 (*.xml);;文本文件 (*.txt);;CSV 文件 (*.csv)</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1500"/>
+        <location filename="mainwindow.cpp" line="1938"/>
         <source>Build dir &apos;%1&apos; does not exist, create it?</source>
+        <translation>构建文件夹 &apos;%1&apos; 不能存在，创建它吗？</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1946"/>
+        <source>To check the project using addons, you need a build directory.</source>
+        <translation>要使用插件检查项目，您需要一个构建目录。</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2367"/>
+        <source>Show Mandatory</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1523"/>
-        <source>Failed to import &apos;%1&apos;, analysis is stopped</source>
+        <location filename="mainwindow.cpp" line="2368"/>
+        <source>Show Required</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1547"/>
-        <source>Project files (*.cppcheck)</source>
+        <location filename="mainwindow.cpp" line="2369"/>
+        <source>Show Advisory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2370"/>
+        <source>Show Document</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2387"/>
+        <source>Show L1</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2388"/>
+        <source>Show L2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2389"/>
+        <source>Show L3</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1549"/>
+        <location filename="mainwindow.cpp" line="2396"/>
+        <source>Show style</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2397"/>
+        <source>Show portability</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2398"/>
+        <source>Show performance</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2399"/>
+        <source>Show information</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <source>Failed to import &apos;%1&apos;, analysis is stopped</source>
+        <translation type="vanished">导入 &apos;%1&apos; 失败，分析已停止</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2033"/>
+        <source>Project files (*.cppcheck)</source>
+        <translation>项目文件 (*.cppcheck)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2035"/>
         <source>Select Project Filename</source>
         <translation>选择项目文件名</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1594"/>
+        <location filename="mainwindow.cpp" line="2081"/>
         <source>No project file loaded</source>
         <translation>项目文件未加载</translation>
     </message>
     <message>
-        <location filename="mainwindow.cpp" line="1662"/>
+        <location filename="mainwindow.cpp" line="2163"/>
         <source>The project file
 
 %1
@@ -1328,7 +1519,7 @@ Do you want to remove the file from the recently used projects -list?</source>
 你要从最近使用的项目列表中删除此文件吗？</translation>
     </message>
     <message>
-        <location filename="main.cpp" line="106"/>
+        <location filename="main.cpp" line="100"/>
         <source>Cppcheck GUI.
 
 Syntax:
@@ -1355,12 +1546,24 @@ Options:
     -d &lt;directory&gt;          Specify the directory that was checked to generate the results xml specified with -l
     -v, --version           Show program version
     --data-dir=&lt;directory&gt;  Specify directory where GUI datafiles are located (translations, cfg)</oldsource>
-        <translation type="unfinished"></translation>
+        <translation>Cppcheck GUI.
+
+语法:
+    cppcheck-gui [选项] [文件或路径]
+
+选项:
+    -h, --help              打印此帮助
+    -p &lt;file&gt;               打开指定的项目文件并开始检查它
+    -l &lt;file&gt;               打开指定的 xml 结果文件
+    -d &lt;directory&gt;          指定检查的目录，用以生成用 -l 指定的 xml 结果
+    -v, --version           显示程序版本
+    --data-dir=&lt;directory&gt;  这个选项用于安装脚本，这样他们可以配置数据文件所在的目录(translations, cfg)。
+                            当使用这个选项时，GUI不会启动。</translation>
     </message>
     <message>
-        <location filename="main.cpp" line="121"/>
+        <location filename="main.cpp" line="115"/>
         <source>Cppcheck GUI - Command line parameters</source>
-        <translation type="unfinished"></translation>
+        <translation>Cppcheck GUI - 命令行参数</translation>
     </message>
 </context>
 <context>
@@ -1368,341 +1571,459 @@ Options:
     <message>
         <location filename="newsuppressiondialog.ui" line="17"/>
         <source>New suppression</source>
-        <translation type="unfinished"></translation>
+        <translation>新建抑制</translation>
     </message>
     <message>
         <location filename="newsuppressiondialog.ui" line="25"/>
         <source>Error ID</source>
-        <translation type="unfinished"></translation>
+        <translation>错误 ID</translation>
     </message>
     <message>
         <location filename="newsuppressiondialog.ui" line="32"/>
         <source>File name</source>
-        <translation type="unfinished"></translation>
+        <translation>文件名</translation>
     </message>
     <message>
         <location filename="newsuppressiondialog.ui" line="42"/>
         <source>Line number</source>
-        <translation type="unfinished"></translation>
+        <translation>行号</translation>
     </message>
     <message>
         <location filename="newsuppressiondialog.ui" line="52"/>
         <source>Symbol name</source>
-        <translation type="unfinished"></translation>
+        <translation>符号名</translation>
     </message>
     <message>
-        <location filename="newsuppressiondialog.cpp" line="52"/>
+        <location filename="newsuppressiondialog.cpp" line="83"/>
         <source>Edit suppression</source>
-        <translation type="unfinished"></translation>
+        <translation>编辑抑制</translation>
     </message>
 </context>
 <context>
     <name>Platforms</name>
     <message>
-        <source>Built-in</source>
-        <translation type="obsolete">内置</translation>
-    </message>
-    <message>
-        <location filename="platforms.cpp" line="37"/>
+        <location filename="platforms.cpp" line="38"/>
         <source>Native</source>
-        <translation type="unfinished"></translation>
+        <translation>本地</translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="38"/>
+        <location filename="platforms.cpp" line="39"/>
         <source>Unix 32-bit</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="39"/>
+        <location filename="platforms.cpp" line="40"/>
         <source>Unix 64-bit</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="40"/>
+        <location filename="platforms.cpp" line="41"/>
         <source>Windows 32-bit ANSI</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="41"/>
+        <location filename="platforms.cpp" line="42"/>
         <source>Windows 32-bit Unicode</source>
         <translation></translation>
     </message>
     <message>
-        <location filename="platforms.cpp" line="42"/>
+        <location filename="platforms.cpp" line="43"/>
         <source>Windows 64-bit</source>
         <translation></translation>
     </message>
 </context>
-<context>
-    <name>Project</name>
-    <message>
-        <source>Cppcheck</source>
-        <translation type="obsolete">Cppcheck</translation>
-    </message>
-    <message>
-        <source>Could not read the project file.</source>
-        <translation type="obsolete">无法读取项目文件。</translation>
-    </message>
-    <message>
-        <source>Could not write the project file.</source>
-        <translation type="obsolete">无法写入项目文件。</translation>
-    </message>
-</context>
 <context>
     <name>ProjectFile</name>
     <message>
-        <location filename="projectfiledialog.ui" line="14"/>
+        <location filename="projectfile.ui" line="14"/>
         <source>Project File</source>
         <translation>项目文件</translation>
     </message>
     <message>
-        <source>Project</source>
-        <translation type="obsolete">项目</translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.ui" line="24"/>
+        <location filename="projectfile.ui" line="24"/>
         <source>Paths and Defines</source>
-        <translation type="unfinished"></translation>
+        <translation>路径和定义</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="30"/>
+        <location filename="projectfile.ui" line="30"/>
         <source>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</source>
         <oldsource>Import Project (Visual studio / compile database)</oldsource>
-        <translation type="unfinished"></translation>
+        <translation>导入项目 (Visual studio / compile database/ Borland C++ Builder 6)</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="163"/>
+        <location filename="projectfile.ui" line="231"/>
         <source>Defines must be separated by a semicolon. Example: DEF1;DEF2=5;DEF3=int</source>
         <oldsource>Defines must be separated by a semicolon &apos;;&apos;</oldsource>
-        <translation type="unfinished"></translation>
+        <translation>定义必须用分号分隔。例如：DEF1;DEF2=5;DEF3=int</translation>
     </message>
     <message>
-        <source>&amp;Root:</source>
-        <oldsource>Root:</oldsource>
-        <translation type="obsolete">根目录:</translation>
+        <location filename="projectfile.ui" line="389"/>
+        <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
+        <translation>注意：把你自己的 .cfg 文件放在和项目文件相同的文件夹中。你应该在上面看到它们。</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="393"/>
-        <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
-        <translation type="unfinished"></translation>
+        <location filename="projectfile.ui" line="655"/>
+        <source>If tags are added, you will be able to right click on warnings and set one of these tags. You can manually categorize warnings.</source>
+        <translation>如果添加了标记，您将能够右键单击警告并设置其中一个标记。您可以手动对警告进行分类。</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="665"/>
+        <source>Exclude source files</source>
+        <translation>排除源文件</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="676"/>
+        <source>Exclude folder...</source>
+        <translation>排除文件夹...</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="683"/>
+        <source>Exclude file...</source>
+        <translation>排除文件...</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="597"/>
         <source>MISRA C 2012</source>
-        <translation type="unfinished"></translation>
+        <translation type="vanished">MISRA C 2012</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="606"/>
-        <source>Misra rule texts</source>
-        <translation type="unfinished"></translation>
+        <location filename="projectfile.ui" line="876"/>
+        <source>MISRA rule texts</source>
+        <translation>MISRA 规则文本</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="613"/>
+        <location filename="projectfile.ui" line="883"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
-        <translation type="unfinished"></translation>
+        <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;从 MISRA C 2012 PDF 的附录 A &amp;quot;指南摘要&amp;quot; 复制/粘贴文本到一个文本文件。&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="620"/>
+        <location filename="projectfile.ui" line="890"/>
         <source>...</source>
-        <translation type="unfinished"></translation>
+        <translation>...</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="69"/>
+        <location filename="projectfile.ui" line="73"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;You have a choice:&lt;/p&gt;&lt;p&gt; * Analyze all Debug and Release configurations&lt;/p&gt;&lt;p&gt; * Only analyze the first matching Debug configuration&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
-        <translation type="unfinished"></translation>
+        <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;您有一个选择：&lt;/p&gt;&lt;p&gt; * 分析所有的 Debug 和 Release 配置&lt;/p&gt;&lt;p&gt; * 只分析第一个匹配的 Debug 配置&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="60"/>
-        <location filename="projectfiledialog.ui" line="309"/>
+        <location filename="projectfile.ui" line="60"/>
+        <location filename="projectfile.ui" line="422"/>
+        <location filename="projectfile.ui" line="616"/>
         <source>Browse...</source>
-        <translation type="unfinished"></translation>
+        <translation>浏览...</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="72"/>
+        <location filename="projectfile.ui" line="76"/>
         <source>Analyze all Visual Studio configurations</source>
-        <translation type="unfinished"></translation>
+        <translation>分析全部 Visual Studio 配置</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="113"/>
+        <source>Selected VS Configurations</source>
+        <translation>已选择的 VS 配置</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="86"/>
+        <location filename="projectfile.ui" line="147"/>
         <source>Paths:</source>
         <translation>路径:</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="113"/>
-        <location filename="projectfiledialog.ui" line="228"/>
-        <location filename="projectfiledialog.ui" line="461"/>
+        <location filename="projectfile.ui" line="181"/>
+        <location filename="projectfile.ui" line="296"/>
         <source>Add...</source>
         <translation>添加...</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="120"/>
-        <location filename="projectfiledialog.ui" line="235"/>
-        <location filename="projectfiledialog.ui" line="468"/>
+        <location filename="projectfile.ui" line="188"/>
+        <location filename="projectfile.ui" line="303"/>
+        <location filename="projectfile.ui" line="690"/>
         <source>Edit</source>
         <translation>编辑</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="127"/>
-        <location filename="projectfiledialog.ui" line="242"/>
-        <location filename="projectfiledialog.ui" line="475"/>
-        <location filename="projectfiledialog.ui" line="518"/>
+        <location filename="projectfile.ui" line="195"/>
+        <location filename="projectfile.ui" line="310"/>
+        <location filename="projectfile.ui" line="697"/>
+        <location filename="projectfile.ui" line="740"/>
         <source>Remove</source>
         <translation>移除</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="174"/>
+        <location filename="projectfile.ui" line="242"/>
         <source>Undefines:</source>
-        <translation type="unfinished"></translation>
+        <translation>未定义：</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="184"/>
+        <location filename="projectfile.ui" line="252"/>
         <source>Undefines must be separated by a semicolon. Example: UNDEF1;UNDEF2;UNDEF3</source>
-        <translation type="unfinished"></translation>
+        <translation>未定义必须用分号分隔。例如：UNDEF1;UNDEF2;UNDEF3</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="197"/>
+        <location filename="projectfile.ui" line="265"/>
         <source>Include Paths:</source>
-        <translation type="unfinished"></translation>
+        <translation>包含目录：</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="362"/>
+        <source>Types and Functions</source>
+        <translation>类型和函数</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="331"/>
+        <location filename="projectfile.ui" line="403"/>
+        <location filename="projectfile.ui" line="488"/>
         <source>Analysis</source>
+        <translation>分析</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="415"/>
+        <source>This is a workfolder that Cppcheck will use for various purposes.</source>
+        <translation>这是一个 Cppcheck 将用于各种目的的工作文件夹。</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="432"/>
+        <source>Parser</source>
+        <translation>解析器</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="438"/>
+        <source>Cppcheck (built in)</source>
+        <translation>Cppcheck (内建)</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="458"/>
+        <source>Check level</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="337"/>
-        <source>Check code in headers  (slower analysis, more results)</source>
+        <location filename="projectfile.ui" line="464"/>
+        <source>Reduced -- meant for usage where developer wants results directly. Limited and faster analysis with fewer results.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="347"/>
-        <source>Check code in unused templates  (slower and less accurate analysis)</source>
+        <location filename="projectfile.ui" line="471"/>
+        <source>Normal -- meant for normal analysis in CI. Analysis should finish in reasonable time.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="356"/>
+        <location filename="projectfile.ui" line="478"/>
+        <source>Exhaustive -- meant for nightly builds etc. Analysis time can be longer (10x slower than compilation is OK).</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="497"/>
+        <source>Check that each class has a safe public interface</source>
+        <translation>检查每个类是否有一个安全的公共接口</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="513"/>
+        <source>Limit analysis</source>
+        <translation>极限分析</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="529"/>
+        <source>Check code in unused templates (should be ON normally, however in theory you can safely ignore warnings in unused templates)</source>
+        <oldsource>Check code in unused templates  (slower and less accurate analysis)</oldsource>
+        <translation>检查未使用模板中的代码（正常情况下应该是打开，但理论上可以忽略未使用模板中的警告）</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="541"/>
         <source>Max CTU depth</source>
+        <translation>最大 CTU 深度</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="607"/>
+        <source>Premium License</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="450"/>
-        <source>Exclude source files in paths</source>
+        <location filename="projectfile.ui" line="765"/>
+        <source>Enable inline suppressions</source>
+        <translation type="unfinished">启用内联方案</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="851"/>
+        <source>2025</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="632"/>
-        <source>External tools</source>
+        <location filename="projectfile.ui" line="901"/>
+        <source>Misra C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="909"/>
+        <source>2008</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="937"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="946"/>
+        <source>CERT-INT35-C:  int precision (if size equals precision, you can leave empty)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Includes</source>
-        <translation type="obsolete">包含</translation>
+        <location filename="projectfile.ui" line="965"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="972"/>
+        <source>Safety profiles (defined in C++ core guidelines)</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <source>Include directories:</source>
-        <translation type="obsolete">Include 目录:</translation>
+        <location filename="projectfile.ui" line="988"/>
+        <source>Bug hunting</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="998"/>
+        <source>External tools</source>
+        <translation>外部工具</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="262"/>
+        <location filename="projectfile.ui" line="330"/>
         <source>Up</source>
         <translation>向上</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="269"/>
+        <location filename="projectfile.ui" line="337"/>
         <source>Down</source>
         <translation>向下</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="294"/>
-        <source>Checking</source>
-        <translation type="unfinished"></translation>
+        <location filename="projectfile.ui" line="368"/>
+        <source>Platform</source>
+        <translation>平台</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="319"/>
-        <source>Platform</source>
-        <translation type="unfinished"></translation>
+        <location filename="projectfile.ui" line="448"/>
+        <source>Clang (experimental)</source>
+        <translation>Clang (实验性的)</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="494"/>
+        <source>If you want to design your classes to be as flexible and robust as possible then the public interface must be very robust. Cppcheck will asumme that arguments can take *any* value.</source>
+        <translation>如果你想要设计你的类尽可能的灵活和健壮，那么公共接口必须非常健壮。Cppcheck 将假设参数可以取 *任何* 值。</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="519"/>
+        <source>Check code in headers  (should be ON normally. if you want a limited quick analysis then turn this OFF)</source>
+        <translation>检查头文件中的代码（通常应该是打开的。如果您想要一个有限的快速分析，那么关掉它)）</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="420"/>
+        <location filename="projectfile.ui" line="572"/>
+        <source>Max recursion in template instantiation</source>
+        <translation>模板实例化中的最大递归</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="627"/>
         <source>Warning options</source>
-        <translation type="unfinished"></translation>
+        <translation>警告选项</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="426"/>
+        <location filename="projectfile.ui" line="633"/>
         <source>Root path:</source>
-        <translation type="unfinished"></translation>
+        <translation>根路径：</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="438"/>
+        <location filename="projectfile.ui" line="639"/>
+        <source>Filepaths in warnings will be relative to this path</source>
+        <translation>警告中的文件路径将相对于此路径</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="649"/>
         <source>Warning tags (separated by semicolon)</source>
-        <translation type="unfinished"></translation>
+        <translation>警告标志（用分号隔开）</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="300"/>
+        <location filename="projectfile.ui" line="409"/>
         <source>Cppcheck build dir (whole program analysis, incremental analysis, statistics, etc)</source>
-        <translation type="unfinished"></translation>
+        <translation>Cppcheck 构建目录 (整个程序分析、增量分析、统计数据等)</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="380"/>
+        <source>Libraries</source>
+        <translation>库</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="722"/>
+        <source>Suppressions</source>
+        <translation>抑制</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="733"/>
+        <source>Add</source>
+        <translation>添加</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="384"/>
-        <source>Libraries</source>
-        <translation type="unfinished"></translation>
+        <location filename="projectfile.ui" line="786"/>
+        <location filename="projectfile.ui" line="792"/>
+        <source>Addons</source>
+        <translation>插件</translation>
     </message>
     <message>
-        <source>Exclude</source>
-        <translation type="obsolete">排除</translation>
+        <location filename="projectfile.ui" line="798"/>
+        <source>Note: Addons require &lt;a href=&quot;https://www.python.org/&quot;&gt;Python&lt;/a&gt; being installed.</source>
+        <translation>注意：插件需要安装  &lt;a href=&quot;https://www.python.org/&quot;&gt;Python&lt;/a&gt;。</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="500"/>
-        <source>Suppressions</source>
-        <translation type="unfinished"></translation>
+        <location filename="projectfile.ui" line="808"/>
+        <source>Y2038</source>
+        <translation>Y2038</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="511"/>
-        <source>Add</source>
-        <translation type="unfinished"></translation>
+        <location filename="projectfile.ui" line="815"/>
+        <source>Thread safety</source>
+        <translation>线程安全</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="557"/>
-        <source>Addons and tools</source>
-        <translation type="unfinished"></translation>
+        <location filename="projectfile.ui" line="825"/>
+        <source>Coding standards</source>
+        <translation>编码标准</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="563"/>
-        <source>Addons</source>
+        <location filename="projectfile.ui" line="833"/>
+        <source>Misra C</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="569"/>
-        <source>Y2038</source>
+        <location filename="projectfile.ui" line="841"/>
+        <source>2012</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="576"/>
-        <source>Thread safety</source>
+        <location filename="projectfile.ui" line="846"/>
+        <location filename="projectfile.ui" line="914"/>
+        <source>2023</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="583"/>
-        <source>Coding standards</source>
+        <location filename="projectfile.ui" line="958"/>
+        <source>Cert C++</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="590"/>
-        <source>Cert</source>
+        <location filename="projectfile.ui" line="982"/>
+        <source>Bug hunting (Premium)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="645"/>
+        <location filename="projectfile.ui" line="1011"/>
         <source>Clang analyzer</source>
-        <translation type="unfinished"></translation>
+        <translation>Clang analyzer</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="638"/>
+        <location filename="projectfile.ui" line="1004"/>
         <source>Clang-tidy</source>
-        <translation type="unfinished"></translation>
+        <translation>Clang-tidy</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.ui" line="153"/>
+        <location filename="projectfile.ui" line="221"/>
         <source>Defines:</source>
         <translation>定义:</translation>
     </message>
@@ -1710,407 +2031,456 @@ Options:
 <context>
     <name>ProjectFileDialog</name>
     <message>
-        <location filename="projectfiledialog.cpp" line="71"/>
+        <location filename="projectfiledialog.cpp" line="138"/>
         <source>Project file: %1</source>
         <translation>项目文件: %1</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="409"/>
+        <location filename="projectfiledialog.cpp" line="590"/>
         <source>Select Cppcheck build dir</source>
-        <translation type="unfinished"></translation>
+        <translation>选择 Cppcheck 构建目录</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="637"/>
+        <location filename="projectfiledialog.cpp" line="851"/>
         <source>Select include directory</source>
         <translation>选择 Include 目录</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="617"/>
+        <location filename="projectfiledialog.cpp" line="831"/>
         <source>Select a directory to check</source>
         <translation>选择一个检查目录</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="305"/>
-        <source>(no rule texts file)</source>
+        <location filename="projectfiledialog.cpp" line="396"/>
+        <source>Note: Open source Cppcheck does not fully implement Misra C 2012</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="311"/>
+        <location filename="projectfiledialog.cpp" line="461"/>
         <source>Clang-tidy (not found)</source>
-        <translation type="unfinished"></translation>
+        <translation>Clang-tidy (未找到)</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="445"/>
+        <location filename="projectfiledialog.cpp" line="629"/>
         <source>Visual Studio</source>
-        <translation type="unfinished"></translation>
+        <translation>Visual Studio</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="446"/>
+        <location filename="projectfiledialog.cpp" line="630"/>
         <source>Compile database</source>
-        <translation type="unfinished"></translation>
+        <translation>Compile database</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="447"/>
+        <location filename="projectfiledialog.cpp" line="631"/>
         <source>Borland C++ Builder 6</source>
-        <translation type="unfinished"></translation>
+        <translation>Borland C++ Builder 6</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="448"/>
+        <location filename="projectfiledialog.cpp" line="632"/>
         <source>Import Project</source>
-        <translation type="unfinished"></translation>
+        <translation>导入项目</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="657"/>
+        <location filename="projectfiledialog.cpp" line="871"/>
         <source>Select directory to ignore</source>
         <translation>选择忽略的目录</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="742"/>
-        <source>Select MISRA rule texts file</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="projectfiledialog.cpp" line="742"/>
-        <source>Misra rule texts file (%1)</source>
-        <translation type="unfinished"></translation>
+        <location filename="projectfiledialog.cpp" line="879"/>
+        <source>Source files</source>
+        <translation>源文件</translation>
     </message>
-</context>
-<context>
-    <name>QDialogButtonBox</name>
     <message>
-        <location filename="translationhandler.cpp" line="34"/>
-        <source>OK</source>
-        <translation type="unfinished"></translation>
+        <location filename="projectfiledialog.cpp" line="880"/>
+        <source>All files</source>
+        <translation>全部文件</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="35"/>
-        <source>Cancel</source>
-        <translation type="unfinished"></translation>
+        <location filename="projectfiledialog.cpp" line="881"/>
+        <source>Exclude file</source>
+        <translation>排除文件</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="36"/>
-        <source>Close</source>
-        <translation type="unfinished">关闭</translation>
+        <location filename="projectfiledialog.cpp" line="964"/>
+        <source>Select MISRA rule texts file</source>
+        <translation>选择 MISRA 规则文本文件</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="37"/>
-        <source>Save</source>
-        <translation type="unfinished"></translation>
+        <location filename="projectfiledialog.cpp" line="966"/>
+        <source>MISRA rule texts file (%1)</source>
+        <translation>MISRA 规则文本文件 (%1)</translation>
     </message>
 </context>
 <context>
     <name>QObject</name>
     <message>
-        <location filename="translationhandler.cpp" line="104"/>
+        <location filename="translationhandler.cpp" line="91"/>
         <source>Unknown language specified!</source>
         <translation>指定了未知语言！</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="132"/>
+        <location filename="translationhandler.cpp" line="117"/>
         <source>Language file %1 not found!</source>
         <translation>语言文件 %1 不存在！</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="138"/>
+        <location filename="translationhandler.cpp" line="122"/>
         <source>Failed to load translation for language %1 from file %2</source>
         <translation>无法从文件 %2 中为语言 %1 加载翻译文件</translation>
     </message>
     <message>
-        <location filename="cppchecklibrarydata.cpp" line="33"/>
+        <location filename="cppchecklibrarydata.cpp" line="38"/>
         <source>line %1: Unhandled element %2</source>
-        <translation type="unfinished"></translation>
+        <translation>第%1行：未处理元素 %2</translation>
     </message>
     <message>
-        <location filename="projectfiledialog.cpp" line="226"/>
+        <location filename="cppchecklibrarydata.cpp" line="43"/>
+        <source>line %1: Mandatory attribute &apos;%2&apos; missing in &apos;%3&apos;</source>
+        <translation>第%1行：在 &quot;%3&quot; 中缺失的必选属性 &quot;%2&quot;</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="284"/>
         <source> (Not found)</source>
-        <translation type="unfinished"></translation>
+        <translation> (未找到)</translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="69"/>
+        <location filename="codeeditstylecontrols.cpp" line="76"/>
         <source>Thin</source>
-        <translation type="unfinished"></translation>
+        <translation>极细</translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="71"/>
+        <location filename="codeeditstylecontrols.cpp" line="78"/>
         <source>ExtraLight</source>
-        <translation type="unfinished"></translation>
+        <translation>更细</translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="73"/>
+        <location filename="codeeditstylecontrols.cpp" line="80"/>
         <source>Light</source>
-        <translation type="unfinished"></translation>
+        <translation>细</translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="75"/>
+        <location filename="codeeditstylecontrols.cpp" line="82"/>
         <source>Normal</source>
-        <translation type="unfinished"></translation>
+        <translation>常规</translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="77"/>
+        <location filename="codeeditstylecontrols.cpp" line="84"/>
         <source>Medium</source>
-        <translation type="unfinished"></translation>
+        <translation>中等</translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="79"/>
+        <location filename="codeeditstylecontrols.cpp" line="86"/>
         <source>DemiBold</source>
-        <translation type="unfinished"></translation>
+        <translation>较粗</translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="81"/>
+        <location filename="codeeditstylecontrols.cpp" line="88"/>
         <source>Bold</source>
-        <translation type="unfinished"></translation>
+        <translation>粗</translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="83"/>
+        <location filename="codeeditstylecontrols.cpp" line="90"/>
         <source>ExtraBold</source>
-        <translation type="unfinished"></translation>
+        <translation>更粗</translation>
     </message>
     <message>
-        <location filename="codeeditstylecontrols.cpp" line="85"/>
+        <location filename="codeeditstylecontrols.cpp" line="92"/>
         <source>Black</source>
-        <translation type="unfinished"></translation>
+        <translation>极粗</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="69"/>
+        <location filename="codeeditstyledialog.cpp" line="80"/>
         <source>Editor Foreground Color</source>
-        <translation type="unfinished"></translation>
+        <translation>编辑器前景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="72"/>
+        <location filename="codeeditstyledialog.cpp" line="83"/>
         <source>Editor Background Color</source>
-        <translation type="unfinished"></translation>
+        <translation>编辑器背景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="75"/>
+        <location filename="codeeditstyledialog.cpp" line="86"/>
         <source>Highlight Background Color</source>
-        <translation type="unfinished"></translation>
+        <translation>高亮背景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="78"/>
+        <location filename="codeeditstyledialog.cpp" line="89"/>
         <source>Line Number Foreground Color</source>
-        <translation type="unfinished"></translation>
+        <translation>行号前景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="81"/>
+        <location filename="codeeditstyledialog.cpp" line="92"/>
         <source>Line Number Background Color</source>
-        <translation type="unfinished"></translation>
+        <translation>行号背景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="84"/>
+        <location filename="codeeditstyledialog.cpp" line="95"/>
         <source>Keyword Foreground Color</source>
-        <translation type="unfinished"></translation>
+        <translation>关键字前景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="87"/>
+        <location filename="codeeditstyledialog.cpp" line="98"/>
         <source>Keyword Font Weight</source>
-        <translation type="unfinished"></translation>
+        <translation>关键字字体大小</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="90"/>
+        <location filename="codeeditstyledialog.cpp" line="101"/>
         <source>Class Foreground Color</source>
         <oldsource>Class ForegroundColor</oldsource>
-        <translation type="unfinished"></translation>
+        <translation>类前景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="93"/>
+        <location filename="codeeditstyledialog.cpp" line="104"/>
         <source>Class Font Weight</source>
-        <translation type="unfinished"></translation>
+        <translation>类字体大小</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="96"/>
+        <location filename="codeeditstyledialog.cpp" line="107"/>
         <source>Quote Foreground Color</source>
-        <translation type="unfinished"></translation>
+        <translation>引用前景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="99"/>
+        <location filename="codeeditstyledialog.cpp" line="110"/>
         <source>Quote Font Weight</source>
-        <translation type="unfinished"></translation>
+        <translation>引用字体大小</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="102"/>
+        <location filename="codeeditstyledialog.cpp" line="113"/>
         <source>Comment Foreground Color</source>
-        <translation type="unfinished"></translation>
+        <translation>注释前景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="105"/>
+        <location filename="codeeditstyledialog.cpp" line="116"/>
         <source>Comment Font Weight</source>
-        <translation type="unfinished"></translation>
+        <translation>注释字体大小</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="108"/>
+        <location filename="codeeditstyledialog.cpp" line="119"/>
         <source>Symbol Foreground Color</source>
-        <translation type="unfinished"></translation>
+        <translation>符号前景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="111"/>
+        <location filename="codeeditstyledialog.cpp" line="122"/>
         <source>Symbol Background Color</source>
-        <translation type="unfinished"></translation>
+        <translation>符号背景色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="114"/>
+        <location filename="codeeditstyledialog.cpp" line="125"/>
         <source>Symbol Font Weight</source>
-        <translation type="unfinished"></translation>
+        <translation>符号字体大小</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="130"/>
+        <location filename="codeeditstyledialog.cpp" line="141"/>
         <source>Set to Default Light</source>
-        <translation type="unfinished"></translation>
+        <translation>设置为默认亮色</translation>
     </message>
     <message>
-        <location filename="codeeditstyledialog.cpp" line="132"/>
+        <location filename="codeeditstyledialog.cpp" line="143"/>
         <source>Set to Default Dark</source>
+        <translation>设置为默认暗色</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="113"/>
+        <source>File</source>
+        <translation type="unfinished">文件</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="114"/>
+        <source>Line</source>
+        <translation type="unfinished">行</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="115"/>
+        <source>Severity</source>
+        <translation type="unfinished">严重性</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="116"/>
+        <source>Classification</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="117"/>
+        <source>Level</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="118"/>
+        <source>Inconclusive</source>
+        <translation type="unfinished">不确定的</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="119"/>
+        <source>Summary</source>
+        <translation type="unfinished">概要</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="120"/>
+        <source>Id</source>
+        <translation type="unfinished">Id</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="121"/>
+        <source>Guideline</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="122"/>
+        <source>Rule</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="123"/>
+        <source>Since date</source>
+        <translation type="unfinished">日期</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="124"/>
+        <source>Tags</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="125"/>
+        <source>CWE</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
 <context>
     <name>QPlatformTheme</name>
     <message>
-        <location filename="translationhandler.cpp" line="39"/>
+        <location filename="translationhandler.cpp" line="41"/>
         <source>OK</source>
-        <translation type="unfinished"></translation>
+        <translation>确定</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="40"/>
+        <location filename="translationhandler.cpp" line="42"/>
         <source>Cancel</source>
-        <translation type="unfinished"></translation>
+        <translation>取消</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="41"/>
+        <location filename="translationhandler.cpp" line="43"/>
         <source>Close</source>
-        <translation type="unfinished">关闭</translation>
+        <translation>关闭</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="42"/>
+        <location filename="translationhandler.cpp" line="44"/>
         <source>Save</source>
-        <translation type="unfinished"></translation>
+        <translation>保存</translation>
     </message>
 </context>
 <context>
     <name>ResultsTree</name>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>File</source>
-        <translation>文件</translation>
+        <translation type="vanished">文件</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Severity</source>
-        <translation>严重性</translation>
+        <translation type="vanished">严重性</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Line</source>
-        <translation>行</translation>
+        <translation type="vanished">行</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Summary</source>
-        <translation>概要</translation>
+        <translation type="vanished">概要</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="136"/>
         <source>Undefined file</source>
-        <translation>未定义文件</translation>
+        <translation type="vanished">未定义文件</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="614"/>
+        <location filename="resultstree.cpp" line="668"/>
         <source>Copy</source>
-        <translation type="unfinished"></translation>
+        <translation>复制</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="797"/>
+        <location filename="resultstree.cpp" line="836"/>
         <source>Could not find file:</source>
-        <translation type="unfinished"></translation>
+        <translation>找不到文件：</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="801"/>
+        <location filename="resultstree.cpp" line="840"/>
         <source>Please select the folder &apos;%1&apos;</source>
-        <translation type="unfinished"></translation>
+        <translation>请选择文件夹 &apos;%1&apos;</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="802"/>
+        <location filename="resultstree.cpp" line="841"/>
         <source>Select Directory &apos;%1&apos;</source>
-        <translation type="unfinished"></translation>
+        <translation>选择目录 &apos;%1&apos;</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="804"/>
+        <location filename="resultstree.cpp" line="843"/>
         <source>Please select the directory where file is located.</source>
-        <translation type="unfinished"></translation>
+        <translation>请选择文件所在的目录。</translation>
     </message>
     <message>
-        <source>[Inconclusive]</source>
-        <translation type="obsolete">[不确定的]</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="312"/>
+        <location filename="resultstree.cpp" line="373"/>
         <source>debug</source>
         <translation>调试</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="249"/>
+        <location filename="resultstree.cpp" line="307"/>
         <source>note</source>
-        <translation type="unfinished"></translation>
+        <translation>注意</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="613"/>
         <source>Recheck</source>
-        <translation type="unfinished"></translation>
+        <translation type="vanished">重新检查</translation>
     </message>
     <message>
-        <source>Copy filename</source>
-        <translation type="obsolete">复制文件名</translation>
-    </message>
-    <message>
-        <source>Copy full path</source>
-        <translation type="obsolete">复制完整路径</translation>
+        <source>Hide</source>
+        <translation type="vanished">隐藏</translation>
     </message>
     <message>
-        <source>Copy message</source>
-        <translation type="obsolete">复制消息</translation>
+        <location filename="resultstree.cpp" line="670"/>
+        <source>Hide all with id</source>
+        <translation>隐藏全部 ID</translation>
     </message>
     <message>
-        <source>Copy message id</source>
-        <translation type="obsolete">复制消息 ID</translation>
+        <location filename="resultstree.cpp" line="692"/>
+        <source>Suppress selected id(s)</source>
+        <translation>抑制选择的 ID</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="615"/>
-        <source>Hide</source>
-        <translation>隐藏</translation>
+        <location filename="resultstree.cpp" line="671"/>
+        <source>Open containing folder</source>
+        <translation>打开包含的文件夹</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="616"/>
-        <source>Hide all with id</source>
+        <location filename="resultstree.cpp" line="376"/>
+        <source>internal</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="617"/>
-        <source>Suppress selected id(s)</source>
+        <location filename="resultstree.cpp" line="667"/>
+        <source>Recheck %1 file(s)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="618"/>
-        <source>Open containing folder</source>
+        <location filename="resultstree.cpp" line="669"/>
+        <source>Hide %1 result(s)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="648"/>
-        <location filename="resultstree.cpp" line="1343"/>
+        <location filename="resultstree.cpp" line="712"/>
         <source>Tag</source>
-        <translation type="unfinished"></translation>
+        <translation>标记</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="650"/>
+        <location filename="resultstree.cpp" line="714"/>
         <source>No tag</source>
-        <translation type="unfinished"></translation>
+        <translation>取消标记</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="693"/>
-        <location filename="resultstree.cpp" line="707"/>
+        <location filename="resultstree.cpp" line="744"/>
+        <location filename="resultstree.cpp" line="758"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="694"/>
+        <location filename="resultstree.cpp" line="745"/>
         <source>No editor application configured.
 
 Configure the editor application for Cppcheck in preferences/Applications.</source>
@@ -2120,7 +2490,7 @@ Configure the editor application for Cppcheck in preferences/Applications.</sour
 在“首先项 / 应用程序”中为 Cppcheck 配置编辑应用程序。</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="708"/>
+        <location filename="resultstree.cpp" line="759"/>
         <source>No default editor application selected.
 
 Please select the default editor application in preferences/Applications.</source>
@@ -2129,12 +2499,12 @@ Please select the default editor application in preferences/Applications.</sourc
 请在“首先项 / 应用程序”中选择默认应用程序。</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="737"/>
+        <location filename="resultstree.cpp" line="779"/>
         <source>Could not find the file!</source>
         <translation>找不到文件！</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="783"/>
+        <location filename="resultstree.cpp" line="822"/>
         <source>Could not start %1
 
 Please check the application path and parameters are correct.</source>
@@ -2143,60 +2513,49 @@ Please check the application path and parameters are correct.</source>
 请检查此应用程序的路径与参数是否正确。</translation>
     </message>
     <message>
-        <source>Could not find file:
-%1
-Please select the directory where file is located.</source>
-        <translation type="obsolete">无法找到文件:
-%1
-请选择文件所在目录。</translation>
-    </message>
-    <message>
-        <location filename="resultstree.cpp" line="805"/>
+        <location filename="resultstree.cpp" line="844"/>
         <source>Select Directory</source>
         <translation>选择目录</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Id</source>
-        <translation>Id</translation>
+        <translation type="vanished">Id</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Inconclusive</source>
-        <translation type="unfinished"></translation>
+        <translation type="vanished">不确定的</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="1343"/>
         <source>Since date</source>
-        <translation type="unfinished"></translation>
+        <translation type="vanished">日期</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="294"/>
+        <location filename="resultstree.cpp" line="355"/>
         <source>style</source>
         <translation>风格</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="297"/>
+        <location filename="resultstree.cpp" line="358"/>
         <source>error</source>
         <translation>错误</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="300"/>
+        <location filename="resultstree.cpp" line="361"/>
         <source>warning</source>
         <translation>警告</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="303"/>
+        <location filename="resultstree.cpp" line="364"/>
         <source>performance</source>
         <translation>性能</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="306"/>
+        <location filename="resultstree.cpp" line="367"/>
         <source>portability</source>
         <translation>移植可能性</translation>
     </message>
     <message>
-        <location filename="resultstree.cpp" line="309"/>
+        <location filename="resultstree.cpp" line="370"/>
         <source>information</source>
         <translation>信息</translation>
     </message>
@@ -2209,101 +2568,122 @@ Please select the directory where file is located.</source>
         <translation>结果</translation>
     </message>
     <message>
-        <location filename="resultsview.ui" line="82"/>
-        <source>Analysis Log</source>
+        <location filename="resultsview.ui" line="60"/>
+        <source>Critical errors</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.ui" line="104"/>
-        <source>Warning Details</source>
-        <translation type="unfinished"></translation>
+        <location filename="resultsview.ui" line="92"/>
+        <source>Analysis Log</source>
+        <translation>分析日志</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="159"/>
-        <source>No errors found, nothing to save.</source>
-        <translation>未发现错误，没有结果可保存。</translation>
+        <location filename="resultsview.ui" line="114"/>
+        <source>Warning Details</source>
+        <translation>警告详情</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="183"/>
-        <location filename="resultsview.cpp" line="191"/>
+        <location filename="resultsview.cpp" line="237"/>
+        <location filename="resultsview.cpp" line="245"/>
         <source>Failed to save the report.</source>
         <translation>保存报告失败。</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="201"/>
+        <location filename="resultsview.cpp" line="255"/>
         <source>Print Report</source>
-        <translation type="unfinished"></translation>
+        <translation>打印报告</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="220"/>
+        <location filename="resultsview.cpp" line="274"/>
         <source>No errors found, nothing to print.</source>
-        <translation type="unfinished"></translation>
+        <translation>没有错误发现，没有可打印内容。</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="264"/>
+        <location filename="resultsview.cpp" line="326"/>
         <source>%p% (%1 of %2 files checked)</source>
         <translation>%p% (%2 个文件已检查 %1 个)</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="277"/>
-        <location filename="resultsview.cpp" line="288"/>
+        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="361"/>
         <source>Cppcheck</source>
         <translation>Cppcheck</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="278"/>
+        <location filename="resultsview.cpp" line="351"/>
         <source>No errors found.</source>
         <translation>未发现错误。</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="285"/>
+        <location filename="resultsview.cpp" line="358"/>
         <source>Errors were found, but they are configured to be hidden.
 To toggle what kind of errors are shown, open view menu.</source>
         <translation>发现错误，但它们被设为隐藏。
 打开“查看”菜单，切换需要显示的错误。</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="331"/>
-        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="421"/>
         <source>Failed to read the report.</source>
         <translation>读取报告失败。</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="338"/>
+        <location filename="resultsview.cpp" line="409"/>
         <source>XML format version 1 is no longer supported.</source>
-        <translation type="unfinished"></translation>
+        <translation>不再支持 XML 格式版本 1。</translation>
     </message>
     <message>
-        <source>Summary</source>
-        <translation type="obsolete">概要</translation>
+        <location filename="resultsview.cpp" line="460"/>
+        <source>First included by</source>
+        <translation>首次包含于</translation>
     </message>
     <message>
-        <source>Message</source>
-        <translation type="obsolete">消息</translation>
+        <location filename="resultsview.cpp" line="465"/>
+        <source>Id</source>
+        <translation>Id</translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="399"/>
-        <source>First included by</source>
+        <source>Bug hunting analysis is incomplete</source>
+        <translation type="vanished">错误搜寻分析未完成</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="539"/>
+        <source>Clear Log</source>
+        <translation>清空日志</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="540"/>
+        <source>Copy this Log entry</source>
+        <translation>复制此日志条目</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="541"/>
+        <source>Copy complete Log</source>
+        <translation>复制完整日志</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="549"/>
+        <source>Analysis was stopped</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="402"/>
-        <source>Id</source>
-        <translation>Id</translation>
+        <location filename="resultsview.cpp" line="563"/>
+        <source>There was a critical error with id &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="471"/>
-        <source>Clear Log</source>
+        <location filename="resultsview.cpp" line="565"/>
+        <source>when checking %1</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="472"/>
-        <source>Copy this Log entry</source>
+        <location filename="resultsview.cpp" line="567"/>
+        <source>when checking a file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="resultsview.cpp" line="473"/>
-        <source>Copy complete Log</source>
+        <location filename="resultsview.cpp" line="568"/>
+        <source>Analysis was aborted.</source>
         <translation type="unfinished"></translation>
     </message>
 </context>
@@ -2317,12 +2697,12 @@ To toggle what kind of errors are shown, open view menu.</source>
     <message>
         <location filename="scratchpad.ui" line="20"/>
         <source>Copy or write some C/C++ code here:</source>
-        <translation type="unfinished"></translation>
+        <translation>在这里复制或输入一些 C/C++ 代码：</translation>
     </message>
     <message>
         <location filename="scratchpad.ui" line="37"/>
         <source>Optionally enter a filename (mainly for automatic language detection) and click on &quot;Check&quot;:</source>
-        <translation type="unfinished"></translation>
+        <translation>可选择输入文件名 (主要用来自动语言检测) 然后点击 &quot;检查&quot;：</translation>
     </message>
     <message>
         <location filename="scratchpad.ui" line="71"/>
@@ -2348,514 +2728,517 @@ To toggle what kind of errors are shown, open view menu.</source>
         <translation>常规</translation>
     </message>
     <message>
-        <source>Include paths:</source>
-        <translation type="obsolete">Include 路径:</translation>
-    </message>
-    <message>
-        <location filename="settings.ui" line="195"/>
+        <location filename="settings.ui" line="196"/>
         <source>Add...</source>
         <translation>添加...</translation>
     </message>
     <message>
         <location filename="settings.ui" line="41"/>
         <source>Number of threads: </source>
-        <translation>线程个数:</translation>
+        <translation>线程个数: </translation>
     </message>
     <message>
-        <location filename="settings.ui" line="85"/>
         <source>Ideal count:</source>
-        <translation>理想个数:</translation>
+        <translation type="vanished">理想个数:</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="114"/>
+        <location filename="settings.ui" line="108"/>
         <source>Force checking all #ifdef configurations</source>
         <oldsource>Check all #ifdef configurations</oldsource>
         <translation>强制检查所有 #ifdef 配置</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="121"/>
+        <location filename="settings.ui" line="115"/>
         <source>Show full path of files</source>
         <translation>显示文件的完整路径</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="128"/>
+        <location filename="settings.ui" line="122"/>
         <source>Show &quot;No errors found&quot; message when no errors found</source>
         <translation>当未找到错误，显示“未发现错误”消息</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="135"/>
+        <location filename="settings.ui" line="129"/>
         <source>Display error Id in column &quot;Id&quot;</source>
         <translation>在列“Id”中显示错误 Id</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="142"/>
+        <location filename="settings.ui" line="136"/>
         <source>Enable inline suppressions</source>
         <translation>启用内联方案</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="149"/>
+        <location filename="settings.ui" line="143"/>
         <source>Check for inconclusive errors also</source>
-        <translation type="unfinished"></translation>
+        <translation>检查不确定的错误</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="156"/>
+        <location filename="settings.ui" line="150"/>
         <source>Show statistics on check completion</source>
+        <translation>检查完成后显示统计数据</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="157"/>
+        <source>Check for updates</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="settings.ui" line="176"/>
+        <location filename="settings.ui" line="177"/>
         <source>Show internal warnings in log</source>
-        <translation type="unfinished"></translation>
+        <translation>在日志中显示内建警告</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="287"/>
+        <location filename="settings.ui" line="288"/>
         <source>Addons</source>
-        <translation type="unfinished"></translation>
+        <translation>插件</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="293"/>
+        <location filename="settings.ui" line="294"/>
         <source>Python binary (leave this empty to use python in the PATH)</source>
-        <translation type="unfinished"></translation>
+        <translation>Python 二进制 (留空将使用 PATH 路径中的 python)</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="302"/>
-        <location filename="settings.ui" line="334"/>
-        <location filename="settings.ui" line="379"/>
+        <location filename="settings.ui" line="305"/>
+        <location filename="settings.ui" line="346"/>
+        <location filename="settings.ui" line="391"/>
         <source>...</source>
-        <translation type="unfinished"></translation>
+        <translation>...</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="312"/>
-        <source>Misra addon</source>
-        <translation type="unfinished"></translation>
+        <location filename="settings.ui" line="324"/>
+        <source>MISRA addon</source>
+        <translation>MISRA 插件</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="320"/>
-        <source>Misra rule texts file</source>
-        <translation type="unfinished"></translation>
+        <location filename="settings.ui" line="332"/>
+        <source>MISRA rule texts file</source>
+        <translation>MISRA 规则文本文件</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="327"/>
+        <location filename="settings.ui" line="339"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
-        <translation type="unfinished"></translation>
+        <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;从 MISRA C 2012 PDF 的附录 A &amp;quot;指南摘要&amp;quot; 复制/粘贴文本到一个文本文件。&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="360"/>
+        <location filename="settings.ui" line="372"/>
         <source>Clang</source>
-        <translation type="unfinished"></translation>
+        <translation>Clang</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="366"/>
+        <location filename="settings.ui" line="378"/>
         <source>Clang path (leave empty to use system PATH)</source>
-        <translation type="unfinished"></translation>
+        <translation>Clang 路径 (留空将使用系统 PATH 路径)</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="389"/>
+        <location filename="settings.ui" line="401"/>
         <source>Visual Studio headers</source>
-        <translation type="unfinished"></translation>
+        <translation>Visual Studio 头文件</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="395"/>
+        <location filename="settings.ui" line="407"/>
         <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Paths to Visual Studio headers, separated by semicolon &apos;;&apos;.&lt;/p&gt;&lt;p&gt;You can open a Visual Studio command prompt, write &amp;quot;SET INCLUDE&amp;quot;. Then copy/paste the paths.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
-        <translation type="unfinished"></translation>
+        <translation>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Visual Studio 头文件路径，用分号 &apos;;&apos; 分割。&lt;/p&gt;&lt;p&gt;你可以打开一个 Visual Studio 命令提示符，输入 &amp;quot;SET INCLUDE&amp;quot;。然后复制/粘贴路径。&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="425"/>
+        <location filename="settings.ui" line="437"/>
         <source>Code Editor</source>
-        <translation type="unfinished"></translation>
+        <translation>代码编辑器</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="431"/>
+        <location filename="settings.ui" line="443"/>
         <source>Code Editor Style</source>
-        <translation type="unfinished"></translation>
+        <translation>代码编辑器风格</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="437"/>
+        <location filename="settings.ui" line="449"/>
         <source>System Style</source>
-        <translation type="unfinished"></translation>
+        <translation>系统风格</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="444"/>
+        <location filename="settings.ui" line="456"/>
         <source>Default Light Style</source>
-        <translation type="unfinished"></translation>
+        <translation>默认浅色风格</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="451"/>
+        <location filename="settings.ui" line="463"/>
         <source>Default Dark Style</source>
-        <translation type="unfinished"></translation>
+        <translation>默认深色风格</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="460"/>
+        <location filename="settings.ui" line="472"/>
         <source>Custom</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <source>Paths</source>
-        <translation type="obsolete">路径</translation>
-    </message>
-    <message>
-        <source>Edit</source>
-        <translation type="obsolete">编辑</translation>
+        <translation>自定义</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="209"/>
+        <location filename="settings.ui" line="210"/>
         <source>Remove</source>
         <translation>移除</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="184"/>
+        <location filename="settings.ui" line="79"/>
+        <source>Max count:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="185"/>
         <source>Applications</source>
         <translation>应用程序</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="202"/>
-        <location filename="settings.ui" line="467"/>
+        <location filename="settings.ui" line="203"/>
+        <location filename="settings.ui" line="479"/>
         <source>Edit...</source>
         <translation>编辑...</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="216"/>
+        <location filename="settings.ui" line="217"/>
         <source>Set as default</source>
         <translation>设为默认</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="239"/>
+        <location filename="settings.ui" line="240"/>
         <source>Reports</source>
         <translation>报告</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="245"/>
+        <location filename="settings.ui" line="246"/>
         <source>Save all errors when creating report</source>
         <translation>创建报告时，保存所有错误</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="252"/>
+        <location filename="settings.ui" line="253"/>
         <source>Save full path to files in reports</source>
         <translation>在报告中保存文件的完整路径</translation>
     </message>
     <message>
-        <location filename="settings.ui" line="273"/>
+        <location filename="settings.ui" line="274"/>
         <source>Language</source>
         <translation>语言</translation>
     </message>
-    <message>
-        <source>Advanced</source>
-        <translation type="obsolete">高级</translation>
-    </message>
-    <message>
-        <source>&amp;Show inconclusive errors</source>
-        <translation type="obsolete">显示不确定的错误(&amp;S)</translation>
-    </message>
-    <message>
-        <source>S&amp;how internal warnings in log</source>
-        <translation type="obsolete">在日记中显示内部警告(&amp;H)</translation>
-    </message>
 </context>
 <context>
     <name>SettingsDialog</name>
     <message>
-        <location filename="settingsdialog.cpp" line="100"/>
         <source>N/A</source>
-        <translation>N/A</translation>
+        <translation type="vanished">N/A</translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="232"/>
+        <source>The executable file &quot;%1&quot; is not available</source>
+        <translation>可执行文件 &quot;%1&quot; 不可用</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="200"/>
+        <location filename="settingsdialog.cpp" line="243"/>
         <source>Add a new application</source>
         <translation>添加一个新的应用程序</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="233"/>
+        <location filename="settingsdialog.cpp" line="273"/>
         <source>Modify an application</source>
         <translation>修改一个应用程序</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="238"/>
+        <location filename="settingsdialog.cpp" line="278"/>
         <source> [Default]</source>
-        <translation type="unfinished"></translation>
+        <translation> [默认]</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="263"/>
+        <location filename="settingsdialog.cpp" line="303"/>
         <source>[Default]</source>
         <translation>[默认]</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="318"/>
+        <location filename="settingsdialog.cpp" line="358"/>
         <source>Select python binary</source>
-        <translation type="unfinished"></translation>
+        <translation>选择 python 二进制</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="325"/>
+        <location filename="settingsdialog.cpp" line="365"/>
         <source>Select MISRA File</source>
-        <translation type="unfinished"></translation>
+        <translation>选择 MISRA 文件</translation>
     </message>
     <message>
-        <location filename="settingsdialog.cpp" line="356"/>
+        <location filename="settingsdialog.cpp" line="396"/>
         <source>Select clang path</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <source>Select include directory</source>
-        <translation type="obsolete">选择包含目录</translation>
+        <translation>选择 clang 路径</translation>
     </message>
 </context>
 <context>
     <name>StatsDialog</name>
     <message>
-        <location filename="stats.ui" line="14"/>
-        <location filename="stats.ui" line="248"/>
-        <location filename="statsdialog.cpp" line="137"/>
-        <location filename="statsdialog.cpp" line="184"/>
+        <location filename="statsdialog.ui" line="14"/>
+        <location filename="statsdialog.ui" line="248"/>
+        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="230"/>
         <source>Statistics</source>
         <translation>统计</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="27"/>
-        <location filename="statsdialog.cpp" line="175"/>
+        <location filename="statsdialog.ui" line="27"/>
+        <location filename="statsdialog.cpp" line="221"/>
         <source>Project</source>
         <translation>项目</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="33"/>
+        <location filename="statsdialog.ui" line="33"/>
         <source>Project:</source>
         <translation>项目:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="53"/>
+        <location filename="statsdialog.ui" line="53"/>
         <source>Paths:</source>
         <translation>路径:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="85"/>
+        <location filename="statsdialog.ui" line="85"/>
         <source>Include paths:</source>
         <translation>包含路径:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="108"/>
+        <location filename="statsdialog.ui" line="108"/>
         <source>Defines:</source>
         <translation>定义:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="131"/>
+        <location filename="statsdialog.ui" line="131"/>
         <source>Undefines:</source>
-        <translation type="unfinished"></translation>
+        <translation>未定义：</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="165"/>
-        <location filename="statsdialog.cpp" line="180"/>
+        <location filename="statsdialog.ui" line="165"/>
+        <location filename="statsdialog.cpp" line="226"/>
         <source>Previous Scan</source>
         <translation>上一次扫描</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="171"/>
+        <location filename="statsdialog.ui" line="171"/>
         <source>Path Selected:</source>
         <translation>选中的路径:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="181"/>
+        <location filename="statsdialog.ui" line="181"/>
         <source>Number of Files Scanned:</source>
         <translation>扫描的文件数:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="201"/>
+        <location filename="statsdialog.ui" line="201"/>
         <source>Scan Duration:</source>
         <translation>扫描时间:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="256"/>
+        <location filename="statsdialog.ui" line="254"/>
         <source>Errors:</source>
         <translation>错误:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="274"/>
+        <location filename="statsdialog.ui" line="271"/>
         <source>Warnings:</source>
         <translation>警告:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="292"/>
+        <location filename="statsdialog.ui" line="288"/>
         <source>Stylistic warnings:</source>
         <translation>Stylistic 警告:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="310"/>
+        <location filename="statsdialog.ui" line="305"/>
         <source>Portability warnings:</source>
         <translation>可移植性警告:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="328"/>
+        <location filename="statsdialog.ui" line="322"/>
         <source>Performance issues:</source>
         <translation>性能警告:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="346"/>
+        <location filename="statsdialog.ui" line="339"/>
         <source>Information messages:</source>
         <translation>信息:</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="363"/>
-        <source>History</source>
+        <location filename="statsdialog.ui" line="356"/>
+        <source>Active checkers:</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="369"/>
-        <source>File:</source>
+        <location filename="statsdialog.ui" line="374"/>
+        <source>Checkers</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="stats.ui" line="407"/>
+        <location filename="statsdialog.ui" line="399"/>
+        <source>History</source>
+        <translation>历史</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="405"/>
+        <source>File:</source>
+        <translation>文件：</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="443"/>
         <source>Copy to Clipboard</source>
         <translation>复制到剪贴板</translation>
     </message>
     <message>
-        <location filename="stats.ui" line="414"/>
+        <location filename="statsdialog.ui" line="450"/>
         <source>Pdf Export</source>
-        <translation type="unfinished"></translation>
+        <translation>导出 PDF</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="113"/>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>1 day</source>
         <translation>1 天</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="113"/>
+        <location filename="statsdialog.cpp" line="159"/>
         <source>%1 days</source>
         <translation>%1 天</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="115"/>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>1 hour</source>
         <translation>1 小时</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="115"/>
+        <location filename="statsdialog.cpp" line="161"/>
         <source>%1 hours</source>
         <translation>%1 小时</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="117"/>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>1 minute</source>
         <translation>1 分钟</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="117"/>
+        <location filename="statsdialog.cpp" line="163"/>
         <source>%1 minutes</source>
         <translation>%1 分钟</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="119"/>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>1 second</source>
         <translation>1 秒</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="119"/>
+        <location filename="statsdialog.cpp" line="165"/>
         <source>%1 seconds</source>
         <translation>%1 秒</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="123"/>
+        <location filename="statsdialog.cpp" line="169"/>
         <source>0.%1 seconds</source>
         <translation>0.%1 秒</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="125"/>
+        <location filename="statsdialog.cpp" line="171"/>
         <source> and </source>
         <translation> 与 </translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="152"/>
+        <location filename="statsdialog.cpp" line="198"/>
         <source>Export PDF</source>
-        <translation type="unfinished"></translation>
+        <translation>导出 PDF</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="174"/>
+        <location filename="statsdialog.cpp" line="220"/>
         <source>Project Settings</source>
         <translation>项目设置</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="176"/>
+        <location filename="statsdialog.cpp" line="222"/>
         <source>Paths</source>
         <translation>路径</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="177"/>
+        <location filename="statsdialog.cpp" line="223"/>
         <source>Include paths</source>
         <translation>包含路径</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="178"/>
+        <location filename="statsdialog.cpp" line="224"/>
         <source>Defines</source>
         <translation>定义</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="179"/>
+        <location filename="statsdialog.cpp" line="225"/>
         <source>Undefines</source>
-        <translation type="unfinished"></translation>
+        <translation>未定义</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="181"/>
+        <location filename="statsdialog.cpp" line="227"/>
         <source>Path selected</source>
         <translation>选中的路径</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="182"/>
+        <location filename="statsdialog.cpp" line="228"/>
         <source>Number of files scanned</source>
         <translation>扫描的文件数</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="229"/>
         <source>Scan duration</source>
         <translation>扫描时间</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="139"/>
         <location filename="statsdialog.cpp" line="185"/>
+        <location filename="statsdialog.cpp" line="231"/>
         <source>Errors</source>
         <translation>错误</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="65"/>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>File: </source>
-        <translation type="unfinished"></translation>
+        <translation>文件: </translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="65"/>
+        <location filename="statsdialog.cpp" line="112"/>
         <source>No cppcheck build dir</source>
-        <translation type="unfinished"></translation>
+        <translation>没有 cppcheck 构建目录</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="141"/>
-        <location filename="statsdialog.cpp" line="186"/>
+        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="232"/>
         <source>Warnings</source>
         <translation>警告</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="143"/>
-        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="233"/>
         <source>Style warnings</source>
         <translation>风格警告</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="145"/>
-        <location filename="statsdialog.cpp" line="188"/>
+        <location filename="statsdialog.cpp" line="191"/>
+        <location filename="statsdialog.cpp" line="234"/>
         <source>Portability warnings</source>
         <translation>移植可能性警告</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="147"/>
-        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="193"/>
+        <location filename="statsdialog.cpp" line="235"/>
         <source>Performance warnings</source>
         <translation>性能警告</translation>
     </message>
     <message>
-        <location filename="statsdialog.cpp" line="149"/>
-        <location filename="statsdialog.cpp" line="190"/>
+        <location filename="statsdialog.cpp" line="195"/>
+        <location filename="statsdialog.cpp" line="236"/>
         <source>Information messages</source>
         <translation>信息</translation>
     </message>
 </context>
+<context>
+    <name>ThreadDetails</name>
+    <message>
+        <location filename="threaddetails.ui" line="14"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
 <context>
     <name>ThreadResult</name>
     <message>
-        <location filename="threadresult.cpp" line="54"/>
+        <location filename="threadresult.cpp" line="47"/>
         <source>%1 of %2 files checked</source>
         <translation>%2 个文件已检查 %1 个</translation>
     </message>
@@ -2863,28 +3246,28 @@ To toggle what kind of errors are shown, open view menu.</source>
 <context>
     <name>TranslationHandler</name>
     <message>
-        <location filename="translationhandler.cpp" line="145"/>
+        <location filename="translationhandler.cpp" line="130"/>
         <source>Failed to change the user interface language:
 
 %1
 
 The user interface language has been reset to English. Open the Preferences-dialog to select any of the available languages.</source>
-        <translation type="unfinished">更改用户界面语言失败:
+        <translation>更改用户界面语言失败:
 
 %1
 
 用户界面语言已被重置为英语。打开“首选项”对话框，选择任何可用的语言。</translation>
     </message>
     <message>
-        <location filename="translationhandler.cpp" line="151"/>
+        <location filename="translationhandler.cpp" line="136"/>
         <source>Cppcheck</source>
-        <translation type="unfinished">Cppcheck</translation>
+        <translation>Cppcheck</translation>
     </message>
 </context>
 <context>
     <name>TxtReport</name>
     <message>
-        <location filename="txtreport.cpp" line="73"/>
+        <location filename="txtreport.cpp" line="74"/>
         <source>inconclusive</source>
         <translation>不确定的</translation>
     </message>
@@ -2892,14 +3275,14 @@ The user interface language has been reset to English. Open the Preferences-dial
 <context>
     <name>toFilterString</name>
     <message>
-        <location filename="common.cpp" line="52"/>
+        <location filename="common.cpp" line="58"/>
         <source>All supported files (%1)</source>
-        <translation type="unfinished"></translation>
+        <translation>全部支持的文件 (%1)</translation>
     </message>
     <message>
-        <location filename="common.cpp" line="57"/>
+        <location filename="common.cpp" line="63"/>
         <source>All files (%1)</source>
-        <translation type="unfinished"></translation>
+        <translation>全部文件 (%1)</translation>
     </message>
 </context>
 </TS>
diff --git a/gui/cppcheck_zh_TW.ts b/gui/cppcheck_zh_TW.ts
new file mode 100644
index 00000000000..644e92e7b49
--- /dev/null
+++ b/gui/cppcheck_zh_TW.ts
@@ -0,0 +1,3185 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE TS>
+<TS version="2.1" language="zh_TW">
+<context>
+    <name>About</name>
+    <message>
+        <location filename="about.ui" line="14"/>
+        <source>About Cppcheck</source>
+        <translation>關於 Cppcheck</translation>
+    </message>
+    <message>
+        <location filename="about.ui" line="64"/>
+        <source>Version %1</source>
+        <translation>版本 %1</translation>
+    </message>
+    <message>
+        <location filename="about.ui" line="71"/>
+        <source>Cppcheck - A tool for static C/C++ code analysis.</source>
+        <translation>Cppcheck - 一款靜態 C/C++ 程式碼分析工具。</translation>
+    </message>
+    <message>
+        <location filename="about.ui" line="81"/>
+        <source>Copyright © 2007-%1 Cppcheck team.</source>
+        <translation>著作權 © 2007-%1 Cppcheck 團隊。</translation>
+    </message>
+    <message>
+        <location filename="about.ui" line="91"/>
+        <source>This program is licensed under the terms
+of the GNU General Public License version 3</source>
+        <translation>該程式是根據 GNU 通用公眾授權條款第 3 版
+的規定進行授權的</translation>
+    </message>
+    <message>
+        <location filename="about.ui" line="102"/>
+        <source>Visit Cppcheck homepage at %1</source>
+        <translation>訪問 Cppcheck 主頁: %1</translation>
+    </message>
+    <message>
+        <location filename="about.ui" line="115"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PCRE&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;PicoJSON&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;TinyXML2&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Boost&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <oldsource>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Many thanks to these libraries that we use:&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;pcre&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;picojson&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;qt&lt;/li&gt;&lt;li style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;tinyxml2&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</oldsource>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
+<context>
+    <name>ApplicationDialog</name>
+    <message>
+        <location filename="applicationdialog.ui" line="23"/>
+        <source>Add an application</source>
+        <translation>新增應用程式</translation>
+    </message>
+    <message>
+        <location filename="applicationdialog.ui" line="41"/>
+        <source>Here you can add an application that can open error files. Specify a name for the application, the application executable and command line parameters for the application.
+
+The following texts in parameters are replaced with appropriate values when application is executed:
+(file) - Filename containing the error
+(line) - Line number containing the error
+(message) - Error message
+(severity) - Error severity
+
+Example opening a file with Kate and make Kate scroll to the correct line:
+Executable: kate
+Parameters: -l(line) (file)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="applicationdialog.ui" line="76"/>
+        <source>&amp;Name:</source>
+        <translation>名稱(&amp;N):</translation>
+    </message>
+    <message>
+        <location filename="applicationdialog.ui" line="86"/>
+        <source>&amp;Executable:</source>
+        <translation>執行檔(&amp;E):</translation>
+    </message>
+    <message>
+        <location filename="applicationdialog.ui" line="96"/>
+        <source>&amp;Parameters:</source>
+        <translation>參數(&amp;P):</translation>
+    </message>
+    <message>
+        <location filename="applicationdialog.ui" line="138"/>
+        <source>Browse</source>
+        <translation>瀏覽</translation>
+    </message>
+    <message>
+        <location filename="applicationdialog.cpp" line="65"/>
+        <source>Executable files (*.exe);;All files(*.*)</source>
+        <translation>執行檔 (*.exe);;所有檔案 (*.*)</translation>
+    </message>
+    <message>
+        <location filename="applicationdialog.cpp" line="68"/>
+        <source>Select viewer application</source>
+        <translation>選取檢視器應用程式</translation>
+    </message>
+    <message>
+        <location filename="applicationdialog.cpp" line="83"/>
+        <source>Cppcheck</source>
+        <translation>Cppcheck</translation>
+    </message>
+    <message>
+        <location filename="applicationdialog.cpp" line="84"/>
+        <source>You must specify a name, a path and optionally parameters for the application!</source>
+        <translation>您必須為應用程式指定名稱、路徑與選用的參數！</translation>
+    </message>
+</context>
+<context>
+    <name>ComplianceReportDialog</name>
+    <message>
+        <location filename="compliancereportdialog.ui" line="14"/>
+        <source>Compliance Report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="29"/>
+        <source>Project name</source>
+        <translation>專案名稱</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="22"/>
+        <source>Project version</source>
+        <translation>專案版本</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="42"/>
+        <source>Coding Standard</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="50"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="55"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="60"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.ui" line="70"/>
+        <source>List of files with md5 checksums</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="133"/>
+        <source>Compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="135"/>
+        <source>HTML files (*.html)</source>
+        <translation>HTML 檔案 (*.html)</translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="176"/>
+        <location filename="compliancereportdialog.cpp" line="239"/>
+        <source>Save compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="compliancereportdialog.cpp" line="177"/>
+        <source>Failed to import &apos;%1&apos; (%2), can not show files in compliance report</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
+<context>
+    <name>FileViewDialog</name>
+    <message>
+        <location filename="fileviewdialog.cpp" line="53"/>
+        <source>Could not find the file: %1</source>
+        <translation>無法找到檔案: %1</translation>
+    </message>
+    <message>
+        <location filename="fileviewdialog.cpp" line="57"/>
+        <location filename="fileviewdialog.cpp" line="71"/>
+        <source>Cppcheck</source>
+        <translation>Cppcheck</translation>
+    </message>
+    <message>
+        <location filename="fileviewdialog.cpp" line="67"/>
+        <source>Could not read the file: %1</source>
+        <translation>無法讀取檔案: %1</translation>
+    </message>
+</context>
+<context>
+    <name>HelpDialog</name>
+    <message>
+        <location filename="helpdialog.ui" line="14"/>
+        <source>Cppcheck GUI help</source>
+        <translation>Cppcheck GUI 幫助</translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="34"/>
+        <source>Contents</source>
+        <translation>內容</translation>
+    </message>
+    <message>
+        <location filename="helpdialog.ui" line="44"/>
+        <source>Index</source>
+        <translation>索引</translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="84"/>
+        <source>Helpfile &apos;%1&apos; was not found</source>
+        <translation>找不到幫助檔 &apos;%1&apos;</translation>
+    </message>
+    <message>
+        <location filename="helpdialog.cpp" line="86"/>
+        <source>Cppcheck</source>
+        <translation>Cppcheck</translation>
+    </message>
+</context>
+<context>
+    <name>LibraryAddFunctionDialog</name>
+    <message>
+        <location filename="libraryaddfunctiondialog.ui" line="23"/>
+        <source>Add function</source>
+        <translation>新增函式</translation>
+    </message>
+    <message>
+        <location filename="libraryaddfunctiondialog.ui" line="34"/>
+        <source>Function name(s)</source>
+        <translation>函式名稱</translation>
+    </message>
+    <message>
+        <location filename="libraryaddfunctiondialog.ui" line="44"/>
+        <source>Number of arguments</source>
+        <translation>引數數量</translation>
+    </message>
+</context>
+<context>
+    <name>LibraryDialog</name>
+    <message>
+        <location filename="librarydialog.ui" line="14"/>
+        <source>Library Editor</source>
+        <translation>程式庫編輯器</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="22"/>
+        <source>Open</source>
+        <translation>開啟</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="29"/>
+        <source>Save</source>
+        <translation>儲存</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="36"/>
+        <source>Save as</source>
+        <translation type="unfinished">另存為</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="62"/>
+        <source>Functions</source>
+        <translation>函式</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="71"/>
+        <source>Sort</source>
+        <translation>排序</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="111"/>
+        <source>Add</source>
+        <translation>新增</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="131"/>
+        <source>Filter:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="164"/>
+        <source>Comments</source>
+        <translation>註釋</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="204"/>
+        <source>noreturn</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="212"/>
+        <source>False</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="217"/>
+        <source>True</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="222"/>
+        <source>Unknown</source>
+        <translation>未知</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="232"/>
+        <source>return value must be used</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="239"/>
+        <source>ignore function in leaks checking</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="246"/>
+        <source>Arguments</source>
+        <translation>引數</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.ui" line="258"/>
+        <source>Edit</source>
+        <translation>編輯</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.cpp" line="97"/>
+        <location filename="librarydialog.cpp" line="169"/>
+        <source>Library files (*.cfg)</source>
+        <translation>程式庫檔案 (*.cfg)</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.cpp" line="99"/>
+        <source>Open library file</source>
+        <translation>開啟程式庫檔案</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.cpp" line="110"/>
+        <location filename="librarydialog.cpp" line="122"/>
+        <location filename="librarydialog.cpp" line="159"/>
+        <source>Cppcheck</source>
+        <translation>Cppcheck</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.cpp" line="111"/>
+        <source>Cannot open file %1.</source>
+        <translation>無法開啟檔案 %1。</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.cpp" line="123"/>
+        <source>Failed to load %1. %2.</source>
+        <translation>無法載入 %1. %2。</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.cpp" line="160"/>
+        <source>Cannot save file %1.</source>
+        <translation>無法儲存檔案 %1。</translation>
+    </message>
+    <message>
+        <location filename="librarydialog.cpp" line="172"/>
+        <source>Save the library as</source>
+        <translation type="unfinished">另存程式庫為</translation>
+    </message>
+</context>
+<context>
+    <name>LibraryEditArgDialog</name>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="14"/>
+        <source>Edit argument</source>
+        <translation>編輯引數</translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="20"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
+&lt;p&gt;Is bool value allowed? For instance result from comparison or from &apos;!&apos; operator.&lt;/p&gt;
+&lt;p&gt;Typically, set this if the argument is a pointer, size, etc.&lt;/p&gt;
+&lt;p&gt;Example:&lt;/p&gt;
+&lt;pre&gt;    memcmp(x, y, i == 123);   // last argument should not have a bool value&lt;/pre&gt;
+&lt;/body&gt;&lt;/html&gt;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="28"/>
+        <source>Not bool</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="35"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;
+&lt;p&gt;Is a null parameter value allowed?&lt;/p&gt;
+&lt;p&gt;Typically this should be used on any pointer parameter that does not allow null.&lt;/p&gt;
+&lt;p&gt;Example:&lt;/p&gt;
+&lt;pre&gt;    strcpy(x,y); // neither x or y is allowed to be null.&lt;/pre&gt;
+&lt;/body&gt;&lt;/html&gt;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="43"/>
+        <source>Not null</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="50"/>
+        <source>Not uninit</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="57"/>
+        <source>String</source>
+        <translation>字串</translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="70"/>
+        <source>Format string</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="92"/>
+        <source>Min size of buffer</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="101"/>
+        <location filename="libraryeditargdialog.ui" line="203"/>
+        <source>Type</source>
+        <translation>型別</translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="109"/>
+        <location filename="libraryeditargdialog.ui" line="214"/>
+        <source>None</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="114"/>
+        <location filename="libraryeditargdialog.ui" line="219"/>
+        <source>argvalue</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="119"/>
+        <location filename="libraryeditargdialog.ui" line="224"/>
+        <source>mul</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="124"/>
+        <location filename="libraryeditargdialog.ui" line="229"/>
+        <source>strlen</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="132"/>
+        <location filename="libraryeditargdialog.ui" line="237"/>
+        <source>Arg</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="159"/>
+        <location filename="libraryeditargdialog.ui" line="264"/>
+        <source>Arg2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="194"/>
+        <source>and</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="libraryeditargdialog.ui" line="310"/>
+        <source>Valid values</source>
+        <translation>有效值</translation>
+    </message>
+</context>
+<context>
+    <name>MainWindow</name>
+    <message>
+        <location filename="mainwindow.ui" line="26"/>
+        <location filename="mainwindow.ui" line="688"/>
+        <location filename="mainwindow.cpp" line="466"/>
+        <location filename="mainwindow.cpp" line="670"/>
+        <location filename="mainwindow.cpp" line="755"/>
+        <location filename="mainwindow.cpp" line="860"/>
+        <location filename="mainwindow.cpp" line="882"/>
+        <location filename="mainwindow.cpp" line="1467"/>
+        <location filename="mainwindow.cpp" line="1596"/>
+        <location filename="mainwindow.cpp" line="1937"/>
+        <location filename="mainwindow.cpp" line="1945"/>
+        <location filename="mainwindow.cpp" line="1999"/>
+        <location filename="mainwindow.cpp" line="2008"/>
+        <location filename="mainwindow.cpp" line="2080"/>
+        <location filename="mainwindow.cpp" line="2168"/>
+        <source>Cppcheck</source>
+        <translation>Cppcheck</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="84"/>
+        <source>Checking for updates</source>
+        <translation>檢查更新</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="100"/>
+        <source>Hide</source>
+        <translation>隱藏</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="132"/>
+        <source>&amp;File</source>
+        <translation>檔案(&amp;F)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="152"/>
+        <source>&amp;View</source>
+        <translation>檢視(&amp;V)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="156"/>
+        <source>&amp;Toolbars</source>
+        <translation>工具條(&amp;T)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="164"/>
+        <location filename="mainwindow.ui" line="980"/>
+        <source>Report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="199"/>
+        <source>&amp;Help</source>
+        <translation>幫助(&amp;H)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="210"/>
+        <source>A&amp;nalyze</source>
+        <translation>分析(&amp;N)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="214"/>
+        <source>C++ standard</source>
+        <translation>C++ 標準</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="226"/>
+        <source>&amp;C standard</source>
+        <translation>C 標準(&amp;C)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="254"/>
+        <source>&amp;Edit</source>
+        <translation>編輯(&amp;E)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="267"/>
+        <source>Standard</source>
+        <translation>標準</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="285"/>
+        <source>Categories</source>
+        <translation>分類</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="304"/>
+        <source>Filter</source>
+        <translation>篩選</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="315"/>
+        <source>&amp;License...</source>
+        <translation>授權(&amp;L)...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="320"/>
+        <source>A&amp;uthors...</source>
+        <translation>作者(&amp;U)...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="329"/>
+        <source>&amp;About...</source>
+        <translation>關於(&amp;A)...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="334"/>
+        <source>&amp;Files...</source>
+        <translation>檔案(&amp;F)...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="337"/>
+        <location filename="mainwindow.ui" line="340"/>
+        <source>Analyze files</source>
+        <translation>分析檔案</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="343"/>
+        <source>Ctrl+F</source>
+        <translation>Ctrl+F</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="352"/>
+        <source>&amp;Directory...</source>
+        <translation>目錄(&amp;D)...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="355"/>
+        <location filename="mainwindow.ui" line="358"/>
+        <source>Analyze directory</source>
+        <translation>分析目錄</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="361"/>
+        <source>Ctrl+D</source>
+        <translation>Ctrl+D</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="370"/>
+        <source>&amp;Reanalyze modified files</source>
+        <translation>重新分析已修改的檔案(&amp;R)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="373"/>
+        <source>Ctrl+R</source>
+        <translation>Ctrl+R</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="382"/>
+        <source>Reanal&amp;yze all files</source>
+        <translation>重新分析所有檔案(&amp;Y)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="391"/>
+        <source>&amp;Stop</source>
+        <translation>停止(&amp;S)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="394"/>
+        <location filename="mainwindow.ui" line="397"/>
+        <source>Stop analysis</source>
+        <translation>停止分析</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="400"/>
+        <source>Esc</source>
+        <translation>Esc</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="409"/>
+        <source>&amp;Save results to file...</source>
+        <translation>儲存結果為檔案(&amp;S)...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="412"/>
+        <source>Ctrl+S</source>
+        <translation>Ctrl+S</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="417"/>
+        <source>&amp;Quit</source>
+        <translation>退出(&amp;Q)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="420"/>
+        <source>Ctrl+Q</source>
+        <translation>Ctrl+Q</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="429"/>
+        <source>&amp;Clear results</source>
+        <translation>清除結果(&amp;C)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="438"/>
+        <source>&amp;Preferences</source>
+        <translation>偏好設定(&amp;P)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="450"/>
+        <source>Style war&amp;nings</source>
+        <translation>樣式警告(&amp;N)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="453"/>
+        <location filename="mainwindow.ui" line="456"/>
+        <source>Show style warnings</source>
+        <translation>顯示樣式警告</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="468"/>
+        <source>E&amp;rrors</source>
+        <translation>錯誤(&amp;R)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="471"/>
+        <location filename="mainwindow.ui" line="474"/>
+        <location filename="mainwindow.cpp" line="2394"/>
+        <source>Show errors</source>
+        <translation>顯示錯誤</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="479"/>
+        <source>&amp;Check all</source>
+        <translation>全部檢查(&amp;C)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="484"/>
+        <source>&amp;Uncheck all</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="489"/>
+        <source>Collapse &amp;all</source>
+        <translation>全部摺疊(&amp;A)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="494"/>
+        <source>&amp;Expand all</source>
+        <translation>全部展開(&amp;E)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="502"/>
+        <source>&amp;Standard</source>
+        <translation>標準(&amp;S)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="505"/>
+        <source>Standard items</source>
+        <translatorcomment>標準項目</translatorcomment>
+        <translation></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="510"/>
+        <source>&amp;Contents</source>
+        <translation>內容(&amp;C)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="513"/>
+        <source>Open the help contents</source>
+        <translation>開啟幫助內容</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="516"/>
+        <source>F1</source>
+        <translation>F1</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="521"/>
+        <source>Toolbar</source>
+        <translation>工具條</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="529"/>
+        <source>&amp;Categories</source>
+        <translation>分類(&amp;C)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="532"/>
+        <source>Error categories</source>
+        <translation>錯誤分類</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="537"/>
+        <source>&amp;Open XML...</source>
+        <translation>開啟 XML(&amp;O)...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="546"/>
+        <source>Open P&amp;roject File...</source>
+        <translation>開啟專案檔(&amp;R)...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="549"/>
+        <source>Ctrl+Shift+O</source>
+        <translation>Ctrl+Shift+O</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="558"/>
+        <source>Sh&amp;ow Scratchpad...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="563"/>
+        <source>&amp;New Project File...</source>
+        <translation>新增專案檔(&amp;N)...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="566"/>
+        <source>Ctrl+Shift+N</source>
+        <translation>Ctrl+Shift+N</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="571"/>
+        <source>&amp;Log View</source>
+        <translation>日誌檢視(&amp;L)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="574"/>
+        <source>Log View</source>
+        <translation>日誌檢視</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="582"/>
+        <source>C&amp;lose Project File</source>
+        <translation>關閉專案檔(&amp;L)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="590"/>
+        <source>&amp;Edit Project File...</source>
+        <translation>編輯專案檔(&amp;E)...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="602"/>
+        <source>&amp;Statistics</source>
+        <translation>統計資料(&amp;S)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="614"/>
+        <source>&amp;Warnings</source>
+        <translation>警告(&amp;W)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="617"/>
+        <location filename="mainwindow.ui" line="620"/>
+        <location filename="mainwindow.cpp" line="2395"/>
+        <source>Show warnings</source>
+        <translation>顯示警告</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="632"/>
+        <source>Per&amp;formance warnings</source>
+        <translation>效能警告(&amp;F)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="635"/>
+        <location filename="mainwindow.ui" line="638"/>
+        <source>Show performance warnings</source>
+        <translation>顯示下效能警告</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="646"/>
+        <source>Show &amp;hidden</source>
+        <translation>顯示隱藏項目(&amp;H)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="658"/>
+        <source>&amp;Information</source>
+        <translation>資訊(&amp;I)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="661"/>
+        <source>Show information messages</source>
+        <translation>顯示資訊訊息</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="673"/>
+        <source>&amp;Portability</source>
+        <translation>可移植性(&amp;P)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="676"/>
+        <source>Show portability warnings</source>
+        <translation>顯示可移植性警告</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="691"/>
+        <source>Show Cppcheck results</source>
+        <translation>顯示 Cppcheck 結果</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="703"/>
+        <source>Clang</source>
+        <translation>Clang</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="706"/>
+        <source>Show Clang results</source>
+        <translation>顯示 Clang 結果</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="714"/>
+        <source>&amp;Filter</source>
+        <translation>篩選(&amp;F)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="717"/>
+        <source>Filter results</source>
+        <translation>篩選結果</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="733"/>
+        <source>Windows 32-bit ANSI</source>
+        <translation>Windows 32 位元 ANSI</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="741"/>
+        <source>Windows 32-bit Unicode</source>
+        <translation>Windows 32 位元 Unicode</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="749"/>
+        <source>Unix 32-bit</source>
+        <translation>Unix 32 位元</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="757"/>
+        <source>Unix 64-bit</source>
+        <translation>Unix 64 位元</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="765"/>
+        <source>Windows 64-bit</source>
+        <translation>Windows 64 位元</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="773"/>
+        <source>P&amp;latforms</source>
+        <translation>平臺(&amp;L)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="787"/>
+        <source>C++&amp;11</source>
+        <translation>C++&amp;11</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="798"/>
+        <source>C&amp;99</source>
+        <translation>C&amp;99</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="806"/>
+        <source>&amp;Posix</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="814"/>
+        <source>C&amp;11</source>
+        <translation>C&amp;11</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="846"/>
+        <source>&amp;C89</source>
+        <translation>&amp;C89</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="854"/>
+        <source>&amp;C++03</source>
+        <translation>&amp;C++03</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="859"/>
+        <source>&amp;Print...</source>
+        <translation>列印(&amp;P)...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="862"/>
+        <source>Print the Current Report</source>
+        <translation>列印當前報告</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="867"/>
+        <source>Print Pre&amp;view...</source>
+        <translation>列印預覽(&amp;V)...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="870"/>
+        <source>Open a Print Preview Dialog for the Current Results</source>
+        <translation>開啟當前結果的列印預覽視窗</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="875"/>
+        <source>&amp;Library Editor...</source>
+        <translation>程式庫編輯器(&amp;L)...</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="878"/>
+        <source>Open library editor</source>
+        <translation>開啟程式庫編輯器</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="886"/>
+        <source>&amp;Auto-detect language</source>
+        <translation>自動偵測語言(&amp;A)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="894"/>
+        <source>&amp;Enforce C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="902"/>
+        <source>E&amp;nforce C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="913"/>
+        <source>C++14</source>
+        <translation>C++14</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="921"/>
+        <source>Reanalyze and check library</source>
+        <translation>重新分析並檢查程式庫</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="929"/>
+        <source>Check configuration (defines, includes)</source>
+        <translation>檢查組態 (定義、包含)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="937"/>
+        <source>C++17</source>
+        <translation>C++17</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="948"/>
+        <source>C++20</source>
+        <translation>C++20</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="975"/>
+        <source>Compliance report...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="988"/>
+        <source>Normal</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="996"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1004"/>
+        <source>Misra C++ 2008</source>
+        <translation type="unfinished">Misra C++ 2008</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1012"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1020"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1028"/>
+        <source>Misra C++ 2023</source>
+        <translation type="unfinished">Misra C++ 2023</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1036"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1041"/>
+        <source>EULA...</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1046"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.ui" line="1049"/>
+        <source>Show thread details</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="main.cpp" line="100"/>
+        <source>Cppcheck GUI.
+
+Syntax:
+    cppcheck-gui [OPTIONS] [files or paths]
+
+Options:
+    -h, --help              Print this help
+    -p &lt;file&gt;               Open given project file and start checking it
+    -l &lt;file&gt;               Open given results xml file
+    -d &lt;directory&gt;          Specify the directory that was checked to generate the results xml specified with -l
+    -v, --version           Show program version
+    --data-dir=&lt;directory&gt;  This option is for installation scripts so they can configure the directory where
+                            datafiles are located (translations, cfg). The GUI is not started when this option
+                            is used.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="main.cpp" line="115"/>
+        <source>Cppcheck GUI - Command line parameters</source>
+        <translation>Cppcheck GUI - 命令行參數</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="157"/>
+        <location filename="mainwindow.cpp" line="1782"/>
+        <source>Quick Filter:</source>
+        <translation>快速篩選:</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="242"/>
+        <location filename="mainwindow.cpp" line="1784"/>
+        <location filename="mainwindow.cpp" line="1850"/>
+        <location filename="mainwindow.cpp" line="2048"/>
+        <source>Project:</source>
+        <translation>專案:</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="461"/>
+        <source>There was a problem with loading the editor application settings.
+
+This is probably because the settings were changed between the Cppcheck versions. Please check (and fix) the editor application settings, otherwise the editor program might not start correctly.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="671"/>
+        <source>No suitable files found to analyze!</source>
+        <translation>找不到適合的檔案來分析！</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="756"/>
+        <source>You must close the project file before selecting new files or directories!</source>
+        <translation>您必須在選取新檔案或目錄之前關閉該專案檔！</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="770"/>
+        <source>C/C++ Source</source>
+        <translation>C/C++ 來源檔</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="771"/>
+        <source>Compile database</source>
+        <translation>編譯資料庫</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="772"/>
+        <source>Visual Studio</source>
+        <translation>Visual Studio</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="773"/>
+        <source>Borland C++ Builder 6</source>
+        <translation>Borland C++ Builder 6</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="776"/>
+        <source>Select files to analyze</source>
+        <translation>選取要分析的檔案</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="791"/>
+        <source>Select directory to analyze</source>
+        <translation>選取要分析的目錄</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="831"/>
+        <source>Select configuration</source>
+        <translation>選取組態</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="831"/>
+        <source>Select the configuration that will be analyzed</source>
+        <translation>選取要分析的組態</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="861"/>
+        <source>Found project file: %1
+
+Do you want to load this project file instead?</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="883"/>
+        <source>Found project files from the directory.
+
+Do you want to proceed analysis without using any of these project files?</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="986"/>
+        <location filename="mainwindow.cpp" line="1024"/>
+        <source>Information</source>
+        <translation>資訊</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="986"/>
+        <source>The library &apos;%1&apos; contains unknown elements:
+%2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="995"/>
+        <source>File not found</source>
+        <translation>找不到檔案</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="998"/>
+        <source>Bad XML</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1001"/>
+        <source>Missing attribute</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1004"/>
+        <source>Bad attribute value</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1007"/>
+        <source>Unsupported format</source>
+        <translation>未支援的格式</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1010"/>
+        <source>Duplicate platform type</source>
+        <translation>重複的平臺型別</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1013"/>
+        <source>Platform type redefined</source>
+        <translation>平臺型別重定義</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1016"/>
+        <source>Duplicate define</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1019"/>
+        <source>Unknown element</source>
+        <translation>未知的元素</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1019"/>
+        <source>Unknown element</source>
+        <oldsource>Unknown issue</oldsource>
+        <translation type="unfinished">未知的議題</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1024"/>
+        <source>Failed to load the selected library &apos;%1&apos;.
+%2</source>
+        <translation>無法載入選取的程式庫 &apos;%1&apos;。
+%2</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1035"/>
+        <source>File not found: &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1058"/>
+        <source>Failed to load/setup addon %1: %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
+        <source>Error</source>
+        <translation>錯誤</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1081"/>
+        <source>Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=&lt;directory&gt; at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1091"/>
+        <source>Failed to load %1 - %2
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1103"/>
+        <location filename="mainwindow.cpp" line="1198"/>
+        <source>%1
+
+Analysis is aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1468"/>
+        <source>Current results will be cleared.
+
+Opening a new XML file will clear current results.
+Do you want to proceed?</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1483"/>
+        <location filename="mainwindow.cpp" line="1682"/>
+        <source>XML files (*.xml)</source>
+        <translation>XML 檔案 (*.xml)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1485"/>
+        <source>Open the report file</source>
+        <translation>開啟報告檔</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1592"/>
+        <source>Analyzer is running.
+
+Do you want to stop the analysis and exit Cppcheck?</source>
+        <translation>分析正在執行
+
+您想停止分析並離開 Cppcheck 嗎？</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1634"/>
+        <source>About</source>
+        <translation>關於</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1648"/>
+        <source>License</source>
+        <translation>授權</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1655"/>
+        <source>Authors</source>
+        <translation>作者</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1673"/>
+        <source>XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)</source>
+        <translation>XML 檔案 (*.xml);;文字檔 (*.txt);;CSV 檔案 (*.csv)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1675"/>
+        <source>Save the report file</source>
+        <translation>儲存報告檔</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1686"/>
+        <source>Text files (*.txt)</source>
+        <translation>文字檔 (*.txt)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1690"/>
+        <source>CSV files (*.csv)</source>
+        <translation>CSV 檔案 (*.csv)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1713"/>
+        <source>Cannot generate a compliance report right now, an analysis must finish successfully. Try to reanalyze the code and ensure there are no critical errors.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1820"/>
+        <source>Project files (*.cppcheck);;All files(*.*)</source>
+        <translation>專案檔 (*.cppcheck);;所有檔案 (*.*)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1822"/>
+        <source>Select Project File</source>
+        <translation>選取專案檔</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1938"/>
+        <source>Build dir &apos;%1&apos; does not exist, create it?</source>
+        <translation>建置目錄 &apos;%1&apos; 不存在，是否建立它？</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1946"/>
+        <source>To check the project using addons, you need a build directory.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1978"/>
+        <source>Failed to open file</source>
+        <translation>無法開啟檔案</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1981"/>
+        <source>Unknown project file format</source>
+        <translation>未知的專案檔格式</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="1984"/>
+        <source>Failed to import project file</source>
+        <translation>無法匯入專案檔</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2000"/>
+        <source>Failed to import &apos;%1&apos;: %2
+
+Analysis is stopped.</source>
+        <translation>無法匯入 &apos;%1&apos;: %2
+
+停止分析。</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2009"/>
+        <source>Failed to import &apos;%1&apos; (%2), analysis is stopped</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2367"/>
+        <source>Show Mandatory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2368"/>
+        <source>Show Required</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2369"/>
+        <source>Show Advisory</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2370"/>
+        <source>Show Document</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2387"/>
+        <source>Show L1</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2388"/>
+        <source>Show L2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2389"/>
+        <source>Show L3</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2396"/>
+        <source>Show style</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2397"/>
+        <source>Show portability</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2398"/>
+        <source>Show performance</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2399"/>
+        <source>Show information</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <source>Failed to import &apos;%1&apos;, analysis is stopped</source>
+        <translation type="vanished">無法匯入 &apos;%1&apos;，停止分析</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2033"/>
+        <source>Project files (*.cppcheck)</source>
+        <translation>專案檔 (*.cppcheck)</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2035"/>
+        <source>Select Project Filename</source>
+        <translation>選取專案檔案名稱</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2081"/>
+        <source>No project file loaded</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2163"/>
+        <source>The project file
+
+%1
+
+ could not be found!
+
+Do you want to remove the file from the recently used projects -list?</source>
+        <translation>專案檔
+
+%1
+
+ 找不到！
+
+您要從最近使用的專案列表中移除該檔案嗎？</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2325"/>
+        <source>Install</source>
+        <translation>安章</translation>
+    </message>
+    <message>
+        <location filename="mainwindow.cpp" line="2329"/>
+        <source>New version available: %1. %2</source>
+        <translation>可用的新版本: %1. %2</translation>
+    </message>
+</context>
+<context>
+    <name>NewSuppressionDialog</name>
+    <message>
+        <location filename="newsuppressiondialog.ui" line="17"/>
+        <source>New suppression</source>
+        <translation>新建抑制</translation>
+    </message>
+    <message>
+        <location filename="newsuppressiondialog.ui" line="25"/>
+        <source>Error ID</source>
+        <translation>錯誤 ID</translation>
+    </message>
+    <message>
+        <location filename="newsuppressiondialog.ui" line="32"/>
+        <source>File name</source>
+        <translation>檔案名稱</translation>
+    </message>
+    <message>
+        <location filename="newsuppressiondialog.ui" line="42"/>
+        <source>Line number</source>
+        <translation>行號</translation>
+    </message>
+    <message>
+        <location filename="newsuppressiondialog.ui" line="52"/>
+        <source>Symbol name</source>
+        <translation>符號名稱</translation>
+    </message>
+    <message>
+        <location filename="newsuppressiondialog.cpp" line="83"/>
+        <source>Edit suppression</source>
+        <translation>編輯抑制</translation>
+    </message>
+</context>
+<context>
+    <name>Platforms</name>
+    <message>
+        <location filename="platforms.cpp" line="38"/>
+        <source>Native</source>
+        <translation>原生</translation>
+    </message>
+    <message>
+        <location filename="platforms.cpp" line="39"/>
+        <source>Unix 32-bit</source>
+        <translation>Unix 32 位元</translation>
+    </message>
+    <message>
+        <location filename="platforms.cpp" line="40"/>
+        <source>Unix 64-bit</source>
+        <translation>Unix 64 位元</translation>
+    </message>
+    <message>
+        <location filename="platforms.cpp" line="41"/>
+        <source>Windows 32-bit ANSI</source>
+        <translation>Windows 32 位元 ANSI</translation>
+    </message>
+    <message>
+        <location filename="platforms.cpp" line="42"/>
+        <source>Windows 32-bit Unicode</source>
+        <translation>Windows 32 位元 Unicode</translation>
+    </message>
+    <message>
+        <location filename="platforms.cpp" line="43"/>
+        <source>Windows 64-bit</source>
+        <translation>Windows 64 位元</translation>
+    </message>
+</context>
+<context>
+    <name>ProjectFile</name>
+    <message>
+        <location filename="projectfile.ui" line="14"/>
+        <source>Project File</source>
+        <translation>專案檔</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="24"/>
+        <source>Paths and Defines</source>
+        <translation>路徑與定義</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="30"/>
+        <source>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</source>
+        <translation>匯入專案 (Visual Studio / 編譯資料庫 / Borland C++ Builder 6)</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="60"/>
+        <location filename="projectfile.ui" line="422"/>
+        <location filename="projectfile.ui" line="616"/>
+        <source>Browse...</source>
+        <translation>瀏覽...</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="73"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;You have a choice:&lt;/p&gt;&lt;p&gt; * Analyze all Debug and Release configurations&lt;/p&gt;&lt;p&gt; * Only analyze the first matching Debug configuration&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="76"/>
+        <source>Analyze all Visual Studio configurations</source>
+        <translation>分析所有 Visual Studio 組態</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="113"/>
+        <source>Selected VS Configurations</source>
+        <translation>選取 VS 組態</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="147"/>
+        <source>Paths:</source>
+        <translation>路徑:</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="181"/>
+        <location filename="projectfile.ui" line="296"/>
+        <source>Add...</source>
+        <translation>新增...</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="188"/>
+        <location filename="projectfile.ui" line="303"/>
+        <location filename="projectfile.ui" line="690"/>
+        <source>Edit</source>
+        <translation>編輯</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="195"/>
+        <location filename="projectfile.ui" line="310"/>
+        <location filename="projectfile.ui" line="697"/>
+        <location filename="projectfile.ui" line="740"/>
+        <source>Remove</source>
+        <translation>移除</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="221"/>
+        <source>Defines:</source>
+        <translation>定義:</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="231"/>
+        <source>Defines must be separated by a semicolon. Example: DEF1;DEF2=5;DEF3=int</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="242"/>
+        <source>Undefines:</source>
+        <translation>未定義:</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="252"/>
+        <source>Undefines must be separated by a semicolon. Example: UNDEF1;UNDEF2;UNDEF3</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="265"/>
+        <source>Include Paths:</source>
+        <translation>包含路徑:</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="330"/>
+        <source>Up</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="337"/>
+        <source>Down</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="362"/>
+        <source>Types and Functions</source>
+        <translation>型別與函式</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="368"/>
+        <source>Platform</source>
+        <translation>平臺</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="380"/>
+        <source>Libraries</source>
+        <translation>程式庫</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="389"/>
+        <source>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="403"/>
+        <location filename="projectfile.ui" line="488"/>
+        <source>Analysis</source>
+        <translation>分析</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="409"/>
+        <source>Cppcheck build dir (whole program analysis, incremental analysis, statistics, etc)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="415"/>
+        <source>This is a workfolder that Cppcheck will use for various purposes.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="432"/>
+        <source>Parser</source>
+        <translation>剖析器</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="438"/>
+        <source>Cppcheck (built in)</source>
+        <translation>Cppcheck (內建)</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="448"/>
+        <source>Clang (experimental)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="458"/>
+        <source>Check level</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="464"/>
+        <source>Reduced -- meant for usage where developer wants results directly. Limited and faster analysis with fewer results.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="471"/>
+        <source>Normal -- meant for normal analysis in CI. Analysis should finish in reasonable time.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="478"/>
+        <source>Exhaustive -- meant for nightly builds etc. Analysis time can be longer (10x slower than compilation is OK).</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="494"/>
+        <source>If you want to design your classes to be as flexible and robust as possible then the public interface must be very robust. Cppcheck will asumme that arguments can take *any* value.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="497"/>
+        <source>Check that each class has a safe public interface</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="513"/>
+        <source>Limit analysis</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="519"/>
+        <source>Check code in headers  (should be ON normally. if you want a limited quick analysis then turn this OFF)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="529"/>
+        <source>Check code in unused templates (should be ON normally, however in theory you can safely ignore warnings in unused templates)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="541"/>
+        <source>Max CTU depth</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="572"/>
+        <source>Max recursion in template instantiation</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="607"/>
+        <source>Premium License</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="627"/>
+        <source>Warning options</source>
+        <translation>警告選項</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="633"/>
+        <source>Root path:</source>
+        <translation>根路徑:</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="639"/>
+        <source>Filepaths in warnings will be relative to this path</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="649"/>
+        <source>Warning tags (separated by semicolon)</source>
+        <translation>警告標記 (由分號分隔)</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="655"/>
+        <source>If tags are added, you will be able to right click on warnings and set one of these tags. You can manually categorize warnings.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="665"/>
+        <source>Exclude source files</source>
+        <translation>排除來源檔</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="676"/>
+        <source>Exclude folder...</source>
+        <translation>排除資料夾...</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="683"/>
+        <source>Exclude file...</source>
+        <translation>排除檔案...</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="722"/>
+        <source>Suppressions</source>
+        <translation>抑制</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="733"/>
+        <source>Add</source>
+        <translation>新增</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="765"/>
+        <source>Enable inline suppressions</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="786"/>
+        <location filename="projectfile.ui" line="792"/>
+        <source>Addons</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="798"/>
+        <source>Note: Addons require &lt;a href=&quot;https://www.python.org/&quot;&gt;Python&lt;/a&gt; being installed.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="808"/>
+        <source>Y2038</source>
+        <translation>Y2038</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="815"/>
+        <source>Thread safety</source>
+        <translation>執行緒安全</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="825"/>
+        <source>Coding standards</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="833"/>
+        <source>Misra C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="841"/>
+        <source>2012</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="846"/>
+        <location filename="projectfile.ui" line="914"/>
+        <source>2023</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="851"/>
+        <source>2025</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="901"/>
+        <source>Misra C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="909"/>
+        <source>2008</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <source>Misra C 2012</source>
+        <translation type="vanished">Misra C 2012</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="876"/>
+        <source>MISRA rule texts</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="883"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="890"/>
+        <source>...</source>
+        <translation>...</translation>
+    </message>
+    <message>
+        <source>Misra C++ 2008</source>
+        <translation type="vanished">Misra C++ 2008</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="937"/>
+        <source>Cert C</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="946"/>
+        <source>CERT-INT35-C:  int precision (if size equals precision, you can leave empty)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="958"/>
+        <source>Cert C++</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="965"/>
+        <source>Autosar</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="972"/>
+        <source>Safety profiles (defined in C++ core guidelines)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="982"/>
+        <source>Bug hunting (Premium)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="988"/>
+        <source>Bug hunting</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="998"/>
+        <source>External tools</source>
+        <translation>外部工具</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="1004"/>
+        <source>Clang-tidy</source>
+        <translation>Clang-tidy</translation>
+    </message>
+    <message>
+        <location filename="projectfile.ui" line="1011"/>
+        <source>Clang analyzer</source>
+        <translation>Clang 分析器</translation>
+    </message>
+</context>
+<context>
+    <name>ProjectFileDialog</name>
+    <message>
+        <location filename="projectfiledialog.cpp" line="138"/>
+        <source>Project file: %1</source>
+        <translation>專案檔: %1</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="396"/>
+        <source>Note: Open source Cppcheck does not fully implement Misra C 2012</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="461"/>
+        <source>Clang-tidy (not found)</source>
+        <translation>Clang-tidy (找不到)</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="590"/>
+        <source>Select Cppcheck build dir</source>
+        <translation>選取 Cppcheck 建置目錄</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="629"/>
+        <source>Visual Studio</source>
+        <translation>Visual Studio</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="630"/>
+        <source>Compile database</source>
+        <translation>編譯資料庫</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="631"/>
+        <source>Borland C++ Builder 6</source>
+        <translation>Borland C++ Builder 6</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="632"/>
+        <source>Import Project</source>
+        <translation>匯入專案</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="831"/>
+        <source>Select a directory to check</source>
+        <translation>選取要檢查的目錄</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="851"/>
+        <source>Select include directory</source>
+        <translation>選取包含目錄</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="871"/>
+        <source>Select directory to ignore</source>
+        <translation>選取要忽略的目錄</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="879"/>
+        <source>Source files</source>
+        <translation>來源檔</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="880"/>
+        <source>All files</source>
+        <translation>所有檔案</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="881"/>
+        <source>Exclude file</source>
+        <translation>排除檔案</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="964"/>
+        <source>Select MISRA rule texts file</source>
+        <translation>選取 MISRA 規則文字檔</translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="966"/>
+        <source>MISRA rule texts file (%1)</source>
+        <translation>MISRA 規則文字檔 (%1)</translation>
+    </message>
+</context>
+<context>
+    <name>QObject</name>
+    <message>
+        <location filename="codeeditstylecontrols.cpp" line="76"/>
+        <source>Thin</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="codeeditstylecontrols.cpp" line="78"/>
+        <source>ExtraLight</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="codeeditstylecontrols.cpp" line="80"/>
+        <source>Light</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="codeeditstylecontrols.cpp" line="82"/>
+        <source>Normal</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="codeeditstylecontrols.cpp" line="84"/>
+        <source>Medium</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="codeeditstylecontrols.cpp" line="86"/>
+        <source>DemiBold</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="codeeditstylecontrols.cpp" line="88"/>
+        <source>Bold</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="codeeditstylecontrols.cpp" line="90"/>
+        <source>ExtraBold</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="codeeditstylecontrols.cpp" line="92"/>
+        <source>Black</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="80"/>
+        <source>Editor Foreground Color</source>
+        <translation>編輯器前景色</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="83"/>
+        <source>Editor Background Color</source>
+        <translation>編輯器背景色</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="86"/>
+        <source>Highlight Background Color</source>
+        <translation>標明背景色</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="89"/>
+        <source>Line Number Foreground Color</source>
+        <translation>行號前景色</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="92"/>
+        <source>Line Number Background Color</source>
+        <translation>行號背景色</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="95"/>
+        <source>Keyword Foreground Color</source>
+        <translation>關鍵字前景色</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="98"/>
+        <source>Keyword Font Weight</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="101"/>
+        <source>Class Foreground Color</source>
+        <translation>類別前景色</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="104"/>
+        <source>Class Font Weight</source>
+        <translation type="unfinished">類別字型粗細</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="107"/>
+        <source>Quote Foreground Color</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="110"/>
+        <source>Quote Font Weight</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="113"/>
+        <source>Comment Foreground Color</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="116"/>
+        <source>Comment Font Weight</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="119"/>
+        <source>Symbol Foreground Color</source>
+        <translation>符號前景色</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="122"/>
+        <source>Symbol Background Color</source>
+        <translation>符號被景色</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="125"/>
+        <source>Symbol Font Weight</source>
+        <translation>符號字型粗細</translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="141"/>
+        <source>Set to Default Light</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="codeeditstyledialog.cpp" line="143"/>
+        <source>Set to Default Dark</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="cppchecklibrarydata.cpp" line="38"/>
+        <source>line %1: Unhandled element %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="cppchecklibrarydata.cpp" line="43"/>
+        <source>line %1: Mandatory attribute &apos;%2&apos; missing in &apos;%3&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="projectfiledialog.cpp" line="284"/>
+        <source> (Not found)</source>
+        <translation> (找不到)</translation>
+    </message>
+    <message>
+        <location filename="translationhandler.cpp" line="91"/>
+        <source>Unknown language specified!</source>
+        <translation>指定了未知語言！</translation>
+    </message>
+    <message>
+        <location filename="translationhandler.cpp" line="117"/>
+        <source>Language file %1 not found!</source>
+        <translation>找不到語言檔 %1！</translation>
+    </message>
+    <message>
+        <location filename="translationhandler.cpp" line="122"/>
+        <source>Failed to load translation for language %1 from file %2</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="113"/>
+        <source>File</source>
+        <translation type="unfinished">檔案</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="114"/>
+        <source>Line</source>
+        <translation type="unfinished">行號</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="115"/>
+        <source>Severity</source>
+        <translation type="unfinished">安全性</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="116"/>
+        <source>Classification</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="117"/>
+        <source>Level</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="118"/>
+        <source>Inconclusive</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="119"/>
+        <source>Summary</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="120"/>
+        <source>Id</source>
+        <translation type="unfinished">識別號</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="121"/>
+        <source>Guideline</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="122"/>
+        <source>Rule</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="123"/>
+        <source>Since date</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="124"/>
+        <source>Tags</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="125"/>
+        <source>CWE</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
+<context>
+    <name>QPlatformTheme</name>
+    <message>
+        <location filename="translationhandler.cpp" line="41"/>
+        <source>OK</source>
+        <translation>確認</translation>
+    </message>
+    <message>
+        <location filename="translationhandler.cpp" line="42"/>
+        <source>Cancel</source>
+        <translation>取消</translation>
+    </message>
+    <message>
+        <location filename="translationhandler.cpp" line="43"/>
+        <source>Close</source>
+        <translation>關閉</translation>
+    </message>
+    <message>
+        <location filename="translationhandler.cpp" line="44"/>
+        <source>Save</source>
+        <translation>儲存</translation>
+    </message>
+</context>
+<context>
+    <name>ResultsTree</name>
+    <message>
+        <source>Undefined file</source>
+        <translation type="vanished">未定義的檔案</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="307"/>
+        <source>note</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="355"/>
+        <source>style</source>
+        <translation>樣式</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="358"/>
+        <source>error</source>
+        <translation>錯誤</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="361"/>
+        <source>warning</source>
+        <translation>警告</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="364"/>
+        <source>performance</source>
+        <translation>效能</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="367"/>
+        <source>portability</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="370"/>
+        <source>information</source>
+        <translation>資訊</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="373"/>
+        <source>debug</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="376"/>
+        <source>internal</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="668"/>
+        <source>Copy</source>
+        <translation>複製</translation>
+    </message>
+    <message>
+        <source>Hide</source>
+        <translation type="vanished">隱藏</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="667"/>
+        <source>Recheck %1 file(s)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="669"/>
+        <source>Hide %1 result(s)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="670"/>
+        <source>Hide all with id</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="671"/>
+        <source>Open containing folder</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="692"/>
+        <source>Suppress selected id(s)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="712"/>
+        <source>Tag</source>
+        <translation>標記</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="714"/>
+        <source>No tag</source>
+        <translation>取消標記</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="744"/>
+        <location filename="resultstree.cpp" line="758"/>
+        <source>Cppcheck</source>
+        <translation>Cppcheck</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="745"/>
+        <source>No editor application configured.
+
+Configure the editor application for Cppcheck in preferences/Applications.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="759"/>
+        <source>No default editor application selected.
+
+Please select the default editor application in preferences/Applications.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="779"/>
+        <source>Could not find the file!</source>
+        <translation>找不到該檔案！</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="822"/>
+        <source>Could not start %1
+
+Please check the application path and parameters are correct.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="836"/>
+        <source>Could not find file:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="840"/>
+        <source>Please select the folder &apos;%1&apos;</source>
+        <translation>請選取資料夾 &apos;%1&apos;</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="841"/>
+        <source>Select Directory &apos;%1&apos;</source>
+        <translation>選取目錄 &apos;%1&apos;</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="843"/>
+        <source>Please select the directory where file is located.</source>
+        <translation>請選取資料夾所在的目錄。</translation>
+    </message>
+    <message>
+        <location filename="resultstree.cpp" line="844"/>
+        <source>Select Directory</source>
+        <translation>選取目錄</translation>
+    </message>
+    <message>
+        <source>File</source>
+        <translation type="vanished">檔案</translation>
+    </message>
+    <message>
+        <source>Severity</source>
+        <translation type="vanished">安全性</translation>
+    </message>
+    <message>
+        <source>Line</source>
+        <translation type="vanished">行號</translation>
+    </message>
+    <message>
+        <source>Id</source>
+        <translation type="vanished">識別號</translation>
+    </message>
+</context>
+<context>
+    <name>ResultsView</name>
+    <message>
+        <location filename="resultsview.ui" line="26"/>
+        <source>Results</source>
+        <translation>結果</translation>
+    </message>
+    <message>
+        <location filename="resultsview.ui" line="60"/>
+        <source>Critical errors</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.ui" line="92"/>
+        <source>Analysis Log</source>
+        <translation>分析日誌</translation>
+    </message>
+    <message>
+        <location filename="resultsview.ui" line="114"/>
+        <source>Warning Details</source>
+        <translation>警告詳細資訊</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="237"/>
+        <location filename="resultsview.cpp" line="245"/>
+        <source>Failed to save the report.</source>
+        <translation>無法載入報告。</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="255"/>
+        <source>Print Report</source>
+        <translation>列印報告</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="274"/>
+        <source>No errors found, nothing to print.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="326"/>
+        <source>%p% (%1 of %2 files checked)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="350"/>
+        <location filename="resultsview.cpp" line="361"/>
+        <source>Cppcheck</source>
+        <translation>Cppcheck</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="351"/>
+        <source>No errors found.</source>
+        <translation>找不到錯誤。</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="358"/>
+        <source>Errors were found, but they are configured to be hidden.
+To toggle what kind of errors are shown, open view menu.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="402"/>
+        <location filename="resultsview.cpp" line="421"/>
+        <source>Failed to read the report.</source>
+        <translation>無法讀取報告。</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="409"/>
+        <source>XML format version 1 is no longer supported.</source>
+        <translation>不再支援 XML 格式版本 1。</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="460"/>
+        <source>First included by</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="465"/>
+        <source>Id</source>
+        <translation>識別號</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="539"/>
+        <source>Clear Log</source>
+        <translation>清除日誌</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="540"/>
+        <source>Copy this Log entry</source>
+        <translation>複製該日誌條目</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="541"/>
+        <source>Copy complete Log</source>
+        <translation>複製完整的日誌</translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="549"/>
+        <source>Analysis was stopped</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="563"/>
+        <source>There was a critical error with id &apos;%1&apos;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="565"/>
+        <source>when checking %1</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="567"/>
+        <source>when checking a file</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="resultsview.cpp" line="568"/>
+        <source>Analysis was aborted.</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
+<context>
+    <name>ScratchPad</name>
+    <message>
+        <location filename="scratchpad.ui" line="14"/>
+        <source>Scratchpad</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="scratchpad.ui" line="20"/>
+        <source>Copy or write some C/C++ code here:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="scratchpad.ui" line="37"/>
+        <source>Optionally enter a filename (mainly for automatic language detection) and click on &quot;Check&quot;:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="scratchpad.ui" line="71"/>
+        <source>filename</source>
+        <translation>檔案名稱</translation>
+    </message>
+    <message>
+        <location filename="scratchpad.ui" line="78"/>
+        <source>Check</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
+<context>
+    <name>Settings</name>
+    <message>
+        <location filename="settings.ui" line="14"/>
+        <source>Preferences</source>
+        <translation>偏好設定</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="24"/>
+        <source>General</source>
+        <translation>一般</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="41"/>
+        <source>Number of threads: </source>
+        <translation>執行緒數量: </translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="79"/>
+        <source>Max count:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="108"/>
+        <source>Force checking all #ifdef configurations</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="115"/>
+        <source>Show full path of files</source>
+        <translation>顯示檔案的完整路徑</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="122"/>
+        <source>Show &quot;No errors found&quot; message when no errors found</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="129"/>
+        <source>Display error Id in column &quot;Id&quot;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="136"/>
+        <source>Enable inline suppressions</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="143"/>
+        <source>Check for inconclusive errors also</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="150"/>
+        <source>Show statistics on check completion</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="157"/>
+        <source>Check for updates</source>
+        <translation>檢查更新</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="177"/>
+        <source>Show internal warnings in log</source>
+        <translation>顯示日誌中的內部警告</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="185"/>
+        <source>Applications</source>
+        <translation>應用程式</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="196"/>
+        <source>Add...</source>
+        <translation>新增...</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="203"/>
+        <location filename="settings.ui" line="479"/>
+        <source>Edit...</source>
+        <translation>編輯...</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="210"/>
+        <source>Remove</source>
+        <translation>移除</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="217"/>
+        <source>Set as default</source>
+        <translation>設定為預設值</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="240"/>
+        <source>Reports</source>
+        <translation>報告</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="246"/>
+        <source>Save all errors when creating report</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="253"/>
+        <source>Save full path to files in reports</source>
+        <translation>在報告中儲存檔案的完整路徑</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="274"/>
+        <source>Language</source>
+        <translation>語言</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="288"/>
+        <source>Addons</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="294"/>
+        <source>Python binary (leave this empty to use python in the PATH)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="305"/>
+        <location filename="settings.ui" line="346"/>
+        <location filename="settings.ui" line="391"/>
+        <source>...</source>
+        <translation>...</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="324"/>
+        <source>MISRA addon</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="332"/>
+        <source>MISRA rule texts file</source>
+        <translation>MISRA 規則文字檔</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="339"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Copy/paste the text from Appendix A &amp;quot;Summary of guidelines&amp;quot; from the MISRA C 2012 pdf to a text file.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="372"/>
+        <source>Clang</source>
+        <translation>Clang</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="378"/>
+        <source>Clang path (leave empty to use system PATH)</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="401"/>
+        <source>Visual Studio headers</source>
+        <translation>Visual Studio 標頭檔</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="407"/>
+        <source>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Paths to Visual Studio headers, separated by semicolon &apos;;&apos;.&lt;/p&gt;&lt;p&gt;You can open a Visual Studio command prompt, write &amp;quot;SET INCLUDE&amp;quot;. Then copy/paste the paths.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="437"/>
+        <source>Code Editor</source>
+        <translation>程式碼編輯器</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="443"/>
+        <source>Code Editor Style</source>
+        <translation>程式碼編輯器樣式</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="449"/>
+        <source>System Style</source>
+        <translation>系統樣式</translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="456"/>
+        <source>Default Light Style</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="463"/>
+        <source>Default Dark Style</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settings.ui" line="472"/>
+        <source>Custom</source>
+        <translation>自訂</translation>
+    </message>
+</context>
+<context>
+    <name>SettingsDialog</name>
+    <message>
+        <location filename="settingsdialog.cpp" line="232"/>
+        <source>The executable file &quot;%1&quot; is not available</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="243"/>
+        <source>Add a new application</source>
+        <translation>新增一個新應用程式</translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="273"/>
+        <source>Modify an application</source>
+        <translation>修改一個應用程式</translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="278"/>
+        <source> [Default]</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="303"/>
+        <source>[Default]</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="358"/>
+        <source>Select python binary</source>
+        <translation>選取 python 二進位檔</translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="365"/>
+        <source>Select MISRA File</source>
+        <translation>選取 MISRA 檔案</translation>
+    </message>
+    <message>
+        <location filename="settingsdialog.cpp" line="396"/>
+        <source>Select clang path</source>
+        <translation>選取 clang 路徑</translation>
+    </message>
+</context>
+<context>
+    <name>StatsDialog</name>
+    <message>
+        <location filename="statsdialog.ui" line="14"/>
+        <location filename="statsdialog.ui" line="248"/>
+        <location filename="statsdialog.cpp" line="183"/>
+        <location filename="statsdialog.cpp" line="230"/>
+        <source>Statistics</source>
+        <translation>統計資料</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="27"/>
+        <location filename="statsdialog.cpp" line="221"/>
+        <source>Project</source>
+        <translation>專案</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="33"/>
+        <source>Project:</source>
+        <translation>專案:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="53"/>
+        <source>Paths:</source>
+        <translation>路徑:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="85"/>
+        <source>Include paths:</source>
+        <translation>包含路徑:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="108"/>
+        <source>Defines:</source>
+        <translation>定義:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="131"/>
+        <source>Undefines:</source>
+        <translation>未定義:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="165"/>
+        <location filename="statsdialog.cpp" line="226"/>
+        <source>Previous Scan</source>
+        <translation>上一次掃描</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="171"/>
+        <source>Path Selected:</source>
+        <translation>選取的路徑:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="181"/>
+        <source>Number of Files Scanned:</source>
+        <translation>已掃描的檔案數量:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="201"/>
+        <source>Scan Duration:</source>
+        <translation>掃描時間:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="254"/>
+        <source>Errors:</source>
+        <translation>錯誤:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="271"/>
+        <source>Warnings:</source>
+        <translation>警告:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="288"/>
+        <source>Stylistic warnings:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="305"/>
+        <source>Portability warnings:</source>
+        <translation>可移植性警告:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="322"/>
+        <source>Performance issues:</source>
+        <translation>效能議題:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="339"/>
+        <source>Information messages:</source>
+        <translation>資訊訊息:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="356"/>
+        <source>Active checkers:</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="374"/>
+        <source>Checkers</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="399"/>
+        <source>History</source>
+        <translation>歷史紀錄</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="405"/>
+        <source>File:</source>
+        <translation>檔案:</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="443"/>
+        <source>Copy to Clipboard</source>
+        <translation>複製到剪貼簿</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.ui" line="450"/>
+        <source>Pdf Export</source>
+        <translation>Pdf 匯出</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="112"/>
+        <source>File: </source>
+        <translation>檔案: </translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="112"/>
+        <source>No cppcheck build dir</source>
+        <translation>沒有 cppcheck 建置目錄</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="159"/>
+        <source>1 day</source>
+        <translation>1 天</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="159"/>
+        <source>%1 days</source>
+        <translation>%1 天</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="161"/>
+        <source>1 hour</source>
+        <translation>1 小時</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="161"/>
+        <source>%1 hours</source>
+        <translation>%1 小時</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="163"/>
+        <source>1 minute</source>
+        <translation>1 分鐘</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="163"/>
+        <source>%1 minutes</source>
+        <translation>%1 分鐘</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="165"/>
+        <source>1 second</source>
+        <translation>1 秒鐘</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="165"/>
+        <source>%1 seconds</source>
+        <translation>%1 秒鐘</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="169"/>
+        <source>0.%1 seconds</source>
+        <translation>0.%1 秒鐘</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="171"/>
+        <source> and </source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="185"/>
+        <location filename="statsdialog.cpp" line="231"/>
+        <source>Errors</source>
+        <translation>錯誤</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="187"/>
+        <location filename="statsdialog.cpp" line="232"/>
+        <source>Warnings</source>
+        <translation>警告</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="189"/>
+        <location filename="statsdialog.cpp" line="233"/>
+        <source>Style warnings</source>
+        <translation>樣式警告</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="191"/>
+        <location filename="statsdialog.cpp" line="234"/>
+        <source>Portability warnings</source>
+        <translation>可移植性警告</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="193"/>
+        <location filename="statsdialog.cpp" line="235"/>
+        <source>Performance warnings</source>
+        <translation>效能警告</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="195"/>
+        <location filename="statsdialog.cpp" line="236"/>
+        <source>Information messages</source>
+        <translation>資訊訊息</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="198"/>
+        <source>Export PDF</source>
+        <translation>匯出 PDF</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="220"/>
+        <source>Project Settings</source>
+        <translation>專案設定</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="222"/>
+        <source>Paths</source>
+        <translation>路徑</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="223"/>
+        <source>Include paths</source>
+        <translation>包含路徑</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="224"/>
+        <source>Defines</source>
+        <translation>定義</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="225"/>
+        <source>Undefines</source>
+        <translation>未定義</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="227"/>
+        <source>Path selected</source>
+        <translation>選取的路徑</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="228"/>
+        <source>Number of files scanned</source>
+        <translation>已掃描的檔案數量</translation>
+    </message>
+    <message>
+        <location filename="statsdialog.cpp" line="229"/>
+        <source>Scan duration</source>
+        <translation>掃描時間</translation>
+    </message>
+</context>
+<context>
+    <name>ThreadDetails</name>
+    <message>
+        <location filename="threaddetails.ui" line="14"/>
+        <source>Thread Details</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
+<context>
+    <name>ThreadResult</name>
+    <message>
+        <location filename="threadresult.cpp" line="47"/>
+        <source>%1 of %2 files checked</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
+<context>
+    <name>TranslationHandler</name>
+    <message>
+        <location filename="translationhandler.cpp" line="130"/>
+        <source>Failed to change the user interface language:
+
+%1
+
+The user interface language has been reset to English. Open the Preferences-dialog to select any of the available languages.</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="translationhandler.cpp" line="136"/>
+        <source>Cppcheck</source>
+        <translation></translation>
+    </message>
+</context>
+<context>
+    <name>TxtReport</name>
+    <message>
+        <location filename="txtreport.cpp" line="74"/>
+        <source>inconclusive</source>
+        <translation type="unfinished"></translation>
+    </message>
+</context>
+<context>
+    <name>toFilterString</name>
+    <message>
+        <location filename="common.cpp" line="58"/>
+        <source>All supported files (%1)</source>
+        <translation>所有支援的檔案 (%1)</translation>
+    </message>
+    <message>
+        <location filename="common.cpp" line="63"/>
+        <source>All files (%1)</source>
+        <translation>所有檔案 (%1)</translation>
+    </message>
+</context>
+</TS>
diff --git a/gui/cppchecklibrarydata.cpp b/gui/cppchecklibrarydata.cpp
index 1af78ca814f..637ad841580 100644
--- a/gui/cppchecklibrarydata.cpp
+++ b/gui/cppchecklibrarydata.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,19 +18,32 @@
 
 #include "cppchecklibrarydata.h"
 
+#include "utils.h"
+
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+#include <QObject>
+#include <QVariant>
+#include <QXmlStreamAttributes>
 #include <QXmlStreamReader>
 #include <QXmlStreamWriter>
 
 const unsigned int CppcheckLibraryData::Function::Arg::ANY = ~0U;
 const unsigned int CppcheckLibraryData::Function::Arg::VARIADIC = ~1U;
 
-CppcheckLibraryData::CppcheckLibraryData()
+NORETURN static void unhandledElement(const QXmlStreamReader &xmlReader)
 {
+    throw std::runtime_error(QObject::tr("line %1: Unhandled element %2").arg(xmlReader.lineNumber()).arg(xmlReader.name().toString()).toStdString());
 }
 
-static std::string unhandledElement(const QXmlStreamReader &xmlReader)
+NORETURN static void mandatoryAttibuteMissing(const QXmlStreamReader &xmlReader, const QString& attributeName)
 {
-    throw std::runtime_error(QObject::tr("line %1: Unhandled element %2").arg(xmlReader.lineNumber()).arg(xmlReader.name().toString()).toStdString());
+    throw std::runtime_error(QObject::tr("line %1: Mandatory attribute '%2' missing in '%3'")
+                             .arg(xmlReader.lineNumber())
+                             .arg(attributeName)
+                             .arg(xmlReader.name().toString()).toStdString());
 }
 
 static CppcheckLibraryData::Container loadContainer(QXmlStreamReader &xmlReader)
@@ -52,7 +65,7 @@ static CppcheckLibraryData::Container loadContainer(QXmlStreamReader &xmlReader)
         if (elementName == "type") {
             container.type.templateParameter = xmlReader.attributes().value("templateParameter").toString();
             container.type.string            = xmlReader.attributes().value("string").toString();
-        } else if (elementName == "size" || elementName == "access" || elementName == "other") {
+        } else if (elementName == "size" || elementName == "access" || elementName == "other" || elementName == "rangeItemRecordType") {
             const QString indexOperator = xmlReader.attributes().value("indexOperator").toString();
             if (elementName == "access" && indexOperator == "array-like")
                 container.access_arrayLike = true;
@@ -65,7 +78,7 @@ static CppcheckLibraryData::Container loadContainer(QXmlStreamReader &xmlReader)
                     break;
                 if (type != QXmlStreamReader::StartElement)
                     continue;
-                struct CppcheckLibraryData::Container::Function function;
+                CppcheckLibraryData::Container::Function function;
                 function.name   = xmlReader.attributes().value("name").toString();
                 function.action = xmlReader.attributes().value("action").toString();
                 function.yields = xmlReader.attributes().value("yields").toString();
@@ -73,7 +86,12 @@ static CppcheckLibraryData::Container loadContainer(QXmlStreamReader &xmlReader)
                     container.sizeFunctions.append(function);
                 else if (elementName == "access")
                     container.accessFunctions.append(function);
-                else
+                else if (elementName == "rangeItemRecordType") {
+                    CppcheckLibraryData::Container::RangeItemRecordType rangeItemRecordType;
+                    rangeItemRecordType.name = xmlReader.attributes().value("name").toString();
+                    rangeItemRecordType.templateParameter = xmlReader.attributes().value("templateParameter").toString();
+                    container.rangeItemRecordTypeList.append(rangeItemRecordType);
+                } else
                     container.otherFunctions.append(function);
             }
         } else {
@@ -96,6 +114,42 @@ static QString loadUndefine(const QXmlStreamReader &xmlReader)
     return xmlReader.attributes().value("name").toString();
 }
 
+static CppcheckLibraryData::SmartPointer loadSmartPointer(QXmlStreamReader &xmlReader)
+{
+    CppcheckLibraryData::SmartPointer smartPointer;
+    smartPointer.name = xmlReader.attributes().value("class-name").toString();
+    QXmlStreamReader::TokenType type;
+    while ((type = xmlReader.readNext()) != QXmlStreamReader::EndElement ||
+           xmlReader.name().toString() != "smart-pointer") {
+        if (type != QXmlStreamReader::StartElement)
+            continue;
+        const QString elementName = xmlReader.name().toString();
+        if (elementName == "unique") {
+            smartPointer.unique = true;
+        } else {
+            unhandledElement(xmlReader);
+        }
+    }
+    return smartPointer;
+}
+
+static CppcheckLibraryData::TypeChecks loadTypeChecks(QXmlStreamReader &xmlReader)
+{
+    CppcheckLibraryData::TypeChecks typeChecks;
+    QXmlStreamReader::TokenType type;
+    while ((type = xmlReader.readNext()) != QXmlStreamReader::EndElement ||
+           xmlReader.name().toString() != "type-checks") {
+        if (type != QXmlStreamReader::StartElement)
+            continue;
+        const QString elementName = xmlReader.name().toString();
+        if (elementName == "suppress" || elementName == "check") {
+            std::pair<QString, QString> entry(elementName, xmlReader.readElementText());
+            typeChecks.append(entry);
+        }
+    }
+    return typeChecks;
+}
+
 static CppcheckLibraryData::Function::Arg loadFunctionArg(QXmlStreamReader &xmlReader)
 {
     CppcheckLibraryData::Function::Arg arg;
@@ -179,6 +233,20 @@ static CppcheckLibraryData::Function loadFunction(QXmlStreamReader &xmlReader, c
             function.warn.reason       = xmlReader.attributes().value("reason").toString();
             function.warn.alternatives = xmlReader.attributes().value("alternatives").toString();
             function.warn.msg          = xmlReader.readElementText();
+        } else if (elementName == "not-overlapping-data") {
+            const QStringList attributeList {"ptr1-arg", "ptr2-arg", "size-arg", "strlen-arg"};
+            for (const QString &attr : attributeList) {
+                if (xmlReader.attributes().hasAttribute(attr)) {
+                    function.notOverlappingDataArgs[attr] = xmlReader.attributes().value(attr).toString();
+                }
+            }
+        } else if (elementName == "container") {
+            const QStringList attributeList {"action", "yields"};
+            for (const QString &attr : attributeList) {
+                if (xmlReader.attributes().hasAttribute(attr)) {
+                    function.containerAttributes[attr] = xmlReader.attributes().value(attr).toString();
+                }
+            }
         } else {
             unhandledElement(xmlReader);
         }
@@ -196,14 +264,30 @@ static CppcheckLibraryData::MemoryResource loadMemoryResource(QXmlStreamReader &
         if (type != QXmlStreamReader::StartElement)
             continue;
         const QString elementName = xmlReader.name().toString();
-        if (elementName == "alloc") {
+        if (elementName == "alloc" || elementName == "realloc") {
             CppcheckLibraryData::MemoryResource::Alloc alloc;
+            alloc.isRealloc = (elementName == "realloc");
+            alloc.noFail = (xmlReader.attributes().value("no-fail").toString() == "true");
             alloc.init = (xmlReader.attributes().value("init").toString() == "true");
+            if (xmlReader.attributes().hasAttribute("arg")) {
+                alloc.arg = xmlReader.attributes().value("arg").toInt();
+            }
+            if (alloc.isRealloc && xmlReader.attributes().hasAttribute("realloc-arg")) {
+                alloc.reallocArg = xmlReader.attributes().value("realloc-arg").toInt();
+            }
+            if (memoryresource.type == "memory") {
+                alloc.bufferSize = xmlReader.attributes().value("buffer-size").toString();
+            }
             alloc.name = xmlReader.readElementText();
             memoryresource.alloc.append(alloc);
-        } else if (elementName == "dealloc")
-            memoryresource.dealloc.append(xmlReader.readElementText());
-        else if (elementName == "use")
+        } else if (elementName == "dealloc") {
+            CppcheckLibraryData::MemoryResource::Dealloc dealloc;
+            if (xmlReader.attributes().hasAttribute("arg")) {
+                dealloc.arg = xmlReader.attributes().value("arg").toInt();
+            }
+            dealloc.name = xmlReader.readElementText();
+            memoryresource.dealloc.append(dealloc);
+        } else if (elementName == "use")
             memoryresource.use.append(xmlReader.readElementText());
         else
             unhandledElement(xmlReader);
@@ -215,11 +299,164 @@ static CppcheckLibraryData::PodType loadPodType(const QXmlStreamReader &xmlReade
 {
     CppcheckLibraryData::PodType podtype;
     podtype.name = xmlReader.attributes().value("name").toString();
+    if (podtype.name.isEmpty()) {
+        mandatoryAttibuteMissing(xmlReader, "name");
+    }
+    podtype.stdtype = xmlReader.attributes().value("stdtype").toString();
     podtype.size = xmlReader.attributes().value("size").toString();
     podtype.sign = xmlReader.attributes().value("sign").toString();
     return podtype;
 }
 
+static CppcheckLibraryData::PlatformType loadPlatformType(QXmlStreamReader &xmlReader)
+{
+    CppcheckLibraryData::PlatformType platformType;
+    platformType.name = xmlReader.attributes().value("name").toString();
+    platformType.value = xmlReader.attributes().value("value").toString();
+
+    QXmlStreamReader::TokenType type;
+    while ((type = xmlReader.readNext()) != QXmlStreamReader::EndElement ||
+           xmlReader.name().toString() != "platformtype") {
+        if (type != QXmlStreamReader::StartElement)
+            continue;
+        const QString elementName = xmlReader.name().toString();
+        if (QStringList({"unsigned", "long", "pointer", "const_ptr", "ptr_ptr"}).contains(elementName)) {
+            platformType.types.append(elementName);
+        } else if (elementName == "platform") {
+            platformType.platforms.append(xmlReader.attributes().value("type").toString());
+        } else {
+            unhandledElement(xmlReader);
+        }
+    }
+    return platformType;
+}
+
+static CppcheckLibraryData::Reflection loadReflection(QXmlStreamReader &xmlReader)
+{
+    CppcheckLibraryData::Reflection reflection;
+
+    QXmlStreamReader::TokenType type;
+    while ((type = xmlReader.readNext()) != QXmlStreamReader::EndElement ||
+           xmlReader.name().toString() != "reflection") {
+        if (type != QXmlStreamReader::StartElement)
+            continue;
+        const QString elementName = xmlReader.name().toString();
+        if (elementName == "call") {
+            CppcheckLibraryData::Reflection::Call call;
+            if (xmlReader.attributes().hasAttribute("arg")) {
+                call.arg = xmlReader.attributes().value("arg").toInt();
+            } else {
+                mandatoryAttibuteMissing(xmlReader, "arg");
+            }
+            call.name = xmlReader.readElementText();
+            reflection.calls.append(call);
+        } else {
+            unhandledElement(xmlReader);
+        }
+    }
+
+    return reflection;
+}
+
+static CppcheckLibraryData::Markup loadMarkup(QXmlStreamReader &xmlReader)
+{
+    CppcheckLibraryData::Markup markup;
+
+    QXmlStreamReader::TokenType type;
+    if (xmlReader.attributes().hasAttribute("ext")) {
+        markup.ext = xmlReader.attributes().value("ext").toString();
+    } else {
+        mandatoryAttibuteMissing(xmlReader, "ext");
+    }
+    if (xmlReader.attributes().hasAttribute("aftercode")) {
+        markup.afterCode = (xmlReader.attributes().value("aftercode") == QString("true"));
+    } else {
+        mandatoryAttibuteMissing(xmlReader, "aftercode");
+    }
+    if (xmlReader.attributes().hasAttribute("reporterrors")) {
+        markup.reportErrors = (xmlReader.attributes().value("reporterrors") == QString("true"));
+    } else {
+        mandatoryAttibuteMissing(xmlReader, "reporterrors");
+    }
+
+    while ((type = xmlReader.readNext()) != QXmlStreamReader::EndElement ||
+           xmlReader.name().toString() != "markup") {
+        if (type != QXmlStreamReader::StartElement)
+            continue;
+        const QString elementName = xmlReader.name().toString();
+        if (elementName == "keywords") {
+            while ((type = xmlReader.readNext()) != QXmlStreamReader::EndElement ||
+                   xmlReader.name().toString() != "keywords") {
+                if (type != QXmlStreamReader::StartElement)
+                    continue;
+                if (xmlReader.name().toString() == "keyword") {
+                    markup.keywords.append(xmlReader.attributes().value("name").toString());
+                } else {
+                    unhandledElement(xmlReader);
+                }
+            }
+        } else if (elementName == "codeblocks") {
+            CppcheckLibraryData::Markup::CodeBlocks codeBlock;
+
+            while ((type = xmlReader.readNext()) != QXmlStreamReader::EndElement ||
+                   xmlReader.name().toString() != "codeblocks") {
+                if (type != QXmlStreamReader::StartElement)
+                    continue;
+                if (xmlReader.name().toString() == "block") {
+                    codeBlock.blocks.append(xmlReader.attributes().value("name").toString());
+                } else if (xmlReader.name().toString() == "structure") {
+                    codeBlock.offset = xmlReader.attributes().value("offset").toInt();
+                    codeBlock.start = xmlReader.attributes().value("start").toString();
+                    codeBlock.end = xmlReader.attributes().value("end").toString();
+                } else {
+                    unhandledElement(xmlReader);
+                }
+            }
+            markup.codeBlocks.append(codeBlock);
+        } else if (elementName == "exported") {
+            CppcheckLibraryData::Markup::Exporter exporter;
+
+            while ((type = xmlReader.readNext()) != QXmlStreamReader::EndElement ||
+                   xmlReader.name().toString() != "exported") {
+                if (type != QXmlStreamReader::StartElement)
+                    continue;
+                if (xmlReader.name().toString() == "exporter") {
+                    exporter.prefix = xmlReader.attributes().value("prefix").toString();
+                } else if (xmlReader.name().toString() == "prefix") {
+                    exporter.prefixList.append(xmlReader.readElementText());
+                } else if (xmlReader.name().toString() == "suffix") {
+                    exporter.suffixList.append(xmlReader.readElementText());
+                } else {
+                    unhandledElement(xmlReader);
+                }
+            }
+            markup.exporter.append(exporter);
+        } else if (elementName == "imported") {
+            while ((type = xmlReader.readNext()) != QXmlStreamReader::EndElement ||
+                   xmlReader.name().toString() != "imported") {
+                if (type != QXmlStreamReader::StartElement)
+                    continue;
+                if (xmlReader.name().toString() == "importer") {
+                    markup.importer.append(xmlReader.readElementText());
+                } else {
+                    unhandledElement(xmlReader);
+                }
+            }
+        } else {
+            unhandledElement(xmlReader);
+        }
+    }
+
+    return markup;
+}
+
+static CppcheckLibraryData::Entrypoint loadEntrypoint(const QXmlStreamReader &xmlReader)
+{
+    CppcheckLibraryData::Entrypoint entrypoint;
+    entrypoint.name = xmlReader.attributes().value("name").toString();
+    return entrypoint;
+}
+
 QString CppcheckLibraryData::open(QIODevice &file)
 {
     clear();
@@ -250,6 +487,18 @@ QString CppcheckLibraryData::open(QIODevice &file)
                     memoryresource.append(loadMemoryResource(xmlReader));
                 else if (elementName == "podtype")
                     podtypes.append(loadPodType(xmlReader));
+                else if (elementName == "smart-pointer")
+                    smartPointers.append(loadSmartPointer(xmlReader));
+                else if (elementName == "type-checks")
+                    typeChecks.append(loadTypeChecks(xmlReader));
+                else if (elementName == "platformtype")
+                    platformTypes.append(loadPlatformType(xmlReader));
+                else if (elementName == "reflection")
+                    reflections.append(loadReflection(xmlReader));
+                else if (elementName == "markup")
+                    markups.append(loadMarkup(xmlReader));
+                else if (elementName == "entrypoint")
+                    entrypoints.append(loadEntrypoint(xmlReader));
                 else
                     unhandledElement(xmlReader);
             } catch (std::runtime_error &e) {
@@ -261,11 +510,12 @@ QString CppcheckLibraryData::open(QIODevice &file)
             break;
         }
     }
-
+    if (xmlReader.hasError())
+        return xmlReader.errorString();
     return QString();
 }
 
-static void writeContainerFunctions(QXmlStreamWriter &xmlWriter, const QString &name, int extra, const QList<struct CppcheckLibraryData::Container::Function> &functions)
+static void writeContainerFunctions(QXmlStreamWriter &xmlWriter, const QString &name, int extra, const QList<CppcheckLibraryData::Container::Function> &functions)
 {
     if (functions.isEmpty() && extra < 0)
         return;
@@ -276,7 +526,7 @@ static void writeContainerFunctions(QXmlStreamWriter &xmlWriter, const QString &
         else if (name == "size")
             xmlWriter.writeAttribute("templateParameter", QString::number(extra));
     }
-    foreach (const CppcheckLibraryData::Container::Function &function, functions) {
+    for (const CppcheckLibraryData::Container::Function &function : functions) {
         xmlWriter.writeStartElement("function");
         xmlWriter.writeAttribute("name", function.name);
         if (!function.action.isEmpty())
@@ -288,6 +538,20 @@ static void writeContainerFunctions(QXmlStreamWriter &xmlWriter, const QString &
     xmlWriter.writeEndElement();
 }
 
+static void writeContainerRangeItemRecords(QXmlStreamWriter &xmlWriter, const QList<CppcheckLibraryData::Container::RangeItemRecordType> &rangeItemRecords)
+{
+    if (rangeItemRecords.isEmpty())
+        return;
+    xmlWriter.writeStartElement("rangeItemRecordType");
+    for (const CppcheckLibraryData::Container::RangeItemRecordType &item : rangeItemRecords) {
+        xmlWriter.writeStartElement("member");
+        xmlWriter.writeAttribute("name", item.name);
+        xmlWriter.writeAttribute("templateParameter", item.templateParameter);
+        xmlWriter.writeEndElement();
+    }
+    xmlWriter.writeEndElement();
+}
+
 static void writeContainer(QXmlStreamWriter &xmlWriter, const CppcheckLibraryData::Container &container)
 {
     xmlWriter.writeStartElement("container");
@@ -314,6 +578,7 @@ static void writeContainer(QXmlStreamWriter &xmlWriter, const CppcheckLibraryDat
     writeContainerFunctions(xmlWriter, "size", container.size_templateParameter, container.sizeFunctions);
     writeContainerFunctions(xmlWriter, "access", container.access_arrayLike?1:-1, container.accessFunctions);
     writeContainerFunctions(xmlWriter, "other", -1, container.otherFunctions);
+    writeContainerRangeItemRecords(xmlWriter, container.rangeItemRecordTypeList);
     xmlWriter.writeEndElement();
 }
 
@@ -324,7 +589,7 @@ static void writeFunction(QXmlStreamWriter &xmlWriter, const CppcheckLibraryData
         comments = comments.mid(1);
     while (comments.endsWith("\n"))
         comments.chop(1);
-    foreach (const QString &comment, comments.split('\n')) {
+    for (const QString &comment : comments.split('\n')) {
         if (comment.length() >= 1)
             xmlWriter.writeComment(comment);
     }
@@ -349,11 +614,11 @@ static void writeFunction(QXmlStreamWriter &xmlWriter, const CppcheckLibraryData
         xmlWriter.writeEndElement();
     }
     if (function.noreturn != CppcheckLibraryData::Function::Unknown)
-        xmlWriter.writeTextElement("noreturn", (function.noreturn == CppcheckLibraryData::Function::True) ? "true" : "false");
+        xmlWriter.writeTextElement("noreturn", bool_to_string(function.noreturn == CppcheckLibraryData::Function::True));
     if (function.leakignore)
         xmlWriter.writeEmptyElement("leak-ignore");
     // Argument info..
-    foreach (const CppcheckLibraryData::Function::Arg &arg, function.args) {
+    for (const CppcheckLibraryData::Function::Arg &arg : function.args) {
         if (arg.formatstr) {
             xmlWriter.writeStartElement("formatstr");
             if (!function.formatstr.scan.isNull())
@@ -386,7 +651,7 @@ static void writeFunction(QXmlStreamWriter &xmlWriter, const CppcheckLibraryData
         if (!arg.valid.isEmpty())
             xmlWriter.writeTextElement("valid",arg.valid);
 
-        foreach (const CppcheckLibraryData::Function::Arg::MinSize &minsize, arg.minsizes) {
+        for (const CppcheckLibraryData::Function::Arg::MinSize &minsize : arg.minsizes) {
             xmlWriter.writeStartElement("minsize");
             xmlWriter.writeAttribute("type", minsize.type);
             xmlWriter.writeAttribute("arg", minsize.arg);
@@ -427,28 +692,173 @@ static void writeFunction(QXmlStreamWriter &xmlWriter, const CppcheckLibraryData
 
         xmlWriter.writeEndElement();
     }
-
+    if (!function.notOverlappingDataArgs.isEmpty()) {
+        xmlWriter.writeStartElement("not-overlapping-data");
+        for (const QString& value : function.notOverlappingDataArgs) {
+            xmlWriter.writeAttribute(function.notOverlappingDataArgs.key(value), value);
+        }
+        xmlWriter.writeEndElement();
+    }
+    if (!function.containerAttributes.isEmpty()) {
+        xmlWriter.writeStartElement("container");
+        for (const QString& value : function.containerAttributes) {
+            xmlWriter.writeAttribute(function.containerAttributes.key(value), value);
+        }
+        xmlWriter.writeEndElement();
+    }
     xmlWriter.writeEndElement();
 }
 
 static void writeMemoryResource(QXmlStreamWriter &xmlWriter, const CppcheckLibraryData::MemoryResource &mr)
 {
     xmlWriter.writeStartElement(mr.type);
-    foreach (const CppcheckLibraryData::MemoryResource::Alloc &alloc, mr.alloc) {
-        xmlWriter.writeStartElement("alloc");
-        xmlWriter.writeAttribute("init", alloc.init ? "true" : "false");
+    for (const CppcheckLibraryData::MemoryResource::Alloc &alloc : mr.alloc) {
+        if (alloc.isRealloc) {
+            xmlWriter.writeStartElement("realloc");
+        } else {
+            xmlWriter.writeStartElement("alloc");
+        }
+        xmlWriter.writeAttribute("init", bool_to_string(alloc.init));
+        if (alloc.noFail)
+            xmlWriter.writeAttribute("no-fail", bool_to_string(alloc.noFail));
+        if (alloc.arg != -1) {
+            xmlWriter.writeAttribute("arg", QString("%1").arg(alloc.arg));
+        }
+        if (alloc.isRealloc && alloc.reallocArg != -1) {
+            xmlWriter.writeAttribute("realloc-arg", QString("%1").arg(alloc.reallocArg));
+        }
+        if (mr.type == "memory" && !alloc.bufferSize.isEmpty()) {
+            xmlWriter.writeAttribute("buffer-size", alloc.bufferSize);
+        }
         xmlWriter.writeCharacters(alloc.name);
         xmlWriter.writeEndElement();
     }
-    foreach (const QString &dealloc, mr.dealloc) {
-        xmlWriter.writeTextElement("dealloc", dealloc);
+
+    for (const CppcheckLibraryData::MemoryResource::Dealloc &dealloc : mr.dealloc) {
+        xmlWriter.writeStartElement("dealloc");
+        if (dealloc.arg != -1) {
+            xmlWriter.writeAttribute("arg", QString("%1").arg(dealloc.arg));
+        }
+        xmlWriter.writeCharacters(dealloc.name);
+        xmlWriter.writeEndElement();
     }
-    foreach (const QString &use, mr.use) {
+
+    for (const QString &use : mr.use) {
         xmlWriter.writeTextElement("use", use);
     }
     xmlWriter.writeEndElement();
 }
 
+static void writeTypeChecks(QXmlStreamWriter &xmlWriter, const CppcheckLibraryData::TypeChecks &typeChecks)
+{
+    xmlWriter.writeStartElement("type-checks");
+    if (!typeChecks.isEmpty()) {
+        xmlWriter.writeStartElement("unusedvar");
+    }
+    for (const std::pair<QString, QString> &check : typeChecks) {
+        xmlWriter.writeStartElement(check.first);
+        xmlWriter.writeCharacters(check.second);
+        xmlWriter.writeEndElement();
+    }
+    if (!typeChecks.isEmpty()) {
+        xmlWriter.writeEndElement();
+    }
+    xmlWriter.writeEndElement();
+}
+
+static void writePlatformType(QXmlStreamWriter &xmlWriter, const CppcheckLibraryData::PlatformType &pt)
+{
+    xmlWriter.writeStartElement("platformtype");
+    xmlWriter.writeAttribute("name", pt.name);
+    xmlWriter.writeAttribute("value", pt.value);
+    for (const QString &type : pt.types) {
+        xmlWriter.writeStartElement(type);
+        xmlWriter.writeEndElement();
+    }
+    for (const QString &platform : pt.platforms) {
+        xmlWriter.writeStartElement("platform");
+        if (!platform.isEmpty()) {
+            xmlWriter.writeAttribute("type", platform);
+        }
+        xmlWriter.writeEndElement();
+    }
+    xmlWriter.writeEndElement();
+}
+
+static void writeReflection(QXmlStreamWriter &xmlWriter, const CppcheckLibraryData::Reflection &refl)
+{
+    xmlWriter.writeStartElement("reflection");
+    for (const CppcheckLibraryData::Reflection::Call &call : refl.calls) {
+        xmlWriter.writeStartElement("call");
+        xmlWriter.writeAttribute("arg", QString("%1").arg(call.arg));
+        xmlWriter.writeCharacters(call.name);
+        xmlWriter.writeEndElement();
+    }
+    xmlWriter.writeEndElement();
+}
+
+static void writeMarkup(QXmlStreamWriter &xmlWriter, const CppcheckLibraryData::Markup &mup)
+{
+    xmlWriter.writeStartElement("markup");
+    xmlWriter.writeAttribute("ext", mup.ext);
+    xmlWriter.writeAttribute("aftercode", QVariant(mup.afterCode).toString());
+    xmlWriter.writeAttribute("reporterrors", QVariant(mup.reportErrors).toString());
+    if (!mup.keywords.isEmpty()) {
+        xmlWriter.writeStartElement("keywords");
+        for (const QString &keyword : mup.keywords) {
+            xmlWriter.writeStartElement("keyword");
+            xmlWriter.writeAttribute("name", keyword);
+            xmlWriter.writeEndElement();
+        }
+        xmlWriter.writeEndElement();
+    }
+    if (!mup.importer.isEmpty()) {
+        xmlWriter.writeStartElement("imported");
+        for (const QString &import : mup.importer) {
+            xmlWriter.writeStartElement("importer");
+            xmlWriter.writeCharacters(import);
+            xmlWriter.writeEndElement();
+        }
+        xmlWriter.writeEndElement();
+    }
+    if (!mup.exporter.isEmpty()) {
+        xmlWriter.writeStartElement("exported");
+        for (const CppcheckLibraryData::Markup::Exporter &exporter : mup.exporter) {
+            xmlWriter.writeStartElement("exporter");
+            xmlWriter.writeAttribute("prefix", exporter.prefix);
+            for (const QString &prefix : exporter.prefixList) {
+                xmlWriter.writeStartElement("prefix");
+                xmlWriter.writeCharacters(prefix);
+                xmlWriter.writeEndElement();
+            }
+            for (const QString &suffix : exporter.suffixList) {
+                xmlWriter.writeStartElement("suffix");
+                xmlWriter.writeCharacters(suffix);
+                xmlWriter.writeEndElement();
+            }
+            xmlWriter.writeEndElement();
+        }
+        xmlWriter.writeEndElement();
+    }
+    if (!mup.codeBlocks.isEmpty()) {
+        for (const CppcheckLibraryData::Markup::CodeBlocks &codeblock : mup.codeBlocks) {
+            xmlWriter.writeStartElement("codeblocks");
+            for (const QString &block : codeblock.blocks) {
+                xmlWriter.writeStartElement("block");
+                xmlWriter.writeAttribute("name", block);
+                xmlWriter.writeEndElement();
+            }
+            xmlWriter.writeStartElement("structure");
+            xmlWriter.writeAttribute("offset", QString("%1").arg(codeblock.offset));
+            xmlWriter.writeAttribute("start", codeblock.start);
+            xmlWriter.writeAttribute("end", codeblock.end);
+            xmlWriter.writeEndElement();
+            xmlWriter.writeEndElement();
+        }
+    }
+    xmlWriter.writeEndElement();
+}
+
 QString CppcheckLibraryData::toString() const
 {
     QString outputString;
@@ -459,34 +869,36 @@ QString CppcheckLibraryData::toString() const
     xmlWriter.writeStartElement("def");
     xmlWriter.writeAttribute("format","2");
 
-    foreach (const Define &define, defines) {
+    for (const Define &define : defines) {
         xmlWriter.writeStartElement("define");
         xmlWriter.writeAttribute("name", define.name);
         xmlWriter.writeAttribute("value", define.value);
         xmlWriter.writeEndElement();
     }
 
-    foreach (const QString &undef, undefines) {
+    for (const QString &undef : undefines) {
         xmlWriter.writeStartElement("undefine");
         xmlWriter.writeAttribute("name", undef);
         xmlWriter.writeEndElement();
     }
 
-    foreach (const Function &function, functions) {
+    for (const Function &function : functions) {
         writeFunction(xmlWriter, function);
     }
 
-    foreach (const MemoryResource &mr, memoryresource) {
+    for (const MemoryResource &mr : memoryresource) {
         writeMemoryResource(xmlWriter, mr);
     }
 
-    foreach (const Container &container, containers) {
+    for (const Container &container : containers) {
         writeContainer(xmlWriter, container);
     }
 
-    foreach (const PodType &podtype, podtypes) {
+    for (const PodType &podtype : podtypes) {
         xmlWriter.writeStartElement("podtype");
         xmlWriter.writeAttribute("name", podtype.name);
+        if (!podtype.stdtype.isEmpty())
+            xmlWriter.writeAttribute("stdtype", podtype.stdtype);
         if (!podtype.sign.isEmpty())
             xmlWriter.writeAttribute("sign", podtype.sign);
         if (!podtype.size.isEmpty())
@@ -494,6 +906,37 @@ QString CppcheckLibraryData::toString() const
         xmlWriter.writeEndElement();
     }
 
+    for (const TypeChecks &check : typeChecks) {
+        writeTypeChecks(xmlWriter, check);
+    }
+
+    for (const SmartPointer &smartPtr : smartPointers) {
+        xmlWriter.writeStartElement("smart-pointer");
+        xmlWriter.writeAttribute("class-name", smartPtr.name);
+        if (smartPtr.unique) {
+            xmlWriter.writeEmptyElement("unique");
+        }
+        xmlWriter.writeEndElement();
+    }
+
+    for (const PlatformType &pt : platformTypes) {
+        writePlatformType(xmlWriter, pt);
+    }
+
+    for (const Reflection &refl : reflections) {
+        writeReflection(xmlWriter, refl);
+    }
+
+    for (const Markup &mup : markups) {
+        writeMarkup(xmlWriter, mup);
+    }
+
+    for (const Entrypoint &ent : entrypoints) {
+        xmlWriter.writeStartElement("entrypoint");
+        xmlWriter.writeAttribute("name", ent.name);
+        xmlWriter.writeEndElement();
+    }
+
     xmlWriter.writeEndElement();
 
     return outputString;
diff --git a/gui/cppchecklibrarydata.h b/gui/cppchecklibrarydata.h
index 93a49692db0..afe39df5050 100644
--- a/gui/cppchecklibrarydata.h
+++ b/gui/cppchecklibrarydata.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,18 +19,23 @@
 #ifndef CPPCHECKLIBRARYDATA_H
 #define CPPCHECKLIBRARYDATA_H
 
+#include "config.h"
+
+#include <cstdint>
+#include <utility>
+
 #include <QList>
+#include <QMap>
 #include <QString>
 #include <QStringList>
-#include <QIODevice>
+
+class QIODevice;
 
 class CppcheckLibraryData {
 public:
-    CppcheckLibraryData();
+    CppcheckLibraryData() = default;
 
     struct Container {
-        Container() : access_arrayLike(false), size_templateParameter(-1) {}
-
         QString id;
         QString inherits;
         QString startPattern;
@@ -38,22 +43,28 @@ class CppcheckLibraryData {
         QString opLessAllowed;
         QString itEndPattern;
 
-        bool access_arrayLike;
-        int  size_templateParameter;
+        bool access_arrayLike{};
+        int size_templateParameter = -1;
 
         struct {
             QString templateParameter;
             QString string;
         } type;
 
+        struct RangeItemRecordType {
+            QString name;
+            QString templateParameter;
+        };
+
         struct Function {
             QString name;
             QString yields;
             QString action;
         };
-        QList<struct Function> accessFunctions;
-        QList<struct Function> otherFunctions;
-        QList<struct Function> sizeFunctions;
+        QList<Function> accessFunctions;
+        QList<Function> otherFunctions;
+        QList<Function> sizeFunctions;
+        QList<RangeItemRecordType> rangeItemRecordTypeList;
     };
 
     struct Define {
@@ -62,22 +73,17 @@ class CppcheckLibraryData {
     };
 
     struct Function {
-        Function() : noreturn(Unknown), gccPure(false), gccConst(false),
-            leakignore(false), useretval(false) {
-        }
-
         QString comments;
         QString name;
-        enum TrueFalseUnknown { False, True, Unknown } noreturn;
-        bool gccPure;
-        bool gccConst;
-        bool leakignore;
-        bool useretval;
+        enum TrueFalseUnknown : std::uint8_t { False, True, Unknown } noreturn = Unknown;
+        bool gccPure{};
+        bool gccConst{};
+        bool leakignore{};
+        bool useretval{};
         struct ReturnValue {
-            ReturnValue() : container(-1) {}
             QString type;
             QString value;
-            int container;
+            int container = -1;
             bool empty() const {
                 return type.isNull() && value.isNull() && container < 0;
             }
@@ -87,34 +93,29 @@ class CppcheckLibraryData {
             QString secure;
         } formatstr;
         struct Arg {
-            Arg() : nr(0), notbool(false), notnull(false), notuninit(false),
-                formatstr(false), strz(false) {
-            }
-
             QString name;
-            unsigned int nr;
+            unsigned int nr{};
             static const unsigned int ANY;
             static const unsigned int VARIADIC;
             QString defaultValue;
-            bool notbool;
-            bool notnull;
-            bool notuninit;
-            bool formatstr;
-            bool strz;
+            bool notbool{};
+            bool notnull{};
+            bool notuninit{};
+            bool formatstr{};
+            bool strz{};
             QString valid;
             struct MinSize {
                 QString type;
                 QString arg;
                 QString arg2;
             };
-            QList<struct MinSize> minsizes;
+            QList<MinSize> minsizes;
             struct Iterator {
-                Iterator() : container(-1) {}
-                int container;
+                int container = -1;
                 QString type;
             } iterator;
         };
-        QList<struct Arg> args;
+        QList<Arg> args;
 
         struct {
             QString severity;
@@ -131,26 +132,89 @@ class CppcheckLibraryData {
                        msg.isEmpty();
             }
         } warn;
+
+        QMap<QString, QString> notOverlappingDataArgs;
+        QMap<QString, QString> containerAttributes;
     };
 
     struct MemoryResource {
         QString type; // "memory" or "resource"
         struct Alloc {
-            Alloc() : init(false) {}
-            bool init;
+            bool isRealloc{};
+            bool init{};
+            bool noFail{};
+            int arg = -1; // -1: Has no optional "realloc-arg" attribute
+            int reallocArg = -1; // -1: Has no optional "arg" attribute
+            QString bufferSize;
             QString name;
         };
-        QList<struct Alloc> alloc;
-        QStringList dealloc;
+        struct Dealloc {
+            int arg = -1; // -1: Has no optional "arg" attribute
+            QString name;
+        };
+
+        QList<Alloc> alloc;
+        QList<Dealloc> dealloc;
         QStringList use;
     };
 
     struct PodType {
         QString name;
+        QString stdtype;
         QString size;
         QString sign;
     };
 
+    struct PlatformType {
+        QString name;
+        QString value;
+        QStringList types;      // Keeps element names w/o attribute (e.g. unsigned)
+        QStringList platforms;  // Keeps "type" attribute of each "platform" element
+    };
+
+    using TypeChecks = QList<std::pair<QString, QString>>;
+
+    struct Reflection {
+        struct Call {
+            int arg = -1; // -1: Mandatory "arg" attribute not available
+            QString name;
+        };
+
+        QList<Call> calls;
+    };
+
+    struct Markup {
+        struct CodeBlocks {
+            QStringList blocks;
+            int offset = -1;
+            QString start;
+            QString end;
+        };
+
+        struct Exporter {
+            QString prefix;
+            QStringList prefixList;
+            QStringList suffixList;
+        };
+
+        QString ext;
+        bool afterCode{};
+        bool reportErrors{};
+        QStringList keywords;
+        QStringList importer;
+        QList<CodeBlocks> codeBlocks;
+        QList<Exporter> exporter;
+    };
+
+    struct SmartPointer {
+        QString name;
+        bool unique{};
+    };
+
+    struct Entrypoint {
+        QString name;
+    };
+
     void clear() {
         containers.clear();
         defines.clear();
@@ -158,27 +222,44 @@ class CppcheckLibraryData {
         functions.clear();
         memoryresource.clear();
         podtypes.clear();
+        smartPointers.clear();
+        typeChecks.clear();
+        platformTypes.clear();
+        reflections.clear();
+        markups.clear();
+        entrypoints.clear();
     }
 
-
-    void swap(CppcheckLibraryData &other) {
+    void swap(CppcheckLibraryData &other) NOEXCEPT {
         containers.swap(other.containers);
         defines.swap(other.defines);
         undefines.swap(other.undefines);
         functions.swap(other.functions);
         memoryresource.swap(other.memoryresource);
         podtypes.swap(other.podtypes);
+        smartPointers.swap(other.smartPointers);
+        typeChecks.swap(other.typeChecks);
+        platformTypes.swap(other.platformTypes);
+        reflections.swap(other.reflections);
+        markups.swap(other.markups);
+        entrypoints.swap(other.entrypoints);
     }
 
     QString open(QIODevice &file);
     QString toString() const;
 
-    QList<struct Container> containers;
-    QList<struct Define> defines;
-    QList<struct Function> functions;
-    QList<struct MemoryResource> memoryresource;
-    QList<struct PodType> podtypes;
+    QList<Container> containers;
+    QList<Define> defines;
+    QList<Function> functions;
+    QList<MemoryResource> memoryresource;
+    QList<PodType> podtypes;
+    QList<TypeChecks> typeChecks;
+    QList<PlatformType> platformTypes;
     QStringList undefines;
+    QList<SmartPointer> smartPointers;
+    QList<Reflection> reflections;
+    QList<Markup> markups;
+    QList<Entrypoint> entrypoints;
 };
 
-#endif // LIBRARYDATA_H
+#endif // CPPCHECKLIBRARYDATA_H
diff --git a/gui/csvreport.cpp b/gui/csvreport.cpp
index d67233b9d8d..df9e4d48c47 100644
--- a/gui/csvreport.cpp
+++ b/gui/csvreport.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2017 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,21 +16,18 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QObject>
-#include <QString>
-#include <QDir>
-#include <QTextStream>
-#include "report.h"
 #include "csvreport.h"
 
+#include "erroritem.h"
+#include "report.h"
+
+#include <QDir>
+#include <QFile>
+#include <QList>
+
 CsvReport::CsvReport(const QString &filename) :
     Report(filename)
-{
-}
-
-CsvReport::~CsvReport()
-{
-}
+{}
 
 bool CsvReport::create()
 {
@@ -43,7 +40,8 @@ bool CsvReport::create()
 
 void CsvReport::writeHeader()
 {
-    // No header for CSV report
+    // Added 5 columns to the header.
+    mTxtWriter << "File, Line, Severity, Id, Summary" << Qt::endl;
 }
 
 void CsvReport::writeFooter()
@@ -54,13 +52,12 @@ void CsvReport::writeFooter()
 void CsvReport::writeError(const ErrorItem &error)
 {
     /*
-    Error as CSV line
-    gui/test.cpp,23,error,Mismatching allocation and deallocation: k
-    */
+       Error as CSV line
+       gui/test.cpp,23,error,Mismatching allocation and deallocation: k
+     */
 
     const QString file = QDir::toNativeSeparators(error.errorPath.back().file);
     QString line = QString("%1,%2,").arg(file).arg(error.errorPath.back().line);
-    line += QString("%1,%2").arg(GuiSeverity::toString(error.severity)).arg(error.summary);
-
-    mTxtWriter << line << endl;
+    line += QString("%1,%2,%3").arg(GuiSeverity::toString(error.severity)).arg(error.errorId).arg(error.summary);
+    mTxtWriter << line << Qt::endl;
 }
diff --git a/gui/csvreport.h b/gui/csvreport.h
index b2f50c39727..3d24ab797d9 100644
--- a/gui/csvreport.h
+++ b/gui/csvreport.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,52 +19,52 @@
 #ifndef CSV_REPORT_H
 #define CSV_REPORT_H
 
+#include "report.h"
+
 #include <QString>
 #include <QTextStream>
-#include "report.h"
 
 /// @addtogroup GUI
 /// @{
 
 
 /**
-* @brief CSV text file report.
-* This report exports results as CSV (comma separated values). CSV files are
-* easy to import to many other programs.
-* @todo This class should be inherited from TxtReport?
-*/
+ * @brief CSV text file report.
+ * This report exports results as CSV (comma separated values). CSV files are
+ * easy to import to many other programs.
+ * @todo This class should be inherited from TxtReport?
+ */
 class CsvReport : public Report {
 public:
     explicit CsvReport(const QString &filename);
-    virtual ~CsvReport();
 
     /**
-    * @brief Create the report (file).
-    * @return true if succeeded, false if file could not be created.
-    */
-    virtual bool create() override;
+     * @brief Create the report (file).
+     * @return true if succeeded, false if file could not be created.
+     */
+    bool create() override;
 
     /**
-    * @brief Write report header.
-    */
-    virtual void writeHeader() override;
+     * @brief Write report header.
+     */
+    void writeHeader() override;
 
     /**
-    * @brief Write report footer.
-    */
-    virtual void writeFooter() override;
+     * @brief Write report footer.
+     */
+    void writeFooter() override;
 
     /**
-    * @brief Write error to report.
-    * @param error Error data.
-    */
-    virtual void writeError(const ErrorItem &error) override;
+     * @brief Write error to report.
+     * @param error Error data.
+     */
+    void writeError(const ErrorItem &error) override;
 
 private:
 
     /**
-    * @brief Text stream writer for writing the report in text format.
-    */
+     * @brief Text stream writer for writing the report in text format.
+     */
     QTextStream mTxtWriter;
 };
 /// @}
diff --git a/gui/erroritem.cpp b/gui/erroritem.cpp
index d8692559e43..77693f26a81 100644
--- a/gui/erroritem.cpp
+++ b/gui/erroritem.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,15 +17,17 @@
  */
 
 #include "erroritem.h"
+
 #include "common.h"
 
-QErrorPathItem::QErrorPathItem(const ErrorLogger::ErrorMessage::FileLocation &loc)
+#include <list>
+
+QErrorPathItem::QErrorPathItem(const ErrorMessage::FileLocation &loc)
     : file(QString::fromStdString(loc.getfile(false)))
     , line(loc.line)
     , column(loc.column)
     , info(QString::fromStdString(loc.getinfo()))
-{
-}
+{}
 
 bool operator==(const QErrorPathItem &i1, const QErrorPathItem &i2)
 {
@@ -35,24 +37,24 @@ bool operator==(const QErrorPathItem &i1, const QErrorPathItem &i2)
 ErrorItem::ErrorItem()
     : severity(Severity::none)
     , inconclusive(false)
-    , cwe(-1)
-{
-}
+    , cwe(0)
+    , hash(0)
+{}
 
-ErrorItem::ErrorItem(const ErrorLogger::ErrorMessage &errmsg)
-    : errorId(QString::fromStdString(errmsg.id))
+ErrorItem::ErrorItem(const ErrorMessage &errmsg)
+    : file0(QString::fromStdString(errmsg.file0))
+    , errorId(QString::fromStdString(errmsg.id))
     , severity(errmsg.severity)
-    , inconclusive(errmsg.inconclusive)
+    , inconclusive(errmsg.certainty == Certainty::inconclusive)
     , summary(QString::fromStdString(errmsg.shortMessage()))
     , message(QString::fromStdString(errmsg.verboseMessage()))
     , cwe(errmsg.cwe.id)
+    , hash(errmsg.hash)
     , symbolNames(QString::fromStdString(errmsg.symbolNames()))
+    , remark(QString::fromStdString(errmsg.remark))
 {
-    for (std::list<ErrorLogger::ErrorMessage::FileLocation>::const_iterator loc = errmsg.callStack.begin();
-         loc != errmsg.callStack.end();
-         ++loc) {
-        errorPath << QErrorPathItem(*loc);
-    }
+    for (const auto& loc: errmsg.callStack)
+        errorPath << QErrorPathItem(loc);
 }
 
 QString ErrorItem::tool() const
@@ -66,23 +68,27 @@ QString ErrorItem::tool() const
     return "cppcheck";
 }
 
-QString ErrorItem::ToString() const
+QString ErrorItem::toString() const
 {
-    QString str = errorPath.back().file + " - " + errorId + " - ";
+    const int i = getMainLocIndex();
+    QString ret = errorPath[i].file + ":" + QString::number(errorPath[i].line) + ":" + QString::number(errorPath[i].column) + ":";
+    ret += GuiSeverity::toString(severity);
     if (inconclusive)
-        str += "inconclusive ";
-    str += GuiSeverity::toString(severity) +"\n";
-    str += summary + "\n";
-    str += message + "\n";
-    for (int i = 0; i < errorPath.size(); i++) {
-        str += "  " + errorPath[i].file + ": " + QString::number(errorPath[i].line) + "\n";
+        ret += ",inconclusive";
+    ret += ": " + summary + " [" + errorId + "]";
+    if (errorPath.size() >= 2) {
+        for (const auto& e: errorPath)
+            ret += "\n" + e.file + ":" + QString::number(e.line) + ":" + QString::number(e.column) + ":note: " + e.info;
     }
-    return str;
+    return ret;
 }
 
-bool ErrorItem::sameCID(const ErrorItem &errorItem1, const ErrorItem &errorItem2)
+bool ErrorItem::same(const ErrorItem &errorItem1, const ErrorItem &errorItem2)
 {
-    // TODO: Implement some better CID calculation
+    if (errorItem1.hash && errorItem2.hash)
+        return errorItem1.hash == errorItem2.hash;
+
+    // fallback
     return errorItem1.errorId == errorItem2.errorId &&
            errorItem1.errorPath == errorItem2.errorPath &&
            errorItem1.file0 == errorItem2.file0 &&
@@ -90,3 +96,19 @@ bool ErrorItem::sameCID(const ErrorItem &errorItem1, const ErrorItem &errorItem2
            errorItem1.inconclusive == errorItem2.inconclusive &&
            errorItem1.severity == errorItem2.severity;
 }
+
+bool ErrorItem::filterMatch(const QString& filter) const
+{
+    if (filter.isEmpty())
+        return true;
+    if (summary.contains(filter, Qt::CaseInsensitive) ||
+        message.contains(filter, Qt::CaseInsensitive) ||
+        errorId.contains(filter, Qt::CaseInsensitive) ||
+        classification.contains(filter, Qt::CaseInsensitive))
+        return true;
+    return std::any_of(errorPath.cbegin(), errorPath.cend(),
+                       [filter](const auto& e) {
+        return e.file.contains(filter, Qt::CaseInsensitive) ||
+               e.info.contains(filter, Qt::CaseInsensitive);
+    });
+}
diff --git a/gui/erroritem.h b/gui/erroritem.h
index ab16ed88749..54c5a32a7f3 100644
--- a/gui/erroritem.h
+++ b/gui/erroritem.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,12 +19,11 @@
 #ifndef ERRORITEM_H
 #define ERRORITEM_H
 
-#include <QString>
-#include <QStringList>
-#include <QMetaType>
 #include "errorlogger.h"
+#include "errortypes.h"
 
-class ErrorLine;
+#include <QList>
+#include <QString>
 
 /// @addtogroup GUI
 /// @{
@@ -37,22 +36,22 @@ class ErrorLine;
  */
 class GuiSeverity {
 public:
-    static QString toString(Severity::SeverityType severity) {
-        return QString::fromStdString(Severity::toString(severity));
+    static QString toString(Severity severity) {
+        return QString::fromStdString(severityToString(severity));
     }
 
-    static Severity::SeverityType fromString(const QString &severity) {
-        return Severity::fromString(severity.toStdString());
+    static Severity fromString(const QString &severity) {
+        return severityFromString(severity.toStdString());
     }
 };
 
 /**
-* @brief A class containing data for one error path item
-*/
+ * @brief A class containing data for one error path item
+ */
 class QErrorPathItem {
 public:
     QErrorPathItem() : line(0), column(-1) {}
-    explicit QErrorPathItem(const ErrorLogger::ErrorMessage::FileLocation &loc);
+    explicit QErrorPathItem(const ErrorMessage::FileLocation &loc);
     QString file;
     int line;
     int column;
@@ -62,63 +61,61 @@ class QErrorPathItem {
 bool operator==(const QErrorPathItem &i1, const QErrorPathItem &i2);
 
 /**
-* @brief A class containing error data for one error.
-*
-* The paths are stored with internal ("/") separators. Only when we show the
-* path or copy if for user (to clipboard) we convert to native separators.
-* Full path is stored instead of relative path for flexibility. It is easy
-* to get the relative path from full path when needed.
-*/
+ * @brief A class containing error data for one error.
+ *
+ * The paths are stored with internal ("/") separators. Only when we show the
+ * path or copy if for user (to clipboard) we convert to native separators.
+ * Full path is stored instead of relative path for flexibility. It is easy
+ * to get the relative path from full path when needed.
+ */
 class ErrorItem {
 public:
     ErrorItem();
-    explicit ErrorItem(const ErrorLogger::ErrorMessage &errmsg);
+    explicit ErrorItem(const ErrorMessage &errmsg);
 
     /**
-    * @brief Convert error item to string.
-    * @return Error item as string.
-    */
-    QString ToString() const;
+     * @brief Convert error item to string.
+     * @return Error item as string.
+     */
+    QString toString() const;
     QString tool() const;
 
+    int getMainLocIndex() const {
+        return isClangResult() ? 0 : errorPath.size() - 1;
+    }
+
+    QString getFile() const {
+        return errorPath.isEmpty() ? QString() : errorPath[getMainLocIndex()].file;
+    }
+
+    bool isClangResult() const {
+        return errorId.startsWith("clang");
+    }
+
+    bool filterMatch(const QString& filter) const;
+
     QString file0;
     QString errorId;
-    Severity::SeverityType severity;
+    Severity severity;
     bool inconclusive;
     QString summary;
     QString message;
     int cwe;
+    unsigned long long hash;
     QList<QErrorPathItem> errorPath;
     QString symbolNames;
+    QString remark;
+    QString classification; // misra/cert/etc: classification/level
+    QString guideline; // misra/cert/etc: guideline/rule
 
     // Special GUI properties
     QString sinceDate;
     QString tags;
 
     /**
-     * Compare "CID"
+     * Compare Hash and fields
      */
-    static bool sameCID(const ErrorItem &errorItem1, const ErrorItem &errorItem2);
+    static bool same(const ErrorItem &errorItem1, const ErrorItem &errorItem2);
 };
-
-Q_DECLARE_METATYPE(ErrorItem)
-
-/**
-* @brief A class containing error data for one shown error line.
-*/
-class ErrorLine {
-public:
-    QString file;
-    unsigned int line;
-    QString file0;
-    QString errorId;
-    bool inconclusive;
-    Severity::SeverityType severity;
-    QString summary;
-    QString message;
-    QString sinceDate;
-    QString tags;
-};
-
 /// @}
 #endif // ERRORITEM_H
diff --git a/gui/filelist.cpp b/gui/filelist.cpp
index 2c80ef11869..cdfa6676a4e 100644
--- a/gui/filelist.cpp
+++ b/gui/filelist.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,17 +16,22 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QString>
-#include <QDir>
-#include <QFileInfo>
 #include "filelist.h"
-#include "path.h"
+
 #include "pathmatch.h"
 
+#include <algorithm>
+#include <iterator>
+#include <string>
+#include <vector>
+
+#include <QDir>
+#include <Qt>
+
 QStringList FileList::getDefaultFilters()
 {
     QStringList extensions;
-    extensions << "*.cpp" << "*.cxx" << "*.cc" << "*.c" << "*.c++" << "*.txx" << "*.tpp";
+    extensions << "*.cpp" << "*.cxx" << "*.cc" << "*.c" << "*.c++" << "*.txx" << "*.tpp" << "*.ipp" << "*.ixx";
     return extensions;
 }
 
@@ -67,9 +72,7 @@ void FileList::addDirectory(const QString &directory, bool recursive)
 
         dir.setNameFilters(origNameFilters);
         dir.setFilter(QDir::Dirs | QDir::NoDotAndDotDot);
-        QFileInfoList list = dir.entryInfoList();
-        QFileInfo item;
-        foreach (item, list) {
+        for (const QFileInfo& item : dir.entryInfoList()) {
             const QString path = item.canonicalFilePath();
             addDirectory(path, recursive);
         }
@@ -78,8 +81,7 @@ void FileList::addDirectory(const QString &directory, bool recursive)
 
 void FileList::addPathList(const QStringList &paths)
 {
-    QString path;
-    foreach (path, paths) {
+    for (const QString& path : paths) {
         QFileInfo inf(path);
         if (inf.isFile())
             addFile(path);
@@ -92,14 +94,13 @@ QStringList FileList::getFileList() const
 {
     if (mExcludedPaths.empty()) {
         QStringList names;
-        foreach (QFileInfo item, mFileList) {
+        for (const QFileInfo& item : mFileList) {
             QString name = QDir::fromNativeSeparators(item.filePath());
             names << name;
         }
         return names;
-    } else {
-        return applyExcludeList();
     }
+    return applyExcludeList();
 }
 
 void FileList::addExcludeList(const QStringList &paths)
@@ -110,25 +111,23 @@ void FileList::addExcludeList(const QStringList &paths)
 static std::vector<std::string> toStdStringList(const QStringList &stringList)
 {
     std::vector<std::string> ret;
-    foreach (const QString &s, stringList) {
-        ret.push_back(s.toStdString());
-    }
+    std::transform(stringList.cbegin(), stringList.cend(), std::back_inserter(ret), [](const QString& s) {
+        return s.toStdString();
+    });
     return ret;
 }
 
 QStringList FileList::applyExcludeList() const
 {
-#ifdef _WIN32
-    const PathMatch pathMatch(toStdStringList(mExcludedPaths), true);
-#else
-    const PathMatch pathMatch(toStdStringList(mExcludedPaths), false);
-#endif
+    const PathMatch pathMatch(toStdStringList(mExcludedPaths), QDir::currentPath().toStdString());
 
     QStringList paths;
-    foreach (QFileInfo item, mFileList) {
-        QString name = QDir::fromNativeSeparators(item.canonicalFilePath());
-        if (!pathMatch.match(name.toStdString()))
-            paths << name;
+    for (const QFileInfo& item : mFileList) {
+        if (pathMatch.match(QDir::fromNativeSeparators(item.filePath()).toStdString()))
+            continue;
+        QString canonical = QDir::fromNativeSeparators(item.canonicalFilePath());
+        if (!pathMatch.match(canonical.toStdString()))
+            paths << canonical;
     }
     return paths;
 }
diff --git a/gui/filelist.h b/gui/filelist.h
index 250d485cf0c..59f1284998d 100644
--- a/gui/filelist.h
+++ b/gui/filelist.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2017 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,7 +19,9 @@
 #ifndef FILELIST_H
 #define FILELIST_H
 
+#include <QFileInfo>
 #include <QFileInfoList>
+#include <QString>
 #include <QStringList>
 
 /**
@@ -38,57 +40,57 @@ class FileList {
 public:
 
     /**
-    * @brief Add filename to the list.
-    * @param filepath Full path to the file.
-    */
+     * @brief Add filename to the list.
+     * @param filepath Full path to the file.
+     */
     void addFile(const QString &filepath);
 
     /**
-    * @brief Add files in the directory to the list.
-    * @param directory Full pathname to directory to add.
-    * @param recursive If true also files in subdirectories are added.
-    */
+     * @brief Add files in the directory to the list.
+     * @param directory Full pathname to directory to add.
+     * @param recursive If true also files in subdirectories are added.
+     */
     void addDirectory(const QString &directory, bool recursive = false);
 
     /**
-    * @brief Add list of filenames and directories to the list.
-    * @param paths List of paths to add.
-    */
+     * @brief Add list of filenames and directories to the list.
+     * @param paths List of paths to add.
+     */
     void addPathList(const QStringList &paths);
 
     /**
-    * @brief Return list of filenames (to check).
-    * @return list of filenames to check.
-    */
+     * @brief Return list of filenames (to check).
+     * @return list of filenames to check.
+     */
     QStringList getFileList() const;
 
     /**
-    * @brief Add list of paths to exclusion list.
-    * @param paths Paths to exclude.
-    */
+     * @brief Add list of paths to exclusion list.
+     * @param paths Paths to exclude.
+     */
     void addExcludeList(const QStringList &paths);
 
     /**
-    * @brief Return list of default filename extensions included.
-    * @return list of default filename extensions included.
-    */
+     * @brief Return list of default filename extensions included.
+     * @return list of default filename extensions included.
+     */
     static QStringList getDefaultFilters();
 
 protected:
 
     /**
-    * @brief Test if filename matches the filename extensions filtering.
-    * @return true if filename matches filtering.
-    */
+     * @brief Test if filename matches the filename extensions filtering.
+     * @return true if filename matches filtering.
+     */
     static bool filterMatches(const QFileInfo &inf);
 
     /**
-    * @brief Get filtered list of paths.
-    * This method takes the list of paths and applies the exclude lists to
-    * it. And then returns the list of paths that did not match the
-    * exclude filters.
-    * @return Filtered list of paths.
-    */
+     * @brief Get filtered list of paths.
+     * This method takes the list of paths and applies the exclude lists to
+     * it. And then returns the list of paths that did not match the
+     * exclude filters.
+     * @return Filtered list of paths.
+     */
     QStringList applyExcludeList() const;
 
 private:
diff --git a/gui/file.ui b/gui/fileview.ui
similarity index 100%
rename from gui/file.ui
rename to gui/fileview.ui
diff --git a/gui/fileviewdialog.cpp b/gui/fileviewdialog.cpp
index f5eed0a2693..3f66f008678 100644
--- a/gui/fileviewdialog.cpp
+++ b/gui/fileviewdialog.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2017 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,23 +16,34 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QFile>
+#include "fileviewdialog.h"
+
 #include <QByteArray>
+#include <QDialogButtonBox>
+#include <QFile>
+#include <QIODevice>
 #include <QMessageBox>
 #include <QTextEdit>
-#include "fileviewdialog.h"
+
+#include "ui_fileview.h"
 
 FileViewDialog::FileViewDialog(const QString &file,
                                const QString &title,
                                QWidget *parent)
     : QDialog(parent)
+    , mUI(new Ui::Fileview)
 {
-    mUI.setupUi(this);
+    mUI->setupUi(this);
 
 
     setWindowTitle(title);
-    connect(mUI.mButtons, SIGNAL(accepted()), this, SLOT(accept()));
-    loadTextFile(file, mUI.mText);
+    connect(mUI->mButtons, SIGNAL(accepted()), this, SLOT(accept()));
+    loadTextFile(file, mUI->mText);
+}
+
+FileViewDialog::~FileViewDialog()
+{
+    delete mUI;
 }
 
 void FileViewDialog::loadTextFile(const QString &filename, QTextEdit *edit)
@@ -51,7 +62,7 @@ void FileViewDialog::loadTextFile(const QString &filename, QTextEdit *edit)
         return;
     }
 
-    file.open(QIODevice::ReadOnly | QIODevice::Text);
+    (void)file.open(QIODevice::ReadOnly | QIODevice::Text); // TODO: check result
     if (!file.isReadable()) {
         QString msg(tr("Could not read the file: %1"));
         msg = msg.arg(filename);
diff --git a/gui/fileviewdialog.h b/gui/fileviewdialog.h
index 8e9cfc8a182..55e32068008 100644
--- a/gui/fileviewdialog.h
+++ b/gui/fileviewdialog.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,22 +20,25 @@
 #define FILEVIEW_DIALOG_H
 
 #include <QDialog>
+#include <QObject>
 #include <QString>
-#include "ui_file.h"
 
 class QWidget;
 class QTextEdit;
+namespace Ui {
+    class Fileview;
+}
 
 /// @addtogroup GUI
 /// @{
 
 
 /**
-* @brief File view -dialog.
-* This dialog shows text files. It is used for showing the license file and
-* the authors list.
-*
-*/
+ * @brief File view -dialog.
+ * This dialog shows text files. It is used for showing the license file and
+ * the authors list.
+ *
+ */
 class FileViewDialog : public QDialog {
     Q_OBJECT
 public:
@@ -43,18 +46,19 @@ class FileViewDialog : public QDialog {
                    const QString &title,
                    QWidget *parent = nullptr);
 
+    ~FileViewDialog() override;
 
 protected:
 
     /**
-    * @brief Load text file contents to edit control.
-    *
-    * @param filename File to load.
-    * @param edit Control where to load the file contents.
-    */
+     * @brief Load text file contents to edit control.
+     *
+     * @param filename File to load.
+     * @param edit Control where to load the file contents.
+     */
     void loadTextFile(const QString &filename, QTextEdit *edit);
 
-    Ui::Fileview mUI;
+    Ui::Fileview* mUI;
 };
 /// @}
 #endif // FILEVIEW_DIALOG_H
diff --git a/gui/gui.pro b/gui/gui.pro
index 7275ec28588..8706e86c86e 100644
--- a/gui/gui.pro
+++ b/gui/gui.pro
@@ -1,4 +1,4 @@
-lessThan(QT_MAJOR_VERSION, 5): error(requires >= Qt 5 (You used: $$QT_VERSION))
+lessThan(QT_MAJOR_VERSION, 6): error(requires >= Qt 6 (You used: $$QT_VERSION))
 
 TEMPLATE = app
 TARGET = cppcheck-gui
@@ -9,6 +9,14 @@ INCLUDEPATH += . \
     ../lib
 QT += widgets
 QT += printsupport
+QT += help
+QT += network
+
+# Build online help
+#onlinehelp.target = online-help.qhc
+#onlinehelp.commands = qhelpgenerator $$PWD/help/online-help.qhcp -o $$PWD/help/online-help.qhc
+#QMAKE_EXTRA_TARGETS += onlinehelp
+#PRE_TARGETDEPS += online-help.qhc
 
 contains(LINKCORE, [yY][eE][sS]) {
     LIBS += -l../bin/cppcheck-core
@@ -49,18 +57,21 @@ win32 {
 
 RESOURCES = gui.qrc
 FORMS = about.ui \
-        application.ui \
-        file.ui \
+        applicationdialog.ui \
+        compliancereportdialog.ui \
+        fileview.ui \
+        helpdialog.ui \
         mainwindow.ui \
-        projectfiledialog.ui \
+        projectfile.ui \
         resultsview.ui \
         scratchpad.ui \
         settings.ui \
-        stats.ui \
+        statsdialog.ui \
         librarydialog.ui \
         libraryaddfunctiondialog.ui \
         libraryeditargdialog.ui \
-        newsuppressiondialog.ui
+        newsuppressiondialog.ui \
+        threaddetails.ui
 
 TRANSLATIONS =  cppcheck_de.ts \
                 cppcheck_es.ts \
@@ -68,20 +79,52 @@ TRANSLATIONS =  cppcheck_de.ts \
                 cppcheck_fr.ts \
                 cppcheck_it.ts \
                 cppcheck_ja.ts \
+                cppcheck_ka.ts \
                 cppcheck_ko.ts \
                 cppcheck_nl.ts \
                 cppcheck_ru.ts \
                 cppcheck_sr.ts \
                 cppcheck_sv.ts \
-                cppcheck_zh_CN.ts
+                cppcheck_zh_CN.ts \
+                cppcheck_zh_TW.ts
 
 # Windows-specific options
 CONFIG += embed_manifest_exe
 
 contains(LINKCORE, [yY][eE][sS]) {
 } else {
-    BASEPATH = ../lib/
-    include($$PWD/../lib/lib.pri)
+    INCLUDEPATH += $$PWD/../lib
+    HEADERS += $$PWD/../lib/*.h
+    SOURCES += $$PWD/../lib/*.cpp
+
+    INCLUDEPATH += $$PWD/../frontend
+    HEADERS += $$PWD/../frontend/*.h
+    SOURCES += $$PWD/../frontend/*.cpp
+
+    INCLUDEPATH += $$PWD/../externals/picojson
+    HEADERS += $$PWD/../externals/picojson/picojson.h
+
+    INCLUDEPATH += $$PWD/../externals/simplecpp
+    HEADERS += $$PWD/../externals/simplecpp/simplecpp.h
+    SOURCES += $$PWD/../externals/simplecpp/simplecpp.cpp
+    DEFINES += SIMPLECPP_TOKENLIST_ALLOW_PTR
+
+    INCLUDEPATH += $$PWD/../externals/tinyxml2
+    HEADERS += $$PWD/../externals/tinyxml2/tinyxml2.h
+    SOURCES += $$PWD/../externals/tinyxml2/tinyxml2.cpp
+}
+
+win32-msvc* {
+    MSVC_VER = $$(VisualStudioVersion)
+    message($$MSVC_VER)
+    MSVC_VER_SPLIT = $$split(MSVC_VER, .)
+    MSVC_VER_MAJOR = $$first(MSVC_VER_SPLIT)
+    # doesn't compile with older VS versions - assume VS2019 (16.x) is the first working for now
+    !lessThan(MSVC_VER_MAJOR, 16) {
+        message("using precompiled header")
+        CONFIG += precompile_header
+        PRECOMPILED_HEADER = precompiled_qmake.h
+    }
 }
 
 HEADERS += aboutdialog.h \
@@ -95,22 +138,26 @@ HEADERS += aboutdialog.h \
            codeeditstyledialog.h \
            codeeditor.h \
            common.h \
+           compliancereportdialog.h \
            csvreport.h \
            erroritem.h \
            filelist.h \
            fileviewdialog.h \
+           helpdialog.h \
            mainwindow.h \
            platforms.h \
            printablereport.h \
            projectfile.h \
            projectfiledialog.h \
            report.h \
+           resultitem.h \
            resultstree.h \
            resultsview.h \
            scratchpad.h \
            settingsdialog.h \
            showtypes.h \
            statsdialog.h \
+           threaddetails.h \
            threadhandler.h \
            threadresult.h \
            translationhandler.h \
@@ -134,10 +181,12 @@ SOURCES += aboutdialog.cpp \
            codeeditstyledialog.cpp \
            codeeditor.cpp \
            common.cpp \
+           compliancereportdialog.cpp \
            csvreport.cpp \
            erroritem.cpp \
            filelist.cpp \
            fileviewdialog.cpp \
+           helpdialog.cpp \
            main.cpp \
            mainwindow.cpp\
            platforms.cpp \
@@ -145,12 +194,14 @@ SOURCES += aboutdialog.cpp \
            projectfile.cpp \
            projectfiledialog.cpp \
            report.cpp \
+           resultitem.cpp \
            resultstree.cpp \
            resultsview.cpp \
            scratchpad.cpp \
            settingsdialog.cpp \
            showtypes.cpp \
            statsdialog.cpp \
+           threaddetails.cpp \
            threadhandler.cpp \
            threadresult.cpp \
            translationhandler.cpp \
@@ -173,16 +224,15 @@ win32 {
 }
 
 contains(QMAKE_CC, gcc) {
-    QMAKE_CXXFLAGS += -std=c++11 -Wno-missing-field-initializers -Wno-missing-braces -Wno-sign-compare -Wno-deprecated-declarations
+    QMAKE_CXXFLAGS += -std=c++17 -pedantic -Wall -Wextra -Wcast-qual -Wno-deprecated-declarations -Wfloat-equal -Wmissing-declarations -Wmissing-format-attribute -Wno-long-long -Wpacked -Wredundant-decls -Wundef -Wno-shadow -Wno-missing-field-initializers -Wno-missing-braces -Wno-sign-compare -Wno-multichar
 }
 
 contains(QMAKE_CXX, clang++) {
-    QMAKE_CXXFLAGS += -std=c++11
+    QMAKE_CXXFLAGS += -std=c++17 -pedantic -Wall -Wextra -Wcast-qual -Wno-deprecated-declarations -Wfloat-equal -Wmissing-declarations -Wmissing-format-attribute -Wno-long-long -Wpacked -Wredundant-decls -Wundef -Wno-shadow -Wno-missing-field-initializers -Wno-missing-braces -Wno-sign-compare -Wno-multichar
 }
 
 contains(HAVE_QCHART, [yY][eE][sS]) {
     QT += charts
-    DEFINES += HAVE_QCHART
 } else {
     message("Charts disabled - to enable it pass HAVE_QCHART=yes to qmake.")
 }
diff --git a/gui/gui.qrc b/gui/gui.qrc
index aa669b4f8e9..c40e1ba7a1c 100644
--- a/gui/gui.qrc
+++ b/gui/gui.qrc
@@ -28,5 +28,6 @@
         <file>images/applications-development.png</file>
         <file>images/applications-system.png</file>
         <file>images/llvm-dragon.png</file>
+        <file>images/verify.svg</file>
     </qresource>
 </RCC>
diff --git a/gui/help/buildhelp.bat b/gui/help/buildhelp.bat
deleted file mode 100644
index b0cfbcc0db0..00000000000
--- a/gui/help/buildhelp.bat
+++ /dev/null
@@ -1,10 +0,0 @@
-@echo off
-
-pushd %~dp0
-
-if exist online-help.qhc del online-help.qhc
-if exist online-help.qch del online-help.qch
-
-qcollectiongenerator online-help.qhcp -o online-help.qhc
-
-popd
diff --git a/gui/help/images/index-mainwindow.png b/gui/help/images/index-mainwindow.png
new file mode 100644
index 00000000000..aa67a5e836d
Binary files /dev/null and b/gui/help/images/index-mainwindow.png differ
diff --git a/gui/help/images/severities-error.png b/gui/help/images/severities-error.png
new file mode 100644
index 00000000000..6bad55fbd4a
Binary files /dev/null and b/gui/help/images/severities-error.png differ
diff --git a/gui/help/images/severities-information.png b/gui/help/images/severities-information.png
new file mode 100644
index 00000000000..70de0695f8c
Binary files /dev/null and b/gui/help/images/severities-information.png differ
diff --git a/gui/help/images/severities-performance.png b/gui/help/images/severities-performance.png
new file mode 100644
index 00000000000..ea9a1c8abce
Binary files /dev/null and b/gui/help/images/severities-performance.png differ
diff --git a/gui/help/images/severities-portability.png b/gui/help/images/severities-portability.png
new file mode 100644
index 00000000000..2bc00aa106f
Binary files /dev/null and b/gui/help/images/severities-portability.png differ
diff --git a/gui/help/images/severities-style.png b/gui/help/images/severities-style.png
new file mode 100644
index 00000000000..7320ae9fd4c
Binary files /dev/null and b/gui/help/images/severities-style.png differ
diff --git a/gui/help/images/severities-warning.png b/gui/help/images/severities-warning.png
new file mode 100644
index 00000000000..196884717cd
Binary files /dev/null and b/gui/help/images/severities-warning.png differ
diff --git a/gui/help/images/walkthrough-analysis.png b/gui/help/images/walkthrough-analysis.png
new file mode 100644
index 00000000000..94efb2890d8
Binary files /dev/null and b/gui/help/images/walkthrough-analysis.png differ
diff --git a/gui/help/images/walkthrough-import-project.png b/gui/help/images/walkthrough-import-project.png
new file mode 100644
index 00000000000..44b18e7f6b2
Binary files /dev/null and b/gui/help/images/walkthrough-import-project.png differ
diff --git a/gui/help/images/walkthrough-library.png b/gui/help/images/walkthrough-library.png
new file mode 100644
index 00000000000..fbb5ae14d09
Binary files /dev/null and b/gui/help/images/walkthrough-library.png differ
diff --git a/gui/help/images/walkthrough-new-project.png b/gui/help/images/walkthrough-new-project.png
new file mode 100644
index 00000000000..55bf7ce2f4f
Binary files /dev/null and b/gui/help/images/walkthrough-new-project.png differ
diff --git a/gui/help/images/walkthrough-toolbar-severities.png b/gui/help/images/walkthrough-toolbar-severities.png
new file mode 100644
index 00000000000..f06e3aa41cf
Binary files /dev/null and b/gui/help/images/walkthrough-toolbar-severities.png differ
diff --git a/gui/help/images/walkthrough-warning-menu.png b/gui/help/images/walkthrough-warning-menu.png
new file mode 100644
index 00000000000..0154b5ccbc9
Binary files /dev/null and b/gui/help/images/walkthrough-warning-menu.png differ
diff --git a/gui/help/index.html b/gui/help/index.html
new file mode 100644
index 00000000000..4d2cd43f824
--- /dev/null
+++ b/gui/help/index.html
@@ -0,0 +1,21 @@
+<html>
+<head>
+<title>Cppcheck GUI</title>
+</head>
+<body>
+
+<h1>Cppcheck GUI</h1>
+
+<p>With the Cppcheck GUI you can analyze your code.</p>
+
+<h2>Contents</h2>
+
+<p>If you want to get started, look at the <a href="walkthrough.html">walk through</a>.</p>
+
+<h2>Example</h2>
+
+<blockquote><img src="images/index-mainwindow.png"></blockquote>
+
+</body>
+</html>
+
diff --git a/gui/help/investigating-warnings.html b/gui/help/investigating-warnings.html
new file mode 100644
index 00000000000..5eec66bd054
--- /dev/null
+++ b/gui/help/investigating-warnings.html
@@ -0,0 +1,22 @@
+<html>
+<head>
+<title>Investigating warnings</title>
+</head>
+<body>
+
+<h1>Investigating warnings</h1>
+
+<p>When you have run the analysis it is time to look at the results.</p>
+
+<p>If you click on a warning then the corresponding code will be shown in the
+&quot;Warning details&quot; at the bottom.</p>
+
+<p>You can right click warnings to get options. The difference of
+&quot;hiding&quot; a warning and &quot;suppressing&quot; a warning is that
+the suppression is permanent and hiding the warning is only temporary. When
+suppressing warning(s), that is saved in the project file.
+
+
+</body>
+</html>
+
diff --git a/gui/help/online-help.qhcp b/gui/help/online-help.qhcp
index 71d37674f17..228649c102a 100644
--- a/gui/help/online-help.qhcp
+++ b/gui/help/online-help.qhcp
@@ -1,14 +1,14 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<QHelpCollectionProject version="1.0">
-    <docFiles>
-        <generate>
-            <file>
-                <input>online-help.qhp</input>
-                <output>online-help.qch</output>
-            </file>
-        </generate>
-        <register>
-            <file>online-help.qch</file>
-        </register>
-    </docFiles>
-</QHelpCollectionProject>
+<?xml version="1.0" encoding="utf-8" ?>
+<QHelpCollectionProject version="1.0">
+    <docFiles>
+        <generate>
+            <file>
+                <input>online-help.qhp</input>
+                <output>online-help.qch</output>
+            </file>
+        </generate>
+        <register>
+            <file>online-help.qch</file>
+        </register>
+    </docFiles>
+</QHelpCollectionProject>
diff --git a/gui/help/online-help.qhp b/gui/help/online-help.qhp
index 16ab79981ed..23411d0f3b4 100644
--- a/gui/help/online-help.qhp
+++ b/gui/help/online-help.qhp
@@ -1,14 +1,50 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<QtHelpProject version="1.0">
-    <namespace>cppcheck.sourceforge.net</namespace>
-    <virtualFolder>doc</virtualFolder>
-    <filterSection>
-        <toc>
-            <section title="Manual" ref="manual.html"/>
-        </toc>
-        <keywords/>
-        <files>
-          <file>manual.html</file>
-        </files>
-    </filterSection>
+<?xml version="1.0" encoding="UTF-8"?>
+<QtHelpProject version="1.0">
+    <namespace>cppcheck.sourceforge.io</namespace>
+    <virtualFolder>doc</virtualFolder>
+    <filterSection>
+        <toc>
+            <section title="Cppcheck GUI help" ref="index.html">
+                <section title="Investigating warnings" ref="investigating-warnings.html"/>
+                <section title="Preferences" ref="preferences.html"/>
+                <section title="Project file dialog" ref="projectfiledialog.html"/>
+                <section title="Severities" ref="severities.html"/>
+                <section title="Standalone analysis" ref="standalone-analysis.html"/>
+                <section title="Tagging" ref="tagging.html"/>
+                <section title="Quick walk through" ref="walkthrough.html"/>
+            </section>
+        </toc>
+        <keywords>
+            <keyword name="Error" ref="severities.html"/>
+            <keyword name="Performance" ref="severities.html"/>
+            <keyword name="Portability" ref="severities.html"/>
+            <keyword name="Project" ref="projectfiledialog.html"/>
+            <keyword name="Style" ref="severities.html"/>
+            <keyword name="Tag" ref="tagging.html"/>
+            <keyword name="Warning" ref="severities.html"/>
+        </keywords>
+        <files>
+          <file>index.html</file>
+          <file>images/index-mainwindow.png</file>
+          <file>investigating-warnings.html</file>
+          <file>preferences.html</file>
+          <file>projectfiledialog.html</file>
+          <file>severities.html</file>
+          <file>images/severities-error.png</file>
+          <file>images/severities-warning.png</file>
+          <file>images/severities-style.png</file>
+          <file>images/severities-performance.png</file>
+          <file>images/severities-portability.png</file>
+          <file>images/severities-information.png</file>
+          <file>standalone-analysis.html</file>
+          <file>tagging.html</file>
+          <file>walkthrough.html</file>
+          <file>images/walkthrough-analysis.png</file>
+          <file>images/walkthrough-library.png</file>
+          <file>images/walkthrough-toolbar-severities.png</file>
+          <file>images/walkthrough-import-project.png</file>
+          <file>images/walkthrough-new-project.png</file> 
+          <file>images/walkthrough-warning-menu.png</file>
+        </files>
+    </filterSection>
 </QtHelpProject>
diff --git a/gui/help/preferences.html b/gui/help/preferences.html
new file mode 100644
index 00000000000..5a591227b3c
--- /dev/null
+++ b/gui/help/preferences.html
@@ -0,0 +1,74 @@
+<html>
+<head>
+<title>Preferences</title>
+</head>
+<body>
+
+<h1>Preferences</h1>
+
+<p><b>Number of threads</b><br>Number of threads to use in analysis. Each
+thread checks its own source file.</p>
+
+<p><b>Force checking of all #ifdef configurations</b><br>Cppcheck try to check
+all code and will therefore guess different preprocessor configurations. The
+maximum number of configurations that is checked is 14 by default.</p>
+
+<p><b>Show full path of files</b><br>Show the full paths in the results.</p>
+
+<p><b>Show &quot;No errors found&quot; message when no errors found</b><br>
+If you want to get a message box about this.</p>
+
+<p><b>Display error id column &quot;Id&quot;</b><br>Show error id in results</p>
+
+<p><b>Enable inline suppressions</b><br>You can suppress warnings with comments.
+See the Cppcheck manual (https://cppcheck.sourceforge.io/manual.pdf) for more
+information about inline suppressions.</p>
+
+<p><b>Check for inconclusive errors also</b><br>When full analysis of the code
+can not determine if there should be a warning or not, it is inconclusive.
+Normally Cppcheck does not warn then.</p>
+
+<p><b>Show statistics on check completion</b><br>Show statistics in a window
+when analysis finish.</p>
+
+<p><b>Show internal warnings in log</b><br>Internal warnings (for debugging) is
+shown in the <i>Analysis log</i>.</p>
+
+<p><b>Applications</b><br>Configure external editor to open from context menu
+when you right click on a warning.</p>
+
+<p><b>Save all errors when creating report</b><br>If hidden warnings should be
+saved or not.</p>
+
+<p><b>Save full path to files in report</b><br>If you use <i>Root path</i> the
+warnings on the screen will not have the full path.</p>
+
+<p><b>Language</b><br>Configure language to use for GUI.</p>
+
+<p><b>Python binary</b><br>To be able to execute addons, Cppcheck needs to know
+where python is. Unless you configure something, Cppcheck will try to execute
+python in your PATH.</p>
+
+<p><b>MISRA rule texts</b><br>Only needed if you want to use the MISRA addon.
+Cppcheck is not legally allowed to distribute the MISRA rule texts and these
+must be provided by users. The MISRA rule texts are proprietary. An example
+rule text file:
+<blockquote><pre>Appendix A Summary of guidelines
+Rule 1.1
+Text of rule 1.1
+Rule 1.2
+Text of rule 1.2</pre></blockquote>
+</p>
+
+<p><b>Clang path</b><br>The path to <i>clang</i> binary. If no path is provided
+then system PATH is used.</p>
+
+<p><b>Visual studio headers</b><br>If you want to use the Visual Studio headers
+in the analysis you can provide the path(s) here. Hint: Open a visual studio
+command prompt and type <i>SET INCLUDE</i>. Then copy/paste the paths.</p>
+
+<p><b>Code editor style</b><br>The visual theme to use for the code editor that
+is used when you investigate results.</p>
+
+</body>
+</html>
diff --git a/gui/help/projectfiledialog.html b/gui/help/projectfiledialog.html
new file mode 100644
index 00000000000..52b4eba444f
--- /dev/null
+++ b/gui/help/projectfiledialog.html
@@ -0,0 +1,179 @@
+<html>
+<head>
+<title>Project File Dialog</title>
+</head>
+<body>
+
+<h1>Project File Dialog</h1>
+
+<p>The <i>Project file</i> dialog contains 4 tabs:</p>
+<ul>
+<li>Paths and defines; paths to check and basic preprocessor settings.
+<li>Types and Functions; configuration of platform and 3rd party libraries
+<li>Analysis; analysis options
+<li>Warning options; formatting warnings, suppressing warnings, etc
+<li>Addons; extra analysis with addons
+</ul>
+
+<h2>Paths and defines</h2>
+
+<p>It is recommended to import a project file.</p>
+
+<h3> Import project</h3>
+
+Project to import. Cppcheck will get:
+<ul>
+<li>What files to check
+<li>Preprocessor defines
+<li>Preprocessor include paths
+<li>Language standard if set
+</ul>
+
+<h3>Paths (If you do not import project)</h3>
+
+<p>What paths to check.</p>
+
+<h3>Defines (If you do not import project)</h3>
+
+<p>Cppcheck automatically checks the code with different preprocessor
+configurations.</p>
+
+<blockquote><pre>#ifdef A
+code1
+#endif
+#ifdef B
+code2
+#endif</pre></blockquote>
+
+<p>Cppcheck will automatically perform analysis both when A is defined and B is
+defined. So any bugs in both code1 and code2 will be detected.</p>
+
+<p>If you want to configure that A will always be defined in Cppcheck analysis
+you can do that here.</p>
+
+<p>Defines are separated by semicolon. So you can for instance write:</p>
+
+<blockquote><pre>A;B=3;C</pre></blockquote>
+
+<h3>Undefines (If you do not import project)</h3>
+
+<p>Cppcheck automatically checks the code with different preprocessor
+configurations.</p>
+
+<blockquote><pre>#ifdef A
+code1
+#endif
+#ifdef B
+code2
+#endif</pre></blockquote>
+
+<p>Cppcheck will automatically perform analysis both when A is defined and B is
+defined. So any bugs in both code1 and code2 will be detected.</p>
+
+<p>If you want to configure that A is never defined in Cppcheck analysis you
+can do that here.</p>
+
+<p>Undefines are separated by semicolon. So you can for instance write:</p>
+
+<blockquote><pre>A;C</pre></blockquote>
+
+<h3>Include paths (If you do not import project)</h3>
+
+<p>Specify include paths.</p>
+
+<h2>Types and Functions</h2>
+
+<p>Cppcheck uses the <i>Platform</i> setting to determine size of
+short/int/long/pointer/etc.</p>
+
+<p>Check the libraries that you use in the <i>Libraries</i> listbox.</p>
+
+<h2>Analysis</h2>
+
+<h3>Cppcheck build dir</h3>
+
+<p>This is a work-folder that Cppcheck uses. Each Cppcheck project should have
+a separate build dir. It is used for:</p>
+<ul>
+<li>whole program analysis
+<li>debug output
+<li>faster analysis (if a source file has changed check it, if source file is
+   not changed then reuse old results)
+<li>statistics
+</ul>
+
+<h3>Parser</h3>
+
+<p>It is in general recommended to use Cppcheck parser. However you can choose
+to use Clang parser; Clang will be executed with a command line flag that tells
+it to dump its AST and Cppcheck will read that AST and convert it into a
+corresponding Cppcheck AST and use that.</p>
+
+<h3>Analysis</h3>
+
+<p>Configure what kind of analysis you want.</p>
+
+<p>The <i>Normal analysis</i> is recommended for most use cases. Especially if
+you use Cppcheck in CI.</p>
+
+<p>The <i>Bug hunting</i> can be used if you really want to find a bug in your
+code and can invest time looking at bad results and providing extra
+configuration.</p>
+
+<h3>Limit analysis</h3>
+
+<p>You can turn off checking of headers. That could be interesting if Cppcheck
+is very slow. But normally, you should check the code in headers.</p>
+
+<p>It is possible to check the code in unused templates. However the Cppcheck
+AST will be incomplete/wrong. The recommendation is that you do not check
+unused templates to avoid wrong warnings. The templates will be checked
+properly when you do use them.</p>
+
+<p>Max CTU depth: How deep should the whole program analysis be. The risk with
+a &quot;too high&quot; value is that Cppcheck will be slow.</p>
+
+<p>Max recursion in template instantiation: Max recursion when Cppcheck
+instantiates templates. The risk with a &quot;too high&quot; value is that
+Cppcheck will be slow and can require much memory.</p>
+
+
+<h2>Warning options</h2>
+
+<h3>Root path</h3>
+
+<p>The root path for warnings. Cppcheck will strip away this part of the path
+from warnings. For instance if there is a warning in
+<pre>../myproject/foo/bar/file.cpp</pre> and the root path is 
+<pre>../myproject/foo</pre> then the path for the warning will be
+<pre>bar/file.cpp</pre>.</p>
+
+<h3>Warning Tags</h3>
+
+<p>Tags allow you to manually categorize warnings.</p>
+
+<h3>Exclude source files</h3>
+
+<p>Excluded source files will not be analyzed by Cppcheck.</p>
+
+<h3>Suppressions</h3>
+
+<p>List of suppressions. These warnings will not be shown.</p>
+
+<h2>Addons</h2>
+
+<p><b>Y2038</b><br>32-bit timers that count number of seconds since 1970 will
+overflow in year 2038. Check that the code does not use such timers.</p>
+
+<p><b>Thread safety</b><br>Check that the code is thread safe</p>
+
+<p><b>MISRA</b><br>Ensure that the MISRA coding standard is followed. Please
+note you need to have a textfile with the misra rule texts to get proper
+warning messages. Cppcheck is not legally allowed to distribute the misra
+rule texts.</p>
+
+<p><b>Clang-tidy</b><br>Run Clang-tidy</p>
+
+</body>
+</html>
+
diff --git a/gui/help/severities.html b/gui/help/severities.html
new file mode 100644
index 00000000000..791c78c68e6
--- /dev/null
+++ b/gui/help/severities.html
@@ -0,0 +1,47 @@
+<html>
+<head>
+<title>Severities</title>
+</head>
+<body>
+
+<h1>Severities</h1>
+
+<h2>error</h2>
+
+<img src="images/severities-error.png"><br>
+<p>when code is executed there is some bad behavior (undefined behavior, leak)</p>
+
+<h2>warning</h2>
+
+<img src="images/severities-warning.png"><br>
+<p>when code is executed there might be undefined behavior</p>
+
+<h2>style</h2>
+
+<img src="images/severities-style.png"><br>
+<p>point out possible mistakes, and suggest more defensive programming. Examples:
+<ul>
+  <li>unused code/variables/functions
+  <li>conditions that are always true/false
+  <li>constness
+  <li>operator precedence
+</ul>
+</p>
+
+<h2>performance</h2>
+
+<img src="images/severities-performance.png"><br>
+<p>Suggestions for making the code faster. These suggestions are only based on common knowledge. It is not certain you'll get any measurable difference in speed by fixing these messages.</p>
+
+<h2>portability</h2>
+
+<img src="images/severities-portability.png"><br>
+<p>portability warnings. Implementation defined behavior. 64-bit portability. Some undefined behavior that probably works &quot;as you want&quot;. etc.</p>
+
+<h2>information</h2>
+
+<img src="images/severities-information.png"><br>
+<p>Configuration problems. If you get such output then your code is ok but your cppcheck configuration could be improved.</p>
+
+</body>
+</html>
diff --git a/gui/help/standalone-analysis.html b/gui/help/standalone-analysis.html
new file mode 100644
index 00000000000..ad7fae5fe55
--- /dev/null
+++ b/gui/help/standalone-analysis.html
@@ -0,0 +1,17 @@
+
+<html>
+<head>
+<title>Standalone analysis</title>
+</head>
+<body>
+
+<h1>Standalone analysis</h1>
+
+<p>It is possible to quickly analyze files. Open the <i>Analyze</i> menu and click on
+either <i>Files...</i> or <i>Directory...</i>.</p>
+
+<p>It is recommended that you create a project for analysis. A properly configured
+project will give you better analysis.</p>
+
+</body>
+</html>
diff --git a/gui/help/tagging.html b/gui/help/tagging.html
new file mode 100644
index 00000000000..7ac4e7ee8d9
--- /dev/null
+++ b/gui/help/tagging.html
@@ -0,0 +1,22 @@
+<html>
+<head>
+<title>Tagging warnings</title>
+</head>
+<body>
+
+<h1>Tagging warnings</h1>
+
+<p>You can manually categorize warnings.</p>
+
+<p>You choose the names of the categories yourself in the project file
+dialog.</p>
+
+<p>If tag names are configured, then you can tag the warnings by
+right-clicking on them and selecting the proper tag in the
+context menu.</p>
+
+<p>Tags are saved in the project file and will be permanent.</p>
+
+</body>
+</html>
+
diff --git a/gui/help/walkthrough.html b/gui/help/walkthrough.html
new file mode 100644
index 00000000000..9f27ce05f6c
--- /dev/null
+++ b/gui/help/walkthrough.html
@@ -0,0 +1,69 @@
+<html>
+<head>
+<title>Walk through</title>
+</head>
+<body>
+
+<h1>Quick walk through</h1>
+
+This is a quick and short walk through to get you started.
+
+<h2>Step 1: Create a project.</h2>
+
+<p>Create a new project:</p>
+
+<blockquote><img src="images/walkthrough-new-project.png"></blockquote>
+
+<p>In the <i>Paths and Defines</i> tab, it is recommended that you import your
+project file at the top.</p>
+
+<blockquote><img src="images/walkthrough-import-project.png"></blockquote>
+
+<p>In the <i>Types and Functions</i> tab, try to activate all 3rd party
+libraries you use (windows, posix, ...).</p>
+
+<blockquote><img src="images/walkthrough-library.png"></blockquote>
+
+<p>In the <i>Analysis</i> tab, leave the default settings to start with.</p>
+
+<p>In the <i>Warnings options</i> tab, leave the default settings to start
+with.</p>
+
+<p>In the <i>Addons</i> tab, leave the default settings to start with.</p>
+
+
+<h2>Step 2: Analyze code.</h2>
+
+<p>When the project file has been created, the analysis will start
+automatically.</p>
+
+<p>While analysis is performed in the background, you can investigate the
+results.</p>
+
+<blockquote><img src="images/walkthrough-analysis.png"></blockquote>
+
+
+<h2>Step 3: Investigate warnings.</h2>
+
+<p>In the toolbar you choose what types of warnings you want to see
+(error/warning/style/performance/portability/information).</p>
+
+<blockquote><img src="images/walkthrough-toolbar-severities.png"></blockquote>
+
+
+<p>All warnings are shown in a list. If you select a warning in the list, then
+details about that warning is shown.</p>
+
+<p>If you right click on warning(s) then you get a context menu.</p>
+
+<blockquote><img src="images/walkthrough-warning-menu.png"></blockquote>
+
+<p>The difference of &quot;Hide&quot; and &quot;Suppress&quot; is that
+suppressions are saved in the project file. The suppressed warnings will not be
+shown again unless you remove the suppression. When you hide a warning then
+they will be temporarily hidden; the next time you analyze your code these
+warnings will be shown again.</p>
+
+</body>
+</html>
+
diff --git a/gui/helpdialog.cpp b/gui/helpdialog.cpp
new file mode 100644
index 00000000000..0768318531c
--- /dev/null
+++ b/gui/helpdialog.cpp
@@ -0,0 +1,122 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "helpdialog.h"
+
+#include "common.h"
+#include "utils.h"
+
+#include "ui_helpdialog.h"
+
+#include <QApplication>
+#include <QFileInfo>
+#include <QHelpEngine>
+#include <QHelpContentWidget>
+#include <QHelpIndexWidget>
+#include <QMessageBox>
+#include <QString>
+#include <QStringList>
+#include <QUrl>
+#include <QVBoxLayout>
+
+class QWidget;
+
+void HelpBrowser::setHelpEngine(QHelpEngine *helpEngine)
+{
+    mHelpEngine = helpEngine;
+}
+
+QVariant HelpBrowser::loadResource(int type, const QUrl &name)
+{
+    if (name.scheme() == "qthelp") {
+        QString url(name.toString());
+        while (url.indexOf("/./") > 0)
+            url.remove(url.indexOf("/./"), 2);
+        return QVariant(mHelpEngine->fileData(QUrl(url)));
+    }
+    return QTextBrowser::loadResource(type, name);
+}
+
+static QString getHelpFile()
+{
+    const QString datadir = getDataDir();
+
+    QStringList paths;
+    paths << (datadir + "/help")
+          << datadir
+          << (QApplication::applicationDirPath() + "/help")
+          << QApplication::applicationDirPath();
+#ifdef FILESDIR
+    const QString filesdir = FILESDIR;
+    paths << (filesdir + "/help")
+          << filesdir;
+#endif
+    for (const QString &p: utils::as_const(paths)) {
+        QString filename = p + "/online-help.qhc";
+        if (QFileInfo::exists(filename))
+            return filename;
+    }
+    return QString();
+}
+
+HelpDialog::HelpDialog(QWidget *parent) :
+    QDialog(parent),
+    mUi(new Ui::HelpDialog)
+{
+    mUi->setupUi(this);
+
+    QString helpFile = getHelpFile();
+    if (helpFile.isEmpty()) {
+        const QString msg = tr("Helpfile '%1' was not found").arg("online-help.qhc");
+        QMessageBox msgBox(QMessageBox::Warning,
+                           tr("Cppcheck"),
+                           msg,
+                           QMessageBox::Ok,
+                           this);
+        msgBox.exec();
+        mHelpEngine = nullptr;
+        return;
+    }
+
+    mHelpEngine = new QHelpEngine(helpFile);
+    // Disable the timestamp check of online-help.qhc by setting _q_readonly
+    mHelpEngine->setProperty("_q_readonly", QVariant::fromValue<bool>(true));
+    mHelpEngine->setupData();
+
+    mUi->contents->addWidget(mHelpEngine->contentWidget());
+    mUi->index->addWidget(mHelpEngine->indexWidget());
+
+    mUi->textBrowser->setHelpEngine(mHelpEngine);
+
+    mUi->textBrowser->setSource(QUrl("qthelp://cppcheck.sourceforge.io/doc/index.html"));
+    connect(mHelpEngine->contentWidget(),
+            SIGNAL(linkActivated(QUrl)),
+            mUi->textBrowser,
+            SLOT(setSource(QUrl)));
+
+    connect(mHelpEngine->indexWidget(),
+            SIGNAL(linkActivated(QUrl,QString)),
+            mUi->textBrowser,
+            SLOT(setSource(QUrl)));
+}
+
+HelpDialog::~HelpDialog()
+{
+    delete mUi;
+    delete mHelpEngine;
+}
diff --git a/gui/helpdialog.h b/gui/helpdialog.h
new file mode 100644
index 00000000000..4f592f5c7f6
--- /dev/null
+++ b/gui/helpdialog.h
@@ -0,0 +1,57 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef HELPDIALOG_H
+#define HELPDIALOG_H
+
+#include <QDialog>
+#include <QObject>
+#include <QTextBrowser>
+
+class QHelpEngine;
+class QWidget;
+namespace Ui {
+    class HelpDialog;
+}
+
+class HelpBrowser : public QTextBrowser {
+public:
+    explicit HelpBrowser(QWidget* parent = nullptr) : QTextBrowser(parent) {}
+    HelpBrowser(const HelpBrowser&) = delete;
+    HelpBrowser(HelpBrowser&&) = delete;
+    HelpBrowser& operator=(const HelpBrowser&) = delete;
+    HelpBrowser& operator=(HelpBrowser&&) = delete;
+    void setHelpEngine(QHelpEngine *helpEngine);
+    QVariant loadResource(int type, const QUrl& name) override;
+private:
+    QHelpEngine* mHelpEngine{};
+};
+
+class HelpDialog : public QDialog {
+    Q_OBJECT
+
+public:
+    explicit HelpDialog(QWidget *parent = nullptr);
+    ~HelpDialog() override;
+
+private:
+    Ui::HelpDialog *mUi;
+    QHelpEngine* mHelpEngine;
+};
+
+#endif // HELPDIALOG_H
diff --git a/gui/helpdialog.ui b/gui/helpdialog.ui
new file mode 100644
index 00000000000..0fb74c6a1e2
--- /dev/null
+++ b/gui/helpdialog.ui
@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>HelpDialog</class>
+ <widget class="QDialog" name="HelpDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>635</width>
+    <height>446</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Cppcheck GUI help</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QSplitter" name="splitter">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <widget class="QTabWidget" name="tabs">
+      <property name="maximumSize">
+       <size>
+        <width>200</width>
+        <height>16777215</height>
+       </size>
+      </property>
+      <property name="currentIndex">
+       <number>0</number>
+      </property>
+      <widget class="QWidget" name="tabContents">
+       <attribute name="title">
+        <string>Contents</string>
+       </attribute>
+       <layout class="QVBoxLayout" name="verticalLayout_5">
+        <item>
+         <layout class="QVBoxLayout" name="contents"/>
+        </item>
+       </layout>
+      </widget>
+      <widget class="QWidget" name="tabIndex">
+       <attribute name="title">
+        <string>Index</string>
+       </attribute>
+       <layout class="QVBoxLayout" name="verticalLayout_3">
+        <item>
+         <layout class="QVBoxLayout" name="index"/>
+        </item>
+       </layout>
+      </widget>
+     </widget>
+     <widget class="HelpBrowser" name="textBrowser"/>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>HelpBrowser</class>
+   <extends>QTextBrowser</extends>
+   <header>helpdialog.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/gui/images/verify.svg b/gui/images/verify.svg
new file mode 100644
index 00000000000..41cdf3c04ab
--- /dev/null
+++ b/gui/images/verify.svg
@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="297"
+   height="210"
+   viewBox="0 0 78.581252 55.562501"
+   version="1.1"
+   id="svg8"
+   inkscape:version="0.92.4 (5da689c313, 2019-01-14)"
+   sodipodi:docname="verify.svg"
+   inkscape:export-filename="/home/danielm/verify.svg.png"
+   inkscape:export-xdpi="96"
+   inkscape:export-ydpi="96">
+  <defs
+     id="defs2" />
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="1.3764247"
+     inkscape:cx="231.16151"
+     inkscape:cy="218.89725"
+     inkscape:document-units="mm"
+     inkscape:current-layer="layer1"
+     showgrid="false"
+     inkscape:window-width="1920"
+     inkscape:window-height="981"
+     inkscape:window-x="0"
+     inkscape:window-y="28"
+     inkscape:window-maximized="1"
+     units="px" />
+  <metadata
+     id="metadata5">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     transform="translate(0,-241.4375)">
+    <ellipse
+       id="path3715"
+       cx="38.99736"
+       cy="269.44327"
+       style="fill:#4d4d4d;stroke-width:0.1327479"
+       rx="21.936352"
+       ry="21.681561" />
+    <path
+       style="fill:#ffffff;stroke:#000000;stroke-width:0.1327479px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       d="m 25.288891,266.30976 11.703894,15.45035 17.71617,-21.78895 -4.248675,-3.6447 -13.467495,16.16344 -7.294892,-9.34944 z"
+       id="path4522"
+       inkscape:connector-curvature="0"
+       sodipodi:nodetypes="ccccccc" />
+  </g>
+</svg>
diff --git a/gui/libraryaddfunctiondialog.cpp b/gui/libraryaddfunctiondialog.cpp
index 9a02840243e..225176b0024 100644
--- a/gui/libraryaddfunctiondialog.cpp
+++ b/gui/libraryaddfunctiondialog.cpp
@@ -1,16 +1,39 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2023 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #include "libraryaddfunctiondialog.h"
+
 #include "ui_libraryaddfunctiondialog.h"
 
-#include <QRegExp>
-#include <QValidator>
+#include <QLineEdit>
+#include <QRegularExpression>
+#include <QRegularExpressionValidator>
+#include <QSpinBox>
+
+class QWidget;
 
 LibraryAddFunctionDialog::LibraryAddFunctionDialog(QWidget *parent) :
     QDialog(parent),
     mUi(new Ui::LibraryAddFunctionDialog)
 {
     mUi->setupUi(this);
-    QRegExp rx(NAMES);
-    QValidator *validator = new QRegExpValidator(rx, this);
+    static const QRegularExpression rx(NAMES);
+    QValidator *validator = new QRegularExpressionValidator(rx, this);
     mUi->functionName->setValidator(validator);
 }
 
diff --git a/gui/libraryaddfunctiondialog.h b/gui/libraryaddfunctiondialog.h
index 3dd81ccd538..d0ff04ac866 100644
--- a/gui/libraryaddfunctiondialog.h
+++ b/gui/libraryaddfunctiondialog.h
@@ -1,23 +1,44 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #ifndef LIBRARYADDFUNCTIONDIALOG_H
 #define LIBRARYADDFUNCTIONDIALOG_H
 
 #include <QDialog>
+#include <QObject>
+#include <QString>
 
-#define SIMPLENAME     "[_a-zA-Z][_a-zA-Z0-9]*"            // just a name
-#define SCOPENAME      SIMPLENAME "(::" SIMPLENAME ")*"    // names with optional scope
-#define NAMES          SCOPENAME "(," SCOPENAME ")*"       // names can be separated by comma
-
+class QWidget;
 namespace Ui {
     class LibraryAddFunctionDialog;
 }
 
+#define SIMPLENAME     "[_a-zA-Z][_a-zA-Z0-9]*"            // just a name
+#define SCOPENAME      SIMPLENAME "(::" SIMPLENAME ")*"    // names with optional scope
+#define NAMES          SCOPENAME "(," SCOPENAME ")*"       // names can be separated by comma
+
 class LibraryAddFunctionDialog : public QDialog {
     Q_OBJECT
 
 public:
     explicit LibraryAddFunctionDialog(QWidget *parent = nullptr);
     LibraryAddFunctionDialog(const LibraryAddFunctionDialog &) = delete;
-    ~LibraryAddFunctionDialog();
+    ~LibraryAddFunctionDialog() override;
     LibraryAddFunctionDialog &operator=(const LibraryAddFunctionDialog &) = delete;
 
     QString functionName() const;
diff --git a/gui/librarydialog.cpp b/gui/librarydialog.cpp
index c2d971dd882..3199af9a975 100644
--- a/gui/librarydialog.cpp
+++ b/gui/librarydialog.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,37 +17,53 @@
  */
 
 #include "librarydialog.h"
-#include "ui_librarydialog.h"
+
+#include "common.h"
 #include "libraryaddfunctiondialog.h"
 #include "libraryeditargdialog.h"
 #include "path.h"
+#include "utils.h"
 
+#include "ui_librarydialog.h"
+
+#include <QCheckBox>
+#include <QComboBox>
 #include <QFile>
-#include <QSettings>
 #include <QFileDialog>
-#include <QTextStream>
-#include <QInputDialog>
+#include <QIODevice>
+#include <QLineEdit>
+#include <QList>
+#include <QListWidget>
+#include <QListWidgetItem>
 #include <QMessageBox>
+#include <QPlainTextEdit>
+#include <QPushButton>
+#include <QRegularExpression>
+#include <QTextStream>
+#include <Qt>
+
+class QWidget;
 
 // TODO: get/compare functions from header
 
-class FunctionListItem : public QListWidgetItem {
-public:
-    FunctionListItem(QListWidget *view,
-                     CppcheckLibraryData::Function *function,
-                     bool selected)
-        : QListWidgetItem(view), function(function) {
-        setText(function->name);
-        setFlags(flags() | Qt::ItemIsEditable);
-        setSelected(selected);
-    }
-    CppcheckLibraryData::Function *function;
-};
+namespace {
+    class FunctionListItem : public QListWidgetItem {
+    public:
+        FunctionListItem(QListWidget *view,
+                         CppcheckLibraryData::Function *function,
+                         bool selected)
+            : QListWidgetItem(view), function(function) {
+            setText(function->name);
+            setFlags(flags() | Qt::ItemIsEditable);
+            setSelected(selected);
+        }
+        CppcheckLibraryData::Function *function;
+    };
+}
 
 LibraryDialog::LibraryDialog(QWidget *parent) :
     QDialog(parent),
-    mUi(new Ui::LibraryDialog),
-    mIgnoreChanges(false)
+    mUi(new Ui::LibraryDialog)
 {
     mUi->setupUi(this);
     mUi->buttonSave->setEnabled(false);
@@ -70,21 +86,20 @@ CppcheckLibraryData::Function *LibraryDialog::currentFunction()
     QList<QListWidgetItem *> selitems = mUi->functions->selectedItems();
     if (selitems.count() != 1)
         return nullptr;
-    return static_cast<FunctionListItem *>(selitems.first())->function;
+    return dynamic_cast<FunctionListItem *>(selitems.first())->function;
 }
 
 void LibraryDialog::openCfg()
 {
-    const QSettings settings;
-    const QString datadir = settings.value("DATADIR",QString()).toString();
+    const QString datadir = getDataDir();
 
     QString selectedFilter;
     const QString filter(tr("Library files (*.cfg)"));
     const QString selectedFile = QFileDialog::getOpenFileName(this,
-                                 tr("Open library file"),
-                                 datadir,
-                                 filter,
-                                 &selectedFilter);
+                                                              tr("Open library file"),
+                                                              datadir,
+                                                              filter,
+                                                              &selectedFilter);
 
     if (selectedFile.isEmpty())
         return;
@@ -121,8 +136,8 @@ void LibraryDialog::openCfg()
     mUi->functions->clear();
     for (CppcheckLibraryData::Function &function : mData.functions) {
         mUi->functions->addItem(new FunctionListItem(mUi->functions,
-                                &function,
-                                false));
+                                                     &function,
+                                                     false));
     }
     mUi->sortFunctions->setEnabled(!mData.functions.empty());
     mUi->filter->setEnabled(!mData.functions.empty());
@@ -152,11 +167,11 @@ void LibraryDialog::saveCfg()
 void LibraryDialog::saveCfgAs()
 {
     const QString filter(tr("Library files (*.cfg)"));
-    const QString path = Path::getPathFromFilename(mFileName.toStdString()).c_str();
+    const QString path = QString::fromStdString(Path::getPathFromFilename(mFileName.toStdString()));
     QString selectedFile = QFileDialog::getSaveFileName(this,
-                           tr("Save the library as"),
-                           path,
-                           filter);
+                                                        tr("Save the library as"),
+                                                        path,
+                                                        filter);
     if (selectedFile.isEmpty())
         return;
 
@@ -169,12 +184,12 @@ void LibraryDialog::saveCfgAs()
 
 void LibraryDialog::addFunction()
 {
-    LibraryAddFunctionDialog *d = new LibraryAddFunctionDialog;
+    auto *d = new LibraryAddFunctionDialog;
     if (d->exec() == QDialog::Accepted && !d->functionName().isEmpty()) {
 
         CppcheckLibraryData::Function f;
         f.name = d->functionName();
-        int args = d->numberOfArguments();
+        const int args = d->numberOfArguments();
 
         for (int i = 1; i <= args; i++) {
             CppcheckLibraryData::Function::Arg arg;
@@ -197,7 +212,8 @@ void LibraryDialog::editFunctionName(QListWidgetItem* item)
     QString functionName = item->text();
     CppcheckLibraryData::Function * const function = dynamic_cast<FunctionListItem*>(item)->function;
     if (functionName != function->name) {
-        if (QRegExp(NAMES).exactMatch(functionName)) {
+        const QRegularExpressionMatch matchRes = QRegularExpression("^" NAMES "$").match(functionName);
+        if (matchRes.hasMatch()) {
             function->name = functionName;
             mUi->buttonSave->setEnabled(true);
         } else {
@@ -258,12 +274,12 @@ void LibraryDialog::sortFunctions(bool sort)
         mUi->functions->sortItems();
     } else {
         mIgnoreChanges = true;
-        CppcheckLibraryData::Function *selfunction = currentFunction();
+        const CppcheckLibraryData::Function* selfunction = currentFunction();
         mUi->functions->clear();
         for (CppcheckLibraryData::Function &function : mData.functions) {
             mUi->functions->addItem(new FunctionListItem(mUi->functions,
-                                    &function,
-                                    selfunction == &function));
+                                                         &function,
+                                                         selfunction == &function));
         }
         if (!mUi->filter->text().isEmpty())
             filterFunctions(mUi->filter->text());
@@ -271,16 +287,16 @@ void LibraryDialog::sortFunctions(bool sort)
     }
 }
 
-void LibraryDialog::filterFunctions(QString filter)
+void LibraryDialog::filterFunctions(const QString& filter)
 {
     QList<QListWidgetItem *> allItems = mUi->functions->findItems(QString(), Qt::MatchContains);
 
     if (filter.isEmpty()) {
-        foreach (QListWidgetItem *item, allItems) {
+        for (QListWidgetItem *item : utils::as_const(allItems)) {
             item->setHidden(false);
         }
     } else {
-        foreach (QListWidgetItem *item, allItems) {
+        for (QListWidgetItem *item : utils::as_const(allItems)) {
             item->setHidden(!item->text().startsWith(filter));
         }
     }
@@ -296,7 +312,7 @@ void LibraryDialog::changeFunction()
         return;
 
     function->comments   = mUi->comments->toPlainText();
-    function->noreturn   = (CppcheckLibraryData::Function::TrueFalseUnknown)mUi->noreturn->currentIndex();
+    function->noreturn   = static_cast<CppcheckLibraryData::Function::TrueFalseUnknown>(mUi->noreturn->currentIndex());
     function->useretval  = mUi->useretval->isChecked();
     function->leakignore = mUi->leakignore->isChecked();
 
@@ -315,7 +331,7 @@ void LibraryDialog::editArg()
 
     LibraryEditArgDialog d(nullptr, arg);
     if (d.exec() == QDialog::Accepted) {
-        unsigned number = arg.nr;
+        const unsigned number = arg.nr;
         arg = d.getArg();
         arg.nr = number;
         mUi->arguments->selectedItems().first()->setText(getArgText(arg));
@@ -329,13 +345,13 @@ QString LibraryDialog::getArgText(const CppcheckLibraryData::Function::Arg &arg)
     if (arg.nr != CppcheckLibraryData::Function::Arg::ANY)
         s += QString::number(arg.nr);
 
-    s += "\n    not bool: " + QString(arg.notbool ? "true" : "false");
-    s += "\n    not null: " + QString(arg.notnull ? "true" : "false");
-    s += "\n    not uninit: " + QString(arg.notuninit ? "true" : "false");
-    s += "\n    format string: " + QString(arg.formatstr ? "true" : "false");
-    s += "\n    strz: " + QString(arg.strz ? "true" : "false");
-    s += "\n    valid: " + QString(arg.valid.isEmpty() ? "any" : arg.valid);
-    foreach (const CppcheckLibraryData::Function::Arg::MinSize &minsize, arg.minsizes) {
+    s += "\n    not bool: " + QString(bool_to_string(arg.notbool));
+    s += "\n    not null: " +  QString(bool_to_string(arg.notnull));
+    s += "\n    not uninit: " +  QString(bool_to_string(arg.notuninit));
+    s += "\n    format string: " +  QString(bool_to_string(arg.formatstr));
+    s += "\n    strz: " +  QString(bool_to_string(arg.strz));
+    s += "\n    valid: " + (arg.valid.isEmpty() ? "any" : arg.valid);
+    for (const CppcheckLibraryData::Function::Arg::MinSize &minsize : arg.minsizes) {
         s += "\n    minsize: " + minsize.type + " " + minsize.arg + " " + minsize.arg2;
     }
     return s;
@@ -344,7 +360,7 @@ QString LibraryDialog::getArgText(const CppcheckLibraryData::Function::Arg &arg)
 void LibraryDialog::updateArguments(const CppcheckLibraryData::Function &function)
 {
     mUi->arguments->clear();
-    foreach (const CppcheckLibraryData::Function::Arg &arg, function.args) {
+    for (const CppcheckLibraryData::Function::Arg &arg : function.args) {
         mUi->arguments->addItem(getArgText(arg));
     }
 }
diff --git a/gui/librarydialog.h b/gui/librarydialog.h
index ffb26b2970e..285d36a820a 100644
--- a/gui/librarydialog.h
+++ b/gui/librarydialog.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,13 +19,14 @@
 #ifndef LIBRARYDIALOG_H
 #define LIBRARYDIALOG_H
 
-#include <QDialog>
-#include <QFile>
-
 #include "cppchecklibrarydata.h"
 
-class QListWidgetItem;
+#include <QDialog>
+#include <QObject>
+#include <QString>
 
+class QListWidgetItem;
+class QWidget;
 namespace Ui {
     class LibraryDialog;
 }
@@ -36,7 +37,7 @@ class LibraryDialog : public QDialog {
 public:
     explicit LibraryDialog(QWidget *parent = nullptr);
     LibraryDialog(const LibraryDialog &) = delete;
-    ~LibraryDialog();
+    ~LibraryDialog() override;
     LibraryDialog &operator=(const LibraryDialog &) = delete;
 
 private slots:
@@ -46,16 +47,16 @@ private slots:
     void addFunction();
     void changeFunction();
     void editArg();
-    void editFunctionName(QListWidgetItem*);
-    void filterFunctions(QString);
+    void editFunctionName(QListWidgetItem* /*item*/);
+    void filterFunctions(const QString& /*filter*/);
     void selectFunction();
-    void sortFunctions(bool);
+    void sortFunctions(bool /*sort*/);
 
 private:
     Ui::LibraryDialog *mUi;
     CppcheckLibraryData mData;
     QString mFileName;
-    bool mIgnoreChanges;
+    bool mIgnoreChanges{};
 
     static QString getArgText(const CppcheckLibraryData::Function::Arg &arg);
     CppcheckLibraryData::Function *currentFunction();
diff --git a/gui/libraryeditargdialog.cpp b/gui/libraryeditargdialog.cpp
index a874ed760ba..2b8521dd686 100644
--- a/gui/libraryeditargdialog.cpp
+++ b/gui/libraryeditargdialog.cpp
@@ -1,6 +1,34 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #include "libraryeditargdialog.h"
+
 #include "ui_libraryeditargdialog.h"
 
+#include <QCheckBox>
+#include <QComboBox>
+#include <QLineEdit>
+#include <QSpinBox>
+#include <QString>
+#include <QStringList>
+
+class QWidget;
+
 LibraryEditArgDialog::LibraryEditArgDialog(QWidget *parent, const CppcheckLibraryData::Function::Arg &arg) :
     QDialog(parent),
     mUi(new Ui::LibraryEditArgDialog),
@@ -89,7 +117,7 @@ CppcheckLibraryData::Function::Arg LibraryEditArgDialog::getArg() const
     return ret;
 }
 
-void LibraryEditArgDialog::minsizeChanged(int)
+void LibraryEditArgDialog::minsizeChanged()
 {
     mUi->minsize1arg->setEnabled(mUi->minsize1type->currentIndex() != 0);
     mUi->minsize1arg2->setEnabled(mUi->minsize1type->currentText() == "mul");
diff --git a/gui/libraryeditargdialog.h b/gui/libraryeditargdialog.h
index f14317ad13b..15d081eee68 100644
--- a/gui/libraryeditargdialog.h
+++ b/gui/libraryeditargdialog.h
@@ -1,9 +1,31 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #ifndef LIBRARYEDITARGDIALOG_H
 #define LIBRARYEDITARGDIALOG_H
 
-#include <QDialog>
 #include "cppchecklibrarydata.h"
 
+#include <QDialog>
+#include <QList>
+#include <QObject>
+
+class QWidget;
 namespace Ui {
     class LibraryEditArgDialog;
 }
@@ -14,13 +36,13 @@ class LibraryEditArgDialog : public QDialog {
 public:
     LibraryEditArgDialog(QWidget *parent, const CppcheckLibraryData::Function::Arg &arg);
     LibraryEditArgDialog(const LibraryEditArgDialog &) = delete;
-    ~LibraryEditArgDialog();
+    ~LibraryEditArgDialog() override;
     LibraryEditArgDialog &operator=(const LibraryEditArgDialog &) = delete;
 
     CppcheckLibraryData::Function::Arg getArg() const;
 
 private slots:
-    void minsizeChanged(int);
+    void minsizeChanged();
 
 private:
     Ui::LibraryEditArgDialog *mUi;
diff --git a/gui/libraryeditargdialog.ui b/gui/libraryeditargdialog.ui
index 49a57ba78b5..6994c7829a6 100644
--- a/gui/libraryeditargdialog.ui
+++ b/gui/libraryeditargdialog.ui
@@ -366,7 +366,7 @@
    <sender>minsize1type</sender>
    <signal>currentIndexChanged(int)</signal>
    <receiver>LibraryEditArgDialog</receiver>
-   <slot>minsizeChanged(int)</slot>
+   <slot>minsizeChanged()</slot>
    <hints>
     <hint type="sourcelabel">
      <x>413</x>
@@ -382,7 +382,7 @@
    <sender>minsize2type</sender>
    <signal>currentIndexChanged(int)</signal>
    <receiver>LibraryEditArgDialog</receiver>
-   <slot>minsizeChanged(int)</slot>
+   <slot>minsizeChanged()</slot>
    <hints>
     <hint type="sourcelabel">
      <x>436</x>
@@ -396,6 +396,6 @@
   </connection>
  </connections>
  <slots>
-  <slot>minsizeChanged(int)</slot>
+  <slot>minsizeChanged()</slot>
  </slots>
 </ui>
diff --git a/gui/main.cpp b/gui/main.cpp
index d1bb3c0b8f6..830cb29a72d 100644
--- a/gui/main.cpp
+++ b/gui/main.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,23 +16,29 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QApplication>
-#include <QCoreApplication>
-#include <QTextCodec>
-#include <QMetaType>
-#include <QStringList>
-#include <QSettings>
+#include "cppcheck.h"
+#include "common.h"
+#include "mainwindow.h"
+#include "erroritem.h" // IWYU pragma: keep
+#include "translationhandler.h"
+
 #ifdef _WIN32
+#include "aboutdialog.h"
+
 #include <QMessageBox>
 #else
 #include <iostream>
 #endif
-#include "cppcheck.h"
-#include "common.h"
-#include "mainwindow.h"
-#include "erroritem.h"
-#include "aboutdialog.h"
-#include "translationhandler.h"
+#include <algorithm>
+#include <string>
+
+#include <QApplication>
+#include <QCoreApplication>
+#include <QIcon>
+#include <QSettings>
+#include <QString>
+#include <QStringList>
+#include <QVariant>
 
 
 static void ShowUsage();
@@ -41,49 +47,37 @@ static bool CheckArgs(const QStringList &args);
 
 int main(int argc, char *argv[])
 {
-
-#if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0))
-    QApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
-    QApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
-#endif
-
     QApplication app(argc, argv);
 
-#if QT_VERSION < 0x050000
-    // Set codecs so that UTF-8 strings in sources are handled correctly.
-    // This is ONLY needed for Qt versions 4.x.
-    // Qt 5.x assumes UTF-8 by default.
-    QTextCodec::setCodecForTr(QTextCodec::codecForName("UTF-8"));
-    QTextCodec::setCodecForCStrings(QTextCodec::codecForName("UTF-8"));
-#endif
-
     QCoreApplication::setOrganizationName("Cppcheck");
     QCoreApplication::setApplicationName("Cppcheck-GUI");
 
-    QSettings* settings = new QSettings("Cppcheck", "Cppcheck-GUI", &app);
+    auto* settings = new QSettings("Cppcheck", "Cppcheck-GUI", &app);
 
     // Set data dir..
-    foreach (const QString arg, app.arguments()) {
-        if (arg.startsWith("--data-dir=")) {
-            settings->setValue("DATADIR", arg.mid(11));
-            return 0;
-        }
+    const QStringList args = QApplication::arguments();
+    auto it = std::find_if(args.cbegin(), args.cend(), [](const QString& arg) {
+        return arg.startsWith("--data-dir=");
+    });
+    if (it != args.end()) {
+        settings->setValue("DATADIR", it->mid(11));
+        return 0;
     }
 
-    TranslationHandler* th = new TranslationHandler(&app);
+    auto* th = new TranslationHandler(&app);
     th->setLanguage(settings->value(SETTINGS_LANGUAGE, th->suggestLanguage()).toString());
 
-    if (!CheckArgs(app.arguments()))
+    if (!CheckArgs(QApplication::arguments()))
         return 0;
 
-    app.setWindowIcon(QIcon(":cppcheck-gui.png"));
+    QApplication::setWindowIcon(QIcon(":cppcheck-gui.png"));
 
     // Register this metatype that is used to transfer error info
     qRegisterMetaType<ErrorItem>("ErrorItem");
 
     MainWindow window(th, settings);
     window.show();
-    return app.exec();
+    return QApplication::exec();
 }
 
 // Check only arguments needing action before GUI is shown.
@@ -104,24 +98,24 @@ static bool CheckArgs(const QStringList &args)
 static void ShowUsage()
 {
     QString helpMessage = MainWindow::tr(
-                              "Cppcheck GUI.\n\n"
-                              "Syntax:\n"
-                              "    cppcheck-gui [OPTIONS] [files or paths]\n\n"
-                              "Options:\n"
-                              "    -h, --help              Print this help\n"
-                              "    -p <file>               Open given project file and start checking it\n"
-                              "    -l <file>               Open given results xml file\n"
-                              "    -d <directory>          Specify the directory that was checked to generate the results xml specified with -l\n"
-                              "    -v, --version           Show program version\n"
-                              "    --data-dir=<directory>  This option is for installation scripts so they can configure the directory where\n"
-                              "                            datafiles are located (translations, cfg). The GUI is not started when this option\n"
-                              "                            is used.");
+        "Cppcheck GUI.\n\n"
+        "Syntax:\n"
+        "    cppcheck-gui [OPTIONS] [files or paths]\n\n"
+        "Options:\n"
+        "    -h, --help              Print this help\n"
+        "    -p <file>               Open given project file and start checking it\n"
+        "    -l <file>               Open given results xml file\n"
+        "    -d <directory>          Specify the directory that was checked to generate the results xml specified with -l\n"
+        "    -v, --version           Show program version\n"
+        "    --data-dir=<directory>  This option is for installation scripts so they can configure the directory where\n"
+        "                            datafiles are located (translations, cfg). The GUI is not started when this option\n"
+        "                            is used.");
 #if defined(_WIN32)
     QMessageBox msgBox(QMessageBox::Information,
                        MainWindow::tr("Cppcheck GUI - Command line parameters"),
                        helpMessage,
                        QMessageBox::Ok
-                      );
+                       );
     (void)msgBox.exec();
 #else
     std::cout << helpMessage.toStdString() << std::endl;
@@ -130,6 +124,7 @@ static void ShowUsage()
 
 static void ShowVersion()
 {
+// TODO: should only *not* show a dialog when we are on a commnd-line
 #if defined(_WIN32)
     AboutDialog *dlg = new AboutDialog(CppCheck::version(), CppCheck::extraVersion(), 0);
     dlg->exec();
diff --git a/gui/mainwindow.cpp b/gui/mainwindow.cpp
index 6f2644cc85b..63917bdc912 100644
--- a/gui/mainwindow.cpp
+++ b/gui/mainwindow.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,65 +16,135 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QApplication>
-#include <QDebug>
-#include <QMessageBox>
-#include <QFileInfo>
-#include <QDir>
-#include <QDesktopServices>
-#include <QUrl>
-#include <QAction>
-#include <QActionGroup>
-#include <QFile>
-#include <QInputDialog>
 #include "mainwindow.h"
 
-#include "cppcheck.h"
-
+#include "addoninfo.h"
 #include "applicationlist.h"
 #include "aboutdialog.h"
+#include "analyzerinfo.h"
+#include "checkers.h"
+#include "checkstatistics.h"
+#include "checkthread.h"
 #include "common.h"
-#include "threadhandler.h"
+#include "cppcheck.h"
+#include "errortypes.h"
+#include "filelist.h"
+#include "filesettings.h"
+#include "compliancereportdialog.h"
 #include "fileviewdialog.h"
+#include "helpdialog.h"
+#include "importproject.h"
+#include "librarydialog.h"
+#include "path.h"
+#include "platform.h"
 #include "projectfile.h"
 #include "projectfiledialog.h"
 #include "report.h"
+#include "resultstree.h"
+#include "resultsview.h"
 #include "scratchpad.h"
+#include "settings.h"
+#include "showtypes.h"
 #include "statsdialog.h"
 #include "settingsdialog.h"
+#include "standards.h"
+#include "suppressions.h"
+#include "threadhandler.h"
 #include "threadresult.h"
 #include "translationhandler.h"
-#include "filelist.h"
-#include "showtypes.h"
-#include "librarydialog.h"
+#include "utils.h"
+#include "threaddetails.h"
+
+#include "ui_mainwindow.h"
+
+#include "frontend.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <fstream>
+#include <iterator>
+#include <list>
+#include <memory>
+#include <set>
+#include <string>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include <QApplication>
+#include <QAction>
+#include <QActionGroup>
+#include <QByteArray>
+#include <QChar>
+#include <QCloseEvent>
+#include <QCoreApplication>
+#include <QDateTime>
+#include <QDesktopServices>
+#include <QDebug>
+#include <QDialog>
+#include <QDir>
+#include <QFile>
+#include <QFileInfo>
+#include <QHBoxLayout>
+#include <QInputDialog>
+#include <QKeySequence>
+#include <QLabel>
+#include <QLineEdit>
+#include <QList>
+#include <QMap>
+#include <QMenu>
+#include <QMessageBox>
+#include <QtNetwork/QNetworkAccessManager>
+#include <QtNetwork/QNetworkReply>
+#include <QtNetwork/QNetworkRequest>
+#include <QPushButton>
+#include <QRegularExpression>
+#include <QSettings>
+#include <QSize>
+#include <QTimer>
+#include <QTemporaryFile>
+#include <QToolBar>
+#include <QUrl>
+#include <QVariant>
+#include <Qt>
+
+#include "json.h"
 
-static const QString OnlineHelpURL("http://cppcheck.net/manual.html");
 static const QString compile_commands_json("compile_commands.json");
 
-static QString getDataDir(const QSettings *settings)
-{
-    const QString dataDir = settings->value("DATADIR", QString()).toString();
-    const QString appPath = QFileInfo(QCoreApplication::applicationFilePath()).canonicalPath();
-    return dataDir.isEmpty() ? appPath : dataDir;
+static QString fromNativePath(const QString& p) {
+#ifdef Q_OS_WIN
+    QString ret(p);
+    ret.replace('\\', '/');
+    return ret;
+#else
+    return p;
+#endif
 }
 
 MainWindow::MainWindow(TranslationHandler* th, QSettings* settings) :
     mSettings(settings),
     mApplications(new ApplicationList(this)),
     mTranslation(th),
-    mScratchPad(nullptr),
-    mProjectFile(nullptr),
+    mUI(new Ui::MainWindow),
     mPlatformActions(new QActionGroup(this)),
     mCStandardActions(new QActionGroup(this)),
     mCppStandardActions(new QActionGroup(this)),
     mSelectLanguageActions(new QActionGroup(this)),
-    mExiting(false),
-    mIsLogfileLoaded(false)
-{
-    mUI.setupUi(this);
+    mSelectReportActions(new QActionGroup(this))
+{
+    {
+        Settings tempSettings;
+        tempSettings.exename = QCoreApplication::applicationFilePath().toStdString();
+        Suppressions tempSupprs;
+        Settings::loadCppcheckCfg(tempSettings, tempSupprs); // TODO: how to handle error?
+        mCppcheckCfgProductName = QString::fromStdString(tempSettings.cppcheckCfgProductName);
+        mCppcheckCfgAbout = QString::fromStdString(tempSettings.cppcheckCfgAbout);
+    }
+
+    mUI->setupUi(this);
     mThread = new ThreadHandler(this);
-    mThread->setDataDir(getDataDir(settings));
-    mUI.mResults->initialize(mSettings, mApplications, mThread);
+    mUI->mResults->initialize(mSettings, mApplications, mThread);
 
     // Filter timer to delay filtering results slightly while typing
     mFilterTimer = new QTimer(this);
@@ -83,89 +153,105 @@ MainWindow::MainWindow(TranslationHandler* th, QSettings* settings) :
     connect(mFilterTimer, &QTimer::timeout, this, &MainWindow::filterResults);
 
     // "Filter" toolbar
-    mLineEditFilter = new QLineEdit(mUI.mToolBarFilter);
+    mLineEditFilter = new QLineEdit(mUI->mToolBarFilter);
     mLineEditFilter->setPlaceholderText(tr("Quick Filter:"));
     mLineEditFilter->setClearButtonEnabled(true);
-    mUI.mToolBarFilter->addWidget(mLineEditFilter);
-    connect(mLineEditFilter, SIGNAL(textChanged(const QString&)), mFilterTimer, SLOT(start()));
+    mUI->mToolBarFilter->addWidget(mLineEditFilter);
+    connect(mLineEditFilter, SIGNAL(textChanged(QString)), mFilterTimer, SLOT(start()));
     connect(mLineEditFilter, &QLineEdit::returnPressed, this, &MainWindow::filterResults);
 
-    connect(mUI.mActionPrint, SIGNAL(triggered()), mUI.mResults, SLOT(print()));
-    connect(mUI.mActionPrintPreview, SIGNAL(triggered()), mUI.mResults, SLOT(printPreview()));
-    connect(mUI.mActionQuit, &QAction::triggered, this, &MainWindow::close);
-    connect(mUI.mActionAnalyzeFiles, &QAction::triggered, this, &MainWindow::analyzeFiles);
-    connect(mUI.mActionAnalyzeDirectory, &QAction::triggered, this, &MainWindow::analyzeDirectory);
-    connect(mUI.mActionSettings, &QAction::triggered, this, &MainWindow::programSettings);
-    connect(mUI.mActionClearResults, &QAction::triggered, this, &MainWindow::clearResults);
-    connect(mUI.mActionOpenXML, &QAction::triggered, this, &MainWindow::openResults);
-
-    connect(mUI.mActionShowStyle, &QAction::toggled, this, &MainWindow::showStyle);
-    connect(mUI.mActionShowErrors, &QAction::toggled, this, &MainWindow::showErrors);
-    connect(mUI.mActionShowWarnings, &QAction::toggled, this, &MainWindow::showWarnings);
-    connect(mUI.mActionShowPortability, &QAction::toggled, this, &MainWindow::showPortability);
-    connect(mUI.mActionShowPerformance, &QAction::toggled, this, &MainWindow::showPerformance);
-    connect(mUI.mActionShowInformation, &QAction::toggled, this, &MainWindow::showInformation);
-    connect(mUI.mActionShowCppcheck, &QAction::toggled, mUI.mResults, &ResultsView::showCppcheckResults);
-    connect(mUI.mActionShowClang, &QAction::toggled, mUI.mResults, &ResultsView::showClangResults);
-    connect(mUI.mActionCheckAll, &QAction::triggered, this, &MainWindow::checkAll);
-    connect(mUI.mActionUncheckAll, &QAction::triggered, this, &MainWindow::uncheckAll);
-    connect(mUI.mActionCollapseAll, &QAction::triggered, mUI.mResults, &ResultsView::collapseAllResults);
-    connect(mUI.mActionExpandAll, &QAction::triggered, mUI.mResults, &ResultsView::expandAllResults);
-    connect(mUI.mActionShowHidden, &QAction::triggered, mUI.mResults, &ResultsView::showHiddenResults);
-    connect(mUI.mActionViewStats, &QAction::triggered, this, &MainWindow::showStatistics);
-    connect(mUI.mActionLibraryEditor, &QAction::triggered, this, &MainWindow::showLibraryEditor);
-
-    connect(mUI.mActionReanalyzeModified, &QAction::triggered, this, &MainWindow::reAnalyzeModified);
-    connect(mUI.mActionReanalyzeAll, &QAction::triggered, this, &MainWindow::reAnalyzeAll);
-    connect(mUI.mActionCheckLibrary, &QAction::triggered, this, &MainWindow::checkLibrary);
-    connect(mUI.mActionCheckConfiguration, &QAction::triggered, this, &MainWindow::checkConfiguration);
-
-    connect(mUI.mActionStop, &QAction::triggered, this, &MainWindow::stopAnalysis);
-    connect(mUI.mActionSave, &QAction::triggered, this, &MainWindow::save);
+    connect(mUI->mActionPrint, SIGNAL(triggered()), mUI->mResults, SLOT(print()));
+    connect(mUI->mActionPrintPreview, SIGNAL(triggered()), mUI->mResults, SLOT(printPreview()));
+    connect(mUI->mActionQuit, &QAction::triggered, this, &MainWindow::close);
+    connect(mUI->mActionAnalyzeFiles, &QAction::triggered, this, &MainWindow::analyzeFiles);
+    connect(mUI->mActionAnalyzeDirectory, &QAction::triggered, this, &MainWindow::analyzeDirectory);
+    connect(mUI->mActionSettings, &QAction::triggered, this, &MainWindow::programSettings);
+    connect(mUI->mActionClearResults, &QAction::triggered, this, &MainWindow::clearResults);
+    connect(mUI->mActionOpenXML, &QAction::triggered, this, &MainWindow::openResults);
+
+    connect(mUI->mActionShowStyle, &QAction::toggled, this, &MainWindow::showStyle);
+    connect(mUI->mActionShowErrors, &QAction::toggled, this, &MainWindow::showErrors);
+    connect(mUI->mActionShowWarnings, &QAction::toggled, this, &MainWindow::showWarnings);
+    connect(mUI->mActionShowPortability, &QAction::toggled, this, &MainWindow::showPortability);
+    connect(mUI->mActionShowPerformance, &QAction::toggled, this, &MainWindow::showPerformance);
+    connect(mUI->mActionShowInformation, &QAction::toggled, this, &MainWindow::showInformation);
+    connect(mUI->mActionShowCppcheck, &QAction::toggled, mUI->mResults, &ResultsView::showCppcheckResults);
+    connect(mUI->mActionShowClang, &QAction::toggled, mUI->mResults, &ResultsView::showClangResults);
+    connect(mUI->mActionCheckAll, &QAction::triggered, this, &MainWindow::checkAll);
+    connect(mUI->mActionUncheckAll, &QAction::triggered, this, &MainWindow::uncheckAll);
+    connect(mUI->mActionCollapseAll, &QAction::triggered, mUI->mResults, &ResultsView::collapseAllResults);
+    connect(mUI->mActionExpandAll, &QAction::triggered, mUI->mResults, &ResultsView::expandAllResults);
+    connect(mUI->mActionShowHidden, &QAction::triggered, mUI->mResults, &ResultsView::showHiddenResults);
+    connect(mUI->mActionViewStats, &QAction::triggered, this, &MainWindow::showStatistics);
+    connect(mUI->mActionLibraryEditor, &QAction::triggered, this, &MainWindow::showLibraryEditor);
+    connect(mUI->mActionShowThreadDetails, &QAction::triggered, this, &MainWindow::showThreadDetails);
+
+    connect(mUI->mActionReanalyzeModified, &QAction::triggered, this, &MainWindow::reAnalyzeModified);
+    connect(mUI->mActionReanalyzeAll, &QAction::triggered, this, &MainWindow::reAnalyzeAll);
+    connect(mUI->mActionCheckLibrary, &QAction::triggered, this, &MainWindow::checkLibrary);
+    connect(mUI->mActionCheckConfiguration, &QAction::triggered, this, &MainWindow::checkConfiguration);
+
+    connect(mUI->mActionStop, &QAction::triggered, this, &MainWindow::stopAnalysis);
+    connect(mUI->mActionSave, &QAction::triggered, this, &MainWindow::save);
+    connect(mUI->mActionComplianceReport, &QAction::triggered, this, &MainWindow::complianceReport);
 
     // About menu
-    connect(mUI.mActionAbout, &QAction::triggered, this, &MainWindow::about);
-    connect(mUI.mActionLicense, &QAction::triggered, this, &MainWindow::showLicense);
+    connect(mUI->mActionAbout, &QAction::triggered, this, &MainWindow::about);
+    connect(mUI->mActionLicense, &QAction::triggered, this, &MainWindow::showLicense);
+    mUI->mActionEULA->setVisible(isCppcheckPremium());
+    connect(mUI->mActionEULA, &QAction::triggered, this, &MainWindow::showEULA);
 
     // View > Toolbar menu
-    connect(mUI.mActionToolBarMain, SIGNAL(toggled(bool)), this, SLOT(toggleMainToolBar()));
-    connect(mUI.mActionToolBarView, SIGNAL(toggled(bool)), this, SLOT(toggleViewToolBar()));
-    connect(mUI.mActionToolBarFilter, SIGNAL(toggled(bool)), this, SLOT(toggleFilterToolBar()));
+    connect(mUI->mActionToolBarMain, SIGNAL(toggled(bool)), this, SLOT(toggleMainToolBar()));
+    connect(mUI->mActionToolBarView, SIGNAL(toggled(bool)), this, SLOT(toggleViewToolBar()));
+    connect(mUI->mActionToolBarFilter, SIGNAL(toggled(bool)), this, SLOT(toggleFilterToolBar()));
 
-    connect(mUI.mActionAuthors, &QAction::triggered, this, &MainWindow::showAuthors);
+    connect(mUI->mActionAuthors, &QAction::triggered, this, &MainWindow::showAuthors);
     connect(mThread, &ThreadHandler::done, this, &MainWindow::analysisDone);
-    connect(mThread, &ThreadHandler::log, mUI.mResults, &ResultsView::log);
-    connect(mThread, &ThreadHandler::debugError, mUI.mResults, &ResultsView::debugError);
-    connect(mUI.mResults, &ResultsView::gotResults, this, &MainWindow::resultsAdded);
-    connect(mUI.mResults, &ResultsView::resultsHidden, mUI.mActionShowHidden, &QAction::setEnabled);
-    connect(mUI.mResults, &ResultsView::checkSelected, this, &MainWindow::performSelectedFilesCheck);
-    connect(mUI.mResults, &ResultsView::tagged, this, &MainWindow::tagged);
-    connect(mUI.mResults, &ResultsView::suppressIds, this, &MainWindow::suppressIds);
-    connect(mUI.mMenuView, &QMenu::aboutToShow, this, &MainWindow::aboutToShowViewMenu);
+    connect(mThread, &ThreadHandler::log, mUI->mResults, &ResultsView::log);
+    connect(mThread, &ThreadHandler::debugError, mUI->mResults, &ResultsView::debugError);
+    connect(mUI->mResults, &ResultsView::gotResults, this, &MainWindow::resultsAdded);
+    connect(mUI->mResults, &ResultsView::resultsHidden, mUI->mActionShowHidden, &QAction::setEnabled);
+    connect(mUI->mResults, &ResultsView::checkSelected, this, &MainWindow::performSelectedFilesCheck);
+    connect(mUI->mResults, &ResultsView::suppressIds, this, &MainWindow::suppressIds);
+    connect(mUI->mMenuView, &QMenu::aboutToShow, this, &MainWindow::aboutToShowViewMenu);
+
+    // Change report type
+    connect(mUI->mActionReportNormal, &QAction::triggered, this, &MainWindow::changeReportType);
+    connect(mUI->mActionReportAutosar, &QAction::triggered, this, &MainWindow::changeReportType);
+    connect(mUI->mActionReportCertC, &QAction::triggered, this, &MainWindow::changeReportType);
+    connect(mUI->mActionReportCertCpp, &QAction::triggered, this, &MainWindow::changeReportType);
+    connect(mUI->mActionReportMisraC, &QAction::triggered, this, &MainWindow::changeReportType);
+    connect(mUI->mActionReportMisraCpp2008, &QAction::triggered, this, &MainWindow::changeReportType);
+    connect(mUI->mActionReportMisraCpp2023, &QAction::triggered, this, &MainWindow::changeReportType);
 
     // File menu
-    connect(mUI.mActionNewProjectFile, &QAction::triggered, this, &MainWindow::newProjectFile);
-    connect(mUI.mActionOpenProjectFile, &QAction::triggered, this, &MainWindow::openProjectFile);
-    connect(mUI.mActionShowScratchpad, &QAction::triggered, this, &MainWindow::showScratchpad);
-    connect(mUI.mActionCloseProjectFile, &QAction::triggered, this, &MainWindow::closeProjectFile);
-    connect(mUI.mActionEditProjectFile, &QAction::triggered, this, &MainWindow::editProjectFile);
+    connect(mUI->mActionNewProjectFile, &QAction::triggered, this, &MainWindow::newProjectFile);
+    connect(mUI->mActionOpenProjectFile, &QAction::triggered, this, &MainWindow::openProjectFile);
+    connect(mUI->mActionShowScratchpad, &QAction::triggered, this, &MainWindow::showScratchpad);
+    connect(mUI->mActionCloseProjectFile, &QAction::triggered, this, &MainWindow::closeProjectFile);
+    connect(mUI->mActionEditProjectFile, &QAction::triggered, this, &MainWindow::editProjectFile);
 
-    connect(mUI.mActionHelpContents, &QAction::triggered, this, &MainWindow::openHelpContents);
+    connect(mUI->mActionHelpContents, &QAction::triggered, this, &MainWindow::openHelpContents);
 
     loadSettings();
 
-    mThread->initialize(mUI.mResults);
-    if (mProjectFile)
+    mThread->initialize(mUI->mResults);
+    if (mProjectFile) {
+        enableProjectActions(true);
         formatAndSetTitle(tr("Project:") + ' ' + mProjectFile->getFilename());
-    else
+    } else {
+        enableProjectActions(false);
         formatAndSetTitle();
+    }
+
+    mUI->mActionComplianceReport->setVisible(isCppcheckPremium());
 
     enableCheckButtons(true);
 
-    mUI.mActionPrint->setShortcut(QKeySequence::Print);
+    mUI->mActionPrint->setShortcut(QKeySequence::Print);
     enableResultsButtons();
     enableProjectOpenActions(true);
-    enableProjectActions(false);
 
     // Must setup MRU menu before CLI param handling as it can load a
     // project file and update MRU menu.
@@ -176,7 +262,7 @@ MainWindow::MainWindow(TranslationHandler* th, QSettings* settings) :
                 this, SLOT(openRecentProject()));
     }
     mRecentProjectActs[MaxRecentProjects] = nullptr; // The separator
-    mUI.mActionProjectMRU->setVisible(false);
+    mUI->mActionProjectMRU->setVisible(false);
     updateMRUMenuItems();
 
     QStringList args = QCoreApplication::arguments();
@@ -186,52 +272,88 @@ MainWindow::MainWindow(TranslationHandler* th, QSettings* settings) :
         handleCLIParams(args);
     }
 
-    mUI.mActionCloseProjectFile->setEnabled(mProjectFile != nullptr);
-    mUI.mActionEditProjectFile->setEnabled(mProjectFile != nullptr);
-
     for (int i = 0; i < mPlatforms.getCount(); i++) {
-        Platform platform = mPlatforms.mPlatforms[i];
-        QAction *action = new QAction(this);
+        PlatformData platform = mPlatforms.mPlatforms[i];
+        auto *action = new QAction(this);
         platform.mActMainWindow = action;
         mPlatforms.mPlatforms[i] = platform;
         action->setText(platform.mTitle);
         action->setData(platform.mType);
         action->setCheckable(true);
         action->setActionGroup(mPlatformActions);
-        mUI.mMenuAnalyze->insertAction(mUI.mActionPlatforms, action);
+        mUI->mMenuAnalyze->insertAction(mUI->mActionPlatforms, action);
         connect(action, SIGNAL(triggered()), this, SLOT(selectPlatform()));
     }
 
-    mUI.mActionC89->setActionGroup(mCStandardActions);
-    mUI.mActionC99->setActionGroup(mCStandardActions);
-    mUI.mActionC11->setActionGroup(mCStandardActions);
-
-    mUI.mActionCpp03->setActionGroup(mCppStandardActions);
-    mUI.mActionCpp11->setActionGroup(mCppStandardActions);
-    mUI.mActionCpp14->setActionGroup(mCppStandardActions);
-    mUI.mActionCpp17->setActionGroup(mCppStandardActions);
-    mUI.mActionCpp20->setActionGroup(mCppStandardActions);
-
-    mUI.mActionEnforceC->setActionGroup(mSelectLanguageActions);
-    mUI.mActionEnforceCpp->setActionGroup(mSelectLanguageActions);
-    mUI.mActionAutoDetectLanguage->setActionGroup(mSelectLanguageActions);
-
+    mUI->mActionReportNormal->setActionGroup(mSelectReportActions);
+    mUI->mActionReportAutosar->setActionGroup(mSelectReportActions);
+    mUI->mActionReportCertC->setActionGroup(mSelectReportActions);
+    mUI->mActionReportCertCpp->setActionGroup(mSelectReportActions);
+    mUI->mActionReportMisraC->setActionGroup(mSelectReportActions);
+    mUI->mActionReportMisraCpp2008->setActionGroup(mSelectReportActions);
+    mUI->mActionReportMisraCpp2023->setActionGroup(mSelectReportActions);
+
+    mUI->mActionC89->setActionGroup(mCStandardActions);
+    mUI->mActionC99->setActionGroup(mCStandardActions);
+    mUI->mActionC11->setActionGroup(mCStandardActions);
+    //mUI->mActionC17->setActionGroup(mCStandardActions);
+    //mUI->mActionC23->setActionGroup(mCStandardActions);
+    //mUI->mActionC2Y->setActionGroup(mCStandardActions);
+
+    mUI->mActionCpp03->setActionGroup(mCppStandardActions);
+    mUI->mActionCpp11->setActionGroup(mCppStandardActions);
+    mUI->mActionCpp14->setActionGroup(mCppStandardActions);
+    mUI->mActionCpp17->setActionGroup(mCppStandardActions);
+    mUI->mActionCpp20->setActionGroup(mCppStandardActions);
+    //mUI->mActionCpp23->setActionGroup(mCppStandardActions);
+    //mUI->mActionCpp26->setActionGroup(mCppStandardActions);
+
+    mUI->mActionEnforceC->setActionGroup(mSelectLanguageActions);
+    mUI->mActionEnforceCpp->setActionGroup(mSelectLanguageActions);
+    mUI->mActionAutoDetectLanguage->setActionGroup(mSelectLanguageActions);
+
+    // TODO: we no longer default to a Windows platform in CLI - so we should probably also get rid of this in the GUI
     // For Windows platforms default to Win32 checked platform.
     // For other platforms default to unspecified/default which means the
     // platform Cppcheck GUI was compiled on.
 #if defined(_WIN32)
-    const Settings::PlatformType defaultPlatform = Settings::Win32W;
+    constexpr Platform::Type defaultPlatform = Platform::Type::Win32W;
 #else
-    const Settings::PlatformType defaultPlatform = Settings::Unspecified;
+    constexpr Platform::Type defaultPlatform = Platform::Type::Unspecified;
 #endif
-    Platform &platform = mPlatforms.get((Settings::PlatformType)mSettings->value(SETTINGS_CHECKED_PLATFORM, defaultPlatform).toInt());
+    PlatformData &platform = mPlatforms.get(static_cast<Platform::Type>(mSettings->value(SETTINGS_CHECKED_PLATFORM, defaultPlatform).toInt()));
     platform.mActMainWindow->setChecked(true);
+
+    mNetworkAccessManager = new QNetworkAccessManager(this);
+    connect(mNetworkAccessManager, &QNetworkAccessManager::finished,
+            this, &MainWindow::replyFinished);
+
+    mUI->mLabelInformation->setVisible(false);
+    mUI->mButtonHideInformation->setVisible(false);
+    connect(mUI->mButtonHideInformation, &QPushButton::clicked,
+            this, &MainWindow::hideInformation);
+
+    if (mSettings->value(SETTINGS_CHECK_FOR_UPDATES, false).toBool()) {
+        // Is there a new version?
+        if (isCppcheckPremium()) {
+            const QUrl url("https://files.cppchecksolutions.com/version.txt");
+            mNetworkAccessManager->get(QNetworkRequest(url));
+        } else {
+            const QUrl url("https://cppcheck.sourceforge.io/version.txt");
+            mNetworkAccessManager->get(QNetworkRequest(url));
+        }
+    } else {
+        delete mUI->mLayoutInformation;
+    }
+
+    changeReportType();
 }
 
 MainWindow::~MainWindow()
 {
     delete mProjectFile;
     delete mScratchPad;
+    delete mUI;
 }
 
 void MainWindow::handleCLIParams(const QStringList &params)
@@ -257,9 +379,9 @@ void MainWindow::handleCLIParams(const QStringList &params)
         } else {
             loadResults(logFile);
         }
-    } else if ((index = params.indexOf(QRegExp(".*\\.cppcheck$", Qt::CaseInsensitive), 0)) >= 0 && index < params.length() && QFile(params[index]).exists()) {
+    } else if ((index = params.indexOf(QRegularExpression(".*\\.cppcheck$", QRegularExpression::CaseInsensitiveOption))) >= 0 && index < params.length() && QFile(params[index]).exists()) {
         loadProjectFile(params[index]);
-    } else if ((index = params.indexOf(QRegExp(".*\\.xml$", Qt::CaseInsensitive), 0)) >= 0 && index < params.length() && QFile(params[index]).exists()) {
+    } else if ((index = params.indexOf(QRegularExpression(".*\\.xml$", QRegularExpression::CaseInsensitiveOption))) >= 0 && index < params.length() && QFile(params[index]).exists()) {
         loadResults(params[index],QDir::currentPath());
     } else
         doAnalyzeFiles(params);
@@ -275,50 +397,66 @@ void MainWindow::loadSettings()
                mSettings->value(SETTINGS_WINDOW_HEIGHT, 600).toInt());
     }
 
-    ShowTypes *types = mUI.mResults->getShowTypes();
-    mUI.mActionShowStyle->setChecked(types->isShown(ShowTypes::ShowStyle));
-    mUI.mActionShowErrors->setChecked(types->isShown(ShowTypes::ShowErrors));
-    mUI.mActionShowWarnings->setChecked(types->isShown(ShowTypes::ShowWarnings));
-    mUI.mActionShowPortability->setChecked(types->isShown(ShowTypes::ShowPortability));
-    mUI.mActionShowPerformance->setChecked(types->isShown(ShowTypes::ShowPerformance));
-    mUI.mActionShowInformation->setChecked(types->isShown(ShowTypes::ShowInformation));
-    mUI.mActionShowCppcheck->setChecked(true);
-    mUI.mActionShowClang->setChecked(true);
+    const ReportType reportType = static_cast<ReportType>(mSettings->value(SETTINGS_REPORT_TYPE, static_cast<int>(ReportType::normal)).toInt());
+    mUI->mActionReportNormal->setChecked(reportType <= ReportType::normal);
+    mUI->mActionReportAutosar->setChecked(reportType == ReportType::autosar);
+    mUI->mActionReportCertC->setChecked(reportType == ReportType::certC);
+    mUI->mActionReportCertCpp->setChecked(reportType == ReportType::certCpp);
+    mUI->mActionReportMisraC->setChecked(reportType == ReportType::misraC2012 ||
+                                         reportType == ReportType::misraC2023 ||
+                                         reportType == ReportType::misraC2025);
+    mUI->mActionReportMisraCpp2008->setChecked(reportType == ReportType::misraCpp2008);
+    mUI->mActionReportMisraCpp2023->setChecked(reportType == ReportType::misraCpp2023);
+
+    const ShowTypes &types = mUI->mResults->getShowTypes();
+    mUI->mActionShowStyle->setChecked(types.isShown(ShowTypes::ShowStyle));
+    mUI->mActionShowErrors->setChecked(types.isShown(ShowTypes::ShowErrors));
+    mUI->mActionShowWarnings->setChecked(types.isShown(ShowTypes::ShowWarnings));
+    mUI->mActionShowPortability->setChecked(types.isShown(ShowTypes::ShowPortability));
+    mUI->mActionShowPerformance->setChecked(types.isShown(ShowTypes::ShowPerformance));
+    mUI->mActionShowInformation->setChecked(types.isShown(ShowTypes::ShowInformation));
+    mUI->mActionShowCppcheck->setChecked(true);
+    mUI->mActionShowClang->setChecked(true);
 
     Standards standards;
     standards.setC(mSettings->value(SETTINGS_STD_C, QString()).toString().toStdString());
-    mUI.mActionC89->setChecked(standards.c == Standards::C89);
-    mUI.mActionC99->setChecked(standards.c == Standards::C99);
-    mUI.mActionC11->setChecked(standards.c == Standards::C11);
+    mUI->mActionC89->setChecked(standards.c == Standards::C89);
+    mUI->mActionC99->setChecked(standards.c == Standards::C99);
+    mUI->mActionC11->setChecked(standards.c == Standards::C11);
+    //mUI->mActionC17->setChecked(standards.c == Standards::C17);
+    //mUI->mActionC23->setChecked(standards.c == Standards::C23);
+    //mUI->mActionC2Y->setChecked(standards.c == Standards::C2Y);
     standards.setCPP(mSettings->value(SETTINGS_STD_CPP, QString()).toString().toStdString());
-    mUI.mActionCpp03->setChecked(standards.cpp == Standards::CPP03);
-    mUI.mActionCpp11->setChecked(standards.cpp == Standards::CPP11);
-    mUI.mActionCpp14->setChecked(standards.cpp == Standards::CPP14);
-    mUI.mActionCpp17->setChecked(standards.cpp == Standards::CPP17);
-    mUI.mActionCpp20->setChecked(standards.cpp == Standards::CPP20);
+    mUI->mActionCpp03->setChecked(standards.cpp == Standards::CPP03);
+    mUI->mActionCpp11->setChecked(standards.cpp == Standards::CPP11);
+    mUI->mActionCpp14->setChecked(standards.cpp == Standards::CPP14);
+    mUI->mActionCpp17->setChecked(standards.cpp == Standards::CPP17);
+    mUI->mActionCpp20->setChecked(standards.cpp == Standards::CPP20);
+    //mUI->mActionCpp23->setChecked(standards.cpp == Standards::CPP23);
+    //mUI->mActionCpp26->setChecked(standards.cpp == Standards::CPP26);
 
     // Main window settings
     const bool showMainToolbar = mSettings->value(SETTINGS_TOOLBARS_MAIN_SHOW, true).toBool();
-    mUI.mActionToolBarMain->setChecked(showMainToolbar);
-    mUI.mToolBarMain->setVisible(showMainToolbar);
+    mUI->mActionToolBarMain->setChecked(showMainToolbar);
+    mUI->mToolBarMain->setVisible(showMainToolbar);
 
     const bool showViewToolbar = mSettings->value(SETTINGS_TOOLBARS_VIEW_SHOW, true).toBool();
-    mUI.mActionToolBarView->setChecked(showViewToolbar);
-    mUI.mToolBarView->setVisible(showViewToolbar);
+    mUI->mActionToolBarView->setChecked(showViewToolbar);
+    mUI->mToolBarView->setVisible(showViewToolbar);
 
     const bool showFilterToolbar = mSettings->value(SETTINGS_TOOLBARS_FILTER_SHOW, true).toBool();
-    mUI.mActionToolBarFilter->setChecked(showFilterToolbar);
-    mUI.mToolBarFilter->setVisible(showFilterToolbar);
-
-    Settings::Language enforcedLanguage = (Settings::Language)mSettings->value(SETTINGS_ENFORCED_LANGUAGE, 0).toInt();
-    if (enforcedLanguage == Settings::CPP)
-        mUI.mActionEnforceCpp->setChecked(true);
-    else if (enforcedLanguage == Settings::C)
-        mUI.mActionEnforceC->setChecked(true);
+    mUI->mActionToolBarFilter->setChecked(showFilterToolbar);
+    mUI->mToolBarFilter->setVisible(showFilterToolbar);
+
+    const Standards::Language enforcedLanguage = static_cast<Standards::Language>(mSettings->value(SETTINGS_ENFORCED_LANGUAGE, 0).toInt());
+    if (enforcedLanguage == Standards::Language::CPP)
+        mUI->mActionEnforceCpp->setChecked(true);
+    else if (enforcedLanguage == Standards::Language::C)
+        mUI->mActionEnforceC->setChecked(true);
     else
-        mUI.mActionAutoDetectLanguage->setChecked(true);
+        mUI->mActionAutoDetectLanguage->setChecked(true);
 
-    bool succeeded = mApplications->loadSettings();
+    const bool succeeded = mApplications->loadSettings();
     if (!succeeded) {
         const QString msg = tr("There was a problem with loading the editor application settings.\n\n"
                                "This is probably because the settings were changed between the Cppcheck versions. "
@@ -338,6 +476,7 @@ void MainWindow::loadSettings()
         if (inf.exists() && inf.isReadable()) {
             setPath(SETTINGS_LAST_PROJECT_PATH, projectFile);
             mProjectFile = new ProjectFile(this);
+            mProjectFile->setActiveProject();
             mProjectFile->read(projectFile);
             loadLastResults();
             QDir::setCurrent(inf.absolutePath());
@@ -345,6 +484,15 @@ void MainWindow::loadSettings()
     }
 }
 
+static ReportType getMisraCReportType(const QStringList &standards)
+{
+    if (standards.contains(CODING_STANDARD_MISRA_C_2023))
+        return ReportType::misraC2023;
+    if (standards.contains(CODING_STANDARD_MISRA_C_2025))
+        return ReportType::misraC2025;
+    return ReportType::misraC2012;
+}
+
 void MainWindow::saveSettings() const
 {
     // Window/dialog sizes
@@ -352,43 +500,62 @@ void MainWindow::saveSettings() const
     mSettings->setValue(SETTINGS_WINDOW_HEIGHT, size().height());
     mSettings->setValue(SETTINGS_WINDOW_MAXIMIZED, isMaximized());
 
+    const ReportType reportType = mUI->mActionReportAutosar->isChecked() ? ReportType::autosar :
+                                  mUI->mActionReportCertC->isChecked() ? ReportType::certC :
+                                  mUI->mActionReportCertCpp->isChecked() ? ReportType::certCpp :
+                                  mUI->mActionReportMisraC->isChecked() ? (mProjectFile ? getMisraCReportType(mProjectFile->getCodingStandards()) : ReportType::misraC2012) :
+                                  mUI->mActionReportMisraCpp2008->isChecked() ? ReportType::misraCpp2008 :
+                                  mUI->mActionReportMisraCpp2023->isChecked() ? ReportType::misraCpp2023 :
+                                  ReportType::normal;
+    mSettings->setValue(SETTINGS_REPORT_TYPE, static_cast<int>(reportType));
+
     // Show * states
-    mSettings->setValue(SETTINGS_SHOW_STYLE, mUI.mActionShowStyle->isChecked());
-    mSettings->setValue(SETTINGS_SHOW_ERRORS, mUI.mActionShowErrors->isChecked());
-    mSettings->setValue(SETTINGS_SHOW_WARNINGS, mUI.mActionShowWarnings->isChecked());
-    mSettings->setValue(SETTINGS_SHOW_PORTABILITY, mUI.mActionShowPortability->isChecked());
-    mSettings->setValue(SETTINGS_SHOW_PERFORMANCE, mUI.mActionShowPerformance->isChecked());
-    mSettings->setValue(SETTINGS_SHOW_INFORMATION, mUI.mActionShowInformation->isChecked());
-
-    if (mUI.mActionC89->isChecked())
+    mSettings->setValue(SETTINGS_SHOW_STYLE, mUI->mActionShowStyle->isChecked());
+    mSettings->setValue(SETTINGS_SHOW_ERRORS, mUI->mActionShowErrors->isChecked());
+    mSettings->setValue(SETTINGS_SHOW_WARNINGS, mUI->mActionShowWarnings->isChecked());
+    mSettings->setValue(SETTINGS_SHOW_PORTABILITY, mUI->mActionShowPortability->isChecked());
+    mSettings->setValue(SETTINGS_SHOW_PERFORMANCE, mUI->mActionShowPerformance->isChecked());
+    mSettings->setValue(SETTINGS_SHOW_INFORMATION, mUI->mActionShowInformation->isChecked());
+
+    if (mUI->mActionC89->isChecked())
         mSettings->setValue(SETTINGS_STD_C, "C89");
-    if (mUI.mActionC99->isChecked())
+    if (mUI->mActionC99->isChecked())
         mSettings->setValue(SETTINGS_STD_C, "C99");
-    if (mUI.mActionC11->isChecked())
+    if (mUI->mActionC11->isChecked())
         mSettings->setValue(SETTINGS_STD_C, "C11");
-
-    if (mUI.mActionCpp03->isChecked())
+    //if (mUI->mActionC17->isChecked())
+    //    mSettings->setValue(SETTINGS_STD_C, "C17");
+    //if (mUI->mActionC23->isChecked())
+    //    mSettings->setValue(SETTINGS_STD_C, "C23");
+    //if (mUI->mActionC2Y->isChecked())
+    //    mSettings->setValue(SETTINGS_STD_C, "C2Y");
+
+    if (mUI->mActionCpp03->isChecked())
         mSettings->setValue(SETTINGS_STD_CPP, "C++03");
-    if (mUI.mActionCpp11->isChecked())
+    if (mUI->mActionCpp11->isChecked())
         mSettings->setValue(SETTINGS_STD_CPP, "C++11");
-    if (mUI.mActionCpp14->isChecked())
+    if (mUI->mActionCpp14->isChecked())
         mSettings->setValue(SETTINGS_STD_CPP, "C++14");
-    if (mUI.mActionCpp17->isChecked())
+    if (mUI->mActionCpp17->isChecked())
         mSettings->setValue(SETTINGS_STD_CPP, "C++17");
-    if (mUI.mActionCpp20->isChecked())
+    if (mUI->mActionCpp20->isChecked())
         mSettings->setValue(SETTINGS_STD_CPP, "C++20");
+    //if (mUI.mActionCpp23->isChecked())
+    //    mSettings->setValue(SETTINGS_STD_CPP, "C++23");
+    //if (mUI.mActionCpp26->isChecked())
+    //    mSettings->setValue(SETTINGS_STD_CPP, "C++26");
 
     // Main window settings
-    mSettings->setValue(SETTINGS_TOOLBARS_MAIN_SHOW, mUI.mToolBarMain->isVisible());
-    mSettings->setValue(SETTINGS_TOOLBARS_VIEW_SHOW, mUI.mToolBarView->isVisible());
-    mSettings->setValue(SETTINGS_TOOLBARS_FILTER_SHOW, mUI.mToolBarFilter->isVisible());
-
-    if (mUI.mActionEnforceCpp->isChecked())
-        mSettings->setValue(SETTINGS_ENFORCED_LANGUAGE, Settings::CPP);
-    else if (mUI.mActionEnforceC->isChecked())
-        mSettings->setValue(SETTINGS_ENFORCED_LANGUAGE, Settings::C);
+    mSettings->setValue(SETTINGS_TOOLBARS_MAIN_SHOW, mUI->mToolBarMain->isVisible());
+    mSettings->setValue(SETTINGS_TOOLBARS_VIEW_SHOW, mUI->mToolBarView->isVisible());
+    mSettings->setValue(SETTINGS_TOOLBARS_FILTER_SHOW, mUI->mToolBarFilter->isVisible());
+
+    if (mUI->mActionEnforceCpp->isChecked())
+        mSettings->setValue(SETTINGS_ENFORCED_LANGUAGE, Standards::Language::CPP);
+    else if (mUI->mActionEnforceC->isChecked())
+        mSettings->setValue(SETTINGS_ENFORCED_LANGUAGE, Standards::Language::C);
     else
-        mSettings->setValue(SETTINGS_ENFORCED_LANGUAGE, Settings::None);
+        mSettings->setValue(SETTINGS_ENFORCED_LANGUAGE, Standards::Language::None);
 
     mApplications->saveSettings();
 
@@ -396,33 +563,44 @@ void MainWindow::saveSettings() const
 
     mSettings->setValue(SETTINGS_OPEN_PROJECT, mProjectFile ? mProjectFile->getFilename() : QString());
 
-    mUI.mResults->saveSettings(mSettings);
+    mUI->mResults->saveSettings(mSettings);
 }
 
 void MainWindow::doAnalyzeProject(ImportProject p, const bool checkLibrary, const bool checkConfiguration)
 {
+    Settings checkSettings;
+    auto supprs = std::make_shared<Suppressions>();
+    if (!getCppcheckSettings(checkSettings, *supprs))
+        return;
+
     clearResults();
 
     mIsLogfileLoaded = false;
     if (mProjectFile) {
         std::vector<std::string> v;
-        foreach (const QString &i, mProjectFile->getExcludedPaths()) {
-            v.push_back(i.toStdString());
-        }
+        const QStringList excluded = mProjectFile->getExcludedPaths();
+        std::transform(excluded.cbegin(), excluded.cend(), std::back_inserter(v), [](const QString& e) {
+            return e.toStdString();
+        });
         p.ignorePaths(v);
 
         if (!mProjectFile->getAnalyzeAllVsConfigs()) {
-            Settings::PlatformType platform = (Settings::PlatformType) mSettings->value(SETTINGS_CHECKED_PLATFORM, 0).toInt();
-            p.selectOneVsConfig(platform);
+            const Platform::Type platform = static_cast<Platform::Type>(mSettings->value(SETTINGS_CHECKED_PLATFORM, 0).toInt());
+            std::vector<std::string> configurations;
+            const QStringList configs = mProjectFile->getVsConfigurations();
+            std::transform(configs.cbegin(), configs.cend(), std::back_inserter(configurations), [](const QString& e) {
+                return e.toStdString();
+            });
+            p.selectVsConfigurations(platform, configurations);
         }
     } else {
         enableProjectActions(false);
     }
 
-    mUI.mResults->clear(true);
+    mUI->mResults->setResultsSource(ResultsTree::ResultsSource::Analysis);
     mThread->clearFiles();
 
-    mUI.mResults->checkingStarted(p.fileSettings.size());
+    mUI->mResults->checkingStarted(p.fileSettings.size());
 
     QDir inf(mCurrentDirectory);
     const QString checkPath = inf.canonicalPath();
@@ -430,8 +608,7 @@ void MainWindow::doAnalyzeProject(ImportProject p, const bool checkLibrary, cons
 
     checkLockDownUI(); // lock UI while checking
 
-    mUI.mResults->setCheckDirectory(checkPath);
-    Settings checkSettings = getCppcheckSettings();
+    mUI->mResults->setCheckDirectory(checkPath);
     checkSettings.force = false;
     checkSettings.checkLibrary = checkLibrary;
     checkSettings.checkConfiguration = checkConfiguration;
@@ -440,26 +617,37 @@ void MainWindow::doAnalyzeProject(ImportProject p, const bool checkLibrary, cons
         qDebug() << "Checking project file" << mProjectFile->getFilename();
 
     if (!checkSettings.buildDir.empty()) {
+        checkSettings.loadSummaries();
         std::list<std::string> sourcefiles;
         AnalyzerInformation::writeFilesTxt(checkSettings.buildDir, sourcefiles, p.fileSettings);
     }
 
     //mThread->SetanalyzeProject(true);
     if (mProjectFile) {
-        mThread->setAddonsAndTools(mProjectFile->getAddonsAndTools(), mSettings->value(SETTINGS_MISRA_FILE).toString());
+        mThread->setAddonsAndTools(mProjectFile->getAddonsAndTools());
         QString clangHeaders = mSettings->value(SETTINGS_VS_INCLUDE_PATHS).toString();
         mThread->setClangIncludePaths(clangHeaders.split(";"));
         mThread->setSuppressions(mProjectFile->getSuppressions());
     }
+
+    const Standards::Language enforcedLang = static_cast<Standards::Language>(mSettings->value(SETTINGS_ENFORCED_LANGUAGE, 0).toInt());
+    frontend::applyLang(p.fileSettings, checkSettings, enforcedLang);
+
     mThread->setProject(p);
-    mThread->check(checkSettings);
+    mThread->check(checkSettings, supprs);
+    mUI->mResults->setCheckSettings(checkSettings);
 }
 
 void MainWindow::doAnalyzeFiles(const QStringList &files, const bool checkLibrary, const bool checkConfiguration)
 {
-    if (files.isEmpty()) {
+    if (files.isEmpty())
         return;
-    }
+
+    Settings checkSettings;
+    auto supprs = std::make_shared<Suppressions>();
+    if (!getCppcheckSettings(checkSettings, *supprs))
+        return;
+
     clearResults();
 
     mIsLogfileLoaded = false;
@@ -472,7 +660,8 @@ void MainWindow::doAnalyzeFiles(const QStringList &files, const bool checkLibrar
     }
     QStringList fileNames = pathList.getFileList();
 
-    mUI.mResults->clear(true);
+    mUI->mResults->clear(true);
+    mUI->mResults->setResultsSource(ResultsTree::ResultsSource::Analysis);
     mThread->clearFiles();
 
     if (fileNames.isEmpty()) {
@@ -485,20 +674,21 @@ void MainWindow::doAnalyzeFiles(const QStringList &files, const bool checkLibrar
         return;
     }
 
-    mUI.mResults->checkingStarted(fileNames.count());
+    std::list<FileWithDetails> fdetails = enrichFilesForAnalysis(fileNames, checkSettings);
 
-    mThread->setFiles(fileNames);
+    // TODO: lock UI here?
+    mUI->mResults->checkingStarted(fdetails.size());
+    mThread->setFiles(std::move(fdetails));
     if (mProjectFile && !checkConfiguration)
-        mThread->setAddonsAndTools(mProjectFile->getAddonsAndTools(), mSettings->value(SETTINGS_MISRA_FILE).toString());
-    mThread->setSuppressions(mProjectFile ? mProjectFile->getSuppressions() : QList<Suppressions::Suppression>());
+        mThread->setAddonsAndTools(mProjectFile->getAddonsAndTools());
+    mThread->setSuppressions(mProjectFile ? mProjectFile->getCheckingSuppressions() : QList<SuppressionList::Suppression>());
     QDir inf(mCurrentDirectory);
     const QString checkPath = inf.canonicalPath();
     setPath(SETTINGS_LAST_CHECK_PATH, checkPath);
 
     checkLockDownUI(); // lock UI while checking
 
-    mUI.mResults->setCheckDirectory(checkPath);
-    Settings checkSettings = getCppcheckSettings();
+    mUI->mResults->setCheckDirectory(checkPath);
     checkSettings.checkLibrary = checkLibrary;
     checkSettings.checkConfiguration = checkConfiguration;
 
@@ -506,44 +696,55 @@ void MainWindow::doAnalyzeFiles(const QStringList &files, const bool checkLibrar
         qDebug() << "Checking project file" << mProjectFile->getFilename();
 
     if (!checkSettings.buildDir.empty()) {
+        checkSettings.loadSummaries();
         std::list<std::string> sourcefiles;
-        foreach (QString s, fileNames)
-            sourcefiles.push_back(s.toStdString());
-        AnalyzerInformation::writeFilesTxt(checkSettings.buildDir, sourcefiles, checkSettings.project.fileSettings);
+        std::transform(fileNames.cbegin(), fileNames.cend(), std::back_inserter(sourcefiles), [](const QString& s) {
+            return s.toStdString();
+        });
+        AnalyzerInformation::writeFilesTxt(checkSettings.buildDir, sourcefiles, {});
     }
 
     mThread->setCheckFiles(true);
-    mThread->check(checkSettings);
+    mThread->check(checkSettings, supprs);
+    mUI->mResults->setCheckSettings(checkSettings);
 }
 
 void MainWindow::analyzeCode(const QString& code, const QString& filename)
 {
+    Settings checkSettings;
+    Suppressions supprs;
+    if (!getCppcheckSettings(checkSettings, supprs))
+        return;
+
+    // TODO: split ErrorLogger from ThreadResult
     // Initialize dummy ThreadResult as ErrorLogger
     ThreadResult result;
-    result.setFiles(QStringList(filename));
-    connect(&result, SIGNAL(progress(int, const QString&)),
-            mUI.mResults, SLOT(progress(int, const QString&)));
-    connect(&result, SIGNAL(error(const ErrorItem &)),
-            mUI.mResults, SLOT(error(const ErrorItem &)));
-    connect(&result, SIGNAL(log(const QString &)),
-            mUI.mResults, SLOT(log(const QString &)));
-    connect(&result, SIGNAL(debugError(const ErrorItem &)),
-            mUI.mResults, SLOT(debugError(const ErrorItem &)));
+    connect(&result, SIGNAL(progress(int,QString)),
+            mUI->mResults, SLOT(progress(int,QString)));
+    connect(&result, SIGNAL(error(ErrorItem)),
+            mUI->mResults, SLOT(error(ErrorItem)));
+    connect(&result, SIGNAL(log(QString)),
+            mUI->mResults, SLOT(log(QString)));
+    connect(&result, SIGNAL(debugError(ErrorItem)),
+            mUI->mResults, SLOT(debugError(ErrorItem)));
 
     // Create CppCheck instance
-    CppCheck cppcheck(result, true);
-    cppcheck.settings() = getCppcheckSettings();
+    CppCheck cppcheck(checkSettings, supprs, result, nullptr, true, nullptr);
 
     // Check
     checkLockDownUI();
     clearResults();
-    mUI.mResults->checkingStarted(1);
-    cppcheck.check(filename.toStdString(), code.toStdString());
+    mUI->mResults->checkingStarted(1);
+    {
+        const std::string code_s = code.toStdString();
+        // TODO: apply enforcedLanguage?
+        cppcheck.checkBuffer(FileWithDetails(filename.toStdString(), Path::identify(filename.toStdString(), false), 0), code_s.data(), code_s.size());
+    }
     analysisDone();
 
     // Expand results
-    if (mUI.mResults->hasVisibleResults())
-        mUI.mResults->expandAllResults();
+    if (mUI->mResults->hasVisibleResults())
+        mUI->mResults->expandAllResults();
 }
 
 QStringList MainWindow::selectFilesToAnalyze(QFileDialog::FileMode mode)
@@ -571,10 +772,10 @@ QStringList MainWindow::selectFilesToAnalyze(QFileDialog::FileMode mode)
         filters[tr("Borland C++ Builder 6")] = "*.bpr";
         QString lastFilter = mSettings->value(SETTINGS_LAST_ANALYZE_FILES_FILTER).toString();
         selected = QFileDialog::getOpenFileNames(this,
-                   tr("Select files to analyze"),
-                   getPath(SETTINGS_LAST_CHECK_PATH),
-                   toFilterString(filters),
-                   &lastFilter);
+                                                 tr("Select files to analyze"),
+                                                 getPath(SETTINGS_LAST_CHECK_PATH),
+                                                 toFilterString(filters),
+                                                 &lastFilter);
         mSettings->setValue(SETTINGS_LAST_ANALYZE_FILES_FILTER, lastFilter);
 
         if (selected.isEmpty())
@@ -584,10 +785,10 @@ QStringList MainWindow::selectFilesToAnalyze(QFileDialog::FileMode mode)
             mCurrentDirectory = inf.absolutePath();
         }
         formatAndSetTitle();
-    } else if (mode == QFileDialog::DirectoryOnly) {
+    } else if (mode == QFileDialog::Directory) {
         QString dir = QFileDialog::getExistingDirectory(this,
-                      tr("Select directory to analyze"),
-                      getPath(SETTINGS_LAST_CHECK_PATH));
+                                                        tr("Select directory to analyze"),
+                                                        getPath(SETTINGS_LAST_CHECK_PATH));
         if (!dir.isEmpty()) {
             qDebug() << "Setting current directory to: " << dir;
             mCurrentDirectory = dir;
@@ -596,8 +797,8 @@ QStringList MainWindow::selectFilesToAnalyze(QFileDialog::FileMode mode)
             formatAndSetTitle(dir);
         }
     }
-
-    setPath(SETTINGS_LAST_CHECK_PATH, mCurrentDirectory);
+    if (!mCurrentDirectory.isEmpty())
+        setPath(SETTINGS_LAST_CHECK_PATH, mCurrentDirectory);
 
     return selected;
 }
@@ -608,7 +809,7 @@ void MainWindow::analyzeFiles()
 
     QStringList selected = selectFilesToAnalyze(QFileDialog::ExistingFiles);
 
-    const QString file0 = (selected.size() ? selected[0].toLower() : QString());
+    const QString file0 = (!selected.empty() ? selected[0].toLower() : QString());
     if (file0.endsWith(".sln")
         || file0.endsWith(".vcxproj")
         || file0.endsWith(compile_commands_json)
@@ -618,7 +819,7 @@ void MainWindow::analyzeFiles()
 
         if (file0.endsWith(".sln")) {
             QStringList configs;
-            for (std::list<ImportProject::FileSettings>::const_iterator it = p.fileSettings.begin(); it != p.fileSettings.end(); ++it) {
+            for (auto it = p.fileSettings.cbegin(); it != p.fileSettings.cend(); ++it) {
                 const QString cfg(QString::fromStdString(it->cfg));
                 if (!configs.contains(cfg))
                     configs.push_back(cfg);
@@ -632,7 +833,7 @@ void MainWindow::analyzeFiles()
             p.ignoreOtherConfigs(cfg.toStdString());
         }
 
-        doAnalyzeProject(p);
+        doAnalyzeProject(p); // TODO: avoid copy
         return;
     }
 
@@ -641,7 +842,7 @@ void MainWindow::analyzeFiles()
 
 void MainWindow::analyzeDirectory()
 {
-    QStringList dir = selectFilesToAnalyze(QFileDialog::DirectoryOnly);
+    QStringList dir = selectFilesToAnalyze(QFileDialog::Directory);
     if (dir.isEmpty())
         return;
 
@@ -663,7 +864,7 @@ void MainWindow::analyzeDirectory()
             msgBox.addButton(QMessageBox::Yes);
             msgBox.addButton(QMessageBox::No);
             msgBox.setDefaultButton(QMessageBox::Yes);
-            int dlgResult = msgBox.exec();
+            const int dlgResult = msgBox.exec();
             if (dlgResult == QMessageBox::Yes) {
                 QString path = checkDir.canonicalPath();
                 if (!path.endsWith("/"))
@@ -686,7 +887,7 @@ void MainWindow::analyzeDirectory()
             msgBox.addButton(QMessageBox::Yes);
             msgBox.addButton(QMessageBox::No);
             msgBox.setDefaultButton(QMessageBox::Yes);
-            int dlgResult = msgBox.exec();
+            const int dlgResult = msgBox.exec();
             if (dlgResult == QMessageBox::Yes) {
                 doAnalyzeFiles(dir);
             }
@@ -698,8 +899,7 @@ void MainWindow::analyzeDirectory()
 
 void MainWindow::addIncludeDirs(const QStringList &includeDirs, Settings &result)
 {
-    QString dir;
-    foreach (dir, includeDirs) {
+    for (const QString& dir : includeDirs) {
         QString incdir;
         if (!QDir::isAbsolutePath(dir))
             incdir = mCurrentDirectory + "/";
@@ -713,24 +913,30 @@ void MainWindow::addIncludeDirs(const QStringList &includeDirs, Settings &result
     }
 }
 
-Library::Error MainWindow::loadLibrary(Library *library, const QString &filename)
+Library::Error MainWindow::loadLibrary(Library &library, const QString &filename)
 {
     Library::Error ret;
 
     // Try to load the library from the project folder..
     if (mProjectFile) {
         QString path = QFileInfo(mProjectFile->getFilename()).canonicalPath();
-        ret = library->load(nullptr, (path+"/"+filename).toLatin1());
+        QString libpath = path+"/"+filename;
+        qDebug().noquote() << "looking for library '" + libpath + "'";
+        ret = library.load(nullptr, libpath.toLatin1());
         if (ret.errorcode != Library::ErrorCode::FILE_NOT_FOUND)
             return ret;
     }
 
     // Try to load the library from the application folder..
     const QString appPath = QFileInfo(QCoreApplication::applicationFilePath()).canonicalPath();
-    ret = library->load(nullptr, (appPath+"/"+filename).toLatin1());
+    QString libpath = appPath+"/"+filename;
+    qDebug().noquote() << "looking for library '" + libpath + "'";
+    ret = library.load(nullptr, libpath.toLatin1());
     if (ret.errorcode != Library::ErrorCode::FILE_NOT_FOUND)
         return ret;
-    ret = library->load(nullptr, (appPath+"/cfg/"+filename).toLatin1());
+    libpath = appPath+"/cfg/"+filename;
+    qDebug().noquote() << "looking for library '" + libpath + "'";
+    ret = library.load(nullptr, libpath.toLatin1());
     if (ret.errorcode != Library::ErrorCode::FILE_NOT_FOUND)
         return ret;
 
@@ -738,34 +944,44 @@ Library::Error MainWindow::loadLibrary(Library *library, const QString &filename
     // Try to load the library from FILESDIR/cfg..
     const QString filesdir = FILESDIR;
     if (!filesdir.isEmpty()) {
-        ret = library->load(nullptr, (filesdir+"/cfg/"+filename).toLatin1());
+        libpath = filesdir+"/cfg/"+filename;
+        qDebug().noquote() << "looking for library '" + libpath + "'";
+        ret = library.load(nullptr, libpath.toLatin1());
         if (ret.errorcode != Library::ErrorCode::FILE_NOT_FOUND)
             return ret;
-        ret = library->load(nullptr, (filesdir+filename).toLatin1());
+        libpath = filesdir+"/"+filename;
+        qDebug().noquote() << "looking for library '" + libpath + "'";
+        ret = library.load(nullptr, libpath.toLatin1());
         if (ret.errorcode != Library::ErrorCode::FILE_NOT_FOUND)
             return ret;
     }
 #endif
 
     // Try to load the library from the cfg subfolder..
-    const QString datadir = mSettings->value("DATADIR", QString()).toString();
+    const QString datadir = getDataDir();
     if (!datadir.isEmpty()) {
-        ret = library->load(nullptr, (datadir+"/"+filename).toLatin1());
+        libpath = datadir+"/"+filename;
+        qDebug().noquote() << "looking for library '" + libpath + "'";
+        ret = library.load(nullptr, libpath.toLatin1());
         if (ret.errorcode != Library::ErrorCode::FILE_NOT_FOUND)
             return ret;
-        ret = library->load(nullptr, (datadir+"/cfg/"+filename).toLatin1());
+        libpath = datadir+"/cfg/"+filename;
+        qDebug().noquote() << "looking for library '" + libpath + "'";
+        ret = library.load(nullptr, libpath.toLatin1());
         if (ret.errorcode != Library::ErrorCode::FILE_NOT_FOUND)
             return ret;
     }
 
+    qDebug().noquote() << "library not found: '" + filename + "'";
+
     return ret;
 }
 
-bool MainWindow::tryLoadLibrary(Library *library, QString filename)
+bool MainWindow::tryLoadLibrary(Library &library, const QString& filename)
 {
     const Library::Error error = loadLibrary(library, filename);
     if (error.errorcode != Library::ErrorCode::OK) {
-        if (error.errorcode == Library::UNKNOWN_ELEMENT) {
+        if (error.errorcode == Library::ErrorCode::UNKNOWN_ELEMENT) {
             QMessageBox::information(this, tr("Information"), tr("The library '%1' contains unknown elements:\n%2").arg(filename).arg(error.reason.c_str()));
             return true;
         }
@@ -795,12 +1011,12 @@ bool MainWindow::tryLoadLibrary(Library *library, QString filename)
         case Library::ErrorCode::PLATFORM_TYPE_REDEFINED:
             errmsg = tr("Platform type redefined");
             break;
+        case Library::ErrorCode::DUPLICATE_DEFINE:
+            errmsg = tr("Duplicate define");
+            break;
         case Library::ErrorCode::UNKNOWN_ELEMENT:
             errmsg = tr("Unknown element");
             break;
-        default:
-            errmsg = tr("Unknown issue");
-            break;
         }
         if (!error.reason.empty())
             errmsg += " '" + QString::fromStdString(error.reason) + "'";
@@ -810,87 +1026,194 @@ bool MainWindow::tryLoadLibrary(Library *library, QString filename)
     return true;
 }
 
-Settings MainWindow::getCppcheckSettings()
+QString MainWindow::loadAddon(Settings &settings, const QString &filesDir, const QString &pythonCmd, const QString& addon)
+{
+    const QString addonFilePath = fromNativePath(ProjectFile::getAddonFilePath(filesDir, addon));
+
+    if (addonFilePath.isEmpty())
+        return tr("File not found: '%1'").arg(addon);
+
+    picojson::object obj;
+    obj["script"] = picojson::value(addonFilePath.toStdString());
+    if (!pythonCmd.isEmpty())
+        obj["python"] = picojson::value(pythonCmd.toStdString());
+
+    if (!isCppcheckPremium() && addon == "misra") {
+        const QString misraFile = fromNativePath(mSettings->value(SETTINGS_MISRA_FILE).toString());
+        if (!misraFile.isEmpty()) {
+            QString arg;
+            picojson::array arr;
+            arg = "--rule-texts=" + misraFile;
+            arr.emplace_back(arg.toStdString());
+            obj["args"] = picojson::value(arr);
+        }
+    }
+
+    const std::string& json_str = picojson::value(obj).serialize();
+
+    AddonInfo addonInfo;
+    const std::string errmsg = addonInfo.getAddonInfo(json_str, settings.exename);
+    if (!errmsg.empty())
+        return tr("Failed to load/setup addon %1: %2").arg(addon, QString::fromStdString(errmsg));
+    settings.addonInfos.emplace_back(std::move(addonInfo));
+
+    settings.addons.emplace(json_str);
+
+    return "";
+}
+
+bool MainWindow::getCppcheckSettings(Settings& settings, Suppressions& supprs)
 {
     saveSettings(); // Save settings
 
-    Settings result;
+    Settings::terminate(true);
+
+    settings.exename = QCoreApplication::applicationFilePath().toStdString();
+    settings.templateFormat = "{file}:{line}:{column}: {severity}:{inconclusive:inconclusive:} {message} [{id}]";
+    settings.reportProgress = 10;
+
+    // default to --check-level=normal for GUI for now
+    settings.setCheckLevel(Settings::CheckLevel::normal);
+
+    const bool std = tryLoadLibrary(settings.library, "std.cfg");
+    if (!std) {
+        QMessageBox::critical(this, tr("Error"), tr("Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=<directory> at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.\n\nAnalysis is aborted.").arg("std.cfg"));
+        return false;
+    }
+
+    const QString filesDir(getDataDir());
+    const QString pythonCmd = fromNativePath(mSettings->value(SETTINGS_PYTHON_PATH).toString());
+
+    {
+        const QString cfgErr = QString::fromStdString(Settings::loadCppcheckCfg(settings, supprs));
+        if (!cfgErr.isEmpty()) {
+            QMessageBox::critical(this, tr("Error"), tr("Failed to load %1 - %2\n\nAnalysis is aborted.").arg("cppcheck.cfg").arg(cfgErr));
+            return false;
+        }
 
-    const bool std = tryLoadLibrary(&result.library, "std.cfg");
-    bool posix = true;
-    if (result.posix())
-        posix = tryLoadLibrary(&result.library, "posix.cfg");
-    bool windows = true;
-    if (result.isWindowsPlatform())
-        windows = tryLoadLibrary(&result.library, "windows.cfg");
+        settings.premium = startsWith(settings.cppcheckCfgProductName, "Cppcheck Premium");
 
-    if (!std || !posix || !windows)
-        QMessageBox::critical(this, tr("Error"), tr("Failed to load %1. Your Cppcheck installation is broken. You can use --data-dir=<directory> at the command line to specify where this file is located. Please note that --data-dir is supposed to be used by installation scripts and therefore the GUI does not start when it is used, all that happens is that the setting is configured.").arg(!std ? "std.cfg" : !posix ? "posix.cfg" : "windows.cfg"));
+        const auto cfgAddons = settings.addons;
+        settings.addons.clear();
+        for (const std::string& addon : cfgAddons) {
+            // TODO: support addons which are a script and not a file
+            const QString addonError = loadAddon(settings, filesDir, pythonCmd, QString::fromStdString(addon));
+            if (!addonError.isEmpty()) {
+                QMessageBox::critical(this, tr("Error"), tr("%1\n\nAnalysis is aborted.").arg(addonError));
+                return false;
+            }
+        }
+    }
 
     // If project file loaded, read settings from it
     if (mProjectFile) {
         QStringList dirs = mProjectFile->getIncludeDirs();
-        addIncludeDirs(dirs, result);
+        addIncludeDirs(dirs, settings);
+
+        settings.inlineSuppressions = mProjectFile->getInlineSuppression();
 
         const QStringList defines = mProjectFile->getDefines();
-        foreach (QString define, defines) {
-            if (!result.userDefines.empty())
-                result.userDefines += ";";
-            result.userDefines += define.toStdString();
+        for (const QString& define : defines) {
+            if (!settings.userDefines.empty())
+                settings.userDefines += ";";
+            settings.userDefines += define.toStdString();
         }
 
+        settings.clang = mProjectFile->clangParser;
+
         const QStringList undefines = mProjectFile->getUndefines();
-        foreach (QString undefine, undefines)
-            result.userUndefs.insert(undefine.toStdString());
+        for (const QString& undefine : undefines)
+            settings.userUndefs.insert(undefine.toStdString());
 
         const QStringList libraries = mProjectFile->getLibraries();
-        foreach (QString library, libraries) {
+        for (const QString& library : libraries) {
+            settings.libraries.emplace_back(library.toStdString());
             const QString filename = library + ".cfg";
-            tryLoadLibrary(&result.library, filename);
+            tryLoadLibrary(settings.library, filename);
         }
 
-        foreach (const Suppressions::Suppression &suppression, mProjectFile->getSuppressions()) {
-            result.nomsg.addSuppression(suppression);
+        for (const SuppressionList::Suppression &suppression : mProjectFile->getCheckingSuppressions()) {
+            supprs.nomsg.addSuppression(suppression); // TODO: check result
         }
 
-        // Only check the given -D configuration
-        if (!defines.isEmpty())
-            result.maxConfigs = 1;
+        // If importing a project, only check the given configuration
+        if (mProjectFile->getImportProject().endsWith("json", Qt::CaseInsensitive))
+            settings.maxConfigsProject = 1;
 
-        const QString &buildDir = mProjectFile->getBuildDir();
+        const QString &buildDir = fromNativePath(mProjectFile->getBuildDir());
         if (!buildDir.isEmpty()) {
             if (QDir(buildDir).isAbsolute()) {
-                result.buildDir = buildDir.toStdString();
+                settings.buildDir = buildDir.toStdString();
             } else {
                 QString prjpath = QFileInfo(mProjectFile->getFilename()).absolutePath();
-                result.buildDir = (prjpath + '/' + buildDir).toStdString();
+                settings.buildDir = (prjpath + '/' + buildDir).toStdString();
             }
         }
 
         const QString platform = mProjectFile->getPlatform();
         if (platform.endsWith(".xml")) {
-            const QString applicationFilePath = QCoreApplication::applicationFilePath();
-            result.loadPlatformFile(applicationFilePath.toStdString().c_str(), platform.toStdString());
+            const std::vector<std::string> paths = {
+                Path::getCurrentPath(), // TODO: do we want to look in CWD?
+                QCoreApplication::applicationFilePath().toStdString(),
+            };
+            settings.platform.loadFromFile(paths, platform.toStdString());
         } else {
-            for (int i = cppcheck::Platform::Native; i <= cppcheck::Platform::Unix64; i++) {
-                const cppcheck::Platform::PlatformType p = (cppcheck::Platform::PlatformType)i;
-                if (platform == cppcheck::Platform::platformString(p)) {
-                    result.platform(p);
+            for (int i = Platform::Type::Native; i <= Platform::Type::Unix64; i++) {
+                const auto p = static_cast<Platform::Type>(i);
+                if (platform == Platform::toString(p)) {
+                    settings.platform.set(p);
                     break;
                 }
             }
         }
 
-        result.maxCtuDepth = mProjectFile->getMaxCtuDepth();
-        result.checkHeaders = mProjectFile->getCheckHeaders();
-        result.checkUnusedTemplates = mProjectFile->getCheckUnusedTemplates();
-        result.safeChecks.classes = mProjectFile->getSafeChecks().classes;
-        result.safeChecks.externalFunctions = mProjectFile->getSafeChecks().externalFunctions;
-        result.safeChecks.internalFunctions = mProjectFile->getSafeChecks().internalFunctions;
-        result.safeChecks.externalVariables = mProjectFile->getSafeChecks().externalVariables;
-        foreach (QString s, mProjectFile->getCheckUnknownFunctionReturn())
-            result.checkUnknownFunctionReturn.insert(s.toStdString());
+        settings.maxCtuDepth = mProjectFile->getMaxCtuDepth();
+        settings.maxTemplateRecursion = mProjectFile->getMaxTemplateRecursion();
+        switch (mProjectFile->getCheckLevel()) {
+        case ProjectFile::CheckLevel::reduced:
+            settings.setCheckLevel(Settings::CheckLevel::reduced);
+            break;
+        case ProjectFile::CheckLevel::normal:
+            settings.setCheckLevel(Settings::CheckLevel::normal);
+            break;
+        case ProjectFile::CheckLevel::exhaustive:
+            settings.setCheckLevel(Settings::CheckLevel::exhaustive);
+            break;
+        }
+        settings.checkHeaders = mProjectFile->getCheckHeaders();
+        settings.checkUnusedTemplates = mProjectFile->getCheckUnusedTemplates();
+        settings.safeChecks.classes = mProjectFile->safeChecks.classes;
+        settings.safeChecks.externalFunctions = mProjectFile->safeChecks.externalFunctions;
+        settings.safeChecks.internalFunctions = mProjectFile->safeChecks.internalFunctions;
+        settings.safeChecks.externalVariables = mProjectFile->safeChecks.externalVariables;
+        for (const QString& s : mProjectFile->getCheckUnknownFunctionReturn())
+            settings.checkUnknownFunctionReturn.insert(s.toStdString());
+
+        for (const QString& addon : mProjectFile->getAddons()) {
+            if (isCppcheckPremium() && addon == "misra")
+                continue;
+            const QString addonError = loadAddon(settings, filesDir, pythonCmd, addon);
+            if (!addonError.isEmpty()) {
+                QMessageBox::critical(this, tr("Error"), tr("%1\n\nAnalysis is aborted.").arg(addonError));
+                return false;
+            }
+        }
+
+        if (isCppcheckPremium()) {
+            QString premiumArgs;
+            if (mProjectFile->getBughunting())
+                premiumArgs += " --bughunting";
+            if (mProjectFile->getCertIntPrecision() > 0)
+                premiumArgs += " --cert-c-int-precision=" + QString::number(mProjectFile->getCertIntPrecision());
+            for (const QString& c: mProjectFile->getCodingStandards())
+                premiumArgs += " --" + c;
+            if (!premiumArgs.contains("--misra-c-") && mProjectFile->getAddons().contains("misra"))
+                premiumArgs += " --misra-c-2012";
+            settings.premiumArgs = premiumArgs.mid(1).toStdString();
+        }
     }
+    else
+        settings.inlineSuppressions = mSettings->value(SETTINGS_INLINE_SUPPRESSIONS, false).toBool();
 
     // Include directories (and files) are searched in listed order.
     // Global include directories must be added AFTER the per project include
@@ -898,38 +1221,34 @@ Settings MainWindow::getCppcheckSettings()
     const QString globalIncludes = mSettings->value(SETTINGS_GLOBAL_INCLUDE_PATHS).toString();
     if (!globalIncludes.isEmpty()) {
         QStringList includes = globalIncludes.split(";");
-        addIncludeDirs(includes, result);
+        addIncludeDirs(includes, settings);
     }
 
-    result.addEnabled("warning");
-    result.addEnabled("style");
-    result.addEnabled("performance");
-    result.addEnabled("portability");
-    result.addEnabled("information");
-    result.addEnabled("missingInclude");
-    if (!result.buildDir.empty())
-        result.addEnabled("unusedFunction");
-    result.debugwarnings = mSettings->value(SETTINGS_SHOW_DEBUG_WARNINGS, false).toBool();
-    result.quiet = false;
-    result.verbose = true;
-    result.force = mSettings->value(SETTINGS_CHECK_FORCE, 1).toBool();
-    result.xml = false;
-    result.jobs = mSettings->value(SETTINGS_CHECK_THREADS, 1).toInt();
-    result.inlineSuppressions = mSettings->value(SETTINGS_INLINE_SUPPRESSIONS, false).toBool();
-    result.inconclusive = mSettings->value(SETTINGS_INCONCLUSIVE_ERRORS, false).toBool();
-    if (!mProjectFile || result.platformType == cppcheck::Platform::Unspecified)
-        result.platform((cppcheck::Platform::PlatformType) mSettings->value(SETTINGS_CHECKED_PLATFORM, 0).toInt());
-    result.standards.setCPP(mSettings->value(SETTINGS_STD_CPP, QString()).toString().toStdString());
-    result.standards.setC(mSettings->value(SETTINGS_STD_C, QString()).toString().toStdString());
-    result.enforcedLang = (Settings::Language)mSettings->value(SETTINGS_ENFORCED_LANGUAGE, 0).toInt();
+    settings.severity.enable(Severity::warning);
+    settings.severity.enable(Severity::style);
+    settings.severity.enable(Severity::performance);
+    settings.severity.enable(Severity::portability);
+    settings.severity.enable(Severity::information);
+    settings.checks.enable(Checks::missingInclude);
+    if (!settings.buildDir.empty())
+        settings.checks.enable(Checks::unusedFunction);
+    settings.debugwarnings = mSettings->value(SETTINGS_SHOW_DEBUG_WARNINGS, false).toBool();
+    settings.quiet = false;
+    settings.verbose = true;
+    settings.force = mSettings->value(SETTINGS_CHECK_FORCE, 0).toBool();
+    settings.outputFormat = Settings::OutputFormat::text;
+    settings.jobs = mSettings->value(SETTINGS_CHECK_THREADS, 1).toInt();
+    settings.certainty.setEnabled(Certainty::inconclusive, mSettings->value(SETTINGS_INCONCLUSIVE_ERRORS, false).toBool());
+    if (!mProjectFile || settings.platform.type == Platform::Type::Unspecified)
+        settings.platform.set(static_cast<Platform::Type>(mSettings->value(SETTINGS_CHECKED_PLATFORM, 0).toInt()));
+    settings.standards.setCPP(mSettings->value(SETTINGS_STD_CPP, QString()).toString().toStdString());
+    settings.standards.setC(mSettings->value(SETTINGS_STD_C, QString()).toString().toStdString());
+
+    settings.jobs = std::max(settings.jobs, 1u);
 
-    if (result.jobs <= 1) {
-        result.jobs = 1;
-    }
-
-    result.terminate(false);
+    Settings::terminate(false);
 
-    return result;
+    return true;
 }
 
 void MainWindow::analysisDone()
@@ -939,41 +1258,41 @@ void MainWindow::analysisDone()
         return;
     }
 
-    mUI.mResults->checkingFinished();
+    mUI->mResults->checkingFinished();
     enableCheckButtons(true);
-    mUI.mActionSettings->setEnabled(true);
-    mUI.mActionOpenXML->setEnabled(true);
+    mUI->mActionSettings->setEnabled(true);
+    mUI->mActionOpenXML->setEnabled(true);
     if (mProjectFile) {
         enableProjectActions(true);
     } else if (mIsLogfileLoaded) {
-        mUI.mActionReanalyzeModified->setEnabled(false);
-        mUI.mActionReanalyzeAll->setEnabled(false);
+        mUI->mActionReanalyzeModified->setEnabled(false);
+        mUI->mActionReanalyzeAll->setEnabled(false);
     }
     enableProjectOpenActions(true);
     mPlatformActions->setEnabled(true);
     mCStandardActions->setEnabled(true);
     mCppStandardActions->setEnabled(true);
     mSelectLanguageActions->setEnabled(true);
-    mUI.mActionPosix->setEnabled(true);
+    mUI->mActionPosix->setEnabled(true);
     if (mScratchPad)
         mScratchPad->setEnabled(true);
-    mUI.mActionViewStats->setEnabled(true);
+    mUI->mActionViewStats->setEnabled(true);
 
     if (mProjectFile && !mProjectFile->getBuildDir().isEmpty()) {
         const QString prjpath = QFileInfo(mProjectFile->getFilename()).absolutePath();
         const QString buildDir = prjpath + '/' + mProjectFile->getBuildDir();
         if (QDir(buildDir).exists()) {
-            mUI.mResults->saveStatistics(buildDir + "/statistics.txt");
-            mUI.mResults->updateFromOldReport(buildDir + "/lastResults.xml");
-            mUI.mResults->save(buildDir + "/lastResults.xml", Report::XMLV2);
+            mUI->mResults->saveStatistics(buildDir + "/statistics.txt");
+            mUI->mResults->updateFromOldReport(buildDir + "/lastResults.xml");
+            mUI->mResults->save(buildDir + "/lastResults.xml", Report::XMLV2, mCppcheckCfgProductName);
         }
     }
 
     enableResultsButtons();
 
-    for (int i = 0; i < MaxRecentProjects + 1; i++) {
-        if (mRecentProjectActs[i] != nullptr)
-            mRecentProjectActs[i]->setEnabled(true);
+    for (QAction* recentProjectAct : mRecentProjectActs) {
+        if (recentProjectAct != nullptr)
+            recentProjectAct->setEnabled(true);
     }
 
     // Notify user - if the window is not active - that check is ready
@@ -985,37 +1304,37 @@ void MainWindow::analysisDone()
 void MainWindow::checkLockDownUI()
 {
     enableCheckButtons(false);
-    mUI.mActionSettings->setEnabled(false);
-    mUI.mActionOpenXML->setEnabled(false);
+    mUI->mActionSettings->setEnabled(false);
+    mUI->mActionOpenXML->setEnabled(false);
     enableProjectActions(false);
     enableProjectOpenActions(false);
     mPlatformActions->setEnabled(false);
     mCStandardActions->setEnabled(false);
     mCppStandardActions->setEnabled(false);
     mSelectLanguageActions->setEnabled(false);
-    mUI.mActionPosix->setEnabled(false);
+    mUI->mActionPosix->setEnabled(false);
     if (mScratchPad)
         mScratchPad->setEnabled(false);
 
-    for (int i = 0; i < MaxRecentProjects + 1; i++) {
-        if (mRecentProjectActs[i] != nullptr)
-            mRecentProjectActs[i]->setEnabled(false);
+    for (QAction* recentProjectAct : mRecentProjectActs) {
+        if (recentProjectAct != nullptr)
+            recentProjectAct->setEnabled(false);
     }
 }
 
 void MainWindow::programSettings()
 {
-    SettingsDialog dialog(mApplications, mTranslation, this);
+    SettingsDialog dialog(mApplications, mTranslation, isCppcheckPremium(), this);
     if (dialog.exec() == QDialog::Accepted) {
         dialog.saveSettingValues();
         mSettings->sync();
-        mUI.mResults->updateSettings(dialog.showFullPath(),
-                                     dialog.saveFullPath(),
-                                     dialog.saveAllErrors(),
-                                     dialog.showNoErrorsMessage(),
-                                     dialog.showErrorId(),
-                                     dialog.showInconclusive());
-        mUI.mResults->updateStyleSetting(mSettings);
+        mUI->mResults->updateSettings(dialog.showFullPath(),
+                                      dialog.saveFullPath(),
+                                      dialog.saveAllErrors(),
+                                      dialog.showNoErrorsMessage(),
+                                      dialog.showErrorId(),
+                                      dialog.showInconclusive());
+        mUI->mResults->updateStyleSetting(mSettings);
         const QString newLang = mSettings->value(SETTINGS_LANGUAGE, "en").toString();
         setLanguage(newLang);
     }
@@ -1029,7 +1348,7 @@ void MainWindow::reAnalyzeModified()
 void MainWindow::reAnalyzeAll()
 {
     if (mProjectFile)
-        analyzeProject(mProjectFile);
+        analyzeProject(mProjectFile, QStringList());
     else
         reAnalyze(true);
 }
@@ -1037,78 +1356,112 @@ void MainWindow::reAnalyzeAll()
 void MainWindow::checkLibrary()
 {
     if (mProjectFile)
-        analyzeProject(mProjectFile, true);
+        analyzeProject(mProjectFile, QStringList(), true);
 }
 
 void MainWindow::checkConfiguration()
 {
     if (mProjectFile)
-        analyzeProject(mProjectFile, false, true);
+        analyzeProject(mProjectFile, QStringList(), false, true);
 }
 
-void MainWindow::reAnalyzeSelected(QStringList files)
+void MainWindow::reAnalyzeSelected(const QStringList& files)
 {
     if (files.empty())
         return;
     if (mThread->isChecking())
         return;
 
+    if (mProjectFile) {
+        // Clear details, statistics and progress
+        mUI->mResults->clear(false);
+        for (int i = 0; i < files.size(); ++i)
+            mUI->mResults->clearRecheckFile(files[i]);
+
+        analyzeProject(mProjectFile, files);
+        return;
+    }
+
+    Settings checkSettings;
+    auto supprs = std::make_shared<Suppressions>();
+    if (!getCppcheckSettings(checkSettings, *supprs))
+        return;
+
     // Clear details, statistics and progress
-    mUI.mResults->clear(false);
+    mUI->mResults->clear(false);
     for (int i = 0; i < files.size(); ++i)
-        mUI.mResults->clearRecheckFile(files[i]);
+        mUI->mResults->clearRecheckFile(files[i]);
 
-    mCurrentDirectory = mUI.mResults->getCheckDirectory();
+    mCurrentDirectory = mUI->mResults->getCheckDirectory();
     FileList pathList;
     pathList.addPathList(files);
     if (mProjectFile)
         pathList.addExcludeList(mProjectFile->getExcludedPaths());
-    QStringList fileNames = pathList.getFileList();
+
+    std::list<FileWithDetails> fdetails = enrichFilesForAnalysis(pathList.getFileList(), checkSettings);
+
     checkLockDownUI(); // lock UI while checking
-    mUI.mResults->checkingStarted(fileNames.size());
-    mThread->setCheckFiles(fileNames);
+    mUI->mResults->checkingStarted(fdetails.size());
+    mThread->setCheckFiles(std::move(fdetails));
 
     // Saving last check start time, otherwise unchecked modified files will not be
     // considered in "Modified Files Check"  performed after "Selected Files Check"
     // TODO: Should we store per file CheckStartTime?
     QDateTime saveCheckStartTime = mThread->getCheckStartTime();
-    mThread->check(getCppcheckSettings());
-    mThread->setCheckStartTime(saveCheckStartTime);
+    mThread->check(checkSettings, supprs);
+    mUI->mResults->setCheckSettings(checkSettings);
+    mThread->setCheckStartTime(std::move(saveCheckStartTime));
 }
 
 void MainWindow::reAnalyze(bool all)
 {
-    const QStringList files = mThread->getReCheckFiles(all);
+    const std::list<FileWithDetails> files = mThread->getReCheckFiles(all);
     if (files.empty())
         return;
 
+    Settings checkSettings;
+    auto supprs = std::make_shared<Suppressions>();
+    if (!getCppcheckSettings(checkSettings, *supprs))
+        return;
+
     // Clear details, statistics and progress
-    mUI.mResults->clear(all);
+    mUI->mResults->clear(all);
 
     // Clear results for changed files
-    for (int i = 0; i < files.size(); ++i)
-        mUI.mResults->clear(files[i]);
+    for (const auto& f : files)
+        mUI->mResults->clear(QString::fromStdString(f.path()));
 
     checkLockDownUI(); // lock UI while checking
-    mUI.mResults->checkingStarted(files.size());
+    mUI->mResults->checkingStarted(files.size());
 
     if (mProjectFile)
         qDebug() << "Rechecking project file" << mProjectFile->getFilename();
 
     mThread->setCheckFiles(all);
-    mThread->check(getCppcheckSettings());
+    mThread->check(checkSettings, supprs);
+    mUI->mResults->setCheckSettings(checkSettings);
 }
 
 void MainWindow::clearResults()
 {
-    mUI.mResults->clear(true);
-    Q_ASSERT(false == mUI.mResults->hasResults());
+    if (mProjectFile && !mProjectFile->getBuildDir().isEmpty()) {
+        QDir dir(QFileInfo(mProjectFile->getFilename()).absolutePath() + '/' + mProjectFile->getBuildDir());
+        for (const QString& f: dir.entryList(QDir::Files)) {
+            if (!f.endsWith("files.txt")) {
+                static const QRegularExpression rx("^.*.s[0-9]+$");
+                if (!rx.match(f).hasMatch())
+                    dir.remove(f);
+            }
+        }
+    }
+    mUI->mResults->clear(true);
+    Q_ASSERT(false == mUI->mResults->hasResults());
     enableResultsButtons();
 }
 
 void MainWindow::openResults()
 {
-    if (mUI.mResults->hasResults()) {
+    if (mUI->mResults->hasResults()) {
         QMessageBox msgBox(this);
         msgBox.setWindowTitle(tr("Cppcheck"));
         const QString msg(tr("Current results will be cleared.\n\n"
@@ -1119,7 +1472,7 @@ void MainWindow::openResults()
         msgBox.addButton(QMessageBox::Yes);
         msgBox.addButton(QMessageBox::No);
         msgBox.setDefaultButton(QMessageBox::Yes);
-        int dlgResult = msgBox.exec();
+        const int dlgResult = msgBox.exec();
         if (dlgResult == QMessageBox::No) {
             return;
         }
@@ -1128,10 +1481,10 @@ void MainWindow::openResults()
     QString selectedFilter;
     const QString filter(tr("XML files (*.xml)"));
     QString selectedFile = QFileDialog::getOpenFileName(this,
-                           tr("Open the report file"),
-                           getPath(SETTINGS_LAST_RESULT_PATH),
-                           filter,
-                           &selectedFilter);
+                                                        tr("Open the report file"),
+                                                        getPath(SETTINGS_LAST_RESULT_PATH),
+                                                        filter,
+                                                        &selectedFilter);
 
     if (!selectedFile.isEmpty()) {
         loadResults(selectedFile);
@@ -1145,10 +1498,11 @@ void MainWindow::loadResults(const QString &selectedFile)
     if (mProjectFile)
         closeProjectFile();
     mIsLogfileLoaded = true;
-    mUI.mResults->clear(true);
-    mUI.mActionReanalyzeModified->setEnabled(false);
-    mUI.mActionReanalyzeAll->setEnabled(false);
-    mUI.mResults->readErrorsXml(selectedFile);
+    mUI->mResults->clear(true);
+    mUI->mResults->setResultsSource(ResultsTree::ResultsSource::Log);
+    mUI->mActionReanalyzeModified->setEnabled(false);
+    mUI->mActionReanalyzeAll->setEnabled(false);
+    mUI->mResults->readErrorsXml(selectedFile);
     setPath(SETTINGS_LAST_RESULT_PATH, selectedFile);
     formatAndSetTitle(selectedFile);
 }
@@ -1156,62 +1510,65 @@ void MainWindow::loadResults(const QString &selectedFile)
 void MainWindow::loadResults(const QString &selectedFile, const QString &sourceDirectory)
 {
     loadResults(selectedFile);
-    mUI.mResults->setCheckDirectory(sourceDirectory);
+    mUI->mResults->setCheckDirectory(sourceDirectory);
 }
 
 void MainWindow::enableCheckButtons(bool enable)
 {
-    mUI.mActionStop->setEnabled(!enable);
-    mUI.mActionAnalyzeFiles->setEnabled(enable);
+    mUI->mActionStop->setEnabled(!enable);
+    mUI->mActionAnalyzeFiles->setEnabled(enable);
 
     if (mProjectFile) {
-        mUI.mActionReanalyzeModified->setEnabled(false);
-        mUI.mActionReanalyzeAll->setEnabled(enable);
+        mUI->mActionReanalyzeModified->setEnabled(enable);
+        mUI->mActionReanalyzeAll->setEnabled(enable);
     } else if (!enable || mThread->hasPreviousFiles()) {
-        mUI.mActionReanalyzeModified->setEnabled(enable);
-        mUI.mActionReanalyzeAll->setEnabled(enable);
+        mUI->mActionReanalyzeModified->setEnabled(enable);
+        mUI->mActionReanalyzeAll->setEnabled(enable);
     }
 
-    mUI.mActionAnalyzeDirectory->setEnabled(enable);
+    mUI->mActionAnalyzeDirectory->setEnabled(enable);
+
+    if (isCppcheckPremium()) {
+        mUI->mActionComplianceReport->setEnabled(enable && mProjectFile && (mProjectFile->getAddons().contains("misra") || !mProjectFile->getCodingStandards().empty()));
+    }
 }
 
 void MainWindow::enableResultsButtons()
 {
-    bool enabled = mUI.mResults->hasResults();
-    mUI.mActionClearResults->setEnabled(enabled);
-    mUI.mActionSave->setEnabled(enabled);
-    mUI.mActionPrint->setEnabled(enabled);
-    mUI.mActionPrintPreview->setEnabled(enabled);
+    mUI->mActionClearResults->setEnabled(mUI->mResults->hasResults());
+    mUI->mActionSave->setEnabled(true);
+    mUI->mActionPrint->setEnabled(true);
+    mUI->mActionPrintPreview->setEnabled(true);
 }
 
 void MainWindow::showStyle(bool checked)
 {
-    mUI.mResults->showResults(ShowTypes::ShowStyle, checked);
+    mUI->mResults->showResults(ShowTypes::ShowStyle, checked);
 }
 
 void MainWindow::showErrors(bool checked)
 {
-    mUI.mResults->showResults(ShowTypes::ShowErrors, checked);
+    mUI->mResults->showResults(ShowTypes::ShowErrors, checked);
 }
 
 void MainWindow::showWarnings(bool checked)
 {
-    mUI.mResults->showResults(ShowTypes::ShowWarnings, checked);
+    mUI->mResults->showResults(ShowTypes::ShowWarnings, checked);
 }
 
 void MainWindow::showPortability(bool checked)
 {
-    mUI.mResults->showResults(ShowTypes::ShowPortability, checked);
+    mUI->mResults->showResults(ShowTypes::ShowPortability, checked);
 }
 
 void MainWindow::showPerformance(bool checked)
 {
-    mUI.mResults->showResults(ShowTypes::ShowPerformance, checked);
+    mUI->mResults->showResults(ShowTypes::ShowPerformance, checked);
 }
 
 void MainWindow::showInformation(bool checked)
 {
-    mUI.mResults->showResults(ShowTypes::ShowInformation, checked);
+    mUI->mResults->showResults(ShowTypes::ShowInformation, checked);
 }
 
 void MainWindow::checkAll()
@@ -1241,7 +1598,7 @@ void MainWindow::closeEvent(QCloseEvent *event)
                         this);
 
         msg.setDefaultButton(QMessageBox::No);
-        int rv = msg.exec();
+        const int rv = msg.exec();
         if (rv == QMessageBox::Yes) {
             // This isn't really very clean way to close threads but since the app is
             // exiting it doesn't matter.
@@ -1255,40 +1612,55 @@ void MainWindow::closeEvent(QCloseEvent *event)
 
 void MainWindow::toggleAllChecked(bool checked)
 {
-    mUI.mActionShowStyle->setChecked(checked);
+    mUI->mActionShowStyle->setChecked(checked);
     showStyle(checked);
-    mUI.mActionShowErrors->setChecked(checked);
+    mUI->mActionShowErrors->setChecked(checked);
     showErrors(checked);
-    mUI.mActionShowWarnings->setChecked(checked);
+    mUI->mActionShowWarnings->setChecked(checked);
     showWarnings(checked);
-    mUI.mActionShowPortability->setChecked(checked);
+    mUI->mActionShowPortability->setChecked(checked);
     showPortability(checked);
-    mUI.mActionShowPerformance->setChecked(checked);
+    mUI->mActionShowPerformance->setChecked(checked);
     showPerformance(checked);
-    mUI.mActionShowInformation->setChecked(checked);
+    mUI->mActionShowInformation->setChecked(checked);
     showInformation(checked);
 }
 
 void MainWindow::about()
 {
-    AboutDialog *dlg = new AboutDialog(CppCheck::version(), CppCheck::extraVersion(), this);
-    dlg->exec();
+    if (!mCppcheckCfgAbout.isEmpty()) {
+        QMessageBox msg(QMessageBox::Information,
+                        tr("About"),
+                        mCppcheckCfgAbout,
+                        QMessageBox::Ok,
+                        this);
+        msg.exec();
+    }
+    else {
+        auto *dlg = new AboutDialog(CppCheck::version(), CppCheck::extraVersion(), this);
+        dlg->exec();
+    }
 }
 
 void MainWindow::showLicense()
 {
-    FileViewDialog *dlg = new FileViewDialog(":COPYING", tr("License"), this);
+    auto *dlg = new FileViewDialog(":COPYING", tr("License"), this);
     dlg->resize(570, 400);
     dlg->exec();
 }
 
 void MainWindow::showAuthors()
 {
-    FileViewDialog *dlg = new FileViewDialog(":AUTHORS", tr("Authors"), this);
+    auto *dlg = new FileViewDialog(":AUTHORS", tr("Authors"), this);
     dlg->resize(350, 400);
     dlg->exec();
 }
 
+void MainWindow::showEULA()
+{
+    QDesktopServices::openUrl(QUrl("https://www.cppcheck.com/EULA"));
+}
+
 void MainWindow::performSelectedFilesCheck(const QStringList &selectedFilesList)
 {
     reAnalyzeSelected(selectedFilesList);
@@ -1299,10 +1671,10 @@ void MainWindow::save()
     QString selectedFilter;
     const QString filter(tr("XML files (*.xml);;Text files (*.txt);;CSV files (*.csv)"));
     QString selectedFile = QFileDialog::getSaveFileName(this,
-                           tr("Save the report file"),
-                           getPath(SETTINGS_LAST_RESULT_PATH),
-                           filter,
-                           &selectedFilter);
+                                                        tr("Save the report file"),
+                                                        getPath(SETTINGS_LAST_RESULT_PATH),
+                                                        filter,
+                                                        &selectedFilter);
 
     if (!selectedFile.isEmpty()) {
         Report::Type type = Report::TXT;
@@ -1327,38 +1699,72 @@ void MainWindow::save()
                 type = Report::CSV;
         }
 
-        mUI.mResults->save(selectedFile, type);
+        mUI->mResults->save(selectedFile, type, mCppcheckCfgProductName);
         setPath(SETTINGS_LAST_RESULT_PATH, selectedFile);
     }
 }
 
+void MainWindow::complianceReport()
+{
+    if (!mUI->mResults->isSuccess()) {
+        QMessageBox m(QMessageBox::Critical,
+                      "Cppcheck",
+                      tr("Cannot generate a compliance report right now, an analysis must finish successfully. Try to reanalyze the code and ensure there are no critical errors."),
+                      QMessageBox::Ok,
+                      this);
+        m.exec();
+        return;
+    }
+
+    QTemporaryFile tempResults;
+    (void)tempResults.open(); // TODO: check result
+    tempResults.close();
+
+    mUI->mResults->save(tempResults.fileName(), Report::XMLV2, mCppcheckCfgProductName);
+
+    ComplianceReportDialog dlg(mProjectFile, tempResults.fileName(), mUI->mResults->getStatistics()->getCheckersReport());
+    dlg.exec();
+}
+
 void MainWindow::resultsAdded()
 {
+    enableResultsButtons();
 }
 
 void MainWindow::toggleMainToolBar()
 {
-    mUI.mToolBarMain->setVisible(mUI.mActionToolBarMain->isChecked());
+    mUI->mToolBarMain->setVisible(mUI->mActionToolBarMain->isChecked());
 }
 
 void MainWindow::toggleViewToolBar()
 {
-    mUI.mToolBarView->setVisible(mUI.mActionToolBarView->isChecked());
+    mUI->mToolBarView->setVisible(mUI->mActionToolBarView->isChecked());
 }
 
 void MainWindow::toggleFilterToolBar()
 {
-    mUI.mToolBarFilter->setVisible(mUI.mActionToolBarFilter->isChecked());
+    mUI->mToolBarFilter->setVisible(mUI->mActionToolBarFilter->isChecked());
     mLineEditFilter->clear(); // Clearing the filter also disables filtering
 }
 
 void MainWindow::formatAndSetTitle(const QString &text)
 {
+    QString nameWithVersion = QString("Cppcheck %1").arg(CppCheck::version());
+
+    QString extraVersion = CppCheck::extraVersion();
+    if (!extraVersion.isEmpty()) {
+        nameWithVersion += " (" + extraVersion + ")";
+    }
+
+    // TODO: should not contain the version
+    if (!mCppcheckCfgProductName.isEmpty())
+        nameWithVersion = mCppcheckCfgProductName;
+
     QString title;
     if (text.isEmpty())
-        title = tr("Cppcheck");
+        title = nameWithVersion;
     else
-        title = QString(tr("Cppcheck - %1")).arg(text);
+        title = QString("%1 - %2").arg(nameWithVersion, text);
     setWindowTitle(title);
 }
 
@@ -1370,25 +1776,30 @@ void MainWindow::setLanguage(const QString &code)
 
     if (mTranslation->setLanguage(code)) {
         //Translate everything that is visible here
-        mUI.retranslateUi(this);
-        mUI.mResults->translate();
+        mUI->retranslateUi(this);
+        mUI->mResults->translate();
+        mLineEditFilter->setPlaceholderText(QCoreApplication::translate("MainWindow", "Quick Filter:"));
+        if (mProjectFile)
+            formatAndSetTitle(tr("Project:") + ' ' + mProjectFile->getFilename());
+        if (mScratchPad)
+            mScratchPad->translate();
     }
 }
 
 void MainWindow::aboutToShowViewMenu()
 {
-    mUI.mActionToolBarMain->setChecked(mUI.mToolBarMain->isVisible());
-    mUI.mActionToolBarView->setChecked(mUI.mToolBarView->isVisible());
-    mUI.mActionToolBarFilter->setChecked(mUI.mToolBarFilter->isVisible());
+    mUI->mActionToolBarMain->setChecked(mUI->mToolBarMain->isVisible());
+    mUI->mActionToolBarView->setChecked(mUI->mToolBarView->isVisible());
+    mUI->mActionToolBarFilter->setChecked(mUI->mToolBarFilter->isVisible());
 }
 
 void MainWindow::stopAnalysis()
 {
     mThread->stop();
-    mUI.mResults->disableProgressbar();
+    mUI->mResults->stopAnalysis();
     const QString &lastResults = getLastResults();
     if (!lastResults.isEmpty()) {
-        mUI.mResults->updateFromOldReport(lastResults);
+        mUI->mResults->updateFromOldReport(lastResults);
     }
 }
 
@@ -1399,16 +1810,17 @@ void MainWindow::openHelpContents()
 
 void MainWindow::openOnlineHelp()
 {
-    QDesktopServices::openUrl(QUrl(OnlineHelpURL));
+    auto *helpDialog = new HelpDialog;
+    helpDialog->showMaximized();
 }
 
 void MainWindow::openProjectFile()
 {
     const QString filter = tr("Project files (*.cppcheck);;All files(*.*)");
     const QString filepath = QFileDialog::getOpenFileName(this,
-                             tr("Select Project File"),
-                             getPath(SETTINGS_LAST_PROJECT_PATH),
-                             filter);
+                                                          tr("Select Project File"),
+                                                          getPath(SETTINGS_LAST_PROJECT_PATH),
+                                                          filter);
 
     if (!filepath.isEmpty()) {
         const QFileInfo fi(filepath);
@@ -1438,12 +1850,15 @@ void MainWindow::loadProjectFile(const QString &filePath)
     addProjectMRU(filePath);
 
     mIsLogfileLoaded = false;
-    mUI.mActionCloseProjectFile->setEnabled(true);
-    mUI.mActionEditProjectFile->setEnabled(true);
+    mUI->mResults->setResultsSource(ResultsTree::ResultsSource::Analysis);
+    mUI->mActionReanalyzeModified->setEnabled(true);
+    mUI->mActionReanalyzeAll->setEnabled(true);
+    enableProjectActions(true);
     delete mProjectFile;
     mProjectFile = new ProjectFile(filePath, this);
+    mProjectFile->setActiveProject();
     if (!loadLastResults())
-        analyzeProject(mProjectFile);
+        analyzeProject(mProjectFile, QStringList());
 }
 
 QString MainWindow::getLastResults() const
@@ -1455,31 +1870,53 @@ QString MainWindow::getLastResults() const
 
 bool MainWindow::loadLastResults()
 {
-    if (mProjectFile)
-        mUI.mResults->setTags(mProjectFile->getTags());
     const QString &lastResults = getLastResults();
     if (lastResults.isEmpty())
         return false;
-    if (!QFileInfo(lastResults).exists())
+    if (!QFileInfo::exists(lastResults))
         return false;
-    mUI.mResults->readErrorsXml(lastResults);
-    mUI.mResults->setCheckDirectory(mSettings->value(SETTINGS_LAST_CHECK_PATH,QString()).toString());
-    mUI.mActionViewStats->setEnabled(true);
+    mUI->mResults->clear(true);
+    mUI->mResults->readErrorsXml(lastResults);
+    mUI->mResults->setCheckDirectory(mSettings->value(SETTINGS_LAST_CHECK_PATH,QString()).toString());
+    mUI->mActionViewStats->setEnabled(true);
     enableResultsButtons();
     return true;
 }
 
-void MainWindow::analyzeProject(const ProjectFile *projectFile, const bool checkLibrary, const bool checkConfiguration)
+void MainWindow::analyzeProject(const ProjectFile *projectFile, const QStringList& recheckFiles, const bool checkLibrary, const bool checkConfiguration)
 {
     Settings::terminate(false);
 
     QFileInfo inf(projectFile->getFilename());
-    const QString rootpath = projectFile->getRootPath();
+    const QString& rootpath = projectFile->getRootPath();
+
+    if (isCppcheckPremium() && !projectFile->getLicenseFile().isEmpty()) {
+        if (rootpath.isEmpty() || rootpath == ".")
+            QDir::setCurrent(inf.absolutePath());
+        else if (QDir(rootpath).isAbsolute())
+            QDir::setCurrent(rootpath);
+        else
+            QDir::setCurrent(inf.absolutePath() + "/" + rootpath);
+
+        QString licenseFile = projectFile->getLicenseFile();
+        if (!QFileInfo(licenseFile).isAbsolute() && !rootpath.isEmpty())
+            licenseFile = inf.absolutePath() + "/" + licenseFile;
+
+#ifdef Q_OS_WIN
+        const QString premiumaddon = QCoreApplication::applicationDirPath() + "/premiumaddon.exe";
+#else
+        const QString premiumaddon = QCoreApplication::applicationDirPath() + "/premiumaddon";
+#endif
+        const std::vector<std::string> args{"--check-loc-license", licenseFile.toStdString()};
+        std::string output;
+        CheckThread::executeCommand(premiumaddon.toStdString(), args, "", output);
+        std::ofstream fout(inf.absolutePath().toStdString() + "/cppcheck-premium-loc");
+        fout << output;
+    }
 
     QDir::setCurrent(inf.absolutePath());
 
-    mThread->setAddonsAndTools(projectFile->getAddonsAndTools(), mSettings->value(SETTINGS_MISRA_FILE).toString());
-    mUI.mResults->setTags(projectFile->getTags());
+    mThread->setAddonsAndTools(projectFile->getAddonsAndTools());
 
     // If the root path is not given or is not "current dir", use project
     // file's location directory as root path
@@ -1495,13 +1932,21 @@ void MainWindow::analyzeProject(const ProjectFile *projectFile, const bool check
         if (!QDir::isAbsolutePath(buildDir))
             buildDir = inf.canonicalPath() + '/' + buildDir;
         if (!QDir(buildDir).exists()) {
-            QMessageBox msg(QMessageBox::Critical,
+            QMessageBox msg(QMessageBox::Question,
                             tr("Cppcheck"),
                             tr("Build dir '%1' does not exist, create it?").arg(buildDir),
                             QMessageBox::Yes | QMessageBox::No,
                             this);
             if (msg.exec() == QMessageBox::Yes) {
                 QDir().mkpath(buildDir);
+            } else if (!projectFile->getAddons().isEmpty()) {
+                QMessageBox m(QMessageBox::Critical,
+                              tr("Cppcheck"),
+                              tr("To check the project using addons, you need a build directory."),
+                              QMessageBox::Ok,
+                              this);
+                m.exec();
+                return;
             }
         }
     }
@@ -1516,21 +1961,61 @@ void MainWindow::analyzeProject(const ProjectFile *projectFile, const bool check
             prjfile = inf.canonicalPath() + '/' + projectFile->getImportProject();
         }
         try {
-            p.import(prjfile.toStdString());
+
+            const ImportProject::Type result = p.import(prjfile.toStdString());
+
+            QString errorMessage;
+            switch (result) {
+            case ImportProject::Type::COMPILE_DB:
+            case ImportProject::Type::VS_SLN:
+            case ImportProject::Type::VS_VCXPROJ:
+            case ImportProject::Type::BORLAND:
+            case ImportProject::Type::CPPCHECK_GUI:
+                // Loading was successful
+                break;
+            case ImportProject::Type::MISSING:
+                errorMessage = tr("Failed to open file");
+                break;
+            case ImportProject::Type::UNKNOWN:
+                errorMessage = tr("Unknown project file format");
+                break;
+            case ImportProject::Type::FAILURE:
+                errorMessage = tr("Failed to import project file");
+                break;
+            case ImportProject::Type::NONE:
+                // can never happen
+                break;
+            }
+
+            if (!p.errors.empty())
+                errorMessage += ": \n";
+
+            for (const auto &error : p.errors)
+                errorMessage += "\n - " + QString::fromStdString(error);
+
+            if (!errorMessage.isEmpty()) {
+                QMessageBox msg(QMessageBox::Critical,
+                                tr("Cppcheck"),
+                                tr("Failed to import '%1': %2\n\nAnalysis is stopped.").arg(prjfile).arg(errorMessage),
+                                QMessageBox::Ok,
+                                this);
+                msg.exec();
+                return;
+            }
         } catch (InternalError &e) {
             QMessageBox msg(QMessageBox::Critical,
                             tr("Cppcheck"),
-                            tr("Failed to import '%1', analysis is stopped").arg(prjfile),
+                            tr("Failed to import '%1' (%2), analysis is stopped").arg(prjfile).arg(QString::fromStdString(e.errorMessage)),
                             QMessageBox::Ok,
                             this);
             msg.exec();
             return;
         }
-        doAnalyzeProject(p, checkLibrary, checkConfiguration);
+        doAnalyzeProject(p, checkLibrary, checkConfiguration);  // TODO: avoid copy
         return;
     }
 
-    QStringList paths = projectFile->getCheckPaths();
+    QStringList paths = recheckFiles.isEmpty() ? projectFile->getCheckPaths() : recheckFiles;
 
     // If paths not given then check the root path (which may be the project
     // file's location, see above). This is to keep the compatibility with
@@ -1546,9 +2031,9 @@ void MainWindow::newProjectFile()
 {
     const QString filter = tr("Project files (*.cppcheck)");
     QString filepath = QFileDialog::getSaveFileName(this,
-                       tr("Select Project Filename"),
-                       getPath(SETTINGS_LAST_PROJECT_PATH),
-                       filter);
+                                                    tr("Select Project Filename"),
+                                                    getPath(SETTINGS_LAST_PROJECT_PATH),
+                                                    filter);
 
     if (filepath.isEmpty())
         return;
@@ -1563,13 +2048,15 @@ void MainWindow::newProjectFile()
 
     delete mProjectFile;
     mProjectFile = new ProjectFile(this);
+    mProjectFile->setActiveProject();
     mProjectFile->setFilename(filepath);
+    mProjectFile->setProjectName(filename.left(filename.indexOf(".")));
     mProjectFile->setBuildDir(filename.left(filename.indexOf(".")) + "-cppcheck-build-dir");
 
-    ProjectFileDialog dlg(mProjectFile, this);
+    ProjectFileDialog dlg(mProjectFile, isCppcheckPremium(), this);
     if (dlg.exec() == QDialog::Accepted) {
         addProjectMRU(filepath);
-        analyzeProject(mProjectFile);
+        analyzeProject(mProjectFile, QStringList());
     } else {
         closeProjectFile();
     }
@@ -1579,8 +2066,7 @@ void MainWindow::closeProjectFile()
 {
     delete mProjectFile;
     mProjectFile = nullptr;
-    mUI.mResults->clear(true);
-    mUI.mResults->setTags(QStringList());
+    mUI->mResults->clear(true);
     enableProjectActions(false);
     enableProjectOpenActions(true);
     formatAndSetTitle();
@@ -1591,17 +2077,17 @@ void MainWindow::editProjectFile()
     if (!mProjectFile) {
         QMessageBox msg(QMessageBox::Critical,
                         tr("Cppcheck"),
-                        QString(tr("No project file loaded")),
+                        tr("No project file loaded"),
                         QMessageBox::Ok,
                         this);
         msg.exec();
         return;
     }
 
-    ProjectFileDialog dlg(mProjectFile, this);
+    ProjectFileDialog dlg(mProjectFile, isCppcheckPremium(), this);
     if (dlg.exec() == QDialog::Accepted) {
         mProjectFile->write();
-        analyzeProject(mProjectFile);
+        analyzeProject(mProjectFile, QStringList());
     }
 }
 
@@ -1614,7 +2100,7 @@ void MainWindow::showStatistics()
     statsDialog.setPathSelected(mCurrentDirectory);
     statsDialog.setNumberOfFilesScanned(mThread->getPreviousFilesCount());
     statsDialog.setScanDuration(mThread->getPreviousScanDuration() / 1000.0);
-    statsDialog.setStatistics(mUI.mResults->getStatistics());
+    statsDialog.setStatistics(mUI->mResults->getStatistics());
 
     statsDialog.exec();
 }
@@ -1625,28 +2111,42 @@ void MainWindow::showLibraryEditor()
     libraryDialog.exec();
 }
 
+void MainWindow::showThreadDetails()
+{
+    if (ThreadDetails::instance())
+        return;
+    auto* threadDetails = new ThreadDetails(this);
+    connect(mThread, &ThreadHandler::threadDetailsUpdated,
+            threadDetails, &ThreadDetails::threadDetailsUpdated, Qt::QueuedConnection);
+    connect(mThread, &ThreadHandler::progress,
+            threadDetails, &ThreadDetails::progress, Qt::QueuedConnection);
+    threadDetails->setAttribute(Qt::WA_DeleteOnClose);
+    threadDetails->show();
+    mThread->emitThreadDetailsUpdated();
+}
+
 void MainWindow::filterResults()
 {
-    mUI.mResults->filterResults(mLineEditFilter->text());
+    mUI->mResults->filterResults(mLineEditFilter->text());
 }
 
 void MainWindow::enableProjectActions(bool enable)
 {
-    mUI.mActionCloseProjectFile->setEnabled(enable);
-    mUI.mActionEditProjectFile->setEnabled(enable);
-    mUI.mActionCheckLibrary->setEnabled(enable);
-    mUI.mActionCheckConfiguration->setEnabled(enable);
+    mUI->mActionCloseProjectFile->setEnabled(enable);
+    mUI->mActionEditProjectFile->setEnabled(enable);
+    mUI->mActionCheckLibrary->setEnabled(enable);
+    mUI->mActionCheckConfiguration->setEnabled(enable);
 }
 
 void MainWindow::enableProjectOpenActions(bool enable)
 {
-    mUI.mActionNewProjectFile->setEnabled(enable);
-    mUI.mActionOpenProjectFile->setEnabled(enable);
+    mUI->mActionNewProjectFile->setEnabled(enable);
+    mUI->mActionOpenProjectFile->setEnabled(enable);
 }
 
 void MainWindow::openRecentProject()
 {
-    QAction *action = qobject_cast<QAction *>(sender());
+    auto *action = qobject_cast<QAction *>(sender());
     if (!action)
         return;
     const QString project = action->data().toString();
@@ -1670,7 +2170,7 @@ void MainWindow::openRecentProject()
                         this);
 
         msg.setDefaultButton(QMessageBox::No);
-        int rv = msg.exec();
+        const int rv = msg.exec();
         if (rv == QMessageBox::Yes) {
             removeProjectMRU(project);
         }
@@ -1679,9 +2179,9 @@ void MainWindow::openRecentProject()
 
 void MainWindow::updateMRUMenuItems()
 {
-    for (int i = 0; i < MaxRecentProjects + 1; i++) {
-        if (mRecentProjectActs[i] != nullptr)
-            mUI.mMenuFile->removeAction(mRecentProjectActs[i]);
+    for (QAction* recentProjectAct : mRecentProjectActs) {
+        if (recentProjectAct != nullptr)
+            mUI->mMenuFile->removeAction(recentProjectAct);
     }
 
     QStringList projects = mSettings->value(SETTINGS_MRU_PROJECTS).toStringList();
@@ -1689,7 +2189,7 @@ void MainWindow::updateMRUMenuItems()
     // Do a sanity check - remove duplicates and non-existing projects
     int removed = projects.removeDuplicates();
     for (int i = projects.size() - 1; i >= 0; i--) {
-        if (!QFileInfo(projects[i]).exists()) {
+        if (!QFileInfo::exists(projects[i])) {
             projects.removeAt(i);
             removed++;
         }
@@ -1698,18 +2198,18 @@ void MainWindow::updateMRUMenuItems()
     if (removed)
         mSettings->setValue(SETTINGS_MRU_PROJECTS, projects);
 
-    const int numRecentProjects = qMin(projects.size(), (int)MaxRecentProjects);
+    const int numRecentProjects = qMin(projects.size(), static_cast<int>(MaxRecentProjects));
     for (int i = 0; i < numRecentProjects; i++) {
         const QString filename = QFileInfo(projects[i]).fileName();
         const QString text = QString("&%1 %2").arg(i + 1).arg(filename);
         mRecentProjectActs[i]->setText(text);
         mRecentProjectActs[i]->setData(projects[i]);
         mRecentProjectActs[i]->setVisible(true);
-        mUI.mMenuFile->insertAction(mUI.mActionProjectMRU, mRecentProjectActs[i]);
+        mUI->mMenuFile->insertAction(mUI->mActionProjectMRU, mRecentProjectActs[i]);
     }
 
     if (numRecentProjects > 1)
-        mRecentProjectActs[numRecentProjects] = mUI.mMenuFile->insertSeparator(mUI.mActionProjectMRU);
+        mRecentProjectActs[numRecentProjects] = mUI->mMenuFile->insertSeparator(mUI->mActionProjectMRU);
 }
 
 void MainWindow::addProjectMRU(const QString &project)
@@ -1735,28 +2235,21 @@ void MainWindow::removeProjectMRU(const QString &project)
 
 void MainWindow::selectPlatform()
 {
-    QAction *action = qobject_cast<QAction *>(sender());
+    auto *action = qobject_cast<QAction *>(sender());
     if (action) {
-        const Settings::PlatformType platform = (Settings::PlatformType) action->data().toInt();
+        const Platform::Type platform = static_cast<Platform::Type>(action->data().toInt());
         mSettings->setValue(SETTINGS_CHECKED_PLATFORM, platform);
     }
 }
 
-void MainWindow::tagged()
-{
-    const QString &lastResults = getLastResults();
-    if (!lastResults.isEmpty())
-        mUI.mResults->save(lastResults, Report::XMLV2);
-}
-
 void MainWindow::suppressIds(QStringList ids)
 {
     if (!mProjectFile)
         return;
     ids.removeDuplicates();
 
-    QList<Suppressions::Suppression> suppressions = mProjectFile->getSuppressions();
-    foreach (QString id, ids) {
+    QList<SuppressionList::Suppression> suppressions = mProjectFile->getSuppressions();
+    for (const QString& id : ids) {
         // Remove all matching suppressions
         std::string id2 = id.toStdString();
         for (int i = 0; i < suppressions.size();) {
@@ -1766,7 +2259,7 @@ void MainWindow::suppressIds(QStringList ids)
                 ++i;
         }
 
-        Suppressions::Suppression newSuppression;
+        SuppressionList::Suppression newSuppression;
         newSuppression.errorId = id2;
         suppressions << newSuppression;
     }
@@ -1774,3 +2267,144 @@ void MainWindow::suppressIds(QStringList ids)
     mProjectFile->setSuppressions(suppressions);
     mProjectFile->write();
 }
+
+static int getVersion(const QString& nameWithVersion) {
+    int ret = 0;
+    int v = 0;
+    int dot = 0;
+    for (const auto c: nameWithVersion) {
+        if (c == '\n' || c == '\r')
+            break;
+        if (c == ' ') {
+            if (ret > 0 && dot == 1 && nameWithVersion.endsWith(" dev"))
+                return (ret * 1000000) + (v * 1000) + 500;
+            dot = ret = v = 0;
+        }
+        else if (c == '.') {
+            ++dot;
+            ret = (ret * 1000) + v;
+            v = 0;
+        } else if (c >= '0' && c <= '9')
+            v = (v * 10) + (c.toLatin1() - '0');
+    }
+    ret = (ret * 1000) + v;
+    while (dot < 2) {
+        ++dot;
+        ret *= 1000;
+    }
+    return ret;
+}
+
+void MainWindow::replyFinished(QNetworkReply *reply) {
+    reply->deleteLater();
+    if (reply->error()) {
+        mUI->mLayoutInformation->deleteLater();
+        qDebug() << "Response: ERROR";
+        return;
+    }
+    const QString str = reply->readAll();
+    qDebug() << "Response: " << str;
+    if (reply->url().fileName() == "version.txt") {
+        // TODO: lacks extra version
+        QString nameWithVersion = QString("Cppcheck %1").arg(CppCheck::version());
+        // TODO: this should not contain the version
+        if (!mCppcheckCfgProductName.isEmpty())
+            nameWithVersion = mCppcheckCfgProductName;
+        const int appVersion = getVersion(nameWithVersion);
+        const int latestVersion = getVersion(str.trimmed());
+        if (appVersion < latestVersion) {
+            if (mSettings->value(SETTINGS_CHECK_VERSION, 0).toInt() != latestVersion) {
+                QString install;
+                if (isCppcheckPremium()) {
+#ifdef Q_OS_WIN
+                    const QString url("https://cppchecksolutions.com/cppcheck-premium-installation");
+#else
+                    const QString url("https://cppchecksolutions.com/cppcheck-premium-linux-installation");
+#endif
+                    install = "<a href=\"" + url + "\">" + tr("Install") + "</a>";
+                }
+                mUI->mButtonHideInformation->setVisible(true);
+                mUI->mLabelInformation->setVisible(true);
+                mUI->mLabelInformation->setText(tr("New version available: %1. %2").arg(str.trimmed()).arg(install));
+            }
+        }
+    }
+    if (!mUI->mLabelInformation->isVisible()) {
+        mUI->mLayoutInformation->deleteLater();
+    }
+}
+
+void MainWindow::hideInformation() {
+    int version = getVersion(mUI->mLabelInformation->text());
+    mSettings->setValue(SETTINGS_CHECK_VERSION, version);
+    mUI->mLabelInformation->setVisible(false);
+    mUI->mButtonHideInformation->setVisible(false);
+    mUI->mLayoutInformation->deleteLater();
+}
+
+bool MainWindow::isCppcheckPremium() const {
+    return mCppcheckCfgProductName.startsWith("Cppcheck Premium ");
+}
+
+void MainWindow::changeReportType() {
+    const ReportType reportType = mUI->mActionReportAutosar->isChecked() ? ReportType::autosar :
+                                  mUI->mActionReportCertC->isChecked() ? ReportType::certC :
+                                  mUI->mActionReportCertCpp->isChecked() ? ReportType::certCpp :
+                                  mUI->mActionReportMisraC->isChecked() ? (mProjectFile ? getMisraCReportType(mProjectFile->getCodingStandards()) : ReportType::misraC2012) :
+                                  mUI->mActionReportMisraCpp2008->isChecked() ? ReportType::misraCpp2008 :
+                                  mUI->mActionReportMisraCpp2023->isChecked() ? ReportType::misraCpp2023 :
+                                  ReportType::normal;
+
+    mUI->mResults->setReportType(reportType);
+
+    auto setTextAndHint = [](QAction* a, const QString& s) {
+        a->setVisible(!s.isEmpty());
+        a->setText(s);
+        a->setToolTip(s);
+    };
+
+    const QString showMandatory = tr("Show Mandatory");
+    const QString showRequired = tr("Show Required");
+    const QString showAdvisory = tr("Show Advisory");
+    const QString showDocument = tr("Show Document");
+
+    if (mUI->mActionReportAutosar->isChecked()) {
+        setTextAndHint(mUI->mActionShowErrors, "");
+        setTextAndHint(mUI->mActionShowWarnings, showRequired);
+        setTextAndHint(mUI->mActionShowStyle, showAdvisory);
+        setTextAndHint(mUI->mActionShowPortability, "");
+        setTextAndHint(mUI->mActionShowPerformance, "");
+        setTextAndHint(mUI->mActionShowInformation, "");
+    } else if (mUI->mActionReportMisraC->isChecked() || mUI->mActionReportMisraCpp2008->isChecked() || mUI->mActionReportMisraCpp2023->isChecked()) {
+        setTextAndHint(mUI->mActionShowErrors, mUI->mActionReportMisraCpp2008->isChecked() ? "" : showMandatory);
+        setTextAndHint(mUI->mActionShowWarnings, showRequired);
+        setTextAndHint(mUI->mActionShowStyle, showAdvisory);
+        setTextAndHint(mUI->mActionShowPortability, "");
+        setTextAndHint(mUI->mActionShowPerformance, "");
+        setTextAndHint(mUI->mActionShowInformation, mUI->mActionReportMisraCpp2008->isChecked() ? showDocument : QString());
+    } else if (mUI->mActionReportCertC->isChecked() || mUI->mActionReportCertCpp->isChecked()) {
+        setTextAndHint(mUI->mActionShowErrors, tr("Show L1"));
+        setTextAndHint(mUI->mActionShowWarnings, tr("Show L2"));
+        setTextAndHint(mUI->mActionShowStyle, tr("Show L3"));
+        setTextAndHint(mUI->mActionShowPortability, "");
+        setTextAndHint(mUI->mActionShowPerformance, "");
+        setTextAndHint(mUI->mActionShowInformation, "");
+    } else {
+        setTextAndHint(mUI->mActionShowErrors, tr("Show errors"));
+        setTextAndHint(mUI->mActionShowWarnings, tr("Show warnings"));
+        setTextAndHint(mUI->mActionShowStyle, tr("Show style"));
+        setTextAndHint(mUI->mActionShowPortability, tr("Show portability"));
+        setTextAndHint(mUI->mActionShowPerformance, tr("Show performance"));
+        setTextAndHint(mUI->mActionShowInformation, tr("Show information"));
+    }
+}
+
+std::list<FileWithDetails> MainWindow::enrichFilesForAnalysis(const QStringList& fileNames, const Settings& settings) const {
+    std::list<FileWithDetails> fdetails;
+    std::transform(fileNames.cbegin(), fileNames.cend(), std::back_inserter(fdetails), [](const QString& f) {
+        return FileWithDetails{f.toStdString(), Standards::Language::None, static_cast<std::size_t>(QFile(f).size())};
+    });
+    const Standards::Language enforcedLang = static_cast<Standards::Language>(mSettings->value(SETTINGS_ENFORCED_LANGUAGE, 0).toInt());
+    frontend::applyLang(fdetails, settings, enforcedLang);
+    return fdetails;
+}
diff --git a/gui/mainwindow.h b/gui/mainwindow.h
index 6812b17c8dd..45506f3f6b8 100644
--- a/gui/mainwindow.h
+++ b/gui/mainwindow.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,23 +19,37 @@
 #ifndef MAINWINDOW_H
 #define MAINWINDOW_H
 
-#include <QMainWindow>
-#include <QSettings>
+#include "library.h"
+#include "platforms.h"
+
+#include <cstdint>
+#include <list>
+
 #include <QFileDialog>
-#include <QActionGroup>
-#include <QTimer>
+#include <QMainWindow>
+#include <QObject>
+#include <QString>
 #include <QStringList>
 
-#include "settings.h"
-#include "platforms.h"
-#include "ui_mainwindow.h"
-
 class ThreadHandler;
 class TranslationHandler;
 class ScratchPad;
 class ProjectFile;
-class ErrorItem;
+class ApplicationList;
 class QAction;
+class QActionGroup;
+class QSettings;
+class QTimer;
+class QLineEdit;
+class ImportProject;
+class QNetworkAccessManager;
+class QNetworkReply;
+class Settings;
+struct Suppressions;
+class FileWithDetails;
+namespace Ui {
+    class MainWindow;
+}
 
 /// @addtogroup GUI
 /// @{
@@ -51,16 +65,16 @@ class MainWindow : public QMainWindow {
     /**
      * @brief Maximum number of MRU project items in File-menu.
      */
-    enum { MaxRecentProjects = 5 };
+    enum : std::uint8_t { MaxRecentProjects = 5 };
 
     MainWindow(TranslationHandler* th, QSettings* settings);
     MainWindow(const MainWindow &) = delete;
-    virtual ~MainWindow();
+    ~MainWindow() override;
     MainWindow &operator=(const MainWindow &) = delete;
 
     /**
-      * List of checked platforms.
-      */
+     * List of checked platforms.
+     */
     Platforms mPlatforms;
 
     /**
@@ -72,7 +86,6 @@ class MainWindow : public QMainWindow {
     void analyzeCode(const QString& code, const QString& filename);
 
 public slots:
-
     /** @brief Slot for analyze files menu item */
     void analyzeFiles();
 
@@ -157,9 +170,15 @@ public slots:
     /** @brief Slot to to show authors list */
     void showAuthors();
 
+    /** @brief Slot to to show EULA */
+    void showEULA();
+
     /** @brief Slot to save results */
     void save();
 
+    /** @brief Slot to generate compliance report */
+    void complianceReport();
+
     /** @brief Slot to create new project file */
     void newProjectFile();
 
@@ -181,7 +200,10 @@ public slots:
     /** @brief Slot for showing the library editor */
     void showLibraryEditor();
 
-protected slots:
+    /** @brief Slot for showing the thread details window */
+    void showThreadDetails();
+
+private slots:
 
     /** @brief Slot for checkthread's done signal */
     void analysisDone();
@@ -219,14 +241,19 @@ protected slots:
     /** @brief Selects the platform as analyzed platform. */
     void selectPlatform();
 
-    /** Some results were tagged */
-    void tagged();
-
     /** Suppress error ids */
     void suppressIds(QStringList ids);
 
+private slots:
+    void replyFinished(QNetworkReply *reply);
+
+    void hideInformation();
+
+    void changeReportType();
 private:
 
+    bool isCppcheckPremium() const;
+
     /** Get filename for last results */
     QString getLastResults() const;
 
@@ -237,15 +264,16 @@ protected slots:
      * @brief Reanalyze selected files
      * @param files list of selected files
      */
-    void reAnalyzeSelected(QStringList files);
+    void reAnalyzeSelected(const QStringList& files);
 
     /**
-      * @brief Analyze the project.
-      * @param projectFile Pointer to the project to analyze.
-      * @param checkLibrary Flag to indicate if the library should be checked.
-      * @param checkConfiguration Flag to indicate if the configuration should be checked.
-      */
-    void analyzeProject(const ProjectFile *projectFile, const bool checkLibrary = false, const bool checkConfiguration = false);
+     * @brief Analyze the project.
+     * @param projectFile Pointer to the project to analyze.
+     * @param recheckFiles files to recheck, empty => check all files
+     * @param checkLibrary Flag to indicate if the library should be checked.
+     * @param checkConfiguration Flag to indicate if the configuration should be checked.
+     */
+    void analyzeProject(const ProjectFile *projectFile, const QStringList& recheckFiles, bool checkLibrary = false, bool checkConfiguration = false);
 
     /**
      * @brief Set current language
@@ -254,7 +282,7 @@ protected slots:
     void setLanguage(const QString &code);
 
     /** @brief Event coming when application is about to close. */
-    virtual void closeEvent(QCloseEvent *event);
+    void closeEvent(QCloseEvent *event) override;
 
     /**
      * @brief Helper function to toggle all show error menu items
@@ -284,7 +312,7 @@ protected slots:
      * @param checkLibrary Flag to indicate if library should be checked
      * @param checkConfiguration Flag to indicate if the configuration should be checked.
      */
-    void doAnalyzeProject(ImportProject p, const bool checkLibrary = false, const bool checkConfiguration = false);
+    void doAnalyzeProject(ImportProject p, bool checkLibrary = false, bool checkConfiguration = false);
 
     /**
      * @brief Analyze all files specified in parameter files
@@ -293,14 +321,12 @@ protected slots:
      * @param checkLibrary Flag to indicate if library should be checked
      * @param checkConfiguration Flag to indicate if the configuration should be checked.
      */
-    void doAnalyzeFiles(const QStringList &files, const bool checkLibrary = false, const bool checkConfiguration = false);
+    void doAnalyzeFiles(const QStringList &files, bool checkLibrary = false, bool checkConfiguration = false);
 
     /**
      * @brief Get our default cppcheck settings and read project file.
-     *
-     * @return Default cppcheck settings
      */
-    Settings getCppcheckSettings();
+    bool getCppcheckSettings(Settings& settings, Suppressions& supprs);
 
     /** @brief Load program settings */
     void loadSettings();
@@ -315,7 +341,7 @@ protected slots:
     void formatAndSetTitle(const QString &text = QString());
 
     /** @brief Show help contents */
-    void openOnlineHelp();
+    static void openOnlineHelp();
 
     /**
      * @brief Enable or disable project file actions.
@@ -359,9 +385,9 @@ protected slots:
     void loadResults(const QString &selectedFile, const QString &sourceDirectory);
 
     /**
-    * @brief Load last project results to the GUI.
-    * @return Returns true if last results was loaded
-    */
+     * @brief Load last project results to the GUI.
+     * @return Returns true if last results was loaded
+     */
     bool loadLastResults();
 
     /**
@@ -376,7 +402,7 @@ protected slots:
      * @param filename filename (no path)
      * @return error code
      */
-    Library::Error loadLibrary(Library *library, const QString &filename);
+    Library::Error loadLibrary(Library &library, const QString &filename);
 
     /**
      * @brief Tries to load library file, prints message on error
@@ -384,7 +410,9 @@ protected slots:
      * @param filename filename (no path)
      * @return True if no error
      */
-    bool tryLoadLibrary(Library *library, QString filename);
+    bool tryLoadLibrary(Library &library, const QString& filename);
+
+    QString loadAddon(Settings &settings, const QString &filesDir, const QString &pythonCmd, const QString& addon);
 
     /**
      * @brief Update project MRU items in File-menu.
@@ -403,6 +431,9 @@ protected slots:
      */
     void removeProjectMRU(const QString &project);
 
+    /** @brief Generate list of detailed files from list of filenames. */
+    std::list<FileWithDetails> enrichFilesForAnalysis(const QStringList& fileNames, const Settings& settings) const;
+
     /** @brief Program settings */
     QSettings *mSettings;
 
@@ -416,16 +447,16 @@ protected slots:
     TranslationHandler *mTranslation;
 
     /** @brief Class holding all UI components */
-    Ui::MainWindow mUI;
+    Ui::MainWindow *mUI;
 
     /** @brief Current analyzed directory. */
     QString mCurrentDirectory;
 
     /** @brief Scratchpad. */
-    ScratchPad* mScratchPad;
+    ScratchPad* mScratchPad{};
 
     /** @brief Project (file). */
-    ProjectFile *mProjectFile;
+    ProjectFile* mProjectFile{};
 
     /** @brief Filter field in the Filter toolbar. */
     QLineEdit* mLineEditFilter;
@@ -442,21 +473,29 @@ protected slots:
     /** @brief GUI actions for selecting language. */
     QActionGroup *mSelectLanguageActions;
 
+    /** @brief GUI actions for selecting report. */
+    QActionGroup *mSelectReportActions;
+
     /**
      * @brief Are we exiting the cppcheck?
      * If this is true then the cppcheck is waiting for check threads to exit
      * so that the application can be closed.
      */
-    bool mExiting;
+    bool mExiting{};
 
     /** @brief Set to true in case of loading log file. */
-    bool mIsLogfileLoaded;
+    bool mIsLogfileLoaded{};
 
     /**
      * @brief Project MRU menu actions.
      * List of MRU menu actions. Needs also to store the separator.
      */
     QAction *mRecentProjectActs[MaxRecentProjects + 1];
+
+    QString mCppcheckCfgAbout;
+    QString mCppcheckCfgProductName;
+
+    QNetworkAccessManager *mNetworkAccessManager = nullptr;
 };
 /// @}
 #endif // MAINWINDOW_H
diff --git a/gui/mainwindow.ui b/gui/mainwindow.ui
index a34a3b4eb41..551874d3225 100644
--- a/gui/mainwindow.ui
+++ b/gui/mainwindow.ui
@@ -50,9 +50,71 @@
      <height>16777215</height>
     </size>
    </property>
-   <layout class="QHBoxLayout" name="horizontalLayout">
+   <layout class="QVBoxLayout" name="verticalLayout">
     <item>
-     <widget class="ResultsView" name="mResults" native="true"/>
+     <widget class="ResultsView" name="mResults" native="true">
+      <property name="sizePolicy">
+       <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+        <horstretch>0</horstretch>
+        <verstretch>0</verstretch>
+       </sizepolicy>
+      </property>
+     </widget>
+    </item>
+    <item>
+     <layout class="QHBoxLayout" name="mLayoutInformation">
+      <property name="sizeConstraint">
+       <enum>QLayout::SizeConstraint::SetDefaultConstraint</enum>
+      </property>
+      <item>
+       <widget class="QLabel" name="mLabelInformation">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="maximumSize">
+         <size>
+          <width>16777215</width>
+          <height>25</height>
+         </size>
+        </property>
+        <property name="text">
+         <string>Checking for updates</string>
+        </property>
+        <property name="textFormat">
+         <enum>Qt::TextFormat::RichText</enum>
+        </property>
+        <property name="openExternalLinks">
+         <bool>true</bool>
+        </property>
+        <property name="textInteractionFlags">
+         <set>Qt::TextInteractionFlag::TextBrowserInteraction</set>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QPushButton" name="mButtonHideInformation">
+        <property name="text">
+         <string>Hide</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <spacer name="horizontalSpacer">
+        <property name="orientation">
+         <enum>Qt::Orientation::Horizontal</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>40</width>
+          <height>20</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+     </layout>
     </item>
    </layout>
   </widget>
@@ -62,7 +124,7 @@
      <x>0</x>
      <y>0</y>
      <width>640</width>
-     <height>28</height>
+     <height>21</height>
     </rect>
    </property>
    <widget class="QMenu" name="mMenuFile">
@@ -78,6 +140,7 @@
     <addaction name="separator"/>
     <addaction name="mActionProjectMRU"/>
     <addaction name="mActionSave"/>
+    <addaction name="mActionComplianceReport"/>
     <addaction name="separator"/>
     <addaction name="mActionPrintPreview"/>
     <addaction name="mActionPrint"/>
@@ -96,8 +159,22 @@
      <addaction name="mActionToolBarView"/>
      <addaction name="mActionToolBarFilter"/>
     </widget>
+    <widget class="QMenu" name="menuReport">
+     <property name="title">
+      <string>Report</string>
+     </property>
+     <addaction name="mActionReportNormal"/>
+     <addaction name="mActionReportAutosar"/>
+     <addaction name="mActionReportCertC"/>
+     <addaction name="mActionReportCertCpp"/>
+     <addaction name="mActionReportMisraC"/>
+     <addaction name="mActionReportMisraCpp2008"/>
+     <addaction name="mActionReportMisraCpp2023"/>
+    </widget>
     <addaction name="mMenuToolbars"/>
     <addaction name="separator"/>
+    <addaction name="menuReport"/>
+    <addaction name="separator"/>
     <addaction name="mActionShowErrors"/>
     <addaction name="mActionShowWarnings"/>
     <addaction name="mActionShowStyle"/>
@@ -115,6 +192,7 @@
     <addaction name="mActionShowScratchpad"/>
     <addaction name="mActionViewStats"/>
     <addaction name="mActionLibraryEditor"/>
+    <addaction name="mActionShowThreadDetails"/>
    </widget>
    <widget class="QMenu" name="mMenuHelp">
     <property name="title">
@@ -123,6 +201,7 @@
     <addaction name="mActionHelpContents"/>
     <addaction name="mActionLicense"/>
     <addaction name="mActionAuthors"/>
+    <addaction name="mActionEULA"/>
     <addaction name="separator"/>
     <addaction name="mActionAbout"/>
    </widget>
@@ -139,6 +218,8 @@
      <addaction name="mActionCpp14"/>
      <addaction name="mActionCpp17"/>
      <addaction name="mActionCpp20"/>
+     <!--addaction name="mActionCpp23"/-->
+     <!--addaction name="mActionCpp26"/-->
     </widget>
     <widget class="QMenu" name="menuC_standard">
      <property name="title">
@@ -147,6 +228,9 @@
      <addaction name="mActionC89"/>
      <addaction name="mActionC99"/>
      <addaction name="mActionC11"/>
+     <!--addaction name="mActionC17"/-->
+     <!--addaction name="mActionC23"/-->
+     <!--addaction name="mActionC2Y"/-->
     </widget>
     <addaction name="mActionAnalyzeFiles"/>
     <addaction name="mActionAnalyzeDirectory"/>
@@ -332,6 +416,9 @@
    <property name="text">
     <string>&amp;Quit</string>
    </property>
+   <property name="shortcut">
+    <string>Ctrl+Q</string>
+   </property>
   </action>
   <action name="mActionClearResults">
    <property name="icon">
@@ -458,6 +545,9 @@
    <property name="text">
     <string>Open P&amp;roject File...</string>
    </property>
+   <property name="shortcut">
+    <string>Ctrl+Shift+O</string>
+   </property>
   </action>
   <action name="mActionShowScratchpad">
    <property name="icon">
@@ -472,6 +562,9 @@
    <property name="text">
     <string>&amp;New Project File...</string>
    </property>
+   <property name="shortcut">
+    <string>Ctrl+Shift+N</string>
+   </property>
   </action>
   <action name="mActionViewLog">
    <property name="text">
@@ -721,6 +814,30 @@
     <string>C&amp;11</string>
    </property>
   </action>
+  <!--action name="mActionC17">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>C&amp;17</string>
+   </property>
+  </action-->
+  <!--action name="mActionC23">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>C&amp;23</string>
+   </property>
+  </action-->
+  <!--action name="mActionC2Y">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>C&amp;2y</string>
+   </property>
+  </action-->
   <action name="mActionC89">
    <property name="checkable">
     <bool>true</bool>
@@ -831,6 +948,107 @@
     <string>C++20</string>
    </property>
   </action>
+  <!--action name="mActionCpp23">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="checked">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>C++23</string>
+   </property>
+  </action-->
+  <!--action name="mActionCpp26">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="checked">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>C++26</string>
+   </property>
+  </action-->
+  <action name="mActionComplianceReport">
+   <property name="text">
+    <string>Compliance report...</string>
+   </property>
+  </action>
+  <action name="actionReport">
+   <property name="text">
+    <string>Report</string>
+   </property>
+  </action>
+  <action name="mActionReportNormal">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>Normal</string>
+   </property>
+  </action>
+  <action name="mActionReportMisraC">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>Misra C</string>
+   </property>
+  </action>
+  <action name="mActionReportMisraCpp2008">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>Misra C++ 2008</string>
+   </property>
+  </action>
+  <action name="mActionReportCertC">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>Cert C</string>
+   </property>
+  </action>
+  <action name="mActionReportCertCpp">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>Cert C++</string>
+   </property>
+  </action>
+  <action name="mActionReportMisraCpp2023">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>Misra C++ 2023</string>
+   </property>
+  </action>
+  <action name="mActionReportAutosar">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>Autosar</string>
+   </property>
+  </action>
+  <action name="mActionEULA">
+   <property name="text">
+    <string>EULA...</string>
+   </property>
+  </action>
+  <action name="mActionShowThreadDetails">
+   <property name="text">
+    <string>Thread Details</string>
+   </property>
+   <property name="toolTip">
+    <string>Show thread details</string>
+   </property>
+  </action>
  </widget>
  <customwidgets>
   <customwidget>
diff --git a/gui/manualtest/mainwindow.md b/gui/manualtest/mainwindow.md
new file mode 100644
index 00000000000..563a538530f
--- /dev/null
+++ b/gui/manualtest/mainwindow.md
@@ -0,0 +1,21 @@
+
+# Main window
+
+Some manual testing in the main window interface
+
+
+## Test: Recheck file
+
+1. Load a project with results.
+1. Restart the GUI.
+1. Right click on a file and click on "Recheck".
+
+EXPECTED: Results for that file should be refreshed.
+
+
+## Test: Switch project
+
+1. Open project #1
+1. Open project #2 that has different results
+
+EXPECTED: Results for project #1 should go away, results for project #2 should be shown
diff --git a/gui/manualtest/projectfiledialog.md b/gui/manualtest/projectfiledialog.md
new file mode 100644
index 00000000000..eb76109e53e
--- /dev/null
+++ b/gui/manualtest/projectfiledialog.md
@@ -0,0 +1,31 @@
+
+# Project file dialog
+
+Some manual testing in the project file dialog interface
+
+
+
+## Test: Platform files
+
+Ticket: #14489
+
+EXPECTED: In the project file dialog it should be possible to select xml files i.e. pic8.xml
+
+TODO: can this test be automated
+
+
+
+## Test: Misra C checkbox
+
+Ticket: #14488
+
+Matrix: Use both open source and premium
+
+1. Load project file in trac ticket 14488
+1. Goto "Edit project"
+1. Goto "Addons" tab
+
+EXPECTED: The misra c checkbox should be checked
+
+TODO: can this test be automated
+
diff --git a/gui/newsuppressiondialog.cpp b/gui/newsuppressiondialog.cpp
index 9009a28cace..e93312681b1 100644
--- a/gui/newsuppressiondialog.cpp
+++ b/gui/newsuppressiondialog.cpp
@@ -1,9 +1,38 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #include "newsuppressiondialog.h"
-#include "ui_newsuppressiondialog.h"
+
 #include "cppcheck.h"
 #include "errorlogger.h"
 #include "suppressions.h"
 
+#include "ui_newsuppressiondialog.h"
+
+#include <string>
+
+#include <QComboBox>
+#include <QLineEdit>
+#include <QString>
+#include <QStringList>
+
+class QWidget;
+
 NewSuppressionDialog::NewSuppressionDialog(QWidget *parent) :
     QDialog(parent),
     mUI(new Ui::NewSuppressionDialog)
@@ -12,16 +41,18 @@ NewSuppressionDialog::NewSuppressionDialog(QWidget *parent) :
 
     class QErrorLogger : public ErrorLogger {
     public:
-        virtual void reportOut(const std::string &/*outmsg*/) {}
-        virtual void reportErr(const ErrorLogger::ErrorMessage &msg) {
+        void reportOut(const std::string & /*outmsg*/, Color /*c*/) override {}
+        void reportErr(const ErrorMessage &msg) override {
             errorIds << QString::fromStdString(msg.id);
         }
+        void reportMetric(const std::string &metric) override {
+            (void) metric;
+        }
         QStringList errorIds;
     };
 
     QErrorLogger errorLogger;
-    CppCheck cppcheck(errorLogger,false);
-    cppcheck.getErrorMessages();
+    CppCheck::getErrorMessages(errorLogger);
     errorLogger.errorIds.sort();
 
     mUI->mComboErrorId->addItems(errorLogger.errorIds);
@@ -34,9 +65,9 @@ NewSuppressionDialog::~NewSuppressionDialog()
     delete mUI;
 }
 
-Suppressions::Suppression NewSuppressionDialog::getSuppression() const
+SuppressionList::Suppression NewSuppressionDialog::getSuppression() const
 {
-    Suppressions::Suppression ret;
+    SuppressionList::Suppression ret;
     ret.errorId = mUI->mComboErrorId->currentText().toStdString();
     if (ret.errorId.empty())
         ret.errorId = "*";
@@ -47,7 +78,7 @@ Suppressions::Suppression NewSuppressionDialog::getSuppression() const
     return ret;
 }
 
-void NewSuppressionDialog::setSuppression(const Suppressions::Suppression &suppression)
+void NewSuppressionDialog::setSuppression(const SuppressionList::Suppression &suppression)
 {
     setWindowTitle(tr("Edit suppression"));
     mUI->mComboErrorId->setCurrentText(QString::fromStdString(suppression.errorId));
diff --git a/gui/newsuppressiondialog.h b/gui/newsuppressiondialog.h
index 442a28c6c39..a0e637ddfec 100644
--- a/gui/newsuppressiondialog.h
+++ b/gui/newsuppressiondialog.h
@@ -1,9 +1,30 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #ifndef NEWSUPPRESSIONDIALOG_H
 #define NEWSUPPRESSIONDIALOG_H
 
-#include <QDialog>
 #include "suppressions.h"
 
+#include <QDialog>
+#include <QObject>
+
+class QWidget;
 namespace Ui {
     class NewSuppressionDialog;
 }
@@ -14,21 +35,21 @@ class NewSuppressionDialog : public QDialog {
 public:
     explicit NewSuppressionDialog(QWidget *parent = nullptr);
     NewSuppressionDialog(const NewSuppressionDialog &) = delete;
-    ~NewSuppressionDialog();
+    ~NewSuppressionDialog() override;
     NewSuppressionDialog &operator=(const NewSuppressionDialog &) = delete;
 
     /**
      * @brief Translate the user input in the GUI into a suppression
      * @return Cppcheck suppression
      */
-    Suppressions::Suppression getSuppression() const;
+    SuppressionList::Suppression getSuppression() const;
 
     /**
      * @brief Update the GUI so it corresponds with the given
      * Cppcheck suppression
      * @param suppression Cppcheck suppression
      */
-    void setSuppression(const Suppressions::Suppression &suppression);
+    void setSuppression(const SuppressionList::Suppression &suppression);
 
 private:
     Ui::NewSuppressionDialog *mUI;
diff --git a/gui/platforms.cpp b/gui/platforms.cpp
index ff9c075abce..77683a6ea09 100644
--- a/gui/platforms.cpp
+++ b/gui/platforms.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2016 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,22 +24,23 @@ Platforms::Platforms(QObject *parent)
     init();
 }
 
-void Platforms::add(const QString &title, Settings::PlatformType platform)
+void Platforms::add(const QString &title, Platform::Type platform)
 {
-    Platform plat;
+    PlatformData plat;
     plat.mTitle = title;
     plat.mType = platform;
+    plat.mActMainWindow = nullptr;
     mPlatforms << plat;
 }
 
 void Platforms::init()
 {
-    add(tr("Native"), Settings::Native);
-    add(tr("Unix 32-bit"), Settings::Unix32);
-    add(tr("Unix 64-bit"), Settings::Unix64);
-    add(tr("Windows 32-bit ANSI"), Settings::Win32A);
-    add(tr("Windows 32-bit Unicode"), Settings::Win32W);
-    add(tr("Windows 64-bit"), Settings::Win64);
+    add(tr("Native"), Platform::Type::Native);
+    add(tr("Unix 32-bit"), Platform::Type::Unix32);
+    add(tr("Unix 64-bit"), Platform::Type::Unix64);
+    add(tr("Windows 32-bit ANSI"), Platform::Type::Win32A);
+    add(tr("Windows 32-bit Unicode"), Platform::Type::Win32W);
+    add(tr("Windows 64-bit"), Platform::Type::Win64);
 }
 
 int Platforms::getCount() const
@@ -47,11 +48,11 @@ int Platforms::getCount() const
     return mPlatforms.count();
 }
 
-Platform& Platforms::get(Settings::PlatformType platform)
+PlatformData& Platforms::get(Platform::Type platform)
 {
-    QList<Platform>::iterator iter = mPlatforms.begin();
+    auto iter = mPlatforms.begin();
     while (iter != mPlatforms.end()) {
-        if ((*iter).mType == platform) {
+        if (iter->mType == platform) {
             return *iter;
         }
         ++iter;
diff --git a/gui/platforms.h b/gui/platforms.h
index 7d5eac38c4b..ec18eccf5ee 100644
--- a/gui/platforms.h
+++ b/gui/platforms.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,11 +19,13 @@
 #ifndef PLATFORMS_H
 #define PLATFORMS_H
 
+#include "platform.h"
+
+#include <QList>
 #include <QObject>
 #include <QString>
-#include <QList>
-#include <QAction>
-#include "settings.h"
+
+class QAction;
 
 /// @addtogroup GUI
 /// @{
@@ -31,26 +33,26 @@
 /**
  * @brief Checked platform GUI-data.
  */
-struct Platform {
+struct PlatformData {
     QString mTitle;  /**< Text visible in the GUI. */
-    Settings::PlatformType mType; /**< Type in the core. */
+    Platform::Type mType; /**< Type in the core. */
     QAction *mActMainWindow; /**< Pointer to main window action item. */
 };
 
 /**
-  * @brief List of checked platforms.
-  */
+ * @brief List of checked platforms.
+ */
 class Platforms : public QObject {
     Q_OBJECT
 
 public:
     explicit Platforms(QObject *parent = nullptr);
-    void add(const QString &title, Settings::PlatformType platform);
+    void add(const QString &title, Platform::Type platform);
     int getCount() const;
     void init();
-    Platform& get(Settings::PlatformType platform);
+    PlatformData& get(Platform::Type platform);
 
-    QList<Platform> mPlatforms;
+    QList<PlatformData> mPlatforms;
 };
 
 /// @}
diff --git a/gui/precompiled.h b/gui/precompiled.h
new file mode 100644
index 00000000000..e22e5442dc2
--- /dev/null
+++ b/gui/precompiled.h
@@ -0,0 +1,33 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+// IWYU pragma: begin_keep
+#include "checkthread.h"
+#include "codeeditor.h"
+#include "codeeditorstyle.h"
+#include "config.h"
+#include "cppcheck.h"
+#include "cppchecklibrarydata.h"
+#include "report.h"
+#include "showtypes.h"
+
+#include <QFile>
+#include <QVariant>
+// IWYU pragma: end_keep
diff --git a/gui/precompiled_qmake.h b/gui/precompiled_qmake.h
new file mode 100644
index 00000000000..dc41edce776
--- /dev/null
+++ b/gui/precompiled_qmake.h
@@ -0,0 +1,23 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+#include "precompiled.h"
+#include <QDialog>
+#include <QObject>
+#include <QWidget>
diff --git a/gui/printablereport.cpp b/gui/printablereport.cpp
index 17ec50f34f8..f6b9808bc55 100644
--- a/gui/printablereport.cpp
+++ b/gui/printablereport.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2017 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,16 +17,15 @@
  */
 
 #include "printablereport.h"
+
+#include "erroritem.h"
+
 #include <QDir>
+#include <QList>
 
 PrintableReport::PrintableReport() :
     Report(QString())
-{
-}
-
-PrintableReport::~PrintableReport()
-{
-}
+{}
 
 bool PrintableReport::create()
 {
@@ -53,7 +52,7 @@ void PrintableReport::writeError(const ErrorItem &error)
     mFormattedReport += "\n";
 }
 
-QString PrintableReport::getFormattedReportText() const
+const QString& PrintableReport::getFormattedReportText() const
 {
     return mFormattedReport;
 }
diff --git a/gui/printablereport.h b/gui/printablereport.h
index a5f9b93697a..7019c287176 100644
--- a/gui/printablereport.h
+++ b/gui/printablereport.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,51 +21,52 @@
 
 #include "report.h"
 
+#include <QString>
+
 /// @addtogroup GUI
 /// @{
 
 
 /**
-* @brief Printable (in-memory) report.
-* This report formats results and exposes them for printing.
-*/
+ * @brief Printable (in-memory) report.
+ * This report formats results and exposes them for printing.
+ */
 class PrintableReport : public Report {
 public:
     PrintableReport();
-    virtual ~PrintableReport();
 
     /**
-    * @brief Create the report (file).
-    * @return true if succeeded, false if file could not be created.
-    */
-    virtual bool create() override;
+     * @brief Create the report (file).
+     * @return true if succeeded, false if file could not be created.
+     */
+    bool create() override;
 
     /**
-    * @brief Write report header.
-    */
-    virtual void writeHeader() override;
+     * @brief Write report header.
+     */
+    void writeHeader() override;
 
     /**
-    * @brief Write report footer.
-    */
-    virtual void writeFooter() override;
+     * @brief Write report footer.
+     */
+    void writeFooter() override;
 
     /**
-    * @brief Write error to report.
-    * @param error Error data.
-    */
-    virtual void writeError(const ErrorItem &error) override;
+     * @brief Write error to report.
+     * @param error Error data.
+     */
+    void writeError(const ErrorItem &error) override;
 
     /**
-    * @brief Returns the formatted report.
-    */
-    QString getFormattedReportText() const;
+     * @brief Returns the formatted report.
+     */
+    const QString& getFormattedReportText() const;
 
 private:
 
     /**
-    * @brief Stores the formatted report contents.
-    */
+     * @brief Stores the formatted report contents.
+     */
     QString mFormattedReport;
 };
 /// @}
diff --git a/gui/projectfile.cpp b/gui/projectfile.cpp
index aad1a3d79c1..b807723ceeb 100644
--- a/gui/projectfile.cpp
+++ b/gui/projectfile.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,18 +16,27 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QObject>
-#include <QString>
-#include <QXmlStreamReader>
-#include <QXmlStreamWriter>
-#include <QFile>
-#include <QDir>
 #include "projectfile.h"
+
 #include "common.h"
+#include "config.h"
 #include "importproject.h"
-
-#include "path.h"
 #include "settings.h"
+#include "utils.h"
+
+#include <utility>
+
+#include <QCoreApplication>
+#include <QFile>
+#include <QDir>
+#include <QIODevice>
+#include <QLatin1String>
+#include <QRegularExpression>
+#include <QXmlStreamAttributes>
+#include <QXmlStreamReader>
+#include <QXmlStreamWriter>
+
+ProjectFile *ProjectFile::mActiveProject;
 
 ProjectFile::ProjectFile(QObject *parent) :
     QObject(parent)
@@ -35,9 +44,9 @@ ProjectFile::ProjectFile(QObject *parent) :
     clear();
 }
 
-ProjectFile::ProjectFile(const QString &filename, QObject *parent) :
+ProjectFile::ProjectFile(QString filename, QObject *parent) :
     QObject(parent),
-    mFilename(filename)
+    mFilename(std::move(filename))
 {
     clear();
     read();
@@ -45,10 +54,12 @@ ProjectFile::ProjectFile(const QString &filename, QObject *parent) :
 
 void ProjectFile::clear()
 {
+    const Settings settings;
+    clangParser = false;
+    mCheckLevel = CheckLevel::normal;
     mRootPath.clear();
     mBuildDir.clear();
     mImportProject.clear();
-    mAnalyzeAllVsConfigs = true;
     mIncludeDirs.clear();
     mDefines.clear();
     mUndefines.clear();
@@ -56,15 +67,27 @@ void ProjectFile::clear()
     mExcludedPaths.clear();
     mLibraries.clear();
     mPlatform.clear();
+    mProjectName.clear();
     mSuppressions.clear();
     mAddons.clear();
     mClangAnalyzer = mClangTidy = false;
-    mAnalyzeAllVsConfigs = false;
+    mAnalyzeAllVsConfigs = false; // TODO: defaults to true if loading a GUI project via CLI
     mCheckHeaders = true;
-    mCheckUnusedTemplates = false;
-    mMaxCtuDepth = 10;
+    mCheckUnusedTemplates = true;
+    mInlineSuppression = true;
+    mMaxCtuDepth = settings.maxCtuDepth;
+    mMaxTemplateRecursion = settings.maxTemplateRecursion;
     mCheckUnknownFunctionReturn.clear();
-    mSafeChecks.clear();
+    safeChecks.clear();
+    mVsConfigurations.clear();
+    mTags.clear();
+    mWarningTags.clear();
+
+    // Premium
+    mBughunting = false;
+    mCertIntPrecision = 0;
+    mCodingStandards.clear();
+    mPremiumLicenseFile.clear();
 }
 
 bool ProjectFile::read(const QString &filename)
@@ -84,7 +107,7 @@ bool ProjectFile::read(const QString &filename)
     while (!xmlReader.atEnd()) {
         switch (xmlReader.readNext()) {
         case QXmlStreamReader::StartElement:
-            if (xmlReader.name() == CppcheckXml::ProjectElementName) {
+            if (xmlReader.name() == QString(CppcheckXml::ProjectElementName)) {
                 insideProject = true;
                 projectTagFound = true;
                 break;
@@ -93,91 +116,128 @@ bool ProjectFile::read(const QString &filename)
                 break;
 
             // Read root path from inside project element
-            if (xmlReader.name() == CppcheckXml::RootPathName)
+            if (xmlReader.name() == QString(CppcheckXml::RootPathName))
                 readRootPath(xmlReader);
 
             // Read root path from inside project element
-            if (xmlReader.name() == CppcheckXml::BuildDirElementName)
+            if (xmlReader.name() == QString(CppcheckXml::BuildDirElementName))
                 readBuildDir(xmlReader);
 
             // Find paths to check from inside project element
-            if (xmlReader.name() == CppcheckXml::PathsElementName)
+            if (xmlReader.name() == QString(CppcheckXml::PathsElementName))
                 readCheckPaths(xmlReader);
 
-            if (xmlReader.name() == CppcheckXml::ImportProjectElementName)
+            if (xmlReader.name() == QString(CppcheckXml::ImportProjectElementName))
                 readImportProject(xmlReader);
 
-            if (xmlReader.name() == CppcheckXml::AnalyzeAllVsConfigsElementName)
+            if (xmlReader.name() == QString(CppcheckXml::AnalyzeAllVsConfigsElementName))
                 mAnalyzeAllVsConfigs = readBool(xmlReader);
 
-            if (xmlReader.name() == CppcheckXml::CheckHeadersElementName)
+            if (xmlReader.name() == QString(CppcheckXml::Parser))
+                clangParser = true;
+
+            if (xmlReader.name() == QString(CppcheckXml::CheckHeadersElementName))
                 mCheckHeaders = readBool(xmlReader);
 
-            if (xmlReader.name() == CppcheckXml::CheckUnusedTemplatesElementName)
+            if (xmlReader.name() == QString(CppcheckXml::CheckUnusedTemplatesElementName))
                 mCheckUnusedTemplates = readBool(xmlReader);
 
+            if (xmlReader.name() == QString(CppcheckXml::InlineSuppression))
+                mInlineSuppression = readBool(xmlReader);
+
+            if (xmlReader.name() == QString(CppcheckXml::CheckLevelExhaustiveElementName))
+                mCheckLevel = CheckLevel::exhaustive;
+
+            if (xmlReader.name() == QString(CppcheckXml::CheckLevelNormalElementName))
+                mCheckLevel = CheckLevel::normal;
+
+            if (xmlReader.name() == QString(CppcheckXml::CheckLevelReducedElementName))
+                mCheckLevel = CheckLevel::reduced;
+
             // Find include directory from inside project element
-            if (xmlReader.name() == CppcheckXml::IncludeDirElementName)
+            if (xmlReader.name() == QString(CppcheckXml::IncludeDirElementName))
                 readIncludeDirs(xmlReader);
 
             // Find preprocessor define from inside project element
-            if (xmlReader.name() == CppcheckXml::DefinesElementName)
+            if (xmlReader.name() == QString(CppcheckXml::DefinesElementName))
                 readDefines(xmlReader);
 
             // Find preprocessor define from inside project element
-            if (xmlReader.name() == CppcheckXml::UndefinesElementName)
+            if (xmlReader.name() == QString(CppcheckXml::UndefinesElementName))
                 readStringList(mUndefines, xmlReader, CppcheckXml::UndefineName);
 
             // Find exclude list from inside project element
-            if (xmlReader.name() == CppcheckXml::ExcludeElementName)
+            if (xmlReader.name() == QString(CppcheckXml::ExcludeElementName))
                 readExcludes(xmlReader);
 
             // Find ignore list from inside project element
             // These are read for compatibility
-            if (xmlReader.name() == CppcheckXml::IgnoreElementName)
+            if (xmlReader.name() == QString(CppcheckXml::IgnoreElementName))
                 readExcludes(xmlReader);
 
             // Find libraries list from inside project element
-            if (xmlReader.name() == CppcheckXml::LibrariesElementName)
+            if (xmlReader.name() == QString(CppcheckXml::LibrariesElementName))
                 readStringList(mLibraries, xmlReader, CppcheckXml::LibraryElementName);
 
-            if (xmlReader.name() == CppcheckXml::PlatformElementName)
+            if (xmlReader.name() == QString(CppcheckXml::PlatformElementName))
                 readPlatform(xmlReader);
 
             // Find suppressions list from inside project element
-            if (xmlReader.name() == CppcheckXml::SuppressionsElementName)
+            if (xmlReader.name() == QString(CppcheckXml::SuppressionsElementName))
                 readSuppressions(xmlReader);
 
             // Unknown function return values
-            if (xmlReader.name() == CppcheckXml::CheckUnknownFunctionReturn)
+            if (xmlReader.name() == QString(CppcheckXml::CheckUnknownFunctionReturn))
                 readStringList(mCheckUnknownFunctionReturn, xmlReader, CppcheckXml::Name);
 
             // check all function parameter values
-            if (xmlReader.name() == Settings::SafeChecks::XmlRootName)
-                mSafeChecks.loadFromXml(xmlReader);
+            if (xmlReader.name() == QString(Settings::SafeChecks::XmlRootName))
+                safeChecks.loadFromXml(xmlReader);
 
             // Addons
-            if (xmlReader.name() == CppcheckXml::AddonsElementName)
+            if (xmlReader.name() == QString(CppcheckXml::AddonsElementName))
                 readStringList(mAddons, xmlReader, CppcheckXml::AddonElementName);
 
             // Tools
-            if (xmlReader.name() == CppcheckXml::ToolsElementName) {
+            if (xmlReader.name() == QString(CppcheckXml::ToolsElementName)) {
                 QStringList tools;
                 readStringList(tools, xmlReader, CppcheckXml::ToolElementName);
                 mClangAnalyzer = tools.contains(CLANG_ANALYZER);
                 mClangTidy = tools.contains(CLANG_TIDY);
             }
 
-            if (xmlReader.name() == CppcheckXml::TagsElementName)
+            if (xmlReader.name() == QString(CppcheckXml::TagsElementName))
                 readStringList(mTags, xmlReader, CppcheckXml::TagElementName);
 
-            if (xmlReader.name() == CppcheckXml::MaxCtuDepthElementName)
+            if (xmlReader.name() == QString(CppcheckXml::TagWarningsElementName))
+                readTagWarnings(xmlReader, xmlReader.attributes().value(QString(), CppcheckXml::TagAttributeName).toString());
+
+            if (xmlReader.name() == QString(CppcheckXml::MaxCtuDepthElementName))
                 mMaxCtuDepth = readInt(xmlReader, mMaxCtuDepth);
 
+            if (xmlReader.name() == QString(CppcheckXml::MaxTemplateRecursionElementName))
+                mMaxTemplateRecursion = readInt(xmlReader, mMaxTemplateRecursion);
+
+            // VSConfiguration
+            if (xmlReader.name() == QString(CppcheckXml::VSConfigurationElementName))
+                readVsConfigurations(xmlReader);
+
+            // Cppcheck Premium
+            if (xmlReader.name() == QString(CppcheckXml::BughuntingElementName))
+                mBughunting = true;
+            if (xmlReader.name() == QString(CppcheckXml::CodingStandardsElementName))
+                readStringList(mCodingStandards, xmlReader, CppcheckXml::CodingStandardElementName);
+            if (xmlReader.name() == QString(CppcheckXml::CertIntPrecisionElementName))
+                mCertIntPrecision = readInt(xmlReader, 0);
+            if (xmlReader.name() == QString(CppcheckXml::LicenseFileElementName))
+                mPremiumLicenseFile = readString(xmlReader);
+            if (xmlReader.name() == QString(CppcheckXml::ProjectNameElementName))
+                mProjectName = readString(xmlReader);
+
             break;
 
         case QXmlStreamReader::EndElement:
-            if (xmlReader.name() == CppcheckXml::ProjectElementName)
+            if (xmlReader.name() == QString(CppcheckXml::ProjectElementName))
                 insideProject = false;
             break;
 
@@ -199,7 +259,7 @@ bool ProjectFile::read(const QString &filename)
     return projectTagFound;
 }
 
-void ProjectFile::readRootPath(QXmlStreamReader &reader)
+void ProjectFile::readRootPath(const QXmlStreamReader &reader)
 {
     QXmlStreamAttributes attribs = reader.attributes();
     QString name = attribs.value(QString(), CppcheckXml::RootPathNameAttrib).toString();
@@ -215,6 +275,7 @@ void ProjectFile::readBuildDir(QXmlStreamReader &reader)
         switch (type) {
         case QXmlStreamReader::Characters:
             mBuildDir = reader.text().toString();
+            FALLTHROUGH;
         case QXmlStreamReader::EndElement:
             return;
         // Not handled
@@ -229,7 +290,7 @@ void ProjectFile::readBuildDir(QXmlStreamReader &reader)
         case QXmlStreamReader::ProcessingInstruction:
             break;
         }
-    } while (1);
+    } while (true);
 }
 
 void ProjectFile::readImportProject(QXmlStreamReader &reader)
@@ -240,6 +301,7 @@ void ProjectFile::readImportProject(QXmlStreamReader &reader)
         switch (type) {
         case QXmlStreamReader::Characters:
             mImportProject = reader.text().toString();
+            FALLTHROUGH;
         case QXmlStreamReader::EndElement:
             return;
         // Not handled
@@ -254,7 +316,7 @@ void ProjectFile::readImportProject(QXmlStreamReader &reader)
         case QXmlStreamReader::ProcessingInstruction:
             break;
         }
-    } while (1);
+    } while (true);
 }
 
 bool ProjectFile::readBool(QXmlStreamReader &reader)
@@ -265,6 +327,7 @@ bool ProjectFile::readBool(QXmlStreamReader &reader)
         switch (type) {
         case QXmlStreamReader::Characters:
             ret = (reader.text().toString() == "true");
+            FALLTHROUGH;
         case QXmlStreamReader::EndElement:
             return ret;
         // Not handled
@@ -279,7 +342,7 @@ bool ProjectFile::readBool(QXmlStreamReader &reader)
         case QXmlStreamReader::ProcessingInstruction:
             break;
         }
-    } while (1);
+    } while (true);
 }
 
 int ProjectFile::readInt(QXmlStreamReader &reader, int defaultValue)
@@ -290,6 +353,33 @@ int ProjectFile::readInt(QXmlStreamReader &reader, int defaultValue)
         switch (type) {
         case QXmlStreamReader::Characters:
             ret = reader.text().toString().toInt();
+            FALLTHROUGH;
+        case QXmlStreamReader::EndElement:
+            return ret;
+        // Not handled
+        case QXmlStreamReader::StartElement:
+        case QXmlStreamReader::NoToken:
+        case QXmlStreamReader::Invalid:
+        case QXmlStreamReader::StartDocument:
+        case QXmlStreamReader::EndDocument:
+        case QXmlStreamReader::Comment:
+        case QXmlStreamReader::DTD:
+        case QXmlStreamReader::EntityReference:
+        case QXmlStreamReader::ProcessingInstruction:
+            break;
+        }
+    } while (true);
+}
+
+QString ProjectFile::readString(QXmlStreamReader &reader)
+{
+    QString ret;
+    do {
+        const QXmlStreamReader::TokenType type = reader.readNext();
+        switch (type) {
+        case QXmlStreamReader::Characters:
+            ret = reader.text().toString();
+            FALLTHROUGH;
         case QXmlStreamReader::EndElement:
             return ret;
         // Not handled
@@ -304,15 +394,14 @@ int ProjectFile::readInt(QXmlStreamReader &reader, int defaultValue)
         case QXmlStreamReader::ProcessingInstruction:
             break;
         }
-    } while (1);
+    } while (true);
 }
 
 void ProjectFile::readIncludeDirs(QXmlStreamReader &reader)
 {
-    QXmlStreamReader::TokenType type;
     bool allRead = false;
     do {
-        type = reader.readNext();
+        QXmlStreamReader::TokenType type = reader.readNext();
         switch (type) {
         case QXmlStreamReader::StartElement:
 
@@ -347,10 +436,9 @@ void ProjectFile::readIncludeDirs(QXmlStreamReader &reader)
 
 void ProjectFile::readDefines(QXmlStreamReader &reader)
 {
-    QXmlStreamReader::TokenType type;
     bool allRead = false;
     do {
-        type = reader.readNext();
+        QXmlStreamReader::TokenType type = reader.readNext();
         switch (type) {
         case QXmlStreamReader::StartElement:
             // Read define-elements
@@ -384,10 +472,9 @@ void ProjectFile::readDefines(QXmlStreamReader &reader)
 
 void ProjectFile::readCheckPaths(QXmlStreamReader &reader)
 {
-    QXmlStreamReader::TokenType type;
     bool allRead = false;
     do {
-        type = reader.readNext();
+        QXmlStreamReader::TokenType type = reader.readNext();
         switch (type) {
         case QXmlStreamReader::StartElement:
 
@@ -422,10 +509,9 @@ void ProjectFile::readCheckPaths(QXmlStreamReader &reader)
 
 void ProjectFile::readExcludes(QXmlStreamReader &reader)
 {
-    QXmlStreamReader::TokenType type;
     bool allRead = false;
     do {
-        type = reader.readNext();
+        QXmlStreamReader::TokenType type = reader.readNext();
         switch (type) {
         case QXmlStreamReader::StartElement:
             // Read exclude-elements
@@ -466,6 +552,43 @@ void ProjectFile::readExcludes(QXmlStreamReader &reader)
     } while (!allRead);
 }
 
+void ProjectFile::readVsConfigurations(QXmlStreamReader &reader)
+{
+    do {
+        QXmlStreamReader::TokenType type = reader.readNext();
+        switch (type) {
+        case QXmlStreamReader::StartElement:
+            // Read library-elements
+            if (reader.name().toString() == CppcheckXml::VSConfigurationName) {
+                QString config;
+                type = reader.readNext();
+                if (type == QXmlStreamReader::Characters) {
+                    config = reader.text().toString();
+                }
+                mVsConfigurations << config;
+            }
+            break;
+
+        case QXmlStreamReader::EndElement:
+            if (reader.name().toString() != CppcheckXml::VSConfigurationName)
+                return;
+            break;
+
+        // Not handled
+        case QXmlStreamReader::NoToken:
+        case QXmlStreamReader::Invalid:
+        case QXmlStreamReader::StartDocument:
+        case QXmlStreamReader::EndDocument:
+        case QXmlStreamReader::Characters:
+        case QXmlStreamReader::Comment:
+        case QXmlStreamReader::DTD:
+        case QXmlStreamReader::EntityReference:
+        case QXmlStreamReader::ProcessingInstruction:
+            break;
+        }
+    } while (true);
+}
+
 void ProjectFile::readPlatform(QXmlStreamReader &reader)
 {
     do {
@@ -473,6 +596,7 @@ void ProjectFile::readPlatform(QXmlStreamReader &reader)
         switch (type) {
         case QXmlStreamReader::Characters:
             mPlatform = reader.text().toString();
+            FALLTHROUGH;
         case QXmlStreamReader::EndElement:
             return;
         // Not handled
@@ -487,26 +611,27 @@ void ProjectFile::readPlatform(QXmlStreamReader &reader)
         case QXmlStreamReader::ProcessingInstruction:
             break;
         }
-    } while (1);
+    } while (true);
 }
 
 
 void ProjectFile::readSuppressions(QXmlStreamReader &reader)
 {
-    QXmlStreamReader::TokenType type;
     do {
-        type = reader.readNext();
+        QXmlStreamReader::TokenType type = reader.readNext();
         switch (type) {
         case QXmlStreamReader::StartElement:
             // Read library-elements
             if (reader.name().toString() == CppcheckXml::SuppressionElementName) {
-                Suppressions::Suppression suppression;
+                SuppressionList::Suppression suppression;
                 if (reader.attributes().hasAttribute(QString(),"fileName"))
                     suppression.fileName = reader.attributes().value(QString(),"fileName").toString().toStdString();
                 if (reader.attributes().hasAttribute(QString(),"lineNumber"))
                     suppression.lineNumber = reader.attributes().value(QString(),"lineNumber").toInt();
                 if (reader.attributes().hasAttribute(QString(),"symbolName"))
                     suppression.symbolName = reader.attributes().value(QString(),"symbolName").toString().toStdString();
+                if (reader.attributes().hasAttribute(QString(),"hash"))
+                    suppression.hash = reader.attributes().value(QString(),"hash").toULongLong();
                 type = reader.readNext();
                 if (type == QXmlStreamReader::Characters) {
                     suppression.errorId = reader.text().toString().toStdString();
@@ -536,12 +661,45 @@ void ProjectFile::readSuppressions(QXmlStreamReader &reader)
 }
 
 
+void ProjectFile::readTagWarnings(QXmlStreamReader &reader, const QString &tag)
+{
+    do {
+        QXmlStreamReader::TokenType type = reader.readNext();
+        switch (type) {
+        case QXmlStreamReader::StartElement:
+            // Read library-elements
+            if (reader.name().toString() == CppcheckXml::WarningElementName) {
+                const std::size_t hash = reader.attributes().value(QString(), CppcheckXml::HashAttributeName).toULongLong();
+                mWarningTags[hash] = tag;
+            }
+            break;
+
+        case QXmlStreamReader::EndElement:
+            if (reader.name().toString() != CppcheckXml::WarningElementName)
+                return;
+            break;
+
+        // Not handled
+        case QXmlStreamReader::NoToken:
+        case QXmlStreamReader::Invalid:
+        case QXmlStreamReader::StartDocument:
+        case QXmlStreamReader::EndDocument:
+        case QXmlStreamReader::Characters:
+        case QXmlStreamReader::Comment:
+        case QXmlStreamReader::DTD:
+        case QXmlStreamReader::EntityReference:
+        case QXmlStreamReader::ProcessingInstruction:
+            break;
+        }
+    } while (true);
+}
+
+
 void ProjectFile::readStringList(QStringList &stringlist, QXmlStreamReader &reader, const char elementname[])
 {
-    QXmlStreamReader::TokenType type;
     bool allRead = false;
     do {
-        type = reader.readNext();
+        QXmlStreamReader::TokenType type = reader.readNext();
         switch (type) {
         case QXmlStreamReader::StartElement:
             // Read library-elements
@@ -609,16 +767,60 @@ void ProjectFile::setPlatform(const QString &platform)
     mPlatform = platform;
 }
 
-void ProjectFile::setSuppressions(const QList<Suppressions::Suppression> &suppressions)
+QList<SuppressionList::Suppression> ProjectFile::getCheckingSuppressions() const
+{
+    const QRegularExpression re1("^[a-zA-Z0-9_\\-]+/.*");
+    const QRegularExpression re2("^[^/]+$");
+    QList<SuppressionList::Suppression> result;
+    for (SuppressionList::Suppression suppression : mSuppressions) {
+        if (re1.match(suppression.fileName.c_str()).hasMatch() || re2.match(suppression.fileName.c_str()).hasMatch()) {
+            if (suppression.fileName[0] != '*')
+                suppression.fileName = QFileInfo(mFilename).absolutePath().toStdString() + "/" + suppression.fileName;
+        }
+        result << suppression;
+    }
+    return result;
+}
+
+void ProjectFile::setSuppressions(const QList<SuppressionList::Suppression> &suppressions)
 {
     mSuppressions = suppressions;
 }
 
+void ProjectFile::addSuppression(const SuppressionList::Suppression &suppression)
+{
+    mSuppressions.append(suppression);
+}
+
 void ProjectFile::setAddons(const QStringList &addons)
 {
     mAddons = addons;
 }
 
+void ProjectFile::setVSConfigurations(const QStringList &vsConfigs)
+{
+    mVsConfigurations = vsConfigs;
+}
+
+void ProjectFile::setCheckLevel(ProjectFile::CheckLevel checkLevel)
+{
+    mCheckLevel = checkLevel;
+}
+
+void ProjectFile::setWarningTags(std::size_t hash, const QString& tags)
+{
+    if (tags.isEmpty())
+        mWarningTags.erase(hash);
+    else if (hash > 0)
+        mWarningTags[hash] = tags;
+}
+
+QString ProjectFile::getWarningTags(std::size_t hash) const
+{
+    auto it = mWarningTags.find(hash);
+    return (it != mWarningTags.end()) ? it->second : QString();
+}
+
 bool ProjectFile::write(const QString &filename)
 {
     if (!filename.isEmpty())
@@ -659,24 +861,38 @@ bool ProjectFile::write(const QString &filename)
     }
 
     xmlWriter.writeStartElement(CppcheckXml::AnalyzeAllVsConfigsElementName);
-    xmlWriter.writeCharacters(mAnalyzeAllVsConfigs ? "true" : "false");
+    xmlWriter.writeCharacters(bool_to_string(mAnalyzeAllVsConfigs));
     xmlWriter.writeEndElement();
 
+    if (clangParser) {
+        xmlWriter.writeStartElement(CppcheckXml::Parser);
+        xmlWriter.writeCharacters("clang");
+        xmlWriter.writeEndElement();
+    }
+
     xmlWriter.writeStartElement(CppcheckXml::CheckHeadersElementName);
-    xmlWriter.writeCharacters(mCheckHeaders ? "true" : "false");
+    xmlWriter.writeCharacters(bool_to_string(mCheckHeaders));
     xmlWriter.writeEndElement();
 
     xmlWriter.writeStartElement(CppcheckXml::CheckUnusedTemplatesElementName);
-    xmlWriter.writeCharacters(mCheckUnusedTemplates ? "true" : "false");
+    xmlWriter.writeCharacters(bool_to_string(mCheckUnusedTemplates));
+    xmlWriter.writeEndElement();
+
+    xmlWriter.writeStartElement(CppcheckXml::InlineSuppression);
+    xmlWriter.writeCharacters(bool_to_string(mInlineSuppression));
     xmlWriter.writeEndElement();
 
     xmlWriter.writeStartElement(CppcheckXml::MaxCtuDepthElementName);
     xmlWriter.writeCharacters(QString::number(mMaxCtuDepth));
     xmlWriter.writeEndElement();
 
+    xmlWriter.writeStartElement(CppcheckXml::MaxTemplateRecursionElementName);
+    xmlWriter.writeCharacters(QString::number(mMaxTemplateRecursion));
+    xmlWriter.writeEndElement();
+
     if (!mIncludeDirs.isEmpty()) {
         xmlWriter.writeStartElement(CppcheckXml::IncludeDirElementName);
-        foreach (QString incdir, mIncludeDirs) {
+        for (const QString& incdir : utils::as_const(mIncludeDirs)) {
             xmlWriter.writeStartElement(CppcheckXml::DirElementName);
             xmlWriter.writeAttribute(CppcheckXml::DirNameAttrib, incdir);
             xmlWriter.writeEndElement();
@@ -686,7 +902,7 @@ bool ProjectFile::write(const QString &filename)
 
     if (!mDefines.isEmpty()) {
         xmlWriter.writeStartElement(CppcheckXml::DefinesElementName);
-        foreach (QString define, mDefines) {
+        for (const QString& define : utils::as_const(mDefines)) {
             xmlWriter.writeStartElement(CppcheckXml::DefineName);
             xmlWriter.writeAttribute(CppcheckXml::DefineNameAttrib, define);
             xmlWriter.writeEndElement();
@@ -694,6 +910,13 @@ bool ProjectFile::write(const QString &filename)
         xmlWriter.writeEndElement();
     }
 
+    if (!mVsConfigurations.isEmpty()) {
+        writeStringList(xmlWriter,
+                        mVsConfigurations,
+                        CppcheckXml::VSConfigurationElementName,
+                        CppcheckXml::VSConfigurationName);
+    }
+
     writeStringList(xmlWriter,
                     mUndefines,
                     CppcheckXml::UndefinesElementName,
@@ -701,7 +924,7 @@ bool ProjectFile::write(const QString &filename)
 
     if (!mPaths.isEmpty()) {
         xmlWriter.writeStartElement(CppcheckXml::PathsElementName);
-        foreach (QString path, mPaths) {
+        for (const QString& path : utils::as_const(mPaths)) {
             xmlWriter.writeStartElement(CppcheckXml::PathName);
             xmlWriter.writeAttribute(CppcheckXml::PathNameAttrib, path);
             xmlWriter.writeEndElement();
@@ -711,7 +934,7 @@ bool ProjectFile::write(const QString &filename)
 
     if (!mExcludedPaths.isEmpty()) {
         xmlWriter.writeStartElement(CppcheckXml::ExcludeElementName);
-        foreach (QString path, mExcludedPaths) {
+        for (const QString& path : utils::as_const(mExcludedPaths)) {
             xmlWriter.writeStartElement(CppcheckXml::ExcludePathName);
             xmlWriter.writeAttribute(CppcheckXml::ExcludePathNameAttrib, path);
             xmlWriter.writeEndElement();
@@ -726,7 +949,7 @@ bool ProjectFile::write(const QString &filename)
 
     if (!mSuppressions.isEmpty()) {
         xmlWriter.writeStartElement(CppcheckXml::SuppressionsElementName);
-        foreach (const Suppressions::Suppression &suppression, mSuppressions) {
+        for (const SuppressionList::Suppression &suppression : utils::as_const(mSuppressions)) {
             xmlWriter.writeStartElement(CppcheckXml::SuppressionElementName);
             if (!suppression.fileName.empty())
                 xmlWriter.writeAttribute("fileName", QString::fromStdString(suppression.fileName));
@@ -734,6 +957,8 @@ bool ProjectFile::write(const QString &filename)
                 xmlWriter.writeAttribute("lineNumber", QString::number(suppression.lineNumber));
             if (!suppression.symbolName.empty())
                 xmlWriter.writeAttribute("symbolName", QString::fromStdString(suppression.symbolName));
+            if (suppression.hash > 0)
+                xmlWriter.writeAttribute(CppcheckXml::HashAttributeName, QString::number(suppression.hash));
             if (!suppression.errorId.empty())
                 xmlWriter.writeCharacters(QString::fromStdString(suppression.errorId));
             xmlWriter.writeEndElement();
@@ -746,7 +971,7 @@ bool ProjectFile::write(const QString &filename)
                     CppcheckXml::CheckUnknownFunctionReturn,
                     CppcheckXml::Name);
 
-    mSafeChecks.saveToXml(xmlWriter);
+    safeChecks.saveToXml(xmlWriter);
 
     writeStringList(xmlWriter,
                     mAddons,
@@ -764,6 +989,69 @@ bool ProjectFile::write(const QString &filename)
                     CppcheckXml::ToolElementName);
 
     writeStringList(xmlWriter, mTags, CppcheckXml::TagsElementName, CppcheckXml::TagElementName);
+    if (!mWarningTags.empty()) {
+        QStringList tags;
+        for (const auto& wt: mWarningTags) {
+            if (!tags.contains(wt.second))
+                tags.append(wt.second);
+        }
+        for (const QString &tag: tags) {
+            xmlWriter.writeStartElement(CppcheckXml::TagWarningsElementName);
+            xmlWriter.writeAttribute(CppcheckXml::TagAttributeName, tag);
+            for (const auto& wt: mWarningTags) {
+                if (wt.second == tag) {
+                    xmlWriter.writeStartElement(CppcheckXml::WarningElementName);
+                    xmlWriter.writeAttribute(CppcheckXml::HashAttributeName, QString::number(wt.first));
+                    xmlWriter.writeEndElement();
+                }
+            }
+            xmlWriter.writeEndElement();
+        }
+    }
+
+    switch (mCheckLevel) {
+    case CheckLevel::reduced:
+        xmlWriter.writeStartElement(CppcheckXml::CheckLevelReducedElementName);
+        xmlWriter.writeEndElement();
+        break;
+    case CheckLevel::normal:
+        xmlWriter.writeStartElement(CppcheckXml::CheckLevelNormalElementName);
+        xmlWriter.writeEndElement();
+        break;
+    case CheckLevel::exhaustive:
+        xmlWriter.writeStartElement(CppcheckXml::CheckLevelExhaustiveElementName);
+        xmlWriter.writeEndElement();
+        break;
+    }
+
+    // Cppcheck Premium
+    if (mBughunting) {
+        xmlWriter.writeStartElement(CppcheckXml::BughuntingElementName);
+        xmlWriter.writeEndElement();
+    }
+
+    writeStringList(xmlWriter,
+                    mCodingStandards,
+                    CppcheckXml::CodingStandardsElementName,
+                    CppcheckXml::CodingStandardElementName);
+
+    if (mCertIntPrecision > 0) {
+        xmlWriter.writeStartElement(CppcheckXml::CertIntPrecisionElementName);
+        xmlWriter.writeCharacters(QString::number(mCertIntPrecision));
+        xmlWriter.writeEndElement();
+    }
+
+    if (!mProjectName.isEmpty()) {
+        xmlWriter.writeStartElement(CppcheckXml::ProjectNameElementName);
+        xmlWriter.writeCharacters(mProjectName);
+        xmlWriter.writeEndElement();
+    }
+
+    if (!mPremiumLicenseFile.isEmpty()) {
+        xmlWriter.writeStartElement(CppcheckXml::LicenseFileElementName);
+        xmlWriter.writeCharacters(mPremiumLicenseFile);
+        xmlWriter.writeEndElement();
+    }
 
     xmlWriter.writeEndDocument();
     file.close();
@@ -776,7 +1064,7 @@ void ProjectFile::writeStringList(QXmlStreamWriter &xmlWriter, const QStringList
         return;
 
     xmlWriter.writeStartElement(startelementname);
-    foreach (QString str, stringlist) {
+    for (const QString& str : stringlist) {
         xmlWriter.writeStartElement(stringelementname);
         xmlWriter.writeCharacters(str);
         xmlWriter.writeEndElement();
@@ -787,7 +1075,7 @@ void ProjectFile::writeStringList(QXmlStreamWriter &xmlWriter, const QStringList
 QStringList ProjectFile::fromNativeSeparators(const QStringList &paths)
 {
     QStringList ret;
-    foreach (const QString &path, paths)
+    for (const QString &path : paths)
         ret << QDir::fromNativeSeparators(path);
     return ret;
 }
@@ -813,13 +1101,13 @@ void ProjectFile::SafeChecks::loadFromXml(QXmlStreamReader &xmlReader)
         switch (type) {
         case QXmlStreamReader::StartElement:
             ++level;
-            if (xmlReader.name() == Settings::SafeChecks::XmlClasses)
+            if (xmlReader.name() == QString(Settings::SafeChecks::XmlClasses))
                 classes = true;
-            else if (xmlReader.name() == Settings::SafeChecks::XmlExternalFunctions)
+            else if (xmlReader.name() == QString(Settings::SafeChecks::XmlExternalFunctions))
                 externalFunctions = true;
-            else if (xmlReader.name() == Settings::SafeChecks::XmlInternalFunctions)
+            else if (xmlReader.name() == QString(Settings::SafeChecks::XmlInternalFunctions))
                 internalFunctions = true;
-            else if (xmlReader.name() == Settings::SafeChecks::XmlExternalVariables)
+            else if (xmlReader.name() == QString(Settings::SafeChecks::XmlExternalVariables))
                 externalVariables = true;
             break;
         case QXmlStreamReader::EndElement:
@@ -839,29 +1127,73 @@ void ProjectFile::SafeChecks::loadFromXml(QXmlStreamReader &xmlReader)
         case QXmlStreamReader::ProcessingInstruction:
             break;
         }
-    } while (1);
+    } while (true);
 }
 
 void ProjectFile::SafeChecks::saveToXml(QXmlStreamWriter &xmlWriter) const
 {
     if (!classes && !externalFunctions && !internalFunctions && !externalVariables)
         return;
-    xmlWriter.writeStartElement(Settings::SafeChecks::XmlRootName);
+    xmlWriter.writeStartElement(QString(Settings::SafeChecks::XmlRootName));
     if (classes) {
-        xmlWriter.writeStartElement(Settings::SafeChecks::XmlClasses);
+        xmlWriter.writeStartElement(QString(Settings::SafeChecks::XmlClasses));
         xmlWriter.writeEndElement();
     }
     if (externalFunctions) {
-        xmlWriter.writeStartElement(Settings::SafeChecks::XmlExternalFunctions);
+        xmlWriter.writeStartElement(QString(Settings::SafeChecks::XmlExternalFunctions));
         xmlWriter.writeEndElement();
     }
     if (internalFunctions) {
-        xmlWriter.writeStartElement(Settings::SafeChecks::XmlInternalFunctions);
+        xmlWriter.writeStartElement(QString(Settings::SafeChecks::XmlInternalFunctions));
         xmlWriter.writeEndElement();
     }
     if (externalVariables) {
-        xmlWriter.writeStartElement(Settings::SafeChecks::XmlExternalVariables);
+        xmlWriter.writeStartElement(QString(Settings::SafeChecks::XmlExternalVariables));
         xmlWriter.writeEndElement();
     }
     xmlWriter.writeEndElement();
 }
+
+QString ProjectFile::getAddonFilePath(QString filesDir, const QString &addon)
+{
+    if (QFile(addon).exists())
+        return addon;
+
+    if (!filesDir.endsWith("/"))
+        filesDir += "/";
+
+    QStringList searchPaths;
+    searchPaths << filesDir << (filesDir + "addons/") << (filesDir + "../addons/")
+#ifdef FILESDIR
+        << (QLatin1String(FILESDIR) + "/addons/")
+#endif
+    ;
+
+    for (const QString& path : utils::as_const(searchPaths)) {
+        QString f = path + addon + ".py";
+        if (QFile(f).exists())
+            return f;
+    }
+
+    return QString();
+}
+
+QStringList ProjectFile::getSearchPaths(const QString& projectPath, const QString& appPath, const QString& datadir, const QString& dir) {
+    QStringList ret;
+    ret << appPath << (appPath + "/" + dir) << projectPath;
+#ifdef FILESDIR
+    if (FILESDIR[0])
+        ret << FILESDIR << (FILESDIR "/" + dir);
+#endif
+    if (!datadir.isEmpty())
+        ret << datadir << (datadir + "/" + dir);
+    return ret;
+}
+
+QStringList ProjectFile::getSearchPaths(const QString& dir) const {
+    const QFileInfo inf(mFilename);
+    const QString applicationFilePath = QCoreApplication::applicationFilePath();
+    const QString appPath = QFileInfo(applicationFilePath).canonicalPath();
+    const QString datadir = getDataDir();
+    return getSearchPaths(inf.canonicalFilePath(), appPath, datadir, dir);
+}
diff --git a/gui/projectfile.h b/gui/projectfile.h
index 63f2be3fb57..e7f8d342180 100644
--- a/gui/projectfile.h
+++ b/gui/projectfile.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,28 +19,53 @@
 #ifndef PROJECT_FILE_H
 #define PROJECT_FILE_H
 
+#include "settings.h"
+#include "suppressions.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <map>
+#include <utility>
+
+#include <QList>
 #include <QObject>
 #include <QString>
 #include <QStringList>
-#include <QXmlStreamReader>
 
-#include "suppressions.h"
+class QXmlStreamReader;
+class QXmlStreamWriter;
 
 /// @addtogroup GUI
 /// @{
 
 
 /**
-* @brief A class that reads and writes project files.
-* The project files contain project-specific settings for checking. For
-* example a list of include paths.
-*/
+ * @brief A class that reads and writes project files.
+ * The project files contain project-specific settings for checking. For
+ * example a list of include paths.
+ */
 class ProjectFile : public QObject {
     Q_OBJECT
 
 public:
     explicit ProjectFile(QObject *parent = nullptr);
-    explicit ProjectFile(const QString &filename, QObject *parent = nullptr);
+    explicit ProjectFile(QString filename, QObject *parent = nullptr);
+    ~ProjectFile() override {
+        if (this == mActiveProject) mActiveProject = nullptr;
+    }
+
+    enum class CheckLevel : std::uint8_t {
+        reduced,
+        normal,
+        exhaustive
+    };
+
+    static ProjectFile* getActiveProject() {
+        return mActiveProject;
+    }
+    void setActiveProject() {
+        mActiveProject = this;
+    }
 
     /**
      * @brief Read the project file.
@@ -52,15 +77,15 @@ class ProjectFile : public QObject {
      * @brief Get project root path.
      * @return project root path.
      */
-    QString getRootPath() const {
+    const QString& getRootPath() const {
         return mRootPath;
     }
 
-    QString getBuildDir() const {
+    const QString& getBuildDir() const {
         return mBuildDir;
     }
 
-    QString getImportProject() const {
+    const QString& getImportProject() const {
         return mImportProject;
     }
 
@@ -84,85 +109,123 @@ class ProjectFile : public QObject {
         mCheckUnusedTemplates = b;
     }
 
+    bool getInlineSuppression() const {
+        return mInlineSuppression;
+    }
+
+    void setInlineSuppression(bool b) {
+        mInlineSuppression = b;
+    }
+
     /**
-    * @brief Get list of include directories.
-    * @return list of directories.
-    */
+     * @brief Get list of include directories.
+     * @return list of directories.
+     */
     QStringList getIncludeDirs() const {
         return ProjectFile::fromNativeSeparators(mIncludeDirs);
     }
 
     /**
-    * @brief Get list of defines.
-    * @return list of defines.
-    */
-    QStringList getDefines() const {
+     * @brief Get list of defines.
+     * @return list of defines.
+     */
+    const QStringList& getDefines() const {
         return mDefines;
     }
 
     /**
-    * @brief Get list of undefines.
-    * @return list of undefines.
-    */
-    QStringList getUndefines() const {
+     * @brief Get list of undefines.
+     * @return list of undefines.
+     */
+    const QStringList& getUndefines() const {
         return mUndefines;
     }
 
     /**
-    * @brief Get list of paths to check.
-    * @return list of paths.
-    */
+     * @brief Get list of paths to check.
+     * @return list of paths.
+     */
     QStringList getCheckPaths() const {
         return ProjectFile::fromNativeSeparators(mPaths);
     }
 
     /**
-    * @brief Get list of paths to exclude from the check.
-    * @return list of paths.
-    */
+     * @brief Get list of paths to exclude from the check.
+     * @return list of paths.
+     */
     QStringList getExcludedPaths() const {
         return ProjectFile::fromNativeSeparators(mExcludedPaths);
     }
 
     /**
-    * @brief Get list libraries.
-    * @return list of libraries.
-    */
-    QStringList getLibraries() const {
+     * @brief Get list of paths to exclude from the check.
+     * @return list of paths.
+     */
+    const QStringList& getVsConfigurations() const {
+        return mVsConfigurations;
+    }
+
+    /**
+     * @brief Get list libraries.
+     * @return list of libraries.
+     */
+    const QStringList& getLibraries() const {
         return mLibraries;
     }
 
     /**
      * @brief Get platform.
-     * @return Current platform. If it ends with .xml then it is a file. Otherwise it must match one of the return values from @sa cppcheck::Platform::platformString() ("win32A", "unix32", ..)
+     * @return Current platform. If it ends with .xml then it is a file. Otherwise it must match one of the return values from @sa cppcheck::Platform::toString() ("win32A", "unix32", ..)
      */
-    QString getPlatform() const {
+    const QString& getPlatform() const {
         return mPlatform;
     }
 
+    const QString& getProjectName() const {
+        return mProjectName;
+    }
+
+    void setProjectName(QString projectName) {
+        mProjectName = std::move(projectName);
+    }
+
     /**
-    * @brief Get "raw" suppressions.
-    * @return list of suppressions.
-    */
-    QList<Suppressions::Suppression> getSuppressions() const {
+     * @brief Get "raw" suppressions.
+     * @return list of suppressions.
+     */
+    const QList<SuppressionList::Suppression>& getSuppressions() const {
         return mSuppressions;
     }
 
     /**
-    * @brief Get list addons.
-    * @return list of addons.
-    */
-    QStringList getAddons() const {
+     * @brief Get "checking" suppressions. Relative paths are converted to absolute paths.
+     * @return list of suppressions.
+     */
+    QList<SuppressionList::Suppression> getCheckingSuppressions() const;
+
+    /**
+     * @brief Get list addons.
+     * @return list of addons.
+     */
+    const QStringList& getAddons() const {
         return mAddons;
     }
 
     /**
-    * @brief Get list of addons and tools.
-    * @return list of addons and tools.
-    */
+     * @brief Get path to addon python script
+     * @param filesDir Data files folder set by --data-dir
+     * @param addon addon i.e. "misra" to lookup
+     */
+    static QString getAddonFilePath(QString filesDir, const QString &addon);
+
+    /**
+     * @brief Get list of addons and tools.
+     * @return list of addons and tools.
+     */
     QStringList getAddonsAndTools() const;
 
     bool getClangAnalyzer() const {
+        // TODO
         return false; //mClangAnalyzer;
     }
 
@@ -178,7 +241,7 @@ class ProjectFile : public QObject {
         mClangTidy = c;
     }
 
-    QStringList getTags() const {
+    const QStringList& getTags() const {
         return mTags;
     }
 
@@ -190,18 +253,26 @@ class ProjectFile : public QObject {
         mMaxCtuDepth = maxCtuDepth;
     }
 
+    int getMaxTemplateRecursion() const {
+        return mMaxTemplateRecursion;
+    }
+
+    void setMaxTemplateRecursion(int maxTemplateRecursion) {
+        mMaxTemplateRecursion = maxTemplateRecursion;
+    }
+
     /**
-    * @brief Get filename for the project file.
-    * @return file name.
-    */
-    QString getFilename() const {
+     * @brief Get filename for the project file.
+     * @return file name.
+     */
+    const QString& getFilename() const {
         return mFilename;
     }
 
     /**
-    * @brief Set project root path.
-    * @param rootpath new project root path.
-    */
+     * @brief Set project root path.
+     * @param rootpath new project root path.
+     */
     void setRootPath(const QString &rootpath) {
         mRootPath = rootpath;
     }
@@ -264,7 +335,10 @@ class ProjectFile : public QObject {
      * @brief Set list of suppressions.
      * @param suppressions List of suppressions.
      */
-    void setSuppressions(const QList<Suppressions::Suppression> &suppressions);
+    void setSuppressions(const QList<SuppressionList::Suppression> &suppressions);
+
+    /** Add suppression */
+    void addSuppression(const SuppressionList::Suppression &suppression);
 
     /**
      * @brief Set list of addons.
@@ -272,6 +346,17 @@ class ProjectFile : public QObject {
      */
     void setAddons(const QStringList &addons);
 
+    /** @brief Set list of Visual Studio configurations to be checked
+     *  @param vsConfigs List of configurations
+     */
+    void setVSConfigurations(const QStringList &vsConfigs);
+
+    /** CheckLevel: normal/exhaustive */
+    void setCheckLevel(CheckLevel checkLevel);
+    CheckLevel getCheckLevel() const {
+        return mCheckLevel;
+    }
+
     /**
      * @brief Set tags.
      * @param tags tag list
@@ -280,6 +365,49 @@ class ProjectFile : public QObject {
         mTags = tags;
     }
 
+    /** Set tags for a warning */
+    void setWarningTags(std::size_t hash, const QString& tags);
+
+    /** Get tags for a warning */
+    QString getWarningTags(std::size_t hash) const;
+
+    /** Bughunting (Cppcheck Premium) */
+    void setBughunting(bool bughunting) {
+        mBughunting = bughunting;
+    }
+    bool getBughunting() const {
+        return mBughunting;
+    }
+
+    /** @brief Get list of coding standards (checked by Cppcheck Premium). */
+    const QStringList& getCodingStandards() const {
+        return mCodingStandards;
+    }
+
+    /**
+     * @brief Set list of coding standards (checked by Cppcheck Premium).
+     * @param codingStandards List of coding standards.
+     */
+    void setCodingStandards(QStringList codingStandards) {
+        mCodingStandards = std::move(codingStandards);
+    }
+
+    /** Cert C: int precision */
+    void setCertIntPrecision(int p) {
+        mCertIntPrecision = p;
+    }
+    int getCertIntPrecision() const {
+        return mCertIntPrecision;
+    }
+
+    /** Cppcheck Premium: License file */
+    void setLicenseFile(const QString& licenseFile) {
+        mPremiumLicenseFile = licenseFile;
+    }
+    const QString& getLicenseFile() const {
+        return mPremiumLicenseFile;
+    }
+
     /**
      * @brief Write project file (to disk).
      * @param filename Filename to use.
@@ -295,60 +423,32 @@ class ProjectFile : public QObject {
     }
 
     /** Do not only check how interface is used. Also check that interface is safe. */
-    class SafeChecks {
+    class SafeChecks : public Settings::SafeChecks {
     public:
-        SafeChecks() : classes(false), externalFunctions(false), internalFunctions(false), externalVariables(false) {}
-
-        void clear() {
-            classes = externalFunctions = internalFunctions = externalVariables = false;
-        }
+        SafeChecks() : Settings::SafeChecks() {}
 
         void loadFromXml(QXmlStreamReader &xmlReader);
         void saveToXml(QXmlStreamWriter &xmlWriter) const;
-
-        /**
-         * Public interface of classes
-         * - public function parameters can have any value
-         * - public functions can be called in any order
-         * - public variables can have any value
-         */
-        bool classes;
-
-        /**
-         * External functions
-         * - external functions can be called in any order
-         * - function parameters can have any values
-         */
-        bool externalFunctions;
-
-        /**
-         * Experimental: assume that internal functions can be used in any way
-         * This is only available in the GUI.
-         */
-        bool internalFunctions;
-
-        /**
-         * Global variables that can be modified outside the TU.
-         * - Such variable can have "any" value
-         */
-        bool externalVariables;
     };
 
-    /** Safe checks */
-    SafeChecks getSafeChecks() const {
-        return mSafeChecks;
-    }
-    void setSafeChecks(SafeChecks safeChecks) {
-        mSafeChecks = safeChecks;
-    }
+    SafeChecks safeChecks;
 
     /** Check unknown function return values */
-    QStringList getCheckUnknownFunctionReturn() const {
+    const QStringList& getCheckUnknownFunctionReturn() const {
         return mCheckUnknownFunctionReturn;
     }
-    void setCheckUnknownFunctionReturn(const QStringList &s) {
+    /*
+       void setCheckUnknownFunctionReturn(const QStringList &s) {
         mCheckUnknownFunctionReturn = s;
-    }
+       }
+     */
+
+    /** Use Clang parser */
+    bool clangParser;
+
+    /** Get paths where we should glob for certain files (dir="cfg"/"platforms"/etc */
+    QStringList getSearchPaths(const QString& dir) const;
+    static QStringList getSearchPaths(const QString& projectPath, const QString& appPath, const QString& datadir, const QString& dir);
 
 protected:
 
@@ -356,7 +456,7 @@ class ProjectFile : public QObject {
      * @brief Read optional root path from XML.
      * @param reader XML stream reader.
      */
-    void readRootPath(QXmlStreamReader &reader);
+    void readRootPath(const QXmlStreamReader &reader);
 
     void readBuildDir(QXmlStreamReader &reader);
 
@@ -366,9 +466,11 @@ class ProjectFile : public QObject {
      */
     void readImportProject(QXmlStreamReader &reader);
 
-    bool readBool(QXmlStreamReader &reader);
+    static bool readBool(QXmlStreamReader &reader);
+
+    static int readInt(QXmlStreamReader &reader, int defaultValue);
 
-    int readInt(QXmlStreamReader &reader, int defaultValue);
+    static QString readString(QXmlStreamReader &reader);
 
     /**
      * @brief Read list of include directories from XML.
@@ -394,6 +496,12 @@ class ProjectFile : public QObject {
      */
     void readExcludes(QXmlStreamReader &reader);
 
+    /**
+     * @brief Read lists of Visual Studio configurations
+     * @param reader XML stream reader.
+     */
+    void readVsConfigurations(QXmlStreamReader &reader);
+
     /**
      * @brief Read platform text.
      * @param reader XML stream reader.
@@ -407,12 +515,18 @@ class ProjectFile : public QObject {
     void readSuppressions(QXmlStreamReader &reader);
 
     /**
-      * @brief Read string list
-      * @param stringlist   destination string list
-      * @param reader       XML stream reader
-      * @param elementname  elementname for each string
-      */
-    void readStringList(QStringList &stringlist, QXmlStreamReader &reader, const char elementname[]);
+     * @brief Read tag warnings, what warnings are tagged with a specific tag
+     * @param reader XML stream reader.
+     */
+    void readTagWarnings(QXmlStreamReader &reader, const QString &tag);
+
+    /**
+     * @brief Read string list
+     * @param stringlist   destination string list
+     * @param reader       XML stream reader
+     * @param elementname  elementname for each string
+     */
+    static void readStringList(QStringList &stringlist, QXmlStreamReader &reader, const char elementname[]);
 
     /**
      * @brief Write string list
@@ -458,12 +572,20 @@ class ProjectFile : public QObject {
      */
     bool mAnalyzeAllVsConfigs;
 
+    /** Check only a selected VS configuration */
+    QStringList mVsConfigurations;
+
     /** Check code in headers */
     bool mCheckHeaders;
 
     /** Check code in unused templates */
     bool mCheckUnusedTemplates;
 
+    /**
+     * @brief Enable inline suppression.
+     */
+    bool mInlineSuppression;
+
     /**
      * @brief List of include directories used to search include files.
      */
@@ -502,13 +624,32 @@ class ProjectFile : public QObject {
     /**
      * @brief List of suppressions.
      */
-    QList<Suppressions::Suppression> mSuppressions;
+    QList<SuppressionList::Suppression> mSuppressions;
 
     /**
      * @brief List of addons.
      */
     QStringList mAddons;
 
+    bool mBughunting = false;
+
+    /** @brief Should Cppcheck run normal or exhaustive analysis? */
+    CheckLevel mCheckLevel = CheckLevel::normal;
+
+    /**
+     * @brief List of coding standards, checked by Cppcheck Premium.
+     */
+    QStringList mCodingStandards;
+
+    /** @brief Cppcheck Premium: license file */
+    QString mPremiumLicenseFile;
+
+    /** @brief Project name, used when generating compliance report */
+    QString mProjectName;
+
+    /** @brief Cppcheck Premium: This value is passed to the Cert C checker if that is enabled */
+    int mCertIntPrecision;
+
     /** @brief Execute clang analyzer? */
     bool mClangAnalyzer;
 
@@ -516,17 +657,24 @@ class ProjectFile : public QObject {
     bool mClangTidy;
 
     /**
-     * @brief Warning tags
+     * @brief Tags
      */
     QStringList mTags;
 
+    /**
+     * @brief Warning tags
+     */
+    std::map<std::size_t, QString> mWarningTags;
+
     /** Max CTU depth */
     int mMaxCtuDepth;
 
-    SafeChecks mSafeChecks;
+    /** Max template instantiation recursion */
+    int mMaxTemplateRecursion;
 
     QStringList mCheckUnknownFunctionReturn;
 
+    static ProjectFile *mActiveProject;
 };
 /// @}
 #endif  // PROJECT_FILE_H
diff --git a/gui/projectfiledialog.ui b/gui/projectfile.ui
similarity index 58%
rename from gui/projectfiledialog.ui
rename to gui/projectfile.ui
index fd775d3bc4e..4bd01339d83 100644
--- a/gui/projectfiledialog.ui
+++ b/gui/projectfile.ui
@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>888</width>
-    <height>585</height>
+    <width>940</width>
+    <height>701</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -29,7 +29,7 @@
          <property name="title">
           <string>Import Project (Visual studio / compile database/ Borland C++ Builder 6)</string>
          </property>
-         <layout class="QVBoxLayout" name="verticalLayout_4">
+         <layout class="QVBoxLayout" name="verticalLayout_17">
           <item>
            <layout class="QHBoxLayout" name="horizontalLayout">
             <item>
@@ -64,14 +64,75 @@
            </layout>
           </item>
           <item>
-           <widget class="QCheckBox" name="mChkAllVsConfigs">
-            <property name="toolTip">
-             <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;You have a choice:&lt;/p&gt;&lt;p&gt; * Analyze all Debug and Release configurations&lt;/p&gt;&lt;p&gt; * Only analyze the first matching Debug configuration&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-            </property>
-            <property name="text">
-             <string>Analyze all Visual Studio configurations</string>
-            </property>
-           </widget>
+           <layout class="QHBoxLayout" name="horizontalLayout_8">
+            <item>
+             <layout class="QVBoxLayout" name="verticalLayout_4">
+              <item>
+               <widget class="QCheckBox" name="mChkAllVsConfigs">
+                <property name="toolTip">
+                 <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;You have a choice:&lt;/p&gt;&lt;p&gt; * Analyze all Debug and Release configurations&lt;/p&gt;&lt;p&gt; * Only analyze the first matching Debug configuration&lt;/p&gt;&lt;p&gt;&lt;br/&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+                </property>
+                <property name="text">
+                 <string>Analyze all Visual Studio configurations</string>
+                </property>
+               </widget>
+              </item>
+              <item>
+               <spacer name="verticalSpacer_11">
+                <property name="orientation">
+                 <enum>Qt::Vertical</enum>
+                </property>
+                <property name="sizeHint" stdset="0">
+                 <size>
+                  <width>20</width>
+                  <height>40</height>
+                 </size>
+                </property>
+               </spacer>
+              </item>
+             </layout>
+            </item>
+            <item>
+             <spacer name="horizontalSpacer_2">
+              <property name="orientation">
+               <enum>Qt::Horizontal</enum>
+              </property>
+              <property name="sizeHint" stdset="0">
+               <size>
+                <width>40</width>
+                <height>20</height>
+               </size>
+              </property>
+             </spacer>
+            </item>
+            <item>
+             <layout class="QVBoxLayout" name="verticalLayout_16">
+              <item>
+               <widget class="QLabel" name="mLabelVSConfig">
+                <property name="text">
+                 <string>Selected VS Configurations</string>
+                </property>
+               </widget>
+              </item>
+              <item>
+               <spacer name="verticalSpacer_12">
+                <property name="orientation">
+                 <enum>Qt::Vertical</enum>
+                </property>
+                <property name="sizeHint" stdset="0">
+                 <size>
+                  <width>20</width>
+                  <height>40</height>
+                 </size>
+                </property>
+               </spacer>
+              </item>
+             </layout>
+            </item>
+            <item>
+             <widget class="QListWidget" name="mListVsConfigs"/>
+            </item>
+           </layout>
           </item>
          </layout>
         </widget>
@@ -103,7 +164,14 @@
           </layout>
          </item>
          <item>
-          <widget class="QListWidget" name="mListCheckPaths"/>
+          <widget class="QListWidget" name="mListCheckPaths">
+           <property name="maximumSize">
+            <size>
+             <width>16777215</width>
+             <height>140</height>
+            </size>
+           </property>
+          </widget>
          </item>
          <item>
           <layout class="QVBoxLayout" name="mLayoutCheckPathsButtons">
@@ -289,11 +357,52 @@
        </item>
       </layout>
      </widget>
-     <widget class="QWidget" name="mTabChecking">
+     <widget class="QWidget" name="mTabTypesAndFunctions">
       <attribute name="title">
-       <string>Checking</string>
+       <string>Types and Functions</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_15">
+       <item>
+        <widget class="QGroupBox" name="groupBox_6">
+         <property name="title">
+          <string>Platform</string>
+         </property>
+         <layout class="QVBoxLayout" name="verticalLayout_12">
+          <item>
+           <widget class="QComboBox" name="mComboBoxPlatform"/>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="groupBox_3">
+         <property name="title">
+          <string>Libraries</string>
+         </property>
+         <layout class="QVBoxLayout" name="verticalLayout_2">
+          <item>
+           <widget class="QListWidget" name="mLibraries"/>
+          </item>
+          <item>
+           <widget class="QLabel" name="mLabelLibrariesNote">
+            <property name="text">
+             <string>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</string>
+            </property>
+            <property name="wordWrap">
+             <bool>true</bool>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+     <widget class="QWidget" name="mTabAnalysis">
+      <attribute name="title">
+       <string>Analysis</string>
+      </attribute>
+      <layout class="QVBoxLayout" name="verticalLayout_22">
        <item>
         <widget class="QGroupBox" name="groupBox_2">
          <property name="title">
@@ -301,7 +410,11 @@
          </property>
          <layout class="QHBoxLayout" name="horizontalLayout_2">
           <item>
-           <widget class="QLineEdit" name="mEditBuildDir"/>
+           <widget class="QLineEdit" name="mEditBuildDir">
+            <property name="toolTip">
+             <string>This is a workfolder that Cppcheck will use for various purposes.</string>
+            </property>
+           </widget>
           </item>
           <item>
            <widget class="QPushButton" name="mBtnBrowseBuildDir">
@@ -314,27 +427,96 @@
         </widget>
        </item>
        <item>
-        <widget class="QGroupBox" name="groupBox_6">
+        <widget class="QGroupBox" name="groupBox_10">
          <property name="title">
-          <string>Platform</string>
+          <string>Parser</string>
          </property>
-         <layout class="QVBoxLayout" name="verticalLayout_12">
+         <layout class="QVBoxLayout" name="verticalLayout_14">
           <item>
-           <widget class="QComboBox" name="mComboBoxPlatform"/>
+           <widget class="QRadioButton" name="mBtnCppcheckParser">
+            <property name="text">
+             <string>Cppcheck (built in)</string>
+            </property>
+            <property name="checked">
+             <bool>true</bool>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QRadioButton" name="mBtnClangParser">
+            <property name="text">
+             <string>Clang (experimental)</string>
+            </property>
+           </widget>
           </item>
          </layout>
         </widget>
        </item>
        <item>
-        <widget class="QGroupBox" name="groupBox_9">
+        <widget class="QGroupBox" name="groupBox_13">
+         <property name="title">
+          <string>Check level</string>
+         </property>
+         <layout class="QVBoxLayout" name="verticalLayout_18">
+          <item>
+           <widget class="QRadioButton" name="mCheckLevelReduced">
+            <property name="text">
+             <string>Reduced -- meant for usage where developer wants results directly. Limited and faster analysis with fewer results.</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QRadioButton" name="mCheckLevelNormal">
+            <property name="text">
+             <string>Normal -- meant for normal analysis in CI. Analysis should finish in reasonable time.</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QRadioButton" name="mCheckLevelExhaustive">
+            <property name="text">
+             <string>Exhaustive -- meant for nightly builds etc. Analysis time can be longer (10x slower than compilation is OK).</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="groupBox_11">
          <property name="title">
           <string>Analysis</string>
          </property>
+         <layout class="QVBoxLayout" name="verticalLayout_19">
+          <item>
+           <widget class="QCheckBox" name="mBtnSafeClasses">
+            <property name="toolTip">
+             <string>If you want to design your classes to be as flexible and robust as possible then the public interface must be very robust. Cppcheck will asumme that arguments can take *any* value.</string>
+            </property>
+            <property name="text">
+             <string>Check that each class has a safe public interface</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="groupBox_9">
+         <property name="sizePolicy">
+          <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
+           <horstretch>0</horstretch>
+           <verstretch>0</verstretch>
+          </sizepolicy>
+         </property>
+         <property name="title">
+          <string>Limit analysis</string>
+         </property>
          <layout class="QVBoxLayout" name="verticalLayout_9">
           <item>
            <widget class="QCheckBox" name="mCheckHeaders">
             <property name="text">
-             <string>Check code in headers  (slower analysis, more results)</string>
+             <string>Check code in headers  (should be ON normally. if you want a limited quick analysis then turn this OFF)</string>
             </property>
             <property name="checked">
              <bool>true</bool>
@@ -344,7 +526,10 @@
           <item>
            <widget class="QCheckBox" name="mCheckUnusedTemplates">
             <property name="text">
-             <string>Check code in unused templates  (slower and less accurate analysis)</string>
+             <string>Check code in unused templates (should be ON normally, however in theory you can safely ignore warnings in unused templates)</string>
+            </property>
+            <property name="checked">
+             <bool>true</bool>
             </property>
            </widget>
           </item>
@@ -358,7 +543,11 @@
              </widget>
             </item>
             <item>
-             <widget class="QSpinBox" name="mMaxCtuDepth"/>
+             <widget class="QSpinBox" name="mMaxCtuDepth">
+              <property name="value">
+               <number>10</number>
+              </property>
+             </widget>
             </item>
             <item>
              <spacer name="horizontalSpacer">
@@ -375,44 +564,62 @@
             </item>
            </layout>
           </item>
+          <item>
+           <layout class="QHBoxLayout" name="horizontalLayout_9">
+            <item>
+             <widget class="QLabel" name="label_4">
+              <property name="text">
+               <string>Max recursion in template instantiation</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QSpinBox" name="mMaxTemplateRecursion">
+              <property name="maximum">
+               <number>1000</number>
+              </property>
+              <property name="value">
+               <number>100</number>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <spacer name="horizontalSpacer_3">
+              <property name="orientation">
+               <enum>Qt::Horizontal</enum>
+              </property>
+              <property name="sizeHint" stdset="0">
+               <size>
+                <width>40</width>
+                <height>20</height>
+               </size>
+              </property>
+             </spacer>
+            </item>
+           </layout>
+          </item>
          </layout>
         </widget>
        </item>
        <item>
-        <widget class="QGroupBox" name="groupBox_3">
+        <widget class="QGroupBox" name="premiumLicense">
          <property name="title">
-          <string>Libraries</string>
+          <string>Premium License</string>
          </property>
-         <layout class="QVBoxLayout" name="verticalLayout_2">
+         <layout class="QHBoxLayout" name="horizontalLayout_12">
           <item>
-           <widget class="QListWidget" name="mLibraries"/>
+           <widget class="QLineEdit" name="mEditLicenseFile"/>
           </item>
           <item>
-           <widget class="QLabel" name="mLabelLibrariesNote">
+           <widget class="QPushButton" name="mBtnBrowseLicense">
             <property name="text">
-             <string>Note: Put your own custom .cfg files in the same folder as the project file. You should see them above.</string>
-            </property>
-            <property name="wordWrap">
-             <bool>true</bool>
+             <string>Browse...</string>
             </property>
            </widget>
           </item>
          </layout>
         </widget>
        </item>
-       <item>
-        <spacer name="verticalSpacer_7">
-         <property name="orientation">
-          <enum>Qt::Vertical</enum>
-         </property>
-         <property name="sizeHint" stdset="0">
-          <size>
-           <width>20</width>
-           <height>96</height>
-          </size>
-         </property>
-        </spacer>
-       </item>
       </layout>
      </widget>
      <widget class="QWidget" name="mTabWarningOptions">
@@ -427,7 +634,11 @@
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_13">
           <item>
-           <widget class="QLineEdit" name="mEditProjectRoot"/>
+           <widget class="QLineEdit" name="mEditProjectRoot">
+            <property name="toolTip">
+             <string>Filepaths in warnings will be relative to this path</string>
+            </property>
+           </widget>
           </item>
          </layout>
         </widget>
@@ -439,7 +650,11 @@
          </property>
          <layout class="QHBoxLayout" name="horizontalLayout_3">
           <item>
-           <widget class="QLineEdit" name="mEditTags"/>
+           <widget class="QLineEdit" name="mEditTags">
+            <property name="toolTip">
+             <string>If tags are added, you will be able to right click on warnings and set one of these tags. You can manually categorize warnings.</string>
+            </property>
+           </widget>
           </item>
          </layout>
         </widget>
@@ -447,7 +662,7 @@
        <item>
         <widget class="QGroupBox" name="groupBox_7">
          <property name="title">
-          <string>Exclude source files in paths</string>
+          <string>Exclude source files</string>
          </property>
          <layout class="QHBoxLayout" name="horizontalLayout_4">
           <item>
@@ -458,7 +673,14 @@
             <item>
              <widget class="QPushButton" name="mBtnAddIgnorePath">
               <property name="text">
-               <string>Add...</string>
+               <string>Exclude folder...</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QPushButton" name="mBtnAddIgnoreFile">
+              <property name="text">
+               <string>Exclude file...</string>
               </property>
              </widget>
             </item>
@@ -537,6 +759,13 @@
          </layout>
         </widget>
        </item>
+       <item>
+        <widget class="QCheckBox" name="mInlineSuppressions">
+         <property name="text">
+          <string>Enable inline suppressions</string>
+         </property>
+        </widget>
+       </item>
        <item>
         <spacer name="verticalSpacer_9">
          <property name="orientation">
@@ -552,9 +781,9 @@
        </item>
       </layout>
      </widget>
-     <widget class="QWidget" name="mTabAddonsAndTools">
+     <widget class="QWidget" name="mTabAddons">
       <attribute name="title">
-       <string>Addons and tools</string>
+       <string>Addons</string>
       </attribute>
       <layout class="QVBoxLayout" name="verticalLayout_10">
        <item>
@@ -564,46 +793,87 @@
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_3">
           <item>
-           <widget class="QCheckBox" name="mAddonY2038">
+           <widget class="QLabel" name="label_addons_require_python">
             <property name="text">
-             <string>Y2038</string>
+             <string>Note: Addons require &lt;a href=&quot;https://www.python.org/&quot;&gt;Python&lt;/a&gt; being installed.</string>
             </property>
-           </widget>
-          </item>
-          <item>
-           <widget class="QCheckBox" name="mAddonThreadSafety">
-            <property name="text">
-             <string>Thread safety</string>
+            <property name="openExternalLinks">
+             <bool>true</bool>
             </property>
            </widget>
           </item>
           <item>
-           <widget class="QLabel" name="label">
+           <widget class="QCheckBox" name="mAddonY2038">
             <property name="text">
-             <string>Coding standards</string>
+             <string>Y2038</string>
             </property>
            </widget>
           </item>
           <item>
-           <widget class="QCheckBox" name="mAddonCert">
+           <widget class="QCheckBox" name="mAddonThreadSafety">
             <property name="text">
-             <string>Cert</string>
+             <string>Thread safety</string>
             </property>
            </widget>
           </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="groupBox_12">
+         <property name="title">
+          <string>Coding standards</string>
+         </property>
+         <layout class="QVBoxLayout" name="verticalLayout_20">
           <item>
-           <widget class="QCheckBox" name="mAddonMisra">
-            <property name="text">
-             <string>MISRA C 2012</string>
-            </property>
-           </widget>
+           <layout class="QHBoxLayout" name="horizontalLayout_6">
+            <item>
+             <widget class="QCheckBox" name="mMisraC">
+              <property name="text">
+               <string>Misra C</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QComboBox" name="mMisraVersion">
+              <item>
+               <property name="text">
+                <string>2012</string>
+               </property>
+              </item>
+              <item>
+               <property name="text">
+                <string>2023</string>
+               </property>
+              </item>
+              <item>
+               <property name="text">
+                <string>2025</string>
+               </property>
+              </item>
+             </widget>
+            </item>
+            <item>
+             <spacer name="horizontalSpacer_4">
+              <property name="orientation">
+               <enum>Qt::Horizontal</enum>
+              </property>
+              <property name="sizeHint" stdset="0">
+               <size>
+                <width>40</width>
+                <height>20</height>
+               </size>
+              </property>
+             </spacer>
+            </item>
+           </layout>
           </item>
           <item>
-           <layout class="QHBoxLayout" name="horizontalLayout_6">
+           <layout class="QHBoxLayout" name="mLayoutMisraRuleTexts">
             <item>
-             <widget class="QLabel" name="label_2">
+             <widget class="QLabel" name="mLabelMisraFile">
               <property name="text">
-               <string>Misra rule texts</string>
+               <string>MISRA rule texts</string>
               </property>
              </widget>
             </item>
@@ -623,6 +893,102 @@
             </item>
            </layout>
           </item>
+          <item>
+           <layout class="QHBoxLayout" name="horizontalLayout_11">
+            <item>
+             <widget class="QCheckBox" name="mMisraCpp">
+              <property name="text">
+               <string>Misra C++</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QComboBox" name="mMisraCppVersion">
+              <item>
+               <property name="text">
+                <string>2008</string>
+               </property>
+              </item>
+              <item>
+               <property name="text">
+                <string>2023</string>
+               </property>
+              </item>
+             </widget>
+            </item>
+            <item>
+             <spacer name="horizontalSpacer_5">
+              <property name="orientation">
+               <enum>Qt::Horizontal</enum>
+              </property>
+              <property name="sizeHint" stdset="0">
+               <size>
+                <width>40</width>
+                <height>20</height>
+               </size>
+              </property>
+             </spacer>
+            </item>
+           </layout>
+          </item>
+          <item>
+           <widget class="QCheckBox" name="mCertC2016">
+            <property name="text">
+             <string>Cert C</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <layout class="QHBoxLayout" name="horizontalLayout_10">
+            <item>
+             <widget class="QLabel" name="mLabelCertIntPrecision">
+              <property name="text">
+               <string>CERT-INT35-C:  int precision (if size equals precision, you can leave empty)</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QLineEdit" name="mEditCertIntPrecision"/>
+            </item>
+           </layout>
+          </item>
+          <item>
+           <widget class="QCheckBox" name="mCertCpp2016">
+            <property name="text">
+             <string>Cert C++</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QCheckBox" name="mAutosar">
+            <property name="text">
+             <string>Autosar</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QCheckBox" name="mSafetyProfiles">
+            <property name="text">
+             <string>Safety profiles (defined in C++ core guidelines)</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="mGroupboxBughunting">
+         <property name="title">
+          <string>Bug hunting (Premium)</string>
+         </property>
+         <layout class="QVBoxLayout" name="verticalLayout_21">
+          <item>
+           <widget class="QCheckBox" name="mBughunting">
+            <property name="text">
+             <string>Bug hunting</string>
+            </property>
+           </widget>
+          </item>
          </layout>
         </widget>
        </item>
diff --git a/gui/projectfiledialog.cpp b/gui/projectfiledialog.cpp
index c9b51b1d4be..21618dbb017 100644
--- a/gui/projectfiledialog.cpp
+++ b/gui/projectfiledialog.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,23 +16,58 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QWidget>
-#include <QDialog>
-#include <QString>
-#include <QStringList>
-#include <QFileInfo>
-#include <QFileDialog>
-#include <QInputDialog>
-#include <QDir>
-#include <QSettings>
-#include <QProcess>
-#include "common.h"
-#include "newsuppressiondialog.h"
 #include "projectfiledialog.h"
+
 #include "checkthread.h"
-#include "projectfile.h"
+#include "common.h"
+#include "importproject.h"
 #include "library.h"
+#include "newsuppressiondialog.h"
+#include "path.h"
+#include "platform.h"
 #include "platforms.h"
+#include "projectfile.h"
+#include "settings.h"
+#include "utils.h"
+
+#include "ui_projectfile.h"
+
+#include <array>
+#include <list>
+#include <string>
+#include <utility>
+
+#include <QByteArray>
+#include <QCheckBox>
+#include <QComboBox>
+#include <QDialogButtonBox>
+#include <QDir>
+#include <QFileDialog>
+#include <QFileInfo>
+#include <QLabel>
+#include <QLineEdit>
+#include <QListWidget>
+#include <QListWidgetItem>
+#include <QMap>
+#include <QObject>
+#include <QPushButton>
+#include <QRadioButton>
+#include <QRegularExpression>
+#include <QRegularExpressionValidator>
+#include <QSettings>
+#include <QSize>
+#include <QSpinBox>
+#include <QVariant>
+
+const char ADDON_MISRA[]   = "misra";
+const char CODING_STANDARD_MISRA_C_2023[] = "misra-c-2023";
+const char CODING_STANDARD_MISRA_C_2025[] = "misra-c-2025";
+const char CODING_STANDARD_MISRA_CPP_2008[] = "misra-cpp-2008";
+const char CODING_STANDARD_MISRA_CPP_2023[] = "misra-cpp-2023";
+const char CODING_STANDARD_CERT_C[] = "cert-c-2016";
+const char CODING_STANDARD_CERT_CPP[] = "cert-cpp-2016";
+const char CODING_STANDARD_AUTOSAR[] = "autosar";
+const char CODING_STANDARD_SAFETY_PROFILES[] = "safety-profiles";
 
 /** Return paths from QListWidget */
 static QStringList getPaths(const QListWidget *list)
@@ -47,24 +82,56 @@ static QStringList getPaths(const QListWidget *list)
 }
 
 /** Platforms shown in the platform combobox */
-static const cppcheck::Platform::PlatformType builtinPlatforms[] = {
-    cppcheck::Platform::Native,
-    cppcheck::Platform::Win32A,
-    cppcheck::Platform::Win32W,
-    cppcheck::Platform::Win64,
-    cppcheck::Platform::Unix32,
-    cppcheck::Platform::Unix64
+static const std::array<Platform::Type, 6> builtinPlatforms = {
+    Platform::Type::Native,
+    Platform::Type::Win32A,
+    Platform::Type::Win32W,
+    Platform::Type::Win64,
+    Platform::Type::Unix32,
+    Platform::Type::Unix64
 };
 
-static const int numberOfBuiltinPlatforms = sizeof(builtinPlatforms) / sizeof(builtinPlatforms[0]);
-
-ProjectFileDialog::ProjectFileDialog(ProjectFile *projectFile, QWidget *parent)
+static std::string suppressionAsText(const SuppressionList::Suppression& s)
+{
+    std::string ret;
+    if (!s.errorId.empty())
+        ret = s.errorId;
+    if (!s.fileName.empty())
+        ret += " fileName=" + s.fileName;
+    if (s.lineNumber != SuppressionList::Suppression::NO_LINE)
+        ret += " lineNumber=" + std::to_string(s.lineNumber);
+    if (!s.symbolName.empty())
+        ret += " symbolName=" + s.symbolName;
+    if (s.hash > 0)
+        ret += " hash=" + std::to_string(s.hash);
+    if (startsWith(ret," "))
+        return ret.substr(1);
+    return ret;
+}
+
+QStringList ProjectFileDialog::getProjectConfigs(const QString &fileName)
+{
+    if (!fileName.endsWith(".sln") && !fileName.endsWith(".vcxproj"))
+        return QStringList();
+    QStringList ret;
+    ImportProject importer;
+    Settings projSettings;
+    Suppressions projSupprs;
+    importer.import(fileName.toStdString(), &projSettings, &projSupprs);
+    for (const std::string &cfg : importer.getVSConfigs())
+        ret << QString::fromStdString(cfg);
+    return ret;
+}
+
+ProjectFileDialog::ProjectFileDialog(ProjectFile *projectFile, bool premium, QWidget *parent)
     : QDialog(parent)
+    , mUI(new Ui::ProjectFile)
     , mProjectFile(projectFile)
+    , mPremium(premium)
 {
-    mUI.setupUi(this);
+    mUI->setupUi(this);
 
-    mUI.mToolClangAnalyzer->hide();
+    mUI->mToolClangAnalyzer->hide();
 
     const QFileInfo inf(projectFile->getFilename());
     QString filename = inf.fileName();
@@ -72,35 +139,24 @@ ProjectFileDialog::ProjectFileDialog(ProjectFile *projectFile, QWidget *parent)
     setWindowTitle(title);
     loadSettings();
 
-    // Checkboxes for the libraries..
-    const QString applicationFilePath = QCoreApplication::applicationFilePath();
-    const QString appPath = QFileInfo(applicationFilePath).canonicalPath();
-    QSettings settings;
-    const QString datadir = settings.value("DATADIR",QString()).toString();
-    QStringList searchPaths;
-    searchPaths << appPath << appPath + "/cfg" << inf.canonicalPath();
-#ifdef FILESDIR
-    if (FILESDIR[0])
-        searchPaths << FILESDIR << FILESDIR "/cfg";
-#endif
-    if (!datadir.isEmpty())
-        searchPaths << datadir << datadir + "/cfg";
+    mUI->premiumLicense->setVisible(false);
+
     QStringList libs;
     // Search the std.cfg first since other libraries could depend on it
     QString stdLibraryFilename;
-    foreach (const QString sp, searchPaths) {
+    for (const QString &sp : projectFile->getSearchPaths("cfg")) {
         QDir dir(sp);
         dir.setSorting(QDir::Name);
         dir.setNameFilters(QStringList("*.cfg"));
         dir.setFilter(QDir::Files | QDir::NoDotAndDotDot);
-        foreach (QFileInfo item, dir.entryInfoList()) {
+        for (const QFileInfo& item : dir.entryInfoList()) {
             QString library = item.fileName();
             if (library.compare("std.cfg", Qt::CaseInsensitive) != 0)
                 continue;
             Library lib;
             const QString fullfilename = sp + "/" + library;
             const Library::Error err = lib.load(nullptr, fullfilename.toLatin1());
-            if (err.errorcode != Library::OK)
+            if (err.errorcode != Library::ErrorCode::OK)
                 continue;
             // Working std.cfg found
             stdLibraryFilename = fullfilename;
@@ -110,23 +166,23 @@ ProjectFileDialog::ProjectFileDialog(ProjectFile *projectFile, QWidget *parent)
             break;
     }
     // Search other libraries
-    foreach (const QString sp, searchPaths) {
+    for (const QString &sp : projectFile->getSearchPaths("cfg")) {
         QDir dir(sp);
         dir.setSorting(QDir::Name);
         dir.setNameFilters(QStringList("*.cfg"));
         dir.setFilter(QDir::Files | QDir::NoDotAndDotDot);
-        foreach (QFileInfo item, dir.entryInfoList()) {
+        for (const QFileInfo& item : dir.entryInfoList()) {
             QString library = item.fileName();
             {
                 Library lib;
                 const QString fullfilename = sp + "/" + library;
                 Library::Error err = lib.load(nullptr, fullfilename.toLatin1());
-                if (err.errorcode != Library::OK) {
+                if (err.errorcode != Library::ErrorCode::OK) {
                     // Some libraries depend on std.cfg so load it first and test again
                     lib.load(nullptr, stdLibraryFilename.toLatin1());
                     err = lib.load(nullptr, fullfilename.toLatin1());
                 }
-                if (err.errorcode != Library::OK)
+                if (err.errorcode != Library::ErrorCode::OK)
                     continue;
             }
             library.chop(4);
@@ -137,30 +193,27 @@ ProjectFileDialog::ProjectFileDialog(ProjectFile *projectFile, QWidget *parent)
         }
     }
     libs.sort();
-    mUI.mLibraries->clear();
-    for (const QString &lib : libs) {
-        QListWidgetItem* item = new QListWidgetItem(lib, mUI.mLibraries);
+    mUI->mLibraries->clear();
+    for (const QString &lib : utils::as_const(libs)) {
+        auto* item = new QListWidgetItem(lib, mUI->mLibraries);
         item->setFlags(item->flags() | Qt::ItemIsUserCheckable); // set checkable flag
         item->setCheckState(Qt::Unchecked); // AND initialize check state
     }
 
     // Platforms..
     Platforms platforms;
-    for (int i = 0; i < numberOfBuiltinPlatforms; i++)
-        mUI.mComboBoxPlatform->addItem(platforms.get(builtinPlatforms[i]).mTitle);
+    for (const Platform::Type builtinPlatform : builtinPlatforms)
+        mUI->mComboBoxPlatform->addItem(platforms.get(builtinPlatform).mTitle);
     QStringList platformFiles;
-    foreach (QString sp, searchPaths) {
-        if (sp.endsWith("/cfg"))
-            sp = sp.mid(0,sp.length()-3) + "platforms";
+    for (const QString& sp : projectFile->getSearchPaths("platforms")) {
         QDir dir(sp);
         dir.setSorting(QDir::Name);
         dir.setNameFilters(QStringList("*.xml"));
         dir.setFilter(QDir::Files | QDir::NoDotAndDotDot);
-        foreach (QFileInfo item, dir.entryInfoList()) {
+        for (const QFileInfo& item : dir.entryInfoList()) {
             const QString platformFile = item.fileName();
-
-            cppcheck::Platform plat2;
-            if (!plat2.loadPlatformFile(applicationFilePath.toStdString().c_str(), platformFile.toStdString()))
+            Platform plat2;
+            if (!plat2.loadFromFile({sp.toStdString()}, platformFile.toStdString()))
                 continue;
 
             if (platformFiles.indexOf(platformFile) == -1)
@@ -168,39 +221,44 @@ ProjectFileDialog::ProjectFileDialog(ProjectFile *projectFile, QWidget *parent)
         }
     }
     platformFiles.sort();
-    mUI.mComboBoxPlatform->addItems(platformFiles);
-
-    mUI.mEditTags->setValidator(new QRegExpValidator(QRegExp("[a-zA-Z0-9 ;]*"),this));
-
-    const QRegExp undefRegExp("\\s*([a-zA-Z_][a-zA-Z0-9_]*[; ]*)*");
-    mUI.mEditUndefines->setValidator(new QRegExpValidator(undefRegExp, this));
-
-    connect(mUI.mButtons, &QDialogButtonBox::accepted, this, &ProjectFileDialog::ok);
-    connect(mUI.mBtnBrowseBuildDir, &QPushButton::clicked, this, &ProjectFileDialog::browseBuildDir);
-    connect(mUI.mBtnClearImportProject, &QPushButton::clicked, this, &ProjectFileDialog::clearImportProject);
-    connect(mUI.mBtnBrowseImportProject, &QPushButton::clicked, this, &ProjectFileDialog::browseImportProject);
-    connect(mUI.mBtnAddCheckPath, SIGNAL(clicked()), this, SLOT(addCheckPath()));
-    connect(mUI.mBtnEditCheckPath, &QPushButton::clicked, this, &ProjectFileDialog::editCheckPath);
-    connect(mUI.mBtnRemoveCheckPath, &QPushButton::clicked, this, &ProjectFileDialog::removeCheckPath);
-    connect(mUI.mBtnAddInclude, SIGNAL(clicked()), this, SLOT(addIncludeDir()));
-    connect(mUI.mBtnEditInclude, &QPushButton::clicked, this, &ProjectFileDialog::editIncludeDir);
-    connect(mUI.mBtnRemoveInclude, &QPushButton::clicked, this, &ProjectFileDialog::removeIncludeDir);
-    connect(mUI.mBtnAddIgnorePath, SIGNAL(clicked()), this, SLOT(addExcludePath()));
-    connect(mUI.mBtnEditIgnorePath, &QPushButton::clicked, this, &ProjectFileDialog::editExcludePath);
-    connect(mUI.mBtnRemoveIgnorePath, &QPushButton::clicked, this, &ProjectFileDialog::removeExcludePath);
-    connect(mUI.mBtnIncludeUp, &QPushButton::clicked, this, &ProjectFileDialog::moveIncludePathUp);
-    connect(mUI.mBtnIncludeDown, &QPushButton::clicked, this, &ProjectFileDialog::moveIncludePathDown);
-    connect(mUI.mBtnAddSuppression, &QPushButton::clicked, this, &ProjectFileDialog::addSuppression);
-    connect(mUI.mBtnRemoveSuppression, &QPushButton::clicked, this, &ProjectFileDialog::removeSuppression);
-    connect(mUI.mListSuppressions, &QListWidget::doubleClicked, this, &ProjectFileDialog::editSuppression);
-    connect(mUI.mBtnBrowseMisraFile, &QPushButton::clicked, this, &ProjectFileDialog::browseMisraFile);
-
+    mUI->mComboBoxPlatform->addItems(platformFiles);
+
+    // integer. allow empty.
+    mUI->mEditCertIntPrecision->setValidator(new QRegularExpressionValidator(QRegularExpression("[0-9]*"),this));
+
+    mUI->mEditTags->setValidator(new QRegularExpressionValidator(QRegularExpression("[a-zA-Z0-9 ;]*"),this));
+
+    const QRegularExpression undefRegExp("\\s*([a-zA-Z_][a-zA-Z0-9_]*[; ]*)*");
+    mUI->mEditUndefines->setValidator(new QRegularExpressionValidator(undefRegExp, this));
+
+    connect(mUI->mButtons, &QDialogButtonBox::accepted, this, &ProjectFileDialog::ok);
+    connect(mUI->mBtnBrowseBuildDir, &QPushButton::clicked, this, &ProjectFileDialog::browseBuildDir);
+    connect(mUI->mBtnClearImportProject, &QPushButton::clicked, this, &ProjectFileDialog::clearImportProject);
+    connect(mUI->mBtnBrowseImportProject, &QPushButton::clicked, this, &ProjectFileDialog::browseImportProject);
+    connect(mUI->mBtnAddCheckPath, SIGNAL(clicked()), this, SLOT(addCheckPath()));
+    connect(mUI->mBtnEditCheckPath, &QPushButton::clicked, this, &ProjectFileDialog::editCheckPath);
+    connect(mUI->mBtnRemoveCheckPath, &QPushButton::clicked, this, &ProjectFileDialog::removeCheckPath);
+    connect(mUI->mBtnAddInclude, SIGNAL(clicked()), this, SLOT(addIncludeDir()));
+    connect(mUI->mBtnEditInclude, &QPushButton::clicked, this, &ProjectFileDialog::editIncludeDir);
+    connect(mUI->mBtnRemoveInclude, &QPushButton::clicked, this, &ProjectFileDialog::removeIncludeDir);
+    connect(mUI->mBtnAddIgnorePath, SIGNAL(clicked()), this, SLOT(addExcludePath()));
+    connect(mUI->mBtnAddIgnoreFile, SIGNAL(clicked()), this, SLOT(addExcludeFile()));
+    connect(mUI->mBtnEditIgnorePath, &QPushButton::clicked, this, &ProjectFileDialog::editExcludePath);
+    connect(mUI->mBtnRemoveIgnorePath, &QPushButton::clicked, this, &ProjectFileDialog::removeExcludePath);
+    connect(mUI->mBtnIncludeUp, &QPushButton::clicked, this, &ProjectFileDialog::moveIncludePathUp);
+    connect(mUI->mBtnIncludeDown, &QPushButton::clicked, this, &ProjectFileDialog::moveIncludePathDown);
+    connect(mUI->mBtnAddSuppression, &QPushButton::clicked, this, &ProjectFileDialog::addSuppression);
+    connect(mUI->mBtnRemoveSuppression, &QPushButton::clicked, this, &ProjectFileDialog::removeSuppression);
+    connect(mUI->mListSuppressions, &QListWidget::doubleClicked, this, &ProjectFileDialog::editSuppression);
+    connect(mUI->mBtnBrowseMisraFile, &QPushButton::clicked, this, &ProjectFileDialog::browseMisraFile);
+    connect(mUI->mChkAllVsConfigs, &QCheckBox::clicked, this, &ProjectFileDialog::checkAllVSConfigs);
     loadFromProjectFile(projectFile);
 }
 
 ProjectFileDialog::~ProjectFileDialog()
 {
     saveSettings();
+    delete mUI;
 }
 
 void ProjectFileDialog::loadSettings()
@@ -221,12 +279,23 @@ static void updateAddonCheckBox(QCheckBox *cb, const ProjectFile *projectFile, c
 {
     if (projectFile)
         cb->setChecked(projectFile->getAddons().contains(addon));
-    if (CheckThread::getAddonFilePath(dataDir, addon + ".py").isEmpty()) {
+    if (ProjectFile::getAddonFilePath(dataDir, addon).isEmpty()) {
         cb->setEnabled(false);
         cb->setText(cb->text() + QObject::tr(" (Not found)"));
     }
 }
 
+void ProjectFileDialog::checkAllVSConfigs()
+{
+    if (mUI->mChkAllVsConfigs->isChecked()) {
+        for (int row = 0; row < mUI->mListVsConfigs->count(); ++row) {
+            QListWidgetItem *item = mUI->mListVsConfigs->item(row);
+            item->setCheckState(Qt::Checked);
+        }
+    }
+    mUI->mListVsConfigs->setEnabled(!mUI->mChkAllVsConfigs->isChecked());
+}
+
 void ProjectFileDialog::loadFromProjectFile(const ProjectFile *projectFile)
 {
     setRootPath(projectFile->getRootPath());
@@ -236,82 +305,164 @@ void ProjectFileDialog::loadFromProjectFile(const ProjectFile *projectFile)
     setUndefines(projectFile->getUndefines());
     setCheckPaths(projectFile->getCheckPaths());
     setImportProject(projectFile->getImportProject());
-    mUI.mChkAllVsConfigs->setChecked(projectFile->getAnalyzeAllVsConfigs());
-    mUI.mCheckHeaders->setChecked(projectFile->getCheckHeaders());
-    mUI.mCheckUnusedTemplates->setChecked(projectFile->getCheckUnusedTemplates());
-    mUI.mMaxCtuDepth->setValue(projectFile->getMaxCtuDepth());
+    mUI->mChkAllVsConfigs->setChecked(projectFile->getAnalyzeAllVsConfigs());
+    setProjectConfigurations(getProjectConfigs(mUI->mEditImportProject->text()));
+    for (int row = 0; row < mUI->mListVsConfigs->count(); ++row) {
+        QListWidgetItem *item = mUI->mListVsConfigs->item(row);
+        if (projectFile->getAnalyzeAllVsConfigs() || projectFile->getVsConfigurations().contains(item->text()))
+            item->setCheckState(Qt::Checked);
+        else
+            item->setCheckState(Qt::Unchecked);
+    }
+    switch (projectFile->getCheckLevel()) {
+    case ProjectFile::CheckLevel::reduced:
+        mUI->mCheckLevelReduced->setChecked(true);
+        break;
+    case ProjectFile::CheckLevel::normal:
+        mUI->mCheckLevelNormal->setChecked(true);
+        break;
+    case ProjectFile::CheckLevel::exhaustive:
+        mUI->mCheckLevelExhaustive->setChecked(true);
+        break;
+    }
+    mUI->mCheckHeaders->setChecked(projectFile->getCheckHeaders());
+    mUI->mCheckUnusedTemplates->setChecked(projectFile->getCheckUnusedTemplates());
+    mUI->mInlineSuppressions->setChecked(projectFile->getInlineSuppression());
+    mUI->mMaxCtuDepth->setValue(projectFile->getMaxCtuDepth());
+    mUI->mMaxTemplateRecursion->setValue(projectFile->getMaxTemplateRecursion());
+    if (projectFile->clangParser)
+        mUI->mBtnClangParser->setChecked(true);
+    else
+        mUI->mBtnCppcheckParser->setChecked(true);
+    mUI->mBtnSafeClasses->setChecked(projectFile->safeChecks.classes);
     setExcludedPaths(projectFile->getExcludedPaths());
     setLibraries(projectFile->getLibraries());
-    const QString platform = projectFile->getPlatform();
+    const QString& platform = projectFile->getPlatform();
     if (platform.endsWith(".xml")) {
         int i;
-        for (i = numberOfBuiltinPlatforms; i < mUI.mComboBoxPlatform->count(); ++i) {
-            if (mUI.mComboBoxPlatform->itemText(i) == platform)
+        for (i = builtinPlatforms.size(); i < mUI->mComboBoxPlatform->count(); ++i) {
+            if (mUI->mComboBoxPlatform->itemText(i) == platform)
                 break;
         }
-        if (i < mUI.mComboBoxPlatform->count())
-            mUI.mComboBoxPlatform->setCurrentIndex(i);
+        if (i < mUI->mComboBoxPlatform->count())
+            mUI->mComboBoxPlatform->setCurrentIndex(i);
         else {
-            mUI.mComboBoxPlatform->addItem(platform);
-            mUI.mComboBoxPlatform->setCurrentIndex(i);
+            mUI->mComboBoxPlatform->addItem(platform);
+            mUI->mComboBoxPlatform->setCurrentIndex(i);
         }
     } else {
         int i;
-        for (i = 0; i < numberOfBuiltinPlatforms; ++i) {
-            const cppcheck::Platform::PlatformType p = builtinPlatforms[i];
-            if (platform == cppcheck::Platform::platformString(p))
+        for (i = 0; i < builtinPlatforms.size(); ++i) {
+            const Platform::Type p = builtinPlatforms[i];
+            if (platform == Platform::toString(p))
                 break;
         }
-        if (i < numberOfBuiltinPlatforms)
-            mUI.mComboBoxPlatform->setCurrentIndex(i);
+        if (i < builtinPlatforms.size())
+            mUI->mComboBoxPlatform->setCurrentIndex(i);
         else
-            mUI.mComboBoxPlatform->setCurrentIndex(-1);
+            mUI->mComboBoxPlatform->setCurrentIndex(-1);
     }
 
-    mUI.mComboBoxPlatform->setCurrentText(projectFile->getPlatform());
+    mUI->mComboBoxPlatform->setCurrentText(projectFile->getPlatform());
     setSuppressions(projectFile->getSuppressions());
 
+    // TODO
     // Human knowledge..
     /*
-    mUI.mListUnknownFunctionReturn->clear();
-    mUI.mListUnknownFunctionReturn->addItem("rand()");
-    for (int row = 0; row < mUI.mListUnknownFunctionReturn->count(); ++row) {
-        QListWidgetItem *item = mUI.mListUnknownFunctionReturn->item(row);
+       mUI->mListUnknownFunctionReturn->clear();
+       mUI->mListUnknownFunctionReturn->addItem("rand()");
+       for (int row = 0; row < mUI->mListUnknownFunctionReturn->count(); ++row) {
+        QListWidgetItem *item = mUI->mListUnknownFunctionReturn->item(row);
         item->setFlags(item->flags() | Qt::ItemIsUserCheckable); // set checkable flag
         const bool unknownValues = projectFile->getCheckUnknownFunctionReturn().contains(item->text());
         item->setCheckState(unknownValues ? Qt::Checked : Qt::Unchecked); // AND initialize check state
-    }
-    mUI.mCheckSafeClasses->setChecked(projectFile->getSafeChecks().classes);
-    mUI.mCheckSafeExternalFunctions->setChecked(projectFile->getSafeChecks().externalFunctions);
-    mUI.mCheckSafeInternalFunctions->setChecked(projectFile->getSafeChecks().internalFunctions);
-    mUI.mCheckSafeExternalVariables->setChecked(projectFile->getSafeChecks().externalVariables);
-    */
+       }
+       mUI->mCheckSafeClasses->setChecked(projectFile->getSafeChecks().classes);
+       mUI->mCheckSafeExternalFunctions->setChecked(projectFile->getSafeChecks().externalFunctions);
+       mUI->mCheckSafeInternalFunctions->setChecked(projectFile->getSafeChecks().internalFunctions);
+       mUI->mCheckSafeExternalVariables->setChecked(projectFile->getSafeChecks().externalVariables);
+     */
 
     // Addons..
     QSettings settings;
-    const QString dataDir = settings.value("DATADIR", QString()).toString();
-    updateAddonCheckBox(mUI.mAddonThreadSafety, projectFile, dataDir, "threadsafety");
-    updateAddonCheckBox(mUI.mAddonY2038, projectFile, dataDir, "y2038");
-    updateAddonCheckBox(mUI.mAddonCert, projectFile, dataDir, "cert");
-    updateAddonCheckBox(mUI.mAddonMisra, projectFile, dataDir, "misra");
+    const QString dataDir = getDataDir();
+    updateAddonCheckBox(mUI->mAddonThreadSafety, projectFile, dataDir, "threadsafety");
+    updateAddonCheckBox(mUI->mAddonY2038, projectFile, dataDir, "y2038");
+
+    // Misra checkbox..
+    if (mPremium)
+        mUI->mMisraC->setText("Misra C");
+    else {
+        mUI->mMisraC->setText("Misra C 2012  " + tr("Note: Open source Cppcheck does not fully implement Misra C 2012"));
+    }
+    updateAddonCheckBox(mUI->mMisraC, projectFile, dataDir, ADDON_MISRA);
+    mUI->mMisraVersion->setEnabled(mUI->mMisraC->isChecked());
+    connect(mUI->mMisraC, &QCheckBox::toggled, mUI->mMisraVersion, &QComboBox::setEnabled);
 
     const QString &misraFile = settings.value(SETTINGS_MISRA_FILE, QString()).toString();
-    mUI.mEditMisraFile->setText(misraFile);
-    if (!mUI.mAddonMisra->isEnabled()) {
-        mUI.mEditMisraFile->setEnabled(false);
-        mUI.mBtnBrowseMisraFile->setEnabled(false);
-    } else if (misraFile.isEmpty()) {
-        mUI.mAddonMisra->setEnabled(false);
-        mUI.mAddonMisra->setText(mUI.mAddonMisra->text() + ' ' + tr("(no rule texts file)"));
+    mUI->mEditMisraFile->setText(misraFile);
+    mUI->mMisraVersion->setVisible(mPremium);
+    if (projectFile->getCodingStandards().contains(CODING_STANDARD_MISRA_C_2023))
+        mUI->mMisraVersion->setCurrentIndex(1);
+    else if (projectFile->getCodingStandards().contains(CODING_STANDARD_MISRA_C_2025))
+        mUI->mMisraVersion->setCurrentIndex(2);
+    else if (projectFile->getAddons().contains(ADDON_MISRA))
+        mUI->mMisraVersion->setCurrentIndex(0);
+    else
+        mUI->mMisraVersion->setCurrentIndex(-1);
+    if (mPremium) {
+        mUI->mLabelMisraFile->setVisible(false);
+        mUI->mEditMisraFile->setVisible(false);
+        mUI->mBtnBrowseMisraFile->setVisible(false);
+    } else if (!mUI->mMisraC->isEnabled()) {
+        mUI->mEditMisraFile->setEnabled(false);
+        mUI->mBtnBrowseMisraFile->setEnabled(false);
+    }
+
+    mUI->mMisraCpp->setEnabled(mPremium);
+    mUI->mMisraCppVersion->setVisible(mPremium);
+    if (projectFile->getCodingStandards().contains(CODING_STANDARD_MISRA_CPP_2008)) {
+        mUI->mMisraCpp->setChecked(true);
+        mUI->mMisraCppVersion->setCurrentIndex(0);
+    }
+    else if (projectFile->getCodingStandards().contains(CODING_STANDARD_MISRA_CPP_2023)) {
+        mUI->mMisraCpp->setChecked(true);
+        mUI->mMisraCppVersion->setCurrentIndex(1);
+    } else {
+        mUI->mMisraCpp->setChecked(false);
+        mUI->mMisraCppVersion->setCurrentIndex(1);
     }
 
-    mUI.mToolClangAnalyzer->setChecked(projectFile->getClangAnalyzer());
-    mUI.mToolClangTidy->setChecked(projectFile->getClangTidy());
+    mUI->mMisraCppVersion->setEnabled(mUI->mMisraCpp->isChecked());
+    connect(mUI->mMisraCpp, &QCheckBox::toggled, mUI->mMisraCppVersion, &QComboBox::setEnabled);
+
+    mUI->mCertC2016->setChecked(mPremium && projectFile->getCodingStandards().contains(CODING_STANDARD_CERT_C));
+    mUI->mCertCpp2016->setChecked(mPremium && projectFile->getCodingStandards().contains(CODING_STANDARD_CERT_CPP));
+    mUI->mAutosar->setChecked(mPremium && projectFile->getCodingStandards().contains(CODING_STANDARD_AUTOSAR));
+    mUI->mSafetyProfiles->setChecked(mPremium && projectFile->getCodingStandards().contains(CODING_STANDARD_SAFETY_PROFILES));
+
+    if (projectFile->getCertIntPrecision() <= 0)
+        mUI->mEditCertIntPrecision->setText(QString());
+    else
+        mUI->mEditCertIntPrecision->setText(QString::number(projectFile->getCertIntPrecision()));
+
+    mUI->mCertC2016->setEnabled(mPremium);
+    mUI->mCertCpp2016->setEnabled(mPremium);
+    mUI->mAutosar->setEnabled(mPremium);
+    mUI->mSafetyProfiles->setEnabled(mPremium);
+    mUI->mLabelCertIntPrecision->setVisible(mPremium);
+    mUI->mEditCertIntPrecision->setVisible(mPremium);
+    mUI->mBughunting->setChecked(mPremium && projectFile->getBughunting());
+    mUI->mBughunting->setEnabled(mPremium);
+
+    mUI->mToolClangAnalyzer->setChecked(projectFile->getClangAnalyzer());
+    mUI->mToolClangTidy->setChecked(projectFile->getClangTidy());
     if (CheckThread::clangTidyCmd().isEmpty()) {
-        mUI.mToolClangTidy->setText(tr("Clang-tidy (not found)"));
-        mUI.mToolClangTidy->setEnabled(false);
+        mUI->mToolClangTidy->setText(tr("Clang-tidy (not found)"));
+        mUI->mToolClangTidy->setEnabled(false);
     }
-    mUI.mEditTags->setText(projectFile->getTags().join(';'));
+    mUI->mEditTags->setText(projectFile->getTags().join(';'));
+    mUI->mEditLicenseFile->setText(projectFile->getLicenseFile());
     updatePathsAndDefines();
 }
 
@@ -320,56 +471,86 @@ void ProjectFileDialog::saveToProjectFile(ProjectFile *projectFile) const
     projectFile->setRootPath(getRootPath());
     projectFile->setBuildDir(getBuildDir());
     projectFile->setImportProject(getImportProject());
-    projectFile->setAnalyzeAllVsConfigs(mUI.mChkAllVsConfigs->isChecked());
-    projectFile->setCheckHeaders(mUI.mCheckHeaders->isChecked());
-    projectFile->setCheckUnusedTemplates(mUI.mCheckUnusedTemplates->isChecked());
-    projectFile->setMaxCtuDepth(mUI.mMaxCtuDepth->value());
+    projectFile->setAnalyzeAllVsConfigs(mUI->mChkAllVsConfigs->isChecked());
+    projectFile->setVSConfigurations(getProjectConfigurations());
+    projectFile->setCheckHeaders(mUI->mCheckHeaders->isChecked());
+    projectFile->setCheckUnusedTemplates(mUI->mCheckUnusedTemplates->isChecked());
+    projectFile->setInlineSuppression(mUI->mInlineSuppressions->isChecked());
+    projectFile->setMaxCtuDepth(mUI->mMaxCtuDepth->value());
+    projectFile->setMaxTemplateRecursion(mUI->mMaxTemplateRecursion->value());
     projectFile->setIncludes(getIncludePaths());
     projectFile->setDefines(getDefines());
     projectFile->setUndefines(getUndefines());
     projectFile->setCheckPaths(getCheckPaths());
     projectFile->setExcludedPaths(getExcludedPaths());
     projectFile->setLibraries(getLibraries());
-    if (mUI.mComboBoxPlatform->currentText().endsWith(".xml"))
-        projectFile->setPlatform(mUI.mComboBoxPlatform->currentText());
+    if (mUI->mCheckLevelReduced->isChecked())
+        projectFile->setCheckLevel(ProjectFile::CheckLevel::reduced);
+    else if (mUI->mCheckLevelNormal->isChecked())
+        projectFile->setCheckLevel(ProjectFile::CheckLevel::normal);
+    else // if (mUI->mCheckLevelExhaustive->isChecked())
+        projectFile->setCheckLevel(ProjectFile::CheckLevel::exhaustive);
+    projectFile->clangParser = mUI->mBtnClangParser->isChecked();
+    projectFile->safeChecks.classes = mUI->mBtnSafeClasses->isChecked();
+    if (mUI->mComboBoxPlatform->currentText().endsWith(".xml"))
+        projectFile->setPlatform(mUI->mComboBoxPlatform->currentText());
     else {
-        int i = mUI.mComboBoxPlatform->currentIndex();
-        if (i < numberOfBuiltinPlatforms)
-            projectFile->setPlatform(cppcheck::Platform::platformString(builtinPlatforms[i]));
+        const int i = mUI->mComboBoxPlatform->currentIndex();
+        if (i>=0 && i < builtinPlatforms.size())
+            projectFile->setPlatform(Platform::toString(builtinPlatforms[i]));
         else
             projectFile->setPlatform(QString());
     }
     projectFile->setSuppressions(getSuppressions());
     // Human knowledge
     /*
-    QStringList unknownReturnValues;
-    for (int row = 0; row < mUI.mListUnknownFunctionReturn->count(); ++row) {
-        QListWidgetItem *item = mUI.mListUnknownFunctionReturn->item(row);
+       QStringList unknownReturnValues;
+       for (int row = 0; row < mUI->mListUnknownFunctionReturn->count(); ++row) {
+        QListWidgetItem *item = mUI->mListUnknownFunctionReturn->item(row);
         if (item->checkState() == Qt::Checked)
             unknownReturnValues << item->text();
-    }
-    projectFile->setCheckUnknownFunctionReturn(unknownReturnValues);
-    ProjectFile::SafeChecks safeChecks;
-    safeChecks.classes = mUI.mCheckSafeClasses->isChecked();
-    safeChecks.externalFunctions = mUI.mCheckSafeExternalFunctions->isChecked();
-    safeChecks.internalFunctions = mUI.mCheckSafeInternalFunctions->isChecked();
-    safeChecks.externalVariables = mUI.mCheckSafeExternalVariables->isChecked();
-    projectFile->setSafeChecks(safeChecks);
-    */
+       }
+       projectFile->setCheckUnknownFunctionReturn(unknownReturnValues);
+       ProjectFile::SafeChecks safeChecks;
+       safeChecks.classes = mUI->mCheckSafeClasses->isChecked();
+       safeChecks.externalFunctions = mUI->mCheckSafeExternalFunctions->isChecked();
+       safeChecks.internalFunctions = mUI->mCheckSafeInternalFunctions->isChecked();
+       safeChecks.externalVariables = mUI->mCheckSafeExternalVariables->isChecked();
+       projectFile->setSafeChecks(safeChecks);
+     */
     // Addons
-    QStringList list;
-    if (mUI.mAddonThreadSafety->isChecked())
-        list << "threadsafety";
-    if (mUI.mAddonY2038->isChecked())
-        list << "y2038";
-    if (mUI.mAddonCert->isChecked())
-        list << "cert";
-    if (mUI.mAddonMisra->isChecked())
-        list << "misra";
-    projectFile->setAddons(list);
-    projectFile->setClangAnalyzer(mUI.mToolClangAnalyzer->isChecked());
-    projectFile->setClangTidy(mUI.mToolClangTidy->isChecked());
-    projectFile->setTags(mUI.mEditTags->text().split(";", QString::SkipEmptyParts));
+    QStringList addons;
+    if (mUI->mAddonThreadSafety->isChecked())
+        addons << "threadsafety";
+    if (mUI->mAddonY2038->isChecked())
+        addons << "y2038";
+    if (mUI->mMisraC->isChecked())
+        addons << ADDON_MISRA;
+    projectFile->setAddons(addons);
+    QStringList codingStandards;
+    if (mUI->mCertC2016->isChecked())
+        codingStandards << CODING_STANDARD_CERT_C;
+    if (mUI->mCertCpp2016->isChecked())
+        codingStandards << CODING_STANDARD_CERT_CPP;
+    if (mPremium && mUI->mMisraVersion->currentIndex() == 1)
+        codingStandards << CODING_STANDARD_MISRA_C_2023;
+    if (mPremium && mUI->mMisraVersion->currentIndex() == 2)
+        codingStandards << CODING_STANDARD_MISRA_C_2025;
+    if (mUI->mMisraCpp->isChecked() && mUI->mMisraCppVersion->currentIndex() == 0)
+        codingStandards << CODING_STANDARD_MISRA_CPP_2008;
+    if (mUI->mMisraCpp->isChecked() && mUI->mMisraCppVersion->currentIndex() == 1)
+        codingStandards << CODING_STANDARD_MISRA_CPP_2023;
+    if (mUI->mAutosar->isChecked())
+        codingStandards << CODING_STANDARD_AUTOSAR;
+    if (mUI->mSafetyProfiles->isChecked())
+        codingStandards << CODING_STANDARD_SAFETY_PROFILES;
+    projectFile->setCodingStandards(std::move(codingStandards));
+    projectFile->setCertIntPrecision(mUI->mEditCertIntPrecision->text().toInt());
+    projectFile->setBughunting(mUI->mBughunting->isChecked());
+    projectFile->setClangAnalyzer(mUI->mToolClangAnalyzer->isChecked());
+    projectFile->setClangTidy(mUI->mToolClangTidy->isChecked());
+    projectFile->setLicenseFile(mUI->mEditLicenseFile->text());
+    projectFile->setTags(mUI->mEditTags->text().split(";", Qt::SkipEmptyParts));
 }
 
 void ProjectFileDialog::ok()
@@ -382,17 +563,17 @@ void ProjectFileDialog::ok()
 QString ProjectFileDialog::getExistingDirectory(const QString &caption, bool trailingSlash)
 {
     const QFileInfo inf(mProjectFile->getFilename());
-    const QString rootpath = inf.absolutePath();
+    const QString projectPath = inf.absolutePath();
     QString selectedDir = QFileDialog::getExistingDirectory(this,
-                          caption,
-                          rootpath);
+                                                            caption,
+                                                            projectPath);
 
     if (selectedDir.isEmpty())
         return QString();
 
     // Check if the path is relative to project file's path and if so
     // make it a relative path instead of absolute path.
-    const QDir dir(rootpath);
+    const QDir dir(projectPath);
     const QString relpath(dir.relativeFilePath(selectedDir));
     if (!relpath.startsWith("../.."))
         selectedDir = relpath;
@@ -408,32 +589,35 @@ void ProjectFileDialog::browseBuildDir()
 {
     const QString dir(getExistingDirectory(tr("Select Cppcheck build dir"), false));
     if (!dir.isEmpty())
-        mUI.mEditBuildDir->setText(dir);
+        mUI->mEditBuildDir->setText(dir);
 }
 
 void ProjectFileDialog::updatePathsAndDefines()
 {
-    const QString &fileName = mUI.mEditImportProject->text();
-    bool importProject = !fileName.isEmpty();
-    mUI.mBtnClearImportProject->setEnabled(importProject);
-    mUI.mListCheckPaths->setEnabled(!importProject);
-    mUI.mListIncludeDirs->setEnabled(!importProject);
-    mUI.mBtnAddCheckPath->setEnabled(!importProject);
-    mUI.mBtnEditCheckPath->setEnabled(!importProject);
-    mUI.mBtnRemoveCheckPath->setEnabled(!importProject);
-    mUI.mEditDefines->setEnabled(!importProject);
-    mUI.mEditUndefines->setEnabled(!importProject);
-    mUI.mBtnAddInclude->setEnabled(!importProject);
-    mUI.mBtnEditInclude->setEnabled(!importProject);
-    mUI.mBtnRemoveInclude->setEnabled(!importProject);
-    mUI.mBtnIncludeUp->setEnabled(!importProject);
-    mUI.mBtnIncludeDown->setEnabled(!importProject);
-    mUI.mChkAllVsConfigs->setEnabled(fileName.endsWith(".sln") || fileName.endsWith(".vcxproj"));
+    const QString &fileName = mUI->mEditImportProject->text();
+    const bool importProject = !fileName.isEmpty();
+    const bool hasConfigs = fileName.endsWith(".sln") || fileName.endsWith(".vcxproj");
+    mUI->mBtnClearImportProject->setEnabled(importProject);
+    mUI->mListCheckPaths->setEnabled(!importProject);
+    mUI->mListIncludeDirs->setEnabled(!importProject);
+    mUI->mBtnAddCheckPath->setEnabled(!importProject);
+    mUI->mBtnEditCheckPath->setEnabled(!importProject);
+    mUI->mBtnRemoveCheckPath->setEnabled(!importProject);
+    mUI->mEditUndefines->setEnabled(!importProject);
+    mUI->mBtnAddInclude->setEnabled(!importProject);
+    mUI->mBtnEditInclude->setEnabled(!importProject);
+    mUI->mBtnRemoveInclude->setEnabled(!importProject);
+    mUI->mBtnIncludeUp->setEnabled(!importProject);
+    mUI->mBtnIncludeDown->setEnabled(!importProject);
+    mUI->mChkAllVsConfigs->setEnabled(hasConfigs);
+    mUI->mListVsConfigs->setEnabled(hasConfigs && !mUI->mChkAllVsConfigs->isChecked());
+    if (!hasConfigs)
+        mUI->mListVsConfigs->clear();
 }
 
 void ProjectFileDialog::clearImportProject()
 {
-    mUI.mEditImportProject->clear();
+    mUI->mEditImportProject->clear();
     updatePathsAndDefines();
 }
 
@@ -446,55 +630,82 @@ void ProjectFileDialog::browseImportProject()
     filters[tr("Compile database")] = "compile_commands.json";
     filters[tr("Borland C++ Builder 6")] = "*.bpr";
     QString fileName = QFileDialog::getOpenFileName(this, tr("Import Project"),
-                       dir.canonicalPath(),
-                       toFilterString(filters));
+                                                    dir.canonicalPath(),
+                                                    toFilterString(filters));
     if (!fileName.isEmpty()) {
-        mUI.mEditImportProject->setText(dir.relativeFilePath(fileName));
+        mUI->mEditImportProject->setText(dir.relativeFilePath(fileName));
         updatePathsAndDefines();
+        setProjectConfigurations(getProjectConfigs(fileName));
+        for (int row = 0; row < mUI->mListVsConfigs->count(); ++row) {
+            QListWidgetItem *item = mUI->mListVsConfigs->item(row);
+            item->setCheckState(Qt::Checked);
+        }
+    }
+}
+
+QStringList ProjectFileDialog::getProjectConfigurations() const
+{
+    QStringList configs;
+    for (int row = 0; row < mUI->mListVsConfigs->count(); ++row) {
+        QListWidgetItem *item = mUI->mListVsConfigs->item(row);
+        if (item->checkState() == Qt::Checked)
+            configs << item->text();
+    }
+    return configs;
+}
+
+void ProjectFileDialog::setProjectConfigurations(const QStringList &configs)
+{
+    mUI->mListVsConfigs->clear();
+    mUI->mListVsConfigs->setEnabled(!configs.isEmpty() && !mUI->mChkAllVsConfigs->isChecked());
+    for (const QString &cfg : configs) {
+        auto* item = new QListWidgetItem(cfg, mUI->mListVsConfigs);
+        item->setFlags(item->flags() | Qt::ItemIsUserCheckable); // set checkable flag
+        item->setCheckState(Qt::Unchecked);
     }
 }
 
 QString ProjectFileDialog::getImportProject() const
 {
-    return mUI.mEditImportProject->text();
+    return mUI->mEditImportProject->text();
 }
 
 void ProjectFileDialog::addIncludeDir(const QString &dir)
 {
-    if (dir.isNull() || dir.isEmpty())
+    if (dir.isEmpty())
         return;
 
     const QString newdir = QDir::toNativeSeparators(dir);
-    QListWidgetItem *item = new QListWidgetItem(newdir);
+    auto *item = new QListWidgetItem(newdir);
     item->setFlags(item->flags() | Qt::ItemIsEditable);
-    mUI.mListIncludeDirs->addItem(item);
+    mUI->mListIncludeDirs->addItem(item);
 }
 
 void ProjectFileDialog::addCheckPath(const QString &path)
 {
-    if (path.isNull() || path.isEmpty())
+    if (path.isEmpty())
         return;
 
     const QString newpath = QDir::toNativeSeparators(path);
-    QListWidgetItem *item = new QListWidgetItem(newpath);
+    auto *item = new QListWidgetItem(newpath);
     item->setFlags(item->flags() | Qt::ItemIsEditable);
-    mUI.mListCheckPaths->addItem(item);
+    mUI->mListCheckPaths->addItem(item);
 }
 
 void ProjectFileDialog::addExcludePath(const QString &path)
 {
-    if (path.isNull() || path.isEmpty())
+    if (path.isEmpty())
         return;
 
     const QString newpath = QDir::toNativeSeparators(path);
-    QListWidgetItem *item = new QListWidgetItem(newpath);
+    auto *item = new QListWidgetItem(newpath);
     item->setFlags(item->flags() | Qt::ItemIsEditable);
-    mUI.mListExcludedPaths->addItem(item);
+    mUI->mListExcludedPaths->addItem(item);
 }
 
 QString ProjectFileDialog::getRootPath() const
 {
-    QString root = mUI.mEditProjectRoot->text();
+    QString root = mUI->mEditProjectRoot->text();
     root = root.trimmed();
     root = QDir::fromNativeSeparators(root);
     return root;
@@ -502,42 +713,42 @@ QString ProjectFileDialog::getRootPath() const
 
 QString ProjectFileDialog::getBuildDir() const
 {
-    return mUI.mEditBuildDir->text();
+    return mUI->mEditBuildDir->text();
 }
 
 QStringList ProjectFileDialog::getIncludePaths() const
 {
-    return getPaths(mUI.mListIncludeDirs);
+    return getPaths(mUI->mListIncludeDirs);
 }
 
 QStringList ProjectFileDialog::getDefines() const
 {
-    return mUI.mEditDefines->text().trimmed().split(QRegExp("\\s*;\\s*"), QString::SkipEmptyParts);
+    return mUI->mEditDefines->text().trimmed().split(QRegularExpression("\\s*;\\s*"), Qt::SkipEmptyParts);
 }
 
 QStringList ProjectFileDialog::getUndefines() const
 {
-    const QString undefine = mUI.mEditUndefines->text().trimmed();
-    QStringList undefines = undefine.split(QRegExp("\\s*;\\s*"), QString::SkipEmptyParts);
+    const QString undefine = mUI->mEditUndefines->text().trimmed();
+    QStringList undefines = undefine.split(QRegularExpression("\\s*;\\s*"), Qt::SkipEmptyParts);
     undefines.removeDuplicates();
     return undefines;
 }
 
 QStringList ProjectFileDialog::getCheckPaths() const
 {
-    return getPaths(mUI.mListCheckPaths);
+    return getPaths(mUI->mListCheckPaths);
 }
 
 QStringList ProjectFileDialog::getExcludedPaths() const
 {
-    return getPaths(mUI.mListExcludedPaths);
+    return getPaths(mUI->mListExcludedPaths);
 }
 
 QStringList ProjectFileDialog::getLibraries() const
 {
     QStringList libraries;
-    for (int row = 0; row < mUI.mLibraries->count(); ++row) {
-        QListWidgetItem *item = mUI.mLibraries->item(row);
+    for (int row = 0; row < mUI->mLibraries->count(); ++row) {
+        QListWidgetItem *item = mUI->mLibraries->item(row);
         if (item->checkState() == Qt::Checked)
             libraries << item->text();
     }
@@ -546,70 +757,73 @@ QStringList ProjectFileDialog::getLibraries() const
 
 void ProjectFileDialog::setRootPath(const QString &root)
 {
-    mUI.mEditProjectRoot->setText(QDir::toNativeSeparators(root));
+    mUI->mEditProjectRoot->setText(QDir::toNativeSeparators(root));
 }
 
 void ProjectFileDialog::setBuildDir(const QString &buildDir)
 {
-    mUI.mEditBuildDir->setText(buildDir);
+    mUI->mEditBuildDir->setText(buildDir);
 }
 
 void ProjectFileDialog::setImportProject(const QString &importProject)
 {
-    mUI.mEditImportProject->setText(importProject);
+    mUI->mEditImportProject->setText(importProject);
 }
 
 void ProjectFileDialog::setIncludepaths(const QStringList &includes)
 {
-    foreach (QString dir, includes) {
+    for (const QString& dir : includes) {
         addIncludeDir(dir);
     }
 }
 
 void ProjectFileDialog::setDefines(const QStringList &defines)
 {
-    mUI.mEditDefines->setText(defines.join(";"));
+    mUI->mEditDefines->setText(defines.join(";"));
 }
 
 void ProjectFileDialog::setUndefines(const QStringList &undefines)
 {
-    mUI.mEditUndefines->setText(undefines.join(";"));
+    mUI->mEditUndefines->setText(undefines.join(";"));
 }
 
 void ProjectFileDialog::setCheckPaths(const QStringList &paths)
 {
-    foreach (QString path, paths) {
+    for (const QString& path : paths) {
         addCheckPath(path);
     }
 }
 
 void ProjectFileDialog::setExcludedPaths(const QStringList &paths)
 {
-    foreach (QString path, paths) {
+    for (const QString& path : paths) {
         addExcludePath(path);
     }
 }
 
 void ProjectFileDialog::setLibraries(const QStringList &libraries)
 {
-    for (int row = 0; row < mUI.mLibraries->count(); ++row) {
-        QListWidgetItem *item = mUI.mLibraries->item(row);
+    for (int row = 0; row < mUI->mLibraries->count(); ++row) {
+        QListWidgetItem *item = mUI->mLibraries->item(row);
         item->setCheckState(libraries.contains(item->text()) ? Qt::Checked : Qt::Unchecked);
     }
 }
 
-void ProjectFileDialog::setSuppressions(const QList<Suppressions::Suppression> &suppressions)
+void ProjectFileDialog::addSingleSuppression(const SuppressionList::Suppression &suppression)
 {
-    mSuppressions = suppressions;
+    mSuppressions += suppression;
+    mUI->mListSuppressions->addItem(QString::fromStdString(suppressionAsText(suppression)));
+}
 
-    QStringList s;
-    foreach (const Suppressions::Suppression &suppression, mSuppressions) {
-        s << QString::fromStdString(suppression.getText());
+void ProjectFileDialog::setSuppressions(const QList<SuppressionList::Suppression> &suppressions)
+{
+    mUI->mListSuppressions->clear();
+    QList<SuppressionList::Suppression> new_suppressions = suppressions;
+    mSuppressions.clear();
+    for (const SuppressionList::Suppression &suppression : new_suppressions) {
+        addSingleSuppression(suppression);
     }
-
-    mUI.mListSuppressions->clear();
-    mUI.mListSuppressions->addItems(s);
-    mUI.mListSuppressions->sortItems();
+    mUI->mListSuppressions->sortItems();
 }
 
 void ProjectFileDialog::addCheckPath()
@@ -621,14 +835,14 @@ void ProjectFileDialog::addCheckPath()
 
 void ProjectFileDialog::editCheckPath()
 {
-    QListWidgetItem *item = mUI.mListCheckPaths->currentItem();
-    mUI.mListCheckPaths->editItem(item);
+    QListWidgetItem *item = mUI->mListCheckPaths->currentItem();
+    mUI->mListCheckPaths->editItem(item);
 }
 
 void ProjectFileDialog::removeCheckPath()
 {
-    const int row = mUI.mListCheckPaths->currentRow();
-    QListWidgetItem *item = mUI.mListCheckPaths->takeItem(row);
+    const int row = mUI->mListCheckPaths->currentRow();
+    QListWidgetItem *item = mUI->mListCheckPaths->takeItem(row);
     delete item;
 }
 
@@ -641,82 +855,90 @@ void ProjectFileDialog::addIncludeDir()
 
 void ProjectFileDialog::removeIncludeDir()
 {
-    const int row = mUI.mListIncludeDirs->currentRow();
-    QListWidgetItem *item = mUI.mListIncludeDirs->takeItem(row);
+    const int row = mUI->mListIncludeDirs->currentRow();
+    QListWidgetItem *item = mUI->mListIncludeDirs->takeItem(row);
     delete item;
 }
 
 void ProjectFileDialog::editIncludeDir()
 {
-    QListWidgetItem *item = mUI.mListIncludeDirs->currentItem();
-    mUI.mListIncludeDirs->editItem(item);
+    QListWidgetItem *item = mUI->mListIncludeDirs->currentItem();
+    mUI->mListIncludeDirs->editItem(item);
 }
 
 void ProjectFileDialog::addExcludePath()
 {
-    QString dir = getExistingDirectory(tr("Select directory to ignore"), true);
-    if (!dir.isEmpty())
-        addExcludePath(dir);
+    addExcludePath(getExistingDirectory(tr("Select directory to ignore"), true));
+}
+
+void ProjectFileDialog::addExcludeFile()
+{
+    const QFileInfo inf(mProjectFile->getFilename());
+    const QDir &dir = inf.absoluteDir();
+    QMap<QString,QString> filters;
+    filters[tr("Source files")] = "*.c *.cpp";
+    filters[tr("All files")] = "*.*";
+    addExcludePath(QFileDialog::getOpenFileName(this, tr("Exclude file"), dir.canonicalPath(), toFilterString(filters)));
 }
 
 void ProjectFileDialog::editExcludePath()
 {
-    QListWidgetItem *item = mUI.mListExcludedPaths->currentItem();
-    mUI.mListExcludedPaths->editItem(item);
+    QListWidgetItem *item = mUI->mListExcludedPaths->currentItem();
+    mUI->mListExcludedPaths->editItem(item);
 }
 
 void ProjectFileDialog::removeExcludePath()
 {
-    const int row = mUI.mListExcludedPaths->currentRow();
-    QListWidgetItem *item = mUI.mListExcludedPaths->takeItem(row);
+    const int row = mUI->mListExcludedPaths->currentRow();
+    QListWidgetItem *item = mUI->mListExcludedPaths->takeItem(row);
     delete item;
 }
 
 void ProjectFileDialog::moveIncludePathUp()
 {
-    int row = mUI.mListIncludeDirs->currentRow();
-    QListWidgetItem *item = mUI.mListIncludeDirs->takeItem(row);
+    int row = mUI->mListIncludeDirs->currentRow();
+    QListWidgetItem *item = mUI->mListIncludeDirs->takeItem(row);
     row = row > 0 ? row - 1 : 0;
-    mUI.mListIncludeDirs->insertItem(row, item);
-    mUI.mListIncludeDirs->setCurrentItem(item);
+    mUI->mListIncludeDirs->insertItem(row, item);
+    mUI->mListIncludeDirs->setCurrentItem(item);
 }
 
 void ProjectFileDialog::moveIncludePathDown()
 {
-    int row = mUI.mListIncludeDirs->currentRow();
-    QListWidgetItem *item = mUI.mListIncludeDirs->takeItem(row);
-    const int count = mUI.mListIncludeDirs->count();
+    int row = mUI->mListIncludeDirs->currentRow();
+    QListWidgetItem *item = mUI->mListIncludeDirs->takeItem(row);
+    const int count = mUI->mListIncludeDirs->count();
     row = row < count ? row + 1 : count;
-    mUI.mListIncludeDirs->insertItem(row, item);
-    mUI.mListIncludeDirs->setCurrentItem(item);
+    mUI->mListIncludeDirs->insertItem(row, item);
+    mUI->mListIncludeDirs->setCurrentItem(item);
 }
 
 void ProjectFileDialog::addSuppression()
 {
     NewSuppressionDialog dlg;
     if (dlg.exec() == QDialog::Accepted) {
-        setSuppressions(mSuppressions << dlg.getSuppression());
+        addSingleSuppression(dlg.getSuppression());
     }
 }
 
 void ProjectFileDialog::removeSuppression()
 {
-    const int row = mUI.mListSuppressions->currentRow();
-    QListWidgetItem *item = mUI.mListSuppressions->takeItem(row);
+    const int row = mUI->mListSuppressions->currentRow();
+    QListWidgetItem *item = mUI->mListSuppressions->takeItem(row);
     if (!item)
         return;
 
-    int suppressionIndex = getSuppressionIndex(item->text());
+    const int suppressionIndex = getSuppressionIndex(item->text());
     if (suppressionIndex >= 0)
         mSuppressions.removeAt(suppressionIndex);
     delete item;
 }
 
-void ProjectFileDialog::editSuppression(const QModelIndex &)
+void ProjectFileDialog::editSuppression(const QModelIndex & /*index*/)
 {
-    const int row = mUI.mListSuppressions->currentRow();
-    QListWidgetItem *item = mUI.mListSuppressions->item(row);
-    int suppressionIndex = getSuppressionIndex(item->text());
+    const int row = mUI->mListSuppressions->currentRow();
+    QListWidgetItem *item = mUI->mListSuppressions->item(row);
+    const int suppressionIndex = getSuppressionIndex(item->text());
     if (suppressionIndex >= 0) { // TODO what if suppression is not found?
         NewSuppressionDialog dlg;
         dlg.setSuppression(mSuppressions[suppressionIndex]);
@@ -730,23 +952,25 @@ void ProjectFileDialog::editSuppression(const QModelIndex &)
 int ProjectFileDialog::getSuppressionIndex(const QString &shortText) const
 {
     const std::string s = shortText.toStdString();
-    for (int i = 0; i < mSuppressions.size(); ++i) {
-        if (mSuppressions[i].getText() == s)
-            return i;
-    }
-    return -1;
+    auto it = std::find_if(mSuppressions.cbegin(), mSuppressions.cend(), [&](const SuppressionList::Suppression& sup) {
+        return suppressionAsText(sup) == s;
+    });
+    return it == mSuppressions.cend() ? -1 : static_cast<int>(std::distance(mSuppressions.cbegin(), it));
 }
 
 void ProjectFileDialog::browseMisraFile()
 {
-    const QString fileName = QFileDialog::getOpenFileName(this, tr("Select MISRA rule texts file"), QDir::homePath(), tr("Misra rule texts file (%1)").arg("*.txt"));
+    const QString fileName = QFileDialog::getOpenFileName(this,
+                                                          tr("Select MISRA rule texts file"),
+                                                          QDir::homePath(),
+                                                          tr("MISRA rule texts file (%1)").arg("*.txt"));
     if (!fileName.isEmpty()) {
         QSettings settings;
-        mUI.mEditMisraFile->setText(fileName);
+        mUI->mEditMisraFile->setText(fileName);
         settings.setValue(SETTINGS_MISRA_FILE, fileName);
 
-        mUI.mAddonMisra->setText("MISRA C 2012");
-        mUI.mAddonMisra->setEnabled(true);
-        updateAddonCheckBox(mUI.mAddonMisra, nullptr, settings.value("DATADIR", QString()).toString(), "misra");
+        mUI->mMisraC->setText("MISRA C 2012");
+        mUI->mMisraC->setEnabled(true);
+        updateAddonCheckBox(mUI->mMisraC, nullptr, getDataDir(), ADDON_MISRA);
     }
 }
diff --git a/gui/projectfiledialog.h b/gui/projectfiledialog.h
index 7af7c530389..68f62ea83e5 100644
--- a/gui/projectfiledialog.h
+++ b/gui/projectfiledialog.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,16 +19,28 @@
 #ifndef PROJECTFILE_DIALOG_H
 #define PROJECTFILE_DIALOG_H
 
+#include "suppressions.h"
+
 #include <QDialog>
+#include <QList>
+#include <QObject>
 #include <QString>
 #include <QStringList>
-#include <QCheckBox>
-
-#include "suppressions.h"
-
-#include "ui_projectfiledialog.h"
 
+class QModelIndex;
 class QWidget;
+namespace Ui {
+    class ProjectFile;
+}
+
+extern const char ADDON_MISRA[];
+extern const char CODING_STANDARD_MISRA_C_2023[];
+extern const char CODING_STANDARD_MISRA_C_2025[];
+extern const char CODING_STANDARD_MISRA_CPP_2008[];
+extern const char CODING_STANDARD_MISRA_CPP_2023[];
+extern const char CODING_STANDARD_CERT_C[];
+extern const char CODING_STANDARD_CERT_CPP[];
+extern const char CODING_STANDARD_AUTOSAR[];
 
 /// @addtogroup GUI
 /// @{
@@ -37,13 +49,13 @@ class QWidget;
 class ProjectFile;
 
 /**
-* @brief A dialog for editing project file data.
-*/
+ * @brief A dialog for editing project file data.
+ */
 class ProjectFileDialog : public QDialog {
     Q_OBJECT
 public:
-    explicit ProjectFileDialog(ProjectFile *projectFile, QWidget *parent = nullptr);
-    virtual ~ProjectFileDialog();
+    explicit ProjectFileDialog(ProjectFile *projectFile, bool premium, QWidget *parent = nullptr);
+    ~ProjectFileDialog() override;
 
 private:
     void loadFromProjectFile(const ProjectFile *projectFile);
@@ -53,64 +65,67 @@ class ProjectFileDialog : public QDialog {
     void updatePathsAndDefines();
 
     /**
-    * @brief Return project root path from the dialog control.
-    * @return Project root path.
-    */
+     * @brief Return project root path from the dialog control.
+     * @return Project root path.
+     */
     QString getRootPath() const;
 
+    QStringList getProjectConfigurations() const;
+    void setProjectConfigurations(const QStringList &configs);
+
     QString getImportProject() const;
 
     /** Get Cppcheck build dir */
     QString getBuildDir() const;
 
     /**
-    * @brief Return include paths from the dialog control.
-    * @return List of include paths.
-    */
+     * @brief Return include paths from the dialog control.
+     * @return List of include paths.
+     */
     QStringList getIncludePaths() const;
 
     /**
-    * @brief Return define names from the dialog control.
-    * @return List of define names.
-    */
+     * @brief Return define names from the dialog control.
+     * @return List of define names.
+     */
     QStringList getDefines() const;
 
     /**
-    * @brief Return undefine names from the dialog control.
-    * @return List of undefine names.
-    */
+     * @brief Return undefine names from the dialog control.
+     * @return List of undefine names.
+     */
     QStringList getUndefines() const;
 
     /**
-    * @brief Return check paths from the dialog control.
-    * @return List of check paths.
-    */
+     * @brief Return check paths from the dialog control.
+     * @return List of check paths.
+     */
     QStringList getCheckPaths() const;
 
     /**
-    * @brief Return excluded paths from the dialog control.
-    * @return List of excluded paths.
-    */
+     * @brief Return excluded paths from the dialog control.
+     * @return List of excluded paths.
+     */
     QStringList getExcludedPaths() const;
 
     /**
-    * @brief Return selected libraries from the dialog control.
-    * @return List of libraries.
-    */
+     * @brief Return selected libraries from the dialog control.
+     * @return List of libraries.
+     */
     QStringList getLibraries() const;
 
     /**
-    * @brief Return suppressions from the dialog control.
-    * @return List of suppressions.
-    */
-    QList<Suppressions::Suppression> getSuppressions() const {
+     * @brief Return suppressions from the dialog control.
+     * @return List of suppressions.
+     */
+    const QList<SuppressionList::Suppression>& getSuppressions() const {
         return mSuppressions;
     }
 
     /**
-    * @brief Set project root path to dialog control.
-    * @param root Project root path to set to dialog control.
-    */
+     * @brief Set project root path to dialog control.
+     * @param root Project root path to set to dialog control.
+     */
     void setRootPath(const QString &root);
 
     /** Set build dir */
@@ -119,131 +134,142 @@ class ProjectFileDialog : public QDialog {
     void setImportProject(const QString &importProject);
 
     /**
-    * @brief Set include paths to dialog control.
-    * @param includes List of include paths to set to dialog control.
-    */
+     * @brief Set include paths to dialog control.
+     * @param includes List of include paths to set to dialog control.
+     */
     void setIncludepaths(const QStringList &includes);
 
     /**
-    * @brief Set define names to dialog control.
-    * @param defines List of define names to set to dialog control.
-    */
+     * @brief Set define names to dialog control.
+     * @param defines List of define names to set to dialog control.
+     */
     void setDefines(const QStringList &defines);
 
     /**
-    * @brief Set undefine names to dialog control.
-    * @param undefines List of undefine names to set to dialog control.
-    */
+     * @brief Set undefine names to dialog control.
+     * @param undefines List of undefine names to set to dialog control.
+     */
     void setUndefines(const QStringList &undefines);
 
     /**
-    * @brief Set check paths to dialog control.
-    * @param paths List of path names to set to dialog control.
-    */
+     * @brief Set check paths to dialog control.
+     * @param paths List of path names to set to dialog control.
+     */
     void setCheckPaths(const QStringList &paths);
 
     /**
-    * @brief Set excluded paths to dialog control.
-    * @param paths List of path names to set to dialog control.
-    */
+     * @brief Set excluded paths to dialog control.
+     * @param paths List of path names to set to dialog control.
+     */
     void setExcludedPaths(const QStringList &paths);
 
     /**
-    * @brief Set libraries to dialog control.
-    * @param libraries List of libraries to set to dialog control.
-    */
+     * @brief Set libraries to dialog control.
+     * @param libraries List of libraries to set to dialog control.
+     */
     void setLibraries(const QStringList &libraries);
 
     /**
-    * @brief Set suppressions to dialog control.
-    * @param suppressions List of suppressions to set to dialog control.
-    */
-    void setSuppressions(const QList<Suppressions::Suppression> &suppressions);
+     * @brief Add a single suppression to dialog control.
+     * @param suppression A suppressions to add to dialog control.
+     */
+    void addSingleSuppression(const SuppressionList::Suppression &suppression);
+
+    /**
+     * @brief Set suppressions to dialog control.
+     * @param suppressions List of suppressions to set to dialog control.
+     */
+    void setSuppressions(const QList<SuppressionList::Suppression> &suppressions);
 
-protected slots:
+private slots:
 
     /** ok button pressed, save changes and accept */
     void ok();
 
     /**
-    * @brief Browse for build dir.
-    */
+     * @brief Browse for build dir.
+     */
     void browseBuildDir();
 
     /**
-    * @brief Clear 'import project'.
-    */
+     * @brief Clear 'import project'.
+     */
     void clearImportProject();
 
     /**
-    * @brief Browse for solution / project / compile database.
-    */
+     * @brief Browse for solution / project / compile database.
+     */
     void browseImportProject();
 
     /**
-    * @brief Add new path to check.
-    */
+     * @brief Add new path to check.
+     */
     void addCheckPath();
 
     /**
-    * @brief Edit path in the list.
-    */
+     * @brief Edit path in the list.
+     */
     void editCheckPath();
 
     /**
-    * @brief Remove path from the list.
-    */
+     * @brief Remove path from the list.
+     */
     void removeCheckPath();
 
     /**
-    * @brief Browse for include directory.
-    * Allow user to add new include directory to the list.
-    */
+     * @brief Browse for include directory.
+     * Allow user to add new include directory to the list.
+     */
     void addIncludeDir();
 
     /**
-    * @brief Remove include directory from the list.
-    */
+     * @brief Remove include directory from the list.
+     */
     void removeIncludeDir();
 
     /**
-    * @brief Edit include directory in the list.
-    */
+     * @brief Edit include directory in the list.
+     */
     void editIncludeDir();
 
     /**
-    * @brief Add new path to exclude.
-    */
+     * @brief Add new path to exclude list.
+     */
     void addExcludePath();
 
     /**
-    * @brief Edit excluded path in the list.
-    */
+     * @brief Add new file to exclude list.
+     */
+    void addExcludeFile();
+
+    /**
+     * @brief Edit excluded path in the list.
+     */
     void editExcludePath();
 
     /**
-    * @brief Remove excluded path from the list.
-    */
+     * @brief Remove excluded path from the list.
+     */
     void removeExcludePath();
 
     /**
-      * @brief Move include path up in the list.
-      */
+     * @brief Move include path up in the list.
+     */
     void moveIncludePathUp();
 
     /**
-      * @brief Move include path down in the list.
-      */
+     * @brief Move include path down in the list.
+     */
     void moveIncludePathDown();
 
     /**
-    * @brief Add suppression to the list
-    */
+     * @brief Add suppression to the list
+     */
     void addSuppression();
 
     /**
-    * @brief Remove selected suppression from the list
-    */
+     * @brief Remove selected suppression from the list
+     */
     void removeSuppression();
 
     /**
@@ -256,6 +282,11 @@ protected slots:
      */
     void browseMisraFile();
 
+    /**
+     * @brief Check for all VS configurations
+     */
+    void checkAllVSConfigs();
+
 protected:
 
     /**
@@ -269,21 +300,21 @@ protected slots:
     void saveSettings() const;
 
     /**
-    * @brief Add new indlude directory.
-    * @param dir Directory to add.
-    */
+     * @brief Add new indlude directory.
+     * @param dir Directory to add.
+     */
     void addIncludeDir(const QString &dir);
 
     /**
-    * @brief Add new path to check.
-    * @param path Path to add.
-    */
+     * @brief Add new path to check.
+     * @param path Path to add.
+     */
     void addCheckPath(const QString &path);
 
     /**
-    * @brief Add new path to ignore list.
-    * @param path Path to add.
-    */
+     * @brief Add new path to ignore list.
+     * @param path Path to add.
+     */
     void addExcludePath(const QString &path);
 
     /**
@@ -295,19 +326,21 @@ protected slots:
     int getSuppressionIndex(const QString &shortText) const;
 
 private:
-    Ui::ProjectFile mUI;
+    static QStringList getProjectConfigs(const QString &fileName);
+
+    Ui::ProjectFile * const mUI;
 
     /**
      * @brief Projectfile path.
      */
-    ProjectFile *mProjectFile;
+    ProjectFile * const mProjectFile;
 
-    /** @brief Library checkboxes */
-    QList<QCheckBox*> mLibraryCheckboxes;
+    /** Is this Cppcheck Premium? */
+    const bool mPremium;
 
     QString getExistingDirectory(const QString &caption, bool trailingSlash);
 
-    QList<Suppressions::Suppression> mSuppressions;
+    QList<SuppressionList::Suppression> mSuppressions;
 };
 
 /// @}
diff --git a/gui/readme.txt b/gui/readme.txt
index bad025959e4..2137c6d174d 100644
--- a/gui/readme.txt
+++ b/gui/readme.txt
@@ -29,28 +29,16 @@ Linux:
   names depend on distribution, but e.g. for Ubuntu the needed packages are:
   * qt5-default 
 
-After you have needed libraries and tools installed, open command
-prompt/console, go to gui directory and run command:
-- qmake (in Linux and in Windows if build with MinGW/gcc or nmake)
-- qmake -tp vc (to generate Visual Studio project file)
-- qmake -tp vc LINKCORE=yes (to generate Visual Studio project file, linking
-                             dynamically to core. Recommended.)
+After you have needed libraries and tools installed you need to run CMake with
+`-DBUILD_GUI=On`.
 
 On Windows, you have to either call qtvars.bat in Qt folder or use the Qt command
 line prompt shortcut added in the start menu by Qt installation.
 
-These commands generate makefiles to actually build the software. After that
-the actual building is done in IDE or command line as usual. Note that you
-don't need to run qmake again unless you add/remove files from the project.
-
-The Visual Studio solution does not contain a configuration for x64 platform, but
-it can be added easily.
-
 Tests
 -----
-There are tests for the GUI in gui/test -directory. There is test.pro
--projectfile for building all the tests. Each test is in own subdirectory and
-builds own binary. Test is run by simple running that binary. The binary also
+There are tests for the GUI in gui/test -directory. Each test is in own subdirectory
+and builds own binary. Test is run by simple running that binary. The binary also
 has several options to select tests etc. You can get the help by running
 "binaryname -help" -command.
 
@@ -60,11 +48,4 @@ The GUI is translated to several languages. Qt comes with two tools to update
 and compile the translations. lupdate updates translations files from the code
 and lrelease compiles translation files use with the executable.
 
-To update translations:
-- run lupdate gui.pro to update the translation files to match the code. This
-  command updates all the .ts files. Which can be then edited to translate
-  the application.
-
-To compile translations:
-- run lrelease gui.pro to compile .ts files to .qm files which are used by the
-  executable.
+The translations are automatically updated and compiled within CMake.
\ No newline at end of file
diff --git a/gui/report.cpp b/gui/report.cpp
index e5e7490e6f8..e7b7e06edf9 100644
--- a/gui/report.cpp
+++ b/gui/report.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2017 Cppcheck team.
+ * Copyright (C) 2007-2023 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,15 +16,15 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QString>
-#include <QFile>
 #include "report.h"
 
-Report::Report(const QString &filename) :
-    QObject(),
-    mFilename(filename)
-{
-}
+#include <utility>
+
+#include <QIODevice>
+
+Report::Report(QString filename) :
+    mFilename(std::move(filename))
+{}
 
 Report::~Report()
 {
diff --git a/gui/report.h b/gui/report.h
index 99184f376e1..1bbd9f8c1bd 100644
--- a/gui/report.h
+++ b/gui/report.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,78 +19,81 @@
 #ifndef REPORT_H
 #define REPORT_H
 
+#include <cstdint>
+
+#include <QFile>
 #include <QObject>
 #include <QString>
-#include <QFile>
-#include "erroritem.h"
+
+class ErrorItem;
 
 /// @addtogroup GUI
 /// @{
 
 /**
-* @brief A base class for reports.
-*/
+ * @brief A base class for reports.
+ */
 class Report : public QObject {
 public:
-    enum Type {
+    enum Type : std::uint8_t {
         TXT,
         XMLV2,
         CSV,
     };
 
-    explicit Report(const QString &filename);
-    virtual ~Report();
+    explicit Report(QString filename);
+    ~Report() override;
 
     /**
-    * @brief Create the report (file).
-    * @return true if succeeded, false if file could not be created.
-    */
+     * @brief Create the report (file).
+     * @return true if succeeded, false if file could not be created.
+     */
     virtual bool create();
 
     /**
-    * @brief Open the existing report (file).
-    * @return true if succeeded, false if file could not be created.
-    */
+     * @brief Open the existing report (file).
+     * @return true if succeeded, false if file could not be created.
+     */
     virtual bool open();
 
     /**
-    * @brief Close the report (file).
-    */
+     * @brief Close the report (file).
+     */
     void close();
 
     /**
-    * @brief Write report header.
-    */
+     * @brief Write report header.
+     */
     virtual void writeHeader() = 0;
 
     /**
-    * @brief Write report footer.
-    */
+     * @brief Write report footer.
+     */
     virtual void writeFooter() = 0;
 
     /**
-    * @brief Write error to report.
-    * @param error Error data.
-    */
+     * @brief Write error to report.
+     * @param error Error data.
+     */
     virtual void writeError(const ErrorItem &error) = 0;
 
 protected:
 
     /**
-    * @brief Get the file object where the report is written to.
-    */
+     * @brief Get the file object where the report is written to.
+     */
     QFile* getFile();
 
 private:
 
     /**
-    * @brief Filename of the report.
-    */
+     * @brief Filename of the report.
+     */
     QString mFilename;
 
     /**
-    * @brief Fileobject for the report file.
-    */
+     * @brief Fileobject for the report file.
+     */
     QFile mFile;
 };
 /// @}
diff --git a/gui/resultitem.cpp b/gui/resultitem.cpp
new file mode 100644
index 00000000000..4f8c14fa056
--- /dev/null
+++ b/gui/resultitem.cpp
@@ -0,0 +1,25 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "resultitem.h"
+
+#include <utility>
+
+ResultItem::ResultItem(QSharedPointer<ErrorItem> errorItem, Type type, int errorPathIndex)
+    : errorItem(std::move(errorItem)), mType(type), mErrorPathIndex(errorPathIndex)
+{}
diff --git a/gui/resultitem.h b/gui/resultitem.h
new file mode 100644
index 00000000000..e0c212b2138
--- /dev/null
+++ b/gui/resultitem.h
@@ -0,0 +1,61 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef RESULTITEM_H
+#define RESULTITEM_H
+
+#include "erroritem.h"
+#include <QStandardItem>
+#include <QSharedPointer>
+
+class ResultItem : public QStandardItem
+{
+public:
+    enum class Type: std::uint8_t {file, message, note};
+
+    ResultItem(QSharedPointer<ErrorItem> errorItem, Type type, int errorPathIndex);
+    QSharedPointer<ErrorItem> errorItem;
+    bool hidden{};
+
+    QErrorPathItem getErrorPathItem() const {
+        if (!errorItem || mErrorPathIndex < 0 || mErrorPathIndex >= errorItem->errorPath.size())
+            return {};
+        return errorItem->errorPath[mErrorPathIndex];
+    }
+
+    Type getType() const {
+        return mType;
+    }
+
+    void setIconFileName(const QString& iconFileName) {
+        mIconFileName = iconFileName;
+        if (!mIconFileName.isEmpty())
+            setIcon(QIcon(iconFileName));
+    }
+
+    // cppcheck-suppress unusedFunction; used in test-resultstree
+    const QString& getIconFileName() const {
+        return mIconFileName;
+    }
+private:
+    const Type mType;
+    const int mErrorPathIndex;
+    QString mIconFileName;
+};
+
+#endif // RESULTITEM_H
diff --git a/gui/resultstree.cpp b/gui/resultstree.cpp
index e9c9e65df16..c553855e99e 100644
--- a/gui/resultstree.cpp
+++ b/gui/resultstree.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,69 +16,132 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QApplication>
-#include <QWidget>
-#include <QDebug>
-#include <QString>
-#include <QStringList>
-#include <QList>
-#include <QMap>
-#include <QVariant>
-#include <QMenu>
-#include <QSignalMapper>
-#include <QProcess>
-#include <QDir>
-#include <QMessageBox>
-#include <QAction>
-#include <QFileInfo>
-#include <QFileDialog>
-#include <QClipboard>
-#include <QDesktopServices>
-#include <QUrl>
-#include <QContextMenuEvent>
-#include <QModelIndex>
+#include "resultstree.h"
+
+#include "application.h"
+#include "applicationlist.h"
+#include "checkers.h"
 #include "common.h"
 #include "erroritem.h"
-#include "applicationlist.h"
-#include "resultstree.h"
+#include "errorlogger.h"
+#include "errortypes.h"
+#include "path.h"
+#include "projectfile.h"
 #include "report.h"
-#include "application.h"
+#include "resultitem.h"
 #include "showtypes.h"
+#include "suppressions.h"
 #include "threadhandler.h"
-#include "path.h"
+#include "utils.h"
 #include "xmlreportv2.h"
 
+#include <algorithm>
+#include <utility>
+
+#include <QAction>
+#include <QApplication>
+#include <QClipboard>
+#include <QContextMenuEvent>
+#include <QDebug>
+#include <QDesktopServices>
+#include <QDir>
+#include <QFileInfo>
+#include <QFileDialog>
+#include <QIcon>
+#include <QItemSelectionModel>
+#include <QKeyEvent>
+#include <QLocale>
+#include <QMenu>
+#include <QMessageBox>
+#include <QModelIndex>
+#include <QObject>
+#include <QProcess>
+#include <QSet>
+#include <QSettings>
+#include <QSignalMapper>
+#include <QStandardItemModel>
+#include <QUrl>
+#include <Qt>
+#include <QHeaderView>
+
 // These must match column headers given in ResultsTree::translate()
-static const unsigned int COLUMN_SINCE_DATE = 6;
-static const unsigned int COLUMN_TAGS       = 7;
+static constexpr int COLUMN_FILE                  = 0;
+static constexpr int COLUMN_LINE                  = 1;
+static constexpr int COLUMN_SEVERITY              = 2;
+static constexpr int COLUMN_MISRA_CLASSIFICATION  = 3;
+static constexpr int COLUMN_CERT_LEVEL            = 4;
+static constexpr int COLUMN_INCONCLUSIVE          = 5;
+static constexpr int COLUMN_SUMMARY               = 6;
+static constexpr int COLUMN_ID                    = 7;
+static constexpr int COLUMN_MISRA_GUIDELINE       = 8;
+static constexpr int COLUMN_CERT_RULE             = 9;
+static constexpr int COLUMN_SINCE_DATE            = 10;
+static constexpr int COLUMN_TAGS                  = 11;
+static constexpr int COLUMN_CWE                   = 12;
+
+static QString getGuideline(ReportType reportType, const std::map<std::string, std::string> &guidelineMapping,
+                            const QString& errorId, Severity severity) {
+    return QString::fromStdString(getGuideline(errorId.toStdString(),
+                                               reportType, guidelineMapping,
+                                               severity));
+}
+
+static QString getClassification(ReportType reportType, const QString& guideline) {
+    return QString::fromStdString(getClassification(guideline.toStdString(), reportType));
+}
+
+static Severity getSeverityFromClassification(const QString &c) {
+    if (c == checkers::Man)
+        return Severity::error;
+    if (c == checkers::Req)
+        return Severity::warning;
+    if (c == checkers::Adv)
+        return Severity::style;
+    if (c == checkers::Doc)
+        return Severity::information;
+    if (c == "L1")
+        return Severity::error;
+    if (c == "L2")
+        return Severity::warning;
+    if (c == "L3")
+        return Severity::style;
+    return Severity::none;
+}
+
+static QStringList getLabels() {
+    return QStringList{
+        QObject::tr("File"),
+        QObject::tr("Line"),
+        QObject::tr("Severity"),
+        QObject::tr("Classification"),
+        QObject::tr("Level"),
+        QObject::tr("Inconclusive"),
+        QObject::tr("Summary"),
+        QObject::tr("Id"),
+        QObject::tr("Guideline"),
+        QObject::tr("Rule"),
+        QObject::tr("Since date"),
+        QObject::tr("Tags"),
+        QObject::tr("CWE")};
+}
+
+static Severity getSeverity(ReportType reportType, const ErrorItem& errorItem) {
+    return reportType == ReportType::normal ? errorItem.severity : getSeverityFromClassification(errorItem.classification);
+}
 
 ResultsTree::ResultsTree(QWidget * parent) :
     QTreeView(parent),
-    mSettings(nullptr),
-    mApplications(nullptr),
-    mContextItem(nullptr),
-    mShowFullPath(false),
-    mSaveFullPath(false),
-    mSaveAllErrors(true),
-    mShowErrorId(false),
-    mVisibleErrors(false),
-    mSelectionModel(nullptr),
-    mThread(nullptr),
-    mShowCppcheck(true),
-    mShowClang(true)
+    mModel(new QStandardItemModel)
 {
-    setModel(&mModel);
+    setModel(mModel);
     translate(); // Adds columns to grid
+    clear();
     setExpandsOnDoubleClick(false);
     setSortingEnabled(true);
 
     connect(this, &ResultsTree::doubleClicked, this, &ResultsTree::quickStartApplication);
 }
 
-ResultsTree::~ResultsTree()
-{
-}
-
 void ResultsTree::keyPressEvent(QKeyEvent *event)
 {
     if (event->key() == Qt::Key_Enter || event->key() == Qt::Key_Return) {
@@ -87,6 +150,52 @@ void ResultsTree::keyPressEvent(QKeyEvent *event)
     QTreeView::keyPressEvent(event);
 }
 
+void ResultsTree::setReportType(ReportType reportType) {
+    mReportType = reportType;
+
+    mGuideline = createGuidelineMapping(reportType);
+
+    for (int i = 0; i < mModel->rowCount(); ++i) {
+        auto *fileItem = dynamic_cast<ResultItem*>(mModel->item(i, COLUMN_FILE));
+        if (!fileItem)
+            continue;
+        for (int j = 0; j < fileItem->rowCount(); ++j) {
+            QSharedPointer<ErrorItem>& errorItem = dynamic_cast<ResultItem*>(fileItem->child(j,0))->errorItem;
+            errorItem->guideline = getGuideline(mReportType, mGuideline, errorItem->errorId, errorItem->severity);
+            errorItem->classification = getClassification(mReportType, errorItem->guideline);
+            dynamic_cast<ResultItem*>(fileItem->child(j, COLUMN_FILE))->setIconFileName(severityToIcon(getSeverity(reportType, *errorItem)));
+            fileItem->child(j, COLUMN_CERT_LEVEL)->setText(errorItem->classification);
+            fileItem->child(j, COLUMN_CERT_RULE)->setText(errorItem->guideline);
+            fileItem->child(j, COLUMN_MISRA_CLASSIFICATION)->setText(errorItem->classification);
+            fileItem->child(j, COLUMN_MISRA_GUIDELINE)->setText(errorItem->guideline);
+        }
+    }
+
+    if (isAutosarMisraReport()) {
+        showColumn(COLUMN_MISRA_CLASSIFICATION);
+        showColumn(COLUMN_MISRA_GUIDELINE);
+    } else {
+        hideColumn(COLUMN_MISRA_CLASSIFICATION);
+        hideColumn(COLUMN_MISRA_GUIDELINE);
+    }
+
+    if (isCertReport()) {
+        showColumn(COLUMN_CERT_LEVEL);
+        showColumn(COLUMN_CERT_RULE);
+    } else {
+        hideColumn(COLUMN_CERT_LEVEL);
+        hideColumn(COLUMN_CERT_RULE);
+    }
+
+    if (mReportType == ReportType::normal) {
+        showColumn(COLUMN_SEVERITY);
+    } else {
+        hideColumn(COLUMN_SEVERITY);
+    }
+
+    refreshTree();
+}
+
 void ResultsTree::initialize(QSettings *settings, ApplicationList *list, ThreadHandler *checkThreadHandler)
 {
     mSettings = settings;
@@ -95,199 +204,151 @@ void ResultsTree::initialize(QSettings *settings, ApplicationList *list, ThreadH
     loadSettings();
 }
 
+ResultItem *ResultsTree::createNormalItem(const QString &text, QSharedPointer<ErrorItem> errorItem, ResultItem::Type type, int errorPathIndex)
+{
+    auto *item = new ResultItem(std::move(errorItem), type, errorPathIndex);
+    item->setText(text);
+    item->setEditable(false);
+    return item;
+}
 
-QStandardItem *ResultsTree::createNormalItem(const QString &name)
+ResultItem *ResultsTree::createFilenameItem(const QSharedPointer<ErrorItem>& errorItem, ResultItem::Type type, int errorPathIndex)
 {
-    QStandardItem *item = new QStandardItem(name);
-    item->setData(name, Qt::ToolTipRole);
+    auto *item = new ResultItem(errorItem, type, errorPathIndex);
+    item->setText(QDir::toNativeSeparators(stripPath(errorItem->errorPath[errorPathIndex].file, false)));
     item->setEditable(false);
     return item;
 }
 
-QStandardItem *ResultsTree::createCheckboxItem(bool checked)
+ResultItem *ResultsTree::createCheckboxItem(bool checked, QSharedPointer<ErrorItem> errorItem, ResultItem::Type type, int errorPathIndex)
 {
-    QStandardItem *item = new QStandardItem;
+    auto *item = new ResultItem(std::move(errorItem), type, errorPathIndex);
     item->setCheckable(true);
     item->setCheckState(checked ? Qt::Checked : Qt::Unchecked);
     item->setEnabled(false);
     return item;
 }
 
-QStandardItem *ResultsTree::createLineNumberItem(const QString &linenumber)
+ResultItem *ResultsTree::createLineNumberItem(int linenumber, QSharedPointer<ErrorItem> errorItem, ResultItem::Type type, int errorPathIndex)
 {
-    QStandardItem *item = new QStandardItem();
-    item->setData(QVariant(linenumber.toULongLong()), Qt::DisplayRole);
-    item->setToolTip(linenumber);
+    auto *item = new ResultItem(std::move(errorItem), type, errorPathIndex);
+    item->setText(QString::number(linenumber));
     item->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
     item->setEditable(false);
     return item;
 }
 
-bool ResultsTree::addErrorItem(const ErrorItem &item)
+bool ResultsTree::addErrorItem(const ErrorItem& errorItem)
 {
-    if (item.errorPath.isEmpty()) {
+    if (errorItem.errorPath.isEmpty())
         return false;
-    }
 
-    const QErrorPathItem &loc = item.errorId.startsWith("clang") ? item.errorPath.front() : item.errorPath.back();
-    QString realfile = stripPath(loc.file, false);
-
-    if (realfile.isEmpty()) {
-        realfile = tr("Undefined file");
-    }
+    const QString s = errorItem.toString();
+    if (mErrorList.contains(s))
+        return false;
+    mErrorList.append(s);
 
-    bool hide = false;
+    QSharedPointer<ErrorItem> errorItemPtr{new ErrorItem(errorItem)};
 
-    // Ids that are temporarily hidden..
-    if (mHiddenMessageId.contains(item.errorId))
-        hide = true;
-
-    //If specified, filter on summary, message, filename, and id
-    if (!hide && !mFilter.isEmpty()) {
-        if (!item.summary.contains(mFilter, Qt::CaseInsensitive) &&
-            !item.message.contains(mFilter, Qt::CaseInsensitive) &&
-            !item.errorPath.back().file.contains(mFilter, Qt::CaseInsensitive) &&
-            !item.errorId.contains(mFilter, Qt::CaseInsensitive)) {
-            hide = true;
-        }
+    if (mReportType != ReportType::normal) {
+        errorItemPtr->guideline = getGuideline(mReportType, mGuideline, errorItemPtr->errorId, errorItemPtr->severity);
+        errorItemPtr->classification = getClassification(mReportType, errorItemPtr->guideline);
     }
 
-    //if there is at least one error that is not hidden, we have a visible error
-    if (!hide) {
-        mVisibleErrors = true;
-    }
+    const bool showItem = !isErrorItemHidden(errorItemPtr);
+
+    // if there is at least one error that is not hidden, we have a visible error
+    mVisibleErrors |= showItem;
 
-    ErrorLine line;
-    line.file = realfile;
-    line.line = loc.line;
-    line.errorId = item.errorId;
-    line.inconclusive = item.inconclusive;
-    line.summary = item.summary;
-    line.message = item.message;
-    line.severity = item.severity;
-    line.sinceDate = item.sinceDate;
-    line.tags      = item.tags;
+    if (const ProjectFile *activeProject = ProjectFile::getActiveProject())
+        errorItemPtr->tags = activeProject->getWarningTags(errorItemPtr->hash);
     //Create the base item for the error and ensure it has a proper
     //file item as a parent
-    QStandardItem* fileItem = ensureFileItem(loc.file, item.file0, hide);
-    QStandardItem* stditem = addBacktraceFiles(fileItem,
-                             line,
-                             hide,
-                             severityToIcon(line.severity),
-                             false);
+    ResultItem* fileItem = ensureFileItem(errorItemPtr, !showItem);
+    ResultItem* stditem = addBacktraceFiles(fileItem,
+                                            errorItemPtr,
+                                            !showItem,
+                                            severityToIcon(getSeverity(mReportType, *errorItemPtr)),
+                                            ResultItem::Type::message,
+                                            errorItemPtr->getMainLocIndex());
 
     if (!stditem)
         return false;
 
-    //Add user data to that item
-    QMap<QString, QVariant> data;
-    data["hide"] = false;
-    data["severity"]  = ShowTypes::SeverityToShowType(item.severity);
-    data["summary"] = item.summary;
-    data["message"]  = item.message;
-    data["file"]  = loc.file;
-    data["line"]  = loc.line;
-    data["column"] = loc.column;
-    data["id"]  = item.errorId;
-    data["inconclusive"] = item.inconclusive;
-    data["file0"] = stripPath(item.file0, true);
-    data["sinceDate"] = item.sinceDate;
-    data["tags"] = item.tags;
-    data["hide"] = hide;
-    stditem->setData(QVariant(data));
-
     //Add backtrace files as children
-    if (item.errorPath.size() > 1U) {
-        for (int i = 0; i < item.errorPath.size(); i++) {
-            const QErrorPathItem &e = item.errorPath[i];
-            line.file = e.file;
-            line.line = e.line;
-            line.message = line.summary = e.info;
-            QStandardItem *child_item;
-            child_item = addBacktraceFiles(stditem,
-                                           line,
-                                           hide,
-                                           ":images/go-down.png",
-                                           true);
-            if (!child_item)
-                continue;
-
-            //Add user data to that item
-            QMap<QString, QVariant> child_data;
-            child_data["severity"]  = ShowTypes::SeverityToShowType(line.severity);
-            child_data["summary"] = line.summary;
-            child_data["message"]  = line.message;
-            child_data["file"]  = e.file;
-            child_data["line"]  = e.line;
-            child_data["column"] = e.column;
-            child_data["id"]  = line.errorId;
-            child_data["inconclusive"] = line.inconclusive;
-            child_item->setData(QVariant(child_data));
+    if (errorItemPtr->errorPath.size() > 1) {
+        for (int i = 0; i < errorItemPtr->errorPath.size(); i++) {
+            addBacktraceFiles(stditem,
+                              errorItemPtr,
+                              false,
+                              ":images/go-down.png",
+                              ResultItem::Type::note,
+                              i);
         }
     }
 
-    // Partially refresh the tree: Unhide file item if necessary
-    if (!hide) {
-        setRowHidden(fileItem->row(), QModelIndex(), !mShowSeverities.isShown(item.severity));
-    }
     return true;
 }
 
-QStandardItem *ResultsTree::addBacktraceFiles(QStandardItem *parent,
-        const ErrorLine &item,
-        const bool hide,
-        const QString &icon,
-        bool childOfMessage)
+ResultItem *ResultsTree::addBacktraceFiles(ResultItem *parent,
+                                           const QSharedPointer<ErrorItem>& errorItem,
+                                           const bool hide,
+                                           const QString &icon,
+                                           ResultItem::Type type,
+                                           int errorPathIndex)
 {
-    if (!parent) {
+    if (!parent)
         return nullptr;
-    }
-
-    QList<QStandardItem*> list;
-    // Ensure shown path is with native separators
-    list << createNormalItem(QDir::toNativeSeparators(item.file))
-         << createNormalItem(childOfMessage ? tr("note") : severityToTranslatedString(item.severity))
-         << createLineNumberItem(QString::number(item.line))
-         << createNormalItem(childOfMessage ? QString() : item.errorId)
-         << (childOfMessage ? createNormalItem(QString()) : createCheckboxItem(item.inconclusive))
-         << createNormalItem(item.summary)
-         << createNormalItem(item.sinceDate)
-         << createNormalItem(item.tags);
 
     //TODO message has parameter names so we'll need changes to the core
     //cppcheck so we can get proper translations
 
+    const bool childOfMessage = (type == ResultItem::Type::note);
+    const QString itemSeverity = childOfMessage ? tr("note") : severityToTranslatedString(errorItem->severity);
+
+    const auto& loc = errorItem->errorPath[errorPathIndex];
+
     // Check for duplicate rows and don't add them if found
-    for (int i = 0; i < parent->rowCount(); i++) {
+    for (int i = 0; i < errorPathIndex; i++) {
         // The first column is the file name and is always the same
+        const auto& e = errorItem->errorPath[i];
+        if (loc.line == e.line && loc.info == e.info)
+            return nullptr;
+    }
 
-        // the third column is the line number so check it first
-        if (parent->child(i, 2)->text() == list[2]->text()) {
-            // the second column is the severity so check it next
-            if (parent->child(i, 1)->text() == list[1]->text()) {
-                // the sixth column is the summary so check it last
-                if (parent->child(i, 5)->text() == list[5]->text()) {
-                    // this row matches so don't add it
-                    return nullptr;
-                }
-            }
-        }
+    const QString text = childOfMessage ? loc.info : errorItem->summary;
+
+    const int numberOfColumns = getLabels().size();
+    QList<ResultItem*> columns(numberOfColumns);
+    columns[COLUMN_FILE] = createFilenameItem(errorItem, type, errorPathIndex);
+    columns[COLUMN_FILE]->setIconFileName(icon);
+    columns[COLUMN_LINE] = createLineNumberItem(loc.line, errorItem, type, errorPathIndex);
+    columns[COLUMN_SEVERITY] = createNormalItem(itemSeverity, errorItem, type, errorPathIndex);
+    columns[COLUMN_SUMMARY] = createNormalItem(text, errorItem, type, errorPathIndex);
+    if (type == ResultItem::Type::message) {
+        columns[COLUMN_CERT_LEVEL] = createNormalItem(errorItem->classification, errorItem, type, errorPathIndex);
+        columns[COLUMN_CERT_RULE] = createNormalItem(errorItem->guideline, errorItem, type, errorPathIndex);
+        columns[COLUMN_CWE] = createNormalItem(errorItem->cwe > 0 ? QString::number(errorItem->cwe) : QString(), errorItem, type, errorPathIndex);
+        columns[COLUMN_ID] = createNormalItem(errorItem->errorId, errorItem, type, errorPathIndex);
+        columns[COLUMN_INCONCLUSIVE] = createCheckboxItem(errorItem->inconclusive, errorItem, type, errorPathIndex);
+        columns[COLUMN_MISRA_CLASSIFICATION] = createNormalItem(errorItem->classification, errorItem, type, errorPathIndex);
+        columns[COLUMN_MISRA_GUIDELINE] = createNormalItem(errorItem->guideline, errorItem, type, errorPathIndex);
+        columns[COLUMN_SINCE_DATE] = createNormalItem(errorItem->sinceDate, errorItem, type, errorPathIndex);
+        columns[COLUMN_TAGS] = createNormalItem(errorItem->tags, errorItem, type, errorPathIndex);
     }
 
+    QList<QStandardItem*> list;
+    for (int i = 0; i < numberOfColumns; ++i)
+        list << (columns[i] ? columns[i] : createNormalItem(QString(), errorItem, type, errorPathIndex));
+
     parent->appendRow(list);
 
     setRowHidden(parent->rowCount() - 1, parent->index(), hide);
 
-    if (!icon.isEmpty()) {
-        list[0]->setIcon(QIcon(icon));
-    }
-
-    //TODO Does this leak memory? Should items from list be deleted?
-
-    return list[0];
+    return columns[COLUMN_FILE];
 }
 
-QString ResultsTree::severityToTranslatedString(Severity::SeverityType severity)
+QString ResultsTree::severityToTranslatedString(Severity severity)
 {
     switch (severity) {
     case Severity::style:
@@ -311,46 +372,63 @@ QString ResultsTree::severityToTranslatedString(Severity::SeverityType severity)
     case Severity::debug:
         return tr("debug");
 
+    case Severity::internal:
+        return tr("internal");
+
     case Severity::none:
-    default:
         return QString();
     }
+
+    cppcheck::unreachable();
 }
 
-QStandardItem *ResultsTree::findFileItem(const QString &name) const
+ResultItem *ResultsTree::findFileItem(const QString &name) const
 {
     // The first column contains the file name. In Windows we can get filenames
     // "header.h" and "Header.h" and must compare them as identical.
 
-    for (int i = 0; i < mModel.rowCount(); i++) {
+    for (int i = 0; i < mModel->rowCount(); i++) {
 #ifdef _WIN32
-        if (QString::compare(mModel.item(i, 0)->text(), name, Qt::CaseInsensitive) == 0)
+        if (QString::compare(mModel->item(i, COLUMN_FILE)->text(), name, Qt::CaseInsensitive) == 0)
 #else
-        if (mModel.item(i, 0)->text() == name)
+        if (mModel->item(i, COLUMN_FILE)->text() == name)
 #endif
-            return mModel.item(i, 0);
+            return dynamic_cast<ResultItem*>(mModel->item(i, COLUMN_FILE));
     }
     return nullptr;
 }
 
 void ResultsTree::clear()
 {
-    mModel.removeRows(0, mModel.rowCount());
+    mErrorList.clear();
+
+    mModel->removeRows(0, mModel->rowCount());
+
+    if (const ProjectFile *activeProject = ProjectFile::getActiveProject()) {
+        hideColumn(COLUMN_SINCE_DATE);
+        if (activeProject->getTags().isEmpty())
+            hideColumn(COLUMN_TAGS);
+        else
+            showColumn(COLUMN_TAGS);
+    } else {
+        hideColumn(COLUMN_SINCE_DATE);
+        hideColumn(COLUMN_TAGS);
+    }
 }
 
 void ResultsTree::clear(const QString &filename)
 {
-    const QString stripped = stripPath(filename, false);
+    const QString stripped = QDir::toNativeSeparators(stripPath(filename, false));
 
-    for (int i = 0; i < mModel.rowCount(); ++i) {
-        const QStandardItem *fileItem = mModel.item(i, 0);
+    for (int i = 0; i < mModel->rowCount(); ++i) {
+        const auto *fileItem = dynamic_cast<ResultItem*>(mModel->item(i, COLUMN_FILE));
         if (!fileItem)
             continue;
 
-        QVariantMap data = fileItem->data().toMap();
-        if (stripped == data["file"].toString() ||
-            filename == data["file0"].toString()) {
-            mModel.removeRow(i);
+        if (stripped == fileItem->text() ||
+            filename == fileItem->errorItem->file0) {
+            mModel->removeRow(i);
+            mErrorList.removeAll(fileItem->errorItem->toString());
             break;
         }
     }
@@ -358,17 +436,17 @@ void ResultsTree::clear(const QString &filename)
 
 void ResultsTree::clearRecheckFile(const QString &filename)
 {
-    for (int i = 0; i < mModel.rowCount(); ++i) {
-        const QStandardItem *fileItem = mModel.item(i, 0);
+    for (int i = 0; i < mModel->rowCount(); ++i) {
+        const auto *fileItem = dynamic_cast<ResultItem*>(mModel->item(i, COLUMN_FILE));
         if (!fileItem)
             continue;
 
         QString actualfile((!mCheckPath.isEmpty() && filename.startsWith(mCheckPath)) ? filename.mid(mCheckPath.length() + 1) : filename);
-        QVariantMap data = fileItem->data().toMap();
-        QString storedfile = data["file"].toString();
+        QString storedfile = fileItem->getErrorPathItem().file;
         storedfile = ((!mCheckPath.isEmpty() && storedfile.startsWith(mCheckPath)) ? storedfile.mid(mCheckPath.length() + 1) : storedfile);
         if (actualfile == storedfile) {
-            mModel.removeRow(i);
+            mModel->removeRow(i);
+            mErrorList.removeAll(fileItem->errorItem->toString());
             break;
         }
     }
@@ -377,22 +455,22 @@ void ResultsTree::clearRecheckFile(const QString &filename)
 
 void ResultsTree::loadSettings()
 {
-    for (int i = 0; i < mModel.columnCount(); i++) {
+    for (int i = 0; i < mModel->columnCount(); i++) {
         QString temp = QString(SETTINGS_RESULT_COLUMN_WIDTH).arg(i);
-        setColumnWidth(i, qMax(20, mSettings->value(temp, 800 / mModel.columnCount()).toInt()));
+        setColumnWidth(i, qMax(20, mSettings->value(temp, 800 / mModel->columnCount()).toInt()));
     }
 
     mSaveFullPath = mSettings->value(SETTINGS_SAVE_FULL_PATH, false).toBool();
     mSaveAllErrors = mSettings->value(SETTINGS_SAVE_ALL_ERRORS, false).toBool();
     mShowFullPath = mSettings->value(SETTINGS_SHOW_FULL_PATH, false).toBool();
 
-    showIdColumn(mSettings->value(SETTINGS_SHOW_ERROR_ID, false).toBool());
+    showIdColumn(mSettings->value(SETTINGS_SHOW_ERROR_ID, true).toBool());
     showInconclusiveColumn(mSettings->value(SETTINGS_INCONCLUSIVE_ERRORS, false).toBool());
 }
 
 void ResultsTree::saveSettings() const
 {
-    for (int i = 0; i < mModel.columnCount(); i++) {
+    for (int i = 0; i < mModel->columnCount(); i++) {
         QString temp = QString(SETTINGS_RESULT_COLUMN_WIDTH).arg(i);
         mSettings->setValue(temp, columnWidth(i));
     }
@@ -428,26 +506,6 @@ void ResultsTree::showHiddenResults()
 {
     //Clear the "hide" flag for each item
     mHiddenMessageId.clear();
-    int filecount = mModel.rowCount();
-    for (int i = 0; i < filecount; i++) {
-        QStandardItem *fileItem = mModel.item(i, 0);
-        if (!fileItem)
-            continue;
-
-        QVariantMap data = fileItem->data().toMap();
-        data["hide"] = false;
-        fileItem->setData(QVariant(data));
-
-        int errorcount = fileItem->rowCount();
-        for (int j = 0; j < errorcount; j++) {
-            QStandardItem *child = fileItem->child(j, 0);
-            if (child) {
-                data = child->data().toMap();
-                data["hide"] = false;
-                child->setData(QVariant(data));
-            }
-        }
-    }
     refreshTree();
     emit resultsHidden(false);
 }
@@ -457,103 +515,94 @@ void ResultsTree::refreshTree()
 {
     mVisibleErrors = false;
     //Get the amount of files in the tree
-    int filecount = mModel.rowCount();
+    const int filecount = mModel->rowCount();
 
     for (int i = 0; i < filecount; i++) {
         //Get file i
-        QStandardItem *fileItem = mModel.item(i, 0);
+        auto *fileItem = dynamic_cast<ResultItem*>(mModel->item(i, 0));
         if (!fileItem) {
             continue;
         }
 
         //Get the amount of errors this file contains
-        int errorcount = fileItem->rowCount();
+        const int errorcount = fileItem->rowCount();
 
         //By default it shouldn't be visible
-        bool show = false;
+        bool showFile = false;
 
         for (int j = 0; j < errorcount; j++) {
             //Get the error itself
-            QStandardItem *child = fileItem->child(j, 0);
+            const auto *child = dynamic_cast<ResultItem*>(fileItem->child(j, 0));
             if (!child) {
                 continue;
             }
 
-            //Get error's user data
-            QVariant userdata = child->data();
-            //Convert it to QVariantMap
-            QVariantMap data = userdata.toMap();
-
             //Check if this error should be hidden
-            bool hide = (data["hide"].toBool() || !mShowSeverities.isShown(ShowTypes::VariantToShowType(data["severity"])));
-
-            //If specified, filter on summary, message, filename, and id
-            if (!hide && !mFilter.isEmpty()) {
-                if (!data["summary"].toString().contains(mFilter, Qt::CaseInsensitive) &&
-                    !data["message"].toString().contains(mFilter, Qt::CaseInsensitive) &&
-                    !data["file"].toString().contains(mFilter, Qt::CaseInsensitive) &&
-                    !data["id"].toString().contains(mFilter, Qt::CaseInsensitive)) {
-                    hide = true;
-                }
-            }
-
-            // Tool filter
-            if (!hide) {
-                if (data["id"].toString().startsWith("clang"))
-                    hide = !mShowClang;
-                else
-                    hide = !mShowCppcheck;
-            }
+            const bool hide = child->hidden || isErrorItemHidden(child->errorItem);
 
             if (!hide) {
+                showFile = true;
                 mVisibleErrors = true;
             }
 
             //Hide/show accordingly
             setRowHidden(j, fileItem->index(), hide);
-
-            //If it was shown then the file itself has to be shown as well
-            if (!hide) {
-                show = true;
-            }
         }
 
-        //Hide the file if its "hide" attribute is set
-        if (fileItem->data().toMap()["hide"].toBool()) {
-            show = false;
-        }
+        // Show the file if any of it's errors are visible
+        setRowHidden(i, QModelIndex(), !showFile);
+    }
+    sortByColumn(header()->sortIndicatorSection(), header()->sortIndicatorOrder());
+}
 
-        //Show the file if any of it's errors are visible
-        setRowHidden(i, QModelIndex(), !show);
+bool ResultsTree::isErrorItemHidden(const QSharedPointer<ErrorItem>& errorItem) const {
+    //Check if this error should be hidden
+    if (mHiddenMessageId.contains(errorItem->errorId))
+        return true;
+
+    bool hide;
+    if (mReportType == ReportType::normal)
+        hide = !mShowSeverities.isShown(errorItem->severity);
+    else
+        hide = errorItem->classification.isEmpty() || !mShowSeverities.isShown(getSeverityFromClassification(errorItem->classification));
+
+    // If specified, filter on summary, message, filename, and id
+    if (!hide && !mFilter.isEmpty())
+        hide = !errorItem->filterMatch(mFilter);
+
+    // Tool filter
+    if (!hide) {
+        if (errorItem->isClangResult())
+            hide = !mShowClang;
+        else
+            hide = !mShowCppcheck;
     }
+
+    return hide;
 }
 
-QStandardItem *ResultsTree::ensureFileItem(const QString &fullpath, const QString &file0, bool hide)
+ResultItem *ResultsTree::ensureFileItem(const QSharedPointer<ErrorItem>& errorItem, bool hide)
 {
-    QString name = stripPath(fullpath, false);
+    QString name = QDir::toNativeSeparators(stripPath(errorItem->getFile(), false));
     // Since item has path with native separators we must use path with
     // native separators to find it.
-    QStandardItem *item = findFileItem(QDir::toNativeSeparators(name));
+    ResultItem *fileItem = findFileItem(name);
 
-    if (item) {
-        return item;
+    if (fileItem) {
+        if (!hide)
+            setRowHidden(fileItem->row(), QModelIndex(), hide);
+        return fileItem;
     }
 
     // Ensure shown path is with native separators
-    name = QDir::toNativeSeparators(name);
-    item = createNormalItem(name);
-    item->setIcon(QIcon(":images/text-x-generic.png"));
+    fileItem = createFilenameItem(errorItem, ResultItem::Type::file, errorItem->getMainLocIndex());
+    fileItem->setIcon(QIcon(":images/text-x-generic.png"));
 
-    //Add user data to that item
-    QMap<QString, QVariant> data;
-    data["file"] = fullpath;
-    data["file0"] = file0;
-    item->setData(QVariant(data));
-    mModel.appendRow(item);
+    mModel->appendRow(fileItem);
 
-    setRowHidden(mModel.rowCount() - 1, QModelIndex(), hide);
+    setRowHidden(fileItem->row(), QModelIndex(), hide);
 
-    return item;
+    return fileItem;
 }
 
 void ResultsTree::contextMenuEvent(QContextMenuEvent * e)
@@ -561,45 +610,39 @@ void ResultsTree::contextMenuEvent(QContextMenuEvent * e)
     QModelIndex index = indexAt(e->pos());
     if (index.isValid()) {
         bool multipleSelection = false;
+
         mSelectionModel = selectionModel();
         if (mSelectionModel->selectedRows().count() > 1)
             multipleSelection = true;
 
-        mContextItem = mModel.itemFromIndex(index);
+        mContextItem = dynamic_cast<ResultItem*>(mModel->itemFromIndex(index));
 
         //Create a new context menu
         QMenu menu(this);
 
-        //Store all applications in a list
-        QList<QAction*> actions;
-
         //Create a signal mapper so we don't have to store data to class
         //member variables
-        QSignalMapper *signalMapper = new QSignalMapper(this);
+        QSignalMapper signalMapper;
 
         if (mContextItem && mApplications->getApplicationCount() > 0 && mContextItem->parent()) {
             //Create an action for the application
             int defaultApplicationIndex = mApplications->getDefaultApplication();
-            if (defaultApplicationIndex < 0)
-                defaultApplicationIndex = 0;
+            defaultApplicationIndex = std::max(defaultApplicationIndex, 0);
             const Application& app = mApplications->getApplication(defaultApplicationIndex);
-            QAction *start = new QAction(app.getName(), &menu);
+            auto *start = new QAction(app.getName(), &menu);
             if (multipleSelection)
                 start->setDisabled(true);
 
-            //Add it to our list so we can disconnect later on
-            actions << start;
-
             //Add it to context menu
             menu.addAction(start);
 
             //Connect the signal to signal mapper
-            connect(start, SIGNAL(triggered()), signalMapper, SLOT(map()));
+            connect(start, &QAction::triggered, &signalMapper, QOverload<>::of(&QSignalMapper::map));
 
             //Add a new mapping
-            signalMapper->setMapping(start, defaultApplicationIndex);
+            signalMapper.setMapping(start, defaultApplicationIndex);
 
-            connect(signalMapper, SIGNAL(mapped(int)),
+            connect(&signalMapper, SIGNAL(mappedInt(int)),
                     this, SLOT(context(int)));
         }
 
@@ -609,55 +652,76 @@ void ResultsTree::contextMenuEvent(QContextMenuEvent * e)
                 menu.addSeparator();
             }
 
+            int selectedFiles = 0;
+            int selectedResults = 0;
+
+            for (auto row : mSelectionModel->selectedRows()) {
+                auto *item = mModel->itemFromIndex(row);
+                if (!item->parent())
+                    selectedFiles++;
+                else if (!item->parent()->parent())
+                    selectedResults++;
+            }
+
             //Create an action for the application
-            QAction *recheckSelectedFiles   = new QAction(tr("Recheck"), &menu);
-            QAction *copy                   = new QAction(tr("Copy"), &menu);
-            QAction *hide                   = new QAction(tr("Hide"), &menu);
-            QAction *hideallid              = new QAction(tr("Hide all with id"), &menu);
-            QAction *suppress               = new QAction(tr("Suppress selected id(s)"), &menu);
-            QAction *opencontainingfolder   = new QAction(tr("Open containing folder"), &menu);
-
-            if (multipleSelection) {
+            auto *recheckAction          = new QAction(tr("Recheck %1 file(s)").arg(selectedFiles), &menu);
+            auto *copyAction             = new QAction(tr("Copy"), &menu);
+            auto *hide                   = new QAction(tr("Hide %1 result(s)").arg(selectedResults), &menu);
+            auto *hideallid              = new QAction(tr("Hide all with id"), &menu);
+            auto *opencontainingfolder   = new QAction(tr("Open containing folder"), &menu);
+
+            if (selectedFiles == 0 || mThread->isChecking() || mResultsSource == ResultsSource::Log)
+                recheckAction->setDisabled(true);
+
+            if (selectedResults == 0)
+                hide->setDisabled(true);
+
+            if (selectedResults == 0 || multipleSelection)
                 hideallid->setDisabled(true);
+
+            if (multipleSelection || mResultsSource == ResultsSource::Log)
                 opencontainingfolder->setDisabled(true);
-            }
-            if (mThread->isChecking())
-                recheckSelectedFiles->setDisabled(true);
-            else
-                recheckSelectedFiles->setDisabled(false);
 
-            menu.addAction(recheckSelectedFiles);
+            menu.addAction(recheckAction);
             menu.addSeparator();
-            menu.addAction(copy);
+            menu.addAction(copyAction);
             menu.addSeparator();
             menu.addAction(hide);
             menu.addAction(hideallid);
+
+            auto *suppress = new QAction(tr("Suppress selected id(s)"), &menu);
+            {
+                if (selectedResults == 0 || ErrorLogger::isCriticalErrorId(mContextItem->errorItem->errorId.toStdString()))
+                    suppress->setDisabled(true);
+            }
             menu.addAction(suppress);
+            connect(suppress, &QAction::triggered, this, &ResultsTree::suppressSelectedIds);
+
             menu.addSeparator();
             menu.addAction(opencontainingfolder);
 
-            connect(recheckSelectedFiles, SIGNAL(triggered()), this, SLOT(recheckSelectedFiles()));
-            connect(copy, SIGNAL(triggered()), this, SLOT(copy()));
-            connect(hide, SIGNAL(triggered()), this, SLOT(hideResult()));
-            connect(hideallid, SIGNAL(triggered()), this, SLOT(hideAllIdResult()));
-            connect(suppress, SIGNAL(triggered()), this, SLOT(suppressSelectedIds()));
-            connect(opencontainingfolder, SIGNAL(triggered()), this, SLOT(openContainingFolder()));
+            connect(recheckAction, &QAction::triggered, this, &ResultsTree::recheckSelectedFiles);
+            connect(copyAction, &QAction::triggered, this, &ResultsTree::copy);
+            connect(hide, &QAction::triggered, this, &ResultsTree::hideResult);
+            connect(hideallid, &QAction::triggered, this, &ResultsTree::hideAllIdResult);
+            connect(opencontainingfolder, &QAction::triggered, this, &ResultsTree::openContainingFolder);
 
-            if (!mTags.isEmpty()) {
+            const ProjectFile *currentProject = ProjectFile::getActiveProject();
+            if (currentProject && !currentProject->getTags().isEmpty()) {
                 menu.addSeparator();
                 QMenu *tagMenu = menu.addMenu(tr("Tag"));
                 {
-                    QAction *action = new QAction(tr("No tag"), tagMenu);
+                    auto *action = new QAction(tr("No tag"), tagMenu);
                     tagMenu->addAction(action);
-                    connect(action, &QAction::triggered, [=]() {
+                    connect(action, &QAction::triggered, [this]() {
                         tagSelectedItems(QString());
                     });
                 }
 
-                foreach (const QString tagstr, mTags) {
-                    QAction *action = new QAction(tagstr, tagMenu);
+                for (const QString& tagstr : currentProject->getTags()) {
+                    auto *action = new QAction(tagstr, tagMenu);
                     tagMenu->addAction(action);
-                    connect(action, &QAction::triggered, [=]() {
+                    connect(action, &QAction::triggered, [tagstr, this]() {
                         tagSelectedItems(tagstr);
                     });
                 }
@@ -667,25 +731,12 @@ void ResultsTree::contextMenuEvent(QContextMenuEvent * e)
         //Start the menu
         menu.exec(e->globalPos());
         index = indexAt(e->pos());
-        if (index.isValid()) {
-            mContextItem = mModel.itemFromIndex(index);
-            if (mContextItem && mApplications->getApplicationCount() > 0 && mContextItem->parent()) {
-                //Disconnect all signals
-                for (int i = 0; i < actions.size(); i++) {
-
-                    disconnect(actions[i], SIGNAL(triggered()), signalMapper, SLOT(map()));
-                }
-
-                disconnect(signalMapper, SIGNAL(mapped(int)),
-                           this, SLOT(context(int)));
-                //And remove the signal mapper
-                delete signalMapper;
-            }
-        }
+        if (index.isValid())
+            mContextItem = dynamic_cast<ResultItem*>(mModel->itemFromIndex(index));
     }
 }
 
-void ResultsTree::startApplication(QStandardItem *target, int application)
+void ResultsTree::startApplication(const ResultItem *target, int application)
 {
     //If there are no applications specified, tell the user about it
     if (mApplications->getApplicationCount() == 0) {
@@ -711,25 +762,16 @@ void ResultsTree::startApplication(QStandardItem *target, int application)
                         this);
         msg.exec();
         return;
-
     }
 
     if (target && application >= 0 && application < mApplications->getApplicationCount() && target->parent()) {
-        // Make sure we are working with the first column
-        if (target->column() != 0)
-            target = target->parent()->child(target->row(), 0);
-
-        QVariantMap data = target->data().toMap();
+        const auto& errorPathItem = target->getErrorPathItem();
 
         //Replace (file) with filename
-        QString file = data["file"].toString();
-        file = QDir::toNativeSeparators(file);
-#ifdef Q_OS_WIN
-        file.replace(QString("\\"), QString("\\\\"));
-#endif
+        QString file = QDir::toNativeSeparators(errorPathItem.file);
         qDebug() << "Opening file: " << file;
 
-        QFileInfo info(file);
+        const QFileInfo info(file);
         if (!info.exists()) {
             if (info.isAbsolute()) {
                 QMessageBox msgbox(this);
@@ -758,11 +800,10 @@ void ResultsTree::startApplication(QStandardItem *target, int application)
         QString params = app.getParameters();
         params.replace("(file)", file, Qt::CaseInsensitive);
 
-        QVariant line = data["line"];
-        params.replace("(line)", QString("%1").arg(line.toInt()), Qt::CaseInsensitive);
+        params.replace("(line)", QString::number(errorPathItem.line), Qt::CaseInsensitive);
 
-        params.replace("(message)", data["message"].toString(), Qt::CaseInsensitive);
-        params.replace("(severity)", data["severity"].toString(), Qt::CaseInsensitive);
+        params.replace("(message)", target->errorItem->message, Qt::CaseInsensitive);
+        params.replace("(severity)", severityToTranslatedString(target->errorItem->severity), Qt::CaseInsensitive);
 
         QString program = app.getPath();
 
@@ -776,9 +817,7 @@ void ResultsTree::startApplication(QStandardItem *target, int application)
         }
 #endif // Q_OS_WIN
 
-        const QString cmdLine = QString("%1 %2").arg(program).arg(params);
-
-        bool success = QProcess::startDetached(cmdLine);
+        const bool success = QProcess::startDetached(program, QProcess::splitCommand(params));
         if (!success) {
             QString text = tr("Could not start %1\n\nPlease check the application path and parameters are correct.").arg(program);
 
@@ -812,14 +851,14 @@ QString ResultsTree::askFileDir(const QString &file)
     msgbox.exec();
 
     QString dir = QFileDialog::getExistingDirectory(this, title,
-                  getPath(SETTINGS_LAST_SOURCE_PATH),
-                  QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
+                                                    getPath(SETTINGS_LAST_SOURCE_PATH),
+                                                    QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
 
     if (dir.isEmpty())
         return QString();
 
     // User selected root path
-    if (QFileInfo(dir + '/' + file).exists())
+    if (QFileInfo::exists(dir + '/' + file))
         mCheckPath = dir;
 
     // user selected checked folder
@@ -828,7 +867,7 @@ QString ResultsTree::askFileDir(const QString &file)
         QString folderName = file.mid(0, file.indexOf('/'));
         if (dir.indexOf('/' + folderName + '/'))
             dir = dir.mid(0, dir.lastIndexOf('/' + folderName + '/'));
-        if (QFileInfo(dir + '/' + file).exists())
+        if (QFileInfo::exists(dir + '/' + file))
             mCheckPath = dir;
     }
 
@@ -845,28 +884,19 @@ void ResultsTree::copy()
     if (!mSelectionModel)
         return;
 
-    QModelIndexList selectedRows = mSelectionModel->selectedRows();
     QString text;
-    foreach (QModelIndex index, selectedRows) {
-        QStandardItem *item = mModel.itemFromIndex(index);
-        if (!item->parent()) {
-            text += item->text() + '\n';
+    for (const QModelIndex& index : mSelectionModel->selectedRows()) {
+        const auto *item = dynamic_cast<ResultItem*>(mModel->itemFromIndex(index));
+        if (!item)
             continue;
+        if (item->getType() == ResultItem::Type::file)
+            text += item->text() + '\n';
+        else if (item->getType() == ResultItem::Type::message)
+            text += item->errorItem->toString() + '\n';
+        else if (item->getType() == ResultItem::Type::note) {
+            const auto e = item->getErrorPathItem();
+            text += e.file + ":" + QString::number(e.line) + ":" + QString::number(e.column) + ":note: " + e.info + '\n';
         }
-        if (item->parent()->parent())
-            item = item->parent();
-        QVariantMap data = item->data().toMap();
-        if (!data.contains("id"))
-            continue;
-        QString inconclusive = data["inconclusive"].toBool() ? ",inconclusive" : "";
-        text += '[' + data["file"].toString() + ':' + QString::number(data["line"].toInt())
-                + "] ("
-                + QString::fromStdString(Severity::toString(ShowTypes::ShowTypeToSeverity((ShowTypes::ShowType)data["severity"].toInt()))) + inconclusive
-                + ") "
-                + data["message"].toString()
-                + " ["
-                + data["id"].toString()
-                + "]\n";
     }
 
     QClipboard *clipboard = QApplication::clipboard();
@@ -877,15 +907,13 @@ void ResultsTree::hideResult()
 {
     if (!mSelectionModel)
         return;
-
-    QModelIndexList selectedRows = mSelectionModel->selectedRows();
-    foreach (QModelIndex index, selectedRows) {
-        QStandardItem *item = mModel.itemFromIndex(index);
-        //Set the "hide" flag for this item
-        QVariantMap data = item->data().toMap();
-        data["hide"] = true;
-        item->setData(QVariant(data));
-
+    bool hide = false;
+    for (const QModelIndex& index : mSelectionModel->selectedRows()) {
+        auto *item = dynamic_cast<ResultItem*>(mModel->itemFromIndex(index));
+        if (item && item->getType() == ResultItem::Type::message)
+            hide = item->hidden = true;
+    }
+    if (hide) {
         refreshTree();
         emit resultsHidden(true);
     }
@@ -896,17 +924,16 @@ void ResultsTree::recheckSelectedFiles()
     if (!mSelectionModel)
         return;
 
-    QModelIndexList selectedRows = mSelectionModel->selectedRows();
     QStringList selectedItems;
-    foreach (QModelIndex index, selectedRows) {
-        QStandardItem *item = mModel.itemFromIndex(index);
+    for (const QModelIndex& index : mSelectionModel->selectedRows()) {
+        const auto *item = dynamic_cast<ResultItem*>(mModel->itemFromIndex(index));
         while (item->parent())
-            item = item->parent();
-        QVariantMap data = item->data().toMap();
-        QString currentFile = data["file"].toString();
+            item = dynamic_cast<const ResultItem*>(item->parent());
+        const auto e = item->getErrorPathItem();
+        const QString currentFile = e.file;
         if (!currentFile.isEmpty()) {
             QString fileNameWithCheckPath;
-            QFileInfo curfileInfo(currentFile);
+            const QFileInfo curfileInfo(currentFile);
             if (!curfileInfo.exists() && !mCheckPath.isEmpty() && currentFile.indexOf(mCheckPath) != 0)
                 fileNameWithCheckPath = mCheckPath + "/" + currentFile;
             else
@@ -917,58 +944,24 @@ void ResultsTree::recheckSelectedFiles()
                 return;
             }
             if (Path::isHeader(currentFile.toStdString())) {
-                if (!data["file0"].toString().isEmpty() && !selectedItems.contains(data["file0"].toString())) {
-                    selectedItems<<((!mCheckPath.isEmpty() && (data["file0"].toString().indexOf(mCheckPath) != 0)) ? (mCheckPath + "/" + data["file0"].toString()) : data["file0"].toString());
+                if (!item->errorItem->file0.isEmpty() && !selectedItems.contains(item->errorItem->file0)) {
+                    selectedItems << ((!mCheckPath.isEmpty() && (item->errorItem->file0.indexOf(mCheckPath) != 0)) ? (mCheckPath + "/" + item->errorItem->file0) : item->errorItem->file0);
                     if (!selectedItems.contains(fileNameWithCheckPath))
-                        selectedItems<<fileNameWithCheckPath;
+                        selectedItems << fileNameWithCheckPath;
                 }
             } else if (!selectedItems.contains(fileNameWithCheckPath))
-                selectedItems<<fileNameWithCheckPath;
+                selectedItems << fileNameWithCheckPath;
         }
     }
-    emit checkSelected(selectedItems);
+    emit checkSelected(std::move(selectedItems));
 }
 
 void ResultsTree::hideAllIdResult()
 {
-    if (!mContextItem || !mContextItem->parent())
+    if (!mContextItem || mContextItem->getType() == ResultItem::Type::file)
         return;
 
-    // Make sure we are working with the first column
-    if (mContextItem->column() != 0)
-        mContextItem = mContextItem->parent()->child(mContextItem->row(), 0);
-    QVariantMap data = mContextItem->data().toMap();
-
-    QString messageId = data["id"].toString();
-
-    mHiddenMessageId.append(messageId);
-
-    // hide all errors with that message Id
-    int filecount = mModel.rowCount();
-    for (int i = 0; i < filecount; i++) {
-        //Get file i
-        QStandardItem *file = mModel.item(i, 0);
-        if (!file) {
-            continue;
-        }
-
-        //Get the amount of errors this file contains
-        int errorcount = file->rowCount();
-
-        for (int j = 0; j < errorcount; j++) {
-            //Get the error itself
-            QStandardItem *child = file->child(j, 0);
-            if (!child) {
-                continue;
-            }
-
-            QVariantMap userdata = child->data().toMap();
-            if (userdata["id"].toString() == messageId) {
-                userdata["hide"] = true;
-                child->setData(QVariant(userdata));
-            }
-        }
-    }
+    mHiddenMessageId.append(mContextItem->errorItem->errorId);
 
     refreshTree();
     emit resultsHidden(true);
@@ -979,41 +972,74 @@ void ResultsTree::suppressSelectedIds()
     if (!mSelectionModel)
         return;
 
-    QModelIndexList selectedRows = mSelectionModel->selectedRows();
     QSet<QString> selectedIds;
-    foreach (QModelIndex index, selectedRows) {
-        QStandardItem *item = mModel.itemFromIndex(index);
-        if (!item->parent())
-            continue;
-        if (item->parent()->parent())
-            item = item->parent();
-        QVariantMap data = item->data().toMap();
-        if (!data.contains("id"))
+    for (const QModelIndex& index : mSelectionModel->selectedRows()) {
+        const auto *item = dynamic_cast<ResultItem*>(mModel->itemFromIndex(index));
+        if (!item || item->getType() == ResultItem::Type::file || !item->errorItem)
             continue;
-        selectedIds << data["id"].toString();
+        selectedIds << item->errorItem->errorId;
     }
 
     // delete all errors with selected message Ids
-    for (int i = 0; i < mModel.rowCount(); i++) {
-        QStandardItem * const file = mModel.item(i, 0);
+    for (int i = 0; i < mModel->rowCount(); i++) {
+        QStandardItem * const file = mModel->item(i, 0);
         for (int j = 0; j < file->rowCount();) {
-            QStandardItem *errorItem = file->child(j, 0);
-            QVariantMap userdata = errorItem->data().toMap();
-            if (selectedIds.contains(userdata["id"].toString())) {
+            const auto *errorItem = dynamic_cast<ResultItem*>(file->child(j, 0));
+            if (errorItem && errorItem->errorItem && selectedIds.contains(errorItem->errorItem->errorId)) {
                 file->removeRow(j);
             } else {
                 j++;
             }
         }
+        if (file->rowCount() == 0)
+            mModel->removeRow(file->row());
     }
 
+    if (!selectedIds.isEmpty()) {
+        refreshTree(); // If all visible warnings was suppressed then the file item should be hidden
+        emit suppressIds(selectedIds.values());
+    }
+}
+
+void ResultsTree::suppressHash()
+{
+    if (!mSelectionModel)
+        return;
+
+    bool changed = false;
+    ProjectFile *projectFile = ProjectFile::getActiveProject();
+
+    for (QModelIndex index : mSelectionModel->selectedRows()) {
+        auto *item = dynamic_cast<ResultItem *>(mModel->itemFromIndex(index));
+        if (!item || item->getType() == ResultItem::Type::file)
+            continue;
+        if (item->getType() == ResultItem::Type::note)
+            item = dynamic_cast<ResultItem *>(item->parent());
+
+        // Suppress
+        if (projectFile && item->errorItem->hash > 0) {
+            SuppressionList::Suppression suppression;
+            suppression.hash = item->errorItem->hash;
+            projectFile->addSuppression(suppression);
+            changed = true;
+        }
+
+        // Remove item
+        QStandardItem *fileItem = item->parent();
+        fileItem->removeRow(item->row());
+        if (fileItem->rowCount() == 0)
+            mModel->removeRow(fileItem->row());
+    }
 
-    emit suppressIds(selectedIds.toList());
+    if (changed)
+        projectFile->write();
 }
 
 void ResultsTree::openContainingFolder()
 {
-    QString filePath = getFilePath(mContextItem, true);
+    if (!mContextItem)
+        return;
+    QString filePath = mContextItem->getErrorPathItem().file;
     if (!filePath.isEmpty()) {
         filePath = QFileInfo(filePath).absolutePath();
         QDesktopServices::openUrl(QUrl::fromLocalFile(filePath));
@@ -1025,18 +1051,22 @@ void ResultsTree::tagSelectedItems(const QString &tag)
     if (!mSelectionModel)
         return;
     bool isTagged = false;
-    foreach (QModelIndex index, mSelectionModel->selectedRows()) {
-        QStandardItem *item = mModel.itemFromIndex(index);
-        QVariantMap data = item->data().toMap();
-        if (data.contains("tags")) {
-            data["tags"] = tag;
-            item->setData(QVariant(data));
+    ProjectFile *currentProject = ProjectFile::getActiveProject();
+    for (QModelIndex index : mSelectionModel->selectedRows()) {
+        auto *item = dynamic_cast<ResultItem*>(mModel->itemFromIndex(index));
+        if (item && item->getType() != ResultItem::Type::file) {
+            if (item->getType() == ResultItem::Type::note)
+                item = dynamic_cast<ResultItem*>(item->parent());
+            item->errorItem->tags = tag;
             item->parent()->child(index.row(), COLUMN_TAGS)->setText(tag);
-            isTagged = true;
+            if (currentProject && item->errorItem->hash > 0) {
+                isTagged = true;
+                currentProject->setWarningTags(item->errorItem->hash, tag);
+            }
         }
     }
     if (isTagged)
-        emit tagged();
+        currentProject->write();
 }
 
 void ResultsTree::context(int application)
@@ -1046,34 +1076,10 @@ void ResultsTree::context(int application)
 
 void ResultsTree::quickStartApplication(const QModelIndex &index)
 {
-    startApplication(mModel.itemFromIndex(index));
+    startApplication(dynamic_cast<ResultItem*>(mModel->itemFromIndex(index)));
 }
 
-QString ResultsTree::getFilePath(QStandardItem *target, bool fullPath)
-{
-    if (target) {
-        // Make sure we are working with the first column
-        if (target->column() != 0)
-            target = target->parent()->child(target->row(), 0);
-
-        QVariantMap data = target->data().toMap();
-        QString pathStr;
-
-        //Replace (file) with filename
-        QString file = data["file"].toString();
-        pathStr = QDir::toNativeSeparators(file);
-        if (!fullPath) {
-            QFileInfo fi(pathStr);
-            pathStr = fi.fileName();
-        }
-
-        return pathStr;
-    }
-
-    return QString();
-}
-
-QString ResultsTree::severityToIcon(Severity::SeverityType severity) const
+QString ResultsTree::severityToIcon(Severity severity)
 {
     switch (severity) {
     case Severity::error:
@@ -1097,22 +1103,22 @@ void ResultsTree::saveResults(Report *report) const
 {
     report->writeHeader();
 
-    for (int i = 0; i < mModel.rowCount(); i++) {
+    for (int i = 0; i < mModel->rowCount(); i++) {
         if (mSaveAllErrors || !isRowHidden(i, QModelIndex()))
-            saveErrors(report, mModel.item(i, 0));
+            saveErrors(report, dynamic_cast<ResultItem*>(mModel->item(i, 0)));
     }
 
     report->writeFooter();
 }
 
-void ResultsTree::saveErrors(Report *report, QStandardItem *fileItem) const
+void ResultsTree::saveErrors(Report *report, const ResultItem *fileItem) const
 {
     if (!fileItem) {
         return;
     }
 
     for (int i = 0; i < fileItem->rowCount(); i++) {
-        const QStandardItem *error = fileItem->child(i, 0);
+        const auto *error = dynamic_cast<ResultItem*>(fileItem->child(i, 0));
 
         if (!error) {
             continue;
@@ -1122,103 +1128,52 @@ void ResultsTree::saveErrors(Report *report, QStandardItem *fileItem) const
             continue;
         }
 
-        ErrorItem item;
-        readErrorItem(error, &item);
-
-        report->writeError(item);
-    }
-}
-
-static int indexOf(const QList<ErrorItem> &list, const ErrorItem &item)
-{
-    for (int i = 0; i < list.size(); i++) {
-        if (ErrorItem::sameCID(item, list[i])) {
-            return i;
-        }
+        report->writeError(*error->errorItem);
     }
-    return -1;
 }
 
 void ResultsTree::updateFromOldReport(const QString &filename)
 {
+    showColumn(COLUMN_SINCE_DATE);
+
     QList<ErrorItem> oldErrors;
-    XmlReportV2 oldReport(filename);
+    XmlReportV2 oldReport(filename, QString());
     if (oldReport.open()) {
         oldErrors = oldReport.read();
         oldReport.close();
     }
 
     // Read current results..
-    for (int i = 0; i < mModel.rowCount(); i++) {
-        QStandardItem *fileItem = mModel.item(i,0);
+    for (int i = 0; i < mModel->rowCount(); i++) {
+        auto *fileItem = dynamic_cast<ResultItem*>(mModel->item(i,COLUMN_FILE));
         for (int j = 0; j < fileItem->rowCount(); j++) {
-            QStandardItem *error = fileItem->child(j,0);
-            ErrorItem errorItem;
-            readErrorItem(error, &errorItem);
-            int oldErrorIndex = indexOf(oldErrors, errorItem);
-            QVariantMap data = error->data().toMap();
+            auto *error = dynamic_cast<ResultItem*>(fileItem->child(j,COLUMN_FILE));
+            if (!error)
+                // FIXME..
+                continue;
+            const auto it = std::find_if(oldErrors.cbegin(),
+                                         oldErrors.cend(),
+                                         [error](const ErrorItem& err) {
+                return ErrorItem::same(err, *error->errorItem);
+            });
+            const ErrorItem* oldError = (it == oldErrors.cend()) ? nullptr : &*it;
 
             // New error .. set the "sinceDate" property
-            if (oldErrorIndex >= 0 && !oldErrors[oldErrorIndex].sinceDate.isEmpty()) {
-                data["sinceDate"] = oldErrors[oldErrorIndex].sinceDate;
-                error->setData(data);
-                fileItem->child(j, COLUMN_SINCE_DATE)->setText(oldErrors[oldErrorIndex].sinceDate);
-            } else if (oldErrorIndex < 0 || data["sinceDate"].toString().isEmpty()) {
-                const QString sinceDate = QDate::currentDate().toString(Qt::SystemLocaleShortDate);
-                data["sinceDate"] = sinceDate;
-                error->setData(data);
+            if (oldError && !oldError->sinceDate.isEmpty()) {
+                error->errorItem->sinceDate = oldError->sinceDate;
+                fileItem->child(j, COLUMN_SINCE_DATE)->setText(error->errorItem->sinceDate);
+            } else if (oldError == nullptr || error->errorItem->sinceDate.isEmpty()) {
+                const QString sinceDate = QLocale::system().toString(QDate::currentDate(), QLocale::ShortFormat);
+                error->errorItem->sinceDate = sinceDate;
                 fileItem->child(j, COLUMN_SINCE_DATE)->setText(sinceDate);
-                if (oldErrorIndex < 0)
-                    continue;
             }
 
-            if (!errorItem.tags.isEmpty())
-                continue;
-
-            const ErrorItem &oldErrorItem = oldErrors[oldErrorIndex];
-            data["tags"] = oldErrorItem.tags;
-            error->setData(data);
+            if (oldError && error->errorItem->tags.isEmpty())
+                error->errorItem->tags = oldError->tags;
         }
     }
 }
 
-void ResultsTree::readErrorItem(const QStandardItem *error, ErrorItem *item) const
-{
-    // Get error's user data
-    QVariantMap data = error->data().toMap();
-
-    item->severity = ShowTypes::ShowTypeToSeverity(ShowTypes::VariantToShowType(data["severity"]));
-    item->summary = data["summary"].toString();
-    item->message = data["message"].toString();
-    item->errorId = data["id"].toString();
-    item->inconclusive = data["inconclusive"].toBool();
-    item->file0 = data["file0"].toString();
-    item->sinceDate = data["sinceDate"].toString();
-    item->tags = data["tags"].toString();
-
-    if (error->rowCount() == 0) {
-        QErrorPathItem e;
-        e.file = stripPath(data["file"].toString(), true);
-        e.line = data["line"].toUInt();
-        e.info = data["message"].toString();
-        item->errorPath << e;
-    }
-
-    for (int j = 0; j < error->rowCount(); j++) {
-        const QStandardItem *child_error = error->child(j, 0);
-        //Get error's user data
-        QVariant child_userdata = child_error->data();
-        //Convert it to QVariantMap
-        QVariantMap child_data = child_userdata.toMap();
-
-        QErrorPathItem e;
-        e.file = stripPath(child_data["file"].toString(), true);
-        e.line = child_data["line"].toUInt();
-        e.info = child_data["message"].toString();
-        item->errorPath << e;
-    }
-}
-
 void ResultsTree::updateSettings(bool showFullPath,
                                  bool saveFullPath,
                                  bool saveAllErrors,
@@ -1242,12 +1197,16 @@ void ResultsTree::setCheckDirectory(const QString &dir)
     mCheckPath = dir;
 }
 
-
-QString ResultsTree::getCheckDirectory(void)
+const QString& ResultsTree::getCheckDirectory() const
 {
     return mCheckPath;
 }
 
+void ResultsTree::setResultsSource(ResultsSource source)
+{
+    mResultsSource = source;
+}
+
 QString ResultsTree::stripPath(const QString &path, bool saving) const
 {
     if ((!saving && mShowFullPath) || (saving && mSaveFullPath)) {
@@ -1258,62 +1217,38 @@ QString ResultsTree::stripPath(const QString &path, bool saving) const
     return dir.relativeFilePath(path);
 }
 
-void ResultsTree::refreshFilePaths(QStandardItem *item)
+void ResultsTree::refreshFilePaths(ResultItem *fileItem)
 {
-    if (!item) {
+    if (!fileItem)
         return;
-    }
 
-    //Mark that this file's path hasn't been updated yet
-    bool updated = false;
+    auto refreshItem = [this](ResultItem* item) {
+        item->setText(QDir::toNativeSeparators(stripPath(item->getErrorPathItem().file, false)));
+    };
+
+    refreshItem(fileItem);
 
     //Loop through all errors within this file
-    for (int i = 0; i < item->rowCount(); i++) {
+    for (int i = 0; i < fileItem->rowCount(); i++) {
         //Get error i
-        QStandardItem *error = item->child(i, 0);
+        auto *error = dynamic_cast<ResultItem*>(fileItem->child(i, COLUMN_FILE));
 
         if (!error) {
             continue;
         }
 
-        //Get error's user data
-        QVariant userdata = error->data();
-        //Convert it to QVariantMap
-        QVariantMap data = userdata.toMap();
-
-        //Get list of files
-        QString file = data["file"].toString();
-
         //Update this error's text
-        error->setText(stripPath(file, false));
-
-        //If this error has backtraces make sure the files list has enough filenames
-        if (error->hasChildren()) {
-            //Loop through all files within the error
-            for (int j = 0; j < error->rowCount(); j++) {
-                //Get file
-                QStandardItem *child = error->child(j, 0);
-                if (!child) {
-                    continue;
-                }
-                //Get child's user data
-                QVariant child_userdata = child->data();
-                //Convert it to QVariantMap
-                QVariantMap child_data = child_userdata.toMap();
+        refreshItem(error);
 
-                //Get list of files
-                QString child_files = child_data["file"].toString();
+        //Loop through all files within the error
+        for (int j = 0; j < error->rowCount(); j++) {
+            //Get file
+            auto *child = dynamic_cast<ResultItem*>(error->child(j, COLUMN_FILE));
+            if (child) {
                 //Update file's path
-                child->setText(stripPath(child_files, false));
+                refreshItem(child);
             }
         }
-
-        //if the main file hasn't been updated yet, update it now
-        if (!updated) {
-            updated = true;
-            item->setText(error->text());
-        }
-
     }
 }
 
@@ -1322,8 +1257,8 @@ void ResultsTree::refreshFilePaths()
     qDebug("Refreshing file paths");
 
     //Go through all file items (these are parent items that contain the errors)
-    for (int i = 0; i < mModel.rowCount(); i++) {
-        refreshFilePaths(mModel.item(i, 0));
+    for (int row = 0; row < mModel->rowCount(); row++) {
+        refreshFilePaths(dynamic_cast<ResultItem*>(mModel->item(row, COLUMN_FILE)));
     }
 }
 
@@ -1334,14 +1269,12 @@ bool ResultsTree::hasVisibleResults() const
 
 bool ResultsTree::hasResults() const
 {
-    return mModel.rowCount() > 0;
+    return mModel->rowCount() > 0;
 }
 
 void ResultsTree::translate()
 {
-    QStringList labels;
-    labels << tr("File") << tr("Severity") << tr("Line") << tr("Id") << tr("Inconclusive") << tr("Summary") << tr("Since date") << tr("Tag");
-    mModel.setHorizontalHeaderLabels(labels);
+    mModel->setHorizontalHeaderLabels(getLabels());
     //TODO go through all the errors in the tree and translate severity and message
 }
 
@@ -1349,21 +1282,35 @@ void ResultsTree::showIdColumn(bool show)
 {
     mShowErrorId = show;
     if (show)
-        showColumn(3);
+        showColumn(COLUMN_ID);
     else
-        hideColumn(3);
+        hideColumn(COLUMN_ID);
 }
 
 void ResultsTree::showInconclusiveColumn(bool show)
 {
     if (show)
-        showColumn(4);
+        showColumn(COLUMN_INCONCLUSIVE);
     else
-        hideColumn(4);
+        hideColumn(COLUMN_INCONCLUSIVE);
 }
 
 void ResultsTree::currentChanged(const QModelIndex &current, const QModelIndex &previous)
 {
     QTreeView::currentChanged(current, previous);
-    emit treeSelectionChanged(current);
+    const auto *item = dynamic_cast<ResultItem*>(mModel->itemFromIndex(current));
+    emit treeSelectionChanged(item);
+}
+
+bool ResultsTree::isCertReport() const {
+    return mReportType == ReportType::certC || mReportType == ReportType::certCpp;
+}
+
+bool ResultsTree::isAutosarMisraReport() const {
+    return mReportType == ReportType::autosar ||
+           mReportType == ReportType::misraC2012 ||
+           mReportType == ReportType::misraC2023 ||
+           mReportType == ReportType::misraC2025 ||
+           mReportType == ReportType::misraCpp2008 ||
+           mReportType == ReportType::misraCpp2023;
 }
diff --git a/gui/resultstree.h b/gui/resultstree.h
index dfb4e92f9a8..23fe5567ed9 100644
--- a/gui/resultstree.h
+++ b/gui/resultstree.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,53 +20,55 @@
 #ifndef RESULTSTREE_H
 #define RESULTSTREE_H
 
-#include <QTreeView>
-#include <QStandardItemModel>
-#include <QStandardItem>
-#include <QSettings>
-#include <QContextMenuEvent>
-#include "errorlogger.h" // Severity
 #include "showtypes.h"
+#include "checkers.h"
+#include "resultitem.h"
+
+#include <cstdint>
+#include <map>
+#include <string>
+
+#include <QObject>
+#include <QString>
+#include <QStringList>
+#include <QTreeView>
 
 class ApplicationList;
 class Report;
 class ErrorItem;
-class ErrorLine;
 class QModelIndex;
 class QWidget;
 class QItemSelectionModel;
 class ThreadHandler;
+class QSettings;
+class QStandardItemModel;
+enum class Severity : std::uint8_t;
 
 /// @addtogroup GUI
 /// @{
 
-
 /**
-* @brief Cppcheck's results are shown in this tree
-*
-*/
+ * @brief Cppcheck's results are shown in this tree
+ *
+ */
 class ResultsTree : public QTreeView {
     Q_OBJECT
 public:
     explicit ResultsTree(QWidget * parent = nullptr);
-    virtual ~ResultsTree();
-    void initialize(QSettings *settings, ApplicationList *list, ThreadHandler *checkThreadHandler);
 
-    void setTags(const QStringList &tags) {
-        mTags = tags;
-    }
+    void initialize(QSettings *settings, ApplicationList *list, ThreadHandler *checkThreadHandler);
 
     /**
-    * @brief Add a new item to the tree
-    *
-    * @param item Error item data
-    */
-    bool addErrorItem(const ErrorItem &item);
+     * @brief Add a new item to the tree
+     *
+     * @param errorItem Error item data
+     */
+    bool addErrorItem(const ErrorItem& errorItem);
 
     /**
-    * @brief Clear all errors from the tree
-    *
-    */
+     * @brief Clear all errors from the tree
+     *
+     */
     void clear();
 
     /**
@@ -80,22 +82,28 @@ class ResultsTree : public QTreeView {
     void clearRecheckFile(const QString &filename);
 
     /**
-    * @brief Function to filter the displayed list of errors.
-    * Refreshes the tree.
-    *
-    * @param filter String that must be found in the summary, description, file or id
-    */
+     * @brief Function to filter the displayed list of errors.
+     * Refreshes the tree.
+     *
+     * @param filter String that must be found in the summary, description, file or id
+     */
     void filterResults(const QString& filter);
 
     /**
-    * @brief Function to show results that were previous hidden with HideResult()
-    */
+     * @brief Function to show results that were previous hidden with HideResult()
+     */
     void showHiddenResults();
 
     /**
-    * @brief Save results to a text stream
-    *
-    */
+     * @brief Refresh tree by checking which of the items should be shown
+     * and which should be hidden
+     */
+    void refreshTree();
+
+    /**
+     * @brief Save results to a text stream
+     *
+     */
     void saveResults(Report *report) const;
 
     /**
@@ -104,69 +112,87 @@ class ResultsTree : public QTreeView {
     void updateFromOldReport(const QString &filename);
 
     /**
-    * @brief Update tree settings
-    *
-    * @param showFullPath Show full path of files in the tree
-    * @param saveFullPath Save full path of files in reports
-    * @param saveAllErrors Save all visible errors
-    * @param showErrorId Show error id
-    * @param showInconclusive Show inconclusive column
-    */
+     * @brief Update tree settings
+     *
+     * @param showFullPath Show full path of files in the tree
+     * @param saveFullPath Save full path of files in reports
+     * @param saveAllErrors Save all visible errors
+     * @param showErrorId Show error id
+     * @param showInconclusive Show inconclusive column
+     */
     void updateSettings(bool showFullPath, bool saveFullPath, bool saveAllErrors, bool showErrorId, bool showInconclusive);
 
     /**
-    * @brief Set the directory we are checking
-    *
-    * This is used to split error file path to relative if necessary
-    * @param dir Directory we are checking
-    */
+     * @brief Set the directory we are checking
+     *
+     * This is used to split error file path to relative if necessary
+     * @param dir Directory we are checking
+     */
     void setCheckDirectory(const QString &dir);
 
     /**
-    * @brief Get the directory we are checking
-    *
-    * @return Directory containing source files
-    */
+     * @brief Get the directory we are checking
+     *
+     * @return Directory containing source files
+     */
 
-    QString getCheckDirectory(void);
+    const QString& getCheckDirectory() const;
 
     /**
-    * @brief Check if there are any visible results in view.
-    * @return true if there is at least one visible warning/error.
-    */
+     * @brief Results source for analysis results in the results tree.
+     */
+    enum class ResultsSource : std::uint8_t {
+        /** Results from a project, files, or directory check */
+        Analysis,
+        /** Saved results from a log file */
+        Log,
+    };
+
+    /**
+     * @brief Set the source type of the current results. This
+     * affects the actions that are allowed on them.
+     *
+     * @param source The results source type.
+     */
+    void setResultsSource(ResultsSource source);
+
+    /**
+     * @brief Check if there are any visible results in view.
+     * @return true if there is at least one visible warning/error.
+     */
     bool hasVisibleResults() const;
 
     /**
-    * @brief Do we have results from check?
-    * @return true if there is at least one warning/error, hidden or visible.
-    */
+     * @brief Do we have results from check?
+     * @return true if there is at least one warning/error, hidden or visible.
+     */
     bool hasResults() const;
 
     /**
-    * @brief Save all settings
-    * Column widths
-    */
+     * @brief Save all settings
+     * Column widths
+     */
     void saveSettings() const;
 
     /**
-    * @brief Change all visible texts language
-    *
-    */
+     * @brief Change all visible texts language
+     *
+     */
     void translate();
 
     /**
-    * @brief Show optional column "Id"
-    */
+     * @brief Show optional column "Id"
+     */
     void showIdColumn(bool show);
 
     /**
-    * @brief Show optional column "Inconclusve"
-    */
+     * @brief Show optional column "Inconclusve"
+     */
     void showInconclusiveColumn(bool show);
 
     /**
-    * @brief Returns true if column "Id" is shown
-    */
+     * @brief Returns true if column "Id" is shown
+     */
     bool showIdColumn() const {
         return mShowErrorId;
     }
@@ -176,363 +202,382 @@ class ResultsTree : public QTreeView {
      */
     ShowTypes mShowSeverities;
 
-    virtual void keyPressEvent(QKeyEvent *event);
+    void setReportType(ReportType reportType);
+
+    /**
+     * @brief should errorItem be hidden by filter/severity/etc?
+     * @param errorItem error item
+     * @return true if error item should be hidden
+     */
+    bool isErrorItemHidden(const QSharedPointer<ErrorItem>& errorItem) const;
 
 signals:
     /**
-    * @brief Signal that results have been hidden or shown
-    *
-    * @param hidden true if there are some hidden results, or false if there are not
-    */
+     * @brief Signal that results have been hidden or shown
+     *
+     * @param hidden true if there are some hidden results, or false if there are not
+     */
+    // NOLINTNEXTLINE(readability-inconsistent-declaration-parameter-name) - caused by generated MOC code
     void resultsHidden(bool hidden);
 
     /**
-    * @brief Signal to perform selected files recheck
-    *
-    * @param selectedItems list of selected files
-    */
+     * @brief Signal to perform selected files recheck
+     *
+     * @param selectedItems list of selected files
+     */
+    // NOLINTNEXTLINE(readability-inconsistent-declaration-parameter-name) - caused by generated MOC code
     void checkSelected(QStringList selectedItems);
 
     /**
-    * @brief Signal for selection change in result tree.
-    *
-    * @param current Model index to specify new selected item.
-    */
-    void treeSelectionChanged(const QModelIndex &current);
-
-    /**
-     * Selected item(s) has been tagged
+     * @brief Signal for selection change in result tree.
+     * @param selectedItem item that was selected
      */
-    void tagged();
+    // NOLINTNEXTLINE(readability-inconsistent-declaration-parameter-name) - caused by generated MOC code
+    void treeSelectionChanged(const ResultItem *selectedItem);
 
     /** Suppress Ids */
+    // NOLINTNEXTLINE(readability-inconsistent-declaration-parameter-name) - caused by generated MOC code
     void suppressIds(QStringList ids);
 
 public slots:
 
     /**
-    * @brief Function to show/hide certain type of errors
-    * Refreshes the tree.
-    *
-    * @param type Type of error to show/hide
-    * @param show Should specified errors be shown (true) or hidden (false)
-    */
+     * @brief Function to show/hide certain type of errors
+     * Refreshes the tree.
+     *
+     * @param type Type of error to show/hide
+     * @param show Should specified errors be shown (true) or hidden (false)
+     */
     void showResults(ShowTypes::ShowType type, bool show);
 
 
     /**
-    * @brief Show/hide cppcheck errors.
-    * Refreshes the tree.
-    *
-    * @param show Should specified errors be shown (true) or hidden (false)
-    */
+     * @brief Show/hide cppcheck errors.
+     * Refreshes the tree.
+     *
+     * @param show Should specified errors be shown (true) or hidden (false)
+     */
     void showCppcheckResults(bool show);
 
     /**
-    * @brief Show/hide clang-tidy/clang-analyzer errors.
-    * Refreshes the tree.
-    *
-    * @param show Should specified errors be shown (true) or hidden (false)
-    */
+     * @brief Show/hide clang-tidy/clang-analyzer errors.
+     * Refreshes the tree.
+     *
+     * @param show Should specified errors be shown (true) or hidden (false)
+     */
     void showClangResults(bool show);
 
 protected slots:
     /**
-    * @brief Slot to quickstart an error with default application
-    *
-    * @param index Model index to specify which error item to open
-    */
+     * @brief Slot to quickstart an error with default application
+     *
+     * @param index Model index to specify which error item to open
+     */
     void quickStartApplication(const QModelIndex &index);
 
     /**
-    * @brief Slot for context menu item to open an error with specified application
-    *
-    * @param application Index of the application to open the error
-    */
+     * @brief Slot for context menu item to open an error with specified application
+     *
+     * @param application Index of the application to open the error
+     */
     void context(int application);
 
     /**
-    * @brief Slot for context menu item to copy selection to clipboard
-    */
+     * @brief Slot for context menu item to copy selection to clipboard
+     */
     void copy();
 
     /**
-    * @brief Slot for context menu item to hide the current error message
-    *
-    */
+     * @brief Slot for context menu item to hide the current error message
+     *
+     */
     void hideResult();
 
     /**
-    * @brief Slot for rechecking selected files
-    *
-    */
+     * @brief Slot for rechecking selected files
+     *
+     */
     void recheckSelectedFiles();
 
     /**
-    * @brief Slot for context menu item to hide all messages with the current message Id
-    *
-    */
+     * @brief Slot for context menu item to hide all messages with the current message Id
+     *
+     */
     void hideAllIdResult();
 
     /** Slot for context menu item to suppress all messages with the current message id */
     void suppressSelectedIds();
 
+    /** Slot for context menu item to suppress message with hash */
+    void suppressHash();
+
     /**
-    * @brief Slot for context menu item to open the folder containing the current file.
-    */
+     * @brief Slot for context menu item to open the folder containing the current file.
+     */
     void openContainingFolder();
 
     /**
-    * @brief Slot for selection change in the results tree.
-    *
-    * @param current Model index to specify new selected item.
-    * @param previous Model index to specify previous selected item.
-    */
-    virtual void currentChanged(const QModelIndex &current, const QModelIndex &previous);
+     * @brief Slot for selection change in the results tree.
+     *
+     * @param current Model index to specify new selected item.
+     * @param previous Model index to specify previous selected item.
+     */
+    void currentChanged(const QModelIndex &current, const QModelIndex &previous) override;
 
 protected:
 
     /**
-    * @brief Hides/shows full file path on all error file items according to mShowFullPath
-    *
-    */
+     * @brief Hides/shows full file path on all error file items according to mShowFullPath
+     *
+     */
     void refreshFilePaths();
 
     /**
-    * @brief Hides/shows full file path on all error file items according to mShowFullPath
-    * @param item Parent item whose childrens paths to change
-    */
-    void refreshFilePaths(QStandardItem *item);
+     * @brief Hides/shows full file path on all error file items according to mShowFullPath
+     * @param fileItem Parent item whose children's paths to change
+     */
+    void refreshFilePaths(ResultItem *fileItem);
 
 
     /**
-    * @brief Removes checking directory from given path if mShowFullPath is false
-    *
-    * @param path Path to remove checking directory
-    * @param saving are we saving? Check mSaveFullPath instead
-    * @return Path that has checking directory removed
-    */
+     * @brief Removes checking directory from given path if mShowFullPath is false
+     *
+     * @param path Path to remove checking directory
+     * @param saving are we saving? Check mSaveFullPath instead
+     * @return Path that has checking directory removed
+     */
     QString stripPath(const QString &path, bool saving) const;
 
 
     /**
-    * @brief Save all errors under specified item
-    * @param report Report that errors are saved to
-    * @param fileItem Item whose errors to save
-    */
-    void saveErrors(Report *report, QStandardItem *fileItem) const;
-
-    /**
-    * @brief Convert a severity string to a icon filename
-    *
-    * @param severity Severity
-    */
-    QString severityToIcon(Severity::SeverityType severity) const;
-
-    /**
-    * @brief Helper function to open an error within target with application*
-    *
-    * @param target Error tree item to open
-    * @param application Index of the application to open with. Giving -1
-    *  (default value) will open the default application.
-    */
-    void startApplication(QStandardItem *target, int application = -1);
-
-    /**
-    * @brief Helper function to copy filename/full path to the clipboard
-    *
-    * @param target Error tree item to open
-    * @param fullPath Are we copying full path or only filename?
-    */
-    void copyPathToClipboard(QStandardItem *target, bool fullPath);
-
-    /**
-    * @brief Helper function returning the filename/full path of the error tree item \a target.
-    *
-    * @param target The error tree item containing the filename/full path
-    * @param fullPath Whether or not to retrieve the full path or only the filename.
-    */
-    QString getFilePath(QStandardItem *target, bool fullPath);
+     * @brief Save all errors under specified item
+     * @param report Report that errors are saved to
+     * @param fileItem Item whose errors to save
+     */
+    void saveErrors(Report *report, const ResultItem *fileItem) const;
 
     /**
-    * @brief Context menu event (user right clicked on the tree)
-    *
-    * @param e Event
-    */
-    void contextMenuEvent(QContextMenuEvent * e);
+     * @brief Convert a severity string to a icon filename
+     *
+     * @param severity Severity
+     */
+    static QString severityToIcon(Severity severity);
 
     /**
-    * @brief Add a new error item beneath a file or a backtrace item beneath an error
-    *
-    * @param parent Parent for the item. Either a file item or an error item
-    * @param item Error line data
-    * @param hide Should this be hidden (true) or shown (false)
-    * @param icon Should a default backtrace item icon be added
-    * @param childOfMessage Is this a child element of a message?
-    * @return newly created QStandardItem *
-    */
-    QStandardItem *addBacktraceFiles(QStandardItem *parent,
-                                     const ErrorLine &item,
-                                     const bool hide,
-                                     const QString &icon,
-                                     bool childOfMessage);
-
+     * @brief Helper function to open an error within target with application*
+     *
+     * @param target Error tree item to open
+     * @param application Index of the application to open with. Giving -1
+     *  (default value) will open the default application.
+     */
+    void startApplication(const ResultItem *target, int application = -1);
 
     /**
-    * @brief Refresh tree by checking which of the items should be shown
-    * and which should be hidden
-    *
-    */
-    void refreshTree();
+     * @brief Context menu event (user right clicked on the tree)
+     *
+     * @param e Event
+     */
+    void contextMenuEvent(QContextMenuEvent * e) override;
+
+    /**
+     * @brief Add a new error item beneath a file or a backtrace item beneath an error
+     *
+     * @param parent Parent for the item. Either a file item or an error item
+     * @param errorItem Error item
+     * @param hide Should this be hidden (true) or shown (false)
+     * @param icon Should a default backtrace item icon be added
+     * @param type type of items to create file/message/note
+     * @param errorPathIndex errorPathIndex
+     * @return newly created ResultItem *
+     */
+    ResultItem *addBacktraceFiles(ResultItem *parent,
+                                  const QSharedPointer<ErrorItem>& errorItem,
+                                  bool hide,
+                                  const QString &icon,
+                                  ResultItem::Type type,
+                                  int errorPathIndex);
 
     /**
-    * @brief Convert Severity to translated string for GUI.
-    * @param severity Severity to convert
-    * @return Severity as translated string
-    */
-    static QString severityToTranslatedString(Severity::SeverityType severity);
+     * @brief Convert Severity to translated string for GUI.
+     * @param severity Severity to convert
+     * @return Severity as translated string
+     */
+    static QString severityToTranslatedString(Severity severity);
 
     /**
-    * @brief Load all settings
-    * Column widths
-    */
+     * @brief Load all settings
+     * Column widths
+     */
     void loadSettings();
 
     /**
-    * @brief Ask directory where file is located.
-    * @param file File name.
-    * @return Directory user chose.
-    */
+     * @brief Ask directory where file is located.
+     * @param file File name.
+     * @return Directory user chose.
+     */
     QString askFileDir(const QString &file);
 
     /**
-    * @brief Create new normal item.
-    *
-    * Normal item has left alignment and text set also as tooltip.
-    * @param name name for the item
-    * @return new QStandardItem
-    */
-    static QStandardItem *createNormalItem(const QString &name);
+     * @brief Create new normal item.
+     *
+     * Normal item has left alignment.
+     * @param text text for the item
+     * @param errorItem errorItem pointer
+     * @param type (file/message)
+     * @param errorPathIndex error path index
+     * @return new ResultItem
+     */
+    static ResultItem *createNormalItem(const QString &text, QSharedPointer<ErrorItem> errorItem, ResultItem::Type type, int errorPathIndex);
 
     /**
-    * @brief Create new normal item.
-    *
-    * Normal item has left alignment and text set also as tooltip.
-    * @param checked checked
-    * @return new QStandardItem
-    */
-    static QStandardItem *createCheckboxItem(bool checked);
+     * @brief Create filename item.
+     *
+     * filename item has left alignment. Path is stripped and converted to native path separators.
+     * @param errorItem errorItem pointer
+     * @param type (file/message)
+     * @param errorPathIndex error path index
+     *
+     * @return new ResultItem
+     */
+    ResultItem *createFilenameItem(const QSharedPointer<ErrorItem>& errorItem, ResultItem::Type type, int errorPathIndex);
 
     /**
-    * @brief Create new line number item.
-    *
-    * Line number item has right align and text set as tooltip.
-    * @param linenumber name for the item
-    * @return new QStandardItem
-    */
-    static QStandardItem *createLineNumberItem(const QString &linenumber);
+     * @brief Create new checkbox item.
+     *
+     * Checkbox item can be checked or unchecked.
+     * @param checked checked
+     * @param errorItem errorItem pointer
+     * @param type (file/message)
+     * @param errorPathIndex error path index
+     * @return new ResultItem
+     */
+    static ResultItem *createCheckboxItem(bool checked, QSharedPointer<ErrorItem> errorItem, ResultItem::Type type, int errorPathIndex);
 
     /**
-    * @brief Finds a file item
-    *
-    * @param name name of the file item to find
-    * @return pointer to file item or null if none found
-    */
-    QStandardItem *findFileItem(const QString &name) const;
+     * @brief Create new line number item.
+     *
+     * Line number item has right align.
+     * @param linenumber line number
+     * @param errorItem errorItem pointer
+     * @param type (file/message)
+     * @param errorPathIndex error path index
+     * @return new ResultItem
+     */
+    static ResultItem *createLineNumberItem(int linenumber, QSharedPointer<ErrorItem> errorItem, ResultItem::Type type, int errorPathIndex);
 
+    /**
+     * @brief Finds a file item
+     *
+     * @param name name of the file item to find
+     * @return pointer to file item or null if none found
+     */
+    ResultItem *findFileItem(const QString &name) const;
 
     /**
-    * @brief Ensures there's a item in the model for the specified file
-    *
-    * @param fullpath Full path to the file item.
-    * @param file0 Source file
-    * @param hide is the error (we want this file item for) hidden?
-    * @return QStandardItem to be used as a parent for all errors for specified file
-    */
-    QStandardItem *ensureFileItem(const QString &fullpath, const QString &file0, bool hide);
+     * @brief Ensures there's a item in the model for the specified file
+     *
+     * @param errorItem Error item
+     * @param hide is the error (we want this file item for) hidden?
+     * @return ResultItem to be used as a parent for all errors for specified file
+     */
+    ResultItem *ensureFileItem(const QSharedPointer<ErrorItem>& errorItem, bool hide);
 
     /**
-    * @brief Item model for tree
-    *
-    */
-    QStandardItemModel mModel;
+     * @brief Item model for tree
+     *
+     */
+    QStandardItemModel* mModel;
 
     /**
-    * @brief Program settings
-    *
-    */
-    QSettings *mSettings;
+     * @brief Program settings
+     *
+     */
+    QSettings* mSettings{};
 
     /**
-    * @brief A string used to filter the results for display.
-    *
-    */
+     * @brief A string used to filter the results for display.
+     *
+     */
     QString mFilter;
 
     /**
-    * @brief List of applications to open errors with
-    *
-    */
-    ApplicationList *mApplications;
+     * @brief List of applications to open errors with
+     *
+     */
+    ApplicationList* mApplications{};
 
     /**
-    * @brief Right clicked item (used by context menu slots)
-    *
-    */
-    QStandardItem *mContextItem;
+     * @brief Right clicked item (used by context menu slots)
+     *
+     */
+    ResultItem* mContextItem{};
 
     /**
-    * @brief Should full path of files be shown (true) or relative (false)
-    *
-    */
-    bool mShowFullPath;
+     * @brief Should full path of files be shown (true) or relative (false)
+     *
+     */
+    bool mShowFullPath{};
 
     /**
-    * @brief Should full path of files be saved
-    *
-    */
-    bool mSaveFullPath;
+     * @brief Should full path of files be saved
+     *
+     */
+    bool mSaveFullPath{};
 
     /**
-    * @brief Save all errors (true) or only visible (false)
-    *
-    */
-    bool mSaveAllErrors;
+     * @brief Save all errors (true) or only visible (false)
+     *
+     */
+    bool mSaveAllErrors = true;
 
     /**
-    * @brief true if optional column "Id" is shown
-    *
-    */
-    bool mShowErrorId;
+     * @brief true if optional column "Id" is shown
+     *
+     */
+    bool mShowErrorId{};
 
     /**
-    * @brief Path we are currently checking
-    *
-    */
+     * @brief Path we are currently checking
+     *
+     */
     QString mCheckPath;
 
     /**
-    * @brief Are there any visible errors
-    *
-    */
-    bool mVisibleErrors;
+     * @brief The type of source of the current results
+     *
+     */
+    ResultsSource mResultsSource{ResultsSource::Analysis};
+
+    /**
+     * @brief Are there any visible errors
+     *
+     */
+    bool mVisibleErrors{};
 
 private:
+    void keyPressEvent(QKeyEvent *event) override;
+
     /** tag selected items */
     void tagSelectedItems(const QString &tag);
 
-    /** @brief Convert GUI error item into data error item */
-    void readErrorItem(const QStandardItem *error, ErrorItem *item) const;
+    bool isCertReport() const;
 
-    QStringList mTags;
+    bool isAutosarMisraReport() const;
 
     QStringList mHiddenMessageId;
 
-    QItemSelectionModel *mSelectionModel;
-    ThreadHandler *mThread;
+    // List of existing errors so we can avoid duplicates
+    QStringList mErrorList;
+
+    QItemSelectionModel* mSelectionModel{};
+    ThreadHandler *mThread{};
+
+    bool mShowCppcheck = true;
+    bool mShowClang = true;
+
+    ReportType mReportType = ReportType::normal;
 
-    bool mShowCppcheck;
-    bool mShowClang;
+    std::map<std::string, std::string> mGuideline;
 };
 /// @}
 #endif // RESULTSTREE_H
diff --git a/gui/resultsview.cpp b/gui/resultsview.cpp
index 0bd9b8a57fc..c6c54a2fd85 100644
--- a/gui/resultsview.cpp
+++ b/gui/resultsview.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,110 +16,171 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QMessageBox>
-#include <QStandardItemModel>
-#include <QStandardItem>
-#include <QVariant>
-#include <QString>
-#include <QModelIndex>
-#include <QPrinter>
-#include <QPrintDialog>
-#include <QPrintPreviewDialog>
-#include <QSettings>
-#include <QDir>
-#include <QDate>
-#include <QMenu>
-#include <QClipboard>
 #include "resultsview.h"
+
+#include "checkstatistics.h"
+#include "checkersreport.h"
+#include "codeeditor.h"
+#include "codeeditorstyle.h"
 #include "common.h"
+#include "csvreport.h"
 #include "erroritem.h"
+#include "errorlogger.h"
+#include "errortypes.h"
+#include "path.h"
+#include "printablereport.h"
+#include "resultstree.h"
+#include "settings.h"
 #include "txtreport.h"
 #include "xmlreport.h"
 #include "xmlreportv2.h"
-#include "csvreport.h"
-#include "printablereport.h"
-#include "applicationlist.h"
-#include "checkstatistics.h"
-#include "path.h"
-#include "codeeditorstyle.h"
+
+#include "ui_resultsview.h"
+
+#include <set>
+#include <string>
+
+#include <QAbstractItemModel>
+#include <QApplication>
+#include <QByteArray>
+#include <QClipboard>
+#include <QDate>
+#include <QDateTime>
+#include <QDialog>
+#include <QDir>
+#include <QFile>
+#include <QFileInfo>
+#include <QIODevice>
+#include <QLabel>
+#include <QList>
+#include <QListWidget>
+#include <QListWidgetItem>
+#include <QMenu>
+#include <QMessageBox>
+#include <QPoint>
+#include <QPrintDialog>
+#include <QPrintPreviewDialog>
+#include <QPrinter>
+#include <QProgressBar>
+#include <QSettings>
+#include <QSplitter>
+#include <QStandardItem>
+#include <QStandardItemModel>
+#include <QTextDocument>
+#include <QTextEdit>
+#include <QTextStream>
+#include <Qt>
+
+enum class ReportType : std::uint8_t;
 
 ResultsView::ResultsView(QWidget * parent) :
     QWidget(parent),
-    mShowNoErrorsMessage(true),
+    mUI(new Ui::ResultsView),
     mStatistics(new CheckStatistics(this))
 {
-    mUI.setupUi(this);
+    mUI->setupUi(this);
 
-    connect(mUI.mTree, &ResultsTree::resultsHidden, this, &ResultsView::resultsHidden);
-    connect(mUI.mTree, &ResultsTree::checkSelected, this, &ResultsView::checkSelected);
-    connect(mUI.mTree, &ResultsTree::treeSelectionChanged, this, &ResultsView::updateDetails);
-    connect(mUI.mTree, &ResultsTree::tagged, this, &ResultsView::tagged);
-    connect(mUI.mTree, &ResultsTree::suppressIds, this, &ResultsView::suppressIds);
-    connect(this, &ResultsView::showResults, mUI.mTree, &ResultsTree::showResults);
-    connect(this, &ResultsView::showCppcheckResults, mUI.mTree, &ResultsTree::showCppcheckResults);
-    connect(this, &ResultsView::showClangResults, mUI.mTree, &ResultsTree::showClangResults);
-    connect(this, &ResultsView::collapseAllResults, mUI.mTree, &ResultsTree::collapseAll);
-    connect(this, &ResultsView::expandAllResults, mUI.mTree, &ResultsTree::expandAll);
-    connect(this, &ResultsView::showHiddenResults, mUI.mTree, &ResultsTree::showHiddenResults);
+    connect(mUI->mTree, &ResultsTree::resultsHidden, this, &ResultsView::resultsHidden);
+    connect(mUI->mTree, &ResultsTree::checkSelected, this, &ResultsView::checkSelected);
+    connect(mUI->mTree, &ResultsTree::treeSelectionChanged, this, &ResultsView::updateDetails);
+    connect(mUI->mTree, &ResultsTree::suppressIds, this, &ResultsView::suppressIds);
+    connect(this, &ResultsView::showResults, mUI->mTree, &ResultsTree::showResults);
+    connect(this, &ResultsView::showCppcheckResults, mUI->mTree, &ResultsTree::showCppcheckResults);
+    connect(this, &ResultsView::showClangResults, mUI->mTree, &ResultsTree::showClangResults);
+    connect(this, &ResultsView::collapseAllResults, mUI->mTree, &ResultsTree::collapseAll);
+    connect(this, &ResultsView::expandAllResults, mUI->mTree, &ResultsTree::expandAll);
+    connect(this, &ResultsView::showHiddenResults, mUI->mTree, &ResultsTree::showHiddenResults);
 
-    mUI.mListLog->setContextMenuPolicy(Qt::CustomContextMenu);
+    mUI->mListLog->setContextMenuPolicy(Qt::CustomContextMenu);
 }
 
 void ResultsView::initialize(QSettings *settings, ApplicationList *list, ThreadHandler *checkThreadHandler)
 {
-    mUI.mProgress->setMinimum(0);
-    mUI.mProgress->setVisible(false);
+    mUI->mProgress->setMinimum(0);
+    mUI->mProgress->setVisible(false);
+    mUI->mLabelCriticalErrors->setVisible(false);
 
     CodeEditorStyle theStyle(CodeEditorStyle::loadSettings(settings));
-    mUI.mCode->setStyle(theStyle);
+    mUI->mCode->setStyle(theStyle);
 
     QByteArray state = settings->value(SETTINGS_MAINWND_SPLITTER_STATE).toByteArray();
-    mUI.mVerticalSplitter->restoreState(state);
+    mUI->mVerticalSplitter->restoreState(state);
     mShowNoErrorsMessage = settings->value(SETTINGS_SHOW_NO_ERRORS, true).toBool();
 
-    mUI.mTree->initialize(settings, list, checkThreadHandler);
+    mUI->mTree->initialize(settings, list, checkThreadHandler);
 }
 
 ResultsView::~ResultsView()
 {
-    //dtor
+    delete mUI;
+    delete mCheckSettings;
 }
 
 void ResultsView::clear(bool results)
 {
     if (results) {
-        mUI.mTree->clear();
+        mUI->mTree->clear();
     }
 
-    mUI.mDetails->setText(QString());
+    mUI->mDetails->setText(QString());
 
     mStatistics->clear();
+    delete mCheckSettings;
+    mCheckSettings = nullptr;
 
     //Clear the progressbar
-    mUI.mProgress->setMaximum(PROGRESS_MAX);
-    mUI.mProgress->setValue(0);
-    mUI.mProgress->setFormat("%p%");
+    mUI->mProgress->setMaximum(PROGRESS_MAX);
+    mUI->mProgress->setValue(0);
+    mUI->mProgress->setFormat("%p%");
+
+    mUI->mLabelCriticalErrors->setVisible(false);
+
+    mSuccess = false;
 }
 
 void ResultsView::clear(const QString &filename)
 {
-    mUI.mTree->clear(filename);
+    mUI->mTree->clear(filename);
 }
 
 void ResultsView::clearRecheckFile(const QString &filename)
 {
-    mUI.mTree->clearRecheckFile(filename);
+    mUI->mTree->clearRecheckFile(filename);
 }
 
-void ResultsView::progress(int value, const QString& description)
+const ShowTypes & ResultsView::getShowTypes() const
 {
-    mUI.mProgress->setValue(value);
-    mUI.mProgress->setFormat(QString("%p% (%1)").arg(description));
+    return mUI->mTree->mShowSeverities;
+}
+
+void ResultsView::setReportType(ReportType reportType) {
+    mUI->mTree->setReportType(reportType);
+}
+
+void ResultsView::setResultsSource(ResultsTree::ResultsSource source)
+{
+    mUI->mTree->setResultsSource(source);
+}
+
+void ResultsView::filesCheckedProgress(int value, const QString& description)
+{
+    mUI->mProgress->setValue(value);
+    mUI->mProgress->setFormat(QString("%p% (%1)").arg(description));
 }
 
 void ResultsView::error(const ErrorItem &item)
 {
-    if (mUI.mTree->addErrorItem(item)) {
+    if (item.severity == Severity::internal && (item.errorId == "logChecker" || item.errorId.endsWith("-logChecker"))) {
+        mStatistics->addChecker(item.message);
+        return;
+    }
+
+    handleCriticalError(item);
+
+    if (item.severity == Severity::internal)
+        return;
+
+    if (mUI->mTree->addErrorItem(item)) {
         emit gotResults();
         mStatistics->addItem(item.tool(), ShowTypes::SeverityToShowType(item.severity));
     }
@@ -127,7 +188,7 @@ void ResultsView::error(const ErrorItem &item)
 
 void ResultsView::filterResults(const QString& filter)
 {
-    mUI.mTree->filterResults(filter);
+    mUI->mTree->filterResults(filter);
 }
 
 void ResultsView::saveStatistics(const QString &filename) const
@@ -138,7 +199,7 @@ void ResultsView::saveStatistics(const QString &filename) const
     QTextStream ts(&f);
     ts <<  '[' << QDate::currentDate().toString("dd.MM.yyyy") << "]\n";
     ts << QDateTime::currentMSecsSinceEpoch() << '\n';
-    foreach (QString tool, mStatistics->getTools()) {
+    for (const QString& tool : mStatistics->getTools()) {
         ts << tool << "-error:" << mStatistics->getCount(tool, ShowTypes::ShowErrors) << '\n';
         ts << tool << "-warning:" << mStatistics->getCount(tool, ShowTypes::ShowWarnings) << '\n';
         ts << tool << "-style:" << mStatistics->getCount(tool, ShowTypes::ShowStyle) << '\n';
@@ -149,18 +210,11 @@ void ResultsView::saveStatistics(const QString &filename) const
 
 void ResultsView::updateFromOldReport(const QString &filename) const
 {
-    mUI.mTree->updateFromOldReport(filename);
+    mUI->mTree->updateFromOldReport(filename);
 }
 
-void ResultsView::save(const QString &filename, Report::Type type) const
+void ResultsView::save(const QString &filename, Report::Type type, const QString& productName) const
 {
-    if (!hasResults()) {
-        QMessageBox msgBox;
-        msgBox.setText(tr("No errors found, nothing to save."));
-        msgBox.setIcon(QMessageBox::Critical);
-        msgBox.exec();
-    }
-
     Report *report = nullptr;
 
     switch (type) {
@@ -171,13 +225,13 @@ void ResultsView::save(const QString &filename, Report::Type type) const
         report = new TxtReport(filename);
         break;
     case Report::XMLV2:
-        report = new XmlReportV2(filename);
+        report = new XmlReportV2(filename, productName);
         break;
     }
 
     if (report) {
         if (report->create())
-            mUI.mTree->saveResults(report);
+            mUI->mTree->saveResults(report);
         else {
             QMessageBox msgBox;
             msgBox.setText(tr("Failed to save the report."));
@@ -213,7 +267,7 @@ void ResultsView::printPreview()
     dialog.exec();
 }
 
-void ResultsView::print(QPrinter* printer)
+void ResultsView::print(QPrinter* printer) const
 {
     if (!hasResults()) {
         QMessageBox msgBox;
@@ -224,7 +278,7 @@ void ResultsView::print(QPrinter* printer)
     }
 
     PrintableReport report;
-    mUI.mTree->saveResults(&report);
+    mUI->mTree->saveResults(&report);
     QTextDocument doc(report.getFormattedReportText());
     doc.print(printer);
 }
@@ -236,38 +290,57 @@ void ResultsView::updateSettings(bool showFullPath,
                                  bool showErrorId,
                                  bool showInconclusive)
 {
-    mUI.mTree->updateSettings(showFullPath, saveFullPath, saveAllErrors, showErrorId, showInconclusive);
+    mUI->mTree->updateSettings(showFullPath, saveFullPath, saveAllErrors, showErrorId, showInconclusive);
     mShowNoErrorsMessage = showNoErrorsMessage;
 }
 
 void ResultsView::updateStyleSetting(QSettings *settings)
 {
     CodeEditorStyle theStyle(CodeEditorStyle::loadSettings(settings));
-    mUI.mCode->setStyle(theStyle);
+    mUI->mCode->setStyle(theStyle);
 }
 
 void ResultsView::setCheckDirectory(const QString &dir)
 {
-    mUI.mTree->setCheckDirectory(dir);
+    mUI->mTree->setCheckDirectory(dir);
+}
+
+QString ResultsView::getCheckDirectory() const
+{
+    return mUI->mTree->getCheckDirectory();
 }
 
-QString ResultsView::getCheckDirectory(void)
+void ResultsView::setCheckSettings(const Settings &settings)
 {
-    return mUI.mTree->getCheckDirectory();
+    delete mCheckSettings;
+    mCheckSettings = new Settings;
+    *mCheckSettings = settings;
 }
 
 void ResultsView::checkingStarted(int count)
 {
-    mUI.mProgress->setVisible(true);
-    mUI.mProgress->setMaximum(PROGRESS_MAX);
-    mUI.mProgress->setValue(0);
-    mUI.mProgress->setFormat(tr("%p% (%1 of %2 files checked)").arg(0).arg(count));
+    mSuccess = true;
+    mUI->mProgress->setVisible(true);
+    mUI->mProgress->setMaximum(PROGRESS_MAX);
+    mUI->mProgress->setValue(0);
+    mUI->mProgress->setFormat(tr("%p% (%1 of %2 files checked)").arg(0).arg(count));
 }
 
 void ResultsView::checkingFinished()
 {
-    mUI.mProgress->setVisible(false);
-    mUI.mProgress->setFormat("%p%");
+    mUI->mProgress->setVisible(false);
+    mUI->mProgress->setFormat("%p%");
+
+    {
+        Settings checkSettings;
+        const std::set<std::string> activeCheckers = mStatistics->getActiveCheckers();
+        CheckersReport checkersReport(mCheckSettings ? *mCheckSettings : checkSettings, activeCheckers);
+        mStatistics->setCheckersReport(QString::fromStdString(checkersReport.getReport(mCriticalErrors.toStdString())));
+    }
+
+    // TODO: Items can be mysteriously hidden when checking is finished, this function
+    // call should be redundant but it "unhides" the wrongly hidden items.
+    mUI->mTree->refreshTree();
 
     //Should we inform user of non visible/not found errors?
     if (mShowNoErrorsMessage) {
@@ -281,8 +354,8 @@ void ResultsView::checkingFinished()
 
             msg.exec();
         } //If we have errors but they aren't visible, tell user about it
-        else if (!mUI.mTree->hasVisibleResults()) {
-            QString text = tr("Errors were found, but they are configured to be hidden.\n"\
+        else if (!mUI->mTree->hasVisibleResults()) {
+            QString text = tr("Errors were found, but they are configured to be hidden.\n" \
                               "To toggle what kind of errors are shown, open view menu.");
             QMessageBox msg(QMessageBox::Information,
                             tr("Cppcheck"),
@@ -297,34 +370,32 @@ void ResultsView::checkingFinished()
 
 bool ResultsView::hasVisibleResults() const
 {
-    return mUI.mTree->hasVisibleResults();
+    return mUI->mTree->hasVisibleResults();
 }
 
 bool ResultsView::hasResults() const
 {
-    return mUI.mTree->hasResults();
+    return mUI->mTree->hasResults();
 }
 
 void ResultsView::saveSettings(QSettings *settings)
 {
-    mUI.mTree->saveSettings();
-    QByteArray state = mUI.mVerticalSplitter->saveState();
+    mUI->mTree->saveSettings();
+    QByteArray state = mUI->mVerticalSplitter->saveState();
     settings->setValue(SETTINGS_MAINWND_SPLITTER_STATE, state);
-    mUI.mVerticalSplitter->restoreState(state);
+    mUI->mVerticalSplitter->restoreState(state);
 }
 
 void ResultsView::translate()
 {
-    mUI.mTree->translate();
-}
-
-void ResultsView::disableProgressbar()
-{
-    mUI.mProgress->setEnabled(false);
+    mUI->retranslateUi(this);
+    mUI->mTree->translate();
 }
 
 void ResultsView::readErrorsXml(const QString &filename)
 {
+    mSuccess = false; // Don't know if results come from an aborted analysis
+
     const int version = XmlReport::determineVersion(filename);
     if (version == 0) {
         QMessageBox msgBox;
@@ -341,7 +412,7 @@ void ResultsView::readErrorsXml(const QString &filename)
         return;
     }
 
-    XmlReportV2 report(filename);
+    XmlReportV2 report(filename, QString());
     QList<ErrorItem> errors;
     if (report.open()) {
         errors = report.read();
@@ -352,95 +423,92 @@ void ResultsView::readErrorsXml(const QString &filename)
         msgBox.exec();
     }
 
-    ErrorItem item;
-    foreach (item, errors) {
-        mUI.mTree->addErrorItem(item);
+    for (const ErrorItem& item : utils::as_const(errors)) {
+        handleCriticalError(item);
+        mUI->mTree->addErrorItem(item);
     }
 
     QString dir;
     if (!errors.isEmpty() && !errors[0].errorPath.isEmpty()) {
         QString relativePath = QFileInfo(filename).canonicalPath();
-        if (QFileInfo(relativePath + '/' + errors[0].errorPath[0].file).exists())
+        if (QFileInfo::exists(relativePath + '/' + errors[0].errorPath[0].file))
             dir = relativePath;
     }
 
-    mUI.mTree->setCheckDirectory(dir);
+    mUI->mTree->setCheckDirectory(dir);
 }
 
-void ResultsView::updateDetails(const QModelIndex &index)
+void ResultsView::updateDetails(const ResultItem* item)
 {
-    QStandardItemModel *model = qobject_cast<QStandardItemModel*>(mUI.mTree->model());
-    QStandardItem *item = model->itemFromIndex(index);
-
-    mUI.mCode->setPlainText(QString());
-
-    if (!item) {
-        mUI.mDetails->setText(QString());
+    if (!item || !item->errorItem) {
+        mUI->mCode->clear();
+        mUI->mDetails->setText(QString());
         return;
     }
 
-    // Make sure we are working with the first column
-    if (item->parent() && item->column() != 0)
-        item = item->parent()->child(item->row(), 0);
-
-    QVariantMap data = item->data().toMap();
-
-    // If there is no severity data then it is a parent item without summary and message
-    if (!data.contains("severity")) {
-        mUI.mDetails->setText(QString());
+    // File item => No details can be shown
+    if (item->getType() == ResultItem::Type::file) {
+        mUI->mCode->clear();
+        mUI->mDetails->setText(QString());
         return;
     }
 
-    const QString message = data["message"].toString();
-    QString formattedMsg = message;
+    QString formattedMsg = item->errorItem->message;
 
-    const QString file0 = data["file0"].toString();
-    if (!file0.isEmpty() && Path::isHeader(data["file"].toString().toStdString()))
+    const QString file0 = item->errorItem->file0;
+    if (!file0.isEmpty() && Path::isHeader(item->getErrorPathItem().file.toStdString()))
         formattedMsg += QString("\n\n%1: %2").arg(tr("First included by")).arg(QDir::toNativeSeparators(file0));
 
-    if (mUI.mTree->showIdColumn())
-        formattedMsg.prepend(tr("Id") + ": " + data["id"].toString() + "\n");
-    mUI.mDetails->setText(formattedMsg);
+    if (item->errorItem->cwe > 0)
+        formattedMsg.prepend("CWE: " + QString::number(item->errorItem->cwe) + "\n");
+    if (mUI->mTree->showIdColumn())
+        formattedMsg.prepend(tr("Id") + ": " + item->errorItem->errorId + "\n");
+    mUI->mDetails->setText(formattedMsg);
 
-    const int lineNumber = data["line"].toInt();
+    const int lineNumber = item->getErrorPathItem().line;
 
-    QString filepath = data["file"].toString();
-    if (!QFileInfo(filepath).exists() && QFileInfo(mUI.mTree->getCheckDirectory() + '/' + filepath).exists())
-        filepath = mUI.mTree->getCheckDirectory() + '/' + filepath;
+    QString filepath = item->getErrorPathItem().file;
+    if (!QFileInfo::exists(filepath) && QFileInfo::exists(mUI->mTree->getCheckDirectory() + '/' + filepath))
+        filepath = mUI->mTree->getCheckDirectory() + '/' + filepath;
 
-    QFile file(filepath);
-    if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
-        QStringList symbols;
-        QRegularExpression re(".*: ([A-Za-z_][A-Za-z0-9_]*)$");
-        const QString errorMessage = data["message"].toString();
-        QRegularExpressionMatch match = re.match(errorMessage);
-        if (match.hasMatch()) {
-            symbols << match.captured(1);
-        }
+    QStringList symbols;
+    if (!item->errorItem->symbolNames.isEmpty())
+        symbols = item->errorItem->symbolNames.split("\n");
 
-        QTextStream in(&file);
-        mUI.mCode->setError(in.readAll(), lineNumber, symbols);
+    if (filepath == mUI->mCode->getFileName()) {
+        mUI->mCode->setError(lineNumber, symbols);
+        return;
+    }
+
+    QFile file(filepath);
+    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        mUI->mCode->clear();
+        return;
     }
+
+    QTextStream in(&file);
+    mUI->mCode->setError(in.readAll(), lineNumber, symbols);
+    mUI->mCode->setFileName(filepath);
 }
 
 void ResultsView::log(const QString &str)
 {
-    mUI.mListLog->addItem(str);
+    mUI->mListLog->addItem(str);
 }
 
 void ResultsView::debugError(const ErrorItem &item)
 {
-    mUI.mListLog->addItem(item.ToString());
+    mUI->mListLog->addItem(item.toString());
 }
 
 void ResultsView::logClear()
 {
-    mUI.mListLog->clear();
+    mUI->mListLog->clear();
 }
 
 void ResultsView::logCopyEntry()
 {
-    const QListWidgetItem * item = mUI.mListLog->currentItem();
+    const QListWidgetItem * item = mUI->mListLog->currentItem();
     if (nullptr != item) {
         QClipboard *clipboard = QApplication::clipboard();
         clipboard->setText(item->text());
@@ -450,8 +518,8 @@ void ResultsView::logCopyEntry()
 void ResultsView::logCopyComplete()
 {
     QString logText;
-    for (int i=0; i < mUI.mListLog->count(); ++i) {
-        const QListWidgetItem * item = mUI.mListLog->item(i);
+    for (int i=0; i < mUI->mListLog->count(); ++i) {
+        const QListWidgetItem * item = mUI->mListLog->item(i);
         if (nullptr != item) {
             logText += item->text();
         }
@@ -462,10 +530,10 @@ void ResultsView::logCopyComplete()
 
 void ResultsView::on_mListLog_customContextMenuRequested(const QPoint &pos)
 {
-    if (mUI.mListLog->count() <= 0)
+    if (mUI->mListLog->count() <= 0)
         return;
 
-    const QPoint globalPos = mUI.mListLog->mapToGlobal(pos);
+    const QPoint globalPos = mUI->mListLog->mapToGlobal(pos);
 
     QMenu contextMenu;
     contextMenu.addAction(tr("Clear Log"), this, SLOT(logClear()));
@@ -474,3 +542,36 @@ void ResultsView::on_mListLog_customContextMenuRequested(const QPoint &pos)
 
     contextMenu.exec(globalPos);
 }
+
+void ResultsView::stopAnalysis()
+{
+    mSuccess = false;
+    mUI->mLabelCriticalErrors->setText(tr("Analysis was stopped"));
+    mUI->mLabelCriticalErrors->setVisible(true);
+}
+
+void ResultsView::handleCriticalError(const ErrorItem &item)
+{
+    if (ErrorLogger::isCriticalErrorId(item.errorId.toStdString())) {
+        if (!mCriticalErrors.contains(item.errorId)) {
+            if (!mCriticalErrors.isEmpty())
+                mCriticalErrors += ",";
+            mCriticalErrors += item.errorId;
+            if (item.severity == Severity::internal)
+                mCriticalErrors += " (suppressed)";
+        }
+        QString msg = tr("There was a critical error with id '%1'").arg(item.errorId);
+        if (!item.file0.isEmpty())
+            msg += ", " + tr("when checking %1").arg(item.file0);
+        else
+            msg += ", " + tr("when checking a file");
+        msg += ". " + tr("Analysis was aborted.");
+        mUI->mLabelCriticalErrors->setText(msg);
+        mUI->mLabelCriticalErrors->setVisible(true);
+        mSuccess = false;
+    }
+}
+
+bool ResultsView::isSuccess() const {
+    return mSuccess;
+}
diff --git a/gui/resultsview.h b/gui/resultsview.h
index e4ac4b26bb9..77b4610145c 100644
--- a/gui/resultsview.h
+++ b/gui/resultsview.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,26 +20,38 @@
 #ifndef RESULTSVIEW_H
 #define RESULTSVIEW_H
 
-
-#include <QWidget>
 #include "report.h"
+#include "resultstree.h"
 #include "showtypes.h"
-#include "ui_resultsview.h"
+
+#include <cstdint>
+
+#include <QObject>
+#include <QString>
+#include <QStringList>
+#include <QWidget>
 
 class ErrorItem;
+class Settings;
 class ApplicationList;
-class QModelIndex;
+class ThreadHandler;
 class QPrinter;
 class QSettings;
 class CheckStatistics;
+class QPoint;
+class ResultItem;
+enum class ReportType : std::uint8_t;
+namespace Ui {
+    class ResultsView;
+}
 
 /// @addtogroup GUI
 /// @{
 
 /**
-* @brief Widget to show cppcheck progressbar and result
-*
-*/
+ * @brief Widget to show cppcheck progressbar and result
+ *
+ */
 class ResultsView : public QWidget {
     Q_OBJECT
 public:
@@ -47,13 +59,9 @@ class ResultsView : public QWidget {
     explicit ResultsView(QWidget * parent = nullptr);
     void initialize(QSettings *settings, ApplicationList *list, ThreadHandler *checkThreadHandler);
     ResultsView(const ResultsView &) = delete;
-    virtual ~ResultsView();
+    ~ResultsView() override;
     ResultsView &operator=(const ResultsView &) = delete;
 
-    void setTags(const QStringList &tags) {
-        mUI.mTree->setTags(tags);
-    }
-
     /**
      * @brief Clear results and statistics and reset progressinfo.
      * @param results Remove all the results from view?
@@ -71,19 +79,20 @@ class ResultsView : public QWidget {
     void clearRecheckFile(const QString &filename);
 
     /**
-    * @brief Write statistics in file
-    *
-    * @param filename Filename to save statistics to
-    */
+     * @brief Write statistics in file
+     *
+     * @param filename Filename to save statistics to
+     */
     void saveStatistics(const QString &filename) const;
 
     /**
-    * @brief Save results to a file
-    *
-    * @param filename Filename to save results to
-    * @param type Type of the report.
-    */
-    void save(const QString &filename, Report::Type type) const;
+     * @brief Save results to a file
+     *
+     * @param filename Filename to save results to
+     * @param type Type of the report.
+     * @param productName Custom product name
+     */
+    void save(const QString &filename, Report::Type type, const QString& productName) const;
 
     /**
      * @brief Update results from old report (tag, sinceDate)
@@ -91,15 +100,15 @@ class ResultsView : public QWidget {
     void updateFromOldReport(const QString &filename) const;
 
     /**
-    * @brief Update tree settings
-    *
-    * @param showFullPath Show full path of files in the tree
-    * @param saveFullPath Save full path of files in reports
-    * @param saveAllErrors Save all visible errors
-    * @param showNoErrorsMessage Show "no errors"?
-    * @param showErrorId Show error id?
-    * @param showInconclusive Show inconclusive?
-    */
+     * @brief Update tree settings
+     *
+     * @param showFullPath Show full path of files in the tree
+     * @param saveFullPath Save full path of files in reports
+     * @param saveAllErrors Save all visible errors
+     * @param showNoErrorsMessage Show "no errors"?
+     * @param showErrorId Show error id?
+     * @param showInconclusive Show inconclusive?
+     */
     void updateSettings(bool showFullPath,
                         bool saveFullPath,
                         bool saveAllErrors,
@@ -118,75 +127,89 @@ class ResultsView : public QWidget {
     void updateStyleSetting(QSettings *settings);
 
     /**
-    * @brief Set the directory we are checking
-    *
-    * This is used to split error file path to relative if necessary
-    * @param dir Directory we are checking
-    */
+     * @brief Set the directory we are checking
+     *
+     * This is used to split error file path to relative if necessary
+     * @param dir Directory we are checking
+     */
     void setCheckDirectory(const QString &dir);
 
     /**
-    * @brief Get the directory we are checking
-    *
-    * @return Directory containing source files
-    */
+     * @brief Get the directory we are checking
+     *
+     * @return Directory containing source files
+     */
+
+    QString getCheckDirectory() const;
 
-    QString getCheckDirectory(void);
+    /**
+     * Set settings used in checking
+     */
+    void setCheckSettings(const Settings& settings);
 
     /**
-    * @brief Inform the view that checking has started
-    *
-    * @param count Count of files to be checked.
-    */
+     * @brief Inform the view that checking has started
+     *
+     * @param count Count of files to be checked.
+     */
     void checkingStarted(int count);
 
     /**
-    * @brief Inform the view that checking finished.
-    *
-    */
+     * @brief Inform the view that checking finished.
+     *
+     */
     void checkingFinished();
 
     /**
-    * @brief Do we have visible results to show?
-    *
-    * @return true if there is at least one warning/error to show.
-    */
+     * @brief Do we have visible results to show?
+     *
+     * @return true if there is at least one warning/error to show.
+     */
     bool hasVisibleResults() const;
 
     /**
-    * @brief Do we have results from check?
-    *
-    * @return true if there is at least one warning/error, hidden or visible.
-    */
+     * @brief Do we have results from check?
+     *
+     * @return true if there is at least one warning/error, hidden or visible.
+     */
     bool hasResults() const;
 
     /**
-    * @brief Save View's settings
-    *
-    * @param settings program settings.
-    */
+     * @brief Save View's settings
+     *
+     * @param settings program settings.
+     */
     void saveSettings(QSettings *settings);
 
     /**
-    * @brief Translate this view
-    *
-    */
+     * @brief Translate this view
+     *
+     */
     void translate();
 
-    void disableProgressbar();
+    /**
+     * @brief This function should be called when analysis is stopped
+     */
+    void stopAnalysis();
+
+    /**
+     * @brief Are there successful results?
+     * @return true if analysis finished without critical errors etc
+     */
+    bool isSuccess() const;
 
     /**
-    * @brief Read errors from report XML file.
-    * @param filename Report file to read.
-    *
-    */
+     * @brief Read errors from report XML file.
+     * @param filename Report file to read.
+     *
+     */
     void readErrorsXml(const QString &filename);
 
     /**
      * @brief Return checking statistics.
      * @return Pointer to checking statistics.
      */
-    CheckStatistics *getStatistics() const {
+    const CheckStatistics *getStatistics() const {
         return mStatistics;
     }
 
@@ -194,123 +217,131 @@ class ResultsView : public QWidget {
      * @brief Return Showtypes.
      * @return Pointer to Showtypes.
      */
-    ShowTypes * getShowTypes() const {
-        return &mUI.mTree->mShowSeverities;
-    }
+    const ShowTypes & getShowTypes() const;
+
+    void setReportType(ReportType reportType);
+
+    /**
+     * @brief Set the results source type for the results tree.
+     *
+     * @param source The results source type.
+     */
+    void setResultsSource(ResultsTree::ResultsSource source);
 
 signals:
 
     /**
-    * @brief Signal to be emitted when we have results
-    *
-    */
+     * @brief Signal to be emitted when we have results
+     *
+     */
     void gotResults();
 
     /**
-    * @brief Signal that results have been hidden or shown
-    *
-    * @param hidden true if there are some hidden results, or false if there are not
-    */
+     * @brief Signal that results have been hidden or shown
+     *
+     * @param hidden true if there are some hidden results, or false if there are not
+     */
+    // NOLINTNEXTLINE(readability-inconsistent-declaration-parameter-name) - caused by generated MOC code
     void resultsHidden(bool hidden);
 
     /**
-    * @brief Signal to perform recheck of selected files
-    *
-    * @param selectedFilesList list of selected files
-    */
-    void checkSelected(QStringList selectedFilesList);
-
-    /**
-     * Some results have been tagged
+     * @brief Signal to perform recheck of selected files
+     *
+     * @param selectedFilesList list of selected files
      */
-    void tagged();
+    // NOLINTNEXTLINE(readability-inconsistent-declaration-parameter-name) - caused by generated MOC code
+    void checkSelected(QStringList selectedFilesList);
 
     /** Suppress Ids */
+    // NOLINTNEXTLINE(readability-inconsistent-declaration-parameter-name) - caused by generated MOC code
     void suppressIds(QStringList ids);
 
     /**
-    * @brief Show/hide certain type of errors
-    * Refreshes the tree.
-    *
-    * @param type Type of error to show/hide
-    * @param show Should specified errors be shown (true) or hidden (false)
-    */
+     * @brief Show/hide certain type of errors
+     * Refreshes the tree.
+     *
+     * @param type Type of error to show/hide
+     * @param show Should specified errors be shown (true) or hidden (false)
+     */
+    // NOLINTNEXTLINE(readability-inconsistent-declaration-parameter-name) - caused by generated MOC code
     void showResults(ShowTypes::ShowType type, bool show);
 
     /**
-    * @brief Show/hide cppcheck errors.
-    * Refreshes the tree.
-    *
-    * @param show Should specified errors be shown (true) or hidden (false)
-    */
+     * @brief Show/hide cppcheck errors.
+     * Refreshes the tree.
+     *
+     * @param show Should specified errors be shown (true) or hidden (false)
+     */
+    // NOLINTNEXTLINE(readability-inconsistent-declaration-parameter-name) - caused by generated MOC code
     void showCppcheckResults(bool show);
 
     /**
-    * @brief Show/hide clang-tidy/clang-analyzer errors.
-    * Refreshes the tree.
-    *
-    * @param show Should specified errors be shown (true) or hidden (false)
-    */
+     * @brief Show/hide clang-tidy/clang-analyzer errors.
+     * Refreshes the tree.
+     *
+     * @param show Should specified errors be shown (true) or hidden (false)
+     */
+    // NOLINTNEXTLINE(readability-inconsistent-declaration-parameter-name) - caused by generated MOC code
     void showClangResults(bool show);
 
     /**
-    * @brief Collapse all results in the result list.
-    */
+     * @brief Collapse all results in the result list.
+     */
     void collapseAllResults();
 
     /**
-    * @brief Expand all results in the result list.
-    */
+     * @brief Expand all results in the result list.
+     */
     void expandAllResults();
 
     /**
-    * @brief Show hidden results in the result list.
-    */
+     * @brief Show hidden results in the result list.
+     */
     void showHiddenResults();
 
 public slots:
 
     /**
-    * @brief Slot for updating the checking progress
-    *
-    * @param value Current progress value
-    * @param description Description to accompany the progress
-    */
-    void progress(int value, const QString& description);
+     * @brief Slot for updating the checking progress
+     *
+     * @param value Current progress value
+     * @param description Description to accompany the progress
+     */
+    void filesCheckedProgress(int value, const QString& description);
 
     /**
-    * @brief Slot for new error to be displayed
-    *
-    * @param item Error data
-    */
+     * @brief Slot for new error to be displayed
+     *
+     * @param item Error data
+     */
     void error(const ErrorItem &item);
 
     /**
-    * @brief Filters the results in the result list.
-    */
+     * @brief Filters the results in the result list.
+     */
     void filterResults(const QString& filter);
 
     /**
-    * @brief Update detailed message when selected item is changed.
-    *
-    * @param index Position of new selected item.
-    */
-    void updateDetails(const QModelIndex &index);
+     * @brief Update detailed message when selected item is changed.
+     *
+     * @param item selected item
+     */
+    void updateDetails(const ResultItem* item);
 
     /**
-    * @brief Slot opening a print dialog to print the current report
-    */
+     * @brief Slot opening a print dialog to print the current report
+     */
     void print();
 
     /**
-    * @brief Slot printing the current report to the printer.
-    * @param printer The printer used for printing the report.
-    */
-    void print(QPrinter* printer);
+     * @brief Slot printing the current report to the printer.
+     * @param printer The printer used for printing the report.
+     */
+    void print(QPrinter* printer) const;
 
     /**
-    * @brief Slot opening a print preview dialog
-    */
+     * @brief Slot opening a print preview dialog
+     */
     void printPreview();
 
     /**
@@ -338,15 +369,33 @@ public slots:
      */
     void logCopyComplete();
 
-protected:
+private:
+
     /**
-    * @brief Should we show a "No errors found dialog" every time no errors were found?
-    */
-    bool mShowNoErrorsMessage;
+     * If provided ErrorItem is a critical error then display warning message
+     * in the resultsview
+     */
+    void handleCriticalError(const ErrorItem& item);
 
-    Ui::ResultsView mUI;
+    /**
+     * @brief Should we show a "No errors found dialog" every time no errors were found?
+     */
+    bool mShowNoErrorsMessage = true;
+
+    Ui::ResultsView *mUI;
 
     CheckStatistics *mStatistics;
+
+    Settings* mCheckSettings = nullptr;
+
+    /**
+     * Set to true when checking finish successfully. Set to false whenever analysis starts.
+     */
+    bool mSuccess = false;
+
+    /** Critical error ids */
+    QString mCriticalErrors;
+
 private slots:
     /**
      * @brief Custom context menu for Analysis Log
diff --git a/gui/resultsview.ui b/gui/resultsview.ui
index 356cf0de71b..7ab18fffc9c 100644
--- a/gui/resultsview.ui
+++ b/gui/resultsview.ui
@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>459</width>
-    <height>357</height>
+    <height>391</height>
    </rect>
   </property>
   <property name="sizePolicy">
@@ -51,6 +51,16 @@
      </property>
     </widget>
    </item>
+   <item>
+    <widget class="QLabel" name="mLabelCriticalErrors">
+     <property name="styleSheet">
+      <string notr="true">color: red;</string>
+     </property>
+     <property name="text">
+      <string>Critical errors</string>
+     </property>
+    </widget>
+   </item>
    <item>
     <widget class="QSplitter" name="mVerticalSplitter">
      <property name="orientation">
diff --git a/gui/scratchpad.cpp b/gui/scratchpad.cpp
index 8a912df55d9..4dee6b44664 100644
--- a/gui/scratchpad.cpp
+++ b/gui/scratchpad.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2017 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,22 +17,40 @@
  */
 
 #include "scratchpad.h"
+
+#include "codeeditor.h"
 #include "mainwindow.h"
-#include <QWidget>
+
+#include "ui_scratchpad.h"
+
+#include <QLineEdit>
+#include <QPushButton>
+#include <QString>
 
 ScratchPad::ScratchPad(MainWindow& mainWindow)
     : QDialog(&mainWindow)
+    , mUI(new Ui::ScratchPad)
     , mMainWindow(mainWindow)
 {
-    mUI.setupUi(this);
+    mUI->setupUi(this);
+
+    connect(mUI->mCheckButton, &QPushButton::clicked, this, &ScratchPad::checkButtonClicked);
+}
 
-    connect(mUI.mCheckButton, &QPushButton::clicked, this, &ScratchPad::checkButtonClicked);
+ScratchPad::~ScratchPad()
+{
+    delete mUI;
+}
+
+void ScratchPad::translate()
+{
+    mUI->retranslateUi(this);
 }
 
 void ScratchPad::checkButtonClicked()
 {
-    QString filename = mUI.lineEdit->text();
+    QString filename = mUI->lineEdit->text();
     if (filename.isEmpty())
         filename = "test.cpp";
-    mMainWindow.analyzeCode(mUI.plainTextEdit->toPlainText(), filename);
+    mMainWindow.analyzeCode(mUI->plainTextEdit->toPlainText(), filename);
 }
diff --git a/gui/scratchpad.h b/gui/scratchpad.h
index 15d8e181598..141b7b953f6 100644
--- a/gui/scratchpad.h
+++ b/gui/scratchpad.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2017 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,29 +20,38 @@
 #define SCRATCHPAD_H
 
 #include <QDialog>
-#include "ui_scratchpad.h"
+#include <QObject>
 
 class MainWindow;
+namespace Ui {
+    class ScratchPad;
+}
 
 /// @addtogroup GUI
 /// @{
 
 /**
-* @brief A window with a text field that .
-*/
+ * @brief A window with a text field that .
+ */
 class ScratchPad : public QDialog {
     Q_OBJECT
 public:
     explicit ScratchPad(MainWindow& mainWindow);
+    ~ScratchPad() override;
+
+    /**
+     * @brief Translate dialog
+     */
+    void translate();
 
 private slots:
     /**
-    * @brief Called when check button is clicked.
-    */
+     * @brief Called when check button is clicked.
+     */
     void checkButtonClicked();
 
 private:
-    Ui::ScratchPad mUI;
+    Ui::ScratchPad *mUI;
     MainWindow& mMainWindow;
 };
 
diff --git a/gui/scratchpad.ui b/gui/scratchpad.ui
index 2341c99c064..9b90a99bb70 100644
--- a/gui/scratchpad.ui
+++ b/gui/scratchpad.ui
@@ -1,121 +1,128 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>ScratchPad</class>
- <widget class="QDialog" name="ScratchPad">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>500</width>
-    <height>600</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Scratchpad</string>
-  </property>
-  <layout class="QVBoxLayout" name="verticalLayout">
-   <item>
-    <widget class="QLabel" name="label_sourcecode">
-     <property name="text">
-      <string>Copy or write some C/C++ code here:</string>
-     </property>
-    </widget>
-   </item>
-   <item>
-    <widget class="QPlainTextEdit" name="plainTextEdit">
-     <property name="font">
-      <font>
-       <family>Courier New</family>
-       <pointsize>10</pointsize>
-      </font>
-     </property>
-    </widget>
-   </item>
-   <item>
-    <widget class="QLabel" name="label_filename">
-     <property name="text">
-      <string>Optionally enter a filename (mainly for automatic language detection) and click on &quot;Check&quot;:</string>
-     </property>
-    </widget>
-   </item>
-   <item>
-    <layout class="QHBoxLayout" name="horizontalLayout">
-     <property name="leftMargin">
-      <number>0</number>
-     </property>
-     <property name="topMargin">
-      <number>0</number>
-     </property>
-     <property name="rightMargin">
-      <number>0</number>
-     </property>
-     <property name="bottomMargin">
-      <number>0</number>
-     </property>
-     <item>
-      <spacer name="horizontalSpacer">
-       <property name="orientation">
-        <enum>Qt::Horizontal</enum>
-       </property>
-       <property name="sizeHint" stdset="0">
-        <size>
-         <width>40</width>
-         <height>20</height>
-        </size>
-       </property>
-      </spacer>
-     </item>
-     <item>
-      <widget class="QLineEdit" name="lineEdit">
-       <property name="placeholderText">
-        <string>filename</string>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <widget class="QPushButton" name="mCheckButton">
-       <property name="text">
-        <string>Check</string>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <widget class="QDialogButtonBox" name="mButtonBox">
-       <property name="sizePolicy">
-        <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
-         <horstretch>0</horstretch>
-         <verstretch>0</verstretch>
-        </sizepolicy>
-       </property>
-       <property name="orientation">
-        <enum>Qt::Horizontal</enum>
-       </property>
-       <property name="standardButtons">
-        <set>QDialogButtonBox::Close</set>
-       </property>
-      </widget>
-     </item>
-    </layout>
-   </item>
-  </layout>
- </widget>
- <resources/>
- <connections>
-  <connection>
-   <sender>mButtonBox</sender>
-   <signal>rejected()</signal>
-   <receiver>ScratchPad</receiver>
-   <slot>reject()</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>20</x>
-     <y>20</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>20</x>
-     <y>20</y>
-    </hint>
-   </hints>
-  </connection>
- </connections>
-</ui>
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ScratchPad</class>
+ <widget class="QDialog" name="ScratchPad">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>574</width>
+    <height>600</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Scratchpad</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QLabel" name="label_sourcecode">
+     <property name="text">
+      <string>Copy or write some C/C++ code here:</string>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="CodeEditor" name="plainTextEdit">
+     <property name="font">
+      <font>
+       <family>Courier New</family>
+       <pointsize>10</pointsize>
+      </font>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QLabel" name="label_filename">
+     <property name="text">
+      <string>Optionally enter a filename (mainly for automatic language detection) and click on &quot;Check&quot;:</string>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <property name="leftMargin">
+      <number>0</number>
+     </property>
+     <property name="topMargin">
+      <number>0</number>
+     </property>
+     <property name="rightMargin">
+      <number>0</number>
+     </property>
+     <property name="bottomMargin">
+      <number>0</number>
+     </property>
+     <item>
+      <spacer name="horizontalSpacer">
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+     <item>
+      <widget class="QLineEdit" name="lineEdit">
+       <property name="placeholderText">
+        <string>filename</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="mCheckButton">
+       <property name="text">
+        <string>Check</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QDialogButtonBox" name="mButtonBox">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="standardButtons">
+        <set>QDialogButtonBox::Close</set>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>CodeEditor</class>
+   <extends>QPlainTextEdit</extends>
+   <header>codeeditor.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>mButtonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>ScratchPad</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>20</x>
+     <y>20</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>20</x>
+     <y>20</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>
diff --git a/gui/settings.ui b/gui/settings.ui
index c3b9c25c724..6db6ec70809 100644
--- a/gui/settings.ui
+++ b/gui/settings.ui
@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>589</width>
-    <height>346</height>
+    <width>627</width>
+    <height>411</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -65,15 +65,9 @@
              <height>20</height>
             </size>
            </property>
-           <property name="inputMask">
-            <string notr="true">009</string>
-           </property>
            <property name="text">
             <string notr="true"/>
            </property>
-           <property name="maxLength">
-            <number>3</number>
-           </property>
            <property name="alignment">
             <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
            </property>
@@ -82,12 +76,12 @@
          <item>
           <widget class="QLabel" name="label_3">
            <property name="text">
-            <string>Ideal count:</string>
+            <string>Max count:</string>
            </property>
           </widget>
          </item>
          <item>
-          <widget class="QLabel" name="mLblIdealThreads">
+          <widget class="QLabel" name="mLblMaxThreads">
            <property name="text">
             <string notr="true">TextLabel</string>
            </property>
@@ -157,6 +151,13 @@
          </property>
         </widget>
        </item>
+       <item>
+        <widget class="QCheckBox" name="mCheckForUpdates">
+         <property name="text">
+          <string>Check for updates</string>
+         </property>
+        </widget>
+       </item>
        <item>
         <spacer name="verticalSpacer_2">
          <property name="orientation">
@@ -292,14 +293,25 @@
          <property name="title">
           <string>Python binary (leave this empty to use python in the PATH)</string>
          </property>
-         <layout class="QHBoxLayout" name="horizontalLayout">
+         <layout class="QVBoxLayout" name="verticalLayout_13">
           <item>
-           <widget class="QLineEdit" name="mEditPythonPath"/>
+           <layout class="QHBoxLayout" name="horizontalLayout">
+            <item>
+             <widget class="QLineEdit" name="mEditPythonPath"/>
+            </item>
+            <item>
+             <widget class="QPushButton" name="mBtnBrowsePythonPath">
+              <property name="text">
+               <string>...</string>
+              </property>
+             </widget>
+            </item>
+           </layout>
           </item>
           <item>
-           <widget class="QPushButton" name="mBtnBrowsePythonPath">
+           <widget class="QLabel" name="mPythonPathWarning">
             <property name="text">
-             <string>...</string>
+             <string/>
             </property>
            </widget>
           </item>
@@ -307,9 +319,9 @@
         </widget>
        </item>
        <item>
-        <widget class="QGroupBox" name="groupBox_4">
+        <widget class="QGroupBox" name="mGroupBoxMisra">
          <property name="title">
-          <string>Misra addon</string>
+          <string>MISRA addon</string>
          </property>
          <layout class="QVBoxLayout" name="verticalLayout_7">
           <item>
@@ -317,7 +329,7 @@
             <item>
              <widget class="QLabel" name="label_4">
               <property name="text">
-               <string>Misra rule texts file</string>
+               <string>MISRA rule texts file</string>
               </property>
              </widget>
             </item>
diff --git a/gui/settingsdialog.cpp b/gui/settingsdialog.cpp
index 04c6378163c..f53069a00ec 100644
--- a/gui/settingsdialog.cpp
+++ b/gui/settingsdialog.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,88 +16,113 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-#include <QDialog>
-#include <QWidget>
-#include <QList>
-#include <QListWidgetItem>
-#include <QSettings>
-#include <QFileDialog>
-#include <QThread>
 #include "settingsdialog.h"
+
+#include "application.h"
 #include "applicationdialog.h"
 #include "applicationlist.h"
-#include "translationhandler.h"
 #include "codeeditorstyle.h"
 #include "codeeditstyledialog.h"
 #include "common.h"
+#include "translationhandler.h"
+
+#include "ui_settings.h"
+
+#include <QCheckBox>
+#include <QDialogButtonBox>
+#include <QDir>
+#include <QFileDialog>
+#include <QFileInfo>
+#include <QGroupBox>
+#include <QLabel>
+#include <QLineEdit>
+#include <QList>
+#include <QListWidget>
+#include <QListWidgetItem>
+#include <QPushButton>
+#include <QRadioButton>
+#include <QSettings>
+#include <QSize>
+#include <QThread>
+#include <QVariant>
+#include <QWidget>
 
 SettingsDialog::SettingsDialog(ApplicationList *list,
                                TranslationHandler *translator,
+                               bool premium,
                                QWidget *parent) :
     QDialog(parent),
     mApplications(list),
     mTempApplications(new ApplicationList(this)),
-    mTranslator(translator)
+    mTranslator(translator),
+    mUI(new Ui::Settings),
+    mPremium(premium)
 {
-    mUI.setupUi(this);
+    mUI->setupUi(this);
+    mUI->mPythonPathWarning->setStyleSheet("color: red");
     QSettings settings;
     mTempApplications->copy(list);
 
-    mUI.mJobs->setText(settings.value(SETTINGS_CHECK_THREADS, 1).toString());
-    mUI.mForce->setCheckState(boolToCheckState(settings.value(SETTINGS_CHECK_FORCE, false).toBool()));
-    mUI.mShowFullPath->setCheckState(boolToCheckState(settings.value(SETTINGS_SHOW_FULL_PATH, false).toBool()));
-    mUI.mShowNoErrorsMessage->setCheckState(boolToCheckState(settings.value(SETTINGS_SHOW_NO_ERRORS, false).toBool()));
-    mUI.mShowDebugWarnings->setCheckState(boolToCheckState(settings.value(SETTINGS_SHOW_DEBUG_WARNINGS, false).toBool()));
-    mUI.mSaveAllErrors->setCheckState(boolToCheckState(settings.value(SETTINGS_SAVE_ALL_ERRORS, false).toBool()));
-    mUI.mSaveFullPath->setCheckState(boolToCheckState(settings.value(SETTINGS_SAVE_FULL_PATH, false).toBool()));
-    mUI.mInlineSuppressions->setCheckState(boolToCheckState(settings.value(SETTINGS_INLINE_SUPPRESSIONS, false).toBool()));
-    mUI.mEnableInconclusive->setCheckState(boolToCheckState(settings.value(SETTINGS_INCONCLUSIVE_ERRORS, false).toBool()));
-    mUI.mShowStatistics->setCheckState(boolToCheckState(settings.value(SETTINGS_SHOW_STATISTICS, false).toBool()));
-    mUI.mShowErrorId->setCheckState(boolToCheckState(settings.value(SETTINGS_SHOW_ERROR_ID, false).toBool()));
-    mUI.mEditPythonPath->setText(settings.value(SETTINGS_PYTHON_PATH, QString()).toString());
-    mUI.mEditMisraFile->setText(settings.value(SETTINGS_MISRA_FILE, QString()).toString());
+    int maxjobs = QThread::idealThreadCount();
+
+    mUI->mJobs->setText(settings.value(SETTINGS_CHECK_THREADS, 1).toString());
+    mUI->mJobs->setValidator(new QIntValidator(1, maxjobs, this));
+    mUI->mForce->setCheckState(boolToCheckState(settings.value(SETTINGS_CHECK_FORCE, false).toBool()));
+    mUI->mShowFullPath->setCheckState(boolToCheckState(settings.value(SETTINGS_SHOW_FULL_PATH, false).toBool()));
+    mUI->mShowNoErrorsMessage->setCheckState(boolToCheckState(settings.value(SETTINGS_SHOW_NO_ERRORS, false).toBool()));
+    mUI->mShowDebugWarnings->setCheckState(boolToCheckState(settings.value(SETTINGS_SHOW_DEBUG_WARNINGS, false).toBool()));
+    mUI->mSaveAllErrors->setCheckState(boolToCheckState(settings.value(SETTINGS_SAVE_ALL_ERRORS, false).toBool()));
+    mUI->mSaveFullPath->setCheckState(boolToCheckState(settings.value(SETTINGS_SAVE_FULL_PATH, false).toBool()));
+    mUI->mInlineSuppressions->setCheckState(boolToCheckState(settings.value(SETTINGS_INLINE_SUPPRESSIONS, false).toBool()));
+    mUI->mEnableInconclusive->setCheckState(boolToCheckState(settings.value(SETTINGS_INCONCLUSIVE_ERRORS, false).toBool()));
+    mUI->mShowStatistics->setCheckState(boolToCheckState(settings.value(SETTINGS_SHOW_STATISTICS, false).toBool()));
+    mUI->mShowErrorId->setCheckState(boolToCheckState(settings.value(SETTINGS_SHOW_ERROR_ID, true).toBool()));
+    mUI->mCheckForUpdates->setCheckState(boolToCheckState(settings.value(SETTINGS_CHECK_FOR_UPDATES, false).toBool()));
+    mUI->mEditPythonPath->setText(settings.value(SETTINGS_PYTHON_PATH, QString()).toString());
+    validateEditPythonPath();
+    if (premium)
+        mUI->mGroupBoxMisra->setVisible(false);
+    mUI->mEditMisraFile->setText(settings.value(SETTINGS_MISRA_FILE, QString()).toString());
 
 #ifdef Q_OS_WIN
-    //mUI.mTabClang->setVisible(true);
-    mUI.mEditClangPath->setText(settings.value(SETTINGS_CLANG_PATH, QString()).toString());
-    mUI.mEditVsIncludePaths->setText(settings.value(SETTINGS_VS_INCLUDE_PATHS, QString()).toString());
-    connect(mUI.mBtnBrowseClangPath, &QPushButton::released, this, &SettingsDialog::browseClangPath);
+    //mUI->mTabClang->setVisible(true);
+    mUI->mEditClangPath->setText(settings.value(SETTINGS_CLANG_PATH, QString()).toString());
+    mUI->mEditVsIncludePaths->setText(settings.value(SETTINGS_VS_INCLUDE_PATHS, QString()).toString());
+    connect(mUI->mBtnBrowseClangPath, &QPushButton::released, this, &SettingsDialog::browseClangPath);
 #else
-    mUI.mTabClang->setVisible(false);
+    mUI->mTabClang->setVisible(false);
 #endif
     mCurrentStyle = new CodeEditorStyle(CodeEditorStyle::loadSettings(&settings));
     manageStyleControls();
 
-    connect(mUI.mButtons, &QDialogButtonBox::accepted, this, &SettingsDialog::ok);
-    connect(mUI.mButtons, &QDialogButtonBox::rejected, this, &SettingsDialog::reject);
-    connect(mUI.mBtnAddApplication, SIGNAL(clicked()),
+    connect(mUI->mEditPythonPath, SIGNAL(textEdited(QString)),
+            this, SLOT(validateEditPythonPath()));
+
+    connect(mUI->mButtons, &QDialogButtonBox::accepted, this, &SettingsDialog::ok);
+    connect(mUI->mButtons, &QDialogButtonBox::rejected, this, &SettingsDialog::reject);
+    connect(mUI->mBtnAddApplication, SIGNAL(clicked()),
             this, SLOT(addApplication()));
-    connect(mUI.mBtnRemoveApplication, SIGNAL(clicked()),
+    connect(mUI->mBtnRemoveApplication, SIGNAL(clicked()),
             this, SLOT(removeApplication()));
-    connect(mUI.mBtnEditApplication, SIGNAL(clicked()),
+    connect(mUI->mBtnEditApplication, SIGNAL(clicked()),
             this, SLOT(editApplication()));
-    connect(mUI.mBtnDefaultApplication, SIGNAL(clicked()),
+    connect(mUI->mBtnDefaultApplication, SIGNAL(clicked()),
             this, SLOT(defaultApplication()));
-    connect(mUI.mListWidget, SIGNAL(itemDoubleClicked(QListWidgetItem *)),
+    connect(mUI->mListWidget, SIGNAL(itemDoubleClicked(QListWidgetItem*)),
             this, SLOT(editApplication()));
 
-    connect(mUI.mBtnBrowsePythonPath, &QPushButton::clicked, this, &SettingsDialog::browsePythonPath);
-    connect(mUI.mBtnBrowseMisraFile, &QPushButton::clicked, this, &SettingsDialog::browseMisraFile);
-    connect(mUI.mBtnEditTheme, SIGNAL(clicked()), this, SLOT(editCodeEditorStyle()));
-    connect(mUI.mThemeSystem, SIGNAL(released()), this, SLOT(setCodeEditorStyleDefault()));
-    connect(mUI.mThemeDark, SIGNAL(released()), this, SLOT(setCodeEditorStyleDefault()));
-    connect(mUI.mThemeLight, SIGNAL(released()), this, SLOT(setCodeEditorStyleDefault()));
-    connect(mUI.mThemeCustom, SIGNAL(toggled(bool)), mUI.mBtnEditTheme, SLOT(setEnabled(bool)));
+    connect(mUI->mBtnBrowsePythonPath, &QPushButton::clicked, this, &SettingsDialog::browsePythonPath);
+    connect(mUI->mBtnBrowseMisraFile, &QPushButton::clicked, this, &SettingsDialog::browseMisraFile);
+    connect(mUI->mBtnEditTheme, SIGNAL(clicked()), this, SLOT(editCodeEditorStyle()));
+    connect(mUI->mThemeSystem, SIGNAL(released()), this, SLOT(setCodeEditorStyleDefault()));
+    connect(mUI->mThemeDark, SIGNAL(released()), this, SLOT(setCodeEditorStyleDefault()));
+    connect(mUI->mThemeLight, SIGNAL(released()), this, SLOT(setCodeEditorStyleDefault()));
+    connect(mUI->mThemeCustom, SIGNAL(toggled(bool)), mUI->mBtnEditTheme, SLOT(setEnabled(bool)));
 
-    mUI.mListWidget->setSortingEnabled(false);
+    mUI->mListWidget->setSortingEnabled(false);
     populateApplicationList();
 
-    const int count = QThread::idealThreadCount();
-    if (count != -1)
-        mUI.mLblIdealThreads->setText(QString::number(count));
-    else
-        mUI.mLblIdealThreads->setText(tr("N/A"));
+    mUI->mLblMaxThreads->setText(QString::number(maxjobs));
 
     loadSettings();
     initTranslationsList();
@@ -106,19 +131,20 @@ SettingsDialog::SettingsDialog(ApplicationList *list,
 SettingsDialog::~SettingsDialog()
 {
     saveSettings();
+    delete mCurrentStyle;
+    delete mUI;
 }
 
 void SettingsDialog::initTranslationsList()
 {
     const QString current = mTranslator->getCurrentLanguage();
-    QList<TranslationInfo> translations = mTranslator->getTranslations();
-    foreach (TranslationInfo translation, translations) {
-        QListWidgetItem *item = new QListWidgetItem;
+    for (const TranslationInfo& translation : mTranslator->getTranslations()) {
+        auto *item = new QListWidgetItem;
         item->setText(translation.mName);
         item->setData(mLangCodeRole, QVariant(translation.mCode));
-        mUI.mListLanguages->addItem(item);
+        mUI->mListLanguages->addItem(item);
         if (translation.mCode == current || translation.mCode == current.mid(0, 2))
-            mUI.mListLanguages->setCurrentItem(item);
+            mUI->mListLanguages->setCurrentItem(item);
     }
 }
 
@@ -132,10 +158,7 @@ Qt::CheckState SettingsDialog::boolToCheckState(bool yes)
 
 bool SettingsDialog::checkStateToBool(Qt::CheckState state)
 {
-    if (state == Qt::Checked) {
-        return true;
-    }
-    return false;
+    return state == Qt::Checked;
 }
 
 
@@ -155,32 +178,30 @@ void SettingsDialog::saveSettings() const
 
 void SettingsDialog::saveSettingValues() const
 {
-    int jobs = mUI.mJobs->text().toInt();
-    if (jobs <= 0) {
-        jobs = 1;
-    }
-
     QSettings settings;
-    settings.setValue(SETTINGS_CHECK_THREADS, jobs);
-    saveCheckboxValue(&settings, mUI.mForce, SETTINGS_CHECK_FORCE);
-    saveCheckboxValue(&settings, mUI.mSaveAllErrors, SETTINGS_SAVE_ALL_ERRORS);
-    saveCheckboxValue(&settings, mUI.mSaveFullPath, SETTINGS_SAVE_FULL_PATH);
-    saveCheckboxValue(&settings, mUI.mShowFullPath, SETTINGS_SHOW_FULL_PATH);
-    saveCheckboxValue(&settings, mUI.mShowNoErrorsMessage, SETTINGS_SHOW_NO_ERRORS);
-    saveCheckboxValue(&settings, mUI.mShowDebugWarnings, SETTINGS_SHOW_DEBUG_WARNINGS);
-    saveCheckboxValue(&settings, mUI.mInlineSuppressions, SETTINGS_INLINE_SUPPRESSIONS);
-    saveCheckboxValue(&settings, mUI.mEnableInconclusive, SETTINGS_INCONCLUSIVE_ERRORS);
-    saveCheckboxValue(&settings, mUI.mShowStatistics, SETTINGS_SHOW_STATISTICS);
-    saveCheckboxValue(&settings, mUI.mShowErrorId, SETTINGS_SHOW_ERROR_ID);
-    settings.setValue(SETTINGS_PYTHON_PATH, mUI.mEditPythonPath->text());
-    settings.setValue(SETTINGS_MISRA_FILE, mUI.mEditMisraFile->text());
+    if (mUI->mJobs->hasAcceptableInput())
+        settings.setValue(SETTINGS_CHECK_THREADS, mUI->mJobs->text().toInt());
+    saveCheckboxValue(&settings, mUI->mForce, SETTINGS_CHECK_FORCE);
+    saveCheckboxValue(&settings, mUI->mSaveAllErrors, SETTINGS_SAVE_ALL_ERRORS);
+    saveCheckboxValue(&settings, mUI->mSaveFullPath, SETTINGS_SAVE_FULL_PATH);
+    saveCheckboxValue(&settings, mUI->mShowFullPath, SETTINGS_SHOW_FULL_PATH);
+    saveCheckboxValue(&settings, mUI->mShowNoErrorsMessage, SETTINGS_SHOW_NO_ERRORS);
+    saveCheckboxValue(&settings, mUI->mShowDebugWarnings, SETTINGS_SHOW_DEBUG_WARNINGS);
+    saveCheckboxValue(&settings, mUI->mInlineSuppressions, SETTINGS_INLINE_SUPPRESSIONS);
+    saveCheckboxValue(&settings, mUI->mEnableInconclusive, SETTINGS_INCONCLUSIVE_ERRORS);
+    saveCheckboxValue(&settings, mUI->mShowStatistics, SETTINGS_SHOW_STATISTICS);
+    saveCheckboxValue(&settings, mUI->mShowErrorId, SETTINGS_SHOW_ERROR_ID);
+    saveCheckboxValue(&settings, mUI->mCheckForUpdates, SETTINGS_CHECK_FOR_UPDATES);
+    settings.setValue(SETTINGS_PYTHON_PATH, mUI->mEditPythonPath->text());
+    if (!mPremium)
+        settings.setValue(SETTINGS_MISRA_FILE, mUI->mEditMisraFile->text());
 
 #ifdef Q_OS_WIN
-    settings.setValue(SETTINGS_CLANG_PATH, mUI.mEditClangPath->text());
-    settings.setValue(SETTINGS_VS_INCLUDE_PATHS, mUI.mEditVsIncludePaths->text());
+    settings.setValue(SETTINGS_CLANG_PATH, mUI->mEditClangPath->text());
+    settings.setValue(SETTINGS_VS_INCLUDE_PATHS, mUI->mEditVsIncludePaths->text());
 #endif
 
-    const QListWidgetItem *currentLang = mUI.mListLanguages->currentItem();
+    const QListWidgetItem *currentLang = mUI->mListLanguages->currentItem();
     if (currentLang) {
         const QString langcode = currentLang->data(mLangCodeRole).toString();
         settings.setValue(SETTINGS_LANGUAGE, langcode);
@@ -188,12 +209,34 @@ void SettingsDialog::saveSettingValues() const
     CodeEditorStyle::saveSettings(&settings, *mCurrentStyle);
 }
 
-void SettingsDialog::saveCheckboxValue(QSettings *settings, QCheckBox *box,
+void SettingsDialog::saveCheckboxValue(QSettings *settings, const QCheckBox *box,
                                        const QString &name)
 {
     settings->setValue(name, checkStateToBool(box->checkState()));
 }
 
+void SettingsDialog::validateEditPythonPath()
+{
+    const auto pythonPath = mUI->mEditPythonPath->text();
+    if (pythonPath.isEmpty()) {
+        mUI->mEditPythonPath->setStyleSheet("");
+        mUI->mPythonPathWarning->hide();
+        return;
+    }
+
+    QFileInfo pythonPathInfo(pythonPath);
+    if (!pythonPathInfo.exists() ||
+        !pythonPathInfo.isFile() ||
+        !pythonPathInfo.isExecutable()) {
+        mUI->mEditPythonPath->setStyleSheet("QLineEdit {border: 1px solid red}");
+        mUI->mPythonPathWarning->setText(tr("The executable file \"%1\" is not available").arg(pythonPath));
+        mUI->mPythonPathWarning->show();
+    } else {
+        mUI->mEditPythonPath->setStyleSheet("");
+        mUI->mPythonPathWarning->hide();
+    }
+}
+
 void SettingsDialog::addApplication()
 {
     Application app;
@@ -201,15 +244,14 @@ void SettingsDialog::addApplication()
 
     if (dialog.exec() == QDialog::Accepted) {
         mTempApplications->addApplication(app);
-        mUI.mListWidget->addItem(app.getName());
+        mUI->mListWidget->addItem(app.getName());
     }
 }
 
 void SettingsDialog::removeApplication()
 {
-    QList<QListWidgetItem *> selected = mUI.mListWidget->selectedItems();
-    foreach (QListWidgetItem *item, selected) {
-        const int removeIndex = mUI.mListWidget->row(item);
+    for (QListWidgetItem *item : mUI->mListWidget->selectedItems()) {
+        const int removeIndex = mUI->mListWidget->row(item);
         const int currentDefault = mTempApplications->getDefaultApplication();
         mTempApplications->removeApplication(removeIndex);
         if (removeIndex == currentDefault)
@@ -219,16 +261,14 @@ void SettingsDialog::removeApplication()
             // Move default app one up if earlier app was removed
             mTempApplications->setDefault(currentDefault - 1);
     }
-    mUI.mListWidget->clear();
+    mUI->mListWidget->clear();
     populateApplicationList();
 }
 
 void SettingsDialog::editApplication()
 {
-    QList<QListWidgetItem *> selected = mUI.mListWidget->selectedItems();
-    QListWidgetItem *item = nullptr;
-    foreach (item, selected) {
-        int row = mUI.mListWidget->row(item);
+    for (QListWidgetItem *item : mUI->mListWidget->selectedItems()) {
+        const int row = mUI->mListWidget->row(item);
         Application& app = mTempApplications->getApplication(row);
         ApplicationDialog dialog(tr("Modify an application"), app, this);
 
@@ -243,11 +283,11 @@ void SettingsDialog::editApplication()
 
 void SettingsDialog::defaultApplication()
 {
-    QList<QListWidgetItem *> selected = mUI.mListWidget->selectedItems();
+    QList<QListWidgetItem *> selected = mUI->mListWidget->selectedItems();
     if (!selected.isEmpty()) {
-        int index = mUI.mListWidget->row(selected[0]);
+        const int index = mUI->mListWidget->row(selected[0]);
         mTempApplications->setDefault(index);
-        mUI.mListWidget->clear();
+        mUI->mListWidget->clear();
         populateApplicationList();
     }
 }
@@ -262,18 +302,18 @@ void SettingsDialog::populateApplicationList()
             name += " ";
             name += tr("[Default]");
         }
-        mUI.mListWidget->addItem(name);
+        mUI->mListWidget->addItem(name);
     }
 
     // Select default application, or if there is no default app then the
     // first item.
     if (defapp == -1)
-        mUI.mListWidget->setCurrentRow(0);
+        mUI->mListWidget->setCurrentRow(0);
     else {
         if (mTempApplications->getApplicationCount() > defapp)
-            mUI.mListWidget->setCurrentRow(defapp);
+            mUI->mListWidget->setCurrentRow(defapp);
         else
-            mUI.mListWidget->setCurrentRow(0);
+            mUI->mListWidget->setCurrentRow(0);
     }
 }
 
@@ -285,56 +325,56 @@ void SettingsDialog::ok()
 
 bool SettingsDialog::showFullPath() const
 {
-    return checkStateToBool(mUI.mShowFullPath->checkState());
+    return checkStateToBool(mUI->mShowFullPath->checkState());
 }
 
 bool SettingsDialog::saveFullPath() const
 {
-    return checkStateToBool(mUI.mSaveFullPath->checkState());
+    return checkStateToBool(mUI->mSaveFullPath->checkState());
 }
 
 bool SettingsDialog::saveAllErrors() const
 {
-    return checkStateToBool(mUI.mSaveAllErrors->checkState());
+    return checkStateToBool(mUI->mSaveAllErrors->checkState());
 }
 
 bool SettingsDialog::showNoErrorsMessage() const
 {
-    return checkStateToBool(mUI.mShowNoErrorsMessage->checkState());
+    return checkStateToBool(mUI->mShowNoErrorsMessage->checkState());
 }
 
 bool SettingsDialog::showErrorId() const
 {
-    return checkStateToBool(mUI.mShowErrorId->checkState());
+    return checkStateToBool(mUI->mShowErrorId->checkState());
 }
 
 bool SettingsDialog::showInconclusive() const
 {
-    return checkStateToBool(mUI.mEnableInconclusive->checkState());
+    return checkStateToBool(mUI->mEnableInconclusive->checkState());
 }
 
 void SettingsDialog::browsePythonPath()
 {
     QString fileName = QFileDialog::getOpenFileName(this, tr("Select python binary"), QDir::rootPath());
     if (fileName.contains("python", Qt::CaseInsensitive))
-        mUI.mEditPythonPath->setText(fileName);
+        mUI->mEditPythonPath->setText(fileName);
 }
 
 void SettingsDialog::browseMisraFile()
 {
     const QString fileName = QFileDialog::getOpenFileName(this, tr("Select MISRA File"), QDir::homePath(), "Misra File (*.pdf *.txt)");
     if (!fileName.isEmpty())
-        mUI.mEditMisraFile->setText(fileName);
+        mUI->mEditMisraFile->setText(fileName);
 }
 
 // Slot to set default light style
 void SettingsDialog::setCodeEditorStyleDefault()
 {
-    if (mUI.mThemeSystem->isChecked())
+    if (mUI->mThemeSystem->isChecked())
         *mCurrentStyle = CodeEditorStyle::getSystemTheme();
-    if (mUI.mThemeLight->isChecked())
+    if (mUI->mThemeLight->isChecked())
         *mCurrentStyle = defaultStyleLight;
-    if (mUI.mThemeDark->isChecked())
+    if (mUI->mThemeDark->isChecked())
         *mCurrentStyle = defaultStyleDark;
     manageStyleControls();
 }
@@ -343,7 +383,7 @@ void SettingsDialog::setCodeEditorStyleDefault()
 void SettingsDialog::editCodeEditorStyle()
 {
     StyleEditDialog dlg(*mCurrentStyle, this);
-    int nResult = dlg.exec();
+    const int nResult = dlg.exec();
     if (nResult == QDialog::Accepted) {
         *mCurrentStyle = dlg.getStyle();
         manageStyleControls();
@@ -353,23 +393,23 @@ void SettingsDialog::editCodeEditorStyle()
 void SettingsDialog::browseClangPath()
 {
     QString selectedDir = QFileDialog::getExistingDirectory(this,
-                          tr("Select clang path"),
-                          QDir::rootPath());
+                                                            tr("Select clang path"),
+                                                            QDir::rootPath());
 
     if (!selectedDir.isEmpty()) {
-        mUI.mEditClangPath->setText(selectedDir);
+        mUI->mEditClangPath->setText(selectedDir);
     }
 }
 
 void SettingsDialog::manageStyleControls()
 {
-    bool isSystemTheme = mCurrentStyle->isSystemTheme();
-    bool isDefaultLight = !isSystemTheme && *mCurrentStyle == defaultStyleLight;
-    bool isDefaultDark =  !isSystemTheme && *mCurrentStyle == defaultStyleDark;
-    mUI.mThemeSystem->setChecked(isSystemTheme);
-    mUI.mThemeLight->setChecked(isDefaultLight && !isDefaultDark);
-    mUI.mThemeDark->setChecked(!isDefaultLight && isDefaultDark);
-    mUI.mThemeCustom->setChecked(!isSystemTheme && !isDefaultLight && !isDefaultDark);
-    mUI.mBtnEditTheme->setEnabled(!isSystemTheme && !isDefaultLight && !isDefaultDark);
+    const bool isSystemTheme = mCurrentStyle->isSystemTheme();
+    const bool isDefaultLight = !isSystemTheme && *mCurrentStyle == defaultStyleLight;
+    const bool isDefaultDark =  !isSystemTheme && *mCurrentStyle == defaultStyleDark;
+    mUI->mThemeSystem->setChecked(isSystemTheme);
+    mUI->mThemeLight->setChecked(isDefaultLight && !isDefaultDark);
+    mUI->mThemeDark->setChecked(!isDefaultLight && isDefaultDark);
+    mUI->mThemeCustom->setChecked(!isSystemTheme && !isDefaultLight && !isDefaultDark);
+    mUI->mBtnEditTheme->setEnabled(!isSystemTheme && !isDefaultLight && !isDefaultDark);
 }
 
diff --git a/gui/settingsdialog.h b/gui/settingsdialog.h
index 8c66f8b841d..d77a703ef26 100644
--- a/gui/settingsdialog.h
+++ b/gui/settingsdialog.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,110 +21,120 @@
 #define SETTINGSDIALOG_H
 
 #include <QDialog>
-#include "ui_settings.h"
+#include <QObject>
+#include <QString>
+#include <Qt>
 
 class QSettings;
 class QWidget;
 class ApplicationList;
 class TranslationHandler;
 class CodeEditorStyle;
+class QCheckBox;
+namespace Ui {
+    class Settings;
+}
 
 /// @addtogroup GUI
 /// @{
 
 /**
-* @brief Settings dialog
-*
-*/
+ * @brief Settings dialog
+ *
+ */
 class SettingsDialog : public QDialog {
     Q_OBJECT
 public:
     SettingsDialog(ApplicationList *list,
                    TranslationHandler *translator,
+                   bool premium,
                    QWidget *parent = nullptr);
     SettingsDialog(const SettingsDialog &) = delete;
-    virtual ~SettingsDialog();
+    ~SettingsDialog() override;
     SettingsDialog &operator=(const SettingsDialog &) = delete;
 
     /**
-    * @brief Save all values to QSettings
-    *
-    */
+     * @brief Save all values to QSettings
+     *
+     */
     void saveSettingValues() const;
 
     /**
-    * @brief Get checkbox value for mShowFullPath
-    *
-    * @return should full path of errors be shown in the tree
-    */
+     * @brief Get checkbox value for mShowFullPath
+     *
+     * @return should full path of errors be shown in the tree
+     */
     bool showFullPath() const;
 
     /**
-    * @brief Get checkbox value for mSaveFullPath
-    *
-    * @return should full path of files be saved when creating a report
-    */
+     * @brief Get checkbox value for mSaveFullPath
+     *
+     * @return should full path of files be saved when creating a report
+     */
     bool saveFullPath() const;
 
 
     /**
-    * @brief Get checkbox value for mNoErrorsMessage
-    *
-    * @return Should "no errors message" be hidden
-    */
+     * @brief Get checkbox value for mNoErrorsMessage
+     *
+     * @return Should "no errors message" be hidden
+     */
     bool showNoErrorsMessage() const;
 
     /**
-    * @brief Get checkbox value for mShowIdColumn
-    *
-    * @return Should error id column be displayed
-    */
+     * @brief Get checkbox value for mShowIdColumn
+     *
+     * @return Should error id column be displayed
+     */
     bool showErrorId() const;
 
 
     /**
-    * @brief Get checkbox value for mEnableInconclusive
-    *
-    * @return Should inconclusive column be displayed
-    */
+     * @brief Get checkbox value for mEnableInconclusive
+     *
+     * @return Should inconclusive column be displayed
+     */
     bool showInconclusive() const;
 
     /**
-    * @brief Get checkbox value for mSaveAllErrors
-    *
-    * @return should all errors be saved to report
-    */
+     * @brief Get checkbox value for mSaveAllErrors
+     *
+     * @return should all errors be saved to report
+     */
     bool saveAllErrors() const;
 
 protected slots:
     /**
-    * @brief Slot for clicking OK.
-    *
-    */
+     * @brief Slot for clicking OK.
+     *
+     */
     void ok();
 
+    /** @brief Slot for validating input value in @c editPythonPath */
+    void validateEditPythonPath();
+
     /**
-    * @brief Slot for adding a new application to the list
-    *
-    */
+     * @brief Slot for adding a new application to the list
+     *
+     */
     void addApplication();
 
     /**
-    * @brief Slot for deleting an application from the list
-    *
-    */
+     * @brief Slot for deleting an application from the list
+     *
+     */
     void removeApplication();
 
     /**
-    * @brief Slot for modifying an application in the list
-    *
-    */
+     * @brief Slot for modifying an application in the list
+     *
+     */
     void editApplication();
 
     /**
-    * @brief Slot for making the selected application as the default (first)
-    *
-    */
+     * @brief Slot for making the selected application as the default (first)
+     *
+     */
     void defaultApplication();
 
     /** @brief Slot for browsing for the python binary */
@@ -150,22 +160,22 @@ protected slots:
 
 protected:
     /**
-    * @brief Clear all applications from the list and re insert them from mTempApplications
-    *
-    */
+     * @brief Clear all applications from the list and re insert them from mTempApplications
+     *
+     */
     void populateApplicationList();
 
     /**
-    * @brief Load saved values
-    * Loads dialog size and column widths.
-    *
-    */
+     * @brief Load saved values
+     * Loads dialog size and column widths.
+     *
+     */
     void loadSettings();
 
     /**
-    * @brief Save settings
-    * Save dialog size and column widths.
-    */
+     * @brief Save settings
+     * Save dialog size and column widths.
+     */
     void saveSettings() const;
 
     /**
@@ -175,27 +185,27 @@ protected slots:
      * @param box checkbox to save
      * @param name name for QSettings to store the value
      */
-    static void saveCheckboxValue(QSettings *settings, QCheckBox *box, const QString &name);
+    static void saveCheckboxValue(QSettings *settings, const QCheckBox *box, const QString &name);
 
     /**
-    * @brief Convert bool to Qt::CheckState
-    *
-    * @param yes value to convert
-    * @return value converted to Qt::CheckState
-    */
+     * @brief Convert bool to Qt::CheckState
+     *
+     * @param yes value to convert
+     * @return value converted to Qt::CheckState
+     */
     static Qt::CheckState boolToCheckState(bool yes);
 
     /**
-    * @brief Converts Qt::CheckState to bool
-    *
-    * @param state Qt::CheckState to convert
-    * @return converted value
-    */
+     * @brief Converts Qt::CheckState to bool
+     *
+     * @param state Qt::CheckState to convert
+     * @return converted value
+     */
     static bool checkStateToBool(Qt::CheckState state);
 
     /**
-    * @brief Populate the translations list.
-    */
+     * @brief Populate the translations list.
+     */
     void initTranslationsList();
 
     /**
@@ -204,33 +214,35 @@ protected slots:
     CodeEditorStyle *mCurrentStyle;
 
     /**
-    * @brief List of applications user has specified
-    *
-    */
+     * @brief List of applications user has specified
+     *
+     */
     ApplicationList *mApplications;
 
     /**
-    * @brief Temporary list of applications
-    * This will be copied to actual list of applications (mApplications)
-    * when user clicks ok.
-    */
+     * @brief Temporary list of applications
+     * This will be copied to actual list of applications (mApplications)
+     * when user clicks ok.
+     */
     ApplicationList *mTempApplications;
 
     /**
-    * @brief List of translations.
-    *
-    */
+     * @brief List of translations.
+     *
+     */
     TranslationHandler *mTranslator;
 
     /**
-    * @brief Dialog from UI designer
-    *
-    */
-    Ui::Settings mUI;
+     * @brief Dialog from UI designer
+     *
+     */
+    Ui::Settings *mUI;
 private:
     void manageStyleControls();
 
-    static const int mLangCodeRole = Qt::UserRole;
+    static constexpr int mLangCodeRole = Qt::UserRole;
+
+    bool mPremium;
 };
 /// @}
 #endif // SETTINGSDIALOG_H
diff --git a/gui/showtypes.cpp b/gui/showtypes.cpp
index 16515a80946..f1c0d325257 100644
--- a/gui/showtypes.cpp
+++ b/gui/showtypes.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2016 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,10 +16,12 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QSettings>
-#include "common.h"
 #include "showtypes.h"
-#include "errorlogger.h"
+
+#include "common.h"
+#include "errortypes.h"
+
+#include <QSettings>
 
 ShowTypes::ShowTypes()
 {
@@ -31,10 +33,11 @@ ShowTypes::~ShowTypes()
     save();
 }
 
-ShowTypes::ShowType ShowTypes::SeverityToShowType(Severity::SeverityType severity)
+ShowTypes::ShowType ShowTypes::SeverityToShowType(Severity severity)
 {
     switch (severity) {
     case Severity::none:
+    case Severity::internal:
         return ShowTypes::ShowNone;
     case Severity::error:
         return ShowTypes::ShowErrors;
@@ -53,42 +56,6 @@ ShowTypes::ShowType ShowTypes::SeverityToShowType(Severity::SeverityType severit
     }
 }
 
-Severity::SeverityType ShowTypes::ShowTypeToSeverity(ShowTypes::ShowType type)
-{
-    switch (type) {
-    case ShowTypes::ShowStyle:
-        return Severity::style;
-
-    case ShowTypes::ShowErrors:
-        return Severity::error;
-
-    case ShowTypes::ShowWarnings:
-        return Severity::warning;
-
-    case ShowTypes::ShowPerformance:
-        return Severity::performance;
-
-    case ShowTypes::ShowPortability:
-        return Severity::portability;
-
-    case ShowTypes::ShowInformation:
-        return Severity::information;
-
-    case ShowTypes::ShowNone:
-    default:
-        return Severity::none;
-    }
-}
-
-ShowTypes::ShowType ShowTypes::VariantToShowType(const QVariant &data)
-{
-    const int value = data.toInt();
-    if (value < ShowTypes::ShowStyle || value > ShowTypes::ShowErrors) {
-        return ShowTypes::ShowNone;
-    }
-    return (ShowTypes::ShowType)value;
-}
-
 void ShowTypes::load()
 {
     QSettings settings;
@@ -116,7 +83,7 @@ bool ShowTypes::isShown(ShowTypes::ShowType category) const
     return mVisible[category];
 }
 
-bool ShowTypes::isShown(Severity::SeverityType severity) const
+bool ShowTypes::isShown(Severity severity) const
 {
     return isShown(ShowTypes::SeverityToShowType(severity));
 }
diff --git a/gui/showtypes.h b/gui/showtypes.h
index d0c4318efcf..5bb43203dd7 100644
--- a/gui/showtypes.h
+++ b/gui/showtypes.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2016 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,28 +19,29 @@
 #ifndef SHOWTYPES_H
 #define SHOWTYPES_H
 
-#include <QVariant>
-#include "errorlogger.h"
+#include <cstdint>
+
+enum class Severity : std::uint8_t;
 
 /// @addtogroup GUI
 /// @{
 
 /**
-  * @brief A class for different show types we have.
-  * This class contains enum type for the different show types we have. Each
-  * show type presents one severity selectable in the GUI. In addition there
-  * are several supporting functions.
-  *
-  * Notice that the "visibility" settings are automatically loaded when the
-  * class is constructed and saved when the class is destroyed.
-  */
+ * @brief A class for different show types we have.
+ * This class contains enum type for the different show types we have. Each
+ * show type presents one severity selectable in the GUI. In addition there
+ * are several supporting functions.
+ *
+ * Notice that the "visibility" settings are automatically loaded when the
+ * class is constructed and saved when the class is destroyed.
+ */
 class ShowTypes {
 public:
 
     /**
-      * @brief Show types we have (i.e. severities in the GUI).
-      */
-    enum ShowType {
+     * @brief Show types we have (i.e. severities in the GUI).
+     */
+    enum ShowType : std::uint8_t {
         ShowStyle = 0,
         ShowWarnings,
         ShowPerformance,
@@ -84,7 +85,7 @@ class ShowTypes {
      * @param severity severity to check.
      * @return true if the severity is visible.
      */
-    bool isShown(Severity::SeverityType severity) const;
+    bool isShown(Severity severity) const;
 
     /**
      * @brief Show/hide the showtype.
@@ -98,22 +99,7 @@ class ShowTypes {
      * @param severity Error severity
      * @return Severity converted to ShowTypes value
      */
-    static ShowTypes::ShowType SeverityToShowType(Severity::SeverityType severity);
-
-    /**
-     * @brief Convert ShowType to severity string
-     * @param type ShowType to convert
-     * @return ShowType converted to severity
-     */
-    static Severity::SeverityType ShowTypeToSeverity(ShowTypes::ShowType type);
-
-    /**
-     * @brief Convert QVariant (that contains an int) to Showtypes value
-     *
-     * @param data QVariant (that contains an int) to be converted
-     * @return data converted to ShowTypes
-     */
-    static ShowTypes::ShowType VariantToShowType(const QVariant &data);
+    static ShowTypes::ShowType SeverityToShowType(Severity severity);
 
     bool mVisible[ShowNone];
 };
diff --git a/gui/statsdialog.cpp b/gui/statsdialog.cpp
index 6126febcd09..f16b6cba3b9 100644
--- a/gui/statsdialog.cpp
+++ b/gui/statsdialog.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,44 +15,91 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
-#include <QPrinter>
+
+#include "statsdialog.h"
+
+#include "checkstatistics.h"
+#include "projectfile.h"
+#include "showtypes.h"
+
+#include <algorithm>
+
+#include "ui_statsdialog.h"
+
+#include <QApplication>
+#include <QClipboard>
 #include <QDate>
 #include <QFileDialog>
 #include <QFileInfo>
+#include <QFont>
+#include <QLabel>
+#include <QLineEdit>
+#include <QMimeData>
+#include <QPageSize>
+#include <QPlainTextEdit>
+#include <QPrinter>
+#include <QPushButton>
+#include <QStringList>
 #include <QTextDocument>
 #include <QWidget>
-#include <QString>
-#include <QClipboard>
-#include <QMimeData>
-#include "projectfile.h"
-#include "statsdialog.h"
-#include "checkstatistics.h"
+#include <Qt>
+
+#ifdef QT_CHARTS_LIB
 #include "common.h"
 
+#include <QAbstractSeries>
+#include <QChartView>
+#include <QDateTime>
+#include <QDateTimeAxis>
+#include <QDir>
+#include <QFile>
+#include <QIODevice>
+#include <QLayout>
+#include <QLineSeries>
+#include <QList>
+#include <QPainter>
+#include <QPointF>
+#include <QRegularExpression>
+#include <QTextStream>
+#include <QValueAxis>
+
+static QLineSeries *numberOfReports(const QString &fileName, const QString &severity);
+static QChartView *createChart(const QString &statsFile, const QString &tool);
+#endif
+
 static const QString CPPCHECK("cppcheck");
 
 StatsDialog::StatsDialog(QWidget *parent)
     : QDialog(parent),
-      mStatistics(nullptr)
+    mUI(new Ui::StatsDialog)
 {
-    mUI.setupUi(this);
+    mUI->setupUi(this);
+
+    QFont font("courier");
+    font.setStyleHint(QFont::Monospace);
+    mUI->mCheckersReport->setFont(font);
 
     setWindowFlags(Qt::Window);
 
-    connect(mUI.mCopyToClipboard, &QPushButton::pressed, this, &StatsDialog::copyToClipboard);
-    connect(mUI.mPDFexport, &QPushButton::pressed, this, &StatsDialog::pdfExport);
+    connect(mUI->mCopyToClipboard, &QPushButton::pressed, this, &StatsDialog::copyToClipboard);
+    connect(mUI->mPDFexport, &QPushButton::pressed, this, &StatsDialog::pdfExport);
+}
+
+StatsDialog::~StatsDialog()
+{
+    delete mUI;
 }
 
 void StatsDialog::setProject(const ProjectFile* projectFile)
 {
     if (projectFile) {
-        mUI.mProject->setText(projectFile->getRootPath());
-        mUI.mPaths->setText(projectFile->getCheckPaths().join(";"));
-        mUI.mIncludePaths->setText(projectFile->getIncludeDirs().join(";"));
-        mUI.mDefines->setText(projectFile->getDefines().join(";"));
-        mUI.mUndefines->setText(projectFile->getUndefines().join(";"));
-#ifndef HAVE_QCHART
-        mUI.mTabHistory->setVisible(false);
+        mUI->mProject->setText(projectFile->getRootPath());
+        mUI->mPaths->setText(projectFile->getCheckPaths().join(";"));
+        mUI->mIncludePaths->setText(projectFile->getIncludeDirs().join(";"));
+        mUI->mDefines->setText(projectFile->getDefines().join(";"));
+        mUI->mUndefines->setText(projectFile->getUndefines().join(";"));
+#ifndef QT_CHARTS_LIB
+        mUI->mTabHistory->setVisible(false);
 #else
         QString statsFile;
         if (!projectFile->getBuildDir().isEmpty()) {
@@ -62,49 +109,48 @@ void StatsDialog::setProject(const ProjectFile* projectFile)
                 statsFile = buildDir + "/statistics.txt";
             }
         }
-        mUI.mLblHistoryFile->setText(tr("File: ") + (statsFile.isEmpty() ? tr("No cppcheck build dir") : statsFile));
+        mUI->mLblHistoryFile->setText(tr("File: ") + (statsFile.isEmpty() ? tr("No cppcheck build dir") : statsFile));
         if (!statsFile.isEmpty()) {
-            QChartView *chartView;
-            chartView = createChart(statsFile, "cppcheck");
-            mUI.mTabHistory->layout()->addWidget(chartView);
+            QChartView *chartView = createChart(statsFile, "cppcheck");
+            mUI->mTabHistory->layout()->addWidget(chartView);
             if (projectFile->getClangAnalyzer()) {
                 chartView = createChart(statsFile, CLANG_ANALYZER);
-                mUI.mTabHistory->layout()->addWidget(chartView);
+                mUI->mTabHistory->layout()->addWidget(chartView);
             }
             if (projectFile->getClangTidy()) {
                 chartView = createChart(statsFile, CLANG_TIDY);
-                mUI.mTabHistory->layout()->addWidget(chartView);
+                mUI->mTabHistory->layout()->addWidget(chartView);
             }
         }
 #endif
     } else {
-        mUI.mProject->setText(QString());
-        mUI.mPaths->setText(QString());
-        mUI.mIncludePaths->setText(QString());
-        mUI.mDefines->setText(QString());
-        mUI.mUndefines->setText(QString());
+        mUI->mProject->setText(QString());
+        mUI->mPaths->setText(QString());
+        mUI->mIncludePaths->setText(QString());
+        mUI->mDefines->setText(QString());
+        mUI->mUndefines->setText(QString());
     }
 }
 
 void StatsDialog::setPathSelected(const QString& path)
 {
-    mUI.mPath->setText(path);
+    mUI->mPath->setText(path);
 }
 
 void StatsDialog::setNumberOfFilesScanned(int num)
 {
-    mUI.mNumberOfFilesScanned->setText(QString::number(num));
+    mUI->mNumberOfFilesScanned->setText(QString::number(num));
 }
 
 void StatsDialog::setScanDuration(double seconds)
 {
     // Factor the duration into units (days/hours/minutes/seconds)
-    int secs = seconds;
-    int days = secs / (24 * 60 * 60);
+    int secs = static_cast<int>(seconds);
+    const int days = secs / (24 * 60 * 60);
     secs -= days * (24 * 60 * 60);
-    int hours = secs / (60 * 60);
+    const int hours = secs / (60 * 60);
     secs -= hours * (60 * 60);
-    int mins = secs / 60;
+    const int mins = secs / 60;
     secs -= mins * 60;
 
     // Concatenate the two most significant units (e.g. "1 day and 3 hours")
@@ -122,18 +168,18 @@ void StatsDialog::setScanDuration(double seconds)
     if (parts.isEmpty())
         parts << tr("0.%1 seconds").arg(int(10.0 *(seconds - secs)));
 
-    mUI.mScanDuration->setText(parts.join(tr(" and ")));
+    mUI->mScanDuration->setText(parts.join(tr(" and ")));
 }
 void StatsDialog::pdfExport()
 {
     const QString Stat = QString(
-                             "<center><h1>%1   %2</h1></center>\n"
-                             "<font color=\"red\"><h3>%3   :   %4</h3></font>\n"
-                             "<font color=\"green\"><h3>%5   :   %6</h3></font>\n"
-                             "<font color=\"orange\"><h3>%7   :   %8</h3></font>\n"
-                             "<font color=\"blue\"><h3>%9   :   %10</h3></font>\n"
-                             "<font color=\"blue\"><h3>%11  :   %12</h3></font>\n"
-                             "<font color=\"purple\"><h3>%13  :   %14</h3></font>\n")
+        "<center><h1>%1   %2</h1></center>\n"
+        "<font color=\"red\"><h3>%3   :   %4</h3></font>\n"
+        "<font color=\"green\"><h3>%5   :   %6</h3></font>\n"
+        "<font color=\"orange\"><h3>%7   :   %8</h3></font>\n"
+        "<font color=\"blue\"><h3>%9   :   %10</h3></font>\n"
+        "<font color=\"blue\"><h3>%11  :   %12</h3></font>\n"
+        "<font color=\"purple\"><h3>%13  :   %14</h3></font>\n")
                          .arg(tr("Statistics"))
                          .arg(QDate::currentDate().toString("dd.MM.yyyy"))
                          .arg(tr("Errors"))
@@ -149,13 +195,13 @@ void StatsDialog::pdfExport()
                          .arg(tr("Information messages"))
                          .arg(mStatistics->getCount(CPPCHECK,ShowTypes::ShowInformation));
 
-    QString fileName = QFileDialog::getSaveFileName((QWidget*)nullptr, tr("Export PDF"), QString(), "*.pdf");
+    QString fileName = QFileDialog::getSaveFileName(nullptr, tr("Export PDF"), QString(), "*.pdf");
     if (QFileInfo(fileName).suffix().isEmpty()) {
         fileName.append(".pdf");
     }
     QPrinter printer(QPrinter::PrinterResolution);
     printer.setOutputFormat(QPrinter::PdfFormat);
-    printer.setPaperSize(QPrinter::A4);
+    printer.setPageSize(QPageSize(QPageSize::A4));
     printer.setOutputFileName(fileName);
 
     QTextDocument doc;
@@ -191,48 +237,48 @@ void StatsDialog::copyToClipboard()
 
     // Plain text summary
     const QString settings = QString(
-                                 "%1\n"
-                                 "\t%2:\t%3\n"
-                                 "\t%4:\t%5\n"
-                                 "\t%6:\t%7\n"
-                                 "\t%8:\t%9\n"
-                                 "\t%10:\t%11\n"
-                             )
+        "%1\n"
+        "\t%2:\t%3\n"
+        "\t%4:\t%5\n"
+        "\t%6:\t%7\n"
+        "\t%8:\t%9\n"
+        "\t%10:\t%11\n"
+        )
                              .arg(projSettings)
                              .arg(project)
-                             .arg(mUI.mProject->text())
+                             .arg(mUI->mProject->text())
                              .arg(paths)
-                             .arg(mUI.mPaths->text())
+                             .arg(mUI->mPaths->text())
                              .arg(incPaths)
-                             .arg(mUI.mIncludePaths->text())
+                             .arg(mUI->mIncludePaths->text())
                              .arg(defines)
-                             .arg(mUI.mDefines->text())
+                             .arg(mUI->mDefines->text())
                              .arg(undefines)
-                             .arg(mUI.mUndefines->text());
+                             .arg(mUI->mUndefines->text());
 
     const QString previous = QString(
-                                 "%1\n"
-                                 "\t%2:\t%3\n"
-                                 "\t%4:\t%5\n"
-                                 "\t%6:\t%7\n"
-                             )
+        "%1\n"
+        "\t%2:\t%3\n"
+        "\t%4:\t%5\n"
+        "\t%6:\t%7\n"
+        )
                              .arg(prevScan)
                              .arg(selPath)
-                             .arg(mUI.mPath->text())
+                             .arg(mUI->mPath->text())
                              .arg(numFiles)
-                             .arg(mUI.mNumberOfFilesScanned->text())
+                             .arg(mUI->mNumberOfFilesScanned->text())
                              .arg(duration)
-                             .arg(mUI.mScanDuration->text());
+                             .arg(mUI->mScanDuration->text());
 
     const QString statistics = QString(
-                                   "%1\n"
-                                   "\t%2:\t%3\n"
-                                   "\t%4:\t%5\n"
-                                   "\t%6:\t%7\n"
-                                   "\t%8:\t%9\n"
-                                   "\t%10:\t%11\n"
-                                   "\t%12:\t%13\n"
-                               )
+        "%1\n"
+        "\t%2:\t%3\n"
+        "\t%4:\t%5\n"
+        "\t%6:\t%7\n"
+        "\t%8:\t%9\n"
+        "\t%10:\t%11\n"
+        "\t%12:\t%13\n"
+        )
                                .arg(stats)
                                .arg(errors)
                                .arg(mStatistics->getCount(CPPCHECK,ShowTypes::ShowErrors))
@@ -251,53 +297,53 @@ void StatsDialog::copyToClipboard()
 
     // HTML summary
     const QString htmlSettings = QString(
-                                     "<h3>%1<h3>\n"
-                                     "<table>\n"
-                                     " <tr><th>%2:</th><td>%3</td></tr>\n"
-                                     " <tr><th>%4:</th><td>%5</td></tr>\n"
-                                     " <tr><th>%6:</th><td>%7</td></tr>\n"
-                                     " <tr><th>%8:</th><td>%9</td></tr>\n"
-                                     " <tr><th>%10:</th><td>%11</td></tr>\n"
-                                     "</table>\n"
-                                 )
+        "<h3>%1<h3>\n"
+        "<table>\n"
+        " <tr><th>%2:</th><td>%3</td></tr>\n"
+        " <tr><th>%4:</th><td>%5</td></tr>\n"
+        " <tr><th>%6:</th><td>%7</td></tr>\n"
+        " <tr><th>%8:</th><td>%9</td></tr>\n"
+        " <tr><th>%10:</th><td>%11</td></tr>\n"
+        "</table>\n"
+        )
                                  .arg(projSettings)
                                  .arg(project)
-                                 .arg(mUI.mProject->text())
+                                 .arg(mUI->mProject->text())
                                  .arg(paths)
-                                 .arg(mUI.mPaths->text())
+                                 .arg(mUI->mPaths->text())
                                  .arg(incPaths)
-                                 .arg(mUI.mIncludePaths->text())
+                                 .arg(mUI->mIncludePaths->text())
                                  .arg(defines)
-                                 .arg(mUI.mDefines->text())
+                                 .arg(mUI->mDefines->text())
                                  .arg(undefines)
-                                 .arg(mUI.mUndefines->text());
+                                 .arg(mUI->mUndefines->text());
 
     const QString htmlPrevious = QString(
-                                     "<h3>%1</h3>\n"
-                                     "<table>\n"
-                                     " <tr><th>%2:</th><td>%3</td></tr>\n"
-                                     " <tr><th>%4:</th><td>%5</td></tr>\n"
-                                     " <tr><th>%6:</th><td>%7</td></tr>\n"
-                                     "</table>\n"
-                                 )
+        "<h3>%1</h3>\n"
+        "<table>\n"
+        " <tr><th>%2:</th><td>%3</td></tr>\n"
+        " <tr><th>%4:</th><td>%5</td></tr>\n"
+        " <tr><th>%6:</th><td>%7</td></tr>\n"
+        "</table>\n"
+        )
                                  .arg(prevScan)
                                  .arg(selPath)
-                                 .arg(mUI.mPath->text())
+                                 .arg(mUI->mPath->text())
                                  .arg(numFiles)
-                                 .arg(mUI.mNumberOfFilesScanned->text())
+                                 .arg(mUI->mNumberOfFilesScanned->text())
                                  .arg(duration)
-                                 .arg(mUI.mScanDuration->text());
+                                 .arg(mUI->mScanDuration->text());
 
     const QString htmlStatistics = QString(
-                                       "<h3>%1</h3>\n"
-                                       " <tr><th>%2:</th><td>%3</td></tr>\n"
-                                       " <tr><th>%4:</th><td>%5</td></tr>\n"
-                                       " <tr><th>%6:</th><td>%7</td></tr>\n"
-                                       " <tr><th>%8:</th><td>%9</td></tr>\n"
-                                       " <tr><th>%10:</th><td>%11</td></tr>\n"
-                                       " <tr><th>%12:</th><td>%13</td></tr>\n"
-                                       "</table>\n"
-                                   )
+        "<h3>%1</h3>\n"
+        " <tr><th>%2:</th><td>%3</td></tr>\n"
+        " <tr><th>%4:</th><td>%5</td></tr>\n"
+        " <tr><th>%6:</th><td>%7</td></tr>\n"
+        " <tr><th>%8:</th><td>%9</td></tr>\n"
+        " <tr><th>%10:</th><td>%11</td></tr>\n"
+        " <tr><th>%12:</th><td>%13</td></tr>\n"
+        "</table>\n"
+        )
                                    .arg(stats)
                                    .arg(errors)
                                    .arg(mStatistics->getCount(CPPCHECK,ShowTypes::ShowErrors))
@@ -314,7 +360,7 @@ void StatsDialog::copyToClipboard()
 
     const QString htmlSummary = htmlSettings + htmlPrevious + htmlStatistics;
 
-    QMimeData *mimeData = new QMimeData();
+    auto *mimeData = new QMimeData();
     mimeData->setText(textSummary);
     mimeData->setHtml(htmlSummary);
     clipboard->setMimeData(mimeData);
@@ -323,44 +369,46 @@ void StatsDialog::copyToClipboard()
 void StatsDialog::setStatistics(const CheckStatistics *stats)
 {
     mStatistics = stats;
-    mUI.mLblErrors->setText(QString("%1").arg(stats->getCount(CPPCHECK,ShowTypes::ShowErrors)));
-    mUI.mLblWarnings->setText(QString("%1").arg(stats->getCount(CPPCHECK,ShowTypes::ShowWarnings)));
-    mUI.mLblStyle->setText(QString("%1").arg(stats->getCount(CPPCHECK,ShowTypes::ShowStyle)));
-    mUI.mLblPortability->setText(QString("%1").arg(stats->getCount(CPPCHECK,ShowTypes::ShowPortability)));
-    mUI.mLblPerformance->setText(QString("%1").arg(stats->getCount(CPPCHECK,ShowTypes::ShowPerformance)));
-    mUI.mLblInformation->setText(QString("%1").arg(stats->getCount(CPPCHECK,ShowTypes::ShowInformation)));
+    mUI->mLblErrors->setText(QString::number(stats->getCount(CPPCHECK,ShowTypes::ShowErrors)));
+    mUI->mLblWarnings->setText(QString::number(stats->getCount(CPPCHECK,ShowTypes::ShowWarnings)));
+    mUI->mLblStyle->setText(QString::number(stats->getCount(CPPCHECK,ShowTypes::ShowStyle)));
+    mUI->mLblPortability->setText(QString::number(stats->getCount(CPPCHECK,ShowTypes::ShowPortability)));
+    mUI->mLblPerformance->setText(QString::number(stats->getCount(CPPCHECK,ShowTypes::ShowPerformance)));
+    mUI->mLblInformation->setText(QString::number(stats->getCount(CPPCHECK,ShowTypes::ShowInformation)));
+    mUI->mLblActiveCheckers->setText(QString::number(stats->getNumberOfActiveCheckers()));
+    mUI->mCheckersReport->setPlainText(stats->getCheckersReport());
 }
 
-#ifdef HAVE_QCHART
-QChartView *StatsDialog::createChart(const QString &statsFile, const QString &tool)
+#ifdef QT_CHARTS_LIB
+QChartView *createChart(const QString &statsFile, const QString &tool)
 {
-    QChart *chart = new QChart;
+    auto *chart = new QChart;
     chart->addSeries(numberOfReports(statsFile, tool + "-error"));
     chart->addSeries(numberOfReports(statsFile, tool + "-warning"));
     chart->addSeries(numberOfReports(statsFile, tool + "-style"));
     chart->addSeries(numberOfReports(statsFile, tool + "-performance"));
     chart->addSeries(numberOfReports(statsFile, tool + "-portability"));
 
-    QDateTimeAxis *axisX = new QDateTimeAxis;
+    auto *axisX = new QDateTimeAxis;
     axisX->setTitleText("Date");
     chart->addAxis(axisX, Qt::AlignBottom);
 
-    foreach (QAbstractSeries *s, chart->series()) {
+    for (QAbstractSeries *s : chart->series()) {
         s->attachAxis(axisX);
     }
 
-    QValueAxis *axisY = new QValueAxis;
+    auto *axisY = new QValueAxis;
     axisY->setLabelFormat("%i");
     axisY->setTitleText("Count");
     chart->addAxis(axisY, Qt::AlignLeft);
 
     qreal maxY = 0;
-    foreach (QAbstractSeries *s, chart->series()) {
+    for (QAbstractSeries *s : chart->series()) {
         s->attachAxis(axisY);
-        if (QLineSeries *ls = dynamic_cast<QLineSeries*>(s)) {
-            foreach (QPointF p, ls->points()) {
-                if (p.y() > maxY)
-                    maxY = p.y();
+        if (const auto *ls = dynamic_cast<const QLineSeries*>(s)) {
+            for (QPointF p : ls->points()) {
+                // cppcheck-suppress useStlAlgorithm - this would reduce the readability of the code
+                maxY = std::max(p.y(), maxY);
             }
         }
     }
@@ -369,14 +417,14 @@ QChartView *StatsDialog::createChart(const QString &statsFile, const QString &to
     //chart->createDefaultAxes();
     chart->setTitle(tool);
 
-    QChartView *chartView = new QChartView(chart);
+    auto *chartView = new QChartView(chart);
     chartView->setRenderHint(QPainter::Antialiasing);
     return chartView;
 }
 
-QLineSeries *StatsDialog::numberOfReports(const QString &fileName, const QString &severity) const
+QLineSeries *numberOfReports(const QString &fileName, const QString &severity)
 {
-    QLineSeries *series = new QLineSeries();
+    auto *series = new QLineSeries();
     series->setName(severity);
     QFile f(fileName);
     if (f.open(QIODevice::ReadOnly | QIODevice::Text)) {
@@ -384,11 +432,12 @@ QLineSeries *StatsDialog::numberOfReports(const QString &fileName, const QString
         QTextStream in(&f);
         while (!in.atEnd()) {
             QString line = in.readLine();
-            QRegExp rxdate("\\[(\\d\\d)\\.(\\d\\d)\\.(\\d\\d\\d\\d)\\]");
-            if (rxdate.exactMatch(line)) {
-                int y = rxdate.cap(3).toInt();
-                int m = rxdate.cap(2).toInt();
-                int d = rxdate.cap(1).toInt();
+            static const QRegularExpression rxdate("^\\[(\\d\\d)\\.(\\d\\d)\\.(\\d\\d\\d\\d)\\]$");
+            const QRegularExpressionMatch matchRes = rxdate.match(line);
+            if (matchRes.hasMatch()) {
+                const int y = matchRes.captured(3).toInt();
+                const int m = matchRes.captured(2).toInt();
+                const int d = matchRes.captured(1).toInt();
                 QDateTime dt;
                 dt.setDate(QDate(y,m,d));
                 if (t == dt.toMSecsSinceEpoch())
@@ -397,7 +446,7 @@ QLineSeries *StatsDialog::numberOfReports(const QString &fileName, const QString
                     t = dt.toMSecsSinceEpoch();
             }
             if (line.startsWith(severity + ':')) {
-                int y = line.mid(1+severity.length()).toInt();
+                const int y = line.mid(1+severity.length()).toInt();
                 series->append(t, y);
             }
         }
diff --git a/gui/statsdialog.h b/gui/statsdialog.h
index 03bea3874db..2093e17389e 100644
--- a/gui/statsdialog.h
+++ b/gui/statsdialog.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,61 +20,60 @@
 #define STATSDIALOG_H
 
 #include <QDialog>
-#ifdef HAVE_QCHART
-#include <QtCharts>
-#endif
-#include "ui_stats.h"
+#include <QObject>
+#include <QString>
 
 class ProjectFile;
 class CheckStatistics;
+class QWidget;
+namespace Ui {
+    class StatsDialog;
+}
 
 /// @addtogroup GUI
 /// @{
 
 /**
-* @brief A dialog that shows project and scan statistics.
-*
-*/
+ * @brief A dialog that shows project and scan statistics.
+ *
+ */
 class StatsDialog : public QDialog {
     Q_OBJECT
 public:
     explicit StatsDialog(QWidget *parent = nullptr);
+    ~StatsDialog() override;
 
     /**
-    * @brief Sets the project to extract statistics from
-    */
+     * @brief Sets the project to extract statistics from
+     */
     void setProject(const ProjectFile *projectFile);
 
     /**
-    * @brief Sets the string to display beside "Path Selected:"
-    */
+     * @brief Sets the string to display beside "Path Selected:"
+     */
     void setPathSelected(const QString& path);
 
     /**
-    * @brief Sets the number to display beside "Number of Files Scanned:"
-    */
+     * @brief Sets the number to display beside "Number of Files Scanned:"
+     */
     void setNumberOfFilesScanned(int num);
 
     /**
-    * @brief Sets the number of seconds to display beside "Scan Duration:"
-    */
+     * @brief Sets the number of seconds to display beside "Scan Duration:"
+     */
     void setScanDuration(double seconds);
 
     /**
-    * @brief Sets the numbers of different error/warnings found."
-    */
+     * @brief Sets the numbers of different error/warnings found."
+     */
     void setStatistics(const CheckStatistics *stats);
 
 private slots:
     void copyToClipboard();
     void pdfExport();
-#ifdef HAVE_QCHART
-    QChartView *createChart(const QString &statsFile, const QString &tool);
-    QLineSeries *numberOfReports(const QString &fileName, const QString &severity) const;
-#endif
 private:
-    Ui::StatsDialog mUI;
-    const CheckStatistics *mStatistics;
+    Ui::StatsDialog *mUI;
+    const CheckStatistics* mStatistics{};
 };
 
 /// @}
diff --git a/gui/stats.ui b/gui/statsdialog.ui
similarity index 70%
rename from gui/stats.ui
rename to gui/statsdialog.ui
index 8147b8e7ec6..a749c51e676 100644
--- a/gui/stats.ui
+++ b/gui/statsdialog.ui
@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>502</width>
-    <height>274</height>
+    <width>500</width>
+    <height>414</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -247,114 +247,150 @@
       <attribute name="title">
        <string>Statistics</string>
       </attribute>
-      <layout class="QFormLayout" name="formLayout">
+      <layout class="QGridLayout" name="gridLayout_2">
        <item row="0" column="0">
-        <layout class="QHBoxLayout" name="horizontalLayout_5">
-         <item>
-          <widget class="QLabel" name="label">
-           <property name="text">
-            <string>Errors:</string>
-           </property>
-          </widget>
-         </item>
-         <item>
-          <widget class="QLabel" name="mLblErrors">
-           <property name="text">
-            <string notr="true">TextLabel</string>
-           </property>
-          </widget>
-         </item>
-        </layout>
+        <widget class="QLabel" name="label">
+         <property name="text">
+          <string>Errors:</string>
+         </property>
+         <property name="alignment">
+          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+         </property>
+        </widget>
+       </item>
+       <item row="0" column="1">
+        <widget class="QLabel" name="mLblErrors">
+         <property name="text">
+          <string notr="true">TextLabel</string>
+         </property>
+        </widget>
        </item>
        <item row="1" column="0">
-        <layout class="QHBoxLayout" name="horizontalLayout_2">
-         <item>
-          <widget class="QLabel" name="label_2">
-           <property name="text">
-            <string>Warnings:</string>
-           </property>
-          </widget>
-         </item>
-         <item>
-          <widget class="QLabel" name="mLblWarnings">
-           <property name="text">
-            <string notr="true">TextLabel</string>
-           </property>
-          </widget>
-         </item>
-        </layout>
+        <widget class="QLabel" name="label_2">
+         <property name="text">
+          <string>Warnings:</string>
+         </property>
+         <property name="alignment">
+          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+         </property>
+        </widget>
+       </item>
+       <item row="1" column="1">
+        <widget class="QLabel" name="mLblWarnings">
+         <property name="text">
+          <string notr="true">TextLabel</string>
+         </property>
+        </widget>
        </item>
        <item row="2" column="0">
-        <layout class="QHBoxLayout" name="horizontalLayout_3">
-         <item>
-          <widget class="QLabel" name="label_3">
-           <property name="text">
-            <string>Stylistic warnings:</string>
-           </property>
-          </widget>
-         </item>
-         <item>
-          <widget class="QLabel" name="mLblStyle">
-           <property name="text">
-            <string notr="true">TextLabel</string>
-           </property>
-          </widget>
-         </item>
-        </layout>
+        <widget class="QLabel" name="label_3">
+         <property name="text">
+          <string>Stylistic warnings:</string>
+         </property>
+         <property name="alignment">
+          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+         </property>
+        </widget>
+       </item>
+       <item row="2" column="1">
+        <widget class="QLabel" name="mLblStyle">
+         <property name="text">
+          <string notr="true">TextLabel</string>
+         </property>
+        </widget>
        </item>
        <item row="3" column="0">
-        <layout class="QHBoxLayout" name="horizontalLayout_8">
-         <item>
-          <widget class="QLabel" name="label_6">
-           <property name="text">
-            <string>Portability warnings:</string>
-           </property>
-          </widget>
-         </item>
-         <item>
-          <widget class="QLabel" name="mLblPortability">
-           <property name="text">
-            <string notr="true">TextLabel</string>
-           </property>
-          </widget>
-         </item>
-        </layout>
+        <widget class="QLabel" name="label_6">
+         <property name="text">
+          <string>Portability warnings:</string>
+         </property>
+         <property name="alignment">
+          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+         </property>
+        </widget>
+       </item>
+       <item row="3" column="1">
+        <widget class="QLabel" name="mLblPortability">
+         <property name="text">
+          <string notr="true">TextLabel</string>
+         </property>
+        </widget>
        </item>
        <item row="4" column="0">
-        <layout class="QHBoxLayout" name="horizontalLayout_4">
-         <item>
-          <widget class="QLabel" name="label_4">
-           <property name="text">
-            <string>Performance issues:</string>
-           </property>
-          </widget>
-         </item>
-         <item>
-          <widget class="QLabel" name="mLblPerformance">
-           <property name="text">
-            <string notr="true">TextLabel</string>
-           </property>
-          </widget>
-         </item>
-        </layout>
+        <widget class="QLabel" name="label_4">
+         <property name="text">
+          <string>Performance issues:</string>
+         </property>
+         <property name="alignment">
+          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+         </property>
+        </widget>
+       </item>
+       <item row="4" column="1">
+        <widget class="QLabel" name="mLblPerformance">
+         <property name="text">
+          <string notr="true">TextLabel</string>
+         </property>
+        </widget>
        </item>
        <item row="5" column="0">
-        <layout class="QHBoxLayout" name="horizontalLayout_6">
-         <item>
-          <widget class="QLabel" name="label_5">
-           <property name="text">
-            <string>Information messages:</string>
-           </property>
-          </widget>
-         </item>
-         <item>
-          <widget class="QLabel" name="mLblInformation">
-           <property name="text">
-            <string notr="true">TextLabel</string>
-           </property>
-          </widget>
-         </item>
-        </layout>
+        <widget class="QLabel" name="label_5">
+         <property name="text">
+          <string>Information messages:</string>
+         </property>
+         <property name="alignment">
+          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+         </property>
+        </widget>
+       </item>
+       <item row="5" column="1">
+        <widget class="QLabel" name="mLblInformation">
+         <property name="text">
+          <string notr="true">TextLabel</string>
+         </property>
+        </widget>
+       </item>
+       <item row="6" column="0">
+        <widget class="QLabel" name="label_7">
+         <property name="text">
+          <string>Active checkers:</string>
+         </property>
+         <property name="alignment">
+          <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+         </property>
+        </widget>
+       </item>
+       <item row="6" column="1">
+        <widget class="QLabel" name="mLblActiveCheckers">
+         <property name="text">
+          <string notr="true">TextLabel</string>
+         </property>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+     <widget class="QWidget" name="mCheckersTab">
+      <attribute name="title">
+       <string>Checkers</string>
+      </attribute>
+      <layout class="QVBoxLayout" name="verticalLayout_4">
+       <item>
+        <widget class="QPlainTextEdit" name="mCheckersReport">
+         <property name="enabled">
+          <bool>true</bool>
+         </property>
+         <property name="font">
+          <font>
+           <family>Courier 10 Pitch</family>
+          </font>
+         </property>
+         <property name="undoRedoEnabled">
+          <bool>true</bool>
+         </property>
+         <property name="readOnly">
+          <bool>true</bool>
+         </property>
+        </widget>
        </item>
       </layout>
      </widget>
diff --git a/gui/test/CMakeLists.txt b/gui/test/CMakeLists.txt
new file mode 100644
index 00000000000..b2e63c08f86
--- /dev/null
+++ b/gui/test/CMakeLists.txt
@@ -0,0 +1,8 @@
+add_custom_target(gui-tests)
+
+add_subdirectory(cppchecklibrarydata)
+add_subdirectory(filelist)
+add_subdirectory(projectfile)
+add_subdirectory(resultstree)
+add_subdirectory(translationhandler)
+add_subdirectory(xmlreportv2)
\ No newline at end of file
diff --git a/gui/test/benchmark/benchmark.pro b/gui/test/benchmark/benchmark.pro
deleted file mode 100644
index 0d3faf3ef33..00000000000
--- a/gui/test/benchmark/benchmark.pro
+++ /dev/null
@@ -1,4 +0,0 @@
-CONFIG  += ordered
-TEMPLATE = subdirs
-
-SUBDIRS = simple
diff --git a/gui/test/benchmark/simple/benchmarksimple.cpp b/gui/test/benchmark/simple/benchmarksimple.cpp
deleted file mode 100644
index f84fe168d89..00000000000
--- a/gui/test/benchmark/simple/benchmarksimple.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-/*
- * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <QObject>
-#include <QFile>
-#include <QString>
-#include <QByteArray>
-#include <sstream>
-#include "benchmarksimple.h"
-#include "tokenize.h"
-#include "token.h"
-#include "settings.h"
-#include "errorlogger.h"
-
-void BenchmarkSimple::tokenize()
-{
-    QFile file(QString(SRCDIR) + "/../../data/benchmark/simple.cpp");
-    QByteArray data = file.readAll();
-
-    Settings settings;
-    settings.debugwarnings = true;
-
-    // tokenize..
-    Tokenizer tokenizer(&settings, this);
-    std::istringstream istr(data.constData());
-    QBENCHMARK {
-        tokenizer.tokenize(istr, "test.cpp");
-    }
-}
-
-void BenchmarkSimple::simplify()
-{
-    QFile file(QString(SRCDIR) + "/../../data/benchmark/simple.cpp");
-    QByteArray data = file.readAll();
-
-    Settings settings;
-    settings.debugwarnings = true;
-
-    // tokenize..
-    Tokenizer tokenizer(&settings, this);
-    std::istringstream istr(data.constData());
-    tokenizer.tokenize(istr, "test.cpp");
-    QBENCHMARK {
-        tokenizer.simplifyTokenList2();
-    }
-}
-
-void BenchmarkSimple::tokenizeAndSimplify()
-{
-    QFile file(QString(SRCDIR) + "/../../data/benchmark/simple.cpp");
-    QByteArray data = file.readAll();
-
-    Settings settings;
-    settings.debugwarnings = true;
-
-    // tokenize..
-    Tokenizer tokenizer(&settings, this);
-    std::istringstream istr(data.constData());
-    QBENCHMARK {
-        tokenizer.tokenize(istr, "test.cpp");
-        tokenizer.simplifyTokenList2();
-    }
-}
-
-QTEST_MAIN(BenchmarkSimple)
diff --git a/gui/test/benchmark/simple/simple.pro b/gui/test/benchmark/simple/simple.pro
deleted file mode 100644
index ef25b2ce5e0..00000000000
--- a/gui/test/benchmark/simple/simple.pro
+++ /dev/null
@@ -1,15 +0,0 @@
-TEMPLATE = app
-TARGET = benchmark-simple
-DEPENDPATH += .
-INCLUDEPATH += .
-OBJECTS_DIR = ../../build
-MOC_DIR = ../../build
-
-include(../../common.pri)
-
-DEFINES += SRCDIR=\\\"$$PWD\\\"
-
-# tests
-SOURCES += benchmarksimple.cpp
-
-HEADERS += benchmarksimple.h
diff --git a/gui/test/common.pri b/gui/test/common.pri
deleted file mode 100644
index e6589d8ed09..00000000000
--- a/gui/test/common.pri
+++ /dev/null
@@ -1,12 +0,0 @@
-QT += testlib
-
-INCLUDEPATH += $${PWD}/.. \
-    $${PWD}/../../lib
-
-contains(QMAKE_CC, gcc) {
-    QMAKE_CXXFLAGS += -std=c++11
-}
-
-contains(QMAKE_CXX, clang++) {
-    QMAKE_CXXFLAGS += -std=c++11
-}
diff --git a/gui/test/cppchecklibrarydata/CMakeLists.txt b/gui/test/cppchecklibrarydata/CMakeLists.txt
new file mode 100644
index 00000000000..ea8f2b95097
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/CMakeLists.txt
@@ -0,0 +1,26 @@
+qt_wrap_cpp(test-cppchecklibrarydata_SRC testcppchecklibrarydata.h)
+QT_ADD_RESOURCES(test-cppchecklibrarydata_resources "resources.qrc")
+add_custom_target(build-cppchecklibrarydata-deps SOURCES ${test-cppchecklibrarydata_SRC} ${test-cppchecklibrarydata_resources})
+add_dependencies(gui-build-deps build-cppchecklibrarydata-deps)
+add_executable(test-cppchecklibrarydata
+        ${test-cppchecklibrarydata_SRC}
+        ${test-cppchecklibrarydata_resources}
+        testcppchecklibrarydata.cpp
+        ${CMAKE_SOURCE_DIR}/gui/cppchecklibrarydata.cpp
+        )
+target_include_directories(test-cppchecklibrarydata PRIVATE ${CMAKE_SOURCE_DIR}/lib ${CMAKE_SOURCE_DIR}/gui)
+target_compile_definitions(test-cppchecklibrarydata PRIVATE SRCDIR="${CMAKE_CURRENT_SOURCE_DIR}")
+target_link_libraries(test-cppchecklibrarydata ${QT_CORE_LIB} ${QT_TEST_LIB})
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    if(QT_VERSION VERSION_GREATER_EQUAL "6.9.0")
+        # caused by Qt generated moc code starting with 6.9.0 - see https://bugreports.qt.io/browse/QTBUG-135638
+        target_compile_options_safe(test-cppchecklibrarydata -Wno-ctad-maybe-unsupported)
+    endif()
+endif()
+
+if (REGISTER_GUI_TESTS)
+    add_test(NAME test-cppchecklibrarydata COMMAND $<TARGET_FILE:test-cppchecklibrarydata>)
+endif()
+
+add_dependencies(gui-tests test-cppchecklibrarydata)
\ No newline at end of file
diff --git a/gui/test/cppchecklibrarydata/files/container_unhandled_element.cfg b/gui/test/cppchecklibrarydata/files/container_unhandled_element.cfg
new file mode 100644
index 00000000000..3d142fea1b1
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/files/container_unhandled_element.cfg
@@ -0,0 +1,11 @@
+<?xml version="1.0"?>
+<def format="2">
+  <container id="stdStack" startPattern="std :: stack &lt;" inherits="stdContainer">
+    <!-- error: invalid element acess -->
+    <acess>
+      <function name="push" action="push"/>
+      <function name="pop" action="pop"/>
+      <function name="top" yields="item"/>
+    </access>
+  </container> 
+</def>
diff --git a/gui/test/cppchecklibrarydata/files/container_valid.cfg b/gui/test/cppchecklibrarydata/files/container_valid.cfg
new file mode 100644
index 00000000000..494821c9f77
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/files/container_valid.cfg
@@ -0,0 +1,9 @@
+<?xml version="1.0"?>
+<def format="2">  
+  <container id="stdMultiMap">
+    <rangeItemRecordType>
+      <member name="first" templateParameter="0"/>
+      <member name="second" templateParameter="1"/>
+    </rangeItemRecordType>
+  </container>
+</def>
diff --git a/gui/test/cppchecklibrarydata/files/define_valid.cfg b/gui/test/cppchecklibrarydata/files/define_valid.cfg
new file mode 100644
index 00000000000..c0cfda81043
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/files/define_valid.cfg
@@ -0,0 +1,5 @@
+<?xml version="1.0"?>
+<def format="2">
+  <define name="INT8_MIN" value="-128"/>
+  <define/>
+</def>
\ No newline at end of file
diff --git a/gui/test/cppchecklibrarydata/files/mandatory_attribute_missing.cfg b/gui/test/cppchecklibrarydata/files/mandatory_attribute_missing.cfg
new file mode 100644
index 00000000000..12601c935c7
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/files/mandatory_attribute_missing.cfg
@@ -0,0 +1,4 @@
+<?xml version="1.0"?>
+<def format="2">
+  <podtype sign="u" size="4" stdtype="uint32_t"/>
+</def>
\ No newline at end of file
diff --git a/gui/test/cppchecklibrarydata/files/markup_mandatory_attribute_missing.cfg b/gui/test/cppchecklibrarydata/files/markup_mandatory_attribute_missing.cfg
new file mode 100644
index 00000000000..f3a2ff4ddc0
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/files/markup_mandatory_attribute_missing.cfg
@@ -0,0 +1,6 @@
+<?xml version="1.0"?>
+<def format="2">
+  <!-- error: invalid attribute reporterror -->
+  <markup ext=".qml" reporterror="false" aftercode="true">
+  </markup>
+</def>
diff --git a/gui/test/cppchecklibrarydata/files/markup_unhandled_element.cfg b/gui/test/cppchecklibrarydata/files/markup_unhandled_element.cfg
new file mode 100644
index 00000000000..5bfb80c9bb6
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/files/markup_unhandled_element.cfg
@@ -0,0 +1,36 @@
+<?xml version="1.0"?>
+<def format="2">
+  <!-- Test data from qt.cfg -->
+  <markup ext=".qml" reporterrors="false" aftercode="true">
+    <keywords>
+      <keyword name="if"/>
+      <keyword name="while"/>
+      <keyword name="typeof"/>
+      <keyword name="for"/>
+    </keywords>
+    <codeblocks>
+      <block name="onClicked"/>
+      <block name="onFinished"/>
+      <block name="onTriggered"/>
+      <block name="onPressed"/>
+      <block name="onTouch"/>
+      <structure offset="3" start="{" end="}"/>
+    </codeblocks>
+    <codeblocks>
+      <block name="function"/>
+      <structure offset="2" start="{" end="}"/>
+    </codeblocks>
+	<!-- error: invalid element export -->
+    <export>
+      <exporter prefix="Q_PROPERTY">
+        <suffix>READ</suffix>
+        <prefix>READ</prefix>
+        <prefix>WRITE</prefix>
+        <prefix>NOTIFY</prefix>
+      </exporter>
+    </export>
+    <imported>
+      <importer>connect</importer>
+    </imported>
+  </markup>
+</def>
diff --git a/gui/test/cppchecklibrarydata/files/markup_valid.cfg b/gui/test/cppchecklibrarydata/files/markup_valid.cfg
new file mode 100644
index 00000000000..286c0c4f326
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/files/markup_valid.cfg
@@ -0,0 +1,35 @@
+<?xml version="1.0"?>
+<def format="2">
+  <!-- Test data from qt.cfg -->
+  <markup ext=".qml" reporterrors="false" aftercode="true">
+    <keywords>
+      <keyword name="if"/>
+      <keyword name="while"/>
+      <keyword name="typeof"/>
+      <keyword name="for"/>
+    </keywords>
+    <codeblocks>
+      <block name="onClicked"/>
+      <block name="onFinished"/>
+      <block name="onTriggered"/>
+      <block name="onPressed"/>
+      <block name="onTouch"/>
+      <structure offset="3" start="{" end="}"/>
+    </codeblocks>
+    <codeblocks>
+      <block name="function"/>
+      <structure offset="2" start="{" end="}"/>
+    </codeblocks>
+    <exported>
+      <exporter prefix="Q_PROPERTY">
+        <suffix>READ</suffix>
+        <prefix>READ</prefix>
+        <prefix>WRITE</prefix>
+        <prefix>NOTIFY</prefix>
+      </exporter>
+    </exported>
+    <imported>
+      <importer>connect</importer>
+    </imported>
+  </markup>
+</def>
diff --git a/gui/test/cppchecklibrarydata/files/memory_resource_unhandled_element.cfg b/gui/test/cppchecklibrarydata/files/memory_resource_unhandled_element.cfg
new file mode 100644
index 00000000000..9a197cdadc2
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/files/memory_resource_unhandled_element.cfg
@@ -0,0 +1,12 @@
+<?xml version="1.0"?>
+<def format="2">
+  <memory>
+    <alloc init="false" buffer-size="malloc">malloc</alloc>
+	<!-- error: invalid element aloc -->
+    <aloc init="true" buffer-size="calloc">calloc</alloc>
+    <alloc init="false" buffer-size="malloc:2">aligned_alloc</alloc>
+    <realloc init="false" buffer-size="malloc:2">realloc</realloc>
+    <realloc init="false" buffer-size="calloc:2,3">reallocarray</realloc>
+    <dealloc>free</dealloc>
+  </memory>
+</def>
diff --git a/gui/test/cppchecklibrarydata/files/memory_resource_valid.cfg b/gui/test/cppchecklibrarydata/files/memory_resource_valid.cfg
new file mode 100644
index 00000000000..3f59249c9c1
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/files/memory_resource_valid.cfg
@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+<def format="2">
+  <memory>	
+    <alloc init="false" buffer-size="malloc">malloc</alloc>
+    <alloc init="true" buffer-size="calloc">calloc</alloc>
+	<realloc init="false" buffer-size="malloc:2">realloc</realloc> 
+	<alloc arg="2">UuidToString</alloc>
+	<dealloc arg="3">HeapFree</dealloc>
+	<alloc init="false" no-fail="true" buffer-size="malloc">g_malloc</alloc>
+  </memory>
+
+  <resource>
+    <dealloc>fclose</dealloc>
+	<alloc init="true" arg="1">_wfopen_s</alloc>
+  </resource>
+</def>
diff --git a/gui/test/cppchecklibrarydata/files/platform_type_unhandled_element.cfg b/gui/test/cppchecklibrarydata/files/platform_type_unhandled_element.cfg
new file mode 100644
index 00000000000..b6b0245ce71
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/files/platform_type_unhandled_element.cfg
@@ -0,0 +1,8 @@
+<?xml version="1.0"?>
+<def format="2">
+  <platformtype name="unhandled element" value="">
+    <!-- error: invalid element ptr --> 
+	<ptr/>
+	<platform type="win32"/>	
+  </platformtype>
+</def>
diff --git a/gui/test/cppchecklibrarydata/files/platform_type_valid.cfg b/gui/test/cppchecklibrarydata/files/platform_type_valid.cfg
new file mode 100644
index 00000000000..ccbd51f5a94
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/files/platform_type_valid.cfg
@@ -0,0 +1,19 @@
+<?xml version="1.0"?>
+<def format="2">
+  <platformtype name="platform" value="with attribute and empty">
+    <platform type="win64"/>
+	<platform/>
+  </platformtype>
+  <platformtype name="types" value="all">
+    <unsigned/>
+    <long/>
+	<pointer/>
+	<const_ptr/>
+	<ptr_ptr/>
+  </platformtype> 
+  <platformtype name="types and platform" value="">        
+	<pointer/>
+	<platform type="win32"/>
+	<ptr_ptr/>
+  </platformtype>
+</def>
diff --git a/gui/test/cppchecklibrarydata/files/podtype_valid.cfg b/gui/test/cppchecklibrarydata/files/podtype_valid.cfg
new file mode 100644
index 00000000000..348c12aa9a8
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/files/podtype_valid.cfg
@@ -0,0 +1,5 @@
+<?xml version="1.0"?>
+<def format="2">
+  <podtype name="bool"/>
+  <podtype name="ulong" sign="u" size="4" stdtype="uint32_t"/>
+</def>
\ No newline at end of file
diff --git a/gui/test/cppchecklibrarydata/files/reflection_mandatory_attribute_missing.cfg b/gui/test/cppchecklibrarydata/files/reflection_mandatory_attribute_missing.cfg
new file mode 100644
index 00000000000..fd9019a4806
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/files/reflection_mandatory_attribute_missing.cfg
@@ -0,0 +1,6 @@
+<?xml version="1.0"?>
+<def format="2">
+  <reflection>
+    <call>invokeMethod</call>
+  </reflection>
+</def>
\ No newline at end of file
diff --git a/gui/test/cppchecklibrarydata/files/reflection_unhandled_element.cfg b/gui/test/cppchecklibrarydata/files/reflection_unhandled_element.cfg
new file mode 100644
index 00000000000..6827f83c992
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/files/reflection_unhandled_element.cfg
@@ -0,0 +1,7 @@
+<?xml version="1.0"?>
+<def format="2">
+  <reflection>
+    <!-- error: invalid element calls -->
+    <calls arg="2">invokeMethod</call>
+  </reflection>
+</def>
diff --git a/gui/test/cppchecklibrarydata/files/reflection_valid.cfg b/gui/test/cppchecklibrarydata/files/reflection_valid.cfg
new file mode 100644
index 00000000000..1eca6368fb6
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/files/reflection_valid.cfg
@@ -0,0 +1,8 @@
+<?xml version="1.0"?>
+<def format="2">
+  <reflection>
+    <call arg="2">invokeMethod</call>
+    <call arg="1">callFunction</call>
+  </reflection>
+  <reflection/>
+</def>
diff --git a/gui/test/cppchecklibrarydata/files/smartptr_valid.cfg b/gui/test/cppchecklibrarydata/files/smartptr_valid.cfg
new file mode 100644
index 00000000000..e0b9245cb03
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/files/smartptr_valid.cfg
@@ -0,0 +1,8 @@
+<?xml version="1.0"?>
+<def format="2">
+  <smart-pointer class-name="wxObjectDataPtr"/>
+  <smart-pointer class-name="wxScopedArray">
+    <unique/>
+  </smart-pointer>
+  <smart-pointer class-name="wxScopedPtr"/>
+</def>
\ No newline at end of file
diff --git a/gui/test/cppchecklibrarydata/files/typechecks_valid.cfg b/gui/test/cppchecklibrarydata/files/typechecks_valid.cfg
new file mode 100644
index 00000000000..42cc5e73645
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/files/typechecks_valid.cfg
@@ -0,0 +1,15 @@
+<?xml version="1.0"?>
+<def format="2">
+  <type-checks>
+    <unusedvar>
+      <suppress>std::insert_iterator</suppress>
+      <check>std::pair</check>
+    </unusedvar>
+  </type-checks>  
+  <type-checks/>
+  <type-checks>
+    <unusedvar>
+      <check>std::tuple</check>
+    </unusedvar>
+  </type-checks>
+</def>
diff --git a/gui/test/cppchecklibrarydata/files/undefine_valid.cfg b/gui/test/cppchecklibrarydata/files/undefine_valid.cfg
new file mode 100644
index 00000000000..62fb7f04de3
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/files/undefine_valid.cfg
@@ -0,0 +1,5 @@
+<?xml version="1.0"?>
+<def format="2">
+  <undefine name="INT8_MIN"/>
+  <undefine/>
+</def>
\ No newline at end of file
diff --git a/gui/test/cppchecklibrarydata/files/unhandled_element.cfg b/gui/test/cppchecklibrarydata/files/unhandled_element.cfg
new file mode 100644
index 00000000000..d9821227b56
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/files/unhandled_element.cfg
@@ -0,0 +1,5 @@
+<?xml version="1.0"?>
+<def format="2">
+  <!-- error: typo which should trigger unhandled element handler -->
+  <podtyp sign="u" size="4" stdtype="uint32_t"/>
+</def>
\ No newline at end of file
diff --git a/gui/test/cppchecklibrarydata/files/xml_reader_error.cfg b/gui/test/cppchecklibrarydata/files/xml_reader_error.cfg
new file mode 100644
index 00000000000..5c397386de2
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/files/xml_reader_error.cfg
@@ -0,0 +1,5 @@
+<?xml version="1.0"?>
+<def format="2">
+  <!-- error: redefinition of size attribute --> 
+  <podtype name="ulong" sign="u" size="4" size="4"/>
+</def>
\ No newline at end of file
diff --git a/gui/test/cppchecklibrarydata/resources.qrc b/gui/test/cppchecklibrarydata/resources.qrc
new file mode 100644
index 00000000000..57625f3b22b
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/resources.qrc
@@ -0,0 +1,24 @@
+<RCC>
+    <qresource prefix="/">
+        <file>files/xml_reader_error.cfg</file>
+        <file>files/mandatory_attribute_missing.cfg</file>
+        <file>files/unhandled_element.cfg</file>
+        <file>files/typechecks_valid.cfg</file>
+        <file>files/podtype_valid.cfg</file>
+        <file>files/smartptr_valid.cfg</file>
+        <file>files/platform_type_valid.cfg</file>
+        <file>files/platform_type_unhandled_element.cfg</file>
+        <file>files/memory_resource_unhandled_element.cfg</file>
+        <file>files/memory_resource_valid.cfg</file>
+        <file>files/define_valid.cfg</file>
+        <file>files/undefine_valid.cfg</file>
+        <file>files/container_unhandled_element.cfg</file>
+        <file>files/reflection_unhandled_element.cfg</file>
+        <file>files/reflection_valid.cfg</file>
+        <file>files/reflection_mandatory_attribute_missing.cfg</file>
+        <file>files/markup_mandatory_attribute_missing.cfg</file>
+        <file>files/markup_valid.cfg</file>
+        <file>files/markup_unhandled_element.cfg</file>
+        <file>files/container_valid.cfg</file>
+    </qresource>
+</RCC>
diff --git a/gui/test/cppchecklibrarydata/testcppchecklibrarydata.cpp b/gui/test/cppchecklibrarydata/testcppchecklibrarydata.cpp
new file mode 100644
index 00000000000..c747f1b5093
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/testcppchecklibrarydata.cpp
@@ -0,0 +1,651 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2021 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "testcppchecklibrarydata.h"
+
+#include <QDir>
+#include <QDebug>
+#include <QFile>
+#include <QIODevice>
+#include <QList>
+#include <QStringList>
+#include <QTextStream>
+#include <QtTest>
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 5, 0))
+#include <QtLogging>
+#endif
+
+const QString TestCppcheckLibraryData::TempCfgFile = "./tmp.cfg";
+
+void TestCppcheckLibraryData::init()
+{
+    result.clear();
+    libraryData.clear();
+    fileLibraryData.clear();
+}
+
+void TestCppcheckLibraryData::xmlReaderError()
+{
+    loadCfgFile(":/files/xml_reader_error.cfg", fileLibraryData, result);
+    QCOMPARE(result.isNull(), false);
+    qDebug() << result;
+}
+
+void TestCppcheckLibraryData::unhandledElement()
+{
+    loadCfgFile(":/files/unhandled_element.cfg", fileLibraryData, result);
+    QCOMPARE(result.isNull(), false);
+    qDebug() << result;
+
+    loadCfgFile(":/files/platform_type_unhandled_element.cfg", fileLibraryData, result);
+    QCOMPARE(result.isNull(), false);
+    qDebug() << result;
+
+    loadCfgFile(":/files/memory_resource_unhandled_element.cfg", fileLibraryData, result);
+    QCOMPARE(result.isNull(), false);
+    qDebug() << result;
+
+    loadCfgFile(":/files/container_unhandled_element.cfg", fileLibraryData, result);
+    QCOMPARE(result.isNull(), false);
+    qDebug() << result;
+
+    loadCfgFile(":/files/reflection_unhandled_element.cfg", fileLibraryData, result);
+    QCOMPARE(result.isNull(), false);
+    qDebug() << result;
+
+    loadCfgFile(":/files/markup_unhandled_element.cfg", fileLibraryData, result);
+    QCOMPARE(result.isNull(), false);
+    qDebug() << result;
+}
+
+void TestCppcheckLibraryData::mandatoryAttributeMissing()
+{
+    loadCfgFile(":/files/mandatory_attribute_missing.cfg", fileLibraryData, result);
+    QCOMPARE(result.isNull(), false);
+    qDebug() << result;
+
+    loadCfgFile(":/files/reflection_mandatory_attribute_missing.cfg", fileLibraryData, result);
+    QCOMPARE(result.isNull(), false);
+    qDebug() << result;
+
+    loadCfgFile(":/files/markup_mandatory_attribute_missing.cfg", fileLibraryData, result);
+    QCOMPARE(result.isNull(), false);
+    qDebug() << result;
+}
+
+void TestCppcheckLibraryData::podtypeValid()
+{
+    // Load library data from file
+    loadCfgFile(":/files/podtype_valid.cfg", fileLibraryData, result);
+    QCOMPARE(result.isNull(), true);
+
+    // Swap library data read from file to other object
+    libraryData.swap(fileLibraryData);
+
+    // Do size and content checks against swapped data.
+    QCOMPARE(libraryData.podtypes.size(), 2);
+
+    QCOMPARE(libraryData.podtypes[0].name, QString("bool"));
+    QCOMPARE(libraryData.podtypes[0].stdtype.isEmpty(), true);
+    QCOMPARE(libraryData.podtypes[0].sign.isEmpty(), true);
+    QCOMPARE(libraryData.podtypes[0].size.isEmpty(), true);
+
+    QCOMPARE(libraryData.podtypes[1].name, QString("ulong"));
+    QCOMPARE(libraryData.podtypes[1].stdtype, QString("uint32_t"));
+    QCOMPARE(libraryData.podtypes[1].sign, QString("u"));
+    QCOMPARE(libraryData.podtypes[1].size, QString("4"));
+
+    // Save library data to file
+    saveCfgFile(TempCfgFile, libraryData);
+
+    fileLibraryData.clear();
+    QCOMPARE(fileLibraryData.podtypes.size(), 0);
+
+    // Reload library data from file
+    loadCfgFile(TempCfgFile, fileLibraryData, result, true);
+    QCOMPARE(result.isNull(), true);
+
+    // Verify no data got lost or modified
+    QCOMPARE(libraryData.podtypes.size(), fileLibraryData.podtypes.size());
+    QCOMPARE(libraryData.podtypes.size(), 2);
+    for (int i=0; i < libraryData.podtypes.size(); i++) {
+        QCOMPARE(libraryData.podtypes[i].name, fileLibraryData.podtypes[i].name);
+        QCOMPARE(libraryData.podtypes[i].stdtype, fileLibraryData.podtypes[i].stdtype);
+        QCOMPARE(libraryData.podtypes[i].sign, fileLibraryData.podtypes[i].sign);
+        QCOMPARE(libraryData.podtypes[i].size, fileLibraryData.podtypes[i].size);
+    }
+}
+
+void TestCppcheckLibraryData::typechecksValid()
+{
+    // Load library data from file
+    loadCfgFile(":/files/typechecks_valid.cfg", fileLibraryData, result);
+    QCOMPARE(result.isNull(), true);
+
+    // Swap library data read from file to other object
+    libraryData.swap(fileLibraryData);
+
+    // Do size and content checks against swapped data.
+    QCOMPARE(libraryData.typeChecks.size(), 3);
+
+    CppcheckLibraryData::TypeChecks check = libraryData.typeChecks[0];
+    QCOMPARE(check.size(), 2);
+    QCOMPARE(check[0].first, QString("suppress"));
+    QCOMPARE(check[0].second, QString("std::insert_iterator"));
+    QCOMPARE(check[1].first, QString("check"));
+    QCOMPARE(check[1].second, QString("std::pair"));
+
+    check = libraryData.typeChecks[1];
+    QCOMPARE(check.isEmpty(), true);
+
+    check = libraryData.typeChecks[2];
+    QCOMPARE(check.size(), 1);
+    QCOMPARE(check[0].first, QString("check"));
+    QCOMPARE(check[0].second, QString("std::tuple"));
+
+    // Save library data to file
+    saveCfgFile(TempCfgFile, libraryData);
+
+    fileLibraryData.clear();
+    QCOMPARE(fileLibraryData.typeChecks.size(), 0);
+
+    // Reload library data from file
+    loadCfgFile(TempCfgFile, fileLibraryData, result, true);
+    QCOMPARE(result.isNull(), true);
+
+    // Verify no data got lost or modified
+    QCOMPARE(libraryData.typeChecks.size(), fileLibraryData.typeChecks.size());
+    QCOMPARE(libraryData.typeChecks.size(), 3);
+    for (int idx=0; idx < libraryData.typeChecks.size(); idx++) {
+        CppcheckLibraryData::TypeChecks lhs = libraryData.typeChecks[idx];
+        CppcheckLibraryData::TypeChecks rhs = fileLibraryData.typeChecks[idx];
+        QCOMPARE(lhs.size(), rhs.size());
+        QCOMPARE(lhs, rhs);
+    }
+}
+
+void TestCppcheckLibraryData::smartPointerValid()
+{
+    // Load library data from file
+    loadCfgFile(":/files/smartptr_valid.cfg", fileLibraryData, result);
+    QCOMPARE(result.isNull(), true);
+
+    // Swap library data read from file to other object
+    libraryData.swap(fileLibraryData);
+
+    // Do size and content checks against swapped data.
+    QCOMPARE(libraryData.smartPointers.size(), 3);
+
+    QCOMPARE(libraryData.smartPointers[0].name, QString("wxObjectDataPtr"));
+    QCOMPARE(libraryData.smartPointers[0].unique, false);
+    QCOMPARE(libraryData.smartPointers[1].name, QString("wxScopedArray"));
+    QCOMPARE(libraryData.smartPointers[1].unique, true);
+    QCOMPARE(libraryData.smartPointers[2].name, QString("wxScopedPtr"));
+    QCOMPARE(libraryData.smartPointers[2].unique, false);
+
+    // Save library data to file
+    saveCfgFile(TempCfgFile, libraryData);
+
+    fileLibraryData.clear();
+    QCOMPARE(fileLibraryData.smartPointers.size(), 0);
+
+    // Reload library data from file
+    loadCfgFile(TempCfgFile, fileLibraryData, result, true);
+    QCOMPARE(result.isNull(), true);
+
+    // Verify no data got lost or modified
+    QCOMPARE(libraryData.smartPointers.size(), fileLibraryData.smartPointers.size());
+    QCOMPARE(libraryData.smartPointers.size(), 3);
+    for (int idx=0; idx < libraryData.smartPointers.size(); idx++) {
+        QCOMPARE(libraryData.smartPointers[idx].name, fileLibraryData.smartPointers[idx].name);
+        QCOMPARE(libraryData.smartPointers[idx].unique, fileLibraryData.smartPointers[idx].unique);
+    }
+}
+
+void TestCppcheckLibraryData::platformTypeValid()
+{
+    // Load library data from file
+    loadCfgFile(":/files/platform_type_valid.cfg", fileLibraryData, result);
+    QCOMPARE(result.isNull(), true);
+
+    // Swap library data read from file to other object
+    libraryData.swap(fileLibraryData);
+
+    // Do size and content checks against swapped data.
+    QCOMPARE(libraryData.platformTypes.size(), 3);
+
+    QCOMPARE(libraryData.platformTypes[0].name, QString("platform"));
+    QCOMPARE(libraryData.platformTypes[0].value, QString("with attribute and empty"));
+    QCOMPARE(libraryData.platformTypes[0].types.size(), 0);
+    QCOMPARE(libraryData.platformTypes[0].platforms.size(), 2);
+    QCOMPARE(libraryData.platformTypes[0].platforms[0], QString("win64"));
+    QCOMPARE(libraryData.platformTypes[0].platforms[1].isEmpty(), true);
+
+    QCOMPARE(libraryData.platformTypes[1].name, QString("types"));
+    QCOMPARE(libraryData.platformTypes[1].value, QString("all"));
+    QCOMPARE(libraryData.platformTypes[1].types.size(), 5);
+    QCOMPARE(libraryData.platformTypes[1].types,
+             QStringList({"unsigned", "long", "pointer", "const_ptr", "ptr_ptr"}));
+    QCOMPARE(libraryData.platformTypes[1].platforms.isEmpty(), true);
+
+    QCOMPARE(libraryData.platformTypes[2].name, QString("types and platform"));
+    QCOMPARE(libraryData.platformTypes[2].value.isEmpty(), true);
+    QCOMPARE(libraryData.platformTypes[2].types.size(), 2);
+    QCOMPARE(libraryData.platformTypes[2].types, QStringList({"pointer", "ptr_ptr"}));
+    QCOMPARE(libraryData.platformTypes[2].platforms.size(), 1);
+    QCOMPARE(libraryData.platformTypes[2].platforms[0], QString("win32"));
+
+    // Save library data to file
+    saveCfgFile(TempCfgFile, libraryData);
+
+    fileLibraryData.clear();
+    QCOMPARE(fileLibraryData.platformTypes.size(), 0);
+
+    // Reload library data from file
+    loadCfgFile(TempCfgFile, fileLibraryData, result, true);
+    QCOMPARE(result.isNull(), true);
+
+    // Verify no data got lost or modified
+    QCOMPARE(libraryData.platformTypes.size(), fileLibraryData.platformTypes.size());
+    QCOMPARE(libraryData.platformTypes.size(), 3);
+    for (int idx=0; idx < libraryData.platformTypes.size(); idx++) {
+        CppcheckLibraryData::PlatformType lhs = libraryData.platformTypes[idx];
+        CppcheckLibraryData::PlatformType rhs = fileLibraryData.platformTypes[idx];
+        QCOMPARE(lhs.name, rhs.name);
+        QCOMPARE(lhs.value, rhs.value);
+        QCOMPARE(lhs.types.size(), rhs.types.size());
+        QCOMPARE(lhs.types, rhs.types);
+        QCOMPARE(lhs.platforms.size(), rhs.platforms.size());
+        QCOMPARE(lhs.platforms, rhs.platforms);
+    }
+}
+
+void TestCppcheckLibraryData::memoryResourceValid()
+{
+    // Load library data from file
+    loadCfgFile(":/files/memory_resource_valid.cfg", fileLibraryData, result);
+    QCOMPARE(result.isNull(), true);
+
+    // Swap library data read from file to other object
+    libraryData.swap(fileLibraryData);
+
+    // Do size and content checks against swapped data.
+    QCOMPARE(libraryData.memoryresource.size(), 2);
+    QCOMPARE(libraryData.memoryresource[0].type, QString("memory"));
+    QCOMPARE(libraryData.memoryresource[0].alloc.size(), 5);
+    QCOMPARE(libraryData.memoryresource[0].dealloc.size(), 1);
+    QCOMPARE(libraryData.memoryresource[0].use.size(), 0);
+
+    QCOMPARE(libraryData.memoryresource[0].alloc[0].name, QString("malloc"));
+    QCOMPARE(libraryData.memoryresource[0].alloc[0].bufferSize, QString("malloc"));
+    QCOMPARE(libraryData.memoryresource[0].alloc[0].isRealloc, false);
+    QCOMPARE(libraryData.memoryresource[0].alloc[0].init, false);
+    QCOMPARE(libraryData.memoryresource[0].alloc[0].noFail, false);
+    QCOMPARE(libraryData.memoryresource[0].alloc[0].arg, -1);
+    QCOMPARE(libraryData.memoryresource[0].alloc[0].reallocArg, -1);
+
+    QCOMPARE(libraryData.memoryresource[0].alloc[1].name, QString("calloc"));
+    QCOMPARE(libraryData.memoryresource[0].alloc[1].bufferSize, QString("calloc"));
+    QCOMPARE(libraryData.memoryresource[0].alloc[1].isRealloc, false);
+    QCOMPARE(libraryData.memoryresource[0].alloc[1].init, true);
+    QCOMPARE(libraryData.memoryresource[0].alloc[1].noFail, false);
+    QCOMPARE(libraryData.memoryresource[0].alloc[1].arg, -1);
+    QCOMPARE(libraryData.memoryresource[0].alloc[1].reallocArg, -1);
+
+    QCOMPARE(libraryData.memoryresource[0].alloc[2].name, QString("realloc"));
+    QCOMPARE(libraryData.memoryresource[0].alloc[2].bufferSize, QString("malloc:2"));
+    QCOMPARE(libraryData.memoryresource[0].alloc[2].isRealloc, true);
+    QCOMPARE(libraryData.memoryresource[0].alloc[2].init, false);
+    QCOMPARE(libraryData.memoryresource[0].alloc[2].noFail, false);
+    QCOMPARE(libraryData.memoryresource[0].alloc[2].arg, -1);
+    QCOMPARE(libraryData.memoryresource[0].alloc[2].reallocArg, -1);
+
+    QCOMPARE(libraryData.memoryresource[0].alloc[3].name, QString("UuidToString"));
+    QCOMPARE(libraryData.memoryresource[0].alloc[3].bufferSize.isEmpty(), true);
+    QCOMPARE(libraryData.memoryresource[0].alloc[3].isRealloc, false);
+    QCOMPARE(libraryData.memoryresource[0].alloc[3].init, false);
+    QCOMPARE(libraryData.memoryresource[0].alloc[3].noFail, false);
+    QCOMPARE(libraryData.memoryresource[0].alloc[3].arg, 2);
+    QCOMPARE(libraryData.memoryresource[0].alloc[3].reallocArg, -1);
+
+    QCOMPARE(libraryData.memoryresource[0].alloc[4].name, QString("g_malloc"));
+    QCOMPARE(libraryData.memoryresource[0].alloc[4].bufferSize, QString("malloc"));
+    QCOMPARE(libraryData.memoryresource[0].alloc[4].isRealloc, false);
+    QCOMPARE(libraryData.memoryresource[0].alloc[4].init, false);
+    QCOMPARE(libraryData.memoryresource[0].alloc[4].noFail, true);
+    QCOMPARE(libraryData.memoryresource[0].alloc[4].arg, -1);
+    QCOMPARE(libraryData.memoryresource[0].alloc[4].reallocArg, -1);
+
+    QCOMPARE(libraryData.memoryresource[0].dealloc[0].name, QString("HeapFree"));
+    QCOMPARE(libraryData.memoryresource[0].dealloc[0].arg, 3);
+
+    QCOMPARE(libraryData.memoryresource[1].type, QString("resource"));
+    QCOMPARE(libraryData.memoryresource[1].alloc.size(), 1);
+    QCOMPARE(libraryData.memoryresource[1].dealloc.size(), 1);
+    QCOMPARE(libraryData.memoryresource[1].use.size(), 0);
+
+    QCOMPARE(libraryData.memoryresource[1].alloc[0].name, QString("_wfopen_s"));
+    QCOMPARE(libraryData.memoryresource[1].alloc[0].bufferSize.isEmpty(), true);
+    QCOMPARE(libraryData.memoryresource[1].alloc[0].isRealloc, false);
+    QCOMPARE(libraryData.memoryresource[1].alloc[0].init, true);
+    QCOMPARE(libraryData.memoryresource[1].alloc[0].noFail, false);
+    QCOMPARE(libraryData.memoryresource[1].alloc[0].arg, 1);
+    QCOMPARE(libraryData.memoryresource[1].alloc[0].reallocArg, -1);
+
+    QCOMPARE(libraryData.memoryresource[1].dealloc[0].name, QString("fclose"));
+    QCOMPARE(libraryData.memoryresource[1].dealloc[0].arg, -1);
+
+    // Save library data to file
+    saveCfgFile(TempCfgFile, libraryData);
+
+    fileLibraryData.clear();
+    QCOMPARE(fileLibraryData.memoryresource.size(), 0);
+
+    // Reload library data from file
+    loadCfgFile(TempCfgFile, fileLibraryData, result, true);
+    QCOMPARE(result.isNull(), true);
+
+    // Verify no data got lost or modified
+    QCOMPARE(libraryData.memoryresource.size(), fileLibraryData.memoryresource.size());
+    QCOMPARE(libraryData.memoryresource.size(), 2);
+
+    for (int idx=0; idx < libraryData.memoryresource.size(); idx++) {
+        CppcheckLibraryData::MemoryResource lhs = libraryData.memoryresource[idx];
+        CppcheckLibraryData::MemoryResource rhs = fileLibraryData.memoryresource[idx];
+
+        QCOMPARE(lhs.type, rhs.type);
+        QCOMPARE(lhs.alloc.size(), rhs.alloc.size());
+        QCOMPARE(lhs.dealloc.size(), rhs.dealloc.size());
+        QCOMPARE(lhs.use, rhs.use);
+
+        for (int num=0; num < lhs.alloc.size(); num++) {
+            QCOMPARE(lhs.alloc[num].name, rhs.alloc[num].name);
+            QCOMPARE(lhs.alloc[num].bufferSize, rhs.alloc[num].bufferSize);
+            QCOMPARE(lhs.alloc[num].isRealloc, rhs.alloc[num].isRealloc);
+            QCOMPARE(lhs.alloc[num].init, rhs.alloc[num].init);
+            QCOMPARE(lhs.alloc[num].noFail, rhs.alloc[num].noFail);
+            QCOMPARE(lhs.alloc[num].arg, rhs.alloc[num].arg);
+            QCOMPARE(lhs.alloc[num].reallocArg, rhs.alloc[num].reallocArg);
+        }
+        for (int num=0; num < lhs.dealloc.size(); num++) {
+            QCOMPARE(lhs.dealloc[num].name, rhs.dealloc[num].name);
+            QCOMPARE(lhs.dealloc[num].arg, rhs.dealloc[num].arg);
+        }
+    }
+}
+
+void TestCppcheckLibraryData::defineValid()
+{
+    // Load library data from file
+    loadCfgFile(":/files/define_valid.cfg", fileLibraryData, result);
+    QCOMPARE(result.isNull(), true);
+
+    // Swap library data read from file to other object
+    libraryData.swap(fileLibraryData);
+
+    // Do size and content checks against swapped data.
+    QCOMPARE(libraryData.defines.size(), 2);
+    QCOMPARE(libraryData.defines[0].name, QString("INT8_MIN"));
+    QCOMPARE(libraryData.defines[0].value, QString("-128"));
+    QCOMPARE(libraryData.defines[1].name.isEmpty(), true);
+    QCOMPARE(libraryData.defines[1].value.isEmpty(), true);
+
+    // Save library data to file
+    saveCfgFile(TempCfgFile, libraryData);
+
+    fileLibraryData.clear();
+    QCOMPARE(fileLibraryData.defines.size(), 0);
+
+    // Reload library data from file
+    loadCfgFile(TempCfgFile, fileLibraryData, result, true);
+    QCOMPARE(result.isNull(), true);
+
+    // Verify no data got lost or modified
+    QCOMPARE(libraryData.defines.size(), fileLibraryData.defines.size());
+    QCOMPARE(libraryData.defines.size(), 2);
+    for (int idx=0; idx < libraryData.defines.size(); idx++) {
+        QCOMPARE(libraryData.defines[idx].name, fileLibraryData.defines[idx].name);
+        QCOMPARE(libraryData.defines[idx].value, fileLibraryData.defines[idx].value);
+    }
+}
+
+void TestCppcheckLibraryData::undefineValid()
+{
+    // Load library data from file
+    loadCfgFile(":/files/undefine_valid.cfg", fileLibraryData, result);
+    QCOMPARE(result.isNull(), true);
+
+    // Swap library data read from file to other object
+    libraryData.swap(fileLibraryData);
+
+    // Do size and content checks against swapped data.
+    QCOMPARE(libraryData.undefines.size(), 2);
+    QCOMPARE(libraryData.undefines[0], QString("INT8_MIN"));
+    QCOMPARE(libraryData.undefines[1].isEmpty(), true);
+
+    // Save library data to file
+    saveCfgFile(TempCfgFile, libraryData);
+
+    fileLibraryData.clear();
+    QCOMPARE(fileLibraryData.undefines.size(), 0);
+
+    // Reload library data from file
+    loadCfgFile(TempCfgFile, fileLibraryData, result, true);
+    QCOMPARE(result.isNull(), true);
+
+    // Verify no data got lost or modified
+    QCOMPARE(libraryData.undefines.size(), fileLibraryData.undefines.size());
+    QCOMPARE(libraryData.undefines.size(), 2);
+    QCOMPARE(libraryData.undefines, fileLibraryData.undefines);
+}
+
+void TestCppcheckLibraryData::reflectionValid()
+{
+    // Load library data from file
+    loadCfgFile(":/files/reflection_valid.cfg", fileLibraryData, result);
+    QCOMPARE(result.isNull(), true);
+
+    // Swap library data read from file to other object
+    libraryData.swap(fileLibraryData);
+
+    // Do size and content checks against swapped data.
+    QCOMPARE(libraryData.reflections.size(), 2);
+    QCOMPARE(libraryData.reflections[0].calls.size(), 2);
+    QCOMPARE(libraryData.reflections[0].calls[0].arg, 2);
+    QCOMPARE(libraryData.reflections[0].calls[0].name, QString("invokeMethod"));
+    QCOMPARE(libraryData.reflections[0].calls[1].arg, 1);
+    QCOMPARE(libraryData.reflections[0].calls[1].name, QString("callFunction"));
+    QCOMPARE(libraryData.reflections[1].calls.isEmpty(), true);
+
+    // Save library data to file
+    saveCfgFile(TempCfgFile, libraryData);
+
+    fileLibraryData.clear();
+    QCOMPARE(fileLibraryData.reflections.size(), 0);
+
+    // Reload library data from file
+    loadCfgFile(TempCfgFile, fileLibraryData, result, true);
+    QCOMPARE(result.isNull(), true);
+
+    // Verify no data got lost or modified
+    QCOMPARE(libraryData.reflections.size(), fileLibraryData.reflections.size());
+    QCOMPARE(libraryData.reflections.size(), 2);
+    for (int idx=0; idx < libraryData.reflections.size(); idx++) {
+        CppcheckLibraryData::Reflection lhs = libraryData.reflections[idx];
+        CppcheckLibraryData::Reflection rhs = fileLibraryData.reflections[idx];
+
+        QCOMPARE(lhs.calls.size(), rhs.calls.size());
+        for (int num=0; num < lhs.calls.size(); num++) {
+            QCOMPARE(lhs.calls[num].arg, rhs.calls[num].arg);
+            QCOMPARE(lhs.calls[num].name, rhs.calls[num].name);
+        }
+    }
+}
+
+void TestCppcheckLibraryData::markupValid()
+{
+    // Load library data from file
+    loadCfgFile(":/files/markup_valid.cfg", fileLibraryData, result);
+    QCOMPARE(result.isNull(), true);
+
+    // Swap library data read from file to other object
+    libraryData.swap(fileLibraryData);
+
+    // Do size and content checks against swapped data.
+    QCOMPARE(libraryData.markups.size(), 1);
+    QCOMPARE(libraryData.markups[0].ext, QString(".qml"));
+    QCOMPARE(libraryData.markups[0].reportErrors, false);
+    QCOMPARE(libraryData.markups[0].afterCode, true);
+
+    QCOMPARE(libraryData.markups[0].keywords.size(), 4);
+    QCOMPARE(libraryData.markups[0].keywords, QStringList({"if", "while", "typeof", "for"}));
+
+    QCOMPARE(libraryData.markups[0].importer.size(), 1);
+    QCOMPARE(libraryData.markups[0].importer, QStringList("connect"));
+
+    QCOMPARE(libraryData.markups[0].exporter.size(), 1);
+    QCOMPARE(libraryData.markups[0].exporter[0].prefix, QString("Q_PROPERTY"));
+    QCOMPARE(libraryData.markups[0].exporter[0].suffixList.size(), 1);
+    QCOMPARE(libraryData.markups[0].exporter[0].suffixList, QStringList("READ"));
+    QCOMPARE(libraryData.markups[0].exporter[0].prefixList.size(), 3);
+    QCOMPARE(libraryData.markups[0].exporter[0].prefixList, QStringList({"READ", "WRITE", "NOTIFY"}));
+
+    QCOMPARE(libraryData.markups[0].codeBlocks.size(), 2);
+    QCOMPARE(libraryData.markups[0].codeBlocks[0].blocks.size(), 5);
+    QCOMPARE(libraryData.markups[0].codeBlocks[0].blocks, QStringList({"onClicked", "onFinished", "onTriggered", "onPressed", "onTouch"}));
+    QCOMPARE(libraryData.markups[0].codeBlocks[0].offset, 3);
+    QCOMPARE(libraryData.markups[0].codeBlocks[0].start, QString("{"));
+    QCOMPARE(libraryData.markups[0].codeBlocks[0].end, QString("}"));
+    QCOMPARE(libraryData.markups[0].codeBlocks[1].blocks.size(), 1);
+    QCOMPARE(libraryData.markups[0].codeBlocks[1].blocks, QStringList("function"));
+    QCOMPARE(libraryData.markups[0].codeBlocks[1].offset, 2);
+    QCOMPARE(libraryData.markups[0].codeBlocks[1].start, QString("{"));
+    QCOMPARE(libraryData.markups[0].codeBlocks[1].end, QString("}"));
+
+    // Save library data to file
+    saveCfgFile(TempCfgFile, libraryData);
+
+    fileLibraryData.clear();
+    QCOMPARE(fileLibraryData.markups.size(), 0);
+
+    // Reload library data from file
+    loadCfgFile(TempCfgFile, fileLibraryData, result, true);
+    QCOMPARE(result.isNull(), true);
+
+    // Verify no data got lost or modified
+    QCOMPARE(libraryData.markups.size(), fileLibraryData.markups.size());
+    for (int idx=0; idx < libraryData.markups.size(); idx++) {
+        CppcheckLibraryData::Markup lhs = libraryData.markups[idx];
+        CppcheckLibraryData::Markup rhs = fileLibraryData.markups[idx];
+
+        QCOMPARE(lhs.ext, rhs.ext);
+        QCOMPARE(lhs.reportErrors, rhs.reportErrors);
+        QCOMPARE(lhs.afterCode, rhs.afterCode);
+        QCOMPARE(lhs.keywords, rhs.keywords);
+        QCOMPARE(lhs.importer, rhs.importer);
+        for (int num=0; num < lhs.exporter.size(); num++) {
+            QCOMPARE(lhs.exporter[num].prefix, rhs.exporter[num].prefix);
+            QCOMPARE(lhs.exporter[num].suffixList, rhs.exporter[num].suffixList);
+            QCOMPARE(lhs.exporter[num].prefixList, rhs.exporter[num].prefixList);
+        }
+        for (int num=0; num < lhs.codeBlocks.size(); num++) {
+            QCOMPARE(lhs.codeBlocks[num].blocks, rhs.codeBlocks[num].blocks);
+            QCOMPARE(lhs.codeBlocks[num].offset, rhs.codeBlocks[num].offset);
+            QCOMPARE(lhs.codeBlocks[num].start, rhs.codeBlocks[num].start);
+            QCOMPARE(lhs.codeBlocks[num].end, rhs.codeBlocks[num].end);
+        }
+    }
+}
+
+void TestCppcheckLibraryData::containerValid()
+{
+    // Load library data from file
+    loadCfgFile(":/files/container_valid.cfg", fileLibraryData, result);
+    QCOMPARE(result.isNull(), true);
+
+    // Swap library data read from file to other object
+    libraryData.swap(fileLibraryData);
+
+    // Do size and content checks against swapped data.
+    QCOMPARE(libraryData.containers.size(), 1);
+
+    QCOMPARE(libraryData.containers[0].rangeItemRecordTypeList.size(), 2);
+    QCOMPARE(libraryData.containers[0].rangeItemRecordTypeList[0].name, QString("first"));
+    QCOMPARE(libraryData.containers[0].rangeItemRecordTypeList[0].templateParameter, QString("0"));
+    QCOMPARE(libraryData.containers[0].rangeItemRecordTypeList[1].name, QString("second"));
+    QCOMPARE(libraryData.containers[0].rangeItemRecordTypeList[1].templateParameter, QString("1"));
+
+    // Save library data to file
+    saveCfgFile(TempCfgFile, libraryData);
+
+    fileLibraryData.clear();
+    QCOMPARE(fileLibraryData.containers.size(), 0);
+
+    // Reload library data from file
+    loadCfgFile(TempCfgFile, fileLibraryData, result, true);
+    QCOMPARE(result.isNull(), true);
+
+    // Verify no data got lost or modified
+    QCOMPARE(libraryData.containers.size(), fileLibraryData.containers.size());
+    for (int idx=0; idx < libraryData.containers.size(); idx++) {
+        CppcheckLibraryData::Container lhs = libraryData.containers[idx];
+        CppcheckLibraryData::Container rhs = fileLibraryData.containers[idx];
+        for (int num=0; num < lhs.rangeItemRecordTypeList.size(); num++) {
+            QCOMPARE(lhs.rangeItemRecordTypeList[num].name, rhs.rangeItemRecordTypeList[num].name);
+            QCOMPARE(lhs.rangeItemRecordTypeList[num].templateParameter, rhs.rangeItemRecordTypeList[num].templateParameter);
+        }
+    }
+}
+
+void TestCppcheckLibraryData::loadCfgFile(const QString &filename, CppcheckLibraryData &data, QString &res, bool removeFile)
+{
+    QFile file(filename);
+    QVERIFY(file.open(QIODevice::ReadOnly | QIODevice::Text));
+    res = data.open(file);
+    file.close();
+    if (removeFile) {
+        file.remove();
+    }
+}
+
+void TestCppcheckLibraryData::saveCfgFile(const QString &filename, CppcheckLibraryData &data)
+{
+    QFile file(filename);
+    QVERIFY(file.open(QIODevice::WriteOnly | QIODevice::Text));
+    QTextStream textStream(&file);
+    textStream << data.toString() << '\n';
+    file.close();
+}
+
+void TestCppcheckLibraryData::validateAllCfg()
+{
+    const QDir dir(QString(SRCDIR) + "/../../../cfg/");
+    const QStringList files = dir.entryList(QStringList() << "*.cfg",QDir::Files);
+    QVERIFY(!files.empty());
+    bool error = false;
+    for (const QString& f : files) {
+        loadCfgFile(dir.absolutePath() + "/" + f, fileLibraryData, result);
+        if (!result.isNull()) {
+            error = true;
+            qDebug() << f << " - " << result;
+        }
+    }
+    QCOMPARE(error, false);
+}
+
+QTEST_MAIN(TestCppcheckLibraryData)
diff --git a/gui/test/cppchecklibrarydata/testcppchecklibrarydata.h b/gui/test/cppchecklibrarydata/testcppchecklibrarydata.h
new file mode 100644
index 00000000000..625ad4046a9
--- /dev/null
+++ b/gui/test/cppchecklibrarydata/testcppchecklibrarydata.h
@@ -0,0 +1,60 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2021 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "cppchecklibrarydata.h"
+
+#include <QObject>
+#include <QString>
+
+class TestCppcheckLibraryData : public QObject {
+    Q_OBJECT
+
+private slots:
+    void init();
+
+    void xmlReaderError();
+    void unhandledElement();
+    void mandatoryAttributeMissing();
+
+    void podtypeValid();
+    void typechecksValid();
+    void smartPointerValid();
+    void platformTypeValid();
+    void memoryResourceValid();
+    void defineValid();
+    void undefineValid();
+    void reflectionValid();
+    void markupValid();
+    void containerValid();
+
+    void validateAllCfg();
+
+private:
+    static void loadCfgFile(const QString &filename, CppcheckLibraryData &data, QString &res, bool removeFile = false);
+    static void saveCfgFile(const QString &filename, CppcheckLibraryData &data);
+
+    // cppcheck-suppress naming-privateMemberVariable - TODO: fix this
+    CppcheckLibraryData libraryData;
+    // cppcheck-suppress naming-privateMemberVariable - TODO: fix this
+    CppcheckLibraryData fileLibraryData;
+    // cppcheck-suppress naming-privateMemberVariable - TODO: fix this
+    QString result;
+
+    // cppcheck-suppress naming-privateMemberVariable - TODO: fix this
+    static const QString TempCfgFile;
+};
diff --git a/gui/test/data/benchmark/simple.cpp b/gui/test/data/benchmark/simple.cpp
deleted file mode 100644
index fda0a38ef21..00000000000
--- a/gui/test/data/benchmark/simple.cpp
+++ /dev/null
@@ -1,3512 +0,0 @@
-/*
- * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-//---------------------------------------------------------------------------
-// Remove includes from the benchmark run
-// Included files aren't found anyway
-//#include "checkother.h"
-//#include "mathlib.h"
-//#include "symboldatabase.h"
-
-//#include <cctype> // std::isupper
-//#include <cmath> // fabs()
-//#include <stack>
-//---------------------------------------------------------------------------
-
-// Register this check class (by creating a static instance of it)
-namespace {
-    CheckOther instance;
-}
-
-//---------------------------------------------------------------------------
-
-void CheckOther::checkIncrementBoolean()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "%var% ++")) {
-            if (tok->varId()) {
-                const Token *declTok = Token::findmatch(_tokenizer->tokens(), "bool %varid%", tok->varId());
-                if (declTok)
-                    incrementBooleanError(tok);
-            }
-        }
-    }
-}
-
-void CheckOther::incrementBooleanError(const Token *tok)
-{
-    reportError(
-        tok,
-        Severity::style,
-        "incrementboolean",
-        "The use of a variable of type bool with the ++ postfix operator is always true and deprecated by the C++ Standard.\n"
-        "The operand of a postfix increment operator may be of type bool but it is deprecated by C++ Standard (Annex D-1) and the operand is always set to true\n"
-    );
-}
-
-//---------------------------------------------------------------------------
-
-
-void CheckOther::clarifyCalculation()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        if (tok->strAt(1) == "?") {
-            // condition
-            const Token *cond = tok;
-            if (cond->isName() || cond->isNumber())
-                cond = cond->previous();
-            else if (cond->str() == ")")
-                cond = cond->link()->previous();
-            else
-                continue;
-
-            // calculation
-            if (!cond->isArithmeticalOp())
-                continue;
-
-            const std::string &op = cond->str();
-            cond = cond->previous();
-
-            // skip previous multiplications..
-            while (cond && cond->strAt(-1) == "*" && (cond->isName() || cond->isNumber()))
-                cond = cond->tokAt(-2);
-
-            if (!cond)
-                continue;
-
-            // first multiplication operand
-            if (cond->str() == ")") {
-                clarifyCalculationError(cond, op);
-            } else if (cond->isName() || cond->isNumber()) {
-                if (Token::Match(cond->previous(),("return|=|+|-|,|(|"+op).c_str()))
-                    clarifyCalculationError(cond, op);
-            }
-        }
-    }
-}
-
-void CheckOther::clarifyCalculationError(const Token *tok, const std::string &op)
-{
-    // suspicious calculation
-    const std::string calc("'a" + op + "b?c:d'");
-
-    // recommended calculation #1
-    const std::string s1("'(a" + op + "b)?c:d'");
-
-    // recommended calculation #2
-    const std::string s2("'a" + op + "(b?c:d)'");
-
-    reportError(tok,
-                Severity::style,
-                "clarifyCalculation",
-                "Clarify calculation precedence for " + op + " and ?\n"
-                "Suspicious calculation. Please use parentheses to clarify the code. "
-                "The code " + calc + " should be written as either " + s1 + " or " + s2 + ".");
-}
-
-
-// Clarify condition '(x = a < 0)' into '((x = a) < 0)' or '(x = (a < 0))'
-void CheckOther::clarifyCondition()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "( %var% =")) {
-            for (const Token *tok2 = tok->tokAt(2); tok2; tok2 = tok2->next()) {
-                if (tok2->str() == "(" || tok2->str() == "[")
-                    tok2 = tok2->link();
-                else if (Token::Match(tok2, "&&|%oror%|?|)"))
-                    break;
-                else if (Token::Match(tok2, "<|<=|==|!=|>|>= %num% )")) {
-                    clarifyConditionError(tok);
-                    break;
-                }
-            }
-        }
-    }
-}
-
-void CheckOther::clarifyConditionError(const Token *tok)
-{
-    reportError(tok,
-                Severity::style,
-                "clarifyCondition",
-                "Suspicious condition (assignment+comparison), it can be clarified with parentheses");
-}
-
-
-
-void CheckOther::warningOldStylePointerCast()
-{
-    if (!_settings->isEnabled("style") ||
-        (_tokenizer->tokens() && _tokenizer->fileLine(_tokenizer->tokens()).find(".cpp") == std::string::npos))
-        return;
-
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        // Old style pointer casting..
-        if (!Token::Match(tok, "( const| %type% * ) %var%") &&
-            !Token::Match(tok, "( const| %type% * ) (| new"))
-            continue;
-
-        int addToIndex = 0;
-        if (tok->tokAt(1)->str() == "const")
-            addToIndex = 1;
-
-        if (tok->tokAt(4 + addToIndex)->str() == "const")
-            continue;
-
-        // Is "type" a class?
-        const std::string pattern("class " + tok->tokAt(1 + addToIndex)->str());
-        if (!Token::findmatch(_tokenizer->tokens(), pattern.c_str()))
-            continue;
-
-        cstyleCastError(tok);
-    }
-}
-
-//---------------------------------------------------------------------------
-// fflush(stdin) <- fflush only applies to output streams in ANSI C
-//---------------------------------------------------------------------------
-void CheckOther::checkFflushOnInputStream()
-{
-    const Token *tok = _tokenizer->tokens();
-    while (tok && ((tok = Token::findsimplematch(tok, "fflush ( stdin )")) != NULL)) {
-        fflushOnInputStreamError(tok, tok->strAt(2));
-        tok = tok->tokAt(4);
-    }
-}
-
-void CheckOther::checkSizeofForNumericParameter()
-{
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "sizeof ( %num% )")
-            || Token::Match(tok, "sizeof ( - %num% )")
-            || Token::Match(tok, "sizeof %num%")
-            || Token::Match(tok, "sizeof - %num%")
-           ) {
-            sizeofForNumericParameterError(tok);
-        }
-    }
-}
-
-void CheckOther::checkSizeofForArrayParameter()
-{
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "sizeof ( %var% )") || Token::Match(tok, "sizeof %var%")) {
-            int tokIdx = 1;
-            if (tok->tokAt(tokIdx)->str() == "(") {
-                ++tokIdx;
-            }
-            if (tok->tokAt(tokIdx)->varId() > 0) {
-                const Token *declTok = Token::findmatch(_tokenizer->tokens(), "%varid%", tok->tokAt(tokIdx)->varId());
-                if (declTok) {
-                    if (Token::simpleMatch(declTok->next(), "[")) {
-                        declTok = declTok->next()->link();
-                        // multidimensional array
-                        while (Token::simpleMatch(declTok->next(), "[")) {
-                            declTok = declTok->next()->link();
-                        }
-                        if (!(Token::Match(declTok->next(), "= %str%")) && !(Token::simpleMatch(declTok->next(), "= {")) && !(Token::simpleMatch(declTok->next(), ";"))) {
-                            if (Token::simpleMatch(declTok->next(), ",")) {
-                                declTok = declTok->next();
-                                while (!Token::simpleMatch(declTok, ";")) {
-                                    if (Token::simpleMatch(declTok, ")")) {
-                                        sizeofForArrayParameterError(tok);
-                                        break;
-                                    }
-                                    if (Token::Match(declTok, "(|[|{")) {
-                                        declTok = declTok->link();
-                                    }
-                                    declTok = declTok->next();
-                                }
-                            }
-                        }
-                        if (Token::simpleMatch(declTok->next(), ")")) {
-                            sizeofForArrayParameterError(tok);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-
-
-//---------------------------------------------------------------------------
-//    switch (x)
-//    {
-//        case 2:
-//            y = a;        // <- this assignment is redundant
-//        case 3:
-//            y = b;        // <- case 2 falls through and sets y twice
-//    }
-//---------------------------------------------------------------------------
-void CheckOther::checkRedundantAssignmentInSwitch()
-{
-    const char switchPattern[] = "switch ( %any% ) { case";
-    const char breakPattern[] = "break|continue|return|exit|goto|throw";
-    const char functionPattern[] = "%var% (";
-
-    // Find the beginning of a switch. E.g.:
-    //   switch (var) { ...
-    const Token *tok = Token::findmatch(_tokenizer->tokens(), switchPattern);
-    while (tok) {
-
-        // Check the contents of the switch statement
-        std::map<unsigned int, const Token*> varsAssigned;
-        int indentLevel = 0;
-        for (const Token *tok2 = tok->tokAt(5); tok2; tok2 = tok2->next()) {
-            if (tok2->str() == "{") {
-                // Inside a conditional or loop. Don't mark variable accesses as being redundant. E.g.:
-                //   case 3: b = 1;
-                //   case 4: if (a) { b = 2; }    // Doesn't make the b=1 redundant because it's conditional
-                if (Token::Match(tok2->previous(), ")|else {") && tok2->link()) {
-                    const Token* endOfConditional = tok2->link();
-                    for (const Token* tok3 = tok2; tok3 != endOfConditional; tok3 = tok3->next()) {
-                        if (tok3->varId() != 0)
-                            varsAssigned.erase(tok3->varId());
-                        else if (Token::Match(tok3, functionPattern) || Token::Match(tok3, breakPattern))
-                            varsAssigned.clear();
-                    }
-                    tok2 = endOfConditional;
-                } else
-                    ++ indentLevel;
-            } else if (tok2->str() == "}") {
-                -- indentLevel;
-
-                // End of the switch block
-                if (indentLevel < 0)
-                    break;
-            }
-
-            // Variable assignment. Report an error if it's assigned to twice before a break. E.g.:
-            //    case 3: b = 1;    // <== redundant
-            //    case 4: b = 2;
-            if (Token::Match(tok2->previous(), ";|{|}|: %var% = %any% ;") && tok2->varId() != 0) {
-                std::map<unsigned int, const Token*>::iterator i = varsAssigned.find(tok2->varId());
-                if (i == varsAssigned.end())
-                    varsAssigned[tok2->varId()] = tok2;
-                else
-                    redundantAssignmentInSwitchError(i->second, i->second->str());
-            }
-            // Not a simple assignment so there may be good reason if this variable is assigned to twice. E.g.:
-            //    case 3: b = 1;
-            //    case 4: b++;
-            else if (tok2->varId() != 0)
-                varsAssigned.erase(tok2->varId());
-
-            // Reset our record of assignments if there is a break or function call. E.g.:
-            //    case 3: b = 1; break;
-            if (Token::Match(tok2, functionPattern) || Token::Match(tok2, breakPattern))
-                varsAssigned.clear();
-
-        }
-
-        tok = Token::findmatch(tok->next(), switchPattern);
-    }
-}
-
-
-void CheckOther::checkSwitchCaseFallThrough()
-{
-    if (!(_settings->isEnabled("style") && _settings->experimental))
-        return;
-
-    const char switchPattern[] = "switch (";
-    const char breakPattern[] = "break|continue|return|exit|goto|throw";
-
-    // Find the beginning of a switch. E.g.:
-    //   switch (var) { ...
-    const Token *tok = Token::findmatch(_tokenizer->tokens(), switchPattern);
-    while (tok) {
-
-        // Check the contents of the switch statement
-        std::stack<std::pair<Token *, bool> > ifnest;
-        std::stack<Token *> loopnest;
-        std::stack<Token *> scopenest;
-        bool justbreak = true;
-        bool firstcase = true;
-        for (const Token *tok2 = tok->tokAt(1)->link()->tokAt(2); tok2; tok2 = tok2->next()) {
-            if (Token::simpleMatch(tok2, "if (")) {
-                tok2 = tok2->tokAt(1)->link()->next();
-                if (tok2->link() == NULL) {
-                    std::ostringstream errmsg;
-                    errmsg << "unmatched if in switch: " << tok2->linenr();
-                    reportError(_tokenizer->tokens(), Severity::debug, "debug", errmsg.str());
-                    break;
-                }
-                ifnest.push(std::make_pair(tok2->link(), false));
-                justbreak = false;
-            } else if (Token::simpleMatch(tok2, "while (")) {
-                tok2 = tok2->tokAt(1)->link()->next();
-                // skip over "do { } while ( ) ;" case
-                if (tok2->str() == "{") {
-                    if (tok2->link() == NULL) {
-                        std::ostringstream errmsg;
-                        errmsg << "unmatched while in switch: " << tok2->linenr();
-                        reportError(_tokenizer->tokens(), Severity::debug, "debug", errmsg.str());
-                        break;
-                    }
-                    loopnest.push(tok2->link());
-                }
-                justbreak = false;
-            } else if (Token::simpleMatch(tok2, "do {")) {
-                tok2 = tok2->tokAt(1);
-                if (tok2->link() == NULL) {
-                    std::ostringstream errmsg;
-                    errmsg << "unmatched do in switch: " << tok2->linenr();
-                    reportError(_tokenizer->tokens(), Severity::debug, "debug", errmsg.str());
-                    break;
-                }
-                loopnest.push(tok2->link());
-                justbreak = false;
-            } else if (Token::simpleMatch(tok2, "for (")) {
-                tok2 = tok2->tokAt(1)->link()->next();
-                if (tok2->link() == NULL) {
-                    std::ostringstream errmsg;
-                    errmsg << "unmatched for in switch: " << tok2->linenr();
-                    reportError(_tokenizer->tokens(), Severity::debug, "debug", errmsg.str());
-                    break;
-                }
-                loopnest.push(tok2->link());
-                justbreak = false;
-            } else if (Token::Match(tok2, switchPattern)) {
-                // skip over nested switch, we'll come to that soon
-                tok2 = tok2->tokAt(1)->link()->next()->link();
-            } else if (Token::Match(tok2, breakPattern)) {
-                if (loopnest.empty()) {
-                    justbreak = true;
-                }
-                tok2 = Token::findsimplematch(tok2, ";");
-            } else if (Token::Match(tok2, "case|default")) {
-                if (!justbreak && !firstcase) {
-                    switchCaseFallThrough(tok2);
-                }
-                tok2 = Token::findsimplematch(tok2, ":");
-                justbreak = true;
-                firstcase = false;
-            } else if (tok2->str() == "{") {
-                scopenest.push(tok2->link());
-            } else if (tok2->str() == "}") {
-                if (!ifnest.empty() && tok2 == ifnest.top().first) {
-                    if (tok2->next()->str() == "else") {
-                        tok2 = tok2->tokAt(2);
-                        ifnest.pop();
-                        if (tok2->link() == NULL) {
-                            std::ostringstream errmsg;
-                            errmsg << "unmatched if in switch: " << tok2->linenr();
-                            reportError(_tokenizer->tokens(), Severity::debug, "debug", errmsg.str());
-                            break;
-                        }
-                        ifnest.push(std::make_pair(tok2->link(), justbreak));
-                        justbreak = false;
-                    } else {
-                        justbreak &= ifnest.top().second;
-                        ifnest.pop();
-                    }
-                } else if (!loopnest.empty() && tok2 == loopnest.top()) {
-                    loopnest.pop();
-                } else if (!scopenest.empty() && tok2 == scopenest.top()) {
-                    scopenest.pop();
-                } else {
-                    if (!ifnest.empty() || !loopnest.empty() || !scopenest.empty()) {
-                        std::ostringstream errmsg;
-                        errmsg << "unexpected end of switch: ";
-                        errmsg << "ifnest=" << ifnest.size();
-                        if (!ifnest.empty())
-                            errmsg << "," << ifnest.top().first->linenr();
-                        errmsg << ", loopnest=" << loopnest.size();
-                        if (!loopnest.empty())
-                            errmsg << "," << loopnest.top()->linenr();
-                        errmsg << ", scopenest=" << scopenest.size();
-                        if (!scopenest.empty())
-                            errmsg << "," << scopenest.top()->linenr();
-                        reportError(_tokenizer->tokens(), Severity::debug, "debug", errmsg.str());
-                    }
-                    // end of switch block
-                    break;
-                }
-            } else if (tok2->str() != ";") {
-                justbreak = false;
-            }
-
-        }
-
-        tok = Token::findmatch(tok->next(), switchPattern);
-    }
-}
-
-
-//---------------------------------------------------------------------------
-//    int x = 1;
-//    x = x;            // <- redundant assignment to self
-//
-//    int y = y;        // <- redundant initialization to self
-//---------------------------------------------------------------------------
-void CheckOther::checkSelfAssignment()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-
-    // POD variables..
-    std::set<unsigned int> pod;
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        if (tok->isStandardType() && Token::Match(tok->tokAt(2), "[,);]") && tok->next()->varId())
-            pod.insert(tok->next()->varId());
-    }
-
-    const char selfAssignmentPattern[] = "%var% = %var% ;|=|)";
-    const Token *tok = Token::findmatch(_tokenizer->tokens(), selfAssignmentPattern);
-    while (tok) {
-        if (Token::Match(tok->previous(), "[;{}]") &&
-            tok->varId() && tok->varId() == tok->tokAt(2)->varId() &&
-            pod.find(tok->varId()) != pod.end()) {
-            selfAssignmentError(tok, tok->str());
-        }
-
-        tok = Token::findmatch(tok->next(), selfAssignmentPattern);
-    }
-}
-
-//---------------------------------------------------------------------------
-//    int a = 1;
-//    assert(a = 2);            // <- assert should not have a side-effect
-//---------------------------------------------------------------------------
-void CheckOther::checkAssignmentInAssert()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-
-    const char assertPattern[] = "assert ( %any%";
-    const Token *tok = Token::findmatch(_tokenizer->tokens(), assertPattern);
-    const Token *endTok = tok ? tok->next()->link() : NULL;
-
-    while (tok && endTok) {
-        const Token* varTok = Token::findmatch(tok->tokAt(2), "%var% --|++|+=|-=|*=|/=|&=|^=|=", endTok);
-        if (varTok) {
-            assignmentInAssertError(tok, varTok->str());
-        } else if (NULL != (varTok = Token::findmatch(tok->tokAt(2), "--|++ %var%", endTok))) {
-            assignmentInAssertError(tok, varTok->strAt(1));
-        }
-
-        tok = Token::findmatch(endTok->next(), assertPattern);
-        endTok = tok ? tok->next()->link() : NULL;
-    }
-}
-
-//---------------------------------------------------------------------------
-//    if ((x != 1) || (x != 3))            // <- always true
-//    if ((x == 1) && (x == 3))            // <- always false
-//    if ((x < 1)  && (x > 3))             // <- always false
-//    if ((x > 3)  || (x < 10))            // <- always true
-//---------------------------------------------------------------------------
-void CheckOther::checkIncorrectLogicOperator()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-
-    const char conditionPattern[] = "if|while (";
-    const Token *tok = Token::findmatch(_tokenizer->tokens(), conditionPattern);
-    const Token *endTok = tok ? tok->next()->link() : NULL;
-
-    while (tok && endTok) {
-        // Find a pair of OR'd terms, with or without parentheses
-        // e.g. if (x != 3 || x != 4)
-        const Token *logicTok = NULL, *term1Tok = NULL, *term2Tok = NULL;
-        const Token *op1Tok = NULL, *op2Tok = NULL, *op3Tok = NULL, *nextTok = NULL;
-        if (NULL != (logicTok = Token::findmatch(tok, "( %any% !=|==|<|>|>=|<= %any% ) &&|%oror% ( %any% !=|==|<|>|>=|<= %any% ) %any%", endTok))) {
-            term1Tok = logicTok->next();
-            term2Tok = logicTok->tokAt(7);
-            op1Tok = logicTok->tokAt(2);
-            op2Tok = logicTok->tokAt(5);
-            op3Tok = logicTok->tokAt(8);
-            nextTok = logicTok->tokAt(11);
-        } else if (NULL != (logicTok = Token::findmatch(tok, "%any% !=|==|<|>|>=|<= %any% &&|%oror% %any% !=|==|<|>|>=|<= %any% %any%", endTok))) {
-            term1Tok = logicTok;
-            term2Tok = logicTok->tokAt(4);
-            op1Tok = logicTok->tokAt(1);
-            op2Tok = logicTok->tokAt(3);
-            op3Tok = logicTok->tokAt(5);
-            nextTok = logicTok->tokAt(7);
-        }
-
-        if (logicTok) {
-            // Find the common variable and the two different-valued constants
-            unsigned int variableTested = 0;
-            std::string firstConstant, secondConstant;
-            bool varFirst1, varFirst2;
-            unsigned int varId;
-            if (Token::Match(term1Tok, "%var% %any% %num%")) {
-                varId = term1Tok->varId();
-                if (!varId) {
-                    tok = Token::findmatch(endTok->next(), conditionPattern);
-                    endTok = tok ? tok->next()->link() : NULL;
-                    continue;
-                }
-                varFirst1 = true;
-                firstConstant = term1Tok->tokAt(2)->str();
-            } else if (Token::Match(term1Tok, "%num% %any% %var%")) {
-                varId = term1Tok->tokAt(2)->varId();
-                if (!varId) {
-                    tok = Token::findmatch(endTok->next(), conditionPattern);
-                    endTok = tok ? tok->next()->link() : NULL;
-                    continue;
-                }
-                varFirst1 = false;
-                firstConstant = term1Tok->str();
-            } else {
-                tok = Token::findmatch(endTok->next(), conditionPattern);
-                endTok = tok ? tok->next()->link() : NULL;
-                continue;
-            }
-
-            if (Token::Match(term2Tok, "%var% %any% %num%")) {
-                const unsigned int varId2 = term2Tok->varId();
-                if (!varId2 || varId != varId2) {
-                    tok = Token::findmatch(endTok->next(), conditionPattern);
-                    endTok = tok ? tok->next()->link() : NULL;
-                    continue;
-                }
-                varFirst2 = true;
-                secondConstant = term2Tok->tokAt(2)->str();
-                variableTested = varId;
-            } else if (Token::Match(term2Tok, "%num% %any% %var%")) {
-                const unsigned int varId2 = term1Tok->tokAt(2)->varId();
-                if (!varId2 || varId != varId2) {
-                    tok = Token::findmatch(endTok->next(), conditionPattern);
-                    endTok = tok ? tok->next()->link() : NULL;
-                    continue;
-                }
-                varFirst2 = false;
-                secondConstant = term2Tok->str();
-                variableTested = varId;
-            } else {
-                tok = Token::findmatch(endTok->next(), conditionPattern);
-                endTok = tok ? tok->next()->link() : NULL;
-                continue;
-            }
-
-            if (variableTested == 0 || firstConstant.empty() || secondConstant.empty()) {
-                tok = Token::findmatch(endTok->next(), conditionPattern);
-                endTok = tok ? tok->next()->link() : NULL;
-                continue;
-            }
-
-            enum Position { First, Second, NA };
-            enum Relation { Equal, NotEqual, Less, LessEqual, More, MoreEqual };
-            struct Condition {
-                const char *before;
-                Position   position1;
-                const char *op1TokStr;
-                const char *op2TokStr;
-                Position   position2;
-                const char *op3TokStr;
-                const char *after;
-                Relation   relation;
-                bool       state;
-            } conditions[] = {
-                { "!!&&", NA,     "!=",   "||", NA,     "!=",   "!!&&", NotEqual,  true  }, // (x != 1) || (x != 3) <- always true
-                { "(",    NA,     "==",   "&&", NA,     "==",   ")",    NotEqual,  false }, // (x == 1) && (x == 3) <- always false
-                { "(",    First,  "<",    "&&", First,  ">",    ")",    LessEqual, false }, // (x < 1)  && (x > 3)  <- always false
-                { "(",    First,  ">",    "&&", First,  "<",    ")",    MoreEqual, false }, // (x > 3)  && (x < 1)  <- always false
-                { "(",    Second, ">",    "&&", First,  ">",    ")",    LessEqual, false }, // (1 > x)  && (x > 3)  <- always false
-                { "(",    First,  ">",    "&&", Second, ">",    ")",    MoreEqual, false }, // (x > 3)  && (1 > x)  <- always false
-                { "(",    First,  "<",    "&&", Second, "<",    ")",    LessEqual, false }, // (x < 1)  && (3 < x)  <- always false
-                { "(",    Second, "<",    "&&", First,  "<",    ")",    MoreEqual, false }, // (3 < x)  && (x < 1)  <- always false
-                { "(",    Second, ">",    "&&", Second, "<",    ")",    LessEqual, false }, // (1 > x)  && (3 < x)  <- always false
-                { "(",    Second, "<",    "&&", Second, ">",    ")",    MoreEqual, false }, // (3 < x)  && (1 > x)  <- always false
-                { "(",    First, ">|>=", "||", First,  "<|<=", ")",    Less,      true  },  // (x > 3)  || (x < 10) <- always true
-                { "(",    First, "<|<=", "||", First,  ">|>=", ")",    More,      true  },  // (x < 10) || (x > 3)  <- always true
-                { "(",    Second, "<|<=", "||", First,  "<|<=", ")",    Less,      true  }, // (3 < x)  || (x < 10) <- always true
-                { "(",    First,  "<|<=", "||", Second, "<|<=", ")",    More,      true  }, // (x < 10) || (3 < x)  <- always true
-                { "(",    First,  ">|>=", "||", Second, ">|>=", ")",    Less,      true  }, // (x > 3)  || (10 > x) <- always true
-                { "(",    Second, ">|>=", "||", First,  ">|>=", ")",    More,      true  }, // (10 > x) || (x > 3)  <- always true
-                { "(",    Second, "<|<=", "||", Second, ">|<=", ")",    Less,      true  }, // (3 < x)  || (10 > x) <- always true
-                { "(",    Second, ">|>=", "||", Second, "<|<=", ")",    More,      true  }, // (10 > x) || (3 < x)  <- always true
-            };
-
-            for (unsigned int i = 0; i < (sizeof(conditions) / sizeof(conditions[0])); i++) {
-                if (!((conditions[i].position1 == NA) || (((conditions[i].position1 == First) && varFirst1) || ((conditions[i].position1 == Second) && !varFirst1))))
-                    continue;
-
-                if (!((conditions[i].position2 == NA) || (((conditions[i].position2 == First) && varFirst2) || ((conditions[i].position2 == Second) && !varFirst2))))
-                    continue;
-
-                if (!Token::Match(op1Tok, conditions[i].op1TokStr))
-                    continue;
-
-                if (!Token::Match(op2Tok, conditions[i].op2TokStr))
-                    continue;
-
-                if (!Token::Match(op3Tok, conditions[i].op3TokStr))
-                    continue;
-
-                if (!Token::Match(logicTok->previous(), conditions[i].before))
-                    continue;
-
-                if (!Token::Match(nextTok, conditions[i].after))
-                    continue;
-
-                if ((conditions[i].relation == Equal     && MathLib::isEqual(firstConstant, secondConstant)) ||
-                    (conditions[i].relation == NotEqual  && MathLib::isNotEqual(firstConstant, secondConstant)) ||
-                    (conditions[i].relation == Less      && MathLib::isLess(firstConstant, secondConstant)) ||
-                    (conditions[i].relation == LessEqual && MathLib::isLessEqual(firstConstant, secondConstant)) ||
-                    (conditions[i].relation == More      && MathLib::isGreater(firstConstant, secondConstant)) ||
-                    (conditions[i].relation == MoreEqual && MathLib::isGreaterEqual(firstConstant, secondConstant)))
-                    incorrectLogicOperatorError(term1Tok, conditions[i].state);
-            }
-        }
-
-        tok = Token::findmatch(endTok->next(), conditionPattern);
-        endTok = tok ? tok->next()->link() : NULL;
-    }
-}
-
-//---------------------------------------------------------------------------
-//    try {} catch (std::exception err) {} <- Should be "std::exception& err"
-//---------------------------------------------------------------------------
-void CheckOther::checkCatchExceptionByValue()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-
-    const char catchPattern[] = "} catch (";
-    const Token *tok = Token::findmatch(_tokenizer->tokens(), catchPattern);
-    const Token *endTok = tok ? tok->tokAt(2)->link() : NULL;
-
-    while (tok && endTok) {
-        // Find a pass-by-value declaration in the catch(), excluding basic types
-        // e.g. catch (std::exception err)
-        const Token *tokType = Token::findmatch(tok, "%type% %var% )", endTok);
-        if (tokType && !tokType->isStandardType()) {
-            catchExceptionByValueError(tokType);
-        }
-
-        tok = Token::findmatch(endTok->next(), catchPattern);
-        endTok = tok ? tok->tokAt(2)->link() : NULL;
-    }
-}
-
-//---------------------------------------------------------------------------
-// strtol(str, 0, radix)  <- radix must be 0 or 2-36
-//---------------------------------------------------------------------------
-
-void CheckOther::invalidFunctionUsage()
-{
-    // strtol and strtoul..
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        if (!Token::Match(tok, "strtol|strtoul ("))
-            continue;
-
-        // Locate the third parameter of the function call..
-        int param = 1;
-        for (const Token *tok2 = tok->tokAt(2); tok2; tok2 = tok2->next()) {
-            if (tok2->str() == "(")
-                tok2 = tok2->link();
-            else if (tok2->str() == ")")
-                break;
-            else if (tok2->str() == ",") {
-                ++param;
-                if (param == 3) {
-                    if (Token::Match(tok2, ", %num% )")) {
-                        const MathLib::bigint radix = MathLib::toLongNumber(tok2->next()->str());
-                        if (!(radix == 0 || (radix >= 2 && radix <= 36))) {
-                            dangerousUsageStrtolError(tok2);
-                        }
-                    }
-                    break;
-                }
-            }
-        }
-    }
-
-    // sprintf|snprintf overlapping data
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        // Get variable id of target buffer..
-        unsigned int varid = 0;
-
-        if (Token::Match(tok, "sprintf|snprintf ( %var% ,"))
-            varid = tok->tokAt(2)->varId();
-
-        else if (Token::Match(tok, "sprintf|snprintf ( %var% . %var% ,"))
-            varid = tok->tokAt(4)->varId();
-
-        if (varid == 0)
-            continue;
-
-        // goto ","
-        const Token *tok2 = tok->tokAt(3);
-        while (tok2 && tok2->str() != ",")
-            tok2 = tok2->next();
-        if (!tok2)
-            continue;
-
-        // is any source buffer overlapping the target buffer?
-        int parlevel = 0;
-        while ((tok2 = tok2->next()) != NULL) {
-            if (tok2->str() == "(")
-                ++parlevel;
-            else if (tok2->str() == ")") {
-                --parlevel;
-                if (parlevel < 0)
-                    break;
-            } else if (parlevel == 0 && Token::Match(tok2, ", %varid% [,)]", varid)) {
-                sprintfOverlappingDataError(tok2->next(), tok2->next()->str());
-                break;
-            }
-        }
-    }
-}
-//---------------------------------------------------------------------------
-
-void CheckOther::invalidScanf()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        const Token *formatToken = 0;
-        if (Token::Match(tok, "scanf|vscanf ( %str% ,"))
-            formatToken = tok->tokAt(2);
-        else if (Token::Match(tok, "fscanf|vfscanf ( %var% , %str% ,"))
-            formatToken = tok->tokAt(4);
-        else
-            continue;
-
-        bool format = false;
-
-        // scan the string backwards, so we don't need to keep states
-        const std::string &formatstr(formatToken->str());
-        for (unsigned int i = 1; i < formatstr.length(); i++) {
-            if (formatstr[i] == '%')
-                format = !format;
-
-            else if (!format)
-                continue;
-
-            else if (std::isdigit(formatstr[i])) {
-                format = false;
-            }
-
-            else if (std::isalpha(formatstr[i])) {
-                invalidScanfError(tok);
-                format = false;
-            }
-        }
-    }
-}
-
-//---------------------------------------------------------------------------
-//    if (!x==3) <- Probably meant to be "x!=3"
-//---------------------------------------------------------------------------
-void CheckOther::checkComparisonOfBoolWithInt()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "( ! %var% ==|!= %num% )")) {
-            const Token *numTok = tok->tokAt(4);
-            if (numTok && numTok->str() != "0") {
-                comparisonOfBoolWithIntError(numTok, tok->strAt(2));
-            }
-        } else if (Token::Match(tok, "( %num% ==|!= ! %var% )")) {
-            const Token *numTok = tok->tokAt(1);
-            if (numTok && numTok->str() != "0") {
-                comparisonOfBoolWithIntError(numTok, tok->strAt(4));
-            }
-        }
-    }
-}
-
-//---------------------------------------------------------------------------
-//    switch (x)
-//    {
-//        case 2:
-//            y = a;
-//            break;
-//            break; // <- Redundant break
-//        case 3:
-//            y = b;
-//    }
-//---------------------------------------------------------------------------
-void CheckOther::checkDuplicateBreak()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-
-    const char breakPattern[] = "break|continue ; break|continue ;";
-
-    // Find consecutive break or continue statements. e.g.:
-    //   break; break;
-    const Token *tok = Token::findmatch(_tokenizer->tokens(), breakPattern);
-    while (tok) {
-        duplicateBreakError(tok);
-        tok = Token::findmatch(tok->next(), breakPattern);
-    }
-}
-
-
-void CheckOther::sizeofForNumericParameterError(const Token *tok)
-{
-    reportError(tok, Severity::error,
-                "sizeofwithnumericparameter", "Using sizeof with a numeric constant as function "
-                "argument might not be what you intended.\n"
-                "It is unusual to use constant value with sizeof. For example, this code:\n"
-                "     int f() {\n"
-                "         return sizeof(10);\n"
-                "     }\n"
-                " returns 4 (in 32-bit systems) or 8 (in 64-bit systems) instead of 10."
-               );
-}
-
-void CheckOther::sizeofForArrayParameterError(const Token *tok)
-{
-    reportError(tok, Severity::error,
-                "sizeofwithsilentarraypointer", "Using sizeof for array given as function argument "
-                "returns the size of pointer.\n"
-                "Giving array as function parameter and then using sizeof-operator for the array "
-                "argument. In this case the sizeof-operator returns the size of pointer (in the "
-                "system). It does not return the size of the whole array in bytes as might be "
-                "expected. For example, this code:\n"
-                "     int f(char a[100]) {\n"
-                "         return sizeof(a);\n"
-                "     }\n"
-                " returns 4 (in 32-bit systems) or 8 (in 64-bit systems) instead of 100 (the "
-                "size of the array in bytes)."
-               );
-}
-
-void CheckOther::invalidScanfError(const Token *tok)
-{
-    reportError(tok, Severity::warning,
-                "invalidscanf", "scanf without field width limits can crash with huge input data\n"
-                "scanf without field width limits can crash with huge input data. To fix this error "
-                "message add a field width specifier:\n"
-                "    %s => %20s\n"
-                "    %i => %3i\n"
-                "\n"
-                "Sample program that can crash:\n"
-                "\n"
-                "#include <stdio.h>\n"
-                "int main()\n"
-                "{\n"
-                "    int a;\n"
-                "    scanf(\"%i\", &a);\n"
-                "    return 0;\n"
-                "}\n"
-                "\n"
-                "To make it crash:\n"
-                "perl -e 'print \"5\"x2100000' | ./a.out");
-}
-
-//---------------------------------------------------------------------------
-// Check for unsigned divisions
-//---------------------------------------------------------------------------
-
-void CheckOther::checkUnsignedDivision()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-
-    // Check for "ivar / uvar" and "uvar / ivar"
-    std::map<unsigned int, char> varsign;
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "[{};(,] %type% %var% [;=,)]")) {
-            if (tok->tokAt(1)->isUnsigned())
-                varsign[tok->tokAt(2)->varId()] = 'u';
-            else
-                varsign[tok->tokAt(2)->varId()] = 's';
-        }
-
-        else if (!Token::Match(tok, "[).]") && Token::Match(tok->next(), "%var% / %num%")) {
-            if (tok->strAt(3)[0] == '-') {
-                char sign1 = varsign[tok->tokAt(1)->varId()];
-                if (sign1 == 'u') {
-                    udivError(tok->next());
-                }
-            }
-        }
-
-        else if (Token::Match(tok, "(|[|=|%op% %num% / %var%")) {
-            if (tok->strAt(1)[0] == '-') {
-                char sign2 = varsign[tok->tokAt(3)->varId()];
-                if (sign2 == 'u') {
-                    udivError(tok->next());
-                }
-            }
-        }
-    }
-}
-
-//---------------------------------------------------------------------------
-// memset(p, y, 0 /* bytes to fill */) <- 2nd and 3rd arguments inverted
-//---------------------------------------------------------------------------
-void CheckOther::checkMemsetZeroBytes()
-{
-    const Token *tok = _tokenizer->tokens();
-    while (tok && ((tok = Token::findmatch(tok, "memset ( %var% , %num% , 0 )")) != NULL)) {
-        memsetZeroBytesError(tok, tok->strAt(2));
-        tok = tok->tokAt(8);
-    }
-}
-//---------------------------------------------------------------------------
-
-
-
-//---------------------------------------------------------------------------
-// Usage of function variables
-//---------------------------------------------------------------------------
-
-/**
- * @brief This class is used to capture the control flow within a function.
- */
-class ScopeInfo {
-public:
-    ScopeInfo() : _token(NULL), _parent(NULL) { }
-    ScopeInfo(const Token *token, ScopeInfo *parent_) : _token(token), _parent(parent_) { }
-    ~ScopeInfo();
-
-    ScopeInfo *parent() {
-        return _parent;
-    }
-    ScopeInfo *addChild(const Token *token);
-    void remove(ScopeInfo *scope);
-
-private:
-    const Token *_token;
-    ScopeInfo *_parent;
-    std::list<ScopeInfo *> _children;
-};
-
-ScopeInfo::~ScopeInfo()
-{
-    while (!_children.empty()) {
-        delete *_children.begin();
-        _children.pop_front();
-    }
-}
-
-ScopeInfo *ScopeInfo::addChild(const Token *token)
-{
-    ScopeInfo *temp = new ScopeInfo(token, this);
-
-    _children.push_back(temp);
-
-    return temp;
-}
-
-void ScopeInfo::remove(ScopeInfo *scope)
-{
-    std::list<ScopeInfo *>::iterator it;
-
-    for (it = _children.begin(); it != _children.end(); ++it) {
-        if (*it == scope) {
-            delete *it;
-            _children.erase(it);
-            break;
-        }
-    }
-}
-
-/**
- * @brief This class is used create a list of variables within a function.
- */
-class Variables {
-public:
-    enum VariableType { standard, array, pointer, reference, pointerArray, referenceArray, pointerPointer };
-
-    /** Store information about variable usage */
-    class VariableUsage {
-    public:
-        VariableUsage(const Token *name = 0,
-                      VariableType type = standard,
-                      ScopeInfo *scope = NULL,
-                      bool read = false,
-                      bool write = false,
-                      bool modified = false,
-                      bool allocateMemory = false) :
-            _name(name),
-            _type(type),
-            _scope(scope),
-            _read(read),
-            _write(write),
-            _modified(modified),
-            _allocateMemory(allocateMemory) {
-        }
-
-        /** variable is used.. set both read+write */
-        void use() {
-            _read = true;
-            _write = true;
-        }
-
-        /** is variable unused? */
-        bool unused() const {
-            return (!_read && !_write);
-        }
-
-        const Token *_name;
-        VariableType _type;
-        ScopeInfo *_scope;
-        bool _read;
-        bool _write;
-        bool _modified; // read/modify/write
-        bool _allocateMemory;
-        std::set<unsigned int> _aliases;
-        std::set<ScopeInfo *> _assignments;
-    };
-
-    typedef std::map<unsigned int, VariableUsage> VariableMap;
-
-    void clear() {
-        _varUsage.clear();
-    }
-    VariableMap &varUsage() {
-        return _varUsage;
-    }
-    void addVar(const Token *name, VariableType type, ScopeInfo *scope, bool write_);
-    void allocateMemory(unsigned int varid);
-    void read(unsigned int varid);
-    void readAliases(unsigned int varid);
-    void readAll(unsigned int varid);
-    void write(unsigned int varid);
-    void writeAliases(unsigned int varid);
-    void writeAll(unsigned int varid);
-    void use(unsigned int varid);
-    void modified(unsigned int varid);
-    VariableUsage *find(unsigned int varid);
-    void alias(unsigned int varid1, unsigned int varid2, bool replace);
-    void erase(unsigned int varid) {
-        _varUsage.erase(varid);
-    }
-    void eraseAliases(unsigned int varid);
-    void eraseAll(unsigned int varid);
-    void clearAliases(unsigned int varid);
-
-private:
-    VariableMap _varUsage;
-};
-
-/**
- * Alias the 2 given variables. Either replace the existing aliases if
- * they exist or merge them.  You would replace an existing alias when this
- * assignment is in the same scope as the previous assignment.  You might
- * merge the aliases when this assignment is in a different scope from the
- * previous assignment depending on the relationship of the 2 scopes.
- */
-void Variables::alias(unsigned int varid1, unsigned int varid2, bool replace)
-{
-    VariableUsage *var1 = find(varid1);
-    VariableUsage *var2 = find(varid2);
-
-    // alias to self
-    if (varid1 == varid2) {
-        if (var1)
-            var1->use();
-        return;
-    }
-
-    std::set<unsigned int>::iterator i;
-
-    if (replace) {
-        // remove var1 from all aliases
-        for (i = var1->_aliases.begin(); i != var1->_aliases.end(); ++i) {
-            VariableUsage *temp = find(*i);
-
-            if (temp)
-                temp->_aliases.erase(var1->_name->varId());
-        }
-
-        // remove all aliases from var1
-        var1->_aliases.clear();
-    }
-
-    // var1 gets all var2s aliases
-    for (i = var2->_aliases.begin(); i != var2->_aliases.end(); ++i) {
-        if (*i != varid1)
-            var1->_aliases.insert(*i);
-    }
-
-    // var2 is an alias of var1
-    var2->_aliases.insert(varid1);
-    var1->_aliases.insert(varid2);
-
-    if (var2->_type == Variables::pointer)
-        var2->_read = true;
-}
-
-void Variables::clearAliases(unsigned int varid)
-{
-    VariableUsage *usage = find(varid);
-
-    if (usage) {
-        // remove usage from all aliases
-        std::set<unsigned int>::iterator i;
-
-        for (i = usage->_aliases.begin(); i != usage->_aliases.end(); ++i) {
-            VariableUsage *temp = find(*i);
-
-            if (temp)
-                temp->_aliases.erase(usage->_name->varId());
-        }
-
-        // remove all aliases from usage
-        usage->_aliases.clear();
-    }
-}
-
-void Variables::eraseAliases(unsigned int varid)
-{
-    VariableUsage *usage = find(varid);
-
-    if (usage) {
-        std::set<unsigned int>::iterator aliases;
-
-        for (aliases = usage->_aliases.begin(); aliases != usage->_aliases.end(); ++aliases)
-            erase(*aliases);
-    }
-}
-
-void Variables::eraseAll(unsigned int varid)
-{
-    eraseAliases(varid);
-    erase(varid);
-}
-
-void Variables::addVar(const Token *name,
-                       VariableType type,
-                       ScopeInfo *scope,
-                       bool write_)
-{
-    if (name->varId() > 0)
-        _varUsage.insert(std::make_pair(name->varId(), VariableUsage(name, type, scope, false, write_, false)));
-}
-
-void Variables::allocateMemory(unsigned int varid)
-{
-    VariableUsage *usage = find(varid);
-
-    if (usage)
-        usage->_allocateMemory = true;
-}
-
-void Variables::read(unsigned int varid)
-{
-    VariableUsage *usage = find(varid);
-
-    if (usage)
-        usage->_read = true;
-}
-
-void Variables::readAliases(unsigned int varid)
-{
-    VariableUsage *usage = find(varid);
-
-    if (usage) {
-        std::set<unsigned int>::iterator aliases;
-
-        for (aliases = usage->_aliases.begin(); aliases != usage->_aliases.end(); ++aliases) {
-            VariableUsage *aliased = find(*aliases);
-
-            if (aliased)
-                aliased->_read = true;
-        }
-    }
-}
-
-void Variables::readAll(unsigned int varid)
-{
-    VariableUsage *usage = find(varid);
-
-    if (usage) {
-        usage->_read = true;
-
-        std::set<unsigned int>::iterator aliases;
-
-        for (aliases = usage->_aliases.begin(); aliases != usage->_aliases.end(); ++aliases) {
-            VariableUsage *aliased = find(*aliases);
-
-            if (aliased)
-                aliased->_read = true;
-        }
-    }
-}
-
-void Variables::write(unsigned int varid)
-{
-    VariableUsage *usage = find(varid);
-
-    if (usage)
-        usage->_write = true;
-}
-
-void Variables::writeAliases(unsigned int varid)
-{
-    VariableUsage *usage = find(varid);
-
-    if (usage) {
-        std::set<unsigned int>::iterator aliases;
-
-        for (aliases = usage->_aliases.begin(); aliases != usage->_aliases.end(); ++aliases) {
-            VariableUsage *aliased = find(*aliases);
-
-            if (aliased)
-                aliased->_write = true;
-        }
-    }
-}
-
-void Variables::writeAll(unsigned int varid)
-{
-    VariableUsage *usage = find(varid);
-
-    if (usage) {
-        usage->_write = true;
-
-        std::set<unsigned int>::iterator aliases;
-
-        for (aliases = usage->_aliases.begin(); aliases != usage->_aliases.end(); ++aliases) {
-            VariableUsage *aliased = find(*aliases);
-
-            if (aliased)
-                aliased->_write = true;
-        }
-    }
-}
-
-void Variables::use(unsigned int varid)
-{
-    VariableUsage *usage = find(varid);
-
-    if (usage) {
-        usage->use();
-
-        std::set<unsigned int>::iterator aliases;
-
-        for (aliases = usage->_aliases.begin(); aliases != usage->_aliases.end(); ++aliases) {
-            VariableUsage *aliased = find(*aliases);
-
-            if (aliased)
-                aliased->use();
-        }
-    }
-}
-
-void Variables::modified(unsigned int varid)
-{
-    VariableUsage *usage = find(varid);
-
-    if (usage) {
-        usage->_modified = true;
-
-        std::set<unsigned int>::iterator aliases;
-
-        for (aliases = usage->_aliases.begin(); aliases != usage->_aliases.end(); ++aliases) {
-            VariableUsage *aliased = find(*aliases);
-
-            if (aliased)
-                aliased->_modified = true;
-        }
-    }
-}
-
-Variables::VariableUsage *Variables::find(unsigned int varid)
-{
-    if (varid) {
-        VariableMap::iterator i = _varUsage.find(varid);
-        if (i != _varUsage.end())
-            return &i->second;
-    }
-    return 0;
-}
-
-static int doAssignment(Variables &variables, const Token *tok, bool dereference, ScopeInfo *scope)
-{
-    int next = 0;
-
-    // a = a + b;
-    if (Token::Match(tok, "%var% = %var% !!;") && tok->str() == tok->strAt(2)) {
-        return 2;
-    }
-
-    // check for aliased variable
-    const unsigned int varid1 = tok->varId();
-    Variables::VariableUsage *var1 = variables.find(varid1);
-
-    if (var1) {
-        int start = 1;
-
-        // search for '='
-        while (tok->tokAt(start)->str() != "=")
-            start++;
-
-        start++;
-
-        if (Token::Match(tok->tokAt(start), "&| %var%") ||
-            Token::Match(tok->tokAt(start), "( const| struct|union| %type% *| ) &| %var%") ||
-            Token::Match(tok->tokAt(start), "( const| struct|union| %type% *| ) ( &| %var%") ||
-            Token::Match(tok->tokAt(start), "%any% < const| struct|union| %type% *| > ( &| %var%")) {
-            unsigned char offset = 0;
-            unsigned int varid2;
-            bool addressOf = false;
-
-            if (Token::Match(tok->tokAt(start), "%var% ."))
-                variables.use(tok->tokAt(start)->varId());   // use = read + write
-
-            // check for C style cast
-            if (tok->tokAt(start)->str() == "(") {
-                if (tok->tokAt(start + 1)->str() == "const")
-                    offset++;
-
-                if (Token::Match(tok->tokAt(start + 1 + offset), "struct|union"))
-                    offset++;
-
-                if (tok->tokAt(start + 2 + offset)->str() == "*")
-                    offset++;
-
-                if (tok->tokAt(start + 3 + offset)->str() == "&") {
-                    addressOf = true;
-                    next = start + 4 + offset;
-                } else if (tok->tokAt(start + 3 + offset)->str() == "(") {
-                    if (tok->tokAt(start + 4 + offset)->str() == "&") {
-                        addressOf = true;
-                        next = start + 5 + offset;
-                    } else
-                        next = start + 4 + offset;
-                } else
-                    next = start + 3 + offset;
-            }
-
-            // check for C++ style cast
-            else if (tok->tokAt(start)->str().find("cast") != std::string::npos &&
-                     tok->tokAt(start + 1)->str() == "<") {
-                if (tok->tokAt(start + 2)->str() == "const")
-                    offset++;
-
-                if (Token::Match(tok->tokAt(start + 2 + offset), "struct|union"))
-                    offset++;
-
-                if (tok->tokAt(start + 3 + offset)->str() == "*")
-                    offset++;
-
-                if (tok->tokAt(start + 5 + offset)->str() == "&") {
-                    addressOf = true;
-                    next = start + 6 + offset;
-                } else
-                    next = start + 5 + offset;
-            }
-
-            // check for var ? ...
-            else if (Token::Match(tok->tokAt(start), "%var% ?")) {
-                next = start;
-            }
-
-            // no cast
-            else {
-                if (tok->tokAt(start)->str() == "&") {
-                    addressOf = true;
-                    next = start + 1;
-                } else if (tok->tokAt(start)->str() == "new")
-                    return 0;
-                else
-                    next = start;
-            }
-
-            // check if variable is local
-            varid2 = tok->tokAt(next)->varId();
-            Variables::VariableUsage *var2 = variables.find(varid2);
-
-            if (var2) { // local variable (alias or read it)
-                if (var1->_type == Variables::pointer) {
-                    if (dereference)
-                        variables.read(varid2);
-                    else {
-                        if (addressOf ||
-                            var2->_type == Variables::array ||
-                            var2->_type == Variables::pointer) {
-                            bool    replace = true;
-
-                            // check if variable declared in same scope
-                            if (scope == var1->_scope)
-                                replace = true;
-
-                            // not in same scope as declaration
-                            else {
-                                std::set<ScopeInfo *>::iterator assignment;
-
-                                // check for an assignment in this scope
-                                assignment = var1->_assignments.find(scope);
-
-                                // no other assignment in this scope
-                                if (assignment == var1->_assignments.end()) {
-                                    // nothing to replace
-                                    if (var1->_assignments.empty())
-                                        replace = false;
-
-                                    // this variable has previous assignments
-                                    else {
-                                        /**
-                                         * @todo determine if existing aliases should be replaced or merged
-                                         */
-
-                                        replace = false;
-                                    }
-                                }
-
-                                // assignment in this scope
-                                else {
-                                    // replace when only one other assignment
-                                    if (var1->_assignments.size() == 1)
-                                        replace = true;
-
-                                    // otherwise, merge them
-                                    else
-                                        replace = false;
-                                }
-                            }
-
-                            variables.alias(varid1, varid2, replace);
-                        } else if (tok->tokAt(next + 1)->str() == "?") {
-                            if (var2->_type == Variables::reference)
-                                variables.readAliases(varid2);
-                            else
-                                variables.read(varid2);
-                        }
-                    }
-                } else if (var1->_type == Variables::reference) {
-                    variables.alias(varid1, varid2, true);
-                } else {
-                    if (var2->_type == Variables::pointer && tok->tokAt(next + 1)->str() == "[")
-                        variables.readAliases(varid2);
-
-                    variables.read(varid2);
-                }
-            } else { // not a local variable (or an unsupported local variable)
-                if (var1->_type == Variables::pointer && !dereference) {
-                    // check if variable declaration is in this scope
-                    if (var1->_scope == scope)
-                        variables.clearAliases(varid1);
-                    else {
-                        std::set<ScopeInfo *>::iterator assignment;
-
-                        // check for an assignment in this scope
-                        assignment = var1->_assignments.find(scope);
-
-                        // no other assignment in this scope
-                        if (assignment == var1->_assignments.end()) {
-                            /**
-                             * @todo determine if existing aliases should be discarded
-                             */
-                        }
-
-                        // this assignment replaces the last assignment in this scope
-                        else {
-                            // aliased variables in a larger scope are not supported
-                            // remove all aliases
-                            variables.clearAliases(varid1);
-                        }
-                    }
-                }
-            }
-        }
-
-        var1->_assignments.insert(scope);
-    }
-
-    // check for alias to struct member
-    // char c[10]; a.b = c;
-    else if (Token::Match(tok->tokAt(-2), "%var% .")) {
-        if (Token::Match(tok->tokAt(2), "%var%")) {
-            unsigned int varid2 = tok->tokAt(2)->varId();
-            Variables::VariableUsage *var2 = variables.find(varid2);
-
-            // struct member aliased to local variable
-            if (var2 && (var2->_type == Variables::array ||
-                         var2->_type == Variables::pointer)) {
-                // erase aliased variable and all variables that alias it
-                // to prevent false positives
-                variables.eraseAll(varid2);
-            }
-        }
-    }
-
-    return next;
-}
-
-static bool nextIsStandardType(const Token *tok)
-{
-    tok = tok->next();
-
-    if (tok->str() == "static")
-        tok = tok->next();
-
-    return tok->isStandardType();
-}
-
-static bool nextIsStandardTypeOrVoid(const Token *tok)
-{
-    tok = tok->next();
-
-    if (tok->str() == "static")
-        tok = tok->next();
-
-    if (tok->str() == "const")
-        tok = tok->next();
-
-    return tok->isStandardType() || tok->str() == "void";
-}
-
-bool CheckOther::isRecordTypeWithoutSideEffects(const Token *tok)
-{
-    const Variable * var = _tokenizer->getSymbolDatabase()->getVariableFromVarId(tok->varId());
-
-    // a type that has no side effects (no constructors and no members with constructors)
-    /** @todo false negative: check base class for side effects */
-    /** @todo false negative: check constructors for side effects */
-    if (var && var->type() && var->type()->numConstructors == 0 &&
-        (var->type()->varlist.empty() || var->type()->needInitialization == Scope::True) &&
-        var->type()->derivedFrom.empty())
-        return true;
-
-    return false;
-}
-
-void CheckOther::functionVariableUsage()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-
-    // Parse all executing scopes..
-    const SymbolDatabase *symbolDatabase = _tokenizer->getSymbolDatabase();
-
-    std::list<Scope>::const_iterator scope;
-
-    for (scope = symbolDatabase->scopeList.begin(); scope != symbolDatabase->scopeList.end(); ++scope) {
-        // only check functions
-        if (scope->type != Scope::eFunction)
-            continue;
-
-        // First token for the current scope..
-        const Token *const tok1 = scope->classStart;
-
-        // varId, usage {read, write, modified}
-        Variables variables;
-
-        // scopes
-        ScopeInfo scopes;
-        ScopeInfo *info = &scopes;
-
-        unsigned int indentlevel = 0;
-        for (const Token *tok = tok1; tok; tok = tok->next()) {
-            if (tok->str() == "{") {
-                // replace the head node when found
-                if (indentlevel == 0)
-                    scopes = ScopeInfo(tok, NULL);
-                // add the new scope
-                else
-                    info = info->addChild(tok);
-                ++indentlevel;
-            } else if (tok->str() == "}") {
-                --indentlevel;
-
-                info = info->parent();
-
-                if (indentlevel == 0)
-                    break;
-            } else if (Token::Match(tok, "struct|union|class {") ||
-                       Token::Match(tok, "struct|union|class %type% {|:")) {
-                while (tok->str() != "{")
-                    tok = tok->next();
-                tok = tok->link();
-                if (! tok)
-                    break;
-            }
-
-            if (Token::Match(tok, "[;{}] asm ( ) ;")) {
-                variables.clear();
-                break;
-            }
-
-            // standard type declaration with possible initialization
-            // int i; int j = 0; static int k;
-            if (Token::Match(tok, "[;{}] static| %type% %var% ;|=") &&
-                !Token::Match(tok->next(), "return|throw")) {
-                tok = tok->next();
-
-                const bool isStatic = tok->str() == "static";
-                if (isStatic)
-                    tok = tok->next();
-
-                if (tok->isStandardType() || isRecordTypeWithoutSideEffects(tok->next())) {
-                    variables.addVar(tok->next(), Variables::standard, info,
-                                     tok->tokAt(2)->str() == "=" || isStatic);
-                }
-                tok = tok->next();
-            }
-
-            // standard const type declaration
-            // const int i = x;
-            else if (Token::Match(tok, "[;{}] const %type% %var% =")) {
-                tok = tok->next()->next();
-
-                if (tok->isStandardType() || isRecordTypeWithoutSideEffects(tok->next()))
-                    variables.addVar(tok->next(), Variables::standard, info, true);
-
-                tok = tok->next();
-            }
-
-            // std::string declaration with possible initialization
-            // std::string s; std::string s = "string";
-            else if (Token::Match(tok, "[;{}] static| std :: string %var% ;|=")) {
-                tok = tok->next();
-
-                const bool isStatic = tok->str() == "static";
-                if (isStatic)
-                    tok = tok->next();
-
-                tok = tok->tokAt(3);
-                variables.addVar(tok, Variables::standard, info,
-                                 tok->next()->str() == "=" || isStatic);
-            }
-
-            // standard struct type declaration with possible initialization
-            // struct S s; struct S s = { 0 }; static struct S s;
-            else if (Token::Match(tok, "[;{}] static| struct %type% %var% ;|=") &&
-                     (isRecordTypeWithoutSideEffects(tok->strAt(1) == "static" ? tok->tokAt(4) : tok->tokAt(3)))) {
-                tok = tok->next();
-
-                bool isStatic = tok->str() == "static";
-                if (isStatic)
-                    tok = tok->next();
-
-                tok = tok->next();
-
-                variables.addVar(tok->next(), Variables::standard, info,
-                                 tok->tokAt(2)->str() == "=" || isStatic);
-                tok = tok->next();
-            }
-
-            // standard type declaration and initialization using constructor
-            // int i(0); static int j(0);
-            else if (Token::Match(tok, "[;{}] static| %type% %var% ( %any% ) ;") &&
-                     nextIsStandardType(tok)) {
-                tok = tok->next();
-
-                if (tok->str() == "static")
-                    tok = tok->next();
-
-                variables.addVar(tok->next(), Variables::standard, info, true);
-
-                // check if a local variable is used to initialize this variable
-                if (tok->tokAt(3)->varId() > 0)
-                    variables.readAll(tok->tokAt(3)->varId());
-                tok = tok->tokAt(4);
-            }
-
-            // standard type declaration of array of with possible initialization
-            // int i[10]; int j[2] = { 0, 1 }; static int k[2] = { 2, 3 };
-            else if (Token::Match(tok, "[;{}] static| const| %type% *| %var% [ %any% ] ;|=") &&
-                     nextIsStandardType(tok)) {
-                tok = tok->next();
-
-                const bool isStatic = tok->str() == "static";
-                if (isStatic)
-                    tok = tok->next();
-
-                if (tok->str() == "const")
-                    tok = tok->next();
-
-                if (tok->str() != "return" && tok->str() != "throw") {
-                    bool isPointer = bool(tok->strAt(1) == "*");
-                    const Token * const nametok = tok->tokAt(isPointer ? 2 : 1);
-
-                    variables.addVar(nametok, isPointer ? Variables::pointerArray : Variables::array, info,
-                                     nametok->tokAt(4)->str() == "=" || isStatic);
-
-                    // check for reading array size from local variable
-                    if (nametok->tokAt(2)->varId() != 0)
-                        variables.read(nametok->tokAt(2)->varId());
-
-                    // look at initializers
-                    if (Token::simpleMatch(nametok->tokAt(4), "= {")) {
-                        tok = nametok->tokAt(6);
-                        while (tok->str() != "}") {
-                            if (Token::Match(tok, "%var%"))
-                                variables.read(tok->varId());
-                            tok = tok->next();
-                        }
-                    } else
-                        tok = nametok->tokAt(3);
-                }
-            }
-
-            // pointer or reference declaration with possible initialization
-            // int * i; int * j = 0; static int * k = 0;
-            else if (Token::Match(tok, "[;{}] static| const| %type% *|& %var% ;|=")) {
-                tok = tok->next();
-
-                const bool isStatic = tok->str() == "static";
-                if (isStatic)
-                    tok = tok->next();
-
-                if (tok->str() == "const")
-                    tok = tok->next();
-
-                if (tok->strAt(1) == "::")
-                    tok = tok->tokAt(2);
-
-                if (tok->str() != "return" && tok->str() != "throw") {
-                    Variables::VariableType type;
-
-                    if (tok->next()->str() == "*")
-                        type = Variables::pointer;
-                    else
-                        type = Variables::reference;
-
-                    bool written = tok->tokAt(3)->str() == "=";
-
-                    variables.addVar(tok->tokAt(2), type, info, written || isStatic);
-
-                    int offset = 0;
-
-                    // check for assignment
-                    if (written)
-                        offset = doAssignment(variables, tok->tokAt(2), false, info);
-
-                    tok = tok->tokAt(2 + offset);
-                }
-            }
-
-            // pointer to pointer declaration with possible initialization
-            // int ** i; int ** j = 0; static int ** k = 0;
-            else if (Token::Match(tok, "[;{}] static| const| %type% * * %var% ;|=")) {
-                tok = tok->next();
-
-                const bool isStatic = tok->str() == "static";
-                if (isStatic)
-                    tok = tok->next();
-
-                if (tok->str() == "const")
-                    tok = tok->next();
-
-                if (tok->str() != "return") {
-                    bool written = tok->tokAt(4)->str() == "=";
-
-                    variables.addVar(tok->tokAt(3), Variables::pointerPointer, info, written || isStatic);
-
-                    int offset = 0;
-
-                    // check for assignment
-                    if (written)
-                        offset = doAssignment(variables, tok->tokAt(3), false, info);
-
-                    tok = tok->tokAt(3 + offset);
-                }
-            }
-
-            // pointer or reference of struct or union declaration with possible initialization
-            // struct s * i; struct s * j = 0; static struct s * k = 0;
-            else if (Token::Match(tok, "[;{}] static| const| struct|union %type% *|& %var% ;|=")) {
-                Variables::VariableType type;
-
-                tok = tok->next();
-
-                const bool isStatic = tok->str() == "static";
-                if (isStatic)
-                    tok = tok->next();
-
-                if (tok->str() == "const")
-                    tok = tok->next();
-
-                if (tok->strAt(2) == "*")
-                    type = Variables::pointer;
-                else
-                    type = Variables::reference;
-
-                const bool written = tok->strAt(4) == "=";
-
-                variables.addVar(tok->tokAt(3), type, info, written || isStatic);
-
-                int offset = 0;
-
-                // check for assignment
-                if (written)
-                    offset = doAssignment(variables, tok->tokAt(3), false, info);
-
-                tok = tok->tokAt(3 + offset);
-            }
-
-            // pointer or reference declaration with initialization using constructor
-            // int * i(j); int * k(i); static int * l(i);
-            else if (Token::Match(tok, "[;{}] static| const| %type% &|* %var% ( %any% ) ;") &&
-                     nextIsStandardTypeOrVoid(tok)) {
-                Variables::VariableType type;
-
-                tok = tok->next();
-
-                if (tok->str() == "static")
-                    tok = tok->next();
-
-                if (tok->str() == "const")
-                    tok = tok->next();
-
-                if (tok->next()->str() == "*")
-                    type = Variables::pointer;
-                else
-                    type = Variables::reference;
-
-                unsigned int varid = 0;
-
-                // check for aliased variable
-                if (Token::Match(tok->tokAt(4), "%var%"))
-                    varid = tok->tokAt(4)->varId();
-
-                variables.addVar(tok->tokAt(2), type, info, true);
-
-                // check if a local variable is used to initialize this variable
-                if (varid > 0) {
-                    Variables::VariableUsage *var = variables.find(varid);
-
-                    if (type == Variables::pointer) {
-                        variables.use(tok->tokAt(4)->varId());
-
-                        if (var && (var->_type == Variables::array ||
-                                    var->_type == Variables::pointer))
-                            var->_aliases.insert(tok->varId());
-                    } else {
-                        variables.readAll(tok->tokAt(4)->varId());
-                        if (var)
-                            var->_aliases.insert(tok->varId());
-                    }
-                }
-                tok = tok->tokAt(5);
-            }
-
-            // array of pointer or reference declaration with possible initialization
-            // int * p[10]; int * q[10] = { 0 }; static int * * r[10] = { 0 };
-            else if (Token::Match(tok, "[;{}] static| const| %type% *|& %var% [ %any% ] ;|=")) {
-                tok = tok->next();
-
-                const bool isStatic = tok->str() == "static";
-                if (isStatic)
-                    tok = tok->next();
-
-                if (tok->str() == "const")
-                    tok = tok->next();
-
-                if (tok->str() != "return") {
-                    variables.addVar(tok->tokAt(2),
-                                     tok->next()->str() == "*" ? Variables::pointerArray : Variables::referenceArray, info,
-                                     tok->tokAt(6)->str() == "=" || isStatic);
-
-                    // check for reading array size from local variable
-                    if (tok->tokAt(4)->varId() != 0)
-                        variables.read(tok->tokAt(4)->varId());
-
-                    tok = tok->tokAt(5);
-                }
-            }
-
-            // array of pointer or reference of struct or union declaration with possible initialization
-            // struct S * p[10]; struct T * q[10] = { 0 }; static struct S * r[10] = { 0 };
-            else if (Token::Match(tok, "[;{}] static| const| struct|union %type% *|& %var% [ %any% ] ;|=")) {
-                tok = tok->next();
-
-                const bool isStatic = tok->str() == "static";
-                if (isStatic)
-                    tok = tok->next();
-
-                if (tok->str() == "const")
-                    tok = tok->next();
-
-                variables.addVar(tok->tokAt(3),
-                                 tok->tokAt(2)->str() == "*" ? Variables::pointerArray : Variables::referenceArray, info,
-                                 tok->tokAt(7)->str() == "=" || isStatic);
-
-                // check for reading array size from local variable
-                if (tok->tokAt(5)->varId() != 0)
-                    variables.read(tok->tokAt(5)->varId());
-
-                tok = tok->tokAt(6);
-            }
-
-            // Freeing memory (not considered "using" the pointer if it was also allocated in this function)
-            else if (Token::Match(tok, "free|g_free|kfree|vfree ( %var% )") ||
-                     Token::Match(tok, "delete %var% ;") ||
-                     Token::Match(tok, "delete [ ] %var% ;")) {
-                unsigned int varid = 0;
-                if (tok->str() != "delete") {
-                    varid = tok->tokAt(2)->varId();
-                    tok = tok->tokAt(3);
-                } else if (tok->strAt(1) == "[") {
-                    varid = tok->tokAt(3)->varId();
-                    tok = tok->tokAt(4);
-                } else {
-                    varid = tok->next()->varId();
-                    tok = tok->tokAt(2);
-                }
-
-                Variables::VariableUsage *var = variables.find(varid);
-                if (var && !var->_allocateMemory) {
-                    variables.readAll(varid);
-                }
-            }
-
-            else if (Token::Match(tok, "return|throw %var%"))
-                variables.readAll(tok->next()->varId());
-
-            // assignment
-            else if (Token::Match(tok, "*| (| ++|--| %var% ++|--| )| =") ||
-                     Token::Match(tok, "*| ( const| %type% *| ) %var% =")) {
-                bool dereference = false;
-                bool pre = false;
-                bool post = false;
-
-                if (tok->str() == "*") {
-                    dereference = true;
-                    tok = tok->next();
-                }
-
-                if (Token::Match(tok, "( const| %type% *| ) %var% ="))
-                    tok = tok->link()->next();
-
-                else if (tok->str() == "(")
-                    tok = tok->next();
-
-                if (Token::Match(tok, "++|--")) {
-                    pre = true;
-                    tok = tok->next();
-                }
-
-                if (Token::Match(tok->next(), "++|--"))
-                    post = true;
-
-                const unsigned int varid1 = tok->varId();
-                const Token *start = tok;
-
-                tok = tok->tokAt(doAssignment(variables, tok, dereference, info));
-
-                if (pre || post)
-                    variables.use(varid1);
-
-                if (dereference) {
-                    Variables::VariableUsage *var = variables.find(varid1);
-                    if (var && var->_type == Variables::array)
-                        variables.write(varid1);
-                    variables.writeAliases(varid1);
-                    variables.read(varid1);
-                } else {
-                    Variables::VariableUsage *var = variables.find(varid1);
-                    if (var && var->_type == Variables::reference) {
-                        variables.writeAliases(varid1);
-                        variables.read(varid1);
-                    }
-                    // Consider allocating memory separately because allocating/freeing alone does not constitute using the variable
-                    else if (var && var->_type == Variables::pointer &&
-                             Token::Match(start, "%var% = new|malloc|calloc|g_malloc|kmalloc|vmalloc")) {
-                        bool allocate = true;
-
-                        if (start->strAt(2) == "new") {
-                            // is it a user defined type?
-                            if (!start->tokAt(3)->isStandardType()) {
-                                if (!isRecordTypeWithoutSideEffects(start))
-                                    allocate = false;
-                            }
-                        }
-
-                        if (allocate)
-                            variables.allocateMemory(varid1);
-                        else
-                            variables.write(varid1);
-                    } else if (varid1 && Token::Match(tok, "%varid% .", varid1)) {
-                        variables.use(varid1);
-                    } else {
-                        variables.write(varid1);
-                    }
-
-                    Variables::VariableUsage *var2 = variables.find(tok->varId());
-                    if (var2) {
-                        if (var2->_type == Variables::reference) {
-                            variables.writeAliases(tok->varId());
-                            variables.read(tok->varId());
-                        } else if (tok->varId() != varid1 && Token::Match(tok, "%var% ."))
-                            variables.read(tok->varId());
-                        else if (tok->varId() != varid1 &&
-                                 var2->_type == Variables::standard &&
-                                 tok->strAt(-1) != "&")
-                            variables.use(tok->varId());
-                    }
-                }
-
-                const Token *equal = tok->next();
-
-                if (Token::Match(tok->next(), "[ %any% ]"))
-                    equal = tok->tokAt(4);
-
-                // checked for chained assignments
-                if (tok != start && equal->str() == "=") {
-                    Variables::VariableUsage *var = variables.find(tok->varId());
-
-                    if (var && var->_type != Variables::reference)
-                        var->_read = true;
-
-                    tok = tok->previous();
-                }
-            }
-
-            // assignment
-            else if (Token::Match(tok, "%var% [") && Token::simpleMatch(tok->next()->link(), "] =")) {
-                unsigned int varid = tok->varId();
-                const Variables::VariableUsage *var = variables.find(varid);
-
-                if (var) {
-                    // Consider allocating memory separately because allocating/freeing alone does not constitute using the variable
-                    if (var->_type == Variables::pointer &&
-                        Token::Match(tok->next()->link(), "] = new|malloc|calloc|g_malloc|kmalloc|vmalloc")) {
-                        variables.allocateMemory(varid);
-                    } else if (var->_type == Variables::pointer || var->_type == Variables::reference) {
-                        variables.read(varid);
-                        variables.writeAliases(varid);
-                    } else
-                        variables.writeAll(varid);
-                }
-            }
-
-            else if (Token::Match(tok, ">>|& %var%"))
-                variables.use(tok->next()->varId());    // use = read + write
-            else if (Token::Match(tok, "[;{}] %var% >>"))
-                variables.use(tok->next()->varId());    // use = read + write
-
-            // function parameter
-            else if (Token::Match(tok, "[(,] %var% ["))
-                variables.use(tok->next()->varId());   // use = read + write
-            else if (Token::Match(tok, "[(,] %var% [,)]") && tok->previous()->str() != "*")
-                variables.use(tok->next()->varId());   // use = read + write
-            else if (Token::Match(tok, "[(,] (") &&
-                     Token::Match(tok->next()->link(), ") %var% [,)]"))
-                variables.use(tok->next()->link()->next()->varId());   // use = read + write
-
-            // function
-            else if (Token::Match(tok, "%var% (")) {
-                variables.read(tok->varId());
-                if (Token::Match(tok->tokAt(2), "%var% ="))
-                    variables.read(tok->tokAt(2)->varId());
-            }
-
-            else if (Token::Match(tok, "[{,] %var% [,}]"))
-                variables.read(tok->next()->varId());
-
-            else if (Token::Match(tok, "%var% ."))
-                variables.use(tok->varId());   // use = read + write
-
-            else if ((Token::Match(tok, "[(=&!]") || tok->isExtendedOp()) &&
-                     (Token::Match(tok->next(), "%var%") && !Token::Match(tok->next(), "true|false|new")))
-                variables.readAll(tok->next()->varId());
-
-            else if (Token::Match(tok, "%var%") && (tok->next()->str() == ")" || tok->next()->isExtendedOp()))
-                variables.readAll(tok->varId());
-
-            else if (Token::Match(tok, "; %var% ;"))
-                variables.readAll(tok->next()->varId());
-
-            if (Token::Match(tok, "++|-- %var%")) {
-                if (tok->strAt(-1) != ";")
-                    variables.use(tok->next()->varId());
-                else
-                    variables.modified(tok->next()->varId());
-            }
-
-            else if (Token::Match(tok, "%var% ++|--")) {
-                if (tok->strAt(-1) != ";")
-                    variables.use(tok->varId());
-                else
-                    variables.modified(tok->varId());
-            }
-
-            else if (tok->isAssignmentOp()) {
-                for (const Token *tok2 = tok->next(); tok2 && tok2->str() != ";"; tok2 = tok2->next()) {
-                    if (tok2->varId()) {
-                        variables.read(tok2->varId());
-                        if (tok2->next()->isAssignmentOp())
-                            variables.write(tok2->varId());
-                    }
-                }
-            }
-        }
-
-        // Check usage of all variables in the current scope..
-        Variables::VariableMap::const_iterator it;
-        for (it = variables.varUsage().begin(); it != variables.varUsage().end(); ++it) {
-            const Variables::VariableUsage &usage = it->second;
-            const std::string &varname = usage._name->str();
-
-            // variable has been marked as unused so ignore it
-            if (usage._name->isUnused())
-                continue;
-
-            // skip things that are only partially implemented to prevent false positives
-            if (usage._type == Variables::pointerPointer ||
-                usage._type == Variables::pointerArray ||
-                usage._type == Variables::referenceArray)
-                continue;
-
-            // variable has had memory allocated for it, but hasn't done
-            // anything with that memory other than, perhaps, freeing it
-            if (usage.unused() && !usage._modified && usage._allocateMemory)
-                allocatedButUnusedVariableError(usage._name, varname);
-
-            // variable has not been written, read, or modified
-            else if (usage.unused() && !usage._modified)
-                unusedVariableError(usage._name, varname);
-
-            // variable has not been written but has been modified
-            else if (usage._modified & !usage._write)
-                unassignedVariableError(usage._name, varname);
-
-            // variable has been written but not read
-            else if (!usage._read && !usage._modified)
-                unreadVariableError(usage._name, varname);
-
-            // variable has been read but not written
-            else if (!usage._write && !usage._allocateMemory)
-                unassignedVariableError(usage._name, varname);
-        }
-    }
-}
-
-void CheckOther::unusedVariableError(const Token *tok, const std::string &varname)
-{
-    reportError(tok, Severity::style, "unusedVariable", "Unused variable: " + varname);
-}
-
-void CheckOther::allocatedButUnusedVariableError(const Token *tok, const std::string &varname)
-{
-    reportError(tok, Severity::style, "unusedAllocatedMemory", "Variable '" + varname + "' is allocated memory that is never used");
-}
-
-void CheckOther::unreadVariableError(const Token *tok, const std::string &varname)
-{
-    reportError(tok, Severity::style, "unreadVariable", "Variable '" + varname + "' is assigned a value that is never used");
-}
-
-void CheckOther::unassignedVariableError(const Token *tok, const std::string &varname)
-{
-    reportError(tok, Severity::style, "unassignedVariable", "Variable '" + varname + "' is not assigned a value");
-}
-//---------------------------------------------------------------------------
-
-
-
-
-
-//---------------------------------------------------------------------------
-// Check scope of variables..
-//---------------------------------------------------------------------------
-
-void CheckOther::checkVariableScope()
-{
-    if (!_settings->isEnabled("information"))
-        return;
-
-    const SymbolDatabase *symbolDatabase = _tokenizer->getSymbolDatabase();
-
-    std::list<Scope>::const_iterator scope;
-
-    for (scope = symbolDatabase->scopeList.begin(); scope != symbolDatabase->scopeList.end(); ++scope) {
-        // only check functions
-        if (scope->type != Scope::eFunction)
-            continue;
-
-        // Walk through all tokens..
-        int indentlevel = 0;
-        for (const Token *tok = scope->classStart; tok; tok = tok->next()) {
-            // Skip function local class and struct declarations..
-            if ((tok->str() == "class") || (tok->str() == "struct") || (tok->str() == "union")) {
-                for (const Token *tok2 = tok; tok2; tok2 = tok2->next()) {
-                    if (tok2->str() == "{") {
-                        tok = tok2->link();
-                        break;
-                    }
-                    if (Token::Match(tok2, "[,);]")) {
-                        break;
-                    }
-                }
-                if (! tok)
-                    break;
-            }
-
-            else if (tok->str() == "{") {
-                ++indentlevel;
-            } else if (tok->str() == "}") {
-                --indentlevel;
-                if (indentlevel == 0)
-                    break;
-            }
-
-            if (indentlevel > 0 && Token::Match(tok, "[{};]")) {
-                // First token of statement..
-                const Token *tok1 = tok->next();
-                if (! tok1)
-                    continue;
-
-                if ((tok1->str() == "return") ||
-                    (tok1->str() == "throw") ||
-                    (tok1->str() == "delete") ||
-                    (tok1->str() == "goto") ||
-                    (tok1->str() == "else"))
-                    continue;
-
-                // Variable declaration?
-                if (Token::Match(tok1, "%type% %var% ; %var% = %num% ;")) {
-                    // Tokenizer modify "int i = 0;" to "int i; i = 0;",
-                    // so to handle this situation we just skip
-                    // initialization (see ticket #272).
-                    const unsigned int firstVarId = tok1->next()->varId();
-                    const unsigned int secondVarId = tok1->tokAt(3)->varId();
-                    if (firstVarId > 0 && firstVarId == secondVarId) {
-                        lookupVar(tok1->tokAt(6), tok1->strAt(1));
-                    }
-                } else if (tok1->isStandardType() && Token::Match(tok1, "%type% %var% [;=]")) {
-                    lookupVar(tok1, tok1->strAt(1));
-                }
-            }
-        }
-    }
-
-}
-//---------------------------------------------------------------------------
-
-void CheckOther::lookupVar(const Token *tok1, const std::string &varname)
-{
-    const Token *tok = tok1;
-
-    // Skip the variable declaration..
-    while (tok && tok->str() != ";")
-        tok = tok->next();
-
-    // Check if the variable is used in this indentlevel..
-    bool used1 = false;   // used in one sub-scope -> reducable
-    bool used2 = false;   // used in more sub-scopes -> not reducable
-    int indentlevel = 0;
-    int parlevel = 0;
-    bool for_or_while = false;  // is sub-scope a "for/while/etc". anything that is not "if"
-    while (tok) {
-        if (tok->str() == "{") {
-            if (tok->strAt(-1) == "=") {
-                if (Token::findmatch(tok, varname.c_str(), tok->link())) {
-                    return;
-                }
-
-                tok = tok->link();
-            } else
-                ++indentlevel;
-        }
-
-        else if (tok->str() == "}") {
-            if (indentlevel == 0)
-                break;
-            --indentlevel;
-            if (indentlevel == 0) {
-                if (for_or_while && used2)
-                    return;
-                used2 |= used1;
-                used1 = false;
-            }
-        }
-
-        else if (tok->str() == "(") {
-            ++parlevel;
-        }
-
-        else if (tok->str() == ")") {
-            --parlevel;
-        }
-
-        // Bail out if references are used
-        else if (Token::simpleMatch(tok, (std::string("& ") + varname).c_str())) {
-            return;
-        }
-
-        else if (tok->str() == varname) {
-            if (indentlevel == 0)
-                return;
-            used1 = true;
-            if (for_or_while && !Token::simpleMatch(tok->next(), "="))
-                used2 = true;
-            if (used1 && used2)
-                return;
-        }
-
-        else if (indentlevel == 0) {
-            // %unknown% ( %any% ) {
-            // If %unknown% is anything except if, we assume
-            // that it is a for or while loop or a macro hiding either one
-            if (Token::simpleMatch(tok->next(), "(") &&
-                Token::simpleMatch(tok->next()->link(), ") {")) {
-                if (tok->str() != "if")
-                    for_or_while = true;
-            }
-
-            else if (Token::simpleMatch(tok, "do {"))
-                for_or_while = true;
-
-            // possible unexpanded macro hiding for/while..
-            else if (tok->str() != "else" && Token::Match(tok->previous(), "[;{}] %type% {")) {
-                for_or_while = true;
-            }
-
-            if (parlevel == 0 && (tok->str() == ";"))
-                for_or_while = false;
-        }
-
-        tok = tok->next();
-    }
-
-    // Warning if this variable:
-    // * not used in this indentlevel
-    // * used in lower indentlevel
-    if (used1 || used2)
-        variableScopeError(tok1, varname);
-}
-//---------------------------------------------------------------------------
-
-
-//---------------------------------------------------------------------------
-// Check for constant function parameters
-//---------------------------------------------------------------------------
-
-void CheckOther::checkConstantFunctionParameter()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-
-    const SymbolDatabase * const symbolDatabase = _tokenizer->getSymbolDatabase();
-
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        // TODO: False negatives. This pattern only checks for string.
-        //       Investigate if there are other classes in the std
-        //       namespace and add them to the pattern. There are
-        //       streams for example (however it seems strange with
-        //       const stream parameter).
-        if (Token::Match(tok, "[,(] const std :: string %var% [,)]")) {
-            passedByValueError(tok, tok->strAt(5));
-        }
-
-        else if (Token::Match(tok, "[,(] const std :: %type% < %type% > %var% [,)]")) {
-            passedByValueError(tok, tok->strAt(8));
-        }
-
-        else if (Token::Match(tok, "[,(] const std :: %type% < std :: %type% > %var% [,)]")) {
-            passedByValueError(tok, tok->strAt(10));
-        }
-
-        else if (Token::Match(tok, "[,(] const std :: %type% < std :: %type% , std :: %type% > %var% [,)]")) {
-            passedByValueError(tok, tok->strAt(14));
-        }
-
-        else if (Token::Match(tok, "[,(] const std :: %type% < %type% , std :: %type% > %var% [,)]")) {
-            passedByValueError(tok, tok->strAt(12));
-        }
-
-        else if (Token::Match(tok, "[,(] const std :: %type% < std :: %type% , %type% > %var% [,)]")) {
-            passedByValueError(tok, tok->strAt(12));
-        }
-
-        else if (Token::Match(tok, "[,(] const std :: %type% < %type% , %type% > %var% [,)]")) {
-            passedByValueError(tok, tok->strAt(10));
-        }
-
-        else if (Token::Match(tok, "[,(] const %type% %var% [,)]")) {
-            // Check if type is a struct or class.
-            if (symbolDatabase->isClassOrStruct(tok->strAt(2))) {
-                passedByValueError(tok, tok->strAt(3));
-            }
-        }
-    }
-}
-//---------------------------------------------------------------------------
-
-
-//---------------------------------------------------------------------------
-// Check that all struct members are used
-//---------------------------------------------------------------------------
-
-void CheckOther::checkStructMemberUsage()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-
-    std::string structname;
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        if (tok->fileIndex() != 0)
-            continue;
-
-        if (Token::Match(tok, "struct|union %type% {")) {
-            structname.clear();
-            if (Token::simpleMatch(tok->previous(), "extern"))
-                continue;
-            if ((!tok->previous() || Token::simpleMatch(tok->previous(), ";")) && Token::Match(tok->tokAt(2)->link(), ("} ; " + tok->strAt(1) + " %var% ;").c_str()))
-                continue;
-
-            structname = tok->strAt(1);
-
-            // Bail out if struct/union contain any functions
-            for (const Token *tok2 = tok->tokAt(2); tok2; tok2 = tok2->next()) {
-                if (tok2->str() == "(") {
-                    structname.clear();
-                    break;
-                }
-
-                if (tok2->str() == "}")
-                    break;
-            }
-
-            // bail out if struct is inherited
-            if (!structname.empty() && Token::findmatch(tok, (",|private|protected|public " + structname).c_str()))
-                structname.clear();
-
-            // Bail out if some data is casted to struct..
-            const std::string s("( struct| " + tok->next()->str() + " * ) & %var% [");
-            if (Token::findmatch(tok, s.c_str()))
-                structname.clear();
-
-            // Try to prevent false positives when struct members are not used directly.
-            if (Token::findmatch(tok, (structname + " *").c_str()))
-                structname.clear();
-            else if (Token::findmatch(tok, (structname + " %type% *").c_str()))
-                structname = "";
-        }
-
-        if (tok->str() == "}")
-            structname.clear();
-
-        if (!structname.empty() && Token::Match(tok, "[{;]")) {
-            // Declaring struct variable..
-            std::string varname;
-
-            // declaring a POD variable?
-            if (!tok->next()->isStandardType())
-                continue;
-
-            if (Token::Match(tok->next(), "%type% %var% [;[]"))
-                varname = tok->strAt(2);
-            else if (Token::Match(tok->next(), "%type% %type% %var% [;[]"))
-                varname = tok->strAt(3);
-            else if (Token::Match(tok->next(), "%type% * %var% [;[]"))
-                varname = tok->strAt(3);
-            else if (Token::Match(tok->next(), "%type% %type% * %var% [;[]"))
-                varname = tok->strAt(4);
-            else
-                continue;
-
-            // Check if the struct variable is used anywhere in the file
-            const std::string usagePattern(". " + varname);
-            bool used = false;
-            for (const Token *tok2 = _tokenizer->tokens(); tok2; tok2 = tok2->next()) {
-                if (Token::simpleMatch(tok2, usagePattern.c_str())) {
-                    used = true;
-                    break;
-                }
-            }
-
-            if (! used) {
-                unusedStructMemberError(tok->next(), structname, varname);
-            }
-        }
-    }
-}
-
-
-
-
-
-//---------------------------------------------------------------------------
-// Check usage of char variables..
-//---------------------------------------------------------------------------
-
-void CheckOther::checkCharVariable()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        // Declaring the variable..
-        if (Token::Match(tok, "[{};(,] const| char *| %var% [;=,)]") ||
-            Token::Match(tok, "[{};(,] const| char %var% [")) {
-            // goto 'char' token
-            tok = tok->next();
-            if (tok->str() == "const")
-                tok = tok->next();
-
-            // Check for unsigned char
-            if (tok->isUnsigned())
-                continue;
-
-            // Set tok to point to the variable name
-            tok = tok->next();
-            const bool isPointer(tok->str() == "*" || tok->strAt(1) == "[");
-            if (tok->str() == "*")
-                tok = tok->next();
-
-            // Check usage of char variable..
-            int indentlevel = 0;
-            for (const Token *tok2 = tok->next(); tok2; tok2 = tok2->next()) {
-                if (tok2->str() == "{")
-                    ++indentlevel;
-
-                else if (tok2->str() == "}") {
-                    --indentlevel;
-                    if (indentlevel <= 0)
-                        break;
-                }
-
-                if (!isPointer) {
-                    std::string temp = "%var% [ " + tok->str() + " ]";
-                    if ((tok2->str() != ".") && Token::Match(tok2->next(), temp.c_str())) {
-                        charArrayIndexError(tok2->next());
-                        break;
-                    }
-                }
-
-                if (Token::Match(tok2, "[;{}] %var% = %any% [&|] %any% ;")) {
-                    // is the char variable used in the calculation?
-                    if (tok2->tokAt(3)->varId() != tok->varId() && tok2->tokAt(5)->varId() != tok->varId())
-                        continue;
-
-                    // it's ok with a bitwise and where the other operand is 0xff or less..
-                    if (tok2->strAt(4) == "&") {
-                        if (tok2->tokAt(3)->isNumber() && MathLib::isGreater("0x100", tok2->strAt(3)))
-                            continue;
-                        if (tok2->tokAt(5)->isNumber() && MathLib::isGreater("0x100", tok2->strAt(5)))
-                            continue;
-                    }
-
-                    // is the result stored in a short|int|long?
-                    if (!Token::findmatch(_tokenizer->tokens(), "short|int|long %varid%", tok2->next()->varId()))
-                        continue;
-
-                    // This is an error..
-                    charBitOpError(tok2);
-                    break;
-                }
-
-                if (isPointer && Token::Match(tok2, "[;{}] %var% = %any% [&|] ( * %varid% ) ;", tok->varId())) {
-                    // it's ok with a bitwise and where the other operand is 0xff or less..
-                    if (tok2->strAt(4) == "&" && tok2->tokAt(3)->isNumber() && MathLib::isGreater("0x100", tok2->strAt(3)))
-                        continue;
-
-                    // is the result stored in a short|int|long?
-                    if (!Token::findmatch(_tokenizer->tokens(), "short|int|long %varid%", tok2->next()->varId()))
-                        continue;
-
-                    // This is an error..
-                    charBitOpError(tok2);
-                    break;
-                }
-            }
-        }
-    }
-}
-//---------------------------------------------------------------------------
-
-
-
-
-
-
-//---------------------------------------------------------------------------
-// Incomplete statement..
-//---------------------------------------------------------------------------
-
-void CheckOther::checkIncompleteStatement()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        if (tok->str() == "(") {
-            tok = tok->link();
-            if (Token::simpleMatch(tok, ") {") && Token::simpleMatch(tok->next()->link(), "} ;"))
-                tok = tok->next()->link();
-        }
-
-        else if (Token::simpleMatch(tok, "= {"))
-            tok = tok->next()->link();
-
-        else if (tok->str() == "{" && Token::Match(tok->tokAt(-2), "%type% %var%"))
-            tok = tok->link();
-
-        else if (Token::Match(tok, "[;{}] %str%") || Token::Match(tok, "[;{}] %num%")) {
-            // bailout if there is a "? :" in this statement
-            bool bailout = false;
-            for (const Token *tok2 = tok->tokAt(2); tok2; tok2 = tok2->next()) {
-                if (tok2->str() == "?")
-                    bailout = true;
-                else if (tok2->str() == ";")
-                    break;
-            }
-            if (bailout)
-                continue;
-
-            constStatementError(tok->next(), tok->next()->isNumber() ? "numeric" : "string");
-        }
-    }
-}
-//---------------------------------------------------------------------------
-
-
-
-
-
-
-//---------------------------------------------------------------------------
-// str plus char
-//---------------------------------------------------------------------------
-
-void CheckOther::strPlusChar()
-{
-    // Don't use this check for Java and C# programs..
-    if (_tokenizer->isJavaOrCSharp()) {
-        return;
-    }
-
-    bool charVars[10000] = {0};
-
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        // Declaring char variable..
-        if (Token::Match(tok, "char|int|short %var% [;=]")) {
-            unsigned int varid = tok->next()->varId();
-            if (varid > 0 && varid < 10000)
-                charVars[varid] = true;
-        }
-
-        //
-        else if (Token::Match(tok, "[=(] %str% + %any%")) {
-            // char constant..
-            const std::string s = tok->strAt(3);
-            if (s[0] == '\'')
-                strPlusChar(tok->next());
-
-            // char variable..
-            unsigned int varid = tok->tokAt(3)->varId();
-            if (varid > 0 && varid < 10000 && charVars[varid])
-                strPlusChar(tok->next());
-        }
-    }
-}
-
-void CheckOther::checkZeroDivision()
-{
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-
-        if (Token::Match(tok, "/ %num%") &&
-            MathLib::isInt(tok->next()->str()) &&
-            MathLib::toLongNumber(tok->next()->str()) == 0L) {
-            zerodivError(tok);
-        } else if (Token::Match(tok, "div|ldiv|lldiv|imaxdiv ( %num% , %num% )") &&
-                   MathLib::isInt(tok->tokAt(4)->str()) &&
-                   MathLib::toLongNumber(tok->tokAt(4)->str()) == 0L) {
-            zerodivError(tok);
-        }
-    }
-}
-
-
-void CheckOther::checkMathFunctions()
-{
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        // case log(-2)
-        if (tok->varId() == 0 &&
-            Token::Match(tok, "log|log10 ( %num% )") &&
-            MathLib::isNegative(tok->tokAt(2)->str()) &&
-            MathLib::isInt(tok->tokAt(2)->str()) &&
-            MathLib::toLongNumber(tok->tokAt(2)->str()) <= 0) {
-            mathfunctionCallError(tok);
-        }
-        // case log(-2.0)
-        else if (tok->varId() == 0 &&
-                 Token::Match(tok, "log|log10 ( %num% )") &&
-                 MathLib::isNegative(tok->tokAt(2)->str()) &&
-                 MathLib::isFloat(tok->tokAt(2)->str()) &&
-                 MathLib::toDoubleNumber(tok->tokAt(2)->str()) <= 0.) {
-            mathfunctionCallError(tok);
-        }
-
-        // case log(0.0)
-        else if (tok->varId() == 0 &&
-                 Token::Match(tok, "log|log10 ( %num% )") &&
-                 !MathLib::isNegative(tok->tokAt(2)->str()) &&
-                 MathLib::isFloat(tok->tokAt(2)->str()) &&
-                 MathLib::toDoubleNumber(tok->tokAt(2)->str()) <= 0.) {
-            mathfunctionCallError(tok);
-        }
-
-        // case log(0)
-        else if (tok->varId() == 0 &&
-                 Token::Match(tok, "log|log10 ( %num% )") &&
-                 !MathLib::isNegative(tok->tokAt(2)->str()) &&
-                 MathLib::isInt(tok->tokAt(2)->str()) &&
-                 MathLib::toLongNumber(tok->tokAt(2)->str()) <= 0) {
-            mathfunctionCallError(tok);
-        }
-        // acos( x ), asin( x )  where x is defined for interval [-1,+1], but not beyond
-        else if (tok->varId() == 0 &&
-                 Token::Match(tok, "acos|asin ( %num% )") &&
-                 std::fabs(MathLib::toDoubleNumber(tok->tokAt(2)->str())) > 1.0) {
-            mathfunctionCallError(tok);
-        }
-        // sqrt( x ): if x is negative the result is undefined
-        else if (tok->varId() == 0 &&
-                 Token::Match(tok, "sqrt|sqrtf|sqrtl ( %num% )") &&
-                 MathLib::isNegative(tok->tokAt(2)->str())) {
-            mathfunctionCallError(tok);
-        }
-        // atan2 ( x , y): x and y can not be zero, because this is mathematically not defined
-        else if (tok->varId() == 0 &&
-                 Token::Match(tok, "atan2 ( %num% , %num% )") &&
-                 MathLib::isNullValue(tok->tokAt(2)->str()) &&
-                 MathLib::isNullValue(tok->tokAt(4)->str())) {
-            mathfunctionCallError(tok, 2);
-        }
-        // fmod ( x , y) If y is zero, then either a range error will occur or the function will return zero (implementation-defined).
-        else if (tok->varId() == 0 &&
-                 Token::Match(tok, "fmod ( %num% , %num% )") &&
-                 MathLib::isNullValue(tok->tokAt(4)->str())) {
-            mathfunctionCallError(tok, 2);
-        }
-        // pow ( x , y) If x is zero, and y is negative --> division by zero
-        else if (tok->varId() == 0 &&
-                 Token::Match(tok, "pow ( %num% , %num% )") &&
-                 MathLib::isNullValue(tok->tokAt(2)->str())  &&
-                 MathLib::isNegative(tok->tokAt(4)->str())) {
-            mathfunctionCallError(tok, 2);
-        }
-
-    }
-}
-
-/** Is there a function with given name? */
-static bool isFunction(const std::string &name, const Token *startToken)
-{
-    const std::string pattern1(name + " (");
-    for (const Token *tok = startToken; tok; tok = tok->next()) {
-        // skip executable scopes etc
-        if (tok->str() == "(") {
-            tok = tok->link();
-            if (Token::simpleMatch(tok, ") {"))
-                tok = tok->next()->link();
-            else if (Token::simpleMatch(tok, ") const {"))
-                tok = tok->tokAt(2)->link();
-        }
-
-        // function declaration/implementation found
-        if ((tok->str() == "*" || (tok->isName() && tok->str().find(":") ==std::string::npos))
-            && Token::simpleMatch(tok->next(), pattern1.c_str()))
-            return true;
-    }
-    return false;
-}
-
-void CheckOther::checkMisusedScopedObject()
-{
-    // Skip this check for .c files
-    {
-        const std::string fname = _tokenizer->getFiles()->at(0);
-        size_t position         = fname.rfind(".");
-
-        if (position != std::string::npos) {
-            const std::string ext = fname.substr(position);
-            if (ext == ".c" || ext == ".C")
-                return;
-        }
-    }
-
-    const SymbolDatabase * const symbolDatabase = _tokenizer->getSymbolDatabase();
-
-    std::list<Scope>::const_iterator scope;
-
-    for (scope = symbolDatabase->scopeList.begin(); scope != symbolDatabase->scopeList.end(); ++scope) {
-        // only check functions
-        if (scope->type != Scope::eFunction)
-            continue;
-
-        unsigned int depth = 0;
-
-        for (const Token *tok = scope->classStart; tok; tok = tok->next()) {
-            if (tok->str() == "{") {
-                ++depth;
-            } else if (tok->str() == "}") {
-                --depth;
-                if (depth == 0)
-                    break;
-            }
-
-            if (Token::Match(tok, "[;{}] %var% (")
-                && Token::simpleMatch(tok->tokAt(2)->link(), ") ;")
-                && symbolDatabase->isClassOrStruct(tok->next()->str())
-                && !isFunction(tok->next()->str(), _tokenizer->tokens())) {
-                tok = tok->next();
-                misusedScopeObjectError(tok, tok->str());
-                tok = tok->next();
-            }
-        }
-    }
-}
-
-void CheckOther::checkIncorrectStringCompare()
-{
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        if (Token::Match(tok, ". substr ( %any% , %num% ) ==|!= %str%")) {
-            size_t clen = MathLib::toLongNumber(tok->tokAt(5)->str());
-            size_t slen = Token::getStrLength(tok->tokAt(8));
-            if (clen != slen) {
-                incorrectStringCompareError(tok->next(), "substr", tok->tokAt(8)->str(), tok->tokAt(5)->str());
-            }
-        }
-        if (Token::Match(tok, "%str% ==|!= %var% . substr ( %any% , %num% )")) {
-            size_t clen = MathLib::toLongNumber(tok->tokAt(8)->str());
-            size_t slen = Token::getStrLength(tok);
-            if (clen != slen) {
-                incorrectStringCompareError(tok->next(), "substr", tok->str(), tok->tokAt(8)->str());
-            }
-        }
-    }
-}
-
-//-----------------------------------------------------------------------------
-// check for duplicate expressions in if statements
-// if (a) { } else if (a) { }
-//-----------------------------------------------------------------------------
-
-static const std::string stringifyTokens(const Token *start, const Token *end)
-{
-    const Token *tok = start;
-    std::string stringified;
-
-    if (tok->isUnsigned())
-        stringified.append("unsigned ");
-    else if (tok->isSigned())
-        stringified.append("signed ");
-
-    if (tok->isLong())
-        stringified.append("long ");
-
-    stringified.append(tok->str());
-
-    while (tok && tok->next() && tok != end) {
-        if (tok->isUnsigned())
-            stringified.append("unsigned ");
-        else if (tok->isSigned())
-            stringified.append("signed ");
-
-        if (tok->isLong())
-            stringified.append("long ");
-
-        tok = tok->next();
-        stringified.append(" ");
-        stringified.append(tok->str());
-    }
-
-    return stringified;
-}
-
-static bool expressionHasSideEffects(const Token *first, const Token *last)
-{
-    for (const Token *tok = first; tok != last->next(); tok = tok->next()) {
-        // check for assignment
-        if (tok->isAssignmentOp())
-            return true;
-
-        // check for inc/dec
-        else if (Token::Match(tok, "++|--"))
-            return true;
-
-        // check for function call
-        else if (Token::Match(tok, "%var% (") &&
-                 !(Token::Match(tok, "c_str|string") || tok->isStandardType()))
-            return true;
-    }
-
-    return false;
-}
-
-void CheckOther::checkDuplicateIf()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-
-    const SymbolDatabase *symbolDatabase = _tokenizer->getSymbolDatabase();
-
-    std::list<Scope>::const_iterator scope;
-
-    for (scope = symbolDatabase->scopeList.begin(); scope != symbolDatabase->scopeList.end(); ++scope) {
-        // only check functions
-        if (scope->type != Scope::eFunction)
-            continue;
-
-        // check all the code in the function for if (...) and else if (...) statements
-        for (const Token *tok = scope->classStart; tok && tok != scope->classStart->link(); tok = tok->next()) {
-            if (Token::simpleMatch(tok, "if (") && tok->strAt(-1) != "else" &&
-                Token::simpleMatch(tok->next()->link(), ") {")) {
-                std::map<std::string, const Token*> expressionMap;
-
-                // get the expression from the token stream
-                std::string expression = stringifyTokens(tok->tokAt(2), tok->next()->link()->previous());
-
-                // save the expression and its location
-                expressionMap.insert(std::make_pair(expression, tok));
-
-                // find the next else if (...) statement
-                const Token *tok1 = tok->next()->link()->next()->link();
-
-                // check all the else if (...) statements
-                while (Token::simpleMatch(tok1, "} else if (") &&
-                       Token::simpleMatch(tok1->tokAt(3)->link(), ") {")) {
-                    // get the expression from the token stream
-                    expression = stringifyTokens(tok1->tokAt(4), tok1->tokAt(3)->link()->previous());
-
-                    // try to look up the expression to check for duplicates
-                    std::map<std::string, const Token *>::iterator it = expressionMap.find(expression);
-
-                    // found a duplicate
-                    if (it != expressionMap.end()) {
-                        // check for expressions that have side effects and ignore them
-                        if (!expressionHasSideEffects(tok1->tokAt(4), tok1->tokAt(3)->link()->previous()))
-                            duplicateIfError(it->second, tok1->next());
-                    }
-
-                    // not a duplicate expression so save it and its location
-                    else
-                        expressionMap.insert(std::make_pair(expression, tok1->next()));
-
-                    // find the next else if (...) statement
-                    tok1 = tok1->tokAt(3)->link()->next()->link();
-                }
-
-                tok = tok->next()->link()->next();
-            }
-        }
-    }
-}
-
-void CheckOther::duplicateIfError(const Token *tok1, const Token *tok2)
-{
-    std::list<const Token *> toks;
-    toks.push_back(tok2);
-    toks.push_back(tok1);
-
-    reportError(toks, Severity::style, "duplicateIf", "Found duplicate if expressions.\n"
-                "Finding the same expression more than once is suspicious and might indicate "
-                "a cut and paste or logic error. Please examine this code carefully to determine "
-                "if it is correct.");
-}
-
-//-----------------------------------------------------------------------------
-// check for duplicate code in if and else branches
-// if (a) { b = true; } else { b = true; }
-//-----------------------------------------------------------------------------
-
-void CheckOther::checkDuplicateBranch()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-
-    if (!_settings->inconclusive)
-        return;
-
-    const SymbolDatabase *symbolDatabase = _tokenizer->getSymbolDatabase();
-
-    std::list<Scope>::const_iterator scope;
-
-    for (scope = symbolDatabase->scopeList.begin(); scope != symbolDatabase->scopeList.end(); ++scope) {
-        // only check functions
-        if (scope->type != Scope::eFunction)
-            continue;
-
-        // check all the code in the function for if (..) else
-        for (const Token *tok = scope->classStart; tok && tok != scope->classStart->link(); tok = tok->next()) {
-            if (Token::simpleMatch(tok, "if (") && tok->strAt(-1) != "else" &&
-                Token::simpleMatch(tok->next()->link(), ") {") &&
-                Token::simpleMatch(tok->next()->link()->next()->link(), "} else {")) {
-                // save if branch code
-                std::string branch1 = stringifyTokens(tok->next()->link()->tokAt(2), tok->next()->link()->next()->link()->previous());
-
-                // find else branch
-                const Token *tok1 = tok->next()->link()->next()->link();
-
-                // save else branch code
-                std::string branch2 = stringifyTokens(tok1->tokAt(3), tok1->tokAt(2)->link()->previous());
-
-                // check for duplicates
-                if (branch1 == branch2)
-                    duplicateBranchError(tok, tok1->tokAt(2));
-
-                tok = tok->next()->link()->next();
-            }
-        }
-    }
-}
-
-void CheckOther::duplicateBranchError(const Token *tok1, const Token *tok2)
-{
-    std::list<const Token *> toks;
-    toks.push_back(tok2);
-    toks.push_back(tok1);
-
-    reportError(toks, Severity::style, "duplicateBranch", "Found duplicate branches for if and else.\n"
-                "Finding the same code for an if branch and an else branch is suspicious and "
-                "might indicate a cut and paste or logic error. Please examine this code "
-                "carefully to determine if it is correct.");
-}
-
-//---------------------------------------------------------------------------
-// check for the same expression on both sides of an operator
-// (x == x), (x && x), (x || x)
-// (x.y == x.y), (x.y && x.y), (x.y || x.y)
-//---------------------------------------------------------------------------
-
-void CheckOther::checkDuplicateExpression()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-
-    // Parse all executing scopes..
-    const SymbolDatabase *symbolDatabase = _tokenizer->getSymbolDatabase();
-
-    std::list<Scope>::const_iterator scope;
-
-    for (scope = symbolDatabase->scopeList.begin(); scope != symbolDatabase->scopeList.end(); ++scope) {
-        // only check functions
-        if (scope->type != Scope::eFunction)
-            continue;
-
-        for (const Token *tok = scope->classStart; tok && tok != scope->classStart->link(); tok = tok->next()) {
-            if (Token::Match(tok, "(|&&|%oror% %var% &&|%oror%|==|!=|<=|>=|<|>|-|%or% %var% )|&&|%oror%") &&
-                tok->strAt(1) == tok->strAt(3)) {
-                // float == float and float != float are valid NaN checks
-                if (Token::Match(tok->tokAt(2), "==|!=") && tok->next()->varId()) {
-                    const Variable * var = symbolDatabase->getVariableFromVarId(tok->next()->varId());
-                    if (var && var->typeStartToken() == var->typeEndToken()) {
-                        if (Token::Match(var->typeStartToken(), "float|double"))
-                            continue;
-                    }
-                }
-
-                duplicateExpressionError(tok->next(), tok->tokAt(3), tok->strAt(2));
-            } else if (Token::Match(tok, "(|&&|%oror% %var% . %var% &&|%oror%|==|!=|<=|>=|<|>|-|%or% %var% . %var% )|&&|%oror%") &&
-                       tok->strAt(1) == tok->strAt(5) && tok->strAt(3) == tok->strAt(7)) {
-                duplicateExpressionError(tok->next(), tok->tokAt(6), tok->strAt(4));
-            }
-        }
-    }
-}
-
-void CheckOther::duplicateExpressionError(const Token *tok1, const Token *tok2, const std::string &op)
-{
-    std::list<const Token *> toks;
-    toks.push_back(tok2);
-    toks.push_back(tok1);
-
-    reportError(toks, Severity::style, "duplicateExpression", "Same expression on both sides of \'" + op + "\'.\n"
-                "Finding the same expression on both sides of an operator is suspicious and might "
-                "indicate a cut and paste or logic error. Please examine this code carefully to "
-                "determine if it is correct.");
-}
-
-
-//---------------------------------------------------------------------------
-// Check for string comparison involving two static strings.
-// if(strcmp("00FF00","00FF00")==0) // <- statement is always true
-//---------------------------------------------------------------------------
-
-void CheckOther::checkAlwaysTrueOrFalseStringCompare()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-
-    const char pattern1[] = "strcmp|stricmp|strcmpi|strcasecmp|wcscmp ( %str% , %str% )";
-    const char pattern2[] = "QString :: compare ( %str% , %str% )";
-
-    const Token *tok = _tokenizer->tokens();
-    while (tok && (tok = Token::findmatch(tok, pattern1)) != NULL) {
-        alwaysTrueFalseStringCompare(tok, tok->strAt(2), tok->strAt(4));
-        tok = tok->tokAt(5);
-    }
-
-    tok = _tokenizer->tokens();
-    while (tok && (tok = Token::findmatch(tok, pattern2)) != NULL) {
-        alwaysTrueFalseStringCompare(tok, tok->strAt(4), tok->strAt(6));
-        tok = tok->tokAt(7);
-    }
-}
-
-void CheckOther::alwaysTrueFalseStringCompare(const Token *tok, const std::string& str1, const std::string& str2)
-{
-    const size_t stringLen = 10;
-    const std::string string1 = (str1.size() < stringLen) ? str1 : (str1.substr(0, stringLen-2) + "..");
-    const std::string string2 = (str2.size() < stringLen) ? str2 : (str2.substr(0, stringLen-2) + "..");
-
-    if (str1 == str2) {
-        reportError(tok, Severity::warning, "staticStringCompare",
-                    "Comparison of always identical static strings.\n"
-                    "The compared strings, '" + string1 + "' and '" + string2 + "', are always identical. "
-                    "If the purpose is to compare these two strings, the comparison is unnecessary. "
-                    "If the strings are supposed to be different, then there is a bug somewhere.");
-    } else {
-        reportError(tok, Severity::performance, "staticStringCompare",
-                    "Unnecessary comparison of static strings.\n"
-                    "The compared strings, '" + string1 + "' and '" + string2 + "', are static and always different. "
-                    "If the purpose is to compare these two strings, the comparison is unnecessary.");
-    }
-}
-
-//-----------------------------------------------------------------------------
-
-void CheckOther::cstyleCastError(const Token *tok)
-{
-    reportError(tok, Severity::style, "cstyleCast", "C-style pointer casting");
-}
-
-void CheckOther::dangerousUsageStrtolError(const Token *tok)
-{
-    reportError(tok, Severity::error, "dangerousUsageStrtol", "Invalid radix in call to strtol or strtoul. Must be 0 or 2-36");
-}
-
-void CheckOther::sprintfOverlappingDataError(const Token *tok, const std::string &varname)
-{
-    reportError(tok, Severity::error, "sprintfOverlappingData",
-                "Undefined behavior: variable is used as parameter and destination in s[n]printf().\n"
-                "The variable '" + varname + "' is used both as a parameter and as a destination in "
-                "s[n]printf(). The origin and destination buffers overlap. Quote from glibc (C-library) "
-                "documentation (http://www.gnu.org/software/libc/manual/html_mono/libc.html#Formatted-Output-Functions): "
-                "'If copying takes place between objects that overlap as a result of a call "
-                "to sprintf() or snprintf(), the results are undefined.'");
-}
-
-void CheckOther::udivError(const Token *tok)
-{
-    reportError(tok, Severity::error, "udivError", "Unsigned division. The result will be wrong.");
-}
-
-void CheckOther::unusedStructMemberError(const Token *tok, const std::string &structname, const std::string &varname)
-{
-    reportError(tok, Severity::style, "unusedStructMember", "struct or union member '" + structname + "::" + varname + "' is never used");
-}
-
-void CheckOther::passedByValueError(const Token *tok, const std::string &parname)
-{
-    reportError(tok, Severity::performance, "passedByValue",
-                "Function parameter '" + parname + "' should be passed by reference.\n"
-                "Parameter '" +  parname + "' is passed as a value. It could be passed "
-                "as a (const) reference which is usually faster and recommended in C++.");
-}
-
-void CheckOther::constStatementError(const Token *tok, const std::string &type)
-{
-    reportError(tok, Severity::warning, "constStatement", "Redundant code: Found a statement that begins with " + type + " constant");
-}
-
-void CheckOther::charArrayIndexError(const Token *tok)
-{
-    reportError(tok,
-                Severity::warning,
-                "charArrayIndex",
-                "Using char type as array index\n"
-                "Using signed char type as array index. If the value "
-                "can be greater than 127 there will be a buffer overflow "
-                "(because of sign extension).");
-}
-
-void CheckOther::charBitOpError(const Token *tok)
-{
-    reportError(tok,
-                Severity::warning,
-                "charBitOp",
-                "When using char variables in bit operations, sign extension can generate unexpected results.\n"
-                "When using char variables in bit operations, sign extension can generate unexpected results. For example:\n"
-                "    char c = 0x80;\n"
-                "    int i = 0 | c;\n"
-                "    if (i & 0x8000)\n"
-                "        printf(\"not expected\");\n"
-                "The 'not expected' will be printed on the screen.");
-}
-
-void CheckOther::variableScopeError(const Token *tok, const std::string &varname)
-{
-    reportError(tok,
-                Severity::information,
-                "variableScope",
-                "The scope of the variable '" + varname + "' can be reduced\n"
-                "The scope of the variable '" + varname + "' can be reduced. Warning: It can be unsafe "
-                "to fix this message. Be careful. Especially when there are inner loops. Here is an "
-                "example where cppcheck will write that the scope for 'i' can be reduced:\n"
-                "void f(int x)\n"
-                "{\n"
-                "    int i = 0;\n"
-                "    if (x) {\n"
-                "        // it's safe to move 'int i = 0' here\n"
-                "        for (int n = 0; n < 10; ++n) {\n"
-                "            // it is possible but not safe to move 'int i = 0' here\n"
-                "            do_something(&i);\n"
-                "        }\n"
-                "    }\n"
-                "}\n"
-                "When you see this message it is always safe to reduce the variable scope 1 level.");
-}
-
-void CheckOther::conditionAlwaysTrueFalse(const Token *tok, const std::string &truefalse)
-{
-    reportError(tok, Severity::style, "conditionAlwaysTrueFalse", "Condition is always " + truefalse);
-}
-
-void CheckOther::strPlusChar(const Token *tok)
-{
-    reportError(tok, Severity::error, "strPlusChar", "Unusual pointer arithmetic");
-}
-
-void CheckOther::zerodivError(const Token *tok)
-{
-    reportError(tok, Severity::error, "zerodiv", "Division by zero");
-}
-
-void CheckOther::mathfunctionCallError(const Token *tok, const unsigned int numParam)
-{
-    if (tok) {
-        if (numParam == 1)
-            reportError(tok, Severity::error, "wrongmathcall", "Passing value " + tok->tokAt(2)->str() + " to " + tok->str() + "() leads to undefined result");
-        else if (numParam == 2)
-            reportError(tok, Severity::error, "wrongmathcall", "Passing value " + tok->tokAt(2)->str() + " and " + tok->tokAt(4)->str() + " to " + tok->str() + "() leads to undefined result");
-    } else
-        reportError(tok, Severity::error, "wrongmathcall", "Passing value " " to " "() leads to undefined result");
-}
-
-void CheckOther::fflushOnInputStreamError(const Token *tok, const std::string &varname)
-{
-    reportError(tok, Severity::error,
-                "fflushOnInputStream", "fflush() called on input stream \"" + varname + "\" may result in undefined behaviour");
-}
-
-void CheckOther::sizeofsizeof()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "sizeof (| sizeof")) {
-            sizeofsizeofError(tok);
-            tok = tok->next();
-        }
-    }
-}
-
-void CheckOther::sizeofsizeofError(const Token *tok)
-{
-    reportError(tok, Severity::warning,
-                "sizeofsizeof", "Calling sizeof for 'sizeof'.\n"
-                "Calling sizeof for 'sizeof looks like a suspicious code and "
-                "most likely there should be just one 'sizeof'. The current "
-                "code is equivalent to 'sizeof(size_t)'");
-}
-
-void CheckOther::sizeofCalculation()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        if (Token::simpleMatch(tok, "sizeof (")) {
-            unsigned int parlevel = 0;
-            for (const Token *tok2 = tok->tokAt(2); tok2; tok2 = tok2->next()) {
-                if (tok2->str() == "(")
-                    ++parlevel;
-                else if (tok2->str() == ")") {
-                    if (parlevel <= 1)
-                        break;
-                    --parlevel;
-                } else if (Token::Match(tok2, "+|/")) {
-                    sizeofCalculationError(tok2);
-                    break;
-                }
-            }
-        }
-    }
-}
-
-void CheckOther::sizeofCalculationError(const Token *tok)
-{
-    reportError(tok, Severity::warning,
-                "sizeofCalculation", "Found calculation inside sizeof()");
-}
-
-void CheckOther::redundantAssignmentInSwitchError(const Token *tok, const std::string &varname)
-{
-    reportError(tok, Severity::warning,
-                "redundantAssignInSwitch", "Redundant assignment of \"" + varname + "\" in switch");
-}
-
-void CheckOther::switchCaseFallThrough(const Token *tok)
-{
-    reportError(tok, Severity::style,
-                "switchCaseFallThrough", "Switch falls through case without comment");
-}
-
-void CheckOther::selfAssignmentError(const Token *tok, const std::string &varname)
-{
-    reportError(tok, Severity::warning,
-                "selfAssignment", "Redundant assignment of \"" + varname + "\" to itself");
-}
-
-void CheckOther::assignmentInAssertError(const Token *tok, const std::string &varname)
-{
-    reportError(tok, Severity::warning,
-                "assignmentInAssert", "Assert statement modifies '" + varname + "'.\n"
-                "Variable '" + varname + "' is modified inside assert statement. "
-                "Assert statements are removed from release builds so the code inside "
-                "assert statement is not run. If the code is needed also in release "
-                "builds this is a bug.");
-}
-
-void CheckOther::incorrectLogicOperatorError(const Token *tok, bool always)
-{
-    if (always)
-        reportError(tok, Severity::warning,
-                    "incorrectLogicOperator", "Mutual exclusion over || always evaluates to true. Did you intend to use && instead?");
-    else
-        reportError(tok, Severity::warning,
-                    "incorrectLogicOperator", "Expression always evaluates to false. Did you intend to use || instead?");
-}
-
-void CheckOther::misusedScopeObjectError(const Token *tok, const std::string& varname)
-{
-    reportError(tok, Severity::error,
-                "unusedScopedObject", "instance of \"" + varname + "\" object destroyed immediately");
-}
-
-void CheckOther::catchExceptionByValueError(const Token *tok)
-{
-    reportError(tok, Severity::style,
-                "catchExceptionByValue", "Exception should be caught by reference.\n"
-                "The exception is caught as a value. It could be caught "
-                "as a (const) reference which is usually recommended in C++.");
-}
-
-void CheckOther::memsetZeroBytesError(const Token *tok, const std::string &varname)
-{
-    const std::string summary("memset() called to fill 0 bytes of \'" + varname + "\'");
-    const std::string verbose(summary + ". Second and third arguments might be inverted.");
-    reportError(tok, Severity::warning, "memsetZeroBytes", summary + "\n" + verbose);
-}
-
-void CheckOther::incorrectStringCompareError(const Token *tok, const std::string& func, const std::string &string, const std::string &len)
-{
-    reportError(tok, Severity::warning, "incorrectStringCompare", "String literal " + string + " doesn't match length argument for " + func + "(" + len + ").");
-}
-
-void CheckOther::comparisonOfBoolWithIntError(const Token *tok, const std::string &varname)
-{
-    reportError(tok, Severity::warning, "comparisonOfBoolWithInt",
-                "Comparison of a boolean with a non-zero integer\n"
-                "The expression \"!" + varname + "\" is of type 'bool' but is compared against a non-zero 'int'.");
-}
-
-void CheckOther::duplicateBreakError(const Token *tok)
-{
-    reportError(tok, Severity::style, "duplicateBreak",
-                "Consecutive break or continue statements are unnecessary\n"
-                "The second of the two statements can never be executed, and so should be removed\n");
-}
-
-
-void CheckOther::checkAssignBoolToPointer()
-{
-    for (const Token *tok = _tokenizer->tokens(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "[;{}] %var% = %bool% ;")) {
-            const SymbolDatabase *symbolDatabase = _tokenizer->getSymbolDatabase();
-
-            const Variable *var1(symbolDatabase->getVariableFromVarId(tok->next()->varId()));
-
-            // Is variable a pointer?
-            if (var1 && var1->nameToken()->strAt(-1) == "*")
-                assignBoolToPointerError(tok->next());
-        }
-    }
-}
-
-void CheckOther::assignBoolToPointerError(const Token *tok)
-{
-    reportError(tok, Severity::error, "assignBoolToPointer",
-                "Assigning bool value to pointer (converting bool value to address)");
-}
-
-//---------------------------------------------------------------------------
-// Check testing sign of unsigned variables.
-//---------------------------------------------------------------------------
-
-void CheckOther::checkSignOfUnsignedVariable()
-{
-    if (!_settings->isEnabled("style"))
-        return;
-
-    const SymbolDatabase *symbolDatabase = _tokenizer->getSymbolDatabase();
-
-    std::list<Scope>::const_iterator scope;
-
-    for (scope = symbolDatabase->scopeList.begin(); scope != symbolDatabase->scopeList.end(); ++scope) {
-        // only check functions
-        if (scope->type != Scope::eFunction)
-            continue;
-
-        // check all the code in the function
-        for (const Token *tok = scope->classStart; tok && tok != scope->classStart->link(); tok = tok->next()) {
-            if (Token::Match(tok, "( %var% <|<= 0 )") && tok->next()->varId()) {
-                const Variable * var = symbolDatabase->getVariableFromVarId(tok->next()->varId());
-                if (var && var->typeEndToken()->isUnsigned())
-                    unsignedLessThanZero(tok->next(), tok->next()->str());
-            } else if (Token::Match(tok, "( 0 > %var% )") && tok->tokAt(3)->varId()) {
-                const Variable * var = symbolDatabase->getVariableFromVarId(tok->tokAt(3)->varId());
-                if (var && var->typeEndToken()->isUnsigned())
-                    unsignedLessThanZero(tok->tokAt(3), tok->strAt(3));
-            } else if (Token::Match(tok, "( 0 <= %var% )") && tok->tokAt(3)->varId()) {
-                const Variable * var = symbolDatabase->getVariableFromVarId(tok->tokAt(3)->varId());
-                if (var && var->typeEndToken()->isUnsigned())
-                    unsignedPositive(tok->tokAt(3), tok->strAt(3));
-            }
-        }
-    }
-}
-
-void CheckOther::unsignedLessThanZero(const Token *tok, const std::string &varname)
-{
-    reportError(tok, Severity::style, "unsignedLessThanZero",
-                "Checking if unsigned variable '" + varname + "' is less than zero.\n"
-                "An unsigned variable will never be negative so it is either pointless or "
-                "an error to check if it is.");
-}
-
-void CheckOther::unsignedPositive(const Token *tok, const std::string &varname)
-{
-    reportError(tok, Severity::style, "unsignedPositive",
-                "Checking if unsigned variable '" + varname + "' is positive is always true.\n"
-                "An unsigned variable can't be negative so it is either pointless or "
-                "an error to check if it is.");
-}
diff --git a/gui/test/data/files/dir1/dir11/foo11.cpp b/gui/test/data/files/dir1/dir11/foo11.cpp
index e4294ad5e40..803876e0b05 100644
--- a/gui/test/data/files/dir1/dir11/foo11.cpp
+++ b/gui/test/data/files/dir1/dir11/foo11.cpp
@@ -1 +1 @@
-Dummy test file.
+Dummy test file .
diff --git a/gui/test/data/files/dir1/foo1.cpp b/gui/test/data/files/dir1/foo1.cpp
index e4294ad5e40..803876e0b05 100644
--- a/gui/test/data/files/dir1/foo1.cpp
+++ b/gui/test/data/files/dir1/foo1.cpp
@@ -1 +1 @@
-Dummy test file.
+Dummy test file .
diff --git a/gui/test/data/files/dir2/foo1.cpp b/gui/test/data/files/dir2/foo1.cpp
index e4294ad5e40..803876e0b05 100644
--- a/gui/test/data/files/dir2/foo1.cpp
+++ b/gui/test/data/files/dir2/foo1.cpp
@@ -1 +1 @@
-Dummy test file.
+Dummy test file .
diff --git a/gui/test/data/files/foo1.cpp b/gui/test/data/files/foo1.cpp
index e4294ad5e40..803876e0b05 100644
--- a/gui/test/data/files/foo1.cpp
+++ b/gui/test/data/files/foo1.cpp
@@ -1 +1 @@
-Dummy test file.
+Dummy test file .
diff --git a/gui/test/data/files/foo4.c b/gui/test/data/files/foo4.c
index e4294ad5e40..803876e0b05 100644
--- a/gui/test/data/files/foo4.c
+++ b/gui/test/data/files/foo4.c
@@ -1 +1 @@
-Dummy test file.
+Dummy test file .
diff --git a/gui/test/data/files/foo8.ipp b/gui/test/data/files/foo8.ipp
new file mode 100644
index 00000000000..e4294ad5e40
--- /dev/null
+++ b/gui/test/data/files/foo8.ipp
@@ -0,0 +1 @@
+Dummy test file.
diff --git a/gui/test/data/files/foo9.ixx b/gui/test/data/files/foo9.ixx
new file mode 100644
index 00000000000..e4294ad5e40
--- /dev/null
+++ b/gui/test/data/files/foo9.ixx
@@ -0,0 +1 @@
+Dummy test file.
diff --git a/gui/test/filelist/CMakeLists.txt b/gui/test/filelist/CMakeLists.txt
new file mode 100644
index 00000000000..4af40a1c876
--- /dev/null
+++ b/gui/test/filelist/CMakeLists.txt
@@ -0,0 +1,24 @@
+qt_wrap_cpp(test-filelist_SRC testfilelist.h)
+add_custom_target(build-testfilelist-deps SOURCES ${test-filelist_SRC})
+add_dependencies(gui-build-deps build-testfilelist-deps)
+add_executable(test-filelist
+        ${test-filelist_SRC}
+        testfilelist.cpp
+        ${CMAKE_SOURCE_DIR}/gui/filelist.cpp
+        )
+target_include_directories(test-filelist PRIVATE ${CMAKE_SOURCE_DIR}/gui)
+target_compile_definitions(test-filelist PRIVATE SRCDIR="${CMAKE_CURRENT_SOURCE_DIR}")
+target_link_libraries(test-filelist ${QT_CORE_LIB} ${QT_TEST_LIB} cppcheck-core simplecpp)
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    if(QT_VERSION VERSION_GREATER_EQUAL "6.9.0")
+        # caused by Qt generated moc code starting with 6.9.0 - see https://bugreports.qt.io/browse/QTBUG-135638
+        target_compile_options_safe(test-filelist -Wno-ctad-maybe-unsupported)
+    endif()
+endif()
+
+if (REGISTER_GUI_TESTS)
+    add_test(NAME test-filelist COMMAND $<TARGET_FILE:test-filelist>)
+endif()
+
+add_dependencies(gui-tests test-filelist)
diff --git a/gui/test/filelist/filelist.pro b/gui/test/filelist/filelist.pro
deleted file mode 100644
index 52adfcbd2de..00000000000
--- a/gui/test/filelist/filelist.pro
+++ /dev/null
@@ -1,24 +0,0 @@
-TEMPLATE = app
-TARGET = test-filelist
-DEPENDPATH += .
-INCLUDEPATH += . ../../../externals/simplecpp
-OBJECTS_DIR = ../build
-MOC_DIR = ../build
-QT += testlib
-
-include(../common.pri)
-
-DEFINES += SRCDIR=\\\"$$PWD\\\"
-
-# tests
-SOURCES += testfilelist.cpp \
-    ../../filelist.cpp \
-    ../../../lib/pathmatch.cpp \
-    ../../../lib/path.cpp \
-    ../../../externals/simplecpp/simplecpp.cpp
-
-HEADERS += testfilelist.h \
-    ../../filelist.h \
-    ../../../lib/pathmatch.h \
-    ../../../lib/path.h \
-    ../../../externals/simplecpp/simplecpp.h
diff --git a/gui/test/filelist/testfilelist.cpp b/gui/test/filelist/testfilelist.cpp
index 8a790646c00..d24b766bcc3 100644
--- a/gui/test/filelist/testfilelist.cpp
+++ b/gui/test/filelist/testfilelist.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2021 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,15 +16,18 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QObject>
-#include <QDir>
-#include <QString>
 #include "testfilelist.h"
+
 #include "filelist.h"
 
-void TestFileList::addFile()
+#include <QDir>
+#include <QString>
+#include <QStringList>
+#include <QtTest>
+
+void TestFileList::addFile() const
 {
-    // Accepted extensions: *.cpp, *.cxx, *.cc, *.c, *.c++, *.txx, *.tpp"
+    // Accepted extensions: *.cpp, *.cxx, *.cc, *.c, *.c++, *.txx, *.tpp, *.ipp, *.ixx"
     FileList list;
     list.addFile(QString(SRCDIR) + "/../data/files/foo1.cpp");
     list.addFile(QString(SRCDIR) + "/../data/files/foo2.cxx");
@@ -33,13 +36,15 @@ void TestFileList::addFile()
     list.addFile(QString(SRCDIR) + "/../data/files/foo5.c++");
     list.addFile(QString(SRCDIR) + "/../data/files/foo6.txx");
     list.addFile(QString(SRCDIR) + "/../data/files/foo7.tpp");
+    list.addFile(QString(SRCDIR) + "/../data/files/foo8.ipp");
+    list.addFile(QString(SRCDIR) + "/../data/files/foo9.ixx");
     QStringList files = list.getFileList();
-    QCOMPARE(files.size(), 7);
+    QCOMPARE(files.size(), 9);
 }
 
-void TestFileList::addPathList()
+void TestFileList::addPathList() const
 {
-    // Accepted extensions: *.cpp, *.cxx, *.cc, *.c, *.c++, *.txx, *.tpp"
+    // Accepted extensions: *.cpp, *.cxx, *.cc, *.c, *.c++, *.txx, *.tpp, *.ipp, *.ixx"
     QStringList paths;
     paths << QString(SRCDIR) + "/../data/files/foo1.cpp";
     paths << QString(SRCDIR) + "/../data/files/foo2.cxx";
@@ -48,13 +53,15 @@ void TestFileList::addPathList()
     paths << QString(SRCDIR) + "/../data/files/foo5.c++";
     paths << QString(SRCDIR) + "/../data/files/foo6.txx";
     paths << QString(SRCDIR) + "/../data/files/foo7.tpp";
+    paths << QString(SRCDIR) + "/../data/files/foo8.ipp";
+    paths << QString(SRCDIR) + "/../data/files/foo9.ixx";
     FileList list;
     list.addPathList(paths);
     QStringList files = list.getFileList();
-    QCOMPARE(files.size(), 7);
+    QCOMPARE(files.size(), 9);
 }
 
-void TestFileList::addFile_notexist()
+void TestFileList::addFile_notexist() const
 {
     FileList list;
     list.addFile(QString(SRCDIR) + "/../data/files/bar1.cpp");
@@ -62,7 +69,7 @@ void TestFileList::addFile_notexist()
     QCOMPARE(files.size(), 0);
 }
 
-void TestFileList::addFile_unknown()
+void TestFileList::addFile_unknown() const
 {
     FileList list;
     list.addFile(QString(SRCDIR) + "/../data/files/bar1");
@@ -71,20 +78,20 @@ void TestFileList::addFile_unknown()
     QCOMPARE(files.size(), 0);
 }
 
-void TestFileList::addDirectory()
+void TestFileList::addDirectory() const
 {
     FileList list;
     list.addDirectory(QString(SRCDIR) + "/../data/files");
     QStringList files = list.getFileList();
-    QCOMPARE(files.size(), 7);
+    QCOMPARE(files.size(), 9);
 }
 
-void TestFileList::addDirectory_recursive()
+void TestFileList::addDirectory_recursive() const
 {
     FileList list;
     list.addDirectory(QString(SRCDIR) + "/../data/files", true);
     QStringList files = list.getFileList();
-    QCOMPARE(files.size(), 10);
+    QCOMPARE(files.size(), 12);
     QDir dir(QString(SRCDIR) + "/../data/files");
     QString base = dir.canonicalPath();
     QVERIFY(files.contains(base + "/dir1/foo1.cpp"));
@@ -92,7 +99,7 @@ void TestFileList::addDirectory_recursive()
     QVERIFY(files.contains(base + "/dir2/foo1.cpp"));
 }
 
-void TestFileList::filterFiles()
+void TestFileList::filterFiles() const
 {
     FileList list;
     QStringList filters;
@@ -105,15 +112,17 @@ void TestFileList::filterFiles()
     list.addFile(QString(SRCDIR) + "/../data/files/foo5.c++");
     list.addFile(QString(SRCDIR) + "/../data/files/foo6.txx");
     list.addFile(QString(SRCDIR) + "/../data/files/foo7.tpp");
+    list.addFile(QString(SRCDIR) + "/../data/files/foo8.ipp");
+    list.addFile(QString(SRCDIR) + "/../data/files/foo9.ixx");
     QStringList files = list.getFileList();
-    QCOMPARE(files.size(), 5);
+    QCOMPARE(files.size(), 7);
     QDir dir(QString(SRCDIR) + "/../data/files");
     QString base = dir.canonicalPath();
-    QVERIFY(! files.contains(base + "/foo1.cpp"));
-    QVERIFY(! files.contains(base + "/foo3.cpp"));
+    QVERIFY(!files.contains(base + "/foo1.cpp"));
+    QVERIFY(!files.contains(base + "/foo3.cpp"));
 }
 
-void TestFileList::filterFiles2()
+void TestFileList::filterFiles2() const
 {
     FileList list;
     QStringList filters;
@@ -121,14 +130,14 @@ void TestFileList::filterFiles2()
     list.addExcludeList(filters);
     list.addDirectory(QString(SRCDIR) + "/../data/files");
     QStringList files = list.getFileList();
-    QCOMPARE(files.size(), 5);
+    QCOMPARE(files.size(), 7);
     QDir dir(QString(SRCDIR) + "/../data/files");
     QString base = dir.canonicalPath();
-    QVERIFY(! files.contains(base + "/foo1.cpp"));
-    QVERIFY(! files.contains(base + "/foo3.cpp"));
+    QVERIFY(!files.contains(base + "/foo1.cpp"));
+    QVERIFY(!files.contains(base + "/foo3.cpp"));
 }
 
-void TestFileList::filterFiles3()
+void TestFileList::filterFiles3() const
 {
     FileList list;
     QStringList filters;
@@ -136,16 +145,16 @@ void TestFileList::filterFiles3()
     list.addExcludeList(filters);
     list.addDirectory(QString(SRCDIR) + "/../data/files", true);
     QStringList files = list.getFileList();
-    QCOMPARE(files.size(), 6);
+    QCOMPARE(files.size(), 8);
     QDir dir(QString(SRCDIR) + "/../data/files");
     QString base = dir.canonicalPath();
-    QVERIFY(! files.contains(base + "/foo1.cpp"));
-    QVERIFY(! files.contains(base + "/foo3.cpp"));
-    QVERIFY(! files.contains(base + "/dir1/foo1.cpp"));
-    QVERIFY(! files.contains(base + "/dir2/foo1.cpp"));
+    QVERIFY(!files.contains(base + "/foo1.cpp"));
+    QVERIFY(!files.contains(base + "/foo3.cpp"));
+    QVERIFY(!files.contains(base + "/dir1/foo1.cpp"));
+    QVERIFY(!files.contains(base + "/dir2/foo1.cpp"));
 }
 
-void TestFileList::filterFiles4()
+void TestFileList::filterFiles4() const
 {
     FileList list;
     QStringList filters;
@@ -153,14 +162,14 @@ void TestFileList::filterFiles4()
     list.addExcludeList(filters);
     list.addDirectory(QString(SRCDIR) + "/../data/files", true);
     QStringList files = list.getFileList();
-    QCOMPARE(files.size(), 8);
+    QCOMPARE(files.size(), 10);
     QDir dir(QString(SRCDIR) + "/../data/files");
     QString base = dir.canonicalPath();
-    QVERIFY(! files.contains(base + "/dir1/foo1.cpp"));
-    QVERIFY(! files.contains(base + "/dir1/dir11/foo11.cpp"));
+    QVERIFY(!files.contains(base + "/dir1/foo1.cpp"));
+    QVERIFY(!files.contains(base + "/dir1/dir11/foo11.cpp"));
 }
-/*
-void TestFileList::filterFiles5()
+
+void TestFileList::filterFiles5() const
 {
     FileList list;
     QStringList filters;
@@ -168,11 +177,11 @@ void TestFileList::filterFiles5()
     list.addExcludeList(filters);
     list.addDirectory(QString(SRCDIR) + "/../data/files", true);
     QStringList files = list.getFileList();
-    QCOMPARE(files.size(), 8);
+    QCOMPARE(files.size(), 10);
     QDir dir(QString(SRCDIR) + "/../data/files");
     QString base = dir.canonicalPath();
-    QVERIFY(! files.contains(base + "/dir1/foo1.cpp"));
-    QVERIFY(! files.contains(base + "/dir1/dir11/foo11.cpp"));
+    QVERIFY(!files.contains(base + "/dir1/foo1.cpp"));
+    QVERIFY(!files.contains(base + "/dir1/dir11/foo11.cpp"));
 }
-*/
+
 QTEST_MAIN(TestFileList)
diff --git a/gui/test/filelist/testfilelist.h b/gui/test/filelist/testfilelist.h
index c02a3dfb4e0..17a33d86e3e 100644
--- a/gui/test/filelist/testfilelist.h
+++ b/gui/test/filelist/testfilelist.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2021 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,21 +16,21 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QtTest/QtTest>
 #include <QObject>
 
-class TestFileList: public QObject {
+class TestFileList : public QObject {
     Q_OBJECT
 
 private slots:
-    void addFile();
-    void addPathList();
-    void addFile_notexist();
-    void addFile_unknown();
-    void addDirectory();
-    void addDirectory_recursive();
-    void filterFiles();
-    void filterFiles2();
-    void filterFiles3();
-    void filterFiles4();
+    void addFile() const;
+    void addPathList() const;
+    void addFile_notexist() const;
+    void addFile_unknown() const;
+    void addDirectory() const;
+    void addDirectory_recursive() const;
+    void filterFiles() const;
+    void filterFiles2() const;
+    void filterFiles3() const;
+    void filterFiles4() const;
+    void filterFiles5() const;
 };
diff --git a/gui/test/projectfile/CMakeLists.txt b/gui/test/projectfile/CMakeLists.txt
new file mode 100644
index 00000000000..f9bab8ba0c7
--- /dev/null
+++ b/gui/test/projectfile/CMakeLists.txt
@@ -0,0 +1,25 @@
+qt_wrap_cpp(test-projectfile_SRC testprojectfile.h ${CMAKE_SOURCE_DIR}/gui/projectfile.h)
+add_custom_target(build-projectfile-deps SOURCES ${test-projectfile_SRC})
+add_dependencies(gui-build-deps build-projectfile-deps)
+add_executable(test-projectfile
+        ${test-projectfile_SRC}
+        testprojectfile.cpp
+        ${CMAKE_SOURCE_DIR}/gui/common.cpp
+        ${CMAKE_SOURCE_DIR}/gui/projectfile.cpp
+        )
+target_include_directories(test-projectfile PRIVATE ${CMAKE_SOURCE_DIR}/gui ${CMAKE_SOURCE_DIR}/lib)
+target_compile_definitions(test-projectfile PRIVATE SRCDIR="${CMAKE_CURRENT_SOURCE_DIR}")
+target_link_libraries(test-projectfile ${QT_CORE_LIB} ${QT_TEST_LIB})
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    if(QT_VERSION VERSION_GREATER_EQUAL "6.9.0")
+        # caused by Qt generated moc code starting with 6.9.0 - see https://bugreports.qt.io/browse/QTBUG-135638
+        target_compile_options_safe(test-projectfile -Wno-ctad-maybe-unsupported)
+    endif()
+endif()
+
+if (REGISTER_GUI_TESTS)
+    add_test(NAME test-projectfile COMMAND $<TARGET_FILE:test-projectfile>)
+endif()
+
+add_dependencies(gui-tests test-projectfile)
\ No newline at end of file
diff --git a/gui/test/projectfile/projectfile.pro b/gui/test/projectfile/projectfile.pro
deleted file mode 100644
index 5a6c7fdd54b..00000000000
--- a/gui/test/projectfile/projectfile.pro
+++ /dev/null
@@ -1,24 +0,0 @@
-TEMPLATE = app
-TARGET = test-projectfile
-DEPENDPATH += .
-INCLUDEPATH += . ../../../externals/simplecpp
-OBJECTS_DIR = ../build
-MOC_DIR = ../build
-QT -= gui
-QT += core
-CONFIG += console
-
-include(../common.pri)
-
-DEFINES += SRCDIR=\\\"$$PWD\\\"
-
-# tests
-SOURCES += testprojectfile.cpp \
-    ../../projectfile.cpp \
-    ../../../lib/path.cpp \
-    ../../../externals/simplecpp/simplecpp.cpp
-
-HEADERS += testprojectfile.h \
-    ../../projectfile.h \
-    ../../../lib/path.h \
-    ../../../externals/simplecpp/simplecpp.h
diff --git a/gui/test/projectfile/testprojectfile.cpp b/gui/test/projectfile/testprojectfile.cpp
index d6a6ea12f7f..b38de056ec3 100644
--- a/gui/test/projectfile/testprojectfile.cpp
+++ b/gui/test/projectfile/testprojectfile.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2021 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,10 +16,20 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QObject>
 #include "testprojectfile.h"
+
+#include "library.h"
+#include "platform.h"
 #include "projectfile.h"
 #include "settings.h"
+#include "suppressions.h"
+
+#include <QFile>
+#include <QIODevice>
+#include <QList>
+#include <QStringList>
+#include <QTemporaryDir>
+#include <QtTest>
 
 // Mock...
 const char Settings::SafeChecks::XmlRootName[] = "safe-checks";
@@ -27,15 +37,20 @@ const char Settings::SafeChecks::XmlClasses[] = "class-public";
 const char Settings::SafeChecks::XmlExternalFunctions[] = "external-functions";
 const char Settings::SafeChecks::XmlInternalFunctions[] = "internal-functions";
 const char Settings::SafeChecks::XmlExternalVariables[] = "external-variables";
+Settings::Settings() : maxCtuDepth(10) {}
+Platform::Platform() = default;
+Library::Library() = default;
+Library::~Library() = default;
+struct Library::LibraryData {};
 
-void TestProjectFile::loadInexisting()
+void TestProjectFile::loadInexisting() const
 {
     const QString filepath(QString(SRCDIR) + "/../data/projectfiles/foo.cppcheck");
     ProjectFile pfile(filepath);
     QCOMPARE(pfile.read(), false);
 }
 
-void TestProjectFile::loadSimple()
+void TestProjectFile::loadSimple() const
 {
     const QString filepath(QString(SRCDIR) + "/../data/projectfiles/simple.cppcheck");
     ProjectFile pfile(filepath);
@@ -58,7 +73,7 @@ void TestProjectFile::loadSimple()
 }
 
 // Test that project file with old 'ignore' element works
-void TestProjectFile::loadSimpleWithIgnore()
+void TestProjectFile::loadSimpleWithIgnore() const
 {
     const QString filepath(QString(SRCDIR) + "/../data/projectfiles/simple_ignore.cppcheck");
     ProjectFile pfile(filepath);
@@ -80,7 +95,7 @@ void TestProjectFile::loadSimpleWithIgnore()
     QCOMPARE(defines[0], QString("FOO"));
 }
 
-void TestProjectFile::loadSimpleNoroot()
+void TestProjectFile::loadSimpleNoroot() const
 {
     const QString filepath(QString(SRCDIR) + "/../data/projectfiles/simple_noroot.cppcheck");
     ProjectFile pfile(filepath);
@@ -102,4 +117,87 @@ void TestProjectFile::loadSimpleNoroot()
     QCOMPARE(defines[0], QString("FOO"));
 }
 
+void TestProjectFile::getAddonFilePath() const
+{
+    QTemporaryDir tempdir;
+    QVERIFY(tempdir.isValid());
+    const QString filepath(tempdir.path() + "/addon.py");
+
+    QFile file(filepath);
+    QVERIFY(file.open(QIODevice::WriteOnly | QIODevice::Text));
+    file.close();
+
+    // Relative path to addon
+    QCOMPARE(ProjectFile::getAddonFilePath(tempdir.path(), "addon"), filepath);
+    QCOMPARE(ProjectFile::getAddonFilePath(tempdir.path(), "not exist"), QString());
+
+    // Absolute path to addon
+    QCOMPARE(ProjectFile::getAddonFilePath("/not/exist", filepath), filepath);
+    QCOMPARE(ProjectFile::getAddonFilePath(tempdir.path(), filepath), filepath);
+}
+
+void TestProjectFile::getSearchPaths() const
+{
+#ifdef FILESDIR
+    const QString f(FILESDIR "\n"        // example: "/usr/local/share/cppcheck\n"
+                    FILESDIR "/dir\n");  // example: "/usr/local/share/cppcheck/dir\n"
+#else
+    const QString f;
+#endif
+
+    QCOMPARE(ProjectFile::getSearchPaths("projectPath", "appPath", "datadir", "dir").join("\n"),
+             "appPath\n"
+             "appPath/dir\n"
+             "projectPath\n" +
+             f +
+             "datadir\n"
+             "datadir/dir");
+}
+
+void TestProjectFile::getInlineSuppressionDefaultValue() const
+{
+    ProjectFile projectFile;
+    projectFile.setFilename("/some/path/123.cppcheck");
+    QCOMPARE(projectFile.getInlineSuppression(), true);
+}
+
+void TestProjectFile::getInlineSuppression() const
+{
+    ProjectFile projectFile;
+    projectFile.setFilename("/some/path/123.cppcheck");
+    projectFile.setInlineSuppression(false);
+    QCOMPARE(projectFile.getInlineSuppression(), false);
+}
+
+void TestProjectFile::getCheckingSuppressionsRelative() const
+{
+    const SuppressionList::Suppression suppression("*", "externals/*");
+    const QList<SuppressionList::Suppression> suppressions{suppression};
+    ProjectFile projectFile;
+    projectFile.setFilename("/some/path/123.cppcheck");
+    projectFile.setSuppressions(suppressions);
+    QCOMPARE(projectFile.getCheckingSuppressions()[0].fileName, "/some/path/externals/*");
+}
+
+void TestProjectFile::getCheckingSuppressionsAbsolute() const
+{
+    const SuppressionList::Suppression suppression("*", "/some/path/1.h");
+    const QList<SuppressionList::Suppression> suppressions{suppression};
+    ProjectFile projectFile;
+    projectFile.setFilename("/other/123.cppcheck");
+    projectFile.setSuppressions(suppressions);
+    QCOMPARE(projectFile.getCheckingSuppressions()[0].fileName, "/some/path/1.h");
+}
+
+void TestProjectFile::getCheckingSuppressionsStar() const
+{
+    const SuppressionList::Suppression suppression("*", "*.cpp");
+    const QList<SuppressionList::Suppression> suppressions{suppression};
+    ProjectFile projectFile;
+    projectFile.setFilename("/some/path/123.cppcheck");
+    projectFile.setSuppressions(suppressions);
+    QCOMPARE(projectFile.getCheckingSuppressions()[0].fileName, "*.cpp");
+}
+
 QTEST_MAIN(TestProjectFile)
+
diff --git a/gui/test/projectfile/testprojectfile.h b/gui/test/projectfile/testprojectfile.h
index dddc5eb714e..027c7069706 100644
--- a/gui/test/projectfile/testprojectfile.h
+++ b/gui/test/projectfile/testprojectfile.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2021 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,15 +16,24 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QtTest/QtTest>
 #include <QObject>
 
-class TestProjectFile: public QObject {
+class TestProjectFile : public QObject {
     Q_OBJECT
 
 private slots:
-    void loadInexisting();
-    void loadSimple();
-    void loadSimpleWithIgnore();
-    void loadSimpleNoroot();
+    void loadInexisting() const;
+    void loadSimple() const;
+    void loadSimpleWithIgnore() const;
+    void loadSimpleNoroot() const;
+
+    void getAddonFilePath() const;
+    void getSearchPaths() const;
+
+    void getInlineSuppressionDefaultValue() const;
+    void getInlineSuppression() const;
+
+    void getCheckingSuppressionsRelative() const;
+    void getCheckingSuppressionsAbsolute() const;
+    void getCheckingSuppressionsStar() const;
 };
diff --git a/gui/test/readme.txt b/gui/test/readme.txt
deleted file mode 100644
index 4421bc02fd9..00000000000
--- a/gui/test/readme.txt
+++ /dev/null
@@ -1,27 +0,0 @@
-GUI tests + benchmark tests
-===========================
-
-As the GUI uses Qt framework, the GUI tests also use Qt's Testlib. This is
-totally different test framework than lib/cli is using. By principle each
-testcase is compiled as an own runnable binary.
-
-Compiling
----------
-
-To compile all the tests run in root directory of tests:
- - qmake ; make
-
-You can also (re)compile single test by CD:ing to the directory where test
-(source) resides and running:
- - qmake ; make
-
-Running
--------
-
-As each test is compiled as single executable binary you can run the test just
-by running the executable.
-
-You can get from
- http://bitbucket.org/kimmov/testrun
-a script which runs all the tests and collects the results.
-
diff --git a/gui/test/resultstree/CMakeLists.txt b/gui/test/resultstree/CMakeLists.txt
new file mode 100644
index 00000000000..a48b137e349
--- /dev/null
+++ b/gui/test/resultstree/CMakeLists.txt
@@ -0,0 +1,57 @@
+qt_wrap_cpp(test-resultstree_SRC
+        testresultstree.h
+        ${CMAKE_SOURCE_DIR}/gui/resultstree.h
+        ${CMAKE_SOURCE_DIR}/gui/resultitem.h
+        ${CMAKE_SOURCE_DIR}/gui/applicationlist.h
+        ${CMAKE_SOURCE_DIR}/gui/common.h
+        ${CMAKE_SOURCE_DIR}/gui/projectfile.h
+        ${CMAKE_SOURCE_DIR}/gui/threadhandler.h
+        ${CMAKE_SOURCE_DIR}/gui/threadresult.h
+)
+add_custom_target(build-resultstree-deps SOURCES ${test-resultstree_SRC})
+add_dependencies(gui-build-deps build-resultstree-deps)
+add_executable(test-resultstree
+        ${test-resultstree_SRC}
+        testresultstree.cpp
+        ${CMAKE_SOURCE_DIR}/gui/resultstree.cpp
+        ${CMAKE_SOURCE_DIR}/gui/resultitem.cpp
+        ${CMAKE_SOURCE_DIR}/gui/common.cpp
+        ${CMAKE_SOURCE_DIR}/gui/erroritem.cpp
+        ${CMAKE_SOURCE_DIR}/gui/showtypes.cpp
+        ${CMAKE_SOURCE_DIR}/gui/report.cpp
+        ${CMAKE_SOURCE_DIR}/gui/xmlreportv2.cpp
+        )
+target_include_directories(test-resultstree PRIVATE ${CMAKE_SOURCE_DIR}/gui)
+target_link_libraries(test-resultstree cppcheck-core simplecpp tinyxml2)
+if (HAVE_RULES)
+    target_link_libraries(test-resultstree ${PCRE_LIBRARY})
+    target_include_directories(test-resultstree SYSTEM PRIVATE ${PCRE_INCLUDE})
+endif()
+target_compile_definitions(test-resultstree PRIVATE SRCDIR="${CMAKE_CURRENT_SOURCE_DIR}")
+target_link_libraries(test-resultstree ${QT_CORE_LIB} ${QT_GUI_LIB} ${QT_WIDGETS_LIB} ${QT_TEST_LIB})
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    if(QT_VERSION VERSION_GREATER_EQUAL "6.9.0")
+        # caused by Qt generated moc code starting with 6.9.0 - see https://bugreports.qt.io/browse/QTBUG-135638
+        target_compile_options_safe(test-resultstree -Wno-ctad-maybe-unsupported)
+    endif()
+    # caused by mocks
+    target_compile_options_safe(test-resultstree -Wno-missing-noreturn)
+elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    # caused by mocs
+    target_compile_options_safe(test-resultstree -Wno-useless-cast)
+    # caused by mocks
+    target_compile_options_safe(test-resultstree -Wno-suggest-attribute=noreturn)
+endif()
+
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    # caused by mocks
+    target_compile_options_safe(test-resultstree -Wno-suggest-attribute=noreturn)
+endif()
+
+if (REGISTER_GUI_TESTS)
+    # TODO: might crash - see #13223
+    #add_test(NAME test-resultstree COMMAND $<TARGET_FILE:test-resultstree> -platform offscreen)
+endif()
+
+add_dependencies(gui-tests test-resultstree)
diff --git a/gui/test/resultstree/testresultstree.cpp b/gui/test/resultstree/testresultstree.cpp
new file mode 100644
index 00000000000..afda38e0075
--- /dev/null
+++ b/gui/test/resultstree/testresultstree.cpp
@@ -0,0 +1,404 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2021 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "testresultstree.h"
+
+#include "resultstree.h"
+
+// headers that declare mocked functions/variables
+#include "applicationlist.h"
+#include "common.h"
+#include "filesettings.h"
+#include "projectfile.h"
+#include "threadhandler.h"
+#include "threadresult.h"
+
+#include "application.h"
+#include "checkers.h"
+#include "erroritem.h"
+#include "errorlogger.h"
+#include "errortypes.h"
+#include "report.h"
+#include "resultitem.h"
+#include "showtypes.h"
+#include "suppressions.h"
+#include "xmlreport.h"
+
+#include <cstddef>
+#include <string>
+#include <utility>
+
+#include <QList>
+#include <QModelIndex>
+#include <QString>
+#include <QtTest>
+
+class TestReport : public Report {
+public:
+    explicit TestReport(QString format) : Report(QString()), format(std::move(format)) {}
+    void writeHeader() override {
+        output.clear();
+    }
+    void writeFooter() override {}
+    void writeError(const ErrorItem &error) override {
+        QString line = format;
+        line.replace("{id}", error.errorId);
+        line.replace("{classification}", error.classification);
+        line.replace("{guideline}", error.guideline);
+        output += (output.isEmpty() ? "" : "\n") + line;
+    }
+    QString format;
+    QString output;
+};
+
+// Mock GUI...
+ProjectFile::ProjectFile(QObject *parent) : QObject(parent) {}
+ProjectFile *ProjectFile::mActiveProject;
+void ProjectFile::addSuppression(const SuppressionList::Suppression & /*unused*/) {}
+QString ProjectFile::getWarningTags(std::size_t /*unused*/) const {
+    return QString();
+}
+void ProjectFile::setWarningTags(std::size_t /*unused*/, const QString& /*unused*/) {}
+bool ProjectFile::write(const QString & /*unused*/) {
+    return true;
+}
+ApplicationList::ApplicationList(QObject *parent) : QObject(parent) {}
+ApplicationList::~ApplicationList() = default;
+int ApplicationList::getApplicationCount() const {
+    return 0;
+}
+ThreadHandler::ThreadHandler(QObject *parent) : QObject(parent) {}
+ThreadHandler::~ThreadHandler() = default;
+bool ThreadHandler::isChecking() const {
+    return false;
+}
+void ThreadHandler::stop() {
+    throw 1;
+}
+void ThreadHandler::threadDone() {
+    throw 1;
+}
+// NOLINTBEGIN(performance-unnecessary-value-param)
+void ThreadHandler::startCheck(CheckThread::Details /*unused*/) {
+    throw 1;
+}
+void ThreadHandler::finishCheck(CheckThread::Details /*unused*/) {
+    throw 1;
+}
+// NOLINTEND(performance-unnecessary-value-param)
+Application& ApplicationList::getApplication(const int /*unused*/) {
+    throw 1;
+}
+const Application& ApplicationList::getApplication(const int index) const {
+    return mApplications.at(index);
+}
+QString XmlReport::quoteMessage(const QString &message) {
+    return message;
+}
+QString XmlReport::unquoteMessage(const QString &message) {
+    return message;
+}
+XmlReport::XmlReport(const QString& filename) : Report(filename) {}
+// NOLINTNEXTLINE(performance-unnecessary-value-param)
+void ThreadResult::finishCheck(CheckThread::Details /*unused*/) {
+    throw 1;
+}
+void ThreadResult::reportOut(const std::string & /*unused*/, Color /*unused*/) {
+    throw 1;
+}
+void ThreadResult::reportErr(const ErrorMessage & /*unused*/) {
+    throw 1;
+}
+void ThreadResult::reportProgress(const std::string &/*filename*/, const char /*stage*/[], const std::size_t /*value*/) {
+    throw 1;
+}
+
+// Test...
+
+void TestResultsTree::test1() const
+{
+    // #12772 : GUI: information messages are shown even though information tool button is deselected
+    ResultsTree tree(nullptr);
+    tree.showResults(ShowTypes::ShowType::ShowInformation, false);
+    ErrorItem errorItem;
+    errorItem.errorPath << QErrorPathItem();
+    errorItem.severity = Severity::information;
+    tree.addErrorItem(errorItem);
+    QCOMPARE(tree.isRowHidden(0,QModelIndex()), true);  // Added item is hidden
+    tree.showResults(ShowTypes::ShowType::ShowInformation, true);
+    QCOMPARE(tree.isRowHidden(0,QModelIndex()), false); // Show item
+}
+
+void TestResultsTree::duplicateResults() const
+{
+    // #14359 - filter out duplicate warnings
+    ResultsTree tree(nullptr);
+
+    ErrorItem errorItem;
+    errorItem.summary = errorItem.message = "test";
+    errorItem.severity = Severity::error;
+    errorItem.errorPath << QErrorPathItem();
+    QVERIFY(tree.addErrorItem(errorItem));
+    QVERIFY(!tree.addErrorItem(errorItem));
+}
+
+static QErrorPathItem createErrorPathItem(QString file, int line, int column, QString info) {
+    QErrorPathItem ret;
+    ret.file = std::move(file);
+    ret.line = line;
+    ret.column = column;
+    ret.info = std::move(info);
+    return ret;
+}
+
+static ErrorItem createErrorItem(const QString& file, int line, Severity sev, const QString& message, QString id) {
+    ErrorItem ret;
+    ret.errorId = std::move(id);
+    ret.severity = sev;
+    ret.cwe = ret.hash = 0;
+    ret.file0 = file;
+    ret.inconclusive = false;
+    ret.message = ret.summary = message;
+    ret.errorPath << createErrorPathItem(file, line, 1, message);
+    return ret;
+}
+
+void TestResultsTree::multiLineResult() const
+{
+    // Create tree with 1 multiline message
+    ResultsTree tree(nullptr);
+    ErrorItem errorItem = createErrorItem("file1.c", 10, Severity::style, "test", "bugId");
+    errorItem.errorPath << createErrorPathItem("file2.c", 23, 2, "abc");
+    tree.addErrorItem(errorItem);
+
+    // Verify model
+    const auto* model = dynamic_cast<QStandardItemModel*>(tree.model());
+    QVERIFY(model != nullptr);
+    QVERIFY(model->rowCount() == 1);
+
+    // Verify file item
+    const ResultItem* fileItem = dynamic_cast<ResultItem*>(model->item(0,0));
+    QVERIFY(fileItem != nullptr);
+    QCOMPARE(fileItem->getType(), ResultItem::Type::file);
+    QCOMPARE(fileItem->text(), "file2.c");
+    QCOMPARE(fileItem->getErrorPathItem().file, "file2.c");
+    QVERIFY(fileItem->rowCount() == 1);
+
+    // Verify message item
+    const ResultItem* res = dynamic_cast<ResultItem*>(fileItem->child(0,0));
+    QVERIFY(res != nullptr);
+    QCOMPARE(res->text(), "file2.c");
+    QVERIFY(res->errorItem != nullptr);
+    QCOMPARE(res->errorItem->toString(),
+             "file2.c:23:2:style: test [bugId]\n"
+             "file1.c:10:1:note: test\n"
+             "file2.c:23:2:note: abc");
+    QCOMPARE(res->getErrorPathItem().file, "file2.c");
+    QVERIFY(res->rowCount() == 2);
+    QVERIFY(res->columnCount() > 5);
+    // Verify both notes
+    for (int row = 0; row < 2; ++row) {
+        for (int col = 0; col < res->columnCount(); ++col) {
+            const ResultItem* item = dynamic_cast<ResultItem*>(res->child(row,col));
+            QVERIFY(item);
+            QCOMPARE(item->errorItem.get(), res->errorItem.get());
+            QCOMPARE(item->getType(), ResultItem::Type::note);
+            QCOMPARE(item->getErrorPathItem().file, row == 0 ? "file1.c" : "file2.c");
+        }
+    }
+}
+
+void TestResultsTree::resultsInSameFile() const
+{
+    ResultsTree tree(nullptr);
+    tree.addErrorItem(createErrorItem("file1.c", 10, Severity::style, "test", "bugId"));
+    tree.addErrorItem(createErrorItem("file1.c", 20, Severity::style, "test", "bugId"));
+    const auto* model = dynamic_cast<QStandardItemModel*>(tree.model());
+    QVERIFY(model != nullptr);
+    QVERIFY(model->rowCount() == 1);
+
+    const ResultItem* fileItem = dynamic_cast<ResultItem*>(model->item(0,0));
+    QVERIFY(fileItem != nullptr);
+    QCOMPARE(fileItem->getType(), ResultItem::Type::file);
+    QCOMPARE(fileItem->text(), "file1.c");
+    QCOMPARE(fileItem->getErrorPathItem().file, "file1.c");
+    QVERIFY(fileItem->rowCount() == 2);
+
+    const ResultItem* res1 = dynamic_cast<ResultItem*>(fileItem->child(0,0));
+    QVERIFY(res1 != nullptr);
+    QCOMPARE(res1->text(), "file1.c");
+    QVERIFY(res1->errorItem != nullptr);
+    QCOMPARE(res1->errorItem->toString(), "file1.c:10:1:style: test [bugId]");
+    QVERIFY(res1->rowCount() == 0);
+    for (int col = 0; col < fileItem->columnCount(); ++col) {
+        const ResultItem* item = dynamic_cast<ResultItem*>(fileItem->child(0,col));
+        QVERIFY(item);
+        QCOMPARE(item->errorItem.get(), res1->errorItem.get());
+        QCOMPARE(item->getType(), ResultItem::Type::message);
+    }
+
+    const ResultItem* res2 = dynamic_cast<ResultItem*>(fileItem->child(1,0));
+    QVERIFY(res2 != nullptr);
+    QCOMPARE(res2->text(), "file1.c");
+    QVERIFY(res2->errorItem != nullptr);
+    QCOMPARE(res2->errorItem->toString(), "file1.c:20:1:style: test [bugId]");
+    QVERIFY(res2->rowCount() == 0);
+    for (int col = 0; col < fileItem->columnCount(); ++col) {
+        const ResultItem* item = dynamic_cast<ResultItem*>(fileItem->child(1,col));
+        QVERIFY(item);
+        QCOMPARE(item->errorItem.get(), res2->errorItem.get());
+        QCOMPARE(item->getType(), ResultItem::Type::message);
+    }
+}
+
+void TestResultsTree::testReportType() const
+{
+    TestReport report("{id},{classification},{guideline}");
+
+    int msgCount = 0;
+    auto createErrorItem = [&msgCount](const Severity severity, const QString& errorId) -> ErrorItem {
+        ++msgCount;
+        ErrorItem errorItem;
+        errorItem.errorPath << QErrorPathItem(ErrorMessage::FileLocation("file1.c", msgCount, 1));
+        errorItem.severity = severity;
+        errorItem.errorId = errorId;
+        errorItem.summary = "test summary " + QString::number(msgCount);
+        return errorItem;
+    };
+
+    // normal report with 2 errors
+    ResultsTree tree(nullptr);
+    tree.updateSettings(false, false, false, false, false);
+    tree.addErrorItem(createErrorItem(Severity::style, "id1"));
+    tree.addErrorItem(createErrorItem(Severity::style, "unusedVariable")); // Misra C 2.8
+    tree.saveResults(&report);
+    QCOMPARE(report.output, "id1,,\nunusedVariable,,");
+
+    // switch to Misra C report and check that "id1" is not shown
+    tree.setReportType(ReportType::misraC2012);
+    tree.saveResults(&report);
+    QCOMPARE(report.output, "unusedVariable,Advisory,2.8");
+
+    // add "missingReturn" and check that it is added properly
+    tree.addErrorItem(createErrorItem(Severity::warning, "missingReturn")); // Misra C 17.4
+    tree.saveResults(&report);
+    QCOMPARE(report.output,
+             "unusedVariable,Advisory,2.8\n"
+             "missingReturn,Mandatory,17.4");
+}
+
+void TestResultsTree::testReportTypeIcon() const {
+    ResultsTree tree(nullptr);
+    tree.setReportType(ReportType::misraC2012);
+    tree.addErrorItem(createErrorItem("file1.c", 10, Severity::style, "some rule text", "premium-misra-c-2012-1.1")); // Required
+    tree.addErrorItem(createErrorItem("file1.c", 20, Severity::style, "some rule text", "premium-misra-c-2012-1.2")); // Advisory
+    tree.addErrorItem(createErrorItem("file1.c", 30, Severity::style, "some rule text", "premium-misra-c-2012-9.1")); // Mandatory
+
+    const auto* model = dynamic_cast<QStandardItemModel*>(tree.model());
+    QVERIFY(model != nullptr);
+    const ResultItem* fileItem = dynamic_cast<ResultItem*>(model->item(0,0));
+
+    const ResultItem* err1 = dynamic_cast<ResultItem*>(fileItem->child(0,0));
+    const ResultItem* err2 = dynamic_cast<ResultItem*>(fileItem->child(1,0));
+    const ResultItem* err3 = dynamic_cast<ResultItem*>(fileItem->child(2,0));
+
+    QCOMPARE(err1->getIconFileName(), ":images/dialog-warning.png");
+    QCOMPARE(err2->getIconFileName(), ":images/applications-development.png");
+    QCOMPARE(err3->getIconFileName(), ":images/dialog-error.png");
+
+    tree.setReportType(ReportType::normal);
+    QCOMPARE(err1->getIconFileName(), ":images/applications-development.png");
+    QCOMPARE(err2->getIconFileName(), ":images/applications-development.png");
+    QCOMPARE(err3->getIconFileName(), ":images/applications-development.png");
+
+    tree.setReportType(ReportType::misraC2012);
+    QCOMPARE(err1->getIconFileName(), ":images/dialog-warning.png");
+    QCOMPARE(err2->getIconFileName(), ":images/applications-development.png");
+    QCOMPARE(err3->getIconFileName(), ":images/dialog-error.png");
+}
+
+void TestResultsTree::testGetGuidelineError() const
+{
+    TestReport report("{id},{classification},{guideline}");
+
+    int msgCount = 0;
+    auto createErrorItem = [&msgCount](const Severity severity, const QString& errorId) -> ErrorItem {
+        ++msgCount;
+        ErrorItem errorItem;
+        errorItem.errorPath << QErrorPathItem(ErrorMessage::FileLocation("file1.c", msgCount, 1));
+        errorItem.severity = severity;
+        errorItem.errorId = errorId;
+        errorItem.summary = "test summary " + QString::number(msgCount);
+        return errorItem;
+    };
+
+    // normal report with 2 errors
+    ResultsTree tree(nullptr);
+    tree.setReportType(ReportType::misraC2012);
+    tree.addErrorItem(createErrorItem(Severity::error, "id1")); // error severity => guideline 1.3
+    tree.saveResults(&report);
+    QCOMPARE(report.output, "id1,Required,1.3");
+}
+
+void TestResultsTree::misraCReportShowClassifications() const
+{
+    ResultsTree tree(nullptr);
+    tree.showResults(ShowTypes::ShowType::ShowErrors, true);
+    tree.showResults(ShowTypes::ShowType::ShowWarnings, true);
+    tree.showResults(ShowTypes::ShowType::ShowStyle, true);
+    tree.setReportType(ReportType::misraC2012);
+    tree.addErrorItem(createErrorItem("file1.c", 10, Severity::style, "some rule text", "premium-misra-c-2012-1.1")); // Required
+    tree.addErrorItem(createErrorItem("file1.c", 20, Severity::style, "some rule text", "premium-misra-c-2012-1.2")); // Advisory
+    tree.addErrorItem(createErrorItem("file1.c", 30, Severity::style, "some rule text", "premium-misra-c-2012-9.1")); // Mandatory
+    QCOMPARE(tree.isRowHidden(0, QModelIndex()), false);
+
+    const auto* model = dynamic_cast<QStandardItemModel*>(tree.model());
+    QVERIFY(model != nullptr);
+    QVERIFY(model->rowCount() == 1);
+    const ResultItem* fileItem = dynamic_cast<ResultItem*>(model->item(0,0));
+    QVERIFY(fileItem != nullptr);
+    QVERIFY(fileItem->rowCount() == 3);
+
+    QCOMPARE(tree.isRowHidden(0, fileItem->index()), false);
+    QCOMPARE(tree.isRowHidden(1, fileItem->index()), false);
+    QCOMPARE(tree.isRowHidden(2, fileItem->index()), false);
+
+    tree.showResults(ShowTypes::ShowType::ShowErrors, false);
+    tree.showResults(ShowTypes::ShowType::ShowWarnings, true);
+    tree.showResults(ShowTypes::ShowType::ShowStyle, true);
+    QCOMPARE(tree.isRowHidden(0, fileItem->index()), false);
+    QCOMPARE(tree.isRowHidden(1, fileItem->index()), false);
+    QCOMPARE(tree.isRowHidden(2, fileItem->index()), true);
+
+    tree.showResults(ShowTypes::ShowType::ShowErrors, true);
+    tree.showResults(ShowTypes::ShowType::ShowWarnings, false);
+    tree.showResults(ShowTypes::ShowType::ShowStyle, true);
+    QCOMPARE(tree.isRowHidden(0, fileItem->index()), true);
+    QCOMPARE(tree.isRowHidden(1, fileItem->index()), false);
+    QCOMPARE(tree.isRowHidden(2, fileItem->index()), false);
+
+    tree.showResults(ShowTypes::ShowType::ShowErrors, true);
+    tree.showResults(ShowTypes::ShowType::ShowWarnings, true);
+    tree.showResults(ShowTypes::ShowType::ShowStyle, false);
+    QCOMPARE(tree.isRowHidden(0, fileItem->index()), false);
+    QCOMPARE(tree.isRowHidden(1, fileItem->index()), true);
+    QCOMPARE(tree.isRowHidden(2, fileItem->index()), false);
+}
+
+QTEST_MAIN(TestResultsTree)
+
diff --git a/gui/test/benchmark/simple/benchmarksimple.h b/gui/test/resultstree/testresultstree.h
similarity index 60%
rename from gui/test/benchmark/simple/benchmarksimple.h
rename to gui/test/resultstree/testresultstree.h
index f5f89c17879..8604dc81c6b 100644
--- a/gui/test/benchmark/simple/benchmarksimple.h
+++ b/gui/test/resultstree/testresultstree.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2021 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,23 +16,18 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QtTest/QtTest>
 #include <QObject>
-#include "errorlogger.h"
 
-class BenchmarkSimple: public QObject, public ErrorLogger {
+class TestResultsTree : public QObject {
     Q_OBJECT
 
 private slots:
-    void tokenize();
-    void simplify();
-    void tokenizeAndSimplify();
-
-private:
-    // Empty implementations of ErrorLogger methods.
-    // We don't care about the output in the benchmark tests.
-    void reportOut(const std::string & outmsg) override {
-    }
-    void reportErr(const ErrorLogger::ErrorMessage &msg) override {
-    }
+    void test1() const;
+    void duplicateResults() const;
+    void multiLineResult() const;
+    void resultsInSameFile() const;
+    void testReportType() const;
+    void testReportTypeIcon() const;
+    void testGetGuidelineError() const;
+    void misraCReportShowClassifications() const;
 };
diff --git a/gui/test/test.pro b/gui/test/test.pro
deleted file mode 100644
index 7f75e3711f9..00000000000
--- a/gui/test/test.pro
+++ /dev/null
@@ -1,9 +0,0 @@
-#lessThan(QT_MAJOR_VERSION, 5): error(requires >= Qt 5 (You used: $$QT_VERSION))
-
-CONFIG  += ordered
-TEMPLATE = subdirs
-
-SUBDIRS = \
-    filelist \
-    projectfile \
-    xmlreportv2
diff --git a/gui/test/translationhandler/CMakeLists.txt b/gui/test/translationhandler/CMakeLists.txt
new file mode 100644
index 00000000000..f70b5759148
--- /dev/null
+++ b/gui/test/translationhandler/CMakeLists.txt
@@ -0,0 +1,24 @@
+qt_wrap_cpp(test-translationhandler_SRC testtranslationhandler.h ${CMAKE_SOURCE_DIR}/gui/translationhandler.h)
+add_custom_target(build-translationhandler-deps SOURCES ${test-translationhandler_SRC})
+add_dependencies(gui-build-deps build-translationhandler-deps)
+add_executable(test-translationhandler
+        ${test-translationhandler_SRC}
+        testtranslationhandler.cpp
+        ${CMAKE_SOURCE_DIR}/gui/common.cpp
+        ${CMAKE_SOURCE_DIR}/gui/translationhandler.cpp
+        )
+target_include_directories(test-translationhandler PRIVATE ${CMAKE_SOURCE_DIR}/gui ${CMAKE_SOURCE_DIR}/lib)
+target_link_libraries(test-translationhandler ${QT_CORE_LIB} ${QT_WIDGETS_LIB} ${QT_TEST_LIB})
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    if(QT_VERSION VERSION_GREATER_EQUAL "6.9.0")
+        # caused by Qt generated moc code starting with 6.9.0 - see https://bugreports.qt.io/browse/QTBUG-135638
+        target_compile_options_safe(test-translationhandler -Wno-ctad-maybe-unsupported)
+    endif()
+endif()
+
+if (REGISTER_GUI_TESTS)
+    add_test(NAME test-translationhandler COMMAND $<TARGET_FILE:test-translationhandler> -platform offscreen)
+endif()
+
+add_dependencies(gui-tests test-translationhandler)
\ No newline at end of file
diff --git a/gui/test/translationhandler/testtranslationhandler.cpp b/gui/test/translationhandler/testtranslationhandler.cpp
index 533fe5b7ee2..7c093e3edfd 100644
--- a/gui/test/translationhandler/testtranslationhandler.cpp
+++ b/gui/test/translationhandler/testtranslationhandler.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2021 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,14 +16,27 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QObject>
 #include "testtranslationhandler.h"
+
 #include "translationhandler.h"
 
-void TestTranslationHandler::construct()
+#include <QList>
+#include <QStringList>
+#include <QtTest>
+
+static QStringList getTranslationNames(const TranslationHandler& handler)
+{
+    QStringList names;
+    for (const TranslationInfo& translation : handler.getTranslations()) {
+        names.append(translation.mName);
+    }
+    return names;
+}
+
+void TestTranslationHandler::construct() const
 {
     TranslationHandler handler;
-    QCOMPARE(handler.getNames().size(), 13);  // 12 translations + english
+    QCOMPARE(getTranslationNames(handler).size(), 15);  // 14 translations + english
     QCOMPARE(handler.getCurrentLanguage(), QString("en"));
 }
 
diff --git a/gui/test/translationhandler/testtranslationhandler.h b/gui/test/translationhandler/testtranslationhandler.h
index 976bd2b5c47..249bbaa5ddd 100644
--- a/gui/test/translationhandler/testtranslationhandler.h
+++ b/gui/test/translationhandler/testtranslationhandler.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2021 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,12 +16,11 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QtTest/QtTest>
 #include <QObject>
 
-class TestTranslationHandler: public QObject {
+class TestTranslationHandler : public QObject {
     Q_OBJECT
 
 private slots:
-    void construct();
+    void construct() const;
 };
diff --git a/gui/test/translationhandler/translationhandler.pro b/gui/test/translationhandler/translationhandler.pro
deleted file mode 100644
index b131732df4b..00000000000
--- a/gui/test/translationhandler/translationhandler.pro
+++ /dev/null
@@ -1,14 +0,0 @@
-TEMPLATE = app
-TARGET = test-translationhandler
-DEPENDPATH += .
-INCLUDEPATH += .
-OBJECTS_DIR = ../build
-MOC_DIR = ../build
-QT += widgets
-
-include(../common.pri)
-
-# tests
-SOURCES += testtranslationhandler.cpp
-
-HEADERS += testtranslationhandler.h
diff --git a/gui/test/xmlreportv2/CMakeLists.txt b/gui/test/xmlreportv2/CMakeLists.txt
new file mode 100644
index 00000000000..fde9da7d0db
--- /dev/null
+++ b/gui/test/xmlreportv2/CMakeLists.txt
@@ -0,0 +1,26 @@
+qt_wrap_cpp(test-xmlreportv2_SRC testxmlreportv2.h)
+add_custom_target(build-xmlreportv2-deps SOURCES ${test-xmlreportv2_SRC})
+add_dependencies(gui-build-deps build-xmlreportv2-deps)
+add_executable(test-xmlreportv2
+        ${test-xmlreportv2_SRC}
+        testxmlreportv2.cpp
+        ${CMAKE_SOURCE_DIR}/gui/erroritem.cpp
+        ${CMAKE_SOURCE_DIR}/gui/report.cpp
+        ${CMAKE_SOURCE_DIR}/gui/xmlreport.cpp
+        ${CMAKE_SOURCE_DIR}/gui/xmlreportv2.cpp
+        )
+target_include_directories(test-xmlreportv2 PRIVATE ${CMAKE_SOURCE_DIR}/gui)
+target_compile_definitions(test-xmlreportv2 PRIVATE SRCDIR="${CMAKE_CURRENT_SOURCE_DIR}")
+target_link_libraries(test-xmlreportv2 ${QT_CORE_LIB} ${QT_TEST_LIB} cppcheck-core)
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    if(QT_VERSION VERSION_GREATER_EQUAL "6.9.0")
+        # caused by Qt generated moc code starting with 6.9.0 - see https://bugreports.qt.io/browse/QTBUG-135638
+        target_compile_options_safe(test-xmlreportv2 -Wno-ctad-maybe-unsupported)
+    endif()
+endif()
+
+if (REGISTER_GUI_TESTS)
+    add_test(NAME test-xmlreportv2 COMMAND $<TARGET_FILE:test-xmlreportv2>)
+endif()
+
+add_dependencies(gui-tests test-xmlreportv2)
diff --git a/gui/test/xmlreportv2/testxmlreportv2.cpp b/gui/test/xmlreportv2/testxmlreportv2.cpp
index 4b55186fb56..cede5842de0 100644
--- a/gui/test/xmlreportv2/testxmlreportv2.cpp
+++ b/gui/test/xmlreportv2/testxmlreportv2.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2021 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,16 +16,18 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QObject>
 #include "testxmlreportv2.h"
-#include "xmlreportv2.h"
+
 #include "erroritem.h"
-#include "errorlogger.h"
+#include "xmlreportv2.h"
+
+#include <QList>
+#include <QtTest>
 
-void TestXmlReportV2::readXml()
+void TestXmlReportV2::readXml() const
 {
     const QString filepath(QString(SRCDIR) + "/../data/xmlfiles/xmlreport_v2.xml");
-    XmlReportV2 report(filepath);
+    XmlReportV2 report(filepath, QString());
     QVERIFY(report.open());
     QList<ErrorItem> errors = report.read();
     QCOMPARE(errors.size(), 6);
@@ -33,7 +35,7 @@ void TestXmlReportV2::readXml()
     const ErrorItem &item = errors[0];
     QCOMPARE(item.errorPath.size(), 1);
     QCOMPARE(item.errorPath[0].file, QString("test.cxx"));
-    QCOMPARE(item.errorPath[0].line, (unsigned int)11);
+    QCOMPARE(item.errorPath[0].line, 11);
     QCOMPARE(item.errorId, QString("unreadVariable"));
     QCOMPARE(GuiSeverity::toString(item.severity), QString("style"));
     QCOMPARE(item.summary, QString("Variable 'a' is assigned a value that is never used"));
@@ -42,9 +44,9 @@ void TestXmlReportV2::readXml()
     const ErrorItem &item2 = errors[3];
     QCOMPARE(item2.errorPath.size(), 2);
     QCOMPARE(item2.errorPath[0].file, QString("test.cxx"));
-    QCOMPARE(item2.errorPath[0].line, (unsigned int)16);
+    QCOMPARE(item2.errorPath[0].line, 16);
     QCOMPARE(item2.errorPath[1].file, QString("test.cxx"));
-    QCOMPARE(item2.errorPath[1].line, (unsigned int)32);
+    QCOMPARE(item2.errorPath[1].line, 32);
     QCOMPARE(item2.errorId, QString("mismatchAllocDealloc"));
     QCOMPARE(GuiSeverity::toString(item2.severity), QString("error"));
     QCOMPARE(item2.summary, QString("Mismatching allocation and deallocation: k"));
diff --git a/gui/test/xmlreportv2/testxmlreportv2.h b/gui/test/xmlreportv2/testxmlreportv2.h
index 600b5c9584c..f4de863bff0 100644
--- a/gui/test/xmlreportv2/testxmlreportv2.h
+++ b/gui/test/xmlreportv2/testxmlreportv2.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2021 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,12 +16,11 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QtTest/QtTest>
 #include <QObject>
 
-class TestXmlReportV2: public QObject {
+class TestXmlReportV2 : public QObject {
     Q_OBJECT
 
 private slots:
-    void readXml();
+    void readXml() const;
 };
diff --git a/gui/test/xmlreportv2/xmlreportv2.pro b/gui/test/xmlreportv2/xmlreportv2.pro
deleted file mode 100644
index 26851a356c1..00000000000
--- a/gui/test/xmlreportv2/xmlreportv2.pro
+++ /dev/null
@@ -1,24 +0,0 @@
-TEMPLATE = app
-TARGET = test-xmlreportv2
-DEPENDPATH += .
-INCLUDEPATH += . ../../../externals/simplecpp ../../../externals/tinyxml
-OBJECTS_DIR = ../build
-MOC_DIR = ../build
-
-include(../common.pri)
-include(../../../lib/lib.pri)
-
-DEFINES += SRCDIR=\\\"$$PWD\\\"
-
-# tests
-SOURCES += testxmlreportv2.cpp \
-    ../../erroritem.cpp \
-    ../../report.cpp \
-    ../../xmlreport.cpp \
-    ../../xmlreportv2.cpp
-
-HEADERS += testxmlreportv2.h \
-    ../../erroritem.h \
-    ../../report.h \
-    ../../xmlreport.cpp \
-    ../../xmlreportv2.h
diff --git a/gui/threaddetails.cpp b/gui/threaddetails.cpp
new file mode 100644
index 00000000000..1fcb97772ef
--- /dev/null
+++ b/gui/threaddetails.cpp
@@ -0,0 +1,56 @@
+#include "threaddetails.h"
+#include "utils.h"
+
+#include "ui_threaddetails.h"
+
+#include <QMutexLocker>
+
+ThreadDetails* ThreadDetails::mInstance;
+
+ThreadDetails::ThreadDetails(QWidget *parent)
+    : QWidget(parent)
+    , mUi(new Ui::ThreadDetails)
+{
+    mInstance = this;
+    setWindowFlags(Qt::Window);
+    mUi->setupUi(this);
+    connect(&mTimer, &QTimer::timeout, this, &ThreadDetails::updateUI);
+    mTimer.start(1000);
+}
+
+ThreadDetails::~ThreadDetails()
+{
+    mInstance = nullptr;
+    delete mUi;
+}
+
+// NOLINTNEXTLINE(performance-unnecessary-value-param) - false positive
+void ThreadDetails::threadDetailsUpdated(QMap<int, CheckThread::Details> threadDetails)
+{
+    QMutexLocker locker(&mMutex);
+    mThreadDetails = threadDetails;
+    if (threadDetails.empty()) {
+        mProgress.clear();
+    }
+}
+
+// cppcheck-suppress passedByValue
+// NOLINTNEXTLINE(performance-unnecessary-value-param) - false positive
+void ThreadDetails::progress(QString filename, QString stage, std::size_t value) {
+    QMutexLocker locker(&mMutex);
+    mProgress[filename] = {QString(), stage + QString(value > 0 ? ": %1%" : "").arg(value)};
+}
+
+void ThreadDetails::updateUI() {
+    QString text("Thread\tStart time\tFile/Progress\n");
+    {
+        QMutexLocker locker(&mMutex);
+        for (const auto& td: utils::as_const(mThreadDetails)) {
+            auto& timeProgress = mProgress[td.file];
+            if (timeProgress.first.isEmpty() && !timeProgress.second.isEmpty())
+                timeProgress.first = QTime::currentTime().toString(Qt::TextDate);
+            text += QString("%1\t%2\t%3\n\t%4\t%5\n").arg(td.threadIndex).arg(td.startTime.toString(Qt::TextDate)).arg(td.file).arg(timeProgress.first).arg(timeProgress.second);
+        }
+    }
+    mUi->plainTextEdit->setPlainText(text);
+}
diff --git a/gui/threaddetails.h b/gui/threaddetails.h
new file mode 100644
index 00000000000..253b53d5407
--- /dev/null
+++ b/gui/threaddetails.h
@@ -0,0 +1,44 @@
+#ifndef THREADDETAILS_H
+#define THREADDETAILS_H
+
+#include <QWidget>
+#include <QMap>
+#include <QMutex>
+#include <QTimer>
+#include "checkthread.h"
+
+namespace Ui {
+    class ThreadDetails;
+}
+
+class ThreadDetails : public QWidget
+{
+    Q_OBJECT
+
+public:
+    explicit ThreadDetails(QWidget *parent = nullptr);
+    ~ThreadDetails() override;
+
+    static ThreadDetails* instance() {
+        return mInstance;
+    }
+
+public slots:
+    void threadDetailsUpdated(QMap<int, CheckThread::Details> threadDetails);
+    void progress(QString filename, QString stage, std::size_t value);
+
+private slots:
+    void updateUI();
+
+private:
+    static ThreadDetails* mInstance;
+    Ui::ThreadDetails *mUi;
+    QMap<QString, QPair<QString,QString>> mProgress;
+    QMap<int, CheckThread::Details> mThreadDetails;
+    QTimer mTimer;
+
+    /** accessing mProgress and mThreadDetails in slots that are triggered from different threads */
+    QMutex mMutex;
+};
+
+#endif // THREADDETAILS_H
diff --git a/gui/threaddetails.ui b/gui/threaddetails.ui
new file mode 100644
index 00000000000..420340cf77d
--- /dev/null
+++ b/gui/threaddetails.ui
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ThreadDetails</class>
+ <widget class="QWidget" name="ThreadDetails">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>640</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Thread Details</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QPlainTextEdit" name="plainTextEdit">
+     <property name="readOnly">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/gui/threadhandler.cpp b/gui/threadhandler.cpp
index 103da76315f..3f89d58b558 100644
--- a/gui/threadhandler.cpp
+++ b/gui/threadhandler.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,25 +16,34 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QObject>
-#include <QFileInfo>
-#include <QStringList>
-#include <QDebug>
-#include "common.h"
-#include "settings.h"
-#include "checkthread.h"
 #include "threadhandler.h"
+
+#include "checkthread.h"
+#include "common.h"
+#include "filesettings.h"
 #include "resultsview.h"
+#include "settings.h"
+#include "utils.h"
 
-ThreadHandler::ThreadHandler(QObject *parent) :
-    QObject(parent),
-    mScanDuration(0),
-    mRunningThreadCount(0),
-    mAnalyseWholeProgram(false)
+#include <algorithm>
+#include <string>
+#include <unordered_set>
+#include <utility>
 
-{
-    setThreadCount(1);
-}
+#include <QDebug>
+#include <QFile>
+#include <QFileInfo>
+#include <QIODevice>
+#include <QSettings>
+#include <QTextStream>
+#include <QVariant>
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 5, 0))
+#include <QtLogging>
+#endif
+
+ThreadHandler::ThreadHandler(QObject *parent) :
+    QObject(parent)
+{}
 
 ThreadHandler::~ThreadHandler()
 {
@@ -46,14 +55,15 @@ void ThreadHandler::clearFiles()
     mLastFiles.clear();
     mResults.clearFiles();
     mAnalyseWholeProgram = false;
+    mCtuInfo.clear();
     mAddonsAndTools.clear();
-    mSuppressions.clear();
+    mSuppressionsUI.clear();
 }
 
-void ThreadHandler::setFiles(const QStringList &files)
+void ThreadHandler::setFiles(std::list<FileWithDetails> files)
 {
-    mResults.setFiles(files);
     mLastFiles = files;
+    mResults.setFiles(std::move(files));
 }
 
 void ThreadHandler::setProject(const ImportProject &prj)
@@ -69,14 +79,22 @@ void ThreadHandler::setCheckFiles(bool all)
     }
 }
 
-void ThreadHandler::setCheckFiles(QStringList files)
+void ThreadHandler::setCheckFiles(std::list<FileWithDetails> files)
 {
     if (mRunningThreadCount == 0) {
-        mResults.setFiles(files);
+        mResults.setFiles(std::move(files));
     }
 }
 
-void ThreadHandler::check(const Settings &settings)
+void ThreadHandler::setupCheckThread(CheckThread &thread) const
+{
+    thread.setAddonsAndTools(mCheckAddonsAndTools);
+    thread.setSuppressions(mSuppressionsUI);
+    thread.setClangIncludePaths(mClangIncludePaths);
+    thread.setSettings(mCheckSettings, mCheckSuppressions);
+}
+
+void ThreadHandler::check(const Settings &settings, const std::shared_ptr<Suppressions>& supprs)
 {
     if (mResults.getFileCount() == 0 || mRunningThreadCount > 0 || settings.jobs == 0) {
         qDebug() << "Can't start checking if there's no files to check or if check is in progress.";
@@ -84,21 +102,26 @@ void ThreadHandler::check(const Settings &settings)
         return;
     }
 
-    setThreadCount(settings.jobs);
+    mCheckSettings = settings;
+    mCheckSuppressions = supprs;
+
+    createThreads(mCheckSettings.jobs);
 
     mRunningThreadCount = mThreads.size();
+    mRunningThreadCount = std::min(mResults.getFileCount(), mRunningThreadCount);
 
-    if (mResults.getFileCount() < mRunningThreadCount) {
-        mRunningThreadCount = mResults.getFileCount();
+    mCheckAddonsAndTools = mAddonsAndTools;
+    for (const std::string& addon: mCheckSettings.addons) {
+        QString s = QString::fromStdString(addon);
+        if (!mCheckAddonsAndTools.contains(s))
+            mCheckAddonsAndTools << s;
     }
 
+    mCtuInfo.clear();
+
     for (int i = 0; i < mRunningThreadCount; i++) {
-        mThreads[i]->setAddonsAndTools(mAddonsAndTools);
-        mThreads[i]->setMisraFile(mMisraFile);
-        mThreads[i]->setSuppressions(mSuppressions);
-        mThreads[i]->setClangIncludePaths(mClangIncludePaths);
-        mThreads[i]->setDataDir(mDataDir);
-        mThreads[i]->check(settings);
+        setupCheckThread(*mThreads[i]);
+        mThreads[i]->start();
     }
 
     // Date and time when checking starts..
@@ -106,19 +129,17 @@ void ThreadHandler::check(const Settings &settings)
 
     mAnalyseWholeProgram = true;
 
-    mTime.start();
+    mTimer.start();
 }
 
 bool ThreadHandler::isChecking() const
 {
-    return mRunningThreadCount > 0;
+    return mRunningThreadCount > 0 || mAnalyseWholeProgram;
 }
 
-void ThreadHandler::setThreadCount(const int count)
+void ThreadHandler::createThreads(const int count)
 {
-    if (mRunningThreadCount > 0 ||
-        count == mThreads.size() ||
-        count <= 0) {
+    if (mRunningThreadCount > 0 || count <= 0) {
         return;
     }
 
@@ -126,49 +147,68 @@ void ThreadHandler::setThreadCount(const int count)
     removeThreads();
     //Create new threads
     for (int i = mThreads.size(); i < count; i++) {
-        mThreads << new CheckThread(mResults);
+        mThreads << new CheckThread(mResults, i + 1);
         connect(mThreads.last(), &CheckThread::done,
-                this, &ThreadHandler::threadDone);
-        connect(mThreads.last(), &CheckThread::fileChecked,
-                &mResults, &ThreadResult::fileChecked);
+                this, &ThreadHandler::threadDone, Qt::QueuedConnection);
+        connect(mThreads.last(), &CheckThread::finishCheck,
+                &mResults, &ThreadResult::finishCheck, Qt::QueuedConnection);
+        connect(mThreads.last(), &CheckThread::startCheck,
+                this, &ThreadHandler::startCheck, Qt::QueuedConnection);
+        connect(mThreads.last(), &CheckThread::finishCheck,
+                this, &ThreadHandler::finishCheck, Qt::QueuedConnection);
     }
 }
 
 
 void ThreadHandler::removeThreads()
 {
-    for (int i = 0; i < mThreads.size(); i++) {
-        mThreads[i]->terminate();
-        disconnect(mThreads[i], &CheckThread::done,
+    for (CheckThread* thread : utils::as_const(mThreads)) {
+        if (thread->isRunning()) {
+            thread->stop();
+            thread->wait();
+        }
+        disconnect(thread, &CheckThread::done,
                    this, &ThreadHandler::threadDone);
-        disconnect(mThreads[i], &CheckThread::fileChecked,
-                   &mResults, &ThreadResult::fileChecked);
-        delete mThreads[i];
+        disconnect(thread, &CheckThread::finishCheck,
+                   &mResults, &ThreadResult::finishCheck);
+        disconnect(mThreads.last(), &CheckThread::startCheck,
+                   this, &ThreadHandler::startCheck);
+        disconnect(mThreads.last(), &CheckThread::finishCheck,
+                   this, &ThreadHandler::finishCheck);
+        delete thread;
     }
 
     mThreads.clear();
-    mAnalyseWholeProgram = false;
 }
 
 void ThreadHandler::threadDone()
 {
-    if (mRunningThreadCount == 1 && mAnalyseWholeProgram) {
-        mThreads[0]->analyseWholeProgram(mLastFiles);
+    mRunningThreadCount--;
+
+    // TODO: also run with projects?
+    if (mRunningThreadCount == 0 && mAnalyseWholeProgram) {
+        createThreads(1);
+        mRunningThreadCount = 1;
+        setupCheckThread(*mThreads[0]);
+        mThreads[0]->analyseWholeProgram(mLastFiles, mCtuInfo);
         mAnalyseWholeProgram = false;
+        mCtuInfo.clear();
         return;
     }
 
-    mRunningThreadCount--;
     if (mRunningThreadCount == 0) {
         emit done();
 
-        mScanDuration = mTime.elapsed();
+        mScanDuration = mTimer.elapsed();
 
         // Set date/time used by the recheck
         if (!mCheckStartTime.isNull()) {
             mLastCheckTime = mCheckStartTime;
             mCheckStartTime = QDateTime();
         }
+
+        mCheckAddonsAndTools.clear();
+        mCheckSuppressions.reset();
     }
 }
 
@@ -176,15 +216,16 @@ void ThreadHandler::stop()
 {
     mCheckStartTime = QDateTime();
     mAnalyseWholeProgram = false;
-    for (int i = 0; i < mThreads.size(); i++) {
-        mThreads[i]->stop();
+    mCtuInfo.clear();
+    for (CheckThread* thread : utils::as_const(mThreads)) {
+        thread->stop();
     }
 }
 
-void ThreadHandler::initialize(ResultsView *view)
+void ThreadHandler::initialize(const ResultsView *view)
 {
-    connect(&mResults, &ThreadResult::progress,
-            view, &ResultsView::progress);
+    connect(&mResults, &ThreadResult::filesCheckedProgress,
+            view, &ResultsView::filesCheckedProgress);
 
     connect(&mResults, &ThreadResult::error,
             view, &ResultsView::error);
@@ -194,11 +235,14 @@ void ThreadHandler::initialize(ResultsView *view)
 
     connect(&mResults, &ThreadResult::debugError,
             this, &ThreadHandler::debugError);
+
+    connect(&mResults, &ThreadResult::progress,
+            this, &ThreadHandler::progress);
 }
 
-void ThreadHandler::loadSettings(QSettings &settings)
+void ThreadHandler::loadSettings(const QSettings &settings)
 {
-    setThreadCount(settings.value(SETTINGS_CHECK_THREADS, 1).toInt());
+    createThreads(settings.value(SETTINGS_CHECK_THREADS, 1).toInt());
 }
 
 void ThreadHandler::saveSettings(QSettings &settings) const
@@ -208,7 +252,7 @@ void ThreadHandler::saveSettings(QSettings &settings) const
 
 bool ThreadHandler::hasPreviousFiles() const
 {
-    return !mLastFiles.isEmpty();
+    return !mLastFiles.empty();
 }
 
 int ThreadHandler::getPreviousFilesCount() const
@@ -221,7 +265,7 @@ int ThreadHandler::getPreviousScanDuration() const
     return mScanDuration;
 }
 
-QStringList ThreadHandler::getReCheckFiles(bool all) const
+std::list<FileWithDetails> ThreadHandler::getReCheckFiles(bool all) const
 {
     if (mLastCheckTime.isNull() || all)
         return mLastFiles;
@@ -229,11 +273,10 @@ QStringList ThreadHandler::getReCheckFiles(bool all) const
     std::set<QString> modified;
     std::set<QString> unmodified;
 
-    QStringList files;
-    for (int i = 0; i < mLastFiles.size(); ++i) {
-        if (needsReCheck(mLastFiles[i], modified, unmodified))
-            files.push_back(mLastFiles[i]);
-    }
+    std::list<FileWithDetails> files;
+    std::copy_if(mLastFiles.cbegin(), mLastFiles.cend(), std::back_inserter(files), [&](const FileWithDetails &f) {
+        return needsReCheck(QString::fromStdString(f.path()), modified, unmodified);
+    });
     return files;
 }
 
@@ -262,12 +305,12 @@ bool ThreadHandler::needsReCheck(const QString &filename, std::set<QString> &mod
         QString line = in.readLine();
         if (line.startsWith("#include \"")) {
             line.remove(0,10);
-            int i = line.indexOf("\"");
+            const int i = line.indexOf("\"");
             if (i > 0) {
                 line.remove(i,line.length());
                 line = QFileInfo(filename).absolutePath() + "/" + line;
                 if (needsReCheck(line, modified, unmodified)) {
-                    modified.insert(line);
+                    modified.insert(std::move(line));
                     return true;
                 }
             }
@@ -284,5 +327,26 @@ QDateTime ThreadHandler::getCheckStartTime() const
 
 void ThreadHandler::setCheckStartTime(QDateTime checkStartTime)
 {
-    mCheckStartTime = checkStartTime;
+    mCheckStartTime = std::move(checkStartTime);
+}
+
+// cppcheck-suppress passedByValueCallback
+// NOLINTNEXTLINE(performance-unnecessary-value-param)
+void ThreadHandler::startCheck(CheckThread::Details details)
+{
+    mThreadDetails[details.threadIndex] = details;
+    emitThreadDetailsUpdated();
+}
+
+// cppcheck-suppress passedByValueCallback
+// NOLINTNEXTLINE(performance-unnecessary-value-param)
+void ThreadHandler::finishCheck(CheckThread::Details details)
+{
+    mThreadDetails.remove(details.threadIndex);
+    emitThreadDetailsUpdated();
+}
+
+void ThreadHandler::emitThreadDetailsUpdated()
+{
+    emit threadDetailsUpdated(mThreadDetails);
 }
diff --git a/gui/threadhandler.h b/gui/threadhandler.h
index ca1702950a2..17f011c32ac 100644
--- a/gui/threadhandler.h
+++ b/gui/threadhandler.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,194 +20,223 @@
 #ifndef THREADHANDLER_H
 #define THREADHANDLER_H
 
+#include "settings.h"
+#include "suppressions.h"
+#include "threadresult.h"
+
+#include <cstddef>
+#include <list>
+#include <memory>
+#include <set>
+#include <string>
+
+#include <QDateTime>
+#include <QElapsedTimer>
+#include <QList>
 #include <QObject>
+#include <QString>
 #include <QStringList>
-#include <QDateTime>
-#include <set>
-#include "threadresult.h"
-#include "importproject.h"
-#include "suppressions.h"
 
 class ResultsView;
 class CheckThread;
 class QSettings;
-class Settings;
+class ImportProject;
+class ErrorItem;
+class FileWithDetails;
 
 /// @addtogroup GUI
 /// @{
 
 
 /**
-* @brief This class handles creating threadresult and starting threads
-*
-*/
+ * @brief This class handles creating threadresult and starting threads
+ *
+ */
 class ThreadHandler : public QObject {
     Q_OBJECT
 public:
     explicit ThreadHandler(QObject *parent = nullptr);
-    virtual ~ThreadHandler();
-
-    /**
-    * @brief Set the number of threads to use
-    * @param count The number of threads to use
-    */
-    void setThreadCount(const int count);
+    ~ThreadHandler() override;
 
     /**
-    * @brief Initialize the threads (connect all signals to resultsview's slots)
-    *
-    * @param view View to show error results
-    */
-    void initialize(ResultsView *view);
+     * @brief Initialize the threads (connect all signals to resultsview's slots)
+     *
+     * @param view View to show error results
+     */
+    void initialize(const ResultsView *view);
 
     /**
-    * @brief Load settings
-    * @param settings QSettings to load settings from
-    */
-    void loadSettings(QSettings &settings);
+     * @brief Load settings
+     * @param settings QSettings to load settings from
+     */
+    void loadSettings(const QSettings &settings);
 
     /**
-    * @brief Save settings
-    * @param settings QSettings to save settings to
-    */
+     * @brief Save settings
+     * @param settings QSettings to save settings to
+     */
     void saveSettings(QSettings &settings) const;
 
-    void setAddonsAndTools(const QStringList &addonsAndTools, const QString &misraFile) {
+    void setAddonsAndTools(const QStringList &addonsAndTools) {
         mAddonsAndTools = addonsAndTools;
-        mMisraFile = misraFile;
     }
 
-    void setSuppressions(const QList<Suppressions::Suppression> &s) {
-        mSuppressions = s;
+    void setSuppressions(const QList<SuppressionList::Suppression> &s) {
+        mSuppressionsUI = s;
     }
 
     void setClangIncludePaths(const QStringList &s) {
         mClangIncludePaths = s;
     }
 
-    void setDataDir(const QString &dataDir) {
-        mDataDir = dataDir;
-    }
-
     /**
-    * @brief Clear all files from cppcheck
-    *
-    */
+     * @brief Clear all files from cppcheck
+     *
+     */
     void clearFiles();
 
     /**
-    * @brief Set files to check
-    *
-    * @param files files to check
-    */
-    void setFiles(const QStringList &files);
+     * @brief Set files to check
+     *
+     * @param files files to check
+     */
+    void setFiles(std::list<FileWithDetails> files);
 
     /**
-    * @brief Set project to check
-    *
-    * @param prj project to check
-    */
+     * @brief Set project to check
+     *
+     * @param prj project to check
+     */
     void setProject(const ImportProject &prj);
 
     /**
-    * @brief Start the threads to check the files
-    *
-    * @param settings Settings for checking
-    */
-    void check(const Settings &settings);
+     * @brief Start the threads to check the files
+     *
+     * @param settings Settings for checking
+     * @param supprs Suppressions for checking
+     */
+    void check(const Settings &settings, const std::shared_ptr<Suppressions>& supprs);
 
     /**
-    * @brief Set files to check
-    *
-    * @param all true if all files, false if modified files
-    */
+     * @brief Set files to check
+     *
+     * @param all true if all files, false if modified files
+     */
     void setCheckFiles(bool all);
 
     /**
-    * @brief Set selected files to check
-    *
-    * @param files list of files to be checked
-    */
-    void setCheckFiles(QStringList files);
+     * @brief Set selected files to check
+     *
+     * @param files list of files to be checked
+     */
+    void setCheckFiles(std::list<FileWithDetails> files);
 
     /**
-    * @brief Is checking running?
-    *
-    * @return true if check is running, false otherwise.
-    */
+     * @brief Is checking running?
+     *
+     * @return true if check is running, false otherwise.
+     */
     bool isChecking() const;
 
     /**
-    * @brief Have we checked files already?
-    *
-    * @return true check has been previously run and recheck can be done
-    */
+     * @brief Have we checked files already?
+     *
+     * @return true check has been previously run and recheck can be done
+     */
     bool hasPreviousFiles() const;
 
     /**
-    * @brief Return count of files we checked last time.
-    *
-    * @return count of files that were checked last time.
-    */
+     * @brief Return count of files we checked last time.
+     *
+     * @return count of files that were checked last time.
+     */
     int getPreviousFilesCount() const;
 
     /**
-    * @brief Return the time elapsed while scanning the previous time.
-    *
-    * @return the time elapsed in milliseconds.
-    */
+     * @brief Return the time elapsed while scanning the previous time.
+     *
+     * @return the time elapsed in milliseconds.
+     */
     int getPreviousScanDuration() const;
 
     /**
      * @brief Get files that should be rechecked because they have been
      * changed.
      */
-    QStringList getReCheckFiles(bool all) const;
+    std::list<FileWithDetails> getReCheckFiles(bool all) const;
 
     /**
-    * @brief Get start time of last check
-    *
-    * @return start time of last check
-    */
+     * @brief Get start time of last check
+     *
+     * @return start time of last check
+     */
     QDateTime getCheckStartTime() const;
 
     /**
-    * @brief Set start time of check
-    *
-    * @param checkStartTime saved start time of the last check
-    */
+     * @brief Set start time of check
+     *
+     * @param checkStartTime saved start time of the last check
+     */
     void setCheckStartTime(QDateTime checkStartTime);
 
+    /**
+     * @brief Emit the threadDetailsUpdated signal
+     */
+    void emitThreadDetailsUpdated();
+
 signals:
     /**
-    * @brief Signal that all threads are done
-    *
-    */
+     * @brief Signal that all threads are done
+     *
+     */
     void done();
 
+    // NOLINTNEXTLINE(readability-inconsistent-declaration-parameter-name) - caused by generated MOC code
     void log(const QString &msg);
 
+    // NOLINTNEXTLINE(readability-inconsistent-declaration-parameter-name) - caused by generated MOC code
     void debugError(const ErrorItem &item);
 
+    /**
+     * @brief Emitted when thread details are updated.
+     */
+    void threadDetailsUpdated(QMap<int, CheckThread::Details> threadDetails);
+
 public slots:
 
     /**
-    * @brief Slot to stop all threads
-    *
-    */
+     * @brief Slot to stop all threads
+     *
+     */
     void stop();
+
+    /**
+     * @brief Slot threads use to signal this class that it started checking a file
+     * @param details Details about what file is being checked and by what thread
+     */
+    void startCheck(CheckThread::Details details);
+
+    /**
+     * @brief Slot threads use to signal this class that it finish checking a file
+     * @param details Details about what file finished being checked and by what thread
+     */
+    void finishCheck(CheckThread::Details details);
+
+signals:
+    void progress(QString filename, QString stage, std::size_t value);
+
 protected slots:
     /**
-    * @brief Slot that a single thread is done
-    *
-    */
+     * @brief Slot that a single thread is done
+     *
+     */
     void threadDone();
 protected:
     /**
-    * @brief List of files checked last time (used when rechecking)
-    *
-    */
-    QStringList mLastFiles;
+     * @brief List of files checked last time (used when rechecking)
+     *
+     */
+    std::list<FileWithDetails> mLastFiles;
 
     /** @brief date and time when current checking started */
     QDateTime mCheckStartTime;
@@ -218,49 +247,77 @@ protected slots:
     QDateTime mLastCheckTime;
 
     /**
-    * @brief Timer used for measuring scan duration
-    *
-    */
-    QTime mTime;
+     * @brief Timer used for measuring scan duration
+     *
+     */
+    QElapsedTimer mTimer;
+
+    /**
+     * @brief The previous scan duration in milliseconds.
+     *
+     */
+    int mScanDuration{};
 
     /**
-    * @brief The previous scan duration in milliseconds.
-    *
-    */
-    int mScanDuration;
+     * @brief Create checker threads
+     * @param count The number of threads to spawn
+     */
+    void createThreads(int count);
 
     /**
-    * @brief Function to delete all threads
-    *
-    */
+     * @brief Function to delete all threads
+     *
+     */
     void removeThreads();
 
+    /*
+     * @brief Apply check settings to a checker thread
+     * @param thread The thread to setup
+     */
+    void setupCheckThread(CheckThread &thread) const;
+
     /**
-    * @brief Thread results are stored here
-    *
-    */
+     * @brief Thread results are stored here
+     *
+     */
     ThreadResult mResults;
 
     /**
-    * @brief List of threads currently in use
-    *
-    */
+     * @brief List of threads currently in use
+     *
+     */
     QList<CheckThread *> mThreads;
 
     /**
-    * @brief The amount of threads currently running
-    *
-    */
-    int mRunningThreadCount;
+     * @brief The amount of threads currently running
+     *
+     */
+    int mRunningThreadCount{};
 
-    bool mAnalyseWholeProgram;
+    /**
+     * @brief A whole program check is queued by check()
+     */
+    bool mAnalyseWholeProgram{};
+    std::string mCtuInfo;
 
     QStringList mAddonsAndTools;
-    QList<Suppressions::Suppression> mSuppressions;
+    QList<SuppressionList::Suppression> mSuppressionsUI;
     QStringList mClangIncludePaths;
 
-    QString mDataDir;
-    QString mMisraFile;
+    /// @{
+    /**
+     * @brief Settings specific to the current analysis
+     */
+    QStringList mCheckAddonsAndTools;
+    Settings mCheckSettings;
+    std::shared_ptr<Suppressions> mCheckSuppressions;
+    /// @}
+
+    /**
+     * @brief Details about currently running threads
+     */
+    QMap<int, CheckThread::Details> mThreadDetails;
+
 private:
 
     /**
diff --git a/gui/threadresult.cpp b/gui/threadresult.cpp
index 0bc894f8081..a3929da7cca 100644
--- a/gui/threadresult.cpp
+++ b/gui/threadresult.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,50 +16,43 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QFile>
-#include <QString>
-#include <QMutexLocker>
-#include <QList>
-#include <QStringList>
-#include <QDebug>
+#include "threadresult.h"
+
 #include "common.h"
 #include "erroritem.h"
 #include "errorlogger.h"
-#include "threadresult.h"
+#include "errortypes.h"
+#include "importproject.h"
 
-ThreadResult::ThreadResult() : mMaxProgress(0), mProgress(0), mFilesChecked(0), mTotalFiles(0)
-{
-    //ctor
-}
+#include <numeric>
+#include <utility>
 
-ThreadResult::~ThreadResult()
-{
-    //dtor
-}
+#include <QFile>
 
-void ThreadResult::reportOut(const std::string &outmsg)
+void ThreadResult::reportOut(const std::string &outmsg, Color /*c*/)
 {
     emit log(QString::fromStdString(outmsg));
 }
 
-void ThreadResult::fileChecked(const QString &file)
+// NOLINTNEXTLINE(performance-unnecessary-value-param)
+void ThreadResult::finishCheck(CheckThread::Details details)
 {
-    QMutexLocker locker(&mutex);
+    std::lock_guard<std::mutex> locker(mutex);
 
-    mProgress += QFile(file).size();
-    mFilesChecked ++;
+    mCheckedFileSize += QFile(details.file).size();
+    mFilesChecked++;
 
-    if (mMaxProgress > 0) {
-        const int value = static_cast<int>(PROGRESS_MAX * mProgress / mMaxProgress);
+    if (mTotalFileSize > 0) {
+        const int value = static_cast<int>(PROGRESS_MAX * mCheckedFileSize / mTotalFileSize);
         const QString description = tr("%1 of %2 files checked").arg(mFilesChecked).arg(mTotalFiles);
 
-        emit progress(value, description);
+        emit filesCheckedProgress(value, description);
     }
 }
 
-void ThreadResult::reportErr(const ErrorLogger::ErrorMessage &msg)
+void ThreadResult::reportErr(const ErrorMessage &msg)
 {
-    QMutexLocker locker(&mutex);
+    std::lock_guard<std::mutex> locker(mutex);
     const ErrorItem item(msg);
     if (msg.severity != Severity::debug)
         emit error(item);
@@ -67,73 +60,80 @@ void ThreadResult::reportErr(const ErrorLogger::ErrorMessage &msg)
         emit debugError(item);
 }
 
-QString ThreadResult::getNextFile()
+// NOLINTNEXTLINE(readability-avoid-const-params-in-decls) - false positive this is an overload
+void ThreadResult::reportProgress(const std::string &filename, const char stage[], const std::size_t value) {
+    emit progress(QString::fromStdString(filename), stage, value);
+}
+
+void ThreadResult::getNextFile(const FileWithDetails*& file)
 {
-    QMutexLocker locker(&mutex);
-    if (mFiles.isEmpty()) {
-        return QString();
+    std::lock_guard<std::mutex> locker(mutex);
+    file = nullptr;
+    if (mItNextFile == mFiles.cend()) {
+        return;
     }
-
-    return mFiles.takeFirst();
+    file = &(*mItNextFile);
+    ++mItNextFile;
 }
 
-ImportProject::FileSettings ThreadResult::getNextFileSettings()
+void ThreadResult::getNextFileSettings(const FileSettings*& fs)
 {
-    QMutexLocker locker(&mutex);
-    if (mFileSettings.empty()) {
-        return ImportProject::FileSettings();
+    std::lock_guard<std::mutex> locker(mutex);
+    fs = nullptr;
+    if (mItNextFileSettings == mFileSettings.cend()) {
+        return;
     }
-    const ImportProject::FileSettings fs = mFileSettings.front();
-    mFileSettings.pop_front();
-    return fs;
+    fs = &(*mItNextFileSettings);
+    ++mItNextFileSettings;
 }
 
-void ThreadResult::setFiles(const QStringList &files)
+void ThreadResult::setFiles(std::list<FileWithDetails> files)
 {
-    QMutexLocker locker(&mutex);
-    mFiles = files;
-    mProgress = 0;
-    mFilesChecked = 0;
+    std::lock_guard<std::mutex> locker(mutex);
     mTotalFiles = files.size();
+    mFiles = std::move(files);
+    mItNextFile = mFiles.cbegin();
+    mCheckedFileSize = 0;
+    mFilesChecked = 0;
 
     // Determine the total size of all of the files to check, so that we can
     // show an accurate progress estimate
-    quint64 sizeOfFiles = 0;
-    foreach (const QString& file, files) {
-        sizeOfFiles += QFile(file).size();
-    }
-    mMaxProgress = sizeOfFiles;
+    quint64 sizeOfFiles = std::accumulate(mFiles.cbegin(), mFiles.cend(), 0, [](quint64 total, const FileWithDetails& file) {
+        return total + file.size();
+    });
+    mTotalFileSize = sizeOfFiles;
 }
 
 void ThreadResult::setProject(const ImportProject &prj)
 {
-    QMutexLocker locker(&mutex);
+    std::lock_guard<std::mutex> locker(mutex);
     mFiles.clear();
+    mItNextFile = mFiles.cbegin();
     mFileSettings = prj.fileSettings;
-    mProgress = 0;
+    mItNextFileSettings = mFileSettings.cbegin();
+    mCheckedFileSize = 0;
     mFilesChecked = 0;
     mTotalFiles = prj.fileSettings.size();
 
     // Determine the total size of all of the files to check, so that we can
     // show an accurate progress estimate
-    quint64 sizeOfFiles = 0;
-    foreach (const ImportProject::FileSettings& fs, prj.fileSettings) {
-        sizeOfFiles += QFile(QString::fromStdString(fs.filename)).size();
-    }
-    mMaxProgress = sizeOfFiles;
+    mTotalFileSize = std::accumulate(prj.fileSettings.begin(), prj.fileSettings.end(), quint64{ 0 }, [](quint64 v, const FileSettings& fs) {
+        return v + QFile(QString::fromStdString(fs.filename())).size();
+    });
 }
 
 void ThreadResult::clearFiles()
 {
-    QMutexLocker locker(&mutex);
+    std::lock_guard<std::mutex> locker(mutex);
     mFiles.clear();
     mFileSettings.clear();
+    mItNextFileSettings = mFileSettings.cend();
     mFilesChecked = 0;
     mTotalFiles = 0;
 }
 
 int ThreadResult::getFileCount() const
 {
-    QMutexLocker locker(&mutex);
+    std::lock_guard<std::mutex> locker(mutex);
     return mFiles.size() + mFileSettings.size();
 }
diff --git a/gui/threadresult.h b/gui/threadresult.h
index 693dd8cb229..1224b3c539d 100644
--- a/gui/threadresult.h
+++ b/gui/threadresult.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,136 +20,152 @@
 #ifndef THREADRESULT_H
 #define THREADRESULT_H
 
-#include <QMutex>
+#include "color.h"
+#include "errorlogger.h"
+#include "filesettings.h"
+#include "checkthread.h"
+
+#include <cstddef>
+#include <list>
+#include <mutex>
+#include <string>
+
 #include <QObject>
+#include <QString>
 #include <QStringList>
-#include "errorlogger.h"
-#include "importproject.h"
 
 class ErrorItem;
+class ImportProject;
 
 /// @addtogroup GUI
 /// @{
 
 /**
-* @brief Threads use this class to obtain new files to process and to publish results
-*
-*/
+ * @brief Threads use this class to obtain new files to process and to publish results
+ *
+ */
 class ThreadResult : public QObject, public ErrorLogger {
     Q_OBJECT
 public:
-    ThreadResult();
-    virtual ~ThreadResult();
+    ThreadResult() = default;
 
     /**
-    * @brief Get next unprocessed file
-    * @return File path
-    */
-    QString getNextFile();
+     * @brief Get next unprocessed file
+     */
+    void getNextFile(const FileWithDetails*& file);
 
-    ImportProject::FileSettings getNextFileSettings();
+    void getNextFileSettings(const FileSettings*& fs);
 
     /**
-    * @brief Set list of files to check
-    * @param files List of files to check
-    */
-    void setFiles(const QStringList &files);
+     * @brief Set list of files to check
+     * @param files List of files to check
+     */
+    void setFiles(std::list<FileWithDetails> files);
 
     void setProject(const ImportProject &prj);
 
     /**
-    * @brief Clear files to check
-    *
-    */
+     * @brief Clear files to check
+     *
+     */
     void clearFiles();
 
     /**
-    * @brief Get the number of files to check
-    *
-    */
+     * @brief Get the number of files to check
+     *
+     */
     int getFileCount() const;
 
     /**
-    * ErrorLogger methods
-    */
-    void reportOut(const std::string &outmsg) override;
-    void reportErr(const ErrorLogger::ErrorMessage &msg) override;
+     * ErrorLogger methods
+     */
+    void reportOut(const std::string &outmsg, Color c = Color::Reset) override;
+    void reportErr(const ErrorMessage &msg) override;
+    void reportMetric(const std::string &metric) override
+    {
+        (void) metric;
+    }
+    // NOLINTNEXTLINE(readability-avoid-const-params-in-decls) - false positive this is an overload
+    void reportProgress(const std::string &filename, const char stage[], const std::size_t value) final;
 
 public slots:
 
     /**
-    * @brief Slot threads use to signal this class that a specific file is checked
-    * @param file File that is checked
-    */
-    void fileChecked(const QString &file);
+     * @brief Slot threads use to signal this class that it finish checking a file
+     * @param details Details about what file finished being checked and by what thread
+     */
+    void finishCheck(CheckThread::Details details);
+
 signals:
     /**
-    * @brief Progress signal
-    * @param value Current progress
-    * @param description Description of the current stage
-    */
-    void progress(int value, const QString& description);
+     * @brief Files checked progress
+     * @param value Current progress (0 - PROGRESS_MAX)
+     * @param description Description of the current stage (example: "13/45 files checked")
+     */
+    // NOLINTNEXTLINE(readability-inconsistent-declaration-parameter-name) - caused by generated MOC code
+    void filesCheckedProgress(int value, const QString& description);
 
     /**
-    * @brief Signal of a new error
-    *
-    * @param item Error data
-    */
+     * @brief Signal of a new error
+     *
+     * @param item Error data
+     */
+    // NOLINTNEXTLINE(readability-inconsistent-declaration-parameter-name) - caused by generated MOC code
     void error(const ErrorItem &item);
 
     /**
-    * @brief Signal of a new log message
-    *
-    * @param logline Log line
-    */
+     * @brief Signal of a new log message
+     *
+     * @param logline Log line
+     */
+    // NOLINTNEXTLINE(readability-inconsistent-declaration-parameter-name) - caused by generated MOC code
     void log(const QString &logline);
 
     /**
-    * @brief Signal of a debug error
-    *
-    * @param item Error data
-    */
+     * @brief Signal of a debug error
+     *
+     * @param item Error data
+     */
+    // NOLINTNEXTLINE(readability-inconsistent-declaration-parameter-name) - caused by generated MOC code
     void debugError(const ErrorItem &item);
 
+    void progress(QString filename, QString stage, std::size_t value);
+
 protected:
 
     /**
-    * @brief Mutex
-    *
-    */
-    mutable QMutex mutex;
+     * @brief Mutex
+     *
+     */
+    mutable std::mutex mutex;
 
     /**
-    * @brief List of files to check
-    *
-    */
-    QStringList mFiles;
+     * @brief List of files to check
+     *
+     */
+    std::list<FileWithDetails> mFiles;
+    std::list<FileWithDetails>::const_iterator mItNextFile{mFiles.cbegin()};
 
-    std::list<ImportProject::FileSettings> mFileSettings;
+    std::list<FileSettings> mFileSettings;
+    std::list<FileSettings>::const_iterator mItNextFileSettings{mFileSettings.cbegin()};
 
-    /**
-    * @brief Max progress
-    *
-    */
-    quint64 mMaxProgress;
+    /** @brief Total file size */
+    quint64 mTotalFileSize{};
 
-    /**
-    * @brief Current progress
-    *
-    */
-    quint64 mProgress;
+    /** @brief File size of checked files */
+    quint64 mCheckedFileSize{};
 
     /**
-    * @brief Current number of files checked
-    *
-    */
-    unsigned long mFilesChecked;
+     * @brief Current number of files checked
+     *
+     */
+    unsigned long mFilesChecked{};
 
     /**
-    * @brief Total number of files
-    *
-    */
-    unsigned long mTotalFiles;
+     * @brief Total number of files
+     *
+     */
+    unsigned long mTotalFiles{};
 };
 /// @}
 #endif // THREADRESULT_H
diff --git a/gui/translationhandler.cpp b/gui/translationhandler.cpp
index 0cb80a0f2ee..d8160525856 100644
--- a/gui/translationhandler.cpp
+++ b/gui/translationhandler.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,43 +16,42 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "translationhandler.h"
+
+#include "config.h"
+#include "common.h"
+
 #include <QApplication>
+#include <QCoreApplication>
 #include <QFile>
-#include <QDebug>
+#include <QFileInfo>
 #include <QLocale>
 #include <QMessageBox>
-#include <QSettings>
-#include <QFileInfo>
-#include "translationhandler.h"
+#include <QTranslator>
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 5, 0))
+#include <QtPreprocessorSupport>
+#else
+#include <QtGlobal>
+#endif
 
 
 // Provide own translations for standard buttons. This (garbage) code is needed to enforce them to appear in .ts files even after "lupdate gui.pro"
-static void unused()
+UNUSED static void unused()
 {
-// NOTE: Keeping semi-colons at end of macro for style preference
-#if ((QT_VERSION >= 0x040000)&&(QT_VERSION < 0x050000))
-    Q_UNUSED(QT_TRANSLATE_NOOP("QDialogButtonBox", "OK"));
-    Q_UNUSED(QT_TRANSLATE_NOOP("QDialogButtonBox", "Cancel"));
-    Q_UNUSED(QT_TRANSLATE_NOOP("QDialogButtonBox", "Close"));
-    Q_UNUSED(QT_TRANSLATE_NOOP("QDialogButtonBox", "Save"));
-#elif ((QT_VERSION >= 0x050000)&&(QT_VERSION < 0x060000))
-    Q_UNUSED(QT_TRANSLATE_NOOP("QPlatformTheme", "OK"));
-    Q_UNUSED(QT_TRANSLATE_NOOP("QPlatformTheme", "Cancel"));
-    Q_UNUSED(QT_TRANSLATE_NOOP("QPlatformTheme", "Close"));
-    Q_UNUSED(QT_TRANSLATE_NOOP("QPlatformTheme", "Save"));
-#else
-#error Unsupported Qt version.
-#endif
+    Q_UNUSED(QT_TRANSLATE_NOOP("QPlatformTheme", "OK"))
+    Q_UNUSED(QT_TRANSLATE_NOOP("QPlatformTheme", "Cancel"))
+    Q_UNUSED(QT_TRANSLATE_NOOP("QPlatformTheme", "Close"))
+    Q_UNUSED(QT_TRANSLATE_NOOP("QPlatformTheme", "Save"))
 }
 
 TranslationHandler::TranslationHandler(QObject *parent) :
     QObject(parent),
-    mCurrentLanguage("en"),
-    mTranslator(nullptr)
+    mCurrentLanguage("en")
 {
     // Add our available languages
     // Keep this list sorted
     addTranslation("Chinese (Simplified)", "cppcheck_zh_CN");
+    addTranslation("Chinese (Traditional)", "cppcheck_zh_TW");
     addTranslation("Dutch", "cppcheck_nl");
     addTranslation("English", "cppcheck_en");
     addTranslation("Finnish", "cppcheck_fi");
@@ -60,6 +59,7 @@ TranslationHandler::TranslationHandler(QObject *parent) :
     addTranslation("German", "cppcheck_de");
     addTranslation("Italian", "cppcheck_it");
     addTranslation("Japanese", "cppcheck_ja");
+    addTranslation("Georgian", "cppcheck_ka");
     addTranslation("Korean", "cppcheck_ko");
     addTranslation("Russian", "cppcheck_ru");
     addTranslation("Serbian", "cppcheck_sr");
@@ -67,26 +67,13 @@ TranslationHandler::TranslationHandler(QObject *parent) :
     addTranslation("Swedish", "cppcheck_sv");
 }
 
-TranslationHandler::~TranslationHandler()
-{
-}
-
-const QStringList TranslationHandler::getNames() const
-{
-    QStringList names;
-    foreach (TranslationInfo translation, mTranslations) {
-        names.append(translation.mName);
-    }
-    return names;
-}
-
 bool TranslationHandler::setLanguage(const QString &code)
 {
     bool failure = false;
     QString error;
 
-    //If English is the language
-    if (code == "en") {
+    //If English is the language. Code can be e.g. en_US
+    if (code.indexOf("en") == 0) {
         //Just remove all extra translators
         if (mTranslator) {
             qApp->removeTranslator(mTranslator);
@@ -99,22 +86,19 @@ bool TranslationHandler::setLanguage(const QString &code)
     }
 
     //Make sure the translator is otherwise valid
-    int index = getLanguageIndexByCode(code);
+    const int index = getLanguageIndexByCode(code);
     if (index == -1) {
         error = QObject::tr("Unknown language specified!");
         failure = true;
     } else {
         // Make sure there is a translator
-        if (!mTranslator && !failure)
+        if (!mTranslator)
             mTranslator = new QTranslator(this);
 
         //Load the new language
         const QString appPath = QFileInfo(QCoreApplication::applicationFilePath()).canonicalPath();
 
-        QSettings settings;
-        QString datadir = settings.value("DATADIR").toString();
-        if (datadir.isEmpty())
-            datadir = appPath;
+        QString datadir = getDataDir();
 
         QString translationFile;
         if (QFile::exists(datadir + "/lang/" + mTranslations[index].mFilename + ".qm"))
@@ -126,18 +110,19 @@ bool TranslationHandler::setLanguage(const QString &code)
         else
             translationFile = appPath + "/" + mTranslations[index].mFilename + ".qm";
 
-        if (!mTranslator->load(translationFile) && !failure) {
+        if (!mTranslator->load(translationFile)) {
+            failure = true;
             //If it failed, lets check if the default file exists
             if (!QFile::exists(translationFile)) {
                 error = QObject::tr("Language file %1 not found!");
                 error = error.arg(translationFile);
-                failure = true;
             }
-
-            //If file exists, there's something wrong with it
-            error = QObject::tr("Failed to load translation for language %1 from file %2");
-            error = error.arg(mTranslations[index].mName);
-            error = error.arg(translationFile);
+            else {
+                //If file exists, there's something wrong with it
+                error = QObject::tr("Failed to load translation for language %1 from file %2");
+                error = error.arg(mTranslations[index].mName);
+                error = error.arg(translationFile);
+            }
         }
     }
 
@@ -162,7 +147,7 @@ bool TranslationHandler::setLanguage(const QString &code)
     return true;
 }
 
-QString TranslationHandler::getCurrentLanguage() const
+const QString& TranslationHandler::getCurrentLanguage() const
 {
     return mCurrentLanguage;
 }
@@ -174,7 +159,7 @@ QString TranslationHandler::suggestLanguage() const
     //qDebug()<<"Your language is"<<language;
 
     //And see if we can find it from our list of language files
-    int index = getLanguageIndexByCode(language);
+    const int index = getLanguageIndexByCode(language);
 
     //If nothing found, return English
     if (index < 0) {
@@ -189,22 +174,15 @@ void TranslationHandler::addTranslation(const char *name, const char *filename)
     TranslationInfo info;
     info.mName = name;
     info.mFilename = filename;
-    int codeLength = QString(filename).length() - QString(filename).indexOf('_') - 1;
+    const int codeLength = QString(filename).length() - QString(filename).indexOf('_') - 1;
     info.mCode = QString(filename).right(codeLength);
     mTranslations.append(info);
 }
 
 int TranslationHandler::getLanguageIndexByCode(const QString &code) const
 {
-    int index = -1;
-    for (int i = 0; i < mTranslations.size(); i++) {
-        if (mTranslations[i].mCode == code) {
-            index = i;
-            break;
-        } else if (mTranslations[i].mCode == code.left(2)) {
-            index = i;
-            break;
-        }
-    }
-    return index;
+    auto it = std::find_if(mTranslations.cbegin(), mTranslations.cend(), [&](const TranslationInfo& ti) {
+        return ti.mCode == code || ti.mCode == code.left(2);
+    });
+    return it == mTranslations.cend() ? -1 : static_cast<int>(std::distance(mTranslations.cbegin(), it));
 }
diff --git a/gui/translationhandler.h b/gui/translationhandler.h
index 01a91064211..4cea7d4ce80 100644
--- a/gui/translationhandler.h
+++ b/gui/translationhandler.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,129 +19,122 @@
 #ifndef TRANSLATIONHANDLER_H
 #define TRANSLATIONHANDLER_H
 
-#include <QStringList>
-#include <QTranslator>
-#include <QObject>
 #include <QList>
+#include <QObject>
+#include <QString>
+
+class QTranslator;
 
 /// @addtogroup GUI
 /// @{
 
 /**
-* @brief Information for one translation.
-*
-*/
+ * @brief Information for one translation.
+ *
+ */
 struct TranslationInfo {
     /**
-    * @brief Readable name for the translation (e.g. "English").
-    *
-    */
+     * @brief Readable name for the translation (e.g. "English").
+     *
+     */
     QString mName;
 
     /**
-    * @brief Filename for the translation.
-    *
-    */
+     * @brief Filename for the translation.
+     *
+     */
     QString mFilename;
 
     /**
-    * @brief ISO 639 language code for the translation (e.g. "en").
-    *
-    */
+     * @brief ISO 639 language code for the translation (e.g. "en").
+     *
+     */
     QString mCode;
 };
 
 /**
-* @brief A class handling the available translations.
-*
-* This class contains a list of available translations. The class also keeps
-* track which translation is the currently active translation.
-*
-*/
-class TranslationHandler : QObject {
+ * @brief A class handling the available translations.
+ *
+ * This class contains a list of available translations. The class also keeps
+ * track which translation is the currently active translation.
+ *
+ */
+class TranslationHandler : public QObject {
     Q_OBJECT
 public:
     explicit TranslationHandler(QObject *parent = nullptr);
-    virtual ~TranslationHandler();
-
-    /**
-    * @brief Get a list of available translation names.
-    * @return List of available translation names.
-    *
-    */
-    const QStringList getNames() const;
 
     /**
-    * @brief Get a list of available translations.
-    * @return List of available translations.
-    *
-    */
-    QList<TranslationInfo> getTranslations() const {
+     * @brief Get a list of available translations.
+     * @return List of available translations.
+     *
+     */
+    const QList<TranslationInfo>& getTranslations() const {
         return mTranslations;
     }
 
     /**
-    * @brief Set active translation.
-    * @param code ISO 639 language code for new selected translation.
-    * @return true if succeeds, false otherwise.
-    *
-    */
+     * @brief Set active translation.
+     * @param code ISO 639 language code for new selected translation.
+     * @return true if succeeds, false otherwise.
+     *
+     */
     bool setLanguage(const QString &code);
 
     /**
-    * @brief Get currently selected translation.
-    * @return ISO 639 language code for current translation.
-    *
-    */
-    QString getCurrentLanguage() const;
+     * @brief Get currently selected translation.
+     * @return ISO 639 language code for current translation.
+     *
+     */
+    const QString& getCurrentLanguage() const;
 
     /**
-    * @brief Get translation suggestion for the system.
-    * This function checks the current system locale and determines which of
-    * the available translations is best as current translation. If none of
-    * the available translations is good then it returns English ("en").
-    * @return Suggested translation ISO 639 language code.
-    *
-    */
+     * @brief Get translation suggestion for the system.
+     * This function checks the current system locale and determines which of
+     * the available translations is best as current translation. If none of
+     * the available translations is good then it returns English ("en").
+     * @return Suggested translation ISO 639 language code.
+     *
+     */
     QString suggestLanguage() const;
 
 protected:
 
     /**
-    * @brief Add new translation to list of available translations.
-    * @param name Name of the translation ("English").
-    * @param filename Filename of the translation.
-    *
-    */
+     * @brief Add new translation to list of available translations.
+     * @param name Name of the translation ("English").
+     * @param filename Filename of the translation.
+     *
+     */
     void addTranslation(const char *name, const char *filename);
 
     /**
-    * @brief Find language in the list and return its index.
-    * @param code ISO 639 language code.
-    * @return Index at list, or -1 if not found.
-    *
-    */
+     * @brief Find language in the list and return its index.
+     * @param code ISO 639 language code.
+     * @return Index at list, or -1 if not found.
+     *
+     */
     int getLanguageIndexByCode(const QString &code) const;
 
 private:
 
     /**
-    * @brief ISO 639 language code of the currently selected translation.
-    *
-    */
+     * @brief ISO 639 language code of the currently selected translation.
+     *
+     */
     QString mCurrentLanguage;
 
     /**
-    * @brief List of available translations.
-    *
-    */
+     * @brief List of available translations.
+     *
+     */
     QList<TranslationInfo> mTranslations;
 
     /**
-    * @brief Translator class instance.
-    *
-    */
-    QTranslator *mTranslator;
+     * @brief Translator class instance.
+     *
+     */
+    QTranslator* mTranslator{};
 };
 
 /// @}
diff --git a/gui/txtreport.cpp b/gui/txtreport.cpp
index cbf25f1ea45..38753bfdd0c 100644
--- a/gui/txtreport.cpp
+++ b/gui/txtreport.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,17 +16,18 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QDir>
 #include "txtreport.h"
 
+#include "erroritem.h"
+
+#include <QDir>
+#include <QFile>
+#include <QList>
+#include <QtGlobal>
+
 TxtReport::TxtReport(const QString &filename) :
     Report(filename)
-{
-}
-
-TxtReport::~TxtReport()
-{
-}
+{}
 
 bool TxtReport::create()
 {
@@ -50,9 +51,9 @@ void TxtReport::writeFooter()
 void TxtReport::writeError(const ErrorItem &error)
 {
     /*
-    Error example from the core program in text
-    [gui/test.cpp:23] -> [gui/test.cpp:14]: (error) Mismatching allocation and deallocation: k
-    */
+       Error example from the core program in text
+       [gui/test.cpp:23] -> [gui/test.cpp:14]: (error) Mismatching allocation and deallocation: k
+     */
 
     QString line;
 
@@ -76,5 +77,5 @@ void TxtReport::writeError(const ErrorItem &error)
     line += temp.arg(GuiSeverity::toString(error.severity));
     line += error.summary;
 
-    mTxtWriter << line << endl;
+    mTxtWriter << line << Qt::endl;
 }
diff --git a/gui/txtreport.h b/gui/txtreport.h
index 5ba3e349d4f..35c6a5a5bfa 100644
--- a/gui/txtreport.h
+++ b/gui/txtreport.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,52 +19,53 @@
 #ifndef TXT_REPORT_H
 #define TXT_REPORT_H
 
+#include "report.h"
+
 #include <QString>
+#include <QObject>
 #include <QTextStream>
-#include "report.h"
 
 /// @addtogroup GUI
 /// @{
 
 
 /**
-* @brief Text file report.
-* This report mimics the output of the command line cppcheck.
-*/
+ * @brief Text file report.
+ * This report mimics the output of the command line cppcheck.
+ */
 class TxtReport : public Report {
     Q_OBJECT
 
 public:
     explicit TxtReport(const QString &filename);
-    virtual ~TxtReport();
 
     /**
-    * @brief Create the report (file).
-    * @return true if succeeded, false if file could not be created.
-    */
-    virtual bool create() override;
+     * @brief Create the report (file).
+     * @return true if succeeded, false if file could not be created.
+     */
+    bool create() override;
 
     /**
-    * @brief Write report header.
-    */
-    virtual void writeHeader() override;
+     * @brief Write report header.
+     */
+    void writeHeader() override;
 
     /**
-    * @brief Write report footer.
-    */
-    virtual void writeFooter() override;
+     * @brief Write report footer.
+     */
+    void writeFooter() override;
 
     /**
-    * @brief Write error to report.
-    * @param error Error data.
-    */
-    virtual void writeError(const ErrorItem &error) override;
+     * @brief Write error to report.
+     * @param error Error data.
+     */
+    void writeError(const ErrorItem &error) override;
 
 private:
 
     /**
-    * @brief Text stream writer for writing the report in text format.
-    */
+     * @brief Text stream writer for writing the report in text format.
+     */
     QTextStream mTxtWriter;
 };
 /// @}
diff --git a/gui/xmlreport.cpp b/gui/xmlreport.cpp
index 4e22b842494..c5f00fc5bb7 100644
--- a/gui/xmlreport.cpp
+++ b/gui/xmlreport.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2017 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,20 +16,21 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QObject>
-#include <QString>
+#include "xmlreport.h"
+
+#include "report.h"
+
 #include <QFile>
+#include <QIODevice>
+#include <QXmlStreamAttributes>
 #include <QXmlStreamReader>
-#include "report.h"
-#include "xmlreport.h"
 
-static const char ResultElementName[] = "results";
-static const char VersionAttribute[] = "version";
+static constexpr char ResultElementName[] = "results";
+static constexpr char VersionAttribute[] = "version";
 
 XmlReport::XmlReport(const QString &filename) :
     Report(filename)
-{
-}
+{}
 
 QString XmlReport::quoteMessage(const QString &message)
 {
@@ -57,7 +58,7 @@ int XmlReport::determineVersion(const QString &filename)
 {
     QFile file;
     file.setFileName(filename);
-    bool succeed = file.open(QIODevice::ReadOnly | QIODevice::Text);
+    const bool succeed = file.open(QIODevice::ReadOnly | QIODevice::Text);
     if (!succeed)
         return 0;
 
@@ -65,13 +66,13 @@ int XmlReport::determineVersion(const QString &filename)
     while (!reader.atEnd()) {
         switch (reader.readNext()) {
         case QXmlStreamReader::StartElement:
-            if (reader.name() == ResultElementName) {
+            if (reader.name() == QString(ResultElementName)) {
                 QXmlStreamAttributes attribs = reader.attributes();
                 if (attribs.hasAttribute(QString(VersionAttribute))) {
-                    int ver = attribs.value(QString(), VersionAttribute).toString().toInt();
+                    const int ver = attribs.value(QString(), VersionAttribute).toString().toInt();
                     return ver;
-                } else
-                    return 1;
+                }
+                return 1;
             }
             break;
 
diff --git a/gui/xmlreport.h b/gui/xmlreport.h
index 9e917b5f947..2483b1b7471 100644
--- a/gui/xmlreport.h
+++ b/gui/xmlreport.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2017 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,20 +19,20 @@
 #ifndef XML_REPORT_H
 #define XML_REPORT_H
 
+#include "report.h"
+
 #include <QString>
 #include <QList>
-#include "report.h"
-#include "erroritem.h"
 
-class QObject;
+class ErrorItem;
 
 /// @addtogroup GUI
 /// @{
 
 
 /**
-* @brief Base class for XML report classes.
-*/
+ * @brief Base class for XML report classes.
+ */
 class XmlReport : public Report {
 public:
     explicit XmlReport(const QString &filename);
diff --git a/gui/xmlreportv2.cpp b/gui/xmlreportv2.cpp
index f70053de564..abf6aa361ba 100644
--- a/gui/xmlreportv2.cpp
+++ b/gui/xmlreportv2.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,17 +16,25 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <QObject>
-#include <QString>
-#include <QList>
-#include <QDir>
-#include <QXmlStreamWriter>
-#include <QDebug>
-#include "report.h"
-#include "erroritem.h"
-#include "xmlreport.h"
 #include "xmlreportv2.h"
+
 #include "cppcheck.h"
+#include "erroritem.h"
+#include "report.h"
+#include "settings.h"
+#include "xmlreport.h"
+
+#include <utility>
+
+#include <QDebug>
+#include <QDir>
+#include <QFile>
+#include <QXmlStreamAttributes>
+#include <QXmlStreamReader>
+#include <QXmlStreamWriter>
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 5, 0))
+#include <QtLogging>
+#endif
 
 static const QString ResultElementName = "results";
 static const QString CppcheckElementName = "cppcheck";
@@ -34,11 +42,13 @@ static const QString ErrorElementName = "error";
 static const QString ErrorsElementName = "errors";
 static const QString LocationElementName = "location";
 static const QString CWEAttribute = "cwe";
+static const QString HashAttribute = "hash";
 static const QString SinceDateAttribute = "sinceDate";
 static const QString TagsAttribute = "tag";
 static const QString FilenameAttribute = "file";
 static const QString IncludedFromFilenameAttribute = "file0";
 static const QString InconclusiveAttribute = "inconclusive";
+static const QString RemarkAttribute = "remark";
 static const QString InfoAttribute = "info";
 static const QString LineAttribute = "line";
 static const QString ColumnAttribute = "column";
@@ -46,14 +56,15 @@ static const QString IdAttribute = "id";
 static const QString SeverityAttribute = "severity";
 static const QString MsgAttribute = "msg";
 static const QString VersionAttribute = "version";
+static const QString ProductNameAttribute = "product-name";
 static const QString VerboseAttribute = "verbose";
 
-XmlReportV2::XmlReportV2(const QString &filename) :
+XmlReportV2::XmlReportV2(const QString &filename, QString productName) :
     XmlReport(filename),
+    mProductName(std::move(productName)),
     mXmlReader(nullptr),
     mXmlWriter(nullptr)
-{
-}
+{}
 
 XmlReportV2::~XmlReportV2()
 {
@@ -81,12 +92,19 @@ bool XmlReportV2::open()
 
 void XmlReportV2::writeHeader()
 {
+    const auto nameAndVersion = Settings::getNameAndVersion(mProductName.toStdString());
+    const QString name = QString::fromStdString(nameAndVersion.first);
+    // TODO: lacks extraVersion
+    const QString version = nameAndVersion.first.empty() ? CppCheck::version() : QString::fromStdString(nameAndVersion.second);
+
     mXmlWriter->setAutoFormatting(true);
     mXmlWriter->writeStartDocument();
     mXmlWriter->writeStartElement(ResultElementName);
     mXmlWriter->writeAttribute(VersionAttribute, QString::number(2));
     mXmlWriter->writeStartElement(CppcheckElementName);
-    mXmlWriter->writeAttribute(VersionAttribute, QString(CppCheck::version()));
+    if (!name.isEmpty())
+        mXmlWriter->writeAttribute(ProductNameAttribute, name);
+    mXmlWriter->writeAttribute(VersionAttribute, version);
     mXmlWriter->writeEndElement();
     mXmlWriter->writeStartElement(ErrorsElementName);
 }
@@ -101,13 +119,13 @@ void XmlReportV2::writeFooter()
 void XmlReportV2::writeError(const ErrorItem &error)
 {
     /*
-    Error example from the core program in xml
-    <error id="mismatchAllocDealloc" severity="error" msg="Mismatching allocation and deallocation: k"
+       Error example from the core program in xml
+       <error id="mismatchAllocDealloc" severity="error" msg="Mismatching allocation and deallocation: k"
               verbose="Mismatching allocation and deallocation: k">
-      <location file="..\..\test\test.cxx" line="16"/>
-      <location file="..\..\test\test.cxx" line="32"/>
-    </error>
-    */
+       <location file="..\..\test\test.cxx" line="16"/>
+       <location file="..\..\test\test.cxx" line="32"/>
+       </error>
+     */
 
     mXmlWriter->writeStartElement(ErrorElementName);
     mXmlWriter->writeAttribute(IdAttribute, error.errorId);
@@ -120,8 +138,14 @@ void XmlReportV2::writeError(const ErrorItem &error)
     mXmlWriter->writeAttribute(VerboseAttribute, message);
     if (error.inconclusive)
         mXmlWriter->writeAttribute(InconclusiveAttribute, "true");
+    if (!error.remark.isEmpty())
+        mXmlWriter->writeAttribute(RemarkAttribute, error.remark);
     if (error.cwe > 0)
         mXmlWriter->writeAttribute(CWEAttribute, QString::number(error.cwe));
+    if (error.hash > 0)
+        mXmlWriter->writeAttribute(HashAttribute, QString::number(error.hash));
+    if (!error.file0.isEmpty())
+        mXmlWriter->writeAttribute(IncludedFromFilenameAttribute, quoteMessage(error.file0));
     if (!error.sinceDate.isEmpty())
         mXmlWriter->writeAttribute(SinceDateAttribute, error.sinceDate);
     if (!error.tags.isEmpty())
@@ -131,9 +155,6 @@ void XmlReportV2::writeError(const ErrorItem &error)
         mXmlWriter->writeStartElement(LocationElementName);
 
         QString file = QDir::toNativeSeparators(error.errorPath[i].file);
-        if (!error.file0.isEmpty() && file != error.file0) {
-            mXmlWriter->writeAttribute(IncludedFromFilenameAttribute, quoteMessage(error.file0));
-        }
         mXmlWriter->writeAttribute(FilenameAttribute, XmlReport::quoteMessage(file));
         mXmlWriter->writeAttribute(LineAttribute, QString::number(error.errorPath[i].line));
         if (error.errorPath[i].column > 0)
@@ -189,16 +210,16 @@ QList<ErrorItem> XmlReportV2::read()
     return errors;
 }
 
-ErrorItem XmlReportV2::readError(QXmlStreamReader *reader)
+ErrorItem XmlReportV2::readError(const QXmlStreamReader *reader)
 {
     /*
-    Error example from the core program in xml
-    <error id="mismatchAllocDealloc" severity="error" msg="Mismatching allocation and deallocation: k"
+       Error example from the core program in xml
+       <error id="mismatchAllocDealloc" severity="error" msg="Mismatching allocation and deallocation: k"
               verbose="Mismatching allocation and deallocation: k">
-      <location file="..\..\test\test.cxx" line="16"/>
-      <location file="..\..\test\test.cxx" line="32"/>
-    </error>
-    */
+       <location file="..\..\test\test.cxx" line="16"/>
+       <location file="..\..\test\test.cxx" line="32"/>
+       </error>
+     */
 
     ErrorItem item;
 
@@ -213,8 +234,14 @@ ErrorItem XmlReportV2::readError(QXmlStreamReader *reader)
         item.message = XmlReport::unquoteMessage(message);
         if (attribs.hasAttribute(QString(), InconclusiveAttribute))
             item.inconclusive = true;
+        if (attribs.hasAttribute(QString(), RemarkAttribute))
+            item.remark = attribs.value(QString(), RemarkAttribute).toString();
         if (attribs.hasAttribute(QString(), CWEAttribute))
-            item.cwe = attribs.value(QString(), CWEAttribute).toString().toInt();
+            item.cwe = attribs.value(QString(), CWEAttribute).toInt();
+        if (attribs.hasAttribute(QString(), HashAttribute))
+            item.hash = attribs.value(QString(), HashAttribute).toULongLong();
+        if (attribs.hasAttribute(QString(), IncludedFromFilenameAttribute))
+            item.file0 = attribs.value(QString(), IncludedFromFilenameAttribute).toString();
         if (attribs.hasAttribute(QString(), SinceDateAttribute))
             item.sinceDate = attribs.value(QString(), SinceDateAttribute).toString();
         if (attribs.hasAttribute(QString(), TagsAttribute))
diff --git a/gui/xmlreportv2.h b/gui/xmlreportv2.h
index 7e4f82d8f70..58d368c4bc2 100644
--- a/gui/xmlreportv2.h
+++ b/gui/xmlreportv2.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,74 +19,79 @@
 #ifndef XML_REPORTV2_H
 #define XML_REPORTV2_H
 
-#include <QObject>
-#include <QString>
-#include <QXmlStreamReader>
-#include <QXmlStreamWriter>
+#include "erroritem.h"
 #include "xmlreport.h"
 
+#include <QString>
+
+class QXmlStreamReader;
+class QXmlStreamWriter;
+
 /// @addtogroup GUI
 /// @{
 
 
 /**
-* @brief XML file report version 2.
-* This report outputs XML-formatted report. The XML format must match command
-* line version's XML output.
-*/
+ * @brief XML file report version 2.
+ * This report outputs XML-formatted report. The XML format must match command
+ * line version's XML output.
+ */
 class XmlReportV2 : public XmlReport {
 public:
-    explicit XmlReportV2(const QString &filename);
-    virtual ~XmlReportV2();
+    explicit XmlReportV2(const QString &filename, QString productName);
+    ~XmlReportV2() override;
 
     /**
-    * @brief Create the report (file).
-    * @return true if succeeded, false if file could not be created.
-    */
-    virtual bool create() override;
+     * @brief Create the report (file).
+     * @return true if succeeded, false if file could not be created.
+     */
+    bool create() override;
 
     /**
-    * @brief Open existing report file.
-    */
-    virtual bool open() override;
+     * @brief Open existing report file.
+     */
+    bool open() override;
 
     /**
-    * @brief Write report header.
-    */
-    virtual void writeHeader() override;
+     * @brief Write report header.
+     */
+    void writeHeader() override;
 
     /**
-    * @brief Write report footer.
-    */
-    virtual void writeFooter() override;
+     * @brief Write report footer.
+     */
+    void writeFooter() override;
 
     /**
-    * @brief Write error to report.
-    * @param error Error data.
-    */
-    virtual void writeError(const ErrorItem &error) override;
+     * @brief Write error to report.
+     * @param error Error data.
+     */
+    void writeError(const ErrorItem &error) override;
 
     /**
-    * @brief Read contents of the report file.
-    */
-    virtual QList<ErrorItem> read() override;
+     * @brief Read contents of the report file.
+     */
+    QList<ErrorItem> read() override;
 
 protected:
     /**
-    * @brief Read and parse error item from XML stream.
-    * @param reader XML stream reader to use.
-    */
-    ErrorItem readError(QXmlStreamReader *reader);
+     * @brief Read and parse error item from XML stream.
+     * @param reader XML stream reader to use.
+     */
+    ErrorItem readError(const QXmlStreamReader *reader);
 
 private:
+    /** Product name read from cppcheck.cfg */
+    const QString mProductName;
+
     /**
-    * @brief XML stream reader for reading the report in XML format.
-    */
+     * @brief XML stream reader for reading the report in XML format.
+     */
     QXmlStreamReader *mXmlReader;
 
     /**
-    * @brief XML stream writer for writing the report in XML format.
-    */
+     * @brief XML stream writer for writing the report in XML format.
+     */
     QXmlStreamWriter *mXmlWriter;
 };
 /// @}
diff --git a/htmlreport/README.txt b/htmlreport/README.txt
index 88a84a1637f..38c035e27f2 100644
--- a/htmlreport/README.txt
+++ b/htmlreport/README.txt
@@ -3,7 +3,7 @@ cppcheck-htmlreport
 This is a little utility to generate a html report of a XML file produced by
 cppcheck.
 
-The utility is implemented in Python (2.7+) and requires the pygments module
+The utility is implemented in Python and requires the pygments module
 to generate syntax highlighted source code.
 If you are using a Debian based Linux system, the pygments package can be 
 installed by following command:
diff --git a/htmlreport/check.sh b/htmlreport/check.sh
deleted file mode 100755
index bff1e2ac843..00000000000
--- a/htmlreport/check.sh
+++ /dev/null
@@ -1,30 +0,0 @@
-#!/bin/bash -ex
-
-
-./cppcheck-htmlreport --file ../gui/test/data/xmlfiles/xmlreport_v1.xml --title "xml1 test" --report-dir . --source-dir ../test/
-./cppcheck-htmlreport --file ../gui/test/data/xmlfiles/xmlreport_v2.xml --title "xml2 test" --report-dir . --source-dir ../test/
-echo -e "\n"
-
-
-../cppcheck ../gui/test --enable=all  --inconclusive --xml-version=2 2> gui_test.xml
-xmllint --noout gui_test.xml
-./cppcheck-htmlreport --file ./gui_test.xml --title "xml2 + inconclusive test" --report-dir .
-echo ""
-
-../cppcheck ../gui/test --enable=all --inconclusive --verbose --xml-version=2 2> gui_test.xml
-xmllint --noout gui_test.xml
-./cppcheck-htmlreport --file ./gui_test.xml --title "xml2 + inconclusive + verbose test" --report-dir .
-echo -e "\n"
-
-
-../cppcheck --errorlist --inconclusive --xml-version=2 > errorlist.xml
-xmllint --noout errorlist.xml
-./cppcheck-htmlreport --file ./errorlist.xml --title "errorlist" --report-dir .
-
-../cppcheck ../samples/memleak/good.c ../samples/resourceLeak/good.c  --xml-version=2 --enable=information --suppressions-list=test_suppressions.txt --xml 2> unmatchedSuppr.xml
-xmllint --noout unmatchedSuppr.xml
-./cppcheck-htmlreport --file ./unmatchedSuppr.xml --title "unmatched Suppressions" --report-dir=.
-grep "unmatchedSuppression<.*>information<.*>Unmatched suppression: variableScope*<" index.html
-grep ">unmatchedSuppression</.*>information<.*>Unmatched suppression: uninitstring<" index.html
-grep "notexisting" index.html
-grep ">unmatchedSuppression<.*>information<.*>Unmatched suppression: \*<" index.html
diff --git a/htmlreport/cppcheck-htmlreport b/htmlreport/cppcheck-htmlreport
index a48f643c471..5044443a0a9 100755
--- a/htmlreport/cppcheck-htmlreport
+++ b/htmlreport/cppcheck-htmlreport
@@ -1,17 +1,23 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 from __future__ import unicode_literals
 
+from datetime import date
+import argparse
 import io
-import sys
-import optparse
-import os
+import locale
 import operator
+import os
+import re
+import sys
+import subprocess
+import time
 
 from collections import Counter
 from pygments import highlight
-from pygments.lexers import guess_lexer_for_filename
-from pygments.formatters import HtmlFormatter
+from pygments.lexers import guess_lexer, guess_lexer_for_filename
+from pygments.formatters import HtmlFormatter  # pylint: disable=no-name-in-module
+from pygments.util import ClassNotFound
 from xml.sax import parse as xml_parse
 from xml.sax import SAXParseException as XmlParseException
 from xml.sax.handler import ContentHandler as XmlContentHandler
@@ -23,56 +29,159 @@ with syntax highlighted source code.
 
 STYLE_FILE = """
 body {
-    font: 13px Arial, Verdana, Sans-Serif;
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif;
+    font-size: 13px;
+    line-height: 1.5;
+    height: 100%;
     margin: 0;
-    width: auto;
+}
+
+#wrapper {
+    position: fixed;
+    height: 100vh;
+    width: 100vw;
+    display: grid;
+    grid-template-rows: fit-content(8rem) auto fit-content(8rem);
+    grid-template-columns: fit-content(25%) 1fr;
+    grid-template-areas:
+      "header header"
+      "menu content"
+      "footer footer";
 }
 
 h1 {
-    margin: 10px;
+    margin: 0 0 8px -2px;
+    font-size: 175%;
+}
+
+.header {
+    padding: 0 0 5px 15px;
+    grid-area: header;
+    border-bottom: thin solid #aaa;
 }
 
-#footer > p {
+.footer {
+    grid-area: footer;
+    border-top: thin solid #aaa;
+    font-size: 85%;
+
+}
+
+.footer > p {
     margin: 4px;
 }
 
+#menu,
+#menu_index {
+    grid-area: menu;
+    text-align: left;
+    overflow: auto;
+    padding: 0 23px 15px 15px;
+    border-right: thin solid #aaa;
+    min-width: 200px;
+}
+
+#menu > a {
+    display: block;
+    margin-left: 10px;
+    font-size: 12px;
+}
+
+#content,
+#content_index {
+    grid-area: content;
+    padding: 0px 5px 15px 15px;
+    overflow: auto;
+}
+
+label {
+    white-space: nowrap;
+}
+
+label.checkBtn.disabled {
+    color: #606060;
+    background: #e0e0e0;
+    font-style: italic;
+}
+
+label.checkBtn, input[type="text"] {
+    border: 1px solid grey;
+    border-radius: 4px;
+    box-shadow: 1px 1px inset;
+    padding: 1px 5px;
+}
+
+label.checkBtn {
+    white-space: nowrap;
+    background: #ccddff;
+}
+
+label.unchecked {
+    background: #eff8ff;
+    box-shadow: 1px 1px 1px;
+}
+
+label.checkBtn:hover, label.unchecked:hover{
+    box-shadow: 0 0 2px;
+}
+
+label.disabled:hover {
+    box-shadow: 1px 1px inset;
+}
+
+label.checkBtn > input {
+    display:none;
+}
+
+.summaryTable {
+    width: 100%;
+}
+
+table.summaryTable td { padding: 0 5px 0 5px; }
+
+.statHeader, .severityHeader, .classificationHeader {
+    font-weight: bold;
+}
+
+.warning {
+    background-color: #ffffa7;
+}
+
 .error {
     background-color: #ffb7b7;
 }
 
 .error2 {
     background-color: #faa;
-    border: 1px dotted black;
     display: inline-block;
     margin-left: 4px;
 }
 
 .inconclusive {
-    background-color: #B6B6B4;
+    background-color: #b6b6b4;
 }
 
 .inconclusive2 {
-    background-color: #B6B6B4;
-    border: 1px dotted black;
+    background-color: #b6b6b4;
     display: inline-block;
     margin-left: 4px;
 }
 
-div.verbose {
+.verbose {
     display: inline-block;
     vertical-align: top;
     cursor: help;
 }
 
-div.verbose div.content {
+.verbose .content {
     display: none;
     position: absolute;
     padding: 10px;
     margin: 4px;
     max-width: 40%;
     white-space: pre-wrap;
-    border: 1px solid black;
-    background-color: #FFFFCC;
+    border: 1px solid #000;
+    background-color: #ffffcc;
     cursor: auto;
 }
 
@@ -80,100 +189,25 @@ div.verbose div.content {
     padding: 1px;
 }
 
-#header {
-    border-bottom: thin solid #aaa;
-}
-
-#menu {
-    float: left;
-    margin-top: 5px;
-    text-align: left;
-    width: 150px;
-    height: 75%;
-    position: fixed;
-    overflow: auto;
-    z-index: 1;
-}
-
-#menu_index {
-    float: left;
-    margin-top: 5px;
-    padding-left: 5px;
-    text-align: left;
-    width: 300px;
-    height: 75%;
-    position: fixed;
-    overflow: auto;
-    z-index: 1;
-}
-
-#menu > a {
-    display: block;
-    margin-left: 10px;
-    font: 12px;
-    z-index: 1;
-}
-
-#filename  {
-    margin-left: 10px;
-    font: 12px;
-    z-index: 1;
-}
-
 .highlighttable {
-    background-color:white;
-    z-index: 10;
+    background-color: #fff;
     position: relative;
-    margin: -10 px;
-}
-
-#content {
-    background-color: white;
-    -webkit-box-sizing: content-box;
-    -moz-box-sizing: content-box;
-    box-sizing: content-box;
-    float: left;
-    margin: 5px;
-    margin-left: 10px;
-    padding: 0 10px 10px 10px;
-    width: 80%;
-    padding-left: 150px;
-}
-
-#content_index {
-    background-color: white;
-    -webkit-box-sizing: content-box;
-    -moz-box-sizing: content-box;
-    box-sizing: content-box;
-    float: left;
-    margin: 5px;
-    margin-left: 10px;
-    padding: 0 10px 10px 10px;
-    width: 80%;
-    padding-left: 300px;
+    margin: -10px;
 }
 
 .linenos {
     border-right: thin solid #aaa;
-    color: lightgray;
+    color: #d3d3d3;
     padding-right: 6px;
 }
 
-#footer {
-    border-top: thin solid #aaa;
-    clear: both;
-    font-size: 90%;
-    margin-top: 5px;
-}
-
-#footer ul {
-    list-style-type: none;
-    padding-left: 0;
+.id-filtered, .severity-filtered, .classification-filtered, .file-filtered, .tool-filtered, .text-filtered {
+    visibility: collapse;
 }
 """
 
 HTML_HEAD = """
-<!DOCTYPE html>
+<!doctype html>
 <html lang="en">
   <head>
     <meta charset="utf-8">
@@ -182,93 +216,237 @@ HTML_HEAD = """
     <style>
 %s
     </style>
-    <script language="javascript">
-      function getStyle(el,styleProp) {
-        if (el.currentStyle)
-          var y = el.currentStyle[styleProp];
-        else if (window.getComputedStyle)
-          var y = document.defaultView.getComputedStyle(el,null).getPropertyValue(styleProp);
+    <script>
+      function getStyle(el, styleProp) {
+        var y;
+
+        if (el.currentStyle) {
+          y = el.currentStyle[styleProp];
+        } else if (window.getComputedStyle) {
+          y = document.defaultView.getComputedStyle(el, null).getPropertyValue(styleProp);
+        }
+
         return y;
       }
+
       function toggle() {
         var el = this.expandable_content;
         var mark = this.expandable_marker;
-        if (el.style.display == "block") {
+
+        if (el.style.display === "block") {
           el.style.display = "none";
-          mark.innerHTML = "[+]";
+          mark.textContent = "[+]";
         } else {
           el.style.display = "block";
-          mark.innerHTML = "[-]";
+          mark.textContent = "[-]";
         }
       }
-      function init_expandables() {
-        var elts = document.getElementsByClassName("expandable");
-        for (var i = 0; i < elts.length; i++) {
-          var el = elts[i];
-          var clickable = el.getElementsByTagName("span")[0];
-          var marker = clickable.getElementsByClassName("marker")[0];
-          var content = el.getElementsByClassName("content")[0];
+
+      function initExpandables() {
+        var elements = document.querySelectorAll(".expandable");
+
+        for (var i = 0, len = elements.length; i < len; i++) {
+          var el = elements[i];
+          var clickable = el.querySelector("span");
+          var marker = clickable.querySelector(".marker");
+          var content = el.querySelector(".content");
           var width = clickable.clientWidth - parseInt(getStyle(content, "padding-left")) - parseInt(getStyle(content, "padding-right"));
           content.style.width = width + "px";
           clickable.expandable_content = content;
           clickable.expandable_marker = marker;
-          clickable.onclick = toggle;
+          clickable.addEventListener("click", toggle);
         }
       }
-      function set_class_display(c, st) {
-        var elements = document.querySelectorAll('.' + c),
-            len = elements.length;
-        for (i = 0; i < len; i++) {
-            elements[i].style.display = st;
+
+      function toggleDisplay(cb) {
+        var elements = document.querySelectorAll("." + cb.id);
+
+        for (var i = 0, len = elements.length; i < len; i++) {
+          elements[i].classList.toggle("id-filtered", !cb.checked);
         }
+
+        updateFileRows();
       }
-      function toggle_class_visibility(id) {
-        var box = document.getElementById(id);
-        set_class_display(id, box.checked ? '' : 'none');
+
+      function toggleSeverity(cb) {
+        cb.parentElement.classList.toggle("unchecked", !cb.checked);
+        var elements = document.querySelectorAll(".sev_" + cb.id);
+
+        for (var i = 0, len = elements.length; i < len; i++) {
+          elements[i].classList.toggle("severity-filtered", !cb.checked);
+        }
+
+        updateFileRows();
       }
-      function toggle_all(){
-        var elts = document.getElementsByTagName("input");
-        for (var i = 1; i < elts.length; i++) {           
-          var el = elts[i];
-          el.checked ? el.checked=false : el.checked=true;
-          toggle_class_visibility(el.id);        
-        }            
+      
+      function toggleClassification(cb) {
+        cb.parentElement.classList.toggle("unchecked", !cb.checked);
+        var elements = document.querySelectorAll(".class_" + cb.id);
+
+        for (var i = 0, len = elements.length; i < len; i++) {
+          elements[i].classList.toggle("classification-filtered", !cb.checked);
+        }
+
+        updateFileRows();
       }
+    
+      function toggleTool(cb) {
+        cb.parentElement.classList.toggle("unchecked", !cb.checked);
+
+        var elements;
+        if (cb.id == "clang-tidy")
+            elements = document.querySelectorAll("[class^=clang-tidy-]");
+        else
+            elements = document.querySelectorAll(".issue:not([class^=clang-tidy-])");
+
+        for (var i = 0, len = elements.length; i < len; i++) {
+          elements[i].classList.toggle("tool-filtered", !cb.checked);
+        }
 
+        updateFileRows();
+      }
+
+      function toggleAll() {
+        var elements = document.querySelectorAll(".idToggle");
+
+        // starting from 1 since 0 is the "toggle all" input
+        for (var i = 1, len = elements.length; i < len; i++) {
+          var changed = elements[i].checked != elements[0].checked;
+          if (changed) {
+            elements[i].checked = elements[0].checked;
+            toggleDisplay(elements[i]);
+          }
+        }
+      }
+
+      function filterFile(filter) {
+        var elements = document.querySelectorAll(".fileEntry");
+
+        for (var i = 0, len = elements.length; i < len; i++) {
+          var visible = elements[i].querySelector("tr").querySelector("td").textContent.toLowerCase().includes(filter.toLowerCase());
+          elements[i].classList.toggle("text-filtered", !visible);
+        }
+      }
+
+      function filterText(text) {
+        filter = text.toLowerCase();
+        var elements = document.querySelectorAll(".issue");
+
+        for (var i = 0, len = elements.length; i < len; i++) {
+          var visible = false;
+          var fields = elements[i].querySelectorAll("td");
+          for (var n = 0, num = fields.length; n < num; n++) {
+            if (fields[n].textContent.toLowerCase().includes(filter)) {
+              visible = true;
+              break;
+            }
+          }
+          elements[i].classList.toggle("text-filtered", !visible);
+        }
+
+        updateFileRows();
+      }
+
+      function updateFileRows(element) {
+        var elements = document.querySelectorAll(".fileEntry");
+
+        for (var i = 0, len = elements.length; i < len; i++) {
+          var visible = elements[i].querySelector(".issue:not(.id-filtered):not(.severity-filtered):not(.classification-filtered):not(.tool-filtered):not(.text-filtered)");
+          elements[i].classList.toggle("file-filtered", !visible);
+        }
+      }
+
+      function reapplyFilters() {
+        // Reapply ID filters
+        var idToggles = document.querySelectorAll(".idToggle");
+        for (var i = 1; i < idToggles.length; i++) {
+          var cb = idToggles[i];
+          var elements = document.querySelectorAll("." + cb.id);
+          for (var j = 0; j < elements.length; j++) {
+            elements[j].classList.toggle("id-filtered", !cb.checked);
+          }
+        }
+
+        // Reapply severity filters
+        var sevToggles = document.querySelectorAll(".sev_toggle");
+        for (var i = 0; i < sevToggles.length; i++) {
+          var cb = sevToggles[i];
+            var elements = document.querySelectorAll(".sev_" + cb.id);
+          for (var j = 0; j < elements.length; j++) {
+            elements[j].classList.toggle("severity-filtered", !cb.checked);
+          }
+        }
+
+        // Reapply classification filters
+        var classToggles = document.querySelectorAll(".class_toggle");
+        for (var i = 0; i < classToggles.length; i++) {
+          var cb = classToggles[i];
+          var elements = document.querySelectorAll(".class_" + cb.id);
+          for (var j = 0; j < elements.length; j++) {
+            elements[j].classList.toggle("classification-filtered", !cb.checked);
+          }
+        }
+
+        // Reapply tool filters
+        var toolToggles = document.querySelectorAll(".tool_toggle");
+        for (var i = 0; i < toolToggles.length; i++) {
+          var cb = toolToggles[i];
+          var elements;
+          if (cb.id == "clang-tidy")
+            elements = document.querySelectorAll("[class^=clang-tidy-]");
+          else
+            elements = document.querySelectorAll(".issue:not([class^=clang-tidy-])");
+
+          for (var j = 0; j < elements.length; j++) {
+            elements[j].classList.toggle("tool-filtered", !cb.checked);
+          }
+        }
+
+        // Update file rows
+        updateFileRows();
+      }
+
+      window.addEventListener("pageshow", reapplyFilters);
+      window.addEventListener("load", initExpandables);
     </script>
   </head>
-  <body onload="init_expandables()">
-      <div id="header">
-        <h1>Cppcheck report - %s: %s </h1>
-      </div>
-      <div id="menu" dir="rtl">
-       <p id="filename"><a href="index.html">Defects:</a> %s</p>
+  <body>
+    <div id="wrapper">
+    <div id="header" class="header">
+      <h1>Cppcheck report - %s%s</h1>
 """
 
 HTML_HEAD_END = """
-      </div>
-      <div id="content">
+    </div>
+"""
+
+HTML_MENU = """
+    <div id="menu">
+     <p><a href="index.html">Defects:</a> %s</p>
+"""
+
+HTML_MENU_END = """
+    </div>
+    <div id="content">
 """
 
 HTML_FOOTER = """
-      </div>
-      <div id="footer">
-        <p>
-         Cppcheck %s - a tool for static C/C++ code analysis</br>
-         </br>
-         Internet: <a href="http://cppcheck.net">http://cppcheck.net</a></br>
-         IRC: <a href="irc://irc.freenode.net/cppcheck">irc://irc.freenode.net/cppcheck</a></br>
-        <p>
-      </div>
+    </div>
+    <div id="footer" class="footer">
+      <p>
+        Created by Cppcheck %s (<a href="https://cppcheck.sourceforge.io">Sourceforge</a>, <a href="irc://irc.libera.chat/#cppcheck">IRC</a>)
+      </p>
+    </div>
+    </div>
   </body>
 </html>
 """
 
-HTML_ERROR = "<span class='error2'>&lt;--- %s</span>\n"
-HTML_INCONCLUSIVE = "<span class='inconclusive2'>&lt;--- %s</span>\n"
+HTML_ERROR = "<span class=\"error2\">&lt;--- %s</span>\n"
+HTML_INCONCLUSIVE = "<span class=\"inconclusive2\">&lt;--- %s</span>\n"
 
-HTML_EXPANDABLE_ERROR = "<div class='verbose expandable'><span class='error2'>&lt;--- %s <span class='marker'>[+]</span></span><div class='content'>%s</div></div>\n"""
-HTML_EXPANDABLE_INCONCLUSIVE = "<div class='verbose expandable'><span class='inconclusive2'>&lt;--- %s <span class='marker'>[+]</span></span><div class='content'>%s</div></div>\n"""
+HTML_EXPANDABLE_ERROR = "<div class=\"verbose expandable\"><span class=\"error2\">&lt;--- %s <span class=\"marker\">[+]</span></span><div class=\"content\">%s</div></div>\n"
+HTML_EXPANDABLE_INCONCLUSIVE = "<div class=\"verbose expandable\"><span class=\"inconclusive2\">&lt;--- %s <span class=\"marker\">[+]</span></span><div class=\"content\">%s</div></div>\n"
 
 # escape() and unescape() takes care of &, < and >.
 html_escape_table = {
@@ -281,13 +459,156 @@ html_unescape_table = {v: k for k, v in html_escape_table.items()}
 def html_escape(text):
     return escape(text, html_escape_table)
 
+def filter_button(enabled_filters, id, function):
+    enabled = enabled_filters.get(id, False)
+    if not id:
+        id = 'None'
+    return '\n        <label class="checkBtn%s"><input type="checkbox" onclick="%s(this)" id="%s" %s>%s</label>'\
+          % (' disabled' if not enabled else '', function, id, 'checked' if enabled else 'disabled', id)
+
+def filter_bar(enabled):
+    severity_bar = ''.join([filter_button(enabled, severity, 'toggleSeverity') for severity in ['error', 'warning', 'portability', 'performance', 'style', 'information']]) + '\n        | '
+    classification_bar = ''.join([filter_button(enabled, _class, 'toggleClassification') for _class in ['Mandatory', 'Required', 'Advisory', 'Document', 'Disapplied', 'L1','L2','L3','']]) + '\n        | '
+    if "checked/>" not in severity_bar:
+        severity_bar = ''
+    if "checked/>" not in classification_bar:
+        classification_bar = ''
+    return ''.join([
+     '      <div id="filters">\n'
+    ,severity_bar
+    , classification_bar
+    ,''.join([filter_button(enabled, tool, 'toggleTool') for tool in ['cppcheck', 'clang-tidy']])
+    ,'\n        | '
+    ,'\n        <label class="severityHeader">File: <input type="search" oninput="filterFile(this.value)"></label>'
+    ,'\n        <label class="severityHeader">Filter: <input type="search" oninput="filterText(this.value)"></label>'
+    ,'\n      </div>\n'])
+def git_blame(errors, path, file, blame_options):
+    last_line= errors[-1]['line']
+    if last_line == 0:
+        return {}
+
+    first_line = next((error for error in errors if error['line'] > 0))['line']
+
+    full_path = os.path.join(path, file)
+    path, filename = os.path.split(full_path)
+
+    if not path:
+        path = None  # make sure this is None
+
+    cmd_args = ['git', 'blame', '-L %d,%d' % (first_line, last_line)]
+    if '-w' in blame_options:
+        cmd_args.append('-w')
+    if '-M' in blame_options:
+        cmd_args.append('-M')
+    cmd_args = cmd_args + ['--porcelain', '--incremental', '--', filename]
+
+    try:
+        result = subprocess.check_output(cmd_args, cwd=path)
+        result = result.decode(locale.getpreferredencoding())
+    except:
+        return []
+
+    if result.startswith('fatal'):
+        return []
+
+    blame_data = []
+    line_from = 0
+    line_to = 0
+    blame_info = {}
+
+    for line_str in result.splitlines():
+        field, _, value = line_str.partition(' ')
+        if len(field) == 40:
+            line_nr, count = value.split(' ')[1:]
+            line_from = int(line_nr)
+            line_to = line_from + int(count)
+        elif field.startswith('author'):
+            blame_info[field] = value
+            if field == 'author-time':
+                author_date = date.fromtimestamp(int(blame_info['author-time']))
+                blame_info['author-time'] = author_date.strftime("%d/%m/%Y")
+        elif field == 'filename':
+            blame_data.append([line_from, line_to, blame_info.copy()])
+
+    return blame_data
+
+
+def blame_lookup(blame_data, line):
+    return next((data for start, end, data in blame_data if line >= start and line < end), {})
+
+
+def tr_str(td_th, line, id, cwe, severity, classification, guideline, message, timestamp, author, author_mail, date, add_author, tr_class=None, htmlfile=None, message_class=None):
+    ret = ''
+    items = [id, cwe]
+    if severity:
+        items.append(severity)
+    if classification:
+        items.extend([classification, guideline])
+    if htmlfile:
+        if htmlfile.startswith("http://") or htmlfile.startswith("https://"):
+            # GitHub/GitLab style line anchor
+            href = f"{htmlfile.rstrip('#L1')}#L{line}"
+            # Emit **line number with link**
+            ret += f'<{td_th}><a href="{href}" target="_blank" rel="noopener noreferrer">{line}</a></{td_th}>'
+        else:
+            # local HTML annotated
+            href = f"{htmlfile}#line-{line}"
+            # Emit **line number with link**
+            ret += f'<{td_th}><a href="{href}">{line}</a></{td_th}>'
+
+        # Emit id, cwe, severity, classification, ...
+        for item in items:
+            ret += f'<{td_th}>{item}</{td_th}>'
+    else:
+        items.insert(0,line)
+        for item in items:
+            ret += '<%s>%s</%s>' % (td_th, item, td_th)
+    if message_class:
+        message_attribute = ' class="%s"' % message_class
+    else:
+        message_attribute = ''
+    ret += '<%s%s>%s</%s>' % (td_th, message_attribute, html_escape(message), td_th)
+
+    if timestamp:
+        ret += '<%s>%s</%s>' % (td_th, timestamp, td_th)
+
+    for field in  add_author:
+        if field == 'name':
+            ret += '<%s>%s</%s>' % (td_th, html_escape(author), td_th)
+        elif field == 'email':
+            ret += '<%s>%s</%s>' % (td_th, html_escape(author_mail), td_th)
+        elif field == 'date':
+            ret += '<%s>%s</%s>' % (td_th, date, td_th)
+
+    if tr_class:
+        tr_attributes = ' class="%s"' % tr_class
+    else:
+        tr_attributes = ''
+    return '<tr%s>%s</tr>' % (tr_attributes, ret)
+
+
+def to_css_selector(tag):
+    # https://www.w3.org/TR/CSS2/syndata.html#characters
+    # Note: for our usage, we don't consider escaped characters
+    invalid_css_chars = re.compile(r"[^-_a-zA-Z0-9\u00A0-\uFFFF]")
+    invalid_start = re.compile(r"^([0-9]|-[0-9]|--)")
+    # Replace forbidden characters by an hyphen
+    valid_chars = invalid_css_chars.sub("-", tag)
+    # Check that the start of the tag doesn't break the rules
+    start_invalid = invalid_start.match(valid_chars)
+    if start_invalid:
+        # otherwise, append a token to make it valid
+        valid_chars_valid_start = "cpp" + valid_chars
+    else:
+        valid_chars_valid_start = valid_chars
+    return valid_chars_valid_start
 
 class AnnotateCodeFormatter(HtmlFormatter):
     errors = []
 
-    def wrap(self, source, outfile):
+    def wrap(self, *args, **kwargs):
         line_no = 1
-        for i, t in HtmlFormatter.wrap(self, source, outfile):
+        for i, t in HtmlFormatter.wrap(self, *args, **kwargs):
             # If this is a source code line we want to add a span tag at the
             # end.
             if i == 1:
@@ -322,6 +643,8 @@ class CppCheckHandler(XmlContentHandler):
         self.errors = []
         self.version = '1'
         self.versionCppcheck = ''
+        self.timestamp = ''
+        self.report_type = False
 
     def startElement(self, name, attributes):
         if name == 'results':
@@ -335,7 +658,10 @@ class CppCheckHandler(XmlContentHandler):
     def handleVersion1(self, name, attributes):
         if name != 'error':
             return
-
+        att_class = attributes.get('classification', '')
+        att_guide = attributes.get('guideline', '')
+        if att_class and not self.report_type:
+            self.report_type = True
         self.errors.append({
             'file': attributes.get('file', ''),
             'line': int(attributes.get('line', 0)),
@@ -345,6 +671,9 @@ class CppCheckHandler(XmlContentHandler):
             }],
             'id': attributes['id'],
             'severity': attributes['severity'],
+            'classification': att_class,
+            'guideline': att_guide,
+            'timestamp': self.timestamp,
             'msg': attributes['msg']
         })
 
@@ -352,12 +681,19 @@ class CppCheckHandler(XmlContentHandler):
         if name == 'cppcheck':
             self.versionCppcheck = attributes['version']
         if name == 'error':
+            att_class = attributes.get('classification', '')
+            att_guide = attributes.get('guideline', '')
+            if att_class and not self.report_type:
+                self.report_type = True
             error = {
                 'locations': [],
                 'file': '',
                 'line': 0,
                 'id': attributes['id'],
+                'classification': att_class,
                 'severity': attributes['severity'],
+                'guideline': att_guide,
+                'timestamp': self.timestamp,
                 'msg': attributes['msg'],
                 'verbose': attributes.get('verbose')
             }
@@ -382,33 +718,48 @@ class CppCheckHandler(XmlContentHandler):
                 'line': line,
                 'info': attributes.get('info')
             })
-
-if __name__ == '__main__':
+def main() -> None:
     # Configure all the options this little utility is using.
-    parser = optparse.OptionParser()
-    parser.add_option('--title', dest='title',
-                      help='The title of the project.',
-                      default='[project name]')
-    parser.add_option('--file', dest='file',
-                      help='The cppcheck xml output file to read defects '
-                           'from. Default is reading from stdin.')
-    parser.add_option('--report-dir', dest='report_dir',
-                      help='The directory where the HTML report content is '
-                           'written.')
-    parser.add_option('--source-dir', dest='source_dir',
-                      help='Base directory where source code files can be '
-                           'found.')
-    parser.add_option('--source-encoding', dest='source_encoding',
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--title', dest='title',
+                        help='The title of the project.',
+                        default='[project name]')
+    parser.add_argument('--file', dest='file', action="append",
+                        help='The cppcheck xml output file to read defects '
+                             'from. You can combine results from several '
+                             'xml reports i.e. "--file file1.xml --file file2.xml ..". '
+                             'Default is reading from stdin.')
+    parser.add_argument('--checkers-report-file', dest='checkers_report',
+                      help='The cppcheck checkers report file as produced '
+                           'with the "--checkers-report" option of cppcheck.')
+    parser.add_argument('--report-dir', dest='report_dir',
+                         help='The directory where the HTML report content is '
+                              'written.')
+    parser.add_argument('--source-dir', dest='source_dir',
+                         help='Base directory where source code files can be '
+                              'found, or a URL to a remote GitHub/GitLab '
+                              'repository including a branch, e.g. '
+                              '--source-dir=https://github.com/<username>/<repo>/blob/<branch>/')
+    parser.add_argument('--add-author-information', dest='add_author_information',
+                        help='Blame information to include. '
+                             'Adds specified author information. '
+                             'Specify as comma-separated list of either "name", "email", "date" or "n","e","d". '
+                             'Default: "n,e,d"')
+    parser.add_argument('--source-encoding', dest='source_encoding',
                       help='Encoding of source code.', default='utf-8')
+    parser.add_argument('--blame-options', dest='blame_options',
+                        help='[-w, -M] blame options which you can use to get author and author mail  '
+                             '-w --> not including white spaces and returns original author of the line  '
+                             '-M --> not including moving of lines and returns original author of the line')
 
     # Parse options and make sure that we have an output directory set.
-    options, args = parser.parse_args()
+    options = parser.parse_args()
 
     try:
         sys.argv[1]
     except IndexError:  # no arguments give, print --help
         parser.print_help()
-        quit()
+        sys.exit(0)
 
     if not options.report_dir:
         parser.error('No report directory set.')
@@ -418,21 +769,46 @@ if __name__ == '__main__':
     if options.source_dir:
         source_dir = options.source_dir
 
-    # Get the stream that we read cppcheck errors from.
-    input_file = sys.stdin
-    if options.file:
-        if not os.path.exists(options.file):
-            parser.error('cppcheck xml file: %s not found.' % options.file)
-        input_file = io.open(options.file, 'r')
-    else:
-        parser.error('No cppcheck xml file specified. (--file=)')
-
-    # Parse the xml file and produce a simple list of errors.
+    is_remote = False
+    if source_dir.startswith("http://") or source_dir.startswith("https://"):
+        is_remote = True
+
+    add_author_information = []
+    if options.add_author_information:
+        fields = [x.strip() for x in options.add_author_information.split(',')]
+        for x in fields:
+            if x.lower() in ['n', 'name']:
+                add_author_information.append('name')
+            elif x.lower() in ['e', 'email']:
+                add_author_information.append('email')
+            elif x.lower() in ['d', 'date']:
+                add_author_information.append('date')
+            else:
+                print('Unrecognized value "%s" for author information, using default (name, email, date)' % x)
+                add_author_information = ['name', 'email', 'date']
+                break
+
+    blame_options = ''
+    if options.blame_options:
+        blame_options = options.blame_options
+        add_author_information = add_author_information or ['name', 'email', 'date']
+
+    # Parse the xml from all files defined in file argument
+    # or from stdin. If no input is provided, stdin is used
+    # Produce a simple list of errors.
     print('Parsing xml report.')
     try:
         contentHandler = CppCheckHandler()
-        xml_parse(input_file, contentHandler)
-    except XmlParseException as msg:
+        for fname in options.file or [sys.stdin]:
+            if options.file is not None:
+                t = os.path.getmtime(fname)
+            else:
+                t = time.time()
+            t_s = time.ctime(t)
+            if t_s is not None:
+                contentHandler.timestamp = t_s
+            xml_parse(fname, contentHandler)
+    except (XmlParseException, ValueError) as msg:
         print('Failed to parse cppcheck xml file: %s' % msg)
         sys.exit(1)
 
@@ -444,10 +820,15 @@ if __name__ == '__main__':
     file_no = 0
     for error in contentHandler.errors:
         filename = error['file']
-        if filename not in files.keys():
-            files[filename] = {
-                'errors': [], 'htmlfile': str(file_no) + '.html'}
-            file_no = file_no + 1
+        if filename not in files:
+            if is_remote:
+                # Construct remote URL for GitHub/GitLab
+                # tr_str() will use the actual line number, so we can just start with line 1
+                remote_url = source_dir.rstrip('/') + '/' + filename + '#L1'
+                files[filename] = {'errors': [], 'htmlfile': remote_url}
+            else:
+                files[filename] = {'errors': [], 'htmlfile': str(file_no) + '.html'}
+                file_no += 1
         files[filename]['errors'].append(error)
 
     # Make sure that the report directory is created if it doesn't exist.
@@ -474,6 +855,8 @@ if __name__ == '__main__':
                     if location.get('info'):
                         newError['msg'] = location['info']
                         newError['severity'] = 'information'
+                        newError['classification'] = ''
+                        newError['guideline'] = ''
                         del newError['verbose']
 
                     errors.append(newError)
@@ -485,14 +868,17 @@ if __name__ == '__main__':
         if filename == '':
             continue
 
+        if is_remote:
+            # Remote source: do NOT generate local annotated HTML files.
+            # The index will still point directly to GitHub/GitLab URLs.
+            continue
+
         source_filename = os.path.join(source_dir, filename)
         try:
             with io.open(source_filename, 'r', encoding=options.source_encoding) as input_file:
                 content = input_file.read()
         except IOError:
-            if (error['id'] == 'unmatchedSuppression'):
-                continue  # file not found, bail out
-            else:
+            if error['id'] != 'unmatchedSuppression':
                 sys.stderr.write("ERROR: Source file '%s' not found.\n" %
                                  source_filename)
             continue
@@ -514,20 +900,24 @@ if __name__ == '__main__':
                               (options.title,
                                htmlFormatter.get_style_defs('.highlight'),
                                options.title,
-                               filename,
-                               filename.split('/')[-1]))
+                               ': ' + filename))
+            output_file.write(HTML_HEAD_END)
 
+            output_file.write(HTML_MENU % (filename.split('/')[-1]))
             for error in sorted(errors, key=lambda k: k['line']):
-                output_file.write("<a href='%s#line-%d'> %s %s</a>" % (data['htmlfile'], error['line'], error['id'],   error['line']))
+                output_file.write("<a href=\"%s#line-%d\"> %s %s</a>" % (data['htmlfile'], error['line'], error['id'], error['line']))
+            output_file.write(HTML_MENU_END)
 
-            output_file.write(HTML_HEAD_END)
             try:
-                lexer = guess_lexer_for_filename(source_filename, '')
-            except:
-                sys.stderr.write("ERROR: Couldn't determine lexer for the file' " + source_filename + " '. Won't be able to syntax highlight this file.")
-                output_file.write("\n <tr><td colspan='5'> Could not generated content because pygments failed to retrieve the determine code type.</td></tr>")
-                output_file.write("\n <tr><td colspan='5'> Sorry about this.</td></tr>")
-                continue
+                lexer = guess_lexer_for_filename(source_filename, '', stripnl=False)
+            except ClassNotFound:
+                try:
+                    lexer = guess_lexer(content, stripnl=False)
+                except ClassNotFound:
+                    sys.stderr.write("ERROR: Couldn't determine lexer for the file' " + source_filename + " '. Won't be able to syntax highlight this file.")
+                    output_file.write("\n <tr><td colspan=\"6\"> Could not generate content because pygments failed to determine the code type.</td></tr>")
+                    output_file.write("\n <tr><td colspan=\"6\"> Sorry about this.</td></tr>")
+                    continue
 
             if options.source_encoding:
                 lexer.encoding = options.source_encoding
@@ -549,9 +939,17 @@ if __name__ == '__main__':
 
         stats_count = 0
         stats = []
+        filter_enabled = {}
         for filename, data in sorted(files.items()):
             for error in data['errors']:
                 stats.append(error['id'])  # get the stats
+                if contentHandler.report_type:
+                    filter_enabled[error['severity']] = False
+                    filter_enabled[error['classification']] = True
+                else:
+                    filter_enabled[error['severity']] = True
+                    filter_enabled[error['classification']] = False
+                filter_enabled['clang-tidy' if error['id'].startswith('clang-tidy-') else 'cppcheck'] = True
                 stats_count += 1
 
         counter = Counter(stats)
@@ -569,88 +967,111 @@ if __name__ == '__main__':
         except IndexError:
             cnt_min = 0
 
-        stat_fmt = "            <tr><td><input type='checkbox' onclick='toggle_class_visibility(this.id)' id='{}' name='{}' checked></td><td>{}</td><td>{}</td></tr>"
+        stat_fmt = "\n            <tr><td><input type=\"checkbox\" class=\"idToggle\" onclick=\"toggleDisplay(this)\" id=\"{}\" name=\"{}\" checked></td><td>{}</td><td>{}</td></tr>"
         for occurrences in reversed(range(cnt_min, cnt_max + 1)):
             for _id in [k for k, v in sorted(counter.items()) if v == occurrences]:
-                stat_html.append(stat_fmt.format(_id, _id, dict(counter.most_common())[_id], _id))
-
-        output_file.write(HTML_HEAD.replace('id="menu" dir="rtl"', 'id="menu_index"', 1).replace("Defects:", "Defect summary;", 1) % (options.title, '', options.title, '', ''))
-        output_file.write('       <table>')
-        output_file.write('           <tr><th>Show</th><th>#</th><th>Defect ID</th></tr>')
-        output_file.write('<label><input type="checkbox" onclick="toggle_all()" checked/> Toggle all</label>')
+                stat_html.append(stat_fmt.format(
+                    to_css_selector(_id),
+                    to_css_selector(_id),
+                    dict(counter.most_common())[_id],
+                    _id
+                ))
+
+        output_file.write(HTML_HEAD % (options.title, '', options.title, ''))
+        output_file.write(filter_bar(filter_enabled))
+        output_file.write(HTML_HEAD_END)
+        output_file.write(HTML_MENU.replace('id="menu"', 'id="menu_index"', 1).replace("Defects:", "Defect summary", 1) % (''))
+        output_file.write('\n       <label><input type="checkbox" class=\"idToggle\" onclick="toggleAll()" checked> Toggle all</label>')
+        output_file.write('\n       <table>')
+        output_file.write('\n           <tr><th>Show</th><th>#</th><th>Defect ID</th></tr>')
         output_file.write(''.join(stat_html))
-        output_file.write('           <tr><td></td><td>' + str(stats_count) + '</td><td>total</td></tr>')
-        output_file.write('       </table>')
-        output_file.write('       <a href="stats.html">Statistics</a></p>')
-        output_file.write(HTML_HEAD_END.replace("content", "content_index", 1))
-        output_file.write('       <table>\n')
-
-        output_file.write(
-            '       <tr><th>Line</th><th>Id</th><th>CWE</th><th>Severity</th><th>Message</th></tr>')
-        for filename, data in sorted(files.items()):
-            if filename in decode_errors:  # don't print a link but a note
-                output_file.write("\n       <tr><td colspan='5'>%s</td></tr>" % (filename))
-                output_file.write("\n       <tr><td colspan='5'> Could not generated due to UnicodeDecodeError</td></tr>")
-            else:
-                if filename.endswith('*'):  # assume unmatched suppression
-                    output_file.write(
-                        "\n       <tr><td colspan='5'>%s</td></tr>" %
-                        (filename))
-                else:
-                    output_file.write(
-                        "\n       <tr><td colspan='5'><a href='%s'>%s</a></td></tr>" %
-                        (data['htmlfile'], filename))
-
-                for error in sorted(data['errors'], key=lambda k: k['line']):
-                    error_class = ''
-                    try:
-                        if error['inconclusive'] == 'true':
-                            error_class = 'class="inconclusive"'
-                            error['severity'] += ", inconcl."
-                    except KeyError:
-                        pass
+        output_file.write('\n           <tr><td></td><td>' + str(stats_count) + '</td><td>total</td></tr>')
+        output_file.write('\n       </table>')
+        output_file.write('\n       <p><a href="stats.html">Statistics</a></p>')
+        if options.checkers_report:
+            output_file.write('\n       <p><a href="checkers.html">Checkers</a></p>')
+        output_file.write(HTML_MENU_END.replace("content", "content_index", 1))
 
-                    try:
-                        if error['cwe']:
-                            cwe_url = "<a href='https://cwe.mitre.org/data/definitions/" + error['cwe'] + ".html'>" + error['cwe'] + "</a>"
-                    except KeyError:
-                        cwe_url = ""
-
-                    if error['severity'] == 'error':
-                        error_class = 'class="error"'
-                    if error['id'] == 'missingInclude':
-                        output_file.write(
-                            '\n         <tr class="%s"><td></td><td>%s</td><td></td><td>%s</td><td>%s</td></tr>' %
-                            (error['id'], error['id'], error['severity'], error['msg']))
-                    elif (error['id'] == 'unmatchedSuppression') and filename.endswith('*'):
-                        output_file.write(
-                            '\n         <tr class="%s"><td></td><td>%s</td><td></td><td>%s</td><td %s>%s</td></tr>' %
-                            (error['id'], error['id'], error['severity'], error_class,
-                             error['msg']))
-                    else:
-                        output_file.write(
-                            '\n       <tr class="%s"><td><a href="%s#line-%d">%d</a></td><td>%s</td><td>%s</td><td>%s</td><td %s>%s</td></tr>' %
-                            (error['id'], data['htmlfile'], error['line'], error['line'],
-                             error['id'], cwe_url, error['severity'], error_class,
-                             error['msg']))
+        output_file.write('\n       <table class=\"summaryTable\">')
+        if contentHandler.report_type:
+            output_file.write(
+                '\n       %s' %
+                tr_str('th', 'Line', 'Id', 'CWE', '', 'Classification', 'Guideline', 'Message', 'Timestamp',
+                       'Author', 'Author mail', 'Date (DD/MM/YYYY)', add_author=add_author_information))
+        else:
+            output_file.write(
+                '\n       %s' %
+                tr_str('th', 'Line', 'Id', 'CWE', 'Severity', '', '', 'Message', 'Timestamp', 'Author', 'Author mail', 'Date (DD/MM/YYYY)', add_author=add_author_information))
 
+        for filename, data in sorted(files.items()):
+            file_error = filename in decode_errors or filename.endswith('*')
+            is_file = filename != '' and not file_error
+            row_content = filename if file_error else "<a href=\"%s\">%s</a>" % (data['htmlfile'], filename)
+            htmlfile = data.get('htmlfile') if is_file else None
+
+            output_file.write("\n      <tbody class=\"fileEntry\">")
+            output_file.write("\n       <tr><td colspan=\"6\">%s</td></tr>" % row_content)
+
+            if filename in decode_errors:
+                output_file.write("\n       <tr><td colspan=\"6\">Could not generated due to UnicodeDecodeError</td></tr>")
+
+            sorted_errors = sorted(data['errors'], key=lambda k: k['line'])
+            blame_data = git_blame(sorted_errors, source_dir, filename, blame_options) if add_author_information else []
+            for error in sorted_errors:
+                git_blame_dict = blame_lookup(blame_data, error['line'])
+                message_class = None
+                try:
+                    if error['inconclusive'] == 'true':
+                        message_class = 'inconclusive'
+                        error['severity'] += ", inconcl."
+                except KeyError:
+                    pass
+
+                cwe_url = ""
+                try:
+                    if error['cwe']:
+                        cwe_url = "<a href=\"https://cwe.mitre.org/data/definitions/" + error['cwe'] + ".html\">" + error['cwe'] + "</a>"
+                except KeyError:
+                    pass
+
+                if error['severity'] in ['error', 'warning']:
+                    message_class = error['severity']
+
+                line = error["line"] if is_file else ""
+                _severity = error.get('severity', '')
+                _classification = error.get('classification', '')
+                _guideline = error.get('guideline', '')
+                if contentHandler.report_type:
+                    _severity = ''
+                    if not _classification:
+                        _classification = 'None'
+                        _guideline = 'None'
+                output_file.write(
+                    '\n         %s' %
+                    tr_str('td', line, error["id"], cwe_url, _severity, _classification, _guideline, error["msg"], error["timestamp"],
+                           git_blame_dict.get('author', 'Unknown'), git_blame_dict.get('author-mail', '---'),
+                           git_blame_dict.get('author-time', '---'),
+                           tr_class=to_css_selector(error["id"]) + ' sev_' + _severity  +' class_' + _classification + ' issue',
+                           message_class=message_class,
+                           add_author=add_author_information,
+                           htmlfile=htmlfile))
+        output_file.write("\n      </tbody>")
         output_file.write('\n       </table>')
         output_file.write(HTML_FOOTER % contentHandler.versionCppcheck)
 
-    if (decode_errors):
+    if decode_errors:
         sys.stderr.write("\nGenerating html failed for the following files: " + ' '.join(decode_errors))
         sys.stderr.write("\nConsider changing source-encoding (for example: \"htmlreport ... --source-encoding=\"iso8859-1\"\"\n")
 
     print('Creating style.css file')
-    with io.open(os.path.join(options.report_dir, 'style.css'),
-                 'w') as css_file:
+    with io.open(os.path.join(options.report_dir, 'style.css'), 'w') as css_file:
         css_file.write(STYLE_FILE)
 
     print("Creating stats.html (statistics)\n")
     stats_countlist = {}
 
     for filename, data in sorted(files.items()):
-        if (filename == ''):
+        if filename == '':
             continue
         stats_tmplist = []
         for error in sorted(data['errors'], key=lambda k: k['line']):
@@ -663,8 +1084,12 @@ if __name__ == '__main__':
 
     with io.open(os.path.join(options.report_dir, 'stats.html'), 'w') as stats_file:
 
-        stats_file.write(HTML_HEAD.replace('id="menu" dir="rtl"', 'id="menu_index"', 1).replace("Defects:", "Back to summary", 1) % (options.title, '', options.title, 'Statistics', ''))
-        stats_file.write(HTML_HEAD_END.replace("content", "content_index", 1))
+        stats_file.write(HTML_HEAD % (options.title, '', options.title, ': Statistics'))
+        stats_file.write(HTML_HEAD_END)
+
+        stats_file.write(HTML_MENU.replace('id="menu"', 'id="menu_index"', 1).replace("Defects:", "Back to summary", 1) % (''))
+        stats_file.write(HTML_MENU_END.replace("content", "content_index", 1))
+
 
         for sev in SEVERITIES:
             _sum = 0
@@ -676,15 +1101,15 @@ if __name__ == '__main__':
                 for filename in stats_countlist:
                     try:  # also bail out if we have a file with no sev-results
                         _sum += stats_countlist[filename][sev]
-                        stats_templist[filename] = (int)(stats_countlist[filename][sev])  # file : amount,
+                        stats_templist[filename] = int(stats_countlist[filename][sev])  # file : amount,
                     except KeyError:
                         continue
                 # don't print "0 style" etc, if no style warnings were found
-                if (_sum == 0):
-                    break
+                if _sum == 0:
+                    continue
             except KeyError:
                 continue
-            stats_file.write("<p>Top 10 files for " + sev + " severity, total findings: " + str(_sum) + "</br>\n")
+            stats_file.write("<p><span class=\"statHeader\">Top 10 files for " + sev + " severity, total findings: " + str(_sum) + "</span><br>\n")
 
             # sort, so that the file with the most severities per type is first
             stats_list_sorted = sorted(stats_templist.items(), key=operator.itemgetter(1, 0), reverse=True)
@@ -694,13 +1119,39 @@ if __name__ == '__main__':
             for i in stats_list_sorted:  # printing loop
                 # for aesthetics: if it's the first iteration of the loop, get
                 # the max length of the number string
-                if (it == 0):
+                if it == 0:
                     LENGTH = len(str(i[1]))  # <- length of longest number, now get the difference and try to  make other numbers align to it
 
-                stats_file.write("&#160;" * 3 + str(i[1]) + "&#160;" * (1 + LENGTH - len(str(i[1]))) + "<a href=\"" + files[i[0]]['htmlfile'] + "\">  " + i[0] + "</a></br>\n")
+                stats_file.write("&#160;" * 3 + str(i[1]) + "&#160;" * (1 + LENGTH - len(str(i[1]))) + "<a href=\"" + files[i[0]]['htmlfile'] + "\">  " + i[0] + "</a><br>\n")
                 it += 1
-                if (it == 10):  # print only the top 10
+                if it == 10:  # print only the top 10
                     break
             stats_file.write("</p>\n")
 
+        stats_file.write(HTML_FOOTER % contentHandler.versionCppcheck)
+
+    if options.checkers_report:
+        print("Creating checkers.html (checkers report)\n")
+
+        with io.open(os.path.join(options.report_dir, 'checkers.html'), 'w') as checkers_file:
+
+            checkers_file.write(HTML_HEAD % (options.title, '', options.title, ': Checkers'))
+            checkers_file.write(HTML_HEAD_END)
+
+            checkers_file.write(HTML_MENU.replace('id="menu"', 'id="menu_index"', 1).replace("Defects:", "Back to summary", 1) % (''))
+            checkers_file.write(HTML_MENU_END.replace("content", "content_index", 1))
+
+            with io.open(options.checkers_report, 'r', encoding=options.source_encoding) as checkers_report:
+                content = checkers_report.read()
+
+                checkers_file.write("<pre>\n")
+                checkers_file.write(html_escape(content))
+                checkers_file.write("</pre>\n")
+
+            checkers_file.write(HTML_FOOTER % contentHandler.versionCppcheck)
+
     print("\nOpen '" + options.report_dir + "/index.html' to see the results.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/htmlreport/cppcheck_htmlreport/__init__.py b/htmlreport/cppcheck_htmlreport/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/htmlreport/setup.py b/htmlreport/setup.py
index e741ece55d8..3e049181ce6 100755
--- a/htmlreport/setup.py
+++ b/htmlreport/setup.py
@@ -1,21 +1,31 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
+import shutil
+from setuptools import find_packages, setup
 
-from setuptools import setup
-
-with open('README.txt') as f:
+with open("README.txt") as f:
     readme = f.read()
 
+shutil.copy("cppcheck-htmlreport", "cppcheck_htmlreport/run.py")
+
 setup(
-    name="cppcheck",
-    description='Python script to parse the XML (version 2) output of ' +
-                'cppcheck and generate an HTML report using Pygments for syntax ' +
-                'highlighting.',
+    name="cppcheck-htmlreport",
+    description=(
+        "Python script to parse the XML (version 2) output of "
+        "cppcheck and generate an HTML report using Pygments for syntax "
+        "highlighting."
+    ),
     long_description=readme,
-    author='Henrik Nilsson',
-    url='https://github.com/danmar/cppcheck',
-    license='GPL',
-    scripts=[
-        "cppcheck-htmlreport",
-    ],
-    install_requires=['Pygments']
+    author="Cppcheck Team",
+    url="https://github.com/danmar/cppcheck",
+    license="GPL",
+    packages=find_packages(exclude=("tests", "docs")),
+    use_scm_version={"root": ".."},
+    entry_points={
+        "console_scripts": [
+            "cppcheck-htmlreport = cppcheck_htmlreport:run.main",
+        ]
+    },
+    install_requires=["Pygments"],
+    # Required by setuptools-scm 7.0 for Python 3.7+
+    setup_requires=["setuptools>=60", "setuptools-scm>=7.0"],
 )
diff --git a/htmlreport/test_suppressions.txt b/htmlreport/test_suppressions.txt
deleted file mode 100644
index ec3130c099f..00000000000
--- a/htmlreport/test_suppressions.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-variableScope:../samples/memleak/good.c
-*:../samples/resourceLeak/notexisting.c*
-uninitstring:*
diff --git a/htmlreport/tox.ini b/htmlreport/tox.ini
deleted file mode 100644
index 502ca70c110..00000000000
--- a/htmlreport/tox.ini
+++ /dev/null
@@ -1,12 +0,0 @@
-[tox]
-envlist=py26,py27,py32,pypy
-
-[testenv]
-commands=
-    python test_htmlreport.py
-deps=pygments
-
-[testenv:py26]
-deps=
-    unittest2
-    pygments
diff --git a/lib/CMakeLists.txt b/lib/CMakeLists.txt
index f37939ecb9b..b826bc0b265 100644
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -1,20 +1,23 @@
-include_directories(SYSTEM ${PROJECT_SOURCE_DIR}/externals/)
-include_directories(SYSTEM ${PROJECT_SOURCE_DIR}/externals/tinyxml/)
-include_directories(${PROJECT_SOURCE_DIR}/externals/simplecpp/)
-
 file(GLOB_RECURSE hdrs "*.h")
 file(GLOB_RECURSE srcs "*.cpp")
 
+# move the slowest files to the top
+set(srcs_slow "${CMAKE_CURRENT_SOURCE_DIR}/valueflow.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/tokenize.cpp" "${CMAKE_CURRENT_SOURCE_DIR}/symboldatabase.cpp")
+list(REMOVE_ITEM srcs ${srcs_slow})
+list(INSERT srcs 0 ${srcs_slow})
+
 function(build_src output filename)
     get_filename_component(file ${filename} NAME)
     set(outfile ${CMAKE_CURRENT_BINARY_DIR}/build/mc_${file})
     set(${output} ${${output}} ${outfile} PARENT_SCOPE)
-    if (${USE_MATCHCOMPILER} STREQUAL "Verify")
+    if (USE_MATCHCOMPILER_OPT STREQUAL "Verify")
         set(verify_option "--verify")
+    else()
+        set(verify_option "")
     endif()
     add_custom_command(
         OUTPUT ${outfile}
-        COMMAND ${PYTHON_EXECUTABLE} "${PROJECT_SOURCE_DIR}/tools/matchcompiler.py" 
+        COMMAND ${Python_EXECUTABLE} "${PROJECT_SOURCE_DIR}/tools/matchcompiler.py"
                 --read-dir="${CMAKE_CURRENT_SOURCE_DIR}" 
                 --prefix="mc_" 
                 --line 
@@ -26,15 +29,39 @@ function(build_src output filename)
     set_source_files_properties(${outfile} PROPERTIES GENERATED TRUE)
 endfunction()
 
-foreach(file ${srcs})
-    build_src(srcs_build ${file})
-endforeach()
+if (NOT USE_MATCHCOMPILER_OPT STREQUAL "Off")
+    set(srcs_build "")
+    foreach(file ${srcs})
+        build_src(srcs_build ${file})
+    endforeach()
 
-if (NOT ${USE_MATCHCOMPILER_OPT} STREQUAL "Off")
     set(srcs_lib ${srcs_build})
 else()
     set(srcs_lib ${srcs})
 endif()
 
-add_library(lib_objs OBJECT ${srcs_lib} ${hdrs})
+if(BUILD_SHARED_LIBS)
+    add_library(cppcheck-core ${srcs_lib} ${hdrs})
+else()
+    # A OBJECT library is used because the auto-registration doesn't work with static libraries
+    add_library(cppcheck-core OBJECT ${srcs_lib} ${hdrs})
+endif()
+if (BUILD_SHARED_LIBS AND MSVC)
+    target_sources(cppcheck-core PRIVATE version.rc)
+endif()
+
+target_dll_compile_definitions(cppcheck-core EXPORT CPPCHECKLIB_EXPORT IMPORT CPPCHECKLIB_IMPORT)
 
+target_include_directories(cppcheck-core PUBLIC .)
+target_link_libraries(cppcheck-core PRIVATE tinyxml2 simplecpp picojson ${PCRE_LIBRARY})
+
+if (HAVE_RULES)
+    target_include_directories(cppcheck-core SYSTEM PRIVATE ${PCRE_INCLUDE})
+endif()
+if (Boost_FOUND)
+    target_include_directories(cppcheck-core SYSTEM PUBLIC ${Boost_INCLUDE_DIRS})
+endif()
+
+if (NOT CMAKE_DISABLE_PRECOMPILE_HEADERS)
+    target_precompile_headers(cppcheck-core PRIVATE precompiled.h)
+endif()
diff --git a/lib/addoninfo.cpp b/lib/addoninfo.cpp
new file mode 100644
index 00000000000..c0139320d7e
--- /dev/null
+++ b/lib/addoninfo.cpp
@@ -0,0 +1,208 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "addoninfo.h"
+
+#include "path.h"
+#include "utils.h"
+
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <utility>
+
+#include "json.h"
+
+static std::string getFullPath(const std::string &fileName, const std::string &exename, bool debug = false) {
+    if (debug)
+        std::cout << "looking for addon '" << fileName << "'" << std::endl;
+    if (Path::isFile(fileName))
+        return fileName;
+
+    const bool is_abs_path = Path::isAbsolute(fileName);
+    if (is_abs_path)
+        return "";
+
+    const std::string exepath = Path::getPathFromFilename(exename);
+    if (debug)
+        std::cout << "looking for addon '" << (exepath + fileName) << "'" << std::endl;
+    if (Path::isFile(exepath + fileName))
+        return exepath + fileName;
+    if (debug)
+        std::cout << "looking for addon '" << (exepath + "addons/" + fileName) << "'" << std::endl;
+    if (Path::isFile(exepath + "addons/" + fileName))
+        return exepath + "addons/" + fileName;
+
+#ifdef FILESDIR
+    if (debug)
+        std::cout << "looking for addon '" << (FILESDIR + ("/" + fileName)) << "'" << std::endl;
+    if (Path::isFile(FILESDIR + ("/" + fileName)))
+        return FILESDIR + ("/" + fileName);
+    if (debug)
+        std::cout << "looking for addon '" << (FILESDIR + ("/addons/" + fileName)) << "'" << std::endl;
+    if (Path::isFile(FILESDIR + ("/addons/" + fileName)))
+        return FILESDIR + ("/addons/" + fileName);
+#endif
+    return "";
+}
+
+static std::string parseAddonInfo(AddonInfo& addoninfo, const picojson::value &json, const std::string &fileName, const std::string &exename) {
+    const std::string& json_error = picojson::get_last_error();
+    if (!json_error.empty()) {
+        return "Loading " + fileName + " failed. " + json_error;
+    }
+    if (!json.is<picojson::object>())
+        return "Loading " + fileName + " failed. JSON is not an object.";
+
+    // TODO: remove/complete default value handling for missing fields
+    const picojson::object& obj = json.get<picojson::object>();
+    {
+        const auto it = obj.find("args");
+        if (it != obj.cend()) {
+            const auto& val = it->second;
+            if (!val.is<picojson::array>())
+                return "Loading " + fileName + " failed. 'args' must be an array.";
+            for (const picojson::value &v : val.get<picojson::array>()) {
+                if (!v.is<std::string>())
+                    return "Loading " + fileName + " failed. 'args' entry is not a string.";
+                addoninfo.args += " " + v.get<std::string>();
+            }
+        }
+    }
+
+    {
+        const auto it = obj.find("ctu");
+        if (it != obj.cend()) {
+            const auto& val = it->second;
+            // ctu is specified in the config file
+            if (!val.is<bool>())
+                return "Loading " + fileName + " failed. 'ctu' must be a boolean.";
+            addoninfo.ctu = val.get<bool>();
+        }
+        else {
+            addoninfo.ctu = false;
+        }
+    }
+
+    {
+        const auto it = obj.find("python");
+        if (it != obj.cend()) {
+            const auto& val = it->second;
+            // Python was defined in the config file
+            if (!val.is<std::string>()) {
+                return "Loading " + fileName +" failed. 'python' must be a string.";
+            }
+            addoninfo.python = val.get<std::string>();
+        }
+        else {
+            addoninfo.python = "";
+        }
+    }
+
+    {
+        const auto it = obj.find("checkers");
+        if (it != obj.cend()) {
+            const auto& val = it->second;
+            if (!val.is<picojson::array>())
+                return "Loading " + fileName + " failed. 'checkers' must be an array.";
+            for (const picojson::value &v : val.get<picojson::array>()) {
+                if (!v.is<picojson::object>())
+                    return "Loading " + fileName + " failed. 'checkers' entry is not an object.";
+
+                const picojson::object& checkerObj = v.get<picojson::object>();
+                if (checkerObj.size() == 1) {
+                    const std::string c = checkerObj.begin()->first;
+                    if (!checkerObj.begin()->second.is<std::string>())
+                        return "Loading " + fileName + " failed. 'checkers' entry requirement is not a string.";
+                    const std::string req = checkerObj.begin()->second.get<std::string>();
+                    addoninfo.checkers.emplace(c, req);
+                }
+            }
+        }
+    }
+
+    {
+        const auto it = obj.find("executable");
+        if (it != obj.cend()) {
+            const auto& val = it->second;
+            if (!val.is<std::string>())
+                return "Loading " + fileName + " failed. 'executable' must be a string.";
+            std::string e = val.get<std::string>();
+            addoninfo.executable = getFullPath(e, fileName);
+            if (addoninfo.executable.empty())
+                addoninfo.executable = std::move(e);
+            return ""; // <- do not load both "executable" and "script".
+        }
+    }
+
+    const auto it = obj.find("script");
+    if (it == obj.cend())
+        return "Loading " + fileName + " failed. 'script' is missing.";
+
+    const auto& val = it->second;
+    if (!val.is<std::string>())
+        return "Loading " + fileName + " failed. 'script' must be a string.";
+
+    return addoninfo.getAddonInfo(val.get<std::string>(), exename);
+}
+
+std::string AddonInfo::getAddonInfo(const std::string &fileName, const std::string &exename, bool debug) {
+    if (fileName[0] == '{') {
+        picojson::value json;
+        const std::string err = picojson::parse(json, fileName);
+        (void)err; // TODO: report
+        return parseAddonInfo(*this, json, fileName, exename);
+    }
+    if (fileName.find('.') == std::string::npos)
+        return getAddonInfo(fileName + ".py", exename, debug);
+
+    if (endsWith(fileName, ".py")) {
+        scriptFile = Path::fromNativeSeparators(getFullPath(fileName, exename, debug));
+        if (scriptFile.empty())
+            return "Did not find addon " + fileName;
+
+        std::string::size_type pos1 = scriptFile.rfind('/');
+        if (pos1 == std::string::npos)
+            pos1 = 0;
+        else
+            pos1++;
+        std::string::size_type pos2 = scriptFile.rfind('.');
+        if (pos2 < pos1)
+            pos2 = std::string::npos;
+        name = scriptFile.substr(pos1, pos2 - pos1);
+
+        runScript = getFullPath("runaddon.py", exename);
+
+        return "";
+    }
+
+    if (!endsWith(fileName, ".json"))
+        return "Failed to open addon " + fileName;
+
+    std::ifstream fin(fileName);
+    if (!fin.is_open())
+        return "Failed to open " + fileName;
+    if (name.empty()) {
+        name = Path::fromNativeSeparators(fileName);
+        if (name.find('/') != std::string::npos)
+            name = name.substr(name.rfind('/') + 1);
+    }
+    picojson::value json;
+    fin >> json;
+    return parseAddonInfo(*this, json, fileName, exename);
+}
diff --git a/lib/addoninfo.h b/lib/addoninfo.h
new file mode 100644
index 00000000000..902a26c2e12
--- /dev/null
+++ b/lib/addoninfo.h
@@ -0,0 +1,40 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef addonInfoH
+#define addonInfoH
+
+#include "config.h"
+
+#include <string>
+#include <map>
+
+struct CPPCHECKLIB AddonInfo {
+    std::string name;
+    std::string scriptFile; // addon script
+    std::string executable; // addon executable
+    std::string args;       // special extra arguments
+    std::string python;     // script interpreter
+    bool ctu = false;
+    std::string runScript;
+    std::map<std::string, std::string> checkers; // checker name and its requirement
+
+    std::string getAddonInfo(const std::string &fileName, const std::string &exename, bool debug = false);
+};
+
+#endif // addonInfoH
diff --git a/lib/analyzer.h b/lib/analyzer.h
new file mode 100644
index 00000000000..a4546eb7dc4
--- /dev/null
+++ b/lib/analyzer.h
@@ -0,0 +1,199 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef analyzerH
+#define analyzerH
+
+#include "config.h"
+#include "mathlib.h"
+
+#include <cstdint>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+class Token;
+template<class T>
+class ValuePtr;
+
+struct Analyzer {
+    struct Action {
+
+        Action() = default;
+        Action(const Action&) = default;
+        Action& operator=(const Action& rhs) & = default;
+
+        template<class T,
+                 REQUIRES("T must be convertible to unsigned int", std::is_convertible<T, unsigned int> ),
+                 REQUIRES("T must not be a bool", !std::is_same<T, bool> )>
+        // NOLINTNEXTLINE(google-explicit-constructor)
+        Action(T f) : mFlag(f) // cppcheck-suppress noExplicitConstructor
+        {}
+
+        enum : std::uint16_t {
+            None = 0,
+            Read = (1 << 0),
+            Write = (1 << 1),
+            Invalid = (1 << 2),
+            Inconclusive = (1 << 3),
+            Match = (1 << 4),
+            Idempotent = (1 << 5),
+            Incremental = (1 << 6),
+            SymbolicMatch = (1 << 7),
+            Internal = (1 << 8),
+        };
+
+        void set(unsigned int f, bool state = true) {
+            mFlag = state ? mFlag | f : mFlag & ~f;
+        }
+
+        bool get(unsigned int f) const {
+            return ((mFlag & f) != 0);
+        }
+
+        bool isRead() const {
+            return get(Read);
+        }
+
+        bool isWrite() const {
+            return get(Write);
+        }
+
+        bool isInvalid() const {
+            return get(Invalid);
+        }
+
+        bool isInconclusive() const {
+            return get(Inconclusive);
+        }
+
+        bool isNone() const {
+            return mFlag == None;
+        }
+
+        bool isModified() const {
+            return isWrite() || isInvalid();
+        }
+
+        bool isIdempotent() const {
+            return get(Idempotent);
+        }
+
+        bool isIncremental() const {
+            return get(Incremental);
+        }
+
+        bool isSymbolicMatch() const {
+            return get(SymbolicMatch);
+        }
+
+        bool isInternal() const {
+            return get(Internal);
+        }
+
+        bool matches() const {
+            return get(Match);
+        }
+
+        Action& operator|=(Action a) {
+            set(a.mFlag);
+            return *this;
+        }
+
+        friend Action operator|(Action a, Action b) {
+            a |= b;
+            return a;
+        }
+
+        friend bool operator==(Action a, Action b) {
+            return a.mFlag == b.mFlag;
+        }
+
+        friend bool operator!=(Action a, Action b) {
+            return a.mFlag != b.mFlag;
+        }
+
+    private:
+        unsigned int mFlag{};
+    };
+
+    enum class Terminate : std::uint8_t { None, Bail, Escape, Modified, Inconclusive, Conditional };
+
+    struct Result {
+        explicit Result(Action action = Action::None, Terminate terminate = Terminate::None)
+            : action(action), terminate(terminate)
+        {}
+        Action action;
+        Terminate terminate;
+
+        void update(Result rhs) {
+            if (terminate == Terminate::None)
+                terminate = rhs.terminate;
+            action |= rhs.action;
+        }
+    };
+
+    enum class Direction : std::uint8_t { Forward, Reverse };
+
+    struct Assume {
+        enum Flags : std::uint8_t {
+            None = 0,
+            Quiet = (1 << 0),
+            Absolute = (1 << 1),
+            ContainerEmpty = (1 << 2),
+        };
+    };
+
+    enum class Evaluate : std::uint8_t { Integral, ContainerEmpty };
+
+    /// Analyze a token
+    virtual Action analyze(const Token* tok, Direction d) const = 0;
+    /// Update the state of the value
+    virtual void update(Token* tok, Action a, Direction d) = 0;
+    /// Try to evaluate the value of a token(most likely a condition)
+    virtual std::vector<MathLib::bigint> evaluate(Evaluate e, const Token* tok, const Token* ctx = nullptr) const = 0;
+    std::vector<MathLib::bigint> evaluate(const Token* tok, const Token* ctx = nullptr) const
+    {
+        return evaluate(Evaluate::Integral, tok, ctx);
+    }
+    /// Lower any values to possible
+    virtual bool lowerToPossible() = 0;
+    /// Lower any values to inconclusive
+    virtual bool lowerToInconclusive() = 0;
+    /// If the analysis is unsure whether to update a scope, this will return true if the analysis should bifurcate the scope
+    virtual bool updateScope(const Token* endBlock, bool modified) const = 0;
+    /// If the value is conditional
+    virtual bool isConditional() const = 0;
+    /// If analysis should stop on the condition
+    virtual bool stopOnCondition(const Token* condTok) const = 0;
+    /// The condition that will be assumed during analysis
+    virtual void assume(const Token* tok, bool state, unsigned int flags = 0) = 0;
+    /// Update the state of the program at the token
+    virtual void updateState(const Token* tok) = 0;
+    /// Return analyzer for expression at token
+    virtual ValuePtr<Analyzer> reanalyze(Token* tok, const std::string& msg = "") const = 0;
+    virtual bool invalid() const {
+        return false;
+    }
+    virtual ~Analyzer() = default;
+    Analyzer(const Analyzer&) = default;
+protected:
+    Analyzer() = default;
+};
+
+#endif
diff --git a/lib/analyzerinfo.cpp b/lib/analyzerinfo.cpp
index 69121de5342..6f919ec3651 100644
--- a/lib/analyzerinfo.cpp
+++ b/lib/analyzerinfo.cpp
@@ -1,30 +1,38 @@
 /*
-* Cppcheck - A tool for static C/C++ code analysis
-* Copyright (C) 2007-2019 Cppcheck team.
-*
-* This program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
 
 #include "analyzerinfo.h"
 
+#include "errorlogger.h"
+#include "filesettings.h"
 #include "path.h"
 #include "utils.h"
 
-#include <tinyxml2.h>
+#include <array>
 #include <cstring>
+#include <exception>
+#include <iostream>
 #include <map>
 #include <sstream>
+#include <stdexcept>
+#include <utility>
+
+#include "xml.h"
 
 AnalyzerInformation::~AnalyzerInformation()
 {
@@ -43,108 +51,155 @@ static std::string getFilename(const std::string &fullpath)
     return fullpath.substr(pos1,pos2);
 }
 
-void AnalyzerInformation::writeFilesTxt(const std::string &buildDir, const std::list<std::string> &sourcefiles, const std::list<ImportProject::FileSettings> &fileSettings)
+void AnalyzerInformation::writeFilesTxt(const std::string &buildDir, const std::list<std::string> &sourcefiles, const std::list<FileSettings> &fileSettings)
 {
-    std::map<std::string, unsigned int> fileCount;
-
     const std::string filesTxt(buildDir + "/files.txt");
     std::ofstream fout(filesTxt);
+    fout << getFilesTxt(sourcefiles, fileSettings);
+}
+
+std::string AnalyzerInformation::getFilesTxt(const std::list<std::string> &sourcefiles, const std::list<FileSettings> &fileSettings) {
+    std::ostringstream ret;
+
+    std::map<std::string, unsigned int> fileCount;
+
     for (const std::string &f : sourcefiles) {
         const std::string afile = getFilename(f);
-        fout << afile << ".a" << (++fileCount[afile]) << "::" << Path::simplifyPath(Path::fromNativeSeparators(f)) << '\n';
+        ret << afile << ".a" << (++fileCount[afile]) << sep << sep << sep << Path::simplifyPath(f) << '\n';
     }
 
-    for (const ImportProject::FileSettings &fs : fileSettings) {
-        const std::string afile = getFilename(fs.filename);
-        fout << afile << ".a" << (++fileCount[afile]) << ":" << fs.cfg << ":" << Path::simplifyPath(Path::fromNativeSeparators(fs.filename)) << std::endl;
+    for (const FileSettings &fs : fileSettings) {
+        const std::string afile = getFilename(fs.filename());
+        const std::string id = fs.file.fsFileId() > 0 ? std::to_string(fs.file.fsFileId()) : "";
+        ret << afile << ".a" << (++fileCount[afile]) << sep << fs.cfg << sep << id << sep << Path::simplifyPath(fs.filename()) << std::endl;
     }
+
+    return ret.str();
 }
 
 void AnalyzerInformation::close()
 {
-    mAnalyzerInfoFile.clear();
     if (mOutputStream.is_open()) {
         mOutputStream << "</analyzerinfo>\n";
         mOutputStream.close();
     }
 }
 
-static bool skipAnalysis(const std::string &analyzerInfoFile, unsigned long long checksum, std::list<ErrorLogger::ErrorMessage> *errors)
+std::string AnalyzerInformation::skipAnalysis(const tinyxml2::XMLDocument &analyzerInfoDoc, std::size_t hash, std::list<ErrorMessage> &errors)
 {
-    tinyxml2::XMLDocument doc;
-    const tinyxml2::XMLError error = doc.LoadFile(analyzerInfoFile.c_str());
-    if (error != tinyxml2::XML_SUCCESS)
-        return false;
-
-    const tinyxml2::XMLElement * const rootNode = doc.FirstChildElement();
+    const tinyxml2::XMLElement * const rootNode = analyzerInfoDoc.FirstChildElement();
     if (rootNode == nullptr)
-        return false;
+        return "no root node found";
 
-    const char *attr = rootNode->Attribute("checksum");
-    if (!attr || attr != std::to_string(checksum))
-        return false;
+    if (strcmp(rootNode->Name(), "analyzerinfo") != 0)
+        return "unexpected root node";
+
+    const char * const attr = rootNode->Attribute("hash");
+    if (!attr)
+        return "no 'hash' attribute found";
+    if (attr != std::to_string(hash))
+        return "hash mismatch";
 
     for (const tinyxml2::XMLElement *e = rootNode->FirstChildElement(); e; e = e->NextSiblingElement()) {
-        if (std::strcmp(e->Name(), "error") == 0)
-            errors->emplace_back(e);
+        if (std::strcmp(e->Name(), "error") != 0)
+            continue;
+
+        // TODO: discarding results on internalError doesn't make sense since that won't fix itself
+        // Check for invalid license error or internal error, in which case we should retry analysis
+        static const std::array<const char*, 3> s_ids{
+            "premium-invalidLicense",
+            "premium-internalError",
+            "internalError"
+        };
+        for (const auto* id : s_ids)
+        {
+            // cppcheck-suppress useStlAlgorithm
+            if (e->Attribute("id", id)) {
+                errors.clear();
+                return std::string("'") + id + "' encountered";
+            }
+        }
+
+        errors.emplace_back(e);
     }
 
-    return true;
+    return "";
 }
 
-std::string AnalyzerInformation::getAnalyzerInfoFile(const std::string &buildDir, const std::string &sourcefile, const std::string &cfg)
+std::string AnalyzerInformation::getAnalyzerInfoFileFromFilesTxt(std::istream& filesTxt, const std::string &sourcefile, const std::string &cfg, int fsFileId)
 {
-    const std::string files(buildDir + "/files.txt");
-    std::ifstream fin(files);
+    std::string line;
+    while (std::getline(filesTxt,line)) {
+        AnalyzerInformation::Info filesTxtInfo;
+        if (!filesTxtInfo.parse(line))
+            continue; // TODO: report error?
+        if (endsWith(sourcefile, filesTxtInfo.sourceFile) && filesTxtInfo.cfg == cfg && filesTxtInfo.fsFileId == fsFileId)
+            return filesTxtInfo.afile;
+    }
+    return "";
+}
+
+std::string AnalyzerInformation::getAnalyzerInfoFile(const std::string &buildDir, const std::string &sourcefile, const std::string &cfg, std::size_t fsFileId)
+{
+    std::ifstream fin(Path::join(buildDir, "files.txt"));
     if (fin.is_open()) {
-        std::string line;
-        const std::string end(':' + cfg + ':' + sourcefile);
-        while (std::getline(fin,line)) {
-            if (line.size() <= end.size() + 2U)
-                continue;
-            if (!endsWith(line, end.c_str(), end.size()))
-                continue;
-            std::ostringstream ostr;
-            ostr << buildDir << '/' << line.substr(0,line.find(':'));
-            return ostr.str();
-        }
+        const std::string& ret = getAnalyzerInfoFileFromFilesTxt(fin, sourcefile, cfg, fsFileId);
+        if (!ret.empty())
+            return Path::join(buildDir, ret);
     }
 
-    std::string filename = Path::fromNativeSeparators(buildDir);
-    if (!endsWith(filename, '/'))
-        filename += '/';
     const std::string::size_type pos = sourcefile.rfind('/');
+    std::string filename;
     if (pos == std::string::npos)
-        filename += sourcefile;
+        filename = sourcefile;
     else
-        filename += sourcefile.substr(pos+1);
-    filename += ".analyzerinfo";
-    return filename;
+        filename = sourcefile.substr(pos + 1);
+    // TODO: is this correct? the above code will return files ending in '.aN'. Also does not consider the ID
+    return Path::join(buildDir, std::move(filename)) + ".analyzerinfo";
 }
 
-bool AnalyzerInformation::analyzeFile(const std::string &buildDir, const std::string &sourcefile, const std::string &cfg, unsigned long long checksum, std::list<ErrorLogger::ErrorMessage> *errors)
+bool AnalyzerInformation::analyzeFile(const std::string &buildDir, const std::string &sourcefile, const std::string &cfg, std::size_t fsFileId, std::size_t hash, std::list<ErrorMessage> &errors, bool debug)
 {
+    if (mOutputStream.is_open())
+        throw std::runtime_error("analyzer information file is already open");
+
     if (buildDir.empty() || sourcefile.empty())
         return true;
-    close();
-
-    mAnalyzerInfoFile = AnalyzerInformation::getAnalyzerInfoFile(buildDir,sourcefile,cfg);
 
-    if (skipAnalysis(mAnalyzerInfoFile, checksum, errors))
-        return false;
+    const std::string analyzerInfoFile = AnalyzerInformation::getAnalyzerInfoFile(buildDir,sourcefile,cfg,fsFileId);
 
-    mOutputStream.open(mAnalyzerInfoFile);
-    if (mOutputStream.is_open()) {
-        mOutputStream << "<?xml version=\"1.0\"?>\n";
-        mOutputStream << "<analyzerinfo checksum=\"" << checksum << "\">\n";
-    } else {
-        mAnalyzerInfoFile.clear();
+    {
+        tinyxml2::XMLDocument analyzerInfoDoc;
+        const tinyxml2::XMLError xmlError = analyzerInfoDoc.LoadFile(analyzerInfoFile.c_str());
+        if (xmlError == tinyxml2::XML_SUCCESS) {
+            const std::string err = skipAnalysis(analyzerInfoDoc, hash, errors);
+            if (err.empty()) {
+                if (debug)
+                    std::cout << "skipping analysis - loaded " << errors.size() << " cached finding(s) from '" << analyzerInfoFile << "' for '" << sourcefile <<  "'" << std::endl;
+                return false;
+            }
+            if (debug) {
+                std::cout << "discarding cached result from '" << analyzerInfoFile << "' for '" << sourcefile << "' - " << err << std::endl;
+            }
+        }
+        else if (xmlError != tinyxml2::XML_ERROR_FILE_NOT_FOUND) {
+            if (debug)
+                std::cout << "discarding cached result - failed to load '" << analyzerInfoFile << "' for '" << sourcefile << "' (" << tinyxml2::XMLDocument::ErrorIDToName(xmlError) << ")" << std::endl;
+        }
+        else if (debug)
+            std::cout << "no cached result '" << analyzerInfoFile << "' for '" << sourcefile << "' found" << std::endl;
     }
 
+    mOutputStream.open(analyzerInfoFile);
+    if (!mOutputStream.is_open())
+        throw std::runtime_error("failed to open '" + analyzerInfoFile + "'");
+    mOutputStream << "<?xml version=\"1.0\"?>\n";
+    mOutputStream << "<analyzerinfo hash=\"" << hash << "\">\n";
+
     return true;
 }
 
-void AnalyzerInformation::reportErr(const ErrorLogger::ErrorMessage &msg, bool /*verbose*/)
+void AnalyzerInformation::reportErr(const ErrorMessage &msg)
 {
     if (mOutputStream.is_open())
         mOutputStream << msg.toXML() << '\n';
@@ -155,3 +210,107 @@ void AnalyzerInformation::setFileInfo(const std::string &check, const std::strin
     if (mOutputStream.is_open() && !fileInfo.empty())
         mOutputStream << "  <FileInfo check=\"" << check << "\">\n" << fileInfo << "  </FileInfo>\n";
 }
+
+// TODO: report detailed errors?
+bool AnalyzerInformation::Info::parse(const std::string& filesTxtLine) {
+    const std::string::size_type sep1 = filesTxtLine.find(sep);
+    if (sep1 == std::string::npos)
+        return false;
+    const std::string::size_type sep2 = filesTxtLine.find(sep, sep1+1);
+    if (sep2 == std::string::npos)
+        return false;
+    const std::string::size_type sep3 = filesTxtLine.find(sep, sep2+1);
+    if (sep3 == std::string::npos)
+        return false;
+
+    if (sep3 == sep2 + 1)
+        fsFileId = 0;
+    else {
+        try {
+            fsFileId = std::stoi(filesTxtLine.substr(sep2+1, sep3-sep2-1));
+        } catch (const std::exception&) {
+            return false;
+        }
+    }
+
+    afile = filesTxtLine.substr(0, sep1);
+    cfg = filesTxtLine.substr(sep1+1, sep2-sep1-1);
+    sourceFile = filesTxtLine.substr(sep3+1);
+    return true;
+}
+
+std::string AnalyzerInformation::processFilesTxt(const std::string& buildDir, const std::function<void(const char* checkattr, const tinyxml2::XMLElement* e, const Info& filesTxtInfo)>& handler, bool debug)
+{
+    const std::string filesTxt(buildDir + "/files.txt");
+    std::ifstream fin(filesTxt.c_str());
+    std::string filesTxtLine;
+    while (std::getline(fin, filesTxtLine)) {
+        AnalyzerInformation::Info filesTxtInfo;
+        if (!filesTxtInfo.parse(filesTxtLine))
+            return "failed to parse '" + filesTxtLine + "' from '" + filesTxt + "'";
+
+        if (filesTxtInfo.afile.empty())
+            return "empty afile from '" + filesTxt + "'";
+
+        const std::string xmlfile = buildDir + '/' + filesTxtInfo.afile;
+
+        tinyxml2::XMLDocument doc;
+        const tinyxml2::XMLError error = doc.LoadFile(xmlfile.c_str());
+        if (error == tinyxml2::XML_ERROR_FILE_NOT_FOUND) {
+            /* FIXME: this can currently not be reported as an error because:
+             * - --clang does not generate any analyzer information - see #14456
+             * - markup files might not generate analyzer information
+             * - files with preprocessor errors might not generate analyzer information
+             */
+            if (debug)
+                std::cout << "'" + xmlfile + "' from '" + filesTxt + "' not found";
+            continue;
+        }
+
+        if (error != tinyxml2::XML_SUCCESS)
+            return "failed to load '" + xmlfile + "' from '" + filesTxt + "'";
+
+        const tinyxml2::XMLElement * const rootNode = doc.FirstChildElement();
+        if (rootNode == nullptr)
+            return "no root node found in '" + xmlfile + "' from '" + filesTxt + "'";
+
+        if (strcmp(rootNode->Name(), "analyzerinfo") != 0)
+            return "unexpected root node in '" + xmlfile + "' from '" + filesTxt + "'";
+
+        for (const tinyxml2::XMLElement *e = rootNode->FirstChildElement(); e; e = e->NextSiblingElement()) {
+            if (std::strcmp(e->Name(), "FileInfo") != 0)
+                continue;
+            const char *checkattr = e->Attribute("check");
+            if (checkattr == nullptr) {
+                if (debug)
+                    std::cout << "'check' attribute missing in 'FileInfo' in '" << xmlfile << "' from '" << filesTxt + "'";
+                continue;
+            }
+            handler(checkattr, e, filesTxtInfo);
+        }
+    }
+
+    // TODO: error on empty file?
+    return "";
+}
+
+void AnalyzerInformation::reopen(const std::string &buildDir, const std::string &sourcefile, const std::string &cfg, std::size_t fsFileId)
+{
+    if (buildDir.empty() || sourcefile.empty())
+        return;
+
+    const std::string analyzerInfoFile = AnalyzerInformation::getAnalyzerInfoFile(buildDir,sourcefile,cfg,fsFileId);
+    std::ifstream ifs(analyzerInfoFile);
+    if (!ifs.is_open())
+        return;
+
+    std::ostringstream iss;
+    iss << ifs.rdbuf();
+    ifs.close();
+
+    std::string content = iss.str();
+    content.resize(content.find("</analyzerinfo>"));
+
+    mOutputStream.open(analyzerInfoFile, std::ios::trunc);
+    mOutputStream << content;
+}
diff --git a/lib/analyzerinfo.h b/lib/analyzerinfo.h
index 338d2255048..d8a220a5c55 100644
--- a/lib/analyzerinfo.h
+++ b/lib/analyzerinfo.h
@@ -1,20 +1,20 @@
-/*
-* Cppcheck - A tool for static C/C++ code analysis
-* Copyright (C) 2007-2018 Cppcheck team.
-*
-* This program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
 
 //---------------------------------------------------------------------------
 #ifndef analyzerinfoH
@@ -22,44 +22,77 @@
 //---------------------------------------------------------------------------
 
 #include "config.h"
-#include "errorlogger.h"
-#include "importproject.h"
 
+#include <cstddef>
 #include <fstream>
+#include <functional>
 #include <list>
 #include <string>
 
+class ErrorMessage;
+struct FileSettings;
+
+namespace tinyxml2 {
+    class XMLDocument;
+    class XMLElement;
+};
+
 /// @addtogroup Core
 /// @{
 
 /**
-* @brief Analyzer information
-*
-* Store various analysis information:
-* - checksum
-* - error messages
-* - whole program analysis data
-*
-* The information can be used for various purposes. It allows:
-* - 'make' - only analyze TUs that are changed and generate full report
-* - should be possible to add distributed analysis later
-* - multi-threaded whole program analysis
-*/
+ * @brief Analyzer information
+ *
+ * Store various analysis information:
+ * - checksum
+ * - error messages
+ * - whole program analysis data
+ *
+ * The information can be used for various purposes. It allows:
+ * - 'make' - only analyze TUs that are changed and generate full report
+ * - should be possible to add distributed analysis later
+ * - multi-threaded whole program analysis
+ */
 class CPPCHECKLIB AnalyzerInformation {
 public:
     ~AnalyzerInformation();
 
-    static void writeFilesTxt(const std::string &buildDir, const std::list<std::string> &sourcefiles, const std::list<ImportProject::FileSettings> &fileSettings);
+    static void writeFilesTxt(const std::string &buildDir, const std::list<std::string> &sourcefiles, const std::list<FileSettings> &fileSettings);
 
     /** Close current TU.analyzerinfo file */
     void close();
-    bool analyzeFile(const std::string &buildDir, const std::string &sourcefile, const std::string &cfg, unsigned long long checksum, std::list<ErrorLogger::ErrorMessage> *errors);
-    void reportErr(const ErrorLogger::ErrorMessage &msg, bool verbose);
+    /**
+     * @throws std::runtime_error thrown if the output file is already open or the output file cannot be opened
+     */
+    bool analyzeFile(const std::string &buildDir, const std::string &sourcefile, const std::string &cfg, std::size_t fsFileId, std::size_t hash, std::list<ErrorMessage> &errors, bool debug = false);
+    void reportErr(const ErrorMessage &msg);
     void setFileInfo(const std::string &check, const std::string &fileInfo);
-    static std::string getAnalyzerInfoFile(const std::string &buildDir, const std::string &sourcefile, const std::string &cfg);
+    static std::string getAnalyzerInfoFile(const std::string &buildDir, const std::string &sourcefile, const std::string &cfg, std::size_t fsFileId);
+
+    void reopen(const std::string &buildDir, const std::string &sourcefile, const std::string &cfg, std::size_t fsFileId);
+
+    static const char sep = ':';
+
+    class CPPCHECKLIB Info {
+    public:
+        bool parse(const std::string& filesTxtLine);
+        std::string afile;
+        std::string cfg;
+        std::size_t fsFileId = 0;
+        std::string sourceFile;
+    };
+
+    static std::string processFilesTxt(const std::string& buildDir, const std::function<void(const char* checkattr, const tinyxml2::XMLElement* e, const Info& filesTxtInfo)>& handler, bool debug = false);
+
+protected:
+    static std::string getFilesTxt(const std::list<std::string> &sourcefiles, const std::list<FileSettings> &fileSettings);
+
+    static std::string getAnalyzerInfoFileFromFilesTxt(std::istream& filesTxt, const std::string &sourcefile, const std::string &cfg, int fsFileId);
+
+    static std::string skipAnalysis(const tinyxml2::XMLDocument &analyzerInfoDoc, std::size_t hash, std::list<ErrorMessage> &errors);
+
 private:
     std::ofstream mOutputStream;
-    std::string mAnalyzerInfoFile;
 };
 
 /// @}
diff --git a/lib/astutils.cpp b/lib/astutils.cpp
index 5d0940190d5..b8e86b3e29d 100644
--- a/lib/astutils.cpp
+++ b/lib/astutils.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,67 +20,139 @@
 //---------------------------------------------------------------------------
 #include "astutils.h"
 
+#include "config.h"
+#include "errortypes.h"
+#include "findtoken.h"
+#include "infer.h"
 #include "library.h"
 #include "mathlib.h"
 #include "settings.h"
 #include "symboldatabase.h"
 #include "token.h"
+#include "utils.h"
 #include "valueflow.h"
+#include "valueptr.h"
+#include "vfvalue.h"
 
+#include "checkclass.h"
+
+#include <algorithm>
+#include <cstring>
+#include <functional>
+#include <initializer_list>
 #include <iterator>
 #include <list>
-#include <stack>
-
+#include <set>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
 
-void visitAstNodes(const Token *ast, std::function<ChildrenToVisit(const Token *)> visitor)
+const Token* findExpression(const nonneg int exprid,
+                            const Token* start,
+                            const Token* end,
+                            const std::function<bool(const Token*)>& pred)
 {
-    std::stack<const Token *> tokens;
-    tokens.push(ast);
-    while (!tokens.empty()) {
-        const Token *tok = tokens.top();
-        tokens.pop();
-        if (!tok)
+    if (exprid == 0)
+        return nullptr;
+    if (!precedes(start, end))
+        return nullptr;
+    for (const Token* tok = start; tok != end; tok = tok->next()) {
+        if (tok->exprId() != exprid)
             continue;
-
-        ChildrenToVisit c = visitor(tok);
-
-        if (c == ChildrenToVisit::done)
-            break;
-        if (c == ChildrenToVisit::op1 || c == ChildrenToVisit::op1_and_op2)
-            tokens.push(tok->astOperand1());
-        if (c == ChildrenToVisit::op2 || c == ChildrenToVisit::op1_and_op2)
-            tokens.push(tok->astOperand2());
+        if (pred(tok))
+            return tok;
     }
+    return nullptr;
 }
 
-static void astFlattenRecursive(const Token *tok, std::vector<const Token *> *result, const char* op, nonneg int depth = 0)
+static int findArgumentPosRecursive(const Token* tok, const Token* tokToFind,  bool &found, nonneg int depth=0)
 {
     ++depth;
     if (!tok || depth >= 100)
+        return -1;
+    if (tok->str() == ",") {
+        int res = findArgumentPosRecursive(tok->astOperand1(), tokToFind, found, depth);
+        if (res == -1)
+            return -1;
+        if (found)
+            return res;
+        const int argn = res;
+        res = findArgumentPosRecursive(tok->astOperand2(), tokToFind, found, depth);
+        if (res == -1)
+            return -1;
+        return argn + res;
+    }
+    if (tokToFind == tok)
+        found = true;
+    return 1;
+}
+
+static int findArgumentPos(const Token* tok, const Token* tokToFind){
+    bool found = false;
+    const int argn = findArgumentPosRecursive(tok, tokToFind, found, 0);
+    if (found)
+        return argn - 1;
+    return -1;
+}
+
+static int getArgumentPos(const Token* ftok, const Token* tokToFind){
+    const Token* tok = ftok;
+    if (Token::Match(tok, "%name% (|{"))
+        tok = ftok->next();
+    if (!Token::Match(tok, "(|{|["))
+        return -1;
+    const Token* startTok = tok->astOperand2();
+    if (!startTok && tok->next() != tok->link())
+        startTok = tok->astOperand1();
+    return findArgumentPos(startTok, tokToFind);
+}
+
+template<class T, class OuputIterator, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+static void astFlattenCopy(T* tok, const char* op, OuputIterator out, int depth = 100)
+{
+    --depth;
+    if (!tok || depth < 0)
         return;
-    if (tok->str() == op) {
-        astFlattenRecursive(tok->astOperand1(), result, op, depth);
-        astFlattenRecursive(tok->astOperand2(), result, op, depth);
+    if (strcmp(tok->str().c_str(), op) == 0) {
+        astFlattenCopy(tok->astOperand1(), op, out, depth);
+        astFlattenCopy(tok->astOperand2(), op, out, depth);
     } else {
-        result->push_back(tok);
+        *out = tok;
+        ++out;
     }
 }
 
 std::vector<const Token*> astFlatten(const Token* tok, const char* op)
 {
     std::vector<const Token*> result;
-    astFlattenRecursive(tok, &result, op);
+    astFlattenCopy(tok, op, std::back_inserter(result));
+    return result;
+}
+
+std::vector<Token*> astFlatten(Token* tok, const char* op)
+{
+    std::vector<Token*> result;
+    astFlattenCopy(tok, op, std::back_inserter(result));
     return result;
 }
 
+nonneg int astCount(const Token* tok, const char* op, int depth)
+{
+    --depth;
+    if (!tok || depth < 0)
+        return 0;
+    if (strcmp(tok->str().c_str(), op) == 0)
+        return astCount(tok->astOperand1(), op, depth) + astCount(tok->astOperand2(), op, depth);
+    return 1;
+}
 
 bool astHasToken(const Token* root, const Token * tok)
 {
     if (!root)
         return false;
-    if (root == tok)
-        return true;
-    return astHasToken(root->astOperand1(), tok) || astHasToken(root->astOperand2(), tok);
+    while (tok->astParent() && tok != root)
+        tok = tok->astParent();
+    return root == tok;
 }
 
 bool astHasVar(const Token * tok, nonneg int varid)
@@ -92,6 +164,15 @@ bool astHasVar(const Token * tok, nonneg int varid)
     return astHasVar(tok->astOperand1(), varid) || astHasVar(tok->astOperand2(), varid);
 }
 
+bool astHasExpr(const Token* tok, nonneg int exprid)
+{
+    if (!tok)
+        return false;
+    if (tok->exprId() == exprid)
+        return true;
+    return astHasExpr(tok->astOperand1(), exprid) || astHasExpr(tok->astOperand2(), exprid);
+}
+
 static bool astIsCharWithSign(const Token *tok, ValueType::Sign sign)
 {
     if (!tok)
@@ -112,6 +193,19 @@ bool astIsUnknownSignChar(const Token *tok)
     return astIsCharWithSign(tok, ValueType::Sign::UNKNOWN_SIGN);
 }
 
+bool astIsGenericChar(const Token* tok)
+{
+    return !astIsPointer(tok) && tok && tok->valueType() && (tok->valueType()->type == ValueType::Type::CHAR || tok->valueType()->type == ValueType::Type::WCHAR_T);
+}
+
+bool astIsPrimitive(const Token* tok)
+{
+    const ValueType* vt = tok ? tok->valueType() : nullptr;
+    if (!vt)
+        return false;
+    return vt->isPrimitive();
+}
+
 bool astIsIntegral(const Token *tok, bool unknown)
 {
     const ValueType *vt = tok ? tok->valueType() : nullptr;
@@ -120,6 +214,11 @@ bool astIsIntegral(const Token *tok, bool unknown)
     return vt->isIntegral() && vt->pointer == 0U;
 }
 
+bool astIsUnsigned(const Token* tok)
+{
+    return tok && tok->valueType() && tok->valueType()->sign == ValueType::UNSIGNED;
+}
+
 bool astIsFloat(const Token *tok, bool unknown)
 {
     const ValueType *vt = tok ? tok->valueType() : nullptr;
@@ -143,31 +242,116 @@ bool astIsSmartPointer(const Token* tok)
     return tok && tok->valueType() && tok->valueType()->smartPointerTypeToken;
 }
 
+bool astIsUniqueSmartPointer(const Token* tok)
+{
+    if (!astIsSmartPointer(tok))
+        return false;
+    if (!tok->valueType()->smartPointer)
+        return false;
+    return tok->valueType()->smartPointer->unique;
+}
+
 bool astIsIterator(const Token *tok)
 {
     return tok && tok->valueType() && tok->valueType()->type == ValueType::Type::ITERATOR;
 }
 
-bool astIsContainer(const Token *tok)
+bool astIsContainer(const Token* tok) {
+    return getLibraryContainer(tok) != nullptr && !astIsIterator(tok);
+}
+
+bool astIsNonStringContainer(const Token* tok)
+{
+    const Library::Container* container = getLibraryContainer(tok);
+    return container && !container->stdStringLike && !astIsIterator(tok);
+}
+
+bool astIsContainerView(const Token* tok)
+{
+    const Library::Container* container = getLibraryContainer(tok);
+    return container && !astIsIterator(tok) && container->view;
+}
+
+bool astIsContainerOwned(const Token* tok) {
+    return astIsContainer(tok) && !astIsContainerView(tok);
+}
+
+bool astIsContainerString(const Token* tok)
+{
+    if (!tok)
+        return false;
+    if (!tok->valueType())
+        return false;
+    const Library::Container* container = tok->valueType()->container;
+    if (!container)
+        return false;
+    return container->stdStringLike;
+}
+
+static std::pair<const Token*, const Library::Container*> getContainerFunction(const Token* tok, const Library& library)
+{
+    const Library::Container* cont{};
+    if (!tok || !tok->valueType() || (!tok->valueType()->container && (!(cont = library.detectContainerOrIterator(tok->valueType()->smartPointerTypeToken)))))
+        return {};
+    const Token* parent = tok->astParent();
+    if (Token::Match(parent, ". %name% [(<]") && astIsLHS(tok)) {
+        return { parent->next(), cont ? cont : tok->valueType()->container };
+    }
+    return {};
+}
+
+Library::Container::Action astContainerAction(const Token* tok, const Library& library, const Token** ftok)
+{
+    const auto ftokCont = getContainerFunction(tok, library);
+    if (ftok)
+        *ftok = ftokCont.first;
+    if (!ftokCont.first)
+        return Library::Container::Action::NO_ACTION;
+    return ftokCont.second->getAction(ftokCont.first->str());
+}
+
+Library::Container::Yield astContainerYield(const Token* tok, const Library& library, const Token** ftok)
+{
+    const auto ftokCont = getContainerFunction(tok, library);
+    if (ftok)
+        *ftok = ftokCont.first;
+    if (!ftokCont.first)
+        return Library::Container::Yield::NO_YIELD;
+    return ftokCont.second->getYield(ftokCont.first->str());
+}
+
+Library::Container::Yield astFunctionYield(const Token* tok, const Settings& settings, const Token** ftok)
+{
+    if (!tok)
+        return Library::Container::Yield::NO_YIELD;
+
+    const auto* function = settings.library.getFunction(tok);
+    if (!function)
+        return Library::Container::Yield::NO_YIELD;
+
+    if (ftok)
+        *ftok = tok;
+    return function->containerYield;
+}
+
+bool astIsRangeBasedForDecl(const Token* tok)
 {
-    return getLibraryContainer(tok) != nullptr && tok->valueType()->type != ValueType::Type::ITERATOR;
+    return Token::simpleMatch(tok->astParent(), ":") && Token::simpleMatch(tok->astParent()->astParent(), "(");
 }
 
-std::string astCanonicalType(const Token *expr)
+std::string astCanonicalType(const Token *expr, bool pointedToType)
 {
     if (!expr)
         return "";
-    if (expr->variable()) {
-        const Variable *var = expr->variable();
+    std::pair<const Token*, const Token*> decl = Token::typeDecl(expr, pointedToType);
+    if (decl.first && decl.second) {
         std::string ret;
-        for (const Token *type = var->typeStartToken(); Token::Match(type,"%name%|::") && type != var->nameToken(); type = type->next()) {
+        for (const Token *type = decl.first; Token::Match(type,"%name%|::") && type != decl.second; type = type->next()) {
             if (!Token::Match(type, "const|static"))
                 ret += type->str();
         }
         return ret;
-
     }
-    // TODO: handle expressions
     return "";
 }
 
@@ -175,7 +359,7 @@ static bool match(const Token *tok, const std::string &rhs)
 {
     if (tok->str() == rhs)
         return true;
-    if (!tok->varId() && tok->hasKnownIntValue() && MathLib::toString(tok->values().front().intvalue) == rhs)
+    if (!tok->varId() && tok->hasKnownIntValue() && MathLib::toString(tok->getKnownIntValue()) == rhs)
         return true;
     return false;
 }
@@ -200,9 +384,14 @@ const Token * astIsVariableComparison(const Token *tok, const std::string &comp,
         } else if (tok->str() == comp && tok->astOperand2() && match(tok->astOperand2(), rhs)) {
             ret = tok->astOperand1();
         }
-    } else if (comp == "!=" && rhs == std::string("0")) {
-        ret = tok;
-    } else if (comp == "==" && rhs == std::string("0")) {
+    } else if (comp == "!=" && rhs == "0") {
+        if (tok->str() == "!") {
+            ret = tok->astOperand1();
+            // handle (!(x==0)) as (x!=0)
+            astIsVariableComparison(ret, "==", "0", &ret);
+        } else
+            ret = tok;
+    } else if (comp == "==" && rhs == "0") {
         if (tok->str() == "!") {
             ret = tok->astOperand1();
             // handle (!(x!=0)) as (x==0)
@@ -220,11 +409,106 @@ const Token * astIsVariableComparison(const Token *tok, const std::string &comp,
     return ret;
 }
 
+bool isVariableDecl(const Token* tok)
+{
+    if (!tok)
+        return false;
+    const Variable* var = tok->variable();
+    if (!var)
+        return false;
+    if (var->nameToken() == tok)
+        return true;
+    const Token * const varDeclEndToken = var->declEndToken();
+    return Token::Match(varDeclEndToken, "; %var%") && varDeclEndToken->next() == tok;
+}
+
+bool isStlStringType(const Token* tok)
+{
+    return Token::Match(tok, "std :: string|wstring|u16string|u32string !!::") ||
+           (Token::simpleMatch(tok, "std :: basic_string <") && !Token::simpleMatch(tok->linkAt(3), "> ::"));
+}
+
+bool isVoidCast(const Token* tok)
+{
+    return Token::simpleMatch(tok, "(") && tok->isCast() && tok->valueType() &&
+           tok->valueType()->type == ValueType::Type::VOID && tok->valueType()->pointer == 0;
+}
+
+bool isTemporary(const Token* tok, const Library* library, bool unknown)
+{
+    if (!tok)
+        return false;
+    if (Token::simpleMatch(tok, "."))
+        return (tok->originalName() != "->" && isTemporary(tok->astOperand1(), library)) ||
+               isTemporary(tok->astOperand2(), library);
+    if (Token::Match(tok, ",|::"))
+        return isTemporary(tok->astOperand2(), library);
+    if (tok->isCast() || (tok->isCpp() && isCPPCast(tok)))
+        return isTemporary(tok->astOperand2(), library);
+    if (findLambdaEndToken(tok) != nullptr)
+        return true;
+    if (Token::Match(tok, ".|[|++|--|%name%|%assign%"))
+        return false;
+    if (tok->isUnaryOp("*"))
+        return false;
+    if (Token::Match(tok, "&|<<|>>") && isLikelyStream(tok->astOperand1()))
+        return false;
+    if (Token::simpleMatch(tok, "?")) {
+        const Token* branchTok = tok->astOperand2();
+        if (!branchTok->astOperand1() || !branchTok->astOperand1()->valueType())
+            return false;
+        if (!branchTok->astOperand2()->valueType())
+            return false;
+        return !branchTok->astOperand1()->valueType()->isTypeEqual(branchTok->astOperand2()->valueType());
+    }
+    if (Token::simpleMatch(tok, "(") && tok->astOperand1() &&
+        (tok->astOperand2() || Token::simpleMatch(tok->next(), ")"))) {
+        if (Token::simpleMatch(tok->astOperand1(), "typeid"))
+            return false;
+        if (tok->valueType()) {
+            if (tok->valueType()->pointer > 0) {
+                const Token* const parent = tok->astParent();
+                if (Token::simpleMatch(parent, "&"))
+                    return true;
+                if (Token::simpleMatch(parent, "return") && parent->valueType()->reference != Reference::None &&
+                    parent->valueType()->container && parent->valueType()->container->stdStringLike)
+                    return true;
+            }
+            return tok->valueType()->reference == Reference::None && tok->valueType()->pointer == 0;
+        }
+        const Token* ftok = nullptr;
+        if (Token::simpleMatch(tok->previous(), ">") && tok->linkAt(-1))
+            ftok = tok->linkAt(-1)->previous();
+        else
+            ftok = tok->previous();
+        if (!ftok)
+            return false;
+        if (const Function * f = ftok->function())
+            return !Function::returnsReference(f, true);
+        if (ftok->type())
+            return true;
+        if (library) {
+            const std::string& returnType = library->returnValueType(ftok);
+            return !returnType.empty() && returnType.back() != '&';
+        }
+        return unknown;
+    }
+    if (tok->isCast())
+        return false;
+    // Currying a function is unknown in cppcheck
+    if (Token::simpleMatch(tok, "(") && Token::simpleMatch(tok->astOperand1(), "("))
+        return unknown;
+    if (Token::simpleMatch(tok, "{") && Token::simpleMatch(tok->astParent(), "return") && tok->astOperand1() &&
+        !tok->astOperand2())
+        return isTemporary(tok->astOperand1(), library);
+    return true;
+}
+
 static bool isFunctionCall(const Token* tok)
 {
     if (Token::Match(tok, "%name% ("))
         return true;
-    if (Token::Match(tok, "%name% <") && Token::simpleMatch(tok->next()->link(), "> ("))
+    if (Token::Match(tok, "%name% <") && Token::simpleMatch(tok->linkAt(1), "> ("))
         return true;
     if (Token::Match(tok, "%name% ::"))
         return isFunctionCall(tok->tokAt(2));
@@ -240,24 +524,60 @@ static bool hasToken(const Token * startTok, const Token * stopTok, const Token
     return false;
 }
 
-const Token * nextAfterAstRightmostLeaf(const Token * tok)
+template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+static T* previousBeforeAstLeftmostLeafGeneric(T* tok)
+{
+    if (!tok)
+        return nullptr;
+    T* leftmostLeaf = tok;
+    while (leftmostLeaf->astOperand1())
+        leftmostLeaf = leftmostLeaf->astOperand1();
+    return leftmostLeaf->previous();
+}
+
+const Token* previousBeforeAstLeftmostLeaf(const Token* tok)
+{
+    return previousBeforeAstLeftmostLeafGeneric(tok);
+}
+Token* previousBeforeAstLeftmostLeaf(Token* tok)
+{
+    return previousBeforeAstLeftmostLeafGeneric(tok);
+}
+
+template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+static T* nextAfterAstRightmostLeafGeneric(T* tok)
 {
-    const Token * rightmostLeaf = tok;
+    T * rightmostLeaf = tok;
     if (!rightmostLeaf || !rightmostLeaf->astOperand1())
         return nullptr;
     do {
-        if (rightmostLeaf->astOperand2())
+        if (T* lam = findLambdaEndToken(rightmostLeaf)) {
+            rightmostLeaf = lam;
+            break;
+        }
+        if (rightmostLeaf->astOperand2() && precedes(rightmostLeaf, rightmostLeaf->astOperand2()))
             rightmostLeaf = rightmostLeaf->astOperand2();
-        else
+        else if (rightmostLeaf->astOperand1() && precedes(rightmostLeaf, rightmostLeaf->astOperand1()))
             rightmostLeaf = rightmostLeaf->astOperand1();
-    } while (rightmostLeaf->astOperand1());
-    while (Token::Match(rightmostLeaf->next(), "]|)") && !hasToken(rightmostLeaf->next()->link(), rightmostLeaf->next(), tok))
+        else
+            break;
+    } while (rightmostLeaf->astOperand1() || rightmostLeaf->astOperand2());
+    while (Token::Match(rightmostLeaf->next(), "]|)") && !hasToken(rightmostLeaf->linkAt(1), rightmostLeaf->next(), tok))
         rightmostLeaf = rightmostLeaf->next();
-    if (rightmostLeaf->str() == "{" && rightmostLeaf->link())
+    if (Token::Match(rightmostLeaf, "{|(|[") && rightmostLeaf->link())
         rightmostLeaf = rightmostLeaf->link();
     return rightmostLeaf->next();
 }
 
+const Token* nextAfterAstRightmostLeaf(const Token* tok)
+{
+    return nextAfterAstRightmostLeafGeneric(tok);
+}
+Token* nextAfterAstRightmostLeaf(Token* tok)
+{
+    return nextAfterAstRightmostLeafGeneric(tok);
+}
+
 const Token* astParentSkipParens(const Token* tok)
 {
     return astParentSkipParens(const_cast<Token*>(tok));
@@ -271,130 +591,625 @@ Token* astParentSkipParens(Token* tok)
         return parent;
     if (parent->link() != nextAfterAstRightmostLeaf(tok))
         return parent;
+    if (Token::Match(parent->previous(), "%name% (") ||
+        (Token::simpleMatch(parent->previous(), "> (") && parent->linkAt(-1)))
+        return parent;
     return astParentSkipParens(parent);
 }
 
-static const Token * getVariableInitExpression(const Variable * var)
+const Token* getParentMember(const Token * tok)
 {
-    if (!var || !var->declEndToken())
-        return nullptr;
-    if (Token::Match(var->declEndToken(), "; %varid% =", var->declarationId()))
-        return var->declEndToken()->tokAt(2)->astOperand2();
-    return var->declEndToken()->astOperand2();
+    if (!tok)
+        return tok;
+    const Token * parent = tok->astParent();
+    if (!Token::simpleMatch(parent, "."))
+        return tok;
+    if (astIsRHS(tok)) {
+        if (Token::simpleMatch(parent->astOperand1(), "."))
+            return parent->astOperand1()->astOperand2();
+        return parent->astOperand1();
+    }
+    const Token * gparent = parent->astParent();
+    if (!Token::simpleMatch(gparent, ".") || gparent->astOperand2() != parent)
+        return tok;
+    if (gparent->astOperand1())
+        return gparent->astOperand1();
+    return tok;
 }
 
-static bool isInLoopCondition(const Token * tok)
+const Token* getParentLifetime(const Token* tok)
 {
-    return Token::Match(tok->astTop()->previous(), "for|while (");
+    if (!tok)
+        return tok;
+    // Skipping checking for variable if its a pointer-to-member
+    if (!Token::simpleMatch(tok->previous(), ". *")) {
+        const Variable* var = tok->variable();
+        // TODO: Call getLifetimeVariable for deeper analysis
+        if (!var)
+            return tok;
+        if (var->isLocal() || var->isArgument())
+            return tok;
+    }
+    const Token* parent = getParentMember(tok);
+    if (parent != tok)
+        return getParentLifetime(parent);
+    return tok;
 }
 
-/// If tok2 comes after tok1
-bool precedes(const Token * tok1, const Token * tok2)
+static std::vector<const Token*> getParentMembers(const Token* tok)
 {
-    if (!tok1)
-        return false;
-    if (!tok2)
-        return false;
-    return tok1->index() < tok2->index();
+    if (!tok)
+        return {};
+    if (!Token::simpleMatch(tok->astParent(), "."))
+        return {tok};
+    const Token* parent = tok->astParent();
+    while (Token::simpleMatch(parent->astParent(), "."))
+        parent = parent->astParent();
+    std::vector<const Token*> result;
+    for (const Token* tok2 : astFlatten(parent, ".")) {
+        if (Token::simpleMatch(tok2, "(") && Token::simpleMatch(tok2->astOperand1(), ".")) {
+            std::vector<const Token*> sub = getParentMembers(tok2->astOperand1());
+            result.insert(result.end(), sub.cbegin(), sub.cend());
+        }
+        result.push_back(tok2);
+    }
+    return result;
 }
 
-bool isAliasOf(const Token *tok, nonneg int varid)
+static const Token* getParentLifetimeObject(const Token* tok)
 {
-    if (tok->varId() == varid)
-        return false;
-    if (tok->varId() == 0)
-        return false;
-    for (const ValueFlow::Value &val : tok->values()) {
-        if (!val.isLocalLifetimeValue())
-            continue;
-        if (val.isInconclusive())
-            continue;
-        if (val.tokvalue->varId() == varid)
-            return true;
-    }
-    return false;
+    while (Token::simpleMatch(tok, "["))
+        tok = tok->astOperand1();
+    return tok;
 }
 
-static bool isAliased(const Token *startTok, const Token *endTok, nonneg int varid)
+const Token* getParentLifetime(const Token* tok, const Library& library)
 {
-    if (!precedes(startTok, endTok))
-        return false;
-    for (const Token *tok = startTok; tok != endTok; tok = tok->next()) {
-        if (Token::Match(tok, "= & %varid% ;", varid))
+    std::vector<const Token*> members = getParentMembers(tok);
+    if (members.size() < 2)
+        return tok;
+    // Find the first local variable, temporary, or array
+    auto it = std::find_if(members.crbegin(), members.crend(), [&](const Token* tok2) {
+        const Variable* var = tok2->variable();
+        if (var)
+            return var->isLocal() || var->isArgument();
+        if (Token::simpleMatch(tok2, "["))
             return true;
-        if (isAliasOf(tok, varid))
+        return isTemporary(tok2, &library);
+    });
+    if (it == members.rend())
+        return tok;
+    // If any of the submembers are borrowed types then stop
+    if (std::any_of(it.base() - 1, members.cend() - 1, [&](const Token* tok2) {
+        const Token* obj = getParentLifetimeObject(tok2);
+        if (!obj)
+            return false;
+        const Variable* var = obj->variable();
+        // Check for arrays first since astIsPointer will return true, but an array is not a borrowed type
+        if (var && var->isArray())
+            return false;
+        if (astIsPointer(obj) || astIsContainerView(obj) || astIsIterator(obj))
             return true;
-    }
-    return false;
+        if (!astIsUniqueSmartPointer(obj)) {
+            if (astIsSmartPointer(obj))
+                return true;
+            const Token* dotTok = obj->next();
+            if (!Token::simpleMatch(dotTok, ".")) {
+                const Token* endTok = nextAfterAstRightmostLeaf(obj);
+                if (!endTok)
+                    dotTok = obj->next();
+                else if (Token::simpleMatch(endTok, "."))
+                    dotTok = endTok;
+                else if (Token::simpleMatch(endTok->next(), "."))
+                    dotTok = endTok->next();
+            }
+            // If we are dereferencing the member variable then treat it as borrowed
+            if (Token::simpleMatch(dotTok, ".") && dotTok->originalName() == "->")
+                return true;
+        }
+        return var && var->isReference();
+    }))
+        return nullptr;
+    const Token* result = getParentLifetimeObject(*it);
+    if (result != *it)
+        return getParentLifetime(result);
+    return result;
 }
 
-bool isAliased(const Variable *var)
+static bool isInConstructorList(const Token* tok)
 {
-    if (!var)
+    if (!tok)
         return false;
-    if (!var->scope())
+    if (!astIsRHS(tok))
         return false;
-    const Token *start = var->declEndToken();
-    if (!start)
+    const Token* parent = tok->astParent();
+    if (!Token::Match(parent, "{|("))
         return false;
-    return isAliased(start, var->scope()->bodyEnd, var->declarationId());
+    if (!Token::Match(parent->previous(), "%var% {|("))
+        return false;
+    if (!parent->astOperand1() || !parent->astOperand2())
+        return false;
+    do {
+        parent = parent->astParent();
+    } while (Token::simpleMatch(parent, ","));
+    return Token::simpleMatch(parent, ":") && !Token::simpleMatch(parent->astParent(), "?");
 }
 
-bool exprDependsOnThis(const Token* expr, nonneg int depth)
+std::vector<ValueType> getParentValueTypes(const Token* tok, const Settings& settings, const Token** parent)
 {
-    if (!expr)
-        return false;
-    if (depth >= 1000)
-        // Abort recursion to avoid stack overflow
-        return true;
-    ++depth;
-    // calling nonstatic method?
-    if (Token::Match(expr->previous(), "!!:: %name% (") && expr->function() && expr->function()->nestedIn && expr->function()->nestedIn->isClassOrStruct()) {
-        // is it a method of this?
-        const Scope *nestedIn = expr->scope()->functionOf;
-        if (nestedIn && nestedIn->function)
-            nestedIn = nestedIn->function->token->scope();
-        while (nestedIn && nestedIn != expr->function()->nestedIn) {
-            nestedIn = nestedIn->nestedIn;
-        }
-        return nestedIn == expr->function()->nestedIn;
-    } else if (Token::Match(expr, "%var%") && expr->variable()) {
-        const Variable* var = expr->variable();
-        return (var->isPrivate() || var->isPublic() || var->isProtected());
+    if (!tok)
+        return {};
+    if (!tok->astParent())
+        return {};
+    if (isInConstructorList(tok)) {
+        if (parent)
+            *parent = tok->astParent()->astOperand1();
+        if (tok->astParent()->astOperand1()->valueType())
+            return {*tok->astParent()->astOperand1()->valueType()};
+        return {};
     }
-    if (Token::simpleMatch(expr, "."))
-        return exprDependsOnThis(expr->astOperand1(), depth);
-    return exprDependsOnThis(expr->astOperand1(), depth) || exprDependsOnThis(expr->astOperand2(), depth);
+    const Token* ftok = nullptr;
+    if (Token::Match(tok->astParent(), "(|{|,")) {
+        int argn = -1;
+        ftok = getTokenArgumentFunction(tok, argn);
+        const Token* typeTok = nullptr;
+        if (ftok && argn >= 0) {
+            if (ftok->function()) {
+                std::vector<ValueType> result;
+                const Token* nameTok = nullptr;
+                for (const Variable* var : getArgumentVars(ftok, argn)) {
+                    if (!var)
+                        continue;
+                    if (!var->valueType())
+                        continue;
+                    nameTok = var->nameToken();
+                    result.push_back(*var->valueType());
+                    if (var->isArray())
+                        result.back().pointer += var->dimensions().size();
+                }
+                if (result.size() == 1 && nameTok && parent) {
+                    *parent = nameTok;
+                }
+                return result;
+            }
+            if (const Type* t = Token::typeOf(ftok, &typeTok)) {
+                if (astIsPointer(typeTok))
+                    return {*typeTok->valueType()};
+                const Scope* scope = t->classScope;
+                // Check for aggregate constructors
+                if (scope && scope->numConstructors == 0 && t->derivedFrom.empty() &&
+                    (t->isClassType() || t->isStructType()) && numberOfArguments(ftok) <= scope->varlist.size() &&
+                    !scope->varlist.empty()) {
+                    if (argn < scope->varlist.size()) {
+                        auto it = std::next(scope->varlist.cbegin(), argn);
+                        if (it->valueType())
+                            return { *it->valueType() };
+                    }
+                }
+            }
+        }
+    }
+    if (Token::Match(tok->astParent()->tokAt(-2), ". push_back|push_front|insert|push (") &&
+        astIsContainer(tok->astParent()->tokAt(-2)->astOperand1())) {
+        const Token* contTok = tok->astParent()->tokAt(-2)->astOperand1();
+        const ValueType* vtCont = contTok->valueType();
+        if (!vtCont->containerTypeToken)
+            return {};
+        ValueType vtParent = ValueType::parseDecl(vtCont->containerTypeToken, settings);
+        return {std::move(vtParent)};
+    }
+    // The return type of a function is not the parent valuetype
+    if (Token::simpleMatch(tok->astParent(), "(") && ftok && !tok->astParent()->isCast() &&
+        ftok->tokType() != Token::eType)
+        return {};
+    if (parent && Token::Match(tok->astParent(), "return|(|{|%assign%")) {
+        *parent = tok->astParent();
+    }
+    if (tok->astParent()->valueType())
+        return {*tok->astParent()->valueType()};
+    return {};
 }
 
-/// This takes a token that refers to a variable and it will return the token
-/// to the expression that the variable is assigned to. If its not valid to
-/// make such substitution then it will return the original token.
-static const Token * followVariableExpression(const Token * tok, bool cpp, const Token * end = nullptr)
+bool astIsLHS(const Token* tok)
 {
     if (!tok)
-        return tok;
-    // Skip following variables that is across multiple files
-    if (end && end->fileIndex() != tok->fileIndex())
-        return tok;
-    // Skip array access
-    if (Token::Match(tok, "%var% ["))
-        return tok;
-    // Skip pointer indirection
-    if (tok->astParent() && tok->isUnaryOp("*"))
-        return tok;
-    // Skip following variables if it is used in an assignment
+        return false;
+    const Token* parent = tok->astParent();
+    if (!parent)
+        return false;
+    if (!parent->astOperand1())
+        return false;
+    if (!parent->astOperand2())
+        return false;
+    return parent->astOperand1() == tok;
+}
+bool astIsRHS(const Token* tok)
+{
+    if (!tok)
+        return false;
+    const Token* parent = tok->astParent();
+    if (!parent)
+        return false;
+    if (!parent->astOperand1())
+        return false;
+    if (!parent->astOperand2())
+        return false;
+    return parent->astOperand2() == tok;
+}
+
+template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+static T* getCondTokImpl(T* tok)
+{
+    if (!tok)
+        return nullptr;
+    if (Token::simpleMatch(tok, "("))
+        return getCondTok(tok->previous());
+    if (Token::simpleMatch(tok, "do {")) {
+        T* endTok = tok->linkAt(1);
+        if (Token::simpleMatch(endTok, "} while ("))
+            return endTok->tokAt(2)->astOperand2();
+    }
+    if (Token::simpleMatch(tok, "for") && Token::simpleMatch(tok->next()->astOperand2(), ";") &&
+        tok->next()->astOperand2()->astOperand2())
+        return tok->next()->astOperand2()->astOperand2()->astOperand1();
+    if (Token::simpleMatch(tok->next()->astOperand2(), ";"))
+        return tok->next()->astOperand2()->astOperand1();
+    if (tok->isName() && !tok->isControlFlowKeyword())
+        return nullptr;
+    return tok->next()->astOperand2();
+}
+
+template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+static T* getCondTokFromEndImpl(T* endBlock)
+{
+    if (!Token::simpleMatch(endBlock, "}"))
+        return nullptr;
+    T* startBlock = endBlock->link();
+    if (!Token::simpleMatch(startBlock, "{"))
+        return nullptr;
+    if (Token::simpleMatch(startBlock->previous(), "do"))
+        return getCondTok(startBlock->previous());
+    if (Token::simpleMatch(startBlock->previous(), ")"))
+        return getCondTok(startBlock->linkAt(-1));
+    if (Token::simpleMatch(startBlock->tokAt(-2), "} else {"))
+        return getCondTokFromEnd(startBlock->tokAt(-2));
+    return nullptr;
+}
+
+template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+static T* getInitTokImpl(T* tok)
+{
+    if (!tok)
+        return nullptr;
+    if (Token::Match(tok, "%name% ("))
+        return getInitTokImpl(tok->next());
+    if (tok->str() != "(")
+        return nullptr;
+    if (!Token::simpleMatch(tok->astOperand2(), ";"))
+        return nullptr;
+    if (Token::simpleMatch(tok->astOperand2()->astOperand1(), ";"))
+        return nullptr;
+    return tok->astOperand2()->astOperand1();
+}
+
+template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+static T* getStepTokImpl(T* tok)
+{
+    if (!tok)
+        return nullptr;
+    if (Token::Match(tok, "%name% ("))
+        return getStepTokImpl(tok->next());
+    if (tok->str() != "(")
+        return nullptr;
+    if (!Token::simpleMatch(tok->astOperand2(), ";"))
+        return nullptr;
+    if (!Token::simpleMatch(tok->astOperand2()->astOperand2(), ";"))
+        return nullptr;
+    return tok->astOperand2()->astOperand2()->astOperand2();
+}
+
+Token* getCondTok(Token* tok)
+{
+    return getCondTokImpl(tok);
+}
+const Token* getCondTok(const Token* tok)
+{
+    return getCondTokImpl(tok);
+}
+
+Token* getCondTokFromEnd(Token* endBlock)
+{
+    return getCondTokFromEndImpl(endBlock);
+}
+const Token* getCondTokFromEnd(const Token* endBlock)
+{
+    return getCondTokFromEndImpl(endBlock);
+}
+
+Token* getInitTok(Token* tok) {
+    return getInitTokImpl(tok);
+}
+const Token* getInitTok(const Token* tok) {
+    return getInitTokImpl(tok);
+}
+
+Token* getStepTok(Token* tok) {
+    return getStepTokImpl(tok);
+}
+const Token* getStepTok(const Token* tok) {
+    return getStepTokImpl(tok);
+}
+
+const Token *findNextTokenFromBreak(const Token *breakToken)
+{
+    const Scope *scope = breakToken->scope();
+    while (scope) {
+        if (scope->isLoopScope() || scope->type == ScopeType::eSwitch) {
+            if (scope->type == ScopeType::eDo && Token::simpleMatch(scope->bodyEnd, "} while ("))
+                return scope->bodyEnd->linkAt(2)->next();
+            return scope->bodyEnd;
+        }
+        scope = scope->nestedIn;
+    }
+    return nullptr;
+}
+
+bool extractForLoopValues(const Token *forToken,
+                          nonneg int &varid,
+                          bool &knownInitValue,
+                          MathLib::bigint &initValue,
+                          bool &partialCond,
+                          MathLib::bigint &stepValue,
+                          MathLib::bigint &lastValue)
+{
+    if (!Token::simpleMatch(forToken, "for (") || !Token::simpleMatch(forToken->next()->astOperand2(), ";"))
+        return false;
+    const Token *initExpr = forToken->next()->astOperand2()->astOperand1();
+    const Token *condExpr = forToken->next()->astOperand2()->astOperand2()->astOperand1();
+    const Token *incExpr  = forToken->next()->astOperand2()->astOperand2()->astOperand2();
+    if (!initExpr || !initExpr->isBinaryOp() || initExpr->str() != "=" || !Token::Match(initExpr->astOperand1(), "%var%"))
+        return false;
+    std::vector<MathLib::bigint> minInitValue =
+        getMinValue(makeIntegralInferModel(), initExpr->astOperand2()->values());
+    if (minInitValue.empty()) {
+        const ValueFlow::Value* v = initExpr->astOperand2()->getMinValue(true);
+        if (v)
+            minInitValue.push_back(v->intvalue);
+    }
+    if (minInitValue.empty())
+        return false;
+    varid = initExpr->astOperand1()->varId();
+    knownInitValue = initExpr->astOperand2()->hasKnownIntValue();
+    initValue = minInitValue.front();
+    partialCond = Token::Match(condExpr, "%oror%|&&");
+    visitAstNodes(condExpr, [varid, &condExpr](const Token *tok) {
+        if (Token::Match(tok, "%oror%|&&"))
+            return ChildrenToVisit::op1_and_op2;
+        if (Token::Match(tok, "<|<=") && tok->isBinaryOp() && tok->astOperand1()->varId() == varid && tok->astOperand2()->hasKnownIntValue()) {
+            if (Token::Match(condExpr, "%oror%|&&") || tok->astOperand2()->getKnownIntValue() < condExpr->astOperand2()->getKnownIntValue())
+                condExpr = tok;
+        }
+        return ChildrenToVisit::none;
+    });
+    if (!Token::Match(condExpr, "<|<=") || !condExpr->isBinaryOp() || condExpr->astOperand1()->varId() != varid || !condExpr->astOperand2()->hasKnownIntValue())
+        return false;
+    if (!incExpr || !incExpr->isUnaryOp("++") || incExpr->astOperand1()->varId() != varid)
+        return false;
+    stepValue = 1;
+    if (condExpr->str() == "<")
+        lastValue = condExpr->astOperand2()->getKnownIntValue() - 1;
+    else
+        lastValue = condExpr->astOperand2()->getKnownIntValue();
+    return true;
+}
+
+
+static const Token * getVariableInitExpression(const Variable * var)
+{
+    if (!var)
+        return nullptr;
+    const Token *varDeclEndToken = var->declEndToken();
+    if (!varDeclEndToken)
+        return nullptr;
+    if (Token::Match(varDeclEndToken, "; %varid% =", var->declarationId()))
+        return varDeclEndToken->tokAt(2)->astOperand2();
+    return varDeclEndToken->astOperand2();
+}
+
+const Token* isInLoopCondition(const Token* tok)
+{
+    const Token* top = tok->astTop();
+    return Token::Match(top->previous(), "for|while (") ? top : nullptr;
+}
+
+bool isDesignatedInitializer(const Token* tok)
+{
+    return tok && tok->isUnaryOp(".");
+}
+
+/// If tok2 comes after tok1
+bool precedes(const Token * tok1, const Token * tok2)
+{
+    if (tok1 == tok2)
+        return false;
+    if (!tok1)
+        return false;
+    if (!tok2)
+        return true;
+    return tok1->index() < tok2->index();
+}
+
+/// If tok1 comes after tok2
+bool succeeds(const Token* tok1, const Token* tok2)
+{
+    if (tok1 == tok2)
+        return false;
+    if (!tok1)
+        return false;
+    if (!tok2)
+        return true;
+    return tok1->index() > tok2->index();
+}
+
+bool isAliasOf(const Token *tok, nonneg int varid, bool* inconclusive)
+{
+    if (tok->varId() == varid)
+        return false;
+    // NOLINTNEXTLINE(readability-use-anyofallof) - TODO: fix this / also Cppcheck false negative
+    for (const ValueFlow::Value &val : tok->values()) {
+        if (!val.isLocalLifetimeValue())
+            continue;
+        if (val.tokvalue->varId() == varid) {
+            if (val.isInconclusive()) {
+                if (inconclusive)
+                    *inconclusive = true;
+                else
+                    continue;
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+bool isAliasOf(const Token* tok, const Token* expr, nonneg int* indirect)
+{
+    if (indirect)
+        *indirect = 1;
+    if (!tok)
+        return false;
+    const Token* r = nullptr;
+    for (const ReferenceToken& ref : tok->refs()) {
+        const bool pointer = astIsPointer(ref.token);
+        r = findAstNode(expr, [&](const Token* childTok) {
+            if (childTok->exprId() == 0)
+                return false;
+            if (ref.token != tok && expr->exprId() == childTok->exprId() && ref.token->isUnaryOp("*") && expr->exprId() == ref.token->astOperand1()->exprId()) {
+                if (indirect)
+                    *indirect = 0;
+                return true;
+            }
+            for (const ValueFlow::Value& val : ref.token->values()) {
+                if (val.isImpossible())
+                    continue;
+                if (val.isLocalLifetimeValue() || (pointer && val.isSymbolicValue() && val.intvalue == 0)) {
+                    if (findAstNode(val.tokvalue,
+                                    [&](const Token* aliasTok) {
+                        return aliasTok != childTok && aliasTok->exprId() == childTok->exprId();
+                    })) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        });
+        if (r)
+            break;
+    }
+    return r;
+}
+
+static bool isAliased(const Token *startTok, const Token *endTok, nonneg int varid)
+{
+    if (!precedes(startTok, endTok))
+        return false;
+    for (const Token *tok = startTok; tok != endTok; tok = tok->next()) {
+        if (Token::Match(tok, "= & %varid% ;", varid))
+            return true;
+        if (isAliasOf(tok, varid))
+            return true;
+    }
+    return false;
+}
+
+bool exprDependsOnThis(const Token* expr, bool onVar, nonneg int depth)
+{
+    if (!expr)
+        return false;
+    if (expr->str() == "this")
+        return true;
+    if (depth >= 1000)
+        // Abort recursion to avoid stack overflow
+        return true;
+    ++depth;
+
+    // calling nonstatic method?
+    if (Token::Match(expr, "%name% (")) {
+        if (expr->function() && expr->function()->nestedIn && expr->function()->nestedIn->isClassOrStruct() && !expr->function()->isStatic()) {
+            // is it a method of this?
+            const Scope* fScope = expr->scope();
+            while (!fScope->functionOf && fScope->nestedIn)
+                fScope = fScope->nestedIn;
+
+            const Scope* classScope = fScope->functionOf;
+            if (classScope && classScope->function)
+                classScope = classScope->function->token->scope();
+
+            if (classScope && classScope->isClassOrStruct())
+                return contains(classScope->findAssociatedScopes(), expr->function()->nestedIn);
+            return false;
+        }
+        if (expr->isOperatorKeyword() && !Token::simpleMatch(expr->next()->astParent(), "."))
+            return true;
+    }
+    if (onVar && expr->variable()) {
+        const Variable* var = expr->variable();
+        return ((var->isPrivate() || var->isPublic() || var->isProtected()) && !var->isStatic());
+    }
+    if (Token::simpleMatch(expr, "."))
+        return exprDependsOnThis(expr->astOperand1(), onVar, depth);
+    return exprDependsOnThis(expr->astOperand1(), onVar, depth) || exprDependsOnThis(expr->astOperand2(), onVar, depth);
+}
+
+static bool hasUnknownVars(const Token* startTok)
+{
+    bool result = false;
+    visitAstNodes(startTok, [&](const Token* tok) {
+        if (tok->varId() > 0 && !tok->variable()) {
+            result = true;
+            return ChildrenToVisit::done;
+        }
+        return ChildrenToVisit::op1_and_op2;
+    });
+    return result;
+}
+
+bool isStructuredBindingVariable(const Variable* var)
+{
+    if (!var || var->isArray())
+        return false;
+    const Token* tok = var->nameToken();
+    while (tok && Token::Match(tok->astParent(), "[|,|:"))
+        tok = tok->astParent();
+    return tok && (tok->str() == "[" || Token::simpleMatch(tok->previous(), "] :")); // TODO: remove workaround when #11105 is fixed
+}
+
+/// This takes a token that refers to a variable and it will return the token
+/// to the expression that the variable is assigned to. If its not valid to
+/// make such substitution then it will return the original token.
+static const Token * followVariableExpression(const Settings& settings, const Token * tok, const Token * end = nullptr)
+{
+    if (!tok)
+        return tok;
+    // Skip following variables that is across multiple files
+    if (end && end->fileIndex() != tok->fileIndex())
+        return tok;
+    // Skip array access
+    if (Token::Match(tok, "%var% ["))
+        return tok;
+    // Skip pointer indirection
+    if (tok->astParent() && tok->isUnaryOp("*"))
+        return tok;
+    // Skip following variables if it is used in an assignment
     if (Token::Match(tok->next(), "%assign%"))
         return tok;
     const Variable * var = tok->variable();
     const Token * varTok = getVariableInitExpression(var);
     if (!varTok)
         return tok;
-    // Bailout. If variable value depends on value of "this".
-    if (exprDependsOnThis(varTok))
+    if (hasUnknownVars(varTok))
         return tok;
-    // Skip array access
-    if (Token::simpleMatch(varTok, "["))
+    if (astIsRangeBasedForDecl(var->nameToken()))
         return tok;
     if (var->isVolatile())
         return tok;
@@ -404,47 +1219,29 @@ static const Token * followVariableExpression(const Token * tok, bool cpp, const
         return tok;
     if (var->isArgument())
         return tok;
+    if (isStructuredBindingVariable(var))
+        return tok;
+    // assigning a floating point value to an integer does not preserve the value
+    if (var->valueType() && var->valueType()->isIntegral() && varTok->valueType() && varTok->valueType()->isFloat())
+        return tok;
     const Token * lastTok = precedes(tok, end) ? end : tok;
     // If this is in a loop then check if variables are modified in the entire scope
     const Token * endToken = (isInLoopCondition(tok) || isInLoopCondition(varTok) || var->scope() != tok->scope()) ? var->scope()->bodyEnd : lastTok;
-    if (!var->isConst() && (!precedes(varTok, endToken) || isVariableChanged(varTok, endToken, tok->varId(), false, nullptr, cpp)))
+    const int indirect = var->isArray() ? var->dimensions().size() : 0;
+    if (!var->isConst() && (!precedes(varTok, endToken) || isVariableChanged(varTok, endToken, indirect, tok->varId(), false, settings)))
         return tok;
     if (precedes(varTok, endToken) && isAliased(varTok, endToken, tok->varId()))
         return tok;
-    // Start at beginning of initialization
-    const Token * startToken = varTok;
-    while (Token::Match(startToken, "%op%|.|(|{") && startToken->astOperand1())
-        startToken = startToken->astOperand1();
-    // Skip if the variable its referring to is modified
-    for (const Token * tok2 = startToken; tok2 != endToken; tok2 = tok2->next()) {
-        if (Token::simpleMatch(tok2, ";"))
-            break;
-        if (tok2->astParent() && tok2->isUnaryOp("*"))
-            return tok;
-        if (tok2->tokType() == Token::eIncDecOp ||
-            tok2->isAssignmentOp() ||
-            Token::Match(tok2, "%name% .|[|++|--|%assign%")) {
-            return tok;
-        }
-
-        if (const Variable * var2 = tok2->variable()) {
-            if (!var2->scope())
-                return tok;
-            const Token * endToken2 = var2->scope() != tok->scope() ? var2->scope()->bodyEnd : endToken;
-            if (!var2->isLocal() && !var2->isConst() && !var2->isArgument())
-                return tok;
-            if (var2->isStatic() && !var2->isConst())
-                return tok;
-            if (!var2->isConst() && (!precedes(tok2, endToken2) || isVariableChanged(tok2, endToken2, tok2->varId(), false, nullptr, cpp)))
-                return tok;
-            if (precedes(tok2, endToken2) && isAliased(tok2, endToken2, tok2->varId()))
-                return tok;
-            // Recognized as a variable but the declaration is unknown
-        } else if (tok2->varId() > 0) {
+    const Token* startToken = nextAfterAstRightmostLeaf(varTok);
+    if (!startToken)
+        startToken = varTok;
+    if (varTok->exprId() == 0) {
+        if (!varTok->isLiteral())
             return tok;
-        } else if (tok2->tokType() == Token::eName && !Token::Match(tok2, "sizeof|decltype|typeof") && !tok2->function()) {
-            return tok;
-        }
+    } else if (!precedes(startToken, endToken)) {
+        return tok;
+    } else if (findExpressionChanged(varTok, startToken, endToken, settings)) {
+        return tok;
     }
     return varTok;
 }
@@ -458,127 +1255,496 @@ static void followVariableExpressionError(const Token *tok1, const Token *tok2,
     if (!tok2)
         return;
     ErrorPathItem item = std::make_pair(tok2, "'" + tok1->str() + "' is assigned value '" + tok2->expressionString() + "' here.");
-    if (std::find(errors->begin(), errors->end(), item) != errors->end())
+    if (std::find(errors->cbegin(), errors->cend(), item) != errors->cend())
         return;
-    errors->push_back(item);
+    errors->push_back(std::move(item));
+}
+
+static SmallVector<ReferenceToken> followAllReferencesInternal(const Token* tok,
+                                                               bool temporary = true,
+                                                               bool inconclusive = true,
+                                                               ErrorPath errors = ErrorPath{},
+                                                               int depth = 20)
+{
+    struct ReferenceTokenLess {
+        bool operator()(const ReferenceToken& x, const ReferenceToken& y) const {
+            return x.token < y.token;
+        }
+    };
+    if (!tok)
+        return {};
+    if (depth < 0) {
+        SmallVector<ReferenceToken> refs_result;
+        refs_result.emplace_back(tok, std::move(errors));
+        return refs_result;
+    }
+    const Variable *var = tok->variable();
+    if (var && var->declarationId() == tok->varId()) {
+        if (var->nameToken() == tok || isStructuredBindingVariable(var)) {
+            SmallVector<ReferenceToken> refs_result;
+            refs_result.emplace_back(tok, std::move(errors));
+            return refs_result;
+        }
+        if (var->isReference() || var->isRValueReference()) {
+            const Token * const varDeclEndToken = var->declEndToken();
+            if (!varDeclEndToken) {
+                SmallVector<ReferenceToken> refs_result;
+                refs_result.emplace_back(tok, std::move(errors));
+                return refs_result;
+            }
+            if (var->isArgument()) {
+                errors.emplace_back(varDeclEndToken, "Passed to reference.");
+                SmallVector<ReferenceToken> refs_result;
+                refs_result.emplace_back(tok, std::move(errors));
+                return refs_result;
+            }
+            if (Token::simpleMatch(varDeclEndToken, "=")) {
+                if (astHasToken(varDeclEndToken, tok))
+                    return {};
+                errors.emplace_back(varDeclEndToken, "Assigned to reference.");
+                const Token *vartok = varDeclEndToken->astOperand2();
+                if (vartok == tok || (!temporary && isTemporary(vartok, nullptr, true) &&
+                                      (var->isConst() || var->isRValueReference()))) {
+                    SmallVector<ReferenceToken> refs_result;
+                    refs_result.emplace_back(tok, std::move(errors));
+                    return refs_result;
+                }
+                if (vartok)
+                    return followAllReferencesInternal(vartok, temporary, inconclusive, std::move(errors), depth - 1);
+            }
+        }
+    } else if (Token::simpleMatch(tok, "?") && Token::simpleMatch(tok->astOperand2(), ":")) {
+        std::set<ReferenceToken, ReferenceTokenLess> result;
+        const Token* tok2 = tok->astOperand2();
+
+        auto refs = followAllReferencesInternal(tok2->astOperand1(), temporary, inconclusive, errors, depth - 1);
+        result.insert(refs.cbegin(), refs.cend());
+        refs = followAllReferencesInternal(tok2->astOperand2(), temporary, inconclusive, errors, depth - 1);
+        result.insert(refs.cbegin(), refs.cend());
+
+        if (!inconclusive && result.size() != 1) {
+            SmallVector<ReferenceToken> refs_result;
+            refs_result.emplace_back(tok, std::move(errors));
+            return refs_result;
+        }
+
+        if (!result.empty()) {
+            SmallVector<ReferenceToken> refs_result;
+            refs_result.insert(refs_result.end(), result.cbegin(), result.cend());
+            return refs_result;
+        }
+
+    } else if (tok->previous() && tok->previous()->function() && Token::Match(tok->previous(), "%name% (")) {
+        const Function *f = tok->previous()->function();
+        if (!Function::returnsReference(f)) {
+            SmallVector<ReferenceToken> refs_result;
+            refs_result.emplace_back(tok, std::move(errors));
+            return refs_result;
+        }
+        std::set<ReferenceToken, ReferenceTokenLess> result;
+        std::vector<const Token*> returns = Function::findReturns(f);
+        for (const Token* returnTok : returns) {
+            if (returnTok == tok)
+                continue;
+            for (const ReferenceToken& rt :
+                 followAllReferencesInternal(returnTok, temporary, inconclusive, errors, depth - returns.size())) {
+                const Variable* argvar = rt.token->variable();
+                if (!argvar) {
+                    SmallVector<ReferenceToken> refs_result;
+                    refs_result.emplace_back(tok, std::move(errors));
+                    return refs_result;
+                }
+                if (argvar->isArgument() && (argvar->isReference() || argvar->isRValueReference())) {
+                    const int n = getArgumentPos(argvar, f);
+                    if (n < 0) {
+                        SmallVector<ReferenceToken> refs_result;
+                        refs_result.emplace_back(tok, std::move(errors));
+                        return refs_result;
+                    }
+                    std::vector<const Token*> args = getArguments(tok->previous());
+                    if (n >= args.size()) {
+                        SmallVector<ReferenceToken> refs_result;
+                        refs_result.emplace_back(tok, std::move(errors));
+                        return refs_result;
+                    }
+                    const Token* argTok = args[n];
+                    ErrorPath er = errors;
+                    er.emplace_back(returnTok, "Return reference.");
+                    er.emplace_back(tok->previous(), "Called function passing '" + argTok->expressionString() + "'.");
+                    auto refs =
+                        followAllReferencesInternal(argTok, temporary, inconclusive, std::move(er), depth - returns.size());
+                    result.insert(refs.cbegin(), refs.cend());
+                    if (!inconclusive && result.size() > 1) {
+                        SmallVector<ReferenceToken> refs_result;
+                        refs_result.emplace_back(tok, std::move(errors));
+                        return refs_result;
+                    }
+                }
+            }
+        }
+        if (!result.empty()) {
+            SmallVector<ReferenceToken> refs_result;
+            refs_result.insert(refs_result.end(), result.cbegin(), result.cend());
+            return refs_result;
+        }
+    }
+    SmallVector<ReferenceToken> refs_result;
+    refs_result.emplace_back(tok, std::move(errors));
+    return refs_result;
+}
+
+SmallVector<ReferenceToken> followAllReferences(const Token* tok, bool temporary)
+{
+    return followAllReferencesInternal(tok, temporary);
+}
+
+const Token* followReferences(const Token* tok, ErrorPath* errors)
+{
+    if (!tok)
+        return nullptr;
+    auto refs = followAllReferencesInternal(tok, true, false);
+    if (refs.size() == 1) {
+        if (errors)
+            *errors = std::move(refs.front().errors);
+        return refs.front().token;
+    }
+    return nullptr;
+}
+
+static bool isSameLifetime(const Token * const tok1, const Token * const tok2)
+{
+    ValueFlow::Value v1 = ValueFlow::getLifetimeObjValue(tok1);
+    if (!v1.isLifetimeValue())
+        return false;
+    ValueFlow::Value v2 = ValueFlow::getLifetimeObjValue(tok2);
+    if (!v2.isLifetimeValue())
+        return false;
+    return v1.tokvalue == v2.tokvalue;
 }
 
-template<class Predicate, class F>
-static void findTokenValue(const Token* const tok, Predicate pred, F f)
+static bool compareKnownValue(const Token * const tok1, const Token * const tok2, const std::function<bool(const ValueFlow::Value&, const ValueFlow::Value&, bool)> &compare)
 {
-    auto x = std::find_if(tok->values().begin(), tok->values().end(), pred);
-    if (x != tok->values().end())
-        f(*x);
+    static const auto isKnownFn = std::mem_fn(&ValueFlow::Value::isKnown);
+
+    const auto v1 = std::find_if(tok1->values().cbegin(), tok1->values().cend(), isKnownFn);
+    if (v1 == tok1->values().end()) {
+        return false;
+    }
+    if (v1->isNonValue() || v1->isContainerSizeValue() || v1->isBufferSizeValue() || v1->isSymbolicValue())
+        return false;
+    const auto v2 = std::find_if(tok2->values().cbegin(), tok2->values().cend(), isKnownFn);
+    if (v2 == tok2->values().end()) {
+        return false;
+    }
+    if (v1->valueType != v2->valueType) {
+        return false;
+    }
+    const bool sameLifetime = isSameLifetime(tok1, tok2);
+    return compare(*v1, *v2, sameLifetime);
 }
 
 bool isEqualKnownValue(const Token * const tok1, const Token * const tok2)
 {
-    bool result = false;
-    findTokenValue(tok1, std::mem_fn(&ValueFlow::Value::isKnown), [&](const ValueFlow::Value& v1) {
-        findTokenValue(tok2, std::mem_fn(&ValueFlow::Value::isKnown), [&](const ValueFlow::Value& v2) {
-            result = v1.equalValue(v2);
-        });
+    return compareKnownValue(tok1, tok2, [&](const ValueFlow::Value& v1, const ValueFlow::Value& v2, bool sameLifetime) {
+        bool r = v1.equalValue(v2);
+        if (v1.isIteratorValue()) {
+            r &= sameLifetime;
+        }
+        return r;
     });
-    return result;
 }
 
-bool isDifferentKnownValues(const Token * const tok1, const Token * const tok2)
+static inline bool isDifferentKnownValues(const Token * const tok1, const Token * const tok2)
 {
-    bool result = false;
-    findTokenValue(tok1, std::mem_fn(&ValueFlow::Value::isKnown), [&](const ValueFlow::Value& v1) {
-        findTokenValue(tok2, std::mem_fn(&ValueFlow::Value::isKnown), [&](const ValueFlow::Value& v2) {
-            result = !v1.equalValue(v2);
-        });
+    return compareKnownValue(tok1, tok2, [&](const ValueFlow::Value& v1, const ValueFlow::Value& v2, bool sameLifetime) {
+        bool r = v1.equalValue(v2);
+        if (v1.isIteratorValue()) {
+            r &= sameLifetime;
+        }
+        return !r;
     });
-    return result;
 }
 
-bool isSameExpression(bool cpp, bool macro, const Token *tok1, const Token *tok2, const Library& library, bool pure, bool followVar, ErrorPath* errors)
+static inline bool isSameConstantValue(bool macro, const Token* tok1, const Token* tok2)
+{
+    if (tok1 == nullptr || tok2 == nullptr)
+        return false;
+
+    auto adjustForCast = [](const Token* tok) {
+        if (tok->astOperand2() && Token::Match(tok->previous(), "%type% (|{") && tok->previous()->isStandardType())
+            return tok->astOperand2();
+        return tok;
+    };
+
+    tok1 = adjustForCast(tok1);
+    if (!tok1->isNumber() && !tok1->enumerator())
+        return false;
+    tok2 = adjustForCast(tok2);
+    if (!tok2->isNumber() && !tok2->enumerator())
+        return false;
+
+    if (macro && (tok1->isExpandedMacro() || tok2->isExpandedMacro() || tok1->isTemplateArg() || tok2->isTemplateArg()))
+        return false;
+
+    const ValueType * v1 = tok1->valueType();
+    const ValueType * v2 = tok2->valueType();
+
+    if (!v1 || !v2 || v1->sign != v2->sign || v1->type != v2->type || v1->pointer != v2->pointer)
+        return false;
+
+    return isEqualKnownValue(tok1, tok2);
+}
+
+
+static bool isForLoopCondition(const Token * const tok)
+{
+    if (!tok)
+        return false;
+    const Token *const parent = tok->astParent();
+    return Token::simpleMatch(parent, ";") && parent->astOperand1() == tok &&
+           Token::simpleMatch(parent->astParent(), ";") &&
+           Token::simpleMatch(parent->astParent()->astParent(), "(") &&
+           parent->astParent()->astParent()->astOperand1()->str() == "for";
+}
+
+static bool isForLoopIncrement(const Token* const tok)
+{
+    if (!tok)
+        return false;
+    const Token *const parent = tok->astParent();
+    return Token::simpleMatch(parent, ";") && parent->astOperand2() == tok &&
+           Token::simpleMatch(parent->astParent(), ";") &&
+           Token::simpleMatch(parent->astParent()->astParent(), "(") &&
+           parent->astParent()->astParent()->astOperand1()->str() == "for";
+}
+
+bool isUsedAsBool(const Token* const tok, const Settings& settings)
+{
+    if (!tok)
+        return false;
+    if (isForLoopIncrement(tok))
+        return false;
+    if (astIsBool(tok))
+        return true;
+    if (Token::Match(tok, "!|&&|%oror%|%comp%"))
+        return true;
+    const Token* parent = tok->astParent();
+    if (!parent)
+        return false;
+    if (Token::simpleMatch(parent, "["))
+        return false;
+    if (parent->isUnaryOp("*"))
+        return false;
+    if (Token::simpleMatch(parent, ".")) {
+        if (astIsRHS(tok))
+            return isUsedAsBool(parent, settings);
+        return false;
+    }
+    if (Token::Match(parent, "&&|!|%oror%"))
+        return true;
+    if (parent->isCast())
+        return !Token::simpleMatch(parent->astOperand1(), "dynamic_cast") && isUsedAsBool(parent, settings);
+    if (parent->isUnaryOp("*"))
+        return isUsedAsBool(parent, settings);
+    if (Token::Match(parent, "==|!=") && tok->valueType() && tok->valueType()->pointer &&
+        tok->astSibling()->hasKnownIntValue() && tok->astSibling()->getKnownIntValue() == 0)
+        return true;
+    if (parent->str() == "(" && astIsRHS(tok) && Token::Match(parent->astOperand1(), "if|while"))
+        return true;
+    if (Token::simpleMatch(parent, "?") && astIsLHS(tok))
+        return true;
+    if (isForLoopCondition(tok))
+        return true;
+    if (!Token::Match(parent, "%cop%") && !(parent->str() == "(" && tok == parent->astOperand1())) {
+        if (parent->str() == "," && parent->isInitComma())
+            return false;
+        std::vector<ValueType> vtParents = getParentValueTypes(tok, settings);
+        return std::any_of(vtParents.cbegin(), vtParents.cend(), [&](const ValueType& vt) {
+            return vt.pointer == 0 && vt.type == ValueType::BOOL;
+        });
+    }
+    return false;
+}
+
+bool compareTokenFlags(const Token* tok1, const Token* tok2, bool macro) {
+    if (macro) {
+        if (tok1->isExpandedMacro() != tok2->isExpandedMacro())
+            return false;
+        if (tok1->isExpandedMacro()) { // both are macros
+            if (tok1->getMacroName() != tok2->getMacroName())
+                return false;
+            if (tok1->astParent() && tok2->astParent() && tok1->astParent()->isExpandedMacro() && tok1->astParent()->getMacroName() == tok2->astParent()->getMacroName())
+                return false;
+        }
+        if (tok1->isTemplateArg() || tok2->isTemplateArg())
+            return false;
+    }
+    if (tok1->isComplex() != tok2->isComplex())
+        return false;
+    if (tok1->isLong() != tok2->isLong())
+        return false;
+    if (tok1->isUnsigned() != tok2->isUnsigned())
+        return false;
+    if (tok1->isSigned() != tok2->isSigned())
+        return false;
+    return true;
+}
+
+static bool astIsBoolLike(const Token* tok, const Settings& settings)
+{
+    return astIsBool(tok) || isUsedAsBool(tok, settings);
+}
+
+bool isSameExpression(bool macro, const Token *tok1, const Token *tok2, const Settings& settings, bool pure, bool followVar, ErrorPath* errors)
 {
-    if (tok1 == nullptr && tok2 == nullptr)
+    if (tok1 == tok2)
         return true;
     if (tok1 == nullptr || tok2 == nullptr)
         return false;
-    if (cpp) {
+    // tokens needs to be from the same TokenList so no need check standard on both of them
+    if (tok1->isCpp()) {
         if (tok1->str() == "." && tok1->astOperand1() && tok1->astOperand1()->str() == "this")
             tok1 = tok1->astOperand2();
         if (tok2->str() == "." && tok2->astOperand1() && tok2->astOperand1()->str() == "this")
             tok2 = tok2->astOperand2();
     }
     // Skip double not
-    if (Token::simpleMatch(tok1, "!") && Token::simpleMatch(tok1->astOperand1(), "!") && !Token::simpleMatch(tok1->astParent(), "=")) {
-        return isSameExpression(cpp, macro, tok1->astOperand1()->astOperand1(), tok2, library, pure, followVar, errors);
+    if (Token::simpleMatch(tok1, "!") && Token::simpleMatch(tok1->astOperand1(), "!") && !Token::simpleMatch(tok1->astParent(), "=") && astIsBoolLike(tok2, settings)) {
+        return isSameExpression(macro, tok1->astOperand1()->astOperand1(), tok2, settings, pure, followVar, errors);
     }
-    if (Token::simpleMatch(tok2, "!") && Token::simpleMatch(tok2->astOperand1(), "!") && !Token::simpleMatch(tok2->astParent(), "=")) {
-        return isSameExpression(cpp, macro, tok1, tok2->astOperand1()->astOperand1(), library, pure, followVar, errors);
+    if (Token::simpleMatch(tok2, "!") && Token::simpleMatch(tok2->astOperand1(), "!") && !Token::simpleMatch(tok2->astParent(), "=") && astIsBoolLike(tok1, settings)) {
+        return isSameExpression(macro, tok1, tok2->astOperand1()->astOperand1(), settings, pure, followVar, errors);
     }
-    if (tok1->str() != tok2->str() && isDifferentKnownValues(tok1, tok2))
+    const bool tok_str_eq = tok1->str() == tok2->str();
+    if (!tok_str_eq && isDifferentKnownValues(tok1, tok2))
         return false;
+
+    const Token *followTok1 = tok1, *followTok2 = tok2;
+    while (Token::simpleMatch(followTok1, "::"))
+        followTok1 = followTok1->astOperand2() ? followTok1->astOperand2() : followTok1->astOperand1();
+    if (!followTok1)
+        followTok1 = tok1; // TODO: remove after #14235 has been fixed
+    while (Token::simpleMatch(followTok2, "::"))
+        followTok2 = followTok2->astOperand2() ? followTok2->astOperand2() : followTok2->astOperand1();
+    if (!followTok2)
+        followTok2 = tok2;
+    if (isSameConstantValue(macro, followTok1, followTok2))
+        return true;
+
     // Follow variable
-    if (followVar && tok1->str() != tok2->str() && (Token::Match(tok1, "%var%") || Token::Match(tok2, "%var%"))) {
-        const Token * varTok1 = followVariableExpression(tok1, cpp, tok2);
-        if (varTok1->str() == tok2->str()) {
-            followVariableExpressionError(tok1, varTok1, errors);
-            return isSameExpression(cpp, macro, varTok1, tok2, library, true, followVar, errors);
+    if (followVar && !tok_str_eq && (followTok1->varId() || followTok2->varId() || followTok1->enumerator() || followTok2->enumerator())) {
+        const Token * varTok1 = followVariableExpression(settings, followTok1, followTok2);
+        if ((varTok1->str() == followTok2->str()) || isSameConstantValue(macro, varTok1, followTok2)) {
+            followVariableExpressionError(followTok1, varTok1, errors);
+            return isSameExpression(macro, varTok1, followTok2, settings, true, followVar, errors);
         }
-        const Token * varTok2 = followVariableExpression(tok2, cpp, tok1);
-        if (tok1->str() == varTok2->str()) {
-            followVariableExpressionError(tok2, varTok2, errors);
-            return isSameExpression(cpp, macro, tok1, varTok2, library, true, followVar, errors);
+        const Token * varTok2 = followVariableExpression(settings, followTok2, followTok1);
+        if ((followTok1->str() == varTok2->str()) || isSameConstantValue(macro, followTok1, varTok2)) {
+            followVariableExpressionError(followTok2, varTok2, errors);
+            return isSameExpression(macro, followTok1, varTok2, settings, true, followVar, errors);
         }
-        if (varTok1->str() == varTok2->str()) {
+        if ((varTok1->str() == varTok2->str()) || isSameConstantValue(macro, varTok1, varTok2)) {
             followVariableExpressionError(tok1, varTok1, errors);
             followVariableExpressionError(tok2, varTok2, errors);
-            return isSameExpression(cpp, macro, varTok1, varTok2, library, true, followVar, errors);
+            return isSameExpression(macro, varTok1, varTok2, settings, true, followVar, errors);
+        }
+    }
+    // Follow references
+    if (!tok_str_eq) {
+        const Token* refTok1 = followReferences(tok1, errors);
+        const Token* refTok2 = followReferences(tok2, errors);
+        if (refTok1 != tok1 || refTok2 != tok2) {
+            if (refTok1 && !refTok1->varId() && refTok2 && !refTok2->varId()) { // complex reference expression
+                const Token *start = refTok1, *end = refTok2;
+                if (!precedes(start, end))
+                    std::swap(start, end);
+                if (findExpressionChanged(start, start, end, settings))
+                    return false;
+            }
+            return isSameExpression(macro, refTok1, refTok2, settings, pure, followVar, errors);
         }
     }
-    if (tok1->varId() != tok2->varId() || tok1->str() != tok2->str() || tok1->originalName() != tok2->originalName()) {
-        if ((Token::Match(tok1,"<|>")   && Token::Match(tok2,"<|>")) ||
+    if (tok1->varId() != tok2->varId() || !tok_str_eq || tok1->originalName() != tok2->originalName()) {
+        if ((Token::Match(tok1,"<|>") && Token::Match(tok2,"<|>")) ||
             (Token::Match(tok1,"<=|>=") && Token::Match(tok2,"<=|>="))) {
-            return isSameExpression(cpp, macro, tok1->astOperand1(), tok2->astOperand2(), library, pure, followVar, errors) &&
-                   isSameExpression(cpp, macro, tok1->astOperand2(), tok2->astOperand1(), library, pure, followVar, errors);
+            return isSameExpression(macro, tok1->astOperand1(), tok2->astOperand2(), settings, pure, followVar, errors) &&
+                   isSameExpression(macro, tok1->astOperand2(), tok2->astOperand1(), settings, pure, followVar, errors);
+        }
+        const Token* condTok = nullptr;
+        const Token* exprTok = nullptr;
+        if (Token::Match(tok1, "==|!=")) {
+            condTok = tok1;
+            exprTok = tok2;
+        } else if (Token::Match(tok2, "==|!=")) {
+            condTok = tok2;
+            exprTok = tok1;
+        }
+        if (condTok && condTok->astOperand1() && condTok->astOperand2() && !Token::Match(exprTok, "%comp%")) {
+            const Token* varTok1 = nullptr;
+            const Token* varTok2 = exprTok;
+            const ValueFlow::Value* value = nullptr;
+            if (const ValueFlow::Value* vi1 = condTok->astOperand1()->getKnownValue(ValueFlow::Value::ValueType::INT)) {
+                value = vi1;
+                varTok1 = condTok->astOperand2();
+            } else if (const ValueFlow::Value* vi2 = condTok->astOperand2()->getKnownValue(ValueFlow::Value::ValueType::INT)) {
+                value = vi2;
+                varTok1 = condTok->astOperand1();
+            }
+            const bool exprIsNot = Token::simpleMatch(exprTok, "!");
+            if (exprIsNot)
+                varTok2 = exprTok->astOperand1();
+            bool compare = false;
+            if (value) {
+                if (value->intvalue == 0 && exprIsNot && Token::simpleMatch(condTok, "==")) {
+                    compare = true;
+                } else if (value->intvalue == 0 && !exprIsNot && Token::simpleMatch(condTok, "!=")) {
+                    compare = true;
+                } else if (value->intvalue != 0 && exprIsNot && Token::simpleMatch(condTok, "!=")) {
+                    compare = true;
+                } else if (value->intvalue != 0 && !exprIsNot && Token::simpleMatch(condTok, "==")) {
+                    compare = true;
+                }
+            }
+            if (compare && astIsBoolLike(varTok1, settings) && astIsBoolLike(varTok2, settings))
+                return isSameExpression(macro, varTok1, varTok2, settings, pure, followVar, errors);
+
         }
         return false;
     }
-    if (macro && (tok1->isExpandedMacro() || tok2->isExpandedMacro() || tok1->isTemplateArg() || tok2->isTemplateArg()))
-        return false;
-    if (tok1->isComplex() != tok2->isComplex())
-        return false;
-    if (tok1->isLong() != tok2->isLong())
-        return false;
-    if (tok1->isUnsigned() != tok2->isUnsigned())
-        return false;
-    if (tok1->isSigned() != tok2->isSigned())
+
+    if (!compareTokenFlags(tok1, tok2, macro))
         return false;
-    if (pure && tok1->isName() && tok1->next()->str() == "(" && tok1->str() != "sizeof") {
+
+    if (pure && tok1->isName() && tok1->strAt(1) == "(" && tok1->str() != "sizeof" && !(tok1->variable() && tok1 == tok1->variable()->nameToken())) {
         if (!tok1->function()) {
             if (Token::simpleMatch(tok1->previous(), ".")) {
                 const Token *lhs = tok1->previous();
                 while (Token::Match(lhs, "(|.|["))
                     lhs = lhs->astOperand1();
+                if (!lhs)
+                    return false;
                 const bool lhsIsConst = (lhs->variable() && lhs->variable()->isConst()) ||
                                         (lhs->valueType() && lhs->valueType()->constness > 0) ||
-                                        (Token::Match(lhs, "%var% . %name% (") && library.isFunctionConst(lhs->tokAt(2)));
+                                        (Token::Match(lhs, "%var% . %name% (") && settings.library.isFunctionConst(lhs->tokAt(2)));
                 if (!lhsIsConst)
                     return false;
             } else {
                 const Token * ftok = tok1;
-                if (Token::simpleMatch(tok1->previous(), "::"))
-                    ftok = tok1->previous();
-                if (!library.isFunctionConst(ftok) && !ftok->isAttributeConst() && !ftok->isAttributePure())
+                if (!settings.library.isFunctionConst(ftok) && !ftok->isAttributeConst() && !ftok->isAttributePure())
                     return false;
             }
         } else {
-            if (tok1->function() && !tok1->function()->isConst() && !tok1->function()->isAttributeConst() && !tok1->function()->isAttributePure())
+            if (!tok1->function()->isConst() && !tok1->function()->isAttributeConst() &&
+                !tok1->function()->isAttributePure())
                 return false;
         }
     }
     // templates/casts
-    if ((Token::Match(tok1, "%name% <") && tok1->next()->link()) ||
-        (Token::Match(tok2, "%name% <") && tok2->next()->link())) {
+    if ((tok1->next() && tok1->linkAt(1) && Token::Match(tok1, "%name% <")) ||
+        (tok2->next() && tok2->linkAt(1) && Token::Match(tok2, "%name% <"))) {
 
         // non-const template function that is not a dynamic_cast => return false
-        if (pure && Token::simpleMatch(tok1->next()->link(), "> (") &&
+        if (pure && Token::simpleMatch(tok1->linkAt(1), "> (") &&
             !(tok1->function() && tok1->function()->isConst()) &&
             tok1->str() != "dynamic_cast")
             return false;
@@ -589,7 +1755,7 @@ bool isSameExpression(bool cpp, bool macro, const Token *tok1, const Token *tok2
         const Token *end1 = t1->link();
         const Token *end2 = t2->link();
         while (t1 && t2 && t1 != end1 && t2 != end2) {
-            if (t1->str() != t2->str())
+            if (t1->str() != t2->str() || !compareTokenFlags(t1, t2, macro))
                 return false;
             t1 = t1->next();
             t2 = t2->next();
@@ -605,14 +1771,12 @@ bool isSameExpression(bool cpp, bool macro, const Token *tok1, const Token *tok2
     // cast => assert that the casts are equal
     if (tok1->str() == "(" && tok1->previous() &&
         !tok1->previous()->isName() &&
-        !(tok1->previous()->str() == ">" && tok1->previous()->link())) {
+        !(tok1->strAt(-1) == ">" && tok1->linkAt(-1))) {
         const Token *t1 = tok1->next();
         const Token *t2 = tok2->next();
         while (t1 && t2 &&
                t1->str() == t2->str() &&
-               t1->isLong() == t2->isLong() &&
-               t1->isUnsigned() == t2->isUnsigned() &&
-               t1->isSigned() == t2->isSigned() &&
+               compareTokenFlags(t1, t2, macro) &&
                (t1->isName() || t1->str() == "*")) {
             t1 = t1->next();
             t2 = t2->next();
@@ -621,15 +1785,15 @@ bool isSameExpression(bool cpp, bool macro, const Token *tok1, const Token *tok2
             return false;
     }
     bool noncommutativeEquals =
-        isSameExpression(cpp, macro, tok1->astOperand1(), tok2->astOperand1(), library, pure, followVar, errors);
+        isSameExpression(macro, tok1->astOperand1(), tok2->astOperand1(), settings, pure, followVar, errors);
     noncommutativeEquals = noncommutativeEquals &&
-                           isSameExpression(cpp, macro, tok1->astOperand2(), tok2->astOperand2(), library, pure, followVar, errors);
+                           isSameExpression(macro, tok1->astOperand2(), tok2->astOperand2(), settings, pure, followVar, errors);
 
     if (noncommutativeEquals)
         return true;
 
     // in c++, a+b might be different to b+a, depending on the type of a and b
-    if (cpp && tok1->str() == "+" && tok1->isBinaryOp()) {
+    if (tok1->isCpp() && tok1->str() == "+" && tok1->isBinaryOp()) {
         const ValueType* vt1 = tok1->astOperand1()->valueType();
         const ValueType* vt2 = tok1->astOperand2()->valueType();
         if (!(vt1 && (vt1->type >= ValueType::VOID || vt1->pointer) && vt2 && (vt2->type >= ValueType::VOID || vt2->pointer)))
@@ -638,9 +1802,9 @@ bool isSameExpression(bool cpp, bool macro, const Token *tok1, const Token *tok2
 
     const bool commutative = tok1->isBinaryOp() && Token::Match(tok1, "%or%|%oror%|+|*|&|&&|^|==|!=");
     bool commutativeEquals = commutative &&
-                             isSameExpression(cpp, macro, tok1->astOperand2(), tok2->astOperand1(), library, pure, followVar, errors);
+                             isSameExpression(macro, tok1->astOperand2(), tok2->astOperand1(), settings, pure, followVar, errors);
     commutativeEquals = commutativeEquals &&
-                        isSameExpression(cpp, macro, tok1->astOperand1(), tok2->astOperand2(), library, pure, followVar, errors);
+                        isSameExpression(macro, tok1->astOperand1(), tok2->astOperand2(), settings, pure, followVar, errors);
 
 
     return commutativeEquals;
@@ -664,41 +1828,88 @@ static bool isZeroBoundCond(const Token * const cond)
     return false;
 }
 
-bool isOppositeCond(bool isNot, bool cpp, const Token * const cond1, const Token * const cond2, const Library& library, bool pure, bool followVar, ErrorPath* errors)
+bool isOppositeCond(bool isNot, const Token * const cond1, const Token * const cond2, const Settings& settings, bool pure, bool followVar, ErrorPath* errors)
 {
     if (!cond1 || !cond2)
         return false;
 
+    if (isSameExpression(true, cond1, cond2, settings, pure, followVar, errors))
+        return false;
+
+    if (!isNot && cond1->str() == "&&" && cond2->str() == "&&") {
+        for (const Token* tok1: {
+            cond1->astOperand1(), cond1->astOperand2()
+        }) {
+            for (const Token* tok2: {
+                cond2->astOperand1(), cond2->astOperand2()
+            }) {
+                if (isSameExpression(true, tok1, tok2, settings, pure, followVar, errors)) {
+                    if (isOppositeCond(isNot, tok1->astSibling(), tok2->astSibling(), settings, pure, followVar, errors))
+                        return true;
+                }
+            }
+        }
+    }
+
+    if (cond1->str() != cond2->str() && (cond1->str() == "||" || cond2->str() == "||")) {
+        const Token* orCond = nullptr;
+        const Token* otherCond = nullptr;
+        if (cond1->str() == "||") {
+            orCond = cond1;
+            otherCond = cond2;
+        }
+        if (cond2->str() == "||") {
+            orCond = cond2;
+            otherCond = cond1;
+        }
+        return isOppositeCond(isNot, orCond->astOperand1(), otherCond, settings, pure, followVar, errors) &&
+               isOppositeCond(isNot, orCond->astOperand2(), otherCond, settings, pure, followVar, errors);
+    }
+
     if (cond1->str() == "!") {
         if (cond2->str() == "!=") {
             if (cond2->astOperand1() && cond2->astOperand1()->str() == "0")
-                return isSameExpression(cpp, true, cond1->astOperand1(), cond2->astOperand2(), library, pure, followVar, errors);
+                return isSameExpression(true, cond1->astOperand1(), cond2->astOperand2(), settings, pure, followVar, errors);
             if (cond2->astOperand2() && cond2->astOperand2()->str() == "0")
-                return isSameExpression(cpp, true, cond1->astOperand1(), cond2->astOperand1(), library, pure, followVar, errors);
+                return isSameExpression(true, cond1->astOperand1(), cond2->astOperand1(), settings, pure, followVar, errors);
         }
-        return isSameExpression(cpp, true, cond1->astOperand1(), cond2, library, pure, followVar, errors);
+        if (!isUsedAsBool(cond2, settings))
+            return false;
+        return isSameExpression(true, cond1->astOperand1(), cond2, settings, pure, followVar, errors);
     }
 
     if (cond2->str() == "!")
-        return isOppositeCond(isNot, cpp, cond2, cond1, library, pure, followVar, errors);
+        return isOppositeCond(isNot, cond2, cond1, settings, pure, followVar, errors);
 
     if (!isNot) {
         if (cond1->str() == "==" && cond2->str() == "==") {
-            if (isSameExpression(cpp, true, cond1->astOperand1(), cond2->astOperand1(), library, pure, followVar, errors))
+            if (isSameExpression(true, cond1->astOperand1(), cond2->astOperand1(), settings, pure, followVar, errors))
                 return isDifferentKnownValues(cond1->astOperand2(), cond2->astOperand2());
-            if (isSameExpression(cpp, true, cond1->astOperand2(), cond2->astOperand2(), library, pure, followVar, errors))
+            if (isSameExpression(true, cond1->astOperand2(), cond2->astOperand2(), settings, pure, followVar, errors))
                 return isDifferentKnownValues(cond1->astOperand1(), cond2->astOperand1());
         }
         // TODO: Handle reverse conditions
         if (Library::isContainerYield(cond1, Library::Container::Yield::EMPTY, "empty") &&
             Library::isContainerYield(cond2->astOperand1(), Library::Container::Yield::SIZE, "size") &&
-            cond1->astOperand1()->astOperand1()->varId() == cond2->astOperand1()->astOperand1()->astOperand1()->varId()) {
+            isSameExpression(true,
+                             cond1->astOperand1()->astOperand1(),
+                             cond2->astOperand1()->astOperand1()->astOperand1(),
+                             settings,
+                             pure,
+                             followVar,
+                             errors)) {
             return !isZeroBoundCond(cond2);
         }
 
         if (Library::isContainerYield(cond2, Library::Container::Yield::EMPTY, "empty") &&
             Library::isContainerYield(cond1->astOperand1(), Library::Container::Yield::SIZE, "size") &&
-            cond2->astOperand1()->astOperand1()->varId() == cond1->astOperand1()->astOperand1()->astOperand1()->varId()) {
+            isSameExpression(true,
+                             cond2->astOperand1()->astOperand1(),
+                             cond1->astOperand1()->astOperand1()->astOperand1(),
+                             settings,
+                             pure,
+                             followVar,
+                             errors)) {
             return !isZeroBoundCond(cond1);
         }
     }
@@ -711,11 +1922,11 @@ bool isOppositeCond(bool isNot, bool cpp, const Token * const cond1, const Token
 
     // condition found .. get comparator
     std::string comp2;
-    if (isSameExpression(cpp, true, cond1->astOperand1(), cond2->astOperand1(), library, pure, followVar, errors) &&
-        isSameExpression(cpp, true, cond1->astOperand2(), cond2->astOperand2(), library, pure, followVar, errors)) {
+    if (isSameExpression(true, cond1->astOperand1(), cond2->astOperand1(), settings, pure, followVar, errors) &&
+        isSameExpression(true, cond1->astOperand2(), cond2->astOperand2(), settings, pure, followVar, errors)) {
         comp2 = cond2->str();
-    } else if (isSameExpression(cpp, true, cond1->astOperand1(), cond2->astOperand2(), library, pure, followVar, errors) &&
-               isSameExpression(cpp, true, cond1->astOperand2(), cond2->astOperand1(), library, pure, followVar, errors)) {
+    } else if (isSameExpression(true, cond1->astOperand1(), cond2->astOperand2(), settings, pure, followVar, errors) &&
+               isSameExpression(true, cond1->astOperand2(), cond2->astOperand1(), settings, pure, followVar, errors)) {
         comp2 = cond2->str();
         if (comp2[0] == '>')
             comp2[0] = '<';
@@ -751,7 +1962,7 @@ bool isOppositeCond(bool isNot, bool cpp, const Token * const cond1, const Token
         if (!expr1 || !value1 || !expr2 || !value2) {
             return false;
         }
-        if (!isSameExpression(cpp, true, expr1, expr2, library, pure, followVar, errors))
+        if (!isSameExpression(true, expr1, expr2, settings, pure, followVar, errors))
             return false;
 
         const ValueFlow::Value &rhsValue1 = value1->values().front();
@@ -759,7 +1970,7 @@ bool isOppositeCond(bool isNot, bool cpp, const Token * const cond1, const Token
 
         if (op1 == "<" || op1 == "<=")
             return (op2 == "==" || op2 == ">" || op2 == ">=") && (rhsValue1.intvalue < rhsValue2.intvalue);
-        else if (op1 == ">=" || op1 == ">")
+        if (op1 == ">=" || op1 == ">")
             return (op2 == "==" || op2 == "<" || op2 == "<=") && (rhsValue1.intvalue > rhsValue2.intvalue);
 
         return false;
@@ -768,62 +1979,151 @@ bool isOppositeCond(bool isNot, bool cpp, const Token * const cond1, const Token
     // is condition opposite?
     return ((comp1 == "==" && comp2 == "!=") ||
             (comp1 == "!=" && comp2 == "==") ||
-            (comp1 == "<"  && comp2 == ">=") ||
+            (comp1 == "<" && comp2 == ">=") ||
             (comp1 == "<=" && comp2 == ">") ||
-            (comp1 == ">"  && comp2 == "<=") ||
+            (comp1 == ">" && comp2 == "<=") ||
             (comp1 == ">=" && comp2 == "<") ||
             (!isNot && ((comp1 == "<" && comp2 == ">") ||
                         (comp1 == ">" && comp2 == "<") ||
                         (comp1 == "==" && (comp2 == "!=" || comp2 == ">" || comp2 == "<")) ||
                         ((comp1 == "!=" || comp1 == ">" || comp1 == "<") && comp2 == "==")
-                       )));
+                        )));
 }
 
-bool isOppositeExpression(bool cpp, const Token * const tok1, const Token * const tok2, const Library& library, bool pure, bool followVar, ErrorPath* errors)
+bool isOppositeExpression(const Token * const tok1, const Token * const tok2, const Settings& settings, bool pure, bool followVar, ErrorPath* errors)
 {
     if (!tok1 || !tok2)
         return false;
-    if (isOppositeCond(true, cpp, tok1, tok2, library, pure, followVar, errors))
+    if (isOppositeCond(true, tok1, tok2, settings, pure, followVar, errors))
         return true;
-    if (tok1->isUnaryOp("-"))
-        return isSameExpression(cpp, true, tok1->astOperand1(), tok2, library, pure, followVar, errors);
-    if (tok2->isUnaryOp("-"))
-        return isSameExpression(cpp, true, tok2->astOperand1(), tok1, library, pure, followVar, errors);
+    if (tok1->isUnaryOp("-") && !(tok2->astParent() && tok2->astParent()->tokType() == Token::eBitOp))
+        return isSameExpression(true, tok1->astOperand1(), tok2, settings, pure, followVar, errors);
+    if (tok2->isUnaryOp("-") && !(tok2->astParent() && tok2->astParent()->tokType() == Token::eBitOp))
+        return isSameExpression(true, tok2->astOperand1(), tok1, settings, pure, followVar, errors);
     return false;
 }
 
-bool isConstExpression(const Token *tok, const Library& library, bool pure, bool cpp)
+static bool functionModifiesArguments(const Function* f)
 {
-    if (!tok)
+    return std::any_of(f->argumentList.cbegin(), f->argumentList.cend(), [](const Variable& var) {
+        return var.isReference() && !var.isConst();
+    });
+}
+
+bool isConstFunctionCall(const Token* ftok, const Library& library)
+{
+    if (isUnevaluated(ftok))
         return true;
-    if (tok->isName() && tok->next()->str() == "(") {
-        if (!tok->function() && !Token::Match(tok->previous(), ".|::") && !library.isFunctionConst(tok->str(), pure))
+    if (!Token::Match(ftok, "%name% ("))
+        return false;
+    if (const Function* f = ftok->function()) {
+        if (f->isAttributePure() || f->isAttributeConst())
+            return true;
+        // Any modified arguments
+        if (functionModifiesArguments(f))
+            return false;
+        if (Function::returnsVoid(f))
+            return false;
+        // Member function call
+        if (Token::simpleMatch(ftok->previous(), ".") || exprDependsOnThis(ftok->next())) {
+            if (f->isConst())
+                return true;
+            // Check for const overloaded function that just return the const version
+            if (!Function::returnsConst(f)) {
+                std::vector<const Function*> fs = f->getOverloadedFunctions();
+                if (std::any_of(fs.cbegin(), fs.cend(), [&](const Function* g) {
+                    if (f == g)
+                        return false;
+                    if (f->argumentList.size() != g->argumentList.size())
+                        return false;
+                    if (functionModifiesArguments(g))
+                        return false;
+                    if (g->isConst() && Function::returnsConst(g))
+                        return true;
+                    return false;
+                }))
+                    return true;
+            }
+            return false;
+        }
+        if (f->argumentList.empty())
+            return f->isConstexpr();
+    } else if (Token::Match(ftok->previous(), ". %name% (") && ftok->previous()->originalName() != "->" &&
+               astIsSmartPointer(ftok->previous()->astOperand1())) {
+        return Token::Match(ftok, "get|get_deleter ( )");
+    } else if (Token::Match(ftok->previous(), ". %name% (") && astIsContainer(ftok->previous()->astOperand1())) {
+        const Library::Container* container = ftok->previous()->astOperand1()->valueType()->container;
+        if (!container)
+            return false;
+        if (container->getYield(ftok->str()) != Library::Container::Yield::NO_YIELD)
+            return true;
+        if (container->getAction(ftok->str()) == Library::Container::Action::FIND_CONST)
+            return true;
+        return false;
+    } else if (const Library::Function* lf = library.getFunction(ftok)) {
+        if (lf->ispure)
+            return true;
+        if (lf->containerYield != Library::Container::Yield::NO_YIELD)
+            return true;
+        if (lf->containerAction == Library::Container::Action::FIND_CONST)
+            return true;
+        return false;
+    } else {
+        const bool memberFunction = Token::Match(ftok->previous(), ". %name% (");
+        bool constMember = !memberFunction;
+        if (Token::Match(ftok->tokAt(-2), "%var% . %name% (")) {
+            const Variable* var = ftok->tokAt(-2)->variable();
+            if (var)
+                constMember = var->isConst();
+        }
+        // TODO: Only check const on lvalues
+        std::vector<const Token*> args = getArguments(ftok);
+        if (args.empty())
             return false;
-        else if (tok->function() && !tok->function()->isConst())
+        return constMember && std::all_of(args.cbegin(), args.cend(), [](const Token* tok) {
+            const Variable* var = tok->variable();
+            if (var)
+                return var->isConst();
+            return false;
+        });
+    }
+    return false;
+}
+
+bool isConstExpression(const Token *tok, const Library& library)
+{
+    if (!tok)
+        return true;
+    if (tok->variable() && tok->variable()->isVolatile())
+        return false;
+    if (tok->isName() && tok->strAt(1) == "(") {
+        if (!isConstFunctionCall(tok, library))
             return false;
     }
     if (tok->tokType() == Token::eIncDecOp)
         return false;
     if (tok->isAssignmentOp())
         return false;
-    if (isLikelyStreamRead(cpp, tok))
+    if (isLikelyStreamRead(tok))
         return false;
     // bailout when we see ({..})
     if (tok->str() == "{")
         return false;
-    return isConstExpression(tok->astOperand1(), library, pure, cpp) && isConstExpression(tok->astOperand2(), library, pure, cpp);
+    return isConstExpression(tok->astOperand1(), library) && isConstExpression(tok->astOperand2(), library);
 }
 
-bool isWithoutSideEffects(bool cpp, const Token* tok)
+bool isWithoutSideEffects(const Token* tok, bool checkArrayAccess, bool checkReference)
 {
-    if (!cpp)
+    if (!tok)
+        return true;
+    if (!tok->isCpp())
         return true;
 
     while (tok && tok->astOperand2() && tok->astOperand2()->str() != "(")
         tok = tok->astOperand2();
     if (tok && tok->varId()) {
         const Variable* var = tok->variable();
-        return var && (!var->isClass() || var->isPointer() || var->isStlType());
+        return var && ((!var->isClass() && (checkReference || !var->isReference())) || var->isPointer() || (checkArrayAccess ? var->isStlType() && !var->isStlType(CheckClass::stl_containers_not_const) : var->isStlType()));
     }
     return true;
 }
@@ -838,17 +2138,14 @@ bool isUniqueExpression(const Token* tok)
         if (!scope)
             return true;
         const std::string returnType = fun->retType ? fun->retType->name() : fun->retDef->stringifyList(fun->tokenDef);
-        for (const Function& f:scope->functionList) {
-            if (f.type != Function::eFunction)
-                continue;
+        if (!std::all_of(scope->functionList.begin(), scope->functionList.end(), [&](const Function& f) {
+            if (f.type != FunctionType::eFunction)
+                return true;
 
-            const std::string freturnType = f.retType ? f.retType->name() : f.retDef->stringifyList(f.tokenDef);
-            if (f.argumentList.size() == fun->argumentList.size() &&
-                returnType == freturnType &&
-                f.name() != fun->name()) {
-                return false;
-            }
-        }
+            const std::string freturnType = f.retType ? f.retType->name() : f.retDef->stringifyList(f.returnDefEnd());
+            return f.argumentList.size() != fun->argumentList.size() || returnType != freturnType || f.name() == fun->name();
+        }))
+            return false;
     } else if (tok->variable()) {
         const Variable * var = tok->variable();
         const Scope * scope = var->scope();
@@ -857,22 +2154,21 @@ bool isUniqueExpression(const Token* tok)
         const Type * varType = var->type();
         // Iterate over the variables in scope and the parameters of the function if possible
         const Function * fun = scope->function;
-        const std::list<Variable>* setOfVars[] = {&scope->varlist, fun ? &fun->argumentList : nullptr};
 
-        for (const std::list<Variable>* vars:setOfVars) {
-            if (!vars)
-                continue;
-            bool other = std::any_of(vars->cbegin(), vars->cend(), [=](const Variable &v) {
-                if (varType)
-                    return v.type() && v.type()->name() == varType->name() && v.name() != var->name();
-                return v.isFloatingType() == var->isFloatingType() &&
-                       v.isEnumType() == var->isEnumType() &&
-                       v.isClass() == var->isClass() &&
-                       v.isArray() == var->isArray() &&
-                       v.isPointer() == var->isPointer() &&
-                       v.name() != var->name();
-            });
-            if (other)
+        auto pred = [=](const Variable& v) {
+            if (varType)
+                return v.type() && v.type()->name() == varType->name() && v.name() != var->name();
+            return v.isFloatingType() == var->isFloatingType() &&
+                   v.isEnumType() == var->isEnumType() &&
+                   v.isClass() == var->isClass() &&
+                   v.isArray() == var->isArray() &&
+                   v.isPointer() == var->isPointer() &&
+                   v.name() != var->name();
+        };
+        if (std::any_of(scope->varlist.cbegin(), scope->varlist.cend(), pred))
+            return false;
+        if (fun) {
+            if (std::any_of(fun->argumentList.cbegin(), fun->argumentList.cend(), pred))
                 return false;
         }
     } else if (!isUniqueExpression(tok->astOperand1())) {
@@ -882,23 +2178,72 @@ bool isUniqueExpression(const Token* tok)
     return isUniqueExpression(tok->astOperand2());
 }
 
-static bool isEscaped(const Token* tok, bool functionsScope)
+static bool isEscaped(const Token* tok, bool functionsScope, const Library& library)
 {
+    if (library.isnoreturn(tok))
+        return true;
     if (functionsScope)
         return Token::simpleMatch(tok, "throw");
-    else
-        return Token::Match(tok, "return|throw");
+    return Token::Match(tok, "return|throw");
 }
 
-static bool isEscapedOrJump(const Token* tok, bool functionsScope)
+static bool isEscapedOrJump(const Token* tok, bool functionsScope, const Library& library)
 {
+    if (library.isnoreturn(tok))
+        return true;
     if (functionsScope)
         return Token::simpleMatch(tok, "throw");
-    else
-        return Token::Match(tok, "return|goto|throw|continue|break");
+    return Token::Match(tok, "return|goto|throw|continue|break");
+}
+
+bool isEscapeFunction(const Token* ftok, const Library& library)
+{
+    if (!Token::Match(ftok, "%name% ("))
+        return false;
+    const Function* function = ftok->function();
+    if (function) {
+        if (function->isEscapeFunction())
+            return true;
+        if (function->isAttributeNoreturn())
+            return true;
+    } else {
+        if (library.isnoreturn(ftok))
+            return true;
+    }
+    return false;
+}
+
+static bool hasNoreturnFunction(const Token* tok, const Library& library, const Token** unknownFunc)
+{
+    if (!tok)
+        return false;
+    const Token* ftok = (tok->str() == "(" && !tok->isCast()) ? tok->previous() : nullptr;
+    while (Token::simpleMatch(ftok, "("))
+        ftok = ftok->astOperand1();
+    if (ftok) {
+        const Function * function = ftok->function();
+        if (function) {
+            if (function->isEscapeFunction())
+                return true;
+            if (function->isAttributeNoreturn())
+                return true;
+        } else if (library.isnoreturn(ftok)) {
+            return true;
+        } else if (Token::Match(ftok, "exit|abort")) {
+            return true;
+        }
+        if (unknownFunc && !function && library.functions().count(library.getFunctionName(ftok)) == 0)
+            *unknownFunc = ftok;
+        return false;
+    }
+    if (tok->isConstOp()) {
+        return hasNoreturnFunction(tok->astOperand1(), library, unknownFunc) || hasNoreturnFunction(tok->astOperand2(), library, unknownFunc);
+    }
+
+    return false;
 }
 
-bool isReturnScope(const Token * const endToken, const Settings * settings, bool functionScope)
+bool isReturnScope(const Token* const endToken, const Library& library, const Token** unknownFunc, bool functionScope)
 {
     if (!endToken || endToken->str() != "}")
         return false;
@@ -911,46 +2256,55 @@ bool isReturnScope(const Token * const endToken, const Settings * settings, bool
 
     if (Token::simpleMatch(prev, "}")) {
         if (Token::simpleMatch(prev->link()->tokAt(-2), "} else {"))
-            return isReturnScope(prev, settings, functionScope) && isReturnScope(prev->link()->tokAt(-2), settings, functionScope);
-        if (Token::simpleMatch(prev->link()->previous(), ") {") &&
+            return isReturnScope(prev, library, unknownFunc, functionScope) &&
+                   isReturnScope(prev->link()->tokAt(-2), library, unknownFunc, functionScope);
+        // TODO: Check all cases
+        if (!functionScope && Token::simpleMatch(prev->link()->previous(), ") {") &&
             Token::simpleMatch(prev->link()->linkAt(-1)->previous(), "switch (") &&
             !Token::findsimplematch(prev->link(), "break", prev)) {
-            return true;
+            return isReturnScope(prev, library, unknownFunc, functionScope);
         }
-        if (isEscaped(prev->link()->astTop(), functionScope))
+        if (isEscaped(prev->link()->astTop(), functionScope, library))
             return true;
         if (Token::Match(prev->link()->previous(), "[;{}] {"))
-            return isReturnScope(prev, settings, functionScope);
+            return isReturnScope(prev, library, unknownFunc, functionScope);
     } else if (Token::simpleMatch(prev, ";")) {
-        if (Token::simpleMatch(prev->previous(), ") ;") && Token::Match(prev->linkAt(-1)->tokAt(-2), "[;{}] %name% (")) {
-            const Token * ftok = prev->linkAt(-1)->previous();
-            const Function * function = ftok->function();
-            if (function) {
-                if (function->isEscapeFunction())
-                    return true;
-                if (function->isAttributeNoreturn())
-                    return true;
-            } else if (settings) {
-                if (settings->library.isnoreturn(ftok))
-                    return true;
-            }
+        if (prev->tokAt(-2) && hasNoreturnFunction(prev->tokAt(-2)->astTop(), library, unknownFunc))
+            return true;
+        // Unknown symbol
+        if (Token::Match(prev->tokAt(-2), ";|}|{ %name% ;") && prev->previous()->isIncompleteVar()) {
+            if (unknownFunc)
+                *unknownFunc = prev->previous();
             return false;
         }
-        if (Token::simpleMatch(prev->previous(), ") ;") && prev->previous()->link() &&
-            isEscaped(prev->previous()->link()->astTop(), functionScope))
+        if (Token::simpleMatch(prev->previous(), ") ;") && prev->linkAt(-1) &&
+            isEscaped(prev->linkAt(-1)->astTop(), functionScope, library))
             return true;
-        if (isEscaped(prev->previous()->astTop(), functionScope))
+        if (isEscaped(prev->previous()->astTop(), functionScope, library))
             return true;
         // return/goto statement
         prev = prev->previous();
-        while (prev && !Token::Match(prev, ";|{|}") && !isEscapedOrJump(prev, functionScope))
+        while (prev && !Token::Match(prev, ";|{|}") && !isEscapedOrJump(prev, functionScope, library))
             prev = prev->previous();
         return prev && prev->isName();
     }
     return false;
 }
 
-bool isVariableChangedByFunctionCall(const Token *tok, int indirect, nonneg int varid, const Settings *settings, bool *inconclusive)
+bool isWithinScope(const Token* tok, const Variable* var, ScopeType type)
+{
+    if (!tok || !var)
+        return false;
+    const Scope* scope = tok->scope();
+    while (scope && scope != var->scope()) {
+        if (scope->type == type)
+            return true;
+        scope = scope->nestedIn;
+    }
+    return false;
+}
+
+bool isVariableChangedByFunctionCall(const Token *tok, int indirect, nonneg int varid, const Settings &settings, bool *inconclusive)
 {
     if (!tok)
         return false;
@@ -973,18 +2327,21 @@ bool isScopeBracket(const Token* tok)
     return false;
 }
 
-const Token * getTokenArgumentFunction(const Token * tok, int& argn)
+template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+static T* getTokenArgumentFunctionImpl(T* tok, int& argn)
 {
     argn = -1;
     {
-        const Token *parent = tok->astParent();
-        if (parent && parent->isUnaryOp("&"))
+        T* parent = tok->astParent();
+        if (parent && (parent->isUnaryOp("&") || parent->isIncDecOp()))
             parent = parent->astParent();
         while (parent && parent->isCast())
             parent = parent->astParent();
+        if (Token::Match(parent, "[+-]") && parent->valueType() && parent->valueType()->pointer)
+            parent = parent->astParent();
 
         // passing variable to subfunction?
-        if (Token::Match(parent, "[(,{]"))
+        if (Token::Match(parent, "[[(,{.]") || Token::Match(parent, "%oror%|&&") || (parent && parent->isUnaryOp("*")))
             ;
         else if (Token::simpleMatch(parent, ":")) {
             while (Token::Match(parent, "[?:]"))
@@ -997,87 +2354,216 @@ const Token * getTokenArgumentFunction(const Token * tok, int& argn)
             return nullptr;
     }
 
-    // goto start of function call and get argn
-    argn = 0;
-    while (tok && !Token::simpleMatch(tok, ";") && !isScopeBracket(tok)) {
-        if (tok->str() == ",")
-            ++argn;
-        else if (Token::Match(tok, ")|}"))
-            tok = tok->link();
-        else if (Token::Match(tok->previous(), "%name% (|{"))
-            break;
-        else if (Token::Match(tok->previous(), "> (|{") && tok->previous()->link())
+    T* argtok = tok;
+    while (argtok && argtok->astParent() && (!Token::Match(argtok->astParent(), ",|(|{") || argtok->astParent()->isCast())) {
+        argtok = argtok->astParent();
+    }
+    if (!argtok)
+        return nullptr;
+    if (Token::simpleMatch(argtok, ","))
+        argtok = argtok->astOperand1();
+    tok = argtok;
+    while (Token::Match(tok->astParent(), ",|(|{")) {
+        tok = tok->astParent();
+        if (Token::Match(tok, "(|{"))
             break;
-        tok = tok->previous();
     }
+    argn = getArgumentPos(tok, argtok);
+    if (argn == -1)
+        return nullptr;
     if (!Token::Match(tok, "{|("))
         return nullptr;
-    tok = tok->previous();
+    if (tok->astOperand2())
+        tok = tok->astOperand1();
+    while (tok && (tok->isUnaryOp("*") || tok->str() == "["))
+        tok = tok->astOperand1();
+    if (Token::Match(tok, ". * %name%")) // bailout for pointer to member
+        return tok->tokAt(2);
+    while (Token::simpleMatch(tok, "."))
+        tok = tok->astOperand2();
+    while (Token::simpleMatch(tok, "::")) {
+        // If there is only a op1 and not op2, then this is a global scope
+        if (!tok->astOperand2() && tok->astOperand1()) {
+            tok = tok->astOperand1();
+            break;
+        }
+        tok = tok->astOperand2();
+        if (Token::simpleMatch(tok, "<") && tok->link())
+            tok = tok->astOperand1();
+    }
     if (tok && tok->link() && tok->str() == ">")
         tok = tok->link()->previous();
-    if (!Token::Match(tok, "%name% [({<]"))
+    if (!Token::Match(tok, "%name%|(|{"))
+        return nullptr;
+    // Skip labels
+    if (Token::Match(tok, "%name% :"))
         return nullptr;
     return tok;
 }
 
-bool isVariableChangedByFunctionCall(const Token *tok, int indirect, const Settings *settings, bool *inconclusive)
+const Token* getTokenArgumentFunction(const Token* tok, int& argn) {
+    return getTokenArgumentFunctionImpl(tok, argn);
+}
+
+Token* getTokenArgumentFunction(Token* tok, int& argn) {
+    return getTokenArgumentFunctionImpl(tok, argn);
+}
+
+std::vector<const Variable*> getArgumentVars(const Token* tok, int argnr)
+{
+    if (!tok)
+        return {};
+    if (tok->function()) {
+        const Variable* argvar = tok->function()->getArgumentVar(argnr);
+        if (argvar)
+            return {argvar};
+        return {};
+    }
+    if (tok->variable() || Token::simpleMatch(tok, "{") || Token::Match(tok->previous(), "%type% (|{")) {
+        const Type* type = Token::typeOf(tok);
+        if (!type)
+            return {};
+        const Scope* typeScope = type->classScope;
+        if (!typeScope)
+            return {};
+        const bool tokIsBrace = Token::simpleMatch(tok, "{");
+        // Aggregate constructor
+        if (tokIsBrace && typeScope->numConstructors == 0 && argnr < typeScope->varlist.size()) {
+            auto it = std::next(typeScope->varlist.cbegin(), argnr);
+            return {&*it};
+        }
+        std::vector<const Variable*> result;
+        const int argCount = numberOfArguments(tok);
+        const bool constructor = tokIsBrace || (tok->variable() && tok->variable()->nameToken() == tok);
+        for (const Function &function : typeScope->functionList) {
+            if (function.argCount() < argCount)
+                continue;
+            if (constructor && !function.isConstructor())
+                continue;
+            if (!constructor && !Token::simpleMatch(function.token, "operator()"))
+                continue;
+            const Variable* argvar = function.getArgumentVar(argnr);
+            if (argvar)
+                result.push_back(argvar);
+        }
+        return result;
+    }
+    return {};
+}
+
+static bool isCPPCastKeyword(const Token* tok)
+{
+    if (!tok)
+        return false;
+    return endsWith(tok->str(), "_cast");
+}
+
+static bool isTrivialConstructor(const Token* tok)
+{
+    const Token* typeTok = nullptr;
+    const Type* t = Token::typeOf(tok, &typeTok);
+    if (t)
+        return false;
+    if (typeTok->valueType() && typeTok->valueType()->isPrimitive())
+        return true;
+    return false;
+}
+
+static bool isArray(const Token* tok)
+{
+    if (!tok)
+        return false;
+    if (tok->variable())
+        return tok->variable()->isArray();
+    if (Token::simpleMatch(tok, "."))
+        return isArray(tok->astOperand2());
+    return false;
+}
+
+bool isMutableExpression(const Token* tok)
+{
+    if (!tok)
+        return false;
+    if (tok->isLiteral() || tok->isKeyword() || tok->isStandardType() || tok->isEnumerator())
+        return false;
+    if (Token::Match(tok, ",|;|:|]|)|}"))
+        return false;
+    if (Token::simpleMatch(tok, "[ ]"))
+        return false;
+    if (tok->previous() && tok->previous()->isKeyword() && Token::Match(tok->previous(), "%name% ("))
+        return false;
+    if (tok->link() && Token::Match(tok, "<|>"))
+        return false;
+    if (tok->astOperand1() && Token::simpleMatch(tok, "["))
+        return isMutableExpression(tok->astOperand1());
+    if (const Variable* var = tok->variable()) {
+        if (var->nameToken() == tok)
+            return false;
+        if (var->isConst() && !var->isPointer() && (!var->isArray() || !var->isArgument()))
+            return false;
+    }
+    return true;
+}
+
+bool isVariableChangedByFunctionCall(const Token *tok, int indirect, const Settings &settings, bool *inconclusive)
 {
     if (!tok)
         return false;
 
+    if (Token::simpleMatch(tok, ","))
+        return false;
+
     const Token * const tok1 = tok;
 
     // address of variable
     const bool addressOf = tok->astParent() && tok->astParent()->isUnaryOp("&");
+    if (addressOf)
+        indirect++;
+
+    const bool deref = tok->astParent() && tok->astParent()->isUnaryOp("*");
+    if (deref && indirect > 0)
+        indirect--;
+
+    if (indirect == 1 && tok->isCpp() && tok->tokAt(-1) && Token::simpleMatch(tok->tokAt(-2), "new (")) // placement new TODO: fix AST
+        return true;
 
     int argnr;
     tok = getTokenArgumentFunction(tok, argnr);
     if (!tok)
         return false; // not a function => variable not changed
+    if (Token::simpleMatch(tok, "{") && isTrivialConstructor(tok))
+        return false;
+    if (tok->isKeyword() && !isCPPCastKeyword(tok) && !startsWith(tok->str(),"operator"))
+        return false;
+    // A functional cast won't modify the variable
+    if (Token::Match(tok, "%type% (|{") && tok->tokType() == Token::eType && astIsPrimitive(tok->next()))
+        return false;
     const Token * parenTok = tok->next();
     if (Token::simpleMatch(parenTok, "<") && parenTok->link())
         parenTok = parenTok->link()->next();
     const bool possiblyPassedByReference = (parenTok->next() == tok1 || Token::Match(tok1->previous(), ", %name% [,)}]"));
 
-    // Constructor call
-    if (tok->variable() && tok->variable()->nameToken() == tok) {
-        // Find constructor..
-        const int argCount = numberOfArguments(tok);
-        const Scope *typeScope = tok->variable()->typeScope();
-        if (typeScope) {
-            for (const Function &function : typeScope->functionList) {
-                if (!function.isConstructor() || function.argCount() < argCount)
-                    continue;
-                const Variable *arg = function.getArgumentVar(argnr);
-                if (arg && arg->isReference() && !arg->isConst())
-                    return true;
-            }
+    if (!tok->function() && !tok->variable() && tok->isName()) {
+        // Check if direction (in, out, inout) is specified in the library configuration and use that
+        const Library::ArgumentChecks::Direction argDirection = settings.library.getArgDirection(tok, 1 + argnr, indirect);
+        if (argDirection == Library::ArgumentChecks::Direction::DIR_IN)
             return false;
-        }
-        if (inconclusive)
-            *inconclusive = true;
-        return false;
-    }
 
-    if (!tok->function()) {
-        // Check if direction (in, out, inout) is specified in the library configuration and use that
-        if (!addressOf && settings) {
-            const Library::ArgumentChecks::Direction argDirection = settings->library.getArgDirection(tok, 1 + argnr);
-            if (argDirection == Library::ArgumentChecks::Direction::DIR_IN)
-                return false;
-            else if (argDirection == Library::ArgumentChecks::Direction::DIR_OUT ||
-                     argDirection == Library::ArgumentChecks::Direction::DIR_INOUT) {
-                // With out or inout the direction of the content is specified, not a pointer itself, so ignore pointers for now
-                const ValueType * const valueType = tok1->valueType();
-                if (valueType && valueType->pointer == indirect) {
-                    return true;
-                }
-            }
+        const bool requireNonNull = settings.library.isnullargbad(tok, 1 + argnr);
+        if (argDirection == Library::ArgumentChecks::Direction::DIR_OUT ||
+            argDirection == Library::ArgumentChecks::Direction::DIR_INOUT) {
+            if (indirect == 0 && isArray(tok1))
+                return true;
+            const bool requireInit = settings.library.isuninitargbad(tok, 1 + argnr);
+            // Assume that if the variable must be initialized then the indirection is 1
+            if (indirect > 0 && requireInit && requireNonNull)
+                return true;
         }
-
+        if (Token::simpleMatch(tok->tokAt(-2), "std :: tie"))
+            return true;
         // if the library says 0 is invalid
         // => it is assumed that parameter is an in parameter (TODO: this is a bad heuristic)
-        if (!addressOf && settings && settings->library.isnullargbad(tok, 1+argnr))
+        if (indirect == 0 && requireNonNull)
             return false;
         // possible pass-by-reference => inconclusive
         if (possiblyPassedByReference) {
@@ -1089,78 +2575,216 @@ bool isVariableChangedByFunctionCall(const Token *tok, int indirect, const Setti
         return true;
     }
 
-    const Variable *arg = tok->function()->getArgumentVar(argnr);
+    if (const Variable* var = tok->variable()) {
+        if (tok == var->nameToken() && (!var->isReference() || (var->isConst() && var->type() == tok1->type())) && (!var->isClass() || (var->valueType() && var->valueType()->container))) // const ref or passed to (copy) ctor
+            return false;
+    }
 
-    if (addressOf || (indirect > 0 && arg && arg->isPointer())) {
-        if (!(arg && arg->isConst()))
+    std::vector<const Variable*> args = getArgumentVars(tok, argnr);
+    bool conclusive = false;
+    for (const Variable *arg:args) {
+        if (!arg)
+            continue;
+        conclusive = true;
+        if (indirect > 0) {
+            if (arg->isPointer() && !(arg->valueType() && arg->valueType()->isConst(indirect)))
+                return true;
+            if (indirect > 1 && addressOf && arg->isPointer() && (!arg->valueType() || !arg->valueType()->isConst(indirect-1)))
+                return true;
+            if (arg->isArray() || (!arg->isPointer() && (!arg->valueType() || arg->valueType()->type == ValueType::UNKNOWN_TYPE)))
+                return true;
+        }
+        if (!arg->isConst() && arg->isReference())
             return true;
-        // If const is applied to the pointer, then the value can still be modified
-        if (arg && Token::simpleMatch(arg->typeEndToken(), "* const"))
+    }
+    if (addressOf && tok1->astParent()->isUnaryOp("&")) {
+        const Token* castToken = tok1->astParent();
+        while (castToken->astParent()->isCast())
+            castToken = castToken->astParent();
+        if (Token::Match(castToken->astParent(), ",|(") &&
+            castToken->valueType() &&
+            castToken->valueType()->isIntegral() &&
+            castToken->valueType()->pointer == 0)
             return true;
     }
+    if (!conclusive && inconclusive) {
+        *inconclusive = true;
+    }
+    return false;
+}
 
-    return arg && !arg->isConst() && arg->isReference();
+static bool hasOverloadedMemberAccess(const Token* tok)
+{
+    if (!Token::simpleMatch(tok, "."))
+        return false;
+    const Token* varTok = tok->astOperand2();
+    return !varTok || !varTok->variable() || !varTok->variable()->valueType() || varTok->variable()->valueType()->pointer == 0;
 }
 
-bool isVariableChanged(const Token *tok, int indirect, const Settings *settings, bool cpp, int depth)
+bool isVariableChanged(const Token *tok, int indirect, const Settings &settings, int depth)
 {
     if (!tok)
         return false;
+    if (!tok->isMutableExpr())
+        return false;
+
+    if (indirect == 0 && isConstVarExpression(tok))
+        return false;
+
     const Token *tok2 = tok;
-    while (Token::simpleMatch(tok2->astParent(), "*") || (Token::simpleMatch(tok2->astParent(), ".") && !Token::simpleMatch(tok2->astParent()->astParent(), "(")) ||
-           (Token::simpleMatch(tok2->astParent(), "[") && tok2 == tok2->astParent()->astOperand1()))
+    int derefs = 0;
+    while ((tok2->astParent() && tok2->astParent()->isUnaryOp("*")) ||
+           (Token::simpleMatch(tok2->astParent(), ".") && !Token::Match(tok2->astParent()->astParent(), "[(,]")) ||
+           (tok2->astParent() && tok2->astParent()->isUnaryOp("&") && Token::simpleMatch(tok2->astParent()->astParent(), ".") && tok2->astParent()->astParent()->originalName()=="->") ||
+           (Token::simpleMatch(tok2->astParent(), "[") && tok2 == tok2->astParent()->astOperand1()) ||
+           (Token::simpleMatch(tok2->astParent(), "(") && tok2->astParent()->isCast())) {
+        if (tok2->astParent() && (tok2->astParent()->isUnaryOp("*") || (astIsLHS(tok2) && tok2->astParent()->originalName() == "->" && !hasOverloadedMemberAccess(tok2))))
+            derefs++;
+        if (derefs > indirect)
+            break;
+        if (tok2->astParent() && tok2->astParent()->isUnaryOp("&") && Token::simpleMatch(tok2->astParent()->astParent(), ".") && tok2->astParent()->astParent()->originalName()=="->")
+            tok2 = tok2->astParent();
         tok2 = tok2->astParent();
+    }
 
-    while (Token::simpleMatch(tok2->astParent(), "?") || (Token::simpleMatch(tok2->astParent(), ":") && Token::simpleMatch(tok2->astParent()->astParent(), "?")))
+    if (tok2->astParent() && tok2->astParent()->isUnaryOp("&")) {
+        const Token* parent = tok2->astParent();
+        while (parent->astParent() && parent->astParent()->isCast())
+            parent = parent->astParent();
+        if (parent->astParent() && parent->astParent()->isUnaryOp("*"))
+            tok2 = parent->astParent();
+    }
+
+    while ((Token::simpleMatch(tok2, ":") && Token::simpleMatch(tok2->astParent(), "?")) ||
+           (Token::simpleMatch(tok2->astParent(), ":") && Token::simpleMatch(tok2->astParent()->astParent(), "?")))
         tok2 = tok2->astParent();
 
-    if (Token::Match(tok2->astParent(), "++|--"))
+    if (indirect == 0 && tok2->astParent() && tok2->astParent()->tokType() == Token::eIncDecOp)
         return true;
 
+    auto skipRedundantPtrOp = [](const Token* tok, const Token* parent) {
+        const Token* gparent = parent ? parent->astParent() : nullptr;
+        while (parent && gparent && ((parent->isUnaryOp("*") && gparent->isUnaryOp("&")) || (parent->isUnaryOp("&") && gparent->isUnaryOp("*")))) {
+            tok = gparent;
+            parent = gparent->astParent();
+            if (parent)
+                gparent = parent->astParent();
+        }
+        return tok;
+    };
+    tok2 = skipRedundantPtrOp(tok2, tok2->astParent());
+
     if (tok2->astParent() && tok2->astParent()->isAssignmentOp()) {
-        if (tok2 == tok2->astParent()->astOperand1())
+        if (astIsLHS(tok2))
             return true;
         // Check if assigning to a non-const lvalue
         const Variable * var = getLHSVariable(tok2->astParent());
-        if (var && var->isReference() && !var->isConst() && var->nameToken() && var->nameToken()->next() == tok2->astParent()) {
-            if (!var->isLocal() || isVariableChanged(var, settings, cpp, depth - 1))
+        if (var && var->isReference() && !var->isConst() && var->nameToken() &&
+            var->nameToken()->next() == tok2->astParent()) {
+            if (!var->isLocal() || isVariableChanged(var, settings, depth - 1))
                 return true;
         }
     }
 
-    if (isLikelyStreamRead(cpp, tok->previous()))
+    const ValueType* vt = tok->variable() ? tok->variable()->valueType() : tok->valueType();
+
+    // Check addressof
+    if (tok2->astParent() && tok2->astParent()->isUnaryOp("&")) {
+        if (isVariableChanged(tok2->astParent(), indirect + 1, settings, depth - 1))
+            return true;
+    } else {
+        // If its already const then it cant be modified
+        if (vt && vt->isConst(indirect))
+            return false;
+    }
+
+    if (tok2->isCpp() && Token::Match(tok2->astParent(), ">>|&") && astIsRHS(tok2) && isLikelyStreamRead(tok2->astParent()))
         return true;
 
-    if (isLikelyStream(cpp, tok2))
+    if (isLikelyStream(tok2))
         return true;
 
     // Member function call
-    if (tok->variable() && Token::Match(tok2->astParent(), ". %name%") && isFunctionCall(tok2->astParent()->next()) && tok2->astParent()->astOperand1() == tok2) {
-        const Variable * var = tok->variable();
-        bool isConst = var && var->isConst();
-        if (!isConst && var) {
-            const ValueType * valueType = var->valueType();
-            isConst = (valueType && valueType->pointer == 1 && valueType->constness == 1);
+    if (Token::Match(tok2->astParent(), ". %name%") && isFunctionCall(tok2->astParent()->next()) &&
+        tok2->astParent()->astOperand1() == tok2) {
+        // Member function cannot change what `this` points to
+        if (indirect == 0 && astIsPointer(tok))
+            return false;
+
+        const Token *ftok = tok2->astParent()->astOperand2();
+        const Token* const ctok = tok2->str() == "." ? tok2->astOperand2() : tok2;
+        if (astIsContainer(ctok) && ctok->valueType() && ctok->valueType()->container) {
+            const Library::Container* c = ctok->valueType()->container;
+            const Library::Container::Action action = c->getAction(ftok->str());
+            if (contains({Library::Container::Action::INSERT,
+                          Library::Container::Action::ERASE,
+                          Library::Container::Action::APPEND,
+                          Library::Container::Action::CHANGE,
+                          Library::Container::Action::CHANGE_CONTENT,
+                          Library::Container::Action::CHANGE_INTERNAL,
+                          Library::Container::Action::CLEAR,
+                          Library::Container::Action::FIND,
+                          Library::Container::Action::PUSH,
+                          Library::Container::Action::POP,
+                          Library::Container::Action::RESIZE},
+                         action))
+                return true;
+            const Library::Container::Yield yield = c->getYield(ftok->str());
+            // If accessing element check if the element is changed
+            if (contains({Library::Container::Yield::ITEM, Library::Container::Yield::AT_INDEX}, yield))
+                return isVariableChanged(ftok->next(), indirect, settings, depth - 1);
+
+            if (contains({Library::Container::Yield::BUFFER,
+                          Library::Container::Yield::BUFFER_NT,
+                          Library::Container::Yield::START_ITERATOR,
+                          Library::Container::Yield::ITERATOR},
+                         yield)) {
+                return isVariableChanged(ftok->next(), indirect + 1, settings, depth - 1);
+            }
+            if (contains({Library::Container::Yield::SIZE,
+                          Library::Container::Yield::EMPTY,
+                          Library::Container::Yield::END_ITERATOR},
+                         yield)) {
+                return false;
+            }
         }
+        if (settings.library.isFunctionConst(ftok) || (astIsSmartPointer(tok) && ftok->str() == "get")) // TODO: replace with action/yield?
+            return false;
 
-        const Token *ftok = tok->tokAt(2);
         const Function * fun = ftok->function();
-        if (!isConst && (!fun || !fun->isConst()))
+        if (!fun)
+            return true;
+        return !fun->isConst();
+    }
+
+    // Member pointer
+    if (Token::Match(tok2->astParent(), ". * ( & %name% ::")) {
+        const Token* ftok = tok2->astParent()->linkAt(2)->previous();
+        // TODO: Check for pointer to member variable
+        if (!ftok->function() || !ftok->function()->isConst())
             return true;
-        else
-            return false;
     }
+    if (Token::Match(tok2->astParent(), ". * %name%")) // bailout
+        return true;
+
+    if (Token::simpleMatch(tok2, "[") && astIsContainer(tok) && vt && vt->container && vt->container->stdAssociativeLike)
+        return true;
 
     const Token *ftok = tok2;
     while (ftok && (!Token::Match(ftok, "[({]") || ftok->isCast()))
         ftok = ftok->astParent();
 
     if (ftok && Token::Match(ftok->link(), ")|} !!{")) {
+        if (ftok->str() == "(" && Token::simpleMatch(ftok->astOperand1(), "[")) // operator() on array element, bail out
+            return true;
         const Token * ptok = tok2;
         while (Token::Match(ptok->astParent(), ".|::|["))
             ptok = ptok->astParent();
+        int pindirect = indirect;
+        if (indirect == 0 && astIsLHS(tok2) && Token::Match(ptok, ". %var%") && astIsPointer(ptok->next()))
+            pindirect = 1;
         bool inconclusive = false;
-        bool isChanged = isVariableChangedByFunctionCall(ptok, indirect, settings, &inconclusive);
+        bool isChanged = isVariableChangedByFunctionCall(ptok, pindirect, settings, &inconclusive);
         isChanged |= inconclusive;
         if (isChanged)
             return true;
@@ -1169,53 +2793,206 @@ bool isVariableChanged(const Token *tok, int indirect, const Settings *settings,
     const Token *parent = tok2->astParent();
     while (Token::Match(parent, ".|::"))
         parent = parent->astParent();
-    if (parent && parent->tokType() == Token::eIncDecOp)
+    if (parent && parent->tokType() == Token::eIncDecOp && (indirect == 0 || tok2 != tok))
         return true;
 
+    // structured binding, nonconst reference variable in lhs
+    if (Token::Match(tok2->astParent(), ":|=") && tok2 == tok2->astParent()->astOperand2() && Token::simpleMatch(tok2->astParent()->previous(), "]")) {
+        const Token *typeStart = tok2->astParent()->linkAt(-1)->previous();
+        if (Token::simpleMatch(typeStart, "&"))
+            typeStart = typeStart->previous();
+        if (typeStart && Token::Match(typeStart->previous(), "[;{}(] auto &| [")) {
+            for (const Token *vartok = typeStart->tokAt(2); vartok != tok2; vartok = vartok->next()) {
+                if (vartok->varId()) {
+                    const Variable* refvar = vartok->variable();
+                    if (!refvar || (!refvar->isConst() && refvar->isReference()))
+                        return true;
+                }
+            }
+        }
+    }
+
     if (Token::simpleMatch(tok2->astParent(), ":") && tok2->astParent()->astParent() && Token::simpleMatch(tok2->astParent()->astParent()->previous(), "for (")) {
+        // TODO: Check if container is empty or not
+        if (astIsLHS(tok2))
+            return true;
         const Token * varTok = tok2->astParent()->previous();
         if (!varTok)
             return false;
         const Variable * loopVar = varTok->variable();
         if (!loopVar)
             return false;
-        if (!loopVar->isConst() && loopVar->isReference() && isVariableChanged(loopVar, settings, cpp, depth - 1))
+        if (!loopVar->isConst() && loopVar->isReference() && isVariableChanged(loopVar, settings, depth - 1))
             return true;
         return false;
     }
+
+    if (indirect > 0) {
+        // check for `*(ptr + 1) = new_value` case
+        parent = tok2->astParent();
+        while (parent && ((parent->isArithmeticalOp() && parent->isBinaryOp()) || parent->isIncDecOp())) {
+            parent = parent->astParent();
+        }
+        if (Token::simpleMatch(parent, "*")) {
+            if (parent->astParent() && parent->astParent()->isAssignmentOp() &&
+                (parent->astParent()->astOperand1() == parent)) {
+                return true;
+            }
+        }
+    }
+
     return false;
 }
 
-bool isVariableChanged(const Token *start, const Token *end, const nonneg int varid, bool globalvar, const Settings *settings, bool cpp, int depth)
+bool isVariableChanged(const Token *start, const Token *end, const nonneg int exprid, bool globalvar, const Settings &settings, int depth)
+{
+    return findVariableChanged(start, end, 0, exprid, globalvar, settings, depth) != nullptr;
+}
+
+bool isVariableChanged(const Token *start, const Token *end, int indirect, const nonneg int exprid, bool globalvar, const Settings &settings, int depth)
+{
+    return findVariableChanged(start, end, indirect, exprid, globalvar, settings, depth) != nullptr;
+}
+
+const Token* findExpression(const Token* start, const nonneg int exprid)
+{
+    const Function* f = Scope::nestedInFunction(start->scope());
+    if (!f)
+        return nullptr;
+    const Scope* scope = f->functionScope;
+    if (!scope)
+        return nullptr;
+    for (const Token *tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
+        if (tok->exprId() != exprid)
+            continue;
+        return tok;
+    }
+    return nullptr;
+}
+
+const Token* findEscapeStatement(const Scope* scope, const Library& library)
+{
+    if (!scope)
+        return nullptr;
+    for (const Token* tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
+        const Scope* escapeScope = tok->scope();
+        if (!escapeScope->isExecutable()) { // skip type definitions
+            tok = escapeScope->bodyEnd;
+            continue;
+        }
+        if (const Token* lambdaEnd = findLambdaEndToken(tok)) { // skip lambdas
+            tok = lambdaEnd;
+            continue;
+        }
+        if (!tok->isName())
+            continue;
+        if (isEscapeFunction(tok, library))
+            return tok;
+        if (!tok->isKeyword())
+            continue;
+        if (Token::Match(tok, "goto|return|throw")) // TODO: check try/catch, labels?
+            return tok;
+        if (!Token::Match(tok, "break|continue"))
+            continue;
+        const bool isBreak = tok->str()[0] == 'b';
+        while (escapeScope && escapeScope != scope) {
+            if (escapeScope->isLoopScope() || (isBreak && escapeScope->type == ScopeType::eSwitch))
+                return nullptr;
+            escapeScope = escapeScope->nestedIn;
+        }
+        return tok;
+    }
+    return nullptr;
+}
+
+template<class F,
+         REQUIRES("F must be a function that returns a Token class",
+                  std::is_convertible<decltype(std::declval<F>()()), const Token*> )>
+static bool isExpressionChangedAt(const F& getExprTok,
+                                  const Token* tok,
+                                  int indirect,
+                                  const nonneg int exprid,
+                                  bool globalvar,
+                                  const Settings& settings,
+                                  int depth)
+{
+    if (depth < 0)
+        return true;
+    if (!tok)
+        return false;
+    if (!tok->isMutableExpr())
+        return false;
+    if (tok->exprId() != exprid || (!tok->varId() && !tok->isName())) {
+        if (globalvar && Token::Match(tok, "%name% (") &&
+            (!(tok->function() && (tok->function()->isAttributePure() || tok->function()->isAttributeConst())))) {
+            if (!Token::simpleMatch(tok->astParent(), "."))
+                return true;
+            const auto yield = astContainerYield(tok->astParent()->astOperand1(), settings.library);
+            if (yield != Library::Container::Yield::SIZE && yield != Library::Container::Yield::EMPTY &&
+                yield != Library::Container::Yield::BUFFER && yield != Library::Container::Yield::BUFFER_NT)
+                // TODO: Is global variable really changed by function call?
+                return true;
+        }
+        nonneg int i = 1;
+        bool aliased = false;
+        // If we can't find the expression then assume it is an alias
+        auto expr = getExprTok();
+        if (!expr && !(tok->valueType() && tok->valueType()->pointer == 0 && tok->valueType()->reference == Reference::None))
+            aliased = true;
+        if (!aliased && expr && expr->varId() && tok->isCast() && tok->valueType() && tok->valueType()->reference != Reference::None &&
+            Token::Match(tok->astOperand2() ? tok->astOperand2() : tok->astOperand1(), "%varid%", expr->varId()))
+            aliased = true;
+        if (!aliased)
+            aliased = isAliasOf(tok, expr, &i);
+        if (!aliased)
+            return false;
+        i += indirect;
+        if (tok->valueType() && tok->valueType()->pointer)
+            i = std::min(i, tok->valueType()->pointer);
+        if (isVariableChanged(tok, i, settings, depth))
+            return true;
+        // TODO: Try to traverse the lambda function
+        if (Token::Match(tok, "%var% ("))
+            return true;
+        return false;
+    }
+    return (isVariableChanged(tok, indirect, settings, depth));
+}
+
+bool isExpressionChangedAt(const Token* expr,
+                           const Token* tok,
+                           int indirect,
+                           bool globalvar,
+                           const Settings& settings,
+                           int depth)
 {
-    return findVariableChanged(start, end, 0, varid, globalvar, settings, cpp, depth) != nullptr;
+    return isExpressionChangedAt([&] {
+        return expr;
+    }, tok, indirect, expr->exprId(), globalvar, settings, depth);
 }
 
-Token* findVariableChanged(Token *start, const Token *end, int indirect, const nonneg int varid, bool globalvar, const Settings *settings, bool cpp, int depth)
+Token* findVariableChanged(Token *start, const Token *end, int indirect, const nonneg int exprid, bool globalvar, const Settings &settings, int depth)
 {
     if (!precedes(start, end))
         return nullptr;
     if (depth < 0)
         return start;
+    auto getExprTok = utils::memoize([&] {
+        return findExpression(start, exprid);
+    });
     for (Token *tok = start; tok != end; tok = tok->next()) {
-        if (tok->varId() != varid) {
-            if (globalvar && Token::Match(tok, "%name% ("))
-                // TODO: Is global variable really changed by function call?
-                return tok;
-            continue;
-        }
-        if (isVariableChanged(tok, indirect, settings, cpp, depth))
+        if (isExpressionChangedAt(getExprTok, tok, indirect, exprid, globalvar, settings, depth))
             return tok;
     }
     return nullptr;
 }
 
-const Token* findVariableChanged(const Token *start, const Token *end, int indirect, const nonneg int varid, bool globalvar, const Settings *settings, bool cpp, int depth)
+const Token* findVariableChanged(const Token *start, const Token *end, int indirect, const nonneg int exprid, bool globalvar, const Settings &settings, int depth)
 {
-    return findVariableChanged(const_cast<Token*>(start), end, indirect, varid, globalvar, settings, cpp, depth);
+    return findVariableChanged(const_cast<Token*>(start), end, indirect, exprid, globalvar, settings, depth);
 }
 
-bool isVariableChanged(const Variable * var, const Settings *settings, bool cpp, int depth)
+bool isVariableChanged(const Variable * var, const Settings &settings, int depth)
 {
     if (!var)
         return false;
@@ -1226,66 +3003,264 @@ bool isVariableChanged(const Variable * var, const Settings *settings, bool cpp,
         return false;
     if (Token::Match(start, "; %varid% =", var->declarationId()))
         start = start->tokAt(2);
-    return isVariableChanged(start->next(), var->scope()->bodyEnd, var->declarationId(), var->isGlobal(), settings, cpp, depth);
+    if (Token::simpleMatch(start, "=")) {
+        const Token* next = nextAfterAstRightmostLeafGeneric(start);
+        if (next)
+            start = next;
+    }
+    return findExpressionChanged(var->nameToken(), start->next(), var->scope()->bodyEnd, settings, depth);
 }
 
 bool isVariablesChanged(const Token* start,
                         const Token* end,
                         int indirect,
-                        std::vector<const Variable*> vars,
-                        const Settings* settings,
-                        bool cpp)
+                        const std::vector<const Variable*> &vars,
+                        const Settings& settings)
 {
     std::set<int> varids;
-    std::transform(vars.begin(), vars.end(), std::inserter(varids, varids.begin()), [](const Variable* var) {
+    std::transform(vars.cbegin(), vars.cend(), std::inserter(varids, varids.begin()), [](const Variable* var) {
         return var->declarationId();
     });
-    const bool globalvar = std::any_of(vars.begin(), vars.end(), [](const Variable* var) {
+    const bool globalvar = std::any_of(vars.cbegin(), vars.cend(), [](const Variable* var) {
         return var->isGlobal();
     });
-    for (const Token* tok = start; tok != end; tok = tok->next()) {
+    for (const Token* tok = start; tok && tok != end; tok = tok->next()) {
         if (tok->varId() == 0 || varids.count(tok->varId()) == 0) {
             if (globalvar && Token::Match(tok, "%name% ("))
                 // TODO: Is global variable really changed by function call?
                 return true;
             continue;
         }
-        if (isVariableChanged(tok, indirect, settings, cpp))
+        if (isVariableChanged(tok, indirect, settings))
             return true;
     }
     return false;
 }
 
-int numberOfArguments(const Token *start)
+bool isThisChanged(const Token* tok, int indirect, const Settings& settings)
 {
-    int arguments=0;
-    const Token* const openBracket = start->next();
-    if (openBracket && openBracket->str()=="(" && openBracket->next() && openBracket->next()->str()!=")") {
-        const Token* argument=openBracket->next();
-        while (argument) {
-            ++arguments;
-            argument = argument->nextArgument();
+    if ((Token::Match(tok->previous(), "%name% (") && !Token::simpleMatch(tok->astOperand1(), ".")) ||
+        Token::Match(tok->tokAt(-3), "this . %name% (")) {
+        if (tok->previous()->function()) {
+            return (!tok->previous()->function()->isConst() && !tok->previous()->function()->isStatic());
+        }
+        if (!tok->previous()->isKeyword() || tok->previous()->isOperatorKeyword()) {
+            return true;
         }
     }
-    return arguments;
+    if (isVariableChanged(tok, indirect, settings))
+        return true;
+    return false;
+}
+
+static const Token* findThisChanged(const Token* start, const Token* end, int indirect, const Settings& settings)
+{
+    if (!precedes(start, end))
+        return nullptr;
+    for (const Token* tok = start; tok != end; tok = tok->next()) {
+        if (!exprDependsOnThis(tok))
+            continue;
+        if (isThisChanged(tok, indirect, settings))
+            return tok;
+    }
+    return nullptr;
+}
+
+template<class Find>
+static const Token* findExpressionChangedImpl(const Token* expr,
+                                              const Token* start,
+                                              const Token* end,
+                                              const Settings& settings,
+                                              int depth,
+                                              Find find)
+{
+    if (depth < 0)
+        return start;
+    if (!precedes(start, end))
+        return nullptr;
+    const Token* result = nullptr;
+    findAstNode(expr, [&](const Token* tok) {
+        if (exprDependsOnThis(tok)) {
+            result = findThisChanged(start, end, /*indirect*/ 0, settings);
+            if (result)
+                return true;
+        }
+        bool global = false;
+        if (tok->variable()) {
+            global = !tok->variable()->isLocal() && !tok->variable()->isArgument() &&
+                     !(tok->variable()->isMember() && !tok->variable()->isStatic());
+        } else if (tok->isIncompleteVar() && !tok->isIncompleteConstant()) {
+            global = true;
+        }
+
+        if (tok->exprId() > 0 || global) {
+            const Token* modifedTok = find(start, end, [&](const Token* tok2) {
+                int indirect = 0;
+                if (const ValueType* vt = tok->valueType()) {
+                    indirect = vt->pointer;
+                    if (vt->type == ValueType::ITERATOR)
+                        ++indirect;
+                }
+                for (int i = 0; i <= indirect; ++i) {
+                    if (isExpressionChangedAt(tok, tok2, i, global, settings, depth))
+                        return true;
+                }
+                return false;
+            });
+            if (modifedTok) {
+                result = modifedTok;
+                return true;
+            }
+        }
+        return false;
+    });
+    return result;
+}
+
+namespace {
+    struct ExpressionChangedSimpleFind {
+        template<class F>
+        const Token* operator()(const Token* start, const Token* end, F f) const
+        {
+            return findToken(start, end, f);
+        }
+    };
+
+    struct ExpressionChangedSkipDeadCode {
+        const Library& library;
+        const std::function<std::vector<MathLib::bigint>(const Token* tok)>* evaluate;
+        ExpressionChangedSkipDeadCode(const Library& library,
+                                      const std::function<std::vector<MathLib::bigint>(const Token* tok)>& evaluate)
+            : library(library), evaluate(&evaluate)
+        {}
+        template<class F>
+        const Token* operator()(const Token* start, const Token* end, F f) const
+        {
+            return findTokenSkipDeadCode(library, start, end, std::move(f), *evaluate);
+        }
+    };
+}
+
+const Token* findExpressionChanged(const Token* expr,
+                                   const Token* start,
+                                   const Token* end,
+                                   const Settings& settings,
+                                   int depth)
+{
+    return findExpressionChangedImpl(expr, start, end, settings, depth, ExpressionChangedSimpleFind{});
 }
 
-std::vector<const Token *> getArguments(const Token *ftok)
+const Token* findExpressionChangedSkipDeadCode(const Token* expr,
+                                               const Token* start,
+                                               const Token* end,
+                                               const Settings& settings,
+                                               const std::function<std::vector<MathLib::bigint>(const Token* tok)>& evaluate,
+                                               int depth)
+{
+    return findExpressionChangedImpl(
+        expr, start, end, settings, depth, ExpressionChangedSkipDeadCode{settings.library, evaluate});
+}
+
+const Token* getArgumentStart(const Token* ftok)
 {
     const Token* tok = ftok;
-    if (Token::Match(tok, "%name% (|{"))
+    if (Token::Match(tok, "%name% (|{|)"))
         tok = ftok->next();
+    while (Token::simpleMatch(tok, ")"))
+        tok = tok->next();
     if (!Token::Match(tok, "(|{|["))
-        return std::vector<const Token *> {};
-    const Token *startTok = tok->astOperand2();
+        return nullptr;
+    const Token* startTok = tok->astOperand2();
     if (!startTok && tok->next() != tok->link())
         startTok = tok->astOperand1();
-    return astFlatten(startTok, ",");
+    return startTok;
+}
+
+int numberOfArguments(const Token* ftok) {
+    return astCount(getArgumentStart(ftok), ",");
+}
+
+int numberOfArgumentsWithoutAst(const Token* start)
+{
+    int arguments = 0;
+    const Token* openBracket = start->next();
+    while (Token::simpleMatch(openBracket, ")"))
+        openBracket = openBracket->next();
+    if (openBracket && openBracket->str()=="(" && openBracket->next() && openBracket->strAt(1)!=")") {
+        const Token* argument=openBracket->next();
+        while (argument) {
+            ++arguments;
+            argument = argument->nextArgument();
+        }
+    }
+    return arguments;
+}
+
+std::vector<const Token*> getArguments(const Token* ftok) {
+    return astFlatten(getArgumentStart(ftok), ",");
+}
+
+int getArgumentPos(const Variable* var, const Function* f)
+{
+    auto arg_it = std::find_if(f->argumentList.cbegin(), f->argumentList.cend(), [&](const Variable& v) {
+        return v.nameToken() == var->nameToken();
+    });
+    if (arg_it == f->argumentList.end())
+        return -1;
+    return std::distance(f->argumentList.cbegin(), arg_it);
+}
+
+const Token* getIteratorExpression(const Token* tok)
+{
+    if (!tok)
+        return nullptr;
+    if (tok->isUnaryOp("*"))
+        return nullptr;
+    if (!tok->isName()) {
+        const Token* iter1 = getIteratorExpression(tok->astOperand1());
+        if (iter1)
+            return iter1;
+        if (tok->str() == "(")
+            return nullptr;
+        const Token* iter2 = getIteratorExpression(tok->astOperand2());
+        if (iter2)
+            return iter2;
+    } else if (Token::Match(tok, "begin|cbegin|rbegin|crbegin|end|cend|rend|crend (")) {
+        if (Token::Match(tok->previous(), ". %name% ( ) !!."))
+            return tok->previous()->astOperand1();
+        if (!Token::simpleMatch(tok->previous(), ".") && Token::Match(tok, "%name% ( !!)") &&
+            !Token::simpleMatch(tok->linkAt(1), ") ."))
+            return tok->next()->astOperand2();
+    }
+    return nullptr;
+}
+
+bool isIteratorPair(const std::vector<const Token*>& args)
+{
+    if (args.size() != 2)
+        return false;
+    if (astIsPointer(args[0]) && astIsPointer(args[1]))
+        return true;
+    // Check if iterator is from same container
+    const Token* tok1 = nullptr;
+    const Token* tok2 = nullptr;
+    if (astIsIterator(args[0]) && astIsIterator(args[1])) {
+        tok1 = ValueFlow::getLifetimeObjValue(args[0]).tokvalue;
+        tok2 = ValueFlow::getLifetimeObjValue(args[1]).tokvalue;
+        if (!tok1 || !tok2)
+            return true;
+    } else {
+        tok1 = getIteratorExpression(args[0]);
+        tok2 = getIteratorExpression(args[1]);
+    }
+    if (tok1 && tok2)
+        return tok1->exprId() == tok2->exprId();
+    return tok1 || tok2;
 }
 
 const Token *findLambdaStartToken(const Token *last)
 {
-    if (!last || last->str() != "}")
+    if (!last || !last->isCpp() || last->str() != "}")
         return nullptr;
     const Token* tok = last->link();
     if (Token::simpleMatch(tok->astParent(), "("))
@@ -1295,15 +3270,36 @@ const Token *findLambdaStartToken(const Token *last)
     return nullptr;
 }
 
-const Token *findLambdaEndToken(const Token *first)
+template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+static T* findLambdaEndTokenGeneric(T* first)
 {
-    if (!first || first->str() != "[")
+    auto maybeLambda = [](T* tok) -> bool {
+        while (Token::Match(tok, "*|%name%|::|>")) {
+            if (tok->link())
+                tok = tok->link()->previous();
+            else {
+                if (tok->str() == ">")
+                    return true;
+                if (tok->str() == "new")
+                    return false;
+                tok = tok->previous();
+            }
+        }
+        return true;
+    };
+
+    if (!first || !first->isCpp() || first->str() != "[")
         return nullptr;
-    if (!Token::Match(first->link(), "] (|{"))
+    if (!maybeLambda(first->previous()))
         return nullptr;
-    if (first->astOperand1() != first->link()->next())
+    if (!Token::Match(first->link(), "] (|{|<"))
         return nullptr;
-    const Token * tok = first;
+    const Token* roundOrCurly = first->link()->next();
+    if (roundOrCurly->link() && roundOrCurly->str() == "<")
+        roundOrCurly = roundOrCurly->link()->next();
+    if (first->astOperand1() != roundOrCurly)
+        return nullptr;
+    T * tok = first;
 
     if (tok->astOperand1() && tok->astOperand1()->str() == "(")
         tok = tok->astOperand1();
@@ -1312,14 +3308,23 @@ const Token *findLambdaEndToken(const Token *first)
     return nullptr;
 }
 
-bool isLikelyStream(bool cpp, const Token *stream)
+const Token* findLambdaEndToken(const Token* first)
 {
-    if (!cpp)
-        return false;
+    return findLambdaEndTokenGeneric(first);
+}
+Token* findLambdaEndToken(Token* first)
+{
+    return findLambdaEndTokenGeneric(first);
+}
 
+bool isLikelyStream(const Token *stream)
+{
     if (!stream)
         return false;
 
+    if (!stream->isCpp())
+        return false;
+
     if (!Token::Match(stream->astParent(), "&|<<|>>") || !stream->astParent()->isBinaryOp())
         return false;
 
@@ -1329,9 +3334,12 @@ bool isLikelyStream(bool cpp, const Token *stream)
     return !astIsIntegral(stream, false);
 }
 
-bool isLikelyStreamRead(bool cpp, const Token *op)
+bool isLikelyStreamRead(const Token *op)
 {
-    if (!cpp)
+    if (!op)
+        return false;
+
+    if (!op->isCpp())
         return false;
 
     if (!Token::Match(op, "&|>>") || !op->isBinaryOp())
@@ -1343,499 +3351,316 @@ bool isLikelyStreamRead(bool cpp, const Token *op)
     const Token *parent = op;
     while (parent->astParent() && parent->astParent()->str() == op->str())
         parent = parent->astParent();
-    if (parent->astParent() && !Token::Match(parent->astParent(), "%oror%|&&|(|,|!"))
+    if (parent->astParent() && !Token::Match(parent->astParent(), "%oror%|&&|(|,|.|!|;|return"))
         return false;
     if (op->str() == "&" && parent->astParent())
         return false;
     if (!parent->astOperand1() || !parent->astOperand2())
         return false;
-    return (!parent->astOperand1()->valueType() || !parent->astOperand1()->valueType()->isIntegral());
-}
-
-bool isCPPCast(const Token* tok)
-{
-    return tok && Token::simpleMatch(tok->previous(), "> (") && tok->astOperand2() && tok->astOperand1() && tok->astOperand1()->str().find("_cast") != std::string::npos;
-}
-
-bool isConstVarExpression(const Token *tok)
-{
-    if (!tok)
-        return false;
-    if (Token::simpleMatch(tok->previous(), "sizeof ("))
-        return true;
-    if (Token::Match(tok->previous(), "%name% (")) {
-        std::vector<const Token *> args = getArguments(tok);
-        return std::all_of(args.begin(), args.end(), &isConstVarExpression);
-    }
-    if (isCPPCast(tok)) {
-        return isConstVarExpression(tok->astOperand2());
-    }
-    if (Token::Match(tok, "( %type%"))
-        return isConstVarExpression(tok->astOperand1());
-    if (Token::Match(tok, "%cop%|[|.")) {
-        if (tok->astOperand1() && !isConstVarExpression(tok->astOperand1()))
-            return false;
-        if (tok->astOperand2() && !isConstVarExpression(tok->astOperand2()))
-            return false;
-        return true;
-    }
-    if (Token::Match(tok, "%bool%|%num%|%str%|%char%|nullptr|NULL"))
-        return true;
-    if (tok->isEnumerator())
-        return true;
-    if (tok->variable())
-        return tok->variable()->isConst();
-    return false;
-}
-
-static const Variable *getLHSVariableRecursive(const Token *tok)
-{
-    if (!tok)
-        return nullptr;
-    if (Token::Match(tok, "*|&|&&|[")) {
-        const Variable *var = getLHSVariableRecursive(tok->astOperand1());
-        if (var || Token::simpleMatch(tok, "["))
-            return var;
-        return getLHSVariableRecursive(tok->astOperand2());
-    }
-    if (Token::Match(tok->previous(), "this . %var%"))
-        return tok->next()->variable();
-    return tok->variable();
-}
-
-const Variable *getLHSVariable(const Token *tok)
-{
-    if (!Token::Match(tok, "%assign%"))
-        return nullptr;
-    if (!tok->astOperand1())
-        return nullptr;
-    if (tok->astOperand1()->varId() > 0 && tok->astOperand1()->variable())
-        return tok->astOperand1()->variable();
-    return getLHSVariableRecursive(tok->astOperand1());
-}
-
-static bool nonLocal(const Variable* var, bool deref)
-{
-    return !var || (!var->isLocal() && !var->isArgument()) || (deref && var->isArgument() && var->isPointer()) || var->isStatic() || var->isReference() || var->isExtern();
-}
-
-static bool hasGccCompoundStatement(const Token *tok)
-{
-    if (!tok)
-        return false;
-    if (tok->str() == "{" && Token::simpleMatch(tok->previous(), "( {"))
-        return true;
-    return hasGccCompoundStatement(tok->astOperand1()) || hasGccCompoundStatement(tok->astOperand2());
-}
-
-static bool hasFunctionCall(const Token *tok)
-{
-    if (!tok)
-        return false;
-    if (Token::Match(tok, "%name% ("))
-        // todo, const/pure function?
-        return true;
-    return hasFunctionCall(tok->astOperand1()) || hasFunctionCall(tok->astOperand2());
+    return (!parent->astOperand1()->valueType() || !parent->astOperand1()->valueType()->isIntegral());
 }
 
-const Scope* PathAnalysis::findOuterScope(const Scope * scope)
+bool isCPPCast(const Token* tok)
 {
-    if (!scope)
-        return nullptr;
-    if (scope->isLocal() && scope->type != Scope::eSwitch)
-        return findOuterScope(scope->nestedIn);
-    return scope;
+    return tok && Token::simpleMatch(tok->previous(), "> (") && tok->astOperand2() && tok->astOperand1() && isCPPCastKeyword(tok->astOperand1());
 }
 
-static const Token* getCondTok(const Token* tok)
+bool isConstVarExpression(const Token *tok, const std::function<bool(const Token*)>& skipPredicate)
 {
     if (!tok)
-        return nullptr;
-    if (Token::simpleMatch(tok, "("))
-        return getCondTok(tok->previous());
-    if (Token::simpleMatch(tok, "for") && Token::simpleMatch(tok->next()->astOperand2(), ";") && tok->next()->astOperand2()->astOperand2())
-        return tok->next()->astOperand2()->astOperand2()->astOperand1();
-    if (Token::simpleMatch(tok->next()->astOperand2(), ";"))
-        return tok->next()->astOperand2()->astOperand1();
-    return tok->next()->astOperand2();
-}
-
-std::pair<bool, bool> PathAnalysis::checkCond(const Token * tok, bool& known)
-{
-    if (tok->hasKnownIntValue()) {
-        known = true;
-        return std::make_pair(tok->values().front().intvalue, !tok->values().front().intvalue);
+        return false;
+    if (tok->str() == "?" && tok->astOperand2() && tok->astOperand2()->str() == ":") // ternary operator
+        return isConstVarExpression(tok->astOperand2()->astOperand1()) && isConstVarExpression(tok->astOperand2()->astOperand2()); // left and right of ":"
+    if (skipPredicate && skipPredicate(tok))
+        return false;
+    if (Token::simpleMatch(tok->previous(), "sizeof ("))
+        return true;
+    if (Token::Match(tok->previous(), "%name% (")) {
+        if (Token::simpleMatch(tok->astOperand1(), ".") && !isConstVarExpression(tok->astOperand1(), skipPredicate))
+            return false;
+        std::vector<const Token *> args = getArguments(tok);
+        if (args.empty() && tok->previous()->function() && tok->previous()->function()->isConstexpr())
+            return true;
+        return !args.empty() && std::all_of(args.cbegin(), args.cend(), [&](const Token* t) {
+            return isConstVarExpression(t, skipPredicate);
+        });
     }
-    auto it = std::find_if(tok->values().begin(), tok->values().end(), [](const ValueFlow::Value& v) {
-        return v.isIntValue();
-    });
-    // If all possible values are the same, then assume all paths have the same value
-    if (it != tok->values().end() && std::all_of(it, tok->values().end(), [&](const ValueFlow::Value& v) {
-    if (v.isIntValue())
-            return v.intvalue == it->intvalue;
+    if (isCPPCast(tok)) {
+        return isConstVarExpression(tok->astOperand2(), skipPredicate);
+    }
+    if (Token::Match(tok, "( %type%"))
+        return isConstVarExpression(tok->astOperand1(), skipPredicate);
+    if (tok->str() == "::" && tok->hasKnownValue())
+        return isConstVarExpression(tok->astOperand2(), skipPredicate);
+    if (Token::Match(tok, "%cop%|[|.")) {
+        if (tok->astOperand1() && !isConstVarExpression(tok->astOperand1(), skipPredicate))
+            return false;
+        if (tok->astOperand2() && !isConstVarExpression(tok->astOperand2(), skipPredicate))
+            return false;
         return true;
-    })) {
-        known = false;
-        return std::make_pair(it->intvalue, !it->intvalue);
     }
-    return std::make_pair(true, true);
+    if (Token::Match(tok, "%bool%|%num%|%str%|%char%|nullptr|NULL"))
+        return true;
+    if (tok->isEnumerator())
+        return true;
+    if (tok->variable())
+        return tok->variable()->isConst() && tok->variable()->nameToken() && tok->variable()->nameToken()->hasKnownValue();
+    return false;
 }
 
-PathAnalysis::Progress PathAnalysis::forwardRecursive(const Token* tok, Info info, const std::function<PathAnalysis::Progress(const Info&)>& f) const
+static ExprUsage getFunctionUsage(const Token* tok, int indirect, const Settings& settings)
 {
-    if (!tok)
-        return Progress::Continue;
-    if (tok->astOperand1() && forwardRecursive(tok->astOperand1(), info, f) == Progress::Break)
-        return Progress::Break;
-    info.tok = tok;
-    if (f(info) == Progress::Break)
-        return Progress::Break;
-    if (tok->astOperand2() && forwardRecursive(tok->astOperand2(), info, f) == Progress::Break)
-        return Progress::Break;
-    return Progress::Continue;
-}
-
-PathAnalysis::Progress PathAnalysis::forwardRange(const Token* startToken, const Token* endToken, Info info, const std::function<PathAnalysis::Progress(const Info&)>& f) const
-{
-    for (const Token *tok = startToken; tok && tok != endToken; tok = tok->next()) {
-        if (Token::Match(tok, "asm|goto|break|continue"))
-            return Progress::Break;
-        if (Token::Match(tok, "return|throw")) {
-            forwardRecursive(tok, info, f);
-            return Progress::Break;
-        }
-        if (Token::simpleMatch(tok, "}") && Token::simpleMatch(tok->link()->previous(), ") {") && Token::Match(tok->link()->linkAt(-1)->previous(), "if|while|for (")) {
-            const Token * blockStart = tok->link()->linkAt(-1)->previous();
-            const Token * condTok = getCondTok(blockStart);
-            if (!condTok)
-                continue;
-            info.errorPath.emplace_back(condTok, "Assuming condition is true.");
-            // Traverse a loop a second time
-            if (Token::Match(blockStart, "for|while (")) {
-                const Token* endCond = blockStart->linkAt(1);
-                bool traverseLoop = true;
-                // Only traverse simple for loops
-                if (Token::simpleMatch(blockStart, "for") && !Token::Match(endCond->tokAt(-3), "; ++|--|%var% %var%|++|-- ) {"))
-                    traverseLoop = false;
-                // Traverse loop a second time
-                if (traverseLoop) {
-                    // Traverse condition
-                    if (forwardRecursive(condTok, info, f) == Progress::Break)
-                        return Progress::Break;
-                    // TODO: Should we traverse the body: forwardRange(tok->link(), tok, info, f)?
-                }
+    const bool addressOf = tok->astParent() && tok->astParent()->isUnaryOp("&");
+
+    int argnr;
+    const Token* ftok = getTokenArgumentFunction(tok, argnr);
+    if (!ftok)
+        return ExprUsage::None;
+    const Function* func = ftok->function();
+    // variable init/constructor call?
+    if (!func && ftok->variable() && ftok == ftok->variable()->nameToken()) {
+        // STL types or containers don't initialize external variables
+        if (ftok->variable()->isStlType() || (ftok->variable()->valueType() && ftok->variable()->valueType()->container))
+            return ExprUsage::Used;
+        // TODO: resolve multiple constructors
+        if (ftok->variable()->type() && ftok->variable()->type()->classScope) {
+            const int nCtor = ftok->variable()->type()->classScope->numConstructors;
+            if (nCtor == 0)
+                return ExprUsage::Used;
+            if (nCtor == 1) {
+                const Scope* scope = ftok->variable()->type()->classScope;
+                auto it = std::find_if(scope->functionList.begin(), scope->functionList.end(), [](const Function& f) {
+                    return f.isConstructor();
+                });
+                if (it != scope->functionList.end())
+                    func = &*it;
             }
         }
-        if (Token::Match(tok, "if|while|for (") && Token::simpleMatch(tok->next()->link(), ") {")) {
-            const Token * endCond = tok->next()->link();
-            const Token * endBlock = endCond->next()->link();
-            const Token * condTok = getCondTok(tok);
-            if (!condTok)
+    }
+    if (func) {
+        std::vector<const Variable*> args = getArgumentVars(ftok, argnr);
+        for (const Variable* arg : args) {
+            if (!arg)
                 continue;
-            // Traverse condition
-            if (forwardRange(tok->next(), tok->next()->link(), info, f) == Progress::Break)
-                return Progress::Break;
-            Info i = info;
-            i.known = false;
-            i.errorPath.emplace_back(condTok, "Assuming condition is true.");
-
-            // Check if condition is true or false
-            bool checkThen = false;
-            bool checkElse = false;
-            std::tie(checkThen, checkElse) = checkCond(condTok, i.known);
-
-            // Traverse then block
-            if (checkThen) {
-                if (forwardRange(endCond->next(), endBlock, i, f) == Progress::Break)
-                    return Progress::Break;
-            }
-            // Traverse else block
-            if (Token::simpleMatch(endBlock, "} else {")) {
-                if (checkElse) {
-                    i.errorPath.back().second = "Assuming condition is false.";
-                    Progress result = forwardRange(endCond->next(), endBlock, i, f);
-                    if (result == Progress::Break)
-                        return Progress::Break;
+            if (arg->isReference() || (arg->isPointer() && indirect == 1)) {
+                if (!func->hasBody())
+                    return ExprUsage::PassedByReference;
+                for (const Token* bodytok = func->functionScope->bodyStart; bodytok != func->functionScope->bodyEnd; bodytok = bodytok->next()) {
+                    if (bodytok->variable() == arg) {
+                        if (arg->isReference())
+                            return ExprUsage::PassedByReference;
+                        if (Token::Match(bodytok->astParent(), "%comp%|!"))
+                            return ExprUsage::NotUsed;
+                        return ExprUsage::PassedByReference;
+                    }
                 }
-                tok = endBlock->linkAt(2);
-            } else {
-                tok = endBlock;
+                return ExprUsage::NotUsed;
             }
-        } else if (Token::simpleMatch(tok, "} else {")) {
-            tok = tok->linkAt(2);
-        } else {
-            info.tok = tok;
-            if (f(info) == Progress::Break)
-                return Progress::Break;
         }
-        // Prevent infinite recursion
-        if (tok->next() == start)
-            break;
+        if (!args.empty() && indirect == 0 && !addressOf)
+            return ExprUsage::Used;
+    } else if (ftok->isControlFlowKeyword()) {
+        return ExprUsage::Used;
+    } else if (ftok->str() == "{") {
+        return indirect == 0 ? ExprUsage::Used : ExprUsage::Inconclusive;
+    } else {
+        const bool isnullbad = settings.library.isnullargbad(ftok, argnr + 1);
+        if (indirect == 0 && astIsPointer(tok) && !addressOf && isnullbad)
+            return ExprUsage::Used;
+        bool hasIndirect = false;
+        const bool isuninitbad = settings.library.isuninitargbad(ftok, argnr + 1, indirect, &hasIndirect);
+        if (isuninitbad && (!addressOf || isnullbad))
+            return ExprUsage::Used;
     }
-    return Progress::Continue;
-}
-
-void PathAnalysis::forward(const std::function<Progress(const Info&)>& f) const
-{
-    const Scope * endScope = findOuterScope(start->scope());
-    if (!endScope)
-        return;
-    const Token * endToken = endScope->bodyEnd;
-    Info info{start, ErrorPath{}, true};
-    forwardRange(start, endToken, info, f);
+    return ExprUsage::Inconclusive;
 }
 
-bool reaches(const Token * start, const Token * dest, const Library& library, ErrorPath* errorPath)
+bool isLeafDot(const Token* tok)
 {
-    PathAnalysis::Info info = PathAnalysis{start, library} .forwardFind([&](const PathAnalysis::Info& i) {
-        return (i.tok == dest);
-    });
-    if (!info.tok)
+    if (!tok)
         return false;
-    if (errorPath)
-        errorPath->insert(errorPath->end(), info.errorPath.begin(), info.errorPath.end());
-    return true;
+    const Token * parent = tok->astParent();
+    if (!Token::simpleMatch(parent, "."))
+        return false;
+    if (parent->astOperand2() == tok && !Token::simpleMatch(parent->astParent(), "."))
+        return true;
+    return isLeafDot(parent);
 }
 
-static bool isUnchanged(const Token *startToken, const Token *endToken, const std::set<int> &exprVarIds, bool local)
+ExprUsage getExprUsage(const Token* tok, int indirect, const Settings& settings)
 {
-    for (const Token *tok = startToken; tok != endToken; tok = tok->next()) {
-        if (!local && Token::Match(tok, "%name% (") && !Token::simpleMatch(tok->linkAt(1), ") {"))
-            // TODO: this is a quick bailout
-            return false;
-        if (tok->varId() <= 0 || exprVarIds.find(tok->varId()) == exprVarIds.end())
-            continue;
-        const Token *parent = tok;
-        while (parent->astParent() && !parent->astParent()->isAssignmentOp() && parent->astParent()->tokType() != Token::Type::eIncDecOp) {
-            if (parent->str() == "," || parent->isUnaryOp("&"))
-                // TODO: This is a quick bailout
-                return false;
+    const Token* parent = tok->astParent();
+    if (indirect > 0 && parent) {
+        while (Token::simpleMatch(parent, "[") && parent->astParent())
             parent = parent->astParent();
+        if (Token::Match(parent, "%assign%") && (astIsRHS(tok) || astIsLHS(parent->astOperand1())))
+            return ExprUsage::NotUsed;
+        if (Token::Match(parent, "++|--"))
+            return ExprUsage::NotUsed;
+        if (parent->isConstOp())
+            return ExprUsage::NotUsed;
+        if (parent->isCast())
+            return ExprUsage::NotUsed;
+        if (Token::simpleMatch(parent, ":") && Token::simpleMatch(parent->astParent(), "?"))
+            return getExprUsage(parent->astParent(), indirect, settings);
+        if (isUsedAsBool(tok, settings))
+            return ExprUsage::NotUsed;
+    }
+    if (tok->isUnaryOp("&") && !parent)
+        return ExprUsage::NotUsed;
+    if (indirect == 0) {
+        if (Token::Match(parent, "%cop%|%assign%|++|--") && parent->str() != "=" &&
+            !parent->isUnaryOp("&") &&
+            !(astIsRHS(tok) && isLikelyStreamRead(parent)))
+            return ExprUsage::Used;
+        if (isLeafDot(tok)) {
+            const Token* op = parent->astParent();
+            while (Token::simpleMatch(op, "."))
+                op = op->astParent();
+            if (Token::Match(op, "%assign%|++|--")) {
+                if (op->str() == "=") {
+                    if (precedes(tok, op))
+                        return ExprUsage::NotUsed;
+                } else
+                    return ExprUsage::Used;
+            }
         }
-        if (parent->astParent()) {
-            if (parent->astParent()->tokType() == Token::Type::eIncDecOp)
-                return false;
-            else if (parent->astParent()->isAssignmentOp() && parent == parent->astParent()->astOperand1())
-                return false;
+        if (Token::simpleMatch(parent, "=") && astIsRHS(tok)) {
+            const Token* const lhs  = parent->astOperand1();
+            if (lhs && lhs->variable() && lhs->variable()->isReference() && lhs == lhs->variable()->nameToken())
+                return ExprUsage::NotUsed;
+            return ExprUsage::Used;
         }
+        // Function call or index
+        if (((Token::simpleMatch(parent, "(") && !parent->isCast()) || (Token::simpleMatch(parent, "[") && tok->valueType())) &&
+            (astIsLHS(tok) || Token::simpleMatch(parent, "( )")))
+            return ExprUsage::Used;
     }
-    return true;
+    return getFunctionUsage(tok, indirect, settings);
 }
 
-struct FwdAnalysis::Result FwdAnalysis::checkRecursive(const Token *expr, const Token *startToken, const Token *endToken, const std::set<int> &exprVarIds, bool local, bool inInnerClass)
+static void getLHSVariablesRecursive(std::vector<const Variable*>& vars, const Token* tok)
 {
-    // Parse the given tokens
-
-    for (const Token* tok = startToken; precedes(tok, endToken); tok = tok->next()) {
-        if (Token::simpleMatch(tok, "try {")) {
-            // TODO: handle try
-            return Result(Result::Type::BAILOUT);
-        }
-
-        if (Token::simpleMatch(tok, "break ;")) {
-            return Result(Result::Type::BREAK, tok);
-        }
-
-        if (Token::simpleMatch(tok, "goto"))
-            return Result(Result::Type::BAILOUT);
-
-        if (!inInnerClass && tok->str() == "{" && tok->scope()->isClassOrStruct()) {
-            // skip returns from local class definition
-            FwdAnalysis::Result result = checkRecursive(expr, tok, tok->link(), exprVarIds, local, true);
-            if (result.type != Result::Type::NONE)
-                return result;
-            tok=tok->link();
-        }
-
-        if (tok->str() == "continue")
-            // TODO
-            return Result(Result::Type::BAILOUT);
-
-        if (const Token *lambdaEndToken = findLambdaEndToken(tok)) {
-            tok = lambdaEndToken;
-            const Result lambdaResult = checkRecursive(expr, lambdaEndToken->link()->next(), lambdaEndToken, exprVarIds, local, inInnerClass);
-            if (lambdaResult.type == Result::Type::READ || lambdaResult.type == Result::Type::BAILOUT)
-                return lambdaResult;
-        }
-
-        if (Token::Match(tok, "return|throw")) {
-            // TODO: Handle these better
-            // Is expr variable used in expression?
-            const Token *end = tok->findExpressionStartEndTokens().second->next();
-            for (const Token *tok2 = tok; tok2 != end; tok2 = tok2->next()) {
-                if (!local && Token::Match(tok2, "%name% ("))
-                    return Result(Result::Type::READ);
-                if (tok2->varId() && exprVarIds.find(tok2->varId()) != exprVarIds.end())
-                    return Result(Result::Type::READ);
-            }
-
-            // #9167: if the return is inside an inner class, it does not tell us anything
-            if (!inInnerClass) {
-                if (!local && mWhat == What::Reassign)
-                    return Result(Result::Type::BAILOUT);
-
-                return Result(Result::Type::RETURN);
-            }
-        }
-
-        if (tok->str() == "}") {
-            // Known value => possible value
-            if (tok->scope() == expr->scope())
-                mValueFlowKnown = false;
-
-            Scope::ScopeType scopeType = tok->scope()->type;
-            if (scopeType == Scope::eWhile || scopeType == Scope::eFor || scopeType == Scope::eDo) {
-                // check condition
-                const Token *conditionStart = nullptr;
-                const Token *conditionEnd = nullptr;
-                if (Token::simpleMatch(tok->link()->previous(), ") {")) {
-                    conditionEnd = tok->link()->previous();
-                    conditionStart = conditionEnd->link();
-                } else if (Token::simpleMatch(tok->link()->previous(), "do {") && Token::simpleMatch(tok, "} while (")) {
-                    conditionStart = tok->tokAt(2);
-                    conditionEnd = conditionStart->link();
-                }
-                if (conditionStart && conditionEnd) {
-                    bool used = false;
-                    for (const Token *condTok = conditionStart; condTok != conditionEnd; condTok = condTok->next()) {
-                        if (exprVarIds.find(condTok->varId()) != exprVarIds.end())
-                            used = true;
-                    }
-                    if (used)
-                        return Result(Result::Type::BAILOUT);
-                }
-
-                // check loop body again..
-                const struct FwdAnalysis::Result &result = checkRecursive(expr, tok->link(), tok, exprVarIds, local, inInnerClass);
-                if (result.type == Result::Type::BAILOUT || result.type == Result::Type::READ)
-                    return result;
-            }
-        }
-
-        if (Token::simpleMatch(tok, "else {"))
-            tok = tok->linkAt(1);
-
-        if (Token::simpleMatch(tok, "asm ("))
-            return Result(Result::Type::BAILOUT);
-
-        if (mWhat == What::ValueFlow && (Token::Match(tok, "while|for (") || Token::simpleMatch(tok, "do {"))) {
-            const Token *bodyStart = nullptr;
-            const Token *conditionStart = nullptr;
-            if (Token::simpleMatch(tok, "do {")) {
-                bodyStart = tok->next();
-                if (Token::simpleMatch(bodyStart->link(), "} while ("))
-                    conditionStart = bodyStart->link()->tokAt(2);
-            } else {
-                conditionStart = tok->next();
-                if (Token::simpleMatch(conditionStart->link(), ") {"))
-                    bodyStart = conditionStart->link()->next();
-            }
-
-            if (!bodyStart || !conditionStart)
-                return Result(Result::Type::BAILOUT);
-
-            // Is expr changed in condition?
-            if (!isUnchanged(conditionStart, conditionStart->link(), exprVarIds, local))
-                return Result(Result::Type::BAILOUT);
+    if (!tok)
+        return;
+    if (vars.empty() && Token::Match(tok, "*|&|&&|[")) {
+        getLHSVariablesRecursive(vars, tok->astOperand1());
+        if (!vars.empty() || Token::simpleMatch(tok, "["))
+            return;
+        getLHSVariablesRecursive(vars, tok->astOperand2());
+    } else if (Token::Match(tok->previous(), "this . %var%")) {
+        getLHSVariablesRecursive(vars, tok->next());
+    } else if (Token::simpleMatch(tok, ".")) {
+        getLHSVariablesRecursive(vars, tok->astOperand1());
+        getLHSVariablesRecursive(vars, tok->astOperand2());
+    } else if (Token::simpleMatch(tok, "::")) {
+        getLHSVariablesRecursive(vars, tok->astOperand2());
+    } else if (tok->variable()) {
+        vars.push_back(tok->variable());
+    }
+}
 
-            // Is expr changed in loop body?
-            if (!isUnchanged(bodyStart, bodyStart->link(), exprVarIds, local))
-                return Result(Result::Type::BAILOUT);
-        }
+std::vector<const Variable*> getLHSVariables(const Token* tok)
+{
+    if (!Token::Match(tok, "%assign%|(|{"))
+        return {};
+    if (!tok->astOperand1())
+        return {};
+    if (tok->astOperand1()->varId() > 0 && tok->astOperand1()->variable())
+        return {tok->astOperand1()->variable()};
+    std::vector<const Variable*> result;
+    getLHSVariablesRecursive(result, tok->astOperand1());
+    return result;
+}
 
-        if (!local && Token::Match(tok, "%name% (") && !Token::simpleMatch(tok->linkAt(1), ") {")) {
-            // TODO: this is a quick bailout
-            return Result(Result::Type::BAILOUT);
-        }
+static const Token* getLHSVariableRecursive(const Token* tok)
+{
+    if (!tok)
+        return nullptr;
+    if (Token::Match(tok, "*|&|&&|[")) {
+        const Token* vartok = getLHSVariableRecursive(tok->astOperand1());
+        if ((vartok && vartok->variable()) || Token::simpleMatch(tok, "["))
+            return vartok;
+        return getLHSVariableRecursive(tok->astOperand2());
+    }
+    if (Token::Match(tok->previous(), "this . %var%"))
+        return tok->next();
+    return tok;
+}
 
-        if (expr->isName() && Token::Match(tok, "%name% (") && tok->str().find("<") != std::string::npos && tok->str().find(expr->str()) != std::string::npos)
-            return Result(Result::Type::BAILOUT);
+const Variable *getLHSVariable(const Token *tok)
+{
+    if (!tok || !tok->isAssignmentOp())
+        return nullptr;
+    if (!tok->astOperand1())
+        return nullptr;
+    if (tok->astOperand1()->varId() > 0 && tok->astOperand1()->variable())
+        return tok->astOperand1()->variable();
+    const Token* vartok = getLHSVariableRecursive(tok->astOperand1());
+    if (!vartok)
+        return nullptr;
+    return vartok->variable();
+}
 
-        if (exprVarIds.find(tok->varId()) != exprVarIds.end()) {
-            const Token *parent = tok;
-            bool other = false;
-            bool same = tok->astParent() && isSameExpression(mCpp, false, expr, tok, mLibrary, true, false, nullptr);
-            while (!same && Token::Match(parent->astParent(), "*|.|::|[|(|%cop%")) {
-                parent = parent->astParent();
-                if (parent && isSameExpression(mCpp, false, expr, parent, mLibrary, true, false, nullptr)) {
-                    same = true;
-                    if (mWhat == What::ValueFlow) {
-                        KnownAndToken v;
-                        v.known = mValueFlowKnown;
-                        v.token = parent;
-                        mValueFlow.push_back(v);
-                    }
-                }
-                if (Token::Match(parent, ". %var%") && parent->next()->varId() && exprVarIds.find(parent->next()->varId()) == exprVarIds.end()) {
-                    other = true;
-                    break;
-                }
-            }
-            if (mWhat != What::ValueFlow && same && Token::simpleMatch(parent->astParent(), "[") && parent == parent->astParent()->astOperand2()) {
-                return Result(Result::Type::READ);
-            }
-            if (other)
-                continue;
-            if (Token::simpleMatch(parent->astParent(), "=") && parent == parent->astParent()->astOperand1()) {
-                if (!local && hasFunctionCall(parent->astParent()->astOperand2())) {
-                    // TODO: this is a quick bailout
-                    return Result(Result::Type::BAILOUT);
-                }
-                if (hasOperand(parent->astParent()->astOperand2(), expr)) {
-                    if (mWhat == What::Reassign)
-                        return Result(Result::Type::READ);
-                    continue;
-                }
-                // ({ .. })
-                if (hasGccCompoundStatement(parent->astParent()->astOperand2()))
-                    return Result(Result::Type::BAILOUT);
-                const bool reassign = isSameExpression(mCpp, false, expr, parent, mLibrary, false, false, nullptr);
-                if (reassign)
-                    return Result(Result::Type::WRITE, parent->astParent());
-                return Result(Result::Type::READ);
-            } else if (mWhat == What::Reassign && parent->valueType() && parent->valueType()->pointer && Token::Match(parent->astParent(), "%assign%") && parent == parent->astParent()->astOperand1()) {
-                return Result(Result::Type::READ);
-            } else if (Token::Match(parent->astParent(), "%assign%") && !parent->astParent()->astParent() && parent == parent->astParent()->astOperand1()) {
-                continue;
-            } else {
-                // TODO: this is a quick bailout
-                return Result(Result::Type::BAILOUT, parent->astParent());
-            }
-        }
+const Token* getLHSVariableToken(const Token* tok)
+{
+    if (!Token::Match(tok, "%assign%"))
+        return nullptr;
+    if (!tok->astOperand1())
+        return nullptr;
+    if (tok->astOperand1()->varId() > 0)
+        return tok->astOperand1();
+    const Token* vartok = getLHSVariableRecursive(tok->astOperand1());
+    if (vartok && vartok->variable() && vartok->variable()->nameToken() == vartok)
+        return vartok;
+    return tok->astOperand1();
+}
 
-        if (Token::simpleMatch(tok, ") {")) {
-            if (Token::simpleMatch(tok->link()->previous(), "switch ("))
-                // TODO: parse switch
-                return Result(Result::Type::BAILOUT);
-            const Result &result1 = checkRecursive(expr, tok->tokAt(2), tok->linkAt(1), exprVarIds, local, inInnerClass);
-            if (result1.type == Result::Type::READ || result1.type == Result::Type::BAILOUT)
-                return result1;
-            if (mWhat == What::ValueFlow && result1.type == Result::Type::WRITE)
-                mValueFlowKnown = false;
-            if (Token::simpleMatch(tok->linkAt(1), "} else {")) {
-                const Token *elseStart = tok->linkAt(1)->tokAt(2);
-                const Result &result2 = checkRecursive(expr, elseStart, elseStart->link(), exprVarIds, local, inInnerClass);
-                if (mWhat == What::ValueFlow && result2.type == Result::Type::WRITE)
-                    mValueFlowKnown = false;
-                if (result2.type == Result::Type::READ || result2.type == Result::Type::BAILOUT)
-                    return result2;
-                if (result1.type == Result::Type::WRITE && result2.type == Result::Type::WRITE)
-                    return result1;
-                tok = elseStart->link();
-            } else {
-                tok = tok->linkAt(1);
-            }
-        }
+const Token* findAllocFuncCallToken(const Token *expr, const Library &library)
+{
+    if (!expr)
+        return nullptr;
+    if (Token::Match(expr, "[+-]")) {
+        const Token *tok1 = findAllocFuncCallToken(expr->astOperand1(), library);
+        return tok1 ? tok1 : findAllocFuncCallToken(expr->astOperand2(), library);
     }
+    if (expr->isCast())
+        return findAllocFuncCallToken(expr->astOperand2() ? expr->astOperand2() : expr->astOperand1(), library);
+    if (Token::Match(expr->previous(), "%name% (") && library.getAllocFuncInfo(expr->astOperand1()))
+        return expr->astOperand1();
+    return (Token::simpleMatch(expr, "new") && expr->astOperand1()) ? expr : nullptr;
+}
 
-    return Result(Result::Type::NONE);
+bool isNullOperand(const Token *expr)
+{
+    if (!expr)
+        return false;
+    if (expr->isCpp() && Token::Match(expr, "static_cast|const_cast|dynamic_cast|reinterpret_cast <"))
+        expr = expr->astParent();
+    else if (!expr->isCast())
+        return Token::Match(expr, "NULL|nullptr");
+    if (expr->valueType() && expr->valueType()->pointer == 0)
+        return false;
+    const Token *castOp = expr->astOperand2() ? expr->astOperand2() : expr->astOperand1();
+    return Token::Match(castOp, "NULL|nullptr") || (MathLib::isInt(castOp->str()) && MathLib::isNullValue(castOp->str()));
 }
 
-bool FwdAnalysis::isGlobalData(const Token *expr) const
+bool isGlobalData(const Token *expr)
 {
+    // function call that returns reference => assume global data
+    if (expr && expr->str() == "(" && expr->valueType() && expr->valueType()->reference != Reference::None) {
+        if (expr->isBinaryOp())
+            return true;
+        if (expr->astOperand1() && precedes(expr->astOperand1(), expr))
+            return true;
+    }
+
     bool globalData = false;
+    bool var = false;
     visitAstNodes(expr,
-    [&](const Token *tok) {
+                  [expr, &globalData, &var](const Token *tok) {
+        if (tok->varId())
+            var = true;
         if (tok->varId() && !tok->variable()) {
             // Bailout, this is probably global
             globalData = true;
@@ -1845,22 +3670,25 @@ bool FwdAnalysis::isGlobalData(const Token *expr) const
             // TODO check if pointer points at local data
             globalData = true;
             return ChildrenToVisit::none;
-        } else if (Token::Match(tok, "[*[]") && tok->astOperand1() && tok->astOperand1()->variable()) {
+        }
+        if (Token::Match(tok, "[*[]") && tok->astOperand1() && tok->astOperand1()->variable()) {
             // TODO check if pointer points at local data
             const Variable *lhsvar = tok->astOperand1()->variable();
             const ValueType *lhstype = tok->astOperand1()->valueType();
-            if (lhsvar->isPointer()) {
+            if (lhsvar->isPointer() || !lhstype || lhstype->type == ValueType::Type::ITERATOR) {
                 globalData = true;
                 return ChildrenToVisit::none;
-            } else if (lhsvar->isArgument() && lhsvar->isArray()) {
+            }
+            if (lhsvar->isArgument() && lhsvar->isArray()) {
                 globalData = true;
                 return ChildrenToVisit::none;
-            } else if (lhsvar->isArgument() && (!lhstype || (lhstype->type <= ValueType::Type::VOID && !lhstype->container))) {
+            }
+            if (lhsvar->isArgument() && lhstype->type <= ValueType::Type::VOID && !lhstype->container) {
                 globalData = true;
                 return ChildrenToVisit::none;
             }
         }
-        if (tok->varId() == 0 && tok->isName() && tok->previous()->str() != ".") {
+        if (tok->varId() == 0 && tok->isName() && tok->strAt(-1) != ".") {
             globalData = true;
             return ChildrenToVisit::none;
         }
@@ -1874,7 +3702,7 @@ bool FwdAnalysis::isGlobalData(const Token *expr) const
                 globalData = true;
                 return ChildrenToVisit::none;
             }
-            if (tok->previous()->str() != "." && !tok->variable()->isLocal() && !tok->variable()->isArgument()) {
+            if (tok->strAt(-1) != "." && !tok->variable()->isLocal() && !tok->variable()->isArgument()) {
                 globalData = true;
                 return ChildrenToVisit::none;
             }
@@ -1888,7 +3716,7 @@ bool FwdAnalysis::isGlobalData(const Token *expr) const
             }
         }
         // Unknown argument type => it might be some reference type..
-        if (mCpp && tok->str() == "." && tok->astOperand1() && tok->astOperand1()->variable() && !tok->astOperand1()->valueType()) {
+        if (tok->isCpp() && tok->str() == "." && tok->astOperand1() && tok->astOperand1()->variable() && !tok->astOperand1()->valueType()) {
             globalData = true;
             return ChildrenToVisit::none;
         }
@@ -1896,177 +3724,179 @@ bool FwdAnalysis::isGlobalData(const Token *expr) const
             return ChildrenToVisit::op1;
         return ChildrenToVisit::op1_and_op2;
     });
-    return globalData;
+    return globalData || !var;
 }
 
-std::set<int> FwdAnalysis::getExprVarIds(const Token* expr, bool* localOut, bool* unknownVarIdOut) const
+bool isUnevaluated(const Token *tok)
 {
-    // all variable ids in expr.
-    std::set<int> exprVarIds;
-    bool local = true;
-    bool unknownVarId = false;
-    visitAstNodes(expr,
-    [&](const Token *tok) {
-        if (tok->varId() == 0 && tok->isName() && tok->previous()->str() != ".") {
-            // unknown variable
-            unknownVarId = true;
-            return ChildrenToVisit::none;
+    return Token::Match(tok, "alignof|_Alignof|_alignof|__alignof|__alignof__|decltype|offsetof|sizeof|typeid|typeof|__typeof__ (");
+}
+
+static std::set<MathLib::bigint> getSwitchValues(const Token *startbrace, bool &hasDefault)
+{
+    std::set<MathLib::bigint> values;
+    const Token *endbrace = startbrace->link();
+    if (!endbrace)
+        return values;
+
+    hasDefault = false;
+    for (const Token *tok = startbrace->next(); tok && tok != endbrace; tok = tok->next()) {
+        if (Token::simpleMatch(tok, "{") && tok->scope()->type == ScopeType::eSwitch) {
+            tok = tok->link();
+            continue;
         }
-        if (tok->varId() > 0) {
-            exprVarIds.insert(tok->varId());
-            if (!Token::simpleMatch(tok->previous(), ".")) {
-                const Variable *var = tok->variable();
-                if (var && var->isReference() && var->isLocal() && Token::Match(var->nameToken(), "%var% [=(]") && !isGlobalData(var->nameToken()->next()->astOperand2()))
-                    return ChildrenToVisit::none;
-                const bool deref = tok->astParent() && (tok->astParent()->isUnaryOp("*") || (tok->astParent()->str() == "[" && tok == tok->astParent()->astOperand1()));
-                local &= !nonLocal(tok->variable(), deref);
-            }
+        if (Token::simpleMatch(tok, "default")) {
+            hasDefault = true;
+            break;
         }
-        return ChildrenToVisit::op1_and_op2;
-    });
-    if (localOut)
-        *localOut = local;
-    if (unknownVarIdOut)
-        *unknownVarIdOut = unknownVarId;
-    return exprVarIds;
+        if (Token::simpleMatch(tok, "case")) {
+            const Token *valueTok = tok->astOperand1();
+            if (const ValueFlow::Value* v = valueTok->getKnownValue(ValueFlow::Value::ValueType::INT))
+                values.insert(v->intvalue);
+            continue;
+        }
+    }
+
+    return values;
 }
 
-FwdAnalysis::Result FwdAnalysis::check(const Token* expr, const Token* startToken, const Token* endToken)
+bool isExhaustiveSwitch(const Token *startbrace)
 {
-    // all variable ids in expr.
-    bool local = true;
-    bool unknownVarId = false;
-    std::set<int> exprVarIds = getExprVarIds(expr, &local, &unknownVarId);
+    if (!startbrace || !Token::simpleMatch(startbrace->previous(), ") {") || startbrace->scope()->type != ScopeType::eSwitch)
+        return false;
+    const Token *rpar = startbrace->previous();
+    const Token *lpar = rpar->link();
+
+    const Token *condition = lpar->astOperand2();
+    if (!condition->valueType())
+        return true;
 
-    if (unknownVarId)
-        return Result(FwdAnalysis::Result::Type::BAILOUT);
+    bool hasDefault = false;
+    const std::set<MathLib::bigint> switchValues = getSwitchValues(startbrace, hasDefault);
 
-    if (mWhat == What::Reassign && isGlobalData(expr))
-        local = false;
+    if (hasDefault)
+        return true;
+
+    if (condition->valueType()->type == ValueType::Type::BOOL)
+        return switchValues.count(0) && switchValues.count(1);
 
-    // In unused values checking we do not want to check assignments to
-    // global data.
-    if (mWhat == What::UnusedValue && isGlobalData(expr))
-        return Result(FwdAnalysis::Result::Type::BAILOUT);
+    if (condition->valueType()->isEnum()) {
+        const std::vector<Enumerator> &enumList = condition->valueType()->typeScope->enumeratorList;
+        return std::all_of(enumList.cbegin(), enumList.cend(), [&](const Enumerator &e) {
+            return !e.value_known || switchValues.count(e.value);
+        });
+    }
 
-    Result result = checkRecursive(expr, startToken, endToken, exprVarIds, local, false);
+    return false;
+}
 
-    // Break => continue checking in outer scope
-    while (mWhat!=What::ValueFlow && result.type == FwdAnalysis::Result::Type::BREAK) {
-        const Scope *s = result.token->scope();
-        while (s->type == Scope::eIf)
-            s = s->nestedIn;
-        if (s->type != Scope::eSwitch && s->type != Scope::eWhile && s->type != Scope::eFor)
+bool isUnreachableOperand(const Token *tok)
+{
+    for (;;)
+    {
+        const Token *parent = tok->astParent();
+        if (!parent)
             break;
-        result = checkRecursive(expr, s->bodyEnd->next(), endToken, exprVarIds, local, false);
+
+        if (parent->isBinaryOp()) {
+            const bool left = tok == parent->astOperand1();
+            const Token *sibling = left ? parent->astOperand2() : parent->astOperand1();
+
+            // logical and
+            if (Token::simpleMatch(parent, "&&") && !left && sibling->hasKnownIntValue()
+                && !sibling->getKnownIntValue())
+                return true;
+
+            // logical or
+            if (Token::simpleMatch(parent, "||") && !left && sibling->hasKnownIntValue()
+                && sibling->getKnownIntValue())
+                return true;
+
+            // ternary
+            if (Token::simpleMatch(parent, ":") && Token::simpleMatch(parent->astParent(), "?")) {
+                const Token *condTok = parent->astParent()->astOperand1();
+                if (condTok->hasKnownIntValue() && static_cast<bool>(condTok->getKnownIntValue()) != left)
+                    return true;
+            }
+        }
+
+        tok = parent;
     }
 
-    return result;
+    return false;
 }
 
-bool FwdAnalysis::hasOperand(const Token *tok, const Token *lhs) const
+static bool unknownLeafValuesAreTemplateArgs(const Token *tok)
 {
     if (!tok)
-        return false;
-    if (isSameExpression(mCpp, false, tok, lhs, mLibrary, false, false, nullptr))
         return true;
-    return hasOperand(tok->astOperand1(), lhs) || hasOperand(tok->astOperand2(), lhs);
-}
 
-const Token *FwdAnalysis::reassign(const Token *expr, const Token *startToken, const Token *endToken)
-{
-    mWhat = What::Reassign;
-    Result result = check(expr, startToken, endToken);
-    return result.type == FwdAnalysis::Result::Type::WRITE ? result.token : nullptr;
-}
+    if (!tok->astOperand1() && !tok->astOperand2())
+        return tok->isTemplateArg() || tok->hasKnownIntValue();
 
-bool FwdAnalysis::unusedValue(const Token *expr, const Token *startToken, const Token *endToken)
-{
-    if (isEscapedAlias(expr))
-        return false;
-    mWhat = What::UnusedValue;
-    Result result = check(expr, startToken, endToken);
-    return (result.type == FwdAnalysis::Result::Type::NONE || result.type == FwdAnalysis::Result::Type::RETURN) && !possiblyAliased(expr, startToken);
+    return unknownLeafValuesAreTemplateArgs(tok->astOperand1())
+           && unknownLeafValuesAreTemplateArgs(tok->astOperand2());
 }
 
-std::vector<FwdAnalysis::KnownAndToken> FwdAnalysis::valueFlow(const Token *expr, const Token *startToken, const Token *endToken)
+static const Token *skipUnreachableIfBranch(const Token *tok)
 {
-    mWhat = What::ValueFlow;
-    mValueFlowKnown = true;
-    check(expr, startToken, endToken);
-    return mValueFlow;
+    const Token *condTok = tok->linkAt(-1);
+    if (!condTok)
+        return tok;
+
+    if (!Token::simpleMatch(condTok->tokAt(-1), "if") && !Token::simpleMatch(condTok->tokAt(-2), "if constexpr"))
+        return tok;
+
+    condTok = condTok->astOperand2();
+    if (!condTok)
+        return tok;
+
+    if ((condTok->hasKnownIntValue() && condTok->getKnownIntValue() == 0)
+        || (unknownLeafValuesAreTemplateArgs(condTok) && condTok->getValue(0))) {
+        tok = tok->link();
+    }
+
+    return tok;
 }
 
-bool FwdAnalysis::possiblyAliased(const Token *expr, const Token *startToken) const
+static const Token *skipUnreachableElseBranch(const Token *tok)
 {
-    if (expr->isUnaryOp("*"))
-        return true;
+    if (!Token::simpleMatch(tok->tokAt(-2), "} else {"))
+        return tok;
 
-    const bool macro = false;
-    const bool pure = false;
-    const bool followVar = false;
-    for (const Token *tok = startToken; tok; tok = tok->previous()) {
-        if (tok->str() == "{" && tok->scope()->type == Scope::eFunction)
-            break;
+    const Token *condTok = tok->linkAt(-2);
+    if (!condTok)
+        return tok;
 
-        if (Token::Match(tok, "%name% (") && !Token::Match(tok, "if|while|for")) {
-            // Is argument passed by reference?
-            const std::vector<const Token*> args = getArguments(tok);
-            for (int argnr = 0; argnr < args.size(); ++argnr) {
-                if (!Token::Match(args[argnr], "%name%|.|::"))
-                    continue;
-                if (tok->function() && tok->function()->getArgumentVar(argnr) && !tok->function()->getArgumentVar(argnr)->isReference() && !tok->function()->isConst())
-                    continue;
-                for (const Token *subexpr = expr; subexpr; subexpr = subexpr->astOperand1()) {
-                    if (isSameExpression(mCpp, macro, subexpr, args[argnr], mLibrary, pure, followVar))
-                        return true;
-                }
-            }
-            continue;
-        }
+    condTok = condTok->linkAt(-1);
+    if (!condTok)
+        return tok;
 
-        const Token *addrOf = nullptr;
-        if (Token::Match(tok, "& %name% ="))
-            addrOf = tok->tokAt(2)->astOperand2();
-        else if (tok->isUnaryOp("&"))
-            addrOf = tok->astOperand1();
-        else if (Token::simpleMatch(tok, "std :: ref ("))
-            addrOf = tok->tokAt(3)->astOperand2();
-        else
-            continue;
+    if (!Token::simpleMatch(condTok->tokAt(-1), "if (") && !Token::simpleMatch(condTok->tokAt(-2), "if constexpr ("))
+        return tok;
 
-        for (const Token *subexpr = expr; subexpr; subexpr = subexpr->astOperand1()) {
-            if (isSameExpression(mCpp, macro, subexpr, addrOf, mLibrary, pure, followVar))
-                return true;
-        }
+    condTok = condTok->astOperand2();
+
+    if ((condTok->hasKnownIntValue() && condTok->getKnownIntValue() != 0)
+        || (unknownLeafValuesAreTemplateArgs(condTok) && condTok->getValueNE(0))) {
+        tok = tok->link();
     }
-    return false;
+
+    return tok;
 }
 
-bool FwdAnalysis::isEscapedAlias(const Token* expr)
+const Token *skipUnreachableBranch(const Token *tok)
 {
-    for (const Token *subexpr = expr; subexpr; subexpr = subexpr->astOperand1()) {
-        for (const ValueFlow::Value &val : subexpr->values()) {
-            if (!val.isLocalLifetimeValue())
-                continue;
-            const Variable* var = val.tokvalue->variable();
-            if (!var)
-                continue;
-            if (!var->isLocal())
-                return true;
-            if (var->isArgument())
-                return true;
+    if (!Token::simpleMatch(tok, "{"))
+        return tok;
 
-        }
+    if (tok->scope()->type == ScopeType::eIf) {
+        return skipUnreachableIfBranch(tok);
     }
-    return false;
-}
 
-bool FwdAnalysis::isNullOperand(const Token *expr)
-{
-    if (!expr)
-        return false;
-    if (Token::Match(expr, "( %name% %name%| * )") && Token::Match(expr->astOperand1(), "0|NULL|nullptr"))
-        return true;
-    return Token::Match(expr, "NULL|nullptr");
+    if (tok->scope()->type == ScopeType::eElse) {
+        return skipUnreachableElseBranch(tok);
+    }
+
+    return tok;
 }
diff --git a/lib/astutils.h b/lib/astutils.h
index c9f2db7ab8c..5b6b878f3ae 100644
--- a/lib/astutils.h
+++ b/lib/astutils.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,20 +22,29 @@
 #define astutilsH
 //---------------------------------------------------------------------------
 
+#include <cstdint>
 #include <functional>
+#include <list>
 #include <string>
+#include <type_traits>
+#include <utility>
 #include <vector>
 
-#include "errorlogger.h"
-#include "utils.h"
+#include "config.h"
+#include "errortypes.h"
+#include "library.h"
+#include "mathlib.h"
+#include "smallvector.h"
+#include "token.h"
 
-class Library;
 class Settings;
-class Scope;
-class Token;
 class Variable;
+class ValueType;
+class Function;
+class Scope;
+enum class ScopeType : std::uint8_t;
 
-enum class ChildrenToVisit {
+enum class ChildrenToVisit : std::uint8_t {
     none,
     op1,
     op2,
@@ -46,20 +55,95 @@ enum class ChildrenToVisit {
 /**
  * Visit AST nodes recursively. The order is not "well defined"
  */
-void visitAstNodes(const Token *ast, std::function<ChildrenToVisit(const Token *)> visitor);
+template<class T, class TFunc, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+void visitAstNodes(T *ast, const TFunc &visitor)
+{
+    if (!ast)
+        return;
+
+    // the size of 8 was determined in tests to be sufficient to avoid excess allocations. also add 1 as a buffer.
+    // we might need to increase that value in the future.
+    SmallVector<T *, 8 + 1> tokens;
+    T *tok = ast;
+    do {
+        const ChildrenToVisit c = visitor(tok);
+        if (c == ChildrenToVisit::done)
+            break;
+
+        if (c == ChildrenToVisit::op2 || c == ChildrenToVisit::op1_and_op2) {
+            T *t2 = tok->astOperand2();
+            if (t2)
+                tokens.push_back(t2);
+        }
+        if (c == ChildrenToVisit::op1 || c == ChildrenToVisit::op1_and_op2) {
+            T *t1 = tok->astOperand1();
+            if (t1)
+                tokens.push_back(t1);
+        }
+
+        if (tokens.empty())
+            break;
+
+        tok = tokens.back();
+        tokens.pop_back();
+    } while (true);
+}
+
+template<class TFunc>
+const Token* findAstNode(const Token* ast, const TFunc& pred)
+{
+    const Token* result = nullptr;
+    visitAstNodes(ast, [&](const Token* tok) {
+        if (pred(tok)) {
+            result = tok;
+            return ChildrenToVisit::done;
+        }
+        return ChildrenToVisit::op1_and_op2;
+    });
+    return result;
+}
+
+template<class TFunc>
+const Token* findParent(const Token* tok, const TFunc& pred)
+{
+    if (!tok)
+        return nullptr;
+    const Token* parent = tok->astParent();
+    while (parent && !pred(parent)) {
+        parent = parent->astParent();
+    }
+    return parent;
+}
+
+const Token* findExpression(nonneg int exprid,
+                            const Token* start,
+                            const Token* end,
+                            const std::function<bool(const Token*)>& pred);
+const Token* findExpression(const Token* start, nonneg int exprid);
+
+/** Does code execution escape from the given scope? */
+const Token* findEscapeStatement(const Scope* scope, const Library& library);
 
 std::vector<const Token*> astFlatten(const Token* tok, const char* op);
+std::vector<Token*> astFlatten(Token* tok, const char* op);
+
+nonneg int astCount(const Token* tok, const char* op, int depth = 100);
 
 bool astHasToken(const Token* root, const Token * tok);
 
+bool astHasExpr(const Token* tok, nonneg int exprid);
 bool astHasVar(const Token * tok, nonneg int varid);
 
+bool astIsPrimitive(const Token* tok);
 /** Is expression a 'signed char' if no promotion is used */
 bool astIsSignedChar(const Token *tok);
 /** Is expression a 'char' if no promotion is used? */
 bool astIsUnknownSignChar(const Token *tok);
+/** Is expression a char according to valueType? */
+bool astIsGenericChar(const Token* tok);
 /** Is expression of integral type? */
 bool astIsIntegral(const Token *tok, bool unknown);
+bool astIsUnsigned(const Token* tok);
 /** Is expression of floating point type? */
 bool astIsFloat(const Token *tok, bool unknown);
 /** Is expression of boolean type? */
@@ -68,10 +152,24 @@ bool astIsBool(const Token *tok);
 bool astIsPointer(const Token *tok);
 
 bool astIsSmartPointer(const Token* tok);
+bool astIsUniqueSmartPointer(const Token* tok);
 
 bool astIsIterator(const Token *tok);
 
 bool astIsContainer(const Token *tok);
+bool astIsNonStringContainer(const Token *tok);
+
+bool astIsContainerView(const Token* tok);
+bool astIsContainerOwned(const Token* tok);
+bool astIsContainerString(const Token* tok);
+
+Library::Container::Action astContainerAction(const Token* tok, const Library& library, const Token** ftok = nullptr);
+Library::Container::Yield astContainerYield(const Token* tok, const Library& library, const Token** ftok = nullptr);
+
+Library::Container::Yield astFunctionYield(const Token* tok, const Settings& settings, const Token** ftok = nullptr);
+
+/** Is given token a range-declaration in a range-based for loop */
+bool astIsRangeBasedForDecl(const Token* tok);
 
 /**
  * Get canonical type of expression. const/static/etc are not included and neither *&.
@@ -82,50 +180,146 @@ bool astIsContainer(const Token *tok);
  * static const int     int
  * std::vector<T>       std::vector
  */
-std::string astCanonicalType(const Token *expr);
+std::string astCanonicalType(const Token *expr, bool pointedToType);
 
 /** Is given syntax tree a variable comparison against value */
 const Token * astIsVariableComparison(const Token *tok, const std::string &comp, const std::string &rhs, const Token **vartok=nullptr);
 
-const Token * nextAfterAstRightmostLeaf(const Token * tok);
+bool isVariableDecl(const Token* tok);
+bool isStlStringType(const Token* tok);
+
+bool isVoidCast(const Token* tok);
+
+bool isTemporary(const Token* tok, const Library* library, bool unknown = false);
+
+const Token* previousBeforeAstLeftmostLeaf(const Token* tok);
+Token* previousBeforeAstLeftmostLeaf(Token* tok);
+
+CPPCHECKLIB const Token * nextAfterAstRightmostLeaf(const Token * tok);
+Token* nextAfterAstRightmostLeaf(Token* tok);
 
 Token* astParentSkipParens(Token* tok);
 const Token* astParentSkipParens(const Token* tok);
 
+const Token* getParentMember(const Token * tok);
+
+const Token* getParentLifetime(const Token* tok);
+const Token* getParentLifetime(const Token* tok, const Library& library);
+
+std::vector<ValueType> getParentValueTypes(const Token* tok,
+                                           const Settings& settings,
+                                           const Token** parent = nullptr);
+
+bool astIsLHS(const Token* tok);
+bool astIsRHS(const Token* tok);
+
+Token* getCondTok(Token* tok);
+const Token* getCondTok(const Token* tok);
+
+Token* getInitTok(Token* tok);
+const Token* getInitTok(const Token* tok);
+
+Token* getStepTok(Token* tok);
+const Token* getStepTok(const Token* tok);
+
+Token* getCondTokFromEnd(Token* endBlock);
+const Token* getCondTokFromEnd(const Token* endBlock);
+
+/// For a "break" token, locate the next token to execute. The token will
+/// be either a "}" or a ";".
+const Token *findNextTokenFromBreak(const Token *breakToken);
+
+/**
+ * Extract for loop values: loopvar varid, init value, step value, last value (inclusive)
+ */
+bool extractForLoopValues(const Token *forToken,
+                          nonneg int &varid,
+                          bool &knownInitValue,
+                          MathLib::bigint &initValue,
+                          bool &partialCond,
+                          MathLib::bigint &stepValue,
+                          MathLib::bigint &lastValue);
+
 bool precedes(const Token * tok1, const Token * tok2);
+bool succeeds(const Token* tok1, const Token* tok2);
 
-bool exprDependsOnThis(const Token* expr, nonneg int depth = 0);
+bool exprDependsOnThis(const Token* expr, bool onVar = true, nonneg int depth = 0);
 
-bool isSameExpression(bool cpp, bool macro, const Token *tok1, const Token *tok2, const Library& library, bool pure, bool followVar, ErrorPath* errors=nullptr);
+struct ReferenceToken {
+    ReferenceToken(const Token* t, ErrorPath e)
+        : token(t)
+        , errors(std::move(e))
+    {}
+    const Token* token;
+    ErrorPath errors;
+};
+
+SmallVector<ReferenceToken> followAllReferences(const Token* tok, bool temporary = true);
+const Token* followReferences(const Token* tok, ErrorPath* errors = nullptr);
+
+CPPCHECKLIB bool isSameExpression(bool macro, const Token *tok1, const Token *tok2, const Settings& settings, bool pure, bool followVar, ErrorPath* errors=nullptr);
+
+bool isEqualKnownValue(const Token * tok1, const Token * tok2);
 
-bool isEqualKnownValue(const Token * const tok1, const Token * const tok2);
+bool isStructuredBindingVariable(const Variable* var);
 
-bool isDifferentKnownValues(const Token * const tok1, const Token * const tok2);
+const Token* isInLoopCondition(const Token* tok);
+
+/**
+ * Is token the dot of a designated initializer?
+ */
+bool isDesignatedInitializer(const Token* tok);
+
+/**
+ * Is token used as boolean, that is to say cast to a bool, or used as a condition in a if/while/for
+ */
+CPPCHECKLIB bool isUsedAsBool(const Token* tok, const Settings& settings);
+
+/**
+ * Are the tokens' flags equal?
+ */
+bool compareTokenFlags(const Token* tok1, const Token* tok2, bool macro);
 
 /**
  * Are two conditions opposite
  * @param isNot  do you want to know if cond1 is !cond2 or if cond1 and cond2 are non-overlapping. true: cond1==!cond2  false: cond1==true => cond2==false
- * @param cpp    c++ file
  * @param cond1  condition1
  * @param cond2  condition2
- * @param library files data
+ * @param settings settings
  * @param pure boolean
  */
-bool isOppositeCond(bool isNot, bool cpp, const Token * const cond1, const Token * const cond2, const Library& library, bool pure, bool followVar, ErrorPath* errors=nullptr);
+bool isOppositeCond(bool isNot, const Token * cond1, const Token * cond2, const Settings& settings, bool pure, bool followVar, ErrorPath* errors=nullptr);
 
-bool isOppositeExpression(bool cpp, const Token * const tok1, const Token * const tok2, const Library& library, bool pure, bool followVar, ErrorPath* errors=nullptr);
+bool isOppositeExpression(const Token * tok1, const Token * tok2, const Settings& settings, bool pure, bool followVar, ErrorPath* errors=nullptr);
 
-bool isConstExpression(const Token *tok, const Library& library, bool pure, bool cpp);
+bool isConstFunctionCall(const Token* ftok, const Library& library);
 
-bool isWithoutSideEffects(bool cpp, const Token* tok);
+bool isConstExpression(const Token *tok, const Library& library);
+
+bool isWithoutSideEffects(const Token* tok, bool checkArrayAccess = false, bool checkReference = true);
 
 bool isUniqueExpression(const Token* tok);
 
+bool isEscapeFunction(const Token* ftok, const Library& library);
+
 /** Is scope a return scope (scope will unconditionally return) */
-bool isReturnScope(const Token *endToken, const Settings * settings = nullptr, bool functionScope=false);
+CPPCHECKLIB bool isReturnScope(const Token* endToken,
+                               const Library& library,
+                               const Token** unknownFunc = nullptr,
+                               bool functionScope = false);
+
+/** Is tok within a scope of the given type, nested within var's scope? */
+bool isWithinScope(const Token* tok,
+                   const Variable* var,
+                   ScopeType type);
 
 /// Return the token to the function and the argument number
 const Token * getTokenArgumentFunction(const Token * tok, int& argn);
+Token* getTokenArgumentFunction(Token* tok, int& argn);
+
+std::vector<const Variable*> getArgumentVars(const Token* tok, int argnr);
+
+bool isMutableExpression(const Token* tok);
 
 /** Is variable changed by function call?
  * In case the answer of the question is inconclusive, e.g. because the function declaration is not known
@@ -136,7 +330,7 @@ const Token * getTokenArgumentFunction(const Token * tok, int& argn);
  * @param settings      program settings
  * @param inconclusive  pointer to output variable which indicates that the answer of the question is inconclusive
  */
-bool isVariableChangedByFunctionCall(const Token *tok, int indirect, nonneg int varid, const Settings *settings, bool *inconclusive);
+bool isVariableChangedByFunctionCall(const Token *tok, int indirect, nonneg int varid, const Settings &settings, bool *inconclusive);
 
 /** Is variable changed by function call?
  * In case the answer of the question is inconclusive, e.g. because the function declaration is not known
@@ -146,188 +340,127 @@ bool isVariableChangedByFunctionCall(const Token *tok, int indirect, nonneg int
  * @param settings      program settings
  * @param inconclusive pointer to output variable which indicates that the answer of the question is inconclusive
  */
-bool isVariableChangedByFunctionCall(const Token *tok, int indirect, const Settings *settings, bool *inconclusive);
+CPPCHECKLIB bool isVariableChangedByFunctionCall(const Token *tok, int indirect, const Settings &settings, bool *inconclusive);
 
 /** Is variable changed in block of code? */
-bool isVariableChanged(const Token *start, const Token *end, const nonneg int varid, bool globalvar, const Settings *settings, bool cpp, int depth = 20);
+CPPCHECKLIB bool isVariableChanged(const Token *start, const Token *end, nonneg int exprid, bool globalvar, const Settings &settings, int depth = 20);
+bool isVariableChanged(const Token *start, const Token *end, int indirect, nonneg int exprid, bool globalvar, const Settings &settings, int depth = 20);
 
-bool isVariableChanged(const Token *tok, int indirect, const Settings *settings, bool cpp, int depth = 20);
+bool isVariableChanged(const Token *tok, int indirect, const Settings &settings, int depth = 20);
 
-bool isVariableChanged(const Variable * var, const Settings *settings, bool cpp, int depth = 20);
+bool isVariableChanged(const Variable * var, const Settings &settings, int depth = 20);
 
 bool isVariablesChanged(const Token* start,
                         const Token* end,
                         int indirect,
-                        std::vector<const Variable*> vars,
-                        const Settings* settings,
-                        bool cpp);
-
-const Token* findVariableChanged(const Token *start, const Token *end, int indirect, const nonneg int varid, bool globalvar, const Settings *settings, bool cpp, int depth = 20);
-Token* findVariableChanged(Token *start, const Token *end, int indirect, const nonneg int varid, bool globalvar, const Settings *settings, bool cpp, int depth = 20);
+                        const std::vector<const Variable*> &vars,
+                        const Settings& settings);
+
+bool isThisChanged(const Token* tok, int indirect, const Settings& settings);
+
+const Token* findVariableChanged(const Token *start, const Token *end, int indirect, nonneg int exprid, bool globalvar, const Settings &settings, int depth = 20);
+Token* findVariableChanged(Token *start, const Token *end, int indirect, nonneg int exprid, bool globalvar, const Settings &settings, int depth = 20);
+
+CPPCHECKLIB const Token* findExpressionChanged(const Token* expr,
+                                               const Token* start,
+                                               const Token* end,
+                                               const Settings& settings,
+                                               int depth = 20);
+
+const Token* findExpressionChangedSkipDeadCode(const Token* expr,
+                                               const Token* start,
+                                               const Token* end,
+                                               const Settings& settings,
+                                               const std::function<std::vector<MathLib::bigint>(const Token* tok)>& evaluate,
+                                               int depth = 20);
+
+bool isExpressionChangedAt(const Token* expr,
+                           const Token* tok,
+                           int indirect,
+                           bool globalvar,
+                           const Settings& settings,
+                           int depth = 20);
 
 /// If token is an alias if another variable
-bool isAliasOf(const Token *tok, nonneg int varid);
+bool isAliasOf(const Token *tok, nonneg int varid, bool* inconclusive = nullptr);
 
-bool isAliased(const Variable *var);
+bool isAliasOf(const Token* tok, const Token* expr, nonneg int* indirect = nullptr);
+
+const Token* getArgumentStart(const Token* ftok);
 
 /** Determines the number of arguments - if token is a function call or macro
- * @param start token which is supposed to be the function/macro name.
- * \return Number of arguments
+ * @param ftok start token which is supposed to be the function/macro name.
+ * @return Number of arguments
  */
-int numberOfArguments(const Token *start);
+int numberOfArguments(const Token* ftok);
+
+/// Get number of arguments without using AST
+int numberOfArgumentsWithoutAst(const Token* start);
 
 /**
  * Get arguments (AST)
  */
 std::vector<const Token *> getArguments(const Token *ftok);
 
-const Token *findLambdaStartToken(const Token *last);
+int getArgumentPos(const Variable* var, const Function* f);
+
+const Token* getIteratorExpression(const Token* tok);
+
+/**
+ * Are the arguments a pair of iterators/pointers?
+ */
+bool isIteratorPair(const std::vector<const Token*>& args);
+
+CPPCHECKLIB const Token *findLambdaStartToken(const Token *last);
 
 /**
  * find lambda function end token
  * \param first The [ token
  * \return nullptr or the }
  */
-const Token *findLambdaEndToken(const Token *first);
+CPPCHECKLIB const Token *findLambdaEndToken(const Token *first);
+CPPCHECKLIB Token* findLambdaEndToken(Token* first);
 
-bool isLikelyStream(bool cpp, const Token *stream);
+bool isLikelyStream(const Token *stream);
 
 /**
  * do we see a likely write of rhs through overloaded operator
  *   s >> x;
  *   a & x;
  */
-bool isLikelyStreamRead(bool cpp, const Token *op);
+bool isLikelyStreamRead(const Token *op);
 
 bool isCPPCast(const Token* tok);
 
-bool isConstVarExpression(const Token *tok);
+bool isConstVarExpression(const Token* tok, const std::function<bool(const Token*)>& skipPredicate = nullptr);
+
+bool isLeafDot(const Token* tok);
+
+enum class ExprUsage : std::uint8_t { None, NotUsed, PassedByReference, Used, Inconclusive };
+
+ExprUsage getExprUsage(const Token* tok, int indirect, const Settings& settings);
 
 const Variable *getLHSVariable(const Token *tok);
 
+const Token* getLHSVariableToken(const Token* tok);
+
+std::vector<const Variable*> getLHSVariables(const Token* tok);
+
+/** Find a allocation function call in expression, so result of expression is allocated memory/resource. */
+const Token* findAllocFuncCallToken(const Token *expr, const Library &library);
+
 bool isScopeBracket(const Token* tok);
 
-struct PathAnalysis {
-    enum class Progress {
-        Continue,
-        Break
-    };
-    PathAnalysis(const Token* start, const Library& library)
-        : start(start), library(&library)
-    {}
-    const Token * start;
-    const Library * library;
-
-    struct Info {
-        const Token* tok;
-        ErrorPath errorPath;
-        bool known;
-    };
-
-    void forward(const std::function<Progress(const Info&)>& f) const;
-    template<class F>
-    void forwardAll(F f) {
-        forward([&](const Info& info) {
-            f(info);
-            return Progress::Continue;
-        });
-    }
-    template<class Predicate>
-    Info forwardFind(Predicate pred) {
-        Info result{};
-        forward([&](const Info& info) {
-            if (pred(info)) {
-                result = info;
-                return Progress::Break;
-            }
-            return Progress::Continue;
-        });
-        return result;
-    }
-private:
+CPPCHECKLIB bool isNullOperand(const Token *expr);
 
-    Progress forwardRecursive(const Token* tok, Info info, const std::function<PathAnalysis::Progress(const Info&)>& f) const;
-    Progress forwardRange(const Token* startToken, const Token* endToken, Info info, const std::function<Progress(const Info&)>& f) const;
+bool isGlobalData(const Token *expr);
 
-    static const Scope* findOuterScope(const Scope * scope);
+bool isUnevaluated(const Token *tok);
 
-    static std::pair<bool, bool> checkCond(const Token * tok, bool& known);
-};
+bool isExhaustiveSwitch(const Token *startbrace);
 
-/**
- * @brief Returns true if there is a path between the two tokens
- *
- * @param start Starting point of the path
- * @param dest The path destination
- * @param errorPath Adds the path traversal to the errorPath
- */
-bool reaches(const Token * start, const Token * dest, const Library& library, ErrorPath* errorPath);
+bool isUnreachableOperand(const Token *tok);
 
-/**
- * Forward data flow analysis for checks
- *  - unused value
- *  - redundant assignment
- *  - valueflow analysis
- */
-class FwdAnalysis {
-public:
-    FwdAnalysis(bool cpp, const Library &library) : mCpp(cpp), mLibrary(library), mWhat(What::Reassign), mValueFlowKnown(true) {}
-
-    bool hasOperand(const Token *tok, const Token *lhs) const;
-
-    /**
-     * Check if "expr" is reassigned. The "expr" can be a tree (x.y[12]).
-     * @param expr Symbolic expression to perform forward analysis for
-     * @param startToken First token in forward analysis
-     * @param endToken Last token in forward analysis
-     * @return Token where expr is reassigned. If it's not reassigned then nullptr is returned.
-     */
-    const Token *reassign(const Token *expr, const Token *startToken, const Token *endToken);
-
-    /**
-     * Check if "expr" is used. The "expr" can be a tree (x.y[12]).
-     * @param expr Symbolic expression to perform forward analysis for
-     * @param startToken First token in forward analysis
-     * @param endToken Last token in forward analysis
-     * @return true if expr is used.
-     */
-    bool unusedValue(const Token *expr, const Token *startToken, const Token *endToken);
-
-    struct KnownAndToken {
-        bool known;
-        const Token *token;
-    };
-
-    std::vector<KnownAndToken> valueFlow(const Token *expr, const Token *startToken, const Token *endToken);
-
-    /** Is there some possible alias for given expression */
-    bool possiblyAliased(const Token *expr, const Token *startToken) const;
-
-    std::set<int> getExprVarIds(const Token* expr, bool* localOut = nullptr, bool* unknownVarIdOut = nullptr) const;
-
-    static bool isNullOperand(const Token *expr);
-private:
-    static bool isEscapedAlias(const Token* expr);
-
-    /** Result of forward analysis */
-    struct Result {
-        enum class Type { NONE, READ, WRITE, BREAK, RETURN, BAILOUT } type;
-        explicit Result(Type type) : type(type), token(nullptr) {}
-        Result(Type type, const Token *token) : type(type), token(token) {}
-        const Token *token;
-    };
-
-    struct Result check(const Token *expr, const Token *startToken, const Token *endToken);
-    struct Result checkRecursive(const Token *expr, const Token *startToken, const Token *endToken, const std::set<int> &exprVarIds, bool local, bool inInnerClass);
-
-    // Is expression a l-value global data?
-    bool isGlobalData(const Token *expr) const;
-
-    const bool mCpp;
-    const Library &mLibrary;
-    enum class What { Reassign, UnusedValue, ValueFlow } mWhat;
-    std::vector<KnownAndToken> mValueFlow;
-    bool mValueFlowKnown;
-};
+const Token *skipUnreachableBranch(const Token *tok);
 
 #endif // astutilsH
diff --git a/lib/calculate.h b/lib/calculate.h
new file mode 100644
index 00000000000..c33e37fd3b7
--- /dev/null
+++ b/lib/calculate.h
@@ -0,0 +1,130 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef calculateH
+#define calculateH
+
+#include "mathlib.h"
+#include "errortypes.h"
+#include <limits>
+#include <string>
+
+template<class T>
+bool isEqual(T x, T y)
+{
+    return x == y;
+}
+
+inline bool isEqual(double x, double y)
+{
+    const double diff = (x > y) ? x - y : y - x;
+    return !((diff / 2) < diff);
+}
+inline bool isEqual(float x, float y)
+{
+    return isEqual(double(x), double(y));
+}
+
+template<class T>
+bool isZero(T x)
+{
+    return isEqual(x, T(0));
+}
+
+/**
+ * @throws InternalError thrown in case of unknown operator
+ */
+template<class R, class T>
+R calculate(const std::string& s, const T& x, const T& y, bool* error = nullptr)
+{
+    auto wrap = [](T z) {
+        return R{z};
+    };
+    constexpr MathLib::bigint maxBitsShift = sizeof(MathLib::bigint) * 8;
+    // For portability we cannot shift signed integers by 63 bits
+    constexpr MathLib::bigint maxBitsSignedShift = maxBitsShift - 1;
+    switch (MathLib::encodeMultiChar(s)) {
+    case '+':
+        return wrap(x + y);
+    case '-':
+        return wrap(x - y);
+    case '*':
+        return wrap(x * y);
+    case '/':
+        if (isZero(y) || (std::is_signed<T>{} && y < 0)) {
+            if (error)
+                *error = true;
+            return R{};
+        }
+        return wrap(x / y);
+    case '%':
+        if (isZero(MathLib::bigint(y)) || (std::is_signed<T>{} && MathLib::bigint(y) < 0)) {
+            if (error)
+                *error = true;
+            return R{};
+        }
+        return wrap(MathLib::bigint(x) % MathLib::bigint(y));
+    case '&':
+        return wrap(MathLib::bigint(x) & MathLib::bigint(y));
+    case '|':
+        return wrap(MathLib::bigint(x) | MathLib::bigint(y));
+    case '^':
+        return wrap(MathLib::bigint(x) ^ MathLib::bigint(y));
+    case '>':
+        return wrap(x > y);
+    case '<':
+        return wrap(x < y);
+    case '<<':
+        if (y >= maxBitsSignedShift || y < 0 || x < 0) {
+            if (error)
+                *error = true;
+            return R{};
+        }
+        return wrap(MathLib::bigint(x) << MathLib::bigint(y));
+    case '>>':
+        if (y >= maxBitsSignedShift || y < 0 || x < 0) {
+            if (error)
+                *error = true;
+            return R{};
+        }
+        return wrap(MathLib::bigint(x) >> MathLib::bigint(y));
+    case '&&':
+        return wrap(!isZero(x) && !isZero(y));
+    case '||':
+        return wrap(!isZero(x) || !isZero(y));
+    case '==':
+        return wrap(isEqual(x, y));
+    case '!=':
+        return wrap(!isEqual(x, y));
+    case '>=':
+        return wrap(x >= y);
+    case '<=':
+        return wrap(x <= y);
+    case '<=>':
+        return wrap(x - y);
+    }
+    throw InternalError(nullptr, "Unknown operator: " + s);
+}
+
+template<class T>
+T calculate(const std::string& s, const T& x, const T& y, bool* error = nullptr)
+{
+    return calculate<T, T>(s, x, y, error);
+}
+
+#endif
diff --git a/lib/check.cpp b/lib/check.cpp
index 6dc506e8156..58b8dbfe0e1 100644
--- a/lib/check.cpp
+++ b/lib/check.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,38 +20,72 @@
 
 #include "check.h"
 
+#include "errorlogger.h"
+#include "settings.h"
+#include "token.h"
+#include "tokenize.h"
+#include "vfvalue.h"
+
+#include <algorithm>
+#include <cctype>
 #include <iostream>
+#include <stdexcept>
+#include <utility>
 
 //---------------------------------------------------------------------------
 
 Check::Check(const std::string &aname)
-    : mTokenizer(nullptr), mSettings(nullptr), mErrorLogger(nullptr), mName(aname)
+    : mName(aname)
 {
-    for (std::list<Check*>::iterator i = instances().begin(); i != instances().end(); ++i) {
-        if ((*i)->name() > aname) {
-            instances().insert(i, this);
-            return;
-        }
+    {
+        const auto it = std::find_if(instances().begin(), instances().end(), [&](const Check *i) {
+            return i->name() == aname;
+        });
+        if (it != instances().end())
+            throw std::runtime_error("'" + aname + "' instance already exists");
     }
-    instances().push_back(this);
+
+    // make sure the instances are sorted
+    const auto it = std::find_if(instances().begin(), instances().end(), [&](const Check* i) {
+        return i->name() > aname;
+    });
+    if (it == instances().end())
+        instances().push_back(this);
+    else
+        instances().insert(it, this);
 }
 
-void Check::reportError(const ErrorLogger::ErrorMessage &errmsg)
+void Check::writeToErrorList(const ErrorMessage &errmsg)
 {
     std::cout << errmsg.toXML() << std::endl;
 }
 
-bool Check::wrongData(const Token *tok, bool condition, const char *str)
+
+void Check::reportError(const std::list<const Token *> &callstack, Severity severity, const std::string &id, const std::string &msg, const CWE &cwe, Certainty certainty)
+{
+    // TODO: report debug warning when error is for a disabled severity
+    const ErrorMessage errmsg(callstack, mTokenizer ? &mTokenizer->list : nullptr, severity, id, msg, cwe, certainty);
+    if (mErrorLogger)
+        mErrorLogger->reportErr(errmsg);
+    else
+        writeToErrorList(errmsg);
+}
+
+void Check::reportError(ErrorPath errorPath, Severity severity, const char id[], const std::string &msg, const CWE &cwe, Certainty certainty)
 {
-#if defined(DACA2) || defined(UNSTABLE)
-    if (condition) {
+    // TODO: report debug warning when error is for a disabled severity
+    const ErrorMessage errmsg(std::move(errorPath), mTokenizer ? &mTokenizer->list : nullptr, severity, id, msg, cwe, certainty);
+    if (mErrorLogger)
+        mErrorLogger->reportErr(errmsg);
+    else
+        writeToErrorList(errmsg);
+}
+
+bool Check::wrongData(const Token *tok, const char *str)
+{
+    if (mSettings->daca)
         reportError(tok, Severity::debug, "DacaWrongData", "Wrong data detected by condition " + std::string(str));
-    }
-#else
-    (void)tok;
-    (void)str;
-#endif
-    return condition;
+    return true;
 }
 
 std::list<Check *> &Check::instances()
@@ -72,6 +106,30 @@ std::string Check::getMessageId(const ValueFlow::Value &value, const char id[])
     if (value.condition != nullptr)
         return id + std::string("Cond");
     if (value.safe)
-        return std::string("safe") + (char)std::toupper(id[0]) + (id + 1);
+        return std::string("safe") + static_cast<char>(std::toupper(id[0])) + (id + 1);
     return id;
 }
+
+ErrorPath Check::getErrorPath(const Token* errtok, const ValueFlow::Value* value, std::string bug) const
+{
+    ErrorPath errorPath;
+    if (!value) {
+        errorPath.emplace_back(errtok, std::move(bug));
+    } else if (mSettings->verbose || mSettings->outputFormat == Settings::OutputFormat::xml || !mSettings->templateLocation.empty()) {
+        errorPath = value->errorPath;
+        errorPath.emplace_back(errtok, std::move(bug));
+    } else {
+        if (value->condition)
+            errorPath.emplace_back(value->condition, "condition '" + value->condition->expressionString() + "'");
+        //else if (!value->isKnown() || value->defaultArg)
+        //    errorPath = value->callstack;
+        errorPath.emplace_back(errtok, std::move(bug));
+    }
+    return errorPath;
+}
+
+void Check::logChecker(const char id[])
+{
+    reportError(nullptr, Severity::internal, "logChecker", id);
+}
+
diff --git a/lib/check.h b/lib/check.h
index e2784f0862f..4e3c5b9a4e3 100644
--- a/lib/check.h
+++ b/lib/check.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,14 +22,11 @@
 //---------------------------------------------------------------------------
 
 #include "config.h"
-#include "errorlogger.h"
-#include "settings.h"
-#include "token.h"
-#include "tokenize.h"
-#include "valueflow.h"
+#include "errortypes.h"
 
 #include <list>
 #include <string>
+#include <utility>
 
 namespace tinyxml2 {
     class XMLElement;
@@ -39,8 +36,18 @@ namespace CTU {
     class FileInfo;
 }
 
+namespace ValueFlow {
+    class Value;
+}
+
+class Settings;
+class Token;
+class ErrorLogger;
+class ErrorMessage;
+class Tokenizer;
+
 /** Use WRONG_DATA in checkers to mark conditions that check that data is correct */
-#define WRONG_DATA(COND, TOK)  (wrongData((TOK), (COND), #COND))
+#define WRONG_DATA(COND, TOK)  ((COND) && wrongData((TOK), #COND))
 
 /// @addtogroup Core
 /// @{
@@ -54,21 +61,25 @@ class CPPCHECKLIB Check {
     /** This constructor is used when registering the CheckClass */
     explicit Check(const std::string &aname);
 
+protected:
     /** This constructor is used when running checks. */
-    Check(const std::string &aname, const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : mTokenizer(tokenizer), mSettings(settings), mErrorLogger(errorLogger), mName(aname) {
-    }
+    Check(std::string aname, const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
+        : mTokenizer(tokenizer), mSettings(settings), mErrorLogger(errorLogger), mName(std::move(aname)) {}
 
+public:
     virtual ~Check() {
         if (!mTokenizer)
             instances().remove(this);
     }
 
+    Check(const Check &) = delete;
+    Check& operator=(const Check &) = delete;
+
     /** List of registered check classes. This is used by Cppcheck to run checks and generate documentation */
     static std::list<Check *> &instances();
 
     /** run checks, the token list is not simplified */
-    virtual void runChecks(const Tokenizer *, const Settings *, ErrorLogger *) = 0;
+    virtual void runChecks(const Tokenizer &, ErrorLogger *) = 0;
 
     /** get error messages */
     virtual void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const = 0;
@@ -82,25 +93,24 @@ class CPPCHECKLIB Check {
     virtual std::string classInfo() const = 0;
 
     /**
-     * Write given error to errorlogger or to out stream in xml format.
+     * Write given error to stdout in xml format.
      * This is for for printout out the error list with --errorlist
      * @param errmsg Error message to write
      */
-    static void reportError(const ErrorLogger::ErrorMessage &errmsg);
+    static void writeToErrorList(const ErrorMessage &errmsg);
 
     /** Base class used for whole-program analysis */
     class CPPCHECKLIB FileInfo {
     public:
-        FileInfo() {}
-        virtual ~FileInfo() {}
+        explicit FileInfo(std::string f0 = {}) : file0(std::move(f0)) {}
+        virtual ~FileInfo() = default;
         virtual std::string toString() const {
             return std::string();
         }
+        std::string file0;
     };
 
-    virtual FileInfo * getFileInfo(const Tokenizer *tokenizer, const Settings *settings) const {
-        (void)tokenizer;
-        (void)settings;
+    virtual FileInfo * getFileInfo(const Tokenizer& /*tokenizer*/, const Settings& /*settings*/, const std::string& /*currentConfig*/) const {
         return nullptr;
     }
 
@@ -110,84 +120,44 @@ class CPPCHECKLIB Check {
     }
 
     // Return true if an error is reported.
-    virtual bool analyseWholeProgram(const CTU::FileInfo *ctu, const std::list<FileInfo*> &fileInfo, const Settings& settings, ErrorLogger &errorLogger) {
-        (void)ctu;
-        (void)fileInfo;
-        (void)settings;
-        (void)errorLogger;
+    virtual bool analyseWholeProgram(const CTU::FileInfo& /*ctu*/, const std::list<FileInfo*>& /*fileInfo*/, const Settings& /*settings*/, ErrorLogger & /*errorLogger*/) {
         return false;
     }
 
+protected:
     static std::string getMessageId(const ValueFlow::Value &value, const char id[]);
 
-protected:
-    const Tokenizer * const mTokenizer;
-    const Settings * const mSettings;
-    ErrorLogger * const mErrorLogger;
+    const Tokenizer* const mTokenizer{};
+    const Settings* const mSettings{};
+    ErrorLogger* const mErrorLogger{};
 
     /** report an error */
-    template<typename T, typename U>
-    void reportError(const Token *tok, const Severity::SeverityType severity, const T id, const U msg) {
-        reportError(tok, severity, id, msg, CWE(0U), false);
+    void reportError(const Token *tok, const Severity severity, const std::string &id, const std::string &msg) {
+        reportError(tok, severity, id, msg, CWE(0U), Certainty::normal);
     }
 
     /** report an error */
-    template<typename T, typename U>
-    void reportError(const Token *tok, const Severity::SeverityType severity, const T id, const U msg, const CWE &cwe, bool inconclusive) {
+    void reportError(const Token *tok, const Severity severity, const std::string &id, const std::string &msg, const CWE &cwe, Certainty certainty) {
         const std::list<const Token *> callstack(1, tok);
-        reportError(callstack, severity, id, msg, cwe, inconclusive);
+        reportError(callstack, severity, id, msg, cwe, certainty);
     }
 
     /** report an error */
-    template<typename T, typename U>
-    void reportError(const std::list<const Token *> &callstack, Severity::SeverityType severity, const T id, const U msg) {
-        reportError(callstack, severity, id, msg, CWE(0U), false);
-    }
+    void reportError(const std::list<const Token *> &callstack, Severity severity, const std::string &id, const std::string &msg, const CWE &cwe, Certainty certainty);
 
-    /** report an error */
-    template<typename T, typename U>
-    void reportError(const std::list<const Token *> &callstack, Severity::SeverityType severity, const T id, const U msg, const CWE &cwe, bool inconclusive) {
-        const ErrorLogger::ErrorMessage errmsg(callstack, mTokenizer ? &mTokenizer->list : nullptr, severity, id, msg, cwe, inconclusive);
-        if (mErrorLogger)
-            mErrorLogger->reportErr(errmsg);
-        else
-            reportError(errmsg);
-    }
+    void reportError(ErrorPath errorPath, Severity severity, const char id[], const std::string &msg, const CWE &cwe, Certainty certainty);
 
-    void reportError(const ErrorPath &errorPath, Severity::SeverityType severity, const char id[], const std::string &msg, const CWE &cwe, bool inconclusive) {
-        const ErrorLogger::ErrorMessage errmsg(errorPath, mTokenizer ? &mTokenizer->list : nullptr, severity, id, msg, cwe, inconclusive);
-        if (mErrorLogger)
-            mErrorLogger->reportErr(errmsg);
-        else
-            reportError(errmsg);
-    }
+    /** log checker */
+    void logChecker(const char id[]);
 
-    ErrorPath getErrorPath(const Token *errtok, const ValueFlow::Value *value, const std::string &bug) const {
-        ErrorPath errorPath;
-        if (!value) {
-            errorPath.emplace_back(errtok,bug);
-        } else if (mSettings->verbose || mSettings->xml || !mSettings->templateLocation.empty()) {
-            errorPath = value->errorPath;
-            errorPath.emplace_back(errtok,bug);
-        } else {
-            if (value->condition)
-                errorPath.emplace_back(value->condition, "condition '" + value->condition->expressionString() + "'");
-            //else if (!value->isKnown() || value->defaultArg)
-            //    errorPath = value->callstack;
-            errorPath.emplace_back(errtok,bug);
-        }
-        return errorPath;
-    }
+    ErrorPath getErrorPath(const Token* errtok, const ValueFlow::Value* value, std::string bug) const;
 
     /**
      * Use WRONG_DATA in checkers when you check for wrong data. That
      * will call this method
      */
-    bool wrongData(const Token *tok, bool condition, const char *str);
+    bool wrongData(const Token *tok, const char *str);
 
-    /** disabled assignment operator and copy constructor */
-    void operator=(const Check &) = delete;
-    Check(const Check &) = delete;
 private:
     const std::string mName;
 };
diff --git a/lib/check64bit.cpp b/lib/check64bit.cpp
index 146fc8399b6..d203eb5f279 100644
--- a/lib/check64bit.cpp
+++ b/lib/check64bit.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,30 +22,47 @@
 
 #include "check64bit.h"
 
-#include "errorlogger.h"
+#include "errortypes.h"
+#include "platform.h"
 #include "settings.h"
 #include "symboldatabase.h"
 #include "token.h"
 #include "tokenize.h"
 
-#include <cstddef>
+#include <vector>
 
 //---------------------------------------------------------------------------
 
 // CWE ids used
-static const struct CWE CWE398(398U);   // Indicator of Poor Code Quality
-static const struct CWE CWE758(758U);   // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior
+static const CWE CWE758(758U);   // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior
 
 // Register this check class (by creating a static instance of it)
 namespace {
     Check64BitPortability instance;
 }
 
+static bool is32BitIntegerReturn(const Function* func, const Settings* settings)
+{
+    if (settings->platform.sizeof_pointer != 8)
+        return false;
+    const ValueType* vt = func->arg->valueType();
+    return vt && vt->pointer == 0 && vt->isIntegral() && vt->getSizeOf(*settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer) == 4;
+}
+
+static bool isFunctionPointer(const Token* tok)
+{
+    if (!tok || !tok->variable())
+        return false;
+    return Tokenizer::isFunctionPointer(tok->variable()->nameToken());
+}
+
 void Check64BitPortability::pointerassignment()
 {
-    if (!mSettings->isEnabled(Settings::PORTABILITY))
+    if (!mSettings->severity.isEnabled(Severity::portability))
         return;
 
+    logChecker("Check64BitPortability::pointerassignment"); // portability
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
     // Check return values
@@ -56,7 +73,7 @@ void Check64BitPortability::pointerassignment()
         bool retPointer = false;
         if (scope->function->token->strAt(-1) == "*") // Function returns a pointer
             retPointer = true;
-        else if (Token::Match(scope->function->token->previous(), "int|long|DWORD")) // Function returns an integer
+        else if (is32BitIntegerReturn(scope->function, mSettings))
             ;
         else
             continue;
@@ -64,7 +81,7 @@ void Check64BitPortability::pointerassignment()
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
             // skip nested functions
             if (tok->str() == "{") {
-                if (tok->scope()->type == Scope::ScopeType::eFunction || tok->scope()->type == Scope::ScopeType::eLambda)
+                if (tok->scope()->type == ScopeType::eFunction || tok->scope()->type == ScopeType::eLambda)
                     tok = tok->link();
             }
 
@@ -81,8 +98,17 @@ void Check64BitPortability::pointerassignment()
             if (retPointer && !returnType->typeScope && returnType->pointer == 0U)
                 returnIntegerError(tok);
 
-            if (!retPointer && returnType->pointer >= 1U)
-                returnPointerError(tok);
+            if (!retPointer) {
+                bool warn = returnType->pointer >= 1U;
+                if (!warn) {
+                    const Token* tok2 = tok->astOperand1();
+                    while (tok2 && tok2->isCast())
+                        tok2 = tok2->astOperand2() ? tok2->astOperand2() : tok2->astOperand1();
+                    warn = tok2 && tok2->valueType() && tok2->valueType()->pointer;
+                }
+                if (warn)
+                    returnPointerError(tok);
+            }
         }
     }
 
@@ -102,7 +128,8 @@ void Check64BitPortability::pointerassignment()
                 !tok->astOperand2()->isNumber() &&
                 rhstype->pointer == 0U &&
                 rhstype->originalTypeName.empty() &&
-                rhstype->type == ValueType::Type::INT)
+                rhstype->type == ValueType::Type::INT &&
+                !isFunctionPointer(tok->astOperand1()))
                 assignmentIntegerToAddressError(tok);
 
             // Assign pointer to integer..
@@ -125,7 +152,7 @@ void Check64BitPortability::assignmentAddressToIntegerError(const Token *tok)
                 "Assigning a pointer to an integer (int/long/etc) is not portable across different platforms and "
                 "compilers. For example in 32-bit Windows and linux they are same width, but in 64-bit Windows and linux "
                 "they are of different width. In worst case you end up assigning 64-bit address to 32-bit integer. The safe "
-                "way is to store addresses only in pointer types (or typedefs like uintptr_t).", CWE758, false);
+                "way is to store addresses only in pointer types (or typedefs like uintptr_t).", CWE758, Certainty::normal);
 }
 
 void Check64BitPortability::assignmentIntegerToAddressError(const Token *tok)
@@ -136,7 +163,7 @@ void Check64BitPortability::assignmentIntegerToAddressError(const Token *tok)
                 "Assigning an integer (int/long/etc) to a pointer is not portable across different platforms and "
                 "compilers. For example in 32-bit Windows and linux they are same width, but in 64-bit Windows and linux "
                 "they are of different width. In worst case you end up assigning 64-bit integer to 32-bit pointer. The safe "
-                "way is to store addresses only in pointer types (or typedefs like uintptr_t).", CWE758, false);
+                "way is to store addresses only in pointer types (or typedefs like uintptr_t).", CWE758, Certainty::normal);
 }
 
 void Check64BitPortability::returnPointerError(const Token *tok)
@@ -147,7 +174,7 @@ void Check64BitPortability::returnPointerError(const Token *tok)
                 "Returning an address value in a function with integer (int/long/etc) return type is not portable across "
                 "different platforms and compilers. For example in 32-bit Windows and Linux they are same width, but in "
                 "64-bit Windows and Linux they are of different width. In worst case you end up casting 64-bit address down "
-                "to 32-bit integer. The safe way is to always return an integer.", CWE758, false);
+                "to 32-bit integer. The safe way is to return a type such as intptr_t.", CWE758, Certainty::normal);
 }
 
 void Check64BitPortability::returnIntegerError(const Token *tok)
@@ -158,5 +185,20 @@ void Check64BitPortability::returnIntegerError(const Token *tok)
                 "Returning an integer (int/long/etc) in a function with pointer return type is not portable across different "
                 "platforms and compilers. For example in 32-bit Windows and Linux they are same width, but in 64-bit Windows "
                 "and Linux they are of different width. In worst case you end up casting 64-bit integer down to 32-bit pointer. "
-                "The safe way is to always return a pointer.", CWE758, false);
+                "The safe way is to always return a pointer.", CWE758, Certainty::normal);
+}
+
+void Check64BitPortability::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    Check64BitPortability check64BitPortability(&tokenizer, &tokenizer.getSettings(), errorLogger);
+    check64BitPortability.pointerassignment();
+}
+
+void Check64BitPortability::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const
+{
+    Check64BitPortability c(nullptr, settings, errorLogger);
+    c.assignmentAddressToIntegerError(nullptr);
+    c.assignmentIntegerToAddressError(nullptr);
+    c.returnIntegerError(nullptr);
+    c.returnPointerError(nullptr);
 }
diff --git a/lib/check64bit.h b/lib/check64bit.h
index 521c3502c8e..79397e98e5f 100644
--- a/lib/check64bit.h
+++ b/lib/check64bit.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -32,7 +32,6 @@ class Settings;
 class Token;
 class Tokenizer;
 
-
 /// @addtogroup Checks
 /// @{
 
@@ -41,45 +40,35 @@ class Tokenizer;
  */
 
 class CPPCHECKLIB Check64BitPortability : public Check {
+    friend class Test64BitPortability;
+
 public:
     /** This constructor is used when registering the Check64BitPortability */
-    Check64BitPortability() : Check(myName()) {
-    }
+    Check64BitPortability() : Check(myName()) {}
 
+private:
     /** This constructor is used when running checks. */
     Check64BitPortability(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger) {}
 
     /** @brief Run checks against the normal token list */
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        Check64BitPortability check64BitPortability(tokenizer, settings, errorLogger);
-        check64BitPortability.pointerassignment();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     /** Check for pointer assignment */
     void pointerassignment();
 
-private:
-
     void assignmentAddressToIntegerError(const Token *tok);
     void assignmentIntegerToAddressError(const Token *tok);
     void returnIntegerError(const Token *tok);
     void returnPointerError(const Token *tok);
 
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        Check64BitPortability c(nullptr, settings, errorLogger);
-        c.assignmentAddressToIntegerError(nullptr);
-        c.assignmentIntegerToAddressError(nullptr);
-        c.returnIntegerError(nullptr);
-        c.returnPointerError(nullptr);
-    }
+    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const override;
 
     static std::string myName() {
         return "64-bit portability";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Check if there is 64-bit portability issues:\n"
                "- assign address to/from int/long\n"
                "- casting address from/to integer when returning from function\n";
diff --git a/lib/checkassert.cpp b/lib/checkassert.cpp
index a5edcfcd60b..3ab55967ede 100644
--- a/lib/checkassert.cpp
+++ b/lib/checkassert.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,17 +22,22 @@
 
 #include "checkassert.h"
 
-#include "errorlogger.h"
+#include "astutils.h"
+#include "errortypes.h"
+#include "library.h"
 #include "settings.h"
 #include "symboldatabase.h"
 #include "token.h"
 #include "tokenize.h"
 #include "tokenlist.h"
 
+#include <algorithm>
+#include <utility>
+
 //---------------------------------------------------------------------------
 
 // CWE ids used
-static const struct CWE CWE398(398U);   // Indicator of Poor Code Quality
+static const CWE CWE398(398U);   // Indicator of Poor Code Quality
 
 // Register this check class (by creating a static instance of it)
 namespace {
@@ -41,27 +46,51 @@ namespace {
 
 void CheckAssert::assertWithSideEffects()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckAssert::assertWithSideEffects"); // warning
+
     for (const Token* tok = mTokenizer->list.front(); tok; tok = tok->next()) {
         if (!Token::simpleMatch(tok, "assert ("))
             continue;
 
-        const Token *endTok = tok->next()->link();
+        const Token *endTok = tok->linkAt(1);
         for (const Token* tmp = tok->next(); tmp != endTok; tmp = tmp->next()) {
+            if (Token::simpleMatch(tmp, "sizeof ("))
+                tmp = tmp->linkAt(1);
+
             checkVariableAssignment(tmp, tok->scope());
 
-            if (tmp->tokType() != Token::eFunction)
+            if (tmp->tokType() != Token::eFunction) {
+                if (const Library::Function* f = mSettings->library.getFunction(tmp)) {
+                    if (f->isconst || f->ispure)
+                        continue;
+                    if (Library::getContainerYield(tmp->next()) != Library::Container::Yield::NO_YIELD) // bailout, assume read access
+                        continue;
+                    if (std::any_of(f->argumentChecks.begin(), f->argumentChecks.end(), [](const std::pair<int, Library::ArgumentChecks>& ac) {
+                        return ac.second.iteratorInfo.container > 0; // bailout, takes iterators -> assume read access
+                    }))
+                        continue;
+                    if (tmp->str() == "get" && Token::simpleMatch(tmp->astParent(), ".") && astIsSmartPointer(tmp->astParent()->astOperand1()))
+                        continue;
+                    if (f->containerYield == Library::Container::Yield::START_ITERATOR || // bailout for std::begin/end/prev/next
+                        f->containerYield == Library::Container::Yield::END_ITERATOR ||
+                        f->containerYield == Library::Container::Yield::ITERATOR)
+                        continue;
+                    sideEffectInAssertError(tmp, mSettings->library.getFunctionName(tmp));
+                }
                 continue;
+            }
 
             const Function* f = tmp->function();
-            if (f->nestedIn->isClassOrStruct() && !f->isStatic() && !f->isConst()) {
-                sideEffectInAssertError(tmp, f->name()); // Non-const member function called
+            const Scope* scope = f->functionScope;
+            if (!scope) {
+                // guess that const method doesn't have side effects
+                if (f->nestedIn->isClassOrStruct() && !f->isConst() && !f->isStatic())
+                    sideEffectInAssertError(tmp, f->name()); // Non-const member function called, assume it has side effects
                 continue;
             }
-            const Scope* scope = f->functionScope;
-            if (!scope) continue;
 
             for (const Token *tok2 = scope->bodyStart; tok2 != scope->bodyEnd; tok2 = tok2->next()) {
                 if (!tok2->isAssignmentOp() && tok2->tokType() != Token::eIncDecOp)
@@ -102,7 +131,7 @@ void CheckAssert::sideEffectInAssertError(const Token *tok, const std::string& f
                 "Non-pure function: '$symbol' is called inside assert statement. "
                 "Assert statements are removed from release builds so the code inside "
                 "assert statement is not executed. If the code is needed also in release "
-                "builds, this is a bug.", CWE398, false);
+                "builds, this is a bug.", CWE398, Certainty::normal);
 }
 
 void CheckAssert::assignmentInAssertError(const Token *tok, const std::string& varname)
@@ -114,19 +143,24 @@ void CheckAssert::assignmentInAssertError(const Token *tok, const std::string& v
                 "Variable '$symbol' is modified inside assert statement. "
                 "Assert statements are removed from release builds so the code inside "
                 "assert statement is not executed. If the code is needed also in release "
-                "builds, this is a bug.", CWE398, false);
+                "builds, this is a bug.", CWE398, Certainty::normal);
 }
 
 // checks if side effects happen on the variable prior to tmp
 void CheckAssert::checkVariableAssignment(const Token* assignTok, const Scope *assertionScope)
 {
-    const Variable* prevVar = assignTok->previous()->variable();
-    if (!prevVar)
+    if (!assignTok->isAssignmentOp() && assignTok->tokType() != Token::eIncDecOp)
+        return;
+
+    if (!assignTok->astOperand1())
+        return;
+    const Variable* var = assignTok->astOperand1()->variable();
+    if (!var)
         return;
 
     // Variable declared in inner scope in assert => don't warn
-    if (assertionScope != prevVar->scope()) {
-        const Scope *s = prevVar->scope();
+    if (assertionScope != var->scope()) {
+        const Scope *s = var->scope();
         while (s && s != assertionScope)
             s = s->nestedIn;
         if (s == assertionScope)
@@ -135,12 +169,12 @@ void CheckAssert::checkVariableAssignment(const Token* assignTok, const Scope *a
 
     // assignment
     if (assignTok->isAssignmentOp() || assignTok->tokType() == Token::eIncDecOp) {
-        if (prevVar->isConst())
+        if (var->isConst()) {
             return;
-
-        assignmentInAssertError(assignTok, prevVar->name());
+        }
+        assignmentInAssertError(assignTok, var->name());
     }
-    // TODO: function calls on prevVar
+    // TODO: function calls on var
 }
 
 bool CheckAssert::inSameScope(const Token* returnTok, const Token* assignTok)
@@ -148,3 +182,16 @@ bool CheckAssert::inSameScope(const Token* returnTok, const Token* assignTok)
     // TODO: even if a return is in the same scope, the assignment might not affect it.
     return returnTok->scope() == assignTok->scope();
 }
+
+void CheckAssert::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    CheckAssert checkAssert(&tokenizer, &tokenizer.getSettings(), errorLogger);
+    checkAssert.assertWithSideEffects();
+}
+
+void CheckAssert::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const
+{
+    CheckAssert c(nullptr, settings, errorLogger);
+    c.sideEffectInAssertError(nullptr, "function");
+    c.assignmentInAssertError(nullptr, "var");
+}
diff --git a/lib/checkassert.h b/lib/checkassert.h
index e4835e381db..b01831a5eec 100644
--- a/lib/checkassert.h
+++ b/lib/checkassert.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -42,40 +42,30 @@ class Tokenizer;
 
 class CPPCHECKLIB CheckAssert : public Check {
 public:
-    CheckAssert() : Check(myName()) {
-    }
+    CheckAssert() : Check(myName()) {}
 
+private:
     CheckAssert(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger) {}
 
     /** run checks, the token list is not simplified */
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        CheckAssert checkAssert(tokenizer, settings, errorLogger);
-        checkAssert.assertWithSideEffects();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     void assertWithSideEffects();
 
-protected:
     void checkVariableAssignment(const Token* assignTok, const Scope *assertionScope);
     static bool inSameScope(const Token* returnTok, const Token* assignTok);
 
-private:
     void sideEffectInAssertError(const Token *tok, const std::string& functionName);
     void assignmentInAssertError(const Token *tok, const std::string &varname);
 
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        CheckAssert c(nullptr, settings, errorLogger);
-        c.sideEffectInAssertError(nullptr, "function");
-        c.assignmentInAssertError(nullptr, "var");
-    }
+    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const override;
 
     static std::string myName() {
         return "Assert";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Warn if there are side effects in assert statements (since this cause different behaviour in debug/release builds).\n";
     }
 };
diff --git a/lib/checkautovariables.cpp b/lib/checkautovariables.cpp
index 0b3e845db64..387e3fd3c2d 100644
--- a/lib/checkautovariables.cpp
+++ b/lib/checkautovariables.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,17 +23,19 @@
 #include "checkautovariables.h"
 
 #include "astutils.h"
-#include "errorlogger.h"
 #include "library.h"
 #include "settings.h"
 #include "symboldatabase.h"
 #include "token.h"
 #include "tokenize.h"
 #include "valueflow.h"
+#include "vfvalue.h"
 
-#include <cstddef>
+#include <algorithm>
 #include <list>
-#include <functional>
+#include <unordered_set>
+#include <utility>
+#include <vector>
 
 //---------------------------------------------------------------------------
 
@@ -53,16 +55,16 @@ static bool isPtrArg(const Token *tok)
     return (var && var->isArgument() && var->isPointer());
 }
 
-static bool isArrayArg(const Token *tok)
+static bool isArrayArg(const Token *tok, const Settings& settings)
 {
     const Variable *var = tok->variable();
-    return (var && var->isArgument() && var->isArray());
+    return (var && var->isArgument() && var->isArray() && (!var->scope() || !settings.library.isentrypoint(var->scope()->className)));
 }
 
 static bool isArrayVar(const Token *tok)
 {
     const Variable *var = tok->variable();
-    return (var && var->isArray());
+    return (var && var->isArray() && !var->isArgument());
 }
 
 static bool isRefPtrArg(const Token *tok)
@@ -74,7 +76,7 @@ static bool isRefPtrArg(const Token *tok)
 static bool isNonReferenceArg(const Token *tok)
 {
     const Variable *var = tok->variable();
-    return (var && var->isArgument() && !var->isReference() && (var->isPointer() || var->valueType()->type >= ValueType::Type::CONTAINER || var->type()));
+    return (var && var->isArgument() && !var->isReference() && (var->isPointer() || (var->valueType() && var->valueType()->type >= ValueType::Type::CONTAINER) || var->type()));
 }
 
 static bool isAutoVar(const Token *tok)
@@ -97,6 +99,8 @@ static bool isAutoVar(const Token *tok)
         } while (Token::Match(tok, "%name% .|::"));
         if (Token::Match(tok, "%name% ("))
             return false;
+        if (tok->variable() && tok->variable()->isPointer())
+            return false;
     }
     return true;
 }
@@ -131,7 +135,7 @@ static bool isAutoVarArray(const Token *tok)
 
     // ValueFlow
     if (var->isPointer() && !var->isArgument()) {
-        for (std::list<ValueFlow::Value>::const_iterator it = tok->values().begin(); it != tok->values().end(); ++it) {
+        for (auto it = tok->values().cbegin(); it != tok->values().cend(); ++it) {
             const ValueFlow::Value &val = *it;
             if (val.isTokValue() && isAutoVarArray(val.tokvalue))
                 return true;
@@ -141,24 +145,27 @@ static bool isAutoVarArray(const Token *tok)
     return false;
 }
 
-// Verification that we really take the address of a local variable
-static bool checkRvalueExpression(const Token * const vartok)
+static bool isLocalContainerBuffer(const Token* tok, const Settings& settings)
 {
-    const Variable * const var = vartok->variable();
-    if (var == nullptr)
+    if (!tok)
         return false;
 
-    if (Token::Match(vartok->previous(), "& %name% [") && var->isPointer())
+    // x+y
+    if (tok->str() == "+")
+        return isLocalContainerBuffer(tok->astOperand1(), settings) || isLocalContainerBuffer(tok->astOperand2(), settings);
+
+    if (tok->str() != "(" || !Token::simpleMatch(tok->astOperand1(), "."))
         return false;
 
-    const Token * const next = vartok->next();
-    // &a.b[0]
-    if (Token::Match(vartok, "%name% . %var% [") && !var->isPointer()) {
-        const Variable *var2 = next->next()->variable();
-        return var2 && !var2->isPointer();
-    }
+    tok = tok->astOperand1()->astOperand1();
 
-    return ((next->str() != "." || (!var->isPointer() && (!var->isClass() || var->type()))) && next->strAt(2) != ".");
+    const Variable* var = tok->variable();
+    if (!var || !var->isLocal() || var->isStatic())
+        return false;
+
+    const Library::Container::Yield yield = astContainerYield(tok, settings.library);
+
+    return yield == Library::Container::Yield::BUFFER || yield == Library::Container::Yield::BUFFER_NT;
 }
 
 static bool isAddressOfLocalVariable(const Token *expr)
@@ -192,8 +199,8 @@ static bool variableIsUsedInScope(const Token* start, nonneg int varId, const Sc
     for (const Token *tok = start; tok && tok != scope->bodyEnd; tok = tok->next()) {
         if (tok->varId() == varId)
             return true;
-        const Scope::ScopeType scopeType = tok->scope()->type;
-        if (scopeType == Scope::eFor || scopeType == Scope::eDo || scopeType == Scope::eWhile) // In case of loops, better checking would be necessary
+        const ScopeType scopeType = tok->scope()->type;
+        if (scopeType == ScopeType::eFor || scopeType == ScopeType::eDo || scopeType == ScopeType::eWhile) // In case of loops, better checking would be necessary
             return true;
         if (Token::simpleMatch(tok, "asm ("))
             return true;
@@ -203,18 +210,20 @@ static bool variableIsUsedInScope(const Token* start, nonneg int varId, const Sc
 
 void CheckAutoVariables::assignFunctionArg()
 {
-    const bool printStyle = mSettings->isEnabled(Settings::STYLE);
-    const bool printWarning = mSettings->isEnabled(Settings::WARNING);
-    if (!printStyle && !printWarning)
+    const bool printStyle = mSettings->severity.isEnabled(Severity::style);
+    const bool printWarning = mSettings->severity.isEnabled(Severity::warning);
+    if (!printStyle && !printWarning && !mSettings->isPremiumEnabled("uselessAssignmentPtrArg"))
         return;
 
+    logChecker("CheckAutoVariables::assignFunctionArg"); // style,warning
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token *tok = scope->bodyStart; tok && tok != scope->bodyEnd; tok = tok->next()) {
             // TODO: What happens if this is removed?
             if (tok->astParent())
                 continue;
-            if (!(tok->isAssignmentOp() || Token::Match(tok, "++|--")) || !Token::Match(tok->astOperand1(), "%var%"))
+            if (!(tok->isAssignmentOp() || tok->tokType() == Token::eIncDecOp) || !Token::Match(tok->astOperand1(), "%var%"))
                 continue;
             const Token* const vartok = tok->astOperand1();
             if (isNonReferenceArg(vartok) &&
@@ -230,9 +239,58 @@ void CheckAutoVariables::assignFunctionArg()
     }
 }
 
+static bool isAutoVariableRHS(const Token* tok, const Settings& settings) {
+    return isAddressOfLocalVariable(tok) || isAutoVarArray(tok) || isLocalContainerBuffer(tok, settings);
+}
+
+static bool hasOverloadedAssignment(const Token* tok, bool& inconclusive)
+{
+    inconclusive = false;
+    if (tok->isC())
+        return false;
+    if (const ValueType* vt = tok->valueType()) {
+        if (vt->pointer && !Token::simpleMatch(tok->astParent(), "*"))
+            return false;
+        if (vt->container && vt->container->stdStringLike)
+            return true;
+        if (vt->typeScope)
+            return std::any_of(vt->typeScope->functionList.begin(), vt->typeScope->functionList.end(), [](const Function& f) { // TODO: compare argument type
+                return f.name() == "operator=";
+            });
+        return false;
+    }
+    inconclusive = true;
+    return true;
+}
+
+static bool isMemberAssignment(const Token* tok, const Token*& rhs, const Settings& settings)
+{
+    const Token *endBracket = nullptr;
+    if (!Token::Match(tok, "[;{}] %var% . %var%")) {
+        if (!Token::Match(tok, "[;{}] %var% ["))
+            return false;
+        endBracket = tok->linkAt(2);
+        if (!Token::Match(endBracket, "] . %var%"))
+            return false;
+    }
+    if (!isPtrArg(tok->next()))
+        return false;
+    const Token* assign = (endBracket ? endBracket->next() : tok->tokAt(2))->astParent();
+    while (Token::simpleMatch(assign, "["))
+        assign = assign->astParent();
+    if (!Token::simpleMatch(assign, "="))
+        return false;
+    if (!isAutoVariableRHS(assign->astOperand2(), settings))
+        return false;
+    rhs = assign->astOperand2();
+    return true;
+}
+
 void CheckAutoVariables::autoVariables()
 {
-    const bool printInconclusive = mSettings->inconclusive;
+    logChecker("CheckAutoVariables::autoVariables");
+
+    const bool printInconclusive = mSettings->certainty.isEnabled(Certainty::inconclusive);
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token *tok = scope->bodyStart; tok && tok != scope->bodyEnd; tok = tok->next()) {
@@ -242,47 +300,47 @@ void CheckAutoVariables::autoVariables()
                 continue;
             }
             // Critical assignment
-            if (Token::Match(tok, "[;{}] %var% = & %var%") && isRefPtrArg(tok->next()) && isAutoVar(tok->tokAt(4))) {
-                if (checkRvalueExpression(tok->tokAt(4)))
-                    errorAutoVariableAssignment(tok->next(), false);
-            } else if (Token::Match(tok, "[;{}] * %var% =") && isPtrArg(tok->tokAt(2)) && isAddressOfLocalVariable(tok->tokAt(3)->astOperand2())) {
-                errorAutoVariableAssignment(tok->next(), false);
-            } else if (Token::Match(tok, "[;{}] %var% . %var% =") && isPtrArg(tok->next()) && isAddressOfLocalVariable(tok->tokAt(4)->astOperand2())) {
-                errorAutoVariableAssignment(tok->next(), false);
-            } else if (Token::Match(tok, "[;{}] %var% . %var% = %var% ;")) {
-                // TODO: check if the parameter is only changed temporarily (#2969)
-                if (printInconclusive && isPtrArg(tok->next())) {
-                    if (isAutoVarArray(tok->tokAt(5)))
-                        errorAutoVariableAssignment(tok->next(), true);
-                }
-                tok = tok->tokAt(5);
-            } else if (Token::Match(tok, "[;{}] * %var% = %var% ;")) {
-                const Variable * var1 = tok->tokAt(2)->variable();
-                if (var1 && var1->isArgument() && Token::Match(var1->nameToken()->tokAt(-3), "%type% * *")) {
-                    if (isAutoVarArray(tok->tokAt(4)))
-                        errorAutoVariableAssignment(tok->next(), false);
-                }
+            const Token* rhs{};
+            if (Token::Match(tok, "[;{}] %var% =") && isRefPtrArg(tok->next()) && isAutoVariableRHS(tok->tokAt(2)->astOperand2(), *mSettings)) {
+                checkAutoVariableAssignment(tok->next(), false);
+            } else if (Token::Match(tok, "[;{}] * %var% =") && isPtrArg(tok->tokAt(2)) && isAutoVariableRHS(tok->tokAt(3)->astOperand2(), *mSettings)) {
+                const Token* lhs = tok->tokAt(2);
+                bool inconclusive = false;
+                if (!hasOverloadedAssignment(lhs, inconclusive) || (printInconclusive && inconclusive))
+                    checkAutoVariableAssignment(tok->next(), inconclusive);
                 tok = tok->tokAt(4);
+            } else if (isMemberAssignment(tok, rhs, *mSettings)) {
+                const Token* lhs = tok->tokAt(3);
+                bool inconclusive = false;
+                if (!hasOverloadedAssignment(lhs, inconclusive) || (printInconclusive && inconclusive))
+                    checkAutoVariableAssignment(tok->next(), inconclusive);
+                tok = rhs;
             } else if (Token::Match(tok, "[;{}] %var% [") && Token::simpleMatch(tok->linkAt(2), "] =") &&
-                       (isPtrArg(tok->next()) || isArrayArg(tok->next())) && isAddressOfLocalVariable(tok->linkAt(2)->next()->astOperand2())) {
+                       (isPtrArg(tok->next()) || isArrayArg(tok->next(), *mSettings)) &&
+                       isAutoVariableRHS(tok->linkAt(2)->next()->astOperand2(), *mSettings)) {
                 errorAutoVariableAssignment(tok->next(), false);
             }
             // Invalid pointer deallocation
-            else if ((Token::Match(tok, "%name% ( %var% ) ;") && mSettings->library.getDeallocFuncInfo(tok)) ||
-                     (mTokenizer->isCPP() && Token::Match(tok, "delete [| ]| (| %var% !!["))) {
-                tok = Token::findmatch(tok->next(), "%var%");
-                if (isArrayVar(tok))
+            else if ((Token::Match(tok, "%name% ( %var%|%str% ) ;") && mSettings->library.getDeallocFuncInfo(tok)) ||
+                     (tok->isCpp() && Token::Match(tok, "delete [| ]| (| %var%|%str% !!["))) {
+                tok = Token::findmatch(tok->next(), "%var%|%str%");
+                if (Token::simpleMatch(tok->astParent(), "."))
+                    continue;
+                if (isArrayVar(tok) || tok->tokType() == Token::eString)
                     errorInvalidDeallocation(tok, nullptr);
-                else if (tok && tok->variable() && tok->variable()->isPointer()) {
+                else if (tok->variable() && tok->variable()->isPointer()) {
                     for (const ValueFlow::Value &v : tok->values()) {
-                        if (v.isTokValue() && isArrayVar(v.tokvalue)) {
+                        if (v.isImpossible())
+                            continue;
+                        if ((v.isTokValue() && (isArrayVar(v.tokvalue) || (v.tokvalue->tokType() == Token::eString))) ||
+                            (v.isLocalLifetimeValue() && v.lifetimeKind == ValueFlow::Value::LifetimeKind::Address && !Token::simpleMatch(v.tokvalue, "("))) {
                             errorInvalidDeallocation(tok, &v);
                             break;
                         }
                     }
                 }
             } else if ((Token::Match(tok, "%name% ( & %var% ) ;") && mSettings->library.getDeallocFuncInfo(tok)) ||
-                       (mTokenizer->isCPP() && Token::Match(tok, "delete [| ]| (| & %var% !!["))) {
+                       (tok->isCpp() && Token::Match(tok, "delete [| ]| (| & %var% !!["))) {
                 tok = Token::findmatch(tok->next(), "%var%");
                 if (isAutoVar(tok))
                     errorInvalidDeallocation(tok, nullptr);
@@ -291,23 +349,49 @@ void CheckAutoVariables::autoVariables()
     }
 }
 
-//---------------------------------------------------------------------------
-
-void CheckAutoVariables::errorReturnAddressToAutoVariable(const Token *tok)
+bool CheckAutoVariables::checkAutoVariableAssignment(const Token *expr, bool inconclusive, const Token *startToken)
 {
-    reportError(tok, Severity::error, "returnAddressOfAutoVariable", "Address of an auto-variable returned.", CWE562, false);
-}
+    if (!startToken)
+        startToken = Token::findsimplematch(expr, "=")->next();
+    for (const Token *tok = startToken; tok; tok = tok->next()) {
+        if (tok->str() == "}" && tok->scope()->type == ScopeType::eFunction) {
+            errorAutoVariableAssignment(expr, inconclusive);
+            return true;
+        }
 
-void CheckAutoVariables::errorReturnAddressToAutoVariable(const Token *tok, const ValueFlow::Value *value)
-{
-    reportError(tok, Severity::error, "returnAddressOfAutoVariable", "Address of auto-variable '" + value->tokvalue->astOperand1()->expressionString() + "' returned", CWE562, false);
-}
+        if (Token::Match(tok, "return|throw|break|continue")) {
+            errorAutoVariableAssignment(expr, inconclusive);
+            return true;
+        }
+        if (Token::simpleMatch(tok, "=")) {
+            const Token *lhs = tok;
+            while (Token::Match(lhs->previous(), "%name%|.|*|]")) {
+                if (lhs->linkAt(-1))
+                    lhs = lhs->linkAt(-1);
+                else
+                    lhs = lhs->previous();
+            }
+            const Token *e = expr;
+            while (e->str() != "=" && lhs->str() == e->str()) {
+                e = e->next();
+                lhs = lhs->next();
+            }
+            if (lhs->str() == "=")
+                return false;
+        }
 
-void CheckAutoVariables::errorReturnPointerToLocalArray(const Token *tok)
-{
-    reportError(tok, Severity::error, "returnLocalVariable", "Pointer to local array variable returned.", CWE562, false);
+        if (Token::simpleMatch(tok, "if (")) {
+            const Token *ifStart = tok->linkAt(1)->next();
+            return checkAutoVariableAssignment(expr, inconclusive, ifStart) || checkAutoVariableAssignment(expr, inconclusive, ifStart->link()->next());
+        }
+        if (Token::simpleMatch(tok, "} else {"))
+            tok = tok->linkAt(2);
+    }
+    return false;
 }
 
+//---------------------------------------------------------------------------
+
 void CheckAutoVariables::errorAutoVariableAssignment(const Token *tok, bool inconclusive)
 {
     if (!inconclusive) {
@@ -316,7 +400,7 @@ void CheckAutoVariables::errorAutoVariableAssignment(const Token *tok, bool inco
                     "Dangerous assignment - the function parameter is assigned the address of a local "
                     "auto-variable. Local auto-variables are reserved from the stack which "
                     "is freed when the function ends. So the pointer to a local variable "
-                    "is invalid after the function ends.", CWE562, false);
+                    "is invalid after the function ends.", CWE562, Certainty::normal);
     } else {
         reportError(tok, Severity::error, "autoVariables",
                     "Address of local auto-variable assigned to a function parameter.\n"
@@ -325,26 +409,16 @@ void CheckAutoVariables::errorAutoVariableAssignment(const Token *tok, bool inco
                     "the function ends. The address is invalid after the function ends and it "
                     "might 'leak' from the function through the parameter.",
                     CWE562,
-                    true);
+                    Certainty::inconclusive);
     }
 }
 
-void CheckAutoVariables::errorReturnAddressOfFunctionParameter(const Token *tok, const std::string &varname)
-{
-    reportError(tok, Severity::error, "returnAddressOfFunctionParameter",
-                "$symbol:" + varname + "\n"
-                "Address of function parameter '$symbol' returned.\n"
-                "Address of the function parameter '$symbol' becomes invalid after the function exits because "
-                "function parameters are stored on the stack which is freed when the function exits. Thus the returned "
-                "value is invalid.", CWE562, false);
-}
-
 void CheckAutoVariables::errorUselessAssignmentArg(const Token *tok)
 {
     reportError(tok,
                 Severity::style,
                 "uselessAssignmentArg",
-                "Assignment of function parameter has no effect outside the function.", CWE398, false);
+                "Assignment of function parameter has no effect outside the function.", CWE398, Certainty::normal);
 }
 
 void CheckAutoVariables::errorUselessAssignmentPtrArg(const Token *tok)
@@ -352,142 +426,18 @@ void CheckAutoVariables::errorUselessAssignmentPtrArg(const Token *tok)
     reportError(tok,
                 Severity::warning,
                 "uselessAssignmentPtrArg",
-                "Assignment of function parameter has no effect outside the function. Did you forget dereferencing it?", CWE398, false);
+                "Assignment of function parameter has no effect outside the function. Did you forget dereferencing it?", CWE398, Certainty::normal);
 }
 
-//---------------------------------------------------------------------------
-
-// return temporary?
-bool CheckAutoVariables::returnTemporary(const Token *tok)
+bool CheckAutoVariables::diag(const Token* tokvalue)
 {
-    bool func = false;     // Might it be a function call?
-    bool retref = false;   // is there such a function that returns a reference?
-    bool retvalue = false; // is there such a function that returns a value?
-
-    const Function *function = tok->function();
-    if (function) {
-        // Ticket #5478: Only functions or operator equal might return a temporary
-        if (function->type != Function::eOperatorEqual && function->type != Function::eFunction)
-            return false;
-        retref = function->tokenDef->strAt(-1) == "&";
-        if (!retref) {
-            const Token *start = function->retDef;
-            if (start->str() == "const")
-                start = start->next();
-            if (start->str() == "::")
-                start = start->next();
-
-            if (Token::simpleMatch(start, "std ::")) {
-                if (start->strAt(3) != "<" || !Token::simpleMatch(start->linkAt(3), "> ::"))
-                    retvalue = true;
-                else
-                    retref = true; // Assume that a reference is returned
-            } else {
-                if (start->type())
-                    retvalue = true;
-                else
-                    retref = true;
-            }
-        }
-        func = true;
-    }
-    if (!func && tok->type())
+    if (!tokvalue)
         return true;
-
-    return (!retref && retvalue);
+    return !mDiagDanglingTemp.insert(tokvalue).second;
 }
 
 //---------------------------------------------------------------------------
 
-static bool astHasAutoResult(const Token *tok)
-{
-    if (tok->astOperand1() && !astHasAutoResult(tok->astOperand1()))
-        return false;
-    if (tok->astOperand2() && !astHasAutoResult(tok->astOperand2()))
-        return false;
-
-    if (tok->isOp()) {
-        if (tok->tokType() == Token::eIncDecOp)
-            return false;
-        if ((tok->str() == "<<" || tok->str() == ">>") && tok->astOperand1()) {
-            const Token* tok2 = tok->astOperand1();
-            while (tok2 && tok2->isUnaryOp("*"))
-                tok2 = tok2->astOperand1();
-            return tok2 && tok2->variable() && !tok2->variable()->isClass() && !tok2->variable()->isStlType(); // Class or unknown type on LHS: Assume it is a stream
-        }
-        return true;
-    }
-
-    if (tok->isLiteral())
-        return true;
-
-    if (tok->isName()) {
-        // TODO: check function calls, struct members, arrays, etc also
-        if (!tok->variable())
-            return false;
-        if (tok->variable()->isStlType())
-            return true;
-        if (tok->variable()->isClass() || tok->variable()->isPointer() || tok->variable()->isReference()) // TODO: Properly handle pointers/references to classes in symbol database
-            return false;
-
-        return true;
-    }
-
-    return false;
-}
-
-void CheckAutoVariables::returnReference()
-{
-    if (mTokenizer->isC())
-        return;
-
-    const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
-
-    for (const Scope * scope : symbolDatabase->functionScopes) {
-        if (!scope->function)
-            continue;
-
-        const Token *tok = scope->function->tokenDef;
-
-        // have we reached a function that returns a reference?
-        if (tok->previous() && tok->previous()->str() == "&") {
-            for (const Token *tok2 = scope->bodyStart->next(); tok2 && tok2 != scope->bodyEnd; tok2 = tok2->next()) {
-                if (!tok2->scope()->isExecutable()) {
-                    tok2 = tok2->scope()->bodyEnd;
-                    if (!tok2)
-                        break;
-                    continue;
-                }
-
-                // Skip over lambdas
-                const Token *lambdaEndToken = findLambdaEndToken(tok2);
-                if (lambdaEndToken)
-                    tok2 = lambdaEndToken->next();
-
-                if (tok2->str() == "(")
-                    tok2 = tok2->link();
-
-                if (tok2->str() != "return")
-                    continue;
-
-                // return reference to temporary..
-                if (Token::Match(tok2, "return %name% (") && Token::simpleMatch(tok2->linkAt(2), ") ;")) {
-                    if (returnTemporary(tok2->next())) {
-                        // report error..
-                        errorReturnTempReference(tok2);
-                    }
-                }
-
-                // Return reference to a literal or the result of a calculation
-                else if (tok2->astOperand1() && (tok2->astOperand1()->isCalculation() || tok2->next()->isLiteral()) &&
-                         astHasAutoResult(tok2->astOperand1())) {
-                    errorReturnTempReference(tok2);
-                }
-            }
-        }
-    }
-}
-
 static bool isInScope(const Token * tok, const Scope * scope)
 {
     if (!tok)
@@ -497,7 +447,7 @@ static bool isInScope(const Token * tok, const Scope * scope)
     const Variable * var = tok->variable();
     if (var && (var->isGlobal() || var->isStatic() || var->isExtern()))
         return false;
-    if (tok->scope() && tok->scope()->isNestedIn(scope))
+    if (tok->scope() && !tok->scope()->isClassOrStructOrUnion() && tok->scope()->isNestedIn(scope))
         return true;
     if (!var)
         return false;
@@ -505,10 +455,10 @@ static bool isInScope(const Token * tok, const Scope * scope)
         const Scope * tokScope = tok->scope();
         if (!tokScope)
             return false;
-        for (const Scope * argScope:tokScope->nestedList) {
-            if (argScope && argScope->isNestedIn(scope))
-                return true;
-        }
+        if (std::any_of(tokScope->nestedList.cbegin(), tokScope->nestedList.cend(), [&](const Scope* argScope) {
+            return argScope && argScope->isNestedIn(scope);
+        }))
+            return true;
     }
     return false;
 }
@@ -531,11 +481,94 @@ static int getPointerDepth(const Token *tok)
 {
     if (!tok)
         return 0;
-    return tok->valueType() ? tok->valueType()->pointer : 0;
+    if (tok->valueType())
+        return tok->valueType()->pointer;
+    int n = 0;
+    std::pair<const Token*, const Token*> decl = Token::typeDecl(tok);
+    for (const Token* tok2 = decl.first; tok2 != decl.second; tok2 = tok2->next())
+        if (Token::simpleMatch(tok2, "*"))
+            n++;
+    return n;
+}
+
+static bool isDeadTemporary(const Token* tok, const Token* expr, const Library& library)
+{
+    if (!isTemporary(tok, &library))
+        return false;
+    if (expr) {
+        if (!precedes(nextAfterAstRightmostLeaf(tok->astTop()), nextAfterAstRightmostLeaf(expr->astTop())))
+            return false;
+        const Token* parent = tok->astParent();
+        if (Token::simpleMatch(parent, "{") && Token::simpleMatch(parent->astParent(), ":"))
+            parent = parent->astParent();
+        // Is in a for loop
+        if (astIsRHS(tok) && Token::simpleMatch(parent, ":") && Token::simpleMatch(parent->astParent(), "(") && Token::simpleMatch(parent->astParent()->previous(), "for (")) {
+            const Token* braces = parent->astParent()->link()->next();
+            if (precedes(braces, expr) && precedes(expr, braces->link()))
+                return false;
+        }
+    }
+    return true;
+}
+
+static bool isEscapedReference(const Variable* var)
+{
+    if (!var)
+        return false;
+    if (!var->isReference())
+        return false;
+    const Token * const varDeclEndToken = var->declEndToken();
+    if (!varDeclEndToken)
+        return false;
+    if (!Token::simpleMatch(varDeclEndToken, "="))
+        return false;
+    const Token* vartok = varDeclEndToken->astOperand2();
+    return !isTemporary(vartok, nullptr, false);
+}
+
+static bool isDanglingSubFunction(const Token* tokvalue, const Token* tok)
+{
+    if (!tokvalue)
+        return false;
+    const Variable* var = tokvalue->variable();
+    if (!var->isLocal())
+        return false;
+    const Function* f = Scope::nestedInFunction(tok->scope());
+    if (!f)
+        return false;
+    const Token* parent = tokvalue->astParent();
+    while (parent && !Token::Match(parent->previous(), "%name% (")) {
+        parent = parent->astParent();
+    }
+    if (!Token::simpleMatch(parent, "("))
+        return false;
+    return exprDependsOnThis(parent);
+}
+
+static const Variable* getParentVar(const Token* tok)
+{
+    if (!tok)
+        return nullptr;
+    if (Token::simpleMatch(tok, "."))
+        return getParentVar(tok->astOperand1());
+    return tok->variable();
+}
+
+static bool isAssignedToNonLocal(const Token* tok)
+{
+    if (!Token::simpleMatch(tok->astParent(), "="))
+        return false;
+    if (!astIsRHS(tok))
+        return false;
+    const Variable* var = getParentVar(tok->astParent()->astOperand1());
+    if (!var)
+        return false;
+    return !var->isLocal() || var->isStatic();
 }
 
 void CheckAutoVariables::checkVarLifetimeScope(const Token * start, const Token * end)
 {
+    const bool printInconclusive = mSettings->certainty.isEnabled(Certainty::inconclusive);
     if (!start)
         return;
     const Scope * scope = start->scope();
@@ -544,19 +577,23 @@ void CheckAutoVariables::checkVarLifetimeScope(const Token * start, const Token
     // If the scope is not set correctly then skip checking it
     if (scope->bodyStart != start)
         return;
-    bool returnRef = Function::returnsReference(scope->function);
+    const bool returnRef = Function::returnsReference(scope->function);
     for (const Token *tok = start; tok && tok != end; tok = tok->next()) {
         // Return reference from function
         if (returnRef && Token::simpleMatch(tok->astParent(), "return")) {
-            for (const LifetimeToken& lt : getLifetimeTokens(tok)) {
-                const Variable* var = lt.token->variable();
-                if (!var)
+            for (const ValueFlow::LifetimeToken& lt : ValueFlow::getLifetimeTokens(tok, *mSettings, true)) {
+                if (!printInconclusive && lt.inconclusive)
                     continue;
-                if (!var->isGlobal() && !var->isStatic() && !var->isReference() && !var->isRValueReference() &&
+                const Variable* var = lt.token->variable();
+                if (var && !var->isGlobal() && !var->isStatic() && !var->isReference() && !var->isRValueReference() &&
                     isInScope(var->nameToken(), tok->scope())) {
                     errorReturnReference(tok, lt.errorPath, lt.inconclusive);
                     break;
                 }
+                if (isDeadTemporary(lt.token, nullptr, mSettings->library)) {
+                    errorReturnTempReference(tok, lt.errorPath, lt.inconclusive);
+                    break;
+                }
             }
             // Assign reference to non-local variable
         } else if (Token::Match(tok->previous(), "&|&& %var% =") && tok->astParent() == tok->next() &&
@@ -564,45 +601,89 @@ void CheckAutoVariables::checkVarLifetimeScope(const Token * start, const Token
                    tok->variable()->declarationId() == tok->varId() && tok->variable()->isStatic() &&
                    !tok->variable()->isArgument()) {
             ErrorPath errorPath;
-            const Variable *var = getLifetimeVariable(tok, errorPath);
+            const Variable *var = ValueFlow::getLifetimeVariable(tok, errorPath, *mSettings);
             if (var && isInScope(var->nameToken(), tok->scope())) {
-                errorDanglingReference(tok, var, errorPath);
+                errorDanglingReference(tok, var, std::move(errorPath));
                 continue;
             }
+            // Reference to temporary
+        } else if (tok->variable() && (tok->variable()->isReference() || tok->variable()->isRValueReference())) {
+            for (const ValueFlow::LifetimeToken& lt : ValueFlow::getLifetimeTokens(getParentLifetime(tok), *mSettings)) {
+                if (!printInconclusive && lt.inconclusive)
+                    continue;
+                const Token * tokvalue = lt.token;
+                if (isDeadTemporary(tokvalue, tok, mSettings->library)) {
+                    errorDanglingTempReference(tok, lt.errorPath, lt.inconclusive);
+                    break;
+                }
+            }
         }
+        const bool escape = Token::simpleMatch(tok->astParent(), "throw") ||
+                            (Token::simpleMatch(tok->astParent(), "return") && !Function::returnsStandardType(scope->function));
+        std::unordered_set<const Token*> exprs;
         for (const ValueFlow::Value& val:tok->values()) {
-            if (!val.isLocalLifetimeValue())
+            if (!val.isLocalLifetimeValue() && !val.isSubFunctionLifetimeValue())
                 continue;
-            if (!val.tokvalue->variable())
+            if (!printInconclusive && val.isInconclusive())
                 continue;
-            if (Token::Match(tok->astParent(), "return|throw")) {
-                if (getPointerDepth(tok) < getPointerDepth(val.tokvalue))
-                    continue;
-                if (!isLifetimeBorrowed(tok, mSettings))
-                    continue;
-                if (isInScope(val.tokvalue->variable()->nameToken(), scope)) {
-                    errorReturnDanglingLifetime(tok, &val);
-                    break;
-                }
-            } else if (isDeadScope(val.tokvalue->variable()->nameToken(), tok->scope())) {
-                errorInvalidLifetime(tok, &val);
-                break;
-            } else if (isInScope(val.tokvalue->variable()->nameToken(), tok->scope())) {
-                const Variable * var = nullptr;
-                const Token * tok2 = tok;
-                if (Token::simpleMatch(tok->astParent(), "=")) {
-                    if (tok->astParent()->astOperand2() == tok) {
-                        var = getLHSVariable(tok->astParent());
-                        tok2 = tok->astParent()->astOperand1();
+            const Token* parent = getParentLifetime(val.tokvalue, mSettings->library);
+            if (!exprs.insert(parent).second)
+                continue;
+            for (const ValueFlow::LifetimeToken& lt : ValueFlow::getLifetimeTokens(parent, *mSettings, escape || isAssignedToNonLocal(tok))) {
+                const Token * tokvalue = lt.token;
+                if (val.isLocalLifetimeValue()) {
+                    if (escape) {
+                        if (getPointerDepth(tok) < getPointerDepth(tokvalue))
+                            continue;
+                        if (!ValueFlow::isLifetimeBorrowed(tok, *mSettings))
+                            continue;
+                        if (tokvalue->exprId() == tok->exprId() && !(tok->variable() && tok->variable()->isArray()) &&
+                            !astIsContainerView(tok->astParent()))
+                            continue;
+                        if ((tokvalue->variable() && !isEscapedReference(tokvalue->variable()) &&
+                             isInScope(tokvalue->variable()->nameToken(), scope)) ||
+                            isDeadTemporary(tokvalue, nullptr, mSettings->library)) {
+                            if (!diag(tokvalue))
+                                errorReturnDanglingLifetime(tok, &val);
+                            break;
+                        }
+                    } else if (tokvalue->variable() && isDeadScope(tokvalue->variable()->nameToken(), tok->scope())) {
+                        errorInvalidLifetime(tok, &val);
+                        break;
+                    } else if (!tokvalue->variable() &&
+                               isDeadTemporary(tokvalue, tok, mSettings->library)) {
+                        if (!diag(tokvalue))
+                            errorDanglingTemporaryLifetime(tok, &val, tokvalue);
+                        break;
                     }
-                } else if (tok->variable() && tok->variable()->declarationId() == tok->varId()) {
-                    var = tok->variable();
                 }
-                if (!isLifetimeBorrowed(tok, mSettings))
-                    continue;
-                if (var && !var->isLocal() && !var->isArgument() && !isVariableChanged(tok->next(), tok->scope()->bodyEnd, var->declarationId(), var->isGlobal(), mSettings, mTokenizer->isCPP())) {
-                    errorDanglngLifetime(tok2, &val);
-                    break;
+                if (tokvalue->variable() && (isInScope(tokvalue->variable()->nameToken(), tok->scope()) ||
+                                             (val.isSubFunctionLifetimeValue() && isDanglingSubFunction(tokvalue, tok)))) {
+                    const Variable * var = nullptr;
+                    const Token * tok2 = tok;
+                    if (Token::simpleMatch(tok->astParent(), "=")) {
+                        if (astIsRHS(tok)) {
+                            var = getParentVar(tok->astParent()->astOperand1());
+                            tok2 = tok->astParent()->astOperand1();
+                        }
+                    } else if (tok->variable() && tok->variable()->declarationId() == tok->varId()) {
+                        var = tok->variable();
+                    }
+                    if (!ValueFlow::isLifetimeBorrowed(tok, *mSettings))
+                        continue;
+                    const Token* nextTok = nextAfterAstRightmostLeaf(tok->astTop());
+                    if (!nextTok)
+                        nextTok = tok->next();
+                    if (var && (!var->isLocal() || var->isStatic()) && !var->isArgument() && !(val.tokvalue && val.tokvalue->variable() && val.tokvalue->variable()->isStatic()) &&
+                        !isVariableChanged(nextTok,
+                                           tok->scope()->bodyEnd,
+                                           var->valueType() ? var->valueType()->pointer : 0,
+                                           var->declarationId(),
+                                           var->isGlobal(),
+                                           *mSettings)) {
+                        errorDanglngLifetime(tok2, &val, var->isLocal());
+                        break;
+                    }
                 }
             }
         }
@@ -613,9 +694,9 @@ void CheckAutoVariables::checkVarLifetimeScope(const Token * start, const Token
         }
         if (tok->str() == "{" && tok->scope()) {
             // Check functions in local classes
-            if (tok->scope()->type == Scope::eClass ||
-                tok->scope()->type == Scope::eStruct ||
-                tok->scope()->type == Scope::eUnion) {
+            if (tok->scope()->type == ScopeType::eClass ||
+                tok->scope()->type == ScopeType::eStruct ||
+                tok->scope()->type == ScopeType::eUnion) {
                 for (const Function& f:tok->scope()->functionList) {
                     if (f.functionScope)
                         checkVarLifetimeScope(f.functionScope->bodyStart, f.functionScope->bodyEnd);
@@ -628,6 +709,7 @@ void CheckAutoVariables::checkVarLifetimeScope(const Token * start, const Token
 
 void CheckAutoVariables::checkVarLifetime()
 {
+    logChecker("CheckAutoVariables::checkVarLifetime");
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         if (!scope->function)
@@ -642,7 +724,7 @@ void CheckAutoVariables::errorReturnDanglingLifetime(const Token *tok, const Val
     ErrorPath errorPath = val ? val->errorPath : ErrorPath();
     std::string msg = "Returning " + lifetimeMessage(tok, val, errorPath);
     errorPath.emplace_back(tok, "");
-    reportError(errorPath, Severity::error, "returnDanglingLifetime", msg + " that will be invalid when returning.", CWE562, inconclusive);
+    reportError(std::move(errorPath), Severity::error, "returnDanglingLifetime", msg + " that will be invalid when returning.", CWE562, inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
 void CheckAutoVariables::errorInvalidLifetime(const Token *tok, const ValueFlow::Value* val)
@@ -651,24 +733,47 @@ void CheckAutoVariables::errorInvalidLifetime(const Token *tok, const ValueFlow:
     ErrorPath errorPath = val ? val->errorPath : ErrorPath();
     std::string msg = "Using " + lifetimeMessage(tok, val, errorPath);
     errorPath.emplace_back(tok, "");
-    reportError(errorPath, Severity::error, "invalidLifetime", msg + " that is out of scope.", CWE562, inconclusive);
+    reportError(std::move(errorPath), Severity::error, "invalidLifetime", msg + " that is out of scope.", CWE562, inconclusive ? Certainty::inconclusive : Certainty::normal);
+}
+
+void CheckAutoVariables::errorDanglingTemporaryLifetime(const Token* tok, const ValueFlow::Value* val, const Token* tempTok)
+{
+    const bool inconclusive = val ? val->isInconclusive() : false;
+    ErrorPath errorPath = val ? val->errorPath : ErrorPath();
+    std::string msg = "Using " + lifetimeMessage(tok, val, errorPath);
+    errorPath.emplace_back(tempTok, "Temporary created here.");
+    errorPath.emplace_back(tok, "");
+    reportError(std::move(errorPath),
+                Severity::error,
+                "danglingTemporaryLifetime",
+                msg + " that is a temporary.",
+                CWE562,
+                inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
-void CheckAutoVariables::errorDanglngLifetime(const Token *tok, const ValueFlow::Value *val)
+void CheckAutoVariables::errorDanglngLifetime(const Token *tok, const ValueFlow::Value *val, bool isStatic)
 {
     const bool inconclusive = val ? val->isInconclusive() : false;
     ErrorPath errorPath = val ? val->errorPath : ErrorPath();
     std::string tokName = tok ? tok->expressionString() : "x";
-    std::string msg = "Non-local variable '" + tokName + "' will use " + lifetimeMessage(tok, val, errorPath);
+    std::string msg = isStatic ? "Static" : "Non-local";
+    msg += " variable '" + tokName + "' will use " + lifetimeMessage(tok, val, errorPath);
+    errorPath.emplace_back(tok, "");
+    reportError(std::move(errorPath), Severity::error, "danglingLifetime", msg + ".", CWE562, inconclusive ? Certainty::inconclusive : Certainty::normal);
+}
+
+void CheckAutoVariables::errorDanglingTempReference(const Token* tok, ErrorPath errorPath, bool inconclusive)
+{
     errorPath.emplace_back(tok, "");
-    reportError(errorPath, Severity::error, "danglingLifetime", msg + ".", CWE562, inconclusive);
+    reportError(
+        std::move(errorPath), Severity::error, "danglingTempReference", "Using reference to dangling temporary.", CWE562, inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
 void CheckAutoVariables::errorReturnReference(const Token* tok, ErrorPath errorPath, bool inconclusive)
 {
     errorPath.emplace_back(tok, "");
     reportError(
-        errorPath, Severity::error, "returnReference", "Reference to local variable returned.", CWE562, inconclusive);
+        std::move(errorPath), Severity::error, "returnReference", "Reference to local variable returned.", CWE562, inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
 void CheckAutoVariables::errorDanglingReference(const Token *tok, const Variable *var, ErrorPath errorPath)
@@ -677,24 +782,30 @@ void CheckAutoVariables::errorDanglingReference(const Token *tok, const Variable
     std::string varName = var ? var->name() : "y";
     std::string msg = "Non-local reference variable '" + tokName + "' to local variable '" + varName + "'";
     errorPath.emplace_back(tok, "");
-    reportError(errorPath, Severity::error, "danglingReference", msg, CWE562, false);
+    reportError(std::move(errorPath), Severity::error, "danglingReference", msg, CWE562, Certainty::normal);
 }
 
-void CheckAutoVariables::errorReturnTempReference(const Token *tok)
+void CheckAutoVariables::errorReturnTempReference(const Token* tok, ErrorPath errorPath, bool inconclusive)
 {
-    reportError(tok, Severity::error, "returnTempReference", "Reference to temporary returned.", CWE562, false);
+    errorPath.emplace_back(tok, "");
+    reportError(
+        std::move(errorPath), Severity::error, "returnTempReference", "Reference to temporary returned.", CWE562, inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
 void CheckAutoVariables::errorInvalidDeallocation(const Token *tok, const ValueFlow::Value *val)
 {
     const Variable *var = val ? val->tokvalue->variable() : (tok ? tok->variable() : nullptr);
 
-    std::string type = "auto-variable";
-    if (var) {
+    std::string type = "an auto-variable";
+    if (tok && tok->tokType() == Token::eString)
+        type = "a string literal";
+    else if (val && val->tokvalue->tokType() == Token::eString)
+        type = "a pointer pointing to a string literal";
+    else if (var) {
         if (var->isGlobal())
-            type = "global variable";
+            type = "a global variable";
         else if (var->isStatic())
-            type = "static variable";
+            type = "a static variable";
     }
 
     if (val)
@@ -703,7 +814,32 @@ void CheckAutoVariables::errorInvalidDeallocation(const Token *tok, const ValueF
     reportError(getErrorPath(tok, val, "Deallocating memory that was not dynamically allocated"),
                 Severity::error,
                 "autovarInvalidDeallocation",
-                "Deallocation of an " + type + " results in undefined behaviour.\n"
-                "The deallocation of an " + type + " results in undefined behaviour. You should only free memory "
-                "that has been allocated dynamically.", CWE590, false);
+                "Deallocation of " + type + " results in undefined behaviour.\n"
+                "The deallocation of " + type + " results in undefined behaviour. You should only free memory "
+                "that has been allocated dynamically.", CWE590, Certainty::normal);
+}
+
+void CheckAutoVariables::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    CheckAutoVariables checkAutoVariables(&tokenizer, &tokenizer.getSettings(), errorLogger);
+    checkAutoVariables.assignFunctionArg();
+    checkAutoVariables.checkVarLifetime();
+    checkAutoVariables.autoVariables();
+}
+
+void CheckAutoVariables::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const
+{
+    CheckAutoVariables c(nullptr,settings,errorLogger);
+    c.errorAutoVariableAssignment(nullptr, false);
+    c.errorReturnReference(nullptr, ErrorPath{}, false);
+    c.errorDanglingReference(nullptr, nullptr, ErrorPath{});
+    c.errorReturnTempReference(nullptr, ErrorPath{}, false);
+    c.errorDanglingTempReference(nullptr, ErrorPath{}, false);
+    c.errorInvalidDeallocation(nullptr, nullptr);
+    c.errorUselessAssignmentArg(nullptr);
+    c.errorUselessAssignmentPtrArg(nullptr);
+    c.errorReturnDanglingLifetime(nullptr, nullptr);
+    c.errorInvalidLifetime(nullptr, nullptr);
+    c.errorDanglngLifetime(nullptr, nullptr);
+    c.errorDanglingTemporaryLifetime(nullptr, nullptr, nullptr);
 }
diff --git a/lib/checkautovariables.h b/lib/checkautovariables.h
index 9bdb1900e4c..d94f254508f 100644
--- a/lib/checkautovariables.h
+++ b/lib/checkautovariables.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,14 +24,21 @@
 
 #include "check.h"
 #include "config.h"
+#include "errortypes.h"
 
 #include <string>
+#include <set>
 
-class ErrorLogger;
 class Settings;
 class Token;
+class ErrorLogger;
+class Variable;
 class Tokenizer;
 
+namespace ValueFlow {
+    class Value;
+}
+
 /// @addtogroup Checks
 /** @brief Various small checks for automatic variables */
 /// @{
@@ -40,22 +47,15 @@ class Tokenizer;
 class CPPCHECKLIB CheckAutoVariables : public Check {
 public:
     /** This constructor is used when registering the CheckClass */
-    CheckAutoVariables() : Check(myName()) {
-    }
+    CheckAutoVariables() : Check(myName()) {}
 
+private:
     /** This constructor is used when running checks. */
     CheckAutoVariables(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger) {}
 
     /** @brief Run checks against the normal token list */
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        CheckAutoVariables checkAutoVariables(tokenizer, settings, errorLogger);
-        checkAutoVariables.assignFunctionArg();
-        checkAutoVariables.returnReference();
-        checkAutoVariables.checkVarLifetime();
-        checkAutoVariables.autoVariables();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     /** assign function argument */
     void assignFunctionArg();
@@ -63,59 +63,35 @@ class CPPCHECKLIB CheckAutoVariables : public Check {
     /** Check auto variables */
     void autoVariables();
 
-    /** Returning reference to local/temporary variable */
-    void returnReference();
+    /**
+     * Check variable assignment.. value must be changed later or there will be a error reported
+     * @return true if error is reported */
+    bool checkAutoVariableAssignment(const Token *expr, bool inconclusive, const Token *startToken = nullptr);
 
     void checkVarLifetime();
 
     void checkVarLifetimeScope(const Token * start, const Token * end);
 
-private:
-    /**
-     * Returning a temporary object?
-     * @param tok pointing at the "return" token
-     * @return true if a temporary object is returned
-     */
-    static bool returnTemporary(const Token *tok);
-
-    void errorReturnAddressToAutoVariable(const Token *tok);
-    void errorReturnAddressToAutoVariable(const Token *tok, const ValueFlow::Value *value);
-    void errorReturnPointerToLocalArray(const Token *tok);
     void errorAutoVariableAssignment(const Token *tok, bool inconclusive);
     void errorReturnDanglingLifetime(const Token *tok, const ValueFlow::Value* val);
     void errorInvalidLifetime(const Token *tok, const ValueFlow::Value* val);
-    void errorDanglngLifetime(const Token *tok, const ValueFlow::Value *val);
+    void errorDanglngLifetime(const Token *tok, const ValueFlow::Value *val, bool isStatic = false);
+    void errorDanglingTemporaryLifetime(const Token* tok, const ValueFlow::Value* val, const Token* tempTok);
     void errorReturnReference(const Token* tok, ErrorPath errorPath, bool inconclusive);
     void errorDanglingReference(const Token *tok, const Variable *var, ErrorPath errorPath);
-    void errorReturnTempReference(const Token *tok);
+    void errorDanglingTempReference(const Token* tok, ErrorPath errorPath, bool inconclusive);
+    void errorReturnTempReference(const Token* tok, ErrorPath errorPath, bool inconclusive);
     void errorInvalidDeallocation(const Token *tok, const ValueFlow::Value *val);
-    void errorReturnAddressOfFunctionParameter(const Token *tok, const std::string &varname);
     void errorUselessAssignmentArg(const Token *tok);
     void errorUselessAssignmentPtrArg(const Token *tok);
 
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        ErrorPath errorPath;
-        CheckAutoVariables c(nullptr,settings,errorLogger);
-        c.errorAutoVariableAssignment(nullptr, false);
-        c.errorReturnAddressToAutoVariable(nullptr);
-        c.errorReturnPointerToLocalArray(nullptr);
-        c.errorReturnReference(nullptr, errorPath, false);
-        c.errorDanglingReference(nullptr, nullptr, errorPath);
-        c.errorReturnTempReference(nullptr);
-        c.errorInvalidDeallocation(nullptr, nullptr);
-        c.errorReturnAddressOfFunctionParameter(nullptr, "parameter");
-        c.errorUselessAssignmentArg(nullptr);
-        c.errorUselessAssignmentPtrArg(nullptr);
-        c.errorReturnDanglingLifetime(nullptr, nullptr);
-        c.errorInvalidLifetime(nullptr, nullptr);
-        c.errorDanglngLifetime(nullptr, nullptr);
-    }
+    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const override;
 
     static std::string myName() {
         return "Auto Variables";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "A pointer to a variable is only valid as long as the variable is in scope.\n"
                "Check:\n"
                "- returning a pointer to auto or temporary variable\n"
@@ -125,6 +101,11 @@ class CPPCHECKLIB CheckAutoVariables : public Check {
                "- suspicious assignment of pointer argument\n"
                "- useless assignment of function argument\n";
     }
+
+    /** returns true if tokvalue has already been diagnosed */
+    bool diag(const Token* tokvalue);
+
+    std::set<const Token*> mDiagDanglingTemp;
 };
 /// @}
 //---------------------------------------------------------------------------
diff --git a/lib/checkbool.cpp b/lib/checkbool.cpp
index dc38193ec0d..93e501416aa 100644
--- a/lib/checkbool.cpp
+++ b/lib/checkbool.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,16 +21,15 @@
 #include "checkbool.h"
 
 #include "astutils.h"
-#include "errorlogger.h"
-#include "mathlib.h"
+#include "errortypes.h"
 #include "settings.h"
 #include "symboldatabase.h"
 #include "token.h"
 #include "tokenize.h"
-#include "valueflow.h"
+#include "vfvalue.h"
 
-#include <cstddef>
 #include <list>
+#include <vector>
 //---------------------------------------------------------------------------
 
 // Register this check class (by creating a static instance of it)
@@ -51,9 +50,11 @@ static bool isBool(const Variable* var)
 //---------------------------------------------------------------------------
 void CheckBool::checkIncrementBoolean()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("incrementboolean"))
         return;
 
+    logChecker("CheckBool::checkIncrementBoolean"); // style
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
@@ -72,8 +73,15 @@ void CheckBool::incrementBooleanError(const Token *tok)
         "incrementboolean",
         "Incrementing a variable of type 'bool' with postfix operator++ is deprecated by the C++ Standard. You should assign it the value 'true' instead.\n"
         "The operand of a postfix increment operator may be of type bool but it is deprecated by C++ Standard (Annex D-1) and the operand is always set to true. You should assign it the value 'true' instead.",
-        CWE398, false
-    );
+        CWE398, Certainty::normal
+        );
+}
+
+static bool isConvertedToBool(const Token* tok)
+{
+    if (!tok->astParent())
+        return false;
+    return astIsBool(tok->astParent()) || Token::Match(tok->astParent()->previous(), "if|while (");
 }
 
 //---------------------------------------------------------------------------
@@ -82,40 +90,59 @@ void CheckBool::incrementBooleanError(const Token *tok)
 //---------------------------------------------------------------------------
 void CheckBool::checkBitwiseOnBoolean()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->isPremiumEnabled("bitwiseOnBoolean") &&
+        !mSettings->severity.isEnabled(Severity::style) &&
+        // danmar: this is inconclusive because I don't like that there are
+        //         warnings for calculations. Example: set_flag(a & b);
+        !mSettings->certainty.isEnabled(Certainty::inconclusive))
         return;
 
-    // danmar: this is inconclusive because I don't like that there are
-    //         warnings for calculations. Example: set_flag(a & b);
-    if (!mSettings->inconclusive)
-        return;
+    logChecker("CheckBool::checkBitwiseOnBoolean"); // style,inconclusive
 
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
-            if (Token::Match(tok, "(|.|return|&&|%oror%|throw|, %var% [&|]")) {
-                const Variable *var = tok->next()->variable();
-                if (isBool(var)) {
-                    bitwiseOnBooleanError(tok->next(), var->name(), tok->strAt(2) == "&" ? "&&" : "||");
-                    tok = tok->tokAt(2);
-                }
-            } else if (Token::Match(tok, "[&|] %var% )|.|return|&&|%oror%|throw|,") && (!tok->previous() || !tok->previous()->isExtendedOp() || tok->strAt(-1) == ")" || tok->strAt(-1) == "]")) {
-                const Variable *var = tok->next()->variable();
-                if (isBool(var)) {
-                    bitwiseOnBooleanError(tok->next(), var->name(), tok->str() == "&" ? "&&" : "||");
-                    tok = tok->tokAt(2);
-                }
+            if (tok->isBinaryOp()) {
+                bool isCompound{};
+                if (tok->str() == "&" || tok->str() == "|")
+                    isCompound = false;
+                else if (tok->str() == "&=" || tok->str() == "|=")
+                    isCompound = true;
+                else
+                    continue;
+                const bool isBoolOp1 = astIsBool(tok->astOperand1());
+                const bool isBoolOp2 = astIsBool(tok->astOperand2());
+                if (!tok->astOperand1()->valueType() || !tok->astOperand2()->valueType())
+                    continue;
+                if (!(isBoolOp1 || isBoolOp2))
+                    continue;
+                if (isCompound && (!isBoolOp1 || isBoolOp2))
+                    continue;
+                if (tok->str() == "|" && !isConvertedToBool(tok) && !(isBoolOp1 && isBoolOp2))
+                    continue;
+                // first operand will always be evaluated
+                if (!isConstExpression(tok->astOperand2(), mSettings->library))
+                    continue;
+                if (tok->astOperand2()->variable() && tok->astOperand2()->variable()->nameToken() == tok->astOperand2())
+                    continue;
+                const std::string expression = (isBoolOp1 ? tok->astOperand1() : tok->astOperand2())->expressionString();
+                bitwiseOnBooleanError(tok, expression, tok->str() == "&" ? "&&" : "||", isCompound);
             }
         }
     }
 }
 
-void CheckBool::bitwiseOnBooleanError(const Token *tok, const std::string &varname, const std::string &op)
+void CheckBool::bitwiseOnBooleanError(const Token* tok, const std::string& expression, const std::string& op, bool isCompound)
 {
-    reportError(tok, Severity::style, "bitwiseOnBoolean",
-                "Boolean variable '" + varname + "' is used in bitwise operation. Did you mean '" + op + "'?",
+    std::string msg = "Boolean expression '" + expression + "' is used in bitwise operation.";
+    if (!isCompound)
+        msg += " Did you mean '" + op + "'?";
+    reportError(tok,
+                Severity::style,
+                "bitwiseOnBoolean",
+                msg,
                 CWE398,
-                true);
+                Certainty::inconclusive);
 }
 
 //---------------------------------------------------------------------------
@@ -124,9 +151,11 @@ void CheckBool::bitwiseOnBooleanError(const Token *tok, const std::string &varna
 
 void CheckBool::checkComparisonOfBoolWithInt()
 {
-    if (!mSettings->isEnabled(Settings::WARNING) || !mTokenizer->isCPP())
+    if (!mSettings->severity.isEnabled(Severity::warning) || !mTokenizer->isCPP())
         return;
 
+    logChecker("CheckBool::checkComparisonOfBoolWithInt"); // warning,c++
+
     const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
@@ -162,7 +191,7 @@ void CheckBool::comparisonOfBoolWithInvalidComparator(const Token *tok, const st
 
 static bool tokenIsFunctionReturningBool(const Token* tok)
 {
-    const Function* func = tok->function();
+    const Function* func = tok ? tok->function() : nullptr;
     if (func && Token::Match(tok, "%name% (")) {
         if (func->tokenDef && Token::Match(func->tokenDef->previous(), "bool|_Bool")) {
             return true;
@@ -173,26 +202,35 @@ static bool tokenIsFunctionReturningBool(const Token* tok)
 
 void CheckBool::checkComparisonOfFuncReturningBool()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style))
         return;
 
     if (!mTokenizer->isCPP())
         return;
 
+    logChecker("CheckBool::checkComparisonOfFuncReturningBool"); // style,c++
+
     const SymbolDatabase * const symbolDatabase = mTokenizer->getSymbolDatabase();
+    auto getFunctionTok = [](const Token* tok) -> const Token* {
+        while (Token::simpleMatch(tok, "!") || (tok && tok->isCast() && !isCPPCast(tok)))
+            tok = tok->astOperand1();
+        if (isCPPCast(tok))
+            tok = tok->astOperand2();
+        if (tok)
+            return tok->previous();
+        return nullptr;
+    };
 
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
             if (!tok->isComparisonOp() || tok->str() == "==" || tok->str() == "!=")
                 continue;
-            const Token *firstToken = tok->previous();
-            if (tok->strAt(-1) == ")") {
-                firstToken = firstToken->link()->previous();
-            }
-            const Token *secondToken = tok->next();
-            while (secondToken->str() == "!") {
-                secondToken = secondToken->next();
-            }
+
+            const Token* firstToken = getFunctionTok(tok->astOperand1());
+            const Token* secondToken = getFunctionTok(tok->astOperand2());
+            if (!firstToken || !secondToken)
+                continue;
+
             const bool firstIsFunctionReturningBool = tokenIsFunctionReturningBool(firstToken);
             const bool secondIsFunctionReturningBool = tokenIsFunctionReturningBool(secondToken);
             if (firstIsFunctionReturningBool && secondIsFunctionReturningBool) {
@@ -212,7 +250,7 @@ void CheckBool::comparisonOfFuncReturningBoolError(const Token *tok, const std::
                 "Comparison of a function returning boolean value using relational (<, >, <= or >=) operator.\n"
                 "The return type of function '" + expression + "' is 'bool' "
                 "and result is of type 'bool'. Comparing 'bool' value using relational (<, >, <= or >=)"
-                " operator could cause unexpected results.", CWE398, false);
+                " operator could cause unexpected results.", CWE398, Certainty::normal);
 }
 
 void CheckBool::comparisonOfTwoFuncsReturningBoolError(const Token *tok, const std::string &expression1, const std::string &expression2)
@@ -221,7 +259,7 @@ void CheckBool::comparisonOfTwoFuncsReturningBoolError(const Token *tok, const s
                 "Comparison of two functions returning boolean value using relational (<, >, <= or >=) operator.\n"
                 "The return type of function '" + expression1 + "' and function '" + expression2 + "' is 'bool' "
                 "and result is of type 'bool'. Comparing 'bool' value using relational (<, >, <= or >=)"
-                " operator could cause unexpected results.", CWE398, false);
+                " operator could cause unexpected results.", CWE398, Certainty::normal);
 }
 
 //-------------------------------------------------------------------------------
@@ -230,17 +268,14 @@ void CheckBool::comparisonOfTwoFuncsReturningBoolError(const Token *tok, const s
 
 void CheckBool::checkComparisonOfBoolWithBool()
 {
-    // FIXME: This checking is "experimental" because of the false positives
-    //        when self checking lib/tokenize.cpp (#2617)
-    if (!mSettings->experimental)
-        return;
-
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style))
         return;
 
     if (!mTokenizer->isCPP())
         return;
 
+    logChecker("CheckBool::checkComparisonOfBoolWithBool"); // style,c++
+
     const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope * scope : symbolDatabase->functionScopes) {
@@ -278,12 +313,13 @@ void CheckBool::comparisonOfBoolWithBoolError(const Token *tok, const std::strin
                 "Comparison of a variable having boolean value using relational (<, >, <= or >=) operator.\n"
                 "The variable '" + expression + "' is of type 'bool' "
                 "and comparing 'bool' value using relational (<, >, <= or >=)"
-                " operator could cause unexpected results.", CWE398, false);
+                " operator could cause unexpected results.", CWE398, Certainty::normal);
 }
 
 //-----------------------------------------------------------------------------
 void CheckBool::checkAssignBoolToPointer()
 {
+    logChecker("CheckBool::checkAssignBoolToPointer");
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
@@ -297,16 +333,18 @@ void CheckBool::checkAssignBoolToPointer()
 void CheckBool::assignBoolToPointerError(const Token *tok)
 {
     reportError(tok, Severity::error, "assignBoolToPointer",
-                "Boolean value assigned to pointer.", CWE587, false);
+                "Boolean value assigned to pointer.", CWE587, Certainty::normal);
 }
 
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 void CheckBool::checkComparisonOfBoolExpressionWithInt()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning) && !mSettings->isPremiumEnabled("compareBoolExpressionWithInt"))
         return;
 
+    logChecker("CheckBool::checkComparisonOfBoolExpressionWithInt"); // warning
+
     const SymbolDatabase* symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope * scope : symbolDatabase->functionScopes) {
@@ -340,49 +378,54 @@ void CheckBool::checkComparisonOfBoolExpressionWithInt()
             if (astIsBool(numTok))
                 continue;
 
-            if (numTok->isNumber()) {
-                const MathLib::bigint num = MathLib::toLongNumber(numTok->str());
-                if (num==0 &&
-                    (numInRhs ? Token::Match(tok, ">|==|!=")
-                     : Token::Match(tok, "<|==|!=")))
-                    continue;
-                if (num==1 &&
-                    (numInRhs ? Token::Match(tok, "<|==|!=")
-                     : Token::Match(tok, ">|==|!=")))
-                    continue;
-                comparisonOfBoolExpressionWithIntError(tok, true);
-            } else if (astIsIntegral(numTok, false) && mTokenizer->isCPP())
-                comparisonOfBoolExpressionWithIntError(tok, false);
+            const ValueFlow::Value *minval = numTok->getValueLE(0, *mSettings);
+            if (minval && minval->intvalue == 0 &&
+                (numInRhs ? Token::Match(tok, ">|==|!=")
+                 : Token::Match(tok, "<|==|!=")))
+                minval = nullptr;
+
+            const ValueFlow::Value *maxval = numTok->getValueGE(1, *mSettings);
+            if (maxval && maxval->intvalue == 1 &&
+                (numInRhs ? Token::Match(tok, "<|==|!=")
+                 : Token::Match(tok, ">|==|!=")))
+                maxval = nullptr;
+
+            if (minval || maxval) {
+                const bool not0or1 = (minval && minval->intvalue < 0) || (maxval && maxval->intvalue > 1);
+                comparisonOfBoolExpressionWithIntError(tok, not0or1);
+            }
         }
     }
 }
 
-void CheckBool::comparisonOfBoolExpressionWithIntError(const Token *tok, bool n0o1)
+void CheckBool::comparisonOfBoolExpressionWithIntError(const Token *tok, bool not0or1)
 {
-    if (n0o1)
+    if (not0or1)
         reportError(tok, Severity::warning, "compareBoolExpressionWithInt",
-                    "Comparison of a boolean expression with an integer other than 0 or 1.", CWE398, false);
+                    "Comparison of a boolean expression with an integer other than 0 or 1.", CWE398, Certainty::normal);
     else
         reportError(tok, Severity::warning, "compareBoolExpressionWithInt",
-                    "Comparison of a boolean expression with an integer.", CWE398, false);
+                    "Comparison of a boolean expression with an integer.", CWE398, Certainty::normal);
 }
 
 
 void CheckBool::pointerArithBool()
 {
+    logChecker("CheckBool::pointerArithBool");
+
     const SymbolDatabase* symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope &scope : symbolDatabase->scopeList) {
-        if (scope.type != Scope::eIf && scope.type != Scope::eWhile && scope.type != Scope::eDo && scope.type != Scope::eFor)
+        if (scope.type != ScopeType::eIf && !scope.isLoopScope())
             continue;
         const Token* tok = scope.classDef->next()->astOperand2();
-        if (scope.type == Scope::eFor) {
+        if (scope.type == ScopeType::eFor) {
             tok = Token::findsimplematch(scope.classDef->tokAt(2), ";");
             if (tok)
                 tok = tok->astOperand2();
             if (tok)
                 tok = tok->astOperand1();
-        } else if (scope.type == Scope::eDo)
+        } else if (scope.type == ScopeType::eDo)
             tok = (scope.bodyEnd->tokAt(2)) ? scope.bodyEnd->tokAt(2)->astOperand2() : nullptr;
 
         pointerArithBoolCond(tok);
@@ -415,15 +458,16 @@ void CheckBool::pointerArithBoolError(const Token *tok)
                 Severity::error,
                 "pointerArithBool",
                 "Converting pointer arithmetic result to bool. The bool is always true unless there is undefined behaviour.\n"
-                "Converting pointer arithmetic result to bool. The boolean result is always true unless there is pointer arithmetic overflow, and overflow is undefined behaviour. Probably a dereference is forgotten.", CWE571, false);
+                "Converting pointer arithmetic result to bool. The boolean result is always true unless there is pointer arithmetic overflow, and overflow is undefined behaviour. Probably a dereference is forgotten.", CWE571, Certainty::normal);
 }
 
 void CheckBool::checkAssignBoolToFloat()
 {
     if (!mTokenizer->isCPP())
         return;
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style))
         return;
+    logChecker("CheckBool::checkAssignBoolToFloat"); // style,c++
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
@@ -437,14 +481,16 @@ void CheckBool::checkAssignBoolToFloat()
 void CheckBool::assignBoolToFloatError(const Token *tok)
 {
     reportError(tok, Severity::style, "assignBoolToFloat",
-                "Boolean value assigned to floating point variable.", CWE704, false);
+                "Boolean value assigned to floating point variable.", CWE704, Certainty::normal);
 }
 
 void CheckBool::returnValueOfFunctionReturningBool()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style))
         return;
 
+    logChecker("CheckBool::returnValueOfFunctionReturningBool"); // style
+
     const SymbolDatabase * const symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope * scope : symbolDatabase->functionScopes) {
@@ -459,7 +505,7 @@ void CheckBool::returnValueOfFunctionReturningBool()
             else if (tok->scope() && tok->scope()->isClassOrStruct())
                 tok = tok->scope()->bodyEnd;
             else if (Token::simpleMatch(tok, "return") && tok->astOperand1() &&
-                     (tok->astOperand1()->getValueGE(2, mSettings) || tok->astOperand1()->getValueLE(-1, mSettings)) &&
+                     (tok->astOperand1()->getValueGE(2, *mSettings) || tok->astOperand1()->getValueLE(-1, *mSettings)) &&
                      !(tok->astOperand1()->astOperand1() && Token::Match(tok->astOperand1(), "&|%or%")))
                 returnValueBoolError(tok);
         }
@@ -470,3 +516,36 @@ void CheckBool::returnValueBoolError(const Token *tok)
 {
     reportError(tok, Severity::style, "returnNonBoolInBooleanFunction", "Non-boolean value returned from function returning bool");
 }
+
+void CheckBool::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    CheckBool checkBool(&tokenizer, &tokenizer.getSettings(), errorLogger);
+
+    // Checks
+    checkBool.checkComparisonOfBoolExpressionWithInt();
+    checkBool.checkComparisonOfBoolWithInt();
+    checkBool.checkAssignBoolToFloat();
+    checkBool.pointerArithBool();
+    checkBool.returnValueOfFunctionReturningBool();
+    checkBool.checkComparisonOfFuncReturningBool();
+    checkBool.checkComparisonOfBoolWithBool();
+    checkBool.checkIncrementBoolean();
+    checkBool.checkAssignBoolToPointer();
+    checkBool.checkBitwiseOnBoolean();
+}
+
+void CheckBool::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const
+{
+    CheckBool c(nullptr, settings, errorLogger);
+    c.assignBoolToPointerError(nullptr);
+    c.assignBoolToFloatError(nullptr);
+    c.comparisonOfFuncReturningBoolError(nullptr, "func_name");
+    c.comparisonOfTwoFuncsReturningBoolError(nullptr, "func_name1", "func_name2");
+    c.comparisonOfBoolWithBoolError(nullptr, "var_name");
+    c.incrementBooleanError(nullptr);
+    c.bitwiseOnBooleanError(nullptr, "expression", "&&");
+    c.comparisonOfBoolExpressionWithIntError(nullptr, true);
+    c.pointerArithBoolError(nullptr);
+    c.comparisonOfBoolWithInvalidComparator(nullptr, "expression");
+    c.returnValueBoolError(nullptr);
+}
diff --git a/lib/checkbool.h b/lib/checkbool.h
index 177e9312597..65e5d0254ea 100644
--- a/lib/checkbool.h
+++ b/lib/checkbool.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -41,30 +41,15 @@ class Tokenizer;
 class CPPCHECKLIB CheckBool : public Check {
 public:
     /** @brief This constructor is used when registering the CheckClass */
-    CheckBool() : Check(myName()) {
-    }
+    CheckBool() : Check(myName()) {}
 
+private:
     /** @brief This constructor is used when running checks. */
     CheckBool(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger) {}
 
     /** @brief Run checks against the normal token list */
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        CheckBool checkBool(tokenizer, settings, errorLogger);
-
-        // Checks
-        checkBool.checkComparisonOfBoolExpressionWithInt();
-        checkBool.checkComparisonOfBoolWithInt();
-        checkBool.checkAssignBoolToFloat();
-        checkBool.pointerArithBool();
-        checkBool.returnValueOfFunctionReturningBool();
-        checkBool.checkComparisonOfFuncReturningBool();
-        checkBool.checkComparisonOfBoolWithBool();
-        checkBool.checkIncrementBoolean();
-        checkBool.checkAssignBoolToPointer();
-        checkBool.checkBitwiseOnBoolean();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     /** @brief %Check for comparison of function returning bool*/
     void checkComparisonOfFuncReturningBool();
@@ -97,7 +82,6 @@ class CPPCHECKLIB CheckBool : public Check {
     /** @brief %Check if a function returning bool returns an integer other than 0 or 1 */
     void returnValueOfFunctionReturningBool();
 
-private:
     // Error messages..
     void comparisonOfFuncReturningBoolError(const Token *tok, const std::string &expression);
     void comparisonOfTwoFuncsReturningBoolError(const Token *tok, const std::string &expression1, const std::string &expression2);
@@ -106,32 +90,18 @@ class CPPCHECKLIB CheckBool : public Check {
     void comparisonOfBoolWithInvalidComparator(const Token *tok, const std::string &expression);
     void assignBoolToPointerError(const Token *tok);
     void assignBoolToFloatError(const Token *tok);
-    void bitwiseOnBooleanError(const Token *tok, const std::string &varname, const std::string &op);
-    void comparisonOfBoolExpressionWithIntError(const Token *tok, bool n0o1);
+    void bitwiseOnBooleanError(const Token* tok, const std::string& expression, const std::string& op, bool isCompound = false);
+    void comparisonOfBoolExpressionWithIntError(const Token *tok, bool not0or1);
     void pointerArithBoolError(const Token *tok);
     void returnValueBoolError(const Token *tok);
 
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        CheckBool c(nullptr, settings, errorLogger);
-
-        c.assignBoolToPointerError(nullptr);
-        c.assignBoolToFloatError(nullptr);
-        c.comparisonOfFuncReturningBoolError(nullptr, "func_name");
-        c.comparisonOfTwoFuncsReturningBoolError(nullptr, "func_name1", "func_name2");
-        c.comparisonOfBoolWithBoolError(nullptr, "var_name");
-        c.incrementBooleanError(nullptr);
-        c.bitwiseOnBooleanError(nullptr, "varname", "&&");
-        c.comparisonOfBoolExpressionWithIntError(nullptr, true);
-        c.pointerArithBoolError(nullptr);
-        c.comparisonOfBoolWithInvalidComparator(nullptr, "expression");
-        c.returnValueBoolError(nullptr);
-    }
+    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const override;
 
     static std::string myName() {
         return "Boolean";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Boolean type checks\n"
                "- using increment on boolean\n"
                "- comparison of a boolean expression with an integer other than 0 or 1\n"
diff --git a/lib/checkboost.cpp b/lib/checkboost.cpp
deleted file mode 100644
index b0fbd339d46..00000000000
--- a/lib/checkboost.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "checkboost.h"
-
-#include "errorlogger.h"
-#include "symboldatabase.h"
-#include "token.h"
-
-#include <cstddef>
-
-// Register this check class (by creating a static instance of it)
-namespace {
-    CheckBoost instance;
-}
-
-static const CWE CWE664(664);
-
-void CheckBoost::checkBoostForeachModification()
-{
-    const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
-    for (const Scope * scope : symbolDatabase->functionScopes) {
-        for (const Token *tok = scope->bodyStart->next(); tok && tok != scope->bodyEnd; tok = tok->next()) {
-            if (!Token::simpleMatch(tok, "BOOST_FOREACH ("))
-                continue;
-
-            const Token *containerTok = tok->next()->link()->previous();
-            if (!Token::Match(containerTok, "%var% ) {"))
-                continue;
-
-            const Token *tok2 = containerTok->tokAt(2);
-            const Token *end = tok2->link();
-            for (; tok2 != end; tok2 = tok2->next()) {
-                if (Token::Match(tok2, "%varid% . insert|erase|push_back|push_front|pop_front|pop_back|clear|swap|resize|assign|merge|remove|remove_if|reverse|sort|splice|unique|pop|push", containerTok->varId())) {
-                    const Token* nextStatement = Token::findsimplematch(tok2->linkAt(3), ";", end);
-                    if (!Token::Match(nextStatement, "; break|return|throw"))
-                        boostForeachError(tok2);
-                    break;
-                }
-            }
-        }
-    }
-}
-
-void CheckBoost::boostForeachError(const Token *tok)
-{
-    reportError(tok, Severity::error, "boostForeachError",
-                "BOOST_FOREACH caches the end() iterator. It's undefined behavior if you modify the container inside.", CWE664, false
-               );
-}
diff --git a/lib/checkboost.h b/lib/checkboost.h
deleted file mode 100644
index b8a3fab017f..00000000000
--- a/lib/checkboost.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-//---------------------------------------------------------------------------
-#ifndef checkboostH
-#define checkboostH
-//---------------------------------------------------------------------------
-
-#include "check.h"
-#include "config.h"
-#include "tokenize.h"
-
-#include <string>
-
-class ErrorLogger;
-class Settings;
-class Token;
-
-/// @addtogroup Checks
-/// @{
-
-
-/** @brief %Check Boost usage */
-class CPPCHECKLIB CheckBoost : public Check {
-public:
-    /** This constructor is used when registering the CheckClass */
-    CheckBoost() : Check(myName()) {
-    }
-
-    /** This constructor is used when running checks. */
-    CheckBoost(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
-
-    /** @brief Run checks against the normal token list */
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        if (!tokenizer->isCPP())
-            return;
-
-        CheckBoost checkBoost(tokenizer, settings, errorLogger);
-        checkBoost.checkBoostForeachModification();
-    }
-
-    /** @brief %Check for container modification while using the BOOST_FOREACH macro */
-    void checkBoostForeachModification();
-
-private:
-    void boostForeachError(const Token *tok);
-
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        CheckBoost c(nullptr, settings, errorLogger);
-        c.boostForeachError(nullptr);
-    }
-
-    static std::string myName() {
-        return "Boost usage";
-    }
-
-    std::string classInfo() const OVERRIDE {
-        return "Check for invalid usage of Boost:\n"
-               "- container modification during BOOST_FOREACH\n";
-    }
-};
-/// @}
-//---------------------------------------------------------------------------
-#endif // checkboostH
diff --git a/lib/checkbufferoverrun.cpp b/lib/checkbufferoverrun.cpp
index f86ff302c66..a8f7efeabd6 100644
--- a/lib/checkbufferoverrun.cpp
+++ b/lib/checkbufferoverrun.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,8 +23,11 @@
 #include "checkbufferoverrun.h"
 
 #include "astutils.h"
+#include "errorlogger.h"
+#include "errortypes.h"
 #include "library.h"
 #include "mathlib.h"
+#include "platform.h"
 #include "settings.h"
 #include "symboldatabase.h"
 #include "token.h"
@@ -32,15 +35,18 @@
 #include "tokenlist.h"
 #include "utils.h"
 #include "valueflow.h"
+#include "vfvalue.h"
 
-#include <tinyxml2.h>
 #include <algorithm>
 #include <cstdlib>
+#include <functional>
+#include <iterator>
 #include <numeric> // std::accumulate
 #include <sstream>
-#include <stack>
 #include <utility>
 
+#include "xml.h"
+
 //---------------------------------------------------------------------------
 
 // Register this check class (by creating a static instance of it)
@@ -53,8 +59,8 @@ namespace {
 // CWE ids used:
 static const CWE CWE131(131U);  // Incorrect Calculation of Buffer Size
 static const CWE CWE170(170U);  // Improper Null Termination
+static const CWE CWE_ARGUMENT_SIZE(398U);  // Indicator of Poor Code Quality
 static const CWE CWE_ARRAY_INDEX_THEN_CHECK(398U);  // Indicator of Poor Code Quality
-static const CWE CWE682(682U);  // Incorrect Calculation
 static const CWE CWE758(758U);  // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior
 static const CWE CWE_POINTER_ARITHMETIC_OVERFLOW(758U); // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior
 static const CWE CWE_BUFFER_UNDERRUN(786U);  // Access of Memory Location Before Start of Buffer
@@ -65,8 +71,16 @@ static const CWE CWE_BUFFER_OVERRUN(788U);   // Access of Memory Location After
 static const ValueFlow::Value *getBufferSizeValue(const Token *tok)
 {
     const std::list<ValueFlow::Value> &tokenValues = tok->values();
-    const auto it = std::find_if(tokenValues.begin(), tokenValues.end(), std::mem_fn(&ValueFlow::Value::isBufferSizeValue));
-    return it == tokenValues.end() ? nullptr : &*it;
+    const auto it = std::find_if(tokenValues.cbegin(), tokenValues.cend(), std::mem_fn(&ValueFlow::Value::isBufferSizeValue));
+    return it == tokenValues.cend() ? nullptr : &*it;
+}
+
+static const Token* getRealBufferTok(const Token* tok) {
+    if (!tok->isUnaryOp("&"))
+        return tok;
+
+    const Token* op = tok->astOperand1();
+    return (op->valueType() && op->valueType()->pointer) ? op : tok;
 }
 
 static int getMinFormatStringOutputLength(const std::vector<const Token*> &parameters, nonneg int formatStringArgNr)
@@ -82,8 +96,8 @@ static int getMinFormatStringOutputLength(const std::vector<const Token*> &param
     std::string digits_string;
     bool i_d_x_f_found = false;
     int parameterLength = 0;
-    int inputArgNr = formatStringArgNr;
-    for (int i = 1; i + 1 < formatString.length(); ++i) {
+    nonneg int inputArgNr = formatStringArgNr;
+    for (std::size_t i = 1; i + 1 < formatString.length(); ++i) {
         if (formatString[i] == '\\') {
             if (i < formatString.length() - 1 && formatString[i + 1] == '0')
                 break;
@@ -142,24 +156,24 @@ static int getMinFormatStringOutputLength(const std::vector<const Token*> &param
             outputStringSize++;
 
         if (handleNextParameter) {
+            // NOLINTNEXTLINE(bugprone-unchecked-string-to-number-conversion) - intentional use
             int tempDigits = std::abs(std::atoi(digits_string.c_str()));
             if (i_d_x_f_found)
                 tempDigits = std::max(tempDigits, 1);
 
             if (digits_string.find('.') != std::string::npos) {
                 const std::string endStr = digits_string.substr(digits_string.find('.') + 1);
+                // NOLINTNEXTLINE(bugprone-unchecked-string-to-number-conversion) - intentional use
                 const int maxLen = std::max(std::abs(std::atoi(endStr.c_str())), 1);
 
                 if (formatString[i] == 's') {
                     // For strings, the length after the dot "%.2s" will limit
                     // the length of the string.
-                    if (parameterLength > maxLen)
-                        parameterLength = maxLen;
+                    parameterLength = std::min(parameterLength, maxLen);
                 } else {
                     // For integers, the length after the dot "%.2d" can
                     // increase required length
-                    if (tempDigits < maxLen)
-                        tempDigits = maxLen;
+                    tempDigits = std::max(tempDigits, maxLen);
                 }
             }
 
@@ -182,100 +196,111 @@ static int getMinFormatStringOutputLength(const std::vector<const Token*> &param
 
 //---------------------------------------------------------------------------
 
-static bool getDimensionsEtc(const Token * const arrayToken, const Settings *settings, std::vector<Dimension> * const dimensions, ErrorPath * const errorPath, bool * const mightBeLarger)
+static bool getDimensionsEtc(const Token * const arrayToken, const Settings &settings, std::vector<Dimension> &dimensions, ErrorPath &errorPath, bool &mightBeLarger, MathLib::bigint &path)
 {
     const Token *array = arrayToken;
     while (Token::Match(array, ".|::"))
         array = array->astOperand2();
 
-    if (!array->variable())
-        return false;
-
-    if (array->variable()->isArray() && !array->variable()->dimensions().empty()) {
-        *dimensions = array->variable()->dimensions();
-        if (dimensions->size() >= 1 && ((*dimensions)[0].num <= 1 || !(*dimensions)[0].tok)) {
+    if (array->variable() && array->variable()->isArray() && !array->variable()->dimensions().empty()) {
+        dimensions = array->variable()->dimensions();
+        if (dimensions[0].num <= 1 || !dimensions[0].tok) {
             visitAstNodes(arrayToken,
-            [&](const Token *child) {
+                          [&](const Token *child) {
                 if (child->originalName() == "->") {
-                    *mightBeLarger = true;
+                    mightBeLarger = true;
                     return ChildrenToVisit::none;
                 }
                 return ChildrenToVisit::op1_and_op2;
             });
         }
-    } else if (const Token *stringLiteral = array->getValueTokenMinStrSize()) {
+    } else if (const Token *stringLiteral = array->getValueTokenMinStrSize(settings, &path)) {
         Dimension dim;
         dim.tok = nullptr;
-        dim.num = Token::getStrSize(stringLiteral);
+        dim.num = Token::getStrArraySize(stringLiteral);
         dim.known = array->hasKnownValue();
-        dimensions->emplace_back(dim);
-    } else if (array->valueType() && array->valueType()->pointer >= 1 && array->valueType()->isIntegral()) {
+        dimensions.emplace_back(dim);
+    } else if (array->valueType() && array->valueType()->pointer >= 1 && (array->valueType()->isIntegral() || array->valueType()->isFloat())) {
         const ValueFlow::Value *value = getBufferSizeValue(array);
         if (!value)
             return false;
-        *errorPath = value->errorPath;
+        path = value->path;
+        errorPath = value->errorPath;
         Dimension dim;
         dim.known = value->isKnown();
         dim.tok = nullptr;
-        dim.num = value->intvalue / array->valueType()->typeSize(*settings);
-        dimensions->emplace_back(dim);
+        const auto sizeOf = array->valueType()->pointer > 1 ? ValueType::SizeOf::Pointer : ValueType::SizeOf::Pointee;
+        const size_t typeSize = array->valueType()->getSizeOf(settings, ValueType::Accuracy::ExactOrZero, sizeOf);
+        if (typeSize == 0)
+            return false;
+        dim.num = value->intvalue / typeSize;
+        dimensions.emplace_back(dim);
     }
-    return !dimensions->empty();
+    return !dimensions.empty();
 }
 
-static std::vector<const ValueFlow::Value *> getOverrunIndexValues(const Token *tok, const Token *arrayToken, const std::vector<Dimension> &dimensions, const std::vector<const Token *> &indexTokens)
+static ValueFlow::Value makeSizeValue(MathLib::bigint size, MathLib::bigint path)
+{
+    ValueFlow::Value v(size);
+    v.path = path;
+    return v;
+}
+
+static std::vector<ValueFlow::Value> getOverrunIndexValues(const Token* tok,
+                                                           const Token* arrayToken,
+                                                           const std::vector<Dimension>& dimensions,
+                                                           const std::vector<const Token*>& indexTokens,
+                                                           MathLib::bigint path)
 {
     const Token *array = arrayToken;
     while (Token::Match(array, ".|::"))
         array = array->astOperand2();
 
-    for (int cond = 0; cond < 2; cond++) {
-        bool equal = false;
-        bool overflow = false;
-        bool allKnown = true;
-        std::vector<const ValueFlow::Value *> indexValues;
-        for (int i = 0; i < dimensions.size() && i < indexTokens.size(); ++i) {
-            const ValueFlow::Value *value = indexTokens[i]->getMaxValue(cond == 1);
-            indexValues.push_back(value);
-            if (!value)
-                continue;
-            if (!value->isKnown()) {
-                if (!allKnown)
-                    continue;
-                allKnown = false;
-            }
-            if (array->variable()->isArray() && dimensions[i].num == 0)
-                continue;
-            if (value->intvalue == dimensions[i].num)
-                equal = true;
-            else if (value->intvalue > dimensions[i].num)
-                overflow = true;
-        }
-        if (equal && tok->str() != "[")
+    bool isArrayIndex = tok->str() == "[";
+    if (isArrayIndex) {
+        const Token* parent = tok;
+        while (Token::simpleMatch(parent, "["))
+            parent = parent->astParent();
+        if (!parent || parent->isUnaryOp("&"))
+            isArrayIndex = false;
+    }
+
+    bool overflow = false;
+    std::vector<ValueFlow::Value> indexValues;
+    for (std::size_t i = 0; i < dimensions.size() && i < indexTokens.size(); ++i) {
+        MathLib::bigint size = dimensions[i].num;
+        if (!isArrayIndex)
+            size++;
+        const bool zeroArray = array->variable() && array->variable()->isArray() && dimensions[i].num == 0;
+        std::vector<ValueFlow::Value> values = !zeroArray
+                                                   ? ValueFlow::isOutOfBounds(makeSizeValue(size, path), indexTokens[i])
+                                                   : std::vector<ValueFlow::Value>{};
+        if (values.empty()) {
+            if (const ValueFlow::Value* v = indexTokens[i]->getKnownValue(ValueFlow::Value::ValueType::INT))
+                indexValues.push_back(*v);
+            else
+                indexValues.push_back(ValueFlow::Value::unknown());
             continue;
-        if (!overflow && equal) {
-            const Token *parent = tok;
-            while (Token::simpleMatch(parent, "["))
-                parent = parent->astParent();
-            if (!parent || parent->isUnaryOp("&"))
-                continue;
         }
-        if (overflow || equal)
-            return indexValues;
+        overflow = true;
+        indexValues.push_back(values.front());
     }
-
-    return std::vector<const ValueFlow::Value *>();
+    if (overflow)
+        return indexValues;
+    return {};
 }
 
 void CheckBufferOverrun::arrayIndex()
 {
+    logChecker("CheckBufferOverrun::arrayIndex");
+
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
         if (tok->str() != "[")
             continue;
         const Token *array = tok->astOperand1();
         while (Token::Match(array, ".|::"))
             array = array->astOperand2();
-        if (!array|| !array->variable() || array->variable()->nameToken() == array)
+        if (!array || ((!array->variable() || array->variable()->nameToken() == array) && array->tokType() != Token::eString))
             continue;
         if (!array->scope()->isExecutable()) {
             // LHS in non-executable scope => This is just a definition
@@ -286,6 +311,9 @@ void CheckBufferOverrun::arrayIndex()
                 continue;
         }
 
+        if (astIsContainer(array))
+            continue;
+
         std::vector<const Token *> indexTokens;
         for (const Token *tok2 = tok; tok2 && tok2->str() == "["; tok2 = tok2->link()->next()) {
             if (!tok2->astOperand2()) {
@@ -300,24 +328,44 @@ void CheckBufferOverrun::arrayIndex()
         std::vector<Dimension> dimensions;
         ErrorPath errorPath;
         bool mightBeLarger = false;
-        if (!getDimensionsEtc(tok->astOperand1(), mSettings, &dimensions, &errorPath, &mightBeLarger))
+        MathLib::bigint path = 0;
+        if (!getDimensionsEtc(tok->astOperand1(), *mSettings, dimensions, errorPath, mightBeLarger, path))
             continue;
 
+        const Variable* const var = array->variable();
+        if (var && var->isArgument() && var->scope()) {
+            const Token* changeTok = var->scope()->bodyStart;
+            bool isChanged = false;
+            while ((changeTok = findVariableChanged(changeTok->next(), var->scope()->bodyEnd, /*indirect*/ 0, var->declarationId(),
+                                                    /*globalvar*/ false, *mSettings))) {
+                if (!Token::simpleMatch(changeTok->astParent(), "[")) {
+                    isChanged = true;
+                    break;
+                }
+            }
+            if (isChanged)
+                continue;
+        }
+
         // Positive index
         if (!mightBeLarger) { // TODO check arrays with dim 1 also
-            const std::vector<const ValueFlow::Value *> &indexValues = getOverrunIndexValues(tok, tok->astOperand1(), dimensions, indexTokens);
+            const std::vector<ValueFlow::Value>& indexValues =
+                getOverrunIndexValues(tok, tok->astOperand1(), dimensions, indexTokens, path);
             if (!indexValues.empty())
                 arrayIndexError(tok, dimensions, indexValues);
         }
 
         // Negative index
         bool neg = false;
-        std::vector<const ValueFlow::Value *> negativeIndexes;
+        std::vector<ValueFlow::Value> negativeIndexes;
         for (const Token * indexToken : indexTokens) {
-            const ValueFlow::Value *negativeValue = indexToken->getValueLE(-1, mSettings);
-            negativeIndexes.emplace_back(negativeValue);
-            if (negativeValue)
+            const ValueFlow::Value *negativeValue = indexToken->getValueLE(-1, *mSettings);
+            if (negativeValue) {
+                negativeIndexes.emplace_back(*negativeValue);
                 neg = true;
+            } else {
+                negativeIndexes.emplace_back(ValueFlow::Value::unknown());
+            }
         }
         if (neg) {
             negativeIndexError(tok, dimensions, negativeIndexes);
@@ -325,60 +373,63 @@ void CheckBufferOverrun::arrayIndex()
     }
 }
 
-static std::string stringifyIndexes(const std::string &array, const std::vector<const ValueFlow::Value *> &indexValues)
+static std::string stringifyIndexes(const std::string& array, const std::vector<ValueFlow::Value>& indexValues)
 {
     if (indexValues.size() == 1)
-        return MathLib::toString(indexValues[0]->intvalue);
+        return MathLib::toString(indexValues[0].intvalue);
 
     std::ostringstream ret;
     ret << array;
-    for (const ValueFlow::Value *index : indexValues) {
+    for (const ValueFlow::Value& index : indexValues) {
         ret << "[";
-        if (index)
-            ret << index->intvalue;
-        else
+        if (index.isNonValue())
             ret << "*";
+        else
+            ret << index.intvalue;
         ret << "]";
     }
     return ret.str();
 }
 
-static std::string arrayIndexMessage(const Token *tok, const std::vector<Dimension> &dimensions, const std::vector<const ValueFlow::Value *> &indexValues, const Token *condition)
+static std::string arrayIndexMessage(const Token* tok,
+                                     const std::vector<Dimension>& dimensions,
+                                     const std::vector<ValueFlow::Value>& indexValues,
+                                     const Token* condition)
 {
     auto add_dim = [](const std::string &s, const Dimension &dim) {
         return s + "[" + MathLib::toString(dim.num) + "]";
     };
-    const std::string array = std::accumulate(dimensions.begin(), dimensions.end(), tok->astOperand1()->expressionString(), add_dim);
+    const std::string array = std::accumulate(dimensions.cbegin(), dimensions.cend(), tok->astOperand1()->expressionString(), std::move(add_dim));
 
     std::ostringstream errmsg;
     if (condition)
         errmsg << ValueFlow::eitherTheConditionIsRedundant(condition)
-               << " or the array '" + array + "' is accessed at index " << stringifyIndexes(tok->astOperand1()->expressionString(), indexValues) << ", which is out of bounds.";
+               << " or the array '" << array << "' is accessed at index " << stringifyIndexes(tok->astOperand1()->expressionString(), indexValues) << ", which is out of bounds.";
     else
         errmsg << "Array '" << array << "' accessed at index " << stringifyIndexes(tok->astOperand1()->expressionString(), indexValues) <<  ", which is out of bounds.";
 
     return errmsg.str();
 }
 
-void CheckBufferOverrun::arrayIndexError(const Token *tok, const std::vector<Dimension> &dimensions, const std::vector<const ValueFlow::Value *> &indexes)
+void CheckBufferOverrun::arrayIndexError(const Token* tok,
+                                         const std::vector<Dimension>& dimensions,
+                                         const std::vector<ValueFlow::Value>& indexes)
 {
     if (!tok) {
-        reportError(tok, Severity::error, "arrayIndexOutOfBounds", "Array 'arr[16]' accessed at index 16, which is out of bounds.", CWE_BUFFER_OVERRUN, false);
-        reportError(tok, Severity::warning, "arrayIndexOutOfBoundsCond", "Array 'arr[16]' accessed at index 16, which is out of bounds.", CWE_BUFFER_OVERRUN, false);
+        reportError(tok, Severity::error, "arrayIndexOutOfBounds", "Array 'arr[16]' accessed at index 16, which is out of bounds.", CWE_BUFFER_OVERRUN, Certainty::normal);
+        reportError(tok, Severity::warning, "arrayIndexOutOfBoundsCond", "Array 'arr[16]' accessed at index 16, which is out of bounds.", CWE_BUFFER_OVERRUN, Certainty::normal);
         return;
     }
 
     const Token *condition = nullptr;
     const ValueFlow::Value *index = nullptr;
-    for (const ValueFlow::Value *indexValue: indexes) {
-        if (!indexValue)
-            continue;
-        if (!indexValue->errorSeverity() && !mSettings->isEnabled(Settings::WARNING))
+    for (const ValueFlow::Value& indexValue : indexes) {
+        if (!indexValue.errorSeverity() && !mSettings->severity.isEnabled(Severity::warning))
             return;
-        if (indexValue->condition)
-            condition = indexValue->condition;
-        if (!index || !indexValue->errorPath.empty())
-            index = indexValue;
+        if (indexValue.condition)
+            condition = indexValue.condition;
+        if (!index || !indexValue.errorPath.empty())
+            index = &indexValue;
     }
 
     reportError(getErrorPath(tok, index, "Array index out of bounds"),
@@ -386,27 +437,27 @@ void CheckBufferOverrun::arrayIndexError(const Token *tok, const std::vector<Dim
                 index->condition ? "arrayIndexOutOfBoundsCond" : "arrayIndexOutOfBounds",
                 arrayIndexMessage(tok, dimensions, indexes, condition),
                 CWE_BUFFER_OVERRUN,
-                index->isInconclusive());
+                index->isInconclusive() ? Certainty::inconclusive : Certainty::normal);
 }
 
-void CheckBufferOverrun::negativeIndexError(const Token *tok, const std::vector<Dimension> &dimensions, const std::vector<const ValueFlow::Value *> &indexes)
+void CheckBufferOverrun::negativeIndexError(const Token* tok,
+                                            const std::vector<Dimension>& dimensions,
+                                            const std::vector<ValueFlow::Value>& indexes)
 {
     if (!tok) {
-        reportError(tok, Severity::error, "negativeIndex", "Negative array index", CWE_BUFFER_UNDERRUN, false);
+        reportError(tok, Severity::error, "negativeIndex", "Negative array index", CWE_BUFFER_UNDERRUN, Certainty::normal);
         return;
     }
 
     const Token *condition = nullptr;
     const ValueFlow::Value *negativeValue = nullptr;
-    for (const ValueFlow::Value *indexValue: indexes) {
-        if (!indexValue)
-            continue;
-        if (!indexValue->errorSeverity() && !mSettings->isEnabled(Settings::WARNING))
+    for (const ValueFlow::Value& indexValue : indexes) {
+        if (!indexValue.errorSeverity() && !mSettings->severity.isEnabled(Severity::warning))
             return;
-        if (indexValue->condition)
-            condition = indexValue->condition;
-        if (!negativeValue || !indexValue->errorPath.empty())
-            negativeValue = indexValue;
+        if (indexValue.condition)
+            condition = indexValue.condition;
+        if (!negativeValue || !indexValue.errorPath.empty())
+            negativeValue = &indexValue;
     }
 
     reportError(getErrorPath(tok, negativeValue, "Negative array index"),
@@ -414,22 +465,24 @@ void CheckBufferOverrun::negativeIndexError(const Token *tok, const std::vector<
                 "negativeIndex",
                 arrayIndexMessage(tok, dimensions, indexes, condition),
                 CWE_BUFFER_UNDERRUN,
-                negativeValue->isInconclusive());
+                negativeValue->isInconclusive() ? Certainty::inconclusive : Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
 
 void CheckBufferOverrun::pointerArithmetic()
 {
-    if (!mSettings->isEnabled(Settings::PORTABILITY))
+    if (!mSettings->severity.isEnabled(Severity::portability) && !mSettings->isPremiumEnabled("pointerOutOfBounds"))
         return;
 
+    logChecker("CheckBufferOverrun::pointerArithmetic"); // portability
+
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
         if (!Token::Match(tok, "+|-"))
             continue;
         if (!tok->valueType() || tok->valueType()->pointer == 0)
             continue;
-        if (!tok->astOperand1() || !tok->astOperand2())
+        if (!tok->isBinaryOp())
             continue;
         if (!tok->astOperand1()->valueType() || !tok->astOperand2()->valueType())
             continue;
@@ -449,22 +502,34 @@ void CheckBufferOverrun::pointerArithmetic()
         std::vector<Dimension> dimensions;
         ErrorPath errorPath;
         bool mightBeLarger = false;
-        if (!getDimensionsEtc(arrayToken, mSettings, &dimensions, &errorPath, &mightBeLarger))
+        MathLib::bigint path = 0;
+        if (!getDimensionsEtc(arrayToken, *mSettings, dimensions, errorPath, mightBeLarger, path))
             continue;
 
         if (tok->str() == "+") {
             // Positive index
             if (!mightBeLarger) { // TODO check arrays with dim 1 also
                 const std::vector<const Token *> indexTokens{indexToken};
-                const std::vector<const ValueFlow::Value *> &indexValues = getOverrunIndexValues(tok, arrayToken, dimensions, indexTokens);
-                if (!indexValues.empty())
-                    pointerArithmeticError(tok, indexToken, indexValues.front());
+                const std::vector<ValueFlow::Value>& indexValues =
+                    getOverrunIndexValues(tok, arrayToken, dimensions, indexTokens, path);
+                if (!indexValues.empty() && !isUnreachableOperand(tok))
+                    pointerArithmeticError(tok, indexToken, &indexValues.front());
             }
 
-            if (const ValueFlow::Value *neg = indexToken->getValueLE(-1, mSettings))
+            if (const ValueFlow::Value *neg = indexToken->getValueLE(-1, *mSettings))
                 pointerArithmeticError(tok, indexToken, neg);
         } else if (tok->str() == "-") {
-            // TODO
+            if (arrayToken->variable() && arrayToken->variable()->isArgument())
+                continue;
+
+            const Token *array = arrayToken;
+            while (Token::Match(array, ".|::"))
+                array = array->astOperand2();
+            if (array->variable() && array->variable()->isArray()) {
+                const ValueFlow::Value *v = indexToken->getValueGE(1, *mSettings);
+                if (v)
+                    pointerArithmeticError(tok, indexToken, v);
+            }
         }
     }
 }
@@ -472,8 +537,8 @@ void CheckBufferOverrun::pointerArithmetic()
 void CheckBufferOverrun::pointerArithmeticError(const Token *tok, const Token *indexToken, const ValueFlow::Value *indexValue)
 {
     if (!tok) {
-        reportError(tok, Severity::portability, "pointerOutOfBounds", "Pointer arithmetic overflow.", CWE_POINTER_ARITHMETIC_OVERFLOW, false);
-        reportError(tok, Severity::portability, "pointerOutOfBoundsCond", "Pointer arithmetic overflow.", CWE_POINTER_ARITHMETIC_OVERFLOW, false);
+        reportError(tok, Severity::portability, "pointerOutOfBounds", "Pointer arithmetic overflow.", CWE_POINTER_ARITHMETIC_OVERFLOW, Certainty::normal);
+        reportError(tok, Severity::portability, "pointerOutOfBoundsCond", "Pointer arithmetic overflow.", CWE_POINTER_ARITHMETIC_OVERFLOW, Certainty::normal);
         return;
     }
 
@@ -488,7 +553,7 @@ void CheckBufferOverrun::pointerArithmeticError(const Token *tok, const Token *i
                 indexValue->condition ? "pointerOutOfBoundsCond" : "pointerOutOfBounds",
                 errmsg,
                 CWE_POINTER_ARITHMETIC_OVERFLOW,
-                indexValue->isInconclusive());
+                indexValue->isInconclusive() ? Certainty::inconclusive : Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -497,6 +562,8 @@ ValueFlow::Value CheckBufferOverrun::getBufferSize(const Token *bufTok) const
 {
     if (!bufTok->valueType())
         return ValueFlow::Value(-1);
+    if (bufTok->isUnaryOp("&"))
+        bufTok = bufTok->astOperand1();
     const Variable *var = bufTok->variable();
 
     if (!var || var->dimensions().empty()) {
@@ -505,10 +572,10 @@ ValueFlow::Value CheckBufferOverrun::getBufferSize(const Token *bufTok) const
             return *value;
     }
 
-    if (!var)
+    if (!var || var->isPointer())
         return ValueFlow::Value(-1);
 
-    MathLib::bigint dim = std::accumulate(var->dimensions().begin(), var->dimensions().end(), 1LL, [](MathLib::bigint i1, const Dimension &dim) {
+    const MathLib::bigint dim = std::accumulate(var->dimensions().cbegin(), var->dimensions().cend(), MathLib::bigint(1), [](MathLib::bigint i1, const Dimension &dim) {
         return i1 * dim.num;
     });
 
@@ -517,11 +584,9 @@ ValueFlow::Value CheckBufferOverrun::getBufferSize(const Token *bufTok) const
     v.valueType = ValueFlow::Value::ValueType::BUFFER_SIZE;
 
     if (var->isPointerArray())
-        v.intvalue = dim * mSettings->sizeof_pointer;
-    else if (var->isPointer())
-        return ValueFlow::Value(-1);
+        v.intvalue = dim * mSettings->platform.sizeof_pointer;
     else {
-        const MathLib::bigint typeSize = bufTok->valueType()->typeSize(*mSettings);
+        const size_t typeSize = bufTok->valueType()->getSizeOf(*mSettings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointee);
         v.intvalue = dim * typeSize;
     }
 
@@ -529,14 +594,14 @@ ValueFlow::Value CheckBufferOverrun::getBufferSize(const Token *bufTok) const
 }
 //---------------------------------------------------------------------------
 
-static bool checkBufferSize(const Token *ftok, const Library::ArgumentChecks::MinSize &minsize, const std::vector<const Token *> &args, const MathLib::bigint bufferSize, const Settings *settings)
+static bool checkBufferSize(const Token *ftok, const Library::ArgumentChecks::MinSize &minsize, const std::vector<const Token *> &args, const MathLib::bigint bufferSize, const Settings &settings, const Tokenizer* tokenizer)
 {
     const Token * const arg = (minsize.arg > 0 && minsize.arg - 1 < args.size()) ? args[minsize.arg - 1] : nullptr;
     const Token * const arg2 = (minsize.arg2 > 0 && minsize.arg2 - 1 < args.size()) ? args[minsize.arg2 - 1] : nullptr;
 
     switch (minsize.type) {
     case Library::ArgumentChecks::MinSize::Type::STRLEN:
-        if (settings->library.isargformatstr(ftok, minsize.arg)) {
+        if (settings.library.isargformatstr(ftok, minsize.arg)) {
             return getMinFormatStringOutputLength(args, minsize.arg) < bufferSize;
         } else if (arg) {
             const Token *strtoken = arg->getValueTokenMaxStrLength();
@@ -544,10 +609,16 @@ static bool checkBufferSize(const Token *ftok, const Library::ArgumentChecks::Mi
                 return Token::getStrLength(strtoken) < bufferSize;
         }
         break;
-    case Library::ArgumentChecks::MinSize::Type::ARGVALUE:
-        if (arg && arg->hasKnownIntValue())
-            return arg->getKnownIntValue() <= bufferSize;
+    case Library::ArgumentChecks::MinSize::Type::ARGVALUE: {
+        if (arg && arg->hasKnownIntValue()) {
+            MathLib::bigint myMinsize = arg->getKnownIntValue();
+            const int baseSize = tokenizer->sizeOfType(minsize.baseType);
+            if (baseSize != 0)
+                myMinsize *= baseSize;
+            return myMinsize <= bufferSize;
+        }
         break;
+    }
     case Library::ArgumentChecks::MinSize::Type::SIZEOF:
         // TODO
         break;
@@ -555,17 +626,24 @@ static bool checkBufferSize(const Token *ftok, const Library::ArgumentChecks::Mi
         if (arg && arg2 && arg->hasKnownIntValue() && arg2->hasKnownIntValue())
             return (arg->getKnownIntValue() * arg2->getKnownIntValue()) <= bufferSize;
         break;
-    case Library::ArgumentChecks::MinSize::Type::VALUE:
-        return minsize.value <= bufferSize;
+    case Library::ArgumentChecks::MinSize::Type::VALUE: {
+        MathLib::bigint myMinsize = minsize.value;
+        const int baseSize = tokenizer->sizeOfType(minsize.baseType);
+        if (baseSize != 0)
+            myMinsize *= baseSize;
+        return myMinsize <= bufferSize;
+    }
     case Library::ArgumentChecks::MinSize::Type::NONE:
         break;
-    };
+    }
     return true;
 }
 
 
 void CheckBufferOverrun::bufferOverflow()
 {
+    logChecker("CheckBufferOverrun::bufferOverflow");
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token *tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
@@ -586,34 +664,53 @@ void CheckBufferOverrun::bufferOverflow()
                     argtok = argtok->astOperand2() ? argtok->astOperand2() : argtok->astOperand1();
                 while (Token::Match(argtok, ".|::"))
                     argtok = argtok->astOperand2();
-                if (!argtok || !argtok->variable())
+                if (!argtok)
+                    continue;
+                if (argtok->valueType() && argtok->valueType()->pointer == 0)
                     continue;
                 // TODO: strcpy(buf+10, "hello");
                 const ValueFlow::Value bufferSize = getBufferSize(argtok);
-                if (bufferSize.intvalue <= 1)
+                if (bufferSize.intvalue <= 0)
                     continue;
-                bool error = std::none_of(minsizes->begin(), minsizes->end(), [=](const Library::ArgumentChecks::MinSize &minsize) {
-                    return checkBufferSize(tok, minsize, args, bufferSize.intvalue, mSettings);
+                // buffer size == 1 => do not warn for dynamic memory
+                if (bufferSize.intvalue == 1 && Token::simpleMatch(argtok->astParent(), ".")) { // TODO: check if parent was allocated dynamically
+                    const Token *tok2 = argtok;
+                    while (Token::simpleMatch(tok2->astParent(), "."))
+                        tok2 = tok2->astParent();
+                    while (Token::Match(tok2, "[|."))
+                        tok2 = tok2->astOperand1();
+                    const Variable *var = tok2 ? tok2->variable() : nullptr;
+                    if (var) {
+                        if (var->isPointer())
+                            continue;
+                        if (var->isArgument() && var->isReference())
+                            continue;
+                    }
+                }
+                const bool error = std::none_of(minsizes->begin(), minsizes->end(), [&](const Library::ArgumentChecks::MinSize &minsize) {
+                    return checkBufferSize(tok, minsize, args, bufferSize.intvalue, *mSettings, mTokenizer);
                 });
                 if (error)
-                    bufferOverflowError(args[argnr], &bufferSize);
+                    bufferOverflowError(args[argnr], &bufferSize, Certainty::normal);
             }
         }
     }
 }
 
-void CheckBufferOverrun::bufferOverflowError(const Token *tok, const ValueFlow::Value *value)
+void CheckBufferOverrun::bufferOverflowError(const Token *tok, const ValueFlow::Value *value, Certainty certainty)
 {
-    reportError(getErrorPath(tok, value, "Buffer overrun"), Severity::error, "bufferAccessOutOfBounds", "Buffer is accessed out of bounds: " + (tok ? tok->expressionString() : "buf"), CWE_BUFFER_OVERRUN, false);
+    reportError(getErrorPath(tok, value, "Buffer overrun"), Severity::error, "bufferAccessOutOfBounds", "Buffer is accessed out of bounds: " + (tok ? getRealBufferTok(tok)->expressionString() : "buf"), CWE_BUFFER_OVERRUN, certainty);
 }
 
 //---------------------------------------------------------------------------
 
 void CheckBufferOverrun::arrayIndexThenCheck()
 {
-    if (!mSettings->isEnabled(Settings::PORTABILITY))
+    if (!mSettings->severity.isEnabled(Severity::style))
         return;
 
+    logChecker("CheckBufferOverrun::arrayIndexThenCheck"); // style
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * const scope : symbolDatabase->functionScopes) {
         for (const Token *tok = scope->bodyStart; tok && tok != scope->bodyEnd; tok = tok->next()) {
@@ -631,7 +728,7 @@ void CheckBufferOverrun::arrayIndexThenCheck()
                 // Iterate AST upwards
                 const Token* tok2 = tok;
                 const Token* tok3 = tok2;
-                while (tok2->astParent() && tok2->tokType() != Token::eLogicalOp) {
+                while (tok2->astParent() && tok2->tokType() != Token::eLogicalOp && tok2->str() != "?") {
                     tok3 = tok2;
                     tok2 = tok2->astParent();
                 }
@@ -659,7 +756,7 @@ void CheckBufferOverrun::arrayIndexThenCheckError(const Token *tok, const std::s
                 "Defensive programming: The variable '$symbol' is used as an array index before it "
                 "is checked that is within limits. This can mean that the array might be accessed out of bounds. "
                 "Reorder conditions such as '(a[i] && i < 10)' to '(i < 10 && a[i])'. That way the array will "
-                "not be accessed if the index is out of limits.", CWE_ARRAY_INDEX_THEN_CHECK, false);
+                "not be accessed if the index is out of limits.", CWE_ARRAY_INDEX_THEN_CHECK, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -667,8 +764,11 @@ void CheckBufferOverrun::arrayIndexThenCheckError(const Token *tok, const std::s
 void CheckBufferOverrun::stringNotZeroTerminated()
 {
     // this is currently 'inconclusive'. See TestBufferOverrun::terminateStrncpy3
-    if (!mSettings->isEnabled(Settings::WARNING) || !mSettings->inconclusive)
+    if (!mSettings->severity.isEnabled(Severity::warning) || !mSettings->certainty.isEnabled(Certainty::inconclusive))
         return;
+
+    logChecker("CheckBufferOverrun::stringNotZeroTerminated"); // warning,inconclusive
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * const scope : symbolDatabase->functionScopes) {
         for (const Token *tok = scope->bodyStart; tok && tok != scope->bodyEnd; tok = tok->next()) {
@@ -683,24 +783,33 @@ void CheckBufferOverrun::stringNotZeroTerminated()
             const ValueFlow::Value &bufferSize = getBufferSize(args[0]);
             if (bufferSize.intvalue < 0 || sizeToken->getKnownIntValue() < bufferSize.intvalue)
                 continue;
-            const Token *srcValue = args[1]->getValueTokenMaxStrLength();
-            if (srcValue && Token::getStrLength(srcValue) < sizeToken->getKnownIntValue())
-                continue;
+            if (Token::simpleMatch(args[1], "(") && Token::simpleMatch(args[1]->astOperand1(), ". c_str") && args[1]->astOperand1()->astOperand1()) {
+                const std::list<ValueFlow::Value>& contValues = args[1]->astOperand1()->astOperand1()->values();
+                auto it = std::find_if(contValues.cbegin(), contValues.cend(), [](const ValueFlow::Value& value) {
+                    return value.isContainerSizeValue() && !value.isImpossible();
+                });
+                if (it != contValues.end() && it->intvalue < sizeToken->getKnownIntValue())
+                    continue;
+            } else {
+                const Token* srcValue = args[1]->getValueTokenMaxStrLength();
+                if (srcValue && Token::getStrLength(srcValue) < sizeToken->getKnownIntValue())
+                    continue;
+            }
             // Is the buffer zero terminated after the call?
             bool isZeroTerminated = false;
-            for (const Token *tok2 = tok->next()->link(); tok2 != scope->bodyEnd; tok2 = tok2->next()) {
+            for (const Token *tok2 = tok->linkAt(1); tok2 != scope->bodyEnd; tok2 = tok2->next()) {
                 if (!Token::simpleMatch(tok2, "] ="))
                     continue;
                 const Token *rhs = tok2->next()->astOperand2();
                 if (!rhs || !rhs->hasKnownIntValue() || rhs->getKnownIntValue() != 0)
                     continue;
-                if (isSameExpression(mTokenizer->isCPP(), false, args[0], tok2->link()->astOperand1(), mSettings->library, false, false))
+                if (isSameExpression(false, args[0], tok2->link()->astOperand1(), *mSettings, false, false))
                     isZeroTerminated = true;
             }
             if (isZeroTerminated)
                 continue;
             // TODO: Locate unsafe string usage..
-            terminateStrncpyError(tok, args[0]->expressionString());
+            terminateStrncpyError(tok, getRealBufferTok(args[0])->expressionString());
         }
     }
 }
@@ -714,42 +823,114 @@ void CheckBufferOverrun::terminateStrncpyError(const Token *tok, const std::stri
                 shortMessage + ' ' +
                 "If the source string's size fits or exceeds the given size, strncpy() does not add a "
                 "zero at the end of the buffer. This causes bugs later in the code if the code "
-                "assumes buffer is null-terminated.", CWE170, true);
+                "assumes buffer is null-terminated.", CWE170, Certainty::inconclusive);
 }
+//---------------------------------------------------------------------------
 
-void CheckBufferOverrun::bufferNotZeroTerminatedError(const Token *tok, const std::string &varname, const std::string &function)
+void CheckBufferOverrun::argumentSize()
 {
-    const std::string errmsg = "$symbol:" + varname + '\n' +
-                               "$symbol:" + function + '\n' +
-                               "The buffer '" + varname + "' is not null-terminated after the call to " + function + "().\n"
-                               "The buffer '" + varname + "' is not null-terminated after the call to " + function + "(). "
-                               "This will cause bugs later in the code if the code assumes the buffer is null-terminated.";
+    // Check '%type% x[10]' arguments
+    if (!mSettings->severity.isEnabled(Severity::warning) && !mSettings->isPremiumEnabled("argumentSize"))
+        return;
+
+    logChecker("CheckBufferOverrun::argumentSize"); // warning
 
-    reportError(tok, Severity::warning, "bufferNotZeroTerminated", errmsg, CWE170, true);
+    const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
+    for (const Scope * const scope : symbolDatabase->functionScopes) {
+        for (const Token *tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
+            if (!tok->function() || !Token::Match(tok, "%name% ("))
+                continue;
+
+            // If argument is '%type% a[num]' then check bounds against num
+            const Function *callfunc = tok->function();
+            const std::vector<const Token *> callargs = getArguments(tok);
+            for (nonneg int paramIndex = 0; paramIndex < callargs.size() && paramIndex < callfunc->argCount(); ++paramIndex) {
+                const Variable* const argument = callfunc->getArgumentVar(paramIndex);
+                if (!argument || !argument->nameToken() || !argument->isArray())
+                    continue;
+                if (!argument->valueType() || !callargs[paramIndex]->valueType())
+                    continue;
+                if (argument->valueType()->type != callargs[paramIndex]->valueType()->type)
+                    continue;
+                const Token * calldata = callargs[paramIndex];
+                while (Token::Match(calldata, "::|."))
+                    calldata = calldata->astOperand2();
+                if (!calldata->variable() || !calldata->variable()->isArray())
+                    continue;
+                if (calldata->variable()->dimensions().size() != argument->dimensions().size())
+                    continue;
+                bool err = false;
+                for (std::size_t d = 0; d < argument->dimensions().size(); ++d) {
+                    const auto& dim1 = calldata->variable()->dimensions()[d];
+                    const auto& dim2 = argument->dimensions()[d];
+                    if (!dim1.known || !dim2.known)
+                        break;
+                    if (dim1.num < dim2.num)
+                        err = true;
+                }
+                if (err)
+                    argumentSizeError(tok, tok->str(), paramIndex, callargs[paramIndex]->expressionString(), calldata->variable(), argument);
+            }
+        }
+    }
 }
 
+void CheckBufferOverrun::argumentSizeError(const Token *tok, const std::string &functionName, nonneg int paramIndex, const std::string &paramExpression, const Variable *paramVar, const Variable *functionArg)
+{
+    const std::string strParamNum = std::to_string(paramIndex + 1) + getOrdinalText(paramIndex + 1);
+    ErrorPath errorPath;
+    errorPath.emplace_back(tok, "Function '" + functionName + "' is called");
+    if (functionArg)
+        errorPath.emplace_back(functionArg->nameToken(), "Declaration of " + strParamNum + " function argument.");
+    if (paramVar)
+        errorPath.emplace_back(paramVar->nameToken(), "Passing buffer '" + paramVar->name() + "' to function that is declared here");
+    errorPath.emplace_back(tok, "");
 
+    reportError(std::move(errorPath), Severity::warning, "argumentSize",
+                "$symbol:" + functionName + '\n' +
+                "Buffer '" + paramExpression + "' is too small, the function '" + functionName + "' expects a bigger buffer in " + strParamNum + " argument", CWE_ARGUMENT_SIZE, Certainty::normal);
+}
 
 //---------------------------------------------------------------------------
 // CTU..
 //---------------------------------------------------------------------------
 
-std::string CheckBufferOverrun::MyFileInfo::toString() const
+// a Clang-built executable will crash when using the anonymous MyFileInfo later on - so put it in a unique namespace for now
+// see https://trac.cppcheck.net/ticket/12108 for more details
+#ifdef __clang__
+inline namespace CheckBufferOverrun_internal
+#else
+namespace
+#endif
 {
-    std::string xml;
-    if (!unsafeArrayIndex.empty())
-        xml = "    <array-index>\n" + CTU::toString(unsafeArrayIndex) + "    </array-index>\n";
-    if (!unsafePointerArith.empty())
-        xml += "    <pointer-arith>\n" + CTU::toString(unsafePointerArith) + "    </pointer-arith>\n";
-    return xml;
+    /** data for multifile checking */
+    class MyFileInfo : public Check::FileInfo {
+    public:
+        using Check::FileInfo::FileInfo;
+        /** unsafe array index usage */
+        std::list<CTU::FileInfo::UnsafeUsage> unsafeArrayIndex;
+
+        /** unsafe pointer arithmetics */
+        std::list<CTU::FileInfo::UnsafeUsage> unsafePointerArith;
+
+        /** Convert data into xml string */
+        std::string toString() const override
+        {
+            std::string xml;
+            if (!unsafeArrayIndex.empty())
+                xml = "    <array-index>\n" + CTU::toString(unsafeArrayIndex) + "    </array-index>\n";
+            if (!unsafePointerArith.empty())
+                xml += "    <pointer-arith>\n" + CTU::toString(unsafePointerArith) + "    </pointer-arith>\n";
+            return xml;
+        }
+    };
 }
 
-bool CheckBufferOverrun::isCtuUnsafeBufferUsage(const Check *check, const Token *argtok, MathLib::bigint *offset, int type)
+bool CheckBufferOverrun::isCtuUnsafeBufferUsage(const Settings &settings, const Token *argtok, CTU::FileInfo::Value *offset, int type)
 {
-    const CheckBufferOverrun *c = dynamic_cast<const CheckBufferOverrun *>(check);
-    if (!c)
+    if (!offset)
         return false;
-    if (!argtok->valueType() || argtok->valueType()->typeSize(*c->mSettings) == 0)
+    if (!argtok->valueType() || argtok->valueType()->getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointee) == 0)
         return false;
     const Token *indexTok = nullptr;
     if (type == 1 && Token::Match(argtok, "%name% [") && argtok->astParent() == argtok->next() && !Token::simpleMatch(argtok->linkAt(1), "] ["))
@@ -762,46 +943,46 @@ bool CheckBufferOverrun::isCtuUnsafeBufferUsage(const Check *check, const Token
         return false;
     if (!indexTok->hasKnownIntValue())
         return false;
-    if (!offset)
-        return false;
-    *offset = indexTok->getKnownIntValue() * argtok->valueType()->typeSize(*c->mSettings);
+    offset->value = indexTok->getKnownIntValue() * argtok->valueType()->getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointee);
     return true;
 }
 
-bool CheckBufferOverrun::isCtuUnsafeArrayIndex(const Check *check, const Token *argtok, MathLib::bigint *offset)
+bool CheckBufferOverrun::isCtuUnsafeArrayIndex(const Settings &settings, const Token *argtok, CTU::FileInfo::Value *offset)
 {
-    return CheckBufferOverrun::isCtuUnsafeBufferUsage(check, argtok, offset, 1);
+    return isCtuUnsafeBufferUsage(settings, argtok, offset, 1);
 }
 
-bool CheckBufferOverrun::isCtuUnsafePointerArith(const Check *check, const Token *argtok, MathLib::bigint *offset)
+bool CheckBufferOverrun::isCtuUnsafePointerArith(const Settings &settings, const Token *argtok, CTU::FileInfo::Value* offset)
 {
-    return CheckBufferOverrun::isCtuUnsafeBufferUsage(check, argtok, offset, 2);
+    return isCtuUnsafeBufferUsage(settings, argtok, offset, 2);
 }
 
 /** @brief Parse current TU and extract file info */
-Check::FileInfo *CheckBufferOverrun::getFileInfo(const Tokenizer *tokenizer, const Settings *settings) const
+Check::FileInfo *CheckBufferOverrun::getFileInfo(const Tokenizer &tokenizer, const Settings &settings, const std::string& /*currentConfig*/) const
 {
-    CheckBufferOverrun checkBufferOverrun(tokenizer, settings, nullptr);
-    MyFileInfo *fileInfo = new MyFileInfo;
-    fileInfo->unsafeArrayIndex = CTU::getUnsafeUsage(tokenizer, settings, &checkBufferOverrun, isCtuUnsafeArrayIndex);
-    fileInfo->unsafePointerArith = CTU::getUnsafeUsage(tokenizer, settings, &checkBufferOverrun, isCtuUnsafePointerArith);
-    if (fileInfo->unsafeArrayIndex.empty() && fileInfo->unsafePointerArith.empty()) {
-        delete fileInfo;
+    const std::list<CTU::FileInfo::UnsafeUsage> &unsafeArrayIndex = CTU::getUnsafeUsage(tokenizer, settings, isCtuUnsafeArrayIndex);
+    const std::list<CTU::FileInfo::UnsafeUsage> &unsafePointerArith = CTU::getUnsafeUsage(tokenizer, settings, isCtuUnsafePointerArith);
+    if (unsafeArrayIndex.empty() && unsafePointerArith.empty()) {
         return nullptr;
     }
+    auto *fileInfo = new MyFileInfo(tokenizer.list.getFiles()[0]);
+    fileInfo->unsafeArrayIndex = unsafeArrayIndex;
+    fileInfo->unsafePointerArith = unsafePointerArith;
     return fileInfo;
 }
 
 Check::FileInfo * CheckBufferOverrun::loadFileInfoFromXml(const tinyxml2::XMLElement *xmlElement) const
 {
+    // cppcheck-suppress shadowFunction - TODO: fix this
     const std::string arrayIndex("array-index");
     const std::string pointerArith("pointer-arith");
 
-    MyFileInfo *fileInfo = new MyFileInfo;
+    auto *fileInfo = new MyFileInfo;
     for (const tinyxml2::XMLElement *e = xmlElement->FirstChildElement(); e; e = e->NextSiblingElement()) {
-        if (e->Name() == arrayIndex)
+        const char* name = e->Name();
+        if (name == arrayIndex)
             fileInfo->unsafeArrayIndex = CTU::loadUnsafeUsageListFromXml(e);
-        else if (e->Name() == pointerArith)
+        else if (name == pointerArith)
             fileInfo->unsafePointerArith = CTU::loadUnsafeUsageListFromXml(e);
     }
 
@@ -814,38 +995,44 @@ Check::FileInfo * CheckBufferOverrun::loadFileInfoFromXml(const tinyxml2::XMLEle
 }
 
 /** @brief Analyse all file infos for all TU */
-bool CheckBufferOverrun::analyseWholeProgram(const CTU::FileInfo *ctu, const std::list<Check::FileInfo*> &fileInfo, const Settings& settings, ErrorLogger &errorLogger)
+bool CheckBufferOverrun::analyseWholeProgram(const CTU::FileInfo &ctu, const std::list<Check::FileInfo*> &fileInfo, const Settings& settings, ErrorLogger &errorLogger)
 {
-    if (!ctu)
+    CheckBufferOverrun dummy(nullptr, &settings, &errorLogger);
+    dummy.
+    logChecker("CheckBufferOverrun::analyseWholeProgram");
+
+    if (fileInfo.empty())
         return false;
-    bool foundErrors = false;
-    (void)settings; // This argument is unused
 
-    const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>> callsMap = ctu->getCallsMap();
+    const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>> callsMap = ctu.getCallsMap();
 
-    for (Check::FileInfo *fi1 : fileInfo) {
-        const MyFileInfo *fi = dynamic_cast<MyFileInfo*>(fi1);
+    bool foundErrors = false;
+
+    for (const Check::FileInfo* fi1 : fileInfo) {
+        const auto *fi = dynamic_cast<const MyFileInfo*>(fi1);
         if (!fi)
             continue;
         for (const CTU::FileInfo::UnsafeUsage &unsafeUsage : fi->unsafeArrayIndex)
-            foundErrors |= analyseWholeProgram1(ctu, callsMap, unsafeUsage, 1, errorLogger);
+            foundErrors |= analyseWholeProgram1(callsMap, unsafeUsage, 1, errorLogger, settings.maxCtuDepth, fi->file0);
         for (const CTU::FileInfo::UnsafeUsage &unsafeUsage : fi->unsafePointerArith)
-            foundErrors |= analyseWholeProgram1(ctu, callsMap, unsafeUsage, 2, errorLogger);
+            foundErrors |= analyseWholeProgram1(callsMap, unsafeUsage, 2, errorLogger, settings.maxCtuDepth, fi->file0);
     }
     return foundErrors;
 }
 
-bool CheckBufferOverrun::analyseWholeProgram1(const CTU::FileInfo *ctu, const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>> &callsMap, const CTU::FileInfo::UnsafeUsage &unsafeUsage, int type, ErrorLogger &errorLogger)
+bool CheckBufferOverrun::analyseWholeProgram1(const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>> &callsMap, const CTU::FileInfo::UnsafeUsage &unsafeUsage,
+                                              int type, ErrorLogger &errorLogger, int maxCtuDepth, const std::string& file0)
 {
     const CTU::FileInfo::FunctionCall *functionCall = nullptr;
 
-    const std::list<ErrorLogger::ErrorMessage::FileLocation> &locationList =
-        ctu->getErrorPath(CTU::FileInfo::InvalidValueType::bufferOverflow,
-                          unsafeUsage,
-                          callsMap,
-                          "Using argument ARG",
-                          &functionCall,
-                          false);
+    std::list<ErrorMessage::FileLocation> locationList =
+        CTU::FileInfo::getErrorPath(CTU::FileInfo::InvalidValueType::bufferOverflow,
+                                    unsafeUsage,
+                                    callsMap,
+                                    "Using argument ARG",
+                                    &functionCall,
+                                    false,
+                                    maxCtuDepth);
     if (locationList.empty())
         return false;
 
@@ -856,22 +1043,22 @@ bool CheckBufferOverrun::analyseWholeProgram1(const CTU::FileInfo *ctu, const st
     if (type == 1) {
         errorId = "ctuArrayIndex";
         if (unsafeUsage.value > 0)
-            errmsg = "Array index out of bounds; '" + unsafeUsage.myArgumentName + "' buffer size is " + MathLib::toString(functionCall->callArgValue) + " and it is accessed at offset " + MathLib::toString(unsafeUsage.value) + ".";
+            errmsg = "Array index out of bounds; '" + unsafeUsage.myArgumentName + "' buffer size is " + MathLib::toString(functionCall->callArgValue.value) + " and it is accessed at offset " + MathLib::toString(unsafeUsage.value) + ".";
         else
             errmsg = "Array index out of bounds; buffer '" + unsafeUsage.myArgumentName + "' is accessed at offset " + MathLib::toString(unsafeUsage.value) + ".";
         cwe = (unsafeUsage.value > 0) ? CWE_BUFFER_OVERRUN : CWE_BUFFER_UNDERRUN;
     } else {
         errorId = "ctuPointerArith";
-        errmsg = "Pointer arithmetic overflow; '" + unsafeUsage.myArgumentName + "' buffer size is " + MathLib::toString(functionCall->callArgValue);
+        errmsg = "Pointer arithmetic overflow; '" + unsafeUsage.myArgumentName + "' buffer size is " + MathLib::toString(functionCall->callArgValue.value);
         cwe = CWE_POINTER_ARITHMETIC_OVERFLOW;
     }
 
-    const ErrorLogger::ErrorMessage errorMessage(locationList,
-            emptyString,
-            Severity::error,
-            errmsg,
-            errorId,
-            cwe, false);
+    const ErrorMessage errorMessage(std::move(locationList),
+                                    file0,
+                                    Severity::error,
+                                    errmsg,
+                                    errorId,
+                                    cwe, Certainty::normal);
     errorLogger.reportErr(errorMessage);
 
     return true;
@@ -879,6 +1066,7 @@ bool CheckBufferOverrun::analyseWholeProgram1(const CTU::FileInfo *ctu, const st
 
 void CheckBufferOverrun::objectIndex()
 {
+    logChecker("CheckBufferOverrun::objectIndex");
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope *functionScope : symbolDatabase->functionScopes) {
         for (const Token *tok = functionScope->bodyStart; tok != functionScope->bodyEnd; tok = tok->next()) {
@@ -888,24 +1076,62 @@ void CheckBufferOverrun::objectIndex()
             const Token *idx = tok->astOperand2();
             if (!idx || !obj)
                 continue;
-            if (idx->hasKnownIntValue() && idx->getKnownIntValue() == 0)
-                continue;
+            if (const ValueFlow::Value* v = idx->getKnownValue(ValueFlow::Value::ValueType::INT)) {
+                if (v->intvalue == 0)
+                    continue;
+            }
 
-            ValueFlow::Value v = getLifetimeObjValue(obj);
-            if (!v.isLocalLifetimeValue())
-                continue;
-            if (v.lifetimeKind != ValueFlow::Value::LifetimeKind::Address)
-                continue;
-            const Variable *var = v.tokvalue->variable();
-            if (var->isReference())
-                continue;
-            if (var->isRValueReference())
-                continue;
-            if (var->isArray())
-                continue;
-            if (var->isPointer())
-                continue;
-            objectIndexError(tok, &v, idx->hasKnownIntValue());
+            std::vector<ValueFlow::Value> values = ValueFlow::getLifetimeObjValues(obj, false, -1);
+            for (const ValueFlow::Value& v:values) {
+                if (v.lifetimeKind != ValueFlow::Value::LifetimeKind::Address)
+                    continue;
+                const Variable *var = v.tokvalue->variable();
+                if (!var)
+                    continue;
+                if (var->isReference())
+                    continue;
+                if (var->isRValueReference())
+                    continue;
+                if (var->isArray())
+                    continue;
+                if (var->isPointer()) {
+                    if (!var->valueType())
+                        continue;
+                    if (!obj->valueType())
+                        continue;
+                    if (var->valueType()->pointer > obj->valueType()->pointer)
+                        continue;
+                }
+                if (obj->valueType() && var->valueType() && (obj->isCast() || (obj->isCpp() && isCPPCast(obj)) || obj->valueType()->pointer)) { // allow cast to a different type
+                    const auto varSize = var->valueType()->getSizeOf(*mSettings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointee);
+                    if (varSize == 0)
+                        continue;
+                    if (obj->valueType()->type != var->valueType()->type) {
+                        if (ValueFlow::isOutOfBounds(makeSizeValue(varSize, v.path), idx).empty())
+                            continue;
+                    }
+                }
+                if (v.path != 0) {
+                    std::vector<ValueFlow::Value> idxValues;
+                    std::copy_if(idx->values().cbegin(),
+                                 idx->values().cend(),
+                                 std::back_inserter(idxValues),
+                                 [&](const ValueFlow::Value& vidx) {
+                        if (!vidx.isIntValue())
+                            return false;
+                        return vidx.path == v.path || vidx.path == 0;
+                    });
+                    if (std::any_of(idxValues.cbegin(), idxValues.cend(), [&](const ValueFlow::Value& vidx) {
+                        if (vidx.isImpossible())
+                            return (vidx.intvalue == 0);
+                        return (vidx.intvalue != 0);
+                    })) {
+                        objectIndexError(tok, &v, idx->hasKnownIntValue());
+                    }
+                } else {
+                    objectIndexError(tok, &v, idx->hasKnownIntValue());
+                }
+            }
         }
     }
 }
@@ -915,15 +1141,112 @@ void CheckBufferOverrun::objectIndexError(const Token *tok, const ValueFlow::Val
     ErrorPath errorPath;
     std::string name;
     if (v) {
-        name = v->tokvalue->variable()->name();
+        const Token* expr = v->tokvalue;
+        while (Token::simpleMatch(expr->astParent(), "."))
+            expr = expr->astParent();
+        name = expr->expressionString();
         errorPath = v->errorPath;
     }
     errorPath.emplace_back(tok, "");
     std::string verb = known ? "is" : "might be";
-    reportError(errorPath,
+    reportError(std::move(errorPath),
                 known ? Severity::error : Severity::warning,
                 "objectIndex",
-                "The address of local variable '" + name + "' " + verb + " accessed at non-zero index.",
+                "The address of variable '" + name + "' " + verb + " accessed at non-zero index.",
                 CWE758,
-                false);
+                Certainty::normal);
+}
+
+static bool isVLAIndex(const Token* tok)
+{
+    if (!tok)
+        return false;
+    if (tok->varId() != 0U)
+        return true;
+    if (tok->str() == "?") {
+        // this is a VLA index if both expressions around the ":" is VLA index
+        return tok->astOperand2() &&
+               tok->astOperand2()->str() == ":" &&
+               isVLAIndex(tok->astOperand2()->astOperand1()) &&
+               isVLAIndex(tok->astOperand2()->astOperand2());
+    }
+    return isVLAIndex(tok->astOperand1()) || isVLAIndex(tok->astOperand2());
+}
+
+void CheckBufferOverrun::negativeArraySize()
+{
+    logChecker("CheckBufferOverrun::negativeArraySize");
+    const SymbolDatabase* symbolDatabase = mTokenizer->getSymbolDatabase();
+    for (const Variable* var : symbolDatabase->variableList()) {
+        if (!var || !var->isArray())
+            continue;
+        const Token* const nameToken = var->nameToken();
+        if (!Token::Match(nameToken, "%var% [") || !nameToken->next()->astOperand2())
+            continue;
+        const ValueFlow::Value* sz = nameToken->next()->astOperand2()->getValueLE(-1, *mSettings);
+        // don't warn about constant negative index because that is a compiler error
+        if (sz && isVLAIndex(nameToken->next()->astOperand2()))
+            negativeArraySizeError(nameToken);
+    }
+
+    for (const Scope* functionScope : symbolDatabase->functionScopes) {
+        for (const Token* tok = functionScope->bodyStart; tok != functionScope->bodyEnd; tok = tok->next()) {
+            if (!tok->isKeyword() || tok->str() != "new" || !tok->astOperand1() || tok->astOperand1()->str() != "[")
+                continue;
+            const Token* valOperand = tok->astOperand1()->astOperand2();
+            if (!valOperand)
+                continue;
+            const ValueFlow::Value* sz = valOperand->getValueLE(-1, *mSettings);
+            if (sz)
+                negativeMemoryAllocationSizeError(tok, sz);
+        }
+    }
+}
+
+void CheckBufferOverrun::negativeArraySizeError(const Token* tok)
+{
+    const std::string arrayName = tok ? tok->expressionString() : std::string();
+    const std::string line1 = arrayName.empty() ? std::string() : ("$symbol:" + arrayName + '\n');
+    reportError(tok, Severity::error, "negativeArraySize",
+                line1 +
+                "Declaration of array '" + arrayName + "' with negative size is undefined behaviour", CWE758, Certainty::normal);
+}
+
+void CheckBufferOverrun::negativeMemoryAllocationSizeError(const Token* tok, const ValueFlow::Value* value)
+{
+    const std::string msg = "Memory allocation size is negative.";
+    ErrorPath errorPath = getErrorPath(tok, value, msg);
+    const bool inconclusive = value != nullptr && !value->isKnown();
+    reportError(std::move(errorPath), inconclusive ? Severity::warning : Severity::error, "negativeMemoryAllocationSize",
+                msg, CWE131, inconclusive ? Certainty::inconclusive : Certainty::normal);
+}
+
+void CheckBufferOverrun::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    CheckBufferOverrun checkBufferOverrun(&tokenizer, &tokenizer.getSettings(), errorLogger);
+    checkBufferOverrun.arrayIndex();
+    checkBufferOverrun.pointerArithmetic();
+    checkBufferOverrun.bufferOverflow();
+    checkBufferOverrun.arrayIndexThenCheck();
+    checkBufferOverrun.stringNotZeroTerminated();
+    checkBufferOverrun.objectIndex();
+    checkBufferOverrun.argumentSize();
+    checkBufferOverrun.negativeArraySize();
+}
+
+void CheckBufferOverrun::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const
+{
+    CheckBufferOverrun c(nullptr, settings, errorLogger);
+    c.arrayIndexError(nullptr, std::vector<Dimension>(), std::vector<ValueFlow::Value>());
+    c.pointerArithmeticError(nullptr, nullptr, nullptr);
+    c.negativeIndexError(nullptr, std::vector<Dimension>(), std::vector<ValueFlow::Value>());
+    c.arrayIndexThenCheckError(nullptr, "i");
+    c.bufferOverflowError(nullptr, nullptr, Certainty::normal);
+    c.objectIndexError(nullptr, nullptr, true);
+    c.argumentSizeError(nullptr, "function", 1, "buffer", nullptr, nullptr);
+    c.negativeMemoryAllocationSizeError(nullptr, nullptr);
+    c.negativeArraySizeError(nullptr);
+    c.terminateStrncpyError(nullptr, "var_name");
+    // TODO: ctuArrayIndex
+    // TODO: ctuPointerArith
 }
diff --git a/lib/checkbufferoverrun.h b/lib/checkbufferoverrun.h
index 386aad59e0e..9c6e1f0386d 100644
--- a/lib/checkbufferoverrun.h
+++ b/lib/checkbufferoverrun.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -25,17 +25,25 @@
 #include "check.h"
 #include "config.h"
 #include "ctu.h"
-#include "errorlogger.h"
-#include "mathlib.h"
-#include "tokenize.h"
-#include "symboldatabase.h"
 
-#include <cstddef>
+#include <cstdint>
 #include <list>
 #include <map>
 #include <string>
 #include <vector>
 
+class ErrorLogger;
+class Settings;
+class Token;
+class Tokenizer;
+class Variable;
+struct Dimension;
+enum class Certainty : std::uint8_t;
+
+namespace ValueFlow
+{
+    class Value;
+}
 
 /// @addtogroup Checks
 /// @{
@@ -51,60 +59,50 @@
  */
 class CPPCHECKLIB CheckBufferOverrun : public Check {
 public:
-
     /** This constructor is used when registering the CheckClass */
-    CheckBufferOverrun() : Check(myName()) {
-    }
+    CheckBufferOverrun() : Check(myName()) {}
 
+private:
     /** This constructor is used when running checks. */
     CheckBufferOverrun(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger) {}
 
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        CheckBufferOverrun checkBufferOverrun(tokenizer, settings, errorLogger);
-        checkBufferOverrun.arrayIndex();
-        checkBufferOverrun.pointerArithmetic();
-        checkBufferOverrun.bufferOverflow();
-        checkBufferOverrun.arrayIndexThenCheck();
-        checkBufferOverrun.stringNotZeroTerminated();
-        checkBufferOverrun.objectIndex();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        CheckBufferOverrun c(nullptr, settings, errorLogger);
-        c.arrayIndexError(nullptr, std::vector<Dimension>(), std::vector<const ValueFlow::Value *>());
-        c.pointerArithmeticError(nullptr, nullptr, nullptr);
-        c.negativeIndexError(nullptr, std::vector<Dimension>(), std::vector<const ValueFlow::Value *>());
-        c.arrayIndexThenCheckError(nullptr, "i");
-        c.bufferOverflowError(nullptr, nullptr);
-        c.objectIndexError(nullptr, nullptr, true);
-    }
+    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const override;
 
     /** @brief Parse current TU and extract file info */
-    Check::FileInfo *getFileInfo(const Tokenizer *tokenizer, const Settings *settings) const OVERRIDE;
+    Check::FileInfo *getFileInfo(const Tokenizer &tokenizer, const Settings &settings, const std::string& /*currentConfig*/) const override;
 
     /** @brief Analyse all file infos for all TU */
-    bool analyseWholeProgram(const CTU::FileInfo *ctu, const std::list<Check::FileInfo*> &fileInfo, const Settings& settings, ErrorLogger &errorLogger) OVERRIDE;
-
-private:
+    bool analyseWholeProgram(const CTU::FileInfo &ctu, const std::list<Check::FileInfo*> &fileInfo, const Settings& settings, ErrorLogger &errorLogger) override;
 
     void arrayIndex();
-    void arrayIndexError(const Token *tok, const std::vector<Dimension> &dimensions, const std::vector<const ValueFlow::Value *> &indexes);
-    void negativeIndexError(const Token *tok, const std::vector<Dimension> &dimensions, const std::vector<const ValueFlow::Value *> &indexes);
+    void arrayIndexError(const Token* tok,
+                         const std::vector<Dimension>& dimensions,
+                         const std::vector<ValueFlow::Value>& indexes);
+    void negativeIndexError(const Token* tok,
+                            const std::vector<Dimension>& dimensions,
+                            const std::vector<ValueFlow::Value>& indexes);
 
     void pointerArithmetic();
     void pointerArithmeticError(const Token *tok, const Token *indexToken, const ValueFlow::Value *indexValue);
 
     void bufferOverflow();
-    void bufferOverflowError(const Token *tok, const ValueFlow::Value *value);
+    void bufferOverflowError(const Token *tok, const ValueFlow::Value *value, Certainty certainty);
 
     void arrayIndexThenCheck();
     void arrayIndexThenCheckError(const Token *tok, const std::string &indexName);
 
     void stringNotZeroTerminated();
     void terminateStrncpyError(const Token *tok, const std::string &varname);
-    void bufferNotZeroTerminatedError(const Token *tok, const std::string &varname, const std::string &function);
+
+    void argumentSize();
+    void argumentSizeError(const Token *tok, const std::string &functionName, nonneg int paramIndex, const std::string &paramExpression, const Variable *paramVar, const Variable *functionArg);
+
+    void negativeArraySize();
+    void negativeArraySizeError(const Token* tok);
+    void negativeMemoryAllocationSizeError(const Token* tok, const ValueFlow::Value* value); // provide a negative value to memory allocation function
 
     void objectIndex();
     void objectIndexError(const Token *tok, const ValueFlow::Value *v, bool known);
@@ -112,40 +110,29 @@ class CPPCHECKLIB CheckBufferOverrun : public Check {
     ValueFlow::Value getBufferSize(const Token *bufTok) const;
 
     // CTU
+    static bool isCtuUnsafeBufferUsage(const Settings &settings, const Token *argtok, CTU::FileInfo::Value *offset, int type);
+    static bool isCtuUnsafeArrayIndex(const Settings &settings, const Token *argtok, CTU::FileInfo::Value *offset);
+    static bool isCtuUnsafePointerArith(const Settings &settings, const Token *argtok, CTU::FileInfo::Value *offset);
 
-    /** data for multifile checking */
-    class MyFileInfo : public Check::FileInfo {
-    public:
-        /** unsafe array index usage */
-        std::list<CTU::FileInfo::UnsafeUsage> unsafeArrayIndex;
-
-        /** unsafe pointer arithmetics */
-        std::list<CTU::FileInfo::UnsafeUsage> unsafePointerArith;
-
-        /** Convert MyFileInfo data into xml string */
-        std::string toString() const OVERRIDE;
-    };
-
-    static bool isCtuUnsafeBufferUsage(const Check *check, const Token *argtok, MathLib::bigint *offset, int type);
-    static bool isCtuUnsafeArrayIndex(const Check *check, const Token *argtok, MathLib::bigint *offset);
-    static bool isCtuUnsafePointerArith(const Check *check, const Token *argtok, MathLib::bigint *offset);
-
-    Check::FileInfo * loadFileInfoFromXml(const tinyxml2::XMLElement *xmlElement) const OVERRIDE;
-    bool analyseWholeProgram1(const CTU::FileInfo *ctu, const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>> &callsMap, const CTU::FileInfo::UnsafeUsage &unsafeUsage, int type, ErrorLogger &errorLogger);
+    Check::FileInfo * loadFileInfoFromXml(const tinyxml2::XMLElement *xmlElement) const override;
+    static bool analyseWholeProgram1(const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>> &callsMap, const CTU::FileInfo::UnsafeUsage &unsafeUsage,
+                                     int type, ErrorLogger &errorLogger, int maxCtuDepth, const std::string& file0);
 
 
     static std::string myName() {
         return "Bounds checking";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Out of bounds checking:\n"
                "- Array index out of bounds\n"
                "- Pointer arithmetic overflow\n"
                "- Buffer overflow\n"
                "- Dangerous usage of strncat()\n"
                "- Using array index before checking it\n"
-               "- Partial string write that leads to buffer that is not zero terminated.\n";
+               "- Partial string write that leads to buffer that is not zero terminated.\n"
+               "- Check for large enough arrays being passed to functions\n"
+               "- Allocating memory with a negative size\n";
     }
 };
 /// @}
diff --git a/lib/checkclass.cpp b/lib/checkclass.cpp
index 9be1870f70d..ebdb434bb24 100644
--- a/lib/checkclass.cpp
+++ b/lib/checkclass.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,19 +20,27 @@
 #include "checkclass.h"
 
 #include "astutils.h"
-#include "errorlogger.h"
 #include "library.h"
 #include "settings.h"
 #include "standards.h"
 #include "symboldatabase.h"
+#include "errorlogger.h"
+#include "errortypes.h"
+#include "platform.h"
 #include "token.h"
 #include "tokenize.h"
+#include "tokenlist.h"
 #include "utils.h"
 
 #include <algorithm>
-#include <cstdlib>
-#include <stack>
+#include <cctype>
+#include <cstring>
+#include <iterator>
 #include <utility>
+#include <unordered_map>
+
+#include "xml.h"
+
 //---------------------------------------------------------------------------
 
 // Register CheckClass..
@@ -46,40 +54,67 @@ static const CWE CWE665(665U);  // Improper Initialization
 static const CWE CWE758(758U);  // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior
 static const CWE CWE762(762U);  // Mismatched Memory Management Routines
 
-static const char * getFunctionTypeName(Function::Type type)
+static const CWE CWE_ONE_DEFINITION_RULE(758U);
+
+static const char * getFunctionTypeName(FunctionType type)
 {
     switch (type) {
-    case Function::eConstructor:
+    case FunctionType::eConstructor:
         return "constructor";
-    case Function::eCopyConstructor:
+    case FunctionType::eCopyConstructor:
         return "copy constructor";
-    case Function::eMoveConstructor:
+    case FunctionType::eMoveConstructor:
         return "move constructor";
-    case Function::eDestructor:
+    case FunctionType::eDestructor:
         return "destructor";
-    case Function::eFunction:
+    case FunctionType::eFunction:
         return "function";
-    case Function::eOperatorEqual:
+    case FunctionType::eOperatorEqual:
         return "operator=";
-    case Function::eLambda:
+    case FunctionType::eLambda:
         return "lambda";
     }
     return "";
 }
 
-static bool isVariableCopyNeeded(const Variable &var)
+static bool isVariableCopyNeeded(const Variable &var, FunctionType type)
 {
-    return var.isPointer() || (var.type() && var.type()->needInitialization == Type::NeedInitialization::True) || (var.valueType()->type >= ValueType::Type::CHAR);
+    bool isOpEqual = false;
+    switch (type) {
+    case FunctionType::eOperatorEqual:
+        isOpEqual = true;
+        break;
+    case FunctionType::eCopyConstructor:
+    case FunctionType::eMoveConstructor:
+        break;
+    default:
+        return true;
+    }
+
+    return (!var.hasDefault() || isOpEqual) && // default init does not matter for operator=
+           (var.isPointer() ||
+            (var.type() && var.type()->needInitialization == Type::NeedInitialization::True) ||
+            (var.valueType() && var.valueType()->type >= ValueType::Type::CHAR));
 }
 
+static bool isVclTypeInit(const Type *type)
+{
+    if (!type)
+        return false;
+    return std::any_of(type->derivedFrom.begin(), type->derivedFrom.end(), [&](const Type::BaseInfo& baseInfo) {
+        if (!baseInfo.type)
+            return true;
+        if (isVclTypeInit(baseInfo.type))
+            return true;
+        return false;
+    });
+}
 //---------------------------------------------------------------------------
 
 CheckClass::CheckClass(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
     : Check(myName(), tokenizer, settings, errorLogger),
-      mSymbolDatabase(tokenizer?tokenizer->getSymbolDatabase():nullptr)
-{
-
-}
+    mSymbolDatabase(tokenizer?tokenizer->getSymbolDatabase():nullptr)
+{}
 
 //---------------------------------------------------------------------------
 // ClassCheck: Check that all class constructors are ok.
@@ -87,105 +122,145 @@ CheckClass::CheckClass(const Tokenizer *tokenizer, const Settings *settings, Err
 
 void CheckClass::constructors()
 {
-    const bool printStyle = mSettings->isEnabled(Settings::STYLE);
-    const bool printWarnings = mSettings->isEnabled(Settings::WARNING);
-    if (!printStyle && !printWarnings)
+    const bool printStyle = mSettings->severity.isEnabled(Severity::style);
+    const bool printWarnings = mSettings->severity.isEnabled(Severity::warning);
+    if (!printStyle && !printWarnings && !mSettings->isPremiumEnabled("uninitMemberVar"))
         return;
 
-    const bool printInconclusive = mSettings->inconclusive;
+    logChecker("CheckClass::checkConstructors"); // style,warning
+
+    const bool printInconclusive = mSettings->certainty.isEnabled(Certainty::inconclusive);
     for (const Scope * scope : mSymbolDatabase->classAndStructScopes) {
+        if (mSettings->hasLib("vcl") && isVclTypeInit(scope->definedType))
+            continue;
+
         const bool unusedTemplate = Token::simpleMatch(scope->classDef->previous(), ">");
 
-        bool usedInUnion = false;
-        for (const Scope &unionScope : mSymbolDatabase->scopeList) {
-            if (unionScope.type != Scope::eUnion)
-                continue;
-            for (const Variable &var : unionScope.varlist) {
-                if (var.type() && var.type()->classScope == scope) {
-                    usedInUnion = true;
-                    break;
-                }
-            }
-        }
+        const bool usedInUnion = std::any_of(mSymbolDatabase->scopeList.cbegin(), mSymbolDatabase->scopeList.cend(), [&](const Scope& unionScope) {
+            if (unionScope.type != ScopeType::eUnion)
+                return false;
+            return std::any_of(unionScope.varlist.cbegin(), unionScope.varlist.cend(), [&](const Variable& var) {
+                return var.type() && var.type()->classScope == scope;
+            });
+        });
 
         // There are no constructors.
         if (scope->numConstructors == 0 && printStyle && !usedInUnion) {
             // If there is a private variable, there should be a constructor..
+            int needInit = 0, haveInit = 0;
+            std::vector<const Variable*> uninitVars;
             for (const Variable &var : scope->varlist) {
-                const Token *initTok = var.nameToken();
-                while (Token::simpleMatch(initTok->next(), "["))
-                    initTok = initTok->linkAt(1);
-                if (var.isPrivate() && !var.isStatic() && !Token::Match(var.nameToken(), "%varid% ; %varid% =", var.declarationId()) &&
-                    !Token::Match(initTok, "%var%|] {|=") &&
+                if (var.isPrivate() && !var.isStatic() &&
                     (!var.isClass() || (var.type() && var.type()->needInitialization == Type::NeedInitialization::True))) {
-                    noConstructorError(scope->classDef, scope->className, scope->classDef->str() == "struct");
-                    break;
+                    ++needInit;
+                    if (!var.isInit() && !var.hasDefault() && var.nameToken()->scope() == scope) // don't warn for anonymous union members
+                        uninitVars.emplace_back(&var);
+                    else
+                        ++haveInit;
                 }
             }
+            if (needInit > haveInit) {
+                if (haveInit == 0)
+                    noConstructorError(scope->classDef, scope->className, scope->classDef->str() == "struct");
+                else
+                    for (const Variable* uv : uninitVars)
+                        uninitVarError(uv->typeStartToken(), uv->scope()->className, uv->name());
+            }
         }
 
         if (!printWarnings)
             continue;
 
-        // #3196 => bailout if there are nested unions
-        // TODO: handle union variables better
-        {
-            bool bailout = false;
-            for (const Scope * const nestedScope : scope->nestedList) {
-                if (nestedScope->type == Scope::eUnion) {
-                    bailout = true;
-                    break;
-                }
-            }
-            if (bailout)
-                continue;
-        }
-
-
-        std::vector<Usage> usage(scope->varlist.size());
+        std::vector<Usage> usageList = createUsageList(scope);
 
         for (const Function &func : scope->functionList) {
-            if (!func.hasBody() || !(func.isConstructor() || func.type == Function::eOperatorEqual))
-                continue;
+            if (!(func.isConstructor() && (func.hasBody() || (func.isDefault() && func.type == FunctionType::eConstructor))) &&
+                !(func.type == FunctionType::eOperatorEqual && func.hasBody()))
+                continue; // a defaulted constructor does not initialize primitive members
 
             // Bail: If initializer list is not recognized as a variable or type then skip since parsing is incomplete
-            if (unusedTemplate && func.type == Function::eConstructor) {
+            if (unusedTemplate && func.type == FunctionType::eConstructor) {
                 const Token *initList = func.constructorMemberInitialization();
                 if (Token::Match(initList, ": %name% (") && initList->next()->tokType() == Token::eName)
                     break;
             }
 
             // Mark all variables not used
-            clearAllVar(usage);
+            clearAllVar(usageList);
+
+            // Variables with default initializers
+            for (Usage &usage : usageList) {
+                const Variable& var = *usage.var;
+
+                // check for C++11 initializer
+                if (var.hasDefault() && func.type != FunctionType::eOperatorEqual && func.type != FunctionType::eCopyConstructor) { // variable still needs to be copied
+                    usage.init = true;
+                }
+            }
 
             std::list<const Function *> callstack;
-            initializeVarList(func, callstack, scope, usage);
+            initializeVarList(func, callstack, scope, usageList);
+
+            // Assign 1 union member => assign all union members
+            for (const Usage &usage : usageList) {
+                const Variable& var = *usage.var;
+                if (!usage.assign && !usage.init)
+                    continue;
+                const Scope* varScope1 = var.nameToken()->scope();
+                while (varScope1->type == ScopeType::eStruct)
+                    varScope1 = varScope1->nestedIn;
+                if (varScope1->type == ScopeType::eUnion) {
+                    for (Usage &usage2 : usageList) {
+                        const Variable& var2 = *usage2.var;
+                        if (usage2.assign || usage2.init || var2.isStatic())
+                            continue;
+                        const Scope* varScope2 = var2.nameToken()->scope();
+                        while (varScope2->type == ScopeType::eStruct)
+                            varScope2 = varScope2->nestedIn;
+                        if (varScope1 == varScope2)
+                            usage2.assign = true;
+                    }
+                }
+            }
 
             // Check if any variables are uninitialized
-            int count = -1;
-            for (const Variable &var : scope->varlist) {
-                ++count;
+            for (const Usage &usage : usageList) {
+                const Variable& var = *usage.var;
 
-                // check for C++11 initializer
-                if (var.hasDefault()) {
-                    usage[count].init = true;
+                if (usage.assign || usage.init || var.isStatic())
                     continue;
-                }
 
-                if (usage[count].assign || usage[count].init || var.isStatic())
+                if (!var.nameToken() || var.nameToken()->isAnonymous())
                     continue;
 
-                if (var.valueType()->pointer == 0 && var.type() && var.type()->needInitialization == Type::NeedInitialization::False && var.type()->derivedFrom.empty())
+                if (var.valueType() && var.valueType()->pointer == 0 && var.type() && var.type()->needInitialization == Type::NeedInitialization::False && var.type()->derivedFrom.empty())
                     continue;
 
                 if (var.isConst() && func.isOperator()) // We can't set const members in assignment operator
                     continue;
 
                 // Check if this is a class constructor
-                if (!var.isPointer() && !var.isPointerArray() && var.isClass() && func.type == Function::eConstructor) {
+                if (!var.isPointer() && !var.isPointerArray() && var.isClass() && func.type == FunctionType::eConstructor) {
                     // Unknown type so assume it is initialized
-                    if (!var.type())
-                        continue;
+                    if (!var.type()) {
+                        if (var.isStlType() && var.valueType() && var.valueType()->containerTypeToken) {
+                            if (var.valueType()->type == ValueType::Type::ITERATOR)
+                            {
+                                // needs initialization
+                            }
+                            else if (var.getTypeName() == "std::array") {
+                                const Token* ctt = var.valueType()->containerTypeToken;
+                                if (!ctt->isStandardType() &&
+                                    (!ctt->type() || ctt->type()->needInitialization != Type::NeedInitialization::True) &&
+                                    !mSettings->library.podtype(ctt->str())) // TODO: handle complex type expression
+                                    continue;
+                            }
+                            else
+                                continue;
+                        }
+                        else
+                            continue;
+                    }
 
                     // Known type that doesn't need initialization or
                     // known type that has member variables of an unknown type
@@ -195,7 +270,7 @@ void CheckClass::constructors()
 
                 // Check if type can't be copied
                 if (!var.isPointer() && !var.isPointerArray() && var.typeScope()) {
-                    if (func.type == Function::eMoveConstructor) {
+                    if (func.type == FunctionType::eMoveConstructor) {
                         if (canNotMove(var.typeScope()))
                             continue;
                     } else {
@@ -204,17 +279,20 @@ void CheckClass::constructors()
                     }
                 }
 
-                bool inconclusive = false;
+                // Is there missing member copy in copy/move constructor or assignment operator?
+                bool missingCopy = false;
+
                 // Don't warn about unknown types in copy constructors since we
                 // don't know if they can be copied or not..
-                if ((func.type == Function::eCopyConstructor || func.type == Function::eMoveConstructor || func.type == Function::eOperatorEqual) && !isVariableCopyNeeded(var))
-                    inconclusive = true;
+                if (!isVariableCopyNeeded(var, func.type)) {
+                    if (!printInconclusive)
+                        continue;
 
-                if (!printInconclusive && inconclusive)
-                    continue;
+                    missingCopy = true;
+                }
 
                 // It's non-static and it's not initialized => error
-                if (func.type == Function::eOperatorEqual) {
+                if (func.type == FunctionType::eOperatorEqual) {
                     const Token *operStart = func.arg;
 
                     bool classNameUsed = false;
@@ -225,36 +303,44 @@ void CheckClass::constructors()
                         }
                     }
 
-                    if (classNameUsed)
-                        operatorEqVarError(func.token, scope->className, var.name(), inconclusive);
+                    if (classNameUsed && mSettings->library.getTypeCheck("operatorEqVarError", var.getTypeName()) != Library::TypeCheck::suppress)
+                        operatorEqVarError(func.token, scope->className, var.name(), missingCopy);
                 } else if (func.access != AccessControl::Private || mSettings->standards.cpp >= Standards::CPP11) {
-                    // If constructor is not in scope then we maybe using a oonstructor from a different template specialization
+                    // If constructor is not in scope then we maybe using a constructor from a different template specialization
                     if (!precedes(scope->bodyStart, func.tokenDef))
                         continue;
-                    const Scope *varType = var.typeScope();
-                    if (!varType || varType->type != Scope::eUnion) {
-                        if (func.type == Function::eConstructor &&
-                            func.nestedIn && (func.nestedIn->numConstructors - func.nestedIn->numCopyOrMoveConstructors) > 1 &&
-                            func.argCount() == 0 && func.functionScope &&
-                            func.arg && func.arg->link()->next() == func.functionScope->bodyStart &&
-                            func.functionScope->bodyStart->link() == func.functionScope->bodyStart->next()) {
-                            // don't warn about user defined default constructor when there are other constructors
-                            if (printInconclusive)
-                                uninitVarError(func.token, func.access == AccessControl::Private, scope->className, var.name(), true);
-                        } else
-                            uninitVarError(func.token, func.access == AccessControl::Private, scope->className, var.name(), inconclusive);
-                    }
+
+                    const bool derived = scope != var.scope();
+                    if (func.type == FunctionType::eConstructor &&
+                        func.nestedIn && (func.nestedIn->numConstructors - func.nestedIn->numCopyOrMoveConstructors) > 1 &&
+                        func.argCount() == 0 && func.functionScope &&
+                        func.arg && func.arg->link()->next() == func.functionScope->bodyStart &&
+                        func.functionScope->bodyStart->link() == func.functionScope->bodyStart->next()) {
+                        // don't warn about user defined default constructor when there are other constructors
+                        if (printInconclusive)
+                            uninitVarError(func.token, func.access == AccessControl::Private, func.type, var.scope()->className, var.name(), derived, true);
+                    } else if (missingCopy)
+                        missingMemberCopyError(func.token, func.type, var.scope()->className, var.name());
+                    else
+                        uninitVarError(func.token, func.access == AccessControl::Private, func.type, var.scope()->className, var.name(), derived, false);
                 }
             }
         }
     }
 }
 
+static bool isPermissibleConversion(const std::string& type)
+{
+    return type == "std::initializer_list" || type == "std::nullptr_t";
+}
+
 void CheckClass::checkExplicitConstructors()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("noExplicitConstructor"))
         return;
 
+    logChecker("CheckClass::checkExplicitConstructors"); // style
+
     for (const Scope * scope : mSymbolDatabase->classAndStructScopes) {
         // Do not perform check, if the class/struct has not any constructors
         if (scope->numConstructors == 0)
@@ -262,17 +348,13 @@ void CheckClass::checkExplicitConstructors()
 
         // Is class abstract? Maybe this test is over-simplification, but it will suffice for simple cases,
         // and it will avoid false positives.
-        bool isAbstractClass = false;
-        for (const Function &func : scope->functionList) {
-            if (func.isPure()) {
-                isAbstractClass = true;
-                break;
-            }
-        }
+        const bool isAbstractClass = std::any_of(scope->functionList.cbegin(), scope->functionList.cend(), [](const Function& func) {
+            return func.isPure();
+        });
 
         // Abstract classes can't be instantiated. But if there is C++11
         // "misuse" by derived classes then these constructors must be explicit.
-        if (isAbstractClass && mSettings->standards.cpp != Standards::CPP11)
+        if (isAbstractClass && mSettings->standards.cpp >= Standards::CPP11)
             continue;
 
         for (const Function &func : scope->functionList) {
@@ -286,94 +368,123 @@ void CheckClass::checkExplicitConstructors()
                 continue;
 
             if (!func.isExplicit() &&
-                func.minArgCount() == 1 &&
-                func.type != Function::eCopyConstructor &&
-                func.type != Function::eMoveConstructor) {
-                noExplicitConstructorError(func.tokenDef, scope->className, scope->type == Scope::eStruct);
+                func.argCount() > 0 && func.minArgCount() < 2 &&
+                func.type != FunctionType::eCopyConstructor &&
+                func.type != FunctionType::eMoveConstructor &&
+                !(func.templateDef && Token::simpleMatch(func.argumentList.front().typeEndToken(), "...")) &&
+                !isPermissibleConversion(func.argumentList.front().getTypeName())) {
+                noExplicitConstructorError(func.tokenDef, scope->className, scope->type == ScopeType::eStruct);
             }
         }
     }
 }
 
-static bool isNonCopyable(const Scope *scope, bool *unknown)
+static bool hasNonCopyableBase(const Scope *scope, bool *unknown)
 {
-    bool u = false;
     // check if there is base class that is not copyable
     for (const Type::BaseInfo &baseInfo : scope->definedType->derivedFrom) {
         if (!baseInfo.type || !baseInfo.type->classScope) {
-            u = true;
+            *unknown = true;
             continue;
         }
 
-        if (isNonCopyable(baseInfo.type->classScope, &u))
+        if (hasNonCopyableBase(baseInfo.type->classScope, unknown))
             return true;
 
         for (const Function &func : baseInfo.type->classScope->functionList) {
-            if (func.type != Function::eCopyConstructor)
+            if (func.type != FunctionType::eCopyConstructor)
                 continue;
-            if (func.access == AccessControl::Private || func.isDelete())
+            if (func.access == AccessControl::Private || func.isDelete()) {
+                *unknown = false;
                 return true;
+            }
         }
     }
-    *unknown = u;
     return false;
 }
 
 void CheckClass::copyconstructors()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckClass::checkCopyConstructors"); // warning
+
     for (const Scope * scope : mSymbolDatabase->classAndStructScopes) {
         std::map<int, const Token*> allocatedVars;
+        std::map<int, const Token*> deallocatedVars;
 
         for (const Function &func : scope->functionList) {
-            if (func.type != Function::eConstructor || !func.functionScope)
-                continue;
-            const Token* tok = func.token->linkAt(1);
-            for (const Token* const end = func.functionScope->bodyStart; tok != end; tok = tok->next()) {
-                if (Token::Match(tok, "%var% ( new") ||
-                    (Token::Match(tok, "%var% ( %name% (") && mSettings->library.getAllocFuncInfo(tok->tokAt(2)))) {
-                    const Variable* var = tok->variable();
-                    if (var && var->isPointer() && var->scope() == scope)
-                        allocatedVars[tok->varId()] = tok;
+            if (func.type == FunctionType::eConstructor && func.functionScope) {
+                // Allocations in constructors
+                const Token* tok = func.token->linkAt(1);
+                for (const Token* const end = func.functionScope->bodyStart; tok != end; tok = tok->next()) {
+                    if (Token::Match(tok, "%var% ( new") ||
+                        (Token::Match(tok, "%var% ( %name% (") && mSettings->library.getAllocFuncInfo(tok->tokAt(2)))) {
+                        const Variable* var = tok->variable();
+                        if (var && var->isPointer() && var->scope() == scope)
+                            allocatedVars[tok->varId()] = tok;
+                    }
                 }
-            }
-            for (const Token* const end = func.functionScope->bodyEnd; tok != end; tok = tok->next()) {
-                if (Token::Match(tok, "%var% = new") ||
-                    (Token::Match(tok, "%var% = %name% (") && mSettings->library.getAllocFuncInfo(tok->tokAt(2)))) {
-                    const Variable* var = tok->variable();
-                    if (var && var->isPointer() && var->scope() == scope && !var->isStatic())
-                        allocatedVars[tok->varId()] = tok;
+                for (const Token* const end = func.functionScope->bodyEnd; tok != end; tok = tok->next()) {
+                    if (Token::Match(tok, "%var% = new") ||
+                        (Token::Match(tok, "%var% = %name% (") && mSettings->library.getAllocFuncInfo(tok->tokAt(2)))) {
+                        const Variable* var = tok->variable();
+                        if (var && var->isPointer() && var->scope() == scope && !var->isStatic())
+                            allocatedVars[tok->varId()] = tok;
+                    }
+                }
+            } else if (func.type == FunctionType::eDestructor && func.functionScope) {
+                // Deallocations in destructors
+                const Token* tok = func.functionScope->bodyStart;
+                for (const Token* const end = func.functionScope->bodyEnd; tok != end; tok = tok->next()) {
+                    if (Token::Match(tok, "delete %var%") ||
+                        (Token::Match(tok, "%name% ( %var%") && mSettings->library.getDeallocFuncInfo(tok))) {
+                        const Token *vartok = tok->str() == "delete" ? tok->next() : tok->tokAt(2);
+                        const Variable* var = vartok->variable();
+                        if (var && var->isPointer() && var->scope() == scope && !var->isStatic())
+                            deallocatedVars[vartok->varId()] = vartok;
+                    }
                 }
             }
         }
 
-        if (!allocatedVars.empty()) {
+        const bool hasAllocatedVars = !allocatedVars.empty();
+        const bool hasDeallocatedVars = !deallocatedVars.empty();
+
+        if (hasAllocatedVars || hasDeallocatedVars) {
             const Function *funcCopyCtor = nullptr;
             const Function *funcOperatorEq = nullptr;
             const Function *funcDestructor = nullptr;
             for (const Function &func : scope->functionList) {
-                if (func.type == Function::eCopyConstructor)
+                if (func.type == FunctionType::eCopyConstructor)
                     funcCopyCtor = &func;
-                else if (func.type == Function::eOperatorEqual)
+                else if (func.type == FunctionType::eOperatorEqual)
                     funcOperatorEq = &func;
-                else if (func.type == Function::eDestructor)
+                else if (func.type == FunctionType::eDestructor)
                     funcDestructor = &func;
             }
             if (!funcCopyCtor || funcCopyCtor->isDefault()) {
                 bool unknown = false;
-                if (!isNonCopyable(scope, &unknown) && !unknown)
-                    noCopyConstructorError(scope, funcCopyCtor, allocatedVars.begin()->second, unknown);
+                if (!hasNonCopyableBase(scope, &unknown) && !unknown) {
+                    if (hasAllocatedVars)
+                        noCopyConstructorError(scope, funcCopyCtor, allocatedVars.cbegin()->second, unknown);
+                    else
+                        noCopyConstructorError(scope, funcCopyCtor, deallocatedVars.cbegin()->second, unknown);
+                }
             }
             if (!funcOperatorEq || funcOperatorEq->isDefault()) {
                 bool unknown = false;
-                if (!isNonCopyable(scope, &unknown) && !unknown)
-                    noOperatorEqError(scope, funcOperatorEq, allocatedVars.begin()->second, unknown);
+                if (!hasNonCopyableBase(scope, &unknown) && !unknown) {
+                    if (hasAllocatedVars)
+                        noOperatorEqError(scope, funcOperatorEq, allocatedVars.cbegin()->second, unknown);
+                    else
+                        noOperatorEqError(scope, funcOperatorEq, deallocatedVars.cbegin()->second, unknown);
+                }
             }
             if (!funcDestructor || funcDestructor->isDefault()) {
                 const Token * mustDealloc = nullptr;
-                for (std::map<int, const Token*>::const_iterator it = allocatedVars.begin(); it != allocatedVars.end(); ++it) {
+                for (auto it = allocatedVars.cbegin(); it != allocatedVars.cend(); ++it) {
                     if (!Token::Match(it->second, "%var% [(=] new %type%")) {
                         mustDealloc = it->second;
                         break;
@@ -383,8 +494,10 @@ void CheckClass::copyconstructors()
                         break;
                     }
                     const Variable *var = it->second->variable();
-                    if (var && var->typeScope() && var->typeScope()->functionList.empty() && var->type()->derivedFrom.empty())
+                    if (var && var->typeScope() && var->typeScope()->functionList.empty() && var->type()->derivedFrom.empty()) {
                         mustDealloc = it->second;
+                        break;
+                    }
                 }
                 if (mustDealloc)
                     noDestructorError(scope, funcDestructor, mustDealloc);
@@ -394,7 +507,7 @@ void CheckClass::copyconstructors()
         std::set<const Token*> copiedVars;
         const Token* copyCtor = nullptr;
         for (const Function &func : scope->functionList) {
-            if (func.type != Function::eCopyConstructor)
+            if (func.type != FunctionType::eCopyConstructor)
                 continue;
             copyCtor = func.tokenDef;
             if (!func.functionScope) {
@@ -415,7 +528,8 @@ void CheckClass::copyconstructors()
                 }
             }
             for (tok = func.functionScope->bodyStart; tok != func.functionScope->bodyEnd; tok = tok->next()) {
-                if (Token::Match(tok, "%var% = new|malloc|g_malloc|g_try_malloc|realloc|g_realloc|g_try_realloc")) {
+                if ((tok->isCpp() && Token::Match(tok, "%var% = new")) ||
+                    (Token::Match(tok, "%var% = %name% (") && (mSettings->library.getAllocFuncInfo(tok->tokAt(2)) || mSettings->library.getReallocFuncInfo(tok->tokAt(2))))) {
                     allocatedVars.erase(tok->varId());
                 } else if (Token::Match(tok, "%var% = %name% . %name% ;") && allocatedVars.find(tok->varId()) != allocatedVars.end()) {
                     copiedVars.insert(tok);
@@ -428,34 +542,34 @@ void CheckClass::copyconstructors()
                 copyConstructorShallowCopyError(cv, cv->str());
             // throw error if count mismatch
             /* FIXME: This doesn't work. See #4154
-            for (std::map<int, const Token*>::const_iterator i = allocatedVars.begin(); i != allocatedVars.end(); ++i) {
+               for (auto i = allocatedVars.cbegin(); i != allocatedVars.end(); ++i) {
                 copyConstructorMallocError(copyCtor, i->second, i->second->str());
-            }
-            */
+               }
+             */
         }
     }
 }
 
 /* This doesn't work. See #4154
-void CheckClass::copyConstructorMallocError(const Token *cctor, const Token *alloc, const std::string& varname)
-{
+   void CheckClass::copyConstructorMallocError(const Token *cctor, const Token *alloc, const std::string& varname)
+   {
     std::list<const Token*> callstack;
     callstack.push_back(cctor);
     callstack.push_back(alloc);
     reportError(callstack, Severity::warning, "copyCtorNoAllocation", "Copy constructor does not allocate memory for member '" + varname + "' although memory has been allocated in other constructors.");
-}
-*/
+   }
+ */
 
 void CheckClass::copyConstructorShallowCopyError(const Token *tok, const std::string& varname)
 {
     reportError(tok, Severity::warning, "copyCtorPointerCopying",
-                "$symbol:" + varname + "\nValue of pointer '$symbol', which points to allocated memory, is copied in copy constructor instead of allocating new memory.", CWE398, false);
+                "$symbol:" + varname + "\nValue of pointer '$symbol', which points to allocated memory, is copied in copy constructor instead of allocating new memory.", CWE398, Certainty::normal);
 }
 
 static std::string noMemberErrorMessage(const Scope *scope, const char function[], bool isdefault)
 {
     const std::string &classname = scope ? scope->className : "class";
-    const std::string type = (scope && scope->type == Scope::eStruct) ? "Struct" : "Class";
+    const std::string type = (scope && scope->type == ScopeType::eStruct) ? "Struct" : "Class";
     const bool isDestructor = (function[0] == 'd');
     std::string errmsg = "$symbol:" + classname + '\n';
 
@@ -466,7 +580,7 @@ static std::string noMemberErrorMessage(const Scope *scope, const char function[
         else
             errmsg += " It is recommended to define or delete the " + std::string(function) + '.';
     } else {
-        errmsg += type + " '$symbol' does not have a " + function + " which is recommended since it has dynamic memory/resource allocation(s).";
+        errmsg += type + " '$symbol' does not have a " + function + " which is recommended since it has dynamic memory/resource management.";
     }
 
     return errmsg;
@@ -474,17 +588,17 @@ static std::string noMemberErrorMessage(const Scope *scope, const char function[
 
 void CheckClass::noCopyConstructorError(const Scope *scope, bool isdefault, const Token *alloc, bool inconclusive)
 {
-    reportError(alloc, Severity::warning, "noCopyConstructor", noMemberErrorMessage(scope, "copy constructor", isdefault), CWE398, inconclusive);
+    reportError(alloc, Severity::warning, "noCopyConstructor", noMemberErrorMessage(scope, "copy constructor", isdefault), CWE398, inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
 void CheckClass::noOperatorEqError(const Scope *scope, bool isdefault, const Token *alloc, bool inconclusive)
 {
-    reportError(alloc, Severity::warning, "noOperatorEq", noMemberErrorMessage(scope, "operator=", isdefault), CWE398, inconclusive);
+    reportError(alloc, Severity::warning, "noOperatorEq", noMemberErrorMessage(scope, "operator=", isdefault), CWE398, inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
 void CheckClass::noDestructorError(const Scope *scope, bool isdefault, const Token *alloc)
 {
-    reportError(alloc, Severity::warning, "noDestructor", noMemberErrorMessage(scope, "destructor", isdefault), CWE398, false);
+    reportError(alloc, Severity::warning, "noDestructor", noMemberErrorMessage(scope, "destructor", isdefault), CWE398, Certainty::normal);
 }
 
 bool CheckClass::canNotCopy(const Scope *scope)
@@ -498,10 +612,11 @@ bool CheckClass::canNotCopy(const Scope *scope)
             constructor = true;
         if (func.access != AccessControl::Public)
             continue;
-        if (func.type == Function::eCopyConstructor) {
+        if (func.type == FunctionType::eCopyConstructor) {
             publicCopy = true;
             break;
-        } else if (func.type == Function::eOperatorEqual) {
+        }
+        if (func.type == FunctionType::eOperatorEqual) {
             publicAssign = true;
             break;
         }
@@ -522,13 +637,15 @@ bool CheckClass::canNotMove(const Scope *scope)
             constructor = true;
         if (func.access != AccessControl::Public)
             continue;
-        if (func.type == Function::eCopyConstructor) {
+        if (func.type == FunctionType::eCopyConstructor) {
             publicCopy = true;
             break;
-        } else if (func.type == Function::eMoveConstructor) {
+        }
+        if (func.type == FunctionType::eMoveConstructor) {
             publicMove = true;
             break;
-        } else if (func.type == Function::eOperatorEqual) {
+        }
+        if (func.type == FunctionType::eOperatorEqual) {
             publicAssign = true;
             break;
         }
@@ -537,45 +654,97 @@ bool CheckClass::canNotMove(const Scope *scope)
     return constructor && !(publicAssign || publicCopy || publicMove);
 }
 
-void CheckClass::assignVar(nonneg int varid, const Scope *scope, std::vector<Usage> &usage)
+static void getAllVariableMembers(const Scope *scope, std::vector<const Variable *>& varList)
 {
-    int count = 0;
-
-    for (std::list<Variable>::const_iterator var = scope->varlist.begin(); var != scope->varlist.end(); ++var, ++count) {
-        if (var->declarationId() == varid) {
-            usage[count].assign = true;
-            return;
+    std::transform(scope->varlist.cbegin(), scope->varlist.cend(), std::back_inserter(varList), [](const Variable& var) {
+        return &var;
+    });
+    if (scope->definedType) {
+        for (const Type::BaseInfo& baseInfo: scope->definedType->derivedFrom) {
+            if (scope->definedType == baseInfo.type)
+                continue;
+            const Scope *baseClass = baseInfo.type ? baseInfo.type->classScope : nullptr;
+            if (baseClass && baseClass->isClassOrStruct() && baseClass->numConstructors == 0)
+                getAllVariableMembers(baseClass, varList);
         }
     }
 }
 
-void CheckClass::initVar(nonneg int varid, const Scope *scope, std::vector<Usage> &usage)
+std::vector<CheckClass::Usage> CheckClass::createUsageList(const Scope *scope)
 {
-    int count = 0;
+    std::vector<Usage> ret;
+    std::vector<const Variable *> varlist;
+    getAllVariableMembers(scope, varlist);
+    ret.reserve(varlist.size());
+    std::transform(varlist.cbegin(), varlist.cend(), std::back_inserter(ret), [](const Variable* var) {
+        return Usage(var);
+    });
+    return ret;
+}
 
-    for (std::list<Variable>::const_iterator var = scope->varlist.begin(); var != scope->varlist.end(); ++var, ++count) {
-        if (var->declarationId() == varid) {
-            usage[count].init = true;
-            return;
-        }
+void CheckClass::assignVar(std::vector<Usage> &usageList, nonneg int varid)
+{
+    auto it = std::find_if(usageList.begin(), usageList.end(), [varid](const Usage& usage) {
+        return usage.var->declarationId() == varid;
+    });
+    if (it != usageList.end())
+        it->assign = true;
+}
+
+void CheckClass::assignVar(std::vector<Usage> &usageList, const Token* vartok)
+{
+    if (vartok->varId() > 0) {
+        assignVar(usageList, vartok->varId());
+        return;
     }
+    auto it = std::find_if(usageList.begin(), usageList.end(), [vartok](const Usage& usage) {
+        // FIXME: This is a workaround when varid is not set for a derived member
+        return usage.var->name() == vartok->str();
+    });
+    if (it != usageList.end())
+        it->assign = true;
+}
+
+void CheckClass::initVar(std::vector<Usage> &usageList, nonneg int varid)
+{
+    auto it = std::find_if(usageList.begin(), usageList.end(), [varid](const Usage& usage) {
+        return usage.var->declarationId() == varid;
+    });
+    if (it != usageList.end())
+        it->init = true;
 }
 
-void CheckClass::assignAllVar(std::vector<Usage> &usage)
+void CheckClass::assignAllVar(std::vector<Usage> &usageList)
 {
-    for (Usage & i : usage)
+    for (Usage & i : usageList)
         i.assign = true;
 }
 
-void CheckClass::clearAllVar(std::vector<Usage> &usage)
+void CheckClass::assignAllVarsVisibleFromScope(std::vector<Usage>& usageList, const Scope* scope)
+{
+    for (Usage& usage : usageList) {
+        if (usage.var->scope() == scope)
+            usage.assign = true;
+    }
+
+    // Iterate through each base class...
+    for (const Type::BaseInfo& i : scope->definedType->derivedFrom) {
+        const Type *derivedFrom = i.type;
+
+        if (derivedFrom && derivedFrom->classScope)
+            assignAllVarsVisibleFromScope(usageList, derivedFrom->classScope);
+    }
+}
+
+void CheckClass::clearAllVar(std::vector<Usage> &usageList)
 {
-    for (Usage & i : usage) {
+    for (Usage & i : usageList) {
         i.assign = false;
         i.init = false;
     }
 }
 
-bool CheckClass::isBaseClassFunc(const Token *tok, const Scope *scope)
+bool CheckClass::isBaseClassMutableMemberFunc(const Token *tok, const Scope *scope)
 {
     // Iterate through each base class...
     for (const Type::BaseInfo & i : scope->definedType->derivedFrom) {
@@ -585,10 +754,13 @@ bool CheckClass::isBaseClassFunc(const Token *tok, const Scope *scope)
         if (derivedFrom && derivedFrom->classScope) {
             const std::list<Function>& functionList = derivedFrom->classScope->functionList;
 
-            for (const Function &func : functionList) {
-                if (func.tokenDef->str() == tok->str())
-                    return true;
-            }
+            if (std::any_of(functionList.cbegin(), functionList.cend(), [&](const Function& func) {
+                return func.tokenDef->str() == tok->str() && !func.isStatic() && !func.isConst();
+            }))
+                return true;
+
+            if (isBaseClassMutableMemberFunc(tok, derivedFrom->classScope))
+                return true;
         }
 
         // Base class not found so assume it is in it.
@@ -599,10 +771,11 @@ bool CheckClass::isBaseClassFunc(const Token *tok, const Scope *scope)
     return false;
 }
 
-void CheckClass::initializeVarList(const Function &func, std::list<const Function *> &callstack, const Scope *scope, std::vector<Usage> &usage)
+void CheckClass::initializeVarList(const Function &func, std::list<const Function *> &callstack, const Scope *scope, std::vector<Usage> &usage) const
 {
     if (!func.functionScope)
-        throw InternalError(nullptr, "Internal Error: Invalid syntax"); // #5702
+        return;
+
     bool initList = func.isConstructor();
     const Token *ftok = func.arg->link()->next();
     int level = 0;
@@ -612,7 +785,14 @@ void CheckClass::initializeVarList(const Function &func, std::list<const Functio
         if (initList) {
             if (level == 0 && Token::Match(ftok, "%name% {|(") && Token::Match(ftok->linkAt(1), "}|) ,|{")) {
                 if (ftok->str() != func.name()) {
-                    initVar(ftok->varId(), scope, usage);
+                    if (ftok->varId())
+                        initVar(usage, ftok->varId());
+                    else { // base class constructor
+                        for (Usage& u : usage) {
+                            if (u.var->scope() != scope) // assume that all variables are initialized in base class
+                                u.init = true;
+                        }
+                    }
                 } else { // c++11 delegate constructor
                     const Function *member = ftok->function();
                     // member function not found => assume it initializes all members
@@ -623,7 +803,7 @@ void CheckClass::initializeVarList(const Function &func, std::list<const Functio
 
                     // recursive call
                     // assume that all variables are initialized
-                    if (std::find(callstack.begin(), callstack.end(), member) != callstack.end()) {
+                    if (std::find(callstack.cbegin(), callstack.cend(), member) != callstack.cend()) {
                         /** @todo false negative: just bail */
                         assignAllVar(usage);
                         return;
@@ -643,7 +823,7 @@ void CheckClass::initializeVarList(const Function &func, std::list<const Functio
                     }
                 }
             } else if (level != 0 && Token::Match(ftok, "%name% =")) // assignment in the initializer: var(value = x)
-                assignVar(ftok->varId(), scope, usage);
+                assignVar(usage, ftok->varId());
 
             // Level handling
             if (ftok->link() && Token::Match(ftok, "(|<"))
@@ -662,8 +842,8 @@ void CheckClass::initializeVarList(const Function &func, std::list<const Functio
             continue;
 
         // Variable getting value from stream?
-        if (Token::Match(ftok, ">>|& %name%") && isLikelyStreamRead(true, ftok)) {
-            assignVar(ftok->next()->varId(), scope, usage);
+        if (Token::Match(ftok, ">>|& %name%") && isLikelyStreamRead(ftok)) {
+            assignVar(usage, ftok->next()->varId());
         }
 
         // If assignment comes after an && or || this is really inconclusive because of short circuiting
@@ -680,20 +860,18 @@ void CheckClass::initializeVarList(const Function &func, std::list<const Functio
         }
 
         // Using swap to assign all variables..
-        if (func.type == Function::eOperatorEqual && Token::Match(ftok, "[;{}] %name% (") && Token::Match(ftok->linkAt(2), ") . %name% ( *| this ) ;")) {
+        if (func.type == FunctionType::eOperatorEqual && Token::Match(ftok, "[;{}] %name% (") && Token::Match(ftok->linkAt(2), ") . %name% ( *| this ) ;")) {
             assignAllVar(usage);
             break;
         }
 
         // Calling member variable function?
-        if (Token::Match(ftok->next(), "%var% . %name% (")) {
-            for (const Variable &var : scope->varlist) {
-                if (var.declarationId() == ftok->next()->varId()) {
-                    /** @todo false negative: we assume function changes variable state */
-                    assignVar(ftok->next()->varId(), scope, usage);
-                    break;
-                }
-            }
+        if (Token::Match(ftok->next(), "%var% . %name% (") && !(ftok->next()->valueType() && ftok->next()->valueType()->pointer)) {
+            if (std::any_of(scope->varlist.cbegin(), scope->varlist.cend(), [&](const Variable& var) {
+                return var.declarationId() == ftok->next()->varId();
+            }))
+                /** @todo false negative: we assume function changes variable state */
+                assignVar(usage, ftok->next()->varId());
 
             ftok = ftok->tokAt(2);
         }
@@ -701,7 +879,9 @@ void CheckClass::initializeVarList(const Function &func, std::list<const Functio
         if (!Token::Match(ftok->next(), "::| %name%") &&
             !Token::Match(ftok->next(), "*| this . %name%") &&
             !Token::Match(ftok->next(), "* %name% =") &&
-            !Token::Match(ftok->next(), "( * this ) . %name%"))
+            !Token::Match(ftok->next(), "( * this ) . %name%") &&
+            !Token::Match(ftok->next(), "( * %name% ) =") &&
+            !Token::Match(ftok->next(), "* ( %name% ) ="))
             continue;
 
         // Goto the first token in this statement..
@@ -733,34 +913,33 @@ void CheckClass::initializeVarList(const Function &func, std::list<const Functio
         }
 
         // Ticket #7068
-        else if (Token::Match(ftok, "::| memset ( &| this . %name%")) {
+        if (Token::Match(ftok, "::| memset ( &| this . %name%")) {
             if (ftok->str() == "::")
                 ftok = ftok->next();
             int offsetToMember = 4;
             if (ftok->strAt(2) == "&")
                 ++offsetToMember;
-            assignVar(ftok->tokAt(offsetToMember)->varId(), scope, usage);
+            assignVar(usage, ftok->tokAt(offsetToMember)->varId());
             ftok = ftok->linkAt(1);
             continue;
         }
 
         // Clearing array..
-        else if (Token::Match(ftok, "::| memset ( %name% ,")) {
+        if (Token::Match(ftok, "::| memset ( %name% ,")) {
             if (ftok->str() == "::")
                 ftok = ftok->next();
-            assignVar(ftok->tokAt(2)->varId(), scope, usage);
+            assignVar(usage, ftok->tokAt(2)->varId());
             ftok = ftok->linkAt(1);
             continue;
         }
 
         // Calling member function?
-        else if (Token::simpleMatch(ftok, "operator= (") &&
-                 ftok->previous()->str() != "::") {
-            if (ftok->function() && ftok->function()->nestedIn == scope) {
+        if (Token::simpleMatch(ftok, "operator= (")) {
+            if (ftok->function()) {
                 const Function *member = ftok->function();
                 // recursive call
                 // assume that all variables are initialized
-                if (std::find(callstack.begin(), callstack.end(), member) != callstack.end()) {
+                if (std::find(callstack.cbegin(), callstack.cend(), member) != callstack.cend()) {
                     /** @todo false negative: just bail */
                     assignAllVar(usage);
                     return;
@@ -774,6 +953,12 @@ void CheckClass::initializeVarList(const Function &func, std::list<const Functio
                     callstack.pop_back();
                 }
 
+                // assume that a base class call to operator= assigns all its base members (but not more)
+                else if (func.tokenDef->str() == ftok->str() && isBaseClassMutableMemberFunc(ftok, scope)) {
+                    if (member->nestedIn)
+                        assignAllVarsVisibleFromScope(usage, member->nestedIn->definedType->classScope);
+                }
+
                 // there is a called member function, but it has no implementation, so we assume it initializes everything
                 else {
                     assignAllVar(usage);
@@ -789,7 +974,7 @@ void CheckClass::initializeVarList(const Function &func, std::list<const Functio
                 ftok = ftok->next();
 
             // Passing "this" => assume that everything is initialized
-            for (const Token *tok2 = ftok->next()->link(); tok2 && tok2 != ftok; tok2 = tok2->previous()) {
+            for (const Token *tok2 = ftok->linkAt(1); tok2 && tok2 != ftok; tok2 = tok2->previous()) {
                 if (tok2->str() == "this") {
                     assignAllVar(usage);
                     return;
@@ -803,7 +988,7 @@ void CheckClass::initializeVarList(const Function &func, std::list<const Functio
 
                 // recursive call
                 // assume that all variables are initialized
-                if (std::find(callstack.begin(), callstack.end(), member) != callstack.end()) {
+                if (std::find(callstack.cbegin(), callstack.cend(), member) != callstack.cend()) {
                     assignAllVar(usage);
                     return;
                 }
@@ -823,21 +1008,30 @@ void CheckClass::initializeVarList(const Function &func, std::list<const Functio
                             tok2 = tok2->next();
                             if (tok2->str() == "&")
                                 tok2 = tok2->next();
-                            assignVar(tok2->varId(), scope, usage);
+                            if (isVariableChangedByFunctionCall(tok2, tok2->strAt(-1) == "&", tok2->varId(), *mSettings, nullptr))
+                                assignVar(usage, tok2->varId());
                         }
                     }
                 }
 
-                // there is a called member function, but it has no implementation, so we assume it initializes everything
-                else {
+                // there is a called member function, but it has no implementation, so we assume it initializes everything (if it can mutate state)
+                else if (!member->isConst() && !member->isStatic()) {
                     assignAllVar(usage);
                 }
+
+                // const method, assume it assigns all mutable members
+                else if (member->isConst()) {
+                    for (Usage& i: usage) {
+                        if (i.var->isMutable())
+                            i.assign = true;
+                    }
+                }
             }
 
             // not member function
             else {
                 // could be a base class virtual function, so we assume it initializes everything
-                if (!func.isConstructor() && isBaseClassFunc(ftok, scope)) {
+                if (!func.isConstructor() && isBaseClassMutableMemberFunc(ftok, scope)) {
                     /** @todo False Negative: we should look at the base class functions to see if they
                      *  call any derived class virtual functions that change the derived class state
                      */
@@ -851,9 +1045,9 @@ void CheckClass::initializeVarList(const Function &func, std::list<const Functio
                 // the function is external and it's neither friend nor inherited virtual function.
                 // assume all variables that are passed to it are initialized..
                 else {
-                    for (const Token *tok = ftok->tokAt(2); tok && tok != ftok->next()->link(); tok = tok->next()) {
+                    for (const Token *tok = ftok->tokAt(2); tok && tok != ftok->linkAt(1); tok = tok->next()) {
                         if (tok->isName()) {
-                            assignVar(tok->varId(), scope, usage);
+                            assignVar(usage, tok->varId());
                         }
                     }
                 }
@@ -862,7 +1056,7 @@ void CheckClass::initializeVarList(const Function &func, std::list<const Functio
 
         // Assignment of member variable?
         else if (Token::Match(ftok, "%name% =")) {
-            assignVar(ftok->varId(), scope, usage);
+            assignVar(usage, ftok);
             bool bailout = ftok->variable() && ftok->variable()->isReference();
             const Token* tok2 = ftok->tokAt(2);
             if (tok2->str() == "&") {
@@ -870,7 +1064,7 @@ void CheckClass::initializeVarList(const Function &func, std::list<const Functio
                 bailout = true;
             }
             if (tok2->variable() && (bailout || tok2->variable()->isArray()) && tok2->strAt(1) != "[")
-                assignVar(tok2->varId(), scope, usage);
+                assignVar(usage, tok2->varId());
         }
 
         // Assignment of array item of member variable?
@@ -878,26 +1072,33 @@ void CheckClass::initializeVarList(const Function &func, std::list<const Functio
             const Token *tok2 = ftok;
             while (tok2) {
                 if (tok2->strAt(1) == "[")
-                    tok2 = tok2->next()->link();
+                    tok2 = tok2->linkAt(1);
                 else if (Token::Match(tok2->next(), ". %name%"))
                     tok2 = tok2->tokAt(2);
                 else
                     break;
             }
             if (tok2 && tok2->strAt(1) == "=")
-                assignVar(ftok->varId(), scope, usage);
+                assignVar(usage, ftok->varId());
         }
 
         // Assignment of array item of member variable?
-        else if (Token::Match(ftok, "* %name% =")) {
-            assignVar(ftok->next()->varId(), scope, usage);
-        } else if (Token::Match(ftok, "* this . %name% =")) {
-            assignVar(ftok->tokAt(3)->varId(), scope, usage);
+        else if (Token::Match(ftok, "* %name% =") && (!func.isConstructor() || (!ftok->next()->variable() || ftok->next()->variable()->isArray()))) {
+            assignVar(usage, ftok->next()->varId());
+        } else if (Token::Match(ftok, "( * %name% ) =") && (!func.isConstructor() || (!ftok->tokAt(2)->variable() || ftok->tokAt(2)->variable()->isArray()))) {
+            assignVar(usage, ftok->tokAt(2)->varId());
+        } else if (Token::Match(ftok, "* this . %name% =") && (!func.isConstructor() || (!ftok->tokAt(3)->variable() || ftok->tokAt(3)->variable()->isArray()))) {
+            assignVar(usage, ftok->tokAt(3)->varId());
+        } else if (astIsRangeBasedForDecl(ftok)) {
+            if (const Variable* rangeVar = ftok->astParent()->astOperand1()->variable()) {
+                if (rangeVar->isReference() && !rangeVar->isConst())
+                    assignVar(usage, ftok->varId());
+            }
         }
 
         // The functions 'clear' and 'Clear' are supposed to initialize variable.
         if (Token::Match(ftok, "%name% . clear|Clear (")) {
-            assignVar(ftok->varId(), scope, usage);
+            assignVar(usage, ftok->varId());
         }
     }
 }
@@ -905,29 +1106,54 @@ void CheckClass::initializeVarList(const Function &func, std::list<const Functio
 void CheckClass::noConstructorError(const Token *tok, const std::string &classname, bool isStruct)
 {
     // For performance reasons the constructor might be intentionally missing. Therefore this is not a "warning"
-    reportError(tok, Severity::style, "noConstructor",
-                "$symbol:" + classname + "\n" +
-                "The " + std::string(isStruct ? "struct" : "class") + " '$symbol' does not have a constructor although it has private member variables.\n"
-                "The " + std::string(isStruct ? "struct" : "class") + " '$symbol' does not have a constructor "
-                "although it has private member variables. Member variables of builtin types are left "
-                "uninitialized when the class is instantiated. That may cause bugs or undefined behavior.", CWE398, false);
+    const std::string message {"The " + std::string(isStruct ? "struct" : "class") + " '$symbol' does not declare a constructor although it has private member variables which likely require initialization."};
+    const std::string verbose {message + " Member variables of native types, pointers, or references are left uninitialized when the class is instantiated. That may cause bugs or undefined behavior."};
+    reportError(tok, Severity::style, "noConstructor", "$symbol:" + classname + '\n' + message + '\n' + verbose, CWE398, Certainty::normal);
 }
 
 void CheckClass::noExplicitConstructorError(const Token *tok, const std::string &classname, bool isStruct)
 {
     const std::string message(std::string(isStruct ? "Struct" : "Class") + " '$symbol' has a constructor with 1 argument that is not explicit.");
-    const std::string verbose(message + " Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.");
-    reportError(tok, Severity::style, "noExplicitConstructor", "$symbol:" + classname + '\n' + message + '\n' + verbose, CWE398, false);
+    const std::string verbose(message + " Such, so called \"Converting constructors\", should in general be explicit for type safety reasons as that prevents unintended implicit conversions.");
+    reportError(tok, Severity::style, "noExplicitConstructor", "$symbol:" + classname + '\n' + message + '\n' + verbose, CWE398, Certainty::normal);
+}
+
+void CheckClass::uninitVarError(const Token *tok, bool isprivate, FunctionType functionType, const std::string &classname, const std::string &varname, bool derived, bool inconclusive)
+{
+    std::string ctor;
+    if (functionType == FunctionType::eCopyConstructor)
+        ctor = "copy ";
+    else if (functionType == FunctionType::eMoveConstructor)
+        ctor = "move ";
+    std::string message("Member variable '$symbol' is not initialized in the " + ctor + "constructor.");
+    if (derived)
+        message += " Maybe it should be initialized directly in the class " + classname + "?";
+    std::string id = std::string("uninit") + (derived ? "Derived" : "") + "MemberVar" + (isprivate ? "Private" : "");
+    const std::string verbose {message + " Member variables of native types, pointers, or references are left uninitialized when the class is instantiated. That may cause bugs or undefined behavior."};
+    reportError(tok, Severity::warning, id, "$symbol:" + classname + "::" + varname + '\n' + message + '\n' + verbose, CWE398, inconclusive ? Certainty::inconclusive : Certainty::normal);
+}
+
+void CheckClass::uninitVarError(const Token *tok, const std::string &classname, const std::string &varname)
+{
+    const std::string message("Member variable '$symbol' is not initialized."); // report missing in-class initializer
+    const std::string verbose {message + " Member variables of native types, pointers, or references are left uninitialized when the class is instantiated. That may cause bugs or undefined behavior."};
+    const std::string id = std::string("uninitMemberVarPrivate");
+    reportError(tok, Severity::warning, id, "$symbol:" + classname + "::" + varname + '\n' + message + '\n' + verbose, CWE398, Certainty::normal);
 }
 
-void CheckClass::uninitVarError(const Token *tok, bool isprivate, const std::string &classname, const std::string &varname, bool inconclusive)
+void CheckClass::missingMemberCopyError(const Token *tok, FunctionType functionType, const std::string& classname, const std::string& varname)
 {
-    reportError(tok, Severity::warning, isprivate ? "uninitMemberVarPrivate" : "uninitMemberVar", "$symbol:" + classname + "::" + varname + "\nMember variable '$symbol' is not initialized in the constructor.", CWE398, inconclusive);
+    const std::string ctor(functionType == FunctionType::eCopyConstructor ? "copy" : "move");
+    const std::string action(functionType == FunctionType::eCopyConstructor ? "copied?" : "moved?");
+    const std::string message =
+        "$symbol:" + classname + "::" + varname + "\n" +
+        "Member variable '$symbol' is not assigned in the " + ctor + " constructor. Should it be " + action;
+    reportError(tok, Severity::warning, "missingMemberCopy", message, CWE398, Certainty::inconclusive);
 }
 
 void CheckClass::operatorEqVarError(const Token *tok, const std::string &classname, const std::string &varname, bool inconclusive)
 {
-    reportError(tok, Severity::warning, "operatorEqVarError", "$symbol:" + classname + "::" + varname + "\nMember variable '$symbol' is not assigned a value in '" + classname + "::operator='.", CWE398, inconclusive);
+    reportError(tok, Severity::warning, "operatorEqVarError", "$symbol:" + classname + "::" + varname + "\nMember variable '$symbol' is not assigned a value in '" + classname + "::operator='.", CWE398, inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -936,14 +1162,22 @@ void CheckClass::operatorEqVarError(const Token *tok, const std::string &classna
 
 void CheckClass::initializationListUsage()
 {
-    if (!mSettings->isEnabled(Settings::PERFORMANCE))
+    if (!mSettings->severity.isEnabled(Severity::performance))
         return;
 
+    logChecker("CheckClass::initializationListUsage"); // performance
+
     for (const Scope *scope : mSymbolDatabase->functionScopes) {
         // Check every constructor
-        if (!scope->function || (!scope->function->isConstructor()))
+        if (!scope->function || !scope->function->isConstructor())
             continue;
 
+        // Do not warn when a delegate constructor is called
+        if (const Token *initList = scope->function->constructorMemberInitialization()) {
+            if (Token::Match(initList, ": %name% {|(") && initList->strAt(1) == scope->className)
+                continue;
+        }
+
         const Scope* owner = scope->functionOf;
         for (const Token* tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
             if (Token::Match(tok, "%name% (")) // Assignments might depend on this function call or if/for/while/switch statement from now on.
@@ -956,7 +1190,9 @@ void CheckClass::initializationListUsage()
             const Variable* var = tok->variable();
             if (!var || var->scope() != owner || var->isStatic())
                 continue;
-            if (var->isPointer() || var->isReference() || var->isEnumType() || var->valueType()->type > ValueType::Type::ITERATOR)
+            if (var->isPointer() || var->isReference() || var->isEnumType())
+                continue;
+            if (!WRONG_DATA(!var->valueType(), tok) && var->valueType()->type > ValueType::Type::ITERATOR)
                 continue;
 
             // bailout: multi line lambda in rhs => do not warn
@@ -966,7 +1202,7 @@ void CheckClass::initializationListUsage()
             // Access local var member in rhs => do not warn
             bool localmember = false;
             visitAstNodes(tok->next()->astOperand2(),
-            [&](const Token *rhs) {
+                          [&](const Token *rhs) {
                 if (rhs->str() == "." && rhs->astOperand1() && rhs->astOperand1()->variable() && rhs->astOperand1()->variable()->isLocal())
                     localmember = true;
                 return ChildrenToVisit::op1_and_op2;
@@ -976,13 +1212,18 @@ void CheckClass::initializationListUsage()
 
             bool allowed = true;
             visitAstNodes(tok->next()->astOperand2(),
-            [&](const Token *tok2) {
+                          [&](const Token *tok2) {
                 const Variable* var2 = tok2->variable();
                 if (var2) {
                     if (var2->scope() == owner && tok2->strAt(-1)!=".") { // Is there a dependency between two member variables?
                         allowed = false;
                         return ChildrenToVisit::done;
-                    } else if (var2->isArray() && var2->isLocal()) { // Can't initialize with a local array
+                    }
+                    if (var2->isArray() && var2->isLocal()) { // Can't initialize with a local array
+                        allowed = false;
+                        return ChildrenToVisit::done;
+                    }
+                    if (var2->isLocal() && isVariableChanged(var2->nameToken(), previousBeforeAstLeftmostLeaf(tok), var2->declarationId(), /*globalvar*/ false, *mSettings)) {
                         allowed = false;
                         return ChildrenToVisit::done;
                     }
@@ -1008,7 +1249,7 @@ void CheckClass::suggestInitializationList(const Token* tok, const std::string&
     reportError(tok, Severity::performance, "useInitializationList", "$symbol:" + varname + "\nVariable '$symbol' is assigned in constructor body. Consider performing initialization in initialization list.\n"
                 "When an object of a class is created, the constructors of all member variables are called consecutively "
                 "in the order the variables are declared, even if you don't explicitly write them to the initialization list. You "
-                "could avoid assigning '$symbol' a value by passing the value to the constructor in the initialization list.", CWE398, false);
+                "could avoid assigning '$symbol' a value by passing the value to the constructor in the initialization list.", CWE398, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -1020,7 +1261,7 @@ static bool checkFunctionUsage(const Function *privfunc, const Scope* scope)
     if (!scope)
         return true; // Assume it is used, if scope is not seen
 
-    for (std::list<Function>::const_iterator func = scope->functionList.begin(); func != scope->functionList.end(); ++func) {
+    for (auto func = scope->functionList.cbegin(); func != scope->functionList.cend(); ++func) {
         if (func->functionScope) {
             if (Token::Match(func->tokenDef, "%name% (")) {
                 for (const Token *ftok = func->tokenDef->tokAt(2); ftok && ftok->str() != ")"; ftok = ftok->next()) {
@@ -1036,22 +1277,22 @@ static bool checkFunctionUsage(const Function *privfunc, const Scope* scope)
                 if (ftok->varId() == 0U && ftok->str() == privfunc->name()) // TODO: This condition should be redundant
                     return true;
             }
-        } else if ((func->type != Function::eCopyConstructor &&
-                    func->type != Function::eOperatorEqual) ||
+        } else if ((func->type != FunctionType::eCopyConstructor &&
+                    func->type != FunctionType::eOperatorEqual &&
+                    !func->isDefault() && !func->isDelete()) ||
                    func->access != AccessControl::Private) // Assume it is used, if a function implementation isn't seen, but empty private copy constructors and assignment operators are OK
             return true;
     }
 
-    const std::map<std::string, Type*>::const_iterator end = scope->definedTypesMap.end();
-    for (std::map<std::string, Type*>::const_iterator iter = scope->definedTypesMap.begin(); iter != end; ++ iter) {
-        const Type *type = (*iter).second;
+    for (auto iter = scope->definedTypesMap.cbegin(); iter != scope->definedTypesMap.cend(); ++iter) {
+        const Type *type = iter->second;
         if (type->enclosingScope == scope && checkFunctionUsage(privfunc, type->classScope))
             return true;
     }
 
     for (const Variable &var : scope->varlist) {
         if (var.isStatic()) {
-            const Token* tok = Token::findmatch(scope->bodyEnd, "%varid% =|(|{", var.declarationId());
+            const Token* tok = Token::findmatch(scope->bodyStart, "%varid% =|(|{", var.declarationId());
             if (tok)
                 tok = tok->tokAt(2);
             while (tok && tok->str() != ";") {
@@ -1067,9 +1308,11 @@ static bool checkFunctionUsage(const Function *privfunc, const Scope* scope)
 
 void CheckClass::privateFunctions()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("unusedPrivateFunction"))
         return;
 
+    logChecker("CheckClass::privateFunctions"); // style
+
     for (const Scope * scope : mSymbolDatabase->classAndStructScopes) {
 
         // do not check borland classes with properties..
@@ -1079,44 +1322,56 @@ void CheckClass::privateFunctions()
         std::list<const Function*> privateFuncs;
         for (const Function &func : scope->functionList) {
             // Get private functions..
-            if (func.type == Function::eFunction && func.access == AccessControl::Private && !func.isOperator()) // TODO: There are smarter ways to check private operator usage
+            if (func.type == FunctionType::eFunction && func.access == AccessControl::Private && !func.isOperator()) // TODO: There are smarter ways to check private operator usage
                 privateFuncs.push_back(&func);
         }
 
         // Bailout for overridden virtual functions of base classes
         if (!scope->definedType->derivedFrom.empty()) {
             // Check virtual functions
-            for (std::list<const Function*>::iterator it = privateFuncs.begin(); it != privateFuncs.end();) {
+            for (auto it = privateFuncs.cbegin(); it != privateFuncs.cend();) {
                 if ((*it)->isImplicitlyVirtual(true)) // Give true as default value to be returned if we don't see all base classes
-                    privateFuncs.erase(it++);
+                    it = privateFuncs.erase(it);
                 else
                     ++it;
             }
         }
 
         while (!privateFuncs.empty()) {
+            const auto& pf = privateFuncs.front();
+            if (pf->token->isAttributeMaybeUnused() || pf->token->isAttributeUnused()) {
+                privateFuncs.pop_front();
+                continue;
+            }
+            if (pf->tokenDef && (pf->tokenDef->isAttributeMaybeUnused() || pf->tokenDef->isAttributeUnused())) {
+                privateFuncs.pop_front();
+                continue;
+            }
             // Check that all private functions are used
-            bool used = checkFunctionUsage(privateFuncs.front(), scope); // Usage in this class
+            bool used = checkFunctionUsage(pf, scope); // Usage in this class
             // Check in friend classes
             const std::vector<Type::FriendInfo>& friendList = scope->definedType->friendList;
-            for (int i = 0; i < friendList.size() && !used; i++) {
+            for (std::size_t i = 0; i < friendList.size() && !used; i++) {
                 if (friendList[i].type)
-                    used = checkFunctionUsage(privateFuncs.front(), friendList[i].type->classScope);
+                    used = checkFunctionUsage(pf, friendList[i].type->classScope);
                 else
                     used = true; // Assume, it is used if we do not see friend class
             }
 
             if (!used)
-                unusedPrivateFunctionError(privateFuncs.front()->tokenDef, scope->className, privateFuncs.front()->name());
+                unusedPrivateFunctionError(pf->token, pf->tokenDef, scope->className, pf->name());
 
             privateFuncs.pop_front();
         }
     }
 }
 
-void CheckClass::unusedPrivateFunctionError(const Token *tok, const std::string &classname, const std::string &funcname)
+void CheckClass::unusedPrivateFunctionError(const Token* tok1, const Token *tok2, const std::string &classname, const std::string &funcname)
 {
-    reportError(tok, Severity::style, "unusedPrivateFunction", "$symbol:" + classname + "::" + funcname + "\nUnused private function: '$symbol'", CWE398, false);
+    std::list<const Token *> toks{ tok1 };
+    if (tok2)
+        toks.push_front(tok2);
+    reportError(toks, Severity::style, "unusedPrivateFunction", "$symbol:" + classname + "::" + funcname + "\nUnused private function: '$symbol'", CWE398, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -1126,7 +1381,7 @@ void CheckClass::unusedPrivateFunctionError(const Token *tok, const std::string
 static const Scope* findFunctionOf(const Scope* scope)
 {
     while (scope) {
-        if (scope->type == Scope::eFunction)
+        if (scope->type == ScopeType::eFunction)
             return scope->functionOf;
         scope = scope->nestedIn;
     }
@@ -1135,7 +1390,8 @@ static const Scope* findFunctionOf(const Scope* scope)
 
 void CheckClass::checkMemset()
 {
-    const bool printWarnings = mSettings->isEnabled(Settings::WARNING);
+    logChecker("CheckClass::checkMemset");
+    const bool printWarnings = mSettings->severity.isEnabled(Severity::warning);
     for (const Scope *scope : mSymbolDatabase->functionScopes) {
         for (const Token *tok = scope->bodyStart; tok && tok != scope->bodyEnd; tok = tok->next()) {
             if (Token::Match(tok, "memset|memcpy|memmove (")) {
@@ -1150,14 +1406,21 @@ void CheckClass::checkMemset()
 
                 const Token *typeTok = nullptr;
                 const Scope *type = nullptr;
-                if (Token::Match(arg3, "sizeof ( %type% ) )"))
-                    typeTok = arg3->tokAt(2);
-                else if (Token::Match(arg3, "sizeof ( %type% :: %type% ) )"))
-                    typeTok = arg3->tokAt(4);
-                else if (Token::Match(arg3, "sizeof ( struct %type% ) )"))
-                    typeTok = arg3->tokAt(3);
-                else if (Token::simpleMatch(arg3, "sizeof ( * this ) )") || Token::simpleMatch(arg1, "this ,")) {
-                    type = findFunctionOf(arg3->scope());
+                const Token* sizeofTok = arg3->previous()->astOperand2(); // try to find sizeof() in argument expression
+                if (sizeofTok && sizeofTok->astOperand1() && Token::simpleMatch(sizeofTok->astOperand1()->previous(), "sizeof ("))
+                    sizeofTok = sizeofTok->astOperand1();
+                else if (sizeofTok && sizeofTok->astOperand2() && Token::simpleMatch(sizeofTok->astOperand2()->previous(), "sizeof ("))
+                    sizeofTok = sizeofTok->astOperand2();
+                if (Token::simpleMatch(sizeofTok, "("))
+                    sizeofTok = sizeofTok->previous();
+                if (Token::Match(sizeofTok, "sizeof ( %type% )"))
+                    typeTok = sizeofTok->tokAt(2);
+                else if (Token::Match(sizeofTok, "sizeof ( %type% :: %type% )"))
+                    typeTok = sizeofTok->tokAt(4);
+                else if (Token::Match(sizeofTok, "sizeof ( struct %type% )"))
+                    typeTok = sizeofTok->tokAt(3);
+                else if (Token::simpleMatch(sizeofTok, "sizeof ( * this )") || Token::simpleMatch(arg1, "this ,")) {
+                    type = findFunctionOf(sizeofTok->scope());
                 } else if (Token::Match(arg1, "&|*|%var%")) {
                     int numIndirToVariableType = 0; // Offset to the actual type in terms of dereference/addressof
                     for (;; arg1 = arg1->next()) {
@@ -1184,6 +1447,11 @@ void CheckClass::checkMemset()
 
                         if (numIndirToVariableType == 1)
                             type = var->typeScope();
+
+                        if (!type && !var->isPointer() && !Token::simpleMatch(var->typeStartToken(), "std :: array") &&
+                            mSettings->library.detectContainerOrIterator(var->typeStartToken())) {
+                            memsetError(tok, tok->str(), var->getTypeName(), {}, /*isContainer*/ true);
+                        }
                     }
                 }
 
@@ -1198,12 +1466,16 @@ void CheckClass::checkMemset()
                     type = typeTok->type()->classScope;
 
                 if (type) {
-                    const std::set<const Scope *> parsedTypes;
-                    checkMemsetType(scope, tok, type, false, parsedTypes);
+                    checkMemsetType(scope, tok, type, false, {});
                 }
-            } else if (tok->variable() && tok->variable()->typeScope() && Token::Match(tok, "%var% = calloc|malloc|realloc|g_malloc|g_try_malloc|g_realloc|g_try_realloc (")) {
-                const std::set<const Scope *> parsedTypes;
-                checkMemsetType(scope, tok->tokAt(2), tok->variable()->typeScope(), true, parsedTypes);
+            } else if (tok->variable() && tok->variable()->isPointer() && tok->variable()->typeScope() && Token::Match(tok, "%var% = %name% (")) {
+                const Library::AllocFunc* alloc = mSettings->library.getAllocFuncInfo(tok->tokAt(2));
+                if (!alloc)
+                    alloc = mSettings->library.getReallocFuncInfo(tok->tokAt(2));
+                if (!alloc || alloc->bufferSize == Library::AllocFunc::BufferSize::none)
+                    continue;
+                std::set<const Scope *> parsedTypes;
+                checkMemsetType(scope, tok->tokAt(2), tok->variable()->typeScope(), true, std::move(parsedTypes));
 
                 if (printWarnings && tok->variable()->typeScope()->numConstructors > 0)
                     mallocOnClassWarning(tok, tok->strAt(2), tok->variable()->typeScope()->classDef);
@@ -1219,7 +1491,7 @@ void CheckClass::checkMemsetType(const Scope *start, const Token *tok, const Sco
         return;
     parsedTypes.insert(type);
 
-    const bool printPortability = mSettings->isEnabled(Settings::PORTABILITY);
+    const bool printPortability = mSettings->severity.isEnabled(Severity::portability);
 
     // recursively check all parent classes
     for (const Type::BaseInfo & i : type->definedType->derivedFrom) {
@@ -1285,7 +1557,7 @@ void CheckClass::mallocOnClassWarning(const Token* tok, const std::string &memfu
                 "$symbol:" + memfunc +"\n"
                 "Memory for class instance allocated with $symbol(), but class provides constructors.\n"
                 "Memory for class instance allocated with $symbol(), but class provides constructors. This is unsafe, "
-                "since no constructor is called and class members remain uninitialized. Consider using 'new' instead.", CWE762, false);
+                "since no constructor is called and class members remain uninitialized. Consider using 'new' instead.", CWE762, Certainty::normal);
 }
 
 void CheckClass::mallocOnClassError(const Token* tok, const std::string &memfunc, const Token* classTok, const std::string &classname)
@@ -1296,25 +1568,26 @@ void CheckClass::mallocOnClassError(const Token* tok, const std::string &memfunc
                 "$symbol:" + classname +"\n"
                 "Memory for class instance allocated with " + memfunc + "(), but class contains a " + classname + ".\n"
                 "Memory for class instance allocated with " + memfunc + "(), but class a " + classname + ". This is unsafe, "
-                "since no constructor is called and class members remain uninitialized. Consider using 'new' instead.", CWE665, false);
+                "since no constructor is called and class members remain uninitialized. Consider using 'new' instead.", CWE665, Certainty::normal);
 }
 
-void CheckClass::memsetError(const Token *tok, const std::string &memfunc, const std::string &classname, const std::string &type)
+void CheckClass::memsetError(const Token *tok, const std::string &memfunc, const std::string &classname, const std::string &type, bool isContainer)
 {
-    reportError(tok, Severity::error, "memsetClass",
-                "$symbol:" + memfunc +"\n"
-                "$symbol:" + classname +"\n"
-                "Using '" + memfunc + "' on " + type + " that contains a " + classname + ".\n"
-                "Using '" + memfunc + "' on " + type + " that contains a " + classname + " is unsafe, because constructor, destructor "
-                "and copy operator calls are omitted. These are necessary for this non-POD type to ensure that a valid object "
-                "is created.", CWE762, false);
+    const std::string typeStr = isContainer ? std::string() : (type + " that contains a ");
+    const std::string msg = "$symbol:" + memfunc + "\n"
+                            "$symbol:" + classname + "\n"
+                            "Using '" + memfunc + "' on " + typeStr + classname + ".\n"
+                            "Using '" + memfunc + "' on " + typeStr + classname + " is unsafe, because constructor, destructor "
+                            "and copy operator calls are omitted. These are necessary for this non-POD type to ensure that a valid object "
+                            "is created.";
+    reportError(tok, Severity::error, "memsetClass", msg, CWE762, Certainty::normal);
 }
 
 void CheckClass::memsetErrorReference(const Token *tok, const std::string &memfunc, const std::string &type)
 {
     reportError(tok, Severity::error, "memsetClassReference",
                 "$symbol:" + memfunc +"\n"
-                "Using '" + memfunc + "' on " + type + " that contains a reference.", CWE665, false);
+                "Using '" + memfunc + "' on " + type + " that contains a reference.", CWE665, Certainty::normal);
 }
 
 void CheckClass::memsetErrorFloat(const Token *tok, const std::string &type)
@@ -1323,61 +1596,9 @@ void CheckClass::memsetErrorFloat(const Token *tok, const std::string &type)
                 "Using memset() on " + type + " which contains a floating point number."
                 " This is not portable because memset() sets each byte of a block of memory to a specific value and"
                 " the actual representation of a floating-point value is implementation defined."
-                " Note: In case of an IEEE754-1985 compatible implementation setting all bits to zero results in the value 0.0.", CWE758, false);
-}
-
-
-//---------------------------------------------------------------------------
-// ClassCheck: "void operator=(" and "const type & operator=("
-//---------------------------------------------------------------------------
-
-void CheckClass::operatorEq()
-{
-    if (!mSettings->isEnabled(Settings::STYLE))
-        return;
-
-    for (const Scope * scope : mSymbolDatabase->classAndStructScopes) {
-        for (std::list<Function>::const_iterator func = scope->functionList.begin(); func != scope->functionList.end(); ++func) {
-            if (func->type == Function::eOperatorEqual && func->access == AccessControl::Public) {
-                // skip "deleted" functions - cannot be called anyway
-                if (func->isDelete())
-                    continue;
-                // use definition for check so we don't have to deal with qualification
-                bool returnSelfRef = false;
-                if (func->retDef->str() == scope->className) {
-                    if (Token::Match(func->retDef, "%type% &")) {
-                        returnSelfRef = true;
-                    } else {
-                        // We might have "Self<template_parameters>&""
-                        const Token * const tok = func->retDef->next();
-                        if (tok && tok->str() == "<" && tok->link() && tok->link()->next() && tok->link()->next()->str() == "&")
-                            returnSelfRef = true;
-                    }
-                }
-                if (!returnSelfRef) {
-                    // make sure we really have a copy assignment operator
-                    const Token *paramTok = func->tokenDef->tokAt(2);
-                    if (Token::Match(paramTok, "const| %name% &")) {
-                        if (paramTok->str() == "const" &&
-                            paramTok->strAt(1) == scope->className)
-                            operatorEqReturnError(func->retDef, scope->className);
-                        else if (paramTok->str() == scope->className)
-                            operatorEqReturnError(func->retDef, scope->className);
-                    }
-                }
-            }
-        }
-    }
+                " Note: In case of an IEEE754-1985 compatible implementation setting all bits to zero results in the value 0.0.", CWE758, Certainty::normal);
 }
 
-void CheckClass::operatorEqReturnError(const Token *tok, const std::string &className)
-{
-    reportError(tok, Severity::style, "operatorEq",
-                "$symbol:" + className +"\n"
-                "'$symbol::operator=' should return '$symbol &'.\n"
-                "The $symbol::operator= does not conform to standard C/C++ behaviour. To conform to standard C/C++ behaviour, return a reference to self (such as: '$symbol &$symbol::operator=(..) { .. return *this; }'. For safety reasons it might be better to not fix this message. If you think that safety is always more important than conformance then please ignore/suppress this message. For more details about this topic, see the book \"Effective C++\" by Scott Meyers."
-                , CWE398, false);
-}
 
 //---------------------------------------------------------------------------
 // ClassCheck: "C& operator=(const C&) { ... return *this; }"
@@ -1386,12 +1607,14 @@ void CheckClass::operatorEqReturnError(const Token *tok, const std::string &clas
 
 void CheckClass::operatorEqRetRefThis()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("operatorEqRetRefThis"))
         return;
 
+    logChecker("CheckClass::operatorEqRetRefThis"); // style
+
     for (const Scope * scope : mSymbolDatabase->classAndStructScopes) {
-        for (std::list<Function>::const_iterator func = scope->functionList.begin(); func != scope->functionList.end(); ++func) {
-            if (func->type == Function::eOperatorEqual && func->hasBody()) {
+        for (auto func = scope->functionList.cbegin(); func != scope->functionList.cend(); ++func) {
+            if (func->type == FunctionType::eOperatorEqual && func->hasBody()) {
                 // make sure return signature is correct
                 if (func->retType == func->nestedIn->definedType && func->tokenDef->strAt(-1) == "&") {
                     checkReturnPtrThis(scope, &(*func), func->functionScope->bodyStart, func->functionScope->bodyEnd);
@@ -1415,6 +1638,10 @@ void CheckClass::checkReturnPtrThis(const Scope *scope, const Function *func, co
 
     for (; tok && tok != last; tok = tok->next()) {
         // check for return of reference to this
+
+        if (const Token* lScope = isLambdaCaptureList(tok)) // skip lambda
+            tok = lScope->link();
+
         if (tok->str() != "return")
             continue;
 
@@ -1427,19 +1654,19 @@ void CheckClass::checkReturnPtrThis(const Scope *scope, const Function *func, co
             continue;
 
         std::string cast("( " + scope->className + " & )");
-        if (Token::simpleMatch(tok->next(), cast.c_str()))
+        if (Token::simpleMatch(tok->next(), cast.c_str(), cast.size()))
             tok = tok->tokAt(4);
 
         // check if a function is called
         if (tok->strAt(2) == "(" &&
-            tok->linkAt(2)->next()->str() == ";") {
+            tok->linkAt(2)->strAt(1) == ";") {
             // check if it is a member function
-            for (std::list<Function>::const_iterator it = scope->functionList.begin(); it != scope->functionList.end(); ++it) {
+            for (auto it = scope->functionList.cbegin(); it != scope->functionList.cend(); ++it) {
                 // check for a regular function with the same name and a body
-                if (it->type == Function::eFunction && it->hasBody() &&
-                    it->token->str() == tok->next()->str()) {
+                if (it->type == FunctionType::eFunction && it->hasBody() &&
+                    it->token->str() == tok->strAt(1)) {
                     // check for the proper return type
-                    if (it->tokenDef->previous()->str() == "&" &&
+                    if (it->tokenDef->strAt(-1) == "&" &&
                         it->tokenDef->strAt(-2) == scope->className) {
                         // make sure it's not a const function
                         if (!it->isConst()) {
@@ -1447,7 +1674,7 @@ void CheckClass::checkReturnPtrThis(const Scope *scope, const Function *func, co
                             // avoid endless recursions
                             if (analyzedFunctions.find(&*it) == analyzedFunctions.end()) {
                                 analyzedFunctions.insert(&*it);
-                                checkReturnPtrThis(scope, &*it, it->arg->link()->next(), it->arg->link()->next()->link(),
+                                checkReturnPtrThis(scope, &*it, it->arg->link()->next(), it->arg->link()->linkAt(1),
                                                    analyzedFunctions);
                             }
                             // just bail for now
@@ -1463,14 +1690,15 @@ void CheckClass::checkReturnPtrThis(const Scope *scope, const Function *func, co
         else if (!(Token::simpleMatch(tok->next(), "operator= (") ||
                    Token::simpleMatch(tok->next(), "this . operator= (") ||
                    (Token::Match(tok->next(), "%type% :: operator= (") &&
-                    tok->next()->str() == scope->className)))
+                    tok->strAt(1) == scope->className)))
             operatorEqRetRefThisError(func->token);
     }
     if (foundReturn) {
         return;
     }
     if (startTok->next() == last) {
-        if (Token::simpleMatch(func->argDef, std::string("( const " + scope->className + " &").c_str())) {
+        const std::string tmp("( const " + scope->className + " &");
+        if (Token::simpleMatch(func->argDef, tmp.c_str(), tmp.size())) {
             // Typical wrong way to suppress default assignment operator by declaring it and leaving empty
             operatorEqMissingReturnStatementError(func->token, func->access == AccessControl::Public);
         } else {
@@ -1490,18 +1718,18 @@ void CheckClass::checkReturnPtrThis(const Scope *scope, const Function *func, co
 
 void CheckClass::operatorEqRetRefThisError(const Token *tok)
 {
-    reportError(tok, Severity::style, "operatorEqRetRefThis", "'operator=' should return reference to 'this' instance.", CWE398, false);
+    reportError(tok, Severity::style, "operatorEqRetRefThis", "'operator=' should return reference to 'this' instance.", CWE398, Certainty::normal);
 }
 
 void CheckClass::operatorEqShouldBeLeftUnimplementedError(const Token *tok)
 {
-    reportError(tok, Severity::style, "operatorEqShouldBeLeftUnimplemented", "'operator=' should either return reference to 'this' instance or be declared private and left unimplemented.", CWE398, false);
+    reportError(tok, Severity::style, "operatorEqShouldBeLeftUnimplemented", "'operator=' should either return reference to 'this' instance or be declared private and left unimplemented.", CWE398, Certainty::normal);
 }
 
 void CheckClass::operatorEqMissingReturnStatementError(const Token *tok, bool error)
 {
     if (error) {
-        reportError(tok, Severity::error, "operatorEqMissingReturnStatement", "No 'return' statement in non-void function causes undefined behavior.", CWE398, false);
+        reportError(tok, Severity::error, "operatorEqMissingReturnStatement", "No 'return' statement in non-void function causes undefined behavior.", CWE398, Certainty::normal);
     } else {
         operatorEqRetRefThisError(tok);
     }
@@ -1523,16 +1751,18 @@ void CheckClass::operatorEqMissingReturnStatementError(const Token *tok, bool er
 
 void CheckClass::operatorEqToSelf()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning) && !mSettings->isPremiumEnabled("operatorEqToSelf"))
         return;
 
+    logChecker("CheckClass::operatorEqToSelf"); // warning
+
     for (const Scope * scope : mSymbolDatabase->classAndStructScopes) {
         // skip classes with multiple inheritance
         if (scope->definedType->derivedFrom.size() > 1)
             continue;
 
         for (const Function &func : scope->functionList) {
-            if (func.type == Function::eOperatorEqual && func.hasBody()) {
+            if (func.type == FunctionType::eOperatorEqual && func.hasBody()) {
                 // make sure that the operator takes an object of the same type as *this, otherwise we can't detect self-assignment checks
                 if (func.argumentList.empty())
                     continue;
@@ -1545,11 +1775,14 @@ void CheckClass::operatorEqToSelf()
                 // make sure return signature is correct
                 if (Token::Match(func.retDef, "%type% &") && func.retDef->str() == scope->className) {
                     // find the parameter name
-                    const Token *rhs = func.argumentList.begin()->nameToken();
-
-                    if (!hasAssignSelf(&func, rhs)) {
+                    const Token *rhs = func.argumentList.cbegin()->nameToken();
+                    const Token* out_ifStatementScopeStart = nullptr;
+                    if (!hasAssignSelf(&func, rhs, out_ifStatementScopeStart)) {
                         if (hasAllocation(&func, scope))
                             operatorEqToSelfError(func.token);
+                    } else if (out_ifStatementScopeStart != nullptr) {
+                        if (hasAllocationInIfScope(&func, scope, out_ifStatementScopeStart))
+                            operatorEqToSelfError(func.token);
                     }
                 }
             }
@@ -1557,32 +1790,44 @@ void CheckClass::operatorEqToSelf()
     }
 }
 
+bool CheckClass::hasAllocationInIfScope(const Function *func, const Scope* scope, const Token *ifStatementScopeStart) const
+{
+    const Token *end;
+    if (ifStatementScopeStart->str() == "{")
+        end = ifStatementScopeStart->link();
+    else
+        end = func->functionScope->bodyEnd;
+    return hasAllocation(func, scope, ifStatementScopeStart, end);
+}
+
 bool CheckClass::hasAllocation(const Function *func, const Scope* scope) const
 {
-    // This function is called when no simple check was found for assignment
-    // to self.  We are currently looking for:
-    //    - deallocate member ; ... member =
-    //    - alloc member
-    // That is not ideal because it can cause false negatives but its currently
-    // necessary to prevent false positives.
-    const Token *last = func->functionScope->bodyEnd;
-    for (const Token *tok = func->functionScope->bodyStart; tok && (tok != last); tok = tok->next()) {
-        if (Token::Match(tok, "%var% = malloc|realloc|calloc|new") && isMemberVar(scope, tok))
+    return hasAllocation(func, scope, func->functionScope->bodyStart, func->functionScope->bodyEnd);
+}
+
+bool CheckClass::hasAllocation(const Function *func, const Scope* scope, const Token *start, const Token *end) const
+{
+    if (!end)
+        end = func->functionScope->bodyEnd;
+    for (const Token *tok = start; tok && (tok != end); tok = tok->next()) {
+        if (((tok->isCpp() && Token::Match(tok, "%var% = new")) ||
+             (Token::Match(tok, "%var% = %name% (") && mSettings->library.getAllocFuncInfo(tok->tokAt(2)))) &&
+            isMemberVar(scope, tok))
             return true;
 
         // check for deallocating memory
         const Token *var;
-        if (Token::Match(tok, "free ( %var%"))
+        if (Token::Match(tok, "%name% ( %var%") && mSettings->library.getDeallocFuncInfo(tok))
             var = tok->tokAt(2);
-        else if (Token::Match(tok, "delete [ ] %var%"))
+        else if (tok->isCpp() && Token::Match(tok, "delete [ ] %var%"))
             var = tok->tokAt(3);
-        else if (Token::Match(tok, "delete %var%"))
+        else if (tok->isCpp() && Token::Match(tok, "delete %var%"))
             var = tok->next();
         else
             continue;
         // Check for assignment to the deleted pointer (only if its a member of the class)
         if (isMemberVar(scope, var)) {
-            for (const Token *tok1 = var->next(); tok1 && (tok1 != last); tok1 = tok1->next()) {
+            for (const Token *tok1 = var->next(); tok1 && (tok1 != end); tok1 = tok1->next()) {
                 if (Token::Match(tok1, "%varid% =", var->varId()))
                     return true;
             }
@@ -1592,7 +1837,66 @@ bool CheckClass::hasAllocation(const Function *func, const Scope* scope) const
     return false;
 }
 
-bool CheckClass::hasAssignSelf(const Function *func, const Token *rhs)
+static bool isTrueKeyword(const Token* tok)
+{
+    return tok->hasKnownIntValue() && tok->getKnownIntValue() == 1;
+}
+
+static bool isFalseKeyword(const Token* tok)
+{
+    return tok->hasKnownIntValue() && tok->getKnownIntValue() == 0;
+}
+
+/*
+ * Checks if self-assignment test is inverse
+ * For example 'if (this == &rhs)'
+ */
+CheckClass::Bool CheckClass::isInverted(const Token *tok, const Token *rhs)
+{
+    bool res = true;
+    for (const Token *itr = tok; itr && itr->str()!="("; itr=itr->astParent()) {
+        if (Token::simpleMatch(itr, "!=") && (isTrueKeyword(itr->astOperand1()) || isTrueKeyword(itr->astOperand2()))) {
+            res = !res;
+        } else if (Token::simpleMatch(itr, "!=") && ((Token::simpleMatch(itr->astOperand1(), "this") && Token::simpleMatch(itr->astOperand2(), "&") && Token::simpleMatch(itr->astOperand2()->next(), rhs->str().c_str(), rhs->str().size()))
+                                                     || (Token::simpleMatch(itr->astOperand2(), "this") && Token::simpleMatch(itr->astOperand1(), "&") && Token::simpleMatch(itr->astOperand1()->next(), rhs->str().c_str(), rhs->str().size())))) {
+            res = !res;
+        } else if (Token::simpleMatch(itr, "!=") && (isFalseKeyword(itr->astOperand1()) || isFalseKeyword(itr->astOperand2()))) {
+            //Do nothing
+        } else if (Token::simpleMatch(itr, "!")) {
+            res = !res;
+        } else if (Token::simpleMatch(itr, "==") && (isFalseKeyword(itr->astOperand1()) || isFalseKeyword(itr->astOperand2()))) {
+            res = !res;
+        } else if (Token::simpleMatch(itr, "==") && (isTrueKeyword(itr->astOperand1()) || isTrueKeyword(itr->astOperand2()))) {
+            //Do nothing
+        } else if (Token::simpleMatch(itr, "==") && ((Token::simpleMatch(itr->astOperand1(), "this") && Token::simpleMatch(itr->astOperand2(), "&") && Token::simpleMatch(itr->astOperand2()->next(), rhs->str().c_str(), rhs->str().size()))
+                                                     || (Token::simpleMatch(itr->astOperand2(), "this") && Token::simpleMatch(itr->astOperand1(), "&") && Token::simpleMatch(itr->astOperand1()->next(), rhs->str().c_str(), rhs->str().size())))) {
+            //Do nothing
+        } else {
+            return Bool::Bailout;
+        }
+    }
+    if (res)
+        return Bool::True;
+    return Bool::False;
+}
+
+const Token * CheckClass::getIfStmtBodyStart(const Token *tok, const Token *rhs)
+{
+    const Token *top = tok->astTop();
+    if (Token::simpleMatch(top->link(), ") {")) {
+        switch (isInverted(tok->astParent(), rhs)) {
+        case Bool::Bailout:
+            return nullptr;
+        case Bool::True:
+            return top->link()->next();
+        case Bool::False:
+            return top->link()->linkAt(1);
+        }
+    }
+    return nullptr;
+}
+
+bool CheckClass::hasAssignSelf(const Function *func, const Token *rhs, const Token *&out_ifStatementScopeStart)
 {
     if (!rhs)
         return false;
@@ -1603,7 +1907,7 @@ bool CheckClass::hasAssignSelf(const Function *func, const Token *rhs)
 
         bool ret = false;
         visitAstNodes(tok->next()->astOperand2(),
-        [&](const Token *tok2) {
+                      [&](const Token *tok2) {
             if (!Token::Match(tok2, "==|!="))
                 return ChildrenToVisit::op1_and_op2;
             if (Token::simpleMatch(tok2->astOperand1(), "this"))
@@ -1614,6 +1918,9 @@ bool CheckClass::hasAssignSelf(const Function *func, const Token *rhs)
                 return ChildrenToVisit::op1_and_op2;
             if (tok2 && tok2->isUnaryOp("&") && tok2->astOperand1()->str() == rhs->str())
                 ret = true;
+            if (ret) {
+                out_ifStatementScopeStart = getIfStmtBodyStart(tok2, rhs);
+            }
             return ret ? ChildrenToVisit::done : ChildrenToVisit::op1_and_op2;
         });
         if (ret)
@@ -1628,7 +1935,7 @@ void CheckClass::operatorEqToSelfError(const Token *tok)
     reportError(tok, Severity::warning, "operatorEqToSelf",
                 "'operator=' should check for assignment to self to avoid problems with dynamic memory.\n"
                 "'operator=' should check for assignment to self to ensure that each block of dynamically "
-                "allocated memory is owned and managed by only one instance of the class.", CWE398, false);
+                "allocated memory is owned and managed by only one instance of the class.", CWE398, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -1642,24 +1949,24 @@ void CheckClass::virtualDestructor()
     // * derived class has non-empty destructor (only c++03, in c++11 it's UB see paragraph 3 in [expr.delete])
     // * base class is deleted
     // unless inconclusive in which case:
-    // * base class has virtual members but doesn't have virtual destructor
-    const bool printInconclusive = mSettings->inconclusive;
+    // * A class with any virtual functions should have a destructor that is either public and virtual or protected
+    const bool printInconclusive = mSettings->certainty.isEnabled(Certainty::inconclusive);
 
     std::list<const Function *> inconclusiveErrors;
 
+    logChecker("CheckClass::virtualDestructor");
+
     for (const Scope * scope : mSymbolDatabase->classAndStructScopes) {
 
         // Skip base classes (unless inconclusive)
         if (scope->definedType->derivedFrom.empty()) {
             if (printInconclusive) {
                 const Function *destructor = scope->getDestructor();
-                if (destructor && !destructor->hasVirtualSpecifier()) {
-                    for (const Function &func : scope->functionList) {
-                        if (func.hasVirtualSpecifier()) {
-                            inconclusiveErrors.push_back(destructor);
-                            break;
-                        }
-                    }
+                if (destructor && !destructor->hasVirtualSpecifier() && destructor->access == AccessControl::Public) {
+                    if (std::any_of(scope->functionList.cbegin(), scope->functionList.cend(), [](const Function& func) {
+                        return func.hasVirtualSpecifier();
+                    }))
+                        inconclusiveErrors.push_back(destructor);
                 }
             }
             continue;
@@ -1715,7 +2022,8 @@ void CheckClass::virtualDestructor()
                         if (Token::Match(tok, "[;{}] %var% =") &&
                             baseClassPointers.find(tok->next()->varId()) != baseClassPointers.end()) {
                             // new derived class..
-                            if (Token::simpleMatch(tok->tokAt(3), ("new " + derivedClass->str()).c_str())) {
+                            const std::string tmp("new " + derivedClass->str());
+                            if (Token::simpleMatch(tok->tokAt(3), tmp.c_str(), tmp.size())) {
                                 dontDelete.insert(tok->next()->varId());
                             }
                         }
@@ -1755,8 +2063,8 @@ void CheckClass::virtualDestructor()
                         if (baseDestructor->access == AccessControl::Public) {
                             virtualDestructorError(baseDestructor->token, derivedFrom->name(), derivedClass->str(), false);
                             // check for duplicate error and remove it if found
-                            const std::list<const Function *>::iterator found = find(inconclusiveErrors.begin(), inconclusiveErrors.end(), baseDestructor);
-                            if (found != inconclusiveErrors.end())
+                            const auto found = std::find(inconclusiveErrors.cbegin(), inconclusiveErrors.cend(), baseDestructor);
+                            if (found != inconclusiveErrors.cend())
                                 inconclusiveErrors.erase(found);
                         }
                     }
@@ -1766,14 +2074,14 @@ void CheckClass::virtualDestructor()
     }
 
     for (const Function *func : inconclusiveErrors)
-        virtualDestructorError(func->tokenDef, func->name(), emptyString, true);
+        virtualDestructorError(func->tokenDef, func->name(), "", true);
 }
 
 void CheckClass::virtualDestructorError(const Token *tok, const std::string &Base, const std::string &Derived, bool inconclusive)
 {
     if (inconclusive) {
-        if (mSettings->isEnabled(Settings::WARNING))
-            reportError(tok, Severity::warning, "virtualDestructor", "$symbol:" + Base + "\nClass '$symbol' which has virtual members does not have a virtual destructor.", CWE404, true);
+        if (mSettings->severity.isEnabled(Severity::warning))
+            reportError(tok, Severity::warning, "virtualDestructor", "$symbol:" + Base + "\nClass '$symbol' which has virtual members does not have a virtual destructor.", CWE404, Certainty::inconclusive);
     } else {
         reportError(tok, Severity::error, "virtualDestructor",
                     "$symbol:" + Base +"\n"
@@ -1782,7 +2090,7 @@ void CheckClass::virtualDestructorError(const Token *tok, const std::string &Bas
                     "Class '" + Base + "' which is inherited by class '" + Derived + "' does not have a virtual destructor. "
                     "If you destroy instances of the derived class by deleting a pointer that points to the base class, only "
                     "the destructor of the base class is executed. Thus, dynamic memory that is managed by the derived class "
-                    "could leak. This can be avoided by adding a virtual destructor to the base class.", CWE404, false);
+                    "could leak. This can be avoided by adding a virtual destructor to the base class.", CWE404, Certainty::normal);
     }
 }
 
@@ -1792,9 +2100,11 @@ void CheckClass::virtualDestructorError(const Token *tok, const std::string &Bas
 
 void CheckClass::thisSubtraction()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckClass::thisSubtraction"); // warning
+
     const Token *tok = mTokenizer->tokens();
     for (;;) {
         tok = Token::findmatch(tok, "this - %name%");
@@ -1810,7 +2120,7 @@ void CheckClass::thisSubtraction()
 
 void CheckClass::thisSubtractionError(const Token *tok)
 {
-    reportError(tok, Severity::warning, "thisSubtraction", "Suspicious pointer subtraction. Did you intend to write '->'?", CWE398, false);
+    reportError(tok, Severity::warning, "thisSubtraction", "Suspicious pointer subtraction. Did you intend to write '->'?", CWE398, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -1819,43 +2129,66 @@ void CheckClass::thisSubtractionError(const Token *tok)
 
 void CheckClass::checkConst()
 {
-    // This is an inconclusive check. False positives: #3322.
-    if (!mSettings->inconclusive)
+    if (!mSettings->severity.isEnabled(Severity::style) &&
+        !mSettings->isPremiumEnabled("functionConst") &&
+        !mSettings->isPremiumEnabled("functionStatic"))
         return;
 
-    if (!mSettings->isEnabled(Settings::STYLE))
-        return;
+    logChecker("CheckClass::checkConst"); // style,inconclusive
 
     for (const Scope * scope : mSymbolDatabase->classAndStructScopes) {
         for (const Function &func : scope->functionList) {
             // does the function have a body?
-            if (func.type != Function::eFunction || !func.hasBody())
+            if (func.type != FunctionType::eFunction || !func.hasBody())
                 continue;
             // don't warn for friend/static/virtual functions
             if (func.isFriend() || func.isStatic() || func.hasVirtualSpecifier())
                 continue;
-            // get last token of return type
-            const Token *previous = func.tokenDef->previous();
+            if (func.functionPointerUsage)
+                continue;
+            if (func.hasRvalRefQualifier())
+                continue;
 
-            // does the function return a pointer or reference?
-            if (Token::Match(previous, "*|&")) {
-                if (func.retDef->str() != "const")
-                    continue;
-            } else if (Token::Match(previous->previous(), "*|& >")) {
-                const Token *temp = previous->previous();
-
-                bool foundConst = false;
-                while (!Token::Match(temp->previous(), ";|}|{|public:|protected:|private:")) {
-                    temp = temp->previous();
-                    if (temp->str() == "const") {
-                        foundConst = true;
-                        break;
+            // don't suggest const when returning non-const pointer/reference, but still suggest static
+            auto isPointerOrReference = [this](const Token* start, const Token* end) -> bool {
+                bool inTemplArgList = false, isConstTemplArg = false;
+                for (const Token* tok = start; tok != end; tok = tok->next()) {
+                    if (tok->str() == "{") // end of trailing return type
+                        return false;
+                    if (tok->str() == "<") {
+                        if (!tok->link())
+                            mSymbolDatabase->debugMessage(tok, "debug", "CheckClass::checkConst found unlinked template argument list '" + tok->expressionString() + "'.");
+                        inTemplArgList = true;
                     }
+                    else if (tok->str() == ">") {
+                        inTemplArgList = false;
+                        isConstTemplArg = false;
+                    }
+                    else if (tok->str() == "const") {
+                        if (!inTemplArgList)
+                            return false;
+                        isConstTemplArg = true;
+                    }
+                    else if (!isConstTemplArg && Token::Match(tok, "*|&"))
+                        return true;
                 }
+                return false;
+            };
+
+            const bool returnsPtrOrRef = isPointerOrReference(func.retDef, func.tokenDef);
 
-                if (!foundConst)
+            if (Function::returnsPointer(&func, /*unknown*/ true) || Function::returnsReference(&func, /*unknown*/ true, /*includeRValueRef*/ true)) { // returns const/non-const depending on template arg
+                bool isTemplateArg = false;
+                for (const Token* tok2 = func.retDef; precedes(tok2, func.token); tok2 = tok2->next())
+                    if (tok2->isTemplateArg() && tok2->str() == "const") {
+                        isTemplateArg = true;
+                        break;
+                    }
+                if (isTemplateArg)
                     continue;
-            } else if (func.isOperator() && Token::Match(previous, ";|{|}|public:|private:|protected:")) { // Operator without return type: conversion operator
+            }
+
+            if (func.isOperator()) { // Operator without return type: conversion operator
                 const std::string& opName = func.tokenDef->str();
                 if (opName.compare(8, 5, "const") != 0 && (endsWith(opName,'&') || endsWith(opName,'*')))
                     continue;
@@ -1865,26 +2198,42 @@ void CheckClass::checkConst()
             } else {
                 // don't warn for unknown types..
                 // LPVOID, HDC, etc
-                if (previous->str().size() > 2 && !previous->type() && previous->isUpperCaseName())
+                if (func.retDef->str().size() > 2 && !func.retDef->type() && func.retDef->isUpperCaseName())
                     continue;
             }
 
             // check if base class function is virtual
-            if (!scope->definedType->derivedFrom.empty() && func.isImplicitlyVirtual(true))
+            bool foundAllBaseClasses = true;
+            if (!scope->definedType->derivedFrom.empty() && func.isImplicitlyVirtual(true, &foundAllBaseClasses) && foundAllBaseClasses)
                 continue;
 
-            bool memberAccessed = false;
+            MemberAccess memberAccessed = MemberAccess::NONE;
             // if nothing non-const was found. write error..
             if (!checkConstFunc(scope, &func, memberAccessed))
                 continue;
 
-            if (func.isConst() && (memberAccessed || func.isOperator()))
+            const bool suggestStatic = memberAccessed != MemberAccess::MEMBER && !func.isOperator();
+            if ((returnsPtrOrRef || func.isConst() || func.hasLvalRefQualifier()) && !suggestStatic)
                 continue;
+            if (!suggestStatic && !mSettings->certainty.isEnabled(Certainty::inconclusive))
+                // functionConst is inconclusive. False positives: #3322.
+                continue;
+            if (suggestStatic && func.isConst()) {
+                const auto overloads = func.getOverloadedFunctions();
+                if (overloads.size() > 1 && std::any_of(overloads.begin(), overloads.end(), [&](const Function* ovl) {
+                    if (&func == ovl)
+                        return false;
+                    if (!ovl->functionScope)
+                        return true;
+                    return func.argCount() == ovl->argCount() && func.argsMatch(ovl->functionScope, ovl->argDef, func.argDef, "", 0);
+                }))
+                    continue;
+            }
 
             std::string classname = scope->className;
             const Scope *nest = scope->nestedIn;
-            while (nest && nest->type != Scope::eGlobal) {
-                classname = std::string(nest->className + "::" + classname);
+            while (nest && nest->type != ScopeType::eGlobal) {
+                classname = nest->className + "::" + classname;
                 nest = nest->nestedIn;
             }
 
@@ -1897,14 +2246,24 @@ void CheckClass::checkConst()
                 functionName += "]";
 
             if (func.isInline())
-                checkConstError(func.token, classname, functionName, !memberAccessed && !func.isOperator());
+                checkConstError(func.token, classname, functionName, suggestStatic, foundAllBaseClasses);
             else // not inline
-                checkConstError2(func.token, func.tokenDef, classname, functionName, !memberAccessed && !func.isOperator());
+                checkConstError2(func.token, func.tokenDef, classname, functionName, suggestStatic, foundAllBaseClasses);
         }
     }
 }
 
-bool CheckClass::isMemberVar(const Scope *scope, const Token *tok) const
+// tok should point at "this"
+static const Token* getFuncTokFromThis(const Token* tok) {
+    if (!Token::simpleMatch(tok->next(), "."))
+        return nullptr;
+    tok = tok->tokAt(2);
+    while (Token::Match(tok, "%name% ::"))
+        tok = tok->tokAt(2);
+    return Token::Match(tok, "%name% (") ? tok : nullptr;
+}
+
+bool CheckClass::isMemberVar(const Scope *scope, const Token *tok) const
 {
     bool again = false;
 
@@ -1912,10 +2271,13 @@ bool CheckClass::isMemberVar(const Scope *scope, const Token *tok) const
     do {
         again = false;
 
-        if (tok->str() == "this") {
-            return true;
-        } else if (Token::simpleMatch(tok->tokAt(-3), "( * this )")) {
+        if (tok->str() == "this")
+            return !getFuncTokFromThis(tok); // function calls are handled elsewhere
+        if (Token::simpleMatch(tok->tokAt(-3), "( * this )"))
             return true;
+        if (Token::Match(tok->tokAt(-3), "%name% ) . %name%")) {
+            tok = tok->tokAt(-3);
+            again = true;
         } else if (Token::Match(tok->tokAt(-2), "%name% . %name%")) {
             tok = tok->tokAt(-2);
             again = true;
@@ -1925,39 +2287,74 @@ bool CheckClass::isMemberVar(const Scope *scope, const Token *tok) const
         } else if (tok->str() == "]") {
             tok = tok->link()->previous();
             again = true;
+        } else if (Token::Match(tok, "%name% ::")) {
+            tok = tok->tokAt(2);
+            again = true;
         }
     } while (again);
 
-    for (const Variable &var : scope->varlist) {
+    if (tok->isKeyword() || tok->isStandardType())
+        return false;
+    if (tok->variable() && (tok->variable()->isArgument() || tok->variable()->isLocal()))
+        return false;
+    if (tok->function() || tok->type() || tok->enumerator())
+        return false;
+
+    for (const Variable& var : scope->varlist) {
         if (var.name() == tok->str()) {
-            if (tok->varId() == 0)
-                mSymbolDatabase->debugMessage(tok, "CheckClass::isMemberVar found used member variable \'" + tok->str() + "\' with varid 0");
+            if (Token::Match(tok, "%name% ::"))
+                continue;
+            const Token* fqTok = tok;
+            while (Token::Match(fqTok->tokAt(-2), "%name% ::"))
+                fqTok = fqTok->tokAt(-2);
+            if (fqTok->strAt(-1) == "::")
+                fqTok = fqTok->previous();
+            bool isMember = tok == fqTok;
+            std::string scopeStr;
+            const Scope* curScope = scope;
+            while (!isMember && curScope && curScope->type != ScopeType::eGlobal) {
+                scopeStr.insert(0, curScope->className + " :: ");
+                isMember = Token::Match(fqTok, scopeStr.c_str());
+
+                curScope = curScope->nestedIn;
+            }
+            if (isMember) {
+                if (tok->varId() == 0)
+                    mSymbolDatabase->debugMessage(tok, "varid0", "CheckClass::isMemberVar found used member variable \'" + tok->str() + "\' with varid 0");
 
-            return !var.isStatic();
+                return !var.isStatic();
+            }
         }
     }
 
     // not found in this class
     if (!scope->definedType->derivedFrom.empty()) {
         // check each base class
+        bool foundAllBaseClasses = true;
         for (const Type::BaseInfo & i : scope->definedType->derivedFrom) {
             // find the base class
             const Type *derivedFrom = i.type;
+            if (!derivedFrom || !derivedFrom->classScope)
+                foundAllBaseClasses = false;
 
             // find the function in the base class
-            if (derivedFrom && derivedFrom->classScope) {
+            if (derivedFrom && derivedFrom->classScope && derivedFrom->classScope != scope) {
                 if (isMemberVar(derivedFrom->classScope, tok))
                     return true;
             }
         }
+        if (!foundAllBaseClasses)
+            return true;
     }
 
     return false;
 }
 
-bool CheckClass::isMemberFunc(const Scope *scope, const Token *tok) const
+bool CheckClass::isMemberFunc(const Scope *scope, const Token *tok)
 {
     if (!tok->function()) {
+        if (Token::simpleMatch(tok->astParent(), ".") && Token::simpleMatch(tok->astParent()->astOperand1(), "this"))
+            return true;
         for (const Function &func : scope->functionList) {
             if (func.name() == tok->str()) {
                 const Token* tok2 = tok->tokAt(2);
@@ -1969,7 +2366,9 @@ bool CheckClass::isMemberFunc(const Scope *scope, const Token *tok) const
                     else
                         break;
                 }
-                if (argsPassed == func.argCount() || (argsPassed < func.argCount() && argsPassed >= func.minArgCount()))
+                if (argsPassed == func.argCount() ||
+                    (func.isVariadic() && argsPassed >= (func.argCount() - 1)) ||
+                    (argsPassed < func.argCount() && argsPassed >= func.minArgCount()))
                     return true;
             }
         }
@@ -1984,7 +2383,7 @@ bool CheckClass::isMemberFunc(const Scope *scope, const Token *tok) const
             const Type *derivedFrom = i.type;
 
             // find the function in the base class
-            if (derivedFrom && derivedFrom->classScope) {
+            if (derivedFrom && derivedFrom->classScope && derivedFrom->classScope != scope) {
                 if (isMemberFunc(derivedFrom->classScope, tok))
                     return true;
             }
@@ -1994,11 +2393,11 @@ bool CheckClass::isMemberFunc(const Scope *scope, const Token *tok) const
     return false;
 }
 
-bool CheckClass::isConstMemberFunc(const Scope *scope, const Token *tok) const
+bool CheckClass::isConstMemberFunc(const Scope *scope, const Token *tok)
 {
     if (!tok->function())
         return false;
-    else if (tok->function()->nestedIn == scope)
+    if (tok->function()->nestedIn == scope)
         return tok->function()->isConst();
 
     // not found in this class
@@ -2019,36 +2418,137 @@ bool CheckClass::isConstMemberFunc(const Scope *scope, const Token *tok) const
     return false;
 }
 
-namespace {
-    // The container contains the STL types whose operator[] is not a const.
-    const std::set<std::string> stl_containers_not_const = { "map", "unordered_map" };
+const std::set<std::string> CheckClass::stl_containers_not_const = { "map", "unordered_map", "std :: map|unordered_map <" }; // start pattern
+
+static bool isNonConstPtrCast(const Token* tok)
+{
+    if (!tok || !tok->isCast())
+        return false;
+    const ValueType* vt = tok->valueType();
+    return !vt || (vt->pointer > 0 && !vt->isConst(vt->pointer));
 }
 
-bool CheckClass::checkConstFunc(const Scope *scope, const Function *func, bool& memberAccessed) const
+bool CheckClass::checkConstFunc(const Scope *scope, const Function *func, MemberAccess& memberAccessed) const
 {
+    if (mTokenizer->hasIfdef(func->functionScope->bodyStart, func->functionScope->bodyEnd))
+        return false;
+
+    auto getFuncTok = [](const Token* tok) -> const Token* {
+        if (Token::simpleMatch(tok, "this"))
+            tok = getFuncTokFromThis(tok);
+        bool isReturn = false;
+        if ((Token::Match(tok, "%name% (|{") || (isReturn = Token::simpleMatch(tok->astParent(), "return {"))) && !tok->isStandardType() && !tok->isKeyword()) {
+            if (isReturn)
+                tok = tok->astParent();
+            return tok;
+        }
+        return nullptr;
+    };
+
+    auto checkFuncCall = [this, &memberAccessed](const Token* funcTok, const Scope* scope, const Function* func) {
+        if (isMemberFunc(scope, funcTok) && (funcTok->strAt(-1) != "." || Token::simpleMatch(funcTok->tokAt(-2), "this ."))) {
+            const bool isSelf = func == funcTok->function();
+            if (!isConstMemberFunc(scope, funcTok) && !isSelf)
+                return false;
+            memberAccessed = (isSelf && memberAccessed != MemberAccess::MEMBER) ? MemberAccess::SELF : MemberAccess::MEMBER;
+        }
+
+        if (const Function* f = funcTok->function()) { // check known function
+            const std::vector<const Token*> args = getArguments(funcTok);
+            const auto argMax = std::min<nonneg int>(args.size(), f->argCount());
+
+            for (nonneg int argIndex = 0; argIndex < argMax; ++argIndex) {
+                const Variable* const argVar = f->getArgumentVar(argIndex);
+                if (!argVar || ((argVar->isArrayOrPointer() || argVar->isReference()) &&
+                                !(argVar->valueType() && argVar->valueType()->isConst(argVar->valueType()->pointer)))) { // argument might be modified
+                    const Token* arg = args[argIndex];
+                    // Member variable given as parameter
+                    while (Token::simpleMatch(arg, "(") && arg->astOperand2())
+                        arg = arg->astOperand2();
+                    const Token* varTok = previousBeforeAstLeftmostLeaf(arg);
+                    if (!varTok)
+                        return false;
+                    varTok = varTok->next();
+                    if ((varTok->isName() && isMemberVar(scope, varTok)) || (varTok->isUnaryOp("&") && (varTok = varTok->astOperand1()) && isMemberVar(scope, varTok))) {
+                        const Variable* var = varTok->variable();
+                        if (!var || (!var->isMutable() && !var->isConst()))
+                            return false;
+                    }
+                }
+            }
+            return true;
+        }
+
+        if (const Library::Function* fLib = mSettings->library.getFunction(funcTok))
+            if (fLib->isconst || fLib->ispure)
+                return true;
+
+        // Member variable given as parameter to unknown function
+        const Token *lpar = funcTok->next();
+        if (Token::simpleMatch(lpar, "( ) ("))
+            lpar = lpar->tokAt(2);
+        for (const Token* tok = lpar->next(); tok && tok != funcTok->linkAt(1); tok = tok->next()) {
+            if (tok->str() == "(")
+                tok = tok->link();
+            else if ((tok->isName() && isMemberVar(scope, tok)) || (tok->isUnaryOp("&") && (tok = tok->astOperand1()) && isMemberVar(scope, tok))) {
+                const Variable* var = tok->variable();
+                if (!var || (!var->isMutable() && !var->isConst()))
+                    return false;
+            }
+        }
+        return true;
+    };
+
     // if the function doesn't have any assignment nor function call,
     // it can be a const function..
     for (const Token *tok1 = func->functionScope->bodyStart; tok1 && tok1 != func->functionScope->bodyEnd; tok1 = tok1->next()) {
         if (tok1->isName() && isMemberVar(scope, tok1)) {
-            memberAccessed = true;
+            memberAccessed = MemberAccess::MEMBER;
             const Variable* v = tok1->variable();
             if (v && v->isMutable())
                 continue;
 
-            if (tok1->str() == "this" && tok1->previous()->isAssignmentOp())
-                return false;
+            if (tok1->str() == "this") {
+                if (tok1->previous()->isAssignmentOp())
+                    return false;
+                if (Token::Match(tok1->previous(), "( this . * %var% )")) // call using ptr to member function TODO: check constness
+                    return false;
+                if (Token::simpleMatch(tok1->astParent(), "*") && tok1->astParent()->astParent() && tok1->astParent()->astParent()->isIncDecOp())
+                    return false;
+            }
 
+            // non const pointer cast
+            if (tok1->valueType() && tok1->valueType()->pointer > 0 && isNonConstPtrCast(tok1->astParent()))
+                return false;
 
             const Token* lhs = tok1->previous();
+            if (lhs->str() == "(" && tok1->astParent() && tok1->astParent()->astParent())
+                lhs = tok1->astParent()->astParent();
+            else if (lhs->str() == "?" && lhs->astParent())
+                lhs = lhs->astParent();
+            else if (lhs->str() == ":" && lhs->astParent() && lhs->astParent()->astParent() && lhs->astParent()->str() == "?")
+                lhs = lhs->astParent()->astParent();
             if (lhs->str() == "&") {
-                lhs = lhs->previous();
-                if (lhs->isAssignmentOp() && lhs->previous()->variable()) {
-                    if (lhs->previous()->variable()->typeStartToken()->strAt(-1) != "const" && lhs->previous()->variable()->isPointer())
+                const Token* parent = lhs->astParent();
+                while (Token::Match(parent, "[+(]")) {
+                    if (isNonConstPtrCast(parent))
+                        return false;
+                    parent = parent->astParent();
+                }
+                const Token* const top = lhs->astTop();
+                if (top->isAssignmentOp()) {
+                    if (Token::simpleMatch(top->astOperand2(), "{") && !top->astOperand2()->previous()->function()) // TODO: check usage in init list
                         return false;
+                    if (top->previous()->variable()) {
+                        if (top->previous()->variable()->typeStartToken()->strAt(-1) != "const" && top->previous()->variable()->isPointer())
+                            return false;
+                    }
                 }
-            } else if (lhs->str() == ":" && lhs->astParent() && lhs->astParent()->str() == "(" && tok1->strAt(1) == ")") { // range-based for-loop (C++11)
-                // TODO: We could additionally check what is done with the elements to avoid false negatives. Here we just rely on "const" keyword being used.
-                if (lhs->astParent()->strAt(1) != "const")
+            } else if (lhs->str() == ":" && lhs->astParent() && lhs->astParent()->str() == "(") { // range-based for-loop (C++11)
+                const Variable* loopVar = lhs->astOperand1()->variable();
+                if (!loopVar || !loopVar->valueType())
+                    return false;
+                if (!loopVar->valueType()->isConst(loopVar->valueType()->pointer))
                     return false;
             } else {
                 if (lhs->isAssignmentOp()) {
@@ -2071,6 +2571,19 @@ bool CheckClass::checkConstFunc(const Scope *scope, const Function *func, bool&
                         const Variable *var = end->variable();
                         if (var && var->isStlType(stl_containers_not_const))
                             return false;
+                        const Token* assignTok = end->next()->astParent();
+                        if (var && assignTok && assignTok->isAssignmentOp() && assignTok->astOperand1() && assignTok->astOperand1()->variable()) {
+                            // cppcheck-suppress shadowFunction - TODO: fix this
+                            const Variable* assignVar = assignTok->astOperand1()->variable();
+                            if (assignVar->isPointer() && !assignVar->isConst() && var->typeScope()) {
+                                const auto& funcMap = var->typeScope()->functionMap;
+                                // if there is no operator that is const and returns a non-const pointer, func cannot be const
+                                if (std::none_of(funcMap.cbegin(), funcMap.cend(), [](const std::pair<std::string, const Function*>& fm) {
+                                    return fm.second->isConst() && fm.first == "operator[]" && !Function::returnsConst(fm.second);
+                                }))
+                                    return false;
+                            }
+                        }
                     }
                     if (!jumpBackToken)
                         jumpBackToken = end->next(); // Check inside the [] brackets
@@ -2081,15 +2594,60 @@ bool CheckClass::checkConstFunc(const Scope *scope, const Function *func, bool&
                     break;
             }
 
+            auto hasOverloadedMemberAccess = [](const Token* end, const Scope* scope) -> bool {
+                if (!end || !scope || !Token::simpleMatch(end->astParent(), "."))
+                    return false;
+                const std::string op = "operator" + end->astParent()->originalName();
+                auto it = std::find_if(scope->functionList.begin(), scope->functionList.end(), [&op](const Function& f) {
+                    return f.isConst() && f.name() == op;
+                });
+                if (it == scope->functionList.end() || !it->retType || !it->retType->classScope)
+                    return false;
+                const Function* func = it->retType->classScope->findFunction(end, /*requireConst*/ true);
+                return func && func->isConst();
+            };
+
+            auto isConstContainerUsage = [&](const ValueType* vt) -> bool {
+                if (!vt || !vt->container)
+                    return false;
+                const auto yield = vt->container->getYield(end->str());
+                const Token* parent = tok1->astParent();
+                while (Token::Match(parent, "(|.|::"))
+                    parent = parent->astParent();
+                if (contains({Library::Container::Yield::START_ITERATOR, Library::Container::Yield::END_ITERATOR, Library::Container::Yield::ITERATOR}, yield)) {
+                    if (parent && parent->isComparisonOp())
+                        return true;
+                    // TODO: use AST
+                    if (parent && parent->isAssignmentOp() && tok1->tokAt(-2)->variable() && Token::Match(tok1->tokAt(-2)->variable()->typeEndToken(), "const_iterator|const_reverse_iterator"))
+                        return true;
+                }
+                if ((yield == Library::Container::Yield::ITEM || yield == Library::Container::Yield::AT_INDEX) &&
+                    ((parent && parent->isComparisonOp()) || lhs->isAssignmentOp() || (lhs->str() == "(" && Token::Match(lhs->astParent(), "%cop%"))))
+                    return true; // assume that these functions have const overloads
+                return false;
+            };
+
             if (end->strAt(1) == "(") {
                 const Variable *var = lastVarTok->variable();
                 if (!var)
                     return false;
                 if (var->isStlType() // assume all std::*::size() and std::*::empty() are const
-                    && (Token::Match(end, "size|empty|cend|crend|cbegin|crbegin|max_size|length|count|capacity|get_allocator|c_str|str ( )") || Token::Match(end, "rfind|copy")))
-                    ;
-                else if (!var->typeScope() || !isConstMemberFunc(var->typeScope(), end))
-                    return false;
+                    && (Token::Match(end, "size|empty|cend|crend|cbegin|crbegin|max_size|length|count|capacity|get_allocator|c_str|str ( )") || Token::Match(end, "rfind|copy"))) {
+                    // empty body
+                }
+                else if (isConstContainerUsage(lastVarTok->valueType())) {
+                    // empty body
+                }
+                else if (var->smartPointerType() && var->smartPointerType()->classScope && isConstMemberFunc(var->smartPointerType()->classScope, end)) {
+                    // empty body
+                } else if (var->isSmartPointer() && Token::simpleMatch(tok1->next(), ".") && tok1->next()->originalName().empty() && mSettings->library.isFunctionConst(end)) {
+                    // empty body
+                } else if (hasOverloadedMemberAccess(end, var->typeScope())) {
+                    // empty body
+                } else if (!var->typeScope() || (end->function() != func && !isConstMemberFunc(var->typeScope(), end))) {
+                    if (!mSettings->library.isFunctionConst(end))
+                        return false;
+                }
             }
 
             // Assignment
@@ -2099,7 +2657,7 @@ bool CheckClass::checkConstFunc(const Scope *scope, const Function *func, bool&
             // Streaming
             else if (end->strAt(1) == "<<" && tok1->strAt(-1) != "<<")
                 return false;
-            else if (isLikelyStreamRead(true, tok1->previous()))
+            else if (isLikelyStreamRead(tok1->previous()))
                 return false;
 
             // ++/--
@@ -2115,6 +2673,8 @@ bool CheckClass::checkConstFunc(const Scope *scope, const Function *func, bool&
                 return false;
 
             tok1 = jumpBackToken?jumpBackToken:end; // Jump back to first [ to check inside, or jump to end of expression
+            if (tok1 == end && Token::Match(end->previous(), ". %name% ( !!)") && !checkFuncCall(tok1, scope, func)) // function call on member
+                return false;
         }
 
         // streaming: <<
@@ -2126,31 +2686,14 @@ bool CheckClass::checkConstFunc(const Scope *scope, const Function *func, bool&
         }
 
         // streaming: >> *this
-        else if (Token::simpleMatch(tok1, ">> * this") && isLikelyStreamRead(true, tok1)) {
+        else if (Token::simpleMatch(tok1, ">> * this") && isLikelyStreamRead(tok1)) {
             return false;
         }
 
-        // function call..
-        else if (Token::Match(tok1, "%name% (") && !tok1->isStandardType() &&
-                 !Token::Match(tok1, "return|if|string|switch|while|catch|for")) {
-            if (isMemberFunc(scope, tok1) && tok1->strAt(-1) != ".") {
-                if (!isConstMemberFunc(scope, tok1))
-                    return false;
-                memberAccessed = true;
-            }
-            // Member variable given as parameter
-            const Token *lpar = tok1->next();
-            if (Token::simpleMatch(lpar, "( ) ("))
-                lpar = lpar->tokAt(2);
-            for (const Token* tok2 = lpar->next(); tok2 && tok2 != tok1->next()->link(); tok2 = tok2->next()) {
-                if (tok2->str() == "(")
-                    tok2 = tok2->link();
-                else if (tok2->isName() && isMemberVar(scope, tok2)) {
-                    const Variable* var = tok2->variable();
-                    if (!var || !var->isMutable())
-                        return false; // TODO: Only bailout if function takes argument as non-const reference
-                }
-            }
+        // function/constructor call, return init list
+        else if (const Token* funcTok = getFuncTok(tok1)) {
+            if (!checkFuncCall(funcTok, scope, func))
+                return false;
         } else if (Token::simpleMatch(tok1, "> (") && (!tok1->link() || !Token::Match(tok1->link()->previous(), "static_cast|const_cast|dynamic_cast|reinterpret_cast"))) {
             return false;
         }
@@ -2159,36 +2702,35 @@ bool CheckClass::checkConstFunc(const Scope *scope, const Function *func, bool&
     return true;
 }
 
-void CheckClass::checkConstError(const Token *tok, const std::string &classname, const std::string &funcname, bool suggestStatic)
+void CheckClass::checkConstError(const Token *tok, const std::string &classname, const std::string &funcname, bool suggestStatic, bool foundAllBaseClasses)
 {
-    checkConstError2(tok, nullptr, classname, funcname, suggestStatic);
+    checkConstError2(tok, nullptr, classname, funcname, suggestStatic, foundAllBaseClasses);
 }
 
-void CheckClass::checkConstError2(const Token *tok1, const Token *tok2, const std::string &classname, const std::string &funcname, bool suggestStatic)
+void CheckClass::checkConstError2(const Token *tok1, const Token *tok2, const std::string &classname, const std::string &funcname, bool suggestStatic, bool foundAllBaseClasses)
 {
-    std::list<const Token *> toks;
-    toks.push_back(tok1);
+    std::list<const Token *> toks{ tok1 };
     if (tok2)
-        toks.push_back(tok2);
-    if (!suggestStatic)
+        toks.push_front(tok2);
+    if (!suggestStatic) {
+        const std::string msg = foundAllBaseClasses ?
+                                "Technically the member function '$symbol' can be const.\nThe member function '$symbol' can be made a const " :
+                                "Either there is a missing 'override', or the member function '$symbol' can be const.\nUnless it overrides a base class member, the member function '$symbol' can be made a const ";
         reportError(toks, Severity::style, "functionConst",
                     "$symbol:" + classname + "::" + funcname +"\n"
-                    "Technically the member function '$symbol' can be const.\n"
-                    "The member function '$symbol' can be made a const "
+                    + msg +
                     "function. Making this function 'const' should not cause compiler errors. "
                     "Even though the function can be made const function technically it may not make "
                     "sense conceptually. Think about your design and the task of the function first - is "
-                    "it a function that must not change object internal state?", CWE398, true);
-    else
-        reportError(toks, Severity::performance, "functionStatic",
-                    "$symbol:" + classname + "::" + funcname +"\n"
-                    "Technically the member function '$symbol' can be static (but you may consider moving to unnamed namespace).\n"
-                    "The member function '$symbol' can be made a static "
-                    "function. Making a function static can bring a performance benefit since no 'this' instance is "
-                    "passed to the function. This change should not cause compiler errors but it does not "
-                    "necessarily make sense conceptually. Think about your design and the task of the function first - "
-                    "is it a function that must not access members of class instances? And maybe it is more appropriate "
-                    "to move this function to a unnamed namespace.", CWE398, true);
+                    "it a function that must not change object internal state?", CWE398, Certainty::inconclusive);
+    }
+    else {
+        const std::string msg = foundAllBaseClasses ?
+                                "The member function '$symbol' can be static." :
+                                "Either there is a missing 'override', or the member function '$symbol' can be static.";
+        reportError(toks, Severity::style, "functionStatic",
+                    "$symbol:" + classname + "::" + funcname +"\n" + msg, CWE398, Certainty::normal);
+    }
 }
 
 //---------------------------------------------------------------------------
@@ -2198,29 +2740,34 @@ void CheckClass::checkConstError2(const Token *tok1, const Token *tok2, const st
 namespace { // avoid one-definition-rule violation
     struct VarInfo {
         VarInfo(const Variable *_var, const Token *_tok)
-            : var(_var), tok(_tok) { }
+            : var(_var), tok(_tok) {}
 
         const Variable *var;
         const Token *tok;
+        std::vector<const Variable*> initArgs;
     };
 }
 
 void CheckClass::initializerListOrder()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
-        return;
+    if (!mSettings->isPremiumEnabled("initializerList")) {
+        if (!mSettings->severity.isEnabled(Severity::style))
+            return;
 
-    // This check is not inconclusive.  However it only determines if the initialization
-    // order is incorrect.  It does not determine if being out of order causes
-    // a real error.  Out of order is not necessarily an error but you can never
-    // have an error if the list is in order so this enforces defensive programming.
-    if (!mSettings->inconclusive)
-        return;
+        // This check is not inconclusive.  However it only determines if the initialization
+        // order is incorrect.  It does not determine if being out of order causes
+        // a real error.  Out of order is not necessarily an error but you can never
+        // have an error if the list is in order so this enforces defensive programming.
+        if (!mSettings->certainty.isEnabled(Certainty::inconclusive))
+            return;
+    }
+
+    logChecker("CheckClass::initializerListOrder"); // style,inconclusive
 
     for (const Scope * scope : mSymbolDatabase->classAndStructScopes) {
 
         // iterate through all member functions looking for constructors
-        for (std::list<Function>::const_iterator func = scope->functionList.begin(); func != scope->functionList.end(); ++func) {
+        for (auto func = scope->functionList.cbegin(); func != scope->functionList.cend(); ++func) {
             if (func->isConstructor() && func->hasBody()) {
                 // check for initializer list
                 const Token *tok = func->arg->link()->next();
@@ -2230,25 +2777,46 @@ void CheckClass::initializerListOrder()
                     tok = tok->next();
 
                     // find all variable initializations in list
-                    while (tok && tok != func->functionScope->bodyStart) {
+                    for (; tok && tok != func->functionScope->bodyStart; tok = tok->next()) {
                         if (Token::Match(tok, "%name% (|{")) {
+                            const Token* const end = tok->linkAt(1);
                             const Variable *var = scope->getVariable(tok->str());
                             if (var)
                                 vars.emplace_back(var, tok);
-
-                            if (Token::Match(tok->tokAt(2), "%name% =")) {
-                                var = scope->getVariable(tok->strAt(2));
-
-                                if (var)
-                                    vars.emplace_back(var, tok->tokAt(2));
+                            else
+                                tok = end;
+
+                            for (; tok != end; tok = tok->next()) {
+                                if (Token::Match(tok->astParent(), ".|::"))
+                                    continue;
+                                if (const Variable* argVar = scope->getVariable(tok->str())) {
+                                    if (scope != argVar->scope())
+                                        continue;
+                                    if (argVar->isStatic())
+                                        continue;
+                                    if (tok->variable() && tok->variable()->isArgument())
+                                        continue;
+                                    if (var->isPointer() && (argVar->isArray() || Token::simpleMatch(tok->astParent(), "&")))
+                                        continue;
+                                    if (var->isReference())
+                                        continue;
+                                    if (Token::simpleMatch(tok->astParent(), "="))
+                                        continue;
+                                    vars.back().initArgs.emplace_back(argVar);
+                                }
                             }
-                            tok = tok->next()->link()->next();
-                        } else
-                            tok = tok->next();
+                        }
                     }
 
-                    // need at least 2 members to have out of order initialization
-                    for (int j = 1; j < vars.size(); j++) {
+                    for (std::size_t j = 0; j < vars.size(); j++) {
+                        // check for use of uninitialized arguments
+                        for (const auto& arg : vars[j].initArgs)
+                            if (vars[j].var->index() < arg->index())
+                                initializerListError(vars[j].tok, vars[j].var->nameToken(), scope->className, vars[j].var->name(), arg->name());
+
+                        // need at least 2 members to have out of order initialization
+                        if (j == 0)
+                            continue;
                         // check for out of order initialization
                         if (vars[j].var->index() < vars[j - 1].var->index())
                             initializerListError(vars[j].tok,vars[j].var->nameToken(), scope->className, vars[j].var->name());
@@ -2259,17 +2827,20 @@ void CheckClass::initializerListOrder()
     }
 }
 
-void CheckClass::initializerListError(const Token *tok1, const Token *tok2, const std::string &classname, const std::string &varname)
+void CheckClass::initializerListError(const Token *tok1, const Token *tok2, const std::string &classname, const std::string &varname, const std::string& argname)
 {
     std::list<const Token *> toks = { tok1, tok2 };
+    const std::string msg = argname.empty() ?
+                            "Member variable '$symbol' is in the wrong place in the initializer list." :
+                            "Member variable '$symbol' uses an uninitialized argument '" + argname + "' due to the order of declarations.";
     reportError(toks, Severity::style, "initializerList",
-                "$symbol:" + classname + "::" + varname +"\n"
-                "Member variable '$symbol' is in the wrong place in the initializer list.\n"
-                "Member variable '$symbol' is in the wrong place in the initializer list. "
+                "$symbol:" + classname + "::" + varname + '\n' +
+                msg + '\n' +
+                msg + ' ' +
                 "Members are initialized in the order they are declared, not in the "
-                "order they are in the initializer list.  Keeping the initializer list "
+                "order they are in the initializer list. Keeping the initializer list "
                 "in the same order that the members were declared prevents order dependent "
-                "initialization errors.", CWE398, true);
+                "initialization errors.", CWE398, Certainty::inconclusive);
 }
 
 
@@ -2279,6 +2850,8 @@ void CheckClass::initializerListError(const Token *tok1, const Token *tok2, cons
 
 void CheckClass::checkSelfInitialization()
 {
+    logChecker("CheckClass::checkSelfInitialization");
+
     for (const Scope *scope : mSymbolDatabase->functionScopes) {
         const Function* function = scope->function;
         if (!function || !function->isConstructor())
@@ -2289,8 +2862,16 @@ void CheckClass::checkSelfInitialization()
             continue;
 
         for (; tok != scope->bodyStart; tok = tok->next()) {
-            if (Token::Match(tok, "[:,] %var% (|{ %var% )|}") && tok->next()->varId() == tok->tokAt(3)->varId()) {
-                selfInitializationError(tok, tok->strAt(1));
+            if (Token::Match(tok, "[:,] %var% (|{")) {
+                const Token* varTok = tok->next();
+                if (Token::Match(varTok->astParent(), "(|{")) {
+                    if (const Token* initTok = varTok->astParent()->astOperand2()) {
+                        if (initTok->varId() == varTok->varId())
+                            selfInitializationError(tok, varTok->str());
+                        else if (initTok->isCast() && ((initTok->astOperand1() && initTok->astOperand1()->varId() == varTok->varId()) || (initTok->astOperand2() && initTok->astOperand2()->varId() == varTok->varId())))
+                            selfInitializationError(tok, varTok->str());
+                    }
+                }
             }
         }
     }
@@ -2298,7 +2879,7 @@ void CheckClass::checkSelfInitialization()
 
 void CheckClass::selfInitializationError(const Token* tok, const std::string& varname)
 {
-    reportError(tok, Severity::error, "selfInitialization", "$symbol:" + varname + "\nMember variable '$symbol' is initialized by itself.", CWE665, false);
+    reportError(tok, Severity::error, "selfInitialization", "$symbol:" + varname + "\nMember variable '$symbol' is initialized by itself.", CWE665, Certainty::normal);
 }
 
 
@@ -2308,9 +2889,10 @@ void CheckClass::selfInitializationError(const Token* tok, const std::string& va
 
 void CheckClass::checkVirtualFunctionCallInConstructor()
 {
-    if (! mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
-    std::map<const Function *, std::list<const Token *> > virtualFunctionCallsMap;
+    logChecker("CheckClass::checkVirtualFunctionCallInConstructor"); // warning
+    std::map<const Function *, std::list<const Token *>> virtualFunctionCallsMap;
     for (const Scope *scope : mSymbolDatabase->functionScopes) {
         if (scope->function == nullptr || !scope->function->hasBody() ||
             !(scope->function->isConstructor() ||
@@ -2323,32 +2905,36 @@ void CheckClass::checkVirtualFunctionCallInConstructor()
             getFirstVirtualFunctionCallStack(virtualFunctionCallsMap, callToken, callstack);
             if (callstack.empty())
                 continue;
-            if (callstack.back()->function()->isPure())
+            const Function* const func = callstack.back()->function();
+            if (!(func->hasVirtualSpecifier() || func->hasOverrideSpecifier()))
+                continue;
+            if (func->isPure())
                 pureVirtualFunctionCallInConstructorError(scope->function, callstack, callstack.back()->str());
-            else
+            else if (!func->hasFinalSpecifier() &&
+                     !(func->nestedIn && func->nestedIn->classDef && func->nestedIn->classDef->isFinalType()))
                 virtualFunctionCallInConstructorError(scope->function, callstack, callstack.back()->str());
         }
     }
 }
 
 const std::list<const Token *> & CheckClass::getVirtualFunctionCalls(const Function & function,
-        std::map<const Function *, std::list<const Token *> > & virtualFunctionCallsMap)
+                                                                     std::map<const Function *, std::list<const Token *>> & virtualFunctionCallsMap)
 {
-    const std::map<const Function *, std::list<const Token *> >::const_iterator found = virtualFunctionCallsMap.find(&function);
+    const auto found = utils::as_const(virtualFunctionCallsMap).find(&function);
     if (found != virtualFunctionCallsMap.end())
         return found->second;
 
     virtualFunctionCallsMap[&function] = std::list<const Token *>();
     std::list<const Token *> & virtualFunctionCalls = virtualFunctionCallsMap.find(&function)->second;
 
-    if (!function.hasBody())
+    if (!function.hasBody() || !function.functionScope)
         return virtualFunctionCalls;
 
     for (const Token *tok = function.arg->link(); tok != function.functionScope->bodyEnd; tok = tok->next()) {
-        if (function.type != Function::eConstructor &&
-            function.type != Function::eCopyConstructor &&
-            function.type != Function::eMoveConstructor &&
-            function.type != Function::eDestructor) {
+        if (function.type != FunctionType::eConstructor &&
+            function.type != FunctionType::eCopyConstructor &&
+            function.type != FunctionType::eMoveConstructor &&
+            function.type != FunctionType::eDestructor) {
             if ((Token::simpleMatch(tok, ") {") && tok->link() && Token::Match(tok->link()->previous(), "if|switch")) ||
                 Token::simpleMatch(tok, "else {")) {
                 // Assume pure virtual function call is prevented by "if|else|switch" condition
@@ -2356,21 +2942,22 @@ const std::list<const Token *> & CheckClass::getVirtualFunctionCalls(const Funct
                 continue;
             }
         }
-        if (tok->scope()->type == Scope::eLambda)
+        if (tok->scope()->type == ScopeType::eLambda)
             tok = tok->scope()->bodyEnd->next();
 
         const Function * callFunction = tok->function();
         if (!callFunction ||
             function.nestedIn != callFunction->nestedIn ||
-            (tok->previous() && tok->previous()->str() == "."))
+            Token::simpleMatch(tok->previous(), ".") ||
+            !(tok->astParent() && (tok->astParent()->str() == "(" || (tok->astParent()->str() == "::" && Token::simpleMatch(tok->astParent()->astParent(), "(")))))
             continue;
 
         if (tok->previous() &&
-            tok->previous()->str() == "(") {
+            tok->strAt(-1) == "(") {
             const Token * prev = tok->previous();
             if (prev->previous() &&
                 (mSettings->library.ignorefunction(tok->str())
-                 || mSettings->library.ignorefunction(prev->previous()->str())))
+                 || mSettings->library.ignorefunction(prev->strAt(-1))))
                 continue;
         }
 
@@ -2389,7 +2976,7 @@ const std::list<const Token *> & CheckClass::getVirtualFunctionCalls(const Funct
 }
 
 void CheckClass::getFirstVirtualFunctionCallStack(
-    std::map<const Function *, std::list<const Token *> > & virtualFunctionCallsMap,
+    std::map<const Function *, std::list<const Token *>> & virtualFunctionCallsMap,
     const Token * callToken,
     std::list<const Token *> & pureFuncStack)
 {
@@ -2398,12 +2985,12 @@ void CheckClass::getFirstVirtualFunctionCallStack(
         pureFuncStack.push_back(callFunction->tokenDef);
         return;
     }
-    std::map<const Function *, std::list<const Token *> >::const_iterator found = virtualFunctionCallsMap.find(callFunction);
-    if (found == virtualFunctionCallsMap.end() || found->second.empty()) {
+    auto found = utils::as_const(virtualFunctionCallsMap).find(callFunction);
+    if (found == virtualFunctionCallsMap.cend() || found->second.empty()) {
         pureFuncStack.clear();
         return;
     }
-    const Token * firstCall = *found->second.begin();
+    const Token * firstCall = *found->second.cbegin();
     pureFuncStack.push_back(firstCall);
     getFirstVirtualFunctionCallStack(virtualFunctionCallsMap, firstCall, pureFuncStack);
 }
@@ -2413,12 +3000,16 @@ void CheckClass::virtualFunctionCallInConstructorError(
     const std::list<const Token *> & tokStack,
     const std::string &funcname)
 {
+    if (scopeFunction && !mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("virtualCallInConstructor"))
+        return;
+
     const char * scopeFunctionTypeName = scopeFunction ? getFunctionTypeName(scopeFunction->type) : "constructor";
 
     ErrorPath errorPath;
+    std::transform(tokStack.cbegin(), tokStack.cend(), std::back_inserter(errorPath), [](const Token* tok) {
+        return ErrorPathItem(tok, "Calling " + tok->str());
+    });
     int lineNumber = 1;
-    for (const Token *tok : tokStack)
-        errorPath.emplace_back(tok, "Calling " + tok->str());
     if (!errorPath.empty()) {
         lineNumber = errorPath.front().first->linenr();
         errorPath.back().second = funcname + " is a virtual function";
@@ -2427,7 +3018,7 @@ void CheckClass::virtualFunctionCallInConstructorError(
     std::string constructorName;
     if (scopeFunction) {
         const Token *endToken = scopeFunction->argDef->link()->next();
-        if (scopeFunction->type == Function::Type::eDestructor)
+        if (scopeFunction->type == FunctionType::eDestructor)
             constructorName = "~";
         for (const Token *tok = scopeFunction->tokenDef; tok != endToken; tok = tok->next()) {
             if (!constructorName.empty() && Token::Match(tok->previous(), "%name%|%num% %name%|%num%"))
@@ -2438,8 +3029,8 @@ void CheckClass::virtualFunctionCallInConstructorError(
         }
     }
 
-    reportError(errorPath, Severity::warning, "virtualCallInConstructor",
-                "Virtual function '" + funcname + "' is called from " + scopeFunctionTypeName + " '" + constructorName + "' at line " + MathLib::toString(lineNumber) + ". Dynamic binding is not used.", CWE(0U), false);
+    reportError(std::move(errorPath), Severity::style, "virtualCallInConstructor",
+                "Virtual function '" + funcname + "' is called from " + scopeFunctionTypeName + " '" + constructorName + "' at line " + std::to_string(lineNumber) + ". Dynamic binding is not used.", CWE(0U), Certainty::normal);
 }
 
 void CheckClass::pureVirtualFunctionCallInConstructorError(
@@ -2450,15 +3041,16 @@ void CheckClass::pureVirtualFunctionCallInConstructorError(
     const char * scopeFunctionTypeName = scopeFunction ? getFunctionTypeName(scopeFunction->type) : "constructor";
 
     ErrorPath errorPath;
-    for (const Token *tok : tokStack)
-        errorPath.emplace_back(tok, "Calling " + tok->str());
+    std::transform(tokStack.cbegin(), tokStack.cend(), std::back_inserter(errorPath), [](const Token* tok) {
+        return ErrorPathItem(tok, "Calling " + tok->str());
+    });
     if (!errorPath.empty())
         errorPath.back().second = purefuncname + " is a pure virtual function without body";
 
-    reportError(errorPath, Severity::warning, "pureVirtualCall",
+    reportError(std::move(errorPath), Severity::warning, "pureVirtualCall",
                 "$symbol:" + purefuncname +"\n"
                 "Call of pure virtual function '$symbol' in " + scopeFunctionTypeName + ".\n"
-                "Call of pure virtual function '$symbol' in " + scopeFunctionTypeName + ". The call will fail during runtime.", CWE(0U), false);
+                "Call of pure virtual function '$symbol' in " + scopeFunctionTypeName + ". The call will fail during runtime.", CWE(0U), Certainty::normal);
 }
 
 
@@ -2468,45 +3060,127 @@ void CheckClass::pureVirtualFunctionCallInConstructorError(
 
 void CheckClass::checkDuplInheritedMembers()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning) && !mSettings->isPremiumEnabled("duplInheritedMember"))
         return;
 
+    logChecker("CheckClass::checkDuplInheritedMembers"); // warning
+
     // Iterate over all classes
     for (const Type &classIt : mSymbolDatabase->typeList) {
         // Iterate over the parent classes
-        for (const Type::BaseInfo &parentClassIt : classIt.derivedFrom) {
-            // Check if there is info about the 'Base' class
-            if (!parentClassIt.type || !parentClassIt.type->classScope)
+        checkDuplInheritedMembersRecursive(&classIt, &classIt);
+    }
+}
+
+namespace {
+    struct DuplMemberInfo {
+        DuplMemberInfo(const Variable* cv, const Variable* pcv, const Type::BaseInfo* pc) : classVar(cv), parentClassVar(pcv), parentClass(pc) {}
+        const Variable* classVar;
+        const Variable* parentClassVar;
+        const Type::BaseInfo* parentClass;
+    };
+    struct DuplMemberFuncInfo {
+        DuplMemberFuncInfo(const Function* cf, const Function* pcf, const Type::BaseInfo* pc) : classFunc(cf), parentClassFunc(pcf), parentClass(pc) {}
+        const Function* classFunc;
+        const Function* parentClassFunc;
+        const Type::BaseInfo* parentClass;
+    };
+}
+
+static std::vector<DuplMemberInfo> getDuplInheritedMembersRecursive(const Type* typeCurrent, const Type* typeBase, bool skipPrivate = true)
+{
+    std::vector<DuplMemberInfo> results;
+    for (const Type::BaseInfo &parentClassIt : typeBase->derivedFrom) {
+        // Check if there is info about the 'Base' class
+        if (!parentClassIt.type || !parentClassIt.type->classScope)
+            continue;
+        // Don't crash on recursive templates
+        if (parentClassIt.type == typeBase)
+            continue;
+        // Check if they have a member variable in common
+        for (const Variable &classVarIt : typeCurrent->classScope->varlist) {
+            for (const Variable &parentClassVarIt : parentClassIt.type->classScope->varlist) {
+                if (classVarIt.name() == parentClassVarIt.name() && (!parentClassVarIt.isPrivate() || !skipPrivate)) // Check if the class and its parent have a common variable
+                    results.emplace_back(&classVarIt, &parentClassVarIt, &parentClassIt);
+            }
+        }
+        if (typeCurrent != parentClassIt.type) {
+            const auto recursive = getDuplInheritedMembersRecursive(typeCurrent, parentClassIt.type, skipPrivate);
+            results.insert(results.end(), recursive.begin(), recursive.end());
+        }
+    }
+    return results;
+}
+
+static std::vector<DuplMemberFuncInfo> getDuplInheritedMemberFunctionsRecursive(const Type* typeCurrent, const Type* typeBase, bool skipPrivate = true)
+{
+    std::vector<DuplMemberFuncInfo> results;
+    for (const Type::BaseInfo &parentClassIt : typeBase->derivedFrom) {
+        // Check if there is info about the 'Base' class
+        if (!parentClassIt.type || !parentClassIt.type->classScope)
+            continue;
+        // Don't crash on recursive templates
+        if (parentClassIt.type == typeBase)
+            continue;
+        for (const Function& classFuncIt : typeCurrent->classScope->functionList) {
+            if (classFuncIt.isImplicitlyVirtual())
                 continue;
-            // Check if they have a member variable in common
-            for (const Variable &classVarIt : classIt.classScope->varlist) {
-                for (const Variable &parentClassVarIt : parentClassIt.type->classScope->varlist) {
-                    if (classVarIt.name() == parentClassVarIt.name() && !parentClassVarIt.isPrivate()) { // Check if the class and its parent have a common variable
-                        duplInheritedMembersError(classVarIt.nameToken(), parentClassVarIt.nameToken(),
-                                                  classIt.name(), parentClassIt.type->name(), classVarIt.name(),
-                                                  classIt.classScope->type == Scope::eStruct,
-                                                  parentClassIt.type->classScope->type == Scope::eStruct);
-                    }
-                }
+            if (classFuncIt.tokenDef->isExpandedMacro())
+                continue;
+            if (classFuncIt.templateDef)
+                continue;
+            for (const Function& parentClassFuncIt : parentClassIt.type->classScope->functionList) {
+                if (classFuncIt.name() == parentClassFuncIt.name() &&
+                    (parentClassFuncIt.access != AccessControl::Private || !skipPrivate) &&
+                    !classFuncIt.isConstructor() && !classFuncIt.isDestructor() &&
+                    classFuncIt.argsMatch(parentClassIt.type->classScope, parentClassFuncIt.argDef, classFuncIt.argDef, "", 0) &&
+                    (classFuncIt.isConst() == parentClassFuncIt.isConst() || Function::returnsConst(&classFuncIt) == Function::returnsConst(&parentClassFuncIt)) &&
+                    !(classFuncIt.isDelete() || parentClassFuncIt.isDelete()))
+                    results.emplace_back(&classFuncIt, &parentClassFuncIt, &parentClassIt);
             }
         }
+        if (typeCurrent != parentClassIt.type) {
+            const auto recursive = getDuplInheritedMemberFunctionsRecursive(typeCurrent, parentClassIt.type);
+            results.insert(results.end(), recursive.begin(), recursive.end());
+        }
+    }
+    return results;
+}
+
+void CheckClass::checkDuplInheritedMembersRecursive(const Type* typeCurrent, const Type* typeBase)
+{
+    const auto resultsVar = getDuplInheritedMembersRecursive(typeCurrent, typeBase);
+    for (const auto& r : resultsVar) {
+        duplInheritedMembersError(r.classVar->nameToken(), r.parentClassVar->nameToken(),
+                                  typeCurrent->name(), r.parentClass->type->name(), r.classVar->name(),
+                                  typeCurrent->classScope->type == ScopeType::eStruct,
+                                  r.parentClass->type->classScope->type == ScopeType::eStruct);
+    }
+
+    const auto resultsFunc = getDuplInheritedMemberFunctionsRecursive(typeCurrent, typeBase);
+    for (const auto& r : resultsFunc) {
+        duplInheritedMembersError(r.classFunc->token, r.parentClassFunc->token,
+                                  typeCurrent->name(), r.parentClass->type->name(), r.classFunc->name(),
+                                  typeCurrent->classScope->type == ScopeType::eStruct,
+                                  r.parentClass->type->classScope->type == ScopeType::eStruct, /*isFunction*/ true);
     }
 }
 
 void CheckClass::duplInheritedMembersError(const Token *tok1, const Token* tok2,
-        const std::string &derivedName, const std::string &baseName,
-        const std::string &variableName, bool derivedIsStruct, bool baseIsStruct)
+                                           const std::string &derivedName, const std::string &baseName,
+                                           const std::string &memberName, bool derivedIsStruct, bool baseIsStruct, bool isFunction)
 {
     ErrorPath errorPath;
-    errorPath.emplace_back(tok2, "Parent variable '" + baseName + "::" + variableName + "'");
-    errorPath.emplace_back(tok1, "Derived variable '" + derivedName + "::" + variableName + "'");
+    const std::string member = isFunction ? "function" : "variable";
+    errorPath.emplace_back(tok2, "Parent " + member + " '" + baseName + "::" + memberName + "'");
+    errorPath.emplace_back(tok1, "Derived " + member + " '" + derivedName + "::" + memberName + "'");
 
-    const std::string symbols = "$symbol:" + derivedName + "\n$symbol:" + variableName + "\n$symbol:" + baseName;
+    const std::string symbols = "$symbol:" + derivedName + "\n$symbol:" + memberName + "\n$symbol:" + baseName;
 
     const std::string message = "The " + std::string(derivedIsStruct ? "struct" : "class") + " '" + derivedName +
-                                "' defines member variable with name '" + variableName + "' also defined in its parent " +
+                                "' defines member " + member + " with name '" + memberName + "' also defined in its parent " +
                                 std::string(baseIsStruct ? "struct" : "class") + " '" + baseName + "'.";
-    reportError(errorPath, Severity::warning, "duplInheritedMember", symbols + '\n' + message, CWE398, false);
+    reportError(std::move(errorPath), Severity::warning, "duplInheritedMember", symbols + '\n' + message, CWE398, Certainty::normal);
 }
 
 
@@ -2514,7 +3188,7 @@ void CheckClass::duplInheritedMembersError(const Token *tok1, const Token* tok2,
 // Check that copy constructor and operator defined together
 //---------------------------------------------------------------------------
 
-enum class CtorType {
+enum class CtorType : std::uint8_t {
     NO,
     WITHOUT_BODY,
     WITH_BODY
@@ -2522,22 +3196,18 @@ enum class CtorType {
 
 void CheckClass::checkCopyCtorAndEqOperator()
 {
-    // This is disabled because of #8388
+    // TODO: This is disabled because of #8388
     // The message must be clarified. How is the behaviour different?
-    return;
-
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if ((true) || !mSettings->severity.isEnabled(Severity::warning)) // NOLINT(readability-simplify-boolean-expr,readability-redundant-parentheses)
         return;
 
+    // logChecker
+
     for (const Scope * scope : mSymbolDatabase->classAndStructScopes) {
 
-        bool hasNonStaticVars = false;
-        for (std::list<Variable>::const_iterator var = scope->varlist.begin(); var != scope->varlist.end(); ++var) {
-            if (!var->isStatic()) {
-                hasNonStaticVars = true;
-                break;
-            }
-        }
+        const bool hasNonStaticVars = std::any_of(scope->varlist.begin(), scope->varlist.end(), [](const Variable& var) {
+            return !var.isStatic();
+        });
         if (!hasNonStaticVars)
             continue;
 
@@ -2546,16 +3216,16 @@ void CheckClass::checkCopyCtorAndEqOperator()
         CtorType assignmentOperators = CtorType::NO;
 
         for (const Function &func : scope->functionList) {
-            if (copyCtors == CtorType::NO && func.type == Function::eCopyConstructor) {
+            if (copyCtors == CtorType::NO && func.type == FunctionType::eCopyConstructor) {
                 copyCtors = func.hasBody() ? CtorType::WITH_BODY : CtorType::WITHOUT_BODY;
             }
-            if (assignmentOperators == CtorType::NO && func.type == Function::eOperatorEqual) {
+            if (assignmentOperators == CtorType::NO && func.type == FunctionType::eOperatorEqual) {
                 const Variable * variable = func.getArgumentVar(0);
                 if (variable && variable->type() && variable->type()->classScope == scope) {
                     assignmentOperators = func.hasBody() ? CtorType::WITH_BODY : CtorType::WITHOUT_BODY;
                 }
             }
-            if (func.type == Function::eMoveConstructor) {
+            if (func.type == FunctionType::eMoveConstructor) {
                 moveCtor = true;
                 break;
             }
@@ -2572,7 +3242,7 @@ void CheckClass::checkCopyCtorAndEqOperator()
         if (copyCtors != CtorType::NO && assignmentOperators != CtorType::NO)
             continue;
 
-        copyCtorAndEqOperatorError(scope->classDef, scope->className, scope->type == Scope::eStruct, copyCtors == CtorType::WITH_BODY);
+        copyCtorAndEqOperatorError(scope->classDef, scope->className, scope->type == ScopeType::eStruct, copyCtors == CtorType::WITH_BODY);
     }
 }
 
@@ -2580,97 +3250,354 @@ void CheckClass::copyCtorAndEqOperatorError(const Token *tok, const std::string
 {
     const std::string message = "$symbol:" + classname + "\n"
                                 "The " + std::string(isStruct ? "struct" : "class") + " '$symbol' has '" +
-                                getFunctionTypeName(hasCopyCtor ? Function::eCopyConstructor : Function::eOperatorEqual) +
-                                "' but lack of '" + getFunctionTypeName(hasCopyCtor ? Function::eOperatorEqual : Function::eCopyConstructor) +
+                                getFunctionTypeName(hasCopyCtor ? FunctionType::eCopyConstructor : FunctionType::eOperatorEqual) +
+                                "' but lack of '" + getFunctionTypeName(hasCopyCtor ? FunctionType::eOperatorEqual : FunctionType::eCopyConstructor) +
                                 "'.";
     reportError(tok, Severity::warning, "copyCtorAndEqOperator", message);
 }
 
-void CheckClass::checkUnsafeClassDivZero(bool test)
+void CheckClass::checkOverride()
 {
-    // style severity: it is a style decision if classes should be safe or
-    // if users should be required to be careful. I expect that many users
-    // will disagree about these reports.
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("missingOverride"))
         return;
-
+    if (mSettings->standards.cpp < Standards::CPP11)
+        return;
+    logChecker("CheckClass::checkMissingOverride"); // style,c++03
     for (const Scope * classScope : mSymbolDatabase->classAndStructScopes) {
-        if (!test && classScope->classDef->fileIndex() != 1)
+        if (!classScope->definedType || classScope->definedType->derivedFrom.empty())
             continue;
         for (const Function &func : classScope->functionList) {
-            if (func.access != AccessControl::Public)
+            if (func.hasOverrideSpecifier() || func.hasFinalSpecifier())
                 continue;
-            if (!func.hasBody())
+            if (func.tokenDef->isExpandedMacro())
                 continue;
-            if (func.name().compare(0,8,"operator")==0)
+            if (func.templateDef)
                 continue;
-            for (const Token *tok = func.functionScope->bodyStart; tok; tok = tok->next()) {
-                if (Token::Match(tok, "if|switch|while|for|do|}"))
-                    break;
-                if (tok->str() != "/")
+            const Function *baseFunc = func.getOverriddenFunction();
+            if (baseFunc)
+                overrideError(baseFunc, &func);
+        }
+    }
+}
+
+void CheckClass::overrideError(const Function *funcInBase, const Function *funcInDerived)
+{
+    const std::string functionName = funcInDerived ? ((funcInDerived->isDestructor() ? "~" : "") + funcInDerived->name()) : "";
+    const std::string funcType = (funcInDerived && funcInDerived->isDestructor()) ? "destructor" : "function";
+
+    ErrorPath errorPath;
+    if (funcInBase && funcInDerived) {
+        errorPath.emplace_back(funcInBase->tokenDef, "Virtual " + funcType + " in base class");
+        errorPath.emplace_back(funcInDerived->tokenDef, char(std::toupper(funcType[0])) + funcType.substr(1) + " in derived class");
+    }
+
+    reportError(std::move(errorPath), Severity::style, "missingOverride",
+                "$symbol:" + functionName + "\n"
+                "The " + funcType + " '$symbol' overrides a " + funcType + " in a base class but is not marked with a 'override' specifier.",
+                CWE(0U) /* Unknown CWE! */,
+                Certainty::normal);
+}
+
+void CheckClass::uselessOverrideError(const Function *funcInBase, const Function *funcInDerived, bool isSameCode)
+{
+    const std::string functionName = funcInDerived ? ((funcInDerived->isDestructor() ? "~" : "") + funcInDerived->name()) : "";
+    const std::string funcType = (funcInDerived && funcInDerived->isDestructor()) ? "destructor" : "function";
+
+    ErrorPath errorPath;
+    if (funcInBase && funcInDerived) {
+        errorPath.emplace_back(funcInBase->tokenDef, "Virtual " + funcType + " in base class");
+        errorPath.emplace_back(funcInDerived->tokenDef, char(std::toupper(funcType[0])) + funcType.substr(1) + " in derived class");
+    }
+
+    std::string errStr = "\nThe " + funcType + " '$symbol' overrides a " + funcType + " in a base class but ";
+    if (isSameCode) {
+        errStr += "is identical to the overridden function";
+    }
+    else
+        errStr += "just delegates back to the base class.";
+    reportError(std::move(errorPath), Severity::style, "uselessOverride",
+                "$symbol:" + functionName +
+                errStr,
+                CWE(0U) /* Unknown CWE! */,
+                Certainty::normal);
+}
+
+static const Token* getSingleFunctionCall(const Scope* scope) {
+    const Token* const start = scope->bodyStart->next();
+    const Token* const end = Token::findsimplematch(start, ";", 1, scope->bodyEnd);
+    if (!end || end->next() != scope->bodyEnd)
+        return nullptr;
+    const Token* ftok = start;
+    if (ftok->str() == "return")
+        ftok = ftok->astOperand1();
+    else {
+        while (Token::Match(ftok, "%name%|::"))
+            ftok = ftok->next();
+    }
+    if (Token::simpleMatch(ftok, "(") && ftok->previous()->function())
+        return ftok->previous();
+    return nullptr;
+}
+
+static bool compareTokenRanges(const Token* start1, const Token* end1, const Token* start2, const Token* end2) {
+    const Token* tok1 = start1;
+    const Token* tok2 = start2;
+    bool isEqual = false;
+    while (tok1 && tok2) {
+        if (tok1->function() != tok2->function())
+            break;
+        if (tok1->str() != tok2->str())
+            break;
+        if (tok1->str() == "this")
+            break;
+        if (tok1->isExpandedMacro() || tok2->isExpandedMacro())
+            break;
+        if (tok1 == end1 && tok2 == end2) {
+            isEqual = true;
+            break;
+        }
+        tok1 = tok1->next();
+        tok2 = tok2->next();
+    }
+    return isEqual;
+}
+
+void CheckClass::checkUselessOverride()
+{
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("uselessOverride"))
+        return;
+
+    logChecker("CheckClass::checkUselessOverride"); // style
+
+    for (const Scope* classScope : mSymbolDatabase->classAndStructScopes) {
+        if (!classScope->definedType || classScope->definedType->derivedFrom.size() != 1)
+            continue;
+        for (const Function& func : classScope->functionList) {
+            if (!func.functionScope)
+                continue;
+            if (func.hasFinalSpecifier())
+                continue;
+            const Function* baseFunc = func.getOverriddenFunction();
+            if (!baseFunc || baseFunc->isPure() || baseFunc->access != func.access)
+                continue;
+            if (std::any_of(classScope->functionList.begin(), classScope->functionList.end(), [&func](const Function& f) { // check for overloads
+                if (&f == &func)
+                    return false;
+                return f.name() == func.name();
+            }))
+                continue;
+            if (func.token->isExpandedMacro() || baseFunc->token->isExpandedMacro())
+                continue;
+            if (baseFunc->functionScope) {
+                bool isSameCode = compareTokenRanges(baseFunc->argDef, baseFunc->argDef->link(), func.argDef, func.argDef->link()); // function arguments
+                if (isSameCode) {
+                    isSameCode = compareTokenRanges(baseFunc->functionScope->bodyStart, baseFunc->functionScope->bodyEnd, // function body
+                                                    func.functionScope->bodyStart, func.functionScope->bodyEnd);
+
+                    if (isSameCode) {
+                        // bailout for shadowed members
+                        if (!classScope->definedType ||
+                            !getDuplInheritedMembersRecursive(classScope->definedType, classScope->definedType, /*skipPrivate*/ false).empty() ||
+                            !getDuplInheritedMemberFunctionsRecursive(classScope->definedType, classScope->definedType, /*skipPrivate*/ false).empty())
+                            continue;
+                        uselessOverrideError(baseFunc, &func, true);
+                        continue;
+                    }
+                }
+            }
+            if (const Token* const call = getSingleFunctionCall(func.functionScope)) {
+                if (call->function() != baseFunc)
+                    continue;
+                if (Token::simpleMatch(call->astParent(), "."))
+                    continue;
+                std::vector<const Token*> callArgs = getArguments(call);
+                if (func.argumentList.size() != callArgs.size() ||
+                    !std::equal(func.argumentList.begin(), func.argumentList.end(), callArgs.begin(), [](const Variable& v, const Token* t) {
+                    return v.nameToken() && v.nameToken()->str() == t->str();
+                }))
                     continue;
-                if (!tok->valueType() || !tok->valueType()->isIntegral())
+                uselessOverrideError(baseFunc, &func);
+            }
+        }
+    }
+}
+
+static const Variable* getSingleReturnVar(const Scope* scope) {
+    if (!scope || !scope->bodyStart)
+        return nullptr;
+    const Token* const start = scope->bodyStart->next();
+    const Token* const end = Token::findsimplematch(start, ";", 1, scope->bodyEnd);
+    if (!end || end->next() != scope->bodyEnd)
+        return nullptr;
+    if (!start->astOperand1() || start->str() != "return")
+        return nullptr;
+    const Token* tok = start->astOperand1();
+    if (tok->str() == ".") {
+        const Token* top = tok->astOperand1();
+        while (Token::Match(top, "[[.]"))
+            top = top->astOperand1();
+        if (!Token::Match(top, "%var%"))
+            return nullptr;
+        tok = tok->astOperand2();
+    }
+    return tok->variable();
+}
+
+void CheckClass::checkReturnByReference()
+{
+    if (!mSettings->severity.isEnabled(Severity::performance) && !mSettings->isPremiumEnabled("returnByReference"))
+        return;
+
+    logChecker("CheckClass::checkReturnByReference"); // performance
+
+    for (const Scope* classScope : mSymbolDatabase->classAndStructScopes) {
+        for (const Function& func : classScope->functionList) {
+            if (Function::returnsPointer(&func) || Function::returnsReference(&func) || Function::returnsStandardType(&func))
+                continue;
+            if (func.isImplicitlyVirtual())
+                continue;
+            if (func.isOperator())
+                continue;
+            if (func.functionPointerUsage)
+                continue;
+            if (const Library::Container* container = mSettings->library.detectContainer(func.retDef))
+                if (container->view)
                     continue;
-                if (!tok->astOperand2())
+            if (!func.isConst() && func.hasRvalRefQualifier())
+                // this method could be used by temporary objects, return by value can be dangerous
+                continue;
+            if (const Variable* var = getSingleReturnVar(func.functionScope)) {
+                if (!var->valueType())
                     continue;
-                const Variable *var = tok->astOperand2()->variable();
-                if (!var || !var->isArgument())
+                if (var->isArgument())
                     continue;
-                unsafeClassDivZeroError(tok, classScope->className, func.name(), var->name());
-                break;
+                const bool isContainer = var->valueType()->type == ValueType::Type::CONTAINER && var->valueType()->container;
+                const bool isView = isContainer && var->valueType()->container->view;
+                bool warn = isContainer && !isView;
+                if (!warn && !isView) {
+                    const std::size_t size = var->valueType()->getSizeOf(*mSettings, ValueType::Accuracy::LowerBound, ValueType::SizeOf::Pointer);
+                    if (size > 2 * mSettings->platform.sizeof_pointer)
+                        warn = true;
+                }
+                if (warn)
+                    returnByReferenceError(&func, var);
             }
         }
     }
 }
 
-void CheckClass::unsafeClassDivZeroError(const Token *tok, const std::string &className, const std::string &methodName, const std::string &varName)
+void CheckClass::returnByReferenceError(const Function* func, const Variable* var)
 {
-    const std::string symbols = "$symbol:" + className + "\n$symbol:" + methodName + "\n$symbol:" + varName + '\n';
-    const std::string s = className + "::" + methodName + "()";
-    reportError(tok, Severity::style, "unsafeClassDivZero", symbols + "Public interface of " + className + " is not safe. When calling " + s + ", if parameter " + varName + " is 0 that leads to division by zero.");
+    const Token* tok = func ? func->tokenDef : nullptr;
+    const std::string message = "Function '" + (func ? func->name() : "func") + "()' should return member '" + (var ? var->name() : "var") + "' by const reference.";
+    reportError(tok, Severity::performance, "returnByReference", message);
 }
 
-void CheckClass::checkOverride()
+void CheckClass::checkThisUseAfterFree()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
-        return;
-    if (mSettings->standards.cpp < Standards::CPP11)
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
+
+    logChecker("CheckClass::checkThisUseAfterFree"); // warning
+
     for (const Scope * classScope : mSymbolDatabase->classAndStructScopes) {
-        if (!classScope->definedType || classScope->definedType->derivedFrom.empty())
-            continue;
-        for (const Function &func : classScope->functionList) {
-            if (func.hasOverrideSpecifier() || func.hasFinalSpecifier())
-                continue;
-            const Function *baseFunc = func.getOverriddenFunction();
-            if (baseFunc)
-                overrideError(baseFunc, &func);
+
+        for (const Variable &var : classScope->varlist) {
+            // Find possible "self pointer".. pointer/smartpointer member variable of "self" type.
+            if (var.valueType() && var.valueType()->smartPointerType != classScope->definedType && var.valueType()->typeScope != classScope) {
+                const ValueType valueType = ValueType::parseDecl(var.typeStartToken(), *mSettings);
+                if (valueType.smartPointerType != classScope->definedType)
+                    continue;
+            }
+
+            // If variable is not static, check that "this" is assigned
+            if (!var.isStatic()) {
+                bool hasAssign = false;
+                for (const Function &func : classScope->functionList) {
+                    if (func.type != FunctionType::eFunction || !func.hasBody())
+                        continue;
+                    for (const Token *tok = func.functionScope->bodyStart; tok != func.functionScope->bodyEnd; tok = tok->next()) {
+                        if (Token::Match(tok, "%varid% = this|shared_from_this", var.declarationId())) {
+                            hasAssign = true;
+                            break;
+                        }
+                    }
+                    if (hasAssign)
+                        break;
+                }
+                if (!hasAssign)
+                    continue;
+            }
+
+            // Check usage of self pointer..
+            for (const Function &func : classScope->functionList) {
+                if (func.type != FunctionType::eFunction || !func.hasBody())
+                    continue;
+
+                const Token * freeToken = nullptr;
+                std::set<const Function *> callstack;
+                checkThisUseAfterFreeRecursive(classScope, &func, &var, std::move(callstack), freeToken);
+            }
         }
     }
 }
 
-void CheckClass::overrideError(const Function *funcInBase, const Function *funcInDerived)
+bool CheckClass::checkThisUseAfterFreeRecursive(const Scope *classScope, const Function *func, const Variable *selfPointer, std::set<const Function *> callstack, const Token *&freeToken)
 {
-    const std::string functionName = funcInDerived ? ((funcInDerived->isDestructor() ? "~" : "") + funcInDerived->name()) : "";
-    const std::string funcType = (funcInDerived && funcInDerived->isDestructor()) ? "destructor" : "function";
+    if (!func || !func->functionScope)
+        return false;
 
-    ErrorPath errorPath;
-    if (funcInBase && funcInDerived) {
-        errorPath.push_back(ErrorPathItem(funcInBase->tokenDef, "Virtual " + funcType + " in base class"));
-        errorPath.push_back(ErrorPathItem(funcInDerived->tokenDef, char(std::toupper(funcType[0])) + funcType.substr(1) + " in derived class"));
+    // avoid recursion
+    if (callstack.count(func))
+        return false;
+    callstack.insert(func);
+
+    const Token * const bodyStart = func->functionScope->bodyStart;
+    const Token * const bodyEnd = func->functionScope->bodyEnd;
+    for (const Token *tok = bodyStart; tok != bodyEnd; tok = tok->next()) {
+        const bool isDestroyed = freeToken != nullptr && !func->isStatic();
+        if (Token::Match(tok, "delete %var% ;") && selfPointer == tok->next()->variable()) {
+            freeToken = tok;
+            tok = tok->tokAt(2);
+        } else if (Token::Match(tok, "%var% . reset ( )") && selfPointer == tok->variable())
+            freeToken = tok;
+        else if (Token::Match(tok->previous(), "!!. %name% (") && tok->function() && tok->function()->nestedIn == classScope && tok->function()->type == FunctionType::eFunction) {
+            if (isDestroyed) {
+                thisUseAfterFree(selfPointer->nameToken(), freeToken, tok);
+                return true;
+            }
+            if (checkThisUseAfterFreeRecursive(classScope, tok->function(), selfPointer, callstack, freeToken))
+                return true;
+        } else if (isDestroyed && Token::Match(tok->previous(), "!!. %name%") && tok->variable() && tok->variable()->scope() == classScope && !tok->variable()->isStatic() && !tok->variable()->isArgument()) {
+            thisUseAfterFree(selfPointer->nameToken(), freeToken, tok);
+            return true;
+        } else if (freeToken && Token::Match(tok, "return|throw")) {
+            // TODO
+            return tok->str() == "throw";
+        } else if (tok->str() == "{" && tok->scope()->type == ScopeType::eLambda) {
+            tok = tok->link();
+        }
     }
+    return false;
+}
 
-    reportError(errorPath, Severity::style, "missingOverride",
-                "$symbol:" + functionName + "\n"
-                "The " + funcType + " '$symbol' overrides a " + funcType + " in a base class but is not marked with a 'override' specifier.",
-                CWE(0U) /* Unknown CWE! */,
-                false);
+void CheckClass::thisUseAfterFree(const Token *self, const Token *free, const Token *use)
+{
+    std::string selfPointer = self ? self->str() : "ptr";
+    ErrorPath errorPath = { ErrorPathItem(self, "Assuming '" + selfPointer + "' is used as 'this'"), ErrorPathItem(free, "Delete '" + selfPointer + "', invalidating 'this'"), ErrorPathItem(use, "Call method when 'this' is invalid") };
+    const std::string usestr = use ? use->str() : "x";
+    const std::string usemsg = use && use->function() ? ("Calling method '" + usestr + "()'") : ("Using member '" + usestr + "'");
+    reportError(std::move(errorPath), Severity::warning, "thisUseAfterFree",
+                "$symbol:" + selfPointer + "\n" +
+                usemsg + " when 'this' might be invalid",
+                CWE(0), Certainty::normal);
 }
 
 void CheckClass::checkUnsafeClassRefMember()
 {
-    if (!mSettings->safeChecks.classes || !mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->safeChecks.classes || !mSettings->severity.isEnabled(Severity::warning))
         return;
+    logChecker("CheckClass::checkUnsafeClassRefMember"); // warning,safeChecks
     for (const Scope * classScope : mSymbolDatabase->classAndStructScopes) {
         for (const Function &func : classScope->functionList) {
             if (!func.hasBody() || !func.isConstructor())
@@ -2696,5 +3623,281 @@ void CheckClass::unsafeClassRefMemberError(const Token *tok, const std::string &
                 "$symbol:" + varname + "\n"
                 "Unsafe class: The const reference member '$symbol' is initialized by a const reference constructor argument. You need to be careful about lifetime issues.\n"
                 "Unsafe class checking: The const reference member '$symbol' is initialized by a const reference constructor argument. You need to be careful about lifetime issues. If you pass a local variable or temporary value in this constructor argument, be extra careful. If the argument is always some global object that is never destroyed then this is safe usage. However it would be defensive to make the member '$symbol' a non-reference variable or a smart pointer.",
-                CWE(0), false);
+                CWE(0), Certainty::normal);
+}
+
+// a Clang-built executable will crash when using the anonymous MyFileInfo later on - so put it in a unique namespace for now
+// see https://trac.cppcheck.net/ticket/12108 for more details
+#ifdef __clang__
+inline namespace CheckClass_internal
+#else
+namespace
+#endif
+{
+    /* multifile checking; one definition rule violations */
+    class MyFileInfo : public Check::FileInfo {
+    public:
+        using Check::FileInfo::FileInfo;
+        struct NameLoc {
+            std::string className;
+            std::string fileName;
+            std::string configuration;
+            int lineNumber;
+            int column;
+            std::size_t hash;
+
+            bool isSameLocation(const NameLoc& other) const {
+                return fileName == other.fileName &&
+                       lineNumber == other.lineNumber &&
+                       column == other.column;
+            }
+        };
+        std::vector<NameLoc> classDefinitions;
+
+        /** Convert data into xml string */
+        std::string toString() const override
+        {
+            std::string ret;
+            for (const NameLoc &nameLoc: classDefinitions) {
+                ret += "<class name=\"" + ErrorLogger::toxml(nameLoc.className) +
+                       "\" file=\"" + ErrorLogger::toxml(nameLoc.fileName) +
+                       "\" configuration=\"" + ErrorLogger::toxml(nameLoc.configuration) +
+                       "\" line=\"" + std::to_string(nameLoc.lineNumber) +
+                       "\" col=\"" + std::to_string(nameLoc.column) +
+                       "\" hash=\"" + std::to_string(nameLoc.hash) +
+                       "\"/>\n";
+            }
+            return ret;
+        }
+    };
+}
+
+Check::FileInfo *CheckClass::getFileInfo(const Tokenizer &tokenizer, const Settings& /*settings*/, const std::string& currentConfig) const
+{
+    if (!tokenizer.isCPP())
+        return nullptr;
+
+    // One definition rule
+    std::vector<MyFileInfo::NameLoc> classDefinitions;
+    for (const Scope * classScope : tokenizer.getSymbolDatabase()->classAndStructScopes) {
+        if (classScope->isAnonymous())
+            continue;
+
+        if (classScope->classDef && Token::simpleMatch(classScope->classDef->previous(), ">"))
+            continue;
+
+        // the full definition must be compared
+        const bool fullDefinition = std::all_of(classScope->functionList.cbegin(),
+                                                classScope->functionList.cend(),
+                                                [](const Function& f) {
+            return f.hasBody();
+        });
+        if (!fullDefinition)
+            continue;
+
+        std::string name;
+        const Scope *scope = classScope;
+        while (scope->isClassOrStruct() && !classScope->className.empty()) {
+            if (Token::Match(scope->classDef, "struct|class %name% :: %name%")) {
+                // TODO handle such classnames
+                name.clear();
+                break;
+            }
+            name = scope->className + "::" + name;
+            scope = scope->nestedIn;
+        }
+        if (name.empty())
+            continue;
+        name.erase(name.size() - 2);
+        if (scope->type != ScopeType::eGlobal)
+            continue;
+
+        MyFileInfo::NameLoc nameLoc;
+        nameLoc.className = std::move(name);
+        nameLoc.fileName = tokenizer.list.file(classScope->classDef);
+        nameLoc.lineNumber = classScope->classDef->linenr();
+        nameLoc.column = classScope->classDef->column();
+
+        // Calculate hash from the full class/struct definition
+        std::string def;
+        for (const Token *tok = classScope->classDef; tok != classScope->bodyEnd; tok = tok->next())
+            def += tok->str();
+        for (const Function &f: classScope->functionList) {
+            if (f.functionScope && f.functionScope->nestedIn != classScope) {
+                for (const Token *tok = f.functionScope->bodyStart; tok != f.functionScope->bodyEnd; tok = tok->next())
+                    def += tok->str();
+            }
+        }
+        nameLoc.hash = std::hash<std::string> {}(def);
+        nameLoc.configuration = currentConfig;
+
+        classDefinitions.push_back(std::move(nameLoc));
+    }
+
+    if (classDefinitions.empty())
+        return nullptr;
+
+    auto *fileInfo = new MyFileInfo(tokenizer.list.getFiles()[0]);
+    fileInfo->classDefinitions.swap(classDefinitions);
+    return fileInfo;
+}
+
+Check::FileInfo * CheckClass::loadFileInfoFromXml(const tinyxml2::XMLElement *xmlElement) const
+{
+    auto *fileInfo = new MyFileInfo;
+    for (const tinyxml2::XMLElement *e = xmlElement->FirstChildElement(); e; e = e->NextSiblingElement()) {
+        if (std::strcmp(e->Name(), "class") != 0)
+            continue;
+        const char *name = e->Attribute("name");
+        const char *file = e->Attribute("file");
+        const char *configuration = e->Attribute("configuration");
+        const char *line = e->Attribute("line");
+        const char *col = e->Attribute("col");
+        const char *hash = e->Attribute("hash");
+        if (name && file && configuration && line && col && hash) {
+            MyFileInfo::NameLoc nameLoc;
+            nameLoc.className = name;
+            nameLoc.fileName = file;
+            nameLoc.configuration = configuration;
+            nameLoc.lineNumber = strToInt<int>(line);
+            nameLoc.column = strToInt<int>(col);
+            nameLoc.hash = strToInt<std::size_t>(hash);
+            fileInfo->classDefinitions.push_back(std::move(nameLoc));
+        }
+    }
+    if (fileInfo->classDefinitions.empty()) {
+        delete fileInfo;
+        fileInfo = nullptr;
+    }
+    return fileInfo;
+}
+
+bool CheckClass::analyseWholeProgram(const CTU::FileInfo &ctu, const std::list<Check::FileInfo*> &fileInfo, const Settings& settings, ErrorLogger &errorLogger)
+{
+    (void)ctu;
+    (void)settings;
+
+    CheckClass dummy(nullptr, &settings, &errorLogger);
+    dummy.
+    logChecker("CheckClass::analyseWholeProgram");
+
+    if (fileInfo.empty())
+        return false;
+
+    bool foundErrors = false;
+
+    std::unordered_map<std::string, MyFileInfo::NameLoc> all;
+
+    for (const Check::FileInfo* fi1 : fileInfo) {
+        const auto *fi = dynamic_cast<const MyFileInfo*>(fi1);
+        if (!fi)
+            continue;
+        for (const MyFileInfo::NameLoc &nameLoc : fi->classDefinitions) {
+            auto it = all.find(nameLoc.className);
+            if (it == all.end()) {
+                all[nameLoc.className] = nameLoc;
+                continue;
+            }
+            if (it->second.hash == nameLoc.hash)
+                continue;
+            if (it->second.fileName == nameLoc.fileName && it->second.configuration != nameLoc.configuration)
+                continue;
+            // Same location, sometimes the hash is different wrongly (possibly because of different token simplifications).
+            if (it->second.isSameLocation(nameLoc))
+                continue;
+
+            std::list<ErrorMessage::FileLocation> locationList;
+            locationList.emplace_back(nameLoc.fileName, nameLoc.lineNumber, nameLoc.column);
+            locationList.emplace_back(it->second.fileName, it->second.lineNumber, it->second.column);
+
+            const ErrorMessage errmsg(std::move(locationList),
+                                      fi->file0,
+                                      Severity::error,
+                                      "$symbol:" + nameLoc.className +
+                                      "\nThe one definition rule is violated, different classes/structs have the same name '$symbol'",
+                                      "ctuOneDefinitionRuleViolation",
+                                      CWE_ONE_DEFINITION_RULE,
+                                      Certainty::normal);
+            errorLogger.reportErr(errmsg);
+
+            foundErrors = true;
+        }
+    }
+    return foundErrors;
+}
+
+void CheckClass::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    if (tokenizer.isC())
+        return;
+
+    CheckClass checkClass(&tokenizer, &tokenizer.getSettings(), errorLogger);
+
+    // can't be a simplified check .. the 'sizeof' is used.
+    checkClass.checkMemset();
+    checkClass.constructors();
+    checkClass.privateFunctions();
+    checkClass.operatorEqRetRefThis();
+    checkClass.thisSubtraction();
+    checkClass.operatorEqToSelf();
+    checkClass.initializerListOrder();
+    checkClass.initializationListUsage();
+    checkClass.checkSelfInitialization();
+    checkClass.virtualDestructor();
+    checkClass.checkConst();
+    checkClass.copyconstructors();
+    checkClass.checkVirtualFunctionCallInConstructor();
+    checkClass.checkDuplInheritedMembers();
+    checkClass.checkExplicitConstructors();
+    checkClass.checkCopyCtorAndEqOperator();
+    checkClass.checkOverride();
+    checkClass.checkUselessOverride();
+    checkClass.checkReturnByReference();
+    checkClass.checkThisUseAfterFree();
+    checkClass.checkUnsafeClassRefMember();
+}
+
+void CheckClass::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const
+{
+    CheckClass c(nullptr, settings, errorLogger);
+    c.noConstructorError(nullptr, "classname", false);
+    c.noExplicitConstructorError(nullptr, "classname", false);
+    //c.copyConstructorMallocError(nullptr, 0, "var");
+    c.copyConstructorShallowCopyError(nullptr, "var");
+    c.noCopyConstructorError(nullptr, false, nullptr, false);
+    c.noOperatorEqError(nullptr, false, nullptr, false);
+    c.noDestructorError(nullptr, false, nullptr);
+    c.uninitVarError(nullptr, false, FunctionType::eConstructor, "classname", "varname", false, false);
+    c.uninitVarError(nullptr, true, FunctionType::eConstructor, "classname", "varnamepriv", false, false);
+    c.uninitVarError(nullptr, false, FunctionType::eConstructor, "classname", "varname", true, false);
+    c.uninitVarError(nullptr, true, FunctionType::eConstructor, "classname", "varnamepriv", true, false);
+    c.missingMemberCopyError(nullptr, FunctionType::eConstructor, "classname", "varnamepriv");
+    c.operatorEqVarError(nullptr, "classname", "", false);
+    c.unusedPrivateFunctionError(nullptr, nullptr, "classname", "funcname");
+    c.memsetError(nullptr, "memfunc", "classname", "class");
+    c.memsetErrorReference(nullptr, "memfunc", "class");
+    c.memsetErrorFloat(nullptr, "class");
+    c.mallocOnClassWarning(nullptr, "malloc", nullptr);
+    c.mallocOnClassError(nullptr, "malloc", nullptr, "std::string");
+    c.virtualDestructorError(nullptr, "Base", "Derived", false);
+    c.thisSubtractionError(nullptr);
+    c.operatorEqRetRefThisError(nullptr);
+    c.operatorEqMissingReturnStatementError(nullptr, true);
+    c.operatorEqShouldBeLeftUnimplementedError(nullptr);
+    c.operatorEqToSelfError(nullptr);
+    c.checkConstError(nullptr, "class", "function", false);
+    c.checkConstError(nullptr, "class", "function", true);
+    c.initializerListError(nullptr, nullptr, "class", "variable");
+    c.suggestInitializationList(nullptr, "variable");
+    c.selfInitializationError(nullptr, "var");
+    c.duplInheritedMembersError(nullptr, nullptr, "class", "class", "variable", false, false);
+    c.copyCtorAndEqOperatorError(nullptr, "class", false, false);
+    c.overrideError(nullptr, nullptr);
+    c.uselessOverrideError(nullptr, nullptr);
+    c.returnByReferenceError(nullptr, nullptr);
+    c.pureVirtualFunctionCallInConstructorError(nullptr, std::list<const Token *>(), "f");
+    c.virtualFunctionCallInConstructorError(nullptr, std::list<const Token *>(), "f");
+    c.thisUseAfterFree(nullptr, nullptr, nullptr);
+    c.unsafeClassRefMemberError(nullptr, "UnsafeClass::var");
+    // TODO: ctuOneDefinitionRuleViolation
 }
diff --git a/lib/checkclass.h b/lib/checkclass.h
index 477105383be..9a2d42442a9 100644
--- a/lib/checkclass.h
+++ b/lib/checkclass.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,8 +23,8 @@
 
 #include "check.h"
 #include "config.h"
-#include "tokenize.h"
 
+#include <cstdint>
 #include <list>
 #include <map>
 #include <set>
@@ -32,11 +32,15 @@
 #include <vector>
 
 class ErrorLogger;
-class Function;
-class Scope;
 class Settings;
-class SymbolDatabase;
+class Tokenizer;
 class Token;
+class Scope;
+class SymbolDatabase;
+class Function;
+class Variable;
+class Type;
+enum class FunctionType : std::uint8_t;
 
 /// @addtogroup Checks
 /// @{
@@ -44,43 +48,23 @@ class Token;
 
 /** @brief %Check classes. Uninitialized member variables, non-conforming operators, missing virtual destructor, etc */
 class CPPCHECKLIB CheckClass : public Check {
+    friend class TestClass;
+    friend class TestConstructors;
+    friend class TestUnusedPrivateFunction;
+
 public:
     /** @brief This constructor is used when registering the CheckClass */
-    CheckClass() : Check(myName()), mSymbolDatabase(nullptr) {
-    }
+    CheckClass() : Check(myName()) {}
+
+    /** @brief Set of the STL types whose operator[] is not const */
+    static const std::set<std::string> stl_containers_not_const;
 
+private:
     /** @brief This constructor is used when running checks. */
     CheckClass(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger);
 
     /** @brief Run checks on the normal token list */
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        if (tokenizer->isC())
-            return;
-
-        CheckClass checkClass(tokenizer, settings, errorLogger);
-
-        // can't be a simplified check .. the 'sizeof' is used.
-        checkClass.checkMemset();
-        checkClass.checkUnsafeClassDivZero();
-        checkClass.constructors();
-        checkClass.operatorEq();
-        checkClass.privateFunctions();
-        checkClass.operatorEqRetRefThis();
-        checkClass.thisSubtraction();
-        checkClass.operatorEqToSelf();
-        checkClass.initializerListOrder();
-        checkClass.initializationListUsage();
-        checkClass.checkSelfInitialization();
-        checkClass.virtualDestructor();
-        checkClass.checkConst();
-        checkClass.copyconstructors();
-        checkClass.checkVirtualFunctionCallInConstructor();
-        checkClass.checkDuplInheritedMembers();
-        checkClass.checkExplicitConstructors();
-        checkClass.checkCopyCtorAndEqOperator();
-        checkClass.checkOverride();
-        checkClass.checkUnsafeClassRefMember();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     /** @brief %Check that all class constructors are ok */
     void constructors();
@@ -103,9 +87,6 @@ class CPPCHECKLIB CheckClass : public Check {
     void checkMemset();
     void checkMemsetType(const Scope *start, const Token *tok, const Scope *type, bool allocation, std::set<const Scope *> parsedTypes);
 
-    /** @brief 'operator=' should return something and it should not be const. */
-    void operatorEq();
-
     /** @brief 'operator=' should return reference to *this */
     void operatorEqRetRefThis();    // Warning upon no "return *this;"
 
@@ -141,17 +122,30 @@ class CPPCHECKLIB CheckClass : public Check {
     /** @brief Check that copy constructor and operator defined together */
     void checkCopyCtorAndEqOperator();
 
-    /** @brief Check that arbitrary usage of the public interface does not result in division by zero */
-    void checkUnsafeClassDivZero(bool test=false);
-
     /** @brief Check that the override keyword is used when overriding virtual functions */
     void checkOverride();
 
+    /** @brief Check that the overriden function is not identical to the base function */
+    void checkUselessOverride();
+
+    /** @brief Check that large members are returned by reference from getter function */
+    void checkReturnByReference();
+
+    /** @brief When "self pointer" is destroyed, 'this' might become invalid. */
+    void checkThisUseAfterFree();
+
     /** @brief Unsafe class check - const reference member */
     void checkUnsafeClassRefMember();
 
-private:
-    const SymbolDatabase *mSymbolDatabase;
+    /** @brief Parse current TU and extract file info */
+    Check::FileInfo *getFileInfo(const Tokenizer &tokenizer, const Settings &settings, const std::string& currentConfig) const override;
+
+    Check::FileInfo * loadFileInfoFromXml(const tinyxml2::XMLElement *xmlElement) const override;
+
+    /** @brief Analyse all file infos for all TU */
+    bool analyseWholeProgram(const CTU::FileInfo &ctu, const std::list<Check::FileInfo*> &fileInfo, const Settings& settings, ErrorLogger &errorLogger) override;
+
+    const SymbolDatabase* mSymbolDatabase{};
 
     // Reporting errors..
     void noConstructorError(const Token *tok, const std::string &classname, bool isStruct);
@@ -161,78 +155,45 @@ class CPPCHECKLIB CheckClass : public Check {
     void noCopyConstructorError(const Scope *scope, bool isdefault, const Token *alloc, bool inconclusive);
     void noOperatorEqError(const Scope *scope, bool isdefault, const Token *alloc, bool inconclusive);
     void noDestructorError(const Scope *scope, bool isdefault, const Token *alloc);
-    void uninitVarError(const Token *tok, bool isprivate, const std::string &classname, const std::string &varname, bool inconclusive);
+    void uninitVarError(const Token *tok, bool isprivate, FunctionType functionType, const std::string &classname, const std::string &varname, bool derived, bool inconclusive);
+    void uninitVarError(const Token *tok, const std::string &classname, const std::string &varname);
+    void missingMemberCopyError(const Token *tok, FunctionType functionType, const std::string& classname, const std::string& varname);
     void operatorEqVarError(const Token *tok, const std::string &classname, const std::string &varname, bool inconclusive);
-    void unusedPrivateFunctionError(const Token *tok, const std::string &classname, const std::string &funcname);
-    void memsetError(const Token *tok, const std::string &memfunc, const std::string &classname, const std::string &type);
+    void unusedPrivateFunctionError(const Token *tok1, const Token *tok2, const std::string &classname, const std::string &funcname);
+    void memsetError(const Token *tok, const std::string &memfunc, const std::string &classname, const std::string &type, bool isContainer = false);
     void memsetErrorReference(const Token *tok, const std::string &memfunc, const std::string &type);
     void memsetErrorFloat(const Token *tok, const std::string &type);
     void mallocOnClassError(const Token* tok, const std::string &memfunc, const Token* classTok, const std::string &classname);
     void mallocOnClassWarning(const Token* tok, const std::string &memfunc, const Token* classTok);
-    void operatorEqReturnError(const Token *tok, const std::string &className);
     void virtualDestructorError(const Token *tok, const std::string &Base, const std::string &Derived, bool inconclusive);
     void thisSubtractionError(const Token *tok);
     void operatorEqRetRefThisError(const Token *tok);
     void operatorEqShouldBeLeftUnimplementedError(const Token *tok);
     void operatorEqMissingReturnStatementError(const Token *tok, bool error);
     void operatorEqToSelfError(const Token *tok);
-    void checkConstError(const Token *tok, const std::string &classname, const std::string &funcname, bool suggestStatic);
-    void checkConstError2(const Token *tok1, const Token *tok2, const std::string &classname, const std::string &funcname, bool suggestStatic);
-    void initializerListError(const Token *tok1,const Token *tok2, const std::string & classname, const std::string &varname);
+    void checkConstError(const Token *tok, const std::string &classname, const std::string &funcname, bool suggestStatic, bool foundAllBaseClasses = true);
+    void checkConstError2(const Token *tok1, const Token *tok2, const std::string &classname, const std::string &funcname, bool suggestStatic, bool foundAllBaseClasses = true);
+    void initializerListError(const Token *tok1,const Token *tok2, const std::string & classname, const std::string &varname, const std::string& argname = {});
     void suggestInitializationList(const Token *tok, const std::string& varname);
     void selfInitializationError(const Token* tok, const std::string& varname);
     void pureVirtualFunctionCallInConstructorError(const Function * scopeFunction, const std::list<const Token *> & tokStack, const std::string &purefuncname);
     void virtualFunctionCallInConstructorError(const Function * scopeFunction, const std::list<const Token *> & tokStack, const std::string &funcname);
-    void duplInheritedMembersError(const Token* tok1, const Token* tok2, const std::string &derivedName, const std::string &baseName, const std::string &variableName, bool derivedIsStruct, bool baseIsStruct);
+    void duplInheritedMembersError(const Token* tok1, const Token* tok2, const std::string &derivedName, const std::string &baseName, const std::string &memberName, bool derivedIsStruct, bool baseIsStruct, bool isFunction = false);
     void copyCtorAndEqOperatorError(const Token *tok, const std::string &classname, bool isStruct, bool hasCopyCtor);
-    void unsafeClassDivZeroError(const Token *tok, const std::string &className, const std::string &methodName, const std::string &varName);
     void overrideError(const Function *funcInBase, const Function *funcInDerived);
+    void uselessOverrideError(const Function *funcInBase, const Function *funcInDerived, bool isSameCode = false);
+    void returnByReferenceError(const Function *func, const Variable* var);
+    void thisUseAfterFree(const Token *self, const Token *free, const Token *use);
     void unsafeClassRefMemberError(const Token *tok, const std::string &varname);
+    void checkDuplInheritedMembersRecursive(const Type* typeCurrent, const Type* typeBase);
 
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        CheckClass c(nullptr, settings, errorLogger);
-        c.noConstructorError(nullptr, "classname", false);
-        c.noExplicitConstructorError(nullptr, "classname", false);
-        //c.copyConstructorMallocError(nullptr, 0, "var");
-        c.copyConstructorShallowCopyError(nullptr, "var");
-        c.noCopyConstructorError(nullptr, false, nullptr, false);
-        c.noOperatorEqError(nullptr, false, nullptr, false);
-        c.noDestructorError(nullptr, false, nullptr);
-        c.uninitVarError(nullptr, false, "classname", "varname", false);
-        c.uninitVarError(nullptr, true, "classname", "varnamepriv", false);
-        c.operatorEqVarError(nullptr, "classname", emptyString, false);
-        c.unusedPrivateFunctionError(nullptr, "classname", "funcname");
-        c.memsetError(nullptr, "memfunc", "classname", "class");
-        c.memsetErrorReference(nullptr, "memfunc", "class");
-        c.memsetErrorFloat(nullptr, "class");
-        c.mallocOnClassWarning(nullptr, "malloc", nullptr);
-        c.mallocOnClassError(nullptr, "malloc", nullptr, "std::string");
-        c.operatorEqReturnError(nullptr, "class");
-        c.virtualDestructorError(nullptr, "Base", "Derived", false);
-        c.thisSubtractionError(nullptr);
-        c.operatorEqRetRefThisError(nullptr);
-        c.operatorEqMissingReturnStatementError(nullptr, true);
-        c.operatorEqShouldBeLeftUnimplementedError(nullptr);
-        c.operatorEqToSelfError(nullptr);
-        c.checkConstError(nullptr, "class", "function", false);
-        c.checkConstError(nullptr, "class", "function", true);
-        c.initializerListError(nullptr, nullptr, "class", "variable");
-        c.suggestInitializationList(nullptr, "variable");
-        c.selfInitializationError(nullptr, "var");
-        c.duplInheritedMembersError(nullptr, nullptr, "class", "class", "variable", false, false);
-        c.copyCtorAndEqOperatorError(nullptr, "class", false, false);
-        c.unsafeClassDivZeroError(nullptr, "Class", "dostuff", "x");
-        c.pureVirtualFunctionCallInConstructorError(nullptr, std::list<const Token *>(), "f");
-        c.virtualFunctionCallInConstructorError(nullptr, std::list<const Token *>(), "f");
-        c.overrideError(nullptr, nullptr);
-        c.unsafeClassRefMemberError(nullptr, "UnsafeClass::var");
-    }
+    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const override;
 
     static std::string myName() {
         return "Class";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Check the code for each class.\n"
                "- Missing constructors and copy constructors\n"
                //"- Missing allocation of memory in copy constructor\n"
@@ -243,7 +204,6 @@ class CPPCHECKLIB CheckClass : public Check {
                "- Warn if memory for classes is allocated with malloc()\n"
                "- If it's a base class, check that the destructor is virtual\n"
                "- Are there unused private functions?\n"
-               "- 'operator=' should return reference to self\n"
                "- 'operator=' should check for assignment to self\n"
                "- Constness for member functions\n"
                "- Order of initializations\n"
@@ -254,7 +214,9 @@ class CPPCHECKLIB CheckClass : public Check {
                "- Duplicated inherited data members\n"
                // disabled for now "- If 'copy constructor' defined, 'operator=' also should be defined and vice versa\n"
                "- Check that arbitrary usage of public interface does not result in division by zero\n"
-               "- Check that the 'override' keyword is used when overriding virtual functions\n";
+               "- Delete \"self pointer\" and then access 'this'\n"
+               "- Check that the 'override' keyword is used when overriding virtual functions\n"
+               "- Check that the 'one definition rule' is not violated\n";
     }
 
     // operatorEqRetRefThis helper functions
@@ -263,55 +225,83 @@ class CPPCHECKLIB CheckClass : public Check {
 
     // operatorEqToSelf helper functions
     bool hasAllocation(const Function *func, const Scope* scope) const;
-    static bool hasAssignSelf(const Function *func, const Token *rhs);
+    bool hasAllocation(const Function *func, const Scope* scope, const Token *start, const Token *end) const;
+    bool hasAllocationInIfScope(const Function *func, const Scope* scope, const Token *ifStatementScopeStart) const;
+    static bool hasAssignSelf(const Function *func, const Token *rhs, const Token *&out_ifStatementScopeStart);
+    enum class Bool : std::uint8_t { True, False, Bailout };
+    static Bool isInverted(const Token *tok, const Token *rhs);
+    static const Token * getIfStmtBodyStart(const Token *tok, const Token *rhs);
 
     // checkConst helper functions
     bool isMemberVar(const Scope *scope, const Token *tok) const;
-    bool isMemberFunc(const Scope *scope, const Token *tok) const;
-    bool isConstMemberFunc(const Scope *scope, const Token *tok) const;
-    bool checkConstFunc(const Scope *scope, const Function *func, bool& memberAccessed) const;
+    static bool isMemberFunc(const Scope *scope, const Token *tok);
+    static bool isConstMemberFunc(const Scope *scope, const Token *tok);
+    enum class MemberAccess : std::uint8_t { NONE, SELF, MEMBER };
+    bool checkConstFunc(const Scope *scope, const Function *func, MemberAccess& memberAccessed) const;
 
     // constructors helper function
     /** @brief Information about a member variable. Used when checking for uninitialized variables */
     struct Usage {
-        Usage() : assign(false), init(false) { }
+        explicit Usage(const Variable *var) : var(var) {}
+
+        /** Variable that this usage is for */
+        const Variable *var;
 
         /** @brief has this variable been assigned? */
-        bool assign;
+        bool assign{};
 
         /** @brief has this variable been initialized? */
-        bool init;
+        bool init{};
     };
 
-    static bool isBaseClassFunc(const Token *tok, const Scope *scope);
+    static bool isBaseClassMutableMemberFunc(const Token *tok, const Scope *scope);
+
+    /**
+     * @brief Create usage list that contains all scope members and also members
+     * of base classes without constructors.
+     * @param scope current class scope
+     */
+    static std::vector<Usage> createUsageList(const Scope *scope);
 
     /**
      * @brief assign a variable in the varlist
+     * @param usageList reference to usage vector
      * @param varid id of variable to mark assigned
-     * @param scope pointer to variable Scope
-     * @param usage reference to usage vector
      */
-    static void assignVar(nonneg int varid, const Scope *scope, std::vector<Usage> &usage);
+    static void assignVar(std::vector<Usage> &usageList, nonneg int varid);
+
+    /**
+     * @brief assign a variable in the varlist
+     * @param usageList reference to usage vector
+     * @param vartok variable token
+     */
+    static void assignVar(std::vector<Usage> &usageList, const Token *vartok);
 
     /**
      * @brief initialize a variable in the varlist
+     * @param usageList reference to usage vector
      * @param varid id of variable to mark initialized
-     * @param scope pointer to variable Scope
-     * @param usage reference to usage vector
      */
-    static void initVar(nonneg int varid, const Scope *scope, std::vector<Usage> &usage);
+    static void initVar(std::vector<Usage> &usageList, nonneg int varid);
 
     /**
      * @brief set all variables in list assigned
-     * @param usage reference to usage vector
+     * @param usageList reference to usage vector
+     */
+    static void assignAllVar(std::vector<Usage> &usageList);
+
+    /**
+     * @brief set all variable in list assigned, if visible from given scope
+     * @param usageList reference to usage vector
+     * @param scope scope from which usages must be visible
      */
-    static void assignAllVar(std::vector<Usage> &usage);
+    static void assignAllVarsVisibleFromScope(std::vector<Usage> &usageList, const Scope *scope);
 
     /**
      * @brief set all variables in list not assigned and not initialized
-     * @param usage reference to usage vector
+     * @param usageList reference to usage vector
      */
-    static void clearAllVar(std::vector<Usage> &usage);
+    static void clearAllVar(std::vector<Usage> &usageList);
 
     /**
      * @brief parse a scope for a constructor or member function and set the "init" flags in the provided varlist
@@ -320,7 +310,7 @@ class CPPCHECKLIB CheckClass : public Check {
      * @param scope pointer to variable Scope
      * @param usage reference to usage vector
      */
-    void initializeVarList(const Function &func, std::list<const Function *> &callstack, const Scope *scope, std::vector<Usage> &usage);
+    void initializeVarList(const Function &func, std::list<const Function *> &callstack, const Scope *scope, std::vector<Usage> &usage) const;
 
     /**
      * @brief gives a list of tokens where virtual functions are called directly or indirectly
@@ -330,7 +320,7 @@ class CPPCHECKLIB CheckClass : public Check {
      */
     const std::list<const Token *> & getVirtualFunctionCalls(
         const Function & function,
-        std::map<const Function *, std::list<const Token *> > & virtualFunctionCallsMap);
+        std::map<const Function *, std::list<const Token *>> & virtualFunctionCallsMap);
 
     /**
      * @brief looks for the first virtual function call stack
@@ -338,14 +328,19 @@ class CPPCHECKLIB CheckClass : public Check {
      * @param callToken token where pure virtual function is called directly or indirectly
      * @param[in,out] pureFuncStack list to append the stack
      */
-    void getFirstVirtualFunctionCallStack(
-        std::map<const Function *, std::list<const Token *> > & virtualFunctionCallsMap,
+    static void getFirstVirtualFunctionCallStack(
+        std::map<const Function *, std::list<const Token *>> & virtualFunctionCallsMap,
         const Token *callToken,
         std::list<const Token *> & pureFuncStack);
 
     static bool canNotCopy(const Scope *scope);
 
     static bool canNotMove(const Scope *scope);
+
+    /**
+     * @brief Helper for checkThisUseAfterFree
+     */
+    bool checkThisUseAfterFreeRecursive(const Scope *classScope, const Function *func, const Variable *selfPointer, std::set<const Function *> callstack, const Token *&freeToken);
 };
 /// @}
 //---------------------------------------------------------------------------
diff --git a/lib/checkcondition.cpp b/lib/checkcondition.cpp
index 64d5ca2cb64..14fa900944d 100644
--- a/lib/checkcondition.cpp
+++ b/lib/checkcondition.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,26 +23,32 @@
 #include "checkcondition.h"
 
 #include "astutils.h"
-#include "errorlogger.h"
+#include "library.h"
+#include "platform.h"
 #include "settings.h"
 #include "symboldatabase.h"
 #include "token.h"
 #include "tokenize.h"
-#include "valueflow.h"
+#include "utils.h"
+#include "vfvalue.h"
+
+#include "checkother.h" // comparisonNonZeroExpressionLessThanZero and testIfNonZeroExpressionIsPositive
 
 #include <algorithm>
-#include <cstddef>
+#include <cstdint>
+#include <initializer_list>
 #include <limits>
 #include <list>
-#include <ostream>
 #include <set>
-#include <stack>
+#include <sstream>
 #include <utility>
+#include <vector>
 
 // CWE ids used
-static const struct CWE CWE398(398U);   // Indicator of Poor Code Quality
-static const struct CWE CWE570(570U);   // Expression is Always False
-static const struct CWE CWE571(571U);   // Expression is Always True
+static const CWE uncheckedErrorConditionCWE(391U);
+static const CWE CWE398(398U);   // Indicator of Poor Code Quality
+static const CWE CWE570(570U);   // Expression is Always False
+static const CWE CWE571(571U);   // Expression is Always True
 
 //---------------------------------------------------------------------------
 
@@ -55,7 +61,16 @@ bool CheckCondition::diag(const Token* tok, bool insert)
 {
     if (!tok)
         return false;
-    if (mCondDiags.find(tok) == mCondDiags.end()) {
+    const Token* parent = tok->astParent();
+    bool hasParent = false;
+    while (Token::Match(parent, "!|&&|%oror%")) {
+        if (mCondDiags.count(parent) != 0) {
+            hasParent = true;
+            break;
+        }
+        parent = parent->astParent();
+    }
+    if (mCondDiags.count(tok) == 0 && !hasParent) {
         if (insert)
             mCondDiags.insert(tok);
         return false;
@@ -63,6 +78,13 @@ bool CheckCondition::diag(const Token* tok, bool insert)
     return true;
 }
 
+bool CheckCondition::diag(const Token* tok1, const Token* tok2)
+{
+    const bool b1 = diag(tok1);
+    const bool b2 = diag(tok2);
+    return b1 && b2;
+}
+
 bool CheckCondition::isAliased(const std::set<int> &vars) const
 {
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
@@ -74,9 +96,11 @@ bool CheckCondition::isAliased(const std::set<int> &vars) const
 
 void CheckCondition::assignIf()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("assignIfError"))
         return;
 
+    logChecker("CheckCondition::assignIf"); // style
+
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
         if (tok->str() != "=")
             continue;
@@ -91,7 +115,7 @@ void CheckCondition::assignIf()
 
             if (Token::Match(tok->next(), "%num% [&|]")) {
                 bitop = tok->strAt(2).at(0);
-                num = MathLib::toLongNumber(tok->next()->str());
+                num = MathLib::toBigNumber(tok->tokAt(1));
             } else {
                 const Token *endToken = Token::findsimplematch(tok, ";");
 
@@ -101,7 +125,7 @@ void CheckCondition::assignIf()
 
                 if (endToken && Token::Match(endToken->tokAt(-2), "[&|] %num% ;")) {
                     bitop = endToken->strAt(-2).at(0);
-                    num = MathLib::toLongNumber(endToken->previous()->str());
+                    num = MathLib::toBigNumber(endToken->tokAt(-1));
                 }
             }
 
@@ -154,7 +178,7 @@ bool CheckCondition::assignIfParseScope(const Token * const assignTok,
 
     for (const Token *tok2 = startTok; tok2; tok2 = tok2->next()) {
         if ((bitop == '&') && Token::Match(tok2->tokAt(2), "%varid% %cop% %num% ;", varid) && tok2->strAt(3) == std::string(1U, bitop)) {
-            const MathLib::bigint num2 = MathLib::toLongNumber(tok2->strAt(4));
+            const MathLib::bigint num2 = MathLib::toBigNumber(tok2->tokAt(4));
             if (0 == (num & num2))
                 mismatchingBitAndError(assignTok, num, tok2, num2);
         }
@@ -162,7 +186,7 @@ bool CheckCondition::assignIfParseScope(const Token * const assignTok,
             return true;
         }
         if (bitop == '&' && Token::Match(tok2, "%varid% &= %num% ;", varid)) {
-            const MathLib::bigint num2 = MathLib::toLongNumber(tok2->strAt(2));
+            const MathLib::bigint num2 = MathLib::toBigNumber(tok2->tokAt(2));
             if (0 == (num & num2))
                 mismatchingBitAndError(assignTok, num, tok2, num2);
         }
@@ -176,7 +200,7 @@ bool CheckCondition::assignIfParseScope(const Token * const assignTok,
             ret = true;
         if (ret && tok2->str() == ";")
             return false;
-        if (!islocal && Token::Match(tok2, "%name% (") && !Token::simpleMatch(tok2->next()->link(), ") {"))
+        if (!islocal && Token::Match(tok2, "%name% (") && !Token::simpleMatch(tok2->linkAt(1), ") {"))
             return true;
         if (Token::Match(tok2, "if|while (")) {
             if (!islocal && tok2->str() == "while")
@@ -185,19 +209,19 @@ bool CheckCondition::assignIfParseScope(const Token * const assignTok,
                 // is variable changed in loop?
                 const Token *bodyStart = tok2->linkAt(1)->next();
                 const Token *bodyEnd   = bodyStart ? bodyStart->link() : nullptr;
-                if (!bodyEnd || bodyEnd->str() != "}" || isVariableChanged(bodyStart, bodyEnd, varid, !islocal, mSettings, mTokenizer->isCPP()))
+                if (!bodyEnd || bodyEnd->str() != "}" || isVariableChanged(bodyStart, bodyEnd, varid, !islocal, *mSettings))
                     continue;
             }
 
             // parse condition
-            const Token * const end = tok2->next()->link();
+            const Token * const end = tok2->linkAt(1);
             for (; tok2 != end; tok2 = tok2->next()) {
                 if (Token::Match(tok2, "[(,] &| %varid% [,)]", varid)) {
                     return true;
                 }
                 if (Token::Match(tok2,"&&|%oror%|( %varid% ==|!= %num% &&|%oror%|)", varid)) {
                     const Token *vartok = tok2->next();
-                    const MathLib::bigint num2 = MathLib::toLongNumber(vartok->strAt(2));
+                    const MathLib::bigint num2 = MathLib::toBigNumber(vartok->tokAt(2));
                     if ((num & num2) != ((bitop=='&') ? num2 : num)) {
                         const std::string& op(vartok->strAt(1));
                         const bool alwaysTrue = op == "!=";
@@ -212,8 +236,8 @@ bool CheckCondition::assignIfParseScope(const Token * const assignTok,
 
             const bool ret1 = assignIfParseScope(assignTok, end->tokAt(2), varid, islocal, bitop, num);
             bool ret2 = false;
-            if (Token::simpleMatch(end->next()->link(), "} else {"))
-                ret2 = assignIfParseScope(assignTok, end->next()->link()->tokAt(3), varid, islocal, bitop, num);
+            if (Token::simpleMatch(end->linkAt(1), "} else {"))
+                ret2 = assignIfParseScope(assignTok, end->linkAt(1)->tokAt(3), varid, islocal, bitop, num);
             if (ret1 || ret2)
                 return true;
         }
@@ -229,7 +253,7 @@ void CheckCondition::assignIfError(const Token *tok1, const Token *tok2, const s
     reportError(locations,
                 Severity::style,
                 "assignIfError",
-                "Mismatching assignment and comparison, comparison '" + condition + "' is always " + std::string(result ? "true" : "false") + ".", CWE398, false);
+                "Mismatching assignment and comparison, comparison '" + condition + "' is always " + std::string(bool_to_string(result)) + ".", CWE398, Certainty::normal);
 }
 
 
@@ -244,18 +268,18 @@ void CheckCondition::mismatchingBitAndError(const Token *tok1, const MathLib::bi
     reportError(locations,
                 Severity::style,
                 "mismatchingBitAnd",
-                msg.str(), CWE398, false);
+                msg.str(), CWE398, Certainty::normal);
 }
 
 
 static void getnumchildren(const Token *tok, std::list<MathLib::bigint> &numchildren)
 {
     if (tok->astOperand1() && tok->astOperand1()->isNumber())
-        numchildren.push_back(MathLib::toLongNumber(tok->astOperand1()->str()));
+        numchildren.push_back(MathLib::toBigNumber(tok->astOperand1()));
     else if (tok->astOperand1() && tok->str() == tok->astOperand1()->str())
         getnumchildren(tok->astOperand1(), numchildren);
     if (tok->astOperand2() && tok->astOperand2()->isNumber())
-        numchildren.push_back(MathLib::toLongNumber(tok->astOperand2()->str()));
+        numchildren.push_back(MathLib::toBigNumber(tok->astOperand2()));
     else if (tok->astOperand2() && tok->str() == tok->astOperand2()->str())
         getnumchildren(tok->astOperand2(), numchildren);
 }
@@ -266,7 +290,7 @@ static bool inBooleanFunction(const Token *tok)
     const Scope *scope = tok ? tok->scope() : nullptr;
     while (scope && scope->isLocal())
         scope = scope->nestedIn;
-    if (scope && scope->type == Scope::eFunction) {
+    if (scope && scope->type == ScopeType::eFunction) {
         const Function *func = scope->function;
         if (func) {
             const Token *ret = func->retDef;
@@ -278,11 +302,24 @@ static bool inBooleanFunction(const Token *tok)
     return false;
 }
 
+static bool isOperandExpanded(const Token *tok)
+{
+    if (tok->isExpandedMacro() || tok->isEnumerator())
+        return true;
+    if (tok->astOperand1() && isOperandExpanded(tok->astOperand1()))
+        return true;
+    if (tok->astOperand2() && isOperandExpanded(tok->astOperand2()))
+        return true;
+    return false;
+}
+
 void CheckCondition::checkBadBitmaskCheck()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("badBitmaskCheck"))
         return;
 
+    logChecker("CheckCondition::checkBadBitmaskCheck"); // style
+
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
         if (tok->str() == "|" && tok->astOperand1() && tok->astOperand2() && tok->astParent()) {
             const Token* parent = tok->astParent();
@@ -292,25 +329,45 @@ void CheckCondition::checkBadBitmaskCheck()
                                    (parent->str() == "(" && Token::Match(parent->astOperand1(), "if|while")) ||
                                    (parent->str() == "return" && parent->astOperand1() == tok && inBooleanFunction(tok));
 
-            const bool isTrue = (tok->astOperand1()->hasKnownIntValue() && tok->astOperand1()->values().front().intvalue != 0) ||
-                                (tok->astOperand2()->hasKnownIntValue() && tok->astOperand2()->values().front().intvalue != 0);
+            const bool isTrue = (tok->astOperand1()->hasKnownIntValue() && tok->astOperand1()->getKnownIntValue() != 0) ||
+                                (tok->astOperand2()->hasKnownIntValue() && tok->astOperand2()->getKnownIntValue() != 0);
 
             if (isBoolean && isTrue)
                 badBitmaskCheckError(tok);
+
+            // If there are #ifdef in the expression don't warn about redundant | to avoid FP
+            const auto& startStop = tok->findExpressionStartEndTokens();
+            if (mTokenizer->hasIfdef(startStop.first, startStop.second))
+                continue;
+
+            const bool isZero1 = (tok->astOperand1()->hasKnownIntValue() && tok->astOperand1()->getKnownIntValue() == 0);
+            const bool isZero2 = (tok->astOperand2()->hasKnownIntValue() && tok->astOperand2()->getKnownIntValue() == 0);
+            if (!isZero1 && !isZero2)
+                continue;
+
+            if (!tok->isExpandedMacro() &&
+                !(isZero1 && isOperandExpanded(tok->astOperand1())) &&
+                !(isZero2 && isOperandExpanded(tok->astOperand2())))
+                badBitmaskCheckError(tok, /*isNoOp*/ true);
         }
     }
 }
 
-void CheckCondition::badBitmaskCheckError(const Token *tok)
+void CheckCondition::badBitmaskCheckError(const Token *tok, bool isNoOp)
 {
-    reportError(tok, Severity::warning, "badBitmaskCheck", "Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?", CWE571, false);
+    if (isNoOp)
+        reportError(tok, Severity::style, "badBitmaskCheck", "Operator '|' with one operand equal to zero is redundant.", CWE571, Certainty::normal);
+    else
+        reportError(tok, Severity::warning, "badBitmaskCheck", "Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?", CWE571, Certainty::normal);
 }
 
 void CheckCondition::comparison()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("comparisonError"))
         return;
 
+    logChecker("CheckCondition::comparison"); // style
+
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
         if (!tok->isComparisonOp())
             continue;
@@ -319,11 +376,13 @@ void CheckCondition::comparison()
         const Token *expr2 = tok->astOperand2();
         if (!expr1 || !expr2)
             continue;
-        if (expr1->isNumber())
+        if (expr1->hasKnownIntValue())
             std::swap(expr1,expr2);
-        if (!expr2->isNumber())
+        if (!expr2->hasKnownIntValue())
+            continue;
+        if (!compareTokenFlags(expr1, expr2, /*macro*/ true))
             continue;
-        const MathLib::bigint num2 = MathLib::toLongNumber(expr2->str());
+        const MathLib::bigint num2 = expr2->getKnownIntValue();
         if (num2 < 0)
             continue;
         if (!Token::Match(expr1,"[&|]"))
@@ -337,15 +396,15 @@ void CheckCondition::comparison()
                 if ((expr1->str() == "&" && (num1 & num2) != num2) ||
                     (expr1->str() == "|" && (num1 | num2) != num2)) {
                     const std::string& op(tok->str());
-                    comparisonError(expr1, expr1->str(), num1, op, num2, op=="==" ? false : true);
+                    comparisonError(expr1, expr1->str(), num1, op, num2, op != "==");
                 }
             } else if (expr1->str() == "&") {
                 const bool or_equal = Token::Match(tok, ">=|<=");
                 const std::string& op(tok->str());
                 if ((Token::Match(tok, ">=|<")) && (num1 < num2)) {
-                    comparisonError(expr1, expr1->str(), num1, op, num2, or_equal ? false : true);
+                    comparisonError(expr1, expr1->str(), num1, op, num2, !or_equal);
                 } else if ((Token::Match(tok, "<=|>")) && (num1 <= num2)) {
-                    comparisonError(expr1, expr1->str(), num1, op, num2, or_equal ? true : false);
+                    comparisonError(expr1, expr1->str(), num1, op, num2, or_equal);
                 }
             } else if (expr1->str() == "|") {
                 if ((expr1->astOperand1()->valueType()) &&
@@ -355,11 +414,11 @@ void CheckCondition::comparison()
                     if ((Token::Match(tok, ">=|<")) && (num1 >= num2)) {
                         //"(a | 0x07) >= 7U" is always true for unsigned a
                         //"(a | 0x07) < 7U" is always false for unsigned a
-                        comparisonError(expr1, expr1->str(), num1, op, num2, or_equal ? true : false);
+                        comparisonError(expr1, expr1->str(), num1, op, num2, or_equal);
                     } else if ((Token::Match(tok, "<=|>")) && (num1 > num2)) {
                         //"(a | 0x08) <= 7U" is always false for unsigned a
                         //"(a | 0x07) > 6U" is always true for unsigned a
-                        comparisonError(expr1, expr1->str(), num1, op, num2, or_equal ? false : true);
+                        comparisonError(expr1, expr1->str(), num1, op, num2, !or_equal);
                     }
                 }
             }
@@ -372,13 +431,13 @@ void CheckCondition::comparisonError(const Token *tok, const std::string &bitop,
     std::ostringstream expression;
     expression << std::hex << "(X " << bitop << " 0x" << value1 << ") " << op << " 0x" << value2;
 
-    const std::string errmsg("Expression '" + expression.str() + "' is always " + (result?"true":"false") + ".\n"
-                             "The expression '" + expression.str() + "' is always " + (result?"true":"false") +
+    const std::string errmsg("Expression '" + expression.str() + "' is always " + bool_to_string(result) + ".\n"
+                             "The expression '" + expression.str() + "' is always " + bool_to_string(result) +
                              ". Check carefully constants and operators used, these errors might be hard to "
                              "spot sometimes. In case of complex expression it might help to split it to "
                              "separate expressions.");
 
-    reportError(tok, Severity::style, "comparisonError", errmsg, CWE398, false);
+    reportError(tok, Severity::style, "comparisonError", errmsg, CWE398, Certainty::normal);
 }
 
 bool CheckCondition::isOverlappingCond(const Token * const cond1, const Token * const cond2, bool pure) const
@@ -387,7 +446,7 @@ bool CheckCondition::isOverlappingCond(const Token * const cond1, const Token *
         return false;
 
     // same expressions
-    if (isSameExpression(mTokenizer->isCPP(), true, cond1, cond2, mSettings->library, pure, false))
+    if (isSameExpression(true, cond1, cond2, *mSettings, pure, false))
         return true;
 
     // bitwise overlap for example 'x&7' and 'x==1'
@@ -410,11 +469,11 @@ bool CheckCondition::isOverlappingCond(const Token * const cond1, const Token *
         if (!num2->isNumber() || MathLib::isNegative(num2->str()))
             return false;
 
-        if (!isSameExpression(mTokenizer->isCPP(), true, expr1, expr2, mSettings->library, pure, false))
+        if (!isSameExpression(true, expr1, expr2, *mSettings, pure, false))
             return false;
 
-        const MathLib::bigint value1 = MathLib::toLongNumber(num1->str());
-        const MathLib::bigint value2 = MathLib::toLongNumber(num2->str());
+        const MathLib::bigint value1 = MathLib::toBigNumber(num1);
+        const MathLib::bigint value2 = MathLib::toBigNumber(num2);
         if (cond2->str() == "&")
             return ((value1 & value2) == value2);
         return ((value1 & value2) > 0);
@@ -424,24 +483,26 @@ bool CheckCondition::isOverlappingCond(const Token * const cond1, const Token *
 
 void CheckCondition::duplicateCondition()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("duplicateCondition"))
         return;
 
+    logChecker("CheckCondition::duplicateCondition"); // style
+
     const SymbolDatabase *const symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope &scope : symbolDatabase->scopeList) {
-        if (scope.type != Scope::eIf)
+        if (scope.type != ScopeType::eIf)
             continue;
 
-        const Token *cond1 = scope.classDef->next()->astOperand2();
+        const Token* tok2 = scope.classDef->next();
+        if (!tok2)
+            continue;
+        const Token* cond1 = tok2->astOperand2();
         if (!cond1)
             continue;
         if (cond1->hasKnownIntValue())
             continue;
 
-        const Token *tok2 = scope.classDef->next();
-        if (!tok2)
-            continue;
         tok2 = tok2->link();
         if (!Token::simpleMatch(tok2, ") {"))
             continue;
@@ -452,43 +513,36 @@ void CheckCondition::duplicateCondition()
         if (!cond2)
             continue;
 
-        bool modified = false;
-        visitAstNodes(cond1, [&](const Token *tok3) {
-            if (tok3->varId() > 0 &&
-                isVariableChanged(scope.classDef->next(), cond2, tok3->varId(), false, mSettings, mTokenizer->isCPP())) {
-                modified = true;
-                return ChildrenToVisit::done;
-            }
-            return ChildrenToVisit::op1_and_op2;
-        });
         ErrorPath errorPath;
-        if (!modified &&
-            isSameExpression(mTokenizer->isCPP(), true, cond1, cond2, mSettings->library, true, true, &errorPath))
-            duplicateConditionError(cond1, cond2, errorPath);
+        if (!findExpressionChanged(cond1, scope.classDef->next(), cond2, *mSettings) &&
+            isSameExpression(true, cond1, cond2, *mSettings, true, true, &errorPath))
+            duplicateConditionError(cond1, cond2, std::move(errorPath));
     }
 }
 
 void CheckCondition::duplicateConditionError(const Token *tok1, const Token *tok2, ErrorPath errorPath)
 {
-    if (diag(tok1) & diag(tok2))
+    if (diag(tok1, tok2))
         return;
     errorPath.emplace_back(tok1, "First condition");
     errorPath.emplace_back(tok2, "Second condition");
 
     std::string msg = "The if condition is the same as the previous if condition";
 
-    reportError(errorPath, Severity::style, "duplicateCondition", msg, CWE398, false);
+    reportError(std::move(errorPath), Severity::style, "duplicateCondition", msg, CWE398, Certainty::normal);
 }
 
 void CheckCondition::multiCondition()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("multiCondition"))
         return;
 
+    logChecker("CheckCondition::multiCondition"); // style
+
     const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope &scope : symbolDatabase->scopeList) {
-        if (scope.type != Scope::eIf)
+        if (scope.type != ScopeType::eIf)
             continue;
 
         const Token * const cond1 = scope.classDef->next()->astOperand2();
@@ -507,14 +561,15 @@ void CheckCondition::multiCondition()
                 break;
             tok2 = tok2->tokAt(4);
 
-            if (tok2->astOperand2() &&
-                !cond1->hasKnownIntValue() &&
-                !tok2->astOperand2()->hasKnownIntValue()) {
+            if (tok2->astOperand2()) {
                 ErrorPath errorPath;
-                if (isOverlappingCond(cond1, tok2->astOperand2(), true))
-                    overlappingElseIfConditionError(tok2, cond1->linenr());
-                else if (isOppositeCond(true, mTokenizer->isCPP(), cond1, tok2->astOperand2(), mSettings->library, true, true, &errorPath))
-                    oppositeElseIfConditionError(cond1, tok2, errorPath);
+                if (isOverlappingCond(cond1, tok2->astOperand2(), true) &&
+                    !findExpressionChanged(cond1, cond1, tok2->astOperand2(), *mSettings))
+                    overlappingElseIfConditionError(tok2->astOperand2(), cond1->linenr());
+                else if (isOppositeCond(
+                             true, cond1, tok2->astOperand2(), *mSettings, true, true, &errorPath) &&
+                         !findExpressionChanged(cond1, cond1, tok2->astOperand2(), *mSettings))
+                    oppositeElseIfConditionError(cond1, tok2->astOperand2(), std::move(errorPath));
             }
         }
     }
@@ -528,12 +583,12 @@ void CheckCondition::overlappingElseIfConditionError(const Token *tok, nonneg in
     errmsg << "Expression is always false because 'else if' condition matches previous condition at line "
            << line1 << ".";
 
-    reportError(tok, Severity::style, "multiCondition", errmsg.str(), CWE398, false);
+    reportError(tok, Severity::style, "multiCondition", errmsg.str(), CWE398, Certainty::normal);
 }
 
 void CheckCondition::oppositeElseIfConditionError(const Token *ifCond, const Token *elseIfCond, ErrorPath errorPath)
 {
-    if (diag(ifCond) & diag(elseIfCond))
+    if (diag(ifCond, elseIfCond))
         return;
     std::ostringstream errmsg;
     errmsg << "Expression is always true because 'else if' condition is opposite to previous condition at line "
@@ -542,7 +597,7 @@ void CheckCondition::oppositeElseIfConditionError(const Token *ifCond, const Tok
     errorPath.emplace_back(ifCond, "first condition");
     errorPath.emplace_back(elseIfCond, "else if condition is opposite to first condition");
 
-    reportError(errorPath, Severity::style, "multiCondition", errmsg.str(), CWE398, false);
+    reportError(std::move(errorPath), Severity::style, "multiCondition", errmsg.str(), CWE398, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -560,25 +615,41 @@ static bool isNonConstFunctionCall(const Token *ftok, const Library &library)
         obj = obj->astOperand1();
     if (!obj)
         return true;
-    else if (obj->variable() && obj->variable()->isConst())
+    if (obj->variable() && obj->variable()->isConst())
         return false;
-    else if (ftok->function() && ftok->function()->isConst())
+    if (ftok->function() && ftok->function()->isConst())
+        return false;
+    if (ftok->isControlFlowKeyword())
         return false;
     return true;
 }
 
+static bool isNestedInLambda(const Scope* inner, const Scope* outer)
+{
+    while (inner && inner != outer) {
+        if (inner->type == ScopeType::eLambda)
+            return true;
+        inner = inner->nestedIn;
+    }
+    return false;
+}
+
 void CheckCondition::multiCondition2()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning) &&
+        !mSettings->isPremiumEnabled("identicalConditionAfterEarlyExit") &&
+        !mSettings->isPremiumEnabled("identicalInnerCondition"))
         return;
 
+    logChecker("CheckCondition::multiCondition2"); // warning
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope &scope : symbolDatabase->scopeList) {
         const Token *condTok = nullptr;
-        if (scope.type == Scope::eIf || scope.type == Scope::eWhile)
+        if (scope.type == ScopeType::eIf || scope.type == ScopeType::eWhile)
             condTok = scope.classDef->next()->astOperand2();
-        else if (scope.type == Scope::eFor) {
+        else if (scope.type == ScopeType::eFor) {
             condTok = scope.classDef->next()->astOperand2();
             if (!condTok || condTok->str() != ";")
                 continue;
@@ -594,12 +665,14 @@ void CheckCondition::multiCondition2()
         if (!Token::simpleMatch(scope.classDef->linkAt(1), ") {"))
             continue;
 
+        bool functionCall = false;
         bool nonConstFunctionCall = false;
         bool nonlocal = false; // nonlocal variable used in condition
         std::set<int> vars; // variables used in condition
         visitAstNodes(condTok,
-        [&](const Token *cond) {
+                      [&](const Token *cond) {
             if (Token::Match(cond, "%name% (")) {
+                functionCall = true;
                 nonConstFunctionCall = isNonConstFunctionCall(cond, mSettings->library);
                 if (nonConstFunctionCall)
                     return ChildrenToVisit::done;
@@ -617,7 +690,7 @@ void CheckCondition::multiCondition2()
                 }
             } else if (!nonlocal && cond->isName()) {
                 // varid is 0. this is possibly a nonlocal variable..
-                nonlocal = Token::Match(cond->astParent(), "%cop%|(|[") || Token::Match(cond, "%name% .") || (mTokenizer->isCPP() && cond->str() == "this");
+                nonlocal = Token::Match(cond->astParent(), "%cop%|(|[") || Token::Match(cond, "%name% .") || (cond->isCpp() && cond->str() == "this");
             } else {
                 return ChildrenToVisit::op1_and_op2;
             }
@@ -627,15 +700,26 @@ void CheckCondition::multiCondition2()
         if (nonConstFunctionCall)
             continue;
 
+        std::vector<const Variable*> varsInCond;
+        visitAstNodes(condTok,
+                      [&varsInCond](const Token *cond) {
+            if (cond->variable()) {
+                const Variable *var = cond->variable();
+                if (std::find(varsInCond.cbegin(), varsInCond.cend(), var) == varsInCond.cend())
+                    varsInCond.push_back(var);
+            }
+            return ChildrenToVisit::op1_and_op2;
+        });
+
         // parse until second condition is reached..
-        enum MULTICONDITIONTYPE { INNER, AFTER };
+        enum MULTICONDITIONTYPE : std::uint8_t { INNER, AFTER };
         const Token *tok;
 
         // Parse inner condition first and then early return condition
         std::vector<MULTICONDITIONTYPE> types = {MULTICONDITIONTYPE::INNER};
         if (Token::Match(scope.bodyStart, "{ return|throw|continue|break"))
             types.push_back(MULTICONDITIONTYPE::AFTER);
-        for (MULTICONDITIONTYPE type:types) {
+        for (const MULTICONDITIONTYPE type:types) {
             if (type == MULTICONDITIONTYPE::AFTER) {
                 tok = scope.bodyEnd->next();
             } else {
@@ -644,72 +728,61 @@ void CheckCondition::multiCondition2()
             const Token * const endToken = tok->scope()->bodyEnd;
 
             for (; tok && tok != endToken; tok = tok->next()) {
+                if (isNestedInLambda(tok->scope(), cond1->scope()))
+                    continue;
+                if (isExpressionChangedAt(cond1, tok, 0, false, *mSettings))
+                    break;
                 if (Token::Match(tok, "if|return")) {
                     const Token * condStartToken = tok->str() == "if" ? tok->next() : tok;
                     const Token * condEndToken = tok->str() == "if" ? condStartToken->link() : Token::findsimplematch(condStartToken, ";");
                     // Does condition modify tracked variables?
-                    if (const Token *op = Token::findmatch(tok, "++|--", condEndToken)) {
-                        bool bailout = false;
-                        while (op) {
-                            if (vars.find(op->astOperand1()->varId()) != vars.end()) {
-                                bailout = true;
-                                break;
-                            }
-                            if (nonlocal && op->astOperand1()->varId() == 0) {
-                                bailout = true;
-                                break;
-                            }
-                            op = Token::findmatch(op->next(), "++|--", condEndToken);
-                        }
-                        if (bailout)
-                            break;
-                    }
+                    if (findExpressionChanged(cond1, condStartToken, condEndToken, *mSettings))
+                        break;
 
                     // Condition..
                     const Token *cond2 = tok->str() == "if" ? condStartToken->astOperand2() : condStartToken->astOperand1();
-                    const bool isReturnVar = (tok->str() == "return" && !Token::Match(cond2, "%cop%"));
+                    const bool isReturnVar = (tok->str() == "return" && (!Token::Match(cond2, "%cop%") || (cond2 && cond2->isUnaryOp("!"))));
 
                     ErrorPath errorPath;
 
                     if (type == MULTICONDITIONTYPE::INNER) {
-                        std::stack<const Token *> tokens1;
-                        tokens1.push(cond1);
-                        while (!tokens1.empty()) {
-                            const Token *firstCondition = tokens1.top();
-                            tokens1.pop();
+                        visitAstNodes(cond1, [&](const Token* firstCondition) {
                             if (!firstCondition)
-                                continue;
+                                return ChildrenToVisit::none;
                             if (firstCondition->str() == "&&") {
-                                tokens1.push(firstCondition->astOperand1());
-                                tokens1.push(firstCondition->astOperand2());
-                            } else if (!firstCondition->hasKnownIntValue()) {
-                                if (!isReturnVar && isOppositeCond(false, mTokenizer->isCPP(), firstCondition, cond2, mSettings->library, true, true, &errorPath)) {
+                                if (!isOppositeCond(false, firstCondition, cond2, *mSettings, true, true))
+                                    return ChildrenToVisit::op1_and_op2;
+                            }
+                            if (!firstCondition->hasKnownIntValue()) {
+                                if (!isReturnVar && isOppositeCond(false, firstCondition, cond2, *mSettings, true, true, &errorPath)) {
                                     if (!isAliased(vars))
                                         oppositeInnerConditionError(firstCondition, cond2, errorPath);
-                                } else if (!isReturnVar && isSameExpression(mTokenizer->isCPP(), true, firstCondition, cond2, mSettings->library, true, true, &errorPath)) {
+                                } else if (!isReturnVar && isSameExpression(true, firstCondition, cond2, *mSettings, true, true, &errorPath)) {
                                     identicalInnerConditionError(firstCondition, cond2, errorPath);
                                 }
                             }
-                        }
+                            return ChildrenToVisit::none;
+                        });
                     } else {
-                        std::stack<const Token *> tokens2;
-                        tokens2.push(cond2);
-                        while (!tokens2.empty()) {
-                            const Token *secondCondition = tokens2.top();
-                            tokens2.pop();
-                            if (!secondCondition)
-                                continue;
-                            if (secondCondition->str() == "||" || secondCondition->str() == "&&") {
-                                tokens2.push(secondCondition->astOperand1());
-                                tokens2.push(secondCondition->astOperand2());
-                            } else if ((!cond1->hasKnownIntValue() || !secondCondition->hasKnownIntValue()) &&
-                                       isSameExpression(mTokenizer->isCPP(), true, cond1, secondCondition, mSettings->library, true, true, &errorPath)) {
-                                if (!isAliased(vars))
+                        visitAstNodes(cond2, [&](const Token *secondCondition) {
+                            if (secondCondition->str() == "||" || secondCondition->str() == "&&")
+                                return ChildrenToVisit::op1_and_op2;
+
+                            if ((!cond1->hasKnownIntValue() || !secondCondition->hasKnownIntValue()) &&
+                                isSameExpression(true, cond1, secondCondition, *mSettings, true, true, &errorPath)) {
+                                if (!isAliased(vars) && !mTokenizer->hasIfdef(cond1, secondCondition)) {
                                     identicalConditionAfterEarlyExitError(cond1, secondCondition, errorPath);
+                                    return ChildrenToVisit::done;
+                                }
                             }
-                        }
+                            return ChildrenToVisit::none;
+                        });
                     }
                 }
+                if (Token::Match(tok, "%name% (") &&
+                    isVariablesChanged(tok, tok->linkAt(1), 0, varsInCond, *mSettings)) {
+                    break;
+                }
                 if (Token::Match(tok, "%type% (") && nonlocal && isNonConstFunctionCall(tok, mSettings->library)) // non const function call -> bailout if there are nonlocal variables
                     break;
                 if (Token::Match(tok, "case|break|continue|return|throw") && tok->scope() == endToken->scope())
@@ -735,18 +808,15 @@ void CheckCondition::multiCondition2()
                         // Incomplete code
                         break;
                     }
-                    bool changed = false;
-                    for (int varid : vars) {
-                        if (isVariableChanged(tok1, tok2, varid, nonlocal, mSettings, mTokenizer->isCPP())) {
-                            changed = true;
-                            break;
-                        }
-                    }
+                    const bool changed = std::any_of(vars.cbegin(), vars.cend(), [&](int varid) {
+                        return isVariableChanged(tok1, tok2, varid, nonlocal, *mSettings);
+                    });
                     if (changed)
                         break;
                 }
                 if ((tok->varId() && vars.find(tok->varId()) != vars.end()) ||
-                    (!tok->varId() && nonlocal)) {
+                    (!tok->varId() && nonlocal) ||
+                    (functionCall && tok->variable() && !tok->variable()->isLocal())) {
                     if (Token::Match(tok, "%name% %assign%|++|--"))
                         break;
                     if (Token::Match(tok->astParent(), "*|.|[")) {
@@ -756,9 +826,9 @@ void CheckCondition::multiCondition2()
                         if (Token::Match(parent->astParent(), "%assign%|++|--"))
                             break;
                     }
-                    if (mTokenizer->isCPP() && Token::Match(tok, "%name% <<") && (!tok->valueType() || !tok->valueType()->isIntegral()))
+                    if (tok->isCpp() && Token::Match(tok, "%name% <<") && (!tok->valueType() || !tok->valueType()->isIntegral()))
                         break;
-                    if (isLikelyStreamRead(mTokenizer->isCPP(), tok->next()) || isLikelyStreamRead(mTokenizer->isCPP(), tok->previous()))
+                    if (isLikelyStreamRead(tok->next()) || isLikelyStreamRead(tok->previous()))
                         break;
                     if (Token::Match(tok, "%name% [")) {
                         const Token *tok2 = tok->linkAt(1);
@@ -776,7 +846,7 @@ void CheckCondition::multiCondition2()
                         if (!function || !function->isConst())
                             break;
                     }
-                    if (Token::Match(tok->previous(), "[(,] %name% [,)]") && isParameterChanged(tok))
+                    if (Token::Match(tok->previous(), "[(,] *|& %name% [,)]") && isParameterChanged(tok))
                         break;
                 }
             }
@@ -788,8 +858,6 @@ static std::string innerSmtString(const Token * tok)
 {
     if (!tok)
         return "if";
-    if (!tok->astTop())
-        return "if";
     const Token * top = tok->astTop();
     if (top->str() == "(" && top->astOperand1())
         return top->astOperand1()->str();
@@ -798,43 +866,55 @@ static std::string innerSmtString(const Token * tok)
 
 void CheckCondition::oppositeInnerConditionError(const Token *tok1, const Token* tok2, ErrorPath errorPath)
 {
-    if (diag(tok1) & diag(tok2))
+    if (diag(tok1, tok2))
         return;
     const std::string s1(tok1 ? tok1->expressionString() : "x");
     const std::string s2(tok2 ? tok2->expressionString() : "!x");
     const std::string innerSmt = innerSmtString(tok2);
-    errorPath.emplace_back(ErrorPathItem(tok1, "outer condition: " + s1));
-    errorPath.emplace_back(ErrorPathItem(tok2, "opposite inner condition: " + s2));
+    errorPath.emplace_back(tok1, "outer condition: " + s1);
+    errorPath.emplace_back(tok2, "opposite inner condition: " + s2);
 
     const std::string msg("Opposite inner '" + innerSmt + "' condition leads to a dead code block.\n"
                           "Opposite inner '" + innerSmt + "' condition leads to a dead code block (outer condition is '" + s1 + "' and inner condition is '" + s2 + "').");
-    reportError(errorPath, Severity::warning, "oppositeInnerCondition", msg, CWE398, false);
+    reportError(std::move(errorPath), Severity::warning, "oppositeInnerCondition", msg, CWE398, Certainty::normal);
 }
 
 void CheckCondition::identicalInnerConditionError(const Token *tok1, const Token* tok2, ErrorPath errorPath)
 {
-    if (diag(tok1) & diag(tok2))
+    if (diag(tok1, tok2))
         return;
     const std::string s1(tok1 ? tok1->expressionString() : "x");
     const std::string s2(tok2 ? tok2->expressionString() : "x");
     const std::string innerSmt = innerSmtString(tok2);
-    errorPath.emplace_back(ErrorPathItem(tok1, "outer condition: " + s1));
-    errorPath.emplace_back(ErrorPathItem(tok2, "identical inner condition: " + s2));
+    errorPath.emplace_back(tok1, "outer condition: " + s1);
+    errorPath.emplace_back(tok2, "identical inner condition: " + s2);
 
     const std::string msg("Identical inner '" + innerSmt + "' condition is always true.\n"
                           "Identical inner '" + innerSmt + "' condition is always true (outer condition is '" + s1 + "' and inner condition is '" + s2 + "').");
-    reportError(errorPath, Severity::warning, "identicalInnerCondition", msg, CWE398, false);
+    reportError(std::move(errorPath), Severity::warning, "identicalInnerCondition", msg, CWE398, Certainty::normal);
 }
 
 void CheckCondition::identicalConditionAfterEarlyExitError(const Token *cond1, const Token* cond2, ErrorPath errorPath)
 {
-    if (diag(cond1) & diag(cond2))
+    if (diag(cond1, cond2))
         return;
-    const std::string cond(cond1 ? cond1->expressionString() : "x");
-    errorPath.emplace_back(ErrorPathItem(cond1, "first condition"));
-    errorPath.emplace_back(ErrorPathItem(cond2, "second condition"));
 
-    reportError(errorPath, Severity::warning, "identicalConditionAfterEarlyExit", "Identical condition '" + cond + "', second condition is always false", CWE398, false);
+    const bool isReturnValue = cond2 && Token::simpleMatch(cond2->astParent(), "return");
+
+    const std::string cond(cond1 ? cond1->expressionString() : "x");
+    const std::string value = (cond2 && cond2->valueType() && cond2->valueType()->type == ValueType::Type::BOOL) ? "false" : "0";
+
+    errorPath.emplace_back(cond1, "If condition '" + cond + "' is true, the function will return/exit");
+    errorPath.emplace_back(cond2, (isReturnValue ? "Returning identical expression '" : "Testing identical condition '") + cond + "'");
+
+    reportError(std::move(errorPath),
+                Severity::warning,
+                "identicalConditionAfterEarlyExit",
+                isReturnValue
+                ? ("Identical condition and return expression '" + cond + "', return value is always " + value)
+                : ("Identical condition '" + cond + "', second condition is always false"),
+                CWE398,
+                Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -863,39 +943,93 @@ static std::string invertOperatorForOperandSwap(std::string s)
     return s;
 }
 
-template <typename T>
+template<typename T>
+static int sign(const T v) {
+    return static_cast<int>(v > 0) - static_cast<int>(v < 0);
+}
+
+// returns 1 (-1) if the first (second) condition is sufficient, 0 if indeterminate
+template<typename T>
+static int sufficientCondition(std::string op1, const bool not1, const T value1, std::string op2, const bool not2, const T value2, const bool isAnd) {
+    auto transformOp = [](std::string& op, const bool invert) {
+        if (invert) {
+            if (op == "==")
+                op = "!=";
+            else if (op == "!=")
+                op = "==";
+            else if (op == "<")
+                op = ">=";
+            else if (op == ">")
+                op = "<=";
+            else if (op == "<=")
+                op = ">";
+            else if (op == ">=")
+                op = "<";
+        }
+    };
+    transformOp(op1, not1);
+    transformOp(op2, not2);
+    int res = 0;
+    bool equal = false;
+    if (op1 == op2) {
+        equal = true;
+        if (op1 == ">" || op1 == ">=")
+            res = sign(value1 - value2);
+        else if (op1 == "<" || op1 == "<=")
+            res = -sign(value1 - value2);
+    } else { // not equal
+        if (op1 == "!=")
+            res = 1;
+        else if (op2 == "!=")
+            res = -1;
+        else if (op1 == "==")
+            res = -1;
+        else if (op2 == "==")
+            res = 1;
+        else if (op1 == ">" && op2 == ">=")
+            res = sign(value1 - (value2 - 1));
+        else if (op1 == ">=" && op2 == ">")
+            res = sign((value1 - 1) - value2);
+        else if (op1 == "<" && op2 == "<=")
+            res = -sign(value1 - (value2 + 1));
+        else if (op1 == "<=" && op2 == "<")
+            res = -sign((value1 + 1) - value2);
+    }
+    return res * (isAnd == equal ? 1 : -1);
+}
+
+template<typename T>
 static bool checkIntRelation(const std::string &op, const T value1, const T value2)
 {
     return (op == "==" && value1 == value2) ||
            (op == "!=" && value1 != value2) ||
-           (op == ">"  && value1 >  value2) ||
+           (op == ">" && value1 >  value2) ||
            (op == ">=" && value1 >= value2) ||
-           (op == "<"  && value1 <  value2) ||
+           (op == "<" && value1 <  value2) ||
            (op == "<=" && value1 <= value2);
 }
 
 static bool checkFloatRelation(const std::string &op, const double value1, const double value2)
 {
-    return (op == ">"  && value1 >  value2) ||
+    return (op == ">" && value1 >  value2) ||
            (op == ">=" && value1 >= value2) ||
-           (op == "<"  && value1 <  value2) ||
+           (op == "<" && value1 <  value2) ||
            (op == "<=" && value1 <= value2);
 }
 
 template<class T>
-T getvalue3(const T value1, const T value2)
+static T getvalue3(const T value1, const T value2)
 {
     const T min = std::min(value1, value2);
     if (min== std::numeric_limits<T>::max())
         return min;
-    else
-        return min+1; // see #5895
+    return min + 1; // see #5895
 }
 
 template<>
 double getvalue3(const double value1, const double value2)
 {
-    return (value1 + value2) / 2.0f;
+    return (value1 + value2) / 2.0;
 }
 
 
@@ -919,15 +1053,15 @@ static inline T getvalue(const int test, const T value1, const T value2)
         return value2;
     case 5:
         return std::numeric_limits<T>::max();
-    };
+    }
     return 0;
 }
 
-static bool parseComparison(const Token *comp, bool *not1, std::string *op, std::string *value, const Token **expr, bool* inconclusive)
+static bool parseComparison(const Token *comp, bool &not1, std::string &op, std::string &value, const Token *&expr, bool &inconclusive)
 {
-    *not1 = false;
+    not1 = false;
     while (comp && comp->str() == "!") {
-        *not1 = !(*not1);
+        not1 = !not1;
         comp = comp->astOperand1();
     }
 
@@ -937,55 +1071,50 @@ static bool parseComparison(const Token *comp, bool *not1, std::string *op, std:
     const Token* op1 = comp->astOperand1();
     const Token* op2 = comp->astOperand2();
     if (!comp->isComparisonOp() || !op1 || !op2) {
-        *op = "!=";
-        *value = "0";
-        *expr = comp;
+        op = "!=";
+        value = "0";
+        expr = comp;
     } else if (op1->isLiteral()) {
         if (op1->isExpandedMacro())
             return false;
-        *op = invertOperatorForOperandSwap(comp->str());
+        op = invertOperatorForOperandSwap(comp->str());
         if (op1->enumerator() && op1->enumerator()->value_known)
-            *value = MathLib::toString(op1->enumerator()->value);
+            value = MathLib::toString(op1->enumerator()->value);
         else
-            *value = op1->str();
-        *expr = op2;
+            value = op1->str();
+        expr = op2;
     } else if (comp->astOperand2()->isLiteral()) {
         if (op2->isExpandedMacro())
             return false;
-        *op = comp->str();
+        op = comp->str();
         if (op2->enumerator() && op2->enumerator()->value_known)
-            *value = MathLib::toString(op2->enumerator()->value);
+            value = MathLib::toString(op2->enumerator()->value);
         else
-            *value = op2->str();
-        *expr = op1;
+            value = op2->str();
+        expr = op1;
     } else {
-        *op = "!=";
-        *value = "0";
-        *expr = comp;
+        op = "!=";
+        value = "0";
+        expr = comp;
     }
 
-    *inconclusive = *inconclusive || ((*value)[0] == '\'' && !(*op == "!=" || *op == "=="));
+    inconclusive = inconclusive || (value[0] == '\'' && !(op == "!=" || op == "=="));
 
     // Only float and int values are currently handled
-    if (!MathLib::isInt(*value) && !MathLib::isFloat(*value) && (*value)[0] != '\'')
-        return false;
-
-    return true;
+    return MathLib::isInt(value) || MathLib::isFloat(value) || (value[0] == '\'');
 }
 
 static std::string conditionString(bool not1, const Token *expr1, const std::string &op, const std::string &value1)
 {
     if (expr1->astParent()->isComparisonOp())
-        return std::string(not1 ? "!(" : "") +
-               (expr1->isName() ? expr1->str() : std::string("EXPR")) +
+        return std::string(not1 ? "!(" : "") + expr1->expressionString() +
                " " +
                op +
                " " +
                value1 +
                (not1 ? ")" : "");
 
-    return std::string(not1 ? "!" : "") +
-           (expr1->isName() ? expr1->str() : std::string("EXPR"));
+    return std::string(not1 ? "!" : "") + expr1->expressionString();
 }
 
 static std::string conditionString(const Token * tok)
@@ -997,7 +1126,7 @@ static std::string conditionString(const Token * tok)
         bool not_;
         std::string op, value;
         const Token *expr;
-        if (parseComparison(tok, &not_, &op, &value, &expr, &inconclusive) && expr->isName()) {
+        if (parseComparison(tok, not_, op, value, expr, inconclusive) && expr->isName()) {
             return conditionString(not_, expr, op, value);
         }
     }
@@ -1010,13 +1139,20 @@ static std::string conditionString(const Token * tok)
     return tok->expressionString();
 }
 
+static bool isIfConstexpr(const Token* tok) {
+    const Token* const top = tok->astTop();
+    return Token::simpleMatch(top->astOperand1(), "if") && top->astOperand1()->isConstexpr();
+}
+
 void CheckCondition::checkIncorrectLogicOperator()
 {
-    const bool printStyle = mSettings->isEnabled(Settings::STYLE);
-    const bool printWarning = mSettings->isEnabled(Settings::WARNING);
-    if (!printWarning && !printStyle)
+    const bool printStyle = mSettings->severity.isEnabled(Severity::style);
+    const bool printWarning = mSettings->severity.isEnabled(Severity::warning);
+    if (!printWarning && !printStyle && !mSettings->isPremiumEnabled("incorrectLogicOperator"))
         return;
-    const bool printInconclusive = mSettings->inconclusive;
+    const bool printInconclusive = mSettings->certainty.isEnabled(Certainty::inconclusive);
+
+    logChecker("CheckCondition::checkIncorrectLogicOperator"); // style,warning
 
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
@@ -1028,11 +1164,13 @@ void CheckCondition::checkIncorrectLogicOperator()
 
             // 'A && (!A || B)' is equivalent to 'A && B'
             // 'A || (!A && B)' is equivalent to 'A || B'
+            // 'A && (A || B)' is equivalent to 'A'
+            // 'A || (A && B)' is equivalent to 'A'
             if (printStyle &&
                 ((tok->str() == "||" && tok->astOperand2()->str() == "&&") ||
                  (tok->str() == "&&" && tok->astOperand2()->str() == "||"))) {
                 const Token* tok2 = tok->astOperand2()->astOperand1();
-                if (isOppositeCond(true, mTokenizer->isCPP(), tok->astOperand1(), tok2, mSettings->library, true, false)) {
+                if (isOppositeCond(true, tok->astOperand1(), tok2, *mSettings, true, false)) {
                     std::string expr1(tok->astOperand1()->expressionString());
                     std::string expr2(tok->astOperand2()->astOperand1()->expressionString());
                     std::string expr3(tok->astOperand2()->astOperand2()->expressionString());
@@ -1064,11 +1202,37 @@ void CheckCondition::checkIncorrectLogicOperator()
                     redundantConditionError(tok, msg, false);
                     continue;
                 }
+                if (isSameExpression(false, tok->astOperand1(), tok2, *mSettings, true, true)) {
+                    std::string expr1(tok->astOperand1()->expressionString());
+                    std::string expr2(tok->astOperand2()->astOperand1()->expressionString());
+                    std::string expr3(tok->astOperand2()->astOperand2()->expressionString());
+                    // make copy for later because the original string might get overwritten
+                    const std::string expr1VerboseMsg = expr1;
+                    const std::string expr2VerboseMsg = expr2;
+                    const std::string expr3VerboseMsg = expr3;
+
+                    if (expr1.length() + expr2.length() + expr3.length() > 50U) {
+                        expr1 = "A";
+                        expr2 = "A";
+                        expr3 = "B";
+                    }
+
+                    const std::string cond1 = expr1 + " " + tok->str() + " (" + expr2 + " " + tok->astOperand2()->str() + " " + expr3 + ")";
+                    const std::string cond2 = std::move(expr1);
+
+                    const std::string cond1VerboseMsg = expr1VerboseMsg + " " + tok->str() + " " + expr2VerboseMsg + " " + tok->astOperand2()->str() + " " + expr3VerboseMsg;
+                    const std::string& cond2VerboseMsg = expr1VerboseMsg;
+                    // for the --verbose message, transform the actual condition and print it
+                    const std::string msg = tok2->expressionString() + ". '" + cond1 + "' is equivalent to '" + cond2 + "'\n"
+                                            "The condition '" + cond1VerboseMsg + "' is equivalent to '" + cond2VerboseMsg + "'.";
+                    redundantConditionError(tok, msg, false);
+                    continue;
+                }
             }
 
             // Comparison #1 (LHS)
             const Token *comp1 = tok->astOperand1();
-            if (comp1 && comp1->str() == tok->str())
+            if (comp1->str() == tok->str())
                 comp1 = comp1->astOperand2();
 
             // Comparison #2 (RHS)
@@ -1081,35 +1245,42 @@ void CheckCondition::checkIncorrectLogicOperator()
             bool not1;
             std::string op1, value1;
             const Token *expr1 = nullptr;
-            parseable &= (parseComparison(comp1, &not1, &op1, &value1, &expr1, &inconclusive));
+            parseable &= (parseComparison(comp1, not1, op1, value1, expr1, inconclusive));
 
             // Parse RHS
             bool not2;
             std::string op2, value2;
             const Token *expr2 = nullptr;
-            parseable &= (parseComparison(comp2, &not2, &op2, &value2, &expr2, &inconclusive));
+            parseable &= (parseComparison(comp2, not2, op2, value2, expr2, inconclusive));
 
             if (inconclusive && !printInconclusive)
                 continue;
 
+            const bool isUnknown = (expr1 && expr1->valueType() && expr1->valueType()->type == ValueType::UNKNOWN_TYPE) ||
+                                   (expr2 && expr2->valueType() && expr2->valueType()->type == ValueType::UNKNOWN_TYPE);
+            if (isUnknown)
+                continue;
+
             const bool isfloat = astIsFloat(expr1, true) || MathLib::isFloat(value1) || astIsFloat(expr2, true) || MathLib::isFloat(value2);
 
             ErrorPath errorPath;
 
             // Opposite comparisons around || or && => always true or always false
-            if (!isfloat && isOppositeCond(tok->str() == "||", mTokenizer->isCPP(), tok->astOperand1(), tok->astOperand2(), mSettings->library, true, true, &errorPath)) {
-
-                const bool alwaysTrue(tok->str() == "||");
-                incorrectLogicOperatorError(tok, conditionString(tok), alwaysTrue, inconclusive, errorPath);
+            const bool isLogicalOr(tok->str() == "||");
+            if (!isfloat && isOppositeCond(isLogicalOr, tok->astOperand1(), tok->astOperand2(), *mSettings, true, true, &errorPath)) {
+                if (!isIfConstexpr(tok)) {
+                    const bool alwaysTrue(isLogicalOr);
+                    incorrectLogicOperatorError(tok, conditionString(tok), alwaysTrue, inconclusive, std::move(errorPath));
+                }
                 continue;
             }
 
             if (!parseable)
                 continue;
 
-            if (isSameExpression(mTokenizer->isCPP(), true, comp1, comp2, mSettings->library, true, true))
+            if (isSameExpression(true, comp1, comp2, *mSettings, true, true))
                 continue; // same expressions => only report that there are same expressions
-            if (!isSameExpression(mTokenizer->isCPP(), true, expr1, expr2, mSettings->library, true, true))
+            if (!isSameExpression(true, expr1, expr2, *mSettings, true, true))
                 continue;
 
 
@@ -1118,17 +1289,18 @@ void CheckCondition::checkIncorrectLogicOperator()
             if (isfloat && (op1 == "==" || op1 == "!=" || op2 == "==" || op2 == "!="))
                 continue;
 
-
-            const double d1 = (isfloat) ? MathLib::toDoubleNumber(value1) : 0;
-            const double d2 = (isfloat) ? MathLib::toDoubleNumber(value2) : 0;
-            const MathLib::bigint i1 = (isfloat) ? 0 : MathLib::toLongNumber(value1);
-            const MathLib::bigint i2 = (isfloat) ? 0 : MathLib::toLongNumber(value2);
-            const bool useUnsignedInt = (std::numeric_limits<MathLib::bigint>::max()==i1)||(std::numeric_limits<MathLib::bigint>::max()==i2);
-            const MathLib::biguint u1 = (useUnsignedInt) ? MathLib::toLongNumber(value1) : 0;
-            const MathLib::biguint u2 = (useUnsignedInt) ? MathLib::toLongNumber(value2) : 0;
+            // the expr are not the token of the value but they provide better context
+            const double d1 = isfloat ? MathLib::toDoubleNumber(value1) : 0;
+            const double d2 = isfloat ? MathLib::toDoubleNumber(value2) : 0;
+            const MathLib::bigint i1 = isfloat ? 0 : MathLib::toBigNumber(value1, expr1);
+            const MathLib::bigint i2 = isfloat ? 0 : MathLib::toBigNumber(value2, expr2);
+            const bool useUnsignedInt = (std::numeric_limits<MathLib::bigint>::max()==i1) || (std::numeric_limits<MathLib::bigint>::max()==i2);
+            const MathLib::biguint u1 = useUnsignedInt ? MathLib::toBigUNumber(value1, expr1) : 0;
+            const MathLib::biguint u2 = useUnsignedInt ? MathLib::toBigUNumber(value2, expr2) : 0;
             // evaluate if expression is always true/false
             bool alwaysTrue = true, alwaysFalse = true;
             bool firstTrue = true, secondTrue = true;
+            const bool isAnd = tok->str() == "&&";
             for (int test = 1; test <= 5; ++test) {
                 // test:
                 // 1 => testvalue is less than both value1 and value2
@@ -1138,15 +1310,15 @@ void CheckCondition::checkIncorrectLogicOperator()
                 // 5 => testvalue is larger than both value1 and value2
                 bool result1, result2;
                 if (isfloat) {
-                    const double testvalue = getvalue<double>(test, d1, d2);
+                    const auto testvalue = getvalue<double>(test, d1, d2);
                     result1 = checkFloatRelation(op1, testvalue, d1);
                     result2 = checkFloatRelation(op2, testvalue, d2);
                 } else if (useUnsignedInt) {
-                    const MathLib::biguint testvalue = getvalue<MathLib::biguint>(test, u1, u2);
+                    const auto testvalue = getvalue<MathLib::biguint>(test, u1, u2);
                     result1 = checkIntRelation(op1, testvalue, u1);
                     result2 = checkIntRelation(op2, testvalue, u2);
                 } else {
-                    const MathLib::bigint testvalue = getvalue<MathLib::bigint>(test, i1, i2);
+                    const auto testvalue = getvalue<MathLib::bigint>(test, i1, i2);
                     result1 = checkIntRelation(op1, testvalue, i1);
                     result2 = checkIntRelation(op2, testvalue, i2);
                 }
@@ -1154,7 +1326,7 @@ void CheckCondition::checkIncorrectLogicOperator()
                     result1 = !result1;
                 if (not2)
                     result2 = !result2;
-                if (tok->str() == "&&") {
+                if (isAnd) {
                     alwaysTrue &= (result1 && result2);
                     alwaysFalse &= !(result1 && result2);
                 } else {
@@ -1169,17 +1341,14 @@ void CheckCondition::checkIncorrectLogicOperator()
             const std::string cond2str = conditionString(not2, expr2, op2, value2);
             if (printWarning && (alwaysTrue || alwaysFalse)) {
                 const std::string text = cond1str + " " + tok->str() + " " + cond2str;
-                incorrectLogicOperatorError(tok, text, alwaysTrue, inconclusive, errorPath);
-            } else if (printStyle && secondTrue) {
-                const std::string text = "If '" + cond1str + "', the comparison '" + cond2str +
-                                         "' is always true.";
-                redundantConditionError(tok, text, inconclusive);
-            } else if (printStyle && firstTrue) {
-                //const std::string text = "The comparison " + cond1str + " is always " +
-                //                         (firstTrue ? "true" : "false") + " when " +
-                //                         cond2str + ".";
-                const std::string text = "If '" + cond2str + "', the comparison '" + cond1str +
-                                         "' is always true.";
+                incorrectLogicOperatorError(tok, text, alwaysTrue, inconclusive, std::move(errorPath));
+            } else if (printStyle && (firstTrue || secondTrue)) {
+                const int which = isfloat ? sufficientCondition(std::move(op1), not1, d1, std::move(op2), not2, d2, isAnd) : sufficientCondition(std::move(op1), not1, i1, std::move(op2), not2, i2, isAnd);
+                std::string text;
+                if (which != 0) {
+                    text = "The condition '" + (which == 1 ? cond2str : cond1str) + "' is redundant since '" + (which == 1 ? cond1str : cond2str) + "' is sufficient.";
+                } else
+                    text = "If '" + (secondTrue ? cond1str : cond2str) + "', the comparison '" + (secondTrue ? cond2str : cond1str) + "' is always true.";
                 redundantConditionError(tok, text, inconclusive);
             }
         }
@@ -1188,22 +1357,26 @@ void CheckCondition::checkIncorrectLogicOperator()
 
 void CheckCondition::incorrectLogicOperatorError(const Token *tok, const std::string &condition, bool always, bool inconclusive, ErrorPath errors)
 {
+    if (diag(tok))
+        return;
     errors.emplace_back(tok, "");
     if (always)
-        reportError(errors, Severity::warning, "incorrectLogicOperator",
+        reportError(std::move(errors), Severity::warning, "incorrectLogicOperator",
                     "Logical disjunction always evaluates to true: " + condition + ".\n"
                     "Logical disjunction always evaluates to true: " + condition + ". "
-                    "Are these conditions necessary? Did you intend to use && instead? Are the numbers correct? Are you comparing the correct variables?", CWE571, inconclusive);
+                    "Are these conditions necessary? Did you intend to use && instead? Are the numbers correct? Are you comparing the correct variables?", CWE571, inconclusive ? Certainty::inconclusive : Certainty::normal);
     else
-        reportError(errors, Severity::warning, "incorrectLogicOperator",
+        reportError(std::move(errors), Severity::warning, "incorrectLogicOperator",
                     "Logical conjunction always evaluates to false: " + condition + ".\n"
                     "Logical conjunction always evaluates to false: " + condition + ". "
-                    "Are these conditions necessary? Did you intend to use || instead? Are the numbers correct? Are you comparing the correct variables?", CWE570, inconclusive);
+                    "Are these conditions necessary? Did you intend to use || instead? Are the numbers correct? Are you comparing the correct variables?", CWE570, inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
 void CheckCondition::redundantConditionError(const Token *tok, const std::string &text, bool inconclusive)
 {
-    reportError(tok, Severity::style, "redundantCondition", "Redundant condition: " + text, CWE398, inconclusive);
+    if (diag(tok))
+        return;
+    reportError(tok, Severity::style, "redundantCondition", "Redundant condition: " + text, CWE398, inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
 //-----------------------------------------------------------------------------
@@ -1211,9 +1384,11 @@ void CheckCondition::redundantConditionError(const Token *tok, const std::string
 //-----------------------------------------------------------------------------
 void CheckCondition::checkModuloAlwaysTrueFalse()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckCondition::checkModuloAlwaysTrueFalse"); // warning
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
@@ -1239,8 +1414,10 @@ void CheckCondition::checkModuloAlwaysTrueFalse()
 
 void CheckCondition::moduloAlwaysTrueFalseError(const Token* tok, const std::string& maxVal)
 {
+    if (diag(tok))
+        return;
     reportError(tok, Severity::warning, "moduloAlwaysTrueFalse",
-                "Comparison of modulo result is predetermined, because it is always less than " + maxVal + ".", CWE398, false);
+                "Comparison of modulo result is predetermined, because it is always less than " + maxVal + ".", CWE398, Certainty::normal);
 }
 
 static int countPar(const Token *tok1, const Token *tok2)
@@ -1263,10 +1440,10 @@ static int countPar(const Token *tok1, const Token *tok2)
 //---------------------------------------------------------------------------
 void CheckCondition::clarifyCondition()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("clarifyCondition"))
         return;
 
-    const bool isC = mTokenizer->isC();
+    logChecker("CheckCondition::clarifyCondition"); // style
 
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
@@ -1277,7 +1454,7 @@ void CheckCondition::clarifyCondition()
                         tok2 = tok2->link();
                     else if (tok2->isComparisonOp()) {
                         // This might be a template
-                        if (!isC && tok2->link())
+                        if (!tok2->isC() && tok2->link())
                             break;
                         if (Token::simpleMatch(tok2->astParent(), "?"))
                             break;
@@ -1322,89 +1499,125 @@ void CheckCondition::clarifyConditionError(const Token *tok, bool assign, bool b
     reportError(tok,
                 Severity::style,
                 "clarifyCondition",
-                errmsg, CWE398, false);
+                errmsg, CWE398, Certainty::normal);
 }
 
 void CheckCondition::alwaysTrueFalse()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    const bool pedantic = mSettings->isPremiumEnabled("alwaysTrue") ||
+                          mSettings->isPremiumEnabled("alwaysFalse") ||
+                          mSettings->isPremiumEnabled("knownConditionTrueFalse");
+
+    if (!pedantic && !mSettings->severity.isEnabled(Severity::style))
         return;
 
+    logChecker("CheckCondition::alwaysTrueFalse"); // style
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
-
-            if (tok->link()) // don't write false positives when templates are used
+            // don't write false positives when templates are used or inside of asserts or non-evaluated contexts
+            if (tok->link() && (Token::simpleMatch(tok, "<") ||
+                                Token::Match(tok->previous(), "static_assert|assert|ASSERT|sizeof|decltype ("))) {
+                tok = tok->link();
                 continue;
+            }
             if (!tok->hasKnownIntValue())
                 continue;
+            if (Token::Match(tok->previous(), "%name% (") && tok->previous()->function()) {
+                const Function* f = tok->previous()->function();
+                if (f->functionScope && Token::Match(f->functionScope->bodyStart, "{ return true|false ;"))
+                    continue;
+            }
+            const Token* condition = nullptr;
+            {
+                // is this a condition..
+                const Token *parent = tok->astParent();
+                while (Token::Match(parent, "%oror%|&&"))
+                    parent = parent->astParent();
+                if (!parent)
+                    continue;
+                if (parent->str() == "?" && precedes(tok, parent))
+                    condition = parent;
+                else if (Token::Match(parent->previous(), "if|while ("))
+                    condition = parent->previous();
+                else if (Token::simpleMatch(parent, "return"))
+                    condition = parent;
+                else if (parent->str() == ";" && parent->astParent() && parent->astParent()->astParent() &&
+                         Token::simpleMatch(parent->astParent()->astParent()->previous(), "for ("))
+                    condition = parent->astParent()->astParent()->previous();
+                else if (Token::Match(tok, "%comp%"))
+                    condition = tok;
+                else if (tok->str() == "(" && astIsBool(parent) && Token::Match(parent, "%assign%"))
+                    condition = tok;
+                else
+                    continue;
+            }
             // Skip already diagnosed values
             if (diag(tok, false))
                 continue;
-            if (Token::Match(tok, "%num%|%bool%|%char%"))
+            if (condition->isConstexpr())
                 continue;
-            if (Token::Match(tok, "! %num%|%bool%|%char%"))
+            if (!isUsedAsBool(tok, *mSettings))
                 continue;
-            if (Token::Match(tok, "%oror%|&&|:"))
+            if (Token::simpleMatch(condition, "return") && Token::Match(tok, "%assign%"))
                 continue;
-            if (Token::Match(tok, "%comp%") && isSameExpression(mTokenizer->isCPP(), true, tok->astOperand1(), tok->astOperand2(), mSettings->library, true, true))
+            if (Token::simpleMatch(tok->astParent(), "return") && Token::Match(tok, ".|%var%"))
                 continue;
-
-            const bool constIfWhileExpression =
-                tok->astParent() && Token::Match(tok->astTop()->astOperand1(), "if|while") && !tok->astTop()->astOperand1()->isConstexpr() &&
-                (Token::Match(tok->astParent(), "%oror%|&&") || Token::Match(tok->astParent()->astOperand1(), "if|while"));
-            const bool constValExpr = tok->isNumber() && Token::Match(tok->astParent(),"%oror%|&&|?"); // just one number in boolean expression
-            const bool compExpr = Token::Match(tok, "%comp%|!"); // a compare expression
-            const bool returnStatement = Token::simpleMatch(tok->astTop(), "return") &&
-                                         Token::Match(tok->astParent(), "%oror%|&&|return");
-            const bool ternaryExpression = Token::simpleMatch(tok->astParent(), "?");
-
-            if (!(constIfWhileExpression || constValExpr || compExpr || returnStatement || ternaryExpression))
+            if (Token::Match(tok, "%num%|%bool%|%char%"))
                 continue;
-
-            if (returnStatement && (!scope->function || !Token::simpleMatch(scope->function->retDef, "bool")))
+            if (Token::Match(tok, "! %num%|%bool%|%char%"))
                 continue;
-
-            if (returnStatement && isConstVarExpression(tok))
+            if (Token::Match(tok, "%oror%|&&")) {
+                bool bail = false;
+                for (const Token* op : { tok->astOperand1(), tok->astOperand2() }) {
+                    if (op->hasKnownIntValue() && (!op->isLiteral() || op->isBoolean())) {
+                        bail = true;
+                        break;
+                    }
+                }
+                if (bail)
+                    continue;
+            }
+            if (Token::simpleMatch(tok, ":"))
+                continue;
+            if (Token::Match(tok->astOperand1(), "%name% (") && Token::simpleMatch(tok->astParent(), "return"))
+                continue;
+            if (tok->isComparisonOp() && isWithoutSideEffects(tok->astOperand1()) &&
+                isSameExpression(true,
+                                 tok->astOperand1(),
+                                 tok->astOperand2(),
+                                 *mSettings,
+                                 true,
+                                 true))
                 continue;
 
-            if (returnStatement && Token::simpleMatch(tok->astParent(), "return") && tok->variable() && (
-                    !tok->variable()->isLocal() ||
-                    tok->variable()->isReference() ||
-                    tok->variable()->isConst() ||
-                    !isVariableChanged(tok->variable(), mSettings, mTokenizer->isCPP())))
+            if (!pedantic && isConstVarExpression(tok, [](const Token* tok) {
+                return Token::Match(tok, "[|(|&|+|-|*|/|%|^|>>|<<") && !Token::simpleMatch(tok, "( )");
+            }))
                 continue;
 
-            // Don't warn in assertions. Condition is often 'always true' by intention.
-            // If platform,defines,etc cause 'always false' then that is not dangerous neither.
-            bool assertFound = false;
-            for (const Token * tok2 = tok->astParent(); tok2 ; tok2 = tok2->astParent()) { // move backwards and try to find "assert"
-                if (tok2->str() == "(" && tok2->astOperand2()) {
-                    const std::string& str = tok2->previous()->str();
-                    if ((str.find("assert")!=std::string::npos || str.find("ASSERT")!=std::string::npos))
-                        assertFound = true;
-                    break;
-                }
+            // there are specific warnings about nonzero expressions (pointer/unsigned)
+            // do not write alwaysTrueFalse for these comparisons.
+            {
+                const ValueFlow::Value *zeroValue = nullptr;
+                const Token *nonZeroExpr = nullptr;
+                if (CheckOther::comparisonNonZeroExpressionLessThanZero(tok, zeroValue, nonZeroExpr, /*suppress*/ true) ||
+                    CheckOther::testIfNonZeroExpressionIsPositive(tok, zeroValue, nonZeroExpr))
+                    continue;
             }
-            if (assertFound)
-                continue;
 
             // Don't warn when there are expanded macros..
             bool isExpandedMacro = false;
-            std::stack<const Token*> tokens;
-            tokens.push(tok);
-            while (!tokens.empty()) {
-                const Token *tok2 = tokens.top();
-                tokens.pop();
+            visitAstNodes(tok, [&](const Token * tok2) {
                 if (!tok2)
-                    continue;
-                tokens.push(tok2->astOperand1());
-                tokens.push(tok2->astOperand2());
+                    return ChildrenToVisit::none;
                 if (tok2->isExpandedMacro()) {
                     isExpandedMacro = true;
-                    break;
+                    return ChildrenToVisit::done;
                 }
-            }
+                return ChildrenToVisit::op1_and_op2;
+            });
             if (isExpandedMacro)
                 continue;
             for (const Token *parent = tok; parent; parent = parent->astParent()) {
@@ -1418,112 +1631,161 @@ void CheckCondition::alwaysTrueFalse()
 
             // don't warn when condition checks sizeof result
             bool hasSizeof = false;
-            tokens.push(tok);
-            while (!tokens.empty()) {
-                const Token *tok2 = tokens.top();
-                tokens.pop();
+            visitAstNodes(tok, [&](const Token * tok2) {
                 if (!tok2)
-                    continue;
+                    return ChildrenToVisit::none;
                 if (tok2->isNumber())
-                    continue;
+                    return ChildrenToVisit::none;
                 if (Token::simpleMatch(tok2->previous(), "sizeof (")) {
                     hasSizeof = true;
-                    continue;
+                    return ChildrenToVisit::none;
                 }
                 if (tok2->isComparisonOp() || tok2->isArithmeticalOp()) {
-                    tokens.push(tok2->astOperand1());
-                    tokens.push(tok2->astOperand2());
-                } else
-                    break;
-            }
-            if (tokens.empty() && hasSizeof)
+                    return ChildrenToVisit::op1_and_op2;
+                }
+                return ChildrenToVisit::none;
+            });
+            if (hasSizeof)
                 continue;
 
-            alwaysTrueFalseError(tok, &tok->values().front());
+            alwaysTrueFalseError(tok, condition, &tok->values().front());
         }
     }
 }
 
-void CheckCondition::alwaysTrueFalseError(const Token *tok, const ValueFlow::Value *value)
+static std::string getConditionString(const Token* condition)
 {
-    const bool condvalue = value && (value->intvalue != 0);
+    if (Token::simpleMatch(condition, "return"))
+        return "Return value";
+    if (Token::simpleMatch(condition, "(") && Token::Match(condition->astParent(), "%assign%"))
+        return "Assigned value";
+    return "Condition";
+}
+
+void CheckCondition::alwaysTrueFalseError(const Token* tok, const Token* condition, const ValueFlow::Value* value)
+{
+    const bool alwaysTrue = value && (value->intvalue != 0 || value->isImpossible());
     const std::string expr = tok ? tok->expressionString() : std::string("x");
-    const std::string errmsg = "Condition '" + expr + "' is always " + (condvalue ? "true" : "false");
-    const ErrorPath errorPath = getErrorPath(tok, value, errmsg);
-    reportError(errorPath,
+    const std::string conditionStr = getConditionString(condition);
+    const std::string errmsg = conditionStr + " '" + expr + "' is always " + bool_to_string(alwaysTrue);
+    ErrorPath errorPath = getErrorPath(tok, value, errmsg);
+    reportError(std::move(errorPath),
                 Severity::style,
                 "knownConditionTrueFalse",
                 errmsg,
-                (condvalue ? CWE571 : CWE570), false);
+                (alwaysTrue ? CWE571 : CWE570), Certainty::normal);
 }
 
 void CheckCondition::checkInvalidTestForOverflow()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    // Interesting blogs:
+    // https://www.airs.com/blog/archives/120
+    // https://kristerw.blogspot.com/2016/02/how-undefined-signed-overflow-enables.html
+    // https://research.checkpoint.com/2020/optout-compiler-undefined-behavior-optimizations/
+
+    // x + c < x       ->   false
+    // x + c <= x      ->   false
+    // x + c > x       ->   true
+    // x + c >= x      ->   true
+
+    // x + y < x       ->   y < 0
+
+
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
-    const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
-    for (const Scope * scope : symbolDatabase->functionScopes) {
+    logChecker("CheckCondition::checkInvalidTestForOverflow"); // warning
 
-        for (const Token* tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
-            if (!tok->isComparisonOp() || !tok->astOperand1() || !tok->astOperand2())
-                continue;
+    for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
+        if (!Token::Match(tok, "<|<=|>=|>") || !tok->isBinaryOp())
+            continue;
 
-            const Token *calcToken, *exprToken;
-            bool result;
-            if (Token::Match(tok, "<|>=") && tok->astOperand1()->str() == "+") {
-                calcToken = tok->astOperand1();
-                exprToken = tok->astOperand2();
-                result = (tok->str() == ">=");
-            } else if (Token::Match(tok, ">|<=") && tok->astOperand2()->str() == "+") {
-                calcToken = tok->astOperand2();
-                exprToken = tok->astOperand1();
-                result = (tok->str() == "<=");
-            } else
-                continue;
+        const Token *lhsTokens[2] = {tok->astOperand1(), tok->astOperand2()};
+        for (const Token *lhs: lhsTokens) {
+            std::string cmp = tok->str();
+            if (lhs == tok->astOperand2())
+                cmp[0] = (cmp[0] == '<') ? '>' : '<';
 
-            // Only warn for signed integer overflows and pointer overflows.
-            if (!(calcToken->valueType() && (calcToken->valueType()->pointer || calcToken->valueType()->sign == ValueType::Sign::SIGNED)))
-                continue;
-            if (!(exprToken->valueType() && (exprToken->valueType()->pointer || exprToken->valueType()->sign == ValueType::Sign::SIGNED)))
+            if (!Token::Match(lhs, "[+-]") || !lhs->isBinaryOp())
                 continue;
 
-            const Token *termToken;
-            if (isSameExpression(mTokenizer->isCPP(), true, exprToken, calcToken->astOperand1(), mSettings->library, true, false))
-                termToken = calcToken->astOperand2();
-            else if (isSameExpression(mTokenizer->isCPP(), true, exprToken, calcToken->astOperand2(), mSettings->library, true, false))
-                termToken = calcToken->astOperand1();
-            else
+            const bool isSignedInteger = lhs->valueType() && lhs->valueType()->isIntegral() && lhs->valueType()->sign == ValueType::Sign::SIGNED;
+            const bool isPointer = lhs->valueType() && lhs->valueType()->pointer > 0;
+            if (!isSignedInteger && !isPointer)
                 continue;
 
-            if (!termToken)
-                continue;
+            const Token *exprTokens[2] = {lhs->astOperand1(), lhs->astOperand2()};
+            for (const Token *expr: exprTokens) {
+                if (lhs->str() == "-" && expr == lhs->astOperand2())
+                    continue; // TODO?
+
+                if (expr->hasKnownIntValue())
+                    continue;
+
+                if (!isSameExpression(true,
+                                      expr,
+                                      lhs->astSibling(),
+                                      *mSettings,
+                                      true,
+                                      false))
+                    continue;
 
-            // Only warn when termToken is always positive
-            if (termToken->valueType() && termToken->valueType()->sign == ValueType::Sign::UNSIGNED)
-                invalidTestForOverflow(tok, result);
-            else if (termToken->isNumber() && MathLib::isPositive(termToken->str()))
-                invalidTestForOverflow(tok, result);
+                const Token * const other = expr->astSibling();
+
+                // x [+-] c cmp x
+                if ((other->isNumber() && other->hasKnownIntValue() && other->getKnownIntValue() > 0) ||
+                    (!other->isNumber() && other->valueType() && other->valueType()->isIntegral() && other->valueType()->sign == ValueType::Sign::UNSIGNED)) {
+                    bool result;
+                    if (lhs->str() == "+")
+                        result = (cmp == ">" || cmp == ">=");
+                    else
+                        result = (cmp == "<" || cmp == "<=");
+                    invalidTestForOverflow(tok, lhs->valueType(), bool_to_string(result));
+                    continue;
+                }
+
+                // x + y cmp x
+                if (lhs->str() == "+" && other->varId() > 0) {
+                    const std::string result = other->str() + cmp + "0";
+                    invalidTestForOverflow(tok, lhs->valueType(), result);
+                    continue;
+                }
+
+                // x - y cmp x
+                if (lhs->str() == "-" && other->varId() > 0) {
+                    std::string cmp2 = cmp;
+                    cmp2[0] = (cmp[0] == '<') ? '>' : '<';
+                    const std::string result = other->str() + cmp2 + "0";
+                    invalidTestForOverflow(tok, lhs->valueType(), result);
+                    continue;
+                }
+            }
         }
     }
 }
 
-void CheckCondition::invalidTestForOverflow(const Token* tok, bool result)
+void CheckCondition::invalidTestForOverflow(const Token* tok, const ValueType *valueType, const std::string &replace)
 {
-    const std::string errmsg = "Invalid test for overflow '" +
-                               (tok ? tok->expressionString() : std::string("x + u < x")) +
-                               "'. Condition is always " +
-                               std::string(result ? "true" : "false") +
-                               " unless there is overflow, and overflow is undefined behaviour.";
-    reportError(tok, Severity::warning, "invalidTestForOverflow", errmsg, (result ? CWE571 : CWE570), false);
+    const std::string expr = (tok ? tok->expressionString() : std::string("x + c < x"));
+    const std::string overflow = (valueType && valueType->pointer) ? "pointer overflow" : "signed integer overflow";
+
+    std::string errmsg =
+        "Invalid test for overflow '" +  expr + "'; " + overflow + " is undefined behavior.";
+    if (replace == "false" || replace == "true")
+        errmsg += " Some mainstream compilers remove such overflow tests when optimising the code and assume it's always " + replace + ".";
+    else
+        errmsg += " Some mainstream compilers removes handling of overflows when optimising the code and change the code to '" + replace + "'.";
+    reportError(tok, Severity::warning, "invalidTestForOverflow", errmsg, uncheckedErrorConditionCWE, Certainty::normal);
 }
 
 
 void CheckCondition::checkPointerAdditionResultNotNull()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckCondition::checkPointerAdditionResultNotNull"); // warning
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
 
@@ -1566,21 +1828,24 @@ void CheckCondition::pointerAdditionResultNotNullError(const Token *tok, const T
 
 void CheckCondition::checkDuplicateConditionalAssign()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("duplicateConditionalAssign"))
         return;
 
+    logChecker("CheckCondition::checkDuplicateConditionalAssign"); // style
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope *scope : symbolDatabase->functionScopes) {
         for (const Token *tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
             if (!Token::simpleMatch(tok, "if ("))
                 continue;
-            if (!Token::simpleMatch(tok->next()->link(), ") {"))
+            if (!Token::simpleMatch(tok->linkAt(1), ") {"))
                 continue;
-            const Token *blockTok = tok->next()->link()->next();
+            const Token *blockTok = tok->linkAt(1)->next();
             const Token *condTok = tok->next()->astOperand2();
-            if (!Token::Match(condTok, "==|!="))
+            const bool isBoolVar = Token::Match(condTok, "!| %var%");
+            if (!isBoolVar && !Token::Match(condTok, "==|!="))
                 continue;
-            if (condTok->str() == "!=" && Token::simpleMatch(blockTok->link(), "} else {"))
+            if ((isBoolVar || condTok->str() == "!=") && Token::simpleMatch(blockTok->link(), "} else {"))
                 continue;
             if (!blockTok->next())
                 continue;
@@ -1589,18 +1854,36 @@ void CheckCondition::checkDuplicateConditionalAssign()
                 continue;
             if (nextAfterAstRightmostLeaf(assignTok) != blockTok->link()->previous())
                 continue;
-            if (!isSameExpression(
-                    mTokenizer->isCPP(), true, condTok->astOperand1(), assignTok->astOperand1(), mSettings->library, true, true))
-                continue;
-            if (!isSameExpression(
-                    mTokenizer->isCPP(), true, condTok->astOperand2(), assignTok->astOperand2(), mSettings->library, true, true))
-                continue;
-            duplicateConditionalAssignError(condTok, assignTok);
+            bool isRedundant = false;
+            if (isBoolVar) {
+                const bool isNegation = condTok->str() == "!";
+                const Token* const varTok = isNegation ? condTok->next() : condTok;
+                const ValueType* vt = varTok->variable() ? varTok->variable()->valueType() : nullptr;
+                if (!(vt && vt->type == ValueType::Type::BOOL && !vt->pointer))
+                    continue;
+
+                if (!(assignTok->astOperand1() && assignTok->astOperand1()->varId() == varTok->varId()))
+                    continue;
+                if (!(assignTok->astOperand2() && assignTok->astOperand2()->hasKnownIntValue()))
+                    continue;
+                const MathLib::bigint val = assignTok->astOperand2()->getKnownIntValue();
+                if (val < 0 || val > 1)
+                    continue;
+                isRedundant = (isNegation && val == 0) || (!isNegation && val == 1);
+            } else { // comparison
+                if (!isSameExpression(
+                        true, condTok->astOperand1(), assignTok->astOperand1(), *mSettings, true, true))
+                    continue;
+                if (!isSameExpression(
+                        true, condTok->astOperand2(), assignTok->astOperand2(), *mSettings, true, true))
+                    continue;
+            }
+            duplicateConditionalAssignError(condTok, assignTok, isRedundant);
         }
     }
 }
 
-void CheckCondition::duplicateConditionalAssignError(const Token *condTok, const Token* assignTok)
+void CheckCondition::duplicateConditionalAssignError(const Token *condTok, const Token* assignTok, bool isRedundant)
 {
     ErrorPath errors;
     std::string msg = "Duplicate expression for the condition and assignment.";
@@ -1610,12 +1893,236 @@ void CheckCondition::duplicateConditionalAssignError(const Token *condTok, const
             errors.emplace_back(condTok, "Condition '" + condTok->expressionString() + "'");
             errors.emplace_back(assignTok, "Assignment '" + assignTok->expressionString() + "' is redundant");
         } else {
-            msg = "The statement 'if (" + condTok->expressionString() + ") " + assignTok->expressionString() + "' is logically equivalent to '" + assignTok->expressionString() + "'.";
+            msg = "The statement 'if (" + condTok->expressionString() + ") " + assignTok->expressionString();
+            msg += isRedundant ? "' is redundant." : "' is logically equivalent to '" + assignTok->expressionString() + "'.";
             errors.emplace_back(assignTok, "Assignment '" + assignTok->expressionString() + "'");
             errors.emplace_back(condTok, "Condition '" + condTok->expressionString() + "' is redundant");
         }
     }
 
     reportError(
-        errors, Severity::style, "duplicateConditionalAssign", msg, CWE398, false);
+        std::move(errors), Severity::style, "duplicateConditionalAssign", msg, CWE398, Certainty::normal);
+}
+
+
+void CheckCondition::checkAssignmentInCondition()
+{
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("assignmentInCondition"))
+        return;
+
+    logChecker("CheckCondition::checkAssignmentInCondition"); // style
+
+    const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
+    for (const Scope * scope : symbolDatabase->functionScopes) {
+        for (const Token* tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
+            if (tok->str() != "=")
+                continue;
+            if (!tok->astParent())
+                continue;
+
+            // Is this assignment of container/iterator?
+            if (!tok->valueType())
+                continue;
+            if (tok->valueType()->pointer > 0)
+                continue;
+            if (tok->valueType()->type != ValueType::Type::CONTAINER && tok->valueType()->type != ValueType::Type::ITERATOR)
+                continue;
+
+            // warn if this is a conditional expression..
+            if (Token::Match(tok->astParent()->previous(), "if|while ("))
+                assignmentInCondition(tok);
+            else if (Token::Match(tok->astParent(), "%oror%|&&"))
+                assignmentInCondition(tok);
+            else if (Token::simpleMatch(tok->astParent(), "?") && tok == tok->astParent()->astOperand1())
+                assignmentInCondition(tok);
+        }
+    }
+}
+
+void CheckCondition::assignmentInCondition(const Token *eq)
+{
+    std::string expr = eq ? eq->expressionString() : "x=y";
+
+    reportError(
+        eq,
+        Severity::style,
+        "assignmentInCondition",
+        "Suspicious assignment in condition. Condition '" + expr + "' is always true.",
+        CWE571,
+        Certainty::normal);
+}
+
+void CheckCondition::checkCompareValueOutOfTypeRange()
+{
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("compareValueOutOfTypeRangeError"))
+        return;
+
+    if (mSettings->platform.type == Platform::Type::Unspecified)
+        return;
+
+    logChecker("CheckCondition::checkCompareValueOutOfTypeRange"); // style,platform
+
+    const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
+    for (const Scope * scope : symbolDatabase->functionScopes) {
+        for (const Token* tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
+            if (!tok->isComparisonOp() || !tok->isBinaryOp())
+                continue;
+
+            for (int i = 0; i < 2; ++i) {
+                const Token * const valueTok = (i == 0) ? tok->astOperand1() : tok->astOperand2();
+                const Token * const typeTok = valueTok->astSibling();
+                if (!valueTok->hasKnownIntValue() || !typeTok->valueType() || typeTok->valueType()->pointer)
+                    continue;
+                if (valueTok->getKnownIntValue() < 0 && valueTok->valueType() && valueTok->valueType()->sign != ValueType::Sign::SIGNED)
+                    continue;
+                if (valueTok->valueType() && valueTok->valueType()->isTypeEqual(typeTok->valueType()))
+                    continue;
+                std::uint8_t bits = 0;
+                switch (typeTok->valueType()->type) {
+                case ValueType::Type::BOOL:
+                    bits = 1;
+                    break;
+                case ValueType::Type::CHAR:
+                    bits = mSettings->platform.char_bit;
+                    break;
+                case ValueType::Type::SHORT:
+                    bits = mSettings->platform.short_bit;
+                    break;
+                case ValueType::Type::INT:
+                    bits = mSettings->platform.int_bit;
+                    break;
+                case ValueType::Type::LONG:
+                    bits = mSettings->platform.long_bit;
+                    break;
+                case ValueType::Type::LONGLONG:
+                    bits = mSettings->platform.long_long_bit;
+                    break;
+                default:
+                    break;
+                }
+                if (bits == 0 || bits >= 63)
+                    continue;
+
+                const auto typeMinValue = (typeTok->valueType()->sign == ValueType::Sign::UNSIGNED) ? 0 : (-(1LL << (bits-1)));
+                const auto unsignedTypeMaxValue = (1LL << bits) - 1LL;
+                long long typeMaxValue;
+                if (typeTok->valueType()->sign != ValueType::Sign::SIGNED)
+                    typeMaxValue = unsignedTypeMaxValue;
+                else if (bits >= mSettings->platform.int_bit && (!valueTok->valueType() || valueTok->valueType()->sign != ValueType::Sign::SIGNED))
+                    typeMaxValue = unsignedTypeMaxValue;
+                else
+                    typeMaxValue = unsignedTypeMaxValue / 2;
+
+                bool result{};
+                const auto kiv = valueTok->getKnownIntValue();
+                if (tok->str() == "==")
+                    result = false;
+                else if (tok->str() == "!=")
+                    result = true;
+                else if (tok->str()[0] == '>' && i == 0)
+                    // num > var
+                    result = (kiv > 0);
+                else if (tok->str()[0] == '>' && i == 1)
+                    // var > num
+                    result = (kiv < 0);
+                else if (tok->str()[0] == '<' && i == 0)
+                    // num < var
+                    result = (kiv < 0);
+                else if (tok->str()[0] == '<' && i == 1)
+                    // var < num
+                    result = (kiv > 0);
+
+                bool error = false;
+                if (kiv < typeMinValue || kiv > typeMaxValue) {
+                    error = true;
+                } else {
+                    switch (i) {
+                    case 0: // num cmp var
+                        if (kiv == typeMinValue) {
+                            if (tok->str() == "<=") {
+                                result = true;
+                                error = true;
+                            } else if (tok->str() == ">")
+                                error = true;
+                        }
+                        else if (kiv == typeMaxValue && (tok->str() == ">=" || tok->str() == "<")) {
+                            error = true;
+                        }
+                        break;
+                    case 1: // var cmp num
+                        if (kiv == typeMinValue) {
+                            if (tok->str() == ">=") {
+                                result = true;
+                                error = true;
+                            } else if (tok->str() == "<")
+                                error = true;
+                        }
+                        else if (kiv == typeMaxValue && (tok->str() == "<=" || tok->str() == ">")) {
+                            error = true;
+                        }
+                        break;
+                    }
+                }
+                if (!error || diag(tok))
+                    continue;
+                compareValueOutOfTypeRangeError(valueTok, typeTok->valueType()->str(), kiv, result);
+            }
+        }
+    }
+}
+
+void CheckCondition::compareValueOutOfTypeRangeError(const Token *comparison, const std::string &type, MathLib::bigint value, bool result)
+{
+    reportError(
+        comparison,
+        Severity::style,
+        "compareValueOutOfTypeRangeError",
+        "Comparing expression of type '" + type + "' against value " + MathLib::toString(value) + ". Condition is always " + bool_to_string(result) + ".",
+        CWE398,
+        Certainty::normal);
+}
+
+void CheckCondition::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    CheckCondition checkCondition(&tokenizer, &tokenizer.getSettings(), errorLogger);
+    checkCondition.multiCondition();
+    checkCondition.clarifyCondition();   // not simplified because ifAssign
+    checkCondition.multiCondition2();
+    checkCondition.checkIncorrectLogicOperator();
+    checkCondition.checkInvalidTestForOverflow();
+    checkCondition.duplicateCondition();
+    checkCondition.checkPointerAdditionResultNotNull();
+    checkCondition.checkDuplicateConditionalAssign();
+    checkCondition.assignIf();
+    checkCondition.checkBadBitmaskCheck();
+    checkCondition.comparison();
+    checkCondition.checkModuloAlwaysTrueFalse();
+    checkCondition.checkAssignmentInCondition();
+    checkCondition.checkCompareValueOutOfTypeRange();
+    checkCondition.alwaysTrueFalse();
+}
+
+void CheckCondition::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const
+{
+    CheckCondition c(nullptr, settings, errorLogger);
+
+    c.assignIfError(nullptr, nullptr, "", false);
+    c.badBitmaskCheckError(nullptr);
+    c.comparisonError(nullptr, "&", 6, "==", 1, false);
+    c.duplicateConditionError(nullptr, nullptr, ErrorPath{});
+    c.overlappingElseIfConditionError(nullptr, 1);
+    c.mismatchingBitAndError(nullptr, 0xf0, nullptr, 1);
+    c.oppositeInnerConditionError(nullptr, nullptr, ErrorPath{});
+    c.identicalInnerConditionError(nullptr, nullptr, ErrorPath{});
+    c.identicalConditionAfterEarlyExitError(nullptr, nullptr, ErrorPath{});
+    c.incorrectLogicOperatorError(nullptr, "foo > 3 && foo < 4", true, false, ErrorPath{});
+    c.redundantConditionError(nullptr, "If x > 11 the condition x > 10 is always true.", false);
+    c.moduloAlwaysTrueFalseError(nullptr, "1");
+    c.clarifyConditionError(nullptr, true, false);
+    c.alwaysTrueFalseError(nullptr, nullptr, nullptr);
+    c.invalidTestForOverflow(nullptr, nullptr, "false");
+    c.pointerAdditionResultNotNullError(nullptr, nullptr);
+    c.duplicateConditionalAssignError(nullptr, nullptr);
+    c.assignmentInCondition(nullptr);
+    c.compareValueOutOfTypeRangeError(nullptr, "unsigned char", 256, true);
 }
diff --git a/lib/checkcondition.h b/lib/checkcondition.h
index bcadceb2054..dac3ba8d0de 100644
--- a/lib/checkcondition.h
+++ b/lib/checkcondition.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -25,14 +25,21 @@
 #include "check.h"
 #include "config.h"
 #include "mathlib.h"
+#include "errortypes.h"
 
+#include <set>
 #include <string>
 
-class ErrorLogger;
 class Settings;
 class Token;
+class ErrorLogger;
+class ValueType;
 class Tokenizer;
 
+namespace ValueFlow {
+    class Value;
+}
+
 /// @addtogroup Checks
 /// @{
 
@@ -43,41 +50,25 @@ class Tokenizer;
 class CPPCHECKLIB CheckCondition : public Check {
 public:
     /** This constructor is used when registering the CheckAssignIf */
-    CheckCondition() : Check(myName()) {
-    }
+    CheckCondition() : Check(myName()) {}
 
+private:
     /** This constructor is used when running checks. */
     CheckCondition(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger) {}
 
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        CheckCondition checkCondition(tokenizer, settings, errorLogger);
-        checkCondition.multiCondition();
-        checkCondition.clarifyCondition();   // not simplified because ifAssign
-        checkCondition.multiCondition2();
-        checkCondition.checkIncorrectLogicOperator();
-        checkCondition.checkInvalidTestForOverflow();
-        checkCondition.duplicateCondition();
-        checkCondition.checkPointerAdditionResultNotNull();
-        checkCondition.checkDuplicateConditionalAssign();
-        checkCondition.assignIf();
-        checkCondition.alwaysTrueFalse();
-        checkCondition.checkBadBitmaskCheck();
-        checkCondition.comparison();
-        checkCondition.checkModuloAlwaysTrueFalse();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     /** mismatching assignment / comparison */
     void assignIf();
 
     /** parse scopes recursively */
-    bool assignIfParseScope(const Token * const assignTok,
-                            const Token * const startTok,
-                            const nonneg int varid,
-                            const bool islocal,
-                            const char bitop,
-                            const MathLib::bigint num);
+    bool assignIfParseScope(const Token * assignTok,
+                            const Token * startTok,
+                            nonneg int varid,
+                            bool islocal,
+                            char bitop,
+                            MathLib::bigint num);
 
     /** check bitmask using | instead of & */
     void checkBadBitmaskCheck();
@@ -118,15 +109,19 @@ class CPPCHECKLIB CheckCondition : public Check {
 
     void checkDuplicateConditionalAssign();
 
-private:
+    /** @brief Assignment in condition */
+    void checkAssignmentInCondition();
+
     // The conditions that have been diagnosed
     std::set<const Token*> mCondDiags;
     bool diag(const Token* tok, bool insert=true);
+    /** @brief Mark both token as diagnosed */
+    bool diag(const Token* tok1, const Token* tok2);
     bool isAliased(const std::set<int> &vars) const;
-    bool isOverlappingCond(const Token * const cond1, const Token * const cond2, bool pure) const;
+    bool isOverlappingCond(const Token * cond1, const Token * cond2, bool pure) const;
     void assignIfError(const Token *tok1, const Token *tok2, const std::string &condition, bool result);
-    void mismatchingBitAndError(const Token *tok1, const MathLib::bigint num1, const Token *tok2, const MathLib::bigint num2);
-    void badBitmaskCheckError(const Token *tok);
+    void mismatchingBitAndError(const Token *tok1, MathLib::bigint num1, const Token *tok2, MathLib::bigint num2);
+    void badBitmaskCheckError(const Token *tok, bool isNoOp = false);
     void comparisonError(const Token *tok,
                          const std::string &bitop,
                          MathLib::bigint value1,
@@ -150,42 +145,25 @@ class CPPCHECKLIB CheckCondition : public Check {
 
     void clarifyConditionError(const Token *tok, bool assign, bool boolop);
 
-    void alwaysTrueFalseError(const Token *tok, const ValueFlow::Value *value);
+    void alwaysTrueFalseError(const Token* tok, const Token* condition, const ValueFlow::Value* value);
 
-    void invalidTestForOverflow(const Token* tok, bool result);
+    void invalidTestForOverflow(const Token* tok, const ValueType *valueType, const std::string &replace);
     void pointerAdditionResultNotNullError(const Token *tok, const Token *calc);
 
-    void duplicateConditionalAssignError(const Token *condTok, const Token* assignTok);
-
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        CheckCondition c(nullptr, settings, errorLogger);
-
-        ErrorPath errorPath;
-
-        c.assignIfError(nullptr, nullptr, emptyString, false);
-        c.badBitmaskCheckError(nullptr);
-        c.comparisonError(nullptr, "&", 6, "==", 1, false);
-        c.duplicateConditionError(nullptr, nullptr, errorPath);
-        c.overlappingElseIfConditionError(nullptr, 1);
-        c.mismatchingBitAndError(nullptr, 0xf0, nullptr, 1);
-        c.oppositeInnerConditionError(nullptr, nullptr, errorPath);
-        c.identicalInnerConditionError(nullptr, nullptr, errorPath);
-        c.identicalConditionAfterEarlyExitError(nullptr, nullptr, errorPath);
-        c.incorrectLogicOperatorError(nullptr, "foo > 3 && foo < 4", true, false, errorPath);
-        c.redundantConditionError(nullptr, "If x > 11 the condition x > 10 is always true.", false);
-        c.moduloAlwaysTrueFalseError(nullptr, "1");
-        c.clarifyConditionError(nullptr, true, false);
-        c.alwaysTrueFalseError(nullptr, nullptr);
-        c.invalidTestForOverflow(nullptr, false);
-        c.pointerAdditionResultNotNullError(nullptr, nullptr);
-        c.duplicateConditionalAssignError(nullptr, nullptr);
-    }
+    void duplicateConditionalAssignError(const Token *condTok, const Token* assignTok, bool isRedundant = false);
+
+    void assignmentInCondition(const Token *eq);
+
+    void checkCompareValueOutOfTypeRange();
+    void compareValueOutOfTypeRangeError(const Token *comparison, const std::string &type, MathLib::bigint value, bool result);
+
+    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const override;
 
     static std::string myName() {
         return "Condition";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Match conditions with assignments and other conditions:\n"
                "- Mismatching assignment and comparison => comparison is always true/false\n"
                "- Mismatching lhs and rhs in comparison => comparison is always true/false\n"
@@ -199,7 +177,8 @@ class CPPCHECKLIB CheckCondition : public Check {
                "- Mutual exclusion over || always evaluating to true\n"
                "- Comparisons of modulo results that are always true/false.\n"
                "- Known variable values => condition is always true/false\n"
-               "- Invalid test for overflow (for example 'ptr+u < ptr'). Condition is always false unless there is overflow, and overflow is undefined behaviour.\n";
+               "- Invalid test for overflow. Some mainstream compilers remove such overflow tests when optimising code.\n"
+               "- Suspicious assignment of container/iterator in condition => condition is always true.\n";
     }
 };
 /// @}
diff --git a/lib/checkers.cpp b/lib/checkers.cpp
new file mode 100644
index 00000000000..f7d7f913da6
--- /dev/null
+++ b/lib/checkers.cpp
@@ -0,0 +1,2059 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// This file is auto-generated by tools/get_checkers.py:
+// python3 tools/get_checkers.py > lib/checkers.cpp
+
+#include "checkers.h"
+
+namespace checkers {
+    const std::map<std::string, std::string> allCheckers{
+        {"Check64BitPortability::pointerassignment","portability"},
+        {"CheckAssert::assertWithSideEffects","warning"},
+        {"CheckAutoVariables::assignFunctionArg","style,warning"},
+        {"CheckAutoVariables::autoVariables",""},
+        {"CheckAutoVariables::checkVarLifetime",""},
+        {"CheckBool::checkAssignBoolToFloat","style,c++"},
+        {"CheckBool::checkAssignBoolToPointer",""},
+        {"CheckBool::checkBitwiseOnBoolean","style,inconclusive"},
+        {"CheckBool::checkComparisonOfBoolExpressionWithInt","warning"},
+        {"CheckBool::checkComparisonOfBoolWithBool","style,c++"},
+        {"CheckBool::checkComparisonOfBoolWithInt","warning,c++"},
+        {"CheckBool::checkComparisonOfFuncReturningBool","style,c++"},
+        {"CheckBool::checkIncrementBoolean","style"},
+        {"CheckBool::pointerArithBool",""},
+        {"CheckBool::returnValueOfFunctionReturningBool","style"},
+        {"CheckBufferOverrun::analyseWholeProgram",""},
+        {"CheckBufferOverrun::argumentSize","warning"},
+        {"CheckBufferOverrun::arrayIndex",""},
+        {"CheckBufferOverrun::arrayIndexThenCheck","style"},
+        {"CheckBufferOverrun::bufferOverflow",""},
+        {"CheckBufferOverrun::negativeArraySize",""},
+        {"CheckBufferOverrun::objectIndex",""},
+        {"CheckBufferOverrun::pointerArithmetic","portability"},
+        {"CheckBufferOverrun::stringNotZeroTerminated","warning,inconclusive"},
+        {"CheckClass::analyseWholeProgram",""},
+        {"CheckClass::checkConst","style,inconclusive"},
+        {"CheckClass::checkConstructors","style,warning"},
+        {"CheckClass::checkCopyConstructors","warning"},
+        {"CheckClass::checkDuplInheritedMembers","warning"},
+        {"CheckClass::checkExplicitConstructors","style"},
+        {"CheckClass::checkMemset",""},
+        {"CheckClass::checkMissingOverride","style,c++03"},
+        {"CheckClass::checkReturnByReference","performance"},
+        {"CheckClass::checkSelfInitialization",""},
+        {"CheckClass::checkThisUseAfterFree","warning"},
+        {"CheckClass::checkUnsafeClassRefMember","warning,safeChecks"},
+        {"CheckClass::checkUselessOverride","style"},
+        {"CheckClass::checkVirtualFunctionCallInConstructor","warning"},
+        {"CheckClass::initializationListUsage","performance"},
+        {"CheckClass::initializerListOrder","style,inconclusive"},
+        {"CheckClass::operatorEqRetRefThis","style"},
+        {"CheckClass::operatorEqToSelf","warning"},
+        {"CheckClass::privateFunctions","style"},
+        {"CheckClass::thisSubtraction","warning"},
+        {"CheckClass::virtualDestructor",""},
+        {"CheckCondition::alwaysTrueFalse","style"},
+        {"CheckCondition::assignIf","style"},
+        {"CheckCondition::checkAssignmentInCondition","style"},
+        {"CheckCondition::checkBadBitmaskCheck","style"},
+        {"CheckCondition::checkCompareValueOutOfTypeRange","style,platform"},
+        {"CheckCondition::checkDuplicateConditionalAssign","style"},
+        {"CheckCondition::checkIncorrectLogicOperator","style,warning"},
+        {"CheckCondition::checkInvalidTestForOverflow","warning"},
+        {"CheckCondition::checkModuloAlwaysTrueFalse","warning"},
+        {"CheckCondition::checkPointerAdditionResultNotNull","warning"},
+        {"CheckCondition::clarifyCondition","style"},
+        {"CheckCondition::comparison","style"},
+        {"CheckCondition::duplicateCondition","style"},
+        {"CheckCondition::multiCondition","style"},
+        {"CheckCondition::multiCondition2","warning"},
+        {"CheckExceptionSafety::checkCatchExceptionByValue","style"},
+        {"CheckExceptionSafety::checkRethrowCopy","style"},
+        {"CheckExceptionSafety::deallocThrow","warning"},
+        {"CheckExceptionSafety::destructors","warning"},
+        {"CheckExceptionSafety::nothrowThrows",""},
+        {"CheckExceptionSafety::rethrowNoCurrentException",""},
+        {"CheckExceptionSafety::unhandledExceptionSpecification","style,inconclusive"},
+        {"CheckFunctions::checkIgnoredReturnValue","style,warning"},
+        {"CheckFunctions::checkMathFunctions","style,warning,c99,c++11"},
+        {"CheckFunctions::checkMissingReturn",""},
+        {"CheckFunctions::checkProhibitedFunctions",""},
+        {"CheckFunctions::invalidFunctionUsage",""},
+        {"CheckFunctions::memsetInvalid2ndParam","warning,portability"},
+        {"CheckFunctions::memsetZeroBytes","warning"},
+        {"CheckFunctions::returnLocalStdMove","performance,c++11"},
+        {"CheckFunctions::useStandardLibrary","style"},
+        {"CheckIO::checkCoutCerrMisusage","c"},
+        {"CheckIO::checkFileUsage",""},
+        {"CheckIO::checkWrongPrintfScanfArguments",""},
+        {"CheckIO::invalidScanf",""},
+        {"CheckLeakAutoVar::check","notclang"},
+        {"CheckMemoryLeakInClass::check",""},
+        {"CheckMemoryLeakInFunction::checkReallocUsage",""},
+        {"CheckMemoryLeakNoVar::check",""},
+        {"CheckMemoryLeakNoVar::checkForUnsafeArgAlloc",""},
+        {"CheckMemoryLeakStructMember::check",""},
+        {"CheckNullPointer::analyseWholeProgram","unusedfunctions"},
+        {"CheckNullPointer::arithmetic",""},
+        {"CheckNullPointer::nullConstantDereference",""},
+        {"CheckNullPointer::nullPointer",""},
+        {"CheckOther::checkAccessOfMovedVariable","c++11,warning"},
+        {"CheckOther::checkCastIntToCharAndBack","warning"},
+        {"CheckOther::checkCharVariable","warning,portability"},
+        {"CheckOther::checkComparePointers",""},
+        {"CheckOther::checkComparisonFunctionIsAlwaysTrueOrFalse","warning"},
+        {"CheckOther::checkConstPointer","style"},
+        {"CheckOther::checkConstVariable","style,c++"},
+        {"CheckOther::checkDuplicateBranch","style,inconclusive"},
+        {"CheckOther::checkDuplicateExpression","style,warning"},
+        {"CheckOther::checkEvaluationOrder",""},
+        {"CheckOther::checkFuncArgNamesDifferent","style,warning,inconclusive"},
+        {"CheckOther::checkIncompleteArrayFill","warning,portability,inconclusive"},
+        {"CheckOther::checkIncompleteStatement","warning"},
+        {"CheckOther::checkInterlockedDecrement","windows-platform"},
+        {"CheckOther::checkInvalidFree",""},
+        {"CheckOther::checkKnownArgument","style"},
+        {"CheckOther::checkKnownPointerToBool","style"},
+        {"CheckOther::checkMisusedScopedObject","style,c++"},
+        {"CheckOther::checkModuloOfOne","style"},
+        {"CheckOther::checkNanInArithmeticExpression","style"},
+        {"CheckOther::checkNegativeBitwiseShift",""},
+        {"CheckOther::checkOverlappingWrite",""},
+        {"CheckOther::checkPassByReference","performance,c++"},
+        {"CheckOther::checkRedundantAssignment","style"},
+        {"CheckOther::checkRedundantCopy","c++,performance,inconclusive"},
+        {"CheckOther::checkRedundantPointerOp","style"},
+        {"CheckOther::checkShadowVariables","style"},
+        {"CheckOther::checkSignOfUnsignedVariable","style"},
+        {"CheckOther::checkSuspiciousCaseInSwitch","warning,inconclusive"},
+        {"CheckOther::checkSuspiciousSemicolon","warning,inconclusive"},
+        {"CheckOther::checkUnionZeroInit","portability"},
+        {"CheckOther::checkUnreachableCode","style"},
+        {"CheckOther::checkUnusedLabel","style,warning"},
+        {"CheckOther::checkVarFuncNullUB","portability"},
+        {"CheckOther::checkVariableScope","style,notclang"},
+        {"CheckOther::checkZeroDivision",""},
+        {"CheckOther::clarifyCalculation","style"},
+        {"CheckOther::clarifyStatement","warning"},
+        {"CheckOther::invalidPointerCast","portability"},
+        {"CheckOther::redundantBitwiseOperationInSwitch","warning"},
+        {"CheckOther::suspiciousFloatingPointCast","style"},
+        {"CheckOther::warningDangerousTypeCast","warning,c++"},
+        {"CheckOther::warningIntToPointerCast","portability"},
+        {"CheckOther::warningOldStylePointerCast","style,c++"},
+        {"CheckPostfixOperator::postfixOperator","performance"},
+        {"CheckSizeof::checkSizeofForArrayParameter","warning"},
+        {"CheckSizeof::checkSizeofForNumericParameter","warning"},
+        {"CheckSizeof::checkSizeofForPointerSize","warning"},
+        {"CheckSizeof::sizeofCalculation","warning"},
+        {"CheckSizeof::sizeofFunction","warning"},
+        {"CheckSizeof::sizeofVoid","portability"},
+        {"CheckSizeof::sizeofsizeof","warning"},
+        {"CheckSizeof::suspiciousSizeofCalculation","warning,inconclusive"},
+        {"CheckStl::checkDereferenceInvalidIterator","warning"},
+        {"CheckStl::checkDereferenceInvalidIterator2",""},
+        {"CheckStl::checkFindInsert","performance"},
+        {"CheckStl::checkMutexes","warning"},
+        {"CheckStl::erase",""},
+        {"CheckStl::eraseIteratorOutOfBounds",""},
+        {"CheckStl::if_find","warning,performance"},
+        {"CheckStl::invalidContainer",""},
+        {"CheckStl::iterators",""},
+        {"CheckStl::knownEmptyContainer","style"},
+        {"CheckStl::misMatchingContainerIterator",""},
+        {"CheckStl::misMatchingContainers",""},
+        {"CheckStl::missingComparison","warning"},
+        {"CheckStl::negativeIndex",""},
+        {"CheckStl::outOfBounds",""},
+        {"CheckStl::outOfBoundsIndexExpression",""},
+        {"CheckStl::redundantCondition","style"},
+        {"CheckStl::size","performance,c++03"},
+        {"CheckStl::stlBoundaries",""},
+        {"CheckStl::stlOutOfBounds",""},
+        {"CheckStl::string_c_str",""},
+        {"CheckStl::useStlAlgorithm","style"},
+        {"CheckStl::uselessCalls","performance,warning"},
+        {"CheckString::checkAlwaysTrueOrFalseStringCompare","warning"},
+        {"CheckString::checkIncorrectStringCompare","warning"},
+        {"CheckString::checkSuspiciousStringCompare","warning"},
+        {"CheckString::overlappingStrcmp","warning"},
+        {"CheckString::sprintfOverlappingData",""},
+        {"CheckString::strPlusChar",""},
+        {"CheckString::stringLiteralWrite",""},
+        {"CheckType::checkFloatToIntegerOverflow",""},
+        {"CheckType::checkIntegerOverflow","platform"},
+        {"CheckType::checkLongCast","style"},
+        {"CheckType::checkSignConversion","warning"},
+        {"CheckType::checkTooBigBitwiseShift","platform"},
+        {"CheckUninitVar::analyseWholeProgram",""},
+        {"CheckUninitVar::check",""},
+        {"CheckUninitVar::valueFlowUninit",""},
+        {"CheckUnusedFunctions::check","unusedFunction"},
+        {"CheckUnusedVar::checkFunctionVariableUsage","style"},
+        {"CheckUnusedVar::checkStructMemberUsage","style"},
+        {"CheckVaarg::va_list_usage","notclang"},
+        {"CheckVaarg::va_start_argument",""},
+    };
+
+
+    const char Req[] = "Required";
+    const char Adv[] = "Advisory";
+    const char Man[] = "Mandatory";
+    const char Doc[] = "Document";
+    const char Dis[] = "Disapplied";
+    const std::vector<MisraInfo> misraC2012Directives{
+        {1,1,Req,0},
+        {2,1,Req,0},
+        {3,1,Req,0},
+        {4,1,Req,0},
+        {4,2,Adv,0},
+        {4,3,Req,0},
+        {4,4,Adv,0},
+        {4,5,Adv,0},
+        {4,6,Adv,3},
+        {4,7,Req,0},
+        {4,8,Adv,0},
+        {4,9,Adv,3},
+        {4,10,Req,0},
+        {4,11,Req,3},
+        {4,12,Req,0},
+        {4,13,Adv,0},
+        {4,14,Req,2},
+        {4,15,Req,3},
+        {5,1,Req,4},
+        {5,2,Req,4},
+        {5,3,Req,4},
+    };
+    const std::vector<MisraInfo> misraC2012Rules{
+        {1,1,Req,0},
+        {1,2,Adv,0},
+        {1,3,Req,0},
+        {1,4,Req,2}, // Amendment 2
+        {1,5,Req,3}, // Amendment 3
+        {2,1,Req,0},
+        {2,2,Req,0},
+        {2,3,Adv,0},
+        {2,4,Adv,0},
+        {2,5,Adv,0},
+        {2,6,Adv,0},
+        {2,7,Adv,0},
+        {2,8,Adv,0},
+        {3,1,Req,0},
+        {3,2,Req,0},
+        {4,1,Req,0},
+        {4,2,Adv,0},
+        {5,1,Req,0},
+        {5,2,Req,0},
+        {5,3,Req,0},
+        {5,4,Req,0},
+        {5,5,Req,0},
+        {5,6,Req,0},
+        {5,7,Req,0},
+        {5,8,Req,0},
+        {5,9,Adv,0},
+        {6,1,Req,0},
+        {6,2,Req,0},
+        {6,3,Req,0},
+        {7,1,Req,0},
+        {7,2,Req,0},
+        {7,3,Req,0},
+        {7,4,Req,0},
+        {7,5,Man,0},
+        {7,6,Req,0},
+        {8,1,Req,0},
+        {8,2,Req,0},
+        {8,3,Req,0},
+        {8,4,Req,0},
+        {8,5,Req,0},
+        {8,6,Req,0},
+        {8,7,Adv,0},
+        {8,8,Req,0},
+        {8,9,Adv,0},
+        {8,10,Req,0},
+        {8,11,Adv,0},
+        {8,12,Req,0},
+        {8,13,Adv,0},
+        {8,14,Req,0},
+        {8,15,Req,0},
+        {8,16,Adv,0},
+        {8,17,Adv,0},
+        {9,1,Man,0},
+        {9,2,Req,0},
+        {9,3,Req,0},
+        {9,4,Req,0},
+        {9,5,Req,0},
+        {9,6,Req,0},
+        {9,7,Man,0},
+        {10,1,Req,0},
+        {10,2,Req,0},
+        {10,3,Req,0},
+        {10,4,Req,0},
+        {10,5,Adv,0},
+        {10,6,Req,0},
+        {10,7,Req,0},
+        {10,8,Req,0},
+        {11,1,Req,0},
+        {11,2,Req,0},
+        {11,3,Req,0},
+        {11,4,Adv,0},
+        {11,5,Adv,0},
+        {11,6,Req,0},
+        {11,7,Req,0},
+        {11,8,Req,0},
+        {11,9,Req,0},
+        {11,10,Req,0},
+        {12,1,Adv,0},
+        {12,2,Req,0},
+        {12,3,Adv,0},
+        {12,4,Adv,0},
+        {12,5,Man,1}, // Amendment 1
+        {12,6,Req,4}, // Amendment 4
+        {13,1,Req,0},
+        {13,2,Req,0},
+        {13,3,Adv,0},
+        {13,4,Adv,0},
+        {13,5,Req,0},
+        {13,6,Req,0},
+        {14,1,Req,0},
+        {14,2,Req,0},
+        {14,3,Req,0},
+        {14,4,Req,0},
+        {15,1,Adv,0},
+        {15,2,Req,0},
+        {15,3,Req,0},
+        {15,4,Adv,0},
+        {15,5,Adv,0},
+        {15,6,Req,0},
+        {15,7,Req,0},
+        {16,1,Req,0},
+        {16,2,Req,0},
+        {16,3,Req,0},
+        {16,4,Req,0},
+        {16,5,Req,0},
+        {16,6,Req,0},
+        {16,7,Req,0},
+        {17,1,Req,0},
+        {17,2,Req,0},
+        {17,3,Man,0},
+        {17,4,Man,0},
+        {17,5,Req,0},
+        {17,6,Man,0},
+        {17,7,Req,0},
+        {17,8,Adv,0},
+        {17,9,Man,0},
+        {17,10,Req,0},
+        {17,11,Adv,0},
+        {17,12,Adv,0},
+        {17,13,Req,0},
+        {18,1,Req,0},
+        {18,2,Req,0},
+        {18,3,Req,0},
+        {18,4,Adv,0},
+        {18,5,Adv,0},
+        {18,6,Req,0},
+        {18,7,Req,0},
+        {18,8,Req,0},
+        {18,9,Req,0},
+        {18,10,Man,0},
+        {19,1,Man,0},
+        {19,2,Adv,0},
+        {20,1,Adv,0},
+        {20,2,Req,0},
+        {20,3,Req,0},
+        {20,4,Req,0},
+        {20,5,Adv,0},
+        {20,6,Req,0},
+        {20,7,Req,0},
+        {20,8,Req,0},
+        {20,9,Req,0},
+        {20,10,Adv,0},
+        {20,11,Req,0},
+        {20,12,Req,0},
+        {20,13,Req,0},
+        {20,14,Req,0},
+        {21,1,Req,0},
+        {21,2,Req,0},
+        {21,3,Req,0},
+        {21,4,Req,0},
+        {21,5,Req,0},
+        {21,6,Req,0},
+        {21,7,Req,0},
+        {21,8,Req,0},
+        {21,9,Req,0},
+        {21,10,Req,0},
+        {21,11,Adv,0},
+        {21,12,Req,0},
+        {21,13,Man,1}, // Amendment 1
+        {21,14,Req,1}, // Amendment 1
+        {21,15,Req,1}, // Amendment 1
+        {21,16,Req,1}, // Amendment 1
+        {21,17,Man,1}, // Amendment 1
+        {21,18,Man,1}, // Amendment 1
+        {21,19,Man,1}, // Amendment 1
+        {21,20,Man,1}, // Amendment 1
+        {21,21,Req,3}, // Amendment 3
+        {21,22,Man,3}, // Amendment 3
+        {21,23,Req,3}, // Amendment 3
+        {21,24,Req,3}, // Amendment 3
+        {21,25,Req,4}, // Amendment 4
+        {21,26,Req,4}, // Amendment 4
+        {22,1,Req,0},
+        {22,2,Man,0},
+        {22,3,Req,0},
+        {22,4,Man,0},
+        {22,5,Man,0},
+        {22,6,Man,0},
+        {22,7,Req,1}, // Amendment 1
+        {22,8,Req,1}, // Amendment 1
+        {22,9,Req,1}, // Amendment 1
+        {22,10,Req,1}, // Amendment 1
+        {22,11,Req,4}, // Amendment 4
+        {22,12,Man,4}, // Amendment 4
+        {22,13,Req,4}, // Amendment 4
+        {22,14,Req,4}, // Amendment 4
+        {22,15,Req,4}, // Amendment 4
+        {22,16,Req,4}, // Amendment 4
+        {22,17,Req,4}, // Amendment 4
+        {22,18,Req,4}, // Amendment 4
+        {22,19,Req,4}, // Amendment 4
+        {22,20,Man,4}, // Amendment 4
+        {23,1,Adv,3}, // Amendment 3
+        {23,2,Req,3}, // Amendment 3
+        {23,3,Adv,3}, // Amendment 3
+        {23,4,Req,3}, // Amendment 3
+        {23,5,Adv,3}, // Amendment 3
+        {23,6,Req,3}, // Amendment 3
+        {23,7,Adv,3}, // Amendment 3
+        {23,8,Req,3}, // Amendment 3
+    };
+    const std::vector<MisraInfo> misraC2023Directives{
+        {1,1,Req,0},
+        {2,1,Req,0},
+        {3,1,Req,0},
+        {4,1,Req,0},
+        {4,2,Adv,0},
+        {4,3,Req,0},
+        {4,4,Adv,0},
+        {4,5,Adv,0},
+        {4,6,Adv,0},
+        {4,7,Req,0},
+        {4,8,Adv,0},
+        {4,9,Adv,0},
+        {4,10,Req,0},
+        {4,11,Req,0},
+        {4,12,Req,0},
+        {4,13,Adv,0},
+        {4,14,Req,0},
+        {4,15,Req,0},
+        {5,1,Req,0},
+        {5,2,Req,0},
+        {5,3,Req,0},
+    };
+    const std::vector<MisraInfo> misraC2023Rules{
+        {1,1,Req,0},
+        {1,2,Adv,0},
+        {1,3,Req,0},
+        {1,4,Req,0},
+        {1,5,Req,0},
+        {2,1,Req,0},
+        {2,2,Req,0},
+        {2,3,Adv,0},
+        {2,4,Adv,0},
+        {2,5,Adv,0},
+        {2,6,Adv,0},
+        {2,7,Adv,0},
+        {2,8,Adv,0},
+        {3,1,Req,0},
+        {3,2,Req,0},
+        {4,1,Req,0},
+        {4,2,Adv,0},
+        {5,1,Req,0},
+        {5,2,Req,0},
+        {5,3,Req,0},
+        {5,4,Req,0},
+        {5,5,Req,0},
+        {5,6,Req,0},
+        {5,7,Req,0},
+        {5,8,Req,0},
+        {5,9,Adv,0},
+        {6,1,Req,0},
+        {6,2,Req,0},
+        {6,3,Req,0},
+        {7,1,Req,0},
+        {7,2,Req,0},
+        {7,3,Req,0},
+        {7,4,Req,0},
+        {7,5,Man,0},
+        {7,6,Req,0},
+        {8,1,Req,0},
+        {8,2,Req,0},
+        {8,3,Req,0},
+        {8,4,Req,0},
+        {8,5,Req,0},
+        {8,6,Req,0},
+        {8,7,Adv,0},
+        {8,8,Req,0},
+        {8,9,Adv,0},
+        {8,10,Req,0},
+        {8,11,Adv,0},
+        {8,12,Req,0},
+        {8,13,Adv,0},
+        {8,14,Req,0},
+        {8,15,Req,0},
+        {8,16,Adv,0},
+        {8,17,Adv,0},
+        {9,1,Man,0},
+        {9,2,Req,0},
+        {9,3,Req,0},
+        {9,4,Req,0},
+        {9,5,Req,0},
+        {9,6,Req,0},
+        {9,7,Man,0},
+        {10,1,Req,0},
+        {10,2,Req,0},
+        {10,3,Req,0},
+        {10,4,Req,0},
+        {10,5,Adv,0},
+        {10,6,Req,0},
+        {10,7,Req,0},
+        {10,8,Req,0},
+        {11,1,Req,0},
+        {11,2,Req,0},
+        {11,3,Req,0},
+        {11,4,Adv,0},
+        {11,5,Adv,0},
+        {11,6,Req,0},
+        {11,7,Req,0},
+        {11,8,Req,0},
+        {11,9,Req,0},
+        {11,10,Req,0},
+        {12,1,Adv,0},
+        {12,2,Req,0},
+        {12,3,Adv,0},
+        {12,4,Adv,0},
+        {12,5,Man,0},
+        {12,6,Req,0},
+        {13,1,Req,0},
+        {13,2,Req,0},
+        {13,3,Adv,0},
+        {13,4,Adv,0},
+        {13,5,Req,0},
+        {13,6,Req,0},
+        {14,1,Req,0},
+        {14,2,Req,0},
+        {14,3,Req,0},
+        {14,4,Req,0},
+        {15,1,Adv,0},
+        {15,2,Req,0},
+        {15,3,Req,0},
+        {15,4,Adv,0},
+        {15,5,Adv,0},
+        {15,6,Req,0},
+        {15,7,Req,0},
+        {16,1,Req,0},
+        {16,2,Req,0},
+        {16,3,Req,0},
+        {16,4,Req,0},
+        {16,5,Req,0},
+        {16,6,Req,0},
+        {16,7,Req,0},
+        {17,1,Req,0},
+        {17,2,Req,0},
+        {17,3,Man,0},
+        {17,4,Man,0},
+        {17,5,Req,0},
+        {17,6,Man,0},
+        {17,7,Req,0},
+        {17,8,Adv,0},
+        {17,9,Man,0},
+        {17,10,Req,0},
+        {17,11,Adv,0},
+        {17,12,Adv,0},
+        {17,13,Req,0},
+        {18,1,Req,0},
+        {18,2,Req,0},
+        {18,3,Req,0},
+        {18,4,Adv,0},
+        {18,5,Adv,0},
+        {18,6,Req,0},
+        {18,7,Req,0},
+        {18,8,Req,0},
+        {18,9,Req,0},
+        {18,10,Man,0},
+        {19,1,Man,0},
+        {19,2,Adv,0},
+        {20,1,Adv,0},
+        {20,2,Req,0},
+        {20,3,Req,0},
+        {20,4,Req,0},
+        {20,5,Adv,0},
+        {20,6,Req,0},
+        {20,7,Req,0},
+        {20,8,Req,0},
+        {20,9,Req,0},
+        {20,10,Adv,0},
+        {20,11,Req,0},
+        {20,12,Req,0},
+        {20,13,Req,0},
+        {20,14,Req,0},
+        {21,1,Req,0},
+        {21,2,Req,0},
+        {21,3,Req,0},
+        {21,4,Req,0},
+        {21,5,Req,0},
+        {21,6,Req,0},
+        {21,7,Req,0},
+        {21,8,Req,0},
+        {21,9,Req,0},
+        {21,10,Req,0},
+        {21,11,Adv,0},
+        {21,12,Req,0},
+        {21,13,Man,0},
+        {21,14,Req,0},
+        {21,15,Req,0},
+        {21,16,Req,0},
+        {21,17,Man,0},
+        {21,18,Man,0},
+        {21,19,Man,0},
+        {21,20,Man,0},
+        {21,21,Req,0},
+        {21,22,Man,0},
+        {21,23,Req,0},
+        {21,24,Req,0},
+        {21,25,Req,0},
+        {21,26,Req,0},
+        {22,1,Req,0},
+        {22,2,Man,0},
+        {22,3,Req,0},
+        {22,4,Man,0},
+        {22,5,Man,0},
+        {22,6,Man,0},
+        {22,7,Req,0},
+        {22,8,Req,0},
+        {22,9,Req,0},
+        {22,10,Req,0},
+        {22,11,Req,0},
+        {22,12,Man,0},
+        {22,13,Req,0},
+        {22,14,Man,0},
+        {22,15,Req,0},
+        {22,16,Req,0},
+        {22,17,Req,0},
+        {22,18,Req,0},
+        {22,19,Req,0},
+        {22,20,Man,0},
+        {23,1,Adv,0},
+        {23,2,Req,0},
+        {23,3,Adv,0},
+        {23,4,Req,0},
+        {23,5,Adv,0},
+        {23,6,Req,0},
+        {23,7,Adv,0},
+        {23,8,Req,0},
+    };
+    const std::vector<MisraInfo> misraC2025Directives{
+        {1,1,Req,0},
+        {1,2,Adv,0},
+        {2,1,Req,0},
+        {3,1,Req,0},
+        {4,1,Req,0},
+        {4,2,Adv,0},
+        {4,3,Req,0},
+        {4,4,Adv,0},
+        {4,5,Adv,0},
+        {4,6,Adv,0},
+        {4,7,Req,0},
+        {4,8,Adv,0},
+        {4,9,Adv,0},
+        {4,10,Req,0},
+        {4,11,Req,0},
+        {4,12,Req,0},
+        {4,13,Adv,0},
+        {4,14,Req,0},
+        {4,15,Req,0},
+        {5,1,Req,0},
+        {5,2,Req,0},
+        {5,3,Req,0},
+    };
+    const std::vector<MisraInfo> misraC2025Rules{
+        {1,1,Req,0},
+        {1,3,Req,0},
+        {1,4,Req,0},
+        {1,5,Req,0},
+        {2,1,Req,0},
+        {2,2,Req,0},
+        {2,3,Adv,0},
+        {2,4,Adv,0},
+        {2,5,Adv,0},
+        {2,6,Adv,0},
+        {2,7,Adv,0},
+        {2,8,Adv,0},
+        {3,1,Req,0},
+        {3,2,Req,0},
+        {4,1,Req,0},
+        {4,2,Adv,0},
+        {5,1,Req,0},
+        {5,2,Req,0},
+        {5,3,Req,0},
+        {5,4,Req,0},
+        {5,5,Req,0},
+        {5,6,Req,0},
+        {5,7,Req,0},
+        {5,8,Req,0},
+        {5,9,Adv,0},
+        {5,10,Req,0},
+        {6,1,Req,0},
+        {6,2,Req,0},
+        {6,3,Req,0},
+        {7,1,Req,0},
+        {7,2,Req,0},
+        {7,3,Req,0},
+        {7,4,Req,0},
+        {7,5,Man,0},
+        {7,6,Req,0},
+        {8,1,Req,0},
+        {8,2,Req,0},
+        {8,3,Req,0},
+        {8,4,Req,0},
+        {8,5,Req,0},
+        {8,6,Req,0},
+        {8,7,Adv,0},
+        {8,8,Req,0},
+        {8,9,Adv,0},
+        {8,10,Req,0},
+        {8,11,Adv,0},
+        {8,12,Req,0},
+        {8,13,Adv,0},
+        {8,14,Req,0},
+        {8,15,Req,0},
+        {8,16,Adv,0},
+        {8,17,Adv,0},
+        {8,18,Req,0},
+        {8,19,Adv,0},
+        {9,1,Man,0},
+        {9,2,Req,0},
+        {9,3,Req,0},
+        {9,4,Req,0},
+        {9,5,Req,0},
+        {9,6,Req,0},
+        {9,7,Man,0},
+        {10,1,Req,0},
+        {10,2,Req,0},
+        {10,3,Req,0},
+        {10,4,Req,0},
+        {10,5,Adv,0},
+        {10,6,Req,0},
+        {10,7,Req,0},
+        {10,8,Req,0},
+        {11,1,Req,0},
+        {11,2,Req,0},
+        {11,3,Req,0},
+        {11,4,Req,0},
+        {11,5,Adv,0},
+        {11,6,Req,0},
+        {11,8,Req,0},
+        {11,9,Req,0},
+        {11,10,Req,0},
+        {11,11,Req,0},
+        {12,1,Adv,0},
+        {12,2,Req,0},
+        {12,3,Adv,0},
+        {12,4,Adv,0},
+        {12,5,Man,0},
+        {12,6,Req,0},
+        {13,1,Req,0},
+        {13,2,Req,0},
+        {13,3,Adv,0},
+        {13,4,Adv,0},
+        {13,5,Req,0},
+        {13,6,Req,0},
+        {14,1,Req,0},
+        {14,2,Req,0},
+        {14,3,Req,0},
+        {14,4,Req,0},
+        {15,1,Adv,0},
+        {15,2,Req,0},
+        {15,3,Req,0},
+        {15,4,Adv,0},
+        {15,5,Dis,0},
+        {15,6,Req,0},
+        {15,7,Req,0},
+        {16,1,Req,0},
+        {16,2,Req,0},
+        {16,3,Req,0},
+        {16,4,Req,0},
+        {16,5,Req,0},
+        {16,6,Req,0},
+        {16,7,Req,0},
+        {17,1,Req,0},
+        {17,2,Req,0},
+        {17,3,Man,0},
+        {17,4,Man,0},
+        {17,5,Req,0},
+        {17,7,Req,0},
+        {17,8,Adv,0},
+        {17,9,Man,0},
+        {17,10,Req,0},
+        {17,11,Adv,0},
+        {17,12,Adv,0},
+        {17,13,Req,0},
+        {18,1,Req,0},
+        {18,2,Req,0},
+        {18,3,Req,0},
+        {18,4,Adv,0},
+        {18,5,Adv,0},
+        {18,6,Req,0},
+        {18,7,Req,0},
+        {18,8,Req,0},
+        {18,9,Req,0},
+        {18,10,Man,0},
+        {19,1,Man,0},
+        {19,2,Adv,0},
+        {19,3,Req,0},
+        {20,1,Adv,0},
+        {20,2,Req,0},
+        {20,3,Req,0},
+        {20,4,Req,0},
+        {20,5,Adv,0},
+        {20,6,Req,0},
+        {20,7,Req,0},
+        {20,8,Req,0},
+        {20,9,Req,0},
+        {20,10,Adv,0},
+        {20,11,Req,0},
+        {20,12,Req,0},
+        {20,13,Req,0},
+        {20,14,Req,0},
+        {20,15,Req,0},
+        {21,3,Req,0},
+        {21,4,Req,0},
+        {21,5,Req,0},
+        {21,6,Req,0},
+        {21,7,Req,0},
+        {21,8,Req,0},
+        {21,9,Req,0},
+        {21,10,Req,0},
+        {21,11,Adv,0},
+        {21,12,Req,0},
+        {21,13,Man,0},
+        {21,14,Req,0},
+        {21,15,Req,0},
+        {21,16,Req,0},
+        {21,17,Man,0},
+        {21,18,Man,0},
+        {21,19,Man,0},
+        {21,20,Man,0},
+        {21,21,Req,0},
+        {21,22,Man,0},
+        {21,23,Req,0},
+        {21,24,Req,0},
+        {21,25,Req,0},
+        {21,26,Req,0},
+        {22,1,Req,0},
+        {22,2,Man,0},
+        {22,3,Req,0},
+        {22,4,Man,0},
+        {22,5,Man,0},
+        {22,6,Man,0},
+        {22,7,Req,0},
+        {22,8,Req,0},
+        {22,9,Req,0},
+        {22,10,Req,0},
+        {22,11,Req,0},
+        {22,12,Man,0},
+        {22,13,Req,0},
+        {22,14,Man,0},
+        {22,15,Req,0},
+        {22,16,Req,0},
+        {22,17,Req,0},
+        {22,18,Req,0},
+        {22,19,Req,0},
+        {22,20,Man,0},
+        {23,1,Adv,0},
+        {23,2,Req,0},
+        {23,3,Adv,0},
+        {23,4,Req,0},
+        {23,5,Adv,0},
+        {23,6,Req,0},
+        {23,7,Adv,0},
+        {23,8,Req,0},
+    };
+
+    const std::vector<MisraCppInfo> misraCpp2008Rules =
+    {
+        {0,1,1,Req},
+        {0,1,2,Req},
+        {0,1,3,Req},
+        {0,1,4,Req},
+        {0,1,5,Req},
+        {0,1,6,Req},
+        {0,1,7,Req},
+        {0,1,8,Req},
+        {0,1,9,Req},
+        {0,1,10,Req},
+        {0,1,11,Req},
+        {0,1,12,Req},
+        {0,2,1,Req},
+        {0,3,1,Doc},
+        {0,3,2,Req},
+        {0,4,1,Doc},
+        {0,4,2,Doc},
+        {0,4,3,Doc},
+        {1,0,1,Req},
+        {1,0,2,Doc},
+        {1,0,3,Doc},
+        {2,2,1,Doc},
+        {2,3,1,Req},
+        {2,5,1,Adv},
+        {2,7,1,Req},
+        {2,7,2,Req},
+        {2,7,3,Adv},
+        {2,10,1,Req},
+        {2,10,2,Req},
+        {2,10,3,Req},
+        {2,10,4,Req},
+        {2,10,5,Adv},
+        {2,10,6,Req},
+        {2,13,1,Req},
+        {2,13,2,Req},
+        {2,13,3,Req},
+        {2,13,4,Req},
+        {2,13,5,Req},
+        {3,1,1,Req},
+        {3,1,2,Req},
+        {3,1,3,Req},
+        {3,2,1,Req},
+        {3,2,2,Req},
+        {3,2,3,Req},
+        {3,2,4,Req},
+        {3,3,1,Req},
+        {3,3,2,Req},
+        {3,4,1,Req},
+        {3,9,1,Req},
+        {3,9,2,Adv},
+        {3,9,3,Req},
+        {4,5,1,Req},
+        {4,5,2,Req},
+        {4,5,3,Req},
+        {4,10,1,Req},
+        {4,10,2,Req},
+        {5,0,1,Req},
+        {5,0,2,Adv},
+        {5,0,3,Req},
+        {5,0,4,Req},
+        {5,0,5,Req},
+        {5,0,6,Req},
+        {5,0,7,Req},
+        {5,0,8,Req},
+        {5,0,9,Req},
+        {5,0,10,Req},
+        {5,0,11,Req},
+        {5,0,12,Req},
+        {5,0,13,Req},
+        {5,0,14,Req},
+        {5,0,15,Req},
+        {5,0,16,Req},
+        {5,0,17,Req},
+        {5,0,18,Req},
+        {5,0,19,Req},
+        {5,0,20,Req},
+        {5,0,21,Req},
+        {5,2,1,Req},
+        {5,2,2,Req},
+        {5,2,3,Adv},
+        {5,2,4,Req},
+        {5,2,5,Req},
+        {5,2,6,Req},
+        {5,2,7,Req},
+        {5,2,8,Req},
+        {5,2,9,Adv},
+        {5,2,10,Adv},
+        {5,2,11,Req},
+        {5,2,12,Req},
+        {5,3,1,Req},
+        {5,3,2,Req},
+        {5,3,3,Req},
+        {5,3,4,Req},
+        {5,8,1,Req},
+        {5,14,1,Req},
+        {5,17,1,Req},
+        {5,18,1,Req},
+        {5,19,1,Adv},
+        {6,2,1,Req},
+        {6,2,2,Req},
+        {6,2,3,Req},
+        {6,3,1,Req},
+        {6,4,1,Req},
+        {6,4,2,Req},
+        {6,4,3,Req},
+        {6,4,4,Req},
+        {6,4,5,Req},
+        {6,4,6,Req},
+        {6,4,7,Req},
+        {6,4,8,Req},
+        {6,5,1,Req},
+        {6,5,2,Req},
+        {6,5,3,Req},
+        {6,5,4,Req},
+        {6,5,5,Req},
+        {6,5,6,Req},
+        {6,6,1,Req},
+        {6,6,2,Req},
+        {6,6,3,Req},
+        {6,6,4,Req},
+        {6,6,5,Req},
+        {7,1,1,Req},
+        {7,1,2,Req},
+        {7,2,1,Req},
+        {7,3,1,Req},
+        {7,3,2,Req},
+        {7,3,3,Req},
+        {7,3,4,Req},
+        {7,3,5,Req},
+        {7,3,6,Req},
+        {7,4,1,Doc},
+        {7,4,2,Req},
+        {7,4,3,Req},
+        {7,5,1,Req},
+        {7,5,2,Req},
+        {7,5,3,Req},
+        {7,5,4,Adv},
+        {8,4,1,Req},
+        {8,4,2,Req},
+        {8,4,3,Req},
+        {8,4,4,Req},
+        {8,5,1,Req},
+        {8,5,2,Req},
+        {8,5,3,Req},
+        {9,3,1,Req},
+        {9,3,2,Req},
+        {9,3,3,Req},
+        {9,5,1,Req},
+        {9,6,1,Doc},
+        {9,6,2,Req},
+        {9,6,3,Req},
+        {9,6,4,Req},
+        {10,1,1,Adv},
+        {10,1,2,Req},
+        {10,1,3,Req},
+        {10,2,1,Adv},
+        {10,3,1,Req},
+        {10,3,2,Req},
+        {10,3,3,Req},
+        {11,0,1,Req},
+        {12,1,1,Req},
+        {12,1,2,Adv},
+        {12,1,3,Req},
+        {12,8,1,Req},
+        {12,8,2,Req},
+        {14,5,1,Req},
+        {14,5,2,Req},
+        {14,5,3,Req},
+        {14,6,1,Req},
+        {14,6,2,Req},
+        {14,7,1,Req},
+        {14,7,2,Req},
+        {14,7,3,Req},
+        {14,8,1,Req},
+        {14,8,2,Req},
+        {15,0,1,Req},
+        {15,0,2,Req},
+        {15,0,3,Req},
+        {15,1,1,Req},
+        {15,1,2,Req},
+        {15,1,3,Req},
+        {15,3,1,Req},
+        {15,3,2,Adv},
+        {15,3,3,Req},
+        {15,3,4,Req},
+        {15,3,5,Req},
+        {15,3,6,Req},
+        {15,3,7,Req},
+        {15,4,1,Req},
+        {15,5,1,Req},
+        {15,5,2,Req},
+        {15,5,3,Req},
+        {16,0,1,Req},
+        {16,0,2,Req},
+        {16,0,3,Req},
+        {16,0,4,Req},
+        {16,0,5,Req},
+        {16,0,6,Req},
+        {16,0,7,Req},
+        {16,0,8,Req},
+        {16,1,1,Req},
+        {16,1,2,Req},
+        {16,2,1,Req},
+        {16,2,2,Req},
+        {16,2,3,Req},
+        {16,2,4,Req},
+        {16,2,5,Adv},
+        {16,2,6,Req},
+        {16,3,1,Req},
+        {16,3,2,Adv},
+        {16,6,1,Doc},
+        {17,0,1,Req},
+        {17,0,2,Req},
+        {17,0,3,Req},
+        {17,0,4,Doc},
+        {17,0,5,Req},
+        {18,0,1,Req},
+        {18,0,2,Req},
+        {18,0,3,Req},
+        {18,0,4,Req},
+        {18,0,5,Req},
+        {18,2,1,Req},
+        {18,4,1,Req},
+        {18,7,1,Req},
+        {19,3,1,Req},
+        {27,0,1,Req}
+    };
+
+    const std::vector<MisraCppInfo> misraCpp2023Directives =
+    {
+        {0,3,1,Adv},
+        {0,3,2,Req},
+        {5,7,2,Adv},
+        {15,8,1,Req},
+    };
+
+    const std::vector<MisraCppInfo> misraCpp2023Rules =
+    {
+        {0,0,1,Req},
+        {0,0,2,Adv},
+        {0,1,1,Adv},
+        {0,1,2,Req},
+        {0,2,1,Adv},
+        {0,2,2,Req},
+        {0,2,3,Adv},
+        {0,2,4,Adv},
+        {4,1,1,Req},
+        {4,1,2,Adv},
+        {4,1,3,Req},
+        {4,6,1,Req},
+        {5,0,1,Adv},
+        {5,7,1,Req},
+        {5,7,3,Req},
+        {5,10,1,Req},
+        {5,13,1,Req},
+        {5,13,2,Req},
+        {5,13,3,Req},
+        {5,13,4,Req},
+        {5,13,5,Req},
+        {5,13,6,Req},
+        {5,13,7,Req},
+        {6,0,1,Req},
+        {6,0,2,Adv},
+        {6,0,3,Adv},
+        {6,0,4,Req},
+        {6,2,1,Req},
+        {6,2,2,Req},
+        {6,2,3,Req},
+        {6,2,4,Req},
+        {6,4,1,Req},
+        {6,4,2,Req},
+        {6,4,3,Req},
+        {6,5,1,Adv},
+        {6,5,2,Adv},
+        {6,7,1,Req},
+        {6,7,2,Req},
+        {6,8,1,Req},
+        {6,8,2,Man},
+        {6,8,3,Req},
+        {6,8,4,Adv},
+        {6,9,1,Req},
+        {6,9,2,Adv},
+        {7,0,1,Req},
+        {7,0,2,Req},
+        {7,0,3,Req},
+        {7,0,4,Req},
+        {7,0,5,Req},
+        {7,0,6,Req},
+        {7,11,1,Req},
+        {7,11,2,Req},
+        {7,11,3,Req},
+        {8,0,1,Adv},
+        {8,1,1,Req},
+        {8,1,2,Adv},
+        {8,2,1,Req},
+        {8,2,2,Req},
+        {8,2,3,Req},
+        {8,2,4,Req},
+        {8,2,5,Req},
+        {8,2,6,Req},
+        {8,2,7,Adv},
+        {8,2,8,Req},
+        {8,2,9,Req},
+        {8,2,10,Req},
+        {8,2,11,Req},
+        {8,3,1,Adv},
+        {8,3,2,Adv},
+        {8,7,1,Req},
+        {8,7,2,Req},
+        {8,9,1,Req},
+        {8,14,1,Adv},
+        {8,18,1,Man},
+        {8,18,2,Adv},
+        {8,19,1,Adv},
+        {8,20,1,Adv},
+        {9,2,1,Req},
+        {9,3,1,Req},
+        {9,4,1,Req},
+        {9,4,2,Req},
+        {9,5,2,Adv},
+        {9,5,3,Req},
+        {9,6,1,Adv},
+        {9,6,2,Req},
+        {9,6,3,Req},
+        {9,6,4,Req},
+        {9,6,5,Req},
+        {10,0,1,Adv},
+        {10,1,1,Adv},
+        {10,1,2,Req},
+        {10,2,1,Req},
+        {10,2,2,Adv},
+        {10,2,3,Req},
+        {10,3,1,Adv},
+        {10,4,1,Req},
+        {11,3,1,Adv},
+        {11,3,2,Adv},
+        {11,6,1,Adv},
+        {11,6,2,Man},
+        {11,6,3,Req},
+        {12,2,1,Adv},
+        {12,2,2,Req},
+        {12,2,3,Req},
+        {12,3,1,Req},
+        {13,1,1,Adv},
+        {13,1,2,Req},
+        {13,3,1,Req},
+        {13,3,2,Req},
+        {13,3,3,Req},
+        {13,3,4,Req},
+        {14,1,1,Adv},
+        {15,0,1,Req},
+        {15,0,2,Adv},
+        {15,1,1,Req},
+        {15,1,2,Adv},
+        {15,1,3,Req},
+        {15,1,4,Adv},
+        {15,1,5,Req},
+        {16,5,2,Req},
+        {16,6,1,Adv},
+        {17,8,1,Req},
+        {18,1,1,Req},
+        {18,1,2,Req},
+        {18,3,1,Adv},
+        {18,3,2,Req},
+        {18,3,3,Req},
+        {18,4,1,Req},
+        {18,5,1,Adv},
+        {18,5,2,Adv},
+        {19,0,1,Req},
+        {19,0,2,Req},
+        {19,0,3,Adv},
+        {19,0,4,Adv},
+        {19,1,1,Req},
+        {19,1,2,Req},
+        {19,1,3,Req},
+        {19,2,1,Req},
+        {19,2,2,Req},
+        {19,2,3,Req},
+        {19,3,1,Adv},
+        {19,3,2,Req},
+        {19,3,3,Req},
+        {19,3,4,Req},
+        {19,3,5,Req},
+        {19,6,1,Adv},
+        {21,2,1,Req},
+        {21,2,2,Req},
+        {21,2,3,Req},
+        {21,2,4,Req},
+        {21,6,1,Adv},
+        {21,6,2,Req},
+        {21,6,3,Req},
+        {21,6,4,Req},
+        {21,6,5,Req},
+        {21,10,1,Req},
+        {21,10,2,Req},
+        {21,10,3,Req},
+        {22,3,1,Req},
+        {22,4,1,Req},
+        {23,11,1,Adv},
+        {24,5,1,Req},
+        {24,5,2,Req},
+        {25,5,1,Req},
+        {25,5,2,Man},
+        {25,5,3,Man},
+        {26,3,1,Adv},
+        {28,3,1,Req},
+        {28,6,1,Req},
+        {28,6,2,Req},
+        {28,6,3,Req},
+        {28,6,4,Req},
+        {30,0,1,Req},
+        {30,0,2,Req}
+    };
+}
+
+std::vector<checkers::Info> checkers::autosarInfo{
+    {"m0-1-1", checkers::Req},
+    {"m0-1-2", checkers::Req},
+    {"m0-1-3", checkers::Req},
+    {"m0-1-4", checkers::Req},
+    {"a0-1-1", checkers::Req},
+    {"a0-1-2", checkers::Req},
+    {"m0-1-8", checkers::Req},
+    {"m0-1-9", checkers::Req},
+    {"m0-1-10", checkers::Adv},
+    {"a0-1-3", checkers::Req},
+    {"a0-1-4", checkers::Req},
+    {"a0-1-5", checkers::Req},
+    {"a0-1-6", checkers::Adv},
+    {"m0-2-1", checkers::Req},
+    {"a0-4-2", checkers::Req},
+    {"a0-4-3", checkers::Req},
+    {"a0-4-4", checkers::Req},
+    {"a1-1-1", checkers::Req},
+    {"a1-4-3", checkers::Adv},
+    {"a2-3-1", checkers::Req},
+    {"a2-5-1", checkers::Req},
+    {"a2-5-2", checkers::Req},
+    {"m2-7-1", checkers::Req},
+    {"a2-7-1", checkers::Req},
+    {"a2-7-3", checkers::Req},
+    {"a2-8-2", checkers::Adv},
+    {"m2-10-1", checkers::Req},
+    {"a2-10-1", checkers::Req},
+    {"a2-10-6", checkers::Req},
+    {"a2-10-4", checkers::Req},
+    {"a2-10-5", checkers::Adv},
+    {"a2-11-1", checkers::Req},
+    {"a2-13-1", checkers::Req},
+    {"a2-13-6", checkers::Req},
+    {"a2-13-5", checkers::Adv},
+    {"m2-13-2", checkers::Req},
+    {"m2-13-3", checkers::Req},
+    {"m2-13-4", checkers::Req},
+    {"a2-13-2", checkers::Req},
+    {"a2-13-3", checkers::Req},
+    {"a2-13-4", checkers::Req},
+    {"a3-1-1", checkers::Req},
+    {"a3-1-2", checkers::Req},
+    {"a3-1-3", checkers::Adv},
+    {"m3-1-2", checkers::Req},
+    {"a3-1-4", checkers::Req},
+    {"a3-1-6", checkers::Adv},
+    {"m3-2-1", checkers::Req},
+    {"m3-2-2", checkers::Req},
+    {"m3-2-3", checkers::Req},
+    {"m3-2-4", checkers::Req},
+    {"a3-3-1", checkers::Req},
+    {"a3-3-2", checkers::Req},
+    {"m3-3-2", checkers::Req},
+    {"m3-4-1", checkers::Req},
+    {"m3-9-1", checkers::Req},
+    {"a3-9-1", checkers::Req},
+    {"m3-9-3", checkers::Req},
+    {"m4-5-1", checkers::Req},
+    {"a4-5-1", checkers::Req},
+    {"m4-5-3", checkers::Req},
+    {"a4-7-1", checkers::Req},
+    {"m4-10-1", checkers::Req},
+    {"a4-10-1", checkers::Req},
+    {"m4-10-2", checkers::Req},
+    {"a5-0-1", checkers::Req},
+    {"m5-0-2", checkers::Adv},
+    {"m5-0-3", checkers::Req},
+    {"m5-0-4", checkers::Req},
+    {"m5-0-5", checkers::Req},
+    {"m5-0-6", checkers::Req},
+    {"m5-0-7", checkers::Req},
+    {"m5-0-8", checkers::Req},
+    {"m5-0-9", checkers::Req},
+    {"m5-0-10", checkers::Req},
+    {"m5-0-11", checkers::Req},
+    {"m5-0-12", checkers::Req},
+    {"a5-0-2", checkers::Req},
+    {"m5-0-14", checkers::Req},
+    {"m5-0-15", checkers::Req},
+    {"m5-0-16", checkers::Req},
+    {"m5-0-17", checkers::Req},
+    {"a5-0-4", checkers::Req},
+    {"m5-0-18", checkers::Req},
+    {"a5-0-3", checkers::Req},
+    {"m5-0-20", checkers::Req},
+    {"m5-0-21", checkers::Req},
+    {"a5-1-1", checkers::Req},
+    {"a5-1-2", checkers::Req},
+    {"a5-1-3", checkers::Req},
+    {"a5-1-4", checkers::Req},
+    {"a5-1-6", checkers::Adv},
+    {"a5-1-7", checkers::Req},
+    {"a5-1-8", checkers::Adv},
+    {"a5-1-9", checkers::Adv},
+    {"m5-2-2", checkers::Req},
+    {"m5-2-3", checkers::Adv},
+    {"a5-2-1", checkers::Adv},
+    {"a5-2-2", checkers::Req},
+    {"a5-2-3", checkers::Req},
+    {"m5-2-6", checkers::Req},
+    {"a5-2-4", checkers::Req},
+    {"a5-2-6", checkers::Req},
+    {"m5-2-8", checkers::Req},
+    {"m5-2-9", checkers::Req},
+    {"m5-2-10", checkers::Req},
+    {"m5-2-11", checkers::Req},
+    {"a5-2-5", checkers::Req},
+    {"m5-2-12", checkers::Req},
+    {"m5-3-1", checkers::Req},
+    {"m5-3-2", checkers::Req},
+    {"m5-3-3", checkers::Req},
+    {"m5-3-4", checkers::Req},
+    {"a5-3-1", checkers::Req},
+    {"a5-3-2", checkers::Req},
+    {"a5-3-3", checkers::Req},
+    {"a5-5-1", checkers::Req},
+    {"a5-6-1", checkers::Req},
+    {"m5-8-1", checkers::Req},
+    {"a5-10-1", checkers::Req},
+    {"m5-14-1", checkers::Req},
+    {"a5-16-1", checkers::Req},
+    {"m5-18-1", checkers::Req},
+    {"m5-19-1", checkers::Req},
+    {"m6-2-1", checkers::Req},
+    {"a6-2-1", checkers::Req},
+    {"a6-2-2", checkers::Req},
+    {"m6-2-2", checkers::Req},
+    {"m6-2-3", checkers::Req},
+    {"m6-3-1", checkers::Req},
+    {"m6-4-1", checkers::Req},
+    {"m6-4-2", checkers::Req},
+    {"m6-4-3", checkers::Req},
+    {"m6-4-4", checkers::Req},
+    {"m6-4-5", checkers::Req},
+    {"m6-4-6", checkers::Req},
+    {"m6-4-7", checkers::Req},
+    {"a6-4-1", checkers::Req},
+    {"a6-5-1", checkers::Req},
+    {"a6-5-2", checkers::Req},
+    {"m6-5-2", checkers::Req},
+    {"m6-5-3", checkers::Req},
+    {"m6-5-4", checkers::Req},
+    {"m6-5-5", checkers::Req},
+    {"m6-5-6", checkers::Req},
+    {"a6-5-3", checkers::Adv},
+    {"a6-5-4", checkers::Adv},
+    {"a6-6-1", checkers::Req},
+    {"m6-6-1", checkers::Req},
+    {"m6-6-2", checkers::Req},
+    {"m6-6-3", checkers::Req},
+    {"a7-1-1", checkers::Req},
+    {"a7-1-2", checkers::Req},
+    {"m7-1-2", checkers::Req},
+    {"a7-1-3", checkers::Req},
+    {"a7-1-4", checkers::Req},
+    {"a7-1-5", checkers::Req},
+    {"a7-1-6", checkers::Req},
+    {"a7-1-7", checkers::Req},
+    {"a7-1-8", checkers::Req},
+    {"a7-1-9", checkers::Req},
+    {"a7-2-1", checkers::Req},
+    {"a7-2-2", checkers::Req},
+    {"a7-2-3", checkers::Req},
+    {"a7-2-4", checkers::Req},
+    {"m7-3-1", checkers::Req},
+    {"m7-3-2", checkers::Req},
+    {"m7-3-3", checkers::Req},
+    {"m7-3-4", checkers::Req},
+    {"a7-3-1", checkers::Req},
+    {"m7-3-6", checkers::Req},
+    {"a7-4-1", checkers::Req},
+    {"m7-4-2", checkers::Req},
+    {"m7-4-3", checkers::Req},
+    {"a7-5-1", checkers::Req},
+    {"a7-5-2", checkers::Req},
+    {"a7-6-1", checkers::Req},
+    {"m8-0-1", checkers::Req},
+    {"a8-2-1", checkers::Req},
+    {"m8-3-1", checkers::Req},
+    {"a8-4-1", checkers::Req},
+    {"m8-4-2", checkers::Req},
+    {"a8-4-2", checkers::Req},
+    {"m8-4-4", checkers::Req},
+    {"a8-4-4", checkers::Adv},
+    {"a8-4-5", checkers::Req},
+    {"a8-4-6", checkers::Req},
+    {"a8-4-7", checkers::Req},
+    {"a8-4-8", checkers::Req},
+    {"a8-4-9", checkers::Req},
+    {"a8-4-10", checkers::Req},
+    {"a8-4-11", checkers::Req},
+    {"a8-4-12", checkers::Req},
+    {"a8-4-13", checkers::Req},
+    {"a8-4-14", checkers::Req},
+    {"a8-5-0", checkers::Req},
+    {"a8-5-1", checkers::Req},
+    {"m8-5-2", checkers::Req},
+    {"a8-5-2", checkers::Req},
+    {"a8-5-3", checkers::Req},
+    {"a8-5-4", checkers::Adv},
+    {"m9-3-1", checkers::Req},
+    {"a9-3-1", checkers::Req},
+    {"m9-3-3", checkers::Req},
+    {"a9-5-1", checkers::Req},
+    {"a9-6-1", checkers::Req},
+    {"m9-6-4", checkers::Req},
+    {"a10-1-1", checkers::Req},
+    {"m10-1-1", checkers::Adv},
+    {"m10-1-2", checkers::Req},
+    {"m10-1-3", checkers::Req},
+    {"m10-2-1", checkers::Adv},
+    {"a10-2-1", checkers::Req},
+    {"a10-3-1", checkers::Req},
+    {"a10-3-2", checkers::Req},
+    {"a10-3-3", checkers::Req},
+    {"a10-3-5", checkers::Req},
+    {"m10-3-3", checkers::Req},
+    {"a10-4-1", checkers::Req},
+    {"m11-0-1", checkers::Req},
+    {"a11-0-1", checkers::Adv},
+    {"a11-0-2", checkers::Req},
+    {"a11-3-1", checkers::Req},
+    {"a12-0-1", checkers::Req},
+    {"a12-0-2", checkers::Req},
+    {"a12-1-1", checkers::Req},
+    {"m12-1-1", checkers::Req},
+    {"a12-1-2", checkers::Req},
+    {"a12-1-3", checkers::Req},
+    {"a12-1-4", checkers::Req},
+    {"a12-1-5", checkers::Req},
+    {"a12-1-6", checkers::Req},
+    {"a12-4-1", checkers::Req},
+    {"a12-4-2", checkers::Adv},
+    {"a12-6-1", checkers::Req},
+    {"a12-7-1", checkers::Req},
+    {"a12-8-1", checkers::Req},
+    {"a12-8-2", checkers::Adv},
+    {"a12-8-3", checkers::Req},
+    {"a12-8-4", checkers::Req},
+    {"a12-8-5", checkers::Req},
+    {"a12-8-6", checkers::Req},
+    {"a12-8-7", checkers::Adv},
+    {"a13-1-2", checkers::Req},
+    {"a13-1-3", checkers::Req},
+    {"a13-2-1", checkers::Req},
+    {"a13-2-2", checkers::Req},
+    {"a13-2-3", checkers::Req},
+    {"a13-3-1", checkers::Req},
+    {"a13-5-1", checkers::Req},
+    {"a13-5-2", checkers::Req},
+    {"a13-5-3", checkers::Adv},
+    {"a13-5-4", checkers::Req},
+    {"a13-5-5", checkers::Req},
+    {"a13-6-1", checkers::Req},
+    {"a14-1-1", checkers::Adv},
+    {"a14-5-1", checkers::Req},
+    {"a14-5-2", checkers::Req},
+    {"a14-5-3", checkers::Req},
+    {"m14-5-3", checkers::Req},
+    {"m14-6-1", checkers::Req},
+    {"a14-7-1", checkers::Req},
+    {"a14-7-2", checkers::Req},
+    {"a14-8-2", checkers::Req},
+    {"a15-0-2", checkers::Req},
+    {"a15-1-2", checkers::Req},
+    {"m15-0-3", checkers::Req},
+    {"m15-1-1", checkers::Req},
+    {"m15-1-2", checkers::Req},
+    {"m15-1-3", checkers::Req},
+    {"a15-1-3", checkers::Adv},
+    {"a15-1-4", checkers::Req},
+    {"a15-2-1", checkers::Req},
+    {"a15-2-2", checkers::Req},
+    {"m15-3-1", checkers::Req},
+    {"a15-3-2", checkers::Req},
+    {"a15-3-3", checkers::Req},
+    {"m15-3-3", checkers::Req},
+    {"m15-3-4", checkers::Req},
+    {"a15-3-5", checkers::Req},
+    {"m15-3-6", checkers::Req},
+    {"m15-3-7", checkers::Req},
+    {"a15-4-1", checkers::Req},
+    {"a15-4-2", checkers::Req},
+    {"a15-4-3", checkers::Req},
+    {"a15-4-4", checkers::Req},
+    {"a15-4-5", checkers::Req},
+    {"a15-5-1", checkers::Req},
+    {"a15-5-2", checkers::Req},
+    {"a15-5-3", checkers::Req},
+    {"a16-0-1", checkers::Req},
+    {"m16-0-1", checkers::Req},
+    {"m16-0-2", checkers::Req},
+    {"m16-0-5", checkers::Req},
+    {"m16-0-6", checkers::Req},
+    {"m16-0-7", checkers::Req},
+    {"m16-0-8", checkers::Req},
+    {"m16-1-1", checkers::Req},
+    {"m16-1-2", checkers::Req},
+    {"m16-2-3", checkers::Req},
+    {"a16-2-1", checkers::Req},
+    {"a16-2-2", checkers::Req},
+    {"a16-2-3", checkers::Req},
+    {"m16-3-1", checkers::Req},
+    {"m16-3-2", checkers::Adv},
+    {"a16-6-1", checkers::Req},
+    {"a16-7-1", checkers::Req},
+    {"a17-0-1", checkers::Req},
+    {"m17-0-2", checkers::Req},
+    {"m17-0-3", checkers::Req},
+    {"m17-0-5", checkers::Req},
+    {"a17-1-1", checkers::Req},
+    {"a17-6-1", checkers::Req},
+    {"a18-0-1", checkers::Req},
+    {"a18-0-2", checkers::Req},
+    {"m18-0-3", checkers::Req},
+    {"m18-0-4", checkers::Req},
+    {"m18-0-5", checkers::Req},
+    {"a18-0-3", checkers::Req},
+    {"a18-1-1", checkers::Req},
+    {"a18-1-2", checkers::Req},
+    {"a18-1-3", checkers::Req},
+    {"a18-1-4", checkers::Req},
+    {"a18-1-6", checkers::Req},
+    {"m18-2-1", checkers::Req},
+    {"a18-5-1", checkers::Req},
+    {"a18-5-2", checkers::Req},
+    {"a18-5-3", checkers::Req},
+    {"a18-5-4", checkers::Req},
+    {"a18-5-5", checkers::Req},
+    {"a18-5-6", checkers::Req},
+    {"a18-5-7", checkers::Req},
+    {"a18-5-8", checkers::Req},
+    {"a18-5-9", checkers::Req},
+    {"a18-5-10", checkers::Req},
+    {"a18-5-11", checkers::Req},
+    {"m18-7-1", checkers::Req},
+    {"a18-9-1", checkers::Req},
+    {"a18-9-2", checkers::Req},
+    {"a18-9-3", checkers::Req},
+    {"a18-9-4", checkers::Req},
+    {"m19-3-1", checkers::Req},
+    {"a20-8-1", checkers::Req},
+    {"a20-8-2", checkers::Req},
+    {"a20-8-3", checkers::Req},
+    {"a20-8-4", checkers::Req},
+    {"a20-8-5", checkers::Req},
+    {"a20-8-6", checkers::Req},
+    {"a20-8-7", checkers::Req},
+    {"a21-8-1", checkers::Req},
+    {"a23-0-1", checkers::Req},
+    {"a23-0-2", checkers::Req},
+    {"a25-1-1", checkers::Req},
+    {"a25-4-1", checkers::Req},
+    {"a26-5-1", checkers::Req},
+    {"a26-5-2", checkers::Req},
+    {"m27-0-1", checkers::Req},
+    {"a27-0-1", checkers::Req},
+    {"a27-0-4", checkers::Req},
+    {"a27-0-2", checkers::Adv},
+    {"a27-0-3", checkers::Req},
+};
+
+std::vector<checkers::Info> checkers::certCInfo{
+    {"PRE30-C", "L3"},
+    {"PRE31-C", "L3"},
+    {"PRE32-C", "L3"},
+    {"DCL30-C", "L2"},
+    {"DCL31-C", "L3"},
+    {"DCL36-C", "L2"},
+    {"DCL37-C", "L3"},
+    {"DCL38-C", "L3"},
+    {"DCL39-C", "L3"},
+    {"DCL40-C", "L3"},
+    {"DCL41-C", "L2"},
+    {"EXP30-C", "L2"},
+    {"EXP32-C", "L2"},
+    {"EXP33-C", "L1"},
+    {"EXP34-C", "L1"},
+    {"EXP35-C", "L2"},
+    {"EXP36-C", "L3"},
+    {"EXP37-C", "L3"},
+    {"EXP39-C", "L2"},
+    {"EXP40-C", "L3"},
+    {"EXP42-C", "L1"},
+    {"EXP43-C", "L3"},
+    {"EXP44-C", "L3"},
+    {"EXP45-C", "L2"},
+    {"EXP46-C", "L2"},
+    {"EXP47-C", "L2"},
+    {"INT30-C", "L2"},
+    {"INT31-C", "L1"},
+    {"INT32-C", "L1"},
+    {"INT33-C", "L2"},
+    {"INT34-C", "L3"},
+    {"INT35-C", "L3"},
+    {"INT36-C", "L3"},
+    {"FLP30-C", "L2"},
+    {"FLP32-C", "L1"},
+    {"FLP34-C", "L3"},
+    {"FLP36-C", "L3"},
+    {"FLP37-C", "L3"},
+    {"ARR30-C", "L2"},
+    {"ARR32-C", "L2"},
+    {"ARR36-C", "L3"},
+    {"ARR37-C", "L2"},
+    {"ARR38-C", "L2"},
+    {"ARR39-C", "L2"},
+    {"STR30-C", "L2"},
+    {"STR31-C", "L2"},
+    {"STR32-C", "L1"},
+    {"STR34-C", "L2"},
+    {"STR37-C", "L3"},
+    {"STR38-C", "L1"},
+    {"MEM30-C", "L2"},
+    {"MEM31-C", "L3"},
+    {"MEM33-C", "L3"},
+    {"MEM34-C", "L2"},
+    {"MEM35-C", "L2"},
+    {"MEM36-C", "L3"},
+    {"FIO30-C", "L1"},
+    {"FIO32-C", "L3"},
+    {"FIO34-C", "L1"},
+    {"FIO37-C", "L1"},
+    {"FIO38-C", "L3"},
+    {"FIO39-C", "L2"},
+    {"FIO40-C", "L2"},
+    {"FIO41-C", "L3"},
+    {"FIO42-C", "L3"},
+    {"FIO44-C", "L3"},
+    {"FIO45-C", "L2"},
+    {"FIO46-C", "L3"},
+    {"FIO47-C", "L2"},
+    {"ENV30-C", "L3"},
+    {"ENV31-C", "L3"},
+    {"ENV32-C", "L1"},
+    {"ENV33-C", "L1"},
+    {"ENV34-C", "L3"},
+    {"SIG30-C", "L1"},
+    {"SIG31-C", "L1"},
+    {"SIG34-C", "L3"},
+    {"SIG35-C", "L3"},
+    {"ERR30-C", "L1"},
+    {"ERR32-C", "L3"},
+    {"ERR33-C", "L1"},
+    {"ERR34-C", "L2"},
+    {"CON30-C", "L3"},
+    {"CON31-C", "L3"},
+    {"CON32-C", "L3"},
+    {"CON33-C", "L3"},
+    {"CON34-C", "L3"},
+    {"CON35-C", "L3"},
+    {"CON36-C", "L3"},
+    {"CON37-C", "L3"},
+    {"CON38-C", "L3"},
+    {"CON39-C", "L3"},
+    {"CON40-C", "L2"},
+    {"CON41-C", "L3"},
+    {"CON43-C", "L3"},
+    {"MSC30-C", "L3"},
+    {"MSC32-C", "L1"},
+    {"MSC33-C", "L2"},
+    {"MSC37-C", "L2"},
+    {"MSC38-C", "L3"},
+    {"MSC39-C", "L3"},
+    {"MSC40-C", "L3"},
+    {"MSC41-C", "L2"},
+    {"POS30-C", "L1"},
+    {"POS34-C", "L2"},
+    {"POS35-C", "L2"},
+    {"POS36-C", "L1"},
+    {"POS37-C", "L1"},
+    {"POS38-C", "L3"},
+    {"POS39-C", "L1"},
+    {"POS44-C", "L3"},
+    {"POS47-C", "L3"},
+    {"POS48-C", "L3"},
+    {"POS49-C", "L3"},
+    {"POS50-C", "L3"},
+    {"POS51-C", "L3"},
+    {"POS52-C", "L3"},
+    {"POS53-C", "L2"},
+    {"POS54-C", "L1"},
+    {"WIN30-C", "L3"},
+    // Recommendations
+    {"PRE00-C", "L3"},
+    {"PRE01-C", "L1"},
+    {"PRE02-C", "L1"},
+    {"PRE04-C", "L3"},
+    {"PRE05-C", "L3"},
+    {"PRE06-C", "L3"},
+    {"PRE07-C", "L3"},
+    {"PRE08-C", "L3"},
+    {"PRE09-C", "L1"},
+    {"PRE10-C", "L1"},
+    {"PRE11-C", "L2"},
+    {"PRE12-C", "L3"},
+    {"PRE13-C", "L3"},
+    {"DCL00-C", "L3"},
+    {"DCL01-C", "L3"},
+    {"DCL02-C", "L3"},
+    {"DCL03-C", "L3"},
+    {"DCL04-C", "L3"},
+    {"DCL05-C", "L3"},
+    {"DCL06-C", "L3"},
+    {"DCL07-C", "L3"},
+    {"DCL08-C", "L3"},
+    {"DCL09-C", "L3"},
+    {"DCL10-C", "L2"},
+    {"DCL11-C", "L1"},
+    {"DCL12-C", "L3"},
+    {"DCL13-C", "L3"},
+    {"DCL15-C", "L3"},
+    {"DCL16-C", "L3"},
+    {"DCL17-C", "L3"},
+    {"DCL18-C", "L3"},
+    {"DCL19-C", "L3"},
+    {"DCL20-C", "L1"},
+    {"DCL21-C", "L3"},
+    {"DCL22-C", "L3"},
+    {"DCL23-C", "L2"},
+    {"EXP00-C", "L2"},
+    {"EXP02-C", "L3"},
+    {"EXP03-C", "L3"},
+    {"EXP05-C", "L3"},
+    {"EXP07-C", "L3"},
+    {"EXP08-C", "L2"},
+    {"EXP09-C", "L2"},
+    {"EXP10-C", "L2"},
+    {"EXP11-C", "L3"},
+    {"EXP12-C", "L3"},
+    {"EXP13-C", "L3"},
+    {"EXP14-C", "L3"},
+    {"EXP15-C", "L1"},
+    {"EXP16-C", "L2"},
+    {"EXP19-C", "L1"},
+    {"EXP20-C", "L1"},
+    {"INT00-C", "L3"},
+    {"INT01-C", "L2"},
+    {"INT02-C", "L3"},
+    {"INT04-C", "L1"},
+    {"INT05-C", "L2"},
+    {"INT07-C", "L1"},
+    {"INT08-C", "L3"},
+    {"INT09-C", "L3"},
+    {"INT10-C", "L3"},
+    {"INT12-C", "L3"},
+    {"INT13-C", "L2"},
+    {"INT14-C", "L3"},
+    {"INT15-C", "L2"},
+    {"INT16-C", "L3"},
+    {"INT17-C", "L3"},
+    {"INT18-C", "L1"},
+    {"FLP00-C", "L3"},
+    {"FLP01-C", "L3"},
+    {"FLP02-C", "L3"},
+    {"FLP03-C", "L3"},
+    {"FLP04-C", "L3"},
+    {"FLP05-C", "L3"},
+    {"FLP06-C", "L3"},
+    {"FLP07-C", "L3"},
+    {"ARR00-C", "L2"},
+    {"ARR01-C", "L1"},
+    {"ARR02-C", "L2"},
+    {"STR00-C", "L3"},
+    {"STR01-C", "L3"},
+    {"STR02-C", "L2"},
+    {"STR03-C", "L3"},
+    {"STR04-C", "L3"},
+    {"STR05-C", "L3"},
+    {"STR06-C", "L2"},
+    {"STR08-C", "L2"},
+    {"STR09-C", "L3"},
+    {"STR10-C", "L3"},
+    {"STR11-C", "L2"},
+    {"FIO01-C", "L1"},
+    {"FIO02-C", "L3"},
+    {"FIO03-C", "L3"},
+    {"FIO05-C", "L3"},
+    {"FIO06-C", "L3"},
+    {"FIO08-C", "L3"},
+    {"FIO09-C", "L3"},
+    {"FIO10-C", "L3"},
+    {"FIO11-C", "L3"},
+    {"FIO13-C", "L3"},
+    {"FIO14-C", "L3"},
+    {"FIO15-C", "L3"},
+    {"FIO17-C", "L2"},
+    {"FIO18-C", "L3"},
+    {"FIO19-C", "L3"},
+    {"FIO20-C", "L1"},
+    {"FIO21-C", "L3"},
+    {"FIO22-C", "L3"},
+    {"FIO23-C", "L3"},
+    {"FIO24-C", "L3"},
+    {"ENV01-C", "L2"},
+    {"ENV02-C", "L3"},
+    {"ENV03-C", "L2"},
+    {"SIG00-C", "L2"},
+    {"SIG01-C", "L3"},
+    {"SIG02-C", "L2"},
+    {"ERR00-C", "L3"},
+    {"ERR01-C", "L2"},
+    {"ERR02-C", "L3"},
+    {"ERR04-C", "L3"},
+    {"ERR05-C", "L2"},
+    {"ERR06-C", "L3"},
+    {"ERR07-C", "L1"},
+    {"API00-C", "L3"},
+    {"API01-C", "L1"},
+    {"API02-C", "L1"},
+    {"API03-C", "L3"},
+    {"API04-C", "L3"},
+    {"API05-C", "L1"},
+    {"API07-C", "L3"},
+    {"API09-C", "L3"},
+    {"API10-C", "L3"},
+    {"CON01-C", "L3"},
+    {"CON02-C", "L3"},
+    {"CON04-C", "L3"},
+    {"CON05-C", "L3"},
+    {"CON06-C", "L3"},
+    {"CON07-C", "L2"},
+    {"CON08-C", "L3"},
+    {"CON09-C", "L3"},
+    {"MSC00-C", "L3"},
+    {"MSC01-C", "L3"},
+    {"MSC04-C", "L3"},
+    {"MSC05-C", "L3"},
+    {"MSC06-C", "L1"},
+    {"MSC07-C", "L3"},
+    {"MSC09-C", "L3"},
+    {"MSC10-C", "L3"},
+    {"MSC11-C", "L3"},
+    {"MSC12-C", "L3"},
+    {"MSC13-C", "L3"},
+    {"MSC14-C", "L3"},
+    {"MSC15-C", "L2"},
+    {"MSC17-C", "L1"},
+    {"MSC18-C", "L3"},
+    {"MSC19-C", "L3"},
+    {"MSC20-C", "L2"},
+    {"MSC21-C", "L3"},
+    {"MSC22-C", "L3"},
+    {"MSC23-C", "L3"},
+    {"MSC24-C", "L1"},
+    {"MSC25-C", "L3"},
+    {"POS01-C", "L2"},
+    {"POS02-C", "L2"},
+    {"POS04-C", "L3"},
+    {"POS05-C", "L3"},
+    {"WIN00-C", "L2"},
+    {"WIN01-C", "L1"},
+    {"WIN02-C", "L1"},
+    {"WIN03-C", "L3"},
+    {"WIN04-C", "L3"},
+};
+
+std::vector<checkers::Info> checkers::certCppInfo{
+    {"DCL50-CPP", "L1"},
+    {"DCL51-CPP", "L3"},
+    {"DCL52-CPP", "L3"},
+    {"DCL53-CPP", "L3"},
+    {"DCL54-CPP", "L3"},
+    {"DCL55-CPP", "L3"},
+    {"DCL56-CPP", "L3"},
+    {"DCL57-CPP", "L2"},
+    {"DCL58-CPP", "L2"},
+    {"DCL59-CPP", "L3"},
+    {"DCL60-CPP", "L2"},
+    {"EXP50-CPP", "L2"},
+    {"EXP51-CPP", "L3"},
+    {"EXP52-CPP", "L3"},
+    {"EXP53-CPP", "L1"},
+    {"EXP54-CPP", "L2"},
+    {"EXP55-CPP", "L3"},
+    {"EXP56-CPP", "L3"},
+    {"EXP57-CPP", "L3"},
+    {"EXP58-CPP", "L3"},
+    {"EXP59-CPP", "L3"},
+    {"EXP60-CPP", "L2"},
+    {"EXP61-CPP", "L2"},
+    {"EXP62-CPP", "L1"},
+    {"EXP63-CPP", "L2"},
+    {"INT50-CPP", "L3"},
+    {"CTR50-CPP", "L2"},
+    {"CTR51-CPP", "L2"},
+    {"CTR52-CPP", "L2"},
+    {"CTR53-CPP", "L2"},
+    {"CTR54-CPP", "L3"},
+    {"CTR55-CPP", "L2"},
+    {"CTR56-CPP", "L2"},
+    {"CTR57-CPP", "L3"},
+    {"CTR58-CPP", "L2"},
+    {"STR50-CPP", "L2"},
+    {"STR51-CPP", "L1"},
+    {"STR52-CPP", "L2"},
+    {"STR53-CPP", "L3"},
+    {"MEM50-CPP", "L2"},
+    {"MEM51-CPP", "L2"},
+    {"MEM52-CPP", "L1"},
+    {"MEM53-CPP", "L2"},
+    {"MEM54-CPP", "L2"},
+    {"MEM55-CPP", "L2"},
+    {"MEM56-CPP", "L2"},
+    {"MEM57-CPP", "L3"},
+    {"FIO50-CPP", "L2"},
+    {"FIO51-CPP", "L3"},
+    {"ERR50-CPP", "L3"},
+    {"ERR51-CPP", "L2"},
+    {"ERR52-CPP", "L3"},
+    {"ERR53-CPP", "L3"},
+    {"ERR54-CPP", "L1"},
+    {"ERR55-CPP", "L2"},
+    {"ERR56-CPP", "L2"},
+    {"ERR57-CPP", "L3"},
+    {"ERR58-CPP", "L2"},
+    {"ERR59-CPP", "L2"},
+    {"ERR60-CPP", "L3"},
+    {"ERR61-CPP", "L3"},
+    {"ERR62-CPP", "L3"},
+    {"OOP50-CPP", "L3"},
+    {"OOP51-CPP", "L3"},
+    {"OOP52-CPP", "L3"},
+    {"OOP53-CPP", "L2"},
+    {"OOP54-CPP", "L3"},
+    {"OOP55-CPP", "L2"},
+    {"OOP56-CPP", "L3"},
+    {"OOP57-CPP", "L1"},
+    {"OOP58-CPP", "L2"},
+    {"CON50-CPP", "L3"},
+    {"CON51-CPP", "L2"},
+    {"CON52-CPP", "L3"},
+    {"CON53-CPP", "L3"},
+    {"CON54-CPP", "L3"},
+    {"CON55-CPP", "L3"},
+    {"CON56-CPP", "L3"},
+    {"MSC50-CPP", "L3"},
+    {"MSC51-CPP", "L1"},
+    {"MSC52-CPP", "L2"},
+    {"MSC53-CPP", "L3"},
+    {"MSC54-CPP", "L2"},
+};
+
diff --git a/lib/checkers.h b/lib/checkers.h
new file mode 100644
index 00000000000..bda4a0320f5
--- /dev/null
+++ b/lib/checkers.h
@@ -0,0 +1,93 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef checkersH
+#define checkersH
+
+#include <map>
+#include <string>
+#include <vector>
+#include <cstdint>
+
+#include "config.h"
+
+enum class ReportType : std::uint8_t {
+    normal = 0,
+    autosar = 1,
+    certC = 2,
+    certCpp = 3,
+    misraC2012 = 4,
+    misraCpp2008 = 5,
+    misraCpp2023 = 6,
+    misraC2023 = 7,
+    misraC2025 = 8,
+};
+
+namespace checkers {
+    extern CPPCHECKLIB const std::map<std::string, std::string> allCheckers;
+
+    struct CPPCHECKLIB MisraInfo {
+        int a;
+        int b;
+        const char* str;
+        int amendment;
+    };
+
+    struct CPPCHECKLIB MisraCppInfo {
+        int a;
+        int b;
+        int c;
+        const char* classification;
+    };
+
+    extern CPPCHECKLIB const char Req[]; // = "Required";
+    extern CPPCHECKLIB const char Adv[]; // = "Advisory";
+    extern CPPCHECKLIB const char Man[]; // = "Mandatory";
+    extern CPPCHECKLIB const char Doc[]; // = "Document";
+
+    extern CPPCHECKLIB const std::vector<MisraInfo> misraC2012Directives;
+    extern CPPCHECKLIB const std::vector<MisraInfo> misraC2012Rules;
+    extern CPPCHECKLIB const std::vector<MisraInfo> misraC2023Directives;
+    extern CPPCHECKLIB const std::vector<MisraInfo> misraC2023Rules;
+    extern CPPCHECKLIB const std::vector<MisraInfo> misraC2025Directives;
+    extern CPPCHECKLIB const std::vector<MisraInfo> misraC2025Rules;
+    extern CPPCHECKLIB const std::vector<MisraCppInfo> misraCpp2008Rules;
+    extern CPPCHECKLIB const std::vector<MisraCppInfo> misraCpp2023Directives;
+    extern CPPCHECKLIB const std::vector<MisraCppInfo> misraCpp2023Rules;
+
+    struct CPPCHECKLIB IdMapping {
+        const char* guideline;
+        const char* cppcheckId;
+    };
+    extern std::vector<IdMapping> idMappingMisraC;
+    extern std::vector<IdMapping> idMappingMisraCpp2008;
+    extern std::vector<IdMapping> idMappingMisraCpp2023;
+    extern std::vector<IdMapping> idMappingAutosar;
+    extern std::vector<IdMapping> idMappingCertC;
+    extern std::vector<IdMapping> idMappingCertCpp;
+
+    struct CPPCHECKLIB Info {
+        const char* guideline;
+        const char* classification;
+    };
+    extern std::vector<Info> autosarInfo;
+    extern std::vector<Info> certCInfo;
+    extern std::vector<Info> certCppInfo;
+}
+
+#endif
diff --git a/lib/checkersidmapping.cpp b/lib/checkersidmapping.cpp
new file mode 100644
index 00000000000..e9636843853
--- /dev/null
+++ b/lib/checkersidmapping.cpp
@@ -0,0 +1,218 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+// This file is auto generated by script, do not edit
+// Mappings of Cppcheck warning IDs to guidelines
+#include "checkers.h"
+#include <vector>
+
+std::vector<checkers::IdMapping> checkers::idMappingAutosar{
+    {"m0-1-1", "unreachableCode,duplicateBreak"},
+    {"m0-1-2", "unsignedLessThanZero"},
+    {"m0-1-3", "unusedVariable,unusedStructMember"},
+    {"a0-1-1", "unreadVariable,redundantAssignment"},
+    {"m0-1-9", "redundantAssignment,redundantInitialization"},
+    {"m0-1-10", "unusedFunction"},
+    {"m0-2-1", "overlappingWriteUnion,overlappingWriteFunction"},
+    {"a1-1-1", "g++ .."},
+    {"a2-3-1", "The code contains unhandled character(s) (character code=195). Neither unicode nor extended ascii is supported. [syntaxError]"},
+    {"a2-7-3", "doxygen,clang -Wdocumentation"},
+    {"a2-10-1", "shadowVariable,shadowFunction,shadowArgument"},
+    {"a2-13-2", "compile error"},
+    {"a2-13-4", "compiler error"},
+    {"m3-2-2", "ctuOneDefinitionRuleViolation"},
+    {"m3-4-1", "variableScope"},
+    {"a5-0-1", "-Wsequence-point"},
+    {"m5-0-16", "pointerOutOfBounds"},
+    {"m5-0-17", "comparePointers"},
+    {"m5-0-18", "comparePointers"},
+    {"a5-1-4", "returnDanglingLifetime"},
+    {"a5-2-5", "arrayIndexOutOfBounds,arrayIndexOutOfBoundsCond,pointerOutOfBounds,pointerOutOfBoundsCond,negativeIndex,arrayIndexThenCheck,bufferAccessOutOfBounds,objectIndex,argumentSize"},
+    {"m5-3-4", "sizeofFunctionCall"},
+    {"a5-3-2", "nullPointer,nullPointerRedundantCheck,nullPointerArithmetic,nullPointerArithmeticRedundantCheck,nullPointerDefaultArg"},
+    {"a5-6-1", "zerodiv,zerodivcond"},
+    {"m5-8-1", "shiftTooManyBits"},
+    {"m7-1-2", "constParameter"},
+    {"a7-5-1", "returnDanglingLifetime"},
+    {"m8-4-2", "funcArgNamesDifferent"},
+    {"a8-4-2", "missingReturn"},
+    {"a8-5-0", "uninitdata"},
+    {"m9-3-3", "functionConst,functionStatic"},
+    {"m10-2-1", "duplInheritedMember"},
+    {"a12-1-1", "uninitMemberVar"},
+    {"m12-1-1", "virtualCallInConstructor"},
+    {"a12-1-4", "noExplicitConstructor"},
+    {"a12-6-1", "useInitializationList"},
+    {"a12-8-3", "accessMoved"},
+    {"a15-1-4", "memleak"},
+    {"m15-3-1", "exceptThrowInDestructor"},
+    {"a15-4-2", "throwInNoexceptFunction"},
+    {"m16-0-5", "preprocessorErrorDirective"},
+    {"a16-2-2", "iwyu,check headers"},
+    {"a18-5-3", "mismatchAllocDealloc"},
+    {"a20-8-1", "doubleFree"},
+    {"a23-0-2", "invalidContainer"},
+};
+
+std::vector<checkers::IdMapping> checkers::idMappingCertC{
+    {"PRE30", "preprocessorErrorDirective"},
+    {"PRE32", "preprocessorErrorDirective"},
+    {"DCL30", "danglingLifetime,autoVariables,invalidLifetime,returnDanglingLifetime"},
+    {"EXP30", "unknownEvaluationOrder"},
+    {"EXP33", "uninitvar,uninitdata,uninitStructMember"},
+    {"EXP34", "nullPointer,nullPointerDefaultArg,nullPointerRedundantCheck,nullPointerArithmetic,nullPointerArithmeticRedundantCheck"},
+    {"EXP44", "sizeofCalculation"},
+    {"EXP46", "bitwiseOnBoolean"},
+    {"INT32", "integerOverflow"},
+    {"FLP32", "invalidFunctionArg"},
+    {"FLP34", "floatConversionOverflow"},
+    {"ARR30", "arrayIndexOutOfBounds,arrayIndexOutOfBoundsCond,pointerOutOfBounds,pointerOutOfBoundsCond,negativeIndex,arrayIndexThenCheck,bufferAccessOutOfBounds,objectIndex,argumentSize"},
+    {"ARR36", "comparePointers"},
+    {"STR30", "stringLiteralWrite"},
+    {"STR37", "invalidFunctionArg"},
+    {"MEM30", "doubleFree,deallocret,deallocuse"},
+    {"MEM31", "memleak,leakReturnValNotUsed,leakUnsafeArgAlloc,memleakOnRealloc"},
+    {"MEM34", "autovarInvalidDeallocation,mismatchAllocDealloc"},
+    {"FIO39", "IOWithoutPositioning"},
+    {"FIO42", "resourceLeak"},
+    {"FIO46", "deallocuse,useClosedFile"},
+    {"FIO47", "invalidscanf,wrongPrintfScanfArgNum,invalidLengthModifierError,invalidScanfFormatWidth,wrongPrintfScanfParameterPositionError"},
+    {"MSC37", "missingReturn"},
+};
+
+std::vector<checkers::IdMapping> checkers::idMappingCertCpp{
+    {"CTR51", "eraseDereference"},
+    {"CTR54", "comparePointers"},
+    {"CTR55", "containerOutOfBounds"},
+    {"DCL57", "exceptDeallocThrow,exceptThrowInDestructor"},
+    {"DCL60", "ctuOneDefinitionRuleViolation"},
+    {"ERR57", "memleak"},
+    {"EXP52", "sizeofCalculation"},
+    {"EXP53", "uninitvar,uninitdata,uninitStructMember"},
+    {"EXP54", "uninitvar,danglingLifetime,danglingReference,danglingTemporaryLifetime,danglingTempReference,returnDanglingLifetime"},
+    {"EXP61", "danglingLifetime,danglingReference,danglingTemporaryLifetime,danglingTempReference,returnDanglingLifetime,deallocuse,deallocret"},
+    {"EXP63", "accessMoved"},
+    {"FIO50", "IOWithoutPositioning"},
+    {"MEM50", "deallocuse"},
+    {"MEM51", "mismatchAllocDealloc"},
+    {"MEM56", "doubleFree"},
+    {"MSC52", "missingReturn"},
+    {"OOP50", "virtualCallInConstructor"},
+    {"OOP52", "virtualDestructor"},
+    {"OOP53", "initializerList"},
+    {"OOP54", "operatorEqToSelf"},
+    {"STR51", "nullPointer"},
+    {"STR52", "invalidContainer"},
+};
+
+std::vector<checkers::IdMapping> checkers::idMappingMisraC{
+    {"1.1", "syntaxError"},
+    {"1.3", "error"},
+    {"2.1", "duplicateBreak,unreachableCode"},
+    {"2.2", "constStatement,redundantCondition,redundantAssignment,redundantAssignInSwitch,unreadVariable,unusedFunction"},
+    {"2.6", "unusedLabel"},
+    {"2.8", "unusedVariable"},
+    {"5.3", "shadowVariable"},
+    {"8.3", "funcArgNamesDifferent"},
+    {"8.13", "constParameterPointer"},
+    {"9.1", "uninitvar"},
+    {"12.5", "sizeofwithsilentarraypointer"},
+    {"13.2", "unknownEvaluationOrder"},
+    {"13.6", "sizeofCalculation"},
+    {"14.3", "compareValueOutOfTypeRangeError,knownConditionTrueFalse"},
+    {"17.4", "missingReturn"},
+    {"17.5", "argumentSize"},
+    {"18.1", "pointerOutOfBounds"},
+    {"18.2", "comparePointers"},
+    {"18.3", "comparePointers"},
+    {"18.6", "danglingLifetime,danglingTemporaryLifetime,returnDanglingLifetime"},
+    {"19.1", "overlappingWriteUnion,overlappingWriteFunction"},
+    {"20.6", "preprocessorErrorDirective"},
+    {"21.13", "invalidFunctionArg"},
+    {"21.17", "bufferAccessOutOfBounds"},
+    {"21.18", "bufferAccessOutOfBounds"},
+    {"22.1", "memleak,resourceLeak,memleakOnRealloc,leakReturnValNotUsed,leakNoVarFunctionCall"},
+    {"22.2", "autovarInvalidDeallocation"},
+    {"22.3", "incompatibleFileOpen"},
+    {"22.4", "writeReadOnlyFile"},
+    {"22.6", "useClosedFile"},
+};
+
+std::vector<checkers::IdMapping> checkers::idMappingMisraCpp2008{
+    {"0-1-1", "unreachableCode,duplicateBreak"},
+    {"0-1-2", "unsignedLessThanZero"},
+    {"0-1-3", "unusedVariable,unusedStructMember"},
+    {"0-1-6", "redundantAssignment,unreadVariable,variableScope"},
+    {"0-1-9", "redundantAssignment,redundantInitialization"},
+    {"0-1-10", "unusedFunction"},
+    {"0-2-1", "overlappingWriteUnion,overlappingWriteFunction"},
+    {"2-10-2", "shadowVariable"},
+    {"3-2-2", "ctuOneDefinitionRuleViolation"},
+    {"3-4-1", "variableScope"},
+    {"5-0-1", "unknownEvaluationOrder"},
+    {"5-0-16", "pointerOutOfBounds"},
+    {"5-0-17", "comparePointers"},
+    {"5-0-18", "comparePointers"},
+    {"5-2-4", "cstyleCast,dangerousTypeCast"},
+    {"5-3-4", "sizeofFunctionCall"},
+    {"5-8-1", "shiftTooManyBits"},
+    {"6-6-5", "missingReturn"},
+    {"7-1-1", "constVariable,constParameter"},
+    {"7-1-2", "constParameter"},
+    {"7-5-1", "autoVariables,returnReference,returnTempReference"},
+    {"7-5-2", "danglingLifetime"},
+    {"8-4-2", "funcArgNamesDifferent"},
+    {"8-4-3", "missingReturn"},
+    {"8-5-1", "uninitvar,uninitdata,uninitStructMember,uninitMemberVar,uninitMemberVarPrivate,uninitDerivedMemberVar,uninitDerivedMemberVarPrivate"},
+    {"9-3-3", "functionConst,functionStatic"},
+    {"10-2-1", "duplInheritedMember"},
+    {"12-1-1", "virtualCallInConstructor"},
+    {"12-1-3", "noExplicitConstructor"},
+    {"15-3-1", "exceptThrowInDestructor"},
+    {"15-5-1", "exceptThrowInDestructor"},
+    {"15-5-3", "exceptThrowInDestructor"},
+    {"16-0-5", "preprocessorErrorDirective"},
+};
+
+std::vector<checkers::IdMapping> checkers::idMappingMisraCpp2023{
+    {"0.0.1", "unreachableCode"},
+    {"0.0.2", "compareBoolExpressionWithInt,compareValueOutOfTypeRangeError,identicalConditionAfterEarlyExit,identicalInnerCondition,knownConditionTrueFalse"},
+    {"0.1.1", "redundantAssignInSwitch,redundantAssignment,redundantCopy,redundantInitialization,unreadVariable"},
+    {"Dir 0.3.1", "floatConversionOverflow"},
+    {"Dir 0.3.2", "invalidFunctionArg,invalidFunctionArgBool,invalidFunctionArgStr"},
+    {"4.1.3", "error"},
+    {"4.6.1", "unknownEvaluationOrder"},
+    {"5.10.1", "syntaxError"},
+    {"6.2.1", "ctuOneDefinitionRuleViolation"},
+    {"6.4.1", "shadowVariable"},
+    {"6.8.1", "danglingLifetime"},
+    {"6.8.2", "autoVariables"},
+    {"8.7.1", "pointerOutOfBounds,pointerOutOfBoundsCond"},
+    {"8.7.2", "subtractPointers"},
+    {"8.9.1", "comparePointers"},
+    {"8.18.1", "overlappingWriteUnion"},
+    {"9.6.5", "missingReturn"},
+    {"10.1.1", "constParameter,constParameterReference"},
+    {"11.6.2", "uninitvar"},
+    {"15.1.1", "virtualCallInConstructor"},
+    {"15.1.3", "noExplicitConstructor"},
+    {"15.1.4", "uninitMemberVar"},
+    {"Dir 15.8.1", "operatorEqToSelf"},
+    {"19.3.5", "preprocessorErrorDirective"},
+    {"28.6.3", "accessForwarded,accessMoved"},
+    {"28.6.4", "ignoredReturnValue"},
+};
diff --git a/lib/checkersreport.cpp b/lib/checkersreport.cpp
new file mode 100644
index 00000000000..a3d55747fe3
--- /dev/null
+++ b/lib/checkersreport.cpp
@@ -0,0 +1,248 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "checkersreport.h"
+
+#include "addoninfo.h"
+#include "checkers.h"
+#include "settings.h"
+#include "utils.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <map>
+#include <sstream>
+#include <unordered_set>
+#include <vector>
+
+static int getMisraCVersion(const Settings& settings) {
+    if (settings.premiumArgs.find("misra-c-2025") != std::string::npos)
+        return 2025;
+    if (settings.premiumArgs.find("misra-c-2023") != std::string::npos)
+        return 2023;
+    if (settings.premiumArgs.find("misra-c-2012") != std::string::npos)
+        return 2012;
+    if (settings.addons.count("misra"))
+        return 2012;
+    const bool misraAddonInfo = std::any_of(settings.addonInfos.cbegin(), settings.addonInfos.cend(), [](const AddonInfo& addonInfo) {
+        return addonInfo.name == "misra";
+    });
+    if (misraAddonInfo)
+        return 2012;
+    return 0;
+}
+
+static bool isMisraRuleActive(const std::set<std::string>& activeCheckers, const std::string& rule) {
+    if (activeCheckers.count("Misra C: " + rule))
+        return true;
+    if (rule == "1.1")
+        return true; // syntax error
+    if (rule == "1.3")
+        return true; // undefined behavior
+    if (rule == "2.1")
+        return activeCheckers.count("CheckCondition::alwaysTrueFalse") != 0;
+    if (rule == "2.6")
+        return activeCheckers.count("CheckOther::checkUnusedLabel") != 0;
+    if (rule == "2.8")
+        return activeCheckers.count("CheckUnusedVar::checkFunctionVariableUsage") != 0;
+    if (rule == "5.3")
+        return activeCheckers.count("CheckOther::checkShadowVariables") != 0;
+    if (rule == "8.13")
+        return activeCheckers.count("CheckOther::checkConstPointer") != 0;
+    if (rule == "9.1")
+        return true; // uninitvar
+    if (rule == "12.5")
+        return activeCheckers.count("CheckOther::checkConstPointer") != 0;
+    if (rule == "14.3")
+        return activeCheckers.count("CheckCondition::alwaysTrueFalse") != 0;
+    if (rule == "17.5")
+        return activeCheckers.count("CheckBufferOverrun::argumentSize") != 0;
+    if (rule == "18.1")
+        return activeCheckers.count("CheckBufferOverrun::pointerArithmetic") != 0;
+    if (rule == "18.2")
+        return activeCheckers.count("CheckOther::checkComparePointers") != 0;
+    if (rule == "18.3")
+        return activeCheckers.count("CheckOther::checkComparePointers") != 0;
+    if (rule == "18.6")
+        return true; // danlingLifetime => error
+    if (rule == "19.1")
+        return activeCheckers.count("CheckOther::checkOverlappingWrite") != 0;
+    if (rule == "20.6")
+        return true; // preprocessorErrorDirective
+    if (rule == "21.13")
+        return activeCheckers.count("CheckFunctions::invalidFunctionUsage") != 0;
+    if (rule == "21.17")
+        return activeCheckers.count("CheckBufferOverrun::bufferOverflow") != 0;
+    if (rule == "21.18")
+        return activeCheckers.count("CheckBufferOverrun::bufferOverflow") != 0;
+    if (rule == "22.1")
+        return true;  // memleak => error
+    if (rule == "22.2")
+        return activeCheckers.count("CheckAutoVariables::autoVariables") != 0;
+    if (rule == "22.3")
+        return activeCheckers.count("CheckIO::checkFileUsage") != 0;
+    if (rule == "22.4")
+        return activeCheckers.count("CheckIO::checkFileUsage") != 0;
+    if (rule == "22.6")
+        return activeCheckers.count("CheckIO::checkFileUsage") != 0;
+
+    return false;
+}
+
+CheckersReport::CheckersReport(const Settings& settings, const std::set<std::string>& activeCheckers)
+    : mSettings(settings), mActiveCheckers(activeCheckers)
+{}
+
+int CheckersReport::getActiveCheckersCount()
+{
+    if (mAllCheckersCount == 0) {
+        countCheckers();
+    }
+    return mActiveCheckersCount;
+}
+
+int CheckersReport::getAllCheckersCount()
+{
+    if (mAllCheckersCount == 0) {
+        countCheckers();
+    }
+    return mAllCheckersCount;
+}
+
+void CheckersReport::countCheckers()
+{
+    mActiveCheckersCount = mAllCheckersCount = 0;
+
+    for (const auto& checkReq: checkers::allCheckers) {
+        if (mActiveCheckers.count(checkReq.first) > 0)
+            ++mActiveCheckersCount;
+        ++mAllCheckersCount;
+    }
+    for (const auto& addonInfo: mSettings.addonInfos) {
+        for (const auto& checkReq: addonInfo.checkers) {
+            if (mActiveCheckers.count(checkReq.first) > 0)
+                ++mActiveCheckersCount;
+            ++mAllCheckersCount;
+        }
+    }
+
+    if (mSettings.addons.count("misra")) {
+        const bool doUnusedFunctionOnly = Settings::unusedFunctionOnly();
+        for (const checkers::MisraInfo& info: checkers::misraC2012Rules) {
+            const std::string rule = std::to_string(info.a) + "." + std::to_string(info.b);
+            // this will return some rules as always active even if they are not in the active checkers.
+            // this leads to a difference in the shown count and in the checkers stored in the builddir
+            // TODO: fix this?
+            const bool active = !doUnusedFunctionOnly && isMisraRuleActive(mActiveCheckers, rule);
+            if (active)
+                ++mActiveCheckersCount;
+            ++mAllCheckersCount;
+        }
+    }
+}
+
+std::string CheckersReport::getReport(const std::string& criticalErrors) const
+{
+    std::ostringstream fout;
+
+    fout << "Critical errors" << std::endl;
+    fout << "---------------" << std::endl;
+    if (!criticalErrors.empty()) {
+        fout << "There were critical errors (" << criticalErrors << ")." << std::endl;
+        fout << "These cause the analysis of the file to end prematurely." << std::endl;
+    } else {
+        fout << "No critical errors encountered." << std::endl;
+        // TODO: mention "information" and "debug" as source for indications of bailouts
+        // TODO: still rephrase this - this message does not provides confidence in the results
+        // TODO: document what a bailout is and why it is done - mention it in the upcoming security/tuning guide
+        // TODO: make bailouts a seperate group - need to differentiate between user bailouts (missing data like configuration/includes) and internal bailouts (e.g. limitations of ValueFlow)
+        fout << "Note: There might still have been non-critical bailouts which might lead to false negatives." << std::endl;
+    }
+
+    fout << std::endl << std::endl;
+    fout << "Open source checkers" << std::endl;
+    fout << "--------------------" << std::endl;
+
+    std::size_t maxCheckerSize = 0;
+    for (const auto& checkReq: checkers::allCheckers) {
+        const std::string& checker = checkReq.first;
+        maxCheckerSize = std::max(checker.size(), maxCheckerSize);
+    }
+    for (const auto& checkReq: checkers::allCheckers) {
+        const std::string& checker = checkReq.first;
+        const bool active = mActiveCheckers.count(checkReq.first) > 0;
+        const std::string& req = checkReq.second;
+        fout << (active ? "Yes  " : "No   ") << checker;
+        if (!active && !req.empty())
+            fout << std::string(maxCheckerSize + 4 - checker.size(), ' ') << "require:" + req;
+        fout << std::endl;
+    }
+
+    for (const auto& addonInfo: mSettings.addonInfos) {
+        if (addonInfo.checkers.empty())
+            continue;
+        fout << std::endl << std::endl;
+        std::string title;
+        if (mSettings.premium && addonInfo.name == "premiumaddon.json")
+            title = "Cppcheck Premium";
+        else {
+            title = addonInfo.name;
+            if (endsWith(title, ".json"))
+                title.erase(title.rfind('.'));
+        }
+        title += " checkers";
+        fout << title << std::endl;
+        fout << std::string(title.size(), '-') << std::endl;
+
+        maxCheckerSize = 0;
+        for (const auto& checkReq: addonInfo.checkers) {
+            const std::string& checker = checkReq.first;
+            maxCheckerSize = std::max(checker.size(), maxCheckerSize);
+        }
+
+        for (const auto& checkReq: addonInfo.checkers) {
+            const std::string& checker = checkReq.first;
+            const bool active = mActiveCheckers.count(checkReq.first) > 0;
+            const std::string& req = checkReq.second;
+            fout << (active ? "Yes  " : "No   ") << checker;
+            if (!active && !req.empty())
+                fout << std::string(maxCheckerSize + 4 - checker.size(), ' ') << "require:" << req;
+            fout << std::endl;
+        }
+    }
+
+    return fout.str();
+}
+
+std::string CheckersReport::getXmlReport(const std::string& criticalErrors) const
+{
+    std::string ret;
+    if (!criticalErrors.empty())
+        ret += "    <critical-errors>" + criticalErrors + "</critical-errors>\n";
+    else
+        ret += "    <critical-errors/>\n";
+    ret += "    <checkers-report>\n";
+    const int misraCVersion = getMisraCVersion(mSettings);
+    for (std::string checker: mActiveCheckers) {
+        if (checker.compare(0,8,"Misra C:") == 0)
+            checker = "Misra C " + std::to_string(misraCVersion) + ":" + checker.substr(8);
+        ret += "        <checker id=\"" + checker + "\"/>\n";
+    }
+    ret += "    </checkers-report>";
+    return ret;
+}
diff --git a/lib/checkersreport.h b/lib/checkersreport.h
new file mode 100644
index 00000000000..b189a7f1ebd
--- /dev/null
+++ b/lib/checkersreport.h
@@ -0,0 +1,49 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef checkersReportH
+#define checkersReportH
+
+#include "config.h"
+
+#include <set>
+#include <string>
+
+class Settings;
+
+class CPPCHECKLIB CheckersReport {
+public:
+    CheckersReport(const Settings& settings, const std::set<std::string>& activeCheckers);
+
+    int getActiveCheckersCount();
+    int getAllCheckersCount();
+
+    std::string getReport(const std::string& criticalErrors) const;
+    std::string getXmlReport(const std::string& criticalErrors) const;
+
+private:
+    const Settings& mSettings;
+    const std::set<std::string>& mActiveCheckers;
+
+    void countCheckers();
+
+    int mActiveCheckersCount = 0;
+    int mAllCheckersCount = 0;
+};
+
+#endif
diff --git a/lib/checkexceptionsafety.cpp b/lib/checkexceptionsafety.cpp
index a3ebe397091..34303cc0f4a 100644
--- a/lib/checkexceptionsafety.cpp
+++ b/lib/checkexceptionsafety.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,12 +19,18 @@
 //---------------------------------------------------------------------------
 #include "checkexceptionsafety.h"
 
+#include "astutils.h"
+#include "errortypes.h"
+#include "library.h"
 #include "settings.h"
 #include "symboldatabase.h"
+#include "token.h"
+#include "tokenize.h"
 
-#include <cstddef>
+#include <list>
 #include <set>
 #include <utility>
+#include <vector>
 
 //---------------------------------------------------------------------------
 
@@ -33,14 +39,19 @@ namespace {
     CheckExceptionSafety instance;
 }
 
+static const CWE CWE398(398U);   // Indicator of Poor Code Quality
+static const CWE CWE703(703U);   // Improper Check or Handling of Exceptional Conditions
+static const CWE CWE480(480U);   // Use of Incorrect Operator
 
 //---------------------------------------------------------------------------
 
 void CheckExceptionSafety::destructors()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckExceptionSafety::destructors"); // warning
+
     const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
 
     // Perform check..
@@ -49,22 +60,21 @@ void CheckExceptionSafety::destructors()
         if (!function)
             continue;
         // only looking for destructors
-        if (function->type == Function::eDestructor) {
+        if (function->type == FunctionType::eDestructor) {
             // Inspect this destructor.
             for (const Token *tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
                 // Skip try blocks
                 if (Token::simpleMatch(tok, "try {")) {
-                    tok = tok->next()->link();
+                    tok = tok->linkAt(1);
                 }
 
                 // Skip uncaught exceptions
                 else if (Token::simpleMatch(tok, "if ( ! std :: uncaught_exception ( ) ) {")) {
-                    tok = tok->next()->link(); // end of if ( ... )
-                    tok = tok->next()->link(); // end of { ... }
+                    tok = tok->linkAt(1); // end of if ( ... )
+                    tok = tok->linkAt(1); // end of { ... }
                 }
-
                 // throw found within a destructor
-                else if (tok->str() == "throw") {
+                else if (tok->str() == "throw" && function->isNoExcept()) {
                     destructorsError(tok, scope->className);
                     break;
                 }
@@ -73,15 +83,24 @@ void CheckExceptionSafety::destructors()
     }
 }
 
-
+void CheckExceptionSafety::destructorsError(const Token * const tok, const std::string &className)
+{
+    reportError(tok, Severity::warning, "exceptThrowInDestructor",
+                "Class " + className + " is not safe, destructor throws exception\n"
+                "The class " + className + " is not safe because its destructor "
+                "throws an exception. If " + className + " is used and an exception "
+                "is thrown that is caught in an outer scope the program will terminate.", CWE398, Certainty::normal);
+}
 
 
 void CheckExceptionSafety::deallocThrow()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning) && !mSettings->isPremiumEnabled("exceptDeallocThrow"))
         return;
 
-    const bool printInconclusive = mSettings->inconclusive;
+    logChecker("CheckExceptionSafety::deallocThrow"); // warning
+
+    const bool printInconclusive = mSettings->certainty.isEnabled(Certainty::inconclusive);
     const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
 
     // Deallocate a global/member pointer and then throw exception
@@ -137,6 +156,12 @@ void CheckExceptionSafety::deallocThrow()
     }
 }
 
+void CheckExceptionSafety::deallocThrowError(const Token * const tok, const std::string &varname)
+{
+    reportError(tok, Severity::warning, "exceptDeallocThrow", "Exception thrown in invalid state, '" +
+                varname + "' points at deallocated memory.", CWE398, Certainty::normal);
+}
+
 //---------------------------------------------------------------------------
 //      catch(const exception & err)
 //      {
@@ -145,22 +170,30 @@ void CheckExceptionSafety::deallocThrow()
 //---------------------------------------------------------------------------
 void CheckExceptionSafety::checkRethrowCopy()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("exceptRethrowCopy"))
         return;
 
+    logChecker("CheckExceptionSafety::checkRethrowCopy"); // style
+
     const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope &scope : symbolDatabase->scopeList) {
-        if (scope.type != Scope::eCatch)
+        if (scope.type != ScopeType::eCatch)
             continue;
 
         const unsigned int varid = scope.bodyStart->tokAt(-2)->varId();
         if (varid) {
             for (const Token* tok = scope.bodyStart->next(); tok && tok != scope.bodyEnd; tok = tok->next()) {
-                if (Token::simpleMatch(tok, "catch (") && tok->next()->link() && tok->next()->link()->next()) { // Don't check inner catch - it is handled in another iteration of outer loop.
-                    tok = tok->next()->link()->next()->link();
+                if (Token::simpleMatch(tok, "catch (") && tok->linkAt(1) && tok->linkAt(1)->next()) { // Don't check inner catch - it is handled in another iteration of outer loop.
+                    tok = tok->linkAt(1)->linkAt(1);
                     if (!tok)
                         break;
+                } else if (Token::Match(tok, "%varid% .", varid)) {
+                    const Token *parent = tok->astParent();
+                    while (Token::simpleMatch(parent->astParent(), "."))
+                        parent = parent->astParent();
+                    if (Token::Match(parent->astParent(), "%assign%|++|--|(") && parent == parent->astParent()->astOperand1())
+                        break;
                 } else if (Token::Match(tok, "throw %varid% ;", varid))
                     rethrowCopyError(tok, tok->strAt(1));
             }
@@ -168,18 +201,28 @@ void CheckExceptionSafety::checkRethrowCopy()
     }
 }
 
+void CheckExceptionSafety::rethrowCopyError(const Token * const tok, const std::string &varname)
+{
+    reportError(tok, Severity::style, "exceptRethrowCopy",
+                "Throwing a copy of the caught exception instead of rethrowing the original exception.\n"
+                "Rethrowing an exception with 'throw " + varname + ";' creates an unnecessary copy of '" + varname + "'. "
+                "To rethrow the caught exception without unnecessary copying or slicing, use a bare 'throw;'.", CWE398, Certainty::normal);
+}
+
 //---------------------------------------------------------------------------
 //    try {} catch (std::exception err) {} <- Should be "std::exception& err"
 //---------------------------------------------------------------------------
 void CheckExceptionSafety::checkCatchExceptionByValue()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("catchExceptionByValue"))
         return;
 
+    logChecker("CheckExceptionSafety::checkCatchExceptionByValue"); // style
+
     const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope &scope : symbolDatabase->scopeList) {
-        if (scope.type != Scope::eCatch)
+        if (scope.type != ScopeType::eCatch)
             continue;
 
         // Find a pass-by-value declaration in the catch(), excluding basic types
@@ -190,6 +233,13 @@ void CheckExceptionSafety::checkCatchExceptionByValue()
     }
 }
 
+void CheckExceptionSafety::catchExceptionByValueError(const Token *tok)
+{
+    reportError(tok, Severity::style,
+                "catchExceptionByValue", "Exception should be caught by reference.\n"
+                "The exception is caught by value. It could be caught "
+                "as a (const) reference which is usually recommended in C++.", CWE398, Certainty::normal);
+}
 
 static const Token * functionThrowsRecursive(const Function * function, std::set<const Function *> & recursive)
 {
@@ -202,23 +252,22 @@ static const Token * functionThrowsRecursive(const Function * function, std::set
 
     for (const Token *tok = function->functionScope->bodyStart->next();
          tok != function->functionScope->bodyEnd; tok = tok->next()) {
-        if (tok->str() == "try") {
-            // just bail for now
-            break;
-        }
-        if (tok->str() == "throw") {
+        tok = skipUnreachableBranch(tok);
+        if (Token::simpleMatch(tok, "try {"))
+            tok = tok->linkAt(1);  // skip till start of catch clauses
+        if (tok->str() == "throw")
             return tok;
-        } else if (tok->function()) {
+        if (tok->function() && (Token::simpleMatch(tok->astParent(), "(") ||
+                                (Token::simpleMatch(tok->astParent(), ".") && Token::simpleMatch(tok->astParent()->astParent(), "(")))) {
             const Function * called = tok->function();
             // check if called function has an exception specification
-            if (called->isThrow() && called->throwArg) {
+            if (called->isThrow() && called->throwArg)
                 return tok;
-            } else if (called->isNoExcept() && called->noexceptArg &&
-                       called->noexceptArg->str() != "true") {
+            if (called->isNoExcept() && called->noexceptArg &&
+                called->noexceptArg->str() != "true")
                 return tok;
-            } else if (functionThrowsRecursive(called, recursive)) {
+            if (functionThrowsRecursive(called, recursive))
                 return tok;
-            }
         }
     }
 
@@ -227,7 +276,7 @@ static const Token * functionThrowsRecursive(const Function * function, std::set
 
 static const Token * functionThrows(const Function * function)
 {
-    std::set<const Function *>  recursive;
+    std::set<const Function *> recursive;
 
     return functionThrowsRecursive(function, recursive);
 }
@@ -239,6 +288,8 @@ static const Token * functionThrows(const Function * function)
 //--------------------------------------------------------------------------
 void CheckExceptionSafety::nothrowThrows()
 {
+    logChecker("CheckExceptionSafety::nothrowThrows");
+
     const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope * scope : symbolDatabase->functionScopes) {
@@ -246,50 +297,58 @@ void CheckExceptionSafety::nothrowThrows()
         if (!function)
             continue;
 
-        // check noexcept and noexcept(true) functions
-        if (function->isNoExcept() &&
-            (!function->noexceptArg || function->noexceptArg->str() == "true")) {
-            const Token *throws = functionThrows(function);
-            if (throws)
-                noexceptThrowError(throws);
+        bool isNoExcept = false, isEntryPoint = false;
+        if (function->isNoExcept() || // noexcept and noexcept(true) functions
+            (function->isThrow() && !function->throwArg) || //  throw() functions
+            function->isAttributeNothrow()) { // __attribute__((nothrow)) or __declspec(nothrow) functions
+            isNoExcept = true;
         }
-
-        // check throw() functions
-        else if (function->isThrow() && !function->throwArg) {
-            const Token *throws = functionThrows(function);
-            if (throws)
-                noexceptThrowError(throws);
+        else if (mSettings->library.isentrypoint(function->name())) {
+            isEntryPoint = true;
         }
+        if (!isNoExcept && !isEntryPoint)
+            continue;
 
-        // check __attribute__((nothrow)) or __declspec(nothrow) functions
-        else if (function->isAttributeNothrow()) {
-            const Token *throws = functionThrows(function);
-            if (throws)
+        if (const Token* throws = functionThrows(function)) {
+            if (isEntryPoint)
+                entryPointThrowError(throws);
+            else
                 noexceptThrowError(throws);
         }
     }
 }
 
+void CheckExceptionSafety::noexceptThrowError(const Token * const tok)
+{
+    reportError(tok, Severity::error, "throwInNoexceptFunction", "Unhandled exception thrown in function declared not to throw exceptions.", CWE398, Certainty::normal);
+}
+
+void CheckExceptionSafety::entryPointThrowError(const Token * const tok)
+{
+    reportError(tok, Severity::error, "throwInEntryPoint", "Unhandled exception thrown in function that is an entry point.", CWE398, Certainty::normal);
+}
+
 //--------------------------------------------------------------------------
 //    void func() { functionWithExceptionSpecification(); }
 //--------------------------------------------------------------------------
 void CheckExceptionSafety::unhandledExceptionSpecification()
 {
-    if (!mSettings->isEnabled(Settings::STYLE) || !mSettings->inconclusive)
+    if ((!mSettings->severity.isEnabled(Severity::style) || !mSettings->certainty.isEnabled(Certainty::inconclusive)) &&
+        !mSettings->isPremiumEnabled("unhandledExceptionSpecification"))
         return;
 
+    logChecker("CheckExceptionSafety::unhandledExceptionSpecification"); // style,inconclusive
+
     const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope * scope : symbolDatabase->functionScopes) {
-        // only check functions without exception epecification
-        if (scope->function && !scope->function->isThrow() &&
-            scope->className != "main" && scope->className != "wmain" &&
-            scope->className != "_tmain" && scope->className != "WinMain") {
+        // only check functions without exception specification
+        if (scope->function && !scope->function->isThrow() && !mSettings->library.isentrypoint(scope->className)) {
             for (const Token *tok = scope->function->functionScope->bodyStart->next();
                  tok != scope->function->functionScope->bodyEnd; tok = tok->next()) {
-                if (tok->str() == "try") {
+                if (tok->str() == "try")
                     break;
-                } else if (tok->function()) {
+                if (tok->function()) {
                     const Function * called = tok->function();
                     // check if called function has an exception specification
                     if (called->isThrow() && called->throwArg) {
@@ -302,3 +361,83 @@ void CheckExceptionSafety::unhandledExceptionSpecification()
     }
 }
 
+void CheckExceptionSafety::unhandledExceptionSpecificationError(const Token * const tok1, const Token * const tok2, const std::string & funcname)
+{
+    const std::string str1(tok1 ? tok1->str() : "foo");
+    const std::list<const Token*> locationList = { tok1, tok2 };
+    reportError(locationList, Severity::style, "unhandledExceptionSpecification",
+                "Unhandled exception specification when calling function " + str1 + "().\n"
+                "Unhandled exception specification when calling function " + str1 + "(). "
+                "Either use a try/catch around the function call, or add a exception specification for " + funcname + "() also.", CWE703, Certainty::inconclusive);
+}
+
+//--------------------------------------------------------------------------
+// 7.6.18.4 If no exception is presently being handled, evaluating a throw-expression with no operand calls std​::​​terminate().
+//--------------------------------------------------------------------------
+void CheckExceptionSafety::rethrowNoCurrentException()
+{
+    logChecker("CheckExceptionSafety::rethrowNoCurrentException");
+    const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
+    for (const Scope * scope : symbolDatabase->functionScopes) {
+        const Function* function = scope->function;
+        if (!function)
+            continue;
+
+        // Rethrow can be used in 'exception dispatcher' idiom which is FP in such case
+        // https://isocpp.org/wiki/faq/exceptions#throw-without-an-object
+        // We check the beginning of the function with idiom pattern
+        if (Token::simpleMatch(function->functionScope->bodyStart->next(), "try { throw ; } catch ("))
+            continue;
+
+        for (const Token *tok = function->functionScope->bodyStart->next();
+             tok != function->functionScope->bodyEnd; tok = tok->next()) {
+            if (Token::simpleMatch(tok, "catch (")) {
+                tok = tok->linkAt(1);       // skip catch argument
+                if (Token::simpleMatch(tok, ") {"))
+                    tok = tok->linkAt(1);   // skip catch scope
+                else
+                    break;
+            }
+            if (Token::simpleMatch(tok, "throw ;")) {
+                rethrowNoCurrentExceptionError(tok);
+            }
+        }
+    }
+}
+
+void CheckExceptionSafety::rethrowNoCurrentExceptionError(const Token *tok)
+{
+    reportError(tok, Severity::error, "rethrowNoCurrentException",
+                "Rethrowing current exception with 'throw;', it seems there is no current exception to rethrow."
+                " If there is no current exception this calls std::terminate()."
+                " More: https://isocpp.org/wiki/faq/exceptions#throw-without-an-object",
+                CWE480, Certainty::normal);
+}
+
+void CheckExceptionSafety::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    if (tokenizer.isC())
+        return;
+
+    CheckExceptionSafety checkExceptionSafety(&tokenizer, &tokenizer.getSettings(), errorLogger);
+    checkExceptionSafety.destructors();
+    checkExceptionSafety.deallocThrow();
+    checkExceptionSafety.checkRethrowCopy();
+    checkExceptionSafety.checkCatchExceptionByValue();
+    checkExceptionSafety.nothrowThrows();
+    checkExceptionSafety.unhandledExceptionSpecification();
+    checkExceptionSafety.rethrowNoCurrentException();
+}
+
+void CheckExceptionSafety::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const
+{
+    CheckExceptionSafety c(nullptr, settings, errorLogger);
+    c.destructorsError(nullptr, "Class");
+    c.deallocThrowError(nullptr, "p");
+    c.rethrowCopyError(nullptr, "varname");
+    c.catchExceptionByValueError(nullptr);
+    c.noexceptThrowError(nullptr);
+    c.entryPointThrowError(nullptr);
+    c.unhandledExceptionSpecificationError(nullptr, nullptr, "funcname");
+    c.rethrowNoCurrentExceptionError(nullptr);
+}
diff --git a/lib/checkexceptionsafety.h b/lib/checkexceptionsafety.h
index 76884b61a44..7c5a52b5605 100644
--- a/lib/checkexceptionsafety.h
+++ b/lib/checkexceptionsafety.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,20 +23,13 @@
 
 #include "check.h"
 #include "config.h"
-#include "errorlogger.h"
-#include "token.h"
-#include "tokenize.h"
-#include "utils.h"
 
-#include <list>
 #include <string>
 
 class Settings;
-
-// CWE ID used:
-static const struct CWE CWE398(398U);   // Indicator of Poor Code Quality
-static const struct CWE CWE703(703U);   // Improper Check or Handling of Exceptional Conditions
-
+class ErrorLogger;
+class Token;
+class Tokenizer;
 
 /// @addtogroup Checks
 /// @{
@@ -53,26 +46,14 @@ static const struct CWE CWE703(703U);   // Improper Check or Handling of Excepti
 class CPPCHECKLIB CheckExceptionSafety : public Check {
 public:
     /** This constructor is used when registering the CheckClass */
-    CheckExceptionSafety() : Check(myName()) {
-    }
+    CheckExceptionSafety() : Check(myName()) {}
 
+private:
     /** This constructor is used when running checks. */
     CheckExceptionSafety(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger) {}
 
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        if (tokenizer->isC())
-            return;
-
-        CheckExceptionSafety checkExceptionSafety(tokenizer, settings, errorLogger);
-        checkExceptionSafety.destructors();
-        checkExceptionSafety.deallocThrow();
-        checkExceptionSafety.checkRethrowCopy();
-        checkExceptionSafety.checkCatchExceptionByValue();
-        checkExceptionSafety.nothrowThrows();
-        checkExceptionSafety.unhandledExceptionSpecification();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     /** Don't throw exceptions in destructors */
     void destructors();
@@ -92,59 +73,23 @@ class CPPCHECKLIB CheckExceptionSafety : public Check {
     /** @brief %Check for unhandled exception specification */
     void unhandledExceptionSpecification();
 
-private:
-    /** Don't throw exceptions in destructors */
-    void destructorsError(const Token * const tok, const std::string &className) {
-        reportError(tok, Severity::warning, "exceptThrowInDestructor",
-                    "Class " + className + " is not safe, destructor throws exception\n"
-                    "The class " + className + " is not safe because its destructor "
-                    "throws an exception. If " + className + " is used and an exception "
-                    "is thrown that is caught in an outer scope the program will terminate.", CWE398, false);
-    }
-
-    void deallocThrowError(const Token * const tok, const std::string &varname) {
-        reportError(tok, Severity::warning, "exceptDeallocThrow", "Exception thrown in invalid state, '" +
-                    varname + "' points at deallocated memory.", CWE398, false);
-    }
-
-    void rethrowCopyError(const Token * const tok, const std::string &varname) {
-        reportError(tok, Severity::style, "exceptRethrowCopy",
-                    "Throwing a copy of the caught exception instead of rethrowing the original exception.\n"
-                    "Rethrowing an exception with 'throw " + varname + ";' creates an unnecessary copy of '" + varname + "'. "
-                    "To rethrow the caught exception without unnecessary copying or slicing, use a bare 'throw;'.", CWE398, false);
-    }
-
-    void catchExceptionByValueError(const Token *tok) {
-        reportError(tok, Severity::style,
-                    "catchExceptionByValue", "Exception should be caught by reference.\n"
-                    "The exception is caught by value. It could be caught "
-                    "as a (const) reference which is usually recommended in C++.", CWE398, false);
-    }
-
-    void noexceptThrowError(const Token * const tok) {
-        reportError(tok, Severity::error, "throwInNoexceptFunction", "Exception thrown in function declared not to throw exceptions.", CWE398, false);
-    }
+    /** @brief %Check for rethrow not from catch scope */
+    void rethrowNoCurrentException();
 
+    /** Don't throw exceptions in destructors */
+    void destructorsError(const Token * tok, const std::string &className);
+    void deallocThrowError(const Token * tok, const std::string &varname);
+    void rethrowCopyError(const Token * tok, const std::string &varname);
+    void catchExceptionByValueError(const Token *tok);
+    void noexceptThrowError(const Token * tok);
+    void entryPointThrowError(const Token * tok);
     /** Missing exception specification */
-    void unhandledExceptionSpecificationError(const Token * const tok1, const Token * const tok2, const std::string & funcname) {
-        const std::string str1(tok1 ? tok1->str() : "foo");
-        const std::list<const Token*> locationList = { tok1, tok2 };
-        reportError(locationList, Severity::style, "unhandledExceptionSpecification",
-                    "Unhandled exception specification when calling function " + str1 + "().\n"
-                    "Unhandled exception specification when calling function " + str1 + "(). "
-                    "Either use a try/catch around the function call, or add a exception specification for " + funcname + "() also.", CWE703, true);
-    }
+    void unhandledExceptionSpecificationError(const Token * tok1, const Token * tok2, const std::string & funcname);
+    /** Rethrow without currently handled exception */
+    void rethrowNoCurrentExceptionError(const Token *tok);
 
     /** Generate all possible errors (for --errorlist) */
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        CheckExceptionSafety c(nullptr, settings, errorLogger);
-        c.destructorsError(nullptr, "Class");
-        c.deallocThrowError(nullptr, "p");
-        c.rethrowCopyError(nullptr, "varname");
-        c.catchExceptionByValueError(nullptr);
-        c.noexceptThrowError(nullptr);
-        c.unhandledExceptionSpecificationError(nullptr, nullptr, "funcname");
-    }
+    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const override;
 
     /** Short description of class (for --doc) */
     static std::string myName() {
@@ -152,14 +97,15 @@ class CPPCHECKLIB CheckExceptionSafety : public Check {
     }
 
     /** wiki formatted description of the class (for --doc) */
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Checking exception safety\n"
                "- Throwing exceptions in destructors\n"
                "- Throwing exception during invalid state\n"
                "- Throwing a copy of a caught exception instead of rethrowing the original exception\n"
                "- Exception caught by value instead of by reference\n"
                "- Throwing exception in noexcept, nothrow(), __attribute__((nothrow)) or __declspec(nothrow) function\n"
-               "- Unhandled exception specification when calling function foo()\n";
+               "- Unhandled exception specification when calling function foo()\n"
+               "- Rethrow without currently handled exception\n";
     }
 };
 /// @}
diff --git a/lib/checkfunctions.cpp b/lib/checkfunctions.cpp
index 08774b4a067..f6799d199e7 100644
--- a/lib/checkfunctions.cpp
+++ b/lib/checkfunctions.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,17 +23,23 @@
 #include "checkfunctions.h"
 
 #include "astutils.h"
+#include "errortypes.h"
+#include "library.h"
 #include "mathlib.h"
+#include "platform.h"
+#include "settings.h"
 #include "standards.h"
 #include "symboldatabase.h"
 #include "token.h"
 #include "tokenize.h"
 #include "valueflow.h"
+#include "vfvalue.h"
 
-#include <cmath>
-#include <cstddef>
 #include <iomanip>
-#include <ostream>
+#include <list>
+#include <map>
+#include <sstream>
+#include <unordered_map>
 #include <vector>
 
 //---------------------------------------------------------------------------
@@ -54,7 +60,9 @@ static const CWE CWE688(688U);  // Function Call With Incorrect Variable or Refe
 
 void CheckFunctions::checkProhibitedFunctions()
 {
-    const bool checkAlloca = mSettings->isEnabled(Settings::WARNING) && ((mSettings->standards.c >= Standards::C99 && mTokenizer->isC()) || mSettings->standards.cpp >= Standards::CPP11);
+    const bool checkAlloca = mSettings->severity.isEnabled(Severity::warning) && ((mTokenizer->isC() && mSettings->standards.c >= Standards::C99) || mSettings->standards.cpp >= Standards::CPP11);
+
+    logChecker("CheckFunctions::checkProhibitedFunctions");
 
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope *scope : symbolDatabase->functionScopes) {
@@ -62,8 +70,8 @@ void CheckFunctions::checkProhibitedFunctions()
             if (!Token::Match(tok, "%name% (") && tok->varId() == 0)
                 continue;
             // alloca() is special as it depends on the code being C or C++, so it is not in Library
-            if (checkAlloca && Token::simpleMatch(tok, "alloca (") && (!tok->function() || tok->function()->nestedIn->type == Scope::eGlobal)) {
-                if (mTokenizer->isC()) {
+            if (checkAlloca && Token::simpleMatch(tok, "alloca (") && (!tok->function() || tok->function()->nestedIn->type == ScopeType::eGlobal)) {
+                if (tok->isC()) {
                     if (mSettings->standards.c > Standards::C89)
                         reportError(tok, Severity::warning, "allocaCalled",
                                     "$symbol:alloca\n"
@@ -84,8 +92,9 @@ void CheckFunctions::checkProhibitedFunctions()
 
                 const Library::WarnInfo* wi = mSettings->library.getWarnInfo(tok);
                 if (wi) {
-                    if (mSettings->isEnabled(wi->severity) && mSettings->standards.c >= wi->standards.c && mSettings->standards.cpp >= wi->standards.cpp) {
-                        reportError(tok, wi->severity, tok->str() + "Called", wi->message, CWE477, false);
+                    if (mSettings->severity.isEnabled(wi->severity) && ((tok->isC() && mSettings->standards.c >= wi->standards.c) || (tok->isCpp() && mSettings->standards.cpp >= wi->standards.cpp))) {
+                        const std::string daca = mSettings->daca ? "prohibited" : "";
+                        reportError(tok, wi->severity, daca + tok->str() + "Called", wi->message, CWE477, Certainty::normal);
                     }
                 }
             }
@@ -94,13 +103,15 @@ void CheckFunctions::checkProhibitedFunctions()
 }
 
 //---------------------------------------------------------------------------
-// Check <valid> and <not-bool>
+// Check <valid>, <strz> and <not-bool>
 //---------------------------------------------------------------------------
 void CheckFunctions::invalidFunctionUsage()
 {
+    logChecker("CheckFunctions::invalidFunctionUsage");
     const SymbolDatabase* symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope *scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
+            tok = skipUnreachableBranch(tok);
             if (!Token::Match(tok, "%name% ( !!)"))
                 continue;
             const Token * const functionToken = tok;
@@ -109,7 +120,7 @@ void CheckFunctions::invalidFunctionUsage()
                 const Token * const argtok = arguments[argnr-1];
 
                 // check <valid>...</valid>
-                const ValueFlow::Value *invalidValue = argtok->getInvalidValue(functionToken,argnr,mSettings);
+                const ValueFlow::Value *invalidValue = argtok->getInvalidValue(functionToken,argnr,*mSettings);
                 if (invalidValue) {
                     invalidFunctionArgError(argtok, functionToken->next()->astOperand1()->expressionString(), argnr, invalidValue, mSettings->library.validarg(functionToken, argnr));
                 }
@@ -120,21 +131,66 @@ void CheckFunctions::invalidFunctionUsage()
                         invalidFunctionArgBoolError(argtok, functionToken->str(), argnr);
 
                     // Are the values 0 and 1 valid?
-                    else if (!mSettings->library.isIntArgValid(functionToken, argnr, 0))
+                    else if (!mSettings->library.isIntArgValid(functionToken, argnr, 0, *mSettings))
                         invalidFunctionArgError(argtok, functionToken->str(), argnr, nullptr, mSettings->library.validarg(functionToken, argnr));
-                    else if (!mSettings->library.isIntArgValid(functionToken, argnr, 1))
+                    else if (!mSettings->library.isIntArgValid(functionToken, argnr, 1, *mSettings))
                         invalidFunctionArgError(argtok, functionToken->str(), argnr, nullptr, mSettings->library.validarg(functionToken, argnr));
                 }
-
+                // check <strz>
                 if (mSettings->library.isargstrz(functionToken, argnr)) {
                     if (Token::Match(argtok, "& %var% !![") && argtok->next() && argtok->next()->valueType()) {
                         const ValueType * valueType = argtok->next()->valueType();
                         const Variable * variable = argtok->next()->variable();
-                        if (valueType->type == ValueType::Type::CHAR && !variable->isArray() && !variable->isGlobal() &&
+                        if ((valueType->type == ValueType::Type::CHAR || valueType->type == ValueType::Type::WCHAR_T || (valueType->type == ValueType::Type::RECORD && Token::Match(argtok, "& %var% . %var% ,|)"))) &&
+                            !variable->isArray() &&
+                            (variable->isConst() || !variable->isGlobal()) &&
                             (!argtok->next()->hasKnownValue() || argtok->next()->getValue(0) == nullptr)) {
                             invalidFunctionArgStrError(argtok, functionToken->str(), argnr);
                         }
                     }
+                    const ValueType* const valueType = argtok->valueType();
+                    const Variable* const variable = argtok->variable();
+                    // Is non-null terminated local variable of type char (e.g. char buf[] = {'x'};) ?
+                    if (variable && variable->isLocal()
+                        && valueType && (valueType->type == ValueType::Type::CHAR || valueType->type == ValueType::Type::WCHAR_T)
+                        && !isVariablesChanged(variable->declEndToken(), functionToken, 0 /*indirect*/, { variable }, *mSettings)) {
+                        const Token* varTok = variable->declEndToken();
+                        MathLib::bigint count = -1; // Find out explicitly set count, e.g.: char buf[3] = {...}. Variable 'count' is set to 3 then.
+                        if (varTok && Token::simpleMatch(varTok->astOperand1(), "["))
+                        {
+                            const Token* const countTok = varTok->astOperand1()->astOperand2();
+                            if (countTok && countTok->hasKnownIntValue())
+                                count = countTok->getKnownIntValue();
+                        }
+                        if (Token::simpleMatch(varTok, "= {")) {
+                            varTok = varTok->tokAt(1);
+                            auto charsUntilFirstZero = 0;
+                            bool search = true;
+                            while (search && varTok && !Token::simpleMatch(varTok->next(), "}")) {
+                                varTok = varTok->next();
+                                if (!Token::simpleMatch(varTok, ",")) {
+                                    if (Token::Match(varTok, "%op%")) {
+                                        varTok = varTok->next();
+                                        continue;
+                                    }
+                                    ++charsUntilFirstZero;
+                                    if (varTok && varTok->hasKnownIntValue() && varTok->getKnownIntValue() == 0)
+                                        search=false; // stop counting for cases like char buf[3] = {'x', '\0', 'y'};
+                                }
+                            }
+                            if (varTok && varTok->hasKnownIntValue() && varTok->getKnownIntValue() != 0
+                                && (count == -1 || (count > 0 && count <= charsUntilFirstZero))) {
+                                invalidFunctionArgStrError(argtok, functionToken->str(), argnr);
+                            }
+                        } else if (count > -1 && Token::Match(varTok, "= %str%")) {
+                            const Token* strTok = varTok->getValueTokenMinStrSize(*mSettings);
+                            if (strTok) {
+                                const int strSize = Token::getStrArraySize(strTok);
+                                if (strSize > count && strTok->str().find('\0') == std::string::npos)
+                                    invalidFunctionArgStrError(argtok, functionToken->str(), argnr);
+                            }
+                        }
+                    }
                 }
             }
         }
@@ -156,18 +212,18 @@ void CheckFunctions::invalidFunctionArgError(const Token *tok, const std::string
         errmsg << " The value is 0 or 1 (boolean) but the valid values are '" << validstr << "'.";
     if (invalidValue)
         reportError(getErrorPath(tok, invalidValue, "Invalid argument"),
-                    invalidValue->errorSeverity() ? Severity::error : Severity::warning,
+                    invalidValue->errorSeverity() && invalidValue->isKnown() ? Severity::error : Severity::warning,
                     "invalidFunctionArg",
                     errmsg.str(),
                     CWE628,
-                    invalidValue->isInconclusive());
+                    invalidValue->isInconclusive() ? Certainty::inconclusive : Certainty::normal);
     else
         reportError(tok,
                     Severity::error,
                     "invalidFunctionArg",
                     errmsg.str(),
                     CWE628,
-                    false);
+                    Certainty::normal);
 }
 
 void CheckFunctions::invalidFunctionArgBoolError(const Token *tok, const std::string &functionName, int argnr)
@@ -175,7 +231,7 @@ void CheckFunctions::invalidFunctionArgBoolError(const Token *tok, const std::st
     std::ostringstream errmsg;
     errmsg << "$symbol:" << functionName << '\n';
     errmsg << "Invalid $symbol() argument nr " << argnr << ". A non-boolean value is required.";
-    reportError(tok, Severity::error, "invalidFunctionArgBool", errmsg.str(), CWE628, false);
+    reportError(tok, Severity::error, "invalidFunctionArgBool", errmsg.str(), CWE628, Certainty::normal);
 }
 
 void CheckFunctions::invalidFunctionArgStrError(const Token *tok, const std::string &functionName, nonneg int argnr)
@@ -183,7 +239,7 @@ void CheckFunctions::invalidFunctionArgStrError(const Token *tok, const std::str
     std::ostringstream errmsg;
     errmsg << "$symbol:" << functionName << '\n';
     errmsg << "Invalid $symbol() argument nr " << argnr << ". A nul-terminated string is required.";
-    reportError(tok, Severity::error, "invalidFunctionArgStr", errmsg.str(), CWE628, false);
+    reportError(tok, Severity::error, "invalidFunctionArgStr", errmsg.str(), CWE628, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -191,9 +247,13 @@ void CheckFunctions::invalidFunctionArgStrError(const Token *tok, const std::str
 //---------------------------------------------------------------------------
 void CheckFunctions::checkIgnoredReturnValue()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning) &&
+        !mSettings->severity.isEnabled(Severity::style) &&
+        !mSettings->isPremiumEnabled("ignoredReturnValue"))
         return;
 
+    logChecker("CheckFunctions::checkIgnoredReturnValue"); // style,warning
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope *scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
@@ -203,10 +263,16 @@ void CheckFunctions::checkIgnoredReturnValue()
             else if (Token::Match(tok, "[(<]") && tok->link())
                 tok = tok->link();
 
-            if (tok->varId() || !Token::Match(tok, "%name% ("))
+            if (tok->varId() || tok->isKeyword() || tok->isStandardType() || !Token::Match(tok, "%name% ("))
                 continue;
 
-            if (tok->next()->astParent())
+            const Token *parent = tok->next()->astParent();
+            while (Token::Match(parent, "%cop%")) {
+                if (Token::Match(parent, "<<|>>|*") && !parent->astParent())
+                    break;
+                parent = parent->astParent();
+            }
+            if (parent)
                 continue;
 
             if (!tok->scope()->isExecutable()) {
@@ -215,9 +281,16 @@ void CheckFunctions::checkIgnoredReturnValue()
             }
 
             if ((!tok->function() || !Token::Match(tok->function()->retDef, "void %name%")) &&
-                (mSettings->library.isUseRetVal(tok) || (tok->function() && tok->function()->isAttributeNodiscard())) &&
-                !WRONG_DATA(!tok->next()->astOperand1(), tok)) {
-                ignoredReturnValueError(tok, tok->next()->astOperand1()->expressionString());
+                tok->next()->astOperand1()) {
+                const Library::UseRetValType retvalTy = mSettings->library.getUseRetValType(tok);
+                const bool warn = (tok->function() && (tok->function()->isAttributeNodiscard() || tok->function()->isAttributePure() || tok->function()->isAttributeConst())) ||
+                                  // avoid duplicate warnings for resource-allocating functions
+                                  (retvalTy == Library::UseRetValType::DEFAULT && mSettings->library.getAllocFuncInfo(tok) == nullptr);
+                if (mSettings->severity.isEnabled(Severity::warning) && warn)
+                    ignoredReturnValueError(tok, tok->next()->astOperand1()->expressionString());
+                else if (mSettings->severity.isEnabled(Severity::style) &&
+                         retvalTy == Library::UseRetValType::ERROR_CODE)
+                    ignoredReturnErrorCode(tok, tok->next()->astOperand1()->expressionString());
             }
         }
     }
@@ -226,17 +299,155 @@ void CheckFunctions::checkIgnoredReturnValue()
 void CheckFunctions::ignoredReturnValueError(const Token* tok, const std::string& function)
 {
     reportError(tok, Severity::warning, "ignoredReturnValue",
-                "$symbol:" + function + "\nReturn value of function $symbol() is not used.", CWE252, false);
+                "$symbol:" + function + "\nReturn value of function $symbol() is not used.", CWE252, Certainty::normal);
 }
 
+void CheckFunctions::ignoredReturnErrorCode(const Token* tok, const std::string& function)
+{
+    reportError(tok, Severity::style, "ignoredReturnErrorCode",
+                "$symbol:" + function + "\nError code from the return value of function $symbol() is not used.", CWE252, Certainty::normal);
+}
 
+//---------------------------------------------------------------------------
+// Check for ignored return values.
+//---------------------------------------------------------------------------
+static const Token *checkMissingReturnScope(const Token *tok, const Library &library);
+
+void CheckFunctions::checkMissingReturn()
+{
+    logChecker("CheckFunctions::checkMissingReturn");
+    const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
+    for (const Scope *scope : symbolDatabase->functionScopes) {
+        const Function *function = scope->function;
+        if (!function || !function->hasBody())
+            continue;
+        if (function->name() == "main" && !(mTokenizer->isC() && mSettings->standards.c < Standards::C99))
+            continue;
+        if (function->type != FunctionType::eFunction && function->type != FunctionType::eOperatorEqual)
+            continue;
+        if (Token::Match(function->retDef, "%name% (") && function->retDef->isUpperCaseName())
+            continue;
+        if (Function::returnsVoid(function, true))
+            continue;
+        const Token *errorToken = checkMissingReturnScope(scope->bodyEnd, mSettings->library);
+        if (errorToken)
+            missingReturnError(errorToken);
+    }
+}
+
+static bool isForwardJump(const Token *gotoToken)
+{
+    if (!Token::Match(gotoToken, "goto %name% ;"))
+        return false;
+    for (const Token *prev = gotoToken; gotoToken; gotoToken = gotoToken->previous()) {
+        if (Token::Match(prev, "%name% :") && prev->str() == gotoToken->strAt(1))
+            return true;
+        if (prev->str() == "{" && prev->scope()->type == ScopeType::eFunction)
+            return false;
+    }
+    return false;
+}
+
+static const Token *checkMissingReturnScope(const Token *tok, const Library &library)
+{
+    const Token *lastStatement = nullptr;
+    while ((tok = tok->previous()) != nullptr) {
+        if (tok->str() == ")")
+            tok = tok->link();
+        if (tok->str() == "{")
+            return lastStatement ? lastStatement : tok->next();
+        if (tok->str() == "}") {
+            for (const Token *prev = tok->link()->previous(); prev && prev->scope() == tok->scope() && !Token::Match(prev, "[;{}]"); prev = prev->previous()) {
+                if (prev->isKeyword() && Token::Match(prev, "return|throw"))
+                    return nullptr;
+                if (prev->str() == "goto" && !isForwardJump(prev))
+                    return nullptr;
+            }
+            if (tok->scope()->type == ScopeType::eSwitch) {
+                bool reachable = false;
+                for (const Token *switchToken = tok->link()->next(); switchToken != tok; switchToken = switchToken->next()) {
+                    if (reachable && Token::simpleMatch(switchToken, "break ;")) {
+                        if (Token::simpleMatch(switchToken->previous(), "}") && !checkMissingReturnScope(switchToken->previous(), library))
+                            reachable = false;
+                        else
+                            return switchToken;
+                    }
+                    if (switchToken->isKeyword() && Token::Match(switchToken, "return|throw"))
+                        reachable = false;
+                    if (Token::Match(switchToken, "%name% (") && library.isnoreturn(switchToken))
+                        reachable = false;
+                    if (Token::Match(switchToken, "case|default"))
+                        reachable = true;
+                    else if (switchToken->str() == "{" && (switchToken->scope()->isLoopScope() || switchToken->scope()->type == ScopeType::eSwitch))
+                        switchToken = switchToken->link();
+                }
+                if (!isExhaustiveSwitch(tok->link()))
+                    return tok->link();
+            } else if (tok->scope()->type == ScopeType::eIf) {
+                const Token *condition = tok->scope()->classDef->next()->astOperand2();
+                if (condition && condition->hasKnownIntValue() && condition->getKnownIntValue() == 1)
+                    return checkMissingReturnScope(tok, library);
+                return tok;
+            } else if (tok->scope()->type == ScopeType::eElse) {
+                const Token *errorToken = checkMissingReturnScope(tok, library);
+                if (errorToken)
+                    return errorToken;
+                tok = tok->link();
+                if (Token::simpleMatch(tok->tokAt(-2), "} else {"))
+                    return checkMissingReturnScope(tok->tokAt(-2), library);
+                return tok;
+            } else if (tok->scope()->type == ScopeType::eCatch) {
+                while (tok->str() == "}") {
+                    const Token *errorToken = checkMissingReturnScope(tok, library);
+                    if (errorToken || tok->scope()->type == ScopeType::eTry)
+                        return errorToken;
+                    tok = tok->link();
+                    if (Token::simpleMatch(tok->previous(), ") {") && Token::simpleMatch(tok->linkAt(-1)->tokAt(-2), "} catch ("))
+                        tok = tok->linkAt(-1)->tokAt(-2);
+                    else
+                        break;
+                }
+                // FIXME this should not be reached
+                return nullptr;
+            }
+            // FIXME
+            return nullptr;
+        }
+        if (tok->isKeyword() && Token::Match(tok, "return|throw"))
+            return nullptr;
+        if (tok->str() == "goto" && !isForwardJump(tok))
+            return nullptr;
+        if (Token::Match(tok, "%name% (") && library.isnoreturn(tok)) {
+            return nullptr;
+        }
+        if (Token::Match(tok->previous(), "[;{}] %name% (") && !library.isnotnoreturn(tok)) {
+            return nullptr;
+        }
+        if (Token::Match(tok, "[;{}] %name% :"))
+            return tok;
+        if (Token::Match(tok, "; !!}") && !lastStatement)
+            lastStatement = tok->next();
+    }
+    return nullptr;
+}
+
+void CheckFunctions::missingReturnError(const Token* tok)
+{
+    reportError(tok, Severity::error, "missingReturn",
+                "Found an exit path from function with non-void return type that has missing return statement", CWE758, Certainty::normal);
+}
 //---------------------------------------------------------------------------
 // Detect passing wrong values to <cmath> functions like atan(0, x);
 //---------------------------------------------------------------------------
 void CheckFunctions::checkMathFunctions()
 {
-    const bool styleC99 = mSettings->isEnabled(Settings::STYLE) && mSettings->standards.c != Standards::C89 && mSettings->standards.cpp != Standards::CPP03;
-    const bool printWarnings = mSettings->isEnabled(Settings::WARNING);
+    const bool styleC99 = mSettings->severity.isEnabled(Severity::style) && ((mTokenizer->isC() && mSettings->standards.c != Standards::C89) || (mTokenizer->isCPP() && mSettings->standards.cpp != Standards::CPP03));
+    const bool printWarnings = mSettings->severity.isEnabled(Severity::warning);
+
+    if (!styleC99 && !printWarnings && !mSettings->isPremiumEnabled("wrongmathcall"))
+        return;
+
+    logChecker("CheckFunctions::checkMathFunctions"); // style,warning,c99,c++11
 
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope *scope : symbolDatabase->functionScopes) {
@@ -247,12 +458,12 @@ void CheckFunctions::checkMathFunctions()
                 if (tok->strAt(-1) != "."
                     && Token::Match(tok, "log|logf|logl|log10|log10f|log10l|log2|log2f|log2l ( %num% )")) {
                     const std::string& number = tok->strAt(2);
-                    if ((MathLib::isInt(number) && MathLib::toLongNumber(number) <= 0) ||
+                    if ((MathLib::isInt(number) && MathLib::toBigNumber(number) <= 0) ||
                         (MathLib::isFloat(number) && MathLib::toDoubleNumber(number) <= 0.))
                         mathfunctionCallWarning(tok);
                 } else if (Token::Match(tok, "log1p|log1pf|log1pl ( %num% )")) {
                     const std::string& number = tok->strAt(2);
-                    if ((MathLib::isInt(number) && MathLib::toLongNumber(number) <= -1) ||
+                    if ((MathLib::isInt(number) && MathLib::toBigNumber(number) <= -1) ||
                         (MathLib::isFloat(number) && MathLib::toDoubleNumber(number) <= -1.))
                         mathfunctionCallWarning(tok);
                 }
@@ -264,7 +475,7 @@ void CheckFunctions::checkMathFunctions()
                 // fmod ( x , y) If y is zero, then either a range error will occur or the function will return zero (implementation-defined).
                 else if (Token::Match(tok, "fmod|fmodf|fmodl (")) {
                     const Token* nextArg = tok->tokAt(2)->nextArgument();
-                    if (nextArg && nextArg->isNumber() && MathLib::isNullValue(nextArg->str()))
+                    if (nextArg && MathLib::isNullValue(nextArg->str()))
                         mathfunctionCallWarning(tok, 2);
                 }
                 // pow ( x , y) If x is zero, and y is negative --> division by zero
@@ -293,16 +504,16 @@ void CheckFunctions::mathfunctionCallWarning(const Token *tok, const nonneg int
 {
     if (tok) {
         if (numParam == 1)
-            reportError(tok, Severity::warning, "wrongmathcall", "$symbol:" + tok->str() + "\nPassing value " + tok->strAt(2) + " to $symbol() leads to implementation-defined result.", CWE758, false);
+            reportError(tok, Severity::warning, "wrongmathcall", "$symbol:" + tok->str() + "\nPassing value " + tok->strAt(2) + " to $symbol() leads to implementation-defined result.", CWE758, Certainty::normal);
         else if (numParam == 2)
-            reportError(tok, Severity::warning, "wrongmathcall", "$symbol:" + tok->str() + "\nPassing values " + tok->strAt(2) + " and " + tok->strAt(4) + " to $symbol() leads to implementation-defined result.", CWE758, false);
+            reportError(tok, Severity::warning, "wrongmathcall", "$symbol:" + tok->str() + "\nPassing values " + tok->strAt(2) + " and " + tok->strAt(4) + " to $symbol() leads to implementation-defined result.", CWE758, Certainty::normal);
     } else
-        reportError(tok, Severity::warning, "wrongmathcall", "Passing value '#' to #() leads to implementation-defined result.", CWE758, false);
+        reportError(tok, Severity::warning, "wrongmathcall", "Passing value '#' to #() leads to implementation-defined result.", CWE758, Certainty::normal);
 }
 
 void CheckFunctions::mathfunctionCallWarning(const Token *tok, const std::string& oldexp, const std::string& newexp)
 {
-    reportError(tok, Severity::style, "unpreciseMathCall", "Expression '" + oldexp + "' can be replaced by '" + newexp + "' to avoid loss of precision.", CWE758, false);
+    reportError(tok, Severity::style, "unpreciseMathCall", "Expression '" + oldexp + "' can be replaced by '" + newexp + "' to avoid loss of precision.", CWE758, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -317,9 +528,11 @@ void CheckFunctions::memsetZeroBytes()
 //       <warn knownIntValue="0" severity="warning" msg="..."/>
 //     </arg>
 
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckFunctions::memsetZeroBytes"); // warning
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope *scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
@@ -328,7 +541,7 @@ void CheckFunctions::memsetZeroBytes()
                 if (WRONG_DATA(arguments.size() != 3U, tok))
                     continue;
                 const Token* lastParamTok = arguments[2];
-                if (lastParamTok->str() == "0")
+                if (MathLib::isNullValue(lastParamTok->str()))
                     memsetZeroBytesError(tok);
             }
         }
@@ -341,7 +554,7 @@ void CheckFunctions::memsetZeroBytesError(const Token *tok)
     const std::string verbose(summary + " The second and third arguments might be inverted."
                               " The function memset ( void * ptr, int value, size_t num ) sets the"
                               " first num bytes of the block of memory pointed by ptr to the specified value.");
-    reportError(tok, Severity::warning, "memsetZeroBytes", summary + "\n" + verbose, CWE687, false);
+    reportError(tok, Severity::warning, "memsetZeroBytes", summary + "\n" + verbose, CWE687, Certainty::normal);
 }
 
 void CheckFunctions::memsetInvalid2ndParam()
@@ -354,11 +567,13 @@ void CheckFunctions::memsetInvalid2ndParam()
 //       <warn possibleIntValue=":-129,256:" severity="warning" msg="..."/>
 //     </arg>
 
-    const bool printPortability = mSettings->isEnabled(Settings::PORTABILITY);
-    const bool printWarning = mSettings->isEnabled(Settings::WARNING);
+    const bool printPortability = mSettings->severity.isEnabled(Severity::portability);
+    const bool printWarning = mSettings->severity.isEnabled(Severity::warning);
     if (!printWarning && !printPortability)
         return;
 
+    logChecker("CheckFunctions::memsetInvalid2ndParam"); // warning,portability
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope *scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok && (tok != scope->bodyEnd); tok = tok->next()) {
@@ -380,9 +595,9 @@ void CheckFunctions::memsetInvalid2ndParam()
             }
 
             if (printWarning && secondParamTok->isNumber()) { // Check if the second parameter is a literal and is out of range
-                const long long int value = MathLib::toLongNumber(secondParamTok->str());
-                const long long sCharMin = mSettings->signedCharMin();
-                const long long uCharMax = mSettings->unsignedCharMax();
+                const MathLib::bigint value = MathLib::toBigNumber(secondParamTok);
+                const long long sCharMin = mSettings->platform.signedCharMin();
+                const long long uCharMax = mSettings->platform.unsignedCharMax();
                 if (value < sCharMin || value > uCharMax)
                     memsetValueOutOfRangeError(secondParamTok, secondParamTok->str());
             }
@@ -396,14 +611,14 @@ void CheckFunctions::memsetFloatError(const Token *tok, const std::string &var_v
                               "' is a float, its representation is implementation defined.");
     const std::string verbose(message + " memset() is used to set each byte of a block of memory to a specific value and"
                               " the actual representation of a floating-point value is implementation defined.");
-    reportError(tok, Severity::portability, "memsetFloat", message + "\n" + verbose, CWE688, false);
+    reportError(tok, Severity::portability, "memsetFloat", message + "\n" + verbose, CWE688, Certainty::normal);
 }
 
 void CheckFunctions::memsetValueOutOfRangeError(const Token *tok, const std::string &value)
 {
     const std::string message("The 2nd memset() argument '" + value + "' doesn't fit into an 'unsigned char'.");
     const std::string verbose(message + " The 2nd parameter is passed as an 'int', but the function fills the block of memory using the 'unsigned char' conversion of this value.");
-    reportError(tok, Severity::warning, "memsetValueOutOfRange", message + "\n" + verbose, CWE686, false);
+    reportError(tok, Severity::warning, "memsetValueOutOfRange", message + "\n" + verbose, CWE686, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -412,35 +627,70 @@ void CheckFunctions::memsetValueOutOfRangeError(const Token *tok, const std::str
 
 void CheckFunctions::checkLibraryMatchFunctions()
 {
-    if (!mSettings->checkLibrary || !mSettings->isEnabled(Settings::INFORMATION))
+    if (!mSettings->checkLibrary)
         return;
 
-    bool New = false;
+    bool insideNew = false;
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
         if (!tok->scope() || !tok->scope()->isExecutable())
             continue;
 
+        // skip uninstantiated templates
+        if (tok == tok->scope()->bodyStart && tok->scope()->function && tok->scope()->function->templateDef) {
+            tok = tok->link();
+            continue;
+        }
+
         if (tok->str() == "new")
-            New = true;
+            insideNew = true;
         else if (tok->str() == ";")
-            New = false;
-        else if (New)
+            insideNew = false;
+        else if (insideNew)
             continue;
 
-        if (!Token::Match(tok, "%name% (") || Token::Match(tok, "asm|sizeof|catch"))
+        if (tok->isKeyword() || !Token::Match(tok, "%name% ("))
             continue;
 
-        if (tok->varId() != 0 || tok->type() || tok->isStandardType() || tok->isControlFlowKeyword())
+        if (tok->varId() != 0 || tok->type() || tok->isStandardType())
             continue;
 
         if (tok->linkAt(1)->strAt(1) == "(")
             continue;
 
+        if (tok->function())
+            continue;
+
+        if (Token::simpleMatch(tok->astTop(), "throw"))
+            continue;
+
+        if (Token::simpleMatch(tok->astParent(), ".")) {
+            const Token* contTok = tok->astParent()->astOperand1();
+            if (astContainerAction(contTok, mSettings->library) != Library::Container::Action::NO_ACTION)
+                continue;
+            if (astContainerYield(contTok, mSettings->library) != Library::Container::Yield::NO_YIELD)
+                continue;
+        }
+
         if (!mSettings->library.isNotLibraryFunction(tok))
             continue;
 
         const std::string &functionName = mSettings->library.getFunctionName(tok);
-        if (functionName.empty() || mSettings->library.functions.find(functionName) != mSettings->library.functions.end())
+        if (functionName.empty())
+            continue;
+
+        if (mSettings->library.functions().find(functionName) != mSettings->library.functions().end())
+            continue;
+
+        if (mSettings->library.podtype(tok->expressionString()))
+            continue;
+
+        if (mSettings->library.getTypeCheck("unusedvar", functionName) != Library::TypeCheck::def)
+            continue;
+
+        const Token* start = tok;
+        while (Token::Match(start->tokAt(-2), "%name% ::") && !start->tokAt(-2)->isKeyword())
+            start = start->tokAt(-2);
+        if (mSettings->library.detectContainerOrIterator(start))
             continue;
 
         reportError(tok,
@@ -449,3 +699,199 @@ void CheckFunctions::checkLibraryMatchFunctions()
                     "--check-library: There is no matching configuration for function " + functionName + "()");
     }
 }
+
+// Check for problems to compiler apply (Named) Return Value Optimization for local variable
+// Technically we have different guarantees between standard versions
+// details: https://en.cppreference.com/w/cpp/language/copy_elision
+void CheckFunctions::returnLocalStdMove()
+{
+    if (!mTokenizer->isCPP() || mSettings->standards.cpp < Standards::CPP11)
+        return;
+
+    if (!mSettings->severity.isEnabled(Severity::performance))
+        return;
+
+    logChecker("CheckFunctions::returnLocalStdMove"); // performance,c++11
+
+    const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
+    for (const Scope *scope : symbolDatabase->functionScopes) {
+        // Expect return by-value
+        if (Function::returnsReference(scope->function, /*unknown*/ true, /*includeRValueRef*/ true))
+            continue;
+        const auto rets = Function::findReturns(scope->function);
+        for (const Token* ret : rets) {
+            if (!Token::simpleMatch(ret->tokAt(-3), "std :: move ("))
+                continue;
+            const Token* retval = ret->astOperand2();
+            // NRVO
+            if (retval->variable() && retval->variable()->isLocal() && !retval->variable()->isVolatile())
+                copyElisionError(retval);
+            // RVO
+            if (Token::Match(retval, "(|{") && !retval->isCast() && !(retval->valueType() && retval->valueType()->reference != Reference::None))
+                copyElisionError(retval);
+        }
+    }
+}
+
+void CheckFunctions::copyElisionError(const Token *tok)
+{
+    reportError(tok,
+                Severity::performance,
+                "returnStdMoveLocal",
+                "Using std::move for returning object by-value from function will affect copy elision optimization."
+                " More: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rf-return-move-local");
+}
+
+void CheckFunctions::useStandardLibrary()
+{
+    if (!mSettings->severity.isEnabled(Severity::style))
+        return;
+
+    logChecker("CheckFunctions::useStandardLibrary"); // style
+
+    for (const Scope& scope: mTokenizer->getSymbolDatabase()->scopeList) {
+        if (scope.type != ScopeType::eFor)
+            continue;
+
+        const Token *forToken = scope.classDef;
+        // for ( initToken ; condToken ; stepToken )
+        const Token* initToken = getInitTok(forToken);
+        if (!initToken)
+            continue;
+        const Token* condToken = getCondTok(forToken);
+        if (!condToken)
+            continue;
+        const Token* stepToken = getStepTok(forToken);
+        if (!stepToken)
+            continue;
+
+        // 1. we expect that idx variable will be initialized with 0
+        const Token* idxToken = initToken->astOperand1();
+        const Token* initVal = initToken->astOperand2();
+        if (!idxToken || !initVal || !initVal->hasKnownIntValue() || initVal->getKnownIntValue() != 0)
+            continue;
+        const auto idxVarId = idxToken->varId();
+        if (0 == idxVarId)
+            continue;
+
+        // 2. we expect that idx will be less of some variable
+        if (!condToken->isComparisonOp())
+            continue;
+
+        const auto& secondOp = condToken->str();
+        const bool isLess = "<" == secondOp &&
+                            isConstExpression(condToken->astOperand2(), mSettings->library) &&
+                            condToken->astOperand1()->varId() == idxVarId;
+        const bool isMore = ">" == secondOp &&
+                            isConstExpression(condToken->astOperand1(), mSettings->library) &&
+                            condToken->astOperand2()->varId() == idxVarId;
+
+        if (!(isLess || isMore))
+            continue;
+
+        // 3. we expect idx incrementing by 1
+        const bool inc = stepToken->str() == "++" && stepToken->astOperand1() && stepToken->astOperand1()->varId() == idxVarId;
+        const bool plusOne = stepToken->isBinaryOp() && stepToken->str() == "+=" &&
+                             stepToken->astOperand1()->varId() == idxVarId &&
+                             stepToken->astOperand2()->str() == "1";
+        if (!inc && !plusOne)
+            continue;
+
+        // technically using void* here is not correct but some compilers could allow it
+
+        const Token *tok = scope.bodyStart;
+        const std::string memcpyName = tok->isCpp() ? "std::memcpy" : "memcpy";
+        // (reinterpret_cast<uint8_t*>(dest))[i] = (reinterpret_cast<const uint8_t*>(src))[i];
+        if (Token::Match(tok, "{ (| reinterpret_cast < uint8_t|int8_t|char|void * > ( %var% ) )| [ %varid% ] = "
+                         "(| reinterpret_cast < const| uint8_t|int8_t|char|void * > ( %var% ) )| [ %varid% ] ; }", idxVarId)) {
+            useStandardLibraryError(tok->next(), memcpyName);
+            continue;
+        }
+
+        // ((char*)dst)[i] = ((const char*)src)[i];
+        if (Token::Match(tok, "{ ( ( uint8_t|int8_t|char|void * ) (| %var% ) )| [ %varid% ] = "
+                         "( ( const| uint8_t|int8_t|char|void * ) (| %var% ) )| [ %varid% ] ; }", idxVarId)) {
+            useStandardLibraryError(tok->next(), memcpyName);
+            continue;
+        }
+
+
+        const static std::string memsetName = tok->isCpp() ? "std::memset" : "memset";
+        // ((char*)dst)[i] = 0;
+        if (Token::Match(tok, "{ ( ( uint8_t|int8_t|char|void * ) (| %var% ) )| [ %varid% ] = %char%|%num% ; }", idxVarId)) {
+            useStandardLibraryError(tok->next(), memsetName);
+            continue;
+        }
+
+        // ((char*)dst)[i] = (const char*)0;
+        if (Token::Match(tok, "{ ( ( uint8_t|int8_t|char|void * ) (| %var% ) )| [ %varid% ] = "
+                         "( const| uint8_t|int8_t|char ) (| %char%|%num% )| ; }", idxVarId)) {
+            useStandardLibraryError(tok->next(), memsetName);
+            continue;
+        }
+
+        // (reinterpret_cast<uint8_t*>(dest))[i] = static_cast<const uint8_t>(0);
+        if (Token::Match(tok, "{ (| reinterpret_cast < uint8_t|int8_t|char|void * > ( %var% ) )| [ %varid% ] = "
+                         "(| static_cast < const| uint8_t|int8_t|char > ( %char%|%num% ) )| ; }", idxVarId)) {
+            useStandardLibraryError(tok->next(), memsetName);
+            continue;
+        }
+
+        // (reinterpret_cast<int8_t*>(dest))[i] = 0;
+        if (Token::Match(tok, "{ (| reinterpret_cast < uint8_t|int8_t|char|void * > ( %var% ) )| [ %varid% ] = "
+                         "%char%|%num% ; }", idxVarId)) {
+            useStandardLibraryError(tok->next(), memsetName);
+            continue;
+        }
+    }
+}
+
+void CheckFunctions::useStandardLibraryError(const Token *tok, const std::string& expected)
+{
+    reportError(tok, Severity::style,
+                "useStandardLibrary",
+                "Consider using " + expected + " instead of loop.");
+}
+
+void CheckFunctions::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    CheckFunctions checkFunctions(&tokenizer, &tokenizer.getSettings(), errorLogger);
+
+    checkFunctions.checkIgnoredReturnValue();
+    checkFunctions.checkMissingReturn();  // Missing "return" in exit path
+
+    // --check-library : functions with nonmatching configuration
+    checkFunctions.checkLibraryMatchFunctions();
+
+    checkFunctions.checkProhibitedFunctions();
+    checkFunctions.invalidFunctionUsage();
+    checkFunctions.checkMathFunctions();
+    checkFunctions.memsetZeroBytes();
+    checkFunctions.memsetInvalid2ndParam();
+    checkFunctions.returnLocalStdMove();
+    checkFunctions.useStandardLibrary();
+}
+
+void CheckFunctions::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const
+{
+    CheckFunctions c(nullptr, settings, errorLogger);
+
+    for (auto i = settings->library.functionwarn().cbegin(); i != settings->library.functionwarn().cend(); ++i) {
+        c.reportError(nullptr, Severity::style, i->first+"Called", i->second.message);
+    }
+
+    c.invalidFunctionArgError(nullptr, "func_name", 1, nullptr,"1:4");
+    c.invalidFunctionArgBoolError(nullptr, "func_name", 1);
+    c.invalidFunctionArgStrError(nullptr, "func_name", 1);
+    c.ignoredReturnValueError(nullptr, "malloc");
+    c.ignoredReturnErrorCode(nullptr, "func_name");
+    c.mathfunctionCallWarning(nullptr);
+    c.mathfunctionCallWarning(nullptr, "1 - erf(x)", "erfc(x)");
+    c.memsetZeroBytesError(nullptr);
+    c.memsetFloatError(nullptr,  "varname");
+    c.memsetValueOutOfRangeError(nullptr,  "varname");
+    c.missingReturnError(nullptr);
+    c.copyElisionError(nullptr);
+    c.useStandardLibraryError(nullptr, "memcpy");
+    // TODO: allocaCalled, <funcname>Called
+}
diff --git a/lib/checkfunctions.h b/lib/checkfunctions.h
index 80f709e0258..f5954d14043 100644
--- a/lib/checkfunctions.h
+++ b/lib/checkfunctions.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,16 +24,14 @@
 
 #include "check.h"
 #include "config.h"
-#include "errorlogger.h"
-#include "library.h"
-#include "settings.h"
 
-#include <map>
 #include <string>
-#include <utility>
 
 class Token;
+class ErrorLogger;
 class Tokenizer;
+class Settings;
+
 namespace ValueFlow {
     class Value;
 }  // namespace ValueFlow
@@ -49,42 +47,27 @@ namespace ValueFlow {
 class CPPCHECKLIB CheckFunctions : public Check {
 public:
     /** This constructor is used when registering the CheckFunctions */
-    CheckFunctions() : Check(myName()) {
-    }
+    CheckFunctions() : Check(myName()) {}
 
+private:
     /** This constructor is used when running checks. */
     CheckFunctions(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger) {}
 
     /** @brief Run checks against the normal token list */
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        CheckFunctions checkFunctions(tokenizer, settings, errorLogger);
-
-        // Checks
-        checkFunctions.checkIgnoredReturnValue();
-
-        // --check-library : functions with nonmatching configuration
-        checkFunctions.checkLibraryMatchFunctions();
-
-        checkFunctions.checkProhibitedFunctions();
-        checkFunctions.invalidFunctionUsage();
-        checkFunctions.checkMathFunctions();
-        checkFunctions.memsetZeroBytes();
-        checkFunctions.memsetInvalid2ndParam();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     /** Check for functions that should not be used */
     void checkProhibitedFunctions();
 
     /**
-    * @brief Invalid function usage (invalid input value / overlapping data)
-    *
-    * %Check that given function parameters are valid according to the standard
-    * - wrong radix given for strtol/strtoul
-    * - overlapping data when using sprintf/snprintf
-    * - wrong input value according to library
-    */
+     * @brief Invalid function usage (invalid input value / overlapping data)
+     *
+     * %Check that given function parameters are valid according to the standard
+     * - wrong radix given for strtol/strtoul
+     * - overlapping data when using sprintf/snprintf
+     * - wrong input value according to library
+     */
     void invalidFunctionUsage();
 
     /** @brief %Check for ignored return values. */
@@ -99,50 +82,48 @@ class CPPCHECKLIB CheckFunctions : public Check {
     /** @brief %Check for invalid 2nd parameter of memset() */
     void memsetInvalid2ndParam();
 
+    /** @brief %Check for copy elision by RVO|NRVO */
+    void returnLocalStdMove();
+
+    void useStandardLibrary();
+
     /** @brief --check-library: warn for unconfigured function calls */
     void checkLibraryMatchFunctions();
 
-private:
+    /** @brief %Check for missing "return" */
+    void checkMissingReturn();
+
     void invalidFunctionArgError(const Token *tok, const std::string &functionName, int argnr, const ValueFlow::Value *invalidValue, const std::string &validstr);
     void invalidFunctionArgBoolError(const Token *tok, const std::string &functionName, int argnr);
     void invalidFunctionArgStrError(const Token *tok, const std::string &functionName, nonneg int argnr);
     void ignoredReturnValueError(const Token* tok, const std::string& function);
-    void mathfunctionCallWarning(const Token *tok, const nonneg int numParam = 1);
+    void ignoredReturnErrorCode(const Token* tok, const std::string& function);
+    void mathfunctionCallWarning(const Token *tok, nonneg int numParam = 1);
     void mathfunctionCallWarning(const Token *tok, const std::string& oldexp, const std::string& newexp);
     void memsetZeroBytesError(const Token *tok);
     void memsetFloatError(const Token *tok, const std::string &var_value);
     void memsetValueOutOfRangeError(const Token *tok, const std::string &value);
+    void missingReturnError(const Token *tok);
+    void copyElisionError(const Token *tok);
+    void useStandardLibraryError(const Token *tok, const std::string& expected);
 
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        CheckFunctions c(nullptr, settings, errorLogger);
-
-        for (std::map<std::string, Library::WarnInfo>::const_iterator i = settings->library.functionwarn.cbegin(); i != settings->library.functionwarn.cend(); ++i) {
-            c.reportError(nullptr, Severity::style, i->first+"Called", i->second.message);
-        }
-
-        c.invalidFunctionArgError(nullptr, "func_name", 1, nullptr,"1:4");
-        c.invalidFunctionArgBoolError(nullptr, "func_name", 1);
-        c.invalidFunctionArgStrError(nullptr, "func_name", 1);
-        c.ignoredReturnValueError(nullptr, "malloc");
-        c.mathfunctionCallWarning(nullptr);
-        c.mathfunctionCallWarning(nullptr, "1 - erf(x)", "erfc(x)");
-        c.memsetZeroBytesError(nullptr);
-        c.memsetFloatError(nullptr,  "varname");
-        c.memsetValueOutOfRangeError(nullptr,  "varname");
-    }
+    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const override;
 
     static std::string myName() {
         return "Check function usage";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Check function usage:\n"
+               "- missing 'return' in non-void function\n"
                "- return value of certain functions not used\n"
                "- invalid input values for functions\n"
                "- Warn if a function is called whose usage is discouraged\n"
                "- memset() third argument is zero\n"
                "- memset() with a value out of range as the 2nd parameter\n"
-               "- memset() with a float as the 2nd parameter\n";
+               "- memset() with a float as the 2nd parameter\n"
+               "- copy elision optimization for returning value affected by std::move\n"
+               "- use memcpy()/memset() instead of for loop\n";
     }
 };
 /// @}
diff --git a/lib/checkinternal.cpp b/lib/checkinternal.cpp
index e7848c35110..f289044b102 100644
--- a/lib/checkinternal.cpp
+++ b/lib/checkinternal.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,11 +21,15 @@
 #include "checkinternal.h"
 
 #include "astutils.h"
+#include "errortypes.h"
+#include "settings.h"
 #include "symboldatabase.h"
-#include "utils.h"
+#include "token.h"
+#include "tokenize.h"
 
-#include <set>
 #include <cstring>
+#include <set>
+#include <vector>
 
 // Register this check class (by creating a static instance of it).
 // Disabled in release builds
@@ -36,8 +40,7 @@ namespace {
 void CheckInternal::checkTokenMatchPatterns()
 {
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
-    for (std::size_t i = 0; i < symbolDatabase->functionScopes.size(); ++i) {
-        const Scope * scope = symbolDatabase->functionScopes[i];
+    for (const Scope *scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
             if (!Token::simpleMatch(tok, "Token :: Match (") && !Token::simpleMatch(tok, "Token :: findmatch ("))
                 continue;
@@ -61,7 +64,7 @@ void CheckInternal::checkTokenMatchPatterns()
             // Check for signs of complex patterns
             if (pattern.find_first_of("[|") != std::string::npos)
                 continue;
-            else if (pattern.find("!!") != std::string::npos)
+            if (pattern.find("!!") != std::string::npos)
                 continue;
 
             bool complex = false;
@@ -123,14 +126,13 @@ void CheckInternal::checkRedundantTokCheck()
 void CheckInternal::checkRedundantTokCheckError(const Token* tok)
 {
     reportError(tok, Severity::style, "redundantTokCheck",
-                "Unnecessary check of \"" + (tok? tok->expressionString(): emptyString) + "\", match-function already checks if it is null.");
+                "Unnecessary check of \"" + (tok? tok->expressionString(): "") + "\", match-function already checks if it is null.");
 }
 
 void CheckInternal::checkTokenSimpleMatchPatterns()
 {
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
-    for (std::size_t i = 0; i < symbolDatabase->functionScopes.size(); ++i) {
-        const Scope * scope = symbolDatabase->functionScopes[i];
+    for (const Scope* scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
             if (!Token::simpleMatch(tok, "Token :: simpleMatch (") && !Token::simpleMatch(tok, "Token :: findsimplematch ("))
                 continue;
@@ -150,9 +152,7 @@ void CheckInternal::checkTokenSimpleMatchPatterns()
 
             // Check for [xyz] usage - but exclude standalone square brackets
             unsigned int char_count = 0;
-            for (std::string::size_type pos = 0; pos < pattern.size(); ++pos) {
-                char c = pattern[pos];
-
+            for (const char c : pattern) {
                 if (c == ' ') {
                     char_count = 0;
                 } else if (c == ']') {
@@ -167,9 +167,7 @@ void CheckInternal::checkTokenSimpleMatchPatterns()
 
             // Check | usage: Count characters before the symbol
             char_count = 0;
-            for (std::string::size_type pos = 0; pos < pattern.size(); ++pos) {
-                const char c = pattern[pos];
-
+            for (const char c : pattern) {
                 if (c == ' ') {
                     char_count = 0;
                 } else if (c == '|') {
@@ -218,8 +216,7 @@ namespace {
 void CheckInternal::checkMissingPercentCharacter()
 {
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
-    for (std::size_t i = 0; i < symbolDatabase->functionScopes.size(); ++i) {
-        const Scope * scope = symbolDatabase->functionScopes[i];
+    for (const Scope* scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
             if (!Token::simpleMatch(tok, "Token :: Match (") && !Token::simpleMatch(tok, "Token :: findmatch ("))
                 continue;
@@ -233,9 +230,8 @@ void CheckInternal::checkMissingPercentCharacter()
 
             const std::string pattern = patternTok->strValue();
 
-            std::set<std::string>::const_iterator knownPattern, knownPatternsEnd = knownPatterns.end();
-            for (knownPattern = knownPatterns.begin(); knownPattern != knownPatternsEnd; ++knownPattern) {
-                const std::string brokenPattern = (*knownPattern).substr(0, (*knownPattern).size() - 1);
+            for (auto knownPattern = knownPatterns.cbegin(); knownPattern != knownPatterns.cend(); ++knownPattern) {
+                const std::string brokenPattern = knownPattern->substr(0, knownPattern->size() - 1);
 
                 std::string::size_type pos = 0;
                 while ((pos = pattern.find(brokenPattern, pos)) != std::string::npos) {
@@ -261,8 +257,7 @@ void CheckInternal::checkMissingPercentCharacter()
 void CheckInternal::checkUnknownPattern()
 {
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
-    for (std::size_t i = 0; i < symbolDatabase->functionScopes.size(); ++i) {
-        const Scope * scope = symbolDatabase->functionScopes[i];
+    for (const Scope* scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
             if (!Token::simpleMatch(tok, "Token :: Match (") && !Token::simpleMatch(tok, "Token :: findmatch ("))
                 continue;
@@ -296,14 +291,13 @@ void CheckInternal::checkUnknownPattern()
 void CheckInternal::checkRedundantNextPrevious()
 {
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
-    for (std::size_t i = 0; i < symbolDatabase->functionScopes.size(); ++i) {
-        const Scope * scope = symbolDatabase->functionScopes[i];
+    for (const Scope* scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
             if (tok->str() != ".")
                 continue;
             tok = tok->next();
 
-            if (Token::Match(tok, "previous ( ) . next|tokAt|strAt|linkAt (") || Token::Match(tok, "next ( ) . previous|tokAt|strAt|linkAt (") ||
+            if (Token::Match(tok, "previous ( ) . previous|next|tokAt|str|strAt|link|linkAt (") || Token::Match(tok, "next ( ) . previous|next|tokAt|str|strAt|link|linkAt (") ||
                 (Token::simpleMatch(tok, "tokAt (") && Token::Match(tok->linkAt(1), ") . previous|next|tokAt|strAt|linkAt|str|link ("))) {
                 const std::string& func1 = tok->str();
                 const std::string& func2 = tok->linkAt(1)->strAt(2);
@@ -311,14 +305,6 @@ void CheckInternal::checkRedundantNextPrevious()
                 if ((func2 == "previous" || func2 == "next" || func2 == "str" || func2 == "link") && tok->linkAt(1)->strAt(4) != ")")
                     continue;
 
-                redundantNextPreviousError(tok, func1, func2);
-            } else if (Token::Match(tok, "next|previous ( ) . next|previous ( ) . next|previous|linkAt|strAt|link|str (")) {
-                const std::string& func1 = tok->str();
-                const std::string& func2 = tok->strAt(8);
-
-                if ((func2 == "previous" || func2 == "next" || func2 == "str" || func2 == "link") && tok->strAt(10) != ")")
-                    continue;
-
                 redundantNextPreviousError(tok, func1, func2);
             }
         }
@@ -328,8 +314,7 @@ void CheckInternal::checkRedundantNextPrevious()
 void CheckInternal::checkExtraWhitespace()
 {
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
-    for (std::size_t i = 0; i < symbolDatabase->functionScopes.size(); ++i) {
-        const Scope * scope = symbolDatabase->functionScopes[i];
+    for (const Scope* scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
             if (!Token::Match(tok, "Token :: simpleMatch|findsimplematch|Match|findmatch ("))
                 continue;
@@ -342,7 +327,7 @@ void CheckInternal::checkExtraWhitespace()
                 continue;
 
             const std::string pattern = patternTok->strValue();
-            if (!pattern.empty() && (pattern[0] == ' ' || *pattern.rbegin() == ' '))
+            if (!pattern.empty() && (pattern[0] == ' ' || *pattern.crbegin() == ' '))
                 extraWhitespaceError(tok, pattern, funcname);
 
             // two whitespaces or more
@@ -352,45 +337,25 @@ void CheckInternal::checkExtraWhitespace()
     }
 }
 
-void CheckInternal::checkStlUsage()
-{
-    const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
-    for (const Scope *scope : symbolDatabase->functionScopes) {
-        for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
-            if (Token::simpleMatch(tok, ". emplace ("))
-                reportError(tok, Severity::error, "internalStlUsage", "The 'emplace' function shall be avoided for now. It is not available e.g. in Slackware 14.0. 'emplace_back' is fine.");
-            //if (Token::simpleMatch(tok, ". back ( )") && tok->astOperand1() && tok->astOperand1()->valueType() && tok->astOperand1()->valueType()->container && Token::simpleMatch(tok->astOperand1()->valueType()->container, "std :: string"))
-            //  reportError(tok, Severity::error, "internalStlUsage", "The 'std::string::back()' function shall be avoided for now.");
-        }
-    }
-}
-
-void CheckInternal::multiComparePatternError(const Token* tok, const std::string& pattern, const std::string &funcname)
-{
-    reportError(tok, Severity::error, "multiComparePatternError",
-                "Bad multicompare pattern (a %cmd% must be first unless it is %or%,%op%,%cop%,%name%,%oror%) inside Token::" + funcname + "() call: \"" + pattern + "\""
-               );
-}
-
 void CheckInternal::simplePatternError(const Token* tok, const std::string& pattern, const std::string &funcname)
 {
     reportError(tok, Severity::warning, "simplePatternError",
                 "Found simple pattern inside Token::" + funcname + "() call: \"" + pattern + "\""
-               );
+                );
 }
 
 void CheckInternal::complexPatternError(const Token* tok, const std::string& pattern, const std::string &funcname)
 {
     reportError(tok, Severity::error, "complexPatternError",
                 "Found complex pattern inside Token::" + funcname + "() call: \"" + pattern + "\""
-               );
+                );
 }
 
 void CheckInternal::missingPercentCharacterError(const Token* tok, const std::string& pattern, const std::string& funcname)
 {
     reportError(tok, Severity::error, "missingPercentCharacter",
                 "Missing percent end character in Token::" + funcname + "() pattern: \"" + pattern + "\""
-               );
+                );
 }
 
 void CheckInternal::unknownPatternError(const Token* tok, const std::string& pattern)
@@ -415,7 +380,36 @@ void CheckInternal::extraWhitespaceError(const Token* tok, const std::string& pa
 {
     reportError(tok, Severity::warning, "extraWhitespaceError",
                 "Found extra whitespace inside Token::" + funcname + "() call: \"" + pattern + "\""
-               );
+                );
+}
+
+void CheckInternal::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    if (!tokenizer.getSettings().checks.isEnabled(Checks::internalCheck))
+        return;
+
+    CheckInternal checkInternal(&tokenizer, &tokenizer.getSettings(), errorLogger);
+
+    checkInternal.checkTokenMatchPatterns();
+    checkInternal.checkTokenSimpleMatchPatterns();
+    checkInternal.checkMissingPercentCharacter();
+    checkInternal.checkUnknownPattern();
+    checkInternal.checkRedundantNextPrevious();
+    checkInternal.checkExtraWhitespace();
+    checkInternal.checkRedundantTokCheck();
+}
+
+void CheckInternal::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const
+{
+    CheckInternal c(nullptr, settings, errorLogger);
+    c.simplePatternError(nullptr, "class {", "Match");
+    c.complexPatternError(nullptr, "%type% ( )", "Match");
+    c.missingPercentCharacterError(nullptr, "%num", "Match");
+    c.unknownPatternError(nullptr, "%typ");
+    c.redundantNextPreviousError(nullptr, "previous", "next");
+    c.orInComplexPattern(nullptr, "||", "Match");
+    c.extraWhitespaceError(nullptr, "%str% ", "Match");
+    c.checkRedundantTokCheckError(nullptr);
 }
 
 #endif // #ifdef CHECK_INTERNAL
diff --git a/lib/checkinternal.h b/lib/checkinternal.h
index 28d0800bc89..1fc97bcb247 100644
--- a/lib/checkinternal.h
+++ b/lib/checkinternal.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -27,6 +27,11 @@
 
 #include <string>
 
+class ErrorLogger;
+class Token;
+class Tokenizer;
+class Settings;
+
 /// @addtogroup Checks
 /// @{
 
@@ -35,29 +40,14 @@
 class CPPCHECKLIB CheckInternal : public Check {
 public:
     /** This constructor is used when registering the CheckClass */
-    CheckInternal() : Check(myName()) {
-    }
+    CheckInternal() : Check(myName()) {}
 
+private:
     /** This constructor is used when running checks. */
     CheckInternal(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
-
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        if (!settings->isEnabled(Settings::INTERNAL))
-            return;
+        : Check(myName(), tokenizer, settings, errorLogger) {}
 
-        CheckInternal checkInternal(tokenizer, settings, errorLogger);
-
-        checkInternal.checkTokenMatchPatterns();
-        checkInternal.checkTokenSimpleMatchPatterns();
-        checkInternal.checkMissingPercentCharacter();
-        checkInternal.checkUnknownPattern();
-        checkInternal.checkRedundantNextPrevious();
-        checkInternal.checkExtraWhitespace();
-        checkInternal.checkRedundantTokCheck();
-        checkInternal.checkStlUsage();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     /** @brief %Check if a simple pattern is used inside Token::Match or Token::findmatch */
     void checkTokenMatchPatterns();
@@ -80,10 +70,6 @@ class CPPCHECKLIB CheckInternal : public Check {
     /** @brief %Check if there is a redundant check for none-nullness of parameter before Match functions, such as (tok && Token::Match(tok, "foo")) */
     void checkRedundantTokCheck();
 
-    /** @brief Try to avoid some new functions that are not fully supported in Linux */
-    void checkStlUsage();
-private:
-    void multiComparePatternError(const Token *tok, const std::string &pattern, const std::string &funcname);
     void simplePatternError(const Token *tok, const std::string &pattern, const std::string &funcname);
     void complexPatternError(const Token *tok, const std::string &pattern, const std::string &funcname);
     void missingPercentCharacterError(const Token *tok, const std::string &pattern, const std::string &funcname);
@@ -93,24 +79,13 @@ class CPPCHECKLIB CheckInternal : public Check {
     void extraWhitespaceError(const Token *tok, const std::string &pattern, const std::string &funcname);
     void checkRedundantTokCheckError(const Token *tok);
 
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        CheckInternal c(nullptr, settings, errorLogger);
-        c.multiComparePatternError(nullptr, ";|%type%", "Match");
-        c.simplePatternError(nullptr, "class {", "Match");
-        c.complexPatternError(nullptr, "%type% ( )", "Match");
-        c.missingPercentCharacterError(nullptr, "%num", "Match");
-        c.unknownPatternError(nullptr, "%typ");
-        c.redundantNextPreviousError(nullptr, "previous", "next");
-        c.orInComplexPattern(nullptr, "||", "Match");
-        c.extraWhitespaceError(nullptr, "%str% ", "Match");
-        c.checkRedundantTokCheckError(nullptr);
-    }
+    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const override;
 
     static std::string myName() {
         return "cppcheck internal API usage";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         // Don't include these checks on the WIKI where people can read what
         // checks there are. These checks are not intended for users.
         return "";
diff --git a/lib/checkio.cpp b/lib/checkio.cpp
index dbbe99e08ea..ee1b4e36c73 100644
--- a/lib/checkio.cpp
+++ b/lib/checkio.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,20 +19,27 @@
 //---------------------------------------------------------------------------
 #include "checkio.h"
 
+#include "astutils.h"
+#include "errortypes.h"
 #include "library.h"
 #include "mathlib.h"
+#include "platform.h"
 #include "settings.h"
 #include "symboldatabase.h"
 #include "token.h"
 #include "tokenize.h"
 #include "utils.h"
-#include "valueflow.h"
+#include "vfvalue.h"
 
+#include <algorithm>
 #include <cctype>
 #include <cstdlib>
+#include <functional>
 #include <list>
 #include <map>
 #include <set>
+#include <sstream>
+#include <unordered_set>
 #include <utility>
 #include <vector>
 
@@ -61,6 +68,8 @@ void CheckIO::checkCoutCerrMisusage()
     if (mTokenizer->isC())
         return;
 
+    logChecker("CheckIO::checkCoutCerrMisusage"); // c
+
     const SymbolDatabase * const symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token *tok = scope->bodyStart; tok && tok != scope->bodyEnd; tok = tok->next()) {
@@ -78,7 +87,7 @@ void CheckIO::checkCoutCerrMisusage()
 
 void CheckIO::coutCerrMisusageError(const Token* tok, const std::string& streamName)
 {
-    reportError(tok, Severity::error, "coutCerrMisusage", "Invalid usage of output stream: '<< std::" + streamName + "'.", CWE398, false);
+    reportError(tok, Severity::error, "coutCerrMisusage", "Invalid usage of output stream: '<< std::" + streamName + "'.", CWE398, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -87,42 +96,44 @@ void CheckIO::coutCerrMisusageError(const Token* tok, const std::string& streamN
 // fopen("","r"); fwrite(); <- write to read-only file (or vice versa)
 // fclose(); fread(); <- Use closed file
 //---------------------------------------------------------------------------
-enum OpenMode { CLOSED, READ_MODE, WRITE_MODE, RW_MODE, UNKNOWN_OM };
+enum class OpenMode : std::uint8_t { CLOSED, READ_MODE, WRITE_MODE, RW_MODE, UNKNOWN_OM };
 static OpenMode getMode(const std::string& str)
 {
     if (str.find('+', 1) != std::string::npos)
-        return RW_MODE;
-    else if (str.find('w') != std::string::npos || str.find('a') != std::string::npos)
-        return WRITE_MODE;
-    else if (str.find('r') != std::string::npos)
-        return READ_MODE;
-    return UNKNOWN_OM;
+        return OpenMode::RW_MODE;
+    if (str.find('w') != std::string::npos || str.find('a') != std::string::npos)
+        return OpenMode::WRITE_MODE;
+    if (str.find('r') != std::string::npos)
+        return OpenMode::READ_MODE;
+    return OpenMode::UNKNOWN_OM;
 }
 
-struct Filepointer {
-    OpenMode mode;
-    nonneg int mode_indent;
-    enum Operation {NONE, UNIMPORTANT, READ, WRITE, POSITIONING, OPEN, CLOSE, UNKNOWN_OP} lastOperation;
-    nonneg int op_indent;
-    enum AppendMode { UNKNOWN_AM, APPEND, APPEND_EX };
-    AppendMode append_mode;
-    explicit Filepointer(OpenMode mode_ = UNKNOWN_OM)
-        : mode(mode_), mode_indent(0), lastOperation(NONE), op_indent(0), append_mode(UNKNOWN_AM) {
-    }
-};
-
 namespace {
-    const std::set<std::string> whitelist = { "clearerr", "feof", "ferror", "fgetpos", "ftell", "setbuf", "setvbuf", "ungetc", "ungetwc" };
+    struct Filepointer {
+        OpenMode mode;
+        nonneg int mode_indent{};
+        enum class Operation : std::uint8_t {NONE, UNIMPORTANT, READ, WRITE, POSITIONING, OPEN, CLOSE, UNKNOWN_OP} lastOperation = Operation::NONE;
+        nonneg int op_indent{};
+        enum class AppendMode : std::uint8_t { UNKNOWN_AM, APPEND, APPEND_EX };
+        AppendMode append_mode = AppendMode::UNKNOWN_AM;
+        std::string filename;
+        explicit Filepointer(OpenMode mode_ = OpenMode::UNKNOWN_OM)
+            : mode(mode_) {}
+    };
+
+    const std::unordered_set<std::string> whitelist = { "clearerr", "feof", "ferror", "fgetpos", "ftell", "setbuf", "setvbuf", "ungetc", "ungetwc" };
 }
 
 void CheckIO::checkFileUsage()
 {
-    const bool windows = mSettings->isWindowsPlatform();
-    const bool printPortability = mSettings->isEnabled(Settings::PORTABILITY);
-    const bool printWarnings = mSettings->isEnabled(Settings::WARNING);
+    const bool windows = mSettings->platform.isWindows();
+    const bool printPortability = mSettings->severity.isEnabled(Severity::portability);
+    const bool printWarnings = mSettings->severity.isEnabled(Severity::warning);
 
     std::map<int, Filepointer> filepointers;
 
+    logChecker("CheckIO::checkFileUsage");
+
     const SymbolDatabase* symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Variable* var : symbolDatabase->variableList()) {
         if (!var || !var->declarationId() || var->isArray() || !Token::simpleMatch(var->typeStartToken(), "FILE *"))
@@ -130,11 +141,11 @@ void CheckIO::checkFileUsage()
 
         if (var->isLocal()) {
             if (var->nameToken()->strAt(1) == "(") // initialize by calling "ctor"
-                filepointers.insert(std::make_pair(var->declarationId(), Filepointer(UNKNOWN_OM)));
+                filepointers.emplace(var->declarationId(), Filepointer(OpenMode::UNKNOWN_OM));
             else
-                filepointers.insert(std::make_pair(var->declarationId(), Filepointer(CLOSED)));
+                filepointers.emplace(var->declarationId(), Filepointer(OpenMode::CLOSED));
         } else {
-            filepointers.insert(std::make_pair(var->declarationId(), Filepointer(UNKNOWN_OM)));
+            filepointers.emplace(var->declarationId(), Filepointer(OpenMode::UNKNOWN_OM));
             // TODO: If all fopen calls we find open the file in the same type, we can set Filepointer::mode
         }
     }
@@ -142,39 +153,44 @@ void CheckIO::checkFileUsage()
     for (const Scope * scope : symbolDatabase->functionScopes) {
         int indent = 0;
         for (const Token *tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
+            if (Token::Match(tok, "%name% (") && isUnevaluated(tok)) {
+                tok = tok->linkAt(1);
+                continue;
+            }
             if (tok->str() == "{")
                 indent++;
             else if (tok->str() == "}") {
                 indent--;
-                for (std::map<int, Filepointer>::iterator i = filepointers.begin(); i != filepointers.end(); ++i) {
-                    if (indent < i->second.mode_indent) {
-                        i->second.mode_indent = 0;
-                        i->second.mode = UNKNOWN_OM;
+                for (std::pair<const int, Filepointer>& filepointer : filepointers) {
+                    if (indent < filepointer.second.mode_indent) {
+                        filepointer.second.mode_indent = 0;
+                        filepointer.second.mode = OpenMode::UNKNOWN_OM;
                     }
-                    if (indent < i->second.op_indent) {
-                        i->second.op_indent = 0;
-                        i->second.lastOperation = Filepointer::UNKNOWN_OP;
+                    if (indent < filepointer.second.op_indent) {
+                        filepointer.second.op_indent = 0;
+                        filepointer.second.lastOperation = Filepointer::Operation::UNKNOWN_OP;
                     }
                 }
             } else if (tok->str() == "return" || tok->str() == "continue" || tok->str() == "break" || mSettings->library.isnoreturn(tok)) { // Reset upon return, continue or break
-                for (std::map<int, Filepointer>::iterator i = filepointers.begin(); i != filepointers.end(); ++i) {
-                    i->second.mode_indent = 0;
-                    i->second.mode = UNKNOWN_OM;
-                    i->second.op_indent = 0;
-                    i->second.lastOperation = Filepointer::UNKNOWN_OP;
+                for (std::pair<const int, Filepointer>& filepointer : filepointers) {
+                    filepointer.second.mode_indent = 0;
+                    filepointer.second.mode = OpenMode::UNKNOWN_OM;
+                    filepointer.second.op_indent = 0;
+                    filepointer.second.lastOperation = Filepointer::Operation::UNKNOWN_OP;
                 }
             } else if (Token::Match(tok, "%var% =") &&
                        (tok->strAt(2) != "fopen" && tok->strAt(2) != "freopen" && tok->strAt(2) != "tmpfile" &&
                         (windows ? (tok->str() != "_wfopen" && tok->str() != "_wfreopen") : true))) {
-                std::map<int, Filepointer>::iterator i = filepointers.find(tok->varId());
+                const auto i = filepointers.find(tok->varId());
                 if (i != filepointers.end()) {
-                    i->second.mode = UNKNOWN_OM;
-                    i->second.lastOperation = Filepointer::UNKNOWN_OP;
+                    i->second.mode = OpenMode::UNKNOWN_OM;
+                    i->second.lastOperation = Filepointer::Operation::UNKNOWN_OP;
                 }
             } else if (Token::Match(tok, "%name% (") && tok->previous() && (!tok->previous()->isName() || Token::Match(tok->previous(), "return|throw"))) {
                 std::string mode;
                 const Token* fileTok = nullptr;
-                Filepointer::Operation operation = Filepointer::NONE;
+                const Token* fileNameTok = nullptr;
+                Filepointer::Operation operation = Filepointer::Operation::NONE;
 
                 if ((tok->str() == "fopen" || tok->str() == "freopen" || tok->str() == "tmpfile" ||
                      (windows && (tok->str() == "_wfopen" || tok->str() == "_wfreopen"))) &&
@@ -186,13 +202,15 @@ void CheckIO::checkFileUsage()
                     } else
                         mode = "wb+";
                     fileTok = tok->tokAt(-2);
-                    operation = Filepointer::OPEN;
+                    operation = Filepointer::Operation::OPEN;
+                    if (Token::Match(tok, "fopen ( %str% ,"))
+                        fileNameTok = tok->tokAt(2);
                 } else if (windows && Token::Match(tok, "fopen_s|freopen_s|_wfopen_s|_wfreopen_s ( & %name%")) {
                     const Token* modeTok = tok->tokAt(2)->nextArgument()->nextArgument();
                     if (modeTok && modeTok->tokType() == Token::eString)
                         mode = modeTok->strValue();
                     fileTok = tok->tokAt(3);
-                    operation = Filepointer::OPEN;
+                    operation = Filepointer::Operation::OPEN;
                 } else if ((tok->str() == "rewind" || tok->str() == "fseek" || tok->str() == "fsetpos" || tok->str() == "fflush") ||
                            (windows && tok->str() == "_fseeki64")) {
                     fileTok = tok->tokAt(2);
@@ -201,11 +219,11 @@ void CheckIO::checkFileUsage()
                             fflushOnInputStreamError(tok, fileTok->str());
                         else {
                             const Filepointer& f = filepointers[fileTok->varId()];
-                            if (f.mode == READ_MODE)
+                            if (f.mode == OpenMode::READ_MODE)
                                 fflushOnInputStreamError(tok, fileTok->str());
                         }
                     }
-                    operation = Filepointer::POSITIONING;
+                    operation = Filepointer::Operation::POSITIONING;
                 } else if (tok->str() == "fgetc" || tok->str() == "fgetwc" ||
                            tok->str() == "fgets" || tok->str() == "fgetws" || tok->str() == "fread" ||
                            tok->str() == "fscanf" || tok->str() == "fwscanf" || tok->str() == "getc" ||
@@ -214,7 +232,7 @@ void CheckIO::checkFileUsage()
                         fileTok = tok->tokAt(2);
                     else
                         fileTok = tok->linkAt(1)->previous();
-                    operation = Filepointer::READ;
+                    operation = Filepointer::Operation::READ;
                 } else if (tok->str() == "fputc" || tok->str() == "fputwc" ||
                            tok->str() == "fputs" || tok->str() == "fputws" || tok->str() == "fwrite" ||
                            tok->str() == "fprintf" || tok->str() == "fwprintf" || tok->str() == "putcc" ||
@@ -223,26 +241,26 @@ void CheckIO::checkFileUsage()
                         fileTok = tok->tokAt(2);
                     else
                         fileTok = tok->linkAt(1)->previous();
-                    operation = Filepointer::WRITE;
+                    operation = Filepointer::Operation::WRITE;
                 } else if (tok->str() == "fclose") {
                     fileTok = tok->tokAt(2);
-                    operation = Filepointer::CLOSE;
+                    operation = Filepointer::Operation::CLOSE;
                 } else if (whitelist.find(tok->str()) != whitelist.end()) {
                     fileTok = tok->tokAt(2);
                     if ((tok->str() == "ungetc" || tok->str() == "ungetwc") && fileTok)
                         fileTok = fileTok->nextArgument();
-                    operation = Filepointer::UNIMPORTANT;
+                    operation = Filepointer::Operation::UNIMPORTANT;
                 } else if (!Token::Match(tok, "if|for|while|catch|switch") && !mSettings->library.isFunctionConst(tok->str(), true)) {
                     const Token* const end2 = tok->linkAt(1);
                     if (scope->functionOf && scope->functionOf->isClassOrStruct() && !scope->function->isStatic() && ((tok->strAt(-1) != "::" && tok->strAt(-1) != ".") || tok->strAt(-2) == "this")) {
                         if (!tok->function() || (tok->function()->nestedIn && tok->function()->nestedIn->isClassOrStruct())) {
-                            for (std::map<int, Filepointer>::iterator i = filepointers.begin(); i != filepointers.end(); ++i) {
-                                const Variable* var = symbolDatabase->getVariableFromVarId(i->first);
+                            for (std::pair<const int, Filepointer>& filepointer : filepointers) {
+                                const Variable* var = symbolDatabase->getVariableFromVarId(filepointer.first);
                                 if (!var || !(var->isLocal() || var->isGlobal() || var->isStatic())) {
-                                    i->second.mode = UNKNOWN_OM;
-                                    i->second.mode_indent = 0;
-                                    i->second.op_indent = indent;
-                                    i->second.lastOperation = Filepointer::UNKNOWN_OP;
+                                    filepointer.second.mode = OpenMode::UNKNOWN_OM;
+                                    filepointer.second.mode_indent = 0;
+                                    filepointer.second.op_indent = indent;
+                                    filepointer.second.lastOperation = Filepointer::Operation::UNKNOWN_OP;
                                 }
                             }
                             continue;
@@ -251,7 +269,7 @@ void CheckIO::checkFileUsage()
                     for (const Token* tok2 = tok->tokAt(2); tok2 != end2; tok2 = tok2->next()) {
                         if (tok2->varId() && filepointers.find(tok2->varId()) != filepointers.end()) {
                             fileTok = tok2;
-                            operation = Filepointer::UNKNOWN_OP; // Assume that repositioning was last operation and that the file is opened now
+                            operation = Filepointer::Operation::UNKNOWN_OP; // Assume that repositioning was last operation and that the file is opened now
                             break;
                         }
                     }
@@ -263,73 +281,83 @@ void CheckIO::checkFileUsage()
                 if (!fileTok || !fileTok->varId() || fileTok->strAt(1) == "[")
                     continue;
 
-                if (filepointers.find(fileTok->varId()) == filepointers.end()) { // function call indicates: Its a File
-                    filepointers.insert(std::make_pair(fileTok->varId(), Filepointer(UNKNOWN_OM)));
-                }
+                // function call indicates: Its a File
+                filepointers.emplace(fileTok->varId(), Filepointer(OpenMode::UNKNOWN_OM));
+
                 Filepointer& f = filepointers[fileTok->varId()];
 
                 switch (operation) {
-                case Filepointer::OPEN:
+                case Filepointer::Operation::OPEN:
+                    if (fileNameTok) {
+                        for (auto it = filepointers.cbegin(); it != filepointers.cend(); ++it) {
+                            const Filepointer &fptr = it->second;
+                            if (fptr.filename == fileNameTok->str() && (fptr.mode == OpenMode::RW_MODE || fptr.mode == OpenMode::WRITE_MODE))
+                                incompatibleFileOpenError(tok, fileNameTok->str());
+                        }
+
+                        f.filename = fileNameTok->str();
+                    }
+
                     f.mode = getMode(mode);
                     if (mode.find('a') != std::string::npos) {
-                        if (f.mode == RW_MODE)
-                            f.append_mode = Filepointer::APPEND_EX;
+                        if (f.mode == OpenMode::RW_MODE)
+                            f.append_mode = Filepointer::AppendMode::APPEND_EX;
                         else
-                            f.append_mode = Filepointer::APPEND;
+                            f.append_mode = Filepointer::AppendMode::APPEND;
                     } else
-                        f.append_mode = Filepointer::UNKNOWN_AM;
+                        f.append_mode = Filepointer::AppendMode::UNKNOWN_AM;
                     f.mode_indent = indent;
                     break;
-                case Filepointer::POSITIONING:
-                    if (f.mode == CLOSED)
+                case Filepointer::Operation::POSITIONING:
+                    if (f.mode == OpenMode::CLOSED)
                         useClosedFileError(tok);
-                    else if (f.append_mode == Filepointer::APPEND && tok->str() != "fflush" && printWarnings)
+                    else if (f.append_mode == Filepointer::AppendMode::APPEND && tok->str() != "fflush" && printWarnings)
                         seekOnAppendedFileError(tok);
                     break;
-                case Filepointer::READ:
-                    if (f.mode == CLOSED)
+                case Filepointer::Operation::READ:
+                    if (f.mode == OpenMode::CLOSED)
                         useClosedFileError(tok);
-                    else if (f.mode == WRITE_MODE)
+                    else if (f.mode == OpenMode::WRITE_MODE)
                         readWriteOnlyFileError(tok);
-                    else if (f.lastOperation == Filepointer::WRITE)
+                    else if (f.lastOperation == Filepointer::Operation::WRITE)
                         ioWithoutPositioningError(tok);
                     break;
-                case Filepointer::WRITE:
-                    if (f.mode == CLOSED)
+                case Filepointer::Operation::WRITE:
+                    if (f.mode == OpenMode::CLOSED)
                         useClosedFileError(tok);
-                    else if (f.mode == READ_MODE)
+                    else if (f.mode == OpenMode::READ_MODE)
                         writeReadOnlyFileError(tok);
-                    else if (f.lastOperation == Filepointer::READ)
+                    else if (f.lastOperation == Filepointer::Operation::READ)
                         ioWithoutPositioningError(tok);
                     break;
-                case Filepointer::CLOSE:
-                    if (f.mode == CLOSED)
+                case Filepointer::Operation::CLOSE:
+                    if (f.mode == OpenMode::CLOSED)
                         useClosedFileError(tok);
                     else
-                        f.mode = CLOSED;
+                        f.mode = OpenMode::CLOSED;
                     f.mode_indent = indent;
                     break;
-                case Filepointer::UNIMPORTANT:
-                    if (f.mode == CLOSED)
+                case Filepointer::Operation::UNIMPORTANT:
+                    if (f.mode == OpenMode::CLOSED)
                         useClosedFileError(tok);
                     break;
-                case Filepointer::UNKNOWN_OP:
-                    f.mode = UNKNOWN_OM;
+                case Filepointer::Operation::UNKNOWN_OP:
+                    f.mode = OpenMode::UNKNOWN_OM;
                     f.mode_indent = 0;
                     break;
                 default:
                     break;
                 }
-                if (operation != Filepointer::NONE && operation != Filepointer::UNIMPORTANT) {
+                if (operation != Filepointer::Operation::NONE && operation != Filepointer::Operation::UNIMPORTANT) {
                     f.op_indent = indent;
                     f.lastOperation = operation;
                 }
             }
         }
-        for (std::map<int, Filepointer>::iterator i = filepointers.begin(); i != filepointers.end(); ++i) {
-            i->second.op_indent = 0;
-            i->second.mode = UNKNOWN_OM;
-            i->second.lastOperation = Filepointer::UNKNOWN_OP;
+        for (std::pair<const int, Filepointer>& filepointer : filepointers) {
+            filepointer.second.op_indent = 0;
+            filepointer.second.mode = OpenMode::UNKNOWN_OM;
+            filepointer.second.lastOperation = Filepointer::Operation::UNKNOWN_OP;
         }
     }
 }
@@ -337,37 +365,43 @@ void CheckIO::checkFileUsage()
 void CheckIO::fflushOnInputStreamError(const Token *tok, const std::string &varname)
 {
     reportError(tok, Severity::portability,
-                "fflushOnInputStream", "fflush() called on input stream '" + varname + "' may result in undefined behaviour on non-linux systems.", CWE398, false);
+                "fflushOnInputStream", "fflush() called on input stream '" + varname + "' may result in undefined behaviour on non-linux systems.", CWE398, Certainty::normal);
 }
 
 void CheckIO::ioWithoutPositioningError(const Token *tok)
 {
     reportError(tok, Severity::error,
-                "IOWithoutPositioning", "Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour.", CWE664, false);
+                "IOWithoutPositioning", "Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour.", CWE664, Certainty::normal);
 }
 
 void CheckIO::readWriteOnlyFileError(const Token *tok)
 {
     reportError(tok, Severity::error,
-                "readWriteOnlyFile", "Read operation on a file that was opened only for writing.", CWE664, false);
+                "readWriteOnlyFile", "Read operation on a file that was opened only for writing.", CWE664, Certainty::normal);
 }
 
 void CheckIO::writeReadOnlyFileError(const Token *tok)
 {
     reportError(tok, Severity::error,
-                "writeReadOnlyFile", "Write operation on a file that was opened only for reading.", CWE664, false);
+                "writeReadOnlyFile", "Write operation on a file that was opened only for reading.", CWE664, Certainty::normal);
 }
 
 void CheckIO::useClosedFileError(const Token *tok)
 {
     reportError(tok, Severity::error,
-                "useClosedFile", "Used file that is not opened.", CWE910, false);
+                "useClosedFile", "Used file that is not opened.", CWE910, Certainty::normal);
 }
 
 void CheckIO::seekOnAppendedFileError(const Token *tok)
 {
     reportError(tok, Severity::warning,
-                "seekOnAppendedFile", "Repositioning operation performed on a file opened in append mode has no effect.", CWE398, false);
+                "seekOnAppendedFile", "Repositioning operation performed on a file opened in append mode has no effect.", CWE398, Certainty::normal);
+}
+
+void CheckIO::incompatibleFileOpenError(const Token *tok, const std::string &filename)
+{
+    reportError(tok, Severity::warning,
+                "incompatibleFileOpen", "The file '" + filename + "' is opened for read and write access at the same time on different streams", CWE664, Certainty::normal);
 }
 
 
@@ -376,9 +410,11 @@ void CheckIO::seekOnAppendedFileError(const Token *tok)
 //---------------------------------------------------------------------------
 void CheckIO::invalidScanf()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning) && !mSettings->isPremiumEnabled("invalidscanf"))
         return;
 
+    logChecker("CheckIO::invalidScanf");
+
     const SymbolDatabase * const symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token *tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
@@ -409,7 +445,7 @@ void CheckIO::invalidScanf()
                     format = false;
                 }
 
-                else if (std::isalpha((unsigned char)formatstr[i]) || formatstr[i] == '[') {
+                else if (std::isalpha(static_cast<unsigned char>(formatstr[i])) || formatstr[i] == '[') {
                     if (formatstr[i] == 's' || formatstr[i] == '[' || formatstr[i] == 'S' || (formatstr[i] == 'l' && formatstr[i+1] == 's'))  // #3490 - field width limits are only necessary for string input
                         invalidScanfError(tok);
                     format = false;
@@ -442,7 +478,7 @@ void CheckIO::invalidScanfError(const Token *tok)
                 "terminating null byte.\n"
                 "Source: http://linux.die.net/man/3/scanf\n"
                 "Source: http://www.opensource.apple.com/source/xnu/xnu-1456.1.26/libkern/stdio/scanf.c",
-                CWE119, false);
+                CWE119, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -452,7 +488,7 @@ void CheckIO::invalidScanfError(const Token *tok)
 //---------------------------------------------------------------------------
 
 static bool findFormat(nonneg int arg, const Token *firstArg,
-                       const Token **formatStringTok, const Token **formatArgTok)
+                       const Token *&formatStringTok, const Token *&formatArgTok)
 {
     const Token* argTok = firstArg;
 
@@ -460,23 +496,24 @@ static bool findFormat(nonneg int arg, const Token *firstArg,
         argTok = argTok->nextArgument();
 
     if (Token::Match(argTok, "%str% [,)]")) {
-        *formatArgTok = argTok->nextArgument();
-        *formatStringTok = argTok;
+        formatArgTok = argTok->nextArgument();
+        formatStringTok = argTok;
         return true;
-    } else if (Token::Match(argTok, "%var% [,)]") &&
-               argTok->variable() &&
-               Token::Match(argTok->variable()->typeStartToken(), "char|wchar_t") &&
-               (argTok->variable()->isPointer() ||
-                (argTok->variable()->dimensions().size() == 1 &&
-                 argTok->variable()->dimensionKnown(0) &&
-                 argTok->variable()->dimension(0) != 0))) {
-        *formatArgTok = argTok->nextArgument();
+    }
+    if (Token::Match(argTok, "%var% [,)]") &&
+        argTok->variable() &&
+        Token::Match(argTok->variable()->typeStartToken(), "char|wchar_t") &&
+        (argTok->variable()->isPointer() ||
+         (argTok->variable()->dimensions().size() == 1 &&
+          argTok->variable()->dimensionKnown(0) &&
+          argTok->variable()->dimension(0) != 0))) {
+        formatArgTok = argTok->nextArgument();
         if (!argTok->values().empty()) {
-            std::list<ValueFlow::Value>::const_iterator value = std::find_if(
-                        argTok->values().begin(), argTok->values().end(), std::mem_fn(&ValueFlow::Value::isTokValue));
-            if (value != argTok->values().end() && value->isTokValue() && value->tokvalue &&
+            const auto value = std::find_if(
+                argTok->values().cbegin(), argTok->values().cend(), std::mem_fn(&ValueFlow::Value::isTokValue));
+            if (value != argTok->values().cend() && value->isTokValue() && value->tokvalue &&
                 value->tokvalue->tokType() == Token::eString) {
-                *formatStringTok = value->tokvalue;
+                formatStringTok = value->tokvalue;
             }
         }
         return true;
@@ -493,7 +530,9 @@ static inline bool typesMatch(const std::string& iToTest, const std::string& iTy
 void CheckIO::checkWrongPrintfScanfArguments()
 {
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
-    const bool isWindows = mSettings->isWindowsPlatform();
+    const bool isWindows = mSettings->platform.isWindows();
+
+    logChecker("CheckIO::checkWrongPrintfScanfArguments");
 
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token *tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
@@ -514,37 +553,37 @@ void CheckIO::checkWrongPrintfScanfArguments()
 
             if (formatStringArgNo >= 0) {
                 // formatstring found in library. Find format string and first argument belonging to format string.
-                if (!findFormat(formatStringArgNo, tok->tokAt(2), &formatStringTok, &argListTok))
+                if (!findFormat(formatStringArgNo, tok->tokAt(2), formatStringTok, argListTok))
                     continue;
             } else if (Token::simpleMatch(tok, "swprintf (")) {
                 if (Token::Match(tok->tokAt(2)->nextArgument(), "%str%")) {
                     // Find third parameter and format string
-                    if (!findFormat(1, tok->tokAt(2), &formatStringTok, &argListTok))
+                    if (!findFormat(1, tok->tokAt(2), formatStringTok, argListTok))
                         continue;
                 } else {
                     // Find fourth parameter and format string
-                    if (!findFormat(2, tok->tokAt(2), &formatStringTok, &argListTok))
+                    if (!findFormat(2, tok->tokAt(2), formatStringTok, argListTok))
                         continue;
                 }
             } else if (isWindows && Token::Match(tok, "sprintf_s|swprintf_s (")) {
                 // template <size_t size> int sprintf_s(char (&buffer)[size], const char *format, ...);
-                if (findFormat(1, tok->tokAt(2), &formatStringTok, &argListTok)) {
+                if (findFormat(1, tok->tokAt(2), formatStringTok, argListTok)) {
                     if (!formatStringTok)
                         continue;
                 }
                 // int sprintf_s(char *buffer, size_t sizeOfBuffer, const char *format, ...);
-                else if (findFormat(2, tok->tokAt(2), &formatStringTok, &argListTok)) {
+                else if (findFormat(2, tok->tokAt(2), formatStringTok, argListTok)) {
                     if (!formatStringTok)
                         continue;
                 }
             } else if (isWindows && Token::Match(tok, "_snprintf_s|_snwprintf_s (")) {
                 // template <size_t size> int _snprintf_s(char (&buffer)[size], size_t count, const char *format, ...);
-                if (findFormat(2, tok->tokAt(2), &formatStringTok, &argListTok)) {
+                if (findFormat(2, tok->tokAt(2), formatStringTok, argListTok)) {
                     if (!formatStringTok)
                         continue;
                 }
                 // int _snprintf_s(char *buffer, size_t sizeOfBuffer, size_t count, const char *format, ...);
-                else if (findFormat(3, tok->tokAt(2), &formatStringTok, &argListTok)) {
+                else if (findFormat(3, tok->tokAt(2), formatStringTok, argListTok)) {
                     if (!formatStringTok)
                         continue;
                 }
@@ -566,7 +605,8 @@ void CheckIO::checkFormatString(const Token * const tok,
                                 const bool scan,
                                 const bool scanf_s)
 {
-    const bool printWarning = mSettings->isEnabled(Settings::WARNING);
+    const bool isWindows = mSettings->platform.isWindows();
+    const bool printWarning = mSettings->severity.isEnabled(Severity::warning);
     const std::string &formatString = formatStringTok->str();
 
     // Count format string parameters..
@@ -575,11 +615,11 @@ void CheckIO::checkFormatString(const Token * const tok,
     bool percent = false;
     const Token* argListTok2 = argListTok;
     std::set<int> parameterPositionsUsed;
-    for (std::string::const_iterator i = formatString.begin(); i != formatString.end(); ++i) {
+    for (auto i = formatString.cbegin(); i != formatString.cend(); ++i) {
         if (*i == '%') {
             percent = !percent;
         } else if (percent && *i == '[') {
-            while (i != formatString.end()) {
+            while (i != formatString.cend()) {
                 if (*i == ']') {
                     numFormat++;
                     if (argListTok)
@@ -595,7 +635,7 @@ void CheckIO::checkFormatString(const Token * const tok,
                     argListTok = argListTok->nextArgument();
                 }
             }
-            if (i == formatString.end())
+            if (i == formatString.cend())
                 break;
         } else if (percent) {
             percent = false;
@@ -605,7 +645,7 @@ void CheckIO::checkFormatString(const Token * const tok,
             std::string width;
             int parameterPosition = 0;
             bool hasParameterPosition = false;
-            while (i != formatString.end() && *i != '[' && !std::isalpha((unsigned char)*i)) {
+            while (i != formatString.cend() && *i != '[' && !std::isalpha(static_cast<unsigned char>(*i))) {
                 if (*i == '*') {
                     skip = true;
                     if (scan)
@@ -618,22 +658,19 @@ void CheckIO::checkFormatString(const Token * const tok,
                 } else if (std::isdigit(*i)) {
                     width += *i;
                 } else if (*i == '$') {
-                    parameterPosition = std::atoi(width.c_str());
+                    parameterPosition = strToInt<int>(width);
                     hasParameterPosition = true;
                     width.clear();
                 }
                 ++i;
             }
-            if (i != formatString.end() && *i == '[') {
-                while (i != formatString.end()) {
-                    if (*i == ']') {
-                        if (!skip) {
-                            numFormat++;
-                            if (argListTok)
-                                argListTok = argListTok->nextArgument();
-                        }
+            auto bracketBeg = formatString.cend();
+            if (i != formatString.cend() && *i == '[') {
+                bracketBeg = i;
+                while (i != formatString.cend()) {
+                    if (*i == ']')
                         break;
-                    }
+
                     ++i;
                 }
                 if (scanf_s && !skip) {
@@ -642,9 +679,8 @@ void CheckIO::checkFormatString(const Token * const tok,
                         argListTok = argListTok->nextArgument();
                     }
                 }
-                _continue = true;
             }
-            if (i == formatString.end())
+            if (i == formatString.cend())
                 break;
             if (_continue)
                 continue;
@@ -661,31 +697,32 @@ void CheckIO::checkFormatString(const Token * const tok,
                 }
 
                 // Perform type checks
-                ArgumentInfo argInfo(argListTok, mSettings, mTokenizer->isCPP());
+                ArgumentInfo argInfo(argListTok, *mSettings, mTokenizer->isCPP());
 
-                if (argInfo.typeToken && !argInfo.isLibraryType(mSettings)) {
+                if ((argInfo.typeToken && !argInfo.isLibraryType(*mSettings)) || *i == ']') {
                     if (scan) {
                         std::string specifier;
                         bool done = false;
                         while (!done) {
                             switch (*i) {
                             case 's':
-                                specifier += *i;
+                            case ']': // charset
+                                specifier += (*i == 's' || bracketBeg == formatString.end()) ? std::string{ 's' } : std::string{ bracketBeg, i + 1 };
                                 if (argInfo.variableInfo && argInfo.isKnownType() && argInfo.variableInfo->isArray() && (argInfo.variableInfo->dimensions().size() == 1) && argInfo.variableInfo->dimensions()[0].known) {
                                     if (!width.empty()) {
-                                        const int numWidth = std::atoi(width.c_str());
+                                        const int numWidth = strToInt<int>(width);
                                         if (numWidth != (argInfo.variableInfo->dimension(0) - 1))
-                                            invalidScanfFormatWidthError(tok, numFormat, numWidth, argInfo.variableInfo, 's');
+                                            invalidScanfFormatWidthError(tok, numFormat, numWidth, argInfo.variableInfo, specifier);
                                     }
                                 }
-                                if (argListTok && argListTok->tokType() != Token::eString &&
+                                if (argListTok && argListTok->tokType() != Token::eString && argInfo.typeToken &&
                                     argInfo.isKnownType() && argInfo.isArrayOrPointer() &&
                                     (!Token::Match(argInfo.typeToken, "char|wchar_t") ||
                                      argInfo.typeToken->strAt(-1) == "const")) {
                                     if (!(argInfo.isArrayOrPointer() && argInfo.element && !argInfo.typeToken->isStandardType()))
                                         invalidScanfArgTypeError_s(tok, numFormat, specifier, &argInfo);
                                 }
-                                if (scanf_s) {
+                                if (scanf_s && argInfo.typeToken) {
                                     numSecure++;
                                     if (argListTok) {
                                         argListTok = argListTok->nextArgument();
@@ -696,9 +733,9 @@ void CheckIO::checkFormatString(const Token * const tok,
                             case 'c':
                                 if (argInfo.variableInfo && argInfo.isKnownType() && argInfo.variableInfo->isArray() && (argInfo.variableInfo->dimensions().size() == 1) && argInfo.variableInfo->dimensions()[0].known) {
                                     if (!width.empty()) {
-                                        const int numWidth = std::atoi(width.c_str());
+                                        const int numWidth = strToInt<int>(width);
                                         if (numWidth > argInfo.variableInfo->dimension(0))
-                                            invalidScanfFormatWidthError(tok, numFormat, numWidth, argInfo.variableInfo, 'c');
+                                            invalidScanfFormatWidthError(tok, numFormat, numWidth, argInfo.variableInfo, std::string(1, *i));
                                     }
                                 }
                                 if (scanf_s) {
@@ -841,7 +878,8 @@ void CheckIO::checkFormatString(const Token * const tok,
                                                 invalidScanfArgTypeError_int(tok, numFormat, specifier, &argInfo, false);
                                             break;
                                         case 'z':
-                                            if (!typesMatch(argInfo.typeToken->originalName(), "ssize_t"))
+                                            if (!(typesMatch(argInfo.typeToken->originalName(), "ssize_t") ||
+                                                  (isWindows && typesMatch(argInfo.typeToken->originalName(), "SSIZE_T"))))
                                                 invalidScanfArgTypeError_int(tok, numFormat, specifier, &argInfo, false);
                                             break;
                                         case 't':
@@ -900,13 +938,13 @@ void CheckIO::checkFormatString(const Token * const tok,
                                 done = true;
                                 break;
                             case 'I':
-                                if ((i+1 != formatString.end() && *(i+1) == '6' &&
-                                     i+2 != formatString.end() && *(i+2) == '4') ||
-                                    (i+1 != formatString.end() && *(i+1) == '3' &&
-                                     i+2 != formatString.end() && *(i+2) == '2')) {
+                                if ((i+1 != formatString.cend() && *(i+1) == '6' &&
+                                     i+2 != formatString.cend() && *(i+2) == '4') ||
+                                    (i+1 != formatString.cend() && *(i+1) == '3' &&
+                                     i+2 != formatString.cend() && *(i+2) == '2')) {
                                     specifier += *i++;
                                     specifier += *i++;
-                                    if ((i+1) != formatString.end() && !isalpha(*(i+1))) {
+                                    if ((i+1) != formatString.cend() && !isalpha(*(i+1))) {
                                         specifier += *i;
                                         invalidLengthModifierError(tok, numFormat, specifier);
                                         done = true;
@@ -914,7 +952,7 @@ void CheckIO::checkFormatString(const Token * const tok,
                                         specifier += *i++;
                                     }
                                 } else {
-                                    if ((i+1) != formatString.end() && !isalpha(*(i+1))) {
+                                    if ((i+1) != formatString.cend() && !isalpha(*(i+1))) {
                                         specifier += *i;
                                         invalidLengthModifierError(tok, numFormat, specifier);
                                         done = true;
@@ -925,16 +963,16 @@ void CheckIO::checkFormatString(const Token * const tok,
                                 break;
                             case 'h':
                             case 'l':
-                                if (i+1 != formatString.end() && *(i+1) == *i)
+                                if (i+1 != formatString.cend() && *(i+1) == *i)
                                     specifier += *i++;
-                            // fallthrough
+                                FALLTHROUGH;
                             case 'j':
                             case 'q':
                             case 't':
                             case 'z':
                             case 'L':
                                 // Expect an alphabetical character after these specifiers
-                                if (i != formatString.end() && !isalpha(*(i+1))) {
+                                if ((i + 1) != formatString.end() && !isalpha(*(i+1))) {
                                     specifier += *i;
                                     invalidLengthModifierError(tok, numFormat, specifier);
                                     done = true;
@@ -951,6 +989,9 @@ void CheckIO::checkFormatString(const Token * const tok,
                         std::string specifier;
                         bool done = false;
                         while (!done) {
+                            if (i == formatString.end()) {
+                                break;
+                            }
                             switch (*i) {
                             case 's':
                                 if (argListTok->tokType() != Token::eString &&
@@ -1095,7 +1136,8 @@ void CheckIO::checkFormatString(const Token * const tok,
                                                 invalidPrintfArgTypeError_sint(tok, numFormat, specifier, &argInfo);
                                             break;
                                         case 'z':
-                                            if (!typesMatch(argInfo.typeToken->originalName(), "ssize_t"))
+                                            if (!(typesMatch(argInfo.typeToken->originalName(), "ssize_t") ||
+                                                  (isWindows && typesMatch(argInfo.typeToken->originalName(), "SSIZE_T"))))
                                                 invalidPrintfArgTypeError_sint(tok, numFormat, specifier, &argInfo);
                                             break;
                                         case 'L':
@@ -1190,7 +1232,7 @@ void CheckIO::checkFormatString(const Token * const tok,
                                 break;
                             case 'p':
                                 if (argInfo.typeToken->tokType() == Token::eString)
-                                    ;// string literals are passed as pointers to literal start, okay
+                                    ; // string literals are passed as pointers to literal start, okay
                                 else if (argInfo.isKnownType() && !argInfo.isArrayOrPointer())
                                     invalidPrintfArgTypeError_p(tok, numFormat, &argInfo);
                                 done = true;
@@ -1219,9 +1261,8 @@ void CheckIO::checkFormatString(const Token * const tok,
                             case 'h': // Can be 'hh' (signed char or unsigned char) or 'h' (short int or unsigned short int)
                             case 'l': { // Can be 'll' (long long int or unsigned long long int) or 'l' (long int or unsigned long int)
                                 // If the next character is the same (which makes 'hh' or 'll') then expect another alphabetical character
-                                const bool isSecondCharAvailable = ((i + 1) != formatString.end());
-                                if (i != formatString.end() && isSecondCharAvailable && *(i + 1) == *i) {
-                                    if (!isalpha(*(i + 2))) {
+                                if ((i + 1) != formatString.end() && *(i + 1) == *i) {
+                                    if ((i + 2) != formatString.end() && !isalpha(*(i + 2))) {
                                         std::string modifier;
                                         modifier += *i;
                                         modifier += *(i + 1);
@@ -1232,17 +1273,13 @@ void CheckIO::checkFormatString(const Token * const tok,
                                         specifier += *i++;
                                     }
                                 } else {
-                                    if (i != formatString.end()) {
-                                        if ((i + 1) != formatString.end() && !isalpha(*(i + 1))) {
-                                            std::string modifier;
-                                            modifier += *i;
-                                            invalidLengthModifierError(tok, numFormat, modifier);
-                                            done = true;
-                                        } else {
-                                            specifier = *i++;
-                                        }
-                                    } else {
+                                    if ((i + 1) != formatString.end() && !isalpha(*(i + 1))) {
+                                        std::string modifier;
+                                        modifier += *i;
+                                        invalidLengthModifierError(tok, numFormat, modifier);
                                         done = true;
+                                    } else {
+                                        specifier = *i++;
                                     }
                                 }
                             }
@@ -1253,13 +1290,13 @@ void CheckIO::checkFormatString(const Token * const tok,
                                     specifier += *i++;
                                     specifier += *i++;
                                 }
-                            // fallthrough
+                                FALLTHROUGH;
                             case 'j': // intmax_t or uintmax_t
                             case 'z': // size_t
                             case 't': // ptrdiff_t
                             case 'L': // long double
                                 // Expect an alphabetical character after these specifiers
-                                if (i != formatString.end() && !isalpha(*(i+1))) {
+                                if ((i + 1) != formatString.end() && !isalpha(*(i+1))) {
                                     specifier += *i;
                                     invalidLengthModifierError(tok, numFormat, specifier);
                                     done = true;
@@ -1284,13 +1321,15 @@ void CheckIO::checkFormatString(const Token * const tok,
     // Count printf/scanf parameters..
     int numFunction = 0;
     while (argListTok2) {
+        if (Token::Match(argListTok2, "%name% ...")) // bailout for parameter pack
+            return;
         numFunction++;
         argListTok2 = argListTok2->nextArgument(); // Find next argument
     }
 
     if (printWarning) {
         // Check that all parameter positions reference an actual parameter
-        for (int i : parameterPositionsUsed) {
+        for (const int i : parameterPositionsUsed) {
             if ((i == 0) || (i > numFormat))
                 wrongPrintfScanfPosixParameterPositionError(tok, tok->str(), i, numFormat);
         }
@@ -1304,28 +1343,23 @@ void CheckIO::checkFormatString(const Token * const tok,
 // We currently only support string literals, variables, and functions.
 /// @todo add non-string literals, and generic expressions
 
-CheckIO::ArgumentInfo::ArgumentInfo(const Token * arg, const Settings *settings, bool _isCPP)
-    : variableInfo(nullptr)
-    , typeToken(nullptr)
-    , functionInfo(nullptr)
-    , tempToken(nullptr)
-    , element(false)
-    , _template(false)
-    , address(false)
-    , isCPP(_isCPP)
+CheckIO::ArgumentInfo::ArgumentInfo(const Token * arg, const Settings &settings, bool _isCPP)
+    : isCPP(_isCPP)
 {
     if (!arg)
         return;
 
     // Use AST type info
     // TODO: This is a bailout so that old code is used in simple cases. Remove the old code and always use the AST type.
-    if (!Token::Match(arg, "%str% ,|)") && !(Token::Match(arg,"%var%") && arg->variable() && arg->variable()->isArray())) {
+    if (!Token::Match(arg, "%str% ,|)") && !(arg->variable() && arg->variable()->isArray())) {
         const Token *top = arg;
+        while (top->str() == "(" && !top->isCast())
+            top = top->next();
         while (top->astParent() && top->astParent()->str() != "," && top->astParent() != arg->previous())
             top = top->astParent();
         const ValueType *valuetype = top->argumentType();
         if (valuetype && valuetype->type >= ValueType::Type::BOOL) {
-            typeToken = tempToken = new Token();
+            typeToken = tempToken = new Token(top);
             if (valuetype->pointer && valuetype->constness & 1) {
                 tempToken->str("const");
                 tempToken->insertToken("a");
@@ -1365,6 +1399,8 @@ CheckIO::ArgumentInfo::ArgumentInfo(const Token * arg, const Settings *settings,
             for (int p = 0; p < valuetype->pointer; p++)
                 tempToken->insertToken("*");
             tempToken = const_cast<Token*>(typeToken);
+            if (top->isBinaryOp() && Token::Match(top, "[+-]") && valuetype->pointer == 1 && (valuetype->type == ValueType::CHAR || valuetype->type == ValueType::WCHAR_T))
+                tempToken->tokType(Token::eString);
             return;
         }
     }
@@ -1373,11 +1409,12 @@ CheckIO::ArgumentInfo::ArgumentInfo(const Token * arg, const Settings *settings,
     if (arg->tokType() == Token::eString) {
         typeToken = arg;
         return;
-    } else if (arg->str() == "&" || arg->tokType() == Token::eVariable ||
-               arg->tokType() == Token::eFunction || Token::Match(arg, "%type% ::") ||
-               (Token::Match(arg, "static_cast|reinterpret_cast|const_cast <") &&
-                Token::simpleMatch(arg->linkAt(1), "> (") &&
-                Token::Match(arg->linkAt(1)->linkAt(1), ") ,|)"))) {
+    }
+    if (arg->str() == "&" || arg->tokType() == Token::eVariable ||
+        arg->tokType() == Token::eFunction || Token::Match(arg, "%type% ::") ||
+        (Token::Match(arg, "static_cast|reinterpret_cast|const_cast <") &&
+         Token::simpleMatch(arg->linkAt(1), "> (") &&
+         Token::Match(arg->linkAt(1)->linkAt(1), ") ,|)"))) {
         if (Token::Match(arg, "static_cast|reinterpret_cast|const_cast")) {
             typeToken = arg->tokAt(2);
             while (typeToken->str() == "const" || typeToken->str() == "extern")
@@ -1396,7 +1433,7 @@ CheckIO::ArgumentInfo::ArgumentInfo(const Token * arg, const Settings *settings,
         const Token *tok1 = arg->next();
         for (; tok1; tok1 = tok1->next()) {
             if (tok1->str() == "," || tok1->str() == ")") {
-                if (tok1->previous()->str() == "]") {
+                if (tok1->strAt(-1) == "]") {
                     varTok = tok1->linkAt(-1)->previous();
                     if (varTok->str() == ")" && varTok->link()->previous()->tokType() == Token::eFunction) {
                         const Function * function = varTok->link()->previous()->function();
@@ -1404,9 +1441,7 @@ CheckIO::ArgumentInfo::ArgumentInfo(const Token * arg, const Settings *settings,
                             if (function->retType->classScope->enumType)
                                 typeToken = function->retType->classScope->enumType;
                             else {
-                                tempToken = new Token();
-                                tempToken->fileIndex(tok1->fileIndex());
-                                tempToken->linenr(tok1->linenr());
+                                tempToken = new Token(tok1);
                                 tempToken->str("int");
                                 typeToken = tempToken;
                             }
@@ -1419,15 +1454,13 @@ CheckIO::ArgumentInfo::ArgumentInfo(const Token * arg, const Settings *settings,
                         }
                         return;
                     }
-                } else if (tok1->previous()->str() == ")" && tok1->linkAt(-1)->previous()->tokType() == Token::eFunction) {
+                } else if (tok1->strAt(-1) == ")" && tok1->linkAt(-1)->previous()->tokType() == Token::eFunction) {
                     const Function * function = tok1->linkAt(-1)->previous()->function();
                     if (function && function->retType && function->retType->isEnumType()) {
                         if (function->retType->classScope->enumType)
                             typeToken = function->retType->classScope->enumType;
                         else {
-                            tempToken = new Token();
-                            tempToken->fileIndex(tok1->fileIndex());
-                            tempToken->linenr(tok1->linenr());
+                            tempToken = new Token(tok1);
                             tempToken->str("int");
                             typeToken = tempToken;
                         }
@@ -1442,25 +1475,24 @@ CheckIO::ArgumentInfo::ArgumentInfo(const Token * arg, const Settings *settings,
                 } else
                     varTok = tok1->previous();
                 break;
-            } else if (tok1->str() == "(" || tok1->str() == "{" || tok1->str() == "[")
+            }
+            if (tok1->str() == "(" || tok1->str() == "{" || tok1->str() == "[")
                 tok1 = tok1->link();
             else if (tok1->link() && tok1->str() == "<")
                 tok1 = tok1->link();
 
             // check for some common well known functions
             else if (isCPP && ((Token::Match(tok1->previous(), "%var% . size|empty|c_str ( ) [,)]") && isStdContainer(tok1->previous())) ||
-                               (Token::Match(tok1->previous(), "] . size|empty|c_str ( ) [,)]") && isStdContainer(tok1->previous()->link()->previous())))) {
-                tempToken = new Token();
-                tempToken->fileIndex(tok1->fileIndex());
-                tempToken->linenr(tok1->linenr());
-                if (tok1->next()->str() == "size") {
+                               (Token::Match(tok1->previous(), "] . size|empty|c_str ( ) [,)]") && isStdContainer(tok1->linkAt(-1)->previous())))) {
+                tempToken = new Token(tok1);
+                if (tok1->strAt(1) == "size") {
                     // size_t is platform dependent
-                    if (settings->sizeof_size_t == 8) {
+                    if (settings.platform.sizeof_size_t == 8) {
                         tempToken->str("long");
-                        if (settings->sizeof_long != 8)
+                        if (settings.platform.sizeof_long != 8)
                             tempToken->isLong(true);
-                    } else if (settings->sizeof_size_t == 4) {
-                        if (settings->sizeof_long == 4) {
+                    } else if (settings.platform.sizeof_size_t == 4) {
+                        if (settings.platform.sizeof_long == 4) {
                             tempToken->str("long");
                         } else {
                             tempToken->str("int");
@@ -1469,9 +1501,9 @@ CheckIO::ArgumentInfo::ArgumentInfo(const Token * arg, const Settings *settings,
 
                     tempToken->originalName("size_t");
                     tempToken->isUnsigned(true);
-                } else if (tok1->next()->str() == "empty") {
+                } else if (tok1->strAt(1) == "empty") {
                     tempToken->str("bool");
-                } else if (tok1->next()->str() == "c_str") {
+                } else if (tok1->strAt(1) == "c_str") {
                     tempToken->str("const");
                     tempToken->insertToken("*");
                     if (typeToken->strAt(2) == "string")
@@ -1501,7 +1533,7 @@ CheckIO::ArgumentInfo::ArgumentInfo(const Token * arg, const Settings *settings,
 
         if (varTok) {
             variableInfo = varTok->variable();
-            element = tok1->previous()->str() == "]";
+            element = tok1->strAt(-1) == "]";
 
             // look for std::vector operator [] and use template type as return type
             if (variableInfo) {
@@ -1511,9 +1543,7 @@ CheckIO::ArgumentInfo::ArgumentInfo(const Token * arg, const Settings *settings,
                     if (variableInfo->type() && variableInfo->type()->classScope && variableInfo->type()->classScope->enumType)
                         typeToken = variableInfo->type()->classScope->enumType;
                     else {
-                        tempToken = new Token();
-                        tempToken->fileIndex(tok1->fileIndex());
-                        tempToken->linenr(tok1->linenr());
+                        tempToken = new Token(tok1);
                         tempToken->str("int");
                         typeToken = tempToken;
                     }
@@ -1549,17 +1579,17 @@ bool CheckIO::ArgumentInfo::isStdVectorOrString()
         typeToken = variableInfo->typeStartToken()->tokAt(4);
         _template = true;
         return true;
-    } else if (variableInfo->isStlType(stl_string)) {
-        tempToken = new Token();
-        tempToken->fileIndex(variableInfo->typeStartToken()->fileIndex());
-        tempToken->linenr(variableInfo->typeStartToken()->linenr());
+    }
+    if (variableInfo->isStlType(stl_string)) {
+        tempToken = new Token(variableInfo->typeStartToken());
         if (variableInfo->typeStartToken()->strAt(2) == "string")
             tempToken->str("char");
         else
             tempToken->str("wchar_t");
         typeToken = tempToken;
         return true;
-    } else if (variableInfo->type() && !variableInfo->type()->derivedFrom.empty()) {
+    }
+    if (variableInfo->type() && !variableInfo->type()->derivedFrom.empty()) {
         const std::vector<Type::BaseInfo>& derivedFrom = variableInfo->type()->derivedFrom;
         for (const Type::BaseInfo & i : derivedFrom) {
             const Token* nameTok = i.nameTok;
@@ -1567,10 +1597,9 @@ bool CheckIO::ArgumentInfo::isStdVectorOrString()
                 typeToken = nameTok->tokAt(4);
                 _template = true;
                 return true;
-            } else if (Token::Match(nameTok, "std :: string|wstring")) {
-                tempToken = new Token();
-                tempToken->fileIndex(variableInfo->typeStartToken()->fileIndex());
-                tempToken->linenr(variableInfo->typeStartToken()->linenr());
+            }
+            if (Token::Match(nameTok, "std :: string|wstring")) {
+                tempToken = new Token(variableInfo->typeStartToken());
                 if (nameTok->strAt(2) == "string")
                     tempToken->str("char");
                 else
@@ -1613,16 +1642,19 @@ bool CheckIO::ArgumentInfo::isStdContainer(const Token *tok)
         if (variable->isStlType(stl_container)) {
             typeToken = variable->typeStartToken()->tokAt(4);
             return true;
-        } else if (variable->isStlType(stl_string)) {
+        }
+        if (variable->isStlType(stl_string)) {
             typeToken = variable->typeStartToken();
             return true;
-        } else if (variable->type() && !variable->type()->derivedFrom.empty()) {
+        }
+        if (variable->type() && !variable->type()->derivedFrom.empty()) {
             for (const Type::BaseInfo &baseInfo : variable->type()->derivedFrom) {
                 const Token* nameTok = baseInfo.nameTok;
                 if (Token::Match(nameTok, "std :: vector|array|bitset|deque|list|forward_list|map|multimap|multiset|priority_queue|queue|set|stack|hash_map|hash_multimap|hash_set|unordered_map|unordered_multimap|unordered_set|unordered_multiset <")) {
                     typeToken = nameTok->tokAt(4);
                     return true;
-                } else if (Token::Match(nameTok, "std :: string|wstring")) {
+                }
+                if (Token::Match(nameTok, "std :: string|wstring")) {
                     typeToken = nameTok;
                     return true;
                 }
@@ -1637,22 +1669,19 @@ bool CheckIO::ArgumentInfo::isArrayOrPointer() const
 {
     if (address)
         return true;
-    else if (variableInfo && !_template) {
+    if (variableInfo && !_template)
         return variableInfo->isArrayOrPointer();
-    } else {
-        const Token *tok = typeToken;
-        while (Token::Match(tok, "const|struct"))
-            tok = tok->next();
-        if (tok && tok->strAt(1) == "*")
-            return true;
-    }
-    return false;
+
+    const Token *tok = typeToken;
+    while (Token::Match(tok, "const|struct"))
+        tok = tok->next();
+    return tok && tok->strAt(1) == "*";
 }
 
 bool CheckIO::ArgumentInfo::isComplexType() const
 {
     if (variableInfo->type())
-        return (true);
+        return true;
 
     const Token* varTypeTok = typeToken;
     if (varTypeTok->str() == "std")
@@ -1665,24 +1694,24 @@ bool CheckIO::ArgumentInfo::isKnownType() const
 {
     if (variableInfo)
         return (typeToken->isStandardType() || typeToken->next()->isStandardType() || isComplexType());
-    else if (functionInfo)
+    if (functionInfo)
         return (typeToken->isStandardType() || functionInfo->retType || Token::Match(typeToken, "std :: string|wstring"));
 
     return typeToken->isStandardType() || Token::Match(typeToken, "std :: string|wstring");
 }
 
-bool CheckIO::ArgumentInfo::isLibraryType(const Settings *settings) const
+bool CheckIO::ArgumentInfo::isLibraryType(const Settings &settings) const
 {
-    return typeToken && typeToken->isStandardType() && settings->library.podtype(typeToken->str());
+    return typeToken && typeToken->isStandardType() && settings.library.podtype(typeToken->str());
 }
 
 void CheckIO::wrongPrintfScanfArgumentsError(const Token* tok,
-        const std::string &functionName,
-        nonneg int numFormat,
-        nonneg int numFunction)
+                                             const std::string &functionName,
+                                             nonneg int numFormat,
+                                             nonneg int numFunction)
 {
-    const Severity::SeverityType severity = numFormat > numFunction ? Severity::error : Severity::warning;
-    if (severity != Severity::error && !mSettings->isEnabled(Settings::WARNING))
+    const Severity severity = numFormat > numFunction ? Severity::error : Severity::warning;
+    if (severity != Severity::error && !mSettings->severity.isEnabled(Severity::warning) && !mSettings->isPremiumEnabled("wrongPrintfScanfArgNum"))
         return;
 
     std::ostringstream errmsg;
@@ -1695,13 +1724,13 @@ void CheckIO::wrongPrintfScanfArgumentsError(const Token* tok,
            << (numFunction != 1 ? " are" : " is")
            << " given.";
 
-    reportError(tok, severity, "wrongPrintfScanfArgNum", errmsg.str(), CWE685, false);
+    reportError(tok, severity, "wrongPrintfScanfArgNum", errmsg.str(), CWE685, Certainty::normal);
 }
 
 void CheckIO::wrongPrintfScanfPosixParameterPositionError(const Token* tok, const std::string& functionName,
-        nonneg int index, nonneg int numFunction)
+                                                          nonneg int index, nonneg int numFunction)
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning) && !mSettings->isPremiumEnabled("wrongPrintfScanfParameterPositionError"))
         return;
     std::ostringstream errmsg;
     errmsg << functionName << ": ";
@@ -1710,13 +1739,13 @@ void CheckIO::wrongPrintfScanfPosixParameterPositionError(const Token* tok, cons
     } else {
         errmsg << "referencing parameter " << index << " while " << numFunction << " arguments given";
     }
-    reportError(tok, Severity::warning, "wrongPrintfScanfParameterPositionError", errmsg.str(), CWE685, false);
+    reportError(tok, Severity::warning, "wrongPrintfScanfParameterPositionError", errmsg.str(), CWE685, Certainty::normal);
 }
 
 void CheckIO::invalidScanfArgTypeError_s(const Token* tok, nonneg int numFormat, const std::string& specifier, const ArgumentInfo* argInfo)
 {
-    const Severity::SeverityType severity = getSeverity(argInfo);
-    if (!mSettings->isEnabled(severity))
+    const Severity severity = getSeverity(argInfo);
+    if (!mSettings->severity.isEnabled(severity))
         return;
     std::ostringstream errmsg;
     errmsg << "%" << specifier << " in format string (no. " << numFormat << ") requires a \'";
@@ -1727,12 +1756,12 @@ void CheckIO::invalidScanfArgTypeError_s(const Token* tok, nonneg int numFormat,
     errmsg << " *\' but the argument type is ";
     argumentType(errmsg, argInfo);
     errmsg << ".";
-    reportError(tok, severity, "invalidScanfArgType_s", errmsg.str(), CWE686, false);
+    reportError(tok, severity, "invalidScanfArgType_s", errmsg.str(), CWE686, Certainty::normal);
 }
 void CheckIO::invalidScanfArgTypeError_int(const Token* tok, nonneg int numFormat, const std::string& specifier, const ArgumentInfo* argInfo, bool isUnsigned)
 {
-    const Severity::SeverityType severity = getSeverity(argInfo);
-    if (!mSettings->isEnabled(severity))
+    const Severity severity = getSeverity(argInfo);
+    if (!mSettings->severity.isEnabled(severity))
         return;
     std::ostringstream errmsg;
     errmsg << "%" << specifier << " in format string (no. " << numFormat << ") requires \'";
@@ -1758,7 +1787,7 @@ void CheckIO::invalidScanfArgTypeError_int(const Token* tok, nonneg int numForma
         else
             errmsg << "intmax_t";
     } else if (specifier[0] == 'z') {
-        if (specifier[1] == 'd')
+        if (specifier[1] == 'd' || specifier[1] == 'i')
             errmsg << "ssize_t";
         else
             errmsg << "size_t";
@@ -1772,12 +1801,12 @@ void CheckIO::invalidScanfArgTypeError_int(const Token* tok, nonneg int numForma
     errmsg << " *\' but the argument type is ";
     argumentType(errmsg, argInfo);
     errmsg << ".";
-    reportError(tok, severity, "invalidScanfArgType_int", errmsg.str(), CWE686, false);
+    reportError(tok, severity, "invalidScanfArgType_int", errmsg.str(), CWE686, Certainty::normal);
 }
 void CheckIO::invalidScanfArgTypeError_float(const Token* tok, nonneg int numFormat, const std::string& specifier, const ArgumentInfo* argInfo)
 {
-    const Severity::SeverityType severity = getSeverity(argInfo);
-    if (!mSettings->isEnabled(severity))
+    const Severity severity = getSeverity(argInfo);
+    if (!mSettings->severity.isEnabled(severity))
         return;
     std::ostringstream errmsg;
     errmsg << "%" << specifier << " in format string (no. " << numFormat << ") requires \'";
@@ -1790,41 +1819,41 @@ void CheckIO::invalidScanfArgTypeError_float(const Token* tok, nonneg int numFor
     errmsg << " *\' but the argument type is ";
     argumentType(errmsg, argInfo);
     errmsg << ".";
-    reportError(tok, severity, "invalidScanfArgType_float", errmsg.str(), CWE686, false);
+    reportError(tok, severity, "invalidScanfArgType_float", errmsg.str(), CWE686, Certainty::normal);
 }
 
 void CheckIO::invalidPrintfArgTypeError_s(const Token* tok, nonneg int numFormat, const ArgumentInfo* argInfo)
 {
-    const Severity::SeverityType severity = getSeverity(argInfo);
-    if (!mSettings->isEnabled(severity))
+    const Severity severity = getSeverity(argInfo);
+    if (!mSettings->severity.isEnabled(severity))
         return;
     std::ostringstream errmsg;
     errmsg << "%s in format string (no. " << numFormat << ") requires \'char *\' but the argument type is ";
     argumentType(errmsg, argInfo);
     errmsg << ".";
-    reportError(tok, severity, "invalidPrintfArgType_s", errmsg.str(), CWE686, false);
+    reportError(tok, severity, "invalidPrintfArgType_s", errmsg.str(), CWE686, Certainty::normal);
 }
 void CheckIO::invalidPrintfArgTypeError_n(const Token* tok, nonneg int numFormat, const ArgumentInfo* argInfo)
 {
-    const Severity::SeverityType severity = getSeverity(argInfo);
-    if (!mSettings->isEnabled(severity))
+    const Severity severity = getSeverity(argInfo);
+    if (!mSettings->severity.isEnabled(severity))
         return;
     std::ostringstream errmsg;
     errmsg << "%n in format string (no. " << numFormat << ") requires \'int *\' but the argument type is ";
     argumentType(errmsg, argInfo);
     errmsg << ".";
-    reportError(tok, severity, "invalidPrintfArgType_n", errmsg.str(), CWE686, false);
+    reportError(tok, severity, "invalidPrintfArgType_n", errmsg.str(), CWE686, Certainty::normal);
 }
 void CheckIO::invalidPrintfArgTypeError_p(const Token* tok, nonneg int numFormat, const ArgumentInfo* argInfo)
 {
-    const Severity::SeverityType severity = getSeverity(argInfo);
-    if (!mSettings->isEnabled(severity))
+    const Severity severity = getSeverity(argInfo);
+    if (!mSettings->severity.isEnabled(severity))
         return;
     std::ostringstream errmsg;
     errmsg << "%p in format string (no. " << numFormat << ") requires an address but the argument type is ";
     argumentType(errmsg, argInfo);
     errmsg << ".";
-    reportError(tok, severity, "invalidPrintfArgType_p", errmsg.str(), CWE686, false);
+    reportError(tok, severity, "invalidPrintfArgType_p", errmsg.str(), CWE686, Certainty::normal);
 }
 static void printfFormatType(std::ostream& os, const std::string& specifier, bool isUnsigned)
 {
@@ -1851,7 +1880,7 @@ static void printfFormatType(std::ostream& os, const std::string& specifier, boo
         else
             os << "intmax_t";
     } else if (specifier[0] == 'z') {
-        if (specifier[1] == 'd')
+        if (specifier[1] == 'd' || specifier[1] == 'i')
             os << "ssize_t";
         else
             os << "size_t";
@@ -1867,8 +1896,8 @@ static void printfFormatType(std::ostream& os, const std::string& specifier, boo
 
 void CheckIO::invalidPrintfArgTypeError_uint(const Token* tok, nonneg int numFormat, const std::string& specifier, const ArgumentInfo* argInfo)
 {
-    const Severity::SeverityType severity = getSeverity(argInfo);
-    if (!mSettings->isEnabled(severity))
+    const Severity severity = getSeverity(argInfo);
+    if (!mSettings->severity.isEnabled(severity))
         return;
     std::ostringstream errmsg;
     errmsg << "%" << specifier << " in format string (no. " << numFormat << ") requires ";
@@ -1876,13 +1905,13 @@ void CheckIO::invalidPrintfArgTypeError_uint(const Token* tok, nonneg int numFor
     errmsg << " but the argument type is ";
     argumentType(errmsg, argInfo);
     errmsg << ".";
-    reportError(tok, severity, "invalidPrintfArgType_uint", errmsg.str(), CWE686, false);
+    reportError(tok, severity, "invalidPrintfArgType_uint", errmsg.str(), CWE686, Certainty::normal);
 }
 
 void CheckIO::invalidPrintfArgTypeError_sint(const Token* tok, nonneg int numFormat, const std::string& specifier, const ArgumentInfo* argInfo)
 {
-    const Severity::SeverityType severity = getSeverity(argInfo);
-    if (!mSettings->isEnabled(severity))
+    const Severity severity = getSeverity(argInfo);
+    if (!mSettings->severity.isEnabled(severity))
         return;
     std::ostringstream errmsg;
     errmsg << "%" << specifier << " in format string (no. " << numFormat << ") requires ";
@@ -1890,12 +1919,12 @@ void CheckIO::invalidPrintfArgTypeError_sint(const Token* tok, nonneg int numFor
     errmsg << " but the argument type is ";
     argumentType(errmsg, argInfo);
     errmsg << ".";
-    reportError(tok, severity, "invalidPrintfArgType_sint", errmsg.str(), CWE686, false);
+    reportError(tok, severity, "invalidPrintfArgType_sint", errmsg.str(), CWE686, Certainty::normal);
 }
 void CheckIO::invalidPrintfArgTypeError_float(const Token* tok, nonneg int numFormat, const std::string& specifier, const ArgumentInfo* argInfo)
 {
-    const Severity::SeverityType severity = getSeverity(argInfo);
-    if (!mSettings->isEnabled(severity))
+    const Severity severity = getSeverity(argInfo);
+    if (!mSettings->severity.isEnabled(severity))
         return;
     std::ostringstream errmsg;
     errmsg << "%" << specifier << " in format string (no. " << numFormat << ") requires \'";
@@ -1904,10 +1933,10 @@ void CheckIO::invalidPrintfArgTypeError_float(const Token* tok, nonneg int numFo
     errmsg << "double\' but the argument type is ";
     argumentType(errmsg, argInfo);
     errmsg << ".";
-    reportError(tok, severity, "invalidPrintfArgType_float", errmsg.str(), CWE686, false);
+    reportError(tok, severity, "invalidPrintfArgType_float", errmsg.str(), CWE686, Certainty::normal);
 }
 
-Severity::SeverityType CheckIO::getSeverity(const CheckIO::ArgumentInfo *argInfo)
+Severity CheckIO::getSeverity(const CheckIO::ArgumentInfo *argInfo)
 {
     return (argInfo && argInfo->typeToken && !argInfo->typeToken->originalName().empty()) ? Severity::portability : Severity::warning;
 }
@@ -1934,7 +1963,7 @@ void CheckIO::argumentType(std::ostream& os, const ArgumentInfo * argInfo)
                     os << type->str() << "::";
                     type = type->tokAt(2);
                 }
-                type->stringify(os, false, true, false);
+                os << type->stringify(false, true, false);
                 if (type->strAt(1) == "*" && !argInfo->element)
                     os << " *";
                 else if (argInfo->variableInfo && !argInfo->element && argInfo->variableInfo->isArray())
@@ -1951,8 +1980,7 @@ void CheckIO::argumentType(std::ostream& os, const ArgumentInfo * argInfo)
                 os << type->originalName();
                 if (type->strAt(1) == "*" || argInfo->address)
                     os << " *";
-                os << " {aka ";
-                type->stringify(os, false, true, false);
+                os << " {aka " << type->stringify(false, true, false);
                 if (type->strAt(1) == "*" || argInfo->address)
                     os << " *";
                 os << "}";
@@ -1965,14 +1993,14 @@ void CheckIO::argumentType(std::ostream& os, const ArgumentInfo * argInfo)
 
 void CheckIO::invalidLengthModifierError(const Token* tok, nonneg int numFormat, const std::string& modifier)
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning) && !mSettings->isPremiumEnabled("invalidLengthModifierError"))
         return;
     std::ostringstream errmsg;
     errmsg << "'" << modifier << "' in format string (no. " << numFormat << ") is a length modifier and cannot be used without a conversion specifier.";
-    reportError(tok, Severity::warning, "invalidLengthModifierError", errmsg.str(), CWE704, false);
+    reportError(tok, Severity::warning, "invalidLengthModifierError", errmsg.str(), CWE704, Certainty::normal);
 }
 
-void CheckIO::invalidScanfFormatWidthError(const Token* tok, nonneg int numFormat, int width, const Variable *var, char c)
+void CheckIO::invalidScanfFormatWidthError(const Token* tok, nonneg int numFormat, int width, const Variable *var, const std::string& specifier)
 {
     MathLib::bigint arrlen = 0;
     std::string varname;
@@ -1984,14 +2012,52 @@ void CheckIO::invalidScanfFormatWidthError(const Token* tok, nonneg int numForma
 
     std::ostringstream errmsg;
     if (arrlen > width) {
-        if (tok != nullptr && (!mSettings->inconclusive || !mSettings->isEnabled(Settings::WARNING)))
+        if (tok != nullptr && (!mSettings->certainty.isEnabled(Certainty::inconclusive) || !mSettings->severity.isEnabled(Severity::warning)))
             return;
         errmsg << "Width " << width << " given in format string (no. " << numFormat << ") is smaller than destination buffer"
                << " '" << varname << "[" << arrlen << "]'.";
-        reportError(tok, Severity::warning, "invalidScanfFormatWidth_smaller", errmsg.str(), CWE(0U), true);
+        reportError(tok, Severity::warning, "invalidScanfFormatWidth_smaller", errmsg.str(), CWE(0U), Certainty::inconclusive);
     } else {
         errmsg << "Width " << width << " given in format string (no. " << numFormat << ") is larger than destination buffer '"
-               << varname << "[" << arrlen << "]', use %" << (c == 'c' ? arrlen : (arrlen - 1)) << c << " to prevent overflowing it.";
-        reportError(tok, Severity::error, "invalidScanfFormatWidth", errmsg.str(), CWE687, false);
+               << varname << "[" << arrlen << "]', use %" << (specifier == "c" ? arrlen : (arrlen - 1)) << specifier << " to prevent overflowing it.";
+        reportError(tok, Severity::error, "invalidScanfFormatWidth", errmsg.str(), CWE687, Certainty::normal);
     }
 }
+
+void CheckIO::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    CheckIO checkIO(&tokenizer, &tokenizer.getSettings(), errorLogger);
+
+    checkIO.checkWrongPrintfScanfArguments();
+    checkIO.checkCoutCerrMisusage();
+    checkIO.checkFileUsage();
+    checkIO.invalidScanf();
+}
+
+void CheckIO::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const
+{
+    CheckIO c(nullptr, settings, errorLogger);
+    c.coutCerrMisusageError(nullptr,  "cout");
+    c.fflushOnInputStreamError(nullptr,  "stdin");
+    c.ioWithoutPositioningError(nullptr);
+    c.readWriteOnlyFileError(nullptr);
+    c.writeReadOnlyFileError(nullptr);
+    c.useClosedFileError(nullptr);
+    c.seekOnAppendedFileError(nullptr);
+    c.incompatibleFileOpenError(nullptr, "tmp");
+    c.invalidScanfError(nullptr);
+    c.wrongPrintfScanfArgumentsError(nullptr, "printf",3,2);
+    c.invalidScanfArgTypeError_s(nullptr,  1, "s", nullptr);
+    c.invalidScanfArgTypeError_int(nullptr,  1, "d", nullptr, false);
+    c.invalidScanfArgTypeError_float(nullptr,  1, "f", nullptr);
+    c.invalidPrintfArgTypeError_s(nullptr,  1, nullptr);
+    c.invalidPrintfArgTypeError_n(nullptr,  1, nullptr);
+    c.invalidPrintfArgTypeError_p(nullptr,  1, nullptr);
+    c.invalidPrintfArgTypeError_uint(nullptr,  1, "u", nullptr);
+    c.invalidPrintfArgTypeError_sint(nullptr,  1, "i", nullptr);
+    c.invalidPrintfArgTypeError_float(nullptr,  1, "f", nullptr);
+    c.invalidLengthModifierError(nullptr,  1, "I");
+    c.invalidScanfFormatWidthError(nullptr,  10, 5, nullptr, "s");
+    c.invalidScanfFormatWidthError(nullptr,  99, -1, nullptr, "s");
+    c.wrongPrintfScanfPosixParameterPositionError(nullptr,  "printf", 2, 1);
+}
diff --git a/lib/checkio.h b/lib/checkio.h
index fe63d18c58f..e37a942770b 100644
--- a/lib/checkio.h
+++ b/lib/checkio.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,41 +23,37 @@
 
 #include "check.h"
 #include "config.h"
-#include "errorlogger.h"
 
+#include <cstdint>
 #include <ostream>
 #include <string>
 
 class Function;
 class Settings;
 class Token;
-class Tokenizer;
 class Variable;
+class ErrorLogger;
+class Tokenizer;
+enum class Severity : std::uint8_t;
 
 /// @addtogroup Checks
 /// @{
 
 /** @brief %Check input output operations. */
 class CPPCHECKLIB CheckIO : public Check {
+    friend class TestIO;
+
 public:
     /** @brief This constructor is used when registering CheckIO */
-    CheckIO() : Check(myName()) {
-    }
+    CheckIO() : Check(myName()) {}
 
+private:
     /** @brief This constructor is used when running checks. */
     CheckIO(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger) {}
 
     /** @brief Run checks on the normal token list */
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        CheckIO checkIO(tokenizer, settings, errorLogger);
-
-        checkIO.checkWrongPrintfScanfArguments();
-        checkIO.checkCoutCerrMisusage();
-        checkIO.checkFileUsage();
-        checkIO.invalidScanf();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     /** @brief %Check for missusage of std::cout */
     void checkCoutCerrMisusage();
@@ -71,38 +67,36 @@ class CPPCHECKLIB CheckIO : public Check {
     /** @brief %Checks type and number of arguments given to functions like printf or scanf*/
     void checkWrongPrintfScanfArguments();
 
-private:
     class ArgumentInfo {
     public:
-        ArgumentInfo(const Token *arg, const Settings *settings, bool _isCPP);
+        ArgumentInfo(const Token *arg, const Settings &settings, bool _isCPP);
         ~ArgumentInfo();
 
+        ArgumentInfo(const ArgumentInfo &) = delete;
+        ArgumentInfo& operator= (const ArgumentInfo &) = delete;
+
         bool isArrayOrPointer() const;
         bool isComplexType() const;
         bool isKnownType() const;
         bool isStdVectorOrString();
         bool isStdContainer(const Token *tok);
-        bool isLibraryType(const Settings *settings) const;
-
-        const Variable *variableInfo;
-        const Token *typeToken;
-        const Function *functionInfo;
-        Token *tempToken;
-        bool element;
-        bool _template;
-        bool address;
-        bool isCPP;
-
-    private:
-        ArgumentInfo(const ArgumentInfo &); // not implemented
-        ArgumentInfo operator = (const ArgumentInfo &); // not implemented
+        bool isLibraryType(const Settings &settings) const;
+
+        const Variable* variableInfo{};
+        const Token* typeToken{};
+        const Function* functionInfo{};
+        Token* tempToken{};
+        bool element{};
+        bool _template{};
+        bool address{};
+        bool isCPP{};
     };
 
-    void checkFormatString(const Token * const tok,
-                           const Token * const formatStringTok,
-                           const Token *       argListTok,
-                           const bool scan,
-                           const bool scanf_s);
+    void checkFormatString(const Token * tok,
+                           const Token * formatStringTok,
+                           const Token * argListTok,
+                           bool scan,
+                           bool scanf_s);
 
     // Reporting errors..
     void coutCerrMisusageError(const Token* tok, const std::string& streamName);
@@ -112,13 +106,14 @@ class CPPCHECKLIB CheckIO : public Check {
     void writeReadOnlyFileError(const Token *tok);
     void useClosedFileError(const Token *tok);
     void seekOnAppendedFileError(const Token *tok);
+    void incompatibleFileOpenError(const Token *tok, const std::string &filename);
     void invalidScanfError(const Token *tok);
     void wrongPrintfScanfArgumentsError(const Token* tok,
                                         const std::string &functionName,
                                         nonneg int numFormat,
                                         nonneg int numFunction);
     void wrongPrintfScanfPosixParameterPositionError(const Token* tok, const std::string& functionName,
-            nonneg int index, nonneg int numFunction);
+                                                     nonneg int index, nonneg int numFunction);
     void invalidScanfArgTypeError_s(const Token* tok, nonneg int numFormat, const std::string& specifier, const ArgumentInfo* argInfo);
     void invalidScanfArgTypeError_int(const Token* tok, nonneg int numFormat, const std::string& specifier, const ArgumentInfo* argInfo, bool isUnsigned);
     void invalidScanfArgTypeError_float(const Token* tok, nonneg int numFormat, const std::string& specifier, const ArgumentInfo* argInfo);
@@ -129,42 +124,17 @@ class CPPCHECKLIB CheckIO : public Check {
     void invalidPrintfArgTypeError_sint(const Token* tok, nonneg int numFormat, const std::string& specifier, const ArgumentInfo* argInfo);
     void invalidPrintfArgTypeError_float(const Token* tok, nonneg int numFormat, const std::string& specifier, const ArgumentInfo* argInfo);
     void invalidLengthModifierError(const Token* tok, nonneg int numFormat, const std::string& modifier);
-    void invalidScanfFormatWidthError(const Token* tok, nonneg int numFormat, int width, const Variable *var, char c);
+    void invalidScanfFormatWidthError(const Token* tok, nonneg int numFormat, int width, const Variable *var, const std::string& specifier);
     static void argumentType(std::ostream & os, const ArgumentInfo * argInfo);
-    static Severity::SeverityType getSeverity(const ArgumentInfo *argInfo);
-
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        CheckIO c(nullptr, settings, errorLogger);
-
-        c.coutCerrMisusageError(nullptr,  "cout");
-        c.fflushOnInputStreamError(nullptr,  "stdin");
-        c.ioWithoutPositioningError(nullptr);
-        c.readWriteOnlyFileError(nullptr);
-        c.writeReadOnlyFileError(nullptr);
-        c.useClosedFileError(nullptr);
-        c.seekOnAppendedFileError(nullptr);
-        c.invalidScanfError(nullptr);
-        c.wrongPrintfScanfArgumentsError(nullptr, "printf",3,2);
-        c.invalidScanfArgTypeError_s(nullptr,  1, "s", nullptr);
-        c.invalidScanfArgTypeError_int(nullptr,  1, "d", nullptr, false);
-        c.invalidScanfArgTypeError_float(nullptr,  1, "f", nullptr);
-        c.invalidPrintfArgTypeError_s(nullptr,  1, nullptr);
-        c.invalidPrintfArgTypeError_n(nullptr,  1, nullptr);
-        c.invalidPrintfArgTypeError_p(nullptr,  1, nullptr);
-        c.invalidPrintfArgTypeError_uint(nullptr,  1, "u", nullptr);
-        c.invalidPrintfArgTypeError_sint(nullptr,  1, "i", nullptr);
-        c.invalidPrintfArgTypeError_float(nullptr,  1, "f", nullptr);
-        c.invalidLengthModifierError(nullptr,  1, "I");
-        c.invalidScanfFormatWidthError(nullptr,  10, 5, nullptr, 's');
-        c.invalidScanfFormatWidthError(nullptr,  99, -1, nullptr, 's');
-        c.wrongPrintfScanfPosixParameterPositionError(nullptr,  "printf", 2, 1);
-    }
+    static Severity getSeverity(const ArgumentInfo *argInfo);
+
+    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const override;
 
     static std::string myName() {
         return "IO using format string";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Check format string input/output operations.\n"
                "- Bad usage of the function 'sprintf' (overlapping data)\n"
                "- Missing or wrong width specifiers in 'scanf' format string\n"
@@ -172,6 +142,7 @@ class CPPCHECKLIB CheckIO : public Check {
                "- File input/output without positioning results in undefined behaviour\n"
                "- Read to a file that has only been opened for writing (or vice versa)\n"
                "- Repositioning operation on a file opened in append mode\n"
+               "- The same file can't be open for read and write at the same time on different streams\n"
                "- Using fflush() on an input stream\n"
                "- Invalid usage of output stream. For example: 'std::cout << std::cout;'\n"
                "- Wrong number of arguments given to 'printf' or 'scanf;'\n";
diff --git a/lib/checkleakautovar.cpp b/lib/checkleakautovar.cpp
index 6fcdfc4a8e1..803ea9967a3 100644
--- a/lib/checkleakautovar.cpp
+++ b/lib/checkleakautovar.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -25,19 +25,23 @@
 #include "astutils.h"
 #include "checkmemoryleak.h"  // <- CheckMemoryLeak::memoryLeak
 #include "checknullpointer.h" // <- CheckNullPointer::isPointerDeRef
-#include "errorlogger.h"
 #include "mathlib.h"
+#include "platform.h"
 #include "settings.h"
+#include "errortypes.h"
 #include "symboldatabase.h"
 #include "token.h"
 #include "tokenize.h"
-#include "valueflow.h"
+#include "tokenlist.h"
+#include "utils.h"
+#include "vfvalue.h"
 
+#include <algorithm>
+#include <array>
 #include <cstddef>
-#include <iostream>
+#include <deque>
 #include <list>
-#include <stack>
-#include <utility>
+#include <vector>
 
 //---------------------------------------------------------------------------
 
@@ -50,13 +54,32 @@ static const CWE CWE672(672U);
 static const CWE CWE415(415U);
 
 // Hardcoded allocation types (not from library)
-static const int NEW_ARRAY = -2;
-static const int NEW = -1;
+static constexpr int NEW_ARRAY = -2;
+static constexpr int NEW = -1;
 
+static const std::array<std::pair<std::string, std::string>, 4> alloc_failed_conds {{{"==", "0"}, {"<", "0"}, {"==", "-1"}, {"<=", "-1"}}};
+static const std::array<std::pair<std::string, std::string>, 5> alloc_success_conds {{{"!=", "0"}, {">", "0"}, {"!=", "-1"}, {">=", "0"}, {">", "-1"}}};
+
+static bool isAutoDeallocType(const Type* type) {
+    if (!type || !type->classScope)
+        return true;
+    if (type->classScope->numConstructors > 0)
+        return true;
+    const std::list<Variable>& varlist = type->classScope->varlist;
+    if (std::any_of(varlist.begin(), varlist.end(), [](const Variable& v) {
+        return !v.valueType() || (!v.valueType()->isPrimitive() && !v.valueType()->container);
+    }))
+        return true;
+    if (std::none_of(type->derivedFrom.cbegin(), type->derivedFrom.cend(), [](const Type::BaseInfo& bi) {
+        return isAutoDeallocType(bi.type);
+    }))
+        return false;
+    return true;
+}
 
 /**
  * @brief Is variable type some class with automatic deallocation?
- * @param vartok variable token
+ * @param var variable token
  * @return true unless it can be seen there is no automatic deallocation
  */
 static bool isAutoDealloc(const Variable *var)
@@ -66,65 +89,30 @@ static bool isAutoDealloc(const Variable *var)
 
     // return false if the type is a simple record type without side effects
     // a type that has no side effects (no constructors and no members with constructors)
-    /** @todo false negative: check base class for side effects */
     /** @todo false negative: check constructors for side effects */
-    if (var->typeScope() && var->typeScope()->numConstructors == 0 &&
-        (var->typeScope()->varlist.empty() || var->type()->needInitialization == Type::NeedInitialization::True) &&
-        var->type()->derivedFrom.empty())
-        return false;
-
-    return true;
+    return isAutoDeallocType(var->type());
 }
 
-//---------------------------------------------------------------------------
-
-void VarInfo::print()
+template<std::size_t N>
+static bool isVarTokComparison(const Token * tok, const Token ** vartok,
+                               const std::array<std::pair<std::string, std::string>, N>& ops)
 {
-    std::cout << "size=" << alloctype.size() << std::endl;
-    for (std::map<int, AllocInfo>::const_iterator it = alloctype.begin(); it != alloctype.end(); ++it) {
-        std::string strusage;
-        const std::map<int, std::string>::const_iterator use =
-            possibleUsage.find(it->first);
-        if (use != possibleUsage.end())
-            strusage = use->second;
-
-        std::string status;
-        switch (it->second.status) {
-        case OWNED:
-            status = "owned";
-            break;
-        case DEALLOC:
-            status = "dealloc";
-            break;
-        case ALLOC:
-            status = "alloc";
-            break;
-        case NOALLOC:
-            status = "noalloc";
-            break;
-        default:
-            status = "?";
-            break;
-        };
-
-        std::cout << "status=" << status << " "
-                  << "alloctype='" << it->second.type << "' "
-                  << "possibleUsage='" << strusage << "' "
-                  << "conditionalAlloc=" << (conditionalAlloc.find(it->first) != conditionalAlloc.end() ? "yes" : "no") << " "
-                  << "referenced=" << (referenced.find(it->first) != referenced.end() ? "yes" : "no") << " "
-                  << std::endl;
-    }
+    return std::any_of(ops.cbegin(), ops.cend(), [&](const std::pair<std::string, std::string>& op) {
+        return astIsVariableComparison(tok, op.first, op.second, vartok);
+    });
 }
 
-void VarInfo::possibleUsageAll(const std::string &functionName)
+//---------------------------------------------------------------------------
+
+void VarInfo::possibleUsageAll(const std::pair<const Token*, Usage>& functionUsage)
 {
     possibleUsage.clear();
-    for (std::map<int, AllocInfo>::const_iterator it = alloctype.begin(); it != alloctype.end(); ++it)
-        possibleUsage[it->first] = functionName;
+    for (auto it = alloctype.cbegin(); it != alloctype.cend(); ++it)
+        possibleUsage[it->first] = functionUsage;
 }
 
 
-void CheckLeakAutoVar::leakError(const Token *tok, const std::string &varname, int type)
+void CheckLeakAutoVar::leakError(const Token *tok, const std::string &varname, int type) const
 {
     const CheckMemoryLeak checkmemleak(mTokenizer, mErrorLogger, mSettings);
     if (Library::isresource(type))
@@ -133,14 +121,14 @@ void CheckLeakAutoVar::leakError(const Token *tok, const std::string &varname, i
         checkmemleak.memleakError(tok, varname);
 }
 
-void CheckLeakAutoVar::mismatchError(const Token *deallocTok, const Token *allocTok, const std::string &varname)
+void CheckLeakAutoVar::mismatchError(const Token *deallocTok, const Token *allocTok, const std::string &varname) const
 {
     const CheckMemoryLeak c(mTokenizer, mErrorLogger, mSettings);
     const std::list<const Token *> callstack = { allocTok, deallocTok };
     c.mismatchAllocDealloc(callstack, varname);
 }
 
-void CheckLeakAutoVar::deallocUseError(const Token *tok, const std::string &varname)
+void CheckLeakAutoVar::deallocUseError(const Token *tok, const std::string &varname) const
 {
     const CheckMemoryLeak c(mTokenizer, mErrorLogger, mSettings);
     c.deallocuseError(tok, varname);
@@ -149,16 +137,20 @@ void CheckLeakAutoVar::deallocUseError(const Token *tok, const std::string &varn
 void CheckLeakAutoVar::deallocReturnError(const Token *tok, const Token *deallocTok, const std::string &varname)
 {
     const std::list<const Token *> locations = { deallocTok, tok };
-    reportError(locations, Severity::error, "deallocret", "$symbol:" + varname + "\nReturning/dereferencing '$symbol' after it is deallocated / released", CWE672, false);
+    reportError(locations, Severity::error, "deallocret", "$symbol:" + varname + "\nReturning/dereferencing '$symbol' after it is deallocated / released", CWE672, Certainty::normal);
 }
 
-void CheckLeakAutoVar::configurationInfo(const Token* tok, const std::string &functionName)
+void CheckLeakAutoVar::configurationInfo(const Token* tok, const std::pair<const Token*, VarInfo::Usage>& functionUsage)
 {
-    if (mSettings->checkLibrary && mSettings->isEnabled(Settings::INFORMATION)) {
+    if (mSettings->checkLibrary && functionUsage.second == VarInfo::USED &&
+        (!functionUsage.first || !functionUsage.first->function() || !functionUsage.first->function()->hasBody())) {
+        std::string funcStr = functionUsage.first ? mSettings->library.getFunctionName(functionUsage.first) : "f";
+        if (funcStr.empty())
+            funcStr = "unknown::" + functionUsage.first->str();
         reportError(tok,
                     Severity::information,
                     "checkLibraryUseIgnore",
-                    "--check-library: Function " + functionName + "() should have <use>/<leak-ignore> configuration");
+                    "--check-library: Function " + funcStr + "() should have <use>/<leak-ignore> configuration");
     }
 }
 
@@ -167,14 +159,19 @@ void CheckLeakAutoVar::doubleFreeError(const Token *tok, const Token *prevFreeTo
     const std::list<const Token *> locations = { prevFreeTok, tok };
 
     if (Library::isresource(type))
-        reportError(locations, Severity::error, "doubleFree", "$symbol:" + varname + "\nResource handle '$symbol' freed twice.", CWE415, false);
+        reportError(locations, Severity::error, "doubleFree", "$symbol:" + varname + "\nResource handle '$symbol' freed twice.", CWE415, Certainty::normal);
     else
-        reportError(locations, Severity::error, "doubleFree", "$symbol:" + varname + "\nMemory pointed to by '$symbol' is freed twice.", CWE415, false);
+        reportError(locations, Severity::error, "doubleFree", "$symbol:" + varname + "\nMemory pointed to by '$symbol' is freed twice.", CWE415, Certainty::normal);
 }
 
 
 void CheckLeakAutoVar::check()
 {
+    if (mSettings->clang)
+        return;
+
+    logChecker("CheckLeakAutoVar::check"); // notclang
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
     // Local variables that are known to be non-zero.
@@ -188,23 +185,7 @@ void CheckLeakAutoVar::check()
         // Empty variable info
         VarInfo varInfo;
 
-        checkScope(scope->bodyStart, &varInfo, notzero, 0);
-
-        varInfo.conditionalAlloc.clear();
-
-        // Clear reference arguments from varInfo..
-        std::map<int, VarInfo::AllocInfo>::iterator it = varInfo.alloctype.begin();
-        while (it != varInfo.alloctype.end()) {
-            const Variable *var = symbolDatabase->getVariableFromVarId(it->first);
-            if (!var ||
-                (var->isArgument() && var->isReference()) ||
-                (!var->isArgument() && !var->isLocal()))
-                varInfo.alloctype.erase(it++);
-            else
-                ++it;
-        }
-
-        ret(scope->bodyEnd, varInfo);
+        checkScope(scope->bodyStart, varInfo, notzero, 0);
     }
 }
 
@@ -212,11 +193,20 @@ static bool isVarUsedInTree(const Token *tok, nonneg int varid)
 {
     if (!tok)
         return false;
-    if (tok->varId() == varid)
-        return true;
-    if (tok->str() == "(" && Token::simpleMatch(tok->astOperand1(), "sizeof"))
-        return false;
-    return isVarUsedInTree(tok->astOperand1(), varid) || isVarUsedInTree(tok->astOperand2(), varid);
+    std::deque<const Token*> nodes{ tok };
+    while (!nodes.empty()) {
+        const Token* node = nodes.front();
+        if (node->varId() == varid)
+            return true;
+        if (node->str() != "(" || !Token::simpleMatch(node->astOperand1(), "sizeof")) {
+            if (node->astOperand1())
+                nodes.emplace_back(node->astOperand1());
+            if (node->astOperand2())
+                nodes.emplace_back(node->astOperand2());
+        }
+        nodes.pop_front();
+    }
+    return false;
 }
 
 static bool isPointerReleased(const Token *startToken, const Token *endToken, nonneg int varid)
@@ -232,7 +222,7 @@ static bool isPointerReleased(const Token *startToken, const Token *endToken, no
     return false;
 }
 
-static bool isLocalVarNoAutoDealloc(const Token *varTok, const bool isCpp)
+static bool isLocalVarNoAutoDealloc(const Token *varTok)
 {
     // not a local variable nor argument?
     const Variable *var = varTok->variable();
@@ -242,13 +232,13 @@ static bool isLocalVarNoAutoDealloc(const Token *varTok, const bool isCpp)
         return false;
 
     // Don't check reference variables
-    if (var->isReference())
+    if (var->isReference() && !var->isArgument())
         return false;
 
     // non-pod variable
-    if (isCpp) {
+    if (varTok->isCpp()) {
         // Possibly automatically deallocated memory
-        if (isAutoDealloc(var) && Token::Match(varTok, "%var% = new"))
+        if (isAutoDealloc(var) && Token::Match(varTok, "%var% [=({] new"))
             return false;
         if (!var->isPointer() && !var->typeStartToken()->isStandardType())
             return false;
@@ -257,16 +247,16 @@ static bool isLocalVarNoAutoDealloc(const Token *varTok, const bool isCpp)
 }
 
 /** checks if nameToken is a name of a function in a function call:
-*     func(arg)
-* or
-*     func<temp1_arg>(arg)
-* @param nameToken Function name token
-* @return opening parenthesis token or NULL if not a function call
-*/
+ *     func(arg)
+ * or
+ *     func<temp1_arg>(arg)
+ * @param nameToken Function name token
+ * @return opening parenthesis token or NULL if not a function call
+ */
 
 static const Token * isFunctionCall(const Token * nameToken)
 {
-    if (nameToken->isName()) {
+    if (!nameToken->isStandardType() && nameToken->isName()) {
         nameToken = nameToken->next();
         // check if function is a template
         if (nameToken && nameToken->link() && nameToken->str() == "<") {
@@ -274,7 +264,7 @@ static const Token * isFunctionCall(const Token * nameToken)
             nameToken = nameToken->link()->next();
         }
         // check for '('
-        if (nameToken && nameToken->link() && nameToken->str() == "(") {
+        if (nameToken && nameToken->link() && !nameToken->isCast() && nameToken->str() == "(") {
             // returning opening parenthesis pointer
             return nameToken;
         }
@@ -282,22 +272,61 @@ static const Token * isFunctionCall(const Token * nameToken)
     return nullptr;
 }
 
-void CheckLeakAutoVar::checkScope(const Token * const startToken,
-                                  VarInfo *varInfo,
+static const Token* getOutparamAllocation(const Token* tok, const Settings& settings)
+{
+    if (!tok)
+        return nullptr;
+    int argn{};
+    const Token* ftok = getTokenArgumentFunction(tok, argn);
+    if (!ftok)
+        return nullptr;
+    if (const Library::AllocFunc* allocFunc = settings.library.getAllocFuncInfo(ftok)) {
+        if (allocFunc->arg == argn + 1)
+            return ftok;
+    }
+    return nullptr;
+}
+
+static const Token* getReturnValueFromOutparamAlloc(const Token* alloc, const Settings& settings)
+{
+    if (const Token* ftok = getOutparamAllocation(alloc, settings)) {
+        if (Token::simpleMatch(ftok->astParent()->astParent(), "="))
+            return ftok->next()->astParent()->astOperand1();
+    }
+    return nullptr;
+}
+
+static std::vector<const Token*> getComparisonTokens(const Token* tok)
+{
+    std::vector<const Token*> result{ tok };
+    if (tok->hasKnownValue(ValueFlow::Value::ValueType::SYMBOLIC))
+        result.push_back(tok->getKnownValue(ValueFlow::Value::ValueType::SYMBOLIC)->tokvalue);
+    for (const Token* op : { tok->astOperand1(), tok->astOperand2() }) {
+        if (op && op->hasKnownValue(ValueFlow::Value::ValueType::SYMBOLIC))
+            result.push_back(op->getKnownValue(ValueFlow::Value::ValueType::SYMBOLIC)->tokvalue);
+    }
+    return result;
+}
+
+bool CheckLeakAutoVar::checkScope(const Token * const startToken,
+                                  VarInfo &varInfo,
                                   std::set<int> notzero,
                                   nonneg int recursiveCount)
 {
 #if ASAN
     static const nonneg int recursiveLimit = 300;
+#elif defined(__MINGW32__)
+    // testrunner crashes with stack overflow in CI
+    static constexpr nonneg int recursiveLimit = 600;
 #else
-    static const nonneg int recursiveLimit = 1000;
+    static constexpr nonneg int recursiveLimit = 1000;
 #endif
     if (++recursiveCount > recursiveLimit)    // maximum number of "else if ()"
         throw InternalError(startToken, "Internal limit: CheckLeakAutoVar::checkScope() Maximum recursive count of 1000 reached.", InternalError::LIMIT);
 
-    std::map<int, VarInfo::AllocInfo> &alloctype = varInfo->alloctype;
-    std::map<int, std::string> &possibleUsage = varInfo->possibleUsage;
-    const std::set<int> conditionalAlloc(varInfo->conditionalAlloc);
+    std::map<int, VarInfo::AllocInfo> &alloctype = varInfo.alloctype;
+    auto& possibleUsage = varInfo.possibleUsage;
+    const std::set<int> conditionalAlloc(varInfo.conditionalAlloc);
 
     // Parse all tokens
     const Token * const endToken = startToken->link();
@@ -310,7 +339,8 @@ void CheckLeakAutoVar::checkScope(const Token * const startToken,
 
         // check each token
         {
-            const Token * nextTok = checkTokenInsideExpression(tok, varInfo);
+            const bool isInit = Token::Match(tok, "%var% {|(") && tok->variable() && tok == tok->variable()->nameToken() && tok->variable()->isPointer();
+            const Token * nextTok = isInit ? nullptr : checkTokenInsideExpression(tok, varInfo);
             if (nextTok) {
                 tok = nextTok;
                 continue;
@@ -319,15 +349,33 @@ void CheckLeakAutoVar::checkScope(const Token * const startToken,
 
 
         // look for end of statement
-        if (!Token::Match(tok, "[;{},]") || Token::Match(tok->next(), "[;{},]"))
+        const bool isInit = Token::Match(tok->tokAt(-1), "%var% {|(") && tok->tokAt(-1)->variable() && tok->tokAt(-1) == tok->tokAt(-1)->variable()->nameToken();
+        if ((!Token::Match(tok, "[;{},]") || Token::Match(tok->next(), "[;{},]")) && !(isInit && tok->str() == "("))
             continue;
 
-        tok = tok->next();
+        if (Token::Match(tok, "[;{},] %var% ["))
+            continue;
+
+        if (!isInit)
+            tok = tok->next();
         if (!tok || tok == endToken)
             break;
 
+        if (Token::Match(tok, "%name% (") && isUnevaluated(tok)) {
+            tok = tok->linkAt(1);
+            continue;
+        }
+
+        if (Token::Match(tok, "const %type%"))
+            tok = tok->tokAt(2);
+
+        while (!isInit && tok->str() == "(")
+            tok = tok->next();
+        while (tok->isUnaryOp("*") && tok->astOperand1()->isUnaryOp("&"))
+            tok = tok->astOperand1()->astOperand1();
+
         // parse statement, skip to last member
-        const Token *varTok = tok;
+        const Token* varTok = isInit ? tok->tokAt(-1) : tok;
         while (Token::Match(varTok, "%name% ::|. %name% !!("))
             varTok = varTok->tokAt(2);
 
@@ -337,23 +385,80 @@ void CheckLeakAutoVar::checkScope(const Token * const startToken,
         while (Token::Match(ftok, "%name% :: %name%"))
             ftok = ftok->tokAt(2);
 
+        // bailout for variable passed to library function with out parameter
+        if (const Library::Function *libFunc = mSettings->library.getFunction(ftok)) {
+            using ArgumentChecks = Library::ArgumentChecks;
+            using Direction = ArgumentChecks::Direction;
+            const std::vector<const Token *> args = getArguments(ftok);
+            const std::map<int, ArgumentChecks> &argChecks = libFunc->argumentChecks;
+            bool hasOutParam = std::any_of(argChecks.cbegin(), argChecks.cend(), [](const std::pair<int, ArgumentChecks> &pair) {
+                return std::any_of(pair.second.direction.cbegin(), pair.second.direction.cend(), [](const Direction dir) {
+                    return dir == Direction::DIR_OUT;
+                });
+            });
+            if (hasOutParam) {
+                for (int i = 0; i < args.size(); i++) {
+                    if (!argChecks.count(i + 1))
+                        continue;
+                    const ArgumentChecks argCheck = argChecks.at(i + 1);
+                    const bool isInParam = std::any_of(argCheck.direction.cbegin(), argCheck.direction.cend(), [&](const Direction dir) {
+                        return dir == Direction::DIR_IN;
+                    });
+                    if (!isInParam)
+                        continue;
+                    const Token *inTok = args[i];
+                    int indirect = 0;
+                    while (inTok->isUnaryOp("&")) {
+                        inTok = inTok->astOperand1();
+                        indirect++;
+                    }
+                    if (inTok->isVariable() && indirect) {
+                        varInfo.erase(inTok->varId());
+                    }
+                }
+            }
+        }
+
+        if (tok->isCpp11init() == Token::Cpp11init::CPP11INIT) {
+            const Token *newTok = tok->astOperand1();
+            const Token *oldTok = tok->astOperand2();
+            if (newTok && newTok->varId() && oldTok && oldTok->varId()) {
+                leakIfAllocated(newTok, varInfo);
+                // no multivariable checking currently => bail out for rhs variables
+                varInfo.erase(oldTok->varId());
+            }
+        }
+
+        auto isAssignment = [](const Token* varTok) -> const Token* {
+            if (varTok->varId()) {
+                const Token* top = varTok;
+                while (top->astParent()) {
+                    top = top->astParent();
+                    if (!Token::Match(top, "(|*|&|."))
+                        break;
+                }
+                if (top->str() == "=" && succeeds(top, varTok))
+                    return top;
+            }
+            return nullptr;
+        };
+
         // assignment..
-        if (Token::Match(varTok, "%var% =")) {
-            const Token* const tokAssignOp = varTok->next();
+        if (const Token* const tokAssignOp = isInit ? varTok : isAssignment(varTok)) {
 
             // taking address of another variable..
-            if (Token::Match(tokAssignOp, "= %var% [+;]")) {
+            if (Token::Match(tokAssignOp, "= %var% +|;|?|%comp%")) {
                 if (varTok->tokAt(2)->varId() != varTok->varId()) {
                     // If variable points at allocated memory => error
-                    leakIfAllocated(varTok, *varInfo);
+                    leakIfAllocated(varTok, varInfo);
 
                     // no multivariable checking currently => bail out for rhs variables
                     for (const Token *tok2 = varTok; tok2; tok2 = tok2->next()) {
                         if (tok2->str() == ";") {
                             break;
                         }
-                        if (tok2->varId()) {
-                            varInfo->erase(tok2->varId());
+                        if (tok2->varId() && !Token::Match(tok2->astParent(), "%comp%|!")) {
+                            varInfo.erase(tok2->varId());
                         }
                     }
                 }
@@ -370,10 +475,10 @@ void CheckLeakAutoVar::checkScope(const Token * const startToken,
 
             // Variable has already been allocated => error
             if (conditionalAlloc.find(varTok->varId()) == conditionalAlloc.end())
-                leakIfAllocated(varTok, *varInfo);
-            varInfo->erase(varTok->varId());
+                leakIfAllocated(varTok, varInfo);
+            varInfo.erase(varTok->varId());
 
-            if (!isLocalVarNoAutoDealloc(varTok, mTokenizer->isCPP()))
+            if (!isLocalVarNoAutoDealloc(varTok))
                 continue;
 
             // allocation?
@@ -388,9 +493,9 @@ void CheckLeakAutoVar::checkScope(const Token * const startToken,
                 }
 
                 changeAllocStatusIfRealloc(alloctype, fTok, varTok);
-            } else if (mTokenizer->isCPP() && Token::Match(varTok->tokAt(2), "new !!(")) {
+            } else if (varTok->isCpp() && Token::Match(varTok->tokAt(2), "new !!(")) {
                 const Token* tok2 = varTok->tokAt(2)->astOperand1();
-                const bool arrayNew = (tok2 && (tok2->str() == "[" || (tok2->str() == "(" && tok2->astOperand1() && tok2->astOperand1()->str() == "[")));
+                const bool arrayNew = (tok2 && (tok2->str() == "[" || (Token::Match(tok2, "(|{") && tok2->astOperand1() && tok2->astOperand1()->str() == "[")));
                 VarInfo::AllocInfo& varAlloc = alloctype[varTok->varId()];
                 varAlloc.type = arrayNew ? NEW_ARRAY : NEW;
                 varAlloc.status = VarInfo::ALLOC;
@@ -399,7 +504,7 @@ void CheckLeakAutoVar::checkScope(const Token * const startToken,
 
             // Assigning non-zero value variable. It might be used to
             // track the execution for a later if condition.
-            if (Token::Match(varTok->tokAt(2), "%num% ;") && MathLib::toLongNumber(varTok->strAt(2)) != 0)
+            if (Token::Match(varTok->tokAt(2), "%num% ;") && MathLib::toBigNumber(varTok->tokAt(2)) != 0)
                 notzero.insert(varTok->varId());
             else if (Token::Match(varTok->tokAt(2), "- %type% ;") && varTok->tokAt(3)->isUpperCaseName())
                 notzero.insert(varTok->varId());
@@ -409,35 +514,54 @@ void CheckLeakAutoVar::checkScope(const Token * const startToken,
 
         // if/else
         else if (Token::simpleMatch(tok, "if (")) {
+
+            bool skipIfBlock = false;
+            bool skipElseBlock = false;
+            const Token *condTok = tok->astSibling();
+
+            if (condTok && condTok->hasKnownIntValue()) {
+                skipIfBlock = !condTok->getKnownIntValue();
+                skipElseBlock = !skipIfBlock;
+            }
+
             // Parse function calls inside the condition
 
             const Token * closingParenthesis = tok->linkAt(1);
             for (const Token *innerTok = tok->tokAt(2); innerTok && innerTok != closingParenthesis; innerTok = innerTok->next()) {
+                if (isUnevaluated(innerTok)) {
+                    innerTok = innerTok->linkAt(1);
+                    continue;
+                }
                 // TODO: replace with checkTokenInsideExpression()
+                const Token* const openingPar = isFunctionCall(innerTok);
+                if (!openingPar)
+                    checkTokenInsideExpression(innerTok, varInfo);
 
-                if (!isLocalVarNoAutoDealloc(innerTok, mTokenizer->isCPP()))
+                if (!isLocalVarNoAutoDealloc(innerTok))
                     continue;
 
-                if (Token::Match(innerTok, "%var% =") && innerTok->astParent() == innerTok->next()) {
+                // Check assignments in the if-statement. Skip multiple assignments since we don't track those
+                if (Token::Match(innerTok, "%var% =") && innerTok->astParent() == innerTok->next() &&
+                    !(innerTok->next()->astParent() && innerTok->next()->astParent()->isAssignmentOp())) {
                     // allocation?
                     // right ast part (after `=` operator)
                     const Token* tokRightAstOperand = innerTok->next()->astOperand2();
                     while (tokRightAstOperand && tokRightAstOperand->isCast())
                         tokRightAstOperand = tokRightAstOperand->astOperand2() ? tokRightAstOperand->astOperand2() : tokRightAstOperand->astOperand1();
                     if (tokRightAstOperand && Token::Match(tokRightAstOperand->previous(), "%type% (")) {
-                        const Library::AllocFunc* f = mSettings->library.getAllocFuncInfo(tokRightAstOperand->previous());
+                        const Token * fTok = tokRightAstOperand->previous();
+                        const Library::AllocFunc* f = mSettings->library.getAllocFuncInfo(fTok);
                         if (f && f->arg == -1) {
                             VarInfo::AllocInfo& varAlloc = alloctype[innerTok->varId()];
                             varAlloc.type = f->groupId;
                             varAlloc.status = VarInfo::ALLOC;
-                            varAlloc.allocTok = tokRightAstOperand->previous();
+                            varAlloc.allocTok = fTok;
                         } else {
                             // Fixme: warn about leak
                             alloctype.erase(innerTok->varId());
                         }
-
-                        changeAllocStatusIfRealloc(alloctype, innerTok->tokAt(2), varTok);
-                    } else if (mTokenizer->isCPP() && Token::Match(innerTok->tokAt(2), "new !!(")) {
+                        changeAllocStatusIfRealloc(alloctype, fTok, varTok);
+                    } else if (innerTok->isCpp() && Token::Match(innerTok->tokAt(2), "new !!(")) {
                         const Token* tok2 = innerTok->tokAt(2)->astOperand1();
                         const bool arrayNew = (tok2 && (tok2->str() == "[" || (tok2->str() == "(" && tok2->astOperand1() && tok2->astOperand1()->str() == "[")));
                         VarInfo::AllocInfo& varAlloc = alloctype[innerTok->varId()];
@@ -448,86 +572,95 @@ void CheckLeakAutoVar::checkScope(const Token * const startToken,
                 }
 
                 // check for function call
-                const Token * const openingPar = isFunctionCall(innerTok);
                 if (openingPar) {
+                    const Library::AllocFunc* allocFunc = mSettings->library.getDeallocFuncInfo(innerTok);
                     // innerTok is a function name
                     const VarInfo::AllocInfo allocation(0, VarInfo::NOALLOC);
-                    functionCall(innerTok, openingPar, varInfo, allocation, nullptr);
+                    functionCall(innerTok, openingPar, varInfo, allocation, allocFunc);
                     innerTok = openingPar->link();
                 }
             }
 
             if (Token::simpleMatch(closingParenthesis, ") {")) {
-                VarInfo varInfo1(*varInfo);  // VarInfo for if code
-                VarInfo varInfo2(*varInfo);  // VarInfo for else code
+                VarInfo varInfo1(varInfo);  // VarInfo for if code
+                VarInfo varInfo2(varInfo);  // VarInfo for else code
+
+                // Skip expressions before commas
+                const Token * astOperand2AfterCommas = tok->next()->astOperand2();
+                while (Token::simpleMatch(astOperand2AfterCommas, ","))
+                    astOperand2AfterCommas = astOperand2AfterCommas->astOperand2();
 
                 // Recursively scan variable comparisons in condition
-                std::stack<const Token *> tokens;
-                tokens.push(tok->next()->astOperand2());
-                while (!tokens.empty()) {
-                    const Token *tok3 = tokens.top();
-                    tokens.pop();
-                    if (!tok3)
-                        continue;
-                    if (tok3->str() == "&&" || tok3->str() == "||") {
-                        // FIXME: handle && ! || better
-                        tokens.push(tok3->astOperand1());
-                        tokens.push(tok3->astOperand2());
-                        continue;
-                    }
-                    if (tok3->str() == "(" && Token::Match(tok3->astOperand1(), "UNLIKELY|LIKELY")) {
-                        tokens.push(tok3->astOperand2());
-                        continue;
-                    } else if (tok3->str() == "(" && Token::Match(tok3->previous(), "%name%")) {
-                        const std::vector<const Token *> params = getArguments(tok3->previous());
-                        for (const Token *par : params) {
-                            if (!par->isComparisonOp())
-                                continue;
-                            const Token *vartok = nullptr;
-                            if (astIsVariableComparison(par, "!=", "0", &vartok) ||
-                                astIsVariableComparison(par, "==", "0", &vartok) ||
-                                astIsVariableComparison(par, "<", "0", &vartok) ||
-                                astIsVariableComparison(par, ">", "0", &vartok) ||
-                                astIsVariableComparison(par, "==", "-1", &vartok) ||
-                                astIsVariableComparison(par, "!=", "-1", &vartok)) {
-                                varInfo1.erase(vartok->varId());
-                                varInfo2.erase(vartok->varId());
+                for (const Token* compTok : getComparisonTokens(astOperand2AfterCommas)) {
+                    visitAstNodes(compTok, [&](const Token* tok3) {
+                        if (!tok3)
+                            return ChildrenToVisit::none;
+                        if (tok3->str() == "&&" || tok3->str() == "||") {
+                            // FIXME: handle && ! || better
+                            return ChildrenToVisit::op1_and_op2;
+                        }
+                        if (tok3->str() == "(" && Token::Match(tok3->astOperand1(), "UNLIKELY|LIKELY")) {
+                            return ChildrenToVisit::op2;
+                        }
+                        if (tok3->str() == "(" && tok3->previous()->isName()) {
+                            const std::vector<const Token*> params = getArguments(tok3->previous());
+                            for (const Token* par : params) {
+                                if (!par->isComparisonOp())
+                                    continue;
+                                const Token* vartok = nullptr;
+                                if (isVarTokComparison(par, &vartok, alloc_success_conds) ||
+                                    (isVarTokComparison(par, &vartok, alloc_failed_conds))) {
+                                    varInfo1.erase(vartok->varId());
+                                    varInfo2.erase(vartok->varId());
+                                }
                             }
+                            return ChildrenToVisit::none;
                         }
-                        continue;
-                    }
 
-                    const Token *vartok = nullptr;
-                    if (astIsVariableComparison(tok3, "!=", "0", &vartok)) {
-                        varInfo2.erase(vartok->varId());
-                        if (notzero.find(vartok->varId()) != notzero.end())
-                            varInfo2.clear();
-                    } else if (astIsVariableComparison(tok3, "==", "0", &vartok)) {
-                        varInfo1.erase(vartok->varId());
-                    } else if (astIsVariableComparison(tok3, "<", "0", &vartok)) {
-                        varInfo1.erase(vartok->varId());
-                    } else if (astIsVariableComparison(tok3, ">", "0", &vartok)) {
-                        varInfo2.erase(vartok->varId());
-                    } else if (astIsVariableComparison(tok3, "==", "-1", &vartok)) {
-                        varInfo1.erase(vartok->varId());
-                    }
+                        const Token* vartok = nullptr;
+                        if (isVarTokComparison(tok3, &vartok, alloc_success_conds)) {
+                            varInfo2.reallocToAlloc(vartok->varId());
+                            varInfo2.erase(vartok->varId());
+                            if (astIsVariableComparison(tok3, "!=", "0", &vartok) &&
+                                (notzero.find(vartok->varId()) != notzero.end()))
+                                varInfo2.clear();
+
+                            if (std::any_of(varInfo1.alloctype.begin(), varInfo1.alloctype.end(), [&](const std::pair<int, VarInfo::AllocInfo>& info) {
+                                if (info.second.status != VarInfo::ALLOC)
+                                    return false;
+                                const Token* ret = getReturnValueFromOutparamAlloc(info.second.allocTok, *mSettings);
+                                return ret && vartok && ret->varId() && ret->varId() == vartok->varId();
+                            })) {
+                                varInfo1.clear();
+                            }
+                        }
+                        else if (isVarTokComparison(tok3, &vartok, alloc_failed_conds)) {
+                            varInfo1.reallocToAlloc(vartok->varId());
+                            varInfo1.erase(vartok->varId());
+                        }
+                        return ChildrenToVisit::none;
+                    });
                 }
 
-                checkScope(closingParenthesis->next(), &varInfo1, notzero, recursiveCount);
+                if (!skipIfBlock && !checkScope(closingParenthesis->next(), varInfo1, notzero, recursiveCount)) {
+                    varInfo.clear();
+                    continue;
+                }
                 closingParenthesis = closingParenthesis->linkAt(1);
                 if (Token::simpleMatch(closingParenthesis, "} else {")) {
-                    checkScope(closingParenthesis->tokAt(2), &varInfo2, notzero, recursiveCount);
+                    if (!skipElseBlock && !checkScope(closingParenthesis->tokAt(2), varInfo2, notzero, recursiveCount)) {
+                        varInfo.clear();
+                        return false;
+                    }
                     tok = closingParenthesis->linkAt(2)->previous();
                 } else {
                     tok = closingParenthesis->previous();
                 }
 
                 VarInfo old;
-                old.swap(*varInfo);
-
-                std::map<int, VarInfo::AllocInfo>::const_iterator it;
+                old.swap(varInfo);
 
-                for (it = old.alloctype.begin(); it != old.alloctype.end(); ++it) {
+                for (auto it = old.alloctype.cbegin(); it != old.alloctype.cend(); ++it) {
                     const int varId = it->first;
                     if (old.conditionalAlloc.find(varId) == old.conditionalAlloc.end())
                         continue;
@@ -539,83 +672,86 @@ void CheckLeakAutoVar::checkScope(const Token * const startToken,
                 }
 
                 // Conditional allocation in varInfo1
-                for (it = varInfo1.alloctype.begin(); it != varInfo1.alloctype.end(); ++it) {
+                for (auto it = varInfo1.alloctype.cbegin(); it != varInfo1.alloctype.cend(); ++it) {
                     if (varInfo2.alloctype.find(it->first) == varInfo2.alloctype.end() &&
                         old.alloctype.find(it->first) == old.alloctype.end()) {
-                        varInfo->conditionalAlloc.insert(it->first);
+                        varInfo.conditionalAlloc.insert(it->first);
                     }
                 }
 
                 // Conditional allocation in varInfo2
-                for (it = varInfo2.alloctype.begin(); it != varInfo2.alloctype.end(); ++it) {
+                for (auto it = varInfo2.alloctype.cbegin(); it != varInfo2.alloctype.cend(); ++it) {
                     if (varInfo1.alloctype.find(it->first) == varInfo1.alloctype.end() &&
                         old.alloctype.find(it->first) == old.alloctype.end()) {
-                        varInfo->conditionalAlloc.insert(it->first);
+                        varInfo.conditionalAlloc.insert(it->first);
                     }
                 }
 
                 // Conditional allocation/deallocation
-                for (it = varInfo1.alloctype.begin(); it != varInfo1.alloctype.end(); ++it) {
+                for (auto it = varInfo1.alloctype.cbegin(); it != varInfo1.alloctype.cend(); ++it) {
                     if (it->second.managed() && conditionalAlloc.find(it->first) != conditionalAlloc.end()) {
-                        varInfo->conditionalAlloc.erase(it->first);
+                        varInfo.conditionalAlloc.erase(it->first);
                         varInfo2.erase(it->first);
                     }
                 }
-                for (it = varInfo2.alloctype.begin(); it != varInfo2.alloctype.end(); ++it) {
+                for (auto it = varInfo2.alloctype.cbegin(); it != varInfo2.alloctype.cend(); ++it) {
                     if (it->second.managed() && conditionalAlloc.find(it->first) != conditionalAlloc.end()) {
-                        varInfo->conditionalAlloc.erase(it->first);
+                        varInfo.conditionalAlloc.erase(it->first);
                         varInfo1.erase(it->first);
                     }
                 }
 
-                alloctype.insert(varInfo1.alloctype.begin(), varInfo1.alloctype.end());
-                alloctype.insert(varInfo2.alloctype.begin(), varInfo2.alloctype.end());
+                alloctype.insert(varInfo1.alloctype.cbegin(), varInfo1.alloctype.cend());
+                alloctype.insert(varInfo2.alloctype.cbegin(), varInfo2.alloctype.cend());
 
-                possibleUsage.insert(varInfo1.possibleUsage.begin(), varInfo1.possibleUsage.end());
-                possibleUsage.insert(varInfo2.possibleUsage.begin(), varInfo2.possibleUsage.end());
+                possibleUsage.insert(varInfo1.possibleUsage.cbegin(), varInfo1.possibleUsage.cend());
+                possibleUsage.insert(varInfo2.possibleUsage.cbegin(), varInfo2.possibleUsage.cend());
             }
         }
 
         // unknown control.. (TODO: handle loops)
         else if ((Token::Match(tok, "%type% (") && Token::simpleMatch(tok->linkAt(1), ") {")) || Token::simpleMatch(tok, "do {")) {
-            varInfo->clear();
-            break;
+            varInfo.clear();
+            return false;
         }
 
         // return
         else if (tok->str() == "return") {
-            ret(tok, *varInfo);
-            varInfo->clear();
+            ret(tok, varInfo);
+            varInfo.clear();
         }
 
         // throw
-        else if (mTokenizer->isCPP() && tok->str() == "throw") {
+        else if (tok->isCpp() && tok->str() == "throw") {
             bool tryFound = false;
             const Scope* scope = tok->scope();
             while (scope && scope->isExecutable()) {
-                if (scope->type == Scope::eTry)
+                if (scope->type == ScopeType::eTry)
                     tryFound = true;
                 scope = scope->nestedIn;
             }
             // If the execution leaves the function then treat it as return
             if (!tryFound)
-                ret(tok, *varInfo);
-            varInfo->clear();
+                ret(tok, varInfo);
+            varInfo.clear();
         }
 
         // delete
-        else if (mTokenizer->isCPP() && tok->str() == "delete") {
+        else if (tok->isCpp() && tok->str() == "delete") {
             const Token * delTok = tok;
+            if (Token::simpleMatch(delTok->astOperand1(), "."))
+                continue;
             const bool arrayDelete = Token::simpleMatch(tok->next(), "[ ]");
             if (arrayDelete)
                 tok = tok->tokAt(3);
             else
                 tok = tok->next();
-            if (tok->str() == "(")
+            bool startparen;
+            if ((startparen = (tok->str() == "(")))
                 tok = tok->next();
-            while (Token::Match(tok, "%name% ::|."))
+            while (Token::Match(tok, "%name% ::|.") || (startparen && Token::Match(tok, "%name% ,")))
                 tok = tok->tokAt(2);
-            const bool isnull = tok->hasKnownIntValue() && tok->values().front().intvalue == 0;
+            const bool isnull = tok->hasKnownIntValue() && tok->getKnownIntValue() == 0;
             if (!isnull && tok->varId() && tok->strAt(1) != "[") {
                 const VarInfo::AllocInfo allocation(arrayDelete ? NEW_ARRAY : NEW, VarInfo::DEALLOC, delTok);
                 changeAllocStatus(varInfo, allocation, tok, tok);
@@ -623,25 +759,34 @@ void CheckLeakAutoVar::checkScope(const Token * const startToken,
         }
 
         // Function call..
-        else if (isFunctionCall(ftok)) {
-            const Token * openingPar = isFunctionCall(ftok);
+        else if (const Token* openingPar = isFunctionCall(ftok)) {
             const Library::AllocFunc* af = mSettings->library.getDeallocFuncInfo(ftok);
             VarInfo::AllocInfo allocation(af ? af->groupId : 0, VarInfo::DEALLOC, ftok);
             if (allocation.type == 0)
                 allocation.status = VarInfo::NOALLOC;
+
             functionCall(ftok, openingPar, varInfo, allocation, af);
 
-            tok = ftok->next()->link();
+            tok = ftok->linkAt(1);
 
             // Handle scopes that might be noreturn
             if (allocation.status == VarInfo::NOALLOC && Token::simpleMatch(tok, ") ; }")) {
-                const std::string &functionName(tok->link()->previous()->str());
+                if (ftok->isKeyword())
+                    continue;
                 bool unknown = false;
-                if (mTokenizer->IsScopeNoReturn(tok->tokAt(2), &unknown)) {
+                if (mTokenizer->isScopeNoReturn(tok->tokAt(2), &unknown)) {
                     if (!unknown)
-                        varInfo->clear();
-                    else if (!mSettings->library.isLeakIgnore(functionName) && !mSettings->library.isUse(functionName))
-                        varInfo->possibleUsageAll(functionName);
+                        varInfo.clear();
+                    else {
+                        if (ftok->function() && !ftok->function()->isAttributeNoreturn() &&
+                            !(ftok->function()->functionScope && mTokenizer->isScopeNoReturn(ftok->function()->functionScope->bodyEnd))) // check function scope
+                            continue;
+                        const std::string functionName(mSettings->library.getFunctionName(ftok));
+                        if (!mSettings->library.isLeakIgnore(functionName) && !mSettings->library.isUse(functionName)) {
+                            const VarInfo::Usage usage = Token::simpleMatch(openingPar, "( )") ? VarInfo::NORET : VarInfo::USED; // TODO: check parameters passed to function
+                            varInfo.possibleUsageAll({ ftok, usage });
+                        }
+                    }
                 }
             }
 
@@ -650,12 +795,13 @@ void CheckLeakAutoVar::checkScope(const Token * const startToken,
 
         // goto => weird execution path
         else if (tok->str() == "goto") {
-            varInfo->clear();
+            varInfo.clear();
+            return false;
         }
 
         // continue/break
         else if (Token::Match(tok, "continue|break ;")) {
-            varInfo->clear();
+            varInfo.clear();
         }
 
         // Check smart pointer
@@ -693,8 +839,10 @@ void CheckLeakAutoVar::checkScope(const Token * const startToken,
                 // Check if its a pointer to a function
                 const Token * dtok = Token::findmatch(deleterToken, "& %name%", endDeleterToken);
                 if (dtok) {
-                    af = mSettings->library.getDeallocFuncInfo(dtok->tokAt(1));
-                } else {
+                    dtok = dtok->next();
+                    af = mSettings->library.getDeallocFuncInfo(dtok);
+                }
+                if (!dtok || !af) {
                     const Token * tscopeStart = nullptr;
                     const Token * tscopeEnd = nullptr;
                     // If the deleter is a lambda, check if it calls the dealloc function
@@ -704,6 +852,13 @@ void CheckLeakAutoVar::checkScope(const Token * const startToken,
                         Token::simpleMatch(deleterToken->link()->linkAt(1), ") {")) {
                         tscopeStart = deleterToken->link()->linkAt(1)->tokAt(1);
                         tscopeEnd = tscopeStart->link();
+                        // check user-defined deleter function
+                    } else if (dtok && dtok->function()) {
+                        const Scope* tscope = dtok->function()->functionScope;
+                        if (tscope) {
+                            tscopeStart = tscope->bodyStart;
+                            tscopeEnd = tscope->bodyEnd;
+                        }
                         // If the deleter is a class, check if class calls the dealloc function
                     } else if ((dtok = Token::findmatch(deleterToken, "%type%", endDeleterToken)) && dtok->type()) {
                         const Scope * tscope = dtok->type()->classScope;
@@ -719,6 +874,9 @@ void CheckLeakAutoVar::checkScope(const Token * const startToken,
                             if (af)
                                 break;
                         }
+                    } else { // there is a deleter, but we can't check it -> assume that it deallocates correctly
+                        varInfo.clear();
+                        continue;
                     }
                 }
             }
@@ -726,99 +884,149 @@ void CheckLeakAutoVar::checkScope(const Token * const startToken,
             const Token * vtok = typeEndTok->tokAt(3);
             const VarInfo::AllocInfo allocation(af ? af->groupId : (arrayDelete ? NEW_ARRAY : NEW), VarInfo::OWNED, ftok);
             changeAllocStatus(varInfo, allocation, vtok, vtok);
-        }
+        } else if (Token::Match(tok, "%var% ."))
+            checkTokenInsideExpression(tok, varInfo);
     }
+    ret(endToken, varInfo, true);
+    return true;
 }
 
 
-const Token * CheckLeakAutoVar::checkTokenInsideExpression(const Token * const tok, VarInfo *varInfo)
+const Token * CheckLeakAutoVar::checkTokenInsideExpression(const Token * const tok, VarInfo &varInfo, bool inFuncCall)
 {
     // Deallocation and then dereferencing pointer..
     if (tok->varId() > 0) {
         // TODO : Write a separate checker for this that uses valueFlowForward.
-        const std::map<int, VarInfo::AllocInfo>::const_iterator var = varInfo->alloctype.find(tok->varId());
-        if (var != varInfo->alloctype.end()) {
+        const auto var = utils::as_const(varInfo.alloctype).find(tok->varId());
+        if (var != varInfo.alloctype.end()) {
             bool unknown = false;
-            if (var->second.status == VarInfo::DEALLOC && CheckNullPointer::isPointerDeRef(tok, unknown, mSettings) && !unknown) {
+            if (var->second.status == VarInfo::DEALLOC && tok->valueType() && tok->valueType()->pointer &&
+                CheckNullPointer::isPointerDeRef(tok, unknown, *mSettings, /*checkNullArg*/ false) && !unknown) {
                 deallocUseError(tok, tok->str());
             } else if (Token::simpleMatch(tok->tokAt(-2), "= &")) {
-                varInfo->erase(tok->varId());
-            } else if (Token::Match(tok->previous(), "= %var% [;,)]")) {
-                varInfo->erase(tok->varId());
+                varInfo.erase(tok->varId());
+            } else {
+                // check if tok is assigned into another variable
+                const Token *rhs = tok;
+                bool isAssignment = false;
+                while (rhs->astParent()) {
+                    if (rhs->astParent()->str() == "=") {
+                        isAssignment = true;
+                        break;
+                    }
+                    rhs = rhs->astParent();
+                }
+                while (rhs->isCast()) {
+                    rhs = rhs->astOperand2() ? rhs->astOperand2() : rhs->astOperand1();
+                }
+                if ((rhs->str() == "." || rhs->varId() == tok->varId()) && isAssignment) {
+                    // simple assignment
+                    varInfo.erase(tok->varId());
+                } else if (rhs->astParent() && rhs->str() == "(" && !mSettings->library.returnValue(rhs->astOperand1()).empty()) {
+                    // #9298, assignment through return value of a function
+                    const std::string &returnValue = mSettings->library.returnValue(rhs->astOperand1());
+                    if (startsWith(returnValue, "arg")) {
+                        int argn;
+                        const Token *func = getTokenArgumentFunction(tok, argn);
+                        if (func) {
+                            const std::string arg = "arg" + std::to_string(argn + 1);
+                            if (returnValue == arg) {
+                                varInfo.erase(tok->varId());
+                            }
+                        }
+                    }
+                }
             }
         } else if (Token::Match(tok->previous(), "& %name% = %var% ;")) {
-            varInfo->referenced.insert(tok->tokAt(2)->varId());
+            varInfo.referenced.insert(tok->tokAt(2)->varId());
         }
     }
 
     // check for function call
-    const Token * const openingPar = isFunctionCall(tok);
+    const Token * const openingPar = inFuncCall ? nullptr : isFunctionCall(tok);
     if (openingPar) {
         const Library::AllocFunc* allocFunc = mSettings->library.getDeallocFuncInfo(tok);
         VarInfo::AllocInfo alloc(allocFunc ? allocFunc->groupId : 0, VarInfo::DEALLOC, tok);
         if (alloc.type == 0)
             alloc.status = VarInfo::NOALLOC;
         functionCall(tok, openingPar, varInfo, alloc, nullptr);
-        return openingPar->link();
+        const std::string &returnValue = mSettings->library.returnValue(tok);
+        if (startsWith(returnValue, "arg"))
+            // the function returns one of its argument, we need to process a potential assignment
+            return openingPar;
+        return isCPPCast(tok->astParent()) ? openingPar : openingPar->link();
     }
 
     return nullptr;
 }
 
 
-void CheckLeakAutoVar::changeAllocStatusIfRealloc(std::map<int, VarInfo::AllocInfo> &alloctype, const Token *fTok, const Token *retTok)
+void CheckLeakAutoVar::changeAllocStatusIfRealloc(std::map<int, VarInfo::AllocInfo> &alloctype, const Token *fTok, const Token *retTok) const
 {
     const Library::AllocFunc* f = mSettings->library.getReallocFuncInfo(fTok);
     if (f && f->arg == -1 && f->reallocArg > 0 && f->reallocArg <= numberOfArguments(fTok)) {
         const Token* argTok = getArguments(fTok).at(f->reallocArg - 1);
-        VarInfo::AllocInfo& argAlloc = alloctype[argTok->varId()];
+        if (alloctype.find(argTok->varId()) != alloctype.end()) {
+            VarInfo::AllocInfo& argAlloc = alloctype[argTok->varId()];
+            if (argAlloc.type != 0 && argAlloc.type != f->groupId)
+                mismatchError(fTok, argAlloc.allocTok, argTok->str());
+            argAlloc.status = VarInfo::REALLOC;
+            argAlloc.allocTok = fTok;
+        }
         VarInfo::AllocInfo& retAlloc = alloctype[retTok->varId()];
-        if (argAlloc.type != 0 && argAlloc.type != f->groupId)
-            mismatchError(fTok, argAlloc.allocTok, argTok->str());
-        argAlloc.status = VarInfo::DEALLOC;
-        argAlloc.allocTok = fTok;
         retAlloc.type = f->groupId;
         retAlloc.status = VarInfo::ALLOC;
         retAlloc.allocTok = fTok;
+        retAlloc.reallocedFromType = argTok->varId();
     }
 }
 
 
-void CheckLeakAutoVar::changeAllocStatus(VarInfo *varInfo, const VarInfo::AllocInfo& allocation, const Token* tok, const Token* arg)
+void CheckLeakAutoVar::changeAllocStatus(VarInfo &varInfo, const VarInfo::AllocInfo& allocation, const Token* tok, const Token* arg)
 {
-    std::map<int, VarInfo::AllocInfo> &alloctype = varInfo->alloctype;
-    const std::map<int, VarInfo::AllocInfo>::iterator var = alloctype.find(arg->varId());
+    std::map<int, VarInfo::AllocInfo> &alloctype = varInfo.alloctype;
+    const auto var = alloctype.find(arg->varId());
     if (var != alloctype.end()) {
+        // bailout if function is also allocating, since the argument might be moved
+        // to the return value, such as in fdopen
+        if (allocation.allocTok && mSettings->library.getAllocFuncInfo(allocation.allocTok)) {
+            varInfo.erase(arg->varId());
+            return;
+        }
         if (allocation.status == VarInfo::NOALLOC) {
             // possible usage
-            varInfo->possibleUsage[arg->varId()] = tok->str();
-            if (var->second.status == VarInfo::DEALLOC && arg->previous()->str() == "&")
-                varInfo->erase(arg->varId());
+            varInfo.possibleUsage[arg->varId()] = { tok, VarInfo::USED };
+            if (var->second.status == VarInfo::DEALLOC && arg->strAt(-1) == "&")
+                varInfo.erase(arg->varId());
         } else if (var->second.managed()) {
             doubleFreeError(tok, var->second.allocTok, arg->str(), allocation.type);
-        } else if (var->second.type != allocation.type) {
+            var->second.status = allocation.status;
+        } else if (var->second.type != allocation.type && var->second.type != 0) {
             // mismatching allocation and deallocation
             mismatchError(tok, var->second.allocTok, arg->str());
-            varInfo->erase(arg->varId());
+            varInfo.erase(arg->varId());
         } else {
             // deallocation
             var->second.status = allocation.status;
             var->second.type = allocation.type;
             var->second.allocTok = allocation.allocTok;
         }
-    } else if (allocation.status != VarInfo::NOALLOC) {
-        alloctype[arg->varId()].status = VarInfo::DEALLOC;
-        alloctype[arg->varId()].allocTok = tok;
+    } else if (allocation.status != VarInfo::NOALLOC && allocation.status != VarInfo::OWNED && !Token::simpleMatch(tok->astTop(), "return")) {
+        auto& allocInfo = alloctype[arg->varId()];
+        allocInfo.status = VarInfo::DEALLOC;
+        allocInfo.allocTok = tok;
+        allocInfo.type = allocation.type;
     }
 }
 
-void CheckLeakAutoVar::functionCall(const Token *tokName, const Token *tokOpeningPar, VarInfo *varInfo, const VarInfo::AllocInfo& allocation, const Library::AllocFunc* af)
+void CheckLeakAutoVar::functionCall(const Token *tokName, const Token *tokOpeningPar, VarInfo &varInfo, const VarInfo::AllocInfo& allocation, const Library::AllocFunc* af)
 {
     // Ignore function call?
-    if (mSettings->library.isLeakIgnore(tokName->str()))
-        return;
+    const bool isLeakIgnore = mSettings->library.isLeakIgnore(mSettings->library.getFunctionName(tokName));
     if (mSettings->library.getReallocFuncInfo(tokName))
         return;
+    if (tokName->next()->valueType() && tokName->next()->valueType()->container && tokName->next()->valueType()->container->stdStringLike)
+        return;
 
     const Token * const tokFirstArg = tokOpeningPar->next();
     if (!tokFirstArg || tokFirstArg->str() == ")") {
@@ -827,31 +1035,66 @@ void CheckLeakAutoVar::functionCall(const Token *tokName, const Token *tokOpenin
     }
 
     int argNr = 1;
-    for (const Token *arg = tokFirstArg; arg; arg = arg->nextArgument()) {
-        if (mTokenizer->isCPP() && arg->str() == "new") {
-            arg = arg->next();
-            if (Token::simpleMatch(arg, "( std :: nothrow )"))
-                arg = arg->tokAt(5);
+    for (const Token *funcArg = tokFirstArg; funcArg; funcArg = funcArg->nextArgument()) {
+        const Token* arg = funcArg;
+        if (arg->isCpp()) {
+            int tokAdvance = 0;
+            if (arg->str() == "new")
+                tokAdvance = 1;
+            else if (Token::simpleMatch(arg, "* new"))
+                tokAdvance = 2;
+            if (tokAdvance > 0) {
+                arg = arg->tokAt(tokAdvance);
+                if (Token::simpleMatch(arg, "( std :: nothrow )"))
+                    arg = arg->tokAt(5);
+            }
         }
 
         // Skip casts
+        if (arg->isKeyword() && arg->astParent() && arg->astParent()->isCast())
+            arg = arg->astParent();
         while (arg && arg->isCast())
             arg = arg->astOperand2() ? arg->astOperand2() : arg->astOperand1();
         const Token * const argTypeStartTok = arg;
 
+        if (Token::simpleMatch(arg, "."))
+            arg = arg->next();
+
         while (Token::Match(arg, "%name% .|:: %name%"))
             arg = arg->tokAt(2);
 
-        if (Token::Match(arg, "%var% [-,)] !!.") || Token::Match(arg, "& %var%")) {
+        if ((Token::Match(arg, "%var% [-,)] !!.") && !(arg->variable() && arg->variable()->isArray())) ||
+            (Token::Match(arg, "& %var% !!.") && !(arg->next()->variable() && arg->next()->variable()->isArray()))) {
             // goto variable
-            if (arg->str() == "&")
+            const bool isAddressOf = arg->str() == "&";
+            if (isAddressOf)
                 arg = arg->next();
 
-            const bool isnull = arg->hasKnownIntValue() && arg->values().front().intvalue == 0;
+            const bool isnull = !isAddressOf && (arg->hasKnownIntValue() && arg->getKnownIntValue() == 0);
 
             // Is variable allocated?
-            if (!isnull && (!af || af->arg == argNr))
-                changeAllocStatus(varInfo, allocation, tokName, arg);
+            if (!isnull && (!af || af->arg == argNr)) {
+                const Library::AllocFunc* deallocFunc = mSettings->library.getDeallocFuncInfo(tokName);
+                VarInfo::AllocInfo dealloc(deallocFunc ? deallocFunc->groupId : 0, VarInfo::DEALLOC, tokName);
+                if (const Library::AllocFunc* allocFunc = mSettings->library.getAllocFuncInfo(tokName)) {
+                    if (mSettings->library.getDeallocFuncInfo(tokName)) {
+                        changeAllocStatus(varInfo, dealloc.type == 0 ? allocation : dealloc, tokName, arg);
+                    }
+                    if (allocFunc->arg == argNr &&
+                        !(arg->variable() && arg->variable()->isArgument() && arg->valueType() && arg->valueType()->pointer > 1) &&
+                        (isAddressOf || (arg->valueType() && arg->valueType()->pointer == 2))) {
+                        leakIfAllocated(arg, varInfo);
+                        VarInfo::AllocInfo& varAlloc = varInfo.alloctype[arg->varId()];
+                        varAlloc.type = allocFunc->groupId;
+                        varAlloc.status = VarInfo::ALLOC;
+                        varAlloc.allocTok = arg;
+                    }
+                }
+                else if (isLeakIgnore)
+                    checkTokenInsideExpression(arg, varInfo);
+                else
+                    changeAllocStatus(varInfo, dealloc.type == 0 ? allocation : dealloc, tokName, arg);
+            }
         }
         // Check smart pointer
         else if (Token::Match(arg, "%name% < %type%") && mSettings->library.isSmartPointer(argTypeStartTok)) {
@@ -900,7 +1143,14 @@ void CheckLeakAutoVar::functionCall(const Token *tokName, const Token *tokOpenin
             const VarInfo::AllocInfo sp_allocation(sp_af ? sp_af->groupId : (arrayDelete ? NEW_ARRAY : NEW), VarInfo::OWNED, allocTok);
             changeAllocStatus(varInfo, sp_allocation, vtok, vtok);
         } else {
-            checkTokenInsideExpression(arg, varInfo);
+            const Token* const nextArg = funcArg->nextArgument();
+            while (arg && ((nextArg && arg != nextArg) || (!nextArg && arg != tokOpeningPar->link()))) {
+                checkTokenInsideExpression(arg, varInfo, /*inFuncCall*/ isLeakIgnore);
+
+                if (isLambdaCaptureList(arg))
+                    break;
+                arg = arg->next();
+            }
         }
         // TODO: check each token in argument expression (could contain multiple variables)
         argNr++;
@@ -912,11 +1162,11 @@ void CheckLeakAutoVar::leakIfAllocated(const Token *vartok,
                                        const VarInfo &varInfo)
 {
     const std::map<int, VarInfo::AllocInfo> &alloctype = varInfo.alloctype;
-    const std::map<int, std::string> &possibleUsage = varInfo.possibleUsage;
+    const auto& possibleUsage = varInfo.possibleUsage;
 
-    const std::map<int, VarInfo::AllocInfo>::const_iterator var = alloctype.find(vartok->varId());
-    if (var != alloctype.end() && var->second.status == VarInfo::ALLOC) {
-        const std::map<int, std::string>::const_iterator use = possibleUsage.find(vartok->varId());
+    const auto var = alloctype.find(vartok->varId());
+    if (var != alloctype.cend() && var->second.status == VarInfo::ALLOC) {
+        const auto use = possibleUsage.find(vartok->varId());
         if (use == possibleUsage.end()) {
             leakError(vartok, vartok->str(), var->second.type);
         } else {
@@ -925,15 +1175,22 @@ void CheckLeakAutoVar::leakIfAllocated(const Token *vartok,
     }
 }
 
-void CheckLeakAutoVar::ret(const Token *tok, const VarInfo &varInfo)
+static bool isSafeCast(const ValueType* vt, const Settings& settings)
+{
+    const size_t sizeOf = vt->getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointee);
+    return sizeOf == 0 || sizeOf >= settings.platform.sizeof_pointer;
+}
+
+void CheckLeakAutoVar::ret(const Token *tok, VarInfo &varInfo, const bool isEndOfScope)
 {
     const std::map<int, VarInfo::AllocInfo> &alloctype = varInfo.alloctype;
-    const std::map<int, std::string> &possibleUsage = varInfo.possibleUsage;
+    const auto& possibleUsage = varInfo.possibleUsage;
+    std::vector<int> toRemove;
 
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
-    for (std::map<int, VarInfo::AllocInfo>::const_iterator it = alloctype.begin(); it != alloctype.end(); ++it) {
-        // don't warn if variable is conditionally allocated
-        if (!it->second.managed() && varInfo.conditionalAlloc.find(it->first) != varInfo.conditionalAlloc.end())
+    for (auto it = alloctype.cbegin(); it != alloctype.cend(); ++it) {
+        // don't warn if variable is conditionally allocated, unless it leaves the scope
+        if (!isEndOfScope && !it->second.managed() && varInfo.conditionalAlloc.find(it->first) != varInfo.conditionalAlloc.end())
             continue;
 
         // don't warn if there is a reference of the variable
@@ -943,43 +1200,99 @@ void CheckLeakAutoVar::ret(const Token *tok, const VarInfo &varInfo)
         const int varid = it->first;
         const Variable *var = symbolDatabase->getVariableFromVarId(varid);
         if (var) {
-            bool used = false;
+            // don't warn if we leave an inner scope
+            if (isEndOfScope && var->scope() && tok != var->scope()->bodyEnd)
+                continue;
+            enum class PtrUsage : std::uint8_t { NONE, DEREF, PTR } used = PtrUsage::NONE;
             for (const Token *tok2 = tok; tok2; tok2 = tok2->next()) {
                 if (tok2->str() == ";")
                     break;
-                if (!Token::Match(tok2, "return|(|{|,"))
+                if (!Token::Match(tok2, "return|(|{|,|*"))
                     continue;
 
                 const Token* tok3 = tok2->next();
-                while (tok3 && tok3->isCast() && tok3->valueType() &&
-                       (tok3->valueType()->pointer ||
-                        (tok3->valueType()->typeSize(*mSettings) == 0) ||
-                        (tok3->valueType()->typeSize(*mSettings) >= mSettings->sizeof_pointer)))
+                while (tok3 && tok3->isCast() &&
+                       (!tok3->valueType() ||
+                        tok3->valueType()->pointer ||
+                        isSafeCast(tok3->valueType(), *mSettings)))
                     tok3 = tok3->astOperand2() ? tok3->astOperand2() : tok3->astOperand1();
-                if (Token::Match(tok3, "%varid%", varid))
+                if (tok3 && tok3->varId() == varid)
                     tok2 = tok3->next();
                 else if (Token::Match(tok3, "& %varid% . %name%", varid))
                     tok2 = tok3->tokAt(4);
+                else if (Token::simpleMatch(tok3, "*") && tok3->next()->varId() == varid)
+                    tok2 = tok3;
                 else
                     continue;
-                if (Token::Match(tok2, "[});,]")) {
-                    used = true;
+                if (Token::Match(tok2, "[});,+]") && (!astIsBool(tok) || tok2->str() != ";")) {
+                    used = PtrUsage::PTR;
                     break;
                 }
+                if (Token::Match(tok2, "[|.|*")) {
+                    used = PtrUsage::DEREF;
+                    break;
+                }
+            }
+
+            // don't warn when returning after checking return value of outparam allocation
+            const Token* outparamFunc{};
+            if ((tok->scope()->type == ScopeType::eIf || tok->scope()->type== ScopeType::eElse) &&
+                (outparamFunc = getOutparamAllocation(it->second.allocTok, *mSettings))) {
+                const Scope* scope = tok->scope();
+                if (scope->type == ScopeType::eElse) {
+                    scope = scope->bodyStart->tokAt(-2)->scope();
+                }
+                const Token* const ifEnd = scope->bodyStart->previous();
+                const Token* const ifStart = ifEnd->link();
+                const Token* const alloc = it->second.allocTok;
+                if (precedes(ifStart, alloc) && succeeds(ifEnd, alloc)) { // allocation and check in if
+                    if (outparamFunc->next()->astParent() == ifStart || Token::Match(outparamFunc->next()->astParent(), "%comp%"))
+                        continue;
+                } else { // allocation result assigned to variable
+                    const Token* const retAssign = outparamFunc->next()->astParent();
+                    if (Token::simpleMatch(retAssign, "=") && retAssign->astOperand1()->varId()) {
+                        bool isRetComp = false;
+                        for (const Token* tok2 = ifStart; tok2 != ifEnd; tok2 = tok2->next()) {
+                            if (tok2->varId() == retAssign->astOperand1()->varId()) {
+                                isRetComp = true;
+                                break;
+                            }
+                        }
+                        if (isRetComp)
+                            continue;
+                    }
+                }
             }
 
             // return deallocated pointer
-            if (used && it->second.status == VarInfo::DEALLOC)
+            if (used != PtrUsage::NONE && it->second.status == VarInfo::DEALLOC)
                 deallocReturnError(tok, it->second.allocTok, var->name());
 
-            else if (!used && !it->second.managed()) {
-                const std::map<int, std::string>::const_iterator use = possibleUsage.find(varid);
+            else if (used != PtrUsage::PTR && !it->second.managed() && !var->isReference()) {
+                const auto use = possibleUsage.find(varid);
                 if (use == possibleUsage.end()) {
                     leakError(tok, var->name(), it->second.type);
-                } else {
+                } else if (!use->second.first->variable()) { // TODO: handle constructors
                     configurationInfo(tok, use->second);
                 }
             }
+            toRemove.push_back(varid);
         }
     }
+    for (const int varId : toRemove)
+        varInfo.erase(varId);
+}
+
+void CheckLeakAutoVar::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    CheckLeakAutoVar checkLeakAutoVar(&tokenizer, &tokenizer.getSettings(), errorLogger);
+    checkLeakAutoVar.check();
+}
+
+void CheckLeakAutoVar::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const
+{
+    CheckLeakAutoVar c(nullptr, settings, errorLogger);
+    c.deallocReturnError(nullptr, nullptr, "p");
+    c.configurationInfo(nullptr, { nullptr, VarInfo::USED });  // user configuration is needed to complete analysis
+    c.doubleFreeError(nullptr, nullptr, "varname", 0);
 }
diff --git a/lib/checkleakautovar.h b/lib/checkleakautovar.h
index 4808e4784b2..b7f57d0bd5e 100644
--- a/lib/checkleakautovar.h
+++ b/lib/checkleakautovar.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -26,19 +26,20 @@
 #include "config.h"
 #include "library.h"
 
+#include <cstdint>
 #include <map>
 #include <set>
 #include <string>
+#include <utility>
 
 class ErrorLogger;
 class Settings;
 class Token;
 class Tokenizer;
 
-
 class CPPCHECKLIB VarInfo {
 public:
-    enum AllocStatus { OWNED = -2, DEALLOC = -1, NOALLOC = 0, ALLOC = 1 };
+    enum AllocStatus : std::int8_t { REALLOC = -3, OWNED = -2, DEALLOC = -1, NOALLOC = 0, ALLOC = 1 };
     struct AllocInfo {
         AllocStatus status;
         /** Allocation type. If it is a positive value then it corresponds to
@@ -46,15 +47,17 @@ class CPPCHECKLIB VarInfo {
          * checkleakautovar allocation type.
          */
         int type;
+        int reallocedFromType = -1;
         const Token * allocTok;
-        AllocInfo(int type_ = 0, AllocStatus status_ = NOALLOC, const Token* allocTok_ = nullptr) : status(status_), type(type_), allocTok(allocTok_) {}
+        explicit AllocInfo(int type_ = 0, AllocStatus status_ = NOALLOC, const Token* allocTok_ = nullptr) : status(status_), type(type_), allocTok(allocTok_) {}
 
         bool managed() const {
             return status < 0;
         }
     };
+    enum Usage : std::uint8_t { USED, NORET };
     std::map<int, AllocInfo> alloctype;
-    std::map<int, std::string> possibleUsage;
+    std::map<int, std::pair<const Token*, Usage>> possibleUsage;
     std::set<int> conditionalAlloc;
     std::set<int> referenced;
 
@@ -72,17 +75,25 @@ class CPPCHECKLIB VarInfo {
         referenced.erase(varid);
     }
 
-    void swap(VarInfo &other) {
+    void swap(VarInfo &other) NOEXCEPT {
         alloctype.swap(other.alloctype);
         possibleUsage.swap(other.possibleUsage);
         conditionalAlloc.swap(other.conditionalAlloc);
         referenced.swap(other.referenced);
     }
 
-    /** set possible usage for all variables */
-    void possibleUsageAll(const std::string &functionName);
+    void reallocToAlloc(nonneg int varid) {
+        const AllocInfo& alloc = alloctype[varid];
+        if (alloc.reallocedFromType >= 0) {
+            const auto it = alloctype.find(alloc.reallocedFromType);
+            if (it != alloctype.end() && it->second.status == REALLOC) {
+                it->second.status = ALLOC;
+            }
+        }
+    }
 
-    void print();
+    /** set possible usage for all variables */
+    void possibleUsageAll(const std::pair<const Token*, Usage>& functionUsage);
 };
 
 
@@ -96,73 +107,64 @@ class CPPCHECKLIB VarInfo {
 class CPPCHECKLIB CheckLeakAutoVar : public Check {
 public:
     /** This constructor is used when registering the CheckLeakAutoVar */
-    CheckLeakAutoVar() : Check(myName()) {
-    }
+    CheckLeakAutoVar() : Check(myName()) {}
 
+private:
     /** This constructor is used when running checks. */
     CheckLeakAutoVar(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
-
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        CheckLeakAutoVar checkLeakAutoVar(tokenizer, settings, errorLogger);
-        checkLeakAutoVar.check();
-    }
+        : Check(myName(), tokenizer, settings, errorLogger) {}
 
-private:
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     /** check for leaks in all scopes */
     void check();
 
-    /** check for leaks in a function scope */
-    void checkScope(const Token * const startToken,
-                    VarInfo *varInfo,
+    /** check for leaks in a function scope
+     * @throws InternalError thrown if recursion count is exceeded
+     */
+    bool checkScope(const Token * startToken,
+                    VarInfo &varInfo,
                     std::set<int> notzero,
                     nonneg int recursiveCount);
 
     /** Check token inside expression.
-    * @param tok token inside expression.
-    * @param varInfo Variable info
-    * @return next token to process (if no other checks needed for this token). NULL if other checks could be performed.
-    */
-    const Token * checkTokenInsideExpression(const Token * const tok, VarInfo *varInfo);
+     * @param tok token inside expression.
+     * @param varInfo Variable info
+     * @return next token to process (if no other checks needed for this token). NULL if other checks could be performed.
+     */
+    const Token * checkTokenInsideExpression(const Token * tok, VarInfo &varInfo, bool inFuncCall = false);
 
     /** parse function call */
-    void functionCall(const Token *tokName, const Token *tokOpeningPar, VarInfo *varInfo, const VarInfo::AllocInfo& allocation, const Library::AllocFunc* af);
+    void functionCall(const Token *tokName, const Token *tokOpeningPar, VarInfo &varInfo, const VarInfo::AllocInfo& allocation, const Library::AllocFunc* af);
 
     /** parse changes in allocation status */
-    void changeAllocStatus(VarInfo *varInfo, const VarInfo::AllocInfo& allocation, const Token* tok, const Token* arg);
+    void changeAllocStatus(VarInfo &varInfo, const VarInfo::AllocInfo& allocation, const Token* tok, const Token* arg);
 
     /** update allocation status if reallocation function */
-    void changeAllocStatusIfRealloc(std::map<int, VarInfo::AllocInfo> &alloctype, const Token *fTok, const Token *retTok);
+    void changeAllocStatusIfRealloc(std::map<int, VarInfo::AllocInfo> &alloctype, const Token *fTok, const Token *retTok) const;
 
     /** return. either "return" or end of variable scope is seen */
-    void ret(const Token *tok, const VarInfo &varInfo);
+    void ret(const Token *tok, VarInfo &varInfo, bool isEndOfScope = false);
 
     /** if variable is allocated then there is a leak */
     void leakIfAllocated(const Token *vartok, const VarInfo &varInfo);
 
-    void leakError(const Token* tok, const std::string &varname, int type);
-    void mismatchError(const Token* deallocTok, const Token* allocTok, const std::string &varname);
-    void deallocUseError(const Token *tok, const std::string &varname);
+    void leakError(const Token* tok, const std::string &varname, int type) const;
+    void mismatchError(const Token* deallocTok, const Token* allocTok, const std::string &varname) const;
+    void deallocUseError(const Token *tok, const std::string &varname) const;
     void deallocReturnError(const Token *tok, const Token *deallocTok, const std::string &varname);
     void doubleFreeError(const Token *tok, const Token *prevFreeTok, const std::string &varname, int type);
 
     /** message: user configuration is needed to complete analysis */
-    void configurationInfo(const Token* tok, const std::string &functionName);
+    void configurationInfo(const Token* tok, const std::pair<const Token*, VarInfo::Usage>& functionUsage);
 
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        CheckLeakAutoVar c(nullptr, settings, errorLogger);
-        c.deallocReturnError(nullptr, nullptr, "p");
-        c.configurationInfo(nullptr, "f");  // user configuration is needed to complete analysis
-        c.doubleFreeError(nullptr, nullptr, "varname", 0);
-    }
+    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const override;
 
     static std::string myName() {
         return "Leaks (auto variables)";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Detect when a auto variable is allocated but not deallocated or deallocated twice.\n";
     }
 };
diff --git a/lib/checkmemoryleak.cpp b/lib/checkmemoryleak.cpp
index a0ffc1eaf54..4e36467bf04 100644
--- a/lib/checkmemoryleak.cpp
+++ b/lib/checkmemoryleak.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,21 +20,20 @@
 #include "checkmemoryleak.h"
 
 #include "astutils.h"
+#include "errorlogger.h"
+#include "errortypes.h"
 #include "library.h"
-#include "mathlib.h"
+#include "platform.h"
 #include "settings.h"
-#include "standards.h"
 #include "symboldatabase.h"
 #include "token.h"
 #include "tokenize.h"
-#include "tokenlist.h"
 #include "utils.h"
-#include "valueflow.h"
 
 #include <algorithm>
 #include <cstddef>
-#include <set>
-#include <stack>
+#include <utility>
+#include <vector>
 
 //---------------------------------------------------------------------------
 
@@ -52,35 +51,13 @@ static const CWE CWE401(401U);  // Improper Release of Memory Before Removing La
 static const CWE CWE771(771U);  // Missing Reference to Active Allocated Resource
 static const CWE CWE772(772U);  // Missing Release of Resource after Effective Lifetime
 
-
-/** List of functions that can be ignored when searching for memory leaks.
- * These functions don't take the address of the given pointer
- * This list contains function names with const parameters e.g.: atof(const char *)
- * TODO: This list should be replaced by <leak-ignore/> in .cfg files.
- */
-static const std::set<std::string> call_func_white_list = {
-    "_open", "_wopen", "access", "adjtime", "asctime_r", "asprintf", "chdir", "chmod", "chown"
-    , "creat", "ctime_r", "execl", "execle", "execlp", "execv", "execve", "fchmod", "fcntl"
-    , "fdatasync", "fclose", "flock", "fmemopen", "fnmatch", "fopen", "fopencookie", "for", "free"
-    , "freopen", "fseeko", "fstat", "fsync", "ftello", "ftruncate", "getgrnam", "gethostbyaddr", "gethostbyname"
-    , "getnetbyname", "getopt", "getopt_long", "getprotobyname", "getpwnam", "getservbyname", "getservbyport"
-    , "glob", "gmtime", "gmtime_r", "if", "index", "inet_addr", "inet_aton", "inet_network", "initgroups"
-    , "ioctl", "link", "localtime_r", "lockf", "lseek", "lstat", "mkdir", "mkfifo", "mknod", "mkstemp"
-    , "obstack_printf", "obstack_vprintf", "open", "opendir", "parse_printf_format", "pathconf"
-    , "perror", "popen", "posix_fadvise", "posix_fallocate", "pread", "psignal", "pwrite", "read", "readahead"
-    , "readdir", "readdir_r", "readlink", "readv", "realloc", "regcomp", "return", "rewinddir", "rindex"
-    , "rmdir", "scandir", "seekdir", "setbuffer", "sethostname", "setlinebuf", "sizeof", "strdup"
-    , "stat", "stpcpy", "strcasecmp", "stricmp", "strncasecmp", "switch"
-    , "symlink", "sync_file_range", "telldir", "tempnam", "time", "typeid", "unlink"
-    , "utime", "utimes", "vasprintf", "while", "wordexp", "write", "writev"
-};
-
 //---------------------------------------------------------------------------
 
 CheckMemoryLeak::AllocType CheckMemoryLeak::getAllocationType(const Token *tok2, nonneg int varid, std::list<const Function*> *callstack) const
 {
     // What we may have...
     //     * var = (char *)malloc(10);
+    //     * var = static_cast<char *>(malloc(10));
     //     * var = new char[10];
     //     * var = strdup("hello");
     //     * var = strndup("hello", 3);
@@ -88,20 +65,24 @@ CheckMemoryLeak::AllocType CheckMemoryLeak::getAllocationType(const Token *tok2,
         tok2 = tok2->link();
         tok2 = tok2 ? tok2->next() : nullptr;
     }
-    if (! tok2)
+    if (tok2 && tok2->isCpp() && tok2->isKeyword() && endsWith(tok2->str(), "_cast"))
+        tok2 = tok2->astParent()->next();
+    if (!tok2)
         return No;
     if (tok2->str() == "::")
         tok2 = tok2->next();
-    if (! tok2->isName())
+    while (Token::Match(tok2, "%name% :: %type%"))
+        tok2 = tok2->tokAt(2);
+    if (!tok2->isName())
         return No;
 
-    if (!Token::Match(tok2, "%name% ::|. %type%")) {
+    if (!Token::Match(tok2, "%name% . %type%")) {
         // Using realloc..
         AllocType reallocType = getReallocationType(tok2, varid);
         if (reallocType != No)
             return reallocType;
 
-        if (mTokenizer_->isCPP() && tok2->str() == "new") {
+        if (tok2->isCpp() && tok2->str() == "new") {
             if (tok2->strAt(1) == "(" && !Token::Match(tok2->next(),"( std| ::| nothrow )"))
                 return No;
             if (tok2->astOperand1() && (tok2->astOperand1()->str() == "[" || (tok2->astOperand1()->astOperand1() && tok2->astOperand1()->astOperand1()->str() == "[")))
@@ -109,15 +90,18 @@ CheckMemoryLeak::AllocType CheckMemoryLeak::getAllocationType(const Token *tok2,
             const Token *typeTok = tok2->next();
             while (Token::Match(typeTok, "%name% :: %name%"))
                 typeTok = typeTok->tokAt(2);
-            if (typeTok->type() && typeTok->type()->isClassType()) {
-                const Scope *classScope = typeTok->type()->classScope;
-                if (classScope && classScope->numConstructors > 0)
-                    return No;
+            const Scope* classScope = nullptr;
+            if (typeTok->type() && (typeTok->type()->isClassType() || typeTok->type()->isStructType() || typeTok->type()->isUnionType())) {
+                classScope = typeTok->type()->classScope;
+            } else if (typeTok->function() && typeTok->function()->isConstructor()) {
+                classScope = typeTok->function()->nestedIn;
             }
+            if (classScope && classScope->numConstructors > 0)
+                return No;
             return New;
         }
 
-        if (mSettings_->posix()) {
+        if (mSettings_->hasLib("posix")) {
             if (Token::Match(tok2, "open|openat|creat|mkstemp|mkostemp|socket (")) {
                 // simple sanity check of function parameters..
                 // TODO: Make such check for all these functions
@@ -146,7 +130,7 @@ CheckMemoryLeak::AllocType CheckMemoryLeak::getAllocationType(const Token *tok2,
         }
     }
 
-    while (Token::Match(tok2,"%name% ::|. %type%"))
+    while (Token::Match(tok2,"%name% . %type%"))
         tok2 = tok2->tokAt(2);
 
     // User function
@@ -155,7 +139,7 @@ CheckMemoryLeak::AllocType CheckMemoryLeak::getAllocationType(const Token *tok2,
         return No;
 
     // Prevent recursion
-    if (callstack && std::find(callstack->begin(), callstack->end(), func) != callstack->end())
+    if (callstack && std::find(callstack->cbegin(), callstack->cend(), func) != callstack->cend())
         return No;
 
     std::list<const Function*> cs;
@@ -175,7 +159,7 @@ CheckMemoryLeak::AllocType CheckMemoryLeak::getReallocationType(const Token *tok
         tok2 = tok2->link();
         tok2 = tok2 ? tok2->next() : nullptr;
     }
-    if (! tok2)
+    if (!tok2)
         return No;
 
     if (!Token::Match(tok2, "%name% ("))
@@ -184,7 +168,10 @@ CheckMemoryLeak::AllocType CheckMemoryLeak::getReallocationType(const Token *tok
     const Library::AllocFunc *f = mSettings_->library.getReallocFuncInfo(tok2);
     if (!(f && f->reallocArg > 0 && f->reallocArg <= numberOfArguments(tok2)))
         return No;
-    const Token* arg = getArguments(tok2).at(f->reallocArg - 1);
+    const auto args = getArguments(tok2);
+    if (args.size() < (f->reallocArg))
+        return No;
+    const Token* arg = args.at(f->reallocArg - 1);
     while (arg && arg->isCast())
         arg = arg->astOperand1();
     while (arg && arg->isUnaryOp("*"))
@@ -206,7 +193,7 @@ CheckMemoryLeak::AllocType CheckMemoryLeak::getReallocationType(const Token *tok
 
 CheckMemoryLeak::AllocType CheckMemoryLeak::getDeallocationType(const Token *tok, nonneg int varid) const
 {
-    if (mTokenizer_->isCPP() && tok->str() == "delete" && tok->astOperand1()) {
+    if (tok->isCpp() && tok->str() == "delete" && tok->astOperand1()) {
         const Token* vartok = tok->astOperand1();
         if (Token::Match(vartok, ".|::"))
             vartok = vartok->astOperand2();
@@ -235,7 +222,7 @@ CheckMemoryLeak::AllocType CheckMemoryLeak::getDeallocationType(const Token *tok
                 if (tok->str() == "realloc" && Token::simpleMatch(vartok->next(), ", 0 )"))
                     return Malloc;
 
-                if (mSettings_->posix()) {
+                if (mSettings_->hasLib("posix")) {
                     if (tok->str() == "close")
                         return Fd;
                     if (tok->str() == "pclose")
@@ -272,6 +259,16 @@ bool CheckMemoryLeak::isReopenStandardStream(const Token *tok) const
     return false;
 }
 
+bool CheckMemoryLeak::isOpenDevNull(const Token *tok) const
+{
+    if (mSettings_->hasLib("posix") && tok->str() == "open" && numberOfArguments(tok) == 2) {
+        const Token* arg = getArguments(tok).at(0);
+        if (Token::simpleMatch(arg, "\"/dev/null\""))
+            return true;
+    }
+    return false;
+}
+
 //--------------------------------------------------------------------------
 
 
@@ -281,7 +278,7 @@ void CheckMemoryLeak::memoryLeak(const Token *tok, const std::string &varname, A
 {
     if (alloctype == CheckMemoryLeak::File ||
         alloctype == CheckMemoryLeak::Pipe ||
-        alloctype == CheckMemoryLeak::Fd   ||
+        alloctype == CheckMemoryLeak::Fd ||
         alloctype == CheckMemoryLeak::OtherRes)
         resourceLeakError(tok, varname);
     else
@@ -289,7 +286,7 @@ void CheckMemoryLeak::memoryLeak(const Token *tok, const std::string &varname, A
 }
 //---------------------------------------------------------------------------
 
-void CheckMemoryLeak::reportErr(const Token *tok, Severity::SeverityType severity, const std::string &id, const std::string &msg, const CWE &cwe) const
+void CheckMemoryLeak::reportErr(const Token *tok, Severity severity, const std::string &id, const std::string &msg, const CWE &cwe) const
 {
     std::list<const Token *> callstack;
 
@@ -299,13 +296,13 @@ void CheckMemoryLeak::reportErr(const Token *tok, Severity::SeverityType severit
     reportErr(callstack, severity, id, msg, cwe);
 }
 
-void CheckMemoryLeak::reportErr(const std::list<const Token *> &callstack, Severity::SeverityType severity, const std::string &id, const std::string &msg, const CWE &cwe) const
+void CheckMemoryLeak::reportErr(const std::list<const Token *> &callstack, Severity severity, const std::string &id, const std::string &msg, const CWE &cwe) const
 {
-    const ErrorLogger::ErrorMessage errmsg(callstack, mTokenizer_ ? &mTokenizer_->list : nullptr, severity, id, msg, cwe, false);
+    const ErrorMessage errmsg(callstack, mTokenizer_ ? &mTokenizer_->list : nullptr, severity, id, msg, cwe, Certainty::normal);
     if (mErrorLogger_)
         mErrorLogger_->reportErr(errmsg);
     else
-        Check::reportError(errmsg);
+        Check::writeToErrorList(errmsg);
 }
 
 void CheckMemoryLeak::memleakError(const Token *tok, const std::string &varname) const
@@ -326,21 +323,11 @@ void CheckMemoryLeak::resourceLeakError(const Token *tok, const std::string &var
     reportErr(tok, Severity::error, "resourceLeak", errmsg, CWE(775U));
 }
 
-void CheckMemoryLeak::deallocDeallocError(const Token *tok, const std::string &varname) const
-{
-    reportErr(tok, Severity::error, "deallocDealloc", "$symbol:" + varname + "\nDeallocating a deallocated pointer: $symbol", CWE(415U));
-}
-
 void CheckMemoryLeak::deallocuseError(const Token *tok, const std::string &varname) const
 {
     reportErr(tok, Severity::error, "deallocuse", "$symbol:" + varname + "\nDereferencing '$symbol' after it is deallocated / released", CWE(416U));
 }
 
-void CheckMemoryLeak::mismatchSizeError(const Token *tok, const std::string &sz) const
-{
-    reportErr(tok, Severity::error, "mismatchSize", "The allocated size " + sz + " is not a multiple of the underlying type's size.", CWE(131U));
-}
-
 void CheckMemoryLeak::mismatchAllocDealloc(const std::list<const Token *> &callstack, const std::string &varname) const
 {
     reportErr(callstack, Severity::error, "mismatchAllocDealloc", "$symbol:" + varname + "\nMismatching allocation and deallocation: $symbol", CWE(762U));
@@ -352,7 +339,7 @@ CheckMemoryLeak::AllocType CheckMemoryLeak::functionReturnType(const Function* f
         return No;
 
     // Get return pointer..
-    int varid = 0;
+    const Variable* var = nullptr;
     for (const Token *tok2 = func->functionScope->bodyStart; tok2 != func->functionScope->bodyEnd; tok2 = tok2->next()) {
         if (const Token *endOfLambda = findLambdaEndToken(tok2))
             tok2 = endOfLambda;
@@ -369,24 +356,24 @@ CheckMemoryLeak::AllocType CheckMemoryLeak::functionReturnType(const Function* f
             if (Token::Match(tok, ".|::"))
                 tok = tok->astOperand2() ? tok->astOperand2() : tok->astOperand1();
             if (tok)
-                varid = tok->varId();
+                var = tok->variable();
             break;
         }
     }
 
     // Not returning pointer value..
-    if (varid == 0)
+    if (!var)
         return No;
 
     // If variable is not local then alloctype shall be "No"
     // Todo: there can be false negatives about mismatching allocation/deallocation.
     //       => Generate "alloc ; use ;" if variable is not local?
-    const Variable *var = mTokenizer_->getSymbolDatabase()->getVariableFromVarId(varid);
-    if (!var || !var->isLocal() || var->isStatic())
+    if (!var->isLocal() || var->isStatic())
         return No;
 
     // Check if return pointer is allocated..
     AllocType allocType = No;
+    nonneg int const varid = var->declarationId();
     for (const Token* tok = func->functionScope->bodyStart; tok != func->functionScope->bodyEnd; tok = tok->next()) {
         if (Token::Match(tok, "%varid% =", varid)) {
             allocType = getAllocationType(tok->tokAt(2), varid, callstack);
@@ -394,7 +381,7 @@ CheckMemoryLeak::AllocType CheckMemoryLeak::functionReturnType(const Function* f
         if (Token::Match(tok, "= %varid% ;", varid)) {
             return No;
         }
-        if (!mTokenizer_->isC() && Token::Match(tok, "[(,] %varid% [,)]", varid)) {
+        if (!tok->isC() && Token::Match(tok, "[(,] %varid% [,)]", varid)) {
             return No;
         }
         if (Token::Match(tok, "[(,] & %varid% [.,)]", varid)) {
@@ -411,57 +398,6 @@ CheckMemoryLeak::AllocType CheckMemoryLeak::functionReturnType(const Function* f
 }
 
 
-const char *CheckMemoryLeak::functionArgAlloc(const Function *func, nonneg int targetpar, AllocType &allocType) const
-{
-    allocType = No;
-
-    if (!func || !func->functionScope)
-        return "";
-
-    if (!Token::simpleMatch(func->retDef, "void"))
-        return "";
-
-    std::list<Variable>::const_iterator arg = func->argumentList.begin();
-    for (; arg != func->argumentList.end(); ++arg) {
-        if (arg->index() == targetpar-1)
-            break;
-    }
-    if (arg == func->argumentList.end())
-        return "";
-
-    // Is **
-    if (!arg->isPointer())
-        return "";
-    const Token* tok = arg->typeEndToken();
-    tok = tok->previous();
-    if (tok->str() != "*")
-        return "";
-
-    // Check if pointer is allocated.
-    bool realloc = false;
-    for (tok = func->functionScope->bodyStart; tok && tok != func->functionScope->bodyEnd; tok = tok->next()) {
-        if (tok->varId() == arg->declarationId()) {
-            if (Token::Match(tok->tokAt(-3), "free ( * %name% )")) {
-                realloc = true;
-                allocType = No;
-            } else if (Token::Match(tok->previous(), "* %name% =")) {
-                allocType = getAllocationType(tok->tokAt(2), arg->declarationId());
-                if (allocType != No) {
-                    if (realloc)
-                        return "realloc";
-                    return "alloc";
-                }
-            } else {
-                // unhandled variable usage: bailout
-                return "";
-            }
-        }
-    }
-
-    return "";
-}
-
-
 static bool notvar(const Token *tok, nonneg int varid)
 {
     if (!tok)
@@ -488,12 +424,6 @@ static bool ifvar(const Token *tok, nonneg int varid, const std::string &comp, c
     return (vartok && vartok->varId() == varid);
 }
 
-bool CheckMemoryLeakInFunction::test_white_list(const std::string &funcname, const Settings *settings, bool cpp)
-{
-    return ((call_func_white_list.find(funcname)!=call_func_white_list.end()) || settings->library.isLeakIgnore(funcname) || (cpp && funcname == "delete"));
-}
-
-
 //---------------------------------------------------------------------------
 // Check for memory leaks due to improper realloc() usage.
 //   Below, "a" may be set to null without being freed if realloc() cannot
@@ -501,14 +431,10 @@ bool CheckMemoryLeakInFunction::test_white_list(const std::string &funcname, con
 //     a = malloc(10); a = realloc(a, 100);
 //---------------------------------------------------------------------------
 
-static bool isNoArgument(const SymbolDatabase* symbolDatabase, nonneg int varid)
-{
-    const Variable* var = symbolDatabase->getVariableFromVarId(varid);
-    return var && !var->isArgument();
-}
-
 void CheckMemoryLeakInFunction::checkReallocUsage()
 {
+    logChecker("CheckMemoryLeakInFunction::checkReallocUsage");
+
     // only check functions
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
@@ -532,7 +458,7 @@ void CheckMemoryLeakInFunction::checkReallocUsage()
                     continue;
 
                 const AllocType allocType = getReallocationType(reallocTok, tok->varId());
-                if (!((allocType == Malloc || allocType == OtherMem)))
+                if (!(allocType == Malloc || allocType == OtherMem))
                     continue;
                 const Token* arg = getArguments(reallocTok).at(f->reallocArg - 1);
                 while (arg && arg->isCast())
@@ -546,20 +472,25 @@ void CheckMemoryLeakInFunction::checkReallocUsage()
                 if (!arg || !tok2)
                     continue;
 
-                if (!((tok->varId() == arg->varId()) && isNoArgument(symbolDatabase, tok->varId())))
+                if (!(tok->varId() == arg->varId() && tok->variable() && !tok->variable()->isArgument()))
                     continue;
 
                 // Check that another copy of the pointer wasn't saved earlier in the function
                 if (Token::findmatch(scope->bodyStart, "%name% = %varid% ;", tok, tok->varId()) ||
-                    Token::findmatch(scope->bodyStart, "[{};] %varid% = %name% [;=]", tok, tok->varId()))
+                    Token::findmatch(scope->bodyStart, "[{};] %varid% = *| %var% .| %var%| [;=]", tok, tok->varId()))
                     continue;
 
+                // Check if the argument is known to be null, which means it is not a memory leak
+                if (arg->hasKnownIntValue() && arg->getKnownIntValue() == 0) {
+                    continue;
+                }
+
                 const Token* tokEndRealloc = reallocTok->linkAt(1);
                 // Check that the allocation isn't followed immediately by an 'if (!var) { error(); }' that might handle failure
                 if (Token::simpleMatch(tokEndRealloc->next(), "; if (") &&
                     notvar(tokEndRealloc->tokAt(3)->astOperand2(), tok->varId())) {
                     const Token* tokEndBrace = tokEndRealloc->linkAt(3)->linkAt(1);
-                    if (tokEndBrace && mTokenizer->IsScopeNoReturn(tokEndBrace))
+                    if (tokEndBrace && mTokenizer->isScopeNoReturn(tokEndBrace))
                         continue;
                 }
 
@@ -570,6 +501,22 @@ void CheckMemoryLeakInFunction::checkReallocUsage()
 }
 //---------------------------------------------------------------------------
 
+void CheckMemoryLeakInFunction::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    CheckMemoryLeakInFunction checkMemoryLeak(&tokenizer, &tokenizer.getSettings(), errorLogger);
+    checkMemoryLeak.checkReallocUsage();
+}
+
+void CheckMemoryLeakInFunction::getErrorMessages(ErrorLogger *e, const Settings *settings) const
+{
+    CheckMemoryLeakInFunction c(nullptr, settings, e);
+    c.memleakError(nullptr, "varname");
+    c.resourceLeakError(nullptr, "varname");
+    c.deallocuseError(nullptr, "varname");
+    const std::list<const Token *> callstack;
+    c.mismatchAllocDealloc(callstack, "varname");
+    c.memleakUponReallocFailureError(nullptr, "realloc", "varname");
+}
 
 //---------------------------------------------------------------------------
 // Checks for memory leaks in classes..
@@ -578,12 +525,14 @@ void CheckMemoryLeakInFunction::checkReallocUsage()
 
 void CheckMemoryLeakInClass::check()
 {
+    logChecker("CheckMemoryLeakInClass::check");
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
     // only check classes and structures
     for (const Scope * scope : symbolDatabase->classAndStructScopes) {
         for (const Variable &var : scope->varlist) {
-            if (!var.isStatic() && var.isPointer()) {
+            if (!var.isStatic() && (var.isPointer() || var.isPointerArray())) {
                 // allocation but no deallocation of private variables in public function..
                 const Token *tok = var.typeStartToken();
                 // Either it is of standard type or a non-derived type
@@ -606,8 +555,8 @@ void CheckMemoryLeakInClass::variable(const Scope *scope, const Token *tokVarnam
     const std::string& classname = scope->className;
 
     // Check if member variable has been allocated and deallocated..
-    CheckMemoryLeak::AllocType Alloc = CheckMemoryLeak::No;
-    CheckMemoryLeak::AllocType Dealloc = CheckMemoryLeak::No;
+    CheckMemoryLeak::AllocType memberAlloc = CheckMemoryLeak::No;
+    CheckMemoryLeak::AllocType memberDealloc = CheckMemoryLeak::No;
 
     bool allocInConstructor = false;
     bool deallocInDestructor = false;
@@ -617,9 +566,9 @@ void CheckMemoryLeakInClass::variable(const Scope *scope, const Token *tokVarnam
         const bool constructor = func.isConstructor();
         const bool destructor = func.isDestructor();
         if (!func.hasBody()) {
-            if (destructor) { // implementation for destructor is not seen => assume it deallocates all variables properly
+            if (destructor && !func.isDefault()) { // implementation for destructor is not seen and not defaulted => assume it deallocates all variables properly
                 deallocInDestructor = true;
-                Dealloc = CheckMemoryLeak::Many;
+                memberDealloc = CheckMemoryLeak::Many;
             }
             continue;
         }
@@ -635,7 +584,7 @@ void CheckMemoryLeakInClass::variable(const Scope *scope, const Token *tokVarnam
                 }
 
                 // Allocate..
-                if (!body || Token::Match(tok, "%varid% =", varid)) {
+                if (!body || Token::Match(tok, "%varid% =|[", varid)) {
                     // var1 = var2 = ...
                     // bail out
                     if (tok->strAt(-1) == "=")
@@ -647,21 +596,23 @@ void CheckMemoryLeakInClass::variable(const Scope *scope, const Token *tokVarnam
                         tok->strAt(-2) != scope->className)
                         return;
 
-                    AllocType alloc = getAllocationType(tok->tokAt(body ? 2 : 3), 0);
+                    const Token* allocTok = tok->tokAt(body ? 2 : 3);
+                    if (tok->astParent() && tok->astParent()->str() == "[" && tok->astParent()->astParent())
+                        allocTok = tok->astParent()->astParent()->astOperand2();
+
+                    AllocType alloc = getAllocationType(allocTok, 0);
                     if (alloc != CheckMemoryLeak::No) {
                         if (constructor)
                             allocInConstructor = true;
 
-                        if (Alloc != No && Alloc != alloc)
+                        if (memberAlloc != No && memberAlloc != alloc)
                             alloc = CheckMemoryLeak::Many;
 
-                        if (alloc != CheckMemoryLeak::Many && Dealloc != CheckMemoryLeak::No && Dealloc != CheckMemoryLeak::Many && Dealloc != alloc) {
-                            std::list<const Token *> callstack;
-                            callstack.push_back(tok);
-                            mismatchAllocDealloc(callstack, classname + "::" + varname);
+                        if (alloc != CheckMemoryLeak::Many && memberDealloc != CheckMemoryLeak::No && memberDealloc != CheckMemoryLeak::Many && memberDealloc != alloc) {
+                            mismatchAllocDealloc({tok}, classname + "::" + varname);
                         }
 
-                        Alloc = alloc;
+                        memberAlloc = alloc;
                     }
                 }
 
@@ -678,46 +629,42 @@ void CheckMemoryLeakInClass::variable(const Scope *scope, const Token *tokVarnam
                     if (destructor)
                         deallocInDestructor = true;
 
+                    if (dealloc != CheckMemoryLeak::Many && memberAlloc != CheckMemoryLeak::No && memberAlloc != Many && memberAlloc != dealloc) {
+                        mismatchAllocDealloc({tok}, classname + "::" + varname);
+                    }
+
                     // several types of allocation/deallocation?
-                    if (Dealloc != CheckMemoryLeak::No && Dealloc != dealloc)
+                    if (memberDealloc != CheckMemoryLeak::No && memberDealloc != dealloc)
                         dealloc = CheckMemoryLeak::Many;
 
-                    if (dealloc != CheckMemoryLeak::Many && Alloc != CheckMemoryLeak::No &&  Alloc != Many && Alloc != dealloc) {
-                        std::list<const Token *> callstack;
-                        callstack.push_back(tok);
-                        mismatchAllocDealloc(callstack, classname + "::" + varname);
-                    }
-
-                    Dealloc = dealloc;
+                    memberDealloc = dealloc;
                 }
 
                 // Function call .. possible deallocation
-                else if (Token::Match(tok->previous(), "[{};] %name% (")) {
-                    if (!CheckMemoryLeakInFunction::test_white_list(tok->str(), mSettings, mTokenizer->isCPP())) {
-                        return;
-                    }
+                else if (Token::Match(tok->previous(), "[{};] %name% (") && !tok->isKeyword() && !mSettings->library.isLeakIgnore(tok->str())) {
+                    return;
                 }
             }
         }
     }
 
     if (allocInConstructor && !deallocInDestructor) {
-        unsafeClassError(tokVarname, classname, classname + "::" + varname /*, Alloc*/);
-    } else if (Alloc != CheckMemoryLeak::No && Dealloc == CheckMemoryLeak::No) {
-        unsafeClassError(tokVarname, classname, classname + "::" + varname /*, Alloc*/);
+        unsafeClassError(tokVarname, classname, classname + "::" + varname /*, memberAlloc*/);
+    } else if (memberAlloc != CheckMemoryLeak::No && memberDealloc == CheckMemoryLeak::No) {
+        unsafeClassError(tokVarname, classname, classname + "::" + varname /*, memberAlloc*/);
     }
 }
 
 void CheckMemoryLeakInClass::unsafeClassError(const Token *tok, const std::string &classname, const std::string &varname)
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("unsafeClassCanLeak"))
         return;
 
     reportError(tok, Severity::style, "unsafeClassCanLeak",
                 "$symbol:" + classname + "\n"
                 "$symbol:" + varname + "\n"
                 "Class '" + classname + "' is unsafe, '" + varname + "' can leak by wrong usage.\n"
-                "The class '" + classname + "' is unsafe, wrong usage can cause memory/resource leaks for '" + varname + "'. This can for instance be fixed by adding proper cleanup in the destructor.", CWE398, false);
+                "The class '" + classname + "' is unsafe, wrong usage can cause memory/resource leaks for '" + varname + "'. This can for instance be fixed by adding proper cleanup in the destructor.", CWE398, Certainty::normal);
 }
 
 
@@ -726,7 +673,7 @@ void CheckMemoryLeakInClass::checkPublicFunctions(const Scope *scope, const Toke
     // Check that public functions deallocate the pointers that they allocate.
     // There is no checking how these functions are used and therefore it
     // isn't established if there is real leaks or not.
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
     const int varid = classtok->varId();
@@ -734,7 +681,7 @@ void CheckMemoryLeakInClass::checkPublicFunctions(const Scope *scope, const Toke
     // Parse public functions..
     // If they allocate member variables, they should also deallocate
     for (const Function &func : scope->functionList) {
-        if ((func.type == Function::eFunction || func.type == Function::eOperatorEqual) &&
+        if ((func.type == FunctionType::eFunction || func.type == FunctionType::eOperatorEqual) &&
             func.access == AccessControl::Public && func.hasBody()) {
             const Token *tok2 = func.functionScope->bodyStart->next();
             if (Token::Match(tok2, "%varid% =", varid)) {
@@ -753,15 +700,38 @@ void CheckMemoryLeakInClass::checkPublicFunctions(const Scope *scope, const Toke
 
 void CheckMemoryLeakInClass::publicAllocationError(const Token *tok, const std::string &varname)
 {
-    reportError(tok, Severity::warning, "publicAllocationError", "$symbol:" + varname + "\nPossible leak in public function. The pointer '$symbol' is not deallocated before it is allocated.", CWE398, false);
+    reportError(tok, Severity::warning, "publicAllocationError", "$symbol:" + varname + "\nPossible leak in public function. The pointer '$symbol' is not deallocated before it is allocated.", CWE398, Certainty::normal);
+}
+
+void CheckMemoryLeakInClass::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    if (!tokenizer.isCPP())
+        return;
+
+    CheckMemoryLeakInClass checkMemoryLeak(&tokenizer, &tokenizer.getSettings(), errorLogger);
+    checkMemoryLeak.check();
+}
+
+void CheckMemoryLeakInClass::getErrorMessages(ErrorLogger *e, const Settings *settings) const
+{
+    CheckMemoryLeakInClass c(nullptr, settings, e);
+    c.publicAllocationError(nullptr, "varname");
+    c.unsafeClassError(nullptr, "class", "class::varname");
 }
 
 
 void CheckMemoryLeakStructMember::check()
 {
+    if (mSettings->clang)
+        return;
+
+    logChecker("CheckMemoryLeakStructMember::check");
+
     const SymbolDatabase* symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Variable* var : symbolDatabase->variableList()) {
-        if (!var || !var->isLocal() || var->isStatic() || var->isReference())
+        if (!var || (!var->isLocal() && !(var->isArgument() && var->scope())) || var->isStatic())
+            continue;
+        if (var->isReference() || (var->valueType() && var->valueType()->pointer > 1))
             continue;
         if (var->typeEndToken()->isStandardType())
             continue;
@@ -769,24 +739,34 @@ void CheckMemoryLeakStructMember::check()
     }
 }
 
-bool CheckMemoryLeakStructMember::isMalloc(const Variable *variable)
+bool CheckMemoryLeakStructMember::isMalloc(const Variable *variable) const
 {
+    if (!variable)
+        return false;
     const int declarationId(variable->declarationId());
     bool alloc = false;
     for (const Token *tok2 = variable->nameToken(); tok2 && tok2 != variable->scope()->bodyEnd; tok2 = tok2->next()) {
-        if (Token::Match(tok2, "= %varid% [;=]", declarationId)) {
+        if (Token::Match(tok2, "= %varid% [;=]", declarationId))
             return false;
-        } else if (Token::Match(tok2, "%varid% = malloc|kmalloc (", declarationId)) {
-            alloc = true;
+        if (Token::Match(tok2, "%varid% =", declarationId)) {
+            const Token* tok3 = tok2->tokAt(1)->astOperand2();
+            while (tok3 && tok3->isCast())
+                tok3 = tok3->astOperand2() ? tok3->astOperand2() : tok3->astOperand1();
+            if ((tok3 && Token::Match(tok3->tokAt(-1), "%name% (") && mSettings->library.getAllocFuncInfo(tok3->tokAt(-1))) ||
+                (Token::simpleMatch(tok3, "new") && tok3->isCpp())) {
+                alloc = true;
+            }
         }
     }
     return alloc;
 }
 
-void CheckMemoryLeakStructMember::checkStructVariable(const Variable * const variable)
+void CheckMemoryLeakStructMember::checkStructVariable(const Variable* const variable) const
 {
+    if (!variable)
+        return;
     // Is struct variable a pointer?
-    if (variable->isPointer()) {
+    if (variable->isArrayOrPointer()) {
         // Check that variable is allocated with malloc
         if (!isMalloc(variable))
             return;
@@ -797,7 +777,57 @@ void CheckMemoryLeakStructMember::checkStructVariable(const Variable * const var
 
     // Check struct..
     int indentlevel2 = 0;
-    for (const Token *tok2 = variable->nameToken(); tok2 && tok2 != variable->scope()->bodyEnd; tok2 = tok2->next()) {
+
+    auto deallocInFunction = [this](const Token* tok, int structid) -> bool {
+        // Calling non-function / function that doesn't deallocate?
+        if (tok->isKeyword() || mSettings->library.isLeakIgnore(tok->str()))
+            return false;
+
+        // Check if the struct is used..
+        bool deallocated = false;
+        const Token* const end = tok->linkAt(1);
+        for (const Token* tok2 = tok; tok2 != end; tok2 = tok2->next()) {
+            if (Token::Match(tok2, "[(,] &| %varid% [,)]", structid)) {
+                /** @todo check if the function deallocates the memory */
+                deallocated = true;
+                break;
+            }
+
+            if (Token::Match(tok2, "[(,] &| %varid% . %name% [,)]", structid)) {
+                /** @todo check if the function deallocates the memory */
+                deallocated = true;
+                break;
+            }
+        }
+
+        return deallocated;
+    };
+
+    // return { memberTok, rhsTok }
+    auto isMemberAssignment = [](const Token* varTok, int varId) -> std::pair<const Token*, const Token*> {
+        if (varTok->varId() != varId)
+            return {};
+        const Token* top = varTok;
+        while (top->astParent()) {
+            if (Token::Match(top->astParent(), "(|["))
+                return {};
+            top = top->astParent();
+        }
+        if (!Token::simpleMatch(top, "=") || !precedes(varTok, top))
+            return {};
+        const Token* dot = top->astOperand1();
+        while (dot && dot->str() != ".")
+            dot = dot->astOperand1();
+        if (!dot)
+            return {};
+        return { dot->astOperand2(), top->next() };
+    };
+    std::pair<const Token*, const Token*> assignToks;
+
+    const Token* tokStart = variable->nameToken();
+    if (variable->isArgument() && variable->scope())
+        tokStart = variable->scope()->bodyStart->next();
+    for (const Token *tok2 = tokStart; tok2 && tok2 != variable->scope()->bodyEnd; tok2 = tok2->next()) {
         if (tok2->str() == "{")
             ++indentlevel2;
 
@@ -813,22 +843,37 @@ void CheckMemoryLeakStructMember::checkStructVariable(const Variable * const var
             break;
 
         // Struct member is allocated => check if it is also properly deallocated..
-        else if (Token::Match(tok2->previous(), "[;{}] %varid% . %var% =", variable->declarationId())) {
-            if (getAllocationType(tok2->tokAt(4), tok2->tokAt(2)->varId()) == AllocType::No)
+        else if ((assignToks = isMemberAssignment(tok2, variable->declarationId())).first && assignToks.first->varId()) {
+            const AllocType allocType = getAllocationType(assignToks.second, assignToks.first->varId());
+            if (allocType == AllocType::No)
                 continue;
 
+            if (variable->isArgument() && variable->valueType() && variable->valueType()->type == ValueType::UNKNOWN_TYPE && assignToks.first->astParent()) {
+                const Token* accessTok = assignToks.first->astParent();
+                while (Token::simpleMatch(accessTok->astOperand1(), "."))
+                    accessTok = accessTok->astOperand1();
+                if (Token::simpleMatch(accessTok, ".") && accessTok->originalName() == "->")
+                    continue;
+            }
+
             const int structid(variable->declarationId());
-            const int structmemberid(tok2->tokAt(2)->varId());
+            const int structmemberid(assignToks.first->varId());
 
             // This struct member is allocated.. check that it is deallocated
             int indentlevel3 = indentlevel2;
             for (const Token *tok3 = tok2; tok3; tok3 = tok3->next()) {
-                if (tok3->str() == "{")
+                if (tok3->str() == "{") {
+                    if (tok3->scope()->type == ScopeType::eIf && tok3 == tok3->scope()->bodyStart) { // bailout: member checked in if condition
+                        const Token* const condBeg = tok3->scope()->classDef->tokAt(1);
+                        if (Token::findmatch(condBeg, ". %varid%", condBeg->link(), assignToks.first->varId()))
+                            break;
+                    }
                     ++indentlevel3;
+                }
 
                 else if (tok3->str() == "}") {
                     if (indentlevel3 == 0) {
-                        memoryLeak(tok3, variable->name() + "." + tok2->strAt(2), Malloc);
+                        memoryLeak(tok3, variable->name() + "." + tok2->strAt(2), allocType);
                         break;
                     }
                     --indentlevel3;
@@ -857,9 +902,9 @@ void CheckMemoryLeakStructMember::checkStructVariable(const Variable * const var
                 }
 
                 // Deallocating the struct..
-                else if (Token::Match(tok3, "free|kfree ( %varid% )", structid)) {
+                else if (Token::Match(tok3, "%name% ( %varid% )", structid) && mSettings->library.getDeallocFuncInfo(tok3)) {
                     if (indentlevel2 == 0)
-                        memoryLeak(tok3, variable->name() + "." + tok2->strAt(2), Malloc);
+                        memoryLeak(tok3, variable->name() + "." + tok2->strAt(2), allocType);
                     break;
                 }
 
@@ -867,20 +912,20 @@ void CheckMemoryLeakStructMember::checkStructVariable(const Variable * const var
                 else if (Token::simpleMatch(tok3, "if (") &&
                          notvar(tok3->next()->astOperand2(), structmemberid)) {
                     // Goto the ")"
-                    tok3 = tok3->next()->link();
+                    tok3 = tok3->linkAt(1);
 
                     // make sure we have ") {".. it should be
                     if (!Token::simpleMatch(tok3, ") {"))
                         break;
 
                     // Goto the "}"
-                    tok3 = tok3->next()->link();
+                    tok3 = tok3->linkAt(1);
                 }
 
                 // succeeded allocation
                 else if (ifvar(tok3, structmemberid, "!=", "0")) {
                     // goto the ")"
-                    tok3 = tok3->next()->link();
+                    tok3 = tok3->linkAt(1);
 
                     // check if the variable is deallocated or returned..
                     int indentlevel4 = 0;
@@ -891,7 +936,7 @@ void CheckMemoryLeakStructMember::checkStructVariable(const Variable * const var
                             --indentlevel4;
                             if (indentlevel4 == 0)
                                 break;
-                        } else if (Token::Match(tok4, "free|kfree ( %var% . %varid% )", structmemberid)) {
+                        } else if (Token::Match(tok4, "%name% ( %var% . %varid% )", structmemberid) && mSettings->library.getDeallocFuncInfo(tok4)) {
                             break;
                         }
                     }
@@ -902,12 +947,13 @@ void CheckMemoryLeakStructMember::checkStructVariable(const Variable * const var
                 }
 
                 // Returning from function..
-                else if (tok3->str() == "return") {
+                else if ((tok3->scope()->type != ScopeType::eLambda || tok3->scope() == variable->scope()) && tok3->str() == "return") {
                     // Returning from function without deallocating struct member?
                     if (!Token::Match(tok3, "return %varid% ;", structid) &&
                         !Token::Match(tok3, "return & %varid%", structid) &&
-                        !(Token::Match(tok3, "return %varid% . %var%", structid) && tok3->tokAt(3)->varId() == structmemberid)) {
-                        memoryLeak(tok3, variable->name() + "." + tok2->strAt(2), Malloc);
+                        !(Token::Match(tok3, "return %varid% . %var%", structid) && tok3->tokAt(3)->varId() == structmemberid) &&
+                        !(Token::Match(tok3, "return %name% (") && tok3->astOperand1() && deallocInFunction(tok3->astOperand1(), structid))) {
+                        memoryLeak(tok3, variable->name() + "." + tok2->strAt(2), allocType);
                     }
                     break;
                 }
@@ -925,28 +971,7 @@ void CheckMemoryLeakStructMember::checkStructVariable(const Variable * const var
 
                 // using struct in a function call..
                 else if (Token::Match(tok3, "%name% (")) {
-                    // Calling non-function / function that doesn't deallocate?
-                    if (CheckMemoryLeakInFunction::test_white_list(tok3->str(), mSettings, mTokenizer->isCPP()))
-                        continue;
-
-                    // Check if the struct is used..
-                    bool deallocated = false;
-                    const Token* const end4 = tok3->linkAt(1);
-                    for (const Token *tok4 = tok3; tok4 != end4; tok4 = tok4->next()) {
-                        if (Token::Match(tok4, "[(,] &| %varid% [,)]", structid)) {
-                            /** @todo check if the function deallocates the memory */
-                            deallocated = true;
-                            break;
-                        }
-
-                        if (Token::Match(tok4, "[(,] &| %varid% . %name% [,)]", structid)) {
-                            /** @todo check if the function deallocates the memory */
-                            deallocated = true;
-                            break;
-                        }
-                    }
-
-                    if (deallocated)
+                    if (deallocInFunction(tok3, structid))
                         break;
                 }
             }
@@ -954,10 +979,20 @@ void CheckMemoryLeakStructMember::checkStructVariable(const Variable * const var
     }
 }
 
+void CheckMemoryLeakStructMember::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    CheckMemoryLeakStructMember checkMemoryLeak(&tokenizer, &tokenizer.getSettings(), errorLogger);
+    checkMemoryLeak.check();
+}
+
+void CheckMemoryLeakStructMember::getErrorMessages(ErrorLogger * /*errorLogger*/, const Settings * /*settings*/) const
+{}
 
 
 void CheckMemoryLeakNoVar::check()
 {
+    logChecker("CheckMemoryLeakNoVar::check");
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
     // only check functions
@@ -985,36 +1020,65 @@ void CheckMemoryLeakNoVar::checkForUnreleasedInputArgument(const Scope *scope)
     // parse the executable scope until tok is reached...
     for (const Token *tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
         // allocating memory in parameter for function call..
-        if (!Token::Match(tok, "%name% ("))
+        if (tok->varId() || !Token::Match(tok, "%name% ("))
             continue;
 
         // check if the output of the function is assigned
         const Token* tok2 = tok->next()->astParent();
-        while (tok2 && tok2->isCast())
+        while (tok2 && (tok2->isCast() || Token::Match(tok2, "?|:")))
             tok2 = tok2->astParent();
-        if (tok2 && tok2->isAssignmentOp())
+        if (Token::Match(tok2, "%assign%")) // TODO: check if function returns allocated resource
+            continue;
+        if (Token::simpleMatch(tok->astTop(), "return"))
             continue;
 
         const std::string& functionName = tok->str();
-        if ((mTokenizer->isCPP() && functionName == "delete") ||
-            functionName == "free" ||
-            functionName == "fclose" ||
-            functionName == "realloc")
+        if ((tok->isCpp() && functionName == "delete") ||
+            functionName == "return")
             continue;
 
-        if (!CheckMemoryLeakInFunction::test_white_list(functionName, mSettings, mTokenizer->isCPP()))
+        if (Token::simpleMatch(tok->next()->astParent(), "(")) // passed to another function
+            continue;
+        if (!tok->isKeyword() && !tok->function() && !mSettings->library.isLeakIgnore(functionName))
             continue;
 
         const std::vector<const Token *> args = getArguments(tok);
+        int argnr = -1;
         for (const Token* arg : args) {
-            if (arg->isOp())
+            ++argnr;
+            if (arg->isOp() && !(tok->isKeyword() && arg->str() == "*")) // e.g. switch (*new int)
                 continue;
-            while (arg->astOperand1())
+            while (arg->astOperand1()) {
+                if (arg->isCpp() && Token::simpleMatch(arg, "new"))
+                    break;
                 arg = arg->astOperand1();
-            if (getAllocationType(arg, 0) == No)
+            }
+            const AllocType alloc = getAllocationType(arg, 0);
+            if (alloc == No)
                 continue;
+            if (alloc == New || alloc == NewArray) {
+                const Token* typeTok = arg->next();
+                bool bail = !typeTok->isStandardType() &&
+                            !mSettings->library.detectContainerOrIterator(typeTok) &&
+                            !mSettings->library.podtype(typeTok->expressionString());
+                if (bail && typeTok->type() && typeTok->type()->classScope &&
+                    typeTok->type()->classScope->numConstructors == 0 &&
+                    typeTok->type()->classScope->getDestructor() == nullptr) {
+                    bail = false;
+                }
+                if (bail)
+                    continue;
+            }
             if (isReopenStandardStream(arg))
                 continue;
+            if (tok->function()) {
+                const Variable* argvar = tok->function()->getArgumentVar(argnr);
+                if (!argvar || !argvar->valueType())
+                    continue;
+                const size_t argSize = argvar->valueType()->getSizeOf(*mSettings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer);
+                if (argSize == 0 || argSize >= mSettings->platform.sizeof_pointer)
+                    continue;
+            }
             functionCallLeak(arg, arg->str(), functionName);
         }
 
@@ -1027,7 +1091,8 @@ void CheckMemoryLeakNoVar::checkForUnreleasedInputArgument(const Scope *scope)
 void CheckMemoryLeakNoVar::checkForUnusedReturnValue(const Scope *scope)
 {
     for (const Token *tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
-        if (!Token::Match(tok, "%name% ("))
+        const bool isNew = tok->isCpp() && tok->str() == "new";
+        if (!isNew && !Token::Match(tok, "%name% ("))
             continue;
 
         if (tok->varId())
@@ -1037,24 +1102,43 @@ void CheckMemoryLeakNoVar::checkForUnusedReturnValue(const Scope *scope)
         if (allocType == No)
             continue;
 
-        if (tok != tok->next()->astOperand1())
+        const Token* ftok = tok->next()->astOperand1();
+        while (Token::simpleMatch(ftok, "::"))
+            ftok = ftok->astOperand2() ? ftok->astOperand2() : ftok->astOperand1();
+        if (tok != ftok && !isNew)
             continue;
 
         if (isReopenStandardStream(tok))
             continue;
+        if (isOpenDevNull(tok))
+            continue;
 
         // get ast parent, skip casts
-        const Token *parent = tok->next()->astParent();
-        while (parent && parent->str() == "(" && !parent->astOperand2())
+        const Token *parent = isNew ? tok->astParent() : tok->next()->astParent();
+        while (parent && parent->isCast())
             parent = parent->astParent();
 
-        if (!parent) {
+        bool warn = true;
+        if (isNew) {
+            const Token* typeTok = tok->next();
+            warn = typeTok && (typeTok->isStandardType() || mSettings->library.detectContainer(typeTok));
+        }
+
+        if (!parent && warn) {
             // Check if we are in a C++11 constructor
             const Token * closingBrace = Token::findmatch(tok, "}|;");
-            if (closingBrace->str() == "}" && Token::Match(closingBrace->link()->tokAt(-1), "%name%"))
+            if (closingBrace->str() == "}" && Token::Match(closingBrace->link()->tokAt(-1), "%name%") && (!isNew && precedes(tok, closingBrace->link())))
                 continue;
             returnValueNotUsedError(tok, tok->str());
-        } else if (Token::Match(parent, "%comp%|!")) {
+        } else if (Token::Match(parent, "%comp%|!|,|%oror%|&&|:")) {
+            if (parent->astParent() && parent->str() == ",")
+                continue;
+            if (parent->str() == ":") {
+                if (!(Token::simpleMatch(parent->astParent(), "?") && !parent->astParent()->astParent()))
+                    continue;
+            }
+            if (tok->str() == "freopen")
+                continue;
             returnValueNotUsedError(tok, tok->str());
         }
     }
@@ -1074,12 +1158,17 @@ void CheckMemoryLeakNoVar::checkForUnusedReturnValue(const Scope *scope)
 void CheckMemoryLeakNoVar::checkForUnsafeArgAlloc(const Scope *scope)
 {
     // This test only applies to C++ source
-    if (!mTokenizer->isCPP() || !mSettings->inconclusive || !mSettings->isEnabled(Settings::WARNING))
+    if (!mTokenizer->isCPP())
+        return;
+
+    if (!mSettings->isPremiumEnabled("leakUnsafeArgAlloc") && (!mSettings->certainty.isEnabled(Certainty::inconclusive) || !mSettings->severity.isEnabled(Severity::warning)))
         return;
 
+    logChecker("CheckMemoryLeakNoVar::checkForUnsafeArgAlloc");
+
     for (const Token *tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
         if (Token::Match(tok, "%name% (")) {
-            const Token *endParamToken = tok->next()->link();
+            const Token *endParamToken = tok->linkAt(1);
             const Token* pointerType = nullptr;
             const Token* functionCalled = nullptr;
 
@@ -1088,12 +1177,12 @@ void CheckMemoryLeakNoVar::checkForUnsafeArgAlloc(const Scope *scope)
                 const Function *func = tok2->function();
                 const bool isNothrow = func && (func->isAttributeNothrow() || func->isThrow());
 
-                if (Token::Match(tok2, "shared_ptr|unique_ptr <") && Token::Match(tok2->next()->link(), "> ( new %name%")) {
+                if (Token::Match(tok2, "shared_ptr|unique_ptr <") && Token::Match(tok2->linkAt(1), "> ( new %name%")) {
                     pointerType = tok2;
                 } else if (!isNothrow) {
                     if (Token::Match(tok2, "%name% ("))
                         functionCalled = tok2;
-                    else if (tok2->isName() && Token::simpleMatch(tok2->next()->link(), "> ("))
+                    else if (tok2->isName() && Token::simpleMatch(tok2->linkAt(1), "> ("))
                         functionCalled = tok2;
                 }
             }
@@ -1102,12 +1191,12 @@ void CheckMemoryLeakNoVar::checkForUnsafeArgAlloc(const Scope *scope)
                 std::string functionName = functionCalled->str();
                 if (functionCalled->strAt(1) == "<") {
                     functionName += '<';
-                    for (const Token* tok2 = functionCalled->tokAt(2); tok2 != functionCalled->next()->link(); tok2 = tok2->next())
+                    for (const Token* tok2 = functionCalled->tokAt(2); tok2 != functionCalled->linkAt(1); tok2 = tok2->next())
                         functionName += tok2->str();
                     functionName += '>';
                 }
                 std::string objectTypeName;
-                for (const Token* tok2 = pointerType->tokAt(2); tok2 != pointerType->next()->link(); tok2 = tok2->next())
+                for (const Token* tok2 = pointerType->tokAt(2); tok2 != pointerType->linkAt(1); tok2 = tok2->next())
                     objectTypeName += tok2->str();
 
                 unsafeArgAllocError(tok, functionName, pointerType->str(), objectTypeName);
@@ -1118,12 +1207,12 @@ void CheckMemoryLeakNoVar::checkForUnsafeArgAlloc(const Scope *scope)
 
 void CheckMemoryLeakNoVar::functionCallLeak(const Token *loc, const std::string &alloc, const std::string &functionCall)
 {
-    reportError(loc, Severity::error, "leakNoVarFunctionCall", "Allocation with " + alloc + ", " + functionCall + " doesn't release it.", CWE772, false);
+    reportError(loc, Severity::error, "leakNoVarFunctionCall", "Allocation with " + alloc + ", " + functionCall + " doesn't release it.", CWE772, Certainty::normal);
 }
 
 void CheckMemoryLeakNoVar::returnValueNotUsedError(const Token *tok, const std::string &alloc)
 {
-    reportError(tok, Severity::error, "leakReturnValNotUsed", "$symbol:" + alloc + "\nReturn value of allocation function '$symbol' is not stored.", CWE771, false);
+    reportError(tok, Severity::error, "leakReturnValNotUsed", "$symbol:" + alloc + "\nReturn value of allocation function '$symbol' is not stored.", CWE771, Certainty::normal);
 }
 
 void CheckMemoryLeakNoVar::unsafeArgAllocError(const Token *tok, const std::string &funcName, const std::string &ptrType, const std::string& objType)
@@ -1133,5 +1222,19 @@ void CheckMemoryLeakNoVar::unsafeArgAllocError(const Token *tok, const std::stri
                 "$symbol:" + funcName + "\n"
                 "Unsafe allocation. If $symbol() throws, memory could be leaked. Use " + factoryFunc + "<" + objType + ">() instead.",
                 CWE401,
-                true); // Inconclusive because funcName may never throw
+                Certainty::inconclusive); // Inconclusive because funcName may never throw
+}
+
+void CheckMemoryLeakNoVar::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    CheckMemoryLeakNoVar checkMemoryLeak(&tokenizer, &tokenizer.getSettings(), errorLogger);
+    checkMemoryLeak.check();
+}
+
+void CheckMemoryLeakNoVar::getErrorMessages(ErrorLogger *e, const Settings *settings) const
+{
+    CheckMemoryLeakNoVar c(nullptr, settings, e);
+    c.functionCallLeak(nullptr, "funcName", "funcName");
+    c.returnValueNotUsedError(nullptr, "funcName");
+    c.unsafeArgAllocError(nullptr, "funcName", "shared_ptr", "int");
 }
diff --git a/lib/checkmemoryleak.h b/lib/checkmemoryleak.h
index 424c7263b7d..cf8cc4c11a2 100644
--- a/lib/checkmemoryleak.h
+++ b/lib/checkmemoryleak.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -34,18 +34,20 @@
 
 #include "check.h"
 #include "config.h"
-#include "errorlogger.h"
-#include "tokenize.h"
 
+#include <cstdint>
 #include <list>
 #include <string>
 
 class Function;
 class Scope;
 class Settings;
-class SymbolDatabase;
 class Token;
 class Variable;
+class ErrorLogger;
+struct CWE;
+class Tokenizer;
+enum class Severity : std::uint8_t;
 
 /// @addtogroup Core
 /// @{
@@ -70,7 +72,7 @@ class CPPCHECKLIB CheckMemoryLeak {
      * @param msg text
      * @param cwe cwe number
      */
-    void reportErr(const Token *tok, Severity::SeverityType severity, const std::string &id, const std::string &msg, const CWE &cwe) const;
+    void reportErr(const Token *tok, Severity severity, const std::string &id, const std::string &msg, const CWE &cwe) const;
 
     /**
      * Report error. Similar with the function Check::reportError
@@ -80,19 +82,18 @@ class CPPCHECKLIB CheckMemoryLeak {
      * @param msg text
      * @param cwe cwe number
      */
-    void reportErr(const std::list<const Token *> &callstack, Severity::SeverityType severity, const std::string &id, const std::string &msg, const CWE &cwe) const;
+    void reportErr(const std::list<const Token *> &callstack, Severity severity, const std::string &id, const std::string &msg, const CWE &cwe) const;
 
 public:
     CheckMemoryLeak() = delete;
     CheckMemoryLeak(const CheckMemoryLeak &) = delete;
-    void operator=(const CheckMemoryLeak &) = delete;
+    CheckMemoryLeak& operator=(const CheckMemoryLeak &) = delete;
 
     CheckMemoryLeak(const Tokenizer *t, ErrorLogger *e, const Settings *s)
-        : mTokenizer_(t), mErrorLogger_(e), mSettings_(s) {
-    }
+        : mTokenizer_(t), mErrorLogger_(e), mSettings_(s) {}
 
     /** @brief What type of allocation are used.. the "Many" means that several types of allocation and deallocation are used */
-    enum AllocType { No, Malloc, New, NewArray, File, Fd, Pipe, OtherMem, OtherRes, Many };
+    enum AllocType : std::uint8_t { No, Malloc, New, NewArray, File, Fd, Pipe, OtherMem, OtherRes, Many };
 
     void memoryLeak(const Token *tok, const std::string &varname, AllocType alloctype) const;
 
@@ -119,6 +120,11 @@ class CPPCHECKLIB CheckMemoryLeak {
      * @param tok token to check
      */
     bool isReopenStandardStream(const Token *tok) const;
+    /**
+     * Check if token opens /dev/null
+     * @param tok token to check
+     */
+    bool isOpenDevNull(const Token *tok) const;
     /**
      * Report that there is a memory leak (new/malloc/etc)
      * @param tok token where memory is leaked
@@ -133,22 +139,12 @@ class CPPCHECKLIB CheckMemoryLeak {
      */
     void resourceLeakError(const Token *tok, const std::string &varname) const;
 
-    /**
-     * @brief Report error: deallocating a deallocated pointer
-     * @param tok token where error occurs
-     * @param varname name of variable
-     */
-    void deallocDeallocError(const Token *tok, const std::string &varname) const;
     void deallocuseError(const Token *tok, const std::string &varname) const;
-    void mismatchSizeError(const Token *tok, const std::string &sz) const;
     void mismatchAllocDealloc(const std::list<const Token *> &callstack, const std::string &varname) const;
     void memleakUponReallocFailureError(const Token *tok, const std::string &reallocfunction, const std::string &varname) const;
 
     /** What type of allocated memory does the given function return? */
     AllocType functionReturnType(const Function* func, std::list<const Function*> *callstack = nullptr) const;
-
-    /** Function allocates pointed-to argument (a la asprintf)? */
-    const char *functionArgAlloc(const Function *func, nonneg int targetpar, AllocType &allocType) const;
 };
 
 /// @}
@@ -169,45 +165,27 @@ class CPPCHECKLIB CheckMemoryLeak {
  * -# finally, check if the simplified token list contain any leaks.
  */
 
-class CPPCHECKLIB CheckMemoryLeakInFunction : private Check, public CheckMemoryLeak {
+class CPPCHECKLIB CheckMemoryLeakInFunction : public Check, public CheckMemoryLeak {
+    friend class TestMemleakInFunction;
+
 public:
     /** @brief This constructor is used when registering this class */
-    CheckMemoryLeakInFunction() : Check(myName()), CheckMemoryLeak(nullptr, nullptr, nullptr) {
-    }
+    CheckMemoryLeakInFunction() : Check(myName()), CheckMemoryLeak(nullptr, nullptr, nullptr) {}
 
+private:
     /** @brief This constructor is used when running checks */
     CheckMemoryLeakInFunction(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger), CheckMemoryLeak(tokenizer, errorLogger, settings) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger), CheckMemoryLeak(tokenizer, errorLogger, settings) {}
 
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        CheckMemoryLeakInFunction checkMemoryLeak(tokenizer, settings, errorLogger);
-        checkMemoryLeak.checkReallocUsage();
-    }
-
-    /** @brief Unit testing : testing the white list */
-    static bool test_white_list(const std::string &funcname, const Settings *settings, bool cpp);
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     /**
      * Checking for a memory leak caused by improper realloc usage.
      */
     void checkReallocUsage();
 
-private:
     /** Report all possible errors (for the --errorlist) */
-    void getErrorMessages(ErrorLogger *e, const Settings *settings) const OVERRIDE {
-        CheckMemoryLeakInFunction c(nullptr, settings, e);
-
-        c.memleakError(nullptr, "varname");
-        c.resourceLeakError(nullptr, "varname");
-
-        c.deallocDeallocError(nullptr, "varname");
-        c.deallocuseError(nullptr, "varname");
-        c.mismatchSizeError(nullptr, "sz");
-        const std::list<const Token *> callstack;
-        c.mismatchAllocDealloc(callstack, "varname");
-        c.memleakUponReallocFailureError(nullptr, "realloc", "varname");
-    }
+    void getErrorMessages(ErrorLogger *e, const Settings *settings) const override;
 
     /**
      * Get name of class (--doc)
@@ -221,7 +199,7 @@ class CPPCHECKLIB CheckMemoryLeakInFunction : private Check, public CheckMemoryL
      * Get class information (--doc)
      * @return Wiki formatted information about this class
      */
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Is there any allocated memory when a function goes out of scope\n";
     }
 };
@@ -232,26 +210,20 @@ class CPPCHECKLIB CheckMemoryLeakInFunction : private Check, public CheckMemoryL
  * @brief %Check class variables, variables that are allocated in the constructor should be deallocated in the destructor
  */
 
-class CPPCHECKLIB CheckMemoryLeakInClass : private Check, private CheckMemoryLeak {
+class CPPCHECKLIB CheckMemoryLeakInClass : public Check, private CheckMemoryLeak {
+    friend class TestMemleakInClass;
+
 public:
-    CheckMemoryLeakInClass() : Check(myName()), CheckMemoryLeak(nullptr, nullptr, nullptr) {
-    }
+    CheckMemoryLeakInClass() : Check(myName()), CheckMemoryLeak(nullptr, nullptr, nullptr) {}
 
+private:
     CheckMemoryLeakInClass(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger), CheckMemoryLeak(tokenizer, errorLogger, settings) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger), CheckMemoryLeak(tokenizer, errorLogger, settings) {}
 
-    void runChecks(const Tokenizer *tokenizr, const Settings *settings, ErrorLogger *errLog) OVERRIDE {
-        if (!tokenizr->isCPP())
-            return;
-
-        CheckMemoryLeakInClass checkMemoryLeak(tokenizr, settings, errLog);
-        checkMemoryLeak.check();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     void check();
 
-private:
     void variable(const Scope *scope, const Token *tokVarname);
 
     /** Public functions: possible double-allocation */
@@ -260,17 +232,13 @@ class CPPCHECKLIB CheckMemoryLeakInClass : private Check, private CheckMemoryLea
 
     void unsafeClassError(const Token *tok, const std::string &classname, const std::string &varname);
 
-    void getErrorMessages(ErrorLogger *e, const Settings *settings) const OVERRIDE {
-        CheckMemoryLeakInClass c(nullptr, settings, e);
-        c.publicAllocationError(nullptr, "varname");
-        c.unsafeClassError(nullptr, "class", "class::varname");
-    }
+    void getErrorMessages(ErrorLogger *e, const Settings *settings) const override;
 
     static std::string myName() {
         return "Memory leaks (class variables)";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "If the constructor allocate memory then the destructor must deallocate it.\n";
     }
 };
@@ -279,37 +247,32 @@ class CPPCHECKLIB CheckMemoryLeakInClass : private Check, private CheckMemoryLea
 
 /** @brief detect simple memory leaks for struct members */
 
-class CPPCHECKLIB CheckMemoryLeakStructMember : private Check, private CheckMemoryLeak {
+class CPPCHECKLIB CheckMemoryLeakStructMember : public Check, private CheckMemoryLeak {
+    friend class TestMemleakStructMember;
+
 public:
-    CheckMemoryLeakStructMember() : Check(myName()), CheckMemoryLeak(nullptr, nullptr, nullptr) {
-    }
+    CheckMemoryLeakStructMember() : Check(myName()), CheckMemoryLeak(nullptr, nullptr, nullptr) {}
 
+private:
     CheckMemoryLeakStructMember(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger), CheckMemoryLeak(tokenizer, errorLogger, settings) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger), CheckMemoryLeak(tokenizer, errorLogger, settings) {}
 
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        CheckMemoryLeakStructMember checkMemoryLeak(tokenizer, settings, errorLogger);
-        checkMemoryLeak.check();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     void check();
 
-private:
-
     /** Is local variable allocated with malloc? */
-    static bool isMalloc(const Variable *variable);
+    bool isMalloc(const Variable *variable) const;
 
-    void checkStructVariable(const Variable * const variable);
+    void checkStructVariable(const Variable*  variable) const;
 
-    void getErrorMessages(ErrorLogger * /*errorLogger*/, const Settings * /*settings*/) const OVERRIDE {
-    }
+    void getErrorMessages(ErrorLogger * errorLogger, const Settings * settings) const override;
 
     static std::string myName() {
         return "Memory leaks (struct members)";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Don't forget to deallocate struct members\n";
     }
 };
@@ -318,23 +281,20 @@ class CPPCHECKLIB CheckMemoryLeakStructMember : private Check, private CheckMemo
 
 /** @brief detect simple memory leaks (address not taken) */
 
-class CPPCHECKLIB CheckMemoryLeakNoVar : private Check, private CheckMemoryLeak {
+class CPPCHECKLIB CheckMemoryLeakNoVar : public Check, private CheckMemoryLeak {
+    friend class TestMemleakNoVar;
+
 public:
-    CheckMemoryLeakNoVar() : Check(myName()), CheckMemoryLeak(nullptr, nullptr, nullptr) {
-    }
+    CheckMemoryLeakNoVar() : Check(myName()), CheckMemoryLeak(nullptr, nullptr, nullptr) {}
 
+private:
     CheckMemoryLeakNoVar(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger), CheckMemoryLeak(tokenizer, errorLogger, settings) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger), CheckMemoryLeak(tokenizer, errorLogger, settings) {}
 
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        CheckMemoryLeakNoVar checkMemoryLeak(tokenizer, settings, errorLogger);
-        checkMemoryLeak.check();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     void check();
 
-private:
     /**
      * @brief %Check if an input argument to a function is the return value of an allocation function
      * like malloc(), and the function does not release it.
@@ -358,19 +318,13 @@ class CPPCHECKLIB CheckMemoryLeakNoVar : private Check, private CheckMemoryLeak
     void returnValueNotUsedError(const Token* tok, const std::string &alloc);
     void unsafeArgAllocError(const Token *tok, const std::string &funcName, const std::string &ptrType, const std::string &objType);
 
-    void getErrorMessages(ErrorLogger *e, const Settings *settings) const OVERRIDE {
-        CheckMemoryLeakNoVar c(nullptr, settings, e);
-
-        c.functionCallLeak(nullptr, "funcName", "funcName");
-        c.returnValueNotUsedError(nullptr, "funcName");
-        c.unsafeArgAllocError(nullptr, "funcName", "shared_ptr", "int");
-    }
+    void getErrorMessages(ErrorLogger *e, const Settings *settings) const override;
 
     static std::string myName() {
         return "Memory leaks (address not taken)";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Not taking the address to allocated memory\n";
     }
 };
diff --git a/lib/checknullpointer.cpp b/lib/checknullpointer.cpp
index 2c61a065167..42b9f76646e 100644
--- a/lib/checknullpointer.cpp
+++ b/lib/checknullpointer.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,28 +21,37 @@
 #include "checknullpointer.h"
 
 #include "astutils.h"
+#include "ctu.h"
 #include "errorlogger.h"
+#include "errortypes.h"
+#include "findtoken.h"
 #include "library.h"
 #include "settings.h"
 #include "symboldatabase.h"
 #include "token.h"
 #include "tokenize.h"
-#include "utils.h"
+#include "tokenlist.h"
+#include "valueflow.h"
+#include "vfvalue.h"
 
 #include <algorithm>
 #include <cctype>
-#include <cstddef>
+#include <map>
 #include <set>
+#include <utility>
+#include <vector>
+
 //---------------------------------------------------------------------------
 
+// CWE ids used:
+static const CWE CWE_NULL_POINTER_DEREFERENCE(476U);
+static const CWE CWE_INCORRECT_CALCULATION(682U);
+
 // Register this check class (by creating a static instance of it)
 namespace {
     CheckNullPointer instance;
 }
 
-static const CWE CWE476(476U);  // NULL Pointer Dereference
-static const CWE CWE682(682U);  // Incorrect Calculation
-
 //---------------------------------------------------------------------------
 
 static bool checkNullpointerFunctionCallPlausibility(const Function* func, unsigned int arg)
@@ -55,29 +64,28 @@ static bool checkNullpointerFunctionCallPlausibility(const Function* func, unsig
  * @param tok first token
  * @param var variables that the function read / write.
  * @param library --library files data
+ * @param checkNullArg perform isnullargbad check for each argument?
  */
-void CheckNullPointer::parseFunctionCall(const Token &tok, std::list<const Token *> &var, const Library *library)
+void CheckNullPointer::parseFunctionCall(const Token &tok, std::list<const Token *> &var, const Library &library, bool checkNullArg)
 {
     if (Token::Match(&tok, "%name% ( )") || !tok.tokAt(2))
         return;
 
     const std::vector<const Token *> args = getArguments(&tok);
 
-    if (library || tok.function() != nullptr) {
-        for (int argnr = 1; argnr <= args.size(); ++argnr) {
-            const Token *param = args[argnr - 1];
-            if (library && library->isnullargbad(&tok, argnr) && checkNullpointerFunctionCallPlausibility(tok.function(), argnr))
+    for (int argnr = 1; argnr <= args.size(); ++argnr) {
+        const Token *param = args[argnr - 1];
+        if ((!checkNullArg || library.isnullargbad(&tok, argnr)) && checkNullpointerFunctionCallPlausibility(tok.function(), argnr))
+            var.push_back(param);
+        else if (tok.function()) {
+            const Variable* argVar = tok.function()->getArgumentVar(argnr-1);
+            if (argVar && argVar->isStlStringType() && !argVar->isArrayOrPointer())
                 var.push_back(param);
-            else if (tok.function()) {
-                const Variable* argVar = tok.function()->getArgumentVar(argnr-1);
-                if (argVar && argVar->isStlStringType() && !argVar->isArrayOrPointer())
-                    var.push_back(param);
-            }
         }
     }
 
-    if (library && library->formatstr_function(&tok)) {
-        const int formatStringArgNr = library->formatstr_argno(&tok);
+    if (library.formatstr_function(&tok)) {
+        const int formatStringArgNr = library.formatstr_argno(&tok);
         if (formatStringArgNr < 0 || formatStringArgNr >= args.size())
             return;
 
@@ -89,17 +97,17 @@ void CheckNullPointer::parseFunctionCall(const Token &tok, std::list<const Token
             return;
         const std::string &formatString = args[formatStringArgNr]->strValue();
         int argnr = formatStringArgNr + 1;
-        const bool scan = library->formatstr_scan(&tok);
+        const bool scan = library.formatstr_scan(&tok);
 
         bool percent = false;
-        for (std::string::const_iterator i = formatString.begin(); i != formatString.end(); ++i) {
+        for (auto i = formatString.cbegin(); i != formatString.cend(); ++i) {
             if (*i == '%') {
                 percent = !percent;
             } else if (percent) {
                 percent = false;
 
                 bool _continue = false;
-                while (!std::isalpha((unsigned char)*i)) {
+                while (!std::isalpha(static_cast<unsigned char>(*i))) {
                     if (*i == '*') {
                         if (scan)
                             _continue = true;
@@ -142,15 +150,15 @@ namespace {
  */
 bool CheckNullPointer::isPointerDeRef(const Token *tok, bool &unknown) const
 {
-    return isPointerDeRef(tok, unknown, mSettings);
+    return isPointerDeRef(tok, unknown, *mSettings);
 }
 
-bool CheckNullPointer::isPointerDeRef(const Token *tok, bool &unknown, const Settings *settings)
+bool CheckNullPointer::isPointerDeRef(const Token *tok, bool &unknown, const Settings &settings, bool checkNullArg)
 {
     unknown = false;
 
     // Is pointer used as function parameter?
-    if (Token::Match(tok->previous(), "[(,] %name% [,)]") && settings) {
+    if (Token::Match(tok->previous(), "[(,] %name% [,)]")) {
         const Token *ftok = tok->previous();
         while (ftok && ftok->str() != "(") {
             if (ftok->str() == ")")
@@ -159,31 +167,39 @@ bool CheckNullPointer::isPointerDeRef(const Token *tok, bool &unknown, const Set
         }
         if (ftok && ftok->previous()) {
             std::list<const Token *> varlist;
-            parseFunctionCall(*ftok->previous(), varlist, &settings->library);
-            if (std::find(varlist.begin(), varlist.end(), tok) != varlist.end()) {
+            parseFunctionCall(*ftok->previous(), varlist, settings.library, checkNullArg);
+            if (std::find(varlist.cbegin(), varlist.cend(), tok) != varlist.cend()) {
                 return true;
             }
         }
     }
 
+    if (tok->str() == "(" && !tok->scope()->isExecutable())
+        return false;
+
     const Token* parent = tok->astParent();
     if (!parent)
         return false;
-    if (parent->str() == "." && parent->astOperand2() == tok)
+    const bool addressOf = parent->astParent() && parent->astParent()->str() == "&";
+    if (parent->str() == "." && astIsRHS(tok))
         return isPointerDeRef(parent, unknown, settings);
     const bool firstOperand = parent->astOperand1() == tok;
-    while (parent->str() == "(" && (parent->astOperand2() == nullptr && parent->strAt(1) != ")")) { // Skip over casts
-        parent = parent->astParent();
-        if (!parent)
-            return false;
-    }
+    parent = astParentSkipParens(tok);
+    if (!parent)
+        return false;
 
     // Dereferencing pointer..
-    if (parent->isUnaryOp("*") && !Token::Match(parent->tokAt(-2), "sizeof|decltype|typeof"))
-        return true;
+    const Token* grandParent = parent->astParent();
+    if (parent->isUnaryOp("*") && !(grandParent && isUnevaluated(grandParent->previous()))) {
+        // declaration of function pointer
+        if (tok->variable() && tok->variable()->nameToken() == tok)
+            return false;
+        if (!addressOf)
+            return true;
+    }
 
     // array access
-    if (firstOperand && parent->str() == "[" && (!parent->astParent() || parent->astParent()->str() != "&"))
+    if (firstOperand && parent->str() == "[" && !addressOf)
         return true;
 
     // address of member variable / array element
@@ -194,14 +210,12 @@ bool CheckNullPointer::isPointerDeRef(const Token *tok, bool &unknown, const Set
         return false;
 
     // read/write member variable
-    if (firstOperand && parent->str() == "." && (!parent->astParent() || parent->astParent()->str() != "&")) {
-        if (!parent->astParent() || parent->astParent()->str() != "(" || parent->astParent() == tok->previous())
-            return true;
-        unknown = true;
-        return false;
-    }
+    if (firstOperand && parent->originalName() == "->" && !addressOf)
+        return true;
 
-    if (Token::Match(tok, "%name% ("))
+    // If its a function pointer then check if its called
+    if (tok->variable() && tok->variable()->isPointer() && Token::Match(tok->variable()->nameToken(), "%name% ) (") &&
+        Token::Match(tok, "%name% ("))
         return true;
 
     if (Token::Match(tok, "%var% = %var% .") &&
@@ -209,10 +223,10 @@ bool CheckNullPointer::isPointerDeRef(const Token *tok, bool &unknown, const Set
         return true;
 
     // std::string dereferences nullpointers
-    if (Token::Match(parent->tokAt(-3), "std :: string|wstring (") && tok->strAt(1) == ")")
+    if (Token::Match(parent->tokAt(-3), "std :: string|wstring (|{"))
         return true;
-    if (Token::Match(parent->previous(), "%name% (") && tok->strAt(1) == ")") {
-        const Variable* var = tok->tokAt(-2)->variable();
+    if (Token::Match(parent->previous(), "%name% (|{")) {
+        const Variable* var = parent->previous()->variable();
         if (var && !var->isPointer() && !var->isArray() && var->isStlStringType())
             return true;
     }
@@ -251,138 +265,73 @@ bool CheckNullPointer::isPointerDeRef(const Token *tok, bool &unknown, const Set
 }
 
 
-void CheckNullPointer::nullPointerLinkedList()
-{
-
-    if (!mSettings->isEnabled(Settings::WARNING))
-        return;
-
-    const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
-
-    // looping through items in a linked list in a inner loop.
-    // Here is an example:
-    //    for (const Token *tok = tokens; tok; tok = tok->next) {
-    //        if (tok->str() == "hello")
-    //            tok = tok->next;   // <- tok might become a null pointer!
-    //    }
-    for (const Scope &forScope : symbolDatabase->scopeList) {
-        const Token* const tok1 = forScope.classDef;
-        // search for a "for" scope..
-        if (forScope.type != Scope::eFor || !tok1)
-            continue;
-
-        // is there any dereferencing occurring in the for statement
-        const Token* end2 = tok1->linkAt(1);
-        for (const Token *tok2 = tok1->tokAt(2); tok2 != end2; tok2 = tok2->next()) {
-            // Dereferencing a variable inside the "for" parentheses..
-            if (Token::Match(tok2, "%var% . %name%")) {
-                // Is this variable a pointer?
-                const Variable *var = tok2->variable();
-                if (!var || !var->isPointer())
-                    continue;
-
-                // Variable id for dereferenced variable
-                const unsigned int varid(tok2->varId());
-
-                if (Token::Match(tok2->tokAt(-2), "%varid% ?", varid))
-                    continue;
-
-                // Check usage of dereferenced variable in the loop..
-                // TODO: Move this to ValueFlow
-                for (const Scope *innerScope : forScope.nestedList) {
-                    if (innerScope->type != Scope::eWhile)
-                        continue;
-
-                    // TODO: are there false negatives for "while ( %varid% ||"
-                    if (Token::Match(innerScope->classDef->next(), "( %varid% &&|)", varid)) {
-                        // Make sure there is a "break" or "return" inside the loop.
-                        // Without the "break" a null pointer could be dereferenced in the
-                        // for statement.
-                        for (const Token *tok4 = innerScope->bodyStart; tok4; tok4 = tok4->next()) {
-                            if (tok4 == forScope.bodyEnd) {
-                                const ValueFlow::Value v(innerScope->classDef, 0LL);
-                                nullPointerError(tok1, var->name(), &v, false);
-                                break;
-                            }
-
-                            // There is a "break" or "return" inside the loop.
-                            // TODO: there can be false negatives. There could still be
-                            //       execution paths that are not properly terminated
-                            else if (tok4->str() == "break" || tok4->str() == "return")
-                                break;
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-static bool isNullablePointer(const Token* tok, const Settings* settings)
+static bool isNullablePointer(const Token* tok)
 {
     if (!tok)
         return false;
+    if (Token::simpleMatch(tok, "new") && tok->varId() == 0)
+        return false;
     if (astIsPointer(tok))
         return true;
     if (astIsSmartPointer(tok))
         return true;
-    // TODO: Move this logic into ValueType
     if (Token::simpleMatch(tok, "."))
-        return isNullablePointer(tok->astOperand2(), settings);
+        return isNullablePointer(tok->astOperand2());
     if (const Variable* var = tok->variable()) {
         return (var->isPointer() || var->isSmartPointer());
     }
-    if (Token::Match(tok->previous(), "%name% (")) {
-        if (const Function* f = tok->previous()->function()) {
-            if (f->retDef) {
-                ValueType vt = ValueType::parseDecl(f->retDef, settings);
-                return vt.smartPointerTypeToken || vt.pointer > 0;
-            }
-        }
-    }
     return false;
 }
 
-void CheckNullPointer::nullPointerByDeRefAndChec()
+void CheckNullPointer::nullPointerByDeRefAndCheck()
 {
-    const bool printInconclusive = (mSettings->inconclusive);
+    const bool printInconclusive = (mSettings->certainty.isEnabled(Certainty::inconclusive));
 
-    for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "sizeof|decltype|typeid|typeof (")) {
-            tok = tok->next()->link();
-            continue;
-        }
+    const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
+    for (const Scope * scope : symbolDatabase->functionScopes) {
+        auto pred = [printInconclusive](const Token* tok) -> bool {
+            if (!tok)
+                return false;
 
-        if (Token::Match(tok, "%num%|%char%|%str%"))
-            continue;
+            if (Token::Match(tok, "%num%|%char%|%str%"))
+                return false;
 
-        if (!isNullablePointer(tok, mSettings))
-            continue;
+            if (!isNullablePointer(tok) ||
+                (tok->str() == "." && isNullablePointer(tok->astOperand2()) && tok->astOperand2()->getValue(0))) // avoid duplicate warning
+                return false;
 
-        // Can pointer be NULL?
-        const ValueFlow::Value *value = tok->getValue(0);
-        if (!value)
-            continue;
+            // Can pointer be NULL?
+            const ValueFlow::Value *value = tok->getValue(0);
+            if (!value)
+                return false;
 
-        if (!printInconclusive && value->isInconclusive())
-            continue;
+            if (!printInconclusive && value->isInconclusive())
+                return false;
 
-        // Pointer dereference.
-        bool unknown = false;
-        if (!isPointerDeRef(tok,unknown)) {
-            if (unknown)
-                nullPointerError(tok, tok->expressionString(), value, true);
-            continue;
-        }
+            return true;
+        };
+        const Token* const start = (scope->function && scope->function->isConstructor()) ? scope->function->token : scope->bodyStart; // Check initialization list
+        std::vector<const Token *> tokens = findTokensSkipDeadAndUnevaluatedCode(mSettings->library, start, scope->bodyEnd, pred);
+        for (const Token *tok : tokens) {
+            const ValueFlow::Value *value = tok->getValue(0);
+
+            // Pointer dereference.
+            bool unknown = false;
+            if (!isPointerDeRef(tok, unknown)) {
+                if (unknown)
+                    nullPointerError(tok, tok->expressionString(), value, true);
+                continue;
+            }
 
-        nullPointerError(tok, tok->expressionString(), value, value->isInconclusive());
+            nullPointerError(tok, tok->expressionString(), value, value->isInconclusive());
+        }
     }
 }
 
 void CheckNullPointer::nullPointer()
 {
-    nullPointerLinkedList();
-    nullPointerByDeRefAndChec();
+    logChecker("CheckNullPointer::nullPointer");
+    nullPointerByDeRefAndCheck();
 }
 
 namespace {
@@ -395,6 +344,8 @@ namespace {
 /** Dereferencing null constant (simplified token list) */
 void CheckNullPointer::nullConstantDereference()
 {
+    logChecker("CheckNullPointer::nullConstantDereference");
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope * scope : symbolDatabase->functionScopes) {
@@ -407,8 +358,8 @@ void CheckNullPointer::nullConstantDereference()
             tok = scope->function->token; // Check initialization list
 
         for (; tok != scope->bodyEnd; tok = tok->next()) {
-            if (Token::Match(tok, "sizeof|decltype|typeid|typeof ("))
-                tok = tok->next()->link();
+            if (isUnevaluated(tok))
+                tok = tok->linkAt(1);
 
             else if (Token::simpleMatch(tok, "* 0")) {
                 if (Token::Match(tok->previous(), "return|throw|;|{|}|:|[|(|,") || tok->previous()->isOp()) {
@@ -416,17 +367,17 @@ void CheckNullPointer::nullConstantDereference()
                 }
             }
 
-            else if (Token::Match(tok, "0 [") && (tok->previous()->str() != "&" || !Token::Match(tok->next()->link()->next(), "[.(]")))
+            else if (Token::Match(tok, "0 [") && (tok->strAt(-1) != "&" || !Token::Match(tok->linkAt(1)->next(), "[.(]")))
                 nullPointerError(tok);
 
-            else if (Token::Match(tok->previous(), "!!. %name% (") && (tok->previous()->str() != "::" || tok->strAt(-2) == "std")) {
-                if (Token::Match(tok->tokAt(2), "0|NULL|nullptr )") && tok->varId()) { // constructor call
+            else if (Token::Match(tok->previous(), "!!. %name% (|{") && (tok->strAt(-1) != "::" || tok->strAt(-2) == "std")) {
+                if (Token::Match(tok->tokAt(2), "0|NULL|nullptr )|}") && tok->varId()) { // constructor call
                     const Variable *var = tok->variable();
                     if (var && !var->isPointer() && !var->isArray() && var->isStlStringType())
                         nullPointerError(tok);
                 } else { // function call
                     std::list<const Token *> var;
-                    parseFunctionCall(*tok, var, &mSettings->library);
+                    parseFunctionCall(*tok, var, mSettings->library);
 
                     // is one of the var items a NULL pointer?
                     for (const Token *vartok : var) {
@@ -443,7 +394,7 @@ void CheckNullPointer::nullConstantDereference()
                     const Token *argtok = args[argnr];
                     if (!argtok->hasKnownIntValue())
                         continue;
-                    if (argtok->values().front().intvalue != 0)
+                    if (argtok->getKnownIntValue() != 0)
                         continue;
                     if (mSettings->library.isnullargbad(tok, argnr+1))
                         nullPointerError(argtok);
@@ -456,7 +407,7 @@ void CheckNullPointer::nullConstantDereference()
                     if (Token::Match(tok2->previous(), ";|{|}|:|("))
                         break;
                 }
-                if (tok2 && tok2->previous() && tok2->previous()->str()=="(")
+                if (tok2 && tok2->previous() && tok2->strAt(-1)=="(")
                     continue;
                 if (Token::simpleMatch(tok2, "std :: cin"))
                     nullPointerError(tok);
@@ -485,48 +436,68 @@ void CheckNullPointer::nullConstantDereference()
     }
 }
 
+void CheckNullPointer::nullPointerError(const Token *tok)
+{
+    ValueFlow::Value v(0);
+    v.setKnown();
+    nullPointerError(tok, "", &v, false);
+}
+
 void CheckNullPointer::nullPointerError(const Token *tok, const std::string &varname, const ValueFlow::Value *value, bool inconclusive)
 {
     const std::string errmsgcond("$symbol:" + varname + '\n' + ValueFlow::eitherTheConditionIsRedundant(value ? value->condition : nullptr) + " or there is possible null pointer dereference: $symbol.");
     const std::string errmsgdefarg("$symbol:" + varname + "\nPossible null pointer dereference if the default parameter value is used: $symbol");
 
     if (!tok) {
-        reportError(tok, Severity::error, "nullPointer", "Null pointer dereference", CWE476, false);
-        reportError(tok, Severity::warning, "nullPointerDefaultArg", errmsgdefarg, CWE476, false);
-        reportError(tok, Severity::warning, "nullPointerRedundantCheck", errmsgcond, CWE476, false);
+        reportError(tok, Severity::error, "nullPointer", "Null pointer dereference", CWE_NULL_POINTER_DEREFERENCE, Certainty::normal);
+        reportError(tok, Severity::warning, "nullPointerDefaultArg", errmsgdefarg, CWE_NULL_POINTER_DEREFERENCE, Certainty::normal);
+        reportError(tok, Severity::warning, "nullPointerRedundantCheck", errmsgcond, CWE_NULL_POINTER_DEREFERENCE, Certainty::normal);
+        reportError(tok, Severity::warning, "nullPointerOutOfMemory", "Null pointer dereference", CWE_NULL_POINTER_DEREFERENCE, Certainty::normal);
+        reportError(tok, Severity::warning, "nullPointerOutOfResources", "Null pointer dereference", CWE_NULL_POINTER_DEREFERENCE, Certainty::normal);
         return;
     }
 
     if (!value) {
-        reportError(tok, Severity::error, "nullPointer", "Null pointer dereference", CWE476, inconclusive);
+        reportError(tok, Severity::error, "nullPointer", "Null pointer dereference", CWE_NULL_POINTER_DEREFERENCE, inconclusive ? Certainty::inconclusive : Certainty::normal);
         return;
     }
 
-    if (!mSettings->isEnabled(value, inconclusive))
+    if (!mSettings->isEnabled(value, inconclusive) && !mSettings->isPremiumEnabled("nullPointer"))
         return;
 
-    const ErrorPath errorPath = getErrorPath(tok, value, "Null pointer dereference");
+    ErrorPath errorPath = getErrorPath(tok, value, "Null pointer dereference");
 
     if (value->condition) {
-        reportError(errorPath, Severity::warning, "nullPointerRedundantCheck", errmsgcond, CWE476, inconclusive || value->isInconclusive());
+        reportError(std::move(errorPath), Severity::warning, "nullPointerRedundantCheck", errmsgcond, CWE_NULL_POINTER_DEREFERENCE, inconclusive || value->isInconclusive() ? Certainty::inconclusive : Certainty::normal);
     } else if (value->defaultArg) {
-        reportError(errorPath, Severity::warning, "nullPointerDefaultArg", errmsgdefarg, CWE476, inconclusive || value->isInconclusive());
+        reportError(std::move(errorPath), Severity::warning, "nullPointerDefaultArg", errmsgdefarg, CWE_NULL_POINTER_DEREFERENCE, inconclusive || value->isInconclusive() ? Certainty::inconclusive : Certainty::normal);
     } else {
-        std::string errmsg;
-        errmsg = std::string(value->isKnown() ? "Null" : "Possible null") + " pointer dereference";
+        std::string errmsg = std::string(value->isKnown() ? "Null" : "Possible null") + " pointer dereference";
+
+        std::string id = "nullPointer";
+        if (value->unknownFunctionReturn == ValueFlow::Value::UnknownFunctionReturn::outOfMemory) {
+            errmsg = "If memory allocation fails, then there is a " + (static_cast<char>(std::tolower(errmsg[0])) + errmsg.substr(1));
+            id += "OutOfMemory";
+        }
+        else if (value->unknownFunctionReturn == ValueFlow::Value::UnknownFunctionReturn::outOfResources) {
+            errmsg = "If resource allocation fails, then there is a " + (static_cast<char>(std::tolower(errmsg[0])) + errmsg.substr(1));
+            id += "OutOfResources";
+        }
+
         if (!varname.empty())
             errmsg = "$symbol:" + varname + '\n' + errmsg + ": $symbol";
 
-        reportError(errorPath,
+        reportError(std::move(errorPath),
                     value->isKnown() ? Severity::error : Severity::warning,
-                    "nullPointer",
+                    id.c_str(),
                     errmsg,
-                    CWE476, inconclusive || value->isInconclusive());
+                    CWE_NULL_POINTER_DEREFERENCE, inconclusive || value->isInconclusive() ? Certainty::inconclusive : Certainty::normal);
     }
 }
 
 void CheckNullPointer::arithmetic()
 {
+    logChecker("CheckNullPointer::arithmetic");
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
@@ -544,23 +515,15 @@ void CheckNullPointer::arithmetic()
                 continue;
             if (numericOperand && numericOperand->valueType() && !numericOperand->valueType()->isIntegral())
                 continue;
-            MathLib::bigint checkValue = 0;
-            // When using an assign op, the value read from
-            // valueflow has already been updated, so instead of
-            // checking for zero we check that the value is equal
-            // to RHS
-            if (tok->astOperand2() && tok->astOperand2()->hasKnownIntValue()) {
-                if (tok->str() == "-=")
-                    checkValue -= tok->astOperand2()->values().front().intvalue;
-                else if (tok->str() == "+=")
-                    checkValue = tok->astOperand2()->values().front().intvalue;
-            }
-            const ValueFlow::Value *value = pointerOperand->getValue(checkValue);
+            const ValueFlow::Value* numValue = numericOperand ? numericOperand->getValue(0) : nullptr;
+            if (numValue && numValue->intvalue == 0) // don't warn for arithmetic with 0
+                continue;
+            const ValueFlow::Value* value = pointerOperand->getValue(0);
             if (!value)
                 continue;
-            if (!mSettings->inconclusive && value->isInconclusive())
+            if (!mSettings->certainty.isEnabled(Certainty::inconclusive) && value->isInconclusive())
                 continue;
-            if (value->condition && !mSettings->isEnabled(Settings::WARNING))
+            if (value->condition && !mSettings->severity.isEnabled(Severity::warning))
                 continue;
             if (value->condition)
                 redundantConditionWarning(tok, value, value->condition, value->isInconclusive());
@@ -574,14 +537,14 @@ static std::string arithmeticTypeString(const Token *tok)
 {
     if (tok && tok->str()[0] == '-')
         return "subtraction";
-    else if (tok && tok->str()[0] == '+')
+    if (tok && tok->str()[0] == '+')
         return "addition";
-    else
-        return "arithmetic";
+    return "arithmetic";
 }
 
 void CheckNullPointer::pointerArithmeticError(const Token* tok, const ValueFlow::Value *value, bool inconclusive)
 {
+    // cppcheck-suppress shadowFunction - TODO: fix this
     std::string arithmetic = arithmeticTypeString(tok);
     std::string errmsg;
     if (tok && tok->str()[0] == '-') {
@@ -589,17 +552,29 @@ void CheckNullPointer::pointerArithmeticError(const Token* tok, const ValueFlow:
     } else {
         errmsg = "Pointer " + arithmetic + " with NULL pointer.";
     }
-    const ErrorPath errorPath = getErrorPath(tok, value, "Null pointer " + arithmetic);
-    reportError(errorPath,
+
+    std::string id = "nullPointerArithmetic";
+    if (value && value->unknownFunctionReturn == ValueFlow::Value::UnknownFunctionReturn::outOfMemory) {
+        errmsg = "If memory allocation fails: " + (static_cast<char>(std::tolower(errmsg[0])) + errmsg.substr(1));
+        id += "OutOfMemory";
+    }
+    else if (value && value->unknownFunctionReturn == ValueFlow::Value::UnknownFunctionReturn::outOfResources) {
+        errmsg = "If resource allocation fails: " + (static_cast<char>(std::tolower(errmsg[0])) + errmsg.substr(1));
+        id += "OutOfResources";
+    }
+
+    ErrorPath errorPath = getErrorPath(tok, value, "Null pointer " + arithmetic);
+    reportError(std::move(errorPath),
                 Severity::error,
-                "nullPointerArithmetic",
+                id.c_str(),
                 errmsg,
-                CWE682,
-                inconclusive);
+                CWE_INCORRECT_CALCULATION,
+                inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
 void CheckNullPointer::redundantConditionWarning(const Token* tok, const ValueFlow::Value *value, const Token *condition, bool inconclusive)
 {
+    // cppcheck-suppress shadowFunction - TODO: fix this
     std::string arithmetic = arithmeticTypeString(tok);
     std::string errmsg;
     if (tok && tok->str()[0] == '-') {
@@ -607,36 +582,53 @@ void CheckNullPointer::redundantConditionWarning(const Token* tok, const ValueFl
     } else {
         errmsg = ValueFlow::eitherTheConditionIsRedundant(condition) + " or there is pointer arithmetic with NULL pointer.";
     }
-    const ErrorPath errorPath = getErrorPath(tok, value, "Null pointer " + arithmetic);
-    reportError(errorPath,
+    ErrorPath errorPath = getErrorPath(tok, value, "Null pointer " + arithmetic);
+    reportError(std::move(errorPath),
                 Severity::warning,
                 "nullPointerArithmeticRedundantCheck",
                 errmsg,
-                CWE682,
-                inconclusive);
+                CWE_INCORRECT_CALCULATION,
+                inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
-std::string CheckNullPointer::MyFileInfo::toString() const
+// NOLINTNEXTLINE(readability-non-const-parameter) - used as callback so we need to preserve the signature
+static bool isUnsafeUsage(const Settings &settings, const Token *vartok, CTU::FileInfo::Value *value)
 {
-    return CTU::toString(unsafeUsage);
+    (void)value;
+    bool unknown = false;
+    return CheckNullPointer::isPointerDeRef(vartok, unknown, settings);
 }
 
-static bool isUnsafeUsage(const Check *check, const Token *vartok, MathLib::bigint *value)
+// a Clang-built executable will crash when using the anonymous MyFileInfo later on - so put it in a unique namespace for now
+// see https://trac.cppcheck.net/ticket/12108 for more details
+#ifdef __clang__
+inline namespace CheckNullPointer_internal
+#else
+namespace
+#endif
 {
-    (void)value;
-    const CheckNullPointer *checkNullPointer = dynamic_cast<const CheckNullPointer *>(check);
-    bool unknown = false;
-    return checkNullPointer && checkNullPointer->isPointerDeRef(vartok, unknown);
+    /* data for multifile checking */
+    class MyFileInfo : public Check::FileInfo {
+    public:
+        using Check::FileInfo::FileInfo;
+        /** function arguments that are dereferenced without checking if they are null */
+        std::list<CTU::FileInfo::UnsafeUsage> unsafeUsage;
+
+        /** Convert data into xml string */
+        std::string toString() const override
+        {
+            return CTU::toString(unsafeUsage);
+        }
+    };
 }
 
-Check::FileInfo *CheckNullPointer::getFileInfo(const Tokenizer *tokenizer, const Settings *settings) const
+Check::FileInfo *CheckNullPointer::getFileInfo(const Tokenizer &tokenizer, const Settings &settings, const std::string& /*currentConfig*/) const
 {
-    CheckNullPointer check(tokenizer, settings, nullptr);
-    const std::list<CTU::FileInfo::UnsafeUsage> &unsafeUsage = CTU::getUnsafeUsage(tokenizer, settings, &check, ::isUnsafeUsage);
+    const std::list<CTU::FileInfo::UnsafeUsage> &unsafeUsage = CTU::getUnsafeUsage(tokenizer, settings, isUnsafeUsage);
     if (unsafeUsage.empty())
         return nullptr;
 
-    MyFileInfo *fileInfo = new MyFileInfo;
+    auto *fileInfo = new MyFileInfo(tokenizer.list.getFiles()[0]);
     fileInfo->unsafeUsage = unsafeUsage;
     return fileInfo;
 }
@@ -647,45 +639,64 @@ Check::FileInfo * CheckNullPointer::loadFileInfoFromXml(const tinyxml2::XMLEleme
     if (unsafeUsage.empty())
         return nullptr;
 
-    MyFileInfo *fileInfo = new MyFileInfo;
+    auto *fileInfo = new MyFileInfo;
     fileInfo->unsafeUsage = unsafeUsage;
     return fileInfo;
 }
 
-bool CheckNullPointer::analyseWholeProgram(const CTU::FileInfo *ctu, const std::list<Check::FileInfo*> &fileInfo, const Settings& settings, ErrorLogger &errorLogger)
+bool CheckNullPointer::analyseWholeProgram(const CTU::FileInfo &ctu, const std::list<Check::FileInfo*> &fileInfo, const Settings& settings, ErrorLogger &errorLogger)
 {
-    if (!ctu)
+    (void)settings;
+
+    CheckNullPointer dummy(nullptr, &settings, &errorLogger);
+    dummy.
+    logChecker("CheckNullPointer::analyseWholeProgram"); // unusedfunctions
+
+    if (fileInfo.empty())
         return false;
-    bool foundErrors = false;
-    (void)settings; // This argument is unused
 
-    const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>> callsMap = ctu->getCallsMap();
+    const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>> callsMap = ctu.getCallsMap();
+
+    bool foundErrors = false;
 
-    for (Check::FileInfo *fi1 : fileInfo) {
-        const MyFileInfo *fi = dynamic_cast<MyFileInfo*>(fi1);
+    for (const Check::FileInfo* fi1 : fileInfo) {
+        const auto *fi = dynamic_cast<const MyFileInfo*>(fi1);
         if (!fi)
             continue;
         for (const CTU::FileInfo::UnsafeUsage &unsafeUsage : fi->unsafeUsage) {
             for (int warning = 0; warning <= 1; warning++) {
-                if (warning == 1 && !settings.isEnabled(Settings::WARNING))
+                if (warning == 1 && !settings.severity.isEnabled(Severity::warning))
                     break;
 
-                const std::list<ErrorLogger::ErrorMessage::FileLocation> &locationList =
-                    ctu->getErrorPath(CTU::FileInfo::InvalidValueType::null,
-                                      unsafeUsage,
-                                      callsMap,
-                                      "Dereferencing argument ARG that is null",
-                                      nullptr,
-                                      warning);
+                ValueFlow::Value::UnknownFunctionReturn unknownFunctionReturn = ValueFlow::Value::UnknownFunctionReturn::no;
+                std::list<ErrorMessage::FileLocation> locationList =
+                    CTU::FileInfo::getErrorPath(CTU::FileInfo::InvalidValueType::null,
+                                                unsafeUsage,
+                                                callsMap,
+                                                "Dereferencing argument ARG that is null",
+                                                nullptr,
+                                                warning,
+                                                settings.maxCtuDepth,
+                                                &unknownFunctionReturn);
                 if (locationList.empty())
                     continue;
 
-                const ErrorLogger::ErrorMessage errmsg(locationList,
-                                                       emptyString,
-                                                       warning ? Severity::warning : Severity::error,
-                                                       "Null pointer dereference: " + unsafeUsage.myArgumentName,
-                                                       "ctunullpointer",
-                                                       CWE476, false);
+                std::string id = "ctunullpointer";
+                std::string message = "Null pointer dereference: " + unsafeUsage.myArgumentName;
+                if (unknownFunctionReturn == ValueFlow::Value::UnknownFunctionReturn::outOfMemory) {
+                    id += "OutOfMemory";
+                    message = "If memory allocation fails, then there is a possible null pointer dereference: " + unsafeUsage.myArgumentName;
+                } else if (unknownFunctionReturn == ValueFlow::Value::UnknownFunctionReturn::outOfResources) {
+                    id += "OutOfResources";
+                    message = "If resource allocation fails, then there is a possible null pointer dereference: " + unsafeUsage.myArgumentName;
+                }
+
+                ErrorMessage errmsg(std::move(locationList),
+                                    fi->file0,
+                                    warning ? Severity::warning : Severity::error,
+                                    message,
+                                    std::move(id),
+                                    CWE_NULL_POINTER_DEREFERENCE, Certainty::normal);
                 errorLogger.reportErr(errmsg);
 
                 foundErrors = true;
@@ -696,3 +707,23 @@ bool CheckNullPointer::analyseWholeProgram(const CTU::FileInfo *ctu, const std::
 
     return foundErrors;
 }
+
+void CheckNullPointer::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    CheckNullPointer checkNullPointer(&tokenizer, &tokenizer.getSettings(), errorLogger);
+    checkNullPointer.nullPointer();
+    checkNullPointer.arithmetic();
+    checkNullPointer.nullConstantDereference();
+}
+
+void CheckNullPointer::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const
+{
+    CheckNullPointer c(nullptr, settings, errorLogger);
+    c.nullPointerError(nullptr, "pointer", nullptr, false);
+    c.pointerArithmeticError(nullptr, nullptr, false);
+    // TODO: nullPointerArithmeticOutOfMemory
+    c.redundantConditionWarning(nullptr, nullptr, nullptr, false);
+    // TODO: ctunullpointer
+    // TODO: ctunullpointerOutOfMemory
+    // TODO: ctunullpointerOutOfResources
+}
diff --git a/lib/checknullpointer.h b/lib/checknullpointer.h
index ef7057a3709..d28927d19e9 100644
--- a/lib/checknullpointer.h
+++ b/lib/checknullpointer.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,8 +24,6 @@
 
 #include "check.h"
 #include "config.h"
-#include "ctu.h"
-#include "valueflow.h"
 
 #include <list>
 #include <string>
@@ -36,6 +34,10 @@ class Settings;
 class Token;
 class Tokenizer;
 
+namespace ValueFlow
+{
+    class Value;
+}
 
 /// @addtogroup Checks
 /// @{
@@ -44,24 +46,26 @@ class Tokenizer;
 /** @brief check for null pointer dereferencing */
 
 class CPPCHECKLIB CheckNullPointer : public Check {
+    friend class TestNullPointer;
+
 public:
     /** @brief This constructor is used when registering the CheckNullPointer */
-    CheckNullPointer() : Check(myName()) {
-    }
+    CheckNullPointer() : Check(myName()) {}
 
-    /** @brief This constructor is used when running checks. */
-    CheckNullPointer(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
+    /**
+     * Is there a pointer dereference? Everything that should result in
+     * a nullpointer dereference error message will result in a true
+     * return value. If it's unknown if the pointer is dereferenced false
+     * is returned.
+     * @param tok token for the pointer
+     * @param unknown it is not known if there is a pointer dereference (could be reported as a debug message)
+     * @return true => there is a dereference
+     */
+    bool isPointerDeRef(const Token *tok, bool &unknown) const;
 
-    /** @brief Run checks against the normal token list */
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        CheckNullPointer checkNullPointer(tokenizer, settings, errorLogger);
-        checkNullPointer.nullPointer();
-        checkNullPointer.arithmetic();
-        checkNullPointer.nullConstantDereference();
-    }
+    static bool isPointerDeRef(const Token *tok, bool &unknown, const Settings &settings, bool checkNullArg = true);
 
+private:
     /**
      * @brief parse a function call and extract information about variable usage
      * @param tok first token
@@ -70,20 +74,14 @@ class CPPCHECKLIB CheckNullPointer : public Check {
      */
     static void parseFunctionCall(const Token &tok,
                                   std::list<const Token *> &var,
-                                  const Library *library);
+                                  const Library &library, bool checkNullArg = true);
 
-    /**
-     * Is there a pointer dereference? Everything that should result in
-     * a nullpointer dereference error message will result in a true
-     * return value. If it's unknown if the pointer is dereferenced false
-     * is returned.
-     * @param tok token for the pointer
-     * @param unknown it is not known if there is a pointer dereference (could be reported as a debug message)
-     * @return true => there is a dereference
-     */
-    bool isPointerDeRef(const Token *tok, bool &unknown) const;
+    /** @brief This constructor is used when running checks. */
+    CheckNullPointer(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
+        : Check(myName(), tokenizer, settings, errorLogger) {}
 
-    static bool isPointerDeRef(const Token *tok, bool &unknown, const Settings *settings);
+    /** @brief Run checks against the normal token list */
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     /** @brief possible null pointer dereference */
     void nullPointer();
@@ -91,39 +89,19 @@ class CPPCHECKLIB CheckNullPointer : public Check {
     /** @brief dereferencing null constant (after Tokenizer::simplifyKnownVariables) */
     void nullConstantDereference();
 
-    void nullPointerError(const Token *tok) {
-        ValueFlow::Value v(0);
-        v.setKnown();
-        nullPointerError(tok, "", &v, false);
-    }
+    void nullPointerError(const Token *tok);
     void nullPointerError(const Token *tok, const std::string &varname, const ValueFlow::Value* value, bool inconclusive);
 
-    /* data for multifile checking */
-    class MyFileInfo : public Check::FileInfo {
-    public:
-        /** function arguments that are dereferenced without checking if they are null */
-        std::list<CTU::FileInfo::UnsafeUsage> unsafeUsage;
-
-        /** Convert MyFileInfo data into xml string */
-        std::string toString() const OVERRIDE;
-    };
-
     /** @brief Parse current TU and extract file info */
-    Check::FileInfo *getFileInfo(const Tokenizer *tokenizer, const Settings *settings) const OVERRIDE;
+    Check::FileInfo *getFileInfo(const Tokenizer &tokenizer, const Settings &settings, const std::string& /*currentConfig*/) const override;
 
-    Check::FileInfo * loadFileInfoFromXml(const tinyxml2::XMLElement *xmlElement) const OVERRIDE;
+    Check::FileInfo * loadFileInfoFromXml(const tinyxml2::XMLElement *xmlElement) const override;
 
     /** @brief Analyse all file infos for all TU */
-    bool analyseWholeProgram(const CTU::FileInfo *ctu, const std::list<Check::FileInfo*> &fileInfo, const Settings& settings, ErrorLogger &errorLogger) OVERRIDE;
+    bool analyseWholeProgram(const CTU::FileInfo &ctu, const std::list<Check::FileInfo*> &fileInfo, const Settings& settings, ErrorLogger &errorLogger) override;
 
-private:
     /** Get error messages. Used by --errorlist */
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        CheckNullPointer c(nullptr, settings, errorLogger);
-        c.nullPointerError(nullptr, "pointer", nullptr, false);
-        c.pointerArithmeticError(nullptr, nullptr, false);
-        c.redundantConditionWarning(nullptr, nullptr, nullptr, false);
-    }
+    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const override;
 
     /** Name of check */
     static std::string myName() {
@@ -131,23 +109,17 @@ class CPPCHECKLIB CheckNullPointer : public Check {
     }
 
     /** class info in WIKI format. Used by --doc */
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Null pointers\n"
                "- null pointer dereferencing\n"
                "- undefined null pointer arithmetic\n";
     }
 
-    /**
-     * @brief Does one part of the check for nullPointer().
-     * looping through items in a linked list in a inner loop..
-     */
-    void nullPointerLinkedList();
-
     /**
      * @brief Does one part of the check for nullPointer().
      * Dereferencing a pointer and then checking if it's NULL..
      */
-    void nullPointerByDeRefAndChec();
+    void nullPointerByDeRefAndCheck();
 
     /** undefined null pointer arithmetic */
     void arithmetic();
diff --git a/lib/checkother.cpp b/lib/checkother.cpp
index 7170e01b190..698ef62e78b 100644
--- a/lib/checkother.cpp
+++ b/lib/checkother.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,25 +19,34 @@
 
 //---------------------------------------------------------------------------
 #include "checkother.h"
-#include "checkuninitvar.h" // CheckUninitVar::isVariableUsage
 
 #include "astutils.h"
-#include "errorlogger.h"
+#include "fwdanalysis.h"
 #include "library.h"
 #include "mathlib.h"
+#include "platform.h"
 #include "settings.h"
 #include "standards.h"
 #include "symboldatabase.h"
 #include "token.h"
 #include "tokenize.h"
+#include "tokenlist.h"
 #include "utils.h"
+#include "valueflow.h"
+#include "vfvalue.h"
 
 #include <algorithm> // find_if()
+#include <cassert>
+#include <cctype>
+#include <cstddef>
+#include <cstdint>
 #include <list>
 #include <map>
-#include <ostream>
 #include <set>
+#include <sstream>
+#include <unordered_map>
 #include <utility>
+
 //---------------------------------------------------------------------------
 
 // Register this check class (by creating a static instance of it)
@@ -45,26 +54,24 @@ namespace {
     CheckOther instance;
 }
 
-static const struct CWE CWE128(128U);   // Wrap-around Error
-static const struct CWE CWE131(131U);   // Incorrect Calculation of Buffer Size
-static const struct CWE CWE197(197U);   // Numeric Truncation Error
-static const struct CWE CWE362(362U);   // Concurrent Execution using Shared Resource with Improper Synchronization ('Race Condition')
-static const struct CWE CWE369(369U);   // Divide By Zero
-static const struct CWE CWE398(398U);   // Indicator of Poor Code Quality
-static const struct CWE CWE475(475U);   // Undefined Behavior for Input to API
-static const struct CWE CWE482(482U);   // Comparing instead of Assigning
-static const struct CWE CWE561(561U);   // Dead Code
-static const struct CWE CWE563(563U);   // Assignment to Variable without Use ('Unused Variable')
-static const struct CWE CWE570(570U);   // Expression is Always False
-static const struct CWE CWE571(571U);   // Expression is Always True
-static const struct CWE CWE672(672U);   // Operation on a Resource after Expiration or Release
-static const struct CWE CWE628(628U);   // Function Call with Incorrectly Specified Arguments
-static const struct CWE CWE683(683U);   // Function Call With Incorrect Order of Arguments
-static const struct CWE CWE686(686U);   // Function Call With Incorrect Argument Type
-static const struct CWE CWE704(704U);   // Incorrect Type Conversion or Cast
-static const struct CWE CWE758(758U);   // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior
-static const struct CWE CWE768(768U);   // Incorrect Short Circuit Evaluation
-static const struct CWE CWE783(783U);   // Operator Precedence Logic Error
+static const CWE CWE128(128U);   // Wrap-around Error
+static const CWE CWE131(131U);   // Incorrect Calculation of Buffer Size
+static const CWE CWE197(197U);   // Numeric Truncation Error
+static const CWE CWE362(362U);   // Concurrent Execution using Shared Resource with Improper Synchronization ('Race Condition')
+static const CWE CWE369(369U);   // Divide By Zero
+static const CWE CWE398(398U);   // Indicator of Poor Code Quality
+static const CWE CWE475(475U);   // Undefined Behavior for Input to API
+static const CWE CWE561(561U);   // Dead Code
+static const CWE CWE563(563U);   // Assignment to Variable without Use ('Unused Variable')
+static const CWE CWE570(570U);   // Expression is Always False
+static const CWE CWE571(571U);   // Expression is Always True
+static const CWE CWE672(672U);   // Operation on a Resource after Expiration or Release
+static const CWE CWE628(628U);   // Function Call with Incorrectly Specified Arguments
+static const CWE CWE683(683U);   // Function Call With Incorrect Order of Arguments
+static const CWE CWE704(704U);   // Incorrect Type Conversion or Cast
+static const CWE CWE758(758U);   // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior
+static const CWE CWE768(768U);   // Incorrect Short Circuit Evaluation
+static const CWE CWE783(783U);   // Operator Precedence Logic Error
 
 //----------------------------------------------------------------------------------
 // The return value of fgetc(), getc(), ungetc(), getchar() etc. is an integer value.
@@ -80,13 +87,15 @@ static const struct CWE CWE783(783U);   // Operator Precedence Logic Error
 //----------------------------------------------------------------------------------
 void CheckOther::checkCastIntToCharAndBack()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckOther::checkCastIntToCharAndBack"); // warning
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         std::map<int, std::string> vars;
-        for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
+        for (const Token* tok = scope->bodyStart->next(); tok && tok != scope->bodyEnd; tok = tok->next()) {
             // Quick check to see if any of the matches below have any chances
             if (!Token::Match(tok, "%var%|EOF %comp%|="))
                 continue;
@@ -101,13 +110,13 @@ void CheckOther::checkCastIntToCharAndBack()
                 if (var && var->typeEndToken()->str() == "char" && !var->typeEndToken()->isSigned()) {
                     checkCastIntToCharAndBackError(tok, tok->strAt(2));
                 }
-            } else if (mTokenizer->isCPP() && (Token::Match(tok, "EOF %comp% ( %var% = std :: cin . get (") || Token::Match(tok, "EOF %comp% ( %var% = cin . get ("))) {
+            } else if (tok->isCpp() && (Token::Match(tok, "EOF %comp% ( %var% = std :: cin . get (") || Token::Match(tok, "EOF %comp% ( %var% = cin . get ("))) {
                 tok = tok->tokAt(3);
                 const Variable *var = tok->variable();
                 if (var && var->typeEndToken()->str() == "char" && !var->typeEndToken()->isSigned()) {
                     checkCastIntToCharAndBackError(tok, "cin.get");
                 }
-            } else if (mTokenizer->isCPP() && (Token::Match(tok, "%var% = std :: cin . get (") || Token::Match(tok, "%var% = cin . get ("))) {
+            } else if (tok->isCpp() && (Token::Match(tok, "%var% = std :: cin . get (") || Token::Match(tok, "%var% = cin . get ("))) {
                 const Variable *var = tok->variable();
                 if (var && var->typeEndToken()->str() == "char" && !var->typeEndToken()->isSigned()) {
                     vars[tok->varId()] = "cin.get";
@@ -138,8 +147,8 @@ void CheckOther::checkCastIntToCharAndBackError(const Token *tok, const std::str
         " When $symbol() returns EOF this value is truncated. Comparing the char "
         "variable with EOF can have unexpected results. For instance a loop \"while (EOF != (c = $symbol());\" "
         "loops forever on some compilers/platforms and on other compilers/platforms it will stop "
-        "when the file contains a matching character.", CWE197, false
-    );
+        "when the file contains a matching character.", CWE197, Certainty::normal
+        );
 }
 
 
@@ -148,9 +157,11 @@ void CheckOther::checkCastIntToCharAndBackError(const Token *tok, const std::str
 //---------------------------------------------------------------------------
 void CheckOther::clarifyCalculation()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("clarifyCalculation"))
         return;
 
+    logChecker("CheckOther::clarifyCalculation"); // style
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
@@ -160,6 +171,23 @@ void CheckOther::clarifyCalculation()
             if (!tok->astOperand1()->isArithmeticalOp() && tok->astOperand1()->tokType() != Token::eBitOp)
                 continue;
 
+            // non-pointer calculation in lhs and pointer in rhs => no clarification is needed
+            if (tok->astOperand1()->isBinaryOp() && Token::Match(tok->astOperand1(), "%or%|&|%|*|/") && tok->astOperand2()->valueType() && tok->astOperand2()->valueType()->pointer > 0)
+                continue;
+
+            // bit operation in lhs and char literals in rhs => probably no mistake
+            if (tok->astOperand1()->tokType() == Token::eBitOp && Token::Match(tok->astOperand2()->astOperand1(), "%char%") && Token::Match(tok->astOperand2()->astOperand2(), "%char%"))
+                continue;
+
+            // 2nd operand in lhs has known integer value => probably no mistake
+            if (tok->astOperand1()->isBinaryOp() && tok->astOperand1()->astOperand2()->hasKnownIntValue()) {
+                const Token *op = tok->astOperand1()->astOperand2();
+                if (op->isNumber())
+                    continue;
+                if (op->valueType() && op->valueType()->isEnum())
+                    continue;
+            }
+
             // Is code clarified by parentheses already?
             const Token *tok2 = tok->astOperand1();
             for (; tok2; tok2 = tok2->next()) {
@@ -192,7 +220,7 @@ void CheckOther::clarifyCalculationError(const Token *tok, const std::string &op
                 "clarifyCalculation",
                 "Clarify calculation precedence for '" + op + "' and '?'.\n"
                 "Suspicious calculation. Please use parentheses to clarify the code. "
-                "The code '" + calc + "' should be written as either '" + s1 + "' or '" + s2 + "'.", CWE783, false);
+                "The code '" + calc + "' should be written as either '" + s1 + "' or '" + s2 + "'.", CWE783, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -200,13 +228,15 @@ void CheckOther::clarifyCalculationError(const Token *tok, const std::string &op
 //---------------------------------------------------------------------------
 void CheckOther::clarifyStatement()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckOther::clarifyStatement"); // warning
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart; tok && tok != scope->bodyEnd; tok = tok->next()) {
-            if (Token::Match(tok, "* %name%") && tok->astOperand1()) {
+            if (tok->astOperand1() && Token::Match(tok, "* %name%")) {
                 const Token *tok2 = tok->previous();
 
                 while (tok2 && tok2->str() == "*")
@@ -226,7 +256,7 @@ void CheckOther::clarifyStatementError(const Token *tok)
 {
     reportError(tok, Severity::warning, "clarifyStatement", "In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'?\n"
                 "A statement like '*A++;' might not do what you intended. Postfix 'operator++' is executed before 'operator*'. "
-                "Thus, the dereference is meaningless. Did you intend to write '(*A)++;'?", CWE783, false);
+                "Thus, the dereference is meaningless. Did you intend to write '(*A)++;'?", CWE783, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -234,31 +264,72 @@ void CheckOther::clarifyStatementError(const Token *tok)
 //---------------------------------------------------------------------------
 void CheckOther::checkSuspiciousSemicolon()
 {
-    if (!mSettings->inconclusive || !mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->certainty.isEnabled(Certainty::inconclusive) || !mSettings->severity.isEnabled(Severity::warning))
         return;
 
     const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
 
+    logChecker("CheckOther::checkSuspiciousSemicolon"); // warning,inconclusive
+
     // Look for "if(); {}", "for(); {}" or "while(); {}"
     for (const Scope &scope : symbolDatabase->scopeList) {
-        if (scope.type == Scope::eIf || scope.type == Scope::eElse || scope.type == Scope::eWhile || scope.type == Scope::eFor) {
+        if (scope.type == ScopeType::eIf || scope.type == ScopeType::eElse || scope.type == ScopeType::eWhile || scope.type == ScopeType::eFor) {
             // Ensure the semicolon is at the same line number as the if/for/while statement
             // and the {..} block follows it without an extra empty line.
             if (Token::simpleMatch(scope.bodyStart, "{ ; } {") &&
-                scope.bodyStart->previous()->linenr() == scope.bodyStart->tokAt(2)->linenr()
-                && scope.bodyStart->linenr()+1 >= scope.bodyStart->tokAt(3)->linenr()) {
-                SuspiciousSemicolonError(scope.classDef);
+                scope.bodyStart->previous()->linenr() == scope.bodyStart->tokAt(2)->linenr() &&
+                scope.bodyStart->linenr()+1 >= scope.bodyStart->tokAt(3)->linenr() &&
+                !scope.bodyStart->tokAt(3)->isExpandedMacro()) {
+                suspiciousSemicolonError(scope.classDef);
             }
         }
     }
 }
 
-void CheckOther::SuspiciousSemicolonError(const Token* tok)
+void CheckOther::suspiciousSemicolonError(const Token* tok)
 {
     reportError(tok, Severity::warning, "suspiciousSemicolon",
-                "Suspicious use of ; at the end of '" + (tok ? tok->str() : std::string()) + "' statement.", CWE398, true);
+                "Suspicious use of ; at the end of '" + (tok ? tok->str() : std::string()) + "' statement.", CWE398, Certainty::normal);
 }
 
+/** @brief would it make sense to use dynamic_cast instead of C style cast? */
+static bool isDangerousTypeConversion(const Token* const tok)
+{
+    const Token* from = tok->astOperand1();
+    if (!from)
+        return false;
+    if (!tok->valueType() || !from->valueType())
+        return false;
+    if (tok->valueType()->typeScope != nullptr &&
+        tok->valueType()->typeScope == from->valueType()->typeScope)
+        return false;
+    if (tok->valueType()->type == from->valueType()->type &&
+        tok->valueType()->isPrimitive())
+        return false;
+    // cast from derived object to base object is safe..
+    if (tok->valueType()->typeScope && from->valueType()->typeScope) {
+        const Type* fromType = from->valueType()->typeScope->definedType;
+        const Type* toType = tok->valueType()->typeScope->definedType;
+        if (fromType && toType && fromType->isDerivedFrom(toType->name()))
+            return false;
+    }
+    const bool refcast = (tok->valueType()->reference != Reference::None);
+    if (!refcast && tok->valueType()->pointer == 0)
+        return false;
+    if (!refcast && from->valueType()->pointer == 0)
+        return false;
+
+    if (tok->valueType()->type == ValueType::Type::VOID || from->valueType()->type == ValueType::Type::VOID)
+        return false;
+    if (tok->valueType()->pointer == 0 && tok->valueType()->isIntegral())
+        // ok: (uintptr_t)ptr;
+        return false;
+    if (from->valueType()->pointer == 0 && from->valueType()->isIntegral())
+        // ok: (int *)addr;
+        return false;
+
+    return true;
+}
 
 //---------------------------------------------------------------------------
 // For C++ code, warn if C-style casts are used on pointer types
@@ -266,9 +337,14 @@ void CheckOther::SuspiciousSemicolonError(const Token* tok)
 void CheckOther::warningOldStylePointerCast()
 {
     // Only valid on C++ code
-    if (!mSettings->isEnabled(Settings::STYLE) || !mTokenizer->isCPP())
+    if (!mTokenizer->isCPP())
+        return;
+
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("cstyleCast"))
         return;
 
+    logChecker("CheckOther::warningOldStylePointerCast"); // style,c++
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         const Token* tok;
@@ -278,11 +354,35 @@ void CheckOther::warningOldStylePointerCast()
             tok = scope->bodyStart;
         for (; tok && tok != scope->bodyEnd; tok = tok->next()) {
             // Old style pointer casting..
-            if (!Token::Match(tok, "( const|volatile| const|volatile| %type% * const| ) (| %name%|%num%|%bool%|%char%|%str%"))
+            if (!tok->isCast() || tok->isBinaryOp())
+                continue;
+            if (isDangerousTypeConversion(tok))
+                continue;
+            const Token* const errtok = tok;
+            const Token* castTok = tok->next();
+            while (Token::Match(castTok, "const|volatile|class|struct|union|%type%|::")) {
+                castTok = castTok->next();
+                if (Token::simpleMatch(castTok, "<") && castTok->link())
+                    castTok = castTok->link()->next();
+            }
+            if (castTok == tok->next())
+                continue;
+            bool isPtr = false, isRef = false;
+            while (Token::Match(castTok, "*|const|&")) {
+                if (castTok->str() == "*")
+                    isPtr = true;
+                else if (castTok->str() == "&")
+                    isRef = true;
+                castTok = castTok->next();
+            }
+            if ((!isPtr && !isRef) || !Token::Match(castTok, ") (| %name%|%bool%|%char%|%str%|&"))
+                continue;
+
+            if (Token::Match(tok->previous(), "%type%"))
                 continue;
 
             // skip first "const" in "const Type* const"
-            while (Token::Match(tok->next(), "const|volatile"))
+            while (Token::Match(tok->next(), "const|volatile|class|struct|union"))
                 tok = tok->next();
             const Token* typeTok = tok->next();
             // skip second "const" in "const Type* const"
@@ -290,24 +390,154 @@ void CheckOther::warningOldStylePointerCast()
                 tok = tok->next();
 
             const Token *p = tok->tokAt(4);
-            if (p->hasKnownIntValue() && p->values().front().intvalue==0) // Casting nullpointers is safe
+            if (p->hasKnownIntValue() && p->getKnownIntValue()==0) // Casting nullpointers is safe
                 continue;
 
-            // Is "type" a class?
-            if (typeTok->type())
-                cstyleCastError(tok);
+            if (typeTok->tokType() == Token::eType || typeTok->tokType() == Token::eName)
+                cstyleCastError(errtok, isPtr);
         }
     }
 }
 
-void CheckOther::cstyleCastError(const Token *tok)
+void CheckOther::cstyleCastError(const Token *tok, bool isPtr)
 {
+    const std::string type = isPtr ? "pointer" : "reference";
     reportError(tok, Severity::style, "cstyleCast",
-                "C-style pointer casting\n"
-                "C-style pointer casting detected. C++ offers four different kinds of casts as replacements: "
+                "C-style " + type + " casting\n"
+                "C-style " + type + " casting detected. C++ offers four different kinds of casts as replacements: "
                 "static_cast, const_cast, dynamic_cast and reinterpret_cast. A C-style cast could evaluate to "
                 "any of those automatically, thus it is considered safer if the programmer explicitly states "
-                "which kind of cast is expected. See also: https://www.securecoding.cert.org/confluence/display/cplusplus/EXP05-CPP.+Do+not+use+C-style+casts.", CWE398, false);
+                "which kind of cast is expected.", CWE398, Certainty::normal);
+}
+
+void CheckOther::warningDangerousTypeCast()
+{
+    // Only valid on C++ code
+    if (!mTokenizer->isCPP())
+        return;
+    if (!mSettings->severity.isEnabled(Severity::warning) && !mSettings->isPremiumEnabled("dangerousTypeCast"))
+        return;
+
+    logChecker("CheckOther::warningDangerousTypeCast"); // warning,c++
+
+    const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
+    for (const Scope * scope : symbolDatabase->functionScopes) {
+        const Token* tok;
+        if (scope->function && scope->function->isConstructor())
+            tok = scope->classDef;
+        else
+            tok = scope->bodyStart;
+        for (; tok && tok != scope->bodyEnd; tok = tok->next()) {
+            // Old style pointer casting..
+            if (!tok->isCast() || tok->isBinaryOp())
+                continue;
+
+            if (isDangerousTypeConversion(tok))
+                dangerousTypeCastError(tok, tok->valueType()->pointer > 0);
+        }
+    }
+}
+
+void CheckOther::dangerousTypeCastError(const Token *tok, bool isPtr)
+{
+    //const std::string type = isPtr ? "pointer" : "reference";
+    (void)isPtr;
+    reportError(tok, Severity::warning, "dangerousTypeCast",
+                "Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast",
+                CWE398, Certainty::normal);
+}
+
+void CheckOther::warningIntToPointerCast()
+{
+    if (!mSettings->severity.isEnabled(Severity::portability) && !mSettings->isPremiumEnabled("cstyleCast"))
+        return;
+
+    logChecker("CheckOther::warningIntToPointerCast"); // portability
+
+    for (const Token* tok = mTokenizer->tokens(); tok; tok = tok->next()) {
+        // pointer casting..
+        if (!tok->isCast())
+            continue;
+        const Token* from = tok->astOperand2() ? tok->astOperand2() : tok->astOperand1();
+        if (!from || !from->isNumber())
+            continue;
+        if (!tok->valueType() || tok->valueType()->pointer == 0)
+            continue;
+        if (!MathLib::isIntHex(from->str()) && from->hasKnownIntValue() && from->getKnownIntValue() != 0) {
+            std::string format;
+            if (MathLib::isDec(from->str()))
+                format = "decimal";
+            else if (MathLib::isOct(from->str()))
+                format = "octal";
+            else
+                continue;
+            intToPointerCastError(tok, format);
+        }
+    }
+}
+
+void CheckOther::intToPointerCastError(const Token *tok, const std::string& format)
+{
+    reportError(tok, Severity::portability, "intToPointerCast",
+                "Casting non-zero " + format + " integer literal to pointer.",
+                CWE398, Certainty::normal);
+}
+
+void CheckOther::suspiciousFloatingPointCast()
+{
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("suspiciousFloatingPointCast"))
+        return;
+
+    logChecker("CheckOther::suspiciousFloatingPointCast"); // style
+
+    const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
+    for (const Scope * scope : symbolDatabase->functionScopes) {
+        const Token* tok = scope->bodyStart;
+        if (scope->function && scope->function->isConstructor())
+            tok = scope->classDef;
+        for (; tok && tok != scope->bodyEnd; tok = tok->next()) {
+
+            if (!tok->isCast())
+                continue;
+
+            const ValueType* vt = tok->valueType();
+            if (!vt || vt->pointer || vt->reference != Reference::None || (vt->type != ValueType::FLOAT && vt->type != ValueType::DOUBLE))
+                continue;
+
+            using VTT = std::vector<ValueType::Type>;
+            const VTT sourceTypes = vt->type == ValueType::FLOAT ? VTT{ ValueType::DOUBLE, ValueType::LONGDOUBLE } : VTT{ ValueType::LONGDOUBLE };
+
+            const Token* source = tok->astOperand2() ? tok->astOperand2() : tok->astOperand1();
+            if (!source || !source->valueType() || std::find(sourceTypes.begin(), sourceTypes.end(), source->valueType()->type) == sourceTypes.end())
+                continue;
+
+            const Token* parent = tok->astParent();
+            if (!parent)
+                continue;
+
+            const ValueType* parentVt = parent->valueType();
+            if (!parentVt || parent->str() == "(") {
+                int argn{};
+                if (const Token* ftok = getTokenArgumentFunction(tok, argn)) {
+                    if (ftok->function()) {
+                        if (const Variable* argVar = ftok->function()->getArgumentVar(argn))
+                            parentVt = argVar->valueType();
+                    }
+                }
+            }
+            if (!parentVt || std::find(sourceTypes.begin(), sourceTypes.end(), parentVt->type) == sourceTypes.end())
+                continue;
+
+            suspiciousFloatingPointCastError(tok);
+        }
+    }
+}
+
+void CheckOther::suspiciousFloatingPointCastError(const Token* tok)
+{
+    reportError(tok, Severity::style, "suspiciousFloatingPointCast",
+                "Floating-point cast causes loss of precision.\n"
+                "If this cast is not intentional, remove it to avoid loss of precision", CWE398, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -316,10 +546,12 @@ void CheckOther::cstyleCastError(const Token *tok)
 
 void CheckOther::invalidPointerCast()
 {
-    if (!mSettings->isEnabled(Settings::PORTABILITY))
+    if (!mSettings->severity.isEnabled(Severity::portability))
         return;
 
-    const bool printInconclusive = mSettings->inconclusive;
+    logChecker("CheckOther::invalidPointerCast"); // portability
+
+    const bool printInconclusive = mSettings->certainty.isEnabled(Certainty::inconclusive);
     const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
@@ -344,69 +576,22 @@ void CheckOther::invalidPointerCast()
             if (fromType->type != toType->type && fromType->type >= ValueType::Type::BOOL && toType->type >= ValueType::Type::BOOL && (toType->type != ValueType::Type::CHAR || printInconclusive)) {
                 if (toType->isIntegral() && fromType->isIntegral())
                     continue;
-                std::string toStr = toType->isIntegral() ? "integer *" : toType->str();
-                toStr.erase(toStr.size()-2);
-                std::string fromStr = fromType->isIntegral() ? "integer *" : fromType->str();
-                fromStr.erase(fromStr.size() - 2);
 
-                invalidPointerCastError(tok, fromStr, toStr, toType->type == ValueType::Type::CHAR);
+                invalidPointerCastError(tok, fromType->str(), toType->str(), toType->type == ValueType::Type::CHAR, toType->isIntegral());
             }
         }
     }
 }
 
-void CheckOther::invalidPointerCastError(const Token* tok, const std::string& from, const std::string& to, bool inconclusive)
-{
-    if (to == "integer") { // If we cast something to int*, this can be useful to play with its binary data representation
-        if (!inconclusive)
-            reportError(tok, Severity::portability, "invalidPointerCast", "Casting from " + from + "* to integer* is not portable due to different binary data representations on different platforms.", CWE704, false);
-        else
-            reportError(tok, Severity::portability, "invalidPointerCast", "Casting from " + from + "* to char* is not portable due to different binary data representations on different platforms.", CWE704, true);
-    } else
-        reportError(tok, Severity::portability, "invalidPointerCast", "Casting between " + from + "* and " + to + "* which have an incompatible binary data representation.", CWE704, false);
-}
 
-//---------------------------------------------------------------------------
-// This check detects errors on POSIX systems, when a pipe command called
-// with a wrong dimensioned file descriptor array. The pipe command requires
-// exactly an integer array of dimension two as parameter.
-//
-// References:
-//  - http://linux.die.net/man/2/pipe
-//  - ticket #3521
-//---------------------------------------------------------------------------
-void CheckOther::checkPipeParameterSize()
+void CheckOther::invalidPointerCastError(const Token* tok, const std::string& from, const std::string& to, bool inconclusive, bool toIsInt)
 {
-    if (!mSettings->posix())
-        return;
-
-    const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
-    for (const Scope * scope : symbolDatabase->functionScopes) {
-        for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
-            if (Token::Match(tok, "pipe ( %var% )") ||
-                Token::Match(tok, "pipe2 ( %var% ,")) {
-                const Token * const varTok = tok->tokAt(2);
-
-                const Variable *var = varTok->variable();
-                MathLib::bigint dim;
-                if (var && var->isArray() && !var->isArgument() && ((dim=var->dimension(0U)) < 2)) {
-                    const std::string strDim = MathLib::toString(dim);
-                    checkPipeParameterSizeError(varTok,varTok->str(), strDim);
-                }
-            }
-        }
-    }
+    if (toIsInt) { // If we cast something to int*, this can be useful to play with its binary data representation
+        reportError(tok, Severity::portability, "invalidPointerCast", "Casting from " + from + " to " + to + " is not portable due to different binary data representations on different platforms.", CWE704, inconclusive ? Certainty::inconclusive : Certainty::normal);
+    } else
+        reportError(tok, Severity::portability, "invalidPointerCast", "Casting between " + from + " and " + to + " which have an incompatible binary data representation.", CWE704, Certainty::normal);
 }
 
-void CheckOther::checkPipeParameterSizeError(const Token *tok, const std::string &strVarName, const std::string &strDim)
-{
-    reportError(tok, Severity::error,
-                "wrongPipeParameterSize",
-                "$symbol:" + strVarName + "\n"
-                "Buffer '$symbol' must have size of 2 integers if used as parameter of pipe().\n"
-                "The pipe()/pipe2() system command takes an argument, which is an array of exactly two integers.\n"
-                "The variable '$symbol' is an array of size " + strDim + ", which does not match.", CWE686, false);
-}
 
 //---------------------------------------------------------------------------
 // Detect redundant assignments: x = 0; x = 4;
@@ -414,8 +599,13 @@ void CheckOther::checkPipeParameterSizeError(const Token *tok, const std::string
 
 void CheckOther::checkRedundantAssignment()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) &&
+        !mSettings->isPremiumEnabled("redundantAssignment") &&
+        !mSettings->isPremiumEnabled("redundantAssignInSwitch"))
         return;
+
+    logChecker("CheckOther::checkRedundantAssignment"); // style
+
     const SymbolDatabase* symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope *scope : symbolDatabase->functionScopes) {
         if (!scope->bodyStart)
@@ -427,21 +617,23 @@ void CheckOther::checkRedundantAssignment()
             if (Token::simpleMatch(tok, "try {"))
                 // todo: check try blocks
                 tok = tok->linkAt(1);
-            if ((tok->isAssignmentOp() || Token::Match(tok, "++|--")) && tok->astOperand1()) {
+            if ((tok->isAssignmentOp() || tok->tokType() == Token::eIncDecOp) && tok->astOperand1()) {
                 if (tok->astParent())
                     continue;
 
                 // Do not warn about redundant initialization when rhs is trivial
                 // TODO : do not simplify the variable declarations
                 bool isInitialization = false;
-                if (Token::Match(tok->tokAt(-3), "%var% ; %var% =") && tok->previous()->variable() && tok->previous()->variable()->nameToken() == tok->tokAt(-3) && tok->tokAt(-3)->linenr() == tok->previous()->linenr()) {
+                if (Token::Match(tok->tokAt(-2), "; %var% =") && tok->tokAt(-2)->isSplittedVarDeclEq()) {
                     isInitialization = true;
                     bool trivial = true;
                     visitAstNodes(tok->astOperand2(),
-                    [&](const Token *rhs) {
+                                  [&](const Token *rhs) {
                         if (Token::simpleMatch(rhs, "{ 0 }"))
                             return ChildrenToVisit::none;
-                        if (Token::Match(rhs, "%str%|%num%|%name%") && !rhs->varId())
+                        if (Token::Match(rhs, "%num%|%name%") && !rhs->varId())
+                            return ChildrenToVisit::none;
+                        if (Token::Match(rhs, ":: %name%") && rhs->hasKnownIntValue())
                             return ChildrenToVisit::none;
                         if (rhs->isCast())
                             return ChildrenToVisit::op2;
@@ -452,8 +644,9 @@ void CheckOther::checkRedundantAssignment()
                         continue;
                 }
 
+                const Token* rhs = tok->astOperand2();
                 // Do not warn about assignment with 0 / NULL
-                if (Token::simpleMatch(tok->astOperand2(), "0") || FwdAnalysis::isNullOperand(tok->astOperand2()))
+                if ((rhs && MathLib::isNullValue(rhs->str())) || isNullOperand(rhs))
                     continue;
 
                 if (tok->astOperand1()->variable() && tok->astOperand1()->variable()->isReference())
@@ -464,33 +657,54 @@ void CheckOther::checkRedundantAssignment()
                     // todo: check static variables
                     continue;
 
-                // If there is a custom assignment operator => this is inconclusive
                 bool inconclusive = false;
-                if (mTokenizer->isCPP() && tok->astOperand1()->valueType() && tok->astOperand1()->valueType()->typeScope) {
-                    const std::string op = "operator" + tok->str();
-                    for (const Function &f : tok->astOperand1()->valueType()->typeScope->functionList) {
-                        if (f.name() == op) {
-                            inconclusive = true;
-                            break;
-                        }
+                if (tok->isCpp() && tok->astOperand1()->valueType()) {
+                    // If there is a custom assignment operator => this is inconclusive
+                    if (tok->astOperand1()->valueType()->typeScope) {
+                        const std::string op = "operator" + tok->str();
+                        const std::list<Function>& fList = tok->astOperand1()->valueType()->typeScope->functionList;
+                        inconclusive = std::any_of(fList.cbegin(), fList.cend(), [&](const Function& f) {
+                            return f.name() == op;
+                        });
                     }
+                    // assigning a smart pointer has side effects
+                    if (tok->astOperand1()->valueType()->type == ValueType::SMART_POINTER)
+                        break;
                 }
-                if (inconclusive && !mSettings->inconclusive)
+                if (inconclusive && !mSettings->certainty.isEnabled(Certainty::inconclusive))
                     continue;
 
-                FwdAnalysis fwdAnalysis(mTokenizer->isCPP(), mSettings->library);
+                FwdAnalysis fwdAnalysis(*mSettings);
                 if (fwdAnalysis.hasOperand(tok->astOperand2(), tok->astOperand1()))
                     continue;
 
                 // Is there a redundant assignment?
                 const Token *start;
                 if (tok->isAssignmentOp())
-                    start = tok->next();
+                    start = tok->astOperand2();
                 else
                     start = tok->findExpressionStartEndTokens().second->next();
 
+                const Token * tokenToCheck = tok->astOperand1();
+
+                // Check if we are working with union
+                for (const Token* tempToken = tokenToCheck; Token::simpleMatch(tempToken, ".");) {
+                    tempToken = tempToken->astOperand1();
+                    if (tempToken && tempToken->variable() && tempToken->variable()->type() && tempToken->variable()->type()->isUnionType())
+                        tokenToCheck = tempToken;
+                }
+
+                if (start->hasKnownSymbolicValue(tokenToCheck) && Token::simpleMatch(start->astParent(), "=") && !diag(tok)) {
+                    const ValueFlow::Value* val = start->getKnownValue(ValueFlow::Value::ValueType::SYMBOLIC);
+                    if (val->intvalue == 0) // no offset
+                        redundantAssignmentSameValueError(tokenToCheck, val, tok->astOperand1()->expressionString());
+                }
+
                 // Get next assignment..
-                const Token *nextAssign = fwdAnalysis.reassign(tok->astOperand1(), start, scope->bodyEnd);
+                const Token *nextAssign = fwdAnalysis.reassign(tokenToCheck, start, scope->bodyEnd);
+                // extra check for union
+                if (nextAssign && tokenToCheck != tok->astOperand1())
+                    nextAssign = fwdAnalysis.reassign(tok->astOperand1(), start, scope->bodyEnd);
 
                 if (!nextAssign)
                     continue;
@@ -511,8 +725,10 @@ void CheckOther::checkRedundantAssignment()
                     redundantAssignmentInSwitchError(tok, nextAssign, tok->astOperand1()->expressionString());
                 else if (isInitialization)
                     redundantInitializationError(tok, nextAssign, tok->astOperand1()->expressionString(), inconclusive);
-                else
+                else {
+                    diag(nextAssign);
                     redundantAssignmentError(tok, nextAssign, tok->astOperand1()->expressionString(), inconclusive);
+                }
             }
         }
     }
@@ -523,46 +739,47 @@ void CheckOther::redundantCopyError(const Token *tok1, const Token* tok2, const
     const std::list<const Token *> callstack = { tok1, tok2 };
     reportError(callstack, Severity::performance, "redundantCopy",
                 "$symbol:" + var + "\n"
-                "Buffer '$symbol' is being written before its old content has been used.", CWE563, false);
-}
-
-void CheckOther::redundantCopyInSwitchError(const Token *tok1, const Token* tok2, const std::string &var)
-{
-    const std::list<const Token *> callstack = { tok1, tok2 };
-    reportError(callstack, Severity::warning, "redundantCopyInSwitch",
-                "$symbol:" + var + "\n"
-                "Buffer '$symbol' is being written before its old content has been used. 'break;' missing?", CWE563, false);
+                "Buffer '$symbol' is being written before its old content has been used.", CWE563, Certainty::normal);
 }
 
 void CheckOther::redundantAssignmentError(const Token *tok1, const Token* tok2, const std::string& var, bool inconclusive)
 {
-    const ErrorPath errorPath = { ErrorPathItem(tok1, var + " is assigned"), ErrorPathItem(tok2, var + " is overwritten") };
+    ErrorPath errorPath = { ErrorPathItem(tok1, var + " is assigned"), ErrorPathItem(tok2, var + " is overwritten") };
     if (inconclusive)
-        reportError(errorPath, Severity::style, "redundantAssignment",
+        reportError(std::move(errorPath), Severity::style, "redundantAssignment",
                     "$symbol:" + var + "\n"
                     "Variable '$symbol' is reassigned a value before the old one has been used if variable is no semaphore variable.\n"
-                    "Variable '$symbol' is reassigned a value before the old one has been used. Make sure that this variable is not used like a semaphore in a threading environment before simplifying this code.", CWE563, true);
+                    "Variable '$symbol' is reassigned a value before the old one has been used. Make sure that this variable is not used like a semaphore in a threading environment before simplifying this code.", CWE563, Certainty::inconclusive);
     else
-        reportError(errorPath, Severity::style, "redundantAssignment",
+        reportError(std::move(errorPath), Severity::style, "redundantAssignment",
                     "$symbol:" + var + "\n"
-                    "Variable '$symbol' is reassigned a value before the old one has been used.", CWE563, false);
+                    "Variable '$symbol' is reassigned a value before the old one has been used.", CWE563, Certainty::normal);
 }
 
 void CheckOther::redundantInitializationError(const Token *tok1, const Token* tok2, const std::string& var, bool inconclusive)
 {
-    const ErrorPath errorPath = { ErrorPathItem(tok1, var + " is initialized"), ErrorPathItem(tok2, var + " is overwritten") };
-    reportError(errorPath, Severity::style, "redundantInitialization",
+    ErrorPath errorPath = { ErrorPathItem(tok1, var + " is initialized"), ErrorPathItem(tok2, var + " is overwritten") };
+    reportError(std::move(errorPath), Severity::style, "redundantInitialization",
                 "$symbol:" + var + "\nRedundant initialization for '$symbol'. The initialized value is overwritten before it is read.",
                 CWE563,
-                inconclusive);
+                inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
 void CheckOther::redundantAssignmentInSwitchError(const Token *tok1, const Token* tok2, const std::string &var)
 {
-    const ErrorPath errorPath = { ErrorPathItem(tok1, "$symbol is assigned"), ErrorPathItem(tok2, "$symbol is overwritten") };
-    reportError(errorPath, Severity::warning, "redundantAssignInSwitch",
+    ErrorPath errorPath = { ErrorPathItem(tok1, "$symbol is assigned"), ErrorPathItem(tok2, "$symbol is overwritten") };
+    reportError(std::move(errorPath), Severity::style, "redundantAssignInSwitch",
+                "$symbol:" + var + "\n"
+                "Variable '$symbol' is reassigned a value before the old one has been used. 'break;' missing?", CWE563, Certainty::normal);
+}
+
+void CheckOther::redundantAssignmentSameValueError(const Token *tok, const ValueFlow::Value* val, const std::string &var)
+{
+    auto errorPath = val->errorPath;
+    errorPath.emplace_back(tok, "");
+    reportError(std::move(errorPath), Severity::style, "redundantAssignment",
                 "$symbol:" + var + "\n"
-                "Variable '$symbol' is reassigned a value before the old one has been used. 'break;' missing?", CWE563, false);
+                "Variable '$symbol' is assigned an expression that holds the same value.", CWE563, Certainty::normal);
 }
 
 
@@ -577,23 +794,22 @@ void CheckOther::redundantAssignmentInSwitchError(const Token *tok1, const Token
 //---------------------------------------------------------------------------
 static inline bool isFunctionOrBreakPattern(const Token *tok)
 {
-    if (Token::Match(tok, "%name% (") || Token::Match(tok, "break|continue|return|exit|goto|throw"))
-        return true;
-
-    return false;
+    return Token::Match(tok, "%name% (") || Token::Match(tok, "break|continue|return|exit|goto|throw");
 }
 
-void CheckOther::checkRedundantAssignmentInSwitch()
+void CheckOther::redundantBitwiseOperationInSwitchError()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckOther::redundantBitwiseOperationInSwitch"); // warning
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
     // Find the beginning of a switch. E.g.:
     //   switch (var) { ...
     for (const Scope &switchScope : symbolDatabase->scopeList) {
-        if (switchScope.type != Scope::eSwitch || !switchScope.bodyStart)
+        if (switchScope.type != ScopeType::eSwitch || !switchScope.bodyStart)
             continue;
 
         // Check the contents of the switch statement
@@ -635,13 +851,13 @@ void CheckOther::checkRedundantAssignmentInSwitch()
             else if (Token::Match(tok2->previous(), ";|{|}|: %var% %assign% %num% ;") &&
                      (tok2->strAt(1) == "|=" || tok2->strAt(1) == "&=") &&
                      Token::Match(tok2->next()->astOperand2(), "%num%")) {
-                const std::string bitOp = tok2->strAt(1)[0] + tok2->strAt(2);
-                const std::map<int, const Token*>::const_iterator i2 = varsWithBitsSet.find(tok2->varId());
+                std::string bitOp = tok2->strAt(1)[0] + tok2->strAt(2);
+                const auto i2 = utils::as_const(varsWithBitsSet).find(tok2->varId());
 
                 // This variable has not had a bit operation performed on it yet, so just make a note of it
                 if (i2 == varsWithBitsSet.end()) {
                     varsWithBitsSet[tok2->varId()] = tok2;
-                    bitOperations[tok2->varId()] = bitOp;
+                    bitOperations[tok2->varId()] = std::move(bitOp);
                 }
 
                 // The same bit operation has been performed on the same variable twice, so report an error
@@ -660,13 +876,13 @@ void CheckOther::checkRedundantAssignmentInSwitch()
             //    case 4: b = b | 1;
             else if (Token::Match(tok2->previous(), ";|{|}|: %var% = %name% %or%|& %num% ;") &&
                      tok2->varId() == tok2->tokAt(2)->varId()) {
-                const std::string bitOp = tok2->strAt(3) + tok2->strAt(4);
-                const std::map<int, const Token*>::const_iterator i2 = varsWithBitsSet.find(tok2->varId());
+                std::string bitOp = tok2->strAt(3) + tok2->strAt(4);
+                const auto i2 = utils::as_const(varsWithBitsSet).find(tok2->varId());
 
                 // This variable has not had a bit operation performed on it yet, so just make a note of it
                 if (i2 == varsWithBitsSet.end()) {
                     varsWithBitsSet[tok2->varId()] = tok2;
-                    bitOperations[tok2->varId()] = bitOp;
+                    bitOperations[tok2->varId()] = std::move(bitOp);
                 }
 
                 // The same bit operation has been performed on the same variable twice, so report an error
@@ -700,7 +916,7 @@ void CheckOther::checkRedundantAssignmentInSwitch()
 
 void CheckOther::redundantBitwiseOperationInSwitchError(const Token *tok, const std::string &varname)
 {
-    reportError(tok, Severity::warning,
+    reportError(tok, Severity::style,
                 "redundantBitwiseOperationInSwitch",
                 "$symbol:" + varname + "\n"
                 "Redundant bitwise operation on '$symbol' in 'switch' statement. 'break;' missing?");
@@ -712,13 +928,15 @@ void CheckOther::redundantBitwiseOperationInSwitchError(const Token *tok, const
 //---------------------------------------------------------------------------
 void CheckOther::checkSuspiciousCaseInSwitch()
 {
-    if (!mSettings->inconclusive || !mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->certainty.isEnabled(Certainty::inconclusive) || !mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckOther::checkSuspiciousCaseInSwitch"); // warning,inconclusive
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope & scope : symbolDatabase->scopeList) {
-        if (scope.type != Scope::eSwitch)
+        if (scope.type != ScopeType::eSwitch)
             continue;
 
         for (const Token* tok = scope.bodyStart->next(); tok != scope.bodyEnd; tok = tok->next()) {
@@ -746,7 +964,44 @@ void CheckOther::suspiciousCaseInSwitchError(const Token* tok, const std::string
 {
     reportError(tok, Severity::warning, "suspiciousCase",
                 "Found suspicious case label in switch(). Operator '" + operatorString + "' probably doesn't work as intended.\n"
-                "Using an operator like '" + operatorString + "' in a case label is suspicious. Did you intend to use a bitwise operator, multiple case labels or if/else instead?", CWE398, true);
+                "Using an operator like '" + operatorString + "' in a case label is suspicious. Did you intend to use a bitwise operator, multiple case labels or if/else instead?", CWE398, Certainty::inconclusive);
+}
+
+static bool isNestedInSwitch(const Scope* scope)
+{
+    while (scope) {
+        if (scope->type == ScopeType::eSwitch)
+            return true;
+        if (scope->type == ScopeType::eUnconditional) {
+            scope = scope->nestedIn;
+            continue;
+        }
+        break;
+    }
+    return false;
+}
+
+static bool isVardeclInSwitch(const Token* tok)
+{
+    if (!tok)
+        return false;
+    if (!isNestedInSwitch(tok->scope()))
+        return false;
+    if (const Token* end = Token::findsimplematch(tok, ";")) {
+        for (const Token* tok2 = tok; tok2 != end; tok2 = tok2->next()) {
+            if (tok2->isKeyword() && tok2->str() == "case")
+                return false;
+            if (tok2->variable() && tok2->variable()->nameToken() == tok2) {
+                end = tok2->scope()->bodyEnd;
+                for (const Token* tok3 = tok2; tok3 != end; tok3 = tok3->next()) {
+                    if (tok3->isKeyword())
+                        return tok3->str() == "case";
+                }
+                return false;
+            }
+        }
+    }
+    return false;
 }
 
 //---------------------------------------------------------------------------
@@ -757,11 +1012,20 @@ void CheckOther::suspiciousCaseInSwitchError(const Token* tok, const std::string
 //---------------------------------------------------------------------------
 void CheckOther::checkUnreachableCode()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    // misra-c-2012-2.1
+    // misra-c-2023-2.1
+    // misra-cpp-2008-0-1-1
+    // autosar
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("duplicateBreak") && !mSettings->isPremiumEnabled("unreachableCode"))
         return;
-    const bool printInconclusive = mSettings->inconclusive;
+
+    logChecker("CheckOther::checkUnreachableCode"); // style
+
+    const bool printInconclusive = mSettings->certainty.isEnabled(Certainty::inconclusive);
     const SymbolDatabase* symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
+        if (scope->hasInlineOrLambdaFunction(nullptr, /*onlyInline*/ true))
+            continue;
         for (const Token* tok = scope->bodyStart; tok && tok != scope->bodyEnd; tok = tok->next()) {
             const Token* secondBreak = nullptr;
             const Token* labelName = nullptr;
@@ -769,7 +1033,7 @@ void CheckOther::checkUnreachableCode()
                 tok = tok->link();
             else if (Token::Match(tok, "break|continue ;"))
                 secondBreak = tok->tokAt(2);
-            else if (Token::Match(tok, "[;{}:] return|throw")) {
+            else if (Token::Match(tok, "[;{}:] return|throw") && tok->next()->isKeyword()) {
                 if (Token::simpleMatch(tok->astParent(), "?"))
                     continue;
                 tok = tok->next(); // tok should point to return or throw
@@ -787,22 +1051,34 @@ void CheckOther::checkUnreachableCode()
             } else if (Token::Match(tok, "%name% (") && mSettings->library.isnoreturn(tok) && !Token::Match(tok->next()->astParent(), "?|:")) {
                 if ((!tok->function() || (tok->function()->token != tok && tok->function()->tokenDef != tok)) && tok->linkAt(1)->strAt(1) != "{")
                     secondBreak = tok->linkAt(1)->tokAt(2);
+                if (Token::simpleMatch(secondBreak, "return")) {
+                    // clarification for tools that function returns
+                    continue;
+                }
+            }
+            while (Token::simpleMatch(secondBreak, "}") && secondBreak->scope()->type == ScopeType::eUnconditional)
+                secondBreak = secondBreak->next();
+            if (secondBreak && secondBreak->scope()->nestedIn && secondBreak->scope()->nestedIn->type == ScopeType::eSwitch &&
+                tok->str() == "break") {
+                while (Token::simpleMatch(secondBreak, "{") && secondBreak->scope()->type == ScopeType::eUnconditional)
+                    secondBreak = secondBreak->next();
             }
+            while (Token::simpleMatch(secondBreak, ";"))
+                secondBreak = secondBreak->next();
 
             // Statements follow directly, no line between them. (#3383)
             // TODO: Try to find a better way to avoid false positives due to preprocessor configurations.
             const bool inconclusive = secondBreak && (secondBreak->linenr() - 1 > secondBreak->previous()->linenr());
 
             if (secondBreak && (printInconclusive || !inconclusive)) {
-                if (Token::Match(secondBreak, "continue|goto|throw") ||
-                    (secondBreak->str() == "return" && (tok->str() == "return" || secondBreak->strAt(1) == ";"))) { // return with value after statements like throw can be necessary to make a function compile
+                if (Token::Match(secondBreak, "continue|goto|throw|return") && secondBreak->isKeyword()) {
                     duplicateBreakError(secondBreak, inconclusive);
                     tok = Token::findmatch(secondBreak, "[}:]");
                 } else if (secondBreak->str() == "break") { // break inside switch as second break statement should not issue a warning
                     if (tok->str() == "break") // If the previous was a break, too: Issue warning
                         duplicateBreakError(secondBreak, inconclusive);
                     else {
-                        if (tok->scope()->type != Scope::eSwitch) // Check, if the enclosing scope is a switch
+                        if (tok->scope()->type != ScopeType::eSwitch) // Check, if the enclosing scope is a switch
                             duplicateBreakError(secondBreak, inconclusive);
                     }
                     tok = Token::findmatch(secondBreak, "[}:]");
@@ -829,17 +1105,20 @@ void CheckOther::checkUnreachableCode()
                         if (Token::Match(silencedWarning, "( void ) %name% ;")) {
                             silencedWarning = silencedWarning->tokAt(5);
                             continue;
-                        } else if (silencedWarning && silencedWarning == scope->bodyEnd)
+                        }
+                        if (silencedWarning && silencedWarning == scope->bodyEnd)
                             silencedCompilerWarningOnly = true;
-
                         break;
                     }
                     if (silencedWarning)
                         secondBreak = silencedWarning;
 
-                    if (!labelInFollowingLoop && !silencedCompilerWarningOnly)
-                        unreachableCodeError(secondBreak, inconclusive);
+                    if (!labelInFollowingLoop && !silencedCompilerWarningOnly && !isVardeclInSwitch(secondBreak))
+                        unreachableCodeError(secondBreak, tok, inconclusive);
                     tok = Token::findmatch(secondBreak, "[}:]");
+                } else if (secondBreak->scope() && secondBreak->scope()->isLoopScope() && secondBreak->str() == "}" && tok->str() == "continue") {
+                    redundantContinueError(tok);
+                    tok = secondBreak;
                 } else
                     tok = secondBreak;
 
@@ -856,13 +1135,54 @@ void CheckOther::duplicateBreakError(const Token *tok, bool inconclusive)
     reportError(tok, Severity::style, "duplicateBreak",
                 "Consecutive return, break, continue, goto or throw statements are unnecessary.\n"
                 "Consecutive return, break, continue, goto or throw statements are unnecessary. "
-                "The second statement can never be executed, and so should be removed.", CWE561, inconclusive);
+                "The second statement can never be executed, and so should be removed.", CWE561, inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
-void CheckOther::unreachableCodeError(const Token *tok, bool inconclusive)
+void CheckOther::unreachableCodeError(const Token *tok, const Token* noreturn, bool inconclusive)
 {
+    std::string msg = "Statements following ";
+    if (noreturn && (noreturn->function() || mSettings->library.isnoreturn(noreturn)))
+        msg += "noreturn function '" + noreturn->str() + "()'";
+    else if (noreturn && noreturn->isKeyword())
+        msg += "'" + noreturn->str() + "'";
+    else
+        msg += "return, break, continue, goto or throw";
+    msg += " will never be executed.";
     reportError(tok, Severity::style, "unreachableCode",
-                "Statements following return, break, continue, goto or throw will never be executed.", CWE561, inconclusive);
+                msg, CWE561, inconclusive ? Certainty::inconclusive : Certainty::normal);
+}
+
+void CheckOther::redundantContinueError(const Token *tok)
+{
+    reportError(tok, Severity::style, "redundantContinue",
+                "'continue' is redundant since it is the last statement in a loop.", CWE561, Certainty::normal);
+}
+
+static bool isSimpleExpr(const Token* tok, const Variable* var, const Settings& settings) {
+    if (!tok)
+        return false;
+    if (tok->isNumber() || tok->tokType() == Token::eString || tok->tokType() == Token::eChar || tok->isBoolean())
+        return true;
+    if (isNullOperand(tok))
+        return true;
+    bool needsCheck = tok->varId() > 0;
+    if (!needsCheck) {
+        if (tok->isArithmeticalOp())
+            return isSimpleExpr(tok->astOperand1(), var, settings) && (!tok->astOperand2() || isSimpleExpr(tok->astOperand2(), var, settings));
+        const Token* ftok = tok->previous();
+        if (Token::Match(ftok, "%name% (") &&
+            ((ftok->function() && ftok->function()->isConst()) || settings.library.isFunctionConst(ftok->str(), /*pure*/ true)))
+            needsCheck = true;
+        else if (tok->str() == "[") {
+            needsCheck = tok->astOperand1() && tok->astOperand1()->varId() > 0;
+            tok = tok->astOperand1();
+        }
+        else if (isLeafDot(tok->astOperand2())) {
+            needsCheck = tok->astOperand2()->varId() > 0;
+            tok = tok->astOperand2();
+        }
+    }
+    return (needsCheck && !findExpressionChanged(tok, tok->astParent(), var->scope()->bodyEnd, settings));
 }
 
 //---------------------------------------------------------------------------
@@ -870,16 +1190,37 @@ void CheckOther::unreachableCodeError(const Token *tok, bool inconclusive)
 //---------------------------------------------------------------------------
 void CheckOther::checkVariableScope()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (mSettings->clang)
+        return;
+
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("variableScope"))
         return;
 
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
+    // In C it is common practice to declare local variables at the
+    // start of functions.
+    if (mSettings->daca && mTokenizer->isC())
+        return;
+
+    logChecker("CheckOther::checkVariableScope"); // style,notclang
+
     for (const Variable* var : symbolDatabase->variableList()) {
-        if (!var || !var->isLocal() || (!var->isPointer() && !var->isReference() && !var->typeStartToken()->isStandardType()))
+        if (!var || !var->isLocal() || var->isConst())
             continue;
 
-        if (var->isConst())
+        if (var->nameToken()->isExpandedMacro())
+            continue;
+        if (isStructuredBindingVariable(var) && // warn for single decomposition
+            !(Token::simpleMatch(var->nameToken()->astParent(), "[") && var->nameToken()->astParent()->astOperand2() == var->nameToken()))
+            continue;
+
+        const bool isPtrOrRef = var->isPointer() || var->isReference();
+        const bool isSimpleType = var->typeStartToken()->isStandardType() || var->typeStartToken()->isEnumType() || var->typeStartToken()->isC() || symbolDatabase->isRecordTypeWithoutSideEffects(var->type());
+        if (!isPtrOrRef && !isSimpleType && !astIsContainer(var->nameToken()))
+            continue;
+
+        if (mTokenizer->hasIfdef(var->nameToken(), var->scope()->bodyEnd))
             continue;
 
         // reference of range for loop variable..
@@ -897,25 +1238,46 @@ void CheckOther::checkVariableScope()
             if (tok->str() == "(") {
                 forHead = true;
                 break;
-            } else if (Token::Match(tok, "[;{}]"))
+            }
+            if (Token::Match(tok, "[;{}]"))
                 break;
         }
         if (forHead)
             continue;
 
         const Token* tok = var->nameToken()->next();
-        if (Token::Match(tok, "; %varid% = %any% ;", var->declarationId())) {
-            tok = tok->tokAt(3);
-            if (!tok->isNumber() && tok->tokType() != Token::eString && tok->tokType() != Token::eChar && !tok->isBoolean())
+        bool isConstructor = false;
+        if (Token::Match(tok, "; %varid% =", var->declarationId())) { // bailout for assignment
+            tok = tok->tokAt(2)->astOperand2();
+            if (!isSimpleExpr(tok, var, *mSettings))
+                continue;
+        }
+        else if (Token::Match(tok, "{|(")) { // bailout for constructor
+            isConstructor = true;
+            const Token* argTok = tok->astOperand2();
+            bool bail = false;
+            while (argTok) {
+                if (Token::simpleMatch(argTok, ",")) {
+                    if (!isSimpleExpr(argTok->astOperand2(), var, *mSettings)) {
+                        bail = true;
+                        break;
+                    }
+                } else if (argTok->str() != "." && !isSimpleExpr(argTok, var, *mSettings)) {
+                    bail = true;
+                    break;
+                }
+                argTok = argTok->astOperand1();
+            }
+            if (bail)
                 continue;
         }
         // bailout if initialized with function call that has possible side effects
-        if (Token::Match(tok, "[(=]") && Token::simpleMatch(tok->astOperand2(), "("))
+        if (!isConstructor && Token::Match(tok, "[(=]") && Token::simpleMatch(tok->astOperand2(), "("))
             continue;
         bool reduce = true;
         bool used = false; // Don't warn about unused variables
         for (; tok && tok != var->scope()->bodyEnd; tok = tok->next()) {
-            if (tok->str() == "{" && tok->scope() != tok->previous()->scope() && !tok->isExpandedMacro() && tok->scope()->type != Scope::eLambda) {
+            if (tok->str() == "{" && tok->scope() != tok->previous()->scope() && !tok->isExpandedMacro() && !isWithinScope(tok, var, ScopeType::eLambda)) {
                 if (used) {
                     bool used2 = false;
                     if (!checkInnerScope(tok, var, used2) || used2) {
@@ -930,17 +1292,8 @@ void CheckOther::checkVariableScope()
                 tok = tok->link();
 
                 // parse else if blocks..
-            } else if (Token::simpleMatch(tok, "else { if (") && Token::simpleMatch(tok->linkAt(3), ") {")) {
-                const Token *endif = tok->linkAt(3)->linkAt(1);
-                bool elseif = false;
-                if (Token::simpleMatch(endif, "} }"))
-                    elseif = true;
-                else if (Token::simpleMatch(endif, "} else {") && Token::simpleMatch(endif->linkAt(2),"} }"))
-                    elseif = true;
-                if (elseif && Token::findmatch(tok->next(), "%varid%", tok->linkAt(1), var->declarationId())) {
-                    reduce = false;
-                    break;
-                }
+            } else if (Token::simpleMatch(tok, "else { if (") && tok->next()->isSimplifiedScope() && Token::simpleMatch(tok->linkAt(3), ") {")) {
+                tok = tok->next();
             } else if (tok->varId() == var->declarationId() || tok->str() == "goto") {
                 reduce = false;
                 break;
@@ -952,21 +1305,56 @@ void CheckOther::checkVariableScope()
     }
 }
 
-bool CheckOther::checkInnerScope(const Token *tok, const Variable* var, bool& used)
+// used to check if an argument to a function might depend on another argument
+static bool mayDependOn(const ValueType *other, const ValueType *original)
+{
+    if (!other || !original)
+        return false;
+
+    // other must be pointer
+    if (!other->pointer)
+        return false;
+
+    // must be same underlying type
+    if (other->type != original->type)
+        return false;
+
+    const int otherPtr = other->pointer + (other->reference == Reference::LValue ? 1 : 0);
+    const int originalPtr = original->pointer;
+
+    if (otherPtr == originalPtr) {
+        // if other is not const than original may be copied to other
+        return !other->isConst(otherPtr);
+    }
+
+    // other may be reassigned to original
+    return otherPtr > originalPtr;
+}
+
+static bool isOnlyUsedInCurrentScope(const Variable* var, const Token *tok, const Scope* scope)
+{
+    if (tok->scope() == scope)
+        return true;
+    if (tok->scope()->type == ScopeType::eSwitch)
+        return false;
+    return !Token::findmatch(tok->scope()->bodyEnd, "%varid%", var->scope()->bodyEnd, var->declarationId());
+}
+
+bool CheckOther::checkInnerScope(const Token *tok, const Variable* var, bool& used) const
 {
     const Scope* scope = tok->next()->scope();
-    bool loopVariable = scope->type == Scope::eFor || scope->type == Scope::eWhile || scope->type == Scope::eDo;
+    bool loopVariable = scope->isLoopScope();
     bool noContinue = true;
     const Token* forHeadEnd = nullptr;
     const Token* end = tok->link();
-    if (scope->type == Scope::eUnconditional && (tok->strAt(-1) == ")" || tok->previous()->isName())) // Might be an unknown macro like BOOST_FOREACH
+    if (scope->type == ScopeType::eUnconditional && (tok->strAt(-1) == ")" || tok->previous()->isName())) // Might be an unknown macro like BOOST_FOREACH
         loopVariable = true;
 
-    if (scope->type == Scope::eDo) {
+    if (scope->type == ScopeType::eDo) {
         end = end->linkAt(2);
     } else if (loopVariable && tok->strAt(-1) == ")") {
         tok = tok->linkAt(-1); // Jump to opening ( of for/while statement
-    } else if (scope->type == Scope::eSwitch) {
+    } else if (scope->type == ScopeType::eSwitch) {
         for (const Scope* innerScope : scope->nestedList) {
             if (used) {
                 bool used2 = false;
@@ -991,22 +1379,18 @@ bool CheckOther::checkInnerScope(const Token *tok, const Variable* var, bool& us
         if (tok == forHeadEnd)
             forHeadEnd = nullptr;
 
-        if (loopVariable && noContinue && tok->scope() == scope && !forHeadEnd && scope->type != Scope::eSwitch && Token::Match(tok, "%varid% =", var->declarationId())) { // Assigned in outer scope.
+        if (loopVariable && noContinue && !forHeadEnd && scope->type != ScopeType::eSwitch && Token::Match(tok, "%varid% =", var->declarationId()) &&
+            isOnlyUsedInCurrentScope(var, tok, scope)) { // Assigned in outer scope.
             loopVariable = false;
-            int indent = 0;
-            for (const Token* tok2 = tok->tokAt(2); tok2; tok2 = tok2->next()) { // Ensure that variable isn't used on right side of =, too
-                if (tok2->str() == "(")
-                    indent++;
-                else if (tok2->str() == ")") {
-                    if (indent == 0)
-                        break;
-                    indent--;
-                } else if (tok2->str() == ";")
-                    break;
-                else if (tok2->varId() == var->declarationId()) {
-                    loopVariable = true;
-                    break;
-                }
+            std::pair<const Token*, const Token*> range = tok->next()->findExpressionStartEndTokens();
+            if (range.first)
+                range.first = range.first->next();
+            const Token* exprTok = findExpression(var->nameToken()->exprId(), range.first, range.second, [&](const Token* tok2) {
+                return tok2->varId() == var->declarationId();
+            });
+            if (exprTok) {
+                tok = exprTok;
+                loopVariable = true;
             }
         }
 
@@ -1016,23 +1400,55 @@ bool CheckOther::checkInnerScope(const Token *tok, const Variable* var, bool& us
         if (Token::Match(tok, "& %varid%", var->declarationId())) // Taking address of variable
             return false;
 
-        if (Token::Match(tok, "%varid% =", var->declarationId()))
+        if (Token::Match(tok, "%varid% =", var->declarationId())) {
+            if (!bFirstAssignment && var->isInit() && Token::findmatch(tok->tokAt(2), "%varid%", Token::findsimplematch(tok->tokAt(3), ";"), var->declarationId()))
+                return false;
             bFirstAssignment = true;
+        }
 
         if (!bFirstAssignment && Token::Match(tok, "* %varid%", var->declarationId())) // dereferencing means access to previous content
             return false;
 
-        if (Token::Match(tok, "= %varid%", var->declarationId()) && (var->isArray() || var->isPointer())) // Create a copy of array/pointer. Bailout, because the memory it points to might be necessary in outer scope
+        if (Token::Match(tok, "= %varid%", var->declarationId()) && (var->isArray() || var->isPointer() || (var->valueType() && var->valueType()->container))) // Create a copy of array/pointer. Bailout, because the memory it points to might be necessary in outer scope
             return false;
 
         if (tok->varId() == var->declarationId()) {
             used = true;
-            if (scope->type == Scope::eSwitch && scope == tok->scope())
-                return false; // Used in outer switch scope - unsafe or impossible to reduce scope
-        }
-    }
+            if (scope == tok->scope()) {
+                if (scope->type == ScopeType::eSwitch)
+                    return false; // Used in outer switch scope - unsafe or impossible to reduce scope
 
-    return true;
+                if (scope->bodyStart && scope->bodyStart->isSimplifiedScope())
+                    return false; // simplified if/for/switch init statement
+            }
+            if (var->isArrayOrPointer()) {
+                int argn{};
+                if (const Token* ftok = getTokenArgumentFunction(tok, argn)) { // var passed to function?
+                    if (ftok->next()->astParent()) { // return value used?
+                        if (ftok->function() && Function::returnsPointer(ftok->function()))
+                            return false;
+                        const std::string ret = mSettings->library.returnValueType(ftok); // assume that var is returned
+                        if (!ret.empty() && ret.back() == '*')
+                            return false;
+                    }
+                    if (ftok->function()) {
+                        const std::list<Variable> &argvars = ftok->function()->argumentList;
+                        if (const Variable* argvar = ftok->function()->getArgumentVar(argn)) {
+                            if (!std::all_of(argvars.cbegin(), argvars.cend(), [&](const Variable& other) {
+                                return &other == argvar || !mayDependOn(other.valueType(), argvar->valueType());
+                            }))
+                                return false;
+                        }
+                    }
+                }
+            }
+            const auto yield = astContainerYield(tok, mSettings->library);
+            if (yield == Library::Container::Yield::BUFFER || yield == Library::Container::Yield::BUFFER_NT)
+                return false;
+        }
+    }
+
+    return true;
 }
 
 void CheckOther::variableScopeError(const Token *tok, const std::string &varname)
@@ -1056,7 +1472,7 @@ void CheckOther::variableScopeError(const Token *tok, const std::string &varname
                 "        }\n"
                 "    }\n"
                 "}\n"
-                "When you see this message it is always safe to reduce the variable scope 1 level.", CWE398, false);
+                "When you see this message it is always safe to reduce the variable scope 1 level.", CWE398, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -1064,12 +1480,11 @@ void CheckOther::variableScopeError(const Token *tok, const std::string &varname
 //---------------------------------------------------------------------------
 void CheckOther::checkCommaSeparatedReturn()
 {
-    // This is experimental for now. See #5076
-    if (!mSettings->experimental)
+    // TODO: This is experimental for now. See #5076
+    if ((true) || !mSettings->severity.isEnabled(Severity::style)) // NOLINT(readability-simplify-boolean-expr,readability-redundant-parentheses)
         return;
 
-    if (!mSettings->isEnabled(Settings::STYLE))
-        return;
+    // logChecker
 
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
         if (tok->str() == "return") {
@@ -1103,187 +1518,115 @@ void CheckOther::commaSeparatedReturnError(const Token *tok)
                 "    if (x)\n"
                 "        return a + 1,\n"
                 "    b++;\n"
-                "However it can be useful to use comma in macros. Cppcheck does not warn when such a "
-                "macro is then used in a return statement, it is less likely such code is misunderstood.", CWE398, false);
+                "However it can be useful to use comma in macros. No warning is reported when such a "
+                "macro is then used in a return statement, it is less likely such code is misunderstood.", CWE398, Certainty::normal);
 }
 
-//---------------------------------------------------------------------------
-// Check for function parameters that should be passed by const reference
-//---------------------------------------------------------------------------
-static int estimateSize(const Type* type, const Settings* settings, const SymbolDatabase* symbolDatabase, int recursionDepth = 0)
-{
-    if (recursionDepth > 20)
-        return 0;
-
-    int cumulatedSize = 0;
-    for (const Variable&var : type->classScope->varlist) {
-        int size = 0;
-        if (var.isStatic())
-            continue;
-        if (var.isPointer() || var.isReference())
-            size = settings->sizeof_pointer;
-        else if (var.type() && var.type()->classScope)
-            size = estimateSize(var.type(), settings, symbolDatabase, recursionDepth+1);
-        else if (var.valueType()->type == ValueType::Type::CONTAINER)
-            size = 3 * settings->sizeof_pointer; // Just guess
-        else
-            size = symbolDatabase->sizeOfType(var.typeStartToken());
-
-        if (var.isArray())
-            cumulatedSize += size * var.dimension(0);
-        else
-            cumulatedSize += size;
-    }
-    for (const Type::BaseInfo &baseInfo : type->derivedFrom) {
-        if (baseInfo.type && baseInfo.type->classScope)
-            cumulatedSize += estimateSize(baseInfo.type, settings, symbolDatabase, recursionDepth+1);
-    }
-    return cumulatedSize;
-}
-
-static bool canBeConst(const Variable *var)
+static bool isLargeContainer(const Variable* var, const Settings& settings)
 {
-    {
-        // check initializer list. If variable is moved from it can't be const.
-        const Function* func_scope = var->scope()->function;
-        if (func_scope->type == Function::Type::eConstructor) {
-            //could be initialized in initializer list
-            if (func_scope->arg->link()->next()->str() == ":") {
-                for (const Token* tok2 = func_scope->arg->link()->next()->next(); tok2 != var->scope()->bodyStart; tok2 = tok2->next()) {
-                    if (tok2->varId() != var->declarationId())
-                        continue;
-                    const Token* parent = tok2->astParent();
-                    if (parent && Token::simpleMatch(parent->previous(), "move ("))
-                        return false;
-                }
-            }
+    const ValueType* vt = var->valueType();
+    if (vt->container->startPattern == "std :: initializer_list <")
+        return false;
+    if (vt->container->size_templateArgNo < 0)
+        return true;
+    const std::size_t maxByValueSize = 2 * settings.platform.sizeof_pointer;
+    if (var->dimensions().empty()) {
+        if (vt->container->startPattern == "std :: bitset <") {
+            if (const ValueFlow::Value* v = vt->containerTypeToken->getKnownValue(ValueFlow::Value::ValueType::INT))
+                return v->intvalue / 8 > maxByValueSize;
         }
+        return false;
     }
-    for (const Token* tok2 = var->scope()->bodyStart; tok2 != var->scope()->bodyEnd; tok2 = tok2->next()) {
-        if (tok2->varId() != var->declarationId())
-            continue;
-
-        const Token* parent = tok2->astParent();
-        if (!parent)
-            continue;
-        if (parent->str() == "<<" || isLikelyStreamRead(true, parent)) {
-            if (parent->str() == "<<" && parent->astOperand1() == tok2)
-                return false;
-            if (parent->str() == ">>" && parent->astOperand2() == tok2)
-                return false;
-        } else if (parent->str() == "," || parent->str() == "(") { // function argument
-            const Token* tok3 = tok2->previous();
-            int argNr = 0;
-            while (tok3 && tok3->str() != "(") {
-                if (tok3->link() && Token::Match(tok3, ")|]|}|>"))
-                    tok3 = tok3->link();
-                else if (tok3->link())
-                    break;
-                else if (tok3->str() == ";")
-                    break;
-                else if (tok3->str() == ",")
-                    argNr++;
-                tok3 = tok3->previous();
-            }
-            if (!tok3 || tok3->str() != "(" || !tok3->astOperand1() || !tok3->astOperand1()->function())
-                return false;
-            else {
-                const Variable* argVar = tok3->astOperand1()->function()->getArgumentVar(argNr);
-                if (!argVar|| (!argVar->isConst() && argVar->isReference()))
-                    return false;
-            }
-        } else if (parent->isUnaryOp("&")) {
-            // TODO: check how pointer is used
-            return false;
-        } else if (parent->isConstOp())
-            continue;
-        else if (parent->isAssignmentOp()) {
-            if (parent->astOperand1() == tok2)
-                return false;
-            else if (parent->astOperand1()->str() == "&") {
-                const Variable* assignedVar = parent->previous()->variable();
-                if (!assignedVar || !assignedVar->isConst())
-                    return false;
-            }
-        } else if (Token::Match(tok2, "%var% . %name% (")) {
-            const Function* func = tok2->tokAt(2)->function();
-            if (func && (func->isConst() || func->isStatic()))
-                continue;
-            else
-                return false;
-        } else
-            return false;
-    }
-
-    return true;
+    const ValueType vtElem = ValueType::parseDecl(vt->containerTypeToken, settings);
+    const auto elemSize = std::max<std::size_t>(vtElem.getSizeOf(settings, ValueType::Accuracy::LowerBound, ValueType::SizeOf::Pointer), 1);
+    const auto arraySize = var->dimension(0) * elemSize;
+    return arraySize > maxByValueSize;
 }
 
 void CheckOther::checkPassByReference()
 {
-    if (!mSettings->isEnabled(Settings::PERFORMANCE) || mTokenizer->isC())
+    if (!mSettings->severity.isEnabled(Severity::performance) || mTokenizer->isC())
         return;
 
+    logChecker("CheckOther::checkPassByReference"); // performance,c++
+
     const SymbolDatabase * const symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Variable* var : symbolDatabase->variableList()) {
-        if (!var || !var->isArgument() || !var->isClass() || var->isPointer() || var->isArray() || var->isReference() || var->isEnumType())
+        if (!var || !var->isClass() || var->isPointer() || (var->isArray() && !var->isStlType()) || var->isReference() || var->isEnumType())
+            continue;
+
+        const bool isRangeBasedFor = astIsRangeBasedForDecl(var->nameToken());
+        if (!var->isArgument() && !isRangeBasedFor)
             continue;
 
-        if (var->scope() && var->scope()->function->arg->link()->strAt(-1) == "...")
+        if (!isRangeBasedFor && var->scope() && var->scope()->function->arg->link()->strAt(-1) == "...")
             continue; // references could not be used as va_start parameters (#5824)
 
+        const Token * const varDeclEndToken = var->declEndToken();
+        if ((varDeclEndToken && varDeclEndToken->isExternC()) ||
+            (var->scope() && var->scope()->function && var->scope()->function->tokenDef && var->scope()->function->tokenDef->isExternC()))
+            continue; // references cannot be used in functions in extern "C" blocks
+
         bool inconclusive = false;
 
-        if (var->valueType()->type == ValueType::Type::CONTAINER) {
-        } else if (var->type() && !var->type()->isEnumType()) { // Check if type is a struct or class.
-            // Ensure that it is a large object.
-            if (!var->type()->classScope)
-                inconclusive = true;
-            else if (estimateSize(var->type(), mSettings, symbolDatabase) <= 2 * mSettings->sizeof_pointer)
+        const bool isContainer = var->valueType() && var->valueType()->type == ValueType::Type::CONTAINER && var->valueType()->container && !var->valueType()->container->view;
+        if (isContainer && !isLargeContainer(var, *mSettings))
+            continue;
+        if (!isContainer) {
+            if (var->type() && !var->type()->isEnumType()) { // Check if type is a struct or class.
+                // Ensure that it is a large object.
+                if (!var->type()->classScope)
+                    inconclusive = true;
+                else if (!var->valueType() || var->valueType()->getSizeOf(*mSettings, ValueType::Accuracy::LowerBound, ValueType::SizeOf::Pointer) <= 2 * mSettings->platform.sizeof_pointer)
+                    continue;
+            }
+            else
                 continue;
-        } else
+        }
+
+        if (inconclusive && !mSettings->certainty.isEnabled(Certainty::inconclusive))
             continue;
 
-        if (inconclusive && !mSettings->inconclusive)
+        if (var->isArray() && (!var->isStlType() || Token::simpleMatch(var->nameToken()->next(), "[")))
             continue;
 
         const bool isConst = var->isConst();
         if (isConst) {
-            passedByValueError(var->nameToken(), var->name(), inconclusive);
+            passedByValueError(var, inconclusive, isRangeBasedFor);
             continue;
         }
 
         // Check if variable could be const
-        if (!var->scope() || var->scope()->function->hasVirtualSpecifier())
+        if (!isRangeBasedFor && (!var->scope() || var->scope()->function->isImplicitlyVirtual()))
             continue;
 
-        if (canBeConst(var)) {
-            passedByValueError(var->nameToken(), var->name(), inconclusive);
+        if (!isVariableChanged(var, *mSettings)) {
+            passedByValueError(var, inconclusive, isRangeBasedFor);
         }
     }
 }
 
-void CheckOther::passedByValueError(const Token *tok, const std::string &parname, bool inconclusive)
+void CheckOther::passedByValueError(const Variable* var, bool inconclusive, bool isRangeBasedFor)
 {
-    reportError(tok, Severity::performance, "passedByValue",
-                "$symbol:" + parname + "\n"
-                "Function parameter '$symbol' should be passed by const reference.\n"
-                "Parameter '$symbol' is passed by value. It could be passed "
-                "as a const reference which is usually faster and recommended in C++.", CWE398, inconclusive);
-}
-
-static bool isUnusedVariable(const Variable *var)
-{
-    if (!var)
-        return false;
-    if (!var->scope())
-        return false;
-    const Token *start = var->declEndToken();
-    if (!start)
-        return false;
-    if (Token::Match(start, "; %varid% =", var->declarationId()))
-        start = start->tokAt(2);
-    return !Token::findmatch(start->next(), "%varid%", var->scope()->bodyEnd, var->declarationId());
+    std::string id = isRangeBasedFor ? "iterateByValue" : "passedByValue";
+    const std::string action = isRangeBasedFor ? "declared as": "passed by";
+    const std::string type = isRangeBasedFor ? "Range variable" : "Function parameter";
+    std::string msg = "$symbol:" + (var ? var->name() : "") + "\n" +
+                      type + " '$symbol' should be " + action + " const reference.";
+    ErrorPath errorPath;
+    if (var && var->scope() && var->scope()->function && var->scope()->function->functionPointerUsage) {
+        id += "Callback";
+        errorPath.emplace_front(var->scope()->function->functionPointerUsage, "Function pointer used here.");
+        msg += " However it seems that '" + var->scope()->function->name() + "' is a callback function.";
+    }
+    if (var)
+        errorPath.emplace_back(var->nameToken(), msg);
+    if (isRangeBasedFor)
+        msg += "\nVariable '$symbol' is used to iterate by value. It could be declared as a const reference which is usually faster and recommended in C++.";
+    else
+        msg += "\nParameter '$symbol' is passed by value. It could be passed as a const reference which is usually faster and recommended in C++.";
+    reportError(std::move(errorPath), Severity::performance, id.c_str(), msg, CWE398, inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
 static bool isVariableMutableInInitializer(const Token* start, const Token * end, nonneg int varid)
@@ -1299,24 +1642,43 @@ static bool isVariableMutableInInitializer(const Token* start, const Token * end
             const Token * memberTok = tok->astParent()->previous();
             if (Token::Match(memberTok, "%var% (") && memberTok->variable()) {
                 const Variable * memberVar = memberTok->variable();
+                if (memberVar->isClass())
+                    //TODO: check if the called constructor could live with a const variable
+                    // pending that, assume the worst (that it can't)
+                    return true;
                 if (!memberVar->isReference())
                     continue;
                 if (memberVar->isConst())
                     continue;
             }
-            return true;
-        } else {
-            return true;
         }
+        return true;
+    }
+    return false;
+}
+
+static bool isCastToVoid(const Variable* var)
+{
+    if (!var)
+        return false;
+    if (!var->scope())
+        return false;
+    for (const Token* tok = var->scope()->bodyStart; tok != var->scope()->bodyEnd; tok = tok->next()) {
+        if (tok->varId() != var->declarationId())
+            continue;
+        if (isVoidCast(tok->astParent()))
+            return true;
     }
     return false;
 }
 
 void CheckOther::checkConstVariable()
 {
-    if (!mSettings->isEnabled(Settings::STYLE) || mTokenizer->isC())
+    if ((!mSettings->severity.isEnabled(Severity::style) || mTokenizer->isC()) && !mSettings->isPremiumEnabled("constVariable"))
         return;
 
+    logChecker("CheckOther::checkConstVariable"); // style,c++
+
     const SymbolDatabase *const symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Variable *var : symbolDatabase->variableList()) {
@@ -1326,19 +1688,19 @@ void CheckOther::checkConstVariable()
             continue;
         if (var->isRValueReference())
             continue;
+        if (var->isPointer())
+            continue;
         if (var->isConst())
             continue;
-        if (!var->scope())
+        const Scope* scope = var->scope();
+        if (!scope)
             continue;
-        const Scope *scope = var->scope();
-        if (!scope->function)
+        const Function* function = scope->function;
+        if (!function && !scope->isLocal())
             continue;
-        Function *function = scope->function;
-        if (var->isArgument()) {
+        if (function && var->isArgument()) {
             if (function->isImplicitlyVirtual() || function->templateDef)
                 continue;
-            if (isUnusedVariable(var))
-                continue;
             if (function->isConstructor() && isVariableMutableInInitializer(function->constructorMemberInitialization(), scope->bodyStart, var->declarationId()))
                 continue;
         }
@@ -1346,38 +1708,361 @@ void CheckOther::checkConstVariable()
             continue;
         if (var->isStatic())
             continue;
-        if (var->isArray())
+        if (var->isArray() && !var->isStlType())
             continue;
         if (var->isEnumType())
             continue;
         if (var->isVolatile())
             continue;
-        if (isAliased(var))
+        if (var->isMaybeUnused())
             continue;
-        if (isVariableChanged(var, mSettings, mTokenizer->isCPP()))
+        if (var->nameToken()->isExpandedMacro())
             continue;
-        if (Function::returnsReference(function) &&
-            Token::findmatch(var->nameToken(), "return %varid% ;|[", scope->bodyEnd, var->declarationId()))
+        if (isStructuredBindingVariable(var)) // TODO: check all bound variables
             continue;
-        // Skip if address is taken
-        if (Token::findmatch(var->nameToken(), "& %varid%", scope->bodyEnd, var->declarationId()))
+        if (isCastToVoid(var))
             continue;
-        constVariableError(var);
+        if (isVariableChanged(var, *mSettings))
+            continue;
+        const bool hasFunction = function != nullptr;
+        if (!hasFunction) {
+            const Scope* functionScope = scope;
+            do {
+                functionScope = functionScope->nestedIn;
+            } while (functionScope && !(function = functionScope->function));
+        }
+        if (function && (Function::returnsReference(function) || Function::returnsPointer(function)) && !Function::returnsConst(function)) {
+            std::vector<const Token*> returns = Function::findReturns(function);
+            if (std::any_of(returns.cbegin(), returns.cend(), [&](const Token* retTok) {
+                if (retTok->varId() == var->declarationId())
+                    return true;
+                while (retTok && retTok->isCast())
+                    retTok = retTok->astOperand2() ? retTok->astOperand2() : retTok->astOperand1();
+                while (Token::simpleMatch(retTok, "."))
+                    retTok = retTok->astOperand2();
+                if (Token::simpleMatch(retTok, "&"))
+                    retTok = retTok->astOperand1();
+                ValueFlow::Value ltVal = ValueFlow::getLifetimeObjValue(retTok);
+                if (ltVal.isLifetimeValue() && ltVal.tokvalue->varId() == var->declarationId())
+                    return true;
+                return ValueFlow::hasLifetimeToken(getParentLifetime(retTok), var->nameToken(), *mSettings);
+            }))
+                continue;
+        }
+        // Skip if another non-const variable is initialized with this variable
+        {
+            //Is it the right side of an initialization of a non-const reference
+            bool usedInAssignment = false;
+            for (const Token* tok = var->nameToken(); tok != scope->bodyEnd && tok != nullptr; tok = tok->next()) {
+                if (Token::Match(tok, "& %var% = %varid%", var->declarationId())) {
+                    const Variable* refvar = tok->next()->variable();
+                    if (refvar && !refvar->isConst() && refvar->nameToken() == tok->next()) {
+                        usedInAssignment = true;
+                        break;
+                    }
+                }
+                if (tok->isUnaryOp("&") && Token::Match(tok, "& %varid%", var->declarationId())) {
+                    const Token* opTok = tok->astParent();
+                    int argn = -1;
+                    if (opTok && (opTok->isUnaryOp("!") || opTok->isComparisonOp()))
+                        continue;
+                    if (opTok && (opTok->isAssignmentOp() || opTok->isCalculation())) {
+                        if (opTok->isCalculation()) {
+                            if (opTok->astOperand1() != tok)
+                                opTok = opTok->astOperand1();
+                            else
+                                opTok = opTok->astOperand2();
+                        }
+                        if (opTok && opTok->valueType() && var->valueType() && opTok->valueType()->isConst(var->valueType()->pointer))
+                            continue;
+                    } else if (const Token* ftok = getTokenArgumentFunction(tok, argn)) {
+                        bool inconclusive{};
+                        if (var->valueType() && !isVariableChangedByFunctionCall(ftok, var->valueType()->pointer, var->declarationId(), *mSettings, &inconclusive) && !inconclusive)
+                            continue;
+                    }
+                    usedInAssignment = true;
+                    break;
+                }
+                if (astIsRangeBasedForDecl(tok) && Token::Match(tok->astParent()->astOperand2(), "%varid%", var->declarationId())) {
+                    const Variable* refvar = tok->astParent()->astOperand1()->variable();
+                    if (refvar && refvar->isReference() && !refvar->isConst()) {
+                        usedInAssignment = true;
+                        break;
+                    }
+                }
+            }
+            if (usedInAssignment)
+                continue;
+        }
+
+        constVariableError(var, hasFunction ? function : nullptr);
     }
 }
 
-void CheckOther::constVariableError(const Variable *var)
+static const Token* getVariableChangedStart(const Variable* p)
+{
+    if (p->isArgument())
+        return p->scope()->bodyStart;
+    const Token* start = p->nameToken()->next();
+    if (start->isSplittedVarDeclEq())
+        start = start->tokAt(3);
+    return start;
+}
+
+static bool isConstPointerVariable(const Variable* p, const Settings& settings)
 {
-    const Token *tok = nullptr;
-    std::string name = "x";
-    std::string id = "Variable";
-    if (var) {
-        tok = var->nameToken();
-        name = var->name();
-        if (var->isArgument())
-            id = "Parameter";
+    const int indirect = p->isArray() ? p->dimensions().size() : 1;
+    const Token* start = getVariableChangedStart(p);
+    while (const Token* tok =
+               findVariableChanged(start, p->scope()->bodyEnd, indirect, p->declarationId(), false, settings)) {
+        if (p->isReference())
+            return false;
+        // Assigning a pointer through another pointer may still be const
+        if (!Token::simpleMatch(tok->astParent(), "="))
+            return false;
+        if (!astIsLHS(tok))
+            return false;
+        start = tok->next();
     }
-    reportError(tok, Severity::style, "const" + id, id + " '" + name + "' can be declared with const", CWE398, false);
+    return true;
+}
+
+namespace {
+    struct CompareVariables {
+        bool operator()(const Variable* a, const Variable* b) const {
+            const int fileA = a->nameToken()->fileIndex();
+            const int fileB = b->nameToken()->fileIndex();
+            if (fileA != fileB)
+                return fileA < fileB;
+            const int lineA = a->nameToken()->linenr();
+            const int lineB = b->nameToken()->linenr();
+            if (lineA != lineB)
+                return lineA < lineB;
+            const int columnA = a->nameToken()->column();
+            const int columnB = b->nameToken()->column();
+            return columnA < columnB;
+        }
+    };
+}
+
+static bool isCastToInteger(const Token* tok)
+{
+    return tok && tok->isCast() && tok->valueType() && tok->valueType()->isIntegral() && tok->valueType()->pointer == 0;
+}
+
+static const Function* getEnclosingFunction(const Variable* var)
+{
+    if (var->isArgument())
+        return var->scope()->function;
+    const Scope* scope = var->scope();
+    while (scope && scope->type != ScopeType::eFunction) {
+        scope = scope->nestedIn;
+    }
+    return scope ? scope->function : nullptr;
+}
+
+void CheckOther::checkConstPointer()
+{
+    if (!mSettings->severity.isEnabled(Severity::style) &&
+        !mSettings->isPremiumEnabled("constParameter") &&
+        !mSettings->isPremiumEnabled("constParameterPointer") &&
+        !mSettings->isPremiumEnabled("constParameterReference") &&
+        !mSettings->isPremiumEnabled("constVariablePointer"))
+        return;
+
+    logChecker("CheckOther::checkConstPointer"); // style
+
+    std::set<const Variable*, CompareVariables> pointers, nonConstPointers;
+    for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
+        const Variable* const var = tok->variable();
+        if (!var)
+            continue;
+        if (!var->isLocal() && !var->isArgument())
+            continue;
+        if (var->isArgument() && var->scope() && var->scope()->type == ScopeType::eLambda && !Token::simpleMatch(var->scope()->bodyEnd, "} ("))
+            continue;
+        const Token* const nameTok = var->nameToken();
+        if (tok == nameTok && var->isLocal() && !astIsRangeBasedForDecl(nameTok)) {
+            if (var->isReference() && var->isPointer()) {
+                nonConstPointers.emplace(var);
+                continue;
+            }
+            // declarations of (static) pointers are (not) split up, array declarations are never split up
+            if ((!var->isStatic() || Token::simpleMatch(nameTok->next(), "[")))
+                continue;
+        }
+        // Skip function pointers
+        if (Token::Match(nameTok, "%name% ) ("))
+            continue;
+        const ValueType* const vt = tok->valueType();
+        if (!vt)
+            continue;
+        if ((vt->pointer != 1 && !(vt->pointer == 2 && var->isArray())) || (vt->constness & 1))
+            continue;
+        if (var->typeStartToken()->isTemplateArg())
+            continue;
+        if (std::find(nonConstPointers.cbegin(), nonConstPointers.cend(), var) != nonConstPointers.cend())
+            continue;
+        pointers.emplace(var);
+        const Token* parent = tok->astParent();
+        enum Deref : std::uint8_t { NONE, DEREF, MEMBER } deref = NONE;
+        bool hasIncDecPlus = false;
+        if (parent && (parent->isUnaryOp("*") || (((hasIncDecPlus = parent->isIncDecOp()) || (hasIncDecPlus = (parent->str() == "+"))) &&
+                                                  parent->astParent() && parent->astParent()->isUnaryOp("*"))))
+            deref = DEREF;
+        else if (Token::simpleMatch(parent, "[") && parent->astOperand1() == tok && tok != nameTok)
+            deref = DEREF;
+        else if (Token::Match(parent, "%op%") && Token::simpleMatch(parent->astParent(), "."))
+            deref = MEMBER;
+        else if (Token::simpleMatch(parent, "."))
+            deref = MEMBER;
+        else if (astIsRangeBasedForDecl(tok))
+            continue;
+        else if (isCastToInteger(parent))
+            continue;
+        if (deref != NONE) {
+            const Token* gparent = parent->astParent();
+            while (Token::simpleMatch(gparent, "[") && parent != gparent->astOperand2() && parent->str() == gparent->str())
+                gparent = gparent->astParent();
+            if (deref == MEMBER) {
+                if (!gparent)
+                    continue;
+                if (parent->astOperand2()) {
+                    if (parent->astOperand2()->function() && parent->astOperand2()->function()->isConst())
+                        continue;
+                    if (mSettings->library.isFunctionConst(parent->astOperand2()))
+                        continue;
+                }
+            }
+            if (hasIncDecPlus) {
+                parent = gparent;
+                gparent = gparent ? gparent->astParent() : nullptr;
+            }
+            if (Token::Match(gparent, "%cop%") && !gparent->isUnaryOp("&") && !gparent->isUnaryOp("*"))
+                continue;
+            int argn = -1;
+            if (Token::simpleMatch(gparent, "return")) {
+                const Function* function = getEnclosingFunction(var);
+                if (function && (!Function::returnsReference(function) || Function::returnsConst(function)))
+                    continue;
+            }
+            else if (Token::Match(gparent, "%assign%") && parent == gparent->astOperand2()) {
+                bool takingRef = false, nonConstPtrAssignment = false;
+                const Token *lhs = gparent->astOperand1();
+                if (lhs && lhs->variable() && lhs->variable()->isReference() && lhs->variable()->nameToken() == lhs && !lhs->variable()->isConst())
+                    takingRef = true;
+                if (lhs && lhs->valueType() && lhs->valueType()->pointer && (lhs->valueType()->constness & 1) == 0 &&
+                    parent->valueType() && parent->valueType()->pointer && lhs->variable() != var)
+                    nonConstPtrAssignment = true;
+                if (!takingRef && !nonConstPtrAssignment)
+                    continue;
+            } else if (Token::simpleMatch(gparent, "[") && gparent->astOperand2() == parent)
+                continue;
+            else if (gparent && gparent->isCast() && gparent->valueType() &&
+                     ((gparent->valueType()->pointer == 0 && gparent->valueType()->reference == Reference::None) ||
+                      (var->valueType() && gparent->valueType()->isConst(var->valueType()->pointer))))
+                continue;
+            else if (const Token* ftok = getTokenArgumentFunction(parent, argn)) {
+                bool inconclusive{};
+                if (!isVariableChangedByFunctionCall(ftok->next(), vt->pointer, var->declarationId(), *mSettings, &inconclusive) && !inconclusive)
+                    continue;
+            }
+        } else {
+            int argn = -1;
+            if (Token::Match(parent, "%oror%|%comp%|&&|?|!|-|<<|;"))
+                continue;
+            if (hasIncDecPlus && (!parent->astParent() || parent->astParent()->str() == ";"))
+                continue;
+            if (Token::simpleMatch(parent, "(") && Token::Match(parent->astOperand1(), "if|while"))
+                continue;
+            if (Token::simpleMatch(parent, "=")) {
+                const Token* lhs = parent->astOperand1();
+                if (lhs == tok)
+                    continue;
+                if (lhs && lhs->valueType() && lhs->valueType()->isConst(vt->pointer))
+                    continue;
+            }
+            if (const Token* ftok = getTokenArgumentFunction(tok, argn)) {
+                if (ftok->function()) {
+                    const bool isCastArg = parent->isCast() && !ftok->function()->getOverloadedFunctions().empty(); // assume that cast changes the called function
+                    if (!isCastArg) {
+                        const Variable* argVar = ftok->function()->getArgumentVar(argn);
+                        if (argVar && argVar->valueType() && argVar->valueType()->isConst(vt->pointer)) {
+                            bool inconclusive{};
+                            if (!isVariableChangedByFunctionCall(ftok, vt->pointer, var->declarationId(), *mSettings, &inconclusive) && !inconclusive)
+                                continue;
+                        }
+                    }
+                } else {
+                    const auto dir = mSettings->library.getArgDirection(ftok, argn + 1);
+                    if (dir == Library::ArgumentChecks::Direction::DIR_IN)
+                        continue;
+                }
+            }
+            else if (Token::simpleMatch(parent, "(")) {
+                if (parent->isCast() && parent->valueType() && var->valueType() && parent->valueType()->isConst(var->valueType()->pointer))
+                    continue;
+            }
+        }
+        if (tok != nameTok)
+            nonConstPointers.emplace(var);
+    }
+    for (const Variable *p: pointers) {
+        if (p->isArgument()) {
+            if (!p->scope() || !p->scope()->function || p->scope()->function->isImplicitlyVirtual(true) || p->scope()->function->hasVirtualSpecifier())
+                continue;
+            if (p->isMaybeUnused())
+                continue;
+        }
+        if (const Function* func = Scope::nestedInFunction(p->scope()))
+            if (func->templateDef)
+                continue;
+        if (std::find(nonConstPointers.cbegin(), nonConstPointers.cend(), p) == nonConstPointers.cend()) {
+            // const Token *start = getVariableChangedStart(p);
+            // const int indirect = p->isArray() ? p->dimensions().size() : 1;
+            // if (isVariableChanged(start, p->scope()->bodyEnd, indirect, p->declarationId(), false, *mSettings))
+            //     continue;
+            if (!isConstPointerVariable(p, *mSettings))
+                continue;
+            if (p->typeStartToken() && p->typeStartToken()->isSimplifiedTypedef() && !(Token::simpleMatch(p->typeEndToken(), "*") && !p->typeEndToken()->isSimplifiedTypedef()))
+                continue;
+            constVariableError(p, p->isArgument() ? p->scope()->function : nullptr);
+        }
+    }
+}
+
+void CheckOther::constVariableError(const Variable *var, const Function *function)
+{
+    if (!var) {
+        reportError(nullptr, Severity::style, "constParameter", "Parameter 'x' can be declared with const");
+        reportError(nullptr, Severity::style, "constVariable",  "Variable 'x' can be declared with const");
+        reportError(nullptr, Severity::style, "constParameterReference", "Parameter 'x' can be declared with const");
+        reportError(nullptr, Severity::style, "constVariableReference", "Variable 'x' can be declared with const");
+        reportError(nullptr, Severity::style, "constParameterPointer", "Parameter 'x' can be declared with const");
+        reportError(nullptr, Severity::style, "constVariablePointer", "Variable 'x' can be declared with const");
+        reportError(nullptr, Severity::style, "constParameterCallback", "Parameter 'x' can be declared with const, however it seems that 'f' is a callback function.");
+        return;
+    }
+
+    const std::string vartype(var->isArgument() ? "Parameter" : "Variable");
+    const std::string& varname(var->name());
+    const std::string ptrRefArray = var->isArray() ? "const array" : (var->isPointer() ? "pointer to const" : "reference to const");
+
+    ErrorPath errorPath;
+    std::string id = "const" + vartype;
+    std::string message = "$symbol:" + varname + "\n" + vartype + " '$symbol' can be declared as " + ptrRefArray;
+    errorPath.emplace_back(var->nameToken(), message);
+    if (var->isArgument() && function && function->functionPointerUsage) {
+        errorPath.emplace_front(function->functionPointerUsage, "You might need to cast the function pointer here");
+        id += "Callback";
+        message += ". However it seems that '" + function->name() + "' is a callback function, if '$symbol' is declared with const you might also need to cast function pointer(s).";
+    } else if (var->isReference()) {
+        id += "Reference";
+    } else if (var->isPointer() && !var->isArray()) {
+        id += "Pointer";
+    }
+
+    reportError(std::move(errorPath), Severity::style, id.c_str(), message, CWE398, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -1386,11 +2071,13 @@ void CheckOther::constVariableError(const Variable *var)
 
 void CheckOther::checkCharVariable()
 {
-    const bool warning = mSettings->isEnabled(Settings::WARNING);
-    const bool portability = mSettings->isEnabled(Settings::PORTABILITY);
+    const bool warning = mSettings->severity.isEnabled(Severity::warning);
+    const bool portability = mSettings->severity.isEnabled(Severity::portability);
     if (!warning && !portability)
         return;
 
+    logChecker("CheckOther::checkCharVariable"); // warning,portability
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
@@ -1400,24 +2087,24 @@ void CheckOther::checkCharVariable()
                 if (!tok->variable()->isArray() && !tok->variable()->isPointer())
                     continue;
                 const Token *index = tok->next()->astOperand2();
-                if (warning && tok->variable()->isArray() && astIsSignedChar(index) && index->getValueGE(0x80, mSettings))
+                if (warning && tok->variable()->isArray() && astIsSignedChar(index) && index->getValueGE(0x80, *mSettings))
                     signedCharArrayIndexError(tok);
-                if (portability && astIsUnknownSignChar(index) && index->getValueGE(0x80, mSettings))
+                if (portability && astIsUnknownSignChar(index) && index->getValueGE(0x80, *mSettings))
                     unknownSignCharArrayIndexError(tok);
             } else if (warning && Token::Match(tok, "[&|^]") && tok->isBinaryOp()) {
                 bool warn = false;
                 if (astIsSignedChar(tok->astOperand1())) {
-                    const ValueFlow::Value *v1 = tok->astOperand1()->getValueLE(-1, mSettings);
+                    const ValueFlow::Value *v1 = tok->astOperand1()->getValueLE(-1, *mSettings);
                     const ValueFlow::Value *v2 = tok->astOperand2()->getMaxValue(false);
                     if (!v1)
-                        v1 = tok->astOperand1()->getValueGE(0x80, mSettings);
+                        v1 = tok->astOperand1()->getValueGE(0x80, *mSettings);
                     if (v1 && !(tok->str() == "&" && v2 && v2->isKnown() && v2->intvalue >= 0 && v2->intvalue < 0x100))
                         warn = true;
                 } else if (astIsSignedChar(tok->astOperand2())) {
-                    const ValueFlow::Value *v1 = tok->astOperand2()->getValueLE(-1, mSettings);
+                    const ValueFlow::Value *v1 = tok->astOperand2()->getValueLE(-1, *mSettings);
                     const ValueFlow::Value *v2 = tok->astOperand1()->getMaxValue(false);
                     if (!v1)
-                        v1 = tok->astOperand2()->getValueGE(0x80, mSettings);
+                        v1 = tok->astOperand2()->getValueGE(0x80, *mSettings);
                     if (v1 && !(tok->str() == "&" && v2 && v2->isKnown() && v2->intvalue >= 0 && v2->intvalue < 0x100))
                         warn = true;
                 }
@@ -1441,7 +2128,7 @@ void CheckOther::signedCharArrayIndexError(const Token *tok)
                 "Signed 'char' type used as array index.\n"
                 "Signed 'char' type used as array index. If the value "
                 "can be greater than 127 there will be a buffer underflow "
-                "because of sign extension.", CWE128, false);
+                "because of sign extension.", CWE128, Certainty::normal);
 }
 
 void CheckOther::unknownSignCharArrayIndexError(const Token *tok)
@@ -1451,7 +2138,7 @@ void CheckOther::unknownSignCharArrayIndexError(const Token *tok)
                 "unknownSignCharArrayIndex",
                 "'char' type used as array index.\n"
                 "'char' type used as array index. Values greater than 127 will be "
-                "treated depending on whether 'char' is signed or unsigned on target platform.", CWE758, false);
+                "treated depending on whether 'char' is signed or unsigned on target platform.", CWE758, Certainty::normal);
 }
 
 void CheckOther::charBitOpError(const Token *tok)
@@ -1465,7 +2152,7 @@ void CheckOther::charBitOpError(const Token *tok)
                 "    int i = 0 | c;\n"
                 "    if (i & 0x8000)\n"
                 "        printf(\"not expected\");\n"
-                "The \"not expected\" will be printed on the screen.", CWE398, false);
+                "The \"not expected\" will be printed on the screen.", CWE398, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -1474,8 +2161,10 @@ void CheckOther::charBitOpError(const Token *tok)
 
 static bool isType(const Token * tok, bool unknown)
 {
-    if (Token::Match(tok, "%type%"))
+    if (tok && (tok->isStandardType() || (!tok->isKeyword() && Token::Match(tok, "%type%")) || tok->str() == "auto"))
         return true;
+    if (tok && tok->varId())
+        return false;
     if (Token::simpleMatch(tok, "::"))
         return isType(tok->astOperand2(), unknown);
     if (Token::simpleMatch(tok, "<") && tok->link())
@@ -1493,34 +2182,109 @@ static bool isVarDeclOp(const Token* tok)
     if (vartok && vartok->variable() && vartok->variable()->nameToken() == vartok)
         return true;
     const Token * typetok = tok->astOperand1();
-    return isType(typetok, Token::Match(vartok, "%var%"));
+    return isType(typetok, vartok && vartok->varId() != 0);
+}
+
+static bool isBracketAccess(const Token* tok)
+{
+    if (!Token::simpleMatch(tok, "[") || !tok->astOperand1())
+        return false;
+    tok = tok->astOperand1();
+    if (tok->str() == ".")
+        tok = tok->astOperand2();
+    while (Token::simpleMatch(tok, "["))
+        tok = tok->astOperand1();
+    if (!tok || !tok->variable())
+        return false;
+    return tok->variable()->nameToken() != tok;
+}
+
+static bool isConstant(const Token* tok) {
+    return tok && (tok->isEnumerator() || Token::Match(tok, "%bool%|%num%|%str%|%char%|nullptr|NULL"));
 }
 
-static bool isConstStatement(const Token *tok)
+static bool isConstStatement(const Token *tok, const Library& library, bool platformIndependent, bool isNestedBracket = false)
 {
     if (!tok)
         return false;
     if (tok->isExpandedMacro())
         return false;
-    if (Token::Match(tok, "%bool%|%num%|%str%|%char%|nullptr|NULL"))
+    if (tok->varId() != 0)
         return true;
-    if (Token::Match(tok, "%var%"))
+    if (isConstant(tok))
         return true;
     if (Token::Match(tok, "*|&|&&") &&
         (Token::Match(tok->previous(), "::|.|const|volatile|restrict") || isVarDeclOp(tok)))
         return false;
     if (Token::Match(tok, "<<|>>") && !astIsIntegral(tok, false))
         return false;
+    const Token* tok2 = tok;
+    while (tok2) {
+        if (Token::simpleMatch(tok2->astOperand1(), "delete"))
+            return false;
+        tok2 = tok2->astParent();
+    }
+    if (Token::Match(tok, "&&|%oror%"))
+        return isConstStatement(tok->astOperand1(), library, platformIndependent) && isConstStatement(tok->astOperand2(), library, platformIndependent);
     if (Token::Match(tok, "!|~|%cop%") && (tok->astOperand1() || tok->astOperand2()))
         return true;
     if (Token::simpleMatch(tok->previous(), "sizeof ("))
+        return !platformIndependent;
+    if (Token::Match(tok->previous(), "alignof|noexcept|typeid (") && tok->previous()->isKeyword())
         return true;
-    if (isCPPCast(tok))
-        return isConstStatement(tok->astOperand2());
-    if (Token::Match(tok, "( %type%"))
-        return isConstStatement(tok->astOperand1());
-    if (Token::simpleMatch(tok, ","))
-        return isConstStatement(tok->astOperand2());
+    if (isCPPCast(tok)) {
+        if (Token::simpleMatch(tok->astOperand1(), "dynamic_cast") && Token::simpleMatch(tok->astOperand1()->linkAt(1)->previous(), "& >"))
+            return false;
+        return isWithoutSideEffects(tok) && isConstStatement(tok->astOperand2(), library, platformIndependent);
+    }
+    if (tok->isCast() && tok->next() && tok->next()->isStandardType())
+        return isWithoutSideEffects(tok->astOperand1()) && isConstStatement(tok->astOperand1(), library, platformIndependent);
+    if (Token::simpleMatch(tok, "."))
+        return isConstStatement(tok->astOperand2(), library, platformIndependent);
+    if (Token::simpleMatch(tok, ",")) {
+        if (tok->astParent()) // warn about const statement on rhs at the top level
+            return isConstStatement(tok->astOperand1(), library, platformIndependent) &&
+                   isConstStatement(tok->astOperand2(), library, platformIndependent);
+
+        const Token* lml = previousBeforeAstLeftmostLeaf(tok); // don't warn about matrix/vector assignment (e.g. Eigen)
+        if (lml)
+            lml = lml->next();
+        const Token* stream = lml;
+        while (stream && Token::Match(stream->astParent(), ".|[|(|*"))
+            stream = stream->astParent();
+        return (!stream || !isLikelyStream(stream)) && isConstStatement(tok->astOperand2(), library, platformIndependent);
+    }
+    if (Token::simpleMatch(tok, "?") && Token::simpleMatch(tok->astOperand2(), ":")) // ternary operator
+        return isConstStatement(tok->astOperand1(), library, platformIndependent) &&
+               isConstStatement(tok->astOperand2()->astOperand1(), library, platformIndependent) &&
+               isConstStatement(tok->astOperand2()->astOperand2(), library, platformIndependent);
+    if (isBracketAccess(tok) && isWithoutSideEffects(tok->astOperand1(), /*checkArrayAccess*/ true, /*checkReference*/ false)) {
+        const bool isChained = succeeds(tok->astParent(), tok);
+        if (Token::simpleMatch(tok->astParent(), "[")) {
+            if (isChained)
+                return isConstStatement(tok->astOperand2(), library, platformIndependent) &&
+                       isConstStatement(tok->astParent(), library, platformIndependent);
+            return isNestedBracket && isConstStatement(tok->astOperand2(), library, platformIndependent);
+        }
+        return isConstStatement(tok->astOperand2(), library, platformIndependent, /*isNestedBracket*/ !isChained);
+    }
+    if (!tok->astParent() && findLambdaEndToken(tok))
+        return true;
+
+    tok2 = tok;
+    if (tok2->str() == "::")
+        tok2 = tok2->next();
+    if (Token::Match(tok2, "%name% ;")) {
+        if (tok2->function())
+            return true;
+        std::string funcStr = tok2->str();
+        while (tok2->index() > 1 && Token::Match(tok2->tokAt(-2), "%name% ::")) {
+            funcStr.insert(0, tok2->strAt(-2) + "::");
+            tok2 = tok2->tokAt(-2);
+        }
+        if (library.functions().count(funcStr) > 0)
+            return true;
+    }
     return false;
 }
 
@@ -1528,10 +2292,12 @@ static bool isVoidStmt(const Token *tok)
 {
     if (Token::simpleMatch(tok, "( void"))
         return true;
+    if (isCPPCast(tok) && tok->astOperand1() && Token::Match(tok->astOperand1()->next(), "< void *| >"))
+        return true;
     const Token *tok2 = tok;
     while (tok2->astOperand1())
         tok2 = tok2->astOperand1();
-    if (Token::simpleMatch(tok2->previous(), ")") && Token::simpleMatch(tok2->previous()->link(), "( void"))
+    if (Token::simpleMatch(tok2->previous(), ")") && Token::simpleMatch(tok2->linkAt(-1), "( void"))
         return true;
     if (Token::simpleMatch(tok2, "( void"))
         return true;
@@ -1542,61 +2308,138 @@ static bool isConstTop(const Token *tok)
 {
     if (!tok)
         return false;
-    if (tok == tok->astTop())
+    if (!tok->astParent())
         return true;
-    if (Token::simpleMatch(tok->astParent(), ";") && tok->astTop() &&
+    if (Token::simpleMatch(tok->astParent(), ";") &&
         Token::Match(tok->astTop()->previous(), "for|if (") && Token::simpleMatch(tok->astTop()->astOperand2(), ";")) {
         if (Token::simpleMatch(tok->astParent()->astParent(), ";"))
             return tok->astParent()->astOperand2() == tok;
-        else
-            return tok->astParent()->astOperand1() == tok;
+        return tok->astParent()->astOperand1() == tok;
     }
+    if (Token::simpleMatch(tok, "[")) {
+        const Token* bracTok = tok;
+        while (Token::simpleMatch(bracTok->astParent(), "["))
+            bracTok = bracTok->astParent();
+        if (!bracTok->astParent())
+            return true;
+    }
+    if (tok->str() == "," && tok->astParent()->isAssignmentOp())
+        return true;
     return false;
 }
 
 void CheckOther::checkIncompleteStatement()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning) &&
+        !mSettings->isPremiumEnabled("constStatement"))
         return;
 
+    logChecker("CheckOther::checkIncompleteStatement"); // warning
+
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
         const Scope *scope = tok->scope();
         if (scope && !scope->isExecutable())
             continue;
         if (!isConstTop(tok))
             continue;
+        if (tok->str() == "," && Token::simpleMatch(tok->astTop()->previous(), "for ("))
+            continue;
+
+        // Do not warn for statement when both lhs and rhs has side effects:
+        //   dostuff() || x=213;
+        if (Token::Match(tok, "%oror%|&&")) {
+            bool warn = false;
+            visitAstNodes(tok, [&warn](const Token *child) {
+                if (Token::Match(child, "%oror%|&&"))
+                    return ChildrenToVisit::op1_and_op2;
+                if (child->isAssignmentOp())
+                    return ChildrenToVisit::none;
+                if (child->tokType() == Token::Type::eIncDecOp)
+                    return ChildrenToVisit::none;
+                if (Token::Match(child->previous(), "%name% ("))
+                    return ChildrenToVisit::none;
+                warn = true;
+                return ChildrenToVisit::done;
+            });
+            if (!warn)
+                continue;
+        }
+
         const Token *rtok = nextAfterAstRightmostLeaf(tok);
         if (!Token::simpleMatch(tok->astParent(), ";") && !Token::simpleMatch(rtok, ";") &&
-            !Token::Match(tok->previous(), ";|}|{ %any% ;"))
+            !Token::Match(tok->previous(), ";|}|{ %any% ;") &&
+            !(tok->isCpp() && tok->isCast() && !tok->astParent()) &&
+            !(!tok->astParent() && tok->astOperand1() && Token::Match(tok->previous(), "%name% (") && tok->previous()->isKeyword()) &&
+            !Token::simpleMatch(tok->tokAt(-2), "for (") &&
+            !Token::Match(tok->tokAt(-1), "%var% [") &&
+            !(tok->str() == "," && tok->astParent() && tok->astParent()->isAssignmentOp()))
             continue;
-        // Skipe statement expressions
+        // Skip statement expressions
         if (Token::simpleMatch(rtok, "; } )"))
             continue;
-        if (!isConstStatement(tok))
+        if (!isConstStatement(tok, mSettings->library, false))
             continue;
         if (isVoidStmt(tok))
             continue;
-        if (mTokenizer->isCPP() && tok->str() == "&" && !(tok->astOperand1()->valueType() && tok->astOperand1()->valueType()->isIntegral()))
+        if (tok->isCpp() && tok->str() == "&" && !(tok->astOperand1() && tok->astOperand1()->valueType() && tok->astOperand1()->valueType()->isIntegral()))
             // Possible archive
             continue;
-        bool inconclusive = Token::Match(tok, "%cop%");
-        if (mSettings->inconclusive || !inconclusive)
+        const bool inconclusive = tok->isConstOp() && !mSettings->isPremiumEnabled("constStatement");
+        if (mSettings->certainty.isEnabled(Certainty::inconclusive) || !inconclusive)
             constStatementError(tok, tok->isNumber() ? "numeric" : "string", inconclusive);
     }
 }
 
 void CheckOther::constStatementError(const Token *tok, const std::string &type, bool inconclusive)
 {
+    const Token *valueTok = tok;
+    while (valueTok && valueTok->isCast())
+        valueTok = valueTok->astOperand2() ? valueTok->astOperand2() : valueTok->astOperand1();
+
     std::string msg;
     if (Token::simpleMatch(tok, "=="))
         msg = "Found suspicious equality comparison. Did you intend to assign a value instead?";
     else if (Token::Match(tok, ",|!|~|%cop%"))
-        msg = "Found suspicious operator '" + tok->str() + "'";
+        msg = "Found suspicious operator '" + tok->str() + "', result is not used.";
     else if (Token::Match(tok, "%var%"))
         msg = "Unused variable value '" + tok->str() + "'";
-    else
+    else if (isConstant(valueTok)) {
+        std::string typeStr("string");
+        if (valueTok->isNumber())
+            typeStr = "numeric";
+        else if (valueTok->isBoolean())
+            typeStr = "bool";
+        else if (valueTok->tokType() == Token::eChar)
+            typeStr = "character";
+        else if (isNullOperand(valueTok))
+            typeStr = "NULL";
+        else if (valueTok->isEnumerator())
+            typeStr = "enumerator";
+        msg = "Redundant code: Found a statement that begins with " + typeStr + " constant.";
+    }
+    else if (!tok)
         msg = "Redundant code: Found a statement that begins with " + type + " constant.";
-    reportError(tok, Severity::warning, "constStatement", msg, CWE398, inconclusive);
+    else if (tok->isCast() && tok->tokType() == Token::Type::eExtendedOp) {
+        msg = "Redundant code: Found unused cast ";
+        msg += valueTok ? "of expression '" + valueTok->expressionString() + "'." : "expression.";
+    }
+    else if (tok->str() == "?" && tok->tokType() == Token::Type::eExtendedOp)
+        msg = "Redundant code: Found unused result of ternary operator.";
+    else if (tok->str() == "." && tok->tokType() == Token::Type::eOther)
+        msg = "Redundant code: Found unused member access.";
+    else if (tok->str() == "[" && tok->tokType() == Token::Type::eExtendedOp)
+        msg = "Redundant code: Found unused array access.";
+    else if (tok->str() == "[" && !tok->astParent())
+        msg = "Redundant code: Found unused lambda.";
+    else if (Token::Match(tok, "%name%|::"))
+        msg = "Redundant code: Found unused function.";
+    else if (Token::Match(tok->previous(), "%name% ("))
+        msg = "Redundant code: Found unused '" + tok->strAt(-1) + "' expression.";
+    else if (mSettings->debugwarnings) {
+        reportError(tok, Severity::debug, "debug", "constStatementError not handled.");
+        return;
+    }
+    reportError(tok, Severity::warning, "constStatement", msg, CWE398, inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -1604,6 +2447,8 @@ void CheckOther::constStatementError(const Token *tok, const std::string &type,
 //---------------------------------------------------------------------------
 void CheckOther::checkZeroDivision()
 {
+    logChecker("CheckOther::checkZeroDivision");
+
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
         if (!tok->astOperand2() || !tok->astOperand1())
             continue;
@@ -1611,6 +2456,8 @@ void CheckOther::checkZeroDivision()
             continue;
         if (!tok->valueType() || !tok->valueType()->isIntegral())
             continue;
+        if (tok->scope() && tok->scope()->type == ScopeType::eEnum) // don't warn for compile-time error
+            continue;
 
         // Value flow..
         const ValueFlow::Value *value = tok->astOperand2()->getValue(0LL);
@@ -1622,12 +2469,12 @@ void CheckOther::checkZeroDivision()
 void CheckOther::zerodivError(const Token *tok, const ValueFlow::Value *value)
 {
     if (!tok && !value) {
-        reportError(tok, Severity::error, "zerodiv", "Division by zero.", CWE369, false);
-        reportError(tok, Severity::error, "zerodivcond", ValueFlow::eitherTheConditionIsRedundant(nullptr) + " or there is division by zero.", CWE369, false);
+        reportError(tok, Severity::error, "zerodiv", "Division by zero.", CWE369, Certainty::normal);
+        reportError(tok, Severity::warning, "zerodivcond", ValueFlow::eitherTheConditionIsRedundant(nullptr) + " or there is division by zero.", CWE369, Certainty::normal);
         return;
     }
 
-    const ErrorPath errorPath = getErrorPath(tok, value, "Division by zero");
+    ErrorPath errorPath = getErrorPath(tok, value, "Division by zero");
 
     std::ostringstream errmsg;
     if (value->condition) {
@@ -1637,10 +2484,10 @@ void CheckOther::zerodivError(const Token *tok, const ValueFlow::Value *value)
     } else
         errmsg << "Division by zero.";
 
-    reportError(errorPath,
+    reportError(std::move(errorPath),
                 value->errorSeverity() ? Severity::error : Severity::warning,
                 value->condition ? "zerodivcond" : "zerodiv",
-                errmsg.str(), CWE369, value->isInconclusive());
+                errmsg.str(), CWE369, value->isInconclusive() ? Certainty::inconclusive : Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -1650,8 +2497,9 @@ void CheckOther::zerodivError(const Token *tok, const ValueFlow::Value *value)
 
 void CheckOther::checkNanInArithmeticExpression()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("nanInArithmeticExpression"))
         return;
+    logChecker("CheckOther::checkNanInArithmeticExpression"); // style
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
         if (tok->str() != "/")
             continue;
@@ -1667,7 +2515,7 @@ void CheckOther::nanInArithmeticExpressionError(const Token *tok)
     reportError(tok, Severity::style, "nanInArithmeticExpression",
                 "Using NaN/Inf in a computation.\n"
                 "Using NaN/Inf in a computation. "
-                "Although nothing bad really happens, it is suspicious.", CWE369, false);
+                "Although nothing bad really happens, it is suspicious.", CWE369, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -1679,31 +2527,83 @@ void CheckOther::checkMisusedScopedObject()
     if (mTokenizer->isC())
         return;
 
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("unusedScopedObject"))
         return;
 
-    const SymbolDatabase * const symbolDatabase = mTokenizer->getSymbolDatabase();
+    logChecker("CheckOther::checkMisusedScopedObject"); // style,c++
+
+    auto getConstructorTok = [](const Token* tok, std::string& typeStr) -> const Token* {
+        if (!Token::Match(tok, "[;{}] %name%") || tok->next()->isKeyword())
+            return nullptr;
+        tok = tok->next();
+        typeStr.clear();
+        while (Token::Match(tok, "%name% ::")) {
+            typeStr += tok->str();
+            typeStr += "::";
+            tok = tok->tokAt(2);
+        }
+        typeStr += tok->str();
+        const Token* endTok = tok;
+        if (Token::Match(endTok, "%name% <"))
+            endTok = endTok->linkAt(1);
+        if (Token::Match(endTok, "%name%|> (|{") && Token::Match(endTok->linkAt(1), ")|} ;") &&
+            !Token::simpleMatch(endTok->next()->astParent(), ";")) { // for loop condition
+            return tok;
+        }
+        return nullptr;
+    };
+
+    auto isLibraryConstructor = [&](const Token* tok, const std::string& typeStr) -> bool {
+        const Library::TypeCheck typeCheck = mSettings->library.getTypeCheck("unusedvar", typeStr);
+        if (typeCheck == Library::TypeCheck::check || typeCheck == Library::TypeCheck::checkFiniteLifetime)
+            return true;
+        return mSettings->library.detectContainerOrIterator(tok);
+    };
+
+    const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
+    std::string typeStr;
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token *tok = scope->bodyStart; tok && tok != scope->bodyEnd; tok = tok->next()) {
-            if ((tok->next()->type() || (tok->next()->function() && tok->next()->function()->isConstructor())) // TODO: The rhs of || should be removed; It is a workaround for a symboldatabase bug
-                && Token::Match(tok, "[;{}] %name% (")
-                && Token::Match(tok->linkAt(2), ") ; !!}")
-                && (!tok->next()->function() || // is not a function on this scope
-                    tok->next()->function()->isConstructor())) { // or is function in this scope and it's a ctor
+            const Token* ctorTok = getConstructorTok(tok, typeStr);
+            if (ctorTok && (((ctorTok->type() || ctorTok->isStandardType() || (ctorTok->function() && ctorTok->function()->isConstructor())) // TODO: The rhs of || should be removed; It is a workaround for a symboldatabase bug
+                             && (!ctorTok->function() || ctorTok->function()->isConstructor()) // // is not a function on this scope or is function in this scope and it's a ctor
+                             && ctorTok->str() != "void") || isLibraryConstructor(tok->next(), typeStr))) {
+                const Token* parTok = ctorTok->next();
+                if (Token::simpleMatch(parTok, "<") && parTok->link())
+                    parTok = parTok->link()->next();
+                if (const Token* arg = parTok->astOperand2()) {
+                    if (!isConstStatement(arg, mSettings->library, false))
+                        continue;
+                    if (parTok->str() == "(") {
+                        if (arg->varId() && !(arg->variable() && arg->variable()->nameToken() != arg))
+                            continue;
+                        const Token* rml = nextAfterAstRightmostLeaf(arg);
+                        if (rml && rml->previous() && rml->previous()->varId())
+                            continue;
+                    }
+                }
                 tok = tok->next();
-                misusedScopeObjectError(tok, tok->str());
+                misusedScopeObjectError(ctorTok, typeStr);
                 tok = tok->next();
             }
+            if (tok->isAssignmentOp() && Token::simpleMatch(tok->astOperand1(), "(") && tok->astOperand1()->astOperand1()) {
+                if (const Function* ftok = tok->astOperand1()->astOperand1()->function()) {
+                    if (ftok->retType && Token::Match(ftok->retType->classDef, "class|struct|union") && !Function::returnsReference(ftok, /*unknown*/ false, /*includeRValueRef*/ true))
+                        misusedScopeObjectError(tok->next(), ftok->retType->name(), /*isAssignment*/ true);
+                }
+            }
         }
     }
 }
 
-void CheckOther::misusedScopeObjectError(const Token *tok, const std::string& varname)
+void CheckOther::misusedScopeObjectError(const Token *tok, const std::string& varname, bool isAssignment)
 {
+    std::string msg = "Instance of '$symbol' object is destroyed immediately";
+    msg += isAssignment ? ", assignment has no effect." : ".";
     reportError(tok, Severity::style,
                 "unusedScopedObject",
-                "$symbol:" + varname + "\n"
-                "Instance of '$symbol' object is destroyed immediately.", CWE563, false);
+                "$symbol:" + varname + "\n" +
+                msg, CWE563, Certainty::normal);
 }
 
 static const Token * getSingleExpressionInBlock(const Token * tok)
@@ -1711,8 +2611,6 @@ static const Token * getSingleExpressionInBlock(const Token * tok)
     if (!tok)
         return nullptr;
     const Token * top = tok->astTop();
-    if (!top)
-        return nullptr;
     const Token * nextExpression = nextAfterAstRightmostLeaf(top);
     if (!Token::simpleMatch(nextExpression, "; }"))
         return nullptr;
@@ -1733,13 +2631,15 @@ void CheckOther::checkDuplicateBranch()
     //   and their conditional code is a duplicate of the condition that
     //   is always true just in case it would be false. See for instance
     //   abiword.
-    if (!mSettings->isEnabled(Settings::STYLE) || !mSettings->inconclusive)
+    if (!mSettings->severity.isEnabled(Severity::style) || !mSettings->certainty.isEnabled(Certainty::inconclusive))
         return;
 
+    logChecker("CheckOther::checkDuplicateBranch"); // style,inconclusive
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope & scope : symbolDatabase->scopeList) {
-        if (scope.type != Scope::eIf)
+        if (scope.type != ScopeType::eIf)
             continue;
 
         // check all the code in the function for if (..) else
@@ -1756,32 +2656,46 @@ void CheckOther::checkDuplicateBranch()
             if (macro)
                 continue;
 
-            // save if branch code
-            const std::string branch1 = scope.bodyStart->next()->stringifyList(scope.bodyEnd);
+            const Token * const tokIf = scope.bodyStart->next();
+            const Token * const tokElse = scope.bodyEnd->tokAt(3);
 
-            if (branch1.empty())
+            // compare first tok before stringifying the whole blocks
+            const std::string tokIfStr = tokIf->stringify(false, true, false);
+            if (tokIfStr.empty())
                 continue;
 
-            // save else branch code
-            const std::string branch2 = scope.bodyEnd->tokAt(3)->stringifyList(scope.bodyEnd->linkAt(2));
+            const std::string tokElseStr = tokElse->stringify(false, true, false);
 
-            ErrorPath errorPath;
-            // check for duplicates
-            if (branch1 == branch2) {
-                duplicateBranchError(scope.classDef, scope.bodyEnd->next(), errorPath);
-                continue;
+            if (tokIfStr == tokElseStr) {
+                // save if branch code
+                const std::string branch1 = tokIf->stringifyList(scope.bodyEnd);
+
+                if (branch1.empty())
+                    continue;
+
+                // save else branch code
+                const std::string branch2 = tokElse->stringifyList(scope.bodyEnd->linkAt(2));
+
+                // check for duplicates
+                if (branch1 == branch2) {
+                    duplicateBranchError(scope.classDef, scope.bodyEnd->next(), ErrorPath{});
+                    continue;
+                }
             }
 
             // check for duplicates using isSameExpression
-            const Token * branchTop1 = getSingleExpressionInBlock(scope.bodyStart->next());
-            const Token * branchTop2 = getSingleExpressionInBlock(scope.bodyEnd->tokAt(3));
-            if (!branchTop1 || !branchTop2)
+            const Token * branchTop1 = getSingleExpressionInBlock(tokIf);
+            if (!branchTop1)
+                continue;
+            const Token * branchTop2 = getSingleExpressionInBlock(tokElse);
+            if (!branchTop2)
                 continue;
             if (branchTop1->str() != branchTop2->str())
                 continue;
-            if (isSameExpression(mTokenizer->isCPP(), false, branchTop1->astOperand1(), branchTop2->astOperand1(), mSettings->library, true, true, &errorPath) &&
-                isSameExpression(mTokenizer->isCPP(), false, branchTop1->astOperand2(), branchTop2->astOperand2(), mSettings->library, true, true, &errorPath))
-                duplicateBranchError(scope.classDef, scope.bodyEnd->next(), errorPath);
+            ErrorPath errorPath;
+            if (isSameExpression(false, branchTop1->astOperand1(), branchTop2->astOperand1(), *mSettings, true, true, &errorPath) &&
+                isSameExpression(false, branchTop1->astOperand2(), branchTop2->astOperand2(), *mSettings, true, true, &errorPath))
+                duplicateBranchError(scope.classDef, scope.bodyEnd->next(), std::move(errorPath));
         }
     }
 }
@@ -1791,10 +2705,10 @@ void CheckOther::duplicateBranchError(const Token *tok1, const Token *tok2, Erro
     errors.emplace_back(tok2, "");
     errors.emplace_back(tok1, "");
 
-    reportError(errors, Severity::style, "duplicateBranch", "Found duplicate branches for 'if' and 'else'.\n"
+    reportError(std::move(errors), Severity::style, "duplicateBranch", "Found duplicate branches for 'if' and 'else'.\n"
                 "Finding the same code in an 'if' and related 'else' branch is suspicious and "
                 "might indicate a cut and paste or logic error. Please examine this code "
-                "carefully to determine if it is correct.", CWE398, true);
+                "carefully to determine if it is correct.", CWE398, Certainty::inconclusive);
 }
 
 
@@ -1808,15 +2722,18 @@ void CheckOther::checkInvalidFree()
     std::map<int, bool> inconclusive;
     std::map<int, std::string> allocation;
 
-    const bool printInconclusive = mSettings->inconclusive;
+    logChecker("CheckOther::checkInvalidFree");
+
+    const bool printInconclusive = mSettings->certainty.isEnabled(Certainty::inconclusive);
     const SymbolDatabase* symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
-        for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
+        for (const Token* tok = scope->bodyStart->next(); tok && tok != scope->bodyEnd; tok = tok->next()) {
 
             // Keep track of which variables were assigned addresses to newly-allocated memory
-            if (Token::Match(tok, "%var% = malloc|g_malloc|new")) {
-                allocation.insert(std::make_pair(tok->varId(), tok->strAt(2)));
-                inconclusive.insert(std::make_pair(tok->varId(), false));
+            if ((tok->isCpp() && Token::Match(tok, "%var% = new")) ||
+                (Token::Match(tok, "%var% = %name% (") && mSettings->library.getAllocFuncInfo(tok->tokAt(2)))) {
+                allocation.emplace(tok->varId(), tok->strAt(2));
+                inconclusive.emplace(tok->varId(), false);
             }
 
             // If a previously-allocated pointer is incremented or decremented, any subsequent
@@ -1842,7 +2759,7 @@ void CheckOther::checkInvalidFree()
 
             // If a variable that was previously assigned a newly-allocated memory location is
             // added or subtracted from when used to free the memory, report an error.
-            else if (Token::Match(tok, "free|g_free|delete ( %any% +|-") ||
+            else if ((Token::Match(tok, "%name% ( %any% +|-") && mSettings->library.getDeallocFuncInfo(tok)) ||
                      Token::Match(tok, "delete [ ] ( %any% +|-") ||
                      Token::Match(tok, "delete %any% +|- %any%")) {
 
@@ -1850,8 +2767,8 @@ void CheckOther::checkInvalidFree()
                                      tok->strAt(3) == "(" ? 4 : 1;
                 const int var1 = tok->tokAt(varIndex)->varId();
                 const int var2 = tok->tokAt(varIndex + 2)->varId();
-                const std::map<int, bool>::const_iterator alloc1 = inconclusive.find(var1);
-                const std::map<int, bool>::const_iterator alloc2 = inconclusive.find(var2);
+                const auto alloc1 = utils::as_const(inconclusive).find(var1);
+                const auto alloc2 = utils::as_const(inconclusive).find(var2);
                 if (alloc1 != inconclusive.end()) {
                     invalidFreeError(tok, allocation[var1], alloc1->second);
                 } else if (alloc2 != inconclusive.end()) {
@@ -1880,7 +2797,7 @@ void CheckOther::invalidFreeError(const Token *tok, const std::string &allocatio
     if (alloc != "new")
         alloc += "()";
     std::string deallocated = (alloc == "new") ? "deleted" : "freed";
-    reportError(tok, Severity::error, "invalidFree", "Mismatching address is " + deallocated + ". The address you get from " + alloc + " must be " + deallocated + " without offset.", CWE(0U), inconclusive);
+    reportError(tok, Severity::error, "invalidFree", "Mismatching address is " + deallocated + ". The address you get from " + alloc + " must be " + deallocated + " without offset.", CWE(0U), inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
 
@@ -1901,29 +2818,55 @@ namespace {
         for (const Scope &scope : symbolDatabase->scopeList) {
             // only add const functions that do not have a non-const overloaded version
             // since it is pretty much impossible to tell which is being called.
-            typedef std::map<std::string, std::list<const Function*> > StringFunctionMap;
+            using StringFunctionMap = std::map<std::string, std::list<const Function*>>;
             StringFunctionMap functionsByName;
             for (const Function &func : scope.functionList) {
                 functionsByName[func.tokenDef->str()].push_back(&func);
             }
-            for (StringFunctionMap::iterator it = functionsByName.begin();
-                 it != functionsByName.end(); ++it) {
-                const std::list<const Function*>::const_iterator nc = std::find_if(it->second.begin(), it->second.end(), notconst);
-                if (nc == it->second.end()) {
+            for (std::pair<const std::string, std::list<const Function*>>& it : functionsByName) {
+                const auto nc = std::find_if(it.second.cbegin(), it.second.cend(), notconst);
+                if (nc == it.second.cend()) {
                     // ok to add all of them
-                    constFunctions.splice(constFunctions.end(), it->second);
+                    constFunctions.splice(constFunctions.end(), it.second);
                 }
             }
         }
     }
 }
 
+static bool
+isStaticAssert(const Settings &settings, const Token *tok)
+{
+    if (tok->isCpp() && settings.standards.cpp >= Standards::CPP11 &&
+        Token::simpleMatch(tok, "static_assert")) {
+        return true;
+    }
+
+    if (tok->isC() && settings.standards.c >= Standards::C11 &&
+        Token::simpleMatch(tok, "_Static_assert")) {
+        return true;
+    }
+
+    return false;
+}
+
 void CheckOther::checkDuplicateExpression()
 {
-    const bool styleEnabled = mSettings->isEnabled(Settings::STYLE);
-    const bool warningEnabled = mSettings->isEnabled(Settings::WARNING);
-    if (!styleEnabled && !warningEnabled)
-        return;
+    {
+        const bool styleEnabled = mSettings->severity.isEnabled(Severity::style);
+        const bool premiumEnabled = mSettings->isPremiumEnabled("oppositeExpression") ||
+                                    mSettings->isPremiumEnabled("duplicateExpression") ||
+                                    mSettings->isPremiumEnabled("duplicateAssignExpression") ||
+                                    mSettings->isPremiumEnabled("duplicateExpressionTernary") ||
+                                    mSettings->isPremiumEnabled("duplicateValueTernary") ||
+                                    mSettings->isPremiumEnabled("selfAssignment") ||
+                                    mSettings->isPremiumEnabled("knownConditionTrueFalse");
+
+        if (!styleEnabled && !premiumEnabled)
+            return;
+    }
+
+    logChecker("CheckOther::checkDuplicateExpression"); // style,warning
 
     // Parse all executing scopes..
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
@@ -1953,79 +2896,153 @@ void CheckOther::checkDuplicateExpression()
                             tok->astOperand2()->isArithmeticalOp() ||
                             tok->astOperand2()->str() == "." ||
                             Token::Match(tok->astOperand2()->previous(), "%name% (")
-                        ) &&
+                            ) &&
                         tok->next()->tokType() != Token::eType &&
-                        isSameExpression(mTokenizer->isCPP(), true, tok->next(), nextAssign->next(), mSettings->library, true, false) &&
-                        isSameExpression(mTokenizer->isCPP(), true, tok->astOperand2(), nextAssign->astOperand2(), mSettings->library, true, false) &&
+                        isSameExpression(true, tok->next(), nextAssign->next(), *mSettings, true, false) &&
+                        isSameExpression(true, tok->astOperand2(), nextAssign->astOperand2(), *mSettings, true, false) &&
                         tok->astOperand2()->expressionString() == nextAssign->astOperand2()->expressionString()) {
-                        bool assigned = false;
+                        bool differentDomain = false;
                         const Scope * varScope = var1->scope() ? var1->scope() : scope;
-                        for (const Token *assignTok = Token::findsimplematch(var2, ";"); assignTok && assignTok != varScope->bodyEnd; assignTok = assignTok->next()) {
-                            if (Token::Match(assignTok, "%varid% = %var%", var1->varId()) && Token::Match(assignTok, "%var% = %varid%", var2->varId())) {
-                                assigned = true;
-                            }
-                            if (Token::Match(assignTok, "%varid% = %var%", var2->varId()) && Token::Match(assignTok, "%var% = %varid%", var1->varId())) {
-                                assigned = true;
-                            }
+                        const Token* assignTok = Token::findsimplematch(var2, ";");
+                        for (; assignTok && assignTok != varScope->bodyEnd; assignTok = assignTok->next()) {
+                            if (!Token::Match(assignTok, "%assign%|%comp%"))
+                                continue;
+                            if (!assignTok->astOperand1())
+                                continue;
+                            if (!assignTok->astOperand2())
+                                continue;
+
+                            if (assignTok->astOperand1()->varId() != var1->varId() &&
+                                assignTok->astOperand1()->varId() != var2->varId() &&
+                                !isSameExpression(true,
+                                                  tok->astOperand2(),
+                                                  assignTok->astOperand1(),
+                                                  *mSettings,
+                                                  true,
+                                                  true))
+                                continue;
+                            if (assignTok->astOperand2()->varId() != var1->varId() &&
+                                assignTok->astOperand2()->varId() != var2->varId() &&
+                                !isSameExpression(true,
+                                                  tok->astOperand2(),
+                                                  assignTok->astOperand2(),
+                                                  *mSettings,
+                                                  true,
+                                                  true))
+                                continue;
+                            differentDomain = true;
+                            break;
                         }
-                        if (!assigned && !isUniqueExpression(tok->astOperand2()))
+                        if (!differentDomain && !isUniqueExpression(tok->astOperand2()))
                             duplicateAssignExpressionError(var1, var2, false);
-                        else if (mSettings->inconclusive)
+                        else if (mSettings->certainty.isEnabled(Certainty::inconclusive)) {
+                            diag(assignTok);
                             duplicateAssignExpressionError(var1, var2, true);
+                        }
                     }
                 }
             }
+            auto isInsideLambdaCaptureList = [](const Token* tok) {
+                const Token* parent = tok->astParent();
+                while (Token::simpleMatch(parent, ","))
+                    parent = parent->astParent();
+                return isLambdaCaptureList(parent);
+            };
             ErrorPath errorPath;
-            if (tok->isOp() && tok->astOperand1() && !Token::Match(tok, "+|*|<<|>>|+=|*=|<<=|>>=")) {
+            if (tok->isOp() && tok->astOperand1() && !Token::Match(tok, "+|*|<<|>>|+=|*=|<<=|>>=") && !isInsideLambdaCaptureList(tok)) {
                 if (Token::Match(tok, "==|!=|-") && astIsFloat(tok->astOperand1(), true))
                     continue;
-                if (isSameExpression(mTokenizer->isCPP(), true, tok->astOperand1(), tok->astOperand2(), mSettings->library, true, true, &errorPath)) {
-                    if (isWithoutSideEffects(mTokenizer->isCPP(), tok->astOperand1())) {
-                        const bool assignment = tok->str() == "=";
-                        if (assignment && warningEnabled)
-                            selfAssignmentError(tok, tok->astOperand1()->expressionString());
-                        else if (styleEnabled) {
-                            if (mTokenizer->isCPP() && mSettings->standards.cpp==Standards::CPP11 && tok->str() == "==") {
-                                const Token* parent = tok->astParent();
-                                while (parent && parent->astParent()) {
-                                    parent = parent->astParent();
-                                }
-                                if (parent && parent->previous() && parent->previous()->str() == "static_assert") {
-                                    continue;
+                if (tok->isArithmeticalOp() &&
+                    (tok->astOperand1()->isEnumerator() || (tok->astOperand2() && tok->astOperand2()->isEnumerator())))
+                    continue;
+                const bool pointerDereference = (tok->astOperand1() && tok->astOperand1()->isUnaryOp("*")) ||
+                                                (tok->astOperand2() && tok->astOperand2()->isUnaryOp("*"));
+                const bool followVar = (!isConstVarExpression(tok) || Token::Match(tok, "%comp%|%oror%|&&")) && !pointerDereference;
+                if (isSameExpression(true,
+                                     tok->astOperand1(),
+                                     tok->astOperand2(),
+                                     *mSettings,
+                                     true,
+                                     followVar,
+                                     &errorPath)) {
+                    if (isWithoutSideEffects(tok->astOperand1())) {
+                        const Token* loopTok = isInLoopCondition(tok);
+                        if (!loopTok ||
+                            !findExpressionChanged(tok, tok, loopTok->link()->linkAt(1), *mSettings)) {
+                            const bool isEnum = tok->scope()->type == ScopeType::eEnum;
+                            const bool assignment = !isEnum && tok->str() == "=";
+                            if (assignment)
+                                selfAssignmentError(tok, tok->astOperand1()->expressionString());
+                            else if (!isEnum) {
+                                if (tok->str() == "==") {
+                                    const Token* parent = tok->astParent();
+                                    while (parent && parent->astParent()) {
+                                        parent = parent->astParent();
+                                    }
+                                    if (parent && parent->previous() &&
+                                        (isStaticAssert(*mSettings, parent->previous()) ||
+                                         Token::simpleMatch(parent->previous(), "assert"))) {
+                                        continue;
+                                    }
                                 }
+                                duplicateExpressionError(tok->astOperand1(), tok->astOperand2(), tok, std::move(errorPath));
                             }
-                            duplicateExpressionError(tok->astOperand1(), tok->astOperand2(), tok, errorPath);
                         }
                     }
-                } else if (tok->str() == "=" && Token::simpleMatch(tok->astOperand2(), "=") && isSameExpression(mTokenizer->isCPP(), false, tok->astOperand1(), tok->astOperand2()->astOperand1(), mSettings->library, true, false)) {
-                    if (warningEnabled && isWithoutSideEffects(mTokenizer->isCPP(), tok->astOperand1())) {
+                } else if (tok->str() == "=" && Token::simpleMatch(tok->astOperand2(), "=") &&
+                           isSameExpression(false,
+                                            tok->astOperand1(),
+                                            tok->astOperand2()->astOperand1(),
+                                            *mSettings,
+                                            true,
+                                            false)) {
+                    if (isWithoutSideEffects(tok->astOperand1())) {
                         selfAssignmentError(tok, tok->astOperand1()->expressionString());
                     }
-                } else if (styleEnabled &&
-                           isOppositeExpression(mTokenizer->isCPP(), tok->astOperand1(), tok->astOperand2(), mSettings->library, false, true, &errorPath) &&
+                } else if (isOppositeExpression(tok->astOperand1(),
+                                                tok->astOperand2(),
+                                                *mSettings,
+                                                false,
+                                                true,
+                                                &errorPath) &&
                            !Token::Match(tok, "=|-|-=|/|/=") &&
-                           isWithoutSideEffects(mTokenizer->isCPP(), tok->astOperand1())) {
-                    oppositeExpressionError(tok, errorPath);
+                           isWithoutSideEffects(tok->astOperand1())) {
+                    oppositeExpressionError(tok, std::move(errorPath));
                 } else if (!Token::Match(tok, "[-/%]")) { // These operators are not associative
-                    if (styleEnabled && tok->astOperand2() && tok->str() == tok->astOperand1()->str() && isSameExpression(mTokenizer->isCPP(), true, tok->astOperand2(), tok->astOperand1()->astOperand2(), mSettings->library, true, true, &errorPath) && isWithoutSideEffects(mTokenizer->isCPP(), tok->astOperand2()))
-                        duplicateExpressionError(tok->astOperand2(), tok->astOperand1()->astOperand2(), tok, errorPath);
-                    else if (tok->astOperand2() && isConstExpression(tok->astOperand1(), mSettings->library, true, mTokenizer->isCPP())) {
+                    if (tok->astOperand2() && tok->str() == tok->astOperand1()->str() &&
+                        isSameExpression(true,
+                                         tok->astOperand2(),
+                                         tok->astOperand1()->astOperand2(),
+                                         *mSettings,
+                                         true,
+                                         followVar,
+                                         &errorPath) &&
+                        isWithoutSideEffects(tok->astOperand2()))
+                        duplicateExpressionError(tok->astOperand2(), tok->astOperand1()->astOperand2(), tok, std::move(errorPath));
+                    else if (tok->astOperand2() && isConstExpression(tok->astOperand1(), mSettings->library)) {
+                        auto checkDuplicate = [&](const Token* exp1, const Token* exp2, const Token* ast1) {
+                            if (isSameExpression(true, exp1, exp2, *mSettings, true, true, &errorPath) &&
+                                isWithoutSideEffects(exp1) &&
+                                isWithoutSideEffects(ast1->astOperand2()))
+                                duplicateExpressionError(exp1, exp2, tok, errorPath, /*hasMultipleExpr*/ true);
+                        };
                         const Token *ast1 = tok->astOperand1();
-                        while (ast1 && tok->str() == ast1->str()) {
-                            if (isSameExpression(mTokenizer->isCPP(), true, ast1->astOperand1(), tok->astOperand2(), mSettings->library, true, true, &errorPath) &&
-                                isWithoutSideEffects(mTokenizer->isCPP(), ast1->astOperand1()) &&
-                                isWithoutSideEffects(mTokenizer->isCPP(), ast1->astOperand2()))
-                                // Probably the message should be changed to 'duplicate expressions X in condition or something like that'.
-                                duplicateExpressionError(ast1->astOperand1(), tok->astOperand2(), tok, errorPath);
+                        while (ast1 && tok->str() == ast1->str()) { // chain of identical operators
+                            checkDuplicate(ast1->astOperand2(), tok->astOperand2(), ast1);
+                            if (ast1->astOperand1() && ast1->astOperand1()->str() != tok->str()) // check first condition in the chain
+                                checkDuplicate(ast1->astOperand1(), tok->astOperand2(), ast1);
                             ast1 = ast1->astOperand1();
                         }
                     }
                 }
-            } else if (styleEnabled && tok->astOperand1() && tok->astOperand2() && tok->str() == ":" && tok->astParent() && tok->astParent()->str() == "?") {
-                if (!tok->astOperand1()->values().empty() && !tok->astOperand2()->values().empty() && isEqualKnownValue(tok->astOperand1(), tok->astOperand2()))
+            } else if (tok->astOperand1() && tok->astOperand2() && tok->str() == ":" && tok->astParent() && tok->astParent()->str() == "?") {
+                if (isSameExpression(true, tok->astOperand1(), tok->astOperand2(), *mSettings, false, true, &errorPath))
+                    duplicateExpressionTernaryError(tok, std::move(errorPath));
+
+                else if (!tok->astOperand1()->values().empty() && !tok->astOperand2()->values().empty() && isEqualKnownValue(tok->astOperand1(), tok->astOperand2()) &&
+                         !isVariableChanged(tok->astParent(), /*indirect*/ 0, *mSettings) &&
+                         isConstStatement(tok->astOperand1(), mSettings->library, true) && isConstStatement(tok->astOperand2(), mSettings->library, true))
                     duplicateValueTernaryError(tok);
-                else if (isSameExpression(mTokenizer->isCPP(), true, tok->astOperand1(), tok->astOperand2(), mSettings->library, false, true, &errorPath))
-                    duplicateExpressionTernaryError(tok, errorPath);
             }
         }
     }
@@ -2037,13 +3054,13 @@ void CheckOther::oppositeExpressionError(const Token *opTok, ErrorPath errors)
 
     const std::string& op = opTok ? opTok->str() : "&&";
 
-    reportError(errors, Severity::style, "oppositeExpression", "Opposite expression on both sides of \'" + op + "\'.\n"
+    reportError(std::move(errors), Severity::style, "oppositeExpression", "Opposite expression on both sides of \'" + op + "\'.\n"
                 "Finding the opposite expression on both sides of an operator is suspicious and might "
                 "indicate a cut and paste or logic error. Please examine this code carefully to "
-                "determine if it is correct.", CWE398, false);
+                "determine if it is correct.", CWE398, Certainty::normal);
 }
 
-void CheckOther::duplicateExpressionError(const Token *tok1, const Token *tok2, const Token *opTok, ErrorPath errors)
+void CheckOther::duplicateExpressionError(const Token *tok1, const Token *tok2, const Token *opTok, ErrorPath errors, bool hasMultipleExpr)
 {
     errors.emplace_back(opTok, "");
 
@@ -2051,23 +3068,24 @@ void CheckOther::duplicateExpressionError(const Token *tok1, const Token *tok2,
     const std::string& expr2 = tok2 ? tok2->expressionString() : "x";
 
     const std::string& op = opTok ? opTok->str() : "&&";
-    std::string msg = "Same expression on both sides of \'" + op + "\'";
-    std::string id = "duplicateExpression";
-    if (expr1 != expr2) {
+    std::string msg = "Same expression " + (hasMultipleExpr ? "\'" + expr1 + "\'" + " found multiple times in chain of \'" + op + "\' operators" : "on both sides of \'" + op + "\'");
+    const char *id = "duplicateExpression";
+    if (expr1 != expr2 && (!opTok || Token::Match(opTok, "%oror%|%comp%|&&|?|!"))) {
         id = "knownConditionTrueFalse";
-        std::string exprMsg = "The expression \'" + expr1 + " " + op +  " " + expr2 + "\' is always ";
+        std::string exprMsg = "The comparison \'" + expr1 + " " + op +  " " + expr2 + "\' is always ";
         if (Token::Match(opTok, "==|>=|<="))
             msg = exprMsg + "true";
         else if (Token::Match(opTok, "!=|>|<"))
             msg = exprMsg + "false";
-        if (!Token::Match(tok1, "%num%|NULL|nullptr") && !Token::Match(tok2, "%num%|NULL|nullptr"))
-            msg += " because '" + expr1 + "' and '" + expr2 + "' represent the same value";
     }
 
-    reportError(errors, Severity::style, id.c_str(), msg + ".\n"
-                "Finding the same expression on both sides of an operator is suspicious and might "
-                "indicate a cut and paste or logic error. Please examine this code carefully to "
-                "determine if it is correct.", CWE398, false);
+    if (expr1 != expr2 && !Token::Match(tok1, "%num%|NULL|nullptr") && !Token::Match(tok2, "%num%|NULL|nullptr"))
+        msg += " because '" + expr1 + "' and '" + expr2 + "' represent the same value";
+
+    reportError(std::move(errors), Severity::style, id, msg +
+                (std::string(".\nFinding the same expression ") + (hasMultipleExpr ? "more than once in a condition" : "on both sides of an operator")) +
+                " is suspicious and might indicate a cut and paste or logic error. Please examine this code carefully to "
+                "determine if it is correct.", CWE398, Certainty::normal);
 }
 
 void CheckOther::duplicateAssignExpressionError(const Token *tok1, const Token *tok2, bool inconclusive)
@@ -2081,30 +3099,30 @@ void CheckOther::duplicateAssignExpressionError(const Token *tok1, const Token *
                 "Same expression used in consecutive assignments of '" + var1 + "' and '" + var2 + "'.\n"
                 "Finding variables '" + var1 + "' and '" + var2 + "' that are assigned the same expression "
                 "is suspicious and might indicate a cut and paste or logic error. Please examine this code carefully to "
-                "determine if it is correct.", CWE398, inconclusive);
+                "determine if it is correct.", CWE398, inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
 void CheckOther::duplicateExpressionTernaryError(const Token *tok, ErrorPath errors)
 {
     errors.emplace_back(tok, "");
-    reportError(errors, Severity::style, "duplicateExpressionTernary", "Same expression in both branches of ternary operator.\n"
+    reportError(std::move(errors), Severity::style, "duplicateExpressionTernary", "Same expression in both branches of ternary operator.\n"
                 "Finding the same expression in both branches of ternary operator is suspicious as "
-                "the same code is executed regardless of the condition.", CWE398, false);
+                "the same code is executed regardless of the condition.", CWE398, Certainty::normal);
 }
 
 void CheckOther::duplicateValueTernaryError(const Token *tok)
 {
     reportError(tok, Severity::style, "duplicateValueTernary", "Same value in both branches of ternary operator.\n"
                 "Finding the same value in both branches of ternary operator is suspicious as "
-                "the same code is executed regardless of the condition.", CWE398, false);
+                "the same code is executed regardless of the condition.", CWE398, Certainty::normal);
 }
 
 void CheckOther::selfAssignmentError(const Token *tok, const std::string &varname)
 {
-    reportError(tok, Severity::warning,
+    reportError(tok, Severity::style,
                 "selfAssignment",
                 "$symbol:" + varname + "\n"
-                "Redundant assignment of '$symbol' to itself.", CWE398, false);
+                "Redundant assignment of '$symbol' to itself.", CWE398, Certainty::normal);
 }
 
 //-----------------------------------------------------------------------------
@@ -2118,9 +3136,11 @@ void CheckOther::selfAssignmentError(const Token *tok, const std::string &varnam
 //-----------------------------------------------------------------------------
 void CheckOther::checkComparisonFunctionIsAlwaysTrueOrFalse()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckOther::checkComparisonFunctionIsAlwaysTrueOrFalse"); // warning
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
@@ -2146,14 +3166,14 @@ void CheckOther::checkComparisonFunctionIsAlwaysTrueOrFalse()
 }
 void CheckOther::checkComparisonFunctionIsAlwaysTrueOrFalseError(const Token* tok, const std::string &functionName, const std::string &varName, const bool result)
 {
-    const std::string strResult = result ? "true" : "false";
-    const struct CWE cweResult = result ? CWE571 : CWE570;
+    const std::string strResult = bool_to_string(result);
+    const CWE cweResult = result ? CWE571 : CWE570;
 
     reportError(tok, Severity::warning, "comparisonFunctionIsAlwaysTrueOrFalse",
                 "$symbol:" + functionName + "\n"
                 "Comparison of two identical variables with $symbol(" + varName + "," + varName + ") always evaluates to " + strResult + ".\n"
                 "The function $symbol is designed to compare two variables. Calling this function with one variable (" + varName + ") "
-                "for both parameters leads to a statement which is always " + strResult + ".", cweResult, false);
+                "for both parameters leads to a statement which is always " + strResult + ".", cweResult, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -2161,81 +3181,115 @@ void CheckOther::checkComparisonFunctionIsAlwaysTrueOrFalseError(const Token* to
 //---------------------------------------------------------------------------
 void CheckOther::checkSignOfUnsignedVariable()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("unsignedLessThanZero"))
         return;
 
+    logChecker("CheckOther::checkSignOfUnsignedVariable"); // style
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope * scope : symbolDatabase->functionScopes) {
         // check all the code in the function
         for (const Token *tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
-            if (!tok->isComparisonOp() || !tok->astOperand1() || !tok->astOperand2())
-                continue;
-
-            const ValueFlow::Value *v1 = tok->astOperand1()->getValue(0);
-            const ValueFlow::Value *v2 = tok->astOperand2()->getValue(0);
-
-            if (Token::Match(tok, "<|<=") && v2 && v2->isKnown()) {
-                const ValueType* vt = tok->astOperand1()->valueType();
-                if (vt && vt->pointer)
-                    pointerLessThanZeroError(tok, v2);
-                if (vt && vt->sign == ValueType::UNSIGNED)
-                    unsignedLessThanZeroError(tok, v2, tok->astOperand1()->expressionString());
-            } else if (Token::Match(tok, ">|>=") && v1 && v1->isKnown()) {
-                const ValueType* vt = tok->astOperand2()->valueType();
-                if (vt && vt->pointer)
-                    pointerLessThanZeroError(tok, v1);
-                if (vt && vt->sign == ValueType::UNSIGNED)
-                    unsignedLessThanZeroError(tok, v1, tok->astOperand2()->expressionString());
-            } else if (Token::simpleMatch(tok, ">=") && v2 && v2->isKnown()) {
-                const ValueType* vt = tok->astOperand1()->valueType();
-                if (vt && vt->pointer)
-                    pointerPositiveError(tok, v2);
-                if (vt && vt->sign == ValueType::UNSIGNED)
-                    unsignedPositiveError(tok, v2, tok->astOperand1()->expressionString());
-            } else if (Token::simpleMatch(tok, "<=") && v1 && v1->isKnown()) {
-                const ValueType* vt = tok->astOperand2()->valueType();
-                if (vt && vt->pointer)
-                    pointerPositiveError(tok, v1);
-                if (vt && vt->sign == ValueType::UNSIGNED)
-                    unsignedPositiveError(tok, v1, tok->astOperand2()->expressionString());
+            const ValueFlow::Value *zeroValue = nullptr;
+            const Token *nonZeroExpr = nullptr;
+            if (comparisonNonZeroExpressionLessThanZero(tok, zeroValue, nonZeroExpr)) {
+                const ValueType* vt = nonZeroExpr->valueType();
+                if (vt->pointer)
+                    pointerLessThanZeroError(tok, zeroValue);
+                else
+                    unsignedLessThanZeroError(tok, zeroValue, nonZeroExpr->expressionString());
+            } else if (testIfNonZeroExpressionIsPositive(tok, zeroValue, nonZeroExpr)) {
+                const ValueType* vt = nonZeroExpr->valueType();
+                if (vt->pointer)
+                    pointerPositiveError(tok, zeroValue);
+                else
+                    unsignedPositiveError(tok, zeroValue, nonZeroExpr->expressionString());
             }
         }
     }
 }
 
+bool CheckOther::comparisonNonZeroExpressionLessThanZero(const Token *tok, const ValueFlow::Value *&zeroValue, const Token *&nonZeroExpr, bool suppress)
+{
+    if (!tok->isComparisonOp() || !tok->astOperand1() || !tok->astOperand2())
+        return false;
+
+    const ValueFlow::Value *v1 = tok->astOperand1()->getValue(0);
+    const ValueFlow::Value *v2 = tok->astOperand2()->getValue(0);
+
+    if (Token::Match(tok, "<|<=") && v2 && v2->isKnown()) {
+        zeroValue = v2;
+        nonZeroExpr = tok->astOperand1();
+    } else if (Token::Match(tok, ">|>=") && v1 && v1->isKnown()) {
+        zeroValue = v1;
+        nonZeroExpr = tok->astOperand2();
+    } else {
+        return false;
+    }
+
+    if (const Variable* var = nonZeroExpr->variable())
+        if (var->typeStartToken()->isTemplateArg())
+            return suppress;
+
+    const ValueType* vt = nonZeroExpr->valueType();
+    return vt && (vt->pointer || vt->sign == ValueType::UNSIGNED);
+}
+
+bool CheckOther::testIfNonZeroExpressionIsPositive(const Token *tok, const ValueFlow::Value *&zeroValue, const Token *&nonZeroExpr)
+{
+    if (!tok->isComparisonOp() || !tok->astOperand1() || !tok->astOperand2())
+        return false;
+
+    const ValueFlow::Value *v1 = tok->astOperand1()->getValue(0);
+    const ValueFlow::Value *v2 = tok->astOperand2()->getValue(0);
+
+    if (Token::simpleMatch(tok, ">=") && v2 && v2->isKnown()) {
+        zeroValue = v2;
+        nonZeroExpr = tok->astOperand1();
+    } else if (Token::simpleMatch(tok, "<=") && v1 && v1->isKnown()) {
+        zeroValue = v1;
+        nonZeroExpr = tok->astOperand2();
+    } else {
+        return false;
+    }
+
+    const ValueType* vt = nonZeroExpr->valueType();
+    return vt && (vt->pointer || vt->sign == ValueType::UNSIGNED);
+}
+
 void CheckOther::unsignedLessThanZeroError(const Token *tok, const ValueFlow::Value * v, const std::string &varname)
 {
     reportError(getErrorPath(tok, v, "Unsigned less than zero"), Severity::style, "unsignedLessThanZero",
                 "$symbol:" + varname + "\n"
                 "Checking if unsigned expression '$symbol' is less than zero.\n"
                 "The unsigned expression '$symbol' will never be negative so it "
-                "is either pointless or an error to check if it is.", CWE570, false);
+                "is either pointless or an error to check if it is.", CWE570, Certainty::normal);
 }
 
 void CheckOther::pointerLessThanZeroError(const Token *tok, const ValueFlow::Value *v)
 {
     reportError(getErrorPath(tok, v, "Pointer less than zero"), Severity::style, "pointerLessThanZero",
-                "A pointer can not be negative so it is either pointless or an error to check if it is.", CWE570, false);
+                "A pointer can not be negative so it is either pointless or an error to check if it is.", CWE570, Certainty::normal);
 }
 
 void CheckOther::unsignedPositiveError(const Token *tok, const ValueFlow::Value * v, const std::string &varname)
 {
     reportError(getErrorPath(tok, v, "Unsigned positive"), Severity::style, "unsignedPositive",
                 "$symbol:" + varname + "\n"
-                "Unsigned expression '$symbol' can't be negative so it is unnecessary to test it.", CWE570, false);
+                "Unsigned expression '$symbol' can't be negative so it is unnecessary to test it.", CWE570, Certainty::normal);
 }
 
 void CheckOther::pointerPositiveError(const Token *tok, const ValueFlow::Value * v)
 {
     reportError(getErrorPath(tok, v, "Pointer positive"), Severity::style, "pointerPositive",
-                "A pointer can not be negative so it is either pointless or an error to check if it is not.", CWE570, false);
+                "A pointer can not be negative so it is either pointless or an error to check if it is not.", CWE570, Certainty::normal);
 }
 
 /* check if a constructor in given class scope takes a reference */
 static bool constructorTakesReference(const Scope * const classScope)
 {
-    for (const Function &constructor : classScope->functionList) {
+    return std::any_of(classScope->functionList.begin(), classScope->functionList.end(), [&](const Function& constructor) {
         if (constructor.isConstructor()) {
             for (int argnr = 0U; argnr < constructor.argCount(); argnr++) {
                 const Variable * const argVar = constructor.getArgumentVar(argnr);
@@ -2244,49 +3298,109 @@ static bool constructorTakesReference(const Scope * const classScope)
                 }
             }
         }
-    }
-    return false;
+        return false;
+    });
+}
+
+static bool isLargeObject(const Variable* var, const Settings& settings)
+{
+    if (!var || var->isGlobal() || !var->valueType())
+        return false;
+    ValueType vt = *var->valueType();
+    vt.reference = Reference::None;
+    return vt.getSizeOf(settings, ValueType::Accuracy::LowerBound, ValueType::SizeOf::Pointer) > 2 * settings.platform.sizeof_pointer;
 }
 
 //---------------------------------------------------------------------------
 // This check rule works for checking the "const A a = getA()" usage when getA() returns "const A &" or "A &".
 // In most scenarios, "const A & a = getA()" will be more efficient.
 //---------------------------------------------------------------------------
+static bool checkFunctionReturnsRef(const Token* tok, const Settings& settings)
+{
+    if (!Token::Match(tok->previous(), "%name% ("))
+        return false;
+    if (!Token::Match(tok->link(), ") )|}| ;")) // bailout for usage like "const A a = getA()+3"
+        return false;
+    const Token* dot = tok->astOperand1();
+    if (Token::simpleMatch(dot, ".")) {
+        const Token* varTok = dot->astOperand1();
+        const int indirect = varTok->valueType() ? varTok->valueType()->pointer : 0;
+        if (isVariableChanged(tok, tok->scope()->bodyEnd, indirect, varTok->varId(), /*globalvar*/ true, settings))
+            return false;
+        if (isTemporary(dot, &settings.library, /*unknown*/ true))
+            return false;
+    }
+    if (exprDependsOnThis(tok->previous()))
+        return false;
+    const Function* func = tok->previous()->function();
+    if (func && func->tokenDef->strAt(-1) == "&") {
+        const Scope* fScope = func->functionScope;
+        if (fScope && fScope->bodyEnd && Token::Match(fScope->bodyEnd->tokAt(-3), "return %var% ;")) {
+            const Token* varTok = fScope->bodyEnd->tokAt(-2);
+            if (isLargeObject(varTok->variable(), settings))
+                return true;
+        }
+    }
+    return false;
+}
+
+static bool checkVariableAssignment(const Token* tok, const ValueType* vtLhs, const Settings& settings)
+{
+    if (!Token::Match(tok, "%var% ;"))
+        return false;
+    const Variable* var = tok->variable();
+    if (!var || !isLargeObject(var, settings))
+        return false;
+    if (!vtLhs || !vtLhs->isTypeEqual(var->valueType()))
+        return false;
+    if (findVariableChanged(tok->tokAt(2), tok->scope()->bodyEnd, /*indirect*/ 0, var->declarationId(), /*globalvar*/ false, settings))
+        return false;
+    if (var->isLocal() || (var->isArgument() && !var->isReference()))
+        return true;
+    const Scope* scope = tok->scope();
+    while (scope && scope->type != ScopeType::eFunction)
+        scope = scope->nestedIn;
+    return scope && scope->function && (!scope->functionOf || scope->function->isConst() || scope->function->isStatic());
+}
+
 void CheckOther::checkRedundantCopy()
 {
-    if (!mSettings->isEnabled(Settings::PERFORMANCE) || mTokenizer->isC() || !mSettings->inconclusive)
+    if (!mSettings->severity.isEnabled(Severity::performance) || mTokenizer->isC() || !mSettings->certainty.isEnabled(Certainty::inconclusive))
         return;
 
+    logChecker("CheckOther::checkRedundantCopy"); // c++,performance,inconclusive
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Variable* var : symbolDatabase->variableList()) {
-        if (!var || var->isReference() || !var->isConst() || var->isPointer() || (!var->type() && !var->isStlType())) // bailout if var is of standard type, if it is a pointer or non-const
+        if (!var || var->isReference() || var->isPointer() ||
+            (!var->type() && !var->isStlType() && !(var->valueType() && var->valueType()->container)) || // bailout if var is of standard type, if it is a pointer or non-const
+            (!var->isConst() && isVariableChanged(var, *mSettings)))
             continue;
 
         const Token* startTok = var->nameToken();
         if (startTok->strAt(1) == "=") // %type% %name% = ... ;
             ;
-        else if (startTok->strAt(1) == "(" && var->isClass() && var->typeScope()) {
+        else if (Token::Match(startTok->next(), "(|{") && var->isClass()) {
+            if (!var->typeScope() && !(var->valueType() && var->valueType()->container))
+                continue;
             // Object is instantiated. Warn if constructor takes arguments by value.
-            if (constructorTakesReference(var->typeScope()))
+            if (var->typeScope() && constructorTakesReference(var->typeScope()))
                 continue;
+        } else if (Token::simpleMatch(startTok->next(), ";") && startTok->next()->isSplittedVarDeclEq()) {
+            startTok = startTok->tokAt(2);
         } else
             continue;
 
         const Token* tok = startTok->next()->astOperand2();
         if (!tok)
             continue;
-        if (!Token::Match(tok->previous(), "%name% ("))
-            continue;
-        if (!Token::Match(tok->link(), ") )| ;")) // bailout for usage like "const A a = getA()+3"
+        if (!checkFunctionReturnsRef(tok, *mSettings) && !checkVariableAssignment(tok, var->valueType(), *mSettings))
             continue;
-
-        const Function* func = tok->previous()->function();
-        if (func && func->tokenDef->strAt(-1) == "&") {
-            redundantCopyError(startTok, startTok->str());
-        }
+        redundantCopyError(startTok, startTok->str());
     }
 }
+
 void CheckOther::redundantCopyError(const Token *tok,const std::string& varname)
 {
     reportError(tok, Severity::performance, "redundantCopyLocalConst",
@@ -2295,23 +3409,27 @@ void CheckOther::redundantCopyError(const Token *tok,const std::string& varname)
                 "The const variable '$symbol' is assigned a copy of the data. You can avoid "
                 "the unnecessary data copying by converting '$symbol' to const reference.",
                 CWE398,
-                true); // since #5618 that check became inconclusive
+                Certainty::inconclusive); // since #5618 that check became inconclusive
 }
 
 //---------------------------------------------------------------------------
 // Checking for shift by negative values
 //---------------------------------------------------------------------------
 
-static bool isNegative(const Token *tok, const Settings *settings)
+static bool isNegative(const Token *tok, const Settings &settings)
 {
     return tok->valueType() && tok->valueType()->sign == ValueType::SIGNED && tok->getValueLE(-1LL, settings);
 }
 
 void CheckOther::checkNegativeBitwiseShift()
 {
-    const bool portability = mSettings->isEnabled(Settings::PORTABILITY);
+    const bool portability = mSettings->severity.isEnabled(Severity::portability);
+
+    logChecker("CheckOther::checkNegativeBitwiseShift");
 
     for (const Token* tok = mTokenizer->tokens(); tok; tok = tok->next()) {
+        tok = skipUnreachableBranch(tok);
+
         if (!tok->astOperand1() || !tok->astOperand2())
             continue;
 
@@ -2319,9 +3437,9 @@ void CheckOther::checkNegativeBitwiseShift()
             continue;
 
         // don't warn if lhs is a class. this is an overloaded operator then
-        if (mTokenizer->isCPP()) {
+        if (tok->isCpp()) {
             const ValueType * lhsType = tok->astOperand1()->valueType();
-            if (!lhsType || !lhsType->isIntegral())
+            if (!lhsType || !lhsType->isIntegral() || lhsType->pointer)
                 continue;
         }
 
@@ -2337,9 +3455,9 @@ void CheckOther::checkNegativeBitwiseShift()
             continue;
 
         // Get negative rhs value. preferably a value which doesn't have 'condition'.
-        if (portability && isNegative(tok->astOperand1(), mSettings))
+        if (portability && isNegative(tok->astOperand1(), *mSettings))
             negativeBitwiseShiftError(tok, 1);
-        else if (isNegative(tok->astOperand2(), mSettings))
+        else if (isNegative(tok->astOperand2(), *mSettings))
             negativeBitwiseShiftError(tok, 2);
     }
 }
@@ -2351,9 +3469,9 @@ void CheckOther::negativeBitwiseShiftError(const Token *tok, int op)
         // LHS - this is used by intention in various software, if it
         // is used often in a project and works as expected then this is
         // a portability issue
-        reportError(tok, Severity::portability, "shiftNegativeLHS", "Shifting a negative value is technically undefined behaviour", CWE758, false);
+        reportError(tok, Severity::portability, "shiftNegativeLHS", "Shifting a negative value is technically undefined behaviour", CWE758, Certainty::normal);
     else // RHS
-        reportError(tok, Severity::error, "shiftNegative", "Shifting by a negative value is undefined behaviour", CWE758, false);
+        reportError(tok, Severity::error, "shiftNegative", "Shifting by a negative value is undefined behaviour", CWE758, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -2361,32 +3479,48 @@ void CheckOther::negativeBitwiseShiftError(const Token *tok, int op)
 //---------------------------------------------------------------------------
 void CheckOther::checkIncompleteArrayFill()
 {
-    if (!mSettings->inconclusive)
+    if (!mSettings->certainty.isEnabled(Certainty::inconclusive))
         return;
-    const bool printWarning = mSettings->isEnabled(Settings::WARNING);
-    const bool printPortability = mSettings->isEnabled(Settings::PORTABILITY);
+    const bool printWarning = mSettings->severity.isEnabled(Severity::warning);
+    const bool printPortability = mSettings->severity.isEnabled(Severity::portability);
     if (!printPortability && !printWarning)
         return;
 
+    logChecker("CheckOther::checkIncompleteArrayFill"); // warning,portability,inconclusive
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
-            if (Token::Match(tok, "memset|memcpy|memmove ( %var% ,") && Token::Match(tok->linkAt(1)->tokAt(-2), ", %num% )")) {
-                const Variable *var = tok->tokAt(2)->variable();
+            if (Token::Match(tok, "memset|memcpy|memmove (")) {
+                std::vector<const Token*> args = getArguments(tok);
+                if (args.size() != 3)
+                    continue;
+                const Token* tok2 = args[0];
+                if (tok2->str() == "::")
+                    tok2 = tok2->next();
+                while (Token::Match(tok2, "%name% ::|."))
+                    tok2 = tok2->tokAt(2);
+                if (!Token::Match(tok2, "%var% ,"))
+                    continue;
+
+                const Variable *var = tok2->variable();
                 if (!var || !var->isArray() || var->dimensions().empty() || !var->dimension(0))
                     continue;
 
-                if (MathLib::toLongNumber(tok->linkAt(1)->strAt(-1)) == var->dimension(0)) {
-                    int size = mTokenizer->sizeOfType(var->typeStartToken());
-                    if (size == 0 && var->valueType()->pointer)
-                        size = mSettings->sizeof_pointer;
-                    if ((size != 1 && size != 100 && size != 0) || var->isPointer()) {
-                        if (printWarning)
-                            incompleteArrayFillError(tok, var->name(), tok->str(), false);
-                    } else if (var->valueType()->type == ValueType::Type::BOOL && printPortability) // sizeof(bool) is not 1 on all platforms
-                        incompleteArrayFillError(tok, var->name(), tok->str(), true);
-                }
+                if (!args[2]->hasKnownIntValue() || args[2]->getKnownIntValue() != var->dimension(0))
+                    continue;
+                int size = mTokenizer->sizeOfType(var->typeStartToken());
+                if (size == 0 && var->valueType()->pointer)
+                    size = mSettings->platform.sizeof_pointer;
+                else if (size == 0 && var->valueType())
+                    size = var->valueType()->getSizeOf(*mSettings, ValueType::Accuracy::LowerBound, ValueType::SizeOf::Pointer);
+                const Token* tok3 = tok->next()->astOperand2()->astOperand1()->astOperand1();
+                if ((size != 1 && size != 100 && size != 0) || var->isPointer()) {
+                    if (printWarning)
+                        incompleteArrayFillError(tok, tok3->expressionString(), tok->str(), false);
+                } else if (var->valueType()->type == ValueType::Type::BOOL && printPortability) // sizeof(bool) is not 1 on all platforms
+                    incompleteArrayFillError(tok, tok3->expressionString(), tok->str(), true);
             }
         }
     }
@@ -2399,13 +3533,13 @@ void CheckOther::incompleteArrayFillError(const Token* tok, const std::string& b
                     "$symbol:" + buffer + "\n"
                     "$symbol:" + function + "\n"
                     "Array '" + buffer + "' might be filled incompletely. Did you forget to multiply the size given to '" + function + "()' with 'sizeof(*" + buffer + ")'?\n"
-                    "The array '" + buffer + "' is filled incompletely. The function '" + function + "()' needs the size given in bytes, but the type 'bool' is larger than 1 on some platforms. Did you forget to multiply the size with 'sizeof(*" + buffer + ")'?", CWE131, true);
+                    "The array '" + buffer + "' is filled incompletely. The function '" + function + "()' needs the size given in bytes, but the type 'bool' is larger than 1 on some platforms. Did you forget to multiply the size with 'sizeof(*" + buffer + ")'?", CWE131, Certainty::inconclusive);
     else
         reportError(tok, Severity::warning, "incompleteArrayFill",
                     "$symbol:" + buffer + "\n"
                     "$symbol:" + function + "\n"
                     "Array '" + buffer + "' is filled incompletely. Did you forget to multiply the size given to '" + function + "()' with 'sizeof(*" + buffer + ")'?\n"
-                    "The array '" + buffer + "' is filled incompletely. The function '" + function + "()' needs the size given in bytes, but an element of the given array is larger than one byte. Did you forget to multiply the size with 'sizeof(*" + buffer + ")'?", CWE131, true);
+                    "The array '" + buffer + "' is filled incompletely. The function '" + function + "()' needs the size given in bytes, but an element of the given array is larger than one byte. Did you forget to multiply the size with 'sizeof(*" + buffer + ")'?", CWE131, Certainty::inconclusive);
 }
 
 //---------------------------------------------------------------------------
@@ -2414,14 +3548,16 @@ void CheckOther::incompleteArrayFillError(const Token* tok, const std::string& b
 
 void CheckOther::checkVarFuncNullUB()
 {
-    if (!mSettings->isEnabled(Settings::PORTABILITY))
+    if (!mSettings->severity.isEnabled(Severity::portability))
         return;
 
+    logChecker("CheckOther::checkVarFuncNullUB"); // portability
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
             // Is NULL passed to a function?
-            if (Token::Match(tok,"[(,] NULL [,)]")) {
+            if (Token::Match(tok,"[(,] NULL )")) {
                 // Locate function name in this function call.
                 const Token *ftok = tok;
                 int argnr = 1;
@@ -2492,16 +3628,26 @@ void CheckOther::varFuncNullUBError(const Token *tok)
                 "    h();\n"
                 "    g();\n"
                 "    return 0;\n"
-                "}", CWE475, false);
+                "}", CWE475, Certainty::normal);
 }
 
 void CheckOther::checkRedundantPointerOp()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("redundantPointerOp"))
         return;
 
+    logChecker("CheckOther::checkRedundantPointerOp"); // style
+
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
-        if (!tok->isUnaryOp("&") || !tok->astOperand1()->isUnaryOp("*"))
+        if (tok->isExpandedMacro() && tok->str() == "(")
+            tok = tok->link();
+
+        bool addressOfDeref{};
+        if (tok->isUnaryOp("&") && tok->astOperand1()->isUnaryOp("*"))
+            addressOfDeref = true;
+        else if (tok->isUnaryOp("*") && tok->astOperand1()->isUnaryOp("&"))
+            addressOfDeref = false;
+        else
             continue;
 
         // variable
@@ -2509,27 +3655,36 @@ void CheckOther::checkRedundantPointerOp()
         if (!varTok || varTok->isExpandedMacro())
             continue;
 
+        if (!addressOfDeref) { // dereference of address
+            if (tok->isExpandedMacro())
+                continue;
+            if (varTok->valueType() && varTok->valueType()->pointer && varTok->valueType()->reference == Reference::LValue)
+                continue;
+        }
+
         const Variable *var = varTok->variable();
-        if (!var || !var->isPointer())
+        if (!var || (addressOfDeref && !var->isPointer()))
             continue;
 
-        redundantPointerOpError(tok, var->name(), false);
+        redundantPointerOpError(tok, var->name(), false, addressOfDeref);
     }
 }
 
-void CheckOther::redundantPointerOpError(const Token* tok, const std::string &varname, bool inconclusive)
+void CheckOther::redundantPointerOpError(const Token* tok, const std::string &varname, bool inconclusive, bool addressOfDeref)
 {
-    reportError(tok, Severity::style, "redundantPointerOp",
-                "$symbol:" + varname + "\n"
-                "Redundant pointer operation on '$symbol' - it's already a pointer.", CWE398, inconclusive);
+    std::string msg = "$symbol:" + varname + "\nRedundant pointer operation on '$symbol' - it's already a ";
+    msg += addressOfDeref ? "pointer." : "variable.";
+    reportError(tok, Severity::style, "redundantPointerOp", msg, CWE398, inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
 void CheckOther::checkInterlockedDecrement()
 {
-    if (!mSettings->isWindowsPlatform()) {
+    if (!mSettings->platform.isWindows()) {
         return;
     }
 
+    logChecker("CheckOther::checkInterlockedDecrement"); // windows-platform
+
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
         if (tok->isName() && Token::Match(tok, "InterlockedDecrement ( & %name% ) ; if ( %name%|!|0")) {
             const Token* interlockedVarTok = tok->tokAt(3);
@@ -2541,11 +3696,11 @@ void CheckOther::checkInterlockedDecrement()
                 raceAfterInterlockedDecrementError(checkStartTok);
             }
         } else if (Token::Match(tok, "if ( ::| InterlockedDecrement ( & %name%")) {
-            const Token* condEnd = tok->next()->link();
+            const Token* condEnd = tok->linkAt(1);
             const Token* funcTok = tok->tokAt(2);
             const Token* firstAccessTok = funcTok->str() == "::" ? funcTok->tokAt(4) : funcTok->tokAt(3);
-            if (condEnd && condEnd->next() && condEnd->next()->link()) {
-                const Token* ifEndTok = condEnd->next()->link();
+            if (condEnd && condEnd->next() && condEnd->linkAt(1)) {
+                const Token* ifEndTok = condEnd->linkAt(1);
                 if (Token::Match(ifEndTok, "} return %name%")) {
                     const Token* secondAccessTok = ifEndTok->tokAt(2);
                     if (secondAccessTok->str() == firstAccessTok->str()) {
@@ -2565,57 +3720,138 @@ void CheckOther::checkInterlockedDecrement()
 void CheckOther::raceAfterInterlockedDecrementError(const Token* tok)
 {
     reportError(tok, Severity::error, "raceAfterInterlockedDecrement",
-                "Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead.", CWE362, false);
+                "Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead.", CWE362, Certainty::normal);
 }
 
 void CheckOther::checkUnusedLabel()
 {
-    if (!mSettings->isEnabled(Settings::STYLE) && !mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->severity.isEnabled(Severity::warning) && !mSettings->isPremiumEnabled("unusedLabel"))
         return;
 
+    logChecker("CheckOther::checkUnusedLabel"); // style,warning
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
+        const bool hasIfdef = mTokenizer->hasIfdef(scope->bodyStart, scope->bodyEnd);
         for (const Token* tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
             if (!tok->scope()->isExecutable())
                 tok = tok->scope()->bodyEnd;
 
-            if (Token::Match(tok, "{|}|; %name% :") && tok->strAt(1) != "default") {
-                if (!Token::findsimplematch(scope->bodyStart->next(), ("goto " + tok->strAt(1)).c_str(), scope->bodyEnd->previous()))
-                    unusedLabelError(tok->next(), tok->next()->scope()->type == Scope::eSwitch);
+            if (Token::Match(tok, "{|}|; %name% :") && !tok->tokAt(1)->isKeyword()) {
+                const std::string tmp("goto " + tok->strAt(1));
+                if (!Token::findsimplematch(scope->bodyStart->next(), tmp.c_str(), tmp.size(), scope->bodyEnd->previous()) && !tok->next()->isExpandedMacro())
+                    unusedLabelError(tok->next(), tok->next()->scope()->type == ScopeType::eSwitch, hasIfdef);
             }
         }
     }
 }
 
-void CheckOther::unusedLabelError(const Token* tok, bool inSwitch)
+void CheckOther::unusedLabelError(const Token* tok, bool inSwitch, bool hasIfdef)
 {
-    if (inSwitch) {
-        if (!tok || mSettings->isEnabled(Settings::WARNING))
-            reportError(tok, Severity::warning, "unusedLabelSwitch",
-                        "$symbol:" + (tok ? tok->str() : emptyString) + "\n"
-                        "Label '$symbol' is not used. Should this be a 'case' of the enclosing switch()?", CWE398, false);
-    } else {
-        if (!tok || mSettings->isEnabled(Settings::STYLE))
-            reportError(tok, Severity::style, "unusedLabel",
-                        "$symbol:" + (tok ? tok->str() : emptyString) + "\n"
-                        "Label '$symbol' is not used.", CWE398, false);
+    if (tok && !mSettings->severity.isEnabled(inSwitch ? Severity::warning : Severity::style) && !mSettings->isPremiumEnabled("unusedLabel"))
+        return;
+
+    std::string id = "unusedLabel";
+    if (inSwitch)
+        id += "Switch";
+    if (hasIfdef)
+        id += "Configuration";
+
+    std::string msg = "$symbol:" + (tok ? tok->str() : "") + "\nLabel '$symbol' is not used.";
+    if (hasIfdef)
+        msg += " There is #if in function body so the label might be used in code that is removed by the preprocessor.";
+    if (inSwitch)
+        msg += " Should this be a 'case' of the enclosing switch()?";
+
+    reportError(tok,
+                inSwitch ? Severity::warning : Severity::style,
+                id,
+                msg,
+                CWE398,
+                Certainty::normal);
+}
+
+static bool checkEvaluationOrderC(const Token * tok, const Token * tok2, const Token * parent, const Settings & settings, bool & selfAssignmentError)
+{
+    // self assignment..
+    if (tok2 == tok && tok->str() == "=" && parent->str() == "=" && isSameExpression(false, tok->astOperand1(), parent->astOperand1(), settings, true, false)) {
+        if (settings.severity.isEnabled(Severity::warning) && isSameExpression(true, tok->astOperand1(), parent->astOperand1(), settings, true, false))
+            selfAssignmentError = true;
+        return false;
+    }
+    // Is expression used?
+    bool foundError = false;
+    visitAstNodes((parent->astOperand1() != tok2) ? parent->astOperand1() : parent->astOperand2(), [&](const Token *tok3) {
+        if (tok3->str() == "&" && !tok3->astOperand2())
+            return ChildrenToVisit::none; // don't handle address-of for now
+        if (tok3->str() == "(" && Token::simpleMatch(tok3->previous(), "sizeof"))
+            return ChildrenToVisit::none; // don't care about sizeof usage
+        if (isSameExpression(false, tok->astOperand1(), tok3, settings, true, false))
+            foundError = true;
+        return foundError ? ChildrenToVisit::done : ChildrenToVisit::op1_and_op2;
+    });
+
+    return foundError;
+}
+
+static bool checkEvaluationOrderCpp11(const Token * tok, const Token * tok2, const Token * parent, const Settings & settings)
+{
+    if (tok->isAssignmentOp()) // TODO check assignment
+        return false;
+    if (tok->previous() == tok->astOperand1() && parent->isArithmeticalOp() && parent->isBinaryOp()) {
+        if (parent->astParent() && parent->astParent()->isAssignmentOp() && isSameExpression(false, tok->astOperand1(), parent->astParent()->astOperand1(), settings, true, false))
+            return true;
     }
+    bool foundUndefined{false};
+    visitAstNodes((parent->astOperand1() != tok2) ? parent->astOperand1() : parent->astOperand2(), [&](const Token *tok3) {
+        if (tok3->str() == "&" && !tok3->astOperand2())
+            return ChildrenToVisit::none; // don't handle address-of for now
+        if (tok3->str() == "(" && Token::simpleMatch(tok3->previous(), "sizeof"))
+            return ChildrenToVisit::none; // don't care about sizeof usage
+        if (isSameExpression(false, tok->astOperand1(), tok3, settings, true, false))
+            foundUndefined = true;
+        return foundUndefined ? ChildrenToVisit::done : ChildrenToVisit::op1_and_op2;
+    });
+
+    return foundUndefined;
 }
 
+static bool checkEvaluationOrderCpp17(const Token * tok, const Token * tok2, const Token * parent, const Settings & settings, bool & foundUnspecified)
+{
+    if (tok->isAssignmentOp())
+        return false;
+    bool foundUndefined{false};
+    visitAstNodes((parent->astOperand1() != tok2) ? parent->astOperand1() : parent->astOperand2(), [&](const Token *tok3) {
+        if (tok3->str() == "&" && !tok3->astOperand2())
+            return ChildrenToVisit::none; // don't handle address-of for now
+        if (tok3->str() == "(" && Token::simpleMatch(tok3->previous(), "sizeof"))
+            return ChildrenToVisit::none; // don't care about sizeof usage
+        if (isSameExpression(false, tok->astOperand1(), tok3, settings, true, false) && parent->isArithmeticalOp() && parent->isBinaryOp())
+            foundUndefined = true;
+        if (tok3->tokType() == Token::eIncDecOp && isSameExpression(false, tok->astOperand1(), tok3->astOperand1(), settings, true, false)) {
+            if (parent->isArithmeticalOp() && parent->isBinaryOp())
+                foundUndefined = true;
+            else
+                foundUnspecified = true;
+        }
+        return (foundUndefined || foundUnspecified) ? ChildrenToVisit::done : ChildrenToVisit::op1_and_op2;
+    });
+
+    return foundUndefined || foundUnspecified;
+}
 
 void CheckOther::checkEvaluationOrder()
 {
-    // This checker is not written according to C++11 sequencing rules
-    if (mTokenizer->isCPP() && mSettings->standards.cpp >= Standards::CPP11)
-        return;
-
+    logChecker("CheckOther::checkEvaluationOrder");
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * functionScope : symbolDatabase->functionScopes) {
         for (const Token* tok = functionScope->bodyStart; tok != functionScope->bodyEnd; tok = tok->next()) {
-            if (!Token::Match(tok, "++|--") && !tok->isAssignmentOp())
+            if (!tok->isIncDecOp() && !tok->isAssignmentOp())
                 continue;
             if (!tok->astOperand1())
                 continue;
+            if (isDesignatedInitializer(tok->astOperand1()))
+                continue;
             for (const Token *tok2 = tok;; tok2 = tok2->astParent()) {
                 // If ast parent is a sequence point then break
                 const Token * const parent = tok2->astParent();
@@ -2643,32 +3879,22 @@ void CheckOther::checkEvaluationOrder()
                 if (parent->str() == "(" && parent->astOperand2())
                     break;
 
-                // self assignment..
-                if (tok2 == tok &&
-                    tok->str() == "=" &&
-                    parent->str() == "=" &&
-                    isSameExpression(mTokenizer->isCPP(), false, tok->astOperand1(), parent->astOperand1(), mSettings->library, true, false)) {
-                    if (mSettings->isEnabled(Settings::WARNING) &&
-                        isSameExpression(mTokenizer->isCPP(), true, tok->astOperand1(), parent->astOperand1(), mSettings->library, true, false))
-                        selfAssignmentError(parent, tok->astOperand1()->expressionString());
-                    break;
+                bool foundError{false}, foundUnspecified{false}, bSelfAssignmentError{false};
+                if (mTokenizer->isCPP() && mSettings->standards.cpp >= Standards::CPP11) {
+                    if (mSettings->standards.cpp >= Standards::CPP17)
+                        foundError = checkEvaluationOrderCpp17(tok, tok2, parent, *mSettings, foundUnspecified);
+                    else
+                        foundError = checkEvaluationOrderCpp11(tok, tok2, parent, *mSettings);
                 }
-
-                // Is expression used?
-                bool foundError = false;
-                visitAstNodes((parent->astOperand1() != tok2) ? parent->astOperand1() : parent->astOperand2(),
-                [&](const Token *tok3) {
-                    if (tok3->str() == "&" && !tok3->astOperand2())
-                        return ChildrenToVisit::none; // don't handle address-of for now
-                    if (tok3->str() == "(" && Token::simpleMatch(tok3->previous(), "sizeof"))
-                        return ChildrenToVisit::none; // don't care about sizeof usage
-                    if (isSameExpression(mTokenizer->isCPP(), false, tok->astOperand1(), tok3, mSettings->library, true, false))
-                        foundError = true;
-                    return foundError ? ChildrenToVisit::done : ChildrenToVisit::op1_and_op2;
-                });
+                else
+                    foundError = checkEvaluationOrderC(tok, tok2, parent, *mSettings, bSelfAssignmentError);
 
                 if (foundError) {
-                    unknownEvaluationOrder(parent);
+                    unknownEvaluationOrder(parent, foundUnspecified);
+                    break;
+                }
+                if (bSelfAssignmentError) {
+                    selfAssignmentError(parent, tok->astOperand1()->expressionString());
                     break;
                 }
             }
@@ -2676,18 +3902,23 @@ void CheckOther::checkEvaluationOrder()
     }
 }
 
-void CheckOther::unknownEvaluationOrder(const Token* tok)
+void CheckOther::unknownEvaluationOrder(const Token* tok, bool isUnspecifiedBehavior)
 {
-    reportError(tok, Severity::error, "unknownEvaluationOrder",
-                "Expression '" + (tok ? tok->expressionString() : std::string("x = x++;")) + "' depends on order of evaluation of side effects", CWE768, false);
+    isUnspecifiedBehavior ?
+    reportError(tok, Severity::portability, "unknownEvaluationOrder",
+                "Expression '" + (tok ? tok->expressionString() : std::string("x++, x++")) + "' depends on order of evaluation of side effects. Behavior is Unspecified according to c++17", CWE768, Certainty::normal)
+    :   reportError(tok, Severity::error, "unknownEvaluationOrder",
+                    "Expression '" + (tok ? tok->expressionString() : std::string("x = x++;")) + "' depends on order of evaluation of side effects", CWE768, Certainty::normal);
 }
 
 void CheckOther::checkAccessOfMovedVariable()
 {
-    if (!mTokenizer->isCPP() || mSettings->standards.cpp < Standards::CPP11 || !mSettings->isEnabled(Settings::WARNING))
+    if (!mTokenizer->isCPP() || mSettings->standards.cpp < Standards::CPP11)
+        return;
+    if (!mSettings->isPremiumEnabled("accessMoved") && !mSettings->severity.isEnabled(Severity::warning))
         return;
-    CheckUninitVar checkUninitVar(mTokenizer, mSettings, mErrorLogger);
-    const bool reportInconclusive = mSettings->inconclusive;
+    logChecker("CheckOther::checkAccessOfMovedVariable"); // c++11,warning
+    const bool reportInconclusive = mSettings->certainty.isEnabled(Certainty::inconclusive);
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         const Token * scopeStart = scope->bodyStart;
@@ -2697,6 +3928,8 @@ void CheckOther::checkAccessOfMovedVariable()
                 scopeStart = memberInitializationStart;
         }
         for (const Token* tok = scopeStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
+            if (!tok->astParent())
+                continue;
             const ValueFlow::Value * movedValue = tok->getMovedValue();
             if (!movedValue || movedValue->moveKind == ValueFlow::Value::MoveKind::NonMovedVariable)
                 continue;
@@ -2711,13 +3944,13 @@ void CheckOther::checkAccessOfMovedVariable()
                 else
                     inconclusive = true;
             } else {
-                const bool isVariableChanged = isVariableChangedByFunctionCall(tok, 0, mSettings, &inconclusive);
-                accessOfMoved = !isVariableChanged && checkUninitVar.isVariableUsage(tok, false, CheckUninitVar::NO_ALLOC);
-                if (inconclusive) {
-                    accessOfMoved = !isMovedParameterAllowedForInconclusiveFunction(tok);
-                    if (accessOfMoved)
-                        inconclusive = false;
-                }
+                const ExprUsage usage = getExprUsage(tok, 0, *mSettings);
+                if (usage == ExprUsage::Used)
+                    accessOfMoved = true;
+                if (usage == ExprUsage::PassedByReference)
+                    accessOfMoved = !isVariableChangedByFunctionCall(tok, 0, *mSettings, &inconclusive);
+                else if (usage == ExprUsage::Inconclusive)
+                    inconclusive = true;
             }
             if (accessOfMoved || (inconclusive && reportInconclusive))
                 accessMovedError(tok, tok->str(), movedValue, inconclusive || movedValue->isInconclusive());
@@ -2725,24 +3958,11 @@ void CheckOther::checkAccessOfMovedVariable()
     }
 }
 
-bool CheckOther::isMovedParameterAllowedForInconclusiveFunction(const Token * tok)
-{
-    if (Token::simpleMatch(tok->tokAt(-4), "std :: move ("))
-        return false;
-    const Token * tokAtM2 = tok->tokAt(-2);
-    if (Token::simpleMatch(tokAtM2, "> (") && tokAtM2->link()) {
-        const Token * leftAngle = tokAtM2->link();
-        if (Token::simpleMatch(leftAngle->tokAt(-3), "std :: forward <"))
-            return false;
-    }
-    return true;
-}
-
 void CheckOther::accessMovedError(const Token *tok, const std::string &varname, const ValueFlow::Value *value, bool inconclusive)
 {
     if (!tok) {
-        reportError(tok, Severity::warning, "accessMoved", "Access of moved variable 'v'.", CWE672, false);
-        reportError(tok, Severity::warning, "accessForwarded", "Access of forwarded variable 'v'.", CWE672, false);
+        reportError(tok, Severity::warning, "accessMoved", "Access of moved variable 'v'.", CWE672, Certainty::normal);
+        reportError(tok, Severity::warning, "accessForwarded", "Access of forwarded variable 'v'.", CWE672, Certainty::normal);
         return;
     }
 
@@ -2761,21 +3981,23 @@ void CheckOther::accessMovedError(const Token *tok, const std::string &varname,
         return;
     }
     const std::string errmsg("$symbol:" + varname + "\nAccess of " + kindString + " variable '$symbol'.");
-    const ErrorPath errorPath = getErrorPath(tok, value, errmsg);
-    reportError(errorPath, Severity::warning, errorId, errmsg, CWE672, inconclusive);
+    ErrorPath errorPath = getErrorPath(tok, value, errmsg);
+    reportError(std::move(errorPath), Severity::warning, errorId, errmsg, CWE672, inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
 
 
 void CheckOther::checkFuncArgNamesDifferent()
 {
-    const bool style = mSettings->isEnabled(Settings::STYLE);
-    const bool inconclusive = mSettings->inconclusive;
-    const bool warning = mSettings->isEnabled(Settings::WARNING);
+    const bool style = mSettings->severity.isEnabled(Severity::style);
+    const bool inconclusive = mSettings->certainty.isEnabled(Certainty::inconclusive);
+    const bool warning = mSettings->severity.isEnabled(Severity::warning);
 
-    if (!(warning || (style && inconclusive)))
+    if (!(warning || (style && inconclusive)) && !mSettings->isPremiumEnabled("funcArgNamesDifferent"))
         return;
 
+    logChecker("CheckOther::checkFuncArgNamesDifferent"); // style,warning,inconclusive
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     // check every function
     for (const Scope *scope : symbolDatabase->functionScopes) {
@@ -2854,9 +4076,9 @@ void CheckOther::funcArgNamesDifferent(const std::string & functionName, nonneg
     std::list<const Token *> tokens = { declaration,definition };
     reportError(tokens, Severity::style, "funcArgNamesDifferent",
                 "$symbol:" + functionName + "\n"
-                "Function '$symbol' argument " + MathLib::toString(index + 1) + " names different: declaration '" +
+                "Function '$symbol' argument " + std::to_string(index + 1) + " names different: declaration '" +
                 (declaration ? declaration->str() : std::string("A")) + "' definition '" +
-                (definition ? definition->str() : std::string("B")) + "'.", CWE628, true);
+                (definition ? definition->str() : std::string("B")) + "'.", CWE628, Certainty::inconclusive);
 }
 
 void CheckOther::funcArgOrderDifferent(const std::string & functionName,
@@ -2865,159 +4087,296 @@ void CheckOther::funcArgOrderDifferent(const std::string & functionName,
                                        const std::vector<const Token *> & definitions)
 {
     std::list<const Token *> tokens = {
-        declarations.size() ? declarations[0] ? declarations[0] : declaration : nullptr,
-        definitions.size() ? definitions[0] ? definitions[0] : definition : nullptr
+        !declarations.empty() ? declarations[0] ? declarations[0] : declaration : nullptr,
+        !definitions.empty() ? definitions[0] ? definitions[0] : definition : nullptr
     };
     std::string msg = "$symbol:" + functionName + "\nFunction '$symbol' argument order different: declaration '";
-    for (int i = 0; i < declarations.size(); ++i) {
+    for (std::size_t i = 0; i < declarations.size(); ++i) {
         if (i != 0)
             msg += ", ";
         if (declarations[i])
             msg += declarations[i]->str();
     }
     msg += "' definition '";
-    for (int i = 0; i < definitions.size(); ++i) {
+    for (std::size_t i = 0; i < definitions.size(); ++i) {
         if (i != 0)
             msg += ", ";
         if (definitions[i])
             msg += definitions[i]->str();
     }
     msg += "'";
-    reportError(tokens, Severity::warning, "funcArgOrderDifferent", msg, CWE683, false);
+    reportError(tokens, Severity::warning, "funcArgOrderDifferent", msg, CWE683, Certainty::normal);
 }
 
-static const Token *findShadowed(const Scope *scope, const std::string &varname, int linenr)
+static const Token *findShadowed(const Scope *scope, const Variable& var, int linenr)
 {
     if (!scope)
         return nullptr;
-    for (const Variable &var : scope->varlist) {
-        if (scope->isExecutable() && var.nameToken()->linenr() > linenr)
+    for (const Variable &v : scope->varlist) {
+        if (scope->isExecutable() && v.nameToken()->linenr() > linenr)
             continue;
-        if (var.name() == varname)
-            return var.nameToken();
+        if (v.name() == var.name())
+            return v.nameToken();
     }
-    for (const Function &f : scope->functionList) {
-        if (f.name() == varname)
-            return f.tokenDef;
-    }
-    if (scope->type == Scope::eLambda)
+    auto it = std::find_if(scope->functionList.cbegin(), scope->functionList.cend(), [&](const Function& f) {
+        return f.type == FunctionType::eFunction && f.name() == var.name() && precedes(f.tokenDef, var.nameToken());
+    });
+    if (it != scope->functionList.end())
+        return it->tokenDef;
+
+    if (scope->type == ScopeType::eLambda)
         return nullptr;
-    return findShadowed(scope->nestedIn, varname, linenr);
+    const Token* shadowed = findShadowed(scope->nestedIn, var, linenr);
+    if (!shadowed)
+        shadowed = findShadowed(scope->functionOf, var, linenr);
+    return shadowed;
 }
 
 void CheckOther::checkShadowVariables()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("shadowVariable"))
         return;
+    logChecker("CheckOther::checkShadowVariables"); // style
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope & scope : symbolDatabase->scopeList) {
-        if (!scope.isExecutable() || scope.type == Scope::eLambda)
+        if (!scope.isExecutable() || scope.type == ScopeType::eLambda)
             continue;
         const Scope *functionScope = &scope;
-        while (functionScope && functionScope->type != Scope::ScopeType::eFunction && functionScope->type != Scope::ScopeType::eLambda)
+        while (functionScope && functionScope->type != ScopeType::eFunction && functionScope->type != ScopeType::eLambda)
             functionScope = functionScope->nestedIn;
         for (const Variable &var : scope.varlist) {
-            if (functionScope && functionScope->type == Scope::ScopeType::eFunction && functionScope->function) {
-                bool shadowArg = false;
-                for (const Variable &arg : functionScope->function->argumentList) {
-                    if (arg.nameToken() && var.name() == arg.name()) {
-                        shadowError(var.nameToken(), arg.nameToken(), "argument");
-                        shadowArg = true;
-                        break;
-                    }
-                }
-                if (shadowArg)
+            if (var.nameToken() && var.nameToken()->isExpandedMacro()) // #8903
+                continue;
+
+            if (functionScope && functionScope->type == ScopeType::eFunction && functionScope->function) {
+                const auto & argList = functionScope->function->argumentList;
+                auto it = std::find_if(argList.cbegin(), argList.cend(), [&](const Variable& arg) {
+                    return arg.nameToken() && var.name() == arg.name();
+                });
+                if (it != argList.end()) {
+                    shadowError(var.nameToken(), it->nameToken(), "argument");
                     continue;
+                }
             }
 
-            const Token *shadowed = findShadowed(scope.nestedIn, var.name(), var.nameToken()->linenr());
+            const Token *shadowed = findShadowed(scope.nestedIn, var, var.nameToken()->linenr());
+            if (!shadowed)
+                shadowed = findShadowed(scope.functionOf, var, var.nameToken()->linenr());
             if (!shadowed)
                 continue;
-            if (scope.type == Scope::eFunction && scope.className == var.name())
+            if (scope.type == ScopeType::eFunction && scope.className == var.name())
+                continue;
+            if (functionScope->functionOf && functionScope->functionOf->isClassOrStructOrUnion() && functionScope->function &&
+                (functionScope->function->isStatic() || functionScope->function->isFriend()) &&
+                shadowed->variable() && !shadowed->variable()->isLocal())
                 continue;
             shadowError(var.nameToken(), shadowed, (shadowed->varId() != 0) ? "variable" : "function");
         }
     }
 }
 
-void CheckOther::shadowError(const Token *var, const Token *shadowed, std::string type)
+void CheckOther::shadowError(const Token *var, const Token *shadowed, const std::string& type)
 {
     ErrorPath errorPath;
-    errorPath.push_back(ErrorPathItem(shadowed, "Shadowed declaration"));
-    errorPath.push_back(ErrorPathItem(var, "Shadow variable"));
+    errorPath.emplace_back(shadowed, "Shadowed declaration");
+    errorPath.emplace_back(var, "Shadow variable");
     const std::string &varname = var ? var->str() : type;
     const std::string Type = char(std::toupper(type[0])) + type.substr(1);
     const std::string id = "shadow" + Type;
     const std::string message = "$symbol:" + varname + "\nLocal variable \'$symbol\' shadows outer " + type;
-    reportError(errorPath, Severity::style, id.c_str(), message, CWE398, false);
+    reportError(std::move(errorPath), Severity::style, id.c_str(), message, CWE398, Certainty::normal);
 }
 
 static bool isVariableExpression(const Token* tok)
 {
-    if (Token::Match(tok, "%var%"))
+    if (tok->varId() != 0)
         return true;
     if (Token::simpleMatch(tok, "."))
         return isVariableExpression(tok->astOperand1()) &&
                isVariableExpression(tok->astOperand2());
+    if (Token::simpleMatch(tok, "["))
+        return isVariableExpression(tok->astOperand1());
+    return false;
+}
+
+static bool isVariableExprHidden(const Token* tok)
+{
+    if (!tok)
+        return false;
+    if (!tok->astParent())
+        return false;
+    if (Token::simpleMatch(tok->astParent(), "*") && Token::simpleMatch(tok->astSibling(), "0"))
+        return true;
+    if (Token::simpleMatch(tok->astParent(), "&&") && Token::simpleMatch(tok->astSibling(), "false"))
+        return true;
+    if (Token::simpleMatch(tok->astParent(), "||") && Token::simpleMatch(tok->astSibling(), "true"))
+        return true;
     return false;
 }
 
-void CheckOther::checkConstArgument()
+void CheckOther::checkKnownArgument()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("knownArgument"))
         return;
+    logChecker("CheckOther::checkKnownArgument"); // style
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope *functionScope : symbolDatabase->functionScopes) {
         for (const Token *tok = functionScope->bodyStart; tok != functionScope->bodyEnd; tok = tok->next()) {
-            if (!Token::simpleMatch(tok->astParent(), "("))
+            if (!tok->hasKnownIntValue() || tok->isExpandedMacro())
                 continue;
-            if (!Token::Match(tok->astParent()->previous(), "%name%"))
+            if (Token::Match(tok, "++|--|%assign%"))
                 continue;
-            if (Token::Match(tok->astParent()->previous(), "if|while|switch|sizeof"))
+            if (!Token::Match(tok->astParent(), "(|{|,"))
                 continue;
-            if (tok == tok->astParent()->previous())
+            if (tok->astParent()->isCast() || (tok->isCast() && Token::Match(tok->astOperand2(), "++|--|%assign%")))
                 continue;
-            if (!tok->hasKnownIntValue())
+            int argn = -1;
+            const Token* ftok = getTokenArgumentFunction(tok, argn);
+            if (!ftok)
+                continue;
+            if (ftok->isCast())
                 continue;
-            if (Token::Match(tok, "++|--"))
+            if (Token::Match(ftok, "if|while|switch|sizeof"))
+                continue;
+            if (tok == tok->astParent()->previous())
                 continue;
             if (isConstVarExpression(tok))
                 continue;
+            if (Token::Match(tok->astOperand1(), "%name% ("))
+                continue;
             const Token * tok2 = tok;
             if (isCPPCast(tok2))
                 tok2 = tok2->astOperand2();
             if (isVariableExpression(tok2))
                 continue;
-            constArgumentError(tok, tok->astParent()->previous(), &tok->values().front());
+            if (tok->isComparisonOp() &&
+                isSameExpression(
+                    true, tok->astOperand1(), tok->astOperand2(), *mSettings, true, true))
+                continue;
+            // ensure that there is a integer variable in expression with unknown value
+            const Token* vartok = nullptr;
+            visitAstNodes(tok, [&](const Token* child) {
+                if (Token::Match(child, "%var%|.|[")) {
+                    if (child->hasKnownIntValue())
+                        return ChildrenToVisit::none;
+                    if (astIsIntegral(child, false) && !astIsPointer(child) && child->values().empty()) {
+                        vartok = child;
+                        return ChildrenToVisit::done;
+                    }
+                }
+                return ChildrenToVisit::op1_and_op2;
+            });
+            if (!vartok)
+                continue;
+            if (vartok->astSibling() &&
+                findAstNode(vartok->astSibling(), [](const Token* child) {
+                return Token::simpleMatch(child, "sizeof");
+            }))
+                continue;
+            // ensure that function name does not contain "assert"
+            std::string funcname = ftok->str();
+            strTolower(funcname);
+            if (funcname.find("assert") != std::string::npos)
+                continue;
+            knownArgumentError(tok, ftok, &tok->values().front(), vartok->expressionString(), isVariableExprHidden(vartok));
         }
     }
 }
 
-void CheckOther::constArgumentError(const Token *tok, const Token *ftok, const ValueFlow::Value *value)
+void CheckOther::knownArgumentError(const Token *tok, const Token *ftok, const ValueFlow::Value *value, const std::string &varexpr, bool isVariableExpressionHidden)
+{
+    if (!tok) {
+        reportError(tok, Severity::style, "knownArgument", "Argument 'x-x' to function 'func' is always 0. It does not matter what value 'x' has.");
+        reportError(tok, Severity::style, "knownArgumentHiddenVariableExpression", "Argument 'x*0' to function 'func' is always 0. Constant literal calculation disable/hide variable expression 'x'.");
+        return;
+    }
+
+    const MathLib::bigint intvalue = value->intvalue;
+    const std::string &expr = tok->expressionString();
+    const std::string &fun = ftok->str();
+
+    std::string ftype = "function ";
+    if (ftok->type())
+        ftype = "constructor ";
+    else if (fun == "{")
+        ftype = "init list ";
+
+    const char *id;
+    std::string errmsg = "Argument '" + expr + "' to " + ftype + fun + " is always " + MathLib::toString(intvalue) + ". ";
+    if (!isVariableExpressionHidden) {
+        id = "knownArgument";
+        errmsg += "It does not matter what value '" + varexpr + "' has.";
+    } else {
+        id = "knownArgumentHiddenVariableExpression";
+        errmsg += "Constant literal calculation disable/hide variable expression '" + varexpr + "'.";
+    }
+
+    ErrorPath errorPath = getErrorPath(tok, value, errmsg);
+    reportError(std::move(errorPath), Severity::style, id, errmsg, CWE570, Certainty::normal);
+}
+
+void CheckOther::checkKnownPointerToBool()
 {
-    MathLib::bigint intvalue = value ? value->intvalue : 0;
-    const std::string expr = tok ? tok->expressionString() : std::string("x");
-    const std::string fun = ftok ? ftok->str() : std::string("f");
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("knownPointerToBool"))
+        return;
+    logChecker("CheckOther::checkKnownPointerToBool"); // style
+    const SymbolDatabase* symbolDatabase = mTokenizer->getSymbolDatabase();
+    for (const Scope* functionScope : symbolDatabase->functionScopes) {
+        for (const Token* tok = functionScope->bodyStart; tok != functionScope->bodyEnd; tok = tok->next()) {
+            if (!tok->hasKnownIntValue())
+                continue;
+            if (!astIsPointer(tok))
+                continue;
+            if (Token::Match(tok->astParent(), "?|!|&&|%oror%|%comp%"))
+                continue;
+            if (tok->astParent() && Token::Match(tok->astParent()->previous(), "if|while|switch|sizeof ("))
+                continue;
+            if (tok->isExpandedMacro())
+                continue;
+            if (findParent(tok, [](const Token* parent) {
+                return parent->isExpandedMacro();
+            }))
+                continue;
+            if (!isUsedAsBool(tok, *mSettings))
+                continue;
+            const ValueFlow::Value& value = tok->values().front();
+            knownPointerToBoolError(tok, &value);
+        }
+    }
+}
 
-    const std::string errmsg = "Argument '" + expr + "' to function " + fun + " is always " + std::to_string(intvalue);
-    const ErrorPath errorPath = getErrorPath(tok, value, errmsg);
-    reportError(errorPath, Severity::style, "constArgument", errmsg, CWE570, false);
+void CheckOther::knownPointerToBoolError(const Token* tok, const ValueFlow::Value* value)
+{
+    if (!tok) {
+        reportError(tok, Severity::style, "knownPointerToBool", "Pointer expression 'p' converted to bool is always true.");
+        return;
+    }
+    std::string cond = bool_to_string(!!value->intvalue);
+    const std::string& expr = tok->expressionString();
+    std::string errmsg = "Pointer expression '" + expr + "' converted to bool is always " + cond + ".";
+    ErrorPath errorPath = getErrorPath(tok, value, errmsg);
+    reportError(std::move(errorPath), Severity::style, "knownPointerToBool", errmsg, CWE570, Certainty::normal);
 }
 
 void CheckOther::checkComparePointers()
 {
+    logChecker("CheckOther::checkComparePointers");
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope *functionScope : symbolDatabase->functionScopes) {
         for (const Token *tok = functionScope->bodyStart; tok != functionScope->bodyEnd; tok = tok->next()) {
             if (!Token::Match(tok, "<|>|<=|>=|-"))
                 continue;
             const Token *tok1 = tok->astOperand1();
+            if (!astIsPointer(tok1))
+                continue;
             const Token *tok2 = tok->astOperand2();
-            if (!astIsPointer(tok1) || !astIsPointer(tok2))
+            if (!astIsPointer(tok2))
+                continue;
+            ValueFlow::Value v1 = ValueFlow::getLifetimeObjValue(tok1);
+            if (!v1.isLocalLifetimeValue())
                 continue;
-            ValueFlow::Value v1 = getLifetimeObjValue(tok1);
-            ValueFlow::Value v2 = getLifetimeObjValue(tok2);
-            if (!v1.isLocalLifetimeValue() || !v2.isLocalLifetimeValue())
+            ValueFlow::Value v2 = ValueFlow::getLifetimeObjValue(tok2);
+            if (!v2.isLocalLifetimeValue())
                 continue;
             const Variable *var1 = v1.tokvalue->variable();
             const Variable *var2 = v2.tokvalue->variable();
@@ -3029,6 +4388,12 @@ void CheckOther::checkComparePointers()
                 continue;
             if (var1->isRValueReference() || var2->isRValueReference())
                 continue;
+            if (const Token* parent2 = getParentLifetime(v2.tokvalue, mSettings->library))
+                if (var1 == parent2->variable())
+                    continue;
+            if (const Token* parent1 = getParentLifetime(v1.tokvalue, mSettings->library))
+                if (var2 == parent1->variable())
+                    continue;
             comparePointersError(tok, &v1, &v2);
         }
     }
@@ -3040,15 +4405,479 @@ void CheckOther::comparePointersError(const Token *tok, const ValueFlow::Value *
     std::string verb = "Comparing";
     if (Token::simpleMatch(tok, "-"))
         verb = "Subtracting";
+    const char * const id = (verb[0] == 'C') ? "comparePointers" : "subtractPointers";
     if (v1) {
         errorPath.emplace_back(v1->tokvalue->variable()->nameToken(), "Variable declared here.");
-        errorPath.insert(errorPath.end(), v1->errorPath.begin(), v1->errorPath.end());
+        errorPath.insert(errorPath.end(), v1->errorPath.cbegin(), v1->errorPath.cend());
     }
     if (v2) {
         errorPath.emplace_back(v2->tokvalue->variable()->nameToken(), "Variable declared here.");
-        errorPath.insert(errorPath.end(), v2->errorPath.begin(), v2->errorPath.end());
+        errorPath.insert(errorPath.end(), v2->errorPath.cbegin(), v2->errorPath.cend());
     }
     errorPath.emplace_back(tok, "");
     reportError(
-        errorPath, Severity::error, "comparePointers", verb + " pointers that point to different objects", CWE570, false);
+        std::move(errorPath), Severity::error, id, verb + " pointers that point to different objects", CWE758, Certainty::normal);
+}
+
+void CheckOther::checkModuloOfOne()
+{
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("moduloofone"))
+        return;
+
+    logChecker("CheckOther::checkModuloOfOne"); // style
+
+    for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
+        if (!tok->astOperand2() || !tok->astOperand1())
+            continue;
+        if (tok->str() != "%" && tok->str() != "%=")
+            continue;
+        if (!tok->valueType() || !tok->valueType()->isIntegral())
+            continue;
+
+        // Value flow..
+        const ValueFlow::Value *value = tok->astOperand2()->getValue(1LL);
+        if (value && value->isKnown())
+            checkModuloOfOneError(tok);
+    }
+}
+
+void CheckOther::checkModuloOfOneError(const Token *tok)
+{
+    reportError(tok, Severity::style, "moduloofone", "Modulo of one is always equal to zero");
+}
+
+static const std::string noname;
+
+struct UnionMember {
+    UnionMember()
+        : name(noname)
+        , size(0) {}
+
+    UnionMember(const std::string &name, size_t size)
+        : name(name)
+        , size(size) {}
+
+    const std::string &name;
+    size_t size;
+};
+
+struct Union {
+    explicit Union(const Scope &scope)
+        : scope(&scope)
+        , name(scope.className) {}
+
+    const Scope *scope;
+    const std::string &name;
+    std::vector<UnionMember> members;
+
+    const UnionMember *largestMember() const {
+        const UnionMember *largest = nullptr;
+        for (const UnionMember &m : members) {
+            if (m.size == 0)
+                return nullptr;
+            if (largest == nullptr || m.size > largest->size)
+                largest = &m;
+        }
+        return largest;
+    }
+
+    bool isLargestMemberFirst() const {
+        const UnionMember *largest = largestMember();
+        return largest == nullptr || largest == &members[0];
+    }
+};
+
+static UnionMember parseUnionMember(const Variable &var,
+                                    const Settings &settings)
+{
+    const Token *nameToken = var.nameToken();
+    if (nameToken == nullptr)
+        return UnionMember();
+
+    const ValueType *vt = nameToken->valueType();
+    size_t size = 0;
+    if (var.isArray()) {
+        size = var.dimension(0);
+    } else if (vt != nullptr) {
+        size = vt->getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer);
+    }
+    return UnionMember(nameToken->str(), size);
+}
+
+static std::vector<Union> parseUnions(const SymbolDatabase &symbolDatabase,
+                                      const Settings &settings)
+{
+    std::vector<Union> unions;
+
+    for (const Scope &scope : symbolDatabase.scopeList) {
+        if (scope.type != ScopeType::eUnion)
+            continue;
+
+        Union u(scope);
+        for (const Variable &var : scope.varlist) {
+            u.members.push_back(parseUnionMember(var, settings));
+        }
+        unions.push_back(std::move(u));
+    }
+
+    return unions;
+}
+
+static bool isZeroInitializer(const Token *tok)
+{
+    return Token::Match(tok, "= { 0| } ;");
+}
+
+
+void CheckOther::checkUnionZeroInit()
+{
+    if (!mSettings->severity.isEnabled(Severity::portability))
+        return;
+
+    logChecker("CheckOther::checkUnionZeroInit"); // portability
+
+    const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
+
+    std::unordered_map<const Scope *, Union> unionsByScopeId;
+    const std::vector<Union> unions = parseUnions(*symbolDatabase, *mSettings);
+    for (const Union &u : unions) {
+        unionsByScopeId.emplace(u.scope, u);
+    }
+
+    for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
+        if (!tok->isName() || !isZeroInitializer(tok->next()))
+            continue;
+
+        const ValueType *vt = tok->valueType();
+        if (vt == nullptr || vt->typeScope == nullptr)
+            continue;
+        auto it = unionsByScopeId.find(vt->typeScope);
+        if (it == unionsByScopeId.end())
+            continue;
+        const Union &u = it->second;
+        if (!u.isLargestMemberFirst()) {
+            const UnionMember *largestMember = u.largestMember();
+            if (largestMember == nullptr) {
+                throw InternalError(tok, "Largest union member not found",
+                                    InternalError::INTERNAL);
+            }
+            assert(largestMember != nullptr);
+            unionZeroInitError(tok, *largestMember);
+        }
+    }
+}
+
+void CheckOther::unionZeroInitError(const Token *tok,
+                                    const UnionMember& largestMember)
+{
+    reportError(tok, Severity::portability, "UnionZeroInit",
+                (tok != nullptr ? "$symbol:" + tok->str() + "\n" : "") +
+                "Zero initializing union '$symbol' does not guarantee " +
+                "its complete storage to be zero initialized as its largest member " +
+                "is not declared as the first member. Consider making " +
+                largestMember.name + " the first member or favor memset().");
+}
+
+//-----------------------------------------------------------------------------
+// Overlapping write (undefined behavior)
+//-----------------------------------------------------------------------------
+static bool getBufAndOffset(const Token *expr, const Token *&buf, MathLib::bigint *offset, const Settings& settings, MathLib::bigint* sizeValue = nullptr)
+{
+    if (!expr)
+        return false;
+    const Token *bufToken, *offsetToken;
+    MathLib::bigint elementSize = 0;
+    if (expr->isUnaryOp("&") && Token::simpleMatch(expr->astOperand1(), "[")) {
+        bufToken = expr->astOperand1()->astOperand1();
+        offsetToken = expr->astOperand1()->astOperand2();
+        if (expr->astOperand1()->valueType())
+            elementSize = expr->astOperand1()->valueType()->getSizeOf(settings, ValueType::Accuracy::LowerBound, ValueType::SizeOf::Pointer);
+    } else if (Token::Match(expr, "+|-") && expr->isBinaryOp()) {
+        const bool pointer1 = (expr->astOperand1()->valueType() && expr->astOperand1()->valueType()->pointer > 0);
+        const bool pointer2 = (expr->astOperand2()->valueType() && expr->astOperand2()->valueType()->pointer > 0);
+        if (pointer1 && !pointer2) {
+            bufToken = expr->astOperand1();
+            offsetToken = expr->astOperand2();
+            auto vt = *expr->astOperand1()->valueType();
+            --vt.pointer;
+            elementSize = vt.getSizeOf(settings, ValueType::Accuracy::LowerBound, ValueType::SizeOf::Pointer);
+        } else if (!pointer1 && pointer2) {
+            bufToken = expr->astOperand2();
+            offsetToken = expr->astOperand1();
+            auto vt = *expr->astOperand2()->valueType();
+            --vt.pointer;
+            elementSize = vt.getSizeOf(settings, ValueType::Accuracy::LowerBound, ValueType::SizeOf::Pointer);
+        } else {
+            return false;
+        }
+    } else if (expr->valueType() && expr->valueType()->pointer > 0) {
+        buf = expr;
+        *offset = 0;
+        auto vt = *expr->valueType();
+        --vt.pointer;
+        elementSize = vt.getSizeOf(settings, ValueType::Accuracy::LowerBound, ValueType::SizeOf::Pointer);
+        if (elementSize > 0) {
+            *offset *= elementSize;
+            if (sizeValue)
+                *sizeValue *= elementSize;
+        }
+        return true;
+    } else {
+        return false;
+    }
+    if (!bufToken->valueType() || !bufToken->valueType()->pointer)
+        return false;
+    if (!offsetToken->hasKnownIntValue())
+        return false;
+    buf = bufToken;
+    *offset = offsetToken->getKnownIntValue();
+    if (elementSize > 0) {
+        *offset *= elementSize;
+        if (sizeValue)
+            *sizeValue *= elementSize;
+    }
+    return true;
+}
+
+void CheckOther::checkOverlappingWrite()
+{
+    logChecker("CheckOther::checkOverlappingWrite");
+    const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
+    for (const Scope *functionScope : symbolDatabase->functionScopes) {
+        for (const Token *tok = functionScope->bodyStart; tok != functionScope->bodyEnd; tok = tok->next()) {
+            if (tok->isAssignmentOp()) {
+                // check if LHS is a union member..
+                const Token * const lhs = tok->astOperand1();
+                if (!Token::simpleMatch(lhs, ".") || !lhs->isBinaryOp())
+                    continue;
+                const Variable * const lhsvar = lhs->astOperand1()->variable();
+                if (!lhsvar || !lhsvar->typeScope() || lhsvar->typeScope()->type != ScopeType::eUnion)
+                    continue;
+                const Token* const lhsmember = lhs->astOperand2();
+                if (!lhsmember)
+                    continue;
+
+                // Is other union member used in RHS?
+                const Token *errorToken = nullptr;
+                visitAstNodes(tok->astOperand2(), [lhsvar, lhsmember, &errorToken](const Token *rhs) {
+                    if (!Token::simpleMatch(rhs, "."))
+                        return ChildrenToVisit::op1_and_op2;
+                    if (!rhs->isBinaryOp() || rhs->astOperand1()->variable() != lhsvar)
+                        return ChildrenToVisit::none;
+                    if (lhsmember->str() == rhs->astOperand2()->str())
+                        return ChildrenToVisit::none;
+                    const Variable* rhsmembervar = rhs->astOperand2()->variable();
+                    const Scope* varscope1 = lhsmember->variable() ? lhsmember->variable()->typeStartToken()->scope() : nullptr;
+                    const Scope* varscope2 = rhsmembervar ? rhsmembervar->typeStartToken()->scope() : nullptr;
+                    if (varscope1 && varscope1 == varscope2 && varscope1 != lhsvar->typeScope())
+                        // lhsmember and rhsmember are declared in same anonymous scope inside union
+                        return ChildrenToVisit::none;
+                    errorToken = rhs->astOperand2();
+                    return ChildrenToVisit::done;
+                });
+                if (errorToken)
+                    overlappingWriteUnion(tok);
+            } else if (Token::Match(tok, "%name% (")) {
+                const Library::NonOverlappingData *nonOverlappingData = mSettings->library.getNonOverlappingData(tok);
+                if (!nonOverlappingData)
+                    continue;
+                const std::vector<const Token *> args = getArguments(tok);
+                if (nonOverlappingData->ptr1Arg <= 0 || nonOverlappingData->ptr1Arg > args.size())
+                    continue;
+                if (nonOverlappingData->ptr2Arg <= 0 || nonOverlappingData->ptr2Arg > args.size())
+                    continue;
+
+                const Token *ptr1 = args[nonOverlappingData->ptr1Arg - 1];
+                if (ptr1->hasKnownIntValue() && ptr1->getKnownIntValue() == 0)
+                    continue;
+
+                const Token *ptr2 = args[nonOverlappingData->ptr2Arg - 1];
+                if (ptr2->hasKnownIntValue() && ptr2->getKnownIntValue() == 0)
+                    continue;
+
+                // TODO: nonOverlappingData->strlenArg
+                const int sizeArg = std::max(nonOverlappingData->sizeArg, nonOverlappingData->countArg);
+                if (sizeArg <= 0 || sizeArg > args.size()) {
+                    if (nonOverlappingData->sizeArg == -1) {
+                        ErrorPath errorPath;
+                        constexpr bool macro = true;
+                        constexpr bool pure = true;
+                        constexpr bool follow = true;
+                        if (!isSameExpression(macro, ptr1, ptr2, *mSettings, pure, follow, &errorPath))
+                            continue;
+                        overlappingWriteFunction(tok, tok->str());
+                    }
+                    continue;
+                }
+                const bool isCountArg = nonOverlappingData->countArg > 0;
+                if (!args[sizeArg-1]->hasKnownIntValue())
+                    continue;
+                MathLib::bigint sizeValue = args[sizeArg-1]->getKnownIntValue();
+                const Token *buf1, *buf2;
+                MathLib::bigint offset1, offset2;
+                if (!getBufAndOffset(ptr1, buf1, &offset1, *mSettings, isCountArg ? &sizeValue : nullptr))
+                    continue;
+                if (!getBufAndOffset(ptr2, buf2, &offset2, *mSettings))
+                    continue;
+
+                if (offset1 < offset2 && offset1 + sizeValue <= offset2)
+                    continue;
+                if (offset2 < offset1 && offset2 + sizeValue <= offset1)
+                    continue;
+
+                ErrorPath errorPath;
+                constexpr bool macro = true;
+                constexpr bool pure = true;
+                constexpr bool follow = true;
+                if (!isSameExpression(macro, buf1, buf2, *mSettings, pure, follow, &errorPath))
+                    continue;
+                overlappingWriteFunction(tok, tok->str());
+            }
+        }
+    }
+}
+
+void CheckOther::overlappingWriteUnion(const Token *tok)
+{
+    reportError(tok, Severity::error, "overlappingWriteUnion", "Overlapping read/write of union is undefined behavior");
+}
+
+void CheckOther::overlappingWriteFunction(const Token *tok, const std::string& funcname)
+{
+    reportError(tok, Severity::error, "overlappingWriteFunction", "Overlapping read/write in " + funcname + "() is undefined behavior");
+}
+
+void CheckOther::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    CheckOther checkOther(&tokenizer, &tokenizer.getSettings(), errorLogger);
+
+    // Checks
+    checkOther.warningOldStylePointerCast();
+    checkOther.warningDangerousTypeCast();
+    checkOther.warningIntToPointerCast();
+    checkOther.suspiciousFloatingPointCast();
+    checkOther.invalidPointerCast();
+    checkOther.checkCharVariable();
+    checkOther.redundantBitwiseOperationInSwitchError();
+    checkOther.checkSuspiciousCaseInSwitch();
+    checkOther.checkDuplicateBranch();
+    checkOther.checkDuplicateExpression();
+    checkOther.checkRedundantAssignment();
+    checkOther.checkUnreachableCode();
+    checkOther.checkSuspiciousSemicolon();
+    checkOther.checkVariableScope();
+    checkOther.checkSignOfUnsignedVariable();  // don't ignore casts (#3574)
+    checkOther.checkIncompleteArrayFill();
+    checkOther.checkVarFuncNullUB();
+    checkOther.checkNanInArithmeticExpression();
+    checkOther.checkCommaSeparatedReturn();
+    checkOther.checkRedundantPointerOp();
+    checkOther.checkZeroDivision();
+    checkOther.checkNegativeBitwiseShift();
+    checkOther.checkInterlockedDecrement();
+    checkOther.checkUnusedLabel();
+    checkOther.checkEvaluationOrder();
+    checkOther.checkFuncArgNamesDifferent();
+    checkOther.checkShadowVariables();
+    checkOther.checkKnownArgument();
+    checkOther.checkKnownPointerToBool();
+    checkOther.checkComparePointers();
+    checkOther.checkIncompleteStatement();
+    checkOther.checkRedundantCopy();
+    checkOther.clarifyCalculation();
+    checkOther.checkPassByReference();
+    checkOther.checkConstVariable();
+    checkOther.checkConstPointer();
+    checkOther.checkComparisonFunctionIsAlwaysTrueOrFalse();
+    checkOther.checkInvalidFree();
+    checkOther.clarifyStatement();
+    checkOther.checkCastIntToCharAndBack();
+    checkOther.checkMisusedScopedObject();
+    checkOther.checkAccessOfMovedVariable();
+    checkOther.checkModuloOfOne();
+    checkOther.checkOverlappingWrite();
+    checkOther.checkUnionZeroInit();
+}
+
+void CheckOther::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const
+{
+    CheckOther c(nullptr, settings, errorLogger);
+
+    // error
+    c.zerodivError(nullptr, nullptr);
+    c.misusedScopeObjectError(nullptr, "varname");
+    c.invalidPointerCastError(nullptr,  "float *", "double *", false, false);
+    c.negativeBitwiseShiftError(nullptr, 1);
+    c.negativeBitwiseShiftError(nullptr, 2);
+    c.raceAfterInterlockedDecrementError(nullptr);
+    c.invalidFreeError(nullptr, "malloc", false);
+    c.overlappingWriteUnion(nullptr);
+    c.overlappingWriteFunction(nullptr, "funcname");
+
+    //performance
+    c.redundantCopyError(nullptr,  "varname");
+    c.redundantCopyError(nullptr, nullptr, "var");
+
+    // style/warning
+    c.checkComparisonFunctionIsAlwaysTrueOrFalseError(nullptr, "isless","varName",false);
+    c.checkCastIntToCharAndBackError(nullptr, "func_name");
+    c.cstyleCastError(nullptr);
+    c.dangerousTypeCastError(nullptr, true);
+    c.intToPointerCastError(nullptr, "decimal");
+    c.suspiciousFloatingPointCastError(nullptr);
+    c.passedByValueError(nullptr, false);
+    // TODO: iterateByValue
+    // TODO: passedByValueCallback
+    c.constVariableError(nullptr, nullptr);
+    c.constStatementError(nullptr, "type", false);
+    c.signedCharArrayIndexError(nullptr);
+    c.unknownSignCharArrayIndexError(nullptr);
+    c.charBitOpError(nullptr);
+    c.variableScopeError(nullptr,  "varname");
+    c.redundantAssignmentInSwitchError(nullptr, nullptr, "var");
+    c.suspiciousCaseInSwitchError(nullptr,  "||");
+    c.selfAssignmentError(nullptr,  "varname");
+    c.clarifyCalculationError(nullptr,  "+");
+    c.clarifyStatementError(nullptr);
+    c.duplicateBranchError(nullptr, nullptr, ErrorPath{});
+    c.duplicateAssignExpressionError(nullptr, nullptr, true);
+    c.oppositeExpressionError(nullptr, ErrorPath{});
+    c.duplicateExpressionError(nullptr, nullptr, nullptr, ErrorPath{});
+    c.duplicateValueTernaryError(nullptr);
+    c.duplicateExpressionTernaryError(nullptr, ErrorPath{});
+    c.duplicateBreakError(nullptr,  false);
+    c.unreachableCodeError(nullptr, nullptr,  false);
+    c.unsignedLessThanZeroError(nullptr, nullptr, "varname");
+    c.unsignedPositiveError(nullptr, nullptr, "varname");
+    c.pointerLessThanZeroError(nullptr, nullptr);
+    c.pointerPositiveError(nullptr, nullptr);
+    c.suspiciousSemicolonError(nullptr);
+    c.incompleteArrayFillError(nullptr,  "buffer", "memset", false);
+    c.varFuncNullUBError(nullptr);
+    c.nanInArithmeticExpressionError(nullptr);
+    c.commaSeparatedReturnError(nullptr);
+    c.redundantPointerOpError(nullptr,  "varname", false, /*addressOfDeref*/ true);
+    c.unusedLabelError(nullptr, false, false);
+    c.unusedLabelError(nullptr, false, true);
+    c.unusedLabelError(nullptr, true, false);
+    c.unusedLabelError(nullptr, true, true);
+    c.unknownEvaluationOrder(nullptr);
+    c.accessMovedError(nullptr, "v", nullptr, false);
+    c.funcArgNamesDifferent("function", 1, nullptr, nullptr);
+    c.redundantBitwiseOperationInSwitchError(nullptr, "varname");
+    c.shadowError(nullptr, nullptr, "variable");
+    c.shadowError(nullptr, nullptr, "function");
+    c.shadowError(nullptr, nullptr, "argument");
+    c.knownArgumentError(nullptr, nullptr, nullptr, "x", false);
+    c.knownPointerToBoolError(nullptr, nullptr);
+    c.comparePointersError(nullptr, nullptr, nullptr);
+    // TODO: subtractPointers
+    c.redundantAssignmentError(nullptr, nullptr, "var", false);
+    c.redundantInitializationError(nullptr, nullptr, "var", false);
+    c.redundantContinueError(nullptr);
+
+    const std::vector<const Token *> nullvec;
+    c.funcArgOrderDifferent("function", nullptr, nullptr, nullvec, nullvec);
+    c.checkModuloOfOneError(nullptr);
+    c.unionZeroInitError(nullptr, UnionMember());
 }
diff --git a/lib/checkother.h b/lib/checkother.h
index a3d31d6e656..28ee25cfa76 100644
--- a/lib/checkother.h
+++ b/lib/checkother.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,17 +24,23 @@
 
 #include "check.h"
 #include "config.h"
-#include "valueflow.h"
+#include "errortypes.h"
 
-#include <cstddef>
+#include <set>
 #include <string>
 #include <vector>
 
-class ErrorLogger;
+namespace ValueFlow {
+    class Value;
+}
+
 class Settings;
 class Token;
-class Tokenizer;
+class Function;
 class Variable;
+class ErrorLogger;
+class Tokenizer;
+struct UnionMember;
 
 /// @addtogroup Checks
 /// @{
@@ -43,60 +49,28 @@ class Variable;
 /** @brief Various small checks */
 
 class CPPCHECKLIB CheckOther : public Check {
+    friend class TestCharVar;
+    friend class TestIncompleteStatement;
+    friend class TestOther;
+
 public:
     /** @brief This constructor is used when registering the CheckClass */
-    CheckOther() : Check(myName()) {
-    }
+    CheckOther() : Check(myName()) {}
 
+    /** Is expression a comparison that checks if a nonzero (unsigned/pointer) expression is less than zero? */
+    static bool comparisonNonZeroExpressionLessThanZero(const Token *tok, const ValueFlow::Value *&zeroValue, const Token *&nonZeroExpr, bool suppress = false);
+
+    /** Is expression a comparison that checks if a nonzero (unsigned/pointer) expression is positive? */
+    static bool testIfNonZeroExpressionIsPositive(const Token *tok, const ValueFlow::Value *&zeroValue, const Token *&nonZeroExpr);
+
+private:
     /** @brief This constructor is used when running checks. */
     CheckOther(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger) {}
+
 
     /** @brief Run checks against the normal token list */
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        CheckOther checkOther(tokenizer, settings, errorLogger);
-
-        // Checks
-        checkOther.warningOldStylePointerCast();
-        checkOther.invalidPointerCast();
-        checkOther.checkCharVariable();
-        checkOther.checkRedundantAssignment();
-        checkOther.checkRedundantAssignmentInSwitch();
-        checkOther.checkSuspiciousCaseInSwitch();
-        checkOther.checkDuplicateBranch();
-        checkOther.checkDuplicateExpression();
-        checkOther.checkUnreachableCode();
-        checkOther.checkSuspiciousSemicolon();
-        checkOther.checkVariableScope();
-        checkOther.checkSignOfUnsignedVariable();  // don't ignore casts (#3574)
-        checkOther.checkIncompleteArrayFill();
-        checkOther.checkVarFuncNullUB();
-        checkOther.checkNanInArithmeticExpression();
-        checkOther.checkCommaSeparatedReturn();
-        checkOther.checkRedundantPointerOp();
-        checkOther.checkZeroDivision();
-        checkOther.checkNegativeBitwiseShift();
-        checkOther.checkInterlockedDecrement();
-        checkOther.checkUnusedLabel();
-        checkOther.checkEvaluationOrder();
-        checkOther.checkFuncArgNamesDifferent();
-        checkOther.checkShadowVariables();
-        checkOther.checkConstArgument();
-        checkOther.checkComparePointers();
-        checkOther.checkIncompleteStatement();
-        checkOther.checkPipeParameterSize();
-        checkOther.checkRedundantCopy();
-        checkOther.clarifyCalculation();
-        checkOther.checkPassByReference();
-        checkOther.checkConstVariable();
-        checkOther.checkComparisonFunctionIsAlwaysTrueOrFalse();
-        checkOther.checkInvalidFree();
-        checkOther.clarifyStatement();
-        checkOther.checkCastIntToCharAndBack();
-        checkOther.checkMisusedScopedObject();
-        checkOther.checkAccessOfMovedVariable();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     /** @brief Clarify calculation for ".. a * b ? .." */
     void clarifyCalculation();
@@ -107,12 +81,20 @@ class CPPCHECKLIB CheckOther : public Check {
     /** @brief Are there C-style pointer casts in a c++ file? */
     void warningOldStylePointerCast();
 
+    /** @brief Dangerous type cast */
+    void warningDangerousTypeCast();
+
+    /** @brief Casting non-hexadecimal integer literal to pointer */
+    void warningIntToPointerCast();
+
+    void suspiciousFloatingPointCast();
+
     /** @brief Check for pointer casts to a type with an incompatible binary data representation */
     void invalidPointerCast();
 
     /** @brief %Check scope of variables */
     void checkVariableScope();
-    static bool checkInnerScope(const Token *tok, const Variable* var, bool& used);
+    bool checkInnerScope(const Token *tok, const Variable* var, bool& used) const;
 
     /** @brief %Check for comma separated statements in return */
     void checkCommaSeparatedReturn();
@@ -121,6 +103,7 @@ class CPPCHECKLIB CheckOther : public Check {
     void checkPassByReference();
 
     void checkConstVariable();
+    void checkConstPointer();
 
     /** @brief Using char variable as array index / as operand in bit operation */
     void checkCharVariable();
@@ -137,8 +120,8 @@ class CPPCHECKLIB CheckOther : public Check {
     /** @brief copying to memory or assigning to a variable twice */
     void checkRedundantAssignment();
 
-    /** @brief %Check for assigning to the same variable twice in a switch statement*/
-    void checkRedundantAssignmentInSwitch();
+    /** @brief %Check for redundant bitwise operation in switch statement*/
+    void redundantBitwiseOperationInSwitchError();
 
     /** @brief %Check for code like 'case A||B:'*/
     void checkSuspiciousCaseInSwitch();
@@ -177,9 +160,6 @@ class CPPCHECKLIB CheckOther : public Check {
     /** @brief %Check that variadic function calls don't use NULL. If NULL is \#defined as 0 and the function expects a pointer, the behaviour is undefined. */
     void checkVarFuncNullUB();
 
-    /** @brief %Check that calling the POSIX pipe() system call is called with an integer array of size two. */
-    void checkPipeParameterSize();
-
     /** @brief %Check to avoid casting a return value to unsigned char and then back to integer type.  */
     void checkCastIntToCharAndBack();
 
@@ -207,21 +187,35 @@ class CPPCHECKLIB CheckOther : public Check {
     /** @brief %Check for shadow variables. Less noisy than gcc/clang -Wshadow. */
     void checkShadowVariables();
 
-    void checkConstArgument();
+    void checkKnownArgument();
+
+    void checkKnownPointerToBool();
 
     void checkComparePointers();
 
-private:
+    void checkModuloOfOne();
+
+    /**
+     * @throws InternalError thrown if largest union member could not be found
+     */
+    void checkUnionZeroInit();
+
+    void checkOverlappingWrite();
+    void overlappingWriteUnion(const Token *tok);
+    void overlappingWriteFunction(const Token *tok, const std::string& funcname);
+
     // Error messages..
-    void checkComparisonFunctionIsAlwaysTrueOrFalseError(const Token* tok, const std::string &functionName, const std::string &varName, const bool result);
+    void checkComparisonFunctionIsAlwaysTrueOrFalseError(const Token* tok, const std::string &functionName, const std::string &varName, bool result);
     void checkCastIntToCharAndBackError(const Token *tok, const std::string &strFunctionName);
-    void checkPipeParameterSizeError(const Token *tok, const std::string &strVarName, const std::string &strDim);
     void clarifyCalculationError(const Token *tok, const std::string &op);
     void clarifyStatementError(const Token* tok);
-    void cstyleCastError(const Token *tok);
-    void invalidPointerCastError(const Token* tok, const std::string& from, const std::string& to, bool inconclusive);
-    void passedByValueError(const Token *tok, const std::string &parname, bool inconclusive);
-    void constVariableError(const Variable *var);
+    void cstyleCastError(const Token *tok, bool isPtr = true);
+    void dangerousTypeCastError(const Token *tok, bool isPtr);
+    void intToPointerCastError(const Token *tok, const std::string& format);
+    void suspiciousFloatingPointCastError(const Token *tok);
+    void invalidPointerCastError(const Token* tok, const std::string& from, const std::string& to, bool inconclusive, bool toIsInt);
+    void passedByValueError(const Variable* var, bool inconclusive, bool isRangeBasedFor = false);
+    void constVariableError(const Variable *var, const Function *function);
     void constStatementError(const Token *tok, const std::string &type, bool inconclusive);
     void signedCharArrayIndexError(const Token *tok);
     void unknownSignCharArrayIndexError(const Token *tok);
@@ -232,119 +226,52 @@ class CPPCHECKLIB CheckOther : public Check {
     void redundantAssignmentError(const Token *tok1, const Token* tok2, const std::string& var, bool inconclusive);
     void redundantInitializationError(const Token *tok1, const Token* tok2, const std::string& var, bool inconclusive);
     void redundantAssignmentInSwitchError(const Token *tok1, const Token *tok2, const std::string &var);
+    void redundantAssignmentSameValueError(const Token* tok, const ValueFlow::Value* val, const std::string& var);
     void redundantCopyError(const Token *tok1, const Token* tok2, const std::string& var);
-    void redundantCopyInSwitchError(const Token *tok1, const Token* tok2, const std::string &var);
     void redundantBitwiseOperationInSwitchError(const Token *tok, const std::string &varname);
     void suspiciousCaseInSwitchError(const Token* tok, const std::string& operatorString);
     void selfAssignmentError(const Token *tok, const std::string &varname);
-    void misusedScopeObjectError(const Token *tok, const std::string &varname);
+    void misusedScopeObjectError(const Token *tok, const std::string &varname, bool isAssignment = false);
     void duplicateBranchError(const Token *tok1, const Token *tok2, ErrorPath errors);
     void duplicateAssignExpressionError(const Token *tok1, const Token *tok2, bool inconclusive);
     void oppositeExpressionError(const Token *opTok, ErrorPath errors);
-    void duplicateExpressionError(const Token *tok1, const Token *tok2, const Token *opTok, ErrorPath errors);
+    void duplicateExpressionError(const Token *tok1, const Token *tok2, const Token *opTok, ErrorPath errors, bool hasMultipleExpr = false);
     void duplicateValueTernaryError(const Token *tok);
     void duplicateExpressionTernaryError(const Token *tok, ErrorPath errors);
     void duplicateBreakError(const Token *tok, bool inconclusive);
-    void unreachableCodeError(const Token* tok, bool inconclusive);
+    void unreachableCodeError(const Token* tok, const Token* noreturn, bool inconclusive);
+    void redundantContinueError(const Token* tok);
     void unsignedLessThanZeroError(const Token *tok, const ValueFlow::Value *v, const std::string &varname);
     void pointerLessThanZeroError(const Token *tok, const ValueFlow::Value *v);
     void unsignedPositiveError(const Token *tok, const ValueFlow::Value *v, const std::string &varname);
     void pointerPositiveError(const Token *tok, const ValueFlow::Value *v);
-    void SuspiciousSemicolonError(const Token *tok);
+    void suspiciousSemicolonError(const Token *tok);
     void negativeBitwiseShiftError(const Token *tok, int op);
     void redundantCopyError(const Token *tok, const std::string &varname);
     void incompleteArrayFillError(const Token* tok, const std::string& buffer, const std::string& function, bool boolean);
     void varFuncNullUBError(const Token *tok);
     void commaSeparatedReturnError(const Token *tok);
-    void redundantPointerOpError(const Token* tok, const std::string& varname, bool inconclusive);
+    void redundantPointerOpError(const Token* tok, const std::string& varname, bool inconclusive, bool addressOfDeref);
     void raceAfterInterlockedDecrementError(const Token* tok);
-    void unusedLabelError(const Token* tok, bool inSwitch);
-    void unknownEvaluationOrder(const Token* tok);
-    static bool isMovedParameterAllowedForInconclusiveFunction(const Token * tok);
+    void unusedLabelError(const Token* tok, bool inSwitch, bool hasIfdef);
+    void unknownEvaluationOrder(const Token* tok, bool isUnspecifiedBehavior = false);
     void accessMovedError(const Token *tok, const std::string &varname, const ValueFlow::Value *value, bool inconclusive);
     void funcArgNamesDifferent(const std::string & functionName, nonneg int index, const Token* declaration, const Token* definition);
     void funcArgOrderDifferent(const std::string & functionName, const Token * declaration, const Token * definition, const std::vector<const Token*> & declarations, const std::vector<const Token*> & definitions);
-    void shadowError(const Token *var, const Token *shadowed, std::string type);
-    void constArgumentError(const Token *tok, const Token *ftok, const ValueFlow::Value *value);
+    void shadowError(const Token *var, const Token *shadowed, const std::string& type);
+    void knownArgumentError(const Token *tok, const Token *ftok, const ValueFlow::Value *value, const std::string &varexpr, bool isVariableExpressionHidden);
+    void knownPointerToBoolError(const Token* tok, const ValueFlow::Value* value);
     void comparePointersError(const Token *tok, const ValueFlow::Value *v1, const ValueFlow::Value *v2);
+    void checkModuloOfOneError(const Token *tok);
+    void unionZeroInitError(const Token *tok, const UnionMember& largestMember);
 
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        CheckOther c(nullptr, settings, errorLogger);
-
-        ErrorPath errorPath;
-
-        // error
-        c.zerodivError(nullptr, nullptr);
-        c.misusedScopeObjectError(nullptr, "varname");
-        c.invalidPointerCastError(nullptr,  "float", "double", false);
-        c.negativeBitwiseShiftError(nullptr, 1);
-        c.negativeBitwiseShiftError(nullptr, 2);
-        c.checkPipeParameterSizeError(nullptr,  "varname", "dimension");
-        c.raceAfterInterlockedDecrementError(nullptr);
-        c.invalidFreeError(nullptr, "malloc", false);
-
-        //performance
-        c.redundantCopyError(nullptr,  "varname");
-        c.redundantCopyError(nullptr, nullptr, "var");
-
-        // style/warning
-        c.checkComparisonFunctionIsAlwaysTrueOrFalseError(nullptr, "isless","varName",false);
-        c.checkCastIntToCharAndBackError(nullptr, "func_name");
-        c.cstyleCastError(nullptr);
-        c.passedByValueError(nullptr, "parametername", false);
-        c.constVariableError(nullptr);
-        c.constStatementError(nullptr, "type", false);
-        c.signedCharArrayIndexError(nullptr);
-        c.unknownSignCharArrayIndexError(nullptr);
-        c.charBitOpError(nullptr);
-        c.variableScopeError(nullptr,  "varname");
-        c.redundantAssignmentInSwitchError(nullptr, nullptr, "var");
-        c.redundantCopyInSwitchError(nullptr, nullptr, "var");
-        c.suspiciousCaseInSwitchError(nullptr,  "||");
-        c.selfAssignmentError(nullptr,  "varname");
-        c.clarifyCalculationError(nullptr,  "+");
-        c.clarifyStatementError(nullptr);
-        c.duplicateBranchError(nullptr, nullptr, errorPath);
-        c.duplicateAssignExpressionError(nullptr, nullptr, true);
-        c.oppositeExpressionError(nullptr, errorPath);
-        c.duplicateExpressionError(nullptr, nullptr, nullptr, errorPath);
-        c.duplicateValueTernaryError(nullptr);
-        c.duplicateExpressionTernaryError(nullptr, errorPath);
-        c.duplicateBreakError(nullptr,  false);
-        c.unreachableCodeError(nullptr,  false);
-        c.unsignedLessThanZeroError(nullptr, nullptr, "varname");
-        c.unsignedPositiveError(nullptr, nullptr, "varname");
-        c.pointerLessThanZeroError(nullptr, nullptr);
-        c.pointerPositiveError(nullptr, nullptr);
-        c.SuspiciousSemicolonError(nullptr);
-        c.incompleteArrayFillError(nullptr,  "buffer", "memset", false);
-        c.varFuncNullUBError(nullptr);
-        c.nanInArithmeticExpressionError(nullptr);
-        c.commaSeparatedReturnError(nullptr);
-        c.redundantPointerOpError(nullptr,  "varname", false);
-        c.unusedLabelError(nullptr,  true);
-        c.unusedLabelError(nullptr,  false);
-        c.unknownEvaluationOrder(nullptr);
-        c.accessMovedError(nullptr, "v", nullptr, false);
-        c.funcArgNamesDifferent("function", 1, nullptr, nullptr);
-        c.redundantBitwiseOperationInSwitchError(nullptr, "varname");
-        c.shadowError(nullptr, nullptr, "variable");
-        c.shadowError(nullptr, nullptr, "function");
-        c.shadowError(nullptr, nullptr, "argument");
-        c.constArgumentError(nullptr, nullptr, nullptr);
-        c.comparePointersError(nullptr, nullptr, nullptr);
-        c.redundantAssignmentError(nullptr, nullptr, "var", false);
-        c.redundantInitializationError(nullptr, nullptr, "var", false);
-
-        const std::vector<const Token *> nullvec;
-        c.funcArgOrderDifferent("function", nullptr, nullptr, nullvec, nullvec);
-    }
+    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const override;
 
     static std::string myName() {
         return "Other";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Other checks\n"
 
                // error
@@ -353,14 +280,15 @@ class CPPCHECKLIB CheckOther : public Check {
                "- assignment in an assert statement\n"
                "- free() or delete of an invalid memory location\n"
                "- bitwise operation with negative right operand\n"
-               "- provide wrong dimensioned array to pipe() system command (--std=posix)\n"
                "- cast the return values of getc(),fgetc() and getchar() to character and compare it to EOF\n"
                "- race condition with non-interlocked access after InterlockedDecrement() call\n"
                "- expression 'x = x++;' depends on order of evaluation of side effects\n"
+               "- overlapping write of union\n"
 
                // warning
                "- either division by zero or useless condition\n"
                "- access of moved or forwarded variable.\n"
+               "- potentially dangerous C style type cast of pointer/reference to object.\n"
 
                // performance
                "- redundant data copying for const variable\n"
@@ -369,6 +297,8 @@ class CPPCHECKLIB CheckOther : public Check {
 
                // portability
                "- Passing NULL pointer to function with variable number of arguments leads to UB.\n"
+               "- Casting non-zero integer literal in decimal or octal format to pointer.\n"
+               "- Incorrect zero initialization of unions can lead to access of uninitialized memory.\n"
 
                // style
                "- C-style pointer cast in C++ code\n"
@@ -398,8 +328,15 @@ class CPPCHECKLIB CheckOther : public Check {
                "- function declaration and definition argument names different.\n"
                "- function declaration and definition argument order different.\n"
                "- shadow variable.\n"
-               "- variable can be declared const.\n";
+               "- variable can be declared const.\n"
+               "- calculating modulo of one.\n"
+               "- known function argument, suspicious calculation.\n";
+    }
+
+    bool diag(const Token* tok) {
+        return !mRedundantAssignmentDiag.emplace(tok).second;
     }
+    std::set<const Token*> mRedundantAssignmentDiag;
 };
 /// @}
 //---------------------------------------------------------------------------
diff --git a/lib/checkpostfixoperator.cpp b/lib/checkpostfixoperator.cpp
index 60c1d009d5c..c6c9ccba77b 100644
--- a/lib/checkpostfixoperator.cpp
+++ b/lib/checkpostfixoperator.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,12 +23,13 @@
 
 #include "checkpostfixoperator.h"
 
-#include "errorlogger.h"
+#include "errortypes.h"
 #include "settings.h"
 #include "symboldatabase.h"
 #include "token.h"
+#include "tokenize.h"
 
-#include <cstddef>
+#include <vector>
 
 //---------------------------------------------------------------------------
 
@@ -40,14 +41,16 @@ namespace {
 
 
 // CWE ids used
-static const struct CWE CWE398(398U);   // Indicator of Poor Code Quality
+static const CWE CWE398(398U);   // Indicator of Poor Code Quality
 
 
 void CheckPostfixOperator::postfixOperator()
 {
-    if (!mSettings->isEnabled(Settings::PERFORMANCE))
+    if (!mSettings->severity.isEnabled(Severity::performance))
         return;
 
+    logChecker("CheckPostfixOperator::postfixOperator"); // performance
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope * scope : symbolDatabase->functionScopes) {
@@ -61,7 +64,19 @@ void CheckPostfixOperator::postfixOperator()
                 if (var->isPointer() || var->isArray())
                     continue;
 
-                if (Token::Match(var->nameToken()->previous(), "iterator|const_iterator|reverse_iterator|const_reverse_iterator")) {
+                const Token* typeEndTok = var->typeStartToken();
+                if (Token::simpleMatch(typeEndTok, "::"))
+                    typeEndTok = typeEndTok->next();
+                while (Token::Match(typeEndTok, "%name% ::|<")) {
+                    if (typeEndTok->linkAt(1)) {
+                        typeEndTok = typeEndTok->linkAt(1)->next();
+                        if (Token::simpleMatch(typeEndTok, "::"))
+                            typeEndTok = typeEndTok->next();
+                    }
+                    else
+                        typeEndTok = typeEndTok->tokAt(2);
+                }
+                if (Token::Match(typeEndTok, "iterator|const_iterator|reverse_iterator|const_reverse_iterator")) {
                     // the variable is an iterator
                     postfixOperatorError(tok);
                 } else if (var->type()) {
@@ -83,5 +98,20 @@ void CheckPostfixOperator::postfixOperatorError(const Token *tok)
                 "Pre-increment/decrement can be more efficient than "
                 "post-increment/decrement. Post-increment/decrement usually "
                 "involves keeping a copy of the previous value around and "
-                "adds a little extra code.", CWE398, false);
+                "adds a little extra code.", CWE398, Certainty::normal);
+}
+
+void CheckPostfixOperator::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    if (tokenizer.isC())
+        return;
+
+    CheckPostfixOperator checkPostfixOperator(&tokenizer, &tokenizer.getSettings(), errorLogger);
+    checkPostfixOperator.postfixOperator();
+}
+
+void CheckPostfixOperator::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const
+{
+    CheckPostfixOperator c(nullptr, settings, errorLogger);
+    c.postfixOperatorError(nullptr);
 }
diff --git a/lib/checkpostfixoperator.h b/lib/checkpostfixoperator.h
index 232e22a7670..c9f58a7e143 100644
--- a/lib/checkpostfixoperator.h
+++ b/lib/checkpostfixoperator.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,13 +24,13 @@
 
 #include "check.h"
 #include "config.h"
-#include "tokenize.h"
 
 #include <string>
 
 class ErrorLogger;
 class Settings;
 class Token;
+class Tokenizer;
 
 /// @addtogroup Checks
 /// @{
@@ -40,41 +40,32 @@ class Token;
  */
 
 class CPPCHECKLIB CheckPostfixOperator : public Check {
+    friend class TestPostfixOperator;
+
 public:
     /** This constructor is used when registering the CheckPostfixOperator */
-    CheckPostfixOperator() : Check(myName()) {
-    }
+    CheckPostfixOperator() : Check(myName()) {}
 
+private:
     /** This constructor is used when running checks. */
     CheckPostfixOperator(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger) {}
 
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        if (tokenizer->isC())
-            return;
-
-        CheckPostfixOperator checkPostfixOperator(tokenizer, settings, errorLogger);
-        checkPostfixOperator.postfixOperator();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     /** Check postfix operators */
     void postfixOperator();
 
-private:
     /** Report Error */
     void postfixOperatorError(const Token *tok);
 
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        CheckPostfixOperator c(nullptr, settings, errorLogger);
-        c.postfixOperatorError(nullptr);
-    }
+    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const override;
 
     static std::string myName() {
         return "Using postfix operators";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Warn if using postfix operators ++ or -- rather than prefix operator\n";
     }
 };
diff --git a/lib/checksizeof.cpp b/lib/checksizeof.cpp
index af5db82688d..f7c0d44d399 100644
--- a/lib/checksizeof.cpp
+++ b/lib/checksizeof.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,13 +20,18 @@
 //---------------------------------------------------------------------------
 #include "checksizeof.h"
 
-#include "errorlogger.h"
+#include "errortypes.h"
+#include "library.h"
 #include "settings.h"
 #include "symboldatabase.h"
 #include "token.h"
 #include "tokenize.h"
 
-#include <cstddef>
+#include <algorithm>
+#include <iterator>
+#include <map>
+#include <vector>
+
 //---------------------------------------------------------------------------
 
 // Register this check class (by creating a static instance of it)
@@ -35,16 +40,17 @@ namespace {
 }
 
 // CWE IDs used:
-static const struct CWE CWE398(398U);   // Indicator of Poor Code Quality
-static const struct CWE CWE467(467U);   // Use of sizeof() on a Pointer Type
-static const struct CWE CWE682(682U);   // Incorrect Calculation
+static const CWE CWE467(467U);   // Use of sizeof() on a Pointer Type
+static const CWE CWE682(682U);   // Incorrect Calculation
 //---------------------------------------------------------------------------
 //---------------------------------------------------------------------------
 void CheckSizeof::checkSizeofForNumericParameter()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckSizeof::checkSizeofForNumericParameter"); // warning
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
@@ -62,7 +68,7 @@ void CheckSizeof::sizeofForNumericParameterError(const Token *tok)
                 "sizeofwithnumericparameter", "Suspicious usage of 'sizeof' with a numeric constant as parameter.\n"
                 "It is unusual to use a constant value with sizeof. For example, 'sizeof(10)'"
                 " returns 4 (in 32-bit systems) or 8 (in 64-bit systems) instead of 10. 'sizeof('A')'"
-                " and 'sizeof(char)' can return different results.", CWE682, false);
+                " and 'sizeof(char)' can return different results.", CWE682, Certainty::normal);
 }
 
 
@@ -70,8 +76,11 @@ void CheckSizeof::sizeofForNumericParameterError(const Token *tok)
 //---------------------------------------------------------------------------
 void CheckSizeof::checkSizeofForArrayParameter()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
+
+    logChecker("CheckSizeof::checkSizeofForArrayParameter"); // warning
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
@@ -102,15 +111,17 @@ void CheckSizeof::sizeofForArrayParameterError(const Token *tok)
                 "         return sizeof(a);\n"
                 "     }\n"
                 "returns 4 (in 32-bit systems) or 8 (in 64-bit systems) instead of 100 (the "
-                "size of the array in bytes).", CWE467, false
-               );
+                "size of the array in bytes).", CWE467, Certainty::normal
+                );
 }
 
 void CheckSizeof::checkSizeofForPointerSize()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckSizeof::checkSizeofForPointerSize"); // warning
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
@@ -123,12 +134,12 @@ void CheckSizeof::checkSizeofForPointerSize()
             // Once leaving those tests, it is mandatory to have:
             // - variable matching the used pointer
             // - tokVar pointing on the argument where sizeof may be used
-            if (Token::Match(tok->tokAt(2), "malloc|alloca|calloc (")) {
+            if (Token::Match(tok->tokAt(2), "%name% (") && mSettings->library.getAllocFuncInfo(tok->tokAt(2))) {
                 if (Token::Match(tok, "%var% ="))
                     variable = tok;
                 else if (tok->strAt(1) == ")" && Token::Match(tok->linkAt(1)->tokAt(-2), "%var% ="))
                     variable = tok->linkAt(1)->tokAt(-2);
-                else if (tok->link() && Token::Match(tok, "> ( malloc|alloca|calloc (") && Token::Match(tok->link()->tokAt(-3), "%var% ="))
+                else if (tok->link() && Token::Match(tok, "> ( %name% (") && Token::Match(tok->link()->tokAt(-3), "%var% ="))
                     variable = tok->link()->tokAt(-3);
                 tokSize = tok->tokAt(4);
                 tokFunc = tok->tokAt(2);
@@ -163,6 +174,21 @@ void CheckSizeof::checkSizeofForPointerSize()
                             if (vt && vt->type == ValueType::CHAR && vt->pointer == 0)
                                 continue;
                         }
+                        auto hasMultiplication = [](const Token* parTok) -> bool {
+                            while (parTok) { // Allow division if followed by multiplication
+                                if (parTok->isArithmeticalOp() && parTok->str() == "*") {
+                                    const Token* szToks[] = { parTok->astOperand1(), parTok->astOperand2() };
+                                    if (std::any_of(std::begin(szToks), std::end(szToks), [](const Token* szTok) {
+                                        return Token::simpleMatch(szTok, "(") && Token::simpleMatch(szTok->previous(), "sizeof");
+                                    }))
+                                        return true;
+                                }
+                                parTok = parTok->astParent();
+                            }
+                            return false;
+                        };
+                        if (hasMultiplication(tok2->astParent()))
+                            continue;
 
                         divideBySizeofError(tok2, tokFunc->str());
                     }
@@ -178,6 +204,9 @@ void CheckSizeof::checkSizeofForPointerSize()
             while (Token::Match(variable2, "%var% ::|."))
                 variable2 = variable2->tokAt(2);
 
+            if (!variable)
+                continue;
+
             // Ensure the variables are in the symbol database
             // Also ensure the variables are pointers
             // Only keep variables which are pointers
@@ -207,7 +236,8 @@ void CheckSizeof::checkSizeofForPointerSize()
                 continue;
 
             // Now check for the sizeof usage: Does the level of pointer indirection match?
-            if (tokSize->linkAt(1)->strAt(-1) == "*") {
+            const Token * const tokLink = tokSize->linkAt(1);
+            if (tokLink && tokLink->strAt(-1) == "*") {
                 if (variable && variable->valueType() && variable->valueType()->pointer == 1 && variable->valueType()->type != ValueType::VOID)
                     sizeofForPointerError(variable, variable->str());
                 else if (variable2 && variable2->valueType() && variable2->valueType()->pointer == 1 && variable2->valueType()->type != ValueType::VOID)
@@ -243,22 +273,24 @@ void CheckSizeof::sizeofForPointerError(const Token *tok, const std::string &var
                 "Size of pointer '" + varname + "' used instead of size of its data.\n"
                 "Size of pointer '" + varname + "' used instead of size of its data. "
                 "This is likely to lead to a buffer overflow. You probably intend to "
-                "write 'sizeof(*" + varname + ")'.", CWE467, false);
+                "write 'sizeof(*" + varname + ")'.", CWE467, Certainty::normal);
 }
 
 void CheckSizeof::divideBySizeofError(const Token *tok, const std::string &memfunc)
 {
     reportError(tok, Severity::warning, "sizeofDivisionMemfunc",
-                "Division by result of sizeof(). " + memfunc + "() expects a size in bytes, did you intend to multiply instead?", CWE682, false);
+                "Division by result of sizeof(). " + memfunc + "() expects a size in bytes, did you intend to multiply instead?", CWE682, Certainty::normal);
 }
 
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 void CheckSizeof::sizeofsizeof()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckSizeof::sizeofsizeof"); // warning
+
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
         if (Token::Match(tok, "sizeof (| sizeof")) {
             sizeofsizeofError(tok);
@@ -273,17 +305,19 @@ void CheckSizeof::sizeofsizeofError(const Token *tok)
                 "sizeofsizeof", "Calling 'sizeof' on 'sizeof'.\n"
                 "Calling sizeof for 'sizeof looks like a suspicious code and "
                 "most likely there should be just one 'sizeof'. The current "
-                "code is equivalent to 'sizeof(size_t)'", CWE682, false);
+                "code is equivalent to 'sizeof(size_t)'", CWE682, Certainty::normal);
 }
 
 //-----------------------------------------------------------------------------
 
 void CheckSizeof::sizeofCalculation()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
-    const bool printInconclusive = mSettings->inconclusive;
+    logChecker("CheckSizeof::sizeofCalculation"); // warning
+
+    const bool printInconclusive = mSettings->certainty.isEnabled(Certainty::inconclusive);
 
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
         if (!Token::simpleMatch(tok, "sizeof ("))
@@ -292,9 +326,9 @@ void CheckSizeof::sizeofCalculation()
         // ignore if the `sizeof` result is cast to void inside a macro, i.e. the calculation is
         // expected to be parsed but skipped, such as in a disabled custom ASSERT() macro
         if (tok->isExpandedMacro() && tok->previous()) {
-            const Token *cast_end = (tok->previous()->str() == "(") ? tok->previous() : tok;
+            const Token *cast_end = (tok->strAt(-1) == "(") ? tok->previous() : tok;
             if (Token::simpleMatch(cast_end->tokAt(-3), "( void )") ||
-                Token::simpleMatch(cast_end->previous(), "static_cast<void>")) {
+                Token::simpleMatch(cast_end->tokAt(-4), "static_cast < void >")) {
                 continue;
             }
         }
@@ -317,25 +351,27 @@ void CheckSizeof::sizeofCalculation()
 void CheckSizeof::sizeofCalculationError(const Token *tok, bool inconclusive)
 {
     reportError(tok, Severity::warning,
-                "sizeofCalculation", "Found calculation inside sizeof().", CWE682, inconclusive);
+                "sizeofCalculation", "Found calculation inside sizeof().", CWE682, inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
 //-----------------------------------------------------------------------------
 
 void CheckSizeof::sizeofFunction()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning) && !mSettings->isPremiumEnabled("sizeofFunctionCall"))
         return;
 
+    logChecker("CheckSizeof::sizeofFunction"); // warning
+
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
         if (Token::simpleMatch(tok, "sizeof (")) {
 
             // ignore if the `sizeof` result is cast to void inside a macro, i.e. the calculation is
             // expected to be parsed but skipped, such as in a disabled custom ASSERT() macro
             if (tok->isExpandedMacro() && tok->previous()) {
-                const Token *cast_end = (tok->previous()->str() == "(") ? tok->previous() : tok;
+                const Token *cast_end = (tok->strAt(-1) == "(") ? tok->previous() : tok;
                 if (Token::simpleMatch(cast_end->tokAt(-3), "( void )") ||
-                    Token::simpleMatch(cast_end->previous(), "static_cast<void>")) {
+                    Token::simpleMatch(cast_end->tokAt(-4), "static_cast < void >")) {
                     continue;
                 }
             }
@@ -343,7 +379,7 @@ void CheckSizeof::sizeofFunction()
             if (const Token *argument = tok->next()->astOperand2()) {
                 const Token *checkToken = argument->previous();
                 if (checkToken->tokType() == Token::eName)
-                    break;
+                    continue;
                 const Function * fun = checkToken->function();
                 // Don't report error if the function is overloaded
                 if (fun && fun->nestedIn->functionMap.count(checkToken->str()) == 1) {
@@ -357,7 +393,7 @@ void CheckSizeof::sizeofFunction()
 void CheckSizeof::sizeofFunctionError(const Token *tok)
 {
     reportError(tok, Severity::warning,
-                "sizeofFunctionCall", "Found function call inside sizeof().", CWE682, false);
+                "sizeofFunctionCall", "Found function call inside sizeof().", CWE682, Certainty::normal);
 }
 
 //-----------------------------------------------------------------------------
@@ -365,19 +401,30 @@ void CheckSizeof::sizeofFunctionError(const Token *tok)
 //-----------------------------------------------------------------------------
 void CheckSizeof::suspiciousSizeofCalculation()
 {
-    if (!mSettings->isEnabled(Settings::WARNING) || !mSettings->inconclusive)
+    if (!mSettings->severity.isEnabled(Severity::warning) || !mSettings->certainty.isEnabled(Certainty::inconclusive))
         return;
 
-    // TODO: Use AST here. This should be possible as soon as sizeof without brackets is correctly parsed
+    logChecker("CheckSizeof::suspiciousSizeofCalculation"); // warning,inconclusive
+
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
         if (Token::simpleMatch(tok, "sizeof (")) {
-            const Token* const end = tok->linkAt(1);
-            const Variable* var = end->previous()->variable();
-            if (end->strAt(-1) == "*" || (var && var->isPointer() && !var->isArray())) {
-                if (end->strAt(1) == "/")
-                    divideSizeofError(tok);
-            } else if (Token::simpleMatch(end, ") * sizeof") && end->next()->astOperand1() == tok->next())
-                multiplySizeofError(tok);
+            const Token* lPar = tok->astParent();
+            if (lPar && lPar->str() == "(") {
+                const Token* const rPar = lPar->link();
+                const Token* varTok = lPar->astOperand2();
+                int derefCount = 0;
+                while (Token::Match(varTok, "[|*")) {
+                    ++derefCount;
+                    varTok = varTok->astOperand1();
+                }
+                if (lPar->astParent() && lPar->astParent()->str() == "/") {
+                    const Variable* var = varTok ? varTok->variable() : nullptr;
+                    if (var && var->isPointer() && !var->isArray() && !(var->valueType() && var->valueType()->pointer <= derefCount))
+                        divideSizeofError(tok);
+                }
+                else if (Token::simpleMatch(rPar, ") * sizeof") && rPar->next()->astOperand1() == tok->next())
+                    multiplySizeofError(tok);
+            }
         }
     }
 }
@@ -385,7 +432,7 @@ void CheckSizeof::suspiciousSizeofCalculation()
 void CheckSizeof::multiplySizeofError(const Token *tok)
 {
     reportError(tok, Severity::warning,
-                "multiplySizeof", "Multiplying sizeof() with sizeof() indicates a logic error.", CWE682, true);
+                "multiplySizeof", "Multiplying sizeof() with sizeof() indicates a logic error.", CWE682, Certainty::inconclusive);
 }
 
 void CheckSizeof::divideSizeofError(const Token *tok)
@@ -393,16 +440,18 @@ void CheckSizeof::divideSizeofError(const Token *tok)
     reportError(tok, Severity::warning,
                 "divideSizeof", "Division of result of sizeof() on pointer type.\n"
                 "Division of result of sizeof() on pointer type. sizeof() returns the size of the pointer, "
-                "not the size of the memory area it points to.", CWE682, true);
+                "not the size of the memory area it points to.", CWE682, Certainty::inconclusive);
 }
 
 void CheckSizeof::sizeofVoid()
 {
-    if (!mSettings->isEnabled(Settings::PORTABILITY))
+    if (!mSettings->severity.isEnabled(Severity::portability))
         return;
 
+    logChecker("CheckSizeof::sizeofVoid"); // portability
+
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
-        if (Token::simpleMatch(tok, "sizeof ( )")) { // "sizeof(void)" gets simplified to sizeof ( )
+        if (Token::simpleMatch(tok, "sizeof ( void )")) {
             sizeofVoidError(tok);
         } else if (Token::simpleMatch(tok, "sizeof (") && tok->next()->astOperand2()) {
             const ValueType *vt = tok->next()->astOperand2()->valueType();
@@ -436,19 +485,51 @@ void CheckSizeof::sizeofVoidError(const Token *tok)
 {
     const std::string message = "Behaviour of 'sizeof(void)' is not covered by the ISO C standard.";
     const std::string verbose = message + " A value for 'sizeof(void)' is defined only as part of a GNU C extension, which defines 'sizeof(void)' to be 1.";
-    reportError(tok, Severity::portability, "sizeofVoid", message + "\n" + verbose, CWE682, false);
+    reportError(tok, Severity::portability, "sizeofVoid", message + "\n" + verbose, CWE682, Certainty::normal);
 }
 
 void CheckSizeof::sizeofDereferencedVoidPointerError(const Token *tok, const std::string &varname)
 {
     const std::string message = "'*" + varname + "' is of type 'void', the behaviour of 'sizeof(void)' is not covered by the ISO C standard.";
     const std::string verbose = message + " A value for 'sizeof(void)' is defined only as part of a GNU C extension, which defines 'sizeof(void)' to be 1.";
-    reportError(tok, Severity::portability, "sizeofDereferencedVoidPointer", message + "\n" + verbose, CWE682, false);
+    reportError(tok, Severity::portability, "sizeofDereferencedVoidPointer", message + "\n" + verbose, CWE682, Certainty::normal);
 }
 
 void CheckSizeof::arithOperationsOnVoidPointerError(const Token* tok, const std::string &varname, const std::string &vartype)
 {
     const std::string message = "'$symbol' is of type '" + vartype + "'. When using void pointers in calculations, the behaviour is undefined.";
     const std::string verbose = message + " Arithmetic operations on 'void *' is a GNU C extension, which defines the 'sizeof(void)' to be 1.";
-    reportError(tok, Severity::portability, "arithOperationsOnVoidPointer", "$symbol:" + varname + '\n' + message + '\n' + verbose, CWE467, false);
+    reportError(tok, Severity::portability, "arithOperationsOnVoidPointer", "$symbol:" + varname + '\n' + message + '\n' + verbose, CWE467, Certainty::normal);
+}
+
+void CheckSizeof::runChecks(const Tokenizer& tokenizer, ErrorLogger* errorLogger)
+{
+    CheckSizeof checkSizeof(&tokenizer, &tokenizer.getSettings(), errorLogger);
+
+    // Checks
+    checkSizeof.sizeofsizeof();
+    checkSizeof.sizeofCalculation();
+    checkSizeof.sizeofFunction();
+    checkSizeof.suspiciousSizeofCalculation();
+    checkSizeof.checkSizeofForArrayParameter();
+    checkSizeof.checkSizeofForPointerSize();
+    checkSizeof.checkSizeofForNumericParameter();
+    checkSizeof.sizeofVoid();
+}
+
+void CheckSizeof::getErrorMessages(ErrorLogger* errorLogger, const Settings* settings) const
+{
+    CheckSizeof c(nullptr, settings, errorLogger);
+    c.sizeofForArrayParameterError(nullptr);
+    c.sizeofForPointerError(nullptr, "varname");
+    c.divideBySizeofError(nullptr, "memset");
+    c.sizeofForNumericParameterError(nullptr);
+    c.sizeofsizeofError(nullptr);
+    c.sizeofCalculationError(nullptr, false);
+    c.sizeofFunctionError(nullptr);
+    c.multiplySizeofError(nullptr);
+    c.divideSizeofError(nullptr);
+    c.sizeofVoidError(nullptr);
+    c.sizeofDereferencedVoidPointerError(nullptr, "varname");
+    c.arithOperationsOnVoidPointerError(nullptr, "varname", "vartype");
 }
diff --git a/lib/checksizeof.h b/lib/checksizeof.h
index 8e5ce2051a6..4c10ca88dac 100644
--- a/lib/checksizeof.h
+++ b/lib/checksizeof.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -41,28 +41,15 @@ class Tokenizer;
 class CPPCHECKLIB CheckSizeof : public Check {
 public:
     /** @brief This constructor is used when registering the CheckClass */
-    CheckSizeof() : Check(myName()) {
-    }
+    CheckSizeof() : Check(myName()) {}
 
+private:
     /** @brief This constructor is used when running checks. */
     CheckSizeof(const Tokenizer* tokenizer, const Settings* settings, ErrorLogger* errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger) {}
 
     /** @brief Run checks against the normal token list */
-    void runChecks(const Tokenizer* tokenizer, const Settings* settings, ErrorLogger* errorLogger) OVERRIDE {
-        CheckSizeof checkSizeof(tokenizer, settings, errorLogger);
-
-        // Checks
-        checkSizeof.sizeofsizeof();
-        checkSizeof.sizeofCalculation();
-        checkSizeof.sizeofFunction();
-        checkSizeof.suspiciousSizeofCalculation();
-        checkSizeof.checkSizeofForArrayParameter();
-        checkSizeof.checkSizeofForPointerSize();
-        checkSizeof.checkSizeofForNumericParameter();
-        checkSizeof.sizeofVoid();
-    }
+    void runChecks(const Tokenizer& tokenizer, ErrorLogger* errorLogger) override;
 
     /** @brief %Check for 'sizeof sizeof ..' */
     void sizeofsizeof();
@@ -88,7 +75,6 @@ class CPPCHECKLIB CheckSizeof : public Check {
     /** @brief %Check for using sizeof(void) */
     void sizeofVoid();
 
-private:
     // Error messages..
     void sizeofsizeofError(const Token* tok);
     void sizeofCalculationError(const Token* tok, bool inconclusive);
@@ -103,28 +89,13 @@ class CPPCHECKLIB CheckSizeof : public Check {
     void sizeofDereferencedVoidPointerError(const Token *tok, const std::string &varname);
     void arithOperationsOnVoidPointerError(const Token* tok, const std::string &varname, const std::string &vartype);
 
-    void getErrorMessages(ErrorLogger* errorLogger, const Settings* settings) const OVERRIDE {
-        CheckSizeof c(nullptr, settings, errorLogger);
-
-        c.sizeofForArrayParameterError(nullptr);
-        c.sizeofForPointerError(nullptr, "varname");
-        c.divideBySizeofError(nullptr, "memset");
-        c.sizeofForNumericParameterError(nullptr);
-        c.sizeofsizeofError(nullptr);
-        c.sizeofCalculationError(nullptr, false);
-        c.sizeofFunctionError(nullptr);
-        c.multiplySizeofError(nullptr);
-        c.divideSizeofError(nullptr);
-        c.sizeofVoidError(nullptr);
-        c.sizeofDereferencedVoidPointerError(nullptr, "varname");
-        c.arithOperationsOnVoidPointerError(nullptr, "varname", "vartype");
-    }
+    void getErrorMessages(ErrorLogger* errorLogger, const Settings* settings) const override;
 
     static std::string myName() {
         return "Sizeof";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "sizeof() usage checks\n"
                "- sizeof for array given as function argument\n"
                "- sizeof for numeric given as function argument\n"
diff --git a/lib/checkstl.cpp b/lib/checkstl.cpp
index 5bbbf70a0c7..882f4588eeb 100644
--- a/lib/checkstl.cpp
+++ b/lib/checkstl.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,21 +18,33 @@
 
 #include "checkstl.h"
 
-#include "checknullpointer.h"
-#include "errorlogger.h"
+#include "astutils.h"
+#include "errortypes.h"
+#include "library.h"
+#include "mathlib.h"
+#include "pathanalysis.h"
 #include "settings.h"
 #include "standards.h"
 #include "symboldatabase.h"
 #include "token.h"
+#include "tokenize.h"
 #include "utils.h"
-#include "astutils.h"
+#include "valueflow.h"
+#include "vfvalue.h"
+
+#include "checknullpointer.h"
 
-#include <cstddef>
+#include <algorithm>
+#include <initializer_list>
+#include <iterator>
 #include <list>
 #include <map>
 #include <set>
 #include <sstream>
+#include <tuple>
+#include <unordered_map>
 #include <utility>
+#include <vector>
 
 // Register this check class (by creating a static instance of it)
 namespace {
@@ -40,78 +52,174 @@ namespace {
 }
 
 // CWE IDs used:
-static const struct CWE CWE398(398U);   // Indicator of Poor Code Quality
-static const struct CWE CWE597(597U);   // Use of Wrong Operator in String Comparison
-static const struct CWE CWE628(628U);   // Function Call with Incorrectly Specified Arguments
-static const struct CWE CWE664(664U);   // Improper Control of a Resource Through its Lifetime
-static const struct CWE CWE704(704U);   // Incorrect Type Conversion or Cast
-static const struct CWE CWE762(762U);   // Mismatched Memory Management Routines
-static const struct CWE CWE786(786U);   // Access of Memory Location Before Start of Buffer
-static const struct CWE CWE788(788U);   // Access of Memory Location After End of Buffer
-static const struct CWE CWE825(825U);   // Expired Pointer Dereference
-static const struct CWE CWE834(834U);   // Excessive Iteration
+static const CWE CWE398(398U);   // Indicator of Poor Code Quality
+static const CWE CWE597(597U);   // Use of Wrong Operator in String Comparison
+static const CWE CWE628(628U);   // Function Call with Incorrectly Specified Arguments
+static const CWE CWE664(664U);   // Improper Control of a Resource Through its Lifetime
+static const CWE CWE667(667U);   // Improper Locking
+static const CWE CWE704(704U);   // Incorrect Type Conversion or Cast
+static const CWE CWE762(762U);   // Mismatched Memory Management Routines
+static const CWE CWE786(786U);   // Access of Memory Location Before Start of Buffer
+static const CWE CWE788(788U);   // Access of Memory Location After End of Buffer
+static const CWE CWE825(825U);   // Expired Pointer Dereference
+static const CWE CWE833(833U);   // Deadlock
+static const CWE CWE834(834U);   // Excessive Iteration
+
+static bool isElementAccessYield(Library::Container::Yield yield)
+{
+    return contains({Library::Container::Yield::ITEM, Library::Container::Yield::AT_INDEX}, yield);
+}
+
+static bool containerAppendsElement(const Library::Container* container, const Token* parent)
+{
+    if (Token::Match(parent, ". %name% (")) {
+        const Library::Container::Action action = container->getAction(parent->strAt(1));
+        if (contains({Library::Container::Action::INSERT,
+                      Library::Container::Action::APPEND,
+                      Library::Container::Action::CHANGE,
+                      Library::Container::Action::CHANGE_INTERNAL,
+                      Library::Container::Action::PUSH,
+                      Library::Container::Action::RESIZE},
+                     action))
+            return true;
+    }
+    return false;
+}
+
+static bool containerYieldsElement(const Library::Container* container, const Token* parent)
+{
+    if (Token::Match(parent, ". %name% (")) {
+        const Library::Container::Yield yield = container->getYield(parent->strAt(1));
+        if (isElementAccessYield(yield))
+            return true;
+    }
+    return false;
+}
+
+static bool containerPopsElement(const Library::Container* container, const Token* parent)
+{
+    if (Token::Match(parent, ". %name% (")) {
+        const Library::Container::Action action = container->getAction(parent->strAt(1));
+        if (contains({ Library::Container::Action::POP }, action))
+            return true;
+    }
+    return false;
+}
+
+static const Token* getContainerIndex(const Library::Container* container, const Token* parent)
+{
+    if (Token::Match(parent, ". %name% (")) {
+        const Library::Container::Yield yield = container->getYield(parent->strAt(1));
+        if (yield == Library::Container::Yield::AT_INDEX && !Token::simpleMatch(parent->tokAt(2), "( )"))
+            return parent->tokAt(2)->astOperand2();
+    }
+    if (!container->arrayLike_indexOp && !container->stdStringLike)
+        return nullptr;
+    if (Token::simpleMatch(parent, "["))
+        return parent->astOperand2();
+    return nullptr;
+}
+
+static const Token* getContainerFromSize(const Library::Container* container, const Token* tok)
+{
+    if (!tok)
+        return nullptr;
+    if (Token::Match(tok->tokAt(-2), ". %name% (")) {
+        const Library::Container::Yield yield = container->getYield(tok->strAt(-1));
+        if (yield == Library::Container::Yield::SIZE)
+            return tok->tokAt(-2)->astOperand1();
+    }
+    return nullptr;
+}
 
 void CheckStl::outOfBounds()
 {
+    logChecker("CheckStl::outOfBounds");
+
     for (const Scope *function : mTokenizer->getSymbolDatabase()->functionScopes) {
         for (const Token *tok = function->bodyStart; tok != function->bodyEnd; tok = tok->next()) {
             const Library::Container *container = getLibraryContainer(tok);
-            if (!container)
+            if (!container || container->stdAssociativeLike)
                 continue;
             const Token * parent = astParentSkipParens(tok);
+            const Token* accessTok = parent;
+            if (Token::simpleMatch(accessTok, ".") && Token::simpleMatch(accessTok->astParent(), "("))
+                accessTok = accessTok->astParent();
+            if (astIsIterator(accessTok) && Token::simpleMatch(accessTok->astParent(), "+"))
+                accessTok = accessTok->astParent();
+            const Token* indexTok = getContainerIndex(container, parent);
+            if (indexTok == tok)
+                continue;
             for (const ValueFlow::Value &value : tok->values()) {
                 if (!value.isContainerSizeValue())
                     continue;
                 if (value.isImpossible())
                     continue;
-                if (value.isInconclusive() && !mSettings->inconclusive)
+                if (value.isInconclusive() && !mSettings->certainty.isEnabled(Certainty::inconclusive))
                     continue;
-                if (!value.errorSeverity() && !mSettings->isEnabled(Settings::WARNING))
+                if (!value.errorSeverity() && !mSettings->severity.isEnabled(Severity::warning))
                     continue;
-                if (value.intvalue == 0 && Token::Match(parent, ". %name% (") && container->getYield(parent->strAt(1)) == Library::Container::Yield::ITEM) {
-                    outOfBoundsError(parent->tokAt(2), tok->expressionString(), &value, parent->strAt(1), nullptr);
+                if (value.intvalue == 0 && (indexTok ||
+                                            (containerYieldsElement(container, parent) && !containerAppendsElement(container, parent)) ||
+                                            containerPopsElement(container, parent))) {
+                    std::string indexExpr;
+                    if (indexTok && !indexTok->hasKnownValue())
+                        indexExpr = indexTok->expressionString();
+                    outOfBoundsError(accessTok, tok->expressionString(), &value, indexExpr, nullptr);
                     continue;
                 }
-                if (Token::Match(tok, "%name% . %name% (") && container->getYield(tok->strAt(2)) == Library::Container::Yield::START_ITERATOR) {
-                    const Token *fparent = tok->tokAt(3)->astParent();
-                    const Token *other = nullptr;
-                    if (Token::simpleMatch(fparent, "+") && fparent->astOperand1() == tok->tokAt(3))
-                        other = fparent->astOperand2();
-                    else if (Token::simpleMatch(fparent, "+") && fparent->astOperand2() == tok->tokAt(3))
-                        other = fparent->astOperand1();
-                    if (other && other->hasKnownIntValue() && other->getKnownIntValue() > value.intvalue) {
-                        outOfBoundsError(fparent, tok->expressionString(), &value, other->expressionString(), &other->values().back());
-                        continue;
-                    } else if (other && !other->hasKnownIntValue() && value.isKnown() && value.intvalue==0) {
-                        outOfBoundsError(fparent, tok->expressionString(), &value, other->expressionString(), nullptr);
+                if (indexTok) {
+                    std::vector<ValueFlow::Value> indexValues =
+                        ValueFlow::isOutOfBounds(value, indexTok, mSettings->severity.isEnabled(Severity::warning));
+                    if (!indexValues.empty()) {
+                        outOfBoundsError(
+                            accessTok, tok->expressionString(), &value, indexTok->expressionString(), &indexValues.front());
                         continue;
                     }
                 }
-                if (!container->arrayLike_indexOp && !container->stdStringLike)
-                    continue;
-                if (value.intvalue == 0 && Token::Match(parent, "[") && tok == parent->astOperand1()) {
-                    outOfBoundsError(parent, tok->expressionString(), &value, "", nullptr);
+            }
+            if (indexTok && !indexTok->hasKnownIntValue()) {
+                const ValueFlow::Value* value =
+                    ValueFlow::findValue(indexTok->values(), *mSettings, [&](const ValueFlow::Value& v) {
+                    if (!v.isSymbolicValue())
+                        return false;
+                    if (v.isImpossible())
+                        return false;
+                    if (v.intvalue < 0)
+                        return false;
+                    const Token* sizeTok = v.tokvalue;
+                    if (sizeTok && sizeTok->isCast())
+                        sizeTok = sizeTok->astOperand2() ? sizeTok->astOperand2() : sizeTok->astOperand1();
+                    const Token* containerTok = getContainerFromSize(container, sizeTok);
+                    if (!containerTok)
+                        return false;
+                    return containerTok->exprId() == tok->exprId();
+                });
+                if (!value)
                     continue;
-                }
-                if (container->arrayLike_indexOp && Token::Match(parent, "[")) {
-                    const ValueFlow::Value *indexValue = parent->astOperand2() ? parent->astOperand2()->getMaxValue(false) : nullptr;
-                    if (indexValue && indexValue->intvalue >= value.intvalue) {
-                        outOfBoundsError(parent, tok->expressionString(), &value, parent->astOperand2()->expressionString(), indexValue);
-                        continue;
-                    }
-                    if (mSettings->isEnabled(Settings::WARNING)) {
-                        indexValue = parent->astOperand2() ? parent->astOperand2()->getMaxValue(true) : nullptr;
-                        if (indexValue && indexValue->intvalue >= value.intvalue) {
-                            outOfBoundsError(parent, tok->expressionString(), &value, parent->astOperand2()->expressionString(), indexValue);
-                            continue;
-                        }
-                    }
-                }
+                outOfBoundsError(accessTok, tok->expressionString(), nullptr, indexTok->expressionString(), value);
             }
         }
     }
 }
 
+static std::string indexValueString(const ValueFlow::Value& indexValue, const std::string& containerName = "")
+{
+    if (indexValue.isIteratorStartValue())
+        return "at position " + MathLib::toString(indexValue.intvalue) + " from the beginning";
+    if (indexValue.isIteratorEndValue())
+        return "at position " + MathLib::toString(-indexValue.intvalue) + " from the end";
+    std::string indexString = MathLib::toString(indexValue.intvalue);
+    if (indexValue.isSymbolicValue()) {
+        indexString = containerName + ".size()";
+        if (indexValue.intvalue != 0)
+            indexString += "+" + MathLib::toString(indexValue.intvalue);
+    }
+    if (indexValue.bound == ValueFlow::Value::Bound::Lower)
+        return "greater or equal to " + indexString;
+    return indexString;
+}
+
 void CheckStl::outOfBoundsError(const Token *tok, const std::string &containerName, const ValueFlow::Value *containerSize, const std::string &index, const ValueFlow::Value *indexValue)
 {
     // Do not warn if both the container size and index value are possible
@@ -121,22 +229,27 @@ void CheckStl::outOfBoundsError(const Token *tok, const std::string &containerNa
     const std::string expression = tok ? tok->expressionString() : (containerName+"[x]");
 
     std::string errmsg;
-    if (!containerSize)
-        errmsg = "Out of bounds access in expression '" + expression + "'";
-    else if (containerSize->intvalue == 0) {
+    if (!containerSize) {
+        if (indexValue && indexValue->condition)
+            errmsg = ValueFlow::eitherTheConditionIsRedundant(indexValue->condition) + " or '" + index +
+                     "' can have the value " + indexValueString(*indexValue, containerName) + ". Expression '" +
+                     expression + "' causes access out of bounds.";
+        else
+            errmsg = "Out of bounds access in expression '" + expression + "'";
+    } else if (containerSize->intvalue == 0) {
         if (containerSize->condition)
-            errmsg = ValueFlow::eitherTheConditionIsRedundant(containerSize->condition) + " or expression '" + expression + "' cause access out of bounds.";
-        else if (indexValue == nullptr && !index.empty())
+            errmsg = ValueFlow::eitherTheConditionIsRedundant(containerSize->condition) + " or expression '" + expression + "' causes access out of bounds.";
+        else if (indexValue == nullptr && !index.empty() && tok->valueType() && tok->valueType()->type == ValueType::ITERATOR)
             errmsg = "Out of bounds access in expression '" + expression + "' because '$symbol' is empty and '" + index + "' may be non-zero.";
         else
             errmsg = "Out of bounds access in expression '" + expression + "' because '$symbol' is empty.";
     } else if (indexValue) {
         if (containerSize->condition)
-            errmsg = ValueFlow::eitherTheConditionIsRedundant(containerSize->condition) + " or $symbol size can be " + MathLib::toString(containerSize->intvalue) + ". Expression '" + expression + "' cause access out of bounds.";
+            errmsg = ValueFlow::eitherTheConditionIsRedundant(containerSize->condition) + " or size of '$symbol' can be " + MathLib::toString(containerSize->intvalue) + ". Expression '" + expression + "' causes access out of bounds.";
         else if (indexValue->condition)
-            errmsg = ValueFlow::eitherTheConditionIsRedundant(indexValue->condition) + " or '" + index + "' can have the value " + MathLib::toString(indexValue->intvalue) + ". Expression '" + expression + "' cause access out of bounds.";
+            errmsg = ValueFlow::eitherTheConditionIsRedundant(indexValue->condition) + " or '" + index + "' can have the value " + indexValueString(*indexValue) + ". Expression '" + expression + "' causes access out of bounds.";
         else
-            errmsg = "Out of bounds access in '" + expression + "', if '$symbol' size is " + MathLib::toString(containerSize->intvalue) + " and '" + index + "' is " + MathLib::toString(indexValue->intvalue);
+            errmsg = "Out of bounds access in '" + expression + "', if '$symbol' size is " + MathLib::toString(containerSize->intvalue) + " and '" + index + "' is " + indexValueString(*indexValue);
     } else {
         // should not happen
         return;
@@ -149,21 +262,21 @@ void CheckStl::outOfBoundsError(const Token *tok, const std::string &containerNa
         ErrorPath errorPath1 = getErrorPath(tok, containerSize, "Access out of bounds");
         ErrorPath errorPath2 = getErrorPath(tok, indexValue, "Access out of bounds");
         if (errorPath1.size() <= 1)
-            errorPath = errorPath2;
+            errorPath = std::move(errorPath2);
         else if (errorPath2.size() <= 1)
-            errorPath = errorPath1;
+            errorPath = std::move(errorPath1);
         else {
-            errorPath = errorPath1;
+            errorPath = std::move(errorPath1);
             errorPath.splice(errorPath.end(), errorPath2);
         }
     }
 
-    reportError(errorPath,
+    reportError(std::move(errorPath),
                 (containerSize && !containerSize->errorSeverity()) || (indexValue && !indexValue->errorSeverity()) ? Severity::warning : Severity::error,
                 "containerOutOfBounds",
                 "$symbol:" + containerName +"\n" + errmsg,
                 CWE398,
-                (containerSize && containerSize->isInconclusive()) || (indexValue && indexValue->isInconclusive()));
+                (containerSize && containerSize->isInconclusive()) || (indexValue && indexValue->isInconclusive()) ? Certainty::inconclusive : Certainty::normal);
 }
 
 bool CheckStl::isContainerSize(const Token *containerToken, const Token *expr) const
@@ -172,9 +285,9 @@ bool CheckStl::isContainerSize(const Token *containerToken, const Token *expr) c
         return false;
     if (!Token::Match(expr->astOperand1(), ". %name% ("))
         return false;
-    if (!isSameExpression(mTokenizer->isCPP(), false, containerToken, expr->astOperand1()->astOperand1(), mSettings->library, false, false))
+    if (!isSameExpression(false, containerToken, expr->astOperand1()->astOperand1(), *mSettings, false, false))
         return false;
-    return containerToken->valueType()->container->getYield(expr->previous()->str()) == Library::Container::Yield::SIZE;
+    return containerToken->valueType()->container->getYield(expr->strAt(-1)) == Library::Container::Yield::SIZE;
 }
 
 bool CheckStl::isContainerSizeGE(const Token * containerToken, const Token *expr) const
@@ -191,7 +304,7 @@ bool CheckStl::isContainerSizeGE(const Token * containerToken, const Token *expr
             mul = expr->astOperand1();
         else
             return false;
-        return mul && (!mul->hasKnownIntValue() || mul->values().front().intvalue != 0);
+        return mul && (!mul->hasKnownIntValue() || mul->getKnownIntValue() != 0);
     }
     if (expr->str() == "+") {
         const Token *op;
@@ -201,13 +314,14 @@ bool CheckStl::isContainerSizeGE(const Token * containerToken, const Token *expr
             op = expr->astOperand1();
         else
             return false;
-        return op && op->getValueGE(0, mSettings);
+        return op && op->getValueGE(0, *mSettings);
     }
     return false;
 }
 
 void CheckStl::outOfBoundsIndexExpression()
 {
+    logChecker("CheckStl::outOfBoundsIndexExpression");
     for (const Scope *function : mTokenizer->getSymbolDatabase()->functionScopes) {
         for (const Token *tok = function->bodyStart; tok != function->bodyEnd; tok = tok->next()) {
             if (!tok->isName() || !tok->valueType())
@@ -228,7 +342,7 @@ void CheckStl::outOfBoundsIndexExpression()
 void CheckStl::outOfBoundsIndexExpressionError(const Token *tok, const Token *index)
 {
     const std::string varname = tok ? tok->str() : std::string("var");
-    const std::string i = index ? index->expressionString() : std::string(varname + ".size()");
+    const std::string i = index ? index->expressionString() : (varname + ".size()");
 
     std::string errmsg = "Out of bounds access of $symbol, index '" + i + "' is out of bounds.";
 
@@ -237,7 +351,7 @@ void CheckStl::outOfBoundsIndexExpressionError(const Token *tok, const Token *in
                 "containerOutOfBoundsIndexExpression",
                 "$symbol:" + varname +"\n" + errmsg,
                 CWE398,
-                false);
+                Certainty::normal);
 }
 
 
@@ -245,7 +359,7 @@ void CheckStl::outOfBoundsIndexExpressionError(const Token *tok, const Token *in
 // Error message for bad iterator usage..
 void CheckStl::invalidIteratorError(const Token *tok, const std::string &iteratorName)
 {
-    reportError(tok, Severity::error, "invalidIterator1", "$symbol:"+iteratorName+"\nInvalid iterator: $symbol", CWE664, false);
+    reportError(tok, Severity::error, "invalidIterator1", "$symbol:"+iteratorName+"\nInvalid iterator: $symbol", CWE664, Certainty::normal);
 }
 
 void CheckStl::iteratorsError(const Token* tok, const std::string& containerName1, const std::string& containerName2)
@@ -253,41 +367,20 @@ void CheckStl::iteratorsError(const Token* tok, const std::string& containerName
     reportError(tok, Severity::error, "iterators1",
                 "$symbol:" + containerName1 + "\n"
                 "$symbol:" + containerName2 + "\n"
-                "Same iterator is used with different containers '" + containerName1 + "' and '" + containerName2 + "'.", CWE664, false);
-}
-
-void CheckStl::iteratorsError(const Token* tok, const Token* containerTok, const std::string& containerName1, const std::string& containerName2)
-{
-    std::list<const Token*> callstack = { tok, containerTok };
-    reportError(callstack, Severity::error, "iterators2",
-                "$symbol:" + containerName1 + "\n"
-                "$symbol:" + containerName2 + "\n"
-                "Same iterator is used with different containers '" + containerName1 + "' and '" + containerName2 + "'.", CWE664, false);
+                "Same iterator is used with different containers '" + containerName1 + "' and '" + containerName2 + "'.", CWE664, Certainty::normal);
 }
 
 void CheckStl::iteratorsError(const Token* tok, const Token* containerTok, const std::string& containerName)
 {
     std::list<const Token*> callstack = { tok, containerTok };
-    reportError(callstack, Severity::error, "iterators3",
-                "$symbol:" + containerName + "\n"
-                "Same iterator is used with containers '" + containerName + "' that are defined in different scopes.", CWE664, false);
-}
-
-void CheckStl::iteratorsCmpError(const Token* cmpOperatorTok, const Token* containerTok1, const Token* containerTok2, const std::string& containerName1, const std::string& containerName2)
-{
-    std::list<const Token*> callstack = { cmpOperatorTok, containerTok1, containerTok2 };
-    reportError(callstack, Severity::error, "iteratorsCmp1",
-                "$symbol:" + containerName1 + "\n"
-                "$symbol:" + containerName2 + "\n"
-                "Comparison of iterators from containers '" + containerName1 + "' and '" + containerName2 + "'.", CWE664, false);
-}
-
-void CheckStl::iteratorsCmpError(const Token* cmpOperatorTok, const Token* containerTok1, const Token* containerTok2, const std::string& containerName)
-{
-    std::list<const Token*> callstack = { cmpOperatorTok, containerTok1, containerTok2 };
-    reportError(callstack, Severity::error, "iteratorsCmp2",
-                "$symbol:" + containerName + "\n"
-                "Comparison of iterators from containers '" + containerName + "' that are defined in different scopes.", CWE664, false);
+    reportError(callstack,
+                Severity::error,
+                "iterators3",
+                "$symbol:" + containerName +
+                "\n"
+                "Same iterator is used with containers '$symbol' that are temporaries or defined in different scopes.",
+                CWE664,
+                Certainty::normal);
 }
 
 // Error message used when dereferencing an iterator that has been erased..
@@ -299,13 +392,13 @@ void CheckStl::dereferenceErasedError(const Token *erased, const Token* deref, c
                     "$symbol:" + itername + "\n"
                     "Iterator '$symbol' used after element has been erased.\n"
                     "The iterator '$symbol' is invalid after the element it pointed to has been erased. "
-                    "Dereferencing or comparing it with another iterator is invalid operation.", CWE664, inconclusive);
+                    "Dereferencing or comparing it with another iterator is invalid operation.", CWE664, inconclusive ? Certainty::inconclusive : Certainty::normal);
     } else {
         reportError(deref, Severity::error, "eraseDereference",
                     "$symbol:" + itername + "\n"
                     "Invalid iterator '$symbol' used.\n"
                     "The iterator '$symbol' is invalid before being assigned. "
-                    "Dereferencing or comparing it with another iterator is invalid operation.", CWE664, inconclusive);
+                    "Dereferencing or comparing it with another iterator is invalid operation.", CWE664, inconclusive ? Certainty::inconclusive : Certainty::normal);
     }
 }
 
@@ -330,11 +423,10 @@ static bool isIterator(const Variable *var, bool& inconclusiveType)
         // look for operator* and operator++
         const Function* end = var->type()->getFunction("operator*");
         const Function* incOperator = var->type()->getFunction("operator++");
-        if (!end || end->argCount() > 0 || !incOperator) {
+        if (!end || end->argCount() > 0 || !incOperator)
             return false;
-        } else {
-            inconclusiveType = true; // heuristics only
-        }
+
+        inconclusiveType = true; // heuristics only
     }
 
     return true;
@@ -353,29 +445,6 @@ static std::string getContainerName(const Token *containerToken)
     return ret;
 }
 
-enum OperandPosition {
-    Left,
-    Right
-};
-
-static const Token* findIteratorContainer(const Token* start, const Token* end, nonneg int id)
-{
-    const Token* containerToken = nullptr;
-    for (const Token* tok = start; tok != end; tok = tok->next()) {
-        if (Token::Match(tok, "%varid% = %name% . %name% (", id)) {
-            // Iterator is assigned to value
-            if (tok->tokAt(5)->valueType() && tok->tokAt(5)->valueType()->type == ValueType::Type::ITERATOR) {
-                containerToken = tok->tokAt(2);
-            }
-        } else if (Token::Match(tok, "%varid% = %name% (", id)) {
-            // Prevent FP: iterator is assigned to something
-            // TODO: Fix it in future
-            containerToken = nullptr;
-        }
-    }
-    return containerToken;
-}
-
 static bool isVector(const Token* tok)
 {
     if (!tok)
@@ -387,6 +456,8 @@ static bool isVector(const Token* tok)
 
 void CheckStl::iterators()
 {
+    logChecker("CheckStl::iterators");
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
     // Filling map of iterators id and their scope begin
@@ -399,20 +470,18 @@ void CheckStl::iterators()
         if (iteratorId != 0)
             iteratorScopeBeginInfo[iteratorId] = var->nameToken();
     }
-    // Storage to save found comparison problems to avoid duplicate error messages
-    std::set<const Token*> foundOperatorErrors;
 
     for (const Variable* var : symbolDatabase->variableList()) {
         bool inconclusiveType=false;
         if (!isIterator(var, inconclusiveType))
             continue;
-        if (inconclusiveType && !mSettings->inconclusive)
+        if (inconclusiveType && !mSettings->certainty.isEnabled(Certainty::inconclusive))
             continue;
 
         const int iteratorId = var->declarationId();
 
         // the validIterator flag says if the iterator has a valid value or not
-        bool validIterator = Token::Match(var->nameToken()->next(), "[(=:{]");
+        bool validIterator = Token::Match(var->nameToken()->next(), "[(=:{[]");
         const Scope* invalidationScope = nullptr;
 
         // The container this iterator can be used with
@@ -438,16 +507,8 @@ void CheckStl::iterators()
                 invalidationScope = nullptr;
             }
 
-            // Is comparison expression?
-            // Check whether iterator compared against different container or iterator of different container?
-            if (tok2->isComparisonOp() && tok2->astOperand1() && tok2->astOperand2() &&
-                (foundOperatorErrors.find(tok2) == foundOperatorErrors.end()) &&
-                compareIteratorAgainstDifferentContainer(tok2, containerToken, iteratorId, iteratorScopeBeginInfo)) {
-                foundOperatorErrors.insert(tok2);
-            }
-
             // Is the iterator used in a insert/erase operation?
-            else if (Token::Match(tok2, "%name% . insert|erase ( *| %varid% )|,", iteratorId) && !isVector(tok2)) {
+            if (Token::Match(tok2, "%name% . insert|erase ( *| %varid% )|,", iteratorId) && !isVector(tok2)) {
                 const Token* itTok = tok2->tokAt(4);
                 if (itTok->str() == "*") {
                     if (tok2->strAt(2) == "insert")
@@ -470,7 +531,7 @@ void CheckStl::iterators()
                         continue; // No warning
 
                     // skip error message if the iterator is erased/inserted by value
-                    if (itTok->previous()->str() == "*")
+                    if (itTok->strAt(-1) == "*")
                         continue;
 
                     // inserting iterator range..
@@ -492,6 +553,21 @@ void CheckStl::iterators()
                             continue;
                     }
 
+                    // Not different containers if a reference is used..
+                    if (containerToken && containerToken->variable() && containerToken->variable()->isReference()) {
+                        const Token *nameToken = containerToken->variable()->nameToken();
+                        if (Token::Match(nameToken, "%name% =")) {
+                            const Token *name1 = nameToken->tokAt(2);
+                            const Token *name2 = tok2;
+                            while (Token::Match(name1, "%name%|.|::") && name2 && name1->str() == name2->str()) {
+                                name1 = name1->next();
+                                name2 = name2->next();
+                            }
+                            if (!Token::simpleMatch(name1, ";") || !Token::Match(name2, "[;,()=]"))
+                                continue;
+                        }
+                    }
+
                     // Show error message, mismatching iterator is used.
                     iteratorsError(tok2, getContainerName(containerToken), getContainerName(tok2));
                 }
@@ -563,65 +639,30 @@ void CheckStl::iterators()
     }
 }
 
-bool CheckStl::compareIteratorAgainstDifferentContainer(const Token* operatorTok, const Token* containerTok, const nonneg int iteratorId, const std::map<int, const Token*>& iteratorScopeBeginInfo)
+void CheckStl::mismatchingContainerIteratorError(const Token* containerTok, const Token* iterTok, const Token* containerTok2)
 {
-    if (!containerTok)
-        return false;
-
-    const Token *otherOperand = nullptr;
-    OperandPosition operandPosition;
-    if (operatorTok->astOperand1()->varId() == iteratorId) {
-        otherOperand = operatorTok->astOperand2();
-        operandPosition = OperandPosition::Right;
-    } else if (operatorTok->astOperand2()->varId() == iteratorId) {
-        otherOperand = operatorTok->astOperand1();
-        operandPosition = OperandPosition::Left;
-    }
-
-    if (!otherOperand)
-        return false;
-
-    const Token * const otherExprPart = otherOperand->tokAt(-3);
-    if (Token::Match(otherExprPart, "%name% . end|rend|cend|crend ( )") && otherExprPart->varId() != containerTok->varId()) {
-        const std::string& firstContainerName = getContainerName(containerTok);
-        const std::string& secondContainerName = getContainerName(otherExprPart);
-        if (firstContainerName != secondContainerName) {
-            if (operandPosition == OperandPosition::Right)
-                iteratorsError(operatorTok, containerTok, firstContainerName, secondContainerName);
-            else
-                iteratorsError(operatorTok, containerTok, secondContainerName, firstContainerName);
-        } else {
-            iteratorsError(operatorTok, containerTok, firstContainerName);
-        }
-        return true;
-    } else {
-        const int otherId = otherOperand->varId();
-        auto it = iteratorScopeBeginInfo.find(otherId);
-        if (it != iteratorScopeBeginInfo.end()) {
-            const Token* otherContainerToken = findIteratorContainer(it->second, operatorTok->astOperand1(), otherId);
-            if (otherContainerToken && otherContainerToken->varId() != containerTok->varId()) {
-                const std::string& firstContainerName = getContainerName(containerTok);
-                const std::string& secondContainerName = getContainerName(otherContainerToken);
-                if (firstContainerName != secondContainerName) {
-                    if (operandPosition == OperandPosition::Right)
-                        iteratorsCmpError(operatorTok, containerTok, otherContainerToken, firstContainerName, secondContainerName);
-                    else
-                        iteratorsCmpError(operatorTok, containerTok, otherContainerToken, secondContainerName, firstContainerName);
-                } else {
-                    iteratorsCmpError(operatorTok, containerTok, otherContainerToken, firstContainerName);
-                }
-                return true;
-            }
-        }
-    }
-
-    return false;
+    const std::string container(containerTok ? containerTok->expressionString() : std::string("v1"));
+    const std::string container2(containerTok2 ? containerTok2->expressionString() : std::string("v2"));
+    const std::string iter(iterTok ? iterTok->expressionString() : std::string("it"));
+    reportError(containerTok,
+                Severity::error,
+                "mismatchingContainerIterator",
+                "Iterator '" + iter + "' referring to container '" + container2 + "' is used with container '" + container + "'.",
+                CWE664,
+                Certainty::normal);
 }
 
 // Error message for bad iterator usage..
-void CheckStl::mismatchingContainersError(const Token *tok)
+void CheckStl::mismatchingContainersError(const Token* tok1, const Token* tok2)
 {
-    reportError(tok, Severity::error, "mismatchingContainers", "Iterators of different containers are used together.", CWE664, false);
+    const std::string expr1(tok1 ? tok1->expressionString() : std::string("v1"));
+    const std::string expr2(tok2 ? tok2->expressionString() : std::string("v2"));
+    reportError(tok1,
+                Severity::error,
+                "mismatchingContainers",
+                "Iterators of different containers '" + expr1 + "' and '" + expr2 + "' are used together.",
+                CWE664,
+                Certainty::normal);
 }
 
 void CheckStl::mismatchingContainerExpressionError(const Token *tok1, const Token *tok2)
@@ -630,293 +671,620 @@ void CheckStl::mismatchingContainerExpressionError(const Token *tok1, const Toke
     const std::string expr2(tok2 ? tok2->expressionString() : std::string("v2"));
     reportError(tok1, Severity::warning, "mismatchingContainerExpression",
                 "Iterators to containers from different expressions '" +
-                expr1 + "' and '" + expr2 + "' are used together.", CWE664, false);
+                expr1 + "' and '" + expr2 + "' are used together.", CWE664, Certainty::normal);
 }
 
 void CheckStl::sameIteratorExpressionError(const Token *tok)
 {
-    reportError(tok, Severity::style, "sameIteratorExpression", "Same iterators expression are used for algorithm.", CWE664, false);
-}
-
-static const std::set<std::string> algorithm2 = { // func(begin1, end1
-    "binary_search", "copy", "copy_if", "equal_range"
-    , "generate", "is_heap", "is_heap_until", "is_partitioned"
-    , "is_permutation", "is_sorted", "is_sorted_until", "lower_bound", "make_heap", "max_element", "minmax_element"
-    , "min_element", "mismatch", "move", "move_backward", "next_permutation", "partition", "partition_copy"
-    , "partition_point", "pop_heap", "prev_permutation", "push_heap", "random_shuffle", "remove", "remove_copy"
-    , "remove_copy_if", "remove_if", "replace", "replace_copy", "replace_copy_if", "replace_if", "reverse", "reverse_copy"
-    , "shuffle", "sort", "sort_heap", "stable_partition", "stable_sort", "swap_ranges", "transform", "unique"
-    , "unique_copy", "upper_bound", "string", "wstring", "u16string", "u32string"
-};
-static const std::set<std::string> algorithm22 = { // func(begin1, end1, begin2, end2
-    "includes", "lexicographical_compare", "merge", "partial_sort_copy"
-    , "set_difference", "set_intersection", "set_symmetric_difference", "set_union"
-};
-static const std::set<std::string> algorithm1x1 = {  // func(begin1, x, end1
-    "nth_element", "partial_sort", "rotate", "rotate_copy"
-};
-
-static const std::string iteratorBeginFuncPattern = "begin|cbegin|rbegin|crbegin";
-static const std::string iteratorEndFuncPattern = "end|cend|rend|crend";
-
-static const std::string pattern1x1_1 = "%name% . " + iteratorBeginFuncPattern + " ( ) , ";
-static const std::string pattern1x1_2 = "%name% . " + iteratorEndFuncPattern + " ( ) ,|)";
-static const std::string pattern2 = pattern1x1_1 + pattern1x1_2;
-
-static const Variable *getContainer(const Token *argtok)
-{
-    while (argtok && argtok->astOperand1())
-        argtok = argtok->astOperand1();
-    if (!Token::Match(argtok, "%var% . begin|end|rbegin|rend ( )")) // TODO: use Library yield
-        return nullptr;
-    const Variable *var = argtok->variable();
-    if (var && Token::simpleMatch(var->typeStartToken(), "std ::"))
-        return var;
-    return nullptr;
+    reportError(tok, Severity::style, "sameIteratorExpression", "Same iterators expression are used for algorithm.", CWE664, Certainty::normal);
 }
 
-static const Token * getIteratorExpression(const Token * tok)
+static std::vector<const Token*> getAddressContainer(const Token* tok)
 {
-    if (!tok)
-        return nullptr;
-    if (tok->isUnaryOp("*"))
-        return nullptr;
-    if (!tok->isName()) {
-        const Token *iter1 = getIteratorExpression(tok->astOperand1());
-        if (iter1)
-            return iter1;
-        if (tok->str() == "(")
-            return nullptr;
-        const Token *iter2 = getIteratorExpression(tok->astOperand2());
-        if (iter2)
-            return iter2;
-    } else if (Token::Match(tok, "begin|cbegin|rbegin|crbegin|end|cend|rend|crend (")) {
-        if (Token::Match(tok->previous(), ". %name% ( ) !!."))
-            return tok->previous()->astOperand1();
-        if (!Token::simpleMatch(tok->previous(), ".") && Token::Match(tok, "%name% ( !!)") && !Token::simpleMatch(tok->linkAt(1), ") ."))
-            return tok->next()->astOperand2();
+    if (Token::simpleMatch(tok, "[") && tok->astOperand1())
+        return { tok->astOperand1() };
+    while (Token::simpleMatch(tok, "::") && tok->astOperand2())
+        tok = tok->astOperand2();
+    std::vector<ValueFlow::Value> values = ValueFlow::getLifetimeObjValues(tok, /*inconclusive*/ false);
+    std::vector<const Token*> res;
+    for (const auto& v : values) {
+        if (v.tokvalue)
+            res.emplace_back(v.tokvalue);
     }
-    return nullptr;
+    if (res.empty())
+        res.emplace_back(tok);
+    return res;
+}
+
+static bool isSameIteratorContainerExpression(const Token* tok1,
+                                              const Token* tok2,
+                                              const Settings& settings,
+                                              ValueFlow::Value::LifetimeKind kind = ValueFlow::Value::LifetimeKind::Iterator)
+{
+    if (isSameExpression(false, tok1, tok2, settings, false, false)) {
+        return !astIsContainerOwned(tok1) || !isTemporary(tok1, &settings.library);
+    }
+    if (astContainerYield(tok2, settings.library) == Library::Container::Yield::ITEM)
+        return true;
+    if (kind == ValueFlow::Value::LifetimeKind::Address || kind == ValueFlow::Value::LifetimeKind::Iterator) {
+        const auto address1 = getAddressContainer(tok1);
+        const auto address2 = getAddressContainer(tok2);
+        return std::any_of(address1.begin(), address1.end(), [&](const Token* tok1) {
+            return std::any_of(address2.begin(), address2.end(), [&](const Token* tok2) {
+                return isSameExpression(false, tok1, tok2, settings, false, false);
+            });
+        });
+    }
+    return false;
+}
+
+// First it groups the lifetimes together using std::partition with the lifetimes that refer to the same token or token of a subexpression.
+// Then it finds the lifetime in that group that refers to the "highest" parent using std::min_element and adds that to the vector.
+static std::vector<ValueFlow::Value> pruneLifetimes(std::vector<ValueFlow::Value> lifetimes)
+{
+    std::vector<ValueFlow::Value> result;
+    auto start = lifetimes.begin();
+    while (start != lifetimes.end())
+    {
+        const Token* tok1 = start->tokvalue;
+        auto it = std::partition(start, lifetimes.end(), [&](const ValueFlow::Value& v) {
+            const Token* tok2 = v.tokvalue;
+            return start->lifetimeKind == v.lifetimeKind && (astHasToken(tok1, tok2) || astHasToken(tok2, tok1));
+        });
+        auto root = std::min_element(start, it, [](const ValueFlow::Value& x, const ValueFlow::Value& y) {
+            return x.tokvalue != y.tokvalue && astHasToken(x.tokvalue, y.tokvalue);
+        });
+        result.push_back(*root);
+        start = it;
+    }
+    return result;
+}
+
+static ValueFlow::Value getLifetimeIteratorValue(const Token* tok, MathLib::bigint path = 0)
+{
+    auto findIterVal = [](const std::vector<ValueFlow::Value>& values, const std::vector<ValueFlow::Value>::const_iterator beg) {
+        return std::find_if(beg, values.cend(), [](const ValueFlow::Value& v) {
+            return v.lifetimeKind == ValueFlow::Value::LifetimeKind::Iterator;
+        });
+    };
+    std::vector<ValueFlow::Value> values = pruneLifetimes(ValueFlow::getLifetimeObjValues(tok, false, path));
+    auto it = findIterVal(values, values.begin());
+    if (it != values.end()) {
+        auto it2 = findIterVal(values, it + 1);
+        if (it2 == values.cend())
+            return *it;
+    }
+    if (values.size() == 1)
+        return values.front();
+    return ValueFlow::Value{};
+}
+
+bool CheckStl::checkIteratorPair(const Token* tok1, const Token* tok2)
+{
+    if (!tok1)
+        return false;
+    if (!tok2)
+        return false;
+    ValueFlow::Value val1 = getLifetimeIteratorValue(tok1);
+    ValueFlow::Value val2 = getLifetimeIteratorValue(tok2);
+    if (val1.tokvalue && val2.tokvalue && val1.lifetimeKind == val2.lifetimeKind) {
+        if (val1.lifetimeKind == ValueFlow::Value::LifetimeKind::Lambda)
+            return false;
+        if (tok1->astParent() == tok2->astParent() && Token::Match(tok1->astParent(), "%comp%|-")) {
+            if (val1.lifetimeKind == ValueFlow::Value::LifetimeKind::Address)
+                return false;
+            if (val1.lifetimeKind == ValueFlow::Value::LifetimeKind::Object &&
+                (!astIsContainer(val1.tokvalue) || !astIsContainer(val2.tokvalue)))
+                return false;
+        }
+        if (isSameIteratorContainerExpression(val1.tokvalue, val2.tokvalue, *mSettings, val1.lifetimeKind))
+            return false;
+        if (val1.tokvalue->expressionString() == val2.tokvalue->expressionString())
+            iteratorsError(tok1, val1.tokvalue, val1.tokvalue->expressionString());
+        else
+            mismatchingContainersError(val1.tokvalue, val2.tokvalue);
+        return true;
+    }
+
+    if (Token::Match(tok1->astParent(), "%comp%|-")) {
+        if (astIsIntegral(tok1, true) || astIsIntegral(tok2, true) ||
+            astIsFloat(tok1, true) || astIsFloat(tok2, true))
+            return false;
+    }
+    const Token* iter1 = getIteratorExpression(tok1);
+    if (!iter1)
+        return false;
+    const Token* iter2 = getIteratorExpression(tok2);
+    if (!iter2)
+        return false;
+    if (!isSameIteratorContainerExpression(iter1, iter2, *mSettings)) {
+        mismatchingContainerExpressionError(iter1, iter2);
+        return true;
+    }
+    return false;
+}
+
+namespace {
+    struct ArgIteratorInfo {
+        const Token* tok;
+        const Library::ArgumentChecks::IteratorInfo* info;
+    };
 }
 
 void CheckStl::mismatchingContainers()
 {
+    logChecker("CheckStl::misMatchingContainers");
+
     // Check if different containers are used in various calls of standard functions
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
             if (Token::Match(tok, "%comp%|-")) {
-                const Token * iter1 = getIteratorExpression(tok->astOperand1());
-                const Token * iter2 = getIteratorExpression(tok->astOperand2());
-                if (iter1 && iter2 && !isSameExpression(true, false, iter1, iter2, mSettings->library, false, false)) {
-                    mismatchingContainerExpressionError(iter1, iter2);
+                if (checkIteratorPair(tok->astOperand1(), tok->astOperand2()))
                     continue;
-                }
             }
             if (!Token::Match(tok, "%name% ( !!)"))
                 continue;
             const Token * const ftok = tok;
-            const Token * firstArg = nullptr;
 
             const std::vector<const Token *> args = getArguments(ftok);
             if (args.size() < 2)
                 continue;
 
-            std::map<const Variable *, int> containerNr;
+            // Group args together by container
+            std::map<int, std::vector<ArgIteratorInfo>> containers;
             for (int argnr = 1; argnr <= args.size(); ++argnr) {
                 const Library::ArgumentChecks::IteratorInfo *i = mSettings->library.getArgIteratorInfo(ftok, argnr);
                 if (!i)
                     continue;
                 const Token * const argTok = args[argnr - 1];
-                if (i->first) {
-                    firstArg = argTok;
-                }
-                if (i->last && firstArg && argTok && isSameExpression(true, false, firstArg, argTok, mSettings->library, false, false)) {
-                    sameIteratorExpressionError(firstArg);
-                }
-                const Variable *c = getContainer(argTok);
-                if (c) {
-                    std::map<const Variable *, int>::const_iterator it = containerNr.find(c);
-                    if (it == containerNr.end()) {
-                        for (it = containerNr.begin(); it != containerNr.end(); ++it) {
-                            if (it->second == i->container) {
-                                mismatchingContainersError(argTok);
-                                break;
-                            }
-                        }
-                        containerNr[c] = i->container;
-                    } else if (it->second != i->container) {
-                        mismatchingContainersError(argTok);
-                    }
-                } else {
-                    if (i->last && firstArg && argTok) {
-                        const Token * iter1 = getIteratorExpression(firstArg);
-                        const Token * iter2 = getIteratorExpression(argTok);
-                        if (iter1 && iter2 && !isSameExpression(true, false, iter1, iter2, mSettings->library, false, false)) {
-                            mismatchingContainerExpressionError(iter1, iter2);
+                containers[i->container].emplace_back(ArgIteratorInfo{argTok, i});
+            }
+
+            // Lambda is used to escape the nested loops
+            [&] {
+                for (const auto& p : containers)
+                {
+                    const std::vector<ArgIteratorInfo>& cargs = p.second;
+                    for (ArgIteratorInfo iter1 : cargs) {
+                        for (ArgIteratorInfo iter2 : cargs) {
+                            if (iter1.tok == iter2.tok)
+                                continue;
+                            if (iter1.info->first && iter2.info->last &&
+                                isSameExpression(false, iter1.tok, iter2.tok, *mSettings, false, false))
+                                sameIteratorExpressionError(iter1.tok);
+                            if (checkIteratorPair(iter1.tok, iter2.tok))
+                                return;
                         }
                     }
                 }
-            }
-            const int ret = mSettings->library.returnValueContainer(ftok);
-            if (ret != -1 && Token::Match(ftok->next()->astParent(), "==|!=")) {
-                const Token *parent = ftok->next()->astParent();
-                const Token *other = (parent->astOperand1() == ftok->next()) ? parent->astOperand2() : parent->astOperand1();
-                const Variable *c = getContainer(other);
-                if (c) {
-                    const std::map<const Variable *, int>::const_iterator it = containerNr.find(c);
-                    if (it == containerNr.end() || it->second != ret)
-                        mismatchingContainersError(other);
-                }
-            }
+            }();
         }
     }
     for (const Variable *var : symbolDatabase->variableList()) {
-        if (var && var->isStlStringType() && Token::Match(var->nameToken(), "%var% (") && Token::Match(var->nameToken()->tokAt(2), pattern2.c_str())) {
+        if (var && var->isStlStringType() && Token::Match(var->nameToken(), "%var% (") &&
+            Token::Match(var->nameToken()->tokAt(2), "%name% . begin|cbegin|rbegin|crbegin ( ) , %name% . end|cend|rend|crend ( ) ,|)")) {
             if (var->nameToken()->strAt(2) != var->nameToken()->strAt(8)) {
-                mismatchingContainersError(var->nameToken());
+                mismatchingContainersError(var->nameToken(), var->nameToken()->tokAt(2));
             }
         }
     }
 }
 
-static bool isInvalidMethod(const Token * tok)
-{
-    if (Token::Match(tok->next(), ". assign|clear"))
-        return true;
-    if (Token::Match(tok->next(), "%assign%"))
-        return true;
-    if (isVector(tok) && Token::Match(tok->next(), ". insert|emplace|emplace_back|push_back|erase|pop_back|reserve ("))
-        return true;
-    return false;
-}
-
-static bool isVariableDecl(const Token* tok)
+void CheckStl::mismatchingContainerIterator()
 {
-    if (!tok)
-        return false;
-    const Variable* var = tok->variable();
-    if (!var)
-        return false;
-    if (var->nameToken() == tok)
-        return true;
-    if (Token::Match(var->declEndToken(), "; %var%") && var->declEndToken()->next() == tok)
-        return true;
-    return false;
-}
+    logChecker("CheckStl::misMatchingContainerIterator");
 
-void CheckStl::invalidContainer()
-{
+    // Check if different containers are used in various calls of standard functions
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
-    const Library& library = mSettings->library;
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
-            if (!Token::Match(tok, "%var%"))
+            if (!astIsContainer(tok))
                 continue;
-            if (tok->varId() == 0)
+            if (!astIsLHS(tok))
                 continue;
-            if (!astIsContainer(tok))
+            if (!Token::Match(tok->astParent(), ". %name% ( !!)"))
                 continue;
-            if (!isInvalidMethod(tok))
+            const Token* const ftok = tok->astParent()->next();
+            const std::vector<const Token *> args = getArguments(ftok);
+
+            const Library::Container * c = tok->valueType()->container;
+            const Library::Container::Action action = c->getAction(tok->strAt(2));
+            const Token* iterTok = nullptr;
+            if (action == Library::Container::Action::INSERT && args.size() == 2) {
+                // Skip if iterator pair
+                if (astIsIterator(args.back()))
+                    continue;
+                if (!astIsIterator(args.front()))
+                    continue;
+                iterTok = args.front();
+            } else if (action == Library::Container::Action::ERASE) {
+                if (!astIsIterator(args.front()))
+                    continue;
+                iterTok = args.front();
+            } else {
                 continue;
-            // Skip if the variable is assigned to
-            unsigned int skipVarId = 0;
-            if (Token::Match(tok->astTop(), "%assign%") && Token::Match(tok->astTop()->previous(), "%var%"))
-                skipVarId = tok->astTop()->previous()->varId();
-            const Token * endToken = nextAfterAstRightmostLeaf(tok->next()->astParent());
-            if (!endToken)
-                endToken = tok->next();
-            const ValueFlow::Value* v = nullptr;
-            ErrorPath errorPath;
-            PathAnalysis::Info info = PathAnalysis{endToken, library} .forwardFind([&](const PathAnalysis::Info& info) {
-                if (!info.tok->variable())
-                    return false;
-                if (info.tok->varId() == skipVarId)
-                    return false;
-                if (info.tok->variable()->isReference() &&
-                    !isVariableDecl(info.tok) &&
-                    reaches(info.tok->variable()->nameToken(), tok, library, nullptr)) {
+            }
 
-                    ErrorPath ep;
-                    bool addressOf = false;
-                    const Variable* var = getLifetimeVariable(info.tok, ep, &addressOf);
-                    // Check the reference is created before the change
-                    if (var && var->declarationId() == tok->varId() && !addressOf) {
-                        // An argument always reaches
-                        if (var->isArgument() || (!var->isReference() && !var->isRValueReference() &&
-                                                  !isVariableDecl(tok) && reaches(var->nameToken(), tok, library, &ep))) {
-                            errorPath = ep;
+            ValueFlow::Value val = getLifetimeIteratorValue(iterTok);
+            if (!val.tokvalue)
+                continue;
+            if (!val.isKnown() && Token::simpleMatch(val.tokvalue->astParent(), ":"))
+                continue;
+            if (val.lifetimeKind != ValueFlow::Value::LifetimeKind::Iterator)
+                continue;
+            if (iterTok->str() == "*" && iterTok->astOperand1()->valueType() && iterTok->astOperand1()->valueType()->type == ValueType::ITERATOR)
+                continue;
+            if (isSameIteratorContainerExpression(tok, val.tokvalue, *mSettings))
+                continue;
+            mismatchingContainerIteratorError(tok, iterTok, val.tokvalue);
+        }
+    }
+}
+
+static const Token* getInvalidMethod(const Token* tok)
+{
+    if (!astIsLHS(tok))
+        return nullptr;
+    if (Token::Match(tok->astParent(), ". assign|clear|swap"))
+        return tok->astParent()->next();
+    if (Token::Match(tok->astParent(), "%assign%"))
+        return tok->astParent();
+    const Token* ftok = nullptr;
+    if (Token::Match(tok->astParent(), ". %name% ("))
+        ftok = tok->astParent()->next();
+    if (!ftok)
+        return nullptr;
+    if (const Library::Container * c = tok->valueType()->container) {
+        const Library::Container::Action action = c->getAction(ftok->str());
+        if (c->unstableErase) {
+            if (action == Library::Container::Action::ERASE)
+                return ftok;
+        }
+        if (c->unstableInsert) {
+            if (action == Library::Container::Action::RESIZE)
+                return ftok;
+            if (action == Library::Container::Action::CLEAR)
+                return ftok;
+            if (action == Library::Container::Action::PUSH)
+                return ftok;
+            if (action == Library::Container::Action::POP)
+                return ftok;
+            if (action == Library::Container::Action::INSERT)
+                return ftok;
+            if (action == Library::Container::Action::CHANGE)
+                return ftok;
+            if (action == Library::Container::Action::CHANGE_INTERNAL)
+                return ftok;
+            if (Token::Match(ftok, "insert|emplace"))
+                return ftok;
+        }
+    }
+    return nullptr;
+}
+
+namespace {
+    struct InvalidContainerAnalyzer {
+        struct Info {
+            struct Reference {
+                const Token* tok;
+                ErrorPath errorPath;
+                const Token* ftok;
+            };
+            std::unordered_map<int, Reference> expressions;
+
+            void add(const std::vector<Reference>& refs) {
+                for (const Reference& r : refs) {
+                    add(r);
+                }
+            }
+            void add(const Reference& r) {
+                if (!r.tok)
+                    return;
+                expressions.emplace(r.tok->exprId(), r);
+            }
+
+            std::vector<Reference> invalidTokens() const {
+                std::vector<Reference> result;
+                std::transform(expressions.cbegin(), expressions.cend(), std::back_inserter(result), SelectMapValues{});
+                return result;
+            }
+        };
+        std::unordered_map<const Function*, Info> invalidMethods;
+
+        std::vector<Info::Reference> invalidatesContainer(const Token* tok) const {
+            std::vector<Info::Reference> result;
+            if (Token::Match(tok, "%name% (")) {
+                const Function* f = tok->function();
+                if (!f)
+                    return result;
+                ErrorPathItem epi = std::make_pair(tok, "Calling function " + tok->str());
+                const bool dependsOnThis = exprDependsOnThis(tok->next());
+                auto it = invalidMethods.find(f);
+                if (it != invalidMethods.end()) {
+                    std::vector<Info::Reference> refs = it->second.invalidTokens();
+                    std::copy_if(refs.cbegin(), refs.cend(), std::back_inserter(result), [&](const Info::Reference& r) {
+                        const Variable* var = r.tok->variable();
+                        if (!var)
+                            return false;
+                        if (dependsOnThis && !var->isLocal() && !var->isGlobal() && !var->isStatic())
                             return true;
+                        if (!var->isArgument())
+                            return false;
+                        if (!var->isReference())
+                            return false;
+                        return true;
+                    });
+                    std::vector<const Token*> args = getArguments(tok);
+                    for (Info::Reference& r : result) {
+                        r.errorPath.push_front(epi);
+                        r.ftok = tok;
+                        const Variable* var = r.tok->variable();
+                        if (!var)
+                            continue;
+                        if (var->isArgument()) {
+                            const int n = getArgumentPos(var, f);
+                            const Token* tok2 = nullptr;
+                            if (n >= 0 && n < args.size())
+                                tok2 = args[n];
+                            r.tok = tok2;
                         }
                     }
                 }
-                for (const ValueFlow::Value& val:info.tok->values()) {
-                    if (!val.isLocalLifetimeValue())
-                        continue;
-                    if (val.lifetimeKind == ValueFlow::Value::LifetimeKind::Address)
-                        continue;
-                    if (!val.tokvalue->variable())
-                        continue;
-                    if (val.tokvalue->varId() != tok->varId())
-                        continue;
+            } else if (astIsContainer(tok)) {
+                const Token* ftok = getInvalidMethod(tok);
+                if (ftok) {
                     ErrorPath ep;
-                    // Check the iterator is created before the change
-                    if (reaches(val.tokvalue, tok, library, &ep)) {
-                        v = &val;
-                        errorPath = ep;
-                        return true;
-                    }
+                    ep.emplace_front(ftok,
+                                     "After calling '" + ftok->expressionString() +
+                                     "', iterators or references to the container's data may be invalid .");
+                    result.emplace_back(Info::Reference{tok, std::move(ep), ftok});
                 }
-                return false;
-            });
-            if (!info.tok)
-                continue;
-            errorPath.insert(errorPath.end(), info.errorPath.begin(), info.errorPath.end());
-            if (v) {
-                invalidContainerError(info.tok, tok, v, errorPath);
-            } else {
-                invalidContainerReferenceError(info.tok, tok, errorPath);
             }
+            return result;
         }
-    }
-}
 
-void CheckStl::invalidContainerError(const Token *tok, const Token * contTok, const ValueFlow::Value *val, ErrorPath errorPath)
-{
-    const bool inconclusive = val ? val->isInconclusive() : false;
-    std::string method = contTok ? contTok->strAt(2) : "erase";
-    errorPath.emplace_back(contTok, "After calling '" + method + "', iterators or references to the container's data may be invalid .");
-    if (val)
-        errorPath.insert(errorPath.begin(), val->errorPath.begin(), val->errorPath.end());
-    std::string msg = "Using " + lifetimeMessage(tok, val, errorPath);
-    errorPath.emplace_back(tok, "");
-    reportError(errorPath, Severity::error, "invalidContainer", msg + " that may be invalid.", CWE664, inconclusive);
+        void analyze(const SymbolDatabase* symboldatabase) {
+            for (const Scope* scope : symboldatabase->functionScopes) {
+                const Function* f = scope->function;
+                if (!f)
+                    continue;
+                for (const Token* tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
+                    if (Token::Match(tok, "if|while|for|goto|return"))
+                        break;
+                    std::vector<Info::Reference> c = invalidatesContainer(tok);
+                    if (c.empty())
+                        continue;
+                    invalidMethods[f].add(c);
+                }
+            }
+        }
+    };
+}
+
+static const Token* getLoopContainer(const Token* tok)
+{
+    if (!Token::simpleMatch(tok, "for ("))
+        return nullptr;
+    const Token* sepTok = tok->next()->astOperand2();
+    if (!Token::simpleMatch(sepTok, ":"))
+        return nullptr;
+    return sepTok->astOperand2();
+}
+
+static const ValueFlow::Value* getInnerLifetime(const Token* tok,
+                                                nonneg int id,
+                                                ErrorPath* errorPath = nullptr,
+                                                int depth = 4)
+{
+    if (depth < 0)
+        return nullptr;
+    if (!tok)
+        return nullptr;
+    for (const ValueFlow::Value& val : tok->values()) {
+        if (!val.isLocalLifetimeValue())
+            continue;
+        if (contains({ValueFlow::Value::LifetimeKind::Address,
+                      ValueFlow::Value::LifetimeKind::SubObject,
+                      ValueFlow::Value::LifetimeKind::Lambda},
+                     val.lifetimeKind)) {
+            if (val.isInconclusive())
+                return nullptr;
+            if (val.capturetok)
+                if (const ValueFlow::Value* v = getInnerLifetime(val.capturetok, id, errorPath, depth - 1))
+                    return v;
+            if (errorPath)
+                errorPath->insert(errorPath->end(), val.errorPath.cbegin(), val.errorPath.cend());
+            if (const ValueFlow::Value* v = getInnerLifetime(val.tokvalue, id, errorPath, depth - 1))
+                return v;
+            continue;
+        }
+        if (!val.tokvalue->variable())
+            continue;
+        if (val.tokvalue->varId() != id)
+            continue;
+        return &val;
+    }
+    return nullptr;
+}
+
+static const Token* endOfExpression(const Token* tok)
+{
+    if (!tok)
+        return nullptr;
+    const Token* parent = tok->astParent();
+    while (Token::simpleMatch(parent, "."))
+        parent = parent->astParent();
+    if (!parent)
+        return tok->next();
+    const Token* endToken = nextAfterAstRightmostLeaf(parent);
+    if (!endToken)
+        return parent->next();
+    return endToken;
+}
+
+void CheckStl::invalidContainer()
+{
+    logChecker("CheckStl::invalidContainer");
+    const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
+    InvalidContainerAnalyzer analyzer;
+    analyzer.analyze(symbolDatabase);
+    for (const Scope * scope : symbolDatabase->functionScopes) {
+        for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
+            if (const Token* contTok = getLoopContainer(tok)) {
+                const Token* blockStart = tok->linkAt(1)->next();
+                const Token* blockEnd = blockStart->link();
+                if (contTok->exprId() == 0)
+                    continue;
+                if (!astIsContainer(contTok))
+                    continue;
+                for (const Token* tok2 = blockStart; tok2 != blockEnd; tok2 = tok2->next()) {
+                    bool bail = false;
+                    for (const InvalidContainerAnalyzer::Info::Reference& r : analyzer.invalidatesContainer(tok2)) {
+                        if (!astIsContainer(r.tok))
+                            continue;
+                        if (r.tok->exprId() != contTok->exprId())
+                            continue;
+                        const Scope* s = tok2->scope();
+                        if (!s)
+                            continue;
+                        if (isReturnScope(s->bodyEnd, mSettings->library))
+                            continue;
+                        invalidContainerLoopError(r.ftok, tok, r.errorPath);
+                        bail = true;
+                        break;
+                    }
+                    if (bail)
+                        break;
+                }
+            } else {
+                for (const InvalidContainerAnalyzer::Info::Reference& r : analyzer.invalidatesContainer(tok)) {
+                    if (!astIsContainer(r.tok))
+                        continue;
+                    std::set<nonneg int> skipVarIds;
+                    // Skip if the variable is assigned to
+                    const Token* assignExpr = tok;
+                    while (assignExpr->astParent()) {
+                        const bool isRHS = astIsRHS(assignExpr);
+                        assignExpr = assignExpr->astParent();
+                        if (Token::Match(assignExpr, "%assign%")) {
+                            if (!isRHS)
+                                assignExpr = nullptr;
+                            break;
+                        }
+                    }
+                    if (Token::Match(assignExpr, "%assign%") && Token::Match(assignExpr->astOperand1(), "%var%"))
+                        skipVarIds.insert(assignExpr->astOperand1()->varId());
+                    const Token* endToken = endOfExpression(tok);
+                    const ValueFlow::Value* v = nullptr;
+                    ErrorPath errorPath;
+                    PathAnalysis::Info info =
+                        PathAnalysis{endToken}.forwardFind([&](const PathAnalysis::Info& info) {
+                        if (!info.tok->variable())
+                            return false;
+                        if (info.tok->varId() == 0)
+                            return false;
+                        if (skipVarIds.count(info.tok->varId()) > 0)
+                            return false;
+                        // if (Token::simpleMatch(info.tok->next(), "."))
+                        // return false;
+                        if (Token::Match(info.tok->astParent(), "%assign%") && astIsLHS(info.tok))
+                            skipVarIds.insert(info.tok->varId());
+                        if (info.tok->variable()->isReference() && !isVariableDecl(info.tok) &&
+                            reaches(info.tok->variable()->nameToken(), tok, nullptr)) {
+
+                            if ((assignExpr && Token::Match(assignExpr->astOperand1(), "& %varid%", info.tok->varId())) || // TODO: fix AST
+                                Token::Match(assignExpr, "& %varid% {|(", info.tok->varId())) {
+                                return false;
+                            }
+
+                            ErrorPath ep;
+                            bool addressOf = false;
+                            const Variable* var = ValueFlow::getLifetimeVariable(info.tok, ep, *mSettings, &addressOf);
+                            // Check the reference is created before the change
+                            if (var && var->declarationId() == r.tok->varId() && !addressOf) {
+                                // An argument always reaches
+                                if (var->isArgument() ||
+                                    (!var->isReference() && !var->isRValueReference() && !isVariableDecl(tok) &&
+                                     reaches(var->nameToken(), tok, &ep))) {
+                                    errorPath = std::move(ep);
+                                    return true;
+                                }
+                            }
+                        }
+                        ErrorPath ep;
+                        const ValueFlow::Value* val = getInnerLifetime(info.tok, r.tok->varId(), &ep);
+                        // Check the iterator is created before the change
+                        if (val && val->tokvalue != tok && reaches(val->tokvalue, tok, &ep)) {
+                            v = val;
+                            errorPath = std::move(ep);
+                            return true;
+                        }
+                        return false;
+                    });
+                    if (!info.tok)
+                        continue;
+                    errorPath.insert(errorPath.end(), info.errorPath.cbegin(), info.errorPath.cend());
+                    errorPath.insert(errorPath.end(), r.errorPath.cbegin(), r.errorPath.cend());
+                    if (v) {
+                        invalidContainerError(info.tok, r.tok, v, std::move(errorPath));
+                    } else {
+                        invalidContainerReferenceError(info.tok, r.tok, std::move(errorPath));
+                    }
+                }
+            }
+        }
+    }
+}
+
+void CheckStl::invalidContainerLoopError(const Token* tok, const Token* loopTok, ErrorPath errorPath)
+{
+    const std::string method = tok ? tok->str() : "erase";
+    errorPath.emplace_back(loopTok, "Iterating container here.");
+
+    // Remove duplicate entries from error path
+    errorPath.remove_if([&](const ErrorPathItem& epi) {
+        return epi.first == tok;
+    });
+
+    const std::string msg = "Calling '" + method + "' while iterating the container is invalid.";
+    errorPath.emplace_back(tok, "");
+    reportError(std::move(errorPath), Severity::error, "invalidContainerLoop", msg, CWE664, Certainty::normal);
+}
+
+void CheckStl::invalidContainerError(const Token *tok, const Token * /*contTok*/, const ValueFlow::Value *val, ErrorPath errorPath)
+{
+    const bool inconclusive = val ? val->isInconclusive() : false;
+    if (val)
+        errorPath.insert(errorPath.begin(), val->errorPath.cbegin(), val->errorPath.cend());
+    std::string msg = "Using " + lifetimeMessage(tok, val, errorPath);
+    errorPath.emplace_back(tok, "");
+    reportError(std::move(errorPath), Severity::error, "invalidContainer", msg + " that may be invalid.", CWE664, inconclusive ? Certainty::inconclusive : Certainty::normal);
 }
 
 void CheckStl::invalidContainerReferenceError(const Token* tok, const Token* contTok, ErrorPath errorPath)
 {
-    std::string method = contTok ? contTok->strAt(2) : "erase";
     std::string name = contTok ? contTok->expressionString() : "x";
-    errorPath.emplace_back(
-        contTok, "After calling '" + method + "', iterators or references to the container's data may be invalid .");
     std::string msg = "Reference to " + name;
     errorPath.emplace_back(tok, "");
-    reportError(errorPath, Severity::error, "invalidContainerReference", msg + " that may be invalid.", CWE664, false);
+    reportError(std::move(errorPath), Severity::error, "invalidContainerReference", msg + " that may be invalid.", CWE664, Certainty::normal);
 }
 
 void CheckStl::stlOutOfBounds()
 {
+    logChecker("CheckStl::stlOutOfBounds");
+
     const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
 
     // Scan through all scopes..
     for (const Scope &scope : symbolDatabase->scopeList) {
         const Token* tok = scope.classDef;
         // only interested in conditions
-        if ((scope.type != Scope::eFor && scope.type != Scope::eWhile && scope.type != Scope::eIf && scope.type != Scope::eDo) || !tok)
+        if ((!scope.isLoopScope() && scope.type != ScopeType::eIf) || !tok)
             continue;
 
         const Token *condition = nullptr;
-        if (scope.type == Scope::eFor) {
+        if (scope.type == ScopeType::eFor) {
             if (Token::simpleMatch(tok->next()->astOperand2(), ";") && Token::simpleMatch(tok->next()->astOperand2()->astOperand2(), ";"))
                 condition = tok->next()->astOperand2()->astOperand2()->astOperand1();
         } else if (Token::simpleMatch(tok, "do {") && Token::simpleMatch(tok->linkAt(1), "} while ("))
@@ -930,7 +1298,7 @@ void CheckStl::stlOutOfBounds()
         std::vector<const Token *> conds;
 
         visitAstNodes(condition,
-        [&](const Token *cond) {
+                      [&](const Token *cond) {
             if (Token::Match(cond, "%oror%|&&"))
                 return ChildrenToVisit::op1_and_op2;
             if (cond->isComparisonOp())
@@ -941,13 +1309,20 @@ void CheckStl::stlOutOfBounds()
         for (const Token *cond : conds) {
             const Token *vartok;
             const Token *containerToken;
-            if (Token::Match(cond, "<= %var% . %name% ( )") && Token::Match(cond->astOperand1(), "%var%")) {
+            // check in the ast that cond is of the form "%var% <= %var% . %name% ( )"
+            if (cond->str() == "<=" && Token::Match(cond->astOperand1(), "%var%") &&
+                cond->astOperand2()->str() == "(" && cond->astOperand2()->astOperand1()->str() == "." &&
+                Token::Match(cond->astOperand2()->astOperand1()->astOperand1(), "%var%") &&
+                Token::Match(cond->astOperand2()->astOperand1()->astOperand2(), "%name%")) {
                 vartok = cond->astOperand1();
                 containerToken = cond->next();
             } else {
                 continue;
             }
 
+            if (containerToken->hasKnownValue(ValueFlow::Value::ValueType::CONTAINER_SIZE))
+                continue;
+
             // Is it a array like container?
             const Library::Container* container = containerToken->valueType() ? containerToken->valueType()->container : nullptr;
             if (!container)
@@ -984,18 +1359,20 @@ void CheckStl::stlOutOfBounds()
 void CheckStl::stlOutOfBoundsError(const Token *tok, const std::string &num, const std::string &var, bool at)
 {
     if (at)
-        reportError(tok, Severity::error, "stlOutOfBounds", "$symbol:" + var + "\nWhen " + num + "==$symbol.size(), $symbol.at(" + num + ") is out of bounds.", CWE788, false);
+        reportError(tok, Severity::error, "stlOutOfBounds", "$symbol:" + var + "\nWhen " + num + "==$symbol.size(), $symbol.at(" + num + ") is out of bounds.", CWE788, Certainty::normal);
     else
-        reportError(tok, Severity::error, "stlOutOfBounds", "$symbol:" + var + "\nWhen " + num + "==$symbol.size(), $symbol[" + num + "] is out of bounds.", CWE788, false);
+        reportError(tok, Severity::error, "stlOutOfBounds", "$symbol:" + var + "\nWhen " + num + "==$symbol.size(), $symbol[" + num + "] is out of bounds.", CWE788, Certainty::normal);
 }
 
 void CheckStl::negativeIndex()
 {
+    logChecker("CheckStl::negativeIndex");
+
     // Negative index is out of bounds..
     const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
-            if (!Token::Match(tok, "%var% [") || WRONG_DATA(!tok->next()->astOperand2(), tok))
+            if (!Token::Match(tok, "%var% [") || !tok->next()->astOperand2())
                 continue;
             const Variable * const var = tok->variable();
             if (!var || tok == var->nameToken())
@@ -1003,7 +1380,7 @@ void CheckStl::negativeIndex()
             const Library::Container * const container = mSettings->library.detectContainer(var->typeStartToken());
             if (!container || !container->arrayLike_indexOp)
                 continue;
-            const ValueFlow::Value *index = tok->next()->astOperand2()->getValueLE(-1, mSettings);
+            const ValueFlow::Value *index = tok->next()->astOperand2()->getValueLE(-1, *mSettings);
             if (!index)
                 continue;
             negativeIndexError(tok, *index);
@@ -1013,22 +1390,26 @@ void CheckStl::negativeIndex()
 
 void CheckStl::negativeIndexError(const Token *tok, const ValueFlow::Value &index)
 {
-    const ErrorPath errorPath = getErrorPath(tok, &index, "Negative array index");
+    ErrorPath errorPath = getErrorPath(tok, &index, "Negative array index");
     std::ostringstream errmsg;
     if (index.condition)
         errmsg << ValueFlow::eitherTheConditionIsRedundant(index.condition)
                << ", otherwise there is negative array index " << index.intvalue << ".";
     else
         errmsg << "Array index " << index.intvalue << " is out of bounds.";
-    reportError(errorPath, index.errorSeverity() ? Severity::error : Severity::warning, "negativeContainerIndex", errmsg.str(), CWE786, index.isInconclusive());
+    const auto severity = index.errorSeverity() && index.isKnown() ? Severity::error : Severity::warning;
+    const auto certainty = index.isInconclusive() ? Certainty::inconclusive : Certainty::normal;
+    reportError(std::move(errorPath), severity, "negativeContainerIndex", errmsg.str(), CWE786, certainty);
 }
 
 void CheckStl::erase()
 {
+    logChecker("CheckStl::erase");
+
     const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope &scope : symbolDatabase->scopeList) {
-        if (scope.type == Scope::eFor && Token::simpleMatch(scope.classDef, "for (")) {
+        if (scope.type == ScopeType::eFor && Token::simpleMatch(scope.classDef, "for (")) {
             const Token *tok = scope.classDef->linkAt(1);
             if (!Token::Match(tok->tokAt(-3), "; ++| %var% ++| ) {"))
                 continue;
@@ -1036,7 +1417,7 @@ void CheckStl::erase()
             if (!tok->isName())
                 tok = tok->previous();
             eraseCheckLoopVar(scope, tok->variable());
-        } else if (scope.type == Scope::eWhile && Token::Match(scope.classDef, "while ( %var% !=")) {
+        } else if (scope.type == ScopeType::eWhile && Token::Match(scope.classDef, "while ( %var% !=")) {
             eraseCheckLoopVar(scope, scope.classDef->tokAt(2)->variable());
         }
     }
@@ -1055,7 +1436,7 @@ void CheckStl::eraseCheckLoopVar(const Scope &scope, const Variable *var)
         // Vector erases are handled by invalidContainer check
         if (isVector(tok->tokAt(-3)))
             continue;
-        if (Token::simpleMatch(tok->astParent(), "="))
+        if (Token::Match(tok->astParent(), "=|return"))
             continue;
         // Iterator is invalid..
         int indentlevel = 0U;
@@ -1088,12 +1469,14 @@ void CheckStl::eraseCheckLoopVar(const Scope &scope, const Variable *var)
 
 void CheckStl::stlBoundaries()
 {
+    logChecker("CheckStl::stlBoundaries");
+
     const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Variable* var : symbolDatabase->variableList()) {
         if (!var || !var->scope() || !var->scope()->isExecutable())
             continue;
 
-        const Library::Container* container = mSettings->library.detectContainer(var->typeStartToken(), true);
+        const Library::Container* container = mSettings->library.detectIterator(var->typeStartToken());
         if (!container || container->opLessAllowed)
             continue;
 
@@ -1114,39 +1497,50 @@ void CheckStl::stlBoundariesError(const Token *tok)
     reportError(tok, Severity::error, "stlBoundaries",
                 "Dangerous comparison using operator< on iterator.\n"
                 "Iterator compared with operator<. This is dangerous since the order of items in the "
-                "container is not guaranteed. One should use operator!= instead to compare iterators.", CWE664, false);
+                "container is not guaranteed. One should use operator!= instead to compare iterators.", CWE664, Certainty::normal);
 }
 
-static bool if_findCompare(const Token * const tokBack)
+static bool if_findCompare(const Token * const tokBack, bool stdStringLike)
 {
     const Token *tok = tokBack->astParent();
     if (!tok)
         return true;
-    if (tok->isComparisonOp())
+    if (tok->isComparisonOp()) {
+        if (stdStringLike) {
+            const Token * const tokOther = tokBack->astSibling();
+            return !tokOther || !tokOther->hasKnownIntValue() || tokOther->getKnownIntValue() != 0;
+        }
         return (!tok->astOperand1()->isNumber() && !tok->astOperand2()->isNumber());
+    }
     if (tok->isArithmeticalOp()) // result is used in some calculation
         return true;  // TODO: check if there is a comparison of the result somewhere
     if (tok->str() == ".")
         return true; // Dereferencing is OK, the programmer might know that the element exists - TODO: An inconclusive warning might be appropriate
     if (tok->isAssignmentOp())
-        return if_findCompare(tok); // Go one step upwards in the AST
+        return if_findCompare(tok, stdStringLike); // Go one step upwards in the AST
     return false;
 }
 
 void CheckStl::if_find()
 {
-    const bool printWarning = mSettings->isEnabled(Settings::WARNING);
-    const bool printPerformance = mSettings->isEnabled(Settings::PERFORMANCE);
+    const bool printWarning = mSettings->severity.isEnabled(Severity::warning);
+    const bool printPerformance = mSettings->severity.isEnabled(Severity::performance);
     if (!printWarning && !printPerformance)
         return;
 
+    logChecker("CheckStl::if_find"); // warning,performance
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope &scope : symbolDatabase->scopeList) {
-        if ((scope.type != Scope::eIf && scope.type != Scope::eWhile) || !scope.classDef)
+        if ((scope.type != ScopeType::eIf && scope.type != ScopeType::eWhile) || !scope.classDef)
             continue;
 
-        for (const Token *tok = scope.classDef->next(); tok->str() != "{"; tok = tok->next()) {
+        const Token *conditionStart = scope.classDef->next();
+        if (Token::simpleMatch(conditionStart->astOperand2(), ";"))
+            conditionStart = conditionStart->astOperand2();
+
+        for (const Token *tok = conditionStart; tok->str() != "{"; tok = tok->next()) {
             const Token* funcTok = nullptr;
             const Library::Container* container = nullptr;
 
@@ -1177,14 +1571,16 @@ void CheckStl::if_find()
                         for (int j = 0; j < container->type_templateArgNo; j++)
                             tok2 = tok2->nextTemplateArgument();
 
-                        container = mSettings->library.detectContainer(tok2); // innner container
+                        container = mSettings->library.detectContainer(tok2); // inner container
                     } else
                         container = nullptr;
                 }
             }
 
-            if (container && container->getAction(funcTok->str()) == Library::Container::Action::FIND) {
-                if (if_findCompare(funcTok->next()))
+            Library::Container::Action action{};
+            if (container &&
+                ((action = container->getAction(funcTok->str())) == Library::Container::Action::FIND || action == Library::Container::Action::FIND_CONST)) {
+                if (if_findCompare(funcTok->next(), container->stdStringLike))
                     continue;
 
                 if (printWarning && container->getYield(funcTok->str()) == Library::Container::Yield::ITERATOR)
@@ -1193,7 +1589,7 @@ void CheckStl::if_find()
                     if_findError(tok, true);
             } else if (printWarning && Token::Match(tok, "std :: find|find_if (")) {
                 // check that result is checked properly
-                if (!if_findCompare(tok->tokAt(3))) {
+                if (!if_findCompare(tok->tokAt(3), false)) {
                     if_findError(tok, false);
                 }
             }
@@ -1210,9 +1606,9 @@ void CheckStl::if_findError(const Token *tok, bool str)
                     "Either inefficient or wrong usage of string::find(). string::starts_with() will be faster if "
                     "string::find's result is compared with 0, because it will not scan the whole "
                     "string. If your intention is to check that there are no findings in the string, "
-                    "you should compare with std::string::npos.", CWE597, false);
+                    "you should compare with std::string::npos.", CWE597, Certainty::normal);
     if (!str)
-        reportError(tok, Severity::warning, "stlIfFind", "Suspicious condition. The result of find() is an iterator, but it is not properly checked.", CWE398, false);
+        reportError(tok, Severity::warning, "stlIfFind", "Suspicious condition. The result of find() is an iterator, but it is not properly checked.", CWE398, Certainty::normal);
 }
 
 static std::pair<const Token *, const Token *> isMapFind(const Token *tok)
@@ -1236,37 +1632,20 @@ static std::pair<const Token *, const Token *> isMapFind(const Token *tok)
     return {contTok, tok->astOperand2()};
 }
 
-static const Token *skipLocalVars(const Token *tok)
+static const Token* skipLocalVars(const Token* const tok)
 {
     if (!tok)
         return tok;
     if (Token::simpleMatch(tok, "{"))
         return skipLocalVars(tok->next());
-    const Scope *scope = tok->scope();
 
-    const Token *top = tok->astTop();
-    if (!top) {
-        const Token *semi = Token::findsimplematch(tok, ";");
-        if (!semi)
-            return tok;
-        if (!Token::Match(semi->previous(), "%var% ;"))
-            return tok;
-        const Token *varTok = semi->previous();
-        const Variable *var = varTok->variable();
-        if (!var)
-            return tok;
-        if (var->nameToken() != varTok)
-            return tok;
-        return skipLocalVars(semi->next());
-    }
-    if (Token::Match(top, "%assign%")) {
+    if (tok->isAssignmentOp()) {
+        const Token *top = tok->astTop();
         const Token *varTok = top->astOperand1();
-        if (!Token::Match(varTok, "%var%"))
-            return tok;
         const Variable *var = varTok->variable();
         if (!var)
             return tok;
-        if (var->scope() != scope)
+        if (var->scope() != tok->scope())
             return tok;
         const Token *endTok = nextAfterAstRightmostLeaf(top);
         if (!endTok)
@@ -1276,7 +1655,7 @@ static const Token *skipLocalVars(const Token *tok)
     return tok;
 }
 
-static const Token *findInsertValue(const Token *tok, const Token *containerTok, const Token *keyTok, const Library &library)
+static const Token *findInsertValue(const Token *tok, const Token *containerTok, const Token *keyTok, const Settings &settings)
 {
     const Token *startTok = skipLocalVars(tok);
     const Token *top = startTok->astTop();
@@ -1301,27 +1680,28 @@ static const Token *findInsertValue(const Token *tok, const Token *containerTok,
     }
     if (!ikeyTok || !icontainerTok)
         return nullptr;
-    if (isSameExpression(true, true, containerTok, icontainerTok, library, true, false) &&
-        isSameExpression(true, true, keyTok, ikeyTok, library, true, true)) {
+    if (isSameExpression(true, containerTok, icontainerTok, settings, true, false) &&
+        isSameExpression(true, keyTok, ikeyTok, settings, true, true)) {
         if (ivalueTok)
             return ivalueTok;
-        else
-            return ikeyTok;
+        return ikeyTok;
     }
     return nullptr;
 }
 
 void CheckStl::checkFindInsert()
 {
-    if (!mSettings->isEnabled(Settings::PERFORMANCE))
+    if (!mSettings->severity.isEnabled(Severity::performance))
         return;
 
+    logChecker("CheckStl::checkFindInsert"); // performance
+
     const SymbolDatabase *const symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope *scope : symbolDatabase->functionScopes) {
         for (const Token *tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
             if (!Token::simpleMatch(tok, "if ("))
                 continue;
-            if (!Token::simpleMatch(tok->next()->link(), ") {"))
+            if (!Token::simpleMatch(tok->linkAt(1), ") {"))
                 continue;
             if (!Token::Match(tok->next()->astOperand2(), "%comp%"))
                 continue;
@@ -1331,18 +1711,21 @@ void CheckStl::checkFindInsert()
             std::tie(containerTok, keyTok) = isMapFind(condTok->astOperand1());
             if (!containerTok)
                 continue;
+            // In < C++17 we only warn for small simple types
+            if (mSettings->standards.cpp < Standards::CPP17 && !(keyTok && keyTok->valueType() && (keyTok->valueType()->isIntegral() || keyTok->valueType()->pointer > 0)))
+                continue;
 
-            const Token *thenTok = tok->next()->link()->next();
-            const Token *valueTok = findInsertValue(thenTok, containerTok, keyTok, mSettings->library);
+            const Token *thenTok = tok->linkAt(1)->next();
+            const Token *valueTok = findInsertValue(thenTok, containerTok, keyTok, *mSettings);
             if (!valueTok)
                 continue;
 
             if (Token::simpleMatch(thenTok->link(), "} else {")) {
                 const Token *valueTok2 =
-                    findInsertValue(thenTok->link()->tokAt(2), containerTok, keyTok, mSettings->library);
+                    findInsertValue(thenTok->link()->tokAt(2), containerTok, keyTok, *mSettings);
                 if (!valueTok2)
                     continue;
-                if (isSameExpression(true, true, valueTok, valueTok2, mSettings->library, true, true)) {
+                if (isSameExpression(true, valueTok, valueTok2, *mSettings, true, true)) {
                     checkFindInsertError(valueTok);
                 }
             } else {
@@ -1354,8 +1737,23 @@ void CheckStl::checkFindInsert()
 
 void CheckStl::checkFindInsertError(const Token *tok)
 {
+    std::string replaceExpr;
+    if (tok && Token::simpleMatch(tok->astParent(), "=") && tok == tok->astParent()->astOperand2() && Token::simpleMatch(tok->astParent()->astOperand1(), "[")) {
+        if (mSettings->standards.cpp < Standards::CPP11)
+            // We will recommend using emplace/try_emplace instead
+            return;
+        const std::string f = (mSettings->standards.cpp < Standards::CPP17) ? "emplace" : "try_emplace";
+        replaceExpr = " Instead of '" + tok->astParent()->expressionString() + "' consider using '" +
+                      tok->astParent()->astOperand1()->astOperand1()->expressionString() +
+                      "." + f + "(" +
+                      tok->astParent()->astOperand1()->astOperand2()->expressionString() +
+                      ", " +
+                      tok->expressionString() +
+                      ");'.";
+    }
+
     reportError(
-        tok, Severity::performance, "stlFindInsert", "Searching before insertion is not necessary.", CWE398, false);
+        tok, Severity::performance, "stlFindInsert", "Searching before insertion is not necessary." + replaceExpr, CWE398, Certainty::normal);
 }
 
 /**
@@ -1371,12 +1769,14 @@ static bool isCpp03ContainerSizeSlow(const Token *tok)
 
 void CheckStl::size()
 {
-    if (!mSettings->isEnabled(Settings::PERFORMANCE))
+    if (!mSettings->severity.isEnabled(Severity::performance))
         return;
 
     if (mSettings->standards.cpp >= Standards::CPP11)
         return;
 
+    logChecker("CheckStl::size"); // performance,c++03
+
     const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
@@ -1390,7 +1790,7 @@ void CheckStl::size()
                 const Token* const end = varTok->tokAt(5);
 
                 // check for comparison to zero
-                if ((tok->previous() && !tok->previous()->isArithmeticalOp() && Token::Match(end, "==|<=|!=|> 0")) ||
+                if ((!tok->previous()->isArithmeticalOp() && Token::Match(end, "==|<=|!=|> 0")) ||
                     (end->next() && !end->next()->isArithmeticalOp() && Token::Match(tok->tokAt(-2), "0 ==|>=|!=|<"))) {
                     if (isCpp03ContainerSizeSlow(varTok)) {
                         sizeError(varTok);
@@ -1399,7 +1799,7 @@ void CheckStl::size()
                 }
 
                 // check for comparison to one
-                if ((tok->previous() && !tok->previous()->isArithmeticalOp() && Token::Match(end, ">=|< 1") && !end->tokAt(2)->isArithmeticalOp()) ||
+                if ((!tok->previous()->isArithmeticalOp() && Token::Match(end, ">=|< 1") && !end->tokAt(2)->isArithmeticalOp()) ||
                     (end->next() && !end->next()->isArithmeticalOp() && Token::Match(tok->tokAt(-2), "1 <=|>") && !tok->tokAt(-3)->isArithmeticalOp())) {
                     if (isCpp03ContainerSizeSlow(varTok))
                         sizeError(varTok);
@@ -1425,18 +1825,20 @@ void CheckStl::sizeError(const Token *tok)
                 "Checking for '$symbol' emptiness might be inefficient. "
                 "Using $symbol.empty() instead of $symbol.size() can be faster. "
                 "$symbol.size() can take linear time but $symbol.empty() is "
-                "guaranteed to take constant time.", CWE398, false);
+                "guaranteed to take constant time.", CWE398, Certainty::normal);
 }
 
 void CheckStl::redundantCondition()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("redundantIfRemove"))
         return;
 
+    logChecker("CheckStl::redundantCondition"); // style
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope &scope : symbolDatabase->scopeList) {
-        if (scope.type != Scope::eIf)
+        if (scope.type != ScopeType::eIf)
             continue;
 
         const Token* tok = scope.classDef->tokAt(2);
@@ -1464,18 +1866,20 @@ void CheckStl::redundantIfRemoveError(const Token *tok)
     reportError(tok, Severity::style, "redundantIfRemove",
                 "Redundant checking of STL container element existence before removing it.\n"
                 "Redundant checking of STL container element existence before removing it. "
-                "It is safe to call the remove method on a non-existing element.", CWE398, false);
+                "It is safe to call the remove method on a non-existing element.", CWE398, Certainty::normal);
 }
 
 void CheckStl::missingComparison()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckStl::missingComparison"); // warning
+
     const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope &scope : symbolDatabase->scopeList) {
-        if (scope.type != Scope::eFor || !scope.classDef)
+        if (scope.type != ScopeType::eFor || !scope.classDef)
             continue;
 
         for (const Token *tok2 = scope.classDef->tokAt(2); tok2 != scope.bodyStart; tok2 = tok2->next()) {
@@ -1502,23 +1906,26 @@ void CheckStl::missingComparison()
             }
 
             const Token *incrementToken = nullptr;
-
             // Parse loop..
             for (const Token *tok3 = scope.bodyStart; tok3 != scope.bodyEnd; tok3 = tok3->next()) {
-                if (Token::Match(tok3, "%varid% ++", iteratorId))
-                    incrementToken = tok3;
-                else if (Token::Match(tok3->previous(), "++ %varid% !!.", iteratorId))
-                    incrementToken = tok3;
-                else if (Token::Match(tok3, "%varid% !=|==", iteratorId))
-                    incrementToken = nullptr;
-                else if (tok3->str() == "break" || tok3->str() == "return")
+                if (tok3->varId() == iteratorId) {
+                    if (Token::Match(tok3, "%varid% = %name% . insert ( ++| %varid% ++| ,", iteratorId)) {
+                        // skip insertion..
+                        tok3 = tok3->linkAt(6);
+                        if (!tok3)
+                            break;
+                    } else if (Token::simpleMatch(tok3->astParent(), "++"))
+                        incrementToken = tok3;
+                    else if (Token::simpleMatch(tok3->astParent(), "+")) {
+                        if (Token::Match(tok3->astSibling(), "%num%")) {
+                            const Token* tokenGrandParent = tok3->astParent()->astParent();
+                            if (Token::Match(tokenGrandParent, "==|!="))
+                                break;
+                        }
+                    } else if (Token::Match(tok3->astParent(), "==|!="))
+                        incrementToken = nullptr;
+                } else if (tok3->str() == "break" || tok3->str() == "return")
                     incrementToken = nullptr;
-                else if (Token::Match(tok3, "%varid% = %name% . insert ( ++| %varid% ++| ,", iteratorId)) {
-                    // skip insertion..
-                    tok3 = tok3->linkAt(6);
-                    if (!tok3)
-                        break;
-                }
             }
             if (incrementToken)
                 missingComparisonError(incrementToken, tok2->tokAt(16));
@@ -1542,7 +1949,7 @@ void CheckStl::missingComparisonError(const Token *incrementToken1, const Token
            << "There is no comparison between these increments to prevent that the iterator is "
            << "incremented beyond the end.";
 
-    reportError(callstack, Severity::warning, "StlMissingComparison", errmsg.str(), CWE834, false);
+    reportError(callstack, Severity::warning, "StlMissingComparison", errmsg.str(), CWE834, Certainty::normal);
 }
 
 
@@ -1552,6 +1959,53 @@ static bool isLocal(const Token *tok)
     return var && !var->isStatic() && var->isLocal();
 }
 
+static bool isc_strCall(const Token* tok, const Library::Container* container)
+{
+    if (!Token::simpleMatch(tok, "("))
+        return false;
+    const Token* dot = tok->astOperand1();
+    if (!Token::simpleMatch(dot, "."))
+        return false;
+    const Token* obj = dot->astOperand1();
+    if (!obj || !obj->valueType())
+        return false;
+    const Library::Container* objContainer = obj->valueType()->container;
+    if (!objContainer || !container || !objContainer->stdStringLike || (objContainer != container && !container->view))
+        return false;
+    return Token::Match(dot->astOperand2(), "c_str|data ( )");
+}
+
+static bool isc_strConcat(const Token* tok)
+{
+    if (!tok->isBinaryOp() || !Token::simpleMatch(tok, "+"))
+        return false;
+    for (const Token* op : { tok->astOperand1(), tok->astOperand2() }) { // NOLINT(readability-use-anyofallof)
+        const Token* sibling = op->astSibling();
+        if (!sibling->valueType())
+            continue;
+        if (isc_strCall(op, sibling->valueType()->container))
+            return true;
+    }
+    return false;
+}
+
+static bool isc_strAssignment(const Token* tok)
+{
+    if (!Token::simpleMatch(tok, "="))
+        return false;
+    const Token* strTok = tok->astOperand1();
+    if (!strTok || !strTok->valueType())
+        return false;
+    return isc_strCall(tok->astOperand2(), strTok->valueType()->container);
+}
+
+static bool isc_strConstructor(const Token* tok)
+{
+    if (!tok->valueType() || !Token::Match(tok, "%var% (|{"))
+        return false;
+    return isc_strCall(tok->tokAt(1)->astOperand2(), tok->valueType()->container);
+}
+
 namespace {
     const std::set<std::string> stl_string_stream = {
         "istringstream", "ostringstream", "stringstream", "wstringstream"
@@ -1560,38 +2014,48 @@ namespace {
 
 void CheckStl::string_c_str()
 {
-    const bool printInconclusive = mSettings->inconclusive;
-    const bool printPerformance = mSettings->isEnabled(Settings::PERFORMANCE);
+    const bool printInconclusive = mSettings->certainty.isEnabled(Certainty::inconclusive);
+    const bool printPerformance = mSettings->severity.isEnabled(Severity::performance);
 
     const SymbolDatabase* symbolDatabase = mTokenizer->getSymbolDatabase();
 
+    logChecker("CheckStl::string_c_str");
+
     // Find all functions that take std::string as argument
-    std::multimap<std::string, int> c_strFuncParam;
+    struct StrArg {
+        nonneg int n;
+        std::string argtype;
+    };
+    std::multimap<const Function*, StrArg> c_strFuncParam;
     if (printPerformance) {
         for (const Scope &scope : symbolDatabase->scopeList) {
             for (const Function &func : scope.functionList) {
-                if (c_strFuncParam.erase(func.tokenDef->str()) != 0) { // Check if function with this name was already found
-                    c_strFuncParam.insert(std::make_pair(func.tokenDef->str(), 0)); // Disable, because there are overloads. TODO: Handle overloads
-                    continue;
-                }
-
-                int numpar = 0;
-                c_strFuncParam.insert(std::make_pair(func.tokenDef->str(), numpar)); // Insert function as dummy, to indicate that there is at least one function with that name
+                nonneg int numpar = 0;
                 for (const Variable &var : func.argumentList) {
                     numpar++;
-                    if (var.isStlStringType() && (!var.isReference() || var.isConst()))
-                        c_strFuncParam.insert(std::make_pair(func.tokenDef->str(), numpar));
+                    if ((var.isStlStringType() || var.isStlStringViewType()) && (!var.isReference() || var.isConst()))
+                        c_strFuncParam.emplace(&func, StrArg{ numpar, var.getTypeName() });
                 }
             }
         }
     }
 
+    auto isString = [](const Token* str) -> bool {
+        while (Token::Match(str, "::|."))
+            str = str->astOperand2();
+        if (Token::Match(str, "(|[") && !(str->valueType() && str->valueType()->type == ValueType::ITERATOR))
+            str = str->previous();
+        return str && ((str->variable() && str->variable()->isStlStringType()) || // variable
+                       (str->function() && isStlStringType(str->function()->retDef)) || // function returning string
+                       (str->valueType() && str->valueType()->type == ValueType::ITERATOR && isStlStringType(str->valueType()->containerTypeToken))); // iterator pointing to string
+    };
+
     // Try to detect common problems when using string::c_str()
     for (const Scope &scope : symbolDatabase->scopeList) {
-        if (scope.type != Scope::eFunction || !scope.function)
+        if (scope.type != ScopeType::eFunction || !scope.function)
             continue;
 
-        enum {charPtr, stdString, stdStringConstRef, Other} returnType = Other;
+        enum : std::uint8_t {charPtr, stdString, stdStringConstRef, Other} returnType = Other;
         if (Token::Match(scope.function->tokenDef->tokAt(-2), "char|wchar_t *"))
             returnType = charPtr;
         else if (Token::Match(scope.function->tokenDef->tokAt(-5), "const std :: string|wstring &"))
@@ -1604,54 +2068,68 @@ void CheckStl::string_c_str()
             if (Token::Match(tok, "throw %var% . c_str|data ( ) ;") && isLocal(tok->next()) &&
                 tok->next()->variable() && tok->next()->variable()->isStlStringType()) {
                 string_c_strThrowError(tok);
-            } else if (Token::Match(tok, "[;{}] %name% = %var% . str ( ) . c_str|data ( ) ;")) {
-                const Variable* var = tok->next()->variable();
-                const Variable* var2 = tok->tokAt(3)->variable();
-                if (var && var->isPointer() && var2 && var2->isStlType(stl_string_stream))
-                    string_c_strError(tok);
-            } else if (Token::Match(tok, "[;{}] %var% = %name% (") &&
-                       Token::Match(tok->linkAt(4), ") . c_str|data ( ) ;") &&
-                       tok->tokAt(3)->function() && Token::Match(tok->tokAt(3)->function()->retDef, "std :: string|wstring %name%")) {
-                const Variable* var = tok->next()->variable();
-                if (var && var->isPointer())
-                    string_c_strError(tok);
-            } else if (printPerformance && Token::Match(tok, "%name% ( !!)") && c_strFuncParam.find(tok->str()) != c_strFuncParam.end() &&
-                       !Token::Match(tok->previous(), "::|.") && tok->varId() == 0 && tok->str() != scope.className) { // calling function. TODO: Add support for member functions
-                const std::pair<std::multimap<std::string, int>::const_iterator, std::multimap<std::string, int>::const_iterator> range = c_strFuncParam.equal_range(tok->str());
-                for (std::multimap<std::string, int>::const_iterator i = range.first; i != range.second; ++i) {
-                    if (i->second == 0)
+            } else if (tok->variable() && tok->strAt(1) == "=") {
+                if (Token::Match(tok->tokAt(2), "%var% . str ( ) . c_str|data ( ) ;")) {
+                    const Variable* var = tok->variable();
+                    const Variable* var2 = tok->tokAt(2)->variable();
+                    if (var->isPointer() && var2 && var2->isStlType(stl_string_stream))
+                        string_c_strError(tok);
+                } else if (printPerformance && isc_strAssignment(tok->tokAt(1))) {
+                    string_c_strAssignment(tok, tok->variable()->getTypeName());
+                } else if (Token::Match(tok->tokAt(2), "%name% (") &&
+                           Token::Match(tok->linkAt(3), ") . c_str|data ( ) ;") &&
+                           tok->tokAt(2)->function() && Token::Match(tok->tokAt(2)->function()->retDef, "std :: string|wstring %name%")) {
+                    const Variable* var = tok->variable();
+                    if (var->isPointer())
+                        string_c_strError(tok);
+                }
+            } else if (printPerformance && tok->function() && Token::Match(tok, "%name% ( !!)") && tok->str() != scope.className) {
+                const auto range = c_strFuncParam.equal_range(tok->function());
+                for (std::multimap<const Function*, StrArg>::const_iterator i = range.first; i != range.second; ++i) {
+                    if (i->second.n == 0)
                         continue;
 
                     const Token* tok2 = tok->tokAt(2);
                     int j;
-                    for (j = 0; tok2 && j < i->second-1; j++)
+                    for (j = 0; tok2 && j < i->second.n - 1; j++)
                         tok2 = tok2->nextArgument();
                     if (tok2)
                         tok2 = tok2->nextArgument();
                     else
                         break;
-                    if (!tok2 && j == i->second-1)
-                        tok2 = tok->next()->link();
+                    if (!tok2 && j == i->second.n - 1)
+                        tok2 = tok->linkAt(1);
                     else if (tok2)
                         tok2 = tok2->previous();
                     else
                         break;
                     if (tok2 && Token::Match(tok2->tokAt(-4), ". c_str|data ( )")) {
-                        const Variable* var = tok2->tokAt(-5)->variable();
-                        if (var && var->isStlStringType()) {
-                            string_c_strParam(tok, i->second);
+                        if (isString(tok2->tokAt(-4)->astOperand1())) {
+                            string_c_strParam(tok, i->second.n, i->second.argtype);
                         } else if (Token::Match(tok2->tokAt(-9), "%name% . str ( )")) { // Check ss.str().c_str() as parameter
                             const Variable* ssVar = tok2->tokAt(-9)->variable();
                             if (ssVar && ssVar->isStlType(stl_string_stream))
-                                string_c_strParam(tok, i->second);
+                                string_c_strParam(tok, i->second.n, i->second.argtype);
                         }
-
                     }
                 }
+            } else if (printPerformance && isc_strConstructor(tok)) {
+                string_c_strConstructor(tok, tok->variable()->getTypeName());
+            } else if (printPerformance && isc_strConcat(tok)) {
+                string_c_strConcat(tok);
+            } else if (printPerformance && Token::simpleMatch(tok, "<<") && tok->astOperand2() && Token::Match(tok->astOperand2()->astOperand1(), ". c_str|data ( )")) {
+                const Token* str = tok->astOperand2()->astOperand1()->astOperand1();
+                if (isString(str)) {
+                    const Token* strm = tok;
+                    while (Token::simpleMatch(strm, "<<"))
+                        strm = strm->astOperand1();
+                    if (strm && ((strm->variable() && strm->variable()->isStlType()) || Token::Match(strm->tokAt(-1), "std :: cout|cerr")))
+                        string_c_strStream(tok);
+                }
             }
 
             // Using c_str() to get the return value is only dangerous if the function returns a char*
-            if ((returnType == charPtr || (printPerformance && (returnType == stdString || returnType == stdStringConstRef))) && tok->str() == "return") {
+            else if ((returnType == charPtr || (printPerformance && (returnType == stdString || returnType == stdStringConstRef))) && tok->str() == "return") {
                 bool err = false;
 
                 const Token* tok2 = tok->next();
@@ -1668,7 +2146,8 @@ void CheckStl::string_c_str()
                             search_tok->next()->variable() && search_tok->next()->variable()->isStlStringType()) {
                             is_implicit_std_string = true;
                             break;
-                        } else if (Token::Match(search_tok, "+ std :: string|wstring (")) {
+                        }
+                        if (Token::Match(search_tok, "+ std :: string|wstring (")) {
                             is_implicit_std_string = true;
                             break;
                         }
@@ -1692,7 +2171,7 @@ void CheckStl::string_c_str()
                         if (Token::Match(refTok, "%var% = %var% .|;|["))
                             refToNonLocal = !isLocal(refTok->tokAt(2));
                     }
-                    ptrOrRef = refToNonLocal || (tok2->variable() && tok2->variable()->isPointer());
+                    ptrOrRef = refToNonLocal || (tok2->variable() && (tok2->variable()->isPointer() || tok2->variable()->isSmartPointer()));
                 }
                 while (tok2) {
                     if (Token::Match(tok2, "%var% .|::")) {
@@ -1738,21 +2217,49 @@ void CheckStl::string_c_strThrowError(const Token* tok)
 void CheckStl::string_c_strError(const Token* tok)
 {
     reportError(tok, Severity::error, "stlcstr", "Dangerous usage of c_str(). The value returned by c_str() is invalid after this call.\n"
-                "Dangerous usage of c_str(). The c_str() return value is only valid until its string is deleted.", CWE664, false);
+                "Dangerous usage of c_str(). The c_str() return value is only valid until its string is deleted.", CWE664, Certainty::normal);
 }
 
 void CheckStl::string_c_strReturn(const Token* tok)
 {
     reportError(tok, Severity::performance, "stlcstrReturn", "Returning the result of c_str() in a function that returns std::string is slow and redundant.\n"
-                "The conversion from const char* as returned by c_str() to std::string creates an unnecessary string copy. Solve that by directly returning the string.", CWE704, false);
+                "The conversion from const char* as returned by c_str() to std::string creates an unnecessary string copy. Solve that by directly returning the string.", CWE704, Certainty::normal);
 }
 
-void CheckStl::string_c_strParam(const Token* tok, nonneg int number)
+void CheckStl::string_c_strParam(const Token* tok, nonneg int number, const std::string& argtype)
 {
     std::ostringstream oss;
-    oss << "Passing the result of c_str() to a function that takes std::string as argument no. " << number << " is slow and redundant.\n"
-        "The conversion from const char* as returned by c_str() to std::string creates an unnecessary string copy. Solve that by directly passing the string.";
-    reportError(tok, Severity::performance, "stlcstrParam", oss.str(), CWE704, false);
+    oss << "Passing the result of c_str() to a function that takes " << argtype << " as argument no. " << number << " is slow and redundant.\n"
+        "The conversion from const char* as returned by c_str() to " << argtype << " creates an unnecessary string copy or length calculation. Solve that by directly passing the string.";
+    reportError(tok, Severity::performance, "stlcstrParam", oss.str(), CWE704, Certainty::normal);
+}
+
+void CheckStl::string_c_strConstructor(const Token* tok, const std::string& argtype)
+{
+    std::string msg = "Constructing a " + argtype + " from the result of c_str() is slow and redundant.\n"
+                      "Constructing a " + argtype + " from const char* requires a call to strlen(). Solve that by directly passing the string.";
+    reportError(tok, Severity::performance, "stlcstrConstructor", msg, CWE704, Certainty::normal);
+}
+
+void CheckStl::string_c_strAssignment(const Token* tok, const std::string& argtype)
+{
+    std::string msg = "Assigning the result of c_str() to a " + argtype + " is slow and redundant.\n"
+                      "Assigning a const char* to a " + argtype + " requires a call to strlen(). Solve that by directly assigning the string.";
+    reportError(tok, Severity::performance, "stlcstrAssignment", msg, CWE704, Certainty::normal);
+}
+
+void CheckStl::string_c_strConcat(const Token* tok)
+{
+    std::string msg = "Concatenating the result of c_str() and a std::string is slow and redundant.\n"
+                      "Concatenating a const char* with a std::string requires a call to strlen(). Solve that by directly concatenating the strings.";
+    reportError(tok, Severity::performance, "stlcstrConcat", msg, CWE704, Certainty::normal);
+}
+
+void CheckStl::string_c_strStream(const Token* tok)
+{
+    std::string msg = "Passing the result of c_str() to a stream is slow and redundant.\n"
+                      "Passing a const char* to a stream requires a call to strlen(). Solve that by directly passing the string.";
+    reportError(tok, Severity::performance, "stlcstrStream", msg, CWE704, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -1771,11 +2278,13 @@ namespace {
 
 void CheckStl::uselessCalls()
 {
-    const bool printPerformance = mSettings->isEnabled(Settings::PERFORMANCE);
-    const bool printWarning = mSettings->isEnabled(Settings::WARNING);
+    const bool printPerformance = mSettings->severity.isEnabled(Severity::performance);
+    const bool printWarning = mSettings->severity.isEnabled(Severity::warning);
     if (!printPerformance && !printWarning)
         return;
 
+    logChecker("CheckStl::uselessCalls"); // performance,warning
+
     const SymbolDatabase* symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
@@ -1791,21 +2300,38 @@ void CheckStl::uselessCalls()
                 if (!var || !var->isStlType())
                     continue;
                 uselessCallsSwapError(tok, tok->str());
-            } else if (printPerformance && Token::Match(tok, "%var% . substr (") &&
-                       tok->variable() && tok->variable()->isStlStringType()) {
-                if (Token::Match(tok->tokAt(4), "0| )")) {
-                    uselessCallsSubstrError(tok, false);
-                } else if (tok->strAt(4) == "0" && tok->linkAt(3)->strAt(-1) == "npos") {
-                    if (!tok->linkAt(3)->previous()->variable()) // Make sure that its no variable
-                        uselessCallsSubstrError(tok, false);
-                } else if (Token::simpleMatch(tok->linkAt(3)->tokAt(-2), ", 0 )"))
-                    uselessCallsSubstrError(tok, true);
+            } else if (printPerformance && Token::Match(tok, "%var% . substr (") && tok->variable() && tok->variable()->isStlStringType()) {
+                const Token* funcTok = tok->tokAt(3);
+                const std::vector<const Token*> args = getArguments(funcTok);
+                if (Token::Match(tok->tokAt(-2), "%var% =") && tok->varId() == tok->tokAt(-2)->varId() &&
+                    !args.empty() && args[0]->hasKnownIntValue() && args[0]->getKnownIntValue() == 0) {
+                    uselessCallsSubstrError(tok, Token::simpleMatch(funcTok->astParent(), "=") ? SubstrErrorType::PREFIX : SubstrErrorType::PREFIX_CONCAT);
+                } else if (args.empty() || (args[0]->hasKnownIntValue() && args[0]->getKnownIntValue() == 0 &&
+                                            (args.size() == 1 || (args.size() == 2 && tok->linkAt(3)->strAt(-1) == "npos" && !tok->linkAt(3)->previous()->variable())))) {
+                    uselessCallsSubstrError(tok, SubstrErrorType::COPY);
+                } else if (args.size() == 2 && args[1]->hasKnownIntValue() && args[1]->getKnownIntValue() == 0) {
+                    uselessCallsSubstrError(tok, SubstrErrorType::EMPTY);
+                }
             } else if (printWarning && Token::Match(tok, "[{};] %var% . empty ( ) ;") &&
                        !tok->tokAt(4)->astParent() &&
                        tok->next()->variable() && tok->next()->variable()->isStlType(stl_containers_with_empty_and_clear))
                 uselessCallsEmptyError(tok->next());
             else if (Token::Match(tok, "[{};] std :: remove|remove_if|unique (") && tok->tokAt(5)->nextArgument())
                 uselessCallsRemoveError(tok->next(), tok->strAt(3));
+            else if (printPerformance && tok->valueType() && tok->valueType()->type == ValueType::CONTAINER) {
+                if (Token::Match(tok, "%var% = { %var% . begin ( ) ,") && tok->varId() == tok->tokAt(3)->varId())
+                    uselessCallsConstructorError(tok);
+                else if (const Variable* var = tok->variable()) {
+                    std::string pattern = "%var% = ";
+                    for (const Token* t = var->typeStartToken(); t != var->typeEndToken()->next(); t = t->next()) {
+                        pattern += t->str();
+                        pattern += ' ';
+                    }
+                    pattern += "{|( %varid% . begin ( ) ,";
+                    if (Token::Match(tok, pattern.c_str(), tok->varId()))
+                        uselessCallsConstructorError(tok);
+                }
+            }
         }
     }
 }
@@ -1821,7 +2347,7 @@ void CheckStl::uselessCallsReturnValueError(const Token *tok, const std::string
            << "(" << varname << "." << function << "(" << varname << ")). As it is currently the "
            << "code is inefficient. It is possible either the string searched ('"
            << varname << "') or searched for ('" << varname << "') is wrong.";
-    reportError(tok, Severity::warning, "uselessCallsCompare", errmsg.str(), CWE628, false);
+    reportError(tok, Severity::warning, "uselessCallsCompare", errmsg.str(), CWE628, Certainty::normal);
 }
 
 void CheckStl::uselessCallsSwapError(const Token *tok, const std::string &varname)
@@ -1831,20 +2357,39 @@ void CheckStl::uselessCallsSwapError(const Token *tok, const std::string &varnam
                 "It is inefficient to swap a object with itself by calling '$symbol.swap($symbol)'\n"
                 "The 'swap()' function has no logical effect when given itself as parameter "
                 "($symbol.swap($symbol)). As it is currently the "
-                "code is inefficient. Is the object or the parameter wrong here?", CWE628, false);
+                "code is inefficient. Is the object or the parameter wrong here?", CWE628, Certainty::normal);
+}
+
+void CheckStl::uselessCallsSubstrError(const Token *tok, SubstrErrorType type)
+{
+    std::string msg = "Ineffective call of function 'substr' because ";
+    switch (type) {
+    case SubstrErrorType::EMPTY:
+        msg += "it returns an empty string.";
+        break;
+    case SubstrErrorType::COPY:
+        msg += "it returns a copy of the object. Use operator= instead.";
+        break;
+    case SubstrErrorType::PREFIX:
+        msg += "a prefix of the string is assigned to itself. Use resize() or pop_back() instead.";
+        break;
+    case SubstrErrorType::PREFIX_CONCAT:
+        msg += "a prefix of the string is assigned to itself. Use replace() instead.";
+        break;
+    }
+    reportError(tok, Severity::performance, "uselessCallsSubstr", msg, CWE398, Certainty::normal);
 }
 
-void CheckStl::uselessCallsSubstrError(const Token *tok, bool empty)
+void CheckStl::uselessCallsConstructorError(const Token *tok)
 {
-    if (empty)
-        reportError(tok, Severity::performance, "uselessCallsSubstr", "Ineffective call of function 'substr' because it returns an empty string.", CWE398, false);
-    else
-        reportError(tok, Severity::performance, "uselessCallsSubstr", "Ineffective call of function 'substr' because it returns a copy of the object. Use operator= instead.", CWE398, false);
+    const std::string container = tok ? tok->str() : "";
+    const std::string msg = "Inefficient constructor call: container '" + container + "' is assigned a partial copy of itself. Use erase() or resize() instead.";
+    reportError(tok, Severity::performance, "uselessCallsConstructor", msg, CWE398, Certainty::normal);
 }
 
 void CheckStl::uselessCallsEmptyError(const Token *tok)
 {
-    reportError(tok, Severity::warning, "uselessCallsEmpty", "Ineffective call of function 'empty()'. Did you intend to call 'clear()' instead?", CWE398, false);
+    reportError(tok, Severity::warning, "uselessCallsEmpty", "Ineffective call of function 'empty()'. Did you intend to call 'clear()' instead?", CWE398, Certainty::normal);
 }
 
 void CheckStl::uselessCallsRemoveError(const Token *tok, const std::string& function)
@@ -1853,25 +2398,27 @@ void CheckStl::uselessCallsRemoveError(const Token *tok, const std::string& func
                 "$symbol:" + function + "\n"
                 "Return value of std::$symbol() ignored. Elements remain in container.\n"
                 "The return value of std::$symbol() is ignored. This function returns an iterator to the end of the range containing those elements that should be kept. "
-                "Elements past new end remain valid but with unspecified values. Use the erase method of the container to delete them.", CWE762, false);
+                "Elements past new end remain valid but with unspecified values. Use the erase method of the container to delete them.", CWE762, Certainty::normal);
 }
 
 // Check for iterators being dereferenced before being checked for validity.
 // E.g.  if (*i && i != str.end()) { }
 void CheckStl::checkDereferenceInvalidIterator()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckStl::checkDereferenceInvalidIterator"); // warning
+
     // Iterate over "if", "while", and "for" conditions where there may
     // be an iterator that is dereferenced before being checked for validity.
     for (const Scope &scope : mTokenizer->getSymbolDatabase()->scopeList) {
-        if (!(scope.type == Scope::eIf || scope.type == Scope::eDo || scope.type == Scope::eWhile || scope.type == Scope::eFor))
+        if (!(scope.type == ScopeType::eIf || scope.isLoopScope()))
             continue;
 
         const Token* const tok = scope.classDef;
         const Token* startOfCondition = tok->next();
-        if (scope.type == Scope::eDo)
+        if (scope.type == ScopeType::eDo)
             startOfCondition = startOfCondition->link()->tokAt(2);
         if (!startOfCondition) // ticket #6626 invalid code
             continue;
@@ -1880,7 +2427,7 @@ void CheckStl::checkDereferenceInvalidIterator()
             continue;
 
         // For "for" loops, only search between the two semicolons
-        if (scope.type == Scope::eFor) {
+        if (scope.type == ScopeType::eFor) {
             startOfCondition = Token::findsimplematch(tok->tokAt(2), ";", endOfCondition);
             if (!startOfCondition)
                 continue;
@@ -1919,59 +2466,145 @@ void CheckStl::checkDereferenceInvalidIterator()
     }
 }
 
-void CheckStl::dereferenceInvalidIteratorError(const Token* deref, const std::string &iterName)
+
+void CheckStl::checkDereferenceInvalidIterator2()
 {
-    reportError(deref, Severity::warning,
-                "derefInvalidIterator",
-                "$symbol:" + iterName + "\n"
-                "Possible dereference of an invalid iterator: $symbol\n"
-                "Possible dereference of an invalid iterator: $symbol. Make sure to check that the iterator is valid before dereferencing it - not after.", CWE825, false);
-}
+    const bool printInconclusive = (mSettings->certainty.isEnabled(Certainty::inconclusive));
 
+    logChecker("CheckStl::checkDereferenceInvalidIterator2");
 
-void CheckStl::readingEmptyStlContainer2()
-{
-    for (const Scope *function : mTokenizer->getSymbolDatabase()->functionScopes) {
-        for (const Token *tok = function->bodyStart; tok != function->bodyEnd; tok = tok->next()) {
-            if (!tok->isName() || !tok->valueType())
-                continue;
-            const Library::Container *container = tok->valueType()->container;
-            if (!container)
-                continue;
-            const ValueFlow::Value *value = tok->getContainerSizeValue(0);
-            if (!value)
+    for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
+        if (Token::Match(tok, "sizeof|decltype|typeid|typeof (")) {
+            tok = tok->linkAt(1);
+            continue;
+        }
+
+        if (Token::Match(tok, "%assign%"))
+            continue;
+
+        std::vector<ValueFlow::Value> contValues;
+        std::copy_if(tok->values().cbegin(), tok->values().cend(), std::back_inserter(contValues), [&](const ValueFlow::Value& value) {
+            if (value.isImpossible())
+                return false;
+            if (!printInconclusive && value.isInconclusive())
+                return false;
+            return value.isContainerSizeValue();
+        });
+
+
+        // Can iterator point to END or before START?
+        for (const ValueFlow::Value& value:tok->values()) {
+            if (value.isImpossible())
                 continue;
-            if (value->isInconclusive() && !mSettings->inconclusive)
+            if (!printInconclusive && value.isInconclusive())
                 continue;
-            if (!value->errorSeverity() && !mSettings->isEnabled(Settings::WARNING))
+            if (!value.isIteratorValue())
                 continue;
-            if (Token::Match(tok, "%name% . %name% (")) {
-                if (container->getYield(tok->strAt(2)) == Library::Container::Yield::ITEM)
-                    readingEmptyStlContainerError(tok,value);
+            bool isInvalidIterator = false;
+            const ValueFlow::Value* cValue = nullptr;
+            if (value.isIteratorEndValue() && value.intvalue >= 0) {
+                isInvalidIterator = value.intvalue > 0;
+            } else if (value.isIteratorStartValue() && value.intvalue < 0) {
+                isInvalidIterator = true;
+            } else {
+                auto it = std::find_if(contValues.cbegin(), contValues.cend(), [&](const ValueFlow::Value& c) {
+                    if (value.path != c.path)
+                        return false;
+                    if (value.isIteratorStartValue() && value.intvalue >= c.intvalue)
+                        return true;
+                    if (value.isIteratorEndValue() && -value.intvalue > c.intvalue)
+                        return true;
+                    return false;
+                });
+                if (it == contValues.end())
+                    continue;
+                cValue = &*it;
+                if (value.isIteratorStartValue() && value.intvalue > cValue->intvalue)
+                    isInvalidIterator = true;
+            }
+            bool inconclusive = false;
+            bool unknown = false;
+            const Token* emptyAdvance = nullptr;
+            const Token* advanceIndex = nullptr;
+            if (cValue && cValue->intvalue == 0) {
+                if (Token::Match(tok->astParent(), "+|-") && astIsIntegral(tok->astSibling(), false)) {
+                    if (tok->astSibling() && tok->astSibling()->hasKnownIntValue()) {
+                        if (tok->astSibling()->getKnownIntValue() == 0)
+                            continue;
+                    } else {
+                        advanceIndex = tok->astSibling();
+                    }
+                    emptyAdvance = tok->astParent();
+                } else if (Token::Match(tok->astParent(), "++|--")) {
+                    emptyAdvance = tok->astParent();
+                }
+            }
+            if (!CheckNullPointer::isPointerDeRef(tok, unknown, *mSettings) && !isInvalidIterator && !emptyAdvance) {
+                if (!unknown)
+                    continue;
+                inconclusive = true;
+            }
+            if (cValue) {
+                const ValueFlow::Value& lValue = getLifetimeIteratorValue(tok, cValue->path);
+                if (!lValue.isLifetimeValue())
+                    continue;
+                if (emptyAdvance)
+                    outOfBoundsError(emptyAdvance,
+                                     lValue.tokvalue->expressionString(),
+                                     cValue,
+                                     advanceIndex ? advanceIndex->expressionString() : "",
+                                     nullptr);
+                else
+                    outOfBoundsError(tok, lValue.tokvalue->expressionString(), cValue, tok->expressionString(), &value);
+            } else {
+                dereferenceInvalidIteratorError(tok, &value, inconclusive);
             }
         }
     }
 }
 
-void CheckStl::readingEmptyStlContainerError(const Token *tok, const ValueFlow::Value *value)
+void CheckStl::dereferenceInvalidIteratorError(const Token* tok, const ValueFlow::Value *value, bool inconclusive)
 {
-    const std::string varname = tok ? tok->str() : std::string("var");
+    const std::string& varname = tok ? tok->expressionString() : "var";
+    const std::string errmsgcond("$symbol:" + varname + '\n' + ValueFlow::eitherTheConditionIsRedundant(value ? value->condition : nullptr) + " or there is possible dereference of an invalid iterator: $symbol.");
+    if (!tok || !value) {
+        reportError(tok, Severity::error, "derefInvalidIterator", "Dereference of an invalid iterator", CWE825, Certainty::normal);
+        reportError(tok, Severity::warning, "derefInvalidIteratorRedundantCheck", errmsgcond, CWE825, Certainty::normal);
+        return;
+    }
+    if (!mSettings->isEnabled(value, inconclusive))
+        return;
 
-    std::string errmsg;
-    if (value && value->condition)
-        errmsg = "Reading from container '$symbol'. " + ValueFlow::eitherTheConditionIsRedundant(value->condition) + " or '$symbol' can be empty.";
-    else
-        errmsg = "Reading from empty STL container '$symbol'";
+    ErrorPath errorPath = getErrorPath(tok, value, "Dereference of an invalid iterator");
 
-    const ErrorPath errorPath = getErrorPath(tok, value, "Reading from empty container");
+    if (value->condition) {
+        reportError(std::move(errorPath), Severity::warning, "derefInvalidIteratorRedundantCheck", errmsgcond, CWE825, (inconclusive || value->isInconclusive()) ? Certainty::inconclusive : Certainty::normal);
+    } else {
+        std::string errmsg = std::string(value->isKnown() ? "Dereference" : "Possible dereference") + " of an invalid iterator";
+        if (!varname.empty())
+            errmsg = "$symbol:" + varname + '\n' + errmsg + ": $symbol";
+
+        reportError(std::move(errorPath),
+                    value->isKnown() ? Severity::error : Severity::warning,
+                    "derefInvalidIterator",
+                    errmsg,
+                    CWE825, (inconclusive || value->isInconclusive()) ? Certainty::inconclusive : Certainty::normal);
+    }
+}
 
-    reportError(errorPath, value ? (value->errorSeverity() ? Severity::error : Severity::warning) : Severity::style, "reademptycontainer", "$symbol:" + varname +"\n" + errmsg, CWE398, !value);
+void CheckStl::dereferenceInvalidIteratorError(const Token* deref, const std::string &iterName)
+{
+    reportError(deref, Severity::warning,
+                "derefInvalidIterator",
+                "$symbol:" + iterName + "\n"
+                "Possible dereference of an invalid iterator: $symbol\n"
+                "Possible dereference of an invalid iterator: $symbol. Make sure to check that the iterator is valid before dereferencing it - not after.", CWE825, Certainty::normal);
 }
 
 void CheckStl::useStlAlgorithmError(const Token *tok, const std::string &algoName)
 {
     reportError(tok, Severity::style, "useStlAlgorithm",
-                "Consider using " + algoName + " algorithm instead of a raw loop.", CWE398, false);
+                "Consider using " + algoName + " algorithm instead of a raw loop.", CWE398, Certainty::normal);
 }
 
 static bool isEarlyExit(const Token *start)
@@ -1979,8 +2612,8 @@ static bool isEarlyExit(const Token *start)
     if (start->str() != "{")
         return false;
     const Token *endToken = start->link();
-    const Token *tok = Token::findmatch(start, "return|throw|break", endToken);
-    if (!tok)
+    const Token *tok = Token::findmatch(start, "return|throw|break|continue", endToken);
+    if (!tok || tok->scope() != start->scope() || tok->str() == "continue")
         return false;
     const Token *endStatement = Token::findsimplematch(tok, "; }", endToken);
     if (!endStatement)
@@ -2003,7 +2636,9 @@ static const Token *singleStatement(const Token *start)
     return endStatement;
 }
 
-static const Token *singleAssignInScope(const Token *start, nonneg int varid, bool &input)
+enum class LoopType : std::uint8_t { OTHER, RANGE, ITERATOR, INDEX };
+
+static const Token *singleAssignInScope(const Token *start, nonneg int varid, bool &input, bool &hasBreak, LoopType loopType, const Settings& settings)
 {
     const Token *endStatement = singleStatement(start);
     if (!endStatement)
@@ -2011,15 +2646,33 @@ static const Token *singleAssignInScope(const Token *start, nonneg int varid, bo
     if (!Token::Match(start->next(), "%var% %assign%"))
         return nullptr;
     const Token *assignTok = start->tokAt(2);
-    if (isVariableChanged(assignTok->next(), endStatement, assignTok->astOperand1()->varId(), false, nullptr, true))
+    if (isVariableChanged(assignTok->next(), endStatement, assignTok->astOperand1()->varId(), /*globalvar*/ false, settings))
         return nullptr;
-    if (isVariableChanged(assignTok->next(), endStatement, varid, false, nullptr, true))
+    if (isVariableChanged(assignTok->next(), endStatement, varid, /*globalvar*/ false, settings))
         return nullptr;
     input = Token::findmatch(assignTok->next(), "%varid%", endStatement, varid) || !Token::Match(start->next(), "%var% =");
+    hasBreak = Token::simpleMatch(endStatement->previous(), "break");
+
+    if (loopType == LoopType::INDEX) { // check for container access
+        nonneg int containerId{};
+        for (const Token* tok = assignTok->next(); tok != endStatement; tok = tok->next()) {
+            if (tok->varId() == varid) {
+                if (!Token::simpleMatch(tok->astParent(), "["))
+                    return nullptr;
+                const Token* contTok = tok->astParent()->astOperand1();
+                if (!contTok->valueType() || !contTok->valueType()->container || contTok->varId() == 0)
+                    return nullptr;
+                if (containerId > 0 && containerId != contTok->varId()) // allow only one container
+                    return nullptr;
+                containerId = contTok->varId();
+            }
+        }
+        return containerId > 0 ? assignTok : nullptr;
+    }
     return assignTok;
 }
 
-static const Token *singleMemberCallInScope(const Token *start, nonneg int varid, bool &input)
+static const Token *singleMemberCallInScope(const Token *start, nonneg int varid, bool &input, const Settings& settings)
 {
     if (start->str() != "{")
         return nullptr;
@@ -2036,7 +2689,7 @@ static const Token *singleMemberCallInScope(const Token *start, nonneg int varid
     if (!Token::findmatch(dotTok->tokAt(2), "%varid%", endStatement, varid))
         return nullptr;
     input = Token::Match(start->next(), "%var% . %name% ( %varid% )", varid);
-    if (isVariableChanged(dotTok->next(), endStatement, dotTok->astOperand1()->varId(), false, nullptr, true))
+    if (isVariableChanged(dotTok->next(), endStatement, dotTok->astOperand1()->varId(), /*globalvar*/ false, settings))
         return nullptr;
     return dotTok;
 }
@@ -2056,7 +2709,7 @@ static const Token *singleIncrementInScope(const Token *start, nonneg int varid,
     return varTok;
 }
 
-static const Token *singleConditionalInScope(const Token *start, nonneg int varid)
+static const Token *singleConditionalInScope(const Token *start, nonneg int varid, LoopType loopType, const Settings& settings)
 {
     if (start->str() != "{")
         return nullptr;
@@ -2073,8 +2726,24 @@ static const Token *singleConditionalInScope(const Token *start, nonneg int vari
         return nullptr;
     if (!Token::findmatch(start, "%varid%", bodyTok, varid))
         return nullptr;
-    if (isVariableChanged(start, bodyTok, varid, false, nullptr, true))
+    if (isVariableChanged(start, bodyTok, varid, /*globalvar*/ false, settings))
         return nullptr;
+    if (loopType == LoopType::INDEX) { // check for container access
+        nonneg int containerId{};
+        for (const Token* tok = start->tokAt(2); tok != start->linkAt(2); tok = tok->next()) {
+            if (tok->varId() == varid) {
+                if (!Token::simpleMatch(tok->astParent(), "["))
+                    return nullptr;
+                const Token* contTok = tok->astParent()->astOperand1();
+                if (!contTok->valueType() || !contTok->valueType()->container || contTok->varId() == 0)
+                    return nullptr;
+                if (containerId > 0 && containerId != contTok->varId()) // allow only one container
+                    return nullptr;
+                containerId = contTok->varId();
+            }
+        }
+        return containerId > 0 ? bodyTok : nullptr;
+    }
     return bodyTok;
 }
 
@@ -2139,11 +2808,9 @@ static std::string flipMinMax(const std::string &algo)
     return algo;
 }
 
-static std::string minmaxCompare(const Token *condTok, nonneg int loopVar, nonneg int assignVar, bool invert = false)
+static std::string minmaxCompare(const Token *condTok, nonneg int loopVar, nonneg int assignVar, LoopType loopType, bool invert = false)
 {
-    if (!Token::Match(condTok, "<|<=|>=|>"))
-        return "std::accumulate";
-    if (!hasVarIds(condTok, loopVar, assignVar))
+    if (loopType == LoopType::RANGE && !hasVarIds(condTok, loopVar, assignVar))
         return "std::accumulate";
     std::string algo = "std::max_element";
     if (Token::Match(condTok, "<|<="))
@@ -2155,30 +2822,260 @@ static std::string minmaxCompare(const Token *condTok, nonneg int loopVar, nonne
     return algo;
 }
 
+static bool isTernaryAssignment(const Token* assignTok, nonneg int loopVarId, nonneg int assignVarId, LoopType loopType, std::string& algo)
+{
+    if (!Token::simpleMatch(assignTok->astOperand2(), "?"))
+        return false;
+    const Token* condTok = assignTok->astOperand2()->astOperand1();
+    if (!Token::Match(condTok, "<|<=|>=|>"))
+        return false;
+
+    const Token* colon = assignTok->astOperand2()->astOperand2();
+    if (loopType == LoopType::RANGE) {
+        if (!(condTok->astOperand1()->varId() && condTok->astOperand2()->varId() && colon->astOperand1()->varId() && colon->astOperand2()->varId()))
+            return false;
+    }
+    else if (loopType == LoopType::INDEX) {
+        int nVar = 0, nCont = 0;
+        for (const Token* tok : { condTok->astOperand1(), condTok->astOperand2(), colon->astOperand1(), colon->astOperand2() }) {
+            if (tok->varId())
+                ++nVar;
+            else if (tok->str() == "[" && tok->astOperand1()->varId() && tok->astOperand1()->valueType() && tok->astOperand1()->valueType()->container &&
+                     tok->astOperand2()->varId() == loopVarId)
+                ++nCont;
+        }
+        if (nVar != 2 || nCont != 2)
+            return false;
+    }
+    else
+        return false;
+
+    algo = minmaxCompare(condTok, loopVarId, assignVarId, loopType, colon->astOperand1()->varId() == assignVarId);
+    return true;
+}
+
+namespace {
+    struct LoopAnalyzer {
+        const Token* bodyTok = nullptr;
+        const Token* loopVar = nullptr;
+        const Settings* settings = nullptr;
+        std::set<nonneg int> varsChanged;
+
+        explicit LoopAnalyzer(const Token* tok, const Settings* psettings)
+            : bodyTok(tok->linkAt(1)->next()), settings(psettings)
+        {
+            const Token* splitTok = tok->next()->astOperand2();
+            if (Token::simpleMatch(splitTok, ":") && splitTok->previous()->varId() != 0) {
+                loopVar = splitTok->previous();
+            }
+            if (valid()) {
+                findChangedVariables();
+            }
+        }
+        bool isLoopVarChanged() const {
+            return varsChanged.count(loopVar->varId()) > 0;
+        }
+
+        bool isModified(const Token* tok) const
+        {
+            if (tok->variable() && tok->variable()->isConst())
+                return false;
+            int n = 1 + (astIsPointer(tok) ? 1 : 0);
+            for (int i = 0; i < n; i++) {
+                bool inconclusive = false;
+                if (isVariableChangedByFunctionCall(tok, i, *settings, &inconclusive))
+                    return true;
+                if (inconclusive)
+                    return true;
+                if (isVariableChanged(tok, i, *settings))
+                    return true;
+            }
+            return false;
+        }
+
+        template<class Predicate, class F>
+        void findTokens(Predicate pred, F f) const
+        {
+            for (const Token* tok = bodyTok; precedes(tok, bodyTok->link()); tok = tok->next()) {
+                if (pred(tok))
+                    f(tok);
+            }
+        }
+
+        template<class Predicate>
+        const Token* findToken(Predicate pred) const
+        {
+            for (const Token* tok = bodyTok; precedes(tok, bodyTok->link()); tok = tok->next()) {
+                if (pred(tok))
+                    return tok;
+            }
+            return nullptr;
+        }
+
+        bool hasGotoOrBreak() const
+        {
+            return findToken([](const Token* tok) {
+                return Token::Match(tok, "goto|break");
+            });
+        }
+
+        bool valid() const {
+            return bodyTok && loopVar;
+        }
+
+        std::string findAlgo() const
+        {
+            if (!valid())
+                return "";
+            bool loopVarChanged = isLoopVarChanged();
+            if (!loopVarChanged && varsChanged.empty()) {
+                if (hasGotoOrBreak())
+                    return "";
+                bool alwaysTrue = true;
+                bool alwaysFalse = true;
+                auto hasReturn = [](const Token* tok) {
+                    return Token::simpleMatch(tok, "return");
+                };
+                findTokens(hasReturn, [&](const Token* tok) {
+                    const Token* returnTok = tok->astOperand1();
+                    if (!returnTok || !returnTok->hasKnownIntValue() || !astIsBool(returnTok)) {
+                        alwaysTrue = false;
+                        alwaysFalse = false;
+                        return;
+                    }
+                    (returnTok->getKnownIntValue() ? alwaysTrue : alwaysFalse) &= true;
+                    (returnTok->getKnownIntValue() ? alwaysFalse : alwaysTrue) &= false;
+                });
+                if (alwaysTrue == alwaysFalse)
+                    return "";
+                if (alwaysTrue)
+                    return "std::any_of";
+                return "std::all_of or std::none_of";
+            }
+            return "";
+        }
+
+        bool isLocalVar(const Variable* var) const
+        {
+            if (!var)
+                return false;
+            if (var->isPointer() || var->isReference())
+                return false;
+            if (var->declarationId() == loopVar->varId())
+                return false;
+            const Scope* scope = var->scope();
+            return scope && scope->isNestedIn(bodyTok->scope());
+        }
+
+    private:
+        void findChangedVariables()
+        {
+            std::set<nonneg int> vars;
+            for (const Token* tok = bodyTok; precedes(tok, bodyTok->link()); tok = tok->next()) {
+                if (tok->varId() == 0)
+                    continue;
+                if (vars.count(tok->varId()) > 0)
+                    continue;
+                if (isLocalVar(tok->variable())) {
+                    vars.insert(tok->varId());
+                    continue;
+                }
+                if (!isModified(tok))
+                    continue;
+                varsChanged.insert(tok->varId());
+                vars.insert(tok->varId());
+            }
+        }
+    };
+} // namespace
+
 void CheckStl::useStlAlgorithm()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("useStlAlgorithm"))
         return;
+
+    logChecker("CheckStl::useStlAlgorithm"); // style
+
+    auto checkAssignee = [](const Token* tok) {
+        if (astIsBool(tok)) // std::accumulate is not a good fit for bool values, std::all/any/none_of return early
+            return false;
+        return !astIsContainer(tok); // don't warn for containers, where overloaded operators can be costly
+    };
+
+    enum class ConditionOpType : std::uint8_t { OTHER, MIN, MAX };
+    auto isConditionWithoutSideEffects = [this](const Token* tok, ConditionOpType& type) -> bool {
+        if (!Token::simpleMatch(tok, "{") || !Token::simpleMatch(tok->previous(), ")"))
+            return false;
+        const Token* condTok = tok->linkAt(-1)->astOperand2();
+        if (isConstExpression(condTok, mSettings->library)) {
+            if (condTok->str() == "<")
+                type = ConditionOpType::MIN;
+            else if (condTok->str() == ">")
+                type = ConditionOpType::MAX;
+            else
+                type = ConditionOpType::OTHER;
+            return true;
+        }
+        return false;
+    };
+
+    auto isAccumulation = [](const Token* tok, int varId) {
+        if (tok->str() != "=")
+            return true;
+        const Token* end = Token::findmatch(tok, "%varid%|;", varId); // TODO: lambdas?
+        return end && end->varId() != 0;
+    };
+
     for (const Scope *function : mTokenizer->getSymbolDatabase()->functionScopes) {
         for (const Token *tok = function->bodyStart; tok != function->bodyEnd; tok = tok->next()) {
             // Parse range-based for loop
             if (!Token::simpleMatch(tok, "for ("))
                 continue;
-            if (!Token::simpleMatch(tok->next()->link(), ") {"))
-                continue;
-            const Token *bodyTok = tok->next()->link()->next();
-            const Token *splitTok = tok->next()->astOperand2();
-            if (!Token::simpleMatch(splitTok, ":"))
+            if (!Token::simpleMatch(tok->linkAt(1), ") {"))
                 continue;
-            const Token *loopVar = splitTok->previous();
-            if (!Token::Match(loopVar, "%var%"))
+            LoopAnalyzer a{tok, mSettings};
+            std::string algoName = a.findAlgo();
+            if (!algoName.empty()) {
+                useStlAlgorithmError(tok, algoName);
                 continue;
+            }
+
+            const Token *bodyTok = tok->linkAt(1)->next();
+            const Token *splitTok = tok->next()->astOperand2();
+            const Token* loopVar{};
+            LoopType loopType{};
+            if (Token::simpleMatch(splitTok, ":")) {
+                loopVar = splitTok->previous();
+                if (loopVar->varId() == 0)
+                    continue;
+                if (Token::simpleMatch(splitTok->astOperand2(), "{"))
+                    continue;
+                loopType = LoopType::RANGE;
+            }
+            else { // iterator-based loop?
+                const Token* initTok = getInitTok(tok);
+                const Token* condTok = getCondTok(tok);
+                const Token* stepTok = getStepTok(tok);
+                if (!initTok || !condTok || !stepTok)
+                    continue;
+                loopVar = Token::Match(condTok, "%comp%") ? condTok->astOperand1() : nullptr;
+                if (!Token::Match(loopVar, "%var%") || !loopVar->valueType() ||
+                    (loopVar->valueType()->type != ValueType::Type::ITERATOR && !loopVar->valueType()->isIntegral()))
+                    continue;
+                if (!Token::simpleMatch(initTok, "=") || !Token::Match(initTok->astOperand1(), "%varid%", loopVar->varId()))
+                    continue;
+                if (!stepTok->isIncDecOp())
+                    continue;
+                loopType = (loopVar->valueType()->type == ValueType::Type::ITERATOR) ? LoopType::ITERATOR : LoopType::INDEX;
+            }
 
             // Check for single assignment
-            bool useLoopVarInAssign;
-            const Token *assignTok = singleAssignInScope(bodyTok, loopVar->varId(), useLoopVarInAssign);
+            bool useLoopVarInAssign{}, hasBreak{};
+            const Token *assignTok = singleAssignInScope(bodyTok, loopVar->varId(), useLoopVarInAssign, hasBreak, loopType, *mSettings);
             if (assignTok) {
-                int assignVarId = assignTok->astOperand1()->varId();
+                if (!checkAssignee(assignTok->astOperand1()))
+                    continue;
+                const int assignVarId = assignTok->astOperand1()->varId();
                 std::string algo;
                 if (assignVarId == loopVar->varId()) {
                     if (useLoopVarInAssign)
@@ -2194,18 +3091,20 @@ void CheckStl::useStlAlgorithm()
                         algo = "std::distance";
                     else if (accumulateBool(assignTok, assignVarId))
                         algo = "std::any_of, std::all_of, std::none_of, or std::accumulate";
-                    else if (Token::Match(assignTok, "= %var% <|<=|>=|> %var% ? %var% : %var%") && hasVarIds(assignTok->tokAt(6), loopVar->varId(), assignVarId))
-                        algo = minmaxCompare(assignTok->tokAt(2), loopVar->varId(), assignVarId, assignTok->tokAt(5)->varId() == assignVarId);
-                    else
+                    else if (isTernaryAssignment(assignTok, loopVar->varId(), assignVarId, loopType, algo))
+                        ;
+                    else if (isAccumulation(assignTok, assignVarId))
                         algo = "std::accumulate";
+                    else
+                        continue;
                 }
                 useStlAlgorithmError(assignTok, algo);
                 continue;
             }
             // Check for container calls
             bool useLoopVarInMemCall;
-            const Token *memberAccessTok = singleMemberCallInScope(bodyTok, loopVar->varId(), useLoopVarInMemCall);
-            if (memberAccessTok) {
+            const Token *memberAccessTok = singleMemberCallInScope(bodyTok, loopVar->varId(), useLoopVarInMemCall, *mSettings);
+            if (memberAccessTok && loopType == LoopType::RANGE) {
                 const Token *memberCallTok = memberAccessTok->astOperand2();
                 const int contVarId = memberAccessTok->astOperand1()->varId();
                 if (contVarId == loopVar->varId())
@@ -2237,11 +3136,13 @@ void CheckStl::useStlAlgorithm()
             }
 
             // Check for conditionals
-            const Token *condBodyTok = singleConditionalInScope(bodyTok, loopVar->varId());
+            const Token *condBodyTok = singleConditionalInScope(bodyTok, loopVar->varId(), loopType, *mSettings);
             if (condBodyTok) {
                 // Check for single assign
-                assignTok = singleAssignInScope(condBodyTok, loopVar->varId(), useLoopVarInAssign);
+                assignTok = singleAssignInScope(condBodyTok, loopVar->varId(), useLoopVarInAssign, hasBreak, loopType, *mSettings);
                 if (assignTok) {
+                    if (!checkAssignee(assignTok->astOperand1()))
+                        continue;
                     const int assignVarId = assignTok->astOperand1()->varId();
                     std::string algo;
                     if (assignVarId == loopVar->varId()) {
@@ -2250,19 +3151,36 @@ void CheckStl::useStlAlgorithm()
                         else
                             algo = "std::replace_if";
                     } else {
+                        ConditionOpType type{};
                         if (addByOne(assignTok, assignVarId))
                             algo = "std::count_if";
                         else if (accumulateBoolLiteral(assignTok, assignVarId))
                             algo = "std::any_of, std::all_of, std::none_of, or std::accumulate";
-                        else
+                        else if (assignTok->str() != "=")
                             algo = "std::accumulate";
+                        else if (isConditionWithoutSideEffects(condBodyTok, type)) {
+                            if (hasBreak)
+                                algo = "std::any_of, std::all_of, std::none_of";
+                            else if (assignTok->astOperand2()->varId() == loopVar->varId()) {
+                                if (type == ConditionOpType::MIN)
+                                    algo = "std::min_element";
+                                else if (type == ConditionOpType::MAX)
+                                    algo = "std::max_element";
+                                else
+                                    continue;
+                            }
+                            else
+                                continue;
+                        }
+                        else
+                            continue;
                     }
                     useStlAlgorithmError(assignTok, algo);
                     continue;
                 }
 
                 // Check for container call
-                memberAccessTok = singleMemberCallInScope(condBodyTok, loopVar->varId(), useLoopVarInMemCall);
+                memberAccessTok = singleMemberCallInScope(condBodyTok, loopVar->varId(), useLoopVarInMemCall, *mSettings);
                 if (memberAccessTok) {
                     const Token *memberCallTok = memberAccessTok->astOperand2();
                     const int contVarId = memberAccessTok->astOperand1()->varId();
@@ -2294,7 +3212,8 @@ void CheckStl::useStlAlgorithm()
                 if (isEarlyExit(condBodyTok)) {
                     const Token *loopVar2 = Token::findmatch(condBodyTok, "%varid%", condBodyTok->link(), loopVar->varId());
                     std::string algo;
-                    if (loopVar2)
+                    if (loopVar2 ||
+                        (loopType == LoopType::ITERATOR && loopVar->variable() && precedes(loopVar->variable()->nameToken(), tok))) // iterator declared outside the loop
                         algo = "std::find_if";
                     else
                         algo = "std::any_of";
@@ -2305,3 +3224,305 @@ void CheckStl::useStlAlgorithm()
         }
     }
 }
+
+void CheckStl::knownEmptyContainerError(const Token *tok, const std::string& algo)
+{
+    const std::string var = tok ? tok->expressionString() : std::string("var");
+
+    std::string msg;
+    if (astIsIterator(tok)) {
+        msg = "Using " + algo + " with iterator '" + var + "' that is always empty.";
+    } else {
+        msg = "Iterating over container '" + var + "' that is always empty.";
+    }
+
+    reportError(tok, Severity::style,
+                "knownEmptyContainer",
+                msg, CWE398, Certainty::normal);
+}
+
+static bool isKnownEmptyContainer(const Token* tok)
+{
+    if (!tok)
+        return false;
+    return std::any_of(tok->values().begin(), tok->values().end(), [&](const ValueFlow::Value& v) {
+        if (!v.isKnown())
+            return false;
+        if (!v.isContainerSizeValue())
+            return false;
+        if (v.intvalue != 0)
+            return false;
+        return true;
+    });
+}
+
+void CheckStl::knownEmptyContainer()
+{
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("knownEmptyContainer"))
+        return;
+    logChecker("CheckStl::knownEmptyContainer"); // style
+    for (const Scope *function : mTokenizer->getSymbolDatabase()->functionScopes) {
+        for (const Token *tok = function->bodyStart; tok != function->bodyEnd; tok = tok->next()) {
+
+            if (!Token::Match(tok, "%name% ( !!)"))
+                continue;
+
+            // Parse range-based for loop
+            if (tok->str() == "for") {
+                if (!Token::simpleMatch(tok->linkAt(1), ") {"))
+                    continue;
+                const Token *splitTok = tok->next()->astOperand2();
+                if (!Token::simpleMatch(splitTok, ":"))
+                    continue;
+                const Token* contTok = splitTok->astOperand2();
+                if (!isKnownEmptyContainer(contTok))
+                    continue;
+                knownEmptyContainerError(contTok, "");
+            } else {
+                const std::vector<const Token *> args = getArguments(tok);
+                if (args.empty())
+                    continue;
+
+                for (int argnr = 1; argnr <= args.size(); ++argnr) {
+                    const Library::ArgumentChecks::IteratorInfo *i = mSettings->library.getArgIteratorInfo(tok, argnr);
+                    if (!i)
+                        continue;
+                    const Token * const argTok = args[argnr - 1];
+                    if (!isKnownEmptyContainer(argTok))
+                        continue;
+                    knownEmptyContainerError(argTok, tok->str());
+                    break;
+
+                }
+            }
+        }
+    }
+}
+
+void CheckStl::eraseIteratorOutOfBoundsError(const Token *ftok, const Token* itertok, const ValueFlow::Value* val)
+{
+    if (!ftok || !itertok || !val) {
+        reportError(ftok, Severity::error, "eraseIteratorOutOfBounds",
+                    "Calling function 'erase()' on the iterator 'iter' which is out of bounds.", CWE628, Certainty::normal);
+        reportError(ftok, Severity::warning, "eraseIteratorOutOfBoundsCond",
+                    "Either the condition 'x' is redundant or function 'erase()' is called on the iterator 'iter' which is out of bounds.", CWE628, Certainty::normal);
+        return;
+    }
+    const std::string& func = ftok->str();
+    const std::string iter = itertok->expressionString();
+
+    const bool isConditional = val->isPossible();
+    std::string msg;
+    if (isConditional) {
+        msg = ValueFlow::eitherTheConditionIsRedundant(val->condition) + " or function '" + func + "()' is called on the iterator '" + iter + "' which is out of bounds.";
+    } else {
+        msg = "Calling function '" + func + "()' on the iterator '" + iter + "' which is out of bounds.";
+    }
+
+    const Severity severity = isConditional ? Severity::warning : Severity::error;
+    const std::string id = isConditional ? "eraseIteratorOutOfBoundsCond" : "eraseIteratorOutOfBounds";
+    reportError(ftok, severity,
+                id,
+                msg, CWE628, Certainty::normal);
+}
+
+static const ValueFlow::Value* getOOBIterValue(const Token* tok, const ValueFlow::Value* sizeVal)
+{
+    auto it = std::find_if(tok->values().begin(), tok->values().end(), [&](const ValueFlow::Value& v) {
+        if (v.isPossible() || v.isKnown()) {
+            switch (v.valueType) {
+            case ValueFlow::Value::ValueType::ITERATOR_END:
+                return v.intvalue >= 0;
+            case ValueFlow::Value::ValueType::ITERATOR_START:
+                return (v.intvalue < 0) || (sizeVal && v.intvalue >= sizeVal->intvalue);
+            default:
+                break;
+            }
+        }
+        return false;
+    });
+    return it != tok->values().end() ? &*it : nullptr;
+}
+
+void CheckStl::eraseIteratorOutOfBounds()
+{
+    logChecker("CheckStl::eraseIteratorOutOfBounds");
+    for (const Scope *function : mTokenizer->getSymbolDatabase()->functionScopes) {
+        for (const Token *tok = function->bodyStart; tok != function->bodyEnd; tok = tok->next()) {
+
+            if (!tok->valueType())
+                continue;
+            const Library::Container* container = tok->valueType()->container;
+            if (!container || !astIsLHS(tok) || !Token::simpleMatch(tok->astParent(), "."))
+                continue;
+            const Token* const ftok = tok->astParent()->astOperand2();
+            const Library::Container::Action action = container->getAction(ftok->str());
+            if (action != Library::Container::Action::ERASE)
+                continue;
+            const std::vector<const Token*> args = getArguments(ftok);
+            if (args.size() != 1) // TODO: check range overload
+                continue;
+
+            const ValueFlow::Value* sizeVal = tok->getKnownValue(ValueFlow::Value::ValueType::CONTAINER_SIZE);
+            if (const ValueFlow::Value* errVal = getOOBIterValue(args[0], sizeVal))
+                eraseIteratorOutOfBoundsError(ftok, args[0], errVal);
+        }
+    }
+}
+
+static bool isMutex(const Variable* var)
+{
+    const Token* tok = Token::typeDecl(var->nameToken()).first;
+    return Token::Match(tok, "std :: mutex|recursive_mutex|timed_mutex|recursive_timed_mutex|shared_mutex");
+}
+
+static bool isLockGuard(const Variable* var)
+{
+    const Token* tok = Token::typeDecl(var->nameToken()).first;
+    return Token::Match(tok, "std :: lock_guard|unique_lock|scoped_lock|shared_lock");
+}
+
+static bool isLocalMutex(const Variable* var, const Scope* scope)
+{
+    if (!var)
+        return false;
+    if (isLockGuard(var))
+        return false;
+    return !var->isReference() && !var->isRValueReference() && !var->isStatic() && var->scope() == scope;
+}
+
+void CheckStl::globalLockGuardError(const Token* tok)
+{
+    reportError(tok, Severity::warning,
+                "globalLockGuard",
+                "Lock guard is defined globally. Lock guards are intended to be local. A global lock guard could lead to a deadlock since it won't unlock until the end of the program.", CWE833, Certainty::normal);
+}
+
+void CheckStl::localMutexError(const Token* tok)
+{
+    reportError(tok, Severity::warning,
+                "localMutex",
+                "The lock is ineffective because the mutex is locked at the same scope as the mutex itself.", CWE667, Certainty::normal);
+}
+
+void CheckStl::checkMutexes()
+{
+    if (!mSettings->severity.isEnabled(Severity::warning))
+        return;
+    logChecker("CheckStl::checkMutexes"); // warning
+    for (const Scope *function : mTokenizer->getSymbolDatabase()->functionScopes) {
+        std::set<nonneg int> checkedVars;
+        for (const Token *tok = function->bodyStart; tok != function->bodyEnd; tok = tok->next()) {
+            if (!Token::Match(tok, "%var%"))
+                continue;
+            const Variable* var = tok->variable();
+            if (!var)
+                continue;
+            if (Token::Match(tok, "%var% . lock ( )")) {
+                if (!isMutex(var))
+                    continue;
+                if (!checkedVars.insert(var->declarationId()).second)
+                    continue;
+                if (isLocalMutex(var, tok->scope()))
+                    localMutexError(tok);
+            } else if (Token::Match(tok, "%var% (|{ %var% )|}|,")) {
+                if (!isLockGuard(var))
+                    continue;
+                const Variable* mvar = tok->tokAt(2)->variable();
+                if (!mvar)
+                    continue;
+                if (!checkedVars.insert(mvar->declarationId()).second)
+                    continue;
+                if (var->isStatic() || var->isGlobal())
+                    globalLockGuardError(tok);
+                else if (isLocalMutex(mvar, tok->scope()))
+                    localMutexError(tok);
+            }
+        }
+    }
+}
+
+void CheckStl::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    if (!tokenizer.isCPP()) {
+        return;
+    }
+
+    CheckStl checkStl(&tokenizer, &tokenizer.getSettings(), errorLogger);
+    checkStl.erase();
+    checkStl.if_find();
+    checkStl.checkFindInsert();
+    checkStl.iterators();
+    checkStl.missingComparison();
+    checkStl.outOfBounds();
+    checkStl.outOfBoundsIndexExpression();
+    checkStl.redundantCondition();
+    checkStl.string_c_str();
+    checkStl.uselessCalls();
+    checkStl.useStlAlgorithm();
+
+    checkStl.stlOutOfBounds();
+    checkStl.negativeIndex();
+
+    checkStl.invalidContainer();
+    checkStl.mismatchingContainers();
+    checkStl.mismatchingContainerIterator();
+    checkStl.knownEmptyContainer();
+    checkStl.eraseIteratorOutOfBounds();
+
+    checkStl.stlBoundaries();
+    checkStl.checkDereferenceInvalidIterator();
+    checkStl.checkDereferenceInvalidIterator2();
+    checkStl.checkMutexes();
+
+    // Style check
+    checkStl.size();
+}
+
+void CheckStl::getErrorMessages(ErrorLogger* errorLogger, const Settings* settings) const
+{
+    CheckStl c(nullptr, settings, errorLogger);
+    c.outOfBoundsError(nullptr, "container", nullptr, "x", nullptr);
+    c.invalidIteratorError(nullptr, "iterator");
+    c.iteratorsError(nullptr, "container1", "container2");
+    c.iteratorsError(nullptr, nullptr, "container");
+    c.invalidContainerLoopError(nullptr, nullptr, ErrorPath{});
+    c.invalidContainerError(nullptr, nullptr, nullptr, ErrorPath{});
+    c.invalidContainerReferenceError(nullptr, nullptr, ErrorPath{});
+    c.mismatchingContainerIteratorError(nullptr, nullptr, nullptr);
+    c.mismatchingContainersError(nullptr, nullptr);
+    c.mismatchingContainerExpressionError(nullptr, nullptr);
+    c.sameIteratorExpressionError(nullptr);
+    c.dereferenceErasedError(nullptr, nullptr, "iter", false);
+    c.stlOutOfBoundsError(nullptr, "i", "foo", false);
+    c.negativeIndexError(nullptr, ValueFlow::Value(-1));
+    c.stlBoundariesError(nullptr);
+    c.if_findError(nullptr, false);
+    c.if_findError(nullptr, true);
+    c.checkFindInsertError(nullptr);
+    c.string_c_strError(nullptr);
+    c.string_c_strReturn(nullptr);
+    c.string_c_strParam(nullptr, 0);
+    c.string_c_strConstructor(nullptr);
+    c.string_c_strAssignment(nullptr);
+    c.string_c_strConcat(nullptr);
+    c.string_c_strStream(nullptr);
+    c.string_c_strThrowError(nullptr);
+    c.sizeError(nullptr);
+    c.missingComparisonError(nullptr, nullptr);
+    c.redundantIfRemoveError(nullptr);
+    c.uselessCallsReturnValueError(nullptr, "str", "find");
+    c.uselessCallsSwapError(nullptr, "str");
+    c.uselessCallsSubstrError(nullptr, SubstrErrorType::COPY);
+    c.uselessCallsConstructorError(nullptr);
+    c.uselessCallsEmptyError(nullptr);
+    c.uselessCallsRemoveError(nullptr, "remove");
+    c.dereferenceInvalidIteratorError(nullptr, "i");
+    // TODO: derefInvalidIteratorRedundantCheck
+    c.eraseIteratorOutOfBoundsError(nullptr, nullptr);
+    c.useStlAlgorithmError(nullptr, "");
+    c.knownEmptyContainerError(nullptr, "");
+    c.globalLockGuardError(nullptr);
+    c.localMutexError(nullptr);
+    c.outOfBoundsIndexExpressionError(nullptr, nullptr);
+}
diff --git a/lib/checkstl.h b/lib/checkstl.h
index 9cf8509233c..60b9d4c7000 100644
--- a/lib/checkstl.h
+++ b/lib/checkstl.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,18 +24,21 @@
 
 #include "check.h"
 #include "config.h"
-#include "library.h"
-#include "tokenize.h"
+#include "errortypes.h"
 
-#include <map>
+#include <cstdint>
 #include <string>
 
-class ErrorLogger;
 class Scope;
 class Settings;
 class Token;
 class Variable;
-
+class ErrorLogger;
+class Tokenizer;
+namespace ValueFlow
+{
+    class Value;
+}
 
 /// @addtogroup Checks
 /// @{
@@ -45,46 +48,15 @@ class Variable;
 class CPPCHECKLIB CheckStl : public Check {
 public:
     /** This constructor is used when registering the CheckClass */
-    CheckStl() : Check(myName()) {
-    }
+    CheckStl() : Check(myName()) {}
 
+private:
     /** This constructor is used when running checks. */
     CheckStl(const Tokenizer* tokenizer, const Settings* settings, ErrorLogger* errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger) {}
 
     /** run checks, the token list is not simplified */
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        if (!tokenizer->isCPP()) {
-            return;
-        }
-
-        CheckStl checkStl(tokenizer, settings, errorLogger);
-        checkStl.erase();
-        checkStl.if_find();
-        checkStl.checkFindInsert();
-        checkStl.iterators();
-        checkStl.mismatchingContainers();
-        checkStl.missingComparison();
-        checkStl.outOfBounds();
-        checkStl.outOfBoundsIndexExpression();
-        checkStl.redundantCondition();
-        checkStl.string_c_str();
-        checkStl.uselessCalls();
-        checkStl.useStlAlgorithm();
-
-        checkStl.stlOutOfBounds();
-        checkStl.negativeIndex();
-
-        checkStl.invalidContainer();
-        checkStl.mismatchingContainers();
-
-        checkStl.stlBoundaries();
-        checkStl.checkDereferenceInvalidIterator();
-
-        // Style check
-        checkStl.size();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     /** Accessing container out of bounds using ValueFlow */
     void outOfBounds();
@@ -111,12 +83,16 @@ class CPPCHECKLIB CheckStl : public Check {
 
     void invalidContainer();
 
+    bool checkIteratorPair(const Token* tok1, const Token* tok2);
+
     /**
      * Mismatching containers:
      * std::find(foo.begin(), bar.end(), x)
      */
     void mismatchingContainers();
 
+    void mismatchingContainerIterator();
+
     /**
      * Dangerous usage of erase. The iterator is invalidated by erase so
      * it is bad to dereference it after the erase.
@@ -161,6 +137,7 @@ class CPPCHECKLIB CheckStl : public Check {
 
     /** @brief %Check for dereferencing an iterator that is invalid */
     void checkDereferenceInvalidIterator();
+    void checkDereferenceInvalidIterator2();
 
     /**
      * Dereferencing an erased iterator
@@ -171,13 +148,15 @@ class CPPCHECKLIB CheckStl : public Check {
      */
     void dereferenceErasedError(const Token* erased, const Token* deref, const std::string& itername, bool inconclusive);
 
-    /** @brief Reading from empty stl container (using valueflow) */
-    void readingEmptyStlContainer2();
-
     /** @brief Look for loops that can replaced with std algorithms */
     void useStlAlgorithm();
 
-private:
+    void knownEmptyContainer();
+
+    void eraseIteratorOutOfBounds();
+
+    void checkMutexes();
+
     bool isContainerSize(const Token *containerToken, const Token *expr) const;
     bool isContainerSizeGE(const Token * containerToken, const Token *expr) const;
 
@@ -185,7 +164,11 @@ class CPPCHECKLIB CheckStl : public Check {
     void string_c_strThrowError(const Token* tok);
     void string_c_strError(const Token* tok);
     void string_c_strReturn(const Token* tok);
-    void string_c_strParam(const Token* tok, nonneg int number);
+    void string_c_strParam(const Token* tok, nonneg int number, const std::string& argtype = "std::string");
+    void string_c_strConstructor(const Token* tok, const std::string& argtype = "std::string");
+    void string_c_strAssignment(const Token* tok, const std::string& argtype = "std::string");
+    void string_c_strConcat(const Token* tok);
+    void string_c_strStream(const Token* tok);
 
     void outOfBoundsError(const Token *tok, const std::string &containerName, const ValueFlow::Value *containerSize, const std::string &index, const ValueFlow::Value *indexValue);
     void outOfBoundsIndexExpressionError(const Token *tok, const Token *index);
@@ -193,11 +176,9 @@ class CPPCHECKLIB CheckStl : public Check {
     void negativeIndexError(const Token* tok, const ValueFlow::Value& index);
     void invalidIteratorError(const Token* tok, const std::string& iteratorName);
     void iteratorsError(const Token* tok, const std::string& containerName1, const std::string& containerName2);
-    void iteratorsError(const Token* tok, const Token* containerTok, const std::string& containerName1, const std::string& containerName2);
     void iteratorsError(const Token* tok, const Token* containerTok, const std::string& containerName);
-    void iteratorsCmpError(const Token* cmpOperatorTok, const Token* containerTok1, const Token* containerTok2, const std::string& containerName1, const std::string& containerName2);
-    void iteratorsCmpError(const Token* cmpOperatorTok, const Token* containerTok1, const Token* containerTok2, const std::string& containerName);
-    void mismatchingContainersError(const Token* tok);
+    void mismatchingContainerIteratorError(const Token* containerTok, const Token* iterTok, const Token* containerTok2);
+    void mismatchingContainersError(const Token* tok1, const Token* tok2);
     void mismatchingContainerExpressionError(const Token *tok1, const Token *tok2);
     void sameIteratorExpressionError(const Token *tok);
     void stlBoundariesError(const Token* tok);
@@ -205,66 +186,37 @@ class CPPCHECKLIB CheckStl : public Check {
     void checkFindInsertError(const Token *tok);
     void sizeError(const Token* tok);
     void redundantIfRemoveError(const Token* tok);
+    void invalidContainerLoopError(const Token* tok, const Token* loopTok, ErrorPath errorPath);
     void invalidContainerError(const Token *tok, const Token * contTok, const ValueFlow::Value *val, ErrorPath errorPath);
     void invalidContainerReferenceError(const Token* tok, const Token* contTok, ErrorPath errorPath);
 
     void uselessCallsReturnValueError(const Token* tok, const std::string& varname, const std::string& function);
     void uselessCallsSwapError(const Token* tok, const std::string& varname);
-    void uselessCallsSubstrError(const Token* tok, bool empty);
+    enum class SubstrErrorType : std::uint8_t { EMPTY, COPY, PREFIX, PREFIX_CONCAT };
+    void uselessCallsSubstrError(const Token* tok, SubstrErrorType type);
     void uselessCallsEmptyError(const Token* tok);
     void uselessCallsRemoveError(const Token* tok, const std::string& function);
+    void uselessCallsConstructorError(const Token* tok);
 
     void dereferenceInvalidIteratorError(const Token* deref, const std::string& iterName);
-
-    void readingEmptyStlContainerError(const Token* tok, const ValueFlow::Value *value=nullptr);
+    void dereferenceInvalidIteratorError(const Token* tok, const ValueFlow::Value *value, bool inconclusive);
 
     void useStlAlgorithmError(const Token *tok, const std::string &algoName);
 
-    bool compareIteratorAgainstDifferentContainer(const Token* operatorTok, const Token* containerTok, const nonneg int iteratorId, const std::map<int, const Token*>& iteratorScopeBeginInfo);
-
-    void getErrorMessages(ErrorLogger* errorLogger, const Settings* settings) const OVERRIDE {
-        ErrorPath errorPath;
-        CheckStl c(nullptr, settings, errorLogger);
-        c.outOfBoundsError(nullptr, "container", nullptr, "x", nullptr);
-        c.invalidIteratorError(nullptr, "iterator");
-        c.iteratorsError(nullptr, "container1", "container2");
-        c.iteratorsError(nullptr, nullptr, "container0", "container1");
-        c.iteratorsError(nullptr, nullptr, "container");
-        c.iteratorsCmpError(nullptr, nullptr, nullptr, "container1", "container2");
-        c.iteratorsCmpError(nullptr, nullptr, nullptr, "container");
-        c.invalidContainerError(nullptr, nullptr, nullptr, errorPath);
-        c.mismatchingContainersError(nullptr);
-        c.mismatchingContainerExpressionError(nullptr, nullptr);
-        c.sameIteratorExpressionError(nullptr);
-        c.dereferenceErasedError(nullptr, nullptr, "iter", false);
-        c.stlOutOfBoundsError(nullptr, "i", "foo", false);
-        c.negativeIndexError(nullptr, ValueFlow::Value(-1));
-        c.stlBoundariesError(nullptr);
-        c.if_findError(nullptr, false);
-        c.if_findError(nullptr, true);
-        c.checkFindInsertError(nullptr);
-        c.string_c_strError(nullptr);
-        c.string_c_strReturn(nullptr);
-        c.string_c_strParam(nullptr, 0);
-        c.string_c_strThrowError(nullptr);
-        c.sizeError(nullptr);
-        c.missingComparisonError(nullptr, nullptr);
-        c.redundantIfRemoveError(nullptr);
-        c.uselessCallsReturnValueError(nullptr, "str", "find");
-        c.uselessCallsSwapError(nullptr, "str");
-        c.uselessCallsSubstrError(nullptr, false);
-        c.uselessCallsEmptyError(nullptr);
-        c.uselessCallsRemoveError(nullptr, "remove");
-        c.dereferenceInvalidIteratorError(nullptr, "i");
-        c.readingEmptyStlContainerError(nullptr);
-        c.useStlAlgorithmError(nullptr, "");
-    }
+    void knownEmptyContainerError(const Token *tok, const std::string& algo);
+
+    void eraseIteratorOutOfBoundsError(const Token* ftok, const Token* itertok, const ValueFlow::Value* val = nullptr);
+
+    void globalLockGuardError(const Token *tok);
+    void localMutexError(const Token *tok);
+
+    void getErrorMessages(ErrorLogger* errorLogger, const Settings* settings) const override;
 
     static std::string myName() {
         return "STL usage";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Check for invalid usage of STL:\n"
                "- out of bounds errors\n"
                "- misuse of iterators when iterating through a container\n"
@@ -279,8 +231,11 @@ class CPPCHECKLIB CheckStl : public Check {
                "- common mistakes when using string::c_str()\n"
                "- useless calls of string and STL functions\n"
                "- dereferencing an invalid iterator\n"
+               "- erasing an iterator that is out of bounds\n"
                "- reading from empty STL container\n"
-               "- consider using an STL algorithm instead of raw loop\n";
+               "- iterating over an empty STL container\n"
+               "- consider using an STL algorithm instead of raw loop\n"
+               "- incorrect locking with mutex\n";
     }
 };
 /// @}
diff --git a/lib/checkstring.cpp b/lib/checkstring.cpp
index fff8215ed4e..64b575df72d 100644
--- a/lib/checkstring.cpp
+++ b/lib/checkstring.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,7 +21,7 @@
 #include "checkstring.h"
 
 #include "astutils.h"
-#include "errorlogger.h"
+#include "errortypes.h"
 #include "mathlib.h"
 #include "settings.h"
 #include "symboldatabase.h"
@@ -32,7 +32,6 @@
 #include <cstddef>
 #include <list>
 #include <vector>
-#include <stack>
 #include <utility>
 
 //---------------------------------------------------------------------------
@@ -43,24 +42,25 @@ namespace {
 }
 
 // CWE ids used:
-static const struct CWE CWE570(570U);   // Expression is Always False
-static const struct CWE CWE571(571U);   // Expression is Always True
-static const struct CWE CWE595(595U);   // Comparison of Object References Instead of Object Contents
-static const struct CWE CWE628(628U);   // Function Call with Incorrectly Specified Arguments
-static const struct CWE CWE665(665U);   // Improper Initialization
-static const struct CWE CWE758(758U);   // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior
+static const CWE CWE570(570U);   // Expression is Always False
+static const CWE CWE571(571U);   // Expression is Always True
+static const CWE CWE595(595U);   // Comparison of Object References Instead of Object Contents
+static const CWE CWE628(628U);   // Function Call with Incorrectly Specified Arguments
+static const CWE CWE665(665U);   // Improper Initialization
+static const CWE CWE758(758U);   // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior
 
 //---------------------------------------------------------------------------
 // Writing string literal is UB
 //---------------------------------------------------------------------------
 void CheckString::stringLiteralWrite()
 {
+    logChecker("CheckString::stringLiteralWrite");
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
             if (!tok->variable() || !tok->variable()->isPointer())
                 continue;
-            const Token *str = tok->getValueTokenMinStrSize();
+            const Token *str = tok->getValueTokenMinStrSize(*mSettings);
             if (!str)
                 continue;
             if (Token::Match(tok, "%var% [") && Token::simpleMatch(tok->linkAt(1), "] ="))
@@ -73,21 +73,21 @@ void CheckString::stringLiteralWrite()
 
 void CheckString::stringLiteralWriteError(const Token *tok, const Token *strValue)
 {
-    std::list<const Token *> callstack;
-    callstack.push_back(tok);
+    std::list<const Token*> callstack{ tok };
     if (strValue)
         callstack.push_back(strValue);
 
     std::string errmsg("Modifying string literal");
     if (strValue) {
-        std::string s = strValue->strValue();
-        if (s.size() > 15U)
-            s = s.substr(0,13) + "..";
-        errmsg += " \"" + s + "\"";
+        std::string s = strValue->str();
+        // 20 is an arbitrary value, the max string length shown in a warning message
+        if (s.size() > 20U)
+            s.replace(17, std::string::npos, "..\"");
+        errmsg += " " + s;
     }
     errmsg += " directly or indirectly is undefined behaviour.";
 
-    reportError(callstack, Severity::error, "stringLiteralWrite", errmsg, CWE758, false);
+    reportError(callstack, Severity::error, "stringLiteralWrite", errmsg, CWE758, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -96,11 +96,13 @@ void CheckString::stringLiteralWriteError(const Token *tok, const Token *strValu
 //---------------------------------------------------------------------------
 void CheckString::checkAlwaysTrueOrFalseStringCompare()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckString::checkAlwaysTrueOrFalseStringCompare"); // warning
+
     for (const Token* tok = mTokenizer->tokens(); tok; tok = tok->next()) {
-        if (tok->isName() && tok->strAt(1) == "(" && Token::Match(tok, "memcmp|strncmp|strcmp|stricmp|strverscmp|bcmp|strcmpi|strcasecmp|strncasecmp|strncasecmp_l|strcasecmp_l|wcsncasecmp|wcscasecmp|wmemcmp|wcscmp|wcscasecmp_l|wcsncasecmp_l|wcsncmp|_mbscmp|_memicmp|_memicmp_l|_stricmp|_wcsicmp|_mbsicmp|_stricmp_l|_wcsicmp_l|_mbsicmp_l")) {
+        if (tok->isName() && tok->strAt(1) == "(" && Token::Match(tok, "memcmp|strncmp|strcmp|stricmp|strverscmp|bcmp|strcmpi|strcasecmp|strncasecmp|strncasecmp_l|strcasecmp_l|wcsncasecmp|wcscasecmp|wmemcmp|wcscmp|wcscasecmp_l|wcsncasecmp_l|wcsncmp|_mbscmp|_mbscmp_l|_memicmp|_memicmp_l|_stricmp|_wcsicmp|wcsicmp|_mbsicmp|_stricmp_l|_wcsicmp_l|_mbsicmp_l")) {
             if (Token::Match(tok->tokAt(2), "%str% , %str% ,|)")) {
                 const std::string &str1 = tok->strAt(2);
                 const std::string &str2 = tok->strAt(4);
@@ -138,14 +140,14 @@ void CheckString::checkAlwaysTrueOrFalseStringCompare()
 
 void CheckString::alwaysTrueFalseStringCompareError(const Token *tok, const std::string& str1, const std::string& str2)
 {
-    const std::size_t stringLen = 10;
+    constexpr std::size_t stringLen = 10;
     const std::string string1 = (str1.size() < stringLen) ? str1 : (str1.substr(0, stringLen-2) + "..");
     const std::string string2 = (str2.size() < stringLen) ? str2 : (str2.substr(0, stringLen-2) + "..");
 
     reportError(tok, Severity::warning, "staticStringCompare",
                 "Unnecessary comparison of static strings.\n"
                 "The compared strings, '" + string1 + "' and '" + string2 + "', are always " + (str1==str2?"identical":"unequal") + ". "
-                "Therefore the comparison is unnecessary and looks suspicious.", (str1==str2)?CWE571:CWE570, false);
+                "Therefore the comparison is unnecessary and looks suspicious.", (str1==str2)?CWE571:CWE570, Certainty::normal);
 }
 
 void CheckString::alwaysTrueStringVariableCompareError(const Token *tok, const std::string& str1, const std::string& str2)
@@ -153,7 +155,7 @@ void CheckString::alwaysTrueStringVariableCompareError(const Token *tok, const s
     reportError(tok, Severity::warning, "stringCompare",
                 "Comparison of identical string variables.\n"
                 "The compared strings, '" + str1 + "' and '" + str2 + "', are identical. "
-                "This could be a logic bug.", CWE571, false);
+                "This could be a logic bug.", CWE571, Certainty::normal);
 }
 
 
@@ -163,9 +165,11 @@ void CheckString::alwaysTrueStringVariableCompareError(const Token *tok, const s
 //-----------------------------------------------------------------------------
 void CheckString::checkSuspiciousStringCompare()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckString::checkSuspiciousStringCompare"); // warning
+
     const SymbolDatabase* symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
@@ -181,40 +185,18 @@ void CheckString::checkSuspiciousStringCompare()
             else if (!Token::Match(litTok, "%char%|%num%|%str%"))
                 continue;
 
-            // Pointer addition?
-            if (varTok->str() == "+" && mTokenizer->isC()) {
-                const Token * const tokens[2] = { varTok->astOperand1(), varTok->astOperand2() };
-                for (const Token * t : tokens) {
-                    while (t && (t->str() == "." || t->str() == "::"))
-                        t = t->astOperand2();
-                    if (t && t->variable() && t->variable()->isPointer())
-                        varTok = t;
-                }
-            }
-
-            if (varTok->str() == "*") {
-                if (!mTokenizer->isC() || varTok->astOperand2() != nullptr || litTok->tokType() != Token::eString)
-                    continue;
-                varTok = varTok->astOperand1();
-            }
-
-            while (varTok && (varTok->str() == "." || varTok->str() == "::"))
-                varTok = varTok->astOperand2();
-            if (!varTok || !varTok->isName())
+            if (varTok->isLiteral())
                 continue;
 
-            const Variable *var = varTok->variable();
-
-            while (Token::Match(varTok->astParent(), "[.*]"))
-                varTok = varTok->astParent();
-            const std::string varname = varTok->expressionString();
+            const ValueType* varType = varTok->valueType();
+            if (varTok->isCpp() && (!varType || !varType->isIntegral()))
+                continue;
 
-            const bool ischar(litTok->tokType() == Token::eChar);
             if (litTok->tokType() == Token::eString) {
-                if (mTokenizer->isC() || (var && var->isArrayOrPointer()))
-                    suspiciousStringCompareError(tok, varname, litTok->isLong());
-            } else if (ischar && var && var->isPointer()) {
-                suspiciousStringCompareError_char(tok, varname);
+                if (varTok->isC() || (varType && varType->pointer))
+                    suspiciousStringCompareError(tok, varTok->expressionString(), litTok->isLong());
+            } else if (litTok->tokType() == Token::eChar && varType && varType->pointer) {
+                suspiciousStringCompareError_char(tok, varTok->expressionString());
             }
         }
     }
@@ -224,13 +206,13 @@ void CheckString::suspiciousStringCompareError(const Token* tok, const std::stri
 {
     const std::string cmpFunc = isLong ? "wcscmp" : "strcmp";
     reportError(tok, Severity::warning, "literalWithCharPtrCompare",
-                "$symbol:" + var + "\nString literal compared with variable '$symbol'. Did you intend to use " + cmpFunc + "() instead?", CWE595, false);
+                "$symbol:" + var + "\nString literal compared with variable '$symbol'. Did you intend to use " + cmpFunc + "() instead?", CWE595, Certainty::normal);
 }
 
 void CheckString::suspiciousStringCompareError_char(const Token* tok, const std::string& var)
 {
     reportError(tok, Severity::warning, "charLiteralWithCharPtrCompare",
-                "$symbol:" + var + "\nChar literal compared with pointer '$symbol'. Did you intend to dereference it?", CWE595, false);
+                "$symbol:" + var + "\nChar literal compared with pointer '$symbol'. Did you intend to dereference it?", CWE595, Certainty::normal);
 }
 
 
@@ -245,6 +227,7 @@ static bool isChar(const Variable* var)
 
 void CheckString::strPlusChar()
 {
+    logChecker("CheckString::strPlusChar");
     const SymbolDatabase* symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
@@ -265,7 +248,29 @@ void CheckString::strPlusCharError(const Token *tok)
         charType = tok->astOperand2()->variable()->typeStartToken()->str();
     else if (tok && tok->astOperand2() && tok->astOperand2()->tokType() == Token::eChar && tok->astOperand2()->isLong())
         charType = "wchar_t";
-    reportError(tok, Severity::error, "strPlusChar", "Unusual pointer arithmetic. A value of type '" + charType +"' is added to a string literal.", CWE665, false);
+    reportError(tok, Severity::error, "strPlusChar", "Unusual pointer arithmetic. A value of type '" + charType +"' is added to a string literal.", CWE665, Certainty::normal);
+}
+
+static bool isMacroUsage(const Token* tok)
+{
+    if (const Token* parent = tok->astParent()) {
+        while (parent && (parent->isCast() || parent->str() == "&&")) {
+            if (parent->isExpandedMacro())
+                return true;
+            parent = parent->astParent();
+        }
+        if (!parent)
+            return false;
+        if (parent->isExpandedMacro())
+            return true;
+        if (parent->isUnaryOp("!") || parent->isComparisonOp()) {
+            int argn{};
+            const Token* ftok = getTokenArgumentFunction(parent, argn);
+            if (ftok && !ftok->function())
+                return true;
+        }
+    }
+    return false;
 }
 
 //---------------------------------------------------------------------------
@@ -274,20 +279,22 @@ void CheckString::strPlusCharError(const Token *tok)
 //---------------------------------------------------------------------------
 void CheckString::checkIncorrectStringCompare()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckString::checkIncorrectStringCompare"); // warning
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
             // skip "assert(str && ..)" and "assert(.. && str)"
-            if ((endsWith(tok->str(), "assert", 6) || endsWith(tok->str(), "ASSERT", 6)) &&
+            if ((endsWith(tok->str(), "assert") || endsWith(tok->str(), "ASSERT")) &&
                 Token::Match(tok, "%name% (") &&
-                (Token::Match(tok->tokAt(2), "%str% &&") || Token::Match(tok->next()->link()->tokAt(-2), "&& %str% )")))
-                tok = tok->next()->link();
+                (Token::Match(tok->tokAt(2), "%str% &&") || Token::Match(tok->linkAt(1)->tokAt(-2), "&& %str% )")))
+                tok = tok->linkAt(1);
 
             if (Token::simpleMatch(tok, ". substr (") && Token::Match(tok->tokAt(3)->nextArgument(), "%num% )")) {
-                const MathLib::biguint clen = MathLib::toULongNumber(tok->linkAt(2)->strAt(-1));
+                const MathLib::biguint clen = MathLib::toBigUNumber(tok->linkAt(2)->tokAt(-1));
                 const Token* begin = tok->previous();
                 for (;;) { // Find start of statement
                     while (begin->link() && Token::Match(begin, "]|)|>"))
@@ -310,30 +317,29 @@ void CheckString::checkIncorrectStringCompare()
                         incorrectStringCompareError(tok->next(), "substr", end->strAt(1));
                     }
                 }
-            } else if (Token::Match(tok, "&&|%oror%|( %str%|%char% &&|%oror%|)") && !Token::Match(tok, "( %str%|%char% )")) {
-                incorrectStringBooleanError(tok->next(), tok->strAt(1));
-            } else if (Token::Match(tok, "if|while ( %str%|%char% )") && !tok->tokAt(2)->getValue(0)) {
-                incorrectStringBooleanError(tok->tokAt(2), tok->strAt(2));
-            } else if (tok->str() == "?" && Token::Match(tok->astOperand1(), "%str%|%char%"))
-                incorrectStringBooleanError(tok->astOperand1(), tok->astOperand1()->str());
+            } else if (Token::Match(tok, "%str%|%char%") &&
+                       !Token::Match(tok->next(), "%name%") &&
+                       isUsedAsBool(tok, *mSettings) &&
+                       !isMacroUsage(tok))
+                incorrectStringBooleanError(tok, tok->str());
         }
     }
 }
 
 void CheckString::incorrectStringCompareError(const Token *tok, const std::string& func, const std::string &string)
 {
-    reportError(tok, Severity::warning, "incorrectStringCompare", "$symbol:" + func + "\nString literal " + string + " doesn't match length argument for $symbol().", CWE570, false);
+    reportError(tok, Severity::warning, "incorrectStringCompare", "$symbol:" + func + "\nString literal " + string + " doesn't match length argument for $symbol().", CWE570, Certainty::normal);
 }
 
 void CheckString::incorrectStringBooleanError(const Token *tok, const std::string& string)
 {
-    const bool charLiteral = string[0] == '\'';
+    const bool charLiteral = isCharLiteral(string);
     const std::string literalType = charLiteral ? "char" : "string";
-    const std::string result = (string == "\'\\0\'") ? "false" : "true";
+    const std::string result = bool_to_string(getCharLiteral(string) != "\\0");
     reportError(tok,
                 Severity::warning,
                 charLiteral ? "incorrectCharBooleanError" : "incorrectStringBooleanError",
-                "Conversion of " + literalType + " literal " + string + " to bool always evaluates to " + result + '.', CWE571, false);
+                "Conversion of " + literalType + " literal " + string + " to bool always evaluates to " + result + '.', CWE571, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -342,9 +348,11 @@ void CheckString::incorrectStringBooleanError(const Token *tok, const std::strin
 //---------------------------------------------------------------------------
 void CheckString::overlappingStrcmp()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckString::overlappingStrcmp"); // warning
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
@@ -352,37 +360,32 @@ void CheckString::overlappingStrcmp()
                 continue;
             std::list<const Token *> equals0;
             std::list<const Token *> notEquals0;
-            std::stack<const Token *> tokens;
-            tokens.push(tok);
-            while (!tokens.empty()) {
-                const Token * const t = tokens.top();
-                tokens.pop();
+            visitAstNodes(tok, [&](const Token * t) {
                 if (!t)
-                    continue;
+                    return ChildrenToVisit::none;
                 if (t->str() == "||") {
-                    tokens.push(t->astOperand1());
-                    tokens.push(t->astOperand2());
-                    continue;
+                    return ChildrenToVisit::op1_and_op2;
                 }
                 if (t->str() == "==") {
                     if (Token::simpleMatch(t->astOperand1(), "(") && Token::simpleMatch(t->astOperand2(), "0"))
                         equals0.push_back(t->astOperand1());
                     else if (Token::simpleMatch(t->astOperand2(), "(") && Token::simpleMatch(t->astOperand1(), "0"))
                         equals0.push_back(t->astOperand2());
-                    continue;
+                    return ChildrenToVisit::none;
                 }
                 if (t->str() == "!=") {
                     if (Token::simpleMatch(t->astOperand1(), "(") && Token::simpleMatch(t->astOperand2(), "0"))
                         notEquals0.push_back(t->astOperand1());
                     else if (Token::simpleMatch(t->astOperand2(), "(") && Token::simpleMatch(t->astOperand1(), "0"))
                         notEquals0.push_back(t->astOperand2());
-                    continue;
+                    return ChildrenToVisit::none;
                 }
                 if (t->str() == "!" && Token::simpleMatch(t->astOperand1(), "("))
                     equals0.push_back(t->astOperand1());
                 else if (t->str() == "(")
                     notEquals0.push_back(t);
-            }
+                return ChildrenToVisit::none;
+            });
 
             for (const Token *eq0 : equals0) {
                 for (const Token * ne0 : notEquals0) {
@@ -397,7 +400,7 @@ void CheckString::overlappingStrcmp()
                     if (args1[1]->isLiteral() &&
                         args2[1]->isLiteral() &&
                         args1[1]->str() != args2[1]->str() &&
-                        isSameExpression(mTokenizer->isCPP(), true, args1[0], args2[0], mSettings->library, true, false))
+                        isSameExpression(true, args1[0], args2[0], *mSettings, true, false))
                         overlappingStrcmpError(eq0, ne0);
                 }
             }
@@ -424,6 +427,8 @@ void CheckString::overlappingStrcmpError(const Token *eq0, const Token *ne0)
 //---------------------------------------------------------------------------
 void CheckString::sprintfOverlappingData()
 {
+    logChecker("CheckString::sprintfOverlappingData");
+
     const SymbolDatabase* symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope * scope : symbolDatabase->functionScopes) {
         for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
@@ -443,11 +448,10 @@ void CheckString::sprintfOverlappingData()
                 while (arg->isCast())
                     arg = arg->astOperand2() ? arg->astOperand2() : arg->astOperand1();
 
-                const bool same = isSameExpression(mTokenizer->isCPP(),
-                                                   false,
+                const bool same = isSameExpression(false,
                                                    dest,
                                                    arg,
-                                                   mSettings->library,
+                                                   *mSettings,
                                                    true,
                                                    false);
                 if (same) {
@@ -469,5 +473,35 @@ void CheckString::sprintfOverlappingDataError(const Token *funcTok, const Token
                 func + "(). The origin and destination buffers overlap. Quote from glibc (C-library) "
                 "documentation (http://www.gnu.org/software/libc/manual/html_mono/libc.html#Formatted-Output-Functions): "
                 "\"If copying takes place between objects that overlap as a result of a call "
-                "to sprintf() or snprintf(), the results are undefined.\"", CWE628, false);
+                "to sprintf() or snprintf(), the results are undefined.\"", CWE628, Certainty::normal);
+}
+
+void CheckString::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    CheckString checkString(&tokenizer, &tokenizer.getSettings(), errorLogger);
+
+    // Checks
+    checkString.strPlusChar();
+    checkString.checkSuspiciousStringCompare();
+    checkString.stringLiteralWrite();
+    checkString.overlappingStrcmp();
+    checkString.checkIncorrectStringCompare();
+    checkString.sprintfOverlappingData();
+    checkString.checkAlwaysTrueOrFalseStringCompare();
+}
+
+void CheckString::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const
+{
+    CheckString c(nullptr, settings, errorLogger);
+    c.stringLiteralWriteError(nullptr, nullptr);
+    c.sprintfOverlappingDataError(nullptr, nullptr, "varname");
+    c.strPlusCharError(nullptr);
+    c.incorrectStringCompareError(nullptr, "substr", "\"Hello World\"");
+    c.suspiciousStringCompareError(nullptr, "foo", false);
+    c.suspiciousStringCompareError_char(nullptr, "foo");
+    c.incorrectStringBooleanError(nullptr, "\"Hello World\"");
+    c.incorrectStringBooleanError(nullptr, "\'x\'");
+    c.alwaysTrueFalseStringCompareError(nullptr, "str1", "str2");
+    c.alwaysTrueStringVariableCompareError(nullptr, "varname1", "varname2");
+    c.overlappingStrcmpError(nullptr, nullptr);
 }
diff --git a/lib/checkstring.h b/lib/checkstring.h
index 86841e2e650..76002f8ed3d 100644
--- a/lib/checkstring.h
+++ b/lib/checkstring.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -41,27 +41,15 @@ class Tokenizer;
 class CPPCHECKLIB CheckString : public Check {
 public:
     /** @brief This constructor is used when registering the CheckClass */
-    CheckString() : Check(myName()) {
-    }
+    CheckString() : Check(myName()) {}
 
+private:
     /** @brief This constructor is used when running checks. */
     CheckString(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger) {}
 
     /** @brief Run checks against the normal token list */
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        CheckString checkString(tokenizer, settings, errorLogger);
-
-        // Checks
-        checkString.strPlusChar();
-        checkString.checkSuspiciousStringCompare();
-        checkString.stringLiteralWrite();
-        checkString.overlappingStrcmp();
-        checkString.checkIncorrectStringCompare();
-        checkString.sprintfOverlappingData();
-        checkString.checkAlwaysTrueOrFalseStringCompare();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     /** @brief undefined behaviour, writing string literal */
     void stringLiteralWrite();
@@ -84,7 +72,6 @@ class CPPCHECKLIB CheckString : public Check {
     /** @brief %Check for overlapping source and destination passed to sprintf() */
     void sprintfOverlappingData();
 
-private:
     void stringLiteralWriteError(const Token *tok, const Token *strValue);
     void sprintfOverlappingDataError(const Token *funcTok, const Token *tok, const std::string &varname);
     void strPlusCharError(const Token *tok);
@@ -96,27 +83,13 @@ class CPPCHECKLIB CheckString : public Check {
     void suspiciousStringCompareError_char(const Token* tok, const std::string& var);
     void overlappingStrcmpError(const Token* eq0, const Token *ne0);
 
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        CheckString c(nullptr, settings, errorLogger);
-
-        c.stringLiteralWriteError(nullptr, nullptr);
-        c.sprintfOverlappingDataError(nullptr, nullptr, "varname");
-        c.strPlusCharError(nullptr);
-        c.incorrectStringCompareError(nullptr, "substr", "\"Hello World\"");
-        c.suspiciousStringCompareError(nullptr, "foo", false);
-        c.suspiciousStringCompareError_char(nullptr, "foo");
-        c.incorrectStringBooleanError(nullptr, "\"Hello World\"");
-        c.incorrectStringBooleanError(nullptr, "\'x\'");
-        c.alwaysTrueFalseStringCompareError(nullptr, "str1", "str2");
-        c.alwaysTrueStringVariableCompareError(nullptr, "varname1", "varname2");
-        c.overlappingStrcmpError(nullptr, nullptr);
-    }
+    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const override;
 
     static std::string myName() {
         return "String";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Detect misusage of C-style strings:\n"
                "- overlapping buffers passed to sprintf as source and destination\n"
                "- incorrect length arguments for 'substr' and 'strncmp'\n"
diff --git a/lib/checktype.cpp b/lib/checktype.cpp
index 0d55bbd5283..3f42bf075ef 100644
--- a/lib/checktype.cpp
+++ b/lib/checktype.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,18 +20,28 @@
 //---------------------------------------------------------------------------
 #include "checktype.h"
 
-#include "errorlogger.h"
+#include "astutils.h"
+#include "errortypes.h"
 #include "mathlib.h"
 #include "platform.h"
 #include "settings.h"
+#include "standards.h"
 #include "symboldatabase.h"
 #include "token.h"
 #include "tokenize.h"
+#include "valueflow.h"
+#include "vfvalue.h"
 
+#include <algorithm>
+#include <cmath>
 #include <cstddef>
+#include <cstdint>
+#include <iterator>
 #include <list>
-#include <ostream>
-#include <stack>
+#include <sstream>
+#include <utility>
+#include <vector>
+
 //---------------------------------------------------------------------------
 
 // Register this check class (by creating a static instance of it)
@@ -45,23 +55,27 @@ namespace {
 //
 
 // CWE ids used:
-static const struct CWE CWE195(195U);   // Signed to Unsigned Conversion Error
-static const struct CWE CWE197(197U);   // Numeric Truncation Error
-static const struct CWE CWE758(758U);   // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior
-static const struct CWE CWE190(190U);   // Integer Overflow or Wraparound
+static const CWE CWE195(195U);   // Signed to Unsigned Conversion Error
+static const CWE CWE197(197U);   // Numeric Truncation Error
+static const CWE CWE758(758U);   // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior
+static const CWE CWE190(190U);   // Integer Overflow or Wraparound
 
 
 void CheckType::checkTooBigBitwiseShift()
 {
     // unknown sizeof(int) => can't run this checker
-    if (mSettings->platformType == Settings::Unspecified)
+    if (mSettings->platform.type == Platform::Type::Unspecified)
         return;
 
+    logChecker("CheckType::checkTooBigBitwiseShift"); // platform
+
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
         // C++ and macro: OUT(x<<y)
-        if (mTokenizer->isCPP() && Token::Match(tok, "[;{}] %name% (") && Token::simpleMatch(tok->linkAt(2), ") ;") && tok->next()->isUpperCaseName() && !tok->next()->function())
+        if (tok->isCpp() && Token::Match(tok, "[;{}] %name% (") && Token::simpleMatch(tok->linkAt(2), ") ;") && tok->next()->isUpperCaseName() && !tok->next()->function())
             tok = tok->linkAt(2);
 
+        tok = skipUnreachableBranch(tok);
+
         if (!tok->astOperand1() || !tok->astOperand2())
             continue;
 
@@ -75,26 +89,26 @@ void CheckType::checkTooBigBitwiseShift()
         // C11 Standard, section 6.5.7 Bitwise shift operators, states:
         //   The integer promotions are performed on each of the operands.
         //   The type of the result is that of the promoted left operand.
-        int lhsbits;
+        std::uint8_t lhsbits;
         if ((lhstype->type == ValueType::Type::CHAR) ||
             (lhstype->type == ValueType::Type::SHORT) ||
             (lhstype->type == ValueType::Type::WCHAR_T) ||
             (lhstype->type == ValueType::Type::BOOL) ||
             (lhstype->type == ValueType::Type::INT))
-            lhsbits = mSettings->int_bit;
+            lhsbits = mSettings->platform.int_bit;
         else if (lhstype->type == ValueType::Type::LONG)
-            lhsbits = mSettings->long_bit;
+            lhsbits = mSettings->platform.long_bit;
         else if (lhstype->type == ValueType::Type::LONGLONG)
-            lhsbits = mSettings->long_long_bit;
+            lhsbits = mSettings->platform.long_long_bit;
         else
             continue;
 
         // Get biggest rhs value. preferably a value which doesn't have 'condition'.
-        const ValueFlow::Value * value = tok->astOperand2()->getValueGE(lhsbits, mSettings);
+        const ValueFlow::Value * value = tok->astOperand2()->getValueGE(lhsbits, *mSettings);
         if (value && mSettings->isEnabled(value, false))
             tooBigBitwiseShiftError(tok, lhsbits, *value);
         else if (lhstype->sign == ValueType::Sign::SIGNED) {
-            value = tok->astOperand2()->getValueGE(lhsbits-1, mSettings);
+            value = tok->astOperand2()->getValueGE(lhsbits-1, *mSettings);
             if (value && mSettings->isEnabled(value, false))
                 tooBigSignedBitwiseShiftError(tok, lhsbits, *value);
         }
@@ -103,51 +117,52 @@ void CheckType::checkTooBigBitwiseShift()
 
 void CheckType::tooBigBitwiseShiftError(const Token *tok, int lhsbits, const ValueFlow::Value &rhsbits)
 {
-    const char id[] = "shiftTooManyBits";
+    constexpr char id[] = "shiftTooManyBits";
 
     if (!tok) {
-        reportError(tok, Severity::error, id, "Shifting 32-bit value by 40 bits is undefined behaviour", CWE758, false);
+        reportError(tok, Severity::error, id, "Shifting 32-bit value by 40 bits is undefined behaviour", CWE758, Certainty::normal);
         return;
     }
 
-    const ErrorPath errorPath = getErrorPath(tok, &rhsbits, "Shift");
+    ErrorPath errorPath = getErrorPath(tok, &rhsbits, "Shift");
 
     std::ostringstream errmsg;
     errmsg << "Shifting " << lhsbits << "-bit value by " << rhsbits.intvalue << " bits is undefined behaviour";
     if (rhsbits.condition)
         errmsg << ". See condition at line " << rhsbits.condition->linenr() << ".";
 
-    reportError(errorPath, rhsbits.errorSeverity() ? Severity::error : Severity::warning, id, errmsg.str(), CWE758, rhsbits.isInconclusive());
+    reportError(std::move(errorPath), rhsbits.errorSeverity() ? Severity::error : Severity::warning, id, errmsg.str(), CWE758, rhsbits.isInconclusive() ? Certainty::inconclusive : Certainty::normal);
 }
 
 void CheckType::tooBigSignedBitwiseShiftError(const Token *tok, int lhsbits, const ValueFlow::Value &rhsbits)
 {
-    const char id[] = "shiftTooManyBitsSigned";
+    constexpr char id[] = "shiftTooManyBitsSigned";
 
-    const bool cpp14 = mSettings->standards.cpp >= Standards::CPP14;
+    const bool cpp14 = ((tok && tok->isCpp()) || (mTokenizer && mTokenizer->isCPP())) && (mSettings->standards.cpp >= Standards::CPP14);
 
     std::string behaviour = "undefined";
     if (cpp14)
         behaviour = "implementation-defined";
     if (!tok) {
-        reportError(tok, Severity::error, id, "Shifting signed 32-bit value by 31 bits is " + behaviour + " behaviour", CWE758, false);
+        reportError(tok, Severity::error, id, "Shifting signed 32-bit value by 31 bits is " + behaviour + " behaviour", CWE758, Certainty::normal);
         return;
     }
 
-    const ErrorPath errorPath = getErrorPath(tok, &rhsbits, "Shift");
+
+    Severity severity = rhsbits.errorSeverity() ? Severity::error : Severity::warning;
+    if (cpp14)
+        severity = Severity::portability;
+
+    if ((severity == Severity::portability) && !mSettings->severity.isEnabled(Severity::portability))
+        return;
+    ErrorPath errorPath = getErrorPath(tok, &rhsbits, "Shift");
 
     std::ostringstream errmsg;
     errmsg << "Shifting signed " << lhsbits << "-bit value by " << rhsbits.intvalue << " bits is " + behaviour + " behaviour";
     if (rhsbits.condition)
         errmsg << ". See condition at line " << rhsbits.condition->linenr() << ".";
 
-    Severity::SeverityType severity = rhsbits.errorSeverity() ? Severity::error : Severity::warning;
-    if (cpp14)
-        severity = Severity::portability;
-
-    if ((severity == Severity::portability) && !mSettings->isEnabled(Settings::PORTABILITY))
-        return;
-    reportError(errorPath, severity, id, errmsg.str(), CWE758, rhsbits.isInconclusive());
+    reportError(std::move(errorPath), severity, id, errmsg.str(), CWE758, rhsbits.isInconclusive() ? Certainty::inconclusive : Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -157,9 +172,11 @@ void CheckType::tooBigSignedBitwiseShiftError(const Token *tok, int lhsbits, con
 void CheckType::checkIntegerOverflow()
 {
     // unknown sizeof(int) => can't run this checker
-    if (mSettings->platformType == Settings::Unspecified || mSettings->int_bit >= MathLib::bigint_bits)
+    if (mSettings->platform.type == Platform::Type::Unspecified || mSettings->platform.int_bit >= MathLib::bigint_bits)
         return;
 
+    logChecker("CheckType::checkIntegerOverflow"); // platform
+
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
         if (!tok->isArithmeticalOp())
             continue;
@@ -171,11 +188,11 @@ void CheckType::checkIntegerOverflow()
 
         unsigned int bits;
         if (vt->type == ValueType::Type::INT)
-            bits = mSettings->int_bit;
+            bits = mSettings->platform.int_bit;
         else if (vt->type == ValueType::Type::LONG)
-            bits = mSettings->long_bit;
+            bits = mSettings->platform.long_bit;
         else if (vt->type == ValueType::Type::LONGLONG)
-            bits = mSettings->long_long_bit;
+            bits = mSettings->platform.long_long_bit;
         else
             continue;
 
@@ -183,43 +200,47 @@ void CheckType::checkIntegerOverflow()
             continue;
 
         // max value according to platform settings.
-        const MathLib::bigint maxvalue = (((MathLib::bigint)1) << (bits - 1)) - 1;
+        const MathLib::bigint maxvalue = (static_cast<MathLib::biguint>(1) << (bits - 1)) - 1;
 
         // is there a overflow result value
-        const ValueFlow::Value *value = tok->getValueGE(maxvalue + 1, mSettings);
-        if (!value)
-            value = tok->getValueLE(-maxvalue - 2, mSettings);
+        bool isOverflow = true;
+        const ValueFlow::Value *value = tok->getValueGE(maxvalue + 1, *mSettings);
+        if (!value) {
+            value = tok->getValueLE(-maxvalue - 2, *mSettings);
+            isOverflow = false;
+        }
         if (!value || !mSettings->isEnabled(value,false))
             continue;
 
         // For left shift, it's common practice to shift into the sign bit
-        if (tok->str() == "<<" && value->intvalue > 0 && value->intvalue < (((MathLib::bigint)1) << bits))
+        if (tok->str() == "<<" && value->intvalue > 0 && value->intvalue < (static_cast<MathLib::biguint>(1) << bits))
             continue;
 
-        integerOverflowError(tok, *value);
+        integerOverflowError(tok, *value, isOverflow);
     }
 }
 
-void CheckType::integerOverflowError(const Token *tok, const ValueFlow::Value &value)
+void CheckType::integerOverflowError(const Token *tok, const ValueFlow::Value &value, bool isOverflow)
 {
     const std::string expr(tok ? tok->expressionString() : "");
+    const std::string type = isOverflow ? "overflow" : "underflow";
 
     std::string msg;
     if (value.condition)
         msg = ValueFlow::eitherTheConditionIsRedundant(value.condition) +
-              " or there is signed integer overflow for expression '" + expr + "'.";
+              " or there is signed integer " + type + " for expression '" + expr + "'.";
     else
-        msg = "Signed integer overflow for expression '" + expr + "'.";
+        msg = "Signed integer " + type + " for expression '" + expr + "'.";
 
     if (value.safe)
         msg = "Safe checks: " + msg;
 
-    reportError(getErrorPath(tok, &value, "Integer overflow"),
+    reportError(getErrorPath(tok, &value, "Integer " + type),
                 value.errorSeverity() ? Severity::error : Severity::warning,
                 getMessageId(value, "integerOverflow").c_str(),
                 msg,
                 CWE190,
-                value.isInconclusive());
+                value.isInconclusive() ? Certainty::inconclusive : Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -228,9 +249,11 @@ void CheckType::integerOverflowError(const Token *tok, const ValueFlow::Value &v
 
 void CheckType::checkSignConversion()
 {
-    if (!mSettings->isEnabled(Settings::WARNING))
+    if (!mSettings->severity.isEnabled(Severity::warning))
         return;
 
+    logChecker("CheckType::checkSignConversion"); // warning
+
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
         if (!tok->isArithmeticalOp() || Token::Match(tok,"+|-"))
             continue;
@@ -240,15 +263,14 @@ void CheckType::checkSignConversion()
             continue;
 
         // Check if an operand can be negative..
-        std::stack<const Token *> tokens;
-        tokens.push(tok->astOperand1());
-        tokens.push(tok->astOperand2());
-        while (!tokens.empty()) {
-            const Token *tok1 = tokens.top();
-            tokens.pop();
+        const Token * astOperands[] = { tok->astOperand1(), tok->astOperand2() };
+        for (const Token * tok1 : astOperands) {
             if (!tok1)
                 continue;
-            const ValueFlow::Value *negativeValue = tok1->getValueLE(-1,mSettings);
+            const ValueFlow::Value* negativeValue =
+                ValueFlow::findValue(tok1->values(), *mSettings, [&](const ValueFlow::Value& v) {
+                return !v.isImpossible() && v.isIntValue() && (v.intvalue <= -1 || v.wideintvalue <= -1);
+            });
             if (!negativeValue)
                 continue;
             if (tok1->valueType() && tok1->valueType()->sign != ValueType::Sign::UNSIGNED)
@@ -270,15 +292,15 @@ void CheckType::signConversionError(const Token *tok, const ValueFlow::Value *ne
         msg << "Expression '" << expr << "' can have a negative value. That is converted to an unsigned value and used in an unsigned calculation.";
 
     if (!negativeValue)
-        reportError(tok, Severity::warning, "signConversion", msg.str(), CWE195, false);
+        reportError(tok, Severity::warning, "signConversion", msg.str(), CWE195, Certainty::normal);
     else {
-        const ErrorPath &errorPath = getErrorPath(tok,negativeValue,"Negative value is converted to an unsigned value");
-        reportError(errorPath,
+        ErrorPath errorPath = getErrorPath(tok,negativeValue,"Negative value is converted to an unsigned value");
+        reportError(std::move(errorPath),
                     Severity::warning,
                     Check::getMessageId(*negativeValue, "signConversion").c_str(),
                     msg.str(),
                     CWE195,
-                    negativeValue->isInconclusive());
+                    negativeValue->isInconclusive() ? Certainty::inconclusive : Certainty::normal);
     }
 }
 
@@ -286,20 +308,44 @@ void CheckType::signConversionError(const Token *tok, const ValueFlow::Value *ne
 //---------------------------------------------------------------------------
 // Checking for long cast of int result   const long x = var1 * var2;
 //---------------------------------------------------------------------------
+static bool checkTypeCombination(ValueType src, ValueType tgt, const Settings& settings)
+{
+    static const std::pair<ValueType::Type, ValueType::Type> typeCombinations[] = {
+        { ValueType::Type::INT, ValueType::Type::LONG },
+        { ValueType::Type::INT, ValueType::Type::LONGLONG },
+        { ValueType::Type::LONG, ValueType::Type::LONGLONG },
+        { ValueType::Type::FLOAT, ValueType::Type::DOUBLE },
+        { ValueType::Type::FLOAT, ValueType::Type::LONGDOUBLE },
+        { ValueType::Type::DOUBLE, ValueType::Type::LONGDOUBLE },
+    };
+
+    src.reference = Reference::None;
+    tgt.reference = Reference::None;
+
+    const std::size_t sizeSrc = src.getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer);
+    const std::size_t sizeTgt = tgt.getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer);
+    if (!(sizeSrc > 0 && sizeTgt > 0 && sizeSrc < sizeTgt))
+        return false;
+
+    return std::any_of(std::begin(typeCombinations), std::end(typeCombinations), [&](const std::pair<ValueType::Type, ValueType::Type>& p) {
+        return src.type == p.first && tgt.type == p.second;
+    });
+}
 
 void CheckType::checkLongCast()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("truncLongCastAssignment"))
         return;
 
+    logChecker("CheckType::checkLongCast"); // style
+
     // Assignments..
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
-        if (tok->str() != "=" || !Token::Match(tok->astOperand2(), "*|<<"))
+        if (tok->str() != "=" || !Token::Match(tok->astOperand2(), "*|<<") || tok->astOperand2()->isUnaryOp("*"))
             continue;
 
-        if (tok->astOperand2()->hasKnownIntValue()) {
-            const ValueFlow::Value &v = tok->astOperand2()->values().front();
-            if (mSettings->isIntValue(v.intvalue))
+        if (const ValueFlow::Value* v = tok->astOperand2()->getKnownValue(ValueFlow::Value::ValueType::INT)) {
+            if (mSettings->platform.isIntValue(v->intvalue))
                 continue;
         }
 
@@ -308,16 +354,15 @@ void CheckType::checkLongCast()
 
         if (!lhstype || !rhstype)
             continue;
+        if (!checkTypeCombination(*rhstype, *lhstype, *mSettings))
+            continue;
 
         // assign int result to long/longlong const nonpointer?
-        if (rhstype->type == ValueType::Type::INT &&
-            rhstype->pointer == 0U &&
+        if (rhstype->pointer == 0U &&
             rhstype->originalTypeName.empty() &&
-            (lhstype->type == ValueType::Type::LONG || lhstype->type == ValueType::Type::LONGLONG) &&
             lhstype->pointer == 0U &&
-            lhstype->constness == 1U &&
             lhstype->originalTypeName.empty())
-            longCastAssignError(tok);
+            longCastAssignError(tok, rhstype, lhstype);
     }
 
     // Return..
@@ -326,16 +371,9 @@ void CheckType::checkLongCast()
 
         // function must return long data
         const Token * def = scope->classDef;
-        bool islong = false;
-        while (Token::Match(def, "%type%|::")) {
-            if (def->str() == "long" && def->originalName().empty()) {
-                islong = true;
-                break;
-            }
-            def = def->previous();
-        }
-        if (!islong)
+        if (!Token::Match(def, "%name% (") || !def->next()->valueType())
             continue;
+        const ValueType* retVt = def->next()->valueType();
 
         // return statements
         const Token *ret = nullptr;
@@ -343,8 +381,14 @@ void CheckType::checkLongCast()
             if (tok->str() == "return") {
                 if (Token::Match(tok->astOperand1(), "<<|*")) {
                     const ValueType *type = tok->astOperand1()->valueType();
-                    if (type && type->type == ValueType::Type::INT && type->pointer == 0U && type->originalTypeName.empty())
-                        ret = tok;
+                    if (type && checkTypeCombination(*type, *retVt, *mSettings) &&
+                        type->pointer == 0U &&
+                        type->originalTypeName.empty()) {
+                        if (!tok->astOperand1()->hasKnownIntValue()) {
+                            ret = tok;
+                        } else if (!mSettings->platform.isIntValue(tok->astOperand1()->getKnownIntValue()))
+                            ret = tok;
+                    }
                 }
                 // All return statements must have problem otherwise no warning
                 if (ret != tok) {
@@ -355,26 +399,41 @@ void CheckType::checkLongCast()
         }
 
         if (ret)
-            longCastReturnError(ret);
+            longCastReturnError(ret, ret->astOperand1()->valueType(), retVt);
     }
 }
 
-void CheckType::longCastAssignError(const Token *tok)
+static void makeBaseTypeString(std::string& typeStr)
 {
+    const auto pos = typeStr.find("signed");
+    if (pos != std::string::npos)
+        typeStr.erase(typeStr.begin(), typeStr.begin() + pos + 6 + 1);
+}
+
+void CheckType::longCastAssignError(const Token *tok, const ValueType* src, const ValueType* tgt)
+{
+    std::string srcStr = src ? src->str() : "int";
+    makeBaseTypeString(srcStr);
+    std::string tgtStr = tgt ? tgt->str() : "long";
+    makeBaseTypeString(tgtStr);
     reportError(tok,
                 Severity::style,
                 "truncLongCastAssignment",
-                "int result is assigned to long variable. If the variable is long to avoid loss of information, then you have loss of information.\n"
-                "int result is assigned to long variable. If the variable is long to avoid loss of information, then there is loss of information. To avoid loss of information you must cast a calculation operand to long, for example 'l = a * b;' => 'l = (long)a * b;'.", CWE197, false);
+                srcStr + " result is assigned to " + tgtStr + " variable. If the variable is " + tgtStr + " to avoid loss of information, then you have loss of information.\n" +
+                srcStr + " result is assigned to " + tgtStr + " variable. If the variable is " + tgtStr + " to avoid loss of information, then there is loss of information. To avoid loss of information you must cast a calculation operand to " + tgtStr + ", for example 'l = a * b;' => 'l = (" + tgtStr + ")a * b;'.", CWE197, Certainty::normal);
 }
 
-void CheckType::longCastReturnError(const Token *tok)
+void CheckType::longCastReturnError(const Token *tok, const ValueType* src, const ValueType* tgt)
 {
+    std::string srcStr = src ? src->str() : "int";
+    makeBaseTypeString(srcStr);
+    std::string tgtStr = tgt ? tgt->str() : "long";
+    makeBaseTypeString(tgtStr);
     reportError(tok,
                 Severity::style,
                 "truncLongCastReturn",
-                "int result is returned as long value. If the return value is long to avoid loss of information, then you have loss of information.\n"
-                "int result is returned as long value. If the return value is long to avoid loss of information, then there is loss of information. To avoid loss of information you must cast a calculation operand to long, for example 'return a*b;' => 'return (long)a*b'.", CWE197, false);
+                srcStr +" result is returned as " + tgtStr + " value. If the return value is " + tgtStr + " to avoid loss of information, then you have loss of information.\n" +
+                srcStr +" result is returned as " + tgtStr + " value. If the return value is " + tgtStr + " to avoid loss of information, then there is loss of information. To avoid loss of information you must cast a calculation operand to long, for example 'return a*b;' => 'return (long)a*b'.", CWE197, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -383,41 +442,45 @@ void CheckType::longCastReturnError(const Token *tok)
 
 void CheckType::checkFloatToIntegerOverflow()
 {
+    logChecker("CheckType::checkFloatToIntegerOverflow");
+
     for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
         const ValueType *vtint, *vtfloat;
-        const std::list<ValueFlow::Value> *floatValues;
 
         // Explicit cast
         if (Token::Match(tok, "( %name%") && tok->astOperand1() && !tok->astOperand2()) {
+            if (isUnreachableOperand(tok))
+                continue;
             vtint = tok->valueType();
             vtfloat = tok->astOperand1()->valueType();
-            floatValues = &tok->astOperand1()->values();
-            checkFloatToIntegerOverflow(tok, vtint, vtfloat, floatValues);
+            checkFloatToIntegerOverflow(tok, vtint, vtfloat, tok->astOperand1()->values());
         }
 
         // Assignment
         else if (tok->str() == "=" && tok->astOperand1() && tok->astOperand2()) {
+            if (isUnreachableOperand(tok))
+                continue;
             vtint = tok->astOperand1()->valueType();
             vtfloat = tok->astOperand2()->valueType();
-            floatValues = &tok->astOperand2()->values();
-            checkFloatToIntegerOverflow(tok, vtint, vtfloat, floatValues);
+            checkFloatToIntegerOverflow(tok, vtint, vtfloat, tok->astOperand2()->values());
         }
 
         else if (tok->str() == "return" && tok->astOperand1() && tok->astOperand1()->valueType() && tok->astOperand1()->valueType()->isFloat()) {
+            if (isUnreachableOperand(tok))
+                continue;
             const Scope *scope = tok->scope();
-            while (scope && scope->type != Scope::ScopeType::eLambda && scope->type != Scope::ScopeType::eFunction)
+            while (scope && scope->type != ScopeType::eLambda && scope->type != ScopeType::eFunction)
                 scope = scope->nestedIn;
-            if (scope && scope->type == Scope::ScopeType::eFunction && scope->function && scope->function->retDef) {
-                const ValueType &valueType = ValueType::parseDecl(scope->function->retDef, mSettings);
+            if (scope && scope->type == ScopeType::eFunction && scope->function && scope->function->retDef) {
+                const ValueType &valueType = ValueType::parseDecl(scope->function->retDef, *mSettings);
                 vtfloat = tok->astOperand1()->valueType();
-                floatValues = &tok->astOperand1()->values();
-                checkFloatToIntegerOverflow(tok, &valueType, vtfloat, floatValues);
+                checkFloatToIntegerOverflow(tok, &valueType, vtfloat, tok->astOperand1()->values());
             }
         }
     }
 }
 
-void CheckType::checkFloatToIntegerOverflow(const Token *tok, const ValueType *vtint, const ValueType *vtfloat, const std::list<ValueFlow::Value> *floatValues)
+void CheckType::checkFloatToIntegerOverflow(const Token *tok, const ValueType *vtint, const ValueType *vtfloat, const std::list<ValueFlow::Value> &floatValues)
 {
     // Conversion of float to integer?
     if (!vtint || !vtint->isIntegral())
@@ -425,30 +488,30 @@ void CheckType::checkFloatToIntegerOverflow(const Token *tok, const ValueType *v
     if (!vtfloat || !vtfloat->isFloat())
         return;
 
-    for (const ValueFlow::Value &f : *floatValues) {
+    for (const ValueFlow::Value &f : floatValues) {
         if (f.valueType != ValueFlow::Value::ValueType::FLOAT)
             continue;
         if (!mSettings->isEnabled(&f, false))
             continue;
-        if (f.floatValue > ~0ULL)
+        if (f.floatValue >= std::exp2(mSettings->platform.long_long_bit))
             floatToIntegerOverflowError(tok, f);
-        else if ((-f.floatValue) > (1ULL<<62))
+        else if ((-f.floatValue) > std::exp2(mSettings->platform.long_long_bit - 1))
             floatToIntegerOverflowError(tok, f);
-        else if (mSettings->platformType != Settings::Unspecified) {
+        else if (mSettings->platform.type != Platform::Type::Unspecified) {
             int bits = 0;
             if (vtint->type == ValueType::Type::CHAR)
-                bits = mSettings->char_bit;
+                bits = mSettings->platform.char_bit;
             else if (vtint->type == ValueType::Type::SHORT)
-                bits = mSettings->short_bit;
+                bits = mSettings->platform.short_bit;
             else if (vtint->type == ValueType::Type::INT)
-                bits = mSettings->int_bit;
+                bits = mSettings->platform.int_bit;
             else if (vtint->type == ValueType::Type::LONG)
-                bits = mSettings->long_bit;
+                bits = mSettings->platform.long_bit;
             else if (vtint->type == ValueType::Type::LONGLONG)
-                bits = mSettings->long_long_bit;
+                bits = mSettings->platform.long_long_bit;
             else
                 continue;
-            if (bits < MathLib::bigint_bits && f.floatValue >= (((MathLib::biguint)1) << bits))
+            if (bits < MathLib::bigint_bits && f.floatValue >= (1ULL << bits))
                 floatToIntegerOverflowError(tok, f);
         }
     }
@@ -461,5 +524,33 @@ void CheckType::floatToIntegerOverflowError(const Token *tok, const ValueFlow::V
     reportError(getErrorPath(tok, &value, "float to integer conversion"),
                 value.errorSeverity() ? Severity::error : Severity::warning,
                 "floatConversionOverflow",
-                errmsg.str(), CWE190, value.isInconclusive());
+                errmsg.str(), CWE190, value.isInconclusive() ? Certainty::inconclusive : Certainty::normal);
+}
+
+void CheckType::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    // These are not "simplified" because casts can't be ignored
+    CheckType checkType(&tokenizer, &tokenizer.getSettings(), errorLogger);
+    checkType.checkTooBigBitwiseShift();
+    checkType.checkIntegerOverflow();
+    checkType.checkSignConversion();
+    checkType.checkLongCast();
+    checkType.checkFloatToIntegerOverflow();
+}
+
+void CheckType::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const
+{
+    CheckType c(nullptr, settings, errorLogger);
+    c.tooBigBitwiseShiftError(nullptr, 32, ValueFlow::Value(64));
+    c.tooBigSignedBitwiseShiftError(nullptr, 31, ValueFlow::Value(31));
+    c.integerOverflowError(nullptr, ValueFlow::Value(1LL<<32));
+    // TODO: integerOverflowCond
+    c.signConversionError(nullptr, nullptr, false);
+    // TODO: signConversionCond
+    c.longCastAssignError(nullptr);
+    c.longCastReturnError(nullptr);
+    ValueFlow::Value f;
+    f.valueType = ValueFlow::Value::ValueType::FLOAT;
+    f.floatValue = 1E100;
+    c.floatToIntegerOverflowError(nullptr, f);
 }
diff --git a/lib/checktype.h b/lib/checktype.h
index e51da8d1d7f..d90e11f6fd1 100644
--- a/lib/checktype.h
+++ b/lib/checktype.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,12 +24,19 @@
 
 #include "check.h"
 #include "config.h"
-#include "valueflow.h"
+
+#include <list>
+#include <string>
 
 class ErrorLogger;
 class Settings;
 class Token;
+class ValueType;
 class Tokenizer;
+namespace ValueFlow
+{
+    class Value;
+}
 
 /// @addtogroup Checks
 /// @{
@@ -40,24 +47,15 @@ class Tokenizer;
 class CPPCHECKLIB CheckType : public Check {
 public:
     /** @brief This constructor is used when registering the CheckClass */
-    CheckType() : Check(myName()) {
-    }
+    CheckType() : Check(myName()) {}
 
+private:
     /** @brief This constructor is used when running checks. */
     CheckType(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger) {}
 
     /** @brief Run checks against the normal token list */
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        // These are not "simplified" because casts can't be ignored
-        CheckType checkType(tokenizer, settings, errorLogger);
-        checkType.checkTooBigBitwiseShift();
-        checkType.checkIntegerOverflow();
-        checkType.checkSignConversion();
-        checkType.checkLongCast();
-        checkType.checkFloatToIntegerOverflow();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     /** @brief %Check for bitwise shift with too big right operand */
     void checkTooBigBitwiseShift();
@@ -73,38 +71,24 @@ class CPPCHECKLIB CheckType : public Check {
 
     /** @brief %Check for float to integer overflow */
     void checkFloatToIntegerOverflow();
-    void checkFloatToIntegerOverflow(const Token *tok, const ValueType *vtint, const ValueType *vtfloat, const std::list<ValueFlow::Value> *floatValues);
-
-private:
+    void checkFloatToIntegerOverflow(const Token *tok, const ValueType *vtint, const ValueType *vtfloat, const std::list<ValueFlow::Value> &floatValues);
 
     // Error messages..
     void tooBigBitwiseShiftError(const Token *tok, int lhsbits, const ValueFlow::Value &rhsbits);
     void tooBigSignedBitwiseShiftError(const Token *tok, int lhsbits, const ValueFlow::Value &rhsbits);
-    void integerOverflowError(const Token *tok, const ValueFlow::Value &value);
-    void signConversionError(const Token *tok, const ValueFlow::Value *negativeValue, const bool constvalue);
-    void longCastAssignError(const Token *tok);
-    void longCastReturnError(const Token *tok);
+    void integerOverflowError(const Token *tok, const ValueFlow::Value &value, bool isOverflow = true);
+    void signConversionError(const Token *tok, const ValueFlow::Value *negativeValue, bool constvalue);
+    void longCastAssignError(const Token *tok, const ValueType* src = nullptr, const ValueType* tgt = nullptr);
+    void longCastReturnError(const Token *tok, const ValueType* src = nullptr, const ValueType* tgt = nullptr);
     void floatToIntegerOverflowError(const Token *tok, const ValueFlow::Value &value);
 
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        CheckType c(nullptr, settings, errorLogger);
-        c.tooBigBitwiseShiftError(nullptr, 32, ValueFlow::Value(64));
-        c.tooBigSignedBitwiseShiftError(nullptr, 31, ValueFlow::Value(31));
-        c.integerOverflowError(nullptr, ValueFlow::Value(1LL<<32));
-        c.signConversionError(nullptr, nullptr, false);
-        c.longCastAssignError(nullptr);
-        c.longCastReturnError(nullptr);
-        ValueFlow::Value f;
-        f.valueType = ValueFlow::Value::ValueType::FLOAT;
-        f.floatValue = 1E100;
-        c.floatToIntegerOverflowError(nullptr, f);
-    }
+    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const override;
 
     static std::string myName() {
         return "Type";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Type checks\n"
                "- bitwise shift by too many bits (only enabled when --platform is used)\n"
                "- signed integer overflow (only enabled when --platform is used)\n"
diff --git a/lib/checkuninitvar.cpp b/lib/checkuninitvar.cpp
index 2d7ef9e2bb9..ecaed652c5e 100644
--- a/lib/checkuninitvar.cpp
+++ b/lib/checkuninitvar.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,7 +21,7 @@
 #include "checkuninitvar.h"
 
 #include "astutils.h"
-#include "checknullpointer.h"   // CheckNullPointer::isPointerDeref
+#include "ctu.h"
 #include "errorlogger.h"
 #include "library.h"
 #include "mathlib.h"
@@ -29,18 +29,27 @@
 #include "symboldatabase.h"
 #include "token.h"
 #include "tokenize.h"
-#include "valueflow.h"
+#include "tokenlist.h"
+#include "utils.h"
+#include "vfvalue.h"
 
-#include <tinyxml2.h>
+#include "checknullpointer.h"   // CheckNullPointer::isPointerDeref
 
+#include <algorithm>
 #include <cassert>
-#include <cstddef>
+#include <functional>
+#include <initializer_list>
 #include <list>
 #include <map>
-#include <stack>
+#include <unordered_set>
 #include <utility>
+#include <vector>
+
 //---------------------------------------------------------------------------
 
+// CWE ids used:
+static const CWE CWE_USE_OF_UNINITIALIZED_VARIABLE(457U);
+
 // Register this check class (by creating a static instance of it)
 namespace {
     CheckUninitVar instance;
@@ -48,12 +57,6 @@ namespace {
 
 //---------------------------------------------------------------------------
 
-// CWE ids used:
-static const struct CWE CWE476(476U);  // NULL Pointer Dereference
-static const struct CWE CWE676(676U);
-static const struct CWE CWE908(908U);
-static const struct CWE CWE825(825U);
-
 // get ast parent, skip possible address-of and casts
 static const Token *getAstParentSkipPossibleCastAndAddressOf(const Token *vartok, bool *unknown)
 {
@@ -78,8 +81,40 @@ static const Token *getAstParentSkipPossibleCastAndAddressOf(const Token *vartok
     return parent;
 }
 
+static std::map<nonneg int, VariableValue> getVariableValues(const Token* tok) {
+    std::map<nonneg int, VariableValue> ret;
+    if (!tok || !tok->scope()->isExecutable())
+        return ret;
+    while (tok && tok->str() != "{") {
+        if (tok->str() == "}") {
+            if (tok->link()->isBinaryOp())
+                tok = tok->link()->previous();
+            else
+                break;
+        }
+        if (Token::Match(tok, "%var% =|{") && tok->next()->isBinaryOp() && tok->varId() && ret.count(tok->varId()) == 0) {
+            const Token* rhs = tok->next()->astOperand2();
+            if (rhs && rhs->hasKnownIntValue())
+                ret[tok->varId()] = VariableValue(rhs->getKnownIntValue());
+        }
+        tok = tok->previous();
+    }
+    return ret;
+}
+
+bool CheckUninitVar::diag(const Token* tok)
+{
+    if (!tok)
+        return true;
+    while (Token::Match(tok->astParent(), "*|&|."))
+        tok = tok->astParent();
+    return !mUninitDiags.insert(tok).second;
+}
+
 void CheckUninitVar::check()
 {
+    logChecker("CheckUninitVar::check");
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
     std::set<std::string> arrayTypeDefs;
@@ -111,11 +146,11 @@ void CheckUninitVar::checkScope(const Scope* scope, const std::set<std::string>
             continue;
 
         if (Token::Match(var.nameToken(), "%name% =")) { // Variable is initialized, but Rhs might be not
-            checkRhs(var.nameToken(), var, NO_ALLOC, 0U, emptyString);
+            checkRhs(var.nameToken(), var, NO_ALLOC, 0U, "");
             continue;
         }
         if (Token::Match(var.nameToken(), "%name% ) (") && Token::simpleMatch(var.nameToken()->linkAt(2), ") =")) { // Function pointer is initialized, but Rhs might be not
-            checkRhs(var.nameToken()->linkAt(2)->next(), var, NO_ALLOC, 0U, emptyString);
+            checkRhs(var.nameToken()->linkAt(2)->next(), var, NO_ALLOC, 0U, "");
             continue;
         }
 
@@ -125,44 +160,50 @@ void CheckUninitVar::checkScope(const Scope* scope, const std::set<std::string>
                 tok = tok->next();
             while (Token::simpleMatch(tok->link(), "] ["))
                 tok = tok->link()->next();
-            if (Token::Match(tok->link(), "] =|{"))
+            if (Token::Match(tok->link(), "] =|{|("))
                 continue;
         }
 
-        bool stdtype = mTokenizer->isC() && arrayTypeDefs.find(var.typeStartToken()->str()) == arrayTypeDefs.end();
+        bool stdtype = var.typeStartToken()->isC() && arrayTypeDefs.find(var.typeStartToken()->str()) == arrayTypeDefs.end();
         const Token* tok = var.typeStartToken();
         for (; tok != var.nameToken() && tok->str() != "<"; tok = tok->next()) {
             if (tok->isStandardType() || tok->isEnumType())
                 stdtype = true;
         }
-        if (var.isArray() && !stdtype)
-            continue;
+        if (var.isArray() && !stdtype) { // std::array
+            if (!(var.isStlType() && Token::simpleMatch(var.typeStartToken(), "std :: array") && var.valueType() &&
+                  var.valueType()->containerTypeToken && var.valueType()->containerTypeToken->isStandardType()))
+                continue;
+        }
 
         while (tok && tok->str() != ";")
             tok = tok->next();
         if (!tok)
             continue;
 
-        if (tok->astParent() && Token::simpleMatch(tok->astParent()->previous(), "for (") &&
-            checkLoopBody(tok->astParent()->link()->next(), var, var.isArray() ? ARRAY : NO_ALLOC, emptyString, true))
+        if (tok->astParent() && Token::simpleMatch(tok->astParent()->previous(), "for (") && Token::simpleMatch(tok->astParent()->link()->next(), "{") &&
+            checkLoopBody(tok->astParent()->link()->next(), var, var.isArray() ? ARRAY : NO_ALLOC, "", true))
             continue;
 
         if (var.isArray()) {
-            Alloc alloc = ARRAY;
-            const std::map<int, VariableValue> variableValue;
             bool init = false;
             for (const Token *parent = var.nameToken(); parent; parent = parent->astParent()) {
-                if (parent->str() == "=")
+                if (parent->str() == "=") {
                     init = true;
+                    break;
+                }
+            }
+            if (!init) {
+                Alloc alloc = ARRAY;
+                std::map<nonneg int, VariableValue> variableValue = getVariableValues(var.typeStartToken());
+                checkScopeForVariable(tok, var, nullptr, nullptr, &alloc, "", variableValue);
             }
-            if (!init)
-                checkScopeForVariable(tok, var, nullptr, nullptr, &alloc, emptyString, variableValue);
             continue;
         }
         if (stdtype || var.isPointer()) {
             Alloc alloc = NO_ALLOC;
-            const std::map<int, VariableValue> variableValue;
-            checkScopeForVariable(tok, var, nullptr, nullptr, &alloc, emptyString, variableValue);
+            std::map<nonneg int, VariableValue> variableValue = getVariableValues(var.typeStartToken());
+            checkScopeForVariable(tok, var, nullptr, nullptr, &alloc, "", variableValue);
         }
         if (var.type())
             checkStruct(tok, var);
@@ -173,15 +214,21 @@ void CheckUninitVar::checkScope(const Scope* scope, const std::set<std::string>
             if (arg.declarationId() && Token::Match(arg.typeStartToken(), "%type% * %name% [,)]")) {
                 // Treat the pointer as initialized until it is assigned by malloc
                 for (const Token *tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
-                    if (Token::Match(tok, "[;{}] %varid% = %name% (", arg.declarationId()) &&
-                        mSettings->library.returnuninitdata.count(tok->strAt(3)) == 1U) {
-                        if (arg.typeStartToken()->strAt(-1) == "struct" || (arg.type() && arg.type()->isStructType()))
-                            checkStruct(tok, arg);
-                        else if (arg.typeStartToken()->isStandardType() || arg.typeStartToken()->isEnumType()) {
-                            Alloc alloc = NO_ALLOC;
-                            const std::map<int, VariableValue> variableValue;
-                            checkScopeForVariable(tok->next(), arg, nullptr, nullptr, &alloc, emptyString, variableValue);
-                        }
+                    if (!Token::Match(tok, "[;{}] %varid% =", arg.declarationId()))
+                        continue;
+                    const Token *allocFuncCallToken = findAllocFuncCallToken(tok->tokAt(2)->astOperand2(), mSettings->library);
+                    if (!allocFuncCallToken)
+                        continue;
+                    const Library::AllocFunc *allocFunc = mSettings->library.getAllocFuncInfo(allocFuncCallToken);
+                    if (!allocFunc || allocFunc->initData)
+                        continue;
+
+                    if (arg.typeStartToken()->strAt(-1) == "struct" || (arg.type() && arg.type()->isStructType()))
+                        checkStruct(tok, arg);
+                    else if (arg.typeStartToken()->isStandardType() || arg.typeStartToken()->isEnumType()) {
+                        Alloc alloc = NO_ALLOC;
+                        std::map<nonneg int, VariableValue> variableValue;
+                        checkScopeForVariable(tok->next(), arg, nullptr, nullptr, &alloc, "", variableValue);
                     }
                 }
             }
@@ -192,6 +239,8 @@ void CheckUninitVar::checkScope(const Scope* scope, const std::set<std::string>
 void CheckUninitVar::checkStruct(const Token *tok, const Variable &structvar)
 {
     const Token *typeToken = structvar.typeStartToken();
+    while (Token::Match(typeToken, "%name% ::"))
+        typeToken = typeToken->tokAt(2);
     const SymbolDatabase * symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Scope *scope2 : symbolDatabase->classAndStructScopes) {
         if (scope2->className == typeToken->str() && scope2->numConstructors == 0U) {
@@ -203,7 +252,7 @@ void CheckUninitVar::checkStruct(const Token *tok, const Variable &structvar)
                 // is the variable declared in a inner union?
                 bool innerunion = false;
                 for (const Scope *innerScope : scope2->nestedList) {
-                    if (innerScope->type == Scope::eUnion) {
+                    if (innerScope->type == ScopeType::eUnion) {
                         if (var.typeStartToken()->linenr() >= innerScope->bodyStart->linenr() &&
                             var.typeStartToken()->linenr() <= innerScope->bodyEnd->linenr()) {
                             innerunion = true;
@@ -217,7 +266,7 @@ void CheckUninitVar::checkStruct(const Token *tok, const Variable &structvar)
                     const Token *tok2 = tok;
                     if (tok->str() == "}")
                         tok2 = tok2->next();
-                    const std::map<int, VariableValue> variableValue;
+                    std::map<nonneg int, VariableValue> variableValue = getVariableValues(structvar.typeStartToken());
                     checkScopeForVariable(tok2, structvar, nullptr, nullptr, &alloc, var.name(), variableValue);
                 }
             }
@@ -239,15 +288,23 @@ static bool operator!=(const VariableValue & v, MathLib::bigint i)
     return v.notEqual ? (i == v.value) : (i != v.value);
 }
 
-static void conditionAlwaysTrueOrFalse(const Token *tok, const std::map<int, VariableValue> &variableValue, bool *alwaysTrue, bool *alwaysFalse)
+static void conditionAlwaysTrueOrFalse(const Token *tok, const std::map<nonneg int, VariableValue> &variableValue, bool *alwaysTrue, bool *alwaysFalse)
 {
     if (!tok)
         return;
 
+    if (const ValueFlow::Value* v = tok->getKnownValue(ValueFlow::Value::ValueType::INT)) {
+        if (v->intvalue == 0)
+            *alwaysFalse = true;
+        else
+            *alwaysTrue = true;
+        return;
+    }
+
     if (tok->isName() || tok->str() == ".") {
         while (tok && tok->str() == ".")
             tok = tok->astOperand2();
-        const std::map<int, VariableValue>::const_iterator it = variableValue.find(tok ? tok->varId() : ~0U);
+        const auto it = tok ? variableValue.find(tok->varId()) : variableValue.end();
         if (it != variableValue.end()) {
             *alwaysTrue = (it->second != 0LL);
             *alwaysFalse = (it->second == 0LL);
@@ -255,11 +312,7 @@ static void conditionAlwaysTrueOrFalse(const Token *tok, const std::map<int, Var
     }
 
     else if (tok->isComparisonOp()) {
-        if (tok->hasKnownIntValue()) {
-            if (tok->values().front().intvalue)
-                *alwaysTrue = true;
-            else
-                *alwaysFalse = true;
+        if (variableValue.empty()) {
             return;
         }
 
@@ -277,14 +330,14 @@ static void conditionAlwaysTrueOrFalse(const Token *tok, const std::map<int, Var
         while (vartok && vartok->str() == ".")
             vartok = vartok->astOperand2();
 
-        const std::map<int, VariableValue>::const_iterator it = variableValue.find(vartok ? vartok->varId() : ~0U);
+        const auto it = vartok ? variableValue.find(vartok->varId()) : variableValue.end();
         if (it == variableValue.end())
             return;
 
         if (tok->str() == "==")
-            *alwaysTrue  = (it->second == MathLib::toLongNumber(numtok->str()));
+            *alwaysTrue  = (it->second == MathLib::toBigNumber(numtok));
         else if (tok->str() == "!=")
-            *alwaysTrue  = (it->second != MathLib::toLongNumber(numtok->str()));
+            *alwaysTrue  = (it->second != MathLib::toBigNumber(numtok));
         else
             return;
         *alwaysFalse = !(*alwaysTrue);
@@ -293,7 +346,7 @@ static void conditionAlwaysTrueOrFalse(const Token *tok, const std::map<int, Var
     else if (tok->str() == "!") {
         bool t=false,f=false;
         conditionAlwaysTrueOrFalse(tok->astOperand1(), variableValue, &t, &f);
-        if (t||f) {
+        if (t || f) {
             *alwaysTrue = !t;
             *alwaysFalse = !f;
         }
@@ -344,9 +397,9 @@ static bool isVariableUsed(const Token *tok, const Variable& var)
     return !parent2 || parent2->isConstOp() || (parent2->str() == "=" && parent2->astOperand2() == parent);
 }
 
-bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var, bool * const possibleInit, bool * const noreturn, Alloc* const alloc, const std::string &membervar, std::map<int, VariableValue> variableValue)
+bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var, bool * const possibleInit, bool * const noreturn, Alloc* const alloc, const std::string &membervar, std::map<nonneg int, VariableValue>& variableValue)
 {
-    const bool suppressErrors(possibleInit && *possibleInit);  // Assume that this is a variable delaratkon, rather than a fundef
+    const bool suppressErrors(possibleInit && *possibleInit);  // Assume that this is a variable declaration, rather than a fundef
     const bool printDebug = mSettings->debugwarnings;
 
     if (possibleInit)
@@ -364,7 +417,7 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
                 *possibleInit = true;
 
             // might be a noreturn function..
-            if (mTokenizer->IsScopeNoReturn(tok)) {
+            if (mTokenizer->isScopeNoReturn(tok)) {
                 if (noreturn)
                     *noreturn = true;
                 return false;
@@ -373,17 +426,29 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
             break;
         }
 
-        // Unconditional inner scope or try..
-        if (tok->str() == "{" && Token::Match(tok->previous(), ",|;|{|}|try")) {
-            if (checkScopeForVariable(tok->next(), var, possibleInit, noreturn, alloc, membervar, variableValue))
+        // Unconditional inner scope, try, lambda, init list
+        if (tok->str() == "{" && Token::Match(tok->previous(), ",|;|{|}|]|try")) {
+            bool possibleInitInner = false;
+            if (checkScopeForVariable(tok->next(), var, &possibleInitInner, noreturn, alloc, membervar, variableValue))
                 return true;
             tok = tok->link();
+            if (possibleInitInner) {
+                number_of_if = 1;
+                if (possibleInit)
+                    *possibleInit = true;
+            }
             continue;
         }
 
-        // assignment with nonzero constant..
-        if (Token::Match(tok->previous(), "[;{}] %var% = - %name% ;"))
-            variableValue[tok->varId()] = !VariableValue(0);
+        // track values of other variables..
+        if (Token::Match(tok->previous(), "[;{}.] %var% =")) {
+            if (tok->next()->astOperand2() && tok->next()->astOperand2()->hasKnownIntValue())
+                variableValue[tok->varId()] = VariableValue(tok->next()->astOperand2()->getKnownIntValue());
+            else if (Token::Match(tok->previous(), "[;{}] %var% = - %name% ;"))
+                variableValue[tok->varId()] = !VariableValue(0);
+            else
+                variableValue.erase(tok->varId());
+        }
 
         // Inner scope..
         else if (Token::simpleMatch(tok, "if (")) {
@@ -401,54 +466,51 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
             conditionAlwaysTrueOrFalse(tok->next()->astOperand2(), variableValue, &alwaysTrue, &alwaysFalse);
 
             // initialization / usage in condition..
-            if (!alwaysTrue && checkIfForWhileHead(tok->next(), var, suppressErrors, bool(number_of_if == 0), *alloc, membervar))
+            if (!alwaysTrue && checkIfForWhileHead(tok->next(), var, suppressErrors, (number_of_if == 0), *alloc, membervar))
                 return true;
 
             // checking if a not-zero variable is zero => bail out
-            int condVarId = 0;
+            nonneg int condVarId = 0;
             VariableValue condVarValue(0);
             const Token *condVarTok = nullptr;
             if (alwaysFalse)
                 ;
-            else if (Token::simpleMatch(tok, "if (") &&
-                     astIsVariableComparison(tok->next()->astOperand2(), "!=", "0", &condVarTok)) {
-                const std::map<int,VariableValue>::const_iterator it = variableValue.find(condVarTok->varId());
-                if (it != variableValue.end() && it->second != 0)
+            else if (astIsVariableComparison(tok->next()->astOperand2(), "!=", "0", &condVarTok)) {
+                const auto it = utils::as_const(variableValue).find(condVarTok->varId());
+                if (it != variableValue.cend() && it->second != 0)
                     return true;   // this scope is not fully analysed => return true
-                else {
-                    condVarId = condVarTok->varId();
-                    condVarValue = !VariableValue(0);
-                }
-            } else if (Token::simpleMatch(tok, "if (") && Token::Match(tok->next()->astOperand2(), "==|!=")) {
+
+                condVarId = condVarTok->varId();
+                condVarValue = !VariableValue(0);
+            } else if (Token::Match(tok->next()->astOperand2(), "==|!=")) {
                 const Token *condition = tok->next()->astOperand2();
                 const Token *lhs = condition->astOperand1();
                 const Token *rhs = condition->astOperand2();
-                const Token *vartok = rhs && rhs->isNumber() ? lhs : rhs;
-                const Token *numtok = rhs && rhs->isNumber() ? rhs : lhs;
+                const Token *vartok = (lhs && lhs->hasKnownIntValue()) ? rhs : lhs;
+                const Token *numtok = (lhs == vartok) ? rhs : lhs;
                 while (Token::simpleMatch(vartok, "."))
                     vartok = vartok->astOperand2();
-                if (vartok && vartok->varId() && numtok) {
-                    const std::map<int,VariableValue>::const_iterator it = variableValue.find(vartok->varId());
-                    if (it != variableValue.end() && it->second != MathLib::toLongNumber(numtok->str()))
+                if (vartok && vartok->varId() && numtok && numtok->hasKnownIntValue()) {
+                    const auto it = utils::as_const(variableValue).find(vartok->varId());
+                    if (it != variableValue.cend() && it->second != numtok->getKnownIntValue())
                         return true;   // this scope is not fully analysed => return true
-                    else {
-                        condVarId = vartok->varId();
-                        condVarValue = VariableValue(MathLib::toLongNumber(numtok->str()));
-                        if (condition->str() == "!=")
-                            condVarValue = !condVarValue;
-                    }
+                    condVarId = vartok->varId();
+                    condVarValue = VariableValue(numtok->getKnownIntValue());
+                    if (condition->str() == "!=")
+                        condVarValue = !condVarValue;
                 }
             }
 
             // goto the {
-            tok = tok->next()->link()->next();
+            tok = tok->linkAt(1)->next();
 
             if (!tok)
                 break;
             if (tok->str() == "{") {
                 bool possibleInitIf((!alwaysTrue && number_of_if > 0) || suppressErrors);
                 bool noreturnIf = false;
-                const bool initif = !alwaysFalse && checkScopeForVariable(tok->next(), var, &possibleInitIf, &noreturnIf, alloc, membervar, variableValue);
+                std::map<nonneg int, VariableValue> varValueIf(variableValue);
+                const bool initif = !alwaysFalse && checkScopeForVariable(tok->next(), var, &possibleInitIf, &noreturnIf, alloc, membervar, varValueIf);
 
                 // bail out for such code:
                 //    if (a) x=0;    // conditional initialization
@@ -462,7 +524,7 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
                             if (tok2->isName() && tok2->next()->isName())
                                 condition += ' ';
                         }
-                        reportError(tok, Severity::debug, "debug", "bailout uninitialized variable checking for '" + var.name() + "'. can't determine if this condition can be false when previous condition is false: " + condition);
+                        reportError(tok, Severity::debug, "bailoutUninitVar", "bailout uninitialized variable checking for '" + var.name() + "'. can't determine if this condition can be false when previous condition is false: " + condition);
                     }
                     return true;
                 }
@@ -470,17 +532,10 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
                 if (alwaysTrue && (initif || noreturnIf))
                     return true;
 
-                std::map<int, VariableValue> varValueIf;
-                if (!alwaysFalse && !initif && !noreturnIf) {
-                    for (const Token *tok2 = tok; tok2 && tok2 != tok->link(); tok2 = tok2->next()) {
-                        if (Token::Match(tok2, "[;{}.] %name% = - %name% ;"))
-                            varValueIf[tok2->next()->varId()] = !VariableValue(0);
-                        else if (Token::Match(tok2, "[;{}.] %name% = %num% ;"))
-                            varValueIf[tok2->next()->varId()] = VariableValue(MathLib::toLongNumber(tok2->strAt(3)));
-                    }
-                }
+                if (!alwaysFalse && !initif && !noreturnIf)
+                    variableValue = varValueIf;
 
-                if (initif && condVarId > 0U)
+                if (initif && condVarId > 0)
                     variableValue[condVarId] = !condVarValue;
 
                 // goto the }
@@ -498,19 +553,13 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
 
                     bool possibleInitElse((!alwaysFalse && number_of_if > 0) || suppressErrors);
                     bool noreturnElse = false;
-                    const bool initelse = !alwaysTrue && checkScopeForVariable(tok->next(), var, &possibleInitElse, &noreturnElse, alloc, membervar, variableValue);
-
-                    std::map<int, VariableValue> varValueElse;
-                    if (!alwaysTrue && !initelse && !noreturnElse) {
-                        for (const Token *tok2 = tok; tok2 && tok2 != tok->link(); tok2 = tok2->next()) {
-                            if (Token::Match(tok2, "[;{}.] %var% = - %name% ;"))
-                                varValueElse[tok2->next()->varId()] = !VariableValue(0);
-                            else if (Token::Match(tok2, "[;{}.] %var% = %num% ;"))
-                                varValueElse[tok2->next()->varId()] = VariableValue(MathLib::toLongNumber(tok2->strAt(3)));
-                        }
-                    }
+                    std::map<nonneg int, VariableValue> varValueElse(variableValue);
+                    const bool initelse = !alwaysTrue && checkScopeForVariable(tok->next(), var, &possibleInitElse, &noreturnElse, alloc, membervar, varValueElse);
 
-                    if (initelse && condVarId > 0U && !noreturnIf && !noreturnElse)
+                    if (!alwaysTrue && !initelse && !noreturnElse)
+                        variableValue = varValueElse;
+
+                    if (initelse && condVarId > 0 && !noreturnIf && !noreturnElse)
                         variableValue[condVarId] = condVarValue;
 
                     // goto the }
@@ -523,17 +572,17 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
                     if (initif || initelse || possibleInitElse)
                         ++number_of_if;
                     if (!initif && !noreturnIf)
-                        variableValue.insert(varValueIf.begin(), varValueIf.end());
+                        variableValue.insert(varValueIf.cbegin(), varValueIf.cend());
                     if (!initelse && !noreturnElse)
-                        variableValue.insert(varValueElse.begin(), varValueElse.end());
+                        variableValue.insert(varValueElse.cbegin(), varValueElse.cend());
                 }
             }
         }
 
         // = { .. }
-        else if (Token::simpleMatch(tok, "= {")) {
+        else if (Token::simpleMatch(tok, "= {") || (Token::Match(tok, "%name% {") && tok->variable() && tok == tok->variable()->nameToken())) {
             // end token
-            const Token *end = tok->next()->link();
+            const Token *end = tok->linkAt(1);
 
             // If address of variable is taken in the block then bail out
             if (var.isPointer() || var.isArray()) {
@@ -545,7 +594,7 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
 
             const Token *errorToken = nullptr;
             visitAstNodes(tok->next(),
-            [&](const Token *child) {
+                          [&](const Token *child) {
                 if (child->isUnaryOp("&"))
                     return ChildrenToVisit::none;
                 if (child->str() == "," || child->str() == "{" || child->isConstOp())
@@ -568,8 +617,8 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
         }
 
         // skip sizeof / offsetof
-        if (Token::Match(tok, "sizeof|typeof|offsetof|decltype ("))
-            tok = tok->next()->link();
+        if (isUnevaluated(tok))
+            tok = tok->linkAt(1);
 
         // for/while..
         else if (Token::Match(tok, "for|while (") || Token::simpleMatch(tok, "do {")) {
@@ -580,7 +629,7 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
                 return true;
 
             // goto the {
-            const Token *tok2 = forwhile ? tok->next()->link()->next() : tok->next();
+            const Token *tok2 = forwhile ? tok->linkAt(1)->next() : tok->next();
 
             if (tok2 && tok2->str() == "{") {
                 const bool init = checkLoopBody(tok2, var, *alloc, membervar, (number_of_if > 0) || suppressErrors);
@@ -592,8 +641,8 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
                 // is variable used in for-head?
                 bool initcond = false;
                 if (!suppressErrors) {
-                    const Token *startCond = forwhile ? tok->next() : tok->next()->link()->tokAt(2);
-                    initcond = checkIfForWhileHead(startCond, var, false, bool(number_of_if == 0), *alloc, membervar);
+                    const Token *startCond = forwhile ? tok->next() : tok->linkAt(1)->tokAt(2);
+                    initcond = checkIfForWhileHead(startCond, var, false, (number_of_if == 0), *alloc, membervar);
                 }
 
                 // goto "}"
@@ -623,7 +672,7 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
         }
 
         // Unknown or unhandled inner scope
-        else if (Token::simpleMatch(tok, ") {") || (Token::Match(tok, "%name% {") && tok->str() != "try")) {
+        else if (Token::simpleMatch(tok, ") {") || (Token::Match(tok, "%name% {") && tok->str() != "try" && !(tok->variable() && tok == tok->variable()->nameToken()))) {
             if (tok->str() == "struct" || tok->str() == "union") {
                 tok = tok->linkAt(1);
                 continue;
@@ -646,6 +695,11 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
             return true;
         }
 
+        // bailout if there is a pointer to member
+        if (Token::Match(tok, "%varid% . *", var.declarationId())) {
+            return true;
+        }
+
         if (tok->str() == "?") {
             if (!tok->astOperand2())
                 return true;
@@ -668,8 +722,14 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
                 // variable is seen..
                 if (tok->varId() == var.declarationId()) {
                     if (!membervar.empty()) {
-                        if (!suppressErrors && Token::Match(tok, "%name% . %name% ;|%cop%") && tok->strAt(2) == membervar)
+                        if (!suppressErrors && Token::Match(tok, "%name% . %name%") && tok->strAt(2) == membervar && Token::Match(tok->next()->astParent(), "%cop%|return|throw|?"))
                             uninitStructMemberError(tok, tok->str() + "." + membervar);
+                        else if (tok->isCpp() && !suppressErrors && Token::Match(tok, "%name%") && Token::Match(tok->astParent(), "return|throw|?")) {
+                            if (std::any_of(tok->values().cbegin(), tok->values().cend(), [](const ValueFlow::Value& v) {
+                                return v.isUninitValue() && !v.isInconclusive();
+                            }))
+                                uninitStructMemberError(tok, tok->str() + "." + membervar);
+                        }
                     }
 
                     // Use variable
@@ -679,7 +739,7 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
                     return true;
                 }
 
-                else if (Token::Match(tok, "sizeof|typeof|offsetof|decltype ("))
+                if (isUnevaluated(tok))
                     tok = tok->linkAt(1);
 
                 else if (tok->str() == "?") {
@@ -705,14 +765,16 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
             if (var.isPointer() && Token::simpleMatch(tok->next(), "=")) {
                 const Token *rhs = tok->next()->astOperand2();
                 while (rhs && rhs->isCast())
-                    rhs = rhs->astOperand1();
-                if (rhs && Token::Match(rhs->previous(), "%name% (") &&
-                    mSettings->library.returnuninitdata.count(rhs->previous()->str()) > 0U) {
-                    *alloc = NO_CTOR_CALL;
-                    continue;
+                    rhs = rhs->astOperand2() ? rhs->astOperand2() : rhs->astOperand1();
+                if (rhs && Token::Match(rhs->previous(), "%name% (")) {
+                    const Library::AllocFunc *allocFunc = mSettings->library.getAllocFuncInfo(rhs->astOperand1());
+                    if (allocFunc && !allocFunc->initData) {
+                        *alloc = NO_CTOR_CALL;
+                        continue;
+                    }
                 }
             }
-            if (var.isPointer() && (var.typeStartToken()->isStandardType() || var.typeStartToken()->isEnumType() || (var.type() && var.type()->needInitialization == Type::NeedInitialization::True)) && Token::simpleMatch(tok->next(), "= new")) {
+            if (mTokenizer->isCPP() && var.isPointer() && (var.typeStartToken()->isStandardType() || var.typeStartToken()->isEnumType() || (var.type() && var.type()->needInitialization == Type::NeedInitialization::True)) && Token::simpleMatch(tok->next(), "= new")) {
                 *alloc = CTOR_CALL;
 
                 // type has constructor(s)
@@ -726,12 +788,8 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
                         return true;
 
                     // array new
-                    if (Token::Match(tok->next(), "= new %type% [")) {
-                        const Token* tokClosingBracket=tok->linkAt(4);
-                        // array new with initialization
-                        if (tokClosingBracket && Token::simpleMatch(tokClosingBracket->next(), "( )"))
-                            return true;
-                    }
+                    if (Token::Match(tok->next(), "= new %type% [") && Token::simpleMatch(tok->linkAt(4), "] ("))
+                        return true;
                 }
 
                 continue;
@@ -739,6 +797,9 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
 
 
             if (!membervar.empty()) {
+                if (mTokenizer->isCPP() && Token::simpleMatch(tok->astParent(), ">>"))
+                    return true;
+
                 if (isMemberVariableAssignment(tok, membervar)) {
                     checkRhs(tok, var, *alloc, number_of_if, membervar);
                     return true;
@@ -749,7 +810,10 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
                     return true;
                 }
 
-                else if (Token::Match(tok->previous(), "[(,] %name% [,)]"))
+                if (Token::Match(tok->previous(), "[(,] %name% [,)]"))
+                    return true;
+
+                if (Token::Match(tok->previous(), "= %var% . %var% ;") && membervar == tok->strAt(2))
                     return true;
 
             } else {
@@ -759,13 +823,29 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
                     return true;
                 }
 
-                else {
-                    if (tok->strAt(1) == "=")
-                        checkRhs(tok, var, *alloc, number_of_if, emptyString);
+                const Token *parent = tok;
+                while (parent->astParent() && ((astIsLHS(parent) && parent->astParent()->str() == "[") || parent->astParent()->isUnaryOp("*"))) {
+                    parent = parent->astParent();
+                    if (parent->str() == "[") {
+                        if (const Token *errorToken = checkExpr(parent->astOperand2(), var, *alloc, number_of_if==0)) {
+                            if (!suppressErrors)
+                                uninitvarError(errorToken, errorToken->expressionString(), *alloc);
+                            return true;
+                        }
+                    }
+                }
+                if (Token::simpleMatch(parent->astParent(), "=") && astIsLHS(parent)) {
+                    const Token *eq = parent->astParent();
+                    if (const Token *errorToken = checkExpr(eq->astOperand2(), var, *alloc, number_of_if==0)) {
+                        if (!suppressErrors)
+                            uninitvarError(errorToken, errorToken->expressionString(), *alloc);
+                        return true;
+                    }
+                }
 
-                    // assume that variable is assigned
+                // assume that variable is assigned
+                if (!Token::simpleMatch(tok->astParent(), "<<"))
                     return true;
-                }
             }
         }
     }
@@ -773,6 +853,35 @@ bool CheckUninitVar::checkScopeForVariable(const Token *tok, const Variable& var
     return false;
 }
 
+const Token* CheckUninitVar::checkExpr(const Token* tok, const Variable& var, const Alloc alloc, bool known, bool* bailout) const
+{
+    if (!tok)
+        return nullptr;
+    if (isUnevaluated(tok->previous()))
+        return nullptr;
+
+    if (tok->astOperand1()) {
+        bool bailout1 = false;
+        const Token *errorToken = checkExpr(tok->astOperand1(), var, alloc, known, &bailout1);
+        if (bailout && bailout1)
+            *bailout = true;
+        if (errorToken)
+            return errorToken;
+        if ((bailout1 || !known) && Token::Match(tok, "%oror%|&&|?"))
+            return nullptr;
+    }
+    if (tok->astOperand2())
+        return checkExpr(tok->astOperand2(), var, alloc, known, bailout);
+    if (tok->varId() == var.declarationId()) {
+        const Token *errorToken = isVariableUsage(tok, var.isPointer(), alloc);
+        if (errorToken)
+            return errorToken;
+        if (bailout)
+            *bailout = true;
+    }
+    return nullptr;
+}
+
 bool CheckUninitVar::checkIfForWhileHead(const Token *startparentheses, const Variable& var, bool suppressErrors, bool isuninit, Alloc alloc, const std::string &membervar)
 {
     const Token * const endpar = startparentheses->link();
@@ -793,39 +902,116 @@ bool CheckUninitVar::checkIfForWhileHead(const Token *startparentheses, const Va
                 continue;
             }
 
-            if (isVariableUsage(tok, var.isPointer(), alloc)) {
+            if (const Token *errorToken = isVariableUsage(tok, var.isPointer(), alloc)) {
                 if (suppressErrors)
                     continue;
-                uninitvarError(tok, tok->str(), alloc);
+                uninitvarError(errorToken, errorToken->expressionString(), alloc);
             }
-            return true;
+            return !Token::Match(tok->astParent(), "!|%comp%");
         }
-        if (Token::Match(tok, "sizeof|decltype|offsetof ("))
-            tok = tok->next()->link();
+        // skip sizeof / offsetof
+        if (isUnevaluated(tok))
+            tok = tok->linkAt(1);
         if ((!isuninit || !membervar.empty()) && tok->str() == "&&")
             suppressErrors = true;
     }
     return false;
 }
 
-bool CheckUninitVar::checkLoopBody(const Token *tok, const Variable& var, const Alloc alloc, const std::string &membervar, const bool suppressErrors)
+/** recursively check loop, return error token */
+const Token* CheckUninitVar::checkLoopBodyRecursive(const Token *start, const Variable& var, const Alloc alloc, const std::string &membervar, bool &bailout, bool &alwaysReturns) const
 {
-    const Token *usetok = nullptr;
+    assert(start->str() == "{");
 
-    assert(tok->str() == "{");
+    const Token *errorToken = nullptr;
 
-    for (const Token * const end = tok->link(); tok != end; tok = tok->next()) {
-        if (Token::Match(tok, "sizeof|typeof (")) {
-            tok = tok->next()->link();
+    const Token *const end = start->link();
+    for (const Token *tok = start->next(); tok != end; tok = tok->next()) {
+        // skip sizeof / offsetof
+        if (isUnevaluated(tok)) {
+            tok = tok->linkAt(1);
             continue;
         }
 
-        if (Token::Match(tok, "asm ( %str% ) ;"))
-            return true;
+        if (Token::Match(tok, "asm ( %str% ) ;")) {
+            bailout = true;
+            return nullptr;
+        }
+
+        // for loop; skip third expression until loop body has been analyzed..
+        if (tok->str() == ";" && Token::simpleMatch(tok->astParent(), ";") && Token::simpleMatch(tok->astParent()->astParent(), "(")) {
+            const Token *top = tok->astParent()->astParent();
+            if (!Token::simpleMatch(top->previous(), "for (") || !Token::simpleMatch(top->link(), ") {"))
+                continue;
+            const Token *bodyStart = top->link()->next();
+            const Token *errorToken1 = checkLoopBodyRecursive(bodyStart, var, alloc, membervar, bailout, alwaysReturns);
+            if (!errorToken)
+                errorToken = errorToken1;
+            bailout |= alwaysReturns;
+            if (bailout)
+                return nullptr;
+        }
+        // for loop; skip loop body if there is third expression
+        if (Token::simpleMatch(tok, ") {") &&
+            Token::simpleMatch(tok->link()->previous(), "for (") &&
+            Token::simpleMatch(tok->link()->astOperand2(), ";") &&
+            Token::simpleMatch(tok->link()->astOperand2()->astOperand2(), ";")) {
+            tok = tok->linkAt(1);
+        }
+
+        if (tok->str() == "{") {
+            // switch => bailout
+            if (tok->scope() && tok->scope()->type == ScopeType::eSwitch) {
+                bailout = true;
+                return nullptr;
+            }
+
+            bool alwaysReturnsUnused = false;
+            const Token *errorToken1 = checkLoopBodyRecursive(tok, var, alloc, membervar, bailout, alwaysReturnsUnused);
+            tok = tok->link();
+            if (Token::simpleMatch(tok, "} else {")) {
+                const Token *elseBody = tok->tokAt(2);
+                const Token *errorToken2 = checkLoopBodyRecursive(elseBody, var, alloc, membervar, bailout, alwaysReturnsUnused);
+                tok = elseBody->link();
+                if (errorToken1 && errorToken2)
+                    return errorToken1;
+                if (errorToken2)
+                    errorToken = errorToken2;
+            }
+            if (bailout)
+                return nullptr;
+            if (!errorToken)
+                errorToken = errorToken1;
+        }
+
+        if (Token::simpleMatch(tok, "return")) {
+            bool returnWithoutVar = true;
+            while (tok && !Token::simpleMatch(tok, ";")) {
+                if (tok->isVariable() && tok->variable() == &var) {
+                    returnWithoutVar = false;
+                    break;
+                }
+                tok = tok->next();
+            }
+            if (returnWithoutVar) {
+                alwaysReturns = true;
+                return nullptr;
+            }
+        }
+        if (!tok)
+            break;
 
         if (tok->varId() != var.declarationId())
             continue;
 
+        bool conditionalUsage = false;
+        for (const Token* parent = tok; parent; parent = parent->astParent()) {
+            if (Token::Match(parent->astParent(), "%oror%|&&|?") && astIsRHS(parent)) {
+                conditionalUsage = true;
+                break;
+            }
+        }
+
         if (!membervar.empty()) {
             if (isMemberVariableAssignment(tok, membervar)) {
                 bool assign = true;
@@ -854,54 +1040,68 @@ bool CheckUninitVar::checkLoopBody(const Token *tok, const Variable& var, const
                         break;
                     }
                 }
-                if (assign)
-                    return true;
+                if (assign) {
+                    bailout = true;
+                    return nullptr;
+                }
+            }
+            if (isMemberVariableUsage(tok, var.isPointer(), alloc, membervar)) {
+                if (!conditionalUsage)
+                    return tok;
+                if (!errorToken)
+                    errorToken = tok;
+            } else if (Token::Match(tok->previous(), "[(,] %name% [,)]")) {
+                bailout = true;
+                return nullptr;
             }
-
-            if (isMemberVariableUsage(tok, var.isPointer(), alloc, membervar))
-                usetok = tok;
-            else if (Token::Match(tok->previous(), "[(,] %name% [,)]"))
-                return true;
         } else {
-            if (isVariableUsage(tok, var.isPointer(), alloc))
-                usetok = tok;
-            else if (tok->strAt(1) == "=") {
-                // Is var used in rhs?
-                bool rhs = false;
-                std::stack<const Token *> tokens;
-                tokens.push(tok->next()->astOperand2());
-                while (!tokens.empty()) {
-                    const Token *t = tokens.top();
-                    tokens.pop();
+            if (const Token *errtok = isVariableUsage(tok, var.isPointer(), alloc)) {
+                if (!conditionalUsage)
+                    return errtok;
+                if (!errorToken)
+                    errorToken = errtok;
+            } else if (tok->strAt(1) == "=") {
+                bool varIsUsedInRhs = false;
+                visitAstNodes(tok->next()->astOperand2(), [&](const Token * t) {
                     if (!t)
-                        continue;
+                        return ChildrenToVisit::none;
                     if (t->varId() == var.declarationId()) {
-                        // var is used in rhs
-                        rhs = true;
-                        break;
+                        varIsUsedInRhs = true;
+                        return ChildrenToVisit::done;
                     }
-                    if (Token::simpleMatch(t->previous(),"sizeof ("))
-                        continue;
-                    tokens.push(t->astOperand1());
-                    tokens.push(t->astOperand2());
+                    if (isUnevaluated(t->previous()))
+                        return ChildrenToVisit::none;
+                    return ChildrenToVisit::op1_and_op2;
+                });
+                if (!varIsUsedInRhs) {
+                    bailout = true;
+                    return nullptr;
                 }
-                if (!rhs)
-                    return true;
             } else {
-                return true;
+                bailout = true;
+                return nullptr;
             }
         }
     }
 
-    if (!suppressErrors && usetok) {
+    return errorToken;
+}
+
+bool CheckUninitVar::checkLoopBody(const Token *tok, const Variable& var, const Alloc alloc, const std::string &membervar, const bool suppressErrors)
+{
+    bool bailout = false;
+    bool alwaysReturns = false;
+    const Token *errorToken = checkLoopBodyRecursive(tok, var, alloc, membervar, bailout, alwaysReturns);
+
+    if (!suppressErrors && !bailout && !alwaysReturns && errorToken) {
         if (membervar.empty())
-            uninitvarError(usetok, usetok->str(), alloc);
+            uninitvarError(errorToken, errorToken->expressionString(), alloc);
         else
-            uninitStructMemberError(usetok, usetok->str() + "." + membervar);
+            uninitStructMemberError(errorToken, errorToken->expressionString() + "." + membervar);
         return true;
     }
 
-    return false;
+    return bailout || alwaysReturns;
 }
 
 void CheckUninitVar::checkRhs(const Token *tok, const Variable &var, Alloc alloc, nonneg int number_of_if, const std::string &membervar)
@@ -918,6 +1118,8 @@ void CheckUninitVar::checkRhs(const Token *tok, const Variable &var, Alloc alloc
                 uninitStructMemberError(tok, tok->str() + "." + membervar);
             else if (Token::Match(tok, "%var% ="))
                 break;
+            else if (Token::Match(tok->previous(), "[(,&]"))
+                break;
         } else if (tok->str() == ";" || (indent==0 && tok->str() == ","))
             break;
         else if (tok->str() == "(")
@@ -933,181 +1135,229 @@ void CheckUninitVar::checkRhs(const Token *tok, const Variable &var, Alloc alloc
             if (err)
                 uninitvarError(tok, var.nameToken()->str(), alloc);
             break;
-        } else if (Token::simpleMatch(tok, "sizeof ("))
-            tok = tok->next()->link();
+        } else if (isUnevaluated(tok))
+            tok = tok->linkAt(1);
+
     }
 }
 
-bool CheckUninitVar::isVariableUsage(const Token *vartok, bool pointer, Alloc alloc) const
+static bool astIsLhs(const Token *tok)
 {
-    if (alloc == NO_ALLOC && ((Token::Match(vartok->previous(), "return|delete %var% !!=")) || (vartok->strAt(-1) == "]" && vartok->linkAt(-1)->strAt(-1) == "delete")))
-        return true;
-
-    // Passing variable to typeof/__alignof__
-    if (Token::Match(vartok->tokAt(-3), "typeof|__alignof__ ( * %name%"))
-        return false;
-
-    // Accessing Rvalue member using "." or "->"
-    if (Token::Match(vartok->previous(), "!!& %var% .")) {
-        // Is struct member passed to function?
-        if (!pointer)
-            return false;
+    return tok && tok->astParent() && tok == tok->astParent()->astOperand1();
+}
 
-        if (alloc != CTOR_CALL && Token::Match(vartok, "%name% . %name% ("))
-            return true;
+static bool astIsRhs(const Token *tok)
+{
+    return tok && tok->astParent() && tok == tok->astParent()->astOperand2();
+}
 
-        bool assignment = false;
-        const Token* parent = vartok->astParent();
-        while (parent) {
-            if (parent->str() == "=") {
-                assignment = true;
-                break;
-            }
-            if (alloc != NO_ALLOC && parent->str() == "(") {
-                if (!mSettings->library.isFunctionConst(parent->strAt(-1), true)) {
-                    assignment = true;
-                    break;
-                }
-            }
-            parent = parent->astParent();
-        }
-        if (!assignment)
-            return true;
+const Token* CheckUninitVar::isVariableUsage(const Token *vartok, const Library& library, bool pointer, Alloc alloc, int indirect)
+{
+    const bool cpp = vartok->isCpp();
+    const Token *valueExpr = vartok;   // non-dereferenced , no address of value as variable
+    while (Token::Match(valueExpr->astParent(), ".|::") && astIsRhs(valueExpr))
+        valueExpr = valueExpr->astParent();
+    // stuff we ignore..
+    while (valueExpr->astParent()) {
+        // *&x
+        if (valueExpr->astParent()->isUnaryOp("&") && valueExpr->astParent()->astParent() && valueExpr->astParent()->astParent()->isUnaryOp("*"))
+            valueExpr = valueExpr->astParent()->astParent();
+        // (type &)x
+        else if (valueExpr->astParent()->isCast() && valueExpr->astParent()->isUnaryOp("(") && Token::simpleMatch(valueExpr->astParent()->link()->previous(), "& )"))
+            valueExpr = valueExpr->astParent();
+        // designated initializers: {.x | { ... , .x
+        else if (Token::simpleMatch(valueExpr->astParent(), ".") &&
+                 Token::Match(valueExpr->astParent()->previous(), ",|{"))
+            valueExpr = valueExpr->astParent();
+        else
+            break;
     }
-
-    // Passing variable to function..
-    {
-        bool unknown = false;
-        const Token *possibleParent = getAstParentSkipPossibleCastAndAddressOf(vartok, &unknown);
-        if (possibleParent && possibleParent->isUnaryOp("*")) {
-            while (possibleParent && possibleParent->isUnaryOp("*"))
-                possibleParent = getAstParentSkipPossibleCastAndAddressOf(possibleParent, &unknown);
-            if (possibleParent && Token::Match(possibleParent->previous(), "decltype|sizeof ("))
-                return false;
+    if (!pointer) {
+        if (Token::Match(vartok, "%name% [.(]") && vartok->variable() && !vartok->variable()->isPointer())
+            return nullptr;
+        while (Token::simpleMatch(valueExpr->astParent(), ".") && astIsLhs(valueExpr) && valueExpr->astParent()->valueType() && valueExpr->astParent()->valueType()->pointer == 0)
+            valueExpr = valueExpr->astParent();
+    }
+    const Token *derefValue = nullptr; // dereferenced value expression
+    if (alloc != NO_ALLOC) {
+        const int arrayDim = (vartok->variable() && vartok->variable()->isArray()) ? vartok->variable()->dimensions().size() : 1;
+        int deref = 0;
+        derefValue = valueExpr;
+        while (Token::Match(derefValue->astParent(), "+|-|*|[|.") ||
+               (derefValue->astParent() && derefValue->astParent()->isCast()) ||
+               (deref < arrayDim && Token::simpleMatch(derefValue->astParent(), "&") && derefValue->astParent()->isBinaryOp())) {
+            const Token * const derefValueParent = derefValue->astParent();
+            if (derefValueParent->str() == "*") {
+                if (derefValueParent->isUnaryOp("*"))
+                    ++deref;
+                else
+                    break;
+            } else if (derefValueParent->str() == "[") {
+                if (astIsLhs(derefValue))
+                    ++deref;
+                else
+                    break;
+            } else if (Token::Match(derefValueParent, "[+-]")) {
+                if (deref >= arrayDim)
+                    break;
+            } else if (derefValueParent->str() == ".")
+                ++deref;
+            derefValue = derefValueParent;
+            if (deref < arrayDim)
+                valueExpr = derefValue;
         }
-        if (Token::Match(possibleParent, "[(,]")) {
-            if (unknown)
-                return false; // TODO: output some info message?
-            const int use = isFunctionParUsage(vartok, pointer, alloc);
-            if (use >= 0)
-                return (use>0);
+        if (deref < arrayDim) {
+            // todo compare deref with array dimensions
+            derefValue = nullptr;
         }
-
-        else if (!pointer && Token::simpleMatch(possibleParent, "=") && vartok->astParent()->str() == "&") {
-            return false;
+    } else if (vartok->astParent() && vartok->astParent()->isUnaryOp("&")) {
+        const Token *child = vartok->astParent();
+        const Token *parent = child->astParent();
+        while (parent && (parent->isCast() || parent->str() == "+")) {
+            child = parent;
+            parent = child->astParent();
         }
+        if (parent && (parent->isUnaryOp("*") || (parent->str() == "[" && astIsLhs(child))))
+            derefValue = parent;
     }
 
-    {
-        const Token *parent = vartok->astParent();
-        while (parent && parent->isCast())
-            parent = parent->astParent();
-        while (parent && parent->str() == ",")
-            parent = parent->astParent();
-        if (Token::simpleMatch(parent, "{"))
-            return true;
-    }
-
-    if (Token::Match(vartok->previous(), "++|--|%cop%")) {
-        if (mTokenizer->isCPP() && alloc == ARRAY && Token::Match(vartok->tokAt(-4), "& %var% =|( *"))
-            return false;
+    if (!valueExpr->astParent())
+        return nullptr;
 
-        if (isLikelyStreamRead(mTokenizer->isCPP(), vartok->previous()))
-            return false;
+    // FIXME handle address of!!
+    if (derefValue && derefValue->astParent() && derefValue->astParent()->isUnaryOp("&"))
+        return nullptr;
 
-        if (mTokenizer->isCPP() && Token::simpleMatch(vartok->previous(), "<<")) {
-            const Token* tok2 = vartok->previous();
+    // BAILOUT for binary & without parent
+    if (Token::simpleMatch(valueExpr->astParent(), "&") && astIsRhs(valueExpr) && Token::Match(valueExpr->astParent()->tokAt(-3), "( %name% ) &"))
+        return nullptr;
 
-            // Looks like stream operator, but could also initialize the variable. Check lhs.
-            do {
-                tok2 = tok2->astOperand1();
-            } while (Token::simpleMatch(tok2, "<<"));
-            if (tok2 && tok2->strAt(-1) == "::")
-                tok2 = tok2->previous();
-            if (tok2 && (Token::simpleMatch(tok2->previous(), "std ::") || (tok2->variable() && tok2->variable()->isStlType()) || tok2->isStandardType() || tok2->isEnumType()))
-                return true;
+    // safe operations
+    if (isVoidCast(valueExpr->astParent()))
+        return nullptr;
+    if (Token::simpleMatch(valueExpr->astParent(), ".")) {
+        const Token *parent = valueExpr->astParent();
+        while (Token::simpleMatch(parent, "."))
+            parent = parent->astParent();
+        if (isVoidCast(parent))
+            return nullptr;
+    }
+    if (alloc != NO_ALLOC) {
+        if (Token::Match(valueExpr->astParent(), "%comp%|%oror%|&&|?|!|%"))
+            return nullptr;
+        if (Token::Match(valueExpr->astParent(), "%or%|&") && valueExpr->astParent()->isBinaryOp())
+            return nullptr;
+        if (alloc == CTOR_CALL && derefValue && Token::simpleMatch(derefValue->astParent(), "(") && astIsLhs(derefValue))
+            return nullptr;
+        if (Token::simpleMatch(valueExpr->astParent(), "return"))
+            return nullptr;
+    }
 
-            const Variable *var = vartok->tokAt(-2)->variable();
-            return (var && (var->typeStartToken()->isStandardType() || var->typeStartToken()->isEnumType()));
+    // Passing variable to function..
+    if (Token::Match(valueExpr->astParent(), "[(,]") && (valueExpr->astParent()->str() == "," || astIsRhs(valueExpr))) {
+        const Token *parent = valueExpr->astParent();
+        while (Token::simpleMatch(parent, ","))
+            parent = parent->astParent();
+        if (Token::simpleMatch(parent, "{"))
+            return valueExpr;
+        const int use = isFunctionParUsage(valueExpr, library, pointer, alloc, indirect);
+        return (use>0) ? valueExpr : nullptr;
+    }
+    if (derefValue && Token::Match(derefValue->astParent(), "[(,]") && (derefValue->astParent()->str() == "," || astIsRhs(derefValue))) {
+        const int use = isFunctionParUsage(derefValue, library, false, NO_ALLOC, indirect);
+        return (use>0) ? derefValue : nullptr;
+    }
+    if (valueExpr->astParent()->isUnaryOp("&")) {
+        const Token *parent = valueExpr->astParent();
+        if (Token::Match(parent->astParent(), "[(,]") && (parent->astParent()->str() == "," || astIsRhs(parent))) {
+            const int use = isFunctionParUsage(valueExpr, library, pointer, alloc, indirect);
+            return (use>0) ? valueExpr : nullptr;
         }
+        return nullptr;
+    }
 
-        // is there something like: ; "*((&var ..expr.. ="  => the variable is assigned
-        if (vartok->previous()->str() == "&" && !vartok->previous()->astOperand2())
-            return false;
-
-        // bailout to avoid fp for 'int x = 2 + x();' where 'x()' is a unseen preprocessor macro (seen in linux)
-        if (!pointer && vartok->next() && vartok->next()->str() == "(")
-            return false;
-
-        if (vartok->previous()->str() != "&" || !Token::Match(vartok->tokAt(-2), "[(,=?:]")) {
-            if (alloc != NO_ALLOC && vartok->previous()->str() == "*") {
-                // TestUninitVar::isVariableUsageDeref()
-                const Token *parent = vartok->previous()->astParent();
-                if (parent && parent->str() == "=" && parent->astOperand1() == vartok->previous())
-                    return false;
-                if (vartok->variable() && vartok->variable()->dimensions().size() >= 2)
-                    return false;
-                return true;
+    // Assignments;
+    // * Is this LHS in assignment
+    // * Passing address in RHS to pointer variable
+    {
+        const Token *tok = derefValue ? derefValue : valueExpr;
+        if (alloc == NO_ALLOC) {
+            while (tok->valueType() && tok->valueType()->pointer == 0 && Token::simpleMatch(tok->astParent(), "."))
+                tok = tok->astParent();
+        }
+        if (Token::simpleMatch(tok->astParent(), "=")) {
+            if (astIsLhs(tok)) {
+                if (alloc == ARRAY || !derefValue || !derefValue->isUnaryOp("*") || !pointer)
+                    return nullptr;
+                const Token* deref = derefValue->astOperand1();
+                while (deref && deref->isCast())
+                    deref = deref->astOperand1();
+                if (deref == vartok || Token::simpleMatch(deref, "+"))
+                    return nullptr;
             }
-            return alloc == NO_ALLOC;
+            if (alloc != NO_ALLOC && astIsRhs(valueExpr))
+                return nullptr;
         }
     }
 
-    if (alloc == NO_ALLOC && Token::Match(vartok->previous(), "%assign% %name% %cop%|;|)")) {
-        // taking reference?
-        const Token *prev = vartok->tokAt(-2);
-        while (Token::Match(prev, "%name%|*"))
-            prev = prev->previous();
-        if (!Token::simpleMatch(prev, "&"))
-            return true;
+    // Initialize reference variable
+    if (Token::Match((derefValue ? derefValue : vartok)->astParent(), "(|=") && astIsRhs(derefValue ? derefValue : vartok)) {
+        const Token *rhstok = derefValue ? derefValue : vartok;
+        const Token *lhstok = rhstok->astParent()->astOperand1();
+        const Variable *lhsvar = lhstok ? lhstok->variable() : nullptr;
+        if (lhsvar && lhsvar->isReference() && lhsvar->nameToken() == lhstok)
+            return nullptr;
     }
 
-    bool unknown = false;
-    if (pointer && alloc == NO_ALLOC && CheckNullPointer::isPointerDeRef(vartok, unknown, mSettings)) {
-        // function parameter?
-        bool functionParameter = false;
-        if (Token::Match(vartok->tokAt(-2), "%name% (") || vartok->previous()->str() == ",")
-            functionParameter = true;
-
-        // if this is not a function parameter report this dereference as variable usage
-        if (!functionParameter)
-            return true;
-    } else if (alloc != NO_ALLOC && Token::Match(vartok, "%var% [")) {
-        const Token *parent = vartok->next()->astParent();
-        while (Token::Match(parent, "[|."))
-            parent = parent->astParent();
-        if (Token::simpleMatch(parent, "&") && !parent->astOperand2())
-            return false;
-        if (parent && Token::Match(parent->previous(), "if|while|switch ("))
-            return true;
-        if (Token::Match(parent, "[=,(]"))
-            return false;
-        return true;
+    // range for loop
+    if (Token::simpleMatch(valueExpr->astParent(), ":") &&
+        valueExpr->astParent()->astParent() &&
+        Token::simpleMatch(valueExpr->astParent()->astParent()->previous(), "for (")) {
+        if (astIsLhs(valueExpr))
+            return nullptr;
+        // Taking value by reference?
+        const Token *lhs = valueExpr->astParent()->astOperand1();
+        if (lhs && lhs->variable() && lhs->variable()->nameToken() == lhs && lhs->variable()->isReference())
+            return nullptr;
     }
 
-    if (mTokenizer->isCPP() && Token::simpleMatch(vartok->next(), "<<")) {
-        // Is this calculation done in rhs?
-        const Token *tok = vartok;
-        while (Token::Match(tok, "%name%|.|::"))
-            tok = tok->previous();
-        if (Token::Match(tok, "[;{}]"))
-            return false;
-
-        // Is variable a known POD type then this is a variable usage,
-        // otherwise we assume it's not.
-        return (vartok->valueType() && vartok->valueType()->isIntegral());
+    // Stream read/write
+    // FIXME this code is a hack!!
+    if (cpp && Token::Match(valueExpr->astParent(), "<<|>>")) {
+        if (isLikelyStreamRead(vartok->previous()))
+            return nullptr;
+
+        if (const auto* vt = valueExpr->valueType()) {
+            if (vt->type == ValueType::Type::VOID)
+                return nullptr;
+            // passing a char* to a stream will dereference it
+            if ((alloc == CTOR_CALL || alloc == ARRAY) && vt->pointer && vt->type != ValueType::Type::CHAR && vt->type != ValueType::Type::WCHAR_T)
+                return nullptr;
+        }
     }
+    if (astIsRhs(derefValue) && isLikelyStreamRead(derefValue->astParent()))
+        return nullptr;
 
-    if (alloc == NO_ALLOC && vartok->next() && vartok->next()->isOp() && !vartok->next()->isAssignmentOp())
-        return true;
-
-    if (alloc == NO_ALLOC && vartok->next() && vartok->next()->isAssignmentOp() && vartok->next()->str() != "=")
-        return true;
+    // Assignment with overloaded &
+    if (cpp && Token::simpleMatch(valueExpr->astParent(), "&") && astIsRhs(valueExpr)) {
+        const Token *parent = valueExpr->astParent();
+        while (Token::simpleMatch(parent, "&") && parent->isBinaryOp())
+            parent = parent->astParent();
+        if (!parent) {
+            const Token *lhs = valueExpr->astParent();
+            while (Token::simpleMatch(lhs, "&") && lhs->isBinaryOp())
+                lhs = lhs->astOperand1();
+            if (lhs && lhs->isName() && (!lhs->valueType() || lhs->valueType()->type <= ValueType::Type::CONTAINER))
+                return nullptr; // <- possible assignment
+        }
+    }
 
-    if (vartok->strAt(1) == "]")
-        return true;
+    return derefValue ? derefValue : valueExpr;
+}
 
-    return false;
+const Token* CheckUninitVar::isVariableUsage(const Token *vartok, bool pointer, Alloc alloc, int indirect) const
+{
+    return isVariableUsage(vartok, mSettings->library, pointer, alloc, indirect);
 }
 
 /***
@@ -1116,7 +1366,7 @@ bool CheckUninitVar::isVariableUsage(const Token *vartok, bool pointer, Alloc al
  * is passed "by reference" then it is not necessarily "used".
  * @return  -1 => unknown   0 => not used   1 => used
  */
-int CheckUninitVar::isFunctionParUsage(const Token *vartok, bool pointer, Alloc alloc) const
+int CheckUninitVar::isFunctionParUsage(const Token *vartok, const Library& library, bool pointer, Alloc alloc, int indirect)
 {
     bool unknown = false;
     const Token *parent = getAstParentSkipPossibleCastAndAddressOf(vartok, &unknown);
@@ -1141,7 +1391,7 @@ int CheckUninitVar::isFunctionParUsage(const Token *vartok, bool pointer, Alloc
 
     // is this a function call?
     if (Token::Match(start->previous(), "%name% (")) {
-        const bool address(vartok->previous()->str() == "&");
+        const bool address(vartok->strAt(-1) == "&");
         const bool array(vartok->variable() && vartok->variable()->isArray());
         // check how function handle uninitialized data arguments..
         const Function *func = start->previous()->function();
@@ -1161,8 +1411,6 @@ int CheckUninitVar::isFunctionParUsage(const Token *vartok, bool pointer, Alloc
                         return -1;
                     return 1;
                 }
-                if ((pointer || address) && alloc == NO_ALLOC && Token::Match(argStart, "const struct| %type% * %name% [,)]"))
-                    return 1;
                 if ((pointer || address) && Token::Match(argStart, "const %type% %name% [") && Token::Match(argStart->linkAt(3), "] [,)]"))
                     return 1;
             }
@@ -1171,12 +1419,13 @@ int CheckUninitVar::isFunctionParUsage(const Token *vartok, bool pointer, Alloc
             // control-flow statement reading the variable "by value"
             return alloc == NO_ALLOC;
         } else {
-            const bool isnullbad = mSettings->library.isnullargbad(start->previous(), argumentNumber + 1);
-            if (pointer && !address && isnullbad && alloc == NO_ALLOC)
+            const bool isnullbad = library.isnullargbad(start->previous(), argumentNumber + 1);
+            if (indirect == 0 && pointer && !address && isnullbad && alloc == NO_ALLOC)
                 return 1;
-            const bool isuninitbad = mSettings->library.isuninitargbad(start->previous(), argumentNumber + 1);
+            bool hasIndirect = false;
+            const bool isuninitbad = library.isuninitargbad(start->previous(), argumentNumber + 1, indirect, &hasIndirect);
             if (alloc != NO_ALLOC)
-                return isnullbad && isuninitbad;
+                return (isnullbad || hasIndirect) && isuninitbad;
             return isuninitbad && (!address || isnullbad);
         }
     }
@@ -1185,16 +1434,21 @@ int CheckUninitVar::isFunctionParUsage(const Token *vartok, bool pointer, Alloc
     return -1;
 }
 
+int CheckUninitVar::isFunctionParUsage(const Token *vartok, bool pointer, Alloc alloc, int indirect) const
+{
+    return CheckUninitVar::isFunctionParUsage(vartok, mSettings->library, pointer, alloc, indirect);
+}
+
 bool CheckUninitVar::isMemberVariableAssignment(const Token *tok, const std::string &membervar) const
 {
     if (Token::Match(tok, "%name% . %name%") && tok->strAt(2) == membervar) {
         if (Token::Match(tok->tokAt(3), "[=.[]"))
             return true;
-        else if (Token::Match(tok->tokAt(-2), "[(,=] &"))
+        if (Token::Match(tok->tokAt(-2), "[(,=] &"))
             return true;
-        else if (isLikelyStreamRead(mTokenizer->isCPP(), tok->previous()))
+        if (isLikelyStreamRead(tok->previous()))
             return true;
-        else if ((tok->previous() && tok->previous()->isConstOp()) || Token::Match(tok->previous(), "[|="))
+        if ((tok->previous() && tok->previous()->isConstOp()) || Token::Match(tok->previous(), "[|="))
             ; // member variable usage
         else if (tok->tokAt(3)->isConstOp())
             ; // member variable usage
@@ -1234,7 +1488,7 @@ bool CheckUninitVar::isMemberVariableAssignment(const Token *tok, const std::str
                     const Library::ArgumentChecks::Direction argDirection = mSettings->library.getArgDirection(ftok, 1 + argumentNumber);
                     if (argDirection == Library::ArgumentChecks::Direction::DIR_IN)
                         return false;
-                    else if (argDirection == Library::ArgumentChecks::Direction::DIR_OUT)
+                    if (argDirection == Library::ArgumentChecks::Direction::DIR_OUT)
                         return true;
                 }
 
@@ -1268,47 +1522,87 @@ bool CheckUninitVar::isMemberVariableUsage(const Token *tok, bool isPointer, All
 
     if (Token::Match(tok, "%name% . %name%") && tok->strAt(2) == membervar && !(tok->tokAt(-2)->variable() && tok->tokAt(-2)->variable()->isReference())) {
         const Token *parent = tok->next()->astParent();
-        if (parent && parent->isUnaryOp("&"))
-            return false;
-        return true;
-    } else if (!isPointer && Token::Match(tok->previous(), "[(,] %name% [,)]") && isVariableUsage(tok, isPointer, alloc))
+        return !parent || !parent->isUnaryOp("&");
+    }
+    if (!isPointer && !Token::simpleMatch(tok->astParent(), ".") && Token::Match(tok->previous(), "[(,] %name% [,)]") && isVariableUsage(tok, isPointer, alloc))
         return true;
 
-    else if (!isPointer && Token::Match(tok->previous(), "= %name% ;"))
-        return true;
+    if (!isPointer && Token::Match(tok->previous(), "= %name% ;")) {
+        const Token* lhs = tok->previous()->astOperand1();
+        return !(lhs && lhs->variable() && lhs->variable()->isReference() && lhs == lhs->variable()->nameToken());
+    }
 
     // = *(&var);
-    else if (!isPointer &&
-             Token::simpleMatch(tok->astParent(),"&") &&
-             Token::simpleMatch(tok->astParent()->astParent(),"*") &&
-             Token::Match(tok->astParent()->astParent()->astParent(), "= * (| &") &&
-             tok->astParent()->astParent()->astParent()->astOperand2() == tok->astParent()->astParent())
+    if (!isPointer &&
+        Token::simpleMatch(tok->astParent(),"&") &&
+        Token::simpleMatch(tok->astParent()->astParent(),"*") &&
+        Token::Match(tok->astParent()->astParent()->astParent(), "= * (| &") &&
+        tok->astParent()->astParent()->astParent()->astOperand2() == tok->astParent()->astParent())
         return true;
 
-    else if (mSettings->experimental &&
-             !isPointer &&
-             Token::Match(tok->tokAt(-2), "[(,] & %name% [,)]") &&
-             isVariableUsage(tok, isPointer, alloc))
+    // TODO: this used to be experimental - enable or remove see #5586
+    if ((false) && // NOLINT(readability-simplify-boolean-expr,readability-redundant-parentheses)
+        !isPointer &&
+        Token::Match(tok->tokAt(-2), "[(,] & %name% [,)]") &&
+        isVariableUsage(tok, isPointer, alloc))
         return true;
 
     return false;
 }
 
-void CheckUninitVar::uninitstringError(const Token *tok, const std::string &varname, bool strncpy_)
+void CheckUninitVar::uninitdataError(const Token *tok, const std::string &varname)
 {
-    reportError(tok, Severity::error, "uninitstring", "$symbol:" + varname + "\nDangerous usage of '$symbol'" + (strncpy_ ? " (strncpy doesn't always null-terminate it)." : " (not null-terminated)."), CWE676, false);
+    reportError(tok, Severity::error, "uninitdata", "$symbol:" + varname + "\nMemory is allocated but not initialized: $symbol", CWE_USE_OF_UNINITIALIZED_VARIABLE, Certainty::normal);
 }
 
-void CheckUninitVar::uninitdataError(const Token *tok, const std::string &varname)
+void CheckUninitVar::uninitvarError(const Token *tok, const std::string &varname, ErrorPath errorPath)
 {
-    reportError(tok, Severity::error, "uninitdata", "$symbol:" + varname + "\nMemory is allocated but not initialized: $symbol", CWE908, false);
+    if (diag(tok))
+        return;
+    errorPath.emplace_back(tok, "");
+    reportError(std::move(errorPath),
+                Severity::error,
+                "legacyUninitvar",
+                "$symbol:" + varname + "\nUninitialized variable: $symbol",
+                CWE_USE_OF_UNINITIALIZED_VARIABLE,
+                Certainty::normal);
 }
 
-void CheckUninitVar::uninitvarError(const Token *tok, const std::string &varname, ErrorPath errorPath)
+void CheckUninitVar::uninitvarError(const Token* tok, const ValueFlow::Value& v)
 {
+    if (!mSettings->isEnabled(&v))
+        return;
+    if (diag(tok))
+        return;
+    const Token* ltok = tok;
+    if (tok && Token::simpleMatch(tok->astParent(), ".") && astIsRHS(tok))
+        ltok = tok->astParent();
+    const std::string& varname = ltok ? ltok->expressionString() : "x";
+    ErrorPath errorPath = v.errorPath;
     errorPath.emplace_back(tok, "");
-    reportError(errorPath, Severity::error, "uninitvar", "$symbol:" + varname + "\nUninitialized variable: $symbol", CWE908, false);
-    // reportError(tok, Severity::error, "uninitvar", "$symbol:" + varname + "\nUninitialized variable: $symbol", CWE908, false);
+    auto severity = v.isKnown() ? Severity::error : Severity::warning;
+    auto certainty = v.isInconclusive() ? Certainty::inconclusive : Certainty::normal;
+    if (v.subexpressions.empty()) {
+        reportError(std::move(errorPath),
+                    severity,
+                    "uninitvar",
+                    "$symbol:" + varname + "\nUninitialized variable: $symbol",
+                    CWE_USE_OF_UNINITIALIZED_VARIABLE,
+                    certainty);
+        return;
+    }
+    std::string vars = v.subexpressions.size() == 1 ? "variable: " : "variables: ";
+    std::string prefix;
+    for (const std::string& var : v.subexpressions) {
+        vars += prefix + varname + "." + var;
+        prefix = ", ";
+    }
+    reportError(std::move(errorPath),
+                severity,
+                "uninitvar",
+                "$symbol:" + varname + "\nUninitialized " + vars,
+                CWE_USE_OF_UNINITIALIZED_VARIABLE,
+                certainty);
 }
 
 void CheckUninitVar::uninitStructMemberError(const Token *tok, const std::string &membername)
@@ -1316,96 +1610,131 @@ void CheckUninitVar::uninitStructMemberError(const Token *tok, const std::string
     reportError(tok,
                 Severity::error,
                 "uninitStructMember",
-                "$symbol:" + membername + "\nUninitialized struct member: $symbol", CWE908, false);
-}
-
-static bool isLeafDot(const Token* tok)
-{
-    if (!tok)
-        return false;
-    const Token * parent = tok->astParent();
-    if (!Token::simpleMatch(parent, "."))
-        return false;
-    if (parent->astOperand2() == tok)
-        return true;
-    return isLeafDot(parent);
+                "$symbol:" + membername + "\nUninitialized struct member: $symbol", CWE_USE_OF_UNINITIALIZED_VARIABLE, Certainty::normal);
 }
 
 void CheckUninitVar::valueFlowUninit()
 {
+    logChecker("CheckUninitVar::valueFlowUninit");
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
-    // check every executable scope
-    for (const Scope &scope : symbolDatabase->scopeList) {
-        if (!scope.isExecutable())
-            continue;
-        for (const Token* tok = scope.bodyStart; tok != scope.bodyEnd; tok = tok->next()) {
-            if (Token::simpleMatch(tok, "sizeof (")) {
-                tok = tok->linkAt(1);
-                continue;
-            }
-            if (!tok->variable() && !tok->isUnaryOp("*"))
-                continue;
-            auto v = std::find_if(tok->values().begin(), tok->values().end(), std::mem_fn(&ValueFlow::Value::isUninitValue));
-            if (v == tok->values().end())
-                continue;
-            if (v->isInconclusive())
-                continue;
-            if (v->indirect > 1 || v->indirect < 0)
-                continue;
-            bool uninitderef = false;
-            if (tok->variable()) {
-                if (!isVariableUsage(tok, tok->variable()->isPointer(), tok->variable()->isArray() ? ARRAY : NO_ALLOC))
+    std::unordered_set<nonneg int> ids;
+    for (const bool subfunction : {false, true}) {
+        // check every executable scope
+        for (const Scope* scope : symbolDatabase->functionScopes) {
+            for (const Token* tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
+                if (isUnevaluated(tok)) {
+                    tok = tok->linkAt(1);
                     continue;
-                bool unknown;
-                const bool deref = CheckNullPointer::isPointerDeRef(tok, unknown, mSettings);
-                if (v->indirect == 1 && !deref)
+                }
+                if (ids.count(tok->exprId()) > 0)
                     continue;
-                uninitderef = deref && v->indirect == 0;
-                const bool isleaf = isLeafDot(tok) || uninitderef;
-                if (Token::Match(tok->astParent(), ". %var%") && !isleaf)
+                if (!tok->variable() && !tok->isUnaryOp("*") && !tok->isUnaryOp("&"))
                     continue;
+                if (Token::Match(tok, "%name% ("))
+                    continue;
+                const Token* parent = tok->astParent();
+                while (Token::simpleMatch(parent, "."))
+                    parent = parent->astParent();
+                if (parent && parent->isUnaryOp("&"))
+                    continue;
+                if (isVoidCast(parent))
+                    continue;
+                auto v = std::find_if(
+                    tok->values().cbegin(), tok->values().cend(), std::mem_fn(&ValueFlow::Value::isUninitValue));
+                if (v == tok->values().cend())
+                    continue;
+                if (v->tokvalue && ids.count(v->tokvalue->exprId()) > 0)
+                    continue;
+                if (subfunction == (v->path == 0))
+                    continue;
+                if (v->isInconclusive())
+                    continue;
+                if (v->indirect > 1 || v->indirect < 0)
+                    continue;
+                bool uninitderef = false;
+                if (tok->variable()) {
+                    bool unknown;
+                    const bool isarray = tok->variable()->isArray();
+                    if (isarray && tok->variable()->isMember())
+                        continue; // Todo: this is a bailout
+                    if (isarray && tok->variable()->isStlType() && Token::simpleMatch(tok->astParent(), ".")) {
+                        const auto yield = astContainerYield(tok, mSettings->library);
+                        if (yield != Library::Container::Yield::AT_INDEX && yield != Library::Container::Yield::ITEM)
+                            continue;
+                    }
+                    const bool deref = CheckNullPointer::isPointerDeRef(tok, unknown, *mSettings);
+                    uninitderef = deref && v->indirect == 0;
+                    const bool isleaf = isLeafDot(tok) || uninitderef;
+                    if (!isleaf && Token::Match(tok->astParent(), ". %name%") &&
+                        (tok->astParent()->next()->variable() || tok->astParent()->next()->isEnumerator()))
+                        continue;
+                }
+                const ExprUsage usage = getExprUsage(tok, v->indirect, *mSettings);
+                if (usage == ExprUsage::NotUsed || usage == ExprUsage::Inconclusive)
+                    continue;
+                if (!v->subexpressions.empty() && usage == ExprUsage::PassedByReference)
+                    continue;
+                if (usage != ExprUsage::Used) {
+                    if (!(Token::Match(tok->astParent(), ". %name% (|[") && uninitderef) &&
+                        isVariableChanged(tok, v->indirect, *mSettings))
+                        continue;
+                    bool inconclusive = false;
+                    if (isVariableChangedByFunctionCall(tok, v->indirect, *mSettings, &inconclusive) || inconclusive)
+                        continue;
+                }
+                uninitvarError(tok, *v);
+                ids.insert(tok->exprId());
+                if (v->tokvalue)
+                    ids.insert(v->tokvalue->exprId());
             }
-            if (!Token::Match(tok->astParent(), ". %name% (") && !uninitderef && isVariableChanged(tok, v->indirect, mSettings, mTokenizer->isCPP()))
-                continue;
-            uninitvarError(tok, tok->expressionString(), v->errorPath);
-            const Token * nextTok = tok;
-            while (Token::simpleMatch(nextTok->astParent(), "."))
-                nextTok = nextTok->astParent();
-            nextTok = nextAfterAstRightmostLeaf(nextTok);
-            if (nextTok == scope.bodyEnd)
-                break;
-            tok = nextTok ? nextTok : tok;
         }
     }
 }
 
-std::string CheckUninitVar::MyFileInfo::toString() const
+// NOLINTNEXTLINE(readability-non-const-parameter) - used as callback so we need to preserve the signature
+static bool isVariableUsage(const Settings &settings, const Token *vartok, MathLib::bigint *value)
 {
-    return CTU::toString(unsafeUsage);
+    (void)value;
+    return CheckUninitVar::isVariableUsage(vartok, settings.library, true, CheckUninitVar::Alloc::ARRAY);
 }
 
-Check::FileInfo *CheckUninitVar::getFileInfo(const Tokenizer *tokenizer, const Settings *settings) const
+// a Clang-built executable will crash when using the anonymous MyFileInfo later on - so put it in a unique namespace for now
+// see https://trac.cppcheck.net/ticket/12108 for more details
+#ifdef __clang__
+inline namespace CheckUninitVar_internal
+#else
+namespace
+#endif
 {
-    const CheckUninitVar checker(tokenizer, settings, nullptr);
-    return checker.getFileInfo();
+    /* data for multifile checking */
+    class MyFileInfo : public Check::FileInfo {
+    public:
+        using Check::FileInfo::FileInfo;
+        /** function arguments that data are unconditionally read */
+        std::list<CTU::FileInfo::UnsafeUsage> unsafeUsage;
+
+        /** Convert data into xml string */
+        std::string toString() const override
+        {
+            return CTU::toString(unsafeUsage);
+        }
+    };
 }
 
-static bool isVariableUsage(const Check *check, const Token *vartok, MathLib::bigint *value)
-{
-    (void)value;
-    const CheckUninitVar *c = dynamic_cast<const CheckUninitVar *>(check);
-    return c && c->isVariableUsage(vartok, true, CheckUninitVar::Alloc::ARRAY);
+static bool isVariableUsage(const Settings &settings, const Token *argtok, CTU::FileInfo::Value *value) {
+    return isVariableUsage(settings, argtok, &value->value);
 }
 
-Check::FileInfo *CheckUninitVar::getFileInfo() const
+Check::FileInfo *CheckUninitVar::getFileInfo(const Tokenizer &tokenizer, const Settings &settings, const std::string& /*currentConfig*/) const
 {
-    const std::list<CTU::FileInfo::UnsafeUsage> &unsafeUsage = CTU::getUnsafeUsage(mTokenizer, mSettings, this, ::isVariableUsage);
+    const std::list<CTU::FileInfo::UnsafeUsage> &unsafeUsage = CTU::getUnsafeUsage(tokenizer, settings, ::isVariableUsage);
     if (unsafeUsage.empty())
         return nullptr;
 
-    MyFileInfo *fileInfo = new MyFileInfo;
-    fileInfo->unsafeUsage = unsafeUsage     ;
+    auto *fileInfo = new MyFileInfo(tokenizer.list.getFiles()[0]);
+    fileInfo->unsafeUsage = unsafeUsage;
     return fileInfo;
 }
 
@@ -1415,43 +1744,51 @@ Check::FileInfo * CheckUninitVar::loadFileInfoFromXml(const tinyxml2::XMLElement
     if (unsafeUsage.empty())
         return nullptr;
 
-    MyFileInfo *fileInfo = new MyFileInfo;
+    auto *fileInfo = new MyFileInfo;
     fileInfo->unsafeUsage = unsafeUsage;
     return fileInfo;
 }
 
-bool CheckUninitVar::analyseWholeProgram(const CTU::FileInfo *ctu, const std::list<Check::FileInfo*> &fileInfo, const Settings& settings, ErrorLogger &errorLogger)
+bool CheckUninitVar::analyseWholeProgram(const CTU::FileInfo &ctu, const std::list<Check::FileInfo*> &fileInfo, const Settings& settings, ErrorLogger &errorLogger)
 {
-    if (!ctu)
+    (void)settings;
+
+    CheckUninitVar dummy(nullptr, &settings, &errorLogger);
+    dummy.
+    logChecker("CheckUninitVar::analyseWholeProgram");
+
+    if (fileInfo.empty())
         return false;
-    bool foundErrors = false;
-    (void)settings; // This argument is unused
 
-    const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>> callsMap = ctu->getCallsMap();
+    const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>> callsMap = ctu.getCallsMap();
+
+    bool foundErrors = false;
 
-    for (Check::FileInfo *fi1 : fileInfo) {
-        const MyFileInfo *fi = dynamic_cast<MyFileInfo*>(fi1);
+    for (const Check::FileInfo* fi1 : fileInfo) {
+        const auto *fi = dynamic_cast<const MyFileInfo*>(fi1);
         if (!fi)
             continue;
         for (const CTU::FileInfo::UnsafeUsage &unsafeUsage : fi->unsafeUsage) {
             const CTU::FileInfo::FunctionCall *functionCall = nullptr;
 
-            const std::list<ErrorLogger::ErrorMessage::FileLocation> &locationList =
-                ctu->getErrorPath(CTU::FileInfo::InvalidValueType::uninit,
-                                  unsafeUsage,
-                                  callsMap,
-                                  "Using argument ARG",
-                                  &functionCall,
-                                  false);
+            std::list<ErrorMessage::FileLocation> locationList =
+                CTU::FileInfo::getErrorPath(CTU::FileInfo::InvalidValueType::uninit,
+                                            unsafeUsage,
+                                            callsMap,
+                                            "Using argument ARG",
+                                            &functionCall,
+                                            false,
+                                            settings.maxCtuDepth);
             if (locationList.empty())
                 continue;
 
-            const ErrorLogger::ErrorMessage errmsg(locationList,
-                                                   emptyString,
-                                                   Severity::error,
-                                                   "Using argument " + unsafeUsage.myArgumentName + " that points at uninitialized variable " + functionCall->callArgumentExpression,
-                                                   "ctuuninitvar",
-                                                   CWE908, false);
+            const ErrorMessage errmsg(std::move(locationList),
+                                      fi->file0,
+                                      Severity::error,
+                                      "Using argument " + unsafeUsage.myArgumentName + " that points at uninitialized variable " + functionCall->callArgumentExpression,
+                                      "ctuuninitvar",
+                                      CWE_USE_OF_UNINITIALIZED_VARIABLE,
+                                      Certainty::normal);
             errorLogger.reportErr(errmsg);
 
             foundErrors = true;
@@ -1459,3 +1796,21 @@ bool CheckUninitVar::analyseWholeProgram(const CTU::FileInfo *ctu, const std::li
     }
     return foundErrors;
 }
+
+void CheckUninitVar::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    CheckUninitVar checkUninitVar(&tokenizer, &tokenizer.getSettings(), errorLogger);
+    checkUninitVar.valueFlowUninit();
+    checkUninitVar.check();
+}
+
+void CheckUninitVar::getErrorMessages(ErrorLogger* errorLogger, const Settings* settings) const
+{
+    CheckUninitVar c(nullptr, settings, errorLogger);
+
+    ValueFlow::Value v{};
+
+    c.uninitvarError(nullptr, v); // TODO: does not produce any output
+    c.uninitdataError(nullptr, "varname");
+    c.uninitStructMemberError(nullptr, "a.b");
+}
diff --git a/lib/checkuninitvar.h b/lib/checkuninitvar.h
index 659554e21b8..b79e9c22be0 100644
--- a/lib/checkuninitvar.h
+++ b/lib/checkuninitvar.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,23 +24,30 @@
 
 #include "check.h"
 #include "config.h"
-#include "ctu.h"
+#include "mathlib.h"
+#include "errortypes.h"
 
+#include <cstdint>
+#include <map>
 #include <set>
 #include <string>
 
-class ErrorLogger;
 class Scope;
-class Settings;
 class Token;
-class Tokenizer;
 class Variable;
-
+class ErrorLogger;
+class Settings;
+class Library;
+class Tokenizer;
+namespace ValueFlow
+{
+    class Value;
+}
 
 struct VariableValue {
-    explicit VariableValue(MathLib::bigint val = 0) : value(val), notEqual(false) {}
+    explicit VariableValue(MathLib::bigint val = 0) : value(val) {}
     MathLib::bigint value;
-    bool notEqual;
+    bool notEqual{};
 };
 
 /// @addtogroup Checks
@@ -50,64 +57,57 @@ struct VariableValue {
 /** @brief Checking for uninitialized variables */
 
 class CPPCHECKLIB CheckUninitVar : public Check {
+    friend class TestUninitVar;
+
 public:
     /** @brief This constructor is used when registering the CheckUninitVar */
-    CheckUninitVar() : Check(myName()) {
-    }
+    CheckUninitVar() : Check(myName()) {}
+
+    enum Alloc : std::uint8_t { NO_ALLOC, NO_CTOR_CALL, CTOR_CALL, ARRAY };
 
+    static const Token *isVariableUsage(const Token *vartok, const Library &library, bool pointer, Alloc alloc, int indirect = 0);
+    const Token *isVariableUsage(const Token *vartok, bool pointer, Alloc alloc, int indirect = 0) const;
+
+private:
     /** @brief This constructor is used when running checks. */
     CheckUninitVar(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger) {}
 
     /** @brief Run checks against the normal token list */
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        CheckUninitVar checkUninitVar(tokenizer, settings, errorLogger);
-        checkUninitVar.check();
-        checkUninitVar.valueFlowUninit();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
+    bool diag(const Token* tok);
     /** Check for uninitialized variables */
     void check();
     void checkScope(const Scope* scope, const std::set<std::string> &arrayTypeDefs);
     void checkStruct(const Token *tok, const Variable &structvar);
-    enum Alloc { NO_ALLOC, NO_CTOR_CALL, CTOR_CALL, ARRAY };
-    bool checkScopeForVariable(const Token *tok, const Variable& var, bool* const possibleInit, bool* const noreturn, Alloc* const alloc, const std::string &membervar, std::map<int, VariableValue> variableValue);
+    bool checkScopeForVariable(const Token *tok, const Variable& var, bool* possibleInit, bool* noreturn, Alloc* alloc, const std::string &membervar, std::map<nonneg int, VariableValue>& variableValue);
+    const Token* checkExpr(const Token* tok, const Variable& var, Alloc alloc, bool known, bool* bailout = nullptr) const;
     bool checkIfForWhileHead(const Token *startparentheses, const Variable& var, bool suppressErrors, bool isuninit, Alloc alloc, const std::string &membervar);
-    bool checkLoopBody(const Token *tok, const Variable& var, const Alloc alloc, const std::string &membervar, const bool suppressErrors);
+    bool checkLoopBody(const Token *tok, const Variable& var, Alloc alloc, const std::string &membervar, bool suppressErrors);
+    const Token* checkLoopBodyRecursive(const Token *start, const Variable& var, Alloc alloc, const std::string &membervar, bool &bailout, bool &alwaysReturns) const;
     void checkRhs(const Token *tok, const Variable &var, Alloc alloc, nonneg int number_of_if, const std::string &membervar);
-    bool isVariableUsage(const Token *vartok, bool pointer, Alloc alloc) const;
-    int isFunctionParUsage(const Token *vartok, bool pointer, Alloc alloc) const;
+    static int isFunctionParUsage(const Token *vartok, const Library &library, bool pointer, Alloc alloc, int indirect = 0);
+    int isFunctionParUsage(const Token *vartok, bool pointer, Alloc alloc, int indirect = 0) const;
     bool isMemberVariableAssignment(const Token *tok, const std::string &membervar) const;
     bool isMemberVariableUsage(const Token *tok, bool isPointer, Alloc alloc, const std::string &membervar) const;
 
     /** ValueFlow-based checking for uninitialized variables */
     void valueFlowUninit();
 
-    /* data for multifile checking */
-    class MyFileInfo : public Check::FileInfo {
-    public:
-        /** function arguments that data are unconditionally read */
-        std::list<CTU::FileInfo::UnsafeUsage> unsafeUsage;
-
-        /** Convert MyFileInfo data into xml string */
-        std::string toString() const OVERRIDE;
-    };
-
     /** @brief Parse current TU and extract file info */
-    Check::FileInfo *getFileInfo(const Tokenizer *tokenizer, const Settings *settings) const OVERRIDE;
+    Check::FileInfo *getFileInfo(const Tokenizer &tokenizer, const Settings &settings, const std::string& /*currentConfig*/) const override;
 
-    Check::FileInfo * loadFileInfoFromXml(const tinyxml2::XMLElement *xmlElement) const OVERRIDE;
+    Check::FileInfo * loadFileInfoFromXml(const tinyxml2::XMLElement *xmlElement) const override;
 
     /** @brief Analyse all file infos for all TU */
-    bool analyseWholeProgram(const CTU::FileInfo *ctu, const std::list<Check::FileInfo*> &fileInfo, const Settings& settings, ErrorLogger &errorLogger) OVERRIDE;
+    bool analyseWholeProgram(const CTU::FileInfo &ctu, const std::list<Check::FileInfo*> &fileInfo, const Settings& settings, ErrorLogger &errorLogger) override;
 
-    void uninitstringError(const Token *tok, const std::string &varname, bool strncpy_);
+    void uninitvarError(const Token* tok, const ValueFlow::Value& v);
     void uninitdataError(const Token *tok, const std::string &varname);
     void uninitvarError(const Token *tok, const std::string &varname, ErrorPath errorPath);
     void uninitvarError(const Token *tok, const std::string &varname) {
-        ErrorPath errorPath;
-        uninitvarError(tok, varname, errorPath);
+        uninitvarError(tok, varname, ErrorPath{});
     }
     void uninitvarError(const Token *tok, const std::string &varname, Alloc alloc) {
         if (alloc == NO_CTOR_CALL || alloc == CTOR_CALL)
@@ -117,25 +117,15 @@ class CPPCHECKLIB CheckUninitVar : public Check {
     }
     void uninitStructMemberError(const Token *tok, const std::string &membername);
 
-private:
-    Check::FileInfo *getFileInfo() const;
-    bool isUnsafeFunction(const Scope *scope, int argnr, const Token **tok) const;
-
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        CheckUninitVar c(nullptr, settings, errorLogger);
+    std::set<const Token*> mUninitDiags;
 
-        // error
-        c.uninitstringError(nullptr, "varname", true);
-        c.uninitdataError(nullptr, "varname");
-        c.uninitvarError(nullptr, "varname");
-        c.uninitStructMemberError(nullptr, "a.b");
-    }
+    void getErrorMessages(ErrorLogger* errorLogger, const Settings* settings) const override;
 
     static std::string myName() {
         return "Uninitialized variables";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Uninitialized variables\n"
                "- using uninitialized local variables\n"
                "- using allocated data before it has been initialized\n";
diff --git a/lib/checkunusedfunctions.cpp b/lib/checkunusedfunctions.cpp
index fda9e6fc355..e10d25a87f1 100644
--- a/lib/checkunusedfunctions.cpp
+++ b/lib/checkunusedfunctions.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,74 +20,112 @@
 //---------------------------------------------------------------------------
 #include "checkunusedfunctions.h"
 
+#include "analyzerinfo.h"
 #include "astutils.h"
 #include "errorlogger.h"
+#include "errortypes.h"
 #include "library.h"
 #include "settings.h"
 #include "symboldatabase.h"
 #include "token.h"
 #include "tokenize.h"
 #include "tokenlist.h"
+#include "utils.h"
 
-#include <tinyxml2.h>
 #include <algorithm>
-#include <cstdlib>
+#include <cctype>
 #include <cstring>
-#include <istream>
+#include <functional>
+#include <map>
+#include <sstream>
+#include <tuple>
 #include <utility>
-//---------------------------------------------------------------------------
-
+#include <vector>
 
+#include "xml.h"
 
-// Register this check class
-CheckUnusedFunctions CheckUnusedFunctions::instance;
+//---------------------------------------------------------------------------
 
-static const struct CWE CWE561(561U);   // Dead Code
+static const CWE CWE561(561U);   // Dead Code
 
+static std::string stripTemplateParameters(const std::string& funcName) {
+    std::string name = funcName;
+    const auto pos = name.find('<');
+    if (pos > 0 && pos != std::string::npos)
+        name.erase(pos - 1);
+    return name;
+}
 
 //---------------------------------------------------------------------------
 // FUNCTION USAGE - Check for unused functions etc
 //---------------------------------------------------------------------------
 
-void CheckUnusedFunctions::parseTokens(const Tokenizer &tokenizer, const char FileName[], const Settings *settings)
+static bool isRecursiveCall(const Token* ftok)
+{
+    return ftok->function() && ftok->function() == Scope::nestedInFunction(ftok->scope());
+}
+
+void CheckUnusedFunctions::parseTokens(const Tokenizer &tokenizer, const Settings &settings)
 {
-    const bool doMarkup = settings->library.markupFile(FileName);
-    const SymbolDatabase* symbolDatabase = tokenizer.getSymbolDatabase();
+    const char * const FileName = tokenizer.list.getFiles().front().c_str();
+
+    const bool doMarkup = settings.library.markupFile(FileName);
 
     // Function declarations..
-    for (const Scope* scope : symbolDatabase->functionScopes) {
-        const Function* func = scope->function;
-        if (!func || !func->token || scope->bodyStart->fileIndex() != 0)
-            continue;
+    if (!doMarkup) {
+        const SymbolDatabase* symbolDatabase = tokenizer.getSymbolDatabase();
+        for (const Scope* scope : symbolDatabase->functionScopes) {
+            const Function* func = scope->function;
+            if (!func || !func->token)
+                continue;
 
-        // Don't warn about functions that are marked by __attribute__((constructor)) or __attribute__((destructor))
-        if (func->isAttributeConstructor() || func->isAttributeDestructor() || func->type != Function::eFunction || func->isOperator())
-            continue;
+            // Don't warn about functions that are marked by __attribute__((constructor)) or __attribute__((destructor))
+            if (func->isAttributeConstructor() || func->isAttributeDestructor() || func->type != FunctionType::eFunction || func->isOperator())
+                continue;
 
-        // Don't care about templates
-        if (tokenizer.isCPP()) {
-            const Token *retDef = func->retDef;
-            while (retDef && retDef->isName())
-                retDef = retDef->previous();
-            if (retDef && retDef->str() == ">")
+            if (func->isAttributeUnused() || func->isAttributeMaybeUnused())
                 continue;
-        }
 
-        mFunctionDecl.emplace_back(func);
+            if (func->isExtern())
+                continue;
 
-        FunctionUsage &usage = mFunctions[func->name()];
+            bool foundAllBaseClasses{};
+            if (const Function* ofunc = func->getOverriddenFunction(&foundAllBaseClasses)) {
+                if (!foundAllBaseClasses || ofunc->isPure())
+                    continue;
+            }
+            else if (func->isImplicitlyVirtual()) {
+                continue;
+            }
 
-        if (!usage.lineNumber)
-            usage.lineNumber = func->token->linenr();
+            mFunctionDecl.emplace_back(func);
 
-        // No filename set yet..
-        if (usage.filename.empty()) {
-            usage.filename = tokenizer.list.getSourceFilePath();
-        }
-        // Multiple files => filename = "+"
-        else if (usage.filename != tokenizer.list.getSourceFilePath()) {
-            //func.filename = "+";
-            usage.usedOtherFile |= usage.usedSameFile;
+            FunctionUsage &usage = mFunctions[stripTemplateParameters(func->name())];
+
+            if (func->retDef && (func->retDef->isAttributeUnused() || func->retDef->isAttributeMaybeUnused())) {
+                usage.usedOtherFile = true;
+            }
+
+            if (!usage.lineNumber) {
+                usage.lineNumber = func->token->linenr();
+                usage.column = func->token->column();
+            }
+            usage.isC = func->token->isC();
+            usage.isStatic = func->isStatic();
+
+            // TODO: why always overwrite this but not the filename and line?
+            usage.fileIndex = func->token->fileIndex();
+            const std::string& fileName = tokenizer.list.file(func->token);
+
+            // No filename set yet..
+            if (usage.filename.empty()) {
+                usage.filename = fileName;
+            }
+            // Multiple files => filename = "+"
+            else if (usage.filename != fileName) {
+                //func.filename = "+";
+                usage.usedOtherFile |= usage.usedSameFile;
+            }
         }
     }
 
@@ -101,8 +139,8 @@ void CheckUnusedFunctions::parseTokens(const Tokenizer &tokenizer, const char Fi
             lambdaEndToken = findLambdaEndToken(tok);
 
         // parsing of library code to find called functions
-        if (settings->library.isexecutableblock(FileName, tok->str())) {
-            const Token * markupVarToken = tok->tokAt(settings->library.blockstartoffset(FileName));
+        if (settings.library.isexecutableblock(FileName, tok->str())) {
+            const Token * markupVarToken = tok->tokAt(settings.library.blockstartoffset(FileName));
             // not found
             if (!markupVarToken)
                 continue;
@@ -110,20 +148,18 @@ void CheckUnusedFunctions::parseTokens(const Tokenizer &tokenizer, const char Fi
             bool start = true;
             // find all function calls in library code (starts with '(', not if or while etc)
             while ((scope || start) && markupVarToken) {
-                if (markupVarToken->str() == settings->library.blockstart(FileName)) {
+                if (markupVarToken->str() == settings.library.blockstart(FileName)) {
                     scope++;
-                    if (start) {
-                        start = false;
-                    }
-                } else if (markupVarToken->str() == settings->library.blockend(FileName))
+                    start = false;
+                } else if (markupVarToken->str() == settings.library.blockend(FileName))
                     scope--;
-                else if (!settings->library.iskeyword(FileName, markupVarToken->str())) {
+                else if (!settings.library.iskeyword(FileName, markupVarToken->str())) {
                     mFunctionCalls.insert(markupVarToken->str());
                     if (mFunctions.find(markupVarToken->str()) != mFunctions.end())
                         mFunctions[markupVarToken->str()].usedOtherFile = true;
-                    else if (markupVarToken->next()->str() == "(") {
+                    else if (markupVarToken->strAt(1) == "(") {
                         FunctionUsage &func = mFunctions[markupVarToken->str()];
-                        func.filename = tokenizer.list.getSourceFilePath();
+                        func.filename = tokenizer.list.getFiles()[markupVarToken->fileIndex()];
                         if (func.filename.empty() || func.filename == "+")
                             func.usedOtherFile = true;
                         else
@@ -135,10 +171,10 @@ void CheckUnusedFunctions::parseTokens(const Tokenizer &tokenizer, const char Fi
         }
 
         if (!doMarkup // only check source files
-            && settings->library.isexporter(tok->str()) && tok->next() != nullptr) {
+            && settings.library.isexporter(tok->str()) && tok->next() != nullptr) {
             const Token * propToken = tok->next();
             while (propToken && propToken->str() != ")") {
-                if (settings->library.isexportedprefix(tok->str(), propToken->str())) {
+                if (settings.library.isexportedprefix(tok->str(), propToken->str())) {
                     const Token* nextPropToken = propToken->next();
                     const std::string& value = nextPropToken->str();
                     if (mFunctions.find(value) != mFunctions.end()) {
@@ -146,7 +182,7 @@ void CheckUnusedFunctions::parseTokens(const Tokenizer &tokenizer, const char Fi
                     }
                     mFunctionCalls.insert(value);
                 }
-                if (settings->library.isexportedsuffix(tok->str(), propToken->str())) {
+                if (settings.library.isexportedsuffix(tok->str(), propToken->str())) {
                     const Token* prevPropToken = propToken->previous();
                     const std::string& value = prevPropToken->str();
                     if (value != ")" && mFunctions.find(value) != mFunctions.end()) {
@@ -158,7 +194,7 @@ void CheckUnusedFunctions::parseTokens(const Tokenizer &tokenizer, const char Fi
             }
         }
 
-        if (doMarkup && settings->library.isimporter(FileName, tok->str()) && tok->next()) {
+        if (doMarkup && settings.library.isimporter(FileName, tok->str()) && tok->next()) {
             const Token * propToken = tok->next();
             if (propToken->next()) {
                 propToken = propToken->next();
@@ -174,8 +210,8 @@ void CheckUnusedFunctions::parseTokens(const Tokenizer &tokenizer, const char Fi
             }
         }
 
-        if (settings->library.isreflection(tok->str())) {
-            const int argIndex = settings->library.reflectionArgument(tok->str());
+        if (settings.library.isreflection(tok->str())) {
+            const int argIndex = settings.library.reflectionArgument(tok->str());
             if (argIndex >= 0) {
                 const Token * funcToken = tok->next();
                 int index = 0;
@@ -192,18 +228,31 @@ void CheckUnusedFunctions::parseTokens(const Tokenizer &tokenizer, const char Fi
                 if (index == argIndex) {
                     value = value.substr(1, value.length() - 2);
                     mFunctions[value].usedOtherFile = true;
-                    mFunctionCalls.insert(value);
+                    mFunctionCalls.insert(std::move(value));
                 }
             }
         }
 
+        if (tok->hasAttributeCleanup()) {
+            const std::string& funcname = tok->getAttributeCleanup();
+            mFunctions[funcname].usedOtherFile = true;
+            mFunctionCalls.insert(funcname);
+            continue;
+        }
+
         const Token *funcname = nullptr;
 
-        if ((lambdaEndToken || tok->scope()->isExecutable()) && Token::Match(tok, "%name% (")) {
+        if (doMarkup)
+            funcname = Token::Match(tok, "%name% (") ? tok : nullptr;
+        else if ((lambdaEndToken || tok->scope()->isExecutable()) && Token::Match(tok, "%name% (")) {
             funcname = tok;
         } else if ((lambdaEndToken || tok->scope()->isExecutable()) && Token::Match(tok, "%name% <") && Token::simpleMatch(tok->linkAt(1), "> (")) {
             funcname = tok;
-        } else if (Token::Match(tok, "[;{}.,()[=+-/|!?:]")) {
+        } else if (Token::Match(tok, "< %name%") && tok->link()) {
+            funcname = tok->next();
+            while (Token::Match(funcname, "%name% :: %name%"))
+                funcname = funcname->tokAt(2);
+        } else if (tok->scope()->type != ScopeType::eEnum && (Token::Match(tok, "[;{}.,()[=+-/|!?:]") || Token::Match(tok, "return|throw"))) {
             funcname = tok->next();
             if (funcname && funcname->str() == "&")
                 funcname = funcname->next();
@@ -212,15 +261,15 @@ void CheckUnusedFunctions::parseTokens(const Tokenizer &tokenizer, const char Fi
             while (Token::Match(funcname, "%name% :: %name%"))
                 funcname = funcname->tokAt(2);
 
-            if (!Token::Match(funcname, "%name% [(),;]:}>]"))
+            if (!Token::Match(funcname, "%name% [(),;]:}<>]"))
                 continue;
         }
 
-        if (!funcname)
+        if (!funcname || funcname->isKeyword() || funcname->isStandardType() || funcname->varId() || funcname->enumerator() || funcname->type())
             continue;
 
         // funcname ( => Assert that the end parentheses isn't followed by {
-        if (Token::Match(funcname, "%name% (|<")) {
+        if (Token::Match(funcname, "%name% (|<") && funcname->linkAt(1)) {
             const Token *ftok = funcname->next();
             if (ftok->str() == "<")
                 ftok = ftok->link();
@@ -229,15 +278,18 @@ void CheckUnusedFunctions::parseTokens(const Tokenizer &tokenizer, const char Fi
         }
 
         if (funcname) {
-            FunctionUsage &func = mFunctions[ funcname->str()];
-            const std::string& called_from_file = tokenizer.list.getSourceFilePath();
+            if (isRecursiveCall(funcname))
+                continue;
+            auto baseName = stripTemplateParameters(funcname->str());
+            FunctionUsage &func = mFunctions[baseName];
+            const std::string& called_from_file = tokenizer.list.getFiles()[funcname->fileIndex()];
 
             if (func.filename.empty() || func.filename == "+" || func.filename != called_from_file)
                 func.usedOtherFile = true;
             else
                 func.usedSameFile = true;
 
-            mFunctionCalls.insert(funcname->str());
+            mFunctionCalls.insert(std::move(baseName));
         }
     }
 }
@@ -287,21 +339,44 @@ static bool isOperatorFunction(const std::string & funcName)
     };
 
 
-    return std::find(additionalOperators.begin(), additionalOperators.end(), funcName.substr(operatorPrefix.length())) != additionalOperators.end();;
+    return std::find(additionalOperators.cbegin(), additionalOperators.cend(), funcName.substr(operatorPrefix.length())) != additionalOperators.cend();
 }
 
+void CheckUnusedFunctions::staticFunctionError(ErrorLogger& errorLogger,
+                                               const std::string &filename, nonneg int fileIndex, nonneg int lineNumber, nonneg int column,
+                                               const std::string &funcname)
+{
+    std::list<ErrorMessage::FileLocation> locationList;
+    if (!filename.empty()) {
+        locationList.emplace_back(filename, lineNumber, column);
+        locationList.back().fileIndex = fileIndex;
+    }
+
+    const ErrorMessage errmsg(std::move(locationList), "", Severity::style, "$symbol:" + funcname + "\nThe function '$symbol' should have static linkage since it is not used outside of its translation unit.", "staticFunction", Certainty::normal);
+    errorLogger.reportErr(errmsg);
+}
 
 
-bool CheckUnusedFunctions::check(ErrorLogger * const errorLogger, const Settings& settings)
+#define logChecker(id) \
+    do { \
+        const ErrorMessage errmsg({}, nullptr, Severity::internal, "logChecker", (id), CWE(0U), Certainty::normal); \
+        errorLogger.reportErr(errmsg); \
+    } while (false)
+
+bool CheckUnusedFunctions::check(const Settings& settings, ErrorLogger& errorLogger) const
 {
-    bool errors = false;
-    for (std::map<std::string, FunctionUsage>::const_iterator it = mFunctions.begin(); it != mFunctions.end(); ++it) {
+    logChecker("CheckUnusedFunctions::check"); // unusedFunction
+
+    // filename, fileindex, line, column
+    using ErrorParams = std::tuple<std::string, nonneg int, nonneg int, nonneg int, std::string>;
+    std::vector<ErrorParams> errors; // ensure well-defined order
+    std::vector<ErrorParams> staticFunctionErrors;
+
+    for (auto it = mFunctions.cbegin(); it != mFunctions.cend(); ++it) {
         const FunctionUsage &func = it->second;
         if (func.usedOtherFile || func.filename.empty())
             continue;
-        if (it->first == "main" ||
-            (settings.isWindowsPlatform() && (it->first == "WinMain" || it->first == "_tmain")) ||
-            it->first == "if")
+        if (settings.library.isentrypoint(it->first))
             continue;
         if (!func.usedSameFile) {
             if (isOperatorFunction(it->first))
@@ -309,68 +384,57 @@ bool CheckUnusedFunctions::check(ErrorLogger * const errorLogger, const Settings
             std::string filename;
             if (func.filename != "+")
                 filename = func.filename;
-            unusedFunctionError(errorLogger, filename, func.lineNumber, it->first);
-            errors = true;
-        } else if (! func.usedOtherFile) {
-            /** @todo add error message "function is only used in <file> it can be static" */
-            /*
-            std::ostringstream errmsg;
-            errmsg << "The function '" << it->first << "' is only used in the file it was declared in so it should have local linkage.";
-            mErrorLogger->reportErr( errmsg.str() );
-            errors = true;
-            */
+            errors.emplace_back(filename, func.fileIndex, func.lineNumber, func.column, it->first);
+        } else if (func.isC && !func.isStatic) {
+            std::string filename;
+            if (func.filename != "+")
+                filename = func.filename;
+            staticFunctionErrors.emplace_back(filename, func.fileIndex, func.lineNumber, func.column, it->first);
         }
     }
-    return errors;
-}
 
-void CheckUnusedFunctions::unusedFunctionError(ErrorLogger * const errorLogger,
-        const std::string &filename, unsigned int lineNumber,
-        const std::string &funcname)
-{
-    std::list<ErrorLogger::ErrorMessage::FileLocation> locationList;
-    if (!filename.empty()) {
-        ErrorLogger::ErrorMessage::FileLocation fileLoc;
-        fileLoc.setfile(filename);
-        fileLoc.line = lineNumber;
-        locationList.push_back(fileLoc);
-    }
+    std::sort(errors.begin(), errors.end());
+    for (const auto& e : errors)
+        unusedFunctionError(errorLogger, std::get<0>(e), std::get<1>(e), std::get<2>(e), std::get<3>(e), std::get<4>(e));
 
-    const ErrorLogger::ErrorMessage errmsg(locationList, emptyString, Severity::style, "$symbol:" + funcname + "\nThe function '$symbol' is never used.", "unusedFunction", CWE561, false);
-    if (errorLogger)
-        errorLogger->reportErr(errmsg);
-    else
-        reportError(errmsg);
-}
+    std::sort(staticFunctionErrors.begin(), staticFunctionErrors.end());
+    for (const auto& e : staticFunctionErrors)
+        staticFunctionError(errorLogger, std::get<0>(e), std::get<1>(e), std::get<2>(e), std::get<3>(e), std::get<4>(e));
 
-Check::FileInfo *CheckUnusedFunctions::getFileInfo(const Tokenizer *tokenizer, const Settings *settings) const
-{
-    if (!settings->isEnabled(Settings::UNUSED_FUNCTION))
-        return nullptr;
-    if (settings->jobs == 1 && settings->buildDir.empty())
-        instance.parseTokens(*tokenizer, tokenizer->list.getFiles().front().c_str(), settings);
-    return nullptr;
+    return !errors.empty();
 }
 
-bool CheckUnusedFunctions::analyseWholeProgram(const CTU::FileInfo *ctu, const std::list<Check::FileInfo*> &fileInfo, const Settings& settings, ErrorLogger &errorLogger)
+void CheckUnusedFunctions::unusedFunctionError(ErrorLogger& errorLogger,
+                                               const std::string &filename, nonneg int fileIndex, nonneg int lineNumber, nonneg int column,
+                                               const std::string &funcname)
 {
-    (void)ctu;
-    (void)fileInfo;
-    return check(&errorLogger, settings);
+    std::list<ErrorMessage::FileLocation> locationList;
+    if (!filename.empty()) {
+        locationList.emplace_back(filename, lineNumber, column);
+        locationList.back().fileIndex = fileIndex;
+    }
+
+    const ErrorMessage errmsg(std::move(locationList), "", Severity::style, "$symbol:" + funcname + "\nThe function '$symbol' is never used.", "unusedFunction", CWE561, Certainty::normal);
+    errorLogger.reportErr(errmsg);
 }
 
 CheckUnusedFunctions::FunctionDecl::FunctionDecl(const Function *f)
-    : functionName(f->name()), lineNumber(f->token->linenr())
-{
-}
+    : functionName(f->name())
+    , fileIndex(f->token->fileIndex())
+    , lineNumber(f->token->linenr())
+    , column(f->token->column())
+{}
 
-std::string CheckUnusedFunctions::analyzerInfo() const
+std::string CheckUnusedFunctions::analyzerInfo(const Tokenizer &tokenizer) const
 {
     std::ostringstream ret;
     for (const FunctionDecl &functionDecl : mFunctionDecl) {
         ret << "    <functiondecl"
+            << " file=\"" << ErrorLogger::toxml(tokenizer.list.getFiles()[functionDecl.fileIndex]) << '\"'
             << " functionName=\"" << ErrorLogger::toxml(functionDecl.functionName) << '\"'
-            << " lineNumber=\"" << functionDecl.lineNumber << "\"/>\n";
+            << " lineNumber=\"" << functionDecl.lineNumber << '\"'
+            << " column=\"" << functionDecl.column << '\"'
+            << "/>\n";
     }
     for (const std::string &fc : mFunctionCalls) {
         ret << "    <functioncall functionName=\"" << ErrorLogger::toxml(fc) << "\"/>\n";
@@ -380,72 +444,80 @@ std::string CheckUnusedFunctions::analyzerInfo() const
 
 namespace {
     struct Location {
-        Location() : lineNumber(0) {}
-        Location(const std::string &f, const int l) : fileName(f), lineNumber(l) {}
+        Location() : lineNumber(0), column(0) {}
+        Location(std::string f, nonneg int l, nonneg int c) : fileName(std::move(f)), lineNumber(l), column(c) {}
         std::string fileName;
-        int lineNumber;
+        nonneg int lineNumber;
+        nonneg int column;
     };
 }
 
-void CheckUnusedFunctions::analyseWholeProgram(ErrorLogger * const errorLogger, const std::string &buildDir)
+// TODO: bail out on unexpected data
+void CheckUnusedFunctions::analyseWholeProgram(const Settings &settings, ErrorLogger &errorLogger, const std::string &buildDir)
 {
     std::map<std::string, Location> decls;
     std::set<std::string> calls;
 
-    const std::string filesTxt(buildDir + "/files.txt");
-    std::ifstream fin(filesTxt.c_str());
-    std::string filesTxtLine;
-    while (std::getline(fin, filesTxtLine)) {
-        const std::string::size_type firstColon = filesTxtLine.find(':');
-        if (firstColon == std::string::npos)
-            continue;
-        const std::string::size_type secondColon = filesTxtLine.find(':', firstColon+1);
-        if (secondColon == std::string::npos)
-            continue;
-        const std::string xmlfile = buildDir + '/' + filesTxtLine.substr(0,firstColon);
-        const std::string sourcefile = filesTxtLine.substr(secondColon+1);
-
-        tinyxml2::XMLDocument doc;
-        const tinyxml2::XMLError error = doc.LoadFile(xmlfile.c_str());
-        if (error != tinyxml2::XML_SUCCESS)
-            continue;
-
-        const tinyxml2::XMLElement * const rootNode = doc.FirstChildElement();
-        if (rootNode == nullptr)
-            continue;
-
-        for (const tinyxml2::XMLElement *e = rootNode->FirstChildElement(); e; e = e->NextSiblingElement()) {
-            if (std::strcmp(e->Name(), "FileInfo") != 0)
+    const auto handler = [&decls, &calls](const char* checkattr, const tinyxml2::XMLElement* e, const AnalyzerInformation::Info& filesTxtInfo) {
+        if (std::strcmp(checkattr,"CheckUnusedFunctions") != 0)
+            return;
+        for (const tinyxml2::XMLElement *e2 = e->FirstChildElement(); e2; e2 = e2->NextSiblingElement()) {
+            const char* functionName = e2->Attribute("functionName");
+            if (functionName == nullptr)
                 continue;
-            const char *checkattr = e->Attribute("check");
-            if (checkattr == nullptr || std::strcmp(checkattr,"CheckUnusedFunctions") != 0)
+            const char* name = e2->Name();
+            if (std::strcmp(name,"functioncall") == 0) {
+                calls.insert(functionName);
                 continue;
-            for (const tinyxml2::XMLElement *e2 = e->FirstChildElement(); e2; e2 = e2->NextSiblingElement()) {
-                const char* functionName = e2->Attribute("functionName");
-                if (functionName == nullptr)
-                    continue;
-                if (std::strcmp(e2->Name(),"functioncall") == 0) {
-                    calls.insert(functionName);
-                    continue;
-                } else if (std::strcmp(e2->Name(),"functiondecl") == 0) {
-                    const char* lineNumber = e2->Attribute("lineNumber");
-                    if (lineNumber)
-                        decls[functionName] = Location(sourcefile, std::atoi(lineNumber));
+            }
+            if (std::strcmp(name,"functiondecl") == 0) {
+                const char* lineNumber = e2->Attribute("lineNumber");
+                if (lineNumber) {
+                    const char* file = e2->Attribute("file");
+                    const char* column = default_if_null(e2->Attribute("column"), "0");
+                    // cppcheck-suppress templateInstantiation - TODO: fix this - see #11631
+                    decls[functionName] = Location(file ? file : filesTxtInfo.sourceFile, strToInt<int>(lineNumber), strToInt<int>(column));
                 }
             }
         }
+    };
+
+    const std::string err = AnalyzerInformation::processFilesTxt(buildDir, handler, settings.debugainfo);
+    if (!err.empty()) {
+        const ErrorMessage errmsg({}, "", Severity::error, err, "internalError", Certainty::normal);
+        errorLogger.reportErr(errmsg);
+        return;
     }
 
-    for (std::map<std::string, Location>::const_iterator decl = decls.begin(); decl != decls.end(); ++decl) {
-        const std::string &functionName = decl->first;
+    for (auto decl = decls.cbegin(); decl != decls.cend(); ++decl) {
+        const std::string &functionName = stripTemplateParameters(decl->first);
 
-        if (functionName == "main" || functionName == "WinMain" || functionName == "_tmain" ||
-            functionName == "if")
+        if (settings.library.isentrypoint(functionName))
             continue;
 
         if (calls.find(functionName) == calls.end() && !isOperatorFunction(functionName)) {
             const Location &loc = decl->second;
-            unusedFunctionError(errorLogger, loc.fileName, loc.lineNumber, functionName);
+            unusedFunctionError(errorLogger, loc.fileName, /*fileIndex*/ 0, loc.lineNumber, loc.column, functionName);
+        }
+    }
+}
+
+void CheckUnusedFunctions::updateFunctionData(const CheckUnusedFunctions& check)
+{
+    for (const auto& entry : check.mFunctions)
+    {
+        FunctionUsage &usage = mFunctions[entry.first];
+        if (!usage.lineNumber) {
+            usage.lineNumber = entry.second.lineNumber;
+            usage.column = entry.second.column;
         }
+        // TODO: why always overwrite this but not the filename and line?
+        usage.fileIndex = entry.second.fileIndex;
+        if (usage.filename.empty())
+            usage.filename = entry.second.filename;
+        usage.usedOtherFile |= entry.second.usedOtherFile;
+        usage.usedSameFile |= entry.second.usedSameFile;
     }
+    mFunctionDecl.insert(mFunctionDecl.cend(), check.mFunctionDecl.cbegin(), check.mFunctionDecl.cend());
+    mFunctionCalls.insert(check.mFunctionCalls.cbegin(), check.mFunctionCalls.cend());
 }
diff --git a/lib/checkunusedfunctions.h b/lib/checkunusedfunctions.h
index 1816f6a4436..6f10e3446eb 100644
--- a/lib/checkunusedfunctions.h
+++ b/lib/checkunusedfunctions.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,101 +22,73 @@
 #define checkunusedfunctionsH
 //---------------------------------------------------------------------------
 
-#include "check.h"
 #include "config.h"
 
 #include <list>
-#include <map>
 #include <set>
 #include <string>
+#include <unordered_map>
 
 class ErrorLogger;
 class Function;
 class Settings;
 class Tokenizer;
 
-/// @addtogroup Checks
 /** @brief Check for functions never called */
 /// @{
 
-class CPPCHECKLIB CheckUnusedFunctions : public Check {
+class CPPCHECKLIB CheckUnusedFunctions {
 public:
-    /** @brief This constructor is used when registering the CheckUnusedFunctions */
-    CheckUnusedFunctions() : Check(myName()) {
-    }
-
-    /** @brief This constructor is used when running checks. */
-    CheckUnusedFunctions(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
-
-    static void clear() {
-        instance.mFunctions.clear();
-        instance.mFunctionCalls.clear();
-    }
+    CheckUnusedFunctions() = default;
 
     // Parse current tokens and determine..
     // * Check what functions are used
     // * What functions are declared
-    void parseTokens(const Tokenizer &tokenizer, const char FileName[], const Settings *settings);
+    void parseTokens(const Tokenizer &tokenizer, const Settings &settings);
 
-    // Return true if an error is reported.
-    bool check(ErrorLogger * const errorLogger, const Settings& settings);
-
-    /** @brief Parse current TU and extract file info */
-    Check::FileInfo *getFileInfo(const Tokenizer *tokenizer, const Settings *settings) const OVERRIDE;
+    std::string analyzerInfo(const Tokenizer &tokenizer) const;
 
-    /** @brief Analyse all file infos for all TU */
-    bool analyseWholeProgram(const CTU::FileInfo *ctu, const std::list<Check::FileInfo*> &fileInfo, const Settings& settings, ErrorLogger &errorLogger) OVERRIDE;
+    static void analyseWholeProgram(const Settings &settings, ErrorLogger& errorLogger, const std::string &buildDir);
 
-    static CheckUnusedFunctions instance;
+    static void getErrorMessages(ErrorLogger &errorLogger) {
+        unusedFunctionError(errorLogger, "", 0, 0, 0, "funcName");
+        staticFunctionError(errorLogger, "", 0, 0, 0, "funcName");
+    }
 
-    std::string analyzerInfo() const;
+    // Return true if an error is reported.
+    bool check(const Settings& settings, ErrorLogger& errorLogger) const;
 
-    /** @brief Combine and analyze all analyzerInfos for all TUs */
-    static void analyseWholeProgram(ErrorLogger * const errorLogger, const std::string &buildDir);
+    void updateFunctionData(const CheckUnusedFunctions& check);
 
 private:
-
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings * /*settings*/) const OVERRIDE {
-        CheckUnusedFunctions::unusedFunctionError(errorLogger, emptyString, 0, "funcName");
-    }
-
-    void runChecks(const Tokenizer * /*tokenizer*/, const Settings * /*settings*/, ErrorLogger * /*errorLogger*/) OVERRIDE {}
-
-    /**
-     * Dummy implementation, just to provide error for --errorlist
-     */
-    static void unusedFunctionError(ErrorLogger * const errorLogger,
-                                    const std::string &filename, unsigned int lineNumber,
+    static void unusedFunctionError(ErrorLogger& errorLogger,
+                                    const std::string &filename, nonneg int fileIndex, nonneg int lineNumber, nonneg int column,
                                     const std::string &funcname);
 
-    static std::string myName() {
-        return "Unused functions";
-    }
-
-    std::string classInfo() const OVERRIDE {
-        return "Check for functions that are never called\n";
-    }
-
-    class CPPCHECKLIB FunctionUsage {
-    public:
-        FunctionUsage() : lineNumber(0), usedSameFile(false), usedOtherFile(false) {
-        }
+    static void staticFunctionError(ErrorLogger& errorLogger,
+                                    const std::string &filename, nonneg int fileIndex, nonneg int lineNumber, nonneg int column,
+                                    const std::string &funcname);
 
+    struct CPPCHECKLIB FunctionUsage {
         std::string filename;
-        unsigned int lineNumber;
-        bool   usedSameFile;
-        bool   usedOtherFile;
+        nonneg int lineNumber{};
+        nonneg int column{};
+        nonneg int fileIndex{};
+        bool usedSameFile{};
+        bool usedOtherFile{};
+        bool isC{};
+        bool isStatic{};
     };
 
-    std::map<std::string, FunctionUsage> mFunctions;
+    std::unordered_map<std::string, FunctionUsage> mFunctions;
 
     class CPPCHECKLIB FunctionDecl {
     public:
         explicit FunctionDecl(const Function *f);
         std::string functionName;
-        unsigned int lineNumber;
+        nonneg int fileIndex;
+        nonneg int lineNumber;
+        nonneg int column;
     };
     std::list<FunctionDecl> mFunctionDecl;
     std::set<std::string> mFunctionCalls;
diff --git a/lib/checkunusedvar.cpp b/lib/checkunusedvar.cpp
index 553d84375b9..6e9381657b0 100644
--- a/lib/checkunusedvar.cpp
+++ b/lib/checkunusedvar.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,16 +21,19 @@
 #include "checkunusedvar.h"
 
 #include "astutils.h"
-#include "errorlogger.h"
+#include "errortypes.h"
+#include "fwdanalysis.h"
+#include "library.h"
 #include "settings.h"
 #include "symboldatabase.h"
 #include "token.h"
 #include "tokenize.h"
+#include "utils.h"
 #include "valueflow.h"
 
 #include <algorithm>
-#include <cctype>
 #include <cstddef>
+#include <cstdint>
 #include <list>
 #include <set>
 #include <utility>
@@ -42,16 +45,65 @@ namespace {
     CheckUnusedVar instance;
 }
 
-static const struct CWE CWE563(563U);   // Assignment to Variable without Use ('Unused Variable')
-static const struct CWE CWE665(665U);   // Improper Initialization
+static const CWE CWE563(563U);   // Assignment to Variable without Use ('Unused Variable')
+static const CWE CWE665(665U);   // Improper Initialization
 
+/** Is scope a raii class scope */
+static bool isRaiiClassScope(const Scope *classScope)
+{
+    return classScope && classScope->getDestructor() != nullptr;
+}
+
+/** Is ValueType a raii class? */
+static bool isRaiiClass(const ValueType *valueType, bool cpp, bool defaultReturn = true)
+{
+    if (!cpp)
+        return false;
+
+    if (!valueType)
+        return defaultReturn;
+
+    if ((valueType->smartPointerType && isRaiiClassScope(valueType->smartPointerType->classScope)) || (!valueType->smartPointerType && valueType->type == ValueType::Type::SMART_POINTER))
+        return true;
+
+    switch (valueType->type) {
+    case ValueType::Type::UNKNOWN_TYPE:
+    case ValueType::Type::NONSTD:
+        return defaultReturn;
+
+    case ValueType::Type::RECORD:
+        if (isRaiiClassScope(valueType->typeScope))
+            return true;
+        return defaultReturn;
+
+    case ValueType::Type::POD:
+    case ValueType::Type::SMART_POINTER:
+    case ValueType::Type::CONTAINER:
+    case ValueType::Type::ITERATOR:
+    case ValueType::Type::VOID:
+    case ValueType::Type::BOOL:
+    case ValueType::Type::CHAR:
+    case ValueType::Type::SHORT:
+    case ValueType::Type::WCHAR_T:
+    case ValueType::Type::INT:
+    case ValueType::Type::LONG:
+    case ValueType::Type::LONGLONG:
+    case ValueType::Type::UNKNOWN_INT:
+    case ValueType::Type::FLOAT:
+    case ValueType::Type::DOUBLE:
+    case ValueType::Type::LONGDOUBLE:
+        return false;
+    }
+
+    return defaultReturn;
+}
 
 /**
  * @brief This class is used create a list of variables within a function.
  */
 class Variables {
 public:
-    enum VariableType { standard, array, pointer, reference, pointerArray, referenceArray, pointerPointer, none };
+    enum VariableType : std::uint8_t { standard, array, pointer, reference, pointerArray, referenceArray, pointerPointer, none };
 
     /** Store information about variable usage */
     class VariableUsage {
@@ -68,8 +120,7 @@ class Variables {
             _read(read),
             _write(write),
             _modified(modified),
-            _allocateMemory(allocateMemory) {
-        }
+            _allocateMemory(allocateMemory) {}
 
         /** variable is used.. set both read+write */
         void use() {
@@ -82,7 +133,7 @@ class Variables {
             return (!_read && !_write);
         }
 
-        std::set<unsigned int> _aliases;
+        std::set<nonneg int> _aliases;
         std::set<const Scope*> _assignments;
 
         const Variable* _var;
@@ -97,31 +148,40 @@ class Variables {
     void clear() {
         mVarUsage.clear();
     }
-    const std::map<unsigned int, VariableUsage> &varUsage() const {
+    void clearConst() {
+        std::set<int> keys;
+        for (const std::pair<const nonneg int, Variables::VariableUsage>& var : mVarUsage) {
+            if (var.second._var && var.second._var->isConst())
+                keys.emplace(var.first);
+        }
+        for (const int key : keys)
+            mVarUsage.erase(key);
+    }
+    const std::map<nonneg int, VariableUsage> &varUsage() const {
         return mVarUsage;
     }
     void addVar(const Variable *var, VariableType type, bool write_);
-    void allocateMemory(unsigned int varid, const Token* tok);
-    void read(unsigned int varid, const Token* tok);
-    void readAliases(unsigned int varid, const Token* tok);
-    void readAll(unsigned int varid, const Token* tok);
-    void write(unsigned int varid, const Token* tok);
-    void writeAliases(unsigned int varid, const Token* tok);
-    void writeAll(unsigned int varid, const Token* tok);
-    void use(unsigned int varid, const Token* tok);
-    void modified(unsigned int varid, const Token* tok);
-    VariableUsage *find(unsigned int varid);
-    void alias(unsigned int varid1, unsigned int varid2, bool replace);
-    void erase(unsigned int varid) {
+    void allocateMemory(nonneg int varid, const Token* tok);
+    void read(nonneg int varid, const Token* tok);
+    void readAliases(nonneg int varid, const Token* tok);
+    void readAll(nonneg int varid, const Token* tok);
+    void write(nonneg int varid, const Token* tok);
+    void writeAliases(nonneg int varid, const Token* tok);
+    void writeAll(nonneg int varid, const Token* tok);
+    void use(nonneg int varid, const Token* tok);
+    void modified(nonneg int varid, const Token* tok);
+    VariableUsage *find(nonneg int varid);
+    void alias(nonneg int varid1, nonneg int varid2, bool replace);
+    void erase(nonneg int varid) {
         mVarUsage.erase(varid);
     }
-    void eraseAliases(unsigned int varid);
-    void eraseAll(unsigned int varid);
-    void clearAliases(unsigned int varid);
+    void eraseAliases(nonneg int varid);
+    void eraseAll(nonneg int varid);
+    void clearAliases(nonneg int varid);
 
 private:
 
-    std::map<unsigned int, VariableUsage> mVarUsage;
+    std::map<nonneg int, VariableUsage> mVarUsage;
 };
 
 
@@ -132,7 +192,7 @@ class Variables {
  * merge the aliases when this assignment is in a different scope from the
  * previous assignment depending on the relationship of the 2 scopes.
  */
-void Variables::alias(unsigned int varid1, unsigned int varid2, bool replace)
+void Variables::alias(nonneg int varid1, nonneg int varid2, bool replace)
 {
     VariableUsage *var1 = find(varid1);
     VariableUsage *var2 = find(varid2);
@@ -148,7 +208,7 @@ void Variables::alias(unsigned int varid1, unsigned int varid2, bool replace)
 
     if (replace) {
         // remove var1 from all aliases
-        for (std::set<unsigned int>::const_iterator i = var1->_aliases.begin(); i != var1->_aliases.end(); ++i) {
+        for (auto i = var1->_aliases.cbegin(); i != var1->_aliases.cend(); ++i) {
             VariableUsage *temp = find(*i);
 
             if (temp)
@@ -160,7 +220,7 @@ void Variables::alias(unsigned int varid1, unsigned int varid2, bool replace)
     }
 
     // var1 gets all var2s aliases
-    for (std::set<unsigned int>::const_iterator i = var2->_aliases.begin(); i != var2->_aliases.end(); ++i) {
+    for (auto i = var2->_aliases.cbegin(); i != var2->_aliases.cend(); ++i) {
         if (*i != varid1)
             var1->_aliases.insert(*i);
     }
@@ -174,15 +234,13 @@ void Variables::alias(unsigned int varid1, unsigned int varid2, bool replace)
     }
 }
 
-void Variables::clearAliases(unsigned int varid)
+void Variables::clearAliases(nonneg int varid)
 {
     VariableUsage *usage = find(varid);
 
     if (usage) {
         // remove usage from all aliases
-        std::set<unsigned int>::const_iterator i;
-
-        for (i = usage->_aliases.begin(); i != usage->_aliases.end(); ++i) {
+        for (auto i = usage->_aliases.cbegin(); i != usage->_aliases.cend(); ++i) {
             VariableUsage *temp = find(*i);
 
             if (temp)
@@ -194,17 +252,17 @@ void Variables::clearAliases(unsigned int varid)
     }
 }
 
-void Variables::eraseAliases(unsigned int varid)
+void Variables::eraseAliases(nonneg int varid)
 {
     VariableUsage *usage = find(varid);
 
     if (usage) {
-        for (std::set<unsigned int>::const_iterator aliases = usage->_aliases.begin(); aliases != usage->_aliases.end(); ++aliases)
+        for (auto aliases = usage->_aliases.cbegin(); aliases != usage->_aliases.cend(); ++aliases)
             erase(*aliases);
     }
 }
 
-void Variables::eraseAll(unsigned int varid)
+void Variables::eraseAll(nonneg int varid)
 {
     eraseAliases(varid);
     erase(varid);
@@ -215,11 +273,11 @@ void Variables::addVar(const Variable *var,
                        bool write_)
 {
     if (var->declarationId() > 0) {
-        mVarUsage.insert(std::make_pair(var->declarationId(), VariableUsage(var, type, false, write_, false)));
+        mVarUsage.emplace(var->declarationId(), VariableUsage(var, type, false, write_, false));
     }
 }
 
-void Variables::allocateMemory(unsigned int varid, const Token* tok)
+void Variables::allocateMemory(nonneg int varid, const Token* tok)
 {
     VariableUsage *usage = find(varid);
 
@@ -229,7 +287,7 @@ void Variables::allocateMemory(unsigned int varid, const Token* tok)
     }
 }
 
-void Variables::read(unsigned int varid, const Token* tok)
+void Variables::read(nonneg int varid, const Token* tok)
 {
     VariableUsage *usage = find(varid);
 
@@ -240,13 +298,13 @@ void Variables::read(unsigned int varid, const Token* tok)
     }
 }
 
-void Variables::readAliases(unsigned int varid, const Token* tok)
+void Variables::readAliases(nonneg int varid, const Token* tok)
 {
-    VariableUsage *usage = find(varid);
+    const VariableUsage *usage = find(varid);
 
     if (usage) {
-        for (std::set<unsigned int>::iterator aliases = usage->_aliases.begin(); aliases != usage->_aliases.end(); ++aliases) {
-            VariableUsage *aliased = find(*aliases);
+        for (nonneg int const aliases : usage->_aliases) {
+            VariableUsage *aliased = find(aliases);
 
             if (aliased) {
                 aliased->_read = true;
@@ -256,13 +314,13 @@ void Variables::readAliases(unsigned int varid, const Token* tok)
     }
 }
 
-void Variables::readAll(unsigned int varid, const Token* tok)
+void Variables::readAll(nonneg int varid, const Token* tok)
 {
     read(varid, tok);
     readAliases(varid, tok);
 }
 
-void Variables::write(unsigned int varid, const Token* tok)
+void Variables::write(nonneg int varid, const Token* tok)
 {
     VariableUsage *usage = find(varid);
 
@@ -274,12 +332,12 @@ void Variables::write(unsigned int varid, const Token* tok)
     }
 }
 
-void Variables::writeAliases(unsigned int varid, const Token* tok)
+void Variables::writeAliases(nonneg int varid, const Token* tok)
 {
     VariableUsage *usage = find(varid);
 
     if (usage) {
-        for (std::set<unsigned int>::const_iterator aliases = usage->_aliases.begin(); aliases != usage->_aliases.end(); ++aliases) {
+        for (auto aliases = usage->_aliases.cbegin(); aliases != usage->_aliases.cend(); ++aliases) {
             VariableUsage *aliased = find(*aliases);
 
             if (aliased) {
@@ -290,13 +348,13 @@ void Variables::writeAliases(unsigned int varid, const Token* tok)
     }
 }
 
-void Variables::writeAll(unsigned int varid, const Token* tok)
+void Variables::writeAll(nonneg int varid, const Token* tok)
 {
     write(varid, tok);
     writeAliases(varid, tok);
 }
 
-void Variables::use(unsigned int varid, const Token* tok)
+void Variables::use(nonneg int varid, const Token* tok)
 {
     VariableUsage *usage = find(varid);
 
@@ -304,7 +362,7 @@ void Variables::use(unsigned int varid, const Token* tok)
         usage->use();
         usage->_lastAccess = tok;
 
-        for (std::set<unsigned int>::const_iterator aliases = usage->_aliases.begin(); aliases != usage->_aliases.end(); ++aliases) {
+        for (auto aliases = usage->_aliases.cbegin(); aliases != usage->_aliases.cend(); ++aliases) {
             VariableUsage *aliased = find(*aliases);
 
             if (aliased) {
@@ -315,7 +373,7 @@ void Variables::use(unsigned int varid, const Token* tok)
     }
 }
 
-void Variables::modified(unsigned int varid, const Token* tok)
+void Variables::modified(nonneg int varid, const Token* tok)
 {
     VariableUsage *usage = find(varid);
 
@@ -325,7 +383,7 @@ void Variables::modified(unsigned int varid, const Token* tok)
         usage->_modified = true;
         usage->_lastAccess = tok;
 
-        for (std::set<unsigned int>::const_iterator aliases = usage->_aliases.begin(); aliases != usage->_aliases.end(); ++aliases) {
+        for (auto aliases = usage->_aliases.cbegin(); aliases != usage->_aliases.cend(); ++aliases) {
             VariableUsage *aliased = find(*aliases);
 
             if (aliased) {
@@ -336,10 +394,10 @@ void Variables::modified(unsigned int varid, const Token* tok)
     }
 }
 
-Variables::VariableUsage *Variables::find(unsigned int varid)
+Variables::VariableUsage *Variables::find(nonneg int varid)
 {
     if (varid) {
-        std::map<unsigned int, VariableUsage>::iterator i = mVarUsage.find(varid);
+        const auto i = mVarUsage.find(varid);
         if (i != mVarUsage.end())
             return &i->second;
     }
@@ -362,7 +420,7 @@ static const Token* doAssignment(Variables &variables, const Token *tok, bool de
     const Token* const tokOld = tok;
 
     // check for aliased variable
-    const unsigned int varid1 = tok->varId();
+    const nonneg int varid1 = tok->varId();
     Variables::VariableUsage *var1 = variables.find(varid1);
 
     if (var1) {
@@ -425,6 +483,8 @@ static const Token* doAssignment(Variables &variables, const Token *tok, bool de
                     tok = tok->next();
 
                 tok = tok->next();
+                if (!tok)
+                    return tokOld;
                 if (tok->str() == "*")
                     tok = tok->next();
 
@@ -447,7 +507,7 @@ static const Token* doAssignment(Variables &variables, const Token *tok, bool de
             }
 
             // check if variable is local
-            const unsigned int varid2 = tok->varId();
+            const nonneg int varid2 = tok->varId();
             const Variables::VariableUsage* var2 = variables.find(varid2);
 
             if (var2) { // local variable (alias or read it)
@@ -472,17 +532,15 @@ static const Token* doAssignment(Variables &variables, const Token *tok, bool de
                             else {
                                 // no other assignment in this scope
                                 if (var1->_assignments.find(scope) == var1->_assignments.end() ||
-                                    scope->type == Scope::eSwitch) {
+                                    scope->type == ScopeType::eSwitch) {
                                     // nothing to replace
+                                    // cppcheck-suppress duplicateBranch - remove when TODO below is address
                                     if (var1->_assignments.empty())
                                         replace = false;
 
                                     // this variable has previous assignments
                                     else {
-                                        /**
-                                         * @todo determine if existing aliases should be replaced or merged
-                                         */
-
+                                        // TODO: determine if existing aliases should be replaced or merged
                                         replace = false;
                                     }
                                 }
@@ -554,7 +612,7 @@ static const Token* doAssignment(Variables &variables, const Token *tok, bool de
     else if (Token::Match(tok->tokAt(-2), "%name% .")) {
         const Token *rhsVarTok = tok->tokAt(2);
         if (rhsVarTok && rhsVarTok->varId()) {
-            const unsigned int varid2 = rhsVarTok->varId();
+            const nonneg int varid2 = rhsVarTok->varId();
             const Variables::VariableUsage *var2 = variables.find(varid2);
 
             // struct member aliased to local variable
@@ -569,7 +627,7 @@ static const Token* doAssignment(Variables &variables, const Token *tok, bool de
 
     // Possible pointer alias
     else if (Token::Match(tok, "%name% = %name% ;")) {
-        const unsigned int varid2 = tok->tokAt(2)->varId();
+        const nonneg int varid2 = tok->tokAt(2)->varId();
         const Variables::VariableUsage *var2 = variables.find(varid2);
         if (var2 && (var2->mType == Variables::array ||
                      var2->mType == Variables::pointer)) {
@@ -586,7 +644,7 @@ static bool isPartOfClassStructUnion(const Token* tok)
         if (tok->str() == "}" || tok->str() == ")")
             tok = tok->link();
         else if (tok->str() == "(")
-            return (false);
+            return false;
         else if (tok->str() == "{") {
             return (tok->strAt(-1) == "struct" || tok->strAt(-2) == "struct" || tok->strAt(-1) == "class" || tok->strAt(-2) == "class" || tok->strAt(-1) == "union" || tok->strAt(-2) == "union");
         }
@@ -594,6 +652,11 @@ static bool isPartOfClassStructUnion(const Token* tok)
     return false;
 }
 
+static bool isVarDecl(const Token *tok)
+{
+    return tok && tok->variable() && tok->variable()->nameToken() == tok;
+}
+
 // Skip [ .. ]
 static const Token * skipBrackets(const Token *tok)
 {
@@ -636,24 +699,24 @@ static void useFunctionArgs(const Token *tok, Variables& variables)
 //---------------------------------------------------------------------------
 // Usage of function variables
 //---------------------------------------------------------------------------
-void CheckUnusedVar::checkFunctionVariableUsage_iterateScopes(const Scope* const scope, Variables& variables)
+void CheckUnusedVar::checkFunctionVariableUsage_iterateScopes(const Scope* const scope, Variables& variables) const
 {
     // Find declarations if the scope is executable..
     if (scope->isExecutable()) {
         // Find declarations
-        for (std::list<Variable>::const_iterator i = scope->varlist.begin(); i != scope->varlist.end(); ++i) {
+        for (auto i = scope->varlist.cbegin(); i != scope->varlist.cend(); ++i) {
             if (i->isThrow() || i->isExtern())
                 continue;
             Variables::VariableType type = Variables::none;
-            if (i->isArray() && (i->nameToken()->previous()->str() == "*" || i->nameToken()->strAt(-2) == "*"))
+            if (i->isArray() && (i->nameToken()->strAt(-1) == "*" || i->nameToken()->strAt(-2) == "*"))
                 type = Variables::pointerArray;
-            else if (i->isArray() && i->nameToken()->previous()->str() == "&")
+            else if (i->isArray() && i->nameToken()->strAt(-1) == "&")
                 type = Variables::referenceArray;
             else if (i->isArray())
-                type = (i->dimensions().size() == 1U) ? Variables::array : Variables::pointerArray;
-            else if (i->isReference())
+                type = Variables::array;
+            else if (i->isReference() && !(i->valueType() && i->valueType()->type == ValueType::UNKNOWN_TYPE && Token::simpleMatch(i->typeStartToken(), "auto")))
                 type = Variables::reference;
-            else if (i->nameToken()->previous()->str() == "*" && i->nameToken()->strAt(-2) == "*")
+            else if (i->nameToken()->strAt(-1) == "*" && i->nameToken()->strAt(-2) == "*")
                 type = Variables::pointerPointer;
             else if (i->isPointerToArray())
                 type = Variables::pointerPointer;
@@ -661,10 +724,12 @@ void CheckUnusedVar::checkFunctionVariableUsage_iterateScopes(const Scope* const
                 type = Variables::pointer;
             else if (mTokenizer->isC() ||
                      i->typeEndToken()->isStandardType() ||
-                     isRecordTypeWithoutSideEffects(i->type()) ||
-                     (i->isStlType() &&
-                      !Token::Match(i->typeStartToken()->tokAt(2), "lock_guard|unique_lock|shared_ptr|unique_ptr|auto_ptr|shared_lock")))
+                     i->isStlType() ||
+                     mTokenizer->getSymbolDatabase()->isRecordTypeWithoutSideEffects(i->type()) ||
+                     mSettings->library.detectContainer(i->typeStartToken()) ||
+                     mSettings->library.getTypeCheck("unusedvar", i->typeStartToken()->str()) == Library::TypeCheck::check)
                 type = Variables::standard;
+
             if (type == Variables::none || isPartOfClassStructUnion(i->typeStartToken()))
                 continue;
             const Token* defValTok = i->nameToken()->next();
@@ -677,18 +742,19 @@ void CheckUnusedVar::checkFunctionVariableUsage_iterateScopes(const Scope* const
                     variables.addVar(&*i, type, true);
                     break;
                 } else if (defValTok->str() == ";" || defValTok->str() == "," || defValTok->str() == ")") {
-                    variables.addVar(&*i, type, i->isStatic());
+                    variables.addVar(&*i, type, i->isStatic() && i->scope()->type != ScopeType::eFunction);
                     break;
                 }
             }
-            if (i->isArray() && i->isClass()) // Array of class/struct members. Initialized by ctor.
+            if (i->isArray() && i->isClass() && // Array of class/struct members. Initialized by ctor except for std::array
+                !(i->isStlType() && i->valueType() && i->valueType()->containerTypeToken && i->valueType()->containerTypeToken->isStandardType()))
                 variables.write(i->declarationId(), i->nameToken());
             if (i->isArray() && Token::Match(i->nameToken(), "%name% [ %var% ]")) // Array index variable read.
                 variables.read(i->nameToken()->tokAt(2)->varId(), i->nameToken());
 
             if (defValTok && defValTok->next()) {
                 // simple assignment "var = 123"
-                if (defValTok->str() == "=" && defValTok->next()->str() != "{") {
+                if (defValTok->str() == "=" && defValTok->strAt(1) != "{") {
                     doAssignment(variables, i->nameToken(), false, scope);
                 } else {
                     // could be "var = {...}" OR "var{...}" (since C++11)
@@ -715,18 +781,17 @@ void CheckUnusedVar::checkFunctionVariableUsage_iterateScopes(const Scope* const
 
     // Check variable usage
     const Token *tok;
-    if (scope->type == Scope::eFunction)
+    if (scope->type == ScopeType::eFunction)
         tok = scope->bodyStart->next();
     else
         tok = scope->classDef->next();
     for (; tok && tok != scope->bodyEnd; tok = tok->next()) {
         if (tok->str() == "{" && tok != scope->bodyStart && !tok->previous()->varId()) {
-            for (const Scope *i : scope->nestedList) {
-                if (i->bodyStart == tok) { // Find associated scope
-                    checkFunctionVariableUsage_iterateScopes(tok->scope(), variables); // Scan child scope
-                    tok = tok->link();
-                    break;
-                }
+            if (std::any_of(scope->nestedList.cbegin(), scope->nestedList.cend(), [&](const Scope* s) {
+                return s->bodyStart == tok;
+            })) {
+                checkFunctionVariableUsage_iterateScopes(tok->scope(), variables); // Scan child scope
+                tok = tok->link();
             }
             if (!tok)
                 break;
@@ -740,9 +805,8 @@ void CheckUnusedVar::checkFunctionVariableUsage_iterateScopes(const Scope* const
         // templates
         if (tok->isName() && endsWith(tok->str(), '>')) {
             // TODO: This is a quick fix to handle when constants are used
-            // as template parameters. Try to handle this better, perhaps
-            // only remove constants.
-            variables.clear();
+            // as template parameters.
+            variables.clearConst();
         }
 
         else if (Token::Match(tok->previous(), "[;{}]")) {
@@ -756,7 +820,7 @@ void CheckUnusedVar::checkFunctionVariableUsage_iterateScopes(const Scope* const
                     // Mark template parameters used in declaration as use..
                     if (tok2->strAt(-1) == ">") {
                         for (const Token *tok3 = tok; tok3 != tok2; tok3 = tok3->next()) {
-                            if (tok3->varId() > 0U)
+                            if (tok3->varId())
                                 variables.use(tok3->varId(), tok3);
                         }
                     }
@@ -778,14 +842,15 @@ void CheckUnusedVar::checkFunctionVariableUsage_iterateScopes(const Scope* const
                     } else if (var->typeEndToken()->str() == ">") // Be careful with types like std::vector
                         tok = tok->previous();
                     break;
-                } else if (Token::Match(tok2, "[;({=]"))
+                }
+                if (Token::Match(tok2, "[;({=]"))
                     break;
             }
         }
         // Freeing memory (not considered "using" the pointer if it was also allocated in this function)
-        if (Token::Match(tok, "free|g_free|kfree|vfree ( %var% )") ||
-            (mTokenizer->isCPP() && (Token::Match(tok, "delete %var% ;") || Token::Match(tok, "delete [ ] %var% ;")))) {
-            unsigned int varid = 0;
+        if ((Token::Match(tok, "%name% ( %var% )") && mSettings->library.getDeallocFuncInfo(tok)) ||
+            (tok->isCpp() && (Token::Match(tok, "delete %var% ;") || Token::Match(tok, "delete [ ] %var% ;")))) {
+            nonneg int varid = 0;
             if (tok->str() != "delete") {
                 const Token *varTok = tok->tokAt(2);
                 varid = varTok->varId();
@@ -843,7 +908,7 @@ void CheckUnusedVar::checkFunctionVariableUsage_iterateScopes(const Scope* const
             if (tok->next()->tokType() == Token::eIncDecOp)
                 post = true;
 
-            const unsigned int varid1 = tok->varId();
+            const nonneg int varid1 = tok->varId();
             const Token * const start = tok;
 
             // assignment in while head..
@@ -888,39 +953,37 @@ void CheckUnusedVar::checkFunctionVariableUsage_iterateScopes(const Scope* const
                 }
                 // Consider allocating memory separately because allocating/freeing alone does not constitute using the variable
                 else if (var && var->mType == Variables::pointer &&
-                         Token::Match(start, "%name% = new|malloc|calloc|kmalloc|kzalloc|kcalloc|strdup|strndup|vmalloc|g_new0|g_try_new|g_new|g_malloc|g_malloc0|g_try_malloc|g_try_malloc0|g_strdup|g_strndup|g_strdup_printf")) {
-                    bool allocate = true;
+                         Token::Match(start, "%name% =") &&
+                         findAllocFuncCallToken(start->next()->astOperand2(), mSettings->library)) {
 
-                    if (start->strAt(2) == "new") {
-                        const Token *type = start->tokAt(3);
+                    const Token *allocFuncCallToken = findAllocFuncCallToken(start->next()->astOperand2(), mSettings->library);
+                    const Library::AllocFunc *allocFunc = mSettings->library.getAllocFuncInfo(allocFuncCallToken);
+
+                    bool allocateMemory = !allocFunc || Library::ismemory(allocFunc->groupId);
+
+                    if (allocFuncCallToken->str() == "new") {
+                        const Token *type = allocFuncCallToken->next();
 
                         // skip nothrow
-                        if (mTokenizer->isCPP() && (Token::simpleMatch(type, "( nothrow )") ||
-                                                    Token::simpleMatch(type, "( std :: nothrow )")))
+                        if (type->isCpp() && (Token::simpleMatch(type, "( nothrow )") ||
+                                              Token::simpleMatch(type, "( std :: nothrow )")))
                             type = type->link()->next();
 
                         // is it a user defined type?
                         if (!type->isStandardType()) {
                             const Variable *variable = start->variable();
-                            if (!variable || !isRecordTypeWithoutSideEffects(variable->type()))
-                                allocate = false;
+                            if (!variable || !mTokenizer->getSymbolDatabase()->isRecordTypeWithoutSideEffects(variable->type()))
+                                allocateMemory = false;
                         }
                     }
 
-                    if (allocate)
+                    if (allocateMemory)
                         variables.allocateMemory(varid1, tok);
                     else
                         variables.write(varid1, tok);
                 } else if (varid1 && Token::Match(tok, "%varid% .", varid1)) {
                     variables.read(varid1, tok);
                     variables.write(varid1, start);
-                } else if (var &&
-                           var->mType == Variables::pointer &&
-                           Token::Match(tok, "%name% ;") &&
-                           tok->varId() == 0 &&
-                           tok->hasKnownIntValue() &&
-                           tok->values().front().intvalue == 0) {
-                    variables.use(varid1, tok);
                 } else {
                     variables.write(varid1, tok);
                 }
@@ -943,7 +1006,7 @@ void CheckUnusedVar::checkFunctionVariableUsage_iterateScopes(const Scope* const
 
             // checked for chained assignments
             if (tok != start && equal && equal->str() == "=") {
-                const unsigned int varId = tok->varId();
+                const nonneg int varId = tok->varId();
                 const Variables::VariableUsage * const var = variables.find(varId);
 
                 if (var && var->mType != Variables::reference) {
@@ -956,7 +1019,7 @@ void CheckUnusedVar::checkFunctionVariableUsage_iterateScopes(const Scope* const
 
         // assignment
         else if ((Token::Match(tok, "%name% [") && Token::simpleMatch(skipBracketsAndMembers(tok->next()), "=")) ||
-                 (Token::simpleMatch(tok, "* (") && Token::simpleMatch(tok->next()->link(), ") ="))) {
+                 (tok->isUnaryOp("*") && astIsLHS(tok) && Token::simpleMatch(tok->astParent(), "=") && Token::simpleMatch(tok->astOperand1(), "+"))) {
             const Token *eq = tok;
             while (eq && !eq->isAssignmentOp())
                 eq = eq->astParent();
@@ -969,13 +1032,14 @@ void CheckUnusedVar::checkFunctionVariableUsage_iterateScopes(const Scope* const
                     tok = tok->link()->next();
             }
 
-            const unsigned int varid = tok->varId();
+            const nonneg int varid = tok->varId();
             const Variables::VariableUsage *var = variables.find(varid);
 
             if (var) {
                 // Consider allocating memory separately because allocating/freeing alone does not constitute using the variable
                 if (var->mType == Variables::pointer &&
-                    Token::Match(skipBrackets(tok->next()), "= new|malloc|calloc|kmalloc|kzalloc|kcalloc|strdup|strndup|vmalloc|g_new0|g_try_new|g_new|g_malloc|g_malloc0|g_try_malloc|g_try_malloc0|g_strdup|g_strndup|g_strdup_printf")) {
+                    ((tok->isCpp() && Token::simpleMatch(skipBrackets(tok->next()), "= new")) ||
+                     (Token::Match(skipBrackets(tok->next()), "= %name% (") && mSettings->library.getAllocFuncInfo(tok->tokAt(2))))) {
                     variables.allocateMemory(varid, tok);
                 } else if (var->mType == Variables::pointer || var->mType == Variables::reference) {
                     variables.read(varid, tok);
@@ -987,7 +1051,7 @@ void CheckUnusedVar::checkFunctionVariableUsage_iterateScopes(const Scope* const
             }
         }
 
-        else if (mTokenizer->isCPP() && Token::Match(tok, "[;{}] %var% <<")) {
+        else if (tok->isCpp() && Token::Match(tok, "[;{}] %var% <<")) {
             variables.erase(tok->next()->varId());
         }
 
@@ -997,43 +1061,48 @@ void CheckUnusedVar::checkFunctionVariableUsage_iterateScopes(const Scope* const
             } else // addressof
                 variables.use(tok->next()->varId(), tok); // use = read + write
         } else if (Token::Match(tok, ">>|>>= %name%")) {
-            if (isLikelyStreamRead(mTokenizer->isCPP(), tok))
+            if (isLikelyStreamRead(tok))
                 variables.use(tok->next()->varId(), tok); // use = read + write
             else
                 variables.read(tok->next()->varId(), tok);
         } else if (Token::Match(tok, "%var% >>|&") && Token::Match(tok->previous(), "[{};:]")) {
             variables.read(tok->varId(), tok);
-        } else if (isLikelyStreamRead(mTokenizer->isCPP(),tok->previous())) {
+        } else if (isLikelyStreamRead(tok->previous())) {
             variables.use(tok->varId(), tok);
         }
 
         // function parameter
         else if (Token::Match(tok, "[(,] %var% [")) {
             variables.use(tok->next()->varId(), tok);   // use = read + write
-        } else if (Token::Match(tok, "[(,] %var% [,)]") && tok->previous()->str() != "*") {
+        } else if (Token::Match(tok, "[(,] %var% [,)]") && tok->strAt(-1) != "*") {
             variables.use(tok->next()->varId(), tok);   // use = read + write
         } else if (Token::Match(tok, "[(,] & %var% [,)]")) {
             variables.eraseAll(tok->tokAt(2)->varId());
         } else if (Token::Match(tok, "[(,] (") &&
-                   Token::Match(tok->next()->link(), ") %var% [,)]")) {
-            variables.use(tok->next()->link()->next()->varId(), tok);   // use = read + write
-        } else if (Token::Match(tok, "[(,] *| %var% =")) {
-            tok = tok->next();
-            if (tok->str() == "*")
-                tok = tok->next();
-            variables.use(tok->varId(), tok);
+                   Token::Match(tok->linkAt(1), ") %var% [,)[]")) {
+            variables.use(tok->linkAt(1)->next()->varId(), tok);   // use = read + write
+        } else if (Token::Match(tok, "[(,] *| *| %var%")) {
+            const Token* vartok = tok->next();
+            while (vartok->str() == "*")
+                vartok = vartok->next();
+            if (!(vartok->variable() && vartok == vartok->variable()->nameToken()) &&
+                !(tok->str() == "(" && !Token::Match(tok->previous(), "%name%")))
+                variables.use(vartok->varId(), vartok);
         }
 
         // function
         else if (Token::Match(tok, "%name% (")) {
-            variables.read(tok->varId(), tok);
+            if (tok->varId() && !tok->function()) // operator()
+                variables.use(tok->varId(), tok);
+            else
+                variables.read(tok->varId(), tok);
             useFunctionArgs(tok->next()->astOperand2(), variables);
         } else if (Token::Match(tok, "std :: ref ( %var% )")) {
             variables.eraseAll(tok->tokAt(4)->varId());
         }
 
         else if (Token::Match(tok->previous(), "[{,] %var% [,}]")) {
-            variables.read(tok->varId(), tok);
+            variables.use(tok->varId(), tok);
         }
 
         else if (tok->varId() && Token::Match(tok, "%var% .")) {
@@ -1047,11 +1116,11 @@ void CheckUnusedVar::checkFunctionVariableUsage_iterateScopes(const Scope* const
                 variables.use(tok->astOperand2()->varId(), tok->astOperand2());
         }
 
-        else if (tok->isExtendedOp() && tok->next() && tok->next()->varId() && tok->strAt(2) != "=") {
+        else if (tok->isExtendedOp() && tok->next() && tok->next()->varId() && tok->strAt(2) != "=" && !isVarDecl(tok->next())) {
             variables.readAll(tok->next()->varId(), tok);
         }
 
-        else if (tok->varId() && tok->next() && (tok->next()->str() == ")" || tok->next()->isExtendedOp())) {
+        else if (tok->varId() && !isVarDecl(tok) && tok->next() && (tok->strAt(1) == ")" || tok->next()->isExtendedOp())) {
             if (Token::Match(tok->tokAt(-2), "%name% ( %var% [,)]") &&
                 !(tok->tokAt(-2)->variable() && tok->tokAt(-2)->variable()->isReference()))
                 variables.use(tok->varId(), tok);
@@ -1082,26 +1151,69 @@ void CheckUnusedVar::checkFunctionVariableUsage_iterateScopes(const Scope* const
                         variables.read(tok2->varId(), tok);
                 }
             }
+        } else if (tok->variable() && tok->variable()->isClass() && tok->variable()->type() &&
+                   (tok->variable()->type()->needInitialization == Type::NeedInitialization::False) &&
+                   tok->strAt(1) == ";") {
+            variables.write(tok->varId(), tok);
         }
     }
 }
 
+static bool isReturnedByRef(const Variable* var, const Function* func)
+{
+    if (!func || !Function::returnsReference(func, true))
+        return false;
+    const std::vector<const Token*> returns = Function::findReturns(func);
+    return std::any_of(returns.begin(), returns.end(), [var](const Token* tok) {
+        return tok->varId() == var->declarationId();
+    });
+}
+
 void CheckUnusedVar::checkFunctionVariableUsage()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->checkLibrary && !mSettings->isPremiumEnabled("unusedVariable"))
         return;
 
+    logChecker("CheckUnusedVar::checkFunctionVariableUsage"); // style
+
     // Parse all executing scopes..
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
+    auto reportLibraryCfgError = [this](const Token* tok, const std::string& typeName) {
+        if (mSettings->checkLibrary) {
+            reportError(tok,
+                        Severity::information,
+                        "checkLibraryCheckType",
+                        "--check-library: Provide <type-checks><unusedvar> configuration for " + typeName);
+        }
+    };
+
     // only check functions
     for (const Scope * scope : symbolDatabase->functionScopes) {
         // Bailout when there are lambdas or inline functions
         // TODO: Handle lambdas and inline functions properly
-        if (scope->hasInlineOrLambdaFunction())
-            continue;
+        const Token* lambdaOrInlineStart{};
+        const bool hasLambdaOrInline = scope->hasInlineOrLambdaFunction(&lambdaOrInlineStart);
+
+        const Token *nextStructuredBindingTok = nullptr;
+        std::vector<std::pair<const Token*, const Token*>> unusedStructuredBindingTokens;
+        size_t structuredBindingTokCount = 0;
+        std::set<const Variable*> diagUnreadVariable; // prevent duplicate warnings
 
         for (const Token *tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
+            if (nextStructuredBindingTok) {
+                tok = nextStructuredBindingTok;
+            } else {
+                if (structuredBindingTokCount > 0 && structuredBindingTokCount == unusedStructuredBindingTokens.size()) {
+                    for (const auto &pair : unusedStructuredBindingTokens) {
+                        unreadVariableError(pair.first, pair.second->expressionString(), false);
+                    }
+                }
+                structuredBindingTokCount = 0;
+                unusedStructuredBindingTokens.clear();
+            }
+            nextStructuredBindingTok = nullptr;
+
             if (findLambdaEndToken(tok))
                 // todo: handle lambdas
                 break;
@@ -1111,8 +1223,20 @@ void CheckUnusedVar::checkFunctionVariableUsage()
             const Token *varDecl = nullptr;
             if (tok->variable() && tok->variable()->nameToken() == tok) {
                 const Token * eq = tok->next();
+                if (isStructuredBindingVariable(tok->variable())) {
+                    structuredBindingTokCount++;
+                    while (!Token::simpleMatch(eq, "]")) {
+                        eq = eq->next();
+                        if (eq->variable() && !nextStructuredBindingTok)
+                            nextStructuredBindingTok = eq;
+                    }
+                    if (eq)
+                        eq = eq->next();
+                }
                 while (Token::simpleMatch(eq, "["))
                     eq = eq->link()->next();
+                if (Token::simpleMatch(eq, ") (") && Token::simpleMatch(eq->linkAt(1), ") ="))
+                    eq = eq->linkAt(1)->next();
                 if (Token::simpleMatch(eq, "=")) {
                     varDecl = tok;
                     tok = eq;
@@ -1120,45 +1244,31 @@ void CheckUnusedVar::checkFunctionVariableUsage()
             }
             // not assignment/initialization/increment => continue
             const bool isAssignment = tok->isAssignmentOp() && tok->astOperand1();
-            const bool isInitialization = (Token::Match(tok, "%var% (") && tok->variable() && tok->variable()->nameToken() == tok);
+            const bool isInitialization = (Token::Match(tok, "%var% (|{") && tok->variable() && tok->variable()->nameToken() == tok);
             const bool isIncrementOrDecrement = (tok->tokType() == Token::Type::eIncDecOp);
             if (!isAssignment && !isInitialization && !isIncrementOrDecrement)
                 continue;
+
+            bool isTrivialInit = false;
+            if (isInitialization && Token::Match(tok, "%var% { }")) // don't warn for trivial initialization
+                isTrivialInit = true;
+
+            if (isIncrementOrDecrement && tok->astParent() && precedes(tok, tok->astOperand1()))
+                continue;
+
+            if (tok->str() == "=" && !(tok->valueType() && tok->valueType()->pointer) && isRaiiClass(tok->valueType(), tok->isCpp(), false))
+                continue;
+
+            const bool isPointer = tok->valueType() && (tok->valueType()->pointer || tok->valueType()->type == ValueType::SMART_POINTER);
+
             if (tok->isName()) {
-                if (mTokenizer->isCPP()) {
-                    // do not check RAII/scope_lock objects
-                    if (!tok->valueType())
-                        continue;
-                    bool check = false;
-                    switch (tok->valueType()->type) {
-                    case ValueType::Type::UNKNOWN_TYPE:
-                    case ValueType::Type::NONSTD:
-                    case ValueType::Type::RECORD:
-                        check = tok->valueType()->typeScope && !tok->valueType()->typeScope->getDestructor();
-                        break;
-                    case ValueType::Type::CONTAINER:
-                    case ValueType::Type::ITERATOR:
-                    case ValueType::Type::VOID:
-                    case ValueType::Type::BOOL:
-                    case ValueType::Type::CHAR:
-                    case ValueType::Type::SHORT:
-                    case ValueType::Type::WCHAR_T:
-                    case ValueType::Type::INT:
-                    case ValueType::Type::LONG:
-                    case ValueType::Type::LONGLONG:
-                    case ValueType::Type::UNKNOWN_INT:
-                    case ValueType::Type::FLOAT:
-                    case ValueType::Type::DOUBLE:
-                    case ValueType::Type::LONGDOUBLE:
-                        check = true;
-                        break;
-                    };
-                    if (!check)
-                        continue;
-                }
+                if (isRaiiClass(tok->valueType(), tok->isCpp(), false) ||
+                    (tok->valueType() && tok->valueType()->type == ValueType::RECORD &&
+                     (!tok->valueType()->typeScope || !symbolDatabase->isRecordTypeWithoutSideEffects(tok->valueType()->typeScope->definedType))))
+                    continue;
                 tok = tok->next();
             }
-            if (tok->astParent() && tok->str() != "(") {
+            if (!isInitialization && tok->astParent() && !tok->astParent()->isAssignmentOp() && tok->str() != "(") {
                 const Token *parent = tok->astParent();
                 while (Token::Match(parent, "%oror%|%comp%|!|&&"))
                     parent = parent->astParent();
@@ -1168,39 +1278,101 @@ void CheckUnusedVar::checkFunctionVariableUsage()
                     continue;
             }
             // Do not warn about assignment with NULL
-            if (FwdAnalysis::isNullOperand(tok->astOperand2()))
+            if (isPointer && isNullOperand(tok->astOperand2()))
                 continue;
 
             if (!tok->astOperand1())
                 continue;
 
-            const Token *iteratorToken = tok->astOperand1();
-            while (Token::Match(iteratorToken, "[.*]"))
-                iteratorToken = iteratorToken->astOperand1();
-            if (iteratorToken && iteratorToken->variable() && iteratorToken->variable()->typeEndToken()->str().find("iterator") != std::string::npos)
-                continue;
+            const Token *op1tok = tok->astOperand1();
+            while (Token::Match(op1tok, ".|[|*"))
+                op1tok = op1tok->astOperand1();
 
-            const Variable *op1Var = tok->astOperand1() ? tok->astOperand1()->variable() : nullptr;
-            if (op1Var && op1Var->isReference() && op1Var->nameToken() != tok->astOperand1())
-                // todo: check references
+            // Assignment in macro => do not warn
+            if (isAssignment && tok->isExpandedMacro() && op1tok && op1tok->isExpandedMacro())
                 continue;
 
-            if (op1Var && op1Var->isStatic())
-                // todo: check static variables
-                continue;
+            const Variable *op1Var = op1tok ? op1tok->variable() : nullptr;
+            if (!op1Var && Token::Match(tok, "(|{") && tok->previous() && tok->previous()->variable())
+                op1Var = tok->previous()->variable();
+            if (hasLambdaOrInline) {
+                if (!op1Var || !lambdaOrInlineStart)
+                    continue;
+                if (precedes(op1Var->nameToken(), lambdaOrInlineStart))
+                    continue;
+            }
 
-            if (op1Var && op1Var->nameToken()->isAttributeUnused())
-                continue;
+            std::string bailoutTypeName;
+            if (op1Var) {
+                if (op1Var->isReference() && op1Var->nameToken() != tok->astOperand1())
+                    // todo: check references
+                    continue;
+
+                if (op1Var->isStatic())
+                    // todo: check static variables
+                    continue;
+
+                if (op1Var->nameToken()->isAttributeUnused())
+                    continue;
+
+                // Avoid FP for union..
+                if (op1Var->type() && op1Var->type()->isUnionType())
+                    continue;
+
+                // Bailout for unknown template classes, we have no idea what side effects such assignments have
+                if (mTokenizer->isCPP() &&
+                    op1Var->isClass() &&
+                    (!op1Var->valueType() || op1Var->valueType()->type == ValueType::Type::UNKNOWN_TYPE)) {
+                    // Check in the library if we should bailout or not..
+                    std::string typeName = op1Var->getTypeName();
+                    if (startsWith(typeName, "::"))
+                        typeName.erase(typeName.begin(), typeName.begin() + 2);
+                    switch (mSettings->library.getTypeCheck("unusedvar", typeName)) {
+                    case Library::TypeCheck::def:
+                        bailoutTypeName = std::move(typeName);
+                        break;
+                    case Library::TypeCheck::check:
+                        break;
+                    case Library::TypeCheck::suppress:
+                    case Library::TypeCheck::checkFiniteLifetime:
+                        continue;
+                    }
+                }
+            }
 
             // Is there a redundant assignment?
             const Token *start = tok->findExpressionStartEndTokens().second->next();
 
             const Token *expr = varDecl ? varDecl : tok->astOperand1();
 
-            FwdAnalysis fwdAnalysis(mTokenizer->isCPP(), mSettings->library);
-            if (fwdAnalysis.unusedValue(expr, start, scope->bodyEnd))
+            if (isInitialization)
+                expr = tok->previous();
+
+            // Is variable in lhs a union member?
+            if (tok->previous() && tok->previous()->variable() && tok->previous()->variable()->nameToken()->scope()->type == ScopeType::eUnion)
+                continue;
+
+            FwdAnalysis fwdAnalysis(*mSettings);
+            const Token* scopeEnd = ValueFlow::getEndOfExprScope(expr, scope, /*smallest*/ false);
+            if (fwdAnalysis.unusedValue(expr, start, scopeEnd)) {
+                if (!bailoutTypeName.empty()) {
+                    if (bailoutTypeName != "auto")
+                        reportLibraryCfgError(tok, bailoutTypeName);
+                    continue;
+                }
+                if (isTrivialInit && findExpressionChanged(expr, start, scopeEnd, *mSettings))
+                    continue;
+
                 // warn
-                unreadVariableError(tok, expr->expressionString(), false);
+                if (!expr->variable() || !expr->variable()->isMaybeUnused()) {
+                    if (structuredBindingTokCount > 0)
+                        unusedStructuredBindingTokens.emplace_back(tok, expr);
+                    else {
+                        unreadVariableError(tok, expr->expressionString(), false);
+                        diagUnreadVariable.emplace(expr->variable());
+                    }
+                }
+            }
         }
 
         // varId, usage {read, write, modified}
@@ -1210,8 +1382,8 @@ void CheckUnusedVar::checkFunctionVariableUsage()
 
 
         // Check usage of all variables in the current scope..
-        for (std::map<unsigned int, Variables::VariableUsage>::const_iterator it = variables.varUsage().begin();
-             it != variables.varUsage().end();
+        for (auto it = variables.varUsage().cbegin();
+             it != variables.varUsage().cend();
              ++it) {
             const Variables::VariableUsage &usage = it->second;
 
@@ -1234,41 +1406,95 @@ void CheckUnusedVar::checkFunctionVariableUsage()
                 allocatedButUnusedVariableError(usage._lastAccess, varname);
 
             // variable has not been written, read, or modified
-            else if (usage.unused() && !usage._modified)
-                unusedVariableError(usage._var->nameToken(), varname);
-
+            else if (usage.unused() && !usage._modified) {
+                if (!usage._var->isMaybeUnused()) {
+                    unusedVariableError(usage._var->nameToken(), varname);
+                }
+            }
             // variable has not been written but has been modified
-            else if (usage._modified && !usage._write && !usage._allocateMemory && var && !var->isStlType())
+            else if (usage._modified && !usage._write && !usage._allocateMemory && var && !var->isStlType()) {
+                if (var->isStatic()) // static variables are initialized by default
+                    continue;
                 unassignedVariableError(usage._var->nameToken(), varname);
-
+            }
             // variable has been read but not written
-            else if (!usage._write && !usage._allocateMemory && var && !var->isStlType() && !isEmptyType(var->type()))
+            else if (!usage._write && !usage._allocateMemory && var && !var->isStlType() && !isEmptyType(var->type()) &&
+                     !(var->type() && var->type()->needInitialization == Type::NeedInitialization::False) &&
+                     !(var->valueType() && var->valueType()->container) &&
+                     !(var->isStatic() && isReturnedByRef(var, scope->function)))
                 unassignedVariableError(usage._var->nameToken(), varname);
+            else if (!usage._var->isMaybeUnused() && !usage._modified && !usage._read && var && diagUnreadVariable.count(usage._var) == 0) {
+                const Token* vnt = var->nameToken();
+                bool error = false;
+                if (vnt->next()->isSplittedVarDeclEq() || (!var->isReference() && vnt->strAt(1) == "=")) {
+                    const Token* nextStmt = vnt->tokAt(2);
+                    if (nextStmt->isExpandedMacro()) {
+                        const Token* parent = nextStmt;
+                        while (parent->astParent() && parent == parent->astParent()->astOperand1())
+                            parent = parent->astParent();
+                        if (parent->isAssignmentOp() && parent->isExpandedMacro())
+                            continue;
+                    }
+                    while (nextStmt && nextStmt->str() != ";")
+                        nextStmt = nextStmt->next();
+                    error = precedes(usage._lastAccess, nextStmt);
+                }
+                if (error) {
+                    if (mTokenizer->isCPP() && var->isClass() &&
+                        (!var->valueType() || var->valueType()->type == ValueType::Type::UNKNOWN_TYPE)) {
+                        const std::string typeName = var->getTypeName();
+                        switch (mSettings->library.getTypeCheck("unusedvar", typeName)) {
+                        case Library::TypeCheck::def:
+                            reportLibraryCfgError(vnt, typeName);
+                            break;
+                        case Library::TypeCheck::check:
+                            break;
+                        case Library::TypeCheck::suppress:
+                        case Library::TypeCheck::checkFiniteLifetime:
+                            error = false;
+                        }
+                    }
+                    if (error)
+                        unreadVariableError(vnt, varname, false);
+                }
+            }
         }
     }
 }
 
 void CheckUnusedVar::unusedVariableError(const Token *tok, const std::string &varname)
 {
-    reportError(tok, Severity::style, "unusedVariable", "$symbol:" + varname + "\nUnused variable: $symbol", CWE563, false);
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("unusedVariable"))
+        return;
+
+    reportError(tok, Severity::style, "unusedVariable", "$symbol:" + varname + "\nUnused variable: $symbol", CWE563, Certainty::normal);
 }
 
 void CheckUnusedVar::allocatedButUnusedVariableError(const Token *tok, const std::string &varname)
 {
-    reportError(tok, Severity::style, "unusedAllocatedMemory", "$symbol:" + varname + "\nVariable '$symbol' is allocated memory that is never used.", CWE563, false);
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("unusedVariable"))
+        return;
+
+    reportError(tok, Severity::style, "unusedAllocatedMemory", "$symbol:" + varname + "\nVariable '$symbol' is allocated memory that is never used.", CWE563, Certainty::normal);
 }
 
 void CheckUnusedVar::unreadVariableError(const Token *tok, const std::string &varname, bool modified)
 {
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("unusedVariable"))
+        return;
+
     if (modified)
-        reportError(tok, Severity::style, "unreadVariable", "$symbol:" + varname + "\nVariable '$symbol' is modified but its new value is never used.", CWE563, false);
+        reportError(tok, Severity::style, "unreadVariable", "$symbol:" + varname + "\nVariable '$symbol' is modified but its new value is never used.", CWE563, Certainty::normal);
     else
-        reportError(tok, Severity::style, "unreadVariable", "$symbol:" + varname + "\nVariable '$symbol' is assigned a value that is never used.", CWE563, false);
+        reportError(tok, Severity::style, "unreadVariable", "$symbol:" + varname + "\nVariable '$symbol' is assigned a value that is never used.", CWE563, Certainty::normal);
 }
 
 void CheckUnusedVar::unassignedVariableError(const Token *tok, const std::string &varname)
 {
-    reportError(tok, Severity::style, "unassignedVariable", "$symbol:" + varname + "\nVariable '$symbol' is not assigned a value.", CWE665, false);
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("unusedVariable"))
+        return;
+
+    reportError(tok, Severity::style, "unassignedVariable", "$symbol:" + varname + "\nVariable '$symbol' is not assigned a value.", CWE665, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -1276,57 +1502,56 @@ void CheckUnusedVar::unassignedVariableError(const Token *tok, const std::string
 //---------------------------------------------------------------------------
 void CheckUnusedVar::checkStructMemberUsage()
 {
-    if (!mSettings->isEnabled(Settings::STYLE))
+    if (!mSettings->severity.isEnabled(Severity::style) && !mSettings->isPremiumEnabled("unusedStructMember") && !mSettings->isPremiumEnabled("unusedVariable"))
         return;
 
+    logChecker("CheckUnusedVar::checkStructMemberUsage"); // style
+
     const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();
 
     for (const Scope &scope : symbolDatabase->scopeList) {
-        if (scope.type != Scope::eStruct && scope.type != Scope::eUnion)
+        if (scope.type != ScopeType::eStruct && scope.type != ScopeType::eClass && scope.type != ScopeType::eUnion)
             continue;
 
         if (scope.bodyStart->fileIndex() != 0 || scope.className.empty())
             continue;
 
+        if (scope.classDef->isExpandedMacro())
+            continue;
+
         // Packed struct => possibly used by lowlevel code. Struct members might be required by hardware.
         if (scope.bodyEnd->isAttributePacked())
             continue;
-
-        // Bail out if struct/union contains any functions
-        if (!scope.functionList.empty())
+        if (mTokenizer->isPacked(scope.bodyStart))
             continue;
 
         // Bail out for template struct, members might be used in non-matching instantiations
-        if (scope.className.find("<") != std::string::npos)
+        if (scope.className.find('<') != std::string::npos)
             continue;
 
         // bail out if struct is inherited
-        bool bailout = false;
-        for (const Scope &derivedScope : symbolDatabase->scopeList) {
-            if (derivedScope.definedType) {
-                for (const Type::BaseInfo &derivedFrom : derivedScope.definedType->derivedFrom) {
-                    if (derivedFrom.type == scope.definedType) {
-                        bailout = true;
-                        break;
-                    }
-                }
-            }
-        }
-        if (bailout)
-            continue;
+        const bool isInherited = std::any_of(symbolDatabase->scopeList.cbegin(), symbolDatabase->scopeList.cend(), [&](const Scope& derivedScope) {
+            const Type* dType = derivedScope.definedType;
+            return dType && std::any_of(dType->derivedFrom.cbegin(), dType->derivedFrom.cend(), [&](const Type::BaseInfo& derivedFrom) {
+                return derivedFrom.type == scope.definedType && derivedFrom.access != AccessControl::Private;
+            });
+        });
 
         // bail out for extern/global struct
+        bool bailout = false;
         for (const Variable* var : symbolDatabase->variableList()) {
             if (var && (var->isExtern() || (var->isGlobal() && !var->isStatic())) && var->typeEndToken()->str() == scope.className) {
                 bailout = true;
                 break;
             }
+            if (bailout)
+                break;
         }
         if (bailout)
             continue;
 
         // Bail out if some data is casted to struct..
-        const std::string castPattern("( struct| " + scope.className + " * ) & %name% [");
+        const std::string castPattern("( struct| " + scope.className + " * ) &| %name%");
         if (Token::findmatch(scope.bodyEnd, castPattern.c_str()))
             continue;
 
@@ -1346,55 +1571,119 @@ void CheckUnusedVar::checkStructMemberUsage()
         if (bailout)
             continue;
 
-        // Try to prevent false positives when struct members are not used directly.
-        if (Token::findmatch(scope.bodyEnd, (scope.className + " %type%| *").c_str()))
+        // Bailout if struct is used in structured binding
+        for (const Variable *var : symbolDatabase->variableList()) {
+            if (!var || !Token::Match(var->typeStartToken(), "auto &|&&| [ %varid%", var->declarationId()))
+                continue;
+
+            const Token *tok = var->nameToken()->linkAt(-1);
+            if (Token::Match(tok, "] %assign%"))
+            {
+                tok = tok->next()->astOperand2();
+                const ValueType *valueType = tok->valueType();
+
+                if (valueType && valueType->typeScope == &scope) {
+                    bailout = true;
+                    break;
+                }
+            }
+
+            if (Token::simpleMatch(tok, "] :")) {
+                tok = tok->next()->astOperand2();
+                const ValueType *valueType = tok->valueType();
+
+                if (!valueType || !valueType->containerTypeToken)
+                    continue;
+
+                const Type *type = valueType->containerTypeToken->type();
+                if (type && type->classScope == &scope) {
+                    bailout = true;
+                    break;
+                }
+            }
+        }
+        if (bailout)
             continue;
 
-        for (const Variable &var : scope.varlist) {
-            // declaring a POD member variable?
-            if (!var.typeStartToken()->isStandardType() && !var.isPointer())
-                continue;
+        // #7458 - if struct is declared inside union and any struct member is used,
+        // then don't warn about other struct members
+        if (scope.type == ScopeType::eStruct && scope.nestedIn && scope.nestedIn->type == ScopeType::eUnion) {
+            bool structMemberUsed = false;
 
-            // Check if the struct member variable is used anywhere in the file
-            if (Token::findsimplematch(mTokenizer->tokens(), (". " + var.name()).c_str()))
-                continue;
+            for (const Token *tok = scope.nestedIn->bodyStart; tok; tok = tok->next()) {
+                if (tok->variable() && tok != tok->variable()->nameToken() && tok->variable()->scope() == &scope) {
+                    structMemberUsed = true;
+                    break;
+                }
+            }
 
-            unusedStructMemberError(var.nameToken(), scope.className, var.name(), scope.type == Scope::eUnion);
+            // Skip reporting unused members if this struct is in a union and any member is used
+            if (structMemberUsed)
+                continue;
         }
-    }
-}
 
-void CheckUnusedVar::unusedStructMemberError(const Token *tok, const std::string &structname, const std::string &varname, bool isUnion)
-{
-    const std::string prefix = isUnion ? "union member " : "struct member ";
-    reportError(tok, Severity::style, "unusedStructMember", "$symbol:" + structname + "::" + varname + '\n' + prefix + "'$symbol' is never used.", CWE563, false);
-}
+        for (const Variable &var : scope.varlist) {
+            // only warn for variables without side effects
+            if (!var.typeStartToken()->isStandardType() && !var.isPointer() && !astIsContainer(var.nameToken()) && !mTokenizer->getSymbolDatabase()->isRecordTypeWithoutSideEffects(var.type()))
+                continue;
+            if (isInherited && !var.isPrivate())
+                continue;
 
-bool CheckUnusedVar::isRecordTypeWithoutSideEffects(const Type* type)
-{
-    // a type that has no side effects (no constructors and no members with constructors)
-    /** @todo false negative: check constructors for side effects */
+            if (!var.nameToken() || var.nameToken()->isAttributeUnused() || var.nameToken()->isAttributeMaybeUnused() || var.nameToken()->isAnonymous())
+                continue;
 
-    const std::pair<std::map<const Type *,bool>::iterator,bool> found=mIsRecordTypeWithoutSideEffectsMap.insert(
-                std::pair<const Type *,bool>(type,false)); //Initialize with side effects for possible recursions
-    bool & withoutSideEffects=found.first->second;
-    if (!found.second)
-        return withoutSideEffects;
+            if (mTokenizer->isVarUsedInTemplate(var.declarationId()))
+                continue;
 
-    if (type && type->classScope && type->classScope->numConstructors == 0 &&
-        (type->classScope->varlist.empty() || type->needInitialization == Type::NeedInitialization::True)) {
-        for (std::vector<Type::BaseInfo>::const_iterator i = type->derivedFrom.begin(); i != type->derivedFrom.end(); ++i) {
-            if (!isRecordTypeWithoutSideEffects(i->type)) {
-                withoutSideEffects=false;
-                return withoutSideEffects;
+            // Check if the struct member variable is used anywhere in the file
+            bool use = false;
+            for (const Token *tok = mTokenizer->tokens(); tok; tok = tok->next()) {
+                if (Token::Match(tok, ". %name%") && !tok->next()->variable() && !tok->next()->function() && tok->strAt(1) == var.name()) {
+                    // not known => assume variable is used
+                    use = true;
+                    break;
+                }
+                // Member referenced in offsetof
+                if (Token::Match(tok, ("offsetof ( struct| " + scope.className + " , %name%").c_str())) {
+                    tok = Token::simpleMatch(tok->tokAt(2), "struct") ? tok->tokAt(5) : tok->tokAt(4);
+                    if (tok->str() == var.name()) {
+                        use = true;
+                        break;
+                    }
+                }
+                // Member referenced in alignas
+                if (tok->hasAttributeAlignas()) {
+                    const std::vector<std::string> alignasExpressions = tok->getAttributeAlignas();
+                    use = std::any_of(alignasExpressions.cbegin(),
+                                      alignasExpressions.cend(),
+                                      [&var](const std::string& alignasExpr){
+                        return alignasExpr == var.name();
+                    });
+                    if (use)
+                        break;
+                }
+                if (tok->variable() != &var)
+                    continue;
+                if (tok != var.nameToken()) {
+                    use = true;
+                    break;
+                }
+            }
+            if (!use) {
+                std::string prefix = "struct";
+                if (scope.type == ScopeType::eClass)
+                    prefix = "class";
+                else if (scope.type == ScopeType::eUnion)
+                    prefix = "union";
+                unusedStructMemberError(var.nameToken(), scope.className, var.name(), prefix);
             }
         }
-        withoutSideEffects=true;
-        return withoutSideEffects;
     }
+}
 
-    withoutSideEffects=false;   // unknown types are assumed to have side effects
-    return withoutSideEffects;
+void CheckUnusedVar::unusedStructMemberError(const Token* tok, const std::string& structname, const std::string& varname, const std::string& prefix)
+{
+    reportError(tok, Severity::style, "unusedStructMember", "$symbol:" + structname + "::" + varname + '\n' + prefix + " member '$symbol' is never used.", CWE563, Certainty::normal);
 }
 
 bool CheckUnusedVar::isEmptyType(const Type* type)
@@ -1402,23 +1691,37 @@ bool CheckUnusedVar::isEmptyType(const Type* type)
     // a type that has no variables and no constructor
 
     const std::pair<std::map<const Type *,bool>::iterator,bool> found=mIsEmptyTypeMap.insert(
-                std::pair<const Type *,bool>(type,false));
+        std::pair<const Type *,bool>(type,false));
     bool & emptyType=found.first->second;
     if (!found.second)
         return emptyType;
 
     if (type && type->classScope && type->classScope->numConstructors == 0 &&
         (type->classScope->varlist.empty())) {
-        for (std::vector<Type::BaseInfo>::const_iterator i = type->derivedFrom.begin(); i != type->derivedFrom.end(); ++i) {
-            if (!isEmptyType(i->type)) {
-                emptyType=false;
-                return emptyType;
-            }
-        }
-        emptyType=true;
-        return emptyType;
+        return (emptyType = std::all_of(type->derivedFrom.cbegin(), type->derivedFrom.cend(), [this](const Type::BaseInfo& bi) {
+            return isEmptyType(bi.type);
+        }));
     }
 
-    emptyType=false;   // unknown types are assumed to be nonempty
-    return emptyType;
+    // unknown types are assumed to be nonempty
+    return (emptyType = false);
+}
+
+void CheckUnusedVar::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    CheckUnusedVar checkUnusedVar(&tokenizer, &tokenizer.getSettings(), errorLogger);
+
+    // Coding style checks
+    checkUnusedVar.checkStructMemberUsage();
+    checkUnusedVar.checkFunctionVariableUsage();
+}
+
+void CheckUnusedVar::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const
+{
+    CheckUnusedVar c(nullptr, settings, errorLogger);
+    c.unusedVariableError(nullptr, "varname");
+    c.allocatedButUnusedVariableError(nullptr, "varname");
+    c.unreadVariableError(nullptr, "varname", false);
+    c.unassignedVariableError(nullptr, "varname");
+    c.unusedStructMemberError(nullptr, "structname", "variable");
 }
diff --git a/lib/checkunusedvar.h b/lib/checkunusedvar.h
index db330932bc5..5ab79514cf9 100644
--- a/lib/checkunusedvar.h
+++ b/lib/checkunusedvar.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -31,9 +31,9 @@ class ErrorLogger;
 class Scope;
 class Settings;
 class Token;
-class Tokenizer;
 class Type;
 class Variables;
+class Tokenizer;
 
 /// @addtogroup Checks
 /// @{
@@ -42,71 +42,53 @@ class Variables;
 /** @brief Various small checks */
 
 class CPPCHECKLIB CheckUnusedVar : public Check {
+    friend class TestUnusedVar;
+
 public:
     /** @brief This constructor is used when registering the CheckClass */
-    CheckUnusedVar() : Check(myName()) {
-    }
+    CheckUnusedVar() : Check(myName()) {}
 
+private:
     /** @brief This constructor is used when running checks. */
     CheckUnusedVar(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger) {}
 
     /** @brief Run checks against the normal token list */
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        CheckUnusedVar checkUnusedVar(tokenizer, settings, errorLogger);
-
-        // Coding style checks
-        checkUnusedVar.checkStructMemberUsage();
-        checkUnusedVar.checkFunctionVariableUsage();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     /** @brief %Check for unused function variables */
-    void checkFunctionVariableUsage_iterateScopes(const Scope* const scope, Variables& variables);
+    void checkFunctionVariableUsage_iterateScopes(const Scope* scope, Variables& variables) const;
     void checkFunctionVariableUsage();
 
     /** @brief %Check that all struct members are used */
     void checkStructMemberUsage();
 
-private:
-    bool isRecordTypeWithoutSideEffects(const Type* type);
     bool isEmptyType(const Type* type);
 
     // Error messages..
-    void unusedStructMemberError(const Token *tok, const std::string &structname, const std::string &varname, bool isUnion = false);
+    void unusedStructMemberError(const Token *tok, const std::string &structname, const std::string &varname, const std::string& prefix = "struct");
     void unusedVariableError(const Token *tok, const std::string &varname);
     void allocatedButUnusedVariableError(const Token *tok, const std::string &varname);
     void unreadVariableError(const Token *tok, const std::string &varname, bool modified);
     void unassignedVariableError(const Token *tok, const std::string &varname);
 
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        CheckUnusedVar c(nullptr, settings, errorLogger);
-
-        // style/warning
-        c.unusedVariableError(nullptr, "varname");
-        c.allocatedButUnusedVariableError(nullptr, "varname");
-        c.unreadVariableError(nullptr, "varname", false);
-        c.unassignedVariableError(nullptr, "varname");
-        c.unusedStructMemberError(nullptr, "structname", "variable");
-    }
+    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const override;
 
     static std::string myName() {
         return "UnusedVar";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "UnusedVar checks\n"
 
                // style
                "- unused variable\n"
                "- allocated but unused variable\n"
-               "- unred variable\n"
+               "- unread variable\n"
                "- unassigned variable\n"
                "- unused struct member\n";
     }
 
-    std::map<const Type *,bool> mIsRecordTypeWithoutSideEffectsMap;
-
     std::map<const Type *,bool> mIsEmptyTypeMap;
 
 };
diff --git a/lib/checkvaarg.cpp b/lib/checkvaarg.cpp
index 527d68802fb..96c65ea41a2 100644
--- a/lib/checkvaarg.cpp
+++ b/lib/checkvaarg.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,14 +19,16 @@
 #include "checkvaarg.h"
 
 #include "astutils.h"
-#include "errorlogger.h"
+#include "errortypes.h"
 #include "settings.h"
 #include "symboldatabase.h"
 #include "token.h"
 #include "tokenize.h"
 
 #include <cstddef>
+#include <iterator>
 #include <list>
+#include <vector>
 
 //---------------------------------------------------------------------------
 
@@ -41,15 +43,17 @@ namespace {
 //---------------------------------------------------------------------------
 
 // CWE ids used:
-static const struct CWE CWE664(664U);   // Improper Control of a Resource Through its Lifetime
-static const struct CWE CWE688(688U);   // Function Call With Incorrect Variable or Reference as Argument
-static const struct CWE CWE758(758U);   // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior
+static const CWE CWE664(664U);   // Improper Control of a Resource Through its Lifetime
+static const CWE CWE688(688U);   // Function Call With Incorrect Variable or Reference as Argument
+static const CWE CWE758(758U);   // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior
 
 void CheckVaarg::va_start_argument()
 {
     const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
     const std::size_t functions = symbolDatabase->functionScopes.size();
-    const bool printWarnings = mSettings->isEnabled(Settings::WARNING);
+    const bool printWarnings = mSettings->severity.isEnabled(Severity::warning);
+
+    logChecker("CheckVaarg::va_start_argument");
 
     for (std::size_t i = 0; i < functions; ++i) {
         const Scope* scope = symbolDatabase->functionScopes[i];
@@ -67,9 +71,9 @@ void CheckVaarg::va_start_argument()
                 if (var && var->isReference())
                     referenceAs_va_start_error(param2, var->name());
                 if (var && var->index() + 2 < function->argCount() && printWarnings) {
-                    std::list<Variable>::const_reverse_iterator it = function->argumentList.rbegin();
-                    ++it;
-                    wrongParameterTo_va_start_error(tok, var->name(), it->name());
+                    auto it = function->argumentList.end();
+                    std::advance(it, -2);
+                    wrongParameterTo_va_start_error(tok, var->name(), it->name()); // cppcheck-suppress derefInvalidIterator // FP due to isVariableChangedByFunctionCall()
                 }
                 tok = tok->linkAt(1);
             }
@@ -80,13 +84,13 @@ void CheckVaarg::va_start_argument()
 void CheckVaarg::wrongParameterTo_va_start_error(const Token *tok, const std::string& paramIsName, const std::string& paramShouldName)
 {
     reportError(tok, Severity::warning,
-                "va_start_wrongParameter", "'" + paramIsName + "' given to va_start() is not last named argument of the function. Did you intend to pass '" + paramShouldName + "'?", CWE688, false);
+                "va_start_wrongParameter", "'" + paramIsName + "' given to va_start() is not last named argument of the function. Did you intend to pass '" + paramShouldName + "'?", CWE688, Certainty::normal);
 }
 
 void CheckVaarg::referenceAs_va_start_error(const Token *tok, const std::string& paramName)
 {
     reportError(tok, Severity::error,
-                "va_start_referencePassed", "Using reference '" + paramName + "' as parameter for va_start() results in undefined behaviour.", CWE758, false);
+                "va_start_referencePassed", "Using reference '" + paramName + "' as parameter for va_start() results in undefined behaviour.", CWE758, Certainty::normal);
 }
 
 //---------------------------------------------------------------------------
@@ -96,6 +100,11 @@ void CheckVaarg::referenceAs_va_start_error(const Token *tok, const std::string&
 
 void CheckVaarg::va_list_usage()
 {
+    if (mSettings->clang)
+        return;
+
+    logChecker("CheckVaarg::va_list_usage"); // notclang
+
     const SymbolDatabase* const symbolDatabase = mTokenizer->getSymbolDatabase();
     for (const Variable* var : symbolDatabase->variableList()) {
         if (!var || var->isPointer() || var->isReference() || var->isArray() || !var->scope() || var->typeStartToken()->str() != "va_list")
@@ -107,7 +116,7 @@ void CheckVaarg::va_list_usage()
         bool exitOnEndOfStatement = false;
 
         const Token* tok = var->nameToken()->next();
-        for (;  tok && tok != var->scope()->bodyEnd; tok = tok->next()) {
+        for (; tok && tok != var->scope()->bodyEnd; tok = tok->next()) {
             // Skip lambdas
             const Token* tok2 = findLambdaEndToken(tok);
             if (tok2)
@@ -138,13 +147,10 @@ void CheckVaarg::va_list_usage()
             } else if (Token::Match(tok, "throw|return"))
                 exitOnEndOfStatement = true;
             else if (tok->str() == "break") {
-                const Scope* scope = tok->scope();
-                while (scope->nestedIn && scope->type != Scope::eFor && scope->type != Scope::eWhile && scope->type != Scope::eDo && scope->type != Scope::eSwitch)
-                    scope = scope->nestedIn;
-                tok = scope->bodyEnd;
+                tok = findNextTokenFromBreak(tok);
                 if (!tok)
                     return;
-            } else if (tok->str() == "goto" || (mTokenizer->isCPP() && tok->str() == "try")) {
+            } else if (tok->str() == "goto" || (tok->isCpp() && tok->str() == "try")) {
                 open = false;
                 break;
             } else if (!open && tok->varId() == var->declarationId())
@@ -160,17 +166,34 @@ void CheckVaarg::va_list_usage()
 void CheckVaarg::va_end_missingError(const Token *tok, const std::string& varname)
 {
     reportError(tok, Severity::error,
-                "va_end_missing", "va_list '" + varname + "' was opened but not closed by va_end().", CWE664, false);
+                "va_end_missing", "va_list '" + varname + "' was opened but not closed by va_end().", CWE664, Certainty::normal);
 }
 
 void CheckVaarg::va_list_usedBeforeStartedError(const Token *tok, const std::string& varname)
 {
     reportError(tok, Severity::error,
-                "va_list_usedBeforeStarted", "va_list '" + varname + "' used before va_start() was called.", CWE664, false);
+                "va_list_usedBeforeStarted", "va_list '" + varname + "' used before va_start() was called.", CWE664, Certainty::normal);
 }
 
 void CheckVaarg::va_start_subsequentCallsError(const Token *tok, const std::string& varname)
 {
     reportError(tok, Severity::error,
-                "va_start_subsequentCalls", "va_start() or va_copy() called subsequently on '" + varname + "' without va_end() in between.", CWE664, false);
+                "va_start_subsequentCalls", "va_start() or va_copy() called subsequently on '" + varname + "' without va_end() in between.", CWE664, Certainty::normal);
+}
+
+void CheckVaarg::runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+{
+    CheckVaarg check(&tokenizer, &tokenizer.getSettings(), errorLogger);
+    check.va_start_argument();
+    check.va_list_usage();
+}
+
+void CheckVaarg::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const
+{
+    CheckVaarg c(nullptr, settings, errorLogger);
+    c.wrongParameterTo_va_start_error(nullptr, "arg1", "arg2");
+    c.referenceAs_va_start_error(nullptr, "arg1");
+    c.va_end_missingError(nullptr, "vl");
+    c.va_list_usedBeforeStartedError(nullptr, "vl");
+    c.va_start_subsequentCallsError(nullptr, "vl");
 }
diff --git a/lib/checkvaarg.h b/lib/checkvaarg.h
index 55021e14599..7af5d98d66f 100644
--- a/lib/checkvaarg.h
+++ b/lib/checkvaarg.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -41,43 +41,30 @@ class Tokenizer;
 
 class CPPCHECKLIB CheckVaarg : public Check {
 public:
-    CheckVaarg() : Check(myName()) {
-    }
+    CheckVaarg() : Check(myName()) {}
 
+private:
     CheckVaarg(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-        : Check(myName(), tokenizer, settings, errorLogger) {
-    }
+        : Check(myName(), tokenizer, settings, errorLogger) {}
 
-    void runChecks(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger) OVERRIDE {
-        CheckVaarg check(tokenizer, settings, errorLogger);
-        check.va_start_argument();
-        check.va_list_usage();
-    }
+    void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger) override;
 
     void va_start_argument();
     void va_list_usage();
 
-private:
     void wrongParameterTo_va_start_error(const Token *tok, const std::string& paramIsName, const std::string& paramShouldName);
     void referenceAs_va_start_error(const Token *tok, const std::string& paramName);
     void va_end_missingError(const Token *tok, const std::string& varname);
     void va_list_usedBeforeStartedError(const Token *tok, const std::string& varname);
     void va_start_subsequentCallsError(const Token *tok, const std::string& varname);
 
-    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const OVERRIDE {
-        CheckVaarg c(nullptr, settings, errorLogger);
-        c.wrongParameterTo_va_start_error(nullptr, "arg1", "arg2");
-        c.referenceAs_va_start_error(nullptr, "arg1");
-        c.va_end_missingError(nullptr, "vl");
-        c.va_list_usedBeforeStartedError(nullptr, "vl");
-        c.va_start_subsequentCallsError(nullptr, "vl");
-    }
+    void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings) const override;
 
     static std::string myName() {
         return "Vaarg";
     }
 
-    std::string classInfo() const OVERRIDE {
+    std::string classInfo() const override {
         return "Check for misusage of variable argument lists:\n"
                "- Wrong parameter passed to va_start()\n"
                "- Reference passed to va_start()\n"
diff --git a/lib/clangimport.cpp b/lib/clangimport.cpp
new file mode 100644
index 00000000000..c96a678347a
--- /dev/null
+++ b/lib/clangimport.cpp
@@ -0,0 +1,1689 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "clangimport.h"
+
+#include "errortypes.h"
+#include "mathlib.h"
+#include "standards.h"
+#include "symboldatabase.h"
+#include "token.h"
+#include "tokenize.h"
+#include "tokenlist.h"
+#include "utils.h"
+#include "vfvalue.h"
+
+#include <algorithm>
+#include <cctype>
+#include <cstring>
+#include <iostream>
+#include <iterator>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <sstream>
+#include <stack>
+#include <string>
+#include <utility>
+#include <vector>
+#include <numeric>
+
+class Settings;
+
+static const std::string AccessSpecDecl = "AccessSpecDecl";
+static const std::string ArraySubscriptExpr = "ArraySubscriptExpr";
+static const std::string BinaryOperator = "BinaryOperator";
+static const std::string BreakStmt = "BreakStmt";
+static const std::string CallExpr = "CallExpr";
+static const std::string CaseStmt = "CaseStmt";
+static const std::string CharacterLiteral = "CharacterLiteral";
+static const std::string ClassTemplateDecl = "ClassTemplateDecl";
+static const std::string ClassTemplateSpecializationDecl = "ClassTemplateSpecializationDecl";
+static const std::string ConditionalOperator = "ConditionalOperator";
+static const std::string ConstantExpr = "ConstantExpr";
+static const std::string CompoundAssignOperator = "CompoundAssignOperator";
+static const std::string CompoundStmt = "CompoundStmt";
+static const std::string ContinueStmt = "ContinueStmt";
+static const std::string CStyleCastExpr = "CStyleCastExpr";
+static const std::string CXXBindTemporaryExpr = "CXXBindTemporaryExpr";
+static const std::string CXXBoolLiteralExpr = "CXXBoolLiteralExpr";
+static const std::string CXXConstructorDecl = "CXXConstructorDecl";
+static const std::string CXXConstructExpr = "CXXConstructExpr";
+static const std::string CXXDefaultArgExpr = "CXXDefaultArgExpr";
+static const std::string CXXDeleteExpr = "CXXDeleteExpr";
+static const std::string CXXDestructorDecl = "CXXDestructorDecl";
+static const std::string CXXForRangeStmt = "CXXForRangeStmt";
+static const std::string CXXFunctionalCastExpr = "CXXFunctionalCastExpr";
+static const std::string CXXMemberCallExpr = "CXXMemberCallExpr";
+static const std::string CXXMethodDecl = "CXXMethodDecl";
+static const std::string CXXNewExpr = "CXXNewExpr";
+static const std::string CXXNullPtrLiteralExpr = "CXXNullPtrLiteralExpr";
+static const std::string CXXOperatorCallExpr = "CXXOperatorCallExpr";
+static const std::string CXXRecordDecl = "CXXRecordDecl";
+static const std::string CXXStaticCastExpr = "CXXStaticCastExpr";
+static const std::string CXXStdInitializerListExpr = "CXXStdInitializerListExpr";
+static const std::string CXXTemporaryObjectExpr = "CXXTemporaryObjectExpr";
+static const std::string CXXThisExpr = "CXXThisExpr";
+static const std::string CXXThrowExpr = "CXXThrowExpr";
+static const std::string DeclRefExpr = "DeclRefExpr";
+static const std::string DeclStmt = "DeclStmt";
+static const std::string DefaultStmt = "DefaultStmt";
+static const std::string DoStmt = "DoStmt";
+static const std::string EnumConstantDecl = "EnumConstantDecl";
+static const std::string EnumDecl = "EnumDecl";
+static const std::string ExprWithCleanups = "ExprWithCleanups";
+static const std::string FieldDecl = "FieldDecl";
+static const std::string FloatingLiteral = "FloatingLiteral";
+static const std::string ForStmt = "ForStmt";
+static const std::string FunctionDecl = "FunctionDecl";
+static const std::string FunctionTemplateDecl = "FunctionTemplateDecl";
+static const std::string GotoStmt = "GotoStmt";
+static const std::string IfStmt = "IfStmt";
+static const std::string ImplicitCastExpr = "ImplicitCastExpr";
+static const std::string InitListExpr = "InitListExpr";
+static const std::string IntegerLiteral = "IntegerLiteral";
+static const std::string LabelStmt = "LabelStmt";
+static const std::string LinkageSpecDecl = "LinkageSpecDecl";
+static const std::string MaterializeTemporaryExpr = "MaterializeTemporaryExpr";
+static const std::string MemberExpr = "MemberExpr";
+static const std::string NamespaceDecl = "NamespaceDecl";
+static const std::string NullStmt = "NullStmt";
+static const std::string ParenExpr = "ParenExpr";
+static const std::string ParmVarDecl = "ParmVarDecl";
+static const std::string RecordDecl = "RecordDecl";
+static const std::string ReturnStmt = "ReturnStmt";
+static const std::string StringLiteral = "StringLiteral";
+static const std::string SwitchStmt = "SwitchStmt";
+static const std::string TemplateArgument = "TemplateArgument";
+static const std::string TypedefDecl = "TypedefDecl";
+static const std::string UnaryOperator = "UnaryOperator";
+static const std::string UnaryExprOrTypeTraitExpr = "UnaryExprOrTypeTraitExpr";
+static const std::string VarDecl = "VarDecl";
+static const std::string WhileStmt = "WhileStmt";
+
+static std::string unquote(const std::string &s)
+{
+    return (s[0] == '\'') ? s.substr(1, s.size() - 2) : s;
+}
+
+
+static std::vector<std::string> splitString(const std::string &line)
+{
+    std::vector<std::string> ret;
+    std::string::size_type pos1 = line.find_first_not_of(' ');
+    while (pos1 < line.size()) {
+        std::string::size_type pos2;
+        if (std::strchr("*()", line[pos1])) {
+            ret.push_back(line.substr(pos1,1));
+            pos1 = line.find_first_not_of(' ', pos1 + 1);
+            continue;
+        }
+        if (line[pos1] == '<')
+            pos2 = line.find('>', pos1);
+        else if (line[pos1] == '\"')
+            pos2 = line.find('\"', pos1+1);
+        else if (line[pos1] == '\'') {
+            pos2 = line.find('\'', pos1+1);
+            if (pos2 < static_cast<int>(line.size()) - 3 && line.compare(pos2, 3, "\':\'", 0, 3) == 0)
+                pos2 = line.find('\'', pos2 + 3);
+        } else {
+            pos2 = pos1;
+            while (pos2 < line.size() && (line[pos2] == '_' || line[pos2] == ':' || std::isalnum(static_cast<unsigned char>(line[pos2]))))
+                ++pos2;
+            if (pos2 > pos1 && pos2 < line.size() && line[pos2] == '<' && std::isalpha(line[pos1])) {
+                int tlevel = 1;
+                while (++pos2 < line.size() && tlevel > 0) {
+                    if (line[pos2] == '<')
+                        ++tlevel;
+                    else if (line[pos2] == '>')
+                        --tlevel;
+                }
+                if (tlevel == 0 && pos2 < line.size() && line[pos2] == ' ') {
+                    ret.push_back(line.substr(pos1, pos2-pos1));
+                    pos1 = pos2 + 1;
+                    continue;
+                }
+            }
+
+            pos2 = line.find(' ', pos1) - 1;
+            if ((std::isalpha(line[pos1]) || line[pos1] == '_') &&
+                line.find("::", pos1) < pos2 &&
+                line.find("::", pos1) < line.find('<', pos1)) {
+                pos2 = line.find("::", pos1);
+                ret.push_back(line.substr(pos1, pos2-pos1));
+                ret.emplace_back("::");
+                pos1 = pos2 + 2;
+                continue;
+            }
+            if ((std::isalpha(line[pos1]) || line[pos1] == '_') &&
+                line.find('<', pos1) < pos2 &&
+                line.find("<<",pos1) != line.find('<',pos1) &&
+                line.find('>', pos1) != std::string::npos &&
+                line.find('>', pos1) > pos2) {
+                int level = 0;
+                for (pos2 = pos1; pos2 < line.size(); ++pos2) {
+                    if (line[pos2] == '<')
+                        ++level;
+                    else if (line[pos2] == '>') {
+                        if (level <= 1)
+                            break;
+                        --level;
+                    }
+                }
+                if (level > 1 && pos2 + 1 >= line.size())
+                    return std::vector<std::string> {};
+                pos2 = line.find(' ', pos2);
+                if (pos2 != std::string::npos)
+                    --pos2;
+            }
+        }
+        if (pos2 == std::string::npos) {
+            ret.push_back(line.substr(pos1));
+            break;
+        }
+        ret.push_back(line.substr(pos1, pos2+1-pos1));
+        pos1 = line.find_first_not_of(' ', pos2 + 1);
+    }
+    return ret;
+}
+
+
+namespace clangimport {
+    struct Data {
+        struct Decl {
+            explicit Decl(Scope *scope) : scope(scope) {}
+            Decl(Token *def, Variable *var) : def(def), var(var) {}
+            Decl(Token *def, Function *function) : def(def), function(function) {}
+            Decl(Token *def, Enumerator *enumerator) : def(def), enumerator(enumerator) {}
+            void ref(Token *tok) const {
+                if (enumerator)
+                    tok->enumerator(enumerator);
+                if (function)
+                    tok->function(function);
+                if (var) {
+                    tok->variable(var);
+                    tok->varId(var->declarationId());
+                }
+            }
+            Token* def{};
+            Enumerator* enumerator{};
+            Function* function{};
+            Scope* scope{};
+            Variable* var{};
+        };
+
+        Data(const Settings& settings, SymbolDatabase& symbolDatabase)
+            : mSettings(settings)
+            , mSymbolDatabase(symbolDatabase)
+        {}
+
+        const Settings &mSettings;
+        SymbolDatabase &mSymbolDatabase;
+
+        int enumValue = 0;
+
+        void enumDecl(const std::string &addr, Token *nameToken, Enumerator *enumerator) {
+            Decl decl(nameToken, enumerator);
+            mDeclMap.emplace(addr, decl);
+            nameToken->enumerator(enumerator);
+            notFound(addr);
+        }
+
+        void funcDecl(const std::string &addr, Token *nameToken, Function *function) {
+            Decl decl(nameToken, function);
+            mDeclMap.emplace(addr, decl);
+            nameToken->function(function);
+            notFound(addr);
+        }
+
+        void scopeDecl(const std::string &addr, Scope *scope) {
+            Decl decl(scope);
+            mDeclMap.emplace(addr, decl);
+        }
+
+        void varDecl(const std::string &addr, Token *def, Variable *var) {
+            Decl decl(def, var);
+            mDeclMap.emplace(addr, decl);
+            def->varId(++mVarId);
+            def->variable(var);
+            if (def->valueType())
+                var->setValueType(*def->valueType());
+            notFound(addr);
+        }
+
+        void replaceVarDecl(const Variable *from, Variable *to) {
+            for (auto &it: mDeclMap) {
+                Decl &decl = it.second;
+                if (decl.var == from)
+                    decl.var = to;
+            }
+        }
+
+        void ref(const std::string &addr, Token *tok) {
+            auto it = mDeclMap.find(addr);
+            if (it != mDeclMap.end())
+                it->second.ref(tok);
+            else
+                mNotFound[addr].push_back(tok);
+        }
+
+        std::vector<const Variable *> getVariableList() const {
+            std::vector<const Variable *> ret;
+            ret.resize(mVarId + 1, nullptr);
+            for (const auto& it: mDeclMap) {
+                if (it.second.var)
+                    ret[it.second.var->declarationId()] = it.second.var;
+            }
+            return ret;
+        }
+
+        bool hasDecl(const std::string &addr) const {
+            return mDeclMap.find(addr) != mDeclMap.end();
+        }
+
+        const Scope *getScope(const std::string &addr) {
+            auto it = mDeclMap.find(addr);
+            return (it == mDeclMap.end() ? nullptr : it->second.scope);
+        }
+
+        // "}" tokens that are not end-of-scope
+        std::set<Token *> mNotScope;
+
+        std::map<const Scope *, AccessControl> scopeAccessControl;
+    private:
+        void notFound(const std::string &addr) {
+            auto it = mNotFound.find(addr);
+            if (it != mNotFound.end()) {
+                for (Token *reftok: it->second)
+                    ref(addr, reftok);
+                mNotFound.erase(it);
+            }
+        }
+
+        std::map<std::string, Decl> mDeclMap;
+        std::map<std::string, std::vector<Token *>> mNotFound;
+        int mVarId = 0;
+    };
+
+    class AstNode;
+    using AstNodePtr = std::shared_ptr<AstNode>;
+
+    class AstNode {
+    public:
+        AstNode(std::string nodeType, const std::string &ext, Data *data)
+            : nodeType(std::move(nodeType)), mExtTokens(splitString(ext)), mData(data)
+        {}
+        std::string nodeType;
+        std::vector<AstNodePtr> children;
+
+        bool isPrologueTypedefDecl() const;
+        /**
+         * @throws InternalError thrown if AST location is invalid
+         */
+        void setLocations(TokenList &tokenList, int file, int line, int col);
+
+        void dumpAst(int num = 0, int indent = 0) const;
+        void createTokens1(TokenList &tokenList) {
+            //dumpAst(); // TODO: reactivate or remove
+            if (isPrologueTypedefDecl())
+                return;
+            if (!tokenList.back()) {
+                setLocations(tokenList, 0, 1, 1);
+            }
+            else
+                setLocations(tokenList, tokenList.back()->fileIndex(), tokenList.back()->linenr(), 1);
+            createTokens(tokenList);
+            if (nodeType == VarDecl || nodeType == RecordDecl || nodeType == TypedefDecl)
+                addtoken(tokenList, ";");
+            mData->mNotScope.clear();
+        }
+
+        /**
+         * @throws InternalError thrown if index is out of bounds
+         */
+        AstNodePtr getChild(int c) {
+            if (c >= children.size()) {
+                std::ostringstream err;
+                err << "ClangImport: AstNodePtr::getChild(" << c << ") out of bounds. children.size=" << children.size() << " " << nodeType;
+                for (const std::string &s: mExtTokens)
+                    err << " " << s;
+                throw InternalError(nullptr, err.str());
+            }
+            return children[c];
+        }
+    private:
+        /**
+         * @throws InternalError thrown if CXXForRangeStmt cannot be imported
+         */
+        Token *createTokens(TokenList &tokenList);
+        Token *addtoken(TokenList &tokenList, const std::string &str, bool valueType=true);
+        const ::Type *addTypeTokens(TokenList &tokenList, const std::string &str, const Scope *scope = nullptr);
+        void addFullScopeNameTokens(TokenList &tokenList, const Scope *recordScope);
+        Scope *createScope(TokenList &tokenList, ScopeType scopeType, AstNodePtr astNode, const Token *def);
+        Scope *createScope(TokenList &tokenList, ScopeType scopeType, const std::vector<AstNodePtr> &children2, const Token *def);
+        RET_NONNULL Token *createTokensCall(TokenList &tokenList);
+        void createTokensFunctionDecl(TokenList &tokenList);
+        void createTokensForCXXRecord(TokenList &tokenList);
+        Token *createTokensVarDecl(TokenList &tokenList);
+        std::string getSpelling() const;
+        std::string getType(int index = 0) const;
+        std::string getFullType(int index = 0) const;
+        bool isDefinition() const;
+        std::string getTemplateParameters() const;
+        const Scope *getNestedInScope(TokenList &tokenList);
+        void setValueType(Token *tok);
+
+        int mFile  = 0;
+        int mLine  = 1;
+        int mCol   = 1;
+        std::vector<std::string> mExtTokens;
+        Data *mData;
+    };
+}
+
+std::string clangimport::AstNode::getSpelling() const
+{
+    if (nodeType == CompoundAssignOperator) {
+        std::size_t typeIndex = 1;
+        while (typeIndex < mExtTokens.size() && mExtTokens[typeIndex][0] != '\'')
+            typeIndex++;
+        // name is next quoted token
+        std::size_t nameIndex = typeIndex + 1;
+        while (nameIndex < mExtTokens.size() && mExtTokens[nameIndex][0] != '\'')
+            nameIndex++;
+        return (nameIndex < mExtTokens.size()) ? unquote(mExtTokens[nameIndex]) : "";
+    }
+
+    if (nodeType == UnaryExprOrTypeTraitExpr) {
+        std::size_t typeIndex = 1;
+        while (typeIndex < mExtTokens.size() && mExtTokens[typeIndex][0] != '\'')
+            typeIndex++;
+        const std::size_t nameIndex = typeIndex + 1;
+        return (nameIndex < mExtTokens.size()) ? unquote(mExtTokens[nameIndex]) : "";
+    }
+
+    int typeIndex = mExtTokens.size() - 1;
+    if (nodeType == FunctionDecl || nodeType == CXXConstructorDecl || nodeType == CXXMethodDecl) {
+        while (typeIndex >= 0 && mExtTokens[typeIndex][0] != '\'')
+            typeIndex--;
+        if (typeIndex <= 0)
+            return "";
+    }
+    if (nodeType == DeclRefExpr) {
+        while (typeIndex > 0 && std::isalpha(mExtTokens[typeIndex][0]))
+            typeIndex--;
+        if (typeIndex <= 0)
+            return "";
+    }
+    const std::string &str = mExtTokens[typeIndex - 1];
+    if (startsWith(str,"col:"))
+        return "";
+    if (startsWith(str,"<invalid"))
+        return "";
+    if (nodeType == RecordDecl && str == "struct")
+        return "";
+    return str;
+}
+
+std::string clangimport::AstNode::getType(int index) const
+{
+    std::string type = getFullType(index);
+    if (type.find(" (") != std::string::npos) {
+        const std::string::size_type pos = type.find(" (");
+        type[pos] = '\'';
+        type.erase(pos+1);
+    }
+    if (type.find(" *(") != std::string::npos) {
+        const std::string::size_type pos = type.find(" *(") + 2;
+        type[pos] = '\'';
+        type.erase(pos+1);
+    }
+    if (type.find(" &(") != std::string::npos) {
+        const std::string::size_type pos = type.find(" &(") + 2;
+        type[pos] = '\'';
+        type.erase(pos+1);
+    }
+    return unquote(type);
+}
+
+std::string clangimport::AstNode::getFullType(int index) const
+{
+    std::size_t typeIndex = 1;
+    while (typeIndex < mExtTokens.size() && mExtTokens[typeIndex][0] != '\'')
+        typeIndex++;
+    if (typeIndex >= mExtTokens.size())
+        return "";
+    std::string type = mExtTokens[typeIndex];
+    if (type.find("\':\'") != std::string::npos) {
+        if (index == 0)
+            type.erase(type.find("\':\'") + 1);
+        else
+            type.erase(0, type.find("\':\'") + 2);
+    }
+    return type;
+}
+
+bool clangimport::AstNode::isDefinition() const
+{
+    return contains(mExtTokens, "definition");
+}
+
+std::string clangimport::AstNode::getTemplateParameters() const
+{
+    if (children.empty() || children[0]->nodeType != TemplateArgument)
+        return "";
+    std::string templateParameters;
+    for (const AstNodePtr& child: children) {
+        if (child->nodeType == TemplateArgument) {
+            if (templateParameters.empty())
+                templateParameters = "<";
+            else
+                templateParameters += ",";
+            templateParameters += unquote(child->mExtTokens.back());
+        }
+    }
+    return templateParameters + ">";
+}
+
+// cppcheck-suppress unusedFunction // only used in comment
+void clangimport::AstNode::dumpAst(int num, int indent) const
+{
+    (void)num;
+    std::cout << std::string(indent, ' ') << nodeType;
+    for (const auto& tok: mExtTokens)
+        std::cout << " " << tok;
+    std::cout << std::endl;
+    for (int c = 0; c < children.size(); ++c) {
+        if (children[c])
+            children[c]->dumpAst(c, indent + 2);
+        else
+            std::cout << std::string(indent + 2, ' ') << "<<<<NULL>>>>>" << std::endl;
+    }
+}
+
+bool clangimport::AstNode::isPrologueTypedefDecl() const
+{
+    // these TypedefDecl are included in *any* AST dump and we should ignore them as they should not be of interest to us
+    // see https://github.com/llvm/llvm-project/issues/120228#issuecomment-2549212109 for an explanation
+    if (nodeType != TypedefDecl)
+        return false;
+
+    // TODO: use different values to indicate "<invalid sloc>"?
+    if (mFile != 0 || mLine != 1 || mCol != 1)
+        return false;
+
+    // TODO: match without using children
+    if (children.empty())
+        return false;
+
+    if (children[0].get()->mExtTokens.size() < 2)
+        return false;
+
+    const auto& type = children[0].get()->mExtTokens[1];
+    if (type == "'__int128'" ||
+        type == "'unsigned __int128'" ||
+        type == "'struct __NSConstantString_tag'" ||
+        type == "'char *'" ||
+        type == "'struct __va_list_tag[1]'")
+    {
+        // NOLINTNEXTLINE(readability-simplify-boolean-expr)
+        return true;
+    }
+
+    return false;
+}
+
+void clangimport::AstNode::setLocations(TokenList &tokenList, int file, int line, int col)
+{
+    if (mExtTokens.size() >= 2)
+    {
+        const std::string &ext = mExtTokens[1];
+        if (startsWith(ext, "<col:"))
+            col = strToInt<int>(ext.substr(5, ext.find_first_of(",>", 5) - 5));
+        else if (startsWith(ext, "<line:")) {
+            line = strToInt<int>(ext.substr(6, ext.find_first_of(":,>", 6) - 6));
+            const auto pos = ext.find(", col:");
+            if (pos != std::string::npos)
+                col = strToInt<int>(ext.substr(pos+6, ext.find_first_of(":,>", pos+6) - (pos+6)));
+        } else if (ext[0] == '<') {
+            const std::string::size_type colon = ext.find(':');
+            if (colon != std::string::npos) {
+                const bool windowsPath = colon == 2 && ext.size() > 3 && ext[2] == ':';
+                const std::string::size_type sep1 = windowsPath ? ext.find(':', 4) : colon;
+                const std::string::size_type sep2 = ext.find(':', sep1 + 1);
+                file = tokenList.appendFileIfNew(ext.substr(1, sep1 - 1));
+                line = strToInt<int>(ext.substr(sep1 + 1, sep2 - sep1 - 1));
+            }
+            else {
+                // "<invalid sloc>" are encountered in every AST dump by some built-in TypedefDecl
+                // an completely empty location block was encountered with a CompoundStmt
+                if (ext != "<<invalid sloc>" && ext != "<>")
+                    throw InternalError(nullptr, "invalid AST location: " + ext, InternalError::AST);
+            }
+        }
+    }
+    mFile = file;
+    mLine = line;
+    mCol = col;
+    for (const auto& child: children) {
+        if (child)
+            child->setLocations(tokenList, file, line, col);
+    }
+}
+
+Token *clangimport::AstNode::addtoken(TokenList &tokenList, const std::string &str, bool valueType)
+{
+    const Scope *scope = getNestedInScope(tokenList);
+    tokenList.addtoken(str, mLine, mCol, mFile);
+    tokenList.back()->scope(scope);
+    if (valueType)
+        setValueType(tokenList.back());
+    return tokenList.back();
+}
+
+const ::Type * clangimport::AstNode::addTypeTokens(TokenList &tokenList, const std::string &str, const Scope *scope)
+{
+    if (str.find("\':\'") != std::string::npos) {
+        return addTypeTokens(tokenList, str.substr(0, str.find("\':\'") + 1), scope);
+    }
+
+    if (startsWith(str, "'enum (anonymous"))
+        return nullptr;
+
+    std::string type;
+    if (str.find(" (") != std::string::npos) {
+        if (str.find('<') != std::string::npos)
+            type = str.substr(1, str.find('<')) + "...>";
+        else
+            type = str.substr(1,str.find(" (")-1);
+    } else
+        type = unquote(str);
+
+    if (type.find("(*)(") != std::string::npos) {
+        type.erase(type.find("(*)("));
+        type += "*";
+    }
+    if (type.find('(') != std::string::npos)
+        type.erase(type.find('('));
+
+    // TODO: put in a helper?
+    std::stack<Token *> lpar;
+    for (const std::string &s: splitString(type)) {
+        Token *tok = addtoken(tokenList, s, false);
+        if (tok->str() == "(")
+            lpar.push(tok);
+        else if (tok->str() == ")") {
+            Token::createMutualLinks(tok, lpar.top());
+            lpar.pop();
+        }
+    }
+
+    // Set Type
+    if (!scope) {
+        scope = tokenList.back() ? tokenList.back()->scope() : nullptr;
+        if (!scope)
+            return nullptr;
+    }
+    for (const Token *typeToken = tokenList.back(); Token::Match(typeToken, "&|*|%name%"); typeToken = typeToken->previous()) {
+        if (!typeToken->isName())
+            continue;
+        const ::Type *recordType = scope->symdb.findVariableType(scope, typeToken);
+        if (recordType) {
+            const_cast<Token*>(typeToken)->type(recordType);
+            return recordType;
+        }
+    }
+    return nullptr;
+}
+
+void clangimport::AstNode::addFullScopeNameTokens(TokenList &tokenList, const Scope *recordScope)
+{
+    if (!recordScope)
+        return;
+    std::list<const Scope *> scopes;
+    while (recordScope && recordScope != tokenList.back()->scope() && !recordScope->isExecutable()) {
+        scopes.push_front(recordScope);
+        recordScope = recordScope->nestedIn;
+    }
+    for (const Scope *s: scopes) {
+        if (!s->className.empty()) {
+            addtoken(tokenList, s->className);
+            addtoken(tokenList, "::");
+        }
+    }
+}
+
+const Scope *clangimport::AstNode::getNestedInScope(TokenList &tokenList)
+{
+    if (!tokenList.back())
+        return &mData->mSymbolDatabase.scopeList.front();
+    if (tokenList.back()->str() == "}" && mData->mNotScope.find(tokenList.back()) == mData->mNotScope.end())
+        return tokenList.back()->scope()->nestedIn;
+    return tokenList.back()->scope();
+}
+
+void clangimport::AstNode::setValueType(Token *tok)
+{
+    for (int i = 0; i < 2; i++) {
+        const std::string &type = getType(i);
+
+        if (type.find('<') != std::string::npos)
+            // TODO
+            continue;
+
+        TokenList decl(mData->mSettings, tok->isCpp() ? Standards::Language::CPP : Standards::Language::C);
+        addTypeTokens(decl, type, tok->scope());
+        if (!decl.front())
+            break;
+
+        ValueType valueType = ValueType::parseDecl(decl.front(), mData->mSettings);
+        if (valueType.type != ValueType::Type::UNKNOWN_TYPE) {
+            tok->setValueType(new ValueType(std::move(valueType)));
+            break;
+        }
+    }
+}
+
+Scope *clangimport::AstNode::createScope(TokenList &tokenList, ScopeType scopeType, AstNodePtr astNode, const Token *def)
+{
+    std::vector<AstNodePtr> children2{std::move(astNode)};
+    return createScope(tokenList, scopeType, children2, def);
+}
+
+Scope *clangimport::AstNode::createScope(TokenList &tokenList, ScopeType scopeType, const std::vector<AstNodePtr> & children2, const Token *def)
+{
+    SymbolDatabase &symbolDatabase = mData->mSymbolDatabase;
+
+    auto *nestedIn = const_cast<Scope *>(getNestedInScope(tokenList));
+
+    symbolDatabase.scopeList.emplace_back(nestedIn->symdb, nullptr, nestedIn);
+    Scope *scope = &symbolDatabase.scopeList.back();
+    if (scopeType == ScopeType::eEnum)
+        scope->enumeratorList.reserve(children2.size());
+    nestedIn->nestedList.push_back(scope);
+    scope->type = scopeType;
+    scope->classDef = def; // TODO: pass into ctor
+    if (Token::Match(def, "if|for|while (")) {
+        std::map<const Variable *, const Variable *> replaceVar;
+        for (const Token *vartok = def->tokAt(2); vartok; vartok = vartok->next()) {
+            if (!vartok->variable())
+                continue;
+            if (vartok->variable()->nameToken() == vartok) {
+                const Variable *from = vartok->variable();
+                scope->varlist.emplace_back(*from, scope);
+                Variable *to = &scope->varlist.back();
+                replaceVar[from] = to;
+                mData->replaceVarDecl(from, to);
+            }
+            if (replaceVar.find(vartok->variable()) != replaceVar.end())
+                const_cast<Token *>(vartok)->variable(replaceVar[vartok->variable()]);
+        }
+        std::list<Variable> &varlist = const_cast<Scope *>(def->scope())->varlist;
+        for (auto var = varlist.cbegin(); var != varlist.cend();) {
+            if (replaceVar.find(&(*var)) != replaceVar.end())
+                var = varlist.erase(var);
+            else
+                ++var;
+        }
+    }
+    scope->bodyStart = addtoken(tokenList, "{");
+    tokenList.back()->scope(scope);
+    mData->scopeAccessControl[scope] = scope->defaultAccess();
+    if (!children2.empty()) {
+        for (const AstNodePtr &astNode: children2) {
+            if (astNode->nodeType == "VisibilityAttr")
+                continue;
+            if (astNode->nodeType == AccessSpecDecl) {
+                if (contains(astNode->mExtTokens, "private"))
+                    mData->scopeAccessControl[scope] = AccessControl::Private;
+                else if (contains(astNode->mExtTokens, "protected"))
+                    mData->scopeAccessControl[scope] = AccessControl::Protected;
+                else if (contains(astNode->mExtTokens, "public"))
+                    mData->scopeAccessControl[scope] = AccessControl::Public;
+                continue;
+            }
+            astNode->createTokens(tokenList);
+            if (scopeType == ScopeType::eEnum)
+                astNode->addtoken(tokenList, ",");
+            else if (!Token::Match(tokenList.back(), "[;{}]"))
+                astNode->addtoken(tokenList, ";");
+        }
+    }
+    scope->bodyEnd = addtoken(tokenList, "}");
+    Token::createMutualLinks(const_cast<Token*>(scope->bodyStart), const_cast<Token*>(scope->bodyEnd));
+    mData->scopeAccessControl.erase(scope);
+    return scope;
+}
+
+Token *clangimport::AstNode::createTokens(TokenList &tokenList)
+{
+    if (nodeType == ArraySubscriptExpr) {
+        Token *array = getChild(0)->createTokens(tokenList);
+        Token *bracket1 = addtoken(tokenList, "[");
+        Token *index = children[1]->createTokens(tokenList);
+        Token *bracket2 = addtoken(tokenList, "]");
+        bracket1->astOperand1(array);
+        bracket1->astOperand2(index);
+        bracket1->link(bracket2);
+        bracket2->link(bracket1);
+        return bracket1;
+    }
+    if (nodeType == BinaryOperator) {
+        Token *tok1 = getChild(0)->createTokens(tokenList);
+        Token *binop = addtoken(tokenList, unquote(mExtTokens.back()));
+        Token *tok2 = children[1]->createTokens(tokenList);
+        binop->astOperand1(tok1);
+        binop->astOperand2(tok2);
+        return binop;
+    }
+    if (nodeType == BreakStmt)
+        return addtoken(tokenList, "break");
+    if (nodeType == CharacterLiteral) {
+        const int c = static_cast<int>(MathLib::toBigNumber(mExtTokens.back()));
+        if (c == 0)
+            return addtoken(tokenList, "\'\\0\'");
+        if (c == '\r')
+            return addtoken(tokenList, "\'\\r\'");
+        if (c == '\n')
+            return addtoken(tokenList, "\'\\n\'");
+        if (c == '\t')
+            return addtoken(tokenList, "\'\\t\'");
+        if (c == '\\')
+            return addtoken(tokenList, "\'\\\\\'");
+        if (c < ' ' || c >= 0x80) {
+            std::ostringstream hex;
+            hex << std::hex << ((c>>4) & 0xf) << (c&0xf);
+            return addtoken(tokenList, "\'\\x" + hex.str() + "\'");
+        }
+        return addtoken(tokenList, std::string("\'") + char(c) + std::string("\'"));
+    }
+    if (nodeType == CallExpr)
+        return createTokensCall(tokenList);
+    if (nodeType == CaseStmt) {
+        Token *caseToken = addtoken(tokenList, "case");
+        Token *exprToken = getChild(0)->createTokens(tokenList);
+        caseToken->astOperand1(exprToken);
+        addtoken(tokenList, ":");
+        children.back()->createTokens(tokenList);
+        return nullptr;
+    }
+    if (nodeType == ClassTemplateDecl) {
+        for (const AstNodePtr& child: children) {
+            if (child->nodeType == ClassTemplateSpecializationDecl)
+                child->createTokens(tokenList);
+        }
+        return nullptr;
+    }
+    if (nodeType == ClassTemplateSpecializationDecl) {
+        createTokensForCXXRecord(tokenList);
+        return nullptr;
+    }
+    if (nodeType == ConditionalOperator) {
+        Token *expr1 = getChild(0)->createTokens(tokenList);
+        Token *tok1 = addtoken(tokenList, "?");
+        Token *expr2 = children[1]->createTokens(tokenList);
+        Token *tok2 = addtoken(tokenList, ":");
+        Token *expr3 = children[2]->createTokens(tokenList);
+        tok2->astOperand1(expr2);
+        tok2->astOperand2(expr3);
+        tok1->astOperand1(expr1);
+        tok1->astOperand2(tok2);
+        return tok1;
+    }
+    if (nodeType == CompoundAssignOperator) {
+        Token *lhs = getChild(0)->createTokens(tokenList);
+        Token *assign = addtoken(tokenList, getSpelling());
+        Token *rhs = children[1]->createTokens(tokenList);
+        assign->astOperand1(lhs);
+        assign->astOperand2(rhs);
+        return assign;
+    }
+    if (nodeType == CompoundStmt) {
+        for (const AstNodePtr& child: children) {
+            child->createTokens(tokenList);
+            if (!Token::Match(tokenList.back(), "[;{}]"))
+                child->addtoken(tokenList, ";");
+        }
+        return nullptr;
+    }
+    if (nodeType == ConstantExpr)
+        return children.back()->createTokens(tokenList);
+    if (nodeType == ContinueStmt)
+        return addtoken(tokenList, "continue");
+    if (nodeType == CStyleCastExpr) {
+        Token *par1 = addtoken(tokenList, "(");
+        addTypeTokens(tokenList, '\'' + getType() + '\'');
+        Token *par2 = addtoken(tokenList, ")");
+        par1->link(par2);
+        par2->link(par1);
+        par1->astOperand1(getChild(0)->createTokens(tokenList));
+        return par1;
+    }
+    if (nodeType == CXXBindTemporaryExpr)
+        return getChild(0)->createTokens(tokenList);
+    if (nodeType == CXXBoolLiteralExpr) {
+        addtoken(tokenList, mExtTokens.back());
+        tokenList.back()->setValueType(new ValueType(ValueType::Sign::UNKNOWN_SIGN, ValueType::Type::BOOL, 0));
+        return tokenList.back();
+    }
+    if (nodeType == CXXConstructExpr) {
+        if (!children.empty())
+            return getChild(0)->createTokens(tokenList);
+        addTypeTokens(tokenList, '\'' + getType() + '\'');
+        Token *type = tokenList.back();
+        Token *par1 = addtoken(tokenList, "(");
+        Token *par2 = addtoken(tokenList, ")");
+        par1->link(par2);
+        par2->link(par1);
+        par1->astOperand1(type);
+        return par1;
+    }
+    if (nodeType == CXXConstructorDecl) {
+        createTokensFunctionDecl(tokenList);
+        return nullptr;
+    }
+    if (nodeType == CXXDeleteExpr) {
+        addtoken(tokenList, "delete");
+        getChild(0)->createTokens(tokenList);
+        return nullptr;
+    }
+    if (nodeType == CXXDestructorDecl) {
+        createTokensFunctionDecl(tokenList);
+        return nullptr;
+    }
+    if (nodeType == CXXForRangeStmt) {
+        Token *forToken = addtoken(tokenList, "for");
+        Token *par1 = addtoken(tokenList, "(");
+        AstNodePtr varDecl;
+        if (children[6]->nodeType == DeclStmt)
+            varDecl = getChild(6)->getChild(0);
+        else
+            varDecl = getChild(5)->getChild(0);
+        varDecl->mExtTokens.pop_back();
+        varDecl->children.clear();
+        Token *expr1 = varDecl->createTokens(tokenList);
+        Token *colon = addtoken(tokenList, ":");
+
+        auto it = std::find_if(children.cbegin(), children.cbegin() + 2, [&](const AstNodePtr& c) {
+            return c && c->nodeType == DeclStmt && c->getChild(0)->nodeType == VarDecl;
+        });
+        if (it == children.cbegin() + 2)
+            throw InternalError(tokenList.back(), "Failed to import CXXForRangeStmt. Range?");
+        AstNodePtr range = (*it)->getChild(0)->getChild(0);
+
+        Token *expr2 = range->createTokens(tokenList);
+        Token *par2 = addtoken(tokenList, ")");
+
+        par1->link(par2);
+        par2->link(par1);
+
+        colon->astOperand1(expr1);
+        colon->astOperand2(expr2);
+        par1->astOperand1(forToken);
+        par1->astOperand2(colon);
+
+        createScope(tokenList, ScopeType::eFor, children.back(), forToken);
+        return nullptr;
+    }
+    if (nodeType == CXXMethodDecl) {
+        for (std::size_t i = 0; i+1 < mExtTokens.size(); ++i) {
+            if (mExtTokens[i] == "prev" && !mData->hasDecl(mExtTokens[i+1]))
+                return nullptr;
+        }
+        createTokensFunctionDecl(tokenList);
+        return nullptr;
+    }
+    if (nodeType == CXXMemberCallExpr)
+        return createTokensCall(tokenList);
+    if (nodeType == CXXNewExpr) {
+        Token *newtok = addtoken(tokenList, "new");
+        if (children.size() == 1 && getChild(0)->nodeType == CXXConstructExpr) {
+            newtok->astOperand1(getChild(0)->createTokens(tokenList));
+            return newtok;
+        }
+        std::string type = getType();
+        if (type.find('*') != std::string::npos)
+            type = type.erase(type.rfind('*'));
+        addTypeTokens(tokenList, type);
+        if (!children.empty()) {
+            Token *bracket1 = addtoken(tokenList, "[");
+            getChild(0)->createTokens(tokenList);
+            Token *bracket2 = addtoken(tokenList, "]");
+            bracket1->link(bracket2);
+            bracket2->link(bracket1);
+        }
+        return newtok;
+    }
+    if (nodeType == CXXNullPtrLiteralExpr)
+        return addtoken(tokenList, "nullptr");
+    if (nodeType == CXXOperatorCallExpr)
+        return createTokensCall(tokenList);
+    if (nodeType == CXXRecordDecl) {
+        createTokensForCXXRecord(tokenList);
+        return nullptr;
+    }
+    if (nodeType == CXXStaticCastExpr || nodeType == CXXFunctionalCastExpr) {
+        Token *cast = addtoken(tokenList, getSpelling());
+        Token *par1 = addtoken(tokenList, "(");
+        Token *expr = getChild(0)->createTokens(tokenList);
+        Token *par2 = addtoken(tokenList, ")");
+        par1->link(par2);
+        par2->link(par1);
+        par1->astOperand1(cast);
+        par1->astOperand2(expr);
+        setValueType(par1);
+        return par1;
+    }
+    if (nodeType == CXXStdInitializerListExpr)
+        return getChild(0)->createTokens(tokenList);
+    if (nodeType == CXXTemporaryObjectExpr && !children.empty())
+        return getChild(0)->createTokens(tokenList);
+    if (nodeType == CXXThisExpr)
+        return addtoken(tokenList, "this");
+    if (nodeType == CXXThrowExpr) {
+        Token *t = addtoken(tokenList, "throw");
+        t->astOperand1(getChild(0)->createTokens(tokenList));
+        return t;
+    }
+    if (nodeType == DeclRefExpr) {
+        int addrIndex = mExtTokens.size() - 1;
+        while (addrIndex > 1 && !startsWith(mExtTokens[addrIndex],"0x"))
+            --addrIndex;
+        const std::string addr = mExtTokens[addrIndex];
+        std::string name = unquote(getSpelling());
+        Token *reftok = addtoken(tokenList, name.empty() ? "<NoName>" : name);
+        mData->ref(addr, reftok);
+        return reftok;
+    }
+    if (nodeType == DeclStmt)
+        return getChild(0)->createTokens(tokenList);
+    if (nodeType == DefaultStmt) {
+        addtoken(tokenList, "default");
+        addtoken(tokenList, ":");
+        children.back()->createTokens(tokenList);
+        return nullptr;
+    }
+    if (nodeType == DoStmt) {
+        addtoken(tokenList, "do");
+        createScope(tokenList, ScopeType::eDo, getChild(0), tokenList.back());
+        Token *tok1 = addtoken(tokenList, "while");
+        Token *par1 = addtoken(tokenList, "(");
+        Token *expr = children[1]->createTokens(tokenList);
+        Token *par2 = addtoken(tokenList, ")");
+        par1->link(par2);
+        par2->link(par1);
+        par1->astOperand1(tok1);
+        par1->astOperand2(expr);
+        return nullptr;
+    }
+    if (nodeType == EnumConstantDecl) {
+        Token *nameToken = addtoken(tokenList, getSpelling());
+        auto *scope = const_cast<Scope *>(nameToken->scope());
+        scope->enumeratorList.emplace_back(nameToken->scope());
+        Enumerator *e = &scope->enumeratorList.back();
+        e->name = nameToken;
+        e->value = mData->enumValue++;
+        e->value_known = true;
+        mData->enumDecl(mExtTokens.front(), nameToken, e);
+        return nameToken;
+    }
+    if (nodeType == EnumDecl) {
+        int colIndex = mExtTokens.size() - 1;
+        while (colIndex > 0 && !startsWith(mExtTokens[colIndex],"col:") && !startsWith(mExtTokens[colIndex],"line:"))
+            --colIndex;
+        if (colIndex == 0)
+            return nullptr;
+
+        mData->enumValue = 0;
+        Token *enumtok = addtoken(tokenList, "enum");
+        const Token *nametok = nullptr;
+        {
+            int nameIndex = mExtTokens.size() - 1;
+            while (nameIndex > colIndex && mExtTokens[nameIndex][0] == '\'')
+                --nameIndex;
+            if (nameIndex > colIndex)
+                nametok = addtoken(tokenList, mExtTokens[nameIndex]);
+            if (mExtTokens.back()[0] == '\'') {
+                addtoken(tokenList, ":");
+                addTypeTokens(tokenList, mExtTokens.back());
+            }
+        }
+        Scope *enumscope = createScope(tokenList, ScopeType::eEnum, children, enumtok);
+        if (nametok)
+            enumscope->className = nametok->str();
+        if (enumscope->bodyEnd && Token::simpleMatch(enumscope->bodyEnd->previous(), ", }"))
+            const_cast<Token *>(enumscope->bodyEnd)->deletePrevious();
+
+        // Create enum type
+        mData->mSymbolDatabase.typeList.emplace_back(enumtok, enumscope, enumtok->scope());
+        enumscope->definedType = &mData->mSymbolDatabase.typeList.back();
+        if (nametok)
+            const_cast<Scope *>(enumtok->scope())->definedTypesMap[nametok->str()] = enumscope->definedType;
+
+        return nullptr;
+    }
+    if (nodeType == ExprWithCleanups)
+        return getChild(0)->createTokens(tokenList);
+    if (nodeType == FieldDecl)
+        return createTokensVarDecl(tokenList);
+    if (nodeType == FloatingLiteral)
+        return addtoken(tokenList, mExtTokens.back());
+    if (nodeType == ForStmt) {
+        Token *forToken = addtoken(tokenList, "for");
+        Token *par1 = addtoken(tokenList, "(");
+        Token *expr1 = getChild(0) ? children[0]->createTokens(tokenList) : nullptr;
+        Token *sep1 = addtoken(tokenList, ";");
+        Token *expr2 = children[2] ? children[2]->createTokens(tokenList) : nullptr;
+        Token *sep2 = addtoken(tokenList, ";");
+        Token *expr3 = children[3] ? children[3]->createTokens(tokenList) : nullptr;
+        Token *par2 = addtoken(tokenList, ")");
+        par1->link(par2);
+        par2->link(par1);
+        par1->astOperand1(forToken);
+        par1->astOperand2(sep1);
+        sep1->astOperand1(expr1);
+        sep1->astOperand2(sep2);
+        sep2->astOperand1(expr2);
+        sep2->astOperand2(expr3);
+        createScope(tokenList, ScopeType::eFor, children[4], forToken);
+        return nullptr;
+    }
+    if (nodeType == FunctionDecl) {
+        createTokensFunctionDecl(tokenList);
+        return nullptr;
+    }
+    if (nodeType == FunctionTemplateDecl) {
+        bool first = true;
+        for (const AstNodePtr& child: children) {
+            if (child->nodeType == FunctionDecl) {
+                if (!first)
+                    child->createTokens(tokenList);
+                first = false;
+            }
+        }
+        return nullptr;
+    }
+    if (nodeType == GotoStmt) {
+        addtoken(tokenList, "goto");
+        addtoken(tokenList, unquote(mExtTokens[mExtTokens.size() - 2]));
+        addtoken(tokenList, ";");
+        return nullptr;
+    }
+    if (nodeType == IfStmt) {
+        AstNodePtr cond;
+        AstNodePtr thenCode;
+        AstNodePtr elseCode;
+        if (children.size() == 2) {
+            cond = children[children.size() - 2];
+            thenCode = children[children.size() - 1];
+        } else {
+            cond = children[children.size() - 3];
+            thenCode = children[children.size() - 2];
+            elseCode = children[children.size() - 1];
+        }
+
+        Token *iftok = addtoken(tokenList, "if");
+        Token *par1 = addtoken(tokenList, "(");
+        par1->astOperand1(iftok);
+        par1->astOperand2(cond->createTokens(tokenList));
+        Token *par2 = addtoken(tokenList, ")");
+        par1->link(par2);
+        par2->link(par1);
+        createScope(tokenList, ScopeType::eIf, std::move(thenCode), iftok);
+        if (elseCode) {
+            elseCode->addtoken(tokenList, "else");
+            createScope(tokenList, ScopeType::eElse, std::move(elseCode), tokenList.back());
+        }
+        return nullptr;
+    }
+    if (nodeType == ImplicitCastExpr) {
+        Token *expr = getChild(0)->createTokens(tokenList);
+        if (!expr->valueType() || contains(mExtTokens, "<ArrayToPointerDecay>"))
+            setValueType(expr);
+        return expr;
+    }
+    if (nodeType == InitListExpr) {
+        const Scope *scope = tokenList.back()->scope();
+        Token *start = addtoken(tokenList, "{");
+        start->scope(scope);
+        for (const AstNodePtr& child: children) {
+            if (tokenList.back()->str() != "{")
+                addtoken(tokenList, ",");
+            child->createTokens(tokenList);
+        }
+        Token *end = addtoken(tokenList, "}");
+        end->scope(scope);
+        start->link(end);
+        end->link(start);
+        mData->mNotScope.insert(end);
+        return start;
+    }
+    if (nodeType == IntegerLiteral)
+        return addtoken(tokenList, mExtTokens.back());
+    if (nodeType == LabelStmt) {
+        addtoken(tokenList, unquote(mExtTokens.back()));
+        addtoken(tokenList, ":");
+        for (const auto& child: children)
+            child->createTokens(tokenList);
+        return nullptr;
+    }
+    if (nodeType == LinkageSpecDecl)
+        return nullptr;
+    if (nodeType == MaterializeTemporaryExpr)
+        return getChild(0)->createTokens(tokenList);
+    if (nodeType == MemberExpr) {
+        Token *s = getChild(0)->createTokens(tokenList);
+        Token *dot = addtoken(tokenList, ".");
+        std::string memberName = getSpelling();
+        if (startsWith(memberName, "->")) {
+            dot->originalName("->");
+            memberName = memberName.substr(2);
+        } else if (startsWith(memberName, ".")) {
+            memberName = memberName.substr(1);
+        }
+        if (memberName.empty())
+            memberName = "<unknown>";
+        Token *member = addtoken(tokenList, memberName);
+        mData->ref(mExtTokens.back(), member);
+        dot->astOperand1(s);
+        dot->astOperand2(member);
+        return dot;
+    }
+    if (nodeType == NamespaceDecl) {
+        if (children.empty())
+            return nullptr;
+        const Token *defToken = addtoken(tokenList, "namespace");
+        const std::string &s = mExtTokens[mExtTokens.size() - 2];
+        const Token* nameToken = (startsWith(s, "col:") || startsWith(s, "line:")) ?
+                                 addtoken(tokenList, mExtTokens.back()) : nullptr;
+        Scope *scope = createScope(tokenList, ScopeType::eNamespace, children, defToken);
+        if (nameToken)
+            scope->className = nameToken->str();
+        return nullptr;
+    }
+    if (nodeType == NullStmt)
+        return addtoken(tokenList, ";");
+    if (nodeType == ParenExpr) {
+        Token *par1 = addtoken(tokenList, "(");
+        Token *expr = getChild(0)->createTokens(tokenList);
+        Token *par2 = addtoken(tokenList, ")");
+        par1->link(par2);
+        par2->link(par1);
+        return expr;
+    }
+    if (nodeType == RecordDecl) {
+        const Token *classDef = addtoken(tokenList, "struct");
+        const std::string &recordName = getSpelling();
+        if (!recordName.empty())
+            addtoken(tokenList, getSpelling());
+        if (!isDefinition()) {
+            addtoken(tokenList, ";");
+            return nullptr;
+        }
+
+        Scope *recordScope = createScope(tokenList, ScopeType::eStruct, children, classDef);
+        mData->mSymbolDatabase.typeList.emplace_back(classDef, recordScope, classDef->scope());
+        recordScope->definedType = &mData->mSymbolDatabase.typeList.back();
+        if (!recordName.empty()) {
+            recordScope->className = recordName;
+            const_cast<Scope *>(classDef->scope())->definedTypesMap[recordName] = recordScope->definedType;
+        }
+
+        return nullptr;
+    }
+    if (nodeType == ReturnStmt) {
+        Token *tok1 = addtoken(tokenList, "return");
+        if (!children.empty()) {
+            getChild(0)->setValueType(tok1);
+            tok1->astOperand1(getChild(0)->createTokens(tokenList));
+        }
+        return tok1;
+    }
+    if (nodeType == StringLiteral)
+        return addtoken(tokenList, mExtTokens.back());
+    if (nodeType == SwitchStmt) {
+        Token *tok1 = addtoken(tokenList, "switch");
+        Token *par1 = addtoken(tokenList, "(");
+        Token *expr = children[children.size() - 2]->createTokens(tokenList);
+        Token *par2 = addtoken(tokenList, ")");
+        par1->link(par2);
+        par2->link(par1);
+        par1->astOperand1(tok1);
+        par1->astOperand2(expr);
+        createScope(tokenList, ScopeType::eSwitch, children.back(), tok1);
+        return nullptr;
+    }
+    if (nodeType == TypedefDecl) {
+        addtoken(tokenList, "typedef");
+        addTypeTokens(tokenList, getType());
+        return addtoken(tokenList, getSpelling());
+    }
+    if (nodeType == UnaryOperator) {
+        int index = static_cast<int>(mExtTokens.size()) - 1;
+        while (index > 0 && mExtTokens[index][0] != '\'')
+            --index;
+        Token *unop = addtoken(tokenList, unquote(mExtTokens[index]));
+        unop->astOperand1(getChild(0)->createTokens(tokenList));
+        return unop;
+    }
+    if (nodeType == UnaryExprOrTypeTraitExpr) {
+        Token *tok1 = addtoken(tokenList, getSpelling());
+        Token *par1 = addtoken(tokenList, "(");
+        if (children.empty())
+            addTypeTokens(tokenList, mExtTokens.back());
+        else {
+            AstNodePtr child = getChild(0);
+            if (child && child->nodeType == ParenExpr)
+                child = child->getChild(0);
+            Token *expr = child->createTokens(tokenList);
+            child->setValueType(expr);
+            par1->astOperand2(expr);
+        }
+        Token *par2 = addtoken(tokenList, ")");
+        par1->link(par2);
+        par2->link(par1);
+        par1->astOperand1(tok1);
+        par1->astOperand2(par1->next());
+        setValueType(par1);
+        return par1;
+    }
+    if (nodeType == VarDecl)
+        return createTokensVarDecl(tokenList);
+    if (nodeType == WhileStmt) {
+        AstNodePtr cond = children[children.size() - 2];
+        AstNodePtr body = children.back();
+        Token *whiletok = addtoken(tokenList, "while");
+        Token *par1 = addtoken(tokenList, "(");
+        par1->astOperand1(whiletok);
+        par1->astOperand2(cond->createTokens(tokenList));
+        Token *par2 = addtoken(tokenList, ")");
+        par1->link(par2);
+        par2->link(par1);
+        createScope(tokenList, ScopeType::eWhile, std::move(body), whiletok);
+        return nullptr;
+    }
+    return addtoken(tokenList, "?" + nodeType + "?");
+}
+
+Token * clangimport::AstNode::createTokensCall(TokenList &tokenList)
+{
+    int firstParam;
+    Token *f;
+    if (nodeType == CXXOperatorCallExpr) {
+        firstParam = 2;
+        Token *obj = getChild(1)->createTokens(tokenList);
+        Token *dot = addtoken(tokenList, ".");
+        Token *op = getChild(0)->createTokens(tokenList);
+        dot->astOperand1(obj);
+        dot->astOperand2(op);
+        f = dot;
+    } else {
+        firstParam = 1;
+        f = getChild(0)->createTokens(tokenList);
+    }
+    f->setValueType(nullptr);
+    Token *par1 = addtoken(tokenList, "(");
+    par1->astOperand1(f);
+    std::size_t args = 0;
+    while (args < children.size() && children[args]->nodeType != CXXDefaultArgExpr)
+        args++;
+    Token *child = nullptr;
+    for (std::size_t c = firstParam; c < args; ++c) {
+        if (child) {
+            Token *comma = addtoken(tokenList, ",");
+            comma->setValueType(nullptr);
+            comma->astOperand1(child);
+            comma->astOperand2(children[c]->createTokens(tokenList));
+            child = comma;
+        } else {
+            child = children[c]->createTokens(tokenList);
+        }
+    }
+    par1->astOperand2(child);
+    Token *par2 = addtoken(tokenList, ")");
+    par1->link(par2);
+    par2->link(par1);
+    return par1;
+}
+
+void clangimport::AstNode::createTokensFunctionDecl(TokenList &tokenList)
+{
+    const bool prev = contains(mExtTokens, "prev");
+    const bool hasBody = !children.empty() && children.back()->nodeType == CompoundStmt;
+    const bool isStatic = contains(mExtTokens, "static");
+    const bool isInline = contains(mExtTokens, "inline");
+
+    const Token *startToken = nullptr;
+
+    SymbolDatabase &symbolDatabase = mData->mSymbolDatabase;
+    if (nodeType != CXXConstructorDecl && nodeType != CXXDestructorDecl) {
+        if (isStatic)
+            addtoken(tokenList, "static");
+        if (isInline)
+            addtoken(tokenList, "inline");
+        const Token * const before = tokenList.back();
+        addTypeTokens(tokenList, '\'' + getType() + '\'');
+        startToken = before ? before->next() : tokenList.front();
+    }
+
+    if (mExtTokens.size() > 4 && mExtTokens[1] == "parent")
+        addFullScopeNameTokens(tokenList, mData->getScope(mExtTokens[2]));
+
+    Token *nameToken = addtoken(tokenList, getSpelling() + getTemplateParameters());
+    auto *nestedIn = const_cast<Scope *>(nameToken->scope());
+
+    if (prev) {
+        const std::string addr = *(std::find(mExtTokens.cbegin(), mExtTokens.cend(), "prev") + 1);
+        mData->ref(addr, nameToken);
+    }
+    if (!nameToken->function()) {
+        nestedIn->functionList.emplace_back(nameToken, unquote(getFullType()));
+        mData->funcDecl(mExtTokens.front(), nameToken, &nestedIn->functionList.back());
+        if (nodeType == CXXConstructorDecl)
+            nestedIn->functionList.back().type = FunctionType::eConstructor;
+        else if (nodeType == CXXDestructorDecl)
+            nestedIn->functionList.back().type = FunctionType::eDestructor;
+        else
+            nestedIn->functionList.back().retDef = startToken;
+    }
+
+    auto * const function = const_cast<Function*>(nameToken->function());
+
+    if (!prev) {
+        auto accessControl = mData->scopeAccessControl.find(tokenList.back()->scope());
+        if (accessControl != mData->scopeAccessControl.end())
+            function->access = accessControl->second;
+    }
+
+    Scope *scope = nullptr;
+    if (hasBody) {
+        symbolDatabase.scopeList.emplace_back(symbolDatabase, nullptr, nestedIn);
+        scope = &symbolDatabase.scopeList.back();
+        scope->function = function;
+        scope->classDef = nameToken; // TODO: pass into ctor
+        scope->type = ScopeType::eFunction;
+        scope->className = nameToken->str();
+        nestedIn->nestedList.push_back(scope);
+        function->hasBody(true);
+        function->functionScope = scope;
+    }
+
+    Token *par1 = addtoken(tokenList, "(");
+    if (!function->arg)
+        function->arg = par1;
+    function->token = nameToken;
+    if (!function->nestedIn)
+        function->nestedIn = nestedIn;
+    function->argDef = par1;
+    // Function arguments
+    for (int i = 0; i < children.size(); ++i) {
+        AstNodePtr child = children[i];
+        if (child->nodeType != ParmVarDecl)
+            continue;
+        if (tokenList.back() != par1)
+            addtoken(tokenList, ",");
+        const Type *recordType = addTypeTokens(tokenList, child->mExtTokens.back(), nestedIn);
+        const Token *typeEndToken = tokenList.back();
+        const std::string spelling = child->getSpelling();
+        Token *vartok = nullptr;
+        if (!spelling.empty())
+            vartok = child->addtoken(tokenList, spelling);
+        if (!prev) {
+            function->argumentList.emplace_back(vartok, child->getType(), nullptr, typeEndToken, i, AccessControl::Argument, recordType, scope);
+            if (vartok) {
+                const std::string addr = child->mExtTokens[0];
+                mData->varDecl(addr, vartok, &function->argumentList.back());
+            }
+        } else if (vartok) {
+            const std::string addr = child->mExtTokens[0];
+            mData->ref(addr, vartok);
+        }
+    }
+    Token *par2 = addtoken(tokenList, ")");
+    par1->link(par2);
+    par2->link(par1);
+
+    if (function->isConst())
+        addtoken(tokenList, "const");
+
+    // Function body
+    if (hasBody) {
+        symbolDatabase.functionScopes.push_back(scope);
+        Token *bodyStart = addtoken(tokenList, "{");
+        bodyStart->scope(scope);
+        children.back()->createTokens(tokenList);
+        Token *bodyEnd = addtoken(tokenList, "}");
+        scope->bodyStart = bodyStart;
+        scope->bodyEnd = bodyEnd;
+        bodyStart->link(bodyEnd);
+        bodyEnd->link(bodyStart);
+    } else {
+        if (nodeType == CXXConstructorDecl && contains(mExtTokens, "default")) {
+            addtoken(tokenList, "=");
+            addtoken(tokenList, "default");
+        }
+
+        addtoken(tokenList, ";");
+    }
+}
+
+void clangimport::AstNode::createTokensForCXXRecord(TokenList &tokenList)
+{
+    const bool isStruct = contains(mExtTokens, "struct");
+    Token * const classToken = addtoken(tokenList, isStruct ? "struct" : "class");
+    std::string className;
+    if (mExtTokens[mExtTokens.size() - 2] == (isStruct?"struct":"class"))
+        className = mExtTokens.back();
+    else
+        className = mExtTokens[mExtTokens.size() - 2];
+    className += getTemplateParameters();
+    /*Token *nameToken =*/ addtoken(tokenList, className);
+    // base classes
+    bool firstBase = true;
+    for (const AstNodePtr &child: children) {
+        if (child->nodeType == "public" || child->nodeType == "protected" || child->nodeType == "private") {
+            addtoken(tokenList, firstBase ? ":" : ",");
+            addtoken(tokenList, child->nodeType);
+            addtoken(tokenList, unquote(child->mExtTokens.back()));
+            firstBase = false;
+        }
+    }
+    // definition
+    if (isDefinition()) {
+        std::vector<AstNodePtr> children2;
+        std::copy_if(children.cbegin(), children.cend(), std::back_inserter(children2), [](const AstNodePtr& child) {
+            return child->nodeType == CXXConstructorDecl ||
+                   child->nodeType == CXXDestructorDecl ||
+                   child->nodeType == CXXMethodDecl ||
+                   child->nodeType == FieldDecl ||
+                   child->nodeType == VarDecl ||
+                   child->nodeType == AccessSpecDecl ||
+                   child->nodeType == TypedefDecl;
+        });
+        Scope *scope = createScope(tokenList, isStruct ? ScopeType::eStruct : ScopeType::eClass, children2, classToken);
+        const std::string addr = mExtTokens[0];
+        mData->scopeDecl(addr, scope);
+        scope->className = className;
+        mData->mSymbolDatabase.typeList.emplace_back(classToken, scope, classToken->scope());
+        scope->definedType = &mData->mSymbolDatabase.typeList.back();
+        const_cast<Scope *>(classToken->scope())->definedTypesMap[className] = scope->definedType;
+    }
+    addtoken(tokenList, ";");
+    tokenList.back()->scope(classToken->scope());
+}
+
+Token * clangimport::AstNode::createTokensVarDecl(TokenList &tokenList)
+{
+    const std::string addr = mExtTokens.front();
+    if (contains(mExtTokens, "static"))
+        addtoken(tokenList, "static");
+    int typeIndex = mExtTokens.size() - 1;
+    while (typeIndex > 1 && std::isalpha(mExtTokens[typeIndex][0]))
+        typeIndex--;
+    const std::string type = mExtTokens[typeIndex];
+    const std::string name = mExtTokens[typeIndex - 1];
+    const Token *startToken = tokenList.back();
+    const ::Type *recordType = addTypeTokens(tokenList, type);
+    if (!startToken)
+        startToken = tokenList.front();
+    else if (startToken->str() != "static")
+        startToken = startToken->next();
+    Token *vartok1 = addtoken(tokenList, name);
+    auto *scope = const_cast<Scope *>(tokenList.back()->scope());
+    scope->varlist.emplace_back(vartok1, unquote(type), startToken, vartok1->previous(), 0, scope->defaultAccess(), recordType, scope);
+    mData->varDecl(addr, vartok1, &scope->varlist.back());
+    if (mExtTokens.back() == "cinit" && !children.empty()) {
+        Token *eq = addtoken(tokenList, "=");
+        eq->astOperand1(vartok1);
+        eq->astOperand2(children.back()->createTokens(tokenList));
+        return eq;
+    }
+    if (mExtTokens.back() == "callinit") {
+        Token *par1 = addtoken(tokenList, "(");
+        par1->astOperand1(vartok1);
+        par1->astOperand2(getChild(0)->createTokens(tokenList));
+        Token *par2 = addtoken(tokenList, ")");
+        par1->link(par2);
+        par2->link(par1);
+        return par1;
+    }
+    if (mExtTokens.back() == "listinit") {
+        return getChild(0)->createTokens(tokenList);
+    }
+    return vartok1;
+}
+
+static void setTypes(TokenList &tokenList)
+{
+    for (Token *tok = tokenList.front(); tok; tok = tok->next()) {
+        if (Token::simpleMatch(tok, "sizeof (")) {
+            for (Token *typeToken = tok->tokAt(2); typeToken->str() != ")"; typeToken = typeToken->next()) {
+                if (typeToken->type())
+                    continue;
+                typeToken->type(typeToken->scope()->findType(typeToken->str()));
+            }
+        }
+    }
+}
+
+static void setValues(const Tokenizer &tokenizer, const SymbolDatabase *symbolDatabase)
+{
+    const Settings & settings = tokenizer.getSettings();
+
+    for (const Scope& scope : symbolDatabase->scopeList) {
+        if (!scope.definedType)
+            continue;
+
+        MathLib::bigint typeSize = 0;
+        for (const Variable &var: scope.varlist) {
+            const MathLib::bigint mul = std::accumulate(var.dimensions().cbegin(), var.dimensions().cend(), MathLib::bigint(1), [](MathLib::bigint v, const Dimension& dim) {
+                return v * dim.num;
+            });
+            if (var.valueType())
+                typeSize += mul * var.valueType()->getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer);
+        }
+        scope.definedType->sizeOf = typeSize;
+    }
+
+    for (auto *tok = const_cast<Token*>(tokenizer.tokens()); tok; tok = tok->next()) {
+        if (Token::simpleMatch(tok, "sizeof (")) {
+            ValueType vt = ValueType::parseDecl(tok->tokAt(2), settings);
+            const size_t sz = vt.getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer);
+            if (sz == 0)
+                continue;
+            long long mul = 1;
+            for (const Token *arrtok = tok->linkAt(1)->previous(); arrtok; arrtok = arrtok->previous()) {
+                const std::string &a = arrtok->str();
+                if (a.size() > 2 && a[0] == '[' && a.back() == ']')
+                    mul *= strToInt<long long>(a.substr(1));
+                else
+                    break;
+            }
+            ValueFlow::Value v(mul * sz);
+            v.setKnown();
+            tok->next()->addValue(v);
+        }
+    }
+}
+
+void clangimport::parseClangAstDump(Tokenizer &tokenizer, std::istream &f)
+{
+    TokenList &tokenList = tokenizer.list;
+
+    tokenizer.createSymbolDatabase();
+    auto *symbolDatabase = const_cast<SymbolDatabase *>(tokenizer.getSymbolDatabase());
+    symbolDatabase->scopeList.emplace_back(*symbolDatabase, nullptr, nullptr);
+    symbolDatabase->scopeList.back().type = ScopeType::eGlobal;
+
+    clangimport::Data data(tokenizer.getSettings(), *symbolDatabase);
+    std::string line;
+    std::vector<AstNodePtr> tree;
+    while (std::getline(f,line)) {
+        const std::string::size_type pos1 = line.find('-');
+        if (pos1 == std::string::npos)
+            continue;
+        if (!tree.empty() && line.substr(pos1) == "-<<<NULL>>>") {
+            const int level = (pos1 - 1) / 2;
+            tree[level - 1]->children.push_back(nullptr);
+            continue;
+        }
+        const std::string::size_type pos2 = line.find(' ', pos1);
+        if (pos2 < pos1 + 4 || pos2 == std::string::npos)
+            continue;
+        const std::string nodeType = line.substr(pos1+1, pos2 - pos1 - 1);
+        const std::string ext = line.substr(pos2);
+
+        if (pos1 == 1 && endsWith(nodeType, "Decl")) {
+            if (!tree.empty())
+                tree[0]->createTokens1(tokenList);
+            tree.clear();
+            tree.push_back(std::make_shared<AstNode>(nodeType, ext, &data));
+            continue;
+        }
+
+        const int level = (pos1 - 1) / 2;
+        if (level == 0 || level > tree.size())
+            continue;
+
+        AstNodePtr newNode = std::make_shared<AstNode>(nodeType, ext, &data);
+        tree[level - 1]->children.push_back(newNode);
+        if (level >= tree.size())
+            tree.push_back(std::move(newNode));
+        else
+            tree[level] = std::move(newNode);
+    }
+
+    if (!tree.empty())
+        tree[0]->createTokens1(tokenList);
+
+    // Validation
+    for (const Token *tok = tokenList.front(); tok; tok = tok->next()) {
+        if (Token::Match(tok, "(|)|[|]|{|}") && !tok->link())
+            throw InternalError(tok, "Token::link() is not set properly");
+    }
+
+    if (tokenList.front())
+        tokenList.front()->assignIndexes();
+    symbolDatabase->clangSetVariables(data.getVariableList());
+    symbolDatabase->createSymbolDatabaseExprIds();
+    tokenList.clangSetOrigFiles();
+    setTypes(tokenList);
+    setValues(tokenizer, symbolDatabase);
+}
+
diff --git a/lib/clangimport.h b/lib/clangimport.h
new file mode 100644
index 00000000000..f0a35e7a3b6
--- /dev/null
+++ b/lib/clangimport.h
@@ -0,0 +1,38 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+//---------------------------------------------------------------------------
+#ifndef clangimportH
+#define clangimportH
+//---------------------------------------------------------------------------
+
+#include "config.h"
+
+#include <istream>
+
+class Tokenizer;
+
+namespace clangimport {
+    /**
+     * @throws InternalError thrown on incorrectly linked tokens
+     */
+    void CPPCHECKLIB parseClangAstDump(Tokenizer &tokenizer, std::istream &f);
+}
+
+#endif
diff --git a/lib/color.cpp b/lib/color.cpp
new file mode 100644
index 00000000000..2a29fb61376
--- /dev/null
+++ b/lib/color.cpp
@@ -0,0 +1,79 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "color.h"
+
+#include <cstdlib>
+#include <sstream>
+#include <iostream>
+
+#ifndef _WIN32
+#include <unistd.h>
+#endif
+
+bool gDisableColors = false;
+
+#ifndef _WIN32
+static bool isStreamATty(const std::ostream & os)
+{
+    static const bool stdout_tty = isatty(STDOUT_FILENO);
+    static const bool stderr_tty = isatty(STDERR_FILENO);
+    if (&os == &std::cout)
+        return stdout_tty;
+    if (&os == &std::cerr)
+        return stderr_tty;
+    return (stdout_tty && stderr_tty);
+}
+#endif
+
+static bool isColorEnabled(const std::ostream & os)
+{
+    // See https://bixense.com/clicolors/
+    static const bool color_forced_off = (nullptr != std::getenv("NO_COLOR"));
+    if (color_forced_off)
+    {
+        return false;
+    }
+    static const bool color_forced_on = (nullptr != std::getenv("CLICOLOR_FORCE"));
+    if (color_forced_on)
+    {
+        return true;
+    }
+#ifdef _WIN32
+    (void)os;
+    return false;
+#else
+    return isStreamATty(os);
+#endif
+}
+
+std::ostream& operator<<(std::ostream & os, Color c)
+{
+    if (!gDisableColors && isColorEnabled(os))
+        return os << "\033[" << static_cast<std::size_t>(c) << "m";
+
+    return os;
+}
+
+std::string toString(Color c)
+{
+    std::ostringstream ss;
+    ss << c;
+    return ss.str();
+}
+
diff --git a/lib/color.h b/lib/color.h
new file mode 100644
index 00000000000..1a677e8393a
--- /dev/null
+++ b/lib/color.h
@@ -0,0 +1,44 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef colorH
+#define colorH
+
+#include "config.h"
+
+#include <cstdint>
+#include <ostream>
+#include <string>
+
+enum class Color : std::uint8_t {
+    Reset      = 0,
+    Bold       = 1,
+    Dim        = 2,
+    FgRed      = 31,
+    FgGreen    = 32,
+    FgBlue     = 34,
+    FgMagenta  = 35,
+    FgDefault  = 39
+};
+CPPCHECKLIB std::ostream& operator<<(std::ostream& os, Color c);
+
+CPPCHECKLIB std::string toString(Color c);
+
+extern CPPCHECKLIB bool gDisableColors; // for testing
+
+#endif
diff --git a/lib/config.h b/lib/config.h
index 859e3ebb02f..ca60904c5d9 100644
--- a/lib/config.h
+++ b/lib/config.h
@@ -1,6 +1,28 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #ifndef configH
 #define configH
 
+#ifdef MAXTIME
+#error "MAXTIME is no longer supported - please use command-line options --checks-max-time=, --template-max-time= and --typedef-max-time= instead"
+#endif
+
 #ifdef _WIN32
 #  ifdef CPPCHECKLIB_EXPORT
 #    define CPPCHECKLIB __declspec(dllexport)
@@ -13,20 +35,191 @@
 #  define CPPCHECKLIB
 #endif
 
-// MS Visual C++ memory leak debug tracing
-#if defined(_MSC_VER) && defined(_DEBUG)
-#  define _CRTDBG_MAP_ALLOC
-#  include <crtdbg.h>
+// compatibility macros
+#ifndef __has_builtin
+#define __has_builtin(x) 0
+#endif
+
+#ifndef __has_include
+#define __has_include(x) 0
+#endif
+
+#ifndef __has_cpp_attribute
+#define __has_cpp_attribute(x) 0
+#endif
+
+#ifndef __has_feature
+#define __has_feature(x) 0
+#endif
+
+// C++11 noexcept
+#if defined(__cpp_noexcept_function_type) || \
+    (defined(__GNUC__) && (__GNUC__ >= 5)) \
+    || defined(__clang__) \
+    || defined(__CPPCHECK__)
+#  define NOEXCEPT noexcept
+#else
+#  define NOEXCEPT
+#endif
+
+// C++11 noreturn
+#if __has_cpp_attribute (noreturn) \
+    || (defined(__GNUC__) && (__GNUC__ >= 5)) \
+    || defined(__clang__) \
+    || defined(__CPPCHECK__)
+#  define NORETURN [[noreturn]]
+#elif defined(__GNUC__)
+#  define NORETURN __attribute__((noreturn))
+#else
+#  define NORETURN
+#endif
+
+// fallthrough
+#if __cplusplus >= 201703L && __has_cpp_attribute (fallthrough)
+#  define FALLTHROUGH [[fallthrough]]
+#elif defined(__clang__)
+#  define FALLTHROUGH [[clang::fallthrough]]
+#elif (defined(__GNUC__) && (__GNUC__ >= 7))
+#  define FALLTHROUGH __attribute__((fallthrough))
+#else
+#  define FALLTHROUGH
+#endif
+
+// unused
+#if __cplusplus >= 201703L && __has_cpp_attribute (maybe_unused)
+#  define UNUSED [[maybe_unused]]
+#elif defined(__GNUC__) \
+    || defined(__clang__) \
+    || defined(__CPPCHECK__)
+#  define UNUSED __attribute__((unused))
+#else
+#  define UNUSED
+#endif
+
+// TODO: AppleClang versions do not align with Clang versions - add check for proper version
+// warn_unused
+#if __has_cpp_attribute (gnu::warn_unused) || \
+    (defined(__clang__) && (__clang_major__ >= 15))
+#  define WARN_UNUSED [[gnu::warn_unused]]
+#else
+#  define WARN_UNUSED
+#endif
+
+// deprecated
+#if defined(__GNUC__) \
+    || defined(__clang__) \
+    || defined(__CPPCHECK__)
+#  define DEPRECATED __attribute__((deprecated))
+#elif defined(_MSC_VER)
+#  define DEPRECATED __declspec(deprecated)
+#else
+#  define DEPRECATED
+#endif
+
+// TODO: AppleClang versions do not align with Clang versions - add check for proper version
+// returns_nonnull
+#if __has_cpp_attribute (gnu::returns_nonnull)
+#  define RET_NONNULL [[gnu::returns_nonnull]]
+#elif (defined(__clang__) && ((__clang_major__ > 3) || ((__clang_major__ == 3) && (__clang_minor__ >= 7)))) \
+    || (defined(__GNUC__) && (__GNUC__ >= 9))
+#  define RET_NONNULL __attribute__((returns_nonnull))
+#else
+#  define RET_NONNULL
+#endif
+
+#define REQUIRES(msg, ...) class=typename std::enable_if<__VA_ARGS__::value>::type
+
+// Use the nonneg macro when you want to assert that a variable/argument is not negative
+#ifdef __CPPCHECK__
+#define nonneg   __cppcheck_low__(0)
+#elif defined(NONNEG)
+// Enable non-negative values checking
+// TODO : investigate using annotations/contracts for stronger value checking
+#define nonneg   unsigned
+#else
+// Disable non-negative values checking
+#define nonneg
+#endif
+
+#if __has_feature(address_sanitizer)
+#define ASAN 1
 #endif
 
-// C++11 override
-#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ >= 5)) || defined(__CPPCHECK__)
-#  define OVERRIDE override
+#ifndef ASAN
+#ifdef  __SANITIZE_ADDRESS__
+#define ASAN 1
 #else
-#  define OVERRIDE
+#define ASAN 0
+#endif
+#endif
+
+#if defined(_WIN32)
+#define HAS_THREADING_MODEL_THREAD
+#define STDCALL __stdcall
+#elif ((defined(__GNUC__) || defined(__sun)) && !defined(__MINGW32__)) || defined(__CPPCHECK__)
+#if !defined(DISALLOW_PROCESS_EXECUTOR)
+#define HAS_THREADING_MODEL_FORK
+#endif
+#if !defined(DISALLOW_THREAD_EXECUTOR)
+#define HAS_THREADING_MODEL_THREAD
+#endif
+#define STDCALL
 #endif
 
-#include <string>
-static const std::string emptyString;
+#if !defined(HAS_THREADING_MODEL_FORK) && !defined(HAS_THREADING_MODEL_THREAD)
+#error "No threading model defined"
+#endif
+
+#define STRINGISIZE(...) #__VA_ARGS__
+
+#ifdef __clang__
+#define SUPPRESS_WARNING_PUSH(warning) _Pragma("clang diagnostic push") _Pragma(STRINGISIZE(clang diagnostic ignored warning))
+#define SUPPRESS_WARNING_POP _Pragma("clang diagnostic pop")
+#define SUPPRESS_WARNING_GCC_PUSH(warning)
+#define SUPPRESS_WARNING_GCC_POP
+#define SUPPRESS_WARNING_CLANG_PUSH(warning) SUPPRESS_WARNING_PUSH(warning)
+#define SUPPRESS_WARNING_CLANG_POP SUPPRESS_WARNING_POP
+#define FORCE_WARNING_PUSH(warn) _Pragma("clang diagnostic push") _Pragma(STRINGISIZE(clang diagnostic warning warn))
+#define FORCE_WARNING_CLANG_PUSH(warning) FORCE_WARNING_PUSH(warning)
+#define FORCE_WARNING_CLANG_POP SUPPRESS_WARNING_POP
+#elif defined(__GNUC__)
+#define SUPPRESS_WARNING_PUSH(warning) _Pragma("GCC diagnostic push") _Pragma(STRINGISIZE(GCC diagnostic ignored warning))
+#define SUPPRESS_WARNING_POP _Pragma("GCC diagnostic pop")
+#define SUPPRESS_WARNING_GCC_PUSH(warning) SUPPRESS_WARNING_PUSH(warning)
+#define SUPPRESS_WARNING_GCC_POP SUPPRESS_WARNING_POP
+#define SUPPRESS_WARNING_CLANG_PUSH(warning)
+#define SUPPRESS_WARNING_CLANG_POP
+#define FORCE_WARNING_PUSH(warning)
+#define FORCE_WARNING_CLANG_PUSH(warning)
+#define FORCE_WARNING_CLANG_POP
+#else
+#define SUPPRESS_WARNING_PUSH(warning)
+#define SUPPRESS_WARNING_POP
+#define SUPPRESS_WARNING_GCC_PUSH(warning)
+#define SUPPRESS_WARNING_GCC_POP
+#define SUPPRESS_WARNING_CLANG_PUSH(warning)
+#define SUPPRESS_WARNING_CLANG_POP
+#define FORCE_WARNING_PUSH(warning)
+#define FORCE_WARNING_CLANG_PUSH(warning)
+#define FORCE_WARNING_CLANG_POP
+#endif
+
+#if !defined(NO_WINDOWS_SEH) && defined(_WIN32) && defined(_MSC_VER)
+#define USE_WINDOWS_SEH
+#endif
+
+#if !defined(NO_UNIX_BACKTRACE_SUPPORT)
+#if defined(HAVE_EXECINFO_H)
+#if HAVE_EXECINFO_H
+#define USE_UNIX_BACKTRACE_SUPPORT
+#endif
+#elif defined(__GNUC__) && !defined(__APPLE__) && !defined(__CYGWIN__) && !defined(__MINGW32__) && !defined(__NetBSD__) && !defined(__OpenBSD__) && !defined(__SVR4) && !defined(__QNX__) && !defined(_AIX)
+#define USE_UNIX_BACKTRACE_SUPPORT
+#endif
+#endif
+
+#if !defined(NO_UNIX_SIGNAL_HANDLING) && defined(__GNUC__) && !defined(__MINGW32__) && !defined(__OS2__)
+#define USE_UNIX_SIGNAL_HANDLING
+#endif
 
 #endif // configH
diff --git a/lib/cppcheck.cpp b/lib/cppcheck.cpp
index 790aa159d1b..5023a5e258e 100644
--- a/lib/cppcheck.cpp
+++ b/lib/cppcheck.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,165 +15,548 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #include "cppcheck.h"
 
+#include "addoninfo.h"
+#include "analyzerinfo.h"
 #include "check.h"
 #include "checkunusedfunctions.h"
+#include "clangimport.h"
+#include "color.h"
 #include "ctu.h"
+#include "errorlogger.h"
+#include "errortypes.h"
+#include "filesettings.h"
 #include "library.h"
-#include "mathlib.h"
 #include "path.h"
 #include "platform.h"
-#include "preprocessor.h" // Preprocessor
+#include "preprocessor.h"
+#include "settings.h"
+#include "standards.h"
 #include "suppressions.h"
+#include "symboldatabase.h"
 #include "timer.h"
 #include "token.h"
-#include "tokenize.h" // Tokenizer
+#include "tokenize.h"
 #include "tokenlist.h"
+#include "utils.h"
+#include "valueflow.h"
 #include "version.h"
 
-#include "exprengine.h"
+#ifdef HAVE_RULES
+#include "regex.h"
+#endif
 
-#define PICOJSON_USE_INT64
-#include <picojson.h>
-#include <simplecpp.h>
-#include <tinyxml2.h>
 #include <algorithm>
+#include <cassert>
+#include <cstdio>
+#include <cstdint>
 #include <cstring>
+#include <cctype>
+#include <cstdlib>
+#include <ctime>
+#include <exception> // IWYU pragma: keep
+#include <fstream>
+#include <iostream>
+#include <map>
 #include <new>
 #include <set>
+#include <sstream>
 #include <stdexcept>
+#include <string>
+#include <unordered_set>
+#include <utility>
 #include <vector>
-#include <memory>
-#include <iostream> // <- TEMPORARY
 
-#ifdef HAVE_RULES
-#define PCRE_STATIC
-#include <pcre.h>
-#endif
+#include "json.h"
+
+#include <simplecpp.h>
+
+namespace tinyxml2 { class XMLElement; }
 
-static const char Version[] = CPPCHECK_VERSION_STRING;
-static const char ExtraVersion[] = "";
+static constexpr char Version[] = CPPCHECK_VERSION_STRING;
+static constexpr char ExtraVersion[] = "";
 
-static TimerResults S_timerResults;
+static constexpr char FILELIST[] = "cppcheck-addon-ctu-file-list";
 
 // CWE ids used
 static const CWE CWE398(398U);  // Indicator of Poor Code Quality
 
-namespace {
-    struct AddonInfo {
-        std::string name;
-        std::string scriptFile;
-        std::string args;
-
-        static std::string getFullPath(const std::string &fileName, const std::string &exename) {
-            if (Path::fileExists(fileName))
-                return fileName;
-
-            const std::string exepath = Path::getPathFromFilename(exename);
-            if (Path::fileExists(exepath + fileName))
-                return exepath + fileName;
-            if (Path::fileExists(exepath + "addons/" + fileName))
-                return exepath + "addons/" + fileName;
-
-#ifdef FILESDIR
-            if (Path::fileExists(FILESDIR + ("/" + fileName)))
-                return FILESDIR + ("/" + fileName);
-            if (Path::fileExists(FILESDIR + ("/addons/" + fileName)))
-                return FILESDIR + ("/addons/" + fileName);
-#endif
-            return "";
+class CppCheck::CppCheckLogger : public ErrorLogger
+{
+public:
+    CppCheckLogger(ErrorLogger& errorLogger, const Settings& settings, Suppressions& suppressions, bool useGlobalSuppressions)
+        : mErrorLogger(errorLogger)
+        , mSettings(settings)
+        , mSuppressions(suppressions)
+        , mUseGlobalSuppressions(useGlobalSuppressions)
+    {}
+
+    ~CppCheckLogger() override
+    {
+        closePlist();
+    }
+
+    void setRemarkComments(std::vector<RemarkComment> remarkComments)
+    {
+        mRemarkComments = std::move(remarkComments);
+    }
+
+    void setLocationMacros(const Token* startTok, const std::vector<std::string>& files)
+    {
+        mLocationMacros.clear();
+        for (const Token* tok = startTok; tok; tok = tok->next()) {
+            if (!tok->getMacroName().empty())
+                mLocationMacros[Location(files[tok->fileIndex()], tok->linenr())].emplace(tok->getMacroName());
         }
+    }
 
-        std::string getAddonInfo(const std::string &fileName, const std::string &exename) {
-            if (fileName.find(".") == std::string::npos)
-                return getAddonInfo(fileName + ".py", exename);
-
-            if (endsWith(fileName, ".py", 3)) {
-                scriptFile = getFullPath(fileName, exename);
-                if (scriptFile.empty())
-                    return "Did not find addon " + fileName;
-
-                std::string::size_type pos1 = scriptFile.rfind("/");
-                if (pos1 == std::string::npos)
-                    pos1 = 0;
-                else
-                    pos1++;
-                std::string::size_type pos2 = scriptFile.rfind(".");
-                if (pos2 < pos1)
-                    pos2 = std::string::npos;
-                name = scriptFile.substr(pos1, pos2 - pos1);
-
-                return "";
+    void resetExitCode()
+    {
+        mExitCode = 0;
+    }
+
+    void clear()
+    {
+        mErrorList.clear();
+    }
+
+    void openPlist(const std::string& filename, const std::vector<std::string>& files)
+    {
+        mPlistFile.open(filename);
+        mPlistFile << ErrorLogger::plistHeader(version(), files);
+    }
+
+    void closePlist()
+    {
+        if (mPlistFile.is_open()) {
+            mPlistFile << ErrorLogger::plistFooter();
+            mPlistFile.close();
+        }
+    }
+
+    unsigned int exitcode() const
+    {
+        return mExitCode;
+    }
+
+    void setAnalyzerInfo(AnalyzerInformation* info)
+    {
+        mAnalyzerInformation = info;
+    }
+
+private:
+    /**
+     * @brief Errors and warnings are directed here.
+     *
+     * @param msg Errors messages are normally in format
+     * "[filepath:line number] Message", e.g.
+     * "[main.cpp:4] Uninitialized member variable"
+     */
+    // TODO: part of this logic is duplicated in Executor::hasToLog()
+    void reportErr(const ErrorMessage &msg) override
+    {
+        if (msg.severity == Severity::internal) {
+            mErrorLogger.reportErr(msg);
+            return;
+        }
+
+        if (!mSettings.library.reportErrors(msg.file0))
+            return;
+
+        std::set<std::string> macroNames;
+        if (!msg.callStack.empty()) {
+            const std::string &file = msg.callStack.back().getfile(false);
+            int lineNumber = msg.callStack.back().line;
+            const auto it = mLocationMacros.find(Location(file, lineNumber));
+            if (it != mLocationMacros.cend())
+                macroNames = it->second;
+        }
+
+        // TODO: only convert if necessary
+        const auto errorMessage = SuppressionList::ErrorMessage::fromErrorMessage(msg, macroNames);
+
+        bool suppressed = false;
+
+        if (mSuppressions.nomsg.isSuppressed(errorMessage, mUseGlobalSuppressions)) {
+            // Safety: Report critical errors to ErrorLogger
+            if (mSettings.safety && ErrorLogger::isCriticalErrorId(msg.id)) {
+                mExitCode = 1;
+
+                if (mSuppressions.nomsg.isSuppressedExplicitly(errorMessage, mUseGlobalSuppressions)) {
+                    // Report with internal severity to signal that there is this critical error but
+                    // it is suppressed
+                    ErrorMessage temp(msg);
+                    temp.severity = Severity::internal;
+                    mErrorLogger.reportErr(temp);
+                } else {
+                    // Report critical error that is not explicitly suppressed
+                    mErrorLogger.reportErr(msg);
+                }
             }
+            suppressed = true;
+        }
+
+        // TODO: there should be no need for the verbose and default messages here
+        std::string errmsg = msg.toString(mSettings.verbose, mSettings.templateFormat, mSettings.templateLocation);
+        if (errmsg.empty())
+            return;
+
+        // Alert only about unique errors.
+        // This makes sure the errors of a single check() call are unique.
+        // TODO: get rid of this? This is forwarded to another ErrorLogger which is also doing this
+        if (!mSettings.emitDuplicates && !mErrorList.emplace(std::move(errmsg)).second)
+            return;
+
+        if (mAnalyzerInformation)
+            mAnalyzerInformation->reportErr(msg);
 
-            if (!endsWith(fileName, ".json", 5))
-                return "Failed to open addon " + fileName;
-
-            std::ifstream fin(fileName);
-            if (!fin.is_open())
-                return "Failed to open " + fileName;
-            picojson::value json;
-            fin >> json;
-            if (!json.is<picojson::object>())
-                return "Loading " + fileName + " failed. Bad json.";
-            picojson::object obj = json.get<picojson::object>();
-            if (obj.count("args")) {
-                if (!obj["args"].is<picojson::array>())
-                    return "Loading " + fileName + " failed. args must be array.";
-                for (const picojson::value &v : obj["args"].get<picojson::array>())
-                    args += " " + v.get<std::string>();
+        if (suppressed)
+            return;
+
+        if (!mSuppressions.nofail.isSuppressed(errorMessage) && !mSuppressions.nomsg.isSuppressed(errorMessage)) {
+            mExitCode = 1;
+        }
+
+        std::string remark;
+        if (!msg.callStack.empty()) {
+            for (const auto& r: mRemarkComments) {
+                if (r.file != msg.callStack.back().getfile(false))
+                    continue;
+                if (r.lineNumber != msg.callStack.back().line)
+                    continue;
+                remark = r.str;
+                break;
             }
+        }
+
+        if (!remark.empty()) {
+            ErrorMessage msg2(msg);
+            msg2.remark = std::move(remark);
+            mErrorLogger.reportErr(msg2);
+        } else {
+            mErrorLogger.reportErr(msg);
+        }
+
+        // check if plistOutput should be populated and the current output file is open and the error is not suppressed
+        if (!mSettings.plistOutput.empty() && mPlistFile.is_open() && !mSuppressions.nomsg.isSuppressed(errorMessage)) {
+            // add error to plist output file
+            mPlistFile << ErrorLogger::plistData(msg);
+        }
+    }
+
+    /**
+     * @brief Information about progress is directed here.
+     *
+     * @param outmsg Message to show, e.g. "Checking main.cpp..."
+     */
+    void reportOut(const std::string &outmsg, Color c = Color::Reset) override
+    {
+        mErrorLogger.reportOut(outmsg, c);
+    }
 
-            return getAddonInfo(obj["script"].get<std::string>(), exename);
+    void reportMetric(const std::string &metric) override
+    {
+        mErrorLogger.reportMetric(metric);
+    }
+
+    void reportProgress(const std::string &filename, const char stage[], const std::size_t value) override
+    {
+        mErrorLogger.reportProgress(filename, stage, value);
+    }
+
+    ErrorLogger &mErrorLogger;
+    const Settings& mSettings;
+    Suppressions& mSuppressions;
+    bool mUseGlobalSuppressions;
+
+    // TODO: store hashes instead of the full messages
+    std::unordered_set<std::string> mErrorList;
+
+    std::vector<RemarkComment> mRemarkComments;
+
+    using Location = std::pair<std::string, int>;
+    std::map<Location, std::set<std::string>> mLocationMacros; // What macros are used on a location?
+
+    std::ofstream mPlistFile;
+
+    unsigned int mExitCode{};
+
+    AnalyzerInformation* mAnalyzerInformation{};
+};
+
+
+// File deleter
+namespace {
+    class FilesDeleter {
+    public:
+        FilesDeleter() = default;
+        ~FilesDeleter() {
+            for (const std::string& fileName: mFilenames)
+                std::remove(fileName.c_str());
         }
+        void addFile(const std::string& fileName) {
+            mFilenames.push_back(fileName);
+        }
+    private:
+        std::vector<std::string> mFilenames;
     };
 }
 
-static std::string executeAddon(const AddonInfo &addonInfo, const std::string &dumpFile)
+static std::string cmdFileName(std::string f)
+{
+    f = Path::toNativeSeparators(std::move(f));
+    if (f.find(' ') != std::string::npos)
+        return "\"" + f + "\"";
+    return f;
+}
+
+static std::vector<std::string> split(const std::string &str, const std::string &sep=" ")
 {
-    const std::string cmd = "python \"" + addonInfo.scriptFile + "\" --cli" + addonInfo.args + " \"" + dumpFile + "\"";
+    std::vector<std::string> ret;
+    for (std::string::size_type startPos = 0U; startPos < str.size();) {
+        startPos = str.find_first_not_of(sep, startPos);
+        if (startPos == std::string::npos)
+            break;
+
+        if (str[startPos] == '\"') {
+            const std::string::size_type endPos = str.find('\"', startPos + 1);
+            ret.push_back(str.substr(startPos + 1, endPos - startPos - 1));
+            startPos = (endPos < str.size()) ? (endPos + 1) : endPos;
+            continue;
+        }
+
+        const std::string::size_type endPos = str.find(sep, startPos + 1);
+        ret.push_back(str.substr(startPos, endPos - startPos));
+        startPos = endPos;
+    }
+
+    return ret;
+}
+
+static std::string getDumpFileName(const Settings& settings, const FileWithDetails& file)
+{
+    std::string extension = ".dump";
+    if (file.fsFileId() > 0)
+        extension = "." + std::to_string(file.fsFileId()) + extension;
+    if (!settings.dump && settings.buildDir.empty())
+        extension = "." + std::to_string(settings.pid) + extension;
+
+    if (!settings.dump && !settings.buildDir.empty())
+        return AnalyzerInformation::getAnalyzerInfoFile(settings.buildDir, file.spath(), "", file.fsFileId()) + extension;
+    return file.spath() + extension;
+}
+
+static std::string getCtuInfoFileName(const std::string &dumpFile)
+{
+    return dumpFile.substr(0, dumpFile.size()-4) + "ctu-info";
+}
 
+static void createDumpFile(const Settings& settings,
+                           const FileWithDetails& file,
+                           std::ofstream& fdump,
+                           std::string& dumpFile)
+{
+    if (!settings.dump && settings.addons.empty())
+        return;
+    dumpFile = getDumpFileName(settings, file);
+
+    fdump.open(dumpFile);
+    if (!fdump.is_open())
+        return;
+
+    if (!settings.buildDir.empty()) {
+        std::ofstream fout(getCtuInfoFileName(dumpFile));
+    }
+
+    std::string language;
+
+    assert(file.lang() != Standards::Language::None);
+
+    switch (file.lang()) {
+    case Standards::Language::C:
+        language = " language=\"c\"";
+        break;
+    case Standards::Language::CPP:
+        language = " language=\"cpp\"";
+        break;
+    case Standards::Language::None:
+        break;
+    }
+
+    fdump << "<?xml version=\"1.0\"?>\n";
+    fdump << "<dumps" << language << ">\n";
+    fdump << "  <platform"
+          << " name=\"" << settings.platform.toString() << '\"'
+          << " char_bit=\"" << static_cast<unsigned>(settings.platform.char_bit) << '\"'
+          << " short_bit=\"" << static_cast<unsigned>(settings.platform.short_bit) << '\"'
+          << " int_bit=\"" << static_cast<unsigned>(settings.platform.int_bit) << '\"'
+          << " long_bit=\"" << static_cast<unsigned>(settings.platform.long_bit) << '\"'
+          << " long_long_bit=\"" << static_cast<unsigned>(settings.platform.long_long_bit) << '\"'
+          << " float_bit=\"" << static_cast<unsigned>(settings.platform.float_bit) << '\"'
+          << " double_bit=\"" << static_cast<unsigned>(settings.platform.double_bit) << '\"'
+          << " long_double_bit=\"" << static_cast<unsigned>(settings.platform.long_double_bit) << '\"'
+          << " pointer_bit=\"" << (settings.platform.sizeof_pointer * settings.platform.char_bit) << '\"'
+          << " wchar_t_bit=\"" << (settings.platform.sizeof_wchar_t * settings.platform.char_bit) << '\"'
+          << " size_t_bit=\"" << (settings.platform.sizeof_size_t * settings.platform.char_bit) << '\"'
+          << "/>\n";
+}
+
+static std::string detectPython(const CppCheck::ExecuteCmdFn &executeCommand)
+{
 #ifdef _WIN32
-    std::unique_ptr<FILE, decltype(&_pclose)> pipe(_popen(cmd.c_str(), "r"), _pclose);
+    const char *py_exes[] = { "python3.exe", "python.exe" };
 #else
-    std::unique_ptr<FILE, decltype(&pclose)> pipe(popen(cmd.c_str(), "r"), pclose);
+    const char *py_exes[] = { "python3", "python" };
 #endif
-    if (!pipe)
-        return "";
-    char buffer[1024];
-    std::string result;
-    while (fgets(buffer, sizeof(buffer), pipe.get()) != nullptr) {
-        result += buffer;
+    for (const char* py_exe : py_exes) {
+        std::string out;
+#ifdef _MSC_VER
+        // FIXME: hack to avoid debug assertion with _popen() in executeCommand() for non-existing commands
+        const std::string cmd = std::string(py_exe) + " --version >NUL 2>&1";
+        if (system(cmd.c_str()) != 0) {
+            // TODO: get more detailed error?
+            continue;
+        }
+#endif
+        if (executeCommand(py_exe, split("--version"), "2>&1", out) == EXIT_SUCCESS && startsWith(out, "Python ") && std::isdigit(out[7])) {
+            return py_exe;
+        }
     }
-    return result;
+    return "";
 }
 
-static std::vector<std::string> split(const std::string &str, const std::string &sep)
+/**
+ * @throws InternalError thrown when execution fails
+ */
+static std::vector<picojson::value> executeAddon(const AddonInfo &addonInfo,
+                                                 const std::string &defaultPythonExe,
+                                                 const std::string &file,
+                                                 const std::string &premiumArgs,
+                                                 const CppCheck::ExecuteCmdFn &executeCommand)
 {
-    std::vector<std::string> ret;
-    for (std::string::size_type defineStartPos = 0U; defineStartPos < str.size();) {
-        const std::string::size_type defineEndPos = str.find(sep, defineStartPos);
-        ret.push_back((defineEndPos == std::string::npos) ? str.substr(defineStartPos) : str.substr(defineStartPos, defineEndPos - defineStartPos));
-        if (defineEndPos == std::string::npos)
-            break;
-        defineStartPos = defineEndPos + 1U;
+    if (!executeCommand)
+        throw InternalError(nullptr, "Failed to execute addon - no command callback provided");
+
+    std::string pythonExe;
+
+    if (!addonInfo.executable.empty())
+        pythonExe = addonInfo.executable;
+    else if (!addonInfo.python.empty())
+        pythonExe = cmdFileName(addonInfo.python);
+    else if (!defaultPythonExe.empty())
+        pythonExe = cmdFileName(defaultPythonExe);
+    else {
+        // store in static variable so we only look this up once - TODO: do not cache globally
+        static const std::string detectedPythonExe = detectPython(executeCommand);
+        if (detectedPythonExe.empty())
+            throw InternalError(nullptr, "Failed to auto detect python");
+        pythonExe = detectedPythonExe;
     }
-    return ret;
+
+    std::string args;
+    if (addonInfo.executable.empty())
+        args = cmdFileName(addonInfo.runScript) + " " + cmdFileName(addonInfo.scriptFile);
+    args += std::string(args.empty() ? "" : " ") + "--cli" + addonInfo.args;
+    if (!premiumArgs.empty() && !addonInfo.executable.empty())
+        args += " " + premiumArgs;
+
+    const bool is_file_list = (file.find(FILELIST) != std::string::npos);
+    const std::string fileArg = (is_file_list ? " --file-list " : " ") + cmdFileName(file);
+    args += fileArg;
+
+    std::string result;
+    if (const int exitcode = executeCommand(pythonExe, split(args), "2>&1", result)) {
+        std::string message("Failed to execute addon '" + addonInfo.name + "' - exitcode is " + std::to_string(exitcode));
+        std::string details = pythonExe + " " + args;
+        if (result.size() > 2) {
+            details += "\nOutput:\n";
+            details += result;
+            const auto pos = details.find_last_not_of("\n\r");
+            if (pos != std::string::npos)
+                details.resize(pos + 1);
+        }
+        throw InternalError(nullptr, std::move(message), std::move(details));
+    }
+
+    std::vector<picojson::value> addonResult;
+
+    // Validate output..
+    std::istringstream istr(result);
+    std::string line;
+    while (std::getline(istr, line)) {
+        // TODO: also bail out?
+        if (line.empty()) {
+            //std::cout << "addon '" << addonInfo.name <<  "' result contains empty line" << std::endl;
+            continue;
+        }
+
+        // TODO: get rid of this
+        if (startsWith(line,"Checking ")) {
+            //std::cout << "addon '" << addonInfo.name <<  "' result contains 'Checking ' line" << std::endl;
+            continue;
+        }
+
+        if (line[0] != '{') {
+            //std::cout << "addon '" << addonInfo.name <<  "' result is not a JSON" << std::endl;
+
+            result.erase(result.find_last_not_of('\n') + 1, std::string::npos); // Remove trailing newlines
+            throw InternalError(nullptr, "Failed to execute '" + pythonExe + " " + args + "'. " + result);
+        }
+
+        //std::cout << "addon '" << addonInfo.name <<  "' result is " << line << std::endl;
+
+        // TODO: make these failures?
+        picojson::value res;
+        const std::string err = picojson::parse(res, line);
+        if (!err.empty()) {
+            //std::cout << "addon '" << addonInfo.name <<  "' result is not a valid JSON (" << err << ")" << std::endl;
+            continue;
+        }
+        if (!res.is<picojson::object>()) {
+            //std::cout << "addon '" << addonInfo.name <<  "' result is not a JSON object" << std::endl;
+            continue;
+        }
+        addonResult.emplace_back(std::move(res));
+    }
+
+    // Valid results
+    return addonResult;
 }
 
-CppCheck::CppCheck(ErrorLogger &errorLogger, bool useGlobalSuppressions)
-    : mErrorLogger(errorLogger), mExitCode(0), mSuppressInternalErrorFound(false), mUseGlobalSuppressions(useGlobalSuppressions), mTooManyConfigs(false), mSimplify(true)
+static std::string getDefinesFlags(const std::string &semicolonSeparatedString)
 {
+    std::string flags;
+    for (const std::string &d: split(semicolonSeparatedString, ";"))
+        flags += "-D" + d + " ";
+    return flags;
 }
 
+CppCheck::CppCheck(const Settings& settings,
+                   Suppressions& supprs,
+                   ErrorLogger &errorLogger,
+                   TimerResults *timerResults,
+                   bool useGlobalSuppressions,
+                   ExecuteCmdFn executeCommand)
+    : mSettings(settings)
+    , mSuppressions(supprs)
+    , mLogger(new CppCheckLogger(errorLogger, mSettings, mSuppressions, useGlobalSuppressions))
+    , mErrorLogger(*mLogger)
+    , mErrorLoggerDirect(errorLogger)
+    , mTimerResults(timerResults)
+    , mUseGlobalSuppressions(useGlobalSuppressions)
+    , mExecuteCommand(std::move(executeCommand))
+{}
+
 CppCheck::~CppCheck()
 {
+    mLogger->setAnalyzerInfo(nullptr);
+
     while (!mFileInfo.empty()) {
         delete mFileInfo.back();
         mFileInfo.pop_back();
     }
-    S_timerResults.ShowResults(mSettings.showtime);
 }
 
 const char * CppCheck::version()
@@ -186,248 +569,528 @@ const char * CppCheck::extraVersion()
     return ExtraVersion;
 }
 
-unsigned int CppCheck::check(const std::string &path)
+static bool reportClangErrors(std::istream &is, const std::function<void(const ErrorMessage&)>& reportErr, std::vector<ErrorMessage> &warnings)
 {
-    std::ifstream fin(path);
-    return checkFile(Path::simplifyPath(path), emptyString, fin);
+    std::string line;
+    while (std::getline(is, line)) {
+        if (line.empty() || line[0] == ' ' || line[0] == '`' || line[0] == '-')
+            continue;
+
+        std::string::size_type pos3 = line.find(": error: ");
+        if (pos3 == std::string::npos)
+            pos3 = line.find(": fatal error:");
+        if (pos3 == std::string::npos)
+            pos3 = line.find(": warning:");
+        if (pos3 == std::string::npos)
+            continue;
+
+        // file:line:column: error: ....
+        const std::string::size_type pos2 = line.rfind(':', pos3 - 1);
+        const std::string::size_type pos1 = line.rfind(':', pos2 - 1);
+
+        if (pos1 >= pos2 || pos2 >= pos3)
+            continue;
+
+        std::string filename = line.substr(0, pos1);
+        const std::string linenr = line.substr(pos1+1, pos2-pos1-1);
+        const std::string colnr = line.substr(pos2+1, pos3-pos2-1);
+        const std::string msg = line.substr(line.find(':', pos3+1) + 2);
+
+        std::string locFile = Path::toNativeSeparators(std::move(filename));
+        const int line_i = strToInt<int>(linenr);
+        const int column = strToInt<unsigned int>(colnr);
+        ErrorMessage::FileLocation loc(locFile, line_i, column);
+        ErrorMessage errmsg({std::move(loc)},
+                            std::move(locFile),
+                            Severity::error,
+                            msg,
+                            "syntaxError",
+                            Certainty::normal);
+
+        if (line.compare(pos3, 10, ": warning:") == 0) {
+            warnings.push_back(std::move(errmsg));
+            continue;
+        }
+
+        reportErr(errmsg);
+
+        return true;
+    }
+    return false;
 }
 
-unsigned int CppCheck::check(const std::string &path, const std::string &content)
+std::string CppCheck::getLibraryDumpData() const {
+    std::string out;
+    for (const std::string &s : mSettings.libraries) {
+        out += "  <library lib=\"" + s + "\"/>\n";
+    }
+    return out;
+}
+
+/**
+ * @brief Get the clang command line flags using the Settings
+ * @param lang language guessed from filename
+ * @return Clang command line flags
+ */
+static std::string getClangFlags(const Settings& setting, Standards::Language lang) {
+    std::string flags;
+
+    assert(lang != Standards::Language::None);
+
+    switch (lang) {
+    case Standards::Language::C:
+        flags = "-x c ";
+        if (!setting.standards.stdValueC.empty())
+            flags += "-std=" + setting.standards.stdValueC + " ";
+        break;
+    case Standards::Language::CPP:
+        flags += "-x c++ ";
+        if (!setting.standards.stdValueCPP.empty())
+            flags += "-std=" + setting.standards.stdValueCPP + " ";
+        break;
+    case Standards::Language::None:
+        break;
+    }
+
+    for (const std::string &i: setting.includePaths)
+        flags += "-I" + i + " ";
+
+    flags += getDefinesFlags(setting.userDefines);
+
+    for (const std::string &i: setting.userIncludes)
+        flags += "--include " + cmdFileName(i) + " ";
+
+    return flags;
+}
+
+// TODO: clear error list before returning
+unsigned int CppCheck::checkClang(const FileWithDetails &file)
 {
-    std::istringstream iss(content);
-    return checkFile(Path::simplifyPath(path), emptyString, iss);
+    // TODO: clear exitcode
+
+    if (mSettings.checks.isEnabled(Checks::unusedFunction) && !mUnusedFunctionsCheck)
+        mUnusedFunctionsCheck.reset(new CheckUnusedFunctions());
+
+    if (!mSettings.quiet)
+        mErrorLogger.reportOut(std::string("Checking ") + file.spath() + " ...", Color::FgGreen);
+
+    // TODO: get language from FileWithDetails object
+    std::string clangStderr;
+    if (!mSettings.buildDir.empty())
+        clangStderr = AnalyzerInformation::getAnalyzerInfoFile(mSettings.buildDir, file.spath(), "", file.fsFileId()) + ".clang-stderr";
+
+    std::string exe = mSettings.clangExecutable;
+#ifdef _WIN32
+    // append .exe if it is not a path
+    if (Path::fromNativeSeparators(mSettings.clangExecutable).find('/') == std::string::npos) {
+        exe += ".exe";
+    }
+#endif
+
+    const std::string args2 = "-fsyntax-only -Xclang -ast-dump -fno-color-diagnostics " +
+                              getClangFlags(mSettings, file.lang()) +
+                              file.spath();
+    const std::string redirect2 = clangStderr.empty() ? "2>&1" : ("2> " + clangStderr);
+    if (mSettings.verbose && !mSettings.quiet) {
+        mErrorLogger.reportOut(exe + " " + args2, Color::Reset);
+    }
+
+    if (!mExecuteCommand) {
+        std::cerr << "Failed to execute '" << exe << " " << args2 << " " << redirect2 << "' - (no command callback provided)" << std::endl;
+        return 0; // TODO: report as failure?
+    }
+
+    std::string output2;
+    const int exitcode = mExecuteCommand(exe,split(args2),redirect2,output2);
+    if (mSettings.debugClangOutput) {
+        std::cout << output2 << std::endl;
+    }
+    // TODO: this might also fail if compiler errors are encountered - we should report them properly
+    if (exitcode != EXIT_SUCCESS) {
+        // TODO: report as proper error
+        std::cerr << "Failed to execute '" << exe << " " << args2 << " " << redirect2 << "' - (exitcode: " << exitcode << " / output: " << output2 << ")" << std::endl;
+        return 0; // TODO: report as failure?
+    }
+
+    if (output2.find("TranslationUnitDecl") == std::string::npos) {
+        // TODO: report as proper error
+        std::cerr << "Failed to execute '" << exe << " " << args2 << " " << redirect2 << "' - (no TranslationUnitDecl in output)" << std::endl;
+        return 0; // TODO: report as failure?
+    }
+
+    const auto reportError = [this](const ErrorMessage& errorMessage) {
+        mErrorLogger.reportErr(errorMessage);
+    };
+
+    // Ensure there are not syntax errors...
+    std::vector<ErrorMessage> compilerWarnings;
+    if (!clangStderr.empty()) {
+        std::ifstream fin(clangStderr);
+        if (reportClangErrors(fin, reportError, compilerWarnings))
+            return 0; // TODO: report as failure?
+    } else {
+        std::istringstream istr(output2);
+        if (reportClangErrors(istr, reportError, compilerWarnings))
+            return 0; // TODO: report as failure?
+    }
+
+    try {
+        TokenList tokenlist{mSettings, file.lang()};
+        tokenlist.appendFileIfNew(file.spath());
+        Tokenizer tokenizer(std::move(tokenlist), mErrorLogger);
+        std::istringstream ast(output2);
+        clangimport::parseClangAstDump(tokenizer, ast);
+        ValueFlow::setValues(tokenizer.list,
+                             const_cast<SymbolDatabase&>(*tokenizer.getSymbolDatabase()),
+                             mErrorLogger,
+                             mSettings,
+                             mTimerResults);
+        tokenizer.printDebugOutput(std::cout);
+        checkNormalTokens(tokenizer, nullptr, ""); // TODO: provide analyzer information
+
+        // create dumpfile
+        std::ofstream fdump;
+        std::string dumpFile;
+        createDumpFile(mSettings, file, fdump, dumpFile);
+        if (fdump.is_open()) {
+            fdump << getLibraryDumpData();
+            // TODO: use tinyxml2 to create XML
+            fdump << "<dump cfg=\"\">\n";
+            for (const ErrorMessage& errmsg: compilerWarnings)
+                fdump << "  <clang-warning file=\"" << ErrorLogger::toxml(errmsg.callStack.front().getfile()) << "\" line=\"" << errmsg.callStack.front().line << "\" column=\"" << errmsg.callStack.front().column << "\" message=\"" << ErrorLogger::toxml(errmsg.shortMessage()) << "\"/>\n";
+            fdump << "  <standards>\n";
+            fdump << "    <c version=\"" << mSettings.standards.getC() << "\"/>\n";
+            fdump << "    <cpp version=\"" << mSettings.standards.getCPP() << "\"/>\n";
+            fdump << "  </standards>\n";
+            tokenizer.dump(fdump);
+            fdump << "</dump>\n";
+            fdump << "</dumps>\n";
+            fdump.close();
+        }
+
+        // run addons
+        executeAddons(dumpFile, file);
+
+    } catch (const InternalError &e) {
+        const ErrorMessage errmsg = ErrorMessage::fromInternalError(e, nullptr, file.spath(), "Bailing out from analysis: Processing Clang AST dump failed");
+        mErrorLogger.reportErr(errmsg);
+    } catch (const TerminateException &) {
+        // Analysis is terminated
+    } catch (const std::exception &e) {
+        internalError(file.spath(), std::string("Processing Clang AST dump failed: ") + e.what());
+    }
+
+    return mLogger->exitcode();
+}
+
+unsigned int CppCheck::check(const FileWithDetails &file)
+{
+    // TODO: handle differently?
+    // dummy call to make sure wildcards are being flagged as checked in case isSuppressed() is never called
+    {
+        // the empty ID is intentional for now - although it should not be allowed
+        ErrorMessage msg({}, file.spath(), Severity::information, "", "", Certainty::normal);
+        (void)mSuppressions.nomsg.isSuppressed(SuppressionList::ErrorMessage::fromErrorMessage(msg, {}), true);
+    }
+
+    unsigned int returnValue;
+    if (mSettings.clang)
+        returnValue = checkClang(file);
+    else
+        returnValue = checkFile(file, "");
+
+    // TODO: call analyseClangTidy()
+
+    return returnValue;
+}
+
+unsigned int CppCheck::checkBuffer(const FileWithDetails &file, const char* data, std::size_t size)
+{
+    return checkBuffer(file, "", data, size);
+}
+
+unsigned int CppCheck::check(const FileSettings &fs)
+{
+    // TODO: move to constructor when CppCheck no longer owns the settings
+    if (mSettings.checks.isEnabled(Checks::unusedFunction) && !mUnusedFunctionsCheck)
+        mUnusedFunctionsCheck.reset(new CheckUnusedFunctions());
+
+    Settings tempSettings = mSettings; // this is a copy
+    if (!tempSettings.userDefines.empty())
+        tempSettings.userDefines += ';';
+    if (mSettings.clang)
+        tempSettings.userDefines += fs.defines;
+    else
+        tempSettings.userDefines += fs.cppcheckDefines();
+    tempSettings.includePaths = fs.includePaths;
+    tempSettings.userUndefs.insert(fs.undefs.cbegin(), fs.undefs.cend());
+    if (fs.standard.find("++") != std::string::npos)
+        tempSettings.standards.setCPP(fs.standard);
+    else if (!fs.standard.empty())
+        tempSettings.standards.setC(fs.standard);
+    if (fs.platformType != Platform::Type::Unspecified)
+        tempSettings.platform.set(fs.platformType);
+    if (mSettings.clang) {
+        tempSettings.includePaths.insert(tempSettings.includePaths.end(), fs.systemIncludePaths.cbegin(), fs.systemIncludePaths.cend());
+        // need to pass the externally provided ErrorLogger instead of our internal wrapper
+        CppCheck temp(tempSettings, mSuppressions, mErrorLoggerDirect, mTimerResults, mUseGlobalSuppressions, mExecuteCommand);
+        // TODO: propagate back mFileInfo
+        const unsigned int returnValue = temp.check(fs.file);
+        if (mUnusedFunctionsCheck)
+            mUnusedFunctionsCheck->updateFunctionData(*temp.mUnusedFunctionsCheck);
+        return returnValue;
+    }
+    // need to pass the externally provided ErrorLogger instead of our internal wrapper
+    CppCheck temp(tempSettings, mSuppressions, mErrorLoggerDirect, mTimerResults, mUseGlobalSuppressions, mExecuteCommand);
+    const unsigned int returnValue = temp.checkFile(fs.file, fs.cfg);
+    if (mUnusedFunctionsCheck)
+        mUnusedFunctionsCheck->updateFunctionData(*temp.mUnusedFunctionsCheck);
+    while (!temp.mFileInfo.empty()) {
+        mFileInfo.push_back(temp.mFileInfo.back());
+        temp.mFileInfo.pop_back();
+    }
+    // TODO: propagate back more data?
+    if (mSettings.clangTidy)
+        analyseClangTidy(fs); // TODO: returnValue
+    return returnValue;
+}
+
+std::size_t CppCheck::calculateHash(const Preprocessor& preprocessor, const std::string& filePath) const
+{
+    std::ostringstream toolinfo;
+    toolinfo << (mSettings.cppcheckCfgProductName.empty() ? CPPCHECK_VERSION_STRING : mSettings.cppcheckCfgProductName);
+    toolinfo << (mSettings.severity.isEnabled(Severity::warning) ? 'w' : ' ');
+    toolinfo << (mSettings.severity.isEnabled(Severity::style) ? 's' : ' ');
+    toolinfo << (mSettings.severity.isEnabled(Severity::performance) ? 'p' : ' ');
+    toolinfo << (mSettings.severity.isEnabled(Severity::portability) ? 'p' : ' ');
+    toolinfo << (mSettings.severity.isEnabled(Severity::information) ? 'i' : ' ');
+    toolinfo << mSettings.userDefines;
+    toolinfo << (mSettings.checkConfiguration ? 'c' : ' '); // --check-config
+    toolinfo << (mSettings.force ? 'f' : ' ');
+    toolinfo << mSettings.maxConfigsOption;
+    toolinfo << std::to_string(static_cast<std::uint8_t>(mSettings.checkLevel));
+    for (const auto &a : mSettings.addonInfos) {
+        toolinfo << a.name;
+        toolinfo << a.args;
+    }
+    toolinfo << mSettings.premiumArgs;
+    // TODO: do we need to add more options?
+    mSuppressions.nomsg.dump(toolinfo, filePath);
+    return preprocessor.calculateHash(toolinfo.str());
+}
+
+unsigned int CppCheck::checkBuffer(const FileWithDetails &file, const std::string &cfgname, const char* data, std::size_t size)
+{
+    const auto f = [&file, data, size](std::vector<std::string>& files, simplecpp::OutputList* outputList) {
+        return simplecpp::TokenList{{data, size}, files, file.spath(), outputList};
+    };
+    return checkInternal(file, cfgname, f);
+}
+
+unsigned int CppCheck::checkFile(const FileWithDetails& file, const std::string &cfgname)
+{
+    const auto f = [&file](std::vector<std::string>& files, simplecpp::OutputList* outputList) {
+        return simplecpp::TokenList{file.spath(), files, outputList};
+    };
+    return checkInternal(file, cfgname, f);
 }
 
-unsigned int CppCheck::check(const ImportProject::FileSettings &fs)
+void CppCheck::checkPlistOutput(const FileWithDetails& file, const std::vector<std::string>& files)
 {
-    CppCheck temp(mErrorLogger, mUseGlobalSuppressions);
-    temp.mSettings = mSettings;
-    if (!temp.mSettings.userDefines.empty())
-        temp.mSettings.userDefines += ';';
-    temp.mSettings.userDefines += fs.cppcheckDefines();
-    temp.mSettings.includePaths = fs.includePaths;
-    temp.mSettings.userUndefs = fs.undefs;
-    if (fs.platformType != Settings::Unspecified) {
-        temp.mSettings.platform(fs.platformType);
-    }
-    std::ifstream fin(fs.filename);
-    return temp.checkFile(Path::simplifyPath(fs.filename), fs.cfg, fin);
+    if (!mSettings.plistOutput.empty()) {
+        const bool slashFound = file.spath().find('/') != std::string::npos;
+        std::string filename = slashFound ? file.spath().substr(file.spath().rfind('/') + 1) : file.spath();
+        // removes suffix from filename when it exists
+        const std::string noSuffixFilename = filename.substr(0, filename.find('.'));
+
+        // the hash is added to handle when files in different folders have the same name
+        const std::size_t fileNameHash = std::hash<std::string> {}(file.spath());
+        filename = mSettings.plistOutput + noSuffixFilename + "_" + std::to_string(fileNameHash) + ".plist";
+        mLogger->openPlist(filename, files);
+    }
 }
 
-unsigned int CppCheck::checkFile(const std::string& filename, const std::string &cfgname, std::istream& fileStream)
+unsigned int CppCheck::checkInternal(const FileWithDetails& file, const std::string &cfgname, const CreateTokenListFn& createTokenList)
 {
-    mExitCode = 0;
-    mSuppressInternalErrorFound = false;
+    // TODO: move to constructor when CppCheck no longer owns the settings
+    if (mSettings.checks.isEnabled(Checks::unusedFunction) && !mUnusedFunctionsCheck)
+        mUnusedFunctionsCheck.reset(new CheckUnusedFunctions());
 
-    // only show debug warnings for accepted C/C++ source files
-    if (!Path::acceptFile(filename))
-        mSettings.debugwarnings = false;
+    const int maxConfigs = mSettings.getMaxConfigs();
+
+    mLogger->resetExitCode();
 
     if (Settings::terminated())
-        return mExitCode;
+        return mLogger->exitcode();
+
+    const Timer fileTotalTimer{file.spath(), mSettings.showtime, nullptr, Timer::Type::FILE};
 
     if (!mSettings.quiet) {
-        std::string fixedpath = Path::simplifyPath(filename);
-        fixedpath = Path::toNativeSeparators(fixedpath);
-        mErrorLogger.reportOut(std::string("Checking ") + fixedpath + ' ' + cfgname + std::string("..."));
+        std::string fixedpath = Path::toNativeSeparators(file.spath());
+        mErrorLogger.reportOut(std::string("Checking ") + fixedpath + ' ' + cfgname + std::string("..."), Color::FgGreen);
 
         if (mSettings.verbose) {
-            mErrorLogger.reportOut("Defines:" + mSettings.userDefines);
+            mErrorLogger.reportOut("Defines:" + mSettings.userDefines, Color::Reset);
             std::string undefs;
             for (const std::string& U : mSettings.userUndefs) {
                 if (!undefs.empty())
                     undefs += ';';
                 undefs += ' ' + U;
             }
-            mErrorLogger.reportOut("Undefines:" + undefs);
+            mErrorLogger.reportOut("Undefines:" + undefs, Color::Reset);
             std::string includePaths;
             for (const std::string &I : mSettings.includePaths)
                 includePaths += " -I" + I;
-            mErrorLogger.reportOut("Includes:" + includePaths);
-            mErrorLogger.reportOut(std::string("Platform:") + mSettings.platformString());
+            mErrorLogger.reportOut("Includes:" + includePaths, Color::Reset);
+            mErrorLogger.reportOut(std::string("Platform:") + mSettings.platform.toString(), Color::Reset);
         }
     }
 
-    if (plistFile.is_open()) {
-        plistFile << ErrorLogger::plistFooter();
-        plistFile.close();
-    }
+    mLogger->closePlist();
 
-    CheckUnusedFunctions checkUnusedFunctions(nullptr, nullptr, nullptr);
+    std::unique_ptr<AnalyzerInformation> analyzerInformation;
 
     try {
-        Preprocessor preprocessor(mSettings, this);
-        std::set<std::string> configurations;
+        if (mSettings.library.markupFile(file.spath())) {
+            // TODO: if an exception occurs in this block it will continue in an unexpected code path
+            if (!mSettings.buildDir.empty())
+            {
+                analyzerInformation.reset(new AnalyzerInformation);
+                mLogger->setAnalyzerInfo(analyzerInformation.get());
+            }
 
-        simplecpp::OutputList outputList;
-        std::vector<std::string> files;
-        simplecpp::TokenList tokens1(fileStream, files, filename, &outputList);
-
-        // If there is a syntax error, report it and stop
-        for (const simplecpp::Output &output : outputList) {
-            bool err;
-            switch (output.type) {
-            case simplecpp::Output::ERROR:
-            case simplecpp::Output::INCLUDE_NESTED_TOO_DEEPLY:
-            case simplecpp::Output::SYNTAX_ERROR:
-            case simplecpp::Output::UNHANDLED_CHAR_ERROR:
-                err = true;
-                break;
-            case simplecpp::Output::WARNING:
-            case simplecpp::Output::MISSING_HEADER:
-            case simplecpp::Output::PORTABILITY_BACKSLASH:
-                err = false;
-                break;
-            };
-
-            if (err) {
-                const ErrorLogger::ErrorMessage::FileLocation loc1(output.location.file(), output.location.line, output.location.col);
-                std::list<ErrorLogger::ErrorMessage::FileLocation> callstack(1, loc1);
-
-                ErrorLogger::ErrorMessage errmsg(callstack,
-                                                 "",
-                                                 Severity::error,
-                                                 output.msg,
-                                                 "syntaxError",
-                                                 false);
-                reportErr(errmsg);
-                return mExitCode;
+            if (mUnusedFunctionsCheck && (mSettings.useSingleJob() || analyzerInformation)) {
+                std::size_t hash = 0;
+                // markup files are special and do not adhere to the enforced language
+                TokenList tokenlist{mSettings, Standards::Language::C};
+                std::vector<std::string> files;
+                simplecpp::TokenList tokens = createTokenList(files, nullptr);
+                if (analyzerInformation) {
+                    const Preprocessor preprocessor(tokens, mSettings, mErrorLogger, file.lang());
+                    hash = calculateHash(preprocessor);
+                }
+                tokenlist.createTokens(std::move(tokens));
+                // this is not a real source file - we just want to tokenize it. treat it as C anyways as the language needs to be determined.
+                Tokenizer tokenizer(std::move(tokenlist), mErrorLogger);
+                mUnusedFunctionsCheck->parseTokens(tokenizer, mSettings);
+
+                if (analyzerInformation) {
+                    mLogger->setAnalyzerInfo(nullptr);
+
+                    std::list<ErrorMessage> errors;
+                    analyzerInformation->analyzeFile(mSettings.buildDir, file.spath(), cfgname, file.fsFileId(), hash, errors, mSettings.debugainfo);
+                    analyzerInformation->setFileInfo("CheckUnusedFunctions", mUnusedFunctionsCheck->analyzerInfo(tokenizer));
+                    analyzerInformation->close();
+                }
             }
+            return EXIT_SUCCESS;
         }
 
-        preprocessor.loadFiles(tokens1, files);
+        simplecpp::OutputList outputList;
+        std::vector<std::string> files;
+        simplecpp::TokenList tokens1 = createTokenList(files, &outputList);
 
-        if (!mSettings.plistOutput.empty()) {
-            std::string filename2;
-            if (filename.find('/') != std::string::npos)
-                filename2 = filename.substr(filename.rfind('/') + 1);
-            else
-                filename2 = filename;
-            filename2 = mSettings.plistOutput + filename2.substr(0, filename2.find('.')) + ".plist";
-            plistFile.open(filename2);
-            plistFile << ErrorLogger::plistHeader(version(), files);
-        }
+        Preprocessor preprocessor(tokens1, mSettings, mErrorLogger, file.lang());
 
-        // write dump file xml prolog
-        std::ofstream fdump;
-        std::string dumpFile;
+        if (preprocessor.reportOutput(outputList, true))
+            return mLogger->exitcode();
+
+        if (!preprocessor.loadFiles(files))
+            return mLogger->exitcode();
+
+        checkPlistOutput(file, files);
+
+        std::string dumpProlog;
         if (mSettings.dump || !mSettings.addons.empty()) {
-            if (!mSettings.dumpFile.empty())
-                dumpFile = mSettings.dumpFile;
-            else if (!mSettings.dump && !mSettings.buildDir.empty())
-                dumpFile = AnalyzerInformation::getAnalyzerInfoFile(mSettings.buildDir, filename, "") + ".dump";
-            else
-                dumpFile = filename + ".dump";
-
-            fdump.open(dumpFile);
-            if (fdump.is_open()) {
-                fdump << "<?xml version=\"1.0\"?>" << std::endl;
-                fdump << "<dumps>" << std::endl;
-                fdump << "  <platform"
-                      << " name=\"" << mSettings.platformString() << '\"'
-                      << " char_bit=\"" << mSettings.char_bit << '\"'
-                      << " short_bit=\"" << mSettings.short_bit << '\"'
-                      << " int_bit=\"" << mSettings.int_bit << '\"'
-                      << " long_bit=\"" << mSettings.long_bit << '\"'
-                      << " long_long_bit=\"" << mSettings.long_long_bit << '\"'
-                      << " pointer_bit=\"" << (mSettings.sizeof_pointer * mSettings.char_bit) << '\"'
-                      << "/>\n";
-                fdump << "  <rawtokens>" << std::endl;
-                for (unsigned int i = 0; i < files.size(); ++i)
-                    fdump << "    <file index=\"" << i << "\" name=\"" << ErrorLogger::toxml(files[i]) << "\"/>" << std::endl;
-                for (const simplecpp::Token *tok = tokens1.cfront(); tok; tok = tok->next) {
-                    fdump << "    <tok "
-                          << "fileIndex=\"" << tok->location.fileIndex << "\" "
-                          << "linenr=\"" << tok->location.line << "\" "
-                          << "column=\"" << tok->location.col << "\" "
-                          << "str=\"" << ErrorLogger::toxml(tok->str()) << "\""
-                          << "/>" << std::endl;
-                }
-                fdump << "  </rawtokens>" << std::endl;
-            }
+            dumpProlog += getDumpFileContentsRawTokens(files, tokens1);
         }
 
         // Parse comments and then remove them
-        preprocessor.inlineSuppressions(tokens1);
-        if ((mSettings.dump || !mSettings.addons.empty()) && fdump.is_open()) {
-            mSettings.nomsg.dump(fdump);
+        mLogger->setRemarkComments(preprocessor.getRemarkComments());
+        preprocessor.inlineSuppressions(mSuppressions.nomsg);
+        if (mSettings.dump || !mSettings.addons.empty()) {
+            std::ostringstream oss;
+            mSuppressions.nomsg.dump(oss);
+            dumpProlog += oss.str();
         }
-        tokens1.removeComments();
         preprocessor.removeComments();
 
         if (!mSettings.buildDir.empty()) {
-            // Get toolinfo
-            std::ostringstream toolinfo;
-            toolinfo << CPPCHECK_VERSION_STRING;
-            toolinfo << (mSettings.isEnabled(Settings::WARNING) ? 'w' : ' ');
-            toolinfo << (mSettings.isEnabled(Settings::STYLE) ? 's' : ' ');
-            toolinfo << (mSettings.isEnabled(Settings::PERFORMANCE) ? 'p' : ' ');
-            toolinfo << (mSettings.isEnabled(Settings::PORTABILITY) ? 'p' : ' ');
-            toolinfo << (mSettings.isEnabled(Settings::INFORMATION) ? 'i' : ' ');
-            toolinfo << mSettings.userDefines;
-            mSettings.nomsg.dump(toolinfo);
-
-            // Calculate checksum so it can be compared with old checksum / future checksums
-            const unsigned int checksum = preprocessor.calculateChecksum(tokens1, toolinfo.str());
-            std::list<ErrorLogger::ErrorMessage> errors;
-            if (!mAnalyzerInformation.analyzeFile(mSettings.buildDir, filename, cfgname, checksum, &errors)) {
+            analyzerInformation.reset(new AnalyzerInformation);
+            mLogger->setAnalyzerInfo(analyzerInformation.get());
+        }
+
+        if (analyzerInformation) {
+            // Calculate hash so it can be compared with old hash / future hashes
+            const std::size_t hash = calculateHash(preprocessor, file.spath());
+            std::list<ErrorMessage> errors;
+            if (!analyzerInformation->analyzeFile(mSettings.buildDir, file.spath(), cfgname, file.fsFileId(), hash, errors, mSettings.debugainfo)) {
                 while (!errors.empty()) {
-                    reportErr(errors.front());
+                    mErrorLogger.reportErr(errors.front());
                     errors.pop_front();
                 }
-                return mExitCode;  // known results => no need to reanalyze file
+                mLogger->setAnalyzerInfo(nullptr);
+                return mLogger->exitcode();  // known results => no need to reanalyze file
             }
         }
 
         // Get directives
-        preprocessor.setDirectives(tokens1);
-        preprocessor.simplifyPragmaAsm(&tokens1);
+        std::list<Directive> directives = preprocessor.createDirectives();
+        preprocessor.simplifyPragmaAsm();
 
-        preprocessor.setPlatformInfo(&tokens1);
+        preprocessor.setPlatformInfo();
 
         // Get configurations..
-        if (mSettings.userDefines.empty() || mSettings.force) {
-            Timer t("Preprocessor::getConfigs", mSettings.showtime, &S_timerResults);
-            configurations = preprocessor.getConfigs(tokens1);
+        std::set<std::string> configurations;
+        if (maxConfigs > 1) {
+            Timer::run("Preprocessor::getConfigs", mSettings.showtime, mTimerResults, [&]() {
+                configurations = preprocessor.getConfigs();
+            });
         } else {
             configurations.insert(mSettings.userDefines);
         }
 
         if (mSettings.checkConfiguration) {
             for (const std::string &config : configurations)
-                (void)preprocessor.getcode(tokens1, config, files, true);
+                (void)preprocessor.getcode(config, files, false);
+
+            if (configurations.size() > maxConfigs)
+                tooManyConfigsError(Path::toNativeSeparators(file.spath()), configurations.size());
 
+            if (analyzerInformation)
+                mLogger->setAnalyzerInfo(nullptr);
             return 0;
         }
 
+#ifdef HAVE_RULES
         // Run define rules on raw code
-        for (const Settings::Rule &rule : mSettings.rules) {
-            if (rule.tokenlist != "define")
-                continue;
-
+        if (hasRule("define")) {
             std::string code;
-            const std::list<Directive> &directives = preprocessor.getDirectives();
             for (const Directive &dir : directives) {
-                if (dir.str.compare(0,8,"#define ") == 0)
-                    code += "#line " + MathLib::toString(dir.linenr) + " \"" + dir.file + "\"\n" + dir.str + '\n';
+                if (startsWith(dir.str,"#define ") || startsWith(dir.str,"#include "))
+                    code += "#line " + std::to_string(dir.linenr) + " \"" + dir.file + "\"\n" + dir.str + '\n';
             }
-            Tokenizer tokenizer2(&mSettings, this);
-            std::istringstream istr2(code);
-            tokenizer2.list.createTokens(istr2);
-            executeRules("define", tokenizer2);
-            break;
+            TokenList tokenlist(mSettings, file.lang());
+            tokenlist.createTokensFromBuffer(code.data(), code.size()); // TODO: check result?
+            executeRules("define", tokenlist);
         }
+#endif
 
-        if (!mSettings.force && configurations.size() > mSettings.maxConfigs) {
-            if (mSettings.isEnabled(Settings::INFORMATION)) {
-                tooManyConfigsError(Path::toNativeSeparators(filename),configurations.size());
-            } else {
-                mTooManyConfigs = true;
-            }
+        FilesDeleter filesDeleter;
+
+        // write dump file xml prolog
+        std::ofstream fdump;
+        std::string dumpFile;
+        createDumpFile(mSettings, file, fdump, dumpFile);
+        if (fdump.is_open()) {
+            fdump << getLibraryDumpData();
+            fdump << dumpProlog;
+            if (!mSettings.dump)
+                filesDeleter.addFile(dumpFile);
         }
 
-        std::set<unsigned long long> checksums;
-        unsigned int checkCount = 0;
+        std::set<unsigned long long> hashes;
+        int checkCount = 0;
         bool hasValidConfig = false;
         std::list<std::string> configurationError;
         for (const std::string &currCfg : configurations) {
@@ -437,27 +1100,39 @@ unsigned int CppCheck::checkFile(const std::string& filename, const std::string
 
             // Check only a few configurations (default 12), after that bail out, unless --force
             // was used.
-            if (!mSettings.force && ++checkCount > mSettings.maxConfigs)
+            if (!mSettings.force && ++checkCount > maxConfigs) {
+                // If maxConfigs is not assigned then report information message that configurations are skipped.
+                // If maxConfigs is assigned then the user is explicitly skipping configurations so
+                // the information message is not reported, the whole purpose of setting i.e. --max-configs=1 is to
+                // skip configurations. When --check-config is used then tooManyConfigs will be reported even if the
+                // value is non-default.
+                if (!mSettings.isMaxConfigsAssigned() && mSettings.severity.isEnabled(Severity::information))
+                    tooManyConfigsError(Path::toNativeSeparators(file.spath()), configurations.size());
+
                 break;
+            }
+
+            std::string currentConfig;
 
             if (!mSettings.userDefines.empty()) {
-                mCurrentConfig = mSettings.userDefines;
+                currentConfig = mSettings.userDefines;
                 const std::vector<std::string> v1(split(mSettings.userDefines, ";"));
                 for (const std::string &cfg: split(currCfg, ";")) {
-                    if (std::find(v1.begin(), v1.end(), cfg) == v1.end()) {
-                        mCurrentConfig += ";" + cfg;
+                    if (std::find(v1.cbegin(), v1.cend(), cfg) == v1.cend()) {
+                        currentConfig += ";" + cfg;
                     }
                 }
             } else {
-                mCurrentConfig = currCfg;
+                currentConfig = currCfg;
             }
 
             if (mSettings.preprocessOnly) {
-                Timer t("Preprocessor::getcode", mSettings.showtime, &S_timerResults);
-                std::string codeWithoutCfg = preprocessor.getcode(tokens1, mCurrentConfig, files, true);
-                t.Stop();
+                std::string codeWithoutCfg;
+                Timer::run("Preprocessor::getcode", mSettings.showtime, mTimerResults, [&]() {
+                    codeWithoutCfg = preprocessor.getcode(currentConfig, files, true);
+                });
 
-                if (codeWithoutCfg.compare(0,5,"#file") == 0)
+                if (startsWith(codeWithoutCfg,"#file"))
                     codeWithoutCfg.insert(0U, "//");
                 std::string::size_type pos = 0;
                 while ((pos = codeWithoutCfg.find("\n#file",pos)) != std::string::npos)
@@ -468,804 +1143,791 @@ unsigned int CppCheck::checkFile(const std::string& filename, const std::string
                 pos = 0;
                 while ((pos = codeWithoutCfg.find(Preprocessor::macroChar,pos)) != std::string::npos)
                     codeWithoutCfg[pos] = ' ';
-                reportOut(codeWithoutCfg);
+                mErrorLogger.reportOut(codeWithoutCfg, Color::Reset);
                 continue;
             }
 
-            Tokenizer mTokenizer(&mSettings, this);
-            if (mSettings.showtime != SHOWTIME_MODES::SHOWTIME_NONE)
-                mTokenizer.setTimerResults(&S_timerResults);
+            TokenList tokenlist{mSettings, file.lang()};
+
+            {
+                bool skipCfg = false;
+                // Create tokens, skip rest of iteration if failed
+                Timer::run("Tokenizer::createTokens", mSettings.showtime, mTimerResults, [&]() {
+                    simplecpp::OutputList outputList_cfg;
+                    simplecpp::TokenList tokensP = preprocessor.preprocess(currentConfig, files, outputList_cfg);
+                    const simplecpp::Output* o = preprocessor.handleErrors(outputList_cfg);
+                    if (!o) {
+                        tokenlist.createTokens(std::move(tokensP));
+                    }
+                    else {
+                        // #error etc during preprocessing
+                        configurationError.push_back((currentConfig.empty() ? "\'\'" : currentConfig) + " : [" + tokensP.file(o->location) + ':' + std::to_string(o->location.line) + "] " + o->msg);
+                        --checkCount; // don't count invalid configurations
+
+                        if (!hasValidConfig && currCfg == *configurations.rbegin()) {
+                            // If there is no valid configuration then report error..
+                            preprocessor.error(o->location, o->msg, o->type);
+                        }
+                        skipCfg = true;
+                    }
+                });
+                if (skipCfg)
+                    continue;
+            }
+            hasValidConfig = true;
 
+            Tokenizer tokenizer(std::move(tokenlist), mErrorLogger);
             try {
-                bool result;
+                if (mSettings.showtime != ShowTime::NONE)
+                    tokenizer.setTimerResults(mTimerResults);
+                tokenizer.setDirectives(directives); // TODO: how to avoid repeated copies?
 
-                // Create tokens, skip rest of iteration if failed
-                Timer timer("Tokenizer::createTokens", mSettings.showtime, &S_timerResults);
-                const simplecpp::TokenList &tokensP = preprocessor.preprocess(tokens1, mCurrentConfig, files, true);
-                mTokenizer.createTokens(&tokensP);
-                timer.Stop();
-                hasValidConfig = true;
+                // locations macros
+                mLogger->setLocationMacros(tokenizer.tokens(), files);
 
                 // If only errors are printed, print filename after the check
-                if (!mSettings.quiet && (!mCurrentConfig.empty() || checkCount > 1)) {
-                    std::string fixedpath = Path::simplifyPath(filename);
-                    fixedpath = Path::toNativeSeparators(fixedpath);
-                    mErrorLogger.reportOut("Checking " + fixedpath + ": " + mCurrentConfig + "...");
+                if (!mSettings.quiet && (!currentConfig.empty() || checkCount > 1)) {
+                    std::string fixedpath = Path::toNativeSeparators(file.spath());
+                    mErrorLogger.reportOut("Checking " + fixedpath + ": " + currentConfig + "...", Color::FgGreen);
                 }
 
-                if (tokensP.empty())
+                if (!tokenizer.tokens())
                     continue;
 
                 // skip rest of iteration if just checking configuration
                 if (mSettings.checkConfiguration)
                     continue;
 
-                // Check raw tokens
-                checkRawTokens(mTokenizer);
+#ifdef HAVE_RULES
+                // Execute rules for "raw" code
+                executeRules("raw", tokenizer.list);
+#endif
 
                 // Simplify tokens into normal form, skip rest of iteration if failed
-                Timer timer2("Tokenizer::simplifyTokens1", mSettings.showtime, &S_timerResults);
-                result = mTokenizer.simplifyTokens1(mCurrentConfig);
-                timer2.Stop();
-                if (!result)
+                if (!tokenizer.simplifyTokens1(currentConfig, file.fsFileId()))
                     continue;
 
                 // dump xml if --dump
                 if ((mSettings.dump || !mSettings.addons.empty()) && fdump.is_open()) {
-                    fdump << "<dump cfg=\"" << ErrorLogger::toxml(mCurrentConfig) << "\">" << std::endl;
+                    fdump << "<dump cfg=\"" << ErrorLogger::toxml(currentConfig) << "\">" << std::endl;
                     fdump << "  <standards>" << std::endl;
                     fdump << "    <c version=\"" << mSettings.standards.getC() << "\"/>" << std::endl;
                     fdump << "    <cpp version=\"" << mSettings.standards.getCPP() << "\"/>" << std::endl;
                     fdump << "  </standards>" << std::endl;
+                    fdump << getLibraryDumpData();
                     preprocessor.dump(fdump);
-                    mTokenizer.dump(fdump);
+                    tokenizer.dump(fdump);
                     fdump << "</dump>" << std::endl;
                 }
 
+                if (mSettings.inlineSuppressions) {
+                    // Need to call this even if the hash will skip this configuration
+                    mSuppressions.nomsg.markUnmatchedInlineSuppressionsAsChecked(tokenizer);
+                }
+
                 // Skip if we already met the same simplified token list
-                if (mSettings.force || mSettings.maxConfigs > 1) {
-                    const unsigned long long checksum = mTokenizer.list.calculateChecksum();
-                    if (checksums.find(checksum) != checksums.end()) {
+                if (maxConfigs > 1) {
+                    const std::size_t hash = tokenizer.list.calculateHash();
+                    if (hashes.find(hash) != hashes.end()) {
                         if (mSettings.debugwarnings)
-                            purgedConfigurationMessage(filename, mCurrentConfig);
+                            purgedConfigurationMessage(file.spath(), currentConfig);
                         continue;
                     }
-                    checksums.insert(checksum);
+                    hashes.insert(hash);
                 }
 
                 // Check normal tokens
-                checkNormalTokens(mTokenizer);
-
-                // Analyze info..
-                if (!mSettings.buildDir.empty())
-                    checkUnusedFunctions.parseTokens(mTokenizer, filename.c_str(), &mSettings);
-
-                // simplify more if required, skip rest of iteration if failed
-                if (mSimplify && hasRule("simple")) {
-                    // if further simplification fails then skip rest of iteration
-                    Timer timer3("Tokenizer::simplifyTokenList2", mSettings.showtime, &S_timerResults);
-                    result = mTokenizer.simplifyTokenList2();
-                    timer3.Stop();
-                    if (!result)
-                        continue;
-
-                    if (!Settings::terminated())
-                        executeRules("simple", mTokenizer);
-                }
-
-            } catch (const simplecpp::Output &o) {
-                // #error etc during preprocessing
-                configurationError.push_back((mCurrentConfig.empty() ? "\'\'" : mCurrentConfig) + " : [" + o.location.file() + ':' + MathLib::toString(o.location.line) + "] " + o.msg);
-                --checkCount; // don't count invalid configurations
-                continue;
-
+                checkNormalTokens(tokenizer, analyzerInformation.get(), currentConfig);
             } catch (const InternalError &e) {
-                std::list<ErrorLogger::ErrorMessage::FileLocation> locationList;
-                if (e.token) {
-                    ErrorLogger::ErrorMessage::FileLocation loc(e.token, &mTokenizer.list);
-                    locationList.push_back(loc);
-                } else {
-                    ErrorLogger::ErrorMessage::FileLocation loc(mTokenizer.list.getSourceFilePath(), 0, 0);
-                    ErrorLogger::ErrorMessage::FileLocation loc2(filename, 0, 0);
-                    locationList.push_back(loc2);
-                    locationList.push_back(loc);
-                }
-                ErrorLogger::ErrorMessage errmsg(locationList,
-                                                 mTokenizer.list.getSourceFilePath(),
-                                                 Severity::error,
-                                                 e.errorMessage,
-                                                 e.id,
-                                                 false);
-
-                if (errmsg.severity == Severity::error || mSettings.isEnabled(errmsg.severity))
-                    reportErr(errmsg);
+                ErrorMessage errmsg = ErrorMessage::fromInternalError(e, &tokenizer.list, file.spath());
+                mErrorLogger.reportErr(errmsg);
             }
         }
 
-        if (!hasValidConfig && configurations.size() > 1 && mSettings.isEnabled(Settings::INFORMATION)) {
+        if (!hasValidConfig && configurations.size() > 1 && mSettings.severity.isEnabled(Severity::information)) {
             std::string msg;
-            msg = "This file is not analyzed. Cppcheck failed to extract a valid configuration. Use -v for more details.";
-            msg += "\nThis file is not analyzed. Cppcheck failed to extract a valid configuration. The tested configurations have these preprocessor errors:";
+            msg = "This file is not analyzed. No working configuration could be extracted. Use -v for more details.";
+            msg += "\nThis file is not analyzed. No working configuration could be extracted. The tested configurations have these preprocessor errors:";
             for (const std::string &s : configurationError)
                 msg += '\n' + s;
 
-            std::list<ErrorLogger::ErrorMessage::FileLocation> locationList;
-            ErrorLogger::ErrorMessage::FileLocation loc;
-            loc.setfile(Path::toNativeSeparators(filename));
-            locationList.push_back(loc);
-            ErrorLogger::ErrorMessage errmsg(locationList,
-                                             loc.getfile(),
-                                             Severity::information,
-                                             msg,
-                                             "noValidConfiguration",
-                                             false);
-            reportErr(errmsg);
+            std::string locFile = Path::toNativeSeparators(file.spath());
+            ErrorMessage::FileLocation loc(locFile, 0, 0);
+            ErrorMessage errmsg({std::move(loc)},
+                                std::move(locFile),
+                                Severity::information,
+                                msg,
+                                "noValidConfiguration",
+                                Certainty::normal);
+            mErrorLogger.reportErr(errmsg);
         }
 
+        // TODO: will not be closed if we encountered an exception
         // dumped all configs, close root </dumps> element now
-        if ((mSettings.dump || !mSettings.addons.empty()) && fdump.is_open())
+        if (fdump.is_open()) {
             fdump << "</dumps>" << std::endl;
-
-        if (!mSettings.addons.empty()) {
             fdump.close();
-
-            for (const std::string &addon : mSettings.addons) {
-                struct AddonInfo addonInfo;
-                const std::string &failedToGetAddonInfo = addonInfo.getAddonInfo(addon, mSettings.exename);
-                if (!failedToGetAddonInfo.empty()) {
-                    reportOut(failedToGetAddonInfo);
-                    continue;
-                }
-                const std::string results = executeAddon(addonInfo, dumpFile);
-                std::istringstream istr(results);
-                std::string line;
-
-                while (std::getline(istr, line)) {
-                    if (line.compare(0,1,"{") != 0)
-                        continue;
-
-                    picojson::value res;
-                    std::istringstream istr2(line);
-                    istr2 >> res;
-                    if (!res.is<picojson::object>())
-                        continue;
-
-                    picojson::object obj = res.get<picojson::object>();
-
-                    const std::string fileName = obj["file"].get<std::string>();
-                    const int64_t lineNumber = obj["linenr"].get<int64_t>();
-                    const int64_t column = obj["column"].get<int64_t>();
-
-                    ErrorLogger::ErrorMessage errmsg;
-
-                    errmsg.callStack.emplace_back(ErrorLogger::ErrorMessage::FileLocation(fileName, lineNumber, column));
-
-                    errmsg.id = obj["addon"].get<std::string>() + "-" + obj["errorId"].get<std::string>();
-                    const std::string text = obj["message"].get<std::string>();
-                    errmsg.setmsg(text);
-                    const std::string severity = obj["severity"].get<std::string>();
-                    errmsg.severity = Severity::fromString(severity);
-                    if (errmsg.severity == Severity::SeverityType::none)
-                        continue;
-                    errmsg.file0 = fileName;
-
-                    reportErr(errmsg);
-                }
-            }
         }
 
+        executeAddons(dumpFile, file);
+    } catch (const TerminateException &) {
+        // Analysis is terminated
+        if (analyzerInformation)
+            mLogger->setAnalyzerInfo(nullptr);
+        return mLogger->exitcode();
     } catch (const std::runtime_error &e) {
-        internalError(filename, e.what());
-    } catch (const std::bad_alloc &e) {
-        internalError(filename, e.what());
+        internalError(file.spath(), std::string("Checking file failed: ") + e.what());
+    } catch (const std::bad_alloc &) {
+        internalError(file.spath(), "Checking file failed: out of memory");
     } catch (const InternalError &e) {
-        internalError(filename, e.errorMessage);
-        mExitCode=1; // e.g. reflect a syntax error
+        const ErrorMessage errmsg = ErrorMessage::fromInternalError(e, nullptr, file.spath(), "Bailing out from analysis: Checking file failed");
+        mErrorLogger.reportErr(errmsg);
     }
 
-    mAnalyzerInformation.setFileInfo("CheckUnusedFunctions", checkUnusedFunctions.analyzerInfo());
-    mAnalyzerInformation.close();
-
-    // In jointSuppressionReport mode, unmatched suppressions are
-    // collected after all files are processed
-    if (!mSettings.jointSuppressionReport && (mSettings.isEnabled(Settings::INFORMATION) || mSettings.checkConfiguration)) {
-        reportUnmatchedSuppressions(mSettings.nomsg.getUnmatchedLocalSuppressions(filename, isUnusedFunctionCheckEnabled()));
+    if (analyzerInformation) {
+        mLogger->setAnalyzerInfo(nullptr);
+        analyzerInformation.reset();
     }
 
-    mErrorList.clear();
+    // TODO: clear earlier?
+    mLogger->clear();
 
-    return mExitCode;
+    if (mTimerResults && (mSettings.showtime == ShowTime::FILE || mSettings.showtime == ShowTime::TOP5_FILE))
+        mTimerResults->showResults(mSettings.showtime);
+
+    return mLogger->exitcode();
 }
 
+// TODO: replace with ErrorMessage::fromInternalError()
 void CppCheck::internalError(const std::string &filename, const std::string &msg)
 {
-    const std::string fixedpath = Path::toNativeSeparators(filename);
-    const std::string fullmsg("Bailing out from checking " + fixedpath + " since there was an internal error: " + msg);
-
-    if (mSettings.isEnabled(Settings::INFORMATION)) {
-        const ErrorLogger::ErrorMessage::FileLocation loc1(filename, 0, 0);
-        std::list<ErrorLogger::ErrorMessage::FileLocation> callstack(1, loc1);
+    const std::string fullmsg("Bailing out from analysis: " + msg);
 
-        ErrorLogger::ErrorMessage errmsg(callstack,
-                                         emptyString,
-                                         Severity::information,
-                                         fullmsg,
-                                         "internalError",
-                                         false);
+    ErrorMessage::FileLocation loc1(filename, 0, 0);
 
-        mErrorLogger.reportErr(errmsg);
-    } else {
-        // Report on stdout
-        mErrorLogger.reportOut(fullmsg);
-    }
-}
+    ErrorMessage errmsg({std::move(loc1)},
+                        "",
+                        Severity::error,
+                        fullmsg,
+                        "internalError",
+                        Certainty::normal);
 
-//---------------------------------------------------------------------------
-// CppCheck - A function that checks a raw token list
-//---------------------------------------------------------------------------
-void CppCheck::checkRawTokens(const Tokenizer &tokenizer)
-{
-    // Execute rules for "raw" code
-    executeRules("raw", tokenizer);
+    mErrorLogger.reportErr(errmsg);
 }
 
 //---------------------------------------------------------------------------
 // CppCheck - A function that checks a normal token list
 //---------------------------------------------------------------------------
 
-void CppCheck::checkNormalTokens(const Tokenizer &tokenizer)
+void CppCheck::checkNormalTokens(const Tokenizer &tokenizer, AnalyzerInformation* analyzerInformation, const std::string& currentConfig)
 {
-    // call all "runChecks" in all registered Check classes
-    for (Check *check : Check::instances()) {
-        if (Settings::terminated())
-            return;
+    const ProgressReporter progressReporter(mErrorLogger, mSettings.reportProgress, tokenizer.list.getSourceFilePath(), "Run checkers");
 
-        if (Tokenizer::isMaxTime())
-            return;
+    CheckUnusedFunctions unusedFunctionsChecker;
 
-        Timer timerRunChecks(check->name() + "::runChecks", mSettings.showtime, &S_timerResults);
-        check->runChecks(&tokenizer, &mSettings, this);
-    }
+    // TODO: this should actually be the behavior if only "--enable=unusedFunction" is specified - see #10648
+    // TODO: log message when this is active?
+    const bool doUnusedFunctionOnly = Settings::unusedFunctionOnly();
+
+    if (!doUnusedFunctionOnly) {
+        const std::time_t maxTime = mSettings.checksMaxTime > 0 ? std::time(nullptr) + mSettings.checksMaxTime : 0;
+
+        // call all "runChecks" in all registered Check classes
+        // cppcheck-suppress shadowFunction - TODO: fix this
+        for (Check *check : Check::instances()) {
+            if (Settings::terminated())
+                return;
+
+            if (maxTime > 0 && std::time(nullptr) > maxTime) {
+                if (mSettings.debugwarnings) {
+                    ErrorMessage::FileLocation loc(tokenizer.list.getFiles()[0], 0, 0);
+                    ErrorMessage errmsg({std::move(loc)},
+                                        "",
+                                        Severity::debug,
+                                        "Checks maximum time exceeded",
+                                        "checksMaxTime",
+                                        Certainty::normal);
+                    mErrorLogger.reportErr(errmsg);
+                }
+                return;
+            }
 
-    // Verification using ExprEngine..
-    if (mSettings.verification) {
-        ExprEngine::runChecks(this, &tokenizer, &mSettings);
+            Timer::run(check->name() + "::runChecks", mSettings.showtime, mTimerResults, [&]() {
+                check->runChecks(tokenizer, &mErrorLogger);
+            });
+        }
     }
 
-    // Analyse the tokens..
+    if (mSettings.checks.isEnabled(Checks::unusedFunction) && !mSettings.buildDir.empty()) {
+        unusedFunctionsChecker.parseTokens(tokenizer, mSettings);
+    }
+    if (mUnusedFunctionsCheck && mSettings.useSingleJob() && mSettings.buildDir.empty()) {
+        mUnusedFunctionsCheck->parseTokens(tokenizer, mSettings);
+    }
 
-    CTU::FileInfo *fi1 = CTU::getFileInfo(&tokenizer);
-    if (fi1) {
-        mFileInfo.push_back(fi1);
-        mAnalyzerInformation.setFileInfo("ctu", fi1->toString());
+    if (mSettings.clang) {
+        // TODO: Use CTU for Clang analysis
+        return;
     }
 
-    for (const Check *check : Check::instances()) {
-        Check::FileInfo *fi = check->getFileInfo(&tokenizer, &mSettings);
-        if (fi != nullptr) {
-            mFileInfo.push_back(fi);
-            mAnalyzerInformation.setFileInfo(check->name(), fi->toString());
+    if (mSettings.useSingleJob() || analyzerInformation) {
+        // Analyse the tokens..
+        {
+            CTU::FileInfo * const fi1 = CTU::getFileInfo(tokenizer);
+            if (analyzerInformation)
+                analyzerInformation->setFileInfo("ctu", fi1->toString());
+            if (mSettings.useSingleJob())
+                mFileInfo.push_back(fi1);
+            else
+                delete fi1;
         }
-    }
 
-    executeRules("normal", tokenizer);
-}
+        if (!doUnusedFunctionOnly) {
+            // cppcheck-suppress shadowFunction - TODO: fix this
+            for (const Check *check : Check::instances()) {
+                if (Check::FileInfo * const fi = check->getFileInfo(tokenizer, mSettings, currentConfig)) {
+                    if (analyzerInformation)
+                        analyzerInformation->setFileInfo(check->name(), fi->toString());
+                    if (mSettings.useSingleJob())
+                        mFileInfo.push_back(fi);
+                    else
+                        delete fi;
+                }
+            }
+        }
+    }
 
-//---------------------------------------------------------------------------
+    if (mSettings.checks.isEnabled(Checks::unusedFunction) && analyzerInformation) {
+        analyzerInformation->setFileInfo("CheckUnusedFunctions", unusedFunctionsChecker.analyzerInfo(tokenizer));
+    }
 
-bool CppCheck::hasRule(const std::string &tokenlist) const
-{
 #ifdef HAVE_RULES
-    for (const Settings::Rule &rule : mSettings.rules) {
-        if (rule.tokenlist == tokenlist)
-            return true;
-    }
-#else
-    (void)tokenlist;
+    executeRules("normal", tokenizer.list);
 #endif
-    return false;
 }
 
+//---------------------------------------------------------------------------
 
 #ifdef HAVE_RULES
-
-static const char * pcreErrorCodeToString(const int pcreExecRet)
+bool CppCheck::hasRule(const std::string &tokenlist) const
 {
-    switch (pcreExecRet) {
-    case PCRE_ERROR_NULL:
-        return "Either code or subject was passed as NULL, or ovector was NULL "
-               "and ovecsize was not zero (PCRE_ERROR_NULL)";
-    case PCRE_ERROR_BADOPTION:
-        return "An unrecognized bit was set in the options argument (PCRE_ERROR_BADOPTION)";
-    case PCRE_ERROR_BADMAGIC:
-        return "PCRE stores a 4-byte \"magic number\" at the start of the compiled code, "
-               "to catch the case when it is passed a junk pointer and to detect when a "
-               "pattern that was compiled in an environment of one endianness is run in "
-               "an environment with the other endianness. This is the error that PCRE "
-               "gives when the magic number is not present (PCRE_ERROR_BADMAGIC)";
-    case PCRE_ERROR_UNKNOWN_NODE:
-        return "While running the pattern match, an unknown item was encountered in the "
-               "compiled pattern. This error could be caused by a bug in PCRE or by "
-               "overwriting of the compiled pattern (PCRE_ERROR_UNKNOWN_NODE)";
-    case PCRE_ERROR_NOMEMORY:
-        return "If a pattern contains back references, but the ovector that is passed "
-               "to pcre_exec() is not big enough to remember the referenced substrings, "
-               "PCRE gets a block of memory at the start of matching to use for this purpose. "
-               "If the call via pcre_malloc() fails, this error is given. The memory is "
-               "automatically freed at the end of matching. This error is also given if "
-               "pcre_stack_malloc() fails in pcre_exec(). "
-               "This can happen only when PCRE has been compiled with "
-               "--disable-stack-for-recursion (PCRE_ERROR_NOMEMORY)";
-    case PCRE_ERROR_NOSUBSTRING:
-        return "This error is used by the pcre_copy_substring(), pcre_get_substring(), "
-               "and pcre_get_substring_list() functions (see below). "
-               "It is never returned by pcre_exec() (PCRE_ERROR_NOSUBSTRING)";
-    case PCRE_ERROR_MATCHLIMIT:
-        return "The backtracking limit, as specified by the match_limit field in a pcre_extra "
-               "structure (or defaulted) was reached. "
-               "See the description above (PCRE_ERROR_MATCHLIMIT)";
-    case PCRE_ERROR_CALLOUT:
-        return "This error is never generated by pcre_exec() itself. "
-               "It is provided for use by callout functions that want to yield a distinctive "
-               "error code. See the pcrecallout documentation for details (PCRE_ERROR_CALLOUT)";
-    case PCRE_ERROR_BADUTF8:
-        return "A string that contains an invalid UTF-8 byte sequence was passed as a subject, "
-               "and the PCRE_NO_UTF8_CHECK option was not set. If the size of the output vector "
-               "(ovecsize) is at least 2, the byte offset to the start of the the invalid UTF-8 "
-               "character is placed in the first element, and a reason code is placed in the "
-               "second element. The reason codes are listed in the following section. For "
-               "backward compatibility, if PCRE_PARTIAL_HARD is set and the problem is a truncated "
-               "UTF-8 character at the end of the subject (reason codes 1 to 5), "
-               "PCRE_ERROR_SHORTUTF8 is returned instead of PCRE_ERROR_BADUTF8";
-    case PCRE_ERROR_BADUTF8_OFFSET:
-        return "The UTF-8 byte sequence that was passed as a subject was checked and found to "
-               "be valid (the PCRE_NO_UTF8_CHECK option was not set), but the value of "
-               "startoffset did not point to the beginning of a UTF-8 character or the end of "
-               "the subject (PCRE_ERROR_BADUTF8_OFFSET)";
-    case PCRE_ERROR_PARTIAL:
-        return "The subject string did not match, but it did match partially. See the "
-               "pcrepartial documentation for details of partial matching (PCRE_ERROR_PARTIAL)";
-    case PCRE_ERROR_BADPARTIAL:
-        return "This code is no longer in use. It was formerly returned when the PCRE_PARTIAL "
-               "option was used with a compiled pattern containing items that were not supported "
-               "for partial matching. From release 8.00 onwards, there are no restrictions on "
-               "partial matching (PCRE_ERROR_BADPARTIAL)";
-    case PCRE_ERROR_INTERNAL:
-        return "An unexpected internal error has occurred. This error could be caused by a bug "
-               "in PCRE or by overwriting of the compiled pattern (PCRE_ERROR_INTERNAL)";
-    case PCRE_ERROR_BADCOUNT:
-        return"This error is given if the value of the ovecsize argument is negative "
-              "(PCRE_ERROR_BADCOUNT)";
-    case PCRE_ERROR_RECURSIONLIMIT :
-        return "The internal recursion limit, as specified by the match_limit_recursion "
-               "field in a pcre_extra structure (or defaulted) was reached. "
-               "See the description above (PCRE_ERROR_RECURSIONLIMIT)";
-    case PCRE_ERROR_DFA_UITEM:
-        return "PCRE_ERROR_DFA_UITEM";
-    case PCRE_ERROR_DFA_UCOND:
-        return "PCRE_ERROR_DFA_UCOND";
-    case PCRE_ERROR_DFA_WSSIZE:
-        return "PCRE_ERROR_DFA_WSSIZE";
-    case PCRE_ERROR_DFA_RECURSE:
-        return "PCRE_ERROR_DFA_RECURSE";
-    case PCRE_ERROR_NULLWSLIMIT:
-        return "PCRE_ERROR_NULLWSLIMIT";
-    case PCRE_ERROR_BADNEWLINE:
-        return "An invalid combination of PCRE_NEWLINE_xxx options was "
-               "given (PCRE_ERROR_BADNEWLINE)";
-    case PCRE_ERROR_BADOFFSET:
-        return "The value of startoffset was negative or greater than the length "
-               "of the subject, that is, the value in length (PCRE_ERROR_BADOFFSET)";
-    case PCRE_ERROR_SHORTUTF8:
-        return "This error is returned instead of PCRE_ERROR_BADUTF8 when the subject "
-               "string ends with a truncated UTF-8 character and the PCRE_PARTIAL_HARD option is set. "
-               "Information about the failure is returned as for PCRE_ERROR_BADUTF8. "
-               "It is in fact sufficient to detect this case, but this special error code for "
-               "PCRE_PARTIAL_HARD precedes the implementation of returned information; "
-               "it is retained for backwards compatibility (PCRE_ERROR_SHORTUTF8)";
-    case PCRE_ERROR_RECURSELOOP:
-        return "This error is returned when pcre_exec() detects a recursion loop "
-               "within the pattern. Specifically, it means that either the whole pattern "
-               "or a subpattern has been called recursively for the second time at the same "
-               "position in the subject string. Some simple patterns that might do this "
-               "are detected and faulted at compile time, but more complicated cases, "
-               "in particular mutual recursions between two different subpatterns, "
-               "cannot be detected until run time (PCRE_ERROR_RECURSELOOP)";
-    case PCRE_ERROR_JIT_STACKLIMIT:
-        return "This error is returned when a pattern that was successfully studied "
-               "using a JIT compile option is being matched, but the memory available "
-               "for the just-in-time processing stack is not large enough. See the pcrejit "
-               "documentation for more details (PCRE_ERROR_JIT_STACKLIMIT)";
-    case PCRE_ERROR_BADMODE:
-        return "This error is given if a pattern that was compiled by the 8-bit library "
-               "is passed to a 16-bit or 32-bit library function, or vice versa (PCRE_ERROR_BADMODE)";
-    case PCRE_ERROR_BADENDIANNESS:
-        return "This error is given if a pattern that was compiled and saved is reloaded on a "
-               "host with different endianness. The utility function pcre_pattern_to_host_byte_order() "
-               "can be used to convert such a pattern so that it runs on the new host (PCRE_ERROR_BADENDIANNESS)";
-    case PCRE_ERROR_DFA_BADRESTART:
-        return "PCRE_ERROR_DFA_BADRESTART";
-#if PCRE_MAJOR >= 8 && PCRE_MINOR >= 32
-    case PCRE_ERROR_BADLENGTH:
-        return "This error is given if pcre_exec() is called with a negative value for the length argument (PCRE_ERROR_BADLENGTH)";
-    case PCRE_ERROR_JIT_BADOPTION:
-        return "This error is returned when a pattern that was successfully studied using a JIT compile "
-               "option is being matched, but the matching mode (partial or complete match) does not correspond "
-               "to any JIT compilation mode. When the JIT fast path function is used, this error may be "
-               "also given for invalid options. See the pcrejit documentation for more details (PCRE_ERROR_JIT_BADOPTION)";
-#endif
-    }
-    return "";
+    return std::any_of(mSettings.rules.cbegin(), mSettings.rules.cend(), [&](const Settings::Rule& rule) {
+        return rule.tokenlist == tokenlist;
+    });
 }
 
-#endif // HAVE_RULES
-
-
-void CppCheck::executeRules(const std::string &tokenlist, const Tokenizer &tokenizer)
+void CppCheck::executeRules(const std::string &tokenlist, const TokenList &list)
 {
-    (void)tokenlist;
-    (void)tokenizer;
-
-#ifdef HAVE_RULES
     // There is no rule to execute
     if (!hasRule(tokenlist))
         return;
 
     // Write all tokens in a string that can be parsed by pcre
-    std::ostringstream ostr;
-    for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next())
-        ostr << " " << tok->str();
-    const std::string str(ostr.str());
+    std::string str;
+    for (const Token *tok = list.front(); tok; tok = tok->next()) {
+        str += " ";
+        str += tok->str();
+    }
 
     for (const Settings::Rule &rule : mSettings.rules) {
-        if (rule.pattern.empty() || rule.id.empty() || rule.severity == Severity::none || rule.tokenlist != tokenlist)
-            continue;
-
-        const char *pcreCompileErrorStr = nullptr;
-        int erroffset = 0;
-        pcre * const re = pcre_compile(rule.pattern.c_str(),0,&pcreCompileErrorStr,&erroffset,nullptr);
-        if (!re) {
-            if (pcreCompileErrorStr) {
-                const std::string msg = "pcre_compile failed: " + std::string(pcreCompileErrorStr);
-                const ErrorLogger::ErrorMessage errmsg(std::list<ErrorLogger::ErrorMessage::FileLocation>(),
-                                                       emptyString,
-                                                       Severity::error,
-                                                       msg,
-                                                       "pcre_compile",
-                                                       false);
-
-                reportErr(errmsg);
-            }
+        if (rule.tokenlist != tokenlist)
             continue;
-        }
 
-        // Optimize the regex, but only if PCRE_CONFIG_JIT is available
-#ifdef PCRE_CONFIG_JIT
-        const char *pcreStudyErrorStr = nullptr;
-        pcre_extra * const pcreExtra = pcre_study(re, PCRE_STUDY_JIT_COMPILE, &pcreStudyErrorStr);
-        // pcre_study() returns NULL for both errors and when it can not optimize the regex.
-        // The last argument is how one checks for errors.
-        // It is NULL if everything works, and points to an error string otherwise.
-        if (pcreStudyErrorStr) {
-            const std::string msg = "pcre_study failed: " + std::string(pcreStudyErrorStr);
-            const ErrorLogger::ErrorMessage errmsg(std::list<ErrorLogger::ErrorMessage::FileLocation>(),
-                                                   emptyString,
-                                                   Severity::error,
-                                                   msg,
-                                                   "pcre_study",
-                                                   false);
-
-            reportErr(errmsg);
-            // pcre_compile() worked, but pcre_study() returned an error. Free the resources allocated by pcre_compile().
-            pcre_free(re);
-            continue;
+        if (!mSettings.quiet) {
+            mErrorLogger.reportOut("Processing rule: " + rule.pattern, Color::FgGreen);
         }
-#else
-        const pcre_extra * const pcreExtra = nullptr;
-#endif
-
-        int pos = 0;
-        int ovector[30]= {0};
-        while (pos < (int)str.size()) {
-            const int pcreExecRet = pcre_exec(re, pcreExtra, str.c_str(), (int)str.size(), pos, 0, ovector, 30);
-            if (pcreExecRet < 0) {
-                const std::string errorMessage = pcreErrorCodeToString(pcreExecRet);
-                if (!errorMessage.empty()) {
-                    const ErrorLogger::ErrorMessage errmsg(std::list<ErrorLogger::ErrorMessage::FileLocation>(),
-                                                           emptyString,
-                                                           Severity::error,
-                                                           std::string("pcre_exec failed: ") + errorMessage,
-                                                           "pcre_exec",
-                                                           false);
-
-                    reportErr(errmsg);
-                }
-                break;
-            }
-            const unsigned int pos1 = (unsigned int)ovector[0];
-            const unsigned int pos2 = (unsigned int)ovector[1];
-
-            // jump to the end of the match for the next pcre_exec
-            pos = (int)pos2;
 
+        auto f = [&](int pos1, int pos2) {
             // determine location..
-            ErrorLogger::ErrorMessage::FileLocation loc;
-            loc.setfile(tokenizer.list.getSourceFilePath());
-            loc.line = 0;
+            int fileIndex = 0;
+            int line = 0;
 
             std::size_t len = 0;
-            for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {
+            for (const Token *tok = list.front(); tok; tok = tok->next()) {
                 len = len + 1U + tok->str().size();
                 if (len > pos1) {
-                    loc.setfile(tokenizer.list.getFiles().at(tok->fileIndex()));
-                    loc.line = tok->linenr();
+                    fileIndex = tok->fileIndex();
+                    line = tok->linenr();
                     break;
                 }
             }
 
-            const std::list<ErrorLogger::ErrorMessage::FileLocation> callStack(1, loc);
+            const std::string& file = list.getFiles()[fileIndex];
+
+            ErrorMessage::FileLocation loc(file, line, 0);
 
             // Create error message
-            std::string summary;
-            if (rule.summary.empty())
-                summary = "found '" + str.substr(pos1, pos2 - pos1) + "'";
-            else
-                summary = rule.summary;
-            const ErrorLogger::ErrorMessage errmsg(callStack, tokenizer.list.getSourceFilePath(), rule.severity, summary, rule.id, false);
+            const ErrorMessage errmsg({std::move(loc)},
+                                      list.getSourceFilePath(),
+                                      rule.severity,
+                                      !rule.summary.empty() ? rule.summary : "found '" + str.substr(pos1, pos2 - pos1) + "'",
+                                      rule.id,
+                                      Certainty::normal);
 
             // Report error
-            reportErr(errmsg);
-        }
-
-        pcre_free(re);
-#ifdef PCRE_CONFIG_JIT
-        // Free up the EXTRA PCRE value (may be NULL at this point)
-        if (pcreExtra) {
-            pcre_free_study(pcreExtra);
+            mErrorLogger.reportErr(errmsg);
+        };
+
+        const std::string err = rule.regex->match(str, f);
+        if (!err.empty()) {
+            const ErrorMessage errmsg(std::list<ErrorMessage::FileLocation>(),
+                                      "",
+                                      Severity::error,
+                                      err,
+                                      "pcre_exec",
+                                      Certainty::normal);
+
+            mErrorLogger.reportErr(errmsg);
         }
-#endif
     }
-#endif
 }
+#endif
 
-Settings &CppCheck::settings()
+void CppCheck::executeAddons(const std::string& dumpFile, const FileWithDetails& file)
 {
-    return mSettings;
+    if (!dumpFile.empty()) {
+        std::vector<std::string> f{dumpFile};
+        Timer::run("CppCheck::executeAddons", mSettings.showtime, mTimerResults, [&]() {
+            executeAddons(f, file.spath());
+        });
+    }
 }
 
-void CppCheck::tooManyConfigsError(const std::string &file, const std::size_t numberOfConfigurations)
+void CppCheck::executeAddons(const std::vector<std::string>& files, const std::string& file0)
 {
-    if (!mSettings.isEnabled(Settings::INFORMATION) && !mTooManyConfigs)
+    if (mSettings.addons.empty() || files.empty() || Settings::unusedFunctionOnly())
         return;
 
-    mTooManyConfigs = false;
+    const bool isCtuInfo = endsWith(files[0], ".ctu-info");
 
-    if (mSettings.isEnabled(Settings::INFORMATION) && file.empty())
-        return;
+    FilesDeleter filesDeleter;
+    std::string fileList;
 
-    std::list<ErrorLogger::ErrorMessage::FileLocation> loclist;
-    if (!file.empty()) {
-        ErrorLogger::ErrorMessage::FileLocation location;
-        location.setfile(file);
-        loclist.push_back(location);
+    if (files.size() >= 2) {
+        fileList = Path::getPathFromFilename(files[0]) + FILELIST + ("-" + std::to_string(mSettings.pid)) + ".txt";
+        std::ofstream fout(fileList);
+        filesDeleter.addFile(fileList);
+        // TODO: check if file could be created
+        for (const std::string& f: files)
+            fout << f << std::endl;
     }
 
-    std::ostringstream msg;
-    msg << "Too many #ifdef configurations - cppcheck only checks " << mSettings.maxConfigs;
-    if (numberOfConfigurations > mSettings.maxConfigs)
-        msg << " of " << numberOfConfigurations << " configurations. Use --force to check all configurations.\n";
-    if (file.empty())
-        msg << " configurations. Use --force to check all configurations. For more details, use --enable=information.\n";
-    msg << "The checking of the file will be interrupted because there are too many "
-        "#ifdef configurations. Checking of all #ifdef configurations can be forced "
-        "by --force command line option or from GUI preferences. However that may "
-        "increase the checking time.";
-    if (file.empty())
-        msg << " For more details, use --enable=information.";
-
-
-    ErrorLogger::ErrorMessage errmsg(loclist,
-                                     emptyString,
-                                     Severity::information,
-                                     msg.str(),
-                                     "toomanyconfigs", CWE398,
-                                     false);
-
-    reportErr(errmsg);
-}
+    // ensure all addons have already been resolved - TODO: remove when settings are const after creation
+    assert(mSettings.addonInfos.size() == mSettings.addons.size());
 
-void CppCheck::purgedConfigurationMessage(const std::string &file, const std::string& configuration)
-{
-    mTooManyConfigs = false;
+    std::string ctuInfo;
 
-    if (mSettings.isEnabled(Settings::INFORMATION) && file.empty())
-        return;
+    for (const AddonInfo &addonInfo : mSettings.addonInfos) {
+        if (isCtuInfo && addonInfo.name != "misra" && !addonInfo.ctu)
+            continue;
 
-    std::list<ErrorLogger::ErrorMessage::FileLocation> loclist;
-    if (!file.empty()) {
-        ErrorLogger::ErrorMessage::FileLocation location;
-        location.setfile(file);
-        loclist.push_back(location);
-    }
+        ProgressReporter progressReporter(mErrorLogger, mSettings.reportProgress, files.front(), "addon:" + addonInfo.name + (isCtuInfo ? " (ctu)" : ""));
 
-    ErrorLogger::ErrorMessage errmsg(loclist,
-                                     emptyString,
-                                     Severity::information,
-                                     "The configuration '" + configuration + "' was not checked because its code equals another one.",
-                                     "purgedConfiguration",
-                                     false);
+        std::vector<picojson::value> results;
 
-    reportErr(errmsg);
-}
+        try {
+            results = executeAddon(addonInfo, mSettings.addonPython, fileList.empty() ? files[0] : fileList, mSettings.premiumArgs, mExecuteCommand);
+        } catch (const InternalError& e) {
+            const std::string ctx = isCtuInfo ? "Whole program analysis" : "Checking file";
+            const ErrorMessage errmsg = ErrorMessage::fromInternalError(e, nullptr, file0, "Bailing out from analysis: " + ctx + " failed");
+            mErrorLogger.reportErr(errmsg);
+        }
 
-//---------------------------------------------------------------------------
+        for (const picojson::value& res : results) {
+            // TODO: get rid of copy?
+            // this is a copy so we can access missing fields and get a default value
+            picojson::object obj = res.get<picojson::object>();
 
-void CppCheck::reportErr(const ErrorLogger::ErrorMessage &msg)
-{
-    mSuppressInternalErrorFound = false;
+            ErrorMessage errmsg;
 
-    if (!mSettings.library.reportErrors(msg.file0))
-        return;
+            if (obj.count("summary") > 0) {
+                if (!mSettings.buildDir.empty()) {
+                    ctuInfo += res.serialize() + "\n";
+                } else {
+                    errmsg.severity = Severity::internal;
+                    errmsg.id = "ctuinfo";
+                    errmsg.setmsg(res.serialize());
+                    mErrorLogger.reportErr(errmsg);
+                }
+                continue;
+            }
 
-    const std::string errmsg = msg.toString(mSettings.verbose);
-    if (errmsg.empty())
-        return;
+            if (obj.count("file") > 0) {
+                std::string fileName = obj["file"].get<std::string>();
+                const int64_t lineNumber = obj["linenr"].get<int64_t>();
+                const int64_t column = obj["column"].get<int64_t>();
+                errmsg.callStack.emplace_back(std::move(fileName), lineNumber, column);
+            } else if (obj.count("loc") > 0) {
+                for (const picojson::value &locvalue: obj["loc"].get<picojson::array>()) {
+                    picojson::object loc = locvalue.get<picojson::object>();
+                    std::string fileName = loc["file"].get<std::string>();
+                    const int64_t lineNumber = loc["linenr"].get<int64_t>();
+                    const int64_t column = loc["column"].get<int64_t>();
+                    std::string info = loc["info"].get<std::string>();
+                    errmsg.callStack.emplace_back(std::move(fileName), std::move(info), lineNumber, column);
+                }
+            }
 
-    // Alert only about unique errors
-    if (std::find(mErrorList.begin(), mErrorList.end(), errmsg) != mErrorList.end())
-        return;
+            if (obj.count("metric") > 0) {
+                picojson::object metric_json = obj["metric"].get<picojson::object>();
 
-    const Suppressions::ErrorMessage errorMessage = msg.toSuppressionsErrorMessage();
+                std::string metric = "<metric";
 
-    if (mUseGlobalSuppressions) {
-        if (mSettings.nomsg.isSuppressed(errorMessage)) {
-            mSuppressInternalErrorFound = true;
-            return;
-        }
-    } else {
-        if (mSettings.nomsg.isSuppressedLocal(errorMessage)) {
-            mSuppressInternalErrorFound = true;
-            return;
+                for (auto pair : metric_json) {
+                    const std::string id = pair.first;
+                    if (pair.second.is<std::int64_t>())
+                        metric += " " + id + "=\"" + std::to_string(pair.second.get<std::int64_t>()) + "\"";
+                    else if (pair.second.is<std::string>())
+                        metric += " " + id + "=\"" + ErrorLogger::toxml(pair.second.get<std::string>()) + "\"";
+                }
+
+                metric += "/>";
+                mErrorLogger.reportMetric(metric);
+
+                continue;
+            }
+
+            errmsg.id = obj["addon"].get<std::string>() + "-" + obj["errorId"].get<std::string>();
+            errmsg.setmsg(obj["message"].get<std::string>());
+            const std::string severity = obj["severity"].get<std::string>();
+            errmsg.severity = severityFromString(severity);
+            if (errmsg.severity == Severity::none || errmsg.severity == Severity::internal) {
+                if (!endsWith(errmsg.id, "-logChecker"))
+                    continue;
+                errmsg.severity = Severity::internal;
+            }
+            else if (!mSettings.severity.isEnabled(errmsg.severity)) {
+                // Do not filter out premium misra/cert/autosar messages that has been
+                // explicitly enabled with a --premium option
+                if (!isPremiumCodingStandardId(errmsg.id))
+                    continue;
+            }
+            errmsg.file0 = file0;
+
+            if (obj.count("cwe")>0)
+                errmsg.cwe = CWE(obj["cwe"].get<std::int64_t>());
+
+            if (obj.count("hash")>0)
+                errmsg.hash = obj["hash"].get<std::int64_t>();
+
+            mErrorLogger.reportErr(errmsg);
         }
     }
 
-    if (!mSettings.nofail.isSuppressed(errorMessage) && !mSettings.nomsg.isSuppressed(errorMessage)) {
-        mExitCode = 1;
+    if (!mSettings.buildDir.empty() && !isCtuInfo) {
+        const std::string& ctuInfoFile = getCtuInfoFileName(files[0]);
+        std::ofstream fout(ctuInfoFile);
+        fout << ctuInfo;
     }
+}
 
-    mErrorList.push_back(errmsg);
+void CppCheck::executeAddonsWholeProgram(const std::list<FileWithDetails> &files, const std::list<FileSettings>& fileSettings, const std::string& ctuInfo)
+{
+    if (mSettings.addons.empty())
+        return;
 
-    mErrorLogger.reportErr(msg);
-    mAnalyzerInformation.reportErr(msg, mSettings.verbose);
-    if (!mSettings.plistOutput.empty() && plistFile.is_open()) {
-        plistFile << ErrorLogger::plistData(msg);
+    if (mSettings.buildDir.empty()) {
+        std::string fileName = std::to_string(mSettings.pid) + ".ctu-info";
+        FilesDeleter filesDeleter;
+        filesDeleter.addFile(fileName);
+        std::ofstream fout(fileName);
+        fout << ctuInfo;
+        fout.close();
+        executeAddons({std::move(fileName)}, "");
+        return;
     }
-}
 
-void CppCheck::reportOut(const std::string &outmsg)
-{
-    mErrorLogger.reportOut(outmsg);
+    std::vector<std::string> ctuInfoFiles;
+    for (const auto &f: files) {
+        const std::string &dumpFileName = getDumpFileName(mSettings, f);
+        ctuInfoFiles.push_back(getCtuInfoFileName(dumpFileName));
+    }
+
+    for (const auto &fs: fileSettings) {
+        const std::string &dumpFileName = getDumpFileName(mSettings, fs.file);
+        ctuInfoFiles.push_back(getCtuInfoFileName(dumpFileName));
+    }
+
+    executeAddons(ctuInfoFiles, "");
 }
 
-void CppCheck::reportProgress(const std::string &filename, const char stage[], const std::size_t value)
+void CppCheck::tooManyConfigsError(const std::string &file, const int numberOfConfigurations)
 {
-    mErrorLogger.reportProgress(filename, stage, value);
+    std::list<ErrorMessage::FileLocation> loclist;
+    if (!file.empty()) {
+        loclist.emplace_back(file, 0, 0);
+    }
+
+    std::ostringstream msg;
+    msg << "Too many #ifdef configurations - cppcheck only checks " << mSettings.getMaxConfigs()
+        << " of " << numberOfConfigurations << " configurations. Use --force to check all configurations.";
+
+    ErrorMessage errmsg(std::move(loclist),
+                        "",
+                        Severity::information,
+                        msg.str(),
+                        "toomanyconfigs", CWE398,
+                        Certainty::normal);
+
+    mErrorLogger.reportErr(errmsg);
 }
 
-void CppCheck::reportInfo(const ErrorLogger::ErrorMessage &msg)
+void CppCheck::purgedConfigurationMessage(const std::string &file, const std::string& configuration)
 {
-    const Suppressions::ErrorMessage &errorMessage = msg.toSuppressionsErrorMessage();
-    if (!mSettings.nomsg.isSuppressed(errorMessage))
-        mErrorLogger.reportInfo(msg);
+    if (mSettings.severity.isEnabled(Severity::information) && file.empty())
+        return;
+
+    std::list<ErrorMessage::FileLocation> loclist;
+    if (!file.empty()) {
+        loclist.emplace_back(file, 0, 0);
+    }
+
+    ErrorMessage errmsg(std::move(loclist),
+                        "",
+                        Severity::information,
+                        "The configuration '" + configuration + "' was not checked because its code equals another one.",
+                        "purgedConfiguration",
+                        Certainty::normal);
+
+    mErrorLogger.reportErr(errmsg);
 }
 
-void CppCheck::reportStatus(unsigned int /*fileindex*/, unsigned int /*filecount*/, std::size_t /*sizedone*/, std::size_t /*sizetotal*/)
+//---------------------------------------------------------------------------
+
+void CppCheck::getErrorMessages(ErrorLogger &errorlogger)
 {
+    Settings settings;
+    settings.templateFormat = "{callstack}: ({severity}) {inconclusive:inconclusive: }{message}"; // TODO: get rid of this
+    Suppressions supprs;
+
+    CppCheck cppcheck(settings, supprs, errorlogger, nullptr, true, nullptr);
+    cppcheck.purgedConfigurationMessage("","");
+    cppcheck.tooManyConfigsError("",0U);
+    // TODO: add functions to get remaining error messages
+
+    Settings s;
+    s.addEnabled("all");
+
+    // call all "getErrorMessages" in all registered Check classes
+    for (auto it = Check::instances().cbegin(); it != Check::instances().cend(); ++it)
+        (*it)->getErrorMessages(&errorlogger, &s);
 
+    CheckUnusedFunctions::getErrorMessages(errorlogger);
+    Preprocessor::getErrorMessages(errorlogger, s);
+    Tokenizer::getErrorMessages(errorlogger, s);
+    SymbolDatabase::getErrorMessages(errorlogger);
 }
 
-void CppCheck::getErrorMessages()
+void CppCheck::analyseClangTidy(const FileSettings &fileSettings)
 {
-    Settings s(mSettings);
-    s.addEnabled("warning");
-    s.addEnabled("style");
-    s.addEnabled("portability");
-    s.addEnabled("performance");
-    s.addEnabled("information");
+    std::string allIncludes;
+    for (const std::string &inc : fileSettings.includePaths) {
+        allIncludes = allIncludes + "-I\"" + inc + "\" ";
+    }
+
+    const std::string allDefines = getDefinesFlags(fileSettings.defines);
 
-    purgedConfigurationMessage("","");
+    std::string exe = mSettings.clangTidyExecutable;
+#ifdef _WIN32
+    // TODO: is this even necessary?
+    // append .exe if it is not a path
+    if (Path::fromNativeSeparators(mSettings.clangTidyExecutable).find('/') == std::string::npos) {
+        exe += ".exe";
+    }
+#endif
 
-    mTooManyConfigs = true;
-    tooManyConfigsError("",0U);
+    if (!mExecuteCommand) {
+        std::cerr << "Failed to execute '" << exe << "' (no command callback provided)" << std::endl;
+        return;
+    }
 
-    // call all "getErrorMessages" in all registered Check classes
-    for (std::list<Check *>::const_iterator it = Check::instances().begin(); it != Check::instances().end(); ++it)
-        (*it)->getErrorMessages(this, &s);
+    // TODO: log this call
+    // TODO: get rid of hard-coded checks
+    const std::string args = "-quiet -checks=*,-clang-analyzer-*,-llvm* \"" + fileSettings.filename() + "\" -- " + allIncludes + allDefines;
+    std::string output;
+    if (const int exitcode = mExecuteCommand(exe, split(args), "2>&1", output)) {
+        // TODO: needs to be a proper error
+        std::cerr << "Failed to execute '" << exe << "' (exitcode: " << std::to_string(exitcode) << ")" << std::endl;
+        return;
+    }
+
+    // parse output and create error messages
+    std::istringstream istr(output);
+    std::string line;
+
+    if (!mSettings.buildDir.empty()) {
+        const std::string analyzerInfoFile = AnalyzerInformation::getAnalyzerInfoFile(mSettings.buildDir, fileSettings.sfilename(), "", fileSettings.file.fsFileId());
+        std::ofstream fcmd(analyzerInfoFile + ".clang-tidy-cmd");
+        fcmd << istr.str();
+    }
+
+    // TODO: log
+    while (std::getline(istr, line)) {
+        if (line.find("error") == std::string::npos && line.find("warning") == std::string::npos)
+            continue;
+
+        std::size_t endColumnPos = line.find(": error:");
+        if (endColumnPos == std::string::npos) {
+            endColumnPos = line.find(": warning:");
+        }
+
+        const std::size_t endLinePos = line.rfind(':', endColumnPos-1);
+        const std::size_t endNamePos = line.rfind(':', endLinePos - 1);
+        const std::size_t endMsgTypePos = line.find(':', endColumnPos + 2);
+        const std::size_t endErrorPos = line.rfind('[', std::string::npos);
+        if (endLinePos==std::string::npos || endNamePos==std::string::npos || endMsgTypePos==std::string::npos || endErrorPos==std::string::npos)
+            continue;
+
+        const std::string lineNumString = line.substr(endNamePos + 1, endLinePos - endNamePos - 1);
+        const std::string columnNumString = line.substr(endLinePos + 1, endColumnPos - endLinePos - 1);
+        const std::string messageString = line.substr(endMsgTypePos + 1, endErrorPos - endMsgTypePos - 1);
+        const std::string errorString = line.substr(endErrorPos, line.length());
+
+        std::string fixedpath = Path::simplifyPath(line.substr(0, endNamePos));
+        fixedpath = Path::toNativeSeparators(std::move(fixedpath));
+        const auto lineNumber = strToInt<int64_t>(lineNumString);
+        const auto column = strToInt<int64_t>(columnNumString);
+
+        ErrorMessage errmsg;
+        errmsg.callStack.emplace_back(fixedpath, lineNumber, column);
+        errmsg.file0 = std::move(fixedpath);
+        errmsg.setmsg(trim(messageString));
+
+        for (const auto& id : splitString(errorString.substr(1, errorString.length() - 2), ',')) {
+            errmsg.id = "clang-tidy-" + id;
+            if (startsWith(id, "performance-"))
+                errmsg.severity = Severity::performance;
+            else if (startsWith(id, "portability-"))
+                errmsg.severity = Severity::portability;
+            else if (startsWith(id, "cert-") || startsWith(id, "misc-") || startsWith(id, "bugprone-") || (id.find("-unused-") != std::string::npos))
+                errmsg.severity = Severity::warning;
+            else
+                errmsg.severity = Severity::style;
 
-    Preprocessor::getErrorMessages(this, &s);
+            mErrorLogger.reportErr(errmsg);
+        }
+    }
 }
 
 bool CppCheck::analyseWholeProgram()
 {
     bool errors = false;
-    // Init CTU
-    CTU::maxCtuDepth = mSettings.maxCtuDepth;
-    // Analyse the tokens
-    CTU::FileInfo ctu;
-    for (const Check::FileInfo *fi : mFileInfo) {
-        const CTU::FileInfo *fi2 = dynamic_cast<const CTU::FileInfo *>(fi);
-        if (fi2) {
-            ctu.functionCalls.insert(ctu.functionCalls.end(), fi2->functionCalls.begin(), fi2->functionCalls.end());
-            ctu.nestedCalls.insert(ctu.nestedCalls.end(), fi2->nestedCalls.begin(), fi2->nestedCalls.end());
+
+    if (!Settings::unusedFunctionOnly()) {
+        // Analyse the tokens
+        CTU::FileInfo ctu;
+        if (mSettings.useSingleJob() || !mSettings.buildDir.empty())
+        {
+            for (const Check::FileInfo *fi : mFileInfo) {
+                const auto *fi2 = dynamic_cast<const CTU::FileInfo *>(fi);
+                if (fi2) {
+                    ctu.functionCalls.insert(ctu.functionCalls.end(), fi2->functionCalls.cbegin(), fi2->functionCalls.cend());
+                    ctu.nestedCalls.insert(ctu.nestedCalls.end(), fi2->nestedCalls.cbegin(), fi2->nestedCalls.cend());
+                }
+            }
         }
+
+        // cppcheck-suppress shadowFunction - TODO: fix this
+        for (Check *check : Check::instances())
+            errors |= check->analyseWholeProgram(ctu, mFileInfo, mSettings, mErrorLogger);  // TODO: ctu
     }
-    for (Check *check : Check::instances())
-        errors |= check->analyseWholeProgram(&ctu, mFileInfo, mSettings, *this);  // TODO: ctu
-    return errors && (mExitCode > 0);
+
+    if (mUnusedFunctionsCheck)
+        errors |= mUnusedFunctionsCheck->check(mSettings, mErrorLogger);
+
+    return errors && (mLogger->exitcode() > 0);
 }
 
-void CppCheck::analyseWholeProgram(const std::string &buildDir, const std::map<std::string, std::size_t> &files)
+unsigned int CppCheck::analyseWholeProgram(const std::string &buildDir, const std::list<FileWithDetails> &files, const std::list<FileSettings>& fileSettings, const std::string& ctuInfo)
 {
-    (void)files;
-    if (buildDir.empty())
-        return;
-    if (mSettings.isEnabled(Settings::UNUSED_FUNCTION))
-        CheckUnusedFunctions::analyseWholeProgram(this, buildDir);
-    std::list<Check::FileInfo*> fileInfoList;
-    CTU::FileInfo ctuFileInfo;
+    if (mSettings.checks.isEnabled(Checks::unusedFunction))
+        CheckUnusedFunctions::analyseWholeProgram(mSettings, mErrorLogger, buildDir);
 
-    // Load all analyzer info data..
-    const std::string filesTxt(buildDir + "/files.txt");
-    std::ifstream fin(filesTxt);
-    std::string filesTxtLine;
-    while (std::getline(fin, filesTxtLine)) {
-        const std::string::size_type firstColon = filesTxtLine.find(':');
-        if (firstColon == std::string::npos)
-            continue;
-        const std::string::size_type lastColon = filesTxtLine.rfind(':');
-        if (firstColon == lastColon)
-            continue;
-        const std::string xmlfile = buildDir + '/' + filesTxtLine.substr(0,firstColon);
-        //const std::string sourcefile = filesTxtLine.substr(lastColon+1);
+    if (mUnusedFunctionsCheck)
+        mUnusedFunctionsCheck->check(mSettings, mErrorLogger);
 
-        tinyxml2::XMLDocument doc;
-        const tinyxml2::XMLError error = doc.LoadFile(xmlfile.c_str());
-        if (error != tinyxml2::XML_SUCCESS)
-            continue;
+    if (Settings::unusedFunctionOnly())
+        return mLogger->exitcode();
 
-        const tinyxml2::XMLElement * const rootNode = doc.FirstChildElement();
-        if (rootNode == nullptr)
-            continue;
+    executeAddonsWholeProgram(files, fileSettings, ctuInfo);
 
-        for (const tinyxml2::XMLElement *e = rootNode->FirstChildElement(); e; e = e->NextSiblingElement()) {
-            if (std::strcmp(e->Name(), "FileInfo") != 0)
-                continue;
-            const char *checkClassAttr = e->Attribute("check");
-            if (!checkClassAttr)
-                continue;
-            if (std::strcmp(checkClassAttr, "ctu") == 0) {
-                ctuFileInfo.loadFromXml(e);
-                continue;
-            }
-            for (Check *check : Check::instances()) {
-                if (checkClassAttr == check->name())
-                    fileInfoList.push_back(check->loadFileInfoFromXml(e));
+    std::list<Check::FileInfo*> fileInfoList;
+    CTU::FileInfo ctuFileInfo;
+
+    const auto handler = [&fileInfoList, &ctuFileInfo](const char* checkattr, const tinyxml2::XMLElement* e, const AnalyzerInformation::Info& filesTxtInfo) {
+        if (std::strcmp(checkattr, "ctu") == 0) {
+            ctuFileInfo.loadFromXml(e);
+            return;
+        }
+        for (const Check *check : Check::instances()) {
+            if (checkattr == check->name()) {
+                if (Check::FileInfo* fi = check->loadFileInfoFromXml(e)) {
+                    fi->file0 = filesTxtInfo.sourceFile;
+                    fileInfoList.push_back(fi);
+                }
             }
         }
-    }
-
-    // Set CTU max depth
-    CTU::maxCtuDepth = mSettings.maxCtuDepth;
+    };
 
-    // Analyse the tokens
-    for (Check *check : Check::instances())
-        check->analyseWholeProgram(&ctuFileInfo, fileInfoList, mSettings, *this);
+    const std::string err = AnalyzerInformation::processFilesTxt(buildDir, handler, mSettings.debugainfo);
+    if (!err.empty()) {
+        const ErrorMessage errmsg({}, "", Severity::error, err, "internalError", Certainty::normal);
+        mErrorLogger.reportErr(errmsg);
+    }
+    else {
+        // Analyse the tokens
+        // cppcheck-suppress shadowFunction - TODO: fix this
+        for (Check *check : Check::instances())
+            check->analyseWholeProgram(ctuFileInfo, fileInfoList, mSettings, mErrorLogger);
+    }
 
     for (Check::FileInfo *fi : fileInfoList)
         delete fi;
+
+    return mLogger->exitcode();
 }
 
-bool CppCheck::isUnusedFunctionCheckEnabled() const
-{
-    return (mSettings.jobs == 1 && mSettings.isEnabled(Settings::UNUSED_FUNCTION));
+bool CppCheck::isPremiumCodingStandardId(const std::string& id) const {
+    if (mSettings.premiumArgs.find("--misra") != std::string::npos && startsWith(id, "premium-misra-"))
+        return true;
+    if (mSettings.premiumArgs.find("--cert") != std::string::npos && startsWith(id, "premium-cert-"))
+        return true;
+    if (mSettings.premiumArgs.find("--autosar") != std::string::npos && startsWith(id, "premium-autosar-"))
+        return true;
+    return false;
+}
+
+std::string CppCheck::getDumpFileContentsRawTokens(const std::vector<std::string>& files, const simplecpp::TokenList& tokens1) const {
+    std::string dumpProlog;
+    dumpProlog += "  <rawtokens>\n";
+    for (unsigned int i = 0; i < files.size(); ++i) {
+        dumpProlog += "    <file index=\"";
+        dumpProlog += std::to_string(i);
+        dumpProlog += "\" name=\"";
+        dumpProlog += ErrorLogger::toxml(Path::getRelativePath(files[i], mSettings.basePaths));
+        dumpProlog += "\"/>\n";
+    }
+    for (const simplecpp::Token *tok = tokens1.cfront(); tok; tok = tok->next) {
+        dumpProlog += "    <tok ";
+
+        dumpProlog += "fileIndex=\"";
+        dumpProlog += std::to_string(tok->location.fileIndex);
+        dumpProlog += "\" ";
+
+        dumpProlog += "linenr=\"";
+        dumpProlog += std::to_string(tok->location.line);
+        dumpProlog += "\" ";
+
+        dumpProlog +="column=\"";
+        dumpProlog += std::to_string(tok->location.col);
+        dumpProlog += "\" ";
+
+        dumpProlog += "str=\"";
+        dumpProlog += ErrorLogger::toxml(tok->str());
+        dumpProlog += "\"";
+
+        dumpProlog += "/>\n";
+    }
+    dumpProlog += "  </rawtokens>\n";
+    return dumpProlog;
 }
diff --git a/lib/cppcheck.h b/lib/cppcheck.h
index 63dfa977542..2aeee1a0beb 100644
--- a/lib/cppcheck.h
+++ b/lib/cppcheck.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,20 +21,32 @@
 #define cppcheckH
 //---------------------------------------------------------------------------
 
-#include "analyzerinfo.h"
 #include "check.h"
 #include "config.h"
-#include "errorlogger.h"
-#include "importproject.h"
-#include "settings.h"
 
 #include <cstddef>
-#include <istream>
+#include <functional>
 #include <list>
-#include <map>
+#include <memory>
 #include <string>
+#include <vector>
 
+class TokenList;
+struct FileSettings;
+class CheckUnusedFunctions;
 class Tokenizer;
+class FileWithDetails;
+class AnalyzerInformation;
+class ErrorLogger;
+class Settings;
+struct Suppressions;
+class Preprocessor;
+class TimerResults;
+
+namespace simplecpp {
+    class TokenList;
+    struct Output;
+}
 
 /// @addtogroup Core
 /// @{
@@ -45,17 +57,27 @@ class Tokenizer;
  * errors or places that could be improved.
  * Usage: See check() for more info.
  */
-class CPPCHECKLIB CppCheck : ErrorLogger {
+class CPPCHECKLIB CppCheck {
+    friend class TestCppcheck;
+
 public:
+    // exe, args, redirect, output
+    using ExecuteCmdFn = std::function<int (std::string,std::vector<std::string>,std::string,std::string&)>;
+
     /**
      * @brief Constructor.
      */
-    CppCheck(ErrorLogger &errorLogger, bool useGlobalSuppressions);
+    CppCheck(const Settings& settings,
+             Suppressions& supprs,
+             ErrorLogger &errorLogger,
+             TimerResults* timerResults,
+             bool useGlobalSuppressions,
+             ExecuteCmdFn executeCommand);
 
     /**
      * @brief Destructor.
      */
-    ~CppCheck() OVERRIDE;
+    ~CppCheck();
 
     /**
      * @brief This starts the actual checking. Note that you must call
@@ -64,40 +86,35 @@ class CPPCHECKLIB CppCheck : ErrorLogger {
      */
 
     /**
-      * @brief Check the file.
-      * This function checks one given file for errors.
-      * @param path Path to the file to check.
-      * @return amount of errors found or 0 if none were found.
-      * @note You must set settings before calling this function (by calling
-      *  settings()).
-      */
-    unsigned int check(const std::string &path);
-    unsigned int check(const ImportProject::FileSettings &fs);
-
-    /**
-      * @brief Check the file.
-      * This function checks one "virtual" file. The file is not read from
-      * the disk but the content is given in @p content. In errors the @p path
-      * is used as a filename.
-      * @param path Path to the file to check.
-      * @param content File content as a string.
-      * @return amount of errors found or 0 if none were found.
-      * @note You must set settings before calling this function (by calling
-      *  settings()).
-      */
-    unsigned int check(const std::string &path, const std::string &content);
+     * @brief Check the file.
+     * This function checks one given file for errors.
+     * @param file The file to check.
+     * @return amount of errors found or 0 if none were found.
+     * @note You must set settings before calling this function (by calling
+     *  settings()).
+     */
+    unsigned int check(const FileWithDetails &file);
+    unsigned int check(const FileSettings &fs);
 
     /**
-     * @brief Get reference to current settings.
-     * @return a reference to current settings
+     * @brief Check the file.
+     * This function checks one "virtual" file. The file is not read from
+     * the disk but the content is given in @p content. In errors the @p path
+     * is used as a filename.
+     * @param file The file to check.
+     * @param data File content as a buffer.
+     * @param size Size of buffer.
+     * @return amount of errors found or 0 if none were found.
+     * @note You must set settings before calling this function (by calling
+     *  settings()).
      */
-    Settings &settings();
+    unsigned int checkBuffer(const FileWithDetails &file, const char* data, std::size_t size);
 
     /**
      * @brief Returns current version number as a string.
      * @return version, e.g. "1.38"
      */
-    static const char * version();
+    RET_NONNULL static const char * version();
 
     /**
      * @brief Returns extra version info as a string.
@@ -105,29 +122,15 @@ class CPPCHECKLIB CppCheck : ErrorLogger {
      * time/date etc.
      * @return extra version info, e.g. "04d42151" (Git commit id).
      */
-    static const char * extraVersion();
-
-    virtual void reportStatus(unsigned int fileindex, unsigned int filecount, std::size_t sizedone, std::size_t sizetotal);
-
-    /**
-     * @brief Terminate checking. The checking will be terminated as soon as possible.
-     */
-    void terminate() {
-        Settings::terminate();
-    }
+    RET_NONNULL static const char * extraVersion();
 
     /**
      * @brief Call all "getErrorMessages" in all registered Check classes.
      * Also print out XML header and footer.
      */
-    void getErrorMessages();
-
-    void tooManyConfigsError(const std::string &file, const std::size_t numberOfConfigurations);
-    void purgedConfigurationMessage(const std::string &file, const std::string& configuration);
+    static void getErrorMessages(ErrorLogger &errorlogger);
 
-    void dontSimplify() {
-        mSimplify = false;
-    }
+    void tooManyConfigsError(const std::string &file, int numberOfConfigurations);
 
     /** Analyse whole program, run this after all TUs has been scanned.
      * This is deprecated and the plan is to remove this when
@@ -136,96 +139,121 @@ class CPPCHECKLIB CppCheck : ErrorLogger {
      */
     bool analyseWholeProgram();
 
-    /** analyse whole program use .analyzeinfo files */
-    void analyseWholeProgram(const std::string &buildDir, const std::map<std::string, std::size_t> &files);
-
-    /** Check if the user wants to check for unused functions
-     * and if it's possible at all */
-    bool isUnusedFunctionCheckEnabled() const;
+    /** analyse whole program use .analyzeinfo files or ctuinfo string */
+    unsigned int analyseWholeProgram(const std::string &buildDir, const std::list<FileWithDetails> &files, const std::list<FileSettings>& fileSettings, const std::string& ctuInfo);
 
 private:
+    void purgedConfigurationMessage(const std::string &file, const std::string& configuration);
+
+    bool isPremiumCodingStandardId(const std::string& id) const;
+
+    /**
+     * @brief Get dumpfile <rawtokens> contents, this is only public for testing purposes
+     */
+    std::string getDumpFileContentsRawTokens(const std::vector<std::string>& files, const simplecpp::TokenList& tokens1) const;
+
+    std::string getLibraryDumpData() const;
+
+    /** Analyze all files using clang-tidy */
+    void analyseClangTidy(const FileSettings &fileSettings);
 
+#ifdef HAVE_RULES
     /** Are there "simple" rules */
     bool hasRule(const std::string &tokenlist) const;
+#endif
 
     /** @brief There has been an internal error => Report information message */
     void internalError(const std::string &filename, const std::string &msg);
 
     /**
-     * @brief Check a file using stream
-     * @param filename file name
+     * @brief Calculate hash used to detect when a file needs to be reanalyzed.
+     *
+     * @param preprocessor  Preprocessor used to calculate the hash.
+     * @return hash
+     */
+    std::size_t calculateHash(const Preprocessor &preprocessor, const std::string& filePath = {}) const;
+
+    /**
+     * @brief Check a file
+     * @param file the file
      * @param cfgname  cfg name
-     * @param fileStream stream the file content can be read from
      * @return number of errors found
      */
-    unsigned int checkFile(const std::string& filename, const std::string &cfgname, std::istream& fileStream);
+    unsigned int checkFile(const FileWithDetails& file, const std::string &cfgname);
+
+    void checkPlistOutput(const FileWithDetails& file, const std::vector<std::string>& files);
 
     /**
-     * @brief Check raw tokens
-     * @param tokenizer tokenizer instance
+     * @brief Check a file using buffer
+     * @param file the file
+     * @param cfgname  cfg name
+     * @param data the data to be read
+     * @param size the size of the data to be read
+     * @return number of errors found
      */
-    void checkRawTokens(const Tokenizer &tokenizer);
+    unsigned int checkBuffer(const FileWithDetails& file, const std::string &cfgname, const char* data, std::size_t size);
+
+    // TODO: should use simplecpp::OutputList
+    using CreateTokenListFn = std::function<simplecpp::TokenList (std::vector<std::string>&, std::list<simplecpp::Output>*)>;
 
     /**
-     * @brief Check normal tokens
-     * @param tokenizer tokenizer instance
+     * @brief Check a file using stream
+     * @param file the file
+     * @param cfgname  cfg name
+     * @param createTokenList a function to create the simplecpp::TokenList with
+     * @return number of errors found
      */
-    void checkNormalTokens(const Tokenizer &tokenizer);
+    unsigned int checkInternal(const FileWithDetails& file, const std::string &cfgname, const CreateTokenListFn& createTokenList);
 
     /**
-     * @brief Execute rules, if any
-     * @param tokenlist token list to use (normal / simple)
-     * @param tokenizer tokenizer
+     * @brief Check normal tokens
+     * @param tokenizer tokenizer instance
+     * @param analyzerInformation the analyzer infomation
      */
-    void executeRules(const std::string &tokenlist, const Tokenizer &tokenizer);
+    void checkNormalTokens(const Tokenizer &tokenizer, AnalyzerInformation* analyzerInformation, const std::string& currentConfig);
 
     /**
-     * @brief Errors and warnings are directed here.
-     *
-     * @param msg Errors messages are normally in format
-     * "[filepath:line number] Message", e.g.
-     * "[main.cpp:4] Uninitialized member variable"
+     * Execute addons
      */
-    void reportErr(const ErrorLogger::ErrorMessage &msg) OVERRIDE;
+    void executeAddons(const std::vector<std::string>& files, const std::string& file0);
+    void executeAddons(const std::string &dumpFile, const FileWithDetails& file);
 
     /**
-     * @brief Information about progress is directed here.
-     *
-     * @param outmsg Message to show, e.g. "Checking main.cpp..."
+     * Execute addons
      */
-    void reportOut(const std::string &outmsg) OVERRIDE;
-
-    std::list<std::string> mErrorList;
-    Settings mSettings;
-
-    void reportProgress(const std::string &filename, const char stage[], const std::size_t value) OVERRIDE;
+    void executeAddonsWholeProgram(const std::list<FileWithDetails> &files, const std::list<FileSettings>& fileSettings, const std::string& ctuInfo);
 
+#ifdef HAVE_RULES
     /**
-     * Output information messages.
+     * @brief Execute rules, if any
+     * @param tokenlist token list to use (define / normal / raw)
+     * @param list token list
      */
-    void reportInfo(const ErrorLogger::ErrorMessage &msg) OVERRIDE;
-
-    ErrorLogger &mErrorLogger;
+    void executeRules(const std::string &tokenlist, const TokenList &list);
+#endif
 
-    /** @brief Current preprocessor configuration */
-    std::string mCurrentConfig;
+    unsigned int checkClang(const FileWithDetails &file);
 
-    unsigned int mExitCode;
+    const Settings& mSettings;
+    Suppressions& mSuppressions;
 
-    bool mSuppressInternalErrorFound;
+    class CppCheckLogger;
+    std::unique_ptr<CppCheckLogger> mLogger;
+    /** the internal ErrorLogger */
+    ErrorLogger& mErrorLogger;
+    /** the ErrorLogger provided to this instance */
+    ErrorLogger& mErrorLoggerDirect;
+    TimerResults* mTimerResults;
 
     bool mUseGlobalSuppressions;
 
-    /** Are there too many configs? */
-    bool mTooManyConfigs;
-
-    /** Simplify code? true by default */
-    bool mSimplify;
-
     /** File info used for whole program analysis */
     std::list<Check::FileInfo*> mFileInfo;
 
-    AnalyzerInformation mAnalyzerInformation;
+    /** Callback for executing a shell command (exe, args, output) */
+    ExecuteCmdFn mExecuteCommand;
+
+    std::unique_ptr<CheckUnusedFunctions> mUnusedFunctionsCheck;
 };
 
 /// @}
diff --git a/lib/cppcheck.natvis b/lib/cppcheck.natvis
index 7a78df96faf..6f5b6fd86a2 100644
--- a/lib/cppcheck.natvis
+++ b/lib/cppcheck.natvis
@@ -1,71 +1,71 @@
-<?xml version="1.0" encoding="utf-8"?> 
-<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
-  <Type Name="Token">
-    <DisplayString>{mStr}</DisplayString>
-  </Type>
-
-    <Type Name="TokensFrontBack">
-        <DisplayString>{front->mStr} - {back->mStr}</DisplayString>
-    </Type>
-
-
-    <Type Name="TokenList">
-    <DisplayString>{mTokensFrontBack.front->mStr} - {mTokensFrontBack.back->mStr}</DisplayString>
-    <Expand>
-      <Item Name="[files]">mFiles</Item>
-      <CustomListItems Optional="true" MaxItemsPerView="5000">
-        <Variable Name="pCurr" InitialValue="mTokensFrontBack.front" />
-        <Loop>
-          <If Condition="pCurr == mTokensFrontBack.back">
-            <Break Condition="1"/>
-          </If>
-          <Item>pCurr</Item>
-          <Exec>pCurr = pCurr->mNext</Exec>
-        </Loop>
-      </CustomListItems>
-      
-    </Expand>
-  </Type>
-
-  <Type Name="Variable">
-    <DisplayString>{mNameToken->mStr}</DisplayString>
-  </Type>
-
-  <Type Name="Function">
-    <DisplayString>{tokenDef->mStr}</DisplayString>
-  </Type>
-
-  <Type Name="Dimension">
-    <DisplayString Condition="known">{num}</DisplayString>
-    <DisplayString Condition="!known">?</DisplayString>
-  </Type>
-
-  <Type Name="Scope">
-    <DisplayString>{type}: {className}</DisplayString>
-  </Type>
-
-  <Type Name="cppcheck::Platform">
-    <DisplayString>{platformType}</DisplayString>
-  </Type>
-  
-  <Type Name="simplecpp::Location">
-    <DisplayString>{files[fileIndex]} : {line} [col={col}]</DisplayString>
-  </Type>
-    
-    
-  <Type Name="ValueFlow::Value">
-    <DisplayString Condition="valueType==INT">{intvalue} (INT)</DisplayString>
-    <DisplayString Condition="valueType==TOK">{tokvalue} (TOK)</DisplayString>
-    <DisplayString Condition="valueType==FLOAT">{floatValue} (FLOAT)</DisplayString>
-    <!--DisplayString Condition="valueType==MOVED">{moveKind}</DisplayString-->    
-  </Type>
-
-
-  <Type Name="Enumerator">
-    <DisplayString Condition="!name">[UNKNOWN]</DisplayString>
-    <DisplayString Condition="value_known">{name} = {value} (value_known=true)</DisplayString>
-    <DisplayString Condition="!value_known">{name} = ?</DisplayString>
-  </Type>
-  
-  
-</AutoVisualizer>
\ No newline at end of file
+<?xml version="1.0" encoding="utf-8"?> 
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+  <Type Name="Token">
+    <DisplayString>{mStr}</DisplayString>
+  </Type>
+
+    <Type Name="TokensFrontBack">
+        <DisplayString>{front->mStr} - {back->mStr}</DisplayString>
+    </Type>
+
+
+    <Type Name="TokenList">
+    <DisplayString>{mTokensFrontBack->front->mStr} - {mTokensFrontBack->back->mStr}</DisplayString>
+    <Expand>
+      <Item Name="[files]">mFiles</Item>
+      <CustomListItems Optional="true" MaxItemsPerView="5000">
+        <Variable Name="pCurr" InitialValue="mTokensFrontBack->front" />
+        <Loop>
+          <If Condition="pCurr == mTokensFrontBack->back">
+            <Break Condition="1"/>
+          </If>
+          <Item>pCurr</Item>
+          <Exec>pCurr = pCurr->mNext</Exec>
+        </Loop>
+      </CustomListItems>
+      
+    </Expand>
+  </Type>
+
+  <Type Name="Variable">
+    <DisplayString>{mNameToken->mStr}</DisplayString>
+  </Type>
+
+  <Type Name="Function">
+    <DisplayString>{tokenDef->mStr}</DisplayString>
+  </Type>
+
+  <Type Name="Dimension">
+    <DisplayString Condition="known">{num}</DisplayString>
+    <DisplayString Condition="!known">?</DisplayString>
+  </Type>
+
+  <Type Name="Scope">
+    <DisplayString>{type}: {className}</DisplayString>
+  </Type>
+
+  <Type Name="cppcheck::Platform">
+    <DisplayString>{platformType}</DisplayString>
+  </Type>
+  
+  <Type Name="simplecpp::Location">
+    <DisplayString>{files[fileIndex]} : {line} [col={col}]</DisplayString>
+  </Type>
+    
+    
+  <Type Name="ValueFlow::Value">
+    <DisplayString Condition="valueType==INT">{intvalue} (INT)</DisplayString>
+    <DisplayString Condition="valueType==TOK">{tokvalue} (TOK)</DisplayString>
+    <DisplayString Condition="valueType==FLOAT">{floatValue} (FLOAT)</DisplayString>
+    <!--DisplayString Condition="valueType==MOVED">{moveKind}</DisplayString-->    
+  </Type>
+
+
+  <Type Name="Enumerator">
+    <DisplayString Condition="!name">[UNKNOWN]</DisplayString>
+    <DisplayString Condition="value_known">{name} = {value} (value_known=true)</DisplayString>
+    <DisplayString Condition="!value_known">{name} = ?</DisplayString>
+  </Type>
+  
+  
+</AutoVisualizer>
diff --git a/lib/cppcheck.vcxproj b/lib/cppcheck.vcxproj
index 833b8cbf9ce..b0e52a814fe 100644
--- a/lib/cppcheck.vcxproj
+++ b/lib/cppcheck.vcxproj
@@ -1,556 +1,422 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug-PCRE|Win32">
-      <Configuration>Debug-PCRE</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug-PCRE|x64">
-      <Configuration>Debug-PCRE</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release-PCRE|Win32">
-      <Configuration>Release-PCRE</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release-PCRE|x64">
-      <Configuration>Release-PCRE</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="..\externals\simplecpp\simplecpp.cpp" />
-    <ClCompile Include="..\externals\tinyxml\tinyxml2.cpp" />
-    <ClCompile Include="analyzerinfo.cpp" />
-    <ClCompile Include="astutils.cpp" />
-    <ClCompile Include="check.cpp">
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|Win32'">Create</PrecompiledHeader>
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|Win32'">Create</PrecompiledHeader>
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">Create</PrecompiledHeader>
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">Create</PrecompiledHeader>
-    </ClCompile>
-    <ClCompile Include="check64bit.cpp" />
-    <ClCompile Include="checkassert.cpp" />
-    <ClCompile Include="checkautovariables.cpp" />
-    <ClCompile Include="checkbool.cpp" />
-    <ClCompile Include="checkboost.cpp" />
-    <ClCompile Include="checkbufferoverrun.cpp" />
-    <ClCompile Include="checkclass.cpp" />
-    <ClCompile Include="checkcondition.cpp" />
-    <ClCompile Include="checkfunctions.cpp" />
-    <ClCompile Include="checkstring.cpp" />
-    <ClCompile Include="checkexceptionsafety.cpp" />
-    <ClCompile Include="checkinternal.cpp" />
-    <ClCompile Include="checkio.cpp" />
-    <ClCompile Include="checkleakautovar.cpp" />
-    <ClCompile Include="checkmemoryleak.cpp" />
-    <ClCompile Include="checknullpointer.cpp" />
-    <ClCompile Include="checkother.cpp" />
-    <ClCompile Include="checkpostfixoperator.cpp" />
-    <ClCompile Include="checksizeof.cpp" />
-    <ClCompile Include="checkstl.cpp" />
-    <ClCompile Include="checktype.cpp" />
-    <ClCompile Include="checkuninitvar.cpp" />
-    <ClCompile Include="checkunusedfunctions.cpp" />
-    <ClCompile Include="checkunusedvar.cpp" />
-    <ClCompile Include="checkvaarg.cpp" />
-    <ClCompile Include="cppcheck.cpp" />
-    <ClCompile Include="ctu.cpp" />
-    <ClCompile Include="errorlogger.cpp" />
-    <ClCompile Include="exprengine.cpp" />
-    <ClCompile Include="library.cpp" />
-    <ClCompile Include="mathlib.cpp" />
-    <ClCompile Include="path.cpp" />
-    <ClCompile Include="pathmatch.cpp" />
-    <ClCompile Include="platform.cpp" />
-    <ClCompile Include="preprocessor.cpp" />
-    <ClCompile Include="importproject.cpp" />
-    <ClCompile Include="settings.cpp" />
-    <ClCompile Include="suppressions.cpp" />
-    <ClCompile Include="symboldatabase.cpp" />
-    <ClCompile Include="templatesimplifier.cpp" />
-    <ClCompile Include="timer.cpp" />
-    <ClCompile Include="token.cpp" />
-    <ClCompile Include="tokenize.cpp" />
-    <ClCompile Include="tokenlist.cpp" />
-    <ClCompile Include="valueflow.cpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="..\externals\simplecpp\simplecpp.h" />
-    <ClInclude Include="..\externals\tinyxml\tinyxml2.h" />
-    <ClInclude Include="analyzerinfo.h" />
-    <ClInclude Include="astutils.h" />
-    <ClInclude Include="check.h" />
-    <ClInclude Include="check64bit.h" />
-    <ClInclude Include="checkassert.h" />
-    <ClInclude Include="checkautovariables.h" />
-    <ClInclude Include="checkbool.h" />
-    <ClInclude Include="checkboost.h" />
-    <ClInclude Include="checkbufferoverrun.h" />
-    <ClInclude Include="checkclass.h" />
-    <ClInclude Include="checkcondition.h" />
-    <ClInclude Include="checkfunctions.h" />
-    <ClInclude Include="checkstring.h" />
-    <ClInclude Include="checkexceptionsafety.h" />
-    <ClInclude Include="checkinternal.h" />
-    <ClInclude Include="checkio.h" />
-    <ClInclude Include="checkleakautovar.h" />
-    <ClInclude Include="checkmemoryleak.h" />
-    <ClInclude Include="checknullpointer.h" />
-    <ClInclude Include="checkother.h" />
-    <ClInclude Include="checkpostfixoperator.h" />
-    <ClInclude Include="checksizeof.h" />
-    <ClInclude Include="checkstl.h" />
-    <ClInclude Include="checktype.h" />
-    <ClInclude Include="checkuninitvar.h" />
-    <ClInclude Include="checkunusedfunctions.h" />
-    <ClInclude Include="checkunusedvar.h" />
-    <ClInclude Include="checkvaarg.h" />
-    <ClInclude Include="config.h" />
-    <ClInclude Include="cppcheck.h" />
-    <ClInclude Include="ctu.h" />
-    <ClInclude Include="errorlogger.h" />
-    <ClInclude Include="library.h" />
-    <ClInclude Include="mathlib.h" />
-    <ClInclude Include="path.h" />
-    <ClInclude Include="pathmatch.h" />
-    <ClInclude Include="platform.h" />
-    <ClInclude Include="preprocessor.h" />
-    <ClInclude Include="importproject.h" />
-    <ClInclude Include="settings.h" />
-    <ClInclude Include="suppressions.h" />
-    <ClInclude Include="symboldatabase.h" />
-    <ClInclude Include="templatesimplifier.h" />
-    <ClInclude Include="timer.h" />
-    <ClInclude Include="token.h" />
-    <ClInclude Include="tokenize.h" />
-    <ClInclude Include="tokenlist.h" />
-    <ClInclude Include="utils.h" />
-    <ClInclude Include="valueflow.h" />
-    <ClInclude Include="version.h" />
-  </ItemGroup>
-  <ItemGroup>
-    <ResourceCompile Include="version.rc" />
-  </ItemGroup>
-  <ItemGroup>
-    <Natvis Include="cppcheck.natvis" />
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{C183DB5B-AD6C-423D-80CA-1F9549555A1A}</ProjectGuid>
-    <RootNamespace>cppcheck_lib</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings" />
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">..\bin\debug\</OutDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|Win32'">..\bin\debug\</OutDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">..\bin\debug\</OutDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">..\bin\debug\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">temp\$(Configuration)_$(PlatformName)\</IntDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|Win32'">temp\$(Configuration)_$(PlatformName)\</IntDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">cppcheck-core</TargetName>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|Win32'">cppcheck-core</TargetName>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">cppcheck-core</TargetName>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">cppcheck-core</TargetName>
-    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</IgnoreImportLibrary>
-    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|Win32'">false</IgnoreImportLibrary>
-    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</IgnoreImportLibrary>
-    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">false</IgnoreImportLibrary>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">..\bin\</OutDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|Win32'">..\bin\</OutDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">..\bin\</OutDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">..\bin\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">temp\$(Configuration)_$(PlatformName)\</IntDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|Win32'">temp\$(Configuration)_$(PlatformName)\</IntDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">cppcheck-core</TargetName>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|Win32'">cppcheck-core</TargetName>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Release|x64'">cppcheck-core</TargetName>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">cppcheck-core</TargetName>
-    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</IgnoreImportLibrary>
-    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|Win32'">false</IgnoreImportLibrary>
-    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</IgnoreImportLibrary>
-    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">false</IgnoreImportLibrary>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|Win32'">true</LinkIncremental>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</LinkIncremental>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">true</LinkIncremental>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>CPPCHECKLIB_EXPORT;TINYXML2_EXPORT;SIMPLECPP_EXPORT;WIN32;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <WarningLevel>Level4</WarningLevel>
-      <AdditionalIncludeDirectories>..\externals;..\externals\simplecpp;..\externals\tinyxml;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <DisableSpecificWarnings>4018;4244;4251;4389;4482;4512;4701</DisableSpecificWarnings>
-      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>check.h</PrecompiledHeaderFile>
-      <ForcedIncludeFiles>check.h</ForcedIncludeFiles>
-      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
-      <LanguageStandard>stdcpplatest</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <IgnoreAllDefaultLibraries>false</IgnoreAllDefaultLibraries>
-      <LargeAddressAware>true</LargeAddressAware>
-      <StackReserveSize>8000000</StackReserveSize>
-      <StackCommitSize>8000000</StackCommitSize>
-    </Link>
-    <PostBuildEvent>
-      <Command>xcopy "$(SolutionDir)cfg" "$(OutDir)cfg" /E /I /D /Y
-xcopy "$(SolutionDir)platforms" "$(OutDir)platforms" /E /I /D /Y</Command>
-    </PostBuildEvent>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|Win32'">
-    <ClCompile>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>CPPCHECKLIB_EXPORT;TINYXML2_EXPORT;SIMPLECPP_EXPORT;WIN32;HAVE_RULES;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;TIXML_USE_STL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <WarningLevel>Level4</WarningLevel>
-      <AdditionalIncludeDirectories>..\externals;..\externals\simplecpp;..\externals\tinyxml;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <DisableSpecificWarnings>4018;4244;4251;4389;4482;4512;4701</DisableSpecificWarnings>
-      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>check.h</PrecompiledHeaderFile>
-      <ForcedIncludeFiles>check.h</ForcedIncludeFiles>
-      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
-      <LanguageStandard>stdcpplatest</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>pcre.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <LargeAddressAware>true</LargeAddressAware>
-      <StackReserveSize>8000000</StackReserveSize>
-      <StackCommitSize>8000000</StackCommitSize>
-    </Link>
-    <PostBuildEvent>
-      <Command>xcopy "$(SolutionDir)cfg" "$(OutDir)cfg" /E /I /D /Y
-xcopy "$(SolutionDir)platforms" "$(OutDir)platforms" /E /I /D /Y</Command>
-    </PostBuildEvent>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <ClCompile>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>CPPCHECKLIB_EXPORT;TINYXML2_EXPORT;SIMPLECPP_EXPORT;WIN32;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;_WIN64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <WarningLevel>Level4</WarningLevel>
-      <AdditionalIncludeDirectories>..\externals;..\externals\simplecpp;..\externals\tinyxml;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <DisableSpecificWarnings>4018;4244;4251;4389;4482;4512;4701</DisableSpecificWarnings>
-      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>check.h</PrecompiledHeaderFile>
-      <ForcedIncludeFiles>check.h</ForcedIncludeFiles>
-      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
-      <LanguageStandard>stdcpplatest</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <StackReserveSize>8000000</StackReserveSize>
-      <StackCommitSize>8000000</StackCommitSize>
-    </Link>
-    <PostBuildEvent>
-      <Command>xcopy "$(SolutionDir)cfg" "$(OutDir)cfg" /E /I /D /Y
-xcopy "$(SolutionDir)platforms" "$(OutDir)platforms" /E /I /D /Y</Command>
-    </PostBuildEvent>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">
-    <ClCompile>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>CPPCHECKLIB_EXPORT;TINYXML2_EXPORT;SIMPLECPP_EXPORT;WIN32;HAVE_RULES;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;_WIN64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <WarningLevel>Level4</WarningLevel>
-      <AdditionalIncludeDirectories>..\externals;..\externals\simplecpp;..\externals\tinyxml;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <DisableSpecificWarnings>4018;4244;4251;4389;4482;4512;4701</DisableSpecificWarnings>
-      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>check.h</PrecompiledHeaderFile>
-      <ForcedIncludeFiles>check.h</ForcedIncludeFiles>
-      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
-      <LanguageStandard>stdcpplatest</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>pcre64.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <StackReserveSize>8000000</StackReserveSize>
-      <StackCommitSize>8000000</StackCommitSize>
-    </Link>
-    <PostBuildEvent>
-      <Command>xcopy "$(SolutionDir)cfg" "$(OutDir)cfg" /E /I /D /Y
-xcopy "$(SolutionDir)platforms" "$(OutDir)platforms" /E /I /D /Y</Command>
-    </PostBuildEvent>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <Optimization>MaxSpeed</Optimization>
-      <WarningLevel>Level4</WarningLevel>
-      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
-      <OmitFramePointers>true</OmitFramePointers>
-      <StringPooling>true</StringPooling>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <AdditionalIncludeDirectories>..\externals;..\externals\simplecpp;..\externals\tinyxml;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <DisableSpecificWarnings>4018;4244;4251;4389;4482;4512;4701</DisableSpecificWarnings>
-      <PreprocessorDefinitions>CPPCHECKLIB_EXPORT;TINYXML2_EXPORT;SIMPLECPP_EXPORT;NDEBUG;WIN32;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-      <DebugInformationFormat>
-      </DebugInformationFormat>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <BufferSecurityCheck>false</BufferSecurityCheck>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>check.h</PrecompiledHeaderFile>
-      <ForcedIncludeFiles>check.h</ForcedIncludeFiles>
-      <AdditionalOptions>/Zc:inline /Zc:throwingNew %(AdditionalOptions)</AdditionalOptions>
-      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
-      <LanguageStandard>stdcpplatest</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <OptimizeReferences>true</OptimizeReferences>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <SetChecksum>true</SetChecksum>
-      <LargeAddressAware>true</LargeAddressAware>
-      <StackReserveSize>8000000</StackReserveSize>
-      <StackCommitSize>8000000</StackCommitSize>
-    </Link>
-    <PostBuildEvent>
-      <Command>xcopy "$(SolutionDir)cfg" "$(OutDir)cfg" /E /I /D /Y
-xcopy "$(SolutionDir)platforms" "$(OutDir)platforms" /E /I /D /Y</Command>
-    </PostBuildEvent>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|Win32'">
-    <ClCompile>
-      <Optimization>MaxSpeed</Optimization>
-      <WarningLevel>Level4</WarningLevel>
-      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
-      <OmitFramePointers>true</OmitFramePointers>
-      <StringPooling>true</StringPooling>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <AdditionalIncludeDirectories>..\externals;..\externals\simplecpp;..\externals\tinyxml;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <DisableSpecificWarnings>4018;4244;4251;4389;4482;4512;4701</DisableSpecificWarnings>
-      <PreprocessorDefinitions>CPPCHECKLIB_EXPORT;TINYXML2_EXPORT;SIMPLECPP_EXPORT;NDEBUG;WIN32;HAVE_RULES;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;TIXML_USE_STL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-      <DebugInformationFormat>
-      </DebugInformationFormat>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <BufferSecurityCheck>false</BufferSecurityCheck>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>check.h</PrecompiledHeaderFile>
-      <ForcedIncludeFiles>check.h</ForcedIncludeFiles>
-      <AdditionalOptions>/Zc:inline /Zc:throwingNew %(AdditionalOptions)</AdditionalOptions>
-      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
-      <LanguageStandard>stdcpplatest</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>pcre.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <OptimizeReferences>true</OptimizeReferences>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <SetChecksum>true</SetChecksum>
-      <LargeAddressAware>true</LargeAddressAware>
-      <StackReserveSize>8000000</StackReserveSize>
-      <StackCommitSize>8000000</StackCommitSize>
-    </Link>
-    <PostBuildEvent>
-      <Command>xcopy "$(SolutionDir)cfg" "$(OutDir)cfg" /E /I /D /Y
-xcopy "$(SolutionDir)platforms" "$(OutDir)platforms" /E /I /D /Y</Command>
-    </PostBuildEvent>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <ClCompile>
-      <Optimization>MaxSpeed</Optimization>
-      <WarningLevel>Level4</WarningLevel>
-      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
-      <OmitFramePointers>true</OmitFramePointers>
-      <StringPooling>true</StringPooling>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <AdditionalIncludeDirectories>..\externals;..\externals\simplecpp;..\externals\tinyxml;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <DisableSpecificWarnings>4018;4244;4251;4389;4482;4512;4701</DisableSpecificWarnings>
-      <PreprocessorDefinitions>CPPCHECKLIB_EXPORT;TINYXML2_EXPORT;SIMPLECPP_EXPORT;NDEBUG;WIN32;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;_WIN64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-      <DebugInformationFormat>
-      </DebugInformationFormat>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <BufferSecurityCheck>false</BufferSecurityCheck>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>check.h</PrecompiledHeaderFile>
-      <ForcedIncludeFiles>check.h</ForcedIncludeFiles>
-      <AdditionalOptions>/Zc:inline /Zc:throwingNew %(AdditionalOptions)</AdditionalOptions>
-      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
-      <LanguageStandard>stdcpplatest</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <OptimizeReferences>true</OptimizeReferences>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <SetChecksum>true</SetChecksum>
-      <StackReserveSize>8000000</StackReserveSize>
-      <StackCommitSize>8000000</StackCommitSize>
-    </Link>
-    <PostBuildEvent>
-      <Command>xcopy "$(SolutionDir)cfg" "$(OutDir)cfg" /E /I /D /Y
-xcopy "$(SolutionDir)platforms" "$(OutDir)platforms" /E /I /D /Y</Command>
-    </PostBuildEvent>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">
-    <ClCompile>
-      <Optimization>MaxSpeed</Optimization>
-      <WarningLevel>Level4</WarningLevel>
-      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
-      <OmitFramePointers>true</OmitFramePointers>
-      <StringPooling>true</StringPooling>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <AdditionalIncludeDirectories>..\externals;..\externals\simplecpp;..\externals\tinyxml;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <DisableSpecificWarnings>4018;4244;4251;4389;4482;4512;4701</DisableSpecificWarnings>
-      <PreprocessorDefinitions>CPPCHECKLIB_EXPORT;TINYXML2_EXPORT;SIMPLECPP_EXPORT;NDEBUG;WIN32;HAVE_RULES;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;_WIN64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-      <DebugInformationFormat>
-      </DebugInformationFormat>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <BufferSecurityCheck>false</BufferSecurityCheck>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>check.h</PrecompiledHeaderFile>
-      <ForcedIncludeFiles>check.h</ForcedIncludeFiles>
-      <AdditionalOptions>/Zc:inline /Zc:throwingNew %(AdditionalOptions)</AdditionalOptions>
-      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
-      <LanguageStandard>stdcpplatest</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>pcre64.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <OptimizeReferences>true</OptimizeReferences>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <SetChecksum>true</SetChecksum>
-      <StackReserveSize>8000000</StackReserveSize>
-      <StackCommitSize>8000000</StackCommitSize>
-    </Link>
-    <PostBuildEvent>
-      <Command>xcopy "$(SolutionDir)cfg" "$(OutDir)cfg" /E /I /D /Y
-xcopy "$(SolutionDir)platforms" "$(OutDir)platforms" /E /I /D /Y</Command>
-    </PostBuildEvent>
-  </ItemDefinitionGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets" />
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug-PCRE|x64">
+      <Configuration>Debug-PCRE</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release-PCRE|x64">
+      <Configuration>Release-PCRE</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup Label="SourceFiles">
+    <ClCompile Include="..\externals\simplecpp\simplecpp.cpp">
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <ForcedIncludeFiles></ForcedIncludeFiles>
+    </ClCompile>
+    <ClCompile Include="..\externals\tinyxml2\tinyxml2.cpp">
+      <PrecompiledHeader>NotUsing</PrecompiledHeader>
+      <ForcedIncludeFiles></ForcedIncludeFiles>
+    </ClCompile>
+    <ClCompile Include="valueflow.cpp" />
+    <ClCompile Include="tokenize.cpp" />
+    <ClCompile Include="symboldatabase.cpp" />
+    <ClCompile Include="addoninfo.cpp" />
+    <ClCompile Include="analyzerinfo.cpp" />
+    <ClCompile Include="astutils.cpp" />
+    <ClCompile Include="check.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="check64bit.cpp" />
+    <ClCompile Include="checkassert.cpp" />
+    <ClCompile Include="checkautovariables.cpp" />
+    <ClCompile Include="checkbool.cpp" />
+    <ClCompile Include="checkbufferoverrun.cpp" />
+    <ClCompile Include="checkclass.cpp" />
+    <ClCompile Include="checkcondition.cpp" />
+    <ClCompile Include="checkers.cpp" />
+    <ClCompile Include="checkersidmapping.cpp" />
+    <ClCompile Include="checkersreport.cpp" />
+    <ClCompile Include="checkexceptionsafety.cpp" />
+    <ClCompile Include="checkfunctions.cpp" />
+    <ClCompile Include="checkinternal.cpp" />
+    <ClCompile Include="checkio.cpp" />
+    <ClCompile Include="checkleakautovar.cpp" />
+    <ClCompile Include="checkmemoryleak.cpp" />
+    <ClCompile Include="checknullpointer.cpp" />
+    <ClCompile Include="checkother.cpp" />
+    <ClCompile Include="checkpostfixoperator.cpp" />
+    <ClCompile Include="checksizeof.cpp" />
+    <ClCompile Include="checkstl.cpp" />
+    <ClCompile Include="checkstring.cpp" />
+    <ClCompile Include="checktype.cpp" />
+    <ClCompile Include="checkuninitvar.cpp" />
+    <ClCompile Include="checkunusedfunctions.cpp" />
+    <ClCompile Include="checkunusedvar.cpp" />
+    <ClCompile Include="checkvaarg.cpp" />
+    <ClCompile Include="clangimport.cpp" />
+    <ClCompile Include="color.cpp" />
+    <ClCompile Include="cppcheck.cpp" />
+    <ClCompile Include="ctu.cpp" />
+    <ClCompile Include="errorlogger.cpp" />
+    <ClCompile Include="errortypes.cpp" />
+    <ClCompile Include="findtoken.cpp" />
+    <ClCompile Include="forwardanalyzer.cpp" />
+    <ClCompile Include="fwdanalysis.cpp" />
+    <ClCompile Include="importproject.cpp" />
+    <ClCompile Include="infer.cpp" />
+    <ClCompile Include="keywords.cpp" />
+    <ClCompile Include="library.cpp" />
+    <ClCompile Include="mathlib.cpp" />
+    <ClCompile Include="path.cpp" />
+    <ClCompile Include="pathanalysis.cpp" />
+    <ClCompile Include="pathmatch.cpp" />
+    <ClCompile Include="platform.cpp" />
+    <ClCompile Include="preprocessor.cpp" />
+    <ClCompile Include="programmemory.cpp" />
+    <ClCompile Include="regex.cpp" />
+    <ClCompile Include="reverseanalyzer.cpp" />
+    <ClCompile Include="sarifreport.cpp" />
+    <ClCompile Include="settings.cpp" />
+    <ClCompile Include="standards.cpp" />
+    <ClCompile Include="summaries.cpp" />
+    <ClCompile Include="suppressions.cpp" />
+    <ClCompile Include="templatesimplifier.cpp" />
+    <ClCompile Include="timer.cpp" />
+    <ClCompile Include="token.cpp" />
+    <ClCompile Include="tokenlist.cpp" />
+    <ClCompile Include="utils.cpp" />
+    <ClCompile Include="vf_analyzers.cpp" />
+    <ClCompile Include="vf_common.cpp" />
+    <ClCompile Include="vf_settokenvalue.cpp" />
+    <ClCompile Include="vfvalue.cpp" />
+  </ItemGroup>
+  <ItemGroup Label="HeaderFiles">
+    <ClInclude Include="..\externals\simplecpp\simplecpp.h" />
+    <ClInclude Include="..\externals\tinyxml2\tinyxml2.h" />
+    <ClInclude Include="addoninfo.h" />
+    <ClInclude Include="analyzer.h" />
+    <ClInclude Include="analyzerinfo.h" />
+    <ClInclude Include="astutils.h" />
+    <ClInclude Include="calculate.h" />
+    <ClInclude Include="check.h" />
+    <ClInclude Include="check64bit.h" />
+    <ClInclude Include="checkassert.h" />
+    <ClInclude Include="checkautovariables.h" />
+    <ClInclude Include="checkbool.h" />
+    <ClInclude Include="checkbufferoverrun.h" />
+    <ClInclude Include="checkclass.h" />
+    <ClInclude Include="checkcondition.h" />
+    <ClInclude Include="checkers.h" />
+    <ClInclude Include="checkersidmapping.h" />
+    <ClInclude Include="checkersreport.h" />
+    <ClInclude Include="checkexceptionsafety.h" />
+    <ClInclude Include="checkfunctions.h" />
+    <ClInclude Include="checkinternal.h" />
+    <ClInclude Include="checkio.h" />
+    <ClInclude Include="checkleakautovar.h" />
+    <ClInclude Include="checkmemoryleak.h" />
+    <ClInclude Include="checknullpointer.h" />
+    <ClInclude Include="checkother.h" />
+    <ClInclude Include="checkpostfixoperator.h" />
+    <ClInclude Include="checksizeof.h" />
+    <ClInclude Include="checkstl.h" />
+    <ClInclude Include="checkstring.h" />
+    <ClInclude Include="checktype.h" />
+    <ClInclude Include="checkuninitvar.h" />
+    <ClInclude Include="checkunusedfunctions.h" />
+    <ClInclude Include="checkunusedvar.h" />
+    <ClInclude Include="checkvaarg.h" />
+    <ClInclude Include="clangimport.h" />
+    <ClInclude Include="color.h" />
+    <ClInclude Include="config.h" />
+    <ClInclude Include="cppcheck.h" />
+    <ClInclude Include="ctu.h" />
+    <ClInclude Include="errorlogger.h" />
+    <ClInclude Include="errortypes.h" />
+    <ClInclude Include="filesettings.h" />
+    <ClInclude Include="findtoken.h" />
+    <ClInclude Include="forwardanalyzer.h" />
+    <ClInclude Include="fwdanalysis.h" />
+    <ClInclude Include="importproject.h" />
+    <ClInclude Include="infer.h" />
+    <ClInclude Include="json.h" />
+    <ClInclude Include="keywords.h" />
+    <ClInclude Include="library.h" />
+    <ClInclude Include="matchcompiler.h" />
+    <ClInclude Include="mathlib.h" />
+    <ClInclude Include="path.h" />
+    <ClInclude Include="pathanalysis.h" />
+    <ClInclude Include="pathmatch.h" />
+    <ClInclude Include="platform.h" />
+    <ClInclude Include="precompiled.h" />
+    <ClInclude Include="preprocessor.h" />
+    <ClInclude Include="programmemory.h" />
+    <ClInclude Include="regex.h" />
+    <ClInclude Include="reverseanalyzer.h" />
+    <ClInclude Include="sarifreport.h" />
+    <ClInclude Include="settings.h" />
+    <ClInclude Include="smallvector.h" />
+    <ClInclude Include="sourcelocation.h" />
+    <ClInclude Include="standards.h" />
+    <ClInclude Include="summaries.h" />
+    <ClInclude Include="suppressions.h" />
+    <ClInclude Include="symboldatabase.h" />
+    <ClInclude Include="templatesimplifier.h" />
+    <ClInclude Include="timer.h" />
+    <ClInclude Include="token.h" />
+    <ClInclude Include="tokenize.h" />
+    <ClInclude Include="tokenlist.h" />
+    <ClInclude Include="tokenrange.h" />
+    <ClInclude Include="utils.h" />
+    <ClInclude Include="valueflow.h" />
+    <ClInclude Include="valueptr.h" />
+    <ClInclude Include="version.h" />
+    <ClInclude Include="vf_analyze.h" />
+    <ClInclude Include="vf_analyzers.h" />
+    <ClInclude Include="vf_common.h" />
+    <ClInclude Include="vf_settokenvalue.h" />
+    <ClInclude Include="vfvalue.h" />
+    <ClInclude Include="xml.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="version.rc" />
+  </ItemGroup>
+  <ItemGroup>
+    <Natvis Include="cppcheck.natvis" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{C183DB5B-AD6C-423D-80CA-1F9549555A1A}</ProjectGuid>
+    <RootNamespace>cppcheck_lib</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings" />
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(SolutionDir)bin\debug\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">$(SolutionDir)bin\debug\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
+    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">cppcheck-core</TargetName>
+    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">cppcheck-core</TargetName>
+    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</IgnoreImportLibrary>
+    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">false</IgnoreImportLibrary>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(SolutionDir)bin\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">$(SolutionDir)bin\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
+    <TargetName Condition="'$(Configuration)|$(Platform)'=='Release|x64'">cppcheck-core</TargetName>
+    <TargetName Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">cppcheck-core</TargetName>
+    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</IgnoreImportLibrary>
+    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">false</IgnoreImportLibrary>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</LinkIncremental>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">true</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>CPPCHECKLIB_EXPORT;TINYXML2_EXPORT;SIMPLECPP_EXPORT;$(HaveBoost);_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <WarningLevel>Level4</WarningLevel>
+      <AdditionalIncludeDirectories>..\externals;..\externals\picojson;..\externals\simplecpp;..\externals\tinyxml2;$(BoostInclude);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <DisableSpecificWarnings>4018;4127;4146;4244;4251;4267;4389;4701;4706;4800;4805</DisableSpecificWarnings>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>precompiled.h</PrecompiledHeaderFile>
+      <ForcedIncludeFiles>precompiled.h</ForcedIncludeFiles>
+      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
+      <LanguageStandard>stdcpp14</LanguageStandard>
+      <AdditionalOptions>/Zc:throwingNew /Zc:__cplusplus %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+    <Link>
+      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <StackReserveSize>8000000</StackReserveSize>
+      <StackCommitSize>8000000</StackCommitSize>
+      <LargeAddressAware>true</LargeAddressAware>
+    </Link>
+    <PostBuildEvent>
+      <Command>xcopy "$(SolutionDir)addons/*.py" "$(OutDir)addons" /E /I /D /Y
+xcopy "$(SolutionDir)addons/*.json" "$(OutDir)addons" /E /I /D /Y
+xcopy "$(SolutionDir)cfg" "$(OutDir)cfg" /E /I /D /Y
+xcopy "$(SolutionDir)platforms" "$(OutDir)platforms" /E /I /D /Y
+if exist "$(OutDir)platforms\unix32-unsigned.xml" del /q "$(OutDir)platforms\unix32-unsigned.xml"
+if exist "$(OutDir)platforms\unix64-unsigned.xml" del /q "$(OutDir)platforms\unix64-unsigned.xml"</Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">
+    <ClCompile>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>CPPCHECKLIB_EXPORT;TINYXML2_EXPORT;SIMPLECPP_EXPORT;$(HaveBoost);HAVE_RULES;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <WarningLevel>Level4</WarningLevel>
+      <AdditionalIncludeDirectories>..\externals;..\externals\picojson;..\externals\simplecpp;..\externals\tinyxml2;$(BoostInclude);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <DisableSpecificWarnings>4018;4127;4146;4244;4251;4267;4389;4701;4706;4800;4805</DisableSpecificWarnings>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>precompiled.h</PrecompiledHeaderFile>
+      <ForcedIncludeFiles>precompiled.h</ForcedIncludeFiles>
+      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
+      <LanguageStandard>stdcpp14</LanguageStandard>
+      <AdditionalOptions>/Zc:throwingNew /Zc:__cplusplus %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>pcre64.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <StackReserveSize>8000000</StackReserveSize>
+      <StackCommitSize>8000000</StackCommitSize>
+      <LargeAddressAware>true</LargeAddressAware>
+    </Link>
+    <PostBuildEvent>
+      <Command>xcopy "$(SolutionDir)addons/*.py" "$(OutDir)addons" /E /I /D /Y
+xcopy "$(SolutionDir)addons/*.json" "$(OutDir)addons" /E /I /D /Y
+xcopy "$(SolutionDir)cfg" "$(OutDir)cfg" /E /I /D /Y
+xcopy "$(SolutionDir)platforms" "$(OutDir)platforms" /E /I /D /Y
+if exist "$(OutDir)platforms\unix32-unsigned.xml" del /q "$(OutDir)platforms\unix32-unsigned.xml"
+if exist "$(OutDir)platforms\unix64-unsigned.xml" del /q "$(OutDir)platforms\unix64-unsigned.xml"</Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <WarningLevel>Level4</WarningLevel>
+      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <StringPooling>true</StringPooling>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <AdditionalIncludeDirectories>..\externals;..\externals\picojson;..\externals\simplecpp;..\externals\tinyxml2;$(BoostInclude);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <DisableSpecificWarnings>4018;4127;4146;4244;4251;4267;4389;4701;4706;4800;4805</DisableSpecificWarnings>
+      <PreprocessorDefinitions>CPPCHECKLIB_EXPORT;TINYXML2_EXPORT;SIMPLECPP_EXPORT;$(HaveBoost);NDEBUG;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>precompiled.h</PrecompiledHeaderFile>
+      <ForcedIncludeFiles>precompiled.h</ForcedIncludeFiles>
+      <AdditionalOptions>/Zc:throwingNew /Zc:__cplusplus %(AdditionalOptions)</AdditionalOptions>
+      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
+      <LanguageStandard>stdcpp14</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <SetChecksum>true</SetChecksum>
+      <StackReserveSize>8000000</StackReserveSize>
+      <StackCommitSize>8000000</StackCommitSize>
+      <LargeAddressAware>true</LargeAddressAware>
+    </Link>
+    <PostBuildEvent>
+      <Command>xcopy "$(SolutionDir)addons/*.py" "$(OutDir)addons" /E /I /D /Y
+xcopy "$(SolutionDir)addons/*.json" "$(OutDir)addons" /E /I /D /Y
+xcopy "$(SolutionDir)cfg" "$(OutDir)cfg" /E /I /D /Y
+xcopy "$(SolutionDir)platforms" "$(OutDir)platforms" /E /I /D /Y
+if exist "$(OutDir)platforms\unix32-unsigned.xml" del /q "$(OutDir)platforms\unix32-unsigned.xml"
+if exist "$(OutDir)platforms\unix64-unsigned.xml" del /q "$(OutDir)platforms\unix64-unsigned.xml"</Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">
+    <ClCompile>
+      <Optimization>MaxSpeed</Optimization>
+      <WarningLevel>Level4</WarningLevel>
+      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <StringPooling>true</StringPooling>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <AdditionalIncludeDirectories>..\externals;..\externals\picojson;..\externals\simplecpp;..\externals\tinyxml2;$(BoostInclude);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <DisableSpecificWarnings>4018;4127;4146;4244;4251;4267;4389;4701;4706;4800;4805</DisableSpecificWarnings>
+      <PreprocessorDefinitions>CPPCHECKLIB_EXPORT;TINYXML2_EXPORT;SIMPLECPP_EXPORT;$(HaveBoost);NDEBUG;HAVE_RULES;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>precompiled.h</PrecompiledHeaderFile>
+      <ForcedIncludeFiles>precompiled.h</ForcedIncludeFiles>
+      <AdditionalOptions>/Zc:throwingNew /Zc:__cplusplus %(AdditionalOptions)</AdditionalOptions>
+      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
+      <LanguageStandard>stdcpp14</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>pcre64.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <SetChecksum>true</SetChecksum>
+      <StackReserveSize>8000000</StackReserveSize>
+      <StackCommitSize>8000000</StackCommitSize>
+      <LargeAddressAware>true</LargeAddressAware>
+    </Link>
+    <PostBuildEvent>
+      <Command>xcopy "$(SolutionDir)addons/*.py" "$(OutDir)addons" /E /I /D /Y
+xcopy "$(SolutionDir)addons/*.json" "$(OutDir)addons" /E /I /D /Y
+xcopy "$(SolutionDir)cfg" "$(OutDir)cfg" /E /I /D /Y
+xcopy "$(SolutionDir)platforms" "$(OutDir)platforms" /E /I /D /Y
+if exist "$(OutDir)platforms\unix32-unsigned.xml" del /q "$(OutDir)platforms\unix32-unsigned.xml"
+if exist "$(OutDir)platforms\unix64-unsigned.xml" del /q "$(OutDir)platforms\unix64-unsigned.xml"</Command>
+    </PostBuildEvent>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets" />
 </Project>
\ No newline at end of file
diff --git a/lib/cppcheck.vcxproj.filters b/lib/cppcheck.vcxproj.filters
index ad964e02b35..249d724fae9 100644
--- a/lib/cppcheck.vcxproj.filters
+++ b/lib/cppcheck.vcxproj.filters
@@ -1,329 +1,498 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
-    </Filter>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="tokenize.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="check64bit.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkautovariables.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkbufferoverrun.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkclass.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkexceptionsafety.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkmemoryleak.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checknullpointer.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkother.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkpostfixoperator.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkstl.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkuninitvar.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkunusedfunctions.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkunusedvar.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="cppcheck.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="errorlogger.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="mathlib.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="path.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="preprocessor.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="settings.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="suppressions.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="symboldatabase.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="timer.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="token.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkboost.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkinternal.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="tokenlist.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkio.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="templatesimplifier.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkleakautovar.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkbool.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checksizeof.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkassert.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="library.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\externals\tinyxml\tinyxml2.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="valueflow.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="check.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkvaarg.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkstring.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkcondition.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checktype.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="astutils.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="checkfunctions.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\externals\simplecpp\simplecpp.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="importproject.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="platform.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="pathmatch.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="analyzerinfo.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="ctu.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="exprengine.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="checkbufferoverrun.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checkclass.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checkexceptionsafety.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checkmemoryleak.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checknullpointer.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checkother.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checkpostfixoperator.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checkstl.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checkuninitvar.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checkunusedfunctions.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checkunusedvar.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="config.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="cppcheck.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="errorlogger.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="mathlib.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="path.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="preprocessor.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="settings.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="suppressions.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="symboldatabase.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="timer.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="token.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="tokenize.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="check.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="check64bit.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checkautovariables.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checkboost.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checkio.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checkinternal.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="tokenlist.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="templatesimplifier.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checkleakautovar.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="version.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checkbool.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checksizeof.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checkassert.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="library.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\externals\tinyxml\tinyxml2.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="valueflow.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checkvaarg.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checkstring.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checkcondition.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checktype.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="astutils.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="utils.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="checkfunctions.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\externals\simplecpp\simplecpp.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="importproject.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="platform.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="pathmatch.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="analyzerinfo.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="ctu.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-  </ItemGroup>
-  <ItemGroup>
-    <ResourceCompile Include="version.rc" />
-  </ItemGroup>
-  <ItemGroup>
-    <Natvis Include="cppcheck.natvis" />
-  </ItemGroup>
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{00a07a33-9811-481c-91aa-46bfba1cda93}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup Label="SourceFiles">
+    <ClCompile Include="tokenize.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="check64bit.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkautovariables.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkbufferoverrun.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkclass.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkexceptionsafety.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkmemoryleak.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checknullpointer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkother.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkpostfixoperator.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkstl.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkuninitvar.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkunusedfunctions.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkunusedvar.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="cppcheck.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="errorlogger.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="errortypes.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="fwdanalysis.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="mathlib.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="path.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="preprocessor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="settings.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="suppressions.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="symboldatabase.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="timer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="token.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkinternal.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="tokenlist.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkio.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="templatesimplifier.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkleakautovar.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkbool.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checksizeof.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkassert.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="library.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\externals\tinyxml2\tinyxml2.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="valueflow.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="check.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkvaarg.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkstring.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkcondition.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checktype.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="astutils.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkfunctions.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\externals\simplecpp\simplecpp.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="importproject.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="platform.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="pathmatch.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="analyzerinfo.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="ctu.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="pathanalysis.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="programmemory.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="clangimport.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="forwardanalyzer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="utils.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="summaries.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="reverseanalyzer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="color.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="infer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="vfvalue.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkersreport.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="keywords.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="addoninfo.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkers.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="checkersidmapping.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="standards.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="vf_analyzers.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="vf_common.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="vf_settokenvalue.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="findtoken.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="regex.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup Label="HeaderFiles">
+    <ClInclude Include="checkbufferoverrun.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkclass.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkexceptionsafety.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkmemoryleak.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checknullpointer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkother.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkpostfixoperator.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkstl.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkuninitvar.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkunusedfunctions.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkunusedvar.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="config.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="cppcheck.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="errorlogger.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="fwdanalysis.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="mathlib.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="path.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="preprocessor.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="settings.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="suppressions.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="symboldatabase.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="timer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="token.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="tokenize.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="check.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="check64bit.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkautovariables.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkio.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkinternal.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="tokenlist.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="templatesimplifier.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkleakautovar.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="version.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkbool.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checksizeof.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkassert.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="library.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\externals\tinyxml2\tinyxml2.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="valueflow.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkvaarg.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkstring.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkcondition.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checktype.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="astutils.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="utils.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkfunctions.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\externals\simplecpp\simplecpp.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="importproject.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="platform.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="pathmatch.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="analyzerinfo.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="ctu.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="clangimport.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="programmemory.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="precompiled.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="summaries.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="tokenrange.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="errortypes.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="color.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="infer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="analyzer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="calculate.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="forwardanalyzer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="pathanalysis.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="reverseanalyzer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="smallvector.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="standards.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="valueptr.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="vfvalue.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="keywords.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkersreport.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="json.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="addoninfo.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkers.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="checkersidmapping.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="filesettings.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="findtoken.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="matchcompiler.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="sourcelocation.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="vf_analyze.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="vf_analyzers.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="vf_common.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="vf_settokenvalue.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="xml.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="regex.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <Natvis Include="cppcheck.natvis">
+      <Filter>Resource Files</Filter>
+    </Natvis>
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="version.rc">
+      <Filter>Resource Files</Filter>
+    </ResourceCompile>
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/lib/ctu.cpp b/lib/ctu.cpp
index 8313cb66a75..938bb2a4dcc 100644
--- a/lib/ctu.cpp
+++ b/lib/ctu.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,41 +19,52 @@
 
 //---------------------------------------------------------------------------
 #include "ctu.h"
+
 #include "astutils.h"
+#include "errortypes.h"
 #include "symboldatabase.h"
-#include <tinyxml2.h>
+#include "token.h"
+#include "tokenize.h"
+#include "tokenlist.h"
+#include "utils.h"
+
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
 #include <iterator>  // back_inserter
+#include <sstream>
+#include <utility>
+
+#include "xml.h"
 //---------------------------------------------------------------------------
 
-static const char ATTR_CALL_ID[] = "call-id";
-static const char ATTR_CALL_FUNCNAME[] = "call-funcname";
-static const char ATTR_CALL_ARGNR[] = "call-argnr";
-static const char ATTR_CALL_ARGEXPR[] = "call-argexpr";
-static const char ATTR_CALL_ARGVALUETYPE[] = "call-argvaluetype";
-static const char ATTR_CALL_ARGVALUE[] = "call-argvalue";
-static const char ATTR_WARNING[] = "warning";
-static const char ATTR_LOC_FILENAME[] = "file";
-static const char ATTR_LOC_LINENR[] = "line";
-static const char ATTR_LOC_COLUMN[] = "col";
-static const char ATTR_INFO[] = "info";
-static const char ATTR_MY_ID[] = "my-id";
-static const char ATTR_MY_ARGNR[] = "my-argnr";
-static const char ATTR_MY_ARGNAME[] = "my-argname";
-static const char ATTR_VALUE[] = "value";
-
-int CTU::maxCtuDepth = 2;
-
-std::string CTU::getFunctionId(const Tokenizer *tokenizer, const Function *function)
+static constexpr char ATTR_CALL_ID[] = "call-id";
+static constexpr char ATTR_CALL_FUNCNAME[] = "call-funcname";
+static constexpr char ATTR_CALL_ARGNR[] = "call-argnr";
+static constexpr char ATTR_CALL_ARGEXPR[] = "call-argexpr";
+static constexpr char ATTR_CALL_ARGVALUETYPE[] = "call-argvaluetype";
+static constexpr char ATTR_CALL_ARGVALUE[] = "call-argvalue";
+static constexpr char ATTR_CALL_UNKNOWN_FUNCTION_RETURN[] = "call-argvalue-ufr";
+static constexpr char ATTR_WARNING[] = "warning";
+static constexpr char ATTR_LOC_FILENAME[] = "file";
+static constexpr char ATTR_LOC_LINENR[] = "line";
+static constexpr char ATTR_LOC_COLUMN[] = "col";
+static constexpr char ATTR_INFO[] = "info";
+static constexpr char ATTR_MY_ID[] = "my-id";
+static constexpr char ATTR_MY_ARGNR[] = "my-argnr";
+static constexpr char ATTR_MY_ARGNAME[] = "my-argname";
+static constexpr char ATTR_VALUE[] = "value";
+
+std::string CTU::getFunctionId(const Tokenizer &tokenizer, const Function *function)
 {
-    return tokenizer->list.file(function->tokenDef) + ':' + MathLib::toString(function->tokenDef->linenr()) + ':' + MathLib::toString(function->tokenDef->column());
+    return tokenizer.list.file(function->tokenDef) + ':' + std::to_string(function->tokenDef->linenr()) + ':' + std::to_string(function->tokenDef->column());
 }
 
-CTU::FileInfo::Location::Location(const Tokenizer *tokenizer, const Token *tok)
-    : fileName(tokenizer->list.file(tok))
+CTU::FileInfo::Location::Location(const Tokenizer &tokenizer, const Token *tok)
+    : fileName(tokenizer.list.file(tok))
     , lineNumber(tok->linenr())
     , column(tok->column())
-{
-}
+{}
 
 std::string CTU::FileInfo::toString() const
 {
@@ -76,9 +87,9 @@ std::string CTU::FileInfo::CallBase::toBaseXmlString() const
 {
     std::ostringstream out;
     out << " " << ATTR_CALL_ID << "=\"" << callId << "\""
-        << " " << ATTR_CALL_FUNCNAME << "=\"" << callFunctionName << "\""
+        << " " << ATTR_CALL_FUNCNAME << "=\"" << ErrorLogger::toxml(callFunctionName) << "\""
         << " " << ATTR_CALL_ARGNR << "=\"" << callArgNr << "\""
-        << " " << ATTR_LOC_FILENAME << "=\"" << location.fileName << "\""
+        << " " << ATTR_LOC_FILENAME << "=\"" << ErrorLogger::toxml(location.fileName) << "\""
         << " " << ATTR_LOC_LINENR << "=\"" << location.lineNumber << "\""
         << " " << ATTR_LOC_COLUMN << "=\"" << location.column << "\"";
     return out.str();
@@ -89,21 +100,22 @@ std::string CTU::FileInfo::FunctionCall::toXmlString() const
     std::ostringstream out;
     out << "<function-call"
         << toBaseXmlString()
-        << " " << ATTR_CALL_ARGEXPR << "=\"" << callArgumentExpression << "\""
-        << " " << ATTR_CALL_ARGVALUETYPE << "=\"" << callValueType << "\""
-        << " " << ATTR_CALL_ARGVALUE << "=\"" << callArgValue << "\"";
+        << " " << ATTR_CALL_ARGEXPR << "=\"" << ErrorLogger::toxml(callArgumentExpression) << "\""
+        << " " << ATTR_CALL_ARGVALUETYPE << "=\"" << static_cast<int>(callValueType) << "\""
+        << " " << ATTR_CALL_ARGVALUE << "=\"" << callArgValue.value << "\""
+        << " " << ATTR_CALL_UNKNOWN_FUNCTION_RETURN << "=\"" << static_cast<int>(callArgValue.unknownFunctionReturn) << "\"";
     if (warning)
         out << " " << ATTR_WARNING << "=\"true\"";
     if (callValuePath.empty())
         out << "/>";
     else {
         out << ">\n";
-        for (const ErrorLogger::ErrorMessage::FileLocation &loc : callValuePath)
+        for (const ErrorMessage::FileLocation &loc : callValuePath)
             out << "  <path"
-                << " " << ATTR_LOC_FILENAME << "=\"" << loc.getfile() << "\""
+                << " " << ATTR_LOC_FILENAME << "=\"" << ErrorLogger::toxml(loc.getfile(false)) << "\""
                 << " " << ATTR_LOC_LINENR << "=\"" << loc.line << "\""
                 << " " << ATTR_LOC_COLUMN << "=\"" << loc.column << "\""
-                << " " << ATTR_INFO << "=\"" << loc.getinfo() << "\"/>\n";
+                << " " << ATTR_INFO << "=\"" << ErrorLogger::toxml(loc.getinfo()) << "\"/>\n";
         out << "</function-call>";
     }
     return out.str();
@@ -127,7 +139,7 @@ std::string CTU::FileInfo::UnsafeUsage::toString() const
         << " " << ATTR_MY_ID << "=\"" << myId << '\"'
         << " " << ATTR_MY_ARGNR << "=\"" << myArgNr << '\"'
         << " " << ATTR_MY_ARGNAME << "=\"" << myArgumentName << '\"'
-        << " " << ATTR_LOC_FILENAME << "=\"" << location.fileName << '\"'
+        << " " << ATTR_LOC_FILENAME << "=\"" << ErrorLogger::toxml(location.fileName) << '\"'
         << " " << ATTR_LOC_LINENR << "=\"" << location.lineNumber << '\"'
         << " " << ATTR_LOC_COLUMN << "=\"" << location.column << '\"'
         << " " << ATTR_VALUE << "=\"" << value << "\""
@@ -143,35 +155,32 @@ std::string CTU::toString(const std::list<CTU::FileInfo::UnsafeUsage> &unsafeUsa
     return ret.str();
 }
 
-CTU::FileInfo::CallBase::CallBase(const Tokenizer *tokenizer, const Token *callToken)
+CTU::FileInfo::CallBase::CallBase(const Tokenizer &tokenizer, const Token *callToken)
     : callId(getFunctionId(tokenizer, callToken->function()))
-    , callArgNr(0)
     , callFunctionName(callToken->next()->astOperand1()->expressionString())
     , location(CTU::FileInfo::Location(tokenizer, callToken))
-{
-}
+{}
 
-CTU::FileInfo::NestedCall::NestedCall(const Tokenizer *tokenizer, const Function *myFunction, const Token *callToken)
+CTU::FileInfo::NestedCall::NestedCall(const Tokenizer &tokenizer, const Function *myFunction, const Token *callToken)
     : CallBase(tokenizer, callToken)
     , myId(getFunctionId(tokenizer, myFunction))
-    , myArgNr(0)
-{
-}
+{}
 
 static std::string readAttrString(const tinyxml2::XMLElement *e, const char *attr, bool *error)
 {
     const char *value = e->Attribute(attr);
     if (!value && error)
         *error = true;
-    return value ? value : "";
+    return empty_if_null(value);
 }
 
 static long long readAttrInt(const tinyxml2::XMLElement *e, const char *attr, bool *error)
 {
-    const char *value = e->Attribute(attr);
-    if (!value && error)
-        *error = true;
-    return value ? std::atoi(value) : 0;
+    int64_t value = 0;
+    const bool err = (e->QueryInt64Attribute(attr, &value) != tinyxml2::XML_SUCCESS);
+    if (error)
+        *error = err;
+    return value;
 }
 
 bool CTU::FileInfo::CallBase::loadBaseFromXml(const tinyxml2::XMLElement *xmlElement)
@@ -192,18 +201,22 @@ bool CTU::FileInfo::FunctionCall::loadFromXml(const tinyxml2::XMLElement *xmlEle
         return false;
     bool error=false;
     callArgumentExpression = readAttrString(xmlElement, ATTR_CALL_ARGEXPR, &error);
-    callValueType = (ValueFlow::Value::ValueType)readAttrInt(xmlElement, ATTR_CALL_ARGVALUETYPE, &error);
-    callArgValue = readAttrInt(xmlElement, ATTR_CALL_ARGVALUE, &error);
+    callValueType = static_cast<ValueFlow::Value::ValueType>(readAttrInt(xmlElement, ATTR_CALL_ARGVALUETYPE, &error));
+    callArgValue.value = readAttrInt(xmlElement, ATTR_CALL_ARGVALUE, &error);
+    const auto ufr = readAttrInt(xmlElement, ATTR_CALL_UNKNOWN_FUNCTION_RETURN, &error);
+    // NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange) - TODO: fix this - #13726
+    callArgValue.unknownFunctionReturn = static_cast<ValueFlow::Value::UnknownFunctionReturn>(ufr>=0 && ufr <=0xff ? ufr : 0xff);
     const char *w = xmlElement->Attribute(ATTR_WARNING);
     warning = w && std::strcmp(w, "true") == 0;
     for (const tinyxml2::XMLElement *e2 = xmlElement->FirstChildElement(); !error && e2; e2 = e2->NextSiblingElement()) {
         if (std::strcmp(e2->Name(), "path") != 0)
             continue;
-        ErrorLogger::ErrorMessage::FileLocation loc;
-        loc.setfile(readAttrString(e2, ATTR_LOC_FILENAME, &error));
-        loc.line = readAttrInt(e2, ATTR_LOC_LINENR, &error);
-        loc.column = readAttrInt(e2, ATTR_LOC_COLUMN, &error);
-        loc.setinfo(readAttrString(e2, ATTR_INFO, &error));
+        std::string file = readAttrString(e2, ATTR_LOC_FILENAME, &error);
+        std::string info = readAttrString(e2, ATTR_INFO, &error);
+        const int line = readAttrInt(e2, ATTR_LOC_LINENR, &error);
+        const int column = readAttrInt(e2, ATTR_LOC_COLUMN, &error);
+        ErrorMessage::FileLocation loc(file, std::move(info), line, column);
+        callValuePath.emplace_back(std::move(loc));
     }
     return !error;
 }
@@ -218,17 +231,19 @@ bool CTU::FileInfo::NestedCall::loadFromXml(const tinyxml2::XMLElement *xmlEleme
     return !error;
 }
 
+// TODO: bail out on unexpected data
 void CTU::FileInfo::loadFromXml(const tinyxml2::XMLElement *xmlElement)
 {
     for (const tinyxml2::XMLElement *e = xmlElement->FirstChildElement(); e; e = e->NextSiblingElement()) {
-        if (std::strcmp(e->Name(), "function-call") == 0) {
+        const char* name = e->Name();
+        if (std::strcmp(name, "function-call") == 0) {
             FunctionCall functionCall;
             if (functionCall.loadFromXml(e))
-                functionCalls.push_back(functionCall);
-        } else if (std::strcmp(e->Name(), "nested-call") == 0) {
+                functionCalls.push_back(std::move(functionCall));
+        } else if (std::strcmp(name, "nested-call") == 0) {
             NestedCall nestedCall;
             if (nestedCall.loadFromXml(e))
-                nestedCalls.push_back(nestedCall);
+                nestedCalls.push_back(std::move(nestedCall));
         }
     }
 }
@@ -260,12 +275,12 @@ std::list<CTU::FileInfo::UnsafeUsage> CTU::loadUnsafeUsageListFromXml(const tiny
         unsafeUsage.value = readAttrInt(e, ATTR_VALUE, &error);
 
         if (!error)
-            ret.push_back(unsafeUsage);
+            ret.push_back(std::move(unsafeUsage));
     }
     return ret;
 }
 
-static int isCallFunction(const Scope *scope, int argnr, const Token **tok)
+static int isCallFunction(const Scope *scope, int argnr, const Token *&tok)
 {
     const Variable * const argvar = scope->function->getArgumentVar(argnr);
     if (!argvar->isPointer())
@@ -288,30 +303,31 @@ static int isCallFunction(const Scope *scope, int argnr, const Token **tok)
             break;
         if (!prev->astOperand1() || !prev->astOperand1()->function())
             break;
-        *tok = prev->previous();
+        tok = prev->previous();
         return argnr2;
     }
     return -1;
 }
 
 
-CTU::FileInfo *CTU::getFileInfo(const Tokenizer *tokenizer)
+CTU::FileInfo *CTU::getFileInfo(const Tokenizer &tokenizer)
 {
-    const SymbolDatabase * const symbolDatabase = tokenizer->getSymbolDatabase();
+    const SymbolDatabase * const symbolDatabase = tokenizer.getSymbolDatabase();
 
-    FileInfo *fileInfo = new FileInfo;
+    auto *fileInfo = new FileInfo;
 
     // Parse all functions in TU
     for (const Scope &scope : symbolDatabase->scopeList) {
-        if (!scope.isExecutable() || scope.type != Scope::eFunction || !scope.function)
+        if (!scope.isExecutable() || scope.type != ScopeType::eFunction || !scope.function)
             continue;
-        const Function *const function = scope.function;
+        const Function *const scopeFunction = scope.function;
 
         // source function calls
         for (const Token *tok = scope.bodyStart; tok != scope.bodyEnd; tok = tok->next()) {
             if (tok->str() != "(" || !tok->astOperand1() || !tok->astOperand2())
                 continue;
-            if (!tok->astOperand1()->function())
+            const Function* tokFunction = tok->astOperand1()->function();
+            if (!tokFunction)
                 continue;
             const std::vector<const Token *> args(getArguments(tok->previous()));
             for (int argnr = 0; argnr < args.size(); ++argnr) {
@@ -326,83 +342,99 @@ CTU::FileInfo *CTU::getFileInfo(const Tokenizer *tokenizer)
                         continue;
                     FileInfo::FunctionCall functionCall;
                     functionCall.callValueType = value.valueType;
-                    functionCall.callId = getFunctionId(tokenizer, tok->astOperand1()->function());
+                    functionCall.callId = getFunctionId(tokenizer, tokFunction);
                     functionCall.callFunctionName = tok->astOperand1()->expressionString();
                     functionCall.location = FileInfo::Location(tokenizer,tok);
                     functionCall.callArgNr = argnr + 1;
                     functionCall.callArgumentExpression = argtok->expressionString();
-                    functionCall.callArgValue = value.intvalue;
+                    functionCall.callArgValue = value;
                     functionCall.warning = !value.errorSeverity();
                     for (const ErrorPathItem &i : value.errorPath) {
-                        ErrorLogger::ErrorMessage::FileLocation loc;
-                        loc.setfile(tokenizer->list.file(i.first));
-                        loc.line = i.first->linenr();
-                        loc.column = i.first->column();
-                        loc.setinfo(i.second);
-                        functionCall.callValuePath.push_back(loc);
+                        const std::string& file = tokenizer.list.file(i.first);
+                        const std::string& info = i.second;
+                        const int line = i.first->linenr();
+                        const int column = i.first->column();
+                        ErrorMessage::FileLocation loc(file, info, line, column);
+                        functionCall.callValuePath.push_back(std::move(loc));
                     }
-                    fileInfo->functionCalls.push_back(functionCall);
+                    fileInfo->functionCalls.push_back(std::move(functionCall));
                 }
                 // array
-                if (argtok->variable() && argtok->variable()->isArray() && argtok->variable()->dimensions().size()==1 && argtok->variable()->dimension(0)>1) {
+                if (argtok->variable() && argtok->variable()->isArray() && argtok->variable()->dimensions().size() == 1 && argtok->variable()->dimensionKnown(0)) {
                     FileInfo::FunctionCall functionCall;
                     functionCall.callValueType = ValueFlow::Value::ValueType::BUFFER_SIZE;
-                    functionCall.callId = getFunctionId(tokenizer, tok->astOperand1()->function());
+                    functionCall.callId = getFunctionId(tokenizer, tokFunction);
                     functionCall.callFunctionName = tok->astOperand1()->expressionString();
                     functionCall.location = FileInfo::Location(tokenizer, tok);
                     functionCall.callArgNr = argnr + 1;
                     functionCall.callArgumentExpression = argtok->expressionString();
-                    functionCall.callArgValue = argtok->variable()->dimension(0) * argtok->valueType()->typeSize(*tokenizer->getSettings());
+                    const auto typeSize = argtok->valueType()->getSizeOf(tokenizer.getSettings(), ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointee);
+                    functionCall.callArgValue.value = typeSize > 0 ? argtok->variable()->dimension(0) * typeSize : -1;
                     functionCall.warning = false;
-                    fileInfo->functionCalls.push_back(functionCall);
+                    fileInfo->functionCalls.push_back(std::move(functionCall));
                 }
                 // &var => buffer
                 if (argtok->isUnaryOp("&") && argtok->astOperand1()->variable() && argtok->astOperand1()->valueType() && !argtok->astOperand1()->variable()->isArray()) {
                     FileInfo::FunctionCall functionCall;
                     functionCall.callValueType = ValueFlow::Value::ValueType::BUFFER_SIZE;
-                    functionCall.callId = getFunctionId(tokenizer, tok->astOperand1()->function());
+                    functionCall.callId = getFunctionId(tokenizer, tokFunction);
                     functionCall.callFunctionName = tok->astOperand1()->expressionString();
                     functionCall.location = FileInfo::Location(tokenizer, tok);
                     functionCall.callArgNr = argnr + 1;
                     functionCall.callArgumentExpression = argtok->expressionString();
-                    functionCall.callArgValue = argtok->astOperand1()->valueType()->typeSize(*tokenizer->getSettings());
+                    functionCall.callArgValue.value = argtok->astOperand1()->valueType()->getSizeOf(tokenizer.getSettings(), ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointee);
                     functionCall.warning = false;
-                    fileInfo->functionCalls.push_back(functionCall);
+                    fileInfo->functionCalls.push_back(std::move(functionCall));
                 }
-                // pointer to uninitialized data..
-                if (!argtok->isUnaryOp("&"))
-                    continue;
-                argtok = argtok->astOperand1();
-                if (!argtok || !argtok->valueType() || argtok->valueType()->pointer != 0)
+                // pointer/reference to uninitialized data
+                auto isAddressOfArg = [](const Token* argtok) -> const Token* {
+                    if (!argtok->isUnaryOp("&"))
+                        return nullptr;
+                    argtok = argtok->astOperand1();
+                    if (!argtok || !argtok->valueType() || argtok->valueType()->pointer != 0)
+                        return nullptr;
+                    return argtok;
+                };
+                auto isReferenceArg = [&](const Token* argtok) -> const Token* {
+                    const Variable* argvar = tokFunction->getArgumentVar(argnr);
+                    if (!argvar || !argvar->valueType() || argvar->valueType()->reference == Reference::None)
+                        return nullptr;
+                    return argtok;
+                };
+                const Token* addr = isAddressOfArg(argtok);
+                argtok = addr ? addr : isReferenceArg(argtok);
+                if (!argtok || argtok->values().size() != 1U)
                     continue;
-                if (argtok->values().size() != 1U)
+                if (argtok->variable() && argtok->variable()->isClass())
                     continue;
+
                 const ValueFlow::Value &v = argtok->values().front();
                 if (v.valueType == ValueFlow::Value::ValueType::UNINIT && !v.isInconclusive()) {
                     FileInfo::FunctionCall functionCall;
                     functionCall.callValueType = ValueFlow::Value::ValueType::UNINIT;
-                    functionCall.callId = getFunctionId(tokenizer, tok->astOperand1()->function());
+                    functionCall.callId = getFunctionId(tokenizer, tokFunction);
                     functionCall.callFunctionName = tok->astOperand1()->expressionString();
                     functionCall.location = FileInfo::Location(tokenizer, tok);
                     functionCall.callArgNr = argnr + 1;
-                    functionCall.callArgValue = 0;
+                    functionCall.callArgValue = v;
+                    functionCall.callArgValue.value = 0;
                     functionCall.callArgumentExpression = argtok->expressionString();
                     functionCall.warning = false;
-                    fileInfo->functionCalls.push_back(functionCall);
+                    fileInfo->functionCalls.push_back(std::move(functionCall));
                     continue;
                 }
             }
         }
 
         // Nested function calls
-        for (int argnr = 0; argnr < function->argCount(); ++argnr) {
+        for (int argnr = 0; argnr < scopeFunction->argCount(); ++argnr) {
             const Token *tok;
-            const int argnr2 = isCallFunction(&scope, argnr, &tok);
+            const int argnr2 = isCallFunction(&scope, argnr, tok);
             if (argnr2 > 0) {
-                FileInfo::NestedCall nestedCall(tokenizer, function, tok);
+                FileInfo::NestedCall nestedCall(tokenizer, scopeFunction, tok);
                 nestedCall.myArgNr = argnr + 1;
                 nestedCall.callArgNr = argnr2;
-                fileInfo->nestedCalls.push_back(nestedCall);
+                fileInfo->nestedCalls.push_back(std::move(nestedCall));
             }
         }
     }
@@ -410,18 +442,21 @@ CTU::FileInfo *CTU::getFileInfo(const Tokenizer *tokenizer)
     return fileInfo;
 }
 
-static std::list<std::pair<const Token *, MathLib::bigint>> getUnsafeFunction(const Tokenizer *tokenizer, const Settings *settings, const Scope *scope, int argnr, const Check *check, bool (*isUnsafeUsage)(const Check *check, const Token *argtok, MathLib::bigint *value))
+static std::vector<std::pair<const Token *, CTU::FileInfo::Value>> getUnsafeFunction(const Settings &settings, const Scope *scope, int argnr, bool (*isUnsafeUsage)(const Settings &settings, const Token *argtok, CTU::FileInfo::Value *value))
 {
-    std::list<std::pair<const Token *, MathLib::bigint>> ret;
+    std::vector<std::pair<const Token *, CTU::FileInfo::Value>> ret;
     const Variable * const argvar = scope->function->getArgumentVar(argnr);
-    if (!argvar->isPointer())
+    if (!argvar->isArrayOrPointer() && !argvar->isReference())
         return ret;
     for (const Token *tok2 = scope->bodyStart; tok2 != scope->bodyEnd; tok2 = tok2->next()) {
         if (Token::Match(tok2, ")|else {")) {
             tok2 = tok2->linkAt(1);
             if (Token::findmatch(tok2->link(), "return|throw", tok2))
                 return ret;
-            if (isVariableChanged(tok2->link(), tok2, argvar->declarationId(), false, settings, tokenizer->isCPP()))
+            int indirect = 0;
+            if (argvar->valueType())
+                indirect = argvar->valueType()->pointer;
+            if (isVariableChanged(tok2->link(), tok2, indirect, argvar->declarationId(), false, settings))
                 return ret;
         }
         if (Token::Match(tok2, "%oror%|&&|?")) {
@@ -430,8 +465,8 @@ static std::list<std::pair<const Token *, MathLib::bigint>> getUnsafeFunction(co
         }
         if (tok2->variable() != argvar)
             continue;
-        MathLib::bigint value = 0;
-        if (!isUnsafeUsage(check, tok2, &value))
+        CTU::FileInfo::Value value;
+        if (!isUnsafeUsage(settings, tok2, &value))
             return ret; // TODO: Is this a read? then continue..
         ret.emplace_back(tok2, value);
         return ret;
@@ -439,24 +474,24 @@ static std::list<std::pair<const Token *, MathLib::bigint>> getUnsafeFunction(co
     return ret;
 }
 
-std::list<CTU::FileInfo::UnsafeUsage> CTU::getUnsafeUsage(const Tokenizer *tokenizer, const Settings *settings, const Check *check, bool (*isUnsafeUsage)(const Check *check, const Token *argtok, MathLib::bigint *_value))
+std::list<CTU::FileInfo::UnsafeUsage> CTU::getUnsafeUsage(const Tokenizer &tokenizer, const Settings &settings, bool (*isUnsafeUsage)(const Settings &settings, const Token *argtok, CTU::FileInfo::Value *value))
 {
     std::list<CTU::FileInfo::UnsafeUsage> unsafeUsage;
 
     // Parse all functions in TU
-    const SymbolDatabase * const symbolDatabase = tokenizer->getSymbolDatabase();
+    const SymbolDatabase * const symbolDatabase = tokenizer.getSymbolDatabase();
 
     for (const Scope &scope : symbolDatabase->scopeList) {
-        if (!scope.isExecutable() || scope.type != Scope::eFunction || !scope.function)
+        if (!scope.isExecutable() || scope.type != ScopeType::eFunction || !scope.function)
             continue;
         const Function *const function = scope.function;
 
         // "Unsafe" functions unconditionally reads data before it is written..
         for (int argnr = 0; argnr < function->argCount(); ++argnr) {
-            for (const std::pair<const Token *, MathLib::bigint> &v : getUnsafeFunction(tokenizer, settings, &scope, argnr, check, isUnsafeUsage)) {
+            for (const std::pair<const Token *, CTU::FileInfo::Value> &v : getUnsafeFunction(settings, &scope, argnr, isUnsafeUsage)) {
                 const Token *tok = v.first;
-                MathLib::bigint value = v.second;
-                unsafeUsage.emplace_back(CTU::getFunctionId(tokenizer, function), argnr+1, tok->str(), CTU::FileInfo::Location(tokenizer,tok), value);
+                const MathLib::bigint val = v.second.value;
+                unsafeUsage.emplace_back(CTU::getFunctionId(tokenizer, function), argnr+1, tok->str(), CTU::FileInfo::Location(tokenizer,tok), val);
             }
         }
     }
@@ -471,12 +506,13 @@ static bool findPath(const std::string &callId,
                      const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>> &callsMap,
                      const CTU::FileInfo::CallBase *path[10],
                      int index,
-                     bool warning)
+                     bool warning,
+                     int maxCtuDepth)
 {
-    if (index >= CTU::maxCtuDepth || index >= 10)
-        return false;
+    if (index >= maxCtuDepth)
+        return false; // TODO: add bailout message?
 
-    const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>>::const_iterator it = callsMap.find(callId);
+    const auto it = callsMap.find(callId);
     if (it == callsMap.end())
         return false;
 
@@ -484,13 +520,15 @@ static bool findPath(const std::string &callId,
         if (c->callArgNr != callArgNr)
             continue;
 
-        const CTU::FileInfo::FunctionCall *functionCall = dynamic_cast<const CTU::FileInfo::FunctionCall *>(c);
+        const auto *functionCall = dynamic_cast<const CTU::FileInfo::FunctionCall *>(c);
         if (functionCall) {
             if (!warning && functionCall->warning)
                 continue;
+            if (!warning && functionCall->callArgValue.unknownFunctionReturn != ValueFlow::Value::UnknownFunctionReturn::no)
+                continue;
             switch (invalidValue) {
             case CTU::FileInfo::InvalidValueType::null:
-                if (functionCall->callValueType != ValueFlow::Value::ValueType::INT || functionCall->callArgValue != 0)
+                if (functionCall->callValueType != ValueFlow::Value::ValueType::INT || functionCall->callArgValue.value != 0)
                     continue;
                 break;
             case CTU::FileInfo::InvalidValueType::uninit:
@@ -500,19 +538,19 @@ static bool findPath(const std::string &callId,
             case CTU::FileInfo::InvalidValueType::bufferOverflow:
                 if (functionCall->callValueType != ValueFlow::Value::ValueType::BUFFER_SIZE)
                     continue;
-                if (unsafeValue < 0 || unsafeValue >= functionCall->callArgValue)
+                if (unsafeValue < 0 || (unsafeValue >= functionCall->callArgValue.value && functionCall->callArgValue.value >= 0))
                     break;
                 continue;
-            };
+            }
             path[index] = functionCall;
             return true;
         }
 
-        const CTU::FileInfo::NestedCall *nestedCall = dynamic_cast<const CTU::FileInfo::NestedCall *>(c);
+        const auto *nestedCall = dynamic_cast<const CTU::FileInfo::NestedCall *>(c);
         if (!nestedCall)
             continue;
 
-        if (findPath(nestedCall->myId, nestedCall->myArgNr, unsafeValue, invalidValue, callsMap, path, index + 1, warning)) {
+        if (findPath(nestedCall->myId, nestedCall->myArgNr, unsafeValue, invalidValue, callsMap, path, index + 1, warning, maxCtuDepth)) {
             path[index] = nestedCall;
             return true;
         }
@@ -521,27 +559,49 @@ static bool findPath(const std::string &callId,
     return false;
 }
 
-std::list<ErrorLogger::ErrorMessage::FileLocation> CTU::FileInfo::getErrorPath(InvalidValueType invalidValue,
-        const CTU::FileInfo::UnsafeUsage &unsafeUsage,
-        const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>> &callsMap,
-        const char info[],
-        const FunctionCall * * const functionCallPtr,
-        bool warning) const
+static std::string getInvalidValueString(CTU::FileInfo::InvalidValueType invalidValue)
 {
-    std::list<ErrorLogger::ErrorMessage::FileLocation> locationList;
+    using InvalidValueType = CTU::FileInfo::InvalidValueType;
+    switch (invalidValue) {
+    case InvalidValueType::null:
+        return "null";
+    case InvalidValueType::uninit:
+        return "uninitialized";
+    case InvalidValueType::bufferOverflow:
+        return "accessed out of bounds";
+    }
+    cppcheck::unreachable();
+}
 
+std::list<ErrorMessage::FileLocation> CTU::FileInfo::getErrorPath(InvalidValueType invalidValue,
+                                                                  const CTU::FileInfo::UnsafeUsage &unsafeUsage,
+                                                                  const std::map<std::string, std::list<const CTU::FileInfo::CallBase *>> &callsMap,
+                                                                  const char info[],
+                                                                  const FunctionCall ** const functionCallPtr,
+                                                                  bool warning,
+                                                                  int maxCtuDepth,
+                                                                  ValueFlow::Value::UnknownFunctionReturn *unknownFunctionReturn)
+{
     const CTU::FileInfo::CallBase *path[10] = {nullptr};
 
-    if (!findPath(unsafeUsage.myId, unsafeUsage.myArgNr, unsafeUsage.value, invalidValue, callsMap, path, 0, warning))
-        return locationList;
+    if (!findPath(unsafeUsage.myId, unsafeUsage.myArgNr, unsafeUsage.value, invalidValue, callsMap, path, 0, warning, maxCtuDepth))
+        return {};
+
+    if (unknownFunctionReturn && path[0]) {
+        const auto* functionCall = dynamic_cast<const CTU::FileInfo::FunctionCall *>(path[0]);
+        if (functionCall)
+            *unknownFunctionReturn = functionCall->callArgValue.unknownFunctionReturn;
+    }
+
+    std::list<ErrorMessage::FileLocation> locationList;
 
-    const std::string value1 = (invalidValue == InvalidValueType::null) ? "null" : "uninitialized";
+    const std::string value1 = getInvalidValueString(invalidValue);
 
     for (int index = 9; index >= 0; index--) {
         if (!path[index])
             continue;
 
-        const CTU::FileInfo::FunctionCall *functionCall = dynamic_cast<const CTU::FileInfo::FunctionCall *>(path[index]);
+        const auto *functionCall = dynamic_cast<const CTU::FileInfo::FunctionCall *>(path[index]);
 
         if (functionCall) {
             if (functionCallPtr)
@@ -549,14 +609,14 @@ std::list<ErrorLogger::ErrorMessage::FileLocation> CTU::FileInfo::getErrorPath(I
             std::copy(functionCall->callValuePath.cbegin(), functionCall->callValuePath.cend(), std::back_inserter(locationList));
         }
 
-        ErrorLogger::ErrorMessage::FileLocation fileLoc(path[index]->location.fileName, path[index]->location.lineNumber, path[index]->location.column);
-        fileLoc.setinfo("Calling function " + path[index]->callFunctionName + ", " + MathLib::toString(path[index]->callArgNr) + getOrdinalText(path[index]->callArgNr) + " argument is " + value1);
-        locationList.push_back(fileLoc);
+        std::string info_s = "Calling function " + path[index]->callFunctionName + ", " + std::to_string(path[index]->callArgNr) + getOrdinalText(path[index]->callArgNr) + " argument is " + value1;
+        ErrorMessage::FileLocation fileLoc(path[index]->location.fileName, std::move(info_s), path[index]->location.lineNumber, path[index]->location.column);
+        locationList.push_back(std::move(fileLoc));
     }
 
-    ErrorLogger::ErrorMessage::FileLocation fileLoc2(unsafeUsage.location.fileName, unsafeUsage.location.lineNumber, unsafeUsage.location.column);
-    fileLoc2.setinfo(replaceStr(info, "ARG", unsafeUsage.myArgumentName));
-    locationList.push_back(fileLoc2);
+    std::string info_s = replaceStr(info, "ARG", unsafeUsage.myArgumentName);
+    ErrorMessage::FileLocation fileLoc2(unsafeUsage.location.fileName, std::move(info_s), unsafeUsage.location.lineNumber, unsafeUsage.location.column);
+    locationList.push_back(std::move(fileLoc2));
 
     return locationList;
 }
diff --git a/lib/ctu.h b/lib/ctu.h
index 63a5e1c77ec..4f5e0b0294c 100644
--- a/lib/ctu.h
+++ b/lib/ctu.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,8 +22,27 @@
 #define ctuH
 //---------------------------------------------------------------------------
 
+#include "config.h"
 #include "check.h"
-#include "valueflow.h"
+#include "errorlogger.h"
+#include "mathlib.h"
+#include "vfvalue.h"
+
+#include <cstdint>
+#include <list>
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+class Function;
+class Settings;
+class Token;
+class Tokenizer;
+
+namespace tinyxml2 {
+    class XMLElement;
+}
 
 /// @addtogroup Core
 /// @{
@@ -33,40 +52,56 @@
 namespace CTU {
     class CPPCHECKLIB FileInfo : public Check::FileInfo {
     public:
-        enum class InvalidValueType { null, uninit, bufferOverflow };
+        enum class InvalidValueType : std::uint8_t { null, uninit, bufferOverflow };
 
-        std::string toString() const OVERRIDE;
+        std::string toString() const override;
 
         struct Location {
             Location() = default;
-            Location(const Tokenizer *tokenizer, const Token *tok);
-            Location(const std::string &fileName, nonneg int lineNumber, nonneg int column) : fileName(fileName), lineNumber(lineNumber), column(column) {}
+            Location(const Tokenizer &tokenizer, const Token *tok);
+            Location(std::string fileName, nonneg int lineNumber, nonneg int column) : fileName(std::move(fileName)), lineNumber(lineNumber), column(column) {}
             std::string fileName;
-            nonneg int lineNumber;
-            nonneg int column;
+            nonneg int lineNumber{};
+            nonneg int column{};
+        };
+
+        struct Value {
+            Value& operator=(const ValueFlow::Value& val) & {
+                value = val.intvalue;
+                unknownFunctionReturn = val.unknownFunctionReturn;
+                return *this;
+            }
+            MathLib::bigint value{};
+            ValueFlow::Value::UnknownFunctionReturn unknownFunctionReturn{};
         };
 
         struct UnsafeUsage {
             UnsafeUsage() = default;
-            UnsafeUsage(const std::string &myId, nonneg int myArgNr, const std::string &myArgumentName, const Location &location, MathLib::bigint value) : myId(myId), myArgNr(myArgNr), myArgumentName(myArgumentName), location(location), value(value) {}
+            UnsafeUsage(std::string myId, nonneg int myArgNr, std::string myArgumentName, Location location, MathLib::bigint value)
+                : myId(std::move(myId))
+                , myArgNr(myArgNr)
+                , myArgumentName(std::move(myArgumentName))
+                , location(std::move(location))
+                , value(value) {}
             std::string myId;
-            nonneg int myArgNr;
+            nonneg int myArgNr{};
             std::string myArgumentName;
             Location location;
-            MathLib::bigint value;
+            MathLib::bigint value{};
             std::string toString() const;
         };
 
         class CallBase {
         public:
             CallBase() = default;
-            CallBase(const std::string &callId, int callArgNr, const std::string &callFunctionName, const Location &loc)
-                : callId(callId), callArgNr(callArgNr), callFunctionName(callFunctionName), location(loc)
+            CallBase(std::string callId, int callArgNr, std::string callFunctionName, Location loc)
+                : callId(std::move(callId)), callArgNr(callArgNr), callFunctionName(std::move(callFunctionName)), location(std::move(loc))
             {}
-            CallBase(const Tokenizer *tokenizer, const Token *callToken);
-            virtual ~CallBase() {}
+            CallBase(const Tokenizer &tokenizer, const Token *callToken);
+            virtual ~CallBase() = default;
+            CallBase(const CallBase&) = default;
             std::string callId;
-            int callArgNr;
+            int callArgNr{};
             std::string callFunctionName;
             Location location;
         protected:
@@ -77,9 +112,9 @@ namespace CTU {
         class FunctionCall : public CallBase {
         public:
             std::string callArgumentExpression;
-            MathLib::bigint callArgValue;
+            Value callArgValue;
             ValueFlow::Value::ValueType callValueType;
-            std::vector<ErrorLogger::ErrorMessage::FileLocation> callValuePath;
+            std::vector<ErrorMessage::FileLocation> callValuePath;
             bool warning;
 
             std::string toXmlString() const;
@@ -90,19 +125,18 @@ namespace CTU {
         public:
             NestedCall() = default;
 
-            NestedCall(const std::string &myId, nonneg int myArgNr, const std::string &callId, nonneg int callArgnr, const std::string &callFunctionName, const Location &location)
+            NestedCall(std::string myId, nonneg int myArgNr, const std::string &callId, nonneg int callArgnr, const std::string &callFunctionName, const Location &location)
                 : CallBase(callId, callArgnr, callFunctionName, location),
-                  myId(myId),
-                  myArgNr(myArgNr) {
-            }
+                myId(std::move(myId)),
+                myArgNr(myArgNr) {}
 
-            NestedCall(const Tokenizer *tokenizer, const Function *myFunction, const Token *callToken);
+            NestedCall(const Tokenizer &tokenizer, const Function *myFunction, const Token *callToken);
 
             std::string toXmlString() const;
             bool loadFromXml(const tinyxml2::XMLElement *xmlElement);
 
             std::string myId;
-            nonneg int myArgNr;
+            nonneg int myArgNr{};
         };
 
         std::list<FunctionCall> functionCalls;
@@ -111,24 +145,24 @@ namespace CTU {
         void loadFromXml(const tinyxml2::XMLElement *xmlElement);
         std::map<std::string, std::list<const CallBase *>> getCallsMap() const;
 
-        std::list<ErrorLogger::ErrorMessage::FileLocation> getErrorPath(InvalidValueType invalidValue,
-                const UnsafeUsage &unsafeUsage,
-                const std::map<std::string, std::list<const CallBase *>> &callsMap,
-                const char info[],
-                const FunctionCall * * const functionCallPtr,
-                bool warning) const;
+        static std::list<ErrorMessage::FileLocation> getErrorPath(InvalidValueType invalidValue,
+                                                                  const UnsafeUsage &unsafeUsage,
+                                                                  const std::map<std::string, std::list<const CallBase *>> &callsMap,
+                                                                  const char info[],
+                                                                  const FunctionCall ** functionCallPtr,
+                                                                  bool warning,
+                                                                  int maxCtuDepth,
+                                                                  ValueFlow::Value::UnknownFunctionReturn *unknownFunctionReturn = nullptr);
     };
 
-    extern int maxCtuDepth;
-
     CPPCHECKLIB std::string toString(const std::list<FileInfo::UnsafeUsage> &unsafeUsage);
 
-    CPPCHECKLIB std::string getFunctionId(const Tokenizer *tokenizer, const Function *function);
+    CPPCHECKLIB std::string getFunctionId(const Tokenizer &tokenizer, const Function *function);
 
     /** @brief Parse current TU and extract file info */
-    CPPCHECKLIB FileInfo *getFileInfo(const Tokenizer *tokenizer);
+    CPPCHECKLIB RET_NONNULL FileInfo *getFileInfo(const Tokenizer &tokenizer);
 
-    CPPCHECKLIB std::list<FileInfo::UnsafeUsage> getUnsafeUsage(const Tokenizer *tokenizer, const Settings *settings, const Check *check, bool (*isUnsafeUsage)(const Check *check, const Token *argtok, MathLib::bigint *value));
+    CPPCHECKLIB std::list<FileInfo::UnsafeUsage> getUnsafeUsage(const Tokenizer &tokenizer, const Settings &settings, bool (*isUnsafeUsage)(const Settings &settings, const Token *argtok, FileInfo::Value *value));
 
     CPPCHECKLIB std::list<FileInfo::UnsafeUsage> loadUnsafeUsageListFromXml(const tinyxml2::XMLElement *xmlElement);
 }
diff --git a/lib/errorlogger.cpp b/lib/errorlogger.cpp
index 781f852b8f6..07332d94fe9 100644
--- a/lib/errorlogger.cpp
+++ b/lib/errorlogger.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,82 +18,83 @@
 
 #include "errorlogger.h"
 
+#include "color.h"
 #include "cppcheck.h"
-#include "mathlib.h"
 #include "path.h"
+#include "settings.h"
+#include "suppressions.h"
 #include "token.h"
 #include "tokenlist.h"
 #include "utils.h"
+#include "checkers.h"
 
-#include <tinyxml2.h>
+#include <algorithm>
 #include <array>
 #include <cassert>
 #include <cctype>
-#include <cstdlib>
 #include <cstring>
+#include <fstream>
 #include <iomanip>
-
-InternalError::InternalError(const Token *tok, const std::string &errorMsg, Type type) :
-    token(tok), errorMessage(errorMsg), type(type)
-{
-    switch (type) {
-    case AST:
-        id = "internalAstError";
-        break;
-    case SYNTAX:
-        id = "syntaxError";
-        break;
-    case UNKNOWN_MACRO:
-        id = "unknownMacro";
-        break;
-    case INTERNAL:
-        id = "cppcheckError";
-        break;
-    case LIMIT:
-        id = "cppcheckLimit";
-        break;
-    case INSTANTIATION:
-        id = "instantiationError";
-        break;
-    }
-}
-
-ErrorLogger::ErrorMessage::ErrorMessage()
-    : severity(Severity::none), cwe(0U), inconclusive(false)
-{
-}
-
-ErrorLogger::ErrorMessage::ErrorMessage(const std::list<FileLocation> &callStack, const std::string& file1, Severity::SeverityType severity, const std::string &msg, const std::string &id, bool inconclusive) :
-    callStack(callStack), // locations for this error message
-    id(id),               // set the message id
-    file0(file1),
+#include <sstream>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+#include "xml.h"
+
+const std::set<std::string> ErrorLogger::mCriticalErrorIds{
+    "cppcheckError",
+    "cppcheckLimit",
+    "includeNestedTooDeeply",
+    "internalAstError",
+    "instantiationError",
+    "internalError",
+    "missingFile",
+    "premium-internalError",
+    "premium-invalidArgument",
+    "premium-invalidLicense",
+    "preprocessorErrorDirective",
+    "syntaxError",
+    "unhandledChar",
+    "unknownMacro"
+};
+
+ErrorMessage::ErrorMessage()
+    : severity(Severity::none), cwe(0U), certainty(Certainty::normal)
+{}
+
+// TODO: id and msg are swapped compared to other calls
+ErrorMessage::ErrorMessage(std::list<FileLocation> callStack, std::string file1, Severity severity, const std::string &msg, std::string id, Certainty certainty) :
+    callStack(std::move(callStack)), // locations for this error message
+    id(std::move(id)),               // set the message id
+    file0(std::move(file1)),
     severity(severity),   // severity for this error message
     cwe(0U),
-    inconclusive(inconclusive)
+    certainty(certainty)
 {
     // set the summary and verbose messages
     setmsg(msg);
 }
 
 
-
-ErrorLogger::ErrorMessage::ErrorMessage(const std::list<FileLocation> &callStack, const std::string& file1, Severity::SeverityType severity, const std::string &msg, const std::string &id, const CWE &cwe, bool inconclusive) :
-    callStack(callStack), // locations for this error message
-    id(id),               // set the message id
-    file0(file1),
+// TODO: id and msg are swapped compared to other calls
+ErrorMessage::ErrorMessage(std::list<FileLocation> callStack, std::string file1, Severity severity, const std::string &msg, std::string id, const CWE &cwe, Certainty certainty) :
+    callStack(std::move(callStack)), // locations for this error message
+    id(std::move(id)),               // set the message id
+    file0(std::move(file1)),
     severity(severity),   // severity for this error message
     cwe(cwe.id),
-    inconclusive(inconclusive)
+    certainty(certainty)
 {
     // set the summary and verbose messages
     setmsg(msg);
 }
 
-ErrorLogger::ErrorMessage::ErrorMessage(const std::list<const Token*>& callstack, const TokenList* list, Severity::SeverityType severity, const std::string& id, const std::string& msg, bool inconclusive)
-    : id(id), severity(severity), cwe(0U), inconclusive(inconclusive)
+ErrorMessage::ErrorMessage(const std::list<const Token*>& callstack, const TokenList* list, Severity severity, std::string id, const std::string& msg, Certainty certainty)
+    : id(std::move(id)), severity(severity), cwe(0U), certainty(certainty)
 {
     // Format callstack
-    for (std::list<const Token *>::const_iterator it = callstack.begin(); it != callstack.end(); ++it) {
+    for (auto it = callstack.cbegin(); it != callstack.cend(); ++it) {
         // --errorlist can provide null values here
         if (!(*it))
             continue;
@@ -108,61 +109,82 @@ ErrorLogger::ErrorMessage::ErrorMessage(const std::list<const Token*>& callstack
 }
 
 
-ErrorLogger::ErrorMessage::ErrorMessage(const std::list<const Token*>& callstack, const TokenList* list, Severity::SeverityType severity, const std::string& id, const std::string& msg, const CWE &cwe, bool inconclusive)
-    : id(id), severity(severity), cwe(cwe.id), inconclusive(inconclusive)
+ErrorMessage::ErrorMessage(const std::list<const Token*>& callstack, const TokenList* list, Severity severity, std::string id, const std::string& msg, const CWE &cwe, Certainty certainty)
+    : id(std::move(id)), severity(severity), cwe(cwe.id), certainty(certainty)
 {
     // Format callstack
-    for (std::list<const Token *>::const_iterator it = callstack.begin(); it != callstack.end(); ++it) {
+    for (const Token *tok: callstack) {
         // --errorlist can provide null values here
-        if (!(*it))
+        if (!tok)
             continue;
 
-        callStack.emplace_back(*it, list);
+        callStack.emplace_back(tok, list);
     }
 
     if (list && !list->getFiles().empty())
         file0 = list->getFiles()[0];
 
     setmsg(msg);
+
+    // hash = calculateWarningHash(list, hashWarning.str());
 }
 
-ErrorLogger::ErrorMessage::ErrorMessage(const ErrorPath &errorPath, const TokenList *tokenList, Severity::SeverityType severity, const char id[], const std::string &msg, const CWE &cwe, bool inconclusive)
-    : id(id), severity(severity), cwe(cwe.id), inconclusive(inconclusive)
+ErrorMessage::ErrorMessage(ErrorPath errorPath, const TokenList *tokenList, Severity severity, const char id[], const std::string &msg, const CWE &cwe, Certainty certainty)
+    : id(id), severity(severity), cwe(cwe.id), certainty(certainty)
 {
     // Format callstack
-    for (ErrorPath::const_iterator it = errorPath.begin(); it != errorPath.end(); ++it) {
-        const Token *tok = it->first;
-        const std::string &info = it->second;
-
+    for (ErrorPathItem& e: errorPath) {
+        const Token *tok = e.first;
         // --errorlist can provide null values here
-        if (tok)
-            callStack.emplace_back(tok, info, tokenList);
+        if (!tok)
+            continue;
+
+        std::string& path_info = e.second;
+
+        std::string info;
+        if (startsWith(path_info,"$symbol:") && path_info.find('\n') < path_info.size()) {
+            const std::string::size_type pos = path_info.find('\n');
+            const std::string symbolName = path_info.substr(8, pos - 8);
+            info = replaceStr(path_info.substr(pos+1), "$symbol", symbolName);
+        }
+        else {
+            info = std::move(path_info);
+        }
+
+        callStack.emplace_back(tok, std::move(info), tokenList);
     }
 
     if (tokenList && !tokenList->getFiles().empty())
         file0 = tokenList->getFiles()[0];
 
     setmsg(msg);
+
+    // hash = calculateWarningHash(tokenList, hashWarning.str());
 }
 
-ErrorLogger::ErrorMessage::ErrorMessage(const tinyxml2::XMLElement * const errmsg)
+// TODO: improve errorhandling?
+ErrorMessage::ErrorMessage(const tinyxml2::XMLElement * const errmsg)
     : severity(Severity::none),
-      cwe(0U),
-      inconclusive(false)
+    cwe(0U),
+    certainty(Certainty::normal)
 {
     const char * const unknown = "<UNKNOWN>";
 
     const char *attr = errmsg->Attribute("id");
     id = attr ? attr : unknown;
 
+    attr = errmsg->Attribute("file0");
+    file0 = attr ? attr : "";
+
     attr = errmsg->Attribute("severity");
-    severity = attr ? Severity::fromString(attr) : Severity::none;
+    severity = attr ? severityFromString(attr) : Severity::none;
 
     attr = errmsg->Attribute("cwe");
-    std::istringstream(attr ? attr : "0") >> cwe.id;
+    // cppcheck-suppress templateInstantiation - TODO: fix this - see #11631
+    cwe.id = attr ? strToInt<unsigned short>(attr) : 0;
 
     attr = errmsg->Attribute("inconclusive");
-    inconclusive = attr && (std::strcmp(attr, "true") == 0);
+    certainty = (attr && (std::strcmp(attr, "true") == 0)) ? Certainty::inconclusive : Certainty::normal;
 
     attr = errmsg->Attribute("msg");
     mShortMessage = attr ? attr : "";
@@ -170,23 +192,33 @@ ErrorLogger::ErrorMessage::ErrorMessage(const tinyxml2::XMLElement * const errms
     attr = errmsg->Attribute("verbose");
     mVerboseMessage = attr ? attr : "";
 
+    attr = errmsg->Attribute("hash");
+    hash = attr ? strToInt<std::size_t>(attr) : 0;
+
     for (const tinyxml2::XMLElement *e = errmsg->FirstChildElement(); e; e = e->NextSiblingElement()) {
-        if (std::strcmp(e->Name(),"location")==0) {
+        const char* name = e->Name();
+        if (std::strcmp(name,"location")==0) {
+            const char *strorigfile = e->Attribute("origfile");
             const char *strfile = e->Attribute("file");
             const char *strinfo = e->Attribute("info");
             const char *strline = e->Attribute("line");
             const char *strcolumn = e->Attribute("column");
 
             const char *file = strfile ? strfile : unknown;
+            const char *origfile = strorigfile ? strorigfile : file;
             const char *info = strinfo ? strinfo : "";
-            const int line = strline ? std::atoi(strline) : 0;
-            const int column = strcolumn ? std::atoi(strcolumn) : 0;
-            callStack.emplace_back(file, info, line, column);
+            const int line = strline ? strToInt<int>(strline) : 0;
+            const int column = strcolumn ? strToInt<int>(strcolumn) : 0;
+            callStack.emplace_front(origfile, info, line, column);
+            if (strorigfile)
+                callStack.front().setfile(file);
+        } else if (std::strcmp(name,"symbol")==0) {
+            mSymbolNames += e->GetText();
         }
     }
 }
 
-void ErrorLogger::ErrorMessage::setmsg(const std::string &msg)
+void ErrorMessage::setmsg(const std::string &msg)
 {
     // If a message ends to a '\n' and contains only a one '\n'
     // it will cause the mVerboseMessage to be empty which will show
@@ -203,7 +235,7 @@ void ErrorLogger::ErrorMessage::setmsg(const std::string &msg)
     if (pos == std::string::npos) {
         mShortMessage = replaceStr(msg, "$symbol", symbolName);
         mVerboseMessage = replaceStr(msg, "$symbol", symbolName);
-    } else if (msg.compare(0,8,"$symbol:") == 0) {
+    } else if (startsWith(msg,"$symbol:")) {
         mSymbolNames += msg.substr(8, pos-7);
         setmsg(msg.substr(pos + 1));
     } else {
@@ -212,111 +244,173 @@ void ErrorLogger::ErrorMessage::setmsg(const std::string &msg)
     }
 }
 
-Suppressions::ErrorMessage ErrorLogger::ErrorMessage::toSuppressionsErrorMessage() const
+static void serializeString(std::string &oss, const std::string & str)
 {
-    Suppressions::ErrorMessage ret;
-    ret.errorId = id;
-    if (!callStack.empty()) {
-        ret.setFileName(callStack.back().getfile(false));
-        ret.lineNumber = callStack.back().line;
-    }
-    ret.inconclusive = inconclusive;
-    ret.symbolNames = mSymbolNames;
-    return ret;
+    oss += std::to_string(str.length());
+    oss += " ";
+    oss += str;
 }
 
+ErrorMessage ErrorMessage::fromInternalError(const InternalError &internalError, const TokenList *tokenList, const std::string &filename, const std::string& msg)
+{
+    if (internalError.token)
+        assert(tokenList != nullptr); // we need to make sure we can look up the provided token
+
+    std::list<ErrorMessage::FileLocation> locationList;
+    if (tokenList && internalError.token) {
+        locationList.emplace_back(internalError.token, tokenList);
+    } else {
+        locationList.emplace_back(filename, 0, 0);
+        if (tokenList && (filename != tokenList->getSourceFilePath())) {
+            locationList.emplace_back(tokenList->getSourceFilePath(), 0, 0);
+        }
+    }
+    ErrorMessage errmsg(std::move(locationList),
+                        tokenList ? tokenList->getSourceFilePath() : filename,
+                        Severity::error,
+                        (msg.empty() ? "" : (msg + ": ")) + internalError.errorMessage,
+                        internalError.id,
+                        Certainty::normal);
+    // TODO: find a better way
+    if (!internalError.details.empty())
+        errmsg.mVerboseMessage = errmsg.mVerboseMessage + ": " + internalError.details;
+    return errmsg;
+}
 
-std::string ErrorLogger::ErrorMessage::serialize() const
+std::string ErrorMessage::serialize() const
 {
     // Serialize this message into a simple string
-    std::ostringstream oss;
-    oss << id.length() << " " << id;
-    oss << Severity::toString(severity).length() << " " << Severity::toString(severity);
-    oss << MathLib::toString(cwe.id).length() << " " << MathLib::toString(cwe.id);
-    if (inconclusive) {
-        const std::string inconclusive("inconclusive");
-        oss << inconclusive.length() << " " << inconclusive;
-    }
+    std::string oss;
+    serializeString(oss, id);
+    serializeString(oss, severityToString(severity));
+    serializeString(oss, std::to_string(cwe.id));
+    serializeString(oss, std::to_string(hash));
+    serializeString(oss, fixInvalidChars(remark));
+    serializeString(oss, file0);
+    serializeString(oss, (certainty == Certainty::inconclusive) ? "1" : "0");
 
     const std::string saneShortMessage = fixInvalidChars(mShortMessage);
     const std::string saneVerboseMessage = fixInvalidChars(mVerboseMessage);
 
-    oss << saneShortMessage.length() << " " << saneShortMessage;
-    oss << saneVerboseMessage.length() << " " << saneVerboseMessage;
-    oss << callStack.size() << " ";
-
-    for (std::list<ErrorLogger::ErrorMessage::FileLocation>::const_iterator loc = callStack.begin(); loc != callStack.end(); ++loc) {
-        std::ostringstream smallStream;
-        smallStream << (*loc).line << '\t' << (*loc).column << '\t' << (*loc).getfile(false) << '\t' << loc->getOrigFile(false) << '\t' << loc->getinfo();
-        oss << smallStream.str().length() << " " << smallStream.str();
+    serializeString(oss, saneShortMessage);
+    serializeString(oss, saneVerboseMessage);
+    serializeString(oss, mSymbolNames);
+    oss += std::to_string(callStack.size());
+    oss += " ";
+
+    for (auto loc = callStack.cbegin(); loc != callStack.cend(); ++loc) {
+        std::string frame;
+        frame += std::to_string(loc->line);
+        frame += '\t';
+        frame += std::to_string(loc->column);
+        frame += '\t';
+        frame += loc->getfile(false);
+        frame += '\t';
+        frame += loc->getOrigFile(false);
+        frame += '\t';
+        frame += loc->getinfo();
+        serializeString(oss, frame);
     }
 
-    return oss.str();
+    return oss;
 }
 
-bool ErrorLogger::ErrorMessage::deserialize(const std::string &data)
+void ErrorMessage::deserialize(const std::string &data)
 {
-    inconclusive = false;
+    // TODO: clear all fields
+    certainty = Certainty::normal;
     callStack.clear();
+
     std::istringstream iss(data);
-    std::array<std::string, 5> results;
+    std::array<std::string, 10> results;
     std::size_t elem = 0;
-    while (iss.good()) {
+    while (iss.good() && elem < 10) {
         unsigned int len = 0;
         if (!(iss >> len))
-            return false;
+            throw InternalError(nullptr, "Internal Error: Deserialization of error message failed - invalid length");
+
+        if (iss.get() != ' ')
+            throw InternalError(nullptr, "Internal Error: Deserialization of error message failed - invalid separator");
+
+        if (!iss.good())
+            throw InternalError(nullptr, "Internal Error: Deserialization of error message failed - premature end of data");
 
-        iss.get();
         std::string temp;
-        for (unsigned int i = 0; i < len && iss.good(); ++i) {
-            const char c = static_cast<char>(iss.get());
-            temp.append(1, c);
-        }
+        if (len > 0) {
+            temp.resize(len);
+            iss.read(&temp[0], len);
 
-        if (temp == "inconclusive") {
-            inconclusive = true;
-            continue;
+            if (!iss.good())
+                throw InternalError(nullptr, "Internal Error: Deserialization of error message failed - premature end of data");
         }
 
-        results[elem++] = temp;
-        if (elem == 5)
-            break;
+        results[elem++] = std::move(temp);
     }
 
-    if (elem != 5)
-        throw InternalError(nullptr, "Internal Error: Deserialization of error message failed");
+    if (!iss.good())
+        throw InternalError(nullptr, "Internal Error: Deserialization of error message failed - premature end of data");
+
+    if (elem != 10)
+        throw InternalError(nullptr, "Internal Error: Deserialization of error message failed - insufficient elements");
 
-    id = results[0];
-    severity = Severity::fromString(results[1]);
-    std::istringstream scwe(results[2]);
-    scwe >> cwe.id;
-    mShortMessage = results[3];
-    mVerboseMessage = results[4];
+    id = std::move(results[0]);
+    severity = severityFromString(results[1]);
+    cwe.id = 0;
+    if (!results[2].empty()) {
+        std::string err;
+        if (!strToInt(results[2], cwe.id, &err))
+            throw InternalError(nullptr, "Internal Error: Deserialization of error message failed - invalid CWE ID - " + err);
+    }
+    hash = 0;
+    if (!results[3].empty()) {
+        std::string err;
+        if (!strToInt(results[3], hash, &err))
+            throw InternalError(nullptr, "Internal Error: Deserialization of error message failed - invalid hash - " + err);
+    }
+    remark = std::move(results[4]);
+    file0 = std::move(results[5]);
+    if (results[6] == "1")
+        certainty = Certainty::inconclusive;
+    mShortMessage = std::move(results[7]);
+    mVerboseMessage = std::move(results[8]);
+    mSymbolNames = std::move(results[9]);
 
     unsigned int stackSize = 0;
     if (!(iss >> stackSize))
-        return false;
+        throw InternalError(nullptr, "Internal Error: Deserialization of error message failed - invalid stack size");
+
+    if (iss.get() != ' ')
+        throw InternalError(nullptr, "Internal Error: Deserialization of error message failed - invalid separator");
+
+    if (stackSize == 0)
+        return;
 
     while (iss.good()) {
         unsigned int len = 0;
         if (!(iss >> len))
-            return false;
+            throw InternalError(nullptr, "Internal Error: Deserialization of error message failed - invalid length (stack)");
+
+        if (iss.get() != ' ')
+            throw InternalError(nullptr, "Internal Error: Deserialization of error message failed - invalid separator (stack)");
 
-        iss.get();
         std::string temp;
-        for (unsigned int i = 0; i < len && iss.good(); ++i) {
-            const char c = static_cast<char>(iss.get());
-            temp.append(1, c);
+        if (len > 0) {
+            temp.resize(len);
+            iss.read(&temp[0], len);
+
+            if (!iss.good())
+                throw InternalError(nullptr, "Internal Error: Deserialization of error message failed - premature end of data (stack)");
         }
 
         std::vector<std::string> substrings;
+        substrings.reserve(5);
         for (std::string::size_type pos = 0; pos < temp.size() && substrings.size() < 5; ++pos) {
             if (substrings.size() == 4) {
                 substrings.push_back(temp.substr(pos));
                 break;
             }
             const std::string::size_type start = pos;
-            pos = temp.find("\t", pos);
+            pos = temp.find('\t', pos);
             if (pos == std::string::npos) {
                 substrings.push_back(temp.substr(start));
                 break;
@@ -324,27 +418,29 @@ bool ErrorLogger::ErrorMessage::deserialize(const std::string &data)
             substrings.push_back(temp.substr(start, pos - start));
         }
         if (substrings.size() < 4)
-            throw InternalError(nullptr, "Internal Error: serializing/deserializing of error message failed!");
+            throw InternalError(nullptr, "Internal Error: Deserializing of error message failed");
 
         // (*loc).line << '\t' << (*loc).column << '\t' << (*loc).getfile(false) << '\t' << loc->getOrigFile(false) << '\t' << loc->getinfo();
 
-        ErrorLogger::ErrorMessage::FileLocation loc(substrings[3], MathLib::toLongNumber(substrings[0]), MathLib::toLongNumber(substrings[1]));
-        loc.setfile(substrings[2]);
+        std::string info;
         if (substrings.size() == 5)
-            loc.setinfo(substrings[4]);
+            info = std::move(substrings[4]);
+        ErrorMessage::FileLocation loc(substrings[3], std::move(info), strToInt<int>(substrings[0]), strToInt<unsigned int>(substrings[1]));
+        loc.setfile(std::move(substrings[2]));
 
-        callStack.push_back(loc);
+        callStack.push_back(std::move(loc));
 
         if (callStack.size() >= stackSize)
             break;
     }
-
-    return true;
 }
 
-std::string ErrorLogger::ErrorMessage::getXMLHeader()
+std::string ErrorMessage::getXMLHeader(std::string productName, int xmlVersion)
 {
-    // xml_version 1 is the default xml format
+    const auto nameAndVersion = Settings::getNameAndVersion(productName);
+    productName = nameAndVersion.first;
+    // TODO: lacks extra version
+    const std::string version = nameAndVersion.first.empty() ? CppCheck::version() : nameAndVersion.second;
 
     tinyxml2::XMLPrinter printer;
 
@@ -354,34 +450,36 @@ std::string ErrorLogger::ErrorMessage::getXMLHeader()
     // header
     printer.OpenElement("results", false);
 
-    printer.PushAttribute("version", 2);
+    printer.PushAttribute("version", xmlVersion);
     printer.OpenElement("cppcheck", false);
-    printer.PushAttribute("version", CppCheck::version());
+    if (!productName.empty())
+        printer.PushAttribute("product-name", productName.c_str());
+    printer.PushAttribute("version", version.c_str());
     printer.CloseElement(false);
     printer.OpenElement("errors", false);
 
     return std::string(printer.CStr()) + '>';
 }
 
-std::string ErrorLogger::ErrorMessage::getXMLFooter()
+std::string ErrorMessage::getXMLFooter(int xmlVersion)
 {
-    return "    </errors>\n</results>";
+    return xmlVersion == 3 ? "</results>" : "    </errors>\n</results>";
 }
 
 // There is no utf-8 support around but the strings should at least be safe for to tinyxml2.
 // See #5300 "Invalid encoding in XML output" and  #6431 "Invalid XML created - Invalid encoding of string literal "
-std::string ErrorLogger::ErrorMessage::fixInvalidChars(const std::string& raw)
+std::string ErrorMessage::fixInvalidChars(const std::string& raw)
 {
     std::string result;
     result.reserve(raw.length());
-    std::string::const_iterator from=raw.begin();
-    while (from!=raw.end()) {
+    auto from=raw.cbegin();
+    while (from!=raw.cend()) {
         if (std::isprint(static_cast<unsigned char>(*from))) {
             result.push_back(*from);
         } else {
             std::ostringstream es;
             // straight cast to (unsigned) doesn't work out.
-            const unsigned uFrom = (unsigned char)*from;
+            const unsigned uFrom = static_cast<unsigned char>(*from);
             es << '\\' << std::setbase(8) << std::setw(3) << std::setfill('0') << uFrom;
             result += es.str();
         }
@@ -390,26 +488,40 @@ std::string ErrorLogger::ErrorMessage::fixInvalidChars(const std::string& raw)
     return result;
 }
 
-std::string ErrorLogger::ErrorMessage::toXML() const
+std::string ErrorMessage::toXML() const
 {
     tinyxml2::XMLPrinter printer(nullptr, false, 2);
     printer.OpenElement("error", false);
     printer.PushAttribute("id", id.c_str());
-    printer.PushAttribute("severity", Severity::toString(severity).c_str());
+    if (!guideline.empty())
+        printer.PushAttribute("guideline", guideline.c_str());
+    printer.PushAttribute("severity", severityToString(severity).c_str());
+    if (!classification.empty())
+        printer.PushAttribute("classification", classification.c_str());
     printer.PushAttribute("msg", fixInvalidChars(mShortMessage).c_str());
     printer.PushAttribute("verbose", fixInvalidChars(mVerboseMessage).c_str());
     if (cwe.id)
         printer.PushAttribute("cwe", cwe.id);
-    if (inconclusive)
+    if (hash)
+        printer.PushAttribute("hash", std::to_string(hash).c_str());
+    if (certainty == Certainty::inconclusive)
         printer.PushAttribute("inconclusive", "true");
 
-    for (std::list<FileLocation>::const_reverse_iterator it = callStack.rbegin(); it != callStack.rend(); ++it) {
+    if (!file0.empty())
+        printer.PushAttribute("file0", file0.c_str());
+
+    if (!remark.empty())
+        printer.PushAttribute("remark", fixInvalidChars(remark).c_str());
+
+    for (auto it = callStack.crbegin(); it != callStack.crend(); ++it) {
         printer.OpenElement("location", false);
-        if (!file0.empty() && (*it).getfile() != file0)
-            printer.PushAttribute("file0", Path::toNativeSeparators(file0).c_str());
-        printer.PushAttribute("file", (*it).getfile().c_str());
-        printer.PushAttribute("line", std::max((*it).line,0));
-        printer.PushAttribute("column", (*it).column);
+        const std::string origfile = it->getOrigFile(false);
+        const std::string file = it->getfile(false);
+        if (origfile != file)
+            printer.PushAttribute("origfile", origfile.c_str());
+        printer.PushAttribute("file", file.c_str());
+        printer.PushAttribute("line", std::max(it->line,0));
+        printer.PushAttribute("column", it->column);
         if (!it->getinfo().empty())
             printer.PushAttribute("info", fixInvalidChars(it->getinfo()).c_str());
         printer.CloseElement(false);
@@ -432,15 +544,6 @@ std::string ErrorLogger::ErrorMessage::toXML() const
     return printer.CStr();
 }
 
-void ErrorLogger::ErrorMessage::findAndReplace(std::string &source, const std::string &searchFor, const std::string &replaceWith)
-{
-    std::string::size_type index = 0;
-    while ((index = source.find(searchFor, index)) != std::string::npos) {
-        source.replace(index, searchFor.length(), replaceWith);
-        index += replaceWith.length();
-    }
-}
-
 // TODO: read info from some shared resource instead?
 static std::string readCode(const std::string &file, int linenr, int column, const char endl[])
 {
@@ -455,53 +558,115 @@ static std::string readCode(const std::string &file, int linenr, int column, con
     std::string::size_type pos = 0;
     while ((pos = line.find('\t', pos)) != std::string::npos)
         line[pos] = ' ';
-    return line + endl + std::string((column>0 ? column-1 : column), ' ') + '^';
+    return line + endl + std::string((column>0 ? column-1 : 0), ' ') + '^';
 }
 
-std::string ErrorLogger::ErrorMessage::toString(bool verbose, const std::string &templateFormat, const std::string &templateLocation) const
+static void replaceSpecialChars(std::string& source)
 {
-    // Save this ErrorMessage in plain text.
+    // Support a few special characters to allow to specific formatting, see http://sourceforge.net/apps/phpbb/cppcheck/viewtopic.php?f=4&t=494&sid=21715d362c0dbafd3791da4d9522f814
+    // Substitution should be done first so messages from cppcheck never get translated.
+    static const std::unordered_map<char, std::string> substitutionMap = {
+        {'b', "\b"},
+        {'n', "\n"},
+        {'r', "\r"},
+        {'t', "\t"}
+    };
+
+    std::string::size_type index = 0;
+    while ((index = source.find('\\', index)) != std::string::npos) {
+        const char searchFor = source[index+1];
+        const auto it = substitutionMap.find(searchFor);
+        if (it == substitutionMap.end()) {
+            index += 1;
+            continue;
+        }
+        const std::string& replaceWith = it->second;
+        source.replace(index, 2, replaceWith);
+        index += replaceWith.length();
+    }
+}
 
-    // No template is given
-    if (templateFormat.empty()) {
-        std::ostringstream text;
-        if (!callStack.empty())
-            text << callStackToString(callStack) << ": ";
-        if (severity != Severity::none) {
-            text << '(' << Severity::toString(severity);
-            if (inconclusive)
-                text << ", inconclusive";
-            text << ") ";
+static void replace(std::string& source, const std::unordered_map<std::string, std::string> &substitutionMap)
+{
+    std::string::size_type index = 0;
+    while ((index = source.find('{', index)) != std::string::npos) {
+        const std::string::size_type end = source.find('}', index);
+        if (end == std::string::npos)
+            break;
+        const std::string searchFor = source.substr(index, end-index+1);
+        const auto it = substitutionMap.find(searchFor);
+        if (it == substitutionMap.end()) {
+            index += 1;
+            continue;
         }
-        text << (verbose ? mVerboseMessage : mShortMessage);
-        return text.str();
+        const std::string& replaceWith = it->second;
+        source.replace(index, searchFor.length(), replaceWith);
+        index += replaceWith.length();
     }
+}
+
+static void replaceColors(std::string& source, bool erase) {
+    // TODO: colors are not applied when either stdout or stderr is not a TTY because we resolve them before the stream usage
+    static const std::unordered_map<std::string, std::string> substitutionMapReplace =
+    {
+        {"{reset}",   ::toString(Color::Reset)},
+        {"{bold}",    ::toString(Color::Bold)},
+        {"{dim}",     ::toString(Color::Dim)},
+        {"{red}",     ::toString(Color::FgRed)},
+        {"{green}",   ::toString(Color::FgGreen)},
+        {"{blue}",    ::toString(Color::FgBlue)},
+        {"{magenta}", ::toString(Color::FgMagenta)},
+        {"{default}", ::toString(Color::FgDefault)},
+    };
+    static const std::unordered_map<std::string, std::string> substitutionMapErase =
+    {
+        {"{reset}",   ""},
+        {"{bold}",    ""},
+        {"{dim}",     ""},
+        {"{red}",     ""},
+        {"{green}",   ""},
+        {"{blue}",    ""},
+        {"{magenta}", ""},
+        {"{default}", ""},
+    };
+    if (!erase)
+        replace(source, substitutionMapReplace);
+    else
+        replace(source, substitutionMapErase);
+}
+
+std::string ErrorMessage::toString(bool verbose, const std::string &templateFormat, const std::string &templateLocation) const
+{
+    assert(!templateFormat.empty());
 
     // template is given. Reformat the output according to it
     std::string result = templateFormat;
-    // Support a few special characters to allow to specific formatting, see http://sourceforge.net/apps/phpbb/cppcheck/viewtopic.php?f=4&t=494&sid=21715d362c0dbafd3791da4d9522f814
-    // Substitution should be done first so messages from cppcheck never get translated.
-    findAndReplace(result, "\\b", "\b");
-    findAndReplace(result, "\\n", "\n");
-    findAndReplace(result, "\\r", "\r");
-    findAndReplace(result, "\\t", "\t");
-
-    findAndReplace(result, "{id}", id);
-    if (result.find("{inconclusive:") != std::string::npos) {
-        const std::string::size_type pos1 = result.find("{inconclusive:");
+
+    // replace id with guideline if present
+    // replace severity with classification if present
+    const std::string idStr = guideline.empty() ? id : guideline;
+    const std::string severityStr = classification.empty() ? severityToString(severity) : classification;
+
+    findAndReplace(result, "{id}", idStr);
+
+    std::string::size_type pos1 = result.find("{inconclusive:");
+    while (pos1 != std::string::npos) {
         const std::string::size_type pos2 = result.find('}', pos1+1);
         const std::string replaceFrom = result.substr(pos1,pos2-pos1+1);
-        const std::string replaceWith = inconclusive ? result.substr(pos1+14, pos2-pos1-14) : std::string();
+        const std::string replaceWith = (certainty == Certainty::inconclusive) ? result.substr(pos1+14, pos2-pos1-14) : std::string();
         findAndReplace(result, replaceFrom, replaceWith);
+        pos1 = result.find("{inconclusive:", pos1);
     }
-    findAndReplace(result, "{severity}", Severity::toString(severity));
-    findAndReplace(result, "{cwe}", MathLib::toString(cwe.id));
+    findAndReplace(result, "{severity}", severityStr);
+    findAndReplace(result, "{cwe}", std::to_string(cwe.id));
     findAndReplace(result, "{message}", verbose ? mVerboseMessage : mShortMessage);
-    findAndReplace(result, "{callstack}", callStack.empty() ? emptyString : callStackToString(callStack));
+    findAndReplace(result, "{remark}", remark);
     if (!callStack.empty()) {
+        if (result.find("{callstack}") != std::string::npos)
+            findAndReplace(result, "{callstack}", ErrorLogger::callStackToString(callStack));
         findAndReplace(result, "{file}", callStack.back().getfile());
-        findAndReplace(result, "{line}", MathLib::toString(callStack.back().line));
-        findAndReplace(result, "{column}", MathLib::toString(callStack.back().column));
+        findAndReplace(result, "{line}", std::to_string(callStack.back().line));
+        findAndReplace(result, "{column}", std::to_string(callStack.back().column));
         if (result.find("{code}") != std::string::npos) {
             const std::string::size_type pos = result.find('\r');
             const char *endl;
@@ -514,24 +679,24 @@ std::string ErrorLogger::ErrorMessage::toString(bool verbose, const std::string
             findAndReplace(result, "{code}", readCode(callStack.back().getOrigFile(), callStack.back().line, callStack.back().column, endl));
         }
     } else {
-        findAndReplace(result, "{file}", "nofile");
-        findAndReplace(result, "{line}", "0");
-        findAndReplace(result, "{column}", "0");
-        findAndReplace(result, "{code}", emptyString);
+        static const std::unordered_map<std::string, std::string> callStackSubstitutionMap =
+        {
+            {"{callstack}",   ""},
+            {"{file}",    "nofile"},
+            {"{line}",     "0"},
+            {"{column}",     "0"},
+            {"{code}",     ""}
+        };
+        replace(result, callStackSubstitutionMap);
     }
 
     if (!templateLocation.empty() && callStack.size() >= 2U) {
         for (const FileLocation &fileLocation : callStack) {
             std::string text = templateLocation;
 
-            findAndReplace(text, "\\b", "\b");
-            findAndReplace(text, "\\n", "\n");
-            findAndReplace(text, "\\r", "\r");
-            findAndReplace(text, "\\t", "\t");
-
             findAndReplace(text, "{file}", fileLocation.getfile());
-            findAndReplace(text, "{line}", MathLib::toString(fileLocation.line));
-            findAndReplace(text, "{column}", MathLib::toString(fileLocation.column));
+            findAndReplace(text, "{line}", std::to_string(fileLocation.line));
+            findAndReplace(text, "{column}", std::to_string(fileLocation.column));
             findAndReplace(text, "{info}", fileLocation.getinfo().empty() ? mShortMessage : fileLocation.getinfo());
             if (text.find("{code}") != std::string::npos) {
                 const std::string::size_type pos = text.find('\r');
@@ -551,119 +716,109 @@ std::string ErrorLogger::ErrorMessage::toString(bool verbose, const std::string
     return result;
 }
 
-bool ErrorLogger::reportUnmatchedSuppressions(const std::list<Suppressions::Suppression> &unmatched)
+std::string ErrorLogger::callStackToString(const std::list<ErrorMessage::FileLocation> &callStack, bool addcolumn)
 {
-    bool err = false;
-    // Report unmatched suppressions
-    for (const Suppressions::Suppression &s : unmatched) {
-        // don't report "unmatchedSuppression" as unmatched
-        if (s.errorId == "unmatchedSuppression")
-            continue;
-
-        // check if this unmatched suppression is suppressed
-        bool suppressed = false;
-        for (const Suppressions::Suppression &s2 : unmatched) {
-            if (s2.errorId == "unmatchedSuppression") {
-                if ((s2.fileName == "*" || s2.fileName == s.fileName) &&
-                    (s2.lineNumber == Suppressions::Suppression::NO_LINE || s2.lineNumber == s.lineNumber)) {
-                    suppressed = true;
-                    break;
-                }
-            }
-        }
-
-        if (suppressed)
-            continue;
-
-        std::list<ErrorLogger::ErrorMessage::FileLocation> callStack;
-        if (!s.fileName.empty())
-            callStack.emplace_back(s.fileName, s.lineNumber, 0);
-        reportErr(ErrorLogger::ErrorMessage(callStack, emptyString, Severity::information, "Unmatched suppression: " + s.errorId, "unmatchedSuppression", false));
-        err = true;
+    std::string str;
+    for (auto tok = callStack.cbegin(); tok != callStack.cend(); ++tok) {
+        str += (tok == callStack.cbegin() ? "" : " -> ");
+        str += tok->stringify(addcolumn);
     }
-    return err;
+    return str;
 }
 
-std::string ErrorLogger::callStackToString(const std::list<ErrorLogger::ErrorMessage::FileLocation> &callStack)
-{
-    std::ostringstream ostr;
-    for (std::list<ErrorLogger::ErrorMessage::FileLocation>::const_iterator tok = callStack.begin(); tok != callStack.end(); ++tok) {
-        ostr << (tok == callStack.begin() ? "" : " -> ") << tok->stringify();
-    }
-    return ostr.str();
-}
+ErrorMessage::FileLocation::FileLocation(const std::string &file, int line, unsigned int column)
+    : fileIndex(0), line(line), column(column), mOrigFileName(file), mFileName(Path::simplifyPath(file))
+{}
 
+ErrorMessage::FileLocation::FileLocation(const std::string &file, std::string info, int line, unsigned int column)
+    : fileIndex(0), line(line), column(column), mOrigFileName(file), mFileName(Path::simplifyPath(file)), mInfo(std::move(info))
+{}
 
-ErrorLogger::ErrorMessage::FileLocation::FileLocation(const Token* tok, const TokenList* tokenList)
-    : fileIndex(tok->fileIndex()), line(tok->linenr()), column(tok->column()), mOrigFileName(tokenList->getOrigFile(tok)), mFileName(tokenList->file(tok))
-{
-}
+ErrorMessage::FileLocation::FileLocation(const Token* tok, const TokenList* tokenList)
+    : fileIndex(tok->fileIndex()), line(tok->linenr()), column(tok->column()), mOrigFileName(tokenList->getOrigFile(tok)), mFileName(Path::simplifyPath(tokenList->file(tok)))
+{}
 
-ErrorLogger::ErrorMessage::FileLocation::FileLocation(const Token* tok, const std::string &info, const TokenList* tokenList)
-    : fileIndex(tok->fileIndex()), line(tok->linenr()), column(tok->column()), mOrigFileName(tokenList->getOrigFile(tok)), mFileName(tokenList->file(tok)), mInfo(info)
-{
-}
+ErrorMessage::FileLocation::FileLocation(const Token* tok, std::string info, const TokenList* tokenList)
+    : fileIndex(tok->fileIndex()), line(tok->linenr()), column(tok->column()), mOrigFileName(tokenList->getOrigFile(tok)), mFileName(Path::simplifyPath(tokenList->file(tok))), mInfo(std::move(info))
+{}
 
-std::string ErrorLogger::ErrorMessage::FileLocation::getfile(bool convert) const
+std::string ErrorMessage::FileLocation::getfile(bool convert) const
 {
     if (convert)
         return Path::toNativeSeparators(mFileName);
     return mFileName;
 }
 
-std::string ErrorLogger::ErrorMessage::FileLocation::getOrigFile(bool convert) const
+std::string ErrorMessage::FileLocation::getOrigFile(bool convert) const
 {
     if (convert)
         return Path::toNativeSeparators(mOrigFileName);
     return mOrigFileName;
 }
 
-void ErrorLogger::ErrorMessage::FileLocation::setfile(const std::string &file)
+void ErrorMessage::FileLocation::setfile(std::string file)
 {
-    mFileName = file;
-    mFileName = Path::fromNativeSeparators(mFileName);
-    mFileName = Path::simplifyPath(mFileName);
+    mFileName = Path::simplifyPath(std::move(file));
 }
 
-std::string ErrorLogger::ErrorMessage::FileLocation::stringify() const
+std::string ErrorMessage::FileLocation::stringify(bool addcolumn) const
 {
-    std::ostringstream oss;
-    oss << '[' << Path::toNativeSeparators(mFileName);
-    if (line != Suppressions::Suppression::NO_LINE)
-        oss << ':' << line;
-    oss << ']';
-    return oss.str();
+    std::string str;
+    str += '[';
+    str += Path::toNativeSeparators(mFileName);
+    if (line != SuppressionList::Suppression::NO_LINE) { // TODO: should not depend on Suppression
+        str += ':';
+        str += std::to_string(line);
+        if (addcolumn) {
+            str += ':';
+            str += std::to_string(column);
+        }
+    }
+    str += ']';
+    return str;
 }
 
 std::string ErrorLogger::toxml(const std::string &str)
 {
-    std::ostringstream xml;
-    for (unsigned char c : str) {
+    std::string xml;
+    for (const unsigned char c : str) {
         switch (c) {
         case '<':
-            xml << "&lt;";
+            xml += "&lt;";
             break;
         case '>':
-            xml << "&gt;";
+            xml += "&gt;";
             break;
         case '&':
-            xml << "&amp;";
+            xml += "&amp;";
             break;
         case '\"':
-            xml << "&quot;";
+            xml += "&quot;";
+            break;
+        case '\'':
+            xml += "&apos;";
             break;
         case '\0':
-            xml << "\\0";
+            xml += "\\0";
+            break;
+        case '\n':
+            xml += "&#10;";
+            break;
+        case '\t':
+            xml += "&#09;";
+            break;
+        case '\r':
+            xml += "&#13;";
             break;
         default:
             if (c >= ' ' && c <= 0x7f)
-                xml << c;
+                xml += c;
             else
-                xml << 'x';
+                xml += 'x';
             break;
         }
     }
-    return xml.str();
+    return xml;
 }
 
 std::string ErrorLogger::plistHeader(const std::string &version, const std::vector<std::string> &files)
@@ -679,13 +834,13 @@ std::string ErrorLogger::plistHeader(const std::string &version, const std::vect
          << " <array>\r\n";
     for (const std::string & file : files)
         ostr << "  <string>" << ErrorLogger::toxml(file) << "</string>\r\n";
-    ostr       << " </array>\r\n"
-               << " <key>diagnostics</key>\r\n"
-               << " <array>\r\n";
+    ostr << " </array>\r\n"
+         << " <key>diagnostics</key>\r\n"
+         << " <array>\r\n";
     return ostr.str();
 }
 
-static std::string plistLoc(const char indent[], const ErrorLogger::ErrorMessage::FileLocation &loc)
+static std::string plistLoc(const char indent[], const ErrorMessage::FileLocation &loc)
 {
     std::ostringstream ostr;
     ostr << indent << "<dict>\r\n"
@@ -696,16 +851,16 @@ static std::string plistLoc(const char indent[], const ErrorLogger::ErrorMessage
     return ostr.str();
 }
 
-std::string ErrorLogger::plistData(const ErrorLogger::ErrorMessage &msg)
+std::string ErrorLogger::plistData(const ErrorMessage &msg)
 {
     std::ostringstream plist;
     plist << "  <dict>\r\n"
           << "   <key>path</key>\r\n"
           << "   <array>\r\n";
 
-    std::list<ErrorLogger::ErrorMessage::FileLocation>::const_iterator prev = msg.callStack.begin();
+    auto prev = msg.callStack.cbegin();
 
-    for (std::list<ErrorLogger::ErrorMessage::FileLocation>::const_iterator it = msg.callStack.begin(); it != msg.callStack.end(); ++it) {
+    for (auto it = msg.callStack.cbegin(); it != msg.callStack.cend(); ++it) {
         if (prev != it) {
             plist << "    <dict>\r\n"
                   << "     <key>kind</key><string>control</string>\r\n"
@@ -728,9 +883,9 @@ std::string ErrorLogger::plistData(const ErrorLogger::ErrorMessage &msg)
             prev = it;
         }
 
-        std::list<ErrorLogger::ErrorMessage::FileLocation>::const_iterator next = it;
+        auto next = it;
         ++next;
-        const std::string message = (it->getinfo().empty() && next == msg.callStack.end() ? msg.shortMessage() : it->getinfo());
+        const std::string message = (it->getinfo().empty() && next == msg.callStack.cend() ? msg.shortMessage() : it->getinfo());
 
         plist << "    <dict>\r\n"
               << "     <key>kind</key><string>event</string>\r\n"
@@ -753,7 +908,7 @@ std::string ErrorLogger::plistData(const ErrorLogger::ErrorMessage &msg)
 
     plist << "   </array>\r\n"
           << "   <key>description</key><string>" << ErrorLogger::toxml(msg.shortMessage()) << "</string>\r\n"
-          << "   <key>category</key><string>" << Severity::toString(msg.severity) << "</string>\r\n"
+          << "   <key>category</key><string>" << severityToString(msg.severity) << "</string>\r\n"
           << "   <key>type</key><string>" << ErrorLogger::toxml(msg.shortMessage()) << "</string>\r\n"
           << "   <key>check_name</key><string>" << msg.id << "</string>\r\n"
           << "   <!-- This hash is experimental and going to change! -->\r\n"
@@ -786,8 +941,225 @@ std::string replaceStr(std::string s, const std::string &from, const std::string
             pos1++;
             continue;
         }
-        s = s.substr(0,pos1) + to + s.substr(pos2);
+        s.replace(pos1, from.size(), to);
         pos1 += to.size();
     }
     return s;
 }
+
+void substituteTemplateFormatStatic(std::string& templateFormat, bool eraseColors)
+{
+    replaceSpecialChars(templateFormat);
+    replaceColors(templateFormat, eraseColors);
+}
+
+void substituteTemplateLocationStatic(std::string& templateLocation, bool eraseColors)
+{
+    replaceSpecialChars(templateLocation);
+    replaceColors(templateLocation, eraseColors);
+}
+
+std::string getClassification(const std::string &guideline, ReportType reportType) {
+    if (guideline.empty())
+        return "";
+
+    const auto getClassification = [](const std::vector<checkers::Info> &info, const std::string &guideline) -> std::string {
+        const auto it = std::find_if(info.cbegin(), info.cend(), [&](const checkers::Info &i) {
+            return caseInsensitiveStringCompare(i.guideline, guideline) == 0;
+        });
+        if (it == info.cend())
+            return "";
+        return it->classification;
+    };
+
+    switch (reportType) {
+    case ReportType::autosar:
+        return getClassification(checkers::autosarInfo, guideline);
+    case ReportType::certC:
+        return getClassification(checkers::certCInfo, guideline);
+    case ReportType::certCpp:
+        return getClassification(checkers::certCppInfo, guideline);
+    case ReportType::misraC2012:
+    case ReportType::misraC2023:
+    case ReportType::misraC2025:
+    {
+        const bool isDirective = guideline.rfind("Dir ", 0) == 0;
+
+        const std::size_t offset = isDirective ? 4 : 0;
+        auto components = splitString(guideline.substr(offset), '.');
+        if (components.size() != 2)
+            return "";
+
+        const int a = std::stoi(components[0]);
+        const int b = std::stoi(components[1]);
+
+        const std::vector<checkers::MisraInfo> *info = nullptr;
+        switch (reportType) {
+        case ReportType::misraC2012:
+            info = isDirective ? &checkers::misraC2012Directives : &checkers::misraC2012Rules;
+            break;
+        case ReportType::misraC2023:
+            info = isDirective ? &checkers::misraC2023Directives : &checkers::misraC2023Rules;
+            break;
+        case ReportType::misraC2025:
+            info = isDirective ? &checkers::misraC2025Directives : &checkers::misraC2025Rules;
+            break;
+        default:
+            cppcheck::unreachable();
+        }
+
+        const auto it = std::find_if(info->cbegin(), info->cend(), [&](const checkers::MisraInfo &i) {
+                return i.a == a && i.b == b;
+            });
+
+        return it == info->cend() ? "" : it->str;
+    }
+    case ReportType::misraCpp2008:
+    case ReportType::misraCpp2023:
+    {
+        const std::vector<checkers::MisraCppInfo> *info;
+        std::vector<std::string> components;
+
+        if (reportType == ReportType::misraCpp2008) {
+            info = &checkers::misraCpp2008Rules;
+            components = splitString(guideline, '-');
+        } else {
+            if (guideline.rfind("Dir ", 0) == 0) {
+                components = splitString(guideline.substr(4), '.');
+                info = &checkers::misraCpp2023Directives;
+            } else {
+                components = splitString(guideline, '.');
+                info = &checkers::misraCpp2023Rules;
+            }
+        }
+
+        if (components.size() != 3)
+            return "";
+
+        const int a = std::stoi(components[0]);
+        const int b = std::stoi(components[1]);
+        const int c = std::stoi(components[2]);
+
+        const auto it = std::find_if(info->cbegin(), info->cend(), [&](const checkers::MisraCppInfo &i) {
+                return i.a == a && i.b == b && i.c == c;
+            });
+
+        if (it == info->cend())
+            return "";
+
+        return it->classification;
+    }
+    default:
+        return "";
+    }
+}
+
+std::string getGuideline(const std::string &errId, ReportType reportType,
+                         const std::map<std::string, std::string> &guidelineMapping,
+                         Severity severity)
+{
+    std::string guideline;
+
+    switch (reportType) {
+    case ReportType::autosar:
+        if (errId.rfind("premium-autosar-", 0) == 0) {
+            guideline = errId.substr(16);
+            break;
+        }
+        if (errId.rfind("premium-misra-cpp-2008-", 0) == 0)
+            guideline = "M" + errId.substr(23);
+        break;
+    case ReportType::certC:
+    case ReportType::certCpp:
+        if (errId.rfind("premium-cert-", 0) == 0) {
+            guideline = errId.substr(13);
+            std::transform(guideline.begin(), guideline.end(),
+                           guideline.begin(), static_cast<int (*)(int)>(std::toupper));
+        }
+        break;
+    case ReportType::misraC2012:
+    case ReportType::misraC2023:
+    case ReportType::misraC2025:
+        if (errId.rfind("misra-c20", 0) == 0 || errId.rfind("premium-misra-c-20", 0) == 0)
+            guideline = errId.substr(errId.rfind('-') + 1);
+        break;
+    case ReportType::misraCpp2008:
+        if (errId.rfind("premium-misra-cpp-2008", 0) == 0)
+            guideline = errId.substr(23);
+        break;
+    case ReportType::misraCpp2023:
+        if (errId.rfind("premium-misra-cpp-2023", 0) == 0)
+            guideline = errId.substr(errId.rfind('-') + 1);
+        break;
+    default:
+        break;
+    }
+
+    if (!guideline.empty()) {
+        if (errId.find("-dir-") != std::string::npos)
+            guideline = "Dir " + guideline;
+        return guideline;
+    }
+
+    auto it = guidelineMapping.find(errId);
+
+    if (it != guidelineMapping.cend())
+        return it->second;
+
+    if (severity == Severity::error || severity == Severity::warning) {
+        it = guidelineMapping.find("error");
+
+        if (it != guidelineMapping.cend())
+            return it->second;
+    }
+
+    return "";
+}
+
+std::map<std::string, std::string> createGuidelineMapping(ReportType reportType) {
+    std::map<std::string, std::string> guidelineMapping;
+    const std::vector<checkers::IdMapping> *idMapping1 = nullptr;
+    const std::vector<checkers::IdMapping> *idMapping2 = nullptr;
+    std::string ext1, ext2;
+
+    switch (reportType) {
+    case ReportType::autosar:
+        idMapping1 = &checkers::idMappingAutosar;
+        break;
+    case ReportType::certCpp:
+        idMapping2 = &checkers::idMappingCertCpp;
+        ext2 = "-CPP";
+        FALLTHROUGH;
+    case ReportType::certC:
+        idMapping1 = &checkers::idMappingCertC;
+        ext1 = "-C";
+        break;
+    case ReportType::misraC2012:
+    case ReportType::misraC2023:
+    case ReportType::misraC2025:
+        idMapping1 = &checkers::idMappingMisraC;
+        break;
+    case ReportType::misraCpp2008:
+        idMapping1 = &checkers::idMappingMisraCpp2008;
+        break;
+    case ReportType::misraCpp2023:
+        idMapping1 = &checkers::idMappingMisraCpp2023;
+        break;
+    default:
+        break;
+    }
+
+    if (idMapping1) {
+        for (const auto &i : *idMapping1)
+            for (const std::string &cppcheckId : splitString(i.cppcheckId, ','))
+                guidelineMapping[cppcheckId] = i.guideline + ext1;
+    }
+
+    if (idMapping2) {
+        for (const auto &i : *idMapping2)
+            for (const std::string &cppcheckId : splitString(i.cppcheckId, ','))
+                guidelineMapping[cppcheckId] = i.guideline + ext2;
+    }
+
+    return guidelineMapping;
+}
diff --git a/lib/errorlogger.h b/lib/errorlogger.h
index c442c8620e5..a6f2a8ebdfb 100644
--- a/lib/errorlogger.h
+++ b/lib/errorlogger.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,28 +22,21 @@
 //---------------------------------------------------------------------------
 
 #include "config.h"
-#include "suppressions.h"
+#include "errortypes.h"
 
-#include <cstddef>
-#include <fstream>
+#include <cstdint>
+#include <ctime>
 #include <list>
+#include <set>
 #include <string>
 #include <utility>
 #include <vector>
-
-/**
- * CWE id (Common Weakness Enumeration)
- * See https://cwe.mitre.org/ for further reference.
- * */
-struct CWE {
-    explicit CWE(unsigned short ID) : id(ID) {}
-    unsigned short id;
-};
-
-
+#include <map>
 
 class Token;
 class TokenList;
+enum class ReportType : std::uint8_t;
+enum class Color : std::uint8_t;
 
 namespace tinyxml2 {
     class XMLElement;
@@ -52,318 +45,187 @@ namespace tinyxml2 {
 /// @addtogroup Core
 /// @{
 
-/** @brief Simple container to be thrown when internal error is detected. */
-struct InternalError {
-    enum Type {AST, SYNTAX, UNKNOWN_MACRO, INTERNAL, LIMIT, INSTANTIATION};
-    InternalError(const Token *tok, const std::string &errorMsg, Type type = INTERNAL);
-    const Token *token;
-    std::string errorMessage;
-    Type type;
-    std::string id;
-};
-
-/** @brief enum class for severity. Used when reporting errors. */
-class CPPCHECKLIB Severity {
+/**
+ * Wrapper for error messages, provided by reportErr()
+ */
+class CPPCHECKLIB ErrorMessage {
 public:
     /**
-     * Message severities.
+     * File name and line number.
+     * Internally paths are stored with / separator. When getting the filename
+     * it is by default converted to native separators.
      */
-    enum SeverityType {
-        /**
-         * No severity (default value).
-         */
-        none,
-        /**
-         * Programming error.
-         * This indicates severe error like memory leak etc.
-         * The error is certain.
-         */
-        error,
-        /**
-         * Warning.
-         * Used for dangerous coding style that can cause severe runtime errors.
-         * For example: forgetting to initialize a member variable in a constructor.
-         */
-        warning,
-        /**
-         * Style warning.
-         * Used for general code cleanup recommendations. Fixing these
-         * will not fix any bugs but will make the code easier to maintain.
-         * For example: redundant code, unreachable code, etc.
-         */
-        style,
+    class CPPCHECKLIB WARN_UNUSED FileLocation {
+    public:
+        FileLocation(const std::string &file, int line, unsigned int column);
+        FileLocation(const std::string &file, std::string info, int line, unsigned int column);
+        FileLocation(const Token* tok, const TokenList* tokenList);
+        FileLocation(const Token* tok, std::string info, const TokenList* tokenList);
+
         /**
-         * Performance warning.
-         * Not an error as is but suboptimal code and fixing it probably leads
-         * to faster performance of the compiled code.
+         * Return the filename.
+         * @param convert If true convert path to native separators.
+         * @return filename.
          */
-        performance,
+        std::string getfile(bool convert = true) const;
+
         /**
-         * Portability warning.
-         * This warning indicates the code is not properly portable for
-         * different platforms and bitnesses (32/64 bit). If the code is meant
-         * to compile in different platforms and bitnesses these warnings
-         * should be fixed.
+         * Filename with the whole path (no --rp)
+         * @param convert If true convert path to native separators.
+         * @return filename.
          */
-        portability,
+        std::string getOrigFile(bool convert = true) const;
+
         /**
-         * Checking information.
-         * Information message about the checking (process) itself. These
-         * messages inform about header files not found etc issues that are
-         * not errors in the code but something user needs to know.
+         * Set the filename.
+         * @param file Filename to set.
          */
-        information,
+        void setfile(std::string file);
+
         /**
-         * Debug message.
-         * Debug-mode message useful for the developers.
+         * @return the location as a string. Format: [file:line]
          */
-        debug
-    };
+        std::string stringify(bool addcolumn = false) const;
+
+        unsigned int fileIndex;
+        int line; // negative value means "no line"
+        unsigned int column;
 
-    static std::string toString(SeverityType severity) {
-        switch (severity) {
-        case none:
-            return "";
-        case error:
-            return "error";
-        case warning:
-            return "warning";
-        case style:
-            return "style";
-        case performance:
-            return "performance";
-        case portability:
-            return "portability";
-        case information:
-            return "information";
-        case debug:
-            return "debug";
+        const std::string& getinfo() const {
+            return mInfo;
         }
-        throw InternalError(nullptr, "Unknown severity");
-    }
-    static SeverityType fromString(const std::string &severity) {
-        if (severity.empty())
-            return none;
-        if (severity == "none")
-            return none;
-        if (severity == "error")
-            return error;
-        if (severity == "warning")
-            return warning;
-        if (severity == "style")
-            return style;
-        if (severity == "performance")
-            return performance;
-        if (severity == "portability")
-            return portability;
-        if (severity == "information")
-            return information;
-        if (severity == "debug")
-            return debug;
-        return none;
-    }
-};
 
+    private:
+        std::string mOrigFileName;
+        std::string mFileName;
+        std::string mInfo;
+    };
 
-typedef std::pair<const Token *, std::string> ErrorPathItem;
-typedef std::list<ErrorPathItem> ErrorPath;
+    ErrorMessage(std::list<FileLocation> callStack,
+                 std::string file1,
+                 Severity severity,
+                 const std::string &msg,
+                 std::string id, Certainty certainty);
+    ErrorMessage(std::list<FileLocation> callStack,
+                 std::string file1,
+                 Severity severity,
+                 const std::string &msg,
+                 std::string id,
+                 const CWE &cwe,
+                 Certainty certainty);
+    ErrorMessage(const std::list<const Token*>& callstack,
+                 const TokenList* list,
+                 Severity severity,
+                 std::string id,
+                 const std::string& msg,
+                 Certainty certainty);
+    ErrorMessage(const std::list<const Token*>& callstack,
+                 const TokenList* list,
+                 Severity severity,
+                 std::string id,
+                 const std::string& msg,
+                 const CWE &cwe,
+                 Certainty certainty);
+    ErrorMessage(ErrorPath errorPath,
+                 const TokenList *tokenList,
+                 Severity severity,
+                 const char id[],
+                 const std::string &msg,
+                 const CWE &cwe,
+                 Certainty certainty);
+    ErrorMessage();
+    explicit ErrorMessage(const tinyxml2::XMLElement * errmsg);
 
-/**
- * @brief This is an interface, which the class responsible of error logging
- * should implement.
- */
-class CPPCHECKLIB ErrorLogger {
-protected:
-    std::ofstream plistFile;
-public:
+    /**
+     * Format the error message in XML format
+     */
+    std::string toXML() const;
+
+    static std::string getXMLHeader(std::string productName, int xmlVersion = 2);
+    static std::string getXMLFooter(int xmlVersion);
 
     /**
-     * Wrapper for error messages, provided by reportErr()
+     * Format the error message into a string.
+     * @param verbose use verbose message
+     * @param templateFormat Empty string to use default output format
+     * or template to be used. E.g. "{file}:{line},{severity},{id},{message}"
+     * @param templateLocation Format Empty string to use default output format
+     * or template to be used. E.g. "{file}:{line},{info}"
+     * @return formatted string
      */
-    class CPPCHECKLIB ErrorMessage {
-    public:
-        /**
-         * File name and line number.
-         * Internally paths are stored with / separator. When getting the filename
-         * it is by default converted to native separators.
-         */
-        class CPPCHECKLIB FileLocation {
-        public:
-            FileLocation()
-                : fileIndex(0), line(0), column(0) {
-            }
-
-            FileLocation(const std::string &file, int line, int column)
-                : fileIndex(0), line(line), column(column), mOrigFileName(file), mFileName(file) {
-            }
-
-            FileLocation(const std::string &file, const std::string &info, int line, int column)
-                : fileIndex(0), line(line), column(column), mOrigFileName(file), mFileName(file), mInfo(info) {
-            }
-
-            FileLocation(const Token* tok, const TokenList* tokenList);
-            FileLocation(const Token* tok, const std::string &info, const TokenList* tokenList);
-
-            /**
-             * Return the filename.
-             * @param convert If true convert path to native separators.
-             * @return filename.
-             */
-            std::string getfile(bool convert = true) const;
-
-            /**
-             * Filename with the whole path (no --rp)
-             * @param convert If true convert path to native separators.
-             * @return filename.
-             */
-            std::string getOrigFile(bool convert = true) const;
-
-            /**
-             * Set the filename.
-             * @param file Filename to set.
-             */
-            void setfile(const std::string &file);
-
-            /**
-             * @return the location as a string. Format: [file:line]
-             */
-            std::string stringify() const;
-
-            unsigned int fileIndex;
-            int line; // negative value means "no line"
-            unsigned int column;
-
-            std::string getinfo() const {
-                return mInfo;
-            }
-            void setinfo(const std::string &i) {
-                mInfo = i;
-            }
-
-        private:
-            std::string mOrigFileName;
-            std::string mFileName;
-            std::string mInfo;
-        };
-
-        ErrorMessage(const std::list<FileLocation> &callStack,
-                     const std::string& file1,
-                     Severity::SeverityType severity,
-                     const std::string &msg,
-                     const std::string &id, bool inconclusive);
-        ErrorMessage(const std::list<FileLocation> &callStack,
-                     const std::string& file1,
-                     Severity::SeverityType severity,
-                     const std::string &msg,
-                     const std::string &id,
-                     const CWE &cwe,
-                     bool inconclusive);
-        ErrorMessage(const std::list<const Token*>& callstack,
-                     const TokenList* list,
-                     Severity::SeverityType severity,
-                     const std::string& id,
-                     const std::string& msg,
-                     bool inconclusive);
-        ErrorMessage(const std::list<const Token*>& callstack,
-                     const TokenList* list,
-                     Severity::SeverityType severity,
-                     const std::string& id,
-                     const std::string& msg,
-                     const CWE &cwe,
-                     bool inconclusive);
-        ErrorMessage(const ErrorPath &errorPath,
-                     const TokenList *tokenList,
-                     Severity::SeverityType severity,
-                     const char id[],
-                     const std::string &msg,
-                     const CWE &cwe,
-                     bool inconclusive);
-        ErrorMessage();
-        explicit ErrorMessage(const tinyxml2::XMLElement * const errmsg);
+    std::string toString(bool verbose,
+                         const std::string &templateFormat,
+                         const std::string &templateLocation) const;
 
-        /**
-         * Format the error message in XML format
-         */
-        std::string toXML() const;
+    std::string serialize() const;
+    /**
+     * @throws InternalError thrown if deserialization failed
+     */
+    void deserialize(const std::string &data);
 
-        static std::string getXMLHeader();
-        static std::string getXMLFooter();
+    std::list<FileLocation> callStack;
+    std::string id;
 
-        /**
-         * Format the error message into a string.
-         * @param verbose use verbose message
-         * @param templateFormat Empty string to use default output format
-         * or template to be used. E.g. "{file}:{line},{severity},{id},{message}"
-         * @param templateLocation Format Empty string to use default output format
-         * or template to be used. E.g. "{file}:{line},{info}"
-        * @return formatted string
-         */
-        std::string toString(bool verbose,
-                             const std::string &templateFormat = emptyString,
-                             const std::string &templateLocation = emptyString) const;
+    /** For GUI rechecking; source file (not header) */
+    std::string file0;
 
-        std::string serialize() const;
-        bool deserialize(const std::string &data);
+    Severity severity;
+    CWE cwe;
+    Certainty certainty;
 
-        std::list<FileLocation> callStack;
-        std::string id;
+    /** remark from REMARK comment */
+    std::string remark;
 
-        /** source file (not header) */
-        std::string file0;
+    /** misra/autosar/certc classification/level */
+    std::string classification;
 
-        Severity::SeverityType severity;
-        CWE cwe;
-        bool inconclusive;
+    /** misra/autosar/certc guideline */
+    std::string guideline;
 
-        /** set short and verbose messages */
-        void setmsg(const std::string &msg);
+    /** Warning hash */
+    std::size_t hash{};
 
-        /** Short message (single line short message) */
-        const std::string &shortMessage() const {
-            return mShortMessage;
-        }
+    /** set short and verbose messages */
+    void setmsg(const std::string &msg);
 
-        /** Verbose message (may be the same as the short message) */
-        const std::string &verboseMessage() const {
-            return mVerboseMessage;
-        }
+    /** Short message (single line short message) */
+    const std::string &shortMessage() const {
+        return mShortMessage;
+    }
 
-        /** Symbol names */
-        const std::string &symbolNames() const {
-            return mSymbolNames;
-        }
+    /** Verbose message (may be the same as the short message) */
+    const std::string &verboseMessage() const {
+        return mVerboseMessage;
+    }
 
-        Suppressions::ErrorMessage toSuppressionsErrorMessage() const;
+    /** Symbol names */
+    const std::string &symbolNames() const {
+        return mSymbolNames;
+    }
 
-    private:
-        /**
-         * Replace all occurrences of searchFor with replaceWith in the
-         * given source.
-         * @param source The string to modify
-         * @param searchFor What should be searched for
-         * @param replaceWith What will replace the found item
-         */
-        static void findAndReplace(std::string &source, const std::string &searchFor, const std::string &replaceWith);
+    static ErrorMessage fromInternalError(const InternalError &internalError, const TokenList *tokenList, const std::string &filename, const std::string& msg = "");
 
-        static std::string fixInvalidChars(const std::string& raw);
+private:
+    static std::string fixInvalidChars(const std::string& raw);
 
-        /** Short message */
-        std::string mShortMessage;
+    /** Short message */
+    std::string mShortMessage;
 
-        /** Verbose message */
-        std::string mVerboseMessage;
+    /** Verbose message */
+    std::string mVerboseMessage;
 
-        /** symbol names */
-        std::string mSymbolNames;
-    };
+    /** symbol names */
+    std::string mSymbolNames;
+};
 
-    ErrorLogger() { }
-    virtual ~ErrorLogger() {
-        if (plistFile.is_open()) {
-            plistFile << ErrorLogger::plistFooter();
-            plistFile.close();
-        }
-    }
+/**
+ * @brief This is an interface, which the class responsible of error logging
+ * should implement.
+ */
+class CPPCHECKLIB ErrorLogger {
+public:
+    ErrorLogger() = default;
+    virtual ~ErrorLogger() = default;
 
     /**
      * Information about progress is directed here.
@@ -371,7 +233,7 @@ class CPPCHECKLIB ErrorLogger {
      *
      * @param outmsg Message to show e.g. "Checking main.cpp..."
      */
-    virtual void reportOut(const std::string &outmsg) = 0;
+    virtual void reportOut(const std::string &outmsg, Color c) = 0;
 
     /**
      * Information about found errors and warnings is directed
@@ -379,7 +241,14 @@ class CPPCHECKLIB ErrorLogger {
      *
      * @param msg Location and other information about the found error.
      */
-    virtual void reportErr(const ErrorLogger::ErrorMessage &msg) = 0;
+    virtual void reportErr(const ErrorMessage &msg) = 0;
+
+    /**
+     * Information about file metrics reported by addons.
+     *
+     * @param metric The file metric to report, as an XML object.
+     */
+    virtual void reportMetric(const std::string &metric) = 0;
 
     /**
      * Report progress to client
@@ -393,22 +262,7 @@ class CPPCHECKLIB ErrorLogger {
         (void)value;
     }
 
-    /**
-     * Output information messages.
-     * @param msg Location and other information about the found error.
-     */
-    virtual void reportInfo(const ErrorLogger::ErrorMessage &msg) {
-        reportErr(msg);
-    }
-
-    /**
-     * Report unmatched suppressions
-     * @param unmatched list of unmatched suppressions (from Settings::Suppressions::getUnmatched(Local|Global)Suppressions)
-     * @return true is returned if errors are reported
-     */
-    bool reportUnmatchedSuppressions(const std::list<Suppressions::Suppression> &unmatched);
-
-    static std::string callStackToString(const std::list<ErrorLogger::ErrorMessage::FileLocation> &callStack);
+    static std::string callStackToString(const std::list<ErrorMessage::FileLocation> &callStack, bool addcolumn = false);
 
     /**
      * Convert XML-sensitive characters into XML entities
@@ -418,17 +272,76 @@ class CPPCHECKLIB ErrorLogger {
     static std::string toxml(const std::string &str);
 
     static std::string plistHeader(const std::string &version, const std::vector<std::string> &files);
-    static std::string plistData(const ErrorLogger::ErrorMessage &msg);
+    static std::string plistData(const ErrorMessage &msg);
     static const char *plistFooter() {
         return " </array>\r\n"
                "</dict>\r\n"
                "</plist>";
     }
+
+    static bool isCriticalErrorId(const std::string& id) {
+        return mCriticalErrorIds.count(id) != 0;
+    }
+
+private:
+    static const std::set<std::string> mCriticalErrorIds;
+};
+
+/// RAII class for reporting progress messages
+class CPPCHECKLIB ProgressReporter {
+public:
+    ProgressReporter(ErrorLogger& e, int reportProgressInterval, std::string filename, std::string stage) :
+        mErrorLogger(e),
+        mReportProgressInterval(reportProgressInterval),
+        mFilename(std::move(filename)),
+        mStage(std::move(stage)) {
+        report(0);
+    }
+
+    ~ProgressReporter() {
+        mErrorLogger.reportProgress(mFilename, mStage.c_str(), 100);
+    }
+
+    void report(int value) {
+        if (mReportProgressInterval < 0 || value == mLastValue)
+            return;
+        const std::time_t t = std::time(nullptr);
+        if (t >= mLastTime + mReportProgressInterval) {
+            mErrorLogger.reportProgress(mFilename, mStage.c_str(), value);
+            mLastTime = t;
+            mLastValue = value;
+        }
+    }
+
+private:
+    ErrorLogger& mErrorLogger;
+    const int mReportProgressInterval;
+    const std::string mFilename;
+    const std::string mStage;
+    std::time_t mLastTime{0};
+    int mLastValue{-1};
 };
 
 /** Replace substring. Example replaceStr("1,NR,3", "NR", "2") => "1,2,3" */
 std::string replaceStr(std::string s, const std::string &from, const std::string &to);
 
+/** replaces the static parts of the location template **/
+CPPCHECKLIB void substituteTemplateFormatStatic(std::string& templateFormat, bool eraseColors = false);
+
+/** replaces the static parts of the location template **/
+CPPCHECKLIB void substituteTemplateLocationStatic(std::string& templateLocation, bool eraseColors = false);
+
+/** Get a classification string from the given guideline and reporttype */
+CPPCHECKLIB std::string getClassification(const std::string &guideline, ReportType reportType);
+
+/** Get a guidline string froM the given error id, reporttype, mapping and severity */
+CPPCHECKLIB std::string getGuideline(const std::string &errId, ReportType reportType,
+                                     const std::map<std::string, std::string> &guidelineMapping,
+                                     Severity severity);
+
+/** Get a map from cppcheck error ids to guidlines matching the given report type */
+CPPCHECKLIB std::map<std::string, std::string> createGuidelineMapping(ReportType reportType);
+
 /// @}
 //---------------------------------------------------------------------------
 #endif // errorloggerH
diff --git a/lib/errortypes.cpp b/lib/errortypes.cpp
new file mode 100644
index 00000000000..0741ea36796
--- /dev/null
+++ b/lib/errortypes.cpp
@@ -0,0 +1,99 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "errortypes.h"
+
+#include "utils.h"
+
+static std::string typeToString(InternalError::Type type)
+{
+    switch (type) {
+    case InternalError::Type::AST:
+        return "internalAstError";
+    case InternalError::Type::SYNTAX:
+        return "syntaxError";
+    case InternalError::Type::UNKNOWN_MACRO:
+        return "unknownMacro";
+    case InternalError::Type::INTERNAL:
+        return "internalError";
+    case InternalError::Type::LIMIT:
+        return "cppcheckLimit";
+    case InternalError::Type::INSTANTIATION:
+        return "instantiationError";
+    }
+    cppcheck::unreachable();
+}
+
+InternalError::InternalError(const Token *tok, std::string errorMsg, Type type) :
+    InternalError(tok, std::move(errorMsg), "", type)
+{}
+
+InternalError::InternalError(const Token *tok, std::string errorMsg, std::string details, Type type) :
+    token(tok), errorMessage(std::move(errorMsg)), details(std::move(details)), type(type), id(typeToString(type))
+{}
+
+std::string severityToString(Severity severity)
+{
+    switch (severity) {
+    case Severity::none:
+        return "";
+    case Severity::error:
+        return "error";
+    case Severity::warning:
+        return "warning";
+    case Severity::style:
+        return "style";
+    case Severity::performance:
+        return "performance";
+    case Severity::portability:
+        return "portability";
+    case Severity::information:
+        return "information";
+    case Severity::debug:
+        return "debug";
+    case Severity::internal:
+        return "internal";
+    }
+    cppcheck::unreachable();
+}
+
+// TODO: bail out on invalid severity
+Severity severityFromString(const std::string& severity)
+{
+    if (severity.empty())
+        return Severity::none;
+    if (severity == "none")
+        return Severity::none;
+    if (severity == "error")
+        return Severity::error;
+    if (severity == "warning")
+        return Severity::warning;
+    if (severity == "style")
+        return Severity::style;
+    if (severity == "performance")
+        return Severity::performance;
+    if (severity == "portability")
+        return Severity::portability;
+    if (severity == "information")
+        return Severity::information;
+    if (severity == "debug")
+        return Severity::debug;
+    if (severity == "internal")
+        return Severity::internal;
+    return Severity::none;
+}
diff --git a/lib/errortypes.h b/lib/errortypes.h
new file mode 100644
index 00000000000..e2fe6897447
--- /dev/null
+++ b/lib/errortypes.h
@@ -0,0 +1,135 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+//---------------------------------------------------------------------------
+#ifndef errortypesH
+#define errortypesH
+//---------------------------------------------------------------------------
+
+#include "config.h"
+
+#include <cstdint>
+#include <stdexcept>
+#include <list>
+#include <string>
+#include <utility>
+
+/// @addtogroup Core
+/// @{
+class Token;
+
+/** @brief Simple container to be thrown when internal error is detected. */
+struct CPPCHECKLIB InternalError {
+    enum Type : std::uint8_t {AST, SYNTAX, UNKNOWN_MACRO, INTERNAL, LIMIT, INSTANTIATION};
+
+    InternalError(const Token *tok, std::string errorMsg, Type type = INTERNAL);
+    InternalError(const Token *tok, std::string errorMsg, std::string details, Type type = INTERNAL);
+
+    const Token *token;
+    std::string errorMessage;
+    std::string details;
+    Type type;
+    std::string id;
+};
+
+class TerminateException : public std::runtime_error {
+public:
+    TerminateException() : std::runtime_error("terminate") {}
+};
+
+enum class Certainty : std::uint8_t {
+    normal, inconclusive
+};
+
+enum class Checks : std::uint8_t {
+    unusedFunction, missingInclude, internalCheck
+};
+
+/** @brief enum class for severity. Used when reporting errors. */
+enum class Severity : std::uint8_t {
+    /**
+     * No severity (default value).
+     */
+    none,
+    /**
+     * Programming error.
+     * This indicates severe error like memory leak etc.
+     * The error is certain.
+     */
+    error,
+    /**
+     * Warning.
+     * Used for dangerous coding style that can cause severe runtime errors.
+     * For example: forgetting to initialize a member variable in a constructor.
+     */
+    warning,
+    /**
+     * Style warning.
+     * Used for general code cleanup recommendations. Fixing these
+     * will not fix any bugs but will make the code easier to maintain.
+     * For example: redundant code, unreachable code, etc.
+     */
+    style,
+    /**
+     * Performance warning.
+     * Not an error as is but suboptimal code and fixing it probably leads
+     * to faster performance of the compiled code.
+     */
+    performance,
+    /**
+     * Portability warning.
+     * This warning indicates the code is not properly portable for
+     * different platforms and bitnesses (32/64 bit). If the code is meant
+     * to compile in different platforms and bitnesses these warnings
+     * should be fixed.
+     */
+    portability,
+    /**
+     * Checking information.
+     * Information message about the checking (process) itself. These
+     * messages inform about header files not found etc issues that are
+     * not errors in the code but something user needs to know.
+     */
+    information,
+    /**
+     * Debug message.
+     * Debug-mode message useful for the developers.
+     */
+    debug,
+    /**
+     * Internal message.
+     * Message will not be shown to the user.
+     * Tracking what checkers is executed, tracking suppressed critical errors, etc.
+     */
+    internal
+};
+
+CPPCHECKLIB std::string severityToString(Severity severity);
+CPPCHECKLIB Severity severityFromString(const std::string &severity);
+
+struct CWE {
+    explicit CWE(unsigned short cweId) : id(cweId) {}
+    unsigned short id;
+};
+
+using ErrorPathItem = std::pair<const Token *, std::string>;
+using ErrorPath = std::list<ErrorPathItem>;
+
+/// @}
+//---------------------------------------------------------------------------
+#endif // errortypesH
diff --git a/lib/exprengine.cpp b/lib/exprengine.cpp
deleted file mode 100644
index 16e839109f7..00000000000
--- a/lib/exprengine.cpp
+++ /dev/null
@@ -1,1242 +0,0 @@
-/*
- * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "exprengine.h"
-#include "astutils.h"
-#include "settings.h"
-#include "symboldatabase.h"
-#include "tokenize.h"
-
-#include <cstdlib>
-#include <limits>
-#include <memory>
-#include <iostream>
-#ifdef USE_Z3
-#include <z3++.h>
-#endif
-
-std::string ExprEngine::str(int128_t value)
-{
-    std::ostringstream ostr;
-#ifdef __GNUC__
-    if (value == (int)value) {
-        ostr << (int) value;
-        return ostr.str();
-    }
-    if (value < 0) {
-        ostr << "-";
-        value = -value;
-    }
-
-    uint64_t high = value >> 64;
-    uint64_t low = value;
-    if (high > 0)
-        ostr << "h" << std::hex << high << "l";
-    ostr << std::hex << low;
-#else
-    ostr << value;
-#endif
-    return ostr.str();
-}
-
-static ExprEngine::ValuePtr getValueRangeFromValueType(const std::string &name, const ValueType *vt, const cppcheck::Platform &platform);
-
-namespace {
-    class TrackExecution {
-    public:
-        TrackExecution() : mDataIndex(0) {}
-        std::map<const Token *, std::vector<std::string>> map;
-        int getNewDataIndex() {
-            return mDataIndex++;
-        }
-
-        void symbolRange(const Token *tok, ExprEngine::ValuePtr value) {
-            if (!tok || !value)
-                return;
-            const std::string &symbolicExpression = value->getSymbolicExpression();
-            if (symbolicExpression[0] != '$')
-                return;
-            if (mSymbols.find(symbolicExpression) != mSymbols.end())
-                return;
-            mSymbols.insert(symbolicExpression);
-            map[tok].push_back(symbolicExpression + "=" + value->getRange());
-
-        }
-
-        void state(const Token *tok, const std::string &s) {
-            map[tok].push_back(s);
-        }
-
-        void print(std::ostream &out) {
-            std::set<std::pair<int,int>> locations;
-            for (auto it : map) {
-                locations.insert(std::pair<int,int>(it.first->linenr(), it.first->column()));
-            }
-            for (const std::pair<int,int> &loc : locations) {
-                int lineNumber = loc.first;
-                int column = loc.second;
-                for (auto &it : map) {
-                    const Token *tok = it.first;
-                    if (lineNumber != tok->linenr())
-                        continue;
-                    if (column != tok->column())
-                        continue;
-                    const std::vector<std::string> &dumps = it.second;
-                    for (const std::string &dump : dumps)
-                        out << lineNumber << ":" << column << ": " << dump << "\n";
-                }
-            }
-        }
-    private:
-        int mDataIndex;
-        std::set<std::string> mSymbols;
-    };
-
-    class Data : public ExprEngine::DataBase {
-    public:
-        Data(int *symbolValueIndex, const Tokenizer *tokenizer, const Settings *settings, const std::vector<ExprEngine::Callback> &callbacks, TrackExecution *trackExecution)
-            : DataBase(settings)
-            , symbolValueIndex(symbolValueIndex)
-            , tokenizer(tokenizer)
-            , callbacks(callbacks)
-            , mTrackExecution(trackExecution)
-            , mDataIndex(trackExecution->getNewDataIndex()) {}
-        typedef std::map<nonneg int, std::shared_ptr<ExprEngine::Value>> Memory;
-        Memory memory;
-        int * const symbolValueIndex;
-        const Tokenizer * const tokenizer;
-        const std::vector<ExprEngine::Callback> &callbacks;
-        std::vector<ExprEngine::ValuePtr> constraints;
-
-        void assignValue(const Token *tok, unsigned int varId, ExprEngine::ValuePtr value) {
-            mTrackExecution->symbolRange(tok, value);
-            if (value) {
-                if (auto arr = std::dynamic_pointer_cast<ExprEngine::ArrayValue>(value)) {
-                    mTrackExecution->symbolRange(tok, arr->size);
-                    for (const auto &indexAndValue: arr->data)
-                        mTrackExecution->symbolRange(tok, indexAndValue.value);
-                } else if (auto s = std::dynamic_pointer_cast<ExprEngine::StructValue>(value)) {
-                    for (const auto &m: s->member)
-                        mTrackExecution->symbolRange(tok, m.second);
-                }
-            }
-            memory[varId] = value;
-        }
-
-        void assignStructMember(const Token *tok, ExprEngine::StructValue *structVal, const std::string &memberName, ExprEngine::ValuePtr value) {
-            mTrackExecution->symbolRange(tok, value);
-            structVal->member[memberName] = value;
-        }
-
-        std::string getNewSymbolName() override {
-            return "$" + std::to_string(++(*symbolValueIndex));
-        }
-
-        std::shared_ptr<ExprEngine::ArrayValue> getArrayValue(const Token *tok) {
-            const Memory::iterator it = memory.find(tok->varId());
-            if (it != memory.end())
-                return std::dynamic_pointer_cast<ExprEngine::ArrayValue>(it->second);
-            if (tok->varId() == 0)
-                return std::shared_ptr<ExprEngine::ArrayValue>();
-            auto val = std::make_shared<ExprEngine::ArrayValue>(this, tok->variable());
-            assignValue(tok, tok->varId(), val);
-            return val;
-        }
-
-        ExprEngine::ValuePtr getValue(unsigned int varId, const ValueType *valueType, const Token *tok) {
-            const Memory::const_iterator it = memory.find(varId);
-            if (it != memory.end())
-                return it->second;
-            if (!valueType)
-                return ExprEngine::ValuePtr();
-            ExprEngine::ValuePtr value = getValueRangeFromValueType(getNewSymbolName(), valueType, *settings);
-            if (value) {
-                assignValue(tok, varId, value);
-            }
-            return value;
-        }
-
-        void trackProgramState(const Token *tok) {
-            if (memory.empty())
-                return;
-            const SymbolDatabase * const symbolDatabase = tokenizer->getSymbolDatabase();
-            std::ostringstream s;
-            s << "{"; // << mDataIndex << ":";
-            for (auto mem : memory) {
-                ExprEngine::ValuePtr value = mem.second;
-                const Variable *var = symbolDatabase->getVariableFromVarId(mem.first);
-                if (!var)
-                    continue;
-                s << " " << var->name() << "=";
-                if (!value)
-                    s << "(null)";
-                else if (value->name[0] == '$' && value->getSymbolicExpression() != value->name)
-                    s << "(" << value->name << "," << value->getSymbolicExpression() << ")";
-                else
-                    s << value->name;
-            }
-            s << "}";
-            mTrackExecution->state(tok, s.str());
-        }
-
-        ExprEngine::ValuePtr notValue(ExprEngine::ValuePtr v) {
-            auto b = std::dynamic_pointer_cast<ExprEngine::BinOpResult>(v);
-            if (b) {
-                std::string binop;
-                if (b->binop == "==")
-                    binop = "!=";
-                else if (b->binop == "!=")
-                    binop = "==";
-                else if (b->binop == ">=")
-                    binop = "<";
-                else if (b->binop == "<=")
-                    binop = ">";
-                else if (b->binop == ">")
-                    binop = "<=";
-                else if (b->binop == "<")
-                    binop = ">=";
-                if (!binop.empty())
-                    return std::make_shared<ExprEngine::BinOpResult>(binop, b->op1, b->op2);
-            }
-            auto zero = std::make_shared<ExprEngine::IntRange>("0", 0, 0);
-            return std::make_shared<ExprEngine::BinOpResult>("==", v, zero);
-        }
-
-        void addConstraint(ExprEngine::ValuePtr condValue, bool trueCond) {
-            if (trueCond)
-                constraints.push_back(condValue);
-            else
-                constraints.push_back(notValue(condValue));
-        }
-    private:
-        TrackExecution * const mTrackExecution;
-        const int mDataIndex;
-    };
-}
-
-static ExprEngine::ValuePtr simplifyValue(ExprEngine::ValuePtr origValue)
-{
-    auto b = std::dynamic_pointer_cast<ExprEngine::BinOpResult>(origValue);
-    if (!b)
-        return origValue;
-    if (!b->op1 || !b->op2)
-        return origValue;
-    auto intRange1 = std::dynamic_pointer_cast<ExprEngine::IntRange>(b->op1);
-    auto intRange2 = std::dynamic_pointer_cast<ExprEngine::IntRange>(b->op2);
-    if (intRange1 && intRange2 && intRange1->minValue == intRange1->maxValue && intRange2->minValue == intRange2->maxValue) {
-        const std::string &binop = b->binop;
-        int128_t v;
-        if (binop == "+")
-            v = intRange1->minValue + intRange2->minValue;
-        else if (binop == "-")
-            v = intRange1->minValue - intRange2->minValue;
-        else if (binop == "*")
-            v = intRange1->minValue * intRange2->minValue;
-        else if (binop == "/" && intRange2->minValue != 0)
-            v = intRange1->minValue / intRange2->minValue;
-        else if (binop == "%" && intRange2->minValue != 0)
-            v = intRange1->minValue % intRange2->minValue;
-        else
-            return origValue;
-        return std::make_shared<ExprEngine::IntRange>(ExprEngine::str(v), v, v);
-    }
-    return origValue;
-}
-
-static ExprEngine::ValuePtr translateUninitValueToRange(ExprEngine::ValuePtr value, const ::ValueType *valueType, Data &data)
-{
-    if (!value)
-        return value;
-    if (value->type == ExprEngine::ValueType::UninitValue) {
-        auto rangeValue = getValueRangeFromValueType(data.getNewSymbolName(), valueType, *data.settings);
-        if (rangeValue)
-            return rangeValue;
-    }
-    if (auto conditionalValue = std::dynamic_pointer_cast<ExprEngine::ConditionalValue>(value)) {
-        if (conditionalValue->values.size() == 1 && conditionalValue->values[0].second && conditionalValue->values[0].second->type == ExprEngine::ValueType::UninitValue) {
-            auto rangeValue = getValueRangeFromValueType(data.getNewSymbolName(), valueType, *data.settings);
-            if (rangeValue)
-                return rangeValue;
-        }
-    }
-    return value;
-}
-
-static int128_t truncateInt(int128_t value, int bits, char sign)
-{
-    value = value & (((int128_t)1 << bits) - 1);
-    // Sign extension
-    if (sign == 's' && value & (1ULL << (bits - 1)))
-        value |= ~(((int128_t)1 << bits) - 1);
-    return value;
-}
-
-ExprEngine::ArrayValue::ArrayValue(const std::string &name, ExprEngine::ValuePtr size, ExprEngine::ValuePtr value)
-    : Value(name, ExprEngine::ValueType::ArrayValue)
-    , size(size)
-{
-    assign(ExprEngine::ValuePtr(), value);
-}
-
-ExprEngine::ArrayValue::ArrayValue(DataBase *data, const Variable *var)
-    : Value(data->getNewSymbolName(), ExprEngine::ValueType::ArrayValue)
-{
-    if (var) {
-        int sz = 1;
-        for (const auto &dim : var->dimensions()) {
-            if (!dim.known) {
-                sz = -1;
-                break;
-            }
-            sz *= dim.num;
-        }
-        if (sz >= 1)
-            size = std::make_shared<ExprEngine::IntRange>(std::to_string(sz), sz, sz);
-    }
-    ValuePtr val;
-    if (var && !var->isGlobal() && !var->isStatic())
-        val = std::make_shared<ExprEngine::UninitValue>();
-    else if (var && var->valueType()) {
-        ::ValueType vt(*var->valueType());
-        vt.pointer = 0;
-        val = getValueRangeFromValueType(data->getNewSymbolName(), &vt, *data->settings);
-    }
-    assign(ExprEngine::ValuePtr(), val);
-}
-
-void ExprEngine::ArrayValue::assign(ExprEngine::ValuePtr index, ExprEngine::ValuePtr value)
-{
-    if (!index)
-        data.clear();
-    if (value) {
-        ExprEngine::ArrayValue::IndexAndValue indexAndValue = {index, value};
-        data.push_back(indexAndValue);
-    }
-}
-
-void ExprEngine::ArrayValue::clear()
-{
-    data.clear();
-    ExprEngine::ArrayValue::IndexAndValue indexAndValue = {
-        ExprEngine::ValuePtr(), std::make_shared<ExprEngine::IntRange>("0", 0, 0)
-    };
-    data.push_back(indexAndValue);
-}
-
-static bool isEqual(ExprEngine::ValuePtr v1, ExprEngine::ValuePtr v2)
-{
-    if (!v1 || !v2)
-        return !v1 && !v2;
-    return v1->name == v2->name;
-}
-
-static bool isNonOverlapping(ExprEngine::ValuePtr v1, ExprEngine::ValuePtr v2)
-{
-    if (!v1 || !v2)
-        return false; // Don't know!
-    auto intRange1 = std::dynamic_pointer_cast<ExprEngine::IntRange>(v1);
-    auto intRange2 = std::dynamic_pointer_cast<ExprEngine::IntRange>(v2);
-    if (intRange1 && intRange2 && (intRange1->minValue > intRange2->maxValue || intRange1->maxValue < intRange2->maxValue))
-        return true;
-    return false;
-}
-
-ExprEngine::ConditionalValue::Vector ExprEngine::ArrayValue::read(ExprEngine::ValuePtr index) const
-{
-    ExprEngine::ConditionalValue::Vector ret;
-    for (const auto indexAndValue : data) {
-        if (isEqual(index, indexAndValue.index))
-            ret.clear();
-        if (isNonOverlapping(index, indexAndValue.index))
-            continue;
-        // Array contains string literal data...
-        if (!indexAndValue.index && indexAndValue.value->type == ExprEngine::ValueType::StringLiteralValue) {
-            auto stringLiteral = std::dynamic_pointer_cast<ExprEngine::StringLiteralValue>(indexAndValue.value);
-            if (!stringLiteral) {
-                ret.push_back(std::pair<ValuePtr,ValuePtr>(indexAndValue.index, std::make_shared<ExprEngine::IntRange>("", -128, 128)));
-                continue;
-            }
-            if (auto i = std::dynamic_pointer_cast<ExprEngine::IntRange>(index)) {
-                if (stringLiteral && i->minValue >= 0 && i->minValue == i->maxValue) {
-                    int c = 0;
-                    if (i->minValue < stringLiteral->size())
-                        c = stringLiteral->string[i->minValue];
-                    ret.push_back(std::pair<ValuePtr,ValuePtr>(indexAndValue.index, std::make_shared<ExprEngine::IntRange>(std::to_string(c), c, c)));
-                    continue;
-                }
-            }
-            int cmin = 0, cmax = 0;
-            for (char c : stringLiteral->string) {
-                if (c < cmin)
-                    cmin = c;
-                else if (c > cmax)
-                    cmax = c;
-            }
-            ret.push_back(std::pair<ValuePtr,ValuePtr>(indexAndValue.index, std::make_shared<ExprEngine::IntRange>("", cmin, cmax)));
-            continue;
-        }
-
-        // Rename IntRange
-        if (auto i = std::dynamic_pointer_cast<ExprEngine::IntRange>(indexAndValue.value)) {
-            ret.push_back(std::pair<ValuePtr,ValuePtr>(indexAndValue.index, std::make_shared<ExprEngine::IntRange>(indexAndValue.value->name + ":" + index->name, i->minValue, i->maxValue)));
-            continue;
-        }
-
-        ret.push_back(std::pair<ValuePtr,ValuePtr>(indexAndValue.index, indexAndValue.value));
-    }
-
-    if (ret.size() == 1)
-        ret[0].first = ExprEngine::ValuePtr();
-    else if (ret.size() == 2 && !ret[0].first) {
-        ret[0].first = std::make_shared<ExprEngine::BinOpResult>("!=", index, ret[1].first);
-        ret[1].first = std::make_shared<ExprEngine::BinOpResult>("==", index, ret[1].first);
-    } else {
-        // FIXME!!
-        ret.clear();
-    }
-
-    return ret;
-}
-
-std::string ExprEngine::ConditionalValue::getSymbolicExpression() const
-{
-    std::ostringstream ostr;
-    ostr << "{";
-    bool first = true;
-    for (auto condvalue : values) {
-        ValuePtr cond = condvalue.first;
-        ValuePtr value = condvalue.second;
-
-        if (!first)
-            ostr << ",";
-        first = false;
-        ostr << "{"
-             << (cond ? cond->getSymbolicExpression() : std::string("(null)"))
-             << ","
-             << value->getSymbolicExpression()
-             << "}";
-    }
-    ostr << "}";
-    return ostr.str();
-}
-
-std::string ExprEngine::ArrayValue::getSymbolicExpression() const
-{
-    std::ostringstream ostr;
-    ostr << "size=" << (size ? size->name : std::string("(null)"));
-    for (const auto indexAndValue : data) {
-        ostr << ",["
-             << (!indexAndValue.index ? std::string(":") : indexAndValue.index->name)
-             << "]="
-             << indexAndValue.value->name;
-    }
-    return ostr.str();
-}
-
-std::string ExprEngine::StructValue::getSymbolicExpression() const
-{
-    std::ostringstream ostr;
-    ostr << "{";
-    bool first = true;
-    for (const auto& m: member) {
-        const std::string &memberName = m.first;
-        auto memberValue = m.second;
-        if (!first)
-            ostr << ",";
-        first = false;
-        ostr << memberName << "=" << (memberValue ? memberValue->getSymbolicExpression() : std::string("(null)"));
-    }
-    ostr << "}";
-    return ostr.str();
-}
-
-std::string ExprEngine::PointerValue::getRange() const
-{
-    std::string r;
-    if (data)
-        r = "->" + data->getSymbolicExpression();
-    if (null)
-        r += std::string(r.empty() ? "" : ",") + "null";
-    if (uninitData)
-        r += std::string(r.empty() ? "" : ",") + "->?";
-    return r;
-}
-
-std::string ExprEngine::IntegerTruncation::getSymbolicExpression() const
-{
-    return sign + std::to_string(bits) + "(" + inputValue->getSymbolicExpression() + ")";
-}
-
-#ifdef USE_Z3
-struct ExprData {
-    typedef std::map<ExprEngine::ValuePtr, z3::expr> ValueExpr;
-    typedef std::vector<z3::expr> AssertionList;
-
-    z3::context c;
-    ValueExpr valueExpr;
-    AssertionList assertionList;
-
-    void addAssertions(z3::solver &solver) const {
-        for (auto assertExpr : assertionList)
-            solver.add(assertExpr);
-    }
-};
-
-static z3::expr getExpr(ExprEngine::ValuePtr v, ExprData &exprData);
-
-static z3::expr getExpr(const ExprEngine::BinOpResult *b, ExprData &exprData)
-{
-    auto op1 = getExpr(b->op1, exprData);
-    auto op2 = getExpr(b->op2, exprData);
-
-    if (b->binop == "+")
-        return op1 + op2;
-    if (b->binop == "-")
-        return op1 - op2;
-    if (b->binop == "*")
-        return op1 * op2;
-    if (b->binop == "/")
-        return op1 / op2;
-    if (b->binop == "%")
-        return op1 % op2;
-    if (b->binop == "==")
-        return op1 == op2;
-    if (b->binop == "!=")
-        return op1 != op2;
-    if (b->binop == ">=")
-        return op1 >= op2;
-    if (b->binop == "<=")
-        return op1 <= op2;
-    if (b->binop == ">")
-        return op1 > op2;
-    if (b->binop == "<")
-        return op1 < op2;
-    if (b->binop == "&&")
-        return op1 && op2;
-    if (b->binop == "||")
-        return op1 || op2;
-    throw std::runtime_error("Internal error: Unhandled operator");
-}
-
-static z3::expr getExpr(ExprEngine::ValuePtr v, ExprData &exprData)
-{
-    if (auto intRange = std::dynamic_pointer_cast<ExprEngine::IntRange>(v)) {
-        if (intRange->name[0] != '$')
-            return exprData.c.int_val(int64_t(intRange->minValue));
-        auto it = exprData.valueExpr.find(v);
-        if (it != exprData.valueExpr.end())
-            return it->second;
-        auto e = exprData.c.int_const(("v" + std::to_string(exprData.valueExpr.size())).c_str());
-        exprData.valueExpr.emplace(v, e);
-        if (intRange->maxValue <= INT_MAX)
-            exprData.assertionList.push_back(e <= int(intRange->maxValue));
-        if (intRange->minValue >= INT_MIN)
-            exprData.assertionList.push_back(e >= int(intRange->minValue));
-        return e;
-    }
-
-    if (auto b = std::dynamic_pointer_cast<ExprEngine::BinOpResult>(v)) {
-        return getExpr(b.get(), exprData);
-    }
-
-    throw std::runtime_error("Internal error: Unhandled value type");
-}
-#endif
-bool ExprEngine::BinOpResult::isIntValueInRange(ExprEngine::DataBase *dataBase, int value) const
-{
-#ifdef USE_Z3
-    ExprData exprData;
-    z3::solver solver(exprData.c);
-    z3::expr e = ::getExpr(this, exprData);
-    exprData.addAssertions(solver);
-    for (auto constraint : dynamic_cast<const Data *>(dataBase)->constraints)
-        solver.add(::getExpr(constraint, exprData));
-    solver.add(e == value);
-    return solver.check() == z3::sat;
-#else
-    (void)dataBase;
-    (void)value;
-    return false;
-#endif
-}
-
-std::string ExprEngine::BinOpResult::getExpr(ExprEngine::DataBase *dataBase) const
-{
-#ifdef USE_Z3
-    ExprData exprData;
-    z3::solver solver(exprData.c);
-    z3::expr e = ::getExpr(this, exprData);
-    exprData.addAssertions(solver);
-    for (auto constraint : dynamic_cast<const Data *>(dataBase)->constraints)
-        solver.add(::getExpr(constraint, exprData));
-    solver.add(e);
-    std::ostringstream os;
-    os << solver;
-    return os.str();
-#else
-    (void)dataBase;
-    return "";
-#endif
-}
-
-
-// Todo: This is taken from ValueFlow and modified.. we should reuse it
-static int getIntBitsFromValueType(const ValueType *vt, const cppcheck::Platform &platform)
-{
-    if (!vt)
-        return 0;
-
-    switch (vt->type) {
-    case ValueType::Type::BOOL:
-        return 1;
-    case ValueType::Type::CHAR:
-        return platform.char_bit;
-    case ValueType::Type::SHORT:
-        return platform.short_bit;
-    case ValueType::Type::INT:
-        return platform.int_bit;
-    case ValueType::Type::LONG:
-        return platform.long_bit;
-    case ValueType::Type::LONGLONG:
-        return platform.long_long_bit;
-    default:
-        return 0;
-    };
-}
-
-static ExprEngine::ValuePtr getValueRangeFromValueType(const std::string &name, const ValueType *vt, const cppcheck::Platform &platform)
-{
-    if (!vt || !(vt->isIntegral() || vt->isFloat()) || vt->pointer)
-        return ExprEngine::ValuePtr();
-
-    int bits = getIntBitsFromValueType(vt, platform);
-    if (bits == 1) {
-        return std::make_shared<ExprEngine::IntRange>(name, 0, 1);
-    } else if (bits > 1) {
-        if (vt->sign == ValueType::Sign::UNSIGNED) {
-            return std::make_shared<ExprEngine::IntRange>(name, 0, ((int128_t)1 << bits) - 1);
-        } else {
-            return std::make_shared<ExprEngine::IntRange>(name, -((int128_t)1 << (bits - 1)), ((int128_t)1 << (bits - 1)) - 1);
-        }
-    }
-
-    switch (vt->type) {
-    case ValueType::Type::FLOAT:
-        return std::make_shared<ExprEngine::FloatRange>(name, std::numeric_limits<float>::min(), std::numeric_limits<float>::max());
-    case ValueType::Type::DOUBLE:
-        return std::make_shared<ExprEngine::FloatRange>(name, std::numeric_limits<double>::min(), std::numeric_limits<double>::max());
-    case ValueType::Type::LONGDOUBLE:
-        return std::make_shared<ExprEngine::FloatRange>(name, std::numeric_limits<long double>::min(), std::numeric_limits<long double>::max());
-    default:
-        return ExprEngine::ValuePtr();
-    };
-}
-
-static void call(const std::vector<ExprEngine::Callback> &callbacks, const Token *tok, ExprEngine::ValuePtr value, Data *dataBase)
-{
-    if (value) {
-        for (ExprEngine::Callback f : callbacks) {
-            f(tok, *value, dataBase);
-        }
-    }
-}
-
-static ExprEngine::ValuePtr executeExpression(const Token *tok, Data &data);
-
-static ExprEngine::ValuePtr executeReturn(const Token *tok, Data &data)
-{
-    ExprEngine::ValuePtr retval = executeExpression(tok->astOperand1(), data);
-    call(data.callbacks, tok, retval, &data);
-    return retval;
-}
-
-static ExprEngine::ValuePtr truncateValue(ExprEngine::ValuePtr val, const ValueType *valueType, Data &data)
-{
-    if (!valueType)
-        return val;
-    if (valueType->pointer != 0)
-        return val;
-    if (!valueType->isIntegral())
-        return val; // TODO
-
-    int bits = getIntBitsFromValueType(valueType, *data.settings);
-    if (bits == 0)
-        // TODO
-        return val;
-
-    if (auto range = std::dynamic_pointer_cast<ExprEngine::IntRange>(val)) {
-        if (range->minValue == range->maxValue) {
-            int128_t newValue = truncateInt(range->minValue, bits, valueType->sign == ValueType::Sign::SIGNED ? 's' : 'u');
-            if (newValue == range->minValue)
-                return val;
-            return std::make_shared<ExprEngine::IntRange>(ExprEngine::str(newValue), newValue, newValue);
-        }
-        if (auto typeRange = getValueRangeFromValueType("", valueType, *data.settings)) {
-            auto typeIntRange = std::dynamic_pointer_cast<ExprEngine::IntRange>(typeRange);
-            if (typeIntRange) {
-                if (range->minValue >= typeIntRange->minValue && range->maxValue <= typeIntRange->maxValue)
-                    return val;
-            }
-        }
-
-        return std::make_shared<ExprEngine::IntegerTruncation>(data.getNewSymbolName(), val, bits, valueType->sign == ValueType::Sign::SIGNED ? 's' : 'u');
-    }
-    // TODO
-    return val;
-}
-
-static ExprEngine::ValuePtr executeAssign(const Token *tok, Data &data)
-{
-    ExprEngine::ValuePtr rhsValue = executeExpression(tok->astOperand2(), data);
-    ExprEngine::ValuePtr assignValue;
-    if (tok->str() == "=")
-        assignValue = rhsValue;
-    else {
-        // "+=" => "+"
-        std::string binop(tok->str());
-        binop = binop.substr(0, binop.size() - 1);
-        ExprEngine::ValuePtr lhsValue = executeExpression(tok->astOperand1(), data);
-        assignValue = simplifyValue(std::make_shared<ExprEngine::BinOpResult>(binop, lhsValue, rhsValue));
-    }
-
-    const Token *lhsToken = tok->astOperand1();
-    assignValue = truncateValue(assignValue, lhsToken->valueType(), data);
-    call(data.callbacks, tok, assignValue, &data);
-
-    if (lhsToken->varId() > 0) {
-        data.assignValue(lhsToken, lhsToken->varId(), assignValue);
-    } else if (lhsToken->str() == "[") {
-        auto arrayValue = data.getArrayValue(lhsToken->astOperand1());
-        if (arrayValue) {
-            // Is it array initialization?
-            const Token *arrayInit = lhsToken->astOperand1();
-            if (arrayInit && arrayInit->variable() && arrayInit->variable()->nameToken() == arrayInit) {
-                if (assignValue->type == ExprEngine::ValueType::StringLiteralValue)
-                    arrayValue->assign(ExprEngine::ValuePtr(), assignValue);
-            } else {
-                auto indexValue = executeExpression(lhsToken->astOperand2(), data);
-                arrayValue->assign(indexValue, assignValue);
-            }
-        }
-    } else if (lhsToken->isUnaryOp("*")) {
-        auto pval = executeExpression(lhsToken->astOperand1(), data);
-        if (pval && pval->type == ExprEngine::ValueType::AddressOfValue) {
-            auto val = std::dynamic_pointer_cast<ExprEngine::AddressOfValue>(pval);
-            if (val)
-                data.assignValue(lhsToken, val->varId, assignValue);
-        } else if (pval && pval->type == ExprEngine::ValueType::BinOpResult) {
-            auto b = std::dynamic_pointer_cast<ExprEngine::BinOpResult>(pval);
-            if (b && b->binop == "+") {
-                std::shared_ptr<ExprEngine::ArrayValue> arr;
-                ExprEngine::ValuePtr offset;
-                if (b->op1->type == ExprEngine::ValueType::ArrayValue) {
-                    arr = std::dynamic_pointer_cast<ExprEngine::ArrayValue>(b->op1);
-                    offset = b->op2;
-                } else {
-                    arr = std::dynamic_pointer_cast<ExprEngine::ArrayValue>(b->op2);
-                    offset = b->op1;
-                }
-                if (arr && offset) {
-                    arr->assign(offset, assignValue);
-                }
-            }
-        }
-    } else if (Token::Match(lhsToken, ". %name%")) {
-        auto structVal = executeExpression(lhsToken->astOperand1(), data);
-        if (structVal && structVal->type == ExprEngine::ValueType::StructValue)
-            data.assignStructMember(tok, &*std::static_pointer_cast<ExprEngine::StructValue>(structVal), lhsToken->strAt(1), assignValue);
-    }
-    return assignValue;
-}
-
-static ExprEngine::ValuePtr executeFunctionCall(const Token *tok, Data &data)
-{
-    std::vector<ExprEngine::ValuePtr> argValues;
-    for (const Token *argtok : getArguments(tok)) {
-        auto val = executeExpression(argtok, data);
-        argValues.push_back(val);
-        if (!argtok->valueType() || (argtok->valueType()->constness & 1) == 1)
-            continue;
-        if (auto arrayValue = std::dynamic_pointer_cast<ExprEngine::ArrayValue>(val)) {
-            ValueType vt(*argtok->valueType());
-            vt.pointer = 0;
-            auto anyVal = getValueRangeFromValueType(data.getNewSymbolName(), &vt, *data.settings);
-            arrayValue->assign(ExprEngine::ValuePtr(), anyVal);
-        } else if (auto addressOf = std::dynamic_pointer_cast<ExprEngine::AddressOfValue>(val)) {
-            ValueType vt(*argtok->valueType());
-            vt.pointer = 0;
-            if (vt.isIntegral() && argtok->valueType()->pointer == 1)
-                data.assignValue(argtok, addressOf->varId, getValueRangeFromValueType(data.getNewSymbolName(), &vt, *data.settings));
-        }
-    }
-
-    if (!tok->valueType() && tok->astParent())
-        throw std::runtime_error("Expression '" + tok->expressionString() + "' has unknown type!");
-
-    auto val = getValueRangeFromValueType(data.getNewSymbolName(), tok->valueType(), *data.settings);
-    call(data.callbacks, tok, val, &data);
-    return val;
-}
-
-static ExprEngine::ValuePtr executeArrayIndex(const Token *tok, Data &data)
-{
-    auto arrayValue = data.getArrayValue(tok->astOperand1());
-    if (arrayValue) {
-        auto indexValue = executeExpression(tok->astOperand2(), data);
-        auto conditionalValues = arrayValue->read(indexValue);
-        for (auto value: conditionalValues)
-            call(data.callbacks, tok, value.second, &data);
-        if (conditionalValues.size() == 1 && !conditionalValues[0].first)
-            return conditionalValues[0].second;
-        return std::make_shared<ExprEngine::ConditionalValue>(data.getNewSymbolName(), conditionalValues);
-    }
-
-    // TODO: Pointer value..
-    executeExpression(tok->astOperand1(), data);
-    executeExpression(tok->astOperand2(), data);
-
-    return ExprEngine::ValuePtr();
-}
-
-static ExprEngine::ValuePtr executeCast(const Token *tok, Data &data)
-{
-    const Token *expr = tok->astOperand2() ? tok->astOperand2() : tok->astOperand1();
-
-    auto val = executeExpression(expr, data);
-
-    if (expr->valueType() && expr->valueType()->type == ::ValueType::Type::VOID && expr->valueType()->pointer > 0) {
-        ::ValueType vt(*tok->valueType());
-        vt.pointer = 0;
-        auto range = getValueRangeFromValueType(data.getNewSymbolName(), &vt, *data.settings);
-
-        if (tok->valueType()->pointer == 0)
-            return range;
-
-        bool uninit = false, null = false;
-        if (val && val->type == ExprEngine::ValueType::PointerValue) {
-            null = std::static_pointer_cast<ExprEngine::PointerValue>(val)->null;
-            uninit = std::static_pointer_cast<ExprEngine::PointerValue>(val)->uninitData;
-        }
-
-        return std::make_shared<ExprEngine::PointerValue>(data.getNewSymbolName(), range, null, uninit);
-    }
-
-    if (val)
-        // TODO: Cast this..
-        return val;
-
-    return getValueRangeFromValueType(data.getNewSymbolName(), tok->valueType(), *data.settings);
-}
-
-static ExprEngine::ValuePtr executeDot(const Token *tok, Data &data)
-{
-    if (!tok->astOperand1() || !tok->astOperand1()->varId())
-        return ExprEngine::ValuePtr();
-    std::shared_ptr<ExprEngine::StructValue> structValue = std::dynamic_pointer_cast<ExprEngine::StructValue>(data.getValue(tok->astOperand1()->varId(), nullptr, nullptr));
-    if (!structValue) {
-        if (tok->originalName() == "->") {
-            std::shared_ptr<ExprEngine::PointerValue> pointerValue = std::dynamic_pointer_cast<ExprEngine::PointerValue>(data.getValue(tok->astOperand1()->varId(), nullptr, nullptr));
-            if (pointerValue) {
-                call(data.callbacks, tok->astOperand1(), pointerValue, &data);
-                structValue = std::dynamic_pointer_cast<ExprEngine::StructValue>(pointerValue->data);
-            } else {
-                call(data.callbacks, tok->astOperand1(), data.getValue(tok->astOperand1()->varId(), nullptr, nullptr), &data);
-            }
-        }
-        if (!structValue)
-            return ExprEngine::ValuePtr();
-    }
-    call(data.callbacks, tok->astOperand1(), structValue, &data);
-    return structValue->getValueOfMember(tok->astOperand2()->str());
-}
-
-static ExprEngine::ValuePtr executeBinaryOp(const Token *tok, Data &data)
-{
-    ExprEngine::ValuePtr v1 = executeExpression(tok->astOperand1(), data);
-    ExprEngine::ValuePtr v2 = executeExpression(tok->astOperand2(), data);
-    if (v1 && v2) {
-        auto result = simplifyValue(std::make_shared<ExprEngine::BinOpResult>(tok->str(), v1, v2));
-        call(data.callbacks, tok, result, &data);
-        return result;
-    }
-    return ExprEngine::ValuePtr();
-}
-
-static ExprEngine::ValuePtr executeAddressOf(const Token *tok, Data &data)
-{
-    auto addr = std::make_shared<ExprEngine::AddressOfValue>(data.getNewSymbolName(), tok->astOperand1()->varId());
-    call(data.callbacks, tok, addr, &data);
-    return addr;
-}
-
-static ExprEngine::ValuePtr executeDeref(const Token *tok, Data &data)
-{
-    ExprEngine::ValuePtr pval = executeExpression(tok->astOperand1(), data);
-    if (pval) {
-        auto addressOf = std::dynamic_pointer_cast<ExprEngine::AddressOfValue>(pval);
-        if (addressOf) {
-            auto val = data.getValue(addressOf->varId, tok->valueType(), tok);
-            call(data.callbacks, tok, val, &data);
-            return val;
-        }
-        auto pointer = std::dynamic_pointer_cast<ExprEngine::PointerValue>(pval);
-        if (pointer) {
-            auto val = pointer->data;
-            call(data.callbacks, tok, val, &data);
-            return val;
-        }
-    }
-    return ExprEngine::ValuePtr();
-}
-
-static ExprEngine::ValuePtr executeVariable(const Token *tok, Data &data)
-{
-    auto val = data.getValue(tok->varId(), tok->valueType(), tok);
-    call(data.callbacks, tok, val, &data);
-    return val;
-}
-
-static ExprEngine::ValuePtr executeKnownMacro(const Token *tok, Data &data)
-{
-    auto val = std::make_shared<ExprEngine::IntRange>(data.getNewSymbolName(), tok->getKnownIntValue(), tok->getKnownIntValue());
-    call(data.callbacks, tok, val, &data);
-    return val;
-}
-
-static ExprEngine::ValuePtr executeNumber(const Token *tok)
-{
-    if (tok->valueType()->isFloat()) {
-        long double value = MathLib::toDoubleNumber(tok->str());
-        return std::make_shared<ExprEngine::FloatRange>(tok->str(), value, value);
-    }
-    int128_t value = MathLib::toLongNumber(tok->str());
-    return std::make_shared<ExprEngine::IntRange>(tok->str(), value, value);
-}
-
-static ExprEngine::ValuePtr executeStringLiteral(const Token *tok, Data &data)
-{
-    std::string s = tok->str();
-    return std::make_shared<ExprEngine::StringLiteralValue>(data.getNewSymbolName(), s.substr(1, s.size()-2));
-}
-
-static ExprEngine::ValuePtr executeExpression1(const Token *tok, Data &data)
-{
-    if (tok->str() == "return")
-        return executeReturn(tok, data);
-
-    if (tok->isAssignmentOp())
-        // TODO: Handle more operators
-        return executeAssign(tok, data);
-
-    if (tok->astOperand1() && tok->astOperand2() && tok->str() == "[")
-        return executeArrayIndex(tok, data);
-
-    if (tok->str() == "(") {
-        if (!tok->isCast())
-            return executeFunctionCall(tok, data);
-        return executeCast(tok, data);
-    }
-
-    if (tok->str() == ".")
-        return executeDot(tok, data);
-
-    if (tok->astOperand1() && tok->astOperand2())
-        return executeBinaryOp(tok, data);
-
-    if (tok->isUnaryOp("&") && Token::Match(tok->astOperand1(), "%var%"))
-        return executeAddressOf(tok, data);
-
-    if (tok->isUnaryOp("*"))
-        return executeDeref(tok, data);
-
-    if (tok->varId())
-        return executeVariable(tok, data);
-
-    if (tok->isName() && tok->hasKnownIntValue())
-        return executeKnownMacro(tok, data);
-
-    if (tok->isNumber() || tok->tokType() == Token::Type::eChar)
-        return executeNumber(tok);
-
-    if (tok->tokType() == Token::Type::eString)
-        return executeStringLiteral(tok, data);
-
-    return ExprEngine::ValuePtr();
-}
-
-static ExprEngine::ValuePtr executeExpression(const Token *tok, Data &data)
-{
-    return translateUninitValueToRange(executeExpression1(tok, data), tok->valueType(), data);
-}
-
-static ExprEngine::ValuePtr createVariableValue(const Variable &var, Data &data);
-
-static void execute(const Token *start, const Token *end, Data &data)
-{
-    for (const Token *tok = start; tok != end; tok = tok->next()) {
-        if (Token::Match(tok, "[;{}]"))
-            data.trackProgramState(tok);
-
-        if (Token::Match(tok, "for|while|switch ("))
-            // TODO this is a bailout
-            return;
-
-        // Variable declaration..
-        if (tok->variable() && tok->variable()->nameToken() == tok) {
-            if (Token::Match(tok, "%varid% ; %varid% =", tok->varId())) {
-                // if variable is not used in assignment rhs then we do not need to create a "confusing" variable value..
-                bool foundInRhs = false;
-                visitAstNodes(tok->tokAt(3)->astOperand2(), [&](const Token *rhs) {
-                    if (rhs->varId()==tok->varId()) {
-                        foundInRhs = true;
-                        return ChildrenToVisit::done;
-                    }
-                    return ChildrenToVisit::op1_and_op2;
-                });
-                if (!foundInRhs) {
-                    tok = tok->tokAt(2);
-                    continue;
-                }
-            }
-            if (tok->variable()->isArray()) {
-                data.assignValue(tok, tok->varId(), std::make_shared<ExprEngine::ArrayValue>(&data, tok->variable()));
-                if (Token::Match(tok, "%name% ["))
-                    tok = tok->linkAt(1);
-            } else if (Token::Match(tok, "%var% ;"))
-                data.assignValue(tok, tok->varId(), createVariableValue(*tok->variable(), data));
-        } else if (!tok->astParent() && (tok->astOperand1() || tok->astOperand2()))
-            executeExpression(tok, data);
-
-        else if (Token::simpleMatch(tok, "if (")) {
-            const Token *cond = tok->next()->astOperand2();
-            const ExprEngine::ValuePtr condValue = executeExpression(cond, data);
-            Data ifData(data);
-            Data elseData(data);
-            ifData.addConstraint(condValue, true);
-            elseData.addConstraint(condValue, false);
-
-            const Token *thenStart = tok->linkAt(1)->next();
-            const Token *thenEnd = thenStart->link();
-            execute(thenStart->next(), thenEnd, ifData);
-            if (Token::simpleMatch(thenEnd, "} else {")) {
-                const Token *elseStart = thenEnd->tokAt(2);
-                execute(elseStart->next(), end, elseData);
-                execute(elseStart->link()->next(), end, ifData);
-            } else {
-                // TODO: Merge ifData and elseData
-                execute(thenEnd->next(), end, ifData);
-                execute(thenEnd->next(), end, elseData);
-            }
-            return;
-        }
-
-        if (Token::simpleMatch(tok, "} else {"))
-            tok = tok->linkAt(2);
-    }
-}
-
-void ExprEngine::executeAllFunctions(const Tokenizer *tokenizer, const Settings *settings, const std::vector<ExprEngine::Callback> &callbacks, std::ostream &trace)
-{
-    const SymbolDatabase *symbolDatabase = tokenizer->getSymbolDatabase();
-    for (const Scope *functionScope : symbolDatabase->functionScopes) {
-        try {
-            executeFunction(functionScope, tokenizer, settings, callbacks, trace);
-        } catch (const std::exception &e) {
-            // FIXME.. there should not be exceptions
-            std::string functionName = functionScope->function->name();
-            std::cout << "Verify: Aborted analysis of function '" << functionName << "': " << e.what() << std::endl;
-        }
-    }
-}
-
-static ExprEngine::ValuePtr createStructVal(const Scope *structScope, bool uninitData, Data &data)
-{
-    if (!structScope)
-        return ExprEngine::ValuePtr();
-    std::shared_ptr<ExprEngine::StructValue> structValue = std::make_shared<ExprEngine::StructValue>(data.getNewSymbolName());
-    auto uninitValue = std::make_shared<ExprEngine::UninitValue>();
-    for (const Variable &member : structScope->varlist) {
-        if (uninitData) {
-            if (member.isPointer()) {
-                structValue->member[member.name()] = uninitValue;
-                continue;
-            }
-            if (member.valueType() && member.valueType()->type >= ::ValueType::Type::CHAR) {
-                structValue->member[member.name()] = uninitValue;
-                continue;
-            }
-        }
-        ExprEngine::ValuePtr memberValue = createVariableValue(member, data);
-        if (memberValue)
-            structValue->member[member.name()] = memberValue;
-    }
-    return structValue;
-}
-
-static ExprEngine::ValuePtr createVariableValue(const Variable &var, Data &data)
-{
-    if (!var.nameToken())
-        return ExprEngine::ValuePtr();
-    const ValueType *valueType = var.valueType();
-    if (!valueType || valueType->type == ValueType::Type::UNKNOWN_TYPE)
-        valueType = var.nameToken()->valueType();
-    if (!valueType || valueType->type == ValueType::Type::UNKNOWN_TYPE) {
-        // variable with unknown type
-        if (var.isLocal() && var.isPointer() && !var.isArray())
-            return std::make_shared<ExprEngine::UninitValue>();
-        return ExprEngine::ValuePtr();
-    }
-
-    if (valueType->pointer > 0) {
-        if (var.isLocal())
-            return std::make_shared<ExprEngine::UninitValue>();
-        ValueType vt(*valueType);
-        vt.pointer = 0;
-        auto range = getValueRangeFromValueType(data.getNewSymbolName(), &vt, *data.settings);
-        return std::make_shared<ExprEngine::PointerValue>(data.getNewSymbolName(), range, true, true);
-    }
-    if (var.isArray())
-        return std::make_shared<ExprEngine::ArrayValue>(&data, &var);
-    if (valueType->isIntegral())
-        return getValueRangeFromValueType(data.getNewSymbolName(), valueType, *data.settings);
-    if (valueType->type == ValueType::Type::RECORD)
-        return createStructVal(valueType->typeScope, var.isLocal() && !var.isStatic(), data);
-    if (valueType->smartPointerType) {
-        auto structValue = createStructVal(valueType->smartPointerType->classScope, var.isLocal() && !var.isStatic(), data);
-        return std::make_shared<ExprEngine::PointerValue>(data.getNewSymbolName(), structValue, true, false);
-    }
-    if (valueType->container && valueType->container->stdStringLike) {
-        auto size = std::make_shared<ExprEngine::IntRange>(data.getNewSymbolName(), 0, ~0ULL);
-        auto value = std::make_shared<ExprEngine::IntRange>(data.getNewSymbolName(), -128, 127);
-        return std::make_shared<ExprEngine::ArrayValue>(data.getNewSymbolName(), size, value);
-    }
-    return ExprEngine::ValuePtr();
-}
-
-void ExprEngine::executeFunction(const Scope *functionScope, const Tokenizer *tokenizer, const Settings *settings, const std::vector<ExprEngine::Callback> &callbacks, std::ostream &trace)
-{
-    if (!functionScope->bodyStart)
-        return;
-    const Function *function = functionScope->function;
-    if (!function)
-        return;
-    if (functionScope->bodyStart->fileIndex() > 0)
-        // TODO.. what about functions in headers?
-        return;
-
-    int symbolValueIndex = 0;
-    TrackExecution trackExecution;
-    Data data(&symbolValueIndex, tokenizer, settings, callbacks, &trackExecution);
-
-    for (const Variable &arg : function->argumentList)
-        data.assignValue(functionScope->bodyStart, arg.declarationId(), createVariableValue(arg, data));
-
-    execute(functionScope->bodyStart, functionScope->bodyEnd, data);
-
-    if (settings->debugVerification) {
-        // TODO generate better output!!
-        trackExecution.print(trace);
-    }
-}
-
-void ExprEngine::runChecks(ErrorLogger *errorLogger, const Tokenizer *tokenizer, const Settings *settings)
-{
-    std::function<void(const Token *, const ExprEngine::Value &, ExprEngine::DataBase *)> divByZero = [=](const Token *tok, const ExprEngine::Value &value, ExprEngine::DataBase *dataBase) {
-        if (!Token::Match(tok->astParent(), "[/%]"))
-            return;
-        if (tok->astParent()->astOperand2() == tok && value.isIntValueInRange(dataBase, 0)) {
-            std::list<const Token*> callstack{tok->astParent()};
-            ErrorLogger::ErrorMessage errmsg(callstack, &tokenizer->list, Severity::SeverityType::error, "verificationDivByZero", "There is division, cannot determine that there can't be a division by zero.", CWE(369), false);
-            errorLogger->reportErr(errmsg);
-        }
-    };
-
-    std::function<void(const Token *, const ExprEngine::Value &, ExprEngine::DataBase *)> nullPointerDereference = [=](const Token *tok, const ExprEngine::Value &value, ExprEngine::DataBase *dataBase) {
-        if (!tok->astParent())
-            return;
-
-        // Is pointer dereferenced?
-        bool deref = false;
-        deref |= tok->astParent()->isUnaryOp("*");
-        deref |= Token::simpleMatch(tok->astParent(), "[");
-        deref |= Token::simpleMatch(tok->astParent(), ".") && tok == tok->astParent()->astOperand1();
-        if (!deref)
-            return;
-
-        // Is this a null pointer value?
-        try {
-            if (auto pointerValue = dynamic_cast<const ExprEngine::PointerValue*>(&value)) {
-                if (!pointerValue->null)
-                    return;
-            } else if (!value.isIntValueInRange(dataBase, 0))
-                return;
-        } catch (const std::exception &) {
-            return;
-        }
-
-        std::list<const Token*> callstack{tok->astParent()};
-        ErrorLogger::ErrorMessage errmsg(callstack, &tokenizer->list, Severity::SeverityType::error, "verificationNullPointerDereference", "There is pointer dereference, cannot determine that the pointer can't be NULL.", CWE(476), false);
-        errorLogger->reportErr(errmsg);
-    };
-
-#ifdef VERIFY_INTEGEROVERFLOW
-    std::function<void(const Token *, const ExprEngine::Value &, ExprEngine::DataBase *)> integerOverflow = [&](const Token *tok, const ExprEngine::Value &value, ExprEngine::DataBase *dataBase) {
-        if (!tok->isArithmeticalOp() || !tok->valueType() || !tok->valueType()->isIntegral() || tok->valueType()->pointer > 0)
-            return;
-
-        const ExprEngine::BinOpResult *b = dynamic_cast<const ExprEngine::BinOpResult *>(&value);
-        if (!b)
-            return;
-
-        ExprEngine::BinOpResult::IntOrFloatValue minValue,maxValue;
-        b->getRange(&minValue, &maxValue);
-        if (minValue.isFloat() || maxValue.isFloat())
-            return;
-
-        int bits = getIntBitsFromValueType(tok->valueType(), *settings);
-        if (bits == 0)
-            return;
-
-        if (tok->valueType()->sign == ::ValueType::Sign::SIGNED) {
-            int128_t v = (int128_t)1 << (bits - 1);
-            if (minValue.intValue >= -v && maxValue.intValue < v)
-                return;
-        } else {
-            int128_t v = (int128_t)1 << bits;
-            if (minValue.intValue >= 0 && maxValue.intValue < v)
-                return;
-        }
-
-        std::string note;
-        if (tok->valueType()->sign == ::ValueType::Sign::UNSIGNED)
-            note = " Note that unsigned integer overflow is defined and will wrap around.";
-
-        std::list<const Token*> callstack{tok};
-        ErrorLogger::ErrorMessage errmsg(callstack, &tokenizer->list, Severity::SeverityType::error, "verificationIntegerOverflow", "Integer overflow, " + tok->valueType()->str() + " result." + note, false);
-        errorLogger->reportErr(errmsg);
-    };
-#endif
-
-    std::vector<ExprEngine::Callback> callbacks;
-    callbacks.push_back(divByZero);
-    callbacks.push_back(nullPointerDereference);
-#ifdef VERIFY_INTEGEROVERFLOW
-    callbacks.push_back(integerOverflow);
-#endif
-    ExprEngine::executeAllFunctions(tokenizer, settings, callbacks, std::cout);
-}
diff --git a/lib/exprengine.h b/lib/exprengine.h
deleted file mode 100644
index d238cd6316f..00000000000
--- a/lib/exprengine.h
+++ /dev/null
@@ -1,275 +0,0 @@
-/*
- * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-//---------------------------------------------------------------------------
-#ifndef exprengineH
-#define exprengineH
-//---------------------------------------------------------------------------
-
-#include "config.h"
-
-#include <functional>
-#include <map>
-#include <memory>
-#include <set>
-#include <string>
-#include <vector>
-#include <stdint.h>
-
-class ErrorLogger;
-class Tokenizer;
-class Scope;
-class Settings;
-class Token;
-class Variable;
-
-#ifdef __GNUC__
-typedef __int128_t   int128_t;
-#else
-typedef long long    int128_t;
-#ifdef _MSC_VER
-#pragma message(__FILE__ "(" _CRT_STRINGIZE(__LINE__) ")" ": warning: TODO No 128-bit integer type is available => Limited analysis of large integers...")
-#else
-#warning TODO No 128-bit integer type is available => Limited analysis of large integers
-#endif
-#endif
-
-namespace ExprEngine {
-    std::string str(int128_t);
-
-    // TODO we need to handle floats, containers, pointers, aliases and structs and stuff
-    enum class ValueType {
-        UninitValue,
-        IntRange,
-        FloatRange,
-        PointerValue,
-        ConditionalValue,
-        ArrayValue,
-        StringLiteralValue,
-        StructValue,
-        AddressOfValue,
-        BinOpResult,
-        IntegerTruncation
-    };
-
-    class Value;
-    typedef std::shared_ptr<Value> ValuePtr;
-
-    class DataBase {
-    public:
-        explicit DataBase(const Settings *settings) : settings(settings) {}
-        virtual std::string getNewSymbolName() = 0;
-        const Settings * const settings;
-    };
-
-    class Value {
-    public:
-        Value(const std::string &name, const ValueType type) : name(name), type(type) {}
-        virtual ~Value() {}
-        virtual std::string getRange() const {
-            return name;
-        }
-        virtual std::string getSymbolicExpression() const {
-            return name;
-        }
-        virtual bool isIntValueInRange(DataBase *dataBase, int value) const {
-            (void)dataBase;
-            (void)value;
-            return false;
-        }
-        const std::string name;
-        ValueType type;
-    };
-
-    class UninitValue: public Value {
-    public:
-        UninitValue() : Value("?", ValueType::UninitValue) {}
-    };
-
-    class IntRange : public Value {
-    public:
-        IntRange(const std::string &name, int128_t minValue, int128_t maxValue)
-            : Value(name, ValueType::IntRange)
-            , minValue(minValue)
-            , maxValue(maxValue) {
-        }
-        std::string getRange() const override {
-            if (minValue == maxValue)
-                return str(minValue);
-            return str(minValue) + ":" + str(maxValue);
-        }
-        bool isIntValueInRange(DataBase *dataBase, int value) const override {
-            (void)dataBase;
-            return value >= minValue && value <= maxValue;
-        }
-
-        int128_t minValue;
-        int128_t maxValue;
-    };
-
-    class FloatRange : public Value {
-    public:
-        FloatRange(const std::string &name, long double minValue, long double maxValue)
-            : Value(name, ValueType::FloatRange)
-            , minValue(minValue)
-            , maxValue(maxValue) {
-        }
-
-        std::string getRange() const override {
-            return std::to_string(minValue) + ":" + std::to_string(maxValue);
-        }
-
-        long double minValue;
-        long double maxValue;
-    };
-
-    class PointerValue: public Value {
-    public:
-        PointerValue(const std::string &name, ValuePtr data, bool null, bool uninitData)
-            : Value(name, ValueType::PointerValue)
-            , data(data)
-            , null(null)
-            , uninitData(uninitData) {
-        }
-        std::string getRange() const override;
-        ValuePtr data;
-        bool null;
-        bool uninitData;
-    };
-
-    class ConditionalValue : public Value {
-    public:
-        typedef std::vector<std::pair<ValuePtr,ValuePtr>> Vector;
-
-        ConditionalValue(const std::string &name, const Vector &values) : Value(name, ValueType::ConditionalValue), values(values) {}
-
-        std::string getSymbolicExpression() const override;
-
-        Vector values;
-    };
-
-    class ArrayValue: public Value {
-    public:
-        const int MAXSIZE = 0x100000;
-
-        ArrayValue(const std::string &name, ValuePtr size, ValuePtr value);
-        ArrayValue(DataBase *data, const Variable *var);
-
-        std::string getSymbolicExpression() const override;
-
-        void assign(ValuePtr index, ValuePtr value);
-        void clear();
-        ConditionalValue::Vector read(ValuePtr index) const;
-
-        struct IndexAndValue {
-            ValuePtr index;
-            ValuePtr value;
-        };
-        std::vector<IndexAndValue> data;
-        ValuePtr size;
-    };
-
-    class StringLiteralValue: public Value {
-    public:
-        StringLiteralValue(const std::string &name, const std::string &s) : Value(name, ValueType::StringLiteralValue), string(s) {}
-
-        std::string getRange() const override {
-            return "\"" + string + "\"";
-        }
-
-        int size() const {
-            return string.size();
-        }
-        const std::string string;
-    };
-
-    class StructValue: public Value {
-    public:
-        explicit StructValue(const std::string &name) : Value(name, ValueType::StructValue) {}
-
-        std::string getSymbolicExpression() const override;
-
-        ValuePtr getValueOfMember(const std::string &name) const {
-            auto it = member.find(name);
-            return (it == member.end()) ? ValuePtr() : it->second;
-        }
-        std::map<std::string, ValuePtr> member;
-    };
-
-    class AddressOfValue: public Value {
-    public:
-        AddressOfValue(const std::string &name, int varId)
-            : Value(name, ValueType::AddressOfValue)
-            , varId(varId)
-        {}
-
-        std::string getRange() const override {
-            return "&@" + std::to_string(varId);
-        }
-
-        int varId;
-    };
-
-    class BinOpResult : public Value {
-    public:
-        BinOpResult(const std::string &binop, ValuePtr op1, ValuePtr op2)
-            : Value(getName(binop, op1, op2), ValueType::BinOpResult)
-            , binop(binop)
-            , op1(op1)
-            , op2(op2) {
-        }
-
-        bool isIntValueInRange(DataBase *dataBase, int value) const;
-        std::string getExpr(DataBase *dataBase) const;
-
-        std::string binop;
-        ValuePtr op1;
-        ValuePtr op2;
-    private:
-        std::string getName(const std::string &binop, ValuePtr op1, ValuePtr op2) const {
-            std::string name1 = op1 ? op1->name : std::string("null");
-            std::string name2 = op2 ? op2->name : std::string("null");
-            return "(" + name1 + ")" + binop + "(" + name2 + ")";
-        }
-    };
-
-    class IntegerTruncation : public Value {
-    public:
-        IntegerTruncation(const std::string &name, ValuePtr inputValue, int bits, char sign)
-            : Value(name, ValueType::IntegerTruncation)
-            , inputValue(inputValue)
-            , bits(bits)
-            , sign(sign) {
-        }
-
-        std::string getSymbolicExpression() const override;
-
-        ExprEngine::ValuePtr inputValue;
-        int bits;
-        char sign;
-    };
-
-    typedef std::function<void(const Token *, const ExprEngine::Value &, ExprEngine::DataBase *)> Callback;
-
-    /** Execute all functions */
-    void CPPCHECKLIB executeAllFunctions(const Tokenizer *tokenizer, const Settings *settings, const std::vector<Callback> &callbacks, std::ostream &trace);
-    void executeFunction(const Scope *functionScope, const Tokenizer *tokenizer, const Settings *settings, const std::vector<Callback> &callbacks, std::ostream &trace);
-
-    void runChecks(ErrorLogger *errorLogger, const Tokenizer *tokenizer, const Settings *settings);
-}
-#endif // exprengineH
diff --git a/lib/filesettings.h b/lib/filesettings.h
new file mode 100644
index 00000000000..e9f883d5a87
--- /dev/null
+++ b/lib/filesettings.h
@@ -0,0 +1,167 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef fileSettingsH
+#define fileSettingsH
+
+#include "config.h"
+#include "path.h"
+#include "platform.h"
+#include "standards.h"
+
+#include <list>
+#include <set>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+class FileWithDetails
+{
+public:
+    /**
+     * @throws std::runtime_error thrown if given path is empty
+     */
+    FileWithDetails(std::string path, Standards::Language lang, std::size_t size)
+        : mLang(lang)
+        , mSize(size)
+    {
+        setPath(std::move(path));
+        if (mPath.empty())
+            throw std::runtime_error("empty path specified");
+    }
+
+    void setPath(std::string path)
+    {
+        mPath = std::move(path);
+        mPathSimplified = Path::simplifyPath(mPath);
+        mPathAbsolute.clear();
+    }
+
+    const std::string& path() const
+    {
+        return mPath;
+    }
+
+    const std::string& spath() const
+    {
+        return mPathSimplified;
+    }
+
+    const std::string& abspath() const
+    {
+        // use delayed resolution as it will fail for files which do not exist
+        if (mPathAbsolute.empty())
+            mPathAbsolute = Path::getAbsoluteFilePath(mPath);
+        return mPathAbsolute;
+    }
+
+    std::size_t size() const
+    {
+        return mSize;
+    }
+
+    void setLang(Standards::Language lang)
+    {
+        mLang = lang;
+    }
+
+    Standards::Language lang() const
+    {
+        return mLang;
+    }
+
+    std::size_t fsFileId() const
+    {
+        return mFsFileId;
+    }
+
+    void setFsFileId(std::size_t fsFileId)
+    {
+        mFsFileId = fsFileId;
+    }
+private:
+    std::string mPath;
+    std::string mPathSimplified;
+    mutable std::string mPathAbsolute;
+    Standards::Language mLang = Standards::Language::None;
+    std::size_t mSize;
+    std::size_t mFsFileId{0};
+};
+
+/** File settings. Multiple configurations for a file is allowed. */
+struct CPPCHECKLIB FileSettings {
+    FileSettings(std::string path, Standards::Language lang, std::size_t size)
+        : file(std::move(path), lang, size)
+    {}
+
+    std::string cfg;
+    FileWithDetails file;
+    const std::string& filename() const
+    {
+        return file.path();
+    }
+    const std::string& sfilename() const
+    {
+        return file.spath();
+    }
+    std::string defines;
+    // TODO: handle differently
+    std::string cppcheckDefines() const {
+        std::ostringstream oss;
+        oss << defines;
+
+        if (msc) {
+            oss << ";_MSC_VER=1900";
+        }
+        if (useMfc) {
+            oss << ";__AFXWIN_H__=1";
+        }
+
+        // Add Y2038 specific flags to configuration
+        if (timeBitsDefined) {
+            oss << ";_TIME_BITS=" << timeBitsValue;
+        }
+        if (fileOffsetBitsDefined) {
+            oss << ";_FILE_OFFSET_BITS=" << fileOffsetBitsValue;
+        }
+        if (useTimeBits64Defined) {
+            oss << ";_USE_TIME_BITS64";
+        }
+
+        return oss.str();
+    }
+    std::set<std::string> undefs;
+    std::list<std::string> includePaths;
+    // only used by clang mode
+    std::list<std::string> systemIncludePaths;
+    std::string standard;
+    Platform::Type platformType = Platform::Type::Unspecified;
+    // TODO: get rid of these
+    bool msc{};
+    bool useMfc{};
+
+    // Y2038 specific configuration flags
+    bool timeBitsDefined{};
+    int timeBitsValue{};
+    bool useTimeBits64Defined{};
+    bool fileOffsetBitsDefined{};
+    int fileOffsetBitsValue{};
+};
+
+#endif // fileSettingsH
diff --git a/lib/findtoken.cpp b/lib/findtoken.cpp
new file mode 100644
index 00000000000..74848228a05
--- /dev/null
+++ b/lib/findtoken.cpp
@@ -0,0 +1,145 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "findtoken.h"
+
+#include "astutils.h"
+#include "token.h"
+
+class Library;
+
+template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+static bool findTokensSkipDeadCodeImpl(const Library& library,
+                                       T* start,
+                                       const Token* end,
+                                       const std::function<bool(const Token*)>& pred,
+                                       const std::function<bool(T*)>& found,
+                                       const std::function<std::vector<MathLib::bigint>(const Token*)>& evaluate,
+                                       bool skipUnevaluated)
+{
+    for (T* tok = start; precedes(tok, end); tok = tok->next()) {
+        if (pred(tok)) {
+            if (found(tok))
+                return true;
+        }
+        if (Token::Match(tok, "if|for|while (") && Token::simpleMatch(tok->linkAt(1), ") {")) {
+            const Token* condTok = getCondTok(tok);
+            if (!condTok)
+                continue;
+            auto result = evaluate(condTok);
+            if (result.empty())
+                continue;
+            if (internal::findTokensSkipDeadCodeImpl(library, tok->next(), tok->linkAt(1), pred, found, evaluate, skipUnevaluated))
+                return true;
+            T* thenStart = tok->linkAt(1)->next();
+            T* elseStart = nullptr;
+            if (Token::simpleMatch(thenStart->link(), "} else {"))
+                elseStart = thenStart->link()->tokAt(2);
+
+            auto r = result.front();
+            if (r == 0) {
+                if (elseStart) {
+                    if (internal::findTokensSkipDeadCodeImpl(library, elseStart, elseStart->link(), pred, found, evaluate, skipUnevaluated))
+                        return true;
+                    if (isReturnScope(elseStart->link(), library))
+                        return true;
+                    tok = elseStart->link();
+                } else {
+                    tok = thenStart->link();
+                }
+            } else {
+                if (internal::findTokensSkipDeadCodeImpl(library, thenStart, thenStart->link(), pred, found, evaluate, skipUnevaluated))
+                    return true;
+                if (isReturnScope(thenStart->link(), library))
+                    return true;
+                tok = thenStart->link();
+            }
+        } else if (Token::Match(tok->astParent(), "&&|?|%oror%") && astIsLHS(tok)) {
+            auto result = evaluate(tok);
+            if (result.empty())
+                continue;
+            const bool cond = result.front() != 0;
+            T* next = nullptr;
+            if ((cond && Token::simpleMatch(tok->astParent(), "||")) ||
+                (!cond && Token::simpleMatch(tok->astParent(), "&&"))) {
+                next = nextAfterAstRightmostLeaf(tok->astParent());
+            } else if (Token::simpleMatch(tok->astParent(), "?")) {
+                T* colon = tok->astParent()->astOperand2();
+                if (!cond) {
+                    next = colon;
+                } else {
+                    if (internal::findTokensSkipDeadCodeImpl(library, tok->astParent()->next(), colon, pred, found, evaluate, skipUnevaluated))
+                        return true;
+                    next = nextAfterAstRightmostLeaf(colon);
+                }
+            }
+            if (next)
+                tok = next;
+        } else if (Token::simpleMatch(tok, "} else {")) {
+            const Token* condTok = getCondTokFromEnd(tok);
+            if (!condTok)
+                continue;
+            auto result = evaluate(condTok);
+            if (result.empty())
+                continue;
+            if (isReturnScope(tok->link(), library))
+                return true;
+            auto r = result.front();
+            if (r != 0) {
+                tok = tok->linkAt(2);
+            }
+        } else if (Token::simpleMatch(tok, "[") && Token::Match(tok->link(), "] (|{")) {
+            T* afterCapture = tok->link()->next();
+            if (Token::simpleMatch(afterCapture, "(") && afterCapture->link())
+                tok = afterCapture->link()->next();
+            else
+                tok = afterCapture;
+        }
+        if (skipUnevaluated && isUnevaluated(tok)) {
+            T *next = tok->linkAt(1);
+            if (!next)
+                continue;
+            tok = next;
+        }
+    }
+    return false;
+}
+
+namespace internal {
+    bool findTokensSkipDeadCodeImpl(const Library& library,
+                                    Token* start,
+                                    const Token* end,
+                                    const std::function<bool(const Token*)>& pred,
+                                    const std::function<bool(Token*)>& found,
+                                    const std::function<std::vector<MathLib::bigint>(const Token*)>& evaluate,
+                                    bool skipUnevaluated)
+    {
+        return ::findTokensSkipDeadCodeImpl(library, start, end, pred, found, evaluate, skipUnevaluated);
+    }
+
+    bool findTokensSkipDeadCodeImpl(const Library& library,
+                                    const Token* start,
+                                    const Token* end,
+                                    const std::function<bool(const Token*)>& pred,
+                                    const std::function<bool(const Token*)>& found,
+                                    const std::function<std::vector<MathLib::bigint>(const Token*)>& evaluate,
+                                    bool skipUnevaluated)
+    {
+        return ::findTokensSkipDeadCodeImpl(library, start, end, pred, found, evaluate, skipUnevaluated);
+    }
+}
diff --git a/lib/findtoken.h b/lib/findtoken.h
new file mode 100644
index 00000000000..222c3ba5c8c
--- /dev/null
+++ b/lib/findtoken.h
@@ -0,0 +1,173 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+//---------------------------------------------------------------------------
+#ifndef findtokenH
+#define findtokenH
+//---------------------------------------------------------------------------
+
+#include <functional>
+#include <type_traits>
+#include <vector>
+
+#include "config.h"
+#include "mathlib.h"
+#include "token.h"
+
+class Library;
+
+inline std::vector<MathLib::bigint> evaluateKnownValues(const Token* tok)
+{
+    if (!tok->hasKnownIntValue())
+        return {};
+    return {tok->getKnownIntValue()};
+}
+
+template<class T, class Predicate, class Found, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+void findTokensImpl(T* start, const Token* end, const Predicate& pred, Found found)
+{
+    for (T* tok = start; precedes(tok, end); tok = tok->next()) {
+        if (pred(tok)) {
+            if (found(tok))
+                break;
+        }
+    }
+}
+
+template<class T, class Predicate, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+std::vector<T*> findTokens(T* start, const Token* end, const Predicate& pred)
+{
+    std::vector<T*> result;
+    findTokensImpl(start, end, pred, [&](T* tok) {
+        result.push_back(tok);
+        return false;
+    });
+    return result;
+}
+
+template<class T, class Predicate, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+T* findToken(T* start, const Token* end, const Predicate& pred)
+{
+    T* result = nullptr;
+    findTokensImpl(start, end, pred, [&](T* tok) {
+        result = tok;
+        return true;
+    });
+    return result;
+}
+
+namespace internal {
+    bool findTokensSkipDeadCodeImpl(const Library &library,
+                                    Token *start,
+                                    const Token *end,
+                                    const std::function<bool(const Token *)> &pred,
+                                    const std::function<bool(Token *)>& found,
+                                    const std::function<std::vector<MathLib::bigint>(const Token *)> &evaluate,
+                                    bool skipUnevaluated);
+
+    bool findTokensSkipDeadCodeImpl(const Library &library,
+                                    const Token *start,
+                                    const Token *end,
+                                    const std::function<bool(const Token *)> &pred,
+                                    const std::function<bool(const Token *)>& found,
+                                    const std::function<std::vector<MathLib::bigint>(const Token *)> &evaluate,
+                                    bool skipUnevaluated);
+}
+
+template<class T, class Predicate, class Evaluate, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+std::vector<T*> findTokensSkipDeadCode(const Library& library,
+                                       T* start,
+                                       const Token* end,
+                                       const Predicate& pred,
+                                       const Evaluate& evaluate)
+{
+    std::vector<T*> result;
+    (void)internal::findTokensSkipDeadCodeImpl(
+        library,
+        start,
+        end,
+        pred,
+        [&](T* tok) {
+        result.push_back(tok);
+        return false;
+    },
+        evaluate,
+        false);
+    return result;
+}
+
+template<class T, class Predicate, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+std::vector<T*> findTokensSkipDeadCode(const Library& library, T* start, const Token* end, const Predicate& pred)
+{
+    return findTokensSkipDeadCode(library, start, end, pred, &evaluateKnownValues);
+}
+
+template<class T, class Predicate, class Evaluate, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+std::vector<T*> findTokensSkipDeadAndUnevaluatedCode(const Library& library,
+                                                     T* start,
+                                                     const Token* end,
+                                                     const Predicate& pred,
+                                                     const Evaluate& evaluate)
+{
+    std::vector<T*> result;
+    (void)internal::findTokensSkipDeadCodeImpl(
+        library,
+        start,
+        end,
+        pred,
+        [&](T* tok) {
+        result.push_back(tok);
+        return false;
+    },
+        evaluate,
+        true);
+    return result;
+}
+
+template<class T, class Predicate, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+std::vector<T*> findTokensSkipDeadAndUnevaluatedCode(const Library& library, T* start, const Token* end, const Predicate& pred)
+{
+    return findTokensSkipDeadAndUnevaluatedCode(library, start, end, pred, &evaluateKnownValues);
+}
+
+
+template<class T, class Predicate, class Evaluate, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+T* findTokenSkipDeadCode(const Library& library, T* start, const Token* end, const Predicate& pred, const Evaluate& evaluate)
+{
+    T* result = nullptr;
+    (void)internal::findTokensSkipDeadCodeImpl(
+        library,
+        start,
+        end,
+        pred,
+        [&](T* tok) {
+        result = tok;
+        return true;
+    },
+        evaluate,
+        false);
+    return result;
+}
+
+template<class T, class Predicate, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+T* findTokenSkipDeadCode(const Library& library, T* start, const Token* end, const Predicate& pred)
+{
+    return findTokenSkipDeadCode(library, start, end, pred, &evaluateKnownValues);
+}
+
+#endif // findtokenH
diff --git a/lib/forwardanalyzer.cpp b/lib/forwardanalyzer.cpp
new file mode 100644
index 00000000000..5c97528372b
--- /dev/null
+++ b/lib/forwardanalyzer.cpp
@@ -0,0 +1,960 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "forwardanalyzer.h"
+
+#include "analyzer.h"
+#include "astutils.h"
+#include "config.h"
+#include "errorlogger.h"
+#include "errortypes.h"
+#include "mathlib.h"
+#include "settings.h"
+#include "symboldatabase.h"
+#include "token.h"
+#include "tokenlist.h"
+#include "utils.h"
+#include "valueptr.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cstdio>
+#include <cstdint>
+#include <functional>
+#include <list>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace {
+    struct ForwardTraversal {
+        enum class Progress : std::uint8_t { Continue, Break, Skip };
+        ForwardTraversal(const ValuePtr<Analyzer>& analyzer, const TokenList& tokenList, ErrorLogger& errorLogger, const Settings& settings)
+            : analyzer(analyzer), tokenList(tokenList), errorLogger(errorLogger), settings(settings)
+        {}
+        ValuePtr<Analyzer> analyzer;
+        const TokenList& tokenList;
+        ErrorLogger& errorLogger;
+        const Settings& settings;
+        Analyzer::Action actions;
+        bool analyzeOnly{};
+        bool analyzeTerminate{};
+        Analyzer::Terminate terminate = Analyzer::Terminate::None;
+        std::vector<Token*> loopEnds;
+        int branchCount = 0;
+
+        Progress Break(Analyzer::Terminate t = Analyzer::Terminate::None) {
+            if ((!analyzeOnly || analyzeTerminate) && t != Analyzer::Terminate::None)
+                terminate = t;
+            return Progress::Break;
+        }
+
+        struct Branch {
+            explicit Branch(Token* tok = nullptr) : endBlock(tok) {}
+            Token* endBlock = nullptr;
+            Analyzer::Action action = Analyzer::Action::None;
+            bool check = false;
+            bool escape = false;
+            bool escapeUnknown = false;
+            bool active = false;
+            bool isEscape() const {
+                return escape || escapeUnknown;
+            }
+            bool isConclusiveEscape() const {
+                return escape && !escapeUnknown;
+            }
+            bool isModified() const {
+                return action.isModified() && !isConclusiveEscape();
+            }
+            bool isInconclusive() const {
+                return action.isInconclusive() && !isConclusiveEscape();
+            }
+            bool isDead() const {
+                return action.isModified() || action.isInconclusive() || isEscape();
+            }
+        };
+
+        bool stopUpdates() {
+            analyzeOnly = true;
+            return actions.isModified();
+        }
+
+        bool stopOnCondition(const Token* condTok) const
+        {
+            if (analyzer->isConditional() && findAstNode(condTok, [](const Token* tok) {
+                return tok->isIncompleteVar();
+            }))
+                return true;
+            return analyzer->stopOnCondition(condTok);
+        }
+
+        std::pair<bool, bool> evalCond(const Token* tok, const Token* ctx = nullptr) const {
+            if (!tok)
+                return std::make_pair(false, false);
+            std::vector<MathLib::bigint> result = analyzer->evaluate(tok, ctx);
+            // TODO: We should convert to bool
+            const bool checkThen = std::any_of(result.cbegin(), result.cend(), [](MathLib::bigint x) {
+                return x != 0;
+            });
+            const bool checkElse = std::any_of(result.cbegin(), result.cend(), [](MathLib::bigint x) {
+                return x == 0;
+            });
+            return std::make_pair(checkThen, checkElse);
+        }
+
+        bool isConditionTrue(const Token* tok, const Token* ctx = nullptr) const {
+            return evalCond(tok, ctx).first;
+        }
+
+        template<class T, class F, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+        Progress traverseTok(T* tok, const F &f, bool traverseUnknown, T** out = nullptr) {
+            if (Token::Match(tok, "asm|goto"))
+                return Break(Analyzer::Terminate::Bail);
+            if (Token::Match(tok, "setjmp|longjmp (")) {
+                // Traverse the parameters of the function before escaping
+                traverseRecursive(tok->next()->astOperand2(), f, traverseUnknown);
+                return Break(Analyzer::Terminate::Bail);
+            }
+            if (Token::simpleMatch(tok, "continue")) {
+                if (loopEnds.empty())
+                    return Break(Analyzer::Terminate::Escape);
+                // If we are in a loop then jump to the end
+                if (out)
+                    *out = loopEnds.back();
+            } else if (Token::Match(tok, "return|throw")) {
+                traverseRecursive(tok->astOperand2(), f, traverseUnknown);
+                traverseRecursive(tok->astOperand1(), f, traverseUnknown);
+                return Break(Analyzer::Terminate::Escape);
+            } else if (Token::Match(tok, "%name% (") && isEscapeFunction(tok, settings.library)) {
+                // Traverse the parameters of the function before escaping
+                traverseRecursive(tok->next()->astOperand2(), f, traverseUnknown);
+                return Break(Analyzer::Terminate::Escape);
+            } else if (isUnevaluated(tok->previous())) {
+                if (out)
+                    *out = tok->link();
+                return Progress::Skip;
+            } else if (tok->astOperand1() && tok->astOperand2() && Token::Match(tok, "?|&&|%oror%")) {
+                if (traverseConditional(tok, f, traverseUnknown) == Progress::Break)
+                    return Break();
+                if (out)
+                    *out = nextAfterAstRightmostLeaf(tok);
+                return Progress::Skip;
+                // Skip lambdas
+            } else if (T* lambdaEndToken = findLambdaEndToken(tok)) {
+                if (checkScope(lambdaEndToken).isModified())
+                    return Break(Analyzer::Terminate::Bail);
+                if (out)
+                    *out = lambdaEndToken->next();
+                // Skip class scope
+            } else if (tok->str() == "{" && tok->scope() && tok->scope()->isClassOrStruct()) {
+                if (out)
+                    *out = tok->link();
+            } else {
+                if (f(tok) == Progress::Break)
+                    return Break();
+            }
+            return Progress::Continue;
+        }
+
+        template<class T, class F, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+        Progress traverseRecursive(T* tok, const F &f, bool traverseUnknown, unsigned int recursion=0) {
+            if (!tok)
+                return Progress::Continue;
+            if (recursion > 10000)
+                return Progress::Skip;
+            T* firstOp = tok->astOperand1();
+            T* secondOp = tok->astOperand2();
+            // Evaluate:
+            //     1. RHS of assignment before LHS
+            //     2. Unary op before operand
+            //     3. Function arguments before function call
+            if (tok->isAssignmentOp() || !secondOp || isFunctionCall(tok))
+                std::swap(firstOp, secondOp);
+            if (firstOp && traverseRecursive(firstOp, f, traverseUnknown, recursion+1) == Progress::Break)
+                return Break();
+            const Progress p = tok->isAssignmentOp() ? Progress::Continue : traverseTok(tok, f, traverseUnknown);
+            if (p == Progress::Break)
+                return Break();
+            if (p == Progress::Continue && secondOp && traverseRecursive(secondOp, f, traverseUnknown, recursion+1) == Progress::Break)
+                return Break();
+            if (tok->isAssignmentOp() && traverseTok(tok, f, traverseUnknown) == Progress::Break)
+                return Break();
+            return Progress::Continue;
+        }
+
+        template<class T, class F, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+        Progress traverseConditional(T* tok, F f, bool traverseUnknown) {
+            Analyzer::Action action = analyzer->analyze(tok, Analyzer::Direction::Forward);
+            if (action.isNone() && Token::Match(tok, "?|&&|%oror%") && tok->astOperand1() && tok->astOperand2()) {
+                const T* condTok = tok->astOperand1();
+                T* childTok = tok->astOperand2();
+                bool checkThen, checkElse;
+                std::tie(checkThen, checkElse) = evalCond(condTok);
+                if (!checkThen && !checkElse) {
+                    if (!traverseUnknown && stopOnCondition(condTok) && tok->str() != "?" && stopUpdates()) {
+                        return Progress::Continue;
+                    }
+                    checkThen = true;
+                    checkElse = true;
+                }
+                if (childTok->str() == ":") {
+                    if (checkThen && traverseRecursive(childTok->astOperand1(), f, traverseUnknown) == Progress::Break)
+                        return Break();
+                    if (checkElse && traverseRecursive(childTok->astOperand2(), f, traverseUnknown) == Progress::Break)
+                        return Break();
+                } else {
+                    if (!checkThen && tok->str() == "&&")
+                        return Progress::Continue;
+                    if (!checkElse && tok->str() == "||")
+                        return Progress::Continue;
+                    if (traverseRecursive(childTok, f, traverseUnknown) == Progress::Break)
+                        return Break();
+                }
+            } else {
+                return f(tok, action);
+            }
+            return Progress::Continue;
+        }
+
+        Progress update(Token* tok) {
+            Analyzer::Action action = analyzer->analyze(tok, Analyzer::Direction::Forward);
+            return update(tok, action);
+        }
+
+        Progress update(Token* tok, Analyzer::Action action)
+        {
+            actions |= action;
+            if (!action.isNone() && !analyzeOnly)
+                analyzer->update(tok, action, Analyzer::Direction::Forward);
+            if (action.isInconclusive() && !analyzer->lowerToInconclusive())
+                return Break(Analyzer::Terminate::Inconclusive);
+            if (action.isInvalid())
+                return Break(Analyzer::Terminate::Modified);
+            if (action.isWrite() && !action.isRead())
+                // Analysis of this write will continue separately
+                return Break(Analyzer::Terminate::Modified);
+            return Progress::Continue;
+        }
+
+        struct AsUpdate {
+            ForwardTraversal* self = nullptr;
+
+            explicit AsUpdate(ForwardTraversal* self) : self(self) {}
+
+            template<class... Ts>
+            Progress operator()(Ts... xs) const
+            {
+                assert(self);
+                return self->update(xs ...);
+            }
+        };
+
+        Progress updateTok(Token* tok, Token** out = nullptr) {
+            return traverseTok(tok, AsUpdate{this}, false, out);
+        }
+
+        Progress updateRecursive(Token* tok) {
+            return traverseRecursive(tok, AsUpdate{this}, false);
+        }
+
+        struct AsAnalyze {
+            ForwardTraversal* self = nullptr;
+            Analyzer::Action* result = nullptr;
+
+            AsAnalyze(ForwardTraversal* self, Analyzer::Action* result) : self(self), result(result) {}
+
+            Progress operator()(const Token* tok) const
+            {
+                assert(self);
+                assert(result);
+                return (*this)(tok, self->analyzer->analyze(tok, Analyzer::Direction::Forward));
+            }
+
+            Progress operator()(const Token* /*unused*/, Analyzer::Action action) const
+            {
+                assert(self);
+                assert(result);
+                *result = action;
+                if (result->isModified() || result->isInconclusive())
+                    return self->Break();
+                return Progress::Continue;
+            }
+        };
+
+        Analyzer::Action analyzeRecursive(const Token* start) {
+            Analyzer::Action result = Analyzer::Action::None;
+            traverseRecursive(start, AsAnalyze{this, &result}, true);
+            return result;
+        }
+
+        Analyzer::Action analyzeRange(const Token* start, const Token* end) const {
+            Analyzer::Action result = Analyzer::Action::None;
+            for (const Token* tok = start; tok && tok != end; tok = tok->next()) {
+                Analyzer::Action action = analyzer->analyze(tok, Analyzer::Direction::Forward);
+                if (action.isModified() || action.isInconclusive())
+                    return action;
+                result |= action;
+            }
+            return result;
+        }
+
+        ForwardTraversal fork(bool analyze = false) const {
+            ForwardTraversal ft = *this;
+            if (analyze) {
+                ft.analyzeOnly = true;
+                ft.analyzeTerminate = true;
+            }
+            ft.actions = Analyzer::Action::None;
+            return ft;
+        }
+
+        std::vector<ForwardTraversal> tryForkScope(Token* endBlock, bool isModified = false) const {
+            if (analyzer->updateScope(endBlock, isModified)) {
+                ForwardTraversal ft = fork();
+                return {std::move(ft)};
+            }
+            return std::vector<ForwardTraversal> {};
+        }
+
+        std::vector<ForwardTraversal> tryForkUpdateScope(Token* endBlock, bool isModified = false) const {
+            std::vector<ForwardTraversal> result = tryForkScope(endBlock, isModified);
+            for (ForwardTraversal& ft : result)
+                ft.updateScope(endBlock);
+            return result;
+        }
+
+        static bool hasGoto(const Token* endBlock) {
+            return Token::findsimplematch(endBlock->link(), "goto", endBlock);
+        }
+
+        static bool hasJump(const Token* endBlock) {
+            return Token::findmatch(endBlock->link(), "goto|break", endBlock);
+        }
+
+        bool hasInnerReturnScope(const Token* start, const Token* end) const {
+            for (const Token* tok=start; tok != end; tok = tok->previous()) {
+                if (Token::simpleMatch(tok, "}")) {
+                    const Token* ftok = nullptr;
+                    const bool r = isReturnScope(tok, settings.library, &ftok);
+                    if (r)
+                        return true;
+                }
+            }
+            return false;
+        }
+
+        bool isEscapeScope(const Token* endBlock, bool& unknown) const {
+            const Token* ftok = nullptr;
+            const bool r = isReturnScope(endBlock, settings.library, &ftok);
+            if (!r && ftok)
+                unknown = true;
+            return r;
+        }
+
+        Analyzer::Action analyzeScope(const Token* endBlock) const {
+            return analyzeRange(endBlock->link(), endBlock);
+        }
+
+        Analyzer::Action checkScope(Token* endBlock) const {
+            Analyzer::Action a = analyzeScope(endBlock);
+            tryForkUpdateScope(endBlock, a.isModified());
+            return a;
+        }
+
+        Analyzer::Action checkScope(const Token* endBlock) const {
+            Analyzer::Action a = analyzeScope(endBlock);
+            return a;
+        }
+
+        bool checkBranch(Branch& branch) const {
+            Analyzer::Action a = analyzeScope(branch.endBlock);
+            branch.action = a;
+            std::vector<ForwardTraversal> ft1 = tryForkUpdateScope(branch.endBlock, a.isModified());
+            const bool bail = hasGoto(branch.endBlock);
+            if (!a.isModified() && !bail) {
+                if (ft1.empty()) {
+                    // Traverse into the branch to see if there is a conditional escape
+                    if (!branch.escape && hasInnerReturnScope(branch.endBlock->previous(), branch.endBlock->link())) {
+                        ForwardTraversal ft2 = fork(true);
+                        ft2.updateScope(branch.endBlock);
+                        if (ft2.terminate == Analyzer::Terminate::Escape) {
+                            branch.escape = true;
+                            branch.escapeUnknown = false;
+                        }
+                    }
+                } else {
+                    if (ft1.front().terminate == Analyzer::Terminate::Escape) {
+                        branch.escape = true;
+                        branch.escapeUnknown = false;
+                    }
+                }
+            }
+            return bail;
+        }
+
+        bool reentersLoop(Token* endBlock, const Token* condTok, const Token* stepTok) const {
+            if (!condTok)
+                return true;
+            if (Token::simpleMatch(condTok, ":"))
+                return true;
+            bool stepChangesCond = false;
+            if (stepTok) {
+                std::pair<const Token*, const Token*> exprToks = stepTok->findExpressionStartEndTokens();
+                if (exprToks.first != nullptr && exprToks.second != nullptr)
+                    stepChangesCond |=
+                        findExpressionChanged(condTok, exprToks.first, exprToks.second->next(), settings) != nullptr;
+            }
+            const bool bodyChangesCond = findExpressionChanged(condTok, endBlock->link(), endBlock, settings);
+            // Check for mutation in the condition
+            const bool condChanged =
+                nullptr != findAstNode(condTok, [&](const Token* tok) {
+                return isVariableChanged(tok, 0, settings);
+            });
+            const bool changed = stepChangesCond || bodyChangesCond || condChanged;
+            if (!changed)
+                return true;
+            ForwardTraversal ft = fork(true);
+            ft.updateScope(endBlock);
+            return ft.isConditionTrue(condTok) && bodyChangesCond;
+        }
+
+        Progress updateInnerLoop(Token* endBlock, Token* stepTok, Token* condTok) {
+            loopEnds.push_back(endBlock);
+            OnExit oe{[&] {
+                    loopEnds.pop_back();
+                }};
+            if (endBlock && updateScope(endBlock) == Progress::Break)
+                return Break();
+            if (stepTok && updateRecursive(stepTok) == Progress::Break)
+                return Break();
+            if (condTok && !Token::simpleMatch(condTok, ":") && updateRecursive(condTok) == Progress::Break)
+                return Break();
+            return Progress::Continue;
+        }
+
+        Progress updateLoop(const Token* endToken,
+                            Token* endBlock,
+                            Token* condTok,
+                            Token* initTok = nullptr,
+                            Token* stepTok = nullptr,
+                            bool exit = false) {
+            if (initTok && updateRecursive(initTok) == Progress::Break)
+                return Break();
+            const bool isDoWhile = precedes(endBlock, condTok);
+            bool checkThen = true;
+            bool checkElse = false;
+            if (condTok && !Token::simpleMatch(condTok, ":"))
+                std::tie(checkThen, checkElse) = evalCond(condTok, isDoWhile ? endBlock->previous() : nullptr);
+            // exiting a do while(false)
+            if (checkElse && exit) {
+                if (hasJump(endBlock)) {
+                    if (!analyzer->lowerToPossible())
+                        return Break(Analyzer::Terminate::Bail);
+                    if (analyzer->isConditional() && stopUpdates())
+                        return Break(Analyzer::Terminate::Conditional);
+                }
+                return Progress::Continue;
+            }
+            Analyzer::Action bodyAnalysis = analyzeScope(endBlock);
+            Analyzer::Action allAnalysis = bodyAnalysis;
+            Analyzer::Action condAnalysis;
+            if (condTok) {
+                condAnalysis = analyzeRecursive(condTok);
+                allAnalysis |= condAnalysis;
+            }
+            if (stepTok)
+                allAnalysis |= analyzeRecursive(stepTok);
+            actions |= allAnalysis;
+            // do while(false) is not really a loop
+            if (checkElse && isDoWhile &&
+                (condTok->hasKnownIntValue() ||
+                 (!bodyAnalysis.isModified() && !condAnalysis.isModified() && condAnalysis.isRead()))) {
+                if (updateScope(endBlock) == Progress::Break)
+                    return Break();
+                return updateRecursive(condTok);
+            }
+            if (allAnalysis.isInconclusive()) {
+                if (!analyzer->lowerToInconclusive())
+                    return Break(Analyzer::Terminate::Bail);
+            } else if (allAnalysis.isModified() || (exit && allAnalysis.isIdempotent())) {
+                if (!analyzer->lowerToPossible())
+                    return Break(Analyzer::Terminate::Bail);
+            }
+
+            if (condTok && !Token::simpleMatch(condTok, ":")) {
+                if (!isDoWhile || (!bodyAnalysis.isModified() && !bodyAnalysis.isIdempotent()))
+                    if (updateRecursive(condTok) == Progress::Break)
+                        return Break();
+            }
+            if (!checkThen && !checkElse && !isDoWhile && stopOnCondition(condTok) && stopUpdates())
+                return Break(Analyzer::Terminate::Conditional);
+            // condition is false, we don't enter the loop
+            if (checkElse && !isDoWhile)
+                return Progress::Continue;
+            if (checkThen || isDoWhile) {
+                // Since we are re-entering the loop then assume the condition is true to update the state
+                if (exit)
+                    analyzer->assume(condTok, true, Analyzer::Assume::Quiet | Analyzer::Assume::Absolute);
+                if (updateInnerLoop(endBlock, stepTok, condTok) == Progress::Break)
+                    return Break();
+                // If loop re-enters then it could be modified again
+                if (allAnalysis.isModified() && reentersLoop(endBlock, condTok, stepTok))
+                    return Break(Analyzer::Terminate::Bail);
+                if (allAnalysis.isIncremental())
+                    return Break(Analyzer::Terminate::Bail);
+            } else if (allAnalysis.isModified()) {
+                std::vector<ForwardTraversal> ftv = tryForkScope(endBlock, allAnalysis.isModified());
+                bool forkContinue = true;
+                for (ForwardTraversal& ft : ftv) {
+                    if (condTok)
+                        ft.analyzer->assume(condTok, false, Analyzer::Assume::Quiet);
+                    if (ft.updateInnerLoop(endBlock, stepTok, condTok) == Progress::Break)
+                        forkContinue = false;
+                }
+
+                if (allAnalysis.isModified() || !forkContinue) {
+                    // TODO: Don't bail on missing condition
+                    if (!condTok)
+                        return Break(Analyzer::Terminate::Bail);
+                    if (analyzer->isConditional() && stopUpdates())
+                        return Break(Analyzer::Terminate::Conditional);
+                    analyzer->assume(condTok, false);
+                }
+                if (forkContinue) {
+                    for (ForwardTraversal& ft : ftv) {
+                        if (!ft.actions.isIncremental())
+                            ft.updateRange(endBlock, endToken);
+                    }
+                }
+                if (allAnalysis.isIncremental())
+                    return Break(Analyzer::Terminate::Bail);
+            } else {
+                if (updateInnerLoop(endBlock, stepTok, condTok) == Progress::Break)
+                    return Progress::Break;
+                if (allAnalysis.isIncremental())
+                    return Break(Analyzer::Terminate::Bail);
+            }
+            return Progress::Continue;
+        }
+
+        Progress updateLoopExit(const Token* endToken,
+                                Token* endBlock,
+                                Token* condTok,
+                                Token* initTok = nullptr,
+                                Token* stepTok = nullptr) {
+            return updateLoop(endToken, endBlock, condTok, initTok, stepTok, true);
+        }
+
+        Progress updateScope(Token* endBlock, int depth = 20)
+        {
+            if (!endBlock)
+                return Break();
+            assert(endBlock->link());
+            Token* ctx = endBlock->link()->previous();
+            if (Token::simpleMatch(ctx, ")"))
+                ctx = ctx->link()->previous();
+            if (ctx)
+                analyzer->updateState(ctx);
+            return updateRange(endBlock->link(), endBlock, depth);
+        }
+
+        /**
+         * @throws InternalError thrown on cyclic analysis
+         */
+        Progress updateRange(Token* start, const Token* end, int depth = 20) {
+            if (depth < 0)
+                return Break(Analyzer::Terminate::Bail);
+            std::size_t i = 0;
+            for (Token* tok = start; precedes(tok, end); tok = tok->next()) {
+                Token* next = nullptr;
+                if (tok->index() <= i)
+                    throw InternalError(tok, "Cyclic forward analysis.");
+                i = tok->index();
+
+                if (tok->link()) {
+                    // Skip casts..
+                    if (tok->str() == "(" && !tok->astOperand2() && tok->isCast()) {
+                        tok = tok->link();
+                        continue;
+                    }
+                    // Skip template arguments..
+                    if (tok->str() == "<") {
+                        tok = tok->link();
+                        continue;
+                    }
+                }
+
+                // Evaluate RHS of assignment before LHS
+                if (Token* assignTok = assignExpr(tok)) {
+                    if (updateRecursive(assignTok) == Progress::Break)
+                        return Break();
+                    tok = nextAfterAstRightmostLeaf(assignTok);
+                    if (!tok)
+                        return Break();
+                } else if (Token::simpleMatch(tok, ") {") && Token::Match(tok->link()->previous(), "for|while (") &&
+                           !Token::simpleMatch(tok->link()->astOperand2(), ":")) {
+                    // In the middle of a loop structure so bail
+                    return Break(Analyzer::Terminate::Bail);
+                } else if (tok->str() == ";" && tok->astParent()) {
+                    Token* top = tok->astTop();
+                    if (Token::Match(top->previous(), "for|while (") && Token::simpleMatch(top->link(), ") {")) {
+                        Token* endCond = top->link();
+                        Token* endBlock = endCond->linkAt(1);
+                        Token* condTok = getCondTok(top);
+                        Token* stepTok = getStepTok(top);
+                        // The semicolon should belong to the initTok otherwise something went wrong, so just bail
+                        if (tok->astOperand2() != condTok && !Token::simpleMatch(tok->astOperand2(), ";"))
+                            return Break(Analyzer::Terminate::Bail);
+                        if (updateLoop(end, endBlock, condTok, nullptr, stepTok) == Progress::Break)
+                            return Break();
+                    }
+                } else if (tok->str() == "break") {
+                    const Token *scopeEndToken = findNextTokenFromBreak(tok);
+                    if (!scopeEndToken)
+                        return Break();
+                    tok = skipTo(tok, scopeEndToken, end);
+                    if (!precedes(tok, end))
+                        return Break(Analyzer::Terminate::Escape);
+                    if (!analyzer->lowerToPossible())
+                        return Break(Analyzer::Terminate::Bail);
+                    // TODO: Don't break, instead move to the outer scope
+                    if (!tok)
+                        return Break();
+                } else if (!tok->variable() && (Token::Match(tok, "%name% :") || tok->str() == "case")) {
+                    if (!analyzer->lowerToPossible())
+                        return Break(Analyzer::Terminate::Bail);
+                } else if (tok->link() && tok->str() == "}" && tok == tok->scope()->bodyEnd) { // might be an init list
+                    const Scope* scope = tok->scope();
+                    if (contains({ScopeType::eDo, ScopeType::eFor, ScopeType::eWhile, ScopeType::eIf, ScopeType::eElse, ScopeType::eSwitch}, scope->type)) {
+                        const bool inElse = scope->type == ScopeType::eElse;
+                        const bool inDoWhile = scope->type == ScopeType::eDo;
+                        const bool inLoop = contains({ScopeType::eDo, ScopeType::eFor, ScopeType::eWhile}, scope->type);
+                        Token* condTok = getCondTokFromEnd(tok);
+                        if (!condTok)
+                            return Break();
+                        if (!condTok->hasKnownIntValue() || inLoop) {
+                            if (!analyzer->lowerToPossible())
+                                return Break(Analyzer::Terminate::Bail);
+                        } else if (condTok->getKnownIntValue() == inElse) {
+                            return Break();
+                        }
+                        // Handle loop
+                        if (inLoop) {
+                            Token* stepTok = getStepTokFromEnd(tok);
+                            bool checkThen, checkElse;
+                            std::tie(checkThen, checkElse) = evalCond(condTok);
+                            if (stepTok && !checkElse) {
+                                if (updateRecursive(stepTok) == Progress::Break)
+                                    return Break();
+                                if (updateRecursive(condTok) == Progress::Break)
+                                    return Break();
+                                // Reevaluate condition
+                                std::tie(checkThen, checkElse) = evalCond(condTok);
+                            }
+                            if (!checkElse) {
+                                if (updateLoopExit(end, tok, condTok, nullptr, stepTok) == Progress::Break)
+                                    return Break();
+                            }
+                        }
+                        analyzer->assume(condTok, !inElse, Analyzer::Assume::Quiet);
+                        assert(!inDoWhile || Token::simpleMatch(tok, "} while ("));
+                        if (Token::simpleMatch(tok, "} else {") || inDoWhile)
+                            tok = tok->linkAt(2);
+                    } else if (contains({ScopeType::eTry, ScopeType::eCatch}, scope->type)) {
+                        if (!analyzer->lowerToPossible())
+                            return Break(Analyzer::Terminate::Bail);
+                    } else if (scope->type == ScopeType::eLambda) {
+                        return Break();
+                    }
+                } else if (tok->isControlFlowKeyword() && Token::Match(tok, "if|while|for (") &&
+                           Token::simpleMatch(tok->linkAt(1), ") {")) {
+                    if ((settings.vfOptions.maxForwardBranches > 0) && (++branchCount > settings.vfOptions.maxForwardBranches)) {
+                        // TODO: should be logged on function-level instead of file-level
+                        if (settings.severity.isEnabled(Severity::information)) {
+                            reportError(Severity::information, "normalCheckLevelMaxBranches", "Limiting analysis of branches. Use --check-level=exhaustive to analyze all branches.");
+                        }
+                        return Break(Analyzer::Terminate::Bail);
+                    }
+                    Token* endCond = tok->linkAt(1);
+                    Token* endBlock = endCond->linkAt(1);
+                    Token* condTok = getCondTok(tok);
+                    Token* initTok = getInitTok(tok);
+                    if (initTok && updateRecursive(initTok) == Progress::Break)
+                        return Break();
+                    if (Token::Match(tok, "for|while (")) {
+                        // For-range loop
+                        if (Token::simpleMatch(condTok, ":")) {
+                            Token* conTok = condTok->astOperand2();
+                            if (conTok && updateRecursive(conTok) == Progress::Break)
+                                return Break();
+                            bool isEmpty = false;
+                            std::vector<MathLib::bigint> result =
+                                analyzer->evaluate(Analyzer::Evaluate::ContainerEmpty, conTok);
+                            if (result.empty())
+                                analyzer->assume(conTok, false, Analyzer::Assume::ContainerEmpty);
+                            else
+                                isEmpty = result.front() != 0;
+                            if (!isEmpty && updateLoop(end, endBlock, condTok) == Progress::Break)
+                                return Break();
+                        } else {
+                            Token* stepTok = getStepTok(tok);
+                            // Dont pass initTok since it was already evaluated
+                            if (updateLoop(end, endBlock, condTok, nullptr, stepTok) == Progress::Break)
+                                return Break();
+                        }
+                        tok = endBlock;
+                    } else {
+                        // Traverse condition
+                        if (updateRecursive(condTok) == Progress::Break)
+                            return Break();
+                        Branch thenBranch{endBlock};
+                        Branch elseBranch{endBlock->tokAt(2) ? endBlock->linkAt(2) : nullptr};
+                        // Check if condition is true or false
+                        std::tie(thenBranch.check, elseBranch.check) = evalCond(condTok);
+                        if (!thenBranch.check && !elseBranch.check && stopOnCondition(condTok) && stopUpdates())
+                            return Break(Analyzer::Terminate::Conditional);
+                        const bool hasElse = Token::simpleMatch(endBlock, "} else {");
+                        bool bail = false;
+
+                        // Traverse then block
+                        thenBranch.escape = isEscapeScope(endBlock, thenBranch.escapeUnknown);
+                        if (thenBranch.check) {
+                            thenBranch.active = true;
+                            if (updateScope(endBlock, depth - 1) == Progress::Break)
+                                return Break();
+                        } else if (!elseBranch.check) {
+                            thenBranch.active = true;
+                            if (checkBranch(thenBranch))
+                                bail = true;
+                        }
+                        // Traverse else block
+                        if (hasElse) {
+                            elseBranch.escape = isEscapeScope(endBlock->linkAt(2), elseBranch.escapeUnknown);
+                            if (elseBranch.check) {
+                                elseBranch.active = true;
+                                const Progress result = updateScope(endBlock->linkAt(2), depth - 1);
+                                if (result == Progress::Break)
+                                    return Break();
+                            } else if (!thenBranch.check) {
+                                elseBranch.active = true;
+                                if (checkBranch(elseBranch))
+                                    bail = true;
+                            }
+                            tok = endBlock->linkAt(2);
+                        } else {
+                            tok = endBlock;
+                        }
+                        if (thenBranch.active)
+                            actions |= thenBranch.action;
+                        if (elseBranch.active)
+                            actions |= elseBranch.action;
+                        if (bail)
+                            return Break(Analyzer::Terminate::Bail);
+                        if (thenBranch.isDead() && elseBranch.isDead()) {
+                            if (thenBranch.isModified() && elseBranch.isModified())
+                                return Break(Analyzer::Terminate::Modified);
+                            if (thenBranch.isConclusiveEscape() && elseBranch.isConclusiveEscape())
+                                return Break(Analyzer::Terminate::Escape);
+                            return Break(Analyzer::Terminate::Bail);
+                        }
+                        // Conditional return
+                        if (thenBranch.active && thenBranch.isEscape() && !hasElse) {
+                            if (!thenBranch.isConclusiveEscape()) {
+                                if (!analyzer->lowerToInconclusive())
+                                    return Break(Analyzer::Terminate::Bail);
+                            } else if (thenBranch.check) {
+                                return Break();
+                            } else {
+                                if (analyzer->isConditional() && stopUpdates())
+                                    return Break(Analyzer::Terminate::Conditional);
+                                analyzer->assume(condTok, false);
+                            }
+                        }
+                        if (thenBranch.isInconclusive() || elseBranch.isInconclusive()) {
+                            if (!analyzer->lowerToInconclusive())
+                                return Break(Analyzer::Terminate::Bail);
+                        } else if (thenBranch.isModified() || elseBranch.isModified()) {
+                            if (!hasElse && analyzer->isConditional() && stopUpdates())
+                                return Break(Analyzer::Terminate::Conditional);
+                            if (!analyzer->lowerToPossible())
+                                return Break(Analyzer::Terminate::Bail);
+                            analyzer->assume(condTok, elseBranch.isModified());
+                        }
+                    }
+                } else if (Token::simpleMatch(tok, "try {")) {
+                    Token* endBlock = tok->linkAt(1);
+                    ForwardTraversal tryTraversal = fork();
+                    tryTraversal.updateScope(endBlock, depth - 1);
+                    bool bail = tryTraversal.actions.isModified();
+                    if (bail) {
+                        actions = tryTraversal.actions;
+                        terminate = tryTraversal.terminate;
+                        return Break();
+                    }
+
+                    while (Token::simpleMatch(endBlock, "} catch (")) {
+                        Token* endCatch = endBlock->linkAt(2);
+                        if (!Token::simpleMatch(endCatch, ") {"))
+                            return Break();
+                        endBlock = endCatch->linkAt(1);
+                        ForwardTraversal ft = fork();
+                        ft.updateScope(endBlock, depth - 1);
+                        bail |= ft.terminate != Analyzer::Terminate::None || ft.actions.isModified();
+                    }
+                    if (bail)
+                        return Break();
+                    tok = endBlock;
+                } else if (Token::simpleMatch(tok, "do {")) {
+                    Token* endBlock = tok->linkAt(1);
+                    Token* condTok = Token::simpleMatch(endBlock, "} while (") ? endBlock->tokAt(2)->astOperand2() : nullptr;
+                    if (updateLoop(end, endBlock, condTok) == Progress::Break)
+                        return Break();
+                    if (condTok)
+                        tok = endBlock->linkAt(2)->next();
+                    else
+                        tok = endBlock;
+                } else if (Token::Match(tok, "assert|ASSERT (")) {
+                    const Token* condTok = tok->next()->astOperand2();
+                    bool checkThen, checkElse;
+                    std::tie(checkThen, checkElse) = evalCond(condTok);
+                    if (checkElse)
+                        return Break();
+                    if (!checkThen)
+                        analyzer->assume(condTok, true, Analyzer::Assume::Quiet | Analyzer::Assume::Absolute);
+                } else if (Token::simpleMatch(tok, "switch (")) {
+                    if (updateRecursive(tok->next()->astOperand2()) == Progress::Break)
+                        return Break();
+                    actions |= Analyzer::Action::Write; // bailout for switch scope
+                    return Break();
+                } else if (Token* callTok = callExpr(tok)) {
+                    // TODO: Dont traverse tokens a second time
+                    if (start != callTok && tok != callTok && updateRecursive(callTok->astOperand1()) == Progress::Break)
+                        return Break();
+                    // Since the call could be an unknown macro, traverse the tokens as a range instead of recursively
+                    if (!Token::simpleMatch(callTok, "( )") &&
+                        updateRange(callTok->next(), callTok->link(), depth - 1) == Progress::Break)
+                        return Break();
+                    if (updateTok(callTok) == Progress::Break)
+                        return Break();
+                    tok = callTok->link();
+                    if (!tok)
+                        return Break();
+                } else {
+                    if (updateTok(tok, &next) == Progress::Break)
+                        return Break();
+                    if (next) {
+                        if (precedes(next, end))
+                            tok = next->previous();
+                        else
+                            return Progress::Continue;
+                    }
+                }
+                // Prevent infinite recursion
+                if (tok->next() == start)
+                    break;
+            }
+            return Progress::Continue;
+        }
+
+        void reportError(Severity severity, const std::string& id, const std::string& msg) {
+            ErrorMessage::FileLocation loc(tokenList.getSourceFilePath(), 0, 0);
+            const ErrorMessage errmsg({std::move(loc)}, tokenList.getSourceFilePath(), severity, msg, id, Certainty::normal);
+            errorLogger.reportErr(errmsg);
+        }
+
+        static bool isFunctionCall(const Token* tok)
+        {
+            if (!Token::simpleMatch(tok, "("))
+                return false;
+            if (tok->isCast())
+                return false;
+            if (!tok->isBinaryOp())
+                return false;
+            if (Token::simpleMatch(tok->link(), ") {"))
+                return false;
+            if (isUnevaluated(tok->previous()))
+                return false;
+            return Token::Match(tok->previous(), "%name%|)|]|>");
+        }
+
+        static Token* assignExpr(Token* tok) {
+            while (tok->astParent() && astIsLHS(tok)) {
+                if (tok->astParent()->isAssignmentOp())
+                    return tok->astParent();
+                tok = tok->astParent();
+            }
+            return nullptr;
+        }
+
+        static Token* callExpr(Token* tok)
+        {
+            while (tok->astParent() && astIsLHS(tok)) {
+                if (!Token::Match(tok, "%name%|::|<|."))
+                    break;
+                if (Token::simpleMatch(tok, "<") && !tok->link())
+                    break;
+                tok = tok->astParent();
+            }
+            if (isFunctionCall(tok))
+                return tok;
+            return nullptr;
+        }
+
+        static Token* skipTo(Token* tok, const Token* dest, const Token* end = nullptr) {
+            if (end && dest->index() > end->index())
+                return nullptr;
+            const int i = dest->index() - tok->index();
+            if (i > 0)
+                return tok->tokAt(dest->index() - tok->index());
+            return nullptr;
+        }
+
+        static Token* getStepTokFromEnd(Token* tok) {
+            if (!Token::simpleMatch(tok, "}"))
+                return nullptr;
+            Token* end = tok->link()->previous();
+            if (!Token::simpleMatch(end, ")"))
+                return nullptr;
+            return getStepTok(end->link());
+        }
+    };
+}
+
+Analyzer::Result valueFlowGenericForward(Token* start, const Token* end, const ValuePtr<Analyzer>& a, const TokenList& tokenList, ErrorLogger& errorLogger, const Settings& settings)
+{
+    if (a->invalid())
+        return Analyzer::Result{Analyzer::Action::None, Analyzer::Terminate::Bail};
+    ForwardTraversal ft{a, tokenList, errorLogger, settings};
+    if (start)
+        ft.analyzer->updateState(start);
+    ft.updateRange(start, end);
+    return Analyzer::Result{ ft.actions, ft.terminate };
+}
+
+Analyzer::Result valueFlowGenericForward(Token* start, const ValuePtr<Analyzer>& a, const TokenList& tokenList, ErrorLogger& errorLogger, const Settings& settings)
+{
+    if (Settings::terminated())
+        throw TerminateException();
+    if (a->invalid())
+        return Analyzer::Result{Analyzer::Action::None, Analyzer::Terminate::Bail};
+    ForwardTraversal ft{a, tokenList, errorLogger, settings};
+    (void)ft.updateRecursive(start);
+    return Analyzer::Result{ ft.actions, ft.terminate };
+}
diff --git a/lib/forwardanalyzer.h b/lib/forwardanalyzer.h
new file mode 100644
index 00000000000..7b722f48c35
--- /dev/null
+++ b/lib/forwardanalyzer.h
@@ -0,0 +1,39 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef forwardanalyzerH
+#define forwardanalyzerH
+
+#include "analyzer.h"
+
+class ErrorLogger;
+class Settings;
+class Token;
+class TokenList;
+template<class T> class ValuePtr;
+
+Analyzer::Result valueFlowGenericForward(Token* start,
+                                         const Token* end,
+                                         const ValuePtr<Analyzer>& a,
+                                         const TokenList& tokenList,
+                                         ErrorLogger& errorLogger,
+                                         const Settings& settings);
+
+Analyzer::Result valueFlowGenericForward(Token* start, const ValuePtr<Analyzer>& a, const TokenList& tokenList, ErrorLogger& errorLogger, const Settings& settings);
+
+#endif
diff --git a/lib/fwdanalysis.cpp b/lib/fwdanalysis.cpp
new file mode 100644
index 00000000000..6363100b083
--- /dev/null
+++ b/lib/fwdanalysis.cpp
@@ -0,0 +1,590 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "fwdanalysis.h"
+
+#include "astutils.h"
+#include "config.h"
+#include "library.h"
+#include "settings.h"
+#include "symboldatabase.h"
+#include "token.h"
+#include "vfvalue.h"
+
+#include <deque>
+#include <list>
+#include <string>
+#include <utility>
+
+static bool isUnchanged(const Token *startToken, const Token *endToken, const std::set<nonneg int> &exprVarIds, bool local)
+{
+    for (const Token *tok = startToken; tok != endToken; tok = tok->next()) {
+        if (!local && Token::Match(tok, "%name% (") && !Token::simpleMatch(tok->linkAt(1), ") {"))
+            // TODO: this is a quick bailout
+            return false;
+        if (tok->varId() == 0 || exprVarIds.find(tok->varId()) == exprVarIds.end())
+            continue;
+        const Token *parent = tok;
+        while (parent->astParent() && !parent->astParent()->isAssignmentOp() && parent->astParent()->tokType() != Token::Type::eIncDecOp) {
+            if (parent->str() == "," || parent->isUnaryOp("&"))
+                // TODO: This is a quick bailout
+                return false;
+            parent = parent->astParent();
+        }
+        if (parent->astParent()) {
+            if (parent->astParent()->tokType() == Token::Type::eIncDecOp)
+                return false;
+            if (parent->astParent()->isAssignmentOp() && parent == parent->astParent()->astOperand1())
+                return false;
+        }
+    }
+    return true;
+}
+
+static bool hasFunctionCall(const Token *tok)
+{
+    if (!tok)
+        return false;
+    if (Token::Match(tok, "%name% ("))
+        // todo, const/pure function?
+        return true;
+    return hasFunctionCall(tok->astOperand1()) || hasFunctionCall(tok->astOperand2());
+}
+
+static bool hasGccCompoundStatement(const Token *tok)
+{
+    if (!tok)
+        return false;
+    if (tok->str() == "{" && Token::simpleMatch(tok->previous(), "( {"))
+        return true;
+    return hasGccCompoundStatement(tok->astOperand1()) || hasGccCompoundStatement(tok->astOperand2());
+}
+
+static bool nonLocal(const Variable* var, bool deref)
+{
+    return !var || (!var->isLocal() && !var->isArgument()) || (deref && var->isArgument() && var->isPointer()) || var->isStatic() || var->isExtern();
+}
+
+static bool hasVolatileCastOrVar(const Token *expr)
+{
+    bool ret = false;
+    visitAstNodes(expr,
+                  [&ret](const Token *tok) {
+        if (tok->variable() && tok->variable()->isVolatile())
+            ret = true;
+        else if (Token::simpleMatch(tok, "( volatile"))
+            ret = true;
+        return ret ? ChildrenToVisit::none : ChildrenToVisit::op1_and_op2;
+    });
+    return ret;
+}
+
+FwdAnalysis::Result FwdAnalysis::checkRecursive(const Token *expr, const Token *startToken, const Token *endToken, const std::set<nonneg int> &exprVarIds, bool local, bool inInnerClass, int depth)
+{
+    // Parse the given tokens
+    if (++depth > 1000)
+        return Result(Result::Type::BAILOUT);
+
+    for (const Token* tok = startToken; precedes(tok, endToken); tok = tok->next()) {
+        if (Token::simpleMatch(tok, "try {")) {
+            // TODO: handle try
+            return Result(Result::Type::BAILOUT);
+        }
+
+        if (Token::simpleMatch(tok, "break ;")) {
+            return Result(Result::Type::BREAK, tok);
+        }
+
+        if (Token::simpleMatch(tok, "goto"))
+            return Result(Result::Type::BAILOUT);
+
+        if (!inInnerClass && tok->str() == "{" && tok->scope()->isClassOrStruct()) {
+            // skip returns from local class definition
+            FwdAnalysis::Result result = checkRecursive(expr, tok, tok->link(), exprVarIds, local, true, depth);
+            if (result.type != Result::Type::NONE)
+                return result;
+            tok=tok->link();
+        }
+
+        if (tok->str() == "continue")
+            // TODO
+            return Result(Result::Type::BAILOUT);
+
+        if (const Token *lambdaEndToken = findLambdaEndToken(tok)) {
+            tok = lambdaEndToken;
+            const Result lambdaResult = checkRecursive(expr, lambdaEndToken->link()->next(), lambdaEndToken, exprVarIds, local, inInnerClass, depth);
+            if (lambdaResult.type == Result::Type::READ || lambdaResult.type == Result::Type::BAILOUT)
+                return lambdaResult;
+        }
+
+        if (Token::Match(tok, "return|throw")) {
+            // TODO: Handle these better
+            // Is expr variable used in expression?
+
+            const Token* opTok = tok->astOperand1();
+            if (!opTok)
+                opTok = tok->next();
+            std::pair<const Token*, const Token*> startEndTokens = opTok->findExpressionStartEndTokens();
+            FwdAnalysis::Result result =
+                checkRecursive(expr, startEndTokens.first, startEndTokens.second->next(), exprVarIds, local, true, depth);
+            if (result.type != Result::Type::NONE)
+                return result;
+
+            // #9167: if the return is inside an inner class, it does not tell us anything
+            if (!inInnerClass) {
+                if (!local && mWhat == What::Reassign)
+                    return Result(Result::Type::BAILOUT);
+
+                return Result(Result::Type::RETURN);
+            }
+        }
+
+        if (tok->str() == "}") {
+            // Known value => possible value
+            if (tok->scope() == expr->scope())
+                mValueFlowKnown = false;
+
+            if (tok->scope()->isLoopScope()) {
+                // check condition
+                const Token *conditionStart = nullptr;
+                const Token *conditionEnd = nullptr;
+                if (Token::simpleMatch(tok->link()->previous(), ") {")) {
+                    conditionEnd = tok->link()->previous();
+                    conditionStart = conditionEnd->link();
+                } else if (Token::simpleMatch(tok->link()->previous(), "do {") && Token::simpleMatch(tok, "} while (")) {
+                    conditionStart = tok->tokAt(2);
+                    conditionEnd = conditionStart->link();
+                }
+                if (conditionStart && conditionEnd) {
+                    bool used = false;
+                    for (const Token *condTok = conditionStart; condTok != conditionEnd; condTok = condTok->next()) {
+                        if (exprVarIds.find(condTok->varId()) != exprVarIds.end()) {
+                            used = true;
+                            break;
+                        }
+                    }
+                    if (used)
+                        return Result(Result::Type::BAILOUT);
+                }
+
+                // check loop body again..
+                const FwdAnalysis::Result &result = checkRecursive(expr, tok->link(), tok, exprVarIds, local, inInnerClass, depth);
+                if (result.type == Result::Type::BAILOUT || result.type == Result::Type::READ)
+                    return result;
+            }
+        }
+
+        if (Token::simpleMatch(tok, "else {"))
+            tok = tok->linkAt(1);
+
+        if (Token::simpleMatch(tok, "asm ("))
+            return Result(Result::Type::BAILOUT);
+
+        if (mWhat == What::ValueFlow && (Token::Match(tok, "while|for (") || Token::simpleMatch(tok, "do {"))) {
+            const Token *bodyStart = nullptr;
+            const Token *conditionStart = nullptr;
+            if (Token::simpleMatch(tok, "do {")) {
+                bodyStart = tok->next();
+                if (Token::simpleMatch(bodyStart->link(), "} while ("))
+                    conditionStart = bodyStart->link()->tokAt(2);
+            } else {
+                conditionStart = tok->next();
+                if (Token::simpleMatch(conditionStart->link(), ") {"))
+                    bodyStart = conditionStart->link()->next();
+            }
+
+            if (!bodyStart || !conditionStart)
+                return Result(Result::Type::BAILOUT);
+
+            // Is expr changed in condition?
+            if (!isUnchanged(conditionStart, conditionStart->link(), exprVarIds, local))
+                return Result(Result::Type::BAILOUT);
+
+            // Is expr changed in loop body?
+            if (!isUnchanged(bodyStart, bodyStart->link(), exprVarIds, local))
+                return Result(Result::Type::BAILOUT);
+        }
+
+        if (mWhat == What::ValueFlow && Token::simpleMatch(tok, "if (") && Token::simpleMatch(tok->linkAt(1), ") {")) {
+            const Token *bodyStart = tok->linkAt(1)->next();
+            const Token *conditionStart = tok->next();
+            const Token *condTok = conditionStart->astOperand2();
+            if (const ValueFlow::Value* v = condTok->getKnownValue(ValueFlow::Value::ValueType::INT)) {
+                const bool cond = !!v->intvalue;
+                if (cond) {
+                    FwdAnalysis::Result result = checkRecursive(expr, bodyStart, bodyStart->link(), exprVarIds, local, true, depth);
+                    if (result.type != Result::Type::NONE)
+                        return result;
+                } else if (Token::simpleMatch(bodyStart->link(), "} else {")) {
+                    bodyStart = bodyStart->link()->tokAt(2);
+                    FwdAnalysis::Result result = checkRecursive(expr, bodyStart, bodyStart->link(), exprVarIds, local, true, depth);
+                    if (result.type != Result::Type::NONE)
+                        return result;
+                }
+            }
+            tok = bodyStart->link();
+            if (isReturnScope(tok, mSettings.library))
+                return Result(Result::Type::BAILOUT);
+            if (Token::simpleMatch(tok, "} else {"))
+                tok = tok->linkAt(2);
+            if (!tok)
+                return Result(Result::Type::BAILOUT);
+
+            // Is expr changed in condition?
+            if (!isUnchanged(conditionStart, conditionStart->link(), exprVarIds, local))
+                return Result(Result::Type::BAILOUT);
+
+            // Is expr changed in condition body?
+            if (!isUnchanged(bodyStart, bodyStart->link(), exprVarIds, local))
+                return Result(Result::Type::BAILOUT);
+        }
+
+        if (!local && Token::Match(tok, "%name% (") && !Token::simpleMatch(tok->linkAt(1), ") {")) {
+            // TODO: this is a quick bailout
+            return Result(Result::Type::BAILOUT);
+        }
+
+        if (mWhat == What::Reassign &&
+            Token::simpleMatch(tok, ";") &&
+            Token::simpleMatch(tok->astParent(), ";") &&
+            Token::simpleMatch(tok->astParent()->astParent(), "(") &&
+            Token::simpleMatch(tok->astParent()->astParent()->previous(), "for (") &&
+            !isUnchanged(tok, tok->astParent()->astParent()->link(), exprVarIds, local))
+            // TODO: This is a quick bailout to avoid FP #9420, there are false negatives (TODO_ASSERT_EQUALS)
+            return Result(Result::Type::BAILOUT);
+
+        if (expr->isName() && Token::Match(tok, "%name% (") && tok->str().find('<') != std::string::npos && tok->str().find(expr->str()) != std::string::npos)
+            return Result(Result::Type::BAILOUT);
+
+        if (exprVarIds.find(tok->varId()) != exprVarIds.end()) {
+            const Token *parent = tok;
+            bool other = false;
+            bool same = tok->astParent() && isSameExpression(false, expr, tok, mSettings, true, false, nullptr);
+            while (!same && Token::Match(parent->astParent(), "*|.|::|[|(|%cop%")) {
+                parent = parent->astParent();
+                if (parent->str() == "(" && !parent->isCast())
+                    break;
+                if (isSameExpression(false, expr, parent, mSettings, true, false, nullptr)) {
+                    same = true;
+                    if (mWhat == What::ValueFlow) {
+                        KnownAndToken v;
+                        v.known = mValueFlowKnown;
+                        v.token = parent;
+                        mValueFlow.push_back(v);
+                    }
+                }
+                if (Token::Match(parent, ". %var%") && parent->next()->varId() && exprVarIds.find(parent->next()->varId()) == exprVarIds.end() &&
+                    isSameExpression(false, expr->astOperand1(), parent->astOperand1(), mSettings, true, false, nullptr)) {
+                    other = true;
+                    break;
+                }
+            }
+            if (mWhat != What::ValueFlow && same && Token::simpleMatch(parent->astParent(), "[") && parent == parent->astParent()->astOperand2()) {
+                return Result(Result::Type::READ);
+            }
+            if (other)
+                continue;
+            if (Token::simpleMatch(parent->astParent(), "=") && parent == parent->astParent()->astOperand1()) {
+                if (!local && hasFunctionCall(parent->astParent()->astOperand2())) {
+                    // TODO: this is a quick bailout
+                    return Result(Result::Type::BAILOUT);
+                }
+                if (hasOperand(parent->astParent()->astOperand2(), expr)) {
+                    if (mWhat == What::Reassign)
+                        return Result(Result::Type::READ);
+                    continue;
+                }
+                const auto startEnd = parent->astParent()->astOperand2()->findExpressionStartEndTokens();
+                for (const Token* tok2 = startEnd.first; tok2 != startEnd.second; tok2 = tok2->next()) {
+                    if (tok2->tokType() == Token::eLambda)
+                        return Result(Result::Type::BAILOUT);
+                    // TODO: analyze usage in lambda
+                }
+                // ({ .. })
+                if (hasGccCompoundStatement(parent->astParent()->astOperand2()))
+                    return Result(Result::Type::BAILOUT);
+                // cppcheck-suppress shadowFunction - TODO: fix this
+                const bool reassign = isSameExpression(false, expr, parent, mSettings, false, false, nullptr);
+                if (reassign)
+                    return Result(Result::Type::WRITE, parent->astParent());
+                return Result(Result::Type::READ);
+            }
+            if (mWhat == What::Reassign) {
+                if (parent->variable() && parent->variable()->type() && parent->variable()->type()->isUnionType() && parent->varId() == expr->varId()) {
+                    while (parent && Token::simpleMatch(parent->astParent(), "."))
+                        parent = parent->astParent();
+                    if (parent && parent->valueType() && Token::simpleMatch(parent->astParent(), "=") && !Token::Match(parent->astParent()->astParent(), "%assign%") && parent->astParent()->astOperand1() == parent) {
+                        const Token * assignment = parent->astParent()->astOperand2();
+                        while (Token::simpleMatch(assignment, ".") && assignment->varId() != expr->varId())
+                            assignment = assignment->astOperand1();
+                        if (assignment && assignment->varId() != expr->varId()) {
+                            if (assignment->valueType() && assignment->valueType()->pointer) // Bailout
+                                return Result(Result::Type::BAILOUT);
+                            return Result(Result::Type::WRITE, parent->astParent());
+                        }
+                    }
+                    return Result(Result::Type::READ);
+                }
+                if (parent->valueType() && parent->valueType()->pointer && Token::Match(parent->astParent(), "%assign%"))
+                    return Result(Result::Type::READ);
+            }
+
+            if (Token::Match(parent->astParent(), "%assign%") && !parent->astParent()->astParent() && parent == parent->astParent()->astOperand1()) {
+                if (mWhat == What::Reassign)
+                    return Result(Result::Type::BAILOUT, parent->astParent());
+                if (mWhat == What::UnusedValue && (!parent->valueType() || parent->valueType()->reference != Reference::None))
+                    return Result(Result::Type::BAILOUT, parent->astParent());
+                continue;
+            }
+            if (mWhat == What::UnusedValue && parent->isUnaryOp("&") && Token::Match(parent->astParent(), "[,(]")) {
+                // Pass variable to function the writes it
+                const Token *ftok = parent->astParent();
+                while (Token::simpleMatch(ftok, ","))
+                    ftok = ftok->astParent();
+                if (ftok && Token::Match(ftok->previous(), "%name% (")) {
+                    const std::vector<const Token *> args = getArguments(ftok);
+                    int argnr = 0;
+                    while (argnr < args.size() && args[argnr] != parent)
+                        argnr++;
+                    if (argnr < args.size()) {
+                        if (mSettings.library.getArgDirection(ftok->astOperand1(), argnr + 1) == Library::ArgumentChecks::Direction::DIR_OUT)
+                            continue;
+                    }
+                }
+                return Result(Result::Type::BAILOUT, parent->astParent());
+            }
+            // TODO: this is a quick bailout
+            return Result(Result::Type::BAILOUT, parent->astParent());
+        }
+
+        if (Token::Match(tok, ")|do {")) {
+            if (tok->str() == ")" && Token::simpleMatch(tok->link()->previous(), "switch ("))
+                // TODO: parse switch
+                return Result(Result::Type::BAILOUT);
+            const Result &result1 = checkRecursive(expr, tok->tokAt(2), tok->linkAt(1), exprVarIds, local, inInnerClass, depth);
+            if (result1.type == Result::Type::READ || result1.type == Result::Type::BAILOUT)
+                return result1;
+            if (mWhat == What::UnusedValue && result1.type == Result::Type::WRITE && expr->variable() && expr->variable()->isReference())
+                return result1;
+            if (mWhat == What::ValueFlow && result1.type == Result::Type::WRITE)
+                mValueFlowKnown = false;
+            if (mWhat == What::Reassign && result1.type == Result::Type::BREAK) {
+                const Token *scopeEndToken = findNextTokenFromBreak(result1.token);
+                if (scopeEndToken) {
+                    const Result &result2 = checkRecursive(expr, scopeEndToken->next(), endToken, exprVarIds, local, inInnerClass, depth);
+                    if (result2.type == Result::Type::BAILOUT)
+                        return result2;
+                }
+            }
+            if (Token::simpleMatch(tok->linkAt(1), "} else {")) {
+                const Token *elseStart = tok->linkAt(1)->tokAt(2);
+                const Result &result2 = checkRecursive(expr, elseStart, elseStart->link(), exprVarIds, local, inInnerClass, depth);
+                if (mWhat == What::ValueFlow && result2.type == Result::Type::WRITE)
+                    mValueFlowKnown = false;
+                if (result2.type == Result::Type::READ || result2.type == Result::Type::BAILOUT)
+                    return result2;
+                if (result1.type == Result::Type::WRITE && result2.type == Result::Type::WRITE)
+                    return result1;
+                tok = elseStart->link();
+            } else {
+                tok = tok->linkAt(1);
+            }
+        }
+    }
+
+    return Result(Result::Type::NONE);
+}
+
+std::set<nonneg int> FwdAnalysis::getExprVarIds(const Token* expr, bool* localOut, bool* unknownVarIdOut) const
+{
+    // all variable ids in expr.
+    std::set<nonneg int> exprVarIds;
+    bool local = true;
+    bool unknownVarId = false;
+    visitAstNodes(expr,
+                  [&](const Token *tok) {
+        if (tok->str() == "[" && mWhat == What::UnusedValue)
+            return ChildrenToVisit::op1;
+        if (tok->varId() == 0 && tok->isName() && tok->strAt(-1) != ".") {
+            // unknown variable
+            unknownVarId = true;
+            return ChildrenToVisit::none;
+        }
+        if (tok->varId() > 0) {
+            exprVarIds.insert(tok->varId());
+            if (!Token::simpleMatch(tok->previous(), ".")) {
+                const Variable *var = tok->variable();
+                if (var && var->isReference() && var->isLocal() && Token::Match(var->nameToken(), "%var% [=(]") && !isGlobalData(var->nameToken()->next()->astOperand2()))
+                    return ChildrenToVisit::none;
+                const bool deref = tok->astParent() && (tok->astParent()->isUnaryOp("*") || (tok->astParent()->str() == "[" && tok == tok->astParent()->astOperand1()));
+                local &= !nonLocal(tok->variable(), deref);
+            }
+        }
+        return ChildrenToVisit::op1_and_op2;
+    });
+    if (localOut)
+        *localOut = local;
+    if (unknownVarIdOut)
+        *unknownVarIdOut = unknownVarId;
+    return exprVarIds;
+}
+
+FwdAnalysis::Result FwdAnalysis::check(const Token* expr, const Token* startToken, const Token* endToken)
+{
+    // all variable ids in expr.
+    bool local = true;
+    bool unknownVarId = false;
+    std::set<nonneg int> exprVarIds = getExprVarIds(expr, &local, &unknownVarId);
+
+    if (unknownVarId)
+        return Result(FwdAnalysis::Result::Type::BAILOUT);
+
+    if (mWhat == What::Reassign && isGlobalData(expr))
+        local = false;
+
+    // In unused values checking we do not want to check assignments to
+    // global data.
+    if (mWhat == What::UnusedValue && isGlobalData(expr))
+        return Result(FwdAnalysis::Result::Type::BAILOUT);
+
+    Result result = checkRecursive(expr, startToken, endToken, exprVarIds, local, false);
+
+    // Break => continue checking in outer scope
+    while (mWhat!=What::ValueFlow && result.type == FwdAnalysis::Result::Type::BREAK) {
+        const Token *scopeEndToken = findNextTokenFromBreak(result.token);
+        if (!scopeEndToken)
+            break;
+        result = checkRecursive(expr, scopeEndToken->next(), endToken, exprVarIds, local, false);
+    }
+
+    return result;
+}
+
+bool FwdAnalysis::hasOperand(const Token *tok, const Token *lhs) const
+{
+    if (!tok)
+        return false;
+    std::deque<const Token*> nodes{ tok };
+    while (!nodes.empty()) {
+        const Token* node = nodes.front();
+        if (isSameExpression(false, node, lhs, mSettings, false, false, nullptr))
+            return true;
+        if (node->astOperand1())
+            nodes.emplace_back(node->astOperand1());
+        if (node->astOperand2())
+            nodes.emplace_back(node->astOperand2());
+        nodes.pop_front();
+    }
+    return false;
+}
+
+const Token *FwdAnalysis::reassign(const Token *expr, const Token *startToken, const Token *endToken)
+{
+    if (hasVolatileCastOrVar(expr))
+        return nullptr;
+    mWhat = What::Reassign;
+    Result result = check(expr, startToken, endToken);
+    return result.type == FwdAnalysis::Result::Type::WRITE ? result.token : nullptr;
+}
+
+bool FwdAnalysis::unusedValue(const Token *expr, const Token *startToken, const Token *endToken)
+{
+    if (isEscapedAlias(expr))
+        return false;
+    if (hasVolatileCastOrVar(expr))
+        return false;
+    if (Token::simpleMatch(expr, "[") && astIsContainerView(expr->astOperand1()))
+        return false;
+    mWhat = What::UnusedValue;
+    Result result = check(expr, startToken, endToken);
+    return (result.type == FwdAnalysis::Result::Type::NONE || result.type == FwdAnalysis::Result::Type::RETURN) && !possiblyAliased(expr, startToken);
+}
+
+bool FwdAnalysis::possiblyAliased(const Token *expr, const Token *startToken) const
+{
+    if (expr->isUnaryOp("*") && !expr->astOperand1()->isUnaryOp("&"))
+        return true;
+    if (Token::simpleMatch(expr, ". *"))
+        return true;
+    if (expr->str() == "(" && Token::simpleMatch(expr->astOperand1(), "."))
+        return true;
+
+    const bool macro = false;
+    const bool pure = false;
+    const bool followVar = false;
+    for (const Token *tok = startToken; tok; tok = tok->previous()) {
+
+        if (Token::Match(tok, "%name% (") && !Token::Match(tok, "if|while|for")) {
+            // Is argument passed by reference?
+            const std::vector<const Token*> args = getArguments(tok);
+            for (int argnr = 0; argnr < args.size(); ++argnr) {
+                if (!Token::Match(args[argnr], "%name%|.|::"))
+                    continue;
+                if (tok->function() && tok->function()->getArgumentVar(argnr) && !tok->function()->getArgumentVar(argnr)->isReference() && !tok->function()->isConst())
+                    continue;
+                for (const Token *subexpr = expr; subexpr; subexpr = subexpr->astOperand1()) {
+                    if (isSameExpression(macro, subexpr, args[argnr], mSettings, pure, followVar)) {
+                        const Scope* scope = expr->scope(); // if there is no other variable, assume no aliasing
+                        if (scope->varlist.size() > 1)
+                            return true;
+                    }
+                }
+            }
+            continue;
+        }
+
+        const Token *addrOf = nullptr;
+        if (Token::Match(tok, "& %name% ="))
+            addrOf = tok->tokAt(2)->astOperand2();
+        else if (tok->isUnaryOp("&"))
+            addrOf = tok->astOperand1();
+        else if (Token::simpleMatch(tok, "std :: ref ("))
+            addrOf = tok->tokAt(3)->astOperand2();
+        else if (tok->valueType() && tok->valueType()->pointer &&
+                 (Token::Match(tok, "%var% = %var% ;") || Token::Match(tok, "%var% {|( %var% }|)")) &&
+                 Token::Match(expr->previous(), "%varid% [", tok->tokAt(2)->varId()))
+            addrOf = tok->tokAt(2);
+        else
+            continue;
+
+        for (const Token *subexpr = expr; subexpr; subexpr = subexpr->astOperand1()) {
+            if (subexpr != addrOf && isSameExpression(macro, subexpr, addrOf, mSettings, pure, followVar))
+                return true;
+        }
+    }
+    return false;
+}
+
+bool FwdAnalysis::isEscapedAlias(const Token* expr)
+{
+    for (const Token *subexpr = expr; subexpr; subexpr = subexpr->astOperand1()) {
+        for (const ValueFlow::Value &val : subexpr->values()) {
+            if (!val.isLocalLifetimeValue())
+                continue;
+            const Variable* var = val.tokvalue->variable();
+            if (!var)
+                continue;
+            if (!var->isLocal())
+                return true;
+            if (var->isArgument())
+                return true;
+
+        }
+    }
+    return false;
+}
diff --git a/lib/fwdanalysis.h b/lib/fwdanalysis.h
new file mode 100644
index 00000000000..389ea195da2
--- /dev/null
+++ b/lib/fwdanalysis.h
@@ -0,0 +1,92 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+//---------------------------------------------------------------------------
+#ifndef fwdanalysisH
+#define fwdanalysisH
+//---------------------------------------------------------------------------
+
+#include "config.h"
+
+#include <cstdint>
+#include <set>
+#include <vector>
+
+class Token;
+class Settings;
+
+/**
+ * Forward data flow analysis for checks
+ *  - unused value
+ *  - redundant assignment
+ *  - valueflow analysis
+ */
+class FwdAnalysis {
+public:
+    explicit FwdAnalysis(const Settings &settings) : mSettings(settings) {}
+
+    bool hasOperand(const Token *tok, const Token *lhs) const;
+
+    /**
+     * Check if "expr" is reassigned. The "expr" can be a tree (x.y[12]).
+     * @param expr Symbolic expression to perform forward analysis for
+     * @param startToken First token in forward analysis
+     * @param endToken Last token in forward analysis
+     * @return Token where expr is reassigned. If it's not reassigned then nullptr is returned.
+     */
+    const Token *reassign(const Token *expr, const Token *startToken, const Token *endToken);
+
+    /**
+     * Check if "expr" is used. The "expr" can be a tree (x.y[12]).
+     * @param expr Symbolic expression to perform forward analysis for
+     * @param startToken First token in forward analysis
+     * @param endToken Last token in forward analysis
+     * @return true if expr is used.
+     */
+    bool unusedValue(const Token *expr, const Token *startToken, const Token *endToken);
+
+    struct KnownAndToken {
+        bool known{};
+        const Token* token{};
+    };
+
+    /** Is there some possible alias for given expression */
+    bool possiblyAliased(const Token *expr, const Token *startToken) const;
+
+    std::set<nonneg int> getExprVarIds(const Token* expr, bool* localOut = nullptr, bool* unknownVarIdOut = nullptr) const;
+private:
+    static bool isEscapedAlias(const Token* expr);
+
+    /** Result of forward analysis */
+    struct Result {
+        enum class Type : std::uint8_t { NONE, READ, WRITE, BREAK, RETURN, BAILOUT } type;
+        explicit Result(Type type) : type(type) {}
+        Result(Type type, const Token *token) : type(type), token(token) {}
+        const Token* token{};
+    };
+
+    Result check(const Token *expr, const Token *startToken, const Token *endToken);
+    Result checkRecursive(const Token *expr, const Token *startToken, const Token *endToken, const std::set<nonneg int> &exprVarIds, bool local, bool inInnerClass, int depth=0);
+
+    const Settings &mSettings;
+    enum class What : std::uint8_t { Reassign, UnusedValue, ValueFlow } mWhat = What::Reassign;
+    std::vector<KnownAndToken> mValueFlow;
+    bool mValueFlowKnown = true;
+};
+
+#endif // fwdanalysisH
diff --git a/lib/importproject.cpp b/lib/importproject.cpp
index ac8920fd8b9..33b75b5dc7e 100644
--- a/lib/importproject.cpp
+++ b/lib/importproject.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,66 +19,197 @@
 #include "importproject.h"
 
 #include "path.h"
+#include "pathmatch.h"
 #include "settings.h"
-#include "tinyxml2.h"
+#include "standards.h"
+#include "suppressions.h"
 #include "token.h"
-#include "tokenize.h"
 #include "tokenlist.h"
 #include "utils.h"
-#define PICOJSON_USE_INT64
-#include <picojson.h>
 
+#include <algorithm>
+#include <cstdlib>
 #include <cstring>
 #include <fstream>
+#include <initializer_list>
+#include <iostream>
+#include <iterator>
+#include <stack>
+#include <unordered_set>
 #include <utility>
-#include <sstream>
+#include <vector>
 
+#include "xml.h"
 
-void ImportProject::ignorePaths(const std::vector<std::string> &ipaths)
+#include "json.h"
+
+std::string ImportProject::collectArgs(const std::string &cmd, std::vector<std::string> &args)
 {
-    for (std::list<FileSettings>::iterator it = fileSettings.begin(); it != fileSettings.end();) {
-        bool ignore = false;
-        for (std::string i : ipaths) {
-            if (it->filename.size() > i.size() && it->filename.compare(0,i.size(),i)==0) {
-                ignore = true;
-                break;
+    args.clear();
+
+    std::string::size_type pos = 0;
+    const std::string::size_type end = cmd.size();
+    std::string arg;
+
+    bool inDoubleQuotes = false;
+    bool inSingleQuotes = false;
+
+    while (pos < end) {
+        char c = cmd[pos++];
+
+        if (c == ' ') {
+            if (inDoubleQuotes || inSingleQuotes) {
+                arg.push_back(c);
+                continue;
             }
-            if (!Path::isAbsolute(i)) {
-                i = mPath + i;
-                if (it->filename.size() > i.size() && it->filename.compare(0,i.size(),i)==0) {
-                    ignore = true;
-                    break;
-                }
+
+            if (!arg.empty())
+                args.push_back(arg);
+            arg.clear();
+
+            pos = cmd.find_first_not_of(' ', pos);
+
+            continue;
+        }
+
+        if (c == '\"' && !inSingleQuotes) {
+            inDoubleQuotes = !inDoubleQuotes;
+            continue;
+        }
+
+        if (c == '\'' && !inDoubleQuotes) {
+            inSingleQuotes = !inSingleQuotes;
+            continue;
+        }
+
+        if (c == '\\' && !inSingleQuotes) {
+            if (pos == end) {
+                arg.push_back('\\');
+                break;
             }
+
+            c = cmd[pos++];
+
+            if (!std::strchr("\\\"\' ", c))
+                arg.push_back('\\');
+
+            arg.push_back(c);
+            continue;
         }
-        if (ignore)
-            fileSettings.erase(it++);
-        else
-            ++it;
+
+        arg.push_back(c);
     }
+
+    if (inSingleQuotes || inDoubleQuotes)
+        return "Missing closing quote in command string";
+
+    if (!arg.empty())
+        args.push_back(std::move(arg));
+
+    return "";
 }
 
-void ImportProject::ignoreOtherConfigs(const std::string &cfg)
+void ImportProject::parseArgs(FileSettings &fs, const std::vector<std::string> &args)
 {
-    for (std::list<FileSettings>::iterator it = fileSettings.begin(); it != fileSettings.end();) {
-        if (it->cfg != cfg)
-            fileSettings.erase(it++);
+    const auto getOptArg = [&args](std::initializer_list<std::string> optNames,
+                                   std::size_t &i) {
+        const auto &arg = args[i];
+        const auto *const it = std::find_if(optNames.begin(),
+                                            optNames.end(),
+                                            [&arg] (const std::string &optName) {
+            return startsWith(arg, optName);
+        });
+
+        if (it == optNames.end())
+            return std::string();
+
+        const std::size_t optLen = it->size();
+        if (arg.size() == optLen)
+            return ++i >= args.size() ? std::string() : args[i];
+
+        return arg.substr(optLen);
+    };
+
+    std::string defs;
+    for (std::size_t i = 0; i < args.size(); i++) {
+        std::string optArg;
+
+        if (!(optArg = getOptArg({ "-I", "/I" }, i)).empty()) {
+            if (std::none_of(fs.includePaths.cbegin(), fs.includePaths.cend(),
+                             [&](const std::string &path) {
+                return path == optArg;
+            }))
+                fs.includePaths.push_back(std::move(optArg));
+            continue;
+        }
+
+        if (!(optArg = getOptArg({ "-isystem" }, i)).empty()) {
+            fs.systemIncludePaths.push_back(std::move(optArg));
+            continue;
+        }
+
+        if (!(optArg = getOptArg({ "-D", "/D" }, i)).empty()) {
+            defs += optArg + ";";
+            continue;
+        }
+
+        if (!(optArg = getOptArg({ "-U", "/U" }, i)).empty()) {
+            fs.undefs.insert(std::move(optArg));
+            continue;
+        }
+
+        if (!(optArg = getOptArg({ "-std=", "/std:" }, i)).empty()) {
+            fs.standard = std::move(optArg);
+            continue;
+        }
+
+        if (!(optArg = getOptArg({ "-f" }, i)).empty()) {
+            if (optArg == "pic")
+                defs += "__pic__;";
+            else if (optArg == "PIC")
+                defs += "__PIC__;";
+            else if (optArg == "pie")
+                defs += "__pie__;";
+            else if (optArg == "PIE")
+                defs += "__PIE__;";
+            continue;
+        }
+
+        if (!(optArg = getOptArg({ "-m" }, i)).empty()) {
+            if (optArg == "unicode")
+                defs += "UNICODE;";
+            continue;
+        }
+    }
+
+    fsSetDefines(fs, std::move(defs));
+}
+
+void ImportProject::ignorePaths(const std::vector<std::string> &ipaths, bool debug)
+{
+    PathMatch matcher(ipaths, Path::getCurrentPath());
+    for (auto it = fileSettings.cbegin(); it != fileSettings.cend();) {
+        if (matcher.match(it->filename())) {
+            if (debug)
+                std::cout << "ignored path: " << it->filename() << std::endl;
+            it = fileSettings.erase(it);
+        }
         else
             ++it;
     }
 }
 
-void ImportProject::ignoreOtherPlatforms(cppcheck::Platform::PlatformType platformType)
+void ImportProject::ignoreOtherConfigs(const std::string &cfg)
 {
-    for (std::list<FileSettings>::iterator it = fileSettings.begin(); it != fileSettings.end();) {
-        if (it->platformType != cppcheck::Platform::Unspecified && it->platformType != platformType)
-            fileSettings.erase(it++);
+    for (auto it = fileSettings.cbegin(); it != fileSettings.cend();) {
+        if (it->cfg != cfg)
+            it = fileSettings.erase(it);
         else
             ++it;
     }
 }
 
-void ImportProject::FileSettings::setDefines(std::string defs)
+void ImportProject::fsSetDefines(FileSettings& fs, std::string defs)
 {
     while (defs.find(";%(") != std::string::npos) {
         const std::string::size_type pos1 = defs.find(";%(");
@@ -90,7 +221,7 @@ void ImportProject::FileSettings::setDefines(std::string defs)
     while (!defs.empty() && defs[0] == ';')
         defs.erase(0, 1);
     while (!defs.empty() && endsWith(defs,';'))
-        defs.erase(defs.size() - 1U); // TODO: Use std::string::pop_back() as soon as travis supports it
+        defs.pop_back();
     bool eq = false;
     for (std::size_t pos = 0; pos < defs.size(); ++pos) {
         if (defs[pos] == '(' || defs[pos] == '=')
@@ -106,7 +237,7 @@ void ImportProject::FileSettings::setDefines(std::string defs)
     }
     if (!eq && !defs.empty())
         defs += "=1";
-    defines.swap(defs);
+    fs.defines.swap(defs);
 }
 
 static bool simplifyPathWithVariables(std::string &s, std::map<std::string, std::string, cppcheck::stricmp> &variables)
@@ -121,7 +252,7 @@ static bool simplifyPathWithVariables(std::string &s, std::map<std::string, std:
         if (expanded.find(var) != expanded.end())
             break;
         expanded.insert(var);
-        std::map<std::string, std::string, cppcheck::stricmp>::const_iterator it1 = variables.find(var);
+        auto it1 = utils::as_const(variables).find(var);
         // variable was not found within defined variables
         if (it1 == variables.end()) {
             const char *envValue = std::getenv(var.c_str());
@@ -132,37 +263,37 @@ static bool simplifyPathWithVariables(std::string &s, std::map<std::string, std:
             variables[var] = std::string(envValue);
             it1 = variables.find(var);
         }
-        s = s.substr(0, start) + it1->second + s.substr(end + 1);
+        s.replace(start, end - start + 1, it1->second);
     }
     if (s.find("$(") != std::string::npos)
         return false;
-    s = Path::simplifyPath(Path::fromNativeSeparators(s));
+    s = Path::simplifyPath(std::move(s));
     return true;
 }
 
-void ImportProject::FileSettings::setIncludePaths(const std::string &basepath, const std::list<std::string> &in, std::map<std::string, std::string, cppcheck::stricmp> &variables)
+void ImportProject::fsSetIncludePaths(FileSettings& fs, const std::string &basepath, const std::list<std::string> &in, std::map<std::string, std::string, cppcheck::stricmp> &variables)
 {
-    std::list<std::string> I;
-    // only parse each includePath once - so remove duplicates
-    std::list<std::string> uniqueIncludePaths = in;
-    uniqueIncludePaths.sort();
-    uniqueIncludePaths.unique();
-
-    for (const std::string &it : uniqueIncludePaths) {
-        if (it.empty())
+    std::set<std::string> found;
+    // NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
+    const std::list<std::string> copyIn(in);
+    fs.includePaths.clear();
+    for (const std::string &ipath : copyIn) {
+        if (ipath.empty())
+            continue;
+        if (startsWith(ipath,"%("))
             continue;
-        if (it.compare(0,2,"%(")==0)
+        std::string s(Path::fromNativeSeparators(ipath));
+        if (!found.insert(s).second)
             continue;
-        std::string s(Path::fromNativeSeparators(it));
         if (s[0] == '/' || (s.size() > 1U && s.compare(1,2,":/") == 0)) {
             if (!endsWith(s,'/'))
                 s += '/';
-            I.push_back(s);
+            fs.includePaths.push_back(std::move(s));
             continue;
         }
 
         if (endsWith(s,'/')) // this is a temporary hack, simplifyPath can crash if path ends with '/'
-            s.erase(s.size() - 1U); // TODO: Use std::string::pop_back() as soon as travis supports it
+            s.pop_back();
 
         if (s.find("$(") == std::string::npos) {
             s = Path::simplifyPath(basepath + s);
@@ -172,12 +303,11 @@ void ImportProject::FileSettings::setIncludePaths(const std::string &basepath, c
         }
         if (s.empty())
             continue;
-        I.push_back(s + '/');
+        fs.includePaths.push_back(s.back() == '/' ? s : (s + '/'));
     }
-    includePaths.swap(I);
 }
 
-ImportProject::Type ImportProject::import(const std::string &filename, Settings *settings)
+ImportProject::Type ImportProject::import(const std::string &filename, Settings *settings, Suppressions *supprs)
 {
     std::ifstream fin(filename);
     if (!fin.is_open())
@@ -187,158 +317,66 @@ ImportProject::Type ImportProject::import(const std::string &filename, Settings
     if (!mPath.empty() && !endsWith(mPath,'/'))
         mPath += '/';
 
-    if (endsWith(filename, ".json", 5)) {
-        importCompileCommands(fin);
-        return ImportProject::Type::COMPILE_DB;
-    } else if (endsWith(filename, ".sln", 4)) {
-        importSln(fin,mPath);
-        return ImportProject::Type::VS_SLN;
-    } else if (endsWith(filename, ".vcxproj", 8)) {
-        std::map<std::string, std::string, cppcheck::stricmp> variables;
-        importVcxproj(filename, variables, emptyString);
-        return ImportProject::Type::VS_VCXPROJ;
-    } else if (endsWith(filename, ".bpr", 4)) {
-        importBcb6Prj(filename);
-        return ImportProject::Type::BORLAND;
-    } else if (settings && endsWith(filename, ".cppcheck", 9)) {
-        return importCppcheckGuiProject(fin, settings) ? ImportProject::Type::CPPCHECK_GUI : ImportProject::Type::MISSING;
-    }
-    return ImportProject::Type::UNKNOWN;
-}
-
-static std::string readUntil(const std::string &command, std::string::size_type *pos, const char until[])
-{
-    std::string ret;
-    bool str = false;
-    while (*pos < command.size() && (str || !std::strchr(until, command[*pos]))) {
-        if (command[*pos] == '\\')
-            ++*pos;
-        if (*pos < command.size())
-            ret += command[(*pos)++];
-        if (endsWith(ret, '\"'))
-            str = !str;
-    }
-    return ret;
-}
-
-void ImportProject::FileSettings::parseCommand(const std::string &command)
-{
-    std::string defs;
+    const std::vector<std::string> fileFilters =
+        settings ? settings->fileFilters : std::vector<std::string>();
 
-    // Parse command..
-    std::string::size_type pos = 0;
-    while (std::string::npos != (pos = command.find(' ',pos))) {
-        while (pos < command.size() && command[pos] == ' ')
-            pos++;
-        if (pos >= command.size())
-            break;
-        if (command[pos] != '/' && command[pos] != '-')
-            continue;
-        pos++;
-        if (pos >= command.size())
-            break;
-        const char F = command[pos++];
-        if (std::strchr("DUI", F)) {
-            while (pos < command.size() && command[pos] == ' ')
-                ++pos;
+    if (endsWith(filename, ".json")) {
+        if (importCompileCommands(fin)) {
+            setRelativePaths(filename);
+            return ImportProject::Type::COMPILE_DB;
         }
-        const std::string fval = readUntil(command, &pos, " =");
-        if (F=='D') {
-            const std::string defval = readUntil(command, &pos, " ");
-            defs += fval;
-            if (!defval.empty())
-                defs += defval;
-            defs += ';';
-        } else if (F=='U')
-            undefs.insert(fval);
-        else if (F=='I')
-            includePaths.push_back(fval);
-        else if (F=='s' && fval.compare(0,2,"td") == 0) {
-            ++pos;
-            const std::string stdval = readUntil(command, &pos, " ");
-            standard = stdval;
-            if (standard.compare(0, 3, "c++") || standard.compare(0, 5, "gnu++")) {
-                std::string stddef;
-                if (standard == "c++98" || standard == "gnu++98" || standard == "c++03" || standard == "gnu++03") {
-                    stddef = "199711L";
-                } else if (standard == "c++11" || standard == "gnu++11"|| standard == "c++0x" || standard == "gnu++0x") {
-                    stddef = "201103L";
-                } else if (standard == "c++14" || standard == "gnu++14" || standard == "c++1y" || standard == "gnu++1y") {
-                    stddef = "201402L";
-                } else if (standard == "c++17" || standard == "gnu++17" || standard == "c++1z" || standard == "gnu++1z") {
-                    stddef = "201703L";
-                }
-
-                if (stddef.empty()) {
-                    // TODO: log error
-                    continue;
-                }
-
-                defs += "__cplusplus=";
-                defs += stddef;
-                defs += ";";
-            } else if (standard.compare(0, 1, "c") || standard.compare(0, 3, "gnu")) {
-                if (standard == "c90" || standard == "iso9899:1990" || standard == "gnu90" || standard == "iso9899:199409") {
-                    // __STDC_VERSION__ is not set for C90 although the macro was added in the 1994 amendments
-                    continue;
-                }
-
-                std::string stddef;
-
-                if (standard == "c99" || standard == "iso9899:1999" || standard == "gnu99") {
-                    stddef = "199901L";
-                } else if (standard == "c11" || standard == "iso9899:2011" || standard == "gnu11" || standard == "c1x" || standard == "gnu1x") {
-                    stddef = "201112L";
-                } else if (standard == "c17") {
-                    stddef = "201710L";
-                }
-
-                if (stddef.empty()) {
-                    // TODO: log error
-                    continue;
-                }
-
-                defs += "__STDC_VERSION__=";
-                defs += stddef;
-                defs += ";";
-            }
-        } else if (F == 'i' && fval == "system") {
-            ++pos;
-            const std::string isystem = readUntil(command, &pos, " ");
-            systemIncludePaths.push_back(isystem);
-        } else if (F=='m') {
-            if (fval == "unicode") {
-                defs += "UNICODE";
-                defs += ";";
-            }
-        } else if (F=='f') {
-            if (fval == "pic") {
-                defs += "__pic__";
-                defs += ";";
-            } else if (fval == "PIC") {
-                defs += "__PIC__";
-                defs += ";";
-            } else if (fval == "pie") {
-                defs += "__pie__";
-                defs += ";";
-            } else if (fval == "PIE") {
-                defs += "__PIE__";
-                defs += ";";
-            }
+    } else if (endsWith(filename, ".sln")) {
+        if (importSln(fin, mPath, fileFilters)) {
+            setRelativePaths(filename);
+            return ImportProject::Type::VS_SLN;
+        }
+    } else if (endsWith(filename, ".vcxproj")) {
+        std::map<std::string, std::string, cppcheck::stricmp> variables;
+        std::vector<SharedItemsProject> sharedItemsProjects;
+        if (importVcxproj(filename, variables, "", fileFilters, sharedItemsProjects)) {
+            setRelativePaths(filename);
+            return ImportProject::Type::VS_VCXPROJ;
+        }
+    } else if (endsWith(filename, ".bpr")) {
+        if (importBcb6Prj(filename)) {
+            setRelativePaths(filename);
+            return ImportProject::Type::BORLAND;
+        }
+    } else if (settings && supprs && endsWith(filename, ".cppcheck")) {
+        if (importCppcheckGuiProject(fin, *settings, *supprs)) {
+            setRelativePaths(filename);
+            return ImportProject::Type::CPPCHECK_GUI;
         }
+    } else {
+        return ImportProject::Type::UNKNOWN;
     }
-    setDefines(defs);
+    return ImportProject::Type::FAILURE;
 }
 
-void ImportProject::importCompileCommands(std::istream &istr)
+bool ImportProject::importCompileCommands(std::istream &istr)
 {
     picojson::value compileCommands;
     istr >> compileCommands;
-    if (!compileCommands.is<picojson::array>())
-        return;
+    if (!compileCommands.is<picojson::array>()) {
+        errors.emplace_back("compilation database is not a JSON array");
+        return false;
+    }
+
+    std::map<std::string, std::size_t> fsFileIds;
 
     for (const picojson::value &fileInfo : compileCommands.get<picojson::array>()) {
         picojson::object obj = fileInfo.get<picojson::object>();
+
+        if (obj.count("directory") == 0) {
+            errors.emplace_back("'directory' field in compilation database entry missing");
+            return false;
+        }
+
+        if (!obj["directory"].is<std::string>()) {
+            errors.emplace_back("'directory' field in compilation database entry is not a string");
+            return false;
+        }
+
         std::string dirpath = Path::fromNativeSeparators(obj["directory"].get<std::string>());
 
         /* CMAKE produces the directory without trailing / so add it if not
@@ -346,59 +384,98 @@ void ImportProject::importCompileCommands(std::istream &istr)
         if (!endsWith(dirpath, '/'))
             dirpath += '/';
 
-        const std::string directory = dirpath;
+        const std::string directory = std::move(dirpath);
 
-        std::ostringstream comm;
-        if (obj.find("arguments") != obj.end()) {
-            if (obj[ "arguments" ].is< picojson::array >()) {
-                for (const picojson::value& arg : obj[ "arguments" ].get< picojson::array >()) {
-                    if (arg.is< std::string >()) {
-                        comm << arg.get< std::string >() << " ";
-                    }
+        std::vector<std::string> arguments;
+        if (obj.count("arguments")) {
+            if (obj["arguments"].is<picojson::array>()) {
+                for (const picojson::value& arg : obj["arguments"].get<picojson::array>()) {
+                    if (arg.is<std::string>())
+                        arguments.push_back(arg.get<std::string>());
                 }
             } else {
-                return;
+                errors.emplace_back("'arguments' field in compilation database entry is not a JSON array");
+                return false;
             }
-        } else if (obj.find("command") != obj.end()) {
-            if (obj[ "command" ].is< std::string >()) {
-                comm << obj[ "command" ].get< std::string >();
+        } else if (obj.count("command")) {
+            std::string command;
+            if (obj["command"].is<std::string>()) {
+                command = obj["command"].get<std::string>();
+            } else {
+                errors.emplace_back("'command' field in compilation database entry is not a string");
+                return false;
+            }
+
+            std::string error = collectArgs(command, arguments);
+            if (!error.empty()) {
+                errors.emplace_back(error);
+                return false;
             }
         } else {
-            return;
+            errors.emplace_back("no 'arguments' or 'command' field found in compilation database entry");
+            return false;
         }
 
-        const std::string command = comm.str();
-        const std::string file = Path::fromNativeSeparators(obj["file"].get<std::string>());
+        if (!obj.count("file") || !obj["file"].is<std::string>()) {
+            errors.emplace_back("skip compilation database entry because it does not have a proper 'file' field");
+            continue;
+        }
+
+        std::string file = Path::fromNativeSeparators(obj["file"].get<std::string>());
 
         // Accept file?
         if (!Path::acceptFile(file))
             continue;
 
-        struct FileSettings fs;
-        if (Path::isAbsolute(file) || Path::fileExists(file))
-            fs.filename = file;
-        else {
-            std::string path = directory;
-            if (!path.empty() && !endsWith(path,'/'))
-                path += '/';
-            path += file;
-            fs.filename = Path::simplifyPath(path);
-        }
-        fs.parseCommand(command); // read settings; -D, -I, -U, -std, -m*, -f*
+        std::string path;
+        if (Path::isAbsolute(file))
+            path = Path::simplifyPath(std::move(file));
+#ifdef _WIN32
+        else if (file[0] == '/' && directory.size() > 2 && std::isalpha(directory[0]) && directory[1] == ':')
+            // directory: C:\foo\bar
+            // file: /xy/z.c
+            // => c:/xy/z.c
+            path = Path::simplifyPath(directory.substr(0,2) + file);
+#endif
+        else
+            path = Path::simplifyPath(directory + file);
+        FileSettings fs{path, Standards::Language::None, 0}; // file will be identified later on
+        parseArgs(fs, arguments);
         std::map<std::string, std::string, cppcheck::stricmp> variables;
-        fs.setIncludePaths(directory, fs.includePaths, variables);
-        fileSettings.push_back(fs);
+        fsSetIncludePaths(fs, directory, fs.includePaths, variables);
+        // Assign a unique index to each file path. If the file path already exists in the map,
+        // increment the index to handle duplicate file entries.
+        fs.file.setFsFileId(fsFileIds[path]++);
+        fileSettings.push_back(std::move(fs));
     }
+
+    return true;
 }
 
-void ImportProject::importSln(std::istream &istr, const std::string &path)
+bool ImportProject::importSln(std::istream &istr, const std::string &path, const std::vector<std::string> &fileFilters)
 {
+    std::string line;
+
+    if (!std::getline(istr,line)) {
+        errors.emplace_back("Visual Studio solution file is empty");
+        return false;
+    }
+
+    if (!startsWith(line, "Microsoft Visual Studio Solution File")) {
+        // Skip BOM
+        if (!std::getline(istr, line) || !startsWith(line, "Microsoft Visual Studio Solution File")) {
+            errors.emplace_back("Visual Studio solution file header not found");
+            return false;
+        }
+    }
+
     std::map<std::string,std::string,cppcheck::stricmp> variables;
     variables["SolutionDir"] = path;
 
-    std::string line;
+    bool found = false;
+    std::vector<SharedItemsProject> sharedItemsProjects;
     while (std::getline(istr,line)) {
-        if (line.compare(0,8,"Project(")!=0)
+        if (!startsWith(line,"Project("))
             continue;
         const std::string::size_type pos = line.find(".vcxproj");
         if (pos == std::string::npos)
@@ -407,25 +484,40 @@ void ImportProject::importSln(std::istream &istr, const std::string &path)
         if (pos1 == std::string::npos)
             continue;
         std::string vcxproj(line.substr(pos1+1, pos-pos1+7));
+        vcxproj = Path::toNativeSeparators(std::move(vcxproj));
         if (!Path::isAbsolute(vcxproj))
             vcxproj = path + vcxproj;
-        importVcxproj(Path::fromNativeSeparators(vcxproj), variables, emptyString);
+        vcxproj = Path::fromNativeSeparators(std::move(vcxproj));
+        if (!importVcxproj(vcxproj, variables, "", fileFilters, sharedItemsProjects)) {
+            errors.emplace_back("failed to load '" + vcxproj + "' from Visual Studio solution");
+            return false;
+        }
+        found = true;
     }
+
+    if (!found) {
+        errors.emplace_back("no projects found in Visual Studio solution file");
+        return false;
+    }
+
+    return true;
 }
 
 namespace {
     struct ProjectConfiguration {
-        explicit ProjectConfiguration(const tinyxml2::XMLElement *cfg) : platform(Unknown) {
+        explicit ProjectConfiguration(const tinyxml2::XMLElement *cfg) {
             const char *a = cfg->Attribute("Include");
             if (a)
                 name = a;
             for (const tinyxml2::XMLElement *e = cfg->FirstChildElement(); e; e = e->NextSiblingElement()) {
-                if (!e->GetText())
+                const char * const text = e->GetText();
+                if (!text)
                     continue;
-                if (std::strcmp(e->Name(),"Configuration")==0)
-                    configuration = e->GetText();
-                else if (std::strcmp(e->Name(),"Platform")==0) {
-                    platformStr = e->GetText();
+                const char * ename = e->Name();
+                if (std::strcmp(ename,"Configuration")==0)
+                    configuration = text;
+                else if (std::strcmp(ename,"Platform")==0) {
+                    platformStr = text;
                     if (platformStr == "Win32")
                         platform = Win32;
                     else if (platformStr == "x64")
@@ -437,30 +529,15 @@ namespace {
         }
         std::string name;
         std::string configuration;
-        enum { Win32, x64, Unknown } platform;
+        enum : std::uint8_t { Win32, x64, Unknown } platform = Unknown;
         std::string platformStr;
     };
 
-    struct ItemDefinitionGroup {
-        explicit ItemDefinitionGroup(const tinyxml2::XMLElement *idg, const std::string &includePaths) : additionalIncludePaths(includePaths) {
+    struct ConditionalGroup {
+        explicit ConditionalGroup(const tinyxml2::XMLElement *idg){
             const char *condAttr = idg->Attribute("Condition");
             if (condAttr)
-                condition = condAttr;
-            for (const tinyxml2::XMLElement *e1 = idg->FirstChildElement(); e1; e1 = e1->NextSiblingElement()) {
-                if (std::strcmp(e1->Name(), "ClCompile") != 0)
-                    continue;
-                for (const tinyxml2::XMLElement *e = e1->FirstChildElement(); e; e = e->NextSiblingElement()) {
-                    if (e->GetText()) {
-                        if (std::strcmp(e->Name(), "PreprocessorDefinitions") == 0)
-                            preprocessorDefinitions = e->GetText();
-                        else if (std::strcmp(e->Name(), "AdditionalIncludeDirectories") == 0) {
-                            if (!additionalIncludePaths.empty())
-                                additionalIncludePaths += ';';
-                            additionalIncludePaths += e->GetText();
-                        }
-                    }
-                }
-            }
+                mCondition = condAttr;
         }
 
         static void replaceAll(std::string &c, const std::string &from, const std::string &to) {
@@ -471,20 +548,38 @@ namespace {
             }
         }
 
+        // see https://learn.microsoft.com/en-us/visualstudio/msbuild/msbuild-conditions
+        // properties are .NET String objects and you can call any of its members on them
         bool conditionIsTrue(const ProjectConfiguration &p) const {
-            if (condition.empty())
+            if (mCondition.empty())
                 return true;
-            std::string c = '(' + condition + ");";
+            std::string c = '(' + mCondition + ");";
             replaceAll(c, "$(Configuration)", p.configuration);
             replaceAll(c, "$(Platform)", p.platformStr);
 
-            // TODO : Better evaluation
-            Settings s;
-            std::istringstream istr(c);
-            Tokenizer tokenizer(&s, nullptr);
-            tokenizer.tokenize(istr,"vcxproj");
-            for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {
+            // TODO: improve evaluation
+            const Settings s;
+            TokenList tokenlist(s, Standards::Language::C);
+            tokenlist.createTokensFromBuffer(c.data(), c.size()); // TODO: check result
+            // TODO: put in a helper
+            // generate links
+            {
+                std::stack<Token*> lpar;
+                for (Token* tok2 = tokenlist.front(); tok2; tok2 = tok2->next()) {
+                    if (tok2->str() == "(")
+                        lpar.push(tok2);
+                    else if (tok2->str() == ")") {
+                        if (lpar.empty())
+                            break;
+                        Token::createMutualLinks(lpar.top(), tok2);
+                        lpar.pop();
+                    }
+                }
+            }
+            tokenlist.createAst();
+            for (const Token *tok = tokenlist.front(); tok; tok = tok->next()) {
                 if (tok->str() == "(" && tok->astOperand1() && tok->astOperand2()) {
+                    // TODO: this is wrong - it is Contains() not Equals()
                     if (tok->astOperand1()->expressionString() == "Configuration.Contains")
                         return ('\'' + p.configuration + '\'') == tok->astOperand2()->str();
                 }
@@ -493,9 +588,74 @@ namespace {
             }
             return false;
         }
-        std::string condition;
+    private:
+        std::string mCondition;
+    };
+
+    struct ItemDefinitionGroup : ConditionalGroup {
+        explicit ItemDefinitionGroup(const tinyxml2::XMLElement *idg, std::string includePaths) : ConditionalGroup(idg), additionalIncludePaths(std::move(includePaths)) {
+            for (const tinyxml2::XMLElement *e1 = idg->FirstChildElement(); e1; e1 = e1->NextSiblingElement()) {
+                const char* name = e1->Name();
+                if (std::strcmp(name, "ClCompile") == 0) {
+                    enhancedInstructionSet = "StreamingSIMDExtensions2";
+                    for (const tinyxml2::XMLElement *e = e1->FirstChildElement(); e; e = e->NextSiblingElement()) {
+                        const char * const text = e->GetText();
+                        if (!text)
+                            continue;
+                        const char * const ename = e->Name();
+                        if (std::strcmp(ename, "PreprocessorDefinitions") == 0)
+                            preprocessorDefinitions = text;
+                        else if (std::strcmp(ename, "AdditionalIncludeDirectories") == 0) {
+                            if (!additionalIncludePaths.empty())
+                                additionalIncludePaths += ';';
+                            additionalIncludePaths += text;
+                        } else if (std::strcmp(ename, "LanguageStandard") == 0) {
+                            if (std::strcmp(text, "stdcpp14") == 0)
+                                cppstd = Standards::CPP14;
+                            else if (std::strcmp(text, "stdcpp17") == 0)
+                                cppstd = Standards::CPP17;
+                            else if (std::strcmp(text, "stdcpp20") == 0)
+                                cppstd = Standards::CPP20;
+                            else if (std::strcmp(text, "stdcpplatest") == 0)
+                                cppstd = Standards::CPPLatest;
+                        } else if (std::strcmp(ename, "EnableEnhancedInstructionSet") == 0) {
+                            enhancedInstructionSet = text;
+                        }
+                    }
+                }
+                else if (std::strcmp(name, "Link") == 0) {
+                    for (const tinyxml2::XMLElement *e = e1->FirstChildElement(); e; e = e->NextSiblingElement()) {
+                        const char * const text = e->GetText();
+                        if (!text)
+                            continue;
+                        if (std::strcmp(e->Name(), "EntryPointSymbol") == 0) {
+                            entryPointSymbol = text;
+                        }
+                    }
+                }
+            }
+        }
+
+        std::string enhancedInstructionSet;
         std::string preprocessorDefinitions;
         std::string additionalIncludePaths;
+        std::string entryPointSymbol; // TODO: use this
+        Standards::cppstd_t cppstd = Standards::CPPLatest;
+    };
+
+    struct ConfigurationPropertyGroup : ConditionalGroup {
+        explicit ConfigurationPropertyGroup(const tinyxml2::XMLElement *idg) : ConditionalGroup(idg) {
+            for (const tinyxml2::XMLElement *e = idg->FirstChildElement(); e; e = e->NextSiblingElement()) {
+                if (std::strcmp(e->Name(), "UseOfMfc") == 0) {
+                    useOfMfc = true;
+                } else if (std::strcmp(e->Name(), "CharacterSet") == 0) {
+                    useUnicode = std::strcmp(e->GetText(), "Unicode") == 0;
+                }
+            }
+        }
+
+        bool useOfMfc = false;
+        bool useUnicode = false;
     };
 }
 
@@ -515,23 +675,14 @@ static std::list<std::string> toStringList(const std::string &s)
     return ret;
 }
 
-static void importPropertyGroup(const tinyxml2::XMLElement *node, std::map<std::string,std::string,cppcheck::stricmp> *variables, std::string *includePath, bool *useOfMfc)
+static void importPropertyGroup(const tinyxml2::XMLElement *node, std::map<std::string, std::string, cppcheck::stricmp> &variables, std::string &includePath)
 {
-    if (useOfMfc) {
-        for (const tinyxml2::XMLElement *e = node->FirstChildElement(); e; e = e->NextSiblingElement()) {
-            if (std::strcmp(e->Name(), "UseOfMfc") == 0) {
-                *useOfMfc = true;
-                break;
-            }
-        }
-    }
-
     const char* labelAttribute = node->Attribute("Label");
     if (labelAttribute && std::strcmp(labelAttribute, "UserMacros") == 0) {
         for (const tinyxml2::XMLElement *propertyGroup = node->FirstChildElement(); propertyGroup; propertyGroup = propertyGroup->NextSiblingElement()) {
-            const std::string name(propertyGroup->Name());
-            const char *text = propertyGroup->GetText();
-            (*variables)[name] = std::string(text ? text : "");
+            const char* name = propertyGroup->Name();
+            const char *text = empty_if_null(propertyGroup->GetText());
+            variables[name] = text;
         }
 
     } else if (!labelAttribute) {
@@ -544,22 +695,22 @@ static void importPropertyGroup(const tinyxml2::XMLElement *node, std::map<std::
             std::string path(text);
             const std::string::size_type pos = path.find("$(IncludePath)");
             if (pos != std::string::npos)
-                path = path.substr(0,pos) + *includePath + path.substr(pos+14U);
-            *includePath = path;
+                path.replace(pos, 14U, includePath);
+            includePath = std::move(path);
         }
     }
 }
 
-static void loadVisualStudioProperties(const std::string &props, std::map<std::string,std::string,cppcheck::stricmp> *variables, std::string *includePath, const std::string &additionalIncludeDirectories, std::list<ItemDefinitionGroup> &itemDefinitionGroupList)
+static void loadVisualStudioProperties(const std::string &props, std::map<std::string,std::string,cppcheck::stricmp> &variables, std::string &includePath, const std::string &additionalIncludeDirectories, std::list<ItemDefinitionGroup> &itemDefinitionGroupList)
 {
     std::string filename(props);
     // variables can't be resolved
-    if (!simplifyPathWithVariables(filename, *variables))
+    if (!simplifyPathWithVariables(filename, variables))
         return;
 
     // prepend project dir (if it exists) to transform relative paths into absolute ones
-    if (!Path::isAbsolute(filename) && variables->count("ProjectDir") > 0)
-        filename = Path::getAbsoluteFilePath(variables->at("ProjectDir") + filename);
+    if (!Path::isAbsolute(filename) && variables.count("ProjectDir") > 0)
+        filename = Path::getAbsoluteFilePath(variables.at("ProjectDir") + filename);
 
     tinyxml2::XMLDocument doc;
     if (doc.LoadFile(filename.c_str()) != tinyxml2::XML_SUCCESS)
@@ -568,7 +719,8 @@ static void loadVisualStudioProperties(const std::string &props, std::map<std::s
     if (rootnode == nullptr)
         return;
     for (const tinyxml2::XMLElement *node = rootnode->FirstChildElement(); node; node = node->NextSiblingElement()) {
-        if (std::strcmp(node->Name(), "ImportGroup") == 0) {
+        const char* name = node->Name();
+        if (std::strcmp(name, "ImportGroup") == 0) {
             const char *labelAttribute = node->Attribute("Label");
             if (labelAttribute == nullptr || std::strcmp(labelAttribute, "PropertySheets") != 0)
                 continue;
@@ -584,107 +736,280 @@ static void loadVisualStudioProperties(const std::string &props, std::map<std::s
                     loadVisualStudioProperties(loadprj, variables, includePath, additionalIncludeDirectories, itemDefinitionGroupList);
                 }
             }
-        } else if (std::strcmp(node->Name(),"PropertyGroup")==0) {
-            importPropertyGroup(node, variables, includePath, nullptr);
-        } else if (std::strcmp(node->Name(),"ItemDefinitionGroup")==0) {
+        } else if (std::strcmp(name,"PropertyGroup")==0) {
+            importPropertyGroup(node, variables, includePath);
+        } else if (std::strcmp(name,"ItemDefinitionGroup")==0) {
             itemDefinitionGroupList.emplace_back(node, additionalIncludeDirectories);
         }
     }
 }
 
-void ImportProject::importVcxproj(const std::string &filename, std::map<std::string, std::string, cppcheck::stricmp> &variables, const std::string &additionalIncludeDirectories)
+bool ImportProject::importVcxproj(const std::string &filename,
+                                  std::map<std::string, std::string, cppcheck::stricmp> &variables,
+                                  const std::string &additionalIncludeDirectories,
+                                  const std::vector<std::string> &fileFilters,
+                                  std::vector<SharedItemsProject> &cache)
+{
+    tinyxml2::XMLDocument doc;
+    const tinyxml2::XMLError error = doc.LoadFile(filename.c_str());
+    if (error != tinyxml2::XML_SUCCESS) {
+        errors.emplace_back(std::string("Visual Studio project file is not a valid XML - ") + tinyxml2::XMLDocument::ErrorIDToName(error));
+        return false;
+    }
+    return importVcxproj(filename, doc, variables, additionalIncludeDirectories, fileFilters, cache);
+}
+
+bool ImportProject::importVcxproj(const std::string &filename, const tinyxml2::XMLDocument &doc, std::map<std::string, std::string, cppcheck::stricmp> &variables, const std::string &additionalIncludeDirectories, const std::vector<std::string> &fileFilters, std::vector<SharedItemsProject> &cache)
 {
     variables["ProjectDir"] = Path::simplifyPath(Path::getPathFromFilename(filename));
 
     std::list<ProjectConfiguration> projectConfigurationList;
     std::list<std::string> compileList;
     std::list<ItemDefinitionGroup> itemDefinitionGroupList;
+    std::vector<ConfigurationPropertyGroup> configurationPropertyGroups;
     std::string includePath;
+    std::vector<SharedItemsProject> sharedItemsProjects;
 
-    bool useOfMfc = false;
-
-    tinyxml2::XMLDocument doc;
-    const tinyxml2::XMLError error = doc.LoadFile(filename.c_str());
-    if (error != tinyxml2::XML_SUCCESS)
-        return;
     const tinyxml2::XMLElement * const rootnode = doc.FirstChildElement();
-    if (rootnode == nullptr)
-        return;
+    if (rootnode == nullptr) {
+        errors.emplace_back("Visual Studio project file has no XML root node");
+        return false;
+    }
     for (const tinyxml2::XMLElement *node = rootnode->FirstChildElement(); node; node = node->NextSiblingElement()) {
-        if (std::strcmp(node->Name(), "ItemGroup") == 0) {
+        const char* name = node->Name();
+        if (std::strcmp(name, "ItemGroup") == 0) {
             const char *labelAttribute = node->Attribute("Label");
             if (labelAttribute && std::strcmp(labelAttribute, "ProjectConfigurations") == 0) {
                 for (const tinyxml2::XMLElement *cfg = node->FirstChildElement(); cfg; cfg = cfg->NextSiblingElement()) {
                     if (std::strcmp(cfg->Name(), "ProjectConfiguration") == 0) {
                         const ProjectConfiguration p(cfg);
-                        if (p.platform != ProjectConfiguration::Unknown)
+                        if (p.platform != ProjectConfiguration::Unknown) {
                             projectConfigurationList.emplace_back(cfg);
+                            mAllVSConfigs.insert(p.configuration);
+                        }
                     }
                 }
             } else {
                 for (const tinyxml2::XMLElement *e = node->FirstChildElement(); e; e = e->NextSiblingElement()) {
                     if (std::strcmp(e->Name(), "ClCompile") == 0) {
                         const char *include = e->Attribute("Include");
-                        if (include && Path::acceptFile(include))
-                            compileList.emplace_back(include);
+                        if (include && Path::acceptFile(include)) {
+                            std::string toInclude = Path::simplifyPath(Path::isAbsolute(include) ? include : Path::getPathFromFilename(filename) + include);
+                            compileList.emplace_back(toInclude);
+                        }
                     }
                 }
             }
-        } else if (std::strcmp(node->Name(), "ItemDefinitionGroup") == 0) {
+        } else if (std::strcmp(name, "ItemDefinitionGroup") == 0) {
             itemDefinitionGroupList.emplace_back(node, additionalIncludeDirectories);
-        } else if (std::strcmp(node->Name(), "PropertyGroup") == 0) {
-            importPropertyGroup(node, &variables, &includePath, &useOfMfc);
-        } else if (std::strcmp(node->Name(), "ImportGroup") == 0) {
+        } else if (std::strcmp(name, "PropertyGroup") == 0) {
+            const char* labelAttribute = node->Attribute("Label");
+            if (labelAttribute && std::strcmp(labelAttribute, "Configuration") == 0) {
+                configurationPropertyGroups.emplace_back(node);
+            } else {
+                importPropertyGroup(node, variables, includePath);
+            }
+        } else if (std::strcmp(name, "ImportGroup") == 0) {
             const char *labelAttribute = node->Attribute("Label");
             if (labelAttribute && std::strcmp(labelAttribute, "PropertySheets") == 0) {
                 for (const tinyxml2::XMLElement *e = node->FirstChildElement(); e; e = e->NextSiblingElement()) {
                     if (std::strcmp(e->Name(), "Import") == 0) {
                         const char *projectAttribute = e->Attribute("Project");
                         if (projectAttribute)
-                            loadVisualStudioProperties(projectAttribute, &variables, &includePath, additionalIncludeDirectories, itemDefinitionGroupList);
+                            loadVisualStudioProperties(projectAttribute, variables, includePath, additionalIncludeDirectories, itemDefinitionGroupList);
+                    }
+                }
+            } else if (labelAttribute && std::strcmp(labelAttribute, "Shared") == 0) {
+                for (const tinyxml2::XMLElement *e = node->FirstChildElement(); e; e = e->NextSiblingElement()) {
+                    if (std::strcmp(e->Name(), "Import") == 0) {
+                        const char *projectAttribute = e->Attribute("Project");
+                        if (projectAttribute) {
+                            // Path to shared items project is relative to current project directory,
+                            // unless the string starts with $(SolutionDir)
+                            std::string pathToSharedItemsFile;
+                            if (std::string(projectAttribute).rfind("$(SolutionDir)", 0) == 0) {
+                                pathToSharedItemsFile = projectAttribute;
+                            } else {
+                                pathToSharedItemsFile = variables["ProjectDir"] + projectAttribute;
+                            }
+                            if (!simplifyPathWithVariables(pathToSharedItemsFile, variables)) {
+                                errors.emplace_back("Could not simplify path to referenced shared items project");
+                                return false;
+                            }
+
+                            SharedItemsProject toAdd = importVcxitems(pathToSharedItemsFile, fileFilters, cache);
+                            if (!toAdd.successful) {
+                                errors.emplace_back("Could not load shared items project \"" + pathToSharedItemsFile + "\" from original path \"" + std::string(projectAttribute) + "\".");
+                                return false;
+                            }
+                            sharedItemsProjects.emplace_back(toAdd);
+                        }
                     }
                 }
             }
         }
     }
+    // # TODO: support signedness of char via /J (and potential XML option for it)?
+    // we can only set it globally but in this context it needs to be treated per file
+
+    // Include shared items project files
+    std::vector<std::string> sharedItemsIncludePaths;
+    for (const auto& sharedProject : sharedItemsProjects) {
+        for (const auto &file : sharedProject.sourceFiles) {
+            std::string pathToFile = Path::simplifyPath(Path::getPathFromFilename(sharedProject.pathToProjectFile) + file);
+            compileList.emplace_back(std::move(pathToFile));
+        }
+        for (const auto &p : sharedProject.includePaths) {
+            std::string path = Path::simplifyPath(Path::getPathFromFilename(sharedProject.pathToProjectFile) + p);
+            sharedItemsIncludePaths.emplace_back(std::move(path));
+        }
+    }
+
+    // Project files
+    PathMatch filtermatcher(fileFilters, Path::getCurrentPath());
+    for (const std::string &cfilename : compileList) {
+        if (!fileFilters.empty() && !filtermatcher.match(cfilename))
+            continue;
 
-    for (const std::string &c : compileList) {
         for (const ProjectConfiguration &p : projectConfigurationList) {
-            FileSettings fs;
-            fs.filename = Path::simplifyPath(Path::isAbsolute(c) ? c : Path::getPathFromFilename(filename) + c);
+
+            if (!guiProject.checkVsConfigs.empty()) {
+                const bool doChecking = std::any_of(guiProject.checkVsConfigs.cbegin(), guiProject.checkVsConfigs.cend(), [&](const std::string& c) {
+                    return c == p.configuration;
+                });
+                if (!doChecking)
+                    continue;
+            }
+
+            FileSettings fs{cfilename, Standards::Language::None, 0}; // file will be identified later on
             fs.cfg = p.name;
+            // TODO: detect actual MSC version
             fs.msc = true;
-            fs.useMfc = useOfMfc;
             fs.defines = "_WIN32=1";
             if (p.platform == ProjectConfiguration::Win32)
-                fs.platformType = cppcheck::Platform::Win32W;
+                fs.platformType = Platform::Type::Win32W;
             else if (p.platform == ProjectConfiguration::x64) {
-                fs.platformType = cppcheck::Platform::Win64;
+                fs.platformType = Platform::Type::Win64;
                 fs.defines += ";_WIN64=1";
             }
             std::string additionalIncludePaths;
             for (const ItemDefinitionGroup &i : itemDefinitionGroupList) {
                 if (!i.conditionIsTrue(p))
                     continue;
+                fs.standard = Standards::getCPP(i.cppstd);
                 fs.defines += ';' + i.preprocessorDefinitions;
+                if (i.enhancedInstructionSet == "StreamingSIMDExtensions")
+                    fs.defines += ";__SSE__";
+                else if (i.enhancedInstructionSet == "StreamingSIMDExtensions2")
+                    fs.defines += ";__SSE2__";
+                else if (i.enhancedInstructionSet == "AdvancedVectorExtensions")
+                    fs.defines += ";__AVX__";
+                else if (i.enhancedInstructionSet == "AdvancedVectorExtensions2")
+                    fs.defines += ";__AVX2__";
+                else if (i.enhancedInstructionSet == "AdvancedVectorExtensions512")
+                    fs.defines += ";__AVX512__";
                 additionalIncludePaths += ';' + i.additionalIncludePaths;
             }
-            fs.setDefines(fs.defines);
-            fs.setIncludePaths(Path::getPathFromFilename(filename), toStringList(includePath + ';' + additionalIncludePaths), variables);
-            fileSettings.push_back(fs);
+            bool useUnicode = false;
+            for (const ConfigurationPropertyGroup &c : configurationPropertyGroups) {
+                if (!c.conditionIsTrue(p))
+                    continue;
+                // in msbuild the last definition wins
+                useUnicode = c.useUnicode;
+                fs.useMfc = c.useOfMfc;
+            }
+            if (useUnicode) {
+                fs.defines += ";UNICODE=1;_UNICODE=1";
+            }
+            fsSetDefines(fs, fs.defines);
+            fsSetIncludePaths(fs, Path::getPathFromFilename(filename), toStringList(includePath + ';' + additionalIncludePaths), variables);
+            for (const auto &path : sharedItemsIncludePaths) {
+                fs.includePaths.emplace_back(path);
+            }
+            fileSettings.push_back(std::move(fs));
+        }
+    }
+
+    return true;
+}
+
+ImportProject::SharedItemsProject ImportProject::importVcxitems(const std::string& filename, const std::vector<std::string>& fileFilters, std::vector<SharedItemsProject> &cache)
+{
+    auto isInCacheCheck = [filename](const ImportProject::SharedItemsProject& e) -> bool {
+        return filename == e.pathToProjectFile;
+    };
+    const auto iterator = std::find_if(cache.begin(), cache.end(), isInCacheCheck);
+    if (iterator != std::end(cache)) {
+        return *iterator;
+    }
+
+    SharedItemsProject result;
+    result.pathToProjectFile = filename;
+
+    PathMatch filtermatcher(fileFilters, Path::getCurrentPath());
+
+    tinyxml2::XMLDocument doc;
+    const tinyxml2::XMLError error = doc.LoadFile(filename.c_str());
+    if (error != tinyxml2::XML_SUCCESS) {
+        errors.emplace_back(std::string("Visual Studio project file is not a valid XML - ") + tinyxml2::XMLDocument::ErrorIDToName(error));
+        return result;
+    }
+    const tinyxml2::XMLElement * const rootnode = doc.FirstChildElement();
+    if (rootnode == nullptr) {
+        errors.emplace_back("Visual Studio project file has no XML root node");
+        return result;
+    }
+    for (const tinyxml2::XMLElement *node = rootnode->FirstChildElement(); node; node = node->NextSiblingElement()) {
+        if (std::strcmp(node->Name(), "ItemGroup") == 0) {
+            for (const tinyxml2::XMLElement *e = node->FirstChildElement(); e; e = e->NextSiblingElement()) {
+                if (std::strcmp(e->Name(), "ClCompile") == 0) {
+                    const char* include = e->Attribute("Include");
+                    if (include && Path::acceptFile(include)) {
+                        std::string file(include);
+                        findAndReplace(file, "$(MSBuildThisFileDirectory)", "./");
+
+                        // Skip file if it doesn't match the filter
+                        if (!fileFilters.empty() && !filtermatcher.match(file))
+                            continue;
+
+                        result.sourceFiles.emplace_back(file);
+                    } else {
+                        errors.emplace_back("Could not find shared items source file");
+                        return result;
+                    }
+                }
+            }
+        } else if (std::strcmp(node->Name(), "ItemDefinitionGroup") == 0) {
+            ItemDefinitionGroup temp(node, "");
+            for (const auto& includePath : toStringList(temp.additionalIncludePaths)) {
+                if (includePath == "%(AdditionalIncludeDirectories)")
+                    continue;
+
+                std::string toAdd(includePath);
+                findAndReplace(toAdd, "$(MSBuildThisFileDirectory)", "./");
+                result.includePaths.emplace_back(toAdd);
+            }
         }
     }
+
+    result.successful = true;
+    cache.emplace_back(result);
+    return result;
 }
 
-void ImportProject::importBcb6Prj(const std::string &projectFilename)
+bool ImportProject::importBcb6Prj(const std::string &projectFilename)
 {
     tinyxml2::XMLDocument doc;
     const tinyxml2::XMLError error = doc.LoadFile(projectFilename.c_str());
-    if (error != tinyxml2::XML_SUCCESS)
-        return;
+    if (error != tinyxml2::XML_SUCCESS) {
+        errors.emplace_back(std::string("Borland project file is not a valid XML - ") + tinyxml2::XMLDocument::ErrorIDToName(error));
+        return false;
+    }
     const tinyxml2::XMLElement * const rootnode = doc.FirstChildElement();
-    if (rootnode == nullptr)
-        return;
+    if (rootnode == nullptr) {
+        errors.emplace_back("Borland project file has no XML root node");
+        return false;
+    }
 
     const std::string& projectDir = Path::simplifyPath(Path::getPathFromFilename(projectFilename));
 
@@ -695,7 +1020,8 @@ void ImportProject::importBcb6Prj(const std::string &projectFilename)
     std::string cflag1;
 
     for (const tinyxml2::XMLElement *node = rootnode->FirstChildElement(); node; node = node->NextSiblingElement()) {
-        if (std::strcmp(node->Name(), "FILELIST") == 0) {
+        const char* name = node->Name();
+        if (std::strcmp(name, "FILELIST") == 0) {
             for (const tinyxml2::XMLElement *f = node->FirstChildElement(); f; f = f->NextSiblingElement()) {
                 if (std::strcmp(f->Name(), "FILE") == 0) {
                     const char *filename = f->Attribute("FILENAME");
@@ -703,23 +1029,24 @@ void ImportProject::importBcb6Prj(const std::string &projectFilename)
                         compileList.emplace_back(filename);
                 }
             }
-        } else if (std::strcmp(node->Name(), "MACROS") == 0) {
+        } else if (std::strcmp(name, "MACROS") == 0) {
             for (const tinyxml2::XMLElement *m = node->FirstChildElement(); m; m = m->NextSiblingElement()) {
-                if (std::strcmp(m->Name(), "INCLUDEPATH") == 0) {
+                const char* mname = m->Name();
+                if (std::strcmp(mname, "INCLUDEPATH") == 0) {
                     const char *v = m->Attribute("value");
                     if (v)
                         includePath = v;
-                } else if (std::strcmp(m->Name(), "USERDEFINES") == 0) {
+                } else if (std::strcmp(mname, "USERDEFINES") == 0) {
                     const char *v = m->Attribute("value");
                     if (v)
                         userdefines = v;
-                } else if (std::strcmp(m->Name(), "SYSDEFINES") == 0) {
+                } else if (std::strcmp(mname, "SYSDEFINES") == 0) {
                     const char *v = m->Attribute("value");
                     if (v)
                         sysdefines = v;
                 }
             }
-        } else if (std::strcmp(node->Name(), "OPTIONS") == 0) {
+        } else if (std::strcmp(name, "OPTIONS") == 0) {
             for (const tinyxml2::XMLElement *m = node->FirstChildElement(); m; m = m->NextSiblingElement()) {
                 if (std::strcmp(m->Name(), "CFLAG1") == 0) {
                     const char *v = m->Attribute("value");
@@ -736,7 +1063,7 @@ void ImportProject::importBcb6Prj(const std::string &projectFilename)
     {
         std::string arg;
 
-        for (char i : cflag1) {
+        for (const char i : cflag1) {
             if (i == ' ' && !arg.empty()) {
                 cflags.insert(arg);
                 arg.clear();
@@ -746,7 +1073,7 @@ void ImportProject::importBcb6Prj(const std::string &projectFilename)
         }
 
         if (!arg.empty()) {
-            cflags.insert(arg);
+            cflags.insert(std::move(arg));
         }
 
         // cleanup: -t is "An alternate name for the -Wxxx switches; there is no difference"
@@ -770,7 +1097,7 @@ void ImportProject::importBcb6Prj(const std::string &projectFilename)
             { "-tWV","-WV" }
         };
 
-        for (std::map<std::string, std::string>::const_iterator i = synonyms.begin(); i != synonyms.end(); ++i) {
+        for (auto i = synonyms.cbegin(); i != synonyms.cend(); ++i) {
             if (cflags.erase(i->first) > 0) {
                 cflags.insert(i->second);
             }
@@ -928,12 +1255,14 @@ void ImportProject::importBcb6Prj(const std::string &projectFilename)
         //
         // We can also force C++ compilation for all files using the -P command line switch.
         const bool cppMode = forceCppMode || Path::getFilenameExtensionInLowerCase(c) == ".cpp";
-        FileSettings fs;
-        fs.setIncludePaths(projectDir, toStringList(includePath), variables);
-        fs.setDefines(cppMode ? cppDefines : defines);
-        fs.filename = Path::simplifyPath(Path::isAbsolute(c) ? c : projectDir + c);
-        fileSettings.push_back(fs);
+        // TODO: needs to set language and ignore later identification and language enforcement
+        FileSettings fs{Path::simplifyPath(Path::isAbsolute(c) ? c : projectDir + c), Standards::Language::None, 0}; // file will be identified later on
+        fsSetIncludePaths(fs, projectDir, toStringList(includePath), variables);
+        fsSetDefines(fs, cppMode ? cppDefines : defines);
+        fileSettings.push_back(std::move(fs));
     }
+
+    return true;
 }
 
 static std::string joinRelativePath(const std::string &path1, const std::string &path2)
@@ -951,7 +1280,20 @@ static std::list<std::string> readXmlStringList(const tinyxml2::XMLElement *node
             continue;
         const char *attr = attribute ? child->Attribute(attribute) : child->GetText();
         if (attr)
-            ret.push_back(joinRelativePath(path, attr));
+            ret.emplace_back(joinRelativePath(path, attr));
+    }
+    return ret;
+}
+
+static std::list<std::string> readXmlPathMatchList(const tinyxml2::XMLElement *node, const std::string &path, const char name[], const char attribute[])
+{
+    std::list<std::string> ret;
+    for (const tinyxml2::XMLElement *child = node->FirstChildElement(); child; child = child->NextSiblingElement()) {
+        if (strcmp(child->Name(), name) != 0)
+            continue;
+        const char *attr = attribute ? child->Attribute(attribute) : child->GetText();
+        if (attr)
+            ret.emplace_back(PathMatch::joinRelativePattern(path, attr));
     }
     return ret;
 }
@@ -971,126 +1313,259 @@ static std::string istream_to_string(std::istream &istr)
     return std::string(std::istreambuf_iterator<char>(istr), eos);
 }
 
-bool ImportProject::importCppcheckGuiProject(std::istream &istr, Settings *settings)
+bool ImportProject::importCppcheckGuiProject(std::istream &istr, Settings &settings, Suppressions &supprs)
 {
     tinyxml2::XMLDocument doc;
     const std::string xmldata = istream_to_string(istr);
-    if (doc.Parse(xmldata.data(), xmldata.size()) != tinyxml2::XML_SUCCESS)
+    const tinyxml2::XMLError error = doc.Parse(xmldata.data(), xmldata.size());
+    if (error != tinyxml2::XML_SUCCESS) {
+        errors.emplace_back(std::string("Cppcheck GUI project file is not a valid XML - ") + tinyxml2::XMLDocument::ErrorIDToName(error));
         return false;
+    }
     const tinyxml2::XMLElement * const rootnode = doc.FirstChildElement();
-    if (rootnode == nullptr || strcmp(rootnode->Name(), CppcheckXml::ProjectElementName) != 0)
+    if (rootnode == nullptr || strcmp(rootnode->Name(), CppcheckXml::ProjectElementName) != 0) {
+        errors.emplace_back("Cppcheck GUI project file has no XML root node");
         return false;
+    }
 
     const std::string &path = mPath;
 
     std::list<std::string> paths;
-    std::list<std::string> suppressions;
+    std::list<SuppressionList::Suppression> suppressions;
     Settings temp;
 
-    guiProject.analyzeAllVsConfigs.clear();
+    // default to --check-level=normal for import for now
+    temp.setCheckLevel(Settings::CheckLevel::normal);
 
+    // TODO: this should support all available command-line options
     for (const tinyxml2::XMLElement *node = rootnode->FirstChildElement(); node; node = node->NextSiblingElement()) {
-        if (strcmp(node->Name(), CppcheckXml::RootPathName) == 0 && node->Attribute(CppcheckXml::RootPathNameAttrib)) {
-            temp.basePaths.push_back(joinRelativePath(path, node->Attribute(CppcheckXml::RootPathNameAttrib)));
-            temp.relativePaths = true;
-        } else if (strcmp(node->Name(), CppcheckXml::BuildDirElementName) == 0)
-            temp.buildDir = joinRelativePath(path, node->GetText() ? node->GetText() : "");
-        else if (strcmp(node->Name(), CppcheckXml::IncludeDirElementName) == 0)
-            temp.includePaths = readXmlStringList(node, path, CppcheckXml::DirElementName, CppcheckXml::DirNameAttrib);
-        else if (strcmp(node->Name(), CppcheckXml::DefinesElementName) == 0)
-            temp.userDefines = join(readXmlStringList(node, "", CppcheckXml::DefineName, CppcheckXml::DefineNameAttrib), ";");
-        else if (strcmp(node->Name(), CppcheckXml::UndefinesElementName) == 0) {
+        const char* name = node->Name();
+        if (strcmp(name, CppcheckXml::RootPathName) == 0) {
+            const char* attr = node->Attribute(CppcheckXml::RootPathNameAttrib);
+            if (attr) {
+                temp.basePaths.push_back(Path::fromNativeSeparators(joinRelativePath(path, attr)));
+                temp.relativePaths = true;
+            }
+        } else if (strcmp(name, CppcheckXml::BuildDirElementName) == 0)
+            temp.buildDir = joinRelativePath(path, empty_if_null(node->GetText()));
+        else if (strcmp(name, CppcheckXml::IncludeDirElementName) == 0)
+            temp.includePaths = readXmlStringList(node, path, CppcheckXml::DirElementName, CppcheckXml::DirNameAttrib); // TODO: append instead of overwrite
+        else if (strcmp(name, CppcheckXml::DefinesElementName) == 0)
+            temp.userDefines = join(readXmlStringList(node, "", CppcheckXml::DefineName, CppcheckXml::DefineNameAttrib), ";"); // TODO: append instead of overwrite
+        else if (strcmp(name, CppcheckXml::UndefinesElementName) == 0) {
             for (const std::string &u : readXmlStringList(node, "", CppcheckXml::UndefineName, nullptr))
                 temp.userUndefs.insert(u);
-        } else if (strcmp(node->Name(), CppcheckXml::ImportProjectElementName) == 0)
-            guiProject.projectFile = path + (node->GetText() ? node->GetText() : "");
-        else if (strcmp(node->Name(), CppcheckXml::PathsElementName) == 0)
+        } else if (strcmp(name, CppcheckXml::ImportProjectElementName) == 0) {
+            const std::string t_str = empty_if_null(node->GetText());
+            if (!t_str.empty())
+                guiProject.projectFile = path + t_str;
+        }
+        else if (strcmp(name, CppcheckXml::PathsElementName) == 0)
             paths = readXmlStringList(node, path, CppcheckXml::PathName, CppcheckXml::PathNameAttrib);
-        else if (strcmp(node->Name(), CppcheckXml::ExcludeElementName) == 0)
-            guiProject.excludedPaths = readXmlStringList(node, "", CppcheckXml::ExcludePathName, CppcheckXml::ExcludePathNameAttrib);
-        else if (strcmp(node->Name(), CppcheckXml::IgnoreElementName) == 0)
-            guiProject.excludedPaths = readXmlStringList(node, "", CppcheckXml::IgnorePathName, CppcheckXml::IgnorePathNameAttrib);
-        else if (strcmp(node->Name(), CppcheckXml::LibrariesElementName) == 0)
-            guiProject.libraries = readXmlStringList(node, "", CppcheckXml::LibraryElementName, nullptr);
-        else if (strcmp(node->Name(), CppcheckXml::SuppressionsElementName) == 0)
-            suppressions = readXmlStringList(node, "", CppcheckXml::SuppressionElementName, nullptr);
-        else if (strcmp(node->Name(), CppcheckXml::PlatformElementName) == 0)
-            guiProject.platform = node->GetText();
-        else if (strcmp(node->Name(), CppcheckXml::AnalyzeAllVsConfigsElementName) == 0)
-            guiProject.analyzeAllVsConfigs = node->GetText();
-        else if (strcmp(node->Name(), CppcheckXml::AddonsElementName) == 0)
-            temp.addons = readXmlStringList(node, "", CppcheckXml::AddonElementName, nullptr);
-        else if (strcmp(node->Name(), CppcheckXml::TagsElementName) == 0)
+        else if (strcmp(name, CppcheckXml::ExcludeElementName) == 0)
+            guiProject.excludedPaths = readXmlPathMatchList(node, path, CppcheckXml::ExcludePathName, CppcheckXml::ExcludePathNameAttrib); // TODO: append instead of overwrite
+        else if (strcmp(name, CppcheckXml::FunctionContracts) == 0)
+            ;
+        else if (strcmp(name, CppcheckXml::VariableContractsElementName) == 0)
+            ;
+        else if (strcmp(name, CppcheckXml::IgnoreElementName) == 0)
+            guiProject.excludedPaths = readXmlPathMatchList(node, path, CppcheckXml::IgnorePathName, CppcheckXml::IgnorePathNameAttrib); // TODO: append instead of overwrite
+        else if (strcmp(name, CppcheckXml::LibrariesElementName) == 0)
+            guiProject.libraries = readXmlStringList(node, "", CppcheckXml::LibraryElementName, nullptr); // TODO: append instead of overwrite
+        else if (strcmp(name, CppcheckXml::SuppressionsElementName) == 0) {
+            for (const tinyxml2::XMLElement *child = node->FirstChildElement(); child; child = child->NextSiblingElement()) {
+                if (strcmp(child->Name(), CppcheckXml::SuppressionElementName) != 0)
+                    continue;
+                SuppressionList::Suppression s;
+                s.errorId = empty_if_null(child->GetText());
+                s.fileName = empty_if_null(child->Attribute("fileName"));
+                if (!s.fileName.empty())
+                    s.fileName = joinRelativePath(path, s.fileName);
+                s.lineNumber = child->IntAttribute("lineNumber", SuppressionList::Suppression::NO_LINE); // TODO: should not depend on Suppression
+                s.symbolName = empty_if_null(child->Attribute("symbolName"));
+                s.hash = strToInt<std::size_t>(default_if_null(child->Attribute("hash"), "0"));
+                suppressions.push_back(std::move(s));
+            }
+        } else if (strcmp(name, CppcheckXml::VSConfigurationElementName) == 0)
+            guiProject.checkVsConfigs = readXmlStringList(node, "", CppcheckXml::VSConfigurationName, nullptr);
+        else if (strcmp(name, CppcheckXml::PlatformElementName) == 0)
+            guiProject.platform = empty_if_null(node->GetText());
+        else if (strcmp(name, CppcheckXml::AnalyzeAllVsConfigsElementName) == 0)
+            temp.analyzeAllVsConfigs = std::string(empty_if_null(node->GetText())) != "false";
+        else if (strcmp(name, CppcheckXml::Parser) == 0)
+            temp.clang = true;
+        else if (strcmp(name, CppcheckXml::AddonsElementName) == 0) {
+            const auto& addons = readXmlStringList(node, "", CppcheckXml::AddonElementName, nullptr);
+            temp.addons.insert(addons.cbegin(), addons.cend());
+            if (settings.premium) {
+                auto it = temp.addons.find("misra");
+                if (it != temp.addons.end()) {
+                    temp.addons.erase(it);
+                    temp.premiumArgs += " --misra-c-2012";
+                }
+            }
+        }
+        else if (strcmp(name, CppcheckXml::TagsElementName) == 0)
             node->Attribute(CppcheckXml::TagElementName); // FIXME: Write some warning
-        else if (strcmp(node->Name(), CppcheckXml::ToolsElementName) == 0)
-            node->Attribute(CppcheckXml::ToolElementName); // FIXME: Write some warning
-        else if (strcmp(node->Name(), CppcheckXml::CheckHeadersElementName) == 0)
-            temp.checkHeaders = (strcmp(node->GetText(), "true") == 0);
-        else if (strcmp(node->Name(), CppcheckXml::CheckUnusedTemplatesElementName) == 0)
-            temp.checkUnusedTemplates = (strcmp(node->GetText(), "true") == 0);
-        else if (strcmp(node->Name(), CppcheckXml::MaxCtuDepthElementName) == 0)
-            temp.maxCtuDepth = std::atoi(node->GetText());
-        else if (strcmp(node->Name(), CppcheckXml::CheckUnknownFunctionReturn) == 0)
+        else if (strcmp(name, CppcheckXml::ToolsElementName) == 0) {
+            const std::list<std::string> toolList = readXmlStringList(node, "", CppcheckXml::ToolElementName, nullptr);
+            for (const std::string &toolName : toolList) {
+                if (toolName == CppcheckXml::ClangTidy)
+                    temp.clangTidy = true;
+            }
+        } else if (strcmp(name, CppcheckXml::CheckHeadersElementName) == 0)
+            temp.checkHeaders = (strcmp(default_if_null(node->GetText(), ""), "true") == 0);
+        else if (strcmp(name, CppcheckXml::CheckLevelReducedElementName) == 0)
+            temp.setCheckLevel(Settings::CheckLevel::reduced);
+        else if (strcmp(name, CppcheckXml::CheckLevelNormalElementName) == 0)
+            temp.setCheckLevel(Settings::CheckLevel::normal);
+        else if (strcmp(name, CppcheckXml::CheckLevelExhaustiveElementName) == 0)
+            temp.setCheckLevel(Settings::CheckLevel::exhaustive);
+        else if (strcmp(name, CppcheckXml::CheckUnusedTemplatesElementName) == 0)
+            temp.checkUnusedTemplates = (strcmp(default_if_null(node->GetText(), ""), "true") == 0);
+        else if (strcmp(name, CppcheckXml::InlineSuppression) == 0)
+            temp.inlineSuppressions = (strcmp(default_if_null(node->GetText(), ""), "true") == 0);
+        else if (strcmp(name, CppcheckXml::MaxCtuDepthElementName) == 0)
+            temp.maxCtuDepth = strToInt<int>(default_if_null(node->GetText(), "2")); // TODO: bail out when missing?
+        else if (strcmp(name, CppcheckXml::MaxTemplateRecursionElementName) == 0)
+            temp.maxTemplateRecursion = strToInt<int>(default_if_null(node->GetText(), "100")); // TODO: bail out when missing?
+        else if (strcmp(name, CppcheckXml::CheckUnknownFunctionReturn) == 0)
             ; // TODO
-        else if (strcmp(node->Name(), Settings::SafeChecks::XmlRootName) == 0) {
+        else if (strcmp(name, Settings::SafeChecks::XmlRootName) == 0) {
             for (const tinyxml2::XMLElement *child = node->FirstChildElement(); child; child = child->NextSiblingElement()) {
-                if (strcmp(child->Name(), Settings::SafeChecks::XmlClasses) == 0)
+                const char* childname = child->Name();
+                if (strcmp(childname, Settings::SafeChecks::XmlClasses) == 0)
                     temp.safeChecks.classes = true;
-                else if (strcmp(child->Name(), Settings::SafeChecks::XmlExternalFunctions) == 0)
+                else if (strcmp(childname, Settings::SafeChecks::XmlExternalFunctions) == 0)
                     temp.safeChecks.externalFunctions = true;
-                else if (strcmp(child->Name(), Settings::SafeChecks::XmlInternalFunctions) == 0)
+                else if (strcmp(childname, Settings::SafeChecks::XmlInternalFunctions) == 0)
                     temp.safeChecks.internalFunctions = true;
-                else if (strcmp(child->Name(), Settings::SafeChecks::XmlExternalVariables) == 0)
+                else if (strcmp(childname, Settings::SafeChecks::XmlExternalVariables) == 0)
                     temp.safeChecks.externalVariables = true;
-                else
+                else {
+                    errors.emplace_back("Unknown '" + std::string(Settings::SafeChecks::XmlRootName) + "' element '" + childname + "' in Cppcheck GUI project file");
                     return false;
+                }
             }
-        } else
+        } else if (strcmp(name, CppcheckXml::TagWarningsElementName) == 0)
+            ; // TODO
+        // Cppcheck Premium features
+        else if (strcmp(name, CppcheckXml::BughuntingElementName) == 0)
+            temp.premiumArgs += " --bughunting";
+        else if (strcmp(name, CppcheckXml::CertIntPrecisionElementName) == 0)
+            temp.premiumArgs += std::string(" --cert-c-int-precision=") + default_if_null(node->GetText(), "0");
+        else if (strcmp(name, CppcheckXml::CodingStandardsElementName) == 0) {
+            for (const tinyxml2::XMLElement *child = node->FirstChildElement(); child; child = child->NextSiblingElement()) {
+                if (strcmp(child->Name(), CppcheckXml::CodingStandardElementName) == 0) {
+                    const char* text = child->GetText();
+                    if (text)
+                        temp.premiumArgs += std::string(" --") + text;
+                }
+            }
+        }
+        else if (strcmp(name, CppcheckXml::ProjectNameElementName) == 0)
+            ; // no-op
+        else {
+            errors.emplace_back("Unknown element '" + std::string(name) + "' in Cppcheck GUI project file");
             return false;
+        }
     }
-    settings->basePaths = temp.basePaths;
-    settings->relativePaths |= temp.relativePaths;
-    settings->buildDir = temp.buildDir;
-    settings->includePaths = temp.includePaths;
-    settings->userDefines = temp.userDefines;
-    settings->userUndefs = temp.userUndefs;
-    settings->addons = temp.addons;
+    settings.basePaths = temp.basePaths; // TODO: append instead of overwrite
+    settings.relativePaths |= temp.relativePaths;
+    settings.buildDir = temp.buildDir;
+    settings.includePaths = temp.includePaths; // TODO: append instead of overwrite
+    settings.userDefines = temp.userDefines; // TODO: append instead of overwrite
+    settings.userUndefs = temp.userUndefs; // TODO: append instead of overwrite
+    for (const std::string &addon : temp.addons)
+        settings.addons.emplace(addon);
+    settings.clang = temp.clang;
+    settings.clangTidy = temp.clangTidy;
+    settings.analyzeAllVsConfigs = temp.analyzeAllVsConfigs;
+
+    if (!settings.premiumArgs.empty())
+        settings.premiumArgs += temp.premiumArgs;
+    else if (!temp.premiumArgs.empty())
+        settings.premiumArgs = temp.premiumArgs.substr(1);
+
     for (const std::string &p : paths)
-        guiProject.pathNames.push_back(p);
-    for (const std::string &supp : suppressions)
-        settings->nomsg.addSuppressionLine(supp);
-    settings->checkHeaders = temp.checkHeaders;
-    settings->checkUnusedTemplates = temp.checkUnusedTemplates;
-    settings->maxCtuDepth = temp.maxCtuDepth;
-    settings->safeChecks = temp.safeChecks;
+        guiProject.pathNames.push_back(Path::fromNativeSeparators(p));
+    supprs.nomsg.addSuppressions(std::move(suppressions)); // TODO: check result
+    settings.checkHeaders = temp.checkHeaders;
+    settings.checkUnusedTemplates = temp.checkUnusedTemplates;
+    settings.maxCtuDepth = temp.maxCtuDepth;
+    settings.maxTemplateRecursion = temp.maxTemplateRecursion;
+    settings.inlineSuppressions |= temp.inlineSuppressions;
+    settings.safeChecks = temp.safeChecks;
+    settings.setCheckLevel(temp.checkLevel);
+
     return true;
 }
 
-void ImportProject::selectOneVsConfig(Settings::PlatformType platform)
+void ImportProject::selectOneVsConfig(Platform::Type platform)
 {
     std::set<std::string> filenames;
-    for (std::list<ImportProject::FileSettings>::iterator it = fileSettings.begin(); it != fileSettings.end();) {
+    for (auto it = fileSettings.cbegin(); it != fileSettings.cend();) {
         if (it->cfg.empty()) {
             ++it;
             continue;
         }
-        const ImportProject::FileSettings &fs = *it;
+        const FileSettings &fs = *it;
         bool remove = false;
-        if (fs.cfg.compare(0,5,"Debug") != 0)
+        if (!startsWith(fs.cfg,"Debug"))
             remove = true;
-        if (platform == Settings::Win64 && fs.platformType != platform)
+        if (platform == Platform::Type::Win64 && fs.platformType != platform)
             remove = true;
-        else if ((platform == Settings::Win32A || platform == Settings::Win32W) && fs.platformType == Settings::Win64)
+        else if ((platform == Platform::Type::Win32A || platform == Platform::Type::Win32W) && fs.platformType == Platform::Type::Win64)
             remove = true;
-        else if (fs.platformType != Settings::Win64 && platform == Settings::Win64)
+        else if (filenames.find(fs.filename()) != filenames.end())
             remove = true;
-        else if (filenames.find(fs.filename) != filenames.end())
+        if (remove) {
+            it = fileSettings.erase(it);
+        } else {
+            filenames.insert(fs.filename());
+            ++it;
+        }
+    }
+}
+
+void ImportProject::selectVsConfigurations(Platform::Type platform, const std::vector<std::string> &configurations)
+{
+    for (auto it = fileSettings.cbegin(); it != fileSettings.cend();) {
+        if (it->cfg.empty()) {
+            ++it;
+            continue;
+        }
+        const FileSettings &fs = *it;
+        const auto config = fs.cfg.substr(0, fs.cfg.find('|'));
+        bool remove = false;
+        if (std::find(configurations.begin(), configurations.end(), config) == configurations.end())
+            remove = true;
+        if (platform == Platform::Type::Win64 && fs.platformType != platform)
+            remove = true;
+        else if ((platform == Platform::Type::Win32A || platform == Platform::Type::Win32W) && fs.platformType == Platform::Type::Win64)
             remove = true;
         if (remove) {
             it = fileSettings.erase(it);
         } else {
-            filenames.insert(fs.filename);
             ++it;
         }
     }
 }
+
+std::list<std::string> ImportProject::getVSConfigs()
+{
+    return std::list<std::string>(mAllVSConfigs.cbegin(), mAllVSConfigs.cend());
+}
+
+void ImportProject::setRelativePaths(const std::string &filename)
+{
+    if (Path::isAbsolute(filename))
+        return;
+    const std::vector<std::string> basePaths{Path::fromNativeSeparators(Path::getCurrentPath())};
+    for (auto &fs: fileSettings) {
+        fs.file.setPath(Path::getRelativePath(fs.filename(), basePaths));
+        for (auto &includePath: fs.includePaths)
+            includePath = Path::getRelativePath(includePath, basePaths);
+    }
+}
+
diff --git a/lib/importproject.h b/lib/importproject.h
index 9e60be4e564..ba873b69ae5 100644
--- a/lib/importproject.h
+++ b/lib/importproject.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,15 +22,24 @@
 //---------------------------------------------------------------------------
 
 #include "config.h"
+#include "filesettings.h"
 #include "platform.h"
 #include "utils.h"
 
+#include <cstdint>
+#include <iosfwd>
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
+class Settings;
+struct Suppressions;
+namespace tinyxml2 {
+    class XMLDocument;
+}
+
 /// @addtogroup Core
 /// @{
 
@@ -42,16 +51,16 @@ namespace cppcheck {
     };
 }
 
-class Settings;
-
 /**
  * @brief Importing project settings.
  */
-class CPPCHECKLIB ImportProject {
+class CPPCHECKLIB WARN_UNUSED ImportProject {
 public:
-    enum class Type {
+    enum class Type : std::uint8_t {
+        NONE,
         UNKNOWN,
         MISSING,
+        FAILURE,
         COMPILE_DB,
         VS_SLN,
         VS_VCXPROJ,
@@ -59,100 +68,130 @@ class CPPCHECKLIB ImportProject {
         CPPCHECK_GUI
     };
 
-    /** File settings. Multiple configurations for a file is allowed. */
-    struct CPPCHECKLIB FileSettings {
-        FileSettings() : platformType(cppcheck::Platform::Unspecified), msc(false), useMfc(false) {}
-        std::string cfg;
-        std::string filename;
-        std::string defines;
-        std::string cppcheckDefines() const {
-            return defines + (msc ? ";_MSC_VER=1900" : "") + (useMfc ? ";__AFXWIN_H__=1" : "");
-        }
-        std::set<std::string> undefs;
-        std::list<std::string> includePaths;
-        std::list<std::string> systemIncludePaths;
-        std::string standard;
-        cppcheck::Platform::PlatformType platformType;
-        bool msc;
-        bool useMfc;
-
-        void parseCommand(const std::string &command);
-        void setDefines(std::string defs);
-        void setIncludePaths(const std::string &basepath, const std::list<std::string> &in, std::map<std::string, std::string, cppcheck::stricmp> &variables);
-    };
+protected:
+    static void fsSetDefines(FileSettings& fs, std::string defs);
+    static void fsSetIncludePaths(FileSettings& fs, const std::string &basepath, const std::list<std::string> &in, std::map<std::string, std::string, cppcheck::stricmp> &variables);
+
+public:
     std::list<FileSettings> fileSettings;
+    std::vector<std::string> errors;
+
+    ImportProject() = default;
+    virtual ~ImportProject() = default;
+    ImportProject(const ImportProject&) = default;
+    ImportProject& operator=(const ImportProject&) & = default;
+
+    void selectOneVsConfig(Platform::Type platform);
+    void selectVsConfigurations(Platform::Type platform, const std::vector<std::string> &configurations);
 
-    void selectOneVsConfig(cppcheck::Platform::PlatformType platform);
+    std::list<std::string> getVSConfigs();
 
     // Cppcheck GUI output
     struct {
-        std::string analyzeAllVsConfigs;
         std::vector<std::string> pathNames;
         std::list<std::string> libraries;
         std::list<std::string> excludedPaths;
+        std::list<std::string> checkVsConfigs;
         std::string projectFile;
         std::string platform;
     } guiProject;
 
-    void ignorePaths(const std::vector<std::string> &ipaths);
+    void ignorePaths(const std::vector<std::string> &ipaths, bool debug = false);
     void ignoreOtherConfigs(const std::string &cfg);
-    void ignoreOtherPlatforms(cppcheck::Platform::PlatformType platformType);
 
-    Type import(const std::string &filename, Settings *settings=nullptr);
+    Type import(const std::string &filename, Settings *settings=nullptr, Suppressions *supprs=nullptr);
 protected:
-    void importCompileCommands(std::istream &istr);
-    bool importCppcheckGuiProject(std::istream &istr, Settings *settings);
+    bool importCompileCommands(std::istream &istr);
+    bool importCppcheckGuiProject(std::istream &istr, Settings &settings, Suppressions &supprs);
+    static std::string collectArgs(const std::string &cmd, std::vector<std::string> &args);
+
+    struct SharedItemsProject {
+        bool successful = false;
+        std::string pathToProjectFile;
+        std::vector<std::string> includePaths;
+        std::vector<std::string> sourceFiles;
+    };
+
+    bool importVcxproj(const std::string &filename, std::map<std::string, std::string, cppcheck::stricmp> &variables, const std::string &additionalIncludeDirectories, const std::vector<std::string> &fileFilters, std::vector<SharedItemsProject> &cache);
+    bool importVcxproj(const std::string &filename, const tinyxml2::XMLDocument &doc, std::map<std::string, std::string, cppcheck::stricmp> &variables, const std::string &additionalIncludeDirectories, const std::vector<std::string> &fileFilters, std::vector<SharedItemsProject> &cache);
+
 private:
-    void importSln(std::istream &istr, const std::string &path);
-    void importVcxproj(const std::string &filename, std::map<std::string, std::string, cppcheck::stricmp> &variables, const std::string &additionalIncludeDirectories);
-    void importBcb6Prj(const std::string &projectFilename);
+    static void parseArgs(FileSettings &fs, const std::vector<std::string> &args);
+    void setRelativePaths(const std::string &filename);
+
+    bool importSln(std::istream &istr, const std::string &path, const std::vector<std::string> &fileFilters);
+    SharedItemsProject importVcxitems(const std::string &filename, const std::vector<std::string> &fileFilters, std::vector<SharedItemsProject> &cache);
+    bool importBcb6Prj(const std::string &projectFilename);
 
     std::string mPath;
+    std::set<std::string> mAllVSConfigs;
 };
 
 
 namespace CppcheckXml {
-    const char ProjectElementName[] = "project";
-    const char ProjectVersionAttrib[] = "version";
-    const char ProjectFileVersion[] = "1";
-    const char BuildDirElementName[] = "builddir";
-    const char ImportProjectElementName[] = "importproject";
-    const char AnalyzeAllVsConfigsElementName[] = "analyze-all-vs-configs";
-    const char IncludeDirElementName[] = "includedir";
-    const char DirElementName[] = "dir";
-    const char DirNameAttrib[] = "name";
-    const char DefinesElementName[] = "defines";
-    const char DefineName[] = "define";
-    const char DefineNameAttrib[] = "name";
-    const char UndefinesElementName[] = "undefines";
-    const char UndefineName[] = "undefine";
-    const char PathsElementName[] = "paths";
-    const char PathName[] = "dir";
-    const char PathNameAttrib[] = "name";
-    const char RootPathName[] = "root";
-    const char RootPathNameAttrib[] = "name";
-    const char IgnoreElementName[] = "ignore";
-    const char IgnorePathName[] = "path";
-    const char IgnorePathNameAttrib[] = "name";
-    const char ExcludeElementName[] = "exclude";
-    const char ExcludePathName[] = "path";
-    const char ExcludePathNameAttrib[] = "name";
-    const char LibrariesElementName[] = "libraries";
-    const char LibraryElementName[] = "library";
-    const char PlatformElementName[] = "platform";
-    const char SuppressionsElementName[] = "suppressions";
-    const char SuppressionElementName[] = "suppression";
-    const char AddonElementName[] = "addon";
-    const char AddonsElementName[] = "addons";
-    const char ToolElementName[] = "tool";
-    const char ToolsElementName[] = "tools";
-    const char TagsElementName[] = "tags";
-    const char TagElementName[] = "tag";
-    const char CheckHeadersElementName[] = "check-headers";
-    const char CheckUnusedTemplatesElementName[] = "check-unused-templates";
-    const char MaxCtuDepthElementName[] = "max-ctu-depth";
-    const char CheckUnknownFunctionReturn[] = "check-unknown-function-return-values";
-    const char Name[] = "name";
+    static constexpr char ProjectElementName[] = "project";
+    static constexpr char ProjectVersionAttrib[] = "version";
+    static constexpr char ProjectFileVersion[] = "1";
+    static constexpr char BuildDirElementName[] = "builddir";
+    static constexpr char ImportProjectElementName[] = "importproject";
+    static constexpr char AnalyzeAllVsConfigsElementName[] = "analyze-all-vs-configs";
+    static constexpr char Parser[] = "parser";
+    static constexpr char IncludeDirElementName[] = "includedir";
+    static constexpr char DirElementName[] = "dir";
+    static constexpr char DirNameAttrib[] = "name";
+    static constexpr char DefinesElementName[] = "defines";
+    static constexpr char DefineName[] = "define";
+    static constexpr char DefineNameAttrib[] = "name";
+    static constexpr char UndefinesElementName[] = "undefines";
+    static constexpr char UndefineName[] = "undefine";
+    static constexpr char PathsElementName[] = "paths";
+    static constexpr char PathName[] = "dir";
+    static constexpr char PathNameAttrib[] = "name";
+    static constexpr char RootPathName[] = "root";
+    static constexpr char RootPathNameAttrib[] = "name";
+    static constexpr char IgnoreElementName[] = "ignore";
+    static constexpr char IgnorePathName[] = "path";
+    static constexpr char IgnorePathNameAttrib[] = "name";
+    static constexpr char ExcludeElementName[] = "exclude";
+    static constexpr char ExcludePathName[] = "path";
+    static constexpr char ExcludePathNameAttrib[] = "name";
+    static constexpr char FunctionContracts[] = "function-contracts";
+    static constexpr char VariableContractsElementName[] = "variable-contracts";
+    static constexpr char LibrariesElementName[] = "libraries";
+    static constexpr char LibraryElementName[] = "library";
+    static constexpr char PlatformElementName[] = "platform";
+    static constexpr char SuppressionsElementName[] = "suppressions";
+    static constexpr char SuppressionElementName[] = "suppression";
+    static constexpr char AddonElementName[] = "addon";
+    static constexpr char AddonsElementName[] = "addons";
+    static constexpr char ToolElementName[] = "tool";
+    static constexpr char ToolsElementName[] = "tools";
+    static constexpr char TagsElementName[] = "tags";
+    static constexpr char TagElementName[] = "tag";
+    static constexpr char TagWarningsElementName[] = "tag-warnings";
+    static constexpr char TagAttributeName[] = "tag";
+    static constexpr char WarningElementName[] = "warning";
+    static constexpr char HashAttributeName[] = "hash";
+    static constexpr char CheckLevelExhaustiveElementName[] = "check-level-exhaustive";
+    static constexpr char CheckLevelNormalElementName[] = "check-level-normal";
+    static constexpr char CheckLevelReducedElementName[] = "check-level-reduced";
+    static constexpr char CheckHeadersElementName[] = "check-headers";
+    static constexpr char CheckUnusedTemplatesElementName[] = "check-unused-templates";
+    static constexpr char MaxCtuDepthElementName[] = "max-ctu-depth";
+    static constexpr char MaxTemplateRecursionElementName[] = "max-template-recursion";
+    static constexpr char CheckUnknownFunctionReturn[] = "check-unknown-function-return-values";
+    static constexpr char InlineSuppression[] = "inline-suppression";
+    static constexpr char ClangTidy[] = "clang-tidy";
+    static constexpr char Name[] = "name";
+    static constexpr char VSConfigurationElementName[] = "vs-configurations";
+    static constexpr char VSConfigurationName[] = "config";
+    // Cppcheck Premium
+    static constexpr char BughuntingElementName[] = "bug-hunting";
+    static constexpr char CodingStandardsElementName[] = "coding-standards";
+    static constexpr char CodingStandardElementName[] = "coding-standard";
+    static constexpr char CertIntPrecisionElementName[] = "cert-c-int-precision";
+    static constexpr char LicenseFileElementName[] = "license-file";
+    static constexpr char ProjectNameElementName[] = "project-name";
 }
 
 /// @}
diff --git a/lib/infer.cpp b/lib/infer.cpp
new file mode 100644
index 00000000000..cad0761f68b
--- /dev/null
+++ b/lib/infer.cpp
@@ -0,0 +1,422 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "infer.h"
+
+#include "calculate.h"
+#include "errortypes.h"
+#include "token.h"
+#include "valueptr.h"
+#include "vfvalue.h"
+
+#include <cassert>
+#include <algorithm>
+#include <functional>
+#include <iterator>
+#include <unordered_set>
+#include <utility>
+
+template<class Predicate, class Compare>
+static const ValueFlow::Value* getCompareValue(const std::list<ValueFlow::Value>& values, Predicate pred, Compare compare)
+{
+    const ValueFlow::Value* result = nullptr;
+    for (const ValueFlow::Value& value : values) {
+        if (!pred(value))
+            continue;
+        if (result)
+            result = &std::min(value, *result, [compare](const ValueFlow::Value& x, const ValueFlow::Value& y) {
+                return compare(x.intvalue, y.intvalue);
+            });
+        else
+            result = &value;
+    }
+    return result;
+}
+
+namespace {
+    struct Interval {
+        std::vector<MathLib::bigint> minvalue, maxvalue;
+        std::vector<const ValueFlow::Value*> minRef, maxRef;
+
+        void setMinValue(MathLib::bigint x, const ValueFlow::Value* ref = nullptr)
+        {
+            minvalue = {x};
+            if (ref)
+                minRef = {ref};
+        }
+
+        void setMaxValue(MathLib::bigint x, const ValueFlow::Value* ref = nullptr)
+        {
+            maxvalue = {x};
+            if (ref)
+                maxRef = {ref};
+        }
+
+        bool isLessThan(MathLib::bigint x, std::vector<const ValueFlow::Value*>* ref = nullptr) const
+        {
+            if (!this->maxvalue.empty() && this->maxvalue.front() < x) {
+                if (ref)
+                    *ref = maxRef;
+                return true;
+            }
+            return false;
+        }
+
+        bool isGreaterThan(MathLib::bigint x, std::vector<const ValueFlow::Value*>* ref = nullptr) const
+        {
+            if (!this->minvalue.empty() && this->minvalue.front() > x) {
+                if (ref)
+                    *ref = minRef;
+                return true;
+            }
+            return false;
+        }
+
+        bool isScalar() const {
+            return minvalue.size() == 1 && minvalue == maxvalue;
+        }
+
+        bool empty() const {
+            return minvalue.empty() && maxvalue.empty();
+        }
+
+        bool isScalarOrEmpty() const {
+            return empty() || isScalar();
+        }
+
+        MathLib::bigint getScalar() const
+        {
+            assert(isScalar());
+            return minvalue.front();
+        }
+
+        std::vector<const ValueFlow::Value*> getScalarRef() const
+        {
+            assert(isScalar());
+            if (minRef != maxRef)
+                return merge(minRef, maxRef);
+            return minRef;
+        }
+
+        static Interval fromInt(MathLib::bigint x, const ValueFlow::Value* ref = nullptr)
+        {
+            Interval result;
+            result.setMinValue(x, ref);
+            result.setMaxValue(x, ref);
+            return result;
+        }
+
+        template<class Predicate>
+        static Interval fromValues(const std::list<ValueFlow::Value>& values, Predicate predicate)
+        {
+            Interval result;
+            const ValueFlow::Value* minValue = getCompareValue(values, predicate, std::less<MathLib::bigint>{});
+            if (minValue) {
+                if (minValue->isImpossible() && minValue->bound == ValueFlow::Value::Bound::Upper)
+                    result.setMinValue(minValue->intvalue + 1, minValue);
+                if (minValue->isPossible() && minValue->bound == ValueFlow::Value::Bound::Lower)
+                    result.setMinValue(minValue->intvalue, minValue);
+                if (!minValue->isImpossible() && (minValue->bound == ValueFlow::Value::Bound::Point || minValue->isKnown()) &&
+                    std::count_if(values.begin(), values.end(), predicate) == 1)
+                    return Interval::fromInt(minValue->intvalue, minValue);
+            }
+            const ValueFlow::Value* maxValue = getCompareValue(values, predicate, std::greater<MathLib::bigint>{});
+            if (maxValue) {
+                if (maxValue->isImpossible() && maxValue->bound == ValueFlow::Value::Bound::Lower)
+                    result.setMaxValue(maxValue->intvalue - 1, maxValue);
+                if (maxValue->isPossible() && maxValue->bound == ValueFlow::Value::Bound::Upper)
+                    result.setMaxValue(maxValue->intvalue, maxValue);
+                assert(!maxValue->isKnown());
+            }
+            return result;
+        }
+
+        static Interval fromValues(const std::list<ValueFlow::Value>& values)
+        {
+            return Interval::fromValues(values, [](const ValueFlow::Value&) {
+                return true;
+            });
+        }
+
+        template<class F>
+        static std::vector<MathLib::bigint> apply(const std::vector<MathLib::bigint>& x,
+                                                  const std::vector<MathLib::bigint>& y,
+                                                  F f)
+        {
+            if (x.empty())
+                return {};
+            if (y.empty())
+                return {};
+            return {f(x.front(), y.front())};
+        }
+
+        static std::vector<const ValueFlow::Value*> merge(std::vector<const ValueFlow::Value*> x,
+                                                          const std::vector<const ValueFlow::Value*>& y)
+        {
+            x.insert(x.end(), y.cbegin(), y.cend());
+            return x;
+        }
+
+        friend Interval operator-(const Interval& lhs, const Interval& rhs)
+        {
+            Interval result;
+            result.minvalue = Interval::apply(lhs.minvalue, rhs.maxvalue, std::minus<MathLib::bigint>{});
+            result.maxvalue = Interval::apply(lhs.maxvalue, rhs.minvalue, std::minus<MathLib::bigint>{});
+            if (!result.minvalue.empty())
+                result.minRef = merge(lhs.minRef, rhs.maxRef);
+            if (!result.maxvalue.empty())
+                result.maxRef = merge(lhs.maxRef, rhs.minRef);
+            return result;
+        }
+
+        static std::vector<int> equal(const Interval& lhs,
+                                      const Interval& rhs,
+                                      std::vector<const ValueFlow::Value*>* ref = nullptr)
+        {
+            if (!lhs.isScalar())
+                return {};
+            if (!rhs.isScalar())
+                return {};
+            if (ref)
+                *ref = merge(lhs.getScalarRef(), rhs.getScalarRef());
+            return {lhs.minvalue == rhs.minvalue};
+        }
+
+        static std::vector<int> compare(const Interval& lhs,
+                                        const Interval& rhs,
+                                        std::vector<const ValueFlow::Value*>* ref = nullptr)
+        {
+            Interval diff = lhs - rhs;
+            if (diff.isGreaterThan(0, ref))
+                return {1};
+            if (diff.isLessThan(0, ref))
+                return {-1};
+            std::vector<int> eq = Interval::equal(lhs, rhs, ref);
+            if (!eq.empty()) {
+                if (eq.front() == 0)
+                    return {1, -1};
+                return {0};
+            }
+            if (diff.isGreaterThan(-1, ref))
+                return {0, 1};
+            if (diff.isLessThan(1, ref))
+                return {0, -1};
+            return {};
+        }
+
+        static std::vector<bool> compare(const std::string& op,
+                                         const Interval& lhs,
+                                         const Interval& rhs,
+                                         std::vector<const ValueFlow::Value*>* ref = nullptr)
+        {
+            std::vector<int> r = compare(lhs, rhs, ref);
+            if (r.empty())
+                return {};
+            bool b = calculate(op, r.front(), 0);
+            if (std::all_of(r.cbegin() + 1, r.cend(), [&](int i) {
+                return b == calculate(op, i, 0);
+            }))
+                return {b};
+            return {};
+        }
+    };
+}
+
+static void addToErrorPath(ValueFlow::Value& value, const std::vector<const ValueFlow::Value*>& refs)
+{
+    std::unordered_set<const Token*> locations;
+    for (const ValueFlow::Value* ref : refs) {
+        if (ref->condition && !value.condition)
+            value.condition = ref->condition;
+        std::copy_if(ref->errorPath.cbegin(),
+                     ref->errorPath.cend(),
+                     std::back_inserter(value.errorPath),
+                     [&](const ErrorPathItem& e) {
+            return locations.insert(e.first).second;
+        });
+        std::copy_if(ref->debugPath.cbegin(),
+                     ref->debugPath.cend(),
+                     std::back_inserter(value.debugPath),
+                     [&](const ErrorPathItem& e) {
+            return locations.insert(e.first).second;
+        });
+    }
+}
+
+static void setValueKind(ValueFlow::Value& value, const std::vector<const ValueFlow::Value*>& refs)
+{
+    bool isPossible = false;
+    bool isInconclusive = false;
+    for (const ValueFlow::Value* ref : refs) {
+        if (ref->isPossible())
+            isPossible = true;
+        if (ref->isInconclusive())
+            isInconclusive = true;
+    }
+    if (isInconclusive)
+        value.setInconclusive();
+    else if (isPossible)
+        value.setPossible();
+    else
+        value.setKnown();
+}
+
+static bool inferNotEqual(const std::list<ValueFlow::Value>& values, MathLib::bigint x)
+{
+    return std::any_of(values.cbegin(), values.cend(), [&](const ValueFlow::Value& value) {
+        return value.isImpossible() && value.intvalue == x;
+    });
+}
+
+std::vector<ValueFlow::Value> infer(const ValuePtr<InferModel>& model,
+                                    const std::string& op,
+                                    std::list<ValueFlow::Value> lhsValues,
+                                    std::list<ValueFlow::Value> rhsValues)
+{
+    std::vector<ValueFlow::Value> result;
+    auto notMatch = [&](const ValueFlow::Value& value) {
+        return !model->match(value);
+    };
+    lhsValues.remove_if(notMatch);
+    if (lhsValues.empty())
+        return result;
+    rhsValues.remove_if(notMatch);
+    if (rhsValues.empty())
+        return result;
+
+    Interval lhs = Interval::fromValues(lhsValues);
+    Interval rhs = Interval::fromValues(rhsValues);
+
+    if (op == "-") {
+        Interval diff = lhs - rhs;
+        if (diff.isScalar()) {
+            std::vector<const ValueFlow::Value*> refs = diff.getScalarRef();
+            ValueFlow::Value value(diff.getScalar());
+            addToErrorPath(value, refs);
+            setValueKind(value, refs);
+            result.push_back(std::move(value));
+        } else {
+            if (!diff.minvalue.empty()) {
+                ValueFlow::Value value(diff.minvalue.front() - 1);
+                value.setImpossible();
+                value.bound = ValueFlow::Value::Bound::Upper;
+                addToErrorPath(value, diff.minRef);
+                result.push_back(std::move(value));
+            }
+            if (!diff.maxvalue.empty()) {
+                ValueFlow::Value value(diff.maxvalue.front() + 1);
+                value.setImpossible();
+                value.bound = ValueFlow::Value::Bound::Lower;
+                addToErrorPath(value, diff.maxRef);
+                result.push_back(std::move(value));
+            }
+        }
+    } else if ((op == "!=" || op == "==") && lhs.isScalarOrEmpty() && rhs.isScalarOrEmpty()) {
+        if (lhs.isScalar() && rhs.isScalar()) {
+            std::vector<const ValueFlow::Value*> refs = Interval::merge(lhs.getScalarRef(), rhs.getScalarRef());
+            ValueFlow::Value value(calculate(op, lhs.getScalar(), rhs.getScalar()));
+            addToErrorPath(value, refs);
+            setValueKind(value, refs);
+            result.push_back(std::move(value));
+        } else {
+            std::vector<const ValueFlow::Value*> refs;
+            if (lhs.isScalar() && inferNotEqual(rhsValues, lhs.getScalar()))
+                refs = lhs.getScalarRef();
+            else if (rhs.isScalar() && inferNotEqual(lhsValues, rhs.getScalar()))
+                refs = rhs.getScalarRef();
+            if (!refs.empty()) {
+                ValueFlow::Value value(op == "!=");
+                addToErrorPath(value, refs);
+                setValueKind(value, refs);
+                result.push_back(std::move(value));
+            }
+        }
+    } else {
+        std::vector<const ValueFlow::Value*> refs;
+        std::vector<bool> r = Interval::compare(op, lhs, rhs, &refs);
+        if (!r.empty()) {
+            ValueFlow::Value value(static_cast<int>(r.front()));
+            addToErrorPath(value, refs);
+            setValueKind(value, refs);
+            result.push_back(std::move(value));
+        }
+    }
+
+    return result;
+}
+
+std::vector<ValueFlow::Value> infer(const ValuePtr<InferModel>& model,
+                                    const std::string& op,
+                                    MathLib::bigint lhs,
+                                    std::list<ValueFlow::Value> rhsValues)
+{
+    return infer(model, op, {model->yield(lhs)}, std::move(rhsValues));
+}
+
+std::vector<ValueFlow::Value> infer(const ValuePtr<InferModel>& model,
+                                    const std::string& op,
+                                    std::list<ValueFlow::Value> lhsValues,
+                                    MathLib::bigint rhs)
+{
+    return infer(model, op, std::move(lhsValues), {model->yield(rhs)});
+}
+
+std::vector<MathLib::bigint> getMinValue(const ValuePtr<InferModel>& model, const std::list<ValueFlow::Value>& values)
+{
+    return Interval::fromValues(values, [&](const ValueFlow::Value& v) {
+        return model->match(v);
+    }).minvalue;
+}
+std::vector<MathLib::bigint> getMaxValue(const ValuePtr<InferModel>& model, const std::list<ValueFlow::Value>& values)
+{
+    return Interval::fromValues(values, [&](const ValueFlow::Value& v) {
+        return model->match(v);
+    }).maxvalue;
+}
+
+namespace {
+    struct IntegralInferModel : InferModel {
+        bool match(const ValueFlow::Value& value) const override {
+            return value.isIntValue();
+        }
+        ValueFlow::Value yield(MathLib::bigint value) const override
+        {
+            ValueFlow::Value result(value);
+            result.valueType = ValueFlow::Value::ValueType::INT;
+            result.setKnown();
+            return result;
+        }
+    };
+}
+
+ValuePtr<InferModel> makeIntegralInferModel()
+{
+    return IntegralInferModel{};
+}
+
+ValueFlow::Value inferCondition(const std::string& op, const Token* varTok, MathLib::bigint val)
+{
+    if (!varTok)
+        return ValueFlow::Value{};
+    if (varTok->hasKnownIntValue())
+        return ValueFlow::Value{};
+    std::vector<ValueFlow::Value> r = infer(makeIntegralInferModel(), op, varTok->values(), val);
+    if (r.size() == 1 && r.front().isKnown())
+        return r.front();
+    return ValueFlow::Value{};
+}
diff --git a/lib/infer.h b/lib/infer.h
new file mode 100644
index 00000000000..8d66d7da016
--- /dev/null
+++ b/lib/infer.h
@@ -0,0 +1,68 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef inferH
+#define inferH
+
+#include "config.h"
+#include "mathlib.h"
+
+#include <list>
+#include <string>
+#include <vector>
+
+class Token;
+template<class T> class ValuePtr;
+
+namespace ValueFlow
+{
+    class Value;
+}
+
+struct InferModel {
+    virtual bool match(const ValueFlow::Value& value) const = 0;
+    virtual ValueFlow::Value yield(MathLib::bigint value) const = 0;
+    virtual ~InferModel() = default;
+    InferModel(const InferModel&) = default;
+protected:
+    InferModel() = default;
+};
+
+std::vector<ValueFlow::Value> infer(const ValuePtr<InferModel>& model,
+                                    const std::string& op,
+                                    std::list<ValueFlow::Value> lhsValues,
+                                    std::list<ValueFlow::Value> rhsValues);
+
+std::vector<ValueFlow::Value> infer(const ValuePtr<InferModel>& model,
+                                    const std::string& op,
+                                    MathLib::bigint lhs,
+                                    std::list<ValueFlow::Value> rhsValues);
+
+std::vector<ValueFlow::Value> infer(const ValuePtr<InferModel>& model,
+                                    const std::string& op,
+                                    std::list<ValueFlow::Value> lhsValues,
+                                    MathLib::bigint rhs);
+
+CPPCHECKLIB std::vector<MathLib::bigint> getMinValue(const ValuePtr<InferModel>& model, const std::list<ValueFlow::Value>& values);
+std::vector<MathLib::bigint> getMaxValue(const ValuePtr<InferModel>& model, const std::list<ValueFlow::Value>& values);
+
+ValuePtr<InferModel> makeIntegralInferModel();
+
+ValueFlow::Value inferCondition(const std::string& op, const Token* varTok, MathLib::bigint val);
+
+#endif
diff --git a/lib/json.h b/lib/json.h
new file mode 100644
index 00000000000..7f7107f7864
--- /dev/null
+++ b/lib/json.h
@@ -0,0 +1,45 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef jsonH
+#define jsonH
+
+#include "config.h"
+
+SUPPRESS_WARNING_PUSH("-Wfloat-equal")
+SUPPRESS_WARNING_GCC_PUSH("-Wuseless-cast")
+SUPPRESS_WARNING_CLANG_PUSH("-Wtautological-type-limit-compare")
+SUPPRESS_WARNING_CLANG_PUSH("-Wextra-semi-stmt")
+SUPPRESS_WARNING_CLANG_PUSH("-Wzero-as-null-pointer-constant")
+SUPPRESS_WARNING_CLANG_PUSH("-Wformat")
+SUPPRESS_WARNING_CLANG_PUSH("-Wfloat-conversion")
+SUPPRESS_WARNING_CLANG_PUSH("-Wimplicit-float-conversion")
+
+#define PICOJSON_USE_INT64
+#include <picojson.h> // IWYU pragma: export
+
+SUPPRESS_WARNING_CLANG_POP
+SUPPRESS_WARNING_CLANG_POP
+SUPPRESS_WARNING_CLANG_POP
+SUPPRESS_WARNING_CLANG_POP
+SUPPRESS_WARNING_CLANG_POP
+SUPPRESS_WARNING_CLANG_POP
+SUPPRESS_WARNING_GCC_POP
+SUPPRESS_WARNING_POP
+
+#endif // jsonH
diff --git a/lib/keywords.cpp b/lib/keywords.cpp
new file mode 100644
index 00000000000..678456d8c36
--- /dev/null
+++ b/lib/keywords.cpp
@@ -0,0 +1,255 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "keywords.h"
+
+#include "utils.h"
+
+// see https://en.cppreference.com/w/c/keyword
+
+#define C90_KEYWORDS \
+    "auto", "break", "case", "char", "const", "continue", "default", \
+    "do", "double", "else", "enum", "extern", "float", "for", "goto", "if", "int", "long", \
+    "register", "return", "short", "signed", "sizeof", "static", "struct", "switch", "typedef", \
+    "union", "unsigned", "void", "volatile", "while"
+
+#define C99_KEYWORDS \
+    "inline", "restrict", "_Bool", "_Complex", "_Imaginary"
+
+#define C11_KEYWORDS \
+    "_Alignas", "_Alignof", "_Atomic", "_Generic", "_Noreturn", "_Static_assert", "_Thread_local"
+
+#define C23_KEYWORDS \
+    "alignas", "alignof", "bool", "constexpr", "false", "nullptr", "static_assert", "thread_local", "true", "typeof", "typeof_unqual", \
+    "_BitInt", "_Decimal128", "_Decimal32", "_Decimal64"
+
+static const std::unordered_set<std::string> c89_keywords_all = {
+    C90_KEYWORDS
+};
+
+static const std::unordered_set<std::string> c89_keywords = {
+    C90_KEYWORDS
+};
+
+static const std::unordered_set<std::string> c99_keywords_all = {
+    C90_KEYWORDS, C99_KEYWORDS
+};
+
+static const std::unordered_set<std::string> c99_keywords = {
+    C99_KEYWORDS
+};
+
+static const std::unordered_set<std::string> c11_keywords_all = {
+    C90_KEYWORDS, C99_KEYWORDS, C11_KEYWORDS
+};
+
+static const std::unordered_set<std::string> c11_keywords = {
+    C11_KEYWORDS
+};
+
+static const std::unordered_set<std::string> c17_keywords_all = {
+    C90_KEYWORDS, C99_KEYWORDS, C11_KEYWORDS
+};
+
+static const std::unordered_set<std::string> c17_keywords = {
+};
+
+static const std::unordered_set<std::string> c23_keywords_all = {
+    C90_KEYWORDS, C99_KEYWORDS, C11_KEYWORDS, C23_KEYWORDS
+};
+
+static const std::unordered_set<std::string> c23_keywords = {
+    C23_KEYWORDS
+};
+
+static const std::unordered_set<std::string> c2y_keywords_all = {
+    C90_KEYWORDS, C99_KEYWORDS, C11_KEYWORDS, C23_KEYWORDS
+};
+
+static const std::unordered_set<std::string> c2y_keywords = {
+};
+
+// see https://en.cppreference.com/w/cpp/keyword
+
+#define CPP03_KEYWORDS \
+    "and", "and_eq", "asm", "auto", "bitand", "bitor", "bool", "break", "case", "catch", "char", \
+    "class", "compl", "const", "const_cast", "continue", "default", \
+    "delete", "do", "double", "dynamic_cast", "else", "enum", "explicit", "export", "extern", "false", \
+    "float", "for", "friend", "goto", "if", "inline", "int", "long", \
+    "mutable", "namespace", "new", "not", "not_eq",  "operator", \
+    "or", "or_eq", "private", "protected", "public", "register", "reinterpret_cast", \
+    "return", "short", "signed", "sizeof", "static", \
+    "static_cast", "struct", "switch", "template", "this", "throw", \
+    "true", "try", "typedef", "typeid", "typename", "union", "unsigned", "using", \
+    "virtual", "void", "volatile", "wchar_t", "while", "xor", "xor_eq"
+
+#define CPP11_KEYWORDS \
+    "alignas", "alignof", "char16_t", "char32_t", "constexpr", "decltype", \
+    "noexcept", "nullptr", "static_assert", "thread_local"
+
+#define CPP20_KEYWORDS \
+    "char8_t", "concept", "consteval", "constinit", "co_await", \
+    "co_return", "co_yield", "requires"
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-macros"
+#endif
+
+#define CPP_TMTS_KEYWORDS \
+    "atomic_cancel", "atomic_commit", "atomic_noexcept", "synchronized"
+
+#define CPP_REFL_TS_KEYWORDS \
+    "reflexpr"
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+static const std::unordered_set<std::string> cpp03_keywords_all = {
+    CPP03_KEYWORDS
+};
+
+static const std::unordered_set<std::string> cpp03_keywords = {
+    CPP03_KEYWORDS
+};
+
+static const std::unordered_set<std::string> cpp11_keywords_all = {
+    CPP03_KEYWORDS, CPP11_KEYWORDS
+};
+
+static const std::unordered_set<std::string> cpp11_keywords = {
+    CPP11_KEYWORDS
+};
+
+static const std::unordered_set<std::string> cpp14_keywords_all = {
+    CPP03_KEYWORDS, CPP11_KEYWORDS
+};
+
+static const std::unordered_set<std::string> cpp14_keywords = {
+};
+
+static const std::unordered_set<std::string> cpp17_keywords_all = {
+    CPP03_KEYWORDS, CPP11_KEYWORDS
+};
+
+static const std::unordered_set<std::string> cpp17_keywords = {
+};
+
+static const std::unordered_set<std::string> cpp20_keywords_all = {
+    CPP03_KEYWORDS, CPP11_KEYWORDS, CPP20_KEYWORDS
+};
+
+static const std::unordered_set<std::string> cpp20_keywords = {
+    CPP20_KEYWORDS
+};
+
+static const std::unordered_set<std::string> cpp23_keywords = {
+};
+
+static const std::unordered_set<std::string> cpp23_keywords_all = {
+    CPP03_KEYWORDS, CPP11_KEYWORDS, CPP20_KEYWORDS
+};
+
+static const std::unordered_set<std::string> cpp26_keywords = {
+};
+
+static const std::unordered_set<std::string> cpp26_keywords_all = {
+    CPP03_KEYWORDS, CPP11_KEYWORDS, CPP20_KEYWORDS
+};
+
+const std::unordered_set<std::string>& Keywords::getAll(Standards::cstd_t cStd)
+{
+    switch (cStd) {
+    case Standards::cstd_t::C89:
+        return c89_keywords_all;
+    case Standards::cstd_t::C99:
+        return c99_keywords_all;
+    case Standards::cstd_t::C11:
+        return c11_keywords_all;
+    case Standards::cstd_t::C17:
+        return c17_keywords_all;
+    case Standards::cstd_t::C23:
+        return c23_keywords_all;
+    case Standards::cstd_t::C2Y:
+        return c2y_keywords_all;
+    }
+    cppcheck::unreachable();
+}
+
+const std::unordered_set<std::string>& Keywords::getAll(Standards::cppstd_t cppStd) {
+    switch (cppStd) {
+    case Standards::cppstd_t::CPP03:
+        return cpp03_keywords_all;
+    case Standards::cppstd_t::CPP11:
+        return cpp11_keywords_all;
+    case Standards::cppstd_t::CPP14:
+        return cpp14_keywords_all;
+    case Standards::cppstd_t::CPP17:
+        return cpp17_keywords_all;
+    case Standards::cppstd_t::CPP20:
+        return cpp20_keywords_all;
+    case Standards::cppstd_t::CPP23:
+        return cpp23_keywords_all;
+    case Standards::cppstd_t::CPP26:
+        return cpp26_keywords_all;
+    }
+    cppcheck::unreachable();
+}
+
+// cppcheck-suppress unusedFunction
+const std::unordered_set<std::string>& Keywords::getOnly(Standards::cstd_t cStd)
+{
+    switch (cStd) {
+    case Standards::cstd_t::C89:
+        return c89_keywords;
+    case Standards::cstd_t::C99:
+        return c99_keywords;
+    case Standards::cstd_t::C11:
+        return c11_keywords;
+    case Standards::cstd_t::C17:
+        return c17_keywords;
+    case Standards::cstd_t::C23:
+        return c23_keywords;
+    case Standards::cstd_t::C2Y:
+        return c2y_keywords;
+    }
+    cppcheck::unreachable();
+}
+
+const std::unordered_set<std::string>& Keywords::getOnly(Standards::cppstd_t cppStd)
+{
+    switch (cppStd) {
+    case Standards::cppstd_t::CPP03:
+        return cpp03_keywords;
+    case Standards::cppstd_t::CPP11:
+        return cpp11_keywords;
+    case Standards::cppstd_t::CPP14:
+        return cpp14_keywords;
+    case Standards::cppstd_t::CPP17:
+        return cpp17_keywords;
+    case Standards::cppstd_t::CPP20:
+        return cpp20_keywords;
+    case Standards::cppstd_t::CPP23:
+        return cpp23_keywords;
+    case Standards::cppstd_t::CPP26:
+        return cpp26_keywords;
+    }
+    cppcheck::unreachable();
+}
+
diff --git a/lib/keywords.h b/lib/keywords.h
new file mode 100644
index 00000000000..1460a5a776a
--- /dev/null
+++ b/lib/keywords.h
@@ -0,0 +1,37 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef keywordsH
+#define keywordsH
+
+#include "standards.h"
+
+#include <string>
+#include <unordered_set>
+
+class Keywords
+{
+public:
+    static const std::unordered_set<std::string>& getAll(Standards::cstd_t cStd);
+    static const std::unordered_set<std::string>& getAll(Standards::cppstd_t cppStd);
+
+    static const std::unordered_set<std::string>& getOnly(Standards::cstd_t cStd);
+    static const std::unordered_set<std::string>& getOnly(Standards::cppstd_t cppStd);
+};
+
+#endif
diff --git a/lib/lib.pri b/lib/lib.pri
deleted file mode 100644
index 5c61e285cfa..00000000000
--- a/lib/lib.pri
+++ /dev/null
@@ -1,102 +0,0 @@
-# no manual edits - this file is autogenerated by dmake
-
-include($$PWD/pcrerules.pri)
-include($$PWD/../externals/externals.pri)
-INCLUDEPATH += $$PWD
-HEADERS += $${PWD}/analyzerinfo.h \
-           $${PWD}/astutils.h \
-           $${PWD}/check.h \
-           $${PWD}/check64bit.h \
-           $${PWD}/checkassert.h \
-           $${PWD}/checkautovariables.h \
-           $${PWD}/checkbool.h \
-           $${PWD}/checkboost.h \
-           $${PWD}/checkbufferoverrun.h \
-           $${PWD}/checkclass.h \
-           $${PWD}/checkcondition.h \
-           $${PWD}/checkexceptionsafety.h \
-           $${PWD}/checkfunctions.h \
-           $${PWD}/checkinternal.h \
-           $${PWD}/checkio.h \
-           $${PWD}/checkleakautovar.h \
-           $${PWD}/checkmemoryleak.h \
-           $${PWD}/checknullpointer.h \
-           $${PWD}/checkother.h \
-           $${PWD}/checkpostfixoperator.h \
-           $${PWD}/checksizeof.h \
-           $${PWD}/checkstl.h \
-           $${PWD}/checkstring.h \
-           $${PWD}/checktype.h \
-           $${PWD}/checkuninitvar.h \
-           $${PWD}/checkunusedfunctions.h \
-           $${PWD}/checkunusedvar.h \
-           $${PWD}/checkvaarg.h \
-           $${PWD}/cppcheck.h \
-           $${PWD}/ctu.h \
-           $${PWD}/errorlogger.h \
-           $${PWD}/exprengine.h \
-           $${PWD}/importproject.h \
-           $${PWD}/library.h \
-           $${PWD}/mathlib.h \
-           $${PWD}/path.h \
-           $${PWD}/pathmatch.h \
-           $${PWD}/platform.h \
-           $${PWD}/preprocessor.h \
-           $${PWD}/settings.h \
-           $${PWD}/suppressions.h \
-           $${PWD}/symboldatabase.h \
-           $${PWD}/templatesimplifier.h \
-           $${PWD}/timer.h \
-           $${PWD}/token.h \
-           $${PWD}/tokenize.h \
-           $${PWD}/tokenlist.h \
-           $${PWD}/valueflow.h
-
-SOURCES += $${PWD}/analyzerinfo.cpp \
-           $${PWD}/astutils.cpp \
-           $${PWD}/check.cpp \
-           $${PWD}/check64bit.cpp \
-           $${PWD}/checkassert.cpp \
-           $${PWD}/checkautovariables.cpp \
-           $${PWD}/checkbool.cpp \
-           $${PWD}/checkboost.cpp \
-           $${PWD}/checkbufferoverrun.cpp \
-           $${PWD}/checkclass.cpp \
-           $${PWD}/checkcondition.cpp \
-           $${PWD}/checkexceptionsafety.cpp \
-           $${PWD}/checkfunctions.cpp \
-           $${PWD}/checkinternal.cpp \
-           $${PWD}/checkio.cpp \
-           $${PWD}/checkleakautovar.cpp \
-           $${PWD}/checkmemoryleak.cpp \
-           $${PWD}/checknullpointer.cpp \
-           $${PWD}/checkother.cpp \
-           $${PWD}/checkpostfixoperator.cpp \
-           $${PWD}/checksizeof.cpp \
-           $${PWD}/checkstl.cpp \
-           $${PWD}/checkstring.cpp \
-           $${PWD}/checktype.cpp \
-           $${PWD}/checkuninitvar.cpp \
-           $${PWD}/checkunusedfunctions.cpp \
-           $${PWD}/checkunusedvar.cpp \
-           $${PWD}/checkvaarg.cpp \
-           $${PWD}/cppcheck.cpp \
-           $${PWD}/ctu.cpp \
-           $${PWD}/errorlogger.cpp \
-           $${PWD}/exprengine.cpp \
-           $${PWD}/importproject.cpp \
-           $${PWD}/library.cpp \
-           $${PWD}/mathlib.cpp \
-           $${PWD}/path.cpp \
-           $${PWD}/pathmatch.cpp \
-           $${PWD}/platform.cpp \
-           $${PWD}/preprocessor.cpp \
-           $${PWD}/settings.cpp \
-           $${PWD}/suppressions.cpp \
-           $${PWD}/symboldatabase.cpp \
-           $${PWD}/templatesimplifier.cpp \
-           $${PWD}/timer.cpp \
-           $${PWD}/token.cpp \
-           $${PWD}/tokenize.cpp \
-           $${PWD}/tokenlist.cpp \
-           $${PWD}/valueflow.cpp
diff --git a/lib/library.cpp b/lib/library.cpp
index 0f2e0b37c7e..efba862eb15 100644
--- a/lib/library.cpp
+++ b/lib/library.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,18 +19,150 @@
 #include "library.h"
 
 #include "astutils.h"
+#include "errortypes.h"
 #include "mathlib.h"
 #include "path.h"
 #include "symboldatabase.h"
-#include "tinyxml2.h"
 #include "token.h"
 #include "tokenlist.h"
 #include "utils.h"
+#include "vfvalue.h"
 
+#include <algorithm>
 #include <cctype>
-#include <cstdlib>
+#include <climits>
 #include <cstring>
+#include <iostream>
 #include <list>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <unordered_set>
+#include <utility>
+
+#include "xml.h"
+
+struct Library::LibraryData
+{
+    struct Platform {
+        const PlatformType *platform_type(const std::string &name) const {
+            const auto it = mPlatformTypes.find(name);
+            return (it != mPlatformTypes.end()) ? &(it->second) : nullptr;
+        }
+        std::map<std::string, PlatformType> mPlatformTypes;
+    };
+
+    class ExportedFunctions {
+    public:
+        void addPrefix(std::string prefix) {
+            mPrefixes.insert(std::move(prefix));
+        }
+        void addSuffix(std::string suffix) {
+            mSuffixes.insert(std::move(suffix));
+        }
+        bool isPrefix(const std::string& prefix) const {
+            return (mPrefixes.find(prefix) != mPrefixes.end());
+        }
+        bool isSuffix(const std::string& suffix) const {
+            return (mSuffixes.find(suffix) != mSuffixes.end());
+        }
+
+    private:
+        std::set<std::string> mPrefixes;
+        std::set<std::string> mSuffixes;
+    };
+
+    class CodeBlock {
+    public:
+        CodeBlock() = default;
+
+        void setStart(const char* s) {
+            mStart = s;
+        }
+        void setEnd(const char* e) {
+            mEnd = e;
+        }
+        void setOffset(const int o) {
+            mOffset = o;
+        }
+        void addBlock(const char* blockName) {
+            mBlocks.insert(blockName);
+        }
+        const std::string& start() const {
+            return mStart;
+        }
+        const std::string& end() const {
+            return mEnd;
+        }
+        int offset() const {
+            return mOffset;
+        }
+        bool isBlock(const std::string& blockName) const {
+            return mBlocks.find(blockName) != mBlocks.end();
+        }
+
+    private:
+        std::string mStart;
+        std::string mEnd;
+        int mOffset{};
+        std::set<std::string> mBlocks;
+    };
+
+    enum class FalseTrueMaybe : std::uint8_t { False, True, Maybe };
+
+    std::map<std::string, WarnInfo> mFunctionwarn;
+    std::set<std::string> mDefines;
+
+    std::unordered_map<std::string, Container> mContainers;
+    std::unordered_map<std::string, Function> mFunctions;
+    std::unordered_map<std::string, SmartPointer> mSmartPointers;
+
+    int mAllocId{};
+    std::set<std::string> mFiles;
+    std::map<std::string, AllocFunc> mAlloc; // allocation functions
+    std::map<std::string, AllocFunc> mDealloc; // deallocation functions
+    std::map<std::string, AllocFunc> mRealloc; // reallocation functions
+    std::unordered_map<std::string, FalseTrueMaybe> mNoReturn; // is function noreturn?
+    std::unordered_map<std::string, std::string> mReturnValue;
+    std::unordered_map<std::string, std::string> mReturnValueType;
+    std::unordered_map<std::string, int> mReturnValueContainer;
+    std::map<std::string, std::vector<MathLib::bigint>> mUnknownReturnValues;
+    std::map<std::string, bool> mReportErrors;
+    std::map<std::string, bool> mProcessAfterCode;
+    std::set<std::string> mMarkupExtensions; // file extensions of markup files
+    std::map<std::string, std::set<std::string>> mKeywords;  // keywords for code in the library
+    std::unordered_map<std::string, CodeBlock> mExecutableBlocks; // keywords for blocks of executable code
+    std::map<std::string, ExportedFunctions> mExporters; // keywords that export variables/functions to libraries (meta-code/macros)
+    std::map<std::string, std::set<std::string>> mImporters;  // keywords that import variables/functions
+    std::map<std::string, int> mReflection; // invocation of reflection
+    std::unordered_map<std::string, struct PodType> mPodTypes; // pod types
+    std::map<std::string, PlatformType> mPlatformTypes; // platform independent typedefs
+    std::map<std::string, Platform> mPlatforms; // platform dependent typedefs
+    std::map<std::pair<std::string,std::string>, TypeCheck> mTypeChecks;
+    std::unordered_map<std::string, NonOverlappingData> mNonOverlappingData;
+    std::unordered_set<std::string> mEntrypoints;
+};
+
+const std::string Library::mEmptyString;
+
+Library::Library()
+    : mData(new LibraryData())
+{}
+
+Library::~Library() = default;
+
+Library::Library(const Library& other)
+    : mData(new LibraryData(*other.mData))
+{}
+
+Library& Library::operator=(const Library& other) &
+{
+    if (this == &other)
+        return *this;
+
+    mData.reset(new LibraryData(*other.mData));
+    return *this;
+}
 
 static std::vector<std::string> getnames(const char *names)
 {
@@ -45,8 +177,8 @@ static std::vector<std::string> getnames(const char *names)
 
 static void gettokenlistfromvalid(const std::string& valid, TokenList& tokenList)
 {
-    std::istringstream istr(valid + ',');
-    tokenList.createTokens(istr);
+    const std::string str(valid + ',');
+    tokenList.createTokensFromBuffer(str.data(), str.size()); // TODO: check result?
     for (Token *tok = tokenList.front(); tok; tok = tok->next()) {
         if (Token::Match(tok,"- %num%")) {
             tok->str("-" + tok->strAt(1));
@@ -55,90 +187,186 @@ static void gettokenlistfromvalid(const std::string& valid, TokenList& tokenList
     }
 }
 
-Library::Library() : mAllocId(0)
-{
-}
-
-Library::Error Library::load(const char exename[], const char path[])
+Library::Error Library::load(const char exename[], const char path[], bool debug)
 {
     if (std::strchr(path,',') != nullptr) {
-        std::string p(path);
-        for (;;) {
-            const std::string::size_type pos = p.find(',');
-            if (pos == std::string::npos)
-                break;
-            const Error &e = load(exename, p.substr(0,pos).c_str());
-            if (e.errorcode != OK)
-                return e;
-            p = p.substr(pos+1);
-        }
-        if (!p.empty())
-            return load(exename, p.c_str());
-        return Error();
+        throw std::runtime_error("handling of multiple libraries not supported");
     }
 
+    const bool is_abs_path = Path::isAbsolute(path);
+
+    std::string fullfilename(path);
+
+    // TODO: what if the extension is not .cfg?
+    // only append extension when we provide the library name and not a path - TODO: handle relative paths?
+    if (!is_abs_path && Path::getFilenameExtension(fullfilename).empty())
+        fullfilename += ".cfg";
+
     std::string absolute_path;
     // open file..
     tinyxml2::XMLDocument doc;
-    tinyxml2::XMLError error = doc.LoadFile(path);
-    if (error == tinyxml2::XML_ERROR_FILE_READ_ERROR && Path::getFilenameExtension(path).empty())
-        // Reading file failed, try again...
-        error = tinyxml2::XML_ERROR_FILE_NOT_FOUND;
+    if (debug)
+        std::cout << "looking for library '" + fullfilename + "'" << std::endl;
+    tinyxml2::XMLError error = xml_LoadFile(doc, fullfilename.c_str());
     if (error == tinyxml2::XML_ERROR_FILE_NOT_FOUND) {
-        // failed to open file.. is there no extension?
-        std::string fullfilename(path);
-        if (Path::getFilenameExtension(fullfilename).empty()) {
-            fullfilename += ".cfg";
-            error = doc.LoadFile(fullfilename.c_str());
-            if (error != tinyxml2::XML_ERROR_FILE_NOT_FOUND)
-                absolute_path = Path::getAbsoluteFilePath(fullfilename);
-        }
-
-        std::list<std::string> cfgfolders;
-#ifdef FILESDIR
-        cfgfolders.emplace_back(FILESDIR "/cfg");
-#endif
-        if (exename) {
-            const std::string exepath(Path::fromNativeSeparators(Path::getPathFromFilename(exename)));
-            cfgfolders.push_back(exepath + "cfg");
-            cfgfolders.push_back(exepath);
-        }
+        // only perform further lookups when the given path was not absolute
+        if (!is_abs_path)
+        {
+            std::list<std::string> cfgfolders;
+    #ifdef FILESDIR
+            cfgfolders.emplace_back(FILESDIR "/cfg");
+    #endif
+            if (exename) {
+                std::string exepath(Path::fromNativeSeparators(Path::getPathFromFilename(Path::getCurrentExecutablePath(exename))));
+                cfgfolders.push_back(exepath + "cfg");
+                cfgfolders.push_back(std::move(exepath));
+            }
 
-        while (error == tinyxml2::XML_ERROR_FILE_NOT_FOUND && !cfgfolders.empty()) {
-            const std::string cfgfolder(cfgfolders.front());
-            cfgfolders.pop_front();
-            const char *sep = (!cfgfolder.empty() && endsWith(cfgfolder,'/') ? "" : "/");
-            const std::string filename(cfgfolder + sep + fullfilename);
-            error = doc.LoadFile(filename.c_str());
-            if (error != tinyxml2::XML_ERROR_FILE_NOT_FOUND)
-                absolute_path = Path::getAbsoluteFilePath(filename);
+            while (error == tinyxml2::XML_ERROR_FILE_NOT_FOUND && !cfgfolders.empty()) {
+                const std::string cfgfolder(cfgfolders.back());
+                cfgfolders.pop_back();
+                const char *sep = (!cfgfolder.empty() && endsWith(cfgfolder,'/') ? "" : "/");
+                const std::string filename(cfgfolder + sep + fullfilename);
+                if (debug)
+                    std::cout << "looking for library '" + std::string(filename) + "'" << std::endl;
+                error = xml_LoadFile(doc, filename.c_str());
+                if (error != tinyxml2::XML_ERROR_FILE_NOT_FOUND)
+                    absolute_path = Path::getAbsoluteFilePath(filename);
+            }
         }
     } else
-        absolute_path = Path::getAbsoluteFilePath(path);
+        absolute_path = Path::getAbsoluteFilePath(fullfilename);
 
     if (error == tinyxml2::XML_SUCCESS) {
-        if (mFiles.find(absolute_path) == mFiles.end()) {
+        if (mData->mFiles.find(absolute_path) == mData->mFiles.end()) {
             Error err = load(doc);
-            if (err.errorcode == OK)
-                mFiles.insert(absolute_path);
+            if (err.errorcode == ErrorCode::OK)
+                mData->mFiles.insert(std::move(absolute_path));
             return err;
         }
 
-        return Error(OK); // ignore duplicates
+        return Error(ErrorCode::OK); // ignore duplicates
     }
 
+    if (debug)
+        std::cout << "library not found: '" + std::string(path) + "'" << std::endl;
+
     if (error == tinyxml2::XML_ERROR_FILE_NOT_FOUND)
-        return Error(FILE_NOT_FOUND);
-    else {
-        doc.PrintError();
-        return Error(BAD_XML);
+        return Error(ErrorCode::FILE_NOT_FOUND);
+
+    doc.PrintError(); // TODO: do not print stray messages
+    return Error(ErrorCode::BAD_XML);
+}
+
+Library::Container::Yield Library::Container::yieldFrom(const std::string& yieldName)
+{
+    if (yieldName == "at_index")
+        return Container::Yield::AT_INDEX;
+    if (yieldName == "item")
+        return Container::Yield::ITEM;
+    if (yieldName == "buffer")
+        return Container::Yield::BUFFER;
+    if (yieldName == "buffer-nt")
+        return Container::Yield::BUFFER_NT;
+    if (yieldName == "start-iterator")
+        return Container::Yield::START_ITERATOR;
+    if (yieldName == "end-iterator")
+        return Container::Yield::END_ITERATOR;
+    if (yieldName == "iterator")
+        return Container::Yield::ITERATOR;
+    if (yieldName == "size")
+        return Container::Yield::SIZE;
+    if (yieldName == "empty")
+        return Container::Yield::EMPTY;
+    return Container::Yield::NO_YIELD;
+}
+Library::Container::Action Library::Container::actionFrom(const std::string& actionName)
+{
+    if (actionName == "resize")
+        return Container::Action::RESIZE;
+    if (actionName == "clear")
+        return Container::Action::CLEAR;
+    if (actionName == "push")
+        return Container::Action::PUSH;
+    if (actionName == "pop")
+        return Container::Action::POP;
+    if (actionName == "find")
+        return Container::Action::FIND;
+    if (actionName == "find-const")
+        return Container::Action::FIND_CONST;
+    if (actionName == "insert")
+        return Container::Action::INSERT;
+    if (actionName == "erase")
+        return Container::Action::ERASE;
+    if (actionName == "append")
+        return Container::Action::APPEND;
+    if (actionName == "change-content")
+        return Container::Action::CHANGE_CONTENT;
+    if (actionName == "change-internal")
+        return Container::Action::CHANGE_INTERNAL;
+    if (actionName == "change")
+        return Container::Action::CHANGE;
+    return Container::Action::NO_ACTION;
+}
+
+std::string Library::Container::toString(Library::Container::Yield yield)
+{
+    switch (yield) {
+    case Library::Container::Yield::AT_INDEX:
+        return "at_index";
+    case Library::Container::Yield::ITEM:
+        return "item";
+    case Library::Container::Yield::BUFFER:
+        return "buffer";
+    case Library::Container::Yield::BUFFER_NT:
+        return "buffer-nt";
+    case Library::Container::Yield::START_ITERATOR:
+        return "start-iterator";
+    case Library::Container::Yield::END_ITERATOR:
+        return "end-iterator";
+    case Library::Container::Yield::ITERATOR:
+        return "iterator";
+    case Library::Container::Yield::SIZE:
+        return "size";
+    case Library::Container::Yield::EMPTY:
+        return "empty";
+    case Library::Container::Yield::NO_YIELD:
+        break;
     }
+    return "";
 }
 
-bool Library::loadxmldata(const char xmldata[], std::size_t len)
+std::string Library::Container::toString(Library::Container::Action action)
 {
-    tinyxml2::XMLDocument doc;
-    return (tinyxml2::XML_SUCCESS == doc.Parse(xmldata, len)) && (load(doc).errorcode == OK);
+    switch (action) {
+    case Library::Container::Action::RESIZE:
+        return "resize";
+    case Library::Container::Action::CLEAR:
+        return "clear";
+    case Library::Container::Action::PUSH:
+        return "push";
+    case Library::Container::Action::POP:
+        return "pop";
+    case Library::Container::Action::FIND:
+        return "find";
+    case Library::Container::Action::FIND_CONST:
+        return "find-const";
+    case Library::Container::Action::INSERT:
+        return "insert";
+    case Library::Container::Action::ERASE:
+        return "erase";
+    case Library::Container::Action::APPEND:
+        return "append";
+    case Library::Container::Action::CHANGE_CONTENT:
+        return "change-content";
+    case Library::Container::Action::CHANGE:
+        return "change";
+    case Library::Container::Action::CHANGE_INTERNAL:
+        return "change-internal";
+    case Library::Container::Action::NO_ACTION:
+        break;
+    }
+    return "";
 }
 
 Library::Error Library::load(const tinyxml2::XMLDocument &doc)
@@ -147,19 +375,16 @@ Library::Error Library::load(const tinyxml2::XMLDocument &doc)
 
     if (rootnode == nullptr) {
         doc.PrintError();
-        return Error(BAD_XML);
+        return Error(ErrorCode::BAD_XML);
     }
 
     if (strcmp(rootnode->Name(),"def") != 0)
-        return Error(UNSUPPORTED_FORMAT, rootnode->Name());
+        return Error(ErrorCode::UNSUPPORTED_FORMAT, rootnode->Name());
 
-    const char* format_string = rootnode->Attribute("format");
-    int format = 1; // Assume format version 1 if nothing else is specified (very old .cfg files had no 'format' attribute)
-    if (format_string)
-        format = atoi(format_string);
+    const int format = rootnode->IntAttribute("format", 1); // Assume format version 1 if nothing else is specified (very old .cfg files had no 'format' attribute)
 
     if (format > 2 || format <= 0)
-        return Error(UNSUPPORTED_FORMAT);
+        return Error(ErrorCode::UNSUPPORTED_FORMAT);
 
     std::set<std::string> unknown_elements;
 
@@ -170,36 +395,39 @@ Library::Error Library::load(const tinyxml2::XMLDocument &doc)
             int allocationId = 0;
             for (const tinyxml2::XMLElement *memorynode = node->FirstChildElement(); memorynode; memorynode = memorynode->NextSiblingElement()) {
                 if (strcmp(memorynode->Name(),"dealloc")==0) {
-                    const std::map<std::string, AllocFunc>::const_iterator it = mDealloc.find(memorynode->GetText());
-                    if (it != mDealloc.end()) {
-                        allocationId = it->second.groupId;
-                        break;
+                    const auto names = getnames(memorynode->GetText());
+                    for (const auto& n : names) {
+                        const auto it = utils::as_const(mData->mDealloc).find(n);
+                        if (it != mData->mDealloc.end()) {
+                            allocationId = it->second.groupId;
+                            break;
+                        }
                     }
+                    if (allocationId != 0)
+                        break;
                 }
             }
             if (allocationId == 0) {
-                if (nodename == "memory")
-                    while (!ismemory(++mAllocId));
-                else
-                    while (!isresource(++mAllocId));
-                allocationId = mAllocId;
+                if (nodename == "memory") {
+                    while (!ismemory(++mData->mAllocId)) {}
+                }
+                else {
+                    while (!isresource(++mData->mAllocId)) {}
+                }
+                allocationId = mData->mAllocId;
             }
 
             // add alloc/dealloc/use functions..
             for (const tinyxml2::XMLElement *memorynode = node->FirstChildElement(); memorynode; memorynode = memorynode->NextSiblingElement()) {
                 const std::string memorynodename = memorynode->Name();
+                const auto names = getnames(memorynode->GetText());
                 if (memorynodename == "alloc" || memorynodename == "realloc") {
-                    AllocFunc temp = {0};
+                    AllocFunc temp;
                     temp.groupId = allocationId;
 
-                    if (memorynode->Attribute("init", "false"))
-                        returnuninitdata.insert(memorynode->GetText());
-
-                    const char *arg = memorynode->Attribute("arg");
-                    if (arg)
-                        temp.arg = atoi(arg);
-                    else
-                        temp.arg = -1;
+                    temp.noFail = memorynode->BoolAttribute("no-fail", false);
+                    temp.initData = memorynode->BoolAttribute("init", true);
+                    temp.arg = memorynode->IntAttribute("arg", -1);
 
                     const char *bufferSize = memorynode->Attribute("buffer-size");
                     if (!bufferSize)
@@ -212,7 +440,7 @@ Library::Error Library::load(const tinyxml2::XMLDocument &doc)
                         else if (std::strncmp(bufferSize, "strdup", 6) == 0)
                             temp.bufferSize = AllocFunc::BufferSize::strdup;
                         else
-                            return Error(BAD_ATTRIBUTE_VALUE, bufferSize);
+                            return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, bufferSize);
                         temp.bufferSizeArg1 = 1;
                         temp.bufferSizeArg2 = 2;
                         if (bufferSize[6] == 0) {
@@ -222,32 +450,24 @@ Library::Error Library::load(const tinyxml2::XMLDocument &doc)
                             if (bufferSize[8] == ',' && bufferSize[9] >= '1' && bufferSize[9] <= '5')
                                 temp.bufferSizeArg2 = bufferSize[9] - '0';
                         } else
-                            return Error(BAD_ATTRIBUTE_VALUE, bufferSize);
+                            return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, bufferSize);
                     }
 
-                    if (memorynodename == "realloc") {
-                        const char *reallocArg =  memorynode->Attribute("realloc-arg");
-                        if (reallocArg)
-                            temp.reallocArg = atoi(reallocArg);
-                        else
-                            temp.reallocArg = 1;
-                    }
+                    if (memorynodename == "realloc")
+                        temp.reallocArg = memorynode->IntAttribute("realloc-arg", 1);
 
-                    if (memorynodename != "realloc")
-                        mAlloc[memorynode->GetText()] = temp;
-                    else
-                        mRealloc[memorynode->GetText()] = temp;
+                    auto& map = (memorynodename == "realloc") ? mData->mRealloc : mData->mAlloc;
+                    for (const auto& n : names)
+                        map[n] = temp;
                 } else if (memorynodename == "dealloc") {
-                    AllocFunc temp = {0};
+                    AllocFunc temp;
                     temp.groupId = allocationId;
-                    const char *arg = memorynode->Attribute("arg");
-                    if (arg)
-                        temp.arg = atoi(arg);
-                    else
-                        temp.arg = 1;
-                    mDealloc[memorynode->GetText()] = temp;
+                    temp.arg = memorynode->IntAttribute("arg", 1);
+                    for (const auto& n : names)
+                        mData->mDealloc[n] = temp;
                 } else if (memorynodename == "use")
-                    functions[memorynode->GetText()].use = true;
+                    for (const auto& n : names)
+                        mData->mFunctions[n].use = true;
                 else
                     unknown_elements.insert(memorynodename);
             }
@@ -256,19 +476,19 @@ Library::Error Library::load(const tinyxml2::XMLDocument &doc)
         else if (nodename == "define") {
             const char *name = node->Attribute("name");
             if (name == nullptr)
-                return Error(MISSING_ATTRIBUTE, "name");
+                return Error(ErrorCode::MISSING_ATTRIBUTE, "name");
             const char *value = node->Attribute("value");
             if (value == nullptr)
-                return Error(MISSING_ATTRIBUTE, "value");
-            defines.push_back(std::string(name) +
-                              " " +
-                              value);
+                return Error(ErrorCode::MISSING_ATTRIBUTE, "value");
+            auto result = mData->mDefines.insert(std::string(name) + " " + value);
+            if (!result.second)
+                return Error(ErrorCode::DUPLICATE_DEFINE, name);
         }
 
         else if (nodename == "function") {
             const char *name = node->Attribute("name");
             if (name == nullptr)
-                return Error(MISSING_ATTRIBUTE, "name");
+                return Error(ErrorCode::MISSING_ATTRIBUTE, "name");
             for (const std::string &s : getnames(name)) {
                 const Error &err = loadFunction(node, s, unknown_elements);
                 if (err.errorcode != ErrorCode::OK)
@@ -285,20 +505,20 @@ Library::Error Library::load(const tinyxml2::XMLDocument &doc)
 
                 const char * const argString = reflectionnode->Attribute("arg");
                 if (!argString)
-                    return Error(MISSING_ATTRIBUTE, "arg");
+                    return Error(ErrorCode::MISSING_ATTRIBUTE, "arg");
 
-                mReflection[reflectionnode->GetText()] = atoi(argString);
+                mData->mReflection[reflectionnode->GetText()] = strToInt<int>(argString);
             }
         }
 
         else if (nodename == "markup") {
             const char * const extension = node->Attribute("ext");
             if (!extension)
-                return Error(MISSING_ATTRIBUTE, "ext");
-            mMarkupExtensions.insert(extension);
+                return Error(ErrorCode::MISSING_ATTRIBUTE, "ext");
+            mData->mMarkupExtensions.insert(extension);
 
-            mReportErrors[extension] = (node->Attribute("reporterrors", "true") != nullptr);
-            mProcessAfterCode[extension] = (node->Attribute("aftercode", "true") != nullptr);
+            mData->mReportErrors[extension] = (node->Attribute("reporterrors", "true") != nullptr);
+            mData->mProcessAfterCode[extension] = (node->Attribute("aftercode", "true") != nullptr);
 
             for (const tinyxml2::XMLElement *markupnode = node->FirstChildElement(); markupnode; markupnode = markupnode->NextSiblingElement()) {
                 const std::string markupnodename = markupnode->Name();
@@ -307,8 +527,8 @@ Library::Error Library::load(const tinyxml2::XMLDocument &doc)
                         if (strcmp(librarynode->Name(), "keyword") == 0) {
                             const char* nodeName = librarynode->Attribute("name");
                             if (nodeName == nullptr)
-                                return Error(MISSING_ATTRIBUTE, "name");
-                            mKeywords[extension].insert(nodeName);
+                                return Error(ErrorCode::MISSING_ATTRIBUTE, "name");
+                            mData->mKeywords[extension].insert(nodeName);
                         } else
                             unknown_elements.insert(librarynode->Name());
                     }
@@ -323,14 +543,14 @@ Library::Error Library::load(const tinyxml2::XMLDocument &doc)
 
                         const char * const prefix = exporter->Attribute("prefix");
                         if (!prefix)
-                            return Error(MISSING_ATTRIBUTE, "prefix");
+                            return Error(ErrorCode::MISSING_ATTRIBUTE, "prefix");
 
                         for (const tinyxml2::XMLElement *e = exporter->FirstChildElement(); e; e = e->NextSiblingElement()) {
                             const std::string ename = e->Name();
                             if (ename == "prefix")
-                                mExporters[prefix].addPrefix(e->GetText());
+                                mData->mExporters[prefix].addPrefix(e->GetText());
                             else if (ename == "suffix")
-                                mExporters[prefix].addSuffix(e->GetText());
+                                mData->mExporters[prefix].addSuffix(e->GetText());
                             else
                                 unknown_elements.insert(ename);
                         }
@@ -340,7 +560,7 @@ Library::Error Library::load(const tinyxml2::XMLDocument &doc)
                 else if (markupnodename == "imported") {
                     for (const tinyxml2::XMLElement *librarynode = markupnode->FirstChildElement(); librarynode; librarynode = librarynode->NextSiblingElement()) {
                         if (strcmp(librarynode->Name(), "importer") == 0)
-                            mImporters[extension].insert(librarynode->GetText());
+                            mData->mImporters[extension].insert(librarynode->GetText());
                         else
                             unknown_elements.insert(librarynode->Name());
                     }
@@ -352,17 +572,19 @@ Library::Error Library::load(const tinyxml2::XMLDocument &doc)
                         if (blocknodename == "block") {
                             const char * blockName = blocknode->Attribute("name");
                             if (blockName)
-                                mExecutableBlocks[extension].addBlock(blockName);
+                                mData->mExecutableBlocks[extension].addBlock(blockName);
                         } else if (blocknodename == "structure") {
                             const char * start = blocknode->Attribute("start");
                             if (start)
-                                mExecutableBlocks[extension].setStart(start);
+                                mData->mExecutableBlocks[extension].setStart(start);
                             const char * end = blocknode->Attribute("end");
                             if (end)
-                                mExecutableBlocks[extension].setEnd(end);
+                                mData->mExecutableBlocks[extension].setEnd(end);
                             const char * offset = blocknode->Attribute("offset");
-                            if (offset)
-                                mExecutableBlocks[extension].setOffset(atoi(offset));
+                            if (offset) {
+                                // cppcheck-suppress templateInstantiation - TODO: fix this - see #11631
+                                mData->mExecutableBlocks[extension].setOffset(strToInt<int>(offset));
+                            }
                         }
 
                         else
@@ -378,23 +600,26 @@ Library::Error Library::load(const tinyxml2::XMLDocument &doc)
         else if (nodename == "container") {
             const char* const id = node->Attribute("id");
             if (!id)
-                return Error(MISSING_ATTRIBUTE, "id");
+                return Error(ErrorCode::MISSING_ATTRIBUTE, "id");
 
-            Container& container = containers[id];
+            Container& container = mData->mContainers[id];
 
             const char* const inherits = node->Attribute("inherits");
             if (inherits) {
-                const std::map<std::string, Container>::const_iterator i = containers.find(inherits);
-                if (i != containers.end())
+                const auto i = utils::as_const(mData->mContainers).find(inherits);
+                if (i != mData->mContainers.end())
                     container = i->second; // Take values from parent and overwrite them if necessary
                 else
-                    return Error(BAD_ATTRIBUTE_VALUE, inherits);
+                    return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, inherits);
             }
 
             const char* const startPattern = node->Attribute("startPattern");
             if (startPattern) {
                 container.startPattern = startPattern;
-                container.startPattern2 = container.startPattern + " !!::";
+                container.startPattern2 = startPattern;
+                if (!endsWith(container.startPattern, '<'))
+                    container.startPattern2 += " !!::";
+                container.startPatternHasStd = startsWith(container.startPattern2, "std :: ");
             }
             const char* const endPattern = node->Attribute("endPattern");
             if (endPattern)
@@ -404,75 +629,49 @@ Library::Error Library::load(const tinyxml2::XMLDocument &doc)
                 container.itEndPattern = itEndPattern;
             const char* const opLessAllowed = node->Attribute("opLessAllowed");
             if (opLessAllowed)
-                container.opLessAllowed = std::string(opLessAllowed) == "true";
+                container.opLessAllowed = strcmp(opLessAllowed, "true") == 0;
+            const char* const hasInitializerListConstructor = node->Attribute("hasInitializerListConstructor");
+            if (hasInitializerListConstructor)
+                container.hasInitializerListConstructor = strcmp(hasInitializerListConstructor, "true") == 0;
+            const char* const view = node->Attribute("view");
+            if (view)
+                container.view = strcmp(view, "true") == 0;
 
             for (const tinyxml2::XMLElement *containerNode = node->FirstChildElement(); containerNode; containerNode = containerNode->NextSiblingElement()) {
                 const std::string containerNodeName = containerNode->Name();
                 if (containerNodeName == "size" || containerNodeName == "access" || containerNodeName == "other") {
                     for (const tinyxml2::XMLElement *functionNode = containerNode->FirstChildElement(); functionNode; functionNode = functionNode->NextSiblingElement()) {
-                        if (std::string(functionNode->Name()) != "function") {
+                        if (strcmp(functionNode->Name(), "function") != 0) {
                             unknown_elements.insert(functionNode->Name());
                             continue;
                         }
 
                         const char* const functionName = functionNode->Attribute("name");
                         if (!functionName)
-                            return Error(MISSING_ATTRIBUTE, "name");
+                            return Error(ErrorCode::MISSING_ATTRIBUTE, "name");
 
                         const char* const action_ptr = functionNode->Attribute("action");
                         Container::Action action = Container::Action::NO_ACTION;
                         if (action_ptr) {
                             std::string actionName = action_ptr;
-                            if (actionName == "resize")
-                                action = Container::Action::RESIZE;
-                            else if (actionName == "clear")
-                                action = Container::Action::CLEAR;
-                            else if (actionName == "push")
-                                action = Container::Action::PUSH;
-                            else if (actionName == "pop")
-                                action = Container::Action::POP;
-                            else if (actionName == "find")
-                                action = Container::Action::FIND;
-                            else if (actionName == "insert")
-                                action = Container::Action::INSERT;
-                            else if (actionName == "erase")
-                                action = Container::Action::ERASE;
-                            else if (actionName == "change-content")
-                                action = Container::Action::CHANGE_CONTENT;
-                            else if (actionName == "change-internal")
-                                action = Container::Action::CHANGE_INTERNAL;
-                            else if (actionName == "change")
-                                action = Container::Action::CHANGE;
-                            else
-                                return Error(BAD_ATTRIBUTE_VALUE, actionName);
+                            action = Container::actionFrom(actionName);
+                            if (action == Container::Action::NO_ACTION)
+                                return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, actionName);
                         }
 
                         const char* const yield_ptr = functionNode->Attribute("yields");
                         Container::Yield yield = Container::Yield::NO_YIELD;
                         if (yield_ptr) {
                             std::string yieldName = yield_ptr;
-                            if (yieldName == "at_index")
-                                yield = Container::Yield::AT_INDEX;
-                            else if (yieldName == "item")
-                                yield = Container::Yield::ITEM;
-                            else if (yieldName == "buffer")
-                                yield = Container::Yield::BUFFER;
-                            else if (yieldName == "buffer-nt")
-                                yield = Container::Yield::BUFFER_NT;
-                            else if (yieldName == "start-iterator")
-                                yield = Container::Yield::START_ITERATOR;
-                            else if (yieldName == "end-iterator")
-                                yield = Container::Yield::END_ITERATOR;
-                            else if (yieldName == "iterator")
-                                yield = Container::Yield::ITERATOR;
-                            else if (yieldName == "size")
-                                yield = Container::Yield::SIZE;
-                            else if (yieldName == "empty")
-                                yield = Container::Yield::EMPTY;
-                            else
-                                return Error(BAD_ATTRIBUTE_VALUE, yieldName);
+                            yield = Container::yieldFrom(yieldName);
+                            if (yield == Container::Yield::NO_YIELD)
+                                return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, yieldName);
                         }
 
+                        const char* const returnType = functionNode->Attribute("returnType");
+                        if (returnType)
+                            container.functions[functionName].returnType = returnType;
+
                         container.functions[functionName].action = action;
                         container.functions[functionName].yield = yield;
                     }
@@ -480,23 +679,40 @@ Library::Error Library::load(const tinyxml2::XMLDocument &doc)
                     if (containerNodeName == "size") {
                         const char* const templateArg = containerNode->Attribute("templateParameter");
                         if (templateArg)
-                            container.size_templateArgNo = atoi(templateArg);
+                            container.size_templateArgNo = strToInt<int>(templateArg);
                     } else if (containerNodeName == "access") {
                         const char* const indexArg = containerNode->Attribute("indexOperator");
                         if (indexArg)
-                            container.arrayLike_indexOp = std::string(indexArg) == "array-like";
+                            container.arrayLike_indexOp = strcmp(indexArg, "array-like") == 0;
                     }
                 } else if (containerNodeName == "type") {
                     const char* const templateArg = containerNode->Attribute("templateParameter");
                     if (templateArg)
-                        container.type_templateArgNo = atoi(templateArg);
+                        container.type_templateArgNo = strToInt<int>(templateArg);
 
                     const char* const string = containerNode->Attribute("string");
                     if (string)
-                        container.stdStringLike = std::string(string) == "std-like";
+                        container.stdStringLike = strcmp(string, "std-like") == 0;
                     const char* const associative = containerNode->Attribute("associative");
                     if (associative)
-                        container.stdAssociativeLike = std::string(associative) == "std-like";
+                        container.stdAssociativeLike = strcmp(associative, "std-like") == 0;
+                    const char* const unstable = containerNode->Attribute("unstable");
+                    if (unstable) {
+                        std::string unstableType = unstable;
+                        if (unstableType.find("erase") != std::string::npos)
+                            container.unstableErase = true;
+                        if (unstableType.find("insert") != std::string::npos)
+                            container.unstableInsert = true;
+                    }
+                } else if (containerNodeName == "rangeItemRecordType") {
+                    for (const tinyxml2::XMLElement* memberNode = node->FirstChildElement(); memberNode; memberNode = memberNode->NextSiblingElement()) {
+                        const char *memberName = memberNode->Attribute("name");
+                        const char *memberTemplateParameter = memberNode->Attribute("templateParameter");
+                        Container::RangeItemRecordTypeItem member;
+                        member.name = memberName ? memberName : "";
+                        member.templateParameter = memberTemplateParameter ? strToInt<int>(memberTemplateParameter) : -1;
+                        container.rangeItemRecordType.emplace_back(std::move(member));
+                    }
                 } else
                     unknown_elements.insert(containerNodeName);
             }
@@ -504,48 +720,74 @@ Library::Error Library::load(const tinyxml2::XMLDocument &doc)
 
         else if (nodename == "smart-pointer") {
             const char *className = node->Attribute("class-name");
-            if (className)
-                smartPointers.insert(className);
+            if (!className)
+                return Error(ErrorCode::MISSING_ATTRIBUTE, "class-name");
+            SmartPointer& smartPointer = mData->mSmartPointers[className];
+            smartPointer.name = className;
+            for (const tinyxml2::XMLElement* smartPointerNode = node->FirstChildElement(); smartPointerNode;
+                 smartPointerNode = smartPointerNode->NextSiblingElement()) {
+                const std::string smartPointerNodeName = smartPointerNode->Name();
+                if (smartPointerNodeName == "unique")
+                    smartPointer.unique = true;
+            }
+        }
+
+        else if (nodename == "type-checks") {
+            for (const tinyxml2::XMLElement *checkNode = node->FirstChildElement(); checkNode; checkNode = checkNode->NextSiblingElement()) {
+                const std::string &checkName = checkNode->Name();
+                for (const tinyxml2::XMLElement *checkTypeNode = checkNode->FirstChildElement(); checkTypeNode; checkTypeNode = checkTypeNode->NextSiblingElement()) {
+                    const std::string checkTypeName = checkTypeNode->Name();
+                    const char *typeName = checkTypeNode->GetText();
+                    if (!typeName)
+                        continue;
+                    if (checkTypeName == "check")
+                        mData->mTypeChecks[std::pair<std::string,std::string>(checkName, typeName)] = TypeCheck::check;
+                    else if (checkTypeName == "suppress")
+                        mData->mTypeChecks[std::pair<std::string,std::string>(checkName, typeName)] = TypeCheck::suppress;
+                    else if (checkTypeName == "checkFiniteLifetime")
+                        mData->mTypeChecks[std::pair<std::string,std::string>(checkName, typeName)] = TypeCheck::checkFiniteLifetime;
+                }
+            }
         }
 
         else if (nodename == "podtype") {
             const char * const name = node->Attribute("name");
             if (!name)
-                return Error(MISSING_ATTRIBUTE, "name");
-            PodType podType = {0};
-            podType.stdtype = PodType::NO;
+                return Error(ErrorCode::MISSING_ATTRIBUTE, "name");
+            PodType podType;
+            podType.stdtype = PodType::Type::NO;
             const char * const stdtype = node->Attribute("stdtype");
             if (stdtype) {
                 if (std::strcmp(stdtype, "bool") == 0)
-                    podType.stdtype = PodType::BOOL;
+                    podType.stdtype = PodType::Type::BOOL;
                 else if (std::strcmp(stdtype, "char") == 0)
-                    podType.stdtype = PodType::CHAR;
+                    podType.stdtype = PodType::Type::CHAR;
                 else if (std::strcmp(stdtype, "short") == 0)
-                    podType.stdtype = PodType::SHORT;
+                    podType.stdtype = PodType::Type::SHORT;
                 else if (std::strcmp(stdtype, "int") == 0)
-                    podType.stdtype = PodType::INT;
+                    podType.stdtype = PodType::Type::INT;
                 else if (std::strcmp(stdtype, "long") == 0)
-                    podType.stdtype = PodType::LONG;
+                    podType.stdtype = PodType::Type::LONG;
                 else if (std::strcmp(stdtype, "long long") == 0)
-                    podType.stdtype = PodType::LONGLONG;
+                    podType.stdtype = PodType::Type::LONGLONG;
             }
             const char * const size = node->Attribute("size");
             if (size)
-                podType.size = atoi(size);
+                podType.size = strToInt<unsigned int>(size);
             const char * const sign = node->Attribute("sign");
             if (sign)
                 podType.sign = *sign;
             for (const std::string &s : getnames(name))
-                mPodTypes[s] = podType;
+                mData->mPodTypes[s] = podType;
         }
 
         else if (nodename == "platformtype") {
             const char * const type_name = node->Attribute("name");
             if (type_name == nullptr)
-                return Error(MISSING_ATTRIBUTE, "name");
+                return Error(ErrorCode::MISSING_ATTRIBUTE, "name");
             const char *value = node->Attribute("value");
             if (value == nullptr)
-                return Error(MISSING_ATTRIBUTE, "value");
+                return Error(ErrorCode::MISSING_ATTRIBUTE, "value");
             PlatformType type;
             type.mType = value;
             std::set<std::string> platform;
@@ -554,121 +796,158 @@ Library::Error Library::load(const tinyxml2::XMLDocument &doc)
                 if (typenodename == "platform") {
                     const char * const type_attribute = typenode->Attribute("type");
                     if (type_attribute == nullptr)
-                        return Error(MISSING_ATTRIBUTE, "type");
+                        return Error(ErrorCode::MISSING_ATTRIBUTE, "type");
                     platform.insert(type_attribute);
                 } else if (typenodename == "signed")
-                    type._signed = true;
+                    type.mSigned = true;
                 else if (typenodename == "unsigned")
-                    type._unsigned = true;
+                    type.mUnsigned = true;
                 else if (typenodename == "long")
-                    type._long = true;
+                    type.mLong = true;
                 else if (typenodename == "pointer")
-                    type._pointer= true;
+                    type.mPointer= true;
                 else if (typenodename == "ptr_ptr")
-                    type._ptr_ptr = true;
+                    type.mPtrPtr = true;
                 else if (typenodename == "const_ptr")
-                    type._const_ptr = true;
+                    type.mConstPtr = true;
                 else
                     unknown_elements.insert(typenodename);
             }
             if (platform.empty()) {
-                const PlatformType * const type_ptr = platform_type(type_name, emptyString);
+                const PlatformType * const type_ptr = platform_type(type_name, "");
                 if (type_ptr) {
                     if (*type_ptr == type)
-                        return Error(DUPLICATE_PLATFORM_TYPE, type_name);
-                    return Error(PLATFORM_TYPE_REDEFINED, type_name);
+                        return Error(ErrorCode::DUPLICATE_PLATFORM_TYPE, type_name);
+                    return Error(ErrorCode::PLATFORM_TYPE_REDEFINED, type_name);
                 }
-                mPlatformTypes[type_name] = type;
+                mData->mPlatformTypes[type_name] = std::move(type);
             } else {
                 for (const std::string &p : platform) {
                     const PlatformType * const type_ptr = platform_type(type_name, p);
                     if (type_ptr) {
                         if (*type_ptr == type)
-                            return Error(DUPLICATE_PLATFORM_TYPE, type_name);
-                        return Error(PLATFORM_TYPE_REDEFINED, type_name);
+                            return Error(ErrorCode::DUPLICATE_PLATFORM_TYPE, type_name);
+                        return Error(ErrorCode::PLATFORM_TYPE_REDEFINED, type_name);
                     }
-                    mPlatforms[p].mPlatformTypes[type_name] = type;
+                    mData->mPlatforms[p].mPlatformTypes[type_name] = type;
                 }
             }
         }
 
+        else if (nodename == "entrypoint") {
+            const char * const type_name = node->Attribute("name");
+            if (type_name == nullptr)
+                return Error(ErrorCode::MISSING_ATTRIBUTE, "name");
+            mData->mEntrypoints.emplace(type_name);
+        }
+
         else
             unknown_elements.insert(nodename);
     }
     if (!unknown_elements.empty()) {
         std::string str;
-        for (std::set<std::string>::const_iterator i = unknown_elements.begin(); i != unknown_elements.end();) {
+        for (auto i = unknown_elements.cbegin(); i != unknown_elements.cend();) {
             str += *i;
             if (++i != unknown_elements.end())
                 str += ", ";
         }
-        return Error(UNKNOWN_ELEMENT, str);
+        return Error(ErrorCode::UNKNOWN_ELEMENT, str);
     }
-    return Error(OK);
+    return Error(ErrorCode::OK);
 }
 
 Library::Error Library::loadFunction(const tinyxml2::XMLElement * const node, const std::string &name, std::set<std::string> &unknown_elements)
 {
     if (name.empty())
-        return Error(OK);
+        return Error(ErrorCode::OK);
 
-    Function& func = functions[name];
+    // TODO: write debug warning if we modify an existing entry
+    Function& func = mData->mFunctions[name];
 
     for (const tinyxml2::XMLElement *functionnode = node->FirstChildElement(); functionnode; functionnode = functionnode->NextSiblingElement()) {
         const std::string functionnodename = functionnode->Name();
-        if (functionnodename == "noreturn")
-            mNoReturn[name] = (strcmp(functionnode->GetText(), "true") == 0);
-        else if (functionnodename == "pure")
+        if (functionnodename == "noreturn") {
+            const char * const text = functionnode->GetText();
+            if (strcmp(text, "false") == 0)
+                mData->mNoReturn[name] = LibraryData::FalseTrueMaybe::False;
+            else if (strcmp(text, "maybe") == 0)
+                mData->mNoReturn[name] = LibraryData::FalseTrueMaybe::Maybe;
+            else
+                mData->mNoReturn[name] = LibraryData::FalseTrueMaybe::True; // Safe
+        } else if (functionnodename == "pure")
             func.ispure = true;
         else if (functionnodename == "const") {
             func.ispure = true;
             func.isconst = true; // a constant function is pure
         } else if (functionnodename == "leak-ignore")
             func.leakignore = true;
-        else if (functionnodename == "use-retval")
-            func.useretval = true;
-        else if (functionnodename == "returnValue") {
+        else if (functionnodename == "not-overlapping-data") {
+            NonOverlappingData nonOverlappingData;
+            nonOverlappingData.ptr1Arg = functionnode->IntAttribute("ptr1-arg", -1);
+            nonOverlappingData.ptr2Arg = functionnode->IntAttribute("ptr2-arg", -1);
+            nonOverlappingData.sizeArg = functionnode->IntAttribute("size-arg", -1);
+            nonOverlappingData.strlenArg = functionnode->IntAttribute("strlen-arg", -1);
+            nonOverlappingData.countArg = functionnode->IntAttribute("count-arg", -1);
+            mData->mNonOverlappingData[name] = nonOverlappingData;
+        } else if (functionnodename == "use-retval") {
+            func.useretval = Library::UseRetValType::DEFAULT;
+            if (const char *type = functionnode->Attribute("type"))
+                if (std::strcmp(type, "error-code") == 0)
+                    func.useretval = Library::UseRetValType::ERROR_CODE;
+        } else if (functionnodename == "returnValue") {
             if (const char *expr = functionnode->GetText())
-                mReturnValue[name] = expr;
+                mData->mReturnValue[name] = expr;
             if (const char *type = functionnode->Attribute("type"))
-                mReturnValueType[name] = type;
+                mData->mReturnValueType[name] = type;
             if (const char *container = functionnode->Attribute("container"))
-                mReturnValueContainer[name] = std::atoi(container);
+                mData->mReturnValueContainer[name] = strToInt<int>(container);
+            // cppcheck-suppress shadowFunction - TODO: fix this
             if (const char *unknownReturnValues = functionnode->Attribute("unknownValues")) {
                 if (std::strcmp(unknownReturnValues, "all") == 0) {
                     std::vector<MathLib::bigint> values{LLONG_MIN, LLONG_MAX};
-                    mUnknownReturnValues[name] = values;
+                    mData->mUnknownReturnValues[name] = std::move(values);
                 }
             }
         } else if (functionnodename == "arg") {
             const char* argNrString = functionnode->Attribute("nr");
             if (!argNrString)
-                return Error(MISSING_ATTRIBUTE, "nr");
+                return Error(ErrorCode::MISSING_ATTRIBUTE, "nr");
             const bool bAnyArg = strcmp(argNrString, "any") == 0;
             const bool bVariadicArg = strcmp(argNrString, "variadic") == 0;
-            const int nr = (bAnyArg || bVariadicArg) ? -1 : std::atoi(argNrString);
+            const int nr = (bAnyArg || bVariadicArg) ? -1 : strToInt<int>(argNrString);
             ArgumentChecks &ac = func.argumentChecks[nr];
             ac.optional  = functionnode->Attribute("default") != nullptr;
             ac.variadic = bVariadicArg;
             const char * const argDirection = functionnode->Attribute("direction");
             if (argDirection) {
                 const size_t argDirLen = strlen(argDirection);
+                ArgumentChecks::Direction dir = ArgumentChecks::Direction::DIR_UNKNOWN;
                 if (!strncmp(argDirection, "in", argDirLen)) {
-                    ac.direction = ArgumentChecks::Direction::DIR_IN;
+                    dir = ArgumentChecks::Direction::DIR_IN;
                 } else if (!strncmp(argDirection, "out", argDirLen)) {
-                    ac.direction = ArgumentChecks::Direction::DIR_OUT;
+                    dir = ArgumentChecks::Direction::DIR_OUT;
                 } else if (!strncmp(argDirection, "inout", argDirLen)) {
-                    ac.direction = ArgumentChecks::Direction::DIR_INOUT;
+                    dir = ArgumentChecks::Direction::DIR_INOUT;
                 }
+                if (const char* const argIndirect = functionnode->Attribute("indirect")) {
+                    const int indirect = strToInt<int>(argIndirect);
+                    ac.direction[indirect] = dir; // TODO: handle multiple directions/indirect levels
+                }
+                else
+                    ac.direction.fill(dir);
             }
             for (const tinyxml2::XMLElement *argnode = functionnode->FirstChildElement(); argnode; argnode = argnode->NextSiblingElement()) {
                 const std::string argnodename = argnode->Name();
+                int indirect = 0;
+                const char * const indirectStr = argnode->Attribute("indirect");
+                if (indirectStr)
+                    indirect = strToInt<int>(indirectStr);
                 if (argnodename == "not-bool")
                     ac.notbool = true;
                 else if (argnodename == "not-null")
                     ac.notnull = true;
                 else if (argnodename == "not-uninit")
-                    ac.notuninit = true;
+                    ac.notuninit = indirect;
                 else if (argnodename == "formatstr")
                     ac.formatstr = true;
                 else if (argnodename == "strz")
@@ -676,44 +955,15 @@ Library::Error Library::loadFunction(const tinyxml2::XMLElement * const node, co
                 else if (argnodename == "valid") {
                     // Validate the validation expression
                     const char *p = argnode->GetText();
-                    bool error = false;
-                    bool range = false;
-                    bool has_dot = false;
-
-                    if (!p)
-                        return Error(BAD_ATTRIBUTE_VALUE, "\"\"");
-
-                    error = *p == '.';
-                    for (; *p; p++) {
-                        if (std::isdigit(*p))
-                            error |= (*(p+1) == '-');
-                        else if (*p == ':') {
-                            error |= range | (*(p+1) == '.');
-                            range = true;
-                            has_dot = false;
-                        } else if (*p == '-')
-                            error |= (!std::isdigit(*(p+1)));
-                        else if (*p == ',') {
-                            range = false;
-                            error |= *(p+1) == '.';
-                            has_dot = false;
-                        } else if (*p == '.') {
-                            error |= has_dot | (!std::isdigit(*(p+1)));
-                            has_dot = true;
-                        } else
-                            error = true;
-                    }
-                    if (error)
-                        return Error(BAD_ATTRIBUTE_VALUE, argnode->GetText());
-
+                    if (!isCompliantValidationExpression(p))
+                        return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, (!p ? "\"\"" : p));
                     // Set validation expression
-                    ac.valid = argnode->GetText();
+                    ac.valid = p;
                 }
-
                 else if (argnodename == "minsize") {
                     const char *typeattr = argnode->Attribute("type");
                     if (!typeattr)
-                        return Error(MISSING_ATTRIBUTE, "type");
+                        return Error(ErrorCode::MISSING_ATTRIBUTE, "type");
 
                     ArgumentChecks::MinSize::Type type;
                     if (strcmp(typeattr,"strlen")==0)
@@ -727,54 +977,58 @@ Library::Error Library::loadFunction(const tinyxml2::XMLElement * const node, co
                     else if (strcmp(typeattr,"value")==0)
                         type = ArgumentChecks::MinSize::Type::VALUE;
                     else
-                        return Error(BAD_ATTRIBUTE_VALUE, typeattr);
+                        return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, typeattr);
 
                     if (type == ArgumentChecks::MinSize::Type::VALUE) {
                         const char *valueattr = argnode->Attribute("value");
                         if (!valueattr)
-                            return Error(MISSING_ATTRIBUTE, "value");
+                            return Error(ErrorCode::MISSING_ATTRIBUTE, "value");
                         long long minsizevalue = 0;
                         try {
-                            minsizevalue = MathLib::toLongNumber(valueattr);
-                        } catch (const InternalError&) {
-                            return Error(BAD_ATTRIBUTE_VALUE, valueattr);
+                            minsizevalue = strToInt<long long>(valueattr);
+                        } catch (const std::runtime_error&) {
+                            return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, valueattr);
                         }
                         if (minsizevalue <= 0)
-                            return Error(BAD_ATTRIBUTE_VALUE, valueattr);
+                            return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, valueattr);
                         ac.minsizes.emplace_back(type, 0);
                         ac.minsizes.back().value = minsizevalue;
                     } else {
                         const char *argattr = argnode->Attribute("arg");
                         if (!argattr)
-                            return Error(MISSING_ATTRIBUTE, "arg");
-                        if (strlen(argattr) != 1 || argattr[0]<'0' || argattr[0]>'9')
-                            return Error(BAD_ATTRIBUTE_VALUE, argattr);
+                            return Error(ErrorCode::MISSING_ATTRIBUTE, "arg");
+                        if (strlen(argattr) != 1 || argattr[0]<'0' || argattr[0]> '9')
+                            return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, argattr);
 
                         ac.minsizes.reserve(type == ArgumentChecks::MinSize::Type::MUL ? 2 : 1);
                         ac.minsizes.emplace_back(type, argattr[0] - '0');
                         if (type == ArgumentChecks::MinSize::Type::MUL) {
                             const char *arg2attr = argnode->Attribute("arg2");
                             if (!arg2attr)
-                                return Error(MISSING_ATTRIBUTE, "arg2");
-                            if (strlen(arg2attr) != 1 || arg2attr[0]<'0' || arg2attr[0]>'9')
-                                return Error(BAD_ATTRIBUTE_VALUE, arg2attr);
+                                return Error(ErrorCode::MISSING_ATTRIBUTE, "arg2");
+                            if (strlen(arg2attr) != 1 || arg2attr[0]<'0' || arg2attr[0]> '9')
+                                return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, arg2attr);
                             ac.minsizes.back().arg2 = arg2attr[0] - '0';
                         }
                     }
+                    const char* baseTypeAttr = argnode->Attribute("baseType"); // used by VALUE, ARGVALUE
+                    if (baseTypeAttr)
+                        ac.minsizes.back().baseType = baseTypeAttr;
                 }
 
                 else if (argnodename == "iterator") {
                     ac.iteratorInfo.it = true;
                     const char* str = argnode->Attribute("type");
-                    ac.iteratorInfo.first = str ? (std::strcmp(str, "first") == 0) : false;
-                    ac.iteratorInfo.last = str ? (std::strcmp(str, "last") == 0) : false;
-                    str = argnode->Attribute("container");
-                    ac.iteratorInfo.container = str ? std::atoi(str) : 0;
+                    ac.iteratorInfo.first = (str && std::strcmp(str, "first") == 0);
+                    ac.iteratorInfo.last = (str && std::strcmp(str, "last") == 0);
+                    ac.iteratorInfo.container = argnode->IntAttribute("container", 0);
                 }
 
                 else
                     unknown_elements.insert(argnodename);
             }
+            if (ac.notuninit == 0)
+                ac.notuninit = ac.notnull ? 1 : 0;
         } else if (functionnodename == "ignorefunction") {
             func.ignore = true;
         } else if (functionnodename == "formatstr") {
@@ -787,20 +1041,20 @@ Library::Error Library::loadFunction(const tinyxml2::XMLElement * const node, co
             WarnInfo wi;
             const char* const severity = functionnode->Attribute("severity");
             if (severity == nullptr)
-                return Error(MISSING_ATTRIBUTE, "severity");
-            wi.severity = Severity::fromString(severity);
+                return Error(ErrorCode::MISSING_ATTRIBUTE, "severity");
+            wi.severity = severityFromString(severity);
 
             const char* const cstd = functionnode->Attribute("cstd");
             if (cstd) {
                 if (!wi.standards.setC(cstd))
-                    return Error(BAD_ATTRIBUTE_VALUE, cstd);
+                    return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, cstd);
             } else
                 wi.standards.c = Standards::C89;
 
             const char* const cppstd = functionnode->Attribute("cppstd");
             if (cppstd) {
                 if (!wi.standards.setCPP(cppstd))
-                    return Error(BAD_ATTRIBUTE_VALUE, cppstd);
+                    return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, cppstd);
             } else
                 wi.standards.cpp = Standards::CPP03;
 
@@ -821,73 +1075,111 @@ Library::Error Library::loadFunction(const tinyxml2::XMLElement * const node, co
                 }
             } else {
                 const char * const message = functionnode->GetText();
-                if (!message) {
-                    return Error(MISSING_ATTRIBUTE, "\"reason\" and \"alternatives\" or some text.");
-                } else
-                    wi.message = message;
+                if (!message)
+                    return Error(ErrorCode::MISSING_ATTRIBUTE, "\"reason\" and \"alternatives\" or some text.");
+
+                wi.message = message;
+            }
+
+            mData->mFunctionwarn[name] = std::move(wi);
+        } else if (functionnodename == "container") {
+            const char* const action_ptr = functionnode->Attribute("action");
+            Container::Action action = Container::Action::NO_ACTION;
+            if (action_ptr) {
+                std::string actionName = action_ptr;
+                action = Container::actionFrom(actionName);
+                if (action == Container::Action::NO_ACTION)
+                    return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, actionName);
+            }
+            func.containerAction = action;
+
+            const char* const yield_ptr = functionnode->Attribute("yields");
+            Container::Yield yield = Container::Yield::NO_YIELD;
+            if (yield_ptr) {
+                std::string yieldName = yield_ptr;
+                yield = Container::yieldFrom(yieldName);
+                if (yield == Container::Yield::NO_YIELD)
+                    return Error(ErrorCode::BAD_ATTRIBUTE_VALUE, yieldName);
             }
+            func.containerYield = yield;
 
-            functionwarn[name] = wi;
+            const char* const returnType = functionnode->Attribute("returnType");
+            if (returnType)
+                func.returnType = returnType;
         } else
             unknown_elements.insert(functionnodename);
     }
-    return Error(OK);
+    return Error(ErrorCode::OK);
 }
 
-bool Library::isIntArgValid(const Token *ftok, int argnr, const MathLib::bigint argvalue) const
+bool Library::isIntArgValid(const Token *ftok, int argnr, const MathLib::bigint argvalue, const Settings& settings) const
 {
     const ArgumentChecks *ac = getarg(ftok, argnr);
     if (!ac || ac->valid.empty())
         return true;
-    else if (ac->valid.find('.') != std::string::npos)
-        return isFloatArgValid(ftok, argnr, argvalue);
-    TokenList tokenList(nullptr);
+    if (ac->valid.find('.') != std::string::npos)
+        return isFloatArgValid(ftok, argnr, static_cast<double>(argvalue), settings);
+    TokenList tokenList(settings, ftok->isCpp() ? Standards::Language::CPP : Standards::Language::C);
     gettokenlistfromvalid(ac->valid, tokenList);
     for (const Token *tok = tokenList.front(); tok; tok = tok->next()) {
-        if (tok->isNumber() && argvalue == MathLib::toLongNumber(tok->str()))
+        if (tok->isNumber() && argvalue == MathLib::toBigNumber(tok))
             return true;
-        if (Token::Match(tok, "%num% : %num%") && argvalue >= MathLib::toLongNumber(tok->str()) && argvalue <= MathLib::toLongNumber(tok->strAt(2)))
+        if (Token::Match(tok, "%num% : %num%") && argvalue >= MathLib::toBigNumber(tok) && argvalue <= MathLib::toBigNumber(tok->tokAt(2)))
             return true;
-        if (Token::Match(tok, "%num% : ,") && argvalue >= MathLib::toLongNumber(tok->str()))
+        if (Token::Match(tok, "%num% : ,") && argvalue >= MathLib::toBigNumber(tok))
             return true;
-        if ((!tok->previous() || tok->previous()->str() == ",") && Token::Match(tok,": %num%") && argvalue <= MathLib::toLongNumber(tok->strAt(1)))
+        if ((!tok->previous() || tok->strAt(-1) == ",") && Token::Match(tok,": %num%") && argvalue <= MathLib::toBigNumber(tok->tokAt(1)))
             return true;
     }
     return false;
 }
 
-bool Library::isFloatArgValid(const Token *ftok, int argnr, double argvalue) const
+bool Library::isFloatArgValid(const Token *ftok, int argnr, double argvalue, const Settings& settings) const
 {
     const ArgumentChecks *ac = getarg(ftok, argnr);
     if (!ac || ac->valid.empty())
         return true;
-    TokenList tokenList(nullptr);
+    TokenList tokenList(settings, ftok->isCpp() ? Standards::Language::CPP : Standards::Language::C);
     gettokenlistfromvalid(ac->valid, tokenList);
     for (const Token *tok = tokenList.front(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "%num% : %num%") && argvalue >= MathLib::toDoubleNumber(tok->str()) && argvalue <= MathLib::toDoubleNumber(tok->strAt(2)))
+        if (Token::Match(tok, "%num% : %num%") && argvalue >= MathLib::toDoubleNumber(tok) && argvalue <= MathLib::toDoubleNumber(tok->tokAt(2)))
             return true;
-        if (Token::Match(tok, "%num% : ,") && argvalue >= MathLib::toDoubleNumber(tok->str()))
+        if (Token::Match(tok, "%num% : ,") && argvalue >= MathLib::toDoubleNumber(tok))
             return true;
-        if ((!tok->previous() || tok->previous()->str() == ",") && Token::Match(tok,": %num%") && argvalue <= MathLib::toDoubleNumber(tok->strAt(1)))
+        if ((!tok->previous() || tok->strAt(-1) == ",") && Token::Match(tok,": %num%") && argvalue <= MathLib::toDoubleNumber(tok->tokAt(1)))
             return true;
+        if (Token::Match(tok, "%num%") && MathLib::isFloat(tok->str()) && MathLib::isEqual(tok->str(), MathLib::toString(argvalue)))
+            return true;
+        if (Token::Match(tok, "! %num%") && MathLib::isFloat(tok->strAt(1)))
+            return MathLib::isNotEqual(tok->strAt(1), MathLib::toString(argvalue));
     }
     return false;
 }
 
-std::string Library::getFunctionName(const Token *ftok, bool *error) const
+std::string Library::getFunctionName(const Token *ftok, bool &error) const
 {
     if (!ftok) {
-        *error = true;
+        error = true;
         return "";
     }
     if (ftok->isName()) {
+        if (Token::simpleMatch(ftok->astParent(), "::"))
+            return ftok->str();
         for (const Scope *scope = ftok->scope(); scope; scope = scope->nestedIn) {
             if (!scope->isClassOrStruct())
                 continue;
             const std::vector<Type::BaseInfo> &derivedFrom = scope->definedType->derivedFrom;
             for (const Type::BaseInfo & baseInfo : derivedFrom) {
-                const std::string name(baseInfo.name + "::" + ftok->str());
-                if (functions.find(name) != functions.end() && matchArguments(ftok, name))
+                std::string name;
+                const Token* tok = baseInfo.nameTok; // baseInfo.name still contains template parameters, but is missing namespaces
+                if (tok->str() == "::")
+                    tok = tok->next();
+                while (Token::Match(tok, "%name%|::")) {
+                    name += tok->str();
+                    tok = tok->next();
+                }
+                name += "::" + ftok->str();
+                if (mData->mFunctions.find(name) != mData->mFunctions.end() && matchArguments(ftok, name))
                     return name;
             }
         }
@@ -899,29 +1191,33 @@ std::string Library::getFunctionName(const Token *ftok, bool *error) const
         return getFunctionName(ftok->astOperand1(),error) + "::" + getFunctionName(ftok->astOperand2(),error);
     }
     if (ftok->str() == "." && ftok->astOperand1()) {
-        const std::string type = astCanonicalType(ftok->astOperand1());
+        const std::string type = astCanonicalType(ftok->astOperand1(), ftok->originalName() == "->");
         if (type.empty()) {
-            *error = true;
+            error = true;
             return "";
         }
 
         return type + "::" + getFunctionName(ftok->astOperand2(),error);
     }
-    *error = true;
+    error = true;
     return "";
 }
 
 std::string Library::getFunctionName(const Token *ftok) const
 {
-    if (!Token::Match(ftok, "%name% (") && (ftok->strAt(-1) != "&" || ftok->previous()->astOperand2()))
+    if (!Token::Match(ftok, "%name% )| (") && (ftok->strAt(-1) != "&" || ftok->previous()->astOperand2()))
         return "";
 
     // Lookup function name using AST..
     if (ftok->astParent()) {
         bool error = false;
         const Token * tok = ftok->astParent()->isUnaryOp("&") ? ftok->astParent()->astOperand1() : ftok->next()->astOperand1();
-        const std::string ret = getFunctionName(tok, &error);
-        return error ? std::string() : ret;
+        std::string ret = getFunctionName(tok, error);
+        if (error)
+            return {};
+        if (startsWith(ret, "::"))
+            ret.erase(0, 2);
+        return ret;
     }
 
     // Lookup function name without using AST..
@@ -944,46 +1240,60 @@ bool Library::isnullargbad(const Token *ftok, int argnr) const
     if (!arg) {
         // scan format string argument should not be null
         const std::string funcname = getFunctionName(ftok);
-        const std::map<std::string, Function>::const_iterator it = functions.find(funcname);
-        if (it != functions.cend() && it->second.formatstr && it->second.formatstr_scan)
+        const auto it = utils::as_const(mData->mFunctions).find(funcname);
+        if (it != mData->mFunctions.cend() && it->second.formatstr && it->second.formatstr_scan)
             return true;
     }
     return arg && arg->notnull;
 }
 
-bool Library::isuninitargbad(const Token *ftok, int argnr) const
+bool Library::isuninitargbad(const Token *ftok, int argnr, int indirect, bool *hasIndirect) const
 {
     const ArgumentChecks *arg = getarg(ftok, argnr);
     if (!arg) {
         // non-scan format string argument should not be uninitialized
         const std::string funcname = getFunctionName(ftok);
-        const std::map<std::string, Function>::const_iterator it = functions.find(funcname);
-        if (it != functions.cend() && it->second.formatstr && !it->second.formatstr_scan)
+        const auto it = utils::as_const(mData->mFunctions).find(funcname);
+        if (it != mData->mFunctions.cend() && it->second.formatstr && !it->second.formatstr_scan)
             return true;
     }
-    return arg && arg->notuninit;
+    if (hasIndirect && arg && arg->notuninit >= 1)
+        *hasIndirect = true;
+    return arg && arg->notuninit >= indirect;
 }
 
 
 /** get allocation info for function */
 const Library::AllocFunc* Library::getAllocFuncInfo(const Token *tok) const
 {
+    while (Token::simpleMatch(tok, "::"))
+        tok = tok->astOperand2() ? tok->astOperand2() : tok->astOperand1();
+    if (!tok)
+        return nullptr;
     const std::string funcname = getFunctionName(tok);
-    return isNotLibraryFunction(tok) && functions.find(funcname) != functions.end() ? nullptr : getAllocDealloc(mAlloc, funcname);
+    return isNotLibraryFunction(tok) && mData->mFunctions.find(funcname) != mData->mFunctions.end() ? nullptr : getAllocDealloc(mData->mAlloc, funcname);
 }
 
 /** get deallocation info for function */
 const Library::AllocFunc* Library::getDeallocFuncInfo(const Token *tok) const
 {
+    while (Token::simpleMatch(tok, "::"))
+        tok = tok->astOperand2() ? tok->astOperand2() : tok->astOperand1();
+    if (!tok)
+        return nullptr;
     const std::string funcname = getFunctionName(tok);
-    return isNotLibraryFunction(tok) && functions.find(funcname) != functions.end() ? nullptr : getAllocDealloc(mDealloc, funcname);
+    return isNotLibraryFunction(tok) && mData->mFunctions.find(funcname) != mData->mFunctions.end() ? nullptr : getAllocDealloc(mData->mDealloc, funcname);
 }
 
 /** get reallocation info for function */
 const Library::AllocFunc* Library::getReallocFuncInfo(const Token *tok) const
 {
+    while (Token::simpleMatch(tok, "::"))
+        tok = tok->astOperand2() ? tok->astOperand2() : tok->astOperand1();
+    if (!tok)
+        return nullptr;
     const std::string funcname = getFunctionName(tok);
-    return isNotLibraryFunction(tok) && functions.find(funcname) != functions.end() ? nullptr : getAllocDealloc(mRealloc, funcname);
+    return isNotLibraryFunction(tok) && mData->mFunctions.find(funcname) != mData->mFunctions.end() ? nullptr : getAllocDealloc(mData->mRealloc, funcname);
 }
 
 /** get allocation id for function */
@@ -1010,16 +1320,14 @@ int Library::getReallocId(const Token *tok, int arg) const
 
 const Library::ArgumentChecks * Library::getarg(const Token *ftok, int argnr) const
 {
-    if (isNotLibraryFunction(ftok))
+    const Function* func = nullptr;
+    if (isNotLibraryFunction(ftok, &func))
         return nullptr;
-    const std::map<std::string, Function>::const_iterator it1 = functions.find(getFunctionName(ftok));
-    if (it1 == functions.cend())
-        return nullptr;
-    const std::map<int,ArgumentChecks>::const_iterator it2 = it1->second.argumentChecks.find(argnr);
-    if (it2 != it1->second.argumentChecks.cend())
+    const auto it2 = func->argumentChecks.find(argnr);
+    if (it2 != func->argumentChecks.cend())
         return &it2->second;
-    const std::map<int,ArgumentChecks>::const_iterator it3 = it1->second.argumentChecks.find(-1);
-    if (it3 != it1->second.argumentChecks.cend())
+    const auto it3 = func->argumentChecks.find(-1);
+    if (it3 != func->argumentChecks.cend())
         return &it3->second;
     return nullptr;
 }
@@ -1041,6 +1349,8 @@ bool Library::isScopeNoReturn(const Token *end, std::string *unknownFunc) const
         return false;
 
     const Token *funcname = end->linkAt(-2)->previous();
+    if (funcname->isCpp() && funcname->astTop()->str() == "throw")
+        return true;
     const Token *start = funcname;
     if (Token::Match(funcname->tokAt(-3),"( * %name% )")) {
         funcname = funcname->previous();
@@ -1052,6 +1362,8 @@ bool Library::isScopeNoReturn(const Token *end, std::string *unknownFunc) const
         return false;
     }
     if (Token::Match(start,"[;{}]") && Token::Match(funcname, "%name% )| (")) {
+        if (funcname->isKeyword())
+            return false;
         if (funcname->str() == "exit")
             return true;
         if (!isnotnoreturn(funcname)) {
@@ -1063,31 +1375,90 @@ bool Library::isScopeNoReturn(const Token *end, std::string *unknownFunc) const
     return false;
 }
 
-const Library::Container* Library::detectContainer(const Token* typeStart, bool iterator) const
+// cppcheck-suppress unusedFunction - used in tests only
+const std::unordered_map<std::string, Library::Container>& Library::containers() const
+{
+    return mData->mContainers;
+}
+
+const Library::Container* Library::detectContainerInternal(const Token* const typeStart, DetectContainer detect, bool* isIterator, bool withoutStd) const
 {
-    for (std::map<std::string, Container>::const_iterator i = containers.begin(); i != containers.end(); ++i) {
-        const Container& container = i->second;
+    if (!typeStart)
+        return nullptr;
+    if (typeStart->isKeyword())
+        return nullptr;
+    const Token* firstLinkedTok = nullptr;
+    for (const Token* tok = typeStart; tok && !tok->varId(); tok = tok->next()) {
+        if (!tok->link())
+            continue;
+
+        firstLinkedTok = tok;
+        break;
+    }
+
+    const bool hasScope = typeStart->strAt(1) == "::";
+    const bool bailIfHasStd = !withoutStd && !hasScope;
+
+    for (const std::pair<const std::string, Library::Container> & c : mData->mContainers) {
+        const Container& container = c.second;
         if (container.startPattern.empty())
             continue;
 
-        if (!Token::Match(typeStart, container.startPattern2.c_str()))
+        if (bailIfHasStd && container.startPatternHasStd)
             continue;
 
-        if (!iterator && container.endPattern.empty()) // If endPattern is undefined, it will always match, but itEndPattern has to be defined.
+        const int offset = (withoutStd && container.startPatternHasStd) ? 7 : 0;
+
+        // If endPattern is undefined, it will always match, but itEndPattern has to be defined.
+        if (detect != IteratorOnly && container.endPattern.empty()) {
+            if (!Token::Match(typeStart, container.startPattern2.c_str() + offset))
+                continue;
+
+            if (isIterator)
+                *isIterator = false;
             return &container;
+        }
 
-        for (const Token* tok = typeStart; tok && !tok->varId(); tok = tok->next()) {
-            if (tok->link()) {
-                const std::string& endPattern = iterator ? container.itEndPattern : container.endPattern;
-                if (Token::Match(tok->link(), endPattern.c_str()))
-                    return &container;
-                break;
-            }
+        if (!firstLinkedTok)
+            continue;
+
+        const bool matchedStartPattern = Token::Match(typeStart, container.startPattern2.c_str() + offset);
+        if (!matchedStartPattern)
+            continue;
+
+        if (detect != ContainerOnly && Token::Match(firstLinkedTok->link(), container.itEndPattern.c_str())) {
+            if (isIterator)
+                *isIterator = true;
+            return &container;
+        }
+        if (detect != IteratorOnly && Token::Match(firstLinkedTok->link(), container.endPattern.c_str())) {
+            if (isIterator)
+                *isIterator = false;
+            return &container;
         }
     }
     return nullptr;
 }
 
+const Library::Container* Library::detectContainer(const Token* typeStart) const
+{
+    return detectContainerInternal(typeStart, ContainerOnly);
+}
+
+const Library::Container* Library::detectIterator(const Token* typeStart) const
+{
+    return detectContainerInternal(typeStart, IteratorOnly);
+}
+
+const Library::Container* Library::detectContainerOrIterator(const Token* typeStart, bool* isIterator, bool withoutStd) const
+{
+    bool res;
+    const Library::Container* c = detectContainerInternal(typeStart, Both, &res, withoutStd);
+    if (c && isIterator)
+        *isIterator = res;
+    return c;
+}
+
 bool Library::isContainerYield(const Token * const cond, Library::Container::Yield y, const std::string& fallback)
 {
     if (!cond)
@@ -1100,189 +1471,345 @@ bool Library::isContainerYield(const Token * const cond, Library::Container::Yie
                     return tok->astOperand2() && y == container->getYield(tok->astOperand2()->str());
                 }
             } else if (!fallback.empty()) {
-                return Token::simpleMatch(cond, "( )") && cond->previous()->str() == fallback;
+                return Token::simpleMatch(cond, "( )") && cond->strAt(-1) == fallback;
             }
         }
     }
     return false;
 }
 
+Library::Container::Yield Library::getContainerYield(const Token* const cond)
+{
+    if (Token::simpleMatch(cond, "(")) {
+        const Token* tok = cond->astOperand1();
+        if (tok && tok->str() == ".") {
+            if (tok->astOperand1() && tok->astOperand1()->valueType()) {
+                if (const Library::Container *container = tok->astOperand1()->valueType()->container) {
+                    if (tok->astOperand2())
+                        return container->getYield(tok->astOperand2()->str());
+                }
+            }
+        }
+    }
+    return Library::Container::Yield::NO_YIELD;
+}
+
 // returns true if ftok is not a library function
-bool Library::isNotLibraryFunction(const Token *ftok) const
+bool Library::isNotLibraryFunction(const Token *ftok, const Function **func) const
 {
-    if (ftok->function() && ftok->function()->nestedIn && ftok->function()->nestedIn->type != Scope::eGlobal)
+    if (ftok->isKeyword() || ftok->isStandardType())
+        return true;
+
+    if (ftok->function() && ftok->function()->nestedIn && ftok->function()->nestedIn->type != ScopeType::eGlobal)
         return true;
 
     // variables are not library functions.
     if (ftok->varId())
         return true;
 
-    return !matchArguments(ftok, getFunctionName(ftok));
+    return !matchArguments(ftok, getFunctionName(ftok), func);
 }
 
-bool Library::matchArguments(const Token *ftok, const std::string &functionName) const
+bool Library::matchArguments(const Token *ftok, const std::string &functionName, const Function **func) const
 {
-    const int callargs = numberOfArguments(ftok);
-    const std::map<std::string, Function>::const_iterator it = functions.find(functionName);
-    if (it == functions.cend())
-        return (callargs == 0);
+    if (functionName.empty())
+        return false;
+    const auto it = utils::as_const(mData->mFunctions).find(functionName);
+    if (it == mData->mFunctions.cend())
+        return false;
+    const int callargs = numberOfArgumentsWithoutAst(ftok);
     int args = 0;
     int firstOptionalArg = -1;
-    for (std::map<int, ArgumentChecks>::const_iterator it2 = it->second.argumentChecks.cbegin(); it2 != it->second.argumentChecks.cend(); ++it2) {
-        if (it2->first > args)
-            args = it2->first;
-        if (it2->second.optional && (firstOptionalArg == -1 || firstOptionalArg > it2->first))
-            firstOptionalArg = it2->first;
-
-        if (it2->second.formatstr || it2->second.variadic)
-            return args <= callargs;
+    for (const std::pair<const int, Library::ArgumentChecks> & argCheck : it->second.argumentChecks) {
+        args = std::max(argCheck.first, args);
+        if (argCheck.second.optional && (firstOptionalArg == -1 || firstOptionalArg > argCheck.first))
+            firstOptionalArg = argCheck.first;
+
+        if (argCheck.second.formatstr || argCheck.second.variadic) {
+            const bool b = args <= callargs;
+            if (b && func)
+                *func = &it->second;
+            return b;
+        }
     }
-    return (firstOptionalArg < 0) ? args == callargs : (callargs >= firstOptionalArg-1 && callargs <= args);
+    const bool b = (firstOptionalArg < 0) ? args == callargs : (callargs >= firstOptionalArg-1 && callargs <= args);
+    if (b && func)
+        *func = &it->second;
+    return b;
+}
+
+const std::map<std::string, Library::WarnInfo>& Library::functionwarn() const
+{
+    return mData->mFunctionwarn;
 }
 
 const Library::WarnInfo* Library::getWarnInfo(const Token* ftok) const
 {
     if (isNotLibraryFunction(ftok))
         return nullptr;
-    std::map<std::string, WarnInfo>::const_iterator i = functionwarn.find(getFunctionName(ftok));
-    if (i == functionwarn.cend())
+    const auto i = utils::as_const(mData->mFunctionwarn).find(getFunctionName(ftok));
+    if (i ==  mData->mFunctionwarn.cend())
         return nullptr;
     return &i->second;
 }
 
+bool Library::isCompliantValidationExpression(const char* p)
+{
+    if (!p || !*p)
+        return false;
+
+    bool error = false;
+    bool range = false;
+    bool has_dot = false;
+    bool has_E = false;
+
+    error = *p == '.';
+    for (; *p; p++) {
+        if (std::isdigit(*p)) {
+            error |= (*(p + 1) == '-');
+        }
+        else if (*p == ':') {
+            // cppcheck-suppress bitwiseOnBoolean - TODO: fix this
+            error |= range | (*(p + 1) == '.');
+            range = true;
+            has_dot = false;
+            has_E = false;
+        }
+        else if ((*p == '-') || (*p == '+')) {
+            error |= (!std::isdigit(*(p + 1)));
+        }
+        else if (*p == ',') {
+            range = false;
+            error |= *(p + 1) == '.';
+            has_dot = false;
+            has_E = false;
+        } else if (*p == '.') {
+            // cppcheck-suppress bitwiseOnBoolean - TODO: fix this
+            error |= has_dot | (!std::isdigit(*(p + 1)));
+            has_dot = true;
+        } else if (*p == 'E' || *p == 'e') {
+            error |= has_E;
+            has_E = true;
+        } else if (*p == '!') {
+            error |= !((*(p+1) == '-') || (*(p+1) == '+') || (std::isdigit(*(p + 1))));
+        } else
+            return false;
+    }
+    return !error;
+}
+
 bool Library::formatstr_function(const Token* ftok) const
 {
     if (isNotLibraryFunction(ftok))
         return false;
 
-    const std::map<std::string, Function>::const_iterator it = functions.find(getFunctionName(ftok));
-    if (it != functions.cend())
+    const auto it = utils::as_const(mData->mFunctions).find(getFunctionName(ftok));
+    if (it != mData->mFunctions.cend())
         return it->second.formatstr;
     return false;
 }
 
 int Library::formatstr_argno(const Token* ftok) const
 {
-    const std::map<int, Library::ArgumentChecks>& argumentChecksFunc = functions.at(getFunctionName(ftok)).argumentChecks;
-    for (std::map<int, Library::ArgumentChecks>::const_iterator i = argumentChecksFunc.cbegin(); i != argumentChecksFunc.cend(); ++i) {
-        if (i->second.formatstr) {
-            return i->first - 1;
-        }
-    }
-    return -1;
+    const std::map<int, Library::ArgumentChecks>& argumentChecksFunc = mData->mFunctions.at(getFunctionName(ftok)).argumentChecks;
+    auto it = std::find_if(argumentChecksFunc.cbegin(), argumentChecksFunc.cend(), [](const std::pair<const int, Library::ArgumentChecks>& a) {
+        return a.second.formatstr;
+    });
+    return it == argumentChecksFunc.cend() ? -1 : it->first - 1;
 }
 
 bool Library::formatstr_scan(const Token* ftok) const
 {
-    return functions.at(getFunctionName(ftok)).formatstr_scan;
+    return mData->mFunctions.at(getFunctionName(ftok)).formatstr_scan;
 }
 
 bool Library::formatstr_secure(const Token* ftok) const
 {
-    return functions.at(getFunctionName(ftok)).formatstr_secure;
+    return mData->mFunctions.at(getFunctionName(ftok)).formatstr_secure;
 }
 
-bool Library::isUseRetVal(const Token* ftok) const
+const Library::NonOverlappingData* Library::getNonOverlappingData(const Token *ftok) const
 {
     if (isNotLibraryFunction(ftok))
-        return false;
-    const std::map<std::string, Function>::const_iterator it = functions.find(getFunctionName(ftok));
-    if (it != functions.cend())
+        return nullptr;
+    const auto it = utils::as_const(mData->mNonOverlappingData).find(getFunctionName(ftok));
+    return (it != mData->mNonOverlappingData.cend()) ? &it->second : nullptr;
+}
+
+Library::UseRetValType Library::getUseRetValType(const Token *ftok) const
+{
+    if (isNotLibraryFunction(ftok)) {
+        if (Token::simpleMatch(ftok->astParent(), ".")) {
+            const Token* contTok = ftok->astParent()->astOperand1();
+            using Yield = Library::Container::Yield;
+            const Yield yield = astContainerYield(contTok, *this);
+            if (yield == Yield::START_ITERATOR || yield == Yield::END_ITERATOR || yield == Yield::AT_INDEX ||
+                yield == Yield::SIZE || yield == Yield::EMPTY || yield == Yield::BUFFER || yield == Yield::BUFFER_NT ||
+                ((yield == Yield::ITEM || yield == Yield::ITERATOR) && astContainerAction(contTok, *this) == Library::Container::Action::NO_ACTION))
+                return Library::UseRetValType::DEFAULT;
+        }
+        return Library::UseRetValType::NONE;
+    }
+    const auto it = utils::as_const(mData->mFunctions).find(getFunctionName(ftok));
+    if (it != mData->mFunctions.cend())
         return it->second.useretval;
-    return false;
+    return Library::UseRetValType::NONE;
 }
 
 const std::string& Library::returnValue(const Token *ftok) const
 {
     if (isNotLibraryFunction(ftok))
-        return emptyString;
-    const std::map<std::string, std::string>::const_iterator it = mReturnValue.find(getFunctionName(ftok));
-    return it != mReturnValue.end() ? it->second : emptyString;
+        return mEmptyString;
+    const auto it = utils::as_const(mData->mReturnValue).find(getFunctionName(ftok));
+    return it != mData->mReturnValue.cend() ? it->second : mEmptyString;
 }
 
 const std::string& Library::returnValueType(const Token *ftok) const
 {
-    if (isNotLibraryFunction(ftok))
-        return emptyString;
-    const std::map<std::string, std::string>::const_iterator it = mReturnValueType.find(getFunctionName(ftok));
-    return it != mReturnValueType.end() ? it->second : emptyString;
+    while (Token::simpleMatch(ftok, "::"))
+        ftok = ftok->astOperand2() ? ftok->astOperand2() : ftok->astOperand1();
+    if (!ftok)
+        return mEmptyString;
+    if (isNotLibraryFunction(ftok)) {
+        if (Token::simpleMatch(ftok->astParent(), ".") && ftok->astParent()->astOperand1()) {
+            const Token* contTok = ftok->astParent()->astOperand1();
+            if (contTok->valueType() && contTok->valueType()->container)
+                return contTok->valueType()->container->getReturnType(ftok->str());
+        }
+        return mEmptyString;
+    }
+    const auto it = utils::as_const(mData->mReturnValueType).find(getFunctionName(ftok));
+    return it != mData->mReturnValueType.cend() ? it->second : mEmptyString;
 }
 
 int Library::returnValueContainer(const Token *ftok) const
 {
     if (isNotLibraryFunction(ftok))
         return -1;
-    const std::map<std::string, int>::const_iterator it = mReturnValueContainer.find(getFunctionName(ftok));
-    return it != mReturnValueContainer.end() ? it->second : -1;
+    const auto it = utils::as_const(mData->mReturnValueContainer).find(getFunctionName(ftok));
+    return it != mData->mReturnValueContainer.cend() ? it->second : -1;
 }
 
 std::vector<MathLib::bigint> Library::unknownReturnValues(const Token *ftok) const
 {
     if (isNotLibraryFunction(ftok))
         return std::vector<MathLib::bigint>();
-    const std::map<std::string, std::vector<MathLib::bigint>>::const_iterator it = mUnknownReturnValues.find(getFunctionName(ftok));
-    return (it == mUnknownReturnValues.end()) ? std::vector<MathLib::bigint>() : it->second;
+    const auto it = utils::as_const(mData->mUnknownReturnValues).find(getFunctionName(ftok));
+    return (it == mData->mUnknownReturnValues.cend()) ? std::vector<MathLib::bigint>() : it->second;
 }
 
+const Library::Function *Library::getFunction(const Token *ftok) const
+{
+    if (isNotLibraryFunction(ftok))
+        return nullptr;
+    const auto it1 = utils::as_const(mData->mFunctions).find(getFunctionName(ftok));
+    if (it1 == mData->mFunctions.cend())
+        return nullptr;
+    return &it1->second;
+}
+
+
 bool Library::hasminsize(const Token *ftok) const
 {
     if (isNotLibraryFunction(ftok))
         return false;
-    const std::map<std::string, Function>::const_iterator it1 = functions.find(getFunctionName(ftok));
-    if (it1 == functions.cend())
+    const auto it = utils::as_const(mData->mFunctions).find(getFunctionName(ftok));
+    if (it == mData->mFunctions.cend())
         return false;
-    for (std::map<int, ArgumentChecks>::const_iterator it2 = it1->second.argumentChecks.cbegin(); it2 != it1->second.argumentChecks.cend(); ++it2) {
-        if (!it2->second.minsizes.empty())
-            return true;
+    return std::any_of(it->second.argumentChecks.cbegin(), it->second.argumentChecks.cend(), [](const std::pair<const int, Library::ArgumentChecks>& a) {
+        return !a.second.minsizes.empty();
+    });
+}
+
+Library::ArgumentChecks::Direction Library::getArgDirection(const Token* ftok, int argnr, int indirect) const
+{
+    const ArgumentChecks* arg = getarg(ftok, argnr);
+    if (arg) {
+        if (indirect < 0 || indirect >= arg->direction.size())
+            return ArgumentChecks::Direction::DIR_UNKNOWN; // TODO: don't generate bad indirect values
+        return arg->direction[indirect];
     }
-    return false;
+    if (formatstr_function(ftok)) {
+        const int fs_argno = formatstr_argno(ftok);
+        if (fs_argno >= 0 && argnr >= fs_argno) {
+            if (formatstr_scan(ftok))
+                return ArgumentChecks::Direction::DIR_OUT;
+            return ArgumentChecks::Direction::DIR_IN;
+        }
+    }
+    return ArgumentChecks::Direction::DIR_UNKNOWN;
 }
 
 bool Library::ignorefunction(const std::string& functionName) const
 {
-    const std::map<std::string, Function>::const_iterator it = functions.find(functionName);
-    if (it != functions.cend())
+    const auto it = utils::as_const(mData->mFunctions).find(functionName);
+    if (it != mData->mFunctions.cend())
         return it->second.ignore;
     return false;
 }
+const std::unordered_map<std::string, Library::Function>& Library::functions() const
+{
+    return mData->mFunctions;
+}
 bool Library::isUse(const std::string& functionName) const
 {
-    const std::map<std::string, Function>::const_iterator it = functions.find(functionName);
-    if (it != functions.cend())
+    const auto it = utils::as_const(mData->mFunctions).find(functionName);
+    if (it != mData->mFunctions.cend())
         return it->second.use;
     return false;
 }
 bool Library::isLeakIgnore(const std::string& functionName) const
 {
-    const  std::map<std::string, Function>::const_iterator it = functions.find(functionName);
-    if (it != functions.cend())
+    const auto it = utils::as_const(mData->mFunctions).find(functionName);
+    if (it != mData->mFunctions.cend())
         return it->second.leakignore;
     return false;
 }
 bool Library::isFunctionConst(const std::string& functionName, bool pure) const
 {
-    const std::map<std::string, Function>::const_iterator it = functions.find(functionName);
-    if (it != functions.cend())
+    const auto it = utils::as_const(mData->mFunctions).find(functionName);
+    if (it != mData->mFunctions.cend())
         return pure ? it->second.ispure : it->second.isconst;
     return false;
 }
 bool Library::isFunctionConst(const Token *ftok) const
 {
-    if (ftok->function() && ftok->function()->isAttributeConst())
+    if (ftok->function() && ftok->function()->isConst())
         return true;
-    if (isNotLibraryFunction(ftok))
+    if (isNotLibraryFunction(ftok)) {
+        if (Token::simpleMatch(ftok->astParent(), ".")) {
+            using Yield = Library::Container::Yield;
+            const Yield yield = astContainerYield(ftok->astParent()->astOperand1(), *this);
+            if (yield == Yield::EMPTY || yield == Yield::SIZE || yield == Yield::BUFFER_NT)
+                return true;
+        }
         return false;
-    const std::map<std::string, Function>::const_iterator it = functions.find(getFunctionName(ftok));
-    return (it != functions.end() && it->second.isconst);
+    }
+    const auto it = utils::as_const(mData->mFunctions).find(getFunctionName(ftok));
+    return (it != mData->mFunctions.cend() && it->second.isconst);
 }
+
 bool Library::isnoreturn(const Token *ftok) const
 {
     if (ftok->function() && ftok->function()->isAttributeNoreturn())
         return true;
-    if (isNotLibraryFunction(ftok))
+    if (ftok->variable() && ftok->variable()->nameToken()->isAttributeNoreturn())
+        return true;
+    if (isNotLibraryFunction(ftok)) {
+        if (Token::simpleMatch(ftok->astParent(), ".")) {
+            const Token* contTok = ftok->astParent()->astOperand1();
+            if (astContainerAction(contTok, *this) != Library::Container::Action::NO_ACTION ||
+                astContainerYield(contTok, *this) != Library::Container::Yield::NO_YIELD)
+                return false;
+        }
         return false;
-    const std::map<std::string, bool>::const_iterator it = mNoReturn.find(getFunctionName(ftok));
-    return (it != mNoReturn.end() && it->second);
+    }
+    const auto it = utils::as_const(mData->mNoReturn).find(getFunctionName(ftok));
+    if (it == mData->mNoReturn.end())
+        return false;
+    if (it->second == LibraryData::FalseTrueMaybe::Maybe)
+        return true;
+    return it->second == LibraryData::FalseTrueMaybe::True;
 }
 
 bool Library::isnotnoreturn(const Token *ftok) const
@@ -1290,41 +1817,45 @@ bool Library::isnotnoreturn(const Token *ftok) const
     if (ftok->function() && ftok->function()->isAttributeNoreturn())
         return false;
     if (isNotLibraryFunction(ftok))
+        return hasAnyTypeCheck(getFunctionName(ftok));
+    const auto it = utils::as_const(mData->mNoReturn).find(getFunctionName(ftok));
+    if (it == mData->mNoReturn.end())
         return false;
-    const std::map<std::string, bool>::const_iterator it = mNoReturn.find(getFunctionName(ftok));
-    return (it != mNoReturn.end() && !it->second);
+    if (it->second == LibraryData::FalseTrueMaybe::Maybe)
+        return false;
+    return it->second == LibraryData::FalseTrueMaybe::False;
 }
 
 bool Library::markupFile(const std::string &path) const
 {
-    return mMarkupExtensions.find(Path::getFilenameExtensionInLowerCase(path)) != mMarkupExtensions.end();
+    return mData->mMarkupExtensions.find(Path::getFilenameExtensionInLowerCase(path)) != mData->mMarkupExtensions.end();
 }
 
 bool Library::processMarkupAfterCode(const std::string &path) const
 {
-    const std::map<std::string, bool>::const_iterator it = mProcessAfterCode.find(Path::getFilenameExtensionInLowerCase(path));
-    return (it == mProcessAfterCode.end() || it->second);
+    const auto it = utils::as_const(mData->mProcessAfterCode).find(Path::getFilenameExtensionInLowerCase(path));
+    return (it == mData->mProcessAfterCode.cend() || it->second);
 }
 
 bool Library::reportErrors(const std::string &path) const
 {
-    const std::map<std::string, bool>::const_iterator it = mReportErrors.find(Path::getFilenameExtensionInLowerCase(path));
-    return (it == mReportErrors.end() || it->second);
+    const auto it = utils::as_const(mData->mReportErrors).find(Path::getFilenameExtensionInLowerCase(path));
+    return (it == mData->mReportErrors.cend() || it->second);
 }
 
 bool Library::isexecutableblock(const std::string &file, const std::string &token) const
 {
-    const std::map<std::string, CodeBlock>::const_iterator it = mExecutableBlocks.find(Path::getFilenameExtensionInLowerCase(file));
-    return (it != mExecutableBlocks.end() && it->second.isBlock(token));
+    const auto it = utils::as_const(mData->mExecutableBlocks).find(Path::getFilenameExtensionInLowerCase(file));
+    return (it != mData->mExecutableBlocks.cend() && it->second.isBlock(token));
 }
 
 int Library::blockstartoffset(const std::string &file) const
 {
     int offset = -1;
-    const std::map<std::string, CodeBlock>::const_iterator map_it
-        = mExecutableBlocks.find(Path::getFilenameExtensionInLowerCase(file));
+    const auto map_it
+        = utils::as_const(mData->mExecutableBlocks).find(Path::getFilenameExtensionInLowerCase(file));
 
-    if (map_it != mExecutableBlocks.end()) {
+    if (map_it != mData->mExecutableBlocks.end()) {
         offset = map_it->second.offset();
     }
     return offset;
@@ -1332,51 +1863,123 @@ int Library::blockstartoffset(const std::string &file) const
 
 const std::string& Library::blockstart(const std::string &file) const
 {
-    const std::map<std::string, CodeBlock>::const_iterator map_it
-        = mExecutableBlocks.find(Path::getFilenameExtensionInLowerCase(file));
+    const auto map_it
+        = utils::as_const(mData->mExecutableBlocks).find(Path::getFilenameExtensionInLowerCase(file));
 
-    if (map_it != mExecutableBlocks.end()) {
+    if (map_it != mData->mExecutableBlocks.end()) {
         return map_it->second.start();
     }
-    return emptyString;
+    return mEmptyString;
 }
 
 const std::string& Library::blockend(const std::string &file) const
 {
-    const std::map<std::string, CodeBlock>::const_iterator map_it
-        = mExecutableBlocks.find(Path::getFilenameExtensionInLowerCase(file));
+    const auto map_it
+        = utils::as_const(mData->mExecutableBlocks).find(Path::getFilenameExtensionInLowerCase(file));
 
-    if (map_it != mExecutableBlocks.end()) {
+    if (map_it != mData->mExecutableBlocks.end()) {
         return map_it->second.end();
     }
-    return emptyString;
+    return mEmptyString;
 }
 
 bool Library::iskeyword(const std::string &file, const std::string &keyword) const
 {
-    const std::map<std::string, std::set<std::string> >::const_iterator it =
-        mKeywords.find(Path::getFilenameExtensionInLowerCase(file));
-    return (it != mKeywords.end() && it->second.count(keyword));
+    const auto it =
+        utils::as_const(mData->mKeywords).find(Path::getFilenameExtensionInLowerCase(file));
+    return (it != mData->mKeywords.end() && it->second.count(keyword));
 }
 
 bool Library::isimporter(const std::string& file, const std::string &importer) const
 {
-    const std::map<std::string, std::set<std::string> >::const_iterator it =
-        mImporters.find(Path::getFilenameExtensionInLowerCase(file));
-    return (it != mImporters.end() && it->second.count(importer) > 0);
+    const auto it =
+        utils::as_const(mData->mImporters).find(Path::getFilenameExtensionInLowerCase(file));
+    return (it != mData->mImporters.end() && it->second.count(importer) > 0);
 }
 
-bool Library::isSmartPointer(const Token *tok) const
+const Token* Library::getContainerFromYield(const Token* tok, Library::Container::Yield yield) const
 {
-    std::string typestr;
-    while (Token::Match(tok, "%name%|::")) {
-        typestr += tok->str();
+    if (!tok)
+        return nullptr;
+    if (Token::Match(tok->tokAt(-2), ". %name% (")) {
+        const Token* containerTok = tok->tokAt(-2)->astOperand1();
+        if (!astIsContainer(containerTok))
+            return nullptr;
+        if (containerTok->valueType()->container &&
+            containerTok->valueType()->container->getYield(tok->strAt(-1)) == yield)
+            return containerTok;
+        if (yield == Library::Container::Yield::EMPTY && Token::simpleMatch(tok->tokAt(-1), "empty ( )"))
+            return containerTok;
+        if (yield == Library::Container::Yield::SIZE && Token::Match(tok->tokAt(-1), "size|length ( )"))
+            return containerTok;
+    } else if (Token::Match(tok->previous(), "%name% (")) {
+        if (const Library::Function* f = this->getFunction(tok->previous())) {
+            if (f->containerYield == yield) {
+                return tok->astOperand2();
+            }
+        }
+    }
+    return nullptr;
+}
+
+// cppcheck-suppress unusedFunction
+const Token* Library::getContainerFromAction(const Token* tok, Library::Container::Action action) const
+{
+    if (!tok)
+        return nullptr;
+    if (Token::Match(tok->tokAt(-2), ". %name% (")) {
+        const Token* containerTok = tok->tokAt(-2)->astOperand1();
+        if (!astIsContainer(containerTok))
+            return nullptr;
+        if (containerTok->valueType()->container &&
+            containerTok->valueType()->container->getAction(tok->strAt(-1)) == action)
+            return containerTok;
+        if (Token::simpleMatch(tok->tokAt(-1), "empty ( )"))
+            return containerTok;
+    } else if (Token::Match(tok->previous(), "%name% (")) {
+        if (const Library::Function* f = this->getFunction(tok->previous())) {
+            if (f->containerAction == action) {
+                return tok->astOperand2();
+            }
+        }
+    }
+    return nullptr;
+}
+
+const std::unordered_map<std::string, Library::SmartPointer>& Library::smartPointers() const
+{
+    return mData->mSmartPointers;
+}
+
+bool Library::isSmartPointer(const Token* tok) const
+{
+    return detectSmartPointer(tok);
+}
+
+const Library::SmartPointer* Library::detectSmartPointer(const Token* tok, bool withoutStd) const
+{
+    if (!tok)
+        return nullptr;
+    if (tok->isKeyword())
+        return nullptr;
+    std::string typestr = withoutStd ? "std::" : "";
+    if (tok->str() == "::")
         tok = tok->next();
+    while (Token::Match(tok, "%name% ::")) {
+        typestr += tok->str();
+        typestr += "::";
+        tok = tok->tokAt(2);
     }
-    return smartPointers.find(typestr) != smartPointers.end();
+    if (tok && tok->isName()) {
+        typestr += tok->str();
+    }
+    auto it = mData->mSmartPointers.find(typestr);
+    if (it == mData->mSmartPointers.end())
+        return nullptr;
+    return &it->second;
 }
 
-CPPCHECKLIB const Library::Container * getLibraryContainer(const Token * tok)
+const Library::Container * getLibraryContainer(const Token * tok)
 {
     if (!tok)
         return nullptr;
@@ -1396,3 +1999,102 @@ CPPCHECKLIB const Library::Container * getLibraryContainer(const Token * tok)
     return tok->valueType()->container;
 }
 
+Library::TypeCheck Library::getTypeCheck(std::string check,  std::string typeName) const
+{
+    auto it = mData->mTypeChecks.find(std::pair<std::string, std::string>(std::move(check), std::move(typeName)));
+    return it == mData->mTypeChecks.end() ? TypeCheck::def : it->second;
+}
+
+bool Library::hasAnyTypeCheck(const std::string& typeName) const
+{
+    return std::any_of(mData->mTypeChecks.begin(), mData->mTypeChecks.end(), [&](const std::pair<const std::pair<std::string, std::string>, Library::TypeCheck>& tc) {
+        return tc.first.second == typeName;
+    });
+}
+
+const Library::AllocFunc* Library::getAllocFuncInfo(const char name[]) const
+{
+    return getAllocDealloc(mData->mAlloc, name);
+}
+
+const Library::AllocFunc* Library::getDeallocFuncInfo(const char name[]) const
+{
+    return getAllocDealloc(mData->mDealloc, name);
+}
+
+// cppcheck-suppress unusedFunction
+int Library::allocId(const char name[]) const
+{
+    const AllocFunc* af = getAllocDealloc(mData->mAlloc, name);
+    return af ? af->groupId : 0;
+}
+
+int Library::deallocId(const char name[]) const
+{
+    const AllocFunc* af = getAllocDealloc(mData->mDealloc, name);
+    return af ? af->groupId : 0;
+}
+
+const std::set<std::string> &Library::markupExtensions() const
+{
+    return mData->mMarkupExtensions;
+}
+
+bool Library::isexporter(const std::string &prefix) const
+{
+    return mData->mExporters.find(prefix) != mData->mExporters.end();
+}
+
+bool Library::isexportedprefix(const std::string &prefix, const std::string &token) const
+{
+    const auto it = utils::as_const(mData->mExporters).find(prefix);
+    return (it != mData->mExporters.end() && it->second.isPrefix(token));
+}
+
+bool Library::isexportedsuffix(const std::string &prefix, const std::string &token) const
+{
+    const auto it = utils::as_const(mData->mExporters).find(prefix);
+    return (it != mData->mExporters.end() && it->second.isSuffix(token));
+}
+
+bool Library::isreflection(const std::string &token) const
+{
+    return mData->mReflection.find(token) != mData->mReflection.end();
+}
+
+int Library::reflectionArgument(const std::string &token) const
+{
+    const auto it = utils::as_const(mData->mReflection).find(token);
+    if (it != mData->mReflection.end())
+        return it->second;
+    return -1;
+}
+
+bool Library::isentrypoint(const std::string &func) const
+{
+    return func == "main" || mData->mEntrypoints.find(func) != mData->mEntrypoints.end();
+}
+
+const std::set<std::string>& Library::defines() const
+{
+    return mData->mDefines;
+}
+
+const Library::PodType *Library::podtype(const std::string &name) const
+{
+    const auto it = utils::as_const(mData->mPodTypes).find(name);
+    return (it != mData->mPodTypes.end()) ? &(it->second) : nullptr;
+}
+
+const Library::PlatformType *Library::platform_type(const std::string &name, const std::string & platform) const
+{
+    const auto it = utils::as_const(mData->mPlatforms).find(platform);
+    if (it != mData->mPlatforms.end()) {
+        const PlatformType * const type = it->second.platform_type(name);
+        if (type)
+            return type;
+    }
+
+    const auto it2 = utils::as_const(mData->mPlatformTypes).find(name);
+    return (it2 != mData->mPlatformTypes.end()) ? &(it2->second) : nullptr;
+}
diff --git a/lib/library.h b/lib/library.h
index f195ed5005e..709a0db2b90 100644
--- a/lib/library.h
+++ b/lib/library.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,18 +22,21 @@
 //---------------------------------------------------------------------------
 
 #include "config.h"
-#include "errorlogger.h"
 #include "mathlib.h"
 #include "standards.h"
 
-#include <cstddef>
+#include <array>
+#include <cstdint>
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
-#include <utility>
+#include <unordered_map>
 #include <vector>
 
 class Token;
+class Settings; // TODO: remove dependency on settings
+enum class Severity : std::uint8_t;
 
 namespace tinyxml2 {
     class XMLDocument;
@@ -47,37 +50,45 @@ namespace tinyxml2 {
  * @brief Library definitions handling
  */
 class CPPCHECKLIB Library {
-    friend class TestSymbolDatabase; // For testing only
+    friend struct LibraryHelper; // for testing
+
+    static const std::string mEmptyString;
 
 public:
     Library();
+    ~Library();
+
+    Library(const Library& other);
+    Library& operator=(const Library& other) &;
 
-    enum ErrorCode { OK, FILE_NOT_FOUND, BAD_XML, UNKNOWN_ELEMENT, MISSING_ATTRIBUTE, BAD_ATTRIBUTE_VALUE, UNSUPPORTED_FORMAT, DUPLICATE_PLATFORM_TYPE, PLATFORM_TYPE_REDEFINED };
+    enum class ErrorCode : std::uint8_t {
+        OK,
+        FILE_NOT_FOUND, BAD_XML, UNKNOWN_ELEMENT, MISSING_ATTRIBUTE, BAD_ATTRIBUTE_VALUE,
+        UNSUPPORTED_FORMAT, DUPLICATE_PLATFORM_TYPE, PLATFORM_TYPE_REDEFINED, DUPLICATE_DEFINE
+    };
 
     class Error {
     public:
-        Error() : errorcode(OK) {}
+        Error() : errorcode(ErrorCode::OK) {}
         explicit Error(ErrorCode e) : errorcode(e) {}
         template<typename T>
         Error(ErrorCode e, T&& r) : errorcode(e), reason(r) {}
-        ErrorCode     errorcode;
-        std::string   reason;
+        ErrorCode errorcode;
+        std::string reason;
     };
 
-    Error load(const char exename [], const char path []);
-    Error load(const tinyxml2::XMLDocument &doc);
-
-    /** this is primarily meant for unit tests. it only returns true/false */
-    bool loadxmldata(const char xmldata[], std::size_t len);
+    Error load(const char exename[], const char path[], bool debug = false);
 
     struct AllocFunc {
-        int groupId;
-        int arg;
-        enum class BufferSize {none,malloc,calloc,strdup};
-        BufferSize bufferSize;
-        int bufferSizeArg1;
-        int bufferSizeArg2;
-        int reallocArg;
+        int groupId{};
+        int arg{};
+        enum class BufferSize : std::uint8_t {none,malloc,calloc,strdup};
+        BufferSize bufferSize{BufferSize::none};
+        int bufferSizeArg1{};
+        int bufferSizeArg2{};
+        int reallocArg{};
+        bool initData{};
+        bool noFail{};
     };
 
     /** get allocation info for function */
@@ -98,56 +109,30 @@ class CPPCHECKLIB Library {
     /** get reallocation id for function */
     int getReallocId(const Token *tok, int arg) const;
 
+    // TODO: get rid of this
     /** get allocation info for function by name (deprecated, use other alloc) */
-    const AllocFunc* getAllocFuncInfo(const char name[]) const {
-        return getAllocDealloc(mAlloc, name);
-    }
+    const AllocFunc* getAllocFuncInfo(const char name[]) const;
 
+    // TODO: get rid of this
     /** get deallocation info for function by name (deprecated, use other alloc) */
-    const AllocFunc* getDeallocFuncInfo(const char name[]) const {
-        return getAllocDealloc(mDealloc, name);
-    }
+    const AllocFunc* getDeallocFuncInfo(const char name[]) const;
 
+    // TODO: get rid of this
     /** get allocation id for function by name (deprecated, use other alloc) */
-    int allocId(const char name[]) const {
-        const AllocFunc* af = getAllocDealloc(mAlloc, name);
-        return af ? af->groupId : 0;
-    }
+    int allocId(const char name[]) const;
 
+    // TODO: get rid of this
     /** get deallocation id for function by name (deprecated, use other alloc) */
-    int deallocId(const char name[]) const {
-        const AllocFunc* af = getAllocDealloc(mDealloc, name);
-        return af ? af->groupId : 0;
-    }
+    int deallocId(const char name[]) const;
 
-    /** set allocation id for function */
-    void setalloc(const std::string &functionname, int id, int arg) {
-        mAlloc[functionname].groupId = id;
-        mAlloc[functionname].arg = arg;
-    }
-
-    void setdealloc(const std::string &functionname, int id, int arg) {
-        mDealloc[functionname].groupId = id;
-        mDealloc[functionname].arg = arg;
-    }
-
-    void setrealloc(const std::string &functionname, int id, int arg, int reallocArg = 1) {
-        mRealloc[functionname].groupId = id;
-        mRealloc[functionname].arg = arg;
-        mRealloc[functionname].reallocArg = reallocArg;
-    }
-
-    /** add noreturn function setting */
-    void setnoreturn(const std::string& funcname, bool noreturn) {
-        mNoReturn[funcname] = noreturn;
-    }
+    static bool isCompliantValidationExpression(const char* p);
 
     /** is allocation type memory? */
     static bool ismemory(const int id) {
         return ((id > 0) && ((id & 1) == 0));
     }
     static bool ismemory(const AllocFunc* const func) {
-        return ((func->groupId > 0) && ((func->groupId & 1) == 0));
+        return func && (func->groupId > 0) && ((func->groupId & 1) == 0);
     }
 
     /** is allocation type resource? */
@@ -155,7 +140,7 @@ class CPPCHECKLIB Library {
         return ((id > 0) && ((id & 1) == 1));
     }
     static bool isresource(const AllocFunc* const func) {
-        return ((func->groupId > 0) && ((func->groupId & 1) == 1));
+        return func && (func->groupId > 0) && ((func->groupId & 1) == 1);
     }
 
     bool formatstr_function(const Token* ftok) const;
@@ -163,20 +148,32 @@ class CPPCHECKLIB Library {
     bool formatstr_scan(const Token* ftok) const;
     bool formatstr_secure(const Token* ftok) const;
 
+    struct NonOverlappingData {
+        int ptr1Arg;
+        int ptr2Arg;
+        int sizeArg;
+        int strlenArg;
+        int countArg;
+    };
+    const NonOverlappingData* getNonOverlappingData(const Token *ftok) const;
+
     struct WarnInfo {
         std::string message;
         Standards standards;
-        Severity::SeverityType severity;
+        Severity severity;
     };
-    std::map<std::string, WarnInfo> functionwarn;
+    const std::map<std::string, WarnInfo>& functionwarn() const;
 
     const WarnInfo* getWarnInfo(const Token* ftok) const;
 
+    struct Function;
+
     // returns true if ftok is not a library function
-    bool isNotLibraryFunction(const Token *ftok) const;
-    bool matchArguments(const Token *ftok, const std::string &functionName) const;
+    bool isNotLibraryFunction(const Token *ftok, const Function **func = nullptr) const;
+    bool matchArguments(const Token *ftok, const std::string &functionName, const Function **func = nullptr) const;
 
-    bool isUseRetVal(const Token* ftok) const;
+    enum class UseRetValType : std::uint8_t { NONE, DEFAULT, ERROR_CODE };
+    UseRetValType getUseRetValType(const Token* ftok) const;
 
     const std::string& returnValue(const Token *ftok) const;
     const std::string& returnValueType(const Token *ftok) const;
@@ -190,123 +187,145 @@ class CPPCHECKLIB Library {
 
     class Container {
     public:
-        Container() :
-            type_templateArgNo(-1),
-            size_templateArgNo(-1),
-            arrayLike_indexOp(false),
-            stdStringLike(false),
-            stdAssociativeLike(false),
-            opLessAllowed(true) {
-        }
-
-        enum class Action {
-            RESIZE, CLEAR, PUSH, POP, FIND, INSERT, ERASE, CHANGE_CONTENT, CHANGE, CHANGE_INTERNAL,
+        Container() = default;
+
+        enum class Action : std::uint8_t {
+            RESIZE,
+            CLEAR,
+            PUSH,
+            POP,
+            FIND,
+            FIND_CONST,
+            INSERT,
+            ERASE,
+            APPEND,
+            CHANGE_CONTENT,
+            CHANGE,
+            CHANGE_INTERNAL,
             NO_ACTION
         };
-        enum class Yield {
-            AT_INDEX, ITEM, BUFFER, BUFFER_NT, START_ITERATOR, END_ITERATOR, ITERATOR, SIZE, EMPTY,
+        enum class Yield : std::uint8_t {
+            AT_INDEX,
+            ITEM,
+            BUFFER,
+            BUFFER_NT,
+            START_ITERATOR,
+            END_ITERATOR,
+            ITERATOR,
+            SIZE,
+            EMPTY,
             NO_YIELD
         };
         struct Function {
             Action action;
             Yield yield;
+            std::string returnType;
+        };
+        struct RangeItemRecordTypeItem {
+            std::string name;
+            int templateParameter; // TODO: use this
         };
         std::string startPattern, startPattern2, endPattern, itEndPattern;
         std::map<std::string, Function> functions;
-        int type_templateArgNo;
-        int size_templateArgNo;
-        bool arrayLike_indexOp;
-        bool stdStringLike;
-        bool stdAssociativeLike;
-        bool opLessAllowed;
+        int type_templateArgNo = -1;
+        std::vector<RangeItemRecordTypeItem> rangeItemRecordType;
+        int size_templateArgNo = -1;
+        bool arrayLike_indexOp{};
+        bool stdStringLike{};
+        bool stdAssociativeLike{};
+        bool opLessAllowed = true;
+        bool hasInitializerListConstructor{};
+        bool unstableErase{};
+        bool unstableInsert{};
+        bool view{};
+        bool startPatternHasStd{};
 
         Action getAction(const std::string& function) const {
-            const std::map<std::string, Function>::const_iterator i = functions.find(function);
+            const auto i = functions.find(function);
             if (i != functions.end())
                 return i->second.action;
             return Action::NO_ACTION;
         }
 
         Yield getYield(const std::string& function) const {
-            const std::map<std::string, Function>::const_iterator i = functions.find(function);
+            const auto i = functions.find(function);
             if (i != functions.end())
                 return i->second.yield;
             return Yield::NO_YIELD;
         }
-    };
-    std::map<std::string, Container> containers;
-    const Container* detectContainer(const Token* typeStart, bool iterator = false) const;
 
-    class ArgumentChecks {
-    public:
-        ArgumentChecks() :
-            notbool(false),
-            notnull(false),
-            notuninit(false),
-            formatstr(false),
-            strz(false),
-            optional(false),
-            variadic(false),
-            iteratorInfo(),
-            direction(Direction::DIR_UNKNOWN) {
+        const std::string& getReturnType(const std::string& function) const {
+            const auto i = functions.find(function);
+            return (i != functions.end()) ? i->second.returnType : mEmptyString;
         }
 
-        bool         notbool;
-        bool         notnull;
-        bool         notuninit;
-        bool         formatstr;
-        bool         strz;
-        bool         optional;
-        bool         variadic;
-        std::string  valid;
-
-        class IteratorInfo {
-        public:
-            IteratorInfo() : container(0), it(false), first(false), last(false) {}
-
-            int  container;
-            bool it;
-            bool first;
-            bool last;
+        CPPCHECKLIB static Yield yieldFrom(const std::string& yieldName);
+        CPPCHECKLIB static Action actionFrom(const std::string& actionName);
+        CPPCHECKLIB static std::string toString(Yield yield);
+        CPPCHECKLIB static std::string toString(Action action);
+    };
+    const std::unordered_map<std::string, Container>& containers() const;
+    const Container* detectContainer(const Token* typeStart) const;
+    const Container* detectIterator(const Token* typeStart) const;
+    const Container* detectContainerOrIterator(const Token* typeStart, bool* isIterator = nullptr, bool withoutStd = false) const;
+
+    struct ArgumentChecks {
+        bool notbool{};
+        bool notnull{};
+        int notuninit = -1;
+        bool formatstr{};
+        bool strz{};
+        bool optional{};
+        bool variadic{};
+        std::string valid;
+
+        struct IteratorInfo {
+            int container{};
+            bool it{};
+            bool first{};
+            bool last{};
         };
         IteratorInfo iteratorInfo;
 
-        class MinSize {
-        public:
-            enum Type { NONE, STRLEN, ARGVALUE, SIZEOF, MUL, VALUE };
-            MinSize(Type t, int a) : type(t), arg(a), arg2(0), value(0) {}
+        struct MinSize {
+            enum class Type : std::uint8_t { NONE, STRLEN, ARGVALUE, SIZEOF, MUL, VALUE };
+            MinSize(Type t, int a) : type(t), arg(a) {}
             Type type;
             int arg;
-            int arg2;
-            long long value;
+            int arg2 = 0;
+            long long value = 0;
+            std::string baseType;
         };
         std::vector<MinSize> minsizes;
 
-        enum class Direction {
+        enum class Direction : std::uint8_t {
             DIR_IN,     ///< Input to called function. Data is treated as read-only.
             DIR_OUT,    ///< Output to caller. Data is passed by reference or address and is potentially written.
             DIR_INOUT,  ///< Input to called function, and output to caller. Data is passed by reference or address and is potentially modified.
             DIR_UNKNOWN ///< direction not known / specified
         };
-        Direction direction;
+        // argument directions up to ** indirect level (only one can be configured explicitly at the moment)
+        std::array<Direction, 3> direction = { { Direction::DIR_UNKNOWN, Direction::DIR_UNKNOWN, Direction::DIR_UNKNOWN } };
     };
 
-
     struct Function {
         std::map<int, ArgumentChecks> argumentChecks; // argument nr => argument data
-        bool use;
-        bool leakignore;
-        bool isconst;
-        bool ispure;
-        bool useretval;
-        bool ignore;  // ignore functions/macros from a library (gtk, qt etc)
-        bool formatstr;
-        bool formatstr_scan;
-        bool formatstr_secure;
-        Function() : use(false), leakignore(false), isconst(false), ispure(false), useretval(false), ignore(false), formatstr(false), formatstr_scan(false), formatstr_secure(false) {}
+        bool use{};
+        bool leakignore{};
+        bool isconst{};
+        bool ispure{};
+        UseRetValType useretval = UseRetValType::NONE;
+        bool ignore{};  // ignore functions/macros from a library (gtk, qt etc)
+        bool formatstr{};
+        bool formatstr_scan{};
+        bool formatstr_secure{};
+        Container::Action containerAction = Container::Action::NO_ACTION;
+        Container::Yield containerYield = Container::Yield::NO_YIELD;
+        std::string returnType;
     };
 
-    std::map<std::string, Function> functions;
+    const Function *getFunction(const Token *ftok) const;
+    const std::unordered_map<std::string, Function>& functions() const;
     bool isUse(const std::string& functionName) const;
     bool isLeakIgnore(const std::string& functionName) const;
     bool isFunctionConst(const std::string& functionName, bool pure) const;
@@ -318,7 +337,7 @@ class CPPCHECKLIB Library {
     }
 
     bool isnullargbad(const Token *ftok, int argnr) const;
-    bool isuninitargbad(const Token *ftok, int argnr) const;
+    bool isuninitargbad(const Token *ftok, int argnr, int indirect = 0, bool *hasIndirect=nullptr) const;
 
     bool isargformatstr(const Token *ftok, int argnr) const {
         const ArgumentChecks *arg = getarg(ftok, argnr);
@@ -330,12 +349,12 @@ class CPPCHECKLIB Library {
         return arg && arg->strz;
     }
 
-    bool isIntArgValid(const Token *ftok, int argnr, const MathLib::bigint argvalue) const;
-    bool isFloatArgValid(const Token *ftok, int argnr, double argvalue) const;
+    bool isIntArgValid(const Token *ftok, int argnr, MathLib::bigint argvalue, const Settings& settings) const;
+    bool isFloatArgValid(const Token *ftok, int argnr, double argvalue, const Settings& settings) const;
 
     const std::string& validarg(const Token *ftok, int argnr) const {
         const ArgumentChecks *arg = getarg(ftok, argnr);
-        return arg ? arg->valid : emptyString;
+        return arg ? arg->valid : mEmptyString;
     }
 
     const ArgumentChecks::IteratorInfo *getArgIteratorInfo(const Token *ftok, int argnr) const {
@@ -350,18 +369,13 @@ class CPPCHECKLIB Library {
         return arg ? &arg->minsizes : nullptr;
     }
 
-    ArgumentChecks::Direction getArgDirection(const Token *ftok, int argnr) const {
-        const ArgumentChecks *arg = getarg(ftok, argnr);
-        return arg ? arg->direction : ArgumentChecks::Direction::DIR_UNKNOWN;
-    }
+    ArgumentChecks::Direction getArgDirection(const Token* ftok, int argnr, int indirect = 0) const;
 
     bool markupFile(const std::string &path) const;
 
     bool processMarkupAfterCode(const std::string &path) const;
 
-    const std::set<std::string> &markupExtensions() const {
-        return mMarkupExtensions;
-    }
+    const std::set<std::string> &markupExtensions() const;
 
     bool reportErrors(const std::string &path) const;
 
@@ -376,194 +390,103 @@ class CPPCHECKLIB Library {
 
     bool iskeyword(const std::string &file, const std::string &keyword) const;
 
-    bool isexporter(const std::string &prefix) const {
-        return mExporters.find(prefix) != mExporters.end();
-    }
+    bool isexporter(const std::string &prefix) const;
 
-    bool isexportedprefix(const std::string &prefix, const std::string &token) const {
-        const std::map<std::string, ExportedFunctions>::const_iterator it = mExporters.find(prefix);
-        return (it != mExporters.end() && it->second.isPrefix(token));
-    }
+    bool isexportedprefix(const std::string &prefix, const std::string &token) const;
 
-    bool isexportedsuffix(const std::string &prefix, const std::string &token) const {
-        const std::map<std::string, ExportedFunctions>::const_iterator it = mExporters.find(prefix);
-        return (it != mExporters.end() && it->second.isSuffix(token));
-    }
+    bool isexportedsuffix(const std::string &prefix, const std::string &token) const;
 
     bool isimporter(const std::string& file, const std::string &importer) const;
 
-    bool isreflection(const std::string &token) const {
-        return mReflection.find(token) != mReflection.end();
-    }
+    const Token* getContainerFromYield(const Token* tok, Container::Yield yield) const;
+    const Token* getContainerFromAction(const Token* tok, Container::Action action) const;
 
-    int reflectionArgument(const std::string &token) const {
-        const std::map<std::string, int>::const_iterator it = mReflection.find(token);
-        if (it != mReflection.end())
-            return it->second;
-        return -1;
-    }
+    static bool isContainerYield(const Token* cond, Library::Container::Yield y, const std::string& fallback = "");
+    static Library::Container::Yield getContainerYield(const Token* cond);
+
+    bool isreflection(const std::string &token) const;
 
-    std::set<std::string> returnuninitdata;
-    std::vector<std::string> defines; // to provide some library defines
+    int reflectionArgument(const std::string &token) const;
 
-    std::set<std::string> smartPointers;
+    bool isentrypoint(const std::string &func) const;
+
+    const std::set<std::string>& defines() const; // to provide some library defines
+
+    struct SmartPointer {
+        std::string name;
+        bool unique = false;
+    };
+
+    const std::unordered_map<std::string, SmartPointer>& smartPointers() const;
     bool isSmartPointer(const Token *tok) const;
+    const SmartPointer* detectSmartPointer(const Token* tok, bool withoutStd = false) const;
 
     struct PodType {
-        unsigned int   size;
-        char           sign;
-        enum { NO, BOOL, CHAR, SHORT, INT, LONG, LONGLONG } stdtype;
+        unsigned int size{};
+        char sign{};
+        enum class Type : std::uint8_t { NO, BOOL, CHAR, SHORT, INT, LONG, LONGLONG } stdtype = Type::NO;
     };
-    const struct PodType *podtype(const std::string &name) const {
-        const std::map<std::string, struct PodType>::const_iterator it = mPodTypes.find(name);
-        return (it != mPodTypes.end()) ? &(it->second) : nullptr;
-    }
+    const PodType *podtype(const std::string &name) const;
 
     struct PlatformType {
-        PlatformType()
-            : _signed(false)
-            , _unsigned(false)
-            , _long(false)
-            , _pointer(false)
-            , _ptr_ptr(false)
-            , _const_ptr(false) {
-        }
         bool operator == (const PlatformType & type) const {
-            return (_signed == type._signed &&
-                    _unsigned == type._unsigned &&
-                    _long == type._long &&
-                    _pointer == type._pointer &&
-                    _ptr_ptr == type._ptr_ptr &&
-                    _const_ptr == type._const_ptr &&
+            return (mSigned == type.mSigned &&
+                    mUnsigned == type.mUnsigned &&
+                    mLong == type.mLong &&
+                    mPointer == type.mPointer &&
+                    mPtrPtr == type.mPtrPtr &&
+                    mConstPtr == type.mConstPtr &&
                     mType == type.mType);
         }
         bool operator != (const PlatformType & type) const {
             return !(*this == type);
         }
         std::string mType;
-        bool _signed;
-        bool _unsigned;
-        bool _long;
-        bool _pointer;
-        bool _ptr_ptr;
-        bool _const_ptr;
-    };
-
-    struct Platform {
-        const PlatformType *platform_type(const std::string &name) const {
-            const std::map<std::string, struct PlatformType>::const_iterator it = mPlatformTypes.find(name);
-            return (it != mPlatformTypes.end()) ? &(it->second) : nullptr;
-        }
-        std::map<std::string, PlatformType> mPlatformTypes;
+        bool mSigned{};
+        bool mUnsigned{};
+        bool mLong{};
+        bool mPointer{};
+        bool mPtrPtr{};
+        bool mConstPtr{};
     };
 
-    const PlatformType *platform_type(const std::string &name, const std::string & platform) const {
-        const std::map<std::string, Platform>::const_iterator it = mPlatforms.find(platform);
-        if (it != mPlatforms.end()) {
-            const PlatformType * const type = it->second.platform_type(name);
-            if (type)
-                return type;
-        }
-
-        const std::map<std::string, PlatformType>::const_iterator it2 = mPlatformTypes.find(name);
-        return (it2 != mPlatformTypes.end()) ? &(it2->second) : nullptr;
-    }
+    const PlatformType *platform_type(const std::string &name, const std::string & platform) const;
 
     /**
      * Get function name for function call
      */
     std::string getFunctionName(const Token *ftok) const;
 
-    static bool isContainerYield(const Token * const cond, Library::Container::Yield y, const std::string& fallback="");
+    /** Suppress/check a type */
+    enum class TypeCheck : std::uint8_t {
+        def,
+        check,
+        suppress,
+        checkFiniteLifetime, // (unusedvar) object has side effects, but immediate destruction is wrong
+    };
+    TypeCheck getTypeCheck(std::string check, std::string typeName) const;
+    bool hasAnyTypeCheck(const std::string& typeName) const;
 
 private:
-    // load a <function> xml node
-    Error loadFunction(const tinyxml2::XMLElement * const node, const std::string &name, std::set<std::string> &unknown_elements);
-
-    class ExportedFunctions {
-    public:
-        void addPrefix(const std::string& prefix) {
-            mPrefixes.insert(prefix);
-        }
-        void addSuffix(const std::string& suffix) {
-            mSuffixes.insert(suffix);
-        }
-        bool isPrefix(const std::string& prefix) const {
-            return (mPrefixes.find(prefix) != mPrefixes.end());
-        }
-        bool isSuffix(const std::string& suffix) const {
-            return (mSuffixes.find(suffix) != mSuffixes.end());
-        }
-
-    private:
-        std::set<std::string> mPrefixes;
-        std::set<std::string> mSuffixes;
-    };
-    class CodeBlock {
-    public:
-        CodeBlock() : mOffset(0) {}
+    Error load(const tinyxml2::XMLDocument &doc);
 
-        void setStart(const char* s) {
-            mStart = s;
-        }
-        void setEnd(const char* e) {
-            mEnd = e;
-        }
-        void setOffset(const int o) {
-            mOffset = o;
-        }
-        void addBlock(const char* blockName) {
-            mBlocks.insert(blockName);
-        }
-        const std::string& start() const {
-            return mStart;
-        }
-        const std::string& end() const {
-            return mEnd;
-        }
-        int offset() const {
-            return mOffset;
-        }
-        bool isBlock(const std::string& blockName) const {
-            return mBlocks.find(blockName) != mBlocks.end();
-        }
+    // load a <function> xml node
+    Error loadFunction(const tinyxml2::XMLElement * node, const std::string &name, std::set<std::string> &unknown_elements);
 
-    private:
-        std::string mStart;
-        std::string mEnd;
-        int mOffset;
-        std::set<std::string> mBlocks;
-    };
-    int mAllocId;
-    std::set<std::string> mFiles;
-    std::map<std::string, AllocFunc> mAlloc; // allocation functions
-    std::map<std::string, AllocFunc> mDealloc; // deallocation functions
-    std::map<std::string, AllocFunc> mRealloc; // reallocation functions
-    std::map<std::string, bool> mNoReturn; // is function noreturn?
-    std::map<std::string, std::string> mReturnValue;
-    std::map<std::string, std::string> mReturnValueType;
-    std::map<std::string, int> mReturnValueContainer;
-    std::map<std::string, std::vector<MathLib::bigint>> mUnknownReturnValues;
-    std::map<std::string, bool> mReportErrors;
-    std::map<std::string, bool> mProcessAfterCode;
-    std::set<std::string> mMarkupExtensions; // file extensions of markup files
-    std::map<std::string, std::set<std::string> > mKeywords; // keywords for code in the library
-    std::map<std::string, CodeBlock> mExecutableBlocks; // keywords for blocks of executable code
-    std::map<std::string, ExportedFunctions> mExporters; // keywords that export variables/functions to libraries (meta-code/macros)
-    std::map<std::string, std::set<std::string> > mImporters; // keywords that import variables/functions
-    std::map<std::string, int> mReflection; // invocation of reflection
-    std::map<std::string, struct PodType> mPodTypes; // pod types
-    std::map<std::string, PlatformType> mPlatformTypes; // platform independent typedefs
-    std::map<std::string, Platform> mPlatforms; // platform dependent typedefs
+    struct LibraryData;
+    std::unique_ptr<LibraryData> mData;
 
     const ArgumentChecks * getarg(const Token *ftok, int argnr) const;
 
-    std::string getFunctionName(const Token *ftok, bool *error) const;
+    std::string getFunctionName(const Token *ftok, bool &error) const;
 
     static const AllocFunc* getAllocDealloc(const std::map<std::string, AllocFunc> &data, const std::string &name) {
-        const std::map<std::string, AllocFunc>::const_iterator it = data.find(name);
+        const auto it = data.find(name);
         return (it == data.end()) ? nullptr : &it->second;
     }
+
+    enum DetectContainer : std::uint8_t { ContainerOnly, IteratorOnly, Both };
+    const Library::Container* detectContainerInternal(const Token* typeStart, DetectContainer detect, bool* isIterator = nullptr, bool withoutStd = false) const;
 };
 
 CPPCHECKLIB const Library::Container * getLibraryContainer(const Token * tok);
diff --git a/lib/matchcompiler.h b/lib/matchcompiler.h
index 4ffb1f07d24..04797952a17 100644
--- a/lib/matchcompiler.h
+++ b/lib/matchcompiler.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2016 Cppcheck team.
+ * Copyright (C) 2007-2024 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,13 +24,12 @@
 
 namespace MatchCompiler {
 
-    template <unsigned int n>
+    template<unsigned int n>
     class ConstString {
     public:
-        typedef const char(&StringRef)[n];
+        using StringRef = const char (&)[n];
         explicit ConstString(StringRef s)
-            :_s(s) {
-        }
+            : _s(s) {}
 
         operator StringRef() const {
             return _s;
@@ -40,32 +39,32 @@ namespace MatchCompiler {
         StringRef _s;
     };
 
-    template <unsigned int n>
+    template<unsigned int n>
     inline bool equalN(const char s1[], const char s2[])
     {
         return (*s1 == *s2) && equalN<n-1>(s1+1, s2+1);
     }
 
-    template <>
-    inline bool equalN<0>(const char [], const char [])
+    template<>
+    inline bool equalN<0>(const char /*s1*/[], const char /*s2*/[])
     {
         return true;
     }
 
-    template <unsigned int n>
+    template<unsigned int n>
     inline bool operator==(const std::string & s1, ConstString<n> const & s2)
     {
         return equalN<n>(s1.c_str(), s2);
     }
 
-    template <unsigned int n>
+    template<unsigned int n>
     inline bool operator!=(const std::string & s1, ConstString<n> const & s2)
     {
         return !operator==(s1,s2);
     }
 
-    template <unsigned int n>
-    inline ConstString<n> makeConstString(const char(&s)[n])
+    template<unsigned int n>
+    inline ConstString<n> makeConstString(const char (&s)[n])
     {
         return ConstString<n>(s);
     }
diff --git a/lib/mathlib.cpp b/lib/mathlib.cpp
index 9dc0e9060d9..403662f4df2 100644
--- a/lib/mathlib.cpp
+++ b/lib/mathlib.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,33 +18,29 @@
 
 
 #include "mathlib.h"
-#include "errorlogger.h"
+#include "errortypes.h"
+#include "token.h"
 #include "utils.h"
 
 #include <cctype>
 #include <cmath>
+#include <cstdint>
 #include <cstdlib>
 #include <limits>
 #include <locale>
+#include <sstream>
+#include <stdexcept>
+#include <numeric>
+
+#include <simplecpp.h>
 
-#if defined(_MSC_VER) && _MSC_VER <= 1700  // VS2012 doesn't have std::isinf and std::isnan
-#define ISINF(x)      (!_finite(x))
-#define ISNAN(x)      (_isnan(x))
-#elif defined(__INTEL_COMPILER)
-#define ISINF(x)      (isinf(x))
-#define ISNAN(x)      (isnan(x))
-#else  // Use C++11 functions
-#define ISINF(x)      (std::isinf(x))
-#define ISNAN(x)      (std::isnan(x))
-#endif
 
 const int MathLib::bigint_bits = 64;
 
-MathLib::value::value(const std::string &s) :
-    mIntValue(0), mDoubleValue(0), mIsUnsigned(false)
+MathLib::value::value(const std::string &s)
 {
     if (MathLib::isFloat(s)) {
-        mType = MathLib::value::FLOAT;
+        mType = MathLib::value::Type::FLOAT;
         mDoubleValue = MathLib::toDoubleNumber(s);
         return;
     }
@@ -52,8 +48,8 @@ MathLib::value::value(const std::string &s) :
     if (!MathLib::isInt(s))
         throw InternalError(nullptr, "Invalid value: " + s);
 
-    mType = MathLib::value::INT;
-    mIntValue = MathLib::toLongNumber(s);
+    mType = MathLib::value::Type::INT;
+    mIntValue = MathLib::toBigNumber(s);
 
     if (isIntHex(s) && mIntValue < 0)
         mIsUnsigned = true;
@@ -65,12 +61,12 @@ MathLib::value::value(const std::string &s) :
             if (c == 'u' || c == 'U')
                 mIsUnsigned = true;
             else if (c == 'l' || c == 'L') {
-                if (mType == MathLib::value::INT)
-                    mType = MathLib::value::LONG;
-                else if (mType == MathLib::value::LONG)
-                    mType = MathLib::value::LONGLONG;
+                if (mType == MathLib::value::Type::INT)
+                    mType = MathLib::value::Type::LONG;
+                else if (mType == MathLib::value::Type::LONG)
+                    mType = MathLib::value::Type::LONGLONG;
             } else if (i > 2U && c == '4' && s[i-1] == '6' && s[i-2] == 'i')
-                mType = MathLib::value::LONGLONG;
+                mType = MathLib::value::Type::LONGLONG;
         }
     }
 }
@@ -78,10 +74,10 @@ MathLib::value::value(const std::string &s) :
 std::string MathLib::value::str() const
 {
     std::ostringstream ostr;
-    if (mType == MathLib::value::FLOAT) {
-        if (ISNAN(mDoubleValue))
+    if (mType == MathLib::value::Type::FLOAT) {
+        if (std::isnan(mDoubleValue))
             return "nan.0";
-        if (ISINF(mDoubleValue))
+        if (std::isinf(mDoubleValue))
             return (mDoubleValue > 0) ? "inf.0" : "-inf.0";
 
         ostr.precision(9);
@@ -102,9 +98,9 @@ std::string MathLib::value::str() const
         ostr << static_cast<biguint>(mIntValue) << "U";
     else
         ostr << mIntValue;
-    if (mType == MathLib::value::LONG)
+    if (mType == MathLib::value::Type::LONG)
         ostr << "L";
-    else if (mType == MathLib::value::LONGLONG)
+    else if (mType == MathLib::value::Type::LONGLONG)
         ostr << "LL";
     return ostr.str();
 }
@@ -120,8 +116,8 @@ void MathLib::value::promote(const MathLib::value &v)
         }
     } else if (!isFloat()) {
         mIsUnsigned = false;
-        mDoubleValue = mIntValue;
-        mType = MathLib::value::FLOAT;
+        mDoubleValue = static_cast<double>(mIntValue);
+        mType = MathLib::value::Type::FLOAT;
     }
 }
 
@@ -155,34 +151,34 @@ MathLib::value MathLib::value::calc(char op, const MathLib::value &v1, const Mat
     } else if (temp.mIsUnsigned) {
         switch (op) {
         case '+':
-            temp.mIntValue += (unsigned long long)v2.mIntValue;
+            temp.mIntValue += static_cast<unsigned long long>(v2.mIntValue);
             break;
         case '-':
-            temp.mIntValue -= (unsigned long long)v2.mIntValue;
+            temp.mIntValue -= static_cast<unsigned long long>(v2.mIntValue);
             break;
         case '*':
-            temp.mIntValue *= (unsigned long long)v2.mIntValue;
+            temp.mIntValue *= static_cast<unsigned long long>(v2.mIntValue);
             break;
         case '/':
             if (v2.mIntValue == 0)
                 throw InternalError(nullptr, "Internal Error: Division by zero");
             if (v1.mIntValue == std::numeric_limits<bigint>::min() && std::abs(v2.mIntValue)<=1)
                 throw InternalError(nullptr, "Internal Error: Division overflow");
-            temp.mIntValue /= (unsigned long long)v2.mIntValue;
+            temp.mIntValue /= static_cast<unsigned long long>(v2.mIntValue);
             break;
         case '%':
             if (v2.mIntValue == 0)
                 throw InternalError(nullptr, "Internal Error: Division by zero");
-            temp.mIntValue %= (unsigned long long)v2.mIntValue;
+            temp.mIntValue %= static_cast<unsigned long long>(v2.mIntValue);
             break;
         case '&':
-            temp.mIntValue &= (unsigned long long)v2.mIntValue;
+            temp.mIntValue &= static_cast<unsigned long long>(v2.mIntValue);
             break;
         case '|':
-            temp.mIntValue |= (unsigned long long)v2.mIntValue;
+            temp.mIntValue |= static_cast<unsigned long long>(v2.mIntValue);
             break;
         case '^':
-            temp.mIntValue ^= (unsigned long long)v2.mIntValue;
+            temp.mIntValue ^= static_cast<unsigned long long>(v2.mIntValue);
             break;
         default:
             throw InternalError(nullptr, "Unhandled calculation");
@@ -241,9 +237,9 @@ int MathLib::value::compare(const MathLib::value &v) const
     }
 
     if (temp.mIsUnsigned) {
-        if ((unsigned long long)mIntValue < (unsigned long long)v.mIntValue)
+        if (static_cast<unsigned long long>(mIntValue) < static_cast<unsigned long long>(v.mIntValue))
             return -1;
-        if ((unsigned long long)mIntValue > (unsigned long long)v.mIntValue)
+        if (static_cast<unsigned long long>(mIntValue) > static_cast<unsigned long long>(v.mIntValue))
             return 1;
         return 0;
     }
@@ -289,227 +285,133 @@ MathLib::value MathLib::value::shiftRight(const MathLib::value &v) const
     return ret;
 }
 
+MathLib::biguint MathLib::toBigUNumber(const Token * tok)
+{
+    return toBigUNumber(tok->str(), tok);
+}
 
-MathLib::biguint MathLib::toULongNumber(const std::string & str)
+// TODO: remove handling of non-literal stuff
+MathLib::biguint MathLib::toBigUNumber(const std::string & str, const Token * const tok)
 {
     // hexadecimal numbers:
     if (isIntHex(str)) {
-        if (str[0] == '-') {
-            biguint ret = 0;
-            std::istringstream istr(str);
-            istr >> std::hex >> ret;
+        try {
+            const biguint ret = std::stoull(str, nullptr, 16);
             return ret;
-        } else {
-            unsigned long long ret = 0;
-            std::istringstream istr(str);
-            istr >> std::hex >> ret;
-            return (biguint)ret;
+        } catch (const std::out_of_range& /*e*/) {
+            throw InternalError(tok, "Internal Error. MathLib::toBigUNumber: out_of_range: " + str);
+        } catch (const std::invalid_argument& /*e*/) {
+            throw InternalError(tok, "Internal Error. MathLib::toBigUNumber: invalid_argument: " + str);
         }
     }
 
     // octal numbers:
     if (isOct(str)) {
-        biguint ret = 0;
-        std::istringstream istr(str);
-        istr >> std::oct >> ret;
-        return ret;
+        try {
+            const biguint ret = std::stoull(str, nullptr, 8);
+            return ret;
+        } catch (const std::out_of_range& /*e*/) {
+            throw InternalError(tok, "Internal Error. MathLib::toBigUNumber: out_of_range: " + str);
+        } catch (const std::invalid_argument& /*e*/) {
+            throw InternalError(tok, "Internal Error. MathLib::toBigUNumber: invalid_argument: " + str);
+        }
     }
 
     // binary numbers:
     if (isBin(str)) {
         biguint ret = 0;
         for (std::string::size_type i = str[0] == '0'?2:3; i < str.length(); i++) {
+            if (str[i] != '1' && str[i] != '0')
+                break;
             ret <<= 1;
             if (str[i] == '1')
                 ret |= 1;
         }
-        /* if (str[0] == '-')
-                ret = -ret; */
+        if (str[0] == '-')
+            ret = -ret;
         return ret;
     }
 
     if (isFloat(str)) {
-        // Things are going to be less precise now: the value can't b represented in the biguint type.
+        // Things are going to be less precise now: the value can't be represented in the biguint type.
         // Use min/max values as an approximation. See #5843
-        const double doubleval = std::atof(str.c_str());
-        if (doubleval > (double)std::numeric_limits<biguint>::max())
+        // TODO: bail out when we are out of range?
+        const double doubleval = toDoubleNumber(str, tok);
+        if (doubleval > static_cast<double>(std::numeric_limits<biguint>::max()))
             return std::numeric_limits<biguint>::max();
-        else
-            return static_cast<biguint>(doubleval);
+        // cast to bigint to avoid UBSAN warning about negative double being out-of-range
+        return static_cast<biguint>(static_cast<bigint>(doubleval));
     }
 
-    biguint ret = 0;
-    std::istringstream istr(str);
-    istr >> ret;
-    return ret;
-}
-
-static unsigned int encodeMultiChar(const std::string& str)
-{
-    unsigned int retval = 0;
-    for (char it : str) {
-        retval = (retval << 8) | it;
+    if (isCharLiteral(str)) {
+        try {
+            return simplecpp::characterLiteralToLL(str);
+        } catch (const std::runtime_error& e) {
+            throw InternalError(tok, "Internal Error. MathLib::toBigUNumber: characterLiteralToLL(" + str + ") => " + e.what());
+        }
     }
-    return retval;
-}
 
-static bool isoctal(int c)
-{
-    return c>='0' && c<='7';
+    try {
+        std::size_t idx = 0;
+        const biguint ret = std::stoull(str, &idx, 10);
+        if (idx != str.size()) {
+            const std::string s = str.substr(idx);
+            if (!isValidIntegerSuffix(s, true))
+                throw InternalError(tok, "Internal Error. MathLib::toBigUNumber: input was not completely consumed: " + str);
+        }
+        return ret;
+    } catch (const std::out_of_range& /*e*/) {
+        throw InternalError(tok, "Internal Error. MathLib::toBigUNumber: out_of_range: " + str);
+    } catch (const std::invalid_argument& /*e*/) {
+        throw InternalError(tok, "Internal Error. MathLib::toBigUNumber: invalid_argument: " + str);
+    }
 }
 
-MathLib::bigint MathLib::characterLiteralToLongNumber(const std::string& str)
+unsigned int MathLib::encodeMultiChar(const std::string& str)
 {
-    if (str.empty())
-        return 0; // <- only possible in unit testing
-
-    // '\xF6'
-    if (str.size() == 4 && str.compare(0,2,"\\x")==0 && std::isxdigit(str[2]) && std::isxdigit(str[3])) {
-        return std::strtoul(str.substr(2).c_str(), nullptr, 16);
-    }
-
-    // '\123'
-    if (str.size() == 4 && str[0] == '\\' && isoctal(str[1]) && isoctal(str[2]) && isoctal(str[3])) {
-        return (char)std::strtoul(str.substr(1).c_str(), nullptr, 8);
-    }
-
-    // C99 6.4.4.4
-    // The value of an integer character constant containing more than one character (e.g., 'ab'),
-    // or containing a character or escape sequence that does not map to a single-byte execution character,
-    // is implementation-defined.
-    // clang and gcc seem to use the following encoding: 'AB' as (('A' << 8) | 'B')
-    const std::string& normStr = normalizeCharacterLiteral(str);
-    return encodeMultiChar(normStr);
+    return std::accumulate(str.cbegin(), str.cend(), uint32_t(), [](uint32_t v, char c) {
+        return (v << 8) | c;
+    });
 }
 
-std::string MathLib::normalizeCharacterLiteral(const std::string& iLiteral)
+MathLib::bigint MathLib::toBigNumber(const Token * tok)
 {
-    std::string normalizedLiteral;
-    const std::string::size_type iLiteralLen = iLiteral.size();
-    for (std::string::size_type idx = 0; idx < iLiteralLen ; ++idx) {
-        if (iLiteral[idx] != '\\') {
-            normalizedLiteral.push_back(iLiteral[idx]);
-            continue;
-        }
-        ++idx;
-        if (idx == iLiteralLen) {
-            throw InternalError(nullptr, "Internal Error. MathLib::normalizeCharacterLiteral: Unhandled char constant '" + iLiteral + "'.");
-        }
-        switch (iLiteral[idx]) {
-        case 'x':
-            // Hexa-decimal number: skip \x and interpret the next two characters
-        {
-            if (++idx == iLiteralLen)
-                throw InternalError(nullptr, "Internal Error. MathLib::normalizeCharacterLiteral: Unhandled char constant '" + iLiteral + "'.");
-            std::string tempBuf;
-            tempBuf.push_back(iLiteral[idx]);
-            if (++idx != iLiteralLen)
-                tempBuf.push_back(iLiteral[idx]);
-            normalizedLiteral.push_back(static_cast<char>(MathLib::toULongNumber("0x" + tempBuf)));
-            continue;
-        }
-        case 'u':
-        case 'U':
-            // Unicode string; just skip the \u or \U
-            if (idx + 1 == iLiteralLen)
-                throw InternalError(nullptr, "Internal Error. MathLib::characterLiteralToLongNumber: Unhandled char constant '" + iLiteral + "'.");
-            continue;
-        }
-        // Single digit octal number
-        if (1 == iLiteralLen - idx) {
-            switch (iLiteral[idx]) {
-            case '0':
-            case '1':
-            case '2':
-            case '3':
-            case '4':
-            case '5':
-            case '6':
-            case '7':
-                normalizedLiteral.push_back(iLiteral[idx]-'0');
-                break;
-            case 'a':
-                normalizedLiteral.push_back('\a');
-                break;
-            case 'b':
-                normalizedLiteral.push_back('\b');
-                break;
-            case 'e':
-                normalizedLiteral.push_back(0x1B); // clang, gcc, tcc interpnormalizedLiteral this as 0x1B - escape character
-                break;
-            case 'f':
-                normalizedLiteral.push_back('\f');
-                break;
-            case 'n':
-                normalizedLiteral.push_back('\n');
-                break;
-            case 'r':
-                normalizedLiteral.push_back('\r');
-                break;
-            case 't':
-                normalizedLiteral.push_back('\t');
-                break;
-            case 'v':
-                normalizedLiteral.push_back('\v');
-                break;
-            case '\\':
-            case '\?':
-            case '\'':
-            case '\"':
-                normalizedLiteral.push_back(iLiteral[idx]);
-                break;
-            default:
-                throw InternalError(nullptr, "Internal Error. MathLib::normalizeCharacterLiteral: Unhandled char constant '" + iLiteral + "'.");
-            }
-            continue;
-        }
-        // 2-3 digit octal number
-        if (!MathLib::isOctalDigit(iLiteral[idx]))
-            throw InternalError(nullptr, "Internal Error. MathLib::normalizeCharacterLiteral: Unhandled char constant '" + iLiteral + "'.");
-        std::string tempBuf;
-        tempBuf.push_back(iLiteral[idx]);
-        ++idx;
-        if (MathLib::isOctalDigit(iLiteral[idx])) {
-            tempBuf.push_back(iLiteral[idx]);
-            ++idx;
-            if (MathLib::isOctalDigit(iLiteral[idx])) {
-                tempBuf.push_back(iLiteral[idx]);
-            }
-        }
-        normalizedLiteral.push_back(static_cast<char>(MathLib::toLongNumber("0" + tempBuf)));
-    }
-    return normalizedLiteral;
+    return toBigNumber(tok->str(), tok);
 }
 
-MathLib::bigint MathLib::toLongNumber(const std::string & str)
+// TODO: remove handling of non-literal stuff
+MathLib::bigint MathLib::toBigNumber(const std::string & str, const Token * const tok)
 {
     // hexadecimal numbers:
     if (isIntHex(str)) {
-        if (str[0] == '-') {
-            bigint ret = 0;
-            std::istringstream istr(str);
-            istr >> std::hex >> ret;
-            return ret;
-        } else {
-            unsigned long long ret = 0;
-            std::istringstream istr(str);
-            istr >> std::hex >> ret;
-            return (bigint)ret;
+        try {
+            const biguint ret = std::stoull(str, nullptr, 16);
+            return static_cast<bigint>(ret);
+        } catch (const std::out_of_range& /*e*/) {
+            throw InternalError(tok, "Internal Error. MathLib::toBigNumber: out_of_range: " + str);
+        } catch (const std::invalid_argument& /*e*/) {
+            throw InternalError(tok, "Internal Error. MathLib::toBigNumber: invalid_argument: " + str);
         }
     }
 
     // octal numbers:
     if (isOct(str)) {
-        bigint ret = 0;
-        std::istringstream istr(str);
-        istr >> std::oct >> ret;
-        return ret;
+        try {
+            const biguint ret = std::stoull(str, nullptr, 8);
+            return ret;
+        } catch (const std::out_of_range& /*e*/) {
+            throw InternalError(tok, "Internal Error. MathLib::toBigNumber: out_of_range: " + str);
+        } catch (const std::invalid_argument& /*e*/) {
+            throw InternalError(tok, "Internal Error. MathLib::toBigNumber: invalid_argument: " + str);
+        }
     }
 
     // binary numbers:
     if (isBin(str)) {
         bigint ret = 0;
         for (std::string::size_type i = str[0] == '0'?2:3; i < str.length(); i++) {
+            if (str[i] != '1' && str[i] != '0')
+                break;
             ret <<= 1;
             if (str[i] == '1')
                 ret |= 1;
@@ -522,30 +424,37 @@ MathLib::bigint MathLib::toLongNumber(const std::string & str)
     if (isFloat(str)) {
         // Things are going to be less precise now: the value can't be represented in the bigint type.
         // Use min/max values as an approximation. See #5843
-        const double doubleval = toDoubleNumber(str);
-        if (doubleval > (double)std::numeric_limits<bigint>::max())
+        // TODO: bail out when we are out of range?
+        const double doubleval = toDoubleNumber(str, tok);
+        if (doubleval > static_cast<double>(std::numeric_limits<bigint>::max()))
             return std::numeric_limits<bigint>::max();
-        else if (doubleval < (double)std::numeric_limits<bigint>::min())
+        if (doubleval < static_cast<double>(std::numeric_limits<bigint>::min()))
             return std::numeric_limits<bigint>::min();
-        else
-            return static_cast<bigint>(doubleval);
+        return static_cast<bigint>(doubleval);
     }
 
-    if (str[0] == '\'' && str.size() >= 3U && endsWith(str,'\'')) {
-        return characterLiteralToLongNumber(str.substr(1,str.size()-2));
+    if (isCharLiteral(str)) {
+        try {
+            return simplecpp::characterLiteralToLL(str);
+        } catch (const std::runtime_error& e) {
+            throw InternalError(tok, "Internal Error. MathLib::toBigNumber: characterLiteralToLL(" + str + ") => " + e.what());
+        }
     }
 
-    if (str[0] == '-') {
-        bigint ret = 0;
-        std::istringstream istr(str);
-        istr >> ret;
+    try {
+        std::size_t idx = 0;
+        const biguint ret = std::stoull(str, &idx, 10);
+        if (idx != str.size()) {
+            const std::string s = str.substr(idx);
+            if (!isValidIntegerSuffix(s, true))
+                throw InternalError(tok, "Internal Error. MathLib::toBigNumber: input was not completely consumed: " + str);
+        }
         return ret;
+    } catch (const std::out_of_range& /*e*/) {
+        throw InternalError(tok, "Internal Error. MathLib::toBigNumber: out_of_range: " + str);
+    } catch (const std::invalid_argument& /*e*/) {
+        throw InternalError(tok, "Internal Error. MathLib::toBigNumber: invalid_argument: " + str);
     }
-
-    biguint ret = 0;
-    std::istringstream istr(str);
-    istr >> ret;
-    return ret;
 }
 
 // in-place conversion of (sub)string to double. Requires no heap.
@@ -565,73 +474,109 @@ static double myStod(const std::string& str, std::string::const_iterator from, s
     int distance;
     if (std::string::npos == decimalsep) {
         distance = to - it;
-    } else  if (decimalsep > (to - str.begin()))
+    } else if (decimalsep > (to - str.begin()))
         return 0.; // error handling??
     else
         distance = int(decimalsep)-(from - str.begin());
     auto digitval = [&](char c) {
         if ((10 < base) && (c > '9'))
             return 10 + std::tolower(c) - 'a';
-        else
-            return c - '0';
+        return c - '0';
     };
     for (; it!=to; ++it) {
         if ('.' == *it)
             continue;
-        else
-            --distance;
+        --distance;
         result += digitval(*it)* std::pow(base, distance);
     }
-    return (positivesign)?result:-result;
+    return positivesign ? result : -result;
 }
 
-
 // Assuming a limited support of built-in hexadecimal floats (see C99, C++17) that is a fall-back implementation.
 // Performance has been optimized WRT to heap activity, however the calculation part is not optimized.
-static double FloatHexToDoubleNumber(const std::string& str)
+static double floatHexToDoubleNumber(const std::string& str)
 {
     const std::size_t p = str.find_first_of("pP",3);
-    const double factor1 = myStod(str, str.begin() + 2, str.begin()+p, 16);
+    const double factor1 = myStod(str, str.cbegin() + 2, str.cbegin()+p, 16);
     const bool suffix = (str.back() == 'f') || (str.back() == 'F') || (str.back() == 'l') || (str.back() == 'L');
-    const double exponent = myStod(str, str.begin() + p + 1, (suffix)?str.end()-1:str.end(), 10);
+    const double exponent = myStod(str, str.cbegin() + p + 1, suffix ? str.cend()-1:str.cend(), 10);
     const double factor2 = std::pow(2, exponent);
     return factor1 * factor2;
 }
 
-double MathLib::toDoubleNumber(const std::string &str)
+double MathLib::toDoubleNumber(const Token * tok)
 {
-    if (str[0] == '\'' && str.size() >= 3U && endsWith(str,'\''))
-        return characterLiteralToLongNumber(str.substr(1,str.size()-2));
+    return toDoubleNumber(tok->str(), tok);
+}
+
+double MathLib::toDoubleNumber(const std::string &str, const Token * const tok)
+{
+    if (isCharLiteral(str)) {
+        try {
+            return simplecpp::characterLiteralToLL(str);
+        } catch (const std::runtime_error& e) {
+            throw InternalError(tok, "Internal Error. MathLib::toDoubleNumber: characterLiteralToLL(" + str + ") => " + e.what());
+        }
+    }
     if (isIntHex(str))
-        return static_cast<double>(toLongNumber(str));
-    // nullcheck
-    if (isNullValue(str))
-        return 0.0;
-#ifdef __clang__
-    if (isFloat(str)) // Workaround libc++ bug at http://llvm.org/bugs/show_bug.cgi?id=17782
-        // TODO : handle locale
+        return static_cast<double>(toBigNumber(str, tok));
+#ifdef _LIBCPP_VERSION
+    if (isFloat(str)) // Workaround libc++ bug at https://github.com/llvm/llvm-project/issues/18156
+        // TODO: handle locale
+        // TODO: make sure all characters are being consumed
         return std::strtod(str.c_str(), nullptr);
 #endif
     if (isFloatHex(str))
-        return FloatHexToDoubleNumber(str);
+        return floatHexToDoubleNumber(str);
     // otherwise, convert to double
     std::istringstream istr(str);
     istr.imbue(std::locale::classic());
     double ret;
-    istr >> ret;
+    if (!(istr >> ret))
+        throw InternalError(tok, "Internal Error. MathLib::toDoubleNumber: conversion failed: " + str);
+    std::string s;
+    if (istr >> s) {
+        if (isDecimalFloat(str))
+            return ret;
+        if (!isValidIntegerSuffix(s, true))
+            throw InternalError(tok, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: " + str);
+    }
     return ret;
 }
 
-template<> std::string MathLib::toString(double value)
+template<> std::string MathLib::toString<MathLib::bigint>(MathLib::bigint value)
+{
+#if defined(HAVE_BOOST) && defined(HAVE_BOOST_INT128)
+    std::ostringstream result;
+    result << value;
+    return result.str();
+#else
+    return std::to_string(value);
+#endif
+}
+
+template<> std::string MathLib::toString<MathLib::biguint>(MathLib::biguint value)
+{
+#if defined(HAVE_BOOST) && defined(HAVE_BOOST_INT128)
+    std::ostringstream result;
+    result << value;
+    return result.str();
+#else
+    return std::to_string(value);
+#endif
+}
+
+template<> std::string MathLib::toString<double>(double value)
 {
     std::ostringstream result;
     result.precision(12);
     result << value;
-    if (result.str() == "-0")
+    std::string s = result.str();
+    if (s == "-0")
         return "0.0";
-    if (result.str().find('.') == std::string::npos)
-        return result.str() + ".0";
-    return result.str();
+    if (s.find_first_of(".e") == std::string::npos)
+        return s + ".0";
+    return s;
 }
 
 bool MathLib::isFloat(const std::string &str)
@@ -643,13 +588,13 @@ bool MathLib::isDecimalFloat(const std::string &str)
 {
     if (str.empty())
         return false;
-    enum class State {
-        START, BASE_DIGITS1, LEADING_DECIMAL, TRAILING_DECIMAL, BASE_DIGITS2, E, MANTISSA_PLUSMINUS, MANTISSA_DIGITS, SUFFIX_F, SUFFIX_L
+    enum class State : std::uint8_t {
+        START, BASE_DIGITS1, LEADING_DECIMAL, TRAILING_DECIMAL, BASE_DIGITS2, E, MANTISSA_PLUSMINUS, MANTISSA_DIGITS, SUFFIX_F, SUFFIX_L, SUFFIX_LITERAL_LEADER, SUFFIX_LITERAL
     } state = State::START;
-    std::string::const_iterator it = str.begin();
+    auto it = str.cbegin();
     if ('+' == *it || '-' == *it)
         ++it;
-    for (; it != str.end(); ++it) {
+    for (; it != str.cend(); ++it) {
         switch (state) {
         case State::START:
             if (*it=='.')
@@ -680,6 +625,8 @@ bool MathLib::isDecimalFloat(const std::string &str)
                 state = State::SUFFIX_F;
             else if (*it=='l' || *it=='L')
                 state = State::SUFFIX_L;
+            else if (*it == '_')
+                state = State::SUFFIX_LITERAL_LEADER;
             else if (std::isdigit(static_cast<unsigned char>(*it)))
                 state = State::BASE_DIGITS2;
             else
@@ -692,6 +639,8 @@ bool MathLib::isDecimalFloat(const std::string &str)
                 state = State::SUFFIX_F;
             else if (*it=='l' || *it=='L')
                 state = State::SUFFIX_L;
+            else if (*it == '_')
+                state = State::SUFFIX_LITERAL_LEADER;
             else if (!std::isdigit(static_cast<unsigned char>(*it)))
                 return false;
             break;
@@ -717,13 +666,18 @@ bool MathLib::isDecimalFloat(const std::string &str)
             else if (!std::isdigit(static_cast<unsigned char>(*it)))
                 return false;
             break;
+        // Ensure at least one post _ char for user defined literals
+        case State::SUFFIX_LITERAL:
+        case State::SUFFIX_LITERAL_LEADER:
+            state = State::SUFFIX_LITERAL;
+            break;
         case State::SUFFIX_F:
             return false;
         case State::SUFFIX_L:
             return false;
         }
     }
-    return (state==State::BASE_DIGITS2 || state==State::MANTISSA_DIGITS || state==State::TRAILING_DECIMAL || state==State::SUFFIX_F || state==State::SUFFIX_L);
+    return (state==State::BASE_DIGITS2 || state==State::MANTISSA_DIGITS || state==State::TRAILING_DECIMAL || state==State::SUFFIX_F || state==State::SUFFIX_L || (state==State::SUFFIX_LITERAL));
 }
 
 bool MathLib::isNegative(const std::string &str)
@@ -740,93 +694,113 @@ bool MathLib::isPositive(const std::string &str)
     return !MathLib::isNegative(str);
 }
 
-static bool _isValidIntegerSuffix(std::string::const_iterator it, std::string::const_iterator end, bool supportMicrosoftExtensions=true)
+static bool isValidIntegerSuffixIt(std::string::const_iterator it, std::string::const_iterator end, bool supportMicrosoftExtensions=true)
 {
-    enum { START, SUFFIX_U, SUFFIX_UL, SUFFIX_ULL, SUFFIX_L, SUFFIX_LU, SUFFIX_LL, SUFFIX_LLU, SUFFIX_I, SUFFIX_I6, SUFFIX_I64, SUFFIX_UI, SUFFIX_UI6, SUFFIX_UI64 } state = START;
+    enum class Status : std::uint8_t { START, SUFFIX_U, SUFFIX_UL, SUFFIX_ULL, SUFFIX_UZ, SUFFIX_L, SUFFIX_LU, SUFFIX_LL, SUFFIX_LLU, SUFFIX_I, SUFFIX_I6, SUFFIX_I64, SUFFIX_UI, SUFFIX_UI6, SUFFIX_UI64, SUFFIX_Z, SUFFIX_LITERAL_LEADER, SUFFIX_LITERAL } state = Status::START;
     for (; it != end; ++it) {
         switch (state) {
-        case START:
+        case Status::START:
             if (*it == 'u' || *it == 'U')
-                state = SUFFIX_U;
+                state = Status::SUFFIX_U;
             else if (*it == 'l' || *it == 'L')
-                state = SUFFIX_L;
+                state = Status::SUFFIX_L;
+            else if (*it == 'z' || *it == 'Z')
+                state = Status::SUFFIX_Z;
             else if (supportMicrosoftExtensions && (*it == 'i' || *it == 'I'))
-                state = SUFFIX_I;
+                state = Status::SUFFIX_I;
+            else if (*it == '_')
+                state = Status::SUFFIX_LITERAL_LEADER;
             else
                 return false;
             break;
-        case SUFFIX_U:
+        case Status::SUFFIX_U:
             if (*it == 'l' || *it == 'L')
-                state = SUFFIX_UL; // UL
+                state = Status::SUFFIX_UL; // UL
+            else if (*it == 'z' || *it == 'Z')
+                state = Status::SUFFIX_UZ; // UZ
             else if (supportMicrosoftExtensions && (*it == 'i' || *it == 'I'))
-                state = SUFFIX_UI;
+                state = Status::SUFFIX_UI;
             else
                 return false;
             break;
-        case SUFFIX_UL:
+        case Status::SUFFIX_UL:
             if (*it == 'l' || *it == 'L')
-                state = SUFFIX_ULL; // ULL
+                state = Status::SUFFIX_ULL; // ULL
             else
                 return false;
             break;
-        case SUFFIX_L:
+        case Status::SUFFIX_L:
             if (*it == 'u' || *it == 'U')
-                state = SUFFIX_LU; // LU
+                state = Status::SUFFIX_LU; // LU
             else if (*it == 'l' || *it == 'L')
-                state = SUFFIX_LL; // LL
+                state = Status::SUFFIX_LL; // LL
             else
                 return false;
             break;
-        case SUFFIX_LU:
+        case Status::SUFFIX_LU:
             return false;
-        case SUFFIX_LL:
+        case Status::SUFFIX_LL:
             if (*it == 'u' || *it == 'U')
-                state = SUFFIX_LLU; // LLU
+                state = Status::SUFFIX_LLU; // LLU
             else
                 return false;
             break;
-        case SUFFIX_I:
+        case Status::SUFFIX_I:
             if (*it == '6')
-                state = SUFFIX_I6;
+                state = Status::SUFFIX_I6;
             else
                 return false;
             break;
-        case SUFFIX_I6:
+        case Status::SUFFIX_I6:
             if (*it == '4')
-                state = SUFFIX_I64;
+                state = Status::SUFFIX_I64;
             else
                 return false;
             break;
-        case SUFFIX_UI:
+        case Status::SUFFIX_UI:
             if (*it == '6')
-                state = SUFFIX_UI6;
+                state = Status::SUFFIX_UI6;
             else
                 return false;
             break;
-        case SUFFIX_UI6:
+        case Status::SUFFIX_UI6:
             if (*it == '4')
-                state = SUFFIX_UI64;
+                state = Status::SUFFIX_UI64;
+            else
+                return false;
+            break;
+        case Status::SUFFIX_Z:
+            if (*it == 'u' || *it == 'U')
+                state = Status::SUFFIX_UZ;
             else
                 return false;
             break;
+        // Ensure at least one post _ char for user defined literals
+        case Status::SUFFIX_LITERAL:
+        case Status::SUFFIX_LITERAL_LEADER:
+            state = Status::SUFFIX_LITERAL;
+            break;
         default:
             return false;
         }
     }
-    return ((state == SUFFIX_U) ||
-            (state == SUFFIX_L) ||
-            (state == SUFFIX_UL) ||
-            (state == SUFFIX_LU) ||
-            (state == SUFFIX_LL) ||
-            (state == SUFFIX_ULL) ||
-            (state == SUFFIX_LLU) ||
-            (state == SUFFIX_I64) ||
-            (state == SUFFIX_UI64));
+    return ((state == Status::SUFFIX_U) ||
+            (state == Status::SUFFIX_L) ||
+            (state == Status::SUFFIX_Z) ||
+            (state == Status::SUFFIX_UL) ||
+            (state == Status::SUFFIX_UZ) ||
+            (state == Status::SUFFIX_LU) ||
+            (state == Status::SUFFIX_LL) ||
+            (state == Status::SUFFIX_ULL) ||
+            (state == Status::SUFFIX_LLU) ||
+            (state == Status::SUFFIX_I64) ||
+            (state == Status::SUFFIX_UI64) ||
+            (state == Status::SUFFIX_LITERAL));
 }
 
 bool MathLib::isValidIntegerSuffix(const std::string& str, bool supportMicrosoftExtensions)
 {
-    return _isValidIntegerSuffix(str.begin(), str.end(), supportMicrosoftExtensions);
+    return isValidIntegerSuffixIt(str.cbegin(), str.cend(), supportMicrosoftExtensions);
 }
 
 
@@ -842,15 +816,15 @@ bool MathLib::isValidIntegerSuffix(const std::string& str, bool supportMicrosoft
  **/
 bool MathLib::isOct(const std::string& str)
 {
-    enum class Status {
+    enum class Status : std::uint8_t {
         START, OCTAL_PREFIX, DIGITS
     } state = Status::START;
     if (str.empty())
         return false;
-    std::string::const_iterator it = str.begin();
+    auto it = str.cbegin();
     if ('+' == *it || '-' == *it)
         ++it;
-    for (; it != str.end(); ++it) {
+    for (; it != str.cend(); ++it) {
         switch (state) {
         case Status::START:
             if (*it == '0')
@@ -868,7 +842,7 @@ bool MathLib::isOct(const std::string& str)
             if (isOctalDigit(static_cast<unsigned char>(*it)))
                 state = Status::DIGITS;
             else
-                return _isValidIntegerSuffix(it,str.end());
+                return isValidIntegerSuffixIt(it,str.end());
             break;
         }
     }
@@ -877,123 +851,123 @@ bool MathLib::isOct(const std::string& str)
 
 bool MathLib::isIntHex(const std::string& str)
 {
-    enum Status {
+    enum class Status : std::uint8_t {
         START, HEX_0, HEX_X, DIGIT
-    } state = START;
+    } state = Status::START;
     if (str.empty())
         return false;
-    std::string::const_iterator it = str.begin();
+    auto it = str.cbegin();
     if ('+' == *it || '-' == *it)
         ++it;
-    for (; it != str.end(); ++it) {
+    for (; it != str.cend(); ++it) {
         switch (state) {
-        case START:
+        case Status::START:
             if (*it == '0')
-                state = HEX_0;
+                state = Status::HEX_0;
             else
                 return false;
             break;
-        case HEX_0:
+        case Status::HEX_0:
             if (*it == 'x' || *it == 'X')
-                state = HEX_X;
+                state = Status::HEX_X;
             else
                 return false;
             break;
-        case HEX_X:
+        case Status::HEX_X:
             if (isxdigit(static_cast<unsigned char>(*it)))
-                state = DIGIT;
+                state = Status::DIGIT;
             else
                 return false;
             break;
-        case DIGIT:
+        case Status::DIGIT:
             if (isxdigit(static_cast<unsigned char>(*it)))
-                ; //  state = DIGIT;
+                ; //  state = Status::DIGIT;
             else
-                return _isValidIntegerSuffix(it,str.end());
+                return isValidIntegerSuffixIt(it,str.end());
             break;
         }
     }
-    return DIGIT==state;
+    return Status::DIGIT == state;
 }
 
 bool MathLib::isFloatHex(const std::string& str)
 {
-    enum Status {
+    enum class Status : std::uint8_t {
         START, HEX_0, HEX_X, WHOLE_NUMBER_DIGIT, POINT, FRACTION, EXPONENT_P, EXPONENT_SIGN, EXPONENT_DIGITS, EXPONENT_SUFFIX
-    } state = START;
+    } state = Status::START;
     if (str.empty())
         return false;
-    std::string::const_iterator it = str.begin();
+    auto it = str.cbegin();
     if ('+' == *it || '-' == *it)
         ++it;
-    for (; it != str.end(); ++it) {
+    for (; it != str.cend(); ++it) {
         switch (state) {
-        case START:
+        case Status::START:
             if (*it == '0')
-                state = HEX_0;
+                state = Status::HEX_0;
             else
                 return false;
             break;
-        case HEX_0:
+        case Status::HEX_0:
             if (*it == 'x' || *it == 'X')
-                state = HEX_X;
+                state = Status::HEX_X;
             else
                 return false;
             break;
-        case HEX_X:
+        case Status::HEX_X:
             if (isxdigit(static_cast<unsigned char>(*it)))
-                state = WHOLE_NUMBER_DIGIT;
+                state = Status::WHOLE_NUMBER_DIGIT;
             else if (*it == '.')
-                state = POINT;
+                state = Status::POINT;
             else
                 return false;
             break;
-        case WHOLE_NUMBER_DIGIT:
+        case Status::WHOLE_NUMBER_DIGIT:
             if (isxdigit(static_cast<unsigned char>(*it)))
-                ; // state = WHOLE_NUMBER_DIGITS;
+                ; // state = Status::WHOLE_NUMBER_DIGITS;
             else if (*it=='.')
-                state = FRACTION;
+                state = Status::FRACTION;
             else if (*it=='p' || *it=='P')
-                state = EXPONENT_P;
+                state = Status::EXPONENT_P;
             else
                 return false;
             break;
-        case POINT:
-        case FRACTION:
+        case Status::POINT:
+        case Status::FRACTION:
             if (isxdigit(static_cast<unsigned char>(*it)))
-                state=FRACTION;
+                state = Status::FRACTION;
             else if (*it == 'p' || *it == 'P')
-                state = EXPONENT_P;
+                state = Status::EXPONENT_P;
             else
                 return false;
             break;
-        case EXPONENT_P:
+        case Status::EXPONENT_P:
             if (isdigit(static_cast<unsigned char>(*it)))
-                state = EXPONENT_DIGITS;
+                state = Status::EXPONENT_DIGITS;
             else if (*it == '+' || *it == '-')
-                state = EXPONENT_SIGN;
+                state = Status::EXPONENT_SIGN;
             else
                 return false;
             break;
-        case EXPONENT_SIGN:
+        case Status::EXPONENT_SIGN:
             if (isdigit(static_cast<unsigned char>(*it)))
-                state = EXPONENT_DIGITS;
+                state = Status::EXPONENT_DIGITS;
             else
                 return false;
             break;
-        case EXPONENT_DIGITS:
+        case Status::EXPONENT_DIGITS:
             if (isdigit(static_cast<unsigned char>(*it)))
-                ; //  state = EXPONENT_DIGITS;
+                ; //  state = Status::EXPONENT_DIGITS;
             else if (*it == 'f' || *it == 'F' || *it == 'l' || *it == 'L')
-                state = EXPONENT_SUFFIX;
+                state = Status::EXPONENT_SUFFIX;
             else
                 return false;
             break;
-        case EXPONENT_SUFFIX:
+        case Status::EXPONENT_SUFFIX:
             return false;
         }
     }
-    return (EXPONENT_DIGITS==state) || (EXPONENT_SUFFIX == state);
+    return (Status::EXPONENT_DIGITS == state) || (Status::EXPONENT_SUFFIX == state);
 }
 
 
@@ -1008,72 +982,72 @@ bool MathLib::isFloatHex(const std::string& str)
  **/
 bool MathLib::isBin(const std::string& str)
 {
-    enum Status {
+    enum class Status : std::uint8_t {
         START, GNU_BIN_PREFIX_0, GNU_BIN_PREFIX_B, DIGIT
-    } state = START;
+    } state = Status::START;
     if (str.empty())
         return false;
-    std::string::const_iterator it = str.begin();
+    auto it = str.cbegin();
     if ('+' == *it || '-' == *it)
         ++it;
-    for (; it != str.end(); ++it) {
+    for (; it != str.cend(); ++it) {
         switch (state) {
-        case START:
+        case Status::START:
             if (*it == '0')
-                state = GNU_BIN_PREFIX_0;
+                state = Status::GNU_BIN_PREFIX_0;
             else
                 return false;
             break;
-        case GNU_BIN_PREFIX_0:
+        case Status::GNU_BIN_PREFIX_0:
             if (*it == 'b' || *it == 'B')
-                state = GNU_BIN_PREFIX_B;
+                state = Status::GNU_BIN_PREFIX_B;
             else
                 return false;
             break;
-        case GNU_BIN_PREFIX_B:
+        case Status::GNU_BIN_PREFIX_B:
             if (*it == '0' || *it == '1')
-                state = DIGIT;
+                state = Status::DIGIT;
             else
                 return false;
             break;
-        case DIGIT:
+        case Status::DIGIT:
             if (*it == '0' || *it == '1')
-                ; //  state = DIGIT;
+                ; //  state = Status::DIGIT;
             else
-                return _isValidIntegerSuffix(it,str.end());
+                return isValidIntegerSuffixIt(it,str.end());
             break;
         }
     }
-    return state == DIGIT;
+    return state == Status::DIGIT;
 }
 
 bool MathLib::isDec(const std::string & str)
 {
-    enum Status {
+    enum class Status : std::uint8_t {
         START, DIGIT
-    } state = START;
+    } state = Status::START;
     if (str.empty())
         return false;
-    std::string::const_iterator it = str.begin();
+    auto it = str.cbegin();
     if ('+' == *it || '-' == *it)
         ++it;
-    for (; it != str.end(); ++it) {
+    for (; it != str.cend(); ++it) {
         switch (state) {
-        case START:
+        case Status::START:
             if (isdigit(static_cast<unsigned char>(*it)))
-                state = DIGIT;
+                state = Status::DIGIT;
             else
                 return false;
             break;
-        case DIGIT:
+        case Status::DIGIT:
             if (isdigit(static_cast<unsigned char>(*it)))
-                state = DIGIT;
+                state = Status::DIGIT;
             else
-                return _isValidIntegerSuffix(it,str.end());
+                return isValidIntegerSuffixIt(it,str.end());
             break;
         }
     }
-    return state == DIGIT;
+    return state == Status::DIGIT;
 }
 
 bool MathLib::isInt(const std::string & str)
@@ -1104,7 +1078,7 @@ std::string MathLib::getSuffix(const std::string& value)
         return isUnsigned ? "UL" : "L";
     if (longState == 2)
         return isUnsigned ? "ULL" : "LL";
-    else return "";
+    return "";
 }
 
 static std::string intsuffix(const std::string & first, const std::string & second)
@@ -1131,7 +1105,7 @@ std::string MathLib::add(const std::string & first, const std::string & second)
     return (value(first) + value(second)).str();
 #else
     if (MathLib::isInt(first) && MathLib::isInt(second)) {
-        return toString(toLongNumber(first) + toLongNumber(second)) + intsuffix(first, second);
+        return MathLib::toString(toBigNumber(first) + toBigNumber(second)) + intsuffix(first, second);
     }
 
     double d1 = toDoubleNumber(first);
@@ -1153,11 +1127,11 @@ std::string MathLib::subtract(const std::string &first, const std::string &secon
     return (value(first) - value(second)).str();
 #else
     if (MathLib::isInt(first) && MathLib::isInt(second)) {
-        return toString(toLongNumber(first) - toLongNumber(second)) + intsuffix(first, second);
+        return MathLib::toString(toBigNumber(first) - toBigNumber(second)) + intsuffix(first, second);
     }
 
     if (first == second)
-        return "0.0" ;
+        return "0.0";
 
     double d1 = toDoubleNumber(first);
     double d2 = toDoubleNumber(second);
@@ -1172,40 +1146,24 @@ std::string MathLib::subtract(const std::string &first, const std::string &secon
 #endif
 }
 
-std::string MathLib::incdec(const std::string & var, const std::string & op)
-{
-#ifdef TEST_MATHLIB_VALUE
-    if (op == "++")
-        return value(var).add(1).str();
-    else if (op == "--")
-        return value(var).add(-1).str();
-#else
-    if (op == "++")
-        return MathLib::add(var, "1");
-    else if (op == "--")
-        return MathLib::subtract(var, "1");
-#endif
-
-    throw InternalError(nullptr, std::string("Unexpected operation '") + op + "' in MathLib::incdec(). Please report this to Cppcheck developers.");
-}
-
 std::string MathLib::divide(const std::string &first, const std::string &second)
 {
 #ifdef TEST_MATHLIB_VALUE
     return (value(first) / value(second)).str();
 #else
     if (MathLib::isInt(first) && MathLib::isInt(second)) {
-        const bigint a = toLongNumber(first);
-        const bigint b = toLongNumber(second);
+        const bigint a = toBigNumber(first);
+        const bigint b = toBigNumber(second);
         if (b == 0)
             throw InternalError(nullptr, "Internal Error: Division by zero");
         if (a == std::numeric_limits<bigint>::min() && std::abs(b)<=1)
             throw InternalError(nullptr, "Internal Error: Division overflow");
-        return toString(toLongNumber(first) / b) + intsuffix(first, second);
-    } else if (isNullValue(second)) {
+        return MathLib::toString(toBigNumber(first) / b) + intsuffix(first, second);
+    }
+    if (isNullValue(second)) {
         if (isNullValue(first))
             return "nan.0";
-        return isPositive(first) ? "inf.0" : "-inf.0";
+        return isPositive(first) == isPositive(second) ? "inf.0" : "-inf.0";
     }
     return toString(toDoubleNumber(first) / toDoubleNumber(second));
 #endif
@@ -1217,7 +1175,7 @@ std::string MathLib::multiply(const std::string &first, const std::string &secon
     return (value(first) * value(second)).str();
 #else
     if (MathLib::isInt(first) && MathLib::isInt(second)) {
-        return toString(toLongNumber(first) * toLongNumber(second)) + intsuffix(first, second);
+        return MathLib::toString(toBigNumber(first) * toBigNumber(second)) + intsuffix(first, second);
     }
     return toString(toDoubleNumber(first) * toDoubleNumber(second));
 #endif
@@ -1229,10 +1187,10 @@ std::string MathLib::mod(const std::string &first, const std::string &second)
     return (value(first) % value(second)).str();
 #else
     if (MathLib::isInt(first) && MathLib::isInt(second)) {
-        const bigint b = toLongNumber(second);
+        const bigint b = toBigNumber(second);
         if (b == 0)
             throw InternalError(nullptr, "Internal Error: Division by zero");
-        return toString(toLongNumber(first) % b) + intsuffix(first, second);
+        return MathLib::toString(toBigNumber(first) % b) + intsuffix(first, second);
     }
     return toString(std::fmod(toDoubleNumber(first),toDoubleNumber(second)));
 #endif
@@ -1257,16 +1215,16 @@ std::string MathLib::calculate(const std::string &first, const std::string &seco
         return MathLib::mod(first, second);
 
     case '&':
-        return MathLib::toString(MathLib::toLongNumber(first) & MathLib::toLongNumber(second)) + intsuffix(first,second);
+        return MathLib::toString(MathLib::toBigNumber(first) & MathLib::toBigNumber(second)) + intsuffix(first, second);
 
     case '|':
-        return MathLib::toString(MathLib::toLongNumber(first) | MathLib::toLongNumber(second)) + intsuffix(first,second);
+        return MathLib::toString(MathLib::toBigNumber(first) | MathLib::toBigNumber(second)) + intsuffix(first, second);
 
     case '^':
-        return MathLib::toString(MathLib::toLongNumber(first) ^ MathLib::toLongNumber(second)) + intsuffix(first,second);
+        return MathLib::toString(MathLib::toBigNumber(first) ^ MathLib::toBigNumber(second)) + intsuffix(first, second);
 
     default:
-        throw InternalError(nullptr, std::string("Unexpected action '") + action + "' in MathLib::calculate(). Please report this to Cppcheck developers.");
+        throw InternalError(nullptr, std::string("Unexpected action '") + action + "' in MathLib::calculate().");
     }
 }
 
@@ -1289,7 +1247,9 @@ std::string MathLib::tan(const std::string &tok)
 
 std::string MathLib::abs(const std::string &tok)
 {
-    return toString(std::abs(toDoubleNumber(tok)));
+    if (isNegative(tok))
+        return tok.substr(1, tok.length() - 1);
+    return tok;
 }
 
 bool MathLib::isEqual(const std::string &first, const std::string &second)
@@ -1304,16 +1264,19 @@ bool MathLib::isNotEqual(const std::string &first, const std::string &second)
     return !isEqual(first, second);
 }
 
+// cppcheck-suppress unusedFunction
 bool MathLib::isGreater(const std::string &first, const std::string &second)
 {
     return toDoubleNumber(first) > toDoubleNumber(second);
 }
 
+// cppcheck-suppress unusedFunction
 bool MathLib::isGreaterEqual(const std::string &first, const std::string &second)
 {
     return toDoubleNumber(first) >= toDoubleNumber(second);
 }
 
+// cppcheck-suppress unusedFunction
 bool MathLib::isLess(const std::string &first, const std::string &second)
 {
     return toDoubleNumber(first) < toDoubleNumber(second);
@@ -1338,11 +1301,16 @@ bool MathLib::isNullValue(const std::string &str)
     if (str.empty() || (!std::isdigit(static_cast<unsigned char>(str[0])) && (str[0] != '.' && str[0] != '-' && str[0] != '+')))
         return false; // Has to be a number
 
-    for (char i : str) {
+    if (!isInt(str) && !isFloat(str))
+        return false;
+    const bool isHex = isIntHex(str) || isFloatHex(str);
+    for (const char i : str) {
         if (std::isdigit(static_cast<unsigned char>(i)) && i != '0') // May not contain digits other than 0
             return false;
-        if (i == 'E' || i == 'e')
+        if (i == 'p' || i == 'P' || (!isHex && (i == 'E' || i == 'e')))
             return true;
+        if (isHex && isxdigit(i) && i != '0')
+            return false;
     }
     return true;
 }
@@ -1352,45 +1320,6 @@ bool MathLib::isOctalDigit(char c)
     return (c >= '0' && c <= '7');
 }
 
-bool MathLib::isDigitSeparator(const std::string& iCode, std::string::size_type iPos)
-{
-    if (iPos == 0 || iPos >= iCode.size() || iCode[iPos] != '\'')
-        return false;
-    std::string::size_type i = iPos - 1;
-    while (std::isxdigit(iCode[i])) {
-        if (i == 0)
-            return true; // Only xdigits before '
-        --i;
-    }
-    if (i == iPos - 1) { // No xdigit before '
-        return false;
-    } else {
-        switch (iCode[i]) {
-        case ' ':
-        case '.':
-        case ',':
-        case 'x':
-        case '(':
-        case '{':
-        case '+':
-        case '-':
-        case '*':
-        case '%':
-        case '/':
-        case '&':
-        case '|':
-        case '^':
-        case '~':
-        case '=':
-            return true;
-        case '\'':
-            return isDigitSeparator(iCode, i);
-        default:
-            return false;
-        }
-    }
-}
-
 MathLib::value operator+(const MathLib::value &v1, const MathLib::value &v2)
 {
     return MathLib::value::calc('+',v1,v2);
diff --git a/lib/mathlib.h b/lib/mathlib.h
index 9a04a43a0e7..d4cc344ee7a 100644
--- a/lib/mathlib.h
+++ b/lib/mathlib.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -23,62 +23,95 @@
 
 #include "config.h"
 
-#include <sstream>
+#include <cstdint>
 #include <string>
 
+#if defined(HAVE_BOOST) && defined(HAVE_BOOST_INT128)
+#include <boost/multiprecision/cpp_int.hpp>
+#endif
+
+class Token;
+
 /// @addtogroup Core
 /// @{
 
 /** @brief simple math functions that uses operands stored in std::string. useful when performing math on tokens. */
 
 class CPPCHECKLIB MathLib {
-    friend class TestMathLib;
-
 public:
+#if defined(HAVE_BOOST) && defined(HAVE_BOOST_INT128)
+    using bigint = boost::multiprecision::int128_t;
+    using biguint = boost::multiprecision::uint128_t;
+#else
+    using bigint = long long;
+    using biguint = unsigned long long;
+#endif
+
     /** @brief value class */
     class value {
     private:
-        long long mIntValue;
-        double mDoubleValue;
-        enum { INT, LONG, LONGLONG, FLOAT } mType;
-        bool mIsUnsigned;
+        bigint mIntValue{};
+        double mDoubleValue{};
+        enum class Type : std::uint8_t { INT, LONG, LONGLONG, FLOAT } mType;
+        bool mIsUnsigned{};
 
         void promote(const value &v);
 
     public:
+        /**
+         * @throws InternalError thrown on invalid value
+         */
         explicit value(const std::string &s);
         std::string str() const;
         bool isInt() const {
-            return mType != FLOAT;
+            return mType != Type::FLOAT;
         }
         bool isFloat() const {
-            return mType == FLOAT;
+            return mType == Type::FLOAT;
         }
 
         double getDoubleValue() const {
-            return isFloat() ? mDoubleValue : (double)mIntValue;
+            return isFloat() ? mDoubleValue : static_cast<double>(mIntValue);
         }
 
+        /**
+         * @throws InternalError thrown on invalid/unhandled calculation or divison by zero
+         */
         static value calc(char op, const value &v1, const value &v2);
         int compare(const value &v) const;
         value add(int v) const;
+        /**
+         * @throws InternalError thrown if operand is not an integer
+         */
         value shiftLeft(const value &v) const;
+        /**
+         * @throws InternalError thrown if operand is not an integer
+         */
         value shiftRight(const value &v) const;
     };
 
-    typedef long long bigint;
-    typedef unsigned long long biguint;
     static const int bigint_bits;
 
-    static bigint toLongNumber(const std::string & str);
-    static biguint toULongNumber(const std::string & str);
+    /** @brief for conversion of numeric literals - for atoi-like conversions please use strToInt() */
+    static bigint toBigNumber(const Token * tok);
+    /** @brief for conversion of numeric literals - for atoi-like conversions please use strToInt()
+     * @throws InternalError thrown if conversion failed
+     */
+    static bigint toBigNumber(const std::string & str, const Token *tok = nullptr);
+    /** @brief for conversion of numeric literals - for atoi-like conversions please use strToInt() */
+    static biguint toBigUNumber(const Token * tok);
+    /** @brief for conversion of numeric literals - for atoi-like conversions please use strToInt()
+     * @throws InternalError thrown if conversion failed
+     */
+    static biguint toBigUNumber(const std::string & str, const Token *tok = nullptr);
 
-    template<class T> static std::string toString(T value) {
-        std::ostringstream result;
-        result << value;
-        return result.str();
-    }
-    static double toDoubleNumber(const std::string & str);
+    template<class T> static std::string toString(T value) = delete;
+    /** @brief for conversion of numeric literals */
+    static double toDoubleNumber(const Token * tok);
+    /** @brief for conversion of numeric literals
+     * @throws InternalError thrown if conversion failed
+     */
+    static double toDoubleNumber(const std::string & str, const Token * tok = nullptr);
 
     static bool isInt(const std::string & str);
     static bool isFloat(const std::string &str);
@@ -93,6 +126,8 @@ class CPPCHECKLIB MathLib {
 
     static std::string getSuffix(const std::string& value);
     /**
+     * Only used in unit tests
+     *
      * \param[in] str string
      * \param[in] supportMicrosoftExtensions support Microsoft extension: i64
      *  \return true if str is a non-empty valid integer suffix
@@ -102,9 +137,17 @@ class CPPCHECKLIB MathLib {
     static std::string add(const std::string & first, const std::string & second);
     static std::string subtract(const std::string & first, const std::string & second);
     static std::string multiply(const std::string & first, const std::string & second);
+    /**
+     * @throws InternalError thrown on overflow or divison by zero
+     */
     static std::string divide(const std::string & first, const std::string & second);
+    /**
+     * @throws InternalError thrown on division by zero
+     */
     static std::string mod(const std::string & first, const std::string & second);
-    static std::string incdec(const std::string & var, const std::string & op);
+    /**
+     * @throws InternalError thrown on unexpected action
+     */
     static std::string calculate(const std::string & first, const std::string & second, char action);
 
     static std::string sin(const std::string & tok);
@@ -125,25 +168,7 @@ class CPPCHECKLIB MathLib {
      */
     static bool isOctalDigit(char c);
 
-    /**
-     * \param[in] str character literal
-     * @return Number of internal representation of the character literal
-     * */
-    static MathLib::bigint characterLiteralToLongNumber(const std::string& str);
-
-    /**
-     * \param[in] iCode Code being considered
-     * \param[in] iPos A posision within iCode
-     * \return Whether iCode[iPos] is a C++14 digit separator
-     */
-    static bool isDigitSeparator(const std::string& iCode, std::string::size_type iPos);
-
-private:
-    /*
-     * \param iLiteral A character literal
-     * \return The equivalent character literal with all escapes interpreted
-     */
-    static std::string normalizeCharacterLiteral(const std::string& iLiteral);
+    static unsigned int encodeMultiChar(const std::string& str);
 };
 
 MathLib::value operator+(const MathLib::value &v1, const MathLib::value &v2);
@@ -157,7 +182,9 @@ MathLib::value operator^(const MathLib::value &v1, const MathLib::value &v2);
 MathLib::value operator<<(const MathLib::value &v1, const MathLib::value &v2);
 MathLib::value operator>>(const MathLib::value &v1, const MathLib::value &v2);
 
-template<> CPPCHECKLIB std::string MathLib::toString(double value); // Declare specialization to avoid linker problems
+template<> CPPCHECKLIB std::string MathLib::toString<MathLib::bigint>(MathLib::bigint value);
+template<> CPPCHECKLIB std::string MathLib::toString<MathLib::biguint>(MathLib::biguint value);
+template<> CPPCHECKLIB std::string MathLib::toString<double>(double value);
 
 /// @}
 //---------------------------------------------------------------------------
diff --git a/lib/path.cpp b/lib/path.cpp
index 4d06a66d5b6..4f18192c7c0 100644
--- a/lib/path.cpp
+++ b/lib/path.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,37 +16,54 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#if defined(__GNUC__) && (defined(_WIN32) || defined(__CYGWIN__))
-#undef __STRICT_ANSI__
+//#define LOG_EMACS_MARKER
+
+#if defined(__CYGWIN__)
+#define _POSIX_C_SOURCE 200112L // required to have readlink()
+#define _BSD_SOURCE // required to have realpath()
 #endif
+
 #include "path.h"
 #include "utils.h"
 
 #include <algorithm>
-#include <cctype>
+#include <cstdio>
 #include <cstdlib>
-#include <cstring>
-#include <fstream>
-#include <sstream>
+#ifdef LOG_EMACS_MARKER
+#include <iostream>
+#endif
+#include <sys/stat.h>
+#include <unordered_set>
+#include <utility>
+
+#include <simplecpp.h>
 
 #ifndef _WIN32
+#include <stdexcept>
+#include <sys/types.h>
 #include <unistd.h>
 #else
 #include <direct.h>
+#include <windows.h>
 #endif
 #if defined(__CYGWIN__)
 #include <strings.h>
 #endif
+#if defined(__APPLE__)
+#include <mach-o/dyld.h>
+#endif
 
-#include <simplecpp.h>
 
 /** Is the filesystem case insensitive? */
-static bool caseInsensitiveFilesystem()
+static constexpr bool caseInsensitiveFilesystem()
 {
-#ifdef _WIN32
+#if defined(_WIN32) || (defined(__APPLE__) && defined(__MACH__))
+    // Windows is case insensitive
+    // MacOS is case insensitive by default (also supports case sensitivity)
     return true;
 #else
     // TODO: Non-windows filesystems might be case insensitive
+    // needs to be determined per filesystem and location - e.g. /sys/fs/ext4/features/casefold
     return false;
 #endif
 }
@@ -54,11 +71,11 @@ static bool caseInsensitiveFilesystem()
 std::string Path::toNativeSeparators(std::string path)
 {
 #if defined(_WIN32)
-    const char separ = '/';
-    const char native = '\\';
+    constexpr char separ = '/';
+    constexpr char native = '\\';
 #else
-    const char separ = '\\';
-    const char native = '/';
+    constexpr char separ = '\\';
+    constexpr char native = '/';
 #endif
     std::replace(path.begin(), path.end(), separ, native);
     return path;
@@ -66,15 +83,15 @@ std::string Path::toNativeSeparators(std::string path)
 
 std::string Path::fromNativeSeparators(std::string path)
 {
-    const char nonnative = '\\';
-    const char newsepar = '/';
+    constexpr char nonnative = '\\';
+    constexpr char newsepar = '/';
     std::replace(path.begin(), path.end(), nonnative, newsepar);
     return path;
 }
 
 std::string Path::simplifyPath(std::string originalPath)
 {
-    return simplecpp::simplifyPath(originalPath);
+    return simplecpp::simplifyPath(std::move(originalPath));
 }
 
 std::string Path::getPathFromFilename(const std::string &filename)
@@ -92,39 +109,30 @@ bool Path::sameFileName(const std::string &fname1, const std::string &fname2)
     return caseInsensitiveFilesystem() ? (caseInsensitiveStringCompare(fname1, fname2) == 0) : (fname1 == fname2);
 }
 
-// This wrapper exists because Sun's CC does not allow a static_cast
-// from extern "C" int(*)(int) to int(*)(int).
-static int tolowerWrapper(int c)
-{
-    return std::tolower(c);
-}
-
 std::string Path::removeQuotationMarks(std::string path)
 {
     path.erase(std::remove(path.begin(), path.end(), '\"'), path.end());
     return path;
 }
 
-std::string Path::getFilenameExtension(const std::string &path)
+std::string Path::getFilenameExtension(const std::string &path, bool lowercase)
 {
     const std::string::size_type dotLocation = path.find_last_of('.');
     if (dotLocation == std::string::npos)
         return "";
 
     std::string extension = path.substr(dotLocation);
-    if (caseInsensitiveFilesystem()) {
+    if (lowercase || caseInsensitiveFilesystem()) {
         // on a case insensitive filesystem the case doesn't matter so
         // let's return the extension in lowercase
-        std::transform(extension.begin(), extension.end(), extension.begin(), tolowerWrapper);
+        strTolower(extension);
     }
     return extension;
 }
 
 std::string Path::getFilenameExtensionInLowerCase(const std::string &path)
 {
-    std::string extension = getFilenameExtension(path);
-    std::transform(extension.begin(), extension.end(), extension.begin(), tolowerWrapper);
-    return extension;
+    return getFilenameExtension(path, true);
 }
 
 std::string Path::getCurrentPath()
@@ -138,26 +146,47 @@ std::string Path::getCurrentPath()
 #endif
         return std::string(currentPath);
 
-    return emptyString;
+    return "";
 }
 
-bool Path::isAbsolute(const std::string& path)
+std::string Path::getCurrentExecutablePath(const char* fallback)
 {
-    const std::string& nativePath = toNativeSeparators(path);
+    char buf[4096] = {};
+    bool success{};
+#ifdef _WIN32
+    success = (GetModuleFileNameA(nullptr, buf, sizeof(buf)) < sizeof(buf));
+#elif defined(__APPLE__)
+    uint32_t size = sizeof(buf);
+    success = (_NSGetExecutablePath(buf, &size) == 0);
+#else
+    const char* procPath =
+#ifdef __SVR4 // Solaris
+        "/proc/self/path/a.out";
+#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__)
+        "/proc/curproc/file";
+#else // Linux
+        "/proc/self/exe";
+#endif
+    // readlink does not null-terminate the string if the buffer is too small, therefore write bufsize - 1
+    success = (readlink(procPath, buf, sizeof(buf) - 1) != -1);
+#endif
+    return success ? std::string(buf) : std::string(fallback);
+}
 
+bool Path::isAbsolute(const std::string& path)
+{
 #ifdef _WIN32
     if (path.length() < 2)
         return false;
 
-    // On Windows, 'C:\foo\bar' is an absolute path, while 'C:foo\bar' is not
-    if (nativePath.compare(0, 2, "\\\\") == 0 || (std::isalpha(nativePath[0]) != 0 && nativePath.compare(1, 2, ":\\") == 0))
+    if ((path[0] == '\\' || path[0] == '/') && (path[1] == '\\' || path[1] == '/'))
         return true;
+
+    // On Windows, 'C:\foo\bar' is an absolute path, while 'C:foo\bar' is not
+    return std::isalpha(path[0]) && path[1] == ':' && (path[2] == '\\' || path[2] == '/');
 #else
-    if (!nativePath.empty() && nativePath[0] == '/')
-        return true;
+    return !path.empty() && path[0] == '/';
 #endif
-
-    return false;
 }
 
 std::string Path::getRelativePath(const std::string& absolutePath, const std::vector<std::string>& basePaths)
@@ -171,58 +200,196 @@ std::string Path::getRelativePath(const std::string& absolutePath, const std::ve
 
         if (endsWith(bp,'/'))
             return absolutePath.substr(bp.length());
-        else if (absolutePath.size() > bp.size() && absolutePath[bp.length()] == '/')
+        if (absolutePath.size() > bp.size() && absolutePath[bp.length()] == '/')
             return absolutePath.substr(bp.length() + 1);
     }
     return absolutePath;
 }
 
-bool Path::isC(const std::string &path)
+static const std::unordered_set<std::string> cpp_src_exts = {
+    ".cpp", ".cxx", ".cc", ".c++", ".tpp", ".txx", ".ipp", ".ixx"
+};
+
+static const std::unordered_set<std::string> c_src_exts = {
+    ".c", ".cl"
+};
+
+static const std::unordered_set<std::string> header_exts = {
+    ".h", ".hpp", ".h++", ".hxx", ".hh"
+};
+
+bool Path::acceptFile(const std::string &path, const std::set<std::string> &extra, Standards::Language* lang)
 {
-    // In unix, ".C" is considered C++ file
-    const std::string extension = getFilenameExtension(path);
-    return extension == ".c" ||
-           extension == ".cl";
+    bool header = false;
+    Standards::Language l = identify(path, false, &header);
+    if (lang)
+        *lang = l;
+    return (l != Standards::Language::None && !header) || extra.find(getFilenameExtension(path)) != extra.end();
 }
 
-bool Path::isCPP(const std::string &path)
+static bool hasEmacsCppMarker(const char* path)
 {
-    const std::string extension = getFilenameExtensionInLowerCase(path);
-    return extension == ".cpp" ||
-           extension == ".cxx" ||
-           extension == ".cc" ||
-           extension == ".c++" ||
-           extension == ".hpp" ||
-           extension == ".hxx" ||
-           extension == ".hh" ||
-           extension == ".tpp" ||
-           extension == ".txx" ||
-           getFilenameExtension(path) == ".C"; // In unix, ".C" is considered C++ file
+    // TODO: identify is called three times for each file
+    // Preprocessor::loadFiles() -> createDUI()
+    // Preprocessor::preprocess() -> createDUI()
+    // TokenList::createTokens() -> TokenList::determineCppC()
+#ifdef LOG_EMACS_MARKER
+    std::cout << path << '\n';
+#endif
+
+    FILE *fp = fopen(path, "rt");
+    if (!fp)
+        return false;
+    std::string buf(128, '\0');
+    {
+#if __cplusplus >= 201703L
+        // C++17 provides an overload with non-const data()
+        #define CONST_CAST(x) (x)
+#else
+        #define CONST_CAST(x) const_cast<char*>(x)
+#endif
+        // TODO: read the whole first line only
+        const char * const res = fgets(CONST_CAST(buf.data()), buf.size(), fp);
+#undef CONST_CAST
+        fclose(fp);
+        fp = nullptr;
+        if (!res)
+            return false; // failed to read file
+    }
+    // TODO: replace with regular expression
+    const auto pos1 = buf.find("-*-");
+    if (pos1 == std::string::npos)
+        return false; // no start marker
+    const auto pos_nl = buf.find_first_of("\r\n");
+    if (pos_nl != std::string::npos && (pos_nl < pos1)) {
+#ifdef LOG_EMACS_MARKER
+        std::cout << path << " - Emacs marker not on the first line" << '\n';
+#endif
+        return false; // not on first line
+    }
+    const auto pos2 = buf.find("-*-", pos1 + 3);
+    // TODO: make sure we have read the whole line before bailing out
+    if (pos2 == std::string::npos) {
+#ifdef LOG_EMACS_MARKER
+        std::cout << path << " - Emacs marker not terminated" << '\n';
+#endif
+        return false; // no end marker
+    }
+#ifdef LOG_EMACS_MARKER
+    std::cout << "Emacs marker: '"  << buf.substr(pos1, (pos2 + 3) - pos1) << "'" << '\n';
+#endif
+    // TODO: support /* */ comments
+    const std::string buf_trim = trim(buf); // trim whitespaces
+    if (buf_trim[0] == '/' && buf_trim[1] == '*') {
+        const auto pos_cmt = buf.find("*/", 2);
+        if (pos_cmt != std::string::npos && pos_cmt < (pos2 + 3))
+        {
+ #ifdef LOG_EMACS_MARKER
+            std::cout << path << " - Emacs marker not contained in C-style comment block: '"  << buf.substr(pos1, (pos2 + 3) - pos1) << "'" << '\n';
+ #endif
+            return false; // not in a comment
+        }
+    }
+    else if (buf_trim[0] != '/' || buf_trim[1] != '/') {
+#ifdef LOG_EMACS_MARKER
+        std::cout << path << " - Emacs marker not in a comment: '"  << buf.substr(pos1, (pos2 + 3) - pos1) << "'" << '\n';
+#endif
+        return false; // not in a comment
+    }
+
+    // there are more variations with lowercase and no whitespaces
+    // -*- C++ -*-
+    // -*- Mode: C++; -*-
+    // -*- Mode: C++; c-basic-offset: 8 -*-
+    std::string marker = trim(buf.substr(pos1 + 3, pos2 - pos1 - 3), " ;");
+    // cut off additional attributes
+    const auto pos_semi = marker.find(';');
+    if (pos_semi != std::string::npos)
+        marker.resize(pos_semi);
+    findAndReplace(marker, "mode:", "");
+    findAndReplace(marker, "Mode:", "");
+    marker = trim(marker);
+    if (marker == "C++" || marker == "c++") {
+        // NOLINTNEXTLINE(readability-simplify-boolean-expr) - TODO: FP
+        return true; // C++ marker found
+    }
+
+    //if (marker == "C" || marker == "c")
+    //    return false;
+#ifdef LOG_EMACS_MARKER
+    std::cout << path << " - unmatched Emacs marker: '"  << marker << "'" << '\n';
+#endif
+
+    return false; // marker is not a C++ one
 }
 
-bool Path::acceptFile(const std::string &path, const std::set<std::string> &extra)
+Standards::Language Path::identify(const std::string &path, bool cppHeaderProbe, bool *header)
 {
-    return !Path::isHeader(path) && (Path::isCPP(path) || Path::isC(path) || extra.find(getFilenameExtension(path)) != extra.end());
+    if (header)
+        *header = false;
+
+    std::string ext = getFilenameExtension(path);
+    // standard library headers have no extension
+    if (cppHeaderProbe && ext.empty()) {
+        if (hasEmacsCppMarker(path.c_str())) {
+            if (header)
+                *header = true;
+            return Standards::Language::CPP;
+        }
+        return Standards::Language::None;
+    }
+    if (ext == ".C")
+        return Standards::Language::CPP;
+    if (c_src_exts.find(ext) != c_src_exts.end())
+        return Standards::Language::C;
+    if (!caseInsensitiveFilesystem())
+        strTolower(ext);
+    if (ext == ".h") {
+        if (header)
+            *header = true;
+        if (cppHeaderProbe && hasEmacsCppMarker(path.c_str()))
+            return Standards::Language::CPP;
+        return Standards::Language::C;
+    }
+    if (cpp_src_exts.find(ext) != cpp_src_exts.end())
+        return Standards::Language::CPP;
+    if (header_exts.find(ext) != header_exts.end()) {
+        if (header)
+            *header = true;
+        return Standards::Language::CPP;
+    }
+    return Standards::Language::None;
 }
 
 bool Path::isHeader(const std::string &path)
 {
-    const std::string extension = getFilenameExtensionInLowerCase(path);
-    return (extension.compare(0, 2, ".h") == 0);
+    bool header;
+    (void)identify(path, false, &header);
+    return header;
 }
 
 std::string Path::getAbsoluteFilePath(const std::string& filePath)
 {
+    if (filePath.empty())
+        return "";
+
     std::string absolute_path;
 #ifdef _WIN32
     char absolute[_MAX_PATH];
     if (_fullpath(absolute, filePath.c_str(), _MAX_PATH))
         absolute_path = absolute;
+    if (!absolute_path.empty() && absolute_path.back() == '\\')
+        absolute_path.pop_back();
 #elif defined(__linux__) || defined(__sun) || defined(__hpux) || defined(__GNUC__) || defined(__CPPCHECK__)
-    char * absolute = realpath(filePath.c_str(), nullptr);
+    // simplify the path since any non-existent part has to exist even if discarded by ".."
+    std::string spath = Path::simplifyPath(filePath);
+    char * absolute = realpath(spath.c_str(), nullptr);
     if (absolute)
         absolute_path = absolute;
     free(absolute);
+    // only throw on realpath() fialure to resolve a path when the given one was non-existent
+    if (!spath.empty() && absolute_path.empty() && !exists(spath))
+        throw std::runtime_error("path '" + filePath + "' does not exist");
 #else
 #error Platform absolute path function needed
 #endif
@@ -232,9 +399,9 @@ std::string Path::getAbsoluteFilePath(const std::string& filePath)
 std::string Path::stripDirectoryPart(const std::string &file)
 {
 #if defined(_WIN32) && !defined(__MINGW32__)
-    const char native = '\\';
+    constexpr char native = '\\';
 #else
-    const char native = '/';
+    constexpr char native = '/';
 #endif
 
     const std::string::size_type p = file.rfind(native);
@@ -244,8 +411,50 @@ std::string Path::stripDirectoryPart(const std::string &file)
     return file;
 }
 
-bool Path::fileExists(const std::string &file)
+#ifdef _WIN32
+using mode_t = unsigned short;
+#endif
+
+static mode_t file_type(const std::string &path)
+{
+    struct stat file_stat;
+    if (stat(path.c_str(), &file_stat) == -1)
+        return 0;
+    return file_stat.st_mode & S_IFMT;
+}
+
+bool Path::isFile(const std::string &path)
+{
+    return file_type(path) == S_IFREG;
+}
+
+bool Path::isDirectory(const std::string &path)
+{
+    return file_type(path) == S_IFDIR;
+}
+
+bool Path::exists(const std::string &path, bool* isdir)
+{
+    const auto type = file_type(path);
+    if (type == S_IFDIR)
+    {
+        if (isdir)
+            *isdir = true;
+        return true;
+    }
+    if (isdir)
+        *isdir = false;
+    return type == S_IFREG;
+}
+
+std::string Path::join(std::string path1, std::string path2)
 {
-    std::ifstream f(file.c_str());
-    return f.is_open();
+    path1 = fromNativeSeparators(std::move(path1));
+    path2 = fromNativeSeparators(std::move(path2));
+    if (path1.empty() || path2.empty())
+        return path1 + path2;
+    // this matches the behavior of std::filesystem::path::operator/=() and os.path.join()
+    if (path2.front() == '/')
+        return path2;
+    return ((path1.back() == '/') ? path1 : (path1 + "/")) + path2;
 }
diff --git a/lib/path.h b/lib/path.h
index 588a30bef23..23db06c4e50 100644
--- a/lib/path.h
+++ b/lib/path.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,6 +22,7 @@
 //---------------------------------------------------------------------------
 
 #include "config.h"
+#include "standards.h"
 
 #include <set>
 #include <string>
@@ -47,10 +48,10 @@ class CPPCHECKLIB Path {
     static std::string toNativeSeparators(std::string path);
 
     /**
-      * Convert path to use internal path separators.
-      * @param path Path string to convert.
-      * @return converted path.
-      */
+     * Convert path to use internal path separators.
+     * @param path Path string to convert.
+     * @return converted path.
+     */
     static std::string fromNativeSeparators(std::string path);
 
     /**
@@ -84,17 +85,18 @@ class CPPCHECKLIB Path {
     static std::string removeQuotationMarks(std::string path);
 
     /**
-      * @brief Get an extension of the filename.
-      * @param path Path containing filename.
-      * @return Filename extension (containing the dot, e.g. ".h" or ".CPP").
-      */
-    static std::string getFilenameExtension(const std::string &path);
+     * @brief Get an extension of the filename.
+     * @param path Path containing filename.
+     * @param lowercase Return the extension in lower case
+     * @return Filename extension (containing the dot, e.g. ".h" or ".CPP").
+     */
+    static std::string getFilenameExtension(const std::string &path, bool lowercase = false);
 
     /**
-      * @brief Get an extension of the filename in lower case.
-      * @param path Path containing filename.
-      * @return Filename extension (containing the dot, e.g. ".h").
-      */
+     * @brief Get an extension of the filename in lower case.
+     * @param path Path containing filename.
+     * @return Filename extension (containing the dot, e.g. ".h").
+     */
     static std::string getFilenameExtensionInLowerCase(const std::string &path);
 
     /**
@@ -103,6 +105,12 @@ class CPPCHECKLIB Path {
      */
     static std::string getCurrentPath();
 
+    /**
+     * @brief Returns the absolute path to the current executable
+     * @return absolute path to the current executable
+     */
+    static std::string getCurrentExecutablePath(const char* fallback);
+
     /**
      * @brief Check if given path is absolute
      * @param path Path to check
@@ -111,60 +119,57 @@ class CPPCHECKLIB Path {
     static bool isAbsolute(const std::string& path);
 
     /**
-      * @brief Create a relative path from an absolute one, if absolute path is inside the basePaths.
-      * @param absolutePath Path to be made relative.
-      * @param basePaths Paths to which it may be made relative.
-      * @return relative path, if possible. Otherwise absolutePath is returned unchanged
-      */
+     * @brief Create a relative path from an absolute one, if absolute path is inside the basePaths.
+     * @param absolutePath Path to be made relative.
+     * @param basePaths Paths to which it may be made relative.
+     * @return relative path, if possible. Otherwise absolutePath is returned unchanged
+     */
     static std::string getRelativePath(const std::string& absolutePath, const std::vector<std::string>& basePaths);
 
     /**
-      * @brief Get an absolute file path from a relative one.
-      * @param filePath File path to be made absolute.
-      * @return absolute path, if possible. Otherwise an empty path is returned
-      */
+     * @brief Get an absolute file path from a relative one.
+     * @param filePath File path to be made absolute.
+     * @return absolute path, if possible. Otherwise an empty path is returned
+     */
     static std::string getAbsoluteFilePath(const std::string& filePath);
 
     /**
      * @brief Check if the file extension indicates that it's a C/C++ source file.
      * Check if the file has source file extension: *.c;*.cpp;*.cxx;*.c++;*.cc;*.txx
      * @param filename filename to check. path info is optional
+     * @param lang the detected language
      * @return true if the file extension indicates it should be checked
      */
-    static bool acceptFile(const std::string &filename) {
+    static bool acceptFile(const std::string &filename, Standards::Language* lang = nullptr) {
         const std::set<std::string> extra;
-        return acceptFile(filename, extra);
+        return acceptFile(filename, extra, lang);
     }
 
     /**
      * @brief Check if the file extension indicates that it's a C/C++ source file.
      * Check if the file has source file extension: *.c;*.cpp;*.cxx;*.c++;*.cc;*.txx
      * @param path filename to check. path info is optional
-     * @param extra    extra file extensions
+     * @param extra extra file extensions
+     * @param lang the detected language
      * @return true if the file extension indicates it should be checked
      */
-    static bool acceptFile(const std::string &path, const std::set<std::string> &extra);
-
-    /**
-     * @brief Identify language based on file extension.
-     * @param path filename to check. path info is optional
-     * @return true if extension is meant for C files
-     */
-    static bool isC(const std::string &path);
+    static bool acceptFile(const std::string &path, const std::set<std::string> &extra, Standards::Language* lang = nullptr);
 
     /**
-     * @brief Identify language based on file extension.
+     * @brief Is filename a header based on file extension
      * @param path filename to check. path info is optional
-     * @return true if extension is meant for C++ files
+     * @return true if filename extension is meant for headers
      */
-    static bool isCPP(const std::string &path);
+    static bool isHeader(const std::string &path);
 
     /**
-     * @brief Is filename a header based on file extension
+     * @brief Identify the language based on the file extension
      * @param path filename to check. path info is optional
-     * @return true if filename extension is meant for headers
+     * @param cppHeaderProbe check optional Emacs marker to identify extension-less and *.h files as C++
+     * @param header if provided indicates if the file is a header
+     * @return the language type
      */
-    static bool isHeader(const std::string &path);
+    static Standards::Language identify(const std::string &path, bool cppHeaderProbe, bool *header = nullptr);
 
     /**
      * @brief Get filename without a directory path part.
@@ -173,7 +178,34 @@ class CPPCHECKLIB Path {
      */
     static std::string stripDirectoryPart(const std::string &file);
 
-    static bool fileExists(const std::string &file);
+    /**
+     * @brief Checks if given path is a file
+     * @param path Path to be checked
+     * @return true if given path is a file
+     */
+    static bool isFile(const std::string &path);
+
+    /**
+     * @brief Checks if a given path is a directory
+     * @param path Path to be checked
+     * @return true if given path is a directory
+     */
+    static bool isDirectory(const std::string &path);
+
+    /**
+     * @brief Checks if a given path exists (i.e. is a file or directory)
+     * @param path Path to be checked
+     * @param isdir Optional parameter which indicates if the existing path is a directory
+     * @return true if given path exists
+     */
+    static bool exists(const std::string &path, bool* isdir = nullptr);
+
+    /**
+     * @brief join 2 paths with '/' separators
+     * if path2 is an absolute path path1 will be dismissed.
+     * @return the joined path with normalized slashes
+     */
+    static std::string join(std::string path1, std::string path2);
 };
 
 /// @}
diff --git a/lib/pathanalysis.cpp b/lib/pathanalysis.cpp
new file mode 100644
index 00000000000..8b2e1b61cbb
--- /dev/null
+++ b/lib/pathanalysis.cpp
@@ -0,0 +1,195 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "pathanalysis.h"
+
+#include "astutils.h"
+#include "symboldatabase.h"
+#include "token.h"
+#include "vfvalue.h"
+
+#include <algorithm>
+#include <string>
+#include <tuple>
+
+const Scope* PathAnalysis::findOuterScope(const Scope * scope)
+{
+    if (!scope)
+        return nullptr;
+    if (scope->isLocal() && scope->type != ScopeType::eSwitch)
+        return findOuterScope(scope->nestedIn);
+    return scope;
+}
+
+static const Token* assignExpr(const Token* tok)
+{
+    while (tok->astParent() && astIsLHS(tok)) {
+        if (Token::Match(tok->astParent(), "%assign%"))
+            return tok->astParent();
+        tok = tok->astParent();
+    }
+    return nullptr;
+}
+
+std::pair<bool, bool> PathAnalysis::checkCond(const Token * tok, bool& known)
+{
+    if (const ValueFlow::Value* v = tok->getKnownValue(ValueFlow::Value::ValueType::INT)) {
+        known = true;
+        return std::make_pair(!!v->intvalue, !v->intvalue);
+    }
+    auto it = std::find_if(tok->values().cbegin(), tok->values().cend(), [](const ValueFlow::Value& v) {
+        return v.isIntValue();
+    });
+    // If all possible values are the same, then assume all paths have the same value
+    if (it != tok->values().cend() && std::all_of(it, tok->values().cend(), [&](const ValueFlow::Value& v) {
+        if (v.isIntValue())
+            return v.intvalue == it->intvalue;
+        return true;
+    })) {
+        known = false;
+        return std::make_pair(!!it->intvalue, !it->intvalue);
+    }
+    return std::make_pair(true, true);
+}
+
+PathAnalysis::Progress PathAnalysis::forwardRecursive(const Token* tok, Info info, const std::function<PathAnalysis::Progress(const Info&)>& f)
+{
+    if (!tok)
+        return Progress::Continue;
+    if (tok->astOperand1() && forwardRecursive(tok->astOperand1(), info, f) == Progress::Break)
+        return Progress::Break;
+    info.tok = tok;
+    if (f(info) == Progress::Break)
+        return Progress::Break;
+    if (tok->astOperand2() && forwardRecursive(tok->astOperand2(), std::move(info), f) == Progress::Break)
+        return Progress::Break;
+    return Progress::Continue;
+}
+
+PathAnalysis::Progress PathAnalysis::forwardRange(const Token* startToken, const Token* endToken, Info info, const std::function<PathAnalysis::Progress(const Info&)>& f) const
+{
+    for (const Token *tok = startToken; precedes(tok, endToken); tok = tok->next()) {
+        if (Token::Match(tok, "asm|goto|break|continue"))
+            return Progress::Break;
+        if (Token::Match(tok, "return|throw")) {
+            forwardRecursive(tok, std::move(info), f);
+            return Progress::Break;
+            // Evaluate RHS of assignment before LHS
+        }
+        if (const Token* assignTok = assignExpr(tok)) {
+            if (forwardRecursive(assignTok->astOperand2(), info, f) == Progress::Break)
+                return Progress::Break;
+            if (forwardRecursive(assignTok->astOperand1(), info, f) == Progress::Break)
+                return Progress::Break;
+            tok = nextAfterAstRightmostLeaf(assignTok);
+            if (!tok)
+                return Progress::Break;
+        } else if (Token::simpleMatch(tok, "}") && Token::simpleMatch(tok->link()->previous(), ") {") && Token::Match(tok->link()->linkAt(-1)->previous(), "if|while|for (")) {
+            const Token * blockStart = tok->link()->linkAt(-1)->previous();
+            const Token * condTok = getCondTok(blockStart);
+            if (!condTok)
+                continue;
+            info.errorPath.emplace_back(condTok, "Assuming condition is true.");
+            // Traverse a loop a second time
+            if (Token::Match(blockStart, "for|while (")) {
+                const Token* endCond = blockStart->linkAt(1);
+                bool traverseLoop = true;
+                // Only traverse simple for loops
+                if (Token::simpleMatch(blockStart, "for") && !Token::Match(endCond->tokAt(-3), "; ++|--|%var% %var%|++|-- ) {"))
+                    traverseLoop = false;
+                // Traverse loop a second time
+                if (traverseLoop) {
+                    // Traverse condition
+                    if (forwardRecursive(condTok, info, f) == Progress::Break)
+                        return Progress::Break;
+                    // TODO: Should we traverse the body: forwardRange(tok->link(), tok, info, f)?
+                }
+            }
+            if (Token::simpleMatch(tok, "} else {")) {
+                tok = tok->linkAt(2);
+            }
+        } else if (Token::Match(tok, "if|while|for (") && Token::simpleMatch(tok->linkAt(1), ") {")) {
+            const Token * endCond = tok->linkAt(1);
+            const Token * endBlock = endCond->linkAt(1);
+            const Token * condTok = getCondTok(tok);
+            if (!condTok)
+                continue;
+            // Traverse condition
+            if (forwardRange(tok->next(), tok->linkAt(1), info, f) == Progress::Break)
+                return Progress::Break;
+            Info i = info;
+            i.known = false;
+            i.errorPath.emplace_back(condTok, "Assuming condition is true.");
+
+            // Check if condition is true or false
+            bool checkThen = false;
+            bool checkElse = false;
+            std::tie(checkThen, checkElse) = checkCond(condTok, i.known);
+
+            // Traverse then block
+            if (checkThen) {
+                if (forwardRange(endCond->next(), endBlock, i, f) == Progress::Break)
+                    return Progress::Break;
+            }
+            // Traverse else block
+            if (Token::simpleMatch(endBlock, "} else {")) {
+                if (checkElse) {
+                    i.errorPath.back().second = "Assuming condition is false.";
+                    const Progress result = forwardRange(endCond->next(), endBlock, std::move(i), f);
+                    if (result == Progress::Break)
+                        return Progress::Break;
+                }
+                tok = endBlock->linkAt(2);
+            } else {
+                tok = endBlock;
+            }
+        } else if (Token::simpleMatch(tok, "} else {")) {
+            tok = tok->linkAt(2);
+        } else {
+            info.tok = tok;
+            if (f(info) == Progress::Break)
+                return Progress::Break;
+        }
+        // Prevent infinite recursion
+        if (tok->next() == mStart)
+            break;
+    }
+    return Progress::Continue;
+}
+
+void PathAnalysis::forward(const std::function<Progress(const Info&)>& f) const
+{
+    const Scope * endScope = findOuterScope(mStart->scope());
+    if (!endScope)
+        return;
+    const Token * endToken = endScope->bodyEnd;
+    Info info{mStart, ErrorPath{}, true};
+    forwardRange(mStart, endToken, std::move(info), f);
+}
+
+bool reaches(const Token * start, const Token * dest, ErrorPath* errorPath)
+{
+    PathAnalysis::Info info = PathAnalysis{start}.forwardFind([&](const PathAnalysis::Info& i) {
+        return (i.tok == dest);
+    });
+    if (!info.tok)
+        return false;
+    if (errorPath)
+        errorPath->insert(errorPath->end(), info.errorPath.cbegin(), info.errorPath.cend());
+    return true;
+}
diff --git a/lib/pathanalysis.h b/lib/pathanalysis.h
new file mode 100644
index 00000000000..1085fec3f4b
--- /dev/null
+++ b/lib/pathanalysis.h
@@ -0,0 +1,81 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GUARD_PATHANALYSIS_H
+#define GUARD_PATHANALYSIS_H
+
+#include "errortypes.h"
+
+#include <cstdint>
+#include <functional>
+#include <utility>
+
+class Scope;
+class Token;
+
+struct PathAnalysis {
+    enum class Progress : std::uint8_t {
+        Continue,
+        Break
+    };
+
+    explicit PathAnalysis(const Token* start)
+        : mStart(start)
+    {}
+
+    struct Info {
+        const Token* tok;
+        ErrorPath errorPath;
+        bool known;
+    };
+
+    Info forwardFind(std::function<bool(const Info&)> pred) const {
+        Info result{};
+        forward([&](const Info& info) {
+            if (pred(info)) {
+                result = info;
+                return Progress::Break;
+            }
+            return Progress::Continue;
+        });
+        return result;
+    }
+private:
+    const Token * mStart;
+
+    void forward(const std::function<Progress(const Info&)>& f) const;
+
+    static Progress forwardRecursive(const Token* tok, Info info, const std::function<PathAnalysis::Progress(const Info&)>& f);
+    Progress forwardRange(const Token* startToken, const Token* endToken, Info info, const std::function<Progress(const Info&)>& f) const;
+
+    static const Scope* findOuterScope(const Scope * scope);
+
+    static std::pair<bool, bool> checkCond(const Token * tok, bool& known);
+};
+
+/**
+ * @brief Returns true if there is a path between the two tokens
+ *
+ * @param start Starting point of the path
+ * @param dest The path destination
+ * @param errorPath Adds the path traversal to the errorPath
+ */
+bool reaches(const Token * start, const Token * dest, ErrorPath* errorPath);
+
+#endif
+
diff --git a/lib/pathmatch.cpp b/lib/pathmatch.cpp
index 79525cd804e..90844befa82 100644
--- a/lib/pathmatch.cpp
+++ b/lib/pathmatch.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,67 +19,133 @@
 #include "pathmatch.h"
 
 #include "path.h"
-#include "utils.h"
 
 #include <algorithm>
-#include <cctype>
-#include <cstddef>
+#include <stack>
+#include <string>
+#include <utility>
+#include <vector>
 
-PathMatch::PathMatch(const std::vector<std::string> &excludedPaths, bool caseSensitive)
-    : mExcludedPaths(excludedPaths), mCaseSensitive(caseSensitive)
+
+PathMatch::PathMatch(std::vector<std::string> patterns, std::string basepath, Syntax syntax) :
+    mPatterns(std::move(patterns)), mBasepath(std::move(basepath)), mSyntax(syntax)
+{}
+
+bool PathMatch::match(const std::string &path, Filemode mode) const
 {
-    if (!mCaseSensitive)
-        for (std::vector<std::string>::iterator i = mExcludedPaths.begin(); i != mExcludedPaths.end(); ++i)
-            std::transform(i->begin(), i->end(), i->begin(), ::tolower);
-    mWorkingDirectory.push_back(Path::getCurrentPath());
+    return std::any_of(mPatterns.cbegin(), mPatterns.cend(), [&] (const std::string &pattern) {
+        return match(pattern, path, mBasepath, mode, mSyntax);
+    });
 }
 
-bool PathMatch::match(const std::string &path) const
+bool PathMatch::match(const std::string &pattern, const std::string &path, const std::string &basepath, Filemode mode, Syntax syntax)
 {
-    if (path.empty())
+    /* Fast paths for common patterns */
+    if (pattern.empty())
         return false;
 
-    for (std::vector<std::string>::const_iterator i = mExcludedPaths.begin(); i != mExcludedPaths.end(); ++i) {
-        const std::string excludedPath((!Path::isAbsolute(path) && Path::isAbsolute(*i)) ? Path::getRelativePath(*i, mWorkingDirectory) : *i);
+    if (pattern == "*" || pattern == "**")
+        return true;
+
+    /* If the pattern ends with a path separator it matches only directories. If the path names a regular file then
+     * the last path component can't match. */
+    bool dir_mismatch = PathIterator::issep(pattern.back(), syntax) && mode != Filemode::directory;
 
-        std::string findpath = Path::fromNativeSeparators(path);
-        if (!mCaseSensitive)
-            std::transform(findpath.begin(), findpath.end(), findpath.begin(), ::tolower);
+    if (!dir_mismatch && pattern == path)
+        return true;
 
-        // Filtering directory name
-        if (endsWith(excludedPath,'/')) {
-            if (!endsWith(findpath,'/'))
-                findpath = removeFilename(findpath);
+    /* A "real" pattern is absolute or relative to the base path. A pattern that isn't real can match at any
+     * path component boundary. */
+    bool real = Path::isAbsolute(pattern) || isRelativePattern(pattern);
+
+    /* Pattern iterator */
+    PathIterator s = PathIterator::fromPattern(pattern, basepath, syntax);
+    /* Path iterator */
+    PathIterator t = PathIterator::fromPath(path, basepath, syntax);
+
+    if (dir_mismatch) {
+        /* Final compponent can't match, so skip it. */
+        while (*t != '\0' && *t != '/')
+            ++t;
+    }
 
-            if (excludedPath.length() > findpath.length())
+    /* Pattern restart position */
+    PathIterator p = s;
+    /* Path restart position */
+    PathIterator q = t;
+
+    /* Backtrack stack */
+    std::stack<std::pair<PathIterator::Pos, PathIterator::Pos>> b;
+
+    for (;;) {
+        switch (*s) {
+        /* Star or star-star, matches any number of characters */
+        case '*': {
+            bool slash = false;
+            ++s;
+            if (*s == '*') {
+                /* Star-star matches slashes as well */
+                slash = true;
+                ++s;
+            }
+            while (*t != '\0' && (slash || *t != '/')) {
+                if (*s == *t) {
+                    /* Could stop here, but do greedy match and add
+                     * backtrack instead */
+                    b.emplace(s.getpos(), t.getpos());
+                }
+                ++t;
+            }
+            continue;
+        }
+        /* Single character wildcard */
+        case '?': {
+            if (*t != '\0' && *t != '/') {
+                ++s;
+                ++t;
                 continue;
-            // Match relative paths starting with mask
-            // -isrc matches src/foo.cpp
-            if (findpath.compare(0, excludedPath.size(), excludedPath) == 0)
-                return true;
-            // Match only full directory name in middle or end of the path
-            // -isrc matches myproject/src/ but does not match
-            // myproject/srcfiles/ or myproject/mysrc/
-            if (findpath.find("/" + excludedPath) != std::string::npos)
+            }
+            break;
+        }
+        /* Start of pattern; matches start of path, or a path separator if the
+         * pattern is not "real" (an absolute or relative path). */
+        case '\0': {
+            if (*t == '\0' || (*t == '/' && !real))
                 return true;
+            break;
         }
-        // Filtering filename
-        else {
-            if (excludedPath.length() > findpath.length())
+        /* Literal character */
+        default: {
+            if (*s == *t) {
+                ++s;
+                ++t;
                 continue;
-            // Check if path ends with mask
-            // -ifoo.cpp matches (./)foo.c, src/foo.cpp and proj/src/foo.cpp
-            // -isrc/file.cpp matches src/foo.cpp and proj/src/foo.cpp
-            if (findpath.compare(findpath.size() - excludedPath.size(), findpath.size(), excludedPath) == 0)
-                return true;
+            }
+            break;
+        }
+        }
 
+        /* No match, try to backtrack */
+        if (!b.empty()) {
+            const auto bp = b.top();
+            b.pop();
+            s.setpos(bp.first);
+            t.setpos(bp.second);
+            continue;
         }
-    }
-    return false;
-}
 
-std::string PathMatch::removeFilename(const std::string &path)
-{
-    const std::size_t ind = path.find_last_of('/');
-    return path.substr(0, ind + 1);
+        /* Couldn't backtrack, try matching from the next path separator */
+        while (*q != '\0' && *q != '/')
+            ++q;
+
+        if (*q == '/') {
+            ++q;
+            s = p;
+            t = q;
+            continue;
+        }
+
+        /* No more path seperators to try from */
+        return false;
+    }
 }
diff --git a/lib/pathmatch.h b/lib/pathmatch.h
index c8cd4591b15..b196528245c 100644
--- a/lib/pathmatch.h
+++ b/lib/pathmatch.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,46 +21,419 @@
 
 #include "config.h"
 
+#include <cctype>
+#include <cstdint>
+#include <cstdio>
 #include <string>
 #include <vector>
 
+#include "path.h"
+
 /// @addtogroup CLI
 /// @{
 
 /**
- * @brief Simple path matching for ignoring paths in CLI.
+ * Path matching rules:
+ * - All patterns are canonicalized (path separators vary by platform):
+ *   - '/./' => '/'
+ *   - '/dir/../' => '/'
+ *   - '//' => '/'
+ *   - Trailing slashes are removed (root slash is preserved)
+ * - Patterns can contain globs:
+ *   - '**' matches any number of characters including path separators.
+ *   - '*' matches any number of characters except path separators.
+ *   - '?' matches any single character except path separators.
+ * - If a pattern looks like an absolute path (e.g. starts with '/', but varies by platform):
+ *   - Match all files where the pattern matches the start of the file's canonical absolute path up until a path
+ *     separator or the end of the pathname.
+ * - If a pattern looks like a relative path, i.e. is '.' or '..', or
+ *   starts with '.' or '..' followed by a path separator:
+ *   - The pattern is interpreted as a path relative to `basepath` and then converted to an absolute path and
+ *     treated as such according to the above procedure. If the pattern is relative to some other directory, it should
+ *     be modified to be relative to `basepath` first (this should be done with patterns in project files, for example).
+ * - Otherwise:
+ *   - Match all files where the pattern matches any part of the file's canonical absolute path up until a
+ *     path separator or the end of the pathname, and the matching part directly follows a path separator.
+ * - If a pattern ends with a path separator before canonicalization then the final path component of the pattern
+ *   only matches the final path component of the file path if the file is a directory (specified by the file mode
+ *   parameter).
+ *
+ * TODO: Handle less common windows syntaxes:
+ *   - Drive-specific relative path: C:dir\foo.cpp
+ *   - Root-relative path: \dir\foo.cpp
+ **/
+
+/**
+ * @brief Syntactic path matching for ignoring paths in CLI.
  */
 class CPPCHECKLIB PathMatch {
 public:
 
+    /**
+     * @brief Path syntax.
+     *
+     * windows: Case insensitive, forward and backward slashes, UNC or drive letter root.
+     * unix: Case sensitive, forward slashes, slash root.
+     *
+     */
+    enum class Syntax : std::uint8_t {
+        windows,
+        unix,
+    };
+
+    /**
+     * @brief The default syntax for the current platform.
+     */
+#ifdef _WIN32
+    static constexpr Syntax platform_syntax = Syntax::windows;
+#else
+    static constexpr Syntax platform_syntax = Syntax::unix;
+#endif
+
+    /**
+     * @brief File mode of a file being matched
+     *
+     * regular: File is a regular file.
+     * directory: File is a directory.
+     */
+    enum class Filemode : std::uint8_t {
+        regular,
+        directory,
+    };
+
     /**
      * The constructor.
-     * @param excludedPaths List of masks.
-     * @param caseSensitive Match the case of the characters when
-     *   matching paths?
+     *
+     * @param patterns List of patterns.
+     * @param basepath Path to which patterns and matched paths are relative, when applicable.
+     * @param syntax Path syntax.
      */
-    explicit PathMatch(const std::vector<std::string> &excludedPaths, bool caseSensitive = true);
+    explicit PathMatch(std::vector<std::string> patterns = {}, std::string basepath = std::string(), Syntax syntax = platform_syntax);
 
     /**
-     * @brief Match path against list of masks.
+     * @brief Match path against list of patterns.
+     *
      * @param path Path to match.
+     * @param mode The file mode of the file named by the path.
      * @return true if any of the masks match the path, false otherwise.
      */
-    bool match(const std::string &path) const;
+    bool match(const std::string &path, Filemode mode = Filemode::regular) const;
 
-protected:
+    /**
+     * @brief Match path against a single pattern.
+     *
+     * @param pattern Pattern to use.
+     * @param path Path to match.
+     * @param basepath Path to which the pattern and path is relative, when applicable.
+     * @param mode The file mode of the file named by the path.
+     * @param syntax Path syntax.
+     * @return true if the pattern matches the path, false otherwise.
+     */
+    static bool match(const std::string &pattern, const std::string &path, const std::string &basepath = std::string(), Filemode mode = Filemode::regular, Syntax syntax = platform_syntax);
 
     /**
-     * @brief Remove filename part from the path.
-     * @param path Path to edit.
-     * @return path without filename part.
+     * @brief Check if a pattern is a relative path name.
+     *
+     * @param pattern Pattern to check.
+     * @return true if the pattern has the form of a relative path name pattern.
      */
-    static std::string removeFilename(const std::string &path);
+    static bool isRelativePattern(const std::string &pattern)
+    {
+        if (pattern.empty() || pattern[0] != '.')
+            return false;
+
+        if (pattern.size() < 2 || pattern[1] == '/' || pattern[1] == '\\')
+            return true;
+
+        if (pattern[1] != '.')
+            return false;
+
+        if (pattern.size() < 3 || pattern[2] == '/' || pattern[2] == '\\')
+            return true;
+
+        return false;
+    }
+
+    /**
+     * @brief Join a pattern with a base path.
+     *
+     * @param basepath The base path to join the pattern to.
+     * @param pattern The pattern to join.
+     * @return The pattern appended to the base path with a separator if the pattern is a relative
+     * path name, otherwise just returns pattern.
+     */
+    static std::string joinRelativePattern(const std::string &basepath, const std::string &pattern)
+    {
+        if (isRelativePattern(pattern))
+            return Path::join(basepath, pattern);
+        return pattern;
+    }
+
+protected:
+    class PathIterator;
+
+private:
+    /* List of patterns */
+    std::vector<std::string> mPatterns;
+    /* Base path to with patterns and paths are relative */
+    std::string mBasepath;
+    /* The syntax to use */
+    Syntax mSyntax;
+};
+
+/**
+ * A more correct and less convenient name for this class would be PathStringsCanonicalReverseIterator.
+ *
+ * This class takes two path strings and iterates their concatenation in reverse while doing canonicalization,
+ * i.e. collapsing double-dots, removing extra slashes, dot-slashes, and trailing slashes, as well as converting
+ * native slashes to forward slashes and optionally converting characters to lowercase.
+ *
+ * Both strings are optional. If both strings are present, then they're concatenated with a slash
+ * (subject to canonicalization).
+ *
+ * Double-dots at the root level are removed. Trailing slashes are removed, the root is preserved.
+ *
+ * Doing the iteration in reverse allows canonicalization to be performed without lookahead. This is useful
+ * for comparing path strings, potentially relative to different base paths, without having to do prior string
+ * processing or extra allocations.
+ *
+ * The length of the output is at most strlen(a) + strlen(b) + 1.
+ *
+ * Example:
+ *   - input:  "/hello/universe/.", "../world//"
+ *   - output: "dlrow/olleh/"
+ **/
+class PathMatch::PathIterator {
+public:
+    /* Create from a pattern and base path */
+    static PathIterator fromPattern(const std::string &pattern, const std::string &basepath, Syntax syntax)
+    {
+        if (isRelativePattern(pattern))
+            return PathIterator(basepath.c_str(), pattern.c_str(), syntax);
+        return PathIterator(pattern.c_str(), nullptr, syntax);
+    }
+
+    /* Create from path and base path */
+    static PathIterator fromPath(const std::string &path, const std::string &basepath, Syntax syntax)
+    {
+        if (Path::isAbsolute(path))
+            return PathIterator(path.c_str(), nullptr, syntax);
+        return PathIterator(basepath.c_str(), path.c_str(), syntax);
+    }
+
+    /* Constructor */
+    explicit PathIterator(const char *path_a = nullptr, const char *path_b = nullptr, Syntax syntax = platform_syntax) :
+        mStart{path_a, path_b}, mSyntax(syntax)
+    {
+
+        for (int i = 0; i < 2; i++) {
+            const char *&p = mEnd[i];
+            p = mStart[i];
+
+            if (p == nullptr || *p == '\0')
+                continue;
+
+            if (mPos.l == 0) {
+                /* Check length of root component */
+                if (issep(p[0], syntax)) {
+                    mRootLength++;
+                    if (syntax == Syntax::windows && issep(p[1], syntax)) {
+                        mRootLength++;
+                        if (p[2] == '.' || p[2] == '?') {
+                            mRootLength++;
+                            if (issep(p[3], syntax))
+                                mRootLength++;
+                        }
+                    }
+                } else if (syntax == Syntax::windows && isdrive(p[0]) && p[1] == ':') {
+                    mRootLength += 2;
+                    if (issep(p[2], syntax))
+                        mRootLength++;
+                }
+                p += mRootLength;
+                mPos.l = mRootLength;
+            } else {
+                /* Add path separator */
+                mPos.l++;
+            }
+
+            while (*p != '\0') {
+                p++;
+                mPos.l++;
+            }
+
+            mPos.p = p - 1;
+        }
+
+        if (mPos.l == 0)
+            mPos.c = '\0';
+
+        skips(false);
+    }
+
+    /* Position struct */
+    struct Pos {
+        /* String pointer */
+        const char *p;
+        /* Raw characters left */
+        std::size_t l;
+        /* Buffered character */
+        int c {EOF};
+    };
+
+    /* Save the current position */
+    const Pos &getpos() const
+    {
+        return mPos;
+    }
+
+    /* Restore a saved position */
+    void setpos(const Pos &pos)
+    {
+        mPos = pos;
+    }
+
+    /* Read the current character */
+    char operator*() const
+    {
+        return current();
+    }
+
+    /* Go to the next character */
+    void operator++()
+    {
+        advance();
+    }
+
+    /* Consume remaining characters into an std::string and reverse, use for testing */
+    std::string read()
+    {
+        std::string str;
+
+        while (current() != '\0') {
+            str.insert(0, 1, current());
+            advance();
+        }
+
+        return str;
+    }
+
+    /* Syntax helper, check if a character is a path separator */
+    static bool issep(char c, Syntax syntax)
+    {
+        return c == '/' || (syntax == Syntax::windows && c == '\\');
+    }
+
+    /* Syntax helper, check if a chracter is a drive letter */
+    static bool isdrive(char c)
+    {
+        return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
+    }
 
 private:
-    std::vector<std::string> mExcludedPaths;
-    bool mCaseSensitive;
-    std::vector<std::string> mWorkingDirectory;
+    /* Read the current character */
+    char current() const
+    {
+        if (mPos.c != EOF)
+            return mPos.c;
+
+        char c = *mPos.p;
+
+        if (mSyntax == Syntax::windows) {
+            if (c == '\\')
+                return '/';
+            return std::tolower(c);
+        }
+
+        return c;
+    }
+
+    /* Do canonicalization on a path component boundary */
+    void skips(bool leadsep)
+    {
+        while (mPos.l > mRootLength) {
+            Pos pos = mPos;
+
+            if (leadsep) {
+                if (current() != '/')
+                    break;
+                nextc();
+            }
+
+            char c = current();
+            if (c == '.') {
+                nextc();
+                c = current();
+                if (c == '.') {
+                    nextc();
+                    c = current();
+                    if (c == '/') {
+                        /* Skip 'dir/../' */
+                        nextc();
+                        skips(false);
+                        while (mPos.l > mRootLength && current() != '/')
+                            nextc();
+                        continue;
+                    }
+                } else if (c == '/') {
+                    /* Skip '/./' */
+                    continue;
+                } else if (c == '\0') {
+                    /* Skip leading './' */
+                    break;
+                }
+            } else if (c == '/') {
+                /* Skip double separator (keep root) */
+                nextc();
+                leadsep = false;
+                continue;
+            }
+
+            mPos = pos;
+            break;
+        }
+    }
+
+    /* Go to the next character, doing skips on path separators */
+    void advance()
+    {
+        nextc();
+
+        if (current() == '/')
+            skips(true);
+    }
+
+    /* Go to the next character */
+    void nextc()
+    {
+        if (mPos.l == 0)
+            return;
+
+        mPos.l--;
+
+        if (mPos.l == 0)
+            mPos.c = '\0';
+        else if (mPos.c != EOF) {
+            mPos.c = EOF;
+        } else {
+            if (mPos.p == mStart[1]) {
+                mPos.p = mEnd[0];
+                mPos.c = '/';
+            }
+            mPos.p--;
+        }
+    }
+
+    /* String start pointers */
+    const char *mStart[2] {};
+    /* String end pointers */
+    const char *mEnd[2] {};
+    /* Current position */
+    Pos mPos {};
+    /* Length of the root component */
+    std::size_t mRootLength {};
+    /* Syntax */
+    Syntax mSyntax;
 };
 
 /// @}
diff --git a/lib/pcrerules.pri b/lib/pcrerules.pri
deleted file mode 100644
index 267b54ab34d..00000000000
--- a/lib/pcrerules.pri
+++ /dev/null
@@ -1,13 +0,0 @@
-# If HAVE_RULES=yes is passed to qmake, use PCRE and enable rules
-contains(HAVE_RULES, [yY][eE][sS]) {
-    CONFIG += use_pcre_rules
-}
-
-use_pcre_rules {
-    DEFINES += HAVE_RULES
-    LIBS += -L../externals -lpcre
-    INCLUDEPATH += ../externals
-    message("Rules enabled - to disable them and remove the dependency on PCRE, pass HAVE_RULES=no to qmake.")
-} else {
-    message("Rules disabled - to enable them, make PCRE available and pass HAVE_RULES=yes to qmake.")
-}
diff --git a/lib/platform.cpp b/lib/platform.cpp
index 3ba2e6f581d..931a0d145a1 100644
--- a/lib/platform.cpp
+++ b/lib/platform.cpp
@@ -1,48 +1,46 @@
 /*
-* Cppcheck - A tool for static C/C++ code analysis
-* Copyright (C) 2007-2019 Cppcheck team.
-*
-* This program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
 
 #include "platform.h"
+
 #include "path.h"
-#include "tinyxml2.h"
-#include <cstdlib>
+
 #include <cstring>
+#include <iostream>
 #include <limits>
+#include <utility>
 #include <vector>
 
-cppcheck::Platform::Platform()
+#include "xml.h"
+
+Platform::Platform()
 {
-    // This assumes the code you are checking is for the same architecture this is compiled on.
-#if defined(_WIN64)
-    platform(Win64);
-#elif defined(_WIN32)
-    platform(Win32A);
-#else
-    platform(Native);
-#endif
+    set(Type::Native);
 }
 
 
-bool cppcheck::Platform::platform(cppcheck::Platform::PlatformType type)
+bool Platform::set(Type t)
 {
-    switch (type) {
-    case Unspecified: // unknown type sizes (sizes etc are set but are not known)
-    case Native: // same as system this code was compile on
-        platformType = type;
+    switch (t) {
+    case Type::Unspecified: // unknown type sizes (sizes etc are set but are not known)
+    case Type::Native: // same as system this code was compile on
+        type = t;
+        windows = false;
         sizeof_bool = sizeof(bool);
         sizeof_short = sizeof(short);
         sizeof_int = sizeof(int);
@@ -54,20 +52,18 @@ bool cppcheck::Platform::platform(cppcheck::Platform::PlatformType type)
         sizeof_wchar_t = sizeof(wchar_t);
         sizeof_size_t = sizeof(std::size_t);
         sizeof_pointer = sizeof(void *);
-        if (type == Unspecified) {
+        if (type == Type::Unspecified) {
             defaultSign = '\0';
         } else {
-            defaultSign = (std::numeric_limits<char>::is_signed) ? 's' : 'u';
+            defaultSign = std::numeric_limits<char>::is_signed ? 's' : 'u';
         }
         char_bit = 8;
-        short_bit = char_bit * sizeof_short;
-        int_bit = char_bit * sizeof_int;
-        long_bit = char_bit * sizeof_long;
-        long_long_bit = char_bit * sizeof_long_long;
+        calculateBitMembers();
         return true;
-    case Win32W:
-    case Win32A:
-        platformType = type;
+    case Type::Win32W:
+    case Type::Win32A:
+        type = t;
+        windows = true;
         sizeof_bool = 1; // 4 in Visual C++ 4.2
         sizeof_short = 2;
         sizeof_int = 4;
@@ -79,15 +75,13 @@ bool cppcheck::Platform::platform(cppcheck::Platform::PlatformType type)
         sizeof_wchar_t = 2;
         sizeof_size_t = 4;
         sizeof_pointer = 4;
-        defaultSign = '\0';
+        defaultSign = 's';
         char_bit = 8;
-        short_bit = char_bit * sizeof_short;
-        int_bit = char_bit * sizeof_int;
-        long_bit = char_bit * sizeof_long;
-        long_long_bit = char_bit * sizeof_long_long;
+        calculateBitMembers();
         return true;
-    case Win64:
-        platformType = type;
+    case Type::Win64:
+        type = t;
+        windows = true;
         sizeof_bool = 1;
         sizeof_short = 2;
         sizeof_int = 4;
@@ -99,15 +93,13 @@ bool cppcheck::Platform::platform(cppcheck::Platform::PlatformType type)
         sizeof_wchar_t = 2;
         sizeof_size_t = 8;
         sizeof_pointer = 8;
-        defaultSign = '\0';
+        defaultSign = 's';
         char_bit = 8;
-        short_bit = char_bit * sizeof_short;
-        int_bit = char_bit * sizeof_int;
-        long_bit = char_bit * sizeof_long;
-        long_long_bit = char_bit * sizeof_long_long;
+        calculateBitMembers();
         return true;
-    case Unix32:
-        platformType = type;
+    case Type::Unix32:
+        type = t;
+        windows = false;
         sizeof_bool = 1;
         sizeof_short = 2;
         sizeof_int = 4;
@@ -119,15 +111,13 @@ bool cppcheck::Platform::platform(cppcheck::Platform::PlatformType type)
         sizeof_wchar_t = 4;
         sizeof_size_t = 4;
         sizeof_pointer = 4;
-        defaultSign = '\0';
+        defaultSign = 's';
         char_bit = 8;
-        short_bit = char_bit * sizeof_short;
-        int_bit = char_bit * sizeof_int;
-        long_bit = char_bit * sizeof_long;
-        long_long_bit = char_bit * sizeof_long_long;
+        calculateBitMembers();
         return true;
-    case Unix64:
-        platformType = type;
+    case Type::Unix64:
+        type = t;
+        windows = false;
         sizeof_bool = 1;
         sizeof_short = 2;
         sizeof_int = 4;
@@ -139,14 +129,11 @@ bool cppcheck::Platform::platform(cppcheck::Platform::PlatformType type)
         sizeof_wchar_t = 4;
         sizeof_size_t = 8;
         sizeof_pointer = 8;
-        defaultSign = '\0';
+        defaultSign = 's';
         char_bit = 8;
-        short_bit = char_bit * sizeof_short;
-        int_bit = char_bit * sizeof_int;
-        long_bit = char_bit * sizeof_long;
-        long_long_bit = char_bit * sizeof_long_long;
+        calculateBitMembers();
         return true;
-    case PlatformFile:
+    case Type::File:
         // sizes are not set.
         return false;
     }
@@ -154,83 +141,324 @@ bool cppcheck::Platform::platform(cppcheck::Platform::PlatformType type)
     return false;
 }
 
-bool cppcheck::Platform::loadPlatformFile(const char exename[], const std::string &filename)
+bool Platform::set(const std::string& platformstr, std::string& errstr, const std::vector<std::string>& paths, bool debug)
 {
-    // open file..
-    tinyxml2::XMLDocument doc;
-    if (doc.LoadFile(filename.c_str()) != tinyxml2::XML_SUCCESS) {
-        std::vector<std::string> filenames;
-        filenames.push_back(filename + ".xml");
-        if (exename && (std::string::npos != Path::fromNativeSeparators(exename).find('/'))) {
-            filenames.push_back(Path::getPathFromFilename(Path::fromNativeSeparators(exename)) + "platforms/" + filename);
-            filenames.push_back(Path::getPathFromFilename(Path::fromNativeSeparators(exename)) + "platforms/" + filename + ".xml");
+    // TODO: needs to be invalidated in case it was already set
+    if (platformstr == "win32A")
+        set(Type::Win32A);
+    else if (platformstr == "win32W")
+        set(Type::Win32W);
+    else if (platformstr == "win64")
+        set(Type::Win64);
+    else if (platformstr == "unix32")
+        set(Type::Unix32);
+    else if (platformstr == "unix64")
+        set(Type::Unix64);
+    else if (platformstr == "native")
+        set(Type::Native);
+    else if (platformstr == "unspecified")
+        set(Type::Unspecified);
+    else if (paths.empty()) {
+        errstr = "unrecognized platform: '" + platformstr + "' (no lookup).";
+        return false;
+    }
+    else if (!loadFromFile(paths, platformstr, debug)) {
+        errstr = "unrecognized platform: '" + platformstr + "'.";
+        return false;
+    }
+
+    return true;
+}
+
+bool Platform::loadFromFile(const std::vector<std::string>& paths, const std::string &filename, bool debug)
+{
+    if (debug)
+        std::cout << "looking for platform '" + filename + "'" << std::endl;
+
+    const bool is_abs_path = Path::isAbsolute(filename);
+
+    std::string fullfilename(filename);
+    // TODO: what if extension is not .xml?
+    // only append extension when we provide the library name is not a path - TODO: handle relative paths?
+    if (!is_abs_path && Path::getFilenameExtension(fullfilename).empty())
+        fullfilename += ".xml";
+
+    // TODO: use native separators
+    std::vector<std::string> filenames;
+    if (is_abs_path)
+    {
+        filenames.push_back(std::move(fullfilename));
+    }
+    else {
+        // TODO: drop duplicated paths
+        for (const std::string& path : paths)
+        {
+            if (path.empty())
+                continue; // TODO: error out instead?
+
+            std::string ppath = Path::fromNativeSeparators(path);
+            if (ppath.back() != '/')
+                ppath += '/';
+            // TODO: look in platforms first?
+            filenames.push_back(ppath + fullfilename);
+            filenames.push_back(ppath + "platforms/" + fullfilename);
         }
 #ifdef FILESDIR
         std::string filesdir = FILESDIR;
-        if (!filesdir.empty() && filesdir[filesdir.size()-1] != '/')
-            filesdir += '/';
-        filenames.push_back(filesdir + ("platforms/" + filename));
-        filenames.push_back(filesdir + ("platforms/" + filename + ".xml"));
+        if (!filesdir.empty()) {
+            if (filesdir.back() != '/')
+                filesdir += '/';
+            // TODO: look in filesdir?
+            filenames.push_back(filesdir + "platforms/" + fullfilename);
+        }
 #endif
-        bool success = false;
-        for (const std::string & f : filenames) {
-            if (doc.LoadFile(f.c_str()) == tinyxml2::XML_SUCCESS) {
-                success = true;
-                break;
-            }
+    }
+
+    // open file..
+    tinyxml2::XMLDocument doc;
+    tinyxml2::XMLError err = tinyxml2::XML_SUCCESS;
+    for (const std::string & f : filenames) {
+        if (debug)
+            std::cout << "try to load platform file '" << f << "' ... ";
+        err = doc.LoadFile(f.c_str());
+        if (err == tinyxml2::XML_SUCCESS) {
+            if (debug)
+                std::cout << "Success" << std::endl;
+            break;
         }
-        if (!success)
-            return false;
+        if (debug)
+            std::cout << doc.ErrorStr() << std::endl;
+        if (err != tinyxml2::XML_ERROR_FILE_NOT_FOUND)
+            break;
     }
+    if (err != tinyxml2::XML_SUCCESS)
+        return false;
 
     return loadFromXmlDocument(&doc);
 }
 
-bool cppcheck::Platform::loadFromXmlDocument(const tinyxml2::XMLDocument *doc)
+static const char* xmlText(const tinyxml2::XMLElement* node, bool& error)
+{
+    const char* const str = node->GetText();
+    if (!str)
+        error = true;
+    return str;
+}
+
+static unsigned int xmlTextAsUInt(const tinyxml2::XMLElement* node, bool& error)
+{
+    unsigned int retval = 0;
+    if (node->QueryUnsignedText(&retval) != tinyxml2::XML_SUCCESS)
+        error = true;
+    return retval;
+}
+
+static unsigned int xmlTextAsBool(const tinyxml2::XMLElement* node, bool& error)
+{
+    bool retval = false;
+    if (node->QueryBoolText(&retval) != tinyxml2::XML_SUCCESS)
+        error = true;
+    return retval;
+}
+
+bool Platform::loadFromXmlDocument(const tinyxml2::XMLDocument *doc)
 {
     const tinyxml2::XMLElement * const rootnode = doc->FirstChildElement();
 
     if (!rootnode || std::strcmp(rootnode->Name(), "platform") != 0)
         return false;
 
+    bool error = false;
     for (const tinyxml2::XMLElement *node = rootnode->FirstChildElement(); node; node = node->NextSiblingElement()) {
-        if (std::strcmp(node->Name(), "default-sign") == 0)
-            defaultSign = *node->GetText();
-        else if (std::strcmp(node->Name(), "char_bit") == 0)
-            char_bit = std::atoi(node->GetText());
-        else if (std::strcmp(node->Name(), "sizeof") == 0) {
+        const char* name = node->Name();
+        if (std::strcmp(name, "default-sign") == 0) {
+            const char * const str = xmlText(node, error);
+            if (!error)
+                defaultSign = *str;
+        } else if (std::strcmp(name, "char_bit") == 0)
+            char_bit = xmlTextAsUInt(node, error);
+        else if (std::strcmp(name, "sizeof") == 0) {
             for (const tinyxml2::XMLElement *sz = node->FirstChildElement(); sz; sz = sz->NextSiblingElement()) {
-                if (std::strcmp(sz->Name(), "short") == 0)
-                    sizeof_short = std::atoi(sz->GetText());
-                else if (std::strcmp(sz->Name(), "bool") == 0)
-                    sizeof_bool = std::atoi(sz->GetText());
-                else if (std::strcmp(sz->Name(), "int") == 0)
-                    sizeof_int = std::atoi(sz->GetText());
-                else if (std::strcmp(sz->Name(), "long") == 0)
-                    sizeof_long = std::atoi(sz->GetText());
-                else if (std::strcmp(sz->Name(), "long-long") == 0)
-                    sizeof_long_long = std::atoi(sz->GetText());
-                else if (std::strcmp(sz->Name(), "float") == 0)
-                    sizeof_float = std::atoi(sz->GetText());
-                else if (std::strcmp(sz->Name(), "double") == 0)
-                    sizeof_double = std::atoi(sz->GetText());
-                else if (std::strcmp(sz->Name(), "long-double") == 0)
-                    sizeof_long_double = std::atoi(sz->GetText());
-                else if (std::strcmp(sz->Name(), "pointer") == 0)
-                    sizeof_pointer = std::atoi(sz->GetText());
-                else if (std::strcmp(sz->Name(), "size_t") == 0)
-                    sizeof_size_t = std::atoi(sz->GetText());
-                else if (std::strcmp(sz->Name(), "wchar_t") == 0)
-                    sizeof_wchar_t = std::atoi(sz->GetText());
+                const char* szname = sz->Name();
+                if (std::strcmp(szname, "short") == 0)
+                    sizeof_short = xmlTextAsUInt(sz, error);
+                else if (std::strcmp(szname, "bool") == 0)
+                    sizeof_bool = xmlTextAsUInt(sz, error);
+                else if (std::strcmp(szname, "int") == 0)
+                    sizeof_int = xmlTextAsUInt(sz, error);
+                else if (std::strcmp(szname, "long") == 0)
+                    sizeof_long = xmlTextAsUInt(sz, error);
+                else if (std::strcmp(szname, "long-long") == 0)
+                    sizeof_long_long = xmlTextAsUInt(sz, error);
+                else if (std::strcmp(szname, "float") == 0)
+                    sizeof_float = xmlTextAsUInt(sz, error);
+                else if (std::strcmp(szname, "double") == 0)
+                    sizeof_double = xmlTextAsUInt(sz, error);
+                else if (std::strcmp(szname, "long-double") == 0)
+                    sizeof_long_double = xmlTextAsUInt(sz, error);
+                else if (std::strcmp(szname, "pointer") == 0)
+                    sizeof_pointer = xmlTextAsUInt(sz, error);
+                else if (std::strcmp(szname, "size_t") == 0)
+                    sizeof_size_t = xmlTextAsUInt(sz, error);
+                else if (std::strcmp(szname, "wchar_t") == 0)
+                    sizeof_wchar_t = xmlTextAsUInt(sz, error);
             }
         }
+        else if (std::strcmp(node->Name(), "windows") == 0) {
+            windows = xmlTextAsBool(node, error);
+        }
     }
+    calculateBitMembers();
+    type = Type::File;
+    return !error;
+}
 
-    short_bit = char_bit * sizeof_short;
-    int_bit = char_bit * sizeof_int;
-    long_bit = char_bit * sizeof_long;
-    long_long_bit = char_bit * sizeof_long_long;
+std::string Platform::getLimitsDefines(bool c99) const
+{
+    std::string s;
 
-    platformType = PlatformFile;
-    return true;
+    // climits / limits.h
+    s += "CHAR_BIT=";
+    s += std::to_string(char_bit);
+    s += ";SCHAR_MIN=";
+    s += std::to_string(min_value(char_bit));
+    s += ";SCHAR_MAX=";
+    s += std::to_string(max_value(char_bit));
+    s += ";UCHAR_MAX=";
+    s += std::to_string(max_value(char_bit+1));
+    s += ";CHAR_MIN=";
+    if (defaultSign == 'u')
+        s += std::to_string(min_value(char_bit));
+    else
+        s += std::to_string(0);
+    s += ";CHAR_MAX=";
+    if (defaultSign == 'u')
+        s += std::to_string(max_value(char_bit+1));
+    else
+        s += std::to_string(max_value(char_bit));
+    // TODO
+    //s += ";MB_LEN_MAX=";
+    s += ";SHRT_MIN=";
+    s += std::to_string(min_value(short_bit));
+    s += ";SHRT_MAX=";
+    s += std::to_string(max_value(short_bit));
+    s += ";USHRT_MAX=";
+    s += std::to_string(max_value(short_bit+1));
+    s += ";INT_MIN=";
+    s += "(-" + std::to_string(max_value(int_bit)) + " - 1)";
+    s += ";INT_MAX=";
+    s += std::to_string(max_value(int_bit));
+    s += ";UINT_MAX=";
+    s += std::to_string(max_value(int_bit+1));
+    s += ";LONG_MIN=";
+    s += "(-" + std::to_string(max_value(long_bit)) + "L - 1L)";
+    s += ";LONG_MAX=";
+    s += std::to_string(max_value(long_bit)) + "L";
+    s += ";ULONG_MAX=";
+    s += std::to_string(max_value_unsigned(long_bit)) + "UL";
+    if (c99) {
+        s += ";LLONG_MIN=";
+        s += "(-" + std::to_string(max_value(long_long_bit)) + "LL - 1LL)";
+        s += ";LLONG_MAX=";
+        s += std::to_string(max_value(long_long_bit)) + "LL";
+        s += ";ULLONG_MAX=";
+        s += std::to_string(max_value_unsigned(long_long_bit)) + "ULL";
+    }
+
+    // cstdint / stdint.h
+    // FIXME: these are currently hard-coded in std.cfg
+    /*
+        INTMAX_MIN
+        INTMAX_MAX
+        UINTMAX_MAX
+        INTN_MIN
+        INTN_MAX
+        UINTN_MAX
+        INT_LEASTN_MIN
+        INT_LEASTN_MAX
+        UINT_LEASTN_MAX
+        INT_FASTN_MIN
+        INT_FASTN_MAX
+        UINT_FASTN_MAX
+        INTPTR_MIN
+        INTPTR_MAX
+        UINTPTR_MAX
+        SIZE_MAX
+        PTRDIFF_MIN
+        PTRDIFF_MAX
+        SIG_ATOMIC_MIN
+        SIG_ATOMIC_MAX
+        WCHAR_MIN
+        WCHAR_MAX
+        WINT_MIN
+        WINT_MAX
+
+        // function-like macros
+        // implemented in std.cfg
+        INTMAX_C
+        UINTMAX_C
+        INTN_C
+        UINTN_C
+     */
+
+    // cfloat / float.h
+    /*
+        // TODO: implement
+        FLT_RADIX
+
+        FLT_MANT_DIG
+        DBL_MANT_DIG
+        LDBL_MANT_DIG
+
+        FLT_DIG
+        DBL_DIG
+        LDBL_DIG
+
+        FLT_MIN_EXP
+        DBL_MIN_EXP
+        LDBL_MIN_EXP
+
+        FLT_MIN_10_EXP
+        DBL_MIN_10_EXP
+        LDBL_MIN_10_EXP
+
+        FLT_MAX_EXP
+        DBL_MAX_EXP
+        LDBL_MAX_EXP
+
+        FLT_MAX_10_EXP
+        DBL_MAX_10_EXP
+        LDBL_MAX_10_EXP
+
+        FLT_MAX
+        DBL_MAX
+        LDBL_MAX
+
+        FLT_EPSILON
+        DBL_EPSILON
+        LDBL_EPSILON
+
+        FLT_MIN
+        DBL_MIN
+        LDBL_MIN
+
+        FLT_ROUNDS
+
+        // C99 / C++11 only
+        FLT_EVAL_METHOD
+
+        DECIMAL_DIG
+     */
+
+    return s;
+}
+
+std::string Platform::getLimitsDefines(Standards::cstd_t cstd) const
+{
+    return getLimitsDefines(cstd >= Standards::cstd_t::C99);
+}
+
+std::string Platform::getLimitsDefines(Standards::cppstd_t cppstd) const
+{
+    return getLimitsDefines(cppstd >= Standards::cppstd_t::CPP11);
 }
diff --git a/lib/platform.h b/lib/platform.h
index 92921e0db16..97e7d296fba 100644
--- a/lib/platform.h
+++ b/lib/platform.h
@@ -1,20 +1,20 @@
-/*
-* Cppcheck - A tool for static C/C++ code analysis
-* Copyright (C) 2007-2019 Cppcheck team.
-*
-* This program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
 
 //---------------------------------------------------------------------------
 #ifndef platformH
@@ -22,10 +22,16 @@
 //---------------------------------------------------------------------------
 
 #include "config.h"
+#include "mathlib.h"
+#include "standards.h"
 #include "utils.h"
 
+#include <cassert>
 #include <climits>
+#include <cstddef>
+#include <cstdint>
 #include <string>
+#include <vector>
 
 /// @addtogroup Core
 /// @{
@@ -34,136 +40,181 @@ namespace tinyxml2 {
     class XMLDocument;
 }
 
-namespace cppcheck {
-
-    /**
-    * @brief Platform settings
-    */
-    class CPPCHECKLIB Platform {
-    private:
-        static long long min_value(int bit) {
-            if (bit >= 64)
-                return LLONG_MIN;
-            return -(1LL << (bit-1));
-        }
-
-        static long long max_value(int bit) {
-            if (bit >= 64)
-                return (~0ULL) >> 1;
-            return (1LL << (bit-1)) - 1LL;
-        }
-    public:
-        Platform();
-        virtual ~Platform() {}
-
-        bool isIntValue(long long value) const {
-            return value >= min_value(int_bit) && value <= max_value(int_bit);
-        }
-
-        bool isLongValue(long long value) const {
-            return value >= min_value(long_bit) && value <= max_value(long_bit);
-        }
+/**
+ * @brief Platform settings
+ */
+class CPPCHECKLIB Platform {
+private:
+    static long long min_value(std::uint8_t bit) {
+        assert(bit > 0);
+        if (bit >= 64)
+            return LLONG_MIN;
+        return -(1LL << (bit-1));
+    }
+
+    static long long max_value(std::uint8_t bit) {
+        assert(bit > 0);
+        if (bit >= 64)
+            return (~0ULL) >> 1;
+        return (1LL << (bit-1)) - 1LL;
+    }
+
+    static unsigned long long max_value_unsigned(std::uint8_t bit) {
+        assert(bit > 0);
+        if (bit >= 64)
+            return ~0ULL;
+        return (1ULL << bit) - 1ULL;
+    }
+
+    void calculateBitMembers() {
+        short_bit = char_bit * sizeof_short;
+        int_bit = char_bit * sizeof_int;
+        long_bit = char_bit * sizeof_long;
+        long_long_bit = char_bit * sizeof_long_long;
+        float_bit = char_bit * sizeof_float;
+        double_bit = char_bit * sizeof_double;
+        long_double_bit = char_bit * sizeof_long_double;
+    }
+
+    /** provides list of defines specified by the limit.h/climits includes */
+    std::string getLimitsDefines(bool c99) const;
+
+protected:
+    /** load platform from xml document, primarily for testing */
+    bool loadFromXmlDocument(const tinyxml2::XMLDocument *doc);
+public:
+    Platform();
+
+    bool isIntValue(MathLib::bigint value) const {
+        return value >= min_value(int_bit) && value <= max_value(int_bit);
+    }
+
+    bool isIntValue(MathLib::biguint value) const {
+        const unsigned long long intMax = max_value(int_bit);
+        return value <= intMax;
+    }
+
+    bool isLongValue(MathLib::bigint value) const {
+        return value >= min_value(long_bit) && value <= max_value(long_bit);
+    }
+
+    bool isLongValue(MathLib::biguint value) const {
+        const MathLib::biguint longMax = max_value(long_bit);
+        return value <= longMax;
+    }
+
+    bool isLongLongValue(MathLib::biguint value) const {
+        const MathLib::biguint longLongMax = max_value(long_long_bit);
+        return value <= longLongMax;
+    }
+
+    std::uint8_t char_bit;       /// bits in char
+    std::uint8_t short_bit;      /// bits in short
+    std::uint8_t int_bit;        /// bits in int
+    std::uint8_t long_bit;       /// bits in long
+    std::uint8_t long_long_bit;  /// bits in long long
+    std::uint8_t float_bit;  /// bits in float
+    std::uint8_t double_bit;  /// bits in double
+    std::uint8_t long_double_bit;  /// bits in long double
+
+    /** size of standard types */
+    std::size_t sizeof_bool;
+    std::size_t sizeof_short;
+    std::size_t sizeof_int;
+    std::size_t sizeof_long;
+    std::size_t sizeof_long_long;
+    std::size_t sizeof_float;
+    std::size_t sizeof_double;
+    std::size_t sizeof_long_double;
+    std::size_t sizeof_wchar_t;
+    std::size_t sizeof_size_t;
+    std::size_t sizeof_pointer;
+
+    char defaultSign;  // unsigned:'u', signed:'s', unknown:'\0'
+
+    bool windows{false}; // indicates if the platform is Windows
+
+    enum Type : std::uint8_t {
+        Unspecified, // No platform specified
+        Native, // whatever system this code was compiled on
+        Win32A,
+        Win32W,
+        Win64,
+        Unix32,
+        Unix64,
+        File
+    };
 
-        nonneg int char_bit;       /// bits in char
-        nonneg int short_bit;      /// bits in short
-        nonneg int int_bit;        /// bits in int
-        nonneg int long_bit;       /// bits in long
-        nonneg int long_long_bit;  /// bits in long long
-
-        /** size of standard types */
-        nonneg int sizeof_bool;
-        nonneg int sizeof_short;
-        nonneg int sizeof_int;
-        nonneg int sizeof_long;
-        nonneg int sizeof_long_long;
-        nonneg int sizeof_float;
-        nonneg int sizeof_double;
-        nonneg int sizeof_long_double;
-        nonneg int sizeof_wchar_t;
-        nonneg int sizeof_size_t;
-        nonneg int sizeof_pointer;
-
-        char defaultSign;  // unsigned:'u', signed:'s', unknown:'\0'
-
-        enum PlatformType {
-            Unspecified, // No platform specified
-            Native, // whatever system this code was compiled on
-            Win32A,
-            Win32W,
-            Win64,
-            Unix32,
-            Unix64,
-            PlatformFile
-        };
-
-        /** platform type */
-        PlatformType platformType;
-
-        /** set the platform type for predefined platforms */
-        bool platform(PlatformType type);
-
-        /**
-         * load platform file
-         * @param exename application path
-         * @param filename platform filename
-         * @return returns true if file was loaded successfully
-         */
-        bool loadPlatformFile(const char exename[], const std::string &filename);
-
-        /** load platform from xml document, primarily for testing */
-        bool loadFromXmlDocument(const tinyxml2::XMLDocument *doc);
-
-        /**
-        * @brief Returns true if platform type is Windows
-        * @return true if Windows platform type.
-        */
-        bool isWindowsPlatform() const {
-            return platformType == Win32A ||
-                   platformType == Win32W ||
-                   platformType == Win64;
-        }
+    /** platform type */
+    Type type;
 
-        const char *platformString() const {
-            return platformString(platformType);
-        }
+    /** set the platform type for predefined platforms - deprecated use set(const std::string&, std::string&) instead */
+    bool set(Type t);
 
-        static const char *platformString(PlatformType pt) {
-            switch (pt) {
-            case Unspecified:
-                return "Unspecified";
-            case Native:
-                return "Native";
-            case Win32A:
-                return "win32A";
-            case Win32W:
-                return "win32W";
-            case Win64:
-                return "win64";
-            case Unix32:
-                return "unix32";
-            case Unix64:
-                return "unix64";
-            case PlatformFile:
-                return "platformFile";
-            default:
-                return "unknown";
-            }
-        }
+    /** set the platform type */
+    bool set(const std::string& platformstr, std::string& errstr, const std::vector<std::string>& paths = {}, bool debug = false);
 
-        long long unsignedCharMax() const {
-            return max_value(char_bit + 1);
-        }
+    /**
+     * load platform file
+     * @param paths the additional paths to look into
+     * @param filename platform filename
+     * @param debug log verbose information about the lookup
+     * @return returns true if file was loaded successfully
+     */
+    bool loadFromFile(const std::vector<std::string>& paths, const std::string &filename, bool debug = false);
 
-        long long signedCharMax() const {
-            return max_value(char_bit);
-        }
 
-        long long signedCharMin() const {
-            return min_value(char_bit);
+    /**
+     * @brief Returns true if platform type is Windows
+     * @return true if Windows platform type.
+     */
+    bool isWindows() const {
+        return windows;
+    }
+
+    const char *toString() const {
+        return toString(type);
+    }
+
+    static const char *toString(Type pt) {
+        switch (pt) {
+        case Type::Unspecified:
+            return "unspecified";
+        case Type::Native:
+            return "native";
+        case Type::Win32A:
+            return "win32A";
+        case Type::Win32W:
+            return "win32W";
+        case Type::Win64:
+            return "win64";
+        case Type::Unix32:
+            return "unix32";
+        case Type::Unix64:
+            return "unix64";
+        case Type::File:
+            return "platformFile";
         }
-    };
-
-}
+        cppcheck::unreachable();
+    }
+
+    long long unsignedCharMax() const {
+        return max_value(char_bit + 1);
+    }
+
+    long long signedCharMax() const {
+        return max_value(char_bit);
+    }
+
+    long long signedCharMin() const {
+        return min_value(char_bit);
+    }
+
+    /** provides list of defines specified by the limit.h/climits includes */
+    std::string getLimitsDefines(Standards::cstd_t cstd) const;
+    /** provides list of defines specified by the limit.h/climits includes */
+    std::string getLimitsDefines(Standards::cppstd_t cppstd) const;
+};
 
 /// @}
 //---------------------------------------------------------------------------
diff --git a/lib/precompiled.h b/lib/precompiled.h
new file mode 100644
index 00000000000..c1e4d0709e3
--- /dev/null
+++ b/lib/precompiled.h
@@ -0,0 +1,32 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+// IWYU pragma: begin_keep
+#include "astutils.h"
+#include "errorlogger.h"
+#include "library.h"
+//#include "matchcompiler.h"
+#include "mathlib.h"
+#include "token.h"
+#include "settings.h"
+#include "suppressions.h"
+#include "utils.h"
+#include "valueflow.h"
+// IWYU pragma: end_keep
diff --git a/lib/preprocessor.cpp b/lib/preprocessor.cpp
index e5107c4664d..9528360906e 100644
--- a/lib/preprocessor.cpp
+++ b/lib/preprocessor.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,129 +20,358 @@
 #include "preprocessor.h"
 
 #include "errorlogger.h"
+#include "errortypes.h"
 #include "library.h"
+#include "mathlib.h"
 #include "path.h"
+#include "platform.h"
 #include "settings.h"
-#include "simplecpp.h"
+#include "standards.h"
 #include "suppressions.h"
+#include "utils.h"
 
 #include <algorithm>
-#include <cstdint>
-#include <cstring>
-#include <iterator> // back_inserter
+#include <array>
+#include <cassert>
+#include <cstddef>
+#include <iterator>
+#include <memory>
+#include <stdexcept>
+#include <sstream>
 #include <utility>
 
-/**
- * Remove heading and trailing whitespaces from the input parameter.
- * If string is all spaces/tabs, return empty string.
- * @param s The string to trim.
- */
-static std::string trim(const std::string& s)
-{
-    const std::string::size_type beg = s.find_first_not_of(" \t");
-    if (beg == std::string::npos)
-        return "";
-    const std::string::size_type end = s.find_last_not_of(" \t");
-    return s.substr(beg, end - beg + 1);
-}
+#include <simplecpp.h>
 
-Directive::Directive(const std::string &_file, const int _linenr, const std::string &_str):
-    file(_file),
-    linenr(_linenr),
-    str(trim(_str))
+static bool sameline(const simplecpp::Token *tok1, const simplecpp::Token *tok2)
 {
+    return tok1 && tok2 && tok1->location.sameline(tok2->location);
 }
 
-bool Preprocessor::missingIncludeFlag;
-bool Preprocessor::missingSystemIncludeFlag;
+Directive::Directive(const simplecpp::TokenList &tokens, const simplecpp::Location & _loc, std::string _str) :
+    file(tokens.file(_loc)),
+    linenr(_loc.line),
+    str(std::move(_str))
+{}
 
-char Preprocessor::macroChar = char(1);
+Directive::DirectiveToken::DirectiveToken(const simplecpp::Token & _tok) :
+    line(_tok.location.line),
+    column(_tok.location.col),
+    tokStr(_tok.str())
+{}
 
-Preprocessor::Preprocessor(Settings& settings, ErrorLogger *errorLogger) : mSettings(settings), mErrorLogger(errorLogger)
-{
-}
+char Preprocessor::macroChar = char(1);
 
-Preprocessor::~Preprocessor()
+Preprocessor::Preprocessor(simplecpp::TokenList& tokens, const Settings& settings, ErrorLogger &errorLogger, Standards::Language lang)
+    : mTokens(tokens)
+    , mSettings(settings)
+    , mErrorLogger(errorLogger)
+    , mLang(lang)
 {
-    for (std::map<std::string, simplecpp::TokenList *>::iterator it = mTokenLists.begin(); it != mTokenLists.end(); ++it)
-        delete it->second;
+    assert(mLang != Standards::Language::None);
 }
 
 namespace {
     struct BadInlineSuppression {
-        BadInlineSuppression(const simplecpp::Location &l, const std::string &msg) : location(l), errmsg(msg) {}
+        BadInlineSuppression(const simplecpp::Location& loc, std::string msg) : location(loc), errmsg(std::move(msg)) {}
         simplecpp::Location location;
         std::string errmsg;
     };
 }
 
-static void inlineSuppressions(const simplecpp::TokenList &tokens, Settings &mSettings, std::list<BadInlineSuppression> *bad)
+static bool parseInlineSuppressionCommentToken(const simplecpp::Token *tok, std::list<SuppressionList::Suppression> &inlineSuppressions, std::list<BadInlineSuppression> &bad)
+{
+    const std::string cppchecksuppress("cppcheck-suppress");
+
+    const std::string &comment = tok->str();
+    if (comment.size() < cppchecksuppress.size())
+        return false;
+    const std::string::size_type pos1 = comment.find_first_not_of("/* \t");
+    if (pos1 == std::string::npos)
+        return false;
+    if (comment.substr(pos1, cppchecksuppress.size()) != cppchecksuppress)
+        return false;
+    if (pos1 + cppchecksuppress.size() >= comment.size()) {
+        bad.emplace_back(tok->location, "suppression without error ID");
+        return false;
+    }
+
+    // check if it has a prefix
+    const std::string::size_type posEndComment = comment.find_first_of(" [", pos1+cppchecksuppress.size());
+
+    // skip spaces after "cppcheck-suppress" and its possible prefix
+    const std::string::size_type pos2 = comment.find_first_not_of(' ', posEndComment);
+    if (pos2 == std::string::npos) {
+        bad.emplace_back(tok->location, "suppression without error ID");
+        return false;
+    }
+
+    SuppressionList::Type errorType = SuppressionList::Type::unique;
+
+    // determine prefix if specified
+    if (posEndComment >= (pos1 + cppchecksuppress.size() + 1)) {
+        const std::string suppressCmdString = comment.substr(pos1, pos2-pos1-1);
+        if (comment.at(pos1 + cppchecksuppress.size()) != '-') {
+            bad.emplace_back(tok->location, "unknown suppression type '" + suppressCmdString + "'");
+            return false;
+        }
+
+        const unsigned int argumentLength =
+            posEndComment - (pos1 + cppchecksuppress.size() + 1);
+
+        const std::string suppressTypeString =
+            comment.substr(pos1 + cppchecksuppress.size() + 1, argumentLength);
+
+        if ("file" == suppressTypeString)
+            errorType = SuppressionList::Type::file;
+        else if ("begin" == suppressTypeString)
+            errorType = SuppressionList::Type::blockBegin;
+        else if ("end" == suppressTypeString)
+            errorType = SuppressionList::Type::blockEnd;
+        else if ("macro" == suppressTypeString)
+            errorType = SuppressionList::Type::macro;
+        else {
+            bad.emplace_back(tok->location, "unknown suppression type '" + suppressCmdString + "'");
+            return false;
+        }
+    }
+
+    if (comment[pos2] == '[') {
+        // multi suppress format
+        std::string errmsg;
+        std::vector<SuppressionList::Suppression> suppressions = SuppressionList::parseMultiSuppressComment(comment, &errmsg);
+
+        for (SuppressionList::Suppression &s : suppressions) {
+            s.isInline = true;
+            s.type = errorType;
+            s.lineNumber = tok->location.line;
+            s.column = tok->location.col;
+        }
+
+        // TODO: return false?
+        if (!errmsg.empty())
+            bad.emplace_back(tok->location, std::move(errmsg));
+
+        // TODO: report ones without ID - return false?
+        std::copy_if(suppressions.cbegin(), suppressions.cend(), std::back_inserter(inlineSuppressions), [](const SuppressionList::Suppression& s) {
+            return !s.errorId.empty();
+        });
+    } else {
+        //single suppress format
+        std::string errmsg;
+        SuppressionList::Suppression s;
+        if (!s.parseComment(comment, &errmsg))
+            return false;
+
+        s.isInline = true;
+        s.type = errorType;
+        s.lineNumber = tok->location.line;
+        s.column = tok->location.col;
+
+        // TODO: report when no ID - unreachable?
+        if (!s.errorId.empty())
+            inlineSuppressions.push_back(std::move(s));
+
+        // TODO: unreachable?
+        // TODO: return false?
+        if (!errmsg.empty())
+            bad.emplace_back(tok->location, std::move(errmsg));
+    }
+
+    return true;
+}
+
+static std::string getRelativeFilename(const simplecpp::TokenList &tokens, const simplecpp::Token* tok, const Settings &settings) {
+    if (!tok)
+        return "";
+    std::string relativeFilename(tokens.file(tok->location));
+    if (settings.relativePaths) {
+        for (const std::string & basePath : settings.basePaths) {
+            const std::string bp = basePath + "/";
+            if (relativeFilename.compare(0,bp.size(),bp)==0) {
+                relativeFilename = relativeFilename.substr(bp.size());
+            }
+        }
+    }
+    return Path::simplifyPath(std::move(relativeFilename));
+}
+
+static void addInlineSuppressions(const simplecpp::TokenList &tokens, const Settings &settings, SuppressionList &suppressions, std::list<BadInlineSuppression> &bad)
 {
-    std::list<Suppressions::Suppression> inlineSuppressions;
+    std::list<SuppressionList::Suppression> inlineSuppressionsBlockBegin;
+
+    bool onlyComments = true;
+
+    polyspace::Parser polyspaceParser(settings);
+
     for (const simplecpp::Token *tok = tokens.cfront(); tok; tok = tok->next) {
-        if (tok->comment) {
-            Suppressions::Suppression s;
-            std::string errmsg;
-            if (!s.parseComment(tok->str(), &errmsg))
-                continue;
-            if (!errmsg.empty())
-                bad->push_back(BadInlineSuppression(tok->location, errmsg));
-            if (!s.errorId.empty())
-                inlineSuppressions.push_back(s);
+        if (!tok->comment) {
+            onlyComments = false;
             continue;
         }
 
+        std::list<SuppressionList::Suppression> inlineSuppressions;
+        if (polyspace::isPolyspaceComment(tok->str())) {
+            inlineSuppressions = polyspaceParser.parse(tok->str(), tok->location.line, getRelativeFilename(tokens, tok, settings));
+        } else {
+            if (!parseInlineSuppressionCommentToken(tok, inlineSuppressions, bad))
+                continue;
+
+            if (!sameline(tok->previous, tok)) {
+                // find code after comment..
+                if (tok->next) {
+                    tok = tok->next;
+
+                    while (tok->comment) {
+                        parseInlineSuppressionCommentToken(tok, inlineSuppressions, bad);
+                        if (tok->next) {
+                            tok = tok->next;
+                        } else {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
         if (inlineSuppressions.empty())
             continue;
 
+        // It should never happen
+        if (!tok)
+            continue;
+
         // Relative filename
-        std::string relativeFilename(tok->location.file());
-        if (mSettings.relativePaths) {
-            for (const std::string & basePath : mSettings.basePaths) {
-                const std::string bp = basePath + "/";
-                if (relativeFilename.compare(0,bp.size(),bp)==0) {
-                    relativeFilename = relativeFilename.substr(bp.size());
-                }
+        const std::string relativeFilename = getRelativeFilename(tokens, tok, settings);
+
+        // Macro name
+        std::string macroName;
+        if (tok->str() == "#" && tok->next && tok->next->str() == "define") {
+            const simplecpp::Token *macroNameTok = tok->next->next;
+            if (sameline(tok, macroNameTok) && macroNameTok->name) {
+                macroName = macroNameTok->str();
             }
         }
-        relativeFilename = Path::simplifyPath(relativeFilename);
 
         // Add the suppressions.
-        for (Suppressions::Suppression &suppr : inlineSuppressions) {
+        for (SuppressionList::Suppression &suppr : inlineSuppressions) {
             suppr.fileName = relativeFilename;
-            suppr.lineNumber = tok->location.line;
-            mSettings.nomsg.addSuppression(suppr);
+            suppr.fileIndex = tok->location.fileIndex;
+
+            if (SuppressionList::Type::block == suppr.type) {
+                suppressions.addSuppression(std::move(suppr));
+            } else if (SuppressionList::Type::blockBegin == suppr.type) {
+                inlineSuppressionsBlockBegin.push_back(std::move(suppr));
+            } else if (SuppressionList::Type::blockEnd == suppr.type) {
+                bool throwError = true;
+
+                if (!inlineSuppressionsBlockBegin.empty()) {
+                    const SuppressionList::Suppression lastBeginSuppression = inlineSuppressionsBlockBegin.back();
+
+                    auto supprBegin = inlineSuppressionsBlockBegin.begin();
+                    while (supprBegin != inlineSuppressionsBlockBegin.end())
+                    {
+                        if (lastBeginSuppression.lineNumber != supprBegin->lineNumber) {
+                            ++supprBegin;
+                            continue;
+                        }
+
+                        if (suppr.symbolName == supprBegin->symbolName && suppr.lineNumber > supprBegin->lineNumber) {
+                            suppr.lineBegin = supprBegin->lineNumber;
+                            suppr.lineEnd = suppr.lineNumber;
+                            suppr.lineNumber = supprBegin->lineNumber;
+                            suppr.column = supprBegin->column;
+                            suppr.type = SuppressionList::Type::block;
+                            inlineSuppressionsBlockBegin.erase(supprBegin);
+                            suppressions.addSuppression(std::move(suppr)); // TODO: check result
+                            throwError = false;
+                            break;
+                        }
+                        ++supprBegin;
+                    }
+                }
+
+                if (throwError) {
+                    simplecpp::Location loc;
+                    // NOLINTNEXTLINE(bugprone-use-after-move) - moved only when thrownError is false
+                    loc.fileIndex = suppr.fileIndex;
+                    loc.line = suppr.lineNumber;
+                    loc.col = suppr.column;
+                    bad.emplace_back(loc, "Suppress End: No matching begin");
+                }
+            } else if (SuppressionList::Type::unique == suppr.type || suppr.type == SuppressionList::Type::macro) {
+                // special handling when suppressing { warnings for backwards compatibility
+                const bool thisAndNextLine = tok->previous &&
+                                             tok->previous->previous &&
+                                             tok->next &&
+                                             !sameline(tok->previous->previous, tok->previous) &&
+                                             tok->location.line + 1 == tok->next->location.line &&
+                                             tok->location.fileIndex == tok->next->location.fileIndex &&
+                                             tok->previous->str() == "{";
+
+                suppr.thisAndNextLine = thisAndNextLine;
+                suppr.lineNumber = tok->location.line;
+                suppr.column = tok->location.col;
+                suppr.macroName = macroName;
+                suppressions.addSuppression(std::move(suppr)); // TODO: check result
+            } else if (SuppressionList::Type::file == suppr.type) {
+                if (onlyComments)
+                    suppressions.addSuppression(std::move(suppr)); // TODO: check result
+                else {
+                    simplecpp::Location loc;
+                    loc.fileIndex = suppr.fileIndex;
+                    loc.line = suppr.lineNumber;
+                    loc.col = suppr.column;
+                    bad.emplace_back(loc, "File suppression should be at the top of the file");
+                }
+            }
         }
-        inlineSuppressions.clear();
+    }
+
+    for (const SuppressionList::Suppression & suppr: inlineSuppressionsBlockBegin) {
+        simplecpp::Location loc;
+        loc.fileIndex = suppr.fileIndex;
+        loc.line = suppr.lineNumber;
+        loc.col = suppr.column;
+        bad.emplace_back(loc, "Suppress Begin: No matching end");
     }
 }
 
-void Preprocessor::inlineSuppressions(const simplecpp::TokenList &tokens)
+void Preprocessor::inlineSuppressions(SuppressionList &suppressions)
 {
     if (!mSettings.inlineSuppressions)
         return;
     std::list<BadInlineSuppression> err;
-    ::inlineSuppressions(tokens, mSettings, &err);
-    for (std::map<std::string,simplecpp::TokenList*>::const_iterator it = mTokenLists.begin(); it != mTokenLists.end(); ++it) {
-        if (it->second)
-            ::inlineSuppressions(*it->second, mSettings, &err);
+    ::addInlineSuppressions(mTokens, mSettings, suppressions, err);
+    for (const auto &filedata : mFileCache) {
+        ::addInlineSuppressions(filedata->tokens, mSettings, suppressions, err);
     }
     for (const BadInlineSuppression &bad : err) {
-        error(bad.location.file(), bad.location.line, bad.errmsg);
+        invalidSuppression(bad.location, bad.errmsg);
     }
 }
 
-void Preprocessor::setDirectives(const simplecpp::TokenList &tokens)
+std::vector<RemarkComment> Preprocessor::getRemarkComments() const
+{
+    std::vector<RemarkComment> ret;
+    addRemarkComments(mTokens, ret);
+    for (const auto &filedata : mFileCache) {
+        addRemarkComments(filedata->tokens, ret);
+    }
+    return ret;
+}
+
+std::list<Directive> Preprocessor::createDirectives() const
 {
     // directive list..
-    mDirectives.clear();
+    std::list<Directive> directives;
 
     std::vector<const simplecpp::TokenList *> list;
-    list.reserve(1U + mTokenLists.size());
-    list.push_back(&tokens);
-    for (std::map<std::string, simplecpp::TokenList *>::const_iterator it = mTokenLists.begin(); it != mTokenLists.end(); ++it) {
-        list.push_back(it->second);
-    }
+    list.reserve(1U + mFileCache.size());
+    list.push_back(&mTokens);
+    std::transform(mFileCache.cbegin(), mFileCache.cend(), std::back_inserter(list),
+                   [](const std::unique_ptr<simplecpp::FileData> &filedata) {
+        return &filedata->tokens;
+    });
 
     for (const simplecpp::TokenList *tokenList : list) {
         for (const simplecpp::Token *tok = tokenList->cfront(); tok; tok = tok->next) {
@@ -150,7 +379,7 @@ void Preprocessor::setDirectives(const simplecpp::TokenList &tokens)
                 continue;
             if (tok->next && tok->next->str() == "endfile")
                 continue;
-            Directive directive(tok->location.file(), tok->location.line, emptyString);
+            Directive directive(mTokens, tok->location, "");
             for (const simplecpp::Token *tok2 = tok; tok2 && tok2->location.line == directive.linenr; tok2 = tok2->next) {
                 if (tok2->comment)
                     continue;
@@ -160,15 +389,14 @@ void Preprocessor::setDirectives(const simplecpp::TokenList &tokens)
                     directive.str += "include";
                 else
                     directive.str += tok2->str();
+
+                directive.strTokens.emplace_back(*tok2);
             }
-            mDirectives.push_back(directive);
+            directives.push_back(std::move(directive));
         }
     }
-}
 
-static bool sameline(const simplecpp::Token *tok1, const simplecpp::Token *tok2)
-{
-    return tok1 && tok2 && tok1->location.sameline(tok2->location);
+    return directives;
 }
 
 static std::string readcondition(const simplecpp::Token *iftok, const std::set<std::string> &defined, const std::set<std::string> &undefined)
@@ -207,38 +435,81 @@ static std::string readcondition(const simplecpp::Token *iftok, const std::set<s
             return next1->str();
     }
 
-    if (len == 3 && cond->name && next1->str() == "==" && next2->number) {
+    if (len == 3 && cond->name && (next1->str() == "==" || next1->str() == "<=" || next1->str() == ">=") && next2->number) {
         if (defined.find(cond->str()) == defined.end())
-            return cond->str() + '=' + cond->next->next->str();
+            return cond->str() + '=' + next1->next->str();
+    }
+
+    const auto lessGreaterThanConfig = [](const simplecpp::Token* dtok, const simplecpp::Token* ctok) {
+        auto v = MathLib::toBigNumber(ctok->next->str());
+        if (ctok->op == '<')
+            v -= 1;
+        else
+            v += 1;
+        return dtok->str() + '=' + std::to_string(v);
+    };
+
+    if (len == 3 && cond->name && (next1->op == '<' || next1->op == '>') && next2->number) {
+        if (defined.find(cond->str()) == defined.end()) {
+            return lessGreaterThanConfig(cond, next1);
+        }
     }
 
     std::set<std::string> configset;
+    bool isNotDefinedMacro = false;
     for (; sameline(iftok,cond); cond = cond->next) {
         if (cond->op == '!') {
             if (!sameline(iftok,cond->next) || !cond->next->name)
                 break;
-            if (cond->next->str() == "defined")
+            if (cond->next->str() == "defined") {
+                isNotDefinedMacro = true;
                 continue;
+            }
             configset.insert(cond->next->str() + "=0");
             continue;
         }
-        if (cond->str() != "defined")
+        if (cond->str() == "==" || cond->str() == "<=" || cond->str() == ">=") {
+            if (cond->next->number) {
+                const simplecpp::Token *dtok = cond->previous;
+                if (sameline(iftok,dtok) && dtok->name && defined.find(dtok->str()) == defined.end() && undefined.find(dtok->str()) == undefined.end())
+                    configset.insert(dtok->str() + '=' + cond->next->str());
+            }
             continue;
-        const simplecpp::Token *dtok = cond->next;
-        if (!dtok)
-            break;
-        if (dtok->op == '(')
-            dtok = dtok->next;
-        if (sameline(iftok,dtok) && dtok->name && defined.find(dtok->str()) == defined.end() && undefined.find(dtok->str()) == undefined.end())
-            configset.insert(dtok->str());
+        }
+        if (cond->op == '<' || cond->op == '>') {
+            if (cond->next->number) {
+                const simplecpp::Token *dtok = cond->previous;
+                if (sameline(iftok,dtok) && dtok->name && defined.find(dtok->str()) == defined.end() && undefined.find(dtok->str()) == undefined.end()) {
+                    configset.insert(lessGreaterThanConfig(dtok, cond));
+                }
+            }
+            continue;
+        }
+        if (cond->str() == "defined") {
+            const simplecpp::Token *dtok = cond->next;
+            if (!dtok)
+                break;
+            if (dtok->op == '(')
+                dtok = dtok->next;
+
+            if (sameline(iftok,dtok) && dtok->name && defined.find(dtok->str()) == defined.end() && undefined.find(dtok->str()) == undefined.end()) {
+                if (!isNotDefinedMacro) {
+                    configset.insert(dtok->str() + "=" + dtok->str()); // if defined is set to itself.
+                } else {
+                    configset.insert(dtok->str());
+                }
+                isNotDefinedMacro = false;
+            }
+            continue;
+        }
     }
-    std::string cfg;
+    std::string cfgStr;
     for (const std::string &s : configset) {
-        if (!cfg.empty())
-            cfg += ';';
-        cfg += s;
+        if (!cfgStr.empty())
+            cfgStr += ';';
+        cfgStr += s;
     }
-    return cfg;
+    return cfgStr;
 }
 
 static bool hasDefine(const std::string &userDefines, const std::string &cfg)
@@ -248,11 +519,12 @@ static bool hasDefine(const std::string &userDefines, const std::string &cfg)
     }
 
     std::string::size_type pos = 0;
+    const std::string cfgname = cfg.substr(0, cfg.find('='));
     while (pos < userDefines.size()) {
-        pos = userDefines.find(cfg, pos);
+        pos = userDefines.find(cfgname, pos);
         if (pos == std::string::npos)
             break;
-        const std::string::size_type pos2 = pos + cfg.size();
+        const std::string::size_type pos2 = pos + cfgname.size();
         if ((pos == 0 || userDefines[pos-1U] == ';') && (pos2 == userDefines.size() || userDefines[pos2] == '='))
             return true;
         pos = pos2;
@@ -262,18 +534,18 @@ static bool hasDefine(const std::string &userDefines, const std::string &cfg)
 
 static std::string cfg(const std::vector<std::string> &configs, const std::string &userDefines)
 {
-    std::set<std::string> configs2(configs.begin(), configs.end());
+    std::set<std::string> configs2(configs.cbegin(), configs.cend());
     std::string ret;
-    for (const std::string &cfg : configs2) {
-        if (cfg.empty())
+    for (const std::string &c : configs2) {
+        if (c.empty())
             continue;
-        if (cfg == "0")
+        if (c == "0")
             return "";
-        if (hasDefine(userDefines, cfg))
+        if (hasDefine(userDefines, c))
             continue;
         if (!ret.empty())
             ret += ';';
-        ret += cfg;
+        ret += c;
     }
     return ret;
 }
@@ -298,7 +570,7 @@ static bool isUndefined(const std::string &cfg, const std::set<std::string> &und
 static bool getConfigsElseIsFalse(const std::vector<std::string> &configs_if, const std::string &userDefines)
 {
     return std::any_of(configs_if.cbegin(), configs_if.cend(),
-    [=](const std::string &cfg) {
+                       [&](const std::string &cfg) {
         return hasDefine(userDefines, cfg);
     });
 }
@@ -308,7 +580,7 @@ static const simplecpp::Token *gotoEndIf(const simplecpp::Token *cmdtok)
     int level = 0;
     while (nullptr != (cmdtok = cmdtok->next)) {
         if (cmdtok->op == '#' && !sameline(cmdtok->previous,cmdtok) && sameline(cmdtok, cmdtok->next)) {
-            if (cmdtok->next->str().compare(0,2,"if")==0)
+            if (startsWith(cmdtok->next->str(),"if"))
                 ++level;
             else if (cmdtok->next->str() == "endif") {
                 --level;
@@ -338,8 +610,11 @@ static void getConfigs(const simplecpp::TokenList &tokens, std::set<std::string>
                 const simplecpp::Token *expr1 = cmdtok->next;
                 if (sameline(tok,expr1) && expr1->name && !sameline(tok,expr1->next))
                     config = expr1->str();
-                if (defined.find(config) != defined.end())
+                if (defined.find(config) != defined.end()) {
                     config.clear();
+                } else if ((cmdtok->str() == "ifdef") && sameline(cmdtok,expr1) && !config.empty()) {
+                    config.append("=" + expr1->str()); //Set equal to itself if ifdef.
+                }
             } else if (cmdtok->str() == "if") {
                 config = readcondition(cmdtok, defined, undefined);
             }
@@ -348,8 +623,57 @@ static void getConfigs(const simplecpp::TokenList &tokens, std::set<std::string>
             if (isUndefined(config, undefined))
                 config.clear();
 
+            bool ifndef = false;
+            if (cmdtok->str() == "ifndef")
+                ifndef = true;
+            else {
+                const std::array<std::string, 6> match{"if", "!", "defined", "(", config, ")"};
+                std::size_t i = 0;
+                ifndef = true;
+                for (const simplecpp::Token *t = cmdtok; i < match.size(); t = t->next) {
+                    if (!t || t->str() != match[i++]) {
+                        ifndef = false;
+                        break;
+                    }
+                }
+            }
+
+            // include guard..
+            if (ifndef && tok->location.fileIndex > 0) {
+                bool includeGuard = true;
+                for (const simplecpp::Token *t = tok->previous; t; t = t->previous) {
+                    if (t->location.fileIndex == tok->location.fileIndex) {
+                        includeGuard = false;
+                        break;
+                    }
+                }
+                if (includeGuard) {
+                    configs_if.emplace_back(/*std::string()*/);
+                    configs_ifndef.emplace_back(/*std::string()*/);
+                    continue;
+                }
+            }
+
+            // check if config already exists in the ret set, but as a more general or more specific version
+            if (cmdtok->str() != "ifndef")
+            {
+                const std::string::size_type eq = config.find('=');
+                const std::string config2 = (eq != std::string::npos) ? config.substr(0, eq) : config + "=" + config;
+                const std::set<std::string>::iterator it2 = ret.find(config2);
+                if (it2 != ret.end()) {
+                    if (eq == std::string::npos) {
+                        // The instance in ret is more specific than the one in config (no =value), replace it with the one in config
+                        ret.erase(it2);
+                    } else {
+                        // The instance in ret is more general than the one in config (have =value), keep the one in ret
+                        config.clear();
+                        continue;
+                    }
+                }
+            }
+
             configs_if.push_back((cmdtok->str() == "ifndef") ? std::string() : config);
-            configs_ifndef.push_back((cmdtok->str() == "ifndef") ? config : std::string());
+            configs_ifndef.push_back((cmdtok->str() == "ifndef") ? std::move(config) : std::string());
             ret.insert(cfg(configs_if,userDefines));
         } else if (cmdtok->str() == "elif" || cmdtok->str() == "else") {
             if (getConfigsElseIsFalse(configs_if,userDefines)) {
@@ -378,11 +702,21 @@ static void getConfigs(const simplecpp::TokenList &tokens, std::set<std::string>
                 std::string config = readcondition(cmdtok, defined, undefined);
                 if (isUndefined(config,undefined))
                     config.clear();
-                configs_if.push_back(config);
+                configs_if.push_back(std::move(config));
                 ret.insert(cfg(configs_if, userDefines));
             } else if (!configs_ifndef.empty()) {
-                configs_if.push_back(configs_ifndef.back());
-                ret.insert(cfg(configs_if, userDefines));
+                //Check if ifndef already existing in ret as more general/specific version
+                const std::string &confCandidate = configs_ifndef.back();
+                if (ret.find(confCandidate) == ret.end()) {
+                    // No instance of config_ifndef in ret. Check if a more specific version exists, in that case replace it
+                    const std::set<std::string>::iterator it = ret.find(confCandidate + "=" + confCandidate);
+                    if (it != ret.end()) {
+                        // The instance in ret is more specific than the one in confCandidate (no =value), replace it with the one in confCandidate
+                        ret.erase(it);
+                    }
+                    configs_if.push_back(configs_ifndef.back());
+                    ret.insert(cfg(configs_if, userDefines));
+                }
             }
         } else if (cmdtok->str() == "endif" && !sameline(tok, cmdtok->next)) {
             if (!configs_if.empty())
@@ -396,6 +730,16 @@ static void getConfigs(const simplecpp::TokenList &tokens, std::set<std::string>
                 std::vector<std::string> configs(configs_if);
                 configs.push_back(configs_ifndef.back());
                 ret.erase(cfg(configs, userDefines));
+                std::set<std::string> temp;
+                temp.swap(ret);
+                for (const std::string &c: temp) {
+                    if (c.find(configs_ifndef.back()) != std::string::npos)
+                        ret.insert(c);
+                    else if (c.empty())
+                        ret.insert("");
+                    else
+                        ret.insert(c + ";" + configs_ifndef.back());
+                }
                 if (!elseError.empty())
                     elseError += ';';
                 elseError += cfg(configs_ifndef, userDefines);
@@ -418,91 +762,39 @@ static void getConfigs(const simplecpp::TokenList &tokens, std::set<std::string>
         }
     }
     if (!elseError.empty())
-        ret.insert(elseError);
+        ret.insert(std::move(elseError));
 }
 
 
-std::set<std::string> Preprocessor::getConfigs(const simplecpp::TokenList &tokens) const
+std::set<std::string> Preprocessor::getConfigs() const
 {
     std::set<std::string> ret = { "" };
-    if (!tokens.cfront())
+    if (!mTokens.cfront())
         return ret;
 
     std::set<std::string> defined = { "__cplusplus" };
 
-    ::getConfigs(tokens, defined, mSettings.userDefines, mSettings.userUndefs, ret);
-
-    for (std::map<std::string, simplecpp::TokenList*>::const_iterator it = mTokenLists.begin(); it != mTokenLists.end(); ++it) {
-        if (!mSettings.configurationExcluded(it->first))
-            ::getConfigs(*(it->second), defined, mSettings.userDefines, mSettings.userUndefs, ret);
-    }
-
-    return ret;
-}
-
-
-void Preprocessor::preprocess(std::istream &istr, std::map<std::string, std::string> &result, const std::string &filename, const std::list<std::string> &includePaths)
-{
-    (void)includePaths;
-
-    simplecpp::OutputList outputList;
-    std::vector<std::string> files;
-    const simplecpp::TokenList tokens1(istr, files, filename, &outputList);
+    // Insert library defines
+    for (const auto &define : mSettings.library.defines()) {
 
-    const std::set<std::string> configs = getConfigs(tokens1);
+        const std::string::size_type paren = define.find("(");
+        const std::string::size_type space = define.find(" ");
+        std::string::size_type end = space;
 
-    for (const std::string &cfg : configs) {
-        if (mSettings.userUndefs.find(cfg) == mSettings.userUndefs.end()) {
-            result[cfg] = getcode(tokens1, cfg, files, false);
-        }
-    }
-}
+        if (paren != std::string::npos && paren < space)
+            end = paren;
 
-std::string Preprocessor::removeSpaceNearNL(const std::string &str)
-{
-    std::string tmp;
-    char prev = '\n'; // treat start of file as newline
-    for (std::size_t i = 0; i < str.size(); i++) {
-        if (str[i] == ' ' &&
-            (prev == '\n' ||
-             i + 1 >= str.size() || // treat end of file as newline
-             str[i+1] == '\n'
-            )
-           ) {
-            // Ignore space that has new line in either side of it
-        } else {
-            tmp.append(1, str[i]);
-            prev = str[i];
-        }
+        defined.insert(define.substr(0, end));
     }
 
-    return tmp;
-}
-
-void Preprocessor::preprocessWhitespaces(std::string &processedFile)
-{
-    // Replace all tabs with spaces..
-    std::replace(processedFile.begin(), processedFile.end(), '\t', ' ');
-
-    // Remove space characters that are after or before new line character
-    processedFile = removeSpaceNearNL(processedFile);
-}
-
-void Preprocessor::preprocess(std::istream &srcCodeStream, std::string &processedFile, std::list<std::string> &resultConfigurations, const std::string &filename, const std::list<std::string> &includePaths)
-{
-    (void)includePaths;
-
-    if (mFile0.empty())
-        mFile0 = filename;
+    ::getConfigs(mTokens, defined, mSettings.userDefines, mSettings.userUndefs, ret);
 
-    simplecpp::OutputList outputList;
-    std::vector<std::string> files;
-    const simplecpp::TokenList tokens1(srcCodeStream, files, filename, &outputList);
-
-    const std::set<std::string> configs = getConfigs(tokens1);
-    std::copy(configs.cbegin(), configs.cend(), std::back_inserter(resultConfigurations));
+    for (const auto &filedata : mFileCache) {
+        if (!mSettings.configurationExcluded(filedata->filename))
+            ::getConfigs(filedata->tokens, defined, mSettings.userDefines, mSettings.userUndefs, ret);
+    }
 
-    processedFile = tokens1.stringify();
+    return ret;
 }
 
 static void splitcfg(const std::string &cfg, std::list<std::string> &defines, const std::string &defaultValue)
@@ -512,22 +804,23 @@ static void splitcfg(const std::string &cfg, std::list<std::string> &defines, co
         std::string def = (defineEndPos == std::string::npos) ? cfg.substr(defineStartPos) : cfg.substr(defineStartPos, defineEndPos - defineStartPos);
         if (!defaultValue.empty() && def.find('=') == std::string::npos)
             def += '=' + defaultValue;
-        defines.push_back(def);
+        defines.push_back(std::move(def));
         if (defineEndPos == std::string::npos)
             break;
         defineStartPos = defineEndPos + 1U;
     }
 }
 
-static simplecpp::DUI createDUI(const Settings &mSettings, const std::string &cfg, const std::string &filename)
+static simplecpp::DUI createDUI(const Settings &mSettings, const std::string &cfg, Standards::Language lang)
 {
+    // TODO: make it possible to specify platform-dependent sizes
     simplecpp::DUI dui;
 
     splitcfg(mSettings.userDefines, dui.defines, "1");
     if (!cfg.empty())
-        splitcfg(cfg, dui.defines, emptyString);
+        splitcfg(cfg, dui.defines, "");
 
-    for (const std::string &def : mSettings.library.defines) {
+    for (const std::string &def : mSettings.library.defines()) {
         const std::string::size_type pos = def.find_first_of(" (");
         if (pos == std::string::npos) {
             dui.defines.push_back(def);
@@ -539,117 +832,100 @@ static simplecpp::DUI createDUI(const Settings &mSettings, const std::string &cf
         } else {
             s[s.find(')')+1] = '=';
         }
-        dui.defines.push_back(s);
+        dui.defines.push_back(std::move(s));
     }
 
-    if (Path::isCPP(filename))
-        dui.defines.emplace_back("__cplusplus");
-
     dui.undefined = mSettings.userUndefs; // -U
     dui.includePaths = mSettings.includePaths; // -I
     dui.includes = mSettings.userIncludes;  // --include
+    if (lang == Standards::Language::CPP) {
+        dui.std = mSettings.standards.stdValueCPP;
+        if (dui.std.empty()) {
+            dui.std = mSettings.standards.getCPP();
+        }
+        splitcfg(mSettings.platform.getLimitsDefines(Standards::getCPP(dui.std)), dui.defines, "");
+    }
+    else if (lang == Standards::Language::C) {
+        dui.std = mSettings.standards.stdValueC;
+        if (dui.std.empty()) {
+            dui.std = mSettings.standards.getC();
+        }
+        splitcfg(mSettings.platform.getLimitsDefines(Standards::getC(dui.std)), dui.defines, "");
+    }
+    dui.clearIncludeCache = mSettings.clearIncludeCache;
     return dui;
 }
 
-static bool hasErrors(const simplecpp::OutputList &outputList)
+const simplecpp::Output* Preprocessor::handleErrors(const simplecpp::OutputList& outputList)
 {
-    for (simplecpp::OutputList::const_iterator it = outputList.begin(); it != outputList.end(); ++it) {
-        switch (it->type) {
-        case simplecpp::Output::ERROR:
-        case simplecpp::Output::INCLUDE_NESTED_TOO_DEEPLY:
-        case simplecpp::Output::SYNTAX_ERROR:
-        case simplecpp::Output::UNHANDLED_CHAR_ERROR:
-            return true;
-        case simplecpp::Output::WARNING:
-        case simplecpp::Output::MISSING_HEADER:
-        case simplecpp::Output::PORTABILITY_BACKSLASH:
-            break;
-        };
-    }
-    return false;
+    const bool showerror = (!mSettings.userDefines.empty() && !mSettings.force);
+    return reportOutput(outputList, showerror);
 }
 
-
-void Preprocessor::loadFiles(const simplecpp::TokenList &rawtokens, std::vector<std::string> &files)
+bool Preprocessor::loadFiles(std::vector<std::string> &files)
 {
-    const simplecpp::DUI dui = createDUI(mSettings, emptyString, files[0]);
+    const simplecpp::DUI dui = createDUI(mSettings, "", mLang);
 
-    mTokenLists = simplecpp::load(rawtokens, files, dui, nullptr);
+    simplecpp::OutputList outputList;
+    mFileCache = simplecpp::load(mTokens, files, dui, &outputList);
+    return !handleErrors(outputList);
 }
 
 void Preprocessor::removeComments()
 {
-    for (std::map<std::string, simplecpp::TokenList*>::iterator it = mTokenLists.begin(); it != mTokenLists.end(); ++it) {
-        if (it->second)
-            it->second->removeComments();
+    mTokens.removeComments();
+    for (const auto &filedata : mFileCache) {
+        filedata->tokens.removeComments();
     }
 }
 
-void Preprocessor::setPlatformInfo(simplecpp::TokenList *tokens) const
+void Preprocessor::setPlatformInfo()
 {
-    tokens->sizeOfType["bool"]          = mSettings.sizeof_bool;
-    tokens->sizeOfType["short"]         = mSettings.sizeof_short;
-    tokens->sizeOfType["int"]           = mSettings.sizeof_int;
-    tokens->sizeOfType["long"]          = mSettings.sizeof_long;
-    tokens->sizeOfType["long long"]     = mSettings.sizeof_long_long;
-    tokens->sizeOfType["float"]         = mSettings.sizeof_float;
-    tokens->sizeOfType["double"]        = mSettings.sizeof_double;
-    tokens->sizeOfType["long double"]   = mSettings.sizeof_long_double;
-    tokens->sizeOfType["bool *"]        = mSettings.sizeof_pointer;
-    tokens->sizeOfType["short *"]       = mSettings.sizeof_pointer;
-    tokens->sizeOfType["int *"]         = mSettings.sizeof_pointer;
-    tokens->sizeOfType["long *"]        = mSettings.sizeof_pointer;
-    tokens->sizeOfType["long long *"]   = mSettings.sizeof_pointer;
-    tokens->sizeOfType["float *"]       = mSettings.sizeof_pointer;
-    tokens->sizeOfType["double *"]      = mSettings.sizeof_pointer;
-    tokens->sizeOfType["long double *"] = mSettings.sizeof_pointer;
+    mTokens.sizeOfType["bool"]          = mSettings.platform.sizeof_bool;
+    mTokens.sizeOfType["short"]         = mSettings.platform.sizeof_short;
+    mTokens.sizeOfType["int"]           = mSettings.platform.sizeof_int;
+    mTokens.sizeOfType["long"]          = mSettings.platform.sizeof_long;
+    mTokens.sizeOfType["long long"]     = mSettings.platform.sizeof_long_long;
+    mTokens.sizeOfType["float"]         = mSettings.platform.sizeof_float;
+    mTokens.sizeOfType["double"]        = mSettings.platform.sizeof_double;
+    mTokens.sizeOfType["long double"]   = mSettings.platform.sizeof_long_double;
+    mTokens.sizeOfType["bool *"]        = mSettings.platform.sizeof_pointer;
+    mTokens.sizeOfType["short *"]       = mSettings.platform.sizeof_pointer;
+    mTokens.sizeOfType["int *"]         = mSettings.platform.sizeof_pointer;
+    mTokens.sizeOfType["long *"]        = mSettings.platform.sizeof_pointer;
+    mTokens.sizeOfType["long long *"]   = mSettings.platform.sizeof_pointer;
+    mTokens.sizeOfType["float *"]       = mSettings.platform.sizeof_pointer;
+    mTokens.sizeOfType["double *"]      = mSettings.platform.sizeof_pointer;
+    mTokens.sizeOfType["long double *"] = mSettings.platform.sizeof_pointer;
 }
 
-simplecpp::TokenList Preprocessor::preprocess(const simplecpp::TokenList &tokens1, const std::string &cfg, std::vector<std::string> &files, bool throwError)
+simplecpp::TokenList Preprocessor::preprocess(const std::string &cfg, std::vector<std::string> &files, simplecpp::OutputList& outputList)
 {
-    const simplecpp::DUI dui = createDUI(mSettings, cfg, files[0]);
+    const simplecpp::DUI dui = createDUI(mSettings, cfg, mLang);
 
-    simplecpp::OutputList outputList;
     std::list<simplecpp::MacroUsage> macroUsage;
+    std::list<simplecpp::IfCond> ifCond;
     simplecpp::TokenList tokens2(files);
-    simplecpp::preprocess(tokens2, tokens1, files, mTokenLists, dui, &outputList, &macroUsage);
-
-    const bool showerror = (!mSettings.userDefines.empty() && !mSettings.force);
-    reportOutput(outputList, showerror);
-    if (throwError && hasErrors(outputList)) {
-        for (const simplecpp::Output &output : outputList) {
-            switch (output.type) {
-            case simplecpp::Output::ERROR:
-            case simplecpp::Output::INCLUDE_NESTED_TOO_DEEPLY:
-            case simplecpp::Output::SYNTAX_ERROR:
-            case simplecpp::Output::UNHANDLED_CHAR_ERROR:
-                throw output;
-            case simplecpp::Output::WARNING:
-            case simplecpp::Output::MISSING_HEADER:
-            case simplecpp::Output::PORTABILITY_BACKSLASH:
-                break;
-            };
-        }
-    }
+    simplecpp::preprocess(tokens2, mTokens, files, mFileCache, dui, &outputList, &macroUsage, &ifCond);
+    mMacroUsage = std::move(macroUsage);
+    mIfCond = std::move(ifCond);
 
     tokens2.removeComments();
 
-    // ensure that guessed define macros without value are not used in the code
-    if (!validateCfg(cfg, macroUsage))
-        return simplecpp::TokenList(files);
-
     return tokens2;
 }
 
-std::string Preprocessor::getcode(const simplecpp::TokenList &tokens1, const std::string &cfg, std::vector<std::string> &files, const bool writeLocations)
+std::string Preprocessor::getcode(const std::string &cfg, std::vector<std::string> &files, const bool writeLocations)
 {
-    simplecpp::TokenList tokens2 = preprocess(tokens1, cfg, files, false);
+    simplecpp::OutputList outputList;
+    simplecpp::TokenList tokens2 = preprocess(cfg, files, outputList);
+    handleErrors(outputList);
     unsigned int prevfile = 0;
     unsigned int line = 1;
     std::ostringstream ret;
     for (const simplecpp::Token *tok = tokens2.cfront(); tok; tok = tok->next) {
         if (writeLocations && tok->location.fileIndex != prevfile) {
-            ret << "\n#line " << tok->location.line << " \"" << tok->location.file() << "\"\n";
+            ret << "\n#line " << tok->location.line << " \"" << mTokens.file(tok->location) << "\"\n";
             prevfile = tok->location.fileIndex;
             line = tok->location.line;
         }
@@ -668,264 +944,209 @@ std::string Preprocessor::getcode(const simplecpp::TokenList &tokens1, const std
     return ret.str();
 }
 
-std::string Preprocessor::getcode(const std::string &filedata, const std::string &cfg, const std::string &filename)
+const simplecpp::Output* Preprocessor::reportOutput(const simplecpp::OutputList &outputList, bool showerror)
 {
-    simplecpp::OutputList outputList;
-    std::vector<std::string> files;
-
-    std::istringstream istr(filedata);
-    simplecpp::TokenList tokens1(istr, files, Path::simplifyPath(filename), &outputList);
-    inlineSuppressions(tokens1);
-    tokens1.removeComments();
-    removeComments();
-    setDirectives(tokens1);
+    const simplecpp::Output* out_ret = nullptr;
 
-    reportOutput(outputList, true);
-
-    if (hasErrors(outputList))
-        return "";
-
-    std::string ret;
-    try {
-        ret = getcode(tokens1, cfg, files, filedata.find("#file") != std::string::npos);
-    } catch (const simplecpp::Output &) {
-        ret.clear();
-    }
-    return ret;
-}
-
-void Preprocessor::reportOutput(const simplecpp::OutputList &outputList, bool showerror)
-{
     for (const simplecpp::Output &out : outputList) {
         switch (out.type) {
         case simplecpp::Output::ERROR:
-            if (out.msg.compare(0,6,"#error")!=0 || showerror)
-                error(out.location.file(), out.location.line, out.msg);
+            out_ret = &out;
+            if (!startsWith(out.msg,"#error") || showerror)
+                error(out.location, out.msg, out.type);
             break;
         case simplecpp::Output::WARNING:
         case simplecpp::Output::PORTABILITY_BACKSLASH:
             break;
         case simplecpp::Output::MISSING_HEADER: {
+            // not considered an "error"
             const std::string::size_type pos1 = out.msg.find_first_of("<\"");
             const std::string::size_type pos2 = out.msg.find_first_of(">\"", pos1 + 1U);
             if (pos1 < pos2 && pos2 != std::string::npos)
-                missingInclude(out.location.file(), out.location.line, out.msg.substr(pos1+1, pos2-pos1-1), out.msg[pos1] == '\"' ? UserHeader : SystemHeader);
+                missingInclude(out.location, out.msg.substr(pos1+1, pos2-pos1-1), out.msg[pos1] == '\"' ? UserHeader : SystemHeader);
         }
         break;
         case simplecpp::Output::INCLUDE_NESTED_TOO_DEEPLY:
         case simplecpp::Output::SYNTAX_ERROR:
         case simplecpp::Output::UNHANDLED_CHAR_ERROR:
-            error(out.location.file(), out.location.line, out.msg);
+            out_ret = &out;
+            error(out.location, out.msg, out.type);
+            break;
+        case simplecpp::Output::EXPLICIT_INCLUDE_NOT_FOUND:
+        case simplecpp::Output::FILE_NOT_FOUND:
+        case simplecpp::Output::DUI_ERROR:
+            out_ret = &out;
+            error({}, out.msg, out.type);
             break;
-        };
+        }
     }
+
+    return out_ret;
 }
 
-void Preprocessor::error(const std::string &filename, unsigned int linenr, const std::string &msg)
+static std::string simplecppErrToId(simplecpp::Output::Type type)
 {
-    std::list<ErrorLogger::ErrorMessage::FileLocation> locationList;
-    if (!filename.empty()) {
-        const ErrorLogger::ErrorMessage::FileLocation loc(filename, linenr, 0);
-        locationList.push_back(loc);
+    switch (type) {
+    case simplecpp::Output::ERROR:
+        return "preprocessorErrorDirective";
+    case simplecpp::Output::SYNTAX_ERROR:
+        return "syntaxError";
+    case simplecpp::Output::UNHANDLED_CHAR_ERROR:
+        return "unhandledChar";
+    case simplecpp::Output::INCLUDE_NESTED_TOO_DEEPLY:
+        return "includeNestedTooDeeply";
+    case simplecpp::Output::FILE_NOT_FOUND:
+        return "missingFile";
+    // should never occur
+    case simplecpp::Output::EXPLICIT_INCLUDE_NOT_FOUND:
+    case simplecpp::Output::DUI_ERROR:
+    // handled separately
+    case simplecpp::Output::MISSING_HEADER:
+    // no handled at all (warnings)
+    case simplecpp::Output::WARNING:
+    case simplecpp::Output::PORTABILITY_BACKSLASH:
+        throw std::runtime_error("unexpected simplecpp::Output type " + std::to_string(type));
     }
-    mErrorLogger->reportErr(ErrorLogger::ErrorMessage(locationList,
-                            mFile0,
-                            Severity::error,
-                            msg,
-                            "preprocessorErrorDirective",
-                            false));
+
+    cppcheck::unreachable();
 }
 
-// Report that include is missing
-void Preprocessor::missingInclude(const std::string &filename, unsigned int linenr, const std::string &header, HeaderTypes headerType)
-{
-    const std::string fname = Path::fromNativeSeparators(filename);
-    Suppressions::ErrorMessage errorMessage;
-    errorMessage.errorId = "missingInclude";
-    errorMessage.setFileName(fname);
-    errorMessage.lineNumber = linenr;
-    if (mSettings.nomsg.isSuppressed(errorMessage))
-        return;
-    errorMessage.errorId = "missingIncludeSystem";
-    if (headerType == SystemHeader && mSettings.nomsg.isSuppressed(errorMessage))
-        return;
+void Preprocessor::error(const simplecpp::Location& loc, const std::string &msg, simplecpp::Output::Type type)
+{
+    error(loc, msg, simplecppErrToId(type));
+}
 
-    if (headerType == SystemHeader)
-        missingSystemIncludeFlag = true;
-    else
-        missingIncludeFlag = true;
-    if (mErrorLogger && mSettings.checkConfiguration) {
-
-        std::list<ErrorLogger::ErrorMessage::FileLocation> locationList;
-        if (!filename.empty()) {
-            ErrorLogger::ErrorMessage::FileLocation loc;
-            loc.line = linenr;
-            loc.setfile(Path::toNativeSeparators(filename));
-            locationList.push_back(loc);
-        }
-        ErrorLogger::ErrorMessage errmsg(locationList, mFile0, Severity::information,
-                                         (headerType==SystemHeader) ?
-                                         "Include file: <" + header + "> not found. Please note: Cppcheck does not need standard library headers to get proper results." :
-                                         "Include file: \"" + header + "\" not found.",
-                                         (headerType==SystemHeader) ? "missingIncludeSystem" : "missingInclude",
-                                         false);
-        mErrorLogger->reportInfo(errmsg);
+void Preprocessor::error(const simplecpp::Location& loc, const std::string &msg, const std::string& id)
+{
+    std::list<ErrorMessage::FileLocation> locationList;
+    if (!mTokens.file(loc).empty()) {
+        std::string file = Path::fromNativeSeparators(mTokens.file(loc));
+        if (mSettings.relativePaths)
+            file = Path::getRelativePath(file, mSettings.basePaths);
+
+        locationList.emplace_back(file, loc.line, loc.col);
     }
+    mErrorLogger.reportErr(ErrorMessage(std::move(locationList),
+                                        mFile0,
+                                        Severity::error,
+                                        msg,
+                                        id,
+                                        Certainty::normal));
 }
 
-bool Preprocessor::validateCfg(const std::string &cfg, const std::list<simplecpp::MacroUsage> &macroUsageList)
+// Report that include is missing
+void Preprocessor::missingInclude(const simplecpp::Location& loc, const std::string &header, HeaderTypes headerType)
 {
-    bool ret = true;
-    std::list<std::string> defines;
-    splitcfg(cfg, defines, emptyString);
-    for (const std::string &define : defines) {
-        if (define.find('=') != std::string::npos)
-            continue;
-        const std::string macroName(define.substr(0, define.find('(')));
-        for (const simplecpp::MacroUsage &mu : macroUsageList) {
-            if (mu.macroValueKnown)
-                continue;
-            if (mu.macroName != macroName)
-                continue;
-            bool directiveLocation = std::any_of(mDirectives.cbegin(), mDirectives.cend(),
-            [=](const Directive &dir) {
-                return mu.useLocation.file() == dir.file && mu.useLocation.line == dir.linenr;
-            });
-
-            if (!directiveLocation) {
-                if (mSettings.isEnabled(Settings::INFORMATION))
-                    validateCfgError(mu.useLocation.file(), mu.useLocation.line, cfg, macroName);
-                ret = false;
-            }
-        }
-    }
+    if (!mSettings.checks.isEnabled(Checks::missingInclude))
+        return;
 
-    return ret;
+    std::list<ErrorMessage::FileLocation> locationList;
+    if (!mTokens.file(loc).empty()) {
+        // TODO: add relative path handling?
+        locationList.emplace_back(mTokens.file(loc), loc.line, loc.col);
+    }
+    ErrorMessage errmsg(std::move(locationList), mFile0, Severity::information,
+                        (headerType==SystemHeader) ?
+                        "Include file: <" + header + "> not found. Please note: Standard library headers do not need to be provided to get proper results." :
+                        "Include file: \"" + header + "\" not found.",
+                        (headerType==SystemHeader) ? "missingIncludeSystem" : "missingInclude",
+                        Certainty::normal);
+    mErrorLogger.reportErr(errmsg);
 }
 
-void Preprocessor::validateCfgError(const std::string &file, const unsigned int line, const std::string &cfg, const std::string &macro)
+void Preprocessor::invalidSuppression(const simplecpp::Location& loc, const std::string &msg)
 {
-    const std::string id = "ConfigurationNotChecked";
-    std::list<ErrorLogger::ErrorMessage::FileLocation> locationList;
-    const ErrorLogger::ErrorMessage::FileLocation loc(file, line, 0);
-    locationList.push_back(loc);
-    const ErrorLogger::ErrorMessage errmsg(locationList, mFile0, Severity::information, "Skipping configuration '" + cfg + "' since the value of '" + macro + "' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.", id, false);
-    mErrorLogger->reportInfo(errmsg);
+    error(loc, msg, "invalidSuppression");
 }
 
-void Preprocessor::getErrorMessages(ErrorLogger *errorLogger, const Settings *settings)
+void Preprocessor::getErrorMessages(ErrorLogger &errorLogger, const Settings &settings)
 {
-    Settings settings2(*settings);
-    Preprocessor preprocessor(settings2, errorLogger);
-    settings2.checkConfiguration = true;
-    preprocessor.missingInclude(emptyString, 1, emptyString, UserHeader);
-    preprocessor.missingInclude(emptyString, 1, emptyString, SystemHeader);
-    preprocessor.validateCfgError(emptyString, 1, "X", "X");
-    preprocessor.error(emptyString, 1, "#error message");   // #error ..
+    std::vector<std::string> files;
+    simplecpp::TokenList tokens(files);
+    Preprocessor preprocessor(tokens, settings, errorLogger, Standards::Language::CPP);
+    simplecpp::Location loc;
+    loc.line = 1;
+    loc.col = 2;
+    preprocessor.missingInclude(loc, "", UserHeader);
+    preprocessor.missingInclude(loc, "", SystemHeader);
+    preprocessor.error(loc, "message", simplecpp::Output::ERROR);
+    preprocessor.error(loc, "message", simplecpp::Output::SYNTAX_ERROR);
+    preprocessor.error(loc, "message", simplecpp::Output::UNHANDLED_CHAR_ERROR);
+    preprocessor.error(loc, "message", simplecpp::Output::INCLUDE_NESTED_TOO_DEEPLY);
+    preprocessor.error(loc, "message", simplecpp::Output::FILE_NOT_FOUND);
+    preprocessor.invalidSuppression(loc, "message");
 }
 
 void Preprocessor::dump(std::ostream &out) const
 {
-    // Create a xml directive dump.
-    // The idea is not that this will be readable for humans. It's a
-    // data dump that 3rd party tools could load and get useful info from.
-    out << "  <directivelist>" << std::endl;
-
-    for (const Directive &dir : mDirectives) {
-        out << "    <directive "
-            << "file=\"" << ErrorLogger::toxml(dir.file) << "\" "
-            << "linenr=\"" << dir.linenr << "\" "
-            // str might contain characters such as '"', '<' or '>' which
-            // could result in invalid XML, so run it through toxml().
-            << "str=\"" << ErrorLogger::toxml(dir.str) << "\"/>" << std::endl;
-    }
-    out << "  </directivelist>" << std::endl;
-}
-
-static const std::uint32_t crc32Table[] = {
-    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
-    0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
-    0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
-    0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
-    0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
-    0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
-    0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
-    0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
-    0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
-    0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
-    0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
-    0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
-    0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
-    0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
-    0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
-    0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
-    0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
-    0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
-    0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
-    0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
-    0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
-    0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
-    0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
-    0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
-    0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
-    0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
-    0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
-    0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
-    0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
-    0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
-    0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
-    0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
-    0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
-    0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
-    0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
-    0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
-    0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
-    0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
-    0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
-    0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
-    0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
-    0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
-    0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
-};
-
-static std::uint32_t crc32(const std::string &data)
-{
-    std::uint32_t crc = ~0U;
-    for (char c : data) {
-        crc = crc32Table[(crc ^ (unsigned char)c) & 0xFF] ^ (crc >> 8);
-    }
-    return crc ^ ~0U;
-}
-
-unsigned int Preprocessor::calculateChecksum(const simplecpp::TokenList &tokens1, const std::string &toolinfo) const
-{
-    std::ostringstream ostr;
-    ostr << toolinfo << '\n';
-    for (const simplecpp::Token *tok = tokens1.cfront(); tok; tok = tok->next) {
-        if (!tok->comment)
-            ostr << tok->str();
+    // Create a xml dump.
+
+    if (!mMacroUsage.empty()) {
+        out << "  <macro-usage>" << std::endl;
+        for (const simplecpp::MacroUsage &macroUsage: mMacroUsage) {
+            out << "    <macro"
+                << " name=\"" << macroUsage.macroName << "\""
+                << " file=\"" << ErrorLogger::toxml(mTokens.file(macroUsage.macroLocation)) << "\""
+                << " line=\"" << macroUsage.macroLocation.line << "\""
+                << " column=\"" << macroUsage.macroLocation.col << "\""
+                << " usefile=\"" << ErrorLogger::toxml(mTokens.file(macroUsage.useLocation)) << "\""
+                << " useline=\"" << macroUsage.useLocation.line << "\""
+                << " usecolumn=\"" << macroUsage.useLocation.col << "\""
+                << " is-known-value=\"" << bool_to_string(macroUsage.macroValueKnown) << "\""
+                << "/>" << std::endl;
+        }
+        out << "  </macro-usage>" << std::endl;
+    }
+
+    if (!mIfCond.empty()) {
+        out << "  <simplecpp-if-cond>" << std::endl;
+        for (const simplecpp::IfCond &ifCond: mIfCond) {
+            out << "    <if-cond"
+                << " file=\"" << ErrorLogger::toxml(mTokens.file(ifCond.location)) << "\""
+                << " line=\"" << ifCond.location.line << "\""
+                << " column=\"" << ifCond.location.col << "\""
+                << " E=\"" << ErrorLogger::toxml(ifCond.E) << "\""
+                << " result=\"" << ifCond.result << "\""
+                << "/>" << std::endl;
+        }
+        out << "  </simplecpp-if-cond>" << std::endl;
+    }
+}
+
+std::size_t Preprocessor::calculateHash(const std::string &toolinfo) const
+{
+    std::string hashData = toolinfo;
+    for (const simplecpp::Token *tok = mTokens.cfront(); tok; tok = tok->next) {
+        if (!tok->comment) {
+            hashData += tok->str();
+            hashData += static_cast<char>(tok->location.line);
+            hashData += static_cast<char>(tok->location.col);
+        }
     }
-    for (std::map<std::string, simplecpp::TokenList *>::const_iterator it = mTokenLists.begin(); it != mTokenLists.end(); ++it) {
-        for (const simplecpp::Token *tok = it->second->cfront(); tok; tok = tok->next) {
-            if (!tok->comment)
-                ostr << tok->str();
+    for (const auto &filedata : mFileCache) {
+        for (const simplecpp::Token *tok = filedata->tokens.cfront(); tok; tok = tok->next) {
+            if (!tok->comment) {
+                hashData += tok->str();
+                hashData += static_cast<char>(tok->location.line);
+                hashData += static_cast<char>(tok->location.col);
+            }
         }
     }
-    return crc32(ostr.str());
+    return (std::hash<std::string>{})(hashData);
 }
 
-void Preprocessor::simplifyPragmaAsm(simplecpp::TokenList *tokenList)
+void Preprocessor::simplifyPragmaAsm()
 {
-    Preprocessor::simplifyPragmaAsmPrivate(tokenList);
-    for (std::map<std::string, simplecpp::TokenList *>::iterator it = mTokenLists.begin(); it != mTokenLists.end(); ++it) {
-        Preprocessor::simplifyPragmaAsmPrivate(it->second);
+    Preprocessor::simplifyPragmaAsmPrivate(mTokens);
+    for (const auto &filedata : mFileCache) {
+        Preprocessor::simplifyPragmaAsmPrivate(filedata->tokens);
     }
 }
 
-void Preprocessor::simplifyPragmaAsmPrivate(simplecpp::TokenList *tokenList)
+void Preprocessor::simplifyPragmaAsmPrivate(simplecpp::TokenList &tokenList)
 {
     // assembler code..
-    for (simplecpp::Token *tok = tokenList->front(); tok; tok = tok->next) {
+    for (simplecpp::Token *tok = tokenList.front(); tok; tok = tok->next) {
         if (tok->op != '#')
             continue;
         if (sameline(tok, tok->previousSkipComments()))
@@ -940,6 +1161,7 @@ void Preprocessor::simplifyPragmaAsmPrivate(simplecpp::TokenList *tokenList)
             continue;
 
         const simplecpp::Token *endasm = tok3;
+        bool foundEndasm = false;
         while ((endasm = endasm->next) != nullptr) {
             if (endasm->op != '#' || sameline(endasm,endasm->previousSkipComments()))
                 continue;
@@ -951,15 +1173,70 @@ void Preprocessor::simplifyPragmaAsmPrivate(simplecpp::TokenList *tokenList)
                 continue;
             while (sameline(endasm,endasm3))
                 endasm = endasm->next;
+            foundEndasm = true;
             break;
         }
 
+        if (!foundEndasm)
+            throw InternalError(nullptr, "syntax error: missing #pragma endasm", InternalError::SYNTAX);
+
         const simplecpp::Token * const tok4 = tok3->next;
         tok->setstr("asm");
         const_cast<simplecpp::Token *>(tok2)->setstr("(");
         const_cast<simplecpp::Token *>(tok3)->setstr(")");
         const_cast<simplecpp::Token *>(tok4)->setstr(";");
         while (tok4->next != endasm)
-            tokenList->deleteToken(tok4->next);
+            tokenList.deleteToken(tok4->next);
+    }
+}
+
+
+void Preprocessor::addRemarkComments(const simplecpp::TokenList &tokens, std::vector<RemarkComment> &remarkComments) const
+{
+    for (const simplecpp::Token *tok = tokens.cfront(); tok; tok = tok->next) {
+        if (!tok->comment)
+            continue;
+
+        const std::string& comment = tok->str();
+
+        // is it a remark comment?
+        const std::string::size_type pos1 = comment.find_first_not_of("/* \t");
+        if (pos1 == std::string::npos)
+            continue;
+        const std::string::size_type pos2 = comment.find_first_of(": \t", pos1);
+        if (pos2 != pos1 + 6 || comment.compare(pos1, 6, "REMARK") != 0)
+            continue;
+        const std::string::size_type pos3 = comment.find_first_not_of(": \t", pos2);
+        if (pos3 == std::string::npos)
+            continue;
+        if (comment.compare(0,2,"/*") == 0 && pos3 + 2 >= tok->str().size())
+            continue;
+
+        const std::string::size_type pos4 = (comment.compare(0,2,"/*") == 0) ? comment.size()-2 : comment.size();
+        const std::string remarkText = comment.substr(pos3, pos4-pos3);
+
+        // Get remarked token
+        const simplecpp::Token* remarkedToken = nullptr;
+        for (const simplecpp::Token* after = tok->next; after; after = after->next) {
+            if (after->comment)
+                continue;
+            remarkedToken = after;
+            break;
+        }
+        for (const simplecpp::Token* prev = tok->previous; prev; prev = prev->previous) {
+            if (prev->comment)
+                continue;
+            if (sameline(prev, tok))
+                remarkedToken = prev;
+            break;
+        }
+        if (!remarkedToken)
+            continue;
+
+        // Relative filename
+        const std::string relativeFilename = getRelativeFilename(tokens, remarkedToken, mSettings);
+
+        // Add the suppressions.
+        remarkComments.emplace_back(relativeFilename, remarkedToken->location.line, remarkText);
     }
 }
diff --git a/lib/preprocessor.h b/lib/preprocessor.h
index 86505d57574..a211341691f 100644
--- a/lib/preprocessor.h
+++ b/lib/preprocessor.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,29 +22,33 @@
 //---------------------------------------------------------------------------
 
 #include "config.h"
+#include "standards.h"
 
-#include <simplecpp.h>
+#include <cstddef>
+#include <cstdint>
 #include <istream>
 #include <list>
-#include <map>
 #include <set>
 #include <string>
+#include <utility>
 #include <vector>
 
+#include <simplecpp.h>
+
 class ErrorLogger;
 class Settings;
+class SuppressionList;
 
 /**
  * @brief A preprocessor directive
  * Each preprocessor directive (\#include, \#define, \#undef, \#if, \#ifdef, \#else, \#endif)
  * will be recorded as an instance of this class.
  *
- * file and linenr denote the location where where the directive is defined.
+ * file and linenr denote the location where the directive is defined.
  *
  */
 
-class CPPCHECKLIB Directive {
-public:
+struct CPPCHECKLIB Directive {
     /** name of (possibly included) file where directive is defined */
     std::string file;
 
@@ -54,8 +58,35 @@ class CPPCHECKLIB Directive {
     /** the actual directive text */
     std::string str;
 
+    struct DirectiveToken {
+        explicit DirectiveToken(const simplecpp::Token & _tok);
+        int line;
+        int column;
+        std::string tokStr;
+    };
+
+    std::vector<DirectiveToken> strTokens;
+
     /** record a directive (possibly filtering src) */
-    Directive(const std::string &_file, const int _linenr, const std::string &_str);
+    Directive(const simplecpp::TokenList &tokens, const simplecpp::Location & _loc, std::string _str);
+};
+
+class CPPCHECKLIB RemarkComment {
+public:
+    RemarkComment(std::string file, unsigned int lineNumber, std::string str)
+        : file(std::move(file))
+        , lineNumber(lineNumber)
+        , str(std::move(str))
+    {}
+
+    /** name of file */
+    std::string file;
+
+    /** line number for the code that the remark comment is about */
+    unsigned int lineNumber;
+
+    /** remark text */
+    std::string str;
 };
 
 /// @addtogroup Core
@@ -66,156 +97,87 @@ class CPPCHECKLIB Directive {
  * The preprocessor has special functionality for extracting the various ifdef
  * configurations that exist in a source file.
  */
-class CPPCHECKLIB Preprocessor {
+class CPPCHECKLIB WARN_UNUSED Preprocessor {
 public:
-
-    /**
-     * Include file types.
-     */
-    enum HeaderTypes {
-        NoHeader = 0,
-        UserHeader,
-        SystemHeader
-    };
-
     /** character that is inserted in expanded macros */
     static char macroChar;
 
-    explicit Preprocessor(Settings& settings, ErrorLogger *errorLogger = nullptr);
-    virtual ~Preprocessor();
-
-    static bool missingIncludeFlag;
-    static bool missingSystemIncludeFlag;
+    Preprocessor(simplecpp::TokenList& tokens, const Settings& settings, ErrorLogger &errorLogger, Standards::Language lang);
 
-    void inlineSuppressions(const simplecpp::TokenList &tokens);
+    void inlineSuppressions(SuppressionList &suppressions);
 
-    void setDirectives(const simplecpp::TokenList &tokens);
+    std::list<Directive> createDirectives() const;
 
-    /** list of all directives met while preprocessing file */
-    const std::list<Directive> &getDirectives() const {
-        return mDirectives;
-    }
+    std::set<std::string> getConfigs() const;
 
-    std::set<std::string> getConfigs(const simplecpp::TokenList &tokens) const;
+    std::vector<RemarkComment> getRemarkComments() const;
 
-    void loadFiles(const simplecpp::TokenList &rawtokens, std::vector<std::string> &files);
+    bool loadFiles(std::vector<std::string> &files);
 
     void removeComments();
 
-    void setPlatformInfo(simplecpp::TokenList *tokens) const;
+    void setPlatformInfo();
 
-    /**
-     * Extract the code for each configuration
-     * @param istr The (file/string) stream to read from.
-     * @param result The map that will get the results
-     * @param filename The name of the file to check e.g. "src/main.cpp"
-     * @param includePaths List of paths where include files should be searched from,
-     * single path can be e.g. in format "include/".
-     * There must be a path separator at the end. Default parameter is empty list.
-     * Note that if path from given filename is also extracted and that is used as
-     * a last include path if include file was not found from earlier paths.
-     */
-    void preprocess(std::istream &istr, std::map<std::string, std::string> &result, const std::string &filename, const std::list<std::string> &includePaths = std::list<std::string>());
+    simplecpp::TokenList preprocess(const std::string &cfg, std::vector<std::string> &files, simplecpp::OutputList& outputList);
 
-    /**
-     * Extract the code for each configuration. Use this with getcode() to get the
-     * file data for each individual configuration.
-     *
-     * @param srcCodeStream The (file/string) stream to read from.
-     * @param processedFile Give reference to empty string as a parameter,
-     * function will fill processed file here. Use this also as a filedata parameter
-     * to getcode() if you received more than once configurations.
-     * @param resultConfigurations List of configurations. Pass these one by one
-     * to getcode() with processedFile.
-     * @param filename The name of the file to check e.g. "src/main.cpp"
-     * @param includePaths List of paths where include files should be searched from,
-     * single path can be e.g. in format "include/".
-     * There must be a path separator at the end. Default parameter is empty list.
-     * Note that if path from given filename is also extracted and that is used as
-     * a last include path if include file was not found from earlier paths.
-     */
-    void preprocess(std::istream &srcCodeStream, std::string &processedFile, std::list<std::string> &resultConfigurations, const std::string &filename, const std::list<std::string> &includePaths);
-
-    simplecpp::TokenList preprocess(const simplecpp::TokenList &tokens1, const std::string &cfg, std::vector<std::string> &files, bool throwError = false);
-
-    std::string getcode(const simplecpp::TokenList &tokens1, const std::string &cfg, std::vector<std::string> &files, const bool writeLocations);
-
-    /**
-     * Get preprocessed code for a given configuration
-     * @param filedata file data including preprocessing 'if', 'define', etc
-     * @param cfg configuration to read out
-     * @param filename name of source file
-     */
-    std::string getcode(const std::string &filedata, const std::string &cfg, const std::string &filename);
-
-    /**
-     * preprocess all whitespaces
-     * @param processedFile The data to be processed
-     */
-    static void preprocessWhitespaces(std::string &processedFile);
+    std::string getcode(const std::string &cfg, std::vector<std::string> &files, bool writeLocations);
 
     /**
-     * make sure empty configuration macros are not used in code. the given code must be a single configuration
-     * @param cfg configuration
-     * @param macroUsageList macro usage list
-     * @return true => configuration is valid
-     */
-    bool validateCfg(const std::string &cfg, const std::list<simplecpp::MacroUsage> &macroUsageList);
-    void validateCfgError(const std::string &file, const unsigned int line, const std::string &cfg, const std::string &macro);
-
-    /**
-     * Calculate CRC32 checksum. Using toolinfo, tokens1, filedata.
+     * Calculate HASH. Using toolinfo, tokens1, filedata.
      *
-     * @param tokens1    Sourcefile tokens
      * @param toolinfo   Arbitrary extra toolinfo
-     * @return CRC32 checksum
+     * @return HASH
      */
-    unsigned int calculateChecksum(const simplecpp::TokenList &tokens1, const std::string &toolinfo) const;
-
-    void simplifyPragmaAsm(simplecpp::TokenList *tokenList);
+    std::size_t calculateHash(const std::string &toolinfo) const;
 
-private:
+    void simplifyPragmaAsm();
 
-    static void simplifyPragmaAsmPrivate(simplecpp::TokenList *tokenList);
+    static void getErrorMessages(ErrorLogger &errorLogger, const Settings &settings);
 
     /**
-     * Remove space that has new line character on left or right side of it.
-     *
-     * @param str The string to be converted
-     * @return The string where space characters have been removed.
+     * dump all directives present in source file
      */
-    static std::string removeSpaceNearNL(const std::string &str);
+    void dump(std::ostream &out) const;
 
-public:
+    const simplecpp::Output* reportOutput(const simplecpp::OutputList &outputList, bool showerror);
 
+    void error(const simplecpp::Location& loc, const std::string &msg, simplecpp::Output::Type type);
 
-    static void getErrorMessages(ErrorLogger *errorLogger, const Settings *settings);
+    const simplecpp::Output* handleErrors(const simplecpp::OutputList &outputList);
 
-    void setFile0(const std::string &f) {
-        mFile0 = f;
-    }
+private:
+    static void simplifyPragmaAsmPrivate(simplecpp::TokenList &tokenList);
 
     /**
-     * dump all directives present in source file
+     * Include file types.
      */
-    void dump(std::ostream &out) const;
+    enum HeaderTypes : std::uint8_t {
+        UserHeader = 1,
+        SystemHeader
+    };
 
-    void reportOutput(const simplecpp::OutputList &outputList, bool showerror);
+    void missingInclude(const simplecpp::Location& loc, const std::string &header, HeaderTypes headerType);
+    void invalidSuppression(const simplecpp::Location& loc, const std::string &msg);
+    void error(const simplecpp::Location& loc, const std::string &msg, const std::string& id);
 
-private:
-    void missingInclude(const std::string &filename, unsigned int linenr, const std::string &header, HeaderTypes headerType);
-    void error(const std::string &filename, unsigned int linenr, const std::string &msg);
+    void addRemarkComments(const simplecpp::TokenList &tokens, std::vector<RemarkComment> &remarkComments) const;
+
+    simplecpp::TokenList& mTokens;
 
-    Settings& mSettings;
-    ErrorLogger *mErrorLogger;
+    const Settings& mSettings;
+    ErrorLogger &mErrorLogger;
 
     /** list of all directives met while preprocessing file */
-    std::list<Directive> mDirectives;
 
-    std::map<std::string, simplecpp::TokenList *> mTokenLists;
+    simplecpp::FileDataCache mFileCache;
 
     /** filename for cpp/c file - useful when reporting errors */
-    std::string mFile0;
+    std::string mFile0; // TODO: this is never set
+    Standards::Language mLang{Standards::Language::None};
+
+    /** simplecpp tracking info */
+    std::list<simplecpp::MacroUsage> mMacroUsage;
+    std::list<simplecpp::IfCond> mIfCond;
 };
 
 /// @}
diff --git a/lib/programmemory.cpp b/lib/programmemory.cpp
new file mode 100644
index 00000000000..750fd6653e0
--- /dev/null
+++ b/lib/programmemory.cpp
@@ -0,0 +1,1921 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "programmemory.h"
+
+#include "astutils.h"
+#include "calculate.h"
+#include "infer.h"
+#include "library.h"
+#include "mathlib.h"
+#include "settings.h"
+#include "standards.h"
+#include "symboldatabase.h"
+#include "token.h"
+#include "tokenlist.h"
+#include "utils.h"
+#include "valueflow.h"
+#include "valueptr.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <functional>
+#include <iterator>
+#include <list>
+#include <memory>
+#include <stack>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+ExprIdToken::ExprIdToken(const Token* tok)
+    : tok(tok)
+{
+    assert(tok);
+    exprid = tok->exprId();
+}
+
+ExprIdToken::ExprIdToken(nonneg int exprId) : exprid(exprId) {}
+
+nonneg int ExprIdToken::getExpressionId() const {
+    return exprid;
+}
+
+std::size_t ExprIdToken::Hash::operator()(ExprIdToken etok) const
+{
+    return std::hash<nonneg int>()(etok.getExpressionId());
+}
+
+void ProgramMemory::setValue(const Token* expr, const ValueFlow::Value& value) {
+    if (!expr)
+        return;
+
+    copyOnWrite();
+
+    ValueFlow::Value subvalue = value;
+    const Token* subexpr = solveExprValue(
+        expr,
+        [&](const Token* tok) -> std::vector<MathLib::bigint> {
+        if (const ValueFlow::Value* v = tok->getKnownValue(ValueFlow::Value::ValueType::INT))
+            return {v->intvalue};
+        MathLib::bigint result = 0;
+        if (getIntValue(tok->exprId(), result))
+            return {result};
+        return {};
+    },
+        subvalue);
+    if (expr != subexpr)
+        (*mValues)[expr] = value;
+    if (subexpr)
+        (*mValues)[subexpr] = std::move(subvalue);
+}
+
+const ValueFlow::Value* ProgramMemory::getValue(nonneg int exprid, bool impossible) const
+{
+    const auto it = find(exprid);
+    const bool found = it != mValues->cend() && (impossible || !it->second.isImpossible());
+    if (found)
+        return &it->second;
+    return nullptr;
+}
+
+bool ProgramMemory::getIntValue(nonneg int exprid, MathLib::bigint& result) const
+{
+    const ValueFlow::Value* value = getValue(exprid);
+    if (value && value->isIntValue()) {
+        result = value->intvalue;
+        return true;
+    }
+    return false;
+}
+
+void ProgramMemory::setIntValue(const Token* expr, MathLib::bigint value, bool impossible)
+{
+    ValueFlow::Value v(value);
+    if (impossible)
+        v.setImpossible();
+    setValue(expr, v);
+}
+
+bool ProgramMemory::getTokValue(nonneg int exprid, const Token*& result) const
+{
+    const ValueFlow::Value* value = getValue(exprid);
+    if (value && value->isTokValue()) {
+        result = value->tokvalue;
+        return true;
+    }
+    return false;
+}
+
+// cppcheck-suppress unusedFunction
+bool ProgramMemory::getContainerSizeValue(nonneg int exprid, MathLib::bigint& result) const
+{
+    const ValueFlow::Value* value = getValue(exprid);
+    if (value && value->isContainerSizeValue()) {
+        result = value->intvalue;
+        return true;
+    }
+    return false;
+}
+bool ProgramMemory::getContainerEmptyValue(nonneg int exprid, MathLib::bigint& result) const
+{
+    const ValueFlow::Value* value = getValue(exprid, true);
+    if (value && value->isContainerSizeValue()) {
+        if (value->isImpossible() && value->intvalue == 0) {
+            result = false;
+            return true;
+        }
+        if (!value->isImpossible()) {
+            result = (value->intvalue == 0);
+            return true;
+        }
+    }
+    return false;
+}
+
+void ProgramMemory::setContainerSizeValue(const Token* expr, MathLib::bigint value, bool isEqual)
+{
+    ValueFlow::Value v(value);
+    v.valueType = ValueFlow::Value::ValueType::CONTAINER_SIZE;
+    if (!isEqual)
+        v.valueKind = ValueFlow::Value::ValueKind::Impossible;
+    setValue(expr, v);
+}
+
+void ProgramMemory::setUnknown(const Token* expr) {
+    copyOnWrite();
+
+    (*mValues)[expr].valueType = ValueFlow::Value::ValueType::UNINIT;
+}
+
+bool ProgramMemory::hasValue(nonneg int exprid) const
+{
+    const auto it = find(exprid);
+    return it != mValues->cend();
+}
+
+const ValueFlow::Value& ProgramMemory::at(nonneg int exprid) const {
+    const auto it = find(exprid);
+    if (it == mValues->cend()) {
+        throw std::out_of_range("ProgramMemory::at");
+    }
+    return it->second;
+}
+
+ValueFlow::Value& ProgramMemory::at(nonneg int exprid) {
+    copyOnWrite();
+
+    const auto it = find(exprid);
+    if (it == mValues->end()) {
+        throw std::out_of_range("ProgramMemory::at");
+    }
+    return it->second;
+}
+
+void ProgramMemory::erase_if(const std::function<bool(const ExprIdToken&)>& pred)
+{
+    if (mValues->empty())
+        return;
+
+    // TODO: how to delay until we actuallly modify?
+    copyOnWrite();
+
+    for (auto it = mValues->begin(); it != mValues->end();) {
+        if (pred(it->first))
+            it = mValues->erase(it);
+        else
+            ++it;
+    }
+}
+
+void ProgramMemory::swap(ProgramMemory &pm) NOEXCEPT
+{
+    mValues.swap(pm.mValues);
+}
+
+void ProgramMemory::clear()
+{
+    if (mValues->empty())
+        return;
+
+    copyOnWrite();
+
+    mValues->clear();
+}
+
+bool ProgramMemory::empty() const
+{
+    return mValues->empty();
+}
+
+// NOLINTNEXTLINE(performance-unnecessary-value-param) - technically correct but we are moving the given values
+void ProgramMemory::replace(ProgramMemory pm, bool skipUnknown)
+{
+    if (pm.empty())
+        return;
+
+    copyOnWrite();
+
+    for (auto&& p : (*pm.mValues)) {
+        if (skipUnknown) {
+            auto it = mValues->find(p.first);
+            if (it != mValues->end() && it->second.isUninitValue())
+                continue;
+        }
+        (*mValues)[p.first] = std::move(p.second);
+    }
+}
+
+void ProgramMemory::copyOnWrite()
+{
+    if (mValues.use_count() == 1)
+        return;
+
+    mValues = std::make_shared<Map>(*mValues);
+}
+
+ProgramMemory::Map::const_iterator ProgramMemory::find(nonneg int exprid) const
+{
+    const auto& cvalues = utils::as_const(*mValues);
+    return cvalues.find(ExprIdToken::create(exprid));
+}
+
+ProgramMemory::Map::iterator ProgramMemory::find(nonneg int exprid)
+{
+    return mValues->find(ExprIdToken::create(exprid));
+}
+
+static ValueFlow::Value execute(const Token* expr, ProgramMemory& pm, const Settings& settings);
+
+static bool evaluateCondition(MathLib::bigint r, const Token* condition, ProgramMemory& pm, const Settings& settings)
+{
+    if (!condition)
+        return false;
+    MathLib::bigint result = 0;
+    bool error = false;
+    execute(condition, pm, &result, &error, settings);
+    return !error && result == r;
+}
+
+bool conditionIsFalse(const Token* condition, ProgramMemory pm, const Settings& settings)
+{
+    return evaluateCondition(0, condition, pm, settings);
+}
+
+bool conditionIsTrue(const Token* condition, ProgramMemory pm, const Settings& settings)
+{
+    return evaluateCondition(1, condition, pm, settings);
+}
+
+static bool frontIs(const std::vector<MathLib::bigint>& v, bool i)
+{
+    if (v.empty())
+        return false;
+    if (v.front())
+        return i;
+    return !i;
+}
+
+static bool isTrue(const ValueFlow::Value& v)
+{
+    if (v.isUninitValue())
+        return false;
+    if (v.isImpossible())
+        return v.intvalue == 0;
+    return v.intvalue != 0;
+}
+
+static bool isFalse(const ValueFlow::Value& v)
+{
+    if (v.isUninitValue())
+        return false;
+    if (v.isImpossible())
+        return false;
+    return v.intvalue == 0;
+}
+
+static bool isTrueOrFalse(const ValueFlow::Value& v, bool b)
+{
+    if (b)
+        return isTrue(v);
+    return isFalse(v);
+}
+
+// If the scope is a non-range for loop
+static bool isBasicForLoop(const Token* tok)
+{
+    if (!tok)
+        return false;
+    if (Token::simpleMatch(tok, "}"))
+        return isBasicForLoop(tok->link());
+    if (!Token::simpleMatch(tok->previous(), ") {"))
+        return false;
+    const Token* start = tok->linkAt(-1);
+    if (!start)
+        return false;
+    if (!Token::simpleMatch(start->previous(), "for ("))
+        return false;
+    if (!Token::simpleMatch(start->astOperand2(), ";"))
+        return false;
+    return true;
+}
+
+static void programMemoryParseCondition(ProgramMemory& pm, const Token* tok, const Token* endTok, const Settings& settings, bool then)
+{
+    auto eval = [&](const Token* t) -> std::vector<MathLib::bigint> {
+        if (!t)
+            return std::vector<MathLib::bigint>{};
+        if (const ValueFlow::Value* v = t->getKnownValue(ValueFlow::Value::ValueType::INT))
+            return {v->intvalue};
+        MathLib::bigint result = 0;
+        bool error = false;
+        execute(t, pm, &result, &error, settings);
+        if (!error)
+            return {result};
+        return std::vector<MathLib::bigint>{};
+    };
+    if (Token::Match(tok, "==|>=|<=|<|>|!=")) {
+        ValueFlow::Value truevalue;
+        ValueFlow::Value falsevalue;
+        const Token* vartok = parseCompareInt(tok, truevalue, falsevalue, eval);
+        if (!vartok)
+            return;
+        if (vartok->exprId() == 0)
+            return;
+        if (!truevalue.isIntValue())
+            return;
+        if (endTok && findExpressionChanged(vartok, tok->next(), endTok, settings))
+            return;
+        const bool impossible = (tok->str() == "==" && !then) || (tok->str() == "!=" && then);
+        const ValueFlow::Value& v = then ? truevalue : falsevalue;
+        pm.setValue(vartok, impossible ? asImpossible(v) : v);
+        const Token* containerTok = settings.library.getContainerFromYield(vartok, Library::Container::Yield::SIZE);
+        if (containerTok)
+            pm.setContainerSizeValue(containerTok, v.intvalue, !impossible);
+    } else if (Token::simpleMatch(tok, "!")) {
+        programMemoryParseCondition(pm, tok->astOperand1(), endTok, settings, !then);
+    } else if (then && Token::simpleMatch(tok, "&&")) {
+        programMemoryParseCondition(pm, tok->astOperand1(), endTok, settings, then);
+        programMemoryParseCondition(pm, tok->astOperand2(), endTok, settings, then);
+    } else if (!then && Token::simpleMatch(tok, "||")) {
+        programMemoryParseCondition(pm, tok->astOperand1(), endTok, settings, then);
+        programMemoryParseCondition(pm, tok->astOperand2(), endTok, settings, then);
+    } else if (Token::Match(tok, "&&|%oror%")) {
+        std::vector<MathLib::bigint> lhs = eval(tok->astOperand1());
+        std::vector<MathLib::bigint> rhs = eval(tok->astOperand2());
+        if (lhs.empty() || rhs.empty()) {
+            if (frontIs(lhs, !then))
+                programMemoryParseCondition(pm, tok->astOperand2(), endTok, settings, then);
+            else if (frontIs(rhs, !then))
+                programMemoryParseCondition(pm, tok->astOperand1(), endTok, settings, then);
+            else
+                pm.setIntValue(tok, 0, then);
+        }
+    } else if (tok && tok->exprId() > 0) {
+        if (endTok && findExpressionChanged(tok, tok->next(), endTok, settings))
+            return;
+        pm.setIntValue(tok, 0, then);
+        const Token* containerTok = settings.library.getContainerFromYield(tok, Library::Container::Yield::EMPTY);
+        if (containerTok)
+            pm.setContainerSizeValue(containerTok, 0, then);
+    }
+}
+
+static void fillProgramMemoryFromConditions(ProgramMemory& pm, const Scope* scope, const Token* endTok, const Settings& settings)
+{
+    if (!scope)
+        return;
+    if (!scope->isLocal())
+        return;
+    assert(scope != scope->nestedIn);
+    fillProgramMemoryFromConditions(pm, scope->nestedIn, endTok, settings);
+    if (scope->type == ScopeType::eIf || scope->type == ScopeType::eWhile || scope->type == ScopeType::eElse || scope->type == ScopeType::eFor) {
+        const Token* condTok = getCondTokFromEnd(scope->bodyEnd);
+        if (!condTok)
+            return;
+        MathLib::bigint result = 0;
+        bool error = false;
+        execute(condTok, pm, &result, &error, settings);
+        if (error)
+            programMemoryParseCondition(pm, condTok, endTok, settings, scope->type != ScopeType::eElse);
+    }
+}
+
+static void fillProgramMemoryFromConditions(ProgramMemory& pm, const Token* tok, const Settings& settings)
+{
+    fillProgramMemoryFromConditions(pm, tok->scope(), tok, settings);
+}
+
+static void fillProgramMemoryFromAssignments(ProgramMemory& pm, const Token* tok, const Settings& settings, const ProgramMemory& state, const ProgramMemory::Map& vars)
+{
+    int indentlevel = 0;
+    for (const Token *tok2 = tok; tok2; tok2 = tok2->previous()) {
+        if ((Token::simpleMatch(tok2, "=") || Token::Match(tok2->previous(), "%var% (|{")) && tok2->astOperand1() &&
+            tok2->astOperand2()) {
+            bool setvar = false;
+            const Token* vartok = tok2->astOperand1();
+            for (const auto& p:vars) {
+                if (p.first.getExpressionId() != vartok->exprId())
+                    continue;
+                if (vartok == tok)
+                    continue;
+                pm.setValue(vartok, p.second);
+                setvar = true;
+            }
+            if (!setvar) {
+                if (!pm.hasValue(vartok->exprId())) {
+                    const Token* valuetok = tok2->astOperand2();
+                    ProgramMemory local = state;
+                    pm.setValue(vartok, execute(valuetok, local, settings));
+                }
+            }
+        } else if (Token::simpleMatch(tok2, ")") && tok2->link() &&
+                   Token::Match(tok2->link()->previous(), "assert|ASSERT ( !!)")) {
+            const Token* cond = tok2->link()->astOperand2();
+            if (!conditionIsTrue(cond, state, settings)) {
+                // TODO: change to assert when we can propagate the assert, for now just bail
+                if (conditionIsFalse(cond, state, settings))
+                    return;
+                programMemoryParseCondition(pm, cond, nullptr, settings, true);
+            }
+            tok2 = tok2->link()->previous();
+        } else if (tok2->exprId() > 0 && Token::Match(tok2, ".|(|[|*|%var%") && !pm.hasValue(tok2->exprId()) &&
+                   isVariableChanged(tok2, 0, settings)) {
+            pm.setUnknown(tok2);
+        }
+
+        if (tok2->str() == "{") {
+            if (indentlevel <= 0) {
+                const Token* cond = getCondTokFromEnd(tok2->link());
+                // Keep progressing with anonymous/do scopes and always true branches
+                if (!Token::Match(tok2->previous(), "do|; {") && !conditionIsTrue(cond, state, settings) &&
+                    (cond || !isBasicForLoop(tok2)))
+                    break;
+            } else
+                --indentlevel;
+            if (Token::simpleMatch(tok2->previous(), "else {"))
+                tok2 = tok2->linkAt(-2)->previous();
+        }
+        if (tok2->str() == "}" && !Token::Match(tok2->link()->previous(), "%var% {")) {
+            const Token *cond = getCondTokFromEnd(tok2);
+            const bool inElse = Token::simpleMatch(tok2->link()->previous(), "else {");
+            if (cond) {
+                if (conditionIsFalse(cond, state, settings)) {
+                    if (inElse) {
+                        ++indentlevel;
+                        continue;
+                    }
+                } else if (conditionIsTrue(cond, state, settings)) {
+                    if (inElse)
+                        tok2 = tok2->link()->tokAt(-2);
+                    ++indentlevel;
+                    continue;
+                }
+            }
+            break;
+        }
+    }
+}
+
+static void removeModifiedVars(ProgramMemory& pm, const Token* tok, const Token* origin, const Settings& settings)
+{
+    pm.erase_if([&](const ExprIdToken& e) {
+        return isVariableChanged(origin, tok, e.getExpressionId(), false, settings);
+    });
+}
+
+static ProgramMemory getInitialProgramState(const Token* tok,
+                                            const Token* origin,
+                                            const Settings& settings,
+                                            const ProgramMemory::Map& vars = ProgramMemory::Map {})
+{
+    ProgramMemory pm;
+    if (origin) {
+        fillProgramMemoryFromConditions(pm, origin, settings);
+        const ProgramMemory state = pm;
+        fillProgramMemoryFromAssignments(pm, tok, settings, state, vars);
+        removeModifiedVars(pm, tok, origin, settings);
+    }
+    return pm;
+}
+
+ProgramMemoryState::ProgramMemoryState(const Settings& s) : settings(s)
+{}
+
+void ProgramMemoryState::replace(ProgramMemory pm, const Token* origin)
+{
+    if (origin)
+        for (const auto& p : pm)
+            origins[p.first.getExpressionId()] = origin;
+    state.replace(std::move(pm), /*skipUnknown*/ true);
+}
+
+static void addVars(ProgramMemory& pm, const ProgramMemory::Map& vars)
+{
+    for (const auto& p:vars) {
+        const ValueFlow::Value &value = p.second;
+        pm.setValue(p.first.tok, value);
+    }
+}
+
+void ProgramMemoryState::addState(const Token* tok, const ProgramMemory::Map& vars)
+{
+    ProgramMemory local = state;
+    addVars(local, vars);
+    fillProgramMemoryFromConditions(local, tok, settings);
+    ProgramMemory pm;
+    fillProgramMemoryFromAssignments(pm, tok, settings, local, vars);
+    local.replace(std::move(pm));
+    addVars(local, vars);
+    replace(std::move(local), tok);
+}
+
+void ProgramMemoryState::assume(const Token* tok, bool b, bool isEmpty)
+{
+    ProgramMemory pm = state;
+    if (isEmpty)
+        pm.setContainerSizeValue(tok, 0, b);
+    else
+        programMemoryParseCondition(pm, tok, nullptr, settings, b);
+    const Token* origin = tok;
+    const Token* top = tok->astTop();
+    if (Token::Match(top->previous(), "for|while|if (") && !Token::simpleMatch(tok->astParent(), "?")) {
+        origin = top->link()->next();
+        if (!b && origin->link()) {
+            origin = origin->link();
+        }
+    }
+    replace(std::move(pm), origin);
+}
+
+void ProgramMemoryState::removeModifiedVars(const Token* tok)
+{
+    const ProgramMemory& pm = state;
+    auto eval = [&](const Token* cond) -> std::vector<MathLib::bigint> {
+        ProgramMemory pm2 = pm;
+        auto result = execute(cond, pm2, settings);
+        if (isTrue(result))
+            return {1};
+        if (isFalse(result))
+            return {0};
+        return {};
+    };
+    state.erase_if([&](const ExprIdToken& e) {
+        const Token* start = origins[e.getExpressionId()];
+        const Token* expr = e.tok;
+        if (!expr || findExpressionChangedSkipDeadCode(expr, start, tok, settings, eval)) {
+            origins.erase(e.getExpressionId());
+            return true;
+        }
+        return false;
+    });
+}
+
+ProgramMemory ProgramMemoryState::get(const Token* tok, const Token* ctx, const ProgramMemory::Map& vars) const
+{
+    ProgramMemoryState local = *this;
+    if (ctx)
+        local.addState(ctx, vars);
+    const Token* start = previousBeforeAstLeftmostLeaf(tok);
+    if (!start)
+        start = tok;
+
+    if (!ctx || precedes(start, ctx)) {
+        local.removeModifiedVars(start);
+        local.addState(start, vars);
+    } else {
+        local.removeModifiedVars(ctx);
+    }
+    return local.state;
+}
+
+ProgramMemory getProgramMemory(const Token* tok, const Token* expr, const ValueFlow::Value& value, const Settings& settings)
+{
+    ProgramMemory programMemory;
+    programMemory.replace(getInitialProgramState(tok, value.tokvalue, settings));
+    programMemory.replace(getInitialProgramState(tok, value.condition, settings));
+    fillProgramMemoryFromConditions(programMemory, tok, settings);
+    programMemory.setValue(expr, value);
+    const ProgramMemory state = programMemory;
+    fillProgramMemoryFromAssignments(programMemory, tok, settings, state, {{expr, value}});
+    return programMemory;
+}
+
+static bool isNumericValue(const ValueFlow::Value& value) {
+    return value.isIntValue() || value.isFloatValue();
+}
+
+static double asFloat(const ValueFlow::Value& value)
+{
+    return value.isFloatValue() ? value.floatValue : static_cast<double>(value.intvalue);
+}
+
+static MathLib::bigint asInt(const ValueFlow::Value& value)
+{
+    return value.isFloatValue() ? static_cast<MathLib::bigint>(value.floatValue) : value.intvalue;
+}
+
+static std::string removeAssign(const std::string& assign) {
+    return std::string{assign.cbegin(), assign.cend() - 1};
+}
+
+namespace {
+    struct assign {
+        template<class T, class U>
+        void operator()(T& x, const U& y) const
+        {
+            x = static_cast<T>(y);
+        }
+    };
+}
+
+static bool isIntegralValue(const ValueFlow::Value& value)
+{
+    return value.isIntValue() || value.isIteratorValue() || value.isSymbolicValue();
+}
+
+static ValueFlow::Value evaluate(const std::string& op, const ValueFlow::Value& lhs, const ValueFlow::Value& rhs)
+{
+    ValueFlow::Value result;
+    if (lhs.isImpossible() && rhs.isImpossible())
+        return ValueFlow::Value::unknown();
+    if (lhs.isImpossible() || rhs.isImpossible()) {
+        // noninvertible
+        if (contains({"%", "/", "&", "|"}, op))
+            return ValueFlow::Value::unknown();
+        result.setImpossible();
+    }
+    if (isNumericValue(lhs) && isNumericValue(rhs)) {
+        if (lhs.isFloatValue() || rhs.isFloatValue()) {
+            result.valueType = ValueFlow::Value::ValueType::FLOAT;
+            bool error = false;
+            result.floatValue = calculate(op, asFloat(lhs), asFloat(rhs), &error);
+            if (error)
+                return ValueFlow::Value::unknown();
+            return result;
+        }
+    }
+    // Must be integral types
+    if (!isIntegralValue(lhs) && !isIntegralValue(rhs))
+        return ValueFlow::Value::unknown();
+    // If not the same type then one must be int
+    if (lhs.valueType != rhs.valueType && !lhs.isIntValue() && !rhs.isIntValue())
+        return ValueFlow::Value::unknown();
+    const bool compareOp = contains({"==", "!=", "<", ">", ">=", "<="}, op);
+    // Comparison must be the same type
+    if (compareOp && lhs.valueType != rhs.valueType)
+        return ValueFlow::Value::unknown();
+    // Only add, subtract, and compare for non-integers
+    if (!compareOp && !contains({"+", "-"}, op) && !lhs.isIntValue() && !rhs.isIntValue())
+        return ValueFlow::Value::unknown();
+    // Both can't be iterators for non-compare
+    if (!compareOp && lhs.isIteratorValue() && rhs.isIteratorValue())
+        return ValueFlow::Value::unknown();
+    // Symbolic values must be in the same ring
+    if (lhs.isSymbolicValue() && rhs.isSymbolicValue() && lhs.tokvalue != rhs.tokvalue)
+        return ValueFlow::Value::unknown();
+    if (!lhs.isIntValue() && !compareOp) {
+        result.valueType = lhs.valueType;
+        result.tokvalue = lhs.tokvalue;
+    } else if (!rhs.isIntValue() && !compareOp) {
+        result.valueType = rhs.valueType;
+        result.tokvalue = rhs.tokvalue;
+    } else {
+        result.valueType = ValueFlow::Value::ValueType::INT;
+    }
+    bool error = false;
+    result.intvalue = calculate(op, lhs.intvalue, rhs.intvalue, &error);
+    if (error)
+        return ValueFlow::Value::unknown();
+    if (result.isImpossible() && op == "!=") {
+        if (isTrue(result)) {
+            result.intvalue = 1;
+        } else if (isFalse(result)) {
+            result.intvalue = 0;
+        } else {
+            return ValueFlow::Value::unknown();
+        }
+        result.setPossible();
+        result.bound = ValueFlow::Value::Bound::Point;
+    }
+    return result;
+}
+
+using BuiltinLibraryFunction = std::function<ValueFlow::Value (const std::vector<ValueFlow::Value>&)>;
+static std::unordered_map<std::string, BuiltinLibraryFunction> createBuiltinLibraryFunctions()
+{
+    std::unordered_map<std::string, BuiltinLibraryFunction> functions;
+    functions["strlen"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!(v_ref.isTokValue() && v_ref.tokvalue->tokType() == Token::eString))
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.valueType = ValueFlow::Value::ValueType::INT;
+        v.intvalue = Token::getStrLength(v.tokvalue);
+        v.tokvalue = nullptr;
+        return v;
+    };
+    functions["strcmp"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 2)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& lhs = args[0];
+        if (!(lhs.isTokValue() && lhs.tokvalue->tokType() == Token::eString))
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& rhs = args[1];
+        if (!(rhs.isTokValue() && rhs.tokvalue->tokType() == Token::eString))
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v(getStringLiteral(lhs.tokvalue->str()).compare(getStringLiteral(rhs.tokvalue->str())));
+        ValueFlow::combineValueProperties(lhs, rhs, v);
+        return v;
+    };
+    functions["strncmp"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 3)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& lhs = args[0];
+        if (!(lhs.isTokValue() && lhs.tokvalue->tokType() == Token::eString))
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& rhs = args[1];
+        if (!(rhs.isTokValue() && rhs.tokvalue->tokType() == Token::eString))
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& len = args[2];
+        if (!len.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v(getStringLiteral(lhs.tokvalue->str())
+                           .compare(0, len.intvalue, getStringLiteral(rhs.tokvalue->str()), 0, len.intvalue));
+        ValueFlow::combineValueProperties(lhs, rhs, v);
+        return v;
+    };
+    functions["sin"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::sin(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["lgamma"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::lgamma(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["cos"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::cos(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["tan"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::tan(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["asin"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::asin(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["acos"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::acos(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["atan"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::atan(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["atan2"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 2 || !std::all_of(args.cbegin(), args.cend(), [](const ValueFlow::Value& v) {
+            return v.isFloatValue() || v.isIntValue();
+        }))
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v;
+        combineValueProperties(args[0], args[1], v);
+        v.floatValue = std::atan2(asFloat(args[0]), asFloat(args[1]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["remainder"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 2 || !std::all_of(args.cbegin(), args.cend(), [](const ValueFlow::Value& v) {
+            return v.isFloatValue() || v.isIntValue();
+        }))
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v;
+        combineValueProperties(args[0], args[1], v);
+        v.floatValue = std::remainder(asFloat(args[0]), asFloat(args[1]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["nextafter"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 2 || !std::all_of(args.cbegin(), args.cend(), [](const ValueFlow::Value& v) {
+            return v.isFloatValue() || v.isIntValue();
+        }))
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v;
+        combineValueProperties(args[0], args[1], v);
+        v.floatValue = std::nextafter(asFloat(args[0]), asFloat(args[1]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["nexttoward"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 2 || !std::all_of(args.cbegin(), args.cend(), [](const ValueFlow::Value& v) {
+            return v.isFloatValue() || v.isIntValue();
+        }))
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v;
+        combineValueProperties(args[0], args[1], v);
+        v.floatValue = std::nexttoward(asFloat(args[0]), asFloat(args[1]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["hypot"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 2 || !std::all_of(args.cbegin(), args.cend(), [](const ValueFlow::Value& v) {
+            return v.isFloatValue() || v.isIntValue();
+        }))
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v;
+        combineValueProperties(args[0], args[1], v);
+        v.floatValue = std::hypot(asFloat(args[0]), asFloat(args[1]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["fdim"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 2 || !std::all_of(args.cbegin(), args.cend(), [](const ValueFlow::Value& v) {
+            return v.isFloatValue() || v.isIntValue();
+        }))
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v;
+        combineValueProperties(args[0], args[1], v);
+        v.floatValue = std::fdim(asFloat(args[0]), asFloat(args[1]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["fmax"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 2 || !std::all_of(args.cbegin(), args.cend(), [](const ValueFlow::Value& v) {
+            return v.isFloatValue() || v.isIntValue();
+        }))
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v;
+        combineValueProperties(args[0], args[1], v);
+        v.floatValue = std::fmax(asFloat(args[0]), asFloat(args[1]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["fmin"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 2 || !std::all_of(args.cbegin(), args.cend(), [](const ValueFlow::Value& v) {
+            return v.isFloatValue() || v.isIntValue();
+        }))
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v;
+        combineValueProperties(args[0], args[1], v);
+        v.floatValue = std::fmin(asFloat(args[0]), asFloat(args[1]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["fmod"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 2 || !std::all_of(args.cbegin(), args.cend(), [](const ValueFlow::Value& v) {
+            return v.isFloatValue() || v.isIntValue();
+        }))
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v;
+        combineValueProperties(args[0], args[1], v);
+        v.floatValue = std::fmod(asFloat(args[0]), asFloat(args[1]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["pow"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 2 || !std::all_of(args.cbegin(), args.cend(), [](const ValueFlow::Value& v) {
+            return v.isFloatValue() || v.isIntValue();
+        }))
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v;
+        combineValueProperties(args[0], args[1], v);
+        v.floatValue = std::pow(asFloat(args[0]), asFloat(args[1]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["scalbln"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 2 || !std::all_of(args.cbegin(), args.cend(), [](const ValueFlow::Value& v) {
+            return v.isFloatValue() || v.isIntValue();
+        }))
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v;
+        combineValueProperties(args[0], args[1], v);
+        v.floatValue = std::scalbln(asFloat(args[0]), asInt(args[1]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["ldexp"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 2 || !std::all_of(args.cbegin(), args.cend(), [](const ValueFlow::Value& v) {
+            return v.isFloatValue() || v.isIntValue();
+        }))
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v;
+        combineValueProperties(args[0], args[1], v);
+        v.floatValue = std::ldexp(asFloat(args[0]), asInt(args[1]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["ilogb"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.intvalue = std::ilogb(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::INT;
+        return v;
+    };
+    functions["erf"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::erf(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["erfc"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::erfc(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["floor"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::floor(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["sqrt"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::sqrt(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["cbrt"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::cbrt(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["ceil"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::ceil(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["exp"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::exp(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["exp2"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::exp2(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["expm1"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::expm1(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["fabs"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::fabs(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["log"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::log(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["log10"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::log10(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["log1p"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::log1p(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["log2"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::log2(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["logb"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::logb(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["nearbyint"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::nearbyint(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["sinh"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::sinh(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["cosh"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::cosh(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["tanh"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::tanh(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["asinh"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::asinh(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["acosh"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::acosh(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["atanh"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::atanh(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["round"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::round(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["tgamma"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::tgamma(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    functions["trunc"] = [](const std::vector<ValueFlow::Value>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        const ValueFlow::Value& v_ref = args[0];
+        if (!v_ref.isFloatValue() && !v_ref.isIntValue())
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value v = v_ref;
+        v.floatValue = std::trunc(asFloat(args[0]));
+        v.valueType = ValueFlow::Value::ValueType::FLOAT;
+        return v;
+    };
+    return functions;
+}
+
+static BuiltinLibraryFunction getBuiltinLibraryFunction(const std::string& name)
+{
+    static const std::unordered_map<std::string, BuiltinLibraryFunction> functions = createBuiltinLibraryFunctions();
+    auto it = functions.find(name);
+    if (it == functions.end())
+        return nullptr;
+    return it->second;
+}
+static bool TokenExprIdCompare(const Token* tok1, const Token* tok2) {
+    return tok1->exprId() < tok2->exprId();
+}
+static bool TokenExprIdEqual(const Token* tok1, const Token* tok2) {
+    return tok1->exprId() == tok2->exprId();
+}
+
+static std::vector<const Token*> setDifference(const std::vector<const Token*>& v1, const std::vector<const Token*>& v2)
+{
+    std::vector<const Token*> result;
+    std::set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), std::back_inserter(result), &TokenExprIdCompare);
+    return result;
+}
+
+static bool evalSameCondition(const ProgramMemory& state,
+                              const Token* storedValue,
+                              const Token* cond,
+                              const Settings& settings)
+{
+    assert(!conditionIsTrue(cond, state, settings));
+    ProgramMemory pm = state;
+    programMemoryParseCondition(pm, storedValue, nullptr, settings, true);
+    if (pm == state)
+        return false;
+    return conditionIsTrue(cond, std::move(pm), settings);
+}
+
+static void pruneConditions(std::vector<const Token*>& conds,
+                            bool b,
+                            const std::unordered_map<nonneg int, ValueFlow::Value>& state)
+{
+    conds.erase(std::remove_if(conds.begin(),
+                               conds.end(),
+                               [&](const Token* cond) {
+        if (cond->exprId() == 0)
+            return false;
+        auto it = state.find(cond->exprId());
+        if (it == state.end())
+            return false;
+        const ValueFlow::Value& v = it->second;
+        return isTrueOrFalse(v, !b);
+    }),
+                conds.end());
+}
+
+namespace {
+    struct Executor {
+        ProgramMemory* pm;
+        const Settings& settings;
+        int fdepth = 4;
+        int depth = 10;
+
+        Executor(ProgramMemory* pm, const Settings& settings) : pm(pm), settings(settings)
+        {
+            assert(pm != nullptr);
+        }
+
+        static ValueFlow::Value unknown() {
+            return ValueFlow::Value::unknown();
+        }
+
+        std::unordered_map<nonneg int, ValueFlow::Value> executeAll(const std::vector<const Token*>& toks,
+                                                                    const bool* b = nullptr) const
+        {
+            std::unordered_map<nonneg int, ValueFlow::Value> result;
+            auto state = *this;
+            for (const Token* tok : toks) {
+                ValueFlow::Value r = state.execute(tok);
+                if (r.isUninitValue())
+                    continue;
+                const bool brk = b && isTrueOrFalse(r, *b);
+                result.emplace(tok->exprId(), std::move(r));
+                // Short-circuit evaluation
+                if (brk)
+                    break;
+            }
+            return result;
+        }
+
+        static std::vector<const Token*> flattenConditions(const Token* tok)
+        {
+            return astFlatten(tok, tok->str().c_str());
+        }
+        static bool sortConditions(std::vector<const Token*>& conditions)
+        {
+            if (std::any_of(conditions.begin(), conditions.end(), [](const Token* child) {
+                return Token::Match(child, "&&|%oror%");
+            }))
+                return false;
+            std::sort(conditions.begin(), conditions.end(), &TokenExprIdCompare);
+            conditions.erase(std::unique(conditions.begin(), conditions.end(), &TokenExprIdCompare), conditions.end());
+            return !conditions.empty() && conditions.front()->exprId() != 0;
+        }
+
+        ValueFlow::Value executeMultiCondition(bool b, const Token* expr)
+        {
+            if (pm->hasValue(expr->exprId())) {
+                const ValueFlow::Value& v = utils::as_const(*pm).at(expr->exprId());
+                if (v.isIntValue())
+                    return v;
+            }
+
+            // Evaluate recursively if there are no exprids
+            if ((expr->astOperand1() && expr->astOperand1()->exprId() == 0) ||
+                (expr->astOperand2() && expr->astOperand2()->exprId() == 0)) {
+                ValueFlow::Value lhs = execute(expr->astOperand1());
+                if (isTrueOrFalse(lhs, b))
+                    return lhs;
+                ValueFlow::Value rhs = execute(expr->astOperand2());
+                if (isTrueOrFalse(rhs, b))
+                    return rhs;
+                if (isTrueOrFalse(lhs, !b) && isTrueOrFalse(rhs, !b))
+                    return lhs;
+                return unknown();
+            }
+
+            nonneg int n = astCount(expr, expr->str().c_str());
+            if (n > 50)
+                return unknown();
+            std::vector<const Token*> conditions1 = flattenConditions(expr);
+            if (conditions1.empty())
+                return unknown();
+            std::unordered_map<nonneg int, ValueFlow::Value> condValues = executeAll(conditions1, &b);
+            bool allNegated = true;
+            ValueFlow::Value negatedValue = unknown();
+            for (const auto& p : condValues) {
+                const ValueFlow::Value& v = p.second;
+                if (isTrueOrFalse(v, b))
+                    return v;
+                allNegated &= isTrueOrFalse(v, !b);
+                if (allNegated && negatedValue.isUninitValue())
+                    negatedValue = v;
+            }
+            if (condValues.size() == conditions1.size() && allNegated)
+                return negatedValue;
+            if (n > 4)
+                return unknown();
+            if (!sortConditions(conditions1))
+                return unknown();
+
+            for (const auto& p : *pm) {
+                const Token* tok = p.first.tok;
+                if (!tok)
+                    continue;
+                const ValueFlow::Value& value = p.second;
+
+                if (tok->str() == expr->str() && !astHasExpr(tok, expr->exprId())) {
+                    // TODO: Handle when it is greater
+                    if (n != astCount(tok, expr->str().c_str()))
+                        continue;
+                    std::vector<const Token*> conditions2 = flattenConditions(tok);
+                    if (!sortConditions(conditions2))
+                        return unknown();
+                    if (conditions1.size() == conditions2.size() &&
+                        std::equal(conditions1.begin(), conditions1.end(), conditions2.begin(), &TokenExprIdEqual))
+                        return value;
+                    std::vector<const Token*> diffConditions1 = setDifference(conditions1, conditions2);
+                    pruneConditions(diffConditions1, !b, condValues);
+                    if (diffConditions1.size() == conditions1.size())
+                        continue;
+                    std::vector<const Token*> diffConditions2 = setDifference(conditions2, conditions1);
+                    pruneConditions(diffConditions2, !b, executeAll(diffConditions2));
+                    if (diffConditions1.size() != diffConditions2.size())
+                        continue;
+                    for (const Token* cond1 : diffConditions1) {
+                        auto it = std::find_if(diffConditions2.begin(), diffConditions2.end(), [&](const Token* cond2) {
+                            return evalSameCondition(*pm, cond2, cond1, settings);
+                        });
+                        if (it == diffConditions2.end())
+                            break;
+                        diffConditions2.erase(it);
+                    }
+                    if (diffConditions2.empty())
+                        return value;
+                }
+            }
+            return unknown();
+        }
+
+        ValueFlow::Value executeImpl(const Token* expr)
+        {
+            const ValueFlow::Value* value = nullptr;
+            if (!expr)
+                return unknown();
+            if (expr->hasKnownIntValue() && !expr->isAssignmentOp() && expr->str() != ",")
+                return *expr->getKnownValue(ValueFlow::Value::ValueType::INT);
+            if ((value = expr->getKnownValue(ValueFlow::Value::ValueType::FLOAT)) ||
+                (value = expr->getKnownValue(ValueFlow::Value::ValueType::TOK)) ||
+                (value = expr->getKnownValue(ValueFlow::Value::ValueType::ITERATOR_START)) ||
+                (value = expr->getKnownValue(ValueFlow::Value::ValueType::ITERATOR_END)) ||
+                (value = expr->getKnownValue(ValueFlow::Value::ValueType::CONTAINER_SIZE))) {
+                return *value;
+            }
+            if (expr->isNumber()) {
+                if (MathLib::isFloat(expr->str()))
+                    return unknown();
+                MathLib::bigint i = MathLib::toBigNumber(expr);
+                if (i < 0 && astIsUnsigned(expr))
+                    return unknown();
+                return ValueFlow::Value{i};
+            }
+            if (expr->isBoolean())
+                return ValueFlow::Value{expr->str() == "true"};
+            if (Token::Match(expr->tokAt(-2), ". %name% (") && astIsContainer(expr->tokAt(-2)->astOperand1())) {
+                const Token* containerTok = expr->tokAt(-2)->astOperand1();
+                const Library::Container::Yield yield = containerTok->valueType()->container->getYield(expr->strAt(-1));
+                if (yield == Library::Container::Yield::SIZE) {
+                    ValueFlow::Value v = execute(containerTok);
+                    if (!v.isContainerSizeValue())
+                        return unknown();
+                    v.valueType = ValueFlow::Value::ValueType::INT;
+                    return v;
+                }
+                if (yield == Library::Container::Yield::EMPTY) {
+                    ValueFlow::Value v = execute(containerTok);
+                    if (!v.isContainerSizeValue())
+                        return unknown();
+                    if (v.isImpossible() && v.intvalue == 0)
+                        return ValueFlow::Value{0};
+                    if (!v.isImpossible())
+                        return ValueFlow::Value{v.intvalue == 0};
+                }
+            } else if (expr->isAssignmentOp() && expr->astOperand1() && expr->astOperand2() &&
+                       expr->astOperand1()->exprId() > 0) {
+                ValueFlow::Value rhs = execute(expr->astOperand2());
+                if (rhs.isUninitValue())
+                    return unknown();
+                if (expr->str() != "=") {
+                    if (!pm->hasValue(expr->astOperand1()->exprId()))
+                        return unknown();
+                    ValueFlow::Value& lhs = pm->at(expr->astOperand1()->exprId());
+                    rhs = evaluate(removeAssign(expr->str()), lhs, rhs);
+                    if (lhs.isIntValue())
+                        ValueFlow::Value::visitValue(rhs, std::bind(assign{}, std::ref(lhs.intvalue), std::placeholders::_1));
+                    else if (lhs.isFloatValue())
+                        ValueFlow::Value::visitValue(rhs,
+                                                     std::bind(assign{}, std::ref(lhs.floatValue), std::placeholders::_1));
+                    else
+                        return unknown();
+                    return lhs;
+                }
+                pm->setValue(expr->astOperand1(), rhs);
+                return rhs;
+            } else if (expr->str() == "&&" && expr->astOperand1() && expr->astOperand2()) {
+                return executeMultiCondition(false, expr);
+            } else if (expr->str() == "||" && expr->astOperand1() && expr->astOperand2()) {
+                return executeMultiCondition(true, expr);
+            } else if (expr->str() == "," && expr->astOperand1() && expr->astOperand2()) {
+                execute(expr->astOperand1());
+                return execute(expr->astOperand2());
+            } else if (expr->tokType() == Token::eIncDecOp && expr->astOperand1() && expr->astOperand1()->exprId() != 0) {
+                if (!pm->hasValue(expr->astOperand1()->exprId()))
+                    return ValueFlow::Value::unknown();
+                ValueFlow::Value& lhs = pm->at(expr->astOperand1()->exprId());
+                if (!lhs.isIntValue())
+                    return unknown();
+                // overflow
+                if (!lhs.isImpossible() && lhs.intvalue == 0 && expr->str() == "--" && astIsUnsigned(expr->astOperand1()))
+                    return unknown();
+
+                if (expr->str() == "++")
+                    lhs.intvalue++;
+                else
+                    lhs.intvalue--;
+                return lhs;
+            } else if (expr->str() == "[" && expr->astOperand1() && expr->astOperand2()) {
+                const Token* tokvalue = nullptr;
+                if (!pm->getTokValue(expr->astOperand1()->exprId(), tokvalue)) {
+                    auto tokvalue_it = std::find_if(expr->astOperand1()->values().cbegin(),
+                                                    expr->astOperand1()->values().cend(),
+                                                    std::mem_fn(&ValueFlow::Value::isTokValue));
+                    if (tokvalue_it == expr->astOperand1()->values().cend() || !tokvalue_it->isKnown()) {
+                        return unknown();
+                    }
+                    tokvalue = tokvalue_it->tokvalue;
+                }
+                if (!tokvalue || !tokvalue->isLiteral()) {
+                    return unknown();
+                }
+                const std::string strValue = tokvalue->strValue();
+                ValueFlow::Value rhs = execute(expr->astOperand2());
+                if (!rhs.isIntValue())
+                    return unknown();
+                const MathLib::bigint index = rhs.intvalue;
+                if (index >= 0 && index < strValue.size())
+                    return ValueFlow::Value{strValue[static_cast<std::size_t>(index)]};
+                if (index == strValue.size())
+                    return ValueFlow::Value{};
+            } else if (Token::Match(expr, "%cop%") && expr->astOperand1() && expr->astOperand2()) {
+                ValueFlow::Value lhs = execute(expr->astOperand1());
+                if (lhs.isUninitValue())
+                    return unknown();
+                ValueFlow::Value rhs = execute(expr->astOperand2());
+                if (rhs.isUninitValue())
+                    return unknown();
+                ValueFlow::Value r = evaluate(expr->str(), lhs, rhs);
+                if (expr->isComparisonOp() && (r.isUninitValue() || r.isImpossible())) {
+                    if (rhs.isIntValue() && !expr->astOperand1()->values().empty()) {
+                        std::vector<ValueFlow::Value> result = infer(makeIntegralInferModel(),
+                                                                     expr->str(),
+                                                                     expr->astOperand1()->values(),
+                                                                     {std::move(rhs)});
+                        if (!result.empty() && result.front().isKnown())
+                            return std::move(result.front());
+                    }
+                    if (lhs.isIntValue() && !expr->astOperand2()->values().empty()) {
+                        std::vector<ValueFlow::Value> result = infer(makeIntegralInferModel(),
+                                                                     expr->str(),
+                                                                     {std::move(lhs)},
+                                                                     expr->astOperand2()->values());
+                        if (!result.empty() && result.front().isKnown())
+                            return std::move(result.front());
+                    }
+                    return unknown();
+                }
+                return r;
+            }
+            // Unary ops
+            else if (Token::Match(expr, "!|+|-") && expr->astOperand1() && !expr->astOperand2()) {
+                ValueFlow::Value lhs = execute(expr->astOperand1());
+                if (!lhs.isIntValue())
+                    return unknown();
+                if (expr->str() == "!") {
+                    if (isTrue(lhs)) {
+                        lhs.intvalue = 0;
+                    } else if (isFalse(lhs)) {
+                        lhs.intvalue = 1;
+                    } else {
+                        return unknown();
+                    }
+                    lhs.setPossible();
+                    lhs.bound = ValueFlow::Value::Bound::Point;
+                }
+                if (expr->str() == "-")
+                    lhs.intvalue = -lhs.intvalue;
+                return lhs;
+            } else if (expr->str() == "?" && expr->astOperand1() && expr->astOperand2()) {
+                ValueFlow::Value cond = execute(expr->astOperand1());
+                if (!cond.isIntValue())
+                    return unknown();
+                const Token* child = expr->astOperand2();
+                if (isFalse(cond))
+                    return execute(child->astOperand2());
+                if (isTrue(cond))
+                    return execute(child->astOperand1());
+
+                return unknown();
+            } else if (expr->str() == "(" && expr->isCast()) {
+                if (expr->astOperand2()) {
+                    if (expr->astOperand1()->str() != "dynamic_cast")
+                        return execute(expr->astOperand2());
+                    return unknown();
+                }
+                return execute(expr->astOperand1());
+            }
+            if (expr->exprId() > 0 && pm->hasValue(expr->exprId())) {
+                ValueFlow::Value result = utils::as_const(*pm).at(expr->exprId());
+                if (result.isImpossible() && result.isIntValue() && result.intvalue == 0 && isUsedAsBool(expr, settings)) {
+                    result.intvalue = !result.intvalue;
+                    result.setKnown();
+                }
+                return result;
+            }
+
+            if (Token::Match(expr->previous(), ">|%name% {|(")) {
+                const Token* ftok = expr->previous();
+                const Function* f = ftok->function();
+                ValueFlow::Value result = unknown();
+                if (expr->str() == "(") {
+                    std::vector<const Token*> tokArgs = getArguments(expr);
+                    std::vector<ValueFlow::Value> args(tokArgs.size());
+                    std::transform(
+                        tokArgs.cbegin(), tokArgs.cend(), args.begin(), [&](const Token* tok) {
+                        return execute(tok);
+                    });
+                    if (f) {
+                        if (fdepth >= 0 && !f->isImplicitlyVirtual()) {
+                            ProgramMemory functionState;
+                            for (std::size_t i = 0; i < args.size(); ++i) {
+                                const Variable* const arg = f->getArgumentVar(i);
+                                if (!arg)
+                                    return unknown();
+                                functionState.setValue(arg->nameToken(), args[i]);
+                            }
+                            Executor ex = *this;
+                            ex.pm = &functionState;
+                            ex.fdepth--;
+                            auto r = ex.execute(f->functionScope);
+                            if (!r.empty())
+                                result = std::move(r.front());
+                            // TODO: Track values changed by reference
+                        }
+                    } else {
+                        BuiltinLibraryFunction lf = getBuiltinLibraryFunction(ftok->str());
+                        if (lf)
+                            return lf(args);
+                        const std::string& returnValue = settings.library.returnValue(ftok);
+                        if (!returnValue.empty()) {
+                            std::unordered_map<nonneg int, ValueFlow::Value> arg_map;
+                            int argn = 0;
+                            for (const ValueFlow::Value& v : args) {
+                                if (!v.isUninitValue())
+                                    arg_map[argn] = v;
+                                argn++;
+                            }
+                            return evaluateLibraryFunction(arg_map, returnValue, settings, ftok->isCpp());
+                        }
+                    }
+                }
+                // Check if function modifies argument
+                visitAstNodes(expr->astOperand2(), [&](const Token* child) {
+                    if (child->exprId() > 0 && pm->hasValue(child->exprId())) {
+                        ValueFlow::Value& v = pm->at(child->exprId());
+                        if (v.valueType == ValueFlow::Value::ValueType::CONTAINER_SIZE) {
+                            if (ValueFlow::isContainerSizeChanged(child, v.indirect, settings))
+                                v = unknown();
+                        } else if (v.valueType != ValueFlow::Value::ValueType::UNINIT) {
+                            if (isVariableChanged(child, v.indirect, settings))
+                                v = unknown();
+                        }
+                    }
+                    return ChildrenToVisit::op1_and_op2;
+                });
+                return result;
+            }
+
+            return unknown();
+        }
+        static const ValueFlow::Value* getImpossibleValue(const Token* tok)
+        {
+            if (!tok)
+                return nullptr;
+            std::vector<const ValueFlow::Value*> values;
+            for (const ValueFlow::Value& v : tok->values()) {
+                if (!v.isImpossible())
+                    continue;
+                if (v.isContainerSizeValue() || v.isIntValue()) {
+                    values.push_back(std::addressof(v));
+                }
+            }
+            auto it =
+                std::max_element(values.begin(), values.end(), [](const ValueFlow::Value* x, const ValueFlow::Value* y) {
+                return x->intvalue < y->intvalue;
+            });
+            if (it == values.end())
+                return nullptr;
+            return *it;
+        }
+
+        static bool updateValue(ValueFlow::Value& v, ValueFlow::Value x)
+        {
+            const bool returnValue = !x.isUninitValue() && !x.isImpossible();
+            if (v.isUninitValue() || returnValue)
+                v = std::move(x);
+            return returnValue;
+        }
+
+        ValueFlow::Value execute(const Token* expr)
+        {
+            depth--;
+            OnExit onExit{[&] {
+                    depth++;
+                }};
+            if (depth < 0)
+                return unknown();
+            ValueFlow::Value v = unknown();
+            if (updateValue(v, executeImpl(expr)))
+                return v;
+            if (!expr)
+                return v;
+            if (expr->exprId() > 0 && pm->hasValue(expr->exprId())) {
+                if (updateValue(v, utils::as_const(*pm).at(expr->exprId())))
+                    return v;
+            }
+            // Find symbolic values
+            for (const ValueFlow::Value& value : expr->values()) {
+                if (!value.isSymbolicValue())
+                    continue;
+                if (!value.isKnown())
+                    continue;
+                if (value.tokvalue->exprId() > 0 && !pm->hasValue(value.tokvalue->exprId()))
+                    continue;
+                const ValueFlow::Value& v_ref = utils::as_const(*pm).at(value.tokvalue->exprId());
+                if (!v_ref.isIntValue() && value.intvalue != 0)
+                    continue;
+                ValueFlow::Value v2 = v_ref;
+                v2.intvalue += value.intvalue;
+                return v2;
+            }
+            if (v.isImpossible() && v.isIntValue())
+                return v;
+            if (const ValueFlow::Value* value = getImpossibleValue(expr))
+                return *value;
+            return v;
+        }
+
+        std::vector<ValueFlow::Value> execute(const Scope* scope)
+        {
+            if (!scope)
+                return {unknown()};
+            if (!scope->bodyStart)
+                return {unknown()};
+            for (const Token* tok = scope->bodyStart->next(); precedes(tok, scope->bodyEnd); tok = tok->next()) {
+                const Token* top = tok->astTop();
+
+                if (Token::simpleMatch(top, "return") && top->astOperand1())
+                    return {execute(top->astOperand1())};
+
+                if (Token::Match(top, "%op%")) {
+                    if (execute(top).isUninitValue())
+                        return {unknown()};
+                    const Token* next = nextAfterAstRightmostLeaf(top);
+                    if (!next)
+                        return {unknown()};
+                    tok = next;
+                } else if (Token::simpleMatch(top->previous(), "if (")) {
+                    const Token* condTok = top->astOperand2();
+                    ValueFlow::Value v = execute(condTok);
+                    if (!v.isIntValue())
+                        return {unknown()};
+                    const Token* thenStart = top->link()->next();
+                    const Token* next = thenStart->link();
+                    const Token* elseStart = nullptr;
+                    if (Token::simpleMatch(thenStart->link(), "} else {")) {
+                        elseStart = thenStart->link()->tokAt(2);
+                        next = elseStart->link();
+                    }
+                    std::vector<ValueFlow::Value> result;
+                    if (isTrue(v)) {
+                        result = execute(thenStart->scope());
+                    } else if (isFalse(v)) {
+                        if (elseStart)
+                            result = execute(elseStart->scope());
+                    } else {
+                        return {unknown()};
+                    }
+                    if (!result.empty())
+                        return result;
+                    tok = next;
+                } else {
+                    return {unknown()};
+                }
+            }
+            return {};
+        }
+    };
+}     // namespace
+
+static ValueFlow::Value execute(const Token* expr, ProgramMemory& pm, const Settings& settings)
+{
+    Executor ex{&pm, settings};
+    return ex.execute(expr);
+}
+
+std::vector<ValueFlow::Value> execute(const Scope* scope, ProgramMemory& pm, const Settings& settings)
+{
+    Executor ex{&pm, settings};
+    return ex.execute(scope);
+}
+
+static std::shared_ptr<Token> createTokenFromExpression(const std::string& returnValue,
+                                                        const Settings& settings,
+                                                        bool cpp,
+                                                        std::unordered_map<nonneg int, const Token*>& lookupVarId)
+{
+    std::shared_ptr<TokenList> tokenList = std::make_shared<TokenList>(settings, cpp ? Standards::Language::CPP : Standards::Language::C);
+    {
+        const std::string code = "return " + returnValue + ";";
+        if (!tokenList->createTokensFromBuffer(code.data(), code.size()))
+            return nullptr;
+    }
+
+    // TODO: put in a helper?
+    // combine operators, set links, etc..
+    std::stack<Token*> lpar;
+    for (Token* tok2 = tokenList->front(); tok2; tok2 = tok2->next()) {
+        if (Token::Match(tok2, "[!<>=] =")) {
+            tok2->str(tok2->str() + "=");
+            tok2->deleteNext();
+        } else if (tok2->str() == "(")
+            lpar.push(tok2);
+        else if (tok2->str() == ")") {
+            if (lpar.empty())
+                return nullptr;
+            Token::createMutualLinks(lpar.top(), tok2);
+            lpar.pop();
+        }
+    }
+    if (!lpar.empty())
+        return nullptr;
+
+    // set varids
+    for (Token* tok2 = tokenList->front(); tok2; tok2 = tok2->next()) {
+        if (!startsWith(tok2->str(), "arg"))
+            continue;
+        nonneg int const id = strToInt<nonneg int>(tok2->str().c_str() + 3);
+        tok2->varId(id);
+        lookupVarId[id] = tok2;
+    }
+
+    // Evaluate expression
+    tokenList->createAst();
+    Token* expr = tokenList->front()->astOperand1();
+    ValueFlow::valueFlowConstantFoldAST(expr, settings);
+    return {tokenList, expr};
+}
+
+ValueFlow::Value evaluateLibraryFunction(const std::unordered_map<nonneg int, ValueFlow::Value>& args,
+                                         const std::string& returnValue,
+                                         const Settings& settings,
+                                         bool cpp)
+{
+    thread_local static std::unordered_map<std::string,
+                                           std::function<ValueFlow::Value(const std::unordered_map<nonneg int, ValueFlow::Value>&, const Settings&)>>
+    functions = {};
+    if (functions.count(returnValue) == 0) {
+
+        std::unordered_map<nonneg int, const Token*> lookupVarId;
+        std::shared_ptr<Token> expr = createTokenFromExpression(returnValue, settings, cpp, lookupVarId);
+
+        functions[returnValue] =
+            [lookupVarId, expr](const std::unordered_map<nonneg int, ValueFlow::Value>& xargs, const Settings& settings) {
+            if (!expr)
+                return ValueFlow::Value::unknown();
+            ProgramMemory pm{};
+            for (const auto& p : xargs) {
+                auto it = lookupVarId.find(p.first);
+                if (it != lookupVarId.end())
+                    pm.setValue(it->second, p.second);
+            }
+            return execute(expr.get(), pm, settings);
+        };
+    }
+    return functions.at(returnValue)(args, settings);
+}
+
+void execute(const Token* expr,
+             ProgramMemory& programMemory,
+             MathLib::bigint* result,
+             bool* error,
+             const Settings& settings)
+{
+    ValueFlow::Value v = execute(expr, programMemory, settings);
+    if (!v.isIntValue() || v.isImpossible()) {
+        if (error)
+            *error = true;
+    } else if (result)
+        *result = v.intvalue;
+}
diff --git a/lib/programmemory.h b/lib/programmemory.h
new file mode 100644
index 00000000000..adb0d1469ce
--- /dev/null
+++ b/lib/programmemory.h
@@ -0,0 +1,216 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GUARD_PROGRAMMEMORY_H
+#define GUARD_PROGRAMMEMORY_H
+
+#include "config.h"
+#include "mathlib.h"
+#include "vfvalue.h" // needed for alias
+
+#include <cstddef>
+#include <functional>
+#include <map>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+class Scope;
+class Token;
+class Settings;
+
+// Class used to handle heterogeneous lookup in unordered_map(since we can't use C++20 yet)
+struct ExprIdToken {
+    const Token* tok = nullptr;
+    nonneg int exprid = 0;
+
+    // cppcheck-suppress noExplicitConstructor
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    ExprIdToken(const Token* tok);
+
+    nonneg int getExpressionId() const;
+
+    bool operator==(const ExprIdToken& rhs) const {
+        return getExpressionId() == rhs.getExpressionId();
+    }
+
+    bool operator<(const ExprIdToken& rhs) const {
+        return getExpressionId() < rhs.getExpressionId();
+    }
+
+    template<class T, class U>
+    friend bool operator!=(const T& lhs, const U& rhs)
+    {
+        return !(lhs == rhs);
+    }
+
+    template<class T, class U>
+    friend bool operator<=(const T& lhs, const U& rhs)
+    {
+        return !(lhs > rhs);
+    }
+
+    template<class T, class U>
+    friend bool operator>(const T& lhs, const U& rhs)
+    {
+        return rhs < lhs;
+    }
+
+    template<class T, class U>
+    friend bool operator>=(const T& lhs, const U& rhs)
+    {
+        return !(lhs < rhs);
+    }
+
+    const Token& operator*() const NOEXCEPT {
+        return *tok;
+    }
+
+    const Token* operator->() const NOEXCEPT {
+        return tok;
+    }
+
+    struct Hash {
+        std::size_t operator()(ExprIdToken etok) const;
+    };
+
+    /** create object for hashed lookups */
+    static ExprIdToken create(nonneg int exprId) {
+        return ExprIdToken(exprId);
+    }
+
+private:
+    // for hashed lookups only
+    explicit ExprIdToken(nonneg int exprId);
+};
+
+struct CPPCHECKLIB ProgramMemory {
+    using Map = std::unordered_map<ExprIdToken, ValueFlow::Value, ExprIdToken::Hash>;
+
+    ProgramMemory() : mValues(new Map()) {}
+
+    explicit ProgramMemory(Map values) : mValues(new Map(std::move(values))) {}
+
+    void setValue(const Token* expr, const ValueFlow::Value& value);
+    const ValueFlow::Value* getValue(nonneg int exprid, bool impossible = false) const;
+
+    bool getIntValue(nonneg int exprid, MathLib::bigint& result) const;
+    void setIntValue(const Token* expr, MathLib::bigint value, bool impossible = false);
+
+    bool getContainerSizeValue(nonneg int exprid, MathLib::bigint& result) const;
+    bool getContainerEmptyValue(nonneg int exprid, MathLib::bigint& result) const;
+    void setContainerSizeValue(const Token* expr, MathLib::bigint value, bool isEqual = true);
+
+    void setUnknown(const Token* expr);
+
+    bool getTokValue(nonneg int exprid, const Token*& result) const;
+    bool hasValue(nonneg int exprid) const;
+
+    const ValueFlow::Value& at(nonneg int exprid) const;
+    ValueFlow::Value& at(nonneg int exprid);
+
+    void erase_if(const std::function<bool(const ExprIdToken&)>& pred);
+
+    void swap(ProgramMemory &pm) NOEXCEPT;
+
+    void clear();
+
+    bool empty() const;
+
+    void replace(ProgramMemory pm, bool skipUnknown = false);
+
+    Map::const_iterator begin() const {
+        return mValues->cbegin();
+    }
+
+    Map::const_iterator end() const {
+        return mValues->cend();
+    }
+
+    friend bool operator==(const ProgramMemory& x, const ProgramMemory& y) {
+        return x.mValues == y.mValues;
+    }
+
+    friend bool operator!=(const ProgramMemory& x, const ProgramMemory& y) {
+        return x.mValues != y.mValues;
+    }
+
+private:
+    void copyOnWrite();
+    Map::const_iterator find(nonneg int exprid) const;
+    Map::iterator find(nonneg int exprid);
+
+    std::shared_ptr<Map> mValues;
+};
+
+struct ProgramMemoryState {
+    ProgramMemory state;
+    std::map<nonneg int, const Token*> origins;
+    const Settings& settings;
+
+    explicit ProgramMemoryState(const Settings& s);
+
+    void replace(ProgramMemory pm, const Token* origin = nullptr);
+
+    void addState(const Token* tok, const ProgramMemory::Map& vars);
+
+    void assume(const Token* tok, bool b, bool isEmpty = false);
+
+    void removeModifiedVars(const Token* tok);
+
+    ProgramMemory get(const Token* tok, const Token* ctx, const ProgramMemory::Map& vars) const;
+};
+
+std::vector<ValueFlow::Value> execute(const Scope* scope, ProgramMemory& pm, const Settings& settings);
+
+void execute(const Token* expr,
+             ProgramMemory& programMemory,
+             MathLib::bigint* result,
+             bool* error,
+             const Settings& settings);
+
+/**
+ * Is condition always false when variable has given value?
+ * \param condition   top ast token in condition
+ * \param pm   program memory
+ */
+bool conditionIsFalse(const Token* condition, ProgramMemory pm, const Settings& settings);
+
+/**
+ * Is condition always true when variable has given value?
+ * \param condition   top ast token in condition
+ * \param pm   program memory
+ */
+bool conditionIsTrue(const Token* condition, ProgramMemory pm, const Settings& settings);
+
+/**
+ * Get program memory by looking backwards from given token.
+ */
+ProgramMemory getProgramMemory(const Token* tok, const Token* expr, const ValueFlow::Value& value, const Settings& settings);
+
+ValueFlow::Value evaluateLibraryFunction(const std::unordered_map<nonneg int, ValueFlow::Value>& args,
+                                         const std::string& returnValue,
+                                         const Settings& settings,
+                                         bool cpp);
+
+#endif
+
+
+
diff --git a/lib/regex.cpp b/lib/regex.cpp
new file mode 100644
index 00000000000..6ad9ad440b0
--- /dev/null
+++ b/lib/regex.cpp
@@ -0,0 +1,260 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_RULES
+
+#include "regex.h"
+
+#include <utility>
+
+#ifdef _WIN32
+#define PCRE_STATIC
+#endif
+#include <pcre.h>
+
+namespace {
+    std::string pcreErrorCodeToString(const int pcreExecRet)
+    {
+        switch (pcreExecRet) {
+        case PCRE_ERROR_NULL:
+            return "Either code or subject was passed as NULL, or ovector was NULL "
+                   "and ovecsize was not zero (PCRE_ERROR_NULL)";
+        case PCRE_ERROR_BADOPTION:
+            return "An unrecognized bit was set in the options argument (PCRE_ERROR_BADOPTION)";
+        case PCRE_ERROR_BADMAGIC:
+            return "PCRE stores a 4-byte \"magic number\" at the start of the compiled code, "
+                   "to catch the case when it is passed a junk pointer and to detect when a "
+                   "pattern that was compiled in an environment of one endianness is run in "
+                   "an environment with the other endianness. This is the error that PCRE "
+                   "gives when the magic number is not present (PCRE_ERROR_BADMAGIC)";
+        case PCRE_ERROR_UNKNOWN_NODE:
+            return "While running the pattern match, an unknown item was encountered in the "
+                   "compiled pattern. This error could be caused by a bug in PCRE or by "
+                   "overwriting of the compiled pattern (PCRE_ERROR_UNKNOWN_NODE)";
+        case PCRE_ERROR_NOMEMORY:
+            return "If a pattern contains back references, but the ovector that is passed "
+                   "to pcre_exec() is not big enough to remember the referenced substrings, "
+                   "PCRE gets a block of memory at the start of matching to use for this purpose. "
+                   "If the call via pcre_malloc() fails, this error is given. The memory is "
+                   "automatically freed at the end of matching. This error is also given if "
+                   "pcre_stack_malloc() fails in pcre_exec(). "
+                   "This can happen only when PCRE has been compiled with "
+                   "--disable-stack-for-recursion (PCRE_ERROR_NOMEMORY)";
+        case PCRE_ERROR_NOSUBSTRING:
+            return "This error is used by the pcre_copy_substring(), pcre_get_substring(), "
+                   "and pcre_get_substring_list() functions (see below). "
+                   "It is never returned by pcre_exec() (PCRE_ERROR_NOSUBSTRING)";
+        case PCRE_ERROR_MATCHLIMIT:
+            return "The backtracking limit, as specified by the match_limit field in a pcre_extra "
+                   "structure (or defaulted) was reached. "
+                   "See the description above (PCRE_ERROR_MATCHLIMIT)";
+        case PCRE_ERROR_CALLOUT:
+            return "This error is never generated by pcre_exec() itself. "
+                   "It is provided for use by callout functions that want to yield a distinctive "
+                   "error code. See the pcrecallout documentation for details (PCRE_ERROR_CALLOUT)";
+        case PCRE_ERROR_BADUTF8:
+            return "A string that contains an invalid UTF-8 byte sequence was passed as a subject, "
+                   "and the PCRE_NO_UTF8_CHECK option was not set. If the size of the output vector "
+                   "(ovecsize) is at least 2, the byte offset to the start of the the invalid UTF-8 "
+                   "character is placed in the first element, and a reason code is placed in the "
+                   "second element. The reason codes are listed in the following section. For "
+                   "backward compatibility, if PCRE_PARTIAL_HARD is set and the problem is a truncated "
+                   "UTF-8 character at the end of the subject (reason codes 1 to 5), "
+                   "PCRE_ERROR_SHORTUTF8 is returned instead of PCRE_ERROR_BADUTF8";
+        case PCRE_ERROR_BADUTF8_OFFSET:
+            return "The UTF-8 byte sequence that was passed as a subject was checked and found to "
+                   "be valid (the PCRE_NO_UTF8_CHECK option was not set), but the value of "
+                   "startoffset did not point to the beginning of a UTF-8 character or the end of "
+                   "the subject (PCRE_ERROR_BADUTF8_OFFSET)";
+        case PCRE_ERROR_PARTIAL:
+            return "The subject string did not match, but it did match partially. See the "
+                   "pcrepartial documentation for details of partial matching (PCRE_ERROR_PARTIAL)";
+        case PCRE_ERROR_BADPARTIAL:
+            return "This code is no longer in use. It was formerly returned when the PCRE_PARTIAL "
+                   "option was used with a compiled pattern containing items that were not supported "
+                   "for partial matching. From release 8.00 onwards, there are no restrictions on "
+                   "partial matching (PCRE_ERROR_BADPARTIAL)";
+        case PCRE_ERROR_INTERNAL:
+            return "An unexpected internal error has occurred. This error could be caused by a bug "
+                   "in PCRE or by overwriting of the compiled pattern (PCRE_ERROR_INTERNAL)";
+        case PCRE_ERROR_BADCOUNT:
+            return "This error is given if the value of the ovecsize argument is negative "
+                   "(PCRE_ERROR_BADCOUNT)";
+        case PCRE_ERROR_RECURSIONLIMIT:
+            return "The internal recursion limit, as specified by the match_limit_recursion "
+                   "field in a pcre_extra structure (or defaulted) was reached. "
+                   "See the description above (PCRE_ERROR_RECURSIONLIMIT)";
+        case PCRE_ERROR_DFA_UITEM:
+            return "PCRE_ERROR_DFA_UITEM";
+        case PCRE_ERROR_DFA_UCOND:
+            return "PCRE_ERROR_DFA_UCOND";
+        case PCRE_ERROR_DFA_WSSIZE:
+            return "PCRE_ERROR_DFA_WSSIZE";
+        case PCRE_ERROR_DFA_RECURSE:
+            return "PCRE_ERROR_DFA_RECURSE";
+        case PCRE_ERROR_NULLWSLIMIT:
+            return "PCRE_ERROR_NULLWSLIMIT";
+        case PCRE_ERROR_BADNEWLINE:
+            return "An invalid combination of PCRE_NEWLINE_xxx options was "
+                   "given (PCRE_ERROR_BADNEWLINE)";
+        case PCRE_ERROR_BADOFFSET:
+            return "The value of startoffset was negative or greater than the length "
+                   "of the subject, that is, the value in length (PCRE_ERROR_BADOFFSET)";
+        case PCRE_ERROR_SHORTUTF8:
+            return "This error is returned instead of PCRE_ERROR_BADUTF8 when the subject "
+                   "string ends with a truncated UTF-8 character and the PCRE_PARTIAL_HARD option is set. "
+                   "Information about the failure is returned as for PCRE_ERROR_BADUTF8. "
+                   "It is in fact sufficient to detect this case, but this special error code for "
+                   "PCRE_PARTIAL_HARD precedes the implementation of returned information; "
+                   "it is retained for backwards compatibility (PCRE_ERROR_SHORTUTF8)";
+        case PCRE_ERROR_RECURSELOOP:
+            return "This error is returned when pcre_exec() detects a recursion loop "
+                   "within the pattern. Specifically, it means that either the whole pattern "
+                   "or a subpattern has been called recursively for the second time at the same "
+                   "position in the subject string. Some simple patterns that might do this "
+                   "are detected and faulted at compile time, but more complicated cases, "
+                   "in particular mutual recursions between two different subpatterns, "
+                   "cannot be detected until run time (PCRE_ERROR_RECURSELOOP)";
+        case PCRE_ERROR_JIT_STACKLIMIT:
+            return "This error is returned when a pattern that was successfully studied "
+                   "using a JIT compile option is being matched, but the memory available "
+                   "for the just-in-time processing stack is not large enough. See the pcrejit "
+                   "documentation for more details (PCRE_ERROR_JIT_STACKLIMIT)";
+        case PCRE_ERROR_BADMODE:
+            return "This error is given if a pattern that was compiled by the 8-bit library "
+                   "is passed to a 16-bit or 32-bit library function, or vice versa (PCRE_ERROR_BADMODE)";
+        case PCRE_ERROR_BADENDIANNESS:
+            return "This error is given if a pattern that was compiled and saved is reloaded on a "
+                   "host with different endianness. The utility function pcre_pattern_to_host_byte_order() "
+                   "can be used to convert such a pattern so that it runs on the new host (PCRE_ERROR_BADENDIANNESS)";
+        case PCRE_ERROR_DFA_BADRESTART:
+            return "PCRE_ERROR_DFA_BADRESTART";
+#if PCRE_MAJOR >= 8 && PCRE_MINOR >= 32
+        case PCRE_ERROR_BADLENGTH:
+            return "This error is given if pcre_exec() is called with a negative value for the length argument (PCRE_ERROR_BADLENGTH)";
+        case PCRE_ERROR_JIT_BADOPTION:
+            return "This error is returned when a pattern that was successfully studied using a JIT compile "
+                   "option is being matched, but the matching mode (partial or complete match) does not correspond "
+                   "to any JIT compilation mode. When the JIT fast path function is used, this error may be "
+                   "also given for invalid options. See the pcrejit documentation for more details (PCRE_ERROR_JIT_BADOPTION)";
+#endif
+        }
+        return "unknown PCRE error " + std::to_string(pcreExecRet);
+    }
+
+    class PcreRegex : public Regex
+    {
+    public:
+        explicit PcreRegex(std::string pattern)
+            : mPattern(std::move(pattern))
+        {}
+
+        ~PcreRegex() override
+        {
+            if (mExtra) {
+                pcre_free(mExtra);
+                mExtra = nullptr;
+            }
+            if (mRe) {
+                pcre_free(mRe);
+                mRe = nullptr;
+            }
+        }
+
+        std::string compile();
+        std::string match(const std::string& str, const MatchFn& match) const override;
+
+    private:
+        std::string mPattern;
+        pcre* mRe{};
+        pcre_extra* mExtra{};
+    };
+
+    std::string PcreRegex::compile()
+    {
+        if (mRe)
+            return "pcre_compile failed: regular expression has already been compiled";
+
+        const char *pcreCompileErrorStr = nullptr;
+        int erroffset = 0;
+        pcre * const re = pcre_compile(mPattern.c_str(),0,&pcreCompileErrorStr,&erroffset,nullptr);
+        if (!re) {
+            if (pcreCompileErrorStr)
+                return "pcre_compile failed: " + std::string(pcreCompileErrorStr);
+            return "pcre_compile failed: unknown error";
+        }
+
+        // Optimize the regex, but only if PCRE_CONFIG_JIT is available
+#ifdef PCRE_CONFIG_JIT
+        const char *pcreStudyErrorStr = nullptr;
+        pcre_extra * const pcreExtra = pcre_study(re, PCRE_STUDY_JIT_COMPILE, &pcreStudyErrorStr);
+        // pcre_study() returns NULL for both errors and when it can not optimize the regex.
+        // The last argument is how one checks for errors.
+        // It is NULL if everything works, and points to an error string otherwise.
+        if (pcreStudyErrorStr) {
+            // pcre_compile() worked, but pcre_study() returned an error. Free the resources allocated by pcre_compile().
+            pcre_free(re);
+            return "pcre_study failed: " + std::string(pcreStudyErrorStr);
+        }
+        mExtra = pcreExtra;
+#endif
+
+        mRe = re;
+
+        return "";
+    }
+
+    std::string PcreRegex::match(const std::string& str, const MatchFn& match) const
+    {
+        if (!mRe)
+            return "pcre_exec failed: regular expression has not been compiled yet";
+
+        int pos = 0;
+        int ovector[30]= {0};
+        while (pos < static_cast<int>(str.size())) {
+            const int pcreExecRet = pcre_exec(mRe, mExtra, str.c_str(), static_cast<int>(str.size()), pos, 0, ovector, 30);
+            if (pcreExecRet == PCRE_ERROR_NOMATCH)
+                return "";
+            if (pcreExecRet < 0) {
+                return "pcre_exec failed (pos: " + std::to_string(pos) + "): " + pcreErrorCodeToString(pcreExecRet);
+            }
+            const auto pos1 = static_cast<unsigned int>(ovector[0]);
+            const auto pos2 = static_cast<unsigned int>(ovector[1]);
+
+            match(pos1, pos2);
+
+            // jump to the end of the match for the next pcre_exec
+            pos = static_cast<int>(pos2);
+        }
+
+        return "";
+    }
+}
+
+std::shared_ptr<Regex> Regex::create(std::string pattern, std::string& err)
+{
+    auto* regex = new PcreRegex(std::move(pattern));
+    err = regex->compile();
+    if (!err.empty()) {
+        delete regex;
+        return nullptr;
+    }
+    return std::shared_ptr<Regex>(regex);
+}
+
+#endif // HAVE_RULES
diff --git a/lib/regex.h b/lib/regex.h
new file mode 100644
index 00000000000..5d89dc52054
--- /dev/null
+++ b/lib/regex.h
@@ -0,0 +1,45 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+//---------------------------------------------------------------------------
+#ifndef regexH
+#define regexH
+//---------------------------------------------------------------------------
+
+#ifdef HAVE_RULES
+
+#include "config.h"
+
+#include <functional>
+#include <memory>
+#include <string>
+
+class CPPCHECKLIB Regex
+{
+public:
+    virtual ~Regex() = default;
+
+    using MatchFn = std::function<void (int start, int end)>;
+    virtual std::string match(const std::string& str, const MatchFn& matchFn) const = 0;
+
+    static std::shared_ptr<Regex> create(std::string pattern, std::string& err);
+};
+
+#endif // HAVE_RULES
+
+#endif // regexH
diff --git a/lib/reverseanalyzer.cpp b/lib/reverseanalyzer.cpp
new file mode 100644
index 00000000000..50aad01fdd9
--- /dev/null
+++ b/lib/reverseanalyzer.cpp
@@ -0,0 +1,415 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "reverseanalyzer.h"
+
+#include "analyzer.h"
+#include "astutils.h"
+#include "errortypes.h"
+#include "forwardanalyzer.h"
+#include "mathlib.h"
+#include "settings.h"
+#include "symboldatabase.h"
+#include "token.h"
+#include "valueptr.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <string>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+namespace {
+    struct ReverseTraversal {
+        ReverseTraversal(const ValuePtr<Analyzer>& analyzer, const TokenList& tokenlist, ErrorLogger& errorLogger, const Settings& settings)
+            : analyzer(analyzer), tokenlist(tokenlist), errorLogger(errorLogger), settings(settings)
+        {}
+        ValuePtr<Analyzer> analyzer;
+        const TokenList& tokenlist;
+        ErrorLogger& errorLogger;
+        const Settings& settings;
+
+        std::pair<bool, bool> evalCond(const Token* tok) const {
+            std::vector<MathLib::bigint> result = analyzer->evaluate(tok);
+            // TODO: We should convert to bool
+            const bool checkThen = std::any_of(result.cbegin(), result.cend(), [](MathLib::bigint x) {
+                return x == 1;
+            });
+            const bool checkElse = std::any_of(result.cbegin(), result.cend(), [](MathLib::bigint x) {
+                return x == 0;
+            });
+            return std::make_pair(checkThen, checkElse);
+        }
+
+        bool update(Token* tok) {
+            Analyzer::Action action = analyzer->analyze(tok, Analyzer::Direction::Reverse);
+            if (action.isInconclusive() && !analyzer->lowerToInconclusive())
+                return false;
+            if (action.isInvalid())
+                return false;
+            if (!action.isNone())
+                analyzer->update(tok, action, Analyzer::Direction::Reverse);
+            return true;
+        }
+
+        static Token* getParentFunction(Token* tok)
+        {
+            if (!tok)
+                return nullptr;
+            if (!tok->astParent())
+                return nullptr;
+            int argn = -1;
+            if (Token* ftok = getTokenArgumentFunction(tok, argn)) {
+                while (!Token::Match(ftok, "(|{")) {
+                    if (!ftok)
+                        return nullptr;
+                    if (ftok->index() >= tok->index())
+                        return nullptr;
+                    if (!ftok->link() || ftok->str() == ")")
+                        ftok = ftok->next();
+                    else
+                        ftok = ftok->link()->next();
+                }
+                if (ftok == tok)
+                    return nullptr;
+                return ftok;
+            }
+            return nullptr;
+        }
+
+        static Token* getTopFunction(Token* tok)
+        {
+            if (!tok)
+                return nullptr;
+            if (!tok->astParent())
+                return tok;
+            Token* parent = tok;
+            Token* top = tok;
+            while ((parent = getParentFunction(parent)))
+                top = parent;
+            return top;
+        }
+
+        static Token* jumpToStart(Token* tok)
+        {
+            if (Token::simpleMatch(tok->tokAt(-2), "} else {"))
+                tok = tok->linkAt(-2);
+            if (Token::simpleMatch(tok->previous(), ") {"))
+                return tok->linkAt(-1);
+            if (Token::simpleMatch(tok->previous(), "do {"))
+                return tok->previous();
+            return tok;
+        }
+
+        bool updateRecursive(Token* start) {
+            bool continueB = true;
+            visitAstNodes(start, [&](Token* tok) {
+                const Token* parent = tok->astParent();
+                while (Token::simpleMatch(parent, ":"))
+                    parent = parent->astParent();
+                if (isUnevaluated(tok) || isDeadCode(tok, parent))
+                    return ChildrenToVisit::none;
+                continueB &= update(tok);
+                if (continueB)
+                    return ChildrenToVisit::op1_and_op2;
+                return ChildrenToVisit::done;
+            });
+            return continueB;
+        }
+
+        Analyzer::Action analyzeRecursive(const Token* start) const {
+            Analyzer::Action result = Analyzer::Action::None;
+            visitAstNodes(start, [&](const Token* tok) {
+                result |= analyzer->analyze(tok, Analyzer::Direction::Reverse);
+                if (result.isModified())
+                    return ChildrenToVisit::done;
+                return ChildrenToVisit::op1_and_op2;
+            });
+            return result;
+        }
+
+        Analyzer::Action analyzeRange(const Token* start, const Token* end) const {
+            Analyzer::Action result = Analyzer::Action::None;
+            for (const Token* tok = start; tok && tok != end; tok = tok->next()) {
+                Analyzer::Action action = analyzer->analyze(tok, Analyzer::Direction::Reverse);
+                if (action.isModified())
+                    return action;
+                result |= action;
+            }
+            return result;
+        }
+
+        Token* isDeadCode(Token* tok, const Token* end = nullptr) const {
+            int opSide = 0;
+            for (; tok && tok->astParent(); tok = tok->astParent()) {
+                if (tok == end)
+                    break;
+                Token* parent = tok->astParent();
+                if (Token::simpleMatch(parent, ":")) {
+                    if (astIsLHS(tok))
+                        opSide = 1;
+                    else if (astIsRHS(tok))
+                        opSide = 2;
+                    else
+                        opSide = 0;
+                }
+                if (tok != parent->astOperand2())
+                    continue;
+                if (Token::simpleMatch(parent, ":"))
+                    parent = parent->astParent();
+                if (!Token::Match(parent, "%oror%|&&|?"))
+                    continue;
+                const Token* condTok = parent->astOperand1();
+                if (!condTok)
+                    continue;
+                bool checkThen, checkElse;
+                std::tie(checkThen, checkElse) = evalCond(condTok);
+
+                if (parent->str() == "?") {
+                    if (checkElse && opSide == 1)
+                        return parent;
+                    if (checkThen && opSide == 2)
+                        return parent;
+                }
+                if (!checkThen && parent->str() == "&&")
+                    return parent;
+                if (!checkElse && parent->str() == "||")
+                    return parent;
+            }
+            return nullptr;
+        }
+
+        /**
+         * @throws InternalError thrown on cyclic analysis
+         */
+        void traverse(Token* start, const Token* end = nullptr) {
+            if (start == end)
+                return;
+            std::size_t i = start->index();
+            for (Token* tok = start->previous(); succeeds(tok, end); tok = tok->previous()) {
+                if (tok->index() >= i)
+                    throw InternalError(tok, "Cyclic reverse analysis.");
+                i = tok->index();
+                if (tok == start || (tok->str() == "{" && (tok->scope()->type == ScopeType::eFunction ||
+                                                           tok->scope()->type == ScopeType::eLambda))) {
+                    const Function* f = tok->scope()->function;
+                    if (f && f->isConstructor()) {
+                        if (const Token* initList = f->constructorMemberInitialization())
+                            traverse(tok->previous(), tok->tokAt(initList->index() - tok->index()));
+                    }
+                    break;
+                }
+                if (Token::Match(tok, "return|break|continue"))
+                    break;
+                if (Token::Match(tok, "%name% :"))
+                    break;
+                if (Token::simpleMatch(tok, ":"))
+                    continue;
+                // Evaluate LHS of assignment before RHS
+                if (Token* assignTok = assignExpr(tok)) {
+                    // If assignTok has broken ast then stop
+                    if (!assignTok->astOperand1() || !assignTok->astOperand2())
+                        break;
+                    Token* assignTop = assignTok;
+                    bool continueB = true;
+                    while (assignTop->isAssignmentOp()) {
+                        if (!Token::Match(assignTop->astOperand1(), "%assign%")) {
+                            continueB &= updateRecursive(assignTop->astOperand1());
+                        }
+                        if (!assignTop->astParent())
+                            break;
+                        assignTop = assignTop->astParent();
+                    }
+                    // Is assignment in dead code
+                    if (Token* parent = isDeadCode(assignTok)) {
+                        tok = parent;
+                        continue;
+                    }
+                    // Simple assign
+                    if (assignTok->str() == "=" && (assignTok->astParent() == assignTop || assignTok == assignTop)) {
+                        Analyzer::Action rhsAction =
+                            analyzer->analyze(assignTok->astOperand2(), Analyzer::Direction::Reverse);
+                        Analyzer::Action lhsAction =
+                            analyzer->analyze(assignTok->astOperand1(), Analyzer::Direction::Reverse);
+                        // Assignment from
+                        if (rhsAction.isRead() && !lhsAction.isInvalid() && assignTok->astOperand1()->exprId() > 0) {
+                            const std::string info = "Assignment from '" + assignTok->expressionString() + "'";
+                            ValuePtr<Analyzer> a = analyzer->reanalyze(assignTok->astOperand1(), info);
+                            if (a) {
+                                valueFlowGenericForward(nextAfterAstRightmostLeaf(assignTok->astOperand2()),
+                                                        assignTok->astOperand2()->scope()->bodyEnd,
+                                                        a,
+                                                        tokenlist,
+                                                        errorLogger,
+                                                        settings);
+                            }
+                            // Assignment to
+                        } else if (lhsAction.matches() && !assignTok->astOperand2()->hasKnownIntValue() &&
+                                   assignTok->astOperand2()->exprId() > 0 &&
+                                   isConstExpression(assignTok->astOperand2(), settings.library)) {
+                            const std::string info = "Assignment to '" + assignTok->expressionString() + "'";
+                            ValuePtr<Analyzer> a = analyzer->reanalyze(assignTok->astOperand2(), info);
+                            if (a) {
+                                valueFlowGenericForward(nextAfterAstRightmostLeaf(assignTok->astOperand2()),
+                                                        assignTok->astOperand2()->scope()->bodyEnd,
+                                                        a,
+                                                        tokenlist,
+                                                        errorLogger,
+                                                        settings);
+                                valueFlowGenericReverse(assignTok->astOperand1()->previous(), end, a, tokenlist, errorLogger, settings);
+                            }
+                        }
+                    }
+                    if (!continueB)
+                        break;
+                    if (!updateRecursive(assignTop->astOperand2()))
+                        break;
+                    tok = previousBeforeAstLeftmostLeaf(assignTop)->next();
+                    continue;
+                }
+                if (tok->str() == ")" && !isUnevaluated(tok)) {
+                    if (Token* top = getTopFunction(tok->link())) {
+                        if (!updateRecursive(top))
+                            break;
+                        Token* next = previousBeforeAstLeftmostLeaf(top);
+                        if (next && precedes(next, tok))
+                            tok = next->next();
+                    }
+                    continue;
+                }
+                if (tok->str() == "}") {
+                    Token* condTok = getCondTokFromEnd(tok);
+                    if (!condTok)
+                        break;
+                    Analyzer::Action condAction = analyzeRecursive(condTok);
+                    if (condAction.isModified())
+                        break;
+                    const bool inLoop = Token::Match(condTok->astTop()->previous(), "for|while (");
+                    // Evaluate condition of for and while loops first
+                    if (inLoop) {
+                        if (Token::findmatch(tok->link(), "goto|break", tok))
+                            break;
+                        valueFlowGenericForward(condTok, analyzer, tokenlist, errorLogger, settings);
+                    }
+                    Token* thenEnd;
+                    const bool hasElse = Token::simpleMatch(tok->link()->tokAt(-2), "} else {");
+                    if (hasElse) {
+                        thenEnd = tok->link()->tokAt(-2);
+                    } else {
+                        thenEnd = tok;
+                    }
+
+                    Analyzer::Action thenAction = analyzeRange(thenEnd->link(), thenEnd);
+                    Analyzer::Action elseAction = Analyzer::Action::None;
+                    if (hasElse) {
+                        elseAction = analyzeRange(tok->link(), tok);
+                    }
+                    if (thenAction.isModified() && inLoop)
+                        break;
+                    if (thenAction.isModified() && !elseAction.isModified())
+                        analyzer->assume(condTok, hasElse);
+                    else if (elseAction.isModified() && !thenAction.isModified())
+                        analyzer->assume(condTok, !hasElse);
+                    // Bail if one of the branches are read to avoid FPs due to over constraints
+                    else if (thenAction.isIdempotent() || elseAction.isIdempotent() || thenAction.isRead() ||
+                             elseAction.isRead())
+                        break;
+                    if (thenAction.isInvalid() || elseAction.isInvalid())
+                        break;
+
+                    if (!thenAction.isModified() && !elseAction.isModified())
+                        valueFlowGenericForward(condTok, analyzer, tokenlist, errorLogger, settings);
+                    else if (condAction.isRead())
+                        break;
+                    // If the condition modifies the variable then bail
+                    if (condAction.isModified())
+                        break;
+                    tok = jumpToStart(tok->link());
+                    continue;
+                }
+                if (tok->str() == "{") {
+                    if (tok->previous() &&
+                        (Token::simpleMatch(tok->previous(), "do") ||
+                         (tok->strAt(-1) == ")" && Token::Match(tok->linkAt(-1)->previous(), "for|while (")))) {
+                        Analyzer::Action action = analyzeRange(tok, tok->link());
+                        if (action.isModified())
+                            break;
+                    }
+                    Token* condTok = getCondTokFromEnd(tok->link());
+                    if (condTok) {
+                        Analyzer::Result r = valueFlowGenericForward(condTok, analyzer, tokenlist, errorLogger, settings);
+                        if (r.action.isModified())
+                            break;
+                    }
+                    tok = jumpToStart(tok);
+                    continue;
+                }
+                if (Token* next = isUnevaluated(tok)) {
+                    tok = next;
+                    continue;
+                }
+                if (Token* parent = isDeadCode(tok)) {
+                    tok = parent;
+                    continue;
+                }
+                if (tok->str() == "case") {
+                    const Scope* scope = tok->scope();
+                    while (scope && scope->type != ScopeType::eSwitch)
+                        scope = scope->nestedIn;
+                    if (!scope || scope->type != ScopeType::eSwitch)
+                        break;
+                    tok = tok->tokAt(scope->bodyStart->index() - tok->index() - 1);
+                    continue;
+                }
+                if (!update(tok))
+                    break;
+            }
+        }
+
+        static Token* assignExpr(Token* tok) {
+            if (Token::Match(tok, ")|}"))
+                tok = tok->link();
+            while (tok->astParent() && (astIsRHS(tok) || !tok->astParent()->isBinaryOp())) {
+                if (tok->astParent()->isAssignmentOp())
+                    return tok->astParent();
+                tok = tok->astParent();
+            }
+            return nullptr;
+        }
+
+        static Token* isUnevaluated(Token* tok) {
+            if (Token::Match(tok, ")|>") && tok->link()) {
+                Token* start = tok->link();
+                if (::isUnevaluated(start->previous()))
+                    return start->previous();
+                if (Token::simpleMatch(start, "<"))
+                    return start;
+            }
+            return nullptr;
+        }
+    };
+}
+
+void valueFlowGenericReverse(Token* start, const Token* end, const ValuePtr<Analyzer>& a, const TokenList& tokenlist, ErrorLogger& errorLogger, const Settings& settings)
+{
+    if (a->invalid())
+        return;
+    ReverseTraversal rt{a, tokenlist, errorLogger, settings};
+    rt.traverse(start, end);
+}
diff --git a/lib/reverseanalyzer.h b/lib/reverseanalyzer.h
new file mode 100644
index 00000000000..2a9877fb337
--- /dev/null
+++ b/lib/reverseanalyzer.h
@@ -0,0 +1,32 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef reverseanalyzerH
+#define reverseanalyzerH
+
+struct Analyzer;
+class ErrorLogger;
+class Settings;
+class Token;
+class TokenList;
+template<class T>
+class ValuePtr;
+
+void valueFlowGenericReverse(Token* start, const Token* end, const ValuePtr<Analyzer>& a, const TokenList& tokenlist, ErrorLogger& errorLogger, const Settings& settings);
+
+#endif
diff --git a/lib/sarifreport.cpp b/lib/sarifreport.cpp
new file mode 100644
index 00000000000..38eb9ea96ca
--- /dev/null
+++ b/lib/sarifreport.cpp
@@ -0,0 +1,225 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "sarifreport.h"
+
+#include "cppcheck.h"
+#include "errorlogger.h"
+#include "errortypes.h"
+#include "settings.h"
+
+#include <cstdint>
+#include <set>
+#include <sstream>
+#include <utility>
+
+static const char sarifVersion[] = "2.1.0";
+static const char sarifSchema[] = "https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/schemas/sarif-schema-2.1.0.json";
+
+void SarifReport::addFinding(ErrorMessage msg)
+{
+    mFindings.push_back(std::move(msg));
+}
+
+picojson::array SarifReport::serializeRules() const
+{
+    picojson::array ret;
+    std::set<std::string> ruleIds;
+    for (const auto& finding : mFindings) {
+        // github only supports findings with locations
+        if (finding.callStack.empty())
+            continue;
+        if (ruleIds.insert(finding.id).second) {
+            // setting name and description to empty strings will make github default
+            // to the instance specific violation message and not rule description,
+            // this makes it so not all the violations have the same description.
+            picojson::object rule;
+            rule["id"] = picojson::value(finding.id);
+            // rule.name
+            rule["name"] = picojson::value("");
+            // rule.shortDescription.text
+            picojson::object shortDescription;
+            shortDescription["text"] = picojson::value("");
+            rule["shortDescription"] = picojson::value(shortDescription);
+            // rule.fullDescription.text
+            picojson::object fullDescription;
+            fullDescription["text"] = picojson::value("");
+            rule["fullDescription"] = picojson::value(fullDescription);
+            // rule.help.text
+            picojson::object help;
+            help["text"] = picojson::value("");
+            rule["help"] = picojson::value(help);
+            // rule.properties.precision, rule.properties.problem.severity
+            picojson::object properties;
+            properties["precision"] = picojson::value(sarifPrecision(finding));
+            // rule.properties.security-severity, rule.properties.tags
+            picojson::array tags;
+
+            // If we have a CWE ID, treat it as security-related (CWE is the authoritative source for security weaknesses)
+            if (finding.cwe.id > 0) {
+                double securitySeverity = 0;
+                if (finding.severity == Severity::error && !ErrorLogger::isCriticalErrorId(finding.id)) {
+                    securitySeverity = 9.9; // critical = 9.0+
+                }
+                else if (finding.severity == Severity::warning) {
+                    securitySeverity = 8.5; // high = 7.0 to 8.9
+                }
+                else if (finding.severity == Severity::performance || finding.severity == Severity::portability ||
+                         finding.severity == Severity::style) {
+                    securitySeverity = 5.5; // medium = 4.0 to 6.9
+                }
+                else if (finding.severity == Severity::information || finding.severity == Severity::internal ||
+                         finding.severity == Severity::debug || finding.severity == Severity::none) {
+                    securitySeverity = 2.0; // low = 0.1 to 3.9
+                }
+                if (securitySeverity > 0.0) {
+                    std::ostringstream ss;
+                    ss << securitySeverity;
+                    properties["security-severity"] = picojson::value(ss.str());
+                    tags.emplace_back("external/cwe/cwe-" + std::to_string(finding.cwe.id));
+                    tags.emplace_back("security");
+                }
+            }
+
+            // Add tags array if it has any content
+            if (!tags.empty()) {
+                properties["tags"] = picojson::value(tags);
+            }
+
+            // Set problem.severity for use with github
+            const std::string problemSeverity = sarifSeverity(finding);
+            properties["problem.severity"] = picojson::value(problemSeverity);
+            rule["properties"] = picojson::value(properties);
+            // rule.defaultConfiguration.level
+            picojson::object defaultConfiguration;
+            defaultConfiguration["level"] = picojson::value(sarifSeverity(finding));
+            rule["defaultConfiguration"] = picojson::value(defaultConfiguration);
+
+            ret.emplace_back(rule);
+        }
+    }
+    return ret;
+}
+
+picojson::array SarifReport::serializeLocations(const ErrorMessage& finding)
+{
+    picojson::array ret;
+    for (const auto& location : finding.callStack) {
+        picojson::object physicalLocation;
+        picojson::object artifactLocation;
+        artifactLocation["uri"] = picojson::value(location.getfile(false));
+        physicalLocation["artifactLocation"] = picojson::value(artifactLocation);
+        picojson::object region;
+        region["startLine"] = picojson::value(static_cast<int64_t>(location.line < 1 ? 1 : location.line));
+        region["startColumn"] = picojson::value(static_cast<int64_t>(location.column < 1 ? 1 : location.column));
+        region["endLine"] = region["startLine"];
+        region["endColumn"] = region["startColumn"];
+        physicalLocation["region"] = picojson::value(region);
+        picojson::object loc;
+        loc["physicalLocation"] = picojson::value(physicalLocation);
+        ret.emplace_back(loc);
+    }
+    return ret;
+}
+
+picojson::array SarifReport::serializeResults() const
+{
+    picojson::array results;
+    for (const auto& finding : mFindings) {
+        // github only supports findings with locations
+        if (finding.callStack.empty())
+            continue;
+        picojson::object res;
+        res["level"] = picojson::value(sarifSeverity(finding));
+        res["locations"] = picojson::value(serializeLocations(finding));
+        picojson::object message;
+        message["text"] = picojson::value(finding.shortMessage());
+        res["message"] = picojson::value(message);
+        res["ruleId"] = picojson::value(finding.id);
+        if (finding.hash != 0) {
+            picojson::object partialFingerprints;
+            partialFingerprints["hash/v1"] = picojson::value(std::to_string(finding.hash));
+            res["partialFingerprints"] = picojson::value(partialFingerprints);
+        }
+        results.emplace_back(res);
+    }
+    return results;
+}
+
+picojson::value SarifReport::serializeRuns(const std::string& productName, const std::string& version) const
+{
+    picojson::object driver;
+    driver["name"] = picojson::value(productName);
+    driver["semanticVersion"] = picojson::value(version);
+    driver["informationUri"] = picojson::value("https://cppcheck.sourceforge.io");
+    driver["rules"] = picojson::value(serializeRules());
+    picojson::object tool;
+    tool["driver"] = picojson::value(driver);
+    picojson::object run;
+    run["tool"] = picojson::value(tool);
+    run["results"] = picojson::value(serializeResults());
+    picojson::array runs{picojson::value(run)};
+    return picojson::value(runs);
+}
+
+std::string SarifReport::serialize(std::string productName) const
+{
+    const auto nameAndVersion = Settings::getNameAndVersion(productName);
+    productName = nameAndVersion.first.empty() ? "Cppcheck" : nameAndVersion.first;
+    std::string version = nameAndVersion.first.empty() ? CppCheck::version() : nameAndVersion.second;
+    if (version.find(' ') != std::string::npos)
+        version.erase(version.find(' '), std::string::npos);
+
+    picojson::object doc;
+    doc["$schema"] = picojson::value(sarifSchema);
+    doc["runs"] = serializeRuns(productName, version);
+
+    // Insert "version" property at the start.
+    // From SARIF specification (https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/sarif-v2.1.0-errata01-os-complete.html#_Toc141790730):
+    // Although the order in which properties appear in a JSON object value is not semantically significant, the version property SHOULD appear first.
+
+    return "{\n  \"version\": \"" + std::string(sarifVersion) + "\"," + picojson::value(doc).serialize(true).substr(1);
+}
+
+std::string SarifReport::sarifSeverity(const ErrorMessage& errmsg)
+{
+    if (ErrorLogger::isCriticalErrorId(errmsg.id))
+        return "error";
+    switch (errmsg.severity) {
+    case Severity::error:
+    case Severity::warning:
+        return "error";
+    case Severity::style:
+    case Severity::portability:
+    case Severity::performance:
+        return "warning";
+    case Severity::information:
+    case Severity::internal:
+    case Severity::debug:
+    case Severity::none:
+        return "note";
+    }
+    return "note";
+}
+
+std::string SarifReport::sarifPrecision(const ErrorMessage& errmsg)
+{
+    if (errmsg.certainty == Certainty::inconclusive)
+        return "medium";
+    return "high";
+}
diff --git a/lib/sarifreport.h b/lib/sarifreport.h
new file mode 100644
index 00000000000..6baf88cb04d
--- /dev/null
+++ b/lib/sarifreport.h
@@ -0,0 +1,53 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SARIF_REPORT_H
+#define SARIF_REPORT_H
+
+#include "config.h"
+#include "errorlogger.h"
+
+#include <string>
+#include <vector>
+
+// Include picojson headers
+#include "json.h"
+
+class CPPCHECKLIB SarifReport {
+public:
+    SarifReport() = default;
+    ~SarifReport() = default;
+
+    void addFinding(ErrorMessage msg);
+    std::string serialize(std::string productName) const;
+
+private:
+    // Implementation methods
+    picojson::array serializeRules() const;
+    static picojson::array serializeLocations(const ErrorMessage& finding);
+    picojson::array serializeResults() const;
+    picojson::value serializeRuns(const std::string& productName, const std::string& version) const;
+
+    // Utility methods
+    static std::string sarifSeverity(const ErrorMessage& errmsg);
+    static std::string sarifPrecision(const ErrorMessage& errmsg);
+
+    std::vector<ErrorMessage> mFindings;
+};
+
+#endif // SARIF_REPORT_H
diff --git a/lib/settings.cpp b/lib/settings.cpp
index 443b5fdbd58..0708a37516b 100644
--- a/lib/settings.cpp
+++ b/lib/settings.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,11 +16,33 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "config.h"
 #include "settings.h"
+#include "path.h"
+#include "summaries.h"
+#include "suppressions.h"
+#include "vfvalue.h"
 
-#include "valueflow.h"
+#include <cctype>
+#include <cstdlib>
+#include <cstring>
+#include <fstream>
+#include <iostream>
+#include <utility>
 
-bool Settings::mTerminated;
+#include "json.h"
+
+#ifndef _WIN32
+#include <unistd.h> // for getpid()
+#else
+#include <process.h> // for getpid()
+#endif
+
+
+std::atomic<bool> Settings::mTerminated;
+
+const int Settings::maxConfigsNotAssigned = 0;
+const int Settings::maxConfigsDefault = 12;
 
 const char Settings::SafeChecks::XmlRootName[] = "safe-checks";
 const char Settings::SafeChecks::XmlClasses[] = "class-public";
@@ -28,43 +50,162 @@ const char Settings::SafeChecks::XmlExternalFunctions[] = "external-functions";
 const char Settings::SafeChecks::XmlInternalFunctions[] = "internal-functions";
 const char Settings::SafeChecks::XmlExternalVariables[] = "external-variables";
 
+static int getPid()
+{
+#ifndef _WIN32
+    return getpid();
+#else
+    return _getpid();
+#endif
+}
+
 Settings::Settings()
-    : mEnabled(0),
-      checkConfiguration(false),
-      checkLibrary(false),
-      checkHeaders(true),
-      checkUnusedTemplates(false),
-      debugSimplified(false),
-      debugnormal(false),
-      debugwarnings(false),
-      debugtemplate(false),
-      dump(false),
-      enforcedLang(None),
-      exceptionHandling(false),
-      exitCode(0),
-      experimental(false),
-      force(false),
-      inconclusive(false),
-      verification(false),
-      debugVerification(false),
-      inlineSuppressions(false),
-      jobs(1),
-      jointSuppressionReport(false),
-      loadAverage(0),
-      maxConfigs(12),
-      maxCtuDepth(2),
-      preprocessOnly(false),
-      quiet(false),
-      relativePaths(false),
-      reportProgress(false),
-      showtime(SHOWTIME_MODES::SHOWTIME_NONE),
-      verbose(false),
-      xml(false),
-      xml_version(2)
 {
+    severity.setEnabled(Severity::error, true);
+    certainty.setEnabled(Certainty::normal, true);
+    setCheckLevel(Settings::CheckLevel::exhaustive);
+    executor = defaultExecutor();
+    pid = getPid();
 }
 
-std::string Settings::addEnabled(const std::string &str)
+std::string Settings::loadCppcheckCfg(Settings& settings, Suppressions& suppressions, bool debug)
+{
+    static const std::string cfgFilename = "cppcheck.cfg";
+    std::string fileName;
+#ifdef FILESDIR
+    {
+        const std::string filesdirCfg = Path::join(FILESDIR, cfgFilename);
+        if (debug)
+            std::cout << "looking for '" << filesdirCfg << "'" << std::endl;
+        if (Path::isFile(filesdirCfg))
+            fileName = filesdirCfg;
+    }
+#endif
+    // cppcheck-suppress knownConditionTrueFalse
+    if (fileName.empty()) {
+        // TODO: make sure that exename is set
+        fileName = Path::join(Path::getPathFromFilename(settings.exename), cfgFilename);
+        if (debug)
+            std::cout << "looking for '" << fileName << "'" << std::endl;
+        if (!Path::isFile(fileName))
+        {
+            if (debug)
+                std::cout << "no configuration found" << std::endl;
+            return "";
+        }
+    }
+
+    std::ifstream fin(fileName);
+    if (!fin.is_open())
+        return "could not open file";
+    picojson::value json;
+    fin >> json;
+    {
+        const std::string& lastErr = picojson::get_last_error();
+        if (!lastErr.empty())
+            return "not a valid JSON - " + lastErr;
+    }
+    const picojson::object& obj = json.get<picojson::object>();
+    {
+        const auto it = obj.find("productName");
+        if (it != obj.cend()) {
+            const auto& v = it->second;
+            if (!v.is<std::string>())
+                return "'productName' is not a string";
+            settings.cppcheckCfgProductName = v.get<std::string>();
+        }
+    }
+    {
+        const auto it = obj.find("manualUrl");
+        if (it != obj.cend()) {
+            const auto& v = it->second;
+            if (!v.is<std::string>())
+                return "'manualUrl' is not a string";
+            settings.manualUrl = v.get<std::string>();
+        }
+    }
+    {
+        const auto it = obj.find("about");
+        if (it != obj.cend()) {
+            const auto& v = it->second;
+            if (!v.is<std::string>())
+                return "'about' is not a string";
+            settings.cppcheckCfgAbout = v.get<std::string>();
+        }
+    }
+    {
+        const auto it = obj.find("addons");
+        if (it != obj.cend()) {
+            const auto& entry = it->second;
+            if (!entry.is<picojson::array>())
+                return "'addons' is not an array";
+            for (const picojson::value &v : entry.get<picojson::array>())
+            {
+                if (!v.is<std::string>())
+                    return "'addons' array entry is not a string";
+                const std::string &s = v.get<std::string>();
+                if (!Path::isAbsolute(s))
+                    settings.addons.emplace(Path::join(Path::getPathFromFilename(fileName), s));
+                else
+                    settings.addons.emplace(s);
+            }
+        }
+    }
+    {
+        const auto it = obj.find("suppressions");
+        if (it != obj.cend()) {
+            const auto& entry = it->second;
+            if (!entry.is<picojson::array>())
+                return "'suppressions' is not an array";
+            for (const picojson::value &v : entry.get<picojson::array>())
+            {
+                if (!v.is<std::string>())
+                    return "'suppressions' array entry is not a string";
+                const std::string &s = v.get<std::string>();
+                const std::string err = suppressions.nomsg.addSuppressionLine(s);
+                if (!err.empty())
+                    return "could not parse suppression '" + s + "' - " + err;
+            }
+        }
+    }
+    {
+        const auto it = obj.find("safety");
+        if (it != obj.cend()) {
+            const auto& v = it->second;
+            if (!v.is<bool>())
+                return "'safety' is not a bool";
+            settings.safety = v.get<bool>();
+        }
+    }
+
+    settings.settingsFiles.emplace_back(std::move(fileName));
+
+    return "";
+}
+
+std::pair<std::string, std::string> Settings::getNameAndVersion(const std::string& productName) {
+    if (productName.empty())
+        return {};
+    const std::string::size_type pos1 = productName.rfind(' ');
+    if (pos1 == std::string::npos)
+        return {};
+    if (pos1 + 2 >= productName.length())
+        return {};
+    for (auto pos2 = pos1 + 1; pos2 < productName.length(); ++pos2) {
+        const char c = productName[pos2];
+        const char prev = productName[pos2-1];
+        if (std::isdigit(c))
+            continue;
+        if (c == '.' && std::isdigit(prev))
+            continue;
+        if (c == 's' && pos2 + 1 == productName.length() && std::isdigit(prev))
+            continue;
+        return {};
+    }
+    return {productName.substr(0, pos1), productName.substr(pos1+1)};
+}
+
+std::string Settings::parseEnabled(const std::string &str, std::tuple<SimpleEnableGroup<Severity>, SimpleEnableGroup<Checks>> &groups)
 {
     // Enable parameters may be comma separated...
     if (str.find(',') != std::string::npos) {
@@ -72,79 +213,558 @@ std::string Settings::addEnabled(const std::string &str)
         std::string::size_type pos = 0;
         while ((pos = str.find(',', pos)) != std::string::npos) {
             if (pos == prevPos)
-                return std::string("cppcheck: --enable parameter is empty");
-            const std::string errmsg(addEnabled(str.substr(prevPos, pos - prevPos)));
+                return std::string("--enable parameter is empty");
+            std::string errmsg(parseEnabled(str.substr(prevPos, pos - prevPos), groups));
             if (!errmsg.empty())
                 return errmsg;
             ++pos;
             prevPos = pos;
         }
         if (prevPos >= str.length())
-            return std::string("cppcheck: --enable parameter is empty");
-        return addEnabled(str.substr(prevPos));
+            return std::string("--enable parameter is empty");
+        return parseEnabled(str.substr(prevPos), groups);
     }
 
+    auto& severity = std::get<0>(groups);
+    auto& checks = std::get<1>(groups);
+
     if (str == "all") {
-        mEnabled |= WARNING | STYLE | PERFORMANCE | PORTABILITY | INFORMATION | UNUSED_FUNCTION | MISSING_INCLUDE;
+        // "error" is always enabled and cannot be controlled - so exclude it from "all"
+        SimpleEnableGroup<Severity> newSeverity;
+        newSeverity.fill();
+        newSeverity.disable(Severity::error);
+        severity.enable(newSeverity);
+        checks.enable(Checks::missingInclude);
+        checks.enable(Checks::unusedFunction);
     } else if (str == "warning") {
-        mEnabled |= WARNING;
+        severity.enable(Severity::warning);
     } else if (str == "style") {
-        mEnabled |= STYLE;
+        severity.enable(Severity::style);
     } else if (str == "performance") {
-        mEnabled |= PERFORMANCE;
+        severity.enable(Severity::performance);
     } else if (str == "portability") {
-        mEnabled |= PORTABILITY;
+        severity.enable(Severity::portability);
     } else if (str == "information") {
-        mEnabled |= INFORMATION | MISSING_INCLUDE;
+        severity.enable(Severity::information);
     } else if (str == "unusedFunction") {
-        mEnabled |= UNUSED_FUNCTION;
+        checks.enable(Checks::unusedFunction);
     } else if (str == "missingInclude") {
-        mEnabled |= MISSING_INCLUDE;
+        checks.enable(Checks::missingInclude);
     }
 #ifdef CHECK_INTERNAL
     else if (str == "internal") {
-        mEnabled |= INTERNAL;
+        checks.enable(Checks::internalCheck);
     }
 #endif
     else {
+        // the actual option is prepending in the applyEnabled() call
         if (str.empty())
-            return std::string("cppcheck: --enable parameter is empty");
-        else
-            return std::string("cppcheck: there is no --enable parameter with the name '" + str + "'");
+            return " parameter is empty";
+        return " parameter with the unknown name '" + str + "'";
     }
 
-    return std::string();
+    return "";
 }
 
-bool Settings::isEnabled(Severity::SeverityType severity) const
+std::string Settings::addEnabled(const std::string &str)
 {
-    switch (severity) {
-    case Severity::none:
-        return true;
-    case Severity::error:
-        return true;
-    case Severity::warning:
-        return isEnabled(WARNING);
-    case Severity::style:
-        return isEnabled(STYLE);
-    case Severity::performance:
-        return isEnabled(PERFORMANCE);
-    case Severity::portability:
-        return isEnabled(PORTABILITY);
-    case Severity::information:
-        return isEnabled(INFORMATION);
-    case Severity::debug:
-        return false;
-    default:
-        return false;
+    return applyEnabled(str, true);
+}
+
+std::string Settings::removeEnabled(const std::string &str)
+{
+    return applyEnabled(str, false);
+}
+
+std::string Settings::applyEnabled(const std::string &str, bool enable)
+{
+    std::tuple<SimpleEnableGroup<Severity>, SimpleEnableGroup<Checks>> groups;
+    std::string errmsg = parseEnabled(str, groups);
+    if (!errmsg.empty())
+        return (enable ? "--enable" : "--disable") + errmsg;
+
+    const auto s = std::get<0>(groups);
+    const auto c = std::get<1>(groups);
+    if (enable) {
+        severity.enable(s);
+        checks.enable(c);
     }
+    else {
+        severity.disable(s);
+        checks.disable(c);
+    }
+    // FIXME: hack to make sure "error" is always enabled
+    severity.enable(Severity::error);
+    return {};
 }
 
 bool Settings::isEnabled(const ValueFlow::Value *value, bool inconclusiveCheck) const
 {
-    if (!isEnabled(Settings::WARNING) && (value->condition || value->defaultArg))
+    if (!severity.isEnabled(Severity::warning) && (value->condition || value->defaultArg))
         return false;
-    if (!inconclusive && (inconclusiveCheck || value->isInconclusive()))
+    if (!certainty.isEnabled(Certainty::inconclusive) && (inconclusiveCheck || value->isInconclusive()))
         return false;
     return true;
 }
+
+void Settings::loadSummaries()
+{
+    Summaries::loadReturn(buildDir, summaryReturn);
+}
+
+void Settings::setCheckLevel(CheckLevel level)
+{
+    if (level == CheckLevel::reduced) {
+        // Checking should finish quickly.
+        checkLevel = level;
+        vfOptions.maxSubFunctionArgs = 8;
+        vfOptions.maxIfCount = 100;
+        vfOptions.doConditionExpressionAnalysis = false;
+        vfOptions.maxForwardBranches = 4;
+        vfOptions.maxIterations = 1;
+    }
+    else if (level == CheckLevel::normal) {
+        // Checking should finish in reasonable time.
+        checkLevel = level;
+        vfOptions.maxSubFunctionArgs = 8;
+        vfOptions.maxIfCount = 100;
+        vfOptions.doConditionExpressionAnalysis = false;
+        vfOptions.maxForwardBranches = 4;
+    }
+    else if (level == CheckLevel::exhaustive) {
+        // Checking can take a little while. ~ 10 times slower than normal analysis is OK.
+        checkLevel = CheckLevel::exhaustive;
+        vfOptions.maxIfCount = -1;
+        vfOptions.maxSubFunctionArgs = 256;
+        vfOptions.doConditionExpressionAnalysis = true;
+        vfOptions.maxForwardBranches = -1;
+    }
+}
+
+// These tables are auto generated from Cppcheck Premium script
+
+static const std::set<std::string> autosarCheckers{
+    "accessMoved",
+    "argumentSize",
+    "arrayIndexOutOfBounds",
+    "arrayIndexOutOfBoundsCond",
+    "arrayIndexThenCheck",
+    "bufferAccessOutOfBounds",
+    "comparePointers",
+    "constParameter",
+    "ctuOneDefinitionRuleViolation",
+    "doubleFree",
+    "duplInheritedMember",
+    "duplicateBreak",
+    "exceptThrowInDestructor",
+    "funcArgNamesDifferent",
+    "functionConst",
+    "functionStatic",
+    "invalidContainer",
+    "memleak",
+    "mismatchAllocDealloc",
+    "missingReturn",
+    "negativeIndex",
+    "noExplicitConstructor",
+    "nullPointer",
+    "nullPointerArithmetic",
+    "nullPointerArithmeticRedundantCheck",
+    "nullPointerDefaultArg",
+    "nullPointerRedundantCheck",
+    "objectIndex",
+    "overlappingWriteFunction",
+    "overlappingWriteUnion",
+    "pointerOutOfBounds",
+    "pointerOutOfBoundsCond",
+    "preprocessorErrorDirective",
+    "redundantAssignment",
+    "redundantInitialization",
+    "returnDanglingLifetime",
+    "shadowArgument",
+    "shadowFunction",
+    "shadowVariable",
+    "shiftTooManyBits",
+    "sizeofFunctionCall",
+    "throwInNoexceptFunction",
+    "uninitMemberVar",
+    "uninitdata",
+    "unreachableCode",
+    "unreadVariable",
+    "unsignedLessThanZero",
+    "unusedFunction",
+    "unusedStructMember",
+    "unusedVariable",
+    "useInitializationList",
+    "variableScope",
+    "virtualCallInConstructor",
+    "zerodiv",
+    "zerodivcond"
+};
+
+static const std::set<std::string> certCCheckers{
+    "IOWithoutPositioning",
+    "argumentSize",
+    "arrayIndexOutOfBounds",
+    "arrayIndexOutOfBoundsCond",
+    "arrayIndexThenCheck",
+    "autoVariables",
+    "autovarInvalidDeallocation",
+    "bitwiseOnBoolean",
+    "bufferAccessOutOfBounds",
+    "comparePointers",
+    "danglingLifetime",
+    "deallocret",
+    "deallocuse",
+    "doubleFree",
+    "floatConversionOverflow",
+    "integerOverflow",
+    "invalidFunctionArg",
+    "invalidLengthModifierError",
+    "invalidLifetime",
+    "invalidScanfFormatWidth",
+    "invalidscanf",
+    "leakReturnValNotUsed",
+    "leakUnsafeArgAlloc",
+    "memleak",
+    "memleakOnRealloc",
+    "mismatchAllocDealloc",
+    "missingReturn",
+    "negativeIndex",
+    "nullPointer",
+    "nullPointerArithmetic",
+    "nullPointerArithmeticRedundantCheck",
+    "nullPointerDefaultArg",
+    "nullPointerRedundantCheck",
+    "objectIndex",
+    "pointerOutOfBounds",
+    "pointerOutOfBoundsCond",
+    "preprocessorErrorDirective",
+    "resourceLeak",
+    "returnDanglingLifetime",
+    "sizeofCalculation",
+    "stringLiteralWrite",
+    "uninitStructMember",
+    "uninitdata",
+    "uninitvar",
+    "unknownEvaluationOrder",
+    "useClosedFile",
+    "wrongPrintfScanfArgNum",
+    "wrongPrintfScanfParameterPositionError"
+};
+
+static const std::set<std::string> certCppCheckers{
+    "IOWithoutPositioning",
+    "accessMoved",
+    "argumentSize",
+    "arrayIndexOutOfBounds",
+    "arrayIndexOutOfBoundsCond",
+    "arrayIndexThenCheck",
+    "autoVariables",
+    "autovarInvalidDeallocation",
+    "bitwiseOnBoolean",
+    "bufferAccessOutOfBounds",
+    "comparePointers",
+    "containerOutOfBounds",
+    "ctuOneDefinitionRuleViolation",
+    "danglingLifetime",
+    "danglingReference",
+    "danglingTempReference",
+    "danglingTemporaryLifetime",
+    "deallocret",
+    "deallocuse",
+    "doubleFree",
+    "eraseDereference",
+    "exceptDeallocThrow",
+    "exceptThrowInDestructor",
+    "floatConversionOverflow",
+    "initializerList",
+    "integerOverflow",
+    "invalidContainer",
+    "invalidFunctionArg",
+    "invalidLengthModifierError",
+    "invalidLifetime",
+    "invalidScanfFormatWidth",
+    "invalidscanf",
+    "leakReturnValNotUsed",
+    "leakUnsafeArgAlloc",
+    "memleak",
+    "memleakOnRealloc",
+    "mismatchAllocDealloc",
+    "missingReturn",
+    "negativeIndex",
+    "nullPointer",
+    "nullPointerArithmetic",
+    "nullPointerArithmeticRedundantCheck",
+    "nullPointerDefaultArg",
+    "nullPointerRedundantCheck",
+    "objectIndex",
+    "operatorEqToSelf",
+    "pointerOutOfBounds",
+    "pointerOutOfBoundsCond",
+    "preprocessorErrorDirective",
+    "resourceLeak",
+    "returnDanglingLifetime",
+    "sizeofCalculation",
+    "stringLiteralWrite",
+    "uninitStructMember",
+    "uninitdata",
+    "uninitvar",
+    "useClosedFile",
+    "virtualCallInConstructor",
+    "virtualDestructor",
+    "wrongPrintfScanfArgNum",
+    "wrongPrintfScanfParameterPositionError"
+};
+
+static const std::set<std::string> misrac2012Checkers{
+    "argumentSize",
+    "autovarInvalidDeallocation",
+    "bufferAccessOutOfBounds",
+    "comparePointers",
+    "compareValueOutOfTypeRangeError",
+    "constParameterPointer",
+    "constStatement",
+    "danglingLifetime",
+    "danglingTemporaryLifetime",
+    "duplicateBreak",
+    "funcArgNamesDifferent",
+    "incompatibleFileOpen",
+    "invalidFunctionArg",
+    "knownConditionTrueFalse",
+    "leakNoVarFunctionCall",
+    "leakReturnValNotUsed",
+    "memleak",
+    "memleakOnRealloc",
+    "missingReturn",
+    "overlappingWriteFunction",
+    "overlappingWriteUnion",
+    "pointerOutOfBounds",
+    "preprocessorErrorDirective",
+    "redundantAssignInSwitch",
+    "redundantAssignment",
+    "redundantCondition",
+    "resourceLeak",
+    "returnDanglingLifetime",
+    "shadowVariable",
+    "sizeofCalculation",
+    "sizeofwithsilentarraypointer",
+    "syntaxError",
+    "uninitvar",
+    "unknownEvaluationOrder",
+    "unreachableCode",
+    "unreadVariable",
+    "unusedFunction",
+    "unusedLabel",
+    "unusedVariable",
+    "useClosedFile",
+    "writeReadOnlyFile"
+};
+
+static const std::set<std::string> misrac2023Checkers{
+    "argumentSize",
+    "autovarInvalidDeallocation",
+    "bufferAccessOutOfBounds",
+    "comparePointers",
+    "compareValueOutOfTypeRangeError",
+    "constParameterPointer",
+    "constStatement",
+    "danglingLifetime",
+    "danglingTemporaryLifetime",
+    "duplicateBreak",
+    "funcArgNamesDifferent",
+    "incompatibleFileOpen",
+    "invalidFunctionArg",
+    "knownConditionTrueFalse",
+    "leakNoVarFunctionCall",
+    "leakReturnValNotUsed",
+    "memleak",
+    "memleakOnRealloc",
+    "missingReturn",
+    "overlappingWriteFunction",
+    "overlappingWriteUnion",
+    "pointerOutOfBounds",
+    "preprocessorErrorDirective",
+    "redundantAssignInSwitch",
+    "redundantAssignment",
+    "redundantCondition",
+    "resourceLeak",
+    "returnDanglingLifetime",
+    "shadowVariable",
+    "sizeofCalculation",
+    "sizeofwithsilentarraypointer",
+    "syntaxError",
+    "uninitvar",
+    "unknownEvaluationOrder",
+    "unreachableCode",
+    "unreadVariable",
+    "unusedFunction",
+    "unusedLabel",
+    "unusedVariable",
+    "useClosedFile",
+    "writeReadOnlyFile"
+};
+
+static const std::set<std::string> misrac2025Checkers{
+    "argumentSize",
+    "autovarInvalidDeallocation",
+    "bufferAccessOutOfBounds",
+    "comparePointers",
+    "compareValueOutOfTypeRangeError",
+    "constParameterPointer",
+    "constStatement",
+    "danglingLifetime",
+    "danglingTemporaryLifetime",
+    "duplicateBreak",
+    "funcArgNamesDifferent",
+    "incompatibleFileOpen",
+    "invalidFunctionArg",
+    "knownConditionTrueFalse",
+    "leakNoVarFunctionCall",
+    "leakReturnValNotUsed",
+    "memleak",
+    "memleakOnRealloc",
+    "missingReturn",
+    "overlappingWriteFunction",
+    "overlappingWriteUnion",
+    "pointerOutOfBounds",
+    "preprocessorErrorDirective",
+    "redundantAssignInSwitch",
+    "redundantAssignment",
+    "redundantCondition",
+    "resourceLeak",
+    "returnDanglingLifetime",
+    "shadowVariable",
+    "sizeofCalculation",
+    "sizeofwithsilentarraypointer",
+    "syntaxError",
+    "uninitvar",
+    "unknownEvaluationOrder",
+    "unreachableCode",
+    "unreadVariable",
+    "unusedFunction",
+    "unusedLabel",
+    "unusedVariable",
+    "useClosedFile",
+    "writeReadOnlyFile"
+};
+
+static const std::set<std::string> misracpp2008Checkers{
+    "autoVariables",
+    "comparePointers",
+    "constParameter",
+    "constVariable",
+    "cstyleCast",
+    "ctuOneDefinitionRuleViolation",
+    "dangerousTypeCast",
+    "danglingLifetime",
+    "duplInheritedMember",
+    "duplicateBreak",
+    "exceptThrowInDestructor",
+    "funcArgNamesDifferent",
+    "functionConst",
+    "functionStatic",
+    "missingReturn",
+    "noExplicitConstructor",
+    "overlappingWriteFunction",
+    "overlappingWriteUnion",
+    "pointerOutOfBounds",
+    "preprocessorErrorDirective",
+    "redundantAssignment",
+    "redundantInitialization",
+    "returnReference",
+    "returnTempReference",
+    "shadowVariable",
+    "shiftTooManyBits",
+    "sizeofFunctionCall",
+    "uninitDerivedMemberVar",
+    "uninitDerivedMemberVarPrivate",
+    "uninitMemberVar",
+    "uninitMemberVarPrivate",
+    "uninitStructMember",
+    "uninitdata",
+    "uninitvar",
+    "unknownEvaluationOrder",
+    "unreachableCode",
+    "unreadVariable",
+    "unsignedLessThanZero",
+    "unusedFunction",
+    "unusedStructMember",
+    "unusedVariable",
+    "variableScope",
+    "virtualCallInConstructor"
+};
+
+static const std::set<std::string> misracpp2023Checkers{
+    "accessForwarded",
+    "accessMoved",
+    "autoVariables",
+    "compareBoolExpressionWithInt",
+    "comparePointers",
+    "compareValueOutOfTypeRangeError",
+    "constParameter",
+    "constParameterReference",
+    "ctuOneDefinitionRuleViolation",
+    "danglingLifetime",
+    "floatConversionOverflow",
+    "identicalConditionAfterEarlyExit",
+    "identicalInnerCondition",
+    "ignoredReturnValue",
+    "invalidFunctionArg",
+    "invalidFunctionArgBool",
+    "invalidFunctionArgStr",
+    "knownConditionTrueFalse",
+    "missingReturn",
+    "noExplicitConstructor",
+    "operatorEqToSelf",
+    "overlappingWriteUnion",
+    "pointerOutOfBounds",
+    "pointerOutOfBoundsCond",
+    "preprocessorErrorDirective",
+    "redundantAssignInSwitch",
+    "redundantAssignment",
+    "redundantCopy",
+    "redundantInitialization",
+    "shadowVariable",
+    "subtractPointers",
+    "syntaxError",
+    "uninitMemberVar",
+    "uninitvar",
+    "unknownEvaluationOrder",
+    "unreachableCode",
+    "unreadVariable",
+    "virtualCallInConstructor"
+};
+
+bool Settings::isPremiumEnabled(const char id[]) const
+{
+    if (premiumArgs.find("autosar") != std::string::npos && autosarCheckers.count(id))
+        return true;
+    if (premiumArgs.find("cert-c-") != std::string::npos && certCCheckers.count(id))
+        return true;
+    if (premiumArgs.find("cert-c++") != std::string::npos && certCppCheckers.count(id))
+        return true;
+    if (premiumArgs.find("misra-c-") != std::string::npos && (misrac2012Checkers.count(id) || misrac2023Checkers.count(id) || misrac2025Checkers.count(id)))
+        return true;
+    if (premiumArgs.find("misra-c++-2008") != std::string::npos && misracpp2008Checkers.count(id))
+        return true;
+    if (premiumArgs.find("misra-c++-2023") != std::string::npos && misracpp2023Checkers.count(id))
+        return true;
+    return false;
+}
+
+Settings::ExecutorType Settings::defaultExecutor()
+{
+    static constexpr ExecutorType defaultExecutor =
+#if defined(HAS_THREADING_MODEL_FORK)
+        ExecutorType::Process;
+#elif defined(HAS_THREADING_MODEL_THREAD)
+        ExecutorType::Thread;
+#endif
+    return defaultExecutor;
+}
+
+bool Settings::unusedFunctionOnly()
+{
+    const char* unusedFunctionOnly = std::getenv("UNUSEDFUNCTION_ONLY");
+    return unusedFunctionOnly && (std::strcmp(unusedFunctionOnly, "1") == 0);
+}
diff --git a/lib/settings.h b/lib/settings.h
index c2bc8da466d..24fa2e93907 100644
--- a/lib/settings.h
+++ b/lib/settings.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,20 +21,37 @@
 #define settingsH
 //---------------------------------------------------------------------------
 
+#include "addoninfo.h"
 #include "config.h"
-#include "errorlogger.h"
-#include "importproject.h"
+#include "errortypes.h"
 #include "library.h"
 #include "platform.h"
 #include "standards.h"
-#include "suppressions.h"
-#include "timer.h"
+#include "checkers.h"
 
+#include <algorithm>
+#include <atomic>
+#include <cstdint>
 #include <list>
 #include <set>
 #include <string>
+#include <tuple>
 #include <vector>
+#include <unordered_set>
+#include <utility>
 
+#if defined(USE_WINDOWS_SEH) || defined(USE_UNIX_SIGNAL_HANDLING)
+#include <cstdio>
+#endif
+
+#ifdef HAVE_RULES
+#include <memory>
+
+class Regex;
+#endif
+
+struct Suppressions;
+enum class ShowTime : std::uint8_t;
 namespace ValueFlow {
     class Value;
 }
@@ -42,170 +59,229 @@ namespace ValueFlow {
 /// @addtogroup Core
 /// @{
 
+template<typename T>
+class SimpleEnableGroup {
+    uint32_t mFlags = 0;
+public:
+    uint32_t intValue() const {
+        return mFlags;
+    }
+    void clear() {
+        mFlags = 0;
+    }
+    void fill() {
+        mFlags = 0xFFFFFFFF;
+    }
+    bool isEnabled(T flag) const {
+        return (mFlags & (1U << static_cast<uint32_t>(flag))) != 0;
+    }
+    void enable(T flag) {
+        mFlags |= (1U << static_cast<uint32_t>(flag));
+    }
+    void enable(SimpleEnableGroup<T> group) {
+        mFlags |= group.intValue();
+    }
+    void disable(T flag) {
+        mFlags &= ~(1U << static_cast<uint32_t>(flag));
+    }
+    void disable(SimpleEnableGroup<T> group) {
+        mFlags &= ~(group.intValue());
+    }
+    void setEnabled(T flag, bool enabled) {
+        if (enabled)
+            enable(flag);
+        else
+            disable(flag);
+    }
+};
+
+
 /**
  * @brief This is just a container for general settings so that we don't need
  * to pass individual values to functions or constructors now or in the
  * future when we might have even more detailed settings.
  */
-class CPPCHECKLIB Settings : public cppcheck::Platform {
-public:
-    enum EnabledGroup {
-        WARNING = 0x1,
-        STYLE = 0x2,
-        PERFORMANCE = 0x4,
-        PORTABILITY = 0x8,
-        INFORMATION = 0x10,
-        UNUSED_FUNCTION = 0x20,
-        MISSING_INCLUDE = 0x40,
-        INTERNAL = 0x80
-    };
-
+// NOLINTNEXTLINE(clang-analyzer-optin.performance.Padding)
+class CPPCHECKLIB WARN_UNUSED Settings {
 private:
-    /** @brief enable extra checks by id */
-    int mEnabled;
 
     /** @brief terminate checking */
-    static bool mTerminated;
+    static std::atomic<bool> mTerminated;
 
 public:
     Settings();
 
-    std::list<std::string> addons;
+    static std::string loadCppcheckCfg(Settings& settings, Suppressions& suppressions, bool debug = false);
+
+    static std::pair<std::string, std::string> getNameAndVersion(const std::string& productName);
+
+    /** @brief Report type */
+    ReportType reportType = ReportType::normal;
+
+    /** @brief addons, either filename of python/json file or json data */
+    std::unordered_set<std::string> addons;
+
+    /** @brief the loaded addons infos */
+    std::vector<AddonInfo> addonInfos;
+
+    /** @brief Path to the python interpreter to be used to run addons. */
+    std::string addonPython;
+
+    /** @brief Analyze all configuration in Visual Studio project. */
+    bool analyzeAllVsConfigs{true};
 
     /** @brief Paths used as base for conversion to relative paths. */
     std::vector<std::string> basePaths;
 
-    /** @brief --cppcheck-build-dir */
+    /** @brief --cppcheck-build-dir. Always uses / as path separator. No trailing path separator. */
     std::string buildDir;
 
     /** Is the 'configuration checking' wanted? */
-    bool checkConfiguration;
-
-    /** Check for incomplete info in library files? */
-    bool checkLibrary;
+    bool checkConfiguration{};
 
     /**
      * Check code in the headers, this is on by default but can
      * be turned off to save CPU */
-    bool checkHeaders;
+    bool checkHeaders = true;
+
+    /** Check for incomplete info in library files? */
+    bool checkLibrary{};
+
+    /** @brief The maximum time in seconds for the checks of a single file */
+    int checksMaxTime{};
+
+    /** @brief --checkers-report=<filename> : Generate report of executed checkers */
+    std::string checkersReportFilename;
+
+    /** @brief check unknown function return values */
+    std::set<std::string> checkUnknownFunctionReturn; // TODO: move to Library?
+
+    /** Check unused/uninstantiated templates */
+    bool checkUnusedTemplates = true;
+
+    /** Use Clang */
+    bool clang{};
+
+    /** Custom Clang executable */
+    std::string clangExecutable = "clang";
+
+    /** Use clang-tidy */
+    bool clangTidy{};
 
-    /** Check unused templates */
-    bool checkUnusedTemplates;
+    /** Custom clang-tidy executable */
+    std::string clangTidyExecutable = "clang-tidy";
+
+    /** Internal: Clear the simplecpp non-existing include cache */
+    bool clearIncludeCache{}; // internal
 
     /** @brief include paths excluded from checking the configuration */
     std::set<std::string> configExcludePaths;
 
-    /** @brief Is --debug-simplified given? */
-    bool debugSimplified;
+    /** cppcheck.cfg: Custom product name */
+    std::string cppcheckCfgProductName;
 
-    /** @brief Is --debug-normal given? */
-    bool debugnormal;
+    /** cppcheck.cfg: About text */
+    std::string cppcheckCfgAbout;
 
-    /** @brief Is --debug-warnings given? */
-    bool debugwarnings;
+    /** @brief check Emacs marker to detect extension-less and *.h files as C++ */
+    bool cppHeaderProbe{};
 
-    /** @brief Is --debug-template given? */
-    bool debugtemplate;
+    /** @brief Are we running from DACA script? */
+    bool daca{};
 
-    /** @brief Is --dump given? */
-    bool dump;
-    std::string dumpFile;
+    /** @brief Is --debug-analyzerinfo given? */
+    bool debugainfo{};
 
-    enum Language {
-        None, C, CPP
-    };
+    /** @brief Is --debug-ast given? */
+    bool debugast{};
 
-    /** @brief Name of the language that is enforced. Empty per default. */
-    Language enforcedLang;
+    /** @brief Is --debug-clang-output given? */
+    bool debugClangOutput{};
 
-    /** @brief Is --exception-handling given */
-    bool exceptionHandling;
+    /** @brief Is --debug-ignore given? */
+    bool debugignore{};
 
-    // argv[0]
-    std::string exename;
+    /** @brief Internal: Is --debug-lookup or --debug-lookup=all given? */
+    bool debuglookup{};
 
-    /** @brief If errors are found, this value is returned from main().
-        Default value is 0. */
-    int exitCode;
+    /** @brief Internal: Is --debug-lookup=addon given? */
+    bool debuglookupAddon{};
 
-    /**
-     * When this flag is false (default) then experimental
-     * heuristics and checks are disabled.
-     *
-     * It should not be possible to enable this from any client.
-     */
-    bool experimental;
+    /** @brief Internal: Is --debug-lookup=config given? */
+    bool debuglookupConfig{};
 
-    /** @brief Force checking the files with "too many" configurations (--force). */
-    bool force;
+    /** @brief Internal: Is --debug-lookup=library given? */
+    bool debuglookupLibrary{};
 
-    /** @brief List of include paths, e.g. "my/includes/" which should be used
-        for finding include files inside source files. (-I) */
-    std::list<std::string> includePaths;
+    /** @brief Internal: Is --debug-lookup=platform given? */
+    bool debuglookupPlatform{};
 
-    /** @brief Inconclusive checks */
-    bool inconclusive;
+    /** @brief Is --debug-normal given? */
+    bool debugnormal{};
 
-    /** Do not only check how interface is used. Also check that interface is safe. */
-    class CPPCHECKLIB SafeChecks {
-    public:
-        SafeChecks() : classes(false), externalFunctions(false), internalFunctions(false), externalVariables(false) {}
+    /** @brief Is --debug-simplified given? */
+    bool debugSimplified{};
 
-        static const char XmlRootName[];
-        static const char XmlClasses[];
-        static const char XmlExternalFunctions[];
-        static const char XmlInternalFunctions[];
-        static const char XmlExternalVariables[];
+    /** @brief Is --debug-symdb given? */
+    bool debugsymdb{};
 
-        /**
-         * Public interface of classes
-         * - public function parameters can have any value
-         * - public functions can be called in any order
-         * - public variables can have any value
-         */
-        bool classes;
+    /** @brief Is --debug-template given? */
+    bool debugtemplate{};
 
-        /**
-         * External functions
-         * - external functions can be called in any order
-         * - function parameters can have any values
-         */
-        bool externalFunctions;
+    /** @brief Is --debug-valueflow given? */
+    bool debugvalueflow{};
 
-        /**
-         * Experimental: assume that internal functions can be used in any way
-         * This is only available in the GUI.
-         */
-        bool internalFunctions;
+    /** @brief Is --debug-warnings given? */
+    bool debugwarnings{};
 
-        /**
-         * Global variables that can be modified outside the TU.
-         * - Such variable can have "any" value
-         */
-        bool externalVariables;
+    /** @brief Is --dump given? */
+    bool dump{};
+
+    /** @brief Do not filter duplicated errors. */
+    bool emitDuplicates{};
+
+#if defined(USE_WINDOWS_SEH) || defined(USE_UNIX_SIGNAL_HANDLING)
+    /** @brief Is --exception-handling given */
+    bool exceptionHandling{};
+
+    FILE* exceptionOutput = stdout;
+#endif
+
+    enum class ExecutorType : std::uint8_t
+    {
+#ifdef HAS_THREADING_MODEL_THREAD
+        Thread,
+#endif
+#ifdef HAS_THREADING_MODEL_FORK
+        Process
+#endif
     };
 
-    SafeChecks safeChecks;
+    ExecutorType executor;
+
+    // argv[0]
+    std::string exename;
 
-    /** @brief Enable verification analysis */
-    bool verification;
+    /** @brief If errors are found, this value is returned from main().
+        Default value is 0. */
+    int exitCode{};
 
-    bool debugVerification;
+    /** @brief List of --file-filter for analyzing special files */
+    std::vector<std::string> fileFilters;
 
-    /** @brief check unknown function return values */
-    std::set<std::string> checkUnknownFunctionReturn;
+    /** @brief Force checking the files with "too many" configurations (--force). */
+    bool force{};
+
+    /** @brief List of include paths, e.g. "my/includes/" which should be used
+        for finding include files inside source files. (-I) */
+    std::list<std::string> includePaths;
 
     /** @brief Is --inline-suppr given? */
-    bool inlineSuppressions;
+    bool inlineSuppressions{};
 
     /** @brief How many processes/threads should do checking at the same
         time. Default is 1. (-j N) */
-    unsigned int jobs;
-
-    /** @brief Collect unmatched suppressions in one run.
-      * This delays the reporting until all files are checked.
-      * It is needed by checks that analyse the whole code base. */
-    bool jointSuppressionReport;
+    unsigned int jobs = 1;
 
     /** @brief --library= */
     std::list<std::string> libraries;
@@ -213,65 +289,158 @@ class CPPCHECKLIB Settings : public cppcheck::Platform {
     /** Library */
     Library library;
 
+#ifdef HAS_THREADING_MODEL_FORK
     /** @brief Load average value */
-    unsigned int loadAverage;
+    int loadAverage{};
+#endif
 
-    /** @brief Maximum number of configurations to check before bailing.
-        Default is 12. (--max-configs=N) */
-    unsigned int maxConfigs;
+    std::string manualUrl{"https://cppcheck.sourceforge.io/manual.pdf"};
 
-    /** @brief --max-ctu-depth */
-    int maxCtuDepth;
+    /** --max-configs value */
+    int maxConfigsOption = 0; // "Not Assigned" value
 
-    /** @brief suppress exitcode */
-    Suppressions nofail;
+    /** max configs from --project option */
+    int maxConfigsProject = 0; // "Not Assigned" value
 
-    /** @brief suppress message (--suppressions) */
-    Suppressions nomsg;
+    static const int maxConfigsNotAssigned;
+    static const int maxConfigsDefault;
+
+    bool isMaxConfigsAssigned() const {
+        return maxConfigsOption != maxConfigsNotAssigned || maxConfigsProject != maxConfigsNotAssigned;
+    }
+
+    /** @brief Maximum number of configurations to check before bailing. */
+    int getMaxConfigs() const {
+        if (force)
+            return 0x7fffffff;
+        if (maxConfigsOption != maxConfigsNotAssigned)
+            return maxConfigsOption;
+        if (maxConfigsProject != maxConfigsNotAssigned)
+            return maxConfigsProject;
+        if (!userDefines.empty())
+            return 1;
+        return maxConfigsDefault;
+    }
+
+    /** @brief --max-ctu-depth */
+    int maxCtuDepth = 2;
+
+    /** @brief max template recursion */
+    int maxTemplateRecursion = 100;
 
     /** @brief write results (--output-file=&lt;file&gt;) */
     std::string outputFile;
 
+    enum class OutputFormat : std::uint8_t {text, plist, sarif, xml};
+    OutputFormat outputFormat = OutputFormat::text;
+
+    Platform platform;
+
+    /** @brief pid of cppcheck. Intention is that this is set in the main process. */
+    int pid; // internal
+
     /** @brief plist output (--plist-output=&lt;dir&gt;) */
     std::string plistOutput;
 
-    /** @brief Using -E for debugging purposes */
-    bool preprocessOnly;
+    /** @brief Are we Cppcheck Premium */
+    bool premium{};
+
+    /** @brief Extra arguments for Cppcheck Premium addon */
+    std::string premiumArgs;
 
-    ImportProject project;
+    /** Is checker id enabled by premiumArgs */
+    bool isPremiumEnabled(const char id[]) const;
+
+    /** @brief Using -E for debugging purposes */
+    bool preprocessOnly{};
 
     /** @brief Is --quiet given? */
-    bool quiet;
+    bool quiet{};
 
     /** @brief Use relative paths in output. */
-    bool relativePaths;
+    bool relativePaths{};
 
     /** @brief --report-progress */
-    bool reportProgress;
+    int reportProgress{-1};
 
+#ifdef HAVE_RULES
     /** Rule */
-    class CPPCHECKLIB Rule {
-    public:
-        Rule()
-            : tokenlist("simple")         // use simple tokenlist
-            , id("rule")                  // default id
-            , severity(Severity::style) { // default severity
-        }
-
-        std::string tokenlist;
+    struct CPPCHECKLIB Rule {
+        std::string tokenlist = "normal"; // use normal tokenlist
         std::string pattern;
-        std::string id;
+        std::string id = "rule"; // default id
         std::string summary;
-        Severity::SeverityType severity;
+        Severity severity = Severity::style; // default severity
+        std::shared_ptr<Regex> regex;
     };
 
     /**
      * @brief Extra rules
      */
     std::list<Rule> rules;
+#endif
+
+    /**
+     * @brief Safety certified behavior
+     * Show checkers report when Cppcheck finishes
+     * Make cppcheck checking more strict about critical errors
+     * - returns nonzero if there is critical errors
+     * - a critical error id is not suppressed (by mistake?) with glob pattern
+     */
+    bool safety = false;
+
+    /** Do not only check how interface is used. Also check that interface is safe. */
+    struct CPPCHECKLIB SafeChecks {
+
+        static const char XmlRootName[];
+        static const char XmlClasses[];
+        static const char XmlExternalFunctions[];
+        static const char XmlInternalFunctions[];
+        static const char XmlExternalVariables[];
+
+        void clear() {
+            classes = externalFunctions = internalFunctions = externalVariables = false;
+        }
+
+        /**
+         * Public interface of classes
+         * - public function parameters can have any value
+         * - public functions can be called in any order
+         * - public variables can have any value
+         */
+        bool classes{};
+
+        /**
+         * External functions
+         * - external functions can be called in any order
+         * - function parameters can have any values
+         */
+        bool externalFunctions{};
+
+        /**
+         * Experimental: assume that internal functions can be used in any way
+         * This is only available in the GUI.
+         */
+        bool internalFunctions{};
+
+        /**
+         * Global variables that can be modified outside the TU.
+         * - Such variable can have "any" value
+         */
+        bool externalVariables{};
+    };
+
+    SafeChecks safeChecks;
+
+    /** @brief the files we successfully loaded settings from */
+    std::vector<std::string> settingsFiles;
+
+    SimpleEnableGroup<Severity> severity;
+    SimpleEnableGroup<Certainty> certainty;
+    SimpleEnableGroup<Checks> checks;
 
     /** @brief show timing information (--showtime=file|summary|top5) */
-    SHOWTIME_MODES showtime;
+    ShowTime showtime{};
 
     /** Struct contains standards settings */
     Standards standards;
@@ -284,6 +453,15 @@ class CPPCHECKLIB Settings : public cppcheck::Platform {
      *  text mode, e.g. "{file}:{line} {info}" */
     std::string templateLocation;
 
+    /** @brief The maximum time in seconds for the template instantiation */
+    std::size_t templateMaxTime{};
+
+    /** @brief The maximum time in seconds for the typedef simplification */
+    std::size_t typedefMaxTime{};
+
+    /** @brief Error IDs which should not be reported as unmatchedSuppression */
+    std::vector<std::string> unmatchedSuppressionFilters;
+
     /** @brief defines given by the user */
     std::string userDefines;
 
@@ -293,26 +471,57 @@ class CPPCHECKLIB Settings : public cppcheck::Platform {
     /** @brief forced includes given by the user */
     std::list<std::string> userIncludes;
 
-    /** @brief Is --verbose given? */
-    bool verbose;
+    // TODO: adjust all options so 0 means "disabled" and -1 "means "unlimited"
+    struct ValueFlowOptions
+    {
+        /** @brief the maximum iterations to execute */
+        std::size_t maxIterations = 4;
+
+        /** @brief maximum numer if-branches */
+        int maxIfCount = -1;
+
+        /** @brief maximum number of sets of arguments to pass to subfuncions */
+        int maxSubFunctionArgs = 256;
+
+        /** @brief Experimental: maximum execution time */
+        int maxTime = -1;
 
-    /** @brief write XML results (--xml) */
-    bool xml;
+        /** @brief Control if condition expression analysis is performed */
+        bool doConditionExpressionAnalysis = true;
+
+        /** @brief Maximum performed for-loop count */
+        int maxForLoopCount = 10000;
+
+        /** @brief Maximum performed forward branches */
+        int maxForwardBranches = -1;
+
+        /** @brief Maximum performed alignof recursion */
+        int maxAlignOfRecursion = 100;
+
+        /** @brief Maximum performed sizeof recursion */
+        int maxSizeOfRecursion = 100;
+
+        /** @brief Maximum expression varid depth */
+        int maxExprVarIdDepth = 4;
+    };
+
+    /** @brief The ValueFlow options */
+    ValueFlowOptions vfOptions;
+
+    /** @brief Is --verbose given? */
+    bool verbose{};
 
     /** @brief XML version (--xml-version=..) */
-    int xml_version;
+    int xml_version = 2; // TODO: integrate into outputFormat enum?
 
     /**
      * @brief return true if a included file is to be excluded in Preprocessor::getConfigs
      * @return true for the file to be excluded.
      */
     bool configurationExcluded(const std::string &file) const {
-        for (const std::string & configExcludePath : configExcludePaths) {
-            if (file.length()>=configExcludePath.length() && file.compare(0,configExcludePath.length(),configExcludePath)==0) {
-                return true;
-            }
-        }
-        return false;
+        return std::any_of(configExcludePaths.begin(), configExcludePaths.end(), [&file](const std::string& path) {
+            return file.length() >= path.length() && file.compare(0, path.length(), path) == 0;
+        });
     }
 
     /**
@@ -324,37 +533,22 @@ class CPPCHECKLIB Settings : public cppcheck::Platform {
     std::string addEnabled(const std::string &str);
 
     /**
-     * @brief Disables all severities, except from error.
+     * @brief Disable extra checks by id
+     * @param str single id or list of id values to be enabled
+     * or empty string to enable all. e.g. "style,possibleError"
+     * @return error message. empty upon success
      */
-    void clearEnabled() {
-        mEnabled = 0;
-    }
+    std::string removeEnabled(const std::string &str);
 
     /**
-     * @brief Returns true if given id is in the list of
-     * enabled extra checks (--enable)
-     * @param group group to be enabled
-     * @return true if the check is enabled.
+     * @brief Returns true if given value can be shown
+     * @return true if the value can be shown
      */
-    bool isEnabled(EnabledGroup group) const {
-        return (mEnabled & group) == group;
-    }
-
-    /**
-    * @brief Returns true if given severity is enabled
-    * @return true if the check is enabled.
-    */
-    bool isEnabled(Severity::SeverityType severity) const;
-
-    /**
-    * @brief Returns true if given value can be shown
-    * @return true if the value can be shown
-    */
     bool isEnabled(const ValueFlow::Value *value, bool inconclusiveCheck=false) const;
 
-    /** Is posix library specified? */
-    bool posix() const {
-        return std::find(libraries.begin(), libraries.end(), "posix") != libraries.end();
+    /** Is library specified? */
+    bool hasLib(const std::string &lib) const {
+        return std::find(libraries.cbegin(), libraries.cend(), lib) != libraries.cend();
     }
 
     /** @brief Request termination of checking */
@@ -366,6 +560,31 @@ class CPPCHECKLIB Settings : public cppcheck::Platform {
     static bool terminated() {
         return Settings::mTerminated;
     }
+
+    std::set<std::string> summaryReturn;
+
+    void loadSummaries();
+
+    bool useSingleJob() const {
+        return jobs == 1;
+    }
+
+    enum class CheckLevel : std::uint8_t {
+        reduced,
+        normal,
+        exhaustive
+    };
+    CheckLevel checkLevel = CheckLevel::exhaustive;
+
+    void setCheckLevel(CheckLevel level);
+
+    static ExecutorType defaultExecutor();
+
+    static bool unusedFunctionOnly();
+
+private:
+    static std::string parseEnabled(const std::string &str, std::tuple<SimpleEnableGroup<Severity>, SimpleEnableGroup<Checks>> &groups);
+    std::string applyEnabled(const std::string &str, bool enable);
 };
 
 /// @}
diff --git a/lib/smallvector.h b/lib/smallvector.h
new file mode 100644
index 00000000000..b269ac7bbe1
--- /dev/null
+++ b/lib/smallvector.h
@@ -0,0 +1,70 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef smallvectorH
+#define smallvectorH
+
+#include <cstddef>
+
+static constexpr std::size_t DefaultSmallVectorSize = 3;
+
+#ifdef HAVE_BOOST
+#include <boost/container/small_vector.hpp> // IWYU pragma: export
+
+template<typename T, std::size_t N = DefaultSmallVectorSize>
+using SmallVector = boost::container::small_vector<T, N>;
+#else
+#include <utility>
+#include <vector>
+
+template<class T, std::size_t N>
+struct TaggedAllocator : std::allocator<T>
+{
+    template<class ... Ts>
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    TaggedAllocator(Ts && ... ts)
+        : std::allocator<T>(std::forward<Ts>(ts)...)
+    {}
+
+    template<class U>
+    // cppcheck-suppress noExplicitConstructor
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    TaggedAllocator(const TaggedAllocator<U, N> /*unused*/) {}
+
+    template<class U>
+    struct rebind
+    {
+        using other = TaggedAllocator<U, N>;
+    };
+};
+
+template<typename T, std::size_t N = DefaultSmallVectorSize>
+class SmallVector : public std::vector<T, TaggedAllocator<T, N>>
+{
+public:
+    template<class ... Ts>
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    SmallVector(Ts&&... ts)
+        : std::vector<T, TaggedAllocator<T, N>>(std::forward<Ts>(ts)...)
+    {
+        this->reserve(N);
+    }
+};
+#endif
+
+#endif
diff --git a/lib/sourcelocation.h b/lib/sourcelocation.h
new file mode 100644
index 00000000000..2555157ed21
--- /dev/null
+++ b/lib/sourcelocation.h
@@ -0,0 +1,98 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef sourcelocationH
+#define sourcelocationH
+
+#include "config.h"
+
+#ifdef __CPPCHECK__
+#define CPPCHECK_HAS_SOURCE_LOCATION 0
+#define CPPCHECK_HAS_SOURCE_LOCATION_TS 0
+#define CPPCHECK_HAS_SOURCE_LOCATION_INTRINSICS 0
+#else
+
+#if __has_include(<source_location>) && __cplusplus >= 202003L
+#define CPPCHECK_HAS_SOURCE_LOCATION 1
+#else
+#define CPPCHECK_HAS_SOURCE_LOCATION 0
+#endif
+#if __has_include(<experimental/source_location>) && __cplusplus >= 201402L
+#define CPPCHECK_HAS_SOURCE_LOCATION_TS 1
+#else
+#define CPPCHECK_HAS_SOURCE_LOCATION_TS 0
+#endif
+
+#if __has_builtin(__builtin_FILE)
+#define CPPCHECK_HAS_SOURCE_LOCATION_INTRINSICS 1
+#if !__has_builtin(__builtin_COLUMN)
+#define __builtin_COLUMN() 0
+#endif
+#else
+#define CPPCHECK_HAS_SOURCE_LOCATION_INTRINSICS 0
+#endif
+
+#endif
+
+#if CPPCHECK_HAS_SOURCE_LOCATION
+#include <source_location>
+using SourceLocation = std::source_location;
+#elif CPPCHECK_HAS_SOURCE_LOCATION_TS
+#include <experimental/source_location>
+using SourceLocation = std::experimental::source_location;
+#else
+#include <cstdint>
+struct SourceLocation {
+#if CPPCHECK_HAS_SOURCE_LOCATION_INTRINSICS
+    static SourceLocation current(std::uint_least32_t line = __builtin_LINE(),
+                                  std::uint_least32_t column = __builtin_COLUMN(),
+                                  const char* file_name = __builtin_FILE(),
+                                  const char* function_name = __builtin_FUNCTION())
+    {
+        SourceLocation result{};
+        result.m_line = line;
+        result.m_column = column;
+        result.m_file_name = file_name;
+        result.m_function_name = function_name;
+        return result;
+    }
+#else
+    static SourceLocation current() {
+        return SourceLocation();
+    }
+#endif
+    std::uint_least32_t m_line = 0;
+    std::uint_least32_t m_column = 0;
+    const char* m_file_name = "";
+    const char* m_function_name = "";
+    std::uint_least32_t line() const {
+        return m_line;
+    }
+    std::uint_least32_t column() const {
+        return m_column;
+    }
+    const char* file_name() const {
+        return m_file_name;
+    }
+    const char* function_name() const {
+        return m_function_name;
+    }
+};
+#endif
+
+#endif
diff --git a/lib/standards.cpp b/lib/standards.cpp
new file mode 100644
index 00000000000..a0ec72c1580
--- /dev/null
+++ b/lib/standards.cpp
@@ -0,0 +1,159 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "standards.h"
+#include "utils.h"
+
+#include <utility>
+
+#include <simplecpp.h>
+
+static Standards::cstd_t mapC(simplecpp::cstd_t cstd) {
+    switch (cstd)
+    {
+    case simplecpp::C89:
+        return Standards::C89;
+    case simplecpp::C99:
+        return Standards::C99;
+    case simplecpp::C11:
+        return Standards::C11;
+    case simplecpp::C17:
+        return Standards::C17;
+    case simplecpp::C23:
+        return Standards::C23;
+    case simplecpp::C2Y:
+        return Standards::C2Y;
+    case simplecpp::CUnknown:
+        return Standards::CLatest;
+    }
+    cppcheck::unreachable();
+}
+
+bool Standards::setC(std::string str)
+{
+    if (str.empty())
+        return false;
+    const simplecpp::cstd_t c_new = simplecpp::getCStd(str);
+    const bool b = (c_new != simplecpp::CUnknown);
+    if (b) {
+        c = mapC(c_new);
+        stdValueC = std::move(str);
+    }
+    return b;
+}
+
+std::string Standards::getC() const
+{
+    return getC(c);
+}
+
+std::string Standards::getC(cstd_t c_std)
+{
+    switch (c_std) {
+    case C89:
+        return "c89";
+    case C99:
+        return "c99";
+    case C11:
+        return "c11";
+    case C17:
+        return "c17";
+    case C23:
+        return "c23";
+    case C2Y:
+        return "c2y";
+    }
+    return "";
+}
+
+Standards::cstd_t Standards::getC(const std::string &std)
+{
+    return mapC(simplecpp::getCStd(std));
+}
+
+static Standards::cppstd_t mapCPP(simplecpp::cppstd_t cppstd) {
+    switch (cppstd)
+    {
+    case simplecpp::CPP03:
+        return Standards::CPP03;
+    case simplecpp::CPP11:
+        return Standards::CPP11;
+    case simplecpp::CPP14:
+        return Standards::CPP14;
+    case simplecpp::CPP17:
+        return Standards::CPP17;
+    case simplecpp::CPP20:
+        return Standards::CPP20;
+    case simplecpp::CPP23:
+        return Standards::CPP23;
+    case simplecpp::CPP26:
+        return Standards::CPP26;
+    case simplecpp::CPPUnknown:
+        return Standards::CPPLatest;
+    }
+    cppcheck::unreachable();
+}
+
+bool Standards::setCPP(std::string str)
+{
+    if (str.empty())
+        return false;
+    const simplecpp::cppstd_t cpp_new = simplecpp::getCppStd(str);
+    const bool b = (cpp_new != simplecpp::CPPUnknown);
+    if (b) {
+        cpp = mapCPP(cpp_new);
+        stdValueCPP = std::move(str);
+    }
+    return b;
+}
+
+std::string Standards::getCPP() const
+{
+    return getCPP(cpp);
+}
+
+std::string Standards::getCPP(cppstd_t std)
+{
+    switch (std) {
+    case CPP03:
+        return "c++03";
+    case CPP11:
+        return "c++11";
+    case CPP14:
+        return "c++14";
+    case CPP17:
+        return "c++17";
+    case CPP20:
+        return "c++20";
+    case CPP23:
+        return "c++23";
+    case CPP26:
+        return "c++26";
+    }
+    return "";
+}
+
+Standards::cppstd_t Standards::getCPP(const std::string &std)
+{
+    return mapCPP(simplecpp::getCppStd(std));
+}
+
+bool Standards::setStd(const std::string& str)
+{
+    return setC(str) || setCPP(str);
+}
diff --git a/lib/standards.h b/lib/standards.h
index 00ef313d848..d2c2a2b8e01 100644
--- a/lib/standards.h
+++ b/lib/standards.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,6 +21,9 @@
 #define standardsH
 //---------------------------------------------------------------------------
 
+#include "config.h"
+
+#include <cstdint>
 #include <string>
 
 /// @addtogroup Core
@@ -31,80 +34,30 @@
  * @brief This is just a container for standards settings.
  * This struct contains all possible standards that cppcheck recognize.
  */
-struct Standards {
-    /** C code C89/C99/C11 standard */
-    enum cstd_t { C89, C99, C11, CLatest=C11 } c;
+struct CPPCHECKLIB Standards {
+    enum Language : std::uint8_t { None, C, CPP };
+
+    /** C code standard */
+    enum cstd_t : std::uint8_t { C89, C99, C11, C17, C23, C2Y, CLatest = C2Y } c = CLatest;
 
     /** C++ code standard */
-    enum cppstd_t { CPP03, CPP11, CPP14, CPP17, CPP20, CPPLatest=CPP20 } cpp;
+    enum cppstd_t : std::uint8_t { CPP03, CPP11, CPP14, CPP17, CPP20, CPP23, CPP26, CPPLatest = CPP26 } cpp = CPPLatest;
+
+    /** --std value given on command line */
+    std::string stdValueC;
 
-    /** This constructor clear all the variables **/
-    Standards() : c(C11), cpp(CPPLatest) {}
+    /** --std value given on command line */
+    std::string stdValueCPP;
 
-    bool setC(const std::string& str) {
-        if (str == "c89" || str == "C89") {
-            c = C89;
-            return true;
-        }
-        if (str == "c99" || str == "C99") {
-            c = C99;
-            return true;
-        }
-        if (str == "c11" || str == "C11") {
-            c = C11;
-            return true;
-        }
-        return false;
-    }
-    const std::string getC() const {
-        switch (c) {
-        case C89:
-            return "c89";
-        case C99:
-            return "c99";
-        case C11:
-            return "c11";
-        }
-        return "";
-    }
-    bool setCPP(const std::string& str) {
-        if (str == "c++03" || str == "C++03") {
-            cpp = CPP03;
-            return true;
-        }
-        if (str == "c++11" || str == "C++11") {
-            cpp = CPP11;
-            return true;
-        }
-        if (str == "c++14" || str == "C++14") {
-            cpp = CPP14;
-            return true;
-        }
-        if (str == "c++17" || str == "C++17") {
-            cpp = CPP17;
-            return true;
-        }
-        if (str == "c++20" || str == "C++20") {
-            cpp = CPP20;
-            return true;
-        }
-        return false;
-    }
-    const std::string getCPP() const {
-        switch (cpp) {
-        case CPP03:
-            return "c++03";
-        case CPP11:
-            return "c++11";
-        case CPP14:
-            return "c++14";
-        case CPP17:
-            return "c++17";
-        case CPP20:
-            return "c++20";
-        }
-        return "";
-    }
+    bool setC(std::string str);
+    std::string getC() const;
+    static std::string getC(cstd_t c_std);
+    static cstd_t getC(const std::string &std);
+    bool setCPP(std::string str);
+    std::string getCPP() const;
+    static std::string getCPP(cppstd_t std);
+    static cppstd_t getCPP(const std::string &std);
+    bool setStd(const std::string& str);
 };
 
 /// @}
diff --git a/lib/summaries.cpp b/lib/summaries.cpp
new file mode 100644
index 00000000000..fa5399fd73d
--- /dev/null
+++ b/lib/summaries.cpp
@@ -0,0 +1,197 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "summaries.h"
+
+#include "analyzerinfo.h"
+#include "path.h"
+#include "settings.h"
+#include "symboldatabase.h"
+#include "token.h"
+#include "tokenize.h"
+#include "tokenlist.h"
+
+#include <algorithm>
+#include <fstream>
+#include <map>
+#include <sstream>
+#include <utility>
+#include <vector>
+
+
+
+std::string Summaries::create(const Tokenizer &tokenizer, const std::string &cfg, std::size_t fsFileId)
+{
+    const SymbolDatabase *symbolDatabase = tokenizer.getSymbolDatabase();
+    const Settings &settings = tokenizer.getSettings();
+
+    std::ostringstream ostr;
+    for (const Scope *scope : symbolDatabase->functionScopes) {
+        const Function *f = scope->function;
+        if (!f)
+            continue;
+
+        // Summarize function
+        std::set<std::string> noreturn;
+        std::set<std::string> globalVars;
+        std::set<std::string> calledFunctions;
+        for (const Token* tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
+            if (tok->variable() && tok->variable()->isGlobal())
+                globalVars.insert(tok->variable()->name());
+            if (Token::Match(tok, "%name% (") && !Token::simpleMatch(tok->linkAt(1), ") {")) {
+                calledFunctions.insert(tok->str());
+                if (Token::simpleMatch(tok->linkAt(1), ") ; }"))
+                    noreturn.insert(tok->str());
+            }
+        }
+
+        // Write summary for function
+        auto join = [](const std::set<std::string> &data) -> std::string {
+            std::string ret;
+            const char *sep = "";
+            for (const std::string &d: data)
+            {
+                ret += sep + d;
+                sep = ",";
+            }
+            return ret;
+        };
+
+        ostr << f->name();
+        if (!globalVars.empty())
+            ostr << " global:[" << join(globalVars) << "]";
+        if (!calledFunctions.empty())
+            ostr << " call:[" << join(calledFunctions) << "]";
+        if (!noreturn.empty())
+            ostr << " noreturn:[" << join(noreturn) << "]";
+        ostr << std::endl;
+    }
+
+    if (!settings.buildDir.empty()) {
+        std::string filename = AnalyzerInformation::getAnalyzerInfoFile(settings.buildDir, Path::simplifyPath(tokenizer.list.getSourceFilePath()), cfg, fsFileId);
+        const std::string::size_type pos = filename.rfind(".a");
+        if (pos != std::string::npos) {
+            filename[pos+1] = 's';
+            std::ofstream fout(filename);
+            fout << ostr.str();
+        }
+    }
+
+    return ostr.str();
+}
+
+
+
+
+static std::vector<std::string> getSummaryFiles(const std::string &filename)
+{
+    std::vector<std::string> ret;
+    std::ifstream fin(filename);
+    if (!fin.is_open())
+        return ret;
+    std::string line;
+    while (std::getline(fin, line)) {
+        const std::string::size_type dotA = line.find(".a");
+        const std::string::size_type colon = line.find(':');
+        if (colon > line.size() || dotA > colon)
+            continue;
+        std::string f = line.substr(0,colon);
+        f[dotA + 1] = 's';
+        ret.push_back(std::move(f));
+    }
+    return ret;
+}
+
+static std::vector<std::string> getSummaryData(const std::string &line, const std::string &data)
+{
+    std::vector<std::string> ret;
+    const std::string::size_type start = line.find(" " + data + ":[");
+    if (start == std::string::npos)
+        return ret;
+    const std::string::size_type end = line.find(']', start);
+    if (end >= line.size())
+        return ret;
+
+    std::string::size_type pos1 = start + 3 + data.size();
+    while (pos1 < end) {
+        const std::string::size_type pos2 = line.find_first_of(",]",pos1);
+        ret.push_back(line.substr(pos1, pos2-pos1-1));
+        pos1 = pos2 + 1;
+    }
+
+    return ret;
+}
+
+static void removeFunctionCalls(const std::string& calledFunction,
+                                std::map<std::string, std::vector<std::string>> &functionCalledBy,
+                                std::map<std::string, std::vector<std::string>> &functionCalls,
+                                std::vector<std::string> &add)
+{
+    std::vector<std::string> calledBy = functionCalledBy[calledFunction];
+    functionCalledBy.erase(calledFunction);
+    for (const std::string &c: calledBy) {
+        std::vector<std::string> &calls = functionCalls[c];
+        calls.erase(std::remove(calls.begin(), calls.end(), calledFunction), calls.end());
+        if (calls.empty()) {
+            add.push_back(calledFunction);
+            removeFunctionCalls(c, functionCalledBy, functionCalls, add);
+        }
+    }
+}
+
+void Summaries::loadReturn(const std::string &buildDir, std::set<std::string> &summaryReturn)
+{
+    if (buildDir.empty())
+        return;
+
+    std::vector<std::string> return1;
+    std::map<std::string, std::vector<std::string>> functionCalls;
+    std::map<std::string, std::vector<std::string>> functionCalledBy;
+
+    // extract "functionNoreturn" and "functionCalledBy" from summaries
+    std::vector<std::string> summaryFiles = getSummaryFiles(buildDir + "/files.txt");
+    for (const std::string &filename: summaryFiles) {
+        std::ifstream fin(buildDir + '/' + filename);
+        if (!fin.is_open())
+            continue;
+        std::string line;
+        while (std::getline(fin, line)) {
+            // Get function name
+            constexpr std::string::size_type pos1 = 0;
+            const std::string::size_type pos2 = line.find(' ', pos1);
+            std::string functionName = (pos2 == std::string::npos) ? line : line.substr(0, pos2);
+            std::vector<std::string> call = getSummaryData(line, "call");
+            if (call.empty())
+                return1.push_back(functionName);
+            else {
+                for (const std::string &c: call) {
+                    functionCalledBy[c].push_back(functionName);
+                }
+            }
+            functionCalls[functionName] = std::move(call);
+        }
+    }
+    summaryReturn.insert(return1.cbegin(), return1.cend());
+
+    // recursively set "summaryNoreturn"
+    for (const std::string &f: return1) {
+        std::vector<std::string> return2;
+        removeFunctionCalls(f, functionCalledBy, functionCalls, return2);
+        summaryReturn.insert(return2.cbegin(), return2.cend());
+    }
+}
diff --git a/lib/summaries.h b/lib/summaries.h
new file mode 100644
index 00000000000..d720d023306
--- /dev/null
+++ b/lib/summaries.h
@@ -0,0 +1,39 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+//---------------------------------------------------------------------------
+#ifndef summariesH
+#define summariesH
+//---------------------------------------------------------------------------
+
+#include "config.h"
+
+#include <cstddef>
+#include <set>
+#include <string>
+
+class Tokenizer;
+
+namespace Summaries {
+    CPPCHECKLIB std::string create(const Tokenizer &tokenizer, const std::string &cfg, std::size_t fsFileId);
+    CPPCHECKLIB void loadReturn(const std::string &buildDir, std::set<std::string> &summaryReturn);
+}
+
+//---------------------------------------------------------------------------
+#endif
+//---------------------------------------------------------------------------
diff --git a/lib/suppressions.cpp b/lib/suppressions.cpp
index 2bfb1e77288..241ec3d1f9f 100644
--- a/lib/suppressions.cpp
+++ b/lib/suppressions.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,31 +18,45 @@
 
 #include "suppressions.h"
 
+#include "addoninfo.h"
 #include "errorlogger.h"
-#include "mathlib.h"
+#include "filesettings.h"
 #include "path.h"
-
-#include <tinyxml2.h>
+#include "pathmatch.h"
+#include "utils.h"
+#include "token.h"
+#include "tokenize.h"
+#include "tokenlist.h"
+#include "settings.h"
 
 #include <algorithm>
 #include <cctype>   // std::isdigit, std::isalnum, etc
-#include <stack>
+#include <cstring>
+#include <functional> // std::bind, std::placeholders
 #include <sstream>
+#include <stdexcept>
 #include <utility>
 
-class ErrorLogger;
+#include "xml.h"
+
+static const char ID_CHECKERSREPORT[] = "checkersReport";
 
-static bool isValidGlobPattern(const std::string &pattern)
+SuppressionList::ErrorMessage SuppressionList::ErrorMessage::fromErrorMessage(const ::ErrorMessage &msg, const std::set<std::string> &macroNames)
 {
-    for (std::string::const_iterator i = pattern.begin(); i != pattern.end(); ++i) {
-        if (*i == '*' || *i == '?') {
-            std::string::const_iterator j = i + 1;
-            if (j != pattern.end() && (*j == '*' || *j == '?')) {
-                return false;
-            }
-        }
+    SuppressionList::ErrorMessage ret;
+    ret.hash = msg.hash;
+    ret.errorId = msg.id;
+    if (!msg.callStack.empty()) {
+        ret.setFileName(msg.callStack.back().getfile(false));
+        ret.lineNumber = msg.callStack.back().line;
+    } else {
+        ret.setFileName(msg.file0);
+        ret.lineNumber = SuppressionList::Suppression::NO_LINE;
     }
-    return true;
+    ret.certainty = msg.certainty;
+    ret.symbolNames = msg.symbolNames();
+    ret.macroNames = macroNames;
+    return ret;
 }
 
 static bool isAcceptedErrorIdChar(char c)
@@ -51,13 +65,14 @@ static bool isAcceptedErrorIdChar(char c)
     case '_':
     case '-':
     case '.':
+    case '*':
         return true;
     default:
-        return std::isalnum(c);
+        return c > 0 && std::isalnum(c);
     }
 }
 
-std::string Suppressions::parseFile(std::istream &istr)
+std::string SuppressionList::parseFile(std::istream &istr)
 {
     // Change '\r' to '\n' in the istr
     std::string filedata;
@@ -73,13 +88,19 @@ std::string Suppressions::parseFile(std::istream &istr)
         if (line.empty())
             continue;
 
+        std::string::size_type pos = 0;
+        while (pos < line.size() && std::isspace(line[pos]))
+            ++pos;
+        if (pos == line.size())
+            continue;
+
         // Skip comments
-        if (line.length() > 1 && line[0] == '#')
+        if (line[pos] == '#')
             continue;
-        if (line.length() >= 2 && line[0] == '/' && line[1] == '/')
+        if (pos < line.size() - 1 && line[pos] == '/' && line[pos + 1] == '/')
             continue;
 
-        const std::string errmsg(addSuppressionLine(line));
+        std::string errmsg(addSuppressionLine(line));
         if (!errmsg.empty())
             return errmsg;
     }
@@ -88,36 +109,40 @@ std::string Suppressions::parseFile(std::istream &istr)
 }
 
 
-std::string Suppressions::parseXmlFile(const char *filename)
+std::string SuppressionList::parseXmlFile(const char *filename)
 {
     tinyxml2::XMLDocument doc;
     const tinyxml2::XMLError error = doc.LoadFile(filename);
-    if (error == tinyxml2::XML_ERROR_FILE_NOT_FOUND)
-        return "File not found";
     if (error != tinyxml2::XML_SUCCESS)
-        return "Failed to parse XML file";
+        return std::string("failed to load suppressions XML '") + filename + "' (" + tinyxml2::XMLDocument::ErrorIDToName(error) + ").";
 
     const tinyxml2::XMLElement * const rootnode = doc.FirstChildElement();
+    if (!rootnode)
+        return std::string("failed to load suppressions XML '") + filename + "' (no root node found).";
+    // TODO: check for proper root node 'suppressions'
     for (const tinyxml2::XMLElement * e = rootnode->FirstChildElement(); e; e = e->NextSiblingElement()) {
         if (std::strcmp(e->Name(), "suppress") != 0)
-            return "Invalid suppression xml file format, expected <suppress> element but got a <" + std::string(e->Name()) + '>';
+            return std::string("invalid suppression xml file '") + filename + "', expected 'suppress' element but got a '" + e->Name() + "'.";
 
         Suppression s;
         for (const tinyxml2::XMLElement * e2 = e->FirstChildElement(); e2; e2 = e2->NextSiblingElement()) {
-            const char *text = e2->GetText() ? e2->GetText() : "";
-            if (std::strcmp(e2->Name(), "id") == 0)
+            const char *name = e2->Name();
+            const char *text = empty_if_null(e2->GetText());
+            if (std::strcmp(name, "id") == 0)
                 s.errorId = text;
-            else if (std::strcmp(e2->Name(), "fileName") == 0)
-                s.fileName = text;
-            else if (std::strcmp(e2->Name(), "lineNumber") == 0)
-                s.lineNumber = std::atoi(text);
-            else if (std::strcmp(e2->Name(), "symbolName") == 0)
+            else if (std::strcmp(name, "fileName") == 0)
+                s.fileName = Path::simplifyPath(text);
+            else if (std::strcmp(name, "lineNumber") == 0)
+                s.lineNumber = strToInt<int>(text);
+            else if (std::strcmp(name, "symbolName") == 0)
                 s.symbolName = text;
+            else if (*text && std::strcmp(name, "hash") == 0)
+                s.hash = strToInt<std::size_t>(text);
             else
-                return "Unknown suppression element <" + std::string(e2->Name()) + ">, expected <id>/<fileName>/<lineNumber>/<symbolName>";
+                return std::string("unknown element '") + name + "' in suppressions XML '" + filename + "', expected id/fileName/lineNumber/symbolName/hash.";
         }
 
-        const std::string err = addSuppression(s);
+        std::string err = addSuppression(std::move(s));
         if (!err.empty())
             return err;
     }
@@ -125,10 +150,79 @@ std::string Suppressions::parseXmlFile(const char *filename)
     return "";
 }
 
-std::string Suppressions::addSuppressionLine(const std::string &line)
+std::vector<SuppressionList::Suppression> SuppressionList::parseMultiSuppressComment(const std::string &comment, std::string *errorMessage)
+{
+    std::vector<Suppression> suppressions;
+
+    // If this function is called we assume that comment starts with "cppcheck-suppress[".
+    const std::string::size_type start_position = comment.find('[');
+    const std::string::size_type end_position = comment.find(']', start_position);
+    if (end_position == std::string::npos) {
+        if (errorMessage && errorMessage->empty())
+            *errorMessage = "Bad multi suppression '" + comment + "'. legal format is cppcheck-suppress[errorId, errorId symbolName=arr, ...]";
+        return suppressions;
+    }
+
+    // parse all suppressions
+    for (std::string::size_type pos = start_position; pos < end_position;) {
+        const std::string::size_type pos1 = pos + 1;
+        pos = comment.find(',', pos1);
+        const std::string::size_type pos2 = (pos < end_position) ? pos : end_position;
+        if (pos1 == pos2)
+            continue;
+
+        Suppression s;
+        std::istringstream iss(comment.substr(pos1, pos2-pos1));
+
+        iss >> s.errorId;
+        if (!iss) {
+            if (errorMessage && errorMessage->empty())
+                *errorMessage = "Bad multi suppression '" + comment + "'. legal format is cppcheck-suppress[errorId, errorId symbolName=arr, ...]";
+            suppressions.clear();
+            return suppressions;
+        }
+
+        const std::string symbolNameString = "symbolName=";
+
+        while (iss) {
+            std::string word;
+            iss >> word;
+            if (!iss)
+                break;
+            if (word.find_first_not_of("+-*/%#;") == std::string::npos)
+                break;
+            if (startsWith(word, symbolNameString)) {
+                s.symbolName = word.substr(symbolNameString.size());
+            } else {
+                if (errorMessage && errorMessage->empty())
+                    *errorMessage = "Bad multi suppression '" + comment + "'. legal format is cppcheck-suppress[errorId, errorId symbolName=arr, ...]";
+                suppressions.clear();
+                return suppressions;
+            }
+        }
+
+        suppressions.push_back(std::move(s));
+    }
+
+    return suppressions;
+}
+
+SuppressionList::Suppression SuppressionList::parseLine(const std::string &line)
 {
-    std::istringstream lineStream(line);
-    Suppressions::Suppression suppression;
+    std::istringstream lineStream;
+    SuppressionList::Suppression suppression;
+
+    // Strip any end of line comments
+    std::string::size_type endpos = std::min(line.find('#'), line.find("//"));
+    if (endpos != std::string::npos) {
+        while (endpos > 0 && std::isspace(line[endpos-1])) {
+            endpos--;
+        }
+        lineStream.str(line.substr(0, endpos));
+    } else {
+        lineStream.str(line);
+    }
+
     if (std::getline(lineStream, suppression.errorId, ':')) {
         if (std::getline(lineStream, suppression.fileName)) {
             // If there is not a dot after the last colon in "file" then
@@ -146,35 +240,56 @@ std::string Suppressions::addSuppressionLine(const std::string &line)
                     std::istringstream istr1(suppression.fileName.substr(pos+1));
                     istr1 >> suppression.lineNumber;
                 } catch (...) {
-                    suppression.lineNumber = Suppressions::Suppression::NO_LINE;
+                    suppression.lineNumber = SuppressionList::Suppression::NO_LINE;
                 }
 
-                if (suppression.lineNumber != Suppressions::Suppression::NO_LINE) {
+                if (suppression.lineNumber != SuppressionList::Suppression::NO_LINE) {
                     suppression.fileName.erase(pos);
                 }
             }
+
+            // when parsing string generated internally by toString() there can be newline
+            std::string extra;
+            while (std::getline(lineStream, extra)) {
+                if (startsWith(extra, "symbol="))
+                    suppression.symbolName = extra.substr(7);
+                else if (extra == "polyspace=1")
+                    suppression.isPolyspace = true;
+            }
         }
     }
 
     suppression.fileName = Path::simplifyPath(suppression.fileName);
 
-    return addSuppression(suppression);
+    return suppression;
 }
 
-std::string Suppressions::addSuppression(const Suppressions::Suppression &suppression)
+std::string SuppressionList::addSuppressionLine(const std::string &line)
 {
+    return addSuppression(parseLine(line));
+}
+
+std::string SuppressionList::addSuppression(SuppressionList::Suppression suppression)
+{
+    std::lock_guard<std::mutex> lg(mSuppressionsSync);
+
+    // Check if suppression is already in list
+    auto foundSuppression = std::find_if(mSuppressions.begin(), mSuppressions.end(),
+                                         std::bind(&Suppression::isSameParameters, &suppression, std::placeholders::_1));
+    if (foundSuppression != mSuppressions.end()) {
+        return "suppression '" + suppression.toString() + "' already exists";
+    }
+
     // Check that errorId is valid..
-    if (suppression.errorId.empty()) {
+    if (suppression.errorId.empty() && suppression.hash == 0)
         return "Failed to add suppression. No id.";
-    }
-    if (suppression.errorId != "*") {
-        for (std::string::size_type pos = 0; pos < suppression.errorId.length(); ++pos) {
-            if (suppression.errorId[pos] < 0 || !isAcceptedErrorIdChar(suppression.errorId[pos])) {
-                return "Failed to add suppression. Invalid id \"" + suppression.errorId + "\"";
-            }
-            if (pos == 0 && std::isdigit(suppression.errorId[pos])) {
-                return "Failed to add suppression. Invalid id \"" + suppression.errorId + "\"";
-            }
+
+    for (std::string::size_type pos = 0; pos < suppression.errorId.length(); ++pos) {
+        if (!isAcceptedErrorIdChar(suppression.errorId[pos])) {
+            return "Failed to add suppression. Invalid id \"" + suppression.errorId + "\"";
+        }
+        if (pos == 0 && std::isdigit(suppression.errorId[pos])) {
+            return "Failed to add suppression. Invalid id \"" + suppression.errorId + "\"";
         }
     }
 
@@ -183,61 +298,127 @@ std::string Suppressions::addSuppression(const Suppressions::Suppression &suppre
     if (!isValidGlobPattern(suppression.fileName))
         return "Failed to add suppression. Invalid glob pattern '" + suppression.fileName + "'.";
 
-    mSuppressions.push_back(suppression);
+    mSuppressions.push_back(std::move(suppression));
 
     return "";
 }
 
-void Suppressions::ErrorMessage::setFileName(const std::string &s)
+std::string SuppressionList::addSuppressions(std::list<Suppression> suppressions)
 {
-    mFileName = Path::simplifyPath(s);
+    for (auto &newSuppression : suppressions) {
+        auto errmsg = addSuppression(std::move(newSuppression));
+        if (!errmsg.empty())
+            return errmsg;
+    }
+    return "";
 }
 
-bool Suppressions::Suppression::parseComment(std::string comment, std::string *errorMessage)
+bool SuppressionList::updateSuppressionState(const SuppressionList::Suppression& suppression)
 {
-    if (comment.size() < 2)
-        return false;
+    std::lock_guard<std::mutex> lg(mSuppressionsSync);
+
+    // Check if suppression is already in list
+    auto foundSuppression = std::find_if(mSuppressions.begin(), mSuppressions.end(),
+                                         std::bind(&Suppression::isSameParameters, &suppression, std::placeholders::_1));
+    if (foundSuppression != mSuppressions.end()) {
+        if (suppression.checked)
+            foundSuppression->checked = true;
+        if (suppression.matched)
+            foundSuppression->matched = true;
+        return true;
+    }
 
-    if (comment.find(';') != std::string::npos)
-        comment.erase(comment.find(';'));
+    return false;
+}
+
+void SuppressionList::ErrorMessage::setFileName(std::string s)
+{
+    mFileName = Path::simplifyPath(std::move(s));
+}
 
-    if (comment.find("//", 2) != std::string::npos)
-        comment.erase(comment.find("//",2));
+bool SuppressionList::Suppression::parseComment(std::string comment, std::string *errorMessage)
+{
+    if (comment.size() < 2)
+        return false;
 
     if (comment.compare(comment.size() - 2, 2, "*/") == 0)
         comment.erase(comment.size() - 2, 2);
 
+    std::string::size_type extraPos = comment.find(';');
+    std::string::size_type extraDelimiterSize = 1;
+
+    if (extraPos == std::string::npos) {
+        extraPos = comment.find("//", 2);
+        extraDelimiterSize = 2;
+    }
+
+    if (extraPos != std::string::npos) {
+        extraComment = trim(comment.substr(extraPos + extraDelimiterSize));
+        for (auto it = extraComment.begin(); it != extraComment.end();)
+            it = *it & 0x80 ? extraComment.erase(it) : it + 1;
+        comment.erase(extraPos);
+    }
+
+    const std::set<std::string> cppchecksuppress{
+        "cppcheck-suppress",
+        "cppcheck-suppress-begin",
+        "cppcheck-suppress-end",
+        "cppcheck-suppress-file",
+        "cppcheck-suppress-macro"
+    };
+
     std::istringstream iss(comment.substr(2));
     std::string word;
     iss >> word;
-    if (word != "cppcheck-suppress")
+    if (!cppchecksuppress.count(word))
         return false;
+
     iss >> errorId;
     if (!iss)
         return false;
+
+    const std::string symbolNameString = "symbolName=";
+
     while (iss) {
         iss >> word;
         if (!iss)
             break;
         if (word.find_first_not_of("+-*/%#;") == std::string::npos)
             break;
-        if (word.compare(0,11,"symbolName=")==0)
-            symbolName = word.substr(11);
+        if (startsWith(word, symbolNameString))
+            symbolName = word.substr(symbolNameString.size());
         else if (errorMessage && errorMessage->empty())
             *errorMessage = "Bad suppression attribute '" + word + "'. You can write comments in the comment after a ; or //. Valid suppression attributes; symbolName=sym";
     }
     return true;
 }
 
-bool Suppressions::Suppression::isSuppressed(const Suppressions::ErrorMessage &errmsg) const
+SuppressionList::Suppression::Result SuppressionList::Suppression::isSuppressed(const SuppressionList::ErrorMessage &errmsg) const
 {
-    if (!errorId.empty() && !matchglob(errorId, errmsg.errorId))
-        return false;
-    if (!fileName.empty() && !matchglob(fileName, errmsg.getFileName()))
-        return false;
-    if (lineNumber != NO_LINE && lineNumber != errmsg.lineNumber)
-        return false;
+    if (type == SuppressionList::Type::macro) {
+        if (errmsg.macroNames.count(macroName) == 0)
+            return Result::None;
+        if (hash > 0 && hash != errmsg.hash)
+            return Result::Checked;
+        if (!errorId.empty() && !matchglob(errorId, errmsg.errorId))
+            return Result::Checked;
+    } else {
+        if ((SuppressionList::Type::unique == type) && (lineNumber != NO_LINE) && (lineNumber != errmsg.lineNumber)) {
+            if (!thisAndNextLine || lineNumber + 1 != errmsg.lineNumber)
+                return Result::None;
+        }
+        if (!fileName.empty() && !PathMatch::match(fileName, errmsg.getFileName()))
+            return Result::None;
+        if (hash > 0 && hash != errmsg.hash)
+            return Result::Checked;
+        // the empty check is a hack to allow wildcard suppressions on IDs to be marked as checked
+        if (!errorId.empty() && (errmsg.errorId.empty() || !matchglob(errorId, errmsg.errorId)))
+            return Result::Checked;
+        if ((SuppressionList::Type::block == type) && ((errmsg.lineNumber < lineBegin) || (errmsg.lineNumber > lineEnd)))
+            return Result::Checked;
+    }
     if (!symbolName.empty()) {
+        bool matchedSymbol = false;
         for (std::string::size_type pos = 0; pos < errmsg.symbolNames.size();) {
             const std::string::size_type pos2 = errmsg.symbolNames.find('\n',pos);
             std::string symname;
@@ -248,57 +429,58 @@ bool Suppressions::Suppression::isSuppressed(const Suppressions::ErrorMessage &e
                 symname = errmsg.symbolNames.substr(pos,pos2-pos);
                 pos = pos2+1;
             }
-            if (matchglob(symbolName, symname))
-                return true;
+            if (matchglob(symbolName, symname)) {
+                matchedSymbol = true;
+                break;
+            }
         }
-        return false;
+        if (!matchedSymbol)
+            return Result::Checked;
     }
-    return true;
+    return Result::Matched;
 }
 
-bool Suppressions::Suppression::isMatch(const Suppressions::ErrorMessage &errmsg)
+bool SuppressionList::Suppression::isMatch(const SuppressionList::ErrorMessage &errmsg)
 {
-    if (!isSuppressed(errmsg))
+    switch (isSuppressed(errmsg)) {
+    case Result::None:
         return false;
-    matched = true;
-    return true;
+    case Result::Checked:
+        checked = true;
+        return false;
+    case Result::Matched:
+        checked = true;
+        matched = true;
+        return true;
+    }
+    cppcheck::unreachable();
 }
 
-std::string Suppressions::Suppression::getText() const
+bool SuppressionList::isSuppressed(const SuppressionList::ErrorMessage &errmsg, bool global)
 {
-    std::string ret;
-    if (!errorId.empty())
-        ret = errorId;
-    if (!fileName.empty())
-        ret += " fileName=" + fileName;
-    if (lineNumber != NO_LINE)
-        ret += " lineNumber=" + MathLib::toString(lineNumber);
-    if (!symbolName.empty())
-        ret += " symbolName=" + symbolName;
-    if (ret.compare(0,1," ")==0)
-        return ret.substr(1);
-    return ret;
-}
+    std::lock_guard<std::mutex> lg(mSuppressionsSync);
 
-bool Suppressions::isSuppressed(const Suppressions::ErrorMessage &errmsg)
-{
     const bool unmatchedSuppression(errmsg.errorId == "unmatchedSuppression");
+    bool returnValue = false;
     for (Suppression &s : mSuppressions) {
+        if (!global && !s.isLocal())
+            continue;
         if (unmatchedSuppression && s.errorId != errmsg.errorId)
             continue;
         if (s.isMatch(errmsg))
-            return true;
+            returnValue = true;
     }
-    return false;
+    return returnValue;
 }
 
-bool Suppressions::isSuppressedLocal(const Suppressions::ErrorMessage &errmsg)
+bool SuppressionList::isSuppressedExplicitly(const SuppressionList::ErrorMessage &errmsg, bool global)
 {
-    const bool unmatchedSuppression(errmsg.errorId == "unmatchedSuppression");
+    std::lock_guard<std::mutex> lg(mSuppressionsSync);
+
     for (Suppression &s : mSuppressions) {
-        if (!s.isLocal())
+        if (!global && !s.isLocal())
             continue;
-        if (unmatchedSuppression && s.errorId != errmsg.errorId)
+        if (s.errorId != errmsg.errorId) // Error id must match exactly
             continue;
         if (s.isMatch(errmsg))
             return true;
@@ -306,10 +488,25 @@ bool Suppressions::isSuppressedLocal(const Suppressions::ErrorMessage &errmsg)
     return false;
 }
 
-void Suppressions::dump(std::ostream & out) const
+bool SuppressionList::isSuppressed(const ::ErrorMessage &errmsg, const std::set<std::string>& macroNames)
 {
+    {
+        std::lock_guard<std::mutex> lg(mSuppressionsSync);
+
+        if (mSuppressions.empty())
+            return false;
+    }
+    return isSuppressed(SuppressionList::ErrorMessage::fromErrorMessage(errmsg, macroNames));
+}
+
+void SuppressionList::dump(std::ostream & out, const std::string& filePath) const
+{
+    std::lock_guard<std::mutex> lg(mSuppressionsSync);
+
     out << "  <suppressions>" << std::endl;
     for (const Suppression &suppression : mSuppressions) {
+        if (suppression.isInline && !suppression.fileName.empty() && !filePath.empty() && filePath != suppression.fileName)
+            continue;
         out << "    <suppression";
         out << " errorId=\"" << ErrorLogger::toxml(suppression.errorId) << '"';
         if (!suppression.fileName.empty())
@@ -318,35 +515,73 @@ void Suppressions::dump(std::ostream & out) const
             out << " lineNumber=\"" << suppression.lineNumber << '"';
         if (!suppression.symbolName.empty())
             out << " symbolName=\"" << ErrorLogger::toxml(suppression.symbolName) << '\"';
+        if (suppression.hash > 0)
+            out << " hash=\"" << suppression.hash << '\"';
+        if (suppression.lineBegin != Suppression::NO_LINE)
+            out << " lineBegin=\"" << suppression.lineBegin << '"';
+        if (suppression.lineEnd != Suppression::NO_LINE)
+            out << " lineEnd=\"" << suppression.lineEnd << '"';
+        if (suppression.type == SuppressionList::Type::file)
+            out << " type=\"file\"";
+        else if (suppression.type == SuppressionList::Type::block)
+            out << " type=\"block\"";
+        else if (suppression.type == SuppressionList::Type::blockBegin)
+            out << " type=\"blockBegin\"";
+        else if (suppression.type == SuppressionList::Type::blockEnd)
+            out << " type=\"blockEnd\"";
+        else if (suppression.type == SuppressionList::Type::macro)
+            out << " type=\"macro\"";
+        if (suppression.isInline)
+            out << " inline=\"true\"";
+        else
+            out << " inline=\"false\"";
+        if (!suppression.extraComment.empty())
+            out << " comment=\"" << ErrorLogger::toxml(suppression.extraComment) << "\"";
         out << " />" << std::endl;
     }
     out << "  </suppressions>" << std::endl;
 }
 
-#include <iostream>
-
-std::list<Suppressions::Suppression> Suppressions::getUnmatchedLocalSuppressions(const std::string &file, const bool unusedFunctionChecking) const
+std::list<SuppressionList::Suppression> SuppressionList::getUnmatchedLocalSuppressions(const FileWithDetails &file) const
 {
+    std::lock_guard<std::mutex> lg(mSuppressionsSync);
+
     std::list<Suppression> result;
     for (const Suppression &s : mSuppressions) {
+        if (s.isInline)
+            continue;
         if (s.matched)
             continue;
-        if (!unusedFunctionChecking && s.errorId == "unusedFunction")
+        if ((s.lineNumber != Suppression::NO_LINE) && !s.checked)
+            continue;
+        if (s.type == SuppressionList::Type::macro)
             continue;
-        if (file.empty() || !s.isLocal() || s.fileName != file)
+        if (s.hash > 0)
+            continue;
+        if (s.errorId == ID_CHECKERSREPORT)
+            continue;
+        if (!s.isLocal() || !PathMatch::match(s.fileName, file.spath()))
             continue;
         result.push_back(s);
     }
     return result;
 }
 
-std::list<Suppressions::Suppression> Suppressions::getUnmatchedGlobalSuppressions(const bool unusedFunctionChecking) const
+std::list<SuppressionList::Suppression> SuppressionList::getUnmatchedGlobalSuppressions() const
 {
+    std::lock_guard<std::mutex> lg(mSuppressionsSync);
+
     std::list<Suppression> result;
     for (const Suppression &s : mSuppressions) {
+        if (s.isInline)
+            continue;
         if (s.matched)
             continue;
-        if (!unusedFunctionChecking && s.errorId == "unusedFunction")
+        if (!s.checked && s.isWildcard())
+            continue;
+        if (s.hash > 0)
+            continue;
+        if (s.errorId == ID_CHECKERSREPORT)
             continue;
         if (s.isLocal())
             continue;
@@ -355,66 +590,313 @@ std::list<Suppressions::Suppression> Suppressions::getUnmatchedGlobalSuppression
     return result;
 }
 
-bool Suppressions::matchglob(const std::string &pattern, const std::string &name)
+std::list<SuppressionList::Suppression> SuppressionList::getUnmatchedInlineSuppressions() const
 {
-    const char *p = pattern.c_str();
-    const char *n = name.c_str();
-    std::stack<std::pair<const char *, const char *> > backtrack;
-
-    for (;;) {
-        bool matching = true;
-        while (*p != '\0' && matching) {
-            switch (*p) {
-            case '*':
-                // Step forward until we match the next character after *
-                while (*n != '\0' && *n != p[1]) {
-                    n++;
-                }
-                if (*n != '\0') {
-                    // If this isn't the last possibility, save it for later
-                    backtrack.push(std::make_pair(p, n));
-                }
-                break;
-            case '?':
-                // Any character matches unless we're at the end of the name
-                if (*n != '\0') {
-                    n++;
-                } else {
-                    matching = false;
-                }
-                break;
-            default:
-                // Non-wildcard characters match literally
-                if (*n == *p) {
-                    n++;
-                } else if (*n == '\\' && *p == '/') {
-                    n++;
-                } else if (*n == '/' && *p == '\\') {
-                    n++;
-                } else {
-                    matching = false;
+    std::list<SuppressionList::Suppression> result;
+    for (const SuppressionList::Suppression &s : SuppressionList::mSuppressions) {
+        if (!s.isInline)
+            continue;
+        // TODO: remove this and markUnmatchedInlineSuppressionsAsChecked()?
+        if (!s.checked)
+            continue;
+        if (s.matched)
+            continue;
+        if (s.hash > 0)
+            continue;
+        result.push_back(s);
+    }
+    return result;
+}
+
+std::list<SuppressionList::Suppression> SuppressionList::getSuppressions() const
+{
+    std::lock_guard<std::mutex> lg(mSuppressionsSync);
+
+    return mSuppressions;
+}
+
+void SuppressionList::markUnmatchedInlineSuppressionsAsChecked(const Tokenizer &tokenizer) {
+    std::lock_guard<std::mutex> lg(mSuppressionsSync);
+
+    int currLineNr = -1;
+    int currFileIdx = -1;
+    for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {
+        if (currFileIdx != tok->fileIndex() || currLineNr != tok->linenr()) {
+            currLineNr = tok->linenr();
+            currFileIdx = tok->fileIndex();
+            for (auto &suppression : mSuppressions) {
+                if (suppression.type == SuppressionList::Type::unique) {
+                    if (!suppression.checked && (suppression.lineNumber == currLineNr) && (suppression.fileName == tokenizer.list.file(tok))) {
+                        suppression.checked = true;
+                    }
+                } else if (suppression.type == SuppressionList::Type::block) {
+                    if ((!suppression.checked && (suppression.lineBegin <= currLineNr) && (suppression.lineEnd >= currLineNr) && (suppression.fileName == tokenizer.list.file(tok)))) {
+                        suppression.checked = true;
+                    }
+                } else if (!suppression.checked && suppression.fileName == tokenizer.list.file(tok)) {
+                    suppression.checked = true;
                 }
-                break;
             }
-            p++;
         }
+    }
+}
 
-        // If we haven't failed matching and we've reached the end of the name, then success
-        if (matching && *n == '\0') {
-            return true;
+std::string SuppressionList::Suppression::toString() const
+{
+    std::string s;
+    s += errorId;
+    if (!fileName.empty()) {
+        s += ':';
+        s += fileName;
+        if (lineNumber != -1) {
+            s += ':';
+            s += std::to_string(lineNumber);
         }
+    }
+    if (!symbolName.empty())
+        s += "\nsymbol=" + symbolName;
+    if (isPolyspace)
+        s += "\npolyspace=1";
+    return s;
+}
 
-        // If there are no other paths to try, then fail
-        if (backtrack.empty()) {
+polyspace::Parser::Parser(const Settings &settings)
+{
+    const bool haveMisraAddon = std::any_of(settings.addonInfos.cbegin(),
+                                            settings.addonInfos.cend(),
+                                            [] (const AddonInfo &info) {
+        return info.name == "misra";
+    });
+
+    if (haveMisraAddon) {
+        mFamilyMap["MISRA-C3"] = "misra-c2012-";
+        mFamilyMap["MISRA2012"] = "misra-c2012-";
+    }
+
+    const auto matchArg = [&](const std::string &arg) {
+        const std::string args = settings.premiumArgs;
+        const std::string::size_type pos = args.find(arg);
+
+        if (pos == std::string::npos)
             return false;
+
+        const char prevChar = (pos > 0) ? args[pos - 1] : ' ';
+        const char nextChar = (pos + arg.size() < args.size()) ? args[pos + arg.size()] : ' ';
+
+        return prevChar == ' ' && (nextChar == ' ' || nextChar == ':');
+    };
+
+    if (matchArg("--misra-c-2012")) {
+        mFamilyMap["MISRA-C3"] = "premium-misra-c-2012-";
+        mFamilyMap["MISRA2012"] = "premium-misra-c-2012-";
+    }
+
+    if (matchArg("--misra-c-2023"))
+        mFamilyMap["MISRA-C-2023"] = "premium-misra-c-2023-";
+
+    if (matchArg("--misra-cpp-2008") || matchArg("--misra-c++-2008"))
+        mFamilyMap["MISRA-CPP"] = "premium-misra-cpp-2008-";
+
+    if (matchArg("--misra-cpp-2023") || matchArg("--misra-c++-2023"))
+        mFamilyMap["MISRA-CPP-2023"] = "premium-misra-cpp-2023-";
+
+    if (matchArg("--cert-c") || matchArg("--cert-c-2016"))
+        mFamilyMap["CERT-C"] = "premium-cert-c-";
+
+    if (matchArg("--cert-cpp") || matchArg("--cert-c++") ||
+        matchArg("--cert-cpp-2016") || matchArg("--cert-c++-2016"))
+        mFamilyMap["CERT-CPP"] = "premium-cert-cpp-";
+
+    if (matchArg("--autosar"))
+        mFamilyMap["AUTOSAR-CPP14"] = "premium-autosar-";
+}
+
+polyspace::CommentKind polyspace::Parser::parseKind(const std::string& comment, std::string::size_type& pos)
+{
+    const std::string::size_type pos1 = pos;
+    pos = comment.find_first_of(" \t", pos);
+    if (pos >= comment.size())
+        return CommentKind::Invalid;
+
+    const std::string token = comment.substr(pos1, pos-pos1);
+
+    if (token == "polyspace")
+        return CommentKind::Regular;
+
+    if (token == "polyspace-begin")
+        return CommentKind::Begin;
+
+    if (token == "polyspace-end")
+        return CommentKind::End;
+
+    return CommentKind::Invalid;
+}
+
+
+std::list<SuppressionList::Suppression> polyspace::Parser::parse(const std::string &comment, int line, const std::string &filename) const
+{
+    // Syntax for a polyspace suppression:
+    // https://se.mathworks.com/help/bugfinder/ug/annotate-hide-known-acceptable-polyspace-results-web-browser.html
+
+    std::list<SuppressionList::Suppression> ret;
+
+    if (mFamilyMap.empty())
+        return ret;
+
+    for (std::string::size_type pos = comment.find_first_not_of("/* "); pos < comment.size();) {
+        // polyspace
+        const auto polyspaceKind = parseKind(comment, pos);
+        if (polyspaceKind == CommentKind::Invalid)
+            break;
+
+        // optional range
+        const int rangeValue = parseRange(comment, pos);
+
+        // ids..
+        const std::set<std::string> ids = parseIds(comment, pos);
+
+        // skip justification
+        if (pos < comment.size() && comment[pos] == '[') {
+            pos = comment.find(']',pos+1);
+            if (pos >= comment.size())
+                break;
+            pos = comment.find_first_not_of(" \t", pos+1);
+            if (pos >= comment.size())
+                break;
         }
 
-        // Restore pointers from backtrack stack
-        p = backtrack.top().first;
-        n = backtrack.top().second;
-        backtrack.pop();
+        // extra comment
+        std::string extraComment;
+        if (pos < comment.size() && comment[pos] == '\"') {
+            const std::string::size_type p1 = pos + 1;
+            pos = comment.find('\"',p1);
+            if (pos >= comment.size())
+                break;
+            extraComment = comment.substr(p1, pos-p1);
+        }
 
-        // Advance name pointer by one because the current position didn't work
-        n++;
+        for (const std::string& errorId: ids) {
+            SuppressionList::Suppression suppr;
+            suppr.errorId = errorId;
+            suppr.isInline = true;
+            suppr.isPolyspace = true;
+            suppr.fileName = filename;
+            suppr.lineNumber = line;
+            suppr.extraComment = extraComment;
+
+            if (rangeValue > 0) {
+                suppr.type = SuppressionList::Type::block;
+                suppr.lineBegin = line;
+                suppr.lineEnd = line + rangeValue;
+            }
+            else if (polyspaceKind == polyspace::CommentKind::Regular)
+                suppr.type = SuppressionList::Type::unique;
+            else if (polyspaceKind == polyspace::CommentKind::Begin)
+                suppr.type = SuppressionList::Type::blockBegin;
+            else
+                suppr.type = SuppressionList::Type::blockEnd;
+
+            ret.emplace_back(suppr);
+        }
+
+        // proceed to next "polyspace" if it exists
+        if (pos < comment.size())
+            pos = comment.find("polyspace", pos);
     }
+
+    return ret;
+}
+
+
+int polyspace::Parser::parseRange(const std::string& comment, std::string::size_type& pos) {
+    pos = comment.find_first_not_of(" \t", pos);
+    if (pos >= comment.size())
+        return 0;
+    if (comment[pos] != '+')
+        return 0;
+    const std::string::size_type startpos = pos + 1;
+    std::string::size_type endpos = comment.find_first_of(" \t", startpos);
+    if (endpos > comment.size())
+        return 0;
+    const std::string range = comment.substr(startpos, endpos-startpos);
+    try {
+        int ret = std::stoi(range);
+        pos = endpos;
+        return ret;
+    } catch (const std::invalid_argument &) {}
+    return 0;
+}
+
+std::vector<std::pair<std::string, std::string>> polyspace::Parser::parseFamilyRules(const std::string& comment, std::string::size_type& pos) {
+    std::vector<std::pair<std::string, std::string>> fr;
+    std::string family;
+    std::string rule;
+    enum class State: uint8_t { family, colon, rule, rule_or_family } state = State::family;
+    const std::string::size_type endpos = startsWith(comment, "/*") ? comment.size() - 2 : comment.size();
+    for (; pos <= endpos; ++pos) {
+        const char c = comment[pos];
+        if (std::strchr("[\"", c))
+            break;
+        switch (state) {
+        case State::family:
+            if (std::isalnum(c) || std::strchr("-_.",c))
+                family += c;
+            else if (!family.empty() && std::strchr(" \t:",c))
+                state = State::colon;
+            break;
+        case State::colon:
+            if (!std::strchr(" \t:", c)) {
+                rule.clear();
+                --pos;
+                state = State::rule;
+            }
+            break;
+        case State::rule:
+            if (std::strchr(", \t",c)) {
+                if (!rule.empty()) {
+                    fr.emplace_back(family,rule);
+                    rule.clear();
+                    if (c != ',')
+                        state = State::rule_or_family;
+                }
+            }
+            else
+                rule += c;
+            break;
+        case State::rule_or_family:
+            rule.clear();
+            if (std::isalnum(c)) {
+                --pos;
+                family.clear();
+                state = State::family;
+            } else if (c == ',') {
+                --pos;
+                state = State::rule;
+            }
+            break;
+        }
+    }
+    if (!family.empty() && !rule.empty())
+        fr.emplace_back(family,rule);
+    return fr;
+}
+
+std::set<std::string> polyspace::Parser::parseIds(const std::string& comment, std::string::size_type& pos) const {
+    std::set<std::string> ids;
+    for (const auto& fr: parseFamilyRules(comment,pos)) {
+        const auto it = mFamilyMap.find(fr.first);
+        if (it != mFamilyMap.cend())
+            ids.emplace(it->second + fr.second);
+    }
+    return ids;
+}
+
+
+bool polyspace::isPolyspaceComment(const std::string &comment)
+{
+    const std::string polyspace = "polyspace";
+    const std::string::size_type pos = comment.find_first_not_of("/* ");
+    if (pos == std::string::npos)
+        return false;
+    return comment.compare(pos, polyspace.size(), polyspace, 0, polyspace.size()) == 0;
 }
diff --git a/lib/suppressions.h b/lib/suppressions.h
index d6a186fb3ce..7f5ffb87b09 100644
--- a/lib/suppressions.h
+++ b/lib/suppressions.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2018 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,46 +22,54 @@
 
 #include "config.h"
 
+#include <cstddef>
+#include <cstdint>
 #include <istream>
 #include <list>
+#include <mutex>
 #include <set>
 #include <string>
+#include <utility>
+#include <vector>
+#include <map>
+
+class Tokenizer;
+class ErrorMessage;
+enum class Certainty : std::uint8_t;
+class FileWithDetails;
+class Settings;
 
 /// @addtogroup Core
 /// @{
 
 /** @brief class for handling suppressions */
-class CPPCHECKLIB Suppressions {
+class CPPCHECKLIB SuppressionList {
 public:
 
+    enum class Type : std::uint8_t {
+        unique, file, block, blockBegin, blockEnd, macro
+    };
+
     struct CPPCHECKLIB ErrorMessage {
+        std::size_t hash;
         std::string errorId;
-        void setFileName(const std::string &s);
+        void setFileName(std::string s);
         const std::string &getFileName() const {
             return mFileName;
         }
-        int lineNumber;
-        bool inconclusive;
+        int lineNumber; // TODO: need to be unsigned
+        Certainty certainty;
         std::string symbolNames;
+        std::set<std::string> macroNames;
+
+        static SuppressionList::ErrorMessage fromErrorMessage(const ::ErrorMessage &msg, const std::set<std::string> &macroNames);
     private:
         std::string mFileName;
     };
 
     struct CPPCHECKLIB Suppression {
-        Suppression() : lineNumber(NO_LINE), matched(false) {}
-        Suppression(const Suppression &other) {
-            *this = other;
-        }
-        Suppression(const std::string &id, const std::string &file, int line=NO_LINE) : errorId(id), fileName(file), lineNumber(line), matched(false) {}
-
-        Suppression & operator=(const Suppression &other) {
-            errorId = other.errorId;
-            fileName = other.fileName;
-            lineNumber = other.lineNumber;
-            symbolName = other.symbolName;
-            matched = other.matched;
-            return *this;
-        }
+        Suppression() = default;
+        Suppression(std::string id, std::string file, int line=NO_LINE) : errorId(std::move(id)), fileName(std::move(file)), lineNumber(line) {}
 
         bool operator<(const Suppression &other) const {
             if (errorId != other.errorId)
@@ -72,9 +80,37 @@ class CPPCHECKLIB Suppressions {
                 return fileName < other.fileName;
             if (symbolName != other.symbolName)
                 return symbolName < other.symbolName;
+            if (macroName != other.macroName)
+                return macroName < other.macroName;
+            if (hash != other.hash)
+                return hash < other.hash;
+            if (thisAndNextLine != other.thisAndNextLine)
+                return thisAndNextLine;
             return false;
         }
 
+        bool operator==(const Suppression &other) const {
+            if (errorId != other.errorId)
+                return false;
+            if (lineNumber < other.lineNumber)
+                return false;
+            if (fileName != other.fileName)
+                return false;
+            if (symbolName != other.symbolName)
+                return false;
+            if (macroName != other.macroName)
+                return false;
+            if (hash != other.hash)
+                return false;
+            if (type != other.type)
+                return false;
+            if (lineBegin != other.lineBegin)
+                return false;
+            if (lineEnd != other.lineEnd)
+                return false;
+            return true;
+        }
+
         /**
          * Parse inline suppression in comment
          * @param comment the full comment text
@@ -83,22 +119,55 @@ class CPPCHECKLIB Suppressions {
          */
         bool parseComment(std::string comment, std::string *errorMessage);
 
-        bool isSuppressed(const ErrorMessage &errmsg) const;
+        enum class Result : std::uint8_t {
+            None,
+            Checked,
+            Matched
+        };
+
+        Result isSuppressed(const ErrorMessage &errmsg) const;
 
         bool isMatch(const ErrorMessage &errmsg);
-        std::string getText() const;
+
+        bool isWildcard() const {
+            return fileName.find_first_of("?*") != std::string::npos;
+        }
 
         bool isLocal() const {
-            return !fileName.empty() && fileName.find_first_of("?*") == std::string::npos;
+            return !fileName.empty() && !isWildcard();
         }
 
+        bool isSameParameters(const Suppression &other) const {
+            return errorId == other.errorId &&
+                   fileName == other.fileName &&
+                   lineNumber == other.lineNumber &&
+                   symbolName == other.symbolName &&
+                   hash == other.hash &&
+                   thisAndNextLine == other.thisAndNextLine;
+        }
+
+        std::string toString() const;
+
         std::string errorId;
         std::string fileName;
-        int lineNumber;
+        std::string extraComment;
+        // TODO: use simplecpp::Location?
+        int fileIndex{};
+        int lineNumber = NO_LINE; // TODO: needs to be unsigned
+        int lineBegin = NO_LINE;
+        int lineEnd = NO_LINE;
+        int column{};
+        Type type = Type::unique;
         std::string symbolName;
-        bool matched;
+        std::string macroName;
+        std::size_t hash{};
+        bool thisAndNextLine{}; // Special case for backwards compatibility: { // cppcheck-suppress something
+        bool matched{}; /** This suppression was fully matched in an isSuppressed() call */
+        bool checked{}; /** This suppression applied to code which was being analyzed but did not match the error in an isSuppressed() call */
+        bool isInline{};
+        bool isPolyspace{};
 
-        enum { NO_LINE = -1 };
+        enum : std::int8_t { NO_LINE = -1 };
     };
 
     /**
@@ -115,6 +184,21 @@ class CPPCHECKLIB Suppressions {
      */
     std::string parseXmlFile(const char *filename);
 
+    /**
+     * Parse multi inline suppression in comment
+     * @param comment the full comment text
+     * @param errorMessage output parameter for error message (wrong suppression attribute)
+     * @return empty vector if something wrong.
+     */
+    static std::vector<Suppression> parseMultiSuppressComment(const std::string &comment, std::string *errorMessage);
+
+    /**
+     * Create a Suppression object from a suppression line
+     * @param line The line to parse.
+     * @return a suppression object
+     */
+    static Suppression parseLine(const std::string &line);
+
     /**
      * @brief Don't show the given error.
      * @param line Description of error to suppress (in id:file:line format).
@@ -128,46 +212,122 @@ class CPPCHECKLIB Suppressions {
      * @param suppression suppression details
      * @return error message. empty upon success
      */
-    std::string addSuppression(const Suppression &suppression);
+    std::string addSuppression(Suppression suppression);
+
+    /**
+     * @brief Combine list of suppressions into the current suppressions.
+     * @param suppressions list of suppression details
+     * @return error message. empty upon success
+     */
+    std::string addSuppressions(std::list<Suppression> suppressions);
+
+    /**
+     * @brief Updates the state of the given suppression.
+     * @param suppression the suppression to update
+     * @return true if suppression to update was found
+     */
+    bool updateSuppressionState(const SuppressionList::Suppression& suppression);
 
     /**
      * @brief Returns true if this message should not be shown to the user.
      * @param errmsg error message
+     * @param global use global suppressions
      * @return true if this error is suppressed.
      */
-    bool isSuppressed(const ErrorMessage &errmsg);
+    bool isSuppressed(const ErrorMessage &errmsg, bool global = true);
 
     /**
-     * @brief Returns true if this message should not be shown to the user, only uses local suppressions.
+     * @brief Returns true if this message is "explicitly" suppressed. The suppression "id" must match textually exactly.
+     * @param errmsg error message
+     * @param global use global suppressions
+     * @return true if this error is explicitly suppressed.
+     */
+    bool isSuppressedExplicitly(const ErrorMessage &errmsg, bool global = true);
+
+    /**
+     * @brief Returns true if this message should not be shown to the user.
      * @param errmsg error message
      * @return true if this error is suppressed.
      */
-    bool isSuppressedLocal(const ErrorMessage &errmsg);
+    bool isSuppressed(const ::ErrorMessage &errmsg, const std::set<std::string>& macroNames);
 
     /**
      * @brief Create an xml dump of suppressions
      * @param out stream to write XML to
-    */
-    void dump(std::ostream &out) const;
+     */
+    void dump(std::ostream &out, const std::string& filePath = {}) const;
 
     /**
      * @brief Returns list of unmatched local (per-file) suppressions.
      * @return list of unmatched suppressions
      */
-    std::list<Suppression> getUnmatchedLocalSuppressions(const std::string &file, const bool unusedFunctionChecking) const;
+    std::list<Suppression> getUnmatchedLocalSuppressions(const FileWithDetails &file) const;
 
     /**
      * @brief Returns list of unmatched global (glob pattern) suppressions.
      * @return list of unmatched suppressions
      */
-    std::list<Suppression> getUnmatchedGlobalSuppressions(const bool unusedFunctionChecking) const;
+    std::list<Suppression> getUnmatchedGlobalSuppressions() const;
+
+    /**
+     * @brief Returns list of unmatched inline suppressions.
+     * @return list of unmatched suppressions
+     */
+    std::list<Suppression> getUnmatchedInlineSuppressions() const;
+
+    /**
+     * @brief Returns list of all suppressions.
+     * @return list of suppressions
+     */
+    std::list<Suppression> getSuppressions() const;
+
+    /**
+     * @brief Marks Inline Suppressions as checked if source line is in the token stream
+     */
+    void markUnmatchedInlineSuppressionsAsChecked(const Tokenizer &tokenizer);
 
-    static bool matchglob(const std::string &pattern, const std::string &name);
 private:
+    mutable std::mutex mSuppressionsSync;
     /** @brief List of error which the user doesn't want to see. */
     std::list<Suppression> mSuppressions;
 };
 
+struct Suppressions
+{
+    /** @brief suppress message (--suppressions) */
+    SuppressionList nomsg;
+    /** @brief suppress exitcode */
+    SuppressionList nofail;
+};
+
+namespace polyspace {
+
+    enum class CommentKind : std::uint8_t {
+        Invalid, Regular, Begin, End,
+    };
+
+    class CPPCHECKLIB Parser {
+    public:
+        Parser() = delete;
+        explicit Parser(const Settings &settings);
+
+        std::list<SuppressionList::Suppression> parse(const std::string &comment, int line, const std::string &filename) const;
+
+        static int parseRange(const std::string& comment, std::string::size_type& pos);
+        static std::vector<std::pair<std::string, std::string>> parseFamilyRules(const std::string& comment, std::string::size_type& pos);
+
+    private:
+        std::set<std::string> parseIds(const std::string& comment, std::string::size_type& pos) const;
+
+        static CommentKind parseKind(const std::string& comment, std::string::size_type& pos);
+
+        std::map<std::string, std::string> mFamilyMap;
+    };
+
+    bool CPPCHECKLIB isPolyspaceComment(const std::string &comment);
+
+}
+
 /// @}
 //---------------------------------------------------------------------------
 #endif // suppressionsH
diff --git a/lib/symboldatabase.cpp b/lib/symboldatabase.cpp
index 01713b4133c..c9851d6e7ca 100644
--- a/lib/symboldatabase.cpp
+++ b/lib/symboldatabase.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,29 +21,52 @@
 
 #include "astutils.h"
 #include "errorlogger.h"
+#include "errortypes.h"
+#include "keywords.h"
+#include "library.h"
+#include "mathlib.h"
+#include "path.h"
 #include "platform.h"
 #include "settings.h"
+#include "standards.h"
+#include "templatesimplifier.h"
 #include "token.h"
 #include "tokenize.h"
 #include "tokenlist.h"
 #include "utils.h"
 #include "valueflow.h"
+#include "vfvalue.h"
 
 #include <algorithm>
 #include <cassert>
-#include <climits>
+#include <cstring>
+#include <functional>
+#include <initializer_list>
 #include <iomanip>
 #include <iostream>
+#include <iterator>
+#include <numeric>
+#include <sstream>
+#include <stack>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
 //---------------------------------------------------------------------------
 
-SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger)
-    : mTokenizer(tokenizer), mSettings(settings), mErrorLogger(errorLogger)
+SymbolDatabase::SymbolDatabase(Tokenizer& tokenizer)
+    : mTokenizer(tokenizer)
+    , mSettings(tokenizer.getSettings())
+    , mErrorLogger(tokenizer.getErrorLogger())
 {
-    mIsCpp = isCPP();
+    if (!mTokenizer.tokens())
+        return;
 
-    if (mSettings->defaultSign == 's' || mSettings->defaultSign == 'S')
+    if (mSettings.platform.defaultSign == 's' || mSettings.platform.defaultSign == 'S')
         mDefaultSignedness = ValueType::SIGNED;
-    else if (mSettings->defaultSign == 'u' || mSettings->defaultSign == 'U')
+    else if (mSettings.platform.defaultSign == 'u' || mSettings.platform.defaultSign == 'U')
         mDefaultSignedness = ValueType::UNSIGNED;
     else
         mDefaultSignedness = ValueType::UNKNOWN_SIGN;
@@ -59,21 +82,24 @@ SymbolDatabase::SymbolDatabase(const Tokenizer *tokenizer, const Settings *setti
     createSymbolDatabaseVariableSymbolTable();
     createSymbolDatabaseSetScopePointers();
     createSymbolDatabaseSetVariablePointers();
+    createSymbolDatabaseSetTypePointers();
     setValueTypeInTokenList(false);
     createSymbolDatabaseSetFunctionPointers(true);
-    createSymbolDatabaseSetTypePointers();
+    createSymbolDatabaseSetSmartPointerType();
+    setValueTypeInTokenList(false);
     createSymbolDatabaseEnums();
     createSymbolDatabaseEscapeFunctions();
     createSymbolDatabaseIncompleteVars();
+    createSymbolDatabaseExprIds();
+    debugSymbolDatabase();
 }
 
 static const Token* skipScopeIdentifiers(const Token* tok)
 {
-    if (tok && tok->str() == "::") {
+    if (Token::Match(tok, ":: %name%"))
         tok = tok->next();
-    }
     while (Token::Match(tok, "%name% ::") ||
-           (Token::Match(tok, "%name% <") && Token::simpleMatch(tok->linkAt(1), "> ::"))) {
+           (Token::Match(tok, "%name% <") && Token::Match(tok->linkAt(1), ">|>> ::"))) {
         if (tok->strAt(1) == "::")
             tok = tok->tokAt(2);
         else
@@ -90,49 +116,108 @@ static bool isExecutableScope(const Token* tok)
     const Token * tok2 = tok->link()->previous();
     if (Token::simpleMatch(tok2, "; }"))
         return true;
-    if (Token::Match(tok2, "{|} }")) {
-        const Token* startTok = tok2->str() == "{" ? tok2 : tok2->link();
+    if (tok2 == tok)
+        return false;
+    if (Token::simpleMatch(tok2, "} }")) { // inner scope
+        const Token* startTok = tok2->link();
         if (Token::Match(startTok->previous(), "do|try|else {"))
             return true;
-        if (Token::simpleMatch(startTok->previous(), ") {"))
+        if (Token::Match(startTok->previous(), ")|] {"))
             return !findLambdaStartToken(tok2);
-        if (tok->str() == "{")
-            return false;
-        else
-            return isExecutableScope(startTok);
+        return isExecutableScope(startTok);
     }
     return false;
 }
 
+const Token* SymbolDatabase::isEnumDefinition(const Token* tok)
+{
+    if (!Token::Match(tok, "enum class| %name%| {|:"))
+        return nullptr;
+    while (!Token::Match(tok, "[{:]"))
+        tok = tok->next();
+    if (tok->str() == "{")
+        return tok;
+    tok = tok->next(); // skip ':'
+    while (Token::Match(tok, "%name%|::"))
+        tok = tok->next();
+    return Token::simpleMatch(tok, "{") ? tok : nullptr;
+}
+
 void SymbolDatabase::createSymbolDatabaseFindAllScopes()
 {
     // create global scope
-    scopeList.emplace_back(this, nullptr, nullptr);
+    scopeList.emplace_back(*this, nullptr, nullptr);
 
     // pointer to current scope
     Scope *scope = &scopeList.back();
 
+    // Store the ending of init lists
+    std::stack<std::pair<const Token*, const Scope*>> endInitList;
+    auto inInitList = [&] {
+        if (endInitList.empty())
+            return false;
+        return endInitList.top().second == scope;
+    };
+
+    std::stack<const Token*> inIfCondition;
+    std::stack<Scope*> pendingIfScopes;
+
+    auto addLambda = [this, &scope](const Token* tok, const Token* lambdaEndToken) -> const Token* {
+        const Token* lambdaStartToken = lambdaEndToken->link();
+        const Token* argStart = lambdaStartToken->astParent();
+        const Token* funcStart = Token::simpleMatch(argStart, "[") ? argStart : argStart->astParent();
+        const Function* function = addGlobalFunction(scope, tok, argStart, funcStart);
+        if (!function)
+            mTokenizer.syntaxError(tok);
+        return lambdaStartToken;
+    };
+
     // Store current access in each scope (depends on evaluation progress)
     std::map<const Scope*, AccessControl> access;
 
+    std::map<Scope *, std::set<std::string>> forwardDecls;
+
+    const std::function<Scope *(const Token *, Scope *)> findForwardDeclScope = [&](const Token *tok, Scope *startScope) {
+        if (tok->str() == "::")
+            return findForwardDeclScope(tok->next(), &scopeList.front());
+
+        if (Token::Match(tok, "%name% :: %name%")) {
+            auto it = std::find_if(startScope->nestedList.cbegin(), startScope->nestedList.cend(), [&](const Scope *scope) {
+                return scope->className == tok->str();
+            });
+
+            if (it == startScope->nestedList.cend())
+                return static_cast<Scope *>(nullptr);
+
+            return findForwardDeclScope(tok->tokAt(2), *it);
+        }
+
+        auto it = forwardDecls.find(startScope);
+        if (it == forwardDecls.cend())
+            return static_cast<Scope *>(nullptr);
+
+        return it->second.count(tok->str()) > 0 ? startScope : nullptr;
+    };
+
+    ProgressReporter progressReporter(mErrorLogger, mSettings.reportProgress, mTokenizer.list.getSourceFilePath(), "SymbolDatabase (find all scopes)");
+
     // find all scopes
-    for (const Token *tok = mTokenizer->tokens(); tok; tok = tok ? tok->next() : nullptr) {
+    for (const Token *tok = mTokenizer.tokens(); tok; tok = tok ? tok->next() : nullptr) {
         // #5593 suggested to add here:
-        if (mErrorLogger)
-            mErrorLogger->reportProgress(mTokenizer->list.getSourceFilePath(),
-                                         "SymbolDatabase",
-                                         tok->progressValue());
+
+        progressReporter.report(tok->progressValue());
+
         // Locate next class
-        if ((mTokenizer->isCPP() && ((Token::Match(tok, "class|struct|union|namespace ::| %name% {|:|::|<") &&
-                                      !Token::Match(tok->previous(), "new|friend|const|enum|typedef|mutable|volatile|using|)|(|<")) ||
-                                     (Token::Match(tok, "enum class| %name% {") ||
-                                      Token::Match(tok, "enum class| %name% : %name% {"))))
-            || (mTokenizer->isC() && Token::Match(tok, "struct|union|enum %name% {"))) {
+        if ((tok->isCpp() && tok->isKeyword() &&
+             ((Token::Match(tok, "class|struct|union|namespace ::| %name% final| {|:|::|<") &&
+               !Token::Match(tok->previous(), "new|friend|const|enum|typedef|mutable|volatile|using|)|(|<")) ||
+              isEnumDefinition(tok)))
+            || (tok->isC() && tok->isKeyword() && Token::Match(tok, "struct|union|enum %name% {"))) {
             const Token *tok2 = tok->tokAt(2);
 
             if (tok->strAt(1) == "::")
                 tok2 = tok2->next();
-            else if (mTokenizer->isCPP() && tok->strAt(1) == "class")
+            else if (tok->isCpp() && tok->strAt(1) == "class")
                 tok2 = tok2->next();
 
             while (Token::Match(tok2, ":: %name%"))
@@ -148,27 +233,27 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
             }
 
             // skip over final
-            if (mTokenizer->isCPP() && Token::simpleMatch(tok2, "final"))
+            if (tok2 && tok2->isCpp() && Token::simpleMatch(tok2, "final"))
                 tok2 = tok2->next();
 
             // make sure we have valid code
             if (!Token::Match(tok2, "{|:")) {
                 // check for qualified variable
                 if (tok2 && tok2->next()) {
-                    if (tok2->next()->str() == ";")
+                    if (tok2->strAt(1) == ";")
                         tok = tok2->next();
                     else if (Token::simpleMatch(tok2->next(), "= {") &&
                              Token::simpleMatch(tok2->linkAt(2), "} ;"))
                         tok = tok2->linkAt(2)->next();
                     else if (Token::Match(tok2->next(), "(|{") &&
-                             tok2->next()->link()->strAt(1) == ";")
-                        tok = tok2->next()->link()->next();
+                             tok2->linkAt(1)->strAt(1) == ";")
+                        tok = tok2->linkAt(1)->next();
                     // skip variable declaration
                     else if (Token::Match(tok2, "*|&|>"))
                         continue;
-                    else if (Token::Match(tok2, "%name% (") && mTokenizer->isFunctionHead(tok2->next(), "{;"))
+                    else if (Token::Match(tok2, "%name% (") && TokenList::isFunctionHead(tok2->next(), "{;"))
                         continue;
-                    else if (Token::Match(tok2, "%name% ["))
+                    else if (Token::Match(tok2, "%name% [|="))
                         continue;
                     // skip template
                     else if (Token::simpleMatch(tok2, ";") &&
@@ -207,7 +292,7 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
                 if (new_scope->isClassOrStruct()) {
                     // goto initial '{'
                     if (!new_scope->definedType)
-                        mTokenizer->syntaxError(nullptr); // #6808
+                        mTokenizer.syntaxError(nullptr); // #6808
                     tok2 = new_scope->definedType->initBaseInfo(tok, tok2);
                     // make sure we have valid code
                     if (!tok2) {
@@ -216,25 +301,28 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
                 }
 
                 // definition may be different than declaration
-                if (mTokenizer->isCPP() && tok->str() == "class") {
+                if (tok->isCpp() && tok->str() == "class") {
                     access[new_scope] = AccessControl::Private;
-                    new_scope->type = Scope::eClass;
+                    new_scope->type = ScopeType::eClass;
                 } else if (tok->str() == "struct") {
                     access[new_scope] = AccessControl::Public;
-                    new_scope->type = Scope::eStruct;
+                    new_scope->type = ScopeType::eStruct;
                 }
 
                 new_scope->classDef = tok;
-                new_scope->bodyStart = tok2;
-                new_scope->bodyEnd = tok2->link();
+                new_scope->setBodyStartEnd(tok2);
                 // make sure we have valid code
                 if (!new_scope->bodyEnd) {
-                    mTokenizer->syntaxError(tok);
+                    mTokenizer.syntaxError(tok);
                 }
                 scope = new_scope;
                 tok = tok2;
             } else {
-                scopeList.emplace_back(this, tok, scope);
+
+                const Scope *forwardDeclScope = findForwardDeclScope(tok->next(), scope);
+                const Scope *nestedIn = forwardDeclScope ? forwardDeclScope : scope;
+
+                scopeList.emplace_back(*this, tok, nestedIn);
                 new_scope = &scopeList.back();
 
                 if (tok->str() == "class")
@@ -243,10 +331,10 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
                     access[new_scope] = AccessControl::Public;
 
                 // fill typeList...
-                if (new_scope->isClassOrStructOrUnion() || new_scope->type == Scope::eEnum) {
+                if (new_scope->isClassOrStructOrUnion() || new_scope->type == ScopeType::eEnum) {
                     Type* new_type = findType(name, scope);
                     if (!new_type) {
-                        typeList.emplace_back(new_scope->classDef, new_scope, scope);
+                        typeList.emplace_back(new_scope->classDef, new_scope, nestedIn);
                         new_type = &typeList.back();
                         scope->definedTypesMap[new_type->name()] = new_type;
                     } else
@@ -261,27 +349,29 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
 
                     // make sure we have valid code
                     if (!tok2) {
-                        mTokenizer->syntaxError(tok);
+                        mTokenizer.syntaxError(tok);
                     }
-                } else if (new_scope->type == Scope::eEnum) {
-                    if (tok2->str() == ":")
+                } else if (new_scope->type == ScopeType::eEnum) {
+                    if (tok2->str() == ":") {
                         tok2 = tok2->tokAt(2);
+                        while (Token::Match(tok2, "%name%|::"))
+                            tok2 = tok2->next();
+                    }
                 }
 
-                new_scope->bodyStart = tok2;
-                new_scope->bodyEnd = tok2->link();
+                new_scope->setBodyStartEnd(tok2);
 
                 // make sure we have valid code
                 if (!new_scope->bodyEnd) {
-                    mTokenizer->syntaxError(tok);
+                    mTokenizer.syntaxError(tok);
                 }
 
-                if (new_scope->type == Scope::eEnum) {
-                    tok2 = new_scope->addEnum(tok, mTokenizer->isCPP());
+                if (new_scope->type == ScopeType::eEnum) {
+                    tok2 = new_scope->addEnum(tok);
                     scope->nestedList.push_back(new_scope);
 
                     if (!tok2)
-                        mTokenizer->syntaxError(tok);
+                        mTokenizer.syntaxError(tok);
                 } else {
                     // make the new scope the current scope
                     scope->nestedList.push_back(new_scope);
@@ -293,19 +383,18 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
         }
 
         // Namespace and unknown macro (#3854)
-        else if (mTokenizer->isCPP() &&
+        else if (tok->isCpp() && tok->isKeyword() &&
                  Token::Match(tok, "namespace %name% %type% (") &&
                  tok->tokAt(2)->isUpperCaseName() &&
                  Token::simpleMatch(tok->linkAt(3), ") {")) {
-            scopeList.emplace_back(this, tok, scope);
+            scopeList.emplace_back(*this, tok, scope);
 
             Scope *new_scope = &scopeList.back();
             access[new_scope] = AccessControl::Public;
 
             const Token *tok2 = tok->linkAt(3)->next();
 
-            new_scope->bodyStart = tok2;
-            new_scope->bodyEnd = tok2->link();
+            new_scope->setBodyStartEnd(tok2);
 
             // make sure we have valid code
             if (!new_scope->bodyEnd) {
@@ -321,19 +410,20 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
         }
 
         // forward declaration
-        else if (Token::Match(tok, "class|struct|union %name% ;") &&
+        else if (tok->isKeyword() && Token::Match(tok, "class|struct|union %name% ;") &&
                  tok->strAt(-1) != "friend") {
             if (!findType(tok->next(), scope)) {
                 // fill typeList..
                 typeList.emplace_back(tok, nullptr, scope);
                 Type* new_type = &typeList.back();
                 scope->definedTypesMap[new_type->name()] = new_type;
+                forwardDecls[scope].insert(tok->strAt(1));
             }
             tok = tok->tokAt(2);
         }
 
         // using namespace
-        else if (mTokenizer->isCPP() && Token::Match(tok, "using namespace ::| %type% ;|::")) {
+        else if (tok->isCpp() && tok->isKeyword() && Token::Match(tok, "using namespace ::| %type% ;|::")) {
             Scope::UsingInfo using_info;
 
             using_info.start = tok; // save location
@@ -353,7 +443,7 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
         }
 
         // using type alias
-        else if (mTokenizer->isCPP() && Token::Match(tok, "using %name% =")) {
+        else if (tok->isCpp() && tok->isKeyword() && Token::Match(tok, "using %name% =") && !tok->tokAt(2)->isSimplifiedTypedef()) {
             if (tok->strAt(-1) != ">" && !findType(tok->next(), scope)) {
                 // fill typeList..
                 typeList.emplace_back(tok, nullptr, scope);
@@ -363,19 +453,23 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
 
             tok = tok->tokAt(3);
 
-            while (tok && tok->str() != ";")
-                tok = tok->next();
+            while (tok && tok->str() != ";") {
+                if (Token::simpleMatch(tok, "decltype ("))
+                    tok = tok->linkAt(1);
+                else
+                    tok = tok->next();
+            }
         }
 
         // unnamed struct and union
-        else if (Token::Match(tok, "struct|union {") &&
-                 Token::Match(tok->next()->link(), "} *|&| %name% ;|[|=")) {
-            scopeList.emplace_back(this, tok, scope);
+        else if (tok->isKeyword() && Token::Match(tok, "struct|union {") &&
+                 Token::Match(tok->linkAt(1), "} *|&| %name% ;|[|=")) {
+            scopeList.emplace_back(*this, tok, scope);
 
             Scope *new_scope = &scopeList.back();
             access[new_scope] = AccessControl::Public;
 
-            const Token* varNameTok = tok->next()->link()->next();
+            const Token* varNameTok = tok->linkAt(1)->next();
             if (varNameTok->str() == "*") {
                 varNameTok = varNameTok->next();
             } else if (varNameTok->str() == "&") {
@@ -389,12 +483,11 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
                 scope->definedTypesMap[new_type->name()] = new_type;
             }
 
-            scope->addVariable(varNameTok, tok, tok, access[scope], new_scope->definedType, scope, mSettings);
+            scope->addVariable(varNameTok, tok, tok, access[scope], new_scope->definedType, scope);
 
             const Token *tok2 = tok->next();
 
-            new_scope->bodyStart = tok2;
-            new_scope->bodyEnd = tok2->link();
+            new_scope->setBodyStartEnd(tok2);
 
             // make sure we have valid code
             if (!new_scope->bodyEnd) {
@@ -410,18 +503,17 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
         }
 
         // anonymous struct, union and namespace
-        else if ((Token::Match(tok, "struct|union {") &&
-                  Token::simpleMatch(tok->next()->link(), "} ;")) ||
-                 Token::simpleMatch(tok, "namespace {")) {
-            scopeList.emplace_back(this, tok, scope);
+        else if (tok->isKeyword() && ((Token::Match(tok, "struct|union {") &&
+                                       Token::simpleMatch(tok->linkAt(1), "} ;")) ||
+                                      Token::simpleMatch(tok, "namespace {"))) {
+            scopeList.emplace_back(*this, tok, scope);
 
             Scope *new_scope = &scopeList.back();
             access[new_scope] = AccessControl::Public;
 
             const Token *tok2 = tok->next();
 
-            new_scope->bodyStart = tok2;
-            new_scope->bodyEnd = tok2->link();
+            new_scope->setBodyStartEnd(tok2);
 
             typeList.emplace_back(tok, new_scope, scope);
             {
@@ -444,7 +536,7 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
         }
 
         // forward declared enum
-        else if (Token::Match(tok, "enum class| %name% ;") || Token::Match(tok, "enum class| %name% : %name% ;")) {
+        else if (tok->isKeyword() && (Token::Match(tok, "enum class| %name% ;") || Token::Match(tok, "enum class| %name% : %name% ;"))) {
             typeList.emplace_back(tok, nullptr, scope);
             Type* new_type = &typeList.back();
             scope->definedTypesMap[new_type->name()] = new_type;
@@ -453,8 +545,15 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
 
         // check for end of scope
         else if (tok == scope->bodyEnd) {
-            access.erase(scope);
-            scope = const_cast<Scope*>(scope->nestedIn);
+            do {
+                access.erase(scope);
+                scope = const_cast<Scope*>(scope->nestedIn);
+            } while (scope->type != ScopeType::eGlobal && succeeds(tok, scope->bodyEnd));
+            continue;
+        }
+        // check for end of init list
+        else if (inInitList() && tok == endInitList.top().first) {
+            endInitList.pop();
             continue;
         }
 
@@ -483,9 +582,9 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
             }
 
             // class function?
-            else if (isFunction(tok, scope, &funcStart, &argStart, &declEnd)) {
-                if (tok->previous()->str() != "::" || tok->strAt(-2) == scope->className) {
-                    Function function(mTokenizer, tok, scope, funcStart, argStart);
+            else if (isFunction(tok, scope, funcStart, argStart, declEnd)) {
+                if (tok->strAt(-1) != "::" || tok->strAt(-2) == scope->className) {
+                    Function function(tok, scope, funcStart, argStart);
 
                     // save the access type
                     function.access = access[scope];
@@ -501,9 +600,9 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
                     function.arg = function.argDef;
 
                     // out of line function
-                    if (const Token *endTok = mTokenizer->isFunctionHead(end, ";")) {
+                    if (const Token *endTok = TokenList::isFunctionHead(end, ";")) {
                         tok = endTok;
-                        scope->addFunction(function);
+                        scope->addFunction(std::move(function));
                     }
 
                     // inline function
@@ -532,7 +631,7 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
                         Function* funcptr = &scope->functionList.back();
                         const Token *tok2 = funcStart;
 
-                        addNewFunction(&scope, &tok2);
+                        addNewFunction(scope, tok2);
                         if (scope) {
                             scope->functionOf = function.nestedIn;
                             scope->function = funcptr;
@@ -549,7 +648,7 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
                     const Scope * const nested = scope->findInNestedListRecursive(tok->strAt(-2));
 
                     if (nested)
-                        addClassFunction(&scope, &tok, argStart);
+                        addClassFunction(scope, tok, argStart);
                     else {
                         /** @todo handle friend functions */
                     }
@@ -557,7 +656,7 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
             }
 
             // friend class declaration?
-            else if (mTokenizer->isCPP() && Token::Match(tok, "friend class| ::| %any% ;|::")) {
+            else if (tok->isCpp() && tok->isKeyword() && Token::Match(tok, "friend class|struct| ::| %any% ;|::")) {
                 Type::FriendInfo friendInfo;
 
                 // save the name start
@@ -576,48 +675,55 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
                 friendInfo.type = nullptr;
 
                 if (!scope->definedType)
-                    mTokenizer->syntaxError(tok);
+                    mTokenizer.syntaxError(tok);
 
                 scope->definedType->friendList.push_back(friendInfo);
             }
-        } else if (scope->type == Scope::eNamespace || scope->type == Scope::eGlobal) {
+        } else if (scope->type == ScopeType::eNamespace || scope->type == ScopeType::eGlobal) {
             const Token *funcStart = nullptr;
             const Token *argStart = nullptr;
             const Token *declEnd = nullptr;
 
             // function?
-            if (isFunction(tok, scope, &funcStart, &argStart, &declEnd)) {
+            if (isFunction(tok, scope, funcStart, argStart, declEnd)) {
                 // has body?
                 if (declEnd && declEnd->str() == "{") {
                     tok = funcStart;
 
                     // class function
-                    if (tok->previous() && tok->previous()->str() == "::")
-                        addClassFunction(&scope, &tok, argStart);
+                    if (tok->previous() && tok->strAt(-1) == "::")
+                        addClassFunction(scope, tok, argStart);
 
                     // class destructor
                     else if (tok->previous() &&
-                             tok->previous()->str() == "~" &&
+                             tok->strAt(-1) == "~" &&
                              tok->strAt(-2) == "::")
-                        addClassFunction(&scope, &tok, argStart);
+                        addClassFunction(scope, tok, argStart);
 
                     // regular function
                     else {
                         const Function* const function = addGlobalFunction(scope, tok, argStart, funcStart);
 
                         if (!function)
-                            mTokenizer->syntaxError(tok);
+                            mTokenizer.syntaxError(tok);
                     }
 
                     // syntax error?
                     if (!scope)
-                        mTokenizer->syntaxError(tok);
+                        mTokenizer.syntaxError(tok);
                 }
                 // function prototype?
                 else if (declEnd && declEnd->str() == ";") {
+                    if ((Token::simpleMatch(tok->tokAt(-1), "::") || (tok->tokAt(-1) && Token::simpleMatch(tok->tokAt(-2), ":: ~"))) &&
+                        Token::Match(declEnd->previous(), "default|delete")) {
+                        addClassFunction(scope, tok, argStart);
+                        continue;
+                    }
+
                     bool newFunc = true; // Is this function already in the database?
-                    for (std::multimap<std::string, const Function *>::const_iterator i = scope->functionMap.find(tok->str()); i != scope->functionMap.end() && i->first == tok->str(); ++i) {
-                        if (Function::argsMatch(scope, i->second->argDef, argStart, emptyString, 0)) {
+                    auto range = scope->functionMap.equal_range(tok->str());
+                    for (std::multimap<std::string, const Function*>::const_iterator it = range.first; it != range.second; ++it) {
+                        if (it->second->argsMatch(scope, it->second->argDef, argStart, "", 0)) {
                             newFunc = false;
                             break;
                         }
@@ -631,81 +737,121 @@ void SymbolDatabase::createSymbolDatabaseFindAllScopes()
                     tok = declEnd;
                     continue;
                 }
+            } else if (const Token *lambdaEndToken = findLambdaEndToken(tok)) {
+                tok = addLambda(tok, lambdaEndToken);
             }
         } else if (scope->isExecutable()) {
-            if (Token::Match(tok, "else|try|do {")) {
+            if (tok->isKeyword() && Token::Match(tok, "else|try|do {")) {
                 const Token* tok1 = tok->next();
                 if (tok->str() == "else")
-                    scopeList.emplace_back(this, tok, scope, Scope::eElse, tok1);
+                    scopeList.emplace_back(*this, tok, scope, ScopeType::eElse, tok1);
                 else if (tok->str() == "do")
-                    scopeList.emplace_back(this, tok, scope, Scope::eDo, tok1);
+                    scopeList.emplace_back(*this, tok, scope, ScopeType::eDo, tok1);
                 else //if (tok->str() == "try")
-                    scopeList.emplace_back(this, tok, scope, Scope::eTry, tok1);
+                    scopeList.emplace_back(*this, tok, scope, ScopeType::eTry, tok1);
 
                 tok = tok1;
                 scope->nestedList.push_back(&scopeList.back());
                 scope = &scopeList.back();
-            } else if (Token::Match(tok, "if|for|while|catch|switch (") && Token::simpleMatch(tok->next()->link(), ") {")) {
-                const Token *scopeStartTok = tok->next()->link()->next();
+            } else if (tok->isKeyword() && Token::Match(tok, "if|for|while|catch|switch (") && Token::simpleMatch(tok->linkAt(1), ") {")) {
+                const Token *scopeStartTok = tok->linkAt(1)->next();
                 if (tok->str() == "if")
-                    scopeList.emplace_back(this, tok, scope, Scope::eIf, scopeStartTok);
+                    scopeList.emplace_back(*this, tok, scope, ScopeType::eIf, scopeStartTok);
                 else if (tok->str() == "for") {
-                    scopeList.emplace_back(this, tok, scope, Scope::eFor, scopeStartTok);
+                    scopeList.emplace_back(*this, tok, scope, ScopeType::eFor, scopeStartTok);
                 } else if (tok->str() == "while")
-                    scopeList.emplace_back(this, tok, scope, Scope::eWhile, scopeStartTok);
+                    scopeList.emplace_back(*this, tok, scope, ScopeType::eWhile, scopeStartTok);
                 else if (tok->str() == "catch") {
-                    scopeList.emplace_back(this, tok, scope, Scope::eCatch, scopeStartTok);
+                    scopeList.emplace_back(*this, tok, scope, ScopeType::eCatch, scopeStartTok);
                 } else // if (tok->str() == "switch")
-                    scopeList.emplace_back(this, tok, scope, Scope::eSwitch, scopeStartTok);
+                    scopeList.emplace_back(*this, tok, scope, ScopeType::eSwitch, scopeStartTok);
 
                 scope->nestedList.push_back(&scopeList.back());
-                scope = &scopeList.back();
-                if (scope->type == Scope::eFor)
-                    scope->checkVariable(tok->tokAt(2), AccessControl::Local, mSettings); // check for variable declaration and add it to new scope if found
-                else if (scope->type == Scope::eCatch)
-                    scope->checkVariable(tok->tokAt(2), AccessControl::Throw, mSettings); // check for variable declaration and add it to new scope if found
-                tok = scopeStartTok;
+                Scope* newScope = &scopeList.back();
+                if (newScope->type == ScopeType::eFor)
+                    newScope->checkVariable(tok->tokAt(2), AccessControl::Local); // check for variable declaration and add it to new scope if found
+                else if (newScope->type == ScopeType::eCatch)
+                    newScope->checkVariable(tok->tokAt(2), AccessControl::Throw); // check for variable declaration and add it to new scope if found
+                tok = tok->next();
+                inIfCondition.push(scopeStartTok);
+                pendingIfScopes.push(newScope);
             } else if (Token::Match(tok, "%var% {")) {
-                tok = tok->linkAt(1);
+                endInitList.emplace(tok->linkAt(1), scope);
+                tok = tok->next();
             } else if (const Token *lambdaEndToken = findLambdaEndToken(tok)) {
-                const Token *lambdaStartToken = lambdaEndToken->link();
-                const Token * argStart = lambdaStartToken->astParent();
-                const Token * funcStart = Token::simpleMatch(argStart, "[") ? argStart : argStart->astParent();
-                const Function * function = addGlobalFunction(scope, tok, argStart, funcStart);
-                if (!function)
-                    mTokenizer->syntaxError(tok);
-                tok = lambdaStartToken;
+                tok = addLambda(tok, lambdaEndToken);
             } else if (tok->str() == "{") {
-                if (isExecutableScope(tok)) {
-                    scopeList.emplace_back(this, tok, scope, Scope::eUnconditional, tok);
+                if (inInitList()) {
+                    endInitList.emplace(tok->link(), scope);
+                } else if (!inIfCondition.empty() && tok == inIfCondition.top()) {
+                    inIfCondition.pop();
+                    scope = pendingIfScopes.top();
+                    pendingIfScopes.pop();
+                } else if (isExecutableScope(tok)) {
+                    scopeList.emplace_back(*this, tok, scope, ScopeType::eUnconditional, tok);
                     scope->nestedList.push_back(&scopeList.back());
                     scope = &scopeList.back();
                 } else {
-                    tok = tok->link();
+                    endInitList.emplace(tok->link(), scope);
+                }
+            } else if (Token::Match(tok, "extern %type%")) {
+                const Token * ftok = tok->next();
+                while (Token::Match(ftok, "%name%|*|&"))
+                    ftok = ftok->next();
+                if (!ftok || ftok->str() != "(")
+                    continue;
+                ftok = ftok->previous();
+                if (Token::simpleMatch(ftok->linkAt(1), ") ;")) {
+                    const Token *funcStart = nullptr;
+                    const Token *argStart = nullptr;
+                    const Token *declEnd = nullptr;
+                    if (isFunction(ftok, scope, funcStart, argStart, declEnd)) {
+                        if (declEnd && declEnd->str() == ";") {
+                            bool newFunc = true; // Is this function already in the database?
+                            auto range = scope->functionMap.equal_range(ftok->str());
+                            for (std::multimap<std::string, const Function*>::const_iterator it = range.first; it != range.second; ++it) {
+                                if (it->second->argsMatch(scope, it->second->argDef, argStart, "", 0)) {
+                                    newFunc = false;
+                                    break;
+                                }
+                            }
+                            // save function prototype in database
+                            if (newFunc) {
+                                Function function(ftok, scope, funcStart, argStart);
+                                if (function.isExtern()) {
+                                    scope->addFunction(std::move(function));
+                                    tok = declEnd;
+                                }
+                            }
+                        }
+                    }
                 }
             }
             // syntax error?
             if (!scope)
-                mTokenizer->syntaxError(tok);
+                mTokenizer.syntaxError(tok);
+            // End of scope or list should be handled above
+            if (tok->str() == "}")
+                mTokenizer.syntaxError(tok);
         }
     }
 }
 
 void SymbolDatabase::createSymbolDatabaseClassInfo()
 {
-    if (mTokenizer->isC())
+    if (mTokenizer.isC())
         return;
 
     // fill in using info
-    for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {
-        for (std::list<Scope::UsingInfo>::iterator i = it->usingList.begin(); i != it->usingList.end(); ++i) {
+    for (Scope& scope : scopeList) {
+        for (Scope::UsingInfo& usingInfo : scope.usingList) {
             // only find if not already found
-            if (i->scope == nullptr) {
+            if (usingInfo.scope == nullptr) {
                 // check scope for match
-                const Scope * const scope = findScope(i->start->tokAt(2), &(*it));
-                if (scope) {
+                const Scope * const found = findScope(usingInfo.start->tokAt(2), &scope);
+                if (found) {
                     // set found scope
-                    i->scope = scope;
+                    usingInfo.scope = found;
                     break;
                 }
             }
@@ -713,13 +859,13 @@ void SymbolDatabase::createSymbolDatabaseClassInfo()
     }
 
     // fill in base class info
-    for (std::list<Type>::iterator it = typeList.begin(); it != typeList.end(); ++it) {
+    for (Type& type : typeList) {
         // finish filling in base class info
-        for (Type::BaseInfo & i : it->derivedFrom) {
-            const Type* found = findType(i.nameTok, it->enclosingScope);
-            if (found && found->findDependency(&(*it))) {
+        for (Type::BaseInfo & i : type.derivedFrom) {
+            const Type* found = findType(i.nameTok, type.enclosingScope, /*lookOutside*/ true);
+            if (found && found->findDependency(&type)) {
                 // circular dependency
-                //mTokenizer->syntaxError(nullptr);
+                //mTokenizer.syntaxError(nullptr);
             } else {
                 i.type = found;
             }
@@ -727,9 +873,9 @@ void SymbolDatabase::createSymbolDatabaseClassInfo()
     }
 
     // fill in friend info
-    for (std::list<Type>::iterator it = typeList.begin(); it != typeList.end(); ++it) {
-        for (Type::FriendInfo &friendInfo : it->friendList) {
-            friendInfo.type = findType(friendInfo.nameStart, it->enclosingScope);
+    for (Type & type : typeList) {
+        for (Type::FriendInfo &friendInfo : type.friendList) {
+            friendInfo.type = findType(friendInfo.nameStart, type.enclosingScope);
         }
     }
 }
@@ -738,18 +884,16 @@ void SymbolDatabase::createSymbolDatabaseClassInfo()
 void SymbolDatabase::createSymbolDatabaseVariableInfo()
 {
     // fill in variable info
-    for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {
+    for (Scope& scope : scopeList) {
         // find variables
-        it->getVariableList(mSettings);
+        scope.getVariableList();
     }
 
     // fill in function arguments
-    for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {
-        std::list<Function>::iterator func;
-
-        for (func = it->functionList.begin(); func != it->functionList.end(); ++func) {
+    for (Scope& scope : scopeList) {
+        for (auto func = scope.functionList.begin(); func != scope.functionList.end(); ++func) {
             // add arguments
-            func->addArguments(this, &*it);
+            func->addArguments(&scope);
         }
     }
 }
@@ -757,26 +901,25 @@ void SymbolDatabase::createSymbolDatabaseVariableInfo()
 void SymbolDatabase::createSymbolDatabaseCopyAndMoveConstructors()
 {
     // fill in class and struct copy/move constructors
-    for (std::list<Scope>::iterator scope = scopeList.begin(); scope != scopeList.end(); ++scope) {
-        if (!scope->isClassOrStruct())
+    for (Scope& scope : scopeList) {
+        if (!scope.isClassOrStruct())
             continue;
 
-        std::list<Function>::iterator func;
-        for (func = scope->functionList.begin(); func != scope->functionList.end(); ++func) {
+        for (auto func = scope.functionList.begin(); func != scope.functionList.end(); ++func) {
             if (!func->isConstructor() || func->minArgCount() != 1)
                 continue;
 
             const Variable* firstArg = func->getArgumentVar(0);
-            if (firstArg->type() == scope->definedType) {
+            if (firstArg->type() == scope.definedType) {
                 if (firstArg->isRValueReference())
-                    func->type = Function::eMoveConstructor;
+                    func->type = FunctionType::eMoveConstructor;
                 else if (firstArg->isReference() && !firstArg->isPointer())
-                    func->type = Function::eCopyConstructor;
+                    func->type = FunctionType::eCopyConstructor;
             }
 
-            if (func->type == Function::eCopyConstructor ||
-                func->type == Function::eMoveConstructor)
-                scope->numCopyOrMoveConstructors++;
+            if (func->type == FunctionType::eCopyConstructor ||
+                func->type == FunctionType::eMoveConstructor)
+                scope.numCopyOrMoveConstructors++;
         }
     }
 }
@@ -784,35 +927,33 @@ void SymbolDatabase::createSymbolDatabaseCopyAndMoveConstructors()
 void SymbolDatabase::createSymbolDatabaseFunctionScopes()
 {
     // fill in function scopes
-    for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {
-        if (it->type == Scope::eFunction)
-            functionScopes.push_back(&*it);
+    for (const Scope & scope : scopeList) {
+        if (scope.type == ScopeType::eFunction)
+            functionScopes.push_back(&scope);
     }
 }
 
 void SymbolDatabase::createSymbolDatabaseClassAndStructScopes()
 {
     // fill in class and struct scopes
-    for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {
-        if (it->isClassOrStruct())
-            classAndStructScopes.push_back(&*it);
+    for (const Scope& scope : scopeList) {
+        if (scope.isClassOrStruct())
+            classAndStructScopes.push_back(&scope);
     }
 }
 
 void SymbolDatabase::createSymbolDatabaseFunctionReturnTypes()
 {
     // fill in function return types
-    for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {
-        std::list<Function>::iterator func;
-
-        for (func = it->functionList.begin(); func != it->functionList.end(); ++func) {
+    for (Scope& scope : scopeList) {
+        for (auto func = scope.functionList.begin(); func != scope.functionList.end(); ++func) {
             // add return types
             if (func->retDef) {
                 const Token *type = func->retDef;
                 while (Token::Match(type, "static|const|struct|union|enum"))
                     type = type->next();
                 if (type) {
-                    func->retType = findVariableTypeInBase(&*it, type);
+                    func->retType = findVariableTypeInBase(&scope, type);
                     if (!func->retType)
                         func->retType = findTypeInNested(type, func->nestedIn);
                 }
@@ -823,12 +964,11 @@ void SymbolDatabase::createSymbolDatabaseFunctionReturnTypes()
 
 void SymbolDatabase::createSymbolDatabaseNeedInitialization()
 {
-    if (mTokenizer->isC()) {
+    if (mTokenizer.isC()) {
         // For C code it is easy, as there are no constructors and no default values
-        for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {
-            Scope *scope = &(*it);
-            if (scope->definedType)
-                scope->definedType->needInitialization = Type::NeedInitialization::True;
+        for (const Scope& scope : scopeList) {
+            if (scope.definedType)
+                scope.definedType->needInitialization = Type::NeedInitialization::True;
         }
     } else {
         // For C++, it is more difficult: Determine if user defined type needs initialization...
@@ -838,30 +978,31 @@ void SymbolDatabase::createSymbolDatabaseNeedInitialization()
         do {
             unknowns = 0;
 
-            for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {
-                Scope *scope = &(*it);
+            for (Scope& scope : scopeList) {
+                if (!scope.isClassOrStructOrUnion())
+                    continue;
+                if (scope.classDef && Token::simpleMatch(scope.classDef->previous(), ">")) // skip uninstantiated template
+                    continue;
 
-                if (!scope->definedType) {
+                if (!scope.definedType) {
                     mBlankTypes.emplace_back();
-                    scope->definedType = &mBlankTypes.back();
+                    scope.definedType = &mBlankTypes.back();
                 }
 
-                if (scope->isClassOrStruct() && scope->definedType->needInitialization == Type::NeedInitialization::Unknown) {
+                if (scope.isClassOrStruct() && scope.definedType->needInitialization == Type::NeedInitialization::Unknown) {
                     // check for default constructor
                     bool hasDefaultConstructor = false;
 
-                    std::list<Function>::const_iterator func;
-
-                    for (func = scope->functionList.begin(); func != scope->functionList.end(); ++func) {
-                        if (func->type == Function::eConstructor) {
+                    for (const Function& func : scope.functionList) {
+                        if (func.type == FunctionType::eConstructor) {
                             // check for no arguments: func ( )
-                            if (func->argCount() == 0) {
+                            if (func.argCount() == 0) {
                                 hasDefaultConstructor = true;
                                 break;
                             }
 
                             /** check for arguments with default values */
-                            else if (func->argCount() == func->initializedArgCount()) {
+                            if (func.argCount() == func.initializedArgCount()) {
                                 hasDefaultConstructor = true;
                                 break;
                             }
@@ -872,52 +1013,53 @@ void SymbolDatabase::createSymbolDatabaseNeedInitialization()
                     // We assume the default constructor initializes everything.
                     // Another check will figure out if the constructor actually initializes everything.
                     if (hasDefaultConstructor)
-                        scope->definedType->needInitialization = Type::NeedInitialization::False;
+                        scope.definedType->needInitialization = Type::NeedInitialization::False;
 
                     // check each member variable to see if it needs initialization
                     else {
                         bool needInitialization = false;
                         bool unknown = false;
 
-                        std::list<Variable>::const_iterator var;
-                        for (var = scope->varlist.begin(); var != scope->varlist.end() && !needInitialization; ++var) {
-                            if (var->isClass()) {
-                                if (var->type()) {
+                        for (const Variable& var: scope.varlist) {
+                            if (var.isStatic())
+                                continue;
+                            if (var.isClass() && !var.isReference()) {
+                                if (var.type()) {
                                     // does this type need initialization?
-                                    if (var->type()->needInitialization == Type::NeedInitialization::True)
+                                    if (var.type()->needInitialization == Type::NeedInitialization::True && !var.hasDefault())
                                         needInitialization = true;
-                                    else if (var->type()->needInitialization == Type::NeedInitialization::Unknown) {
-                                        if (!(var->valueType() && var->valueType()->type == ValueType::CONTAINER))
+                                    else if (var.type()->needInitialization == Type::NeedInitialization::Unknown) {
+                                        if (!(var.valueType() && var.valueType()->type == ValueType::CONTAINER))
                                             unknown = true;
                                     }
                                 }
-                            } else if (!var->hasDefault())
+                            } else if (!var.hasDefault()) {
                                 needInitialization = true;
+                                break;
+                            }
                         }
 
                         if (needInitialization)
-                            scope->definedType->needInitialization = Type::NeedInitialization::True;
+                            scope.definedType->needInitialization = Type::NeedInitialization::True;
                         else if (!unknown)
-                            scope->definedType->needInitialization = Type::NeedInitialization::False;
+                            scope.definedType->needInitialization = Type::NeedInitialization::False;
                         else {
-                            if (scope->definedType->needInitialization == Type::NeedInitialization::Unknown)
+                            if (scope.definedType->needInitialization == Type::NeedInitialization::Unknown)
                                 unknowns++;
                         }
                     }
-                } else if (scope->type == Scope::eUnion && scope->definedType->needInitialization == Type::NeedInitialization::Unknown)
-                    scope->definedType->needInitialization = Type::NeedInitialization::True;
+                } else if (scope.type == ScopeType::eUnion && scope.definedType->needInitialization == Type::NeedInitialization::Unknown)
+                    scope.definedType->needInitialization = Type::NeedInitialization::True;
             }
 
             retry++;
         } while (unknowns && retry < 100);
 
         // this shouldn't happen so output a debug warning
-        if (retry == 100 && mSettings->debugwarnings) {
-            for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {
-                const Scope *scope = &(*it);
-
-                if (scope->isClassOrStruct() && scope->definedType->needInitialization == Type::NeedInitialization::Unknown)
-                    debugMessage(scope->classDef, "SymbolDatabase::SymbolDatabase couldn't resolve all user defined types.");
+        if (retry == 100 && mSettings.debugwarnings) {
+            for (const Scope& scope : scopeList) {
+                if (scope.isClassOrStruct() && scope.definedType->needInitialization == Type::NeedInitialization::Unknown)
+                    debugMessage(scope.classDef, "debug", "SymbolDatabase couldn't resolve all user defined types.");
             }
         }
     }
@@ -926,39 +1068,36 @@ void SymbolDatabase::createSymbolDatabaseNeedInitialization()
 void SymbolDatabase::createSymbolDatabaseVariableSymbolTable()
 {
     // create variable symbol table
-    mVariableList.resize(mTokenizer->varIdCount() + 1);
-    std::fill_n(mVariableList.begin(), mVariableList.size(), (const Variable*)nullptr);
+    mVariableList.resize(mTokenizer.varIdCount() + 1);
+    std::fill_n(mVariableList.begin(), mVariableList.size(), nullptr);
 
     // check all scopes for variables
-    for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {
-        Scope *scope = &(*it);
-
+    for (Scope& scope : scopeList) {
         // add all variables
-        for (std::list<Variable>::iterator var = scope->varlist.begin(); var != scope->varlist.end(); ++var) {
-            const unsigned int varId = var->declarationId();
+        for (Variable& var: scope.varlist) {
+            const int varId = var.declarationId();
             if (varId)
-                mVariableList[varId] = &(*var);
+                mVariableList[varId] = &var;
             // fix up variables without type
-            if (!var->type() && !var->typeStartToken()->isStandardType()) {
-                const Type *type = findType(var->typeStartToken(), scope);
+            if (!var.type() && !var.typeStartToken()->isStandardType()) {
+                const Type *type = findType(var.typeStartToken(), &scope);
                 if (type)
-                    var->type(type);
+                    var.type(type);
             }
         }
 
         // add all function parameters
-        for (std::list<Function>::iterator func = scope->functionList.begin(); func != scope->functionList.end(); ++func) {
-            for (std::list<Variable>::iterator arg = func->argumentList.begin(); arg != func->argumentList.end(); ++arg) {
+        for (Function& func : scope.functionList) {
+            for (Variable& arg: func.argumentList) {
                 // check for named parameters
-                if (arg->nameToken() && arg->declarationId()) {
-                    const unsigned int declarationId = arg->declarationId();
-                    if (declarationId > 0U)
-                        mVariableList[declarationId] = &(*arg);
+                if (arg.nameToken() && arg.declarationId()) {
+                    const int declarationId = arg.declarationId();
+                    mVariableList[declarationId] = &arg;
                     // fix up parameters without type
-                    if (!arg->type() && !arg->typeStartToken()->isStandardType()) {
-                        const Type *type = findTypeInNested(arg->typeStartToken(), scope);
+                    if (!arg.type() && !arg.typeStartToken()->isStandardType()) {
+                        const Type *type = findTypeInNested(arg.typeStartToken(), &scope);
                         if (type)
-                            arg->type(type);
+                            arg.type(type);
                     }
                 }
             }
@@ -966,24 +1105,24 @@ void SymbolDatabase::createSymbolDatabaseVariableSymbolTable()
     }
 
     // fill in missing variables if possible
-    const std::size_t functions = functionScopes.size();
-    for (std::size_t i = 0; i < functions; ++i) {
-        const Scope *func = functionScopes[i];
+    for (const Scope *func: functionScopes) {
         for (const Token *tok = func->bodyStart->next(); tok && tok != func->bodyEnd; tok = tok->next()) {
             // check for member variable
-            if (tok->varId() && tok->next() &&
-                (tok->next()->str() == "." ||
-                 (tok->next()->str() == "[" && tok->linkAt(1)->strAt(1) == "."))) {
-                const Token *tok1 = tok->next()->str() == "." ? tok->tokAt(2) : tok->linkAt(1)->tokAt(2);
-                if (tok1 && tok1->varId() && mVariableList[tok1->varId()] == nullptr) {
-                    const Variable *var = mVariableList[tok->varId()];
-                    if (var && var->typeScope()) {
-                        // find the member variable of this variable
-                        const Variable *var1 = var->typeScope()->getVariable(tok1->str());
-                        if (var1) {
-                            // add this variable to the look up table
-                            mVariableList[tok1->varId()] = var1;
-                        }
+            if (!Token::Match(tok, "%var% .|["))
+                continue;
+            const Token* tokDot = tok->next();
+            while (Token::simpleMatch(tokDot, "["))
+                tokDot = tokDot->link()->next();
+            if (!Token::Match(tokDot, ". %var%"))
+                continue;
+            const Token *member = tokDot->next();
+            if (mVariableList[member->varId()] == nullptr) {
+                const Variable *var1 = mVariableList[tok->varId()];
+                if (var1 && var1->typeScope()) {
+                    const Variable* memberVar = var1->typeScope()->getVariable(member->str());
+                    if (memberVar) {
+                        // add this variable to the look up table
+                        mVariableList[member->varId()] = memberVar;
                     }
                 }
             }
@@ -993,26 +1132,20 @@ void SymbolDatabase::createSymbolDatabaseVariableSymbolTable()
 
 void SymbolDatabase::createSymbolDatabaseSetScopePointers()
 {
-    // Set scope pointers
-    for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {
-        Token* start = const_cast<Token*>(it->bodyStart);
-        Token* end = const_cast<Token*>(it->bodyEnd);
-        if (it->type == Scope::eGlobal) {
-            start = const_cast<Token*>(mTokenizer->list.front());
-            end = const_cast<Token*>(mTokenizer->list.back());
-        }
-        assert(start);
-        assert(end);
+    auto setScopePointers = [](const Scope &scope, const Token *bodyStart, const Token *bodyEnd) {
+        assert(bodyStart);
+        assert(bodyEnd);
 
-        end->scope(&*it);
+        const_cast<Token *>(bodyEnd)->scope(&scope);
 
-        for (Token* tok = start; tok != end; tok = tok->next()) {
-            if (start != end && tok->str() == "{") {
+        for (auto* tok = const_cast<Token *>(bodyStart); tok != bodyEnd; tok = tok->next()) {
+            if (bodyStart != bodyEnd && tok->str() == "{") {
                 bool isEndOfScope = false;
-                for (std::list<Scope*>::const_iterator innerScope = it->nestedList.begin(); innerScope != it->nestedList.end(); ++innerScope) {
-                    if (tok == (*innerScope)->bodyStart) { // Is begin of inner scope
+                for (Scope* innerScope: scope.nestedList) {
+                    const auto &list = innerScope->bodyStartList;
+                    if (std::find(list.cbegin(), list.cend(), tok) != list.cend()) {     // Is begin of inner scope
                         tok = tok->link();
-                        if (tok->next() == end || !tok->next()) {
+                        if (tok->next() == bodyEnd || !tok->next()) {
                             isEndOfScope = true;
                             break;
                         }
@@ -1023,7 +1156,17 @@ void SymbolDatabase::createSymbolDatabaseSetScopePointers()
                 if (isEndOfScope)
                     break;
             }
-            tok->scope(&*it);
+            tok->scope(&scope);
+        }
+    };
+
+    // Set scope pointers
+    for (const Scope& scope: scopeList) {
+        if (scope.type == ScopeType::eGlobal)
+            setScopePointers(scope, mTokenizer.list.front(), mTokenizer.list.back());
+        else {
+            for (const Token *bodyStart: scope.bodyStartList)
+                setScopePointers(scope, bodyStart, bodyStart->link());
         }
     }
 }
@@ -1032,32 +1175,45 @@ void SymbolDatabase::createSymbolDatabaseSetFunctionPointers(bool firstPass)
 {
     if (firstPass) {
         // Set function definition and declaration pointers
-        for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {
-            for (std::list<Function>::const_iterator func = it->functionList.begin(); func != it->functionList.end(); ++func) {
-                if (func->tokenDef)
-                    const_cast<Token *>(func->tokenDef)->function(&*func);
+        for (const Scope& scope: scopeList) {
+            for (const Function& func: scope.functionList) {
+                if (func.tokenDef)
+                    const_cast<Token *>(func.tokenDef)->function(&func);
 
-                if (func->token)
-                    const_cast<Token *>(func->token)->function(&*func);
+                if (func.token)
+                    const_cast<Token *>(func.token)->function(&func);
             }
         }
     }
 
     // Set function call pointers
-    for (const Token* tok = mTokenizer->list.front(); tok != mTokenizer->list.back(); tok = tok->next()) {
-        if (!tok->function() && tok->varId() == 0 && Token::Match(tok, "%name% (") && !isReservedName(tok->str())) {
+    const Token* inTemplateArg = nullptr;
+    for (Token* tok = mTokenizer.list.front(); tok != mTokenizer.list.back(); tok = tok->next()) {
+        if (inTemplateArg == nullptr && tok->link() && tok->str() == "<")
+            inTemplateArg = tok->link();
+        if (inTemplateArg == tok)
+            inTemplateArg = nullptr;
+        if (tok->isName() && !tok->function() && tok->varId() == 0 && ((tok->astParent() && tok->astParent()->isComparisonOp()) || Token::Match(tok, "%name% [{}(,)>;:]]")) && !isReservedName(tok)) {
+            if (tok->strAt(1) == ">" && !tok->linkAt(1))
+                continue;
+
             const Function *function = findFunction(tok);
-            if (function)
-                const_cast<Token *>(tok)->function(function);
+            if (!function || (inTemplateArg && function->isConstructor()))
+                continue;
+
+            tok->function(function);
+
+            if (tok->strAt(1) != "(")
+                const_cast<Function *>(function)->functionPointerUsage = tok;
         }
     }
 
     // Set C++ 11 delegate constructor function call pointers
-    for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {
-        for (std::list<Function>::const_iterator func = it->functionList.begin(); func != it->functionList.end(); ++func) {
+    for (const Scope& scope: scopeList) {
+        for (const Function& func: scope.functionList) {
             // look for initializer list
-            if (func->isConstructor() && func->functionScope && func->functionScope->functionOf && func->arg) {
-                const Token * tok = func->arg->link()->next();
+            if (func.isConstructor() && func.functionScope && func.functionScope->functionOf && func.arg) {
+                const Token * tok = func.arg->link()->next();
                 if (tok->str() == "noexcept") {
                     const Token * closingParenTok = tok->linkAt(1);
                     if (!closingParenTok || !closingParenTok->next()) {
@@ -1069,10 +1225,10 @@ void SymbolDatabase::createSymbolDatabaseSetFunctionPointers(bool firstPass)
                     continue;
                 }
                 tok = tok->next();
-                while (tok && tok != func->functionScope->bodyStart) {
+                while (tok && tok != func.functionScope->bodyStart) {
                     if (Token::Match(tok, "%name% {|(")) {
-                        if (tok->str() == func->tokenDef->str()) {
-                            const Function *function = func->functionScope->functionOf->findFunction(tok);
+                        if (tok->str() == func.tokenDef->str()) {
+                            const Function *function = func.functionScope->functionOf->findFunction(tok);
                             if (function)
                                 const_cast<Token *>(tok)->function(function);
                             break;
@@ -1088,42 +1244,58 @@ void SymbolDatabase::createSymbolDatabaseSetFunctionPointers(bool firstPass)
 
 void SymbolDatabase::createSymbolDatabaseSetTypePointers()
 {
-    std::set<std::string> typenames;
+    std::unordered_set<std::string> typenames;
     for (const Type &t : typeList) {
         typenames.insert(t.name());
     }
 
     // Set type pointers
-    for (const Token* tok = mTokenizer->list.front(); tok != mTokenizer->list.back(); tok = tok->next()) {
+    for (Token* tok = mTokenizer.list.front(); tok != mTokenizer.list.back(); tok = tok->next()) {
         if (!tok->isName() || tok->varId() || tok->function() || tok->type() || tok->enumerator())
             continue;
 
+        if (Token::simpleMatch(tok->next(), "<"))
+            continue;
+
         if (typenames.find(tok->str()) == typenames.end())
             continue;
 
         const Type *type = findVariableType(tok->scope(), tok);
         if (type)
-            const_cast<Token *>(tok)->type(type);
+            tok->type(type);
+    }
+}
+
+void SymbolDatabase::createSymbolDatabaseSetSmartPointerType()
+{
+    for (Scope &scope: scopeList) {
+        for (Variable &var: scope.varlist) {
+            if (var.valueType() && var.valueType()->smartPointerTypeToken && !var.valueType()->smartPointerType) {
+                ValueType vt(*var.valueType());
+                vt.smartPointerType = vt.smartPointerTypeToken->type();
+                var.setValueType(vt);
+            }
+        }
     }
 }
 
 void SymbolDatabase::fixVarId(VarIdMap & varIds, const Token * vartok, Token * membertok, const Variable * membervar)
 {
-    VarIdMap::iterator varId = varIds.find(vartok->varId());
+    auto varId = varIds.find(vartok->varId());
     if (varId == varIds.end()) {
         MemberIdMap memberId;
         if (membertok->varId() == 0) {
-            memberId[membervar->nameToken()->varId()] = const_cast<Tokenizer *>(mTokenizer)->newVarId();
+            memberId[membervar->nameToken()->varId()] = mTokenizer.newVarId();
             mVariableList.push_back(membervar);
         } else
             mVariableList[membertok->varId()] = membervar;
-        varIds.insert(std::make_pair(vartok->varId(), memberId));
+        varIds.emplace(vartok->varId(), memberId);
         varId = varIds.find(vartok->varId());
     }
-    MemberIdMap::iterator memberId = varId->second.find(membervar->nameToken()->varId());
-    if (memberId == varId->second.end()) {
+    auto memberId = utils::as_const(varId->second).find(membervar->nameToken()->varId());
+    if (memberId == varId->second.cend()) {
         if (membertok->varId() == 0) {
-            varId->second.insert(std::make_pair(membervar->nameToken()->varId(), const_cast<Tokenizer *>(mTokenizer)->newVarId()));
+            varId->second.emplace(membervar->nameToken()->varId(), mTokenizer.newVarId());
             mVariableList.push_back(membervar);
             memberId = varId->second.find(membervar->nameToken()->varId());
         } else
@@ -1133,53 +1305,85 @@ void SymbolDatabase::fixVarId(VarIdMap & varIds, const Token * vartok, Token * m
         membertok->varId(memberId->second);
 }
 
+static bool isContainerYieldElement(Library::Container::Yield yield);
+
 void SymbolDatabase::createSymbolDatabaseSetVariablePointers()
 {
     VarIdMap varIds;
 
+    auto setMemberVar = [&](const Variable* membervar, Token* membertok, const Token* vartok) -> void {
+        if (membervar) {
+            membertok->variable(membervar);
+            if (vartok && (membertok->varId() == 0 || mVariableList[membertok->varId()] == nullptr))
+                fixVarId(varIds, vartok, membertok, membervar);
+        }
+    };
+
     // Set variable pointers
-    for (const Token* tok = mTokenizer->list.front(); tok != mTokenizer->list.back(); tok = tok->next()) {
+    for (Token* tok = mTokenizer.list.front(); tok != mTokenizer.list.back(); tok = tok->next()) {
+        if (!tok->isName() || tok->isKeyword() || tok->isStandardType())
+            continue;
         if (tok->varId())
-            const_cast<Token *>(tok)->variable(getVariableFromVarId(tok->varId()));
+            tok->variable(getVariableFromVarId(tok->varId()));
 
         // Set Token::variable pointer for array member variable
         // Since it doesn't point at a fixed location it doesn't have varid
-        if (tok->variable() != nullptr &&
-            (tok->variable()->typeScope() || (tok->valueType() && tok->valueType()->type == ValueType::CONTAINER)) &&
-            Token::Match(tok, "%name% [|.")) {
-
-            Token *tok2 = tok->next();
-            // Locate "]"
-            while (tok2 && tok2->str() == "[")
-                tok2 = tok2->link()->next();
-
-            Token *membertok = nullptr;
-            if (Token::Match(tok2, ". %name%"))
-                membertok = tok2->next();
-            else if (Token::Match(tok2, ") . %name%") && tok->strAt(-1) == "(")
-                membertok = tok2->tokAt(2);
+        const bool isVar = tok->variable() && (tok->variable()->typeScope() || tok->variable()->isSmartPointer() ||
+                                               (tok->valueType() && (tok->valueType()->type == ValueType::CONTAINER || tok->valueType()->type == ValueType::ITERATOR)));
+        const bool isArrayAccess = isVar && Token::simpleMatch(tok->astParent(), "[");
+        const bool isDirectAccess = isVar && !isArrayAccess && Token::simpleMatch(tok->astParent(), ".");
+        const bool isDerefAccess = isVar && !isDirectAccess && Token::simpleMatch(tok->astParent(), "*") && Token::simpleMatch(tok->astParent()->astParent(), ".");
+        if (isVar && (isArrayAccess || isDirectAccess || isDerefAccess)) {
+            Token* membertok{};
+            if (isArrayAccess) {
+                membertok = tok->astParent();
+                while (Token::simpleMatch(membertok, "["))
+                    membertok = membertok->astParent();
+                if (membertok)
+                    membertok = membertok->astOperand2();
+            }
+            else if (isDirectAccess) {
+                membertok = tok->astParent()->astOperand2();
+                if (membertok == tok) {
+                    Token* gptok = tok->astParent()->astParent();
+                    if (Token::simpleMatch(gptok, ".")) // chained access
+                        membertok = gptok->astOperand2();
+                    else if (Token::simpleMatch(gptok, "[") && Token::simpleMatch(gptok->astParent(), "."))
+                        membertok = gptok->astParent()->astOperand2();
+                }
+            }
+            else { // isDerefAccess
+                membertok = tok->astParent();
+                while (Token::simpleMatch(membertok, "*"))
+                    membertok = membertok->astParent();
+                if (membertok)
+                    membertok = membertok->astOperand2();
+            }
 
-            if (membertok) {
+            if (membertok && membertok != tok) {
                 const Variable *var = tok->variable();
-                if (var && var->typeScope()) {
+                if (var->typeScope()) {
                     const Variable *membervar = var->typeScope()->getVariable(membertok->str());
-                    if (membervar) {
-                        membertok->variable(membervar);
-                        if (membertok->varId() == 0 || mVariableList[membertok->varId()] == nullptr)
-                            fixVarId(varIds, tok, const_cast<Token *>(membertok), membervar);
-                    }
-                } else if (var && tok->valueType() && tok->valueType()->type == ValueType::CONTAINER) {
-                    if (Token::Match(var->typeStartToken(), "std :: %type% < %type% *| *| >")) {
-                        const Type * type = var->typeStartToken()->tokAt(4)->type();
-                        if (type && type->classScope && type->classScope->definedType) {
-                            const Variable *membervar = type->classScope->getVariable(membertok->str());
-                            if (membervar) {
-                                membertok->variable(membervar);
-                                if (membertok->varId() == 0 || mVariableList[membertok->varId()] == nullptr)
-                                    fixVarId(varIds, tok, const_cast<Token *>(membertok), membervar);
-                            }
+                    setMemberVar(membervar, membertok, tok);
+                } else if (const ::Type *type = var->smartPointerType()) {
+                    const Scope *classScope = type->classScope;
+                    const Variable *membervar = classScope ? classScope->getVariable(membertok->str()) : nullptr;
+                    setMemberVar(membervar, membertok, tok);
+                } else if (tok->valueType() && tok->valueType()->type == ValueType::CONTAINER) {
+                    if (const Token* ctt = tok->valueType()->containerTypeToken) {
+                        while (ctt && ctt->isKeyword())
+                            ctt = ctt->next();
+                        const Type* ct = findTypeInNested(ctt, tok->scope());
+                        if (ct && ct->classScope && ct->classScope->definedType) {
+                            const Variable *membervar = ct->classScope->getVariable(membertok->str());
+                            setMemberVar(membervar, membertok, tok);
                         }
                     }
+                } else if (const Type* iterType = var->iteratorType()) {
+                    if (iterType->classScope && iterType->classScope->definedType) {
+                        const Variable *membervar = iterType->classScope->getVariable(membertok->str());
+                        setMemberVar(membervar, membertok, tok);
+                    }
                 }
             }
         }
@@ -1187,210 +1391,445 @@ void SymbolDatabase::createSymbolDatabaseSetVariablePointers()
         // check for function returning record type
         // func(...).var
         // func(...)[...].var
-        else if (tok->function() && tok->next()->str() == "(" &&
-                 (Token::Match(tok->next()->link(), ") . %name% !!(") ||
-                  (Token::Match(tok->next()->link(), ") [") && Token::Match(tok->next()->link()->next()->link(), "] . %name% !!(")))) {
+        else if (tok->function() && tok->strAt(1) == "(" &&
+                 (Token::Match(tok->linkAt(1), ") . %name% !!(") ||
+                  (Token::Match(tok->linkAt(1), ") [") && Token::Match(tok->linkAt(1)->linkAt(1), "] . %name% !!(")))) {
             const Type *type = tok->function()->retType;
+            Token* membertok;
+            if (tok->linkAt(1)->strAt(1) == ".")
+                membertok = tok->linkAt(1)->tokAt(2);
+            else
+                membertok = tok->linkAt(1)->linkAt(1)->tokAt(2);
             if (type) {
-                Token *membertok;
-                if (tok->next()->link()->next()->str() == ".")
-                    membertok = tok->next()->link()->next()->next();
-                else
-                    membertok = tok->next()->link()->next()->link()->next()->next();
                 const Variable *membervar = membertok->variable();
                 if (!membervar) {
                     if (type->classScope) {
                         membervar = type->classScope->getVariable(membertok->str());
-                        if (membervar) {
-                            membertok->variable(membervar);
-                            if (membertok->varId() == 0 || mVariableList[membertok->varId()] == nullptr) {
-                                if (tok->function()->retDef)
-                                    fixVarId(varIds, tok->function()->retDef, const_cast<Token *>(membertok), membervar);
-                            }
+                        setMemberVar(membervar, membertok, tok->function()->retDef);
+                    }
+                }
+            } else if (mSettings.library.detectSmartPointer(tok->function()->retDef)) {
+                if (const Token* templateArg = Token::findsimplematch(tok->function()->retDef, "<")) {
+                    if (const Type* spType = findTypeInNested(templateArg->next(), tok->scope())) {
+                        if (spType->classScope) {
+                            const Variable* membervar = spType->classScope->getVariable(membertok->str());
+                            setMemberVar(membervar, membertok, tok->function()->retDef);
                         }
                     }
                 }
             }
         }
+        else if (Token::simpleMatch(tok->astParent(), ".") && tok->strAt(1) == "(" &&
+                 astIsContainer(tok->astParent()->astOperand1()) && Token::Match(tok->linkAt(1), ") . %name% !!(")) {
+            const ValueType* vt = tok->astParent()->astOperand1()->valueType();
+            const Library::Container* cont = vt->container;
+            auto it = cont->functions.find(tok->str());
+            if (it != cont->functions.end() && isContainerYieldElement(it->second.yield) && vt->containerTypeToken) {
+                Token* memberTok = tok->linkAt(1)->tokAt(2);
+                const Scope* scope = vt->containerTypeToken->scope();
+                const Type* contType{};
+                const std::string& typeStr = vt->containerTypeToken->str(); // TODO: handle complex type expressions
+                while (scope && !contType) {
+                    contType = scope->findType(typeStr); // find the type stored in the container
+                    scope = scope->nestedIn;
+                }
+                if (contType && contType->classScope) {
+                    const Variable* membervar = contType->classScope->getVariable(memberTok->str());
+                    setMemberVar(membervar, memberTok, vt->containerTypeToken);
+                }
+            }
+        }
     }
 }
 
 void SymbolDatabase::createSymbolDatabaseEnums()
 {
     // fill in enumerators in enum
-    for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {
-        if (it->type != Scope::eEnum)
+    for (const Scope &scope : scopeList) {
+        if (scope.type != ScopeType::eEnum)
             continue;
 
         // add enumerators to enumerator tokens
-        for (Enumerator & i : it->enumeratorList)
+        for (const Enumerator & i : scope.enumeratorList)
             const_cast<Token *>(i.name)->enumerator(&i);
     }
 
-    // fill in enumerator values
-    for (std::list<Scope>::iterator it = scopeList.begin(); it != scopeList.end(); ++it) {
-        if (it->type != Scope::eEnum)
-            continue;
+    std::set<std::string> tokensThatAreNotEnumeratorValues;
 
-        MathLib::bigint value = 0;
+    for (const Scope &scope : scopeList) {
+        if (scope.type != ScopeType::eEnum)
+            continue;
 
-        for (Enumerator & enumerator : it->enumeratorList) {
+        for (const Enumerator & enumerator : scope.enumeratorList) {
             // look for initialization tokens that can be converted to enumerators and convert them
             if (enumerator.start) {
                 if (!enumerator.end)
-                    mTokenizer->syntaxError(enumerator.start);
+                    mTokenizer.syntaxError(enumerator.start);
                 for (const Token * tok3 = enumerator.start; tok3 && tok3 != enumerator.end->next(); tok3 = tok3->next()) {
                     if (tok3->tokType() == Token::eName) {
-                        const Enumerator * e = findEnumerator(tok3);
+                        const Enumerator * e = findEnumerator(tok3, tokensThatAreNotEnumeratorValues);
                         if (e)
                             const_cast<Token *>(tok3)->enumerator(e);
                     }
                 }
-
-                // look for possible constant folding expressions
-                // rhs of operator:
-                Token *rhs = enumerator.start->previous()->astOperand2();
-
-                // constant folding of expression:
-                ValueFlow::valueFlowConstantFoldAST(rhs, mSettings);
-
-                // get constant folded value:
-                if (rhs && rhs->hasKnownIntValue()) {
-                    enumerator.value = rhs->values().front().intvalue;
-                    enumerator.value_known = true;
-                    value = enumerator.value + 1;
-                }
-            }
-
-            // not initialized so use default value
-            else {
-                enumerator.value = value++;
-                enumerator.value_known = true;
             }
         }
     }
 
     // find enumerators
-    for (const Token* tok = mTokenizer->list.front(); tok != mTokenizer->list.back(); tok = tok->next()) {
-        if (tok->tokType() != Token::eName)
+    for (Token* tok = mTokenizer.list.front(); tok != mTokenizer.list.back(); tok = tok->next()) {
+        const bool isVariable = (tok->tokType() == Token::eVariable && !tok->variable());
+        if (tok->tokType() != Token::eName && !isVariable)
             continue;
-        const Enumerator * enumerator = findEnumerator(tok);
-        if (enumerator)
-            const_cast<Token *>(tok)->enumerator(enumerator);
+        const Enumerator * enumerator = findEnumerator(tok, tokensThatAreNotEnumeratorValues);
+        if (enumerator) {
+            if (isVariable)
+                tok->varId(0);
+            tok->enumerator(enumerator);
+        }
     }
 }
 
 void SymbolDatabase::createSymbolDatabaseIncompleteVars()
 {
-    const std::set<std::string> cpp20keywords = {
-        "alignas",
-        "alignof",
-        "axiom",
-        "co_await",
-        "co_return",
-        "co_yield",
-        "concept",
-        "synchronized",
-        "consteval",
-        "reflexpr",
-        "requires",
-    };
-    const std::set<std::string> cppkeywords = {
-        "asm",
-        "auto",
-        "catch",
-        "char",
-        "class",
-        "const",
-        "constexpr",
-        "decltype",
-        "default",
-        "do",
-        "enum",
-        "explicit",
-        "export",
-        "extern",
-        "final",
-        "friend",
-        "inline",
-        "mutable",
-        "namespace",
-        "new",
-        "noexcept",
-        "override",
-        "private",
-        "protected",
-        "public",
-        "register",
-        "sizeof",
-        "static",
-        "static_assert",
-        "struct",
-        "template",
-        "this",
-        "thread_local",
-        "throw",
-        "try",
-        "typedef",
-        "typeid",
-        "typename",
-        "union",
-        "using",
-        "virtual",
-        "void",
-        "volatile",
-    };
-    for (const Token* tok = mTokenizer->list.front(); tok != mTokenizer->list.back(); tok = tok->next()) {
+    for (Token* tok = mTokenizer.list.front(); tok != mTokenizer.list.back(); tok = tok->next()) {
         const Scope * scope = tok->scope();
         if (!scope)
             continue;
         if (!scope->isExecutable())
             continue;
-        if (!Token::Match(tok, "%name%"))
+        if (tok->varId() != 0)
+            continue;
+        if (tok->isCast() && !isCPPCast(tok) && tok->link() && tok->str() == "(") {
+            tok = tok->link();
             continue;
-        if (!tok->isNameOnly())
+        }
+        if (tok->isCpp()) {
+            if (Token::Match(tok, "catch|typeid (") ||
+                Token::Match(tok, "static_cast|dynamic_cast|const_cast|reinterpret_cast")) {
+                tok = tok->linkAt(1);
+                continue;
+            }
+            if (tok->str() == "using") {
+                Token* usingEnd = Token::findsimplematch(tok, ";");
+                if (!usingEnd)
+                    mTokenizer.syntaxError(tok);
+                tok = usingEnd;
+                continue;
+            }
+        }
+        if (tok->str() == "NULL")
             continue;
-        if (Token::Match(tok, "%var%"))
+        if (tok->isKeyword() || !tok->isNameOnly())
             continue;
         if (tok->type())
             continue;
-        if (Token::Match(tok->next(), "::|.|(|:|%var%"))
+        if (Token::Match(tok->next(), "::|.|(|{|:|%var%"))
             continue;
-        if (Token::Match(tok->next(), "&|&&|* )|%var%"))
+        if (Token::Match(tok->next(), "&|&&|* *| *| )|,|%var%|const"))
             continue;
-        if (Token::simpleMatch(tok->next(), ")") && Token::simpleMatch(tok->next()->link()->previous(), "catch ("))
+        if (Token::Match(tok->previous(), "%str%"))
             continue;
         // Very likely a typelist
-        if (Token::Match(tok->tokAt(-2), "%type% ,"))
+        if (Token::Match(tok->tokAt(-2), "%type% ,") || Token::Match(tok->next(), ", %type%"))
             continue;
         // Inside template brackets
-        if (Token::Match(tok->next(), "<|>") && tok->next()->link())
-            continue;
-        if (Token::simpleMatch(tok->previous(), "<") && tok->previous()->link())
+        if (Token::simpleMatch(tok->next(), "<") && tok->linkAt(1)) {
+            tok = tok->linkAt(1);
             continue;
+        }
         // Skip goto labels
         if (Token::simpleMatch(tok->previous(), "goto"))
             continue;
-        if (cppkeywords.count(tok->str()) > 0)
-            continue;
-        if (mSettings->standards.cpp >= Standards::CPP20 && cpp20keywords.count(tok->str()) > 0)
+        std::string fstr = tok->str();
+        const Token* ftok = tok->previous();
+        while (Token::simpleMatch(ftok, "::")) {
+            if (!Token::Match(ftok->previous(), "%name%"))
+                break;
+            fstr.insert(0, ftok->strAt(-1) + "::");
+            ftok = ftok->tokAt(-2);
+        }
+        if (mSettings.library.functions().find(fstr) != mSettings.library.functions().end())
             continue;
-        const_cast<Token *>(tok)->isIncompleteVar(true);
+        if (tok->isCpp()) {
+            const Token* parent = tok->astParent();
+            while (Token::Match(parent, "::|[|{"))
+                parent = parent->astParent();
+            if (Token::simpleMatch(parent, "new"))
+                continue;
+            // trailing return type
+            if (Token::simpleMatch(ftok, ".") && ftok->originalName() == "->" && Token::Match(ftok->tokAt(-1), "[])]"))
+                continue;
+        }
+        tok->isIncompleteVar(true);
     }
 }
 
+// cppcheck-suppress functionConst - has side effects
 void SymbolDatabase::createSymbolDatabaseEscapeFunctions()
 {
-    for (Scope & scope : scopeList) {
-        if (scope.type != Scope::eFunction)
+    for (const Scope& scope : scopeList) {
+        if (scope.type != ScopeType::eFunction)
             continue;
         Function * function = scope.function;
         if (!function)
             continue;
-        function->isEscapeFunction(isReturnScope(scope.bodyEnd, mSettings, true));
+        if (Token::findsimplematch(scope.bodyStart, "return", scope.bodyEnd))
+            continue;
+        function->isEscapeFunction(isReturnScope(scope.bodyEnd, mSettings.library, nullptr, true));
+    }
+}
+
+static bool isExpression(const Token* tok)
+{
+    if (!tok)
+        return false;
+    if (Token::simpleMatch(tok, "{") && tok->scope() && tok->scope()->bodyStart != tok &&
+        (tok->astOperand1() || tok->astOperand2()))
+        return true;
+    if (!Token::Match(tok, "(|.|[|::|?|:|++|--|%cop%|%assign%"))
+        return false;
+    if (Token::Match(tok, "*|&|&&")) {
+        const Token* vartok = findAstNode(tok, [&](const Token* tok2) {
+            const Variable* var = tok2->variable();
+            if (!var)
+                return false;
+            return var->nameToken() == tok2;
+        });
+        if (vartok)
+            return false;
+    }
+    return true;
+}
+
+static std::string getIncompleteNameID(const Token* tok)
+{
+    std::string result = tok->str() + "@";
+    while (Token::Match(tok->astParent(), ".|::"))
+        tok = tok->astParent();
+    return result + tok->expressionString();
+}
+
+namespace {
+    struct ExprIdKey {
+        std::string parentOp;
+        nonneg int operand1;
+        nonneg int operand2;
+        bool operator<(const ExprIdKey& k) const {
+            return std::tie(parentOp, operand1, operand2) < std::tie(k.parentOp, k.operand1, k.operand2);
+        }
+    };
+    using ExprIdMap = std::map<ExprIdKey, nonneg int>;
+    void setParentExprId(Token* tok, ExprIdMap& exprIdMap, nonneg int &id) {
+        for (;;) {
+            if (!tok->astParent() || tok->astParent()->isControlFlowKeyword())
+                break;
+            const Token* op1 = tok->astParent()->astOperand1();
+            if (op1 && op1->exprId() == 0 && !Token::Match(op1, "[{[]"))
+                break;
+            const Token* op2 = tok->astParent()->astOperand2();
+            if (op2 && op2->exprId() == 0 &&
+                !((tok->astParent()->astParent() && tok->astParent()->isAssignmentOp() && tok->astParent()->astParent()->isAssignmentOp()) ||
+                  isLambdaCaptureList(op2) ||
+                  (op2->str() == "(" && isLambdaCaptureList(op2->astOperand1())) ||
+                  Token::simpleMatch(op2, "{ }") ||
+                  (Token::simpleMatch(tok->astParent(), "[") && op2->str() == "{")))
+                break;
+
+            if (tok->astParent()->isExpandedMacro() || Token::Match(tok->astParent(), "++|--")) {
+                tok->astParent()->exprId(id);
+                ++id;
+                tok = tok->astParent();
+                continue;
+            }
+
+            ExprIdKey key;
+            key.parentOp = tok->astParent()->str();
+            key.operand1 = op1 ? op1->exprId() : 0;
+            key.operand2 = op2 ? op2->exprId() : 0;
+
+            if (tok->astParent()->isCast() && tok->astParent()->str() == "(") {
+                const Token* typeStartToken;
+                const Token* typeEndToken;
+                if (tok->astParent()->astOperand2()) {
+                    typeStartToken = tok->astParent()->astOperand1();
+                    typeEndToken = tok;
+                } else {
+                    typeStartToken = tok->astParent()->next();
+                    typeEndToken = tok->astParent()->link();
+                }
+                std::string type;
+                for (const Token* t = typeStartToken; precedes(t, typeEndToken); t = t->next()) {
+                    type += " " + t->str();
+                }
+                key.parentOp += type;
+            }
+
+            for (const auto& ref: followAllReferences(op1)) {
+                if (ref.token->exprId() != 0) { // cppcheck-suppress useStlAlgorithm
+                    key.operand1 = ref.token->exprId();
+                    break;
+                }
+            }
+            for (const auto& ref: followAllReferences(op2)) {
+                if (ref.token->exprId() != 0) { // cppcheck-suppress useStlAlgorithm
+                    key.operand2 = ref.token->exprId();
+                    break;
+                }
+            }
+
+            if (key.operand1 > key.operand2 && key.operand2 &&
+                Token::Match(tok->astParent(), "%or%|%oror%|+|*|&|&&|^|==|!=")) {
+                // In C++ the order of operands of + might matter
+                if (!tok->isCpp() ||
+                    key.parentOp != "+" ||
+                    !tok->astParent()->valueType() ||
+                    tok->astParent()->valueType()->isIntegral() ||
+                    tok->astParent()->valueType()->isFloat() ||
+                    tok->astParent()->valueType()->pointer > 0)
+                    std::swap(key.operand1, key.operand2);
+            }
+
+            const auto it = exprIdMap.find(key);
+            if (it == exprIdMap.end()) {
+                exprIdMap[key] = id;
+                tok->astParent()->exprId(id);
+                ++id;
+            } else {
+                tok->astParent()->exprId(it->second);
+            }
+            tok = tok->astParent();
+        }
+    }
+}
+
+void SymbolDatabase::createSymbolDatabaseExprIds()
+{
+    // Find highest varId
+    nonneg int maximumVarId = 0;
+    for (const Token* tok = mTokenizer.list.front(); tok; tok = tok->next()) {
+        maximumVarId = std::max(tok->varId(), maximumVarId);
+    }
+    nonneg int id = maximumVarId + 1;
+    // Find incomplete vars that are used in constant context
+    std::unordered_map<std::string, nonneg int> unknownConstantIds;
+    const Token* inConstExpr = nullptr;
+    for (const Token* tok = mTokenizer.list.front(); tok != mTokenizer.list.back(); tok = tok->next()) {
+        if (Token::Match(tok, "decltype|sizeof|typeof (") && tok->linkAt(1)) {
+            tok = tok->linkAt(1)->previous();
+        } else if (tok == inConstExpr) {
+            inConstExpr = nullptr;
+        } else if (inConstExpr) {
+            if (!tok->isIncompleteVar())
+                continue;
+            if (!isExpression(tok->astParent()))
+                continue;
+            const std::string& name = getIncompleteNameID(tok);
+            if (unknownConstantIds.count(name) > 0)
+                continue;
+            unknownConstantIds[name] = id++;
+        } else if (tok->link() && tok->str() == "<") {
+            inConstExpr = tok->link();
+        } else if (Token::Match(tok, "%var% [") && tok->variable() && tok->variable()->nameToken() == tok) {
+            inConstExpr = tok->linkAt(1);
+        }
+    }
+
+    auto exprScopes = functionScopes; // functions + global lambdas + namespaces
+    std::copy_if(scopeList.front().nestedList.begin(), scopeList.front().nestedList.end(), std::back_inserter(exprScopes), [](const Scope* scope) {
+        return scope && (scope->type == ScopeType::eLambda || scope->type == ScopeType::eNamespace);
+    });
+
+    for (const Scope * scope : exprScopes) {
+        std::unordered_map<std::string, nonneg int> unknownIds;
+        // Assign IDs to incomplete vars which are part of an expression
+        // Such variables should be assumed global
+        for (auto* tok = const_cast<Token*>(scope->bodyStart); tok != scope->bodyEnd; tok = tok->next()) {
+            if (!tok->isIncompleteVar())
+                continue;
+            if (!isExpression(tok->astParent()))
+                continue;
+            const std::string& name = getIncompleteNameID(tok);
+            nonneg int sid = 0;
+            if (unknownConstantIds.count(name) > 0) {
+                sid = unknownConstantIds.at(name);
+                tok->isIncompleteConstant(true);
+            } else if (unknownIds.count(name) == 0) {
+                sid = id++;
+                unknownIds[name] = sid;
+            } else {
+                sid = unknownIds.at(name);
+            }
+            assert(sid > 0);
+            tok->exprId(sid);
+        }
+
+        // Assign IDs
+        ExprIdMap exprIdMap;
+        std::map<std::string, std::pair<nonneg int, const Token*>> baseIds;
+        for (auto* tok = const_cast<Token*>(scope->bodyStart); tok != scope->bodyEnd; tok = tok->next()) {
+            if (tok->varId() > 0) {
+                tok->exprId(tok->varId());
+                if (tok->astParent() && tok->astParent()->exprId() == 0)
+                    setParentExprId(tok, exprIdMap, id);
+            } else if (tok->astParent() && !tok->astOperand1() && !tok->astOperand2()) {
+                if (tok->tokType() == Token::Type::eBracket)
+                    continue;
+                if (tok->astParent()->str() == "=")
+                    continue;
+                if (tok->isControlFlowKeyword())
+                    continue;
+                if (Token::Match(tok->tokAt(-1), ". %name%") && Token::Match(tok->tokAt(-2), "[{,]")) // designated initializers
+                    continue;
+
+                if (Token::Match(tok, "%name% <") && tok->linkAt(1)) {
+                    tok->exprId(id);
+                    ++id;
+                } else {
+                    const auto it = baseIds.find(tok->str());
+                    if (it != baseIds.end() && compareTokenFlags(tok, it->second.second, /*macro*/ true)) {
+                        tok->exprId(it->second.first);
+                    } else {
+                        baseIds[tok->str()] = { id, tok };
+                        tok->exprId(id);
+                        ++id;
+                    }
+                }
+
+                setParentExprId(tok, exprIdMap, id);
+            }
+        }
+        for (auto* tok = const_cast<Token*>(scope->bodyStart); tok != scope->bodyEnd; tok = tok->next()) {
+            if (tok->varId() == 0 && tok->exprId() > 0 && tok->astParent() && !tok->astOperand1() && !tok->astOperand2()) {
+                if (tok->isNumber() || tok->isKeyword() || Token::Match(tok->astParent(), ".|::") ||
+                    (Token::simpleMatch(tok->astParent(), "(") && precedes(tok, tok->astParent())))
+                    tok->exprId(0);
+            }
+        }
+    }
+
+    // Mark expressions that are unique
+    std::vector<std::pair<Token*, int>> uniqueExprId(id);
+    for (Token* tok = mTokenizer.list.front(); tok; tok = tok->next()) {
+        const auto id2 = tok->exprId();
+        if (id2 == 0 || id2 <= maximumVarId)
+            continue;
+        uniqueExprId[id2].first = tok;
+        uniqueExprId[id2].second++;
+    }
+    for (const auto& p : uniqueExprId) {
+        if (!p.first || p.second != 1)
+            continue;
+        if (p.first->variable()) {
+            const Variable* var = p.first->variable();
+            if (var->nameToken() != p.first)
+                continue;
+        }
+        p.first->setUniqueExprId();
     }
 }
 
+// cppcheck-suppress functionConst - has side effects
 void SymbolDatabase::setArrayDimensionsUsingValueFlow()
 {
     // set all unknown array dimensions
@@ -1400,42 +1839,89 @@ void SymbolDatabase::setArrayDimensionsUsingValueFlow()
             continue;
         // check each array dimension
         for (const Dimension &const_dimension : var->dimensions()) {
-            Dimension &dimension = const_cast<Dimension &>(const_dimension);
+            auto &dimension = const_cast<Dimension &>(const_dimension);
             if (dimension.num != 0 || !dimension.tok)
                 continue;
+
+            if (Token::Match(dimension.tok->previous(), "[<,]")) {
+                if (dimension.known)
+                    continue;
+
+                // In template arguments, there might not be AST
+                // Determine size by using the "raw tokens"
+                TokenList tokenList(mSettings, dimension.tok->isCpp() ? Standards::Language::CPP : Standards::Language::C);
+                tokenList.addtoken(";", 0, 0, 0, false);
+                bool fail = false;
+                for (const Token *tok = dimension.tok; tok && !Token::Match(tok, "[,>]"); tok = tok->next()) {
+                    if (!tok->isName())
+                        tokenList.addtoken(tok->str(), 0, 0, 0, false);
+
+                    else if (const ValueFlow::Value* v = tok->getKnownValue(ValueFlow::Value::ValueType::INT))
+                        tokenList.addtoken(MathLib::toString(v->intvalue), 0, 0, 0, false);
+
+                    else {
+                        fail = true;
+                        break;
+                    }
+                }
+
+                if (fail)
+                    continue;
+
+                tokenList.addtoken(";", 0, 0, 0, false);
+
+                for (Token *tok = tokenList.front(); tok;) {
+                    if (TemplateSimplifier::simplifyNumericCalculations(tok, false))
+                        tok = tokenList.front();
+                    else
+                        tok = tok->next();
+                }
+
+                if (Token::Match(tokenList.front(), "; %num% ;")) {
+                    dimension.known = true;
+                    dimension.num = MathLib::toBigNumber(tokenList.front()->tokAt(1));
+                }
+
+                continue;
+            }
+
+            // Normal array [..dimension..]
             dimension.known = false;
 
             // check for a single token dimension
-            if (dimension.tok->hasKnownIntValue()) {
+            if (const ValueFlow::Value* v = dimension.tok->getKnownValue(ValueFlow::Value::ValueType::INT)) {
                 dimension.known = true;
-                dimension.num = dimension.tok->getKnownIntValue();
+                dimension.num = v->intvalue;
                 continue;
             }
 
-            else if (dimension.tok->valueType() && dimension.tok->valueType()->pointer == 0) {
-                int bits = 0;
+            if (dimension.tok->valueType() && dimension.tok->valueType()->pointer == 0) {
+                std::uint8_t bits = 0;
                 switch (dimension.tok->valueType()->type) {
                 case ValueType::Type::CHAR:
-                    bits = mSettings->char_bit;
+                    bits = mSettings.platform.char_bit;
                     break;
                 case ValueType::Type::SHORT:
-                    bits = mSettings->short_bit;
+                    bits = mSettings.platform.short_bit;
                     break;
                 case ValueType::Type::INT:
-                    bits = mSettings->int_bit;
+                    bits = mSettings.platform.int_bit;
                     break;
                 case ValueType::Type::LONG:
-                    bits = mSettings->long_bit;
+                    bits = mSettings.platform.long_bit;
                     break;
                 case ValueType::Type::LONGLONG:
-                    bits = mSettings->long_long_bit;
+                    bits = mSettings.platform.long_long_bit;
                     break;
                 default:
                     break;
-                };
+                }
 
                 if (bits > 0 && bits <= 62) {
-                    if (dimension.tok->valueType()->sign == ValueType::Sign::UNSIGNED)
+                    auto sign = dimension.tok->valueType()->sign;
+                    if (sign == ValueType::Sign::UNKNOWN_SIGN && dimension.tok->valueType()->type == ValueType::Type::CHAR)
+                        sign = mDefaultSignedness;
+                    if (sign == ValueType::Sign::UNSIGNED)
                         dimension.num = 1LL << bits;
                     else
                         dimension.num = 1LL << (bits - 1);
@@ -1448,17 +1934,17 @@ void SymbolDatabase::setArrayDimensionsUsingValueFlow()
 SymbolDatabase::~SymbolDatabase()
 {
     // Clear scope, type, function and variable pointers
-    for (const Token* tok = mTokenizer->list.front(); tok; tok = tok->next()) {
-        const_cast<Token *>(tok)->scope(nullptr);
-        const_cast<Token *>(tok)->type(nullptr);
-        const_cast<Token *>(tok)->function(nullptr);
-        const_cast<Token *>(tok)->variable(nullptr);
-        const_cast<Token *>(tok)->enumerator(nullptr);
-        const_cast<Token *>(tok)->setValueType(nullptr);
+    for (Token* tok = mTokenizer.list.front(); tok; tok = tok->next()) {
+        tok->scope(nullptr);
+        tok->type(nullptr);
+        tok->function(nullptr);
+        tok->variable(nullptr);
+        tok->enumerator(nullptr);
+        tok->setValueType(nullptr);
     }
 }
 
-bool SymbolDatabase::isFunction(const Token *tok, const Scope* outerScope, const Token **funcStart, const Token **argStart, const Token** declEnd) const
+bool SymbolDatabase::isFunction(const Token *tok, const Scope* outerScope, const Token *&funcStart, const Token *&argStart, const Token*& declEnd) const
 {
     if (tok->varId())
         return false;
@@ -1466,44 +1952,48 @@ bool SymbolDatabase::isFunction(const Token *tok, const Scope* outerScope, const
     // function returning function pointer? '... ( ... %name% ( ... ))( ... ) {'
     // function returning reference to array '... ( & %name% ( ... ))[ ... ] {'
     // TODO: Activate this again
-    if (false && tok->str() == "(" && tok->strAt(1) != "*" &&
-        (tok->link()->previous()->str() == ")" || Token::simpleMatch(tok->link()->tokAt(-2), ") const"))) {
+    if ((false) && tok->str() == "(" && tok->strAt(1) != "*" && // NOLINT(readability-simplify-boolean-expr,readability-redundant-parentheses)
+        (tok->link()->strAt(-1) == ")" || Token::simpleMatch(tok->link()->tokAt(-2), ") const"))) {
         const Token* tok2 = tok->link()->next();
         if (tok2 && tok2->str() == "(" && Token::Match(tok2->link()->next(), "{|;|const|=")) {
             const Token* argStartTok;
-            if (tok->link()->previous()->str() == "const")
+            if (tok->link()->strAt(-1) == "const")
                 argStartTok = tok->link()->linkAt(-2);
             else
                 argStartTok = tok->link()->linkAt(-1);
-            *funcStart = argStartTok->previous();
-            *argStart = argStartTok;
-            *declEnd = Token::findmatch(tok2->link()->next(), "{|;");
+            funcStart = argStartTok->previous();
+            argStart = argStartTok;
+            declEnd = Token::findmatch(tok2->link()->next(), "{|;");
             return true;
-        } else if (tok2 && tok2->str() == "[") {
+        }
+        if (tok2 && tok2->str() == "[") {
             while (tok2 && tok2->str() == "[")
                 tok2 = tok2->link()->next();
             if (Token::Match(tok2, "{|;|const|=")) {
                 const Token* argStartTok;
-                if (tok->link()->previous()->str() == "const")
+                if (tok->link()->strAt(-1) == "const")
                     argStartTok = tok->link()->linkAt(-2);
                 else
                     argStartTok = tok->link()->linkAt(-1);
-                *funcStart = argStartTok->previous();
-                *argStart = argStartTok;
-                *declEnd = Token::findmatch(tok2, "{|;");
+                funcStart = argStartTok->previous();
+                argStart = argStartTok;
+                declEnd = Token::findmatch(tok2, "{|;");
                 return true;
             }
         }
     }
 
-    // regular function?
-    else if (Token::Match(tok, "%name% (") && !isReservedName(tok->str()) && tok->previous() &&
-             (Token::Match(tok->previous(), "%name%|>|&|*|::|~") || // Either a return type or scope qualifier in front of tok
+    else if (!tok->isName() || !tok->next() || !tok->linkAt(1))
+        return false;
+
+    // regular function?
+    else if (Token::Match(tok, "%name% ( !!*") && !isReservedName(tok) && tok->previous() &&
+             (Token::Match(tok->previous(), "%name%|>|&|&&|*|::|~") || // Either a return type or scope qualifier in front of tok
               outerScope->isClassOrStructOrUnion())) { // or a ctor/dtor
         const Token* tok1 = tok->previous();
-        const Token* tok2 = tok->next()->link()->next();
+        const Token* tok2 = tok->linkAt(1)->next();
 
-        if (!mTokenizer->isFunctionHead(tok->next(), ";:{"))
+        if (!TokenList::isFunctionHead(tok->next(), ";:{"))
             return false;
 
         // skip over destructor "~"
@@ -1513,7 +2003,7 @@ bool SymbolDatabase::isFunction(const Token *tok, const Scope* outerScope, const
         // skip over qualification
         while (Token::simpleMatch(tok1, "::")) {
             tok1 = tok1->previous();
-            if (Token::Match(tok1, "%name%"))
+            if (tok1 && tok1->isName())
                 tok1 = tok1->previous();
             else if (tok1 && tok1->str() == ">" && tok1->link() && Token::Match(tok1->link()->previous(), "%name%"))
                 tok1 = tok1->link()->tokAt(-2);
@@ -1527,7 +2017,9 @@ bool SymbolDatabase::isFunction(const Token *tok, const Scope* outerScope, const
         }
 
         // skip over trailing return type
+        bool hasTrailingRet = false;
         if (tok2 && tok2->str() == ".") {
+            hasTrailingRet = true;
             for (tok2 = tok2->next(); tok2; tok2 = tok2->next()) {
                 if (Token::Match(tok2, ";|{|=|override|final"))
                     break;
@@ -1539,9 +2031,14 @@ bool SymbolDatabase::isFunction(const Token *tok, const Scope* outerScope, const
         // done if constructor or destructor
         if (!Token::Match(tok1, "{|}|;|public:|protected:|private:") && tok1) {
             // skip over pointers and references
-            while (Token::Match(tok1, "%type%|*|&") && !endsWith(tok1->str(), ':') && (!isReservedName(tok1->str()) || tok1->str() == "const"))
+            while (Token::Match(tok1, "%type%|*|&|&&") && !endsWith(tok1->str(), ':') && (!isReservedName(tok1) || tok1->str() == "const"))
                 tok1 = tok1->previous();
 
+            // skip over decltype
+            if (Token::simpleMatch(tok1, ")") && tok1->link() &&
+                Token::simpleMatch(tok1->link()->previous(), "decltype ("))
+                tok1 = tok1->link()->tokAt(-2);
+
             // skip over template
             if (tok1 && tok1->str() == ">") {
                 if (tok1->link())
@@ -1555,25 +2052,29 @@ bool SymbolDatabase::isFunction(const Token *tok, const Scope* outerScope, const
                 return false;
 
             // skip over return type
-            if (Token::Match(tok1, "%name%")) {
+            if (tok1 && tok1->isName()) {
                 if (tok1->str() == "return")
                     return false;
-                tok1 = tok1->previous();
+                if (tok1->str() != "friend")
+                    tok1 = tok1->previous();
             }
 
             // skip over qualification
             while (Token::simpleMatch(tok1, "::")) {
                 tok1 = tok1->previous();
-                if (Token::Match(tok1, "%name%"))
+                if (tok1 && tok1->isName())
                     tok1 = tok1->previous();
                 else if (tok1 && tok1->str() == ">" && tok1->link() && Token::Match(tok1->link()->previous(), "%name%"))
                     tok1 = tok1->link()->tokAt(-2);
+                else if (Token::simpleMatch(tok1, ")") && tok1->link() &&
+                         Token::simpleMatch(tok1->link()->previous(), "decltype ("))
+                    tok1 = tok1->link()->tokAt(-2);
             }
 
             // skip over modifiers and other stuff
             while (Token::Match(tok1, "const|static|extern|template|virtual|struct|class|enum|%name%")) {
                 // friend type func(); is not a function
-                if (isCPP() && tok1->str() == "friend" && tok2->str() == ";")
+                if (tok1->isCpp() && tok1->str() == "friend" && tok2->str() == ";")
                     return false;
                 tok1 = tok1->previous();
             }
@@ -1586,54 +2087,57 @@ bool SymbolDatabase::isFunction(const Token *tok, const Scope* outerScope, const
         if (tok2 &&
             (Token::Match(tok2, ";|{|=") ||
              (tok2->isUpperCaseName() && Token::Match(tok2, "%name% ;|{")) ||
-             (tok2->isUpperCaseName() && Token::Match(tok2, "%name% (") && tok2->next()->link()->strAt(1) == "{") ||
+             (tok2->isUpperCaseName() && Token::Match(tok2, "%name% (") && tok2->linkAt(1)->strAt(1) == "{") ||
              Token::Match(tok2, ": ::| %name% (|::|<|{") ||
              Token::Match(tok2, "&|&&| ;|{") ||
-             Token::Match(tok2, "= delete|default ;"))) {
-            *funcStart = tok;
-            *argStart = tok->next();
-            *declEnd = Token::findmatch(tok2, "{|;");
+             Token::Match(tok2, "= delete|default ;") ||
+             (hasTrailingRet && Token::Match(tok2, "final|override")))) {
+            funcStart = tok;
+            argStart = tok->next();
+            declEnd = Token::findmatch(tok2, "{|;");
             return true;
         }
     }
 
     // UNKNOWN_MACRO(a,b) { ... }
-    else if (outerScope->type == Scope::eGlobal &&
+    else if (outerScope->type == ScopeType::eGlobal &&
              Token::Match(tok, "%name% (") &&
              tok->isUpperCaseName() &&
              Token::simpleMatch(tok->linkAt(1), ") {") &&
              (!tok->previous() || Token::Match(tok->previous(), "[;{}]"))) {
-        *funcStart = tok;
-        *argStart = tok->next();
-        *declEnd = tok->linkAt(1)->next();
+        funcStart = tok;
+        argStart = tok->next();
+        declEnd = tok->linkAt(1)->next();
         return true;
     }
 
     // template constructor?
-    else if (Token::Match(tok, "%name% <") && Token::simpleMatch(tok->next()->link(), "> (")) {
-        const Token* tok2 = tok->next()->link()->next()->link();
+    else if (Token::Match(tok, "%name% <") && Token::simpleMatch(tok->linkAt(1), "> (")) {
+        if (tok->isKeyword() || tok->isStandardType() || !outerScope->isClassOrStructOrUnion())
+            return false;
+        const Token* tok2 = tok->linkAt(1)->linkAt(1);
         if (Token::Match(tok2, ") const| ;|{|=") ||
             Token::Match(tok2, ") : ::| %name% (|::|<|{") ||
             Token::Match(tok2, ") const| noexcept {|;|(")) {
-            *funcStart = tok;
-            *argStart = tok2->link();
-            *declEnd = Token::findmatch(tok2->next(), "{|;");
+            funcStart = tok;
+            argStart = tok2->link();
+            declEnd = Token::findmatch(tok2->next(), "{|;");
             return true;
         }
     }
 
     // regular C function with missing return or invalid C++ ?
-    else if (Token::Match(tok, "%name% (") && !isReservedName(tok->str()) &&
+    else if (Token::Match(tok, "%name% (") && !isReservedName(tok) &&
              Token::simpleMatch(tok->linkAt(1), ") {") &&
              (!tok->previous() || Token::Match(tok->previous(), ";|}"))) {
-        if (mTokenizer->isC()) {
-            debugMessage(tok, "SymbolDatabase::isFunction found C function '" + tok->str() + "' without a return type.");
-            *funcStart = tok;
-            *argStart = tok->next();
-            *declEnd = tok->linkAt(1)->next();
+        if (tok->isC()) {
+            returnImplicitIntError(tok);
+            funcStart = tok;
+            argStart = tok->next();
+            declEnd = tok->linkAt(1)->next();
             return true;
         }
-        mTokenizer->syntaxError(tok);
+        mTokenizer.syntaxError(tok);
     }
 
     return false;
@@ -1648,28 +2152,28 @@ void SymbolDatabase::validateExecutableScopes() const
         if (scope->isExecutable() && !function) {
             const std::list<const Token*> callstack(1, scope->classDef);
             const std::string msg = std::string("Executable scope '") + scope->classDef->str() + "' with unknown function.";
-            const ErrorLogger::ErrorMessage errmsg(callstack, &mTokenizer->list, Severity::debug,
-                                                   "symbolDatabaseWarning",
-                                                   msg,
-                                                   false);
-            mErrorLogger->reportErr(errmsg);
+            const ErrorMessage errmsg(callstack, &mTokenizer.list, Severity::debug,
+                                      "symbolDatabaseWarning",
+                                      msg,
+                                      Certainty::normal);
+            mErrorLogger.reportErr(errmsg);
         }
     }
 }
 
 namespace {
-    const Function* getFunctionForArgumentvariable(const Variable * const var, const std::vector<const Scope *>& functionScopes)
+    const Function* getFunctionForArgumentvariable(const Variable * const var)
     {
-        const std::size_t functions = functionScopes.size();
-        for (std::size_t i = 0; i < functions; ++i) {
-            const Scope* const scope = functionScopes[i];
-            const Function* const function = scope->function;
-            if (function) {
-                for (std::size_t arg=0; arg < function->argCount(); ++arg) {
-                    if (var==function->getArgumentVar(arg))
-                        return function;
+        if (const Scope* scope = var->nameToken()->scope()) {
+            auto it = std::find_if(scope->functionList.begin(), scope->functionList.end(), [&](const Function& function) {
+                for (nonneg int arg = 0; arg < function.argCount(); ++arg) {
+                    if (var == function.getArgumentVar(arg))
+                        return true;
                 }
-            }
+                return false;
+            });
+            if (it != scope->functionList.end())
+                return &*it;
         }
         return nullptr;
     }
@@ -1677,26 +2181,291 @@ namespace {
 
 void SymbolDatabase::validateVariables() const
 {
-    for (std::vector<const Variable *>::const_iterator iter = mVariableList.begin(); iter!=mVariableList.end(); ++iter) {
+    for (auto iter = mVariableList.cbegin(); iter!=mVariableList.cend(); ++iter) {
         const Variable * const var = *iter;
         if (var) {
             if (!var->scope()) {
-                const Function* function = getFunctionForArgumentvariable(var, functionScopes);
-                if (!var->isArgument() || (function && function->hasBody())) {
+                const Function* function = getFunctionForArgumentvariable(var);
+                if (!var->isArgument() || (!function || function->hasBody())) { // variables which only appear in a function declaration do not have a scope
                     throw InternalError(var->nameToken(), "Analysis failed (variable without scope). If the code is valid then please report this failure.", InternalError::INTERNAL);
-                    //std::cout << "!!!Variable found without scope: " << var->nameToken()->str() << std::endl;
                 }
             }
         }
     }
 }
 
+bool SymbolDatabase::isVariableWithoutSideEffects(const Variable& var, const Type* type) const
+{
+    const Type* variableType = var.type();
+    if (variableType && variableType != type) {
+        if (!isRecordTypeWithoutSideEffects(variableType))
+            return false;
+    }
+    else {
+        if (!var.valueType())
+            return false;
+        const ValueType::Type valueType = var.valueType()->type;
+        if ((valueType == ValueType::Type::UNKNOWN_TYPE) || (valueType == ValueType::Type::NONSTD))
+            return false;
+    }
+
+    return true;
+}
+
+bool SymbolDatabase::isFunctionWithoutSideEffects(const Function& func, const Token* functionUsageToken, std::list<const Function*> checkedFuncs) const
+{
+    // no body to analyze
+    if (!func.hasBody()) {
+        return false;
+    }
+
+    for (const Token* argsToken = functionUsageToken->next(); !Token::simpleMatch(argsToken, ")"); argsToken = argsToken->next()) {
+        const Variable* argVar = argsToken->variable();
+        if (argVar && argVar->isGlobal()) {
+            return false; // TODO: analyze global variable usage
+        }
+    }
+
+    bool sideEffectReturnFound = false;
+    std::set<const Variable*> pointersToGlobals;
+    for (const Token* bodyToken = func.functionScope->bodyStart->next(); bodyToken != func.functionScope->bodyEnd;
+         bodyToken = bodyToken->next()) {
+        // check variable inside function body
+        const Variable* bodyVariable = bodyToken->variable();
+        if (bodyVariable) {
+            if (!isVariableWithoutSideEffects(*bodyVariable)) {
+                return false;
+            }
+            // check if global variable is changed
+            if (bodyVariable->isGlobal() || (pointersToGlobals.find(bodyVariable) != pointersToGlobals.end())) {
+                const int indirect = bodyVariable->isArray() ? bodyVariable->dimensions().size() : bodyVariable->isPointer();
+                if (isVariableChanged(bodyToken, indirect, mSettings)) {
+                    return false;
+                }
+                // check if pointer to global variable assigned to another variable (another_var = &global_var)
+                if (Token::simpleMatch(bodyToken->tokAt(-1), "&") && Token::simpleMatch(bodyToken->tokAt(-2), "=")) {
+                    const Token* assigned_var_token = bodyToken->tokAt(-3);
+                    if (assigned_var_token && assigned_var_token->variable()) {
+                        pointersToGlobals.insert(assigned_var_token->variable());
+                    }
+                }
+            }
+        }
+
+        // check nested function
+        const Function* bodyFunction = bodyToken->function();
+        if (bodyFunction) {
+            if (std::find(checkedFuncs.cbegin(), checkedFuncs.cend(), bodyFunction) != checkedFuncs.cend()) { // recursion found
+                continue;
+            }
+            checkedFuncs.push_back(bodyFunction);
+            if (!isFunctionWithoutSideEffects(*bodyFunction, bodyToken, checkedFuncs)) {
+                return false;
+            }
+        }
+
+        // check returned value
+        if (Token::simpleMatch(bodyToken, "return")) {
+            const Token* returnValueToken = bodyToken->next();
+            // TODO: handle complex return expressions
+            if (!Token::simpleMatch(returnValueToken->next(), ";")) {
+                sideEffectReturnFound = true;
+                continue;
+            }
+            // simple one-token return
+            const Variable* returnVariable = returnValueToken->variable();
+            if (returnValueToken->isLiteral() ||
+                (returnVariable && isVariableWithoutSideEffects(*returnVariable))) {
+                continue;
+            }
+            sideEffectReturnFound = true;
+        }
+
+        // unknown name
+        if (bodyToken->isNameOnly()) {
+            return false;
+        }
+    }
+
+    return !sideEffectReturnFound;
+}
+
+bool SymbolDatabase::isRecordTypeWithoutSideEffects(const Type* type) const
+{
+    const std::pair<std::map<const Type*, bool>::iterator, bool> found = mIsRecordTypeWithoutSideEffectsMap.insert(
+        std::pair<const Type*, bool>(type, false));         //Initialize with side effects for possible recursions
+    bool& withoutSideEffects = found.first->second;
+    if (!found.second)
+        return withoutSideEffects;
+
+    // unknown types are assumed to have side effects
+    if (!type || !type->classScope)
+        return (withoutSideEffects = false);
+
+    // Non-empty constructors => possible side effects
+    for (const Function& f : type->classScope->functionList) {
+        if (!f.isConstructor() && !f.isDestructor())
+            continue;
+        if (f.argDef && Token::simpleMatch(f.argDef->link(), ") ="))
+            continue; // ignore default/deleted constructors
+        const bool emptyBody = (f.functionScope && Token::simpleMatch(f.functionScope->bodyStart, "{ }"));
+
+        const Token* nextToken = f.argDef ? f.argDef->link() : nullptr;
+        if (Token::simpleMatch(nextToken, ") :")) {
+            // validating initialization list
+            nextToken = nextToken->next(); // goto ":"
+
+            for (const Token* initListToken = nextToken; Token::Match(initListToken, "[:,] %var% [({]"); initListToken = initListToken->linkAt(2)->next()) {
+                const Token* varToken = initListToken->next();
+                const Variable* variable = varToken->variable();
+                if (variable && !isVariableWithoutSideEffects(*variable)) {
+                    return withoutSideEffects = false;
+                }
+
+                const Token* valueEnd = initListToken->linkAt(2);
+                for (const Token* valueToken = initListToken->tokAt(3); valueToken != valueEnd; valueToken = valueToken->next()) {
+                    const Variable* initValueVar = valueToken->variable();
+                    if (initValueVar && !isVariableWithoutSideEffects(*initValueVar)) {
+                        return withoutSideEffects = false;
+                    }
+                    if ((valueToken->tokType() == Token::Type::eName) ||
+                        (valueToken->tokType() == Token::Type::eLambda) ||
+                        (valueToken->tokType() == Token::Type::eOther)) {
+                        return withoutSideEffects = false;
+                    }
+                    const Function* initValueFunc = valueToken->function();
+                    if (initValueFunc && !isFunctionWithoutSideEffects(*initValueFunc, valueToken,
+                                                                       std::list<const Function*> {})) {
+                        return withoutSideEffects = false;
+                    }
+                }
+            }
+        }
+
+        if (!emptyBody)
+            return (withoutSideEffects = false);
+    }
+
+    // Derived from type that has side effects?
+    if (std::any_of(type->derivedFrom.cbegin(), type->derivedFrom.cend(), [this](const Type::BaseInfo& derivedFrom) {
+        return !isRecordTypeWithoutSideEffects(derivedFrom.type);
+    }))
+        return (withoutSideEffects = false);
+
+    // Is there a member variable with possible side effects
+    for (const Variable& var : type->classScope->varlist) {
+        withoutSideEffects = isVariableWithoutSideEffects(var, type);
+        if (!withoutSideEffects) {
+            return withoutSideEffects;
+        }
+    }
+    return (withoutSideEffects = true);
+}
+
 void SymbolDatabase::validate() const
 {
-    if (mSettings->debugwarnings) {
+    if (mSettings.debugwarnings) {
         validateExecutableScopes();
     }
-    //validateVariables();
+    validateVariables();
+}
+
+void SymbolDatabase::clangSetVariables(const std::vector<const Variable *> &variableList)
+{
+    mVariableList = variableList;
+}
+
+void SymbolDatabase::debugSymbolDatabase() const
+{
+    if (!mSettings.debugnormal && !mSettings.debugwarnings)
+        return;
+    for (const Token* tok = mTokenizer.list.front(); tok != mTokenizer.list.back(); tok = tok->next()) {
+        if (tok->astParent() && tok->astParent()->getTokenDebug() == tok->getTokenDebug())
+            continue;
+        if (tok->getTokenDebug() == TokenDebug::ValueType) {
+
+            std::string msg = "Value type is ";
+            ErrorPath errorPath;
+            if (tok->valueType()) {
+                msg += tok->valueType()->str();
+                errorPath.insert(errorPath.end(), tok->valueType()->debugPath.cbegin(), tok->valueType()->debugPath.cend());
+
+            } else {
+                msg += "missing";
+            }
+            errorPath.emplace_back(tok, "");
+            mErrorLogger.reportErr(
+                {std::move(errorPath), &mTokenizer.list, Severity::debug, "valueType", msg, CWE{0}, Certainty::normal});
+        }
+    }
+}
+
+Variable::Variable(const Token *name_, const std::string &clangType, const Token *typeStart,
+                   const Token *typeEnd, nonneg int index_, AccessControl access_,
+                   const Type *type_, const Scope *scope_)
+    : mNameToken(name_),
+    mTypeStartToken(typeStart),
+    mTypeEndToken(typeEnd),
+    mIndex(index_),
+    mAccess(access_),
+    mFlags(0),
+    mType(type_),
+    mScope(scope_)
+{
+    if (!mTypeStartToken && mTypeEndToken) {
+        mTypeStartToken = mTypeEndToken;
+        while (Token::Match(mTypeStartToken->previous(), "%type%|*|&"))
+            mTypeStartToken = mTypeStartToken->previous();
+    }
+
+    while (Token::Match(mTypeStartToken, "const|struct|static")) {
+        if (mTypeStartToken->str() == "static")
+            setFlag(fIsStatic, true);
+        mTypeStartToken = mTypeStartToken->next();
+    }
+
+    if (Token::simpleMatch(mTypeEndToken, "&"))
+        setFlag(fIsReference, true);
+    else if (Token::simpleMatch(mTypeEndToken, "&&")) {
+        setFlag(fIsReference, true);
+        setFlag(fIsRValueRef, true);
+    }
+
+    std::string::size_type pos = clangType.find('[');
+    if (pos != std::string::npos) {
+        setFlag(fIsArray, true);
+        do {
+            const std::string::size_type pos1 = pos+1;
+            pos = clangType.find(']', pos1);
+            Dimension dim;
+            dim.tok = nullptr;
+            dim.known = pos > pos1;
+            if (pos > pos1)
+                dim.num = MathLib::toBigNumber(clangType.substr(pos1, pos - pos1));
+            else
+                dim.num = 0;
+            mDimensions.push_back(dim);
+            ++pos;
+        } while (pos < clangType.size() && clangType[pos] == '[');
+    }
+
+    // Is there initialization in variable declaration
+    const Token *initTok = mNameToken ? mNameToken->next() : nullptr;
+    while (initTok && initTok->str() == "[")
+        initTok = initTok->link()->next();
+    if (Token::Match(initTok, "=|{") || (initTok && initTok->isSplittedVarDeclEq()))
+        setFlag(fIsInit, true);
+}
+
+Variable::Variable(const Variable &var, const Scope *scope)
+{
+    *this = var;
+    mScope = scope;
+}
+
+Variable::Variable(const Variable &var)
+{
+    *this = var;
 }
 
 Variable::~Variable()
@@ -1704,28 +2473,77 @@ Variable::~Variable()
     delete mValueType;
 }
 
+Variable& Variable::operator=(const Variable &var) &
+{
+    if (this == &var)
+        return *this;
+
+    const ValueType* vt = nullptr;
+    if (var.mValueType)
+        vt = new ValueType(*var.mValueType);
+
+    mNameToken = var.mNameToken;
+    mTypeStartToken = var.mTypeStartToken;
+    mTypeEndToken = var.mTypeEndToken;
+    mIndex = var.mIndex;
+    mAccess = var.mAccess;
+    mFlags = var.mFlags;
+    mType = var.mType;
+    mScope = var.mScope;
+    mDimensions = var.mDimensions;
+    delete mValueType;
+    mValueType = vt;
+
+    return *this;
+}
+
+bool Variable::isMember() const {
+    return mScope && mScope->isClassOrStructOrUnion();
+}
+
 bool Variable::isPointerArray() const
 {
-    return isArray() && nameToken() && nameToken()->previous() && (nameToken()->previous()->str() == "*");
+    return isArray() && nameToken() && nameToken()->previous() && (nameToken()->strAt(-1) == "*");
+}
+
+bool Variable::isUnsigned() const
+{
+    return mValueType ? (mValueType->sign == ValueType::Sign::UNSIGNED) : mTypeStartToken->isUnsigned();
 }
 
 const Token * Variable::declEndToken() const
 {
     Token const * declEnd = typeStartToken();
-    while (declEnd && !Token::Match(declEnd, "[;,)={]")) {
-        if (declEnd->link() && Token::Match(declEnd,"(|["))
+    if (declEnd->tokAt(-1) && Token::simpleMatch(declEnd->tokAt(-2), "for ("))
+        declEnd = nameToken();
+    while (declEnd && !Token::Match(declEnd, "[;:,)={]")) {
+        if (declEnd->link() && Token::Match(declEnd,"(|[|<"))
             declEnd = declEnd->link();
         declEnd = declEnd->next();
     }
     return declEnd;
 }
 
-void Variable::evaluate(const Settings* settings)
+void Variable::evaluate(const Settings& settings)
 {
-    const Library * const lib = settings ? &settings->library : nullptr;
+    // Is there initialization in variable declaration
+    const Token *initTok = mNameToken ? mNameToken->next() : nullptr;
+    while (Token::Match(initTok, "[")) {
+        initTok = initTok->link()->next();
+        if (Token::simpleMatch(initTok, ")"))
+            initTok = initTok->next();
+    }
+    if (Token::Match(initTok, "[={(]") || (initTok && initTok->isSplittedVarDeclEq()))
+        setFlag(fIsInit, true);
+
+    const Library & lib = settings.library;
+
+    bool isContainer = false;
+    if (mNameToken) {
+        setFlag(fIsArray, arrayDimensions(settings, isContainer));
+        setFlag(fIsMaybeUnused, mNameToken->isAttributeMaybeUnused());
+    }
 
-    if (mNameToken)
-        setFlag(fIsArray, arrayDimensions(settings));
 
     if (mTypeStartToken)
         setValueType(ValueType::parseDecl(mTypeStartToken,settings));
@@ -1741,14 +2559,17 @@ void Variable::evaluate(const Settings* settings)
             setFlag(fIsStatic, true);
         else if (tok->str() == "extern")
             setFlag(fIsExtern, true);
-        else if (tok->str() == "volatile")
+        else if (tok->str() == "volatile" || Token::simpleMatch(tok, "std :: atomic <"))
             setFlag(fIsVolatile, true);
         else if (tok->str() == "mutable")
             setFlag(fIsMutable, true);
         else if (tok->str() == "const")
             setFlag(fIsConst, true);
-        else if (tok->str() == "*") {
-            setFlag(fIsPointer, !isArray() || Token::Match(tok->previous(), "( * %name% )"));
+        else if (tok->str() == "constexpr") {
+            setFlag(fIsConst, true);
+            setFlag(fIsStatic, true);
+        } else if (tok->str() == "*") {
+            setFlag(fIsPointer, !isArray() || (isContainer && !Token::Match(tok->next(), "%name% [")) || Token::Match(tok, "* const| %name% )"));
             setFlag(fIsConst, false); // Points to const, isn't necessarily const itself
         } else if (tok->str() == "&") {
             if (isReference())
@@ -1765,7 +2586,7 @@ void Variable::evaluate(const Settings* settings)
             tok = tok->next();
     }
 
-    while (Token::Match(mTypeStartToken, "static|const|volatile %any%"))
+    while (Token::Match(mTypeStartToken, "static|const|constexpr|volatile %any%"))
         mTypeStartToken = mTypeStartToken->next();
     while (mTypeEndToken && mTypeEndToken->previous() && Token::Match(mTypeEndToken, "const|volatile"))
         mTypeEndToken = mTypeEndToken->previous();
@@ -1774,10 +2595,10 @@ void Variable::evaluate(const Settings* settings)
         std::string strtype = mTypeStartToken->str();
         for (const Token *typeToken = mTypeStartToken; Token::Match(typeToken, "%type% :: %type%"); typeToken = typeToken->tokAt(2))
             strtype += "::" + typeToken->strAt(2);
-        setFlag(fIsClass, !lib->podtype(strtype) && !mTypeStartToken->isStandardType() && !isEnumType() && !isPointer() && !isReference() && strtype != "...");
+        setFlag(fIsClass, !lib.podtype(strtype) && !mTypeStartToken->isStandardType() && !isEnumType() && !isPointer() && !isReference() && strtype != "...");
         setFlag(fIsStlType, Token::simpleMatch(mTypeStartToken, "std ::"));
-        setFlag(fIsStlString, isStlType() && (Token::Match(mTypeStartToken->tokAt(2), "string|wstring|u16string|u32string !!::") || (Token::simpleMatch(mTypeStartToken->tokAt(2), "basic_string <") && !Token::simpleMatch(mTypeStartToken->linkAt(3), "> ::"))));
-        setFlag(fIsSmartPointer, lib->isSmartPointer(mTypeStartToken));
+        setFlag(fIsStlString, ::isStlStringType(mTypeStartToken));
+        setFlag(fIsSmartPointer, mTypeStartToken->isCpp() && lib.isSmartPointer(mTypeStartToken));
     }
     if (mAccess == AccessControl::Argument) {
         tok = mNameToken;
@@ -1788,8 +2609,8 @@ void Variable::evaluate(const Settings* settings)
             while (tok && tok->str() == "]")
                 tok = tok->link()->previous();
             // add array dimensions if present
-            if (tok && tok->next()->str() == "[")
-                setFlag(fIsArray, arrayDimensions(settings));
+            if (tok && tok->strAt(1) == "[")
+                setFlag(fIsArray, arrayDimensions(settings, isContainer));
         }
         if (!tok)
             return;
@@ -1817,16 +2638,23 @@ void Variable::evaluate(const Settings* settings)
 
 void Variable::setValueType(const ValueType &valueType)
 {
+    if (valueType.type == ValueType::Type::UNKNOWN_TYPE) {
+        const Token *declType = Token::findsimplematch(mTypeStartToken, "decltype (", mTypeEndToken);
+        if (declType && !declType->next()->valueType())
+            return;
+    }
+    const auto* vt = new ValueType(valueType);
     delete mValueType;
-    mValueType = new ValueType(valueType);
+    mValueType = vt;
     if ((mValueType->pointer > 0) && (!isArray() || Token::Match(mNameToken->previous(), "( * %name% )")))
         setFlag(fIsPointer, true);
     setFlag(fIsConst, mValueType->constness & (1U << mValueType->pointer));
+    setFlag(fIsVolatile, mValueType->volatileness & (1U << mValueType->pointer));
     if (mValueType->smartPointerType)
         setFlag(fIsSmartPointer, true);
 }
 
-const Type *Variable::smartPointerType() const
+const Type* Variable::smartPointerType() const
 {
     if (!isSmartPointer())
         return nullptr;
@@ -1834,101 +2662,112 @@ const Type *Variable::smartPointerType() const
     if (mValueType->smartPointerType)
         return mValueType->smartPointerType;
 
-    // TODO: Cache result
-    const Token *ptrType = typeStartToken();
-    while (Token::Match(ptrType, "%name%|::"))
-        ptrType = ptrType->next();
-    if (Token::Match(ptrType, "< %name% >"))
-        return ptrType->next()->type();
+    // TODO: Cache result, handle more complex type expression
+    const Token* typeTok = typeStartToken();
+    while (Token::Match(typeTok, "%name%|::"))
+        typeTok = typeTok->next();
+    if (Token::Match(typeTok, "< %name% >")) {
+        // cppcheck-suppress shadowFunction - TODO: fix this
+        const Scope* scope = typeTok->scope();
+        const Type* ptrType{};
+        while (scope && !ptrType) {
+            ptrType = scope->findType(typeTok->strAt(1));
+            scope = scope->nestedIn;
+        }
+        return ptrType;
+    }
     return nullptr;
 }
 
-Function::Function(const Tokenizer *mTokenizer,
-                   const Token *tok,
+const Type* Variable::iteratorType() const
+{
+    if (!mValueType || mValueType->type != ValueType::ITERATOR)
+        return nullptr;
+
+    if (mValueType->containerTypeToken)
+        return mValueType->containerTypeToken->type();
+
+    return nullptr;
+}
+
+bool Variable::isStlStringViewType() const
+{
+    return getFlag(fIsStlType) && valueType() && valueType()->container && valueType()->container->stdStringLike && valueType()->container->view;
+}
+
+std::string Variable::getTypeName() const
+{
+    std::string ret;
+    // TODO: For known types, generate the full type name
+    for (const Token *typeTok = mTypeStartToken; Token::Match(typeTok, "%name%|::") && typeTok->varId() == 0; typeTok = typeTok->next()) {
+        ret += typeTok->str();
+        if (Token::simpleMatch(typeTok->next(), "<") && typeTok->linkAt(1)) // skip template arguments
+            typeTok = typeTok->linkAt(1);
+    }
+    return ret;
+}
+
+static bool isOperator(const Token *tokenDef)
+{
+    if (!tokenDef)
+        return false;
+    if (tokenDef->isOperatorKeyword())
+        return true;
+    const std::string &name = tokenDef->str();
+    return name.size() > 8 && startsWith(name,"operator") && std::strchr("+-*/%&|~^<>!=[(", name[8]);
+}
+
+static bool isTrailingReturnType(const Token* tok)
+{
+    while (tok && tok->isKeyword())
+        tok = tok->next();
+    return Token::Match(tok, "&|&&| .");
+}
+
+Function::Function(const Token *tok,
                    const Scope *scope,
                    const Token *tokDef,
                    const Token *tokArgDef)
     : tokenDef(tokDef),
-      argDef(tokArgDef),
-      token(nullptr),
-      arg(nullptr),
-      retDef(nullptr),
-      retType(nullptr),
-      functionScope(nullptr),
-      nestedIn(scope),
-      initArgCount(0),
-      type(eFunction),
-      access(AccessControl::Public),
-      noexceptArg(nullptr),
-      throwArg(nullptr),
-      templateDef(nullptr),
-      mFlags(0)
+    argDef(tokArgDef),
+    nestedIn(scope)
 {
     // operator function
-    if (tokenDef->isOperatorKeyword()) {
+    if (::isOperator(tokenDef)) {
         isOperator(true);
 
         // 'operator =' is special
         if (tokenDef->str() == "operator=")
-            type = Function::eOperatorEqual;
+            type = FunctionType::eOperatorEqual;
     }
 
     else if (tokenDef->str() == "[") {
-        type = Function::eLambda;
+        type = FunctionType::eLambda;
     }
 
     // class constructor/destructor
-    else if (tokenDef->str() == scope->className) {
+    else if (scope->isClassOrStructOrUnion() &&
+             ((tokenDef->str() == scope->className) ||
+              (tokenDef->str().substr(0, scope->className.size()) == scope->className &&
+               tokenDef->str().size() > scope->className.size() + 1 &&
+               tokenDef->str()[scope->className.size() + 1] == '<'))) {
         // destructor
-        if (tokenDef->previous()->str() == "~")
-            type = Function::eDestructor;
+        if (tokenDef->strAt(-1) == "~") {
+            type = FunctionType::eDestructor;
+            isNoExcept(true);
+        }
         // constructor of any kind
         else
-            type = Function::eConstructor;
-
-        isExplicit(tokenDef->previous()->str() == "explicit");
+            type = FunctionType::eConstructor;
     }
 
-    const Token *tok1 = tok;
-
-    // look for end of previous statement
-    while (tok1->previous() && !Token::Match(tok1->previous(), ";|}|{|public:|protected:|private:")) {
-        tok1 = tok1->previous();
-
-        // extern function
-        if (tok1->str() == "extern") {
-            isExtern(true);
-        }
-
-        // virtual function
-        else if (tok1->str() == "virtual") {
-            hasVirtualSpecifier(true);
-        }
-
-        // static function
-        else if (tok1->str() == "static") {
-            isStatic(true);
-            if (scope->type == Scope::eNamespace || scope->type == Scope::eGlobal)
-                isStaticLocal(true);
-        }
-
-        // friend function
-        else if (tok1->str() == "friend") {
-            isFriend(true);
-        }
-
-        // Function template
-        else if (tok1->link() && tok1->str() == ">" && Token::simpleMatch(tok1->link()->previous(), "template <")) {
-            templateDef = tok1->link()->previous();
-            break;
-        }
-    }
+    const Token *tok1 = setFlags(tok, scope);
 
     // find the return type
-    if (!isConstructor() && !isDestructor() && !isLambda()) {
+    if (!isConstructor() && !isDestructor()) {
         // @todo auto type deduction should be checked
         // @todo attributes and exception specification can also precede trailing return type
-        if (Token::Match(argDef->link()->next(), "const|volatile| &|&&| .")) { // Trailing return type
+        if (isTrailingReturnType(argDef->link()->next())) { // Trailing return type
             hasTrailingReturnType(true);
             if (argDef->link()->strAt(1) == ".")
                 retDef = argDef->link()->tokAt(2);
@@ -1936,7 +2775,7 @@ Function::Function(const Tokenizer *mTokenizer,
                 retDef = argDef->link()->tokAt(3);
             else if (argDef->link()->strAt(3) == ".")
                 retDef = argDef->link()->tokAt(4);
-        } else {
+        } else if (!isLambda()) {
             if (tok1->str() == ">")
                 tok1 = tok1->next();
             while (Token::Match(tok1, "extern|virtual|static|friend|struct|union|enum"))
@@ -1964,7 +2803,7 @@ Function::Function(const Tokenizer *mTokenizer,
             isVolatile(true);
         else if (tok->str() == "noexcept") {
             isNoExcept(!Token::simpleMatch(tok->next(), "( false )"));
-            if (tok->next()->str() == "(")
+            if (tok->strAt(1) == "(")
                 tok = tok->linkAt(1);
         } else if (Token::simpleMatch(tok, "throw (")) {
             isThrow(true);
@@ -1986,26 +2825,255 @@ Function::Function(const Tokenizer *mTokenizer,
             tok = tok->next();
     }
 
-    if (mTokenizer->isFunctionHead(end, ":{")) {
+    if (TokenList::isFunctionHead(end, ":{")) {
         // assume implementation is inline (definition and implementation same)
         token = tokenDef;
         arg = argDef;
         isInline(true);
         hasBody(true);
     }
+
+    for (tok = tokenDef->previous(); Token::Match(tok, "&|&&|*|::|)|]|%name%"); tok = tok->previous()) {
+        // We should set other keywords here as well
+        if (tok->str() == "explicit")
+            isExplicit(true);
+        if (tok->str() == "]" || tok->str() == ")")
+            tok = tok->link();
+    }
+}
+
+Function::Function(const Token *tokenDef, const std::string &clangType)
+    : tokenDef(tokenDef)
+{
+    // operator function
+    if (::isOperator(tokenDef)) {
+        isOperator(true);
+
+        // 'operator =' is special
+        if (tokenDef->str() == "operator=")
+            type = FunctionType::eOperatorEqual;
+    }
+
+    setFlags(tokenDef, tokenDef->scope());
+
+    if (endsWith(clangType, " const"))
+        isConst(true);
+}
+
+const Token *Function::setFlags(const Token *tok1, const Scope *scope)
+{
+    if (tok1->isInline())
+        isInlineKeyword(true);
+
+    if (tok1->isExternC())
+        isExtern(true);
+
+    // look for end of previous statement
+    while (tok1->previous() && !Token::Match(tok1->previous(), ";|}|{|public:|protected:|private:")) {
+        tok1 = tok1->previous();
+
+        if (tok1->isInline())
+            isInlineKeyword(true);
+
+        // extern function
+        if (tok1->str() == "extern") {
+            isExtern(true);
+        }
+
+        // virtual function
+        else if (tok1->str() == "virtual") {
+            hasVirtualSpecifier(true);
+        }
+
+        // static function
+        else if (tok1->str() == "static") {
+            isStatic(true);
+            if (scope->type == ScopeType::eNamespace || scope->type == ScopeType::eGlobal)
+                isStaticLocal(true);
+        }
+
+        // friend function
+        else if (tok1->str() == "friend") {
+            isFriend(true);
+        }
+
+        // constexpr function
+        else if (tok1->str() == "constexpr") {
+            isConstexpr(true);
+        }
+
+        // decltype
+        else if (tok1->str() == ")" && Token::simpleMatch(tok1->link()->previous(), "decltype (")) {
+            tok1 = tok1->link()->previous();
+        }
+
+        else if (tok1->link() && tok1->str() == ">") {
+            // Function template
+            if (Token::simpleMatch(tok1->link()->previous(), "template <")) {
+                templateDef = tok1->link()->previous();
+                break;
+            }
+            tok1 = tok1->link();
+        }
+    }
+    return tok1;
+}
+
+std::string Function::fullName() const
+{
+    std::string ret = name();
+    for (const Scope *s = nestedIn; s; s = s->nestedIn) {
+        if (!s->className.empty())
+            ret = s->className + "::" + ret;
+    }
+    ret += "(";
+    for (const Variable &a : argumentList)
+        ret += (a.index() == 0 ? "" : ",") + a.name();
+    return ret + ")";
+}
+
+static std::string qualifiedName(const Scope *scope)
+{
+    std::string name = scope->className;
+    while (scope->nestedIn) {
+        if (!scope->nestedIn->className.empty())
+            name = (scope->nestedIn->className + " :: ") + name;
+        scope = scope->nestedIn;
+    }
+    return name;
+}
+
+static bool usingNamespace(const Scope *scope, const Token *first, const Token *second, int &offset)
+{
+    // check if qualifications match first before checking if using is needed
+    const Token *tok1 = first;
+    const Token *tok2 = second;
+    bool match = false;
+    while (Token::Match(tok1, "%type% :: %type%") && Token::Match(tok2, "%type% :: %type%")) {
+        if (tok1->str() == tok2->str()) {
+            tok1 = tok1->tokAt(2);
+            tok2 = tok2->tokAt(2);
+            match = true;
+        } else {
+            match = false;
+            break;
+        }
+    }
+
+    if (match)
+        return false;
+
+    offset = 0;
+    std::string name = first->str();
+
+    while (Token::Match(first, "%type% :: %type%")) {
+        if (offset)
+            name += (" :: " + first->str());
+        offset += 2;
+        first = first->tokAt(2);
+        if (first->str() == second->str()) {
+            break;
+        }
+    }
+
+    if (offset) {
+        while (scope) {
+            for (const auto & info : scope->usingList) {
+                if (info.scope) {
+                    if (name == qualifiedName(info.scope))
+                        return true;
+                }
+                // no scope so get name from using
+                else {
+                    const Token *start = info.start->tokAt(2);
+                    std::string nsName;
+                    while (start && start->str() != ";") {
+                        if (!nsName.empty())
+                            nsName += " ";
+                        nsName += start->str();
+                        start = start->next();
+                    }
+                    if (nsName == name)
+                        return true;
+                }
+            }
+            scope = scope->nestedIn;
+        }
+    }
+
+    return false;
+}
+
+static bool typesMatch(
+    const Scope *first_scope,
+    const Token *first_token,
+    const Scope *second_scope,
+    const Token *second_token,
+    const Token *&new_first,
+    const Token *&new_second)
+{
+    // get first type
+    const Type* first_type = first_scope->symdb.findType(first_token, first_scope, /*lookOutside*/ true);
+    if (first_type) {
+        // get second type
+        const Type* second_type = second_scope->symdb.findType(second_token, second_scope, /*lookOutside*/ true);
+        // check if types match
+        if (first_type == second_type) {
+            const Token* tok1 = first_token;
+            while (tok1 && tok1->str() != first_type->name())
+                tok1 = tok1->next();
+            const Token *tok2 = second_token;
+            while (tok2 && tok2->str() != second_type->name())
+                tok2 = tok2->next();
+            // update parser token positions
+            if (tok1 && tok2) {
+                new_first = tok1->previous();
+                new_second = tok2->previous();
+                return true;
+            }
+        }
+    }
+    return false;
 }
 
-bool Function::argsMatch(const Scope *scope, const Token *first, const Token *second, const std::string &path, nonneg int path_length)
+bool Function::argsMatch(const Scope *scope, const Token *first, const Token *second, const std::string &path, nonneg int path_length) const
 {
-    const bool isCPP = scope->check->isCPP();
-    if (!isCPP) // C does not support overloads
+    if (!first->isCpp()) // C does not support overloads
         return true;
 
     int arg_path_length = path_length;
+    int offset = 0;
+    int openParen = 0;
+
+    // check for () == (void) and (void) == ()
+    if ((Token::simpleMatch(first, "( )") && Token::simpleMatch(second, "( void )")) ||
+        (Token::simpleMatch(first, "( void )") && Token::simpleMatch(second, "( )")))
+        return true;
+
+    auto skipTopLevelConst = [](const Token* start) -> const Token* {
+        const Token* tok = start->next();
+        if (Token::simpleMatch(tok, "const")) {
+            tok = tok->next();
+            while (Token::Match(tok, "%name%|%type%|::"))
+                tok = tok->next();
+            if (Token::Match(tok, ",|)|="))
+                return start->next();
+        }
+        return start;
+    };
 
     while (first->str() == second->str() &&
            first->isLong() == second->isLong() &&
            first->isUnsigned() == second->isUnsigned()) {
+        if (first->str() == "(")
+            openParen++;
+
+        // at end of argument list
+        else if (first->str() == ")") {
+            if (openParen == 1)
+                return true;
+            --openParen;
+        }
 
         // skip optional type information
         if (Token::Match(first->next(), "struct|enum|union|class"))
@@ -2014,24 +3082,16 @@ bool Function::argsMatch(const Scope *scope, const Token *first, const Token *se
             second = second->next();
 
         // skip const on type passed by value
-        if (Token::Match(first->next(), "const %type% %name%|,|)") &&
-            !Token::Match(first->next(), "const %type% %name%| ["))
-            first = first->next();
-        if (Token::Match(second->next(), "const %type% %name%|,|)") &&
-            !Token::Match(second->next(), "const %type% %name%| ["))
-            second = second->next();
-
-        // at end of argument list
-        if (first->str() == ")") {
-            return true;
-        }
+        const Token* const oldSecond = second;
+        first = skipTopLevelConst(first);
+        second = skipTopLevelConst(second);
 
         // skip default value assignment
-        else if (first->next()->str() == "=") {
+        if (oldSecond == second && first->strAt(1) == "=") {
             first = first->nextArgument();
             if (first)
                 first = first->tokAt(-2);
-            if (second->next()->str() == "=") {
+            if (second->strAt(1) == "=") {
                 second = second->nextArgument();
                 if (second)
                     second = second->tokAt(-2);
@@ -2041,46 +3101,55 @@ bool Function::argsMatch(const Scope *scope, const Token *first, const Token *se
             } else if (!first) { // End of argument list (first)
                 return !second->nextArgument(); // End of argument list (second)
             }
-        } else if (second->next()->str() == "=") {
+        } else if (oldSecond == second && second->strAt(1) == "=") {
             second = second->nextArgument();
             if (second)
                 second = second->tokAt(-2);
             if (!second) { // End of argument list (second)
-                return false;
+                return !first->nextArgument();
             }
         }
 
         // definition missing variable name
-        else if ((first->next()->str() == "," && second->next()->str() != ",") ||
-                 (first->next()->str() == ")" && second->next()->str() != ")")) {
+        else if ((first->strAt(1) == "," && second->strAt(1) != ",") ||
+                 (Token::Match(first, "!!( )") && second->strAt(1) != ")")) {
             second = second->next();
             // skip default value assignment
-            if (second->next()->str() == "=") {
+            if (second->strAt(1) == "=") {
                 do {
                     second = second->next();
                 } while (!Token::Match(second->next(), ",|)"));
             }
-        } else if (first->next()->str() == "[" && second->next()->str() != "[")
+        } else if (first->strAt(1) == "[" && second->strAt(1) != "[")
             second = second->next();
 
         // function missing variable name
-        else if ((second->next()->str() == "," && first->next()->str() != ",") ||
-                 (second->next()->str() == ")" && first->next()->str() != ")")) {
+        else if ((second->strAt(1) == "," && first->strAt(1) != ",") ||
+                 (Token::Match(second, "!!( )") && first->strAt(1) != ")")) {
             first = first->next();
             // skip default value assignment
-            if (first->next()->str() == "=") {
+            if (first->strAt(1) == "=") {
                 do {
                     first = first->next();
                 } while (!Token::Match(first->next(), ",|)"));
             }
-        } else if (second->next()->str() == "[" && first->next()->str() != "[")
+        } else if (second->strAt(1) == "[" && first->strAt(1) != "[")
+            first = first->next();
+
+        // unnamed parameters
+        else if (Token::Match(first, "(|, %type% ,|)") && Token::Match(second, "(|, %type% ,|)")) {
+            if (first->next()->expressionString() != second->next()->expressionString())
+                break;
             first = first->next();
+            second = second->next();
+            continue;
+        }
 
         // argument list has different number of arguments
-        else if (second->str() == ")")
+        else if (openParen == 1 && second->str() == ")" && first->str() != ")")
             break;
 
-        // ckeck for type * x == type x[]
+        // check for type * x == type x[]
         else if (Token::Match(first->next(), "* %name%| ,|)|=") &&
                  Token::Match(second->next(), "%name%| [ ] ,|)")) {
             do {
@@ -2092,35 +3161,62 @@ bool Function::argsMatch(const Scope *scope, const Token *first, const Token *se
         }
 
         // const after *
-        else if (first->next()->str() == "*" && first->strAt(2) != "const" &&
-                 second->next()->str() == "*" && second->strAt(2) == "const") {
-            first = first->next();
-            second = second->tokAt(2);
+        else if (first->strAt(1) == "*" && second->strAt(1) == "*" &&
+                 ((first->strAt(2) != "const" && second->strAt(2) == "const") ||
+                  (first->strAt(2) == "const" && second->strAt(2) != "const"))) {
+            if (first->strAt(2) != "const") {
+                if (Token::Match(first->tokAt(2), "%name%| ,|)") && Token::Match(second->tokAt(3), "%name%| ,|)")) {
+                    first = first->tokAt(Token::Match(first->tokAt(2), "%name%") ? 2 : 1);
+                    second = second->tokAt(Token::Match(second->tokAt(3), "%name%") ? 3 : 2);
+                } else {
+                    first = first->next();
+                    second = second->tokAt(2);
+                }
+            } else {
+                if (Token::Match(second->tokAt(2), "%name%| ,|)") && Token::Match(first->tokAt(3), "%name%| ,|)")) {
+                    first = first->tokAt(Token::Match(first->tokAt(3), "%name%") ? 3 : 2);
+                    second = second->tokAt(Token::Match(second->tokAt(2), "%name%") ? 2 : 1);
+                } else {
+                    first = first->tokAt(2);
+                    second = second->next();
+                }
+            }
         }
 
         // variable names are different
         else if ((Token::Match(first->next(), "%name% ,|)|=|[") &&
                   Token::Match(second->next(), "%name% ,|)|[")) &&
-                 (first->next()->str() != second->next()->str())) {
+                 (first->strAt(1) != second->strAt(1))) {
             // skip variable names
             first = first->next();
             second = second->next();
 
             // skip default value assignment
-            if (first->next()->str() == "=") {
+            if (first->strAt(1) == "=") {
                 do {
                     first = first->next();
                 } while (!Token::Match(first->next(), ",|)"));
             }
         }
 
+        // using namespace
+        else if (usingNamespace(scope, first->next(), second->next(), offset))
+            first = first->tokAt(offset);
+
+        // same type with different qualification
+        else if (typesMatch(scope, first->next(), nestedIn, second->next(), first, second))
+            ;
+
         // variable with class path
         else if (arg_path_length && Token::Match(first->next(), "%name%") && first->strAt(1) != "const") {
             std::string param = path;
 
-            if (Token::simpleMatch(second->next(), param.c_str())) {
-                second = second->tokAt(int(arg_path_length));
-                arg_path_length = 0;
+            if (Token::simpleMatch(second->next(), param.c_str(), param.size())) {
+                // check for redundant qualification before skipping it
+                if (!Token::simpleMatch(first->next(), param.c_str(), param.size())) {
+                    second = second->tokAt(arg_path_length);
+                    arg_path_length = 0;
+                }
             }
 
             // nested or base class variable
@@ -2128,9 +3224,10 @@ bool Function::argsMatch(const Scope *scope, const Token *first, const Token *se
                      (Token::Match(second->next(), "%name% :: %name%") ||
                       (Token::Match(second->next(), "%name% <") &&
                        Token::Match(second->linkAt(1), "> :: %name%"))) &&
-                     ((second->next()->str() == scope->className) ||
-                      (scope->definedType && scope->definedType->isDerivedFrom(second->next()->str()))) &&
-                     (first->next()->str() == second->strAt(3))) {
+                     ((second->strAt(1) == scope->className) ||
+                      (scope->nestedIn && second->strAt(1) == scope->nestedIn->className) ||
+                      (scope->definedType && scope->definedType->isDerivedFrom(second->strAt(1)))) &&
+                     (first->strAt(1) == second->strAt(3))) {
                 if (Token::Match(second->next(), "%name% <"))
                     second = second->linkAt(1)->next();
                 else
@@ -2140,7 +3237,7 @@ bool Function::argsMatch(const Scope *scope, const Token *first, const Token *se
             // remove class name
             else if (arg_path_length > 2 && first->strAt(1) != second->strAt(1)) {
                 std::string short_path = path;
-                unsigned int short_path_length = arg_path_length;
+                int short_path_length = arg_path_length;
 
                 // remove last " :: "
                 short_path.resize(short_path.size() - 4);
@@ -2161,9 +3258,9 @@ bool Function::argsMatch(const Scope *scope, const Token *first, const Token *se
                     }
                 }
 
-                param = short_path;
-                if (Token::simpleMatch(second->next(), param.c_str())) {
-                    second = second->tokAt(int(short_path_length));
+                param = std::move(short_path);
+                if (Token::simpleMatch(second->next(), param.c_str(), param.size())) {
+                    second = second->tokAt(short_path_length);
                     arg_path_length = 0;
                 }
             }
@@ -2180,41 +3277,175 @@ bool Function::argsMatch(const Scope *scope, const Token *first, const Token *se
     return false;
 }
 
-bool Function::returnsReference(const Function *function)
+static bool isUnknownType(const Token* start, const Token* end)
+{
+    while (Token::Match(start, "const|volatile"))
+        start = start->next();
+    start = skipScopeIdentifiers(start);
+    if (start->tokAt(1) == end && !start->type() && !start->isStandardType())
+        return true;
+    // TODO: Try to deduce the type of the expression
+    if (Token::Match(start, "decltype|typeof"))
+        return true;
+    return false;
+}
+
+static const Token* getEnableIfReturnType(const Token* start)
+{
+    if (!start)
+        return nullptr;
+    for (const Token* tok = start->next(); precedes(tok, start->link()); tok = tok->next()) {
+        if (tok->link() && Token::Match(tok, "(|[|{|<")) {
+            tok = tok->link();
+            continue;
+        }
+        if (Token::simpleMatch(tok, ","))
+            return tok->next();
+    }
+    return nullptr;
+}
+
+template<class Predicate>
+static bool checkReturns(const Function* function, bool unknown, bool emptyEnableIf, Predicate pred)
 {
     if (!function)
         return false;
-    if (function->type != Function::eFunction)
+    if (function->type != FunctionType::eFunction && function->type != FunctionType::eOperatorEqual && function->type != FunctionType::eLambda)
+        return false;
+    const Token* defStart = function->retDef;
+    if (!defStart)
+        return unknown;
+    const Token* defEnd = function->returnDefEnd();
+    if (!defEnd)
+        return unknown;
+    if (defEnd == defStart)
+        return unknown;
+    if (pred(defStart, defEnd))
+        return true;
+    if (Token::Match(defEnd->tokAt(-1), "*|&|&&"))
         return false;
-    return function->tokenDef->strAt(-1) == "&";
+    // void STDCALL foo()
+    while (defEnd->previous() != defStart && Token::Match(defEnd->tokAt(-2), "%name%|> %name%") &&
+           !Token::Match(defEnd->tokAt(-2), "const|volatile"))
+        defEnd = defEnd->previous();
+    // enable_if
+    const Token* enableIfEnd = nullptr;
+    if (Token::simpleMatch(defEnd->previous(), ">"))
+        enableIfEnd = defEnd->previous();
+    else if (Token::simpleMatch(defEnd->tokAt(-3), "> :: type"))
+        enableIfEnd = defEnd->tokAt(-3);
+    if (enableIfEnd && enableIfEnd->link() &&
+        Token::Match(enableIfEnd->link()->previous(), "enable_if|enable_if_t|EnableIf")) {
+        if (const Token* start = getEnableIfReturnType(enableIfEnd->link())) {
+            defStart = start;
+            defEnd = enableIfEnd;
+        } else {
+            return emptyEnableIf;
+        }
+    }
+    assert(defEnd != defStart);
+    if (pred(defStart, defEnd))
+        return true;
+    if (isUnknownType(defStart, defEnd)) {
+        const Token* tok = function->token ? function->token->next() : function->tokenDef->next();
+        if (tok->valueType() && tok->valueType()->type >= ValueType::Type::RECORD)
+            return false;
+        return unknown;
+    }
+    return false;
+}
+
+bool Function::returnsConst(const Function* function, bool unknown)
+{
+    return checkReturns(function, unknown, false, [](const Token* defStart, const Token* defEnd) {
+        return Token::findsimplematch(defStart, "const", defEnd);
+    });
+}
+
+bool Function::returnsReference(const Function* function, bool unknown, bool includeRValueRef)
+{
+    return checkReturns(function, unknown, false, [includeRValueRef](const Token* /*defStart*/, const Token* defEnd) {
+        return includeRValueRef ? Token::Match(defEnd->previous(), "&|&&") : Token::simpleMatch(defEnd->previous(), "&");
+    });
+}
+
+bool Function::returnsPointer(const Function* function, bool unknown)
+{
+    return checkReturns(function, unknown, false, [](const Token* /*defStart*/, const Token* defEnd) {
+        return Token::simpleMatch(defEnd->previous(), "*");
+    });
+}
+
+bool Function::returnsStandardType(const Function* function, bool unknown)
+{
+    return checkReturns(function, unknown, true, [](const Token* /*defStart*/, const Token* defEnd) {
+        return defEnd->previous() && defEnd->previous()->isStandardType();
+    });
+}
+
+bool Function::returnsVoid(const Function* function, bool unknown)
+{
+    return checkReturns(function, unknown, true, [](const Token* /*defStart*/, const Token* defEnd) {
+        return Token::simpleMatch(defEnd->previous(), "void");
+    });
+}
+
+std::vector<const Token*> Function::findReturns(const Function* f)
+{
+    std::vector<const Token*> result;
+    if (!f)
+        return result;
+    const Scope* scope = f->functionScope;
+    if (!scope)
+        return result;
+    if (!scope->bodyStart)
+        return result;
+    for (const Token* tok = scope->bodyStart->next(); tok && tok != scope->bodyEnd; tok = tok->next()) {
+        if (tok->str() == "{" && tok->scope() &&
+            (tok->scope()->type == ScopeType::eLambda || tok->scope()->type == ScopeType::eClass)) {
+            tok = tok->link();
+            continue;
+        }
+        if (Token::simpleMatch(tok->astParent(), "return")) {
+            result.push_back(tok);
+        }
+        // Skip lambda functions since the scope may not be set correctly
+        const Token* lambdaEndToken = findLambdaEndToken(tok);
+        if (lambdaEndToken) {
+            tok = lambdaEndToken;
+        }
+    }
+    return result;
 }
 
 const Token * Function::constructorMemberInitialization() const
 {
-    if (!isConstructor() || !functionScope || !functionScope->bodyStart)
+    if (!isConstructor() || !arg)
         return nullptr;
-    if (Token::Match(token, "%name% (") && Token::simpleMatch(token->linkAt(1), ") :"))
-        return token->linkAt(1)->next();
+    if (Token::simpleMatch(arg->link(), ") :"))
+        return arg->link()->next();
+    if (Token::simpleMatch(arg->link(), ") noexcept (") && arg->link()->linkAt(2)->strAt(1) == ":")
+        return arg->link()->linkAt(2)->next();
     return nullptr;
 }
 
-bool Function::isSafe(const Settings *settings) const
+bool Function::isSafe(const Settings &settings) const
 {
-    if (settings->safeChecks.externalFunctions) {
-        if (nestedIn->type == Scope::ScopeType::eNamespace && token->fileIndex() != 0)
+    if (settings.safeChecks.externalFunctions) {
+        if (nestedIn->type == ScopeType::eNamespace && token->fileIndex() != 0)
             return true;
-        if (nestedIn->type == Scope::ScopeType::eGlobal && (token->fileIndex() != 0 || !isStatic()))
+        if (nestedIn->type == ScopeType::eGlobal && (token->fileIndex() != 0 || !isStatic()))
             return true;
     }
 
-    if (settings->safeChecks.internalFunctions) {
-        if (nestedIn->type == Scope::ScopeType::eNamespace && token->fileIndex() == 0)
+    if (settings.safeChecks.internalFunctions) {
+        if (nestedIn->type == ScopeType::eNamespace && token->fileIndex() == 0)
             return true;
-        if (nestedIn->type == Scope::ScopeType::eGlobal && (token->fileIndex() == 0 || isStatic()))
+        if (nestedIn->type == ScopeType::eGlobal && (token->fileIndex() == 0 || isStatic()))
             return true;
     }
 
-    if (settings->safeChecks.classes && access == AccessControl::Public && (nestedIn->type == Scope::ScopeType::eClass || nestedIn->type == Scope::ScopeType::eStruct))
+    if (settings.safeChecks.classes && access == AccessControl::Public && (nestedIn->type == ScopeType::eClass || nestedIn->type == ScopeType::eStruct))
         return true;
 
     return false;
@@ -2225,12 +3456,13 @@ Function* SymbolDatabase::addGlobalFunction(Scope*& scope, const Token*& tok, co
     Function* function = nullptr;
     // Lambda functions are always unique
     if (tok->str() != "[") {
-        for (std::multimap<std::string, const Function *>::iterator i = scope->functionMap.find(tok->str()); i != scope->functionMap.end() && i->first == tok->str(); ++i) {
-            const Function *f = i->second;
+        auto range = scope->functionMap.equal_range(tok->str());
+        for (std::multimap<std::string, const Function*>::const_iterator it = range.first; it != range.second; ++it) {
+            const Function *f = it->second;
             if (f->hasBody())
                 continue;
-            if (Function::argsMatch(scope, f->argDef, argStart, emptyString, 0)) {
-                function = const_cast<Function *>(i->second);
+            if (f->argsMatch(scope, f->argDef, argStart, "", 0)) {
+                function = const_cast<Function *>(it->second);
                 break;
             }
         }
@@ -2243,7 +3475,7 @@ Function* SymbolDatabase::addGlobalFunction(Scope*& scope, const Token*& tok, co
     function->token = funcStart;
     function->hasBody(true);
 
-    addNewFunction(&scope, &tok);
+    addNewFunction(scope, tok);
 
     if (scope) {
         scope->function = function;
@@ -2255,28 +3487,28 @@ Function* SymbolDatabase::addGlobalFunction(Scope*& scope, const Token*& tok, co
 
 Function* SymbolDatabase::addGlobalFunctionDecl(Scope*& scope, const Token *tok, const Token *argStart, const Token* funcStart)
 {
-    Function function(mTokenizer, tok, scope, funcStart, argStart);
-    scope->addFunction(function);
+    Function function(tok, scope, funcStart, argStart);
+    scope->addFunction(std::move(function));
     return &scope->functionList.back();
 }
 
-void SymbolDatabase::addClassFunction(Scope **scope, const Token **tok, const Token *argStart)
+void SymbolDatabase::addClassFunction(Scope *&scope, const Token *&tok, const Token *argStart)
 {
-    const bool destructor((*tok)->previous()->str() == "~");
+    const bool destructor(tok->strAt(-1) == "~");
     const bool has_const(argStart->link()->strAt(1) == "const");
     const bool lval(argStart->link()->strAt(has_const ? 2 : 1) == "&");
     const bool rval(argStart->link()->strAt(has_const ? 2 : 1) == "&&");
     int count = 0;
     std::string path;
     unsigned int path_length = 0;
-    const Token *tok1 = (*tok);
+    const Token *tok1 = tok;
 
     if (destructor)
         tok1 = tok1->previous();
 
     // back up to head of path
-    while (tok1 && tok1->previous() && tok1->previous()->str() == "::" && tok1->tokAt(-2) &&
-           (tok1->tokAt(-2)->isName() ||
+    while (tok1 && tok1->previous() && tok1->strAt(-1) == "::" && tok1->tokAt(-2) &&
+           ((tok1->tokAt(-2)->isName() && !tok1->tokAt(-2)->isStandardType()) ||
             (tok1->strAt(-2) == ">" && tok1->linkAt(-2) && Token::Match(tok1->linkAt(-2)->previous(), "%name%")))) {
         count++;
         const Token * tok2 = tok1->tokAt(-2);
@@ -2285,7 +3517,7 @@ void SymbolDatabase::addClassFunction(Scope **scope, const Token **tok, const To
 
         if (tok2) {
             do {
-                path = tok1->previous()->str() + " " + path;
+                path = tok1->strAt(-1) + " " + path;
                 tok1 = tok1->previous();
                 path_length++;
             } while (tok1 != tok2);
@@ -2297,30 +3529,41 @@ void SymbolDatabase::addClassFunction(Scope **scope, const Token **tok, const To
     if (!tok1)
         return;
 
-    std::list<Scope>::iterator it1;
+    // add global namespace if present
+    if (tok1->strAt(-1) == "::") {
+        path_length++;
+        path.insert(0, ":: ");
+    }
 
     // search for match
-    for (it1 = scopeList.begin(); it1 != scopeList.end(); ++it1) {
+    for (auto it1 = scopeList.begin(); it1 != scopeList.end(); ++it1) {
         Scope *scope1 = &(*it1);
 
         bool match = false;
 
         // check in namespace if using found
-        if (*scope == scope1 && !scope1->usingList.empty()) {
-            std::list<Scope::UsingInfo>::const_iterator it2;
-            for (it2 = scope1->usingList.begin(); it2 != scope1->usingList.end(); ++it2) {
+        if (scope == scope1 && !scope1->usingList.empty()) {
+            for (auto it2 = scope1->usingList.cbegin(); it2 != scope1->usingList.cend(); ++it2) {
                 if (it2->scope) {
                     Function * func = findFunctionInScope(tok1, it2->scope, path, path_length);
                     if (func) {
                         if (!func->hasBody()) {
+                            const Token *closeParen = tok->linkAt(1);
+                            if (closeParen) {
+                                const Token *eq = TokenList::isFunctionHead(closeParen, ";");
+                                if (eq && Token::simpleMatch(eq->tokAt(-2), "= default ;")) {
+                                    func->isDefault(true);
+                                    return;
+                                }
+                            }
                             func->hasBody(true);
-                            func->token = *tok;
+                            func->token = tok;
                             func->arg = argStart;
                             addNewFunction(scope, tok);
-                            if (*scope) {
-                                (*scope)->functionOf = func->nestedIn;
-                                (*scope)->function = func;
-                                (*scope)->function->functionScope = *scope;
+                            if (scope) {
+                                scope->functionOf = func->nestedIn;
+                                scope->function = func;
+                                scope->function->functionScope = scope;
                             }
                             return;
                         }
@@ -2329,16 +3572,17 @@ void SymbolDatabase::addClassFunction(Scope **scope, const Token **tok, const To
             }
         }
 
-        if (scope1->className == tok1->str() && (scope1->type != Scope::eFunction)) {
+        const bool isAnonymousNamespace = (scope1->type == ScopeType::eNamespace && scope1->className.empty());
+        if ((scope1->className == tok1->str() && (scope1->type != ScopeType::eFunction)) || isAnonymousNamespace) {
             // do the scopes match (same scope) or do their names match (multiple namespaces)
-            if ((*scope == scope1->nestedIn) || (*scope &&
-                                                 (*scope)->className == scope1->nestedIn->className &&
-                                                 !(*scope)->className.empty() &&
-                                                 (*scope)->type == scope1->nestedIn->type)) {
+            if ((scope == scope1->nestedIn) || (scope &&
+                                                scope->className == scope1->nestedIn->className &&
+                                                !scope->className.empty() &&
+                                                scope->type == scope1->nestedIn->type)) {
 
                 // nested scopes => check that they match
                 {
-                    const Scope *s1 = *scope;
+                    const Scope *s1 = scope;
                     const Scope *s2 = scope1->nestedIn;
                     while (s1 && s2) {
                         if (s1->className != s2->className)
@@ -2361,6 +3605,8 @@ void SymbolDatabase::addClassFunction(Scope **scope, const Token **tok, const To
                         tok1 = tok1->tokAt(2);
                     scope2 = scope2->findRecordInNestedList(tok1->str());
                 }
+                if (scope2 && isAnonymousNamespace)
+                    scope2 = scope2->findRecordInNestedList(tok1->str());
 
                 if (count == 1 && scope2) {
                     match = true;
@@ -2370,16 +3616,28 @@ void SymbolDatabase::addClassFunction(Scope **scope, const Token **tok, const To
         }
 
         if (match) {
-            for (std::multimap<std::string, const Function *>::iterator it = scope1->functionMap.find((*tok)->str()); it != scope1->functionMap.end() && it->first == (*tok)->str(); ++it) {
-                Function * func = const_cast<Function *>(it->second);
+            auto range = scope1->functionMap.equal_range(tok->str());
+            for (std::multimap<std::string, const Function*>::const_iterator it = range.first; it != range.second; ++it) {
+                auto * func = const_cast<Function *>(it->second);
+                if (destructor && func->type != FunctionType::eDestructor)
+                    continue;
                 if (!func->hasBody()) {
-                    if (Function::argsMatch(scope1, func->argDef, (*tok)->next(), path, path_length)) {
-                        if (func->type == Function::eDestructor && destructor) {
-                            func->hasBody(true);
-                        } else if (func->type != Function::eDestructor && !destructor) {
-                            // normal function?
-                            if ((*tok)->next()->link()) {
-                                const bool hasConstKeyword = (*tok)->next()->link()->next()->str() == "const";
+                    if (func->argsMatch(scope1, func->argDef, tok->next(), path, path_length)) {
+                        const Token *closeParen = tok->linkAt(1);
+                        if (closeParen) {
+                            const Token *eq = TokenList::isFunctionHead(closeParen, ";");
+                            if (eq && Token::Match(eq->tokAt(-2), "= default|delete ;")) {
+                                if (eq->strAt(-1) == "default")
+                                    func->isDefault(true);
+                                else
+                                    func->isDelete(true);
+                                return;
+                            }
+                            if (func->type == FunctionType::eDestructor && destructor) {
+                                func->hasBody(true);
+                            } else if (func->type != FunctionType::eDestructor && !destructor) {
+                                // normal function?
+                                const bool hasConstKeyword = closeParen->strAt(1) == "const";
                                 if ((func->isConst() == hasConstKeyword) &&
                                     (func->hasLvalRefQualifier() == lval) &&
                                     (func->hasRvalRefQualifier() == rval)) {
@@ -2389,13 +3647,13 @@ void SymbolDatabase::addClassFunction(Scope **scope, const Token **tok, const To
                         }
 
                         if (func->hasBody()) {
-                            func->token = *tok;
+                            func->token = tok;
                             func->arg = argStart;
                             addNewFunction(scope, tok);
-                            if (*scope) {
-                                (*scope)->functionOf = scope1;
-                                (*scope)->function = func;
-                                (*scope)->function->functionScope = *scope;
+                            if (scope) {
+                                scope->functionOf = scope1;
+                                scope->function = func;
+                                scope->function->functionScope = scope;
                             }
                             return;
                         }
@@ -2409,20 +3667,18 @@ void SymbolDatabase::addClassFunction(Scope **scope, const Token **tok, const To
     addNewFunction(scope, tok);
 }
 
-void SymbolDatabase::addNewFunction(Scope **scope, const Token **tok)
+void SymbolDatabase::addNewFunction(Scope *&scope, const Token *&tok)
 {
-    const Token *tok1 = *tok;
-    scopeList.emplace_back(this, tok1, *scope);
+    const Token *tok1 = tok;
+    scopeList.emplace_back(*this, tok1, scope);
     Scope *newScope = &scopeList.back();
 
     // find start of function '{'
     bool foundInitList = false;
     while (tok1 && tok1->str() != "{" && tok1->str() != ";") {
-        if (tok1->link() && Token::Match(tok1, "(|<")) {
+        if (tok1->link() && Token::Match(tok1, "(|[|<")) {
             tok1 = tok1->link();
-        } else if (foundInitList &&
-                   Token::Match(tok1, "%name%|> {") &&
-                   Token::Match(tok1->linkAt(1), "} ,|{")) {
+        } else if (foundInitList && Token::Match(tok1, "%name%|> {") && Token::Match(tok1->linkAt(1), "} ,|{")) {
             tok1 = tok1->linkAt(1);
         } else {
             if (tok1->str() == ":")
@@ -2432,27 +3688,43 @@ void SymbolDatabase::addNewFunction(Scope **scope, const Token **tok)
     }
 
     if (tok1 && tok1->str() == "{") {
-        newScope->bodyStart = tok1;
-        newScope->bodyEnd = tok1->link();
+        newScope->setBodyStartEnd(tok1);
 
         // syntax error?
         if (!newScope->bodyEnd) {
-            scopeList.pop_back();
-            while (tok1->next())
-                tok1 = tok1->next();
-            *scope = nullptr;
-            *tok = tok1;
-            return;
+            mTokenizer.unmatchedToken(tok1);
+        } else {
+            scope->nestedList.push_back(newScope);
+            scope = newScope;
         }
-
-        (*scope)->nestedList.push_back(newScope);
-        *scope = newScope;
-        *tok = tok1;
-    } else {
+    } else if (tok1 && Token::Match(tok1->tokAt(-2), "= default|delete ;")) {
         scopeList.pop_back();
-        *scope = nullptr;
-        *tok = nullptr;
+    } else {
+        throw InternalError(tok, "Analysis failed (function not recognized). If the code is valid then please report this failure.");
     }
+    tok = tok1;
+}
+
+bool Type::isClassType() const
+{
+    return classScope && classScope->type == ScopeType::eClass;
+}
+
+bool Type::isEnumType() const
+{
+    //We explicitly check for "enum" because a forward declared enum doesn't get its own scope
+    return (classDef && classDef->str() == "enum") ||
+           (classScope && classScope->type == ScopeType::eEnum);
+}
+
+bool Type::isStructType() const
+{
+    return classScope && classScope->type == ScopeType::eStruct;
+}
+
+bool Type::isUnionType() const
+{
+    return classScope && classScope->type == ScopeType::eUnion;
 }
 
 const Token *Type::initBaseInfo(const Token *tok, const Token *tok1)
@@ -2526,8 +3798,12 @@ const Token *Type::initBaseInfo(const Token *tok, const Token *tok1)
                 }
             }
 
+            const Type * baseType = classScope->symdb.findType(base.nameTok, enclosingScope);
+            if (baseType && !baseType->findDependency(this))
+                base.type = baseType;
+
             // save pattern for base class name
-            derivedFrom.push_back(base);
+            derivedFrom.push_back(std::move(base));
         } else
             tok2 = tok2->next();
     }
@@ -2535,37 +3811,60 @@ const Token *Type::initBaseInfo(const Token *tok, const Token *tok1)
     return tok2;
 }
 
-const std::string& Type::name() const
+std::string Type::name() const
 {
-    const Token* next = classDef->next();
+    const Token* start = classDef->next();
     if (classScope && classScope->enumClass && isEnumType())
-        return next->strAt(1);
-    else if (next->str() == "class")
-        return next->strAt(1);
-    else if (next->isName())
-        return next->str();
-    return emptyString;
+        start = start->tokAt(1);
+    else if (start->str() == "class")
+        start = start->tokAt(1);
+    else if (!start->isName())
+        return "";
+    const Token* next = start;
+    while (Token::Match(next, "::|<|>|(|)|[|]|*|&|&&|%name%")) {
+        if (Token::Match(next, "<|(|[") && next->link())
+            next = next->link();
+        next = next->next();
+    }
+    std::string result;
+    for (const Token* tok = start; tok != next; tok = tok->next()) {
+        if (!result.empty())
+            result += ' ';
+        result += tok->str();
+    }
+    return result;
+}
+
+void SymbolDatabase::debugMessage(const Token *tok, const std::string &type, const std::string &msg) const
+{
+    if (tok && mSettings.debugwarnings) {
+        const std::list<const Token*> locationList(1, tok);
+        const ErrorMessage errmsg(locationList, &mTokenizer.list,
+                                  Severity::debug,
+                                  type,
+                                  msg,
+                                  Certainty::normal);
+        mErrorLogger.reportErr(errmsg);
+    }
 }
 
-void SymbolDatabase::debugMessage(const Token *tok, const std::string &msg) const
+void SymbolDatabase::returnImplicitIntError(const Token *tok) const
 {
-    if (tok && mSettings->debugwarnings) {
+    if (tok && mSettings.severity.isEnabled(Severity::portability) && (tok->isC() && mSettings.standards.c != Standards::C89)) {
         const std::list<const Token*> locationList(1, tok);
-        const ErrorLogger::ErrorMessage errmsg(locationList, &mTokenizer->list,
-                                               Severity::debug,
-                                               "debug",
-                                               msg,
-                                               false);
-        if (mErrorLogger)
-            mErrorLogger->reportErr(errmsg);
+        const ErrorMessage errmsg(locationList, &mTokenizer.list,
+                                  Severity::portability,
+                                  "returnImplicitInt",
+                                  "Omitted return type of function '" + tok->str() + "' defaults to int, this is not supported by ISO C99 and later standards.",
+                                  Certainty::normal);
+        mErrorLogger.reportErr(errmsg);
     }
 }
 
 const Function* Type::getFunction(const std::string& funcName) const
 {
     if (classScope) {
-        const std::multimap<std::string, const Function *>::const_iterator it = classScope->functionMap.find(funcName);
-
+        const auto it = classScope->functionMap.find(funcName);
         if (it != classScope->functionMap.end())
             return it->second;
     }
@@ -2586,36 +3885,31 @@ bool Type::hasCircularDependencies(std::set<BaseInfo>* ancestors) const
     if (!ancestors) {
         ancestors=&knownAncestors;
     }
-    for (std::vector<BaseInfo>::const_iterator parent=derivedFrom.begin(); parent!=derivedFrom.end(); ++parent) {
+    for (auto parent=derivedFrom.cbegin(); parent!=derivedFrom.cend(); ++parent) {
         if (!parent->type)
             continue;
-        else if (this==parent->type)
+        if (this==parent->type)
             return true;
-        else if (ancestors->find(*parent)!=ancestors->end())
+        if (ancestors->find(*parent)!=ancestors->end())
+            return true;
+
+        ancestors->insert(*parent);
+        if (parent->type->hasCircularDependencies(ancestors))
             return true;
-        else {
-            ancestors->insert(*parent);
-            if (parent->type->hasCircularDependencies(ancestors))
-                return true;
-        }
     }
     return false;
 }
 
 bool Type::findDependency(const Type* ancestor) const
 {
-    if (this==ancestor)
-        return true;
-    for (std::vector<BaseInfo>::const_iterator parent=derivedFrom.begin(); parent!=derivedFrom.end(); ++parent) {
-        if (parent->type && parent->type->findDependency(ancestor))
-            return true;
-    }
-    return false;
+    return this == ancestor || std::any_of(derivedFrom.cbegin(), derivedFrom.cend(), [&](const BaseInfo& d) {
+        return d.type && (d.type == this || d.type->findDependency(ancestor));
+    });
 }
 
 bool Type::isDerivedFrom(const std::string & ancestor) const
 {
-    for (std::vector<BaseInfo>::const_iterator parent=derivedFrom.begin(); parent!=derivedFrom.end(); ++parent) {
+    for (auto parent=derivedFrom.cbegin(); parent!=derivedFrom.cend(); ++parent) {
         if (parent->name == ancestor)
             return true;
         if (parent->type && parent->type->isDerivedFrom(ancestor))
@@ -2624,28 +3918,28 @@ bool Type::isDerivedFrom(const std::string & ancestor) const
     return false;
 }
 
-bool Variable::arrayDimensions(const Settings* settings)
+bool Variable::arrayDimensions(const Settings& settings, bool& isContainer)
 {
-    const Library::Container* container = settings->library.detectContainer(mTypeStartToken);
+    isContainer = false;
+    const Library::Container* container = (mTypeStartToken && mTypeStartToken->isCpp()) ? settings.library.detectContainer(mTypeStartToken) : nullptr;
     if (container && container->arrayLike_indexOp && container->size_templateArgNo > 0) {
-        const Token* tok = Token::findsimplematch(mTypeStartToken, "<");
-        if (tok) {
+        const Token* tok = mTypeStartToken;
+        while (Token::Match(tok, "%name%|::"))
+            tok = tok->next();
+        if (tok && tok->str() == "<") {
+            isContainer = true;
             Dimension dimension_;
             tok = tok->next();
             for (int i = 0; i < container->size_templateArgNo && tok; i++) {
                 tok = tok->nextTemplateArgument();
             }
-            if (tok) {
-                while (!tok->astParent() && !Token::Match(tok->next(), "[,<>]"))
-                    tok = tok->next();
-                while (tok->astParent() && !Token::Match(tok->astParent(), "[,<>]"))
-                    tok = tok->astParent();
+            if (Token::Match(tok, "%num% [,>]")) {
                 dimension_.tok = tok;
-                ValueFlow::valueFlowConstantFoldAST(const_cast<Token *>(dimension_.tok), settings);
-                if (tok->hasKnownIntValue()) {
-                    dimension_.num = tok->getKnownIntValue();
-                    dimension_.known = true;
-                }
+                dimension_.known = true;
+                dimension_.num = MathLib::toBigNumber(tok);
+            } else if (tok) {
+                dimension_.tok = tok;
+                dimension_.known = false;
             }
             mDimensions.push_back(dimension_);
             return true;
@@ -2670,12 +3964,21 @@ bool Variable::arrayDimensions(const Settings* settings)
         Dimension dimension_;
         dimension_.known = false;
         // check for empty array dimension []
-        if (dim->next()->str() != "]") {
+        if (dim->strAt(1) != "]") {
             dimension_.tok = dim->astOperand2();
+            // TODO: only perform when ValueFlow is enabled
+            // TODO: collect timing information for this call?
             ValueFlow::valueFlowConstantFoldAST(const_cast<Token *>(dimension_.tok), settings);
-            if (dimension_.tok && dimension_.tok->hasKnownIntValue()) {
-                dimension_.num = dimension_.tok->getKnownIntValue();
-                dimension_.known = true;
+            if (dimension_.tok) {
+                if (const ValueFlow::Value* v = dimension_.tok->getKnownValue(ValueFlow::Value::ValueType::INT)) {
+                    dimension_.num = v->intvalue;
+                    dimension_.known = true;
+                }
+                else if (dimension_.tok->isTemplateArg() && !dimension_.tok->values().empty()) {
+                    assert(dimension_.tok->values().size() == 1);
+                    dimension_.num = dimension_.tok->values().front().intvalue;
+                    dimension_.known = true;
+                }
             }
         }
         mDimensions.push_back(dimension_);
@@ -2685,30 +3988,54 @@ bool Variable::arrayDimensions(const Settings* settings)
     return arr;
 }
 
-static std::ostream & operator << (std::ostream & s, Scope::ScopeType type)
-{
-    s << (type == Scope::eGlobal ? "Global" :
-          type == Scope::eClass ? "Class" :
-          type == Scope::eStruct ? "Struct" :
-          type == Scope::eUnion ? "Union" :
-          type == Scope::eNamespace ? "Namespace" :
-          type == Scope::eFunction ? "Function" :
-          type == Scope::eIf ? "If" :
-          type == Scope::eElse ? "Else" :
-          type == Scope::eFor ? "For" :
-          type == Scope::eWhile ? "While" :
-          type == Scope::eDo ? "Do" :
-          type == Scope::eSwitch ? "Switch" :
-          type == Scope::eTry ? "Try" :
-          type == Scope::eCatch ? "Catch" :
-          type == Scope::eUnconditional ? "Unconditional" :
-          type == Scope::eLambda ? "Lambda" :
-          type == Scope::eEnum ? "Enum" :
-          "Unknown");
+static std::string scopeTypeToString(ScopeType type)
+{
+    switch (type) {
+    case ScopeType::eGlobal:
+        return "Global";
+    case ScopeType::eClass:
+        return "Class";
+    case ScopeType::eStruct:
+        return "Struct";
+    case ScopeType::eUnion:
+        return "Union";
+    case ScopeType::eNamespace:
+        return "Namespace";
+    case ScopeType::eFunction:
+        return "Function";
+    case ScopeType::eIf:
+        return "If";
+    case ScopeType::eElse:
+        return "Else";
+    case ScopeType::eFor:
+        return "For";
+    case ScopeType::eWhile:
+        return "While";
+    case ScopeType::eDo:
+        return "Do";
+    case ScopeType::eSwitch:
+        return "Switch";
+    case ScopeType::eTry:
+        return "Try";
+    case ScopeType::eCatch:
+        return "Catch";
+    case ScopeType::eUnconditional:
+        return "Unconditional";
+    case ScopeType::eLambda:
+        return "Lambda";
+    case ScopeType::eEnum:
+        return "Enum";
+    }
+    return "Unknown";
+}
+
+static std::ostream & operator << (std::ostream & s, ScopeType type)
+{
+    s << scopeTypeToString(type);
     return s;
 }
 
-static std::string accessControlToString(const AccessControl& access)
+static std::string accessControlToString(AccessControl access)
 {
     switch (access) {
     case AccessControl::Public:
@@ -2731,24 +4058,47 @@ static std::string accessControlToString(const AccessControl& access)
     return "Unknown";
 }
 
-static std::string tokenToString(const Token* tok, const Tokenizer* tokenizer)
+static const char* functionTypeToString(FunctionType type)
+{
+    switch (type) {
+    case FunctionType::eConstructor:
+        return "Constructor";
+    case FunctionType::eCopyConstructor:
+        return "CopyConstructor";
+    case FunctionType::eMoveConstructor:
+        return "MoveConstructor";
+    case FunctionType::eOperatorEqual:
+        return "OperatorEqual";
+    case FunctionType::eDestructor:
+        return "Destructor";
+    case FunctionType::eFunction:
+        return "Function";
+    case FunctionType::eLambda:
+        return "Lambda";
+    }
+    cppcheck::unreachable();
+}
+
+static std::string tokenToString(const Token* tok, const Tokenizer& tokenizer)
 {
     std::ostringstream oss;
     if (tok) {
         oss << tok->str() << " ";
-        oss << tokenizer->list.fileLine(tok) << " ";
+        oss << tokenizer.list.fileLine(tok) << " ";
     }
     oss << tok;
     return oss.str();
 }
 
-static std::string scopeToString(const Scope* scope, const Tokenizer* tokenizer)
+static std::string scopeToString(const Scope* scope, const Tokenizer& tokenizer)
 {
     std::ostringstream oss;
     if (scope) {
         oss << scope->type << " ";
+        if (!scope->className.empty())
+            oss << scope->className << " ";
         if (scope->classDef)
-            oss << tokenizer->list.fileLine(scope->classDef) << " ";
+            oss << tokenizer.list.fileLine(scope->classDef) << " ";
     }
     oss << scope;
     return oss.str();
@@ -2780,20 +4130,24 @@ void SymbolDatabase::printVariable(const Variable *var, const char *indent) cons
     std::cout << indent << "mTypeStartToken: " << tokenToString(var->typeStartToken(), mTokenizer) << std::endl;
     std::cout << indent << "mTypeEndToken: " << tokenToString(var->typeEndToken(), mTokenizer) << std::endl;
 
-    const Token * autoTok = nullptr;
-    std::cout << indent << "   ";
-    for (const Token * tok = var->typeStartToken(); tok != var->typeEndToken()->next(); tok = tok->next()) {
-        std::cout << " " << tokenType(tok);
-        if (tok->str() == "auto")
-            autoTok = tok;
-    }
-    std::cout << std::endl;
-    if (autoTok) {
-        const ValueType * valueType = autoTok->valueType();
-        std::cout << indent << "    auto valueType: " << valueType << std::endl;
-        if (var->typeStartToken()->valueType()) {
-            std::cout << indent << "        " << valueType->str() << std::endl;
+    if (var->typeStartToken()) {
+        const Token * autoTok = nullptr;
+        std::cout << indent << "   ";
+        for (const Token * tok = var->typeStartToken(); tok != var->typeEndToken()->next(); tok = tok->next()) {
+            std::cout << " " << tokenType(tok);
+            if (tok->str() == "auto")
+                autoTok = tok;
+        }
+        std::cout << std::endl;
+        if (autoTok) {
+            const ValueType * valueType = autoTok->valueType();
+            std::cout << indent << "    auto valueType: " << valueType << std::endl;
+            if (var->typeStartToken()->valueType()) {
+                std::cout << indent << "        " << valueType->str() << std::endl;
+            }
         }
+    } else if (var->valueType()) {
+        std::cout << indent << "   " << var->valueType()->str() << std::endl;
     }
     std::cout << indent << "mIndex: " << var->index() << std::endl;
     std::cout << indent << "mAccess: " << accessControlToString(var->accessControl()) << std::endl;
@@ -2813,7 +4167,7 @@ void SymbolDatabase::printVariable(const Variable *var, const char *indent) cons
     std::cout << indent << "mType: ";
     if (var->type()) {
         std::cout << var->type()->type() << " " << var->type()->name();
-        std::cout << " " << mTokenizer->list.fileLine(var->type()->classDef);
+        std::cout << " " << mTokenizer.list.fileLine(var->type()->classDef);
         std::cout << " " << var->type() << std::endl;
     } else
         std::cout << "none" << std::endl;
@@ -2843,27 +4197,18 @@ void SymbolDatabase::printOut(const char *title) const
     if (title)
         std::cout << "\n### " << title << " ###\n";
 
-    for (std::list<Scope>::const_iterator scope = scopeList.begin(); scope != scopeList.end(); ++scope) {
+    for (auto scope = scopeList.cbegin(); scope != scopeList.cend(); ++scope) {
         std::cout << "Scope: " << &*scope << " " << scope->type << std::endl;
         std::cout << "    className: " << scope->className << std::endl;
         std::cout << "    classDef: " << tokenToString(scope->classDef, mTokenizer) << std::endl;
         std::cout << "    bodyStart: " << tokenToString(scope->bodyStart, mTokenizer) << std::endl;
         std::cout << "    bodyEnd: " << tokenToString(scope->bodyEnd, mTokenizer) << std::endl;
 
-        std::list<Function>::const_iterator func;
-
         // find the function body if not implemented inline
-        for (func = scope->functionList.begin(); func != scope->functionList.end(); ++func) {
+        for (auto func = scope->functionList.cbegin(); func != scope->functionList.cend(); ++func) {
             std::cout << "    Function: " << &*func << std::endl;
             std::cout << "        name: " << tokenToString(func->tokenDef, mTokenizer) << std::endl;
-            std::cout << "        type: " << (func->type == Function::eConstructor? "Constructor" :
-                                              func->type == Function::eCopyConstructor ? "CopyConstructor" :
-                                              func->type == Function::eMoveConstructor ? "MoveConstructor" :
-                                              func->type == Function::eOperatorEqual ? "OperatorEqual" :
-                                              func->type == Function::eDestructor ? "Destructor" :
-                                              func->type == Function::eFunction ? "Function" :
-                                              func->type == Function::eLambda ? "Lambda" :
-                                              "Unknown") << std::endl;
+            std::cout << "        type: " << functionTypeToString(func->type) << std::endl;
             std::cout << "        access: " << accessControlToString(func->access) << std::endl;
             std::cout << "        hasBody: " << func->hasBody() << std::endl;
             std::cout << "        isInline: " << func->isInline() << std::endl;
@@ -2917,12 +4262,9 @@ void SymbolDatabase::printOut(const char *title) const
             }
             std::cout << "        retType: " << func->retType << std::endl;
 
-            if (func->tokenDef->next()->valueType()) {
-                const ValueType * valueType = func->tokenDef->next()->valueType();
+            if (const ValueType* valueType = func->tokenDef->next()->valueType()) {
                 std::cout << "        valueType: " << valueType << std::endl;
-                if (valueType) {
-                    std::cout << "            " << valueType->str() << std::endl;
-                }
+                std::cout << "            " << valueType->str() << std::endl;
             }
 
             if (func->hasBody()) {
@@ -2932,41 +4274,36 @@ void SymbolDatabase::printOut(const char *title) const
             std::cout << "        nestedIn: " << scopeToString(func->nestedIn, mTokenizer) << std::endl;
             std::cout << "        functionScope: " << scopeToString(func->functionScope, mTokenizer) << std::endl;
 
-            std::list<Variable>::const_iterator var;
-
-            for (var = func->argumentList.begin(); var != func->argumentList.end(); ++var) {
+            for (auto var = func->argumentList.cbegin(); var != func->argumentList.cend(); ++var) {
                 std::cout << "        Variable: " << &*var << std::endl;
                 printVariable(&*var, "            ");
             }
         }
 
-        std::list<Variable>::const_iterator var;
-
-        for (var = scope->varlist.begin(); var != scope->varlist.end(); ++var) {
+        for (auto var = scope->varlist.cbegin(); var != scope->varlist.cend(); ++var) {
             std::cout << "    Variable: " << &*var << std::endl;
             printVariable(&*var, "        ");
         }
 
-        if (scope->type == Scope::eEnum) {
+        if (scope->type == ScopeType::eEnum) {
             std::cout << "    enumType: ";
-            if (scope->enumType)
-                scope->enumType->stringify(std::cout, false, true, false);
-            else
+            if (scope->enumType) {
+                std::cout << scope->enumType->stringify(false, true, false);
+            } else
                 std::cout << "int";
             std::cout << std::endl;
             std::cout << "    enumClass: " << scope->enumClass << std::endl;
-            for (std::vector<Enumerator>::const_iterator enumerator = scope->enumeratorList.begin(); enumerator != scope->enumeratorList.end(); ++enumerator) {
-                std::cout << "        Enumerator: " << enumerator->name->str() << " = ";
-                if (enumerator->value_known) {
-                    std::cout << enumerator->value;
-                }
-
-                if (enumerator->start) {
-                    const Token * tok = enumerator->start;
-                    std::cout << (enumerator->value_known ? " " : "") << "[" << tok->str();
-                    while (tok && tok != enumerator->end) {
+            for (const Enumerator &enumerator : scope->enumeratorList) {
+                std::cout << "        Enumerator: " << enumerator.name->str() << " = ";
+                if (enumerator.value_known)
+                    std::cout << enumerator.value;
+
+                if (enumerator.start) {
+                    const Token * tok = enumerator.start;
+                    std::cout << (enumerator.value_known ? " " : "") << "[" << tok->str();
+                    while (tok && tok != enumerator.end) {
                         if (tok->next())
-                            std::cout << " " << tok->next()->str();
+                            std::cout << " " << tok->strAt(1);
                         tok = tok->next();
                     }
 
@@ -2988,10 +4325,8 @@ void SymbolDatabase::printOut(const char *title) const
 
         std::cout << "    nestedList[" << scope->nestedList.size() << "] = (";
 
-        std::list<Scope *>::const_iterator nsi;
-
         std::size_t count = scope->nestedList.size();
-        for (nsi = scope->nestedList.begin(); nsi != scope->nestedList.end(); ++nsi) {
+        for (auto nsi = scope->nestedList.cbegin(); nsi != scope->nestedList.cend(); ++nsi) {
             std::cout << " " << (*nsi) << " " << (*nsi)->type << " " << (*nsi)->className;
             if (count-- > 1)
                 std::cout << ",";
@@ -2999,16 +4334,14 @@ void SymbolDatabase::printOut(const char *title) const
 
         std::cout << " )" << std::endl;
 
-        std::list<Scope::UsingInfo>::const_iterator use;
-
-        for (use = scope->usingList.begin(); use != scope->usingList.end(); ++use) {
+        for (auto use = scope->usingList.cbegin(); use != scope->usingList.cend(); ++use) {
             std::cout << "    using: " << use->scope << " " << use->start->strAt(2);
             const Token *tok1 = use->start->tokAt(3);
             while (tok1 && tok1->str() == "::") {
                 std::cout << "::" << tok1->strAt(1);
                 tok1 = tok1->tokAt(2);
             }
-            std::cout << " " << mTokenizer->list.fileLine(use->start) << std::endl;
+            std::cout << " " << mTokenizer.list.fileLine(use->start) << std::endl;
         }
 
         std::cout << "    functionOf: " << scopeToString(scope->functionOf, mTokenizer) << std::endl;
@@ -3019,7 +4352,7 @@ void SymbolDatabase::printOut(const char *title) const
         std::cout << std::endl;
     }
 
-    for (std::list<Type>::const_iterator type = typeList.begin(); type != typeList.end(); ++type) {
+    for (auto type = typeList.cbegin(); type != typeList.cend(); ++type) {
         std::cout << "Type: " << &(*type) << std::endl;
         std::cout << "    name: " << type->name() << std::endl;
         std::cout << "    classDef: " << tokenToString(type->classDef, mTokenizer) << std::endl;
@@ -3031,9 +4364,9 @@ void SymbolDatabase::printOut(const char *title) const
         }
         std::cout << std::endl;
         std::cout << "    needInitialization: " << (type->needInitialization == Type::NeedInitialization::Unknown ? "Unknown" :
-                  type->needInitialization == Type::NeedInitialization::True ? "True" :
-                  type->needInitialization == Type::NeedInitialization::False ? "False" :
-                  "Invalid") << std::endl;
+                                                    type->needInitialization == Type::NeedInitialization::True ? "True" :
+                                                    type->needInitialization == Type::NeedInitialization::False ? "False" :
+                                                    "Invalid") << std::endl;
 
         std::cout << "    derivedFrom[" << type->derivedFrom.size() << "] = (";
         std::size_t count = type->derivedFrom.size();
@@ -3079,7 +4412,7 @@ void SymbolDatabase::printOut(const char *title) const
         std::cout << "mVariableList[" << i << "]: " << mVariableList[i];
         if (mVariableList[i]) {
             std::cout << " " << mVariableList[i]->name() << " "
-                      << mTokenizer->list.fileLine(mVariableList[i]->nameToken());
+                      << mTokenizer.list.fileLine(mVariableList[i]->nameToken());
         }
         std::cout << std::endl;
     }
@@ -3088,107 +4421,241 @@ void SymbolDatabase::printOut(const char *title) const
 
 void SymbolDatabase::printXml(std::ostream &out) const
 {
-    out << std::setiosflags(std::ios::boolalpha);
+    std::string outs;
 
     std::set<const Variable *> variables;
 
     // Scopes..
-    out << "  <scopes>" << std::endl;
-    for (std::list<Scope>::const_iterator scope = scopeList.begin(); scope != scopeList.end(); ++scope) {
-        out << "    <scope";
-        out << " id=\"" << &*scope << "\"";
-        out << " type=\"" << scope->type << "\"";
-        if (!scope->className.empty())
-            out << " className=\"" << ErrorLogger::toxml(scope->className) << "\"";
-        if (scope->bodyStart)
-            out << " bodyStart=\"" << scope->bodyStart << '\"';
-        if (scope->bodyEnd)
-            out << " bodyEnd=\"" << scope->bodyEnd << '\"';
-        if (scope->nestedIn)
-            out << " nestedIn=\"" << scope->nestedIn << "\"";
-        if (scope->function)
-            out << " function=\"" << scope->function << "\"";
+    outs += "  <scopes>\n";
+    for (auto scope = scopeList.cbegin(); scope != scopeList.cend(); ++scope) {
+        outs += "    <scope";
+        outs += " id=\"";
+        outs += id_string(&*scope);
+        outs += "\"";
+        outs += " type=\"";
+        outs += scopeTypeToString(scope->type);
+        outs += "\"";
+        if (!scope->className.empty()) {
+            outs += " className=\"";
+            outs += ErrorLogger::toxml(scope->className);
+            outs += "\"";
+        }
+        if (scope->bodyStart) {
+            outs += " bodyStart=\"";
+            outs += id_string(scope->bodyStart);
+            outs += '\"';
+        }
+        if (scope->bodyEnd) {
+            outs += " bodyEnd=\"";
+            outs += id_string(scope->bodyEnd);
+            outs += '\"';
+        }
+        if (scope->nestedIn) {
+            outs += " nestedIn=\"";
+            outs += id_string(scope->nestedIn);
+            outs += "\"";
+        }
+        if (scope->function) {
+            outs += " function=\"";
+            outs += id_string(scope->function);
+            outs += "\"";
+        }
+        if (scope->definedType) {
+            outs += " definedType=\"";
+            outs += id_string(scope->definedType);
+            outs += "\"";
+        }
         if (scope->functionList.empty() && scope->varlist.empty())
-            out << "/>" << std::endl;
+            outs += "/>\n";
         else {
-            out << '>' << std::endl;
+            outs += ">\n";
             if (!scope->functionList.empty()) {
-                out << "      <functionList>" << std::endl;
-                for (std::list<Function>::const_iterator function = scope->functionList.begin(); function != scope->functionList.end(); ++function) {
-                    out << "        <function id=\"" << &*function << "\" tokenDef=\"" << function->tokenDef << "\" name=\"" << ErrorLogger::toxml(function->name()) << '\"';
-                    out << " type=\"" << (function->type == Function::eConstructor? "Constructor" :
-                                          function->type == Function::eCopyConstructor ? "CopyConstructor" :
-                                          function->type == Function::eMoveConstructor ? "MoveConstructor" :
-                                          function->type == Function::eOperatorEqual ? "OperatorEqual" :
-                                          function->type == Function::eDestructor ? "Destructor" :
-                                          function->type == Function::eFunction ? "Function" :
-                                          function->type == Function::eLambda ? "Lambda" :
-                                          "Unknown") << '\"';
+                outs += "      <functionList>\n";
+                for (auto function = scope->functionList.cbegin(); function != scope->functionList.cend(); ++function) {
+                    outs += "        <function id=\"";
+                    outs += id_string(&*function);
+                    outs += "\" token=\"";
+                    outs += id_string(function->token);
+                    outs += "\" tokenDef=\"";
+                    outs += id_string(function->tokenDef);
+                    outs += "\" name=\"";
+                    outs += ErrorLogger::toxml(function->name());
+                    outs += '\"';
+                    outs += " type=\"";
+                    outs += functionTypeToString(function->type);
+                    outs += '\"';
                     if (function->nestedIn->definedType) {
                         if (function->hasVirtualSpecifier())
-                            out << " hasVirtualSpecifier=\"true\"";
+                            outs += " hasVirtualSpecifier=\"true\"";
                         else if (function->isImplicitlyVirtual())
-                            out << " isImplicitlyVirtual=\"true\"";
+                            outs += " isImplicitlyVirtual=\"true\"";
                     }
+                    if (function->access == AccessControl::Public || function->access == AccessControl::Protected || function->access == AccessControl::Private) {
+                        outs += " access=\"";
+                        outs += accessControlToString(function->access);
+                        outs +="\"";
+                    }
+                    if (function->isOperator())
+                        outs += " isOperator=\"true\"";
+                    if (function->isExplicit())
+                        outs += " isExplicit=\"true\"";
+                    if (function->hasOverrideSpecifier())
+                        outs += " hasOverrideSpecifier=\"true\"";
+                    if (function->hasFinalSpecifier())
+                        outs += " hasFinalSpecifier=\"true\"";
+                    if (function->isInlineKeyword())
+                        outs += " isInlineKeyword=\"true\"";
+                    if (function->isStatic())
+                        outs += " isStatic=\"true\"";
+                    if (function->isFriend())
+                        outs += " isFriend=\"true\"";
+                    if (function->isAttributeNoreturn())
+                        outs += " isAttributeNoreturn=\"true\"";
+                    if (const Function* overriddenFunction = function->getOverriddenFunction()) {
+                        outs += " overriddenFunction=\"";
+                        outs += id_string(overriddenFunction);
+                        outs += "\"";
+                    }
+                    if (function->isAttributeConst())
+                        outs += " isAttributeConst=\"true\"";
+                    if (function->isAttributePure())
+                        outs += " isAttributePure=\"true\"";
                     if (function->argCount() == 0U)
-                        out << "/>" << std::endl;
+                        outs += "/>\n";
                     else {
-                        out << ">" << std::endl;
+                        outs += ">\n";
                         for (unsigned int argnr = 0; argnr < function->argCount(); ++argnr) {
                             const Variable *arg = function->getArgumentVar(argnr);
-                            out << "          <arg nr=\"" << argnr+1 << "\" variable=\"" << arg << "\"/>" << std::endl;
+                            outs += "          <arg nr=\"";
+                            outs += std::to_string(argnr+1);
+                            outs += "\" variable=\"";
+                            outs += id_string(arg);
+                            outs += "\"/>\n";
                             variables.insert(arg);
                         }
-                        out << "        </function>" << std::endl;
+                        outs += "        </function>\n";
                     }
                 }
-                out << "      </functionList>" << std::endl;
+                outs += "      </functionList>\n";
             }
             if (!scope->varlist.empty()) {
-                out << "      <varlist>" << std::endl;
-                for (std::list<Variable>::const_iterator var = scope->varlist.begin(); var != scope->varlist.end(); ++var)
-                    out << "        <var id=\""   << &*var << "\"/>" << std::endl;
-                out << "      </varlist>" << std::endl;
+                outs += "      <varlist>\n";
+                for (auto var = scope->varlist.cbegin(); var != scope->varlist.cend(); ++var) {
+                    outs += "        <var id=\"";
+                    outs += id_string(&*var);
+                    outs += "\"/>\n";
+                }
+                outs += "      </varlist>\n";
+            }
+            outs += "    </scope>\n";
+        }
+    }
+    outs += "  </scopes>\n";
+
+    if (!typeList.empty()) {
+        outs += "  <types>\n";
+        for (const Type& type:typeList) {
+            outs += "    <type id=\"";
+            outs += id_string(&type);
+            outs += "\" classScope=\"";
+            outs += id_string(type.classScope);
+            outs += "\"";
+            if (type.derivedFrom.empty()) {
+                outs += "/>\n";
+                continue;
             }
-            out << "    </scope>" << std::endl;
+            outs += ">\n";
+            for (const Type::BaseInfo& baseInfo: type.derivedFrom) {
+                outs += "      <derivedFrom";
+                outs += " access=\"";
+                outs += accessControlToString(baseInfo.access);
+                outs += "\"";
+                outs += " type=\"";
+                outs += id_string(baseInfo.type);
+                outs += "\"";
+                outs += " isVirtual=\"";
+                outs += bool_to_string(baseInfo.isVirtual);
+                outs += "\"";
+                outs += " nameTok=\"";
+                outs += id_string(baseInfo.nameTok);
+                outs += "\"";
+                outs += "/>\n";
+            }
+            outs += "    </type>\n";
         }
+        outs += "  </types>\n";
     }
-    out << "  </scopes>" << std::endl;
 
     // Variables..
     for (const Variable *var : mVariableList)
         variables.insert(var);
-    out << "  <variables>" << std::endl;
+    outs += "  <variables>\n";
     for (const Variable *var : variables) {
         if (!var)
             continue;
-        out << "    <var id=\""   << var << '\"';
-        out << " nameToken=\""      << var->nameToken() << '\"';
-        out << " typeStartToken=\"" << var->typeStartToken() << '\"';
-        out << " typeEndToken=\""   << var->typeEndToken() << '\"';
-        out << " access=\""         << accessControlToString(var->mAccess) << '\"';
-        out << " scope=\""          << var->scope() << '\"';
-        out << " constness=\""      << var->valueType()->constness << '\"';
-        out << " isArgument=\""     << var->isArgument() << '\"';
-        out << " isArray=\""        << var->isArray() << '\"';
-        out << " isClass=\""        << var->isClass() << '\"';
-        out << " isConst=\""        << var->isConst() << '\"';
-        out << " isExtern=\""       << var->isExtern() << '\"';
-        out << " isLocal=\""        << var->isLocal() << '\"';
-        out << " isPointer=\""      << var->isPointer() << '\"';
-        out << " isReference=\""    << var->isReference() << '\"';
-        out << " isStatic=\""       << var->isStatic() << '\"';
-        out << "/>" << std::endl;
-    }
-    out << "  </variables>" << std::endl;
-    out << std::resetiosflags(std::ios::boolalpha);
+        outs += "    <var id=\"";
+        outs += id_string(var);
+        outs += '\"';
+        outs += " nameToken=\"";
+        outs += id_string(var->nameToken());
+        outs += '\"';
+        outs += " typeStartToken=\"";
+        outs += id_string(var->typeStartToken());
+        outs += '\"';
+        outs += " typeEndToken=\"";
+        outs += id_string(var->typeEndToken());
+        outs += '\"';
+        outs += " access=\"";
+        outs += accessControlToString(var->mAccess);
+        outs += '\"';
+        outs += " scope=\"";
+        outs += id_string(var->scope());
+        outs += '\"';
+        if (var->valueType()) {
+            outs += " constness=\"";
+            outs += std::to_string(var->valueType()->constness);
+            outs += '\"';
+
+            outs += " volatileness=\"";
+            outs += std::to_string(var->valueType()->volatileness);
+            outs += '\"';
+        }
+        outs += " isArray=\"";
+        outs += bool_to_string(var->isArray());
+        outs += '\"';
+        outs += " isClass=\"";
+        outs += bool_to_string(var->isClass());
+        outs += '\"';
+        outs += " isConst=\"";
+        outs += bool_to_string(var->isConst());
+        outs += '\"';
+        outs += " isExtern=\"";
+        outs += bool_to_string(var->isExtern());
+        outs += '\"';
+        outs += " isPointer=\"";
+        outs += bool_to_string(var->isPointer());
+        outs += '\"';
+        outs += " isReference=\"";
+        outs += bool_to_string(var->isReference());
+        outs += '\"';
+        outs += " isStatic=\"";
+        outs += bool_to_string(var->isStatic());
+        outs += '\"';
+        outs += " isVolatile=\"";
+        outs += bool_to_string(var->isVolatile());
+        outs += '\"';
+        outs += "/>\n";
+    }
+    outs += "  </variables>\n";
+
+    out << outs;
 }
 
 //---------------------------------------------------------------------------
 
-static const Type* findVariableTypeIncludingUsedNamespaces(const SymbolDatabase* symbolDatabase, const Scope* scope, const Token* typeTok)
+static const Type* findVariableTypeIncludingUsedNamespaces(const Scope* scope, const Token* typeTok)
 {
-    const Type* argType = symbolDatabase->findVariableType(scope, typeTok);
+    const Type* argType = scope->symdb.findVariableType(scope, typeTok);
     if (argType)
         return argType;
 
@@ -3196,7 +4663,7 @@ static const Type* findVariableTypeIncludingUsedNamespaces(const SymbolDatabase*
     while (scope) {
         for (const Scope::UsingInfo &ui : scope->usingList) {
             if (ui.scope) {
-                argType = symbolDatabase->findVariableType(ui.scope, typeTok);
+                argType = scope->symdb.findVariableType(ui.scope, typeTok);
                 if (argType)
                     return argType;
             }
@@ -3208,7 +4675,7 @@ static const Type* findVariableTypeIncludingUsedNamespaces(const SymbolDatabase*
 
 //---------------------------------------------------------------------------
 
-void Function::addArguments(const SymbolDatabase *symbolDatabase, const Scope *scope)
+void Function::addArguments(const Scope *scope)
 {
     // check for non-empty argument list "( ... )"
     const Token * start = arg ? arg : argDef;
@@ -3228,18 +4695,30 @@ void Function::addArguments(const SymbolDatabase *symbolDatabase, const Scope *s
         const Token* nameTok  = nullptr;
 
         do {
+            if (Token::simpleMatch(tok, "decltype (")) {
+                tok = tok->linkAt(1)->next();
+                continue;
+            }
             if (tok != startTok && !nameTok && Token::Match(tok, "( & %var% ) [")) {
                 nameTok = tok->tokAt(2);
                 endTok = nameTok->previous();
                 tok = tok->link();
+            } else if (tok != startTok && !nameTok && Token::Match(tok, "( * const| %var% ) (") && Token::Match(tok->link()->linkAt(1), ") [,)]")) {
+                nameTok = tok->link()->previous();
+                endTok = nameTok->previous();
+                tok = tok->link()->linkAt(1);
+            } else if (tok != startTok && !nameTok && Token::Match(tok, "( * %var% ) [")) {
+                nameTok = tok->tokAt(2);
+                endTok = nameTok->previous();
+                tok = tok->link();
             } else if (tok->varId() != 0) {
                 nameTok = tok;
                 endTok = tok->previous();
             } else if (tok->str() == "[") {
                 // skip array dimension(s)
                 tok = tok->link();
-                while (tok->next()->str() == "[")
-                    tok = tok->next()->link();
+                while (tok->strAt(1) == "[")
+                    tok = tok->linkAt(1);
             } else if (tok->str() == "<") {
                 tok = tok->link();
                 if (!tok) // something is wrong so just bail out
@@ -3257,12 +4736,16 @@ void Function::addArguments(const SymbolDatabase *symbolDatabase, const Scope *s
         while (Token::Match(typeTok, "const|volatile|enum|struct|::"))
             typeTok = typeTok->next();
         if (Token::Match(typeTok, ",|)")) { // #8333
-            symbolDatabase->mTokenizer->syntaxError(typeTok);
-            return;
+            scope->symdb.mTokenizer.syntaxError(typeTok);
         }
+        if (Token::Match(typeTok, "%type% <") && Token::Match(typeTok->linkAt(1), "> :: %type%"))
+            typeTok = typeTok->linkAt(1)->tokAt(2);
         // skip over qualification
-        while (Token::Match(typeTok, "%type% ::"))
+        while (Token::Match(typeTok, "%type% ::")) {
             typeTok = typeTok->tokAt(2);
+            if (Token::Match(typeTok, "%type% <") && Token::Match(typeTok->linkAt(1), "> :: %type%"))
+                typeTok = typeTok->linkAt(1)->tokAt(2);
+        }
 
         // check for argument with no name or missing varid
         if (!endTok) {
@@ -3272,7 +4755,7 @@ void Function::addArguments(const SymbolDatabase *symbolDatabase, const Scope *s
                     endTok = nameTok->previous();
 
                     if (hasBody())
-                        symbolDatabase->debugMessage(nameTok, "Function::addArguments found argument \'" + nameTok->str() + "\' with varid 0.");
+                        scope->symdb.debugMessage(nameTok, "varid0", "Function::addArguments found argument \'" + nameTok->str() + "\' with varid 0.");
                 } else
                     endTok = typeTok;
             } else
@@ -3281,7 +4764,7 @@ void Function::addArguments(const SymbolDatabase *symbolDatabase, const Scope *s
 
         const ::Type *argType = nullptr;
         if (!typeTok->isStandardType()) {
-            argType = findVariableTypeIncludingUsedNamespaces(symbolDatabase, scope, typeTok);
+            argType = findVariableTypeIncludingUsedNamespaces(scope, typeTok);
 
             // save type
             const_cast<Token *>(typeTok)->type(argType);
@@ -3300,11 +4783,14 @@ void Function::addArguments(const SymbolDatabase *symbolDatabase, const Scope *s
         while (Token::Match(startTok, "enum|struct|const|volatile"))
             startTok = startTok->next();
 
-        argumentList.emplace_back(nameTok, startTok, endTok, count++, AccessControl::Argument, argType, functionScope, symbolDatabase->mSettings);
+        if (startTok == nameTok)
+            break;
+
+        argumentList.emplace_back(nameTok, startTok, endTok, count++, AccessControl::Argument, argType, functionScope, scope->symdb.mSettings);
 
         if (tok->str() == ")") {
-            // check for a variadic function
-            if (Token::simpleMatch(startTok, "..."))
+            // check for a variadic function or a variadic template function
+            if (Token::simpleMatch(endTok, "..."))
                 isVariadic(true);
 
             break;
@@ -3313,25 +4799,61 @@ void Function::addArguments(const SymbolDatabase *symbolDatabase, const Scope *s
 
     // count default arguments
     for (const Token* tok = argDef->next(); tok && tok != argDef->link(); tok = tok->next()) {
-        if (tok->str() == "=")
+        if (tok->str() == "=") {
             initArgCount++;
+            if (tok->strAt(1) == "[") {
+                const Token* lambdaStart = tok->next();
+                if (type == FunctionType::eLambda)
+                    tok = findLambdaEndTokenWithoutAST(lambdaStart);
+                else {
+                    tok = findLambdaEndToken(lambdaStart);
+                    if (!tok)
+                        tok = findLambdaEndTokenWithoutAST(lambdaStart);
+                }
+                if (!tok)
+                    throw InternalError(lambdaStart, "Analysis failed (lambda not recognized). If the code is valid then please report this failure.", InternalError::INTERNAL);
+            }
+        }
     }
 }
 
-bool Function::isImplicitlyVirtual(bool defaultVal) const
+bool Function::isImplicitlyVirtual(bool defaultVal, bool* pFoundAllBaseClasses) const
 {
-    if (hasVirtualSpecifier()) //If it has the virtual specifier it's definitely virtual
-        return true;
-    if (hasOverrideSpecifier()) //If it has the override specifier then it's either virtual or not going to compile
+    if (hasVirtualSpecifier() || hasOverrideSpecifier() || hasFinalSpecifier())
         return true;
     bool foundAllBaseClasses = true;
     if (getOverriddenFunction(&foundAllBaseClasses)) //If it overrides a base class's method then it's virtual
         return true;
+    if (pFoundAllBaseClasses)
+        *pFoundAllBaseClasses = foundAllBaseClasses;
     if (foundAllBaseClasses) //If we've seen all the base classes and none of the above were true then it must not be virtual
         return false;
     return defaultVal; //If we can't see all the bases classes then we can't say conclusively
 }
 
+std::vector<const Function*> Function::getOverloadedFunctions() const
+{
+    std::vector<const Function*> result;
+    const Scope* scope = nestedIn;
+
+    while (scope) {
+        const bool isMemberFunction = scope->isClassOrStruct() && !isStatic();
+        for (auto it = scope->functionMap.find(tokenDef->str());
+             it != scope->functionMap.end() && it->first == tokenDef->str();
+             ++it) {
+            const Function* func = it->second;
+            if (isMemberFunction && isMemberFunction == func->isStatic())
+                continue;
+            result.push_back(func);
+        }
+        if (isMemberFunction)
+            break;
+        scope = scope->nestedIn;
+    }
+
+    return result;
+}
+
 const Function *Function::getOverriddenFunction(bool *foundAllBaseClasses) const
 {
     if (foundAllBaseClasses)
@@ -3341,6 +4863,17 @@ const Function *Function::getOverriddenFunction(bool *foundAllBaseClasses) const
     return getOverriddenFunctionRecursive(nestedIn->definedType, foundAllBaseClasses);
 }
 
+// prevent recursion if base is the same except for different template parameters
+static bool isDerivedFromItself(const std::string& thisName, const std::string& baseName)
+{
+    if (thisName.back() != '>')
+        return false;
+    const auto pos = thisName.find('<');
+    if (pos == std::string::npos)
+        return false;
+    return thisName.compare(0, pos + 1, baseName, 0, pos + 1) == 0;
+}
+
 const Function * Function::getOverriddenFunctionRecursive(const ::Type* baseType, bool *foundAllBaseClasses) const
 {
     // check each base class
@@ -3356,18 +4889,18 @@ const Function * Function::getOverriddenFunctionRecursive(const ::Type* baseType
         const Scope *parent = derivedFromType->classScope;
 
         // check if function defined in base class
-        for (std::multimap<std::string, const Function *>::const_iterator it = parent->functionMap.find(tokenDef->str()); it != parent->functionMap.end() && it->first == tokenDef->str(); ++it) {
+        auto range = parent->functionMap.equal_range(tokenDef->str());
+        for (auto it = range.first; it != range.second; ++it) {
             const Function * func = it->second;
-            if (func->hasVirtualSpecifier()) { // Base is virtual and of same name
+            if (func->isImplicitlyVirtual()) { // Base is virtual and of same name
                 const Token *temp1 = func->tokenDef->previous();
                 const Token *temp2 = tokenDef->previous();
                 bool match = true;
 
                 // check for matching return parameters
-                while (temp1->str() != "virtual") {
+                while (!Token::Match(temp1, "virtual|public:|private:|protected:|{|}|;")) {
                     if (temp1->str() != temp2->str() &&
-                        !(temp1->str() == derivedFromType->name() &&
-                          temp2->str() == baseType->name())) {
+                        !(temp1->type() && temp2->type() && temp2->type()->isDerivedFrom(temp1->type()->name()))) {
                         match = false;
                         break;
                     }
@@ -3377,7 +4910,7 @@ const Function * Function::getOverriddenFunctionRecursive(const ::Type* baseType
                 }
 
                 // check for matching function parameters
-                match = match && argsMatch(baseType->classScope, func->argDef, argDef, emptyString, 0);
+                match = match && argsMatch(baseType->classScope, func->argDef, argDef, "", 0);
 
                 // check for matching cv-ref qualifiers
                 match = match
@@ -3393,11 +4926,19 @@ const Function * Function::getOverriddenFunctionRecursive(const ::Type* baseType
             }
         }
 
-        if (!derivedFromType->derivedFrom.empty() && !derivedFromType->hasCircularDependencies()) {
+        if (isDestructor()) {
+            auto it = std::find_if(parent->functionList.begin(), parent->functionList.end(), [](const Function& f) {
+                return f.isDestructor() && f.isImplicitlyVirtual();
+            });
+            if (it != parent->functionList.end())
+                return &*it;
+        }
+
+        if (!derivedFromType->derivedFrom.empty() && !derivedFromType->hasCircularDependencies() && !isDerivedFromItself(baseType->classScope->className, i.name)) {
             // avoid endless recursion, see #5289 Crash: Stack overflow in isImplicitlyVirtual_rec when checking SVN and
             // #5590 with a loop within the class hierarchy.
             const Function *func = getOverriddenFunctionRecursive(derivedFromType, foundAllBaseClasses);
-            if (func)  {
+            if (func) {
                 return func;
             }
         }
@@ -3407,11 +4948,10 @@ const Function * Function::getOverriddenFunctionRecursive(const ::Type* baseType
 
 const Variable* Function::getArgumentVar(nonneg int num) const
 {
-    for (std::list<Variable>::const_iterator i = argumentList.begin(); i != argumentList.end(); ++i) {
-        if (i->index() == num)
-            return (&*i);
-        else if (i->index() > num)
-            return nullptr;
+    if (num < argumentList.size()) {
+        auto it = argumentList.begin();
+        std::advance(it, num);
+        return &*it;
     }
     return nullptr;
 }
@@ -3419,131 +4959,118 @@ const Variable* Function::getArgumentVar(nonneg int num) const
 
 //---------------------------------------------------------------------------
 
-Scope::Scope(const SymbolDatabase *check_, const Token *classDef_, const Scope *nestedIn_, ScopeType type_, const Token *start_) :
-    check(check_),
+Scope::Scope(const SymbolDatabase &symdb_, const Token *classDef_, const Scope *nestedIn_, ScopeType type_, const Token *start_) :
+    symdb(symdb_),
     classDef(classDef_),
-    bodyStart(start_),
-    bodyEnd(start_->link()),
     nestedIn(nestedIn_),
-    numConstructors(0),
-    numCopyOrMoveConstructors(0),
-    type(type_),
-    definedType(nullptr),
-    functionOf(nullptr),
-    function(nullptr),
-    enumType(nullptr),
-    enumClass(false)
+    type(type_)
 {
+    setBodyStartEnd(start_);
 }
 
-Scope::Scope(const SymbolDatabase *check_, const Token *classDef_, const Scope *nestedIn_) :
-    check(check_),
+Scope::Scope(const SymbolDatabase &symdb_, const Token *classDef_, const Scope *nestedIn_) :
+    symdb(symdb_),
     classDef(classDef_),
-    bodyStart(nullptr),
-    bodyEnd(nullptr),
-    nestedIn(nestedIn_),
-    numConstructors(0),
-    numCopyOrMoveConstructors(0),
-    definedType(nullptr),
-    functionOf(nullptr),
-    function(nullptr),
-    enumType(nullptr),
-    enumClass(false)
+    nestedIn(nestedIn_)
 {
     const Token *nameTok = classDef;
     if (!classDef) {
-        type = Scope::eGlobal;
-    } else if (classDef->str() == "class" && check && check->isCPP()) {
-        type = Scope::eClass;
+        type = ScopeType::eGlobal;
+    } else if (classDef->str() == "class" && classDef->isCpp()) {
+        type = ScopeType::eClass;
         nameTok = nameTok->next();
     } else if (classDef->str() == "struct") {
-        type = Scope::eStruct;
+        type = ScopeType::eStruct;
         nameTok = nameTok->next();
     } else if (classDef->str() == "union") {
-        type = Scope::eUnion;
+        type = ScopeType::eUnion;
         nameTok = nameTok->next();
     } else if (classDef->str() == "namespace") {
-        type = Scope::eNamespace;
+        type = ScopeType::eNamespace;
         nameTok = nameTok->next();
     } else if (classDef->str() == "enum") {
-        type = Scope::eEnum;
+        type = ScopeType::eEnum;
         nameTok = nameTok->next();
         if (nameTok->str() == "class") {
             enumClass = true;
             nameTok = nameTok->next();
         }
     } else if (classDef->str() == "[") {
-        type = Scope::eLambda;
+        type = ScopeType::eLambda;
     } else {
-        type = Scope::eFunction;
+        type = ScopeType::eFunction;
     }
     // skip over qualification if present
     nameTok = skipScopeIdentifiers(nameTok);
-    if (nameTok && ((type == Scope::eEnum && Token::Match(nameTok, ":|{")) || nameTok->str() != "{")) // anonymous and unnamed structs/unions don't have a name
+    if (nameTok && ((type == ScopeType::eEnum && Token::Match(nameTok, ":|{")) || nameTok->str() != "{")) // anonymous and unnamed structs/unions don't have a name
         className = nameTok->str();
 }
 
-bool Scope::hasDefaultConstructor() const
-{
-    if (numConstructors) {
-        std::list<Function>::const_iterator func;
-
-        for (func = functionList.begin(); func != functionList.end(); ++func) {
-            if (func->type == Function::eConstructor && func->argCount() == 0)
-                return true;
-        }
-    }
-    return false;
-}
-
 AccessControl Scope::defaultAccess() const
 {
     switch (type) {
-    case eGlobal:
+    case ScopeType::eGlobal:
         return AccessControl::Global;
-    case eClass:
+    case ScopeType::eClass:
         return AccessControl::Private;
-    case eStruct:
+    case ScopeType::eStruct:
         return AccessControl::Public;
-    case eUnion:
+    case ScopeType::eUnion:
         return AccessControl::Public;
-    case eNamespace:
+    case ScopeType::eNamespace:
         return AccessControl::Namespace;
     default:
         return AccessControl::Local;
     }
 }
 
-// Get variable list..
-void Scope::getVariableList(const Settings* settings)
+void Scope::addVariable(const Token *token_, const Token *start_, const Token *end_,
+                        AccessControl access_, const Type *type_, const Scope *scope_)
 {
-    const Token *start;
+    // keep possible size_t -> int truncation outside emplace_back() to have a single line
+    // C4267 VC++ warning instead of several dozens lines
+    const int varIndex = varlist.size();
+    varlist.emplace_back(token_, start_, end_, varIndex, access_, type_, scope_, scope_->symdb.mSettings);
+}
 
-    if (bodyStart)
-        start = bodyStart->next();
+// Get variable list..
+void Scope::getVariableList()
+{
+    if (!bodyStartList.empty()) {
+        for (const Token *bs: bodyStartList)
+            getVariableList(bs->next(), bs->link());
+    }
 
     // global scope
-    else if (className.empty())
-        start = check->mTokenizer->tokens();
+    else if (type == ScopeType::eGlobal)
+        getVariableList(symdb.mTokenizer.tokens(), nullptr);
 
     // forward declaration
     else
         return;
+}
+
+void Scope::getVariableList(const Token* start, const Token* end)
+{
+    // Variable declared in condition: if (auto x = bar())
+    if (Token::Match(classDef, "if|while ( %type%") && Token::simpleMatch(classDef->next()->astOperand2(), "=")) {
+        checkVariable(classDef->tokAt(2), defaultAccess());
+    }
 
     AccessControl varaccess = defaultAccess();
-    for (const Token *tok = start; tok && tok != bodyEnd; tok = tok->next()) {
+    for (const Token *tok = start; tok && tok != end; tok = tok->next()) {
         // syntax error?
         if (tok->next() == nullptr)
             break;
 
         // Is it a function?
-        else if (tok->str() == "{") {
+        if (tok->str() == "{") {
             tok = tok->link();
             continue;
         }
 
         // Is it a nested class or structure?
-        else if (Token::Match(tok, "class|struct|union|namespace %type% :|{")) {
+        if (tok->isKeyword() && Token::Match(tok, "class|struct|union|namespace %type% :|{")) {
             tok = tok->tokAt(2);
             while (tok && tok->str() != "{")
                 tok = tok->next();
@@ -3551,13 +5078,15 @@ void Scope::getVariableList(const Settings* settings)
                 // skip implementation
                 tok = tok->link();
                 continue;
-            } else
-                break;
-        } else if (Token::Match(tok, "struct|union {")) {
-            if (Token::Match(tok->next()->link(), "} %name% ;|[")) {
-                tok = tok->next()->link()->tokAt(2);
+            }
+            break;
+        }
+        if (tok->isKeyword() && Token::Match(tok, "struct|union {")) {
+            if (Token::Match(tok->linkAt(1), "} %name% ;|[")) {
+                tok = tok->linkAt(1)->tokAt(2);
                 continue;
-            } else if (Token::simpleMatch(tok->next()->link(), "} ;")) {
+            }
+            if (Token::simpleMatch(tok->linkAt(1), "} ;")) {
                 tok = tok->next();
                 continue;
             }
@@ -3574,8 +5103,7 @@ void Scope::getVariableList(const Settings* settings)
             }
             if (tok)
                 continue;
-            else
-                break;
+            break;
         }
 
         // "private:" "public:" "protected:" etc
@@ -3591,7 +5119,7 @@ void Scope::getVariableList(const Settings* settings)
         }
 
         // Is it a forward declaration?
-        else if (Token::Match(tok, "class|struct|union %name% ;")) {
+        else if (tok->isKeyword() && Token::Match(tok, "class|struct|union %name% ;")) {
             tok = tok->tokAt(2);
             continue;
         }
@@ -3601,50 +5129,50 @@ void Scope::getVariableList(const Settings* settings)
             continue;
 
         // skip return, goto and delete
-        else if (Token::Match(tok, "return|delete|goto")) {
+        else if (tok->isKeyword() && Token::Match(tok, "return|delete|goto")) {
             while (tok->next() &&
-                   tok->next()->str() != ";" &&
-                   tok->next()->str() != "}" /* ticket #4994 */) {
+                   tok->strAt(1) != ";" &&
+                   tok->strAt(1) != "}" /* ticket #4994 */) {
                 tok = tok->next();
             }
             continue;
         }
 
         // skip case/default
-        if (Token::Match(tok, "case|default")) {
+        if (tok->isKeyword() && Token::Match(tok, "case|default")) {
             while (tok->next() && !Token::Match(tok->next(), "[:;{}]"))
                 tok = tok->next();
             continue;
         }
 
         // Search for start of statement..
-        else if (tok->previous() && !Token::Match(tok->previous(), ";|{|}|public:|protected:|private:"))
+        if (tok->previous() && !Token::Match(tok->previous(), ";|{|}|public:|protected:|private:"))
             continue;
-        else if (tok->str() == ";")
+        if (tok->str() == ";")
             continue;
 
-        tok = checkVariable(tok, varaccess, settings);
+        tok = checkVariable(tok, varaccess);
 
         if (!tok)
             break;
     }
 }
 
-const Token *Scope::checkVariable(const Token *tok, AccessControl varaccess, const Settings* settings)
+const Token *Scope::checkVariable(const Token *tok, AccessControl varaccess)
 {
     // Is it a throw..?
-    if (Token::Match(tok, "throw %any% (") &&
+    if (tok->isKeyword() && Token::Match(tok, "throw %any% (") &&
         Token::simpleMatch(tok->linkAt(2), ") ;")) {
         return tok->linkAt(2);
     }
 
-    if ((Token::Match(tok, "throw %any% :: %any% (") &&
-         Token::simpleMatch(tok->linkAt(4), ") ;"))) {
+    if (tok->isKeyword() && Token::Match(tok, "throw %any% :: %any% (") &&
+        Token::simpleMatch(tok->linkAt(4), ") ;")) {
         return tok->linkAt(4);
     }
 
     // friend?
-    if (Token::Match(tok, "friend %type%") && tok->next()->varId() == 0) {
+    if (tok->isKeyword() && Token::Match(tok, "friend %type%") && tok->next()->varId() == 0) {
         const Token *next = Token::findmatch(tok->tokAt(2), ";|{");
         if (next && next->str() == "{")
             next = next->link();
@@ -3652,14 +5180,24 @@ const Token *Scope::checkVariable(const Token *tok, AccessControl varaccess, con
     }
 
     // skip const|volatile|static|mutable|extern
-    while (Token::Match(tok, "const|volatile|static|mutable|extern")) {
+    while (tok && tok->isKeyword() && Token::Match(tok, "const|constexpr|volatile|static|mutable|extern")) {
         tok = tok->next();
     }
 
     // the start of the type tokens does not include the above modifiers
     const Token *typestart = tok;
 
-    if (Token::Match(tok, "class|struct|union|enum")) {
+    // C++17 structured bindings
+    if (tok && tok->isCpp() && (symdb.mSettings.standards.cpp >= Standards::CPP17) && Token::Match(tok, "auto &|&&| [")) {
+        const Token *typeend = Token::findsimplematch(typestart, "[")->previous();
+        for (tok = typeend->tokAt(2); Token::Match(tok, "%name%|,"); tok = tok->next()) {
+            if (tok->varId())
+                addVariable(tok, typestart, typeend, varaccess, nullptr, this);
+        }
+        return typeend->linkAt(1);
+    }
+
+    while (tok && tok->isKeyword() && Token::Match(tok, "class|struct|union|enum")) {
         tok = tok->next();
     }
 
@@ -3668,6 +5206,7 @@ const Token *Scope::checkVariable(const Token *tok, AccessControl varaccess, con
     const Token *typetok = nullptr;
 
     if (tok && isVariableDeclaration(tok, vartok, typetok)) {
+        const Token* const orig = tok;
         // If the vartok was set in the if-blocks above, create a entry for this variable..
         tok = vartok->next();
         while (Token::Match(tok, "[|{"))
@@ -3675,14 +5214,14 @@ const Token *Scope::checkVariable(const Token *tok, AccessControl varaccess, con
 
         if (vartok->varId() == 0) {
             if (!vartok->isBoolean())
-                check->debugMessage(vartok, "Scope::checkVariable found variable \'" + vartok->str() + "\' with varid 0.");
+                symdb.debugMessage(vartok, "varid0", "Scope::checkVariable found variable \'" + vartok->str() + "\' with varid 0.");
             return tok;
         }
 
         const Type *vType = nullptr;
 
         if (typetok) {
-            vType = findVariableTypeIncludingUsedNamespaces(check, this, typetok);
+            vType = findVariableTypeIncludingUsedNamespaces(this, typetok);
 
             const_cast<Token *>(typetok)->type(vType);
         }
@@ -3691,7 +5230,23 @@ const Token *Scope::checkVariable(const Token *tok, AccessControl varaccess, con
         if (Token::Match(typestart, "enum|struct"))
             typestart = typestart->next();
 
-        addVariable(vartok, typestart, vartok->previous(), varaccess, vType, this, settings);
+        addVariable(vartok, typestart, vartok->previous(), varaccess, vType, this);
+
+        if (type == ScopeType::eFor && orig->strAt(-2) == "for") {
+            for (const Token* tok2 = tok; tok2 && !Token::Match(tok2, "[;:]"); tok2 = tok2->next()) {
+                if (tok2->link() && precedes(tok2, tok2->link())) {
+                    tok2 = tok2->link();
+                    continue;
+                }
+                if (Token::Match(tok2, ", %name%")) {
+                    if (tok2->next()->varId() == 0) {
+                        symdb.debugMessage(tok2->next(), "varid0", "Scope::checkVariable found variable \'" + tok2->strAt(1) + "\' with varid 0.");
+                        return tok;
+                    }
+                    addVariable(tok2->next(), typestart, vartok->previous(), varaccess, vType, this);
+                }
+            }
+        }
     }
 
     return tok;
@@ -3699,31 +5254,65 @@ const Token *Scope::checkVariable(const Token *tok, AccessControl varaccess, con
 
 const Variable *Scope::getVariable(const std::string &varname) const
 {
-    std::list<Variable>::const_iterator iter;
+    auto it = std::find_if(varlist.begin(), varlist.end(), [&varname](const Variable& var) {
+        return var.name() == varname;
+    });
+    if (it != varlist.end())
+        return &*it;
 
-    for (iter = varlist.begin(); iter != varlist.end(); ++iter) {
-        if (iter->name() == varname)
-            return &*iter;
+    if (definedType) {
+        for (const Type::BaseInfo& baseInfo: definedType->derivedFrom) {
+            if (baseInfo.type && baseInfo.type->classScope) {
+                if (const Variable* var = baseInfo.type->classScope->getVariable(varname))
+                    return var;
+            }
+        }
     }
-
     return nullptr;
 }
 
 static const Token* skipPointers(const Token* tok)
 {
-    while (Token::Match(tok, "*|&|&&")  || (Token::Match(tok, "( [*&]") && Token::Match(tok->link()->next(), "(|["))) {
+    const Token *start = tok;
+    bool memberPointer = false;
+    while (tok) {
+        if (Token::simpleMatch(tok, "::")) {
+            tok = tok->next();
+            continue;
+        }
+        if (Token::Match(tok, "%type% ::")) {
+            tok = tok->tokAt(2);
+            memberPointer = true;
+            continue;
+        }
+        if (Token::Match(tok, "%type% <") && tok->linkAt(1)) {
+            tok = tok->linkAt(1)->next();
+            continue;
+        }
+        break;
+    }
+    if (memberPointer && !Token::simpleMatch(tok, "*"))
+        return start;
+    while (Token::Match(tok, "*|&|&&") || (Token::Match(tok, "( [*&]") && Token::Match(tok->link()->next(), "(|["))) {
         tok = tok->next();
-        if (tok->strAt(-1) == "(" && Token::Match(tok, "%type% ::"))
+        if (tok && tok->strAt(-1) == "(" && Token::Match(tok, "%type% ::"))
             tok = tok->tokAt(2);
     }
 
+    if (Token::simpleMatch(tok, "( *") && Token::simpleMatch(tok->link()->previous(), "] ) ;") &&
+        (tok->tokAt(-1)->isStandardType() || tok->tokAt(-1)->isKeyword() || tok->strAt(-1) == "*")) {
+        const Token *tok2 = skipPointers(tok->next());
+        if (Token::Match(tok2, "%name% [") && Token::simpleMatch(tok2->linkAt(1), "] ) ;"))
+            return tok2;
+    }
+
     return tok;
 }
 
 static const Token* skipPointersAndQualifiers(const Token* tok)
 {
     tok = skipPointers(tok);
-    while (Token::Match(tok, "const|volatile")) {
+    while (Token::Match(tok, "const|static|volatile")) {
         tok = tok->next();
         tok = skipPointers(tok);
     }
@@ -3733,12 +5322,15 @@ static const Token* skipPointersAndQualifiers(const Token* tok)
 
 bool Scope::isVariableDeclaration(const Token* const tok, const Token*& vartok, const Token*& typetok) const
 {
-    const bool isCPP = check && check->mTokenizer->isCPP();
+    if (!tok)
+        return false;
+
+    const bool isCPP = tok->isCpp();
 
     if (isCPP && Token::Match(tok, "throw|new"))
         return false;
 
-    const bool isCPP11 = isCPP && check->mSettings->standards.cpp >= Standards::CPP11;
+    const bool isCPP11 = isCPP && symdb.mSettings.standards.cpp >= Standards::CPP11;
 
     if (isCPP11 && tok->str() == "using")
         return false;
@@ -3746,11 +5338,14 @@ bool Scope::isVariableDeclaration(const Token* const tok, const Token*& vartok,
     const Token* localTypeTok = skipScopeIdentifiers(tok);
     const Token* localVarTok = nullptr;
 
+    while (Token::simpleMatch(localTypeTok, "alignas (") && Token::Match(localTypeTok->linkAt(1), ") %name%"))
+        localTypeTok = localTypeTok->linkAt(1)->next();
+
     if (Token::Match(localTypeTok, "%type% <")) {
         if (Token::Match(tok, "const_cast|dynamic_cast|reinterpret_cast|static_cast <"))
             return false;
 
-        const Token* closeTok = localTypeTok->next()->link();
+        const Token* closeTok = localTypeTok->linkAt(1);
         if (closeTok) {
             localVarTok = skipPointers(closeTok->next());
 
@@ -3763,13 +5358,22 @@ bool Scope::isVariableDeclaration(const Token* const tok, const Token*& vartok,
             }
         }
     } else if (Token::Match(localTypeTok, "%type%")) {
-        localVarTok = skipPointersAndQualifiers(localTypeTok->next());
+
+        if (isCPP11 && Token::simpleMatch(localTypeTok, "decltype (") && Token::Match(localTypeTok->linkAt(1), ") %name%|*|&|&&"))
+            localVarTok = skipPointersAndQualifiers(localTypeTok->linkAt(1)->next());
+        else {
+            localVarTok = skipPointersAndQualifiers(localTypeTok->next());
+            if (isCPP11 && Token::simpleMatch(localVarTok, "decltype (") && Token::Match(localVarTok->linkAt(1), ") %name%|*|&|&&"))
+                localVarTok = skipPointersAndQualifiers(localVarTok->linkAt(1)->next());
+        }
     }
 
     if (!localVarTok)
         return false;
 
-    if (localVarTok->str() == "const")
+    if (Token::simpleMatch(localVarTok, "( *") && Token::Match(localTypeTok->previous(), "class|struct|union|enum")) // not a function call
+        localVarTok = localVarTok->next();
+    while (Token::Match(localVarTok, "const|*|&"))
         localVarTok = localVarTok->next();
 
     if (Token::Match(localVarTok, "%name% ;|=") || (localVarTok && localVarTok->varId() && localVarTok->strAt(1) == ":")) {
@@ -3779,10 +5383,10 @@ bool Scope::isVariableDeclaration(const Token* const tok, const Token*& vartok,
         vartok = localVarTok;
         typetok = localTypeTok;
     } else if (localVarTok && localVarTok->varId() && Token::Match(localVarTok, "%name% (|{") &&
-               Token::Match(localVarTok->next()->link(), ")|} ;")) {
+               Token::Match(localVarTok->linkAt(1), ")|} ;")) {
         vartok = localVarTok;
         typetok = localTypeTok;
-    } else if (type == eCatch &&
+    } else if (type == ScopeType::eCatch &&
                Token::Match(localVarTok, "%name% )")) {
         vartok = localVarTok;
         typetok = localTypeTok;
@@ -3791,12 +5395,12 @@ bool Scope::isVariableDeclaration(const Token* const tok, const Token*& vartok,
     return nullptr != vartok;
 }
 
-const Token * Scope::addEnum(const Token * tok, bool isCpp)
+const Token * Scope::addEnum(const Token * tok)
 {
     const Token * tok2 = tok->next();
 
     // skip over class if present
-    if (isCpp && tok2->str() == "class")
+    if (tok2->isCpp() && tok2->str() == "class")
         tok2 = tok2->next();
 
     // skip over name
@@ -3807,7 +5411,8 @@ const Token * Scope::addEnum(const Token * tok, bool isCpp)
         tok2 = tok2->next();
 
         enumType = tok2;
-        tok2 = tok2->next();
+        while (Token::Match(tok2, "%name%|::"))
+            tok2 = tok2->next();
     }
 
     // add enumerators
@@ -3857,7 +5462,7 @@ const Token * Scope::addEnum(const Token * tok, bool isCpp)
         if (tok2 == end) {
             tok2 = tok2->next();
 
-            if (tok2 && tok2->str() != ";")
+            if (tok2 && tok2->str() != ";" && (tok2->isCpp() || tok2->str() != ")"))
                 tok2 = nullptr;
         } else
             tok2 = nullptr;
@@ -3867,15 +5472,44 @@ const Token * Scope::addEnum(const Token * tok, bool isCpp)
     return tok2;
 }
 
-const Enumerator * SymbolDatabase::findEnumerator(const Token * tok) const
+static const Scope* findEnumScopeInBase(const Scope* scope, const std::string& tokStr)
 {
-    const Scope * scope = tok->scope();
+    if (scope->definedType) {
+        const std::vector<Type::BaseInfo>& derivedFrom = scope->definedType->derivedFrom;
+        for (const Type::BaseInfo& i : derivedFrom) {
+            const Type *derivedFromType = i.type;
+            if (derivedFromType && derivedFromType->classScope) {
+                if (const Scope* enumScope = derivedFromType->classScope->findRecordInNestedList(tokStr))
+                    return enumScope;
+            }
+        }
+    }
+    return nullptr;
+}
 
-    const std::string &tokStr = tok->str();
+static const Enumerator* findEnumeratorInUsingList(const Scope* scope, const std::string& name)
+{
+    for (const auto& u : scope->usingList) {
+        if (!u.scope)
+            continue;
+        for (const Scope* nested : u.scope->nestedList) {
+            if (nested->type != ScopeType::eEnum)
+                continue;
+            const Enumerator* e = nested->findEnumerator(name);
+            if (e && !(e->scope && e->scope->enumClass))
+                return e;
+        }
+    }
+    return nullptr;
+}
 
-    if (mTokensThatAreNotEnumeratorValues.find(tokStr) != mTokensThatAreNotEnumeratorValues.end()) {
+const Enumerator * SymbolDatabase::findEnumerator(const Token * tok, std::set<std::string>& tokensThatAreNotEnumeratorValues) const
+{
+    if (tok->isKeyword())
         return nullptr;
-    }
+
+    const std::string& tokStr = tok->str();
+    const Scope* scope = tok->scope();
 
     // check for qualified name
     if (tok->strAt(-1) == "::") {
@@ -3887,11 +5521,23 @@ const Enumerator * SymbolDatabase::findEnumerator(const Token * tok) const
         if (tok1->strAt(-1) == "::")
             scope = &scopeList.front();
         else {
-            // FIXME search base class here
-
+            const Scope* temp = nullptr;
+            if (scope)
+                temp = scope->findRecordInNestedList(tok1->str());
             // find first scope
             while (scope && scope->nestedIn) {
-                const Scope * temp = scope->nestedIn->findRecordInNestedList(tok1->str());
+                if (!temp)
+                    temp = scope->nestedIn->findRecordInNestedList(tok1->str());
+                if (!temp && scope->functionOf) {
+                    temp = scope->functionOf->findRecordInNestedList(tok1->str());
+                    const Scope* nested = scope->functionOf->nestedIn;
+                    while (!temp && nested) {
+                        temp = nested->findRecordInNestedList(tok1->str());
+                        nested = nested->nestedIn;
+                    }
+                }
+                if (!temp)
+                    temp = findEnumScopeInBase(scope, tok1->str());
                 if (temp) {
                     scope = temp;
                     break;
@@ -3913,26 +5559,49 @@ const Enumerator * SymbolDatabase::findEnumerator(const Token * tok) const
                 if (enumerator) // enum class
                     return enumerator;
                 // enum
-                else {
-                    for (std::list<Scope *>::const_iterator it = scope->nestedList.begin(), end = scope->nestedList.end(); it != end; ++it) {
-                        enumerator = (*it)->findEnumerator(tokStr);
+                for (auto it = scope->nestedList.cbegin(), end = scope->nestedList.cend(); it != end; ++it) {
+                    enumerator = (*it)->findEnumerator(tokStr);
 
-                        if (enumerator)
-                            return enumerator;
-                    }
+                    if (enumerator && !(enumerator->scope && enumerator->scope->enumClass))
+                        return enumerator;
                 }
             }
         }
-    } else {
+    } else { // unqualified name
+
+        if (tokensThatAreNotEnumeratorValues.find(tokStr) != tokensThatAreNotEnumeratorValues.end())
+            return nullptr;
+
+        if (tok->scope()->type == ScopeType::eGlobal) {
+            const Token* astTop = tok->astTop();
+            if (Token::simpleMatch(astTop, ":") && Token::simpleMatch(astTop->astOperand1(), "(")) { // ctor init list
+                const Token* ctor = astTop->astOperand1()->previous();
+                if (ctor && ctor->function() && ctor->function()->nestedIn)
+                    scope = ctor->function()->nestedIn;
+            }
+        }
         const Enumerator * enumerator = scope->findEnumerator(tokStr);
+        if (!enumerator)
+            enumerator = findEnumeratorInUsingList(scope, tokStr);
 
-        if (enumerator)
+        if (enumerator && !(enumerator->scope && enumerator->scope->enumClass))
             return enumerator;
 
-        for (std::list<Scope *>::const_iterator s = scope->nestedList.begin(); s != scope->nestedList.end(); ++s) {
+        if (Token::simpleMatch(tok->astParent(), ".")) {
+            const Token* varTok = tok->astParent()->astOperand1();
+            if (varTok && varTok->variable() && varTok->variable()->type() && varTok->variable()->type()->classScope)
+                scope = varTok->variable()->type()->classScope;
+        }
+        else if (Token::simpleMatch(tok->astParent(), "[")) {
+            const Token* varTok = tok->astParent()->previous();
+            if (varTok && varTok->variable() && varTok->variable()->scope() && Token::simpleMatch(tok->astParent()->astOperand1(), "::"))
+                scope = varTok->variable()->scope();
+        }
+
+        for (auto s = scope->nestedList.cbegin(); s != scope->nestedList.cend(); ++s) {
             enumerator = (*s)->findEnumerator(tokStr);
 
-            if (enumerator)
+            if (enumerator && !(enumerator->scope && enumerator->scope->enumClass))
                 return enumerator;
         }
 
@@ -3940,49 +5609,64 @@ const Enumerator * SymbolDatabase::findEnumerator(const Token * tok) const
             const std::vector<Type::BaseInfo> & derivedFrom = scope->definedType->derivedFrom;
             for (const Type::BaseInfo & i : derivedFrom) {
                 const Type *derivedFromType = i.type;
-                if (derivedFromType && derivedFromType ->classScope) {
+                if (derivedFromType && derivedFromType->classScope) {
                     enumerator = derivedFromType->classScope->findEnumerator(tokStr);
 
-                    if (enumerator)
+                    if (enumerator && !(enumerator->scope && enumerator->scope->enumClass))
                         return enumerator;
                 }
             }
         }
 
         while (scope->nestedIn) {
-            if (scope->type == Scope::eFunction && scope->functionOf)
+            if (scope->type == ScopeType::eFunction && scope->functionOf)
                 scope = scope->functionOf;
             else
                 scope = scope->nestedIn;
 
             enumerator = scope->findEnumerator(tokStr);
+            if (!enumerator)
+                enumerator = findEnumeratorInUsingList(scope, tokStr);
 
-            if (enumerator)
+            if (enumerator && !(enumerator->scope && enumerator->scope->enumClass))
                 return enumerator;
 
-            for (std::list<Scope*>::const_iterator s = scope->nestedList.begin(); s != scope->nestedList.end(); ++s) {
+            for (auto s = scope->nestedList.cbegin(); s != scope->nestedList.cend(); ++s) {
                 enumerator = (*s)->findEnumerator(tokStr);
 
-                if (enumerator)
+                if (enumerator && !(enumerator->scope && enumerator->scope->enumClass))
                     return enumerator;
+
+                if (tok->isCpp() && (*s)->type == ScopeType::eNamespace && Token::simpleMatch((*s)->classDef, "namespace {")) {
+                    for (const Scope* nested : (*s)->nestedList) {
+                        if (nested->type != ScopeType::eEnum)
+                            continue;
+                        enumerator = nested->findEnumerator(tokStr);
+
+                        if (enumerator && !(enumerator->scope && enumerator->scope->enumClass))
+                            return enumerator;
+                    }
+                }
             }
         }
     }
 
-    mTokensThatAreNotEnumeratorValues.insert(tokStr);
+    tokensThatAreNotEnumeratorValues.insert(tokStr);
 
     return nullptr;
 }
 
 //---------------------------------------------------------------------------
 
-const Type* SymbolDatabase::findVariableTypeInBase(const Scope* scope, const Token* typeTok) const
+const Type* SymbolDatabase::findVariableTypeInBase(const Scope* scope, const Token* typeTok)
 {
     if (scope && scope->definedType && !scope->definedType->derivedFrom.empty()) {
         const std::vector<Type::BaseInfo> &derivedFrom = scope->definedType->derivedFrom;
         for (const Type::BaseInfo & i : derivedFrom) {
             const Type *base = i.type;
             if (base && base->classScope) {
+                if (base->classScope == scope)
+                    return nullptr;
                 const Type * type = base->classScope->findType(typeTok->str());
                 if (type)
                     return type;
@@ -4024,7 +5708,7 @@ const Type* SymbolDatabase::findVariableType(const Scope *start, const Token *ty
             }
 
             // check if in member function class to see if it's present in class
-            if (scope->type == Scope::eFunction && scope->functionOf) {
+            if (scope->type == ScopeType::eFunction && scope->functionOf) {
                 const Scope *scope1 = scope->functionOf;
 
                 type = scope1->findType(typeTok->str());
@@ -4051,7 +5735,7 @@ const Type* SymbolDatabase::findVariableType(const Scope *start, const Token *ty
         // find start of qualified function name
         const Token *tok1 = typeTok;
 
-        while (Token::Match(tok1->tokAt(-2), "%type% ::") ||
+        while ((Token::Match(tok1->tokAt(-2), "%type% ::") && !tok1->tokAt(-2)->isKeyword()) ||
                (Token::simpleMatch(tok1->tokAt(-2), "> ::") && tok1->linkAt(-2) && Token::Match(tok1->linkAt(-2)->tokAt(-1), "%type%"))) {
             if (tok1->strAt(-1) == "::")
                 tok1 = tok1->tokAt(-2);
@@ -4071,17 +5755,17 @@ const Type* SymbolDatabase::findVariableType(const Scope *start, const Token *ty
             while (scope) {
                 if (scope->className == tok1->str())
                     break;
-                else {
-                    const Scope *scope1 = scope->findRecordInNestedList(tok1->str());
 
-                    if (scope1) {
-                        scope = scope1;
-                        break;
-                    } else if (scope->type == Scope::eFunction && scope->functionOf)
-                        scope = scope->functionOf;
-                    else
-                        scope = scope->nestedIn;
+                const Scope *scope1 = scope->findRecordInNestedList(tok1->str());
+
+                if (scope1) {
+                    scope = scope1;
+                    break;
                 }
+                if (scope->type == ScopeType::eFunction && scope->functionOf)
+                    scope = scope->functionOf;
+                else
+                    scope = scope->nestedIn;
             }
         }
 
@@ -4112,20 +5796,37 @@ const Type* SymbolDatabase::findVariableType(const Scope *start, const Token *ty
     return nullptr;
 }
 
-bool Scope::hasInlineOrLambdaFunction() const
+static bool hasEmptyCaptureList(const Token* tok) {
+    if (!Token::simpleMatch(tok, "{"))
+        return false;
+    const Token* listTok = tok->astParent();
+    if (Token::simpleMatch(listTok, "("))
+        listTok = listTok->astParent();
+    return Token::simpleMatch(listTok, "[ ]");
+}
+
+bool Scope::hasInlineOrLambdaFunction(const Token** tokStart, bool onlyInline) const
 {
-    for (const Scope *s : nestedList) {
+    return std::any_of(nestedList.begin(), nestedList.end(), [&](const Scope* s) {
         // Inline function
-        if (s->type == Scope::eUnconditional && Token::simpleMatch(s->bodyStart->previous(), ") {"))
+        if (s->type == ScopeType::eUnconditional && Token::simpleMatch(s->bodyStart->previous(), ") {")) {
+            if (tokStart)
+                *tokStart = nullptr; // bailout for e.g. loop-like macros
             return true;
+        }
         // Lambda function
-        if (s->type == Scope::eLambda)
+        if (!onlyInline && s->type == ScopeType::eLambda && !hasEmptyCaptureList(s->bodyStart)) {
+            if (tokStart)
+                *tokStart = s->bodyStart;
             return true;
-    }
-    return false;
+        }
+        if (s->hasInlineOrLambdaFunction(tokStart, onlyInline))
+            return true;
+        return false;
+    });
 }
 
-void Scope::findFunctionInBase(const std::string & name, nonneg int args, std::vector<const Function *> & matches) const
+void Scope::findFunctionInBase(const Token* tok, nonneg int args, std::vector<const Function *> & matches) const
 {
     if (isClassOrStruct() && definedType && !definedType->derivedFrom.empty()) {
         const std::vector<Type::BaseInfo> &derivedFrom = definedType->derivedFrom;
@@ -4135,17 +5836,63 @@ void Scope::findFunctionInBase(const std::string & name, nonneg int args, std::v
                 if (base->classScope == this) // Ticket #5120, #5125: Recursive class; tok should have been found already
                     continue;
 
-                for (std::multimap<std::string, const Function *>::const_iterator it = base->classScope->functionMap.find(name); it != base->classScope->functionMap.end() && it->first == name; ++it) {
+                auto range = base->classScope->functionMap.equal_range(tok->str());
+                for (auto it = range.first; it != range.second; ++it) {
                     const Function *func = it->second;
-                    if (args == func->argCount() || (args < func->argCount() && args >= func->minArgCount())) {
+                    if (func->isDestructor() && !Token::simpleMatch(tok->tokAt(-1), "~"))
+                        continue;
+                    if ((func->isVariadic() && args >= (func->argCount() - 1)) ||
+                        (args == func->argCount() || (args < func->argCount() && args >= func->minArgCount()))) {
                         matches.push_back(func);
                     }
                 }
 
-                base->classScope->findFunctionInBase(name, args, matches);
+                base->classScope->findFunctionInBase(tok, args, matches);
+            }
+        }
+    }
+}
+
+const Scope *Scope::findRecordInBase(const std::string & name) const
+{
+    if (isClassOrStruct() && definedType && !definedType->derivedFrom.empty()) {
+        const std::vector<Type::BaseInfo> &derivedFrom = definedType->derivedFrom;
+        for (const Type::BaseInfo & i : derivedFrom) {
+            const Type *base = i.type;
+            if (base && base->classScope) {
+                if (base->classScope == this) // Recursive class; tok should have been found already
+                    continue;
+
+                if (base->name() == name) {
+                    return base->classScope;
+                }
+
+                const ::Type * t = base->classScope->findType(name);
+                if (t)
+                    return t->classScope;
+            }
+        }
+    }
+
+    return nullptr;
+}
+
+std::vector<const Scope*> Scope::findAssociatedScopes() const
+{
+    std::vector<const Scope*> result = {this};
+    if (isClassOrStruct() && definedType && !definedType->derivedFrom.empty()) {
+        const std::vector<Type::BaseInfo>& derivedFrom = definedType->derivedFrom;
+        for (const Type::BaseInfo& i : derivedFrom) {
+            const Type* base = i.type;
+            if (base && base->classScope) {
+                if (contains(result, base->classScope))
+                    continue;
+                std::vector<const Scope*> baseScopes = base->classScope->findAssociatedScopes();
+                result.insert(result.end(), baseScopes.cbegin(), baseScopes.cend());
             }
         }
     }
+    return result;
 }
 
 //---------------------------------------------------------------------------
@@ -4153,7 +5900,7 @@ void Scope::findFunctionInBase(const std::string & name, nonneg int args, std::v
 static void checkVariableCallMatch(const Variable* callarg, const Variable* funcarg, size_t& same, size_t& fallback1, size_t& fallback2)
 {
     if (callarg) {
-        ValueType::MatchResult res = ValueType::matchParameter(callarg->valueType(), callarg, funcarg);
+        const ValueType::MatchResult res = ValueType::matchParameter(callarg->valueType(), callarg, funcarg);
         if (res == ValueType::MatchResult::SAME) {
             same++;
             return;
@@ -4169,15 +5916,15 @@ static void checkVariableCallMatch(const Variable* callarg, const Variable* func
         if (res == ValueType::MatchResult::NOMATCH)
             return;
 
-        bool ptrequals = callarg->isArrayOrPointer() == funcarg->isArrayOrPointer();
-        bool constEquals = !callarg->isArrayOrPointer() || ((callarg->typeStartToken()->strAt(-1) == "const") == (funcarg->typeStartToken()->strAt(-1) == "const"));
+        const bool ptrequals = callarg->isArrayOrPointer() == funcarg->isArrayOrPointer();
+        const bool constEquals = !callarg->isArrayOrPointer() || ((callarg->typeStartToken()->strAt(-1) == "const") == (funcarg->typeStartToken()->strAt(-1) == "const"));
         if (ptrequals && constEquals &&
             callarg->typeStartToken()->str() == funcarg->typeStartToken()->str() &&
             callarg->typeStartToken()->isUnsigned() == funcarg->typeStartToken()->isUnsigned() &&
             callarg->typeStartToken()->isLong() == funcarg->typeStartToken()->isLong()) {
             same++;
         } else if (callarg->isArrayOrPointer()) {
-            if (ptrequals && constEquals && funcarg->typeStartToken()->str() == "void")
+            if (ptrequals && constEquals && funcarg->typeStartToken()->str() == "void") // cppcheck-suppress knownConditionTrueFalse // #14418
                 fallback1++;
             else if (constEquals && funcarg->isStlStringType() && Token::Match(callarg->typeStartToken(), "char|wchar_t"))
                 fallback2++;
@@ -4204,11 +5951,12 @@ static std::string getTypeString(const Token *typeToken)
             while (Token::Match(typeToken, ":: %name%")) {
                 ret += "::" + typeToken->strAt(1);
                 typeToken = typeToken->tokAt(2);
-            }
-            if (typeToken->str() == "<") {
-                for (const Token *tok = typeToken; tok != typeToken->link(); tok = tok->next())
-                    ret += tok->str();
-                ret += ">";
+                if (typeToken->str() == "<") {
+                    for (const Token *tok = typeToken; tok != typeToken->link(); tok = tok->next())
+                        ret += tok->str();
+                    ret += ">";
+                    typeToken = typeToken->link()->next();
+                }
             }
             return ret;
         }
@@ -4220,12 +5968,27 @@ static std::string getTypeString(const Token *typeToken)
     return "";
 }
 
-const Function* Scope::findFunction(const Token *tok, bool requireConst) const
+static bool hasMatchingConstructor(const Scope* classScope, const ValueType* argType) {
+    if (!classScope || !argType)
+        return false;
+    return std::any_of(classScope->functionList.cbegin(),
+                       classScope->functionList.cend(),
+                       [&](const Function& f) {
+        if (!f.isConstructor() || f.argCount() != 1 || !f.getArgumentVar(0))
+            return false;
+        const ValueType* vt = f.getArgumentVar(0)->valueType();
+        return vt &&
+               vt->type == argType->type &&
+               (argType->sign == ValueType::Sign::UNKNOWN_SIGN || vt->sign == argType->sign) &&
+               vt->pointer == argType->pointer &&
+               (vt->constness & 1) >= (argType->constness & 1) &&
+               (vt->volatileness & 1) >= (argType->volatileness & 1);
+    });
+}
+
+const Function* Scope::findFunction(const Token *tok, bool requireConst, Reference ref) const
 {
-    // make sure this is a function call
-    const Token *end = tok->linkAt(1);
-    if (!end)
-        return nullptr;
+    const bool isCall = Token::Match(tok->next(), "(|{");
 
     const std::vector<const Token *> arguments = getArguments(tok);
 
@@ -4235,10 +5998,24 @@ const Function* Scope::findFunction(const Token *tok, bool requireConst) const
     const std::size_t args = arguments.size();
 
     auto addMatchingFunctions = [&](const Scope *scope) {
-        for (std::multimap<std::string, const Function *>::const_iterator it = scope->functionMap.find(tok->str()); it != scope->functionMap.cend() && it->first == tok->str(); ++it) {
+        auto range = scope->functionMap.equal_range(tok->str());
+        for (auto it = range.first; it != range.second; ++it) {
             const Function *func = it->second;
-            if (args == func->argCount() ||
-                (func->isVariadic() && args >= (func->argCount() - 1)) ||
+            if (ref == Reference::LValue && func->hasRvalRefQualifier())
+                continue;
+            if (ref == Reference::None && func->hasRvalRefQualifier()) {
+                if (Token::simpleMatch(tok->astParent(), ".")) {
+                    const Token* obj = tok->astParent()->astOperand1();
+                    while (obj && obj->str() == "[")
+                        obj = obj->astOperand1();
+                    if (!obj || obj->isName())
+                        continue;
+                }
+            }
+            if (func->isDestructor() && !Token::simpleMatch(tok->tokAt(-1), "~"))
+                continue;
+            if (!isCall || args == func->argCount() ||
+                (func->isVariadic() && args >= (func->minArgCount() - 1)) ||
                 (args < func->argCount() && args >= func->minArgCount())) {
                 matches.push_back(func);
             }
@@ -4247,20 +6024,30 @@ const Function* Scope::findFunction(const Token *tok, bool requireConst) const
 
     addMatchingFunctions(this);
 
-    // check in anonumous namespaces
+    // check in anonymous namespaces
     for (const Scope *nestedScope : nestedList) {
-        if (nestedScope->type == eNamespace && nestedScope->className.empty())
+        if (nestedScope->type == ScopeType::eNamespace && nestedScope->className.empty())
             addMatchingFunctions(nestedScope);
     }
 
+    const std::size_t numberOfMatchesNonBase = matches.size();
+
     // check in base classes
-    findFunctionInBase(tok->str(), args, matches);
+    findFunctionInBase(tok, args, matches);
+
+    // Non-call => Do not match parameters
+    if (!isCall) {
+        return matches.empty() ? nullptr : matches[0];
+    }
 
-    const Function* fallback1Func = nullptr;
-    const Function* fallback2Func = nullptr;
+    // store function and number of matching arguments
+    std::vector<std::pair<const Function*, size_t>> fallback1Func, fallback2Func;
 
     // check each function against the arguments in the function call for a match
     for (std::size_t i = 0; i < matches.size();) {
+        if (i > 0 && i == numberOfMatchesNonBase && fallback1Func.empty() && !fallback2Func.empty())
+            break;
+
         bool constFallback = false;
         const Function * func = matches[i];
         size_t same = 0;
@@ -4275,7 +6062,8 @@ const Function* Scope::findFunction(const Token *tok, bool requireConst) const
             const Scope * scope = tok->scope();
 
             // check if this function is a member function
-            if (scope && scope->functionOf && scope->functionOf->isClassOrStruct() && scope->function) {
+            if (scope && scope->functionOf && scope->functionOf->isClassOrStruct() && scope->function &&
+                func->nestedIn == scope->functionOf) {
                 // check if isConst mismatches
                 if (scope->function->isConst() != func->isConst()) {
                     if (scope->function->isConst()) {
@@ -4317,6 +6105,8 @@ const Function* Scope::findFunction(const Token *tok, bool requireConst) const
                         {
                             if (typeToken->str() == "const")
                                 ret.constness |= (1 << ret.pointer);
+                            else if (typeToken->str() == "volatile")
+                                ret.volatileness |= (1 << ret.pointer);
                             else if (typeToken->str() == "*")
                                 ret.pointer++;
                             else if (typeToken->str() == "<") {
@@ -4339,7 +6129,7 @@ const Function* Scope::findFunction(const Token *tok, bool requireConst) const
                         callArgType.sign = funcArgType.sign = ValueType::Sign::SIGNED;
                         callArgType.type = funcArgType.type = ValueType::Type::INT;
 
-                        ValueType::MatchResult res = ValueType::matchParameter(&callArgType, &funcArgType);
+                        const ValueType::MatchResult res = ValueType::matchParameter(&callArgType, &funcArgType);
                         if (res == ValueType::MatchResult::SAME)
                             ++same;
                         else if (res == ValueType::MatchResult::FALLBACK1)
@@ -4364,15 +6154,40 @@ const Function* Scope::findFunction(const Token *tok, bool requireConst) const
             else if (funcarg->isPointer() && Token::Match(arguments[j], "nullptr|NULL ,|)"))
                 same++;
 
-            else if (arguments[j]->isNumber() && funcarg->isPointer() && MathLib::isNullValue(arguments[j]->str()))
+            else if (funcarg->isPointer() && MathLib::isNullValue(arguments[j]->str()))
                 fallback1++;
 
+            else if (!funcarg->isPointer() && funcarg->type() && hasMatchingConstructor(funcarg->type()->classScope, arguments[j]->valueType()))
+                fallback2++;
+
             // Try to evaluate the apparently more complex expression
-            else {
+            else if (arguments[j]->isCpp()) {
                 const Token *vartok = arguments[j];
+                if (vartok->str() == ".") {
+                    const Token* rml = nextAfterAstRightmostLeaf(vartok);
+                    if (rml)
+                        vartok = rml->previous();
+                }
                 while (vartok->isUnaryOp("&") || vartok->isUnaryOp("*"))
                     vartok = vartok->astOperand1();
-                ValueType::MatchResult res = ValueType::matchParameter(arguments[j]->valueType(), vartok->variable(), funcarg);
+                const Variable* var = vartok->variable();
+                // smart pointer deref?
+                bool unknownDeref = false;
+                if (var && vartok->astParent() && vartok->astParent()->str() == "*") {
+                    if (var->isSmartPointer() && var->valueType() && var->valueType()->smartPointerTypeToken)
+                        var = var->valueType()->smartPointerTypeToken->variable();
+                    else
+                        unknownDeref = true;
+                }
+                const Token* valuetok = arguments[j];
+                if (valuetok->str() == "::") {
+                    const Token* rml = nextAfterAstRightmostLeaf(valuetok);
+                    if (rml)
+                        valuetok = rml->previous();
+                }
+                if (vartok->isEnumerator())
+                    valuetok = vartok;
+                const ValueType::MatchResult res = ValueType::matchParameter(valuetok->valueType(), var, funcarg);
                 if (res == ValueType::MatchResult::SAME)
                     ++same;
                 else if (res == ValueType::MatchResult::FALLBACK1)
@@ -4380,12 +6195,18 @@ const Function* Scope::findFunction(const Token *tok, bool requireConst) const
                 else if (res == ValueType::MatchResult::FALLBACK2)
                     ++fallback2;
                 else if (res == ValueType::MatchResult::NOMATCH) {
+                    if (unknownDeref)
+                        continue;
                     // can't match so remove this function from possible matches
                     matches.erase(matches.begin() + i);
                     erased = true;
                     break;
                 }
             }
+
+            else
+                // C code: if number of arguments match then do not match types
+                fallback1++;
         }
 
         const size_t hasToBe = func->isVariadic() ? (func->argCount() - 1) : args;
@@ -4393,16 +6214,16 @@ const Function* Scope::findFunction(const Token *tok, bool requireConst) const
         // check if all arguments matched
         if (same == hasToBe) {
             if (constFallback || (!requireConst && func->isConst()))
-                fallback1Func = func;
+                fallback1Func.emplace_back(func, same);
             else
                 return func;
         }
 
-        else if (!fallback1Func) {
+        else {
             if (same + fallback1 == hasToBe)
-                fallback1Func = func;
-            else if (!fallback2Func && same + fallback2 + fallback1 == hasToBe)
-                fallback2Func = func;
+                fallback1Func.emplace_back(func, same);
+            else if (same + fallback2 + fallback1 == hasToBe)
+                fallback2Func.emplace_back(func, same);
         }
 
         if (!erased)
@@ -4410,26 +6231,78 @@ const Function* Scope::findFunction(const Token *tok, bool requireConst) const
     }
 
     // Fallback cases
-    if (fallback1Func)
-        return fallback1Func;
-
-    if (fallback2Func)
-        return fallback2Func;
+    auto fb_pred = [](const std::pair<const Function*, size_t>& a, const std::pair<const Function*, size_t>& b) {
+        return a.second > b.second;
+    };
+    // sort according to matching arguments
+    std::sort(fallback1Func.begin(), fallback1Func.end(), fb_pred);
+    std::sort(fallback2Func.begin(), fallback2Func.end(), fb_pred);
+    const auto fallbackFuncs = { std::move(fallback1Func), std::move(fallback2Func) };
+    for (const auto& fb : fallbackFuncs) {
+        if (fb.size() == 1)
+            return fb[0].first;
+        if (fb.size() >= 2) {
+            if (fb[0].second > fb[1].second)
+                return fb[0].first;
+        }
+        if (fb.size() == 2) {
+            if (fb[0].first->isConst() && !fb[1].first->isConst())
+                return fb[1].first;
+            if (fb[1].first->isConst() && !fb[0].first->isConst())
+                return fb[0].first;
+        }
+    }
+
+    // remove pure virtual function if there is an overrider
+    auto itPure = std::find_if(matches.begin(), matches.end(), [](const Function* m) {
+        return m->isPure();
+    });
+    if (itPure != matches.end() && std::any_of(matches.begin(), matches.end(), [&](const Function* m) {
+        return m->isImplicitlyVirtual() && m != *itPure;
+    }))
+        matches.erase(itPure);
 
     // Only one candidate left
-    if (matches.size() == 1)
+    if (matches.size() == 1 && std::none_of(functionList.begin(), functionList.end(), [tok](const Function& f) {
+        return startsWith(f.name(), tok->str() + " <");
+    }))
         return matches[0];
 
+    // Prioritize matches in derived scopes
+    for (const auto& fb : fallbackFuncs) {
+        const Function* ret = nullptr;
+        for (std::size_t i = 0; i < fb.size(); ++i) {
+            if (std::find(matches.cbegin(), matches.cend(), fb[i].first) == matches.cend())
+                continue;
+            if (this == fb[i].first->nestedIn) {
+                if (!ret)
+                    ret = fb[i].first;
+                else {
+                    ret = nullptr;
+                    break;
+                }
+            }
+        }
+        if (ret)
+            return ret;
+    }
+
     return nullptr;
 }
 
 //---------------------------------------------------------------------------
 
-const Function* SymbolDatabase::findFunction(const Token *tok) const
+const Function* SymbolDatabase::findFunction(const Token* const tok) const
 {
+    if (tok->tokType() == Token::Type::eEnumerator)
+        return nullptr;
+
     // find the scope this function is in
     const Scope *currScope = tok->scope();
     while (currScope && currScope->isExecutable()) {
+        if (const Function* f = currScope->findFunction(tok)) {
+            return f;
+        }
         if (currScope->functionOf)
             currScope = currScope->functionOf;
         else
@@ -4445,11 +6318,8 @@ const Function* SymbolDatabase::findFunction(const Token *tok) const
             if (tok1->strAt(-2) == ">") {
                 if (tok1->linkAt(-2))
                     tok1 = tok1->linkAt(-2)->tokAt(-1);
-                else {
-                    if (mSettings->debugwarnings)
-                        debugMessage(tok1->tokAt(-2), "SymbolDatabase::findFunction found '>' without link.");
-                    return nullptr;
-                }
+                else
+                    break;
             } else
                 tok1 = tok1->tokAt(-2);
         }
@@ -4458,6 +6328,9 @@ const Function* SymbolDatabase::findFunction(const Token *tok) const
         if (tok1->strAt(-1) == "::") {
             currScope = &scopeList.front();
 
+            if (const Function* f = currScope->findFunction(tok))
+                return f;
+
             currScope = currScope->findRecordInNestedList(tok1->str());
         }
 
@@ -4466,44 +6339,65 @@ const Function* SymbolDatabase::findFunction(const Token *tok) const
             while (currScope) {
                 if (currScope->className == tok1->str())
                     break;
-                else {
-                    const Scope *scope = currScope->findRecordInNestedList(tok1->str());
 
-                    if (scope) {
-                        currScope = scope;
-                        break;
-                    } else
-                        currScope = currScope->nestedIn;
+                const Scope *scope = currScope->findRecordInNestedList(tok1->str());
+
+                if (scope) {
+                    currScope = scope;
+                    break;
                 }
+                currScope = currScope->nestedIn;
             }
         }
 
         if (currScope) {
-            while (currScope && !(Token::Match(tok1, "%type% :: %any% (") ||
-                                  (Token::Match(tok1, "%type% <") && Token::Match(tok1->linkAt(1), "> :: %any% (")))) {
+            while (currScope && tok1 && !(Token::Match(tok1, "%type% :: %name% [(),>]") ||
+                                          (Token::Match(tok1, "%type% <") && Token::Match(tok1->linkAt(1), "> :: %name% (")))) {
                 if (tok1->strAt(1) == "::")
                     tok1 = tok1->tokAt(2);
-                else
+                else if (tok1->strAt(1) == "<")
                     tok1 = tok1->linkAt(1)->tokAt(2);
-                currScope = currScope->findRecordInNestedList(tok1->str());
+                else
+                    tok1 = nullptr;
+
+                if (tok1) {
+                    const Function* func = currScope->findFunction(tok1);
+                    if (func)
+                        return func;
+
+                    currScope = currScope->findRecordInNestedList(tok1->str());
+                }
             }
 
-            tok1 = tok1->tokAt(2);
+            if (tok1)
+                tok1 = tok1->tokAt(2);
 
-            if (currScope && tok1)
-                return currScope->findFunction(tok1);
+            if (currScope && tok1) {
+                const Function* func = currScope->findFunction(tok1);
+                if (func)
+                    return func;
+            }
         }
     }
 
     // check for member function
     else if (Token::Match(tok->tokAt(-2), "!!this .")) {
-        const Token *tok1 = tok->tokAt(-2);
-        if (Token::Match(tok1, "%var% .")) {
+        const Token* tok1 = tok->previous()->astOperand1();
+        if (tok1 && tok1->valueType() && tok1->valueType()->typeScope)
+            return tok1->valueType()->typeScope->findFunction(tok, tok1->valueType()->constness == 1, tok1->valueType()->reference);
+        if (tok1 && Token::Match(tok1->previous(), "%name% (") && tok1->previous()->function() &&
+            tok1->previous()->function()->retDef) {
+            ValueType vt = ValueType::parseDecl(tok1->previous()->function()->retDef, mSettings);
+            if (vt.typeScope)
+                return vt.typeScope->findFunction(tok, vt.constness == 1);
+        } else if (Token::Match(tok1, "%var% .")) {
             const Variable *var = getVariableFromVarId(tok1->varId());
             if (var && var->typeScope())
                 return var->typeScope()->findFunction(tok, var->valueType()->constness == 1);
             if (var && var->smartPointerType() && var->smartPointerType()->classScope && tok1->next()->originalName() == "->")
                 return var->smartPointerType()->classScope->findFunction(tok, var->valueType()->constness == 1);
+            if (var && var->iteratorType() && var->iteratorType()->classScope && tok1->next()->originalName() == "->")
+                return var->iteratorType()->classScope->findFunction(tok, var->valueType()->constness == 1);
         } else if (Token::simpleMatch(tok->previous()->astOperand1(), "(")) {
             const Token *castTok = tok->previous()->astOperand1();
             if (castTok->isCast()) {
@@ -4522,74 +6416,105 @@ const Function* SymbolDatabase::findFunction(const Token *tok) const
                 return func;
             currScope = currScope->nestedIn;
         }
+        // check using namespace
+        currScope = tok->scope();
+        while (currScope) {
+            for (const auto& ul : currScope->usingList) {
+                if (ul.scope) {
+                    const Function* func = ul.scope->findFunction(tok);
+                    if (func)
+                        return func;
+                }
+            }
+            currScope = currScope->nestedIn;
+        }
+    }
+    // Check for constructor
+    if (Token::Match(tok, "%name% (|{")) {
+        ValueType vt = ValueType::parseDecl(tok, mSettings);
+        if (vt.typeScope)
+            return vt.typeScope->findFunction(tok, false);
     }
     return nullptr;
 }
 
 //---------------------------------------------------------------------------
 
+// cppcheck-suppress unusedFunction
 const Scope *SymbolDatabase::findScopeByName(const std::string& name) const
 {
-    for (std::list<Scope>::const_iterator it = scopeList.begin(); it != scopeList.end(); ++it) {
-        if (it->className == name)
-            return &*it;
-    }
-    return nullptr;
+    auto it = std::find_if(scopeList.cbegin(), scopeList.cend(), [&](const Scope& s) {
+        return s.className == name;
+    });
+    return it == scopeList.end() ? nullptr : &*it;
 }
 
 //---------------------------------------------------------------------------
 
-Scope *Scope::findInNestedList(const std::string & name)
+template<class S, class T, REQUIRES("S must be a Scope class", std::is_convertible<S*, const Scope*> ), REQUIRES("T must be a Type class", std::is_convertible<T*, const Type*> )>
+static S* findRecordInNestedListImpl(S& thisScope, const std::string& name, bool isC, std::set<const Scope*>& visited)
 {
-    std::list<Scope *>::iterator it;
-
-    for (it = nestedList.begin(); it != nestedList.end(); ++it) {
-        if ((*it)->className == name)
-            return (*it);
+    for (S* scope: thisScope.nestedList) {
+        if (scope->className == name && scope->type != ScopeType::eFunction)
+            return scope;
+        if (isC) {
+            S* nestedScope = scope->findRecordInNestedList(name, isC);
+            if (nestedScope)
+                return nestedScope;
+        }
     }
-    return nullptr;
-}
-
-//---------------------------------------------------------------------------
 
-const Scope *Scope::findRecordInNestedList(const std::string & name) const
-{
-    std::list<Scope *>::const_iterator it;
-
-    for (it = nestedList.begin(); it != nestedList.end(); ++it) {
-        if ((*it)->className == name && (*it)->type != eFunction)
-            return (*it);
+    for (const auto& u : thisScope.usingList) {
+        if (!u.scope || u.scope == &thisScope || visited.find(u.scope) != visited.end())
+            continue;
+        visited.emplace(u.scope);
+        S* nestedScope = findRecordInNestedListImpl<S, T>(const_cast<S&>(*u.scope), name, false, visited);
+        if (nestedScope)
+            return nestedScope;
     }
 
-    const Type * nested_type = findType(name);
+    T * nested_type = thisScope.findType(name);
 
     if (nested_type) {
         if (nested_type->isTypeAlias()) {
             if (nested_type->typeStart == nested_type->typeEnd)
-                return findRecordInNestedList(nested_type->typeStart->str());
+                return thisScope.findRecordInNestedList(nested_type->typeStart->str()); // TODO: pass isC?
         } else
-            return nested_type->classScope;
+            return const_cast<S*>(nested_type->classScope);
     }
 
     return nullptr;
 }
 
+const Scope* Scope::findRecordInNestedList(const std::string & name, bool isC) const
+{
+    std::set<const Scope*> visited;
+    return findRecordInNestedListImpl<const Scope, const Type>(*this, name, isC, visited);
+}
+
+Scope* Scope::findRecordInNestedList(const std::string & name, bool isC)
+{
+    std::set<const Scope*> visited;
+    return findRecordInNestedListImpl<Scope, Type>(*this, name, isC, visited);
+}
+
 //---------------------------------------------------------------------------
 
-const Type* Scope::findType(const std::string & name) const
+template<class S, class T, REQUIRES("S must be a Scope class", std::is_convertible<S*, const Scope*> ), REQUIRES("T must be a Type class", std::is_convertible<T*, const Type*> )>
+static T* findTypeImpl(S& thisScope, const std::string & name)
 {
-    auto it = definedTypesMap.find(name);
+    auto it = thisScope.definedTypesMap.find(name);
 
     // Type was found
-    if (definedTypesMap.end() != it)
-        return (*it).second;
+    if (thisScope.definedTypesMap.end() != it)
+        return it->second;
 
     // is type defined in anonymous namespace..
-    it = definedTypesMap.find("");
-    if (it != definedTypesMap.end()) {
-        for (const Scope *scope : nestedList) {
-            if (scope->className.empty() && (scope->type == eNamespace || scope->isClassOrStructOrUnion())) {
-                const Type *t = scope->findType(name);
+    it = thisScope.definedTypesMap.find("");
+    if (it != thisScope.definedTypesMap.end()) {
+        for (S *scope : thisScope.nestedList) {
+            if (scope->className.empty() && (scope->type == ScopeType::eNamespace || scope->isClassOrStructOrUnion())) {
+                T *t = scope->findType(name);
                 if (t)
                     return t;
             }
@@ -4600,42 +6525,42 @@ const Type* Scope::findType(const std::string & name) const
     return nullptr;
 }
 
-//---------------------------------------------------------------------------
-
-Scope *Scope::findInNestedListRecursive(const std::string & name)
+const Type* Scope::findType(const std::string& name) const
 {
-    std::list<Scope *>::iterator it;
-
-    for (it = nestedList.begin(); it != nestedList.end(); ++it) {
-        if ((*it)->className == name)
-            return (*it);
-    }
+    return findTypeImpl<const Scope, const Type>(*this, name);
+}
 
-    for (it = nestedList.begin(); it != nestedList.end(); ++it) {
-        Scope *child = (*it)->findInNestedListRecursive(name);
-        if (child)
-            return child;
-    }
-    return nullptr;
+Type* Scope::findType(const std::string& name)
+{
+    return findTypeImpl<Scope, Type>(*this, name);
 }
 
 //---------------------------------------------------------------------------
 
-const Function *Scope::getDestructor() const
+const Scope *Scope::findInNestedListRecursive(const std::string & name) const
 {
-    std::list<Function>::const_iterator it;
-    for (it = functionList.begin(); it != functionList.end(); ++it) {
-        if (it->type == Function::eDestructor)
-            return &(*it);
+    auto it = std::find_if(nestedList.cbegin(), nestedList.cend(), [&](const Scope* s) {
+        return s->className == name;
+    });
+    if (it != nestedList.end())
+        return *it;
+
+    for (const Scope* scope: nestedList) {
+        const Scope *child = scope->findInNestedListRecursive(name);
+        if (child)
+            return child;
     }
     return nullptr;
 }
 
 //---------------------------------------------------------------------------
 
-bool SymbolDatabase::isCPP() const
+const Function *Scope::getDestructor() const
 {
-    return mTokenizer->isCPP();
+    auto it = std::find_if(functionList.cbegin(), functionList.cend(), [](const Function& f) {
+        return f.type == FunctionType::eDestructor;
+    });
+    return it == functionList.end() ? nullptr : &*it;
 }
 
 //---------------------------------------------------------------------------
@@ -4657,10 +6582,9 @@ const Scope *SymbolDatabase::findScope(const Token *tok, const Scope *startScope
         if (tok->strAt(1) == "::") {
             scope = scope->findRecordInNestedList(tok->str());
             tok = tok->tokAt(2);
-        } else if (tok->strAt(1) == "<" && Token::simpleMatch(tok->linkAt(1), "> ::")) {
-            scope = scope->findRecordInNestedList(tok->str());
-            tok = tok->linkAt(1)->tokAt(2);
-        } else
+        } else if (tok->strAt(1) == "<")
+            return nullptr;
+        else
             return scope->findRecordInNestedList(tok->str());
     }
 
@@ -4670,7 +6594,7 @@ const Scope *SymbolDatabase::findScope(const Token *tok, const Scope *startScope
 
 //---------------------------------------------------------------------------
 
-const Type* SymbolDatabase::findType(const Token *startTok, const Scope *startScope) const
+const Type* SymbolDatabase::findType(const Token *startTok, const Scope *startScope, bool lookOutside) const
 {
     // skip over struct or union
     if (Token::Match(startTok, "struct|union"))
@@ -4707,18 +6631,26 @@ const Type* SymbolDatabase::findType(const Token *startTok, const Scope *startSc
                 tok = startTok;
             }
         } else {
-            const Type * type = scope->findType(tok->str());
+            const Scope* scope1{};
+            const Type* type = scope->findType(tok->str());
             if (type)
                 return type;
-            else
+            if (lookOutside && (scope1 = scope->findRecordInBase(tok->str()))) {
+                type = scope1->definedType;
+                if (type)
+                    return type;
+            } else if (lookOutside && scope->type == ScopeType::eNamespace) {
+                scope = scope->nestedIn;
+                continue;
+            } else
                 break;
         }
     }
 
     // check using namespaces
     while (startScope) {
-        for (std::list<Scope::UsingInfo>::const_iterator it = startScope->usingList.begin();
-             it != startScope->usingList.end(); ++it) {
+        for (auto it = startScope->usingList.cbegin();
+             it != startScope->usingList.cend(); ++it) {
             tok = startTok;
             scope = it->scope;
             start_scope = startScope;
@@ -4742,7 +6674,11 @@ const Type* SymbolDatabase::findType(const Token *startTok, const Scope *startSc
                     const Type * type = scope->findType(tok->str());
                     if (type)
                         return type;
-                    else
+                    if (const Scope *scope1 = scope->findRecordInBase(tok->str())) {
+                        type = scope1->definedType;
+                        if (type)
+                            return type;
+                    } else
                         break;
                 }
             }
@@ -4763,7 +6699,7 @@ const Type* SymbolDatabase::findTypeInNested(const Token *startTok, const Scope
         startTok = startTok->next();
 
     // type same as scope
-    if (startTok->str() == startScope->className && startScope->isClassOrStruct())
+    if (startScope->isClassOrStruct() && startTok->str() == startScope->className && !Token::simpleMatch(startTok->next(), "::"))
         return startScope->definedType;
 
     bool hasPath = false;
@@ -4798,11 +6734,10 @@ const Type* SymbolDatabase::findTypeInNested(const Token *startTok, const Scope
             const Type * type = scope->findType(tok->str());
             if (hasPath || type)
                 return type;
-            else {
-                scope = scope->nestedIn;
-                if (!scope)
-                    break;
-            }
+
+            scope = scope->nestedIn;
+            if (!scope)
+                break;
         }
     }
 
@@ -4818,7 +6753,7 @@ const Scope * SymbolDatabase::findNamespace(const Token * tok, const Scope * sco
 
     if (s)
         return s;
-    else if (scope->nestedIn)
+    if (scope->nestedIn)
         return findNamespace(tok, scope->nestedIn);
 
     return nullptr;
@@ -4831,10 +6766,9 @@ Function * SymbolDatabase::findFunctionInScope(const Token *func, const Scope *n
     const Function * function = nullptr;
     const bool destructor = func->strAt(-1) == "~";
 
-    for (std::multimap<std::string, const Function *>::const_iterator it = ns->functionMap.find(func->str());
-         it != ns->functionMap.end() && it->first == func->str(); ++it) {
-
-        if (Function::argsMatch(ns, it->second->argDef, func->next(), path, path_length) &&
+    auto range = ns->functionMap.equal_range(func->str());
+    for (auto it = range.first; it != range.second; ++it) {
+        if (it->second->argsMatch(ns, it->second->argDef, func->next(), path, path_length) &&
             it->second->isDestructor() == destructor) {
             function = it->second;
             break;
@@ -4861,86 +6795,93 @@ Function * SymbolDatabase::findFunctionInScope(const Token *func, const Scope *n
 
 //---------------------------------------------------------------------------
 
-namespace {
-
-#define C_KEYWORDS\
-    "_Bool", "auto", "break", "case", "char", "const", "continue", "default", "do",\
-        "double", "else", "enum", "extern", "float", "for", "goto", "if", "inline",\
-        "int", "long", "register", "restrict", "return", "short", "signed", "sizeof",\
-        "static", "struct", "switch", "typedef", "union", "unsigned", "void", "volatile",\
-        "while"
-
-    const std::set<std::string> c_keywords = { C_KEYWORDS };
-    const std::set<std::string> cpp_keywords = {
-        C_KEYWORDS,
-        "alignas", "alignof", "and", "and_eq", "asm", "bitand", "bitor", "bool", "catch", "class", "compl",
-        "concept", "constexpr", "const_cast", "decltype",
-        "delete", "dynamic_cast", "explicit", "export", "false", "friend",
-        "mutable", "namespace", "new", "noexcept", "not", "not_eq", "nullptr", "operator",
-        "or", "or_eq", "private", "protected", "public", "reinterpret_cast",
-        "requires", "static_assert",
-        "static_cast", "template", "this", "thread_local", "throw",
-        "true", "try", "typeid", "typename", "using",
-        "virtual", "wchar_t", "xor", "xor_eq"
-    };
-}
-
-bool SymbolDatabase::isReservedName(const std::string& iName) const
+bool SymbolDatabase::isReservedName(const Token* tok)
 {
-    if (isCPP())
+    const std::string& iName = tok->str();
+    if (tok->isCpp()) {
+        static const auto& cpp_keywords = Keywords::getAll(Standards::cppstd_t::CPPLatest);
         return cpp_keywords.find(iName) != cpp_keywords.cend();
-    else
-        return c_keywords.find(iName) != c_keywords.cend();
+    }
+    static const auto& c_keywords = Keywords::getAll(Standards::cstd_t::CLatest);
+    return c_keywords.find(iName) != c_keywords.cend();
 }
 
 nonneg int SymbolDatabase::sizeOfType(const Token *type) const
 {
-    int size = mTokenizer->sizeOfType(type);
+    int size = mTokenizer.sizeOfType(type);
 
     if (size == 0 && type->type() && type->type()->isEnumType() && type->type()->classScope) {
-        size = mSettings->sizeof_int;
+        size = mSettings.platform.sizeof_int;
         const Token * enum_type = type->type()->classScope->enumType;
         if (enum_type)
-            size = mTokenizer->sizeOfType(enum_type);
+            size = mTokenizer.sizeOfType(enum_type);
     }
 
     return size;
 }
 
-static const Token * parsedecl(const Token *type, ValueType * const valuetype, ValueType::Sign defaultSignedness, const Settings* settings);
+static const Token* parsedecl(const Token* type,
+                              ValueType* valuetype,
+                              ValueType::Sign defaultSignedness,
+                              const Settings& settings,
+                              SourceLocation loc = SourceLocation::current());
 
-void SymbolDatabase::setValueType(Token *tok, const Variable &var)
+void SymbolDatabase::setValueType(Token* tok, const Variable& var, const SourceLocation &loc)
 {
     ValueType valuetype;
+    if (mSettings.debugnormal || mSettings.debugwarnings)
+        valuetype.setDebugPath(tok, loc);
     if (var.nameToken())
         valuetype.bits = var.nameToken()->bits();
+
     valuetype.pointer = var.dimensions().size();
+    // HACK: don't set pointer for plain std::array
+    if (var.valueType() && var.valueType()->container && Token::simpleMatch(var.typeStartToken(), "std :: array") && !Token::simpleMatch(var.nameToken()->next(), "["))
+        valuetype.pointer = 0;
+
     valuetype.typeScope = var.typeScope();
     if (var.valueType()) {
         valuetype.container = var.valueType()->container;
+        valuetype.containerTypeToken = var.valueType()->containerTypeToken;
     }
     valuetype.smartPointerType = var.smartPointerType();
     if (parsedecl(var.typeStartToken(), &valuetype, mDefaultSignedness, mSettings)) {
         if (tok->str() == "." && tok->astOperand1()) {
             const ValueType * const vt = tok->astOperand1()->valueType();
-            if (vt && (vt->constness & 1) != 0)
-                valuetype.constness |= 1;
+            if (vt && (vt->constness & 1) != 0) {
+                if (var.isArray()) // constness propagates to arrays, but not to regular pointers
+                    valuetype.constness |= 1;
+                else
+                    valuetype.constness |= (1 << valuetype.pointer);
+            }
+            if (vt && (vt->volatileness & 1) != 0) {
+                if (var.isArray())
+                    valuetype.volatileness |= 1;
+                else
+                    valuetype.volatileness |= (1 << valuetype.pointer);
+            }
         }
         setValueType(tok, valuetype);
     }
 }
 
-void SymbolDatabase::setValueType(Token *tok, const Enumerator &enumerator)
+static ValueType::Type getEnumType(const Scope* scope, const Platform& platform);
+
+void SymbolDatabase::setValueType(Token* tok, const Enumerator& enumerator, const SourceLocation &loc)
 {
     ValueType valuetype;
+    if (mSettings.debugnormal || mSettings.debugwarnings)
+        valuetype.setDebugPath(tok, loc);
     valuetype.typeScope = enumerator.scope;
     const Token * type = enumerator.scope->enumType;
+    if (type && type->astParent())
+        type = type->astParent();
     if (type) {
         valuetype.type = ValueType::typeFromString(type->str(), type->isLong());
-        if (valuetype.type == ValueType::Type::UNKNOWN_TYPE && type->isStandardType())
-            valuetype.fromLibraryType(type->str(), mSettings);
+        if (valuetype.type == ValueType::Type::UNKNOWN_TYPE)
+            valuetype.fromLibraryType(type->expressionString(), mSettings);
 
-        if (valuetype.isIntegral()) {
+        if (valuetype.sign == ValueType::UNKNOWN_SIGN && valuetype.isIntegral()) {
             if (type->isSigned())
                 valuetype.sign = ValueType::Sign::SIGNED;
             else if (type->isUnsigned())
@@ -4954,7 +6895,7 @@ void SymbolDatabase::setValueType(Token *tok, const Enumerator &enumerator)
         setValueType(tok, valuetype);
     } else {
         valuetype.sign = ValueType::SIGNED;
-        valuetype.type = ValueType::INT;
+        valuetype.type = getEnumType(enumerator.scope, mSettings.platform);
         setValueType(tok, valuetype);
     }
 }
@@ -4966,24 +6907,66 @@ static void setAutoTokenProperties(Token * const autoTok)
         autoTok->isStandardType(true);
 }
 
-void SymbolDatabase::setValueType(Token *tok, const ValueType &valuetype)
+static bool isContainerYieldElement(Library::Container::Yield yield)
+{
+    return yield == Library::Container::Yield::ITEM || yield == Library::Container::Yield::AT_INDEX ||
+           yield == Library::Container::Yield::BUFFER || yield == Library::Container::Yield::BUFFER_NT;
+}
+
+static bool isContainerYieldPointer(Library::Container::Yield yield)
 {
-    tok->setValueType(new ValueType(valuetype));
+    return yield == Library::Container::Yield::BUFFER || yield == Library::Container::Yield::BUFFER_NT;
+}
+
+void SymbolDatabase::setValueType(Token* tok, const ValueType& valuetype, const SourceLocation &loc)
+{
+    auto* valuetypePtr = new ValueType(valuetype);
+    if (mSettings.debugnormal || mSettings.debugwarnings)
+        valuetypePtr->setDebugPath(tok, loc);
+    tok->setValueType(valuetypePtr);
     Token *parent = tok->astParent();
     if (!parent || parent->valueType())
         return;
     if (!parent->astOperand1())
         return;
 
-    const ValueType *vt1 = parent->astOperand1() ? parent->astOperand1()->valueType() : nullptr;
+    const ValueType *vt1 = parent->astOperand1()->valueType();
     const ValueType *vt2 = parent->astOperand2() ? parent->astOperand2()->valueType() : nullptr;
 
     if (vt1 && Token::Match(parent, "<<|>>")) {
-        if (!mIsCpp || (vt2 && vt2->isIntegral()))
-            setValueType(parent, *vt1);
+        if (!parent->isCpp() || (vt2 && vt2->isIntegral())) {
+            if (vt1->type < ValueType::Type::BOOL || vt1->type >= ValueType::Type::INT) {
+                ValueType vt(*vt1);
+                vt.reference = Reference::None;
+                setValueType(parent, vt);
+            } else {
+                ValueType vt(*vt1);
+                vt.type = ValueType::Type::INT; // Integer promotion
+                vt.sign = ValueType::Sign::SIGNED;
+                vt.reference = Reference::None;
+                setValueType(parent, vt);
+            }
+
+        }
         return;
     }
 
+    if (vt1 && vt1->container && vt1->containerTypeToken && Token::Match(parent, ". %name% (") &&
+        isContainerYieldElement(vt1->container->getYield(parent->strAt(1)))) {
+        ValueType item;
+        if (parsedecl(vt1->containerTypeToken, &item, mDefaultSignedness, mSettings)) {
+            if (item.constness == 0)
+                item.constness = vt1->constness;
+            if (item.volatileness == 0)
+                item.volatileness = vt1->volatileness;
+            if (isContainerYieldPointer(vt1->container->getYield(parent->strAt(1))))
+                item.pointer += 1;
+            else
+                item.reference = Reference::LValue;
+            setValueType(parent->tokAt(2), item);
+        }
+    }
+
     if (vt1 && vt1->smartPointerType && Token::Match(parent, ". %name% (") && parent->originalName() == "->" && !parent->next()->function()) {
         const Scope *scope = vt1->smartPointerType->classScope;
         const Function *f = scope ? scope->findFunction(parent->next(), false) : nullptr;
@@ -4992,24 +6975,32 @@ void SymbolDatabase::setValueType(Token *tok, const ValueType &valuetype)
     }
 
     if (parent->isAssignmentOp()) {
-        if (vt1)
-            setValueType(parent, *vt1);
-        else if (mIsCpp && ((Token::Match(parent->tokAt(-3), "%var% ; %var% =") && parent->strAt(-3) == parent->strAt(-1)) ||
-                            Token::Match(parent->tokAt(-1), "%var% ="))) {
+        if (vt1) {
+            auto vt = *vt1;
+            vt.reference = Reference::None;
+            setValueType(parent, vt);
+        } else if (parent->isCpp() && ((Token::Match(parent->tokAt(-3), "%var% ; %var% =") && parent->strAt(-3) == parent->strAt(-1)) ||
+                                       Token::Match(parent->tokAt(-1), "%var% ="))) {
             Token *var1Tok = parent->strAt(-2) == ";" ? parent->tokAt(-3) : parent->tokAt(-1);
             Token *autoTok = nullptr;
-            if (Token::Match(var1Tok->tokAt(-2), ";|{|}|(|const auto"))
+            if (Token::simpleMatch(var1Tok->tokAt(-1), "auto"))
                 autoTok = var1Tok->previous();
-            else if (Token::Match(var1Tok->tokAt(-3), ";|{|}|(|const auto *"))
+            else if (Token::Match(var1Tok->tokAt(-2), "auto *|&|&&"))
                 autoTok = var1Tok->tokAt(-2);
+            else if (Token::simpleMatch(var1Tok->tokAt(-3), "auto * const"))
+                autoTok = var1Tok->tokAt(-3);
             if (autoTok) {
                 ValueType vt(*vt2);
                 if (vt.constness & (1 << vt.pointer))
                     vt.constness &= ~(1 << vt.pointer);
+                if (vt.volatileness & (1 << vt.pointer))
+                    vt.volatileness &= ~(1 << vt.pointer);
                 if (autoTok->strAt(1) == "*" && vt.pointer)
                     vt.pointer--;
-                if (autoTok->strAt(-1) == "const")
-                    vt.constness |= 1;
+                if (Token::Match(autoTok->tokAt(-1), "const|constexpr"))
+                    vt.constness |= (1 << vt.pointer);
+                if (Token::simpleMatch(autoTok->tokAt(-1), "volatile"))
+                    vt.volatileness |= (1 << vt.pointer);
                 setValueType(autoTok, vt);
                 setAutoTokenProperties(autoTok);
                 if (vt2->pointer > vt.pointer)
@@ -5017,15 +7008,23 @@ void SymbolDatabase::setValueType(Token *tok, const ValueType &valuetype)
                 setValueType(var1Tok, vt);
                 if (var1Tok != parent->previous())
                     setValueType(parent->previous(), vt);
-                Variable *var = const_cast<Variable *>(parent->previous()->variable());
+                auto *var = const_cast<Variable *>(parent->previous()->variable());
                 if (var) {
                     ValueType vt2_(*vt2);
                     if (vt2_.pointer == 0 && autoTok->strAt(1) == "*")
                         vt2_.pointer = 1;
                     if ((vt.constness & (1 << vt2->pointer)) != 0)
                         vt2_.constness |= (1 << vt2->pointer);
-                    if (!Token::Match(autoTok->tokAt(1), "*|&"))
+                    if ((vt.volatileness & (1 << vt2->pointer)) != 0)
+                        vt2_.volatileness |= (1 << vt2->pointer);
+                    if (!Token::Match(autoTok->tokAt(1), "*|&")) {
                         vt2_.constness = vt.constness;
+                        vt2_.volatileness = vt.volatileness;
+                    }
+                    if (Token::simpleMatch(autoTok->tokAt(1), "* const"))
+                        vt2_.constness |= (1 << vt2->pointer);
+                    if (Token::simpleMatch(autoTok->tokAt(1), "* volatile"))
+                        vt2_.volatileness |= (1 << vt2->pointer);
                     var->setValueType(vt2_);
                     if (vt2->typeScope && vt2->typeScope->definedType) {
                         var->type(vt2->typeScope->definedType);
@@ -5038,7 +7037,7 @@ void SymbolDatabase::setValueType(Token *tok, const ValueType &valuetype)
         return;
     }
 
-    if (parent->str() == "[" && (!mIsCpp || parent->astOperand1() == tok) && valuetype.pointer > 0U && !Token::Match(parent->previous(), "[{,]")) {
+    if (parent->str() == "[" && (!parent->isCpp() || parent->astOperand1() == tok) && valuetype.pointer > 0U && !Token::Match(parent->previous(), "[{,]")) {
         const Token *op1 = parent->astOperand1();
         while (op1 && op1->str() == "[")
             op1 = op1->astOperand1();
@@ -5050,23 +7049,57 @@ void SymbolDatabase::setValueType(Token *tok, const ValueType &valuetype)
         setValueType(parent, vt);
         return;
     }
-    if (Token::Match(parent->previous(), "%name% (") && parent->astOperand1() == tok && valuetype.pointer > 0U) {
+    if (Token::Match(parent->tokAt(-1), "%name% (") && !parent->tokAt(-1)->isKeyword() && parent->astOperand1() == tok && valuetype.pointer > 0U) {
         ValueType vt(valuetype);
         vt.pointer -= 1U;
         setValueType(parent, vt);
         return;
     }
+    // std::move
+    if (vt2 && parent->str() == "(" && Token::simpleMatch(parent->tokAt(-3), "std :: move (")) {
+        ValueType vt = valuetype;
+        vt.reference = Reference::RValue;
+        setValueType(parent, vt);
+        return;
+    }
     if (parent->str() == "*" && !parent->astOperand2() && valuetype.pointer > 0U) {
         ValueType vt(valuetype);
         vt.pointer -= 1U;
         setValueType(parent, vt);
         return;
     }
+    // Dereference iterator
+    if (parent->str() == "*" && !parent->astOperand2() && valuetype.type == ValueType::Type::ITERATOR &&
+        valuetype.containerTypeToken) {
+        ValueType vt;
+        if (parsedecl(valuetype.containerTypeToken, &vt, mDefaultSignedness, mSettings)) {
+            if (vt.constness == 0)
+                vt.constness = valuetype.constness;
+            if (vt.volatileness == 0)
+                vt.volatileness = valuetype.volatileness;
+            vt.reference = Reference::LValue;
+            setValueType(parent, vt);
+            return;
+        }
+    }
+    // Dereference smart pointer
+    if (parent->str() == "*" && !parent->astOperand2() && valuetype.type == ValueType::Type::SMART_POINTER &&
+        valuetype.smartPointerTypeToken) {
+        ValueType vt;
+        if (parsedecl(valuetype.smartPointerTypeToken, &vt, mDefaultSignedness, mSettings)) {
+            if (vt.constness == 0)
+                vt.constness = valuetype.constness;
+            if (vt.volatileness == 0)
+                vt.volatileness = valuetype.volatileness;
+            setValueType(parent, vt);
+            return;
+        }
+    }
     if (parent->str() == "*" && Token::simpleMatch(parent->astOperand2(), "[") && valuetype.pointer > 0U) {
         const Token *op1 = parent->astOperand2()->astOperand1();
         while (op1 && op1->str() == "[")
             op1 = op1->astOperand1();
-        ValueType vt(valuetype);
+        const ValueType& vt(valuetype);
         if (op1 && op1->variable() && op1->variable()->nameToken() == op1) {
             setValueType(parent, vt);
             return;
@@ -5074,7 +7107,18 @@ void SymbolDatabase::setValueType(Token *tok, const ValueType &valuetype)
     }
     if (parent->str() == "&" && !parent->astOperand2()) {
         ValueType vt(valuetype);
-        vt.pointer += 1U;
+        vt.reference = Reference::None; //Given int& x; the type of &x is int* not int&*
+        bool isArrayToPointerDecay = false;
+        for (const Token* child = parent->astOperand1(); child;) {
+            if (Token::Match(child, ".|::"))
+                child = child->astOperand2();
+            else {
+                isArrayToPointerDecay = child->variable() && child->variable()->isArray();
+                break;
+            }
+        }
+        if (!isArrayToPointerDecay)
+            vt.pointer += 1U;
         setValueType(parent, vt);
         return;
     }
@@ -5087,38 +7131,55 @@ void SymbolDatabase::setValueType(Token *tok, const ValueType &valuetype)
             const Scope *typeScope = vt1->typeScope;
             if (!typeScope)
                 return;
-            for (std::list<Variable>::const_iterator it = typeScope->varlist.begin(); it != typeScope->varlist.end(); ++it) {
-                if (it->nameToken()->str() == name) {
-                    var = &*it;
-                    break;
-                }
-            }
+            auto it = std::find_if(typeScope->varlist.begin(), typeScope->varlist.end(), [&name](const Variable& v) {
+                return v.nameToken()->str() == name;
+            });
+            if (it != typeScope->varlist.end())
+                var = &*it;
         }
-        if (var)
+        if (var) {
             setValueType(parent, *var);
+            return;
+        }
+        if (const Enumerator* enu = parent->astOperand2()->enumerator())
+            setValueType(parent, *enu);
         return;
     }
 
     // range for loop, auto
     if (vt2 &&
         parent->str() == ":" &&
-        Token::Match(parent->astParent(), "( const| auto *|&| %var% :") &&
+        Token::Match(parent->astParent(), "( const| auto *|&|&&| %var% :") && // TODO: east-const, multiple const, ref to ptr
         !parent->previous()->valueType() &&
         Token::simpleMatch(parent->astParent()->astOperand1(), "for")) {
         const bool isconst = Token::simpleMatch(parent->astParent()->next(), "const");
+        const bool isvolatile = Token::simpleMatch(parent->astParent()->next(), "volatile");
         Token * const autoToken = parent->astParent()->tokAt(isconst ? 2 : 1);
         if (vt2->pointer) {
             ValueType autovt(*vt2);
             autovt.pointer--;
             autovt.constness = 0;
+            autovt.volatileness = 0;
             setValueType(autoToken, autovt);
             setAutoTokenProperties(autoToken);
             ValueType varvt(*vt2);
             varvt.pointer--;
-            if (isconst)
-                varvt.constness |= 1;
+            if (Token::simpleMatch(autoToken->next(), "&"))
+                varvt.reference = Reference::LValue;
+            if (isconst) {
+                if (varvt.pointer && varvt.reference != Reference::None)
+                    varvt.constness |= (1 << varvt.pointer);
+                else
+                    varvt.constness |= 1;
+            }
+            if (isvolatile) {
+                if (varvt.pointer && varvt.reference != Reference::None)
+                    varvt.volatileness |= (1 << varvt.pointer);
+                else
+                    varvt.volatileness |= 1;
+            }
             setValueType(parent->previous(), varvt);
-            Variable *var = const_cast<Variable *>(parent->previous()->variable());
+            auto *var = const_cast<Variable *>(parent->previous()->variable());
             if (var) {
                 var->setValueType(varvt);
                 if (vt2->typeScope && vt2->typeScope->definedType) {
@@ -5138,29 +7199,45 @@ void SymbolDatabase::setValueType(Token *tok, const ValueType &valuetype)
                     break;
             }
 
-            const Token *containerElementType = typeStart;
-            while (Token::Match(containerElementType, "%name%|::"))
-                containerElementType = containerElementType->next();
-
             // Try to determine type of "auto" token.
             // TODO: Get type better
             bool setType = false;
             ValueType autovt;
             const Type *templateArgType = nullptr; // container element type / smart pointer type
-            if (Token::Match(containerElementType, "< %type% *| *| >")) {
-                if (parsedecl(containerElementType->next(), &autovt, mDefaultSignedness, mSettings)) {
-                    setType = true;
-                    templateArgType = containerElementType->next()->type();
-                }
-            } else if (mSettings->library.isSmartPointer(containerElementType->next())) {
-                const Token *smartPointerTypeTok = containerElementType->next();
-                while (Token::Match(smartPointerTypeTok, "%name%|::"))
-                    smartPointerTypeTok = smartPointerTypeTok->next();
-                if (Token::Match(smartPointerTypeTok, "< %name% > >") && smartPointerTypeTok->next()->type()) {
+            if (!vt2->container->rangeItemRecordType.empty()) {
+                setType = true;
+                autovt.type = ValueType::Type::RECORD;
+            } else if (vt2->containerTypeToken) {
+                if (mSettings.library.isSmartPointer(vt2->containerTypeToken)) {
+                    const Token *smartPointerTypeTok = vt2->containerTypeToken;
+                    while (Token::Match(smartPointerTypeTok, "%name%|::"))
+                        smartPointerTypeTok = smartPointerTypeTok->next();
+                    if (Token::simpleMatch(smartPointerTypeTok, "<")) {
+                        if ((templateArgType = findTypeInNested(smartPointerTypeTok->next(), tok->scope()))) {
+                            setType = true;
+                            autovt.smartPointerType = templateArgType;
+                            autovt.type = ValueType::Type::NONSTD;
+                        }
+                    }
+                } else if (parsedecl(vt2->containerTypeToken, &autovt, mDefaultSignedness, mSettings)) {
                     setType = true;
-                    templateArgType = smartPointerTypeTok->next()->type();
-                    autovt.smartPointerType = templateArgType;
-                    autovt.type = ValueType::Type::NONSTD;
+                    templateArgType = vt2->containerTypeToken->type();
+                    if (Token::simpleMatch(autoToken->next(), "&"))
+                        autovt.reference = Reference::LValue;
+                    else if (Token::simpleMatch(autoToken->next(), "&&"))
+                        autovt.reference = Reference::RValue;
+                    if (autoToken->strAt(-1) == "const") {
+                        if (autovt.pointer && autovt.reference != Reference::None)
+                            autovt.constness |= 2;
+                        else
+                            autovt.constness |= 1;
+                    }
+                    if (autoToken->strAt(-1) == "volatile") {
+                        if (autovt.pointer && autovt.reference != Reference::None)
+                            autovt.volatileness |= 2;
+                        else
+                            autovt.volatileness |= 1;
+                    }
                 }
             }
 
@@ -5169,10 +7246,14 @@ void SymbolDatabase::setValueType(Token *tok, const ValueType &valuetype)
                 setValueType(autoToken, autovt);
                 setAutoTokenProperties(autoToken);
                 ValueType varvt(autovt);
+                if (autoToken->strAt(1) == "*" && autovt.pointer)
+                    autovt.pointer--;
                 if (isconst)
-                    varvt.constness |= 1;
+                    varvt.constness |= (1 << autovt.pointer);
+                if (isvolatile)
+                    varvt.volatileness |= (1 << autovt.pointer);
                 setValueType(parent->previous(), varvt);
-                Variable * var = const_cast<Variable *>(parent->previous()->variable());
+                auto * var = const_cast<Variable *>(parent->previous()->variable());
                 if (var) {
                     var->setValueType(varvt);
                     if (templateArgType && templateArgType->classScope && templateArgType->classScope->definedType) {
@@ -5192,6 +7273,23 @@ void SymbolDatabase::setValueType(Token *tok, const ValueType &valuetype)
         }
     }
 
+    if (parent->isCpp() && vt2 && Token::simpleMatch(parent->previous(), "decltype (")) {
+        setValueType(parent, *vt2);
+        return;
+    }
+
+    // c++17 auto type deduction of braced init list
+    if (parent->isCpp() && mSettings.standards.cpp >= Standards::CPP17 && vt2 && Token::Match(parent->tokAt(-2), "auto %var% {")) {
+        Token *autoTok = parent->tokAt(-2);
+        setValueType(autoTok, *vt2);
+        setAutoTokenProperties(autoTok);
+        if (parent->previous()->variable())
+            const_cast<Variable*>(parent->previous()->variable())->setValueType(*vt2);
+        else
+            debugMessage(parent->previous(), "debug", "Missing variable class for variable with varid");
+        return;
+    }
+
     if (!vt1)
         return;
     if (parent->astOperand2() && !vt2)
@@ -5204,15 +7302,50 @@ void SymbolDatabase::setValueType(Token *tok, const ValueType &valuetype)
         parent = parent->astParent();
     }
 
-    if (ternary || parent->isArithmeticalOp() || parent->tokType() == Token::eIncDecOp) {
-        if (vt1->pointer != 0U && vt2 && vt2->pointer == 0U) {
-            setValueType(parent, *vt1);
-            return;
-        }
+    if (ternary || parent->isArithmeticalOp() || parent->tokType() == Token::eIncDecOp) {
+
+        // CONTAINER + x => CONTAINER
+        if (parent->str() == "+" && vt1->type == ValueType::Type::CONTAINER && vt2 && vt2->isIntegral()) {
+            setValueType(parent, *vt1);
+            return;
+        }
+        // x + CONTAINER => CONTAINER
+        if (parent->str() == "+" && vt1->isIntegral() && vt2 && vt2->type == ValueType::Type::CONTAINER) {
+            setValueType(parent, *vt2);
+            return;
+        }
+
+        if (parent->isArithmeticalOp()) {
+            if (vt1->pointer != 0U && vt2 && vt2->pointer == 0U) {
+                setValueType(parent, *vt1);
+                return;
+            }
+
+            if (vt1->pointer == 0U && vt2 && vt2->pointer != 0U) {
+                setValueType(parent, *vt2);
+                return;
+            }
+        } else if (ternary) {
+            if (vt1->pointer != 0U && vt2 && vt2->pointer == 0U) {
+                if (vt2->isPrimitive())
+                    setValueType(parent, *vt1);
+                else
+                    setValueType(parent, *vt2);
+                return;
+            }
+
+            if (vt1->pointer == 0U && vt2 && vt2->pointer != 0U) {
+                if (vt1->isPrimitive())
+                    setValueType(parent, *vt2);
+                else
+                    setValueType(parent, *vt1);
+                return;
+            }
 
-        if (vt1->pointer == 0U && vt2 && vt2->pointer != 0U) {
-            setValueType(parent, *vt2);
-            return;
+            if (vt1->isTypeEqual(vt2)) {
+                setValueType(parent, *vt1);
+                return;
+            }
         }
 
         if (vt1->pointer != 0U) {
@@ -5242,6 +7375,11 @@ void SymbolDatabase::setValueType(Token *tok, const ValueType &valuetype)
             setValueType(parent, *vt1);
             return;
         }
+
+        if (parent->str() == "+" && vt1->type == ValueType::Type::CONTAINER && vt2 && vt2->type == ValueType::Type::CONTAINER && vt1->container == vt2->container) {
+            setValueType(parent, *vt1);
+            return;
+        }
     }
 
     if (vt1->isIntegral() && vt1->pointer == 0U &&
@@ -5278,18 +7416,54 @@ void SymbolDatabase::setValueType(Token *tok, const ValueType &valuetype)
     }
 }
 
-static const Token * parsedecl(const Token *type, ValueType * const valuetype, ValueType::Sign defaultSignedness, const Settings* settings)
+static ValueType::Type getEnumType(const Scope* scope, const Platform& platform) // TODO: also determine sign?
+{
+    ValueType::Type type = ValueType::Type::INT;
+    for (const Token* tok = scope->bodyStart; tok && tok != scope->bodyEnd; tok = tok->next()) {
+        if (const Token* lam = findLambdaEndToken(tok)) {
+            tok = lam;
+            continue;
+        }
+        if (!tok->isAssignmentOp())
+            continue;
+        const Token* vTok = tok->astOperand2();
+        if (!vTok->hasKnownIntValue()) {
+            if (!vTok->isLiteral())
+                continue;
+            if (const ValueType* vt = vTok->valueType()) {
+                if ((vt->type > type && (vt->type == ValueType::Type::LONG || vt->type == ValueType::Type::LONGLONG)))
+                    type = vt->type;
+            }
+            continue;
+        }
+        const MathLib::bigint value = vTok->getKnownIntValue();
+        if (!platform.isIntValue(value)) {
+            type = ValueType::Type::LONG;
+            if (!platform.isLongValue(value))
+                type = ValueType::Type::LONGLONG;
+        }
+    }
+    return type;
+}
+
+static const Token* parsedecl(const Token* type,
+                              ValueType* const valuetype,
+                              ValueType::Sign defaultSignedness,
+                              const Settings& settings,
+                              SourceLocation loc)
 {
+    if (settings.debugnormal || settings.debugwarnings)
+        valuetype->setDebugPath(type, loc);
     const Token * const previousType = type;
-    const unsigned int pointer0 = valuetype->pointer;
-    while (Token::Match(type->previous(), "%name%"))
+    const int pointer0 = valuetype->pointer;
+    while (Token::Match(type->previous(), "%name%") && !endsWith(type->strAt(-1), ':'))
         type = type->previous();
     valuetype->sign = ValueType::Sign::UNKNOWN_SIGN;
     if (!valuetype->typeScope && !valuetype->smartPointerType)
         valuetype->type = ValueType::Type::UNKNOWN_TYPE;
     else if (valuetype->smartPointerType)
-        valuetype->type = ValueType::Type::NONSTD;
-    else if (valuetype->typeScope->type == Scope::eEnum) {
+        valuetype->type = ValueType::Type::SMART_POINTER;
+    else if (valuetype->typeScope->type == ScopeType::eEnum) {
         const Token * enum_type = valuetype->typeScope->enumType;
         if (enum_type) {
             if (enum_type->isSigned())
@@ -5297,18 +7471,42 @@ static const Token * parsedecl(const Token *type, ValueType * const valuetype, V
             else if (enum_type->isUnsigned())
                 valuetype->sign = ValueType::Sign::UNSIGNED;
             else
-                valuetype->sign = defaultSignedness;
+                valuetype->sign = defaultSignedness; // TODO: this is implementation-dependent might be separate from char
             const ValueType::Type t = ValueType::typeFromString(enum_type->str(), enum_type->isLong());
             if (t != ValueType::Type::UNKNOWN_TYPE)
                 valuetype->type = t;
             else if (enum_type->isStandardType())
                 valuetype->fromLibraryType(enum_type->str(), settings);
         } else
-            valuetype->type = ValueType::Type::INT;
+            valuetype->type = getEnumType(valuetype->typeScope, settings.platform);
     } else
         valuetype->type = ValueType::Type::RECORD;
-    while (Token::Match(type, "%name%|*|&|::") && !Token::Match(type, "typename|template") &&
+    const bool cpp = type->isCpp();
+    bool par = false;
+    while (Token::Match(type, "%name%|*|&|&&|::|(") && !Token::Match(type, "typename|template") && type->varId() == 0 &&
            !type->variable() && !type->function()) {
+        bool isIterator = false;
+        if (type->str() == "(") {
+            if (!Token::simpleMatch(type, "( *"))
+                break;
+            if (Token::Match(type->link(), ") const| {"))
+                break;
+            if (par)
+                break;
+            par = true;
+        }
+        if (Token::simpleMatch(type, "decltype (") && type->next()->valueType()) {
+            const ValueType *vt2 = type->next()->valueType();
+            if (valuetype->sign == ValueType::Sign::UNKNOWN_SIGN)
+                valuetype->sign = vt2->sign;
+            if (valuetype->type == ValueType::Type::UNKNOWN_TYPE)
+                valuetype->type = vt2->type;
+            valuetype->constness += vt2->constness;
+            valuetype->pointer += vt2->pointer;
+            valuetype->reference = vt2->reference;
+            type = type->linkAt(1)->next();
+            continue;
+        }
         if (type->isSigned())
             valuetype->sign = ValueType::Sign::SIGNED;
         else if (type->isUnsigned())
@@ -5317,12 +7515,94 @@ static const Token * parsedecl(const Token *type, ValueType * const valuetype, V
             type->type() && type->type()->isTypeAlias() && type->type()->typeStart &&
             type->type()->typeStart->str() != type->str() && type->type()->typeStart != previousType)
             parsedecl(type->type()->typeStart, valuetype, defaultSignedness, settings);
-        else if (type->str() == "const")
+        else if (Token::Match(type, "const|constexpr"))
             valuetype->constness |= (1 << (valuetype->pointer - pointer0));
-        else if (const Library::Container *container = settings->library.detectContainer(type)) {
-            valuetype->type = ValueType::Type::CONTAINER;
+        else if (Token::simpleMatch(type, "volatile"))
+            valuetype->volatileness |= (1 << (valuetype->pointer - pointer0));
+        else if (settings.clang && type->str().size() > 2 && type->str().find("::") < type->str().find('<')) {
+            TokenList typeTokens(settings, type->isCpp() ? Standards::Language::CPP : Standards::Language::C);
+            std::string::size_type pos1 = 0;
+            do {
+                const std::string::size_type pos2 = type->str().find("::", pos1);
+                if (pos2 == std::string::npos) {
+                    typeTokens.addtoken(type->str().substr(pos1), 0, 0, 0, false);
+                    break;
+                }
+                typeTokens.addtoken(type->str().substr(pos1, pos2 - pos1), 0, 0, 0, false);
+                typeTokens.addtoken("::", 0, 0, 0, false);
+                pos1 = pos2 + 2;
+            } while (pos1 < type->str().size());
+            const Library::Container* container =
+                settings.library.detectContainerOrIterator(typeTokens.front(), &isIterator);
+            if (container) {
+                if (isIterator)
+                    valuetype->type = ValueType::Type::ITERATOR;
+                else
+                    valuetype->type = ValueType::Type::CONTAINER;
+                valuetype->container = container;
+            } else {
+                const Scope *scope = type->scope();
+                valuetype->typeScope = scope->symdb.findScope(typeTokens.front(), scope);
+                if (valuetype->typeScope)
+                    valuetype->type = (scope->type == ScopeType::eClass) ? ValueType::Type::RECORD : ValueType::Type::NONSTD;
+            }
+        } else if (ValueType::Type type_s = ValueType::typeFromString(type->str(), type->isLong())) { // != UNKNOWN_TYPE
+            const ValueType::Type t0 = valuetype->type;
+            valuetype->type = type_s;
+            if (t0 == ValueType::Type::LONG) {
+                if (valuetype->type == ValueType::Type::LONG)
+                    valuetype->type = ValueType::Type::LONGLONG;
+                else if (valuetype->type == ValueType::Type::DOUBLE)
+                    valuetype->type = ValueType::Type::LONGDOUBLE;
+            }
+        } else if (type->str() == "auto") {
+            const ValueType *vt = type->valueType();
+            if (!vt)
+                return nullptr;
+            valuetype->type = vt->type;
+            valuetype->pointer = vt->pointer;
+            valuetype->reference = vt->reference;
+            if (vt->sign != ValueType::Sign::UNKNOWN_SIGN)
+                valuetype->sign = vt->sign;
+            valuetype->constness = vt->constness;
+            valuetype->volatileness = vt->volatileness;
+            valuetype->originalTypeName = vt->originalTypeName;
+            const bool hasConst = Token::simpleMatch(type->previous(), "const");
+            const bool hasVolatile = Token::simpleMatch(type->previous(), "volatile");
+            while (Token::Match(type, "%name%|*|&|&&|::") && !type->variable()) {
+                if (type->str() == "*") {
+                    valuetype->pointer = 1;
+                    if (hasConst)
+                        valuetype->constness = 1;
+                    if (hasVolatile)
+                        valuetype->volatileness = 1;
+                } else if (type->str() == "&") {
+                    valuetype->reference = Reference::LValue;
+                } else if (type->str() == "&&") {
+                    valuetype->reference = Reference::RValue;
+                }
+                if (type->str() == "const")
+                    valuetype->constness |= (1 << valuetype->pointer);
+                if (type->str() == "volatile")
+                    valuetype->volatileness |= (1 << valuetype->pointer);
+                type = type->next();
+            }
+            break;
+        } else if (type->str() == "*")
+            valuetype->pointer++;
+        else if (type->str() == "&")
+            valuetype->reference = Reference::LValue;
+        else if (type->str() == "&&")
+            valuetype->reference = Reference::RValue;
+        else if (type->isStandardType())
+            valuetype->fromLibraryType(type->str(), settings);
+        else if (const Library::Container* container = (cpp ? settings.library.detectContainerOrIterator(type, &isIterator) : nullptr)) {
+            if (isIterator)
+                valuetype->type = ValueType::Type::ITERATOR;
+            else
+                valuetype->type = ValueType::Type::CONTAINER;
             valuetype->container = container;
-            while (Token::Match(type, "%name%|::|<")) {
+            while (Token::Match(type, "%type%|::|<") && type->str() != "const") {
                 if (type->str() == "<" && type->link()) {
                     if (container->type_templateArgNo >= 0) {
                         const Token *templateType = type->next();
@@ -5334,13 +7614,22 @@ static const Token * parsedecl(const Token *type, ValueType * const valuetype, V
                 }
                 type = type->next();
             }
+            if (type && type->str() == "(" && type->previous()->function())
+                // we are past the end of the type
+                type = type->previous();
             continue;
-        } else if (settings->library.isSmartPointer(type)) {
+        } else if (const Library::SmartPointer* smartPointer = (cpp ? settings.library.detectSmartPointer(type) : nullptr)) {
             const Token* argTok = Token::findsimplematch(type, "<");
             if (!argTok)
-                continue;
+                break;
+            valuetype->smartPointer = smartPointer;
             valuetype->smartPointerTypeToken = argTok->next();
             valuetype->smartPointerType = argTok->next()->type();
+            valuetype->type = ValueType::Type::SMART_POINTER;
+            type = argTok->link();
+            if (type)
+                type = type->next();
+            continue;
         } else if (Token::Match(type, "%name% :: %name%")) {
             std::string typestr;
             const Token *end = type;
@@ -5351,48 +7640,36 @@ static const Token * parsedecl(const Token *type, ValueType * const valuetype, V
             typestr += end->str();
             if (valuetype->fromLibraryType(typestr, settings))
                 type = end;
-        } else if (ValueType::Type::UNKNOWN_TYPE != ValueType::typeFromString(type->str(), type->isLong()))
-            valuetype->type = ValueType::typeFromString(type->str(), type->isLong());
-        else if (type->str() == "auto") {
-            const ValueType *vt = type->valueType();
-            if (!vt)
-                return nullptr;
-            valuetype->type = vt->type;
-            valuetype->pointer = vt->pointer;
-            if (vt->sign != ValueType::Sign::UNKNOWN_SIGN)
-                valuetype->sign = vt->sign;
-            valuetype->constness = vt->constness;
-            valuetype->originalTypeName = vt->originalTypeName;
-            while (Token::Match(type, "%name%|*|&|::") && !type->variable())
-                type = type->next();
-            break;
-        } else if (!valuetype->typeScope && (type->str() == "struct" || type->str() == "enum"))
+        } else if (!valuetype->typeScope && (type->str() == "struct" || type->str() == "enum") && valuetype->type != ValueType::Type::SMART_POINTER)
             valuetype->type = type->str() == "struct" ? ValueType::Type::RECORD : ValueType::Type::NONSTD;
-        else if (!valuetype->typeScope && type->type() && type->type()->classScope) {
-            valuetype->type = ValueType::Type::RECORD;
+        else if (!valuetype->typeScope && type->type() && type->type()->classScope && valuetype->type != ValueType::Type::SMART_POINTER) {
+            if (type->type()->classScope->type == ScopeType::eEnum) {
+                valuetype->sign = ValueType::Sign::SIGNED;
+                valuetype->type = getEnumType(type->type()->classScope, settings.platform);
+            } else {
+                valuetype->type = ValueType::Type::RECORD;
+            }
             valuetype->typeScope = type->type()->classScope;
         } else if (type->isName() && valuetype->sign != ValueType::Sign::UNKNOWN_SIGN && valuetype->pointer == 0U)
             return nullptr;
-        else if (type->str() == "*")
-            valuetype->pointer++;
-        else if (type->isStandardType())
-            valuetype->fromLibraryType(type->str(), settings);
-        else if (Token::Match(type->previous(), "!!:: %name% !!::"))
-            valuetype->fromLibraryType(type->str(), settings);
+        else if (Token::Match(type->previous(), "!!:: %name% !!::")) {
+            if (!type->isKeyword())
+                valuetype->fromLibraryType(type->str(), settings);
+        }
         if (!type->originalName().empty())
             valuetype->originalTypeName = type->originalName();
         type = type->next();
+        if (type && type->link() && type->str() == "<")
+            type = type->link()->next();
     }
 
     // Set signedness for integral types..
     if (valuetype->isIntegral() && valuetype->sign == ValueType::Sign::UNKNOWN_SIGN) {
-        if (valuetype->type == ValueType::Type::CHAR)
-            valuetype->sign = defaultSignedness;
-        else if (valuetype->type >= ValueType::Type::SHORT)
+        if (valuetype->type >= ValueType::Type::SHORT)
             valuetype->sign = ValueType::Sign::SIGNED;
     }
 
-    return (type && (valuetype->type != ValueType::Type::UNKNOWN_TYPE || valuetype->pointer > 0)) ? type : nullptr;
+    return (type && (valuetype->type != ValueType::Type::UNKNOWN_TYPE || valuetype->pointer > 0 || valuetype->reference != Reference::None)) ? type : nullptr;
 }
 
 static const Scope *getClassScope(const Token *tok)
@@ -5405,18 +7682,17 @@ static const Scope *getClassScope(const Token *tok)
 static const Function *getOperatorFunction(const Token * const tok)
 {
     const std::string functionName("operator" + tok->str());
-    std::multimap<std::string, const Function *>::const_iterator it;
 
     const Scope *classScope = getClassScope(tok->astOperand1());
     if (classScope) {
-        it = classScope->functionMap.find(functionName);
+        auto it = classScope->functionMap.find(functionName);
         if (it != classScope->functionMap.end())
             return it->second;
     }
 
     classScope = getClassScope(tok->astOperand2());
     if (classScope) {
-        it = classScope->functionMap.find(functionName);
+        auto it = classScope->functionMap.find(functionName);
         if (it != classScope->functionMap.end())
             return it->second;
     }
@@ -5424,9 +7700,61 @@ static const Function *getOperatorFunction(const Token * const tok)
     return nullptr;
 }
 
-void SymbolDatabase::setValueTypeInTokenList(bool reportDebugWarnings)
+static const Function* getFunction(const Token* tok) {
+    if (!tok)
+        return nullptr;
+    if (tok->function() && tok->function()->retDef)
+        return tok->function();
+    if (const Variable* lvar = tok->variable()) { // lambda
+        const Function* lambda{};
+        if (Token::Match(lvar->nameToken()->next(), "; %varid% = [", lvar->declarationId()))
+            lambda = lvar->nameToken()->tokAt(4)->function();
+        else if (Token::simpleMatch(lvar->nameToken()->next(), "{ ["))
+            lambda = lvar->nameToken()->tokAt(2)->function();
+        if (lambda && lambda->retDef)
+            return lambda;
+    }
+    return nullptr;
+}
+
+static int getIntegerConstantMacroWidth(const Token* tok) {
+    if (!Token::Match(tok, "%name% (") || Token::simpleMatch(tok->next()->astOperand2(), ","))
+        return 0;
+    const std::string &name = tok->str();
+    if (name.back() != 'C')
+        return 0;
+    size_t pos = (name[0] == 'U') ? 1 : 0;
+    if (name[pos] != 'I' || name[pos + 1] != 'N' || name[pos + 2] != 'T')
+        return 0;
+    pos += 3;
+    int intnum = 0;
+    if (name[pos] == '8') {
+        ++pos;
+        intnum = 8;
+    }
+    else if (name[pos] == '1' && name[pos + 1] == '6') {
+        pos += 2;
+        intnum = 16;
+    }
+    else if (name[pos] == '3' && name[pos + 1] == '2') {
+        pos += 2;
+        intnum = 32;
+    }
+    else if (name[pos] == '6' && name[pos + 1] == '4') {
+        pos += 2;
+        intnum = 64;
+    }
+    else
+        return 0;
+    if (pos + 2 != name.size() || name[pos] != '_')
+        return 0;
+    return intnum;
+}
+
+void SymbolDatabase::setValueTypeInTokenList(bool reportDebugWarnings, Token *tokens)
 {
-    Token * tokens = const_cast<Tokenizer *>(mTokenizer)->list.front();
+    if (!tokens)
+        tokens = mTokenizer.list.front();
 
     for (Token *tok = tokens; tok; tok = tok->next())
         tok->setValueType(nullptr);
@@ -5442,35 +7770,45 @@ void SymbolDatabase::setValueTypeInTokenList(bool reportDebugWarnings)
                     type = ValueType::Type::LONGDOUBLE;
                 setValueType(tok, ValueType(ValueType::Sign::UNKNOWN_SIGN, type, 0U));
             } else if (MathLib::isInt(tok->str())) {
-                const bool unsignedSuffix = (tok->str().find_last_of("uU") != std::string::npos);
+                const std::string tokStr = MathLib::abs(tok->str());
+                const bool unsignedSuffix = (tokStr.find_last_of("uU") != std::string::npos);
                 ValueType::Sign sign = unsignedSuffix ? ValueType::Sign::UNSIGNED : ValueType::Sign::SIGNED;
-                ValueType::Type type;
-                const MathLib::bigint value = MathLib::toLongNumber(tok->str());
-                if (mSettings->platformType == cppcheck::Platform::Unspecified)
-                    type = ValueType::Type::INT;
-                else if (mSettings->isIntValue(unsignedSuffix ? (value >> 1) : value))
-                    type = ValueType::Type::INT;
-                else if (mSettings->isLongValue(unsignedSuffix ? (value >> 1) : value))
-                    type = ValueType::Type::LONG;
-                else
-                    type = ValueType::Type::LONGLONG;
-                if (MathLib::isIntHex(tok->str()))
-                    sign = ValueType::Sign::UNSIGNED;
-                for (std::size_t pos = tok->str().size() - 1U; pos > 0U; --pos) {
-                    const char suffix = tok->str()[pos];
+                ValueType::Type type = ValueType::Type::INT;
+                const MathLib::biguint value = MathLib::toBigUNumber(tokStr, tok);
+                for (std::size_t pos = tokStr.size() - 1U; pos > 0U; --pos) {
+                    const char suffix = tokStr[pos];
                     if (suffix == 'u' || suffix == 'U')
                         sign = ValueType::Sign::UNSIGNED;
                     else if (suffix == 'l' || suffix == 'L')
                         type = (type == ValueType::Type::INT) ? ValueType::Type::LONG : ValueType::Type::LONGLONG;
-                    else if (pos > 2U && suffix == '4' && tok->str()[pos - 1] == '6' && tok->str()[pos - 2] == 'i') {
+                    else if (pos > 2U && suffix == '4' && tokStr[pos - 1] == '6' && tokStr[pos - 2] == 'i') {
                         type = ValueType::Type::LONGLONG;
                         pos -= 2;
                     } else break;
                 }
+                if (mSettings.platform.type != Platform::Type::Unspecified) {
+                    if (type <= ValueType::Type::INT && mSettings.platform.isIntValue(unsignedSuffix ? (value >> 1) : value))
+                        type = ValueType::Type::INT;
+                    else if (type <= ValueType::Type::INT && !MathLib::isDec(tokStr) && mSettings.platform.isIntValue(value >> 2)) {
+                        type = ValueType::Type::INT;
+                        sign = ValueType::Sign::UNSIGNED;
+                    } else if (type <= ValueType::Type::LONG && mSettings.platform.isLongValue(unsignedSuffix ? (value >> 1) : value))
+                        type = ValueType::Type::LONG;
+                    else if (type <= ValueType::Type::LONG && !MathLib::isDec(tokStr) && mSettings.platform.isLongValue(value >> 2)) {
+                        type = ValueType::Type::LONG;
+                        sign = ValueType::Sign::UNSIGNED;
+                    } else if (mSettings.platform.isLongLongValue(unsignedSuffix ? (value >> 1) : value))
+                        type = ValueType::Type::LONGLONG;
+                    else {
+                        type = ValueType::Type::LONGLONG;
+                        sign = ValueType::Sign::UNSIGNED;
+                    }
+                }
+
                 setValueType(tok, ValueType(sign, type, 0U));
             }
         } else if (tok->isComparisonOp() || tok->tokType() == Token::eLogicalOp) {
-            if (mIsCpp && tok->isComparisonOp() && (getClassScope(tok->astOperand1()) || getClassScope(tok->astOperand2()))) {
+            if (tok->isCpp() && tok->isComparisonOp() && (getClassScope(tok->astOperand1()) || getClassScope(tok->astOperand2()))) {
                 const Function *function = getOperatorFunction(tok);
                 if (function) {
                     ValueType vt;
@@ -5482,16 +7820,31 @@ void SymbolDatabase::setValueTypeInTokenList(bool reportDebugWarnings)
             setValueType(tok, ValueType(ValueType::Sign::UNKNOWN_SIGN, ValueType::Type::BOOL, 0U));
         } else if (tok->isBoolean()) {
             setValueType(tok, ValueType(ValueType::Sign::UNKNOWN_SIGN, ValueType::Type::BOOL, 0U));
-        } else if (tok->tokType() == Token::eChar) {
-            setValueType(tok, ValueType(ValueType::Sign::UNKNOWN_SIGN, tok->isLong() ? ValueType::Type::WCHAR_T : ValueType::Type::CHAR, 0U));
-        } else if (tok->tokType() == Token::eString) {
-            ValueType valuetype(ValueType::Sign::UNKNOWN_SIGN, ValueType::Type::CHAR, 1U, 1U);
-            if (tok->isLong()) {
+        } else if (tok->tokType() == Token::eChar || tok->tokType() == Token::eString) {
+            nonneg int const pointer = tok->tokType() == Token::eChar ? 0 : 1;
+            nonneg int const constness = tok->tokType() == Token::eChar ? 0 : 1;
+            nonneg int const volatileness = 0;
+            ValueType valuetype(ValueType::Sign::UNKNOWN_SIGN, ValueType::Type::CHAR, pointer, constness, volatileness);
+
+            if (tok->isCpp() && mSettings.standards.cpp >= Standards::CPP20 && tok->isUtf8()) {
+                valuetype.originalTypeName = "char8_t";
+                valuetype.fromLibraryType(valuetype.originalTypeName, mSettings);
+            } else if (tok->isUtf16()) {
+                valuetype.originalTypeName = "char16_t";
+                valuetype.fromLibraryType(valuetype.originalTypeName, mSettings);
+            } else if (tok->isUtf32()) {
+                valuetype.originalTypeName = "char32_t";
+                valuetype.fromLibraryType(valuetype.originalTypeName, mSettings);
+            } else if (tok->isLong()) {
                 valuetype.originalTypeName = "wchar_t";
                 valuetype.type = ValueType::Type::WCHAR_T;
+            } else if ((tok->tokType() == Token::eChar) && ((!tok->isCpp() && tok->isCChar()) || (tok->isCMultiChar()))) {
+                valuetype.type = ValueType::Type::INT;
+                valuetype.sign = ValueType::Sign::SIGNED;
             }
             setValueType(tok, valuetype);
-        } else if (tok->str() == "(") {
+        } else if (tok->link() && Token::Match(tok, "(|{")) {
+            const Token* start = tok->astOperand1() ? tok->astOperand1()->findExpressionStartEndTokens().first : nullptr;
             // cast
             if (tok->isCast() && !tok->astOperand2() && Token::Match(tok, "( %name%")) {
                 ValueType valuetype;
@@ -5506,16 +7859,29 @@ void SymbolDatabase::setValueTypeInTokenList(bool reportDebugWarnings)
                     setValueType(tok, valuetype);
             }
 
-            // function
-            else if (tok->previous() && tok->previous()->function() && tok->previous()->function()->retDef) {
+            // Construct smart pointer
+            else if (start && start->isCpp() && mSettings.library.isSmartPointer(start)) {
+                ValueType valuetype;
+                if (parsedecl(start, &valuetype, mDefaultSignedness, mSettings)) {
+                    setValueType(tok, valuetype);
+                    setValueType(tok->astOperand1(), valuetype);
+                }
+
+            }
+
+            // function or lambda
+            else if (const Function* f = getFunction(tok->previous())) {
                 ValueType valuetype;
-                if (parsedecl(tok->previous()->function()->retDef, &valuetype, mDefaultSignedness, mSettings))
+                if (parsedecl(f->retDef, &valuetype, mDefaultSignedness, mSettings))
                     setValueType(tok, valuetype);
             }
 
             else if (Token::simpleMatch(tok->previous(), "sizeof (")) {
-                // TODO: use specified size_t type
                 ValueType valuetype(ValueType::Sign::UNSIGNED, ValueType::Type::LONG, 0U);
+                // TODO: handle via sizeof_size_t instead
+                if (mSettings.platform.type == Platform::Type::Win64)
+                    valuetype.type = ValueType::Type::LONGLONG;
+
                 valuetype.originalTypeName = "size_t";
                 setValueType(tok, valuetype);
 
@@ -5527,43 +7893,134 @@ void SymbolDatabase::setValueTypeInTokenList(bool reportDebugWarnings)
                 }
             }
 
+            // functions from stdint.h
+            else if (const int macroWidth = getIntegerConstantMacroWidth(tok->previous())) {
+                ValueType valuetype;
+                if (macroWidth == mSettings.platform.char_bit)
+                    valuetype.type = ValueType::Type::CHAR;
+                else if (macroWidth == mSettings.platform.short_bit)
+                    valuetype.type = ValueType::Type::SHORT;
+                else if (macroWidth == mSettings.platform.int_bit)
+                    valuetype.type = ValueType::Type::INT;
+                else if (macroWidth == mSettings.platform.long_bit)
+                    valuetype.type = ValueType::Type::LONG;
+                else if (macroWidth == mSettings.platform.long_long_bit)
+                    valuetype.type = ValueType::Type::LONGLONG;
+                else
+                    valuetype.type = ValueType::Type::INT;
+
+                if (tok->strAt(-1)[0] == 'U')
+                    valuetype.sign = ValueType::Sign::UNSIGNED;
+                else
+                    valuetype.sign = ValueType::Sign::SIGNED;
+                setValueType(tok, valuetype);
+            }
+
             // function style cast
             else if (tok->previous() && tok->previous()->isStandardType()) {
                 ValueType valuetype;
-                valuetype.type = ValueType::typeFromString(tok->previous()->str(), tok->previous()->isLong());
+                if (tok->astOperand1() && valuetype.fromLibraryType(tok->astOperand1()->expressionString(), mSettings)) {
+                    setValueType(tok, valuetype);
+                    continue;
+                }
+
+                valuetype.type = ValueType::typeFromString(tok->strAt(-1), tok->previous()->isLong());
                 if (tok->previous()->isUnsigned())
                     valuetype.sign = ValueType::Sign::UNSIGNED;
                 else if (tok->previous()->isSigned())
                     valuetype.sign = ValueType::Sign::SIGNED;
+                else if (valuetype.isIntegral() && valuetype.type != ValueType::UNKNOWN_INT)
+                    valuetype.sign = (valuetype.type == ValueType::Type::CHAR) ? mDefaultSignedness : ValueType::Sign::SIGNED;
                 setValueType(tok, valuetype);
             }
 
-            // constructor
-            else if (tok->previous() && tok->previous()->type() && tok->previous()->type()->classScope) {
+            // constructor call
+            else if (tok->previous() && tok->previous()->function() && tok->previous()->function()->isConstructor()) {
                 ValueType valuetype;
                 valuetype.type = ValueType::RECORD;
-                valuetype.typeScope = tok->previous()->type()->classScope;
+                valuetype.typeScope = tok->previous()->function()->tokenDef->scope();
                 setValueType(tok, valuetype);
             }
 
-            // library function
+            else if (Token::simpleMatch(tok->previous(), "= {") && tok->tokAt(-2) && tok->tokAt(-2)->valueType()) {
+                ValueType vt = *tok->tokAt(-2)->valueType();
+                setValueType(tok, vt);
+            }
+
+            // library type/function
             else if (tok->previous()) {
-                const std::string& typestr(mSettings->library.returnValueType(tok->previous()));
+                // Aggregate constructor
+                if (Token::Match(tok->previous(), "%name%")) {
+                    ValueType valuetype;
+                    if (parsedecl(tok->previous(), &valuetype, mDefaultSignedness, mSettings)) {
+                        if (valuetype.typeScope) {
+                            setValueType(tok, valuetype);
+                            continue;
+                        }
+                    }
+                }
+                if (tok->isCpp() && tok->astParent() && Token::Match(tok->astOperand1(), "%name%|::")) {
+                    const Token *typeStartToken = tok->astOperand1();
+                    while (typeStartToken && typeStartToken->str() == "::")
+                        typeStartToken = typeStartToken->astOperand1();
+                    if (mSettings.library.detectContainerOrIterator(typeStartToken) ||
+                        mSettings.library.detectSmartPointer(typeStartToken)) {
+                        ValueType vt;
+                        if (parsedecl(typeStartToken, &vt, mDefaultSignedness, mSettings)) {
+                            setValueType(tok, vt);
+                            continue;
+                        }
+                    }
+
+                    const std::string e = tok->astOperand1()->expressionString();
+
+                    if ((e == "std::make_shared" || e == "std::make_unique") && Token::Match(tok->astOperand1(), ":: %name% < %name%")) {
+                        ValueType vt;
+                        parsedecl(tok->astOperand1()->tokAt(3), &vt, mDefaultSignedness, mSettings);
+                        if (vt.typeScope) {
+                            vt.smartPointerType = vt.typeScope->definedType;
+                            vt.typeScope = nullptr;
+                        }
+                        if (e == "std::make_shared" && mSettings.library.smartPointers().count("std::shared_ptr") > 0)
+                            vt.smartPointer = &mSettings.library.smartPointers().at("std::shared_ptr");
+                        if (e == "std::make_unique" && mSettings.library.smartPointers().count("std::unique_ptr") > 0)
+                            vt.smartPointer = &mSettings.library.smartPointers().at("std::unique_ptr");
+                        vt.type = ValueType::Type::SMART_POINTER;
+                        vt.smartPointerTypeToken = tok->astOperand1()->tokAt(3);
+                        setValueType(tok, vt);
+                        continue;
+                    }
+
+                    ValueType podtype;
+                    if (podtype.fromLibraryType(e, mSettings)) {
+                        setValueType(tok, podtype);
+                        continue;
+                    }
+                }
+
+                const std::string& typestr(mSettings.library.returnValueType(tok->previous()));
                 if (!typestr.empty()) {
                     ValueType valuetype;
-                    if (valuetype.fromLibraryType(typestr, mSettings)) {
+                    TokenList tokenList(mSettings, tok->isCpp() ? Standards::Language::CPP : Standards::Language::C);
+                    const std::string str(typestr+";");
+                    tokenList.createTokensFromBuffer(str.data(), str.size()); // TODO: check result?
+                    tokenList.simplifyStdType();
+                    if (parsedecl(tokenList.front(), &valuetype, mDefaultSignedness, mSettings)) {
+                        valuetype.originalTypeName = typestr;
                         setValueType(tok, valuetype);
                     }
                 }
 
-                if (typestr.empty() || typestr == "iterator") {
+                //Is iterator fetching function invoked on container?
+                const bool isReturnIter = typestr == "iterator";
+                if (typestr.empty() || isReturnIter) {
                     if (Token::simpleMatch(tok->astOperand1(), ".") &&
                         tok->astOperand1()->astOperand1() &&
                         tok->astOperand1()->astOperand2() &&
                         tok->astOperand1()->astOperand1()->valueType() &&
                         tok->astOperand1()->astOperand1()->valueType()->container) {
                         const Library::Container *cont = tok->astOperand1()->astOperand1()->valueType()->container;
-                        const std::map<std::string, Library::Container::Function>::const_iterator it = cont->functions.find(tok->astOperand1()->astOperand2()->str());
+                        const auto it = cont->functions.find(tok->astOperand1()->astOperand2()->str());
                         if (it != cont->functions.end()) {
                             if (it->second.yield == Library::Container::Yield::START_ITERATOR ||
                                 it->second.yield == Library::Container::Yield::END_ITERATOR ||
@@ -5571,36 +8028,108 @@ void SymbolDatabase::setValueTypeInTokenList(bool reportDebugWarnings)
                                 ValueType vt;
                                 vt.type = ValueType::Type::ITERATOR;
                                 vt.container = cont;
+                                vt.containerTypeToken =
+                                    tok->astOperand1()->astOperand1()->valueType()->containerTypeToken;
                                 setValueType(tok, vt);
+                                continue;
+                            }
+                        }
+                        //Is iterator fetching function called?
+                    } else if (Token::simpleMatch(tok->astOperand1(), "::") &&
+                               tok->astOperand2() &&
+                               tok->astOperand2()->isVariable()) {
+                        const auto* const paramVariable = tok->astOperand2()->variable();
+                        if (!paramVariable ||
+                            !paramVariable->valueType() ||
+                            !paramVariable->valueType()->container) {
+                            continue;
+                        }
+
+                        const auto yield = astFunctionYield(tok->previous(), mSettings);
+                        if (yield == Library::Container::Yield::START_ITERATOR ||
+                            yield == Library::Container::Yield::END_ITERATOR ||
+                            yield == Library::Container::Yield::ITERATOR) {
+                            ValueType vt;
+                            vt.type = ValueType::Type::ITERATOR;
+                            vt.container = paramVariable->valueType()->container;
+                            vt.containerTypeToken = paramVariable->valueType()->containerTypeToken;
+                            setValueType(tok, vt);
+                        }
+                    }
+                    if (isReturnIter) {
+                        const std::vector<const Token*> args = getArguments(tok);
+                        if (!args.empty()) {
+                            const Library::ArgumentChecks::IteratorInfo* info = mSettings.library.getArgIteratorInfo(tok->previous(), 1);
+                            if (info && info->it) {
+                                const Token* contTok = args[0];
+                                if (Token::simpleMatch(args[0]->astOperand1(), ".") && args[0]->astOperand1()->astOperand1()) // .begin()
+                                    contTok = args[0]->astOperand1()->astOperand1();
+                                else if (Token::simpleMatch(args[0], "(") && args[0]->astOperand2()) // std::begin()
+                                    contTok = args[0]->astOperand2();
+                                while (Token::simpleMatch(contTok, "[")) // move to container token
+                                    contTok = contTok->astOperand1();
+                                if (Token::simpleMatch(contTok, "."))
+                                    contTok = contTok->astOperand2();
+                                if (contTok && contTok->variable() && contTok->variable()->valueType() && contTok->variable()->valueType()->container) {
+                                    ValueType vt;
+                                    vt.type = ValueType::Type::ITERATOR;
+                                    vt.container = contTok->variable()->valueType()->container;
+                                    vt.containerTypeToken = contTok->variable()->valueType()->containerTypeToken;
+                                    setValueType(tok, vt);
+                                } else if (Token::simpleMatch(contTok, "(") && contTok->astOperand1() && contTok->astOperand1()->function()) {
+                                    const Function* func = contTok->astOperand1()->function();
+                                    if (const ValueType* funcVt = func->tokenDef->next()->valueType()) {
+                                        ValueType vt;
+                                        vt.type = ValueType::Type::ITERATOR;
+                                        vt.container = funcVt->container;
+                                        vt.containerTypeToken = funcVt->containerTypeToken;
+                                        setValueType(tok, vt);
+                                    }
+                                }
                             }
                         }
                     }
                     continue;
                 }
-                TokenList tokenList(mSettings);
-                std::istringstream istr(typestr+";");
-                if (tokenList.createTokens(istr)) {
+                TokenList tokenList(mSettings, tok->isCpp() ? Standards::Language::CPP : Standards::Language::C);
+                const std::string str(typestr+";");
+                if (tokenList.createTokensFromBuffer(str.data(), str.size())) {
                     ValueType vt;
                     tokenList.simplifyPlatformTypes();
                     tokenList.simplifyStdType();
                     if (parsedecl(tokenList.front(), &vt, mDefaultSignedness, mSettings)) {
+                        vt.originalTypeName = typestr;
                         setValueType(tok, vt);
                     }
                 }
             }
+        } else if (tok->str() == "return") {
+            const Scope *functionScope = tok->scope();
+            while (functionScope && functionScope->isExecutable() && functionScope->type != ScopeType::eLambda && functionScope->type != ScopeType::eFunction)
+                functionScope = functionScope->nestedIn;
+            if (functionScope && functionScope->type == ScopeType::eFunction && functionScope->function &&
+                functionScope->function->retDef) {
+                ValueType vt = ValueType::parseDecl(functionScope->function->retDef, mSettings);
+                setValueType(tok, vt);
+                if (Token::simpleMatch(tok, "return {"))
+                    setValueType(tok->next(), vt);
+            }
         } else if (tok->variable()) {
             setValueType(tok, *tok->variable());
+            if (!tok->variable()->valueType() && tok->valueType())
+                const_cast<Variable*>(tok->variable())->setValueType(*tok->valueType());
         } else if (tok->enumerator()) {
             setValueType(tok, *tok->enumerator());
-        } else if (mIsCpp && tok->str() == "new") {
+        } else if (tok->isKeyword() && tok->str() == "new") {
             const Token *typeTok = tok->next();
             if (Token::Match(typeTok, "( std| ::| nothrow )"))
                 typeTok = typeTok->link()->next();
-            if (const Library::Container *c = mSettings->library.detectContainer(typeTok)) {
+            bool isIterator = false;
+            if (const Library::Container* c = mSettings.library.detectContainerOrIterator(typeTok, &isIterator)) {
                 ValueType vt;
                 vt.pointer = 1;
                 vt.container = c;
-                vt.type = ValueType::Type::CONTAINER;
+                vt.type = isIterator ? ValueType::Type::ITERATOR : ValueType::Type::CONTAINER;
                 setValueType(tok, vt);
                 continue;
             }
@@ -5631,20 +8160,45 @@ void SymbolDatabase::setValueTypeInTokenList(bool reportDebugWarnings)
                     vt.sign = (vt.type == ValueType::Type::CHAR) ? mDefaultSignedness : ValueType::Sign::SIGNED;
             }
             setValueType(tok, vt);
-        } else if (tok->str() == "return" && tok->scope()) {
-            const Function *function = tok->scope()->function;
-            if (function && function->retDef) {
+            if (Token::simpleMatch(tok->astOperand1(), "(")) {
+                vt.pointer--;
+                setValueType(tok->astOperand1(), vt);
+            }
+        } else if (tok->isKeyword() && tok->str() == "return" && tok->scope()) {
+            const Scope* fscope = tok->scope();
+            while (fscope && !fscope->function)
+                fscope = fscope->nestedIn;
+            if (fscope && fscope->function && fscope->function->retDef) {
                 ValueType vt;
-                parsedecl(function->retDef, &vt, mDefaultSignedness, mSettings);
+                parsedecl(fscope->function->retDef, &vt, mDefaultSignedness, mSettings);
+                setValueType(tok, vt);
+            }
+        } else if (tok->isKeyword() && tok->str() == "this" && tok->scope()->isExecutable()) {
+            const Scope* fscope = tok->scope();
+            while (fscope && !fscope->function)
+                fscope = fscope->nestedIn;
+            const Scope* defScope = fscope && fscope->function->tokenDef ? fscope->function->tokenDef->scope() : nullptr;
+            if (defScope && defScope->isClassOrStruct()) {
+                ValueType vt(ValueType::Sign::UNKNOWN_SIGN, ValueType::Type::RECORD, 1);
+                vt.typeScope = defScope;
+                if (fscope->function->isConst())
+                    vt.constness = 1;
+                if (fscope->function->isVolatile())
+                    vt.volatileness = 1;
                 setValueType(tok, vt);
             }
         }
     }
 
-    if (reportDebugWarnings && mSettings->debugwarnings) {
+    if (reportDebugWarnings && mSettings.debugwarnings) {
         for (Token *tok = tokens; tok; tok = tok->next()) {
-            if (tok->str() == "auto" && !tok->valueType())
-                debugMessage(tok, "auto token with no type.");
+            if (tok->str() == "auto" && !tok->valueType()) {
+                if (Token::Match(tok->next(), "%name% ; %name% = [") && isLambdaCaptureList(tok->tokAt(5)))
+                    continue;
+                if (Token::Match(tok->next(), "%name% {|= [") && isLambdaCaptureList(tok->tokAt(3)))
+                    continue;
+                debugMessage(tok, "autoNoType", "auto token with no type.");
+            }
         }
     }
 
@@ -5655,10 +8209,10 @@ void SymbolDatabase::setValueTypeInTokenList(bool reportDebugWarnings)
     createSymbolDatabaseSetVariablePointers();
 }
 
-ValueType ValueType::parseDecl(const Token *type, const Settings *settings)
+ValueType ValueType::parseDecl(const Token *type, const Settings &settings)
 {
     ValueType vt;
-    parsedecl(type, &vt, settings->defaultSign == 'u' ? Sign::UNSIGNED : Sign::SIGNED, settings);
+    parsedecl(type, &vt, settings.platform.defaultSign == 'u' ? Sign::UNSIGNED : Sign::SIGNED, settings);
     return vt;
 }
 
@@ -5685,39 +8239,44 @@ ValueType::Type ValueType::typeFromString(const std::string &typestr, bool longT
     return ValueType::Type::UNKNOWN_TYPE;
 }
 
-bool ValueType::fromLibraryType(const std::string &typestr, const Settings *settings)
+bool ValueType::fromLibraryType(const std::string &typestr, const Settings &settings)
 {
-    const Library::PodType* podtype = settings->library.podtype(typestr);
+    const Library::PodType* podtype = settings.library.podtype(typestr);
     if (podtype && (podtype->sign == 's' || podtype->sign == 'u')) {
         if (podtype->size == 1)
             type = ValueType::Type::CHAR;
-        else if (podtype->size == settings->sizeof_int)
+        else if (podtype->size == settings.platform.sizeof_int)
             type = ValueType::Type::INT;
-        else if (podtype->size == settings->sizeof_short)
+        else if (podtype->size == settings.platform.sizeof_short)
             type = ValueType::Type::SHORT;
-        else if (podtype->size == settings->sizeof_long)
+        else if (podtype->size == settings.platform.sizeof_long)
             type = ValueType::Type::LONG;
-        else if (podtype->size == settings->sizeof_long_long)
+        else if (podtype->size == settings.platform.sizeof_long_long)
             type = ValueType::Type::LONGLONG;
-        else if (podtype->stdtype == Library::PodType::BOOL)
+        else if (podtype->stdtype == Library::PodType::Type::BOOL)
             type = ValueType::Type::BOOL;
-        else if (podtype->stdtype == Library::PodType::CHAR)
+        else if (podtype->stdtype == Library::PodType::Type::CHAR)
             type = ValueType::Type::CHAR;
-        else if (podtype->stdtype == Library::PodType::SHORT)
+        else if (podtype->stdtype == Library::PodType::Type::SHORT)
             type = ValueType::Type::SHORT;
-        else if (podtype->stdtype == Library::PodType::INT)
+        else if (podtype->stdtype == Library::PodType::Type::INT)
             type = ValueType::Type::INT;
-        else if (podtype->stdtype == Library::PodType::LONG)
+        else if (podtype->stdtype == Library::PodType::Type::LONG)
             type = ValueType::Type::LONG;
-        else if (podtype->stdtype == Library::PodType::LONGLONG)
+        else if (podtype->stdtype == Library::PodType::Type::LONGLONG)
             type = ValueType::Type::LONGLONG;
         else
             type = ValueType::Type::UNKNOWN_INT;
         sign = (podtype->sign == 'u') ? ValueType::UNSIGNED : ValueType::SIGNED;
         return true;
     }
+    if (podtype && podtype->stdtype == Library::PodType::Type::NO) {
+        type = ValueType::Type::POD;
+        sign = ValueType::UNKNOWN_SIGN;
+        return true;
+    }
 
-    const Library::PlatformType *platformType = settings->library.platform_type(typestr, settings->platformString());
+    const Library::PlatformType *platformType = settings.library.platform_type(typestr, settings.platform.toString());
     if (platformType) {
         if (platformType->mType == "char")
             type = ValueType::Type::CHAR;
@@ -5726,28 +8285,29 @@ bool ValueType::fromLibraryType(const std::string &typestr, const Settings *sett
         else if (platformType->mType == "wchar_t")
             type = ValueType::Type::WCHAR_T;
         else if (platformType->mType == "int")
-            type = platformType->_long ? ValueType::Type::LONG : ValueType::Type::INT;
+            type = platformType->mLong ? ValueType::Type::LONG : ValueType::Type::INT;
         else if (platformType->mType == "long")
-            type = platformType->_long ? ValueType::Type::LONGLONG : ValueType::Type::LONG;
-        if (platformType->_signed)
+            type = platformType->mLong ? ValueType::Type::LONGLONG : ValueType::Type::LONG;
+        if (platformType->mSigned)
             sign = ValueType::SIGNED;
-        else if (platformType->_unsigned)
+        else if (platformType->mUnsigned)
             sign = ValueType::UNSIGNED;
-        if (platformType->_pointer)
+        if (platformType->mPointer)
             pointer = 1;
-        if (platformType->_ptr_ptr)
+        if (platformType->mPtrPtr)
             pointer = 2;
-        if (platformType->_const_ptr)
+        if (platformType->mConstPtr)
             constness = 1;
         return true;
-    } else if (!podtype && (typestr == "size_t" || typestr == "std::size_t")) {
+    }
+    if (!podtype && (typestr == "size_t" || typestr == "std::size_t")) {
         originalTypeName = "size_t";
         sign = ValueType::UNSIGNED;
-        if (settings->sizeof_size_t == settings->sizeof_long)
+        if (settings.platform.sizeof_size_t == settings.platform.sizeof_long)
             type = ValueType::Type::LONG;
-        else if (settings->sizeof_size_t == settings->sizeof_long_long)
+        else if (settings.platform.sizeof_size_t == settings.platform.sizeof_long_long)
             type = ValueType::Type::LONGLONG;
-        else if (settings->sizeof_size_t == settings->sizeof_int)
+        else if (settings.platform.sizeof_size_t == settings.platform.sizeof_int)
             type = ValueType::Type::INT;
         else
             type = ValueType::Type::UNKNOWN_INT;
@@ -5759,116 +8319,332 @@ bool ValueType::fromLibraryType(const std::string &typestr, const Settings *sett
 
 std::string ValueType::dump() const
 {
-    std::ostringstream ret;
+    std::string ret;
     switch (type) {
     case UNKNOWN_TYPE:
         return "";
     case NONSTD:
-        ret << "valueType-type=\"nonstd\"";
+        ret += "valueType-type=\"nonstd\"";
+        break;
+    case POD:
+        ret += "valueType-type=\"pod\"";
         break;
     case RECORD:
-        ret << "valueType-type=\"record\"";
+        ret += "valueType-type=\"record\"";
         break;
-    case CONTAINER:
-        ret << "valueType-type=\"container\"";
+    case SMART_POINTER:
+        ret += "valueType-type=\"smart-pointer\"";
         break;
+    case CONTAINER: {
+        ret += "valueType-type=\"container\"";
+        ret += " valueType-containerId=\"";
+        ret += id_string(container);
+        ret += "\"";
+        break;
+    }
     case ITERATOR:
-        ret << "valueType-type=\"iterator\"";
+        ret += "valueType-type=\"iterator\"";
         break;
     case VOID:
-        ret << "valueType-type=\"void\"";
+        ret += "valueType-type=\"void\"";
         break;
     case BOOL:
-        ret << "valueType-type=\"bool\"";
+        ret += "valueType-type=\"bool\"";
         break;
     case CHAR:
-        ret << "valueType-type=\"char\"";
+        ret += "valueType-type=\"char\"";
         break;
     case SHORT:
-        ret << "valueType-type=\"short\"";
+        ret += "valueType-type=\"short\"";
         break;
     case WCHAR_T:
-        ret << "valueType-type=\"wchar_t\"";
+        ret += "valueType-type=\"wchar_t\"";
         break;
     case INT:
-        ret << "valueType-type=\"int\"";
+        ret += "valueType-type=\"int\"";
         break;
     case LONG:
-        ret << "valueType-type=\"long\"";
+        ret += "valueType-type=\"long\"";
         break;
     case LONGLONG:
-        ret << "valueType-type=\"long long\"";
+        ret += "valueType-type=\"long long\"";
         break;
     case UNKNOWN_INT:
-        ret << "valueType-type=\"unknown int\"";
+        ret += "valueType-type=\"unknown int\"";
         break;
     case FLOAT:
-        ret << "valueType-type=\"float\"";
+        ret += "valueType-type=\"float\"";
         break;
     case DOUBLE:
-        ret << "valueType-type=\"double\"";
+        ret += "valueType-type=\"double\"";
         break;
     case LONGDOUBLE:
-        ret << "valueType-type=\"long double\"";
+        ret += "valueType-type=\"long double\"";
         break;
-    };
+    }
 
     switch (sign) {
     case Sign::UNKNOWN_SIGN:
         break;
     case Sign::SIGNED:
-        ret << " valueType-sign=\"signed\"";
+        ret += " valueType-sign=\"signed\"";
         break;
     case Sign::UNSIGNED:
-        ret << " valueType-sign=\"unsigned\"";
+        ret += " valueType-sign=\"unsigned\"";
         break;
-    };
+    }
+
+    if (bits >= 0) {
+        ret += " valueType-bits=\"";
+        ret += std::to_string(bits);
+        ret += '\"';
+    }
+
+    if (pointer > 0) {
+        ret += " valueType-pointer=\"";
+        ret += std::to_string(pointer);
+        ret += '\"';
+    }
 
-    if (bits > 0)
-        ret << " valueType-bits=\"" << bits << '\"';
+    if (constness > 0) {
+        ret += " valueType-constness=\"";
+        ret += std::to_string(constness);
+        ret += '\"';
+    }
 
-    if (pointer > 0)
-        ret << " valueType-pointer=\"" << pointer << '\"';
+    if (volatileness > 0) {
+        ret += " valueType-volatileness=\"";
+        ret += std::to_string(volatileness);
+        ret += '\"';
+    }
 
-    if (constness > 0)
-        ret << " valueType-constness=\"" << constness << '\"';
+    if (reference == Reference::None)
+        ret += " valueType-reference=\"None\"";
+    else if (reference == Reference::LValue)
+        ret += " valueType-reference=\"LValue\"";
+    else if (reference == Reference::RValue)
+        ret += " valueType-reference=\"RValue\"";
 
-    if (typeScope)
-        ret << " valueType-typeScope=\"" << typeScope << '\"';
+    if (typeScope) {
+        ret += " valueType-typeScope=\"";
+        ret += id_string(typeScope);
+        ret += '\"';
+    }
 
-    if (!originalTypeName.empty())
-        ret << " valueType-originalTypeName=\"" << originalTypeName << '\"';
+    if (!originalTypeName.empty()) {
+        ret += " valueType-originalTypeName=\"";
+        ret += ErrorLogger::toxml(originalTypeName);
+        ret += '\"';
+    }
 
-    return ret.str();
+    return ret;
 }
 
-MathLib::bigint ValueType::typeSize(const cppcheck::Platform &platform) const
+bool ValueType::isConst(nonneg int indirect) const
 {
-    switch (type) {
-    case ValueType::Type::BOOL:
-        return platform.sizeof_bool;
-    case ValueType::Type::CHAR:
+    if (indirect > pointer)
+        return false;
+    return constness & (1 << (pointer - indirect));
+}
+
+bool ValueType::isVolatile(nonneg int indirect) const
+{
+    if (indirect > pointer)
+        return false;
+    return volatileness & (1 << (pointer - indirect));
+}
+
+namespace {
+    struct Result
+    {
+        size_t total;
+        bool success;
+    };
+}
+
+template<class F>
+static Result accumulateStructMembers(const Scope* scope, F f, ValueType::Accuracy accuracy)
+{
+    size_t total = 0;
+    std::set<const Scope*> anonScopes;
+    for (const Variable& var : scope->varlist) {
+        if (var.isStatic())
+            continue;
+        const MathLib::bigint bits = var.nameToken() ? var.nameToken()->bits() : -1;
+        if (const ValueType* vt = var.valueType()) {
+            if (vt->type == ValueType::Type::RECORD && vt->typeScope == scope)
+                return {0, false};
+            const MathLib::bigint dim = std::accumulate(var.dimensions().cbegin(), var.dimensions().cend(), MathLib::bigint(1), [](MathLib::bigint i1, const Dimension& dim) {
+                return i1 * dim.num;
+            });
+            if (var.nameToken()->scope() != scope && var.nameToken()->scope()->definedType) { // anonymous union
+                const auto ret = anonScopes.insert(var.nameToken()->scope());
+                if (ret.second)
+                    total = f(total, *vt, dim, bits);
+            }
+            else
+                total = f(total, *vt, dim, bits);
+        }
+        if (accuracy == ValueType::Accuracy::ExactOrZero && total == 0 && bits == -1)
+            return {0, false};
+    }
+    return {total, true};
+}
+
+
+static size_t bitCeil(size_t x)
+{
+    if (x <= 1)
+        return 1;
+    --x;
+    x |= x >> 1;
+    x |= x >> 2;
+    x |= x >> 4;
+    x |= x >> 8;
+    x |= x >> 16;
+    x |= x >> 32;
+    return x + 1;
+}
+
+static size_t getAlignOf(const ValueType& vt, const Settings& settings, ValueType::Accuracy accuracy, ValueType::SizeOf sizeOf, int maxRecursion = 0)
+{
+    if (maxRecursion == settings.vfOptions.maxAlignOfRecursion) {
+        // TODO: add bailout message
+        return 0;
+    }
+    if ((vt.pointer && sizeOf == ValueType::SizeOf::Pointer) || vt.reference != Reference::None || vt.isPrimitive()) {
+        auto align = vt.getSizeOf(settings, accuracy, ValueType::SizeOf::Pointer);
+        return align == 0 ? 0 : bitCeil(align);
+    }
+    if (vt.type == ValueType::Type::RECORD && vt.typeScope) {
+        auto accHelper = [&](size_t max, const ValueType& vt2, size_t /*dim*/, MathLib::bigint /*bits*/) {
+            size_t a = getAlignOf(vt2, settings, accuracy, ValueType::SizeOf::Pointer, ++maxRecursion);
+            return std::max(max, a);
+        };
+        Result result = accumulateStructMembers(vt.typeScope, accHelper, accuracy);
+        size_t total = result.total;
+        if (const Type* dt = vt.typeScope->definedType) {
+            total = std::accumulate(dt->derivedFrom.begin(), dt->derivedFrom.end(), total, [&](size_t v, const Type::BaseInfo& bi) {
+                if (bi.type && bi.type->classScope)
+                    v += accumulateStructMembers(bi.type->classScope, accHelper, accuracy).total;
+                return v;
+            });
+        }
+        return result.success ? std::max<size_t>(1, total) : total;
+    }
+    if (vt.type == ValueType::Type::CONTAINER)
+        return settings.platform.sizeof_pointer; // Just guess
+    return 0;
+}
+
+size_t ValueType::getSizeOf( const Settings& settings, Accuracy accuracy, SizeOf sizeOf, int maxRecursion) const
+{
+    if (maxRecursion == settings.vfOptions.maxSizeOfRecursion) {
+        // TODO: add bailout message
+        return 0;
+    }
+    const auto& platform = settings.platform;
+    if (sizeOf == SizeOf::Pointer && (pointer || reference != Reference::None))
+        return platform.sizeof_pointer;
+    if (type == ValueType::Type::BOOL || type == ValueType::Type::CHAR)
         return 1;
-    case ValueType::Type::SHORT:
+    if (type == ValueType::Type::SHORT)
         return platform.sizeof_short;
-    case ValueType::Type::WCHAR_T:
+    if (type == ValueType::Type::WCHAR_T)
         return platform.sizeof_wchar_t;
-    case ValueType::Type::INT:
+    if (type == ValueType::Type::INT)
         return platform.sizeof_int;
-    case ValueType::Type::LONG:
+    if (type == ValueType::Type::LONG)
         return platform.sizeof_long;
-    case ValueType::Type::LONGLONG:
+    if (type == ValueType::Type::LONGLONG)
         return platform.sizeof_long_long;
-    case ValueType::Type::FLOAT:
+    if (type == ValueType::Type::FLOAT)
         return platform.sizeof_float;
-    case ValueType::Type::DOUBLE:
+    if (type == ValueType::Type::DOUBLE)
         return platform.sizeof_double;
-    case ValueType::Type::LONGDOUBLE:
+    if (type == ValueType::Type::LONGDOUBLE)
         return platform.sizeof_long_double;
-    default:
-        return 0;
-    };
+    if (type == ValueType::Type::CONTAINER)
+        return 3 * platform.sizeof_pointer; // Just guess
+    if (type == ValueType::Type::RECORD && typeScope) {
+        size_t currentBitCount = 0;
+        size_t currentBitfieldAlloc = 0;
+        auto accHelper = [&](size_t total, const ValueType& vt2, size_t dim, MathLib::bigint nBits) -> size_t {
+            const size_t charBit = settings.platform.char_bit;
+            size_t n = vt2.getSizeOf(settings, accuracy, SizeOf::Pointer, ++maxRecursion);
+            size_t a = getAlignOf(vt2, settings, accuracy, SizeOf::Pointer);
+            if (n == 0 || a == 0)
+                return accuracy == Accuracy::ExactOrZero ? 0 : total;
+            if (nBits == 0) {
+                if (currentBitfieldAlloc == 0) {
+                    nBits = n * charBit;
+                } else {
+                    nBits = (currentBitfieldAlloc * charBit) - currentBitCount;
+                }
+            }
+            if (nBits > 0) {
+                size_t ret = total;
+                if (currentBitfieldAlloc == 0) {
+                    currentBitfieldAlloc = n;
+                    currentBitCount = 0;
+                } else if (currentBitCount + nBits > charBit * currentBitfieldAlloc) {
+                    ret += currentBitfieldAlloc;
+                    currentBitfieldAlloc = n;
+                    currentBitCount = 0;
+                }
+                while (nBits > charBit * currentBitfieldAlloc) {
+                    ret += currentBitfieldAlloc;
+                    nBits -= charBit * currentBitfieldAlloc;
+                }
+                currentBitCount += nBits;
+                return ret;
+            }
+            n *= dim;
+            size_t padding = (a - (total % a)) % a;
+            if (currentBitCount > 0) {
+                bool fitsInBitfield = currentBitCount + (n * charBit) <= currentBitfieldAlloc * charBit;
+                bool isAligned = currentBitCount % (charBit * a) == 0;
+                if (vt2.isIntegral() && fitsInBitfield && isAligned) {
+                    currentBitCount += charBit * n;
+                    return total;
+                }
+                n += currentBitfieldAlloc;
+                currentBitfieldAlloc = 0;
+                currentBitCount = 0;
+            }
+            return typeScope->type == ScopeType::eUnion ? std::max(total, n) : total + padding + n;
+        };
+        Result result = accumulateStructMembers(typeScope, accHelper, accuracy);
+        size_t total = result.total;
+        if (currentBitCount > 0)
+            total += currentBitfieldAlloc;
+        if (const ::Type* dt = typeScope->definedType) {
+            total = std::accumulate(dt->derivedFrom.begin(), dt->derivedFrom.end(), total, [&](size_t v, const ::Type::BaseInfo& bi) {
+                if (bi.type && bi.type->classScope)
+                    v += accumulateStructMembers(bi.type->classScope, accHelper, accuracy).total;
+                return v;
+            });
+        }
+        if (accuracy == Accuracy::ExactOrZero && total == 0 && !result.success)
+            return 0;
+        total = std::max(size_t{1}, total);
+        size_t align = getAlignOf(*this, settings, accuracy, sizeOf);
+        if (align == 0)
+            return accuracy == Accuracy::ExactOrZero ? 0 : total;
+        total += (align - (total % align)) % align;
+        return total;
+    }
+    return 0;
+}
 
+bool ValueType::isTypeEqual(const ValueType* that) const
+{
+    if (!that)
+        return false;
+    auto tie = [](const ValueType* vt) {
+        return std::tie(vt->type, vt->container, vt->pointer, vt->typeScope, vt->smartPointer);
+    };
+    return tie(this) == tie(that);
 }
 
 std::string ValueType::str() const
@@ -5876,6 +8652,8 @@ std::string ValueType::str() const
     std::string ret;
     if (constness & 1)
         ret = " const";
+    if (volatileness & 1)
+        ret = " volatile";
     if (type == VOID)
         ret += " void";
     else if (isIntegral()) {
@@ -5908,25 +8686,43 @@ std::string ValueType::str() const
     else if ((type == ValueType::Type::NONSTD || type == ValueType::Type::RECORD) && typeScope) {
         std::string className(typeScope->className);
         const Scope *scope = typeScope->definedType ? typeScope->definedType->enclosingScope : typeScope->nestedIn;
-        while (scope && scope->type != Scope::eGlobal) {
-            if (scope->type == Scope::eClass || scope->type == Scope::eStruct || scope->type == Scope::eNamespace)
+        while (scope && scope->type != ScopeType::eGlobal) {
+            if (scope->type == ScopeType::eClass || scope->type == ScopeType::eStruct || scope->type == ScopeType::eNamespace)
                 className = scope->className + "::" + className;
-            scope = scope->definedType ? scope->definedType->enclosingScope : scope->nestedIn;
+            scope = (scope->definedType && scope->definedType->enclosingScope) ? scope->definedType->enclosingScope : scope->nestedIn;
         }
         ret += ' ' + className;
     } else if (type == ValueType::Type::CONTAINER && container) {
         ret += " container(" + container->startPattern + ')';
     } else if (type == ValueType::Type::ITERATOR && container) {
         ret += " iterator(" + container->startPattern + ')';
-    } else if (smartPointerType) {
-        ret += " smart-pointer<" + smartPointerType->name() + ">";
+    } else if (type == ValueType::Type::SMART_POINTER && smartPointer) {
+        ret += " smart-pointer(" + smartPointer->name + ")";
     }
     for (unsigned int p = 0; p < pointer; p++) {
         ret += " *";
         if (constness & (2 << p))
             ret += " const";
-    }
-    return ret.empty() ? ret : ret.substr(1);
+        if (volatileness & (2 << p))
+            ret += " volatile";
+    }
+    if (reference == Reference::LValue)
+        ret += " &";
+    else if (reference == Reference::RValue)
+        ret += " &&";
+    if (ret.empty())
+        return {};
+    return ret.substr(1);
+}
+
+void ValueType::setDebugPath(const Token* tok, SourceLocation ctx, const SourceLocation &local)
+{
+    std::string file = ctx.file_name();
+    if (file.empty())
+        return;
+    std::string s = Path::stripDirectoryPart(file) + ":" + std::to_string(ctx.line()) + ": " + ctx.function_name() +
+                    " => " + local.function_name();
+    debugPath.emplace_back(tok, std::move(s));
 }
 
 ValueType::MatchResult ValueType::matchParameter(const ValueType *call, const ValueType *func)
@@ -5936,55 +8732,100 @@ ValueType::MatchResult ValueType::matchParameter(const ValueType *call, const Va
     if (call->pointer != func->pointer) {
         if (call->pointer > 1 && func->pointer == 1 && func->type == ValueType::Type::VOID)
             return ValueType::MatchResult::FALLBACK1;
+        if (call->pointer == 1 && func->pointer == 0 && func->isIntegral() && func->sign != ValueType::Sign::SIGNED)
+            return ValueType::MatchResult::FALLBACK1;
         if (call->pointer == 1 && call->type == ValueType::Type::CHAR && func->pointer == 0 && func->container && func->container->stdStringLike)
             return ValueType::MatchResult::FALLBACK2;
         return ValueType::MatchResult::NOMATCH; // TODO
     }
-    if (call->pointer > 0 && ((call->constness | func->constness) != func->constness))
-        return ValueType::MatchResult::NOMATCH;
-    if (call->type != func->type) {
+    if (call->pointer > 0) {
+        const unsigned int mask = (1U << call->pointer) - 1;
+        if (((call->constness | func->constness) & mask) != (func->constness & mask))
+            return ValueType::MatchResult::NOMATCH;
+        if ((call->volatileness | func->volatileness) != func->volatileness)
+            return ValueType::MatchResult::NOMATCH;
+        if (call->constness == 0 && func->constness != 0 && func->reference != Reference::None)
+            return ValueType::MatchResult::NOMATCH;
+        if (call->volatileness == 0 && func->volatileness != 0 && func->reference != Reference::None)
+            return ValueType::MatchResult::NOMATCH;
+    }
+    if (call->type != func->type || (call->isEnum() && !func->isEnum())) {
         if (call->type == ValueType::Type::VOID || func->type == ValueType::Type::VOID)
             return ValueType::MatchResult::FALLBACK1;
-        if (call->pointer > 0 && func->pointer > 0)
+        if (call->pointer > 0)
             return func->type == ValueType::UNKNOWN_TYPE ? ValueType::MatchResult::UNKNOWN : ValueType::MatchResult::NOMATCH;
         if (call->isIntegral() && func->isIntegral())
             return call->type < func->type ?
                    ValueType::MatchResult::FALLBACK1 :
                    ValueType::MatchResult::FALLBACK2;
-        else if (call->isFloat() && func->isFloat())
+        if (call->isFloat() && func->isFloat())
             return ValueType::MatchResult::FALLBACK1;
-        else if (call->isIntegral() && func->isFloat())
+        if (call->isIntegral() && func->isFloat())
             return ValueType::MatchResult::FALLBACK2;
-        else if (call->isFloat() && func->isIntegral())
+        if (call->isFloat() && func->isIntegral())
             return ValueType::MatchResult::FALLBACK2;
         return ValueType::MatchResult::UNKNOWN; // TODO
     }
 
-    if (call->typeScope != nullptr || func->typeScope != nullptr)
-        return call->typeScope == func->typeScope ? ValueType::MatchResult::SAME : ValueType::MatchResult::NOMATCH;
+    if (call->typeScope != nullptr || func->typeScope != nullptr) {
+        if (call->typeScope != func->typeScope &&
+            !(call->typeScope && func->typeScope && call->typeScope->definedType && call->typeScope->definedType->isDerivedFrom(func->typeScope->className)))
+            return ValueType::MatchResult::NOMATCH;
+    }
 
     if (call->container != nullptr || func->container != nullptr) {
         if (call->container != func->container)
             return ValueType::MatchResult::NOMATCH;
     }
 
-    else if (func->type < ValueType::Type::VOID || func->type == ValueType::Type::UNKNOWN_INT)
-        return ValueType::MatchResult::UNKNOWN;
+    if (func->typeScope != nullptr && func->container != nullptr) {
+        if (func->type < ValueType::Type::VOID || func->type == ValueType::Type::UNKNOWN_INT)
+            return ValueType::MatchResult::UNKNOWN;
+    }
 
-    if (call->isIntegral() && func->isIntegral() && call->sign != ValueType::Sign::UNKNOWN_SIGN && func->sign != ValueType::Sign::UNKNOWN_SIGN && call->sign != func->sign)
-        return ValueType::MatchResult::UNKNOWN; // TODO
+    if (call->isIntegral() && func->isIntegral() && call->sign != func->sign)
+        return ValueType::MatchResult::FALLBACK1;
+
+    if (func->reference != Reference::None && (func->constness > call->constness || func->volatileness > call->volatileness))
+        return ValueType::MatchResult::FALLBACK1;
 
     return ValueType::MatchResult::SAME;
 }
 
 ValueType::MatchResult ValueType::matchParameter(const ValueType *call, const Variable *callVar, const Variable *funcVar)
 {
-    ValueType::MatchResult res = ValueType::matchParameter(call, funcVar->valueType());
-    if (res == ValueType::MatchResult::SAME && callVar && call->container) {
+    ValueType vt;
+    const ValueType* pvt = funcVar->valueType();
+    if (pvt && funcVar->isArray() && !(funcVar->isStlType() && Token::simpleMatch(funcVar->typeStartToken(), "std :: array"))) { // std::array doesn't decay to a pointer
+        vt = *pvt;
+        if (vt.pointer == 0) // don't bump array of pointers
+            vt.pointer = funcVar->dimensions().size();
+        pvt = &vt;
+    }
+    ValueType cvt;
+    if (call && callVar && callVar->isArray() && !(callVar->isStlType() && Token::simpleMatch(callVar->typeStartToken(), "std :: array"))) {
+        cvt = *call;
+        if (cvt.pointer == 0) // don't bump array of pointers
+            cvt.pointer = callVar->dimensions().size();
+        call = &cvt;
+    }
+    const ValueType::MatchResult res = ValueType::matchParameter(call, pvt);
+    if (callVar && ((res == ValueType::MatchResult::SAME && call->container) || res == ValueType::MatchResult::UNKNOWN)) {
         const std::string type1 = getTypeString(callVar->typeStartToken());
         const std::string type2 = getTypeString(funcVar->typeStartToken());
-        if (type1 != type2)
+        const bool templateVar =
+            funcVar->scope() && funcVar->scope()->function && funcVar->scope()->function->templateDef;
+        if (type1 == type2)
+            return ValueType::MatchResult::SAME;
+        if (!templateVar && type1.find("auto") == std::string::npos && type2.find("auto") == std::string::npos)
             return ValueType::MatchResult::NOMATCH;
     }
     return res;
 }
+
+void SymbolDatabase::getErrorMessages(ErrorLogger& /*errorLogger*/)
+{
+    // TODO
+    //SymbolDatabase symdb;
+    //symdb.returnImplicitIntError(nullptr);
+}
diff --git a/lib/symboldatabase.h b/lib/symboldatabase.h
index bc0f96c0e24..a4cdfc5370a 100644
--- a/lib/symboldatabase.h
+++ b/lib/symboldatabase.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,12 +22,18 @@
 //---------------------------------------------------------------------------
 
 #include "config.h"
+#include "errortypes.h"
 #include "library.h"
 #include "mathlib.h"
-#include "platform.h"
+#include "sourcelocation.h"
 #include "token.h"
+#include "utils.h"
 
+#include <algorithm>
+#include <cctype>
 #include <cstddef>
+#include <cstdint>
+#include <iosfwd>
 #include <list>
 #include <map>
 #include <set>
@@ -35,28 +41,32 @@
 #include <utility>
 #include <vector>
 
-class ErrorLogger;
 class Function;
 class Scope;
 class Settings;
 class SymbolDatabase;
 class Tokenizer;
 class ValueType;
+class ErrorLogger;
+
+enum class Reference : std::uint8_t {
+    None,
+    LValue,
+    RValue
+};
 
 /**
  * @brief Access control enumerations.
  */
-enum class AccessControl { Public, Protected, Private, Global, Namespace, Argument, Local, Throw };
+enum class AccessControl : std::uint8_t { Public, Protected, Private, Global, Namespace, Argument, Local, Throw };
 
 /**
  * @brief Array dimension information.
  */
 struct Dimension {
-    Dimension() : tok(nullptr), num(0), known(true) { }
-
-    const Token *tok;    ///< size token
-    MathLib::bigint num; ///< (assumed) dimension length when size is a number, 0 if not known
-    bool known;          ///< Known size
+    const Token* tok{};    ///< size token
+    MathLib::bigint num{}; ///< (assumed) dimension length when size is a number, 0 if not known
+    bool known = true;     ///< Known size
 };
 
 /** @brief Information about a class type. */
@@ -65,21 +75,16 @@ class CPPCHECKLIB Type {
     const Token* classDef;     ///< Points to "class" token
     const Scope* classScope;
     const Scope* enclosingScope;
-    enum class NeedInitialization {
+    enum class NeedInitialization : std::uint8_t {
         Unknown, True, False
-    } needInitialization;
-
-    class BaseInfo {
-    public:
-        BaseInfo() :
-            type(nullptr), nameTok(nullptr), access(AccessControl::Public), isVirtual(false) {
-        }
+    } needInitialization = NeedInitialization::Unknown;
 
+    struct BaseInfo {
         std::string name;
-        const Type* type;
-        const Token* nameTok;
-        AccessControl access;  // public/protected/private
-        bool isVirtual;
+        const Type* type{};
+        const Token* nameTok{};
+        AccessControl access{};  // public/protected/private
+        bool isVirtual{};
         // allow ordering within containers
         bool operator<(const BaseInfo& rhs) const {
             return this->type < rhs.type;
@@ -87,90 +92,81 @@ class CPPCHECKLIB Type {
     };
 
     struct FriendInfo {
-        FriendInfo() :
-            nameStart(nullptr), nameEnd(nullptr), type(nullptr) {
-        }
-
-        const Token* nameStart;
-        const Token* nameEnd;
-        const Type* type;
+        const Token* nameStart{};
+        const Token* nameEnd{};
+        const Type* type{};
     };
 
     std::vector<BaseInfo> derivedFrom;
     std::vector<FriendInfo> friendList;
 
-    const Token * typeStart;
-    const Token * typeEnd;
+    const Token* typeStart{};
+    const Token* typeEnd{};
+    MathLib::bigint sizeOf{};
 
-    Type(const Token* classDef_ = nullptr, const Scope* classScope_ = nullptr, const Scope* enclosingScope_ = nullptr) :
+    explicit Type(const Token* classDef_ = nullptr, const Scope* classScope_ = nullptr, const Scope* enclosingScope_ = nullptr) :
         classDef(classDef_),
         classScope(classScope_),
-        enclosingScope(enclosingScope_),
-        needInitialization(NeedInitialization::Unknown),
-        typeStart(nullptr),
-        typeEnd(nullptr) {
+        enclosingScope(enclosingScope_) {
         if (classDef_ && classDef_->str() == "enum")
             needInitialization = NeedInitialization::True;
         else if (classDef_ && classDef_->str() == "using") {
             typeStart = classDef->tokAt(3);
             typeEnd = typeStart;
-            while (typeEnd->next() && typeEnd->next()->str() != ";")
-                typeEnd = typeEnd->next();
+            while (typeEnd->next() && typeEnd->strAt(1) != ";") {
+                if (Token::simpleMatch(typeEnd, "decltype ("))
+                    typeEnd = typeEnd->linkAt(1);
+                else
+                    typeEnd = typeEnd->next();
+            }
         }
     }
 
-    const std::string& name() const;
+    std::string name() const;
 
     const std::string& type() const {
-        return classDef ? classDef->str() : emptyString;
+        static const std::string s_empty_string;
+        return classDef ? classDef->str() : s_empty_string;
     }
 
-    bool isClassType() const {
-        return classDef && classDef->str() == "class";
-    }
-
-    bool isEnumType() const {
-        return classDef && classDef->str() == "enum";
-    }
+    bool isClassType() const;
+    bool isEnumType() const;
+    bool isStructType() const;
+    bool isUnionType() const;
 
     bool isTypeAlias() const {
         return classDef && classDef->str() == "using";
     }
 
-    bool isStructType() const {
-        return classDef && classDef->str() == "struct";
-    }
-
     const Token *initBaseInfo(const Token *tok, const Token *tok1);
 
     const Function* getFunction(const std::string& funcName) const;
 
     /**
-    * Check for circulare dependencies, i.e. loops within the class hierarchy
-    * @param ancestors list of ancestors. For internal usage only, clients should not supply this argument.
-    * @return true if there is a circular dependency
-    */
+     * Check for circulare dependencies, i.e. loops within the class hierarchy
+     * @param ancestors list of ancestors. For internal usage only, clients should not supply this argument.
+     * @return true if there is a circular dependency
+     */
     bool hasCircularDependencies(std::set<BaseInfo>* ancestors = nullptr) const;
 
     /**
-    * Check for dependency
-    * @param ancestor potential ancestor
-    * @return true if there is a dependency
-    */
+     * Check for dependency
+     * @param ancestor potential ancestor
+     * @return true if there is a dependency
+     */
     bool findDependency(const Type* ancestor) const;
 
     bool isDerivedFrom(const std::string & ancestor) const;
 };
 
-class CPPCHECKLIB Enumerator {
-public:
-    explicit Enumerator(const Scope * scope_) : scope(scope_), name(nullptr), value(0), start(nullptr), end(nullptr), value_known(false) { }
+struct CPPCHECKLIB Enumerator {
+    explicit Enumerator(const Scope * scope_) : scope(scope_) {}
     const Scope * scope;
-    const Token * name;
-    MathLib::bigint value;
-    const Token * start;
-    const Token * end;
-    bool value_known;
+    const Token* name{};
+    MathLib::bigint value{};
+    const Token* start{};
+    const Token* end{};
+    bool value_known{};
 };
 
 /** @brief Information about a member variable. */
@@ -191,7 +187,9 @@ class CPPCHECKLIB Variable {
         fIsStlString  = (1 << 11),  /** @brief std::string|wstring|basic_string&lt;T&gt;|u16string|u32string */
         fIsFloatType  = (1 << 12),  /** @brief Floating point type */
         fIsVolatile   = (1 << 13),  /** @brief volatile */
-        fIsSmartPointer = (1 << 14)   /** @brief std::shared_ptr|unique_ptr */
+        fIsSmartPointer = (1 << 14),/** @brief std::shared_ptr|unique_ptr */
+        fIsMaybeUnused = (1 << 15), /** @brief marked [[maybe_unused]] */
+        fIsInit       = (1 << 16), /** @brief Is variable initialized in declaration */
     };
 
     /**
@@ -215,28 +213,38 @@ class CPPCHECKLIB Variable {
     /**
      * @brief parse and save array dimension information
      * @param settings Platform settings and library
+     * @param isContainer Is the array container-like?
      * @return true if array, false if not
      */
-    bool arrayDimensions(const Settings* settings);
+    bool arrayDimensions(const Settings& settings, bool& isContainer);
 
 public:
     Variable(const Token *name_, const Token *start_, const Token *end_,
              nonneg int index_, AccessControl access_, const Type *type_,
-             const Scope *scope_, const Settings* settings)
+             const Scope *scope_, const Settings& settings)
         : mNameToken(name_),
-          mTypeStartToken(start_),
-          mTypeEndToken(end_),
-          mIndex(index_),
-          mAccess(access_),
-          mFlags(0),
-          mType(type_),
-          mScope(scope_),
-          mValueType(nullptr) {
+        mTypeStartToken(start_),
+        mTypeEndToken(end_),
+        mIndex(index_),
+        mAccess(access_),
+        mFlags(0),
+        mType(type_),
+        mScope(scope_) {
         evaluate(settings);
     }
 
+    Variable(const Token *name_, const std::string &clangType, const Token *typeStart,
+             const Token *typeEnd, nonneg int index_, AccessControl access_,
+             const Type *type_, const Scope *scope_);
+
+    Variable(const Variable &var, const Scope *scope);
+
+    Variable(const Variable &var);
+
     ~Variable();
 
+    Variable &operator=(const Variable &var) &;
+
     /**
      * Get name token.
      * @return name token
@@ -287,7 +295,8 @@ class CPPCHECKLIB Variable {
         if (mNameToken)
             return mNameToken->str();
 
-        return emptyString;
+        static const std::string s_empty_string;
+        return s_empty_string;
     }
 
     /**
@@ -346,6 +355,7 @@ class CPPCHECKLIB Variable {
      * Is variable in a namespace.
      * @return true if in a namespace, false if not
      */
+    // cppcheck-suppress unusedFunction
     bool isNamespace() const {
         return mAccess == AccessControl::Namespace;
     }
@@ -366,6 +376,12 @@ class CPPCHECKLIB Variable {
         return (mAccess == AccessControl::Local) && !isExtern();
     }
 
+    /**
+     * Is variable a member of a user-defined type.
+     * @return true if member, false if not or unknown
+     */
+    bool isMember() const;
+
     /**
      * Is variable mutable.
      * @return true if mutable, false if not
@@ -476,6 +492,12 @@ class CPPCHECKLIB Variable {
         return getFlag(fIsRValueRef);
     }
 
+    /**
+     * Is variable unsigned.
+     * @return true only if variable _is_ unsigned. if the sign is unknown, false is returned.
+     */
+    bool isUnsigned() const;
+
     /**
      * Does variable have a default value.
      * @return true if has a default falue, false if not
@@ -484,6 +506,14 @@ class CPPCHECKLIB Variable {
         return getFlag(fHasDefault);
     }
 
+    /**
+     * Is variable initialized in its declaration
+     * @return true if variable declaration contains initialization
+     */
+    bool isInit() const {
+        return getFlag(fIsInit);
+    }
+
     /**
      * Get Type pointer of known type.
      * @return pointer to type if known, NULL if not known
@@ -521,7 +551,7 @@ class CPPCHECKLIB Variable {
      * @return length of dimension
      */
     MathLib::bigint dimension(nonneg int index_) const {
-        return mDimensions[index_].num;
+        return mDimensions.at(index_).num;
     }
 
     /**
@@ -529,17 +559,21 @@ class CPPCHECKLIB Variable {
      * @return length of dimension known
      */
     bool dimensionKnown(nonneg int index_) const {
-        return mDimensions[index_].known;
+        return mDimensions.at(index_).known;
+    }
+
+    void setDimensions(const std::vector<Dimension> &dimensions_) {
+        mDimensions = dimensions_;
     }
 
     /**
-    * Checks if the variable is an STL type ('std::')
-    * E.g.:
-    *   std::string s;
-    *   ...
-    *   sVar->isStlType() == true
-    * @return true if it is an stl type and its type matches any of the types in 'stlTypes'
-    */
+     * Checks if the variable is an STL type ('std::')
+     * E.g.:
+     *   std::string s;
+     *   ...
+     *   sVar->isStlType() == true
+     * @return true if it is an stl type and its type matches any of the types in 'stlTypes'
+     */
     bool isStlType() const {
         return getFlag(fIsStlType);
     }
@@ -556,11 +590,14 @@ class CPPCHECKLIB Variable {
         return getFlag(fIsStlString);
     }
 
+    bool isStlStringViewType() const;
+
     bool isSmartPointer() const {
         return getFlag(fIsSmartPointer);
     }
 
-    const Type *smartPointerType() const;
+    const Type* smartPointerType() const;
+    const Type* iteratorType() const;
 
     /**
      * Checks if the variable is of any of the STL types passed as arguments ('std::')
@@ -591,21 +628,25 @@ class CPPCHECKLIB Variable {
     }
 
     /**
-    * Determine whether it's a floating number type
-    * @return true if the type is known and it's a floating type (float, double and long double) or a pointer/array to it
-    */
+     * Determine whether it's a floating number type
+     * @return true if the type is known and it's a floating type (float, double and long double) or a pointer/array to it
+     */
     bool isFloatingType() const {
         return getFlag(fIsFloatType);
     }
 
     /**
-    * Determine whether it's an enumeration type
-    * @return true if the type is known and it's an enumeration type
-    */
+     * Determine whether it's an enumeration type
+     * @return true if the type is known and it's an enumeration type
+     */
     bool isEnumType() const {
         return type() && type()->isEnumType();
     }
 
+    bool isMaybeUnused() const {
+        return getFlag(fIsMaybeUnused);
+    }
+
     const ValueType *valueType() const {
         return mValueType;
     }
@@ -616,6 +657,8 @@ class CPPCHECKLIB Variable {
         return mAccess;
     }
 
+    std::string getTypeName() const;
+
 private:
     // only symbol database can change the type
     friend class SymbolDatabase;
@@ -652,16 +695,21 @@ class CPPCHECKLIB Variable {
     /** @brief pointer to scope this variable is in */
     const Scope *mScope;
 
-    ValueType *mValueType;
+    const ValueType* mValueType{};
 
     /** @brief array dimensions */
     std::vector<Dimension> mDimensions;
 
     /** @brief fill in information, depending on Tokens given at instantiation */
-    void evaluate(const Settings* settings);
+    void evaluate(const Settings& settings);
 };
 
+enum class FunctionType : std::uint8_t { eConstructor, eCopyConstructor, eMoveConstructor, eOperatorEqual, eDestructor, eFunction, eLambda };
+
 class CPPCHECKLIB Function {
+    // only symbol database can change this
+    friend class SymbolDatabase;
+
     /** @brief flags mask used to access specific bit. */
     enum {
         fHasBody               = (1 << 0),  ///< @brief has implementation
@@ -687,6 +735,8 @@ class CPPCHECKLIB Function {
         fIsVolatile            = (1 << 20), ///< @brief is volatile
         fHasTrailingReturnType = (1 << 21), ///< @brief has trailing return type
         fIsEscapeFunction      = (1 << 22), ///< @brief Function throws or exits
+        fIsInlineKeyword       = (1 << 23), ///< @brief Function has "inline" keyword
+        fIsConstexpr           = (1 << 24), ///< @brief is constexpr
     };
 
     /**
@@ -708,14 +758,15 @@ class CPPCHECKLIB Function {
     }
 
 public:
-    enum Type { eConstructor, eCopyConstructor, eMoveConstructor, eOperatorEqual, eDestructor, eFunction, eLambda };
-
-    Function(const Tokenizer *mTokenizer, const Token *tok, const Scope *scope, const Token *tokDef, const Token *tokArgDef);
+    Function(const Token *tok, const Scope *scope, const Token *tokDef, const Token *tokArgDef);
+    Function(const Token *tokenDef, const std::string &clangType);
 
     const std::string &name() const {
         return tokenDef->str();
     }
 
+    std::string fullName() const;
+
     nonneg int argCount() const {
         return argumentList.size();
     }
@@ -726,26 +777,31 @@ class CPPCHECKLIB Function {
     nonneg int initializedArgCount() const {
         return initArgCount;
     }
-    void addArguments(const SymbolDatabase *symbolDatabase, const Scope *scope);
+    /**
+     * @throws InternalError thrown on unrecognized lambda
+     */
+    void addArguments(const Scope *scope);
 
     /** @brief check if this function is virtual in the base classes */
-    bool isImplicitlyVirtual(bool defaultVal = false) const;
+    bool isImplicitlyVirtual(bool defaultVal = false, bool* pFoundAllBaseClasses = nullptr) const;
+
+    std::vector<const Function*> getOverloadedFunctions() const;
 
     /** @brief get function in base class that is overridden */
     const Function *getOverriddenFunction(bool *foundAllBaseClasses = nullptr) const;
 
     bool isLambda() const {
-        return type==eLambda;
+        return type==FunctionType::eLambda;
     }
 
     bool isConstructor() const {
-        return type==eConstructor ||
-               type==eCopyConstructor ||
-               type==eMoveConstructor;
+        return type==FunctionType::eConstructor ||
+               type==FunctionType::eCopyConstructor ||
+               type==FunctionType::eMoveConstructor;
     }
 
     bool isDestructor() const {
-        return type==eDestructor;
+        return type==FunctionType::eDestructor;
     }
     bool isAttributeConstructor() const {
         return tokenDef->isAttributeConstructor();
@@ -768,6 +824,12 @@ class CPPCHECKLIB Function {
     bool isAttributeNodiscard() const {
         return tokenDef->isAttributeNodiscard();
     }
+    bool isAttributeUnused() const {
+        return tokenDef->isAttributeUnused();
+    }
+    bool isAttributeMaybeUnused() const {
+        return tokenDef->isAttributeMaybeUnused();
+    }
 
     bool hasBody() const {
         return getFlag(fHasBody);
@@ -838,6 +900,9 @@ class CPPCHECKLIB Function {
     void hasBody(bool state) {
         setFlag(fHasBody, state);
     }
+    bool isInlineKeyword() const {
+        return getFlag(fIsInlineKeyword);
+    }
 
     bool isEscapeFunction() const {
         return getFlag(fIsEscapeFunction);
@@ -845,34 +910,48 @@ class CPPCHECKLIB Function {
     void isEscapeFunction(bool state) {
         setFlag(fIsEscapeFunction, state);
     }
-    bool isSafe(const Settings *settings) const;
 
-    const Token *tokenDef;            ///< function name token in class definition
-    const Token *argDef;              ///< function argument start '(' in class definition
-    const Token *token;               ///< function name token in implementation
-    const Token *arg;                 ///< function argument start '('
-    const Token *retDef;              ///< function return type token
-    const ::Type *retType;            ///< function return type
-    const Scope *functionScope;       ///< scope of function body
-    const Scope* nestedIn;            ///< Scope the function is declared in
-    std::list<Variable> argumentList; ///< argument list
-    nonneg int initArgCount;        ///< number of args with default values
-    Type type;                        ///< constructor, destructor, ...
-    AccessControl access;             ///< public/protected/private
-    const Token *noexceptArg;         ///< noexcept token
-    const Token *throwArg;            ///< throw token
-    const Token *templateDef;         ///< points to 'template <' before function
+    bool isConstexpr() const {
+        return getFlag(fIsConstexpr);
+    }
+    void isConstexpr(bool state) {
+        setFlag(fIsConstexpr, state);
+    }
+    bool isSafe(const Settings &settings) const;
+
+    const Token* tokenDef{};          ///< function name token in class definition
+    const Token* argDef{};            ///< function argument start '(' in class definition
+    const Token* token{};             ///< function name token in implementation
+    const Token* arg{};               ///< function argument start '('
+    const Token* retDef{};            ///< function return type token
+    const ::Type* retType{};          ///< function return type
+    const Scope* functionScope{};     ///< scope of function body
+    const Scope* nestedIn{};          ///< Scope the function is declared in
+    std::list<Variable> argumentList; ///< argument list, must remain list due to clangimport usage!
+    nonneg int initArgCount{};        ///< number of args with default values
+    FunctionType type = FunctionType::eFunction; ///< constructor, destructor, ...
+    const Token* noexceptArg{};       ///< noexcept token
+    const Token* throwArg{};          ///< throw token
+    const Token* templateDef{};       ///< points to 'template <' before function
+    const Token* functionPointerUsage{}; ///< function pointer usage
+    AccessControl access{};           ///< public/protected/private
 
-    static bool argsMatch(const Scope *scope, const Token *first, const Token *second, const std::string &path, nonneg int path_length);
+    bool argsMatch(const Scope *scope, const Token *first, const Token *second, const std::string &path, nonneg int path_length) const;
 
-    static bool returnsReference(const Function *function);
+    static bool returnsConst(const Function* function, bool unknown = false);
+
+    static bool returnsPointer(const Function* function, bool unknown = false);
+    static bool returnsReference(const Function* function, bool unknown = false, bool includeRValueRef = false);
+    static bool returnsStandardType(const Function* function, bool unknown = false);
+
+    static bool returnsVoid(const Function* function, bool unknown = false);
+
+    static std::vector<const Token*> findReturns(const Function* f);
 
     const Token* returnDefEnd() const {
-        if (this->hasTrailingReturnType()) {
-            return Token::findsimplematch(retDef, "{");
-        } else {
-            return tokenDef;
-        }
+        if (this->hasTrailingReturnType())
+            return Token::findmatch(retDef, "{|;");
+        return tokenDef;
     }
 
     /**
@@ -885,7 +964,7 @@ class CPPCHECKLIB Function {
     /** Recursively determine if this function overrides a virtual function in a base class */
     const Function * getOverriddenFunctionRecursive(const ::Type* baseType, bool *foundAllBaseClasses) const;
 
-    unsigned int mFlags;
+    unsigned int mFlags{};
 
     void isInline(bool state) {
         setFlag(fIsInline, state);
@@ -942,10 +1021,16 @@ class CPPCHECKLIB Function {
         setFlag(fIsVolatile, state);
     }
     void hasTrailingReturnType(bool state) {
-        return setFlag(fHasTrailingReturnType, state);
+        setFlag(fHasTrailingReturnType, state);
+    }
+    void isInlineKeyword(bool state) {
+        setFlag(fIsInlineKeyword, state);
     }
+    RET_NONNULL const Token *setFlags(const Token *tok1, const Scope *scope);
 };
 
+enum class ScopeType : std::uint8_t { eGlobal, eClass, eStruct, eUnion, eNamespace, eFunction, eIf, eElse, eFor, eWhile, eDo, eSwitch, eUnconditional, eTry, eCatch, eLambda, eEnum };
+
 class CPPCHECKLIB Scope {
     // let tests access private function for testing
     friend class TestSymbolDatabase;
@@ -956,44 +1041,54 @@ class CPPCHECKLIB Scope {
         const Scope *scope;
     };
 
-    enum ScopeType { eGlobal, eClass, eStruct, eUnion, eNamespace, eFunction, eIf, eElse, eFor, eWhile, eDo, eSwitch, eUnconditional, eTry, eCatch, eLambda, eEnum };
+    Scope(const SymbolDatabase &symdb_, const Token *classDef_, const Scope *nestedIn_);
+    Scope(const SymbolDatabase &symdb_, const Token *classDef_, const Scope *nestedIn_, ScopeType type_, const Token *start_);
 
-    Scope(const SymbolDatabase *check_, const Token *classDef_, const Scope *nestedIn_);
-    Scope(const SymbolDatabase *check_, const Token *classDef_, const Scope *nestedIn_, ScopeType type_, const Token *start_);
-
-    const SymbolDatabase *check;
+    const SymbolDatabase& symdb;
     std::string className;
-    const Token *classDef;   ///< class/struct/union/namespace token
-    const Token *bodyStart;  ///< '{' token
-    const Token *bodyEnd;    ///< '}' token
+    const Token* classDef{};   ///< class/struct/union/namespace token
+    const Token* bodyStart{};  ///< '{' token
+    const Token* bodyEnd{};    ///< '}' token
     std::list<Function> functionList;
     std::multimap<std::string, const Function *> functionMap;
     std::list<Variable> varlist;
-    const Scope *nestedIn;
-    std::list<Scope *> nestedList;
-    nonneg int numConstructors;
-    nonneg int numCopyOrMoveConstructors;
-    std::list<UsingInfo> usingList;
-    ScopeType type;
-    Type* definedType;
+    const Scope* nestedIn{};
+    std::vector<Scope *> nestedList;
+    nonneg int numConstructors{};
+    nonneg int numCopyOrMoveConstructors{};
+    std::vector<UsingInfo> usingList;
+    ScopeType type{};
+    Type* definedType{};
     std::map<std::string, Type*> definedTypesMap;
+    std::vector<const Token *> bodyStartList;
 
     // function specific fields
-    const Scope *functionOf; ///< scope this function belongs to
-    Function *function; ///< function info for this function
+    const Scope* functionOf{}; ///< scope this function belongs to
+    Function* function{}; ///< function info for this function
 
     // enum specific fields
-    const Token * enumType;
-    bool enumClass;
+    const Token* enumType{};
+    bool enumClass{};
 
     std::vector<Enumerator> enumeratorList;
 
+    void setBodyStartEnd(const Token *start) {
+        bodyStart = start;
+        bodyEnd = start ? start->link() : nullptr;
+        if (start)
+            bodyStartList.push_back(start);
+    }
+
+    bool isAnonymous() const {
+        // TODO: Check if class/struct is anonymous
+        return className.size() > 9 && startsWith(className,"Anonymous") && std::isdigit(className[9]);
+    }
+
     const Enumerator * findEnumerator(const std::string & name) const {
-        for (const Enumerator & i : enumeratorList) {
-            if (i.name->str() == name)
-                return &i;
-        }
-        return nullptr;
+        auto it = std::find_if(enumeratorList.cbegin(), enumeratorList.cend(), [&](const Enumerator& i) {
+            return i.name->str() == name;
+        });
+        return it == enumeratorList.end() ? nullptr : &*it;
     }
 
     bool isNestedIn(const Scope * outer) const {
@@ -1004,32 +1099,45 @@ class CPPCHECKLIB Scope {
         const Scope * parent = nestedIn;
         while (outer != parent && parent)
             parent = parent->nestedIn;
-        if (parent && parent == outer)
-            return true;
-        return false;
+        return parent && parent == outer;
+    }
+
+    static Function* nestedInFunction(const Scope* scope) {
+        while (scope) {
+            if (scope->type == ScopeType::eFunction)
+                break;
+            scope = scope->nestedIn;
+        }
+        if (!scope)
+            return nullptr;
+        return scope->function;
     }
 
     bool isClassOrStruct() const {
-        return (type == eClass || type == eStruct);
+        return (type == ScopeType::eClass || type == ScopeType::eStruct);
     }
 
     bool isClassOrStructOrUnion() const {
-        return (type == eClass || type == eStruct || type == eUnion);
+        return (type == ScopeType::eClass || type == ScopeType::eStruct || type == ScopeType::eUnion);
     }
 
     bool isExecutable() const {
-        return type != eClass && type != eStruct && type != eUnion && type != eGlobal && type != eNamespace && type != eEnum;
+        return type != ScopeType::eClass && type != ScopeType::eStruct && type != ScopeType::eUnion && type != ScopeType::eGlobal && type != ScopeType::eNamespace && type != ScopeType::eEnum;
+    }
+
+    bool isLoopScope() const {
+        return type == ScopeType::eFor || type == ScopeType::eWhile || type == ScopeType::eDo;
     }
 
     bool isLocal() const {
-        return (type == eIf || type == eElse ||
-                type == eFor || type == eWhile || type == eDo ||
-                type == eSwitch || type == eUnconditional ||
-                type == eTry || type == eCatch);
+        return (type == ScopeType::eIf || type == ScopeType::eElse ||
+                type == ScopeType::eFor || type == ScopeType::eWhile || type == ScopeType::eDo ||
+                type == ScopeType::eSwitch || type == ScopeType::eUnconditional ||
+                type == ScopeType::eTry || type == ScopeType::eCatch);
     }
 
     // Is there lambda/inline function(s) in this scope?
-    bool hasInlineOrLambdaFunction() const;
+    bool hasInlineOrLambdaFunction(const Token** tokStart = nullptr, bool onlyInline = false) const;
 
     /**
      * @brief find a function
@@ -1037,63 +1145,46 @@ class CPPCHECKLIB Scope {
      * @param requireConst if const refers to a const variable only const methods should be matched
      * @return pointer to function if found or NULL if not found
      */
-    const Function *findFunction(const Token *tok, bool requireConst=false) const;
+    const Function *findFunction(const Token *tok, bool requireConst=false, Reference ref=Reference::None) const;
 
-    /**
-     * @brief find if name is in nested list
-     * @param name name of nested scope
-     */
-    Scope *findInNestedList(const std::string & name);
-
-    const Scope *findRecordInNestedList(const std::string & name) const;
-    Scope *findRecordInNestedList(const std::string & name) {
-        return const_cast<Scope *>(const_cast<const Scope *>(this)->findRecordInNestedList(name));
-    }
+    const Scope *findRecordInNestedList(const std::string & name, bool isC = false) const;
+    Scope *findRecordInNestedList(const std::string & name, bool isC = false);
 
     const Type* findType(const std::string& name) const;
-    Type* findType(const std::string& name) {
-        return const_cast<Type*>(const_cast<const Scope *>(this)->findType(name));
-    }
+    Type* findType(const std::string& name);
 
     /**
      * @brief find if name is in nested list
      * @param name name of nested scope
      */
-    Scope *findInNestedListRecursive(const std::string & name);
+    const Scope *findInNestedListRecursive(const std::string & name) const;
 
     void addVariable(const Token *token_, const Token *start_,
                      const Token *end_, AccessControl access_, const Type *type_,
-                     const Scope *scope_, const Settings* settings) {
-        varlist.emplace_back(token_, start_, end_, varlist.size(),
-                             access_,
-                             type_, scope_, settings);
-    }
+                     const Scope *scope_);
 
     /** @brief initialize varlist */
-    void getVariableList(const Settings* settings);
+    void getVariableList();
 
     const Function *getDestructor() const;
 
-    void addFunction(const Function & func) {
-        functionList.push_back(func);
+    void addFunction(Function func) {
+        functionList.push_back(std::move(func));
 
         const Function * back = &functionList.back();
 
-        functionMap.insert(make_pair(back->tokenDef->str(), back));
+        functionMap.emplace(back->tokenDef->str(), back);
     }
 
-    bool hasDefaultConstructor() const;
-
     AccessControl defaultAccess() const;
 
     /**
      * @brief check if statement is variable declaration and add it if it is
      * @param tok pointer to start of statement
      * @param varaccess access control of statement
-     * @param settings Settings
      * @return pointer to last token
      */
-    const Token *checkVariable(const Token *tok, AccessControl varaccess, const Settings* settings);
+    const Token *checkVariable(const Token *tok, AccessControl varaccess);
 
     /**
      * @brief get variable from name
@@ -1102,7 +1193,11 @@ class CPPCHECKLIB Scope {
      */
     const Variable *getVariable(const std::string &varname) const;
 
-    const Token * addEnum(const Token * tok, bool isCpp);
+    const Token * addEnum(const Token * tok);
+
+    const Scope *findRecordInBase(const std::string &name) const;
+
+    std::vector<const Scope*> findAssociatedScopes() const;
 
 private:
     /**
@@ -1112,99 +1207,96 @@ class CPPCHECKLIB Scope {
      * @param typetok populated with pointer to the type token, if found
      * @return true if tok points to a variable declaration, false otherwise
      */
-    bool isVariableDeclaration(const Token* const tok, const Token*& vartok, const Token*& typetok) const;
+    bool isVariableDeclaration(const Token* tok, const Token*& vartok, const Token*& typetok) const;
 
-    void findFunctionInBase(const std::string & name, nonneg int args, std::vector<const Function *> & matches) const;
-};
+    void findFunctionInBase(const Token* tok, nonneg int args, std::vector<const Function *> & matches) const;
 
+    /** @brief initialize varlist */
+    void getVariableList(const Token *start, const Token *end);
+};
 
 /** Value type */
 class CPPCHECKLIB ValueType {
 public:
-    enum Sign { UNKNOWN_SIGN, SIGNED, UNSIGNED } sign;
-    enum Type { UNKNOWN_TYPE, NONSTD, RECORD, CONTAINER, ITERATOR, VOID, BOOL, CHAR, SHORT, WCHAR_T, INT, LONG, LONGLONG, UNKNOWN_INT, FLOAT, DOUBLE, LONGDOUBLE } type;
-    nonneg int bits;                    ///< bitfield bitcount
-    nonneg int pointer;                 ///< 0=>not pointer, 1=>*, 2=>**, 3=>***, etc
-    nonneg int constness;               ///< bit 0=data, bit 1=*, bit 2=**
-    const Scope *typeScope;               ///< if the type definition is seen this point out the type scope
-    const ::Type *smartPointerType;       ///< Smart pointer type
-    const Token* smartPointerTypeToken;   ///< Smart pointer type token
-    const Library::Container *container;  ///< If the type is a container defined in a cfg file, this is the used container
-    const Token *containerTypeToken;      ///< The container type token. the template argument token that defines the container element type.
-    std::string originalTypeName;         ///< original type name as written in the source code. eg. this might be "uint8_t" when type is CHAR.
-
-    ValueType()
-        : sign(UNKNOWN_SIGN),
-          type(UNKNOWN_TYPE),
-          bits(0),
-          pointer(0U),
-          constness(0U),
-          typeScope(nullptr),
-          smartPointerType(nullptr),
-          smartPointerTypeToken(nullptr),
-          container(nullptr),
-          containerTypeToken(nullptr)
-    {}
-    ValueType(const ValueType& vt)
-        : sign(vt.sign),
-          type(vt.type),
-          bits(vt.bits),
-          pointer(vt.pointer),
-          constness(vt.constness),
-          typeScope(vt.typeScope),
-          smartPointerType(vt.smartPointerType),
-          smartPointerTypeToken(vt.smartPointerTypeToken),
-          container(vt.container),
-          containerTypeToken(vt.containerTypeToken),
-          originalTypeName(vt.originalTypeName)
+    enum Sign : std::uint8_t { UNKNOWN_SIGN, SIGNED, UNSIGNED } sign = UNKNOWN_SIGN;
+    enum Type : std::uint8_t {
+        UNKNOWN_TYPE,
+        POD,
+        NONSTD,
+        RECORD,
+        SMART_POINTER,
+        CONTAINER,
+        ITERATOR,
+        VOID,
+        BOOL,
+        CHAR,
+        SHORT,
+        WCHAR_T,
+        INT,
+        LONG,
+        LONGLONG,
+        UNKNOWN_INT,
+        FLOAT,
+        DOUBLE,
+        LONGDOUBLE
+    } type = UNKNOWN_TYPE;
+    int bits{};                                ///< bitfield bitcount
+    nonneg int pointer{};                      ///< 0=>not pointer, 1=>*, 2=>**, 3=>***, etc
+    nonneg int constness{};                    ///< bit 0=data, bit 1=*, bit 2=**
+    nonneg int volatileness{};                 ///< bit 0=data, bit 1=*, bit 2=**
+    Reference reference = Reference::None;     ///< Is the outermost indirection of this type a reference or rvalue
+    ///< reference or not? pointer=2, Reference=LValue would be a T**&
+    const Scope* typeScope{};                  ///< if the type definition is seen this point out the type scope
+    const ::Type* smartPointerType{};          ///< Smart pointer type
+    const Token* smartPointerTypeToken{};      ///< Smart pointer type token
+    const Library::SmartPointer* smartPointer{}; ///< Smart pointer
+    const Library::Container* container{};     ///< If the type is a container defined in a cfg file, this is the used
+    ///< container
+    const Token* containerTypeToken{}; ///< The container type token. the template argument token that defines the
+    ///< container element type.
+    std::string originalTypeName;    ///< original type name as written in the source code. eg. this might be "uint8_t"
+    ///< when type is CHAR.
+    ErrorPath debugPath; ///< debug path to the type
+
+    ValueType() = default;
+    ValueType(Sign s, Type t, nonneg int p)
+        : sign(s),
+        type(t),
+        pointer(p)
     {}
-    ValueType(enum Sign s, enum Type t, nonneg int p)
+    ValueType(Sign s, Type t, nonneg int p, nonneg int c)
         : sign(s),
-          type(t),
-          bits(0),
-          pointer(p),
-          constness(0U),
-          typeScope(nullptr),
-          smartPointerType(nullptr),
-          smartPointerTypeToken(nullptr),
-          container(nullptr),
-          containerTypeToken(nullptr)
+        type(t),
+        pointer(p),
+        constness(c)
     {}
-    ValueType(enum Sign s, enum Type t, nonneg int p, nonneg int c)
+    ValueType(Sign s, Type t, nonneg int p, nonneg int c, nonneg int v)
         : sign(s),
-          type(t),
-          bits(0),
-          pointer(p),
-          constness(c),
-          typeScope(nullptr),
-          smartPointerType(nullptr),
-          smartPointerTypeToken(nullptr),
-          container(nullptr),
-          containerTypeToken(nullptr)
+        type(t),
+        pointer(p),
+        constness(c),
+        volatileness(v)
     {}
-    ValueType(enum Sign s, enum Type t, nonneg int p, nonneg int c, const std::string& otn)
+    ValueType(Sign s, Type t, nonneg int p, nonneg int c, std::string otn)
         : sign(s),
-          type(t),
-          bits(0),
-          pointer(p),
-          constness(c),
-          typeScope(nullptr),
-          smartPointerType(nullptr),
-          smartPointerTypeToken(nullptr),
-          container(nullptr),
-          containerTypeToken(nullptr),
-          originalTypeName(otn)
+        type(t),
+        pointer(p),
+        constness(c),
+        originalTypeName(std::move(otn))
     {}
-    ValueType &operator=(const ValueType &other) = delete;
 
-    static ValueType parseDecl(const Token *type, const Settings *settings);
+    static ValueType parseDecl(const Token *type, const Settings &settings);
 
     static Type typeFromString(const std::string &typestr, bool longType);
 
-    enum class MatchResult { UNKNOWN, SAME, FALLBACK1, FALLBACK2, NOMATCH };
+    enum class MatchResult : std::uint8_t { UNKNOWN, SAME, FALLBACK1, FALLBACK2, NOMATCH };
     static MatchResult matchParameter(const ValueType *call, const ValueType *func);
     static MatchResult matchParameter(const ValueType *call, const Variable *callVar, const Variable *funcVar);
 
+    bool isPrimitive() const {
+        return (type >= ValueType::Type::BOOL);
+    }
+
     bool isIntegral() const {
         return (type >= ValueType::Type::BOOL && type <= ValueType::Type::UNKNOWN_INT);
     }
@@ -1213,33 +1305,50 @@ class CPPCHECKLIB ValueType {
         return (type >= ValueType::Type::FLOAT && type <= ValueType::Type::LONGDOUBLE);
     }
 
-    bool fromLibraryType(const std::string &typestr, const Settings *settings);
+    bool fromLibraryType(const std::string &typestr, const Settings &settings);
 
     bool isEnum() const {
-        return typeScope && typeScope->type == Scope::eEnum;
+        return typeScope && typeScope->type == ScopeType::eEnum;
     }
 
-    MathLib::bigint typeSize(const cppcheck::Platform &platform) const;
+    bool isConst(nonneg int indirect = 0) const;
+
+    bool isVolatile(nonneg int indirect = 0) const;
+
+    enum class Accuracy : std::uint8_t {
+        ExactOrZero,
+        LowerBound,
+    };
+    enum class SizeOf : std::uint8_t {
+        Pointer,
+        Pointee,
+    };
+    size_t getSizeOf(const Settings& settings, Accuracy accuracy, SizeOf sizeOf, int maxRecursion = 0) const;
+
+    /// Check if type is the same ignoring const and references
+    bool isTypeEqual(const ValueType* that) const;
 
     std::string str() const;
     std::string dump() const;
+
+    void setDebugPath(const Token* tok, SourceLocation ctx, const SourceLocation &local = SourceLocation::current());
 };
 
 
 class CPPCHECKLIB SymbolDatabase {
     friend class TestSymbolDatabase;
 public:
-    SymbolDatabase(const Tokenizer *tokenizer, const Settings *settings, ErrorLogger *errorLogger);
+    explicit SymbolDatabase(Tokenizer& tokenizer);
     ~SymbolDatabase();
 
-    /** @brief Information about all namespaces/classes/structrues */
+    /** @brief Information about all namespaces/classes/structures */
     std::list<Scope> scopeList;
 
     /** @brief Fast access to function scopes */
-    std::vector<const Scope *> functionScopes;
+    std::vector<const Scope*> functionScopes;
 
     /** @brief Fast access to class and struct scopes */
-    std::vector<const Scope *> classAndStructScopes;
+    std::vector<const Scope*> classAndStructScopes;
 
     /** @brief Fast access to types */
     std::list<Type> typeList;
@@ -1250,25 +1359,32 @@ class CPPCHECKLIB SymbolDatabase {
      * @param typeTok token containing variable type
      * @return pointer to type if found or NULL if not found
      */
-    const Type *findVariableType(const Scope *start, const Token *typeTok) const;
+    const Type* findVariableType(const Scope* start, const Token* typeTok) const;
 
     /**
      * @brief find a function
      * @param tok token of function call
      * @return pointer to function if found or NULL if not found
      */
-    const Function *findFunction(const Token *tok) const;
+    const Function* findFunction(const Token* tok) const;
 
-    const Scope *findScopeByName(const std::string& name) const;
+    /** For unit testing only */
+    const Scope* findScopeByName(const std::string& name) const;
 
-    const Type* findType(const Token *startTok, const Scope *startScope) const;
-    Type* findType(const Token *startTok, Scope *startScope) const {
-        return const_cast<Type*>(this->findType(startTok, const_cast<const Scope *>(startScope)));
+    const Type* findType(const Token* startTok, const Scope* startScope, bool lookOutside = false) const;
+    Type* findType(const Token* startTok, Scope* startScope, bool lookOutside = false)
+    {
+        return const_cast<Type*>(this->findType(startTok, static_cast<const Scope*>(startScope), lookOutside));
     }
 
     const Scope *findScope(const Token *tok, const Scope *startScope) const;
-    Scope *findScope(const Token *tok, Scope *startScope) const {
-        return const_cast<Scope *>(this->findScope(tok, const_cast<const Scope *>(startScope)));
+    Scope *findScope(const Token *tok, Scope *startScope) {
+        return const_cast<Scope *>(this->findScope(tok, static_cast<const Scope *>(startScope)));
+    }
+
+    // cppcheck-suppress unusedFunction
+    bool isVarId(nonneg int varid) const {
+        return varid < mVariableList.size();
     }
 
     const Variable *getVariableFromVarId(nonneg int varId) const {
@@ -1282,27 +1398,21 @@ class CPPCHECKLIB SymbolDatabase {
     /**
      * @brief output a debug message
      */
-    void debugMessage(const Token *tok, const std::string &msg) const;
+    void debugMessage(const Token *tok, const std::string &type, const std::string &msg) const;
+
+    void returnImplicitIntError(const Token *tok) const;
 
     void printOut(const char * title = nullptr) const;
     void printVariable(const Variable *var, const char *indent) const;
     void printXml(std::ostream &out) const;
 
-    bool isCPP() const;
-
     /*
      * @brief Do a sanity check
      */
     void validate() const;
 
-    void validateExecutableScopes() const;
-    /**
-     * @brief Check variable list, e.g. variables w/o scope
-     */
-    void validateVariables() const;
-
     /** Set valuetype in provided tokenlist */
-    void setValueTypeInTokenList(bool reportDebugWarnings);
+    void setValueTypeInTokenList(bool reportDebugWarnings, Token *tokens=nullptr);
 
     /**
      * Calculates sizeof value for given type.
@@ -1314,11 +1424,26 @@ class CPPCHECKLIB SymbolDatabase {
     /** Set array dimensions when valueflow analysis is completed */
     void setArrayDimensionsUsingValueFlow();
 
+    void clangSetVariables(const std::vector<const Variable *> &variableList);
+    void createSymbolDatabaseExprIds();
+
+    /* returns the opening { if tok points to enum */
+    static const Token* isEnumDefinition(const Token* tok);
+
+    static void getErrorMessages(ErrorLogger &errorLogger);
+
+    // check if type has no side effects (no constructors and no members with constructors)
+    /** @todo false negative: check constructors for side effects */
+    bool isRecordTypeWithoutSideEffects(const Type* type) const;
+
 private:
     friend class Scope;
     friend class Function;
 
     // Create symboldatabase...
+    /**
+     * @throws InternalError thrown on unhandled code
+     */
     void createSymbolDatabaseFindAllScopes();
     void createSymbolDatabaseClassInfo();
     void createSymbolDatabaseVariableInfo();
@@ -1332,37 +1457,54 @@ class CPPCHECKLIB SymbolDatabase {
     void createSymbolDatabaseSetFunctionPointers(bool firstPass);
     void createSymbolDatabaseSetVariablePointers();
     void createSymbolDatabaseSetTypePointers();
+    void createSymbolDatabaseSetSmartPointerType();
     void createSymbolDatabaseEnums();
     void createSymbolDatabaseEscapeFunctions();
     void createSymbolDatabaseIncompleteVars();
 
-    void addClassFunction(Scope **scope, const Token **tok, const Token *argStart);
-    Function *addGlobalFunctionDecl(Scope*& scope, const Token* tok, const Token *argStart, const Token* funcStart);
+    void debugSymbolDatabase() const;
+
+    void addClassFunction(Scope *&scope, const Token *&tok, const Token *argStart);
+    RET_NONNULL static Function *addGlobalFunctionDecl(Scope*& scope, const Token* tok, const Token *argStart, const Token* funcStart);
     Function *addGlobalFunction(Scope*& scope, const Token*& tok, const Token *argStart, const Token* funcStart);
-    void addNewFunction(Scope **scope, const Token **tok);
-    bool isFunction(const Token *tok, const Scope* outerScope, const Token **funcStart, const Token **argStart, const Token** declEnd) const;
+    /**
+     * @throws InternalError thrown on unrecognized function
+     */
+    void addNewFunction(Scope *&scope, const Token *&tok);
+    bool isFunction(const Token *tok, const Scope* outerScope, const Token *&funcStart, const Token *&argStart, const Token*& declEnd) const;
     const Type *findTypeInNested(const Token *startTok, const Scope *startScope) const;
     const Scope *findNamespace(const Token * tok, const Scope * scope) const;
-    Function *findFunctionInScope(const Token *func, const Scope *ns, const std::string & path, nonneg int path_length);
-    const Type *findVariableTypeInBase(const Scope *scope, const Token *typeTok) const;
+    static Function *findFunctionInScope(const Token *func, const Scope *ns, const std::string & path, nonneg int path_length);
+    static const Type *findVariableTypeInBase(const Scope *scope, const Token *typeTok);
 
-    typedef std::map<unsigned int, unsigned int> MemberIdMap;
-    typedef std::map<unsigned int, MemberIdMap> VarIdMap;
+    using MemberIdMap = std::map<unsigned int, unsigned int>;
+    using VarIdMap = std::map<unsigned int, MemberIdMap>;
 
     void fixVarId(VarIdMap & varIds, const Token * vartok, Token * membertok, const Variable * membervar);
 
-    /** Whether iName is a keyword as defined in http://en.cppreference.com/w/c/keyword and http://en.cppreference.com/w/cpp/keyword*/
-    bool isReservedName(const std::string& iName) const;
+    /** Whether the token is a keyword as defined in http://en.cppreference.com/w/c/keyword and http://en.cppreference.com/w/cpp/keyword*/
+    static bool isReservedName(const Token* tok);
+
+    const Enumerator * findEnumerator(const Token * tok, std::set<std::string>& tokensThatAreNotEnumeratorValues) const;
 
-    const Enumerator * findEnumerator(const Token * tok) const;
+    void setValueType(Token* tok, const ValueType& valuetype, const SourceLocation &loc = SourceLocation::current());
+    void setValueType(Token* tok, const Variable& var, const SourceLocation &loc = SourceLocation::current());
+    void setValueType(Token* tok, const Enumerator& enumerator, const SourceLocation &loc = SourceLocation::current());
+
+    void validateExecutableScopes() const;
+    /**
+     * @brief Check variable list, e.g. variables w/o scope
+     * @throws InternalError thrown on variable without scope
+     */
+    void validateVariables() const;
 
-    void setValueType(Token *tok, const ValueType &valuetype);
-    void setValueType(Token *tok, const Variable &var);
-    void setValueType(Token *tok, const Enumerator &enumerator);
+    bool isVariableWithoutSideEffects(const Variable& var, const Type* type = nullptr) const;
+    bool isFunctionWithoutSideEffects(const Function& func, const Token* functionUsageToken,
+                                      std::list<const Function*> checkedFuncs) const;
 
-    const Tokenizer *mTokenizer;
-    const Settings *mSettings;
-    ErrorLogger *mErrorLogger;
+    Tokenizer& mTokenizer;
+    const Settings &mSettings;
+    ErrorLogger &mErrorLogger;
 
     /** variable symbol table */
     std::vector<const Variable *> mVariableList;
@@ -1370,11 +1512,9 @@ class CPPCHECKLIB SymbolDatabase {
     /** list for missing types */
     std::list<Type> mBlankTypes;
 
-    bool mIsCpp;
     ValueType::Sign mDefaultSignedness;
 
-    /** "negative cache" list of tokens that we find are not enumeration values */
-    mutable std::set<std::string> mTokensThatAreNotEnumeratorValues;
+    mutable std::map<const Type*, bool> mIsRecordTypeWithoutSideEffectsMap;
 };
 
 
diff --git a/lib/templatesimplifier.cpp b/lib/templatesimplifier.cpp
index aee8a5555b8..d73b3e7a9aa 100644
--- a/lib/templatesimplifier.cpp
+++ b/lib/templatesimplifier.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,19 +19,50 @@
 #include "templatesimplifier.h"
 
 #include "errorlogger.h"
+#include "errortypes.h"
 #include "mathlib.h"
 #include "settings.h"
+#include "standards.h"
 #include "token.h"
 #include "tokenize.h"
 #include "tokenlist.h"
+#include "utils.h"
 
 #include <algorithm>
 #include <cassert>
 #include <iostream>
 #include <map>
+#include <memory>
 #include <stack>
+#include <type_traits>
 #include <utility>
 
+static Token *skipRequires(Token *tok)
+{
+    if (!Token::simpleMatch(tok, "requires"))
+        return tok;
+
+    while (Token::Match(tok, "%oror%|&&|requires %name%|(")) {
+        Token *after = tok->next();
+        if (after->str() == "(") {
+            tok = after->link()->next();
+            continue;
+        }
+        if (Token::simpleMatch(after, "requires (") && Token::simpleMatch(after->linkAt(1), ") {")) {
+            tok = after->linkAt(1)->linkAt(1)->next();
+            continue;
+        }
+        while (Token::Match(after, "%name% :: %name%"))
+            after = after->tokAt(2);
+        if (Token::Match(after, "%name% <")) {
+            after = after->next()->findClosingBracket();
+            tok = after ? after->next() : nullptr;
+        } else
+            break;
+    }
+    return tok;
+}
+
 namespace {
     class FindToken {
     public:
@@ -45,7 +76,7 @@ namespace {
 
     class FindName {
     public:
-        explicit FindName(const std::string &name) : mName(name) {}
+        explicit FindName(std::string name) : mName(std::move(name)) {}
         bool operator()(const TemplateSimplifier::TokenAndName &tokenAndName) const {
             return tokenAndName.name() == mName;
         }
@@ -55,7 +86,7 @@ namespace {
 
     class FindFullName {
     public:
-        explicit FindFullName(const std::string &fullName) : mFullName(fullName) {}
+        explicit FindFullName(std::string fullName) : mFullName(std::move(fullName)) {}
         bool operator()(const TemplateSimplifier::TokenAndName &tokenAndName) const {
             return tokenAndName.fullName() == mFullName;
         }
@@ -64,17 +95,24 @@ namespace {
     };
 }
 
-TemplateSimplifier::TokenAndName::TokenAndName(Token *token, const std::string &scope) :
-    mToken(token), mScope(scope), mName(mToken ? mToken->str() : ""),
+TemplateSimplifier::TokenAndName::TokenAndName(Token *token, std::string scope) :
+    mToken(token), mScope(std::move(scope)), mName(mToken ? mToken->str() : ""),
     mFullName(mScope.empty() ? mName : (mScope + " :: " + mName)),
     mNameToken(nullptr), mParamEnd(nullptr), mFlags(0)
 {
-    if (mToken)
+    if (mToken) {
+        if (mToken->strAt(1) == "<") {
+            const Token *end = mToken->next()->findClosingBracket();
+            if (end && end->strAt(1) == "(") {
+                isFunction(true);
+            }
+        }
         mToken->templateSimplifierPointer(this);
+    }
 }
 
-TemplateSimplifier::TokenAndName::TokenAndName(Token *token, const std::string &scope, const Token *nameToken, const Token *paramEnd) :
-    mToken(token), mScope(scope), mName(nameToken->str()),
+TemplateSimplifier::TokenAndName::TokenAndName(Token *token, std::string scope, const Token *nameToken, const Token *paramEnd) :
+    mToken(token), mScope(std::move(scope)), mName(nameToken->str()),
     mFullName(mScope.empty() ? mName : (mScope + " :: " + mName)),
     mNameToken(nameToken), mParamEnd(paramEnd), mFlags(0)
 {
@@ -113,7 +151,7 @@ TemplateSimplifier::TokenAndName::TokenAndName(Token *token, const std::string &
         isClass(Token::Match(next, "class|struct|union %name% <|{|:|;|::"));
         if (mToken->strAt(1) == "<" && !isSpecialization()) {
             const Token *end = mToken->next()->findClosingBracket();
-            isVariadic(end && Token::findmatch(mToken->tokAt(2), "typename|class ...", end));
+            isVariadic(end && Token::findmatch(mToken->tokAt(2), "%name% ...", end));
         }
         const Token *tok1 = mNameToken->next();
         if (tok1->str() == "<") {
@@ -144,23 +182,27 @@ TemplateSimplifier::TokenAndName::TokenAndName(Token *token, const std::string &
             }
         }
         // check for member class or function and adjust scope
-        if ((isFunction() || isClass()) && mNameToken->strAt(-1) == "::") {
+        if ((isFunction() || isClass()) &&
+            (mNameToken->strAt(-1) == "::" || Token::simpleMatch(mNameToken->tokAt(-2), ":: ~"))) {
             const Token * start = mNameToken;
+            if (start->strAt(-1) == "~")
+                start = start->previous();
+            const Token *end = start;
 
-            while (Token::Match(start->tokAt(-2), "%name% ::") ||
-                   (Token::simpleMatch(start->tokAt(-2), "> ::") &&
-                    start->tokAt(-2)->findOpeningBracket() &&
-                    Token::Match(start->tokAt(-2)->findOpeningBracket()->previous(), "%name% <"))) {
+            while (start && (Token::Match(start->tokAt(-2), "%name% ::") ||
+                             (Token::simpleMatch(start->tokAt(-2), "> ::") &&
+                              start->tokAt(-2)->findOpeningBracket() &&
+                              Token::Match(start->tokAt(-2)->findOpeningBracket()->previous(), "%name% <")))) {
                 if (start->strAt(-2) == ">")
                     start = start->tokAt(-2)->findOpeningBracket()->previous();
                 else
                     start = start->tokAt(-2);
             }
 
-            if (start && start != nameToken) {
+            if (start && start != end) {
                 if (!mScope.empty())
                     mScope += " ::";
-                while (start && start->next() != mNameToken) {
+                while (start && start->next() != end) {
                     if (start->str() == "<")
                         start = start->findClosingBracket();
                     else {
@@ -177,9 +219,8 @@ TemplateSimplifier::TokenAndName::TokenAndName(Token *token, const std::string &
     }
 
     // make sure at most only one family flag is set
-    assert(isClass() ? !(isFunction() || isVariable()) : true);
-    assert(isFunction() ? !(isClass() || isVariable()) : true);
-    assert(isVariable() ? !(isClass() || isFunction()) : true);
+    if (isClass() + isFunction() + isVariable() > 1)
+        syntaxError(token);
 
     if (mToken)
         mToken->templateSimplifierPointer(this);
@@ -195,8 +236,15 @@ TemplateSimplifier::TokenAndName::TokenAndName(const TokenAndName& other) :
 
 TemplateSimplifier::TokenAndName::~TokenAndName()
 {
-    if (mToken)
-        mToken->templateSimplifierPointers().erase(this);
+    if (mToken && mToken->templateSimplifierPointers())
+        mToken->templateSimplifierPointers()->erase(this);
+}
+
+std::string TemplateSimplifier::TokenAndName::dump(const std::vector<std::string>& fileNames) const {
+    std::string ret = "    <TokenAndName name=\"" + ErrorLogger::toxml(mName) + "\" file=\"" + ErrorLogger::toxml(fileNames.at(mToken->fileIndex())) + "\" line=\"" + std::to_string(mToken->linenr()) + "\">\n";
+    for (const Token* tok = mToken; tok && !Token::Match(tok, "[;{}]"); tok = tok->next())
+        ret += "      <template-token str=\"" + ErrorLogger::toxml(tok->str()) + "\"/>\n";
+    return ret + "    </TokenAndName>\n";
 }
 
 const Token * TemplateSimplifier::TokenAndName::aliasStartToken() const
@@ -224,87 +272,10 @@ bool TemplateSimplifier::TokenAndName::isAliasToken(const Token *tok) const
     return false;
 }
 
-TemplateSimplifier::TemplateSimplifier(Tokenizer *tokenizer)
-    : mTokenizer(tokenizer), mTokenList(tokenizer->list), mSettings(tokenizer->mSettings),
-      mErrorLogger(tokenizer->mErrorLogger), mChanged(false)
-{
-}
-
-TemplateSimplifier::~TemplateSimplifier()
-{
-}
-
-void TemplateSimplifier::fixAngleBrackets()
-{
-    for (Token *tok = mTokenList.front(); tok; tok = tok->next()) {
-        // Ticket #6181: normalize C++11 template parameter list closing syntax
-        if (tok->str() == "<" && templateParameters(tok)) {
-            Token *endTok = tok->findClosingBracket();
-            if (endTok && endTok->str() == ">>") {
-                endTok->str(">");
-                endTok->insertToken(">");
-            }
-        } else if (Token::Match(tok, "class|struct|union|=|:|public|protected|private %name% <")) {
-            Token *endTok = tok->tokAt(2)->findClosingBracket();
-            if (Token::Match(endTok, ">> ;|{")) {
-                endTok->str(">");
-                endTok->insertToken(">");
-            }
-        }
-    }
-}
-
-void TemplateSimplifier::cleanupAfterSimplify()
-{
-    bool goback = false;
-    for (Token *tok = mTokenList.front(); tok; tok = tok->next()) {
-        if (goback) {
-            tok = tok->previous();
-            goback = false;
-        }
-        if (tok->str() == "(")
-            tok = tok->link();
-
-        else if (Token::Match(tok, "template < > %name%")) {
-            const Token *end = tok;
-            while (end) {
-                if (end->str() == ";")
-                    break;
-                if (end->str() == "{") {
-                    end = end->link()->next();
-                    break;
-                }
-                if (!Token::Match(end, "%name%|::|<|>|,")) {
-                    end = nullptr;
-                    break;
-                }
-                end = end->next();
-            }
-            if (end) {
-                Token::eraseTokens(tok,end);
-                tok->deleteThis();
-            }
-        }
-
-        else if (Token::Match(tok, "%type% <") &&
-                 (!tok->previous() || tok->previous()->str() == ";")) {
-            const Token *tok2 = tok->tokAt(2);
-            std::string type;
-            while (Token::Match(tok2, "%type%|%num% ,")) {
-                type += tok2->str() + ",";
-                tok2 = tok2->tokAt(2);
-            }
-            if (Token::Match(tok2, "%type%|%num% > (")) {
-                type += tok2->str();
-                tok->str(tok->str() + "<" + type + ">");
-                Token::eraseTokens(tok, tok2->tokAt(2));
-                if (tok == mTokenList.front())
-                    goback = true;
-            }
-        }
-    }
-}
-
+TemplateSimplifier::TemplateSimplifier(Tokenizer &tokenizer)
+    : mTokenizer(tokenizer), mTokenList(mTokenizer.list), mSettings(mTokenizer.getSettings()),
+    mErrorLogger(mTokenizer.getErrorLogger())
+{}
 
 void TemplateSimplifier::checkComplicatedSyntaxErrorsInTemplates()
 {
@@ -324,11 +295,11 @@ void TemplateSimplifier::checkComplicatedSyntaxErrorsInTemplates()
 
         // skip executing scopes (ticket #1985)..
         else if (Token::simpleMatch(tok, "try {")) {
-            tok = tok->next()->link();
+            tok = tok->linkAt(1);
             while (Token::simpleMatch(tok, "} catch (")) {
                 tok = tok->linkAt(2);
                 if (Token::simpleMatch(tok, ") {"))
-                    tok = tok->next()->link();
+                    tok = tok->linkAt(1);
             }
         }
 
@@ -349,14 +320,15 @@ void TemplateSimplifier::checkComplicatedSyntaxErrorsInTemplates()
             break;
 
         // template variable or type..
-        if (Token::Match(tok, "%type% <")) {
+        if (Token::Match(tok, "%type% <") && !Token::simpleMatch(tok, "template")) {
             // these are used types..
             std::set<std::string> usedtypes;
 
             // parse this statement and see if the '<' and '>' are matching
             unsigned int level = 0;
             for (const Token *tok2 = tok; tok2 && !Token::simpleMatch(tok2, ";"); tok2 = tok2->next()) {
-                if (Token::simpleMatch(tok2, "{") && (!Token::Match(tok2->previous(), ">|%type%") || Token::simpleMatch(tok2->link(), "} ;")))
+                if (Token::simpleMatch(tok2, "{") &&
+                    (!Token::Match(tok2->previous(), ">|%type%") || Token::simpleMatch(tok2->link(), "} ;")))
                     break;
                 if (tok2->str() == "(")
                     tok2 = tok2->link();
@@ -366,15 +338,17 @@ void TemplateSimplifier::checkComplicatedSyntaxErrorsInTemplates()
                         ;
                     else if (level == 0 && Token::Match(tok2->previous(), "%type%")) {
                         // @todo add better expression detection
-                        if (!Token::Match(tok2->next(), "*| %type%|%num% ;"))
+                        if (!(Token::Match(tok2->next(), "*| %type%|%num% ;") ||
+                              Token::Match(tok2->next(), "*| %type% . %type% ;"))) {
                             inclevel = true;
-                    } else if (tok2->next() && tok2->next()->isStandardType())
+                        }
+                    } else if (tok2->next() && tok2->next()->isStandardType() && !Token::Match(tok2->tokAt(2), "(|{"))
                         inclevel = true;
                     else if (Token::simpleMatch(tok2, "< typename"))
                         inclevel = true;
-                    else if (Token::Match(tok2->tokAt(-2), "<|, %type% <") && usedtypes.find(tok2->previous()->str()) != usedtypes.end())
+                    else if (Token::Match(tok2->tokAt(-2), "<|, %type% <") && usedtypes.find(tok2->strAt(-1)) != usedtypes.end())
                         inclevel = true;
-                    else if (Token::Match(tok2, "< %type%") && usedtypes.find(tok2->next()->str()) != usedtypes.end())
+                    else if (Token::Match(tok2, "< %type%") && usedtypes.find(tok2->strAt(1)) != usedtypes.end())
                         inclevel = true;
                     else if (Token::Match(tok2, "< %type%")) {
                         // is the next token a type and not a variable/constant?
@@ -390,7 +364,7 @@ void TemplateSimplifier::checkComplicatedSyntaxErrorsInTemplates()
                     if (inclevel) {
                         ++level;
                         if (Token::Match(tok2->tokAt(-2), "<|, %type% <"))
-                            usedtypes.insert(tok2->previous()->str());
+                            usedtypes.insert(tok2->strAt(-1));
                     }
                 } else if (tok2->str() == ">") {
                     if (level > 0)
@@ -432,9 +406,11 @@ unsigned int TemplateSimplifier::templateParameters(const Token *tok)
                 if (closing->str() == ">>")
                     return numberOfParameters;
                 tok = closing->next();
-                if (tok->str() == ">" || tok->str() == ">>")
+                if (!tok)
+                    syntaxError(tok);
+                if (Token::Match(tok, ">|>>|>>="))
                     return numberOfParameters;
-                else if (tok->str() == ",") {
+                if (tok->str() == ",") {
                     ++numberOfParameters;
                     tok = tok->next();
                     continue;
@@ -458,7 +434,7 @@ unsigned int TemplateSimplifier::templateParameters(const Token *tok)
         // Skip variadic types (Ticket #5774, #6059, #6172)
         if (Token::simpleMatch(tok, "...")) {
             if ((tok->previous()->isName() && !Token::Match(tok->tokAt(-2), "<|,|::")) ||
-                (!tok->previous()->isName() && tok->strAt(-1) != ">"))
+                (!tok->previous()->isName() && !Token::Match(tok->previous(), ">|&|&&|*")))
                 return 0; // syntax error
             tok = tok->next();
             if (!tok)
@@ -467,12 +443,13 @@ unsigned int TemplateSimplifier::templateParameters(const Token *tok)
                 if (level == 0)
                     return numberOfParameters;
                 --level;
-            } else if (tok->str() == ">>") {
+            } else if (tok->str() == ">>" || tok->str() == ">>=") {
                 if (level == 1)
                     return numberOfParameters;
                 level -= 2;
-            } else if (tok->str() == "," && level == 0) {
-                ++numberOfParameters;
+            } else if (tok->str() == ",") {
+                if (level == 0)
+                    ++numberOfParameters;
                 tok = tok->next();
                 continue;
             }
@@ -493,17 +470,18 @@ unsigned int TemplateSimplifier::templateParameters(const Token *tok)
                 return 0;
             if (tok->str() == ">" && level == 0)
                 return numberOfParameters;
-            else if (tok->str() == ">>" && level == 1)
+            if ((tok->str() == ">>" || tok->str() == ">>=") && level == 1)
                 return numberOfParameters;
-            else if (tok->str() == "," && level == 0) {
-                ++numberOfParameters;
+            if (tok->str() == ",") {
+                if (level == 0)
+                    ++numberOfParameters;
                 tok = tok->next();
             }
             continue;
         }
 
         // skip std::
-        if (tok && tok->str() == "::")
+        if (tok->str() == "::")
             tok = tok->next();
         while (Token::Match(tok, "%name% ::")) {
             tok = tok->tokAt(2);
@@ -514,7 +492,7 @@ unsigned int TemplateSimplifier::templateParameters(const Token *tok)
             return 0;
 
         // num/type ..
-        if (!tok->isNumber() && tok->tokType() != Token::eChar && !tok->isName() && !tok->isOp())
+        if (!tok->isNumber() && tok->tokType() != Token::eChar && tok->tokType() != Token::eString && !tok->isName() && !tok->isOp())
             return 0;
         tok = tok->next();
         if (!tok)
@@ -540,7 +518,7 @@ unsigned int TemplateSimplifier::templateParameters(const Token *tok)
             return 0;
 
         // inner template
-        if (tok->str() == "<") {
+        if (tok->str() == "<" && tok->previous()->isName()) {
             ++level;
             tok = tok->next();
         }
@@ -549,18 +527,18 @@ unsigned int TemplateSimplifier::templateParameters(const Token *tok)
             return 0;
 
         // ,/>
-        while (Token::Match(tok, ">|>>")) {
+        while (Token::Match(tok, ">|>>|>>=")) {
             if (level == 0)
                 return tok->str() == ">" && !Token::Match(tok->next(), "%num%") ? numberOfParameters : 0;
             --level;
-            if (tok->str() == ">>") {
+            if (tok->str() == ">>" || tok->str() == ">>=") {
                 if (level == 0)
                     return !Token::Match(tok->next(), "%num%") ? numberOfParameters : 0;
                 --level;
             }
             tok = tok->next();
 
-            if (Token::simpleMatch(tok,"("))
+            if (Token::Match(tok, "(|["))
                 tok = tok->link()->next();
 
             if (!tok)
@@ -576,12 +554,8 @@ unsigned int TemplateSimplifier::templateParameters(const Token *tok)
     return 0;
 }
 
-const Token *TemplateSimplifier::findTemplateDeclarationEnd(const Token *tok)
-{
-    return const_cast<const Token *>(findTemplateDeclarationEnd(const_cast<Token *>(tok)));
-}
-
-Token *TemplateSimplifier::findTemplateDeclarationEnd(Token *tok)
+template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+static T *findTemplateDeclarationEndImpl(T *tok)
 {
     if (Token::simpleMatch(tok, "template <")) {
         tok = tok->next()->findClosingBracket();
@@ -592,12 +566,20 @@ Token *TemplateSimplifier::findTemplateDeclarationEnd(Token *tok)
     if (!tok)
         return nullptr;
 
-    Token * tok2 = tok;
+    T * tok2 = tok;
+    bool in_init = false;
     while (tok2 && !Token::Match(tok2, ";|{")) {
         if (tok2->str() == "<")
             tok2 = tok2->findClosingBracket();
         else if (Token::Match(tok2, "(|[") && tok2->link())
             tok2 = tok2->link();
+        else if (tok2->str() == ":")
+            in_init = true;
+        else if (in_init && Token::Match(tok2, "%name% (|{")) {
+            tok2 = tok2->linkAt(1);
+            if (tok2->strAt(1) == "{")
+                in_init = false;
+        }
         if (tok2)
             tok2 = tok2->next();
     }
@@ -613,6 +595,16 @@ Token *TemplateSimplifier::findTemplateDeclarationEnd(Token *tok)
     return tok;
 }
 
+Token *TemplateSimplifier::findTemplateDeclarationEnd(Token *tok)
+{
+    return findTemplateDeclarationEndImpl(tok);
+}
+
+const Token *TemplateSimplifier::findTemplateDeclarationEnd(const Token *tok)
+{
+    return findTemplateDeclarationEndImpl(tok);
+}
+
 void TemplateSimplifier::eraseTokens(Token *begin, const Token *end)
 {
     if (!begin || begin == end)
@@ -631,71 +623,29 @@ void TemplateSimplifier::deleteToken(Token *tok)
         tok->deleteThis();
 }
 
-bool TemplateSimplifier::removeTemplate(Token *tok)
+static void invalidateForwardDecls(const Token* beg, const Token* end, std::map<Token*, Token*>* forwardDecls) {
+    if (!forwardDecls)
+        return;
+    for (auto& fwd : *forwardDecls) {
+        for (const Token* tok = beg; tok != end; tok = tok->next())
+            if (fwd.second == tok) {
+                fwd.second = nullptr;
+                break;
+            }
+    }
+}
+
+bool TemplateSimplifier::removeTemplate(Token *tok, std::map<Token*, Token*>* forwardDecls)
 {
     if (!Token::simpleMatch(tok, "template <"))
         return false;
 
-    int indentlevel = 0;
-    unsigned int countgt = 0;   // Counter for ">"
-    for (const Token *tok2 = tok->next(); tok2; tok2 = tok2->next()) {
-
-        if (tok2->str() == "(") {
-            tok2 = tok2->link();
-        } else if (tok2->str() == ")") {  // garbage code! (#3504)
-            eraseTokens(tok,tok2);
-            deleteToken(tok);
-            return false;
-        }
-
-        else if (tok2->str() == "{") {
-            tok2 = tok2->link();
-            if (indentlevel < 2) {
-                tok2 = tok2->next();
-                if (tok2 && tok2->str() == ";" && tok2->next())
-                    tok2 = tok2->next();
-                eraseTokens(tok, tok2);
-                deleteToken(tok);
-                return true;
-            }
-        } else if (tok2->str() == "}") {  // garbage code! (#3449)
-            eraseTokens(tok,tok2);
-            deleteToken(tok);
-            return false;
-        }
-
-        // Count ">"
-        if (tok2->str() == ">")
-            countgt++;
-
-        // don't remove constructor
-        if (tok2->str() == "explicit" ||
-            (countgt == 1 && Token::Match(tok2->previous(), "> %type% (") &&
-             Tokenizer::startOfExecutableScope(tok2->linkAt(1)))) {
-            eraseTokens(tok, tok2);
-            deleteToken(tok);
-            return true;
-        }
-
-        if (tok2->str() == ";") {
-            tok2 = tok2->next();
-            eraseTokens(tok, tok2);
-            deleteToken(tok);
-            return true;
-        }
-
-        if (tok2->str() == "<")
-            ++indentlevel;
-
-        else if (indentlevel >= 2 && tok2->str() == ">")
-            --indentlevel;
-
-        else if (Token::Match(tok2, "> class|struct|union %name% [,)]")) {
-            tok2 = tok2->next();
-            eraseTokens(tok, tok2);
-            deleteToken(tok);
-            return true;
-        }
+    Token *end = findTemplateDeclarationEnd(tok);
+    if (end && end->next()) {
+        invalidateForwardDecls(tok, end->next(), forwardDecls);
+        eraseTokens(tok, end->next());
+        deleteToken(tok);
+        return true;
     }
 
     return false;
@@ -708,24 +658,21 @@ bool TemplateSimplifier::getTemplateDeclarations()
         if (!Token::simpleMatch(tok, "template <"))
             continue;
         // ignore template template parameter
-        if (tok->strAt(-1) == "<")
+        if (tok->strAt(-1) == "<" || tok->strAt(-1) == ",")
             continue;
         // ignore nested template
         if (tok->strAt(-1) == ">")
             continue;
         // skip to last nested template parameter
         const Token *tok1 = tok;
-        while (tok1 && tok1->next() && Token::simpleMatch(tok1->next()->findClosingBracket(), "> template <")) {
+        while (tok1 && tok1->next()) {
             const Token *closing = tok1->next()->findClosingBracket();
-            if (!closing)
-                syntaxError(tok1->next());
+            if (!Token::simpleMatch(closing, "> template <"))
+                break;
             tok1 = closing->next();
         }
-        if (!tok1)
+        if (!Token::Match(tok, "%any% %any%"))
             syntaxError(tok);
-        // Some syntax checks, see #6865
-        if (!tok->tokAt(2))
-            syntaxError(tok->next());
         if (tok->strAt(2)=="typename" &&
             !Token::Match(tok->tokAt(3), "%name%|...|,|=|>"))
             syntaxError(tok->next());
@@ -742,6 +689,8 @@ bool TemplateSimplifier::getTemplateDeclarations()
             else if (Token::Match(tok2, "{|=|;")) {
                 const int namepos = getTemplateNamePosition(parmEnd);
                 if (namepos > 0) {
+                    if (!tok->scopeInfo())
+                        syntaxError(tok);
                     TokenAndName decl(tok, tok->scopeInfo()->name, parmEnd->tokAt(namepos), parmEnd);
                     if (decl.isForwardDeclaration()) {
                         // Declaration => add to mTemplateForwardDeclarations
@@ -750,6 +699,9 @@ bool TemplateSimplifier::getTemplateDeclarations()
                         // Implementation => add to mTemplateDeclarations
                         mTemplateDeclarations.emplace_back(std::move(decl));
                     }
+                    Token *end = findTemplateDeclarationEnd(tok);
+                    if (end)
+                        tok = end;
                     break;
                 }
             }
@@ -762,7 +714,78 @@ void TemplateSimplifier::addInstantiation(Token *token, const std::string &scope
 {
     simplifyTemplateArgs(token->tokAt(2), token->next()->findClosingBracket());
 
-    mTemplateInstantiations.emplace_back(token, scope);
+    TokenAndName instantiation(token, scope);
+
+    // check if instantiation already exists before adding it
+    const auto it = std::find(mTemplateInstantiations.cbegin(),
+                              mTemplateInstantiations.cend(),
+                              instantiation);
+
+    if (it == mTemplateInstantiations.cend())
+        mTemplateInstantiations.emplace_back(std::move(instantiation));
+}
+
+static const Token* getFunctionToken(const Token* nameToken)
+{
+    if (Token::Match(nameToken, "%name% ("))
+        return nameToken->next();
+
+    if (Token::Match(nameToken, "%name% <")) {
+        const Token* end = nameToken->next()->findClosingBracket();
+        if (Token::simpleMatch(end, "> ("))
+            return end->next();
+    }
+
+    return nullptr;
+}
+
+static void getFunctionArguments(const Token* nameToken, std::vector<const Token*>& args)
+{
+    const Token* functionToken = getFunctionToken(nameToken);
+    if (!functionToken)
+        return;
+
+    const Token* argToken = functionToken->next();
+
+    if (argToken->str() == ")")
+        return;
+
+    args.push_back(argToken);
+
+    while ((argToken = argToken->nextArgumentBeforeCreateLinks2()))
+        args.push_back(argToken);
+}
+
+static bool isConstMethod(const Token* nameToken)
+{
+    const Token* functionToken = getFunctionToken(nameToken);
+    if (!functionToken)
+        return false;
+    const Token* endToken = functionToken->link();
+    return Token::simpleMatch(endToken, ") const");
+}
+
+static bool areAllParamsTypes(const std::vector<const Token *> &params)
+{
+    if (params.empty())
+        return false;
+
+    return std::all_of(params.cbegin(), params.cend(), [](const Token* param) {
+        return Token::Match(param->previous(), "typename|class %name% ,|>");
+    });
+}
+
+static bool isTemplateInstantion(const Token* tok)
+{
+    if (!tok->isName() || (tok->isKeyword() && !tok->isOperatorKeyword()))
+        return false;
+    if (Token::Match(tok->tokAt(-1), "%type% %name% ::|<"))
+        return true;
+    if (Token::Match(tok->tokAt(-2), "[,:] private|protected|public %name% ::|<"))
+        return true;
+    if (Token::Match(tok->tokAt(-1), "(|{|}|;|=|>|<<|:|.|*|&|return|<|,|!|[ %name% ::|<|("))
+        return true;
+    return Token::Match(tok->tokAt(-2), "(|{|}|;|=|<<|:|.|*|&|return|<|,|!|[ :: %name% ::|<|(");
 }
 
 void TemplateSimplifier::getTemplateInstantiations()
@@ -771,12 +794,12 @@ void TemplateSimplifier::getTemplateInstantiations()
 
     for (const auto & decl : mTemplateDeclarations) {
         if (decl.isFunction())
-            functionNameMap.insert(std::make_pair(decl.name(), &decl));
+            functionNameMap.emplace(decl.name(), &decl);
     }
 
     for (const auto & decl : mTemplateForwardDeclarations) {
         if (decl.isFunction())
-            functionNameMap.insert(std::make_pair(decl.name(), &decl));
+            functionNameMap.emplace(decl.name(), &decl);
     }
 
     const Token *skip = nullptr;
@@ -799,7 +822,7 @@ void TemplateSimplifier::getTemplateInstantiations()
                 // Don't ignore user specialization but don't consider it an instantiation.
                 // Instantiations in return type, function parameters, and executable code
                 // are not ignored.
-                unsigned int pos = getTemplateNamePosition(tok);
+                const int pos = getTemplateNamePosition(tok);
                 if (pos > 0)
                     skip = tok->tokAt(pos);
             } else {
@@ -821,74 +844,117 @@ void TemplateSimplifier::getTemplateInstantiations()
             Token *tok2 = Token::findsimplematch(tok->tokAt(2), ";");
             if (tok2)
                 tok = tok2;
-        } else if (Token::Match(tok->previous(), "(|{|}|;|=|>|<<|:|.|*|&|return|<|,|! %name% ::|<|(") ||
-                   Token::Match(tok->previous(), "%type% %name% ::|<") ||
-                   Token::Match(tok->tokAt(-2), "[,:] private|protected|public %name% ::|<")) {
+        } else if (isTemplateInstantion(tok)) {
+            if (!tok->scopeInfo())
+                syntaxError(tok);
             std::string scopeName = tok->scopeInfo()->name;
             std::string qualification;
             Token * qualificationTok = tok;
             while (Token::Match(tok, "%name% :: %name%")) {
-                // ignore redundant namespaces
-                if (scopeName.find(tok->str()) == std::string::npos)
-                    qualification += (qualification.empty() ? "" : " :: ") + tok->str();
+                qualification += (qualification.empty() ? "" : " :: ") + tok->str();
                 tok = tok->tokAt(2);
             }
 
+            // skip specialization
+            if (tok == skip) {
+                skip = nullptr;
+                continue;
+            }
+
             // look for function instantiation with type deduction
-            // fixme: only single argument functions supported
             if (tok->strAt(1) == "(") {
-                std::string fullName = qualification + (qualification.empty() ? "" : " :: ") + tok->str();
+                std::vector<const Token *> instantiationArgs;
+                getFunctionArguments(tok, instantiationArgs);
+
+                std::string fullName;
+                if (!qualification.empty())
+                    fullName = qualification + " :: " + tok->str();
+                else if (!scopeName.empty())
+                    fullName = scopeName + " :: " + tok->str();
+                else
+                    fullName = tok->str();
+
                 // get all declarations with this name
-                for (auto pos = functionNameMap.lower_bound(tok->str());
-                     pos != functionNameMap.upper_bound(tok->str()); ++pos) {
-                    // look for declaration with same qualification
-                    if (pos->second->fullName() == fullName) {
-                        // make sure it is a single argument function
-                        if (Token::Match(pos->second->token()->tokAt(2), "typename|class %name% >") &&
-                            Token::Match(pos->second->nameToken()->tokAt(2), "const| %type% &| %name%| )") &&
-                            Token::Match(tok->tokAt(2), "%num%|%str%|%char%|%bool% )")) {
+                auto range = functionNameMap.equal_range(tok->str());
+                for (auto pos = range.first; pos != range.second; ++pos) {
+                    // look for declaration with same qualification or constructor with same qualification
+                    if (pos->second->fullName() == fullName ||
+                        (pos->second->scope() == fullName && tok->str() == pos->second->name())) {
+                        std::vector<const Token *> templateParams;
+                        getTemplateParametersInDeclaration(pos->second->token()->tokAt(2), templateParams);
+
+                        // todo: handle more than one template parameter
+                        if (templateParams.size() != 1 || !areAllParamsTypes(templateParams))
+                            continue;
+
+                        std::vector<const Token *> declarationParams;
+                        getFunctionArguments(pos->second->nameToken(), declarationParams);
+
+                        // function argument counts must match
+                        if (instantiationArgs.empty() || instantiationArgs.size() != declarationParams.size())
+                            continue;
+
+                        size_t match = 0;
+                        size_t argMatch = 0;
+                        for (size_t i = 0; i < declarationParams.size(); ++i) {
+                            // fixme: only type deduction from literals is supported
+                            const bool isArgLiteral = Token::Match(instantiationArgs[i], "%num%|%str%|%char%|%bool% ,|)");
+                            if (isArgLiteral && Token::Match(declarationParams[i], "const| %type% &| %name%| ,|)")) {
+                                match++;
+
+                                // check if parameter types match
+                                if (templateParams[0]->str() == declarationParams[i]->str())
+                                    argMatch = i;
+                                else {
+                                    // todo: check if non-template args match for function overloads
+                                }
+                            }
+                        }
+
+                        if (match == declarationParams.size()) {
+                            const Token *arg = instantiationArgs[argMatch];
                             tok->insertToken(">");
-                            switch (tok->tokAt(3)->tokType()) {
+                            switch (arg->tokType()) {
                             case Token::eBoolean:
                                 tok->insertToken("bool");
                                 break;
                             case Token::eChar:
-                                if (tok->tokAt(3)->isLong())
+                                if (arg->isLong())
                                     tok->insertToken("wchar_t");
                                 else
                                     tok->insertToken("char");
                                 break;
                             case Token::eString:
                                 tok->insertToken("*");
-                                if (tok->tokAt(4)->isLong())
+                                if (arg->isLong())
                                     tok->insertToken("wchar_t");
                                 else
                                     tok->insertToken("char");
                                 tok->insertToken("const");
                                 break;
                             case Token::eNumber: {
-                                MathLib::value num(tok->strAt(3));
+                                MathLib::value num(arg->str());
                                 if (num.isFloat()) {
                                     // MathLib::getSuffix doesn't work for floating point numbers
-                                    char suffix = tok->strAt(3).back();
+                                    const char suffix = arg->str().back();
                                     if (suffix == 'f' || suffix == 'F')
                                         tok->insertToken("float");
                                     else if (suffix == 'l' || suffix == 'L') {
                                         tok->insertToken("double");
-                                        tok->insertToken("long");
+                                        tok->next()->isLong(true);
                                     } else
                                         tok->insertToken("double");
                                 } else if (num.isInt()) {
                                     std::string suffix = MathLib::getSuffix(tok->strAt(3));
                                     if (suffix.find("LL") != std::string::npos) {
                                         tok->insertToken("long");
-                                        tok->insertToken("long");
+                                        tok->next()->isLong(true);
                                     } else if (suffix.find('L') != std::string::npos)
                                         tok->insertToken("long");
                                     else
                                         tok->insertToken("int");
                                     if (suffix.find('U') != std::string::npos)
-                                        tok->insertToken("unsigned");
+                                        tok->next()->isUnsigned(true);
                                 }
                                 break;
                             }
@@ -918,7 +984,7 @@ void TemplateSimplifier::getTemplateInstantiations()
             // parse backwards and add template instantiations
             // TODO
             for (; tok2 && tok2 != tok; tok2 = tok2->previous()) {
-                if (Token::Match(tok2, ",|< %name% <") &&
+                if (Token::Match(tok2, ",|< %name% <") && !tok2->next()->isKeyword() &&
                     (tok2->strAt(3) == ">" || templateParameters(tok2->tokAt(2)))) {
                     addInstantiation(tok2->next(), tok->scopeInfo()->name);
                 } else if (Token::Match(tok2->next(), "class|struct"))
@@ -927,51 +993,49 @@ void TemplateSimplifier::getTemplateInstantiations()
 
             // Add outer template..
             if (templateParameters(tok->next()) || tok->strAt(2) == ">") {
-                const std::string scopeName1(scopeName);
                 while (true) {
-                    const std::string fullName = scopeName + (scopeName.empty()?"":" :: ") +
-                                                 qualification + (qualification.empty()?"":" :: ") + tok->str();
-                    const std::list<TokenAndName>::const_iterator it = std::find_if(mTemplateDeclarations.begin(), mTemplateDeclarations.end(), FindFullName(fullName));
+                    std::string fullName = scopeName + (scopeName.empty()?"":" :: ") +
+                                           qualification + (qualification.empty()?"":" :: ") + tok->str();
+                    const auto it = std::find_if(mTemplateDeclarations.cbegin(), mTemplateDeclarations.cend(), FindFullName(std::move(fullName)));
                     if (it != mTemplateDeclarations.end()) {
                         // full name matches
                         addInstantiation(tok, it->scope());
                         break;
-                    } else {
-                        // full name doesn't match so try with using namespaces if available
-                        bool found = false;
-                        for (const auto & nameSpace :  tok->scopeInfo()->usingNamespaces) {
-                            std::string fullNameSpace = scopeName + (scopeName.empty()?"":" :: ") +
-                                                        nameSpace + (qualification.empty()?"":" :: ") + qualification;
-                            std::string newFullName = fullNameSpace + " :: " + tok->str();
-                            const std::list<TokenAndName>::const_iterator it1 = std::find_if(mTemplateDeclarations.begin(), mTemplateDeclarations.end(), FindFullName(newFullName));
-                            if (it1 != mTemplateDeclarations.end()) {
-                                // insert using namespace into token stream
-                                std::string::size_type offset = 0;
-                                std::string::size_type pos = 0;
-                                while ((pos = nameSpace.substr(offset).find(' ')) != std::string::npos) {
-                                    qualificationTok->insertToken(nameSpace.substr(offset, pos), "", true);
-                                    offset = offset + pos + 1;
-                                }
-                                qualificationTok->insertToken(nameSpace.substr(offset), "", true);
-                                qualificationTok->insertToken("::", "", true);
-                                addInstantiation(tok, it1->scope());
-                                found = true;
-                                break;
+                    }
+                    // full name doesn't match so try with using namespaces if available
+                    bool found = false;
+                    for (const auto & nameSpace :  tok->scopeInfo()->usingNamespaces) {
+                        std::string fullNameSpace = scopeName + (scopeName.empty()?"":" :: ") +
+                                                    nameSpace + (qualification.empty()?"":" :: ") + qualification;
+                        std::string newFullName = fullNameSpace + " :: " + tok->str();
+                        const auto it1 = std::find_if(mTemplateDeclarations.cbegin(), mTemplateDeclarations.cend(), FindFullName(std::move(newFullName)));
+                        if (it1 != mTemplateDeclarations.end()) {
+                            // insert using namespace into token stream
+                            std::string::size_type offset = 0;
+                            std::string::size_type pos = 0;
+                            while ((pos = nameSpace.find(' ', offset)) != std::string::npos) {
+                                qualificationTok->insertTokenBefore(nameSpace.substr(offset, pos - offset));
+                                offset = pos + 1;
                             }
-                        }
-                        if (found)
-                            break;
-
-                        if (scopeName.empty()) {
-                            if (!qualification.empty())
-                                addInstantiation(tok, qualification);
-                            else
-                                addInstantiation(tok,  tok->scopeInfo()->name);
+                            qualificationTok->insertTokenBefore(nameSpace.substr(offset));
+                            qualificationTok->insertTokenBefore("::");
+                            addInstantiation(tok, it1->scope());
+                            found = true;
                             break;
                         }
-                        const std::string::size_type pos = scopeName.rfind(" :: ");
-                        scopeName = (pos == std::string::npos) ? std::string() : scopeName.substr(0,pos);
                     }
+                    if (found)
+                        break;
+
+                    if (scopeName.empty()) {
+                        if (!qualification.empty())
+                            addInstantiation(tok, qualification);
+                        else
+                            addInstantiation(tok,  tok->scopeInfo()->name);
+                        break;
+                    }
+                    const std::string::size_type pos = scopeName.rfind(" :: ");
+                    scopeName = (pos == std::string::npos) ? std::string() : scopeName.substr(0,pos);
                 }
             }
         }
@@ -997,7 +1061,11 @@ void TemplateSimplifier::useDefaultArgumentValues(TokenAndName &declaration)
     // template parameters with default value has syntax such as:
     //     x = y
     // this list will contain all the '=' tokens for such arguments
-    std::list<Token *> eq;
+    struct Default {
+        Token *eq;
+        Token *end;
+    };
+    std::list<Default> eq;
     // and this set the position of parameters with a default value
     std::set<std::size_t> defaultedArgPos;
 
@@ -1011,7 +1079,14 @@ void TemplateSimplifier::useDefaultArgumentValues(TokenAndName &declaration)
     std::map<std::string, unsigned int> typeParameterNames;
 
     // Scan template declaration..
-    for (Token *tok = declaration.token(); tok; tok = tok->next()) {
+    for (Token *tok = declaration.token()->next(); tok; tok = tok->next()) {
+        if (Token::simpleMatch(tok, "template <")) {
+            Token* end = tok->next()->findClosingBracket();
+            if (end)
+                tok = end;
+            continue;
+        }
+
         if (tok->link() && Token::Match(tok, "{|(|[")) { // Ticket #6835
             tok = tok->link();
             continue;
@@ -1024,10 +1099,12 @@ void TemplateSimplifier::useDefaultArgumentValues(TokenAndName &declaration)
 
         // end of template parameters?
         if (tok->str() == ">") {
-            if (templateParmDepth<2)
+            if (templateParmDepth<2) {
+                if (!eq.empty())
+                    eq.back().end = tok;
                 break;
-            else
-                --templateParmDepth;
+            }
+            --templateParmDepth;
         }
 
         // map type parameter name to index
@@ -1035,13 +1112,16 @@ void TemplateSimplifier::useDefaultArgumentValues(TokenAndName &declaration)
             typeParameterNames[tok->strAt(1)] = templatepar - 1;
 
         // next template parameter
-        if (tok->str() == "," && (1 == templateParmDepth)) // Ticket #5823: Properly count parameters
+        if (tok->str() == "," && (1 == templateParmDepth)) { // Ticket #5823: Properly count parameters
+            if (!eq.empty())
+                eq.back().end = tok;
             ++templatepar;
+        }
 
         // default parameter value?
         else if (Token::Match(tok, "= !!>")) {
             if (defaultedArgPos.insert(templatepar).second) {
-                eq.push_back(tok);
+                eq.emplace_back(Default{tok, nullptr});
             } else {
                 // Ticket #5605: Syntax error (two equal signs for the same parameter), bail out
                 eq.clear();
@@ -1072,6 +1152,8 @@ void TemplateSimplifier::useDefaultArgumentValues(TokenAndName &declaration)
                     instantiationArgs[index].push_back(tok1);
                     tok1 = tok1->next();
                 } while (tok1 && tok1 != endLink);
+                if (!tok1)
+                    syntaxError(end);
                 instantiationArgs[index].push_back(tok1);
             } else if (tok1->str() == "<" &&
                        (tok1->strAt(1) == ">" || (tok1->previous()->isName() &&
@@ -1081,6 +1163,8 @@ void TemplateSimplifier::useDefaultArgumentValues(TokenAndName &declaration)
                     instantiationArgs[index].push_back(tok1);
                     tok1 = tok1->next();
                 } while (tok1 && tok1 != endLink);
+                if (!tok1)
+                    syntaxError(end);
                 instantiationArgs[index].push_back(tok1);
             } else if (tok1->str() == ",") {
                 ++index;
@@ -1097,25 +1181,31 @@ void TemplateSimplifier::useDefaultArgumentValues(TokenAndName &declaration)
 
         if (tok && tok->str() == ">") {
             tok = tok->previous();
-            std::list<Token *>::const_iterator it = eq.begin();
-            for (std::size_t i = (templatepar - eq.size()); it != eq.end() && i < usedpar; ++i)
+            auto it = eq.cbegin();
+            for (std::size_t i = (templatepar - eq.size()); it != eq.cend() && i < usedpar; ++i)
                 ++it;
             int count = 0;
-            while (it != eq.end()) {
-                int indentlevel = 0;
+            while (it != eq.cend()) {
+                // check for end
+                if (!it->end) {
+                    if (mSettings.debugwarnings && mSettings.severity.isEnabled(Severity::debug)) {
+                        const std::list<const Token*> locationList(1, it->eq);
+                        const ErrorMessage errmsg(locationList, &mTokenizer.list,
+                                                  Severity::debug,
+                                                  "noparamend",
+                                                  "TemplateSimplifier couldn't find end of template parameter.",
+                                                  Certainty::normal);
+                        mErrorLogger.reportErr(errmsg);
+                    }
+                    break;
+                }
+
                 if ((usedpar + count) && usedpar <= (instantiationArgs.size() + count)) {
                     tok->insertToken(",");
                     tok = tok->next();
                 }
-                const Token *from = (*it)->next();
                 std::stack<Token *> links;
-                while (from && (!links.empty() || indentlevel || !Token::Match(from, ",|>"))) {
-                    if (from->str() == "<" &&
-                        (from->strAt(1) == ">" || (from->previous()->isName() &&
-                                                   typeParameterNames.find(from->strAt(-1)) == typeParameterNames.end())))
-                        ++indentlevel;
-                    else if (from->str() == ">")
-                        --indentlevel;
+                for (const Token* from = it->eq->next(); from && from != it->end; from = from->next()) {
                     auto entry = typeParameterNames.find(from->str());
                     if (entry != typeParameterNames.end() && entry->second < instantiationArgs.size()) {
                         for (const Token *tok1 : instantiationArgs[entry->second]) {
@@ -1140,7 +1230,6 @@ void TemplateSimplifier::useDefaultArgumentValues(TokenAndName &declaration)
                             links.pop();
                         }
                     }
-                    from = from->next();
                 }
                 ++it;
                 count++;
@@ -1151,7 +1240,8 @@ void TemplateSimplifier::useDefaultArgumentValues(TokenAndName &declaration)
         simplifyTemplateArgs(instantiation.token()->next(), instantiationEnd);
     }
 
-    for (Token * const eqtok : eq) {
+    for (const auto & entry : eq) {
+        Token *const eqtok = entry.eq;
         Token *tok2;
         int indentlevel = 0;
         for (tok2 = eqtok->next(); tok2; tok2 = tok2->next()) {
@@ -1162,9 +1252,9 @@ void TemplateSimplifier::useDefaultArgumentValues(TokenAndName &declaration)
             if (Token::Match(tok2, "(|{|["))
                 tok2 = tok2->link();
             else if (Token::Match(tok2, "%type% <") && (tok2->strAt(2) == ">" || templateParameters(tok2->next()))) {
-                std::list<TokenAndName>::iterator ti = std::find_if(mTemplateInstantiations.begin(),
-                                                       mTemplateInstantiations.end(),
-                                                       FindToken(tok2));
+                const auto ti = std::find_if(mTemplateInstantiations.cbegin(),
+                                             mTemplateInstantiations.cend(),
+                                             FindToken(tok2));
                 if (ti != mTemplateInstantiations.end())
                     mTemplateInstantiations.erase(ti);
                 ++indentlevel;
@@ -1181,9 +1271,9 @@ void TemplateSimplifier::useDefaultArgumentValues(TokenAndName &declaration)
             continue;
 
         // don't strip args from uninstantiated templates
-        std::list<TokenAndName>::iterator ti2 = std::find_if(mTemplateInstantiations.begin(),
-                                                mTemplateInstantiations.end(),
-                                                FindName(declaration.name()));
+        const auto ti2 = std::find_if(mTemplateInstantiations.cbegin(),
+                                      mTemplateInstantiations.cend(),
+                                      FindName(declaration.name()));
 
         if (ti2 == mTemplateInstantiations.end())
             continue;
@@ -1198,8 +1288,8 @@ void TemplateSimplifier::useDefaultArgumentValues(TokenAndName &declaration)
 
 void TemplateSimplifier::simplifyTemplateAliases()
 {
-    for (std::list<TokenAndName>::iterator it1 = mTemplateDeclarations.begin(); it1 != mTemplateDeclarations.end();) {
-        TokenAndName &aliasDeclaration = *it1;
+    for (auto it1 = mTemplateDeclarations.cbegin(); it1 != mTemplateDeclarations.cend();) {
+        const TokenAndName &aliasDeclaration = *it1;
 
         if (!aliasDeclaration.isAlias()) {
             ++it1;
@@ -1215,8 +1305,8 @@ void TemplateSimplifier::simplifyTemplateAliases()
 
         // Look for alias usages..
         bool found = false;
-        for (std::list<TokenAndName>::iterator it2 = mTemplateInstantiations.begin(); it2 != mTemplateInstantiations.end();) {
-            TokenAndName &aliasUsage = *it2;
+        for (auto it2 = mTemplateInstantiations.cbegin(); it2 != mTemplateInstantiations.cend();) {
+            const TokenAndName &aliasUsage = *it2;
             if (!aliasUsage.token() || aliasUsage.fullName() != aliasDeclaration.fullName()) {
                 ++it2;
                 continue;
@@ -1235,8 +1325,11 @@ void TemplateSimplifier::simplifyTemplateAliases()
                 while (tok2 && !Token::Match(tok2, "[,>;{}]")) {
                     if (tok2->link() && Token::Match(tok2, "(|["))
                         tok2 = tok2->link();
-                    else if (tok2->str() == "<")
+                    else if (tok2->str() == "<") {
                         tok2 = tok2->findClosingBracket();
+                        if (!tok2)
+                            break;
+                    }
                     tok2 = tok2->next();
                 }
 
@@ -1258,7 +1351,7 @@ void TemplateSimplifier::simplifyTemplateAliases()
 
             // copy template-id from declaration to after instantiation
             Token * dst = aliasUsage.token()->next()->findClosingBracket();
-            Token * end = TokenList::copyTokens(dst, aliasDeclaration.aliasStartToken(), aliasDeclaration.aliasEndToken()->previous(), false)->next();
+            const Token* end = TokenList::copyTokens(dst, aliasDeclaration.aliasStartToken(), aliasDeclaration.aliasEndToken()->previous(), false)->next();
 
             // replace parameters
             for (Token *tok1 = dst->next(); tok1 != end; tok1 = tok1->next()) {
@@ -1269,7 +1362,7 @@ void TemplateSimplifier::simplifyTemplateAliases()
                     const Token * const fromStart = args[argnr].first;
                     const Token * const fromEnd   = args[argnr].second->previous();
                     Token *temp = TokenList::copyTokens(tok1, fromStart, fromEnd, true);
-                    const bool tempOK(temp && temp != tok1->next());
+                    const bool tempOK(temp != tok1->next());
                     tok1->deleteThis();
                     if (tempOK)
                         tok1 = temp; // skip over inserted parameters
@@ -1284,10 +1377,10 @@ void TemplateSimplifier::simplifyTemplateAliases()
                 if (aliasParameterNames.find(tok2->str()) == aliasParameterNames.end()) {
                     // Create template instance..
                     if (Token::Match(tok1, "%name% <")) {
-                        const std::list<TokenAndName>::iterator it = std::find_if(mTemplateInstantiations.begin(),
-                                mTemplateInstantiations.end(),
-                                FindToken(tok1));
-                        if (it != mTemplateInstantiations.end())
+                        const auto it = std::find_if(mTemplateInstantiations.cbegin(),
+                                                     mTemplateInstantiations.cend(),
+                                                     FindToken(tok1));
+                        if (it != mTemplateInstantiations.cend())
                             addInstantiation(tok2, it->scope());
                     }
                 }
@@ -1302,7 +1395,7 @@ void TemplateSimplifier::simplifyTemplateAliases()
         }
 
         if (found) {
-            Token *end = const_cast<Token *>(aliasDeclaration.aliasEndToken());
+            auto *end = const_cast<Token *>(aliasDeclaration.aliasEndToken());
 
             // remove declaration tokens
             if (aliasDeclaration.token()->previous())
@@ -1319,11 +1412,12 @@ void TemplateSimplifier::simplifyTemplateAliases()
     }
 }
 
-bool TemplateSimplifier::instantiateMatch(const Token *instance, const std::size_t numberOfArguments, const char patternAfter[])
+bool TemplateSimplifier::instantiateMatch(const Token *instance, const std::size_t numberOfArguments, bool variadic, const char patternAfter[])
 {
     assert(instance->strAt(1) == "<");
 
-    if (numberOfArguments != templateParameters(instance->next()))
+    auto n = templateParameters(instance->next());
+    if (variadic ? (n + 1 < numberOfArguments) : (numberOfArguments != n))
         return false;
 
     if (patternAfter) {
@@ -1344,23 +1438,23 @@ bool TemplateSimplifier::getTemplateNamePositionTemplateFunction(const Token *to
         if (Token::Match(tok->next(), ";|{"))
             return false;
         // skip decltype(...)
-        else if (Token::simpleMatch(tok->next(), "decltype (")) {
+        if (Token::simpleMatch(tok->next(), "decltype (")) {
             const Token * end = tok->linkAt(2)->previous();
-            while (tok && tok->next() && tok != end) {
+            while (tok->next() && tok != end) {
                 tok = tok->next();
                 namepos++;
             }
         } else if (Token::Match(tok->next(), "%type% <")) {
             const Token *closing = tok->tokAt(2)->findClosingBracket();
             if (closing) {
-                if (closing->strAt(1) == "(" && Tokenizer::isFunctionHead(closing->next(), ";|{|:", true))
+                if (closing->strAt(1) == "(" && TokenList::isFunctionHead(closing->next(), ";{:"))
                     return true;
-                while (tok && tok->next() && tok->next() != closing) {
+                while (tok->next() && tok->next() != closing) {
                     tok = tok->next();
                     namepos++;
                 }
             }
-        } else if (Token::Match(tok->next(), "%type% (") && Tokenizer::isFunctionHead(tok->tokAt(2), ";|{|:", true)) {
+        } else if (Token::Match(tok->next(), "%type% (") && TokenList::isFunctionHead(tok->tokAt(2), ";{:")) {
             return true;
         }
         tok = tok->next();
@@ -1376,9 +1470,9 @@ bool TemplateSimplifier::getTemplateNamePositionTemplateVariable(const Token *to
         if (Token::Match(tok->next(), ";|{|(|using"))
             return false;
         // skip decltype(...)
-        else if (Token::simpleMatch(tok->next(), "decltype (")) {
+        if (Token::simpleMatch(tok->next(), "decltype (")) {
             const Token * end = tok->linkAt(2);
-            while (tok && tok->next() && tok != end) {
+            while (tok->next() && tok != end) {
                 tok = tok->next();
                 namepos++;
             }
@@ -1387,7 +1481,7 @@ bool TemplateSimplifier::getTemplateNamePositionTemplateVariable(const Token *to
             if (closing) {
                 if (Token::Match(closing->next(), "=|;"))
                     return true;
-                while (tok && tok->next() && tok->next() != closing) {
+                while (tok->next() && tok->next() != closing) {
                     tok = tok->next();
                     namepos++;
                 }
@@ -1432,10 +1526,11 @@ bool TemplateSimplifier::getTemplateNamePositionTemplateClass(const Token *tok,
 
 int TemplateSimplifier::getTemplateNamePosition(const Token *tok)
 {
-    assert(tok && tok->str() == ">");
+    if (!tok || tok->str() != ">")
+        syntaxError(tok);
 
     auto it = mTemplateNamePos.find(tok);
-    if (!mSettings->debugtemplate && it != mTemplateNamePos.end()) {
+    if (!mSettings.debugtemplate && it != mTemplateNamePos.end()) {
         return it->second;
     }
     // get the position of the template name
@@ -1470,7 +1565,7 @@ void TemplateSimplifier::addNamespace(const TokenAndName &templateDeclaration, c
     std::string::size_type end = 0;
     bool inTemplate = false;
     int level = 0;
-    while ((end = templateDeclaration.scope().find(" ", start)) != std::string::npos) {
+    while ((end = templateDeclaration.scope().find(' ', start)) != std::string::npos) {
         std::string token = templateDeclaration.scope().substr(start, end - start);
         // done if scopes overlap
         if (token == tokStart->str() && tok->strAt(-1) != "::")
@@ -1491,9 +1586,9 @@ void TemplateSimplifier::addNamespace(const TokenAndName &templateDeclaration, c
             }
         } else {
             if (insert)
-                mTokenList.back()->tokAt(offset)->insertToken(token, "");
+                mTokenList.back()->tokAt(offset)->insertToken(token);
             else
-                mTokenList.addtoken(token, tok->linenr(), tok->fileIndex());
+                mTokenList.addtoken(token, tok->linenr(), tok->column(), tok->fileIndex());
         }
         start = end + 1;
     }
@@ -1502,23 +1597,23 @@ void TemplateSimplifier::addNamespace(const TokenAndName &templateDeclaration, c
     if (token != tokStart->str() || tok->strAt(-1) != "::") {
         if (insert) {
             if (!inTemplate)
-                mTokenList.back()->tokAt(offset)->insertToken(templateDeclaration.scope().substr(start), "");
+                mTokenList.back()->tokAt(offset)->insertToken(templateDeclaration.scope().substr(start));
             else
                 mTokenList.back()->tokAt(offset)->str(mTokenList.back()->strAt(offset) + templateDeclaration.scope().substr(start));
-            mTokenList.back()->tokAt(offset)->insertToken("::", "");
+            mTokenList.back()->tokAt(offset)->insertToken("::");
         } else {
             if (!inTemplate)
-                mTokenList.addtoken(templateDeclaration.scope().substr(start), tok->linenr(), tok->fileIndex());
+                mTokenList.addtoken(templateDeclaration.scope().substr(start), tok->linenr(), tok->column(), tok->fileIndex());
             else
                 mTokenList.back()->str(mTokenList.back()->str() + templateDeclaration.scope().substr(start));
-            mTokenList.addtoken("::", tok->linenr(), tok->fileIndex());
+            mTokenList.addtoken("::", tok->linenr(), tok->column(), tok->fileIndex());
         }
     }
 }
 
 bool TemplateSimplifier::alreadyHasNamespace(const TokenAndName &templateDeclaration, const Token *tok)
 {
-    std::string scope = templateDeclaration.scope();
+    const std::string& scope = templateDeclaration.scope();
 
     // get the length in tokens of the namespace
     std::string::size_type pos = 0;
@@ -1529,9 +1624,15 @@ bool TemplateSimplifier::alreadyHasNamespace(const TokenAndName &templateDeclara
         pos += 2;
     }
 
-    return Token::simpleMatch(tok->tokAt(offset), scope.c_str()) ;
+    return Token::simpleMatch(tok->tokAt(offset), scope.c_str(), scope.size());
 }
 
+struct newInstantiation {
+    newInstantiation(Token* t, std::string s) : token(t), scope(std::move(s)) {}
+    Token* token;
+    std::string scope;
+};
+
 void TemplateSimplifier::expandTemplate(
     const TokenAndName &templateDeclaration,
     const TokenAndName &templateInstantiation,
@@ -1548,18 +1649,20 @@ void TemplateSimplifier::expandTemplate(
     const bool isFunction = templateDeclaration.isFunction();
     const bool isSpecialization = templateDeclaration.isSpecialization();
     const bool isVariable = templateDeclaration.isVariable();
-    struct newInstantiation {
-        newInstantiation(Token *t, const std::string &s) : token(t), scope(s) { }
-        Token *token;
-        std::string scope;
-    };
+
     std::vector<newInstantiation> newInstantiations;
 
+    for (const Token* tok = templateInstantiation.token()->next()->findClosingBracket();
+         tok && tok != templateInstantiation.token(); tok = tok->previous()) {
+        if (tok->isName())
+            mUsedVariables[newName].insert(tok->str());
+    }
+
     // add forward declarations
     if (copy && isClass) {
-        templateDeclaration.token()->insertToken(templateDeclarationToken->strAt(1), "", true);
-        templateDeclaration.token()->insertToken(newName, "", true);
-        templateDeclaration.token()->insertToken(";", "", true);
+        templateDeclaration.token()->insertTokenBefore(templateDeclarationToken->strAt(1));
+        templateDeclaration.token()->insertTokenBefore(newName);
+        templateDeclaration.token()->insertTokenBefore(";");
     } else if ((isFunction && (copy || isSpecialization)) ||
                (isVariable && !isSpecialization) ||
                (isClass && isSpecialization && mTemplateSpecializationMap.find(templateDeclaration.token()) != mTemplateSpecializationMap.end())) {
@@ -1567,10 +1670,10 @@ void TemplateSimplifier::expandTemplate(
         Token * dstStart = dst->previous();
         bool isStatic = false;
         std::string scope;
-        Token * start;
-        Token * end;
+        const Token * start;
+        const Token * end;
         auto it = mTemplateForwardDeclarationsMap.find(dst);
-        if (it != mTemplateForwardDeclarationsMap.end()) {
+        if (!isSpecialization && it != mTemplateForwardDeclarationsMap.end()) {
             dst = it->second;
             dstStart = dst->previous();
             const Token * temp1 = dst->tokAt(1)->findClosingBracket();
@@ -1578,6 +1681,14 @@ void TemplateSimplifier::expandTemplate(
             start = temp1->next();
             end = temp2->linkAt(1)->next();
         } else {
+            if (it != mTemplateForwardDeclarationsMap.end()) {
+                const auto it1 = std::find_if(mTemplateForwardDeclarations.cbegin(),
+                                              mTemplateForwardDeclarations.cend(),
+                                              FindToken(it->second));
+                if (it1 != mTemplateForwardDeclarations.cend())
+                    mMemberFunctionsToDelete.push_back(*it1);
+            }
+
             auto it2 = mTemplateSpecializationMap.find(dst);
             if (it2 != mTemplateSpecializationMap.end()) {
                 dst = it2->second;
@@ -1596,7 +1707,7 @@ void TemplateSimplifier::expandTemplate(
             if (end->str() == "(")
                 end = end->link()->next();
             else if (isVariable && end->str() == "=") {
-                Token *temp = end->next();
+                const Token *temp = end->next();
                 while (temp && temp->str() != ";") {
                     if (temp->link() && Token::Match(temp, "{|[|("))
                         temp = temp->link();
@@ -1606,7 +1717,7 @@ void TemplateSimplifier::expandTemplate(
             }
         }
         unsigned int typeindentlevel = 0;
-        while (!(typeindentlevel == 0 && Token::Match(end, ";|{|:"))) {
+        while (end && !(typeindentlevel == 0 && Token::Match(end, ";|{|:"))) {
             if (Token::Match(end, "<|(|{"))
                 ++typeindentlevel;
             else if (Token::Match(end, ">|)|}"))
@@ -1614,8 +1725,13 @@ void TemplateSimplifier::expandTemplate(
             end = end->next();
         }
 
-        if (isStatic)
-            dst->insertToken("static", "", true);
+        if (isStatic) {
+            dst->insertTokenBefore("static");
+            if (start) {
+                dst->previous()->linenr(start->linenr());
+                dst->previous()->column(start->column());
+            }
+        }
 
         std::map<const Token *, Token *> links;
         bool inAssignment = false;
@@ -1626,13 +1742,21 @@ void TemplateSimplifier::expandTemplate(
             while (itype < typeParametersInDeclaration.size() && typeParametersInDeclaration[itype]->str() != start->str())
                 ++itype;
 
-            if (itype < typeParametersInDeclaration.size() &&
+            if (itype < typeParametersInDeclaration.size() && itype < mTypesUsedInTemplateInstantiation.size() &&
                 (!isVariable || !Token::Match(typeParametersInDeclaration[itype]->previous(), "<|, %type% >|,"))) {
                 typeindentlevel = 0;
                 std::stack<Token *> brackets1; // holds "(" and "{" tokens
+                bool pointerType = false;
+                Token * const dst1 = dst->previous();
+                const bool isVariadicTemplateArg = templateDeclaration.isVariadic() && itype + 1 == typeParametersInDeclaration.size();
+                if (isVariadicTemplateArg && Token::Match(start, "%name% ... %name%"))
+                    start = start->tokAt(2);
+                const std::string endStr(isVariadicTemplateArg ? ">" : ",>");
                 for (const Token *typetok = mTypesUsedInTemplateInstantiation[itype].token();
-                     typetok && (typeindentlevel > 0 || !Token::Match(typetok, ",|>"));
+                     typetok && (typeindentlevel > 0 || endStr.find(typetok->str()[0]) == std::string::npos);
                      typetok = typetok->next()) {
+                    if (typeindentlevel == 0 && typetok->str() == "*")
+                        pointerType = true;
                     if (Token::simpleMatch(typetok, "..."))
                         continue;
                     if (Token::Match(typetok, "%name% <") && (typetok->strAt(2) == ">" || templateParameters(typetok->next())))
@@ -1643,9 +1767,11 @@ void TemplateSimplifier::expandTemplate(
                         ++typeindentlevel;
                     else if (typetok->str() == ")")
                         --typeindentlevel;
-                    dst->insertToken(typetok->str(), typetok->originalName(), true);
+                    dst->insertTokenBefore(typetok->str(), typetok->originalName(), typetok->getMacroName());
+                    dst->previous()->linenr(start->linenr());
+                    dst->previous()->column(start->column());
                     Token *previous = dst->previous();
-                    previous->isTemplateArg(true);
+                    previous->templateArgFrom(typetok);
                     previous->isSigned(typetok->isSigned());
                     previous->isUnsigned(typetok->isUnsigned());
                     previous->isLong(typetok->isLong());
@@ -1668,6 +1794,12 @@ void TemplateSimplifier::expandTemplate(
                         brackets1.pop();
                     }
                 }
+                if (pointerType && Token::simpleMatch(dst1, "const")) {
+                    dst->insertTokenBefore("const", dst1->originalName(), dst1->getMacroName());
+                    dst->previous()->linenr(start->linenr());
+                    dst->previous()->column(start->column());
+                    dst1->deleteThis();
+                }
             } else {
                 if (isSpecialization && !copy && !scope.empty() && Token::Match(start, (scope + templateDeclarationNameToken->str()).c_str())) {
                     // skip scope
@@ -1677,18 +1809,22 @@ void TemplateSimplifier::expandTemplate(
                            !(templateDeclaration.isFunction() && templateDeclaration.scope().empty() &&
                              (start->strAt(-1) == "." || Token::simpleMatch(start->tokAt(-2), ". template")))) {
                     if (start->strAt(1) != "<" || Token::Match(start, newName.c_str()) || !inAssignment) {
-                        dst->insertToken(newName, "", true);
+                        dst->insertTokenBefore(newName);
+                        dst->previous()->linenr(start->linenr());
+                        dst->previous()->column(start->column());
                         if (start->strAt(1) == "<")
                             start = start->next()->findClosingBracket();
                     } else {
-                        dst->insertToken(start->str(), "", true);
+                        dst->insertTokenBefore(start->str());
+                        dst->previous()->linenr(start->linenr());
+                        dst->previous()->column(start->column());
                         newInstantiations.emplace_back(dst->previous(), templateDeclaration.scope());
                     }
                 } else {
                     // check if type is a template
                     if (start->strAt(1) == "<") {
                         // get the instantiated name
-                        Token * closing = start->next()->findClosingBracket();
+                        const Token * closing = start->next()->findClosingBracket();
                         if (closing) {
                             std::string name;
                             const Token * type = start;
@@ -1699,24 +1835,29 @@ void TemplateSimplifier::expandTemplate(
                                 type = type->next();
                             }
                             // check if type is instantiated
-                            for (const auto & inst : mTemplateInstantiations) {
-                                if (Token::simpleMatch(inst.token(), name.c_str())) {
-                                    // use the instantiated name
-                                    dst->insertToken(name, "", true);
-                                    start = closing;
-                                    break;
-                                }
+                            if (std::any_of(mTemplateInstantiations.cbegin(), mTemplateInstantiations.cend(), [&](const TokenAndName& inst) {
+                                return Token::simpleMatch(inst.token(), name.c_str(), name.size());
+                            })) {
+                                // use the instantiated name
+                                dst->insertTokenBefore(name);
+                                dst->previous()->linenr(start->linenr());
+                                dst->previous()->column(start->column());
+                                start = closing;
                             }
                         }
                         // just copy the token if it wasn't instantiated
                         if (start != closing) {
-                            dst->insertToken(start->str(), start->originalName(), true);
+                            dst->insertTokenBefore(start->str(), start->originalName(), start->getMacroName());
+                            dst->previous()->linenr(start->linenr());
+                            dst->previous()->column(start->column());
                             dst->previous()->isSigned(start->isSigned());
                             dst->previous()->isUnsigned(start->isUnsigned());
                             dst->previous()->isLong(start->isLong());
                         }
                     } else {
-                        dst->insertToken(start->str(), start->originalName(), true);
+                        dst->insertTokenBefore(start->str(), start->originalName(), start->getMacroName());
+                        dst->previous()->linenr(start->linenr());
+                        dst->previous()->column(start->column());
                         dst->previous()->isSigned(start->isSigned());
                         dst->previous()->isUnsigned(start->isUnsigned());
                         dst->previous()->isLong(start->isLong());
@@ -1730,15 +1871,21 @@ void TemplateSimplifier::expandTemplate(
                     if (Token::Match(start, "[|{|(")) {
                         links[start->link()] = dst->previous();
                     } else if (Token::Match(start, "]|}|)")) {
-                        Token::createMutualLinks(links[start], dst->previous());
-                        links.erase(start);
+                        const auto link = utils::as_const(links).find(start);
+                        // make sure link is valid
+                        if (link != links.cend()) {
+                            Token::createMutualLinks(link->second, dst->previous());
+                            links.erase(start);
+                        }
                     }
                 }
             }
 
             start = start->next();
         }
-        dst->insertToken(";", "", true);
+        dst->insertTokenBefore(";");
+        dst->previous()->linenr(dst->tokAt(-2)->linenr());
+        dst->previous()->column(dst->tokAt(-2)->column() + 1);
 
         if (isVariable || isFunction)
             simplifyTemplateArgs(dstStart, dst);
@@ -1779,13 +1926,10 @@ void TemplateSimplifier::expandTemplate(
         }
 
         if (tok3->str()=="template") {
-            if (tok3->next() && tok3->next()->str()=="<") {
+            if (tok3->next() && tok3->strAt(1)=="<") {
                 std::vector<const Token *> localTypeParametersInDeclaration;
                 getTemplateParametersInDeclaration(tok3->tokAt(2), localTypeParametersInDeclaration);
-                if (localTypeParametersInDeclaration.size() != typeParametersInDeclaration.size())
-                    inTemplateDefinition = false; // Partial specialization
-                else
-                    inTemplateDefinition = true;
+                inTemplateDefinition = localTypeParametersInDeclaration.size() == typeParametersInDeclaration.size(); // Partial specialization
             } else {
                 inTemplateDefinition = false; // Only template instantiation
             }
@@ -1805,7 +1949,7 @@ void TemplateSimplifier::expandTemplate(
         else if (inTemplateDefinition &&
                  Token::Match(tok3, "%name% <") &&
                  templateInstantiation.name() == tok3->str() &&
-                 instantiateMatch(tok3, typeParametersInDeclaration.size(), ":: ~| %name% (")) {
+                 instantiateMatch(tok3, typeParametersInDeclaration.size(), templateDeclaration.isVariadic(), ":: ~| %name% (")) {
             // there must be template..
             bool istemplate = false;
             Token * tok5 = nullptr; // start of function return type
@@ -1822,7 +1966,7 @@ void TemplateSimplifier::expandTemplate(
             const Token *tok4 = tok3->next()->findClosingBracket();
             while (tok4 && tok4->str() != "(")
                 tok4 = tok4->next();
-            if (!Tokenizer::isFunctionHead(tok4, ":{", true))
+            if (!TokenList::isFunctionHead(tok4, ":{"))
                 continue;
             // find function return type start
             tok5 = tok5->next()->findClosingBracket();
@@ -1836,7 +1980,7 @@ void TemplateSimplifier::expandTemplate(
                     if (copy) {
                         if (!templateDeclaration.scope().empty() && tok5->strAt(-1) != "::")
                             addNamespace(templateDeclaration, tok5);
-                        mTokenList.addtoken(newName, tok5->linenr(), tok5->fileIndex());
+                        mTokenList.addtoken(newName, tok5->linenr(), tok5->column(), tok5->fileIndex());
                         tok5 = tok5->next()->findClosingBracket();
                     } else {
                         tok5->str(newName);
@@ -1851,21 +1995,12 @@ void TemplateSimplifier::expandTemplate(
                             ++itype;
 
                         // replace type with given type..
-                        if (itype < typeParametersInDeclaration.size()) {
-                            unsigned int typeindentlevel = 0;
+                        if (itype < typeParametersInDeclaration.size() && itype < mTypesUsedInTemplateInstantiation.size()) {
                             std::stack<Token *> brackets1; // holds "(" and "{" tokens
                             for (const Token *typetok = mTypesUsedInTemplateInstantiation[itype].token();
-                                 typetok && (typeindentlevel>0 || !Token::Match(typetok, ",|>"));
+                                 typetok && !Token::Match(typetok, ",|>");
                                  typetok = typetok->next()) {
                                 if (!Token::simpleMatch(typetok, "...")) {
-                                    if (Token::Match(typetok, "%name% <") && (typetok->strAt(2) == ">" || templateParameters(typetok->next())))
-                                        ++typeindentlevel;
-                                    else if (typeindentlevel > 0 && typetok->str() == ">")
-                                        --typeindentlevel;
-                                    else if (typetok->str() == "(")
-                                        ++typeindentlevel;
-                                    else if (typetok->str() == ")")
-                                        --typeindentlevel;
                                     mTokenList.addtoken(typetok, tok5);
                                     Token *back = mTokenList.back();
                                     if (Token::Match(back, "{|(|[")) {
@@ -1886,7 +2021,10 @@ void TemplateSimplifier::expandTemplate(
                                         Token::createMutualLinks(brackets1.top(), back);
                                         brackets1.pop();
                                     }
-                                    back->isTemplateArg(true);
+                                    back->templateArgFrom(typetok);
+                                    back->isUnsigned(typetok->isUnsigned());
+                                    back->isSigned(typetok->isSigned());
+                                    back->isLong(typetok->isLong());
                                     added = true;
                                     break;
                                 }
@@ -1922,16 +2060,16 @@ void TemplateSimplifier::expandTemplate(
             if (copy) {
                 if (!templateDeclaration.scope().empty() && tok3->strAt(-1) != "::")
                     addNamespace(templateDeclaration, tok3);
-                mTokenList.addtoken(newName, tok3->linenr(), tok3->fileIndex());
+                mTokenList.addtoken(newName, tok3->linenr(), tok3->column(), tok3->fileIndex());
             }
 
             while (tok3 && tok3->str() != "::")
                 tok3 = tok3->next();
 
-            std::list<TokenAndName>::iterator it = std::find_if(mTemplateDeclarations.begin(),
-                                                   mTemplateDeclarations.end(),
-                                                   FindToken(startOfTemplateDeclaration));
-            if (it != mTemplateDeclarations.end())
+            const auto it = std::find_if(mTemplateDeclarations.cbegin(),
+                                         mTemplateDeclarations.cend(),
+                                         FindToken(startOfTemplateDeclaration));
+            if (it != mTemplateDeclarations.cend())
                 mMemberFunctionsToDelete.push_back(*it);
         }
 
@@ -1945,20 +2083,57 @@ void TemplateSimplifier::expandTemplate(
         const std::string lastName = (templateInstantiation.name().find(' ') != std::string::npos) ? templateInstantiation.name().substr(templateInstantiation.name().rfind(' ')+1) : templateInstantiation.name();
 
         std::stack<const Token *> templates;
+        int scopeCount = 0;
         for (; tok3; tok3 = tok3->next()) {
-            if (tok3->isName() && !Token::Match(tok3, "class|typename|struct") && !tok3->isStandardType()) {
+            if (tok3->str() == "{")
+                ++scopeCount;
+            else if (tok3->str() == "}")
+                --scopeCount;
+            if (scopeCount < 0)
+                break;
+            if (tok3->isName() && !Token::Match(tok3, "class|typename|struct") && !tok3->isStandardType() && !Token::Match(tok3->previous(), ".|::")) {
                 // search for this token in the type vector
                 unsigned int itype = 0;
                 while (itype < typeParametersInDeclaration.size() && typeParametersInDeclaration[itype]->str() != tok3->str())
                     ++itype;
 
                 // replace type with given type..
-                if (itype < typeParametersInDeclaration.size()) {
+                if (itype < typeParametersInDeclaration.size() && itype < mTypesUsedInTemplateInstantiation.size()) {
                     unsigned int typeindentlevel = 0;
                     std::stack<Token *> brackets1; // holds "(" and "{" tokens
-                    for (const Token *typetok = mTypesUsedInTemplateInstantiation[itype].token();
-                         typetok && (typeindentlevel > 0 || !Token::Match(typetok, ",|>"));
+                    Token * const beforeTypeToken = mTokenList.back();
+                    bool pointerType = false;
+                    const bool isVariadicTemplateArg = templateDeclaration.isVariadic() && itype + 1 == typeParametersInDeclaration.size();
+                    if (isVariadicTemplateArg && Token::Match(tok3, "%name% ... %name%"))
+                        tok3 = tok3->tokAt(2);
+                    if (!isVariadicTemplateArg && copy && Token::Match(mTypesUsedInTemplateInstantiation[itype].token(), "%num% ,|>|>>") &&
+                        Token::Match(tok3->previous(), "%assign%|%cop%|( %name% %cop%|;|)")) {
+                        const Token* declTok = typeParametersInDeclaration[itype];
+                        while (Token::Match(declTok->previous(), "%name%|::|*"))
+                            declTok = declTok->previous();
+                        if (Token::Match(declTok->previous(), "[<,]")) {
+                            const Token* typetok = mTypesUsedInTemplateInstantiation[itype].token();
+                            mTokenList.addtoken("(", declTok);
+                            Token* const par1 = mTokenList.back();
+                            while (declTok != typeParametersInDeclaration[itype]) {
+                                mTokenList.addtoken(declTok);
+                                declTok = declTok->next();
+                            }
+                            mTokenList.addtoken(")", declTok);
+                            Token::createMutualLinks(par1, mTokenList.back());
+                            mTokenList.addtoken(typetok, tok3);
+                            for (Token* t = par1; t; t = t->next())
+                                t->templateArgFrom(typetok);
+                            continue;
+                        }
+                    }
+                    const std::string endStr(isVariadicTemplateArg ? ">" : ",>");
+                    Token* begPar = nullptr;
+                    for (Token *typetok = mTypesUsedInTemplateInstantiation[itype].token();
+                         typetok && (typeindentlevel > 0 || endStr.find(typetok->str()[0]) == std::string::npos);
                          typetok = typetok->next()) {
+                        if (typeindentlevel == 0 && typetok->str() == "*")
+                            pointerType = true;
                         if (Token::simpleMatch(typetok, "..."))
                             continue;
                         if (Token::Match(typetok, "%name% <") &&
@@ -1968,16 +2143,23 @@ void TemplateSimplifier::expandTemplate(
                         } else if (typeindentlevel > 0 && typetok->str() == ">" && brackets1.top()->str() == "<") {
                             --typeindentlevel;
                             brackets1.pop();
+                        } else if (Token::Match(typetok, "const_cast|dynamic_cast|reinterpret_cast|static_cast <")) {
+                            brackets1.push(typetok->next());
+                            ++typeindentlevel;
                         } else if (typetok->str() == "(")
                             ++typeindentlevel;
                         else if (typetok->str() == ")")
                             --typeindentlevel;
                         Token *back;
                         if (copy) {
+                            if (isVariadicTemplateArg && typetok == mTypesUsedInTemplateInstantiation[itype].token() && typetok->isLiteral()) {
+                                mTokenList.addtoken("(", mTokenList.back());
+                                begPar = mTokenList.back();
+                            }
                             mTokenList.addtoken(typetok, tok3);
                             back = mTokenList.back();
                         } else
-                            back = const_cast<Token *>(typetok);
+                            back = typetok;
                         if (Token::Match(back, "{|(|["))
                             brackets1.push(back);
                         else if (back->str() == "}") {
@@ -2000,7 +2182,15 @@ void TemplateSimplifier::expandTemplate(
                             brackets1.pop();
                         }
                         if (copy)
-                            back->isTemplateArg(true);
+                            back->templateArgFrom(typetok);
+                    }
+                    if (begPar) {
+                        mTokenList.addtoken(")", mTokenList.back());
+                        Token::createMutualLinks(begPar, mTokenList.back());
+                    }
+                    if (pointerType && Token::simpleMatch(beforeTypeToken, "const")) {
+                        mTokenList.addtoken(beforeTypeToken);
+                        beforeTypeToken->deleteThis();
                     }
                     continue;
                 }
@@ -2022,9 +2212,10 @@ void TemplateSimplifier::expandTemplate(
                                 eraseTokens(tok3, closingBracket->next());
                             }
                             continue;
-                        } else if (!templateDeclaration.scope().empty() &&
-                                   !alreadyHasNamespace(templateDeclaration, tok3) &&
-                                   !Token::Match(closingBracket->next(), "(|::")) {
+                        }
+                        if (!templateDeclaration.scope().empty() &&
+                            !alreadyHasNamespace(templateDeclaration, tok3) &&
+                            !Token::Match(closingBracket->next(), "(|::")) {
                             if (copy)
                                 addNamespace(templateDeclaration, tok3);
                         }
@@ -2041,7 +2232,7 @@ void TemplateSimplifier::expandTemplate(
                             addNamespace(templateDeclaration, tok3);
                         }
                         mTokenList.addtoken(newName, tok3);
-                    } else if (!Token::Match(tok3->next(), ":|{|="))
+                    } else if (!Token::Match(tok3->next(), "[:{=;[]),]"))
                         tok3->str(newName);
                     continue;
                 }
@@ -2077,6 +2268,10 @@ void TemplateSimplifier::expandTemplate(
                         continue;
                 }
 
+                // don't add instantiations in template definitions
+                if (!templates.empty())
+                    continue;
+
                 std::string scope;
                 const Token *prev = tok3;
                 for (; Token::Match(prev->tokAt(-2), "%name% ::"); prev = prev->tokAt(-2)) {
@@ -2090,23 +2285,20 @@ void TemplateSimplifier::expandTemplate(
                 if (prev->strAt(-1) != "::") {
                     // adjust for current scope
                     std::string token_scope = tok3->scopeInfo()->name;
-                    std::string::size_type end = token_scope.find_last_of(" :: ");
+                    const std::string::size_type end = token_scope.find_last_of(" :: ");
                     if (end != std::string::npos) {
                         token_scope.resize(end);
                         if (scope.empty())
-                            scope = token_scope;
+                            scope = std::move(token_scope);
                         else
                             scope = token_scope + " :: " + scope;
                     }
                 }
 
-                // don't add instantiations in template definitions
-                if (templates.empty()) {
-                    if (copy)
-                        newInstantiations.emplace_back(mTokenList.back(), scope);
-                    else if (!inTemplateDefinition)
-                        newInstantiations.emplace_back(tok3, scope);
-                }
+                if (copy)
+                    newInstantiations.emplace_back(mTokenList.back(), std::move(scope));
+                else if (!inTemplateDefinition)
+                    newInstantiations.emplace_back(tok3, std::move(scope));
             }
 
             // link() newly tokens manually
@@ -2121,13 +2313,13 @@ void TemplateSimplifier::expandTemplate(
                     assert(brackets.empty() == false);
                     assert(brackets.top()->str() == "{");
                     Token::createMutualLinks(brackets.top(), mTokenList.back());
-                    if (tok3->strAt(1) == ";") {
-                        const Token * tokSemicolon = tok3->next();
-                        mTokenList.addtoken(tokSemicolon, tokSemicolon->linenr(), tokSemicolon->fileIndex());
-                    }
                     brackets.pop();
-                    if (brackets.empty() && !Token::Match(tok3, "} >|,|%cop%")) {
+                    if (brackets.empty() && !Token::Match(tok3, "} >|,|{")) {
                         inTemplateDefinition = false;
+                        if (isClass && tok3->strAt(1) == ";") {
+                            const Token* tokSemicolon = tok3->next();
+                            mTokenList.addtoken(tokSemicolon, tokSemicolon->linenr(), tokSemicolon->column(), tokSemicolon->fileIndex());
+                        }
                         break;
                     }
                 } else if (tok3->str() == ")") {
@@ -2149,10 +2341,11 @@ void TemplateSimplifier::expandTemplate(
 
     // add new instantiations
     for (const auto & inst : newInstantiations) {
-        std::string fullName = inst.scope + (inst.scope.empty() ? "" : " :: ") + inst.token->str();
-        simplifyTemplateArgs(inst.token->tokAt(2), inst.token->next()->findClosingBracket());
+        if (!inst.token)
+            continue;
+        simplifyTemplateArgs(inst.token->tokAt(2), inst.token->next()->findClosingBracket(), &newInstantiations);
         // only add recursive instantiation if its arguments are a constant expression
-        if (templateDeclaration.fullName() != fullName ||
+        if (templateDeclaration.name() != inst.token->str() ||
             (inst.token->tokAt(2)->isNumber() || inst.token->tokAt(2)->isStandardType()))
             mTemplateInstantiations.emplace_back(inst.token, inst.scope);
     }
@@ -2202,8 +2395,8 @@ bool TemplateSimplifier::simplifyNumericCalculations(Token *tok, bool isTemplate
             break;
         const Token* op = tok->next();
         const Token* after = tok->tokAt(3);
-        const std::string &num1 = op->previous()->str();
-        const std::string &num2 = op->next()->str();
+        const std::string &num1 = op->strAt(-1);
+        const std::string &num2 = op->strAt(1);
         if (Token::Match(before, "* %num% /") && (num2 != "0") && num1 == MathLib::multiply(num2, MathLib::divide(num1, num2))) {
             // Division where result is a whole number
         } else if (!((op->str() == "*" && (isLowerThanMulDiv(before) || before->str() == "*") && isLowerEqualThanMulDiv(after)) || // associative
@@ -2219,8 +2412,9 @@ bool TemplateSimplifier::simplifyNumericCalculations(Token *tok, bool isTemplate
 
         // Don't simplify "%num% / 0"
         if (Token::Match(op, "[/%] 0")) {
-            if (isTemplate) throw InternalError(op, "Instantiation error: Divide by zero in template instantiation.", InternalError::INSTANTIATION);
-            else return ret;
+            if (isTemplate)
+                throw InternalError(op, "Instantiation error: Divide by zero in template instantiation.", InternalError::INSTANTIATION);
+            return ret;
         }
 
         // Integer operations
@@ -2253,7 +2447,7 @@ bool TemplateSimplifier::simplifyNumericCalculations(Token *tok, bool isTemplate
             case '^':
                 tok->str((v1 ^ v2).str());
                 break;
-            };
+            }
         }
 
         // Logical operations
@@ -2285,7 +2479,7 @@ bool TemplateSimplifier::simplifyNumericCalculations(Token *tok, bool isTemplate
     return ret;
 }
 
-static Token *skipTernaryOp(Token *tok, Token *backToken)
+static Token *skipTernaryOp(Token *tok, const Token *backToken)
 {
     unsigned int colonLevel = 1;
     while (nullptr != (tok = tok->next())) {
@@ -2308,7 +2502,19 @@ static Token *skipTernaryOp(Token *tok, Token *backToken)
     return tok;
 }
 
-void TemplateSimplifier::simplifyTemplateArgs(Token *start, Token *end)
+static void invalidateInst(const Token* beg, const Token* end, std::vector<newInstantiation>* newInst) {
+    if (!newInst)
+        return;
+    for (auto& inst : *newInst) {
+        for (const Token* tok = beg; tok != end; tok = tok->next())
+            if (inst.token == tok) {
+                inst.token = nullptr;
+                break;
+            }
+    }
+}
+
+void TemplateSimplifier::simplifyTemplateArgs(Token *start, const Token *end, std::vector<newInstantiation>* newInst)
 {
     // start could be erased so use the token before start if available
     Token * first = (start && start->previous()) ? start->previous() : mTokenList.front();
@@ -2324,9 +2530,7 @@ void TemplateSimplifier::simplifyTemplateArgs(Token *start, Token *end)
                     tok->deleteNext();
                     tok->deleteThis();
                     tok->deleteNext();
-                    std::ostringstream sz;
-                    sz << 1;
-                    tok->str(sz.str());
+                    tok->str(std::to_string(1));
                     again = true;
                 }
 
@@ -2335,24 +2539,22 @@ void TemplateSimplifier::simplifyTemplateArgs(Token *start, Token *end)
                     tok->deleteNext();
                     tok->deleteThis();
                     tok->deleteNext();
-                    std::ostringstream ostr;
-                    ostr << (Token::getStrLength(tok) + 1);
-                    tok->str(ostr.str());
+                    tok->str(std::to_string(Token::getStrLength(tok) + 1));
                     again = true;
                 }
 
                 else if (Token::Match(tok->next(), "( %type% * )")) {
-                    tok->str(MathLib::toString(mTokenizer->sizeOfType(tok->tokAt(3))));
+                    tok->str(std::to_string(mTokenizer.sizeOfType(tok->tokAt(3))));
                     tok->deleteNext(4);
                     again = true;
                 } else if (Token::simpleMatch(tok->next(), "( * )")) {
-                    tok->str(MathLib::toString(mTokenizer->sizeOfType(tok->tokAt(2))));
+                    tok->str(std::to_string(mTokenizer.sizeOfType(tok->tokAt(2))));
                     tok->deleteNext(3);
                     again = true;
                 } else if (Token::Match(tok->next(), "( %type% )")) {
-                    const unsigned int size = mTokenizer->sizeOfType(tok->tokAt(2));
+                    const unsigned int size = mTokenizer.sizeOfType(tok->tokAt(2));
                     if (size > 0) {
-                        tok->str(MathLib::toString(size));
+                        tok->str(std::to_string(size));
                         tok->deleteNext(3);
                         again = true;
                     }
@@ -2364,30 +2566,34 @@ void TemplateSimplifier::simplifyTemplateArgs(Token *start, Token *end)
                        MathLib::isInt(tok->strAt(2))) {
                 if ((Token::Match(tok->previous(), "(|&&|%oror%|,") || tok == start) &&
                     (Token::Match(tok->tokAt(3), ")|&&|%oror%|?") || tok->tokAt(3) == end)) {
-                    const MathLib::bigint op1(MathLib::toLongNumber(tok->str()));
-                    const std::string &cmp(tok->next()->str());
-                    const MathLib::bigint op2(MathLib::toLongNumber(tok->strAt(2)));
+                    const MathLib::bigint op1(MathLib::toBigNumber(tok));
+                    const std::string &cmp(tok->strAt(1));
+                    const MathLib::bigint op2(MathLib::toBigNumber(tok->tokAt(2)));
 
                     std::string result;
 
                     if (cmp == "==")
-                        result = (op1 == op2) ? "true" : "false";
+                        result = bool_to_string(op1 == op2);
                     else if (cmp == "!=")
-                        result = (op1 != op2) ? "true" : "false";
+                        result = bool_to_string(op1 != op2);
                     else if (cmp == "<=")
-                        result = (op1 <= op2) ? "true" : "false";
+                        result = bool_to_string(op1 <= op2);
                     else if (cmp == ">=")
-                        result = (op1 >= op2) ? "true" : "false";
+                        result = bool_to_string(op1 >= op2);
                     else if (cmp == "<")
-                        result = (op1 < op2) ? "true" : "false";
+                        result = bool_to_string(op1 < op2);
                     else
-                        result = (op1 > op2) ? "true" : "false";
+                        result = bool_to_string(op1 > op2);
 
                     tok->str(result);
                     tok->deleteNext(2);
                     again = true;
                     tok = tok->previous();
                 }
+            } else if (Token::Match(tok, "( %type% ) %num%")) {
+                tok = tok->previous();
+                again = true;
+                tok->deleteNext(3);
             }
         }
 
@@ -2398,11 +2604,11 @@ void TemplateSimplifier::simplifyTemplateArgs(Token *start, Token *end)
             if (tok->str() == "?" &&
                 ((tok->previous()->isNumber() || tok->previous()->isBoolean()) ||
                  Token::Match(tok->tokAt(-3), "( %bool%|%num% )"))) {
-                const int offset = (tok->previous()->str() == ")") ? 2 : 1;
+                const int offset = (tok->strAt(-1) == ")") ? 2 : 1;
 
                 // Find the token ":" then go to the next token
                 Token *colon = skipTernaryOp(tok, end);
-                if (!colon || colon->previous()->str() != ":" || !colon->next())
+                if (!colon || colon->strAt(-1) != ":" || !colon->next())
                     continue;
 
                 //handle the GNU extension: "x ? : y" <-> "x ? x : y"
@@ -2420,6 +2626,7 @@ void TemplateSimplifier::simplifyTemplateArgs(Token *start, Token *end)
                 }
 
                 if (Token::Match(tok->next(), "false|0")) {
+                    invalidateInst(tok->next(), colon, newInst);
                     // Use code after colon, remove code before it.
                     Token::eraseTokens(tok, colon);
 
@@ -2446,6 +2653,7 @@ void TemplateSimplifier::simplifyTemplateArgs(Token *start, Token *end)
                             else if (endTok->str() == ">" && !end)
                                 ;
                             else {
+                                invalidateInst(colon->tokAt(-1), endTok, newInst);
                                 Token::eraseTokens(colon->tokAt(-2), endTok);
                                 again = true;
                                 break;
@@ -2457,8 +2665,15 @@ void TemplateSimplifier::simplifyTemplateArgs(Token *start, Token *end)
         }
 
         for (Token *tok = first->next(); tok && tok != end; tok = tok->next()) {
+            if (tok->isKeyword() && endsWith(tok->str(), "_cast")) {
+                Token* tok2 = tok->next()->findClosingBracket();
+                if (!Token::simpleMatch(tok2, "> ("))
+                    syntaxError(tok);
+                tok = tok2->linkAt(1);
+                continue;
+            }
             if (Token::Match(tok, "( %num%|%bool% )") &&
-                (tok->previous() && !Token::Match(tok->previous(), "%name%"))) {
+                (tok->previous() && !tok->previous()->isName())) {
                 tok->deleteThis();
                 tok->deleteNext();
                 again = true;
@@ -2502,7 +2717,7 @@ static bool validTokenEnd(bool bounded, const Token *tok, const Token *backToken
 
 // TODO: This is not the correct class for simplifyCalculations(), so it
 // should be moved away.
-bool TemplateSimplifier::simplifyCalculations(Token* frontToken, Token *backToken, bool isTemplate)
+bool TemplateSimplifier::simplifyCalculations(Token* frontToken, const Token *backToken, bool isTemplate)
 {
     bool ret = false;
     const bool bounded = frontToken || backToken;
@@ -2535,7 +2750,7 @@ bool TemplateSimplifier::simplifyCalculations(Token* frontToken, Token *backToke
 
         if (validTokenEnd(bounded, tok, backToken, 3) &&
             Token::Match(tok->previous(), "(|&&|%oror% %char% %comp% %num% &&|%oror%|)")) {
-            tok->str(MathLib::toString(MathLib::toLongNumber(tok->str())));
+            tok->str(MathLib::toString(MathLib::toBigNumber(tok)));
         }
 
         if (validTokenEnd(bounded, tok, backToken, 5) &&
@@ -2556,7 +2771,7 @@ bool TemplateSimplifier::simplifyCalculations(Token* frontToken, Token *backToke
                 tok->str("bool");
             else if (MathLib::isFloat(tok->str())) {
                 // MathLib::getSuffix doesn't work for floating point numbers
-                char suffix = tok->str().back();
+                const char suffix = tok->str().back();
                 if (suffix == 'f' || suffix == 'F')
                     tok->str("float");
                 else if (suffix == 'l' || suffix == 'L') {
@@ -2580,7 +2795,8 @@ bool TemplateSimplifier::simplifyCalculations(Token* frontToken, Token *backToke
         }
 
         if (validTokenEnd(bounded, tok, backToken, 2) &&
-            Token::Match(tok, "char|short|int|long { }")) {
+            (Token::Match(tok, "char|short|int|long { }") ||
+             Token::Match(tok, "char|short|int|long ( )"))) {
             tok->str("0"); // FIXME add type suffix
             tok->isSigned(false);
             tok->isUnsigned(false);
@@ -2609,7 +2825,7 @@ bool TemplateSimplifier::simplifyCalculations(Token* frontToken, Token *backToke
                  Token::Match(tok->previous(), "[(=,] 1 %oror%"))) {
                 unsigned int par = 0;
                 const Token *tok2 = tok;
-                const bool andAnd = (tok->next()->str() == "&&");
+                const bool andAnd = (tok->strAt(1) == "&&");
                 for (; tok2; tok2 = tok2->next()) {
                     if (tok2->str() == "(" || tok2->str() == "[")
                         ++par;
@@ -2633,7 +2849,7 @@ bool TemplateSimplifier::simplifyCalculations(Token* frontToken, Token *backToke
                      (Token::Match(tok->previous(), "%or% 0 %cop%|;") && isLowerThanXor(tok->next())))) {
                     tok = tok->previous();
                     if (Token::Match(tok->tokAt(-4), "[;{}] %name% = %name% [+-|] 0 ;") &&
-                        tok->strAt(-3) == tok->previous()->str()) {
+                        tok->strAt(-3) == tok->strAt(-1)) {
                         tok = tok->tokAt(-4);
                         tok->deleteNext(5);
                     } else {
@@ -2650,12 +2866,12 @@ bool TemplateSimplifier::simplifyCalculations(Token* frontToken, Token *backToke
                 } else if ((((Token::Match(tok->previous(), "[=[(,] 0 * %name%|%num% ,|]|)|;|=|%cop%") ||
                               Token::Match(tok->previous(), "return|case 0 *|&& %name%|%num% ,|:|;|=|%cop%")) &&
                              validTokenEnd(bounded, tok, backToken, 3)) ||
-                            (((Token::Match(tok->previous(), "[=[(,] 0 * (") ||
-                               Token::Match(tok->previous(), "return|case 0 *|&& (")) &&
-                              validTokenEnd(bounded, tok, backToken, 2))))) {
+                            ((Token::Match(tok->previous(), "[=[(,] 0 * (") ||
+                              Token::Match(tok->previous(), "return|case 0 *|&& (")) &&
+                             validTokenEnd(bounded, tok, backToken, 2)))) {
                     tok->deleteNext();
-                    if (tok->next()->str() == "(")
-                        eraseTokens(tok, tok->next()->link());
+                    if (tok->strAt(1) == "(")
+                        eraseTokens(tok, tok->linkAt(1));
                     tok->deleteNext();
                     ret = true;
                 } else if (validTokenEnd(bounded, tok, backToken, 4) &&
@@ -2663,8 +2879,8 @@ bool TemplateSimplifier::simplifyCalculations(Token* frontToken, Token *backToke
                             Token::Match(tok->previous(), "return|case 0 && *|& %any% ,|:|;|=|%cop%"))) {
                     tok->deleteNext();
                     tok->deleteNext();
-                    if (tok->next()->str() == "(")
-                        eraseTokens(tok, tok->next()->link());
+                    if (tok->strAt(1) == "(")
+                        eraseTokens(tok, tok->linkAt(1));
                     tok->deleteNext();
                     ret = true;
                 }
@@ -2675,8 +2891,8 @@ bool TemplateSimplifier::simplifyCalculations(Token* frontToken, Token *backToke
                     (Token::Match(tok->previous(), "[=[(,] 1 %oror% %any% ,|]|)|;|=|%cop%") ||
                      Token::Match(tok->previous(), "return|case 1 %oror% %any% ,|:|;|=|%cop%"))) {
                     tok->deleteNext();
-                    if (tok->next()->str() == "(")
-                        eraseTokens(tok, tok->next()->link());
+                    if (tok->strAt(1) == "(")
+                        eraseTokens(tok, tok->linkAt(1));
                     tok->deleteNext();
                     ret = true;
                 } else if (validTokenEnd(bounded, tok, backToken, 4) &&
@@ -2684,8 +2900,8 @@ bool TemplateSimplifier::simplifyCalculations(Token* frontToken, Token *backToke
                             Token::Match(tok->previous(), "return|case 1 %oror% *|& %any% ,|:|;|=|%cop%"))) {
                     tok->deleteNext();
                     tok->deleteNext();
-                    if (tok->next()->str() == "(")
-                        eraseTokens(tok, tok->next()->link());
+                    if (tok->strAt(1) == "(")
+                        eraseTokens(tok, tok->linkAt(1));
                     tok->deleteNext();
                     ret = true;
                 }
@@ -2730,9 +2946,9 @@ bool TemplateSimplifier::simplifyCalculations(Token* frontToken, Token *backToke
                 if (validTokenStart(bounded, tok, frontToken, -1) &&
                     Token::Match(tok->previous(), "(|&&|%oror%") &&
                     Token::Match(tok->tokAt(3), ")|&&|%oror%|?")) {
-                    const MathLib::bigint op1(MathLib::toLongNumber(tok->str()));
-                    const std::string &cmp(tok->next()->str());
-                    const MathLib::bigint op2(MathLib::toLongNumber(tok->strAt(2)));
+                    const MathLib::bigint op1(MathLib::toBigNumber(tok));
+                    const std::string &cmp(tok->strAt(1));
+                    const MathLib::bigint op2(MathLib::toBigNumber(tok->tokAt(2)));
 
                     std::string result;
 
@@ -2760,7 +2976,7 @@ bool TemplateSimplifier::simplifyCalculations(Token* frontToken, Token *backToke
     return ret;
 }
 
-const Token * TemplateSimplifier::getTemplateParametersInDeclaration(
+void TemplateSimplifier::getTemplateParametersInDeclaration(
     const Token * tok,
     std::vector<const Token *> & typeParametersInDeclaration)
 {
@@ -2768,6 +2984,7 @@ const Token * TemplateSimplifier::getTemplateParametersInDeclaration(
 
     typeParametersInDeclaration.clear();
     const Token *end = tok->previous()->findClosingBracket();
+    bool inDefaultValue = false;
     for (; tok && tok!= end; tok = tok->next()) {
         if (Token::simpleMatch(tok, "template <")) {
             const Token *closing = tok->next()->findClosingBracket();
@@ -2775,10 +2992,22 @@ const Token * TemplateSimplifier::getTemplateParametersInDeclaration(
                 tok = closing->next();
         } else if (tok->link() && Token::Match(tok, "{|(|["))
             tok = tok->link();
-        else if (Token::Match(tok, "%name% ,|>|="))
-            typeParametersInDeclaration.push_back(tok);
+        else if (Token::Match(tok, "%name% ,|>|=")) {
+            if (!inDefaultValue) {
+                typeParametersInDeclaration.push_back(tok);
+                if (tok->strAt(1) == "=")
+                    inDefaultValue = true;
+            }
+        } else if (inDefaultValue) {
+            if (tok->str() == ",")
+                inDefaultValue = false;
+            else if (tok->str() == "<") {
+                const Token *closing = tok->findClosingBracket();
+                if (closing)
+                    tok = closing;
+            }
+        }
     }
-    return tok;
 }
 
 bool TemplateSimplifier::matchSpecialization(
@@ -2787,7 +3016,7 @@ bool TemplateSimplifier::matchSpecialization(
     const std::list<const Token *> & specializations)
 {
     // Is there a matching specialization?
-    for (std::list<const Token *>::const_iterator it = specializations.begin(); it != specializations.end(); ++it) {
+    for (auto it = specializations.cbegin(); it != specializations.cend(); ++it) {
         if (!Token::Match(*it, "%name% <"))
             continue;
         const Token *startToken = (*it);
@@ -2795,6 +3024,7 @@ bool TemplateSimplifier::matchSpecialization(
             startToken = startToken->previous();
         if (!Token::simpleMatch(startToken, "template <"))
             continue;
+        // cppcheck-suppress shadowFunction - TODO: fix this
         std::vector<const Token *> templateParameters;
         getTemplateParametersInDeclaration(startToken->tokAt(2), templateParameters);
 
@@ -2804,7 +3034,10 @@ bool TemplateSimplifier::matchSpecialization(
         if (!endToken)
             continue;
         while (declToken != endToken) {
-            if (declToken->str() != instToken->str()) {
+            if (declToken->str() != instToken->str() ||
+                declToken->isSigned() != instToken->isSigned() ||
+                declToken->isUnsigned() != instToken->isUnsigned() ||
+                declToken->isLong() != instToken->isLong()) {
                 int nr = 0;
                 while (nr < templateParameters.size() && templateParameters[nr]->str() != declToken->str())
                     ++nr;
@@ -2836,7 +3069,7 @@ std::string TemplateSimplifier::getNewName(
     const Token * endToken = tok2->next()->findClosingBracket();
     for (Token *tok3 = tok2->tokAt(2); tok3 != endToken && (indentlevel > 0 || tok3->str() != ">"); tok3 = tok3->next()) {
         // #2721 - unhandled [ => bail out
-        if (tok3->str() == "[") {
+        if (tok3->str() == "[" && !Token::Match(tok3->next(), "%num%| ]")) {
             typeForNewName.clear();
             break;
         }
@@ -2846,29 +3079,36 @@ std::string TemplateSimplifier::getNewName(
         }
         if (Token::Match(tok3->tokAt(-2), "<|,|:: %name% <") && (tok3->strAt(1) == ">" || templateParameters(tok3)))
             ++indentlevel;
-        else if (indentlevel > 0 && Token::Match(tok3, "> [,>]"))
+        else if (indentlevel > 0 && Token::Match(tok3, "> ,|>|::"))
             --indentlevel;
-        if (indentlevel == 0 && Token::Match(tok3->previous(), "[<,]")) {
+        else if (indentlevel == 0 && Token::Match(tok3->previous(), "[<,]")) {
             mTypesUsedInTemplateInstantiation.emplace_back(tok3, "");
         }
-        if (tok3->str() == "(")
+        if (Token::Match(tok3, "(|["))
             ++indentlevel;
-        else if (tok3->str() == ")")
+        else if (Token::Match(tok3, ")|]"))
             --indentlevel;
         const bool constconst = tok3->str() == "const" && tok3->strAt(1) == "const";
         if (!constconst) {
+            if (tok3->isUnsigned())
+                typeStringsUsedInTemplateInstantiation.emplace_back("unsigned");
+            else if (tok3->isSigned())
+                typeStringsUsedInTemplateInstantiation.emplace_back("signed");
+            if (tok3->isLong())
+                typeStringsUsedInTemplateInstantiation.emplace_back("long");
             typeStringsUsedInTemplateInstantiation.push_back(tok3->str());
         }
         // add additional type information
         if (!constconst && !Token::Match(tok3, "class|struct|enum")) {
-            if (tok3->isUnsigned())
-                typeForNewName += "unsigned";
-            else if (tok3->isSigned())
-                typeForNewName += "signed";
-            if (tok3->isLong())
-                typeForNewName += "long";
             if (!typeForNewName.empty())
                 typeForNewName += ' ';
+            if (tok3->isUnsigned())
+                typeForNewName += "unsigned ";
+            else if (tok3->isSigned())
+                typeForNewName += "signed ";
+            if (tok3->isLong()) {
+                typeForNewName += "long ";
+            }
             typeForNewName += tok3->str();
         }
     }
@@ -2889,7 +3129,7 @@ bool TemplateSimplifier::simplifyTemplateInstantiations(
     // Contains tokens such as "T"
     std::vector<const Token *> typeParametersInDeclaration;
     getTemplateParametersInDeclaration(templateDeclaration.token()->tokAt(2), typeParametersInDeclaration);
-    const bool printDebug = mSettings->debugwarnings;
+    const bool printDebug = mSettings.debugwarnings;
     const bool specialized = templateDeclaration.isSpecialization();
     const bool isfunc = templateDeclaration.isFunction();
     const bool isVar = templateDeclaration.isVariable();
@@ -2901,10 +3141,29 @@ bool TemplateSimplifier::simplifyTemplateInstantiations(
     bool instantiated = false;
 
     for (const TokenAndName &instantiation : mTemplateInstantiations) {
+        // skip deleted instantiations
+        if (!instantiation.token())
+            continue;
         if (numberOfTemplateInstantiations != mTemplateInstantiations.size()) {
             numberOfTemplateInstantiations = mTemplateInstantiations.size();
             ++recursiveCount;
-            if (recursiveCount > 100) {
+            if (recursiveCount > mSettings.maxTemplateRecursion) {
+                if (mSettings.severity.isEnabled(Severity::information)) {
+                    std::list<std::string> typeStringsUsedInTemplateInstantiation;
+                    const std::string typeForNewName = templateDeclaration.name() + "<" + getNewName(instantiation.token(), typeStringsUsedInTemplateInstantiation) + ">";
+
+                    const std::list<const Token *> callstack(1, instantiation.token());
+                    const ErrorMessage errmsg(callstack,
+                                              &mTokenizer.list,
+                                              Severity::information,
+                                              "templateRecursion",
+                                              "TemplateSimplifier: max template recursion ("
+                                              + std::to_string(mSettings.maxTemplateRecursion)
+                                              + ") reached for template '"+typeForNewName+"'.",
+                                              Certainty::normal);
+                    mErrorLogger.reportErr(errmsg);
+                }
+
                 // bail out..
                 break;
             }
@@ -2914,7 +3173,9 @@ bool TemplateSimplifier::simplifyTemplateInstantiations(
         if (!Token::Match(instantiation.token(), "%name% <"))
             continue;
 
-        if (instantiation.fullName() != templateDeclaration.fullName()) {
+        if (!((instantiation.fullName() == templateDeclaration.fullName()) ||
+              (instantiation.name() == templateDeclaration.name() &&
+               instantiation.fullName() == templateDeclaration.scope()))) {
             // FIXME: fallback to not matching scopes until type deduction works
 
             // names must match
@@ -2926,6 +3187,38 @@ bool TemplateSimplifier::simplifyTemplateInstantiations(
                 continue;
         }
 
+        // make sure constructors and destructors don't match each other
+        if (templateDeclaration.nameToken()->strAt(-1) == "~" && instantiation.token()->strAt(-1) != "~")
+            continue;
+
+        // template families should match
+        if (!instantiation.isFunction() && templateDeclaration.isFunction()) {
+            // there are exceptions
+            if (!Token::simpleMatch(instantiation.token()->tokAt(-2), "decltype ("))
+                continue;
+        }
+
+        if (templateDeclaration.isFunction() && instantiation.isFunction()) {
+            std::vector<const Token*> declFuncArgs;
+            getFunctionArguments(templateDeclaration.nameToken(), declFuncArgs);
+            std::vector<const Token*> instFuncParams;
+            getFunctionArguments(instantiation.token(), instFuncParams);
+
+            if (declFuncArgs.size() != instFuncParams.size()) {
+                // check for default arguments
+                const Token* tok = templateDeclaration.nameToken()->tokAt(2);
+                const Token* end = templateDeclaration.nameToken()->linkAt(1);
+                size_t count = 0;
+                for (; tok != end; tok = tok->next()) {
+                    if (tok->str() == "=")
+                        count++;
+                }
+
+                if (instFuncParams.size() < (declFuncArgs.size() - count) || instFuncParams.size() > declFuncArgs.size())
+                    continue;
+            }
+        }
+
         // A global function can't be called through a pointer.
         if (templateDeclaration.isFunction() && templateDeclaration.scope().empty() &&
             (instantiation.token()->strAt(-1) == "." ||
@@ -2936,19 +3229,27 @@ bool TemplateSimplifier::simplifyTemplateInstantiations(
             continue;
 
         Token * const tok2 = instantiation.token();
-        if (mErrorLogger && !mTokenList.getFiles().empty())
-            mErrorLogger->reportProgress(mTokenList.getFiles()[0], "TemplateSimplifier::simplifyTemplateInstantiations()", tok2->progressValue());
-#ifdef MAXTIME
-        if (std::time(0) > maxtime)
+        if ((mSettings.reportProgress != -1) && !mTokenList.getFiles().empty())
+            mErrorLogger.reportProgress(mTokenList.getFiles()[0], "TemplateSimplifier::simplifyTemplateInstantiations()", tok2->progressValue());
+
+        if (maxtime > 0 && std::time(nullptr) > maxtime) {
+            if (mSettings.debugwarnings) {
+                ErrorMessage::FileLocation loc(mTokenList.getFiles()[0], 0, 0);
+                ErrorMessage errmsg({std::move(loc)},
+                                    "",
+                                    Severity::debug,
+                                    "Template instantiation maximum time exceeded",
+                                    "templateMaxTime",
+                                    Certainty::normal);
+                mErrorLogger.reportErr(errmsg);
+            }
             return false;
-#else
-        (void)maxtime;
-#endif
+        }
+
         assert(mTokenList.validateToken(tok2)); // that assertion fails on examples from #6021
 
         const Token *startToken = tok2;
-        while (Token::Match(startToken->tokAt(-2), "%name% :: %name%") ||
-               Token::Match(startToken->tokAt(-2), "> :: %name%")) {
+        while (Token::Match(startToken->tokAt(-2), ">|%name% :: %name%")) {
             if (startToken->strAt(-2) == ">") {
                 const Token * tok3 = startToken->tokAt(-2)->findOpeningBracket();
                 if (tok3)
@@ -2959,9 +3260,15 @@ bool TemplateSimplifier::simplifyTemplateInstantiations(
                 startToken = startToken->tokAt(-2);
         }
 
-        if (Token::Match(startToken->previous(), ";|{|}|=|const") &&
-            (!specialized && !instantiateMatch(tok2, typeParametersInDeclaration.size(), isfunc ? "(" : isVar ? ";|%op%|(" : "*|&|::| %name%")))
-            continue;
+        if (Token::Match(startToken->previous(), ";|{|}|=|const")) {
+            const char* patternAfter = isfunc ? "(" : isVar ? ";|%op%|(" : "*|&|::| %name%";
+            if (!isfunc && !isVar)
+                if (const Token* end = startToken->next()->findClosingBracket())
+                    if (Token::Match(end, "> (|{"))
+                        patternAfter = "(|{";
+            if (!specialized && !instantiateMatch(tok2, typeParametersInDeclaration.size(), templateDeclaration.isVariadic(), patternAfter))
+                continue;
+        }
 
         // New type..
         mTypesUsedInTemplateInstantiation.clear();
@@ -2969,11 +3276,11 @@ bool TemplateSimplifier::simplifyTemplateInstantiations(
         std::string typeForNewName = getNewName(tok2, typeStringsUsedInTemplateInstantiation);
 
         if ((typeForNewName.empty() && !templateDeclaration.isVariadic()) ||
-            (!typeParametersInDeclaration.empty() && typeParametersInDeclaration.size() != mTypesUsedInTemplateInstantiation.size())) {
-            if (printDebug && mErrorLogger) {
+            (!typeParametersInDeclaration.empty() && !instantiateMatch(tok2, typeParametersInDeclaration.size(), templateDeclaration.isVariadic(), nullptr))) {
+            if (printDebug) {
                 std::list<const Token *> callstack(1, tok2);
-                mErrorLogger->reportErr(ErrorLogger::ErrorMessage(callstack, &mTokenList, Severity::debug, "debug",
-                                        "Failed to instantiate template \"" + instantiation.name() + "\". The checking continues anyway.", false));
+                mErrorLogger.reportErr(ErrorMessage(callstack, &mTokenList, Severity::debug, "templateInstantiation",
+                                                    "Failed to instantiate template \"" + instantiation.name() + "\". The checking continues anyway.", Certainty::normal));
             }
             if (typeForNewName.empty())
                 continue;
@@ -2982,9 +3289,9 @@ bool TemplateSimplifier::simplifyTemplateInstantiations(
 
         // New classname/funcname..
         const std::string newName(templateDeclaration.name() + " < " + typeForNewName + " >");
-        const std::string newFullName(templateDeclaration.scope() + (templateDeclaration.scope().empty() ? "" : " :: ") + newName);
+        std::string newFullName(templateDeclaration.scope() + (templateDeclaration.scope().empty() ? "" : " :: ") + newName);
 
-        if (expandedtemplates.insert(newFullName).second) {
+        if (expandedtemplates.insert(std::move(newFullName)).second) {
             expandTemplate(templateDeclaration, instantiation, typeParametersInDeclaration, newName, !specialized && !isVar);
             instantiated = true;
             mChanged = true;
@@ -2997,22 +3304,30 @@ bool TemplateSimplifier::simplifyTemplateInstantiations(
     // process uninstantiated templates
     // TODO: remove the specialized check and handle all uninstantiated templates someday.
     if (!instantiated && specialized) {
-        Token * tok2 = const_cast<Token *>(templateDeclaration.nameToken());
-        if (mErrorLogger && !mTokenList.getFiles().empty())
-            mErrorLogger->reportProgress(mTokenList.getFiles()[0], "TemplateSimplifier::simplifyTemplateInstantiations()", tok2->progressValue());
-#ifdef MAXTIME
-        if (std::time(0) > maxtime)
+        auto * tok2 = const_cast<Token *>(templateDeclaration.nameToken());
+        if ((mSettings.reportProgress != -1) && !mTokenList.getFiles().empty())
+            mErrorLogger.reportProgress(mTokenList.getFiles()[0], "TemplateSimplifier::simplifyTemplateInstantiations()", tok2->progressValue());
+
+        if (maxtime > 0 && std::time(nullptr) > maxtime) {
+            if (mSettings.debugwarnings) {
+                ErrorMessage::FileLocation loc(mTokenList.getFiles()[0], 0, 0);
+                ErrorMessage errmsg({std::move(loc)},
+                                    "",
+                                    Severity::debug,
+                                    "Template instantiation maximum time exceeded",
+                                    "templateMaxTime",
+                                    Certainty::normal);
+                mErrorLogger.reportErr(errmsg);
+            }
             return false;
-#else
-        (void)maxtime;
-#endif
+        }
+
         assert(mTokenList.validateToken(tok2)); // that assertion fails on examples from #6021
 
         Token *startToken = tok2;
-        while (Token::Match(startToken->tokAt(-2), "%name% :: %name%") ||
-               Token::Match(startToken->tokAt(-2), "> :: %name%")) {
+        while (Token::Match(startToken->tokAt(-2), ">|%name% :: %name%")) {
             if (startToken->strAt(-2) == ">") {
-                const Token * tok3 = startToken->tokAt(-2)->findOpeningBracket();
+                Token * tok3 = startToken->tokAt(-2)->findOpeningBracket();
                 if (tok3)
                     startToken = tok3->previous();
                 else
@@ -3021,9 +3336,10 @@ bool TemplateSimplifier::simplifyTemplateInstantiations(
                 startToken = startToken->tokAt(-2);
         }
 
-        if (Token::Match(startToken->previous(), ";|{|}|=|const") &&
-            (!specialized && !instantiateMatch(tok2, typeParametersInDeclaration.size(), isfunc ? "(" : isVar ? ";|%op%|(" : "*|&|::| %name%")))
-            return false;
+        // TODO: re-enable when specialized check is removed
+        // if (Token::Match(startToken->previous(), ";|{|}|=|const") &&
+        //     (!specialized && !instantiateMatch(tok2, typeParametersInDeclaration.size(), isfunc ? "(" : isVar ? ";|%op%|(" : "*|&|::| %name%")))
+        //     return false;
 
         // already simplified
         if (!Token::Match(tok2, "%name% <"))
@@ -3038,19 +3354,19 @@ bool TemplateSimplifier::simplifyTemplateInstantiations(
         std::string typeForNewName = getNewName(tok2, typeStringsUsedInTemplateInstantiation);
 
         if (typeForNewName.empty()) {
-            if (printDebug && mErrorLogger) {
+            if (printDebug) {
                 std::list<const Token *> callstack(1, tok2);
-                mErrorLogger->reportErr(ErrorLogger::ErrorMessage(callstack, &mTokenList, Severity::debug, "debug",
-                                        "Failed to instantiate template \"" + templateDeclaration.name() + "\". The checking continues anyway.", false));
+                mErrorLogger.reportErr(ErrorMessage(callstack, &mTokenList, Severity::debug, "templateInstantiation",
+                                                    "Failed to instantiate template \"" + templateDeclaration.name() + "\". The checking continues anyway.", Certainty::normal));
             }
             return false;
         }
 
         // New classname/funcname..
         const std::string newName(templateDeclaration.name() + " < " + typeForNewName + " >");
-        const std::string newFullName(templateDeclaration.scope() + (templateDeclaration.scope().empty() ? "" : " :: ") + newName);
+        std::string newFullName(templateDeclaration.scope() + (templateDeclaration.scope().empty() ? "" : " :: ") + newName);
 
-        if (expandedtemplates.insert(newFullName).second) {
+        if (expandedtemplates.insert(std::move(newFullName)).second) {
             expandTemplate(templateDeclaration, templateDeclaration, typeParametersInDeclaration, newName, !specialized && !isVar);
             instantiated = true;
             mChanged = true;
@@ -3066,13 +3382,41 @@ bool TemplateSimplifier::simplifyTemplateInstantiations(
 
 static bool matchTemplateParameters(const Token *nameTok, const std::list<std::string> &strings)
 {
-    std::list<std::string>::const_iterator it = strings.begin();
     const Token *tok = nameTok->tokAt(2);
-    while (tok && it != strings.end() && *it == tok->str()) {
+    const Token *end = nameTok->next()->findClosingBracket();
+    if (!end)
+        return false;
+    auto it = strings.cbegin();
+    while (tok && tok != end && it != strings.cend()) {
+        if (tok->isUnsigned()) {
+            if (*it != "unsigned")
+                return false;
+
+            ++it;
+            if (it == strings.cend())
+                return false;
+        } else if (tok->isSigned()) {
+            if (*it != "signed")
+                return false;
+
+            ++it;
+            if (it == strings.cend())
+                return false;
+        }
+        if (tok->isLong()) {
+            if (*it != "long")
+                return false;
+
+            ++it;
+            if (it == strings.cend())
+                return false;
+        }
+        if (*it != tok->str())
+            return false;
         tok = tok->next();
         ++it;
     }
-    return it == strings.end() && tok && tok->str() == ">";
+    return it == strings.cend() && tok && tok->str() == ">";
 }
 
 void TemplateSimplifier::replaceTemplateUsage(
@@ -3080,18 +3424,18 @@ void TemplateSimplifier::replaceTemplateUsage(
     const std::list<std::string> &typeStringsUsedInTemplateInstantiation,
     const std::string &newName)
 {
-    std::list< std::pair<Token *, Token *> > removeTokens;
+    std::list<std::pair<Token *, Token *>> removeTokens;
     for (Token *nameTok = mTokenList.front(); nameTok; nameTok = nameTok->next()) {
         if (!Token::Match(nameTok, "%name% <") ||
             Token::Match(nameTok, "template|const_cast|dynamic_cast|reinterpret_cast|static_cast"))
             continue;
 
-        std::set<TemplateSimplifier::TokenAndName*> & pointers = nameTok->templateSimplifierPointers();
+        std::set<TemplateSimplifier::TokenAndName*>* pointers = nameTok->templateSimplifierPointers();
 
         // check if instantiation matches token instantiation from pointer
-        if (pointers.size()) {
+        if (pointers && !pointers->empty()) {
             // check full name
-            if (instantiation.fullName() != (*pointers.begin())->fullName()) {
+            if (instantiation.fullName() != (*pointers->begin())->fullName()) {
                 // FIXME:  fallback to just matching name
                 if (nameTok->str() != instantiation.name())
                     continue;
@@ -3107,68 +3451,31 @@ void TemplateSimplifier::replaceTemplateUsage(
         if (!matchTemplateParameters(nameTok, typeStringsUsedInTemplateInstantiation))
             continue;
 
-        // match parameters
-        Token * tok2 = nameTok->tokAt(2);
-        const Token * endToken = nameTok->next()->findClosingBracket();
-        unsigned int typeCountInInstantiation = tok2->str() == ">" ? 0U : 1U;
-        const Token *typetok = (!mTypesUsedInTemplateInstantiation.empty()) ? mTypesUsedInTemplateInstantiation[0].token() : nullptr;
-        unsigned int indentlevel2 = 0;  // indentlevel for tokgt
-        while (tok2 != endToken && (indentlevel2 > 0 || tok2->str() != ">")) {
-            if (tok2->str() == "<" && (tok2->strAt(1) == ">" || templateParameters(tok2)))
-                ++indentlevel2;
-            else if (tok2->str() == "(")
-                ++indentlevel2;
-            else if (tok2->str() == ")")
-                --indentlevel2;
-            else if (indentlevel2 > 0 && Token::Match(tok2, "> [,>]"))
-                --indentlevel2;
-            else if (indentlevel2 == 0) {
-                if (tok2->str() != ",") {
-                    if (!typetok ||
-                        tok2->isUnsigned() != typetok->isUnsigned() ||
-                        tok2->isSigned() != typetok->isSigned() ||
-                        tok2->isLong() != typetok->isLong()) {
-                        break;
-                    }
-
-                    typetok = typetok->next();
-                } else {
-                    if (typeCountInInstantiation < mTypesUsedInTemplateInstantiation.size())
-                        typetok = mTypesUsedInTemplateInstantiation[typeCountInInstantiation++].token();
-                    else
-                        typetok = nullptr;
-                }
-            }
-            tok2 = tok2->next();
-        }
+        Token *tok2 = nameTok->next()->findClosingBracket();
 
         if (!tok2)
             break;
 
+        const Token * const nameTok1 = nameTok;
+        nameTok->str(newName);
+
         // matching template usage => replace tokens..
         // Foo < int >  =>  Foo<int>
-        if (tok2->str() == ">" && typeCountInInstantiation == mTypesUsedInTemplateInstantiation.size()) {
-            const Token * const nameTok1 = nameTok;
-            nameTok->str(newName);
-
-            for (Token *tok = nameTok1->next(); tok != tok2; tok = tok->next()) {
-                if (tok->isName() && !tok->templateSimplifierPointers().empty()) {
-                    std::list<TokenAndName>::iterator ti;
-                    for (ti = mTemplateInstantiations.begin(); ti != mTemplateInstantiations.end();) {
-                        if (ti->token() == tok) {
-                            mTemplateInstantiations.erase(ti++);
-                            break;
-                        } else {
-                            ++ti;
-                        }
+        for (const Token *tok = nameTok1->next(); tok != tok2; tok = tok->next()) {
+            if (tok->isName() && tok->templateSimplifierPointers() && !tok->templateSimplifierPointers()->empty()) {
+                for (auto ti = mTemplateInstantiations.cbegin(); ti != mTemplateInstantiations.cend();) {
+                    if (ti->token() == tok) {
+                        mTemplateInstantiations.erase(ti);
+                        break;
                     }
+                    ++ti;
                 }
             }
-            // Fix crash in #9007
-            if (Token::simpleMatch(nameTok->previous(), ">"))
-                mTemplateNamePos.erase(nameTok->previous());
-            removeTokens.emplace_back(nameTok, tok2->next());
         }
+        // Fix crash in #9007
+        if (Token::simpleMatch(nameTok->previous(), ">"))
+            mTemplateNamePos.erase(nameTok->previous());
+        removeTokens.emplace_back(nameTok, tok2->next());
 
         nameTok = tok2;
     }
@@ -3186,38 +3493,44 @@ static bool specMatch(
     if (decl.isPartialSpecialization() || decl.isSpecialization() || decl.isAlias() || decl.isFriend())
         return false;
 
-    return spec.isSameFamily(decl);
+    if (!spec.isSameFamily(decl))
+        return false;
+
+    // make sure the scopes and names match
+    if (spec.fullName() == decl.fullName()) {
+        if (spec.isFunction()) {
+            std::vector<const Token*> specArgs;
+            std::vector<const Token*> declArgs;
+            getFunctionArguments(spec.nameToken(), specArgs);
+            getFunctionArguments(decl.nameToken(), declArgs);
+
+            if (specArgs.size() == declArgs.size()) {
+                // @todo make sure function parameters also match
+                return true;
+            }
+        } else
+            return true;
+    }
+
+    return false;
 }
 
 void TemplateSimplifier::getSpecializations()
 {
     // try to locate a matching declaration for each user defined specialization
-    for (auto & spec : mTemplateDeclarations) {
+    for (const auto& spec : mTemplateDeclarations) {
         if (spec.isSpecialization()) {
-            bool found = false;
-            for (auto & decl : mTemplateDeclarations) {
-                if (!specMatch(spec, decl))
-                    continue;
-
-                // make sure the scopes and names match
-                if (spec.fullName() == decl.fullName()) {
-                    // @todo make sure function parameters also match
-                    mTemplateSpecializationMap[spec.token()] = decl.token();
-                    found = true;
-                }
-            }
-
-            if (!found) {
-                for (auto & decl : mTemplateForwardDeclarations) {
-                    if (!specMatch(spec, decl))
-                        continue;
-
-                    // make sure the scopes and names match
-                    if (spec.fullName() == decl.fullName()) {
-                        // @todo make sure function parameters also match
-                        mTemplateSpecializationMap[spec.token()] = decl.token();
-                    }
-                }
+            auto it = std::find_if(mTemplateDeclarations.cbegin(), mTemplateDeclarations.cend(), [&](const TokenAndName& decl) {
+                return specMatch(spec, decl);
+            });
+            if (it != mTemplateDeclarations.cend())
+                mTemplateSpecializationMap[spec.token()] = it->token();
+            else {
+                it = std::find_if(mTemplateForwardDeclarations.cbegin(), mTemplateForwardDeclarations.cend(), [&](const TokenAndName& decl) {
+                    return specMatch(spec, decl);
+                });
+                if (it != mTemplateForwardDeclarations.cend())
+                    mTemplateSpecializationMap[spec.token()] = it->token();
             }
         }
     }
@@ -3226,32 +3539,19 @@ void TemplateSimplifier::getSpecializations()
 void TemplateSimplifier::getPartialSpecializations()
 {
     // try to locate a matching declaration for each user defined partial specialization
-    for (auto & spec : mTemplateDeclarations) {
+    for (const auto& spec : mTemplateDeclarations) {
         if (spec.isPartialSpecialization()) {
-            bool found = false;
-            for (auto & decl : mTemplateDeclarations) {
-                if (!specMatch(spec, decl))
-                    continue;
-
-                // make sure the scopes and names match
-                if (spec.fullName() == decl.fullName()) {
-                    // @todo make sure function parameters also match
-                    mTemplatePartialSpecializationMap[spec.token()] = decl.token();
-                    found = true;
-                }
-            }
-
-            if (!found) {
-                for (auto & decl : mTemplateForwardDeclarations) {
-                    if (!specMatch(spec, decl))
-                        continue;
-
-                    // make sure the scopes and names match
-                    if (spec.fullName() == decl.fullName()) {
-                        // @todo make sure function parameters also match
-                        mTemplatePartialSpecializationMap[spec.token()] = decl.token();
-                    }
-                }
+            auto it = std::find_if(mTemplateDeclarations.cbegin(), mTemplateDeclarations.cend(), [&](const TokenAndName& decl) {
+                return specMatch(spec, decl);
+            });
+            if (it != mTemplateDeclarations.cend())
+                mTemplatePartialSpecializationMap[spec.token()] = it->token();
+            else {
+                it = std::find_if(mTemplateForwardDeclarations.cbegin(), mTemplateForwardDeclarations.cend(), [&](const TokenAndName& decl) {
+                    return specMatch(spec, decl);
+                });
+                if (it != mTemplateForwardDeclarations.cend())
+                    mTemplatePartialSpecializationMap[spec.token()] = it->token();
             }
         }
     }
@@ -3298,7 +3598,6 @@ void TemplateSimplifier::fixForwardDeclaredDefaultArgumentValues()
                             }
                             if (end)
                                 TokenList::copyTokens(const_cast<Token *>(params2[k]), params1[k]->next(), end->previous());
-                            break;
                         }
                     }
 
@@ -3359,6 +3658,12 @@ void TemplateSimplifier::printOut(const TokenAndName &tokenAndName, const std::s
             const Token *start = tokenAndName.token()->next();
             std::cout << indent << "type: ";
             while (start && start != end) {
+                if (start->isUnsigned())
+                    std::cout << "unsigned";
+                else if (start->isSigned())
+                    std::cout << "signed";
+                if (start->isLong())
+                    std::cout << "long";
                 std::cout << start->str();
                 start = start->next();
             }
@@ -3493,9 +3798,7 @@ void TemplateSimplifier::printOut(const std::string & text) const
     }
 }
 
-void TemplateSimplifier::simplifyTemplates(
-    const std::time_t maxtime,
-    bool &codeWithTemplates)
+void TemplateSimplifier::simplifyTemplates(const std::time_t maxtime)
 {
     // convert "sizeof ..." to "sizeof..."
     for (Token *tok = mTokenList.front(); tok; tok = tok->next()) {
@@ -3517,15 +3820,37 @@ void TemplateSimplifier::simplifyTemplates(
         }
     }
 
-    mTokenizer->calculateScopes();
+    if (mSettings.standards.cpp >= Standards::CPP20) {
+        // Remove concepts/requires
+        // TODO concepts are not removed yet
+        for (Token *tok = mTokenList.front(); tok; tok = tok->next()) {
+            if (!Token::Match(tok, ")|>|>> requires %name%|("))
+                continue;
+            const Token* end = skipRequires(tok->next());
+            if (end)
+                Token::eraseTokens(tok, end);
+        }
+
+        // explicit(bool)
+        for (Token *tok = mTokenList.front(); tok; tok = tok->next()) {
+            if (Token::simpleMatch(tok, "explicit (")) {
+                const bool isFalse = Token::simpleMatch(tok->tokAt(2), "false )");
+                Token::eraseTokens(tok, tok->linkAt(1)->next());
+                if (isFalse)
+                    tok->deleteThis();
+            }
+        }
+    }
+
+    mTokenizer.calculateScopes();
 
     unsigned int passCount = 0;
-    const unsigned int passCountMax = 10;
+    constexpr unsigned int passCountMax = 10;
     for (; passCount < passCountMax; ++passCount) {
         if (passCount) {
             // it may take more than one pass to simplify type aliases
             bool usingChanged = false;
-            while (mTokenizer->simplifyUsing())
+            while (mTokenizer.simplifyUsing())
                 usingChanged = true;
 
             if (!usingChanged && !mChanged)
@@ -3543,18 +3868,25 @@ void TemplateSimplifier::simplifyTemplates(
             mTemplateNamePos.clear();
         }
 
-        bool hasTemplates = getTemplateDeclarations();
+        getTemplateDeclarations();
 
-        if (passCount == 0)
-            codeWithTemplates = hasTemplates;
+        if (passCount == 0) {
+            mDump.clear();
+            for (const TokenAndName& t: mTemplateDeclarations)
+                mDump += t.dump(mTokenizer.list.getFiles());
+            for (const TokenAndName& t: mTemplateForwardDeclarations)
+                mDump += t.dump(mTokenizer.list.getFiles());
+            if (!mDump.empty())
+                mDump = "  <TemplateSimplifier>\n" + mDump + "  </TemplateSimplifier>\n";
+        }
 
         // Make sure there is something to simplify.
         if (mTemplateDeclarations.empty() && mTemplateForwardDeclarations.empty())
             return;
 
-        if (passCount != 0 && mSettings->debugtemplate && mSettings->debugnormal) {
+        if (mSettings.debugtemplate && mSettings.debugnormal) {
             std::string title("Template Simplifier pass " + std::to_string(passCount + 1));
-            mTokenList.front()->printOut(title.c_str(), mTokenList.getFiles());
+            mTokenList.front()->printOut(std::cout, false, title.c_str(), mTokenList.getFiles());
         }
 
         // Copy default argument values from forward declaration to declaration
@@ -3574,18 +3906,69 @@ void TemplateSimplifier::simplifyTemplates(
 
         simplifyTemplateAliases();
 
-        if (mSettings->debugtemplate)
+        if (mSettings.debugtemplate)
             printOut("### Template Simplifier pass " + std::to_string(passCount + 1) + " ###");
 
+        // Keep track of the order the names appear so sort can preserve that order
+        std::unordered_map<std::string, int> nameOrdinal;
+        int ordinal = 0;
+        for (const auto& decl : mTemplateDeclarations) {
+            nameOrdinal.emplace(decl.fullName(), ordinal++);
+        }
+
+        auto score = [&](const Token* arg) {
+            int i = 0;
+            for (const Token* tok = arg; tok; tok = tok->next()) {
+                if (tok->str() == ",")
+                    return i;
+                if (tok->link() && Token::Match(tok, "(|{|["))
+                    tok = tok->link();
+                else if (tok->str() == "<") {
+                    const Token* temp = tok->findClosingBracket();
+                    if (temp)
+                        tok = temp;
+                } else if (Token::Match(tok, ")|;"))
+                    return i;
+                else if (Token::simpleMatch(tok, "const"))
+                    i--;
+            }
+            return 0;
+        };
+        // Sort so const parameters come first in the list
+        mTemplateDeclarations.sort([&](const TokenAndName& x, const TokenAndName& y) {
+            if (x.fullName() != y.fullName())
+                return nameOrdinal.at(x.fullName()) < nameOrdinal.at(y.fullName());
+            if (x.isFunction() && y.isFunction()) {
+                std::vector<const Token*> xargs;
+                getFunctionArguments(x.nameToken(), xargs);
+                std::vector<const Token*> yargs;
+                getFunctionArguments(y.nameToken(), yargs);
+                if (xargs.size() != yargs.size())
+                    return xargs.size() < yargs.size();
+                if (isConstMethod(x.nameToken()) != isConstMethod(y.nameToken()))
+                    return isConstMethod(x.nameToken());
+                return std::lexicographical_compare(xargs.begin(),
+                                                    xargs.end(),
+                                                    yargs.begin(),
+                                                    yargs.end(),
+                                                    [&](const Token* xarg, const Token* yarg) {
+                    if (xarg != yarg)
+                        return score(xarg) < score(yarg);
+                    return false;
+                });
+            }
+            return false;
+        });
+
         std::set<std::string> expandedtemplates;
 
-        for (std::list<TokenAndName>::reverse_iterator iter1 = mTemplateDeclarations.rbegin(); iter1 != mTemplateDeclarations.rend(); ++iter1) {
+        for (auto iter1 = mTemplateDeclarations.crbegin(); iter1 != mTemplateDeclarations.crend(); ++iter1) {
             if (iter1->isAlias() || iter1->isFriend())
                 continue;
 
             // get specializations..
             std::list<const Token *> specializations;
-            for (std::list<TokenAndName>::const_iterator iter2 = mTemplateDeclarations.begin(); iter2 != mTemplateDeclarations.end(); ++iter2) {
+            for (auto iter2 = mTemplateDeclarations.cbegin(); iter2 != mTemplateDeclarations.cend(); ++iter2) {
                 if (iter2->isAlias() || iter2->isFriend())
                     continue;
 
@@ -3594,20 +3977,20 @@ void TemplateSimplifier::simplifyTemplates(
             }
 
             const bool instantiated = simplifyTemplateInstantiations(
-                                          *iter1,
-                                          specializations,
-                                          maxtime,
-                                          expandedtemplates);
-            if (instantiated)
+                *iter1,
+                specializations,
+                maxtime,
+                expandedtemplates);
+            if (instantiated) {
                 mInstantiatedTemplates.push_back(*iter1);
+                mTemplateNamePos.clear(); // positions might be invalid after instantiations
+            }
         }
 
-        for (std::list<TokenAndName>::const_iterator it = mInstantiatedTemplates.begin(); it != mInstantiatedTemplates.end(); ++it) {
-            std::list<TokenAndName>::iterator decl;
-            for (decl = mTemplateDeclarations.begin(); decl != mTemplateDeclarations.end(); ++decl) {
-                if (decl->token() == it->token())
-                    break;
-            }
+        for (auto it = mInstantiatedTemplates.cbegin(); it != mInstantiatedTemplates.cend(); ++it) {
+            auto decl = std::find_if(mTemplateDeclarations.begin(), mTemplateDeclarations.end(), [&it](const TokenAndName& decl) {
+                return decl.token() == it->token();
+            });
             if (decl != mTemplateDeclarations.end()) {
                 if (it->isSpecialization()) {
                     // delete the "template < >"
@@ -3618,8 +4001,8 @@ void TemplateSimplifier::simplifyTemplates(
                     // remove forward declaration if found
                     auto it1 = mTemplateForwardDeclarationsMap.find(it->token());
                     if (it1 != mTemplateForwardDeclarationsMap.end())
-                        removeTemplate(it1->second);
-                    removeTemplate(it->token());
+                        removeTemplate(it1->second, &mTemplateForwardDeclarationsMap);
+                    removeTemplate(it->token(), &mTemplateForwardDeclarationsMap);
                 }
                 mTemplateDeclarations.erase(decl);
             }
@@ -3627,19 +4010,28 @@ void TemplateSimplifier::simplifyTemplates(
 
         // remove out of line member functions
         while (!mMemberFunctionsToDelete.empty()) {
-            const std::list<TokenAndName>::iterator it = std::find_if(mTemplateDeclarations.begin(),
-                    mTemplateDeclarations.end(),
-                    FindToken(mMemberFunctionsToDelete.begin()->token()));
+            const auto it = std::find_if(mTemplateDeclarations.begin(),
+                                         mTemplateDeclarations.end(),
+                                         FindToken(mMemberFunctionsToDelete.cbegin()->token()));
             // multiple functions can share the same declaration so make sure it hasn't already been deleted
             if (it != mTemplateDeclarations.end()) {
                 removeTemplate(it->token());
                 mTemplateDeclarations.erase(it);
+            } else {
+                const auto it1 = std::find_if(mTemplateForwardDeclarations.begin(),
+                                              mTemplateForwardDeclarations.end(),
+                                              FindToken(mMemberFunctionsToDelete.cbegin()->token()));
+                // multiple functions can share the same declaration so make sure it hasn't already been deleted
+                if (it1 != mTemplateForwardDeclarations.end()) {
+                    removeTemplate(it1->token());
+                    mTemplateForwardDeclarations.erase(it1);
+                }
             }
             mMemberFunctionsToDelete.erase(mMemberFunctionsToDelete.begin());
         }
 
         // remove explicit instantiations
-        for (TokenAndName & j : mExplicitInstantiationsToDelete) {
+        for (const TokenAndName& j : mExplicitInstantiationsToDelete) {
             Token * start = j.token();
             if (start) {
                 Token * end = start->next();
@@ -3655,15 +4047,57 @@ void TemplateSimplifier::simplifyTemplates(
     }
 
     if (passCount == passCountMax) {
-        if (mSettings->debugwarnings) {
+        if (mSettings.debugwarnings) {
             const std::list<const Token*> locationList(1, mTokenList.front());
-            const ErrorLogger::ErrorMessage errmsg(locationList, &mTokenizer->list,
-                                                   Severity::debug,
-                                                   "debug",
-                                                   "TemplateSimplifier: pass count limit hit before simplifications were finished.",
-                                                   false);
-            if (mErrorLogger)
-                mErrorLogger->reportErr(errmsg);
+            const ErrorMessage errmsg(locationList, &mTokenizer.list,
+                                      Severity::debug,
+                                      "debug",
+                                      "TemplateSimplifier: pass count limit hit before simplifications were finished.",
+                                      Certainty::normal);
+            mErrorLogger.reportErr(errmsg);
+        }
+    }
+
+    // Tweak uninstantiated C++17 fold expressions (... && args)
+    if (mSettings.standards.cpp >= Standards::CPP17) {
+        bool simplify = false;
+        for (Token *tok = mTokenList.front(); tok; tok = tok->next()) {
+            if (tok->str() == "template")
+                simplify = false;
+            if (tok->str() == "{")
+                simplify = true;
+            if (!simplify || tok->str() != "(")
+                continue;
+            const Token *op = nullptr;
+            const Token *args = nullptr;
+            if (Token::Match(tok, "( ... %op%")) {
+                op = tok->tokAt(2);
+                args = tok->link()->previous();
+            } else if (Token::Match(tok, "( %name% %op% ...") && !Token::simpleMatch(tok->previous(), "] (")) {
+                op = tok->tokAt(2);
+                args = tok->link()->previous()->isName() ? nullptr : tok->next();
+            } else if (Token::Match(tok->link()->tokAt(-3), "%op% ... )")) {
+                op = tok->link()->tokAt(-2);
+                args = tok->next();
+            } else if (Token::Match(tok->link()->tokAt(-3), "... %op% %name% )")) {
+                op = tok->link()->tokAt(-2);
+                args = tok->next()->isName() ? nullptr : tok->link()->previous();
+            } else {
+                continue;
+            }
+
+            const std::string strop = op->str();
+            const std::string strargs = (args && args->isName()) ? args->str() : "";
+
+            Token::eraseTokens(tok, tok->link());
+            tok->insertToken(")");
+            if (!strargs.empty()) {
+                tok->insertToken("...");
+                tok->insertToken(strargs);
+            }
+            tok->insertToken("(");
+            Token::createMutualLinks(tok->next(), tok->link()->previous());
+            tok->insertToken("__cppcheck_fold_" + strop + "__");
         }
     }
 }
diff --git a/lib/templatesimplifier.h b/lib/templatesimplifier.h
index 2508340d6d7..f6e507459a9 100644
--- a/lib/templatesimplifier.h
+++ b/lib/templatesimplifier.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,6 +24,7 @@
 
 #include "config.h"
 
+#include <cstdint>
 #include <ctime>
 #include <list>
 #include <map>
@@ -37,6 +38,7 @@ class Settings;
 class Token;
 class Tokenizer;
 class TokenList;
+struct newInstantiation;
 
 /// @addtogroup Core
 /// @{
@@ -44,15 +46,15 @@ class TokenList;
 /** @brief Simplify templates from the preprocessed and partially simplified code. */
 class CPPCHECKLIB TemplateSimplifier {
 public:
-    explicit TemplateSimplifier(Tokenizer *tokenizer);
-    ~TemplateSimplifier();
+    explicit TemplateSimplifier(Tokenizer &tokenizer);
 
-    /**
-     * Used after simplifyTemplates to perform a little cleanup.
-     * Sometimes the simplifyTemplates isn't fully successful and then
-     * there are function calls etc with "wrong" syntax.
-     */
-    void cleanupAfterSimplify();
+    const std::string& dump() const {
+        return mDump;
+    }
+
+    const std::map<std::string, std::set<std::string>>& getUsedVariables() const {
+        return mUsedVariables;
+    }
 
     /**
      */
@@ -78,7 +80,7 @@ class CPPCHECKLIB TemplateSimplifier {
         const Token *mParamEnd;
         unsigned int mFlags;
 
-        enum {
+        enum : std::uint16_t {
             fIsClass                 = (1 << 0), // class template
             fIsFunction              = (1 << 1), // function template
             fIsVariable              = (1 << 2), // variable template
@@ -140,18 +142,19 @@ class CPPCHECKLIB TemplateSimplifier {
     public:
         /**
          * Constructor used for instantiations.
-         * \param tok template instantiation name token "name<...>"
-         * \param s full qualification of template(scope)
+         * \param token template instantiation name token "name<...>"
+         * \param scope full qualification of template(scope)
          */
-        TokenAndName(Token *token, const std::string &scope);
+        TokenAndName(Token *token, std::string scope);
         /**
          * Constructor used for declarations.
-         * \param tok template declaration token "template < ... >"
-         * \param s full qualification of template(scope)
-         * \param nt template name token "template < ... > class name"
-         * \param pe template parameter end token ">"
+         * @param token template declaration token "template < ... >"
+         * @param scope full qualification of template(scope)
+         * @param nameToken template name token "template < ... > class name"
+         * @param paramEnd template parameter end token ">"
+         * @throws InternalError thrown on template issues
          */
-        TokenAndName(Token *token, const std::string &scope, const Token *nameToken, const Token *paramEnd);
+        TokenAndName(Token *token, std::string scope, const Token *nameToken, const Token *paramEnd);
         TokenAndName(const TokenAndName& other);
         ~TokenAndName();
 
@@ -160,6 +163,9 @@ class CPPCHECKLIB TemplateSimplifier {
                    mNameToken == rhs.mNameToken && mParamEnd == rhs.mParamEnd && mFlags == rhs.mFlags;
         }
 
+        std::string dump(const std::vector<std::string>& fileNames) const;
+
+        // TODO: do not return non-const pointer from const object
         Token * token() const {
             return mToken;
         }
@@ -175,7 +181,7 @@ class CPPCHECKLIB TemplateSimplifier {
         const std::string & fullName() const {
             return mFullName;
         }
-        const Token * nameToken() const  {
+        const Token * nameToken() const {
             return mNameToken;
         }
         const Token * paramEnd() const {
@@ -247,7 +253,7 @@ class CPPCHECKLIB TemplateSimplifier {
         bool isSameFamily(const TemplateSimplifier::TokenAndName &decl) const {
             // Make sure a family flag is set and matches.
             // This works because at most only one flag will be set.
-            return (mFlags & fFamilyMask) & (decl.mFlags & (fFamilyMask));
+            return ((mFlags & fFamilyMask) && (decl.mFlags & fFamilyMask));
         }
     };
 
@@ -259,15 +265,18 @@ class CPPCHECKLIB TemplateSimplifier {
     static Token *findTemplateDeclarationEnd(Token *tok);
     static const Token *findTemplateDeclarationEnd(const Token *tok);
 
+protected:
     /**
      * Match template declaration/instantiation
      * @param instance template instantiation
      * @param numberOfArguments number of template arguments
+     * @param variadic last template argument is variadic
      * @param patternAfter pattern that must match the tokens after the ">"
      * @return match => true
      */
-    static bool instantiateMatch(const Token *instance, const std::size_t numberOfArguments, const char patternAfter[]);
+    static bool instantiateMatch(const Token *instance, std::size_t numberOfArguments, bool variadic, const char patternAfter[]);
 
+public: // TODO: only needs to be public for tests
     /**
      * Match template declaration/instantiation
      * @param tok The ">" token e.g. before "class"
@@ -276,6 +285,7 @@ class CPPCHECKLIB TemplateSimplifier {
      */
     int getTemplateNamePosition(const Token *tok);
 
+private:
     /**
      * Get class template name position
      * @param tok The ">" token e.g. before "class"
@@ -300,43 +310,37 @@ class CPPCHECKLIB TemplateSimplifier {
      * */
     static bool getTemplateNamePositionTemplateVariable(const Token *tok, int &namepos);
 
+public:
     /**
      * Simplify templates
      * @param maxtime time when the simplification should be stopped
-     * @param codeWithTemplates output parameter that is set if code contains templates
      */
-    void simplifyTemplates(
-        const std::time_t maxtime,
-        bool &codeWithTemplates);
+    void simplifyTemplates(std::time_t maxtime);
 
     /**
      * Simplify constant calculations such as "1+2" => "3"
      * @param tok start token
      * @return true if modifications to token-list are done.
      *         false if no modifications are done.
+     * @throws InternalError thrown on division by zero in template instantiation
      */
     static bool simplifyNumericCalculations(Token *tok, bool isTemplate = true);
 
+private:
     /**
      * Simplify constant calculations such as "1+2" => "3".
      * This also performs simple cleanup of parentheses etc.
      * @return true if modifications to token-list are done.
      *         false if no modifications are done.
      */
-    bool simplifyCalculations(Token* frontToken = nullptr, Token *backToken = nullptr, bool isTemplate = true);
+    bool simplifyCalculations(Token* frontToken = nullptr, const Token *backToken = nullptr, bool isTemplate = true);
 
     /** Simplify template instantiation arguments.
      * @param start first token of arguments
      * @param end token following last argument token
      */
-    void simplifyTemplateArgs(Token *start, Token *end);
+    void simplifyTemplateArgs(Token *start, const Token *end, std::vector<newInstantiation>* newInst = nullptr);
 
-    /** Fix angle brackets.
-     * foo < bar < >> => foo < bar < > >
-     */
-    void fixAngleBrackets();
-
-private:
     /**
      * Get template declarations
      * @return true if code has templates.
@@ -400,7 +404,7 @@ class CPPCHECKLIB TemplateSimplifier {
     bool simplifyTemplateInstantiations(
         const TokenAndName &templateDeclaration,
         const std::list<const Token *> &specializations,
-        const std::time_t maxtime,
+        std::time_t maxtime,
         std::set<std::string> &expandedtemplates);
 
     /**
@@ -443,26 +447,28 @@ class CPPCHECKLIB TemplateSimplifier {
                               const std::list<std::string> &typeStringsUsedInTemplateInstantiation,
                               const std::string &newName);
 
+protected:
     /**
      * @brief TemplateParametersInDeclaration
      * @param tok  template < typename T, typename S >
      *                        ^ tok
      * @param typeParametersInDeclaration  template < typename T, typename S >
      *                                                         ^ [0]       ^ [1]
-     * @return  template < typename T, typename S >
-     *                                              ^ return
      */
-    static const Token * getTemplateParametersInDeclaration(
+    static void getTemplateParametersInDeclaration(
         const Token * tok,
         std::vector<const Token *> & typeParametersInDeclaration);
 
+private:
     /**
      * Remove a specific "template < ..." template class/function
      */
-    static bool removeTemplate(Token *tok);
+    static bool removeTemplate(Token *tok, std::map<Token*, Token*>* forwardDecls = nullptr);
 
-    /** Syntax error */
-    static void syntaxError(const Token *tok);
+    /** Syntax error
+     * @throws InternalError thrown unconditionally
+     */
+    NORETURN static void syntaxError(const Token *tok);
 
     static bool matchSpecialization(
         const Token *templateDeclarationNameToken,
@@ -498,11 +504,11 @@ class CPPCHECKLIB TemplateSimplifier {
         const std::string &indent = "    ") const;
     void printOut(const std::string &text = "") const;
 
-    Tokenizer *mTokenizer;
+    Tokenizer &mTokenizer;
     TokenList &mTokenList;
-    const Settings *mSettings;
-    ErrorLogger *mErrorLogger;
-    bool mChanged;
+    const Settings &mSettings;
+    ErrorLogger &mErrorLogger;
+    bool mChanged{};
 
     std::list<TokenAndName> mTemplateDeclarations;
     std::list<TokenAndName> mTemplateForwardDeclarations;
@@ -515,6 +521,9 @@ class CPPCHECKLIB TemplateSimplifier {
     std::vector<TokenAndName> mExplicitInstantiationsToDelete;
     std::vector<TokenAndName> mTypesUsedInTemplateInstantiation;
     std::unordered_map<const Token*, int> mTemplateNamePos;
+    std::string mDump;
+
+    std::map<std::string, std::set<std::string>> mUsedVariables;
 };
 
 /// @}
diff --git a/lib/timer.cpp b/lib/timer.cpp
index 11d3b329562..a135ad13233 100644
--- a/lib/timer.cpp
+++ b/lib/timer.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,88 +19,126 @@
 #include "timer.h"
 
 #include <algorithm>
+#include <cstddef>
 #include <iostream>
 #include <utility>
 #include <vector>
-/*
-    TODO:
-    - rename "file" to "single"
-    - synchronise map access in multithreaded mode or disable timing
-    - add unit tests
-        - for --showtime (needs input file)
-        - for Timer* classes
-*/
 
 namespace {
-    typedef std::pair<std::string, struct TimerResultsData> dataElementType;
+    using dataElementType = std::pair<std::string, TimerResultsData>;
     bool more_second_sec(const dataElementType& lhs, const dataElementType& rhs)
     {
-        return lhs.second.seconds() > rhs.second.seconds();
+        return lhs.second.getSeconds() > rhs.second.getSeconds();
     }
+
+    // TODO: remove and print through (synchronized) ErrorLogger instead
+    std::mutex stdCoutLock;
 }
 
-void TimerResults::ShowResults(SHOWTIME_MODES mode) const
+// TODO: this does not include any file context when SHOWTIME_FILE thus rendering it useless - should we include the logging with the progress logging?
+// that could also get rid of the broader locking
+void TimerResults::showResults(ShowTime mode) const
 {
-    if (mode == SHOWTIME_MODES::SHOWTIME_NONE)
+    if (mode == ShowTime::NONE || mode == ShowTime::FILE_TOTAL)
         return;
+    std::vector<dataElementType> data;
 
-    std::cout << std::endl;
-    TimerResultsData overallData;
+    {
+        std::lock_guard<std::mutex> l(mResultsSync);
 
-    std::vector<dataElementType> data(mResults.begin(), mResults.end());
+        data.reserve(mResults.size());
+        data.insert(data.begin(), mResults.cbegin(), mResults.cend());
+    }
     std::sort(data.begin(), data.end(), more_second_sec);
 
+    // lock the whole logging operation to avoid multiple threads printing their results at the same time
+    std::lock_guard<std::mutex> l(stdCoutLock);
+
+    std::cout << std::endl;
+
     size_t ordinal = 1; // maybe it would be nice to have an ordinal in output later!
-    for (std::vector<dataElementType>::const_iterator iter=data.begin() ; iter!=data.end(); ++iter) {
-        const double sec = iter->second.seconds();
-        const double secAverage = sec / (double)(iter->second.mNumberOfResults);
-        overallData.mClocks += iter->second.mClocks;
-        if ((mode != SHOWTIME_MODES::SHOWTIME_TOP5) || (ordinal<=5)) {
+    for (auto iter=data.cbegin(); iter!=data.cend(); ++iter) {
+        const double sec = iter->second.getSeconds().count();
+        const double secAverage = sec / static_cast<double>(iter->second.mNumberOfResults);
+        if ((mode != ShowTime::TOP5_FILE && mode != ShowTime::TOP5_SUMMARY) || (ordinal<=5)) {
             std::cout << iter->first << ": " << sec << "s (avg. " << secAverage << "s - " << iter->second.mNumberOfResults  << " result(s))" << std::endl;
         }
         ++ordinal;
     }
-
-    const double secOverall = overallData.seconds();
-    std::cout << "Overall time: " << secOverall << "s" << std::endl;
 }
 
-void TimerResults::AddResults(const std::string& str, std::clock_t clocks)
+void TimerResults::addResults(const std::string& str, std::chrono::milliseconds duration)
 {
-    mResults[str].mClocks += clocks;
+    std::lock_guard<std::mutex> l(mResultsSync);
+
+    mResults[str].mDuration += duration;
     mResults[str].mNumberOfResults++;
 }
 
-Timer::Timer(const std::string& str, SHOWTIME_MODES showtimeMode, TimerResultsIntf* timerResults)
-    : mStr(str)
-    , mTimerResults(timerResults)
-    , mStart(0)
-    , mShowTimeMode(showtimeMode)
-    , mStopped(false)
+void TimerResults::reset()
 {
-    if (showtimeMode != SHOWTIME_MODES::SHOWTIME_NONE)
-        mStart = std::clock();
+    std::lock_guard<std::mutex> l(mResultsSync);
+    mResults.clear();
 }
 
+Timer::Timer(std::string str, ShowTime showtimeMode, TimerResultsIntf* timerResults, Type type)
+    : mName(std::move(str))
+    , mMode(showtimeMode)
+    , mType(type)
+    , mStart(Clock::now())
+    , mResults(timerResults)
+{}
+
 Timer::~Timer()
 {
-    Stop();
+    stop();
 }
 
-void Timer::Stop()
+void Timer::stop()
 {
-    if ((mShowTimeMode != SHOWTIME_MODES::SHOWTIME_NONE) && !mStopped) {
-        const std::clock_t end = std::clock();
-        const std::clock_t diff = end - mStart;
-
-        if (mShowTimeMode == SHOWTIME_MODES::SHOWTIME_FILE) {
-            const double sec = (double)diff / CLOCKS_PER_SEC;
-            std::cout << mStr << ": " << sec << "s" << std::endl;
+    if (mMode == ShowTime::NONE)
+        return;
+    if (mType == Type::OVERALL && mMode != ShowTime::TOP5_SUMMARY && mMode != ShowTime::SUMMARY) {
+        mMode = ShowTime::NONE;
+        return;
+    }
+    if (mType == Type::FILE && mMode != ShowTime::TOP5_FILE && mMode != ShowTime::FILE && mMode != ShowTime::FILE_TOTAL) {
+        mMode = ShowTime::NONE;
+        return;
+    }
+    if (mStart != TimePoint{}) {
+        auto diff = std::chrono::duration_cast<std::chrono::milliseconds>(Clock::now() - mStart);
+        if (!mResults) {
+            std::lock_guard<std::mutex> l(stdCoutLock);
+            std::cout << (mType == Type::OVERALL ? "Overall time: " : "Check time: " + mName + ": ") << TimerResultsData::durationToString(diff) << std::endl;
         } else {
-            if (mTimerResults)
-                mTimerResults->AddResults(mStr, diff);
+            mResults->addResults(mName, diff);
         }
     }
+    mMode = ShowTime::NONE; // prevent multiple stops
+}
+
+std::string TimerResultsData::durationToString(std::chrono::milliseconds duration)
+{
+    // Extract hours
+    auto hours = std::chrono::duration_cast<std::chrono::hours>(duration);
+    duration -= hours; // Subtract the extracted hours
+
+    // Extract minutes
+    auto minutes = std::chrono::duration_cast<std::chrono::minutes>(duration);
+    duration -= minutes; // Subtract the extracted minutes
+
+    // Extract seconds
+    std::chrono::duration<double> seconds = std::chrono::duration_cast<std::chrono::duration<double>>(duration);
 
-    mStopped = true;
+    std::string ellapsedTime;
+    if (hours.count() > 0)
+        ellapsedTime += std::to_string(hours.count()) + "h ";
+    if (minutes.count() > 0)
+        ellapsedTime += std::to_string(minutes.count()) + "m ";
+    std::string secondsStr{std::to_string(seconds.count())};
+    auto pos = secondsStr.find_first_of('.');
+    if (pos != std::string::npos && (pos + 4) < secondsStr.size())
+        secondsStr.resize(pos + 4); // keep three decimal
+    return (ellapsedTime + secondsStr + "s");
 }
diff --git a/lib/timer.h b/lib/timer.h
index 7120e6a5cd1..043e1c40b14 100644
--- a/lib/timer.h
+++ b/lib/timer.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,66 +22,86 @@
 
 #include "config.h"
 
-#include <ctime>
+#include <chrono>
+#include <cstdint>
 #include <map>
+#include <mutex>
 #include <string>
+#include <utility>
 
-enum class SHOWTIME_MODES {
-    SHOWTIME_NONE = 0,
-    SHOWTIME_FILE,
-    SHOWTIME_SUMMARY,
-    SHOWTIME_TOP5
+enum class ShowTime : std::uint8_t {
+    NONE,
+    FILE,
+    FILE_TOTAL,
+    SUMMARY,
+    TOP5_SUMMARY,
+    TOP5_FILE
 };
 
 class CPPCHECKLIB TimerResultsIntf {
 public:
-    virtual ~TimerResultsIntf() { }
+    virtual ~TimerResultsIntf() = default;
 
-    virtual void AddResults(const std::string& str, std::clock_t clocks) = 0;
+    virtual void addResults(const std::string& timerName, std::chrono::milliseconds duation) = 0;
 };
 
 struct TimerResultsData {
-    std::clock_t mClocks;
-    long mNumberOfResults;
+    std::chrono::milliseconds mDuration;
+    long mNumberOfResults{};
 
-    TimerResultsData()
-        : mClocks(0)
-        , mNumberOfResults(0) {
+    std::chrono::duration<double> getSeconds() const {
+        return std::chrono::duration_cast<std::chrono::duration<double>>(mDuration);
     }
 
-    double seconds() const {
-        const double ret = (double)((unsigned long)mClocks) / (double)CLOCKS_PER_SEC;
-        return ret;
-    }
+    static std::string durationToString(std::chrono::milliseconds duration);
 };
 
-class CPPCHECKLIB TimerResults : public TimerResultsIntf {
+class CPPCHECKLIB WARN_UNUSED TimerResults : public TimerResultsIntf {
 public:
-    TimerResults() {
-    }
+    TimerResults() = default;
+
+    void showResults(ShowTime mode) const;
+    void addResults(const std::string& str, std::chrono::milliseconds duration) override;
 
-    void ShowResults(SHOWTIME_MODES mode) const;
-    void AddResults(const std::string& str, std::clock_t clocks) OVERRIDE;
+    void reset();
 
 private:
-    std::map<std::string, struct TimerResultsData> mResults;
+    std::map<std::string, TimerResultsData> mResults;
+    mutable std::mutex mResultsSync;
 };
 
 class CPPCHECKLIB Timer {
 public:
-    Timer(const std::string& str, SHOWTIME_MODES showtimeMode, TimerResultsIntf* timerResults = nullptr);
+    using Clock = std::chrono::high_resolution_clock;
+    using TimePoint = std::chrono::time_point<Clock>;
+
+    enum class Type : std::uint8_t {
+        FILE,
+        OVERALL,
+        OTHER
+    };
+
+    Timer(std::string str, ShowTime showtimeMode, TimerResultsIntf* timerResults = nullptr, Type type = Type::OTHER);
     ~Timer();
-    void Stop();
+
+    Timer(const Timer&) = delete;
+    Timer& operator=(const Timer&) = delete;
+
+    void stop();
+
+    template<class TFunc>
+    static void run(std::string str, ShowTime showtimeMode, TimerResultsIntf* timerResults, const TFunc& f) {
+        Timer t(std::move(str), showtimeMode, timerResults);
+        f();
+    }
 
 private:
-    Timer(const Timer& other); // disallow copying
-    Timer& operator=(const Timer&); // disallow assignments
-
-    const std::string mStr;
-    TimerResultsIntf* mTimerResults;
-    std::clock_t mStart;
-    const SHOWTIME_MODES mShowTimeMode;
-    bool mStopped;
+    const std::string mName;
+    ShowTime mMode{};
+    Type mType{};
+    TimePoint mStart;
+    TimerResultsIntf* mResults{};
 };
+
 //---------------------------------------------------------------------------
 #endif // timerH
diff --git a/lib/token.cpp b/lib/token.cpp
index 1fddb3ec827..5424ac3396e 100644
--- a/lib/token.cpp
+++ b/lib/token.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,48 +19,61 @@
 #include "token.h"
 
 #include "astutils.h"
-#include "errorlogger.h"
+#include "errortypes.h"
 #include "library.h"
+#include "mathlib.h"
 #include "settings.h"
 #include "symboldatabase.h"
+#include "tokenlist.h"
 #include "utils.h"
+#include "tokenrange.h"
+#include "valueflow.h"
 
+#include <algorithm>
 #include <cassert>
 #include <cctype>
+#include <climits>
+#include <cmath>
+#include <cstdio>
 #include <cstring>
+#include <functional>
 #include <iostream>
+#include <iterator>
 #include <map>
 #include <set>
+#include <sstream>
 #include <stack>
+#include <type_traits>
+#include <unordered_set>
 #include <utility>
 
-static const std::string literal_prefix[4] = {"u8", "u", "U", "L"};
+#include <simplecpp.h>
 
-static bool isStringCharLiteral(const std::string &str, char q)
-{
+namespace {
+    struct less {
+        template<class T, class U>
+        bool operator()(const T &x, const U &y) const {
+            return x < y;
+        }
+    };
+}
 
-    if (!endsWith(str, q))
-        return false;
-    if (str[0] == q && str.length() > 1)
-        return true;
+const std::list<ValueFlow::Value> Token::mEmptyValueList;
+const std::string Token::mEmptyString;
 
-    for (const std::string & p: literal_prefix) {
-        if ((str.length() + 1) > p.length() && (str.compare(0, p.size() + 1, (p + q)) == 0))
-            return true;
-    }
-    return false;
-}
-const std::list<ValueFlow::Value> TokenImpl::mEmptyValueList;
+Token::Token(const TokenList& tokenlist, std::shared_ptr<TokensFrontBack> tokensFrontBack)
+    : mList(tokenlist)
+    , mTokensFrontBack(std::move(tokensFrontBack))
+    , mImpl(new Impl)
+    , mIsC(mList.isC())
+    , mIsCpp(mList.isCPP())
+{}
 
-Token::Token(TokensFrontBack *tokensFrontBack) :
-    mTokensFrontBack(tokensFrontBack),
-    mNext(nullptr),
-    mPrevious(nullptr),
-    mLink(nullptr),
-    mTokType(eNone),
-    mFlags(0)
+Token::Token(const Token* tok)
+    : Token(tok->mList, const_cast<Token*>(tok)->mTokensFrontBack)
 {
-    mImpl = new TokenImpl();
+    fileIndex(tok->fileIndex());
+    linenr(tok->linenr());
 }
 
 Token::~Token()
@@ -68,7 +81,18 @@ Token::~Token()
     delete mImpl;
 }
 
-static const std::set<std::string> controlFlowKeywords = {
+/*
+ * Get a TokenRange which starts at this token and contains every token following it in order up to but not including 't'
+ * e.g. for the sequence of tokens A B C D E, C.until(E) would yield the Range C D
+ * note t can be nullptr to iterate all the way to the end.
+ */
+// cppcheck-suppress unusedFunction // only used in testtokenrange.cpp
+ConstTokenRange Token::until(const Token* t) const
+{
+    return ConstTokenRange(this, t);
+}
+
+static const std::unordered_set<std::string> controlFlowKeywords = {
     "goto",
     "do",
     "if",
@@ -84,24 +108,54 @@ static const std::set<std::string> controlFlowKeywords = {
 
 void Token::update_property_info()
 {
-    setFlag(fIsControlFlowKeyword, controlFlowKeywords.find(mStr) != controlFlowKeywords.end());
+    assert(mImpl);
+
+    setFlag(fIsControlFlowKeyword, false);
+    // TODO: clear fIsLong
+    isStandardType(false);
 
     if (!mStr.empty()) {
-        if (mStr == "true" || mStr == "false")
-            tokType(eBoolean);
-        else if (isStringCharLiteral(mStr, '\"'))
+        if (mStr == "true" || mStr == "false") {
+            if (mImpl->mVarId) {
+                if (mIsCpp)
+                    throw InternalError(this, "Internal error. VarId set for bool literal.");
+                tokType(eVariable);
+            }
+            else
+                tokType(eBoolean);
+        }
+        else if (isStringLiteral(mStr)) {
             tokType(eString);
-        else if (isStringCharLiteral(mStr, '\''))
+            isLong(isPrefixStringCharLiteral(mStr, '"', "L"));
+        }
+        else if (isCharLiteral(mStr)) {
             tokType(eChar);
-        else if (std::isalpha((unsigned char)mStr[0]) || mStr[0] == '_' || mStr[0] == '$') { // Name
+            isLong(isPrefixStringCharLiteral(mStr, '\'', "L"));
+        }
+        else if (std::isalpha(static_cast<unsigned char>(mStr[0])) || mStr[0] == '_' || mStr[0] == '$') { // Name
             if (mImpl->mVarId)
                 tokType(eVariable);
-            else if (mTokType != eVariable && mTokType != eFunction && mTokType != eType && mTokType != eKeyword)
+            else if (mList.isKeyword(mStr)) {
+                tokType(eKeyword);
+                update_property_isStandardType();
+                if (mTokType != eType) // cannot be a control-flow keyword when it is a type
+                    setFlag(fIsControlFlowKeyword, controlFlowKeywords.find(mStr) != controlFlowKeywords.end());
+            }
+            else if (mStr == "asm") { // TODO: not a keyword
+                tokType(eKeyword);
+            }
+            else {
                 tokType(eName);
-        } else if (std::isdigit((unsigned char)mStr[0]) || (mStr.length() > 1 && mStr[0] == '-' && std::isdigit((unsigned char)mStr[1])))
-            tokType(eNumber);
-        else if (mStr == "=" || mStr == "<<=" || mStr == ">>=" ||
-                 (mStr.size() == 2U && mStr[1] == '=' && std::strchr("+-*/%&^|", mStr[0])))
+                // some types are not being treated as keywords
+                update_property_isStandardType();
+            }
+        } else if (simplecpp::Token::isNumberLike(mStr)) {
+            if ((MathLib::isInt(mStr) || MathLib::isFloat(mStr)) && mStr.find('_') == std::string::npos)
+                tokType(eNumber);
+            else
+                tokType(eLiteral); // assume it is a user defined literal
+        } else if (mStr == "=" || mStr == "<<=" || mStr == ">>=" ||
+                   (mStr.size() == 2U && mStr[1] == '=' && std::strchr("+-*/%&^|", mStr[0])))
             tokType(eAssignmentOp);
         else if (mStr.size() == 1 && mStr.find_first_of(",[]()?:") != std::string::npos)
             tokType(eExtendedOp);
@@ -114,14 +168,17 @@ void Token::update_property_info()
                   mStr == "||" ||
                   mStr == "!"))
             tokType(eLogicalOp);
+        // TODO: should link check only apply to < and >? Token::link() suggests so
         else if (mStr.size() <= 2 && !mLink &&
                  (mStr == "==" ||
                   mStr == "!=" ||
-                  mStr == "<"  ||
+                  mStr == "<" ||
                   mStr == "<=" ||
-                  mStr == ">"  ||
+                  mStr == ">" ||
                   mStr == ">="))
             tokType(eComparisonOp);
+        else if (mStr == "<=>")
+            tokType(eComparisonOp);
         else if (mStr.size() == 2 &&
                  (mStr == "++" ||
                   mStr == "--"))
@@ -135,75 +192,65 @@ void Token::update_property_info()
     } else {
         tokType(eNone);
     }
+    assert(!mImpl->mVarId || mTokType == eVariable);
+    // TODO: validate type for linked token?
+}
+
+static const std::unordered_set<std::string> stdTypes = { "bool"
+                                                          , "_Bool"
+                                                          , "char"
+                                                          , "double"
+                                                          , "float"
+                                                          , "int"
+                                                          , "long"
+                                                          , "short"
+                                                          , "size_t"
+                                                          , "void"
+                                                          , "wchar_t"
+                                                          , "signed"
+                                                          , "unsigned"
+};
 
-    update_property_char_string_literal();
-    update_property_isStandardType();
+bool Token::isStandardType(const std::string& str)
+{
+    return stdTypes.find(str) != stdTypes.end();
 }
 
-static const std::set<std::string> stdTypes = { "bool"
-                                                , "_Bool"
-                                                , "char"
-                                                , "double"
-                                                , "float"
-                                                , "int"
-                                                , "long"
-                                                , "short"
-                                                , "size_t"
-                                                , "void"
-                                                , "wchar_t"
-                                              };
-
 void Token::update_property_isStandardType()
 {
-    isStandardType(false);
-
-    if (mStr.size() < 3)
+    if (mStr.size() < 3 || mStr.size() > 7)
         return;
 
-    if (stdTypes.find(mStr)!=stdTypes.end()) {
+    if (isStandardType(mStr)) {
         isStandardType(true);
         tokType(eType);
     }
 }
 
-void Token::update_property_char_string_literal()
-{
-    if (!(mTokType == Token::eString || mTokType == Token::eChar)) // Token has already been updated
-        return;
-
-    for (const std::string & p : literal_prefix) {
-        if (((mTokType == Token::eString) && mStr.compare(0, p.size() + 1, p + "\"") == 0) ||
-            ((mTokType == Token::eChar) && (mStr.compare(0, p.size() +  1, p + "\'") == 0))) {
-            mStr = mStr.substr(p.size());
-            isLong(p != "u8");
-            break;
-        }
-    }
-}
-
 bool Token::isUpperCaseName() const
 {
     if (!isName())
         return false;
-    for (char i : mStr) {
-        if (std::islower(i))
-            return false;
-    }
-    return true;
+    return std::none_of(mStr.begin(), mStr.end(), [](char c) {
+        return std::islower(c);
+    });
 }
 
 void Token::concatStr(std::string const& b)
 {
-    mStr.erase(mStr.length() - 1);
-    mStr.append(b.begin() + 1, b.end());
+    mStr.pop_back();
+    mStr.append(getStringLiteral(b) + "\"");
 
+    if (isCChar() && isStringLiteral(b) && b[0] != '"') {
+        mStr.insert(0, b.substr(0, b.find('"')));
+    }
     update_property_info();
 }
 
 std::string Token::strValue() const
 {
     assert(mTokType == eString);
-    std::string ret(mStr.substr(1, mStr.length() - 2));
+    std::string ret(getStringLiteral(mStr));
     std::string::size_type pos = 0U;
     while ((pos = ret.find('\\', pos)) != std::string::npos) {
         ret.erase(pos,1U);
@@ -238,7 +285,7 @@ void Token::deleteNext(nonneg int count)
 
     if (mNext)
         mNext->previous(this);
-    else if (mTokensFrontBack)
+    else
         mTokensFrontBack->back = this;
 }
 
@@ -258,7 +305,7 @@ void Token::deletePrevious(nonneg int count)
 
     if (mPrevious)
         mPrevious->next(this);
-    else if (mTokensFrontBack)
+    else
         mTokensFrontBack->front = this;
 }
 
@@ -269,13 +316,17 @@ void Token::swapWithNext()
         std::swap(mTokType, mNext->mTokType);
         std::swap(mFlags, mNext->mFlags);
         std::swap(mImpl, mNext->mImpl);
-        for (auto templateSimplifierPointer : mImpl->mTemplateSimplifierPointers) {
-            templateSimplifierPointer->token(this);
-        }
+        if (mImpl->mTemplateSimplifierPointers)
+            // cppcheck-suppress shadowFunction - TODO: fix this
+            for (auto *templateSimplifierPointer : *mImpl->mTemplateSimplifierPointers) {
+                templateSimplifierPointer->token(this);
+            }
 
-        for (auto templateSimplifierPointer : mNext->mImpl->mTemplateSimplifierPointers) {
-            templateSimplifierPointer->token(mNext);
-        }
+        if (mNext->mImpl->mTemplateSimplifierPointers)
+            // cppcheck-suppress shadowFunction - TODO: fix this
+            for (auto *templateSimplifierPointer : *mNext->mImpl->mTemplateSimplifierPointers) {
+                templateSimplifierPointer->token(mNext);
+            }
         if (mNext->mLink)
             mNext->mLink->mLink = this;
         if (this->mLink)
@@ -292,9 +343,11 @@ void Token::takeData(Token *fromToken)
     delete mImpl;
     mImpl = fromToken->mImpl;
     fromToken->mImpl = nullptr;
-    for (auto templateSimplifierPointer : mImpl->mTemplateSimplifierPointers) {
-        templateSimplifierPointer->token(this);
-    }
+    if (mImpl->mTemplateSimplifierPointers)
+        // cppcheck-suppress shadowFunction - TODO: fix this
+        for (auto *templateSimplifierPointer : *mImpl->mTemplateSimplifierPointers) {
+            templateSimplifierPointer->token(this);
+        }
     mLink = fromToken->mLink;
     if (mLink)
         mLink->link(this);
@@ -306,18 +359,14 @@ void Token::deleteThis()
         takeData(mNext);
         mNext->link(nullptr); // mark as unlinked
         deleteNext();
-    } else if (mPrevious && mPrevious->mPrevious) { // Copy previous to this and delete previous
+    } else if (mPrevious) { // Copy previous to this and delete previous
         takeData(mPrevious);
-
-        Token* toDelete = mPrevious;
-        mPrevious = mPrevious->mPrevious;
-        mPrevious->mNext = this;
-
-        delete toDelete;
+        mPrevious->link(nullptr);
+        deletePrevious();
     } else {
         // We are the last token in the list, we can't delete
         // ourselves, so just make us empty
-        str("");
+        str(";");
     }
 }
 
@@ -340,7 +389,7 @@ void Token::replace(Token *replaceThis, Token *start, Token *end)
     start->previous(replaceThis->previous());
     end->next(replaceThis->next());
 
-    if (end->mTokensFrontBack && end->mTokensFrontBack->back == end) {
+    if (end->mTokensFrontBack->back == end) {
         while (end->next())
             end = end->next();
         end->mTokensFrontBack->back = end;
@@ -354,48 +403,20 @@ void Token::replace(Token *replaceThis, Token *start, Token *end)
     delete replaceThis;
 }
 
-const Token *Token::tokAt(int index) const
-{
-    const Token *tok = this;
-    while (index > 0 && tok) {
-        tok = tok->next();
-        --index;
-    }
-    while (index < 0 && tok) {
-        tok = tok->previous();
-        ++index;
-    }
-    return tok;
-}
-
-const Token *Token::linkAt(int index) const
-{
-    const Token *tok = this->tokAt(index);
-    if (!tok) {
-        throw InternalError(this, "Internal error. Token::linkAt called with index outside the tokens range.");
-    }
-    return tok->link();
-}
-
-const std::string &Token::strAt(int index) const
-{
-    const Token *tok = this->tokAt(index);
-    return tok ? tok->mStr : emptyString;
-}
-
-static int multiComparePercent(const Token *tok, const char*& haystack, nonneg int varid)
+/**
+ * @throws InternalError thrown on unexpected command or missing varid with %varid%
+ */
+static
+#if defined(__GNUC__)
+// GCC does not inline this by itself
+// need to use the old syntax since the C++11 [[xxx:always_inline]] cannot be used here
+inline __attribute__((always_inline))
+#endif
+int multiComparePercent(const Token *tok, const char*& haystack, nonneg int varid)
 {
     ++haystack;
     // Compare only the first character of the string for optimization reasons
     switch (haystack[0]) {
-    case '\0':
-    case ' ':
-    case '|':
-        //simple '%' character
-        haystack += 1;
-        if (tok->isArithmeticalOp() && tok->str() == "%")
-            return 1;
-        break;
     case 'v':
         if (haystack[3] == '%') { // %var%
             haystack += 4;
@@ -403,7 +424,7 @@ static int multiComparePercent(const Token *tok, const char*& haystack, nonneg i
                 return 1;
         } else { // %varid%
             if (varid == 0) {
-                throw InternalError(tok, "Internal error. Token::Match called with varid 0. Please report this to Cppcheck developers");
+                throw InternalError(tok, "Internal error. Token::Match called with varid 0.");
             }
 
             haystack += 6;
@@ -416,7 +437,7 @@ static int multiComparePercent(const Token *tok, const char*& haystack, nonneg i
         // Type (%type%)
     {
         haystack += 5;
-        if (tok->isName() && tok->varId() == 0 && !tok->isKeyword())
+        if (tok->isName() && tok->varId() == 0)
             return 1;
     }
     break;
@@ -426,11 +447,11 @@ static int multiComparePercent(const Token *tok, const char*& haystack, nonneg i
         if (haystack[3] == '%') { // %any%
             haystack += 4;
             return 1;
-        } else { // %assign%
-            haystack += 7;
-            if (tok->isAssignmentOp())
-                return 1;
         }
+        // %assign%
+        haystack += 7;
+        if (tok->isAssignmentOp())
+            return 1;
     }
     break;
     case 'n':
@@ -523,7 +544,12 @@ static int multiComparePercent(const Token *tok, const char*& haystack, nonneg i
     return 0xFFFF;
 }
 
-int Token::multiCompare(const Token *tok, const char *haystack, nonneg int varid)
+static
+#if defined(__GNUC__)
+// need to use the old syntax since the C++11 [[xxx:always_inline]] cannot be used here
+inline __attribute__((always_inline))
+#endif
+int multiCompareImpl(const Token *tok, const char *haystack, nonneg int varid)
 {
     const char *needle = tok->str().c_str();
     const char *needlePointer = needle;
@@ -557,11 +583,14 @@ int Token::multiCompare(const Token *tok, const char *haystack, nonneg int varid
 
             do {
                 ++haystack;
-            } while (*haystack != ' ' && *haystack != '|' && *haystack);
 
-            if (*haystack == ' ' || *haystack == '\0') {
-                return -1;
-            }
+                if (*haystack == ' ' || *haystack == '\0') {
+                    return -1;
+                }
+                if (*haystack == '|') {
+                    break;
+                }
+            } while (true);
 
             ++haystack;
         }
@@ -573,26 +602,34 @@ int Token::multiCompare(const Token *tok, const char *haystack, nonneg int varid
     return -1;
 }
 
-bool Token::simpleMatch(const Token *tok, const char pattern[])
+// cppcheck-suppress unusedFunction - used in tests only
+int Token::multiCompare(const Token *tok, const char *haystack, nonneg int varid)
+{
+    return multiCompareImpl(tok, haystack, varid);
+}
+
+bool Token::simpleMatch(const Token *tok, const char pattern[], size_t pattern_len)
 {
     if (!tok)
         return false; // shortcut
-    const char *current  = pattern;
-    const char *next = std::strchr(pattern, ' ');
+    const char *current = pattern;
+    const char *end = pattern + pattern_len;
+    // cppcheck-suppress shadowFunction - TODO: fix this
+    const char *next = static_cast<const char*>(std::memchr(pattern, ' ', pattern_len));
     if (!next)
-        next = pattern + std::strlen(pattern);
+        next = end;
 
     while (*current) {
         const std::size_t length = next - current;
 
-        if (!tok || length != tok->mStr.length() || std::strncmp(current, tok->mStr.c_str(), length))
+        if (!tok || length != tok->mStr.length() || std::strncmp(current, tok->mStr.c_str(), length) != 0)
             return false;
 
         current = next;
         if (*next) {
             next = std::strchr(++current, ' ');
             if (!next)
-                next = current + std::strlen(current);
+                next = end;
         }
         tok = tok->next();
     }
@@ -603,9 +640,9 @@ bool Token::simpleMatch(const Token *tok, const char pattern[])
 bool Token::firstWordEquals(const char *str, const char *word)
 {
     for (;;) {
-        if (*str != *word) {
+        if (*str != *word)
             return (*str == ' ' && *word == 0);
-        } else if (*str == 0)
+        if (*str == 0)
             break;
 
         ++str;
@@ -630,8 +667,11 @@ const char *Token::chrInFirstWord(const char *str, char c)
 
 bool Token::Match(const Token *tok, const char pattern[], nonneg int varid)
 {
+    if (!(*pattern))
+        return true;
+
     const char *p = pattern;
-    while (*p) {
+    while (true) {
         // Skip spaces in pattern..
         while (*p == ' ')
             ++p;
@@ -646,8 +686,9 @@ bool Token::Match(const Token *tok, const char pattern[], nonneg int varid)
                 while (*p && *p != ' ')
                     ++p;
                 continue;
-            } else
-                return false;
+            }
+
+            return false;
         }
 
         // [.. => search for a one-character token..
@@ -678,8 +719,6 @@ bool Token::Match(const Token *tok, const char pattern[], nonneg int varid)
                 return false;
 
             p = temp;
-            while (*p && *p != ' ')
-                ++p;
         }
 
         // Parse "not" options. Token can be anything except the given one
@@ -687,26 +726,26 @@ bool Token::Match(const Token *tok, const char pattern[], nonneg int varid)
             p += 2;
             if (firstWordEquals(p, tok->str().c_str()))
                 return false;
-            while (*p && *p != ' ')
-                ++p;
         }
 
         // Parse multi options, such as void|int|char (accept token which is one of these 3)
         else {
-            const int res = multiCompare(tok, p, varid);
+            const int res = multiCompareImpl(tok, p, varid);
             if (res == 0) {
                 // Empty alternative matches, use the same token on next round
                 while (*p && *p != ' ')
                     ++p;
                 continue;
-            } else if (res == -1) {
+            }
+            if (res == -1) {
                 // No match
                 return false;
             }
         }
 
-        while (*p && *p != ' ')
-            ++p;
+        // using strchr() for the other instances leads to a performance decrease
+        if (!(p = strchr(p, ' ')))
+            break;
 
         tok = tok->next();
     }
@@ -720,36 +759,20 @@ nonneg int Token::getStrLength(const Token *tok)
     assert(tok != nullptr);
     assert(tok->mTokType == eString);
 
-    int len = 0;
-    std::string::const_iterator it = tok->str().begin() + 1U;
-    const std::string::const_iterator end = tok->str().end() - 1U;
-
-    while (it != end) {
-        if (*it == '\\') {
-            ++it;
-
-            // string ends at '\0'
-            if (*it == '0')
-                return len;
-        }
+    const std::string s(replaceEscapeSequences(getStringLiteral(tok->str())));
 
-        if (*it == '\0')
-            return len;
-
-        ++it;
-        ++len;
-    }
-
-    return len;
+    const auto pos = s.find('\0');
+    return pos < s.size() ? pos : s.size();
 }
 
-nonneg int Token::getStrSize(const Token *tok)
+nonneg int Token::getStrArraySize(const Token *tok)
 {
     assert(tok != nullptr);
     assert(tok->tokType() == eString);
-    const std::string &str = tok->str();
+    // cppcheck-suppress shadowFunction - TODO: fix this
+    const std::string str(getStringLiteral(tok->str()));
     int sizeofstring = 1;
-    for (int i = 1; i < (int)str.size() - 1; i++) {
+    for (int i = 0; i < static_cast<int>(str.size()); i++) {
         if (str[i] == '\\')
             ++i;
         ++sizeofstring;
@@ -757,34 +780,16 @@ nonneg int Token::getStrSize(const Token *tok)
     return sizeofstring;
 }
 
-std::string Token::getCharAt(const Token *tok, MathLib::bigint index)
+nonneg int Token::getStrSize(const Token *tok, const Settings &settings)
 {
-    assert(tok != nullptr);
-
-    std::string::const_iterator it = tok->str().begin() + 1U;
-    const std::string::const_iterator end = tok->str().end() - 1U;
-
-    while (it != end) {
-        if (index == 0) {
-            if (*it == '\0')
-                return "\\0";
-
-            std::string ret(1, *it);
-            if (*it == '\\') {
-                ++it;
-                ret += *it;
-            }
-            return ret;
-        }
-
-        if (*it == '\\')
-            ++it;
-        ++it;
-        --index;
+    assert(tok != nullptr && tok->tokType() == eString);
+    nonneg int sizeofType = 1;
+    if (tok->valueType()) {
+        ValueType vt(*tok->valueType());
+        vt.pointer = 0;
+        sizeofType = vt.getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer);
     }
-    assert(index == 0);
-
-    return "\\0";
+    return getStrArraySize(tok) * sizeofType;
 }
 
 void Token::move(Token *srcStart, Token *srcEnd, Token *newLocation)
@@ -808,12 +813,13 @@ void Token::move(Token *srcStart, Token *srcEnd, Token *newLocation)
         tok->mImpl->mProgressValue = newLocation->mImpl->mProgressValue;
 }
 
-Token* Token::nextArgument() const
+template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+static T* nextArgumentImpl(T *thisTok)
 {
-    for (const Token* tok = this; tok; tok = tok->next()) {
+    for (T* tok = thisTok; tok; tok = tok->next()) {
         if (tok->str() == ",")
             return tok->next();
-        else if (tok->link() && Token::Match(tok, "(|{|[|<"))
+        if (tok->link() && Token::Match(tok, "(|{|[|<"))
             tok = tok->link();
         else if (Token::Match(tok, ")|;"))
             return nullptr;
@@ -821,12 +827,22 @@ Token* Token::nextArgument() const
     return nullptr;
 }
 
-Token* Token::nextArgumentBeforeCreateLinks2() const
+const Token* Token::nextArgument() const
+{
+    return nextArgumentImpl(this);
+}
+
+Token *Token::nextArgument()
+{
+    return nextArgumentImpl(this);
+}
+
+const Token* Token::nextArgumentBeforeCreateLinks2() const
 {
     for (const Token* tok = this; tok; tok = tok->next()) {
         if (tok->str() == ",")
             return tok->next();
-        else if (tok->link() && Token::Match(tok, "(|{|["))
+        if (tok->link() && Token::Match(tok, "(|{|["))
             tok = tok->link();
         else if (tok->str() == "<") {
             const Token* temp = tok->findClosingBracket();
@@ -838,12 +854,12 @@ Token* Token::nextArgumentBeforeCreateLinks2() const
     return nullptr;
 }
 
-Token* Token::nextTemplateArgument() const
+const Token* Token::nextTemplateArgument() const
 {
     for (const Token* tok = this; tok; tok = tok->next()) {
         if (tok->str() == ",")
             return tok->next();
-        else if (tok->link() && Token::Match(tok, "(|{|[|<"))
+        if (tok->link() && Token::Match(tok, "(|{|[|<"))
             tok = tok->link();
         else if (Token::Match(tok, ">|;"))
             return nullptr;
@@ -864,10 +880,28 @@ const Token * Token::findClosingBracket() const
     if (mStr != "<")
         return nullptr;
 
+    if (!mPrevious)
+        return nullptr;
+
+    if (!(mPrevious->isName() || Token::simpleMatch(mPrevious, "]") ||
+          Token::Match(mPrevious->previous(), "operator %op% <") ||
+          Token::Match(mPrevious->tokAt(-2), "operator [([] [)]] <")))
+        return nullptr;
+
     const Token *closing = nullptr;
     const bool templateParameter(strAt(-1) == "template");
     std::set<std::string> templateParameters;
 
+    bool isDecl = true;
+    for (const Token *prev = previous(); prev; prev = prev->previous()) {
+        if (prev->str() == "=")
+            isDecl = false;
+        if (Token::simpleMatch(prev, "template <"))
+            isDecl = true;
+        if (Token::Match(prev, "[;{}]"))
+            break;
+    }
+
     unsigned int depth = 0;
     for (closing = this; closing != nullptr; closing = closing->next()) {
         if (Token::Match(closing, "{|[|(")) {
@@ -878,20 +912,22 @@ const Token * Token::findClosingBracket() const
             return nullptr;
         // we can make some guesses for template parameters
         else if (closing->str() == "<" && closing->previous() &&
-                 (closing->previous()->isName() || isOperator(closing->previous())) &&
+                 (closing->previous()->isName() || Token::simpleMatch(closing->previous(), "]") || isOperator(closing->previous())) &&
                  (templateParameter ? templateParameters.find(closing->strAt(-1)) == templateParameters.end() : true))
             ++depth;
         else if (closing->str() == ">") {
             if (--depth == 0)
                 return closing;
-        } else if (closing->str() == ">>") {
+        } else if (closing->str() == ">>" || closing->str() == ">>=") {
+            if (!isDecl && depth == 1)
+                continue;
             if (depth <= 2)
                 return closing;
             depth -= 2;
         }
         // save named template parameter
-        else if (templateParameter && depth == 1 && closing->str() == "," &&
-                 closing->previous()->isName() && !Match(closing->previous(), "class|typename|."))
+        else if (templateParameter && depth == 1 && Token::Match(closing, "[,=]") &&
+                 closing->previous()->isName() && !Token::Match(closing->previous(), "class|typename|.") && !Token::Match(closing->tokAt(-2), "=|::"))
             templateParameters.insert(closing->strAt(-1));
     }
 
@@ -901,7 +937,7 @@ const Token * Token::findClosingBracket() const
 Token * Token::findClosingBracket()
 {
     // return value of const function
-    return const_cast<Token*>(const_cast<const Token*>(this)->findClosingBracket());
+    return const_cast<Token*>(static_cast<const Token*>(this)->findClosingBracket());
 }
 
 const Token * Token::findOpeningBracket() const
@@ -933,47 +969,88 @@ const Token * Token::findOpeningBracket() const
 Token * Token::findOpeningBracket()
 {
     // return value of const function
-    return const_cast<Token*>(const_cast<const Token*>(this)->findOpeningBracket());
+    return const_cast<Token*>(static_cast<const Token*>(this)->findOpeningBracket());
 }
 
 //---------------------------------------------------------------------------
 
-const Token *Token::findsimplematch(const Token * const startTok, const char pattern[])
+template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+static T *findsimplematchImpl(T * const startTok, const char pattern[], size_t pattern_len)
 {
-    for (const Token* tok = startTok; tok; tok = tok->next()) {
-        if (Token::simpleMatch(tok, pattern))
+    for (T* tok = startTok; tok; tok = tok->next()) {
+        if (Token::simpleMatch(tok, pattern, pattern_len))
             return tok;
     }
     return nullptr;
 }
 
-const Token *Token::findsimplematch(const Token * const startTok, const char pattern[], const Token * const end)
+const Token *Token::findsimplematch(const Token * const startTok, const char pattern[], size_t pattern_len)
 {
-    for (const Token* tok = startTok; tok && tok != end; tok = tok->next()) {
-        if (Token::simpleMatch(tok, pattern))
+    return findsimplematchImpl(startTok, pattern, pattern_len);
+}
+
+Token *Token::findsimplematch(Token * const startTok, const char pattern[], size_t pattern_len)
+{
+    return findsimplematchImpl(startTok, pattern, pattern_len);
+}
+
+template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+static T *findsimplematchImpl(T * const startTok, const char pattern[], size_t pattern_len, const Token * const end)
+{
+    for (T* tok = startTok; tok && tok != end; tok = tok->next()) {
+        if (Token::simpleMatch(tok, pattern, pattern_len))
             return tok;
     }
     return nullptr;
 }
 
-const Token *Token::findmatch(const Token * const startTok, const char pattern[], const nonneg int varId)
+const Token *Token::findsimplematch(const Token * const startTok, const char pattern[], size_t pattern_len, const Token * const end)
+{
+    return findsimplematchImpl(startTok, pattern, pattern_len, end);
+}
+
+Token *Token::findsimplematch(Token * const startTok, const char pattern[], size_t pattern_len, const Token * const end) {
+    return findsimplematchImpl(startTok, pattern, pattern_len, end);
+}
+
+template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+static T *findmatchImpl(T * const startTok, const char pattern[], const nonneg int varId)
 {
-    for (const Token* tok = startTok; tok; tok = tok->next()) {
+    for (T* tok = startTok; tok; tok = tok->next()) {
         if (Token::Match(tok, pattern, varId))
             return tok;
     }
     return nullptr;
 }
 
-const Token *Token::findmatch(const Token * const startTok, const char pattern[], const Token * const end, const nonneg int varId)
+const Token *Token::findmatch(const Token * const startTok, const char pattern[], const nonneg int varId)
 {
-    for (const Token* tok = startTok; tok && tok != end; tok = tok->next()) {
+    return findmatchImpl(startTok, pattern, varId);
+}
+
+Token *Token::findmatch(Token * const startTok, const char pattern[], const nonneg int varId) {
+    return findmatchImpl(startTok, pattern, varId);
+}
+
+template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+static T *findmatchImpl(T * const startTok, const char pattern[], const Token * const end, const nonneg int varId)
+{
+    for (T* tok = startTok; tok && tok != end; tok = tok->next()) {
         if (Token::Match(tok, pattern, varId))
             return tok;
     }
     return nullptr;
 }
 
+const Token *Token::findmatch(const Token * const startTok, const char pattern[], const Token * const end, const nonneg int varId)
+{
+    return findmatchImpl(startTok, pattern, end, varId);
+}
+
+Token *Token::findmatch(Token * const startTok, const char pattern[], const Token * const end, const nonneg int varId) {
+    return findmatchImpl(startTok, pattern, end, varId);
+}
+
 void Token::function(const Function *f)
 {
     mImpl->mFunction = f;
@@ -986,16 +1063,14 @@ void Token::function(const Function *f)
         tokType(eName);
 }
 
-void Token::insertToken(const std::string &tokenStr, const std::string &originalNameStr, bool prepend)
+Token* Token::insertToken(const std::string& tokenStr, bool prepend)
 {
     Token *newToken;
     if (mStr.empty())
         newToken = this;
     else
-        newToken = new Token(mTokensFrontBack);
+        newToken = new Token(mList, mTokensFrontBack);
     newToken->str(tokenStr);
-    if (!originalNameStr.empty())
-        newToken->originalName(originalNameStr);
 
     if (newToken != this) {
         newToken->mImpl->mLineNumber = mImpl->mLineNumber;
@@ -1006,7 +1081,7 @@ void Token::insertToken(const std::string &tokenStr, const std::string &original
             if (this->previous()) {
                 newToken->previous(this->previous());
                 newToken->previous()->next(newToken);
-            } else if (mTokensFrontBack) {
+            } else {
                 mTokensFrontBack->front = newToken;
             }
             this->previous(newToken);
@@ -1015,7 +1090,7 @@ void Token::insertToken(const std::string &tokenStr, const std::string &original
             if (this->next()) {
                 newToken->next(this->next());
                 newToken->next()->previous(newToken);
-            } else if (mTokensFrontBack) {
+            } else {
                 mTokensFrontBack->back = newToken;
             }
             this->next(newToken);
@@ -1024,36 +1099,35 @@ void Token::insertToken(const std::string &tokenStr, const std::string &original
 
         if (mImpl->mScopeInfo) {
             // If the brace is immediately closed there is no point opening a new scope for it
-            if (tokenStr == "{") {
+            if (newToken->str() == "{") {
                 std::string nextScopeNameAddition;
                 // This might be the opening of a member function
                 Token *tok1 = newToken;
                 while (Token::Match(tok1->previous(), "const|volatile|final|override|&|&&|noexcept"))
                     tok1 = tok1->previous();
-                if (tok1 && tok1->previous() && tok1->strAt(-1) == ")") {
+                if (tok1->previous() && tok1->strAt(-1) == ")") {
                     tok1 = tok1->linkAt(-1);
                     if (Token::Match(tok1->previous(), "throw|noexcept")) {
                         tok1 = tok1->previous();
                         while (Token::Match(tok1->previous(), "const|volatile|final|override|&|&&|noexcept"))
                             tok1 = tok1->previous();
                         if (tok1->strAt(-1) != ")")
-                            return;
+                            return newToken;
                     } else if (Token::Match(newToken->tokAt(-2), ":|, %name%")) {
                         tok1 = tok1->tokAt(-2);
                         if (tok1->strAt(-1) != ")")
-                            return;
+                            return newToken;
                     }
                     if (tok1->strAt(-1) == ">")
                         tok1 = tok1->previous()->findOpeningBracket();
                     if (tok1 && Token::Match(tok1->tokAt(-3), "%name% :: %name%")) {
                         tok1 = tok1->tokAt(-2);
+                        // cppcheck-suppress shadowFunction - TODO: fix this
                         std::string scope = tok1->strAt(-1);
                         while (Token::Match(tok1->tokAt(-2), ":: %name%")) {
                             scope = tok1->strAt(-3) + " :: " + scope;
                             tok1 = tok1->tokAt(-2);
                         }
-
-                        if (!nextScopeNameAddition.empty() && !scope.empty()) nextScopeNameAddition += " :: ";
                         nextScopeNameAddition += scope;
                     }
                 }
@@ -1069,7 +1143,8 @@ void Token::insertToken(const std::string &tokenStr, const std::string &original
                             nextScopeNameAddition.append(nameTok->str());
                             nextScopeNameAddition.append(" ");
                         }
-                        if (nextScopeNameAddition.length() > 0) nextScopeNameAddition = nextScopeNameAddition.substr(0, nextScopeNameAddition.length() - 1);
+                        if (!nextScopeNameAddition.empty())
+                            nextScopeNameAddition.pop_back();
                     }
                 }
 
@@ -1080,8 +1155,8 @@ void Token::insertToken(const std::string &tokenStr, const std::string &original
                 newScopeInfo->name.append(nextScopeNameAddition);
                 nextScopeNameAddition = "";
 
-                newToken->scopeInfo(newScopeInfo);
-            } else if (tokenStr == "}") {
+                newToken->scopeInfo(std::move(newScopeInfo));
+            } else if (newToken->str() == "}") {
                 Token* matchingTok = newToken->previous();
                 int depth = 0;
                 while (matchingTok && (depth != 0 || !Token::simpleMatch(matchingTok, "{"))) {
@@ -1098,9 +1173,11 @@ void Token::insertToken(const std::string &tokenStr, const std::string &original
                 } else {
                     newToken->mImpl->mScopeInfo = mImpl->mScopeInfo;
                 }
-                if (tokenStr == ";") {
-                    const Token* statementStart;
-                    for (statementStart = newToken; statementStart->previous() && !Token::Match(statementStart->previous(), ";|{"); statementStart = statementStart->previous());
+                if (newToken->str() == ";") {
+                    const Token* statementStart = newToken;
+                    while (statementStart->previous() && !Token::Match(statementStart->previous(), ";|{")) {
+                        statementStart = statementStart->previous();
+                    }
                     if (Token::Match(statementStart, "using namespace %name% ::|;")) {
                         const Token * tok1 = statementStart->tokAt(2);
                         std::string nameSpace;
@@ -1110,12 +1187,29 @@ void Token::insertToken(const std::string &tokenStr, const std::string &original
                             nameSpace += tok1->str();
                             tok1 = tok1->next();
                         }
-                        mImpl->mScopeInfo->usingNamespaces.insert(nameSpace);
+                        mImpl->mScopeInfo->usingNamespaces.insert(std::move(nameSpace));
                     }
                 }
             }
         }
     }
+    return newToken;
+}
+
+Token* Token::insertToken(const std::string& tokenStr, const std::string& originalNameStr, bool prepend)
+{
+    Token* const newToken = insertToken(tokenStr, prepend);
+    if (!originalNameStr.empty())
+        newToken->originalName(originalNameStr);
+    return newToken;
+}
+
+Token* Token::insertToken(const std::string& tokenStr, const std::string& originalNameStr, const std::string& macroNameStr, bool prepend)
+{
+    Token* const newToken = insertToken(tokenStr, originalNameStr, prepend);
+    if (!macroNameStr.empty())
+        newToken->setMacroName(macroNameStr);
+    return newToken;
 }
 
 void Token::eraseTokens(Token *begin, const Token *end)
@@ -1137,68 +1231,116 @@ void Token::createMutualLinks(Token *begin, Token *end)
     end->link(begin);
 }
 
-void Token::printOut(const char *title) const
+void Token::printOut() const
+{
+    printOut(std::cout, "");
+}
+
+void Token::printOut(std::ostream& out, const char *title) const
 {
     if (title && title[0])
-        std::cout << "\n### " << title << " ###\n";
-    std::cout << stringifyList(true, true, true, true, true, nullptr, nullptr) << std::endl;
+        out << "\n### " << title << " ###\n";
+    out << stringifyList(stringifyOptions::forPrintOut(), nullptr, nullptr) << std::endl;
 }
 
-void Token::printOut(const char *title, const std::vector<std::string> &fileNames) const
+void Token::printOut(std::ostream& out, bool xml, const char *title, const std::vector<std::string> &fileNames) const
 {
+    if (xml)
+    {
+        out << "<file>" << std::endl;
+        out << "<![CDATA[";
+    }
     if (title && title[0])
-        std::cout << "\n### " << title << " ###\n";
-    std::cout << stringifyList(true, true, true, true, true, &fileNames, nullptr) << std::endl;
+        out << "\n### " << title << " ###\n";
+    out << stringifyList(stringifyOptions::forPrintOut(), &fileNames, nullptr) << std::endl;
+    if (xml)
+    {
+        out << "]]>" << std::endl;
+        out << "</file>" << std::endl;
+    }
 }
 
-void Token::stringify(std::ostream& os, bool varid, bool attributes, bool macro) const
+// cppcheck-suppress unusedFunction - used for debugging
+void Token::printLines(std::ostream& out, int lines) const
 {
-    if (attributes) {
+    const Token *end = this;
+    while (end && end->linenr() < lines + linenr())
+        end = end->next();
+    out << stringifyList(stringifyOptions::forDebugExprId(), nullptr, end) << std::endl;
+}
+
+std::string Token::stringify(const stringifyOptions& options) const
+{
+    std::string ret;
+    if (options.attributes) {
         if (isUnsigned())
-            os << "unsigned ";
+            ret += "unsigned ";
         else if (isSigned())
-            os << "signed ";
+            ret += "signed ";
         if (isComplex())
-            os << "_Complex ";
+            ret += "_Complex ";
         if (isLong()) {
-            if (mTokType == eString || mTokType == eChar)
-                os << "L";
-            else
-                os << "long ";
+            if (!(mTokType == eString || mTokType == eChar))
+                ret += "long ";
         }
     }
-    if (macro && isExpandedMacro())
-        os << "$";
+    if (options.macro && isExpandedMacro())
+        ret += '$';
     if (isName() && mStr.find(' ') != std::string::npos) {
-        for (char i : mStr) {
+        for (const char i : mStr) {
             if (i != ' ')
-                os << i;
+                ret += i;
         }
     } else if (mStr[0] != '\"' || mStr.find('\0') == std::string::npos)
-        os << mStr;
+        ret += mStr;
     else {
-        for (char i : mStr) {
+        for (const char i : mStr) {
             if (i == '\0')
-                os << "\\0";
+                ret += "\\0";
             else
-                os << i;
+                ret += i;
         }
     }
-    if (varid && mImpl->mVarId != 0)
-        os << '@' << mImpl->mVarId;
+    if (options.varid && mImpl->mVarId != 0) {
+        ret += '@';
+        ret += (options.idtype ? "var" : "");
+        ret += std::to_string(mImpl->mVarId);
+    } else if (options.exprid && mImpl->mExprId != 0) {
+        ret += '@';
+        ret += (options.idtype ? "expr" : "");
+        if ((mImpl->mExprId & (1U << efIsUnique)) != 0)
+            ret += "UNIQUE";
+        else
+            ret += std::to_string(mImpl->mExprId);
+    }
+
+    return ret;
 }
 
-std::string Token::stringifyList(bool varid, bool attributes, bool linenumbers, bool linebreaks, bool files, const std::vector<std::string>* fileNames, const Token* end) const
+std::string Token::stringify(bool varid, bool attributes, bool macro) const
+{
+    stringifyOptions options;
+    options.varid = varid;
+    options.attributes = attributes;
+    options.macro = macro;
+    return stringify(options);
+}
+
+std::string Token::stringifyList(const stringifyOptions& options, const std::vector<std::string>* fileNames, const Token* end) const
 {
     if (this == end)
         return "";
 
-    std::ostringstream ret;
+    std::string ret;
 
-    unsigned int lineNumber = mImpl->mLineNumber - (linenumbers ? 1U : 0U);
-    unsigned int fileIndex = files ? ~0U : mImpl->mFileIndex;
+    unsigned int lineNumber = mImpl->mLineNumber - (options.linenumbers ? 1U : 0U);
+    // cppcheck-suppress shadowFunction - TODO: fix this
+    unsigned int fileIndex = options.files ? ~0U : mImpl->mFileIndex;
     std::map<int, unsigned int> lineNumbers;
     for (const Token *tok = this; tok != end; tok = tok->next()) {
+        assert(tok && "end precedes token");
+        if (!tok)
+            return ret;
         bool fileChange = false;
         if (tok->mImpl->mFileIndex != fileIndex) {
             if (fileIndex != ~0U) {
@@ -1206,47 +1348,72 @@ std::string Token::stringifyList(bool varid, bool attributes, bool linenumbers,
             }
 
             fileIndex = tok->mImpl->mFileIndex;
-            if (files) {
-                ret << "\n\n##file ";
+            if (options.files) {
+                ret += "\n\n##file ";
                 if (fileNames && fileNames->size() > tok->mImpl->mFileIndex)
-                    ret << fileNames->at(tok->mImpl->mFileIndex);
+                    ret += fileNames->at(tok->mImpl->mFileIndex);
                 else
-                    ret << fileIndex;
-                ret << '\n';
+                    ret += std::to_string(fileIndex);
+                ret += '\n';
             }
 
             lineNumber = lineNumbers[fileIndex];
             fileChange = true;
         }
 
-        if (linebreaks && (lineNumber != tok->linenr() || fileChange)) {
+        if (options.linebreaks && (lineNumber != tok->linenr() || fileChange)) {
             if (lineNumber+4 < tok->linenr() && fileIndex == tok->mImpl->mFileIndex) {
-                ret << '\n' << lineNumber+1 << ":\n|\n";
-                ret << tok->linenr()-1 << ":\n";
-                ret << tok->linenr() << ": ";
-            } else if (this == tok && linenumbers) {
-                ret << tok->linenr() << ": ";
+                ret += '\n';
+                ret += std::to_string(lineNumber+1);
+                ret += ":\n|\n";
+                ret += std::to_string(tok->linenr()-1);
+                ret += ":\n";
+                ret += std::to_string(tok->linenr());
+                ret += ": ";
+            } else if (this == tok && options.linenumbers) {
+                ret += std::to_string(tok->linenr());
+                ret += ": ";
+            } else if (lineNumber > tok->linenr()) {
+                lineNumber = tok->linenr();
+                ret += '\n';
+                if (options.linenumbers) {
+                    ret += std::to_string(lineNumber);
+                    ret += ':';
+                    ret += ' ';
+                }
             } else {
                 while (lineNumber < tok->linenr()) {
                     ++lineNumber;
-                    ret << '\n';
-                    if (linenumbers) {
-                        ret << lineNumber << ':';
+                    ret += '\n';
+                    if (options.linenumbers) {
+                        ret += std::to_string(lineNumber);
+                        ret += ':';
                         if (lineNumber == tok->linenr())
-                            ret << ' ';
+                            ret += ' ';
                     }
                 }
             }
             lineNumber = tok->linenr();
         }
 
-        tok->stringify(ret, varid, attributes, attributes); // print token
-        if (tok->next() != end && (!linebreaks || (tok->next()->linenr() <= tok->linenr() && tok->next()->fileIndex() == tok->fileIndex())))
-            ret << ' ';
+        ret += tok->stringify(options); // print token
+        if (tok->next() != end && (!options.linebreaks || (tok->next()->linenr() == tok->linenr() && tok->next()->fileIndex() == tok->fileIndex())))
+            ret += ' ';
     }
-    if (linebreaks && (files || linenumbers))
-        ret << '\n';
-    return ret.str();
+    if (options.linebreaks && (options.files || options.linenumbers))
+        ret += '\n';
+    return ret;
+}
+std::string Token::stringifyList(bool varid, bool attributes, bool linenumbers, bool linebreaks, bool files, const std::vector<std::string>* fileNames, const Token* end) const
+{
+    stringifyOptions options;
+    options.varid = varid;
+    options.attributes = attributes;
+    options.macro = attributes;
+    options.linenumbers = linenumbers;
+    options.linebreaks = linebreaks;
+    options.files = files;
+    return stringifyList(options, fileNames, end);
 }
 
 std::string Token::stringifyList(const Token* end, bool attributes) const
@@ -1259,19 +1426,33 @@ std::string Token::stringifyList(bool varid) const
     return stringifyList(varid, false, true, true, true, nullptr, nullptr);
 }
 
+void Token::astParent(Token* tok)
+{
+    const Token* tok2 = tok;
+    while (tok2) {
+        if (this == tok2)
+            throw InternalError(this, "Internal error. AST cyclic dependency.");
+        tok2 = tok2->astParent();
+    }
+    // Clear children to avoid nodes referenced twice
+    if (this->astParent()) {
+        Token* parent = this->astParent();
+        if (parent->astOperand1() == this)
+            parent->mImpl->mAstOperand1 = nullptr;
+        if (parent->astOperand2() == this)
+            parent->mImpl->mAstOperand2 = nullptr;
+    }
+    mImpl->mAstParent = tok;
+}
+
 void Token::astOperand1(Token *tok)
 {
     if (mImpl->mAstOperand1)
-        mImpl->mAstOperand1->mImpl->mAstParent = nullptr;
+        mImpl->mAstOperand1->astParent(nullptr);
     // goto parent operator
     if (tok) {
-        std::set<Token*> visitedParents;
-        while (tok->mImpl->mAstParent) {
-            if (!visitedParents.insert(tok->mImpl->mAstParent).second) // #6838/#6726/#8352 avoid hang on garbage code
-                throw InternalError(this, "Internal error. Token::astOperand1() cyclic dependency.");
-            tok = tok->mImpl->mAstParent;
-        }
-        tok->mImpl->mAstParent = this;
+        tok = tok->astTop();
+        tok->astParent(this);
     }
     mImpl->mAstOperand1 = tok;
 }
@@ -1279,17 +1460,11 @@ void Token::astOperand1(Token *tok)
 void Token::astOperand2(Token *tok)
 {
     if (mImpl->mAstOperand2)
-        mImpl->mAstOperand2->mImpl->mAstParent = nullptr;
+        mImpl->mAstOperand2->astParent(nullptr);
     // goto parent operator
     if (tok) {
-        std::set<Token*> visitedParents;
-        while (tok->mImpl->mAstParent) {
-            //std::cout << tok << " -> " << tok->mAstParent ;
-            if (!visitedParents.insert(tok->mImpl->mAstParent).second) // #6838/#6726 avoid hang on garbage code
-                throw InternalError(this, "Internal error. Token::astOperand2() cyclic dependency.");
-            tok = tok->mImpl->mAstParent;
-        }
-        tok->mImpl->mAstParent = this;
+        tok = tok->astTop();
+        tok->astParent(this);
     }
     mImpl->mAstOperand2 = tok;
 }
@@ -1334,8 +1509,7 @@ std::pair<const Token *, const Token *> Token::findExpressionStartEndTokens() co
 
     // find start node in AST tree
     const Token *start = top;
-    while (start->astOperand1() &&
-           (start->astOperand2() || !start->isUnaryPreOp() || Token::simpleMatch(start, "( )") || start->str() == "{"))
+    while (start->astOperand1() && precedes(start->astOperand1(), start))
         start = start->astOperand1();
 
     // find end node in AST tree
@@ -1349,8 +1523,8 @@ std::pair<const Token *, const Token *> Token::findExpressionStartEndTokens() co
                 break;
             }
         }
-        if (Token::Match(end,"(|[") &&
-            !(Token::Match(end, "( %type%") && !end->astOperand2())) {
+        if (Token::Match(end,"(|[|{") &&
+            !(Token::Match(end, "( ::| %type%") && !end->astOperand2())) {
             end = end->link();
             break;
         }
@@ -1362,6 +1536,12 @@ std::pair<const Token *, const Token *> Token::findExpressionStartEndTokens() co
     end = goToRightParenthesis(start, end);
     if (Token::simpleMatch(end, "{"))
         end = end->link();
+
+    if (precedes(top, start))
+        throw InternalError(start, "Cannot find start of expression");
+    if (succeeds(top, end))
+        throw InternalError(end, "Cannot find end of expression");
+
     return std::pair<const Token *, const Token *>(start,end);
 }
 
@@ -1405,7 +1585,7 @@ bool Token::isUnaryPreOp() const
 {
     if (!astOperand1() || astOperand2())
         return false;
-    if (!Token::Match(this, "++|--"))
+    if (this->tokType() != Token::eIncDecOp)
         return true;
     const Token *tokbefore = mPrevious;
     const Token *tokafter = mNext;
@@ -1422,22 +1602,38 @@ bool Token::isUnaryPreOp() const
 
 static std::string stringFromTokenRange(const Token* start, const Token* end)
 {
-    std::ostringstream ret;
+    std::string ret;
     if (end)
         end = end->next();
     for (const Token *tok = start; tok && tok != end; tok = tok->next()) {
         if (tok->isUnsigned())
-            ret << "unsigned ";
-        if (tok->isLong())
-            ret << (tok->isLiteral() ? "L" : "long ");
-        if (tok->originalName().empty() || tok->isUnsigned() || tok->isLong()) {
-            ret << tok->str();
+            ret += "unsigned ";
+        if (tok->isLong() && !tok->isLiteral())
+            ret += "long ";
+        if (tok->tokType() == Token::eString) {
+            for (const unsigned char c: tok->str()) {
+                if (c == '\n')
+                    ret += "\\n";
+                else if (c == '\r')
+                    ret += "\\r";
+                else if (c == '\t')
+                    ret += "\\t";
+                else if (c >= ' ' && c <= 126)
+                    ret += c;
+                else {
+                    char str[5];
+                    snprintf(str, sizeof(str), "\\x%02x", c);
+                    ret += str;
+                }
+            }
+        } else if (tok->originalName().empty() || tok->isUnsigned() || tok->isLong()) {
+            ret += tok->str();
         } else
-            ret << tok->originalName();
+            ret += tok->originalName();
         if (Token::Match(tok, "%name%|%num% %name%|%num%"))
-            ret << ' ';
+            ret += ' ';
     }
-    return ret.str();
+    return ret;
 }
 
 std::string Token::expressionString() const
@@ -1451,8 +1647,8 @@ static void astStringXml(const Token *tok, nonneg int indent, std::ostream &out)
     const std::string strindent(indent, ' ');
 
     out << strindent << "<token str=\"" << tok->str() << '\"';
-    if (tok->varId() > 0U)
-        out << " varId=\"" << MathLib::toString(tok->varId()) << '\"';
+    if (tok->varId())
+        out << " varId=\"" << tok->varId() << '\"';
     if (tok->variable())
         out << " variable=\"" << tok->variable() << '\"';
     if (tok->function())
@@ -1474,14 +1670,15 @@ static void astStringXml(const Token *tok, nonneg int indent, std::ostream &out)
     }
 }
 
-void Token::printAst(bool verbose, bool xml, std::ostream &out) const
+void Token::printAst(bool xml, const std::vector<std::string> &fileNames, std::ostream &out) const
 {
+    if (!xml)
+        out << "\n\n##AST" << std::endl;
+
     std::set<const Token *> printed;
     for (const Token *tok = this; tok; tok = tok->next()) {
         if (!tok->mImpl->mAstParent && tok->mImpl->mAstOperand1) {
-            if (printed.empty() && !xml)
-                out << "\n\n##AST" << std::endl;
-            else if (printed.find(tok) != printed.end())
+            if (printed.find(tok) != printed.end())
                 continue;
             printed.insert(tok);
 
@@ -1490,10 +1687,8 @@ void Token::printAst(bool verbose, bool xml, std::ostream &out) const
                     << "\" column=\"" << tok->column() << "\">" << std::endl;
                 astStringXml(tok, 2U, out);
                 out << "</ast>" << std::endl;
-            } else if (verbose)
-                out << tok->astStringVerbose() << std::endl;
-            else
-                out << tok->astString(" ") << std::endl;
+            } else
+                out << "[" << fileNames[tok->fileIndex()] << ":" << tok->linenr() << "]" << std::endl << tok->astStringVerbose() << std::endl;
             if (tok->str() == "(")
                 tok = tok->link();
         }
@@ -1515,6 +1710,11 @@ void Token::astStringVerboseRecursive(std::string& ret, const nonneg int indent1
     ret += mStr;
     if (mImpl->mValueType)
         ret += " \'" + mImpl->mValueType->str() + '\'';
+    if (function()) {
+        std::ostringstream ostr;
+        ostr << std::hex << function();
+        ret += " f:" + ostr.str();
+    }
     ret += '\n';
 
     if (mImpl->mAstOperand1) {
@@ -1542,185 +1742,234 @@ std::string Token::astStringVerbose() const
     return ret;
 }
 
+// cppcheck-suppress unusedFunction // used in test
+std::string Token::astStringZ3() const
+{
+    if (!astOperand1())
+        return str();
+    if (!astOperand2())
+        return "(" + str() + " " + astOperand1()->astStringZ3() + ")";
+    return "(" + str() + " " + astOperand1()->astStringZ3() + " " + astOperand2()->astStringZ3() + ")";
+}
 
-void Token::printValueFlow(bool xml, std::ostream &out) const
+void Token::printValueFlow(const std::vector<std::string>& files, bool xml, std::ostream &out) const
 {
+    std::string outs;
+
+    // cppcheck-suppress shadowFunction
+    int fileIndex = -1;
     int line = 0;
     if (xml)
-        out << "  <valueflow>" << std::endl;
+        outs += "  <valueflow>\n";
     else
-        out << "\n\n##Value flow" << std::endl;
+        outs += "\n\n##Value flow\n";
     for (const Token *tok = this; tok; tok = tok->next()) {
-        if (!tok->mImpl->mValues)
+        // cppcheck-suppress shadowFunction - TODO: fix this
+        const auto* const values = tok->mImpl->mValues;
+        if (!values)
             continue;
-        if (xml)
-            out << "    <values id=\"" << tok->mImpl->mValues << "\">" << std::endl;
-        else if (line != tok->linenr())
-            out << "Line " << tok->linenr() << std::endl;
+        if (values->empty()) // Values might be removed by removeContradictions
+            continue;
+        if (xml) {
+            outs += "    <values id=\"";
+            outs += id_string(values);
+            outs +=  "\">";
+            outs += '\n';
+        }
+        else {
+            if (fileIndex != tok->fileIndex()) {
+                outs += "File ";
+                outs += files[tok->fileIndex()];
+                outs += '\n';
+                line = 0;
+            }
+            if (line != tok->linenr()) {
+                outs += "Line ";
+                outs += std::to_string(tok->linenr());
+                outs += '\n';
+            }
+        }
+        fileIndex = tok->fileIndex();
         line = tok->linenr();
         if (!xml) {
-            out << "  " << tok->str() << (tok->mImpl->mValues->front().isKnown() ? " always " : " possible ");
-            if (tok->mImpl->mValues->size() > 1U)
-                out << '{';
+            ValueFlow::Value::ValueKind valueKind = values->front().valueKind;
+            const bool same = std::all_of(values->begin(), values->end(), [&](const ValueFlow::Value& value) {
+                return value.valueKind == valueKind;
+            });
+            outs += "  ";
+            outs += tok->str();
+            outs += " ";
+            if (same) {
+                switch (valueKind) {
+                case ValueFlow::Value::ValueKind::Impossible:
+                case ValueFlow::Value::ValueKind::Known:
+                    outs += "always ";
+                    break;
+                case ValueFlow::Value::ValueKind::Inconclusive:
+                    outs += "inconclusive ";
+                    break;
+                case ValueFlow::Value::ValueKind::Possible:
+                    outs += "possible ";
+                    break;
+                }
+            }
+            if (values->size() > 1U)
+                outs += '{';
         }
-        for (const ValueFlow::Value &value : *tok->mImpl->mValues) {
+        for (const ValueFlow::Value& value : *values) {
             if (xml) {
-                out << "      <value ";
+                outs += "      <value ";
                 switch (value.valueType) {
-                case ValueFlow::Value::INT:
-                    if (tok->valueType() && tok->valueType()->sign == ValueType::UNSIGNED)
-                        out << "intvalue=\"" << (MathLib::biguint)value.intvalue << '\"';
-                    else
-                        out << "intvalue=\"" << value.intvalue << '\"';
+                case ValueFlow::Value::ValueType::INT:
+                    if (tok->valueType() && tok->valueType()->sign == ValueType::UNSIGNED) {
+                        outs += "intvalue=\"";
+                        outs += MathLib::toString(static_cast<MathLib::biguint>(value.intvalue));
+                        outs += '\"';
+                    }
+                    else {
+                        outs += "intvalue=\"";
+                        outs += MathLib::toString(value.intvalue);
+                        outs += '\"';
+                    }
+                    break;
+                case ValueFlow::Value::ValueType::TOK:
+                    outs +=  "tokvalue=\"";
+                    outs += id_string(value.tokvalue);
+                    outs += '\"';
                     break;
-                case ValueFlow::Value::TOK:
-                    out << "tokvalue=\"" << value.tokvalue << '\"';
+                case ValueFlow::Value::ValueType::FLOAT:
+                    outs += "floatvalue=\"";
+                    outs += MathLib::toString(value.floatValue);
+                    outs += '\"';
                     break;
-                case ValueFlow::Value::FLOAT:
-                    out << "floatvalue=\"" << value.floatValue << '\"';
+                case ValueFlow::Value::ValueType::MOVED:
+                    outs += "movedvalue=\"";
+                    outs += ValueFlow::Value::toString(value.moveKind);
+                    outs += '\"';
                     break;
-                case ValueFlow::Value::MOVED:
-                    out << "movedvalue=\"" << ValueFlow::Value::toString(value.moveKind) << '\"';
+                case ValueFlow::Value::ValueType::UNINIT:
+                    outs +=  "uninit=\"1\"";
                     break;
-                case ValueFlow::Value::UNINIT:
-                    out << "uninit=\"1\"";
+                case ValueFlow::Value::ValueType::BUFFER_SIZE:
+                    outs += "buffer-size=\"";
+                    outs += MathLib::toString(value.intvalue);
+                    outs += "\"";
                     break;
-                case ValueFlow::Value::BUFFER_SIZE:
-                    out << "buffer-size=\"" << value.intvalue << "\"";
+                case ValueFlow::Value::ValueType::CONTAINER_SIZE:
+                    outs += "container-size=\"";
+                    outs += MathLib::toString(value.intvalue);
+                    outs += '\"';
                     break;
-                case ValueFlow::Value::CONTAINER_SIZE:
-                    out << "container-size=\"" << value.intvalue << '\"';
+                case ValueFlow::Value::ValueType::ITERATOR_START:
+                    outs +=  "iterator-start=\"";
+                    outs += MathLib::toString(value.intvalue);
+                    outs += '\"';
                     break;
-                case ValueFlow::Value::LIFETIME:
-                    out << "lifetime=\"" << value.tokvalue << '\"';
+                case ValueFlow::Value::ValueType::ITERATOR_END:
+                    outs +=  "iterator-end=\"";
+                    outs += MathLib::toString(value.intvalue);
+                    outs += '\"';
+                    break;
+                case ValueFlow::Value::ValueType::LIFETIME:
+                    outs += "lifetime=\"";
+                    outs += id_string(value.tokvalue);
+                    outs += '\"';
+                    outs += " lifetime-scope=\"";
+                    outs += ValueFlow::Value::toString(value.lifetimeScope);
+                    outs += "\"";
+                    outs += " lifetime-kind=\"";
+                    outs += ValueFlow::Value::toString(value.lifetimeKind);
+                    outs += "\"";
+                    break;
+                case ValueFlow::Value::ValueType::SYMBOLIC:
+                    outs += "symbolic=\"";
+                    outs += id_string(value.tokvalue);
+                    outs += '\"';
+                    outs += " symbolic-delta=\"";
+                    outs += MathLib::toString(value.intvalue);
+                    outs += '\"';
                     break;
                 }
-                if (value.condition)
-                    out << " condition-line=\"" << value.condition->linenr() << '\"';
+                outs += " bound=\"";
+                outs += ValueFlow::Value::toString(value.bound);
+                outs += "\"";
+                if (value.condition) {
+                    outs += " condition-line=\"";
+                    outs += std::to_string(value.condition->linenr());
+                    outs += '\"';
+                }
                 if (value.isKnown())
-                    out << " known=\"true\"";
+                    outs += " known=\"true\"";
                 else if (value.isPossible())
-                    out << " possible=\"true\"";
+                    outs += " possible=\"true\"";
                 else if (value.isImpossible())
-                    out << " impossible=\"true\"";
+                    outs += " impossible=\"true\"";
                 else if (value.isInconclusive())
-                    out << " inconclusive=\"true\"";
-                out << "/>" << std::endl;
-            }
+                    outs += " inconclusive=\"true\"";
 
+                outs += " path=\"";
+                outs += MathLib::toString(value.path);
+                outs += "\"";
+
+                outs += "/>\n";
+            }
             else {
-                if (&value != &tok->mImpl->mValues->front())
-                    out << ",";
-                if (value.isImpossible())
-                    out << "!";
-                if (value.bound == ValueFlow::Value::Bound::Lower)
-                    out << ">";
-                if (value.bound == ValueFlow::Value::Bound::Upper)
-                    out << "<";
-                switch (value.valueType) {
-                case ValueFlow::Value::INT:
-                    if (tok->valueType() && tok->valueType()->sign == ValueType::UNSIGNED)
-                        out << (MathLib::biguint)value.intvalue;
-                    else
-                        out << value.intvalue;
-                    break;
-                case ValueFlow::Value::TOK:
-                    out << value.tokvalue->str();
-                    break;
-                case ValueFlow::Value::FLOAT:
-                    out << value.floatValue;
-                    break;
-                case ValueFlow::Value::MOVED:
-                    out << ValueFlow::Value::toString(value.moveKind);
-                    break;
-                case ValueFlow::Value::UNINIT:
-                    out << "Uninit";
-                    break;
-                case ValueFlow::Value::BUFFER_SIZE:
-                case ValueFlow::Value::CONTAINER_SIZE:
-                    out << "size=" << value.intvalue;
-                    break;
-                case ValueFlow::Value::LIFETIME:
-                    out << "lifetime=" << value.tokvalue->str();
-                    break;
-                }
-                if (value.indirect > 0)
-                    for (int i=0; i<value.indirect; i++)
-                        out << "*";
+                if (&value != &values->front())
+                    outs += ",";
+                outs += value.toString();
             }
         }
         if (xml)
-            out << "    </values>" << std::endl;
-        else if (tok->mImpl->mValues->size() > 1U)
-            out << '}' << std::endl;
+            outs += "    </values>\n";
+        else if (values->size() > 1U)
+            outs += "}\n";
         else
-            out << std::endl;
+            outs += '\n';
     }
     if (xml)
-        out << "  </valueflow>" << std::endl;
+        outs += "  </valueflow>\n";
+
+    out << outs;
 }
 
-const ValueFlow::Value * Token::getValueLE(const MathLib::bigint val, const Settings *settings) const
+const ValueFlow::Value * Token::getValueLE(const MathLib::bigint val, const Settings &settings) const
 {
     if (!mImpl->mValues)
         return nullptr;
-    const ValueFlow::Value *ret = nullptr;
-    std::list<ValueFlow::Value>::const_iterator it;
-    for (it = mImpl->mValues->begin(); it != mImpl->mValues->end(); ++it) {
-        if (it->isImpossible())
-            continue;
-        if (it->isIntValue() && it->intvalue <= val) {
-            if (!ret || ret->isInconclusive() || (ret->condition && !it->isInconclusive()))
-                ret = &(*it);
-            if (!ret->isInconclusive() && !ret->condition)
-                break;
-        }
-    }
-    if (settings && ret) {
-        if (ret->isInconclusive() && !settings->inconclusive)
-            return nullptr;
-        if (ret->condition && !settings->isEnabled(Settings::WARNING))
-            return nullptr;
-    }
-    return ret;
+    return ValueFlow::findValue(*mImpl->mValues, settings, [&](const ValueFlow::Value& v) {
+        return !v.isImpossible() && v.isIntValue() && v.intvalue <= val;
+    });
 }
 
-const ValueFlow::Value * Token::getValueGE(const MathLib::bigint val, const Settings *settings) const
+const ValueFlow::Value * Token::getValueGE(const MathLib::bigint val, const Settings &settings) const
 {
     if (!mImpl->mValues)
         return nullptr;
-    const ValueFlow::Value *ret = nullptr;
-    std::list<ValueFlow::Value>::const_iterator it;
-    for (it = mImpl->mValues->begin(); it != mImpl->mValues->end(); ++it) {
-        if (it->isImpossible())
-            continue;
-        if (it->isIntValue() && it->intvalue >= val) {
-            if (!ret || ret->isInconclusive() || (ret->condition && !it->isInconclusive()))
-                ret = &(*it);
-            if (!ret->isInconclusive() && !ret->condition)
-                break;
-        }
-    }
-    if (settings && ret) {
-        if (ret->isInconclusive() && !settings->inconclusive)
-            return nullptr;
-        if (ret->condition && !settings->isEnabled(Settings::WARNING))
-            return nullptr;
-    }
-    return ret;
+    return ValueFlow::findValue(*mImpl->mValues, settings, [&](const ValueFlow::Value& v) {
+        return !v.isImpossible() && v.isIntValue() && v.intvalue >= val;
+    });
 }
 
-const ValueFlow::Value * Token::getInvalidValue(const Token *ftok, nonneg int argnr, const Settings *settings) const
+const ValueFlow::Value * Token::getValueNE(MathLib::bigint val) const
 {
-    if (!mImpl->mValues || !settings)
+    if (!mImpl->mValues)
+        return nullptr;
+    const auto it = std::find_if(mImpl->mValues->cbegin(), mImpl->mValues->cend(), [=](const ValueFlow::Value& value) {
+        return value.isIntValue() && !value.isImpossible() && value.intvalue != val;
+    });
+    return it == mImpl->mValues->end() ? nullptr : &*it;
+}
+
+const ValueFlow::Value * Token::getInvalidValue(const Token *ftok, nonneg int argnr, const Settings &settings) const
+{
+    if (!mImpl->mValues)
         return nullptr;
     const ValueFlow::Value *ret = nullptr;
-    std::list<ValueFlow::Value>::const_iterator it;
-    for (it = mImpl->mValues->begin(); it != mImpl->mValues->end(); ++it) {
+    for (auto it = mImpl->mValues->begin(); it != mImpl->mValues->end(); ++it) {
         if (it->isImpossible())
             continue;
-        if ((it->isIntValue() && !settings->library.isIntArgValid(ftok, argnr, it->intvalue)) ||
-            (it->isFloatValue() && !settings->library.isFloatArgValid(ftok, argnr, it->floatValue))) {
+        if ((it->isIntValue() && !settings.library.isIntArgValid(ftok, argnr, it->intvalue, settings)) ||
+            (it->isFloatValue() && !settings.library.isFloatArgValid(ftok, argnr, it->floatValue, settings))) {
             if (!ret || ret->isInconclusive() || (ret->condition && !it->isInconclusive()))
                 ret = &(*it);
             if (!ret->isInconclusive() && !ret->condition)
@@ -1728,27 +1977,28 @@ const ValueFlow::Value * Token::getInvalidValue(const Token *ftok, nonneg int ar
         }
     }
     if (ret) {
-        if (ret->isInconclusive() && !settings->inconclusive)
+        if (ret->isInconclusive() && !settings.certainty.isEnabled(Certainty::inconclusive))
             return nullptr;
-        if (ret->condition && !settings->isEnabled(Settings::WARNING))
+        if (ret->condition && !settings.severity.isEnabled(Severity::warning))
             return nullptr;
     }
     return ret;
 }
 
-const Token *Token::getValueTokenMinStrSize() const
+const Token *Token::getValueTokenMinStrSize(const Settings &settings, MathLib::bigint* path) const
 {
     if (!mImpl->mValues)
         return nullptr;
     const Token *ret = nullptr;
     int minsize = INT_MAX;
-    std::list<ValueFlow::Value>::const_iterator it;
-    for (it = mImpl->mValues->begin(); it != mImpl->mValues->end(); ++it) {
+    for (auto it = mImpl->mValues->begin(); it != mImpl->mValues->end(); ++it) {
         if (it->isTokValue() && it->tokvalue && it->tokvalue->tokType() == Token::eString) {
-            const int size = getStrSize(it->tokvalue);
+            const int size = getStrSize(it->tokvalue, settings);
             if (!ret || size < minsize) {
                 minsize = size;
                 ret = it->tokvalue;
+                if (path)
+                    *path = it->path;
             }
         }
     }
@@ -1761,8 +2011,7 @@ const Token *Token::getValueTokenMaxStrLength() const
         return nullptr;
     const Token *ret = nullptr;
     int maxlength = 0;
-    std::list<ValueFlow::Value>::const_iterator it;
-    for (it = mImpl->mValues->begin(); it != mImpl->mValues->end(); ++it) {
+    for (auto it = mImpl->mValues->cbegin(); it != mImpl->mValues->end(); ++it) {
         if (it->isTokValue() && it->tokvalue && it->tokvalue->tokType() == Token::eString) {
             const int length = getStrLength(it->tokvalue);
             if (!ret || length > maxlength) {
@@ -1774,87 +2023,167 @@ const Token *Token::getValueTokenMaxStrLength() const
     return ret;
 }
 
-static const Scope *getfunctionscope(const Scope *s)
+static bool isAdjacent(const ValueFlow::Value& x, const ValueFlow::Value& y)
 {
-    while (s && s->type != Scope::eFunction)
-        s = s->nestedIn;
-    return s;
+    if (x.bound != ValueFlow::Value::Bound::Point && x.bound == y.bound)
+        return true;
+    if (x.valueType == ValueFlow::Value::ValueType::FLOAT)
+        return false;
+    return std::abs(x.intvalue - y.intvalue) == 1;
 }
 
-const Token *Token::getValueTokenDeadPointer() const
+static bool removePointValue(std::list<ValueFlow::Value>& values, std::list<ValueFlow::Value>::iterator& x)
 {
-    const Scope * const functionscope = getfunctionscope(this->scope());
-
-    std::list<ValueFlow::Value>::const_iterator it;
-    for (it = values().begin(); it != values().end(); ++it) {
-        // Is this a pointer alias?
-        if (!it->isTokValue() || (it->tokvalue && it->tokvalue->str() != "&"))
-            continue;
-        // Get variable
-        const Token *vartok = it->tokvalue->astOperand1();
-        if (!vartok || !vartok->isName() || !vartok->variable())
-            continue;
-        const Variable * const var = vartok->variable();
-        if (var->isStatic() || var->isReference())
-            continue;
-        if (!var->scope())
-            return nullptr; // #6804
-        if (var->scope()->type == Scope::eUnion && var->scope()->nestedIn == this->scope())
-            continue;
-        // variable must be in same function (not in subfunction)
-        if (functionscope != getfunctionscope(var->scope()))
-            continue;
-        // Is variable defined in this scope or upper scope?
-        const Scope *s = this->scope();
-        while ((s != nullptr) && (s != var->scope()))
-            s = s->nestedIn;
-        if (!s)
-            return it->tokvalue;
-    }
-    return nullptr;
+    const bool isPoint = x->bound == ValueFlow::Value::Bound::Point;
+    if (!isPoint)
+        x->decreaseRange();
+    else
+        x = values.erase(x);
+    return isPoint;
 }
 
 static bool removeContradiction(std::list<ValueFlow::Value>& values)
 {
     bool result = false;
-    for (ValueFlow::Value& x : values) {
-        if (x.isNonValue())
+    for (auto itx = values.begin(); itx != values.end(); ++itx) {
+        if (itx->isNonValue())
             continue;
-        for (ValueFlow::Value& y : values) {
-            if (y.isNonValue())
+
+        auto ity = itx;
+        ++ity;
+        for (; ity != values.end(); ++ity) {
+            if (ity->isNonValue())
                 continue;
-            if (x == y)
+            if (*itx == *ity)
                 continue;
-            if (x.valueType != y.valueType)
+            if (itx->valueType != ity->valueType)
                 continue;
-            if (x.isImpossible() == y.isImpossible())
+            if (itx->isImpossible() == ity->isImpossible())
                 continue;
-            if (!x.equalValue(y))
+            if (itx->isSymbolicValue() && !ValueFlow::Value::sameToken(itx->tokvalue, ity->tokvalue))
                 continue;
-            if (x.bound == y.bound ||
-                (x.bound != ValueFlow::Value::Bound::Point && y.bound != ValueFlow::Value::Bound::Point)) {
-                const bool removex = !x.isImpossible() || y.isKnown();
-                const bool removey = !y.isImpossible() || x.isKnown();
+            if (!itx->equalValue(*ity)) {
+                auto compare = [](const std::list<ValueFlow::Value>::const_iterator& x, const std::list<ValueFlow::Value>::const_iterator& y) {
+                    return x->compareValue(*y, less{});
+                };
+                auto itMax = std::max(itx, ity, compare);
+                auto itMin = std::min(itx, ity, compare);
+                // TODO: Adjust non-points instead of removing them
+                if (itMax->isImpossible() && itMax->bound == ValueFlow::Value::Bound::Upper) {
+                    values.erase(itMin);
+                    return true;
+                }
+                if (itMin->isImpossible() && itMin->bound == ValueFlow::Value::Bound::Lower) {
+                    values.erase(itMax);
+                    return true;
+                }
+                continue;
+            }
+            const bool removex = !itx->isImpossible() || ity->isKnown();
+            const bool removey = !ity->isImpossible() || itx->isKnown();
+            if (itx->bound == ity->bound) {
                 if (removex)
-                    values.remove(x);
+                    values.erase(itx);
                 if (removey)
-                    values.remove(y);
+                    values.erase(ity);
+                // itx and ity are invalidated
                 return true;
-            } else if (x.bound == ValueFlow::Value::Bound::Point) {
-                y.decreaseRange();
-                result = true;
             }
+            result = removex || removey;
+            bool bail = false;
+            if (removex && removePointValue(values, itx))
+                bail = true;
+            if (removey && removePointValue(values, ity))
+                bail = true;
+            if (bail)
+                return true;
         }
     }
     return result;
 }
 
+using ValueIterator = std::list<ValueFlow::Value>::iterator;
+
+template<class Iterator>
+// NOLINTNEXTLINE(performance-unnecessary-value-param) - false positive
+static ValueIterator removeAdjacentValues(std::list<ValueFlow::Value>& values, ValueIterator x, Iterator start, Iterator last)
+{
+    if (!isAdjacent(*x, **start))
+        return std::next(x);
+    auto it = std::adjacent_find(start, last, [](ValueIterator x, ValueIterator y) {
+        return !isAdjacent(*x, *y);
+    });
+    if (it == last)
+        it--;
+    (*it)->bound = x->bound;
+    std::for_each(std::move(start), std::move(it), [&](ValueIterator y) {
+        values.erase(y);
+    });
+    return values.erase(x);
+}
+
+static void mergeAdjacent(std::list<ValueFlow::Value>& values)
+{
+    for (auto x = values.begin(); x != values.end();) {
+        if (x->isNonValue()) {
+            x++;
+            continue;
+        }
+        if (x->bound == ValueFlow::Value::Bound::Point) {
+            x++;
+            continue;
+        }
+        std::vector<ValueIterator> adjValues;
+        for (auto y = values.begin(); y != values.end(); y++) {
+            if (x == y)
+                continue;
+            if (y->isNonValue())
+                continue;
+            if (x->valueType != y->valueType)
+                continue;
+            if (x->valueKind != y->valueKind)
+                continue;
+            if (x->isSymbolicValue() && !ValueFlow::Value::sameToken(x->tokvalue, y->tokvalue))
+                continue;
+            if (x->bound != y->bound) {
+                if (y->bound != ValueFlow::Value::Bound::Point && isAdjacent(*x, *y)) {
+                    adjValues.clear();
+                    break;
+                }
+                // No adjacent points for floating points
+                if (x->valueType == ValueFlow::Value::ValueType::FLOAT)
+                    continue;
+                if (y->bound != ValueFlow::Value::Bound::Point)
+                    continue;
+            }
+            if (x->bound == ValueFlow::Value::Bound::Lower && !y->compareValue(*x, less{}))
+                continue;
+            if (x->bound == ValueFlow::Value::Bound::Upper && !x->compareValue(*y, less{}))
+                continue;
+            adjValues.push_back(y);
+        }
+        if (adjValues.empty()) {
+            x++;
+            continue;
+        }
+        std::sort(adjValues.begin(), adjValues.end(), [&values](ValueIterator xx, ValueIterator yy) {
+            (void)values;
+            assert(xx != values.end() && yy != values.end());
+            return xx->compareValue(*yy, less{});
+        });
+        if (x->bound == ValueFlow::Value::Bound::Lower)
+            x = removeAdjacentValues(values, x, adjValues.rbegin(), adjValues.rend());
+        else if (x->bound == ValueFlow::Value::Bound::Upper)
+            x = removeAdjacentValues(values, x, adjValues.begin(), adjValues.end());
+    }
+}
+
 static void removeOverlaps(std::list<ValueFlow::Value>& values)
 {
-    for (ValueFlow::Value& x : values) {
+    for (const ValueFlow::Value& x : values) {
         if (x.isNonValue())
             continue;
-        values.remove_if([&](ValueFlow::Value& y) {
+        values.remove_if([&](const ValueFlow::Value& y) {
             if (y.isNonValue())
                 return false;
             if (&x == &y)
@@ -1863,7 +2192,7 @@ static void removeOverlaps(std::list<ValueFlow::Value>& values)
                 return false;
             if (x.valueKind != y.valueKind)
                 return false;
-            // TODO: Remove points coverd in a lower or upper bound
+            // TODO: Remove points covered in a lower or upper bound
             // TODO: Remove lower or upper bound already covered by a lower and upper bound
             if (!x.equalValue(y))
                 return false;
@@ -1872,12 +2201,14 @@ static void removeOverlaps(std::list<ValueFlow::Value>& values)
             return true;
         });
     }
+    mergeAdjacent(values);
 }
 
 // Removing contradictions is an NP-hard problem. Instead we run multiple
 // passes to try to catch most contradictions
 static void removeContradictions(std::list<ValueFlow::Value>& values)
 {
+    removeOverlaps(values);
     for (int i = 0; i < 4; i++) {
         if (!removeContradiction(values))
             return;
@@ -1885,15 +2216,37 @@ static void removeContradictions(std::list<ValueFlow::Value>& values)
     }
 }
 
+static bool sameValueType(const ValueFlow::Value& x, const ValueFlow::Value& y)
+{
+    if (x.valueType != y.valueType)
+        return false;
+    // Symbolic are the same type if they share the same tokvalue
+    if (x.isSymbolicValue())
+        return x.tokvalue->exprId() == 0 || x.tokvalue->exprId() == y.tokvalue->exprId();
+    return true;
+}
+
 bool Token::addValue(const ValueFlow::Value &value)
 {
     if (value.isKnown() && mImpl->mValues) {
         // Clear all other values of the same type since value is known
-        mImpl->mValues->remove_if([&](const ValueFlow::Value & x) {
-            return x.valueType == value.valueType;
+        mImpl->mValues->remove_if([&](const ValueFlow::Value& x) {
+            return sameValueType(x, value);
         });
     }
 
+    // Don't add a value if its already known
+    if (!value.isKnown() && mImpl->mValues &&
+        std::any_of(mImpl->mValues->begin(), mImpl->mValues->end(), [&](const ValueFlow::Value& x) {
+        return x.isKnown() && sameValueType(x, value) && !x.equalValue(value);
+    }))
+        return false;
+
+    // assert(value.isKnown() || !mImpl->mValues || std::none_of(mImpl->mValues->begin(), mImpl->mValues->end(),
+    // [&](const ValueFlow::Value& x) {
+    //     return x.isKnown() && sameValueType(x, value);
+    // }));
+
     if (mImpl->mValues) {
         // Don't handle more than 10 values for performance reasons
         // TODO: add setting?
@@ -1901,8 +2254,8 @@ bool Token::addValue(const ValueFlow::Value &value)
             return false;
 
         // if value already exists, don't add it again
-        std::list<ValueFlow::Value>::iterator it;
-        for (it = mImpl->mValues->begin(); it != mImpl->mValues->end(); ++it) {
+        auto it = mImpl->mValues->begin();
+        for (; it != mImpl->mValues->end(); ++it) {
             // different types => continue
             if (it->valueType != value.valueType)
                 continue;
@@ -1911,29 +2264,7 @@ bool Token::addValue(const ValueFlow::Value &value)
                 continue;
 
             // different value => continue
-            bool differentValue = true;
-            switch (it->valueType) {
-            case ValueFlow::Value::ValueType::INT:
-            case ValueFlow::Value::ValueType::CONTAINER_SIZE:
-            case ValueFlow::Value::ValueType::BUFFER_SIZE:
-                differentValue = (it->intvalue != value.intvalue);
-                break;
-            case ValueFlow::Value::ValueType::TOK:
-            case ValueFlow::Value::ValueType::LIFETIME:
-                differentValue = (it->tokvalue != value.tokvalue);
-                break;
-            case ValueFlow::Value::ValueType::FLOAT:
-                // TODO: Write some better comparison
-                differentValue = (it->floatValue > value.floatValue || it->floatValue < value.floatValue);
-                break;
-            case ValueFlow::Value::ValueType::MOVED:
-                differentValue = (it->moveKind != value.moveKind);
-                break;
-            case ValueFlow::Value::ValueType::UNINIT:
-                differentValue = false;
-                break;
-            }
-            if (differentValue)
+            if (!it->equalValue(value))
                 continue;
 
             if ((value.isTokValue() || value.isLifetimeValue()) && (it->tokvalue != value.tokvalue) && (it->tokvalue->str() != value.tokvalue->str()))
@@ -1957,15 +2288,16 @@ bool Token::addValue(const ValueFlow::Value &value)
             if (v.varId == 0)
                 v.varId = mImpl->mVarId;
             if (v.isKnown() && v.isIntValue())
-                mImpl->mValues->push_front(v);
+                mImpl->mValues->push_front(std::move(v));
             else
-                mImpl->mValues->push_back(v);
+                mImpl->mValues->push_back(std::move(v));
         }
     } else {
         ValueFlow::Value v(value);
         if (v.varId == 0)
             v.varId = mImpl->mVarId;
-        mImpl->mValues = new std::list<ValueFlow::Value>(1, v);
+        mImpl->mValues = new std::list<ValueFlow::Value>;
+        mImpl->mValues->push_back(std::move(v));
     }
 
     removeContradictions(*mImpl->mValues);
@@ -1980,11 +2312,12 @@ void Token::assignProgressValues(Token *tok)
         ++total_count;
     int count = 0;
     for (Token *tok2 = tok; tok2; tok2 = tok2->next())
-        tok2->mImpl->mProgressValue = count++ * 100 / total_count;
+        tok2->mImpl->mProgressValue = count++ *100 / total_count;
 }
 
 void Token::assignIndexes()
 {
+    // cppcheck-suppress shadowFunction - TODO: fix this
     int index = (mPrevious ? mPrevious->mImpl->mIndex : 0) + 1;
     for (Token *tok = this; tok; tok = tok->next())
         tok->mImpl->mIndex = index++;
@@ -1998,6 +2331,13 @@ void Token::setValueType(ValueType *vt)
     }
 }
 
+const ValueType *Token::argumentType() const {
+    const Token *top = this;
+    while (top && !Token::Match(top->astParent(), ",|("))
+        top = top->astParent();
+    return top ? top->mImpl->mValueType : nullptr;
+}
+
 void Token::type(const ::Type *t)
 {
     mImpl->mType = t;
@@ -2008,72 +2348,158 @@ void Token::type(const ::Type *t)
         tokType(eName);
 }
 
-const ::Type *Token::typeOf(const Token *tok)
+const ::Type* Token::typeOf(const Token* tok, const Token** typeTok)
 {
+    if (!tok)
+        return nullptr;
+    if (typeTok != nullptr)
+        *typeTok = tok;
+    const Token* lhsVarTok{};
+    if (tok->type())
+        return tok->type();
+    if (tok->variable())
+        return tok->variable()->type();
+    if (tok->function())
+        return tok->function()->retType;
     if (Token::simpleMatch(tok, "return")) {
+        // cppcheck-suppress shadowFunction - TODO: fix this
         const Scope *scope = tok->scope();
         if (!scope)
             return nullptr;
+        // cppcheck-suppress shadowFunction - TODO: fix this
         const Function *function = scope->function;
         if (!function)
             return nullptr;
         return function->retType;
-    } else if (Token::Match(tok, "%type%")) {
-        return tok->type();
-    } else if (Token::Match(tok, "%var%")) {
-        const Variable *var = tok->variable();
-        if (!var)
+    }
+    if (Token::Match(tok->previous(), "%type%|= (|{"))
+        return typeOf(tok->previous(), typeTok);
+    if (Token::simpleMatch(tok, "=") && (lhsVarTok = getLHSVariableToken(tok)) != tok->next())
+        return Token::typeOf(lhsVarTok, typeTok);
+    if (Token::simpleMatch(tok, "."))
+        return Token::typeOf(tok->astOperand2(), typeTok);
+    if (Token::simpleMatch(tok, "["))
+        return Token::typeOf(tok->astOperand1(), typeTok);
+    if (Token::simpleMatch(tok, "{")) {
+        int argnr;
+        const Token* ftok = getTokenArgumentFunction(tok, argnr);
+        if (argnr < 0)
             return nullptr;
-        return var->type();
-    } else if (Token::Match(tok, "%name%")) {
-        const Function *function = tok->function();
-        if (!function)
+        if (!ftok)
             return nullptr;
-        return function->retType;
-    } else if (Token::simpleMatch(tok, "=")) {
-        return Token::typeOf(tok->astOperand1());
-    } else if (Token::simpleMatch(tok, ".")) {
-        return Token::typeOf(tok->astOperand2());
-    } else if (Token::simpleMatch(tok, "[")) {
-        return Token::typeOf(tok->astOperand1());
+        if (ftok == tok)
+            return nullptr;
+        std::vector<const Variable*> vars = getArgumentVars(ftok, argnr);
+        if (vars.empty())
+            return nullptr;
+        if (std::all_of(
+                vars.cbegin(), vars.cend(), [&](const Variable* var) {
+            return var->type() == vars.front()->type();
+        }))
+            return vars.front()->type();
     }
+
     return nullptr;
 }
 
-std::pair<const Token*, const Token*> Token::typeDecl(const Token * tok)
+std::pair<const Token*, const Token*> Token::typeDecl(const Token* tok, bool pointedToType)
 {
-    if (Token::simpleMatch(tok, "return")) {
-        const Scope *scope = tok->scope();
-        if (!scope)
-            return {};
-        const Function *function = scope->function;
-        if (!function)
-            return {};
-        return {function->retDef, function->returnDefEnd()};
-    } else if (Token::Match(tok, "%type%")) {
+    if (!tok)
+        return {};
+    if (tok->type())
         return {tok, tok->next()};
-    } else if (Token::Match(tok, "%var%")) {
+    if (tok->variable()) {
         const Variable *var = tok->variable();
-        if (!var)
-            return {};
         if (!var->typeStartToken() || !var->typeEndToken())
             return {};
+        if (pointedToType && astIsSmartPointer(var->nameToken())) {
+            const ValueType* vt = var->valueType();
+            if (vt && vt->smartPointerTypeToken)
+                return { vt->smartPointerTypeToken, vt->smartPointerTypeToken->linkAt(-1) };
+        }
+        if (pointedToType && astIsIterator(var->nameToken())) {
+            const ValueType* vt = var->valueType();
+            if (vt && vt->containerTypeToken)
+                return { vt->containerTypeToken, vt->containerTypeToken->linkAt(-1) };
+        }
+        std::pair<const Token*, const Token*> result;
+        if (Token::simpleMatch(var->typeStartToken(), "auto")) {
+            const Token * tok2 = var->declEndToken();
+            if (Token::Match(tok2, "; %varid% =", var->declarationId()))
+                tok2 = tok2->tokAt(2);
+            if (Token::simpleMatch(tok2, "=") && Token::Match(tok2->astOperand2(), "!!=") && tok != tok2->astOperand2()) {
+                tok2 = tok2->astOperand2();
+
+                if (Token::simpleMatch(tok2, "[") && tok2->astOperand1()) {
+                    const ValueType* vt = tok2->astOperand1()->valueType();
+                    if (vt && vt->containerTypeToken)
+                        return { vt->containerTypeToken, vt->containerTypeToken->linkAt(-1) };
+                }
+
+                const Token* varTok = tok2; // try to find a variable
+                if (Token::Match(varTok, ":: %name%"))
+                    varTok = varTok->next();
+                while (Token::Match(varTok, "%name% ::"))
+                    varTok = varTok->tokAt(2);
+                std::pair<const Token*, const Token*> r = typeDecl(varTok);
+                if (r.first)
+                    return r;
+
+                if (pointedToType && tok2->astOperand1() && Token::simpleMatch(tok2, "new")) {
+                    if (Token::simpleMatch(tok2->astOperand1(), "("))
+                        return { tok2->next(), tok2->astOperand1() };
+                    const Token* declEnd = nextAfterAstRightmostLeaf(tok2->astOperand1());
+                    if (Token::simpleMatch(declEnd, "<") && declEnd->link())
+                        declEnd = declEnd->link()->next();
+                    return { tok2->next(), declEnd };
+                }
+                const Token *typeBeg{}, *typeEnd{};
+                if (tok2->str() == "::" && Token::simpleMatch(tok2->astOperand2(), "{")) { // empty initlist
+                    typeBeg = previousBeforeAstLeftmostLeaf(tok2);
+                    typeEnd = tok2->astOperand2();
+                }
+                else if (tok2->str() == "{") {
+                    typeBeg = previousBeforeAstLeftmostLeaf(tok2);
+                    typeEnd = tok2;
+                }
+                if (typeBeg && typeBeg != typeEnd)
+                    result = { typeBeg->next(), typeEnd }; // handle smart pointers/iterators first
+            }
+            if (astIsRangeBasedForDecl(var->nameToken()) && astIsContainer(var->nameToken()->astParent()->astOperand2())) { // range-based for
+                const ValueType* vt = var->nameToken()->astParent()->astOperand2()->valueType();
+                if (vt && vt->containerTypeToken)
+                    return { vt->containerTypeToken, vt->containerTypeToken->linkAt(-1) };
+            }
+        }
+        if (result.first)
+            return result;
         return {var->typeStartToken(), var->typeEndToken()->next()};
-    } else if (Token::Match(tok, "%name%")) {
-        const Function *function = tok->function();
+    }
+    if (Token::simpleMatch(tok, "return")) {
+        // cppcheck-suppress shadowFunction - TODO: fix this
+        const Scope* scope = tok->scope();
+        if (!scope)
+            return {};
+        // cppcheck-suppress shadowFunction - TODO: fix this
+        const Function* function = scope->function;
         if (!function)
             return {};
+        return { function->retDef, function->returnDefEnd() };
+    }
+    if (tok->previous() && tok->previous()->function()) {
+        // cppcheck-suppress shadowFunction - TODO: fix this
+        const Function *function = tok->previous()->function();
         return {function->retDef, function->returnDefEnd()};
-    } else if (Token::simpleMatch(tok, "=")) {
+    }
+    if (Token::simpleMatch(tok, "="))
         return Token::typeDecl(tok->astOperand1());
-    } else if (Token::simpleMatch(tok, ".")) {
+    if (Token::simpleMatch(tok, "."))
         return Token::typeDecl(tok->astOperand2());
-    } else {
-        const ::Type * t = typeOf(tok);
-        if (!t || !t->classDef)
-            return {};
-        return {t->classDef->next(), t->classDef->tokAt(2)};
-    }
+
+    const ::Type * t = typeOf(tok);
+    if (!t || !t->classDef)
+        return {};
+    return {t->classDef->next(), t->classDef->tokAt(2)};
 }
 std::string Token::typeStr(const Token* tok)
 {
@@ -2091,33 +2517,156 @@ std::string Token::typeStr(const Token* tok)
 
 void Token::scopeInfo(std::shared_ptr<ScopeInfo2> newScopeInfo)
 {
-    mImpl->mScopeInfo = newScopeInfo;
+    mImpl->mScopeInfo = std::move(newScopeInfo);
 }
 std::shared_ptr<ScopeInfo2> Token::scopeInfo() const
 {
     return mImpl->mScopeInfo;
 }
 
-TokenImpl::~TokenImpl()
+// if there is a known INT value it will always be the first entry
+bool Token::hasKnownIntValue() const
+{
+    if (!mImpl->mValues)
+        return false;
+    if (mImpl->mValues->empty())
+        return false;
+    const ValueFlow::Value& value = mImpl->mValues->front();
+    return value.isIntValue() && value.isKnown();
+}
+
+bool Token::hasKnownValue() const
+{
+    return mImpl->mValues && std::any_of(mImpl->mValues->begin(), mImpl->mValues->end(), std::mem_fn(&ValueFlow::Value::isKnown));
+}
+
+bool Token::hasKnownValue(ValueFlow::Value::ValueType t) const
+{
+    return mImpl->mValues &&
+           std::any_of(mImpl->mValues->begin(), mImpl->mValues->end(), [&](const ValueFlow::Value& value) {
+        return value.isKnown() && value.valueType == t;
+    });
+}
+
+bool Token::hasKnownSymbolicValue(const Token* tok) const
+{
+    if (tok->exprId() == 0)
+        return false;
+    return mImpl->mValues &&
+           std::any_of(mImpl->mValues->begin(), mImpl->mValues->end(), [&](const ValueFlow::Value& value) {
+        return value.isKnown() && value.isSymbolicValue() && value.tokvalue &&
+               value.tokvalue->exprId() == tok->exprId();
+    });
+}
+
+const ValueFlow::Value* Token::getKnownValue(ValueFlow::Value::ValueType t) const
+{
+    if (!mImpl->mValues)
+        return nullptr;
+    if (mImpl->mValues->empty())
+        return nullptr;
+    // known INT values are always the first entry
+    if (t == ValueFlow::Value::ValueType::INT) {
+        const auto& v = mImpl->mValues->front();
+        if (!v.isKnown() || !v.isIntValue())
+            return nullptr;
+        return &v;
+    }
+    auto it = std::find_if(mImpl->mValues->begin(), mImpl->mValues->end(), [&](const ValueFlow::Value& value) {
+        return value.isKnown() && value.valueType == t;
+    });
+    return it == mImpl->mValues->end() ? nullptr : &*it;
+}
+
+const ValueFlow::Value* Token::getValue(const MathLib::bigint val) const
+{
+    if (!mImpl->mValues)
+        return nullptr;
+    const auto it = std::find_if(mImpl->mValues->begin(), mImpl->mValues->end(), [=](const ValueFlow::Value& value) {
+        return value.isIntValue() && !value.isImpossible() && value.intvalue == val;
+    });
+    return it == mImpl->mValues->end() ? nullptr : &*it;
+}
+
+template<class Compare>
+static const ValueFlow::Value* getCompareValue(const std::list<ValueFlow::Value>& values,
+                                               bool condition,
+                                               MathLib::bigint path,
+                                               Compare compare)
 {
+    const ValueFlow::Value* ret = nullptr;
+    for (const ValueFlow::Value& value : values) {
+        if (!value.isIntValue())
+            continue;
+        if (value.isImpossible())
+            continue;
+        if (path > -0 && value.path != 0 && value.path != path)
+            continue;
+        if ((!ret || compare(value.intvalue, ret->intvalue)) && ((value.condition != nullptr) == condition))
+            ret = &value;
+    }
+    return ret;
+}
+
+const ValueFlow::Value* Token::getMaxValue(bool condition, MathLib::bigint path) const
+{
+    if (!mImpl->mValues)
+        return nullptr;
+    return getCompareValue(*mImpl->mValues, condition, path, std::greater<MathLib::bigint>{});
+}
+
+const ValueFlow::Value* Token::getMinValue(bool condition, MathLib::bigint path) const
+{
+    if (!mImpl->mValues)
+        return nullptr;
+    return getCompareValue(*mImpl->mValues, condition, path, std::less<MathLib::bigint>{});
+}
+
+const ValueFlow::Value* Token::getMovedValue() const
+{
+    if (!mImpl->mValues)
+        return nullptr;
+    const auto it = std::find_if(mImpl->mValues->begin(), mImpl->mValues->end(), [](const ValueFlow::Value& value) {
+        return value.isMovedValue() && !value.isImpossible() &&
+               value.moveKind != ValueFlow::Value::MoveKind::NonMovedVariable;
+    });
+    return it == mImpl->mValues->end() ? nullptr : &*it;
+}
+
+const ValueFlow::Value* Token::getContainerSizeValue(const MathLib::bigint val) const
+{
+    if (!mImpl->mValues)
+        return nullptr;
+    const auto it = std::find_if(mImpl->mValues->begin(), mImpl->mValues->end(), [=](const ValueFlow::Value& value) {
+        return value.isContainerSizeValue() && !value.isImpossible() && value.intvalue == val;
+    });
+    return it == mImpl->mValues->end() ? nullptr : &*it;
+}
+
+Token::Impl::~Impl()
+{
+    delete mMacroName;
     delete mOriginalName;
     delete mValueType;
     delete mValues;
 
-    for (auto templateSimplifierPointer : mTemplateSimplifierPointers) {
-        templateSimplifierPointer->token(nullptr);
+    if (mTemplateSimplifierPointers) {
+        for (auto *p : *mTemplateSimplifierPointers) {
+            p->token(nullptr);
+        }
     }
+    delete mTemplateSimplifierPointers;
 
     while (mCppcheckAttributes) {
-        struct CppcheckAttributes *c = mCppcheckAttributes;
+        CppcheckAttributes *c = mCppcheckAttributes;
         mCppcheckAttributes = mCppcheckAttributes->next;
         delete c;
     }
 }
 
-void TokenImpl::setCppcheckAttribute(TokenImpl::CppcheckAttributes::Type type, MathLib::bigint value)
+void Token::Impl::setCppcheckAttribute(CppcheckAttributesType type, MathLib::bigint value)
 {
-    struct CppcheckAttributes *attr = mCppcheckAttributes;
+    CppcheckAttributes *attr = mCppcheckAttributes;
     while (attr && attr->type != type)
         attr = attr->next;
     if (attr)
@@ -2131,12 +2680,83 @@ void TokenImpl::setCppcheckAttribute(TokenImpl::CppcheckAttributes::Type type, M
     }
 }
 
-bool TokenImpl::getCppcheckAttribute(TokenImpl::CppcheckAttributes::Type type, MathLib::bigint *value) const
+bool Token::Impl::getCppcheckAttribute(CppcheckAttributesType type, MathLib::bigint &value) const
 {
-    struct CppcheckAttributes *attr = mCppcheckAttributes;
+    const CppcheckAttributes *attr = mCppcheckAttributes;
     while (attr && attr->type != type)
         attr = attr->next;
     if (attr)
-        *value = attr->value;
+        value = attr->value;
     return attr != nullptr;
 }
+
+Token* findTypeEnd(Token* tok)
+{
+    while (Token::Match(tok, "%name%|.|::|*|&|&&|<|(|template|decltype|sizeof")) {
+        if (Token::Match(tok, "(|<"))
+            tok = tok->link();
+        if (!tok)
+            return nullptr;
+        tok = tok->next();
+    }
+    return tok;
+}
+
+Token* findLambdaEndScope(Token* tok)
+{
+    if (!Token::simpleMatch(tok, "["))
+        return nullptr;
+    tok = tok->link();
+    if (!Token::Match(tok, "] (|{"))
+        return nullptr;
+    tok = tok->linkAt(1);
+    if (Token::simpleMatch(tok, "}"))
+        return tok;
+    if (Token::simpleMatch(tok, ") {"))
+        return tok->linkAt(1);
+    if (!Token::simpleMatch(tok, ")"))
+        return nullptr;
+    tok = tok->next();
+    while (Token::Match(tok, "mutable|constexpr|consteval|noexcept|.")) {
+        if (Token::simpleMatch(tok, "noexcept ("))
+            tok = tok->linkAt(1);
+        if (Token::simpleMatch(tok, ".")) {
+            tok = findTypeEnd(tok);
+            break;
+        }
+        tok = tok->next();
+    }
+    if (Token::simpleMatch(tok, "{"))
+        return tok->link();
+    return nullptr;
+}
+const Token* findLambdaEndScope(const Token* tok) {
+    return findLambdaEndScope(const_cast<Token*>(tok));
+}
+
+void Token::templateArgFrom(const Token* fromToken) {
+    setFlag(fIsTemplateArg, fromToken != nullptr);
+    mImpl->mTemplateArgFileIndex = fromToken ? fromToken->mImpl->mFileIndex : -1;
+    mImpl->mTemplateArgLineNumber = fromToken ? fromToken->mImpl->mLineNumber : -1;
+    mImpl->mTemplateArgColumn = fromToken ? fromToken->mImpl->mColumn : -1;
+}
+
+const SmallVector<ReferenceToken>& Token::refs(bool temporary) const
+{
+    if (temporary) {
+        if (!mImpl->mRefsTemp)
+            mImpl->mRefsTemp.reset(new SmallVector<ReferenceToken>(followAllReferences(this, true)));
+        return *mImpl->mRefsTemp;
+    }
+
+    if (!mImpl->mRefs)
+        mImpl->mRefs.reset(new SmallVector<ReferenceToken>(followAllReferences(this, false)));
+    return *mImpl->mRefs;
+}
+
+bool Token::isMutableExpr() const
+{
+    if (mImpl->mMutableExpr == -1)
+        mImpl->mMutableExpr = isMutableExpression(this);
+    return !!mImpl->mMutableExpr;
+}
diff --git a/lib/token.h b/lib/token.h
index d9f80645f3e..51fe1b6b7d0 100644
--- a/lib/token.h
+++ b/lib/token.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,131 +22,49 @@
 //---------------------------------------------------------------------------
 
 #include "config.h"
+#include "errortypes.h"
 #include "mathlib.h"
-#include "valueflow.h"
+#include "smallvector.h"
 #include "templatesimplifier.h"
 #include "utils.h"
+#include "vfvalue.h"
 
 #include <algorithm>
+#include <cassert>
+#include <cstdint>
 #include <cstddef>
 #include <functional>
+#include <limits>
 #include <list>
 #include <memory>
 #include <ostream>
+#include <set>
 #include <string>
+#include <type_traits>
+#include <utility>
 #include <vector>
 
-class Enumerator;
+struct Enumerator;
 class Function;
 class Scope;
 class Settings;
 class Type;
 class ValueType;
 class Variable;
-
-/**
- * @brief This struct stores pointers to the front and back tokens of the list this token is in.
- */
-struct TokensFrontBack {
-    Token *front;
-    Token *back;
-};
+class ConstTokenRange;
+class Token;
+struct TokensFrontBack;
+class TokenList;
+struct ReferenceToken;
 
 struct ScopeInfo2 {
-    ScopeInfo2(const std::string &name_, const Token *bodyEnd_, const std::set<std::string> &usingNamespaces_ = std::set<std::string>()) : name(name_), bodyEnd(bodyEnd_), usingNamespaces(usingNamespaces_) {}
+    ScopeInfo2(std::string name_, const Token *bodyEnd_, std::set<std::string> usingNamespaces_ = std::set<std::string>()) : name(std::move(name_)), bodyEnd(bodyEnd_), usingNamespaces(std::move(usingNamespaces_)) {}
     std::string name;
-    const Token * const bodyEnd;
+    const Token* const bodyEnd{};
     std::set<std::string> usingNamespaces;
 };
 
-struct TokenImpl {
-    nonneg int mVarId;
-    nonneg int mFileIndex;
-    nonneg int mLineNumber;
-    nonneg int mColumn;
-
-    // AST..
-    Token *mAstOperand1;
-    Token *mAstOperand2;
-    Token *mAstParent;
-
-    // symbol database information
-    const Scope *mScope;
-    union {
-        const Function *mFunction;
-        const Variable *mVariable;
-        const ::Type* mType;
-        const Enumerator *mEnumerator;
-    };
-
-    /**
-     * A value from 0-100 that provides a rough idea about where in the token
-     * list this token is located.
-     */
-    nonneg int mProgressValue;
-
-    /**
-     * Token index. Position in token list
-     */
-    nonneg int mIndex;
-
-    // original name like size_t
-    std::string* mOriginalName;
-
-    // ValueType
-    ValueType *mValueType;
-
-    // ValueFlow
-    std::list<ValueFlow::Value>* mValues;
-    static const std::list<ValueFlow::Value> mEmptyValueList;
-
-    /** Bitfield bit count. */
-    unsigned char mBits;
-
-    // Pointer to a template in the template simplifier
-    std::set<TemplateSimplifier::TokenAndName*> mTemplateSimplifierPointers;
-
-    // Pointer to the object representing this token's scope
-    std::shared_ptr<ScopeInfo2> mScopeInfo;
-
-    // __cppcheck_in_range__
-    struct CppcheckAttributes {
-        enum Type {LOW,HIGH} type;
-        MathLib::bigint value;
-        struct CppcheckAttributes *next;
-    };
-    struct CppcheckAttributes *mCppcheckAttributes;
-
-    // For memoization, to speed up parsing of huge arrays #8897
-    enum class Cpp11init {UNKNOWN, CPP11INIT, NOINIT} mCpp11init;
-
-    void setCppcheckAttribute(CppcheckAttributes::Type type, MathLib::bigint value);
-    bool getCppcheckAttribute(CppcheckAttributes::Type type, MathLib::bigint *value) const;
-
-    TokenImpl()
-        : mVarId(0)
-        , mFileIndex(0)
-        , mLineNumber(0)
-        , mColumn(0)
-        , mAstOperand1(nullptr)
-        , mAstOperand2(nullptr)
-        , mAstParent(nullptr)
-        , mScope(nullptr)
-        , mFunction(nullptr) // Initialize whole union
-        , mProgressValue(0)
-        , mIndex(0)
-        , mOriginalName(nullptr)
-        , mValueType(nullptr)
-        , mValues(nullptr)
-        , mBits(0)
-        , mTemplateSimplifierPointers()
-        , mScopeInfo(nullptr)
-        , mCppcheckAttributes(nullptr)
-        , mCpp11init(Cpp11init::UNKNOWN)
-    {}
-
-    ~TokenImpl();
-};
+enum class TokenDebug : std::uint8_t { None, ValueFlow, ValueType };
 
 /// @addtogroup Core
 /// @{
@@ -162,15 +80,120 @@ struct TokenImpl {
  * The Token class also has other functions for management of token list, matching tokens, etc.
  */
 class CPPCHECKLIB Token {
+
+public:
+    enum CppcheckAttributesType : std::uint8_t { LOW, HIGH };
+    enum class Cpp11init : std::uint8_t { UNKNOWN, CPP11INIT, NOINIT };
+
 private:
-    TokensFrontBack* mTokensFrontBack;
+    struct Impl {
+        nonneg int mVarId{};
+        nonneg int mFileIndex{};
+        nonneg int mLineNumber{};
+        nonneg int mColumn{};
+        nonneg int mExprId{};
+
+        // original template argument location
+        int mTemplateArgFileIndex{-1};
+        int mTemplateArgLineNumber{-1};
+        int mTemplateArgColumn{-1};
+
+        /**
+         * A value from 0-100 that provides a rough idea about where in the token
+         * list this token is located.
+         */
+        nonneg int mProgressValue{};
+
+        /**
+         * Token index. Position in token list
+         */
+        nonneg int mIndex{};
+
+        /** Bitfield bit count. */
+        short mBits = -1;
+
+        // AST..
+        Token* mAstOperand1{};
+        Token* mAstOperand2{};
+        Token* mAstParent{};
+        Token* mAstTop{};
+
+        // symbol database information
+        const Scope* mScope{};
+        union {
+            const Function *mFunction{};
+            const Variable *mVariable;
+            const ::Type* mType;
+            const Enumerator *mEnumerator;
+        };
+
+        // original name like size_t
+        std::string* mOriginalName{};
+
+        // If this token came from a macro replacement list, this is the name of that macro
+        std::string* mMacroName{};
+
+        // ValueType
+        ValueType* mValueType{};
+
+        // ValueFlow
+        std::list<ValueFlow::Value>* mValues{};
+
+        // Pointer to a template in the template simplifier
+        std::set<TemplateSimplifier::TokenAndName*>* mTemplateSimplifierPointers{};
+
+        // Pointer to the object representing this token's scope
+        std::shared_ptr<ScopeInfo2> mScopeInfo;
+
+        // __cppcheck_in_range__
+        struct CppcheckAttributes {
+            CppcheckAttributesType type{LOW};
+            MathLib::bigint value{};
+            CppcheckAttributes* next{};
+        };
+        CppcheckAttributes* mCppcheckAttributes{};
+
+        // alignas expressions
+        std::unique_ptr<std::vector<std::string>> mAttributeAlignas;
+        void addAttributeAlignas(const std::string& a) {
+            if (!mAttributeAlignas)
+                mAttributeAlignas = std::unique_ptr<std::vector<std::string>>(new std::vector<std::string>());
+            if (std::find(mAttributeAlignas->cbegin(), mAttributeAlignas->cend(), a) == mAttributeAlignas->cend())
+                mAttributeAlignas->push_back(a);
+        }
 
-    // Not implemented..
-    Token(const Token &);
-    Token operator=(const Token &);
+        std::string mAttributeCleanup;
+
+        // For memoization, to speed up parsing of huge arrays #8897
+        Cpp11init mCpp11init{Cpp11init::UNKNOWN};
+
+        TokenDebug mDebug{};
+
+        std::unique_ptr<SmallVector<ReferenceToken>> mRefs;
+        std::unique_ptr<SmallVector<ReferenceToken>> mRefsTemp;
+
+        std::int8_t mMutableExpr{-1};
+
+        void setCppcheckAttribute(CppcheckAttributesType type, MathLib::bigint value);
+        bool getCppcheckAttribute(CppcheckAttributesType type, MathLib::bigint &value) const;
+
+        Impl() = default;
+        ~Impl();
+
+        Impl(const Impl &) = delete;
+        Impl operator=(const Impl &) = delete;
+    };
+
+    const TokenList& mList;
+    std::shared_ptr<TokensFrontBack> mTokensFrontBack;
+
+    static const std::string mEmptyString;
 
 public:
-    enum Type {
+    Token(const Token &) = delete;
+    Token& operator=(const Token &) = delete;
+
+    enum Type : std::uint8_t {
         eVariable, eType, eFunction, eKeyword, eName, // Names: Variable (varId), Type (typeId, later), Function (FuncId, later), Language keyword, Name (unknown identifier)
         eNumber, eString, eChar, eBoolean, eLiteral, eEnumerator, // Literals: Number, String, Character, Boolean, User defined literal (C++11), Enumerator
         eArithmeticalOp, eComparisonOp, eAssignmentOp, eLogicalOp, eBitOp, eIncDecOp, eExtendedOp, // Operators: Arithmetical, Comparison, Assignment, Logical, Bitwise, ++/--, Extended
@@ -181,9 +204,13 @@ class CPPCHECKLIB Token {
         eNone
     };
 
-    explicit Token(TokensFrontBack *tokensFrontBack = nullptr);
+    Token(const TokenList& tokenlist, std::shared_ptr<TokensFrontBack> tokensFrontBack);
+    // for usage in CheckIO::ArgumentInfo only
+    explicit Token(const Token *tok);
     ~Token();
 
+    ConstTokenRange until(const Token * t) const;
+
     template<typename T>
     void str(T&& s) {
         mStr = s;
@@ -208,8 +235,8 @@ class CPPCHECKLIB Token {
     void deleteNext(nonneg int count = 1);
 
     /**
-    * Unlink and delete the previous 'count' tokens.
-    */
+     * Unlink and delete the previous 'count' tokens.
+     */
     void deletePrevious(nonneg int count = 1);
 
     /**
@@ -222,25 +249,37 @@ class CPPCHECKLIB Token {
      * For example index 1 would return next token, and 2
      * would return next from that one.
      */
-    const Token *tokAt(int index) const;
-    Token *tokAt(int index) {
-        return const_cast<Token *>(const_cast<const Token *>(this)->tokAt(index));
+    const Token *tokAt(int index) const
+    {
+        return tokAtImpl(this, index);
+    }
+    Token *tokAt(int index)
+    {
+        return tokAtImpl(this, index);
     }
 
     /**
      * @return the link to the token in given index, related to this token.
      * For example index 1 would return the link to next token.
      */
-    const Token *linkAt(int index) const;
-    Token *linkAt(int index) {
-        return const_cast<Token *>(const_cast<const Token *>(this)->linkAt(index));
+    const Token *linkAt(int index) const
+    {
+        return linkAtImpl(this, index);
+    }
+    Token *linkAt(int index)
+    {
+        return linkAtImpl(this, index);
     }
 
     /**
      * @return String of the token in given index, related to this token.
      * If that token does not exist, an empty string is being returned.
      */
-    const std::string &strAt(int index) const;
+    const std::string &strAt(int index) const
+    {
+        const Token *tok = this->tokAt(index);
+        return tok ? tok->mStr : mEmptyString;
+    }
 
     /**
      * Match given token (or list of tokens) to a pattern list.
@@ -261,7 +300,12 @@ class CPPCHECKLIB Token {
      * @return true if given token matches with given pattern
      *         false if given token does not match with given pattern
      */
-    static bool simpleMatch(const Token *tok, const char pattern[]);
+    template<size_t count>
+    static bool simpleMatch(const Token *tok, const char (&pattern)[count]) {
+        return simpleMatch(tok, pattern, count-1);
+    }
+
+    static bool simpleMatch(const Token *tok, const char pattern[], size_t pattern_len);
 
     /**
      * Match given token (or list of tokens) to a pattern list.
@@ -273,18 +317,18 @@ class CPPCHECKLIB Token {
      * - "%char%" Any token enclosed in &apos;-character.
      * - "%comp%" Any token such that isComparisonOp() returns true.
      * - "%cop%" Any token such that isConstOp() returns true.
-     * - "%name%" any token which is a name, variable or type e.g. "hello" or "int"
+     * - "%name%" any token which is a name, variable or type e.g. "hello" or "int". Also matches keywords.
      * - "%num%" Any numeric token, e.g. "23"
      * - "%op%" Any token such that isOp() returns true.
      * - "%or%" A bitwise-or operator '|'
      * - "%oror%" A logical-or operator '||'
-     * - "%type%" Anything that can be a variable type, e.g. "int", but not "delete".
+     * - "%type%" Anything that can be a variable type, e.g. "int". Also matches keywords.
      * - "%str%" Any token starting with &quot;-character (C-string).
      * - "%var%" Match with token with varId > 0
      * - "%varid%" Match with parameter varid
      * - "[abc]" Any of the characters 'a' or 'b' or 'c'
      * - "int|void|char" Any of the strings, int, void or char
-     * - "int|void|char|" Any of the strings, int, void or char or empty string
+     * - "int|void|char|" Any of the strings, int, void or char or no token
      * - "!!else" No tokens or any token that is not "else".
      * - "someRandomText" If token contains "someRandomText".
      *
@@ -318,35 +362,30 @@ class CPPCHECKLIB Token {
     static nonneg int getStrLength(const Token *tok);
 
     /**
-     * @return sizeof of C-string.
+     * @return array length of C-string.
      *
      * Should be called for %%str%% tokens only.
      *
      * @param tok token with C-string
      **/
-    static nonneg int getStrSize(const Token *tok);
+    static nonneg int getStrArraySize(const Token *tok);
 
     /**
-     * @return char of C-string at index (possible escaped "\\n")
+     * @return sizeof of C-string.
      *
      * Should be called for %%str%% tokens only.
      *
      * @param tok token with C-string
-     * @param index position of character
+     * @param settings Settings
      **/
-    static std::string getCharAt(const Token *tok, MathLib::bigint index);
+    static nonneg int getStrSize(const Token *tok, const Settings & settings);
 
     const ValueType *valueType() const {
         return mImpl->mValueType;
     }
     void setValueType(ValueType *vt);
 
-    const ValueType *argumentType() const {
-        const Token *top = this;
-        while (top && !Token::Match(top->astParent(), ",|("))
-            top = top->astParent();
-        return top ? top->mImpl->mValueType : nullptr;
-    }
+    const ValueType *argumentType() const;
 
     Token::Type tokType() const {
         return mTokType;
@@ -363,12 +402,6 @@ class CPPCHECKLIB Token {
                                         mTokType == eBoolean || mTokType == eLiteral || mTokType == eEnumerator);
         setFlag(fIsLiteral, memoizedIsLiteral);
     }
-    void isKeyword(const bool kwd) {
-        if (kwd)
-            tokType(eKeyword);
-        else if (mTokType == eKeyword)
-            tokType(eName);
-    }
     bool isKeyword() const {
         return mTokType == eKeyword;
     }
@@ -388,6 +421,9 @@ class CPPCHECKLIB Token {
     bool isEnumerator() const {
         return mTokType == eEnumerator;
     }
+    bool isVariable() const {
+        return mTokType == eVariable;
+    }
     bool isOp() const {
         return (isConstOp() ||
                 isAssignmentOp() ||
@@ -415,6 +451,9 @@ class CPPCHECKLIB Token {
     bool isBoolean() const {
         return mTokType == eBoolean;
     }
+    bool isIncDecOp() const {
+        return mTokType == eIncDecOp;
+    }
     bool isBinaryOp() const {
         return astOperand1() != nullptr && astOperand2() != nullptr;
     }
@@ -423,10 +462,10 @@ class CPPCHECKLIB Token {
     }
     bool isUnaryPreOp() const;
 
-    unsigned int flags() const {
+    uint64_t flags() const {
         return mFlags;
     }
-    void flags(const unsigned int flags_) {
+    void flags(const uint64_t flags_) {
         mFlags = flags_;
     }
     bool isUnsigned() const {
@@ -441,6 +480,7 @@ class CPPCHECKLIB Token {
     void isSigned(const bool sign) {
         setFlag(fIsSigned, sign);
     }
+    // cppcheck-suppress unusedFunction
     bool isPointerCompare() const {
         return getFlag(fIsPointerCompare);
     }
@@ -460,10 +500,7 @@ class CPPCHECKLIB Token {
         setFlag(fIsStandardType, b);
     }
     bool isExpandedMacro() const {
-        return getFlag(fIsExpandedMacro);
-    }
-    void isExpandedMacro(const bool m) {
-        setFlag(fIsExpandedMacro, m);
+        return !!mImpl->mMacroName;
     }
     bool isCast() const {
         return getFlag(fIsCast);
@@ -519,6 +556,12 @@ class CPPCHECKLIB Token {
     void isAttributeNothrow(const bool value) {
         setFlag(fIsAttributeNothrow, value);
     }
+    bool isAttributeExport() const {
+        return getFlag(fIsAttributeExport);
+    }
+    void isAttributeExport(const bool value) {
+        setFlag(fIsAttributeExport, value);
+    }
     bool isAttributePacked() const {
         return getFlag(fIsAttributePacked);
     }
@@ -531,12 +574,46 @@ class CPPCHECKLIB Token {
     void isAttributeNodiscard(const bool value) {
         setFlag(fIsAttributeNodiscard, value);
     }
-    void setCppcheckAttribute(TokenImpl::CppcheckAttributes::Type type, MathLib::bigint value) {
+    bool isAttributeMaybeUnused() const {
+        return getFlag(fIsAttributeMaybeUnused);
+    }
+    void isAttributeMaybeUnused(const bool value) {
+        setFlag(fIsAttributeMaybeUnused, value);
+    }
+    bool isAttributeFallthrough() const {
+        return getFlag(fIsAttributeFallthrough);
+    }
+    void isAttributeFallthrough(const bool value) {
+        setFlag(fIsAttributeFallthrough, value);
+    }
+    std::vector<std::string> getAttributeAlignas() const {
+        return mImpl->mAttributeAlignas ? *mImpl->mAttributeAlignas : std::vector<std::string>();
+    }
+    bool hasAttributeAlignas() const {
+        return !!mImpl->mAttributeAlignas;
+    }
+    void addAttributeAlignas(const std::string& a) {
+        mImpl->addAttributeAlignas(a);
+    }
+    void addAttributeCleanup(const std::string& funcname) {
+        mImpl->mAttributeCleanup = funcname;
+    }
+    const std::string& getAttributeCleanup() const {
+        return mImpl->mAttributeCleanup;
+    }
+    bool hasAttributeCleanup() const {
+        return !mImpl->mAttributeCleanup.empty();
+    }
+    void setCppcheckAttribute(CppcheckAttributesType type, MathLib::bigint value) {
         mImpl->setCppcheckAttribute(type, value);
     }
-    bool getCppcheckAttribute(TokenImpl::CppcheckAttributes::Type type, MathLib::bigint *value) const {
+    bool getCppcheckAttribute(CppcheckAttributesType type, MathLib::bigint &value) const {
         return mImpl->getCppcheckAttribute(type, value);
     }
+    // cppcheck-suppress unusedFunction
+    bool hasCppcheckAttributes() const {
+        return nullptr != mImpl->mCppcheckAttributes;
+    }
     bool isControlFlowKeyword() const {
         return getFlag(fIsControlFlowKeyword);
     }
@@ -571,6 +648,20 @@ class CPPCHECKLIB Token {
         setFlag(fIncompleteVar, b);
     }
 
+    bool isSimplifiedTypedef() const {
+        return getFlag(fIsSimplifiedTypedef);
+    }
+    void isSimplifiedTypedef(bool b) {
+        setFlag(fIsSimplifiedTypedef, b);
+    }
+
+    bool isIncompleteConstant() const {
+        return getFlag(fIsIncompleteConstant);
+    }
+    void isIncompleteConstant(bool b) {
+        setFlag(fIsIncompleteConstant, b);
+    }
+
     bool isConstexpr() const {
         return getFlag(fConstexpr);
     }
@@ -578,21 +669,154 @@ class CPPCHECKLIB Token {
         setFlag(fConstexpr, b);
     }
 
+    bool isExternC() const {
+        return getFlag(fExternC);
+    }
+    void isExternC(bool b) {
+        setFlag(fExternC, b);
+    }
+
+    bool isSplittedVarDeclComma() const {
+        return getFlag(fIsSplitVarDeclComma);
+    }
+    void isSplittedVarDeclComma(bool b) {
+        setFlag(fIsSplitVarDeclComma, b);
+    }
+
+    bool isSplittedVarDeclEq() const {
+        return getFlag(fIsSplitVarDeclEq);
+    }
+    void isSplittedVarDeclEq(bool b) {
+        setFlag(fIsSplitVarDeclEq, b);
+    }
+
+    bool isImplicitInt() const {
+        return getFlag(fIsImplicitInt);
+    }
+    void isImplicitInt(bool b) {
+        setFlag(fIsImplicitInt, b);
+    }
+
+    bool isInline() const {
+        return getFlag(fIsInline);
+    }
+    void isInline(bool b) {
+        setFlag(fIsInline, b);
+    }
+
+    bool isAtomic() const {
+        return getFlag(fIsAtomic);
+    }
+    void isAtomic(bool b) {
+        setFlag(fIsAtomic, b);
+    }
+
+    bool isRestrict() const {
+        return getFlag(fIsRestrict);
+    }
+    void isRestrict(bool b) {
+        setFlag(fIsRestrict, b);
+    }
+
+    bool isRemovedVoidParameter() const {
+        return getFlag(fIsRemovedVoidParameter);
+    }
+    void setRemovedVoidParameter(bool b) {
+        setFlag(fIsRemovedVoidParameter, b);
+    }
+
+    bool isTemplate() const {
+        return getFlag(fIsTemplate);
+    }
+    void isTemplate(bool b) {
+        setFlag(fIsTemplate, b);
+    }
+
+    bool isSimplifiedScope() const {
+        return getFlag(fIsSimplifedScope);
+    }
+    void isSimplifiedScope(bool b) {
+        setFlag(fIsSimplifedScope, b);
+    }
+
+    bool isFinalType() const {
+        return getFlag(fIsFinalType);
+    }
+    void isFinalType(bool b) {
+        setFlag(fIsFinalType, b);
+    }
+
+    bool isInitComma() const {
+        return getFlag(fIsInitComma);
+    }
+    void isInitComma(bool b) {
+        setFlag(fIsInitComma, b);
+    }
 
+    bool isInitBracket() const {
+        return getFlag(fIsInitBracket);
+    }
+    void isInitBracket(bool b) {
+        setFlag(fIsInitBracket, b);
+    }
+
+    bool isAnonymous() const {
+        return getFlag(fIsAnonymous);
+    }
+    void isAnonymous(bool b) {
+        setFlag(fIsAnonymous, b);
+    }
+
+    // cppcheck-suppress unusedFunction
     bool isBitfield() const {
-        return mImpl->mBits > 0;
+        return mImpl->mBits >= 0;
     }
-    unsigned char bits() const {
+    short bits() const {
         return mImpl->mBits;
     }
-    std::set<TemplateSimplifier::TokenAndName*> &templateSimplifierPointers() const {
+    const std::set<TemplateSimplifier::TokenAndName*>* templateSimplifierPointers() const {
+        return mImpl->mTemplateSimplifierPointers;
+    }
+    std::set<TemplateSimplifier::TokenAndName*>* templateSimplifierPointers() {
         return mImpl->mTemplateSimplifierPointers;
     }
     void templateSimplifierPointer(TemplateSimplifier::TokenAndName* tokenAndName) {
-        mImpl->mTemplateSimplifierPointers.insert(tokenAndName);
+        if (!mImpl->mTemplateSimplifierPointers)
+            mImpl->mTemplateSimplifierPointers = new std::set<TemplateSimplifier::TokenAndName*>;
+        mImpl->mTemplateSimplifierPointers->insert(tokenAndName);
+    }
+    bool setBits(const MathLib::bigint b) {
+        const MathLib::bigint max = std::numeric_limits<short>::max();
+        if (b > max) {
+            mImpl->mBits = static_cast<short>(max);
+            return false;
+        }
+        mImpl->mBits = b < 0 ? -1 : static_cast<short>(b);
+        return true;
+    }
+
+    bool isUtf8() const {
+        return (((mTokType == eString) && isPrefixStringCharLiteral(mStr, '"', "u8")) ||
+                ((mTokType == eChar) && isPrefixStringCharLiteral(mStr, '\'', "u8")));
+    }
+
+    bool isUtf16() const {
+        return (((mTokType == eString) && isPrefixStringCharLiteral(mStr, '"', "u")) ||
+                ((mTokType == eChar) && isPrefixStringCharLiteral(mStr, '\'', "u")));
+    }
+
+    bool isUtf32() const {
+        return (((mTokType == eString) && isPrefixStringCharLiteral(mStr, '"', "U")) ||
+                ((mTokType == eChar) && isPrefixStringCharLiteral(mStr, '\'', "U")));
     }
-    void setBits(const unsigned char b) {
-        mImpl->mBits = b;
+
+    bool isCChar() const {
+        return (((mTokType == eString) && isPrefixStringCharLiteral(mStr, '"', "")) ||
+                ((mTokType == eChar) && isPrefixStringCharLiteral(mStr, '\'', "") && (replaceEscapeSequences(getCharLiteral(mStr)).size() == 1)));
+    }
+
+    bool isCMultiChar() const {
+        return (mTokType == eChar) && isPrefixStringCharLiteral(mStr, '\'', "") && (replaceEscapeSequences(getCharLiteral(mStr)).size() > 1);
     }
 
     /**
@@ -615,27 +839,85 @@ class CPPCHECKLIB Token {
     bool isTemplateArg() const {
         return getFlag(fIsTemplateArg);
     }
-    void isTemplateArg(const bool value) {
-        setFlag(fIsTemplateArg, value);
+    void templateArgFrom(const Token* fromToken);
+    int templateArgFileIndex() const {
+        return mImpl->mTemplateArgFileIndex;
+    }
+    int templateArgLineNumber() const {
+        return mImpl->mTemplateArgLineNumber;
+    }
+    int templateArgColumn() const {
+        return mImpl->mTemplateArgColumn;
+    }
+
+    const std::string& getMacroName() const {
+        return mImpl->mMacroName ? *mImpl->mMacroName : mEmptyString;
+    }
+    void setMacroName(std::string name) {
+        if (!mImpl->mMacroName)
+            mImpl->mMacroName = new std::string(std::move(name));
+        else
+            *mImpl->mMacroName = std::move(name);
     }
 
-    static const Token *findsimplematch(const Token * const startTok, const char pattern[]);
-    static const Token *findsimplematch(const Token * const startTok, const char pattern[], const Token * const end);
-    static const Token *findmatch(const Token * const startTok, const char pattern[], const nonneg int varId = 0);
-    static const Token *findmatch(const Token * const startTok, const char pattern[], const Token * const end, const nonneg int varId = 0);
-    static Token *findsimplematch(Token * const startTok, const char pattern[]) {
-        return const_cast<Token *>(findsimplematch(const_cast<const Token *>(startTok), pattern));
+    template<size_t count>
+    static const Token *findsimplematch(const Token * const startTok, const char (&pattern)[count]) {
+        return findsimplematch(startTok, pattern, count-1);
     }
-    static Token *findsimplematch(Token * const startTok, const char pattern[], const Token * const end) {
-        return const_cast<Token *>(findsimplematch(const_cast<const Token *>(startTok), pattern, end));
+    static const Token *findsimplematch(const Token * startTok, const char pattern[], size_t pattern_len);
+
+    template<size_t count>
+    static const Token *findsimplematch(const Token * const startTok, const char (&pattern)[count], const Token * const end) {
+        return findsimplematch(startTok, pattern, count-1, end);
     }
-    static Token *findmatch(Token * const startTok, const char pattern[], const nonneg int varId = 0) {
-        return const_cast<Token *>(findmatch(const_cast<const Token *>(startTok), pattern, varId));
+    static const Token *findsimplematch(const Token * startTok, const char pattern[], size_t pattern_len, const Token * end);
+
+    static const Token *findmatch(const Token * startTok, const char pattern[], nonneg int varId = 0);
+    static const Token *findmatch(const Token * startTok, const char pattern[], const Token * end, nonneg int varId = 0);
+
+    template<size_t count>
+    static Token *findsimplematch(Token * const startTok, const char (&pattern)[count]) {
+        return findsimplematch(startTok, pattern, count-1);
     }
-    static Token *findmatch(Token * const startTok, const char pattern[], const Token * const end, const nonneg int varId = 0) {
-        return const_cast<Token *>(findmatch(const_cast<const Token *>(startTok), pattern, end, varId));
+    static Token *findsimplematch(Token * startTok, const char pattern[], size_t pattern_len);
+    template<size_t count>
+    static Token *findsimplematch(Token * const startTok, const char (&pattern)[count], const Token * const end) {
+        return findsimplematch(startTok, pattern, count-1, end);
     }
+    static Token *findsimplematch(Token * startTok, const char pattern[], size_t pattern_len, const Token * end);
+
+    static Token *findmatch(Token * startTok, const char pattern[], nonneg int varId = 0);
+    static Token *findmatch(Token * startTok, const char pattern[], const Token * end, nonneg int varId = 0);
 
+private:
+    template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+    static T *tokAtImpl(T *tok, int index)
+    {
+        while (index > 0 && tok) {
+            tok = tok->next();
+            --index;
+        }
+        while (index < 0 && tok) {
+            tok = tok->previous();
+            ++index;
+        }
+        return tok;
+    }
+
+    /**
+     * @throws InternalError thrown if index is out of range
+     */
+    template<class T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+    static T *linkAtImpl(T *thisTok, int index)
+    {
+        T *tok = thisTok->tokAt(index);
+        if (!tok) {
+            throw InternalError(thisTok, "Internal error. Token::linkAt called with index outside the tokens range.");
+        }
+        return tok->link();
+    }
+
+protected:
     /**
      * Needle is build from multiple alternatives. If one of
      * them is equal to haystack, return value is 1. If there
@@ -652,6 +934,7 @@ class CPPCHECKLIB Token {
      */
     static int multiCompare(const Token *tok, const char *haystack, nonneg int varid);
 
+public:
     nonneg int fileIndex() const {
         return mImpl->mFileIndex;
     }
@@ -673,10 +956,13 @@ class CPPCHECKLIB Token {
         mImpl->mColumn = c;
     }
 
-    Token *next() const {
+    Token* next() {
         return mNext;
     }
 
+    const Token* next() const {
+        return mNext;
+    }
 
     /**
      * Delete tokens between begin and end. E.g. if begin = 1
@@ -687,51 +973,115 @@ class CPPCHECKLIB Token {
      */
     static void eraseTokens(Token *begin, const Token *end);
 
+    /**
+     * Insert new token after this token. This function will handle
+     * relations between next and previous token also.
+     * @param tokenStr String for the new token.
+     */
+    RET_NONNULL Token* insertToken(const std::string& tokenStr)
+    {
+        return insertToken(tokenStr, false);
+    }
+    /**
+     * Insert new token after this token. This function will handle
+     * relations between next and previous token also.
+     * @param tokenStr String for the new token.
+     * @param originalNameStr String used for Token::originalName().
+     */
+    RET_NONNULL Token* insertToken(const std::string& tokenStr, const std::string& originalNameStr)
+    {
+        return insertToken(tokenStr, originalNameStr, false);
+    }
     /**
      * Insert new token after this token. This function will handle
      * relations between next and previous token also.
      * @param tokenStr String for the new token.
      * @param originalNameStr String used for Token::originalName().
-     * @param prepend Insert the new token before this token when it's not
-     * the first one on the tokens list.
+     * @param macroNameStr String used for Token::getMacroName().
      */
-    void insertToken(const std::string &tokenStr, const std::string &originalNameStr=emptyString, bool prepend=false);
+    RET_NONNULL Token* insertToken(const std::string& tokenStr, const std::string& originalNameStr, const std::string& macroNameStr)
+    {
+        return insertToken(tokenStr, originalNameStr, macroNameStr, false);
+    }
 
-    Token *previous() const {
+    RET_NONNULL Token* insertTokenBefore(const std::string& tokenStr)
+    {
+        return insertToken(tokenStr, true);
+    }
+    RET_NONNULL Token* insertTokenBefore(const std::string& tokenStr, const std::string& originalNameStr)
+    {
+        return insertToken(tokenStr, originalNameStr, true);
+    }
+    RET_NONNULL Token* insertTokenBefore(const std::string& tokenStr, const std::string& originalNameStr, const std::string& macroNameStr)
+    {
+        return insertToken(tokenStr, originalNameStr, macroNameStr, true);
+    }
+
+    Token* previous() {
         return mPrevious;
     }
 
+    const Token* previous() const {
+        return mPrevious;
+    }
 
     nonneg int varId() const {
         return mImpl->mVarId;
     }
     void varId(nonneg int id) {
+        if (mImpl->mVarId == id)
+            return;
+
         mImpl->mVarId = id;
-        if (id != 0) {
-            tokType(eVariable);
-            isStandardType(false);
-        } else {
-            update_property_info();
-        }
+        update_property_info();
+    }
+
+    nonneg int exprId() const {
+        if (mImpl->mExprId)
+            return mImpl->mExprId;
+        return mImpl->mVarId;
+    }
+    void exprId(nonneg int id) {
+        mImpl->mExprId = id;
+    }
+
+    void setUniqueExprId()
+    {
+        assert(mImpl->mExprId > 0);
+        mImpl->mExprId |= 1 << efIsUnique;
     }
 
+    bool isUniqueExprId() const
+    {
+        return (mImpl->mExprId & (1 << efIsUnique)) != 0;
+    }
+
+    /**
+     * For debugging purposes, prints token and all tokens followed by it.
+     */
+    void printOut() const;
+
     /**
-     * For debugging purposes, prints token and all tokens
-     * followed by it.
+     * For debugging purposes, prints token and all tokens followed by it.
      * @param title Title for the printout or use default parameter or 0
      * for no title.
      */
-    void printOut(const char *title = nullptr) const;
+    void printOut(std::ostream& out, const char *title = nullptr) const;
 
     /**
-     * For debugging purposes, prints token and all tokens
-     * followed by it.
+     * For debugging purposes, prints token and all tokens followed by it.
+     * @param xml print in XML format
      * @param title Title for the printout or use default parameter or 0
      * for no title.
      * @param fileNames Prints out file name instead of file index.
      * File index should match the index of the string in this vector.
      */
-    void printOut(const char *title, const std::vector<std::string> &fileNames) const;
+    void printOut(std::ostream& out, bool xml, const char *title, const std::vector<std::string> &fileNames) const;
+
+    /**
+     * print out tokens - used for debugging
+     */
+    void printLines(std::ostream& out, int lines=5) const;
 
     /**
      * Replace token replaceThis with tokens between start and end,
@@ -742,18 +1092,61 @@ class CPPCHECKLIB Token {
      */
     static void replace(Token *replaceThis, Token *start, Token *end);
 
+    struct stringifyOptions {
+        bool varid = false;
+        bool exprid = false;
+        bool idtype = false; // distinguish varid / exprid
+        bool attributes = false;
+        bool macro = false;
+        bool linenumbers = false;
+        bool linebreaks = false;
+        bool files = false;
+        static stringifyOptions forDebug() {
+            stringifyOptions options;
+            options.attributes = true;
+            options.macro = true;
+            options.linenumbers = true;
+            options.linebreaks = true;
+            options.files = true;
+            return options;
+        }
+        // cppcheck-suppress unusedFunction
+        static stringifyOptions forDebugVarId() {
+            stringifyOptions options = forDebug();
+            options.varid = true;
+            return options;
+        }
+        static stringifyOptions forDebugExprId() {
+            stringifyOptions options = forDebug();
+            options.exprid = true;
+            return options;
+        }
+        static stringifyOptions forPrintOut() {
+            stringifyOptions options = forDebug();
+            options.exprid = true;
+            options.varid = true;
+            options.idtype = true;
+            return options;
+        }
+    };
+
+    std::string stringify(const stringifyOptions& options) const;
+
     /**
      * Stringify a token
-     * @param os The result is shifted into that output stream
-     * @param varid Print varids. (Style: "varname@id")
+     * @param varid Print varids. (Style: "varname\@id")
      * @param attributes Print attributes of tokens like "unsigned" in front of it.
      * @param macro Prints $ in front of the token if it was expanded from a macro.
      */
-    void stringify(std::ostream& os, bool varid, bool attributes, bool macro) const;
+    std::string stringify(bool varid, bool attributes, bool macro) const;
+
+    std::string stringifyList(const stringifyOptions& options, const std::vector<std::string>* fileNames = nullptr, const Token* end = nullptr) const;
+    std::string stringifyList(const Token* end, bool attributes = true) const;
+    std::string stringifyList(bool varid = false) const;
 
     /**
      * Stringify a list of token, from current instance on.
-     * @param varid Print varids. (Style: "varname@id")
+     * @param varid Print varids. (Style: "varname\@id")
      * @param attributes Print attributes of tokens like "unsigned" in front of it.
      * @param linenumbers Print line number in front of each line
      * @param linebreaks Insert "\\n" into string when line number changes
@@ -763,8 +1156,6 @@ class CPPCHECKLIB Token {
      * @return Stringified token list as a string
      */
     std::string stringifyList(bool varid, bool attributes, bool linenumbers, bool linebreaks, bool files, const std::vector<std::string>* fileNames = nullptr, const Token* end = nullptr) const;
-    std::string stringifyList(const Token* end, bool attributes = true) const;
-    std::string stringifyList(bool varid = false) const;
 
     /**
      * Remove the contents for this token from the token list.
@@ -782,6 +1173,9 @@ class CPPCHECKLIB Token {
      * to.
      */
     void link(Token *linkToToken) {
+        if (mLink == linkToToken)
+            return;
+
         mLink = linkToToken;
         if (mStr == "<" || mStr == ">")
             update_property_info();
@@ -796,7 +1190,11 @@ class CPPCHECKLIB Token {
      *
      * @return The token where this token links to.
      */
-    Token *link() const {
+    const Token* link() const {
+        return mLink;
+    }
+
+    Token* link() {
         return mLink;
     }
 
@@ -848,27 +1246,33 @@ class CPPCHECKLIB Token {
     }
 
     /**
-    * Associate this token with given type
-    * @param t Type to be associated
-    */
+     * Associate this token with given type
+     * @param t Type to be associated
+     */
     void type(const ::Type *t);
 
     /**
-    * @return a pointer to the type associated with this token.
-    */
+     * @return a pointer to the type associated with this token.
+     */
     const ::Type *type() const {
         return mTokType == eType ? mImpl->mType : nullptr;
     }
 
-    static const ::Type *typeOf(const Token *tok);
+    static const ::Type* typeOf(const Token* tok, const Token** typeTok = nullptr);
 
-    static std::pair<const Token*, const Token*> typeDecl(const Token * tok);
+    /**
+     * @return the declaration associated with this token.
+     * @param pointedToType return the pointed-to type?
+     */
+    static std::pair<const Token*, const Token*> typeDecl(const Token* tok, bool pointedToType = false);
 
     static std::string typeStr(const Token* tok);
 
+    static bool isStandardType(const std::string& str);
+
     /**
-    * @return a pointer to the Enumerator associated with this token.
-    */
+     * @return a pointer to the Enumerator associated with this token.
+     */
     const Enumerator *enumerator() const {
         return mTokType == eEnumerator ? mImpl->mEnumerator : nullptr;
     }
@@ -918,23 +1322,24 @@ class CPPCHECKLIB Token {
     /**
      * @return the first token of the next argument. Does only work on argument
      * lists. Requires that Tokenizer::createLinks2() has been called before.
-     * Returns 0, if there is no next argument.
+     * Returns nullptr, if there is no next argument.
      */
-    Token* nextArgument() const;
+    const Token* nextArgument() const;
+    Token *nextArgument();
 
     /**
      * @return the first token of the next argument. Does only work on argument
      * lists. Should be used only before Tokenizer::createLinks2() was called.
-     * Returns 0, if there is no next argument.
+     * Returns nullptr, if there is no next argument.
      */
-    Token* nextArgumentBeforeCreateLinks2() const;
+    const Token* nextArgumentBeforeCreateLinks2() const;
 
     /**
-    * @return the first token of the next template argument. Does only work on template argument
-    * lists. Requires that Tokenizer::createLinks2() has been called before.
-    * Returns 0, if there is no next argument.
-    */
-    Token* nextTemplateArgument() const;
+     * @return the first token of the next template argument. Does only work on template argument
+     * lists. Requires that Tokenizer::createLinks2() has been called before.
+     * Returns nullptr, if there is no next argument.
+     */
+    const Token* nextTemplateArgument() const;
 
     /**
      * Returns the closing bracket of opening '<'. Should only be used if link()
@@ -951,13 +1356,19 @@ class CPPCHECKLIB Token {
      * @return the original name.
      */
     const std::string & originalName() const {
-        return mImpl->mOriginalName ? *mImpl->mOriginalName : emptyString;
+        return mImpl->mOriginalName ? *mImpl->mOriginalName : mEmptyString;
     }
 
     const std::list<ValueFlow::Value>& values() const {
-        return mImpl->mValues ? *mImpl->mValues : TokenImpl::mEmptyValueList;
+        return mImpl->mValues ? *mImpl->mValues : mEmptyValueList;
     }
 
+    // provides and caches result of a followAllReferences() call
+    const SmallVector<ReferenceToken>& refs(bool temporary = true) const;
+
+    // provides and caches the result of a isMutableExpression() call
+    bool isMutableExpr() const;
+
     /**
      * Sets the original name.
      */
@@ -969,83 +1380,43 @@ class CPPCHECKLIB Token {
             *mImpl->mOriginalName = name;
     }
 
-    bool hasKnownIntValue() const {
-        if (!mImpl->mValues)
-            return false;
-        return std::any_of(mImpl->mValues->begin(), mImpl->mValues->end(), [](const ValueFlow::Value &value) {
-            return value.isKnown() && value.isIntValue();
-        });
-    }
-
-    bool hasKnownValue() const {
-        return mImpl->mValues && std::any_of(mImpl->mValues->begin(), mImpl->mValues->end(), std::mem_fn(&ValueFlow::Value::isKnown));
-    }
+    bool hasKnownIntValue() const;
+    bool hasKnownValue() const;
+    bool hasKnownValue(ValueFlow::Value::ValueType t) const;
+    bool hasKnownSymbolicValue(const Token* tok) const;
 
+    const ValueFlow::Value* getKnownValue(ValueFlow::Value::ValueType t) const;
     MathLib::bigint getKnownIntValue() const {
+        assert(!mImpl->mValues->empty());
+        assert(mImpl->mValues->front().isKnown());
+        assert(mImpl->mValues->front().valueType == ValueFlow::Value::ValueType::INT);
         return mImpl->mValues->front().intvalue;
     }
 
-    const ValueFlow::Value * getValue(const MathLib::bigint val) const {
-        if (!mImpl->mValues)
-            return nullptr;
-        const auto it = std::find_if(mImpl->mValues->begin(), mImpl->mValues->end(), [=](const ValueFlow::Value& value) {
-            return value.isIntValue() && !value.isImpossible() && value.intvalue == val;
-        });
-        return it == mImpl->mValues->end() ? nullptr : &*it;;
-    }
+    const ValueFlow::Value* getValue(MathLib::bigint val) const;
 
-    const ValueFlow::Value * getMaxValue(bool condition) const {
-        if (!mImpl->mValues)
-            return nullptr;
-        const ValueFlow::Value *ret = nullptr;
-        for (const ValueFlow::Value &value : *mImpl->mValues) {
-            if (!value.isIntValue())
-                continue;
-            if (value.isImpossible())
-                continue;
-            if ((!ret || value.intvalue > ret->intvalue) &&
-                ((value.condition != nullptr) == condition))
-                ret = &value;
-        }
-        return ret;
-    }
+    const ValueFlow::Value* getMaxValue(bool condition, MathLib::bigint path = 0) const;
+    const ValueFlow::Value* getMinValue(bool condition, MathLib::bigint path = 0) const;
 
-    const ValueFlow::Value * getMovedValue() const {
-        if (!mImpl->mValues)
-            return nullptr;
-        const auto it = std::find_if(mImpl->mValues->begin(), mImpl->mValues->end(), [](const ValueFlow::Value& value) {
-            return value.isMovedValue() && !value.isImpossible() &&
-                   value.moveKind != ValueFlow::Value::MoveKind::NonMovedVariable;
-        });
-        return it == mImpl->mValues->end() ? nullptr : &*it;;
-    }
+    const ValueFlow::Value* getMovedValue() const;
 
-    const ValueFlow::Value * getValueLE(const MathLib::bigint val, const Settings *settings) const;
-    const ValueFlow::Value * getValueGE(const MathLib::bigint val, const Settings *settings) const;
+    const ValueFlow::Value * getValueLE(MathLib::bigint val, const Settings &settings) const;
+    const ValueFlow::Value * getValueGE(MathLib::bigint val, const Settings &settings) const;
+    const ValueFlow::Value * getValueNE(MathLib::bigint val) const;
 
-    const ValueFlow::Value * getInvalidValue(const Token *ftok, nonneg int argnr, const Settings *settings) const;
+    const ValueFlow::Value * getInvalidValue(const Token *ftok, nonneg int argnr, const Settings &settings) const;
 
-    const ValueFlow::Value * getContainerSizeValue(const MathLib::bigint val) const {
-        if (!mImpl->mValues)
-            return nullptr;
-        const auto it = std::find_if(mImpl->mValues->begin(), mImpl->mValues->end(), [=](const ValueFlow::Value& value) {
-            return value.isContainerSizeValue() && !value.isImpossible() && value.intvalue == val;
-        });
-        return it == mImpl->mValues->end() ? nullptr : &*it;
-    }
+    const ValueFlow::Value* getContainerSizeValue(MathLib::bigint val) const;
 
     const Token *getValueTokenMaxStrLength() const;
-    const Token *getValueTokenMinStrSize() const;
-
-    const Token *getValueTokenDeadPointer() const;
+    const Token *getValueTokenMinStrSize(const Settings &settings, MathLib::bigint* path = nullptr) const;
 
     /** Add token value. Return true if value is added. */
     bool addValue(const ValueFlow::Value &value);
 
-    template<class Predicate>
-    void removeValues(Predicate pred) {
+    void removeValues(std::function<bool(const ValueFlow::Value &)> pred) {
         if (mImpl->mValues)
-            mImpl->mValues->remove_if(pred);
+            mImpl->mValues->remove_if(std::move(pred));
     }
 
     nonneg int index() const {
@@ -1055,6 +1426,7 @@ class CPPCHECKLIB Token {
     void assignIndexes();
 
 private:
+    static const std::list<ValueFlow::Value> mEmptyValueList;
 
     void next(Token *nextToken) {
         mNext = nextToken;
@@ -1080,54 +1452,82 @@ class CPPCHECKLIB Token {
      */
     static const char *chrInFirstWord(const char *str, char c);
 
+    RET_NONNULL Token* insertToken(const std::string& tokenStr, bool prepend);
+    RET_NONNULL Token* insertToken(const std::string& tokenStr, const std::string& originalNameStr, bool prepend);
+    RET_NONNULL Token* insertToken(const std::string& tokenStr, const std::string& originalNameStr, const std::string& macroNameStr, bool prepend);
+
     std::string mStr;
 
-    Token *mNext;
-    Token *mPrevious;
-    Token *mLink;
-
-    enum {
-        fIsUnsigned             = (1 << 0),
-        fIsSigned               = (1 << 1),
-        fIsPointerCompare       = (1 << 2),
-        fIsLong                 = (1 << 3),
-        fIsStandardType         = (1 << 4),
-        fIsExpandedMacro        = (1 << 5),
-        fIsCast                 = (1 << 6),
-        fIsAttributeConstructor = (1 << 7),  // __attribute__((constructor)) __attribute__((constructor(priority)))
-        fIsAttributeDestructor  = (1 << 8),  // __attribute__((destructor))  __attribute__((destructor(priority)))
-        fIsAttributeUnused      = (1 << 9),  // __attribute__((unused))
-        fIsAttributePure        = (1 << 10), // __attribute__((pure))
-        fIsAttributeConst       = (1 << 11), // __attribute__((const))
-        fIsAttributeNoreturn    = (1 << 12), // __attribute__((noreturn)), __declspec(noreturn)
-        fIsAttributeNothrow     = (1 << 13), // __attribute__((nothrow)), __declspec(nothrow)
-        fIsAttributeUsed        = (1 << 14), // __attribute__((used))
-        fIsAttributePacked      = (1 << 15), // __attribute__((packed))
-        fIsControlFlowKeyword   = (1 << 16), // if/switch/while/...
-        fIsOperatorKeyword      = (1 << 17), // operator=, etc
-        fIsComplex              = (1 << 18), // complex/_Complex type
-        fIsEnumType             = (1 << 19), // enumeration type
-        fIsName                 = (1 << 20),
-        fIsLiteral              = (1 << 21),
-        fIsTemplateArg          = (1 << 22),
-        fIsAttributeNodiscard   = (1 << 23), // __attribute__ ((warn_unused_result)), [[nodiscard]]
-        fAtAddress              = (1 << 24), // @ 0x4000
-        fIncompleteVar          = (1 << 25),
-        fConstexpr              = (1 << 26),
+    Token* mNext{};
+    Token* mPrevious{};
+    Token* mLink{};
+
+    enum : uint64_t {
+        fIsUnsigned             = (1ULL << 0),
+        fIsSigned               = (1ULL << 1),
+        fIsPointerCompare       = (1ULL << 2),
+        fIsLong                 = (1ULL << 3),
+        fIsStandardType         = (1ULL << 4),
+        //fIsExpandedMacro        = (1ULL << 5),
+        fIsCast                 = (1ULL << 6),
+        fIsAttributeConstructor = (1ULL << 7),  // __attribute__((constructor)) __attribute__((constructor(priority)))
+        fIsAttributeDestructor  = (1ULL << 8),  // __attribute__((destructor))  __attribute__((destructor(priority)))
+        fIsAttributeUnused      = (1ULL << 9),  // __attribute__((unused))
+        fIsAttributePure        = (1ULL << 10), // __attribute__((pure))
+        fIsAttributeConst       = (1ULL << 11), // __attribute__((const))
+        fIsAttributeNoreturn    = (1ULL << 12), // __attribute__((noreturn)), __declspec(noreturn)
+        fIsAttributeNothrow     = (1ULL << 13), // __attribute__((nothrow)), __declspec(nothrow)
+        fIsAttributeUsed        = (1ULL << 14), // __attribute__((used))
+        fIsAttributePacked      = (1ULL << 15), // __attribute__((packed))
+        fIsAttributeExport      = (1ULL << 16), // __attribute__((__visibility__("default"))), __declspec(dllexport)
+        fIsAttributeMaybeUnused = (1ULL << 17), // [[maybe_unused]]
+        fIsAttributeNodiscard   = (1ULL << 18), // __attribute__ ((warn_unused_result)), [[nodiscard]]
+        fIsAttributeFallthrough = (1ULL << 19), // [[__fallthrough__]], [[fallthrough]]
+        fIsControlFlowKeyword   = (1ULL << 20), // if/switch/while/...
+        fIsOperatorKeyword      = (1ULL << 21), // operator=, etc
+        fIsComplex              = (1ULL << 22), // complex/_Complex type
+        fIsEnumType             = (1ULL << 23), // enumeration type
+        fIsName                 = (1ULL << 24),
+        fIsLiteral              = (1ULL << 25),
+        fIsTemplateArg          = (1ULL << 26),
+        fAtAddress              = (1ULL << 27), // @ 0x4000
+        fIncompleteVar          = (1ULL << 28),
+        fConstexpr              = (1ULL << 29),
+        fExternC                = (1ULL << 30),
+        fIsSplitVarDeclComma    = (1ULL << 31), // set to true when variable declarations are split up ('int a,b;' => 'int a; int b;')
+        fIsSplitVarDeclEq       = (1ULL << 32), // set to true when variable declaration with initialization is split up ('int a=5;' => 'int a; a=5;')
+        fIsImplicitInt          = (1ULL << 33), // Is "int" token implicitly added?
+        fIsInline               = (1ULL << 34), // Is this a inline type
+        fIsTemplate             = (1ULL << 35),
+        fIsSimplifedScope       = (1ULL << 36), // scope added when simplifying e.g. if (int i = ...; ...)
+        fIsRemovedVoidParameter = (1ULL << 37), // A void function parameter has been removed
+        fIsIncompleteConstant   = (1ULL << 38),
+        fIsRestrict             = (1ULL << 39), // Is this a restrict pointer type
+        fIsAtomic               = (1ULL << 40), // Is this a _Atomic declaration
+        fIsSimplifiedTypedef    = (1ULL << 41),
+        fIsFinalType            = (1ULL << 42), // Is this a type with final specifier
+        fIsInitComma            = (1ULL << 43), // Is this comma located inside some {..}. i.e: {1,2,3,4}
+        fIsInitBracket          = (1ULL << 44), // Is this bracket used as a part of variable initialization i.e: int a{5}, b(2);
+        fIsAnonymous            = (1ULL << 45), // Is this a token added for an unnamed member
+    };
+
+    enum : std::uint8_t {
+        efMaxSize = sizeof(nonneg int) * 8,
+        efIsUnique = efMaxSize - 2,
     };
 
-    Token::Type mTokType;
+    Token::Type mTokType = eNone;
 
-    unsigned int mFlags;
+    uint64_t mFlags{};
 
-    TokenImpl *mImpl;
+    Impl* mImpl{};
 
     /**
      * Get specified flag state.
      * @param flag_ flag to get state of
      * @return true if flag set or false in flag not set
      */
-    bool getFlag(unsigned int flag_) const {
+    bool getFlag(uint64_t flag_) const {
         return ((mFlags & flag_) != 0);
     }
 
@@ -1136,26 +1536,36 @@ class CPPCHECKLIB Token {
      * @param flag_ flag to set state
      * @param state_ new state of flag
      */
-    void setFlag(unsigned int flag_, bool state_) {
+    void setFlag(uint64_t flag_, bool state_) {
         mFlags = state_ ? mFlags | flag_ : mFlags & ~flag_;
     }
 
     /** Updates internal property cache like _isName or _isBoolean.
-        Called after any mStr() modification. */
+        Called after any mStr() modification.
+        @throws InternalError thrown if a bool literal has a varid
+     */
     void update_property_info();
 
     /** Update internal property cache about isStandardType() */
     void update_property_isStandardType();
 
-    /** Update internal property cache about string and char literals */
-    void update_property_char_string_literal();
-
     /** Internal helper function to avoid excessive string allocations */
-    void astStringVerboseRecursive(std::string& ret, const nonneg int indent1 = 0, const nonneg int indent2 = 0) const;
+    void astStringVerboseRecursive(std::string& ret, nonneg int indent1 = 0, nonneg int indent2 = 0) const;
+
+    // cppcheck-suppress premium-misra-cpp-2023-12.2.1
+    bool mIsC : 1;
+    bool mIsCpp : 1;
 
 public:
     void astOperand1(Token *tok);
     void astOperand2(Token *tok);
+    /**
+     * @throws InternalError thrown on cyclic dependency
+     */
+    void astParent(Token* tok);
+    void astTop(Token * tok) {
+        mImpl->mAstTop = tok;
+    }
 
     Token * astOperand1() {
         return mImpl->mAstOperand1;
@@ -1175,20 +1585,49 @@ class CPPCHECKLIB Token {
     const Token * astParent() const {
         return mImpl->mAstParent;
     }
-    Token *astTop() {
+    Token * astSibling() {
+        if (!astParent())
+            return nullptr;
+        if (this == astParent()->astOperand1())
+            return astParent()->astOperand2();
+        if (this == astParent()->astOperand2())
+            return astParent()->astOperand1();
+        return nullptr;
+
+    }
+    const Token * astSibling() const {
+        if (!astParent())
+            return nullptr;
+        if (this == astParent()->astOperand1())
+            return astParent()->astOperand2();
+        if (this == astParent()->astOperand2())
+            return astParent()->astOperand1();
+        return nullptr;
+
+    }
+    RET_NONNULL Token *astTop() {
+        if (mImpl->mAstTop) {
+            return mImpl->mAstTop;
+        }
         Token *ret = this;
         while (ret->mImpl->mAstParent)
             ret = ret->mImpl->mAstParent;
         return ret;
     }
 
-    const Token *astTop() const {
+    RET_NONNULL const Token *astTop() const {
+        if (mImpl->mAstTop) {
+            return mImpl->mAstTop;
+        }
         const Token *ret = this;
         while (ret->mImpl->mAstParent)
             ret = ret->mImpl->mAstParent;
         return ret;
     }
 
+    /**
+     * @throws InternalError thrown if start or end cannot be found
+     */
     std::pair<const Token *, const Token *> findExpressionStartEndTokens() const;
 
     /**
@@ -1200,15 +1639,12 @@ class CPPCHECKLIB Token {
      */
     bool isCalculation() const;
 
-    void clearAst() {
-        mImpl->mAstOperand1 = mImpl->mAstOperand2 = mImpl->mAstParent = nullptr;
-    }
-
     void clearValueFlow() {
         delete mImpl->mValues;
         mImpl->mValues = nullptr;
     }
 
+    // cppcheck-suppress unusedFunction - used in tests only
     std::string astString(const char *sep = "") const {
         std::string ret;
         if (mImpl->mAstOperand1)
@@ -1220,23 +1656,46 @@ class CPPCHECKLIB Token {
 
     std::string astStringVerbose() const;
 
+    std::string astStringZ3() const;
+
     std::string expressionString() const;
 
-    void printAst(bool verbose, bool xml, std::ostream &out) const;
+    void printAst(bool xml, const std::vector<std::string> &fileNames, std::ostream &out) const;
 
-    void printValueFlow(bool xml, std::ostream &out) const;
+    void printValueFlow(const std::vector<std::string>& files, bool xml, std::ostream &out) const;
 
     void scopeInfo(std::shared_ptr<ScopeInfo2> newScopeInfo);
     std::shared_ptr<ScopeInfo2> scopeInfo() const;
 
     void setCpp11init(bool cpp11init) const {
-        mImpl->mCpp11init=cpp11init ? TokenImpl::Cpp11init::CPP11INIT : TokenImpl::Cpp11init::NOINIT;
+        mImpl->mCpp11init=cpp11init ? Cpp11init::CPP11INIT : Cpp11init::NOINIT;
     }
-    TokenImpl::Cpp11init isCpp11init() const {
+    Cpp11init isCpp11init() const {
         return mImpl->mCpp11init;
     }
+
+    TokenDebug getTokenDebug() const {
+        return mImpl->mDebug;
+    }
+    void setTokenDebug(TokenDebug td) {
+        mImpl->mDebug = td;
+    }
+
+    bool isCpp() const
+    {
+        return mIsCpp;
+    }
+
+    bool isC() const
+    {
+        return mIsC;
+    }
 };
 
+Token* findTypeEnd(Token* tok);
+Token* findLambdaEndScope(Token* tok);
+const Token* findLambdaEndScope(const Token* tok);
+
 /// @}
 //---------------------------------------------------------------------------
 #endif // tokenH
diff --git a/lib/tokenize.cpp b/lib/tokenize.cpp
index 35ca38299f0..c2ecb907028 100644
--- a/lib/tokenize.cpp
+++ b/lib/tokenize.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -19,113 +19,85 @@
 //---------------------------------------------------------------------------
 #include "tokenize.h"
 
-#include "check.h"
+#include "astutils.h"
+#include "errorlogger.h"
+#include "errortypes.h"
 #include "library.h"
 #include "mathlib.h"
 #include "path.h"
 #include "platform.h"
+#include "preprocessor.h"
 #include "settings.h"
 #include "standards.h"
+#include "summaries.h"
 #include "symboldatabase.h"
 #include "templatesimplifier.h"
 #include "timer.h"
 #include "token.h"
 #include "utils.h"
 #include "valueflow.h"
+#include "vfvalue.h"
 
 #include <algorithm>
+#include <array>
 #include <cassert>
 #include <cctype>
+#include <cstdlib>
 #include <cstring>
 #include <ctime>
 #include <iostream>
+#include <iterator>
+#include <limits>
+#include <memory>
 #include <set>
+#include <sstream>
 #include <stack>
+#include <stdexcept>
 #include <unordered_map>
+#include <unordered_set>
 #include <utility>
 #include <vector>
+
+#include <simplecpp.h>
+
 //---------------------------------------------------------------------------
 
 namespace {
     // local struct used in setVarId
     // in order to store information about the scope
     struct VarIdScopeInfo {
-        VarIdScopeInfo()
-            :isExecutable(false), isStructInit(false), isEnum(false), startVarid(0) {
-        }
+        VarIdScopeInfo() = default;
         VarIdScopeInfo(bool isExecutable, bool isStructInit, bool isEnum, nonneg int startVarid)
-            :isExecutable(isExecutable), isStructInit(isStructInit), isEnum(isEnum), startVarid(startVarid) {
-        }
+            : isExecutable(isExecutable), isStructInit(isStructInit), isEnum(isEnum), startVarid(startVarid) {}
 
-        const bool isExecutable;
-        const bool isStructInit;
-        const bool isEnum;
-        const nonneg int startVarid;
+        const bool isExecutable{};
+        const bool isStructInit{};
+        const bool isEnum{};
+        const nonneg int startVarid{};
     };
 }
 
 /** Return whether tok is the "{" that starts an enumerator list */
 static bool isEnumStart(const Token* tok)
 {
-    if (!tok || tok->str() != "{")
+    if (!Token::simpleMatch(tok, "{"))
         return false;
-    return (tok->strAt(-1) == "enum") || (tok->strAt(-2) == "enum");
+    tok = tok->previous();
+    while (tok && (!tok->isKeyword() || Token::isStandardType(tok->str())) && Token::Match(tok, "%name%|::|:"))
+        tok = tok->previous();
+    if (Token::simpleMatch(tok, "class"))
+        tok = tok->previous();
+    return Token::simpleMatch(tok, "enum");
 }
 
 template<typename T>
-static void skipEnumBody(T **tok)
+static void skipEnumBody(T *&tok)
 {
-    T *defStart = *tok;
+    T *defStart = tok;
     while (Token::Match(defStart, "%name%|::|:"))
         defStart = defStart->next();
     if (defStart && defStart->str() == "{")
-        *tok = defStart->link()->next();
-}
-
-const Token * Tokenizer::isFunctionHead(const Token *tok, const std::string &endsWith) const
-{
-    return Tokenizer::isFunctionHead(tok, endsWith, isCPP());
-}
-
-const Token * Tokenizer::isFunctionHead(const Token *tok, const std::string &endsWith, bool cpp)
-{
-    if (!tok)
-        return nullptr;
-    if (tok->str() == "(")
-        tok = tok->link();
-    if (Token::Match(tok, ") ;|{|[")) {
-        tok = tok->next();
-        while (tok && tok->str() == "[" && tok->link())
-            tok = tok->link()->next();
-        return (tok && endsWith.find(tok->str()) != std::string::npos) ? tok : nullptr;
-    }
-    if (cpp && tok->str() == ")") {
-        tok = tok->next();
-        while (Token::Match(tok, "const|noexcept|override|final|volatile|&|&& !!(") ||
-               (Token::Match(tok, "%name% !!(") && tok->isUpperCaseName()))
-            tok = tok->next();
-        if (tok && tok->str() == ")")
-            tok = tok->next();
-        while (tok && tok->str() == "[")
-            tok = tok->link()->next();
-        if (Token::Match(tok, "throw|noexcept ("))
-            tok = tok->linkAt(1)->next();
-        if (Token::Match(tok, "%name% (") && tok->isUpperCaseName())
-            tok = tok->linkAt(1)->next();
-        if (tok && tok->originalName() == "->") { // trailing return type
-            for (tok = tok->next(); tok && !Token::Match(tok, ";|{|override|final"); tok = tok->next())
-                if (tok->link() && Token::Match(tok, "<|[|("))
-                    tok = tok->link();
-        }
-        while (Token::Match(tok, "override|final !!(") ||
-               (Token::Match(tok, "%name% !!(") && tok->isUpperCaseName()))
-            tok = tok->next();
-        if (Token::Match(tok, "= 0|default|delete ;"))
-            tok = tok->tokAt(2);
-
-        return (tok && endsWith.find(tok->str()) != std::string::npos) ? tok : nullptr;
-    }
-    return nullptr;
+        tok = defStart->link()->next();
 }
 
 /**
@@ -136,48 +108,19 @@ static bool isClassStructUnionEnumStart(const Token * tok)
     if (!Token::Match(tok->previous(), "class|struct|union|enum|%name%|>|>> {"))
         return false;
     const Token * tok2 = tok->previous();
-    while (tok2 && !Token::Match(tok2, "class|struct|union|enum|{|}|;"))
+    while (tok2 && !Token::Match(tok2, "class|struct|union|enum|{|}|)|;"))
         tok2 = tok2->previous();
-    return Token::Match(tok2, "class|struct|union|enum");
+    return Token::Match(tok2, "class|struct|union|enum") && !Token::simpleMatch(tok2->tokAt(-1), "->");
 }
 
 //---------------------------------------------------------------------------
 
-Tokenizer::Tokenizer() :
-    list(nullptr),
-    mSettings(nullptr),
-    mErrorLogger(nullptr),
-    mSymbolDatabase(nullptr),
-    mTemplateSimplifier(nullptr),
-    mVarId(0),
-    mUnnamedCount(0),
-    mCodeWithTemplates(false), //is there any templates?
-    mTimerResults(nullptr)
-#ifdef MAXTIME
-    ,mMaxTime(std::time(0) + MAXTIME)
-#endif
-{
-}
-
-Tokenizer::Tokenizer(const Settings *settings, ErrorLogger *errorLogger) :
-    list(settings),
-    mSettings(settings),
+Tokenizer::Tokenizer(TokenList tokenList, ErrorLogger &errorLogger) :
+    list(std::move(tokenList)),
+    mSettings(list.getSettings()),
     mErrorLogger(errorLogger),
-    mSymbolDatabase(nullptr),
-    mTemplateSimplifier(nullptr),
-    mVarId(0),
-    mUnnamedCount(0),
-    mCodeWithTemplates(false), //is there any templates?
-    mTimerResults(nullptr)
-#ifdef MAXTIME
-    ,mMaxTime(std::time(0) + MAXTIME)
-#endif
-{
-    // make sure settings are specified
-    assert(mSettings);
-
-    mTemplateSimplifier = new TemplateSimplifier(this);
-}
+    mTemplateSimplifier(new TemplateSimplifier(*this))
+{}
 
 Tokenizer::~Tokenizer()
 {
@@ -190,6 +133,19 @@ Tokenizer::~Tokenizer()
 // SizeOfType - gives the size of a type
 //---------------------------------------------------------------------------
 
+nonneg int Tokenizer::sizeOfType(const std::string& type) const
+{
+    const auto it = mTypeSize.find(type);
+    if (it == mTypeSize.end()) {
+        const Library::PodType* podtype = mSettings.library.podtype(type);
+        if (!podtype)
+            return 0;
+
+        return podtype->size;
+    }
+    return it->second;
+}
+
 nonneg int Tokenizer::sizeOfType(const Token *type) const
 {
     if (!type || type->str().empty())
@@ -198,18 +154,19 @@ nonneg int Tokenizer::sizeOfType(const Token *type) const
     if (type->tokType() == Token::eString)
         return Token::getStrLength(type) + 1U;
 
-    const std::map<std::string, int>::const_iterator it = mTypeSize.find(type->str());
+    const auto it = mTypeSize.find(type->str());
     if (it == mTypeSize.end()) {
-        const Library::PodType* podtype = mSettings->library.podtype(type->str());
+        const Library::PodType* podtype = mSettings.library.podtype(type->str());
         if (!podtype)
             return 0;
 
         return podtype->size;
-    } else if (type->isLong()) {
+    }
+    if (type->isLong()) {
         if (type->str() == "double")
-            return mSettings->sizeof_long_double;
-        else if (type->str() == "long")
-            return mSettings->sizeof_long_long;
+            return mSettings.platform.sizeof_long_double;
+        if (type->str() == "long")
+            return mSettings.platform.sizeof_long_long;
     }
 
     return it->second;
@@ -217,12 +174,12 @@ nonneg int Tokenizer::sizeOfType(const Token *type) const
 //---------------------------------------------------------------------------
 
 // check if this statement is a duplicate definition
-bool Tokenizer::duplicateTypedef(Token **tokPtr, const Token *name, const Token *typeDef) const
+bool Tokenizer::duplicateTypedef(Token *&tokPtr, const Token *name, const Token *typeDef) const
 {
     // check for an end of definition
-    const Token * tok = *tokPtr;
+    Token * tok = tokPtr;
     if (tok && Token::Match(tok->next(), ";|,|[|=|)|>|(|{")) {
-        const Token * end = tok->next();
+        Token * end = tok->next();
 
         if (end->str() == "[") {
             if (!end->link())
@@ -235,30 +192,30 @@ bool Tokenizer::duplicateTypedef(Token **tokPtr, const Token *name, const Token
 
             // find end of definition
             while (end && end->next() && !Token::Match(end->next(), ";|)|>")) {
-                if (end->next()->str() == "(")
+                if (end->strAt(1) == "(")
                     end = end->linkAt(1);
 
-                end = (end)?end->next():nullptr;
+                end = end ? end->next() : nullptr;
             }
             if (end)
                 end = end->next();
         } else if (end->str() == "(") {
-            if (tok->previous()->str().compare(0, 8, "operator")  == 0) {
+            if (startsWith(tok->strAt(-1), "operator"))
                 // conversion operator
                 return false;
-            } else if (tok->previous()->str() == "typedef") {
+            if (tok->strAt(-1) == "typedef")
                 // typedef of function returning this type
                 return false;
-            } else if (Token::Match(tok->previous(), "public:|private:|protected:")) {
+            if (Token::Match(tok->previous(), "public:|private:|protected:"))
                 return false;
-            } else if (tok->previous()->str() == ">") {
+            if (tok->strAt(-1) == ">") {
                 if (!Token::Match(tok->tokAt(-2), "%type%"))
                     return false;
 
                 if (!Token::Match(tok->tokAt(-3), ",|<"))
                     return false;
 
-                *tokPtr = end->link();
+                tokPtr = end->link();
                 return true;
             }
         }
@@ -269,7 +226,7 @@ bool Tokenizer::duplicateTypedef(Token **tokPtr, const Token *name, const Token
                 if (Token::Match(tok->previous(), "%type%") &&
                     !Token::Match(tok->previous(), "return|new|const|struct")) {
                     // duplicate definition so skip entire function
-                    *tokPtr = end->next()->link();
+                    tokPtr = end->linkAt(1);
                     return true;
                 }
             } else if (end->str() == ">") { // template parameter ?
@@ -280,61 +237,52 @@ bool Tokenizer::duplicateTypedef(Token **tokPtr, const Token *name, const Token
                     while (end && end->str() != "{")
                         end = end->next();
                     if (end) {
-                        *tokPtr = end->link();
+                        tokPtr = end->link();
                         return true;
                     }
                 }
             } else {
                 // look backwards
                 if (Token::Match(tok->previous(), "typedef|}|>") ||
-                    (end->str() == ";" && tok->previous()->str() == ",") ||
-                    (tok->previous()->str() == "*" && tok->next()->str() != "(") ||
+                    (end->str() == ";" && tok->strAt(-1) == ",") ||
+                    (tok->strAt(-1) == "*" && tok->strAt(1) != "(") ||
                     (Token::Match(tok->previous(), "%type%") &&
                      (!Token::Match(tok->previous(), "return|new|const|friend|public|private|protected|throw|extern") &&
                       !Token::simpleMatch(tok->tokAt(-2), "friend class")))) {
                     // scan backwards for the end of the previous statement
                     while (tok && tok->previous() && !Token::Match(tok->previous(), ";|{")) {
-                        if (tok->previous()->str() == "}") {
-                            tok = tok->previous()->link();
-                        } else if (tok->previous()->str() == "typedef") {
+                        if (tok->strAt(-1) == "}") {
+                            tok = tok->linkAt(-1);
+                        } else if (tok->strAt(-1) == "typedef") {
                             return true;
-                        } else if (tok->previous()->str() == "enum") {
+                        } else if (tok->strAt(-1) == "enum") {
                             return true;
-                        } else if (tok->previous()->str() == "struct") {
+                        } else if (tok->strAt(-1) == "struct") {
                             if (tok->strAt(-2) == "typedef" &&
-                                tok->next()->str() == "{" &&
+                                tok->strAt(1) == "{" &&
                                 typeDef->strAt(3) != "{") {
                                 // declaration after forward declaration
                                 return true;
-                            } else if (tok->next()->str() == "{") {
-                                return true;
-                            } else if (Token::Match(tok->next(), ")|*")) {
-                                return true;
-                            } else if (tok->next()->str() == name->str()) {
+                            }
+                            if (tok->strAt(1) == "{")
                                 return true;
-                            } else if (tok->next()->str() != ";") {
+                            if (Token::Match(tok->next(), ")|*"))
                                 return true;
-                            } else {
-                                return false;
-                            }
-                        } else if (tok->previous()->str() == "union") {
-                            if (tok->next()->str() != ";") {
+                            if (tok->strAt(1) == name->str())
                                 return true;
-                            } else {
-                                return false;
-                            }
-                        } else if (isCPP() && tok->previous()->str() == "class") {
-                            if (tok->next()->str() != ";") {
+                            if (tok->strAt(1) != ";")
                                 return true;
-                            } else {
-                                return false;
-                            }
+                            return false;
+                        } else if (tok->strAt(-1) == "union") {
+                            return tok->strAt(1) != ";";
+                        } else if (tok->isCpp() && tok->strAt(-1) == "class") {
+                            return tok->strAt(1) != ";";
                         }
                         if (tok)
                             tok = tok->previous();
                     }
 
-                    if ((*tokPtr)->strAt(1) != "(" || !Token::Match((*tokPtr)->linkAt(1), ") .|(|["))
+                    if (tokPtr->strAt(1) != "(" || !Token::Match(tokPtr->linkAt(1), ") .|(|["))
                         return true;
                 }
             }
@@ -346,7 +294,7 @@ bool Tokenizer::duplicateTypedef(Token **tokPtr, const Token *name, const Token
 
 void Tokenizer::unsupportedTypedef(const Token *tok) const
 {
-    if (!mSettings->debugwarnings)
+    if (!mSettings.debugwarnings)
         return;
 
     std::ostringstream str;
@@ -355,7 +303,7 @@ void Tokenizer::unsupportedTypedef(const Token *tok) const
     while (tok) {
         if (level == 0 && tok->str() == ";")
             break;
-        else if (tok->str() == "{")
+        if (tok->str() == "{")
             ++level;
         else if (tok->str() == "}") {
             if (level == 0)
@@ -371,7 +319,7 @@ void Tokenizer::unsupportedTypedef(const Token *tok) const
     if (tok)
         str << " ;";
 
-    reportError(tok1, Severity::debug, "debug",
+    reportError(tok1, Severity::debug, "simplifyTypedef",
                 "Failed to parse \'" + str.str() + "\'. The checking continues anyway.");
 }
 
@@ -381,12 +329,13 @@ Token * Tokenizer::deleteInvalidTypedef(Token *typeDef)
 
     // remove typedef but leave ;
     while (typeDef->next()) {
-        if (typeDef->next()->str() == ";") {
+        if (typeDef->strAt(1) == ";") {
             typeDef->deleteNext();
             break;
-        } else if (typeDef->next()->str() == "{")
+        }
+        if (typeDef->strAt(1) == "{")
             Token::eraseTokens(typeDef, typeDef->linkAt(1));
-        else if (typeDef->next()->str() == "}")
+        else if (typeDef->strAt(1) == "}")
             break;
         typeDef->deleteNext();
     }
@@ -404,76 +353,79 @@ Token * Tokenizer::deleteInvalidTypedef(Token *typeDef)
 
 namespace {
     struct Space {
-        Space() : bodyEnd(nullptr), isNamespace(false) { }
         std::string className;
-        const Token * bodyEnd;
-        bool isNamespace;
+        const Token* bodyEnd{};  // for body contains typedef define
+        const Token* bodyEnd2{}; // for body contains typedef using
+        bool isNamespace{};
+        std::set<std::string> recordTypes;
     };
 }
 
 static Token *splitDefinitionFromTypedef(Token *tok, nonneg int *unnamedCount)
 {
-    Token *tok1;
     std::string name;
-    bool isConst = false;
+    std::set<std::string> qualifiers;
 
-    if (tok->next()->str() == "const") {
+    while (Token::Match(tok->next(), "const|volatile")) {
+        qualifiers.insert(tok->strAt(1));
         tok->deleteNext();
-        isConst = true;
     }
 
-    if (tok->strAt(2) == "{") { // unnamed
-        tok1 = tok->linkAt(2);
+    // skip "class|struct|union|enum"
+    Token *tok1 = tok->tokAt(2);
 
-        if (tok1 && tok1->next()) {
-            // use typedef name if available
-            if (Token::Match(tok1->next(), "%type%"))
-                name = tok1->next()->str();
-            else // create a unique name
-                name = "Unnamed" + MathLib::toString((*unnamedCount)++);
-            tok->next()->insertToken(name);
-        } else
-            return nullptr;
-    } else if (tok->strAt(3) == ":") {
-        tok1 = tok->tokAt(4);
+    const bool hasName = Token::Match(tok1, "%name%");
+
+    // skip name
+    if (hasName) {
+        name = tok1->str();
+        tok1 = tok1->next();
+    }
+
+    // skip base classes if present
+    if (tok1->str() == ":") {
+        tok1 = tok1->next();
         while (tok1 && tok1->str() != "{")
             tok1 = tok1->next();
         if (!tok1)
             return nullptr;
+    }
 
-        tok1 = tok1->link();
-
-        name = tok->strAt(2);
-    } else { // has a name
-        tok1 = tok->linkAt(3);
+    // skip to end
+    tok1 = tok1->link();
 
-        if (!tok1)
+    if (!hasName) { // unnamed
+        if (tok1->next()) {
+            // use typedef name if available
+            if (Token::Match(tok1->next(), "%type%"))
+                name = tok1->strAt(1);
+            else // create a unique name
+                name = "Unnamed" + std::to_string((*unnamedCount)++);
+            tok->next()->insertToken(name);
+        } else
             return nullptr;
-
-        name = tok->strAt(2);
     }
 
     tok1->insertToken(";");
     tok1 = tok1->next();
 
-    if (tok1->next() && tok1->next()->str() == ";" && tok1->previous()->str() == "}") {
+    if (tok1->next() && tok1->strAt(1) == ";" && tok1->strAt(-1) == "}") {
         tok->deleteThis();
         tok1->deleteThis();
         return nullptr;
-    } else {
-        tok1->insertToken("typedef");
-        tok1 = tok1->next();
-        Token * tok3 = tok1;
-        if (isConst) {
-            tok1->insertToken("const");
-            tok1 = tok1->next();
-        }
-        tok1->insertToken(tok->next()->str()); // struct, union or enum
+    }
+    tok1->insertToken("typedef");
+    tok1 = tok1->next();
+    Token * tok3 = tok1;
+    for (const std::string &qualifier : qualifiers) {
+        tok1->insertToken(qualifier);
         tok1 = tok1->next();
-        tok1->insertToken(name);
-        tok->deleteThis();
-        tok = tok3;
     }
+    tok1->insertToken(tok->strAt(1)); // struct, union or enum
+    tok1 = tok1->next();
+    tok1->insertToken(name);
+    tok->deleteThis();
+    tok = tok3;
 
     return tok;
 }
@@ -483,10 +435,10 @@ static Token *splitDefinitionFromTypedef(Token *tok, nonneg int *unnamedCount)
  * code that generated it deals in some way with functions, then this
  * function will probably need to be extended to handle a new function
  * related pattern */
-Token *Tokenizer::processFunc(Token *tok2, bool inOperator) const
+const Token *Tokenizer::processFunc(const Token *tok2, bool inOperator) const
 {
-    if (tok2->next() && tok2->next()->str() != ")" &&
-        tok2->next()->str() != ",") {
+    if (tok2->next() && tok2->strAt(1) != ")" &&
+        tok2->strAt(1) != ",") {
         // skip over tokens for some types of canonicalization
         if (Token::Match(tok2->next(), "( * %type% ) ("))
             tok2 = tok2->linkAt(5);
@@ -503,39 +455,42 @@ Token *Tokenizer::processFunc(Token *tok2, bool inOperator) const
                  Token::simpleMatch(tok2->linkAt(2), "] ;"))
             tok2 = tok2->next();
         else {
-            if (tok2->next()->str() == "(")
-                tok2 = tok2->next()->link();
+            if (tok2->strAt(1) == "(")
+                tok2 = tok2->linkAt(1);
             else if (!inOperator && !Token::Match(tok2->next(), "[|>|;")) {
                 tok2 = tok2->next();
 
                 while (Token::Match(tok2, "*|&") &&
-                       !Token::Match(tok2->next(), ")|>"))
+                       !Token::Match(tok2->next(), "[)>,]"))
                     tok2 = tok2->next();
 
                 // skip over namespace
                 while (Token::Match(tok2, "%name% ::"))
                     tok2 = tok2->tokAt(2);
 
+                if (Token::simpleMatch(tok2, "const"))
+                    tok2 = tok2->next();
+
                 if (!tok2)
                     return nullptr;
 
                 if (tok2->str() == "(" &&
                     tok2->link()->next() &&
-                    tok2->link()->next()->str() == "(") {
+                    tok2->link()->strAt(1) == "(") {
                     tok2 = tok2->link();
 
-                    if (tok2->next()->str() == "(")
-                        tok2 = tok2->next()->link();
+                    if (tok2->strAt(1) == "(")
+                        tok2 = tok2->linkAt(1);
                 }
 
                 // skip over typedef parameter
-                if (tok2->next() && tok2->next()->str() == "(") {
-                    tok2 = tok2->next()->link();
+                if (tok2->next() && tok2->strAt(1) == "(") {
+                    tok2 = tok2->linkAt(1);
                     if (!tok2->next())
                         syntaxError(tok2);
 
-                    if (tok2->next()->str() == "(")
-                        tok2 = tok2->next()->link();
+                    if (tok2->strAt(1) == "(")
+                        tok2 = tok2->linkAt(1);
                 }
             }
         }
@@ -543,7348 +498,7473 @@ Token *Tokenizer::processFunc(Token *tok2, bool inOperator) const
     return tok2;
 }
 
-void Tokenizer::simplifyTypedef()
+Token *Tokenizer::processFunc(Token *tok2, bool inOperator)
 {
-    std::vector<Space> spaceInfo;
-    bool isNamespace = false;
-    std::string className;
-    bool hasClass = false;
-    bool goback = false;
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (mErrorLogger && !list.getFiles().empty())
-            mErrorLogger->reportProgress(list.getFiles()[0], "Tokenize (typedef)", tok->progressValue());
-
-        if (Settings::terminated())
-            return;
+    return const_cast<Token*>(processFunc(const_cast<const Token*>(tok2), inOperator));
+}
 
-        if (isMaxTime())
-            return;
+void Tokenizer::simplifyTypedefLHS()
+{
+    if (!list.front())
+        return;
 
-        if (goback) {
-            //jump back once, see the comment at the end of the function
-            goback = false;
-            tok = tok->previous();
+    for (Token* tok = list.front()->next(); tok; tok = tok->next()) {
+        if (tok->str() == "typedef") {
+            bool doSimplify = !Token::Match(tok->previous(), ";|{|}|:|public:|private:|protected:");
+            if (doSimplify && Token::simpleMatch(tok->previous(), ")") && Token::Match(tok->linkAt(-1)->previous(), "if|for|while"))
+                doSimplify = false;
+            bool haveStart = false;
+            Token* start{};
+            if (!doSimplify && Token::simpleMatch(tok->previous(), "}")) {
+                start = tok->linkAt(-1)->previous();
+                while (Token::Match(start, "%name%")) {
+                    if (Token::Match(start, "class|struct|union|enum")) {
+                        start = start->previous();
+                        doSimplify = true;
+                        haveStart = true;
+                        break;
+                    }
+                    start = start->previous();
+                }
+            }
+            if (doSimplify) {
+                if (!haveStart) {
+                    start = tok;
+                    while (start && !Token::Match(start, "[;{}]"))
+                        start = start->previous();
+                }
+                if (start)
+                    start = start->next();
+                else
+                    start = list.front();
+                start->insertTokenBefore(tok->str());
+                tok->deleteThis();
+            }
         }
+    }
+}
 
-        if (tok->str() != "typedef") {
-            if (tok->str() == "(" && tok->strAt(1) == "typedef") {
-                // Skip typedefs inside parentheses (#2453 and #4002)
-                tok = tok->next();
-            } else if (Token::Match(tok, "class|struct|namespace %any%") &&
-                       (!tok->previous() || tok->previous()->str() != "enum")) {
-                isNamespace = (tok->str() == "namespace");
-                hasClass = true;
-                className = tok->next()->str();
-            } else if (hasClass && tok->str() == ";") {
-                hasClass = false;
-            } else if (hasClass && tok->str() == "{") {
-                Space info;
-                info.isNamespace = isNamespace;
-                info.className = className;
-                info.bodyEnd = tok->link();
-                spaceInfo.push_back(info);
-
-                hasClass = false;
-            } else if (!spaceInfo.empty() && tok->str() == "}" && spaceInfo.back().bodyEnd == tok) {
-                spaceInfo.pop_back();
+namespace {
+    class TypedefSimplifier {
+    private:
+        Token* mTypedefToken;  // The "typedef" token
+        Token* mEndToken{nullptr};  // Semicolon
+        std::pair<Token*, Token*> mRangeType;
+        std::pair<Token*, Token*> mRangeTypeQualifiers;
+        std::pair<Token*, Token*> mRangeAfterVar;
+        Token* mNameToken{nullptr};
+        bool mFail = false;
+        bool mReplaceFailed = false;
+        bool mUsed = false;
+
+    public:
+        explicit TypedefSimplifier(Token* typedefToken) : mTypedefToken(typedefToken) {
+            Token* start = typedefToken->next();
+            if (Token::simpleMatch(start, "typename"))
+                start = start->next();
+
+            // TODO handle unnamed structs etc
+            if (Token::Match(start, "const| enum|struct|union|class %name%| {")) {
+                const std::pair<Token*, Token*> rangeBefore(start, Token::findsimplematch(start, "{"));
+
+                // find typedef name token
+                Token* nameToken = rangeBefore.second->link()->next();
+                while (Token::Match(nameToken, "%name%|* %name%|*"))
+                    nameToken = nameToken->next();
+                const std::pair<Token*, Token*> rangeQualifiers(rangeBefore.second->link()->next(), nameToken);
+
+                if (Token::Match(nameToken, "%name% ;")) {
+                    if (Token::Match(rangeBefore.second->previous(), "enum|struct|union|class {"))
+                        rangeBefore.second->previous()->insertToken(nameToken->str());
+                    mRangeType = rangeBefore;
+                    mRangeTypeQualifiers = rangeQualifiers;
+                    Token* typeName = rangeBefore.second->previous();
+                    if (typeName->isKeyword()) {
+                        // TODO typeName->insertToken("T:" + std::to_string(num++));
+                        typeName->insertToken(nameToken->str());
+                    }
+                    mNameToken = nameToken;
+                    mEndToken = nameToken->next();
+                    return;
+                }
             }
-            continue;
-        }
 
-        // pull struct, union, enum or class definition out of typedef
-        // use typedef name for unnamed struct, union, enum or class
-        if (Token::Match(tok->next(), "const| struct|enum|union|class %type%| {")) {
-            Token *tok1 = splitDefinitionFromTypedef(tok, &mUnnamedCount);
-            if (!tok1)
-                continue;
-            tok = tok1;
-        } else if (Token::Match(tok->next(), "const| struct|class %type% :")) {
-            Token *tok1 = tok;
-            while (tok1 && tok1->str() != ";" && tok1->str() != "{")
-                tok1 = tok1->next();
-            if (tok1 && tok1->str() == "{") {
-                tok1 = splitDefinitionFromTypedef(tok, &mUnnamedCount);
-                if (!tok1)
-                    continue;
-                tok = tok1;
+            for (Token* type = start; Token::Match(type, "%name%|*|&|&&"); type = type->next()) {
+                if (type != start && Token::Match(type, "%name% ;") && !type->isStandardType()) {
+                    mRangeType.first = start;
+                    mRangeType.second = type;
+                    mNameToken = type;
+                    mEndToken = mNameToken->next();
+                    return;
+                }
+                if (type != start && Token::Match(type, "%name% [")) {
+                    Token* end = type->linkAt(1);
+                    while (Token::simpleMatch(end, "] ["))
+                        end = end->linkAt(1);
+                    if (!Token::simpleMatch(end, "] ;"))
+                        break;
+                    mRangeType.first = start;
+                    mRangeType.second = type;
+                    mNameToken = type;
+                    mEndToken = end->next();
+                    mRangeAfterVar.first = mNameToken->next();
+                    mRangeAfterVar.second = mEndToken;
+                    return;
+                }
+                if (Token::Match(type->next(), "( * const| %name% ) (") && Token::simpleMatch(type->linkAt(1)->linkAt(1), ") ;")) {
+                    mNameToken = type->linkAt(1)->previous();
+                    mEndToken = type->linkAt(1)->linkAt(1)->next();
+                    mRangeType.first = start;
+                    mRangeType.second = mNameToken;
+                    mRangeAfterVar.first = mNameToken->next();
+                    mRangeAfterVar.second = mEndToken;
+                    return;
+                }
+                if (type != start && Token::Match(type, "%name% ( !!(") && Token::simpleMatch(type->linkAt(1), ") ;") && !type->isStandardType()) {
+                    mNameToken = type;
+                    mEndToken = type->linkAt(1)->next();
+                    mRangeType.first = start;
+                    mRangeType.second = type;
+                    mRangeAfterVar.first = mNameToken->next();
+                    mRangeAfterVar.second = mEndToken;
+                    return;
+                }
             }
+            // TODO: handle all typedefs
+            if ((false)) // NOLINT(readability-redundant-parentheses)
+                printTypedef(typedefToken, std::cout);
+            mFail = true;
         }
 
-        /** @todo add support for union */
-        if (Token::Match(tok->next(), "enum %type% %type% ;") && tok->strAt(2) == tok->strAt(3)) {
-            tok->deleteNext(3);
-            tok->deleteThis();
-            if (tok->next())
-                tok->deleteThis();
-            //now the next token to process is 'tok', not 'tok->next()';
-            goback = true;
-            continue;
+        const Token* getTypedefToken() const {
+            return mTypedefToken;
         }
 
-        Token *typeName;
-        Token *typeStart = nullptr;
-        Token *typeEnd = nullptr;
-        Token *argStart = nullptr;
-        Token *argEnd = nullptr;
-        Token *arrayStart = nullptr;
-        Token *arrayEnd = nullptr;
-        Token *specStart = nullptr;
-        Token *specEnd = nullptr;
-        Token *typeDef = tok;
-        Token *argFuncRetStart = nullptr;
-        Token *argFuncRetEnd = nullptr;
-        Token *funcStart = nullptr;
-        Token *funcEnd = nullptr;
-        Token *tokOffset = tok->next();
-        bool function = false;
-        bool functionPtr = false;
-        bool functionRetFuncPtr = false;
-        bool functionPtrRetFuncPtr = false;
-        bool ptrToArray = false;
-        bool refToArray = false;
-        bool ptrMember = false;
-        bool typeOf = false;
-        Token *namespaceStart = nullptr;
-        Token *namespaceEnd = nullptr;
-
-        // check for invalid input
-        if (!tokOffset)
-            syntaxError(tok);
-
+        bool isUsed() const {
+            return mUsed;
+        }
 
-        if (tokOffset->str() == "::") {
-            typeStart = tokOffset;
-            tokOffset = tokOffset->next();
+        bool isInvalidConstFunctionType(const std::map<std::string, TypedefSimplifier>& m) const {
+            if (!Token::Match(mTypedefToken, "typedef const %name% %name% ;"))
+                return false;
+            const auto it = m.find(mTypedefToken->strAt(2));
+            if (it == m.end())
+                return false;
+            return Token::Match(it->second.mNameToken, "%name% (");
+        }
 
-            while (Token::Match(tokOffset, "%type% ::"))
-                tokOffset = tokOffset->tokAt(2);
+        bool fail() const {
+            return mFail;
+        }
 
-            typeEnd = tokOffset;
+        bool replaceFailed() const {
+            return mReplaceFailed;
+        }
 
-            if (Token::Match(tokOffset, "%type%"))
-                tokOffset = tokOffset->next();
-        } else if (Token::Match(tokOffset, "%type% ::")) {
-            typeStart = tokOffset;
+        bool isStructEtc() const {
+            return mRangeType.second && mRangeType.second->str() == "{";
+        }
 
-            do {
-                tokOffset = tokOffset->tokAt(2);
-            } while (Token::Match(tokOffset, "%type% ::"));
+        std::string name() const {
+            return mNameToken ? mNameToken->str() : "";
+        }
 
-            typeEnd = tokOffset;
+        /**
+         * @throws InternalError thrown if simplification failed
+         */
+        void replace(Token* tok, const std::string &originalname) {
+            if (tok == mNameToken)
+                return;
 
-            if (Token::Match(tokOffset, "%type%"))
-                tokOffset = tokOffset->next();
-        } else if (Token::Match(tokOffset, "%type%")) {
-            typeStart = tokOffset;
+            mUsed = true;
+            const bool isFunctionPointer = Tokenizer::isFunctionPointer(mNameToken);
 
-            while (Token::Match(tokOffset, "const|struct|enum %type%") ||
-                   (tokOffset->next() && tokOffset->next()->isStandardType()))
-                tokOffset = tokOffset->next();
+            // Special handling for T(...) when T is a pointer
+            if (Token::Match(tok, "%name% [({]") && !isFunctionPointer && !Token::simpleMatch(tok->linkAt(1), ") (")) {
+                bool pointerType = false;
+                for (const Token* type = mRangeType.first; type != mRangeType.second; type = type->next()) {
+                    if (type->str() == "*" || type->str() == "&") {
+                        pointerType = true;
+                        break;
+                    }
+                }
+                for (const Token* type = mRangeTypeQualifiers.first; type != mRangeTypeQualifiers.second; type = type->next()) {
+                    if (type->str() == "*" || type->str() == "&") {
+                        pointerType = true;
+                        break;
+                    }
+                }
+                if (pointerType) {
+                    tok->tokAt(1)->str("(");
+                    tok->linkAt(1)->str(")");
+                    if (tok->linkAt(1) == tok->tokAt(2)) { // T() or T{}
+                        tok->deleteThis();
+                        tok->next()->insertToken("0");
+                        Token* tok2 = insertTokens(tok, mRangeType);
+                        insertTokens(tok2, mRangeTypeQualifiers);
+                    }
+                    else { // functional-style cast
+                        tok->originalName(originalname);
+                        tok->isSimplifiedTypedef(true);
+                        tok->str("(");
+                        Token* tok2 = insertTokens(tok, mRangeType);
+                        tok2 = insertTokens(tok2, mRangeTypeQualifiers);
+                        Token* tok3 = tok2->insertToken(")");
+                        Token::createMutualLinks(tok, tok3);
+                        tok->insertTokenBefore("(");
+                        tok3 = tok3->linkAt(1);
+                        tok3 = tok3->insertToken(")");
+                        Token::createMutualLinks(tok->tokAt(-1), tok3);
+                    }
+                    return;
+                }
+            }
 
-            typeEnd = tokOffset;
-            tokOffset = tokOffset->next();
+            // Special handling of function pointer cast
+            if (isFunctionPointer && isCast(tok->previous())) {
+                tok->insertToken("*");
+                Token* const tok_1 = insertTokens(tok, std::pair<Token*, Token*>(mRangeType.first, mNameToken->linkAt(1)));
+                tok_1->originalName(originalname);
+                tok->deleteThis();
+                return;
+            }
 
-            while (Token::Match(tokOffset, "%type%") &&
-                   (tokOffset->isStandardType() || Token::Match(tokOffset, "unsigned|signed"))) {
-                typeEnd = tokOffset;
-                tokOffset = tokOffset->next();
+            // Inherited type => skip "struct" / "class"
+            if (Token::Match(mRangeType.first, "const| struct|class %name% {") && Token::Match(tok->previous(), "public|protected|private|<")) {
+                tok->originalName(originalname);
+                tok->str(mRangeType.second->strAt(-1));
+                return;
             }
 
-            bool atEnd = false;
-            while (!atEnd) {
-                if (tokOffset && tokOffset->str() == "::") {
-                    typeEnd = tokOffset;
-                    tokOffset = tokOffset->next();
+            if (Token::Match(tok, "%name% ::")) {
+                if (Token::Match(mRangeType.first, "const| struct|class|union|enum %name% %name%|{") ||
+                    Token::Match(mRangeType.first, "%name% %name% ;")) {
+                    tok->originalName(originalname);
+                    tok->str(mRangeType.second->strAt(-1));
+                } else {
+                    mReplaceFailed = true;
                 }
+                return;
+            }
 
-                if (Token::Match(tokOffset, "%type%") &&
-                    tokOffset->next() && !Token::Match(tokOffset->next(), "[|;|,|(")) {
-                    typeEnd = tokOffset;
-                    tokOffset = tokOffset->next();
-                } else if (Token::simpleMatch(tokOffset, "const (")) {
-                    typeEnd = tokOffset;
-                    tokOffset = tokOffset->next();
-                    atEnd = true;
-                } else
-                    atEnd = true;
+            // pointer => move "const"
+            if (Token::simpleMatch(tok->previous(), "const")) {
+                bool pointerType = false;
+                for (const Token* type = mRangeType.first; type != mRangeType.second; type = type->next()) {
+                    if (type->str() == "*") {
+                        pointerType = true;
+                        break;
+                    }
+                }
+                if (pointerType) {
+                    tok->insertToken("const");
+                    tok->next()->column(tok->column());
+                    if (!tok->previous()->getMacroName().empty())
+                        tok->next()->setMacroName(tok->previous()->getMacroName());
+                    tok->deletePrevious();
+                }
             }
-        } else
-            continue; // invalid input
 
-        // check for invalid input
-        if (!tokOffset)
-            syntaxError(tok);
+            // Do not duplicate class/struct/enum/union
+            if (Token::Match(tok->previous(), "enum|union|struct|class")) {
+                bool found = false;
+                const std::string &kw = tok->strAt(-1);
+                for (const Token* type = mRangeType.first; type != mRangeType.second; type = type->next()) {
+                    if (type->str() == kw) {
+                        found = true;
+                        break;
+                    }
+                }
+                if (found)
+                    tok->deletePrevious();
+                else {
+                    mReplaceFailed = true;
+                    return;
+                }
+            }
 
-        // check for template
-        if (!isC() && tokOffset->str() == "<") {
-            typeEnd = tokOffset->findClosingBracket();
+            // don't add class|struct|union in inheritance list
+            auto rangeType = mRangeType;
+            if (Token::Match(tok->previous(), "public|private|protected")) {
+                while (Token::Match(rangeType.first, "const|class|struct|union"))
+                    rangeType.first = rangeType.first->next();
+            }
 
-            while (typeEnd && Token::Match(typeEnd->next(), ":: %type%"))
-                typeEnd = typeEnd->tokAt(2);
+            Token* const tok2 = insertTokens(tok, rangeType);
+            Token* const tok3 = insertTokens(tok2, mRangeTypeQualifiers);
 
-            if (!typeEnd) {
-                // internal error
+            tok2->originalName(originalname);
+            tok3->originalName(originalname);
+            Token *after = tok3;
+            while (Token::Match(after, "%name%|*|&|&&|::"))
+                after = after->next();
+            if (Token::Match(mNameToken, "%name% (") && Token::Match(tok3->next(), "*|const")) {
+                while (Token::Match(after, "(|["))
+                    after = after->link()->next();
+                if (after) {
+                    tok3->insertToken("(");
+                    after->previous()->insertToken(")");
+                    Token::createMutualLinks(tok3->next(), after->previous());
+                }
+            }
+            if (!after) {
+                mReplaceFailed = true;
                 return;
             }
 
-            while (Token::Match(typeEnd->next(), "const|volatile"))
-                typeEnd = typeEnd->next();
-
-            tok = typeEnd;
-            tokOffset = tok->next();
-        }
-
-        std::list<std::string> pointers;
-        // check for pointers and references
-        while (Token::Match(tokOffset, "*|&|&&|const")) {
-            pointers.push_back(tokOffset->str());
-            tokOffset = tokOffset->next();
-        }
+            bool useAfterVarRange = true;
+            if (Token::simpleMatch(mRangeAfterVar.first, "[")) {
+                if (Token::Match(after->previous(), "%name% ( !!*")) {
+                    useAfterVarRange = false;
+                    // Function return type => replace array with "*"
+                    for (const Token* a = mRangeAfterVar.first; Token::simpleMatch(a, "["); a = a->link()->next())
+                        tok3->insertToken("*");
+                } else if (Token::Match(after->previous(), "%name% ( * %name% ) [")) {
+                    after = after->linkAt(4)->next();
+                } else {
+                    Token* prev = after->previous();
+                    if (prev->isName() && prev != tok3)
+                        prev = prev->previous();
+                    if (Token::Match(prev, "*|&|&&") && prev != tok3) {
+                        while (Token::Match(prev, "*|&|&&") && prev != tok3)
+                            prev = prev->previous();
+                        prev->insertToken("(");
+                        after->previous()->insertToken(")");
+                    }
+                }
+            }
 
-        // check for invalid input
-        if (!tokOffset)
-            syntaxError(tok);
+            if (isFunctionPointer) {
+                if (Token::Match(after, "( * %name% ) ("))
+                    after = after->link()->linkAt(1)->next();
+                else if (after->str() == "(") {
+                    useAfterVarRange = false;
+                    if (Token::simpleMatch(tok3->previous(), "( *"))
+                        tok3->deletePrevious();
+                    else if (Token::simpleMatch(tok3->tokAt(-2), "( * const"))
+                        tok3->tokAt(-1)->deletePrevious();
+                }
+                else if (after->str() == "[") {
+                    while (after && after->str() == "[")
+                        after = after->link()->next();
+                }
+            }
+            else {
+                while (Token::simpleMatch(after, "["))
+                    after = after->link()->next();
+            }
 
-        if (Token::Match(tokOffset, "%type%")) {
-            // found the type name
-            typeName = tokOffset;
-            tokOffset = tokOffset->next();
+            if (!after)
+                throw InternalError(tok, "Failed to simplify typedef. Is the code valid?");
 
-            // check for array
-            if (tokOffset && tokOffset->str() == "[") {
-                arrayStart = tokOffset;
+            Token* const tok4 = useAfterVarRange ? insertTokens(after->previous(), mRangeAfterVar)->next() : tok3->next();
 
-                bool atEnd = false;
-                while (!atEnd) {
-                    while (tokOffset->next() && !Token::Match(tokOffset->next(), ";|,")) {
-                        tokOffset = tokOffset->next();
-                    }
+            if (tok->next() == tok4)
+                throw InternalError(tok, "Failed to simplify typedef. Is the code valid?");
 
-                    if (!tokOffset->next())
-                        return; // invalid input
-                    else if (tokOffset->next()->str() == ";")
-                        atEnd = true;
-                    else if (tokOffset->str() == "]")
-                        atEnd = true;
-                    else
-                        tokOffset = tokOffset->next();
-                }
+            tok->deleteThis();
 
-                arrayEnd = tokOffset;
-                tokOffset = tokOffset->next();
+            // Unsplit variable declarations
+            if (tok4 && tok4->isSplittedVarDeclEq() &&
+                ((tok4->isCpp() && Token::Match(tok4->tokAt(-2), "&|&& %name% ;")) || Token::Match(tok4->previous(), "] ; %name% = {"))) {
+                tok4->deleteNext();
+                tok4->deleteThis();
             }
 
-            // check for end or another
-            if (Token::Match(tokOffset, ";|,"))
-                tok = tokOffset;
-
-            // or a function typedef
-            else if (tokOffset && tokOffset->str() == "(") {
-                Token *tokOffset2 = nullptr;
-                if (Token::Match(tokOffset, "( *|%name%")) {
-                    tokOffset2 = tokOffset->next();
-                    if (tokOffset2->str() == "typename")
-                        tokOffset2 = tokOffset2->next();
-                    while (Token::Match(tokOffset2, "%type% ::"))
-                        tokOffset2 = tokOffset2->tokAt(2);
+            // Set links
+            std::stack<Token*> brackets;
+            for (; tok != tok4; tok = tok->next()) {
+                if (Token::Match(tok, "[{([]"))
+                    brackets.push(tok);
+                else if (Token::Match(tok, "[})]]")) {
+                    Token::createMutualLinks(brackets.top(), tok);
+                    brackets.pop();
                 }
+            }
+        }
 
-                // unhandled typedef, skip it and continue
-                if (typeName->str() == "void") {
-                    unsupportedTypedef(typeDef);
-                    tok = deleteInvalidTypedef(typeDef);
-                    if (tok == list.front())
-                        //now the next token to process is 'tok', not 'tok->next()';
-                        goback = true;
-                    continue;
-                }
+        void removeDeclaration() {
+            if (Token::simpleMatch(mRangeType.second, "{")) {
+                while (Token::Match(mTypedefToken, "typedef|const"))
+                    mTypedefToken->deleteThis();
+                Token::eraseTokens(mRangeType.second->link(), mEndToken);
+            } else {
+                Token::eraseTokens(mTypedefToken, mEndToken);
+                mTypedefToken->deleteThis();
+            }
+        }
 
-                // function pointer
-                else if (Token::Match(tokOffset2, "* %name% ) (")) {
-                    // name token wasn't a name, it was part of the type
-                    typeEnd = typeEnd->next();
-                    functionPtr = true;
-                    funcStart = funcEnd = tokOffset2; // *
-                    tokOffset = tokOffset2->tokAt(3); // (
-                    typeName = tokOffset->tokAt(-2);
-                    argStart = tokOffset;
-                    argEnd = tokOffset->link();
-                    tok = argEnd->next();
+        static int canReplaceStatic(const Token* tok) {
+            if (!Token::Match(tok, "%name% %name%|*|&|&&|;|(|)|,|::")) {
+                if (Token::Match(tok->previous(), "( %name% =") && Token::Match(tok->linkAt(-1), ") %name%|{") && !tok->tokAt(-2)->isKeyword())
+                    return true;
+                if (Token::Match(tok->previous(), ", %name% ="))
+                    return true;
+                if (Token::Match(tok->previous(), "new %name% ["))
+                    return true;
+                if (Token::Match(tok->previous(), "< %name%") && tok->previous()->findClosingBracket())
+                    return true;
+                if (Token::Match(tok->previous(), ", %name% >|>>")) {
+                    for (const Token* prev = tok->previous(); prev; prev = prev->previous()) {
+                        if (Token::Match(prev, "[;{}(]"))
+                            break;
+                        if (prev->str() == "<" && prev->findClosingBracket() == tok->next())
+                            return true;
+                        if (prev->str() == ")")
+                            prev = prev->link();
+                    }
+                    return true;
                 }
-
-                // function
-                else if (isFunctionHead(tokOffset->link(), ";,")) {
-                    function = true;
-                    if (tokOffset->link()->next()->str() == "const") {
-                        specStart = tokOffset->link()->next();
-                        specEnd = specStart;
+                if (Token::Match(tok->previous(), "public|protected|private"))
+                    return true;
+                if (Token::Match(tok->previous(), ", %name% :")) {
+                    bool isGeneric = false;
+                    for (; tok; tok = tok->previous()) {
+                        if (Token::Match(tok, ")|]"))
+                            tok = tok->link();
+                        else if (Token::Match(tok, "[;{}(]")) {
+                            isGeneric = Token::simpleMatch(tok->previous(), "_Generic (");
+                            break;
+                        }
                     }
-                    argStart = tokOffset;
-                    argEnd = tokOffset->link();
-                    tok = argEnd->next();
-                    if (specStart)
-                        tok = tok->next();
+                    return isGeneric;
                 }
-
-                // syntax error
-                else
-                    syntaxError(tok);
+                return false;
             }
+            return -1;
+        }
 
-            // unhandled typedef, skip it and continue
-            else {
-                unsupportedTypedef(typeDef);
-                tok = deleteInvalidTypedef(typeDef);
-                if (tok == list.front())
-                    //now the next token to process is 'tok', not 'tok->next()';
-                    goback = true;
-                continue;
+        bool canReplace(const Token* tok) {
+            if (mNameToken == tok)
+                return false;
+            if (!Token::Match(tok->previous(), "%name%|;|{|}|(|,|<") && !Token::Match(tok->previous(), "!!. %name% ("))
+                return false;
+            {
+                const int res = canReplaceStatic(tok);
+                if (res == 0 || res == 1)
+                    return res != 0;
+            }
+            if (Token::Match(tok->previous(), "%name%") && !tok->previous()->isKeyword())
+                return false;
+            if (Token::simpleMatch(tok->next(), "(") && Token::Match(tok->linkAt(1), ") %name%|{"))
+                return false;
+            if (Token::Match(tok->previous(), "struct|union|class|enum %name% %name%") &&
+                Token::simpleMatch(mRangeType.second, "{") &&
+                tok->str() != mRangeType.second->strAt(-1))
+                return true;
+            if (Token::Match(tok->previous(), "; %name% ;"))
+                return false;
+            if (Token::Match(tok->previous(), "<|, %name% * ,|>"))
+                return true;
+            for (const Token* after = tok->next(); after; after = after->next()) {
+                if (Token::Match(after, "%name%|::|&|*|&&"))
+                    continue;
+                if (after->str() == "<" && after->link())
+                    break;
+                if (after->isNumber())
+                    return false;
+                if (after->isComparisonOp() || after->isArithmeticalOp())
+                    return false;
+                break;
+            }
+            for (const Token* before = tok->previous(); before; before = before->previous()) {
+                if (Token::Match(before, "[+-*/&|~!]"))
+                    return false;
+                if (Token::Match(before, "struct|union|class|enum") || before->isStandardType())
+                    return false;
+                if (before->str() == "::")
+                    return false;
+                if (before->isName())
+                    continue;
+                break;
             }
+            return true;
         }
 
-        // typeof: typedef __typeof__ ( ... ) type;
-        else if (Token::simpleMatch(tokOffset->previous(), "__typeof__ (") &&
-                 Token::Match(tokOffset->link(), ") %type% ;")) {
-            argStart = tokOffset;
-            argEnd = tokOffset->link();
-            typeName = tokOffset->link()->next();
-            tok = typeName->next();
-            typeOf = true;
+        Token* endToken() const {
+            return mEndToken;
         }
 
-        // function: typedef ... ( ... type )( ... );
-        //           typedef ... (( ... type )( ... ));
-        //           typedef ... ( * ( ... type )( ... ));
-        else if (tokOffset->str() == "(" && (
-                     (tokOffset->link() && Token::Match(tokOffset->link()->previous(), "%type% ) (") &&
-                      Token::Match(tokOffset->link()->next()->link(), ") const|volatile|;")) ||
-                     (Token::simpleMatch(tokOffset, "( (") &&
-                      tokOffset->next() && Token::Match(tokOffset->next()->link()->previous(), "%type% ) (") &&
-                      Token::Match(tokOffset->next()->link()->next()->link(), ") const|volatile| ) ;|,")) ||
-                     (Token::simpleMatch(tokOffset, "( * (") &&
-                      tokOffset->linkAt(2) && Token::Match(tokOffset->linkAt(2)->previous(), "%type% ) (") &&
-                      Token::Match(tokOffset->linkAt(2)->next()->link(), ") const|volatile| ) ;|,")))) {
-            if (tokOffset->next()->str() == "(")
-                tokOffset = tokOffset->next();
-            else if (Token::simpleMatch(tokOffset, "( * (")) {
-                pointers.emplace_back("*");
-                tokOffset = tokOffset->tokAt(2);
-            }
+        Token* nameToken() const {
+            return mNameToken;
+        }
 
-            if (tokOffset->link()->strAt(-2) == "*")
-                functionPtr = true;
-            else
-                function = true;
-            funcStart = tokOffset->next();
-            tokOffset = tokOffset->link();
-            funcEnd = tokOffset->tokAt(-2);
-            typeName = tokOffset->previous();
-            argStart = tokOffset->next();
-            argEnd = tokOffset->next()->link();
-            if (!argEnd)
-                syntaxError(argStart);
+    private:
+        static bool isCast(const Token* tok) {
+            if (Token::Match(tok, "( %name% ) (|%name%|%num%"))
+                return !tok->tokAt(3)->isKeyword();
+            if (Token::Match(tok, "< %name% > (") && tok->previous() && endsWith(tok->strAt(-1), "_cast", 5))
+                return true;
+            return false;
+        }
 
-            tok = argEnd->next();
-            Token *spec = tok;
-            if (Token::Match(spec, "const|volatile")) {
-                specStart = spec;
-                specEnd = spec;
-                while (Token::Match(spec->next(), "const|volatile")) {
-                    specEnd = spec->next();
-                    spec = specEnd;
-                }
-                tok = specEnd->next();
+        static Token* insertTokens(Token* to, std::pair<Token*,Token*> range) {
+            for (const Token* from = range.first; from != range.second; from = from->next()) {
+                to->insertToken(from->str());
+                to->next()->column(to->column());
+                to = to->next();
+                to->isSimplifiedTypedef(true);
+                to->isExternC(from->isExternC());
             }
-            if (!tok)
-                syntaxError(specEnd);
+            return to;
+        }
 
-            if (tok->str() == ")")
+        static void printTypedef(const Token *tok, std::ostream& out) {
+            int indent = 0;
+            while (tok && (indent > 0 || tok->str() != ";")) {
+                if (tok->str() == "{")
+                    ++indent;
+                else if (tok->str() == "}")
+                    --indent;
+                out << " " << tok->str();
                 tok = tok->next();
+            }
+            out << "\n";
         }
+    };
+}
 
-        else if (Token::Match(tokOffset, "( %type% (")) {
-            function = true;
-            if (tokOffset->link()->next()) {
-                tok = tokOffset->link()->next();
-                tokOffset = tokOffset->tokAt(2);
-                typeName = tokOffset->previous();
-                argStart = tokOffset;
-                argEnd = tokOffset->link();
-            } else {
-                // internal error
+bool Tokenizer::isFunctionPointer(const Token* tok) {
+    return Token::Match(tok, "%name% ) (");
+}
+
+void Tokenizer::simplifyTypedef()
+{
+    // Simplify global typedefs that are not redefined with the fast 1-pass simplification.
+    // Then use the slower old typedef simplification.
+    std::map<std::string, std::set<std::string>> numberOfTypedefs;
+    for (Token* tok = list.front(); tok; tok = tok->next()) {
+        if (tok->str() == "typedef") {
+            TypedefSimplifier ts(tok);
+            if (ts.fail() || !ts.nameToken())
                 continue;
+            std::string existing_data_type;
+            for (const Token* t = ts.getTypedefToken()->next(); t != ts.endToken(); t = t->next()) {
+                if (t != ts.nameToken())
+                    existing_data_type += t->str() + " ";
             }
+            numberOfTypedefs[ts.name()].emplace(std::move(existing_data_type));
+            continue;
         }
+    }
 
-        // pointer to function returning pointer to function
-        else if (Token::Match(tokOffset, "( * ( * %type% ) (") &&
-                 Token::simpleMatch(tokOffset->linkAt(6), ") ) (") &&
-                 Token::Match(tokOffset->linkAt(6)->linkAt(2), ") ;|,")) {
-            functionPtrRetFuncPtr = true;
-
-            tokOffset = tokOffset->tokAt(6);
-            typeName = tokOffset->tokAt(-2);
-            argStart = tokOffset;
-            argEnd = tokOffset->link();
-            if (!argEnd)
-                syntaxError(arrayStart);
+    int indentlevel = 0;
+    std::map<std::string, TypedefSimplifier> typedefs;
+    for (Token* tok = list.front(); tok; tok = tok->next()) {
+        if (!tok->isName()) {
+            if (tok->str()[0] == '{')
+                ++indentlevel;
+            else if (tok->str()[0] == '}')
+                --indentlevel;
+            continue;
+        }
 
-            argFuncRetStart = argEnd->tokAt(2);
-            argFuncRetEnd = argFuncRetStart->link();
-            if (!argFuncRetEnd)
-                syntaxError(argFuncRetStart);
+        if (indentlevel == 0 && tok->str() == "typedef") {
+            TypedefSimplifier ts(tok);
+            if (!ts.fail() && numberOfTypedefs[ts.name()].size() == 1) {
+                if (mSettings.severity.isEnabled(Severity::portability) && ts.isInvalidConstFunctionType(typedefs))
+                    invalidConstFunctionTypeError(tok->next());
+                typedefs.emplace(ts.name(), ts);
+                if (!ts.isStructEtc())
+                    tok = ts.endToken();
+            }
+            continue;
+        }
 
-            tok = argFuncRetEnd->next();
+        auto it = typedefs.find(tok->str());
+        if (it != typedefs.end() && it->second.canReplace(tok)) {
+            std::set<std::string> r;
+            std::string originalname;
+            while (it != typedefs.end() && r.insert(tok->str()).second) {
+                if (originalname.empty())
+                    originalname = tok->str();
+                it->second.replace(tok, originalname);
+                it = typedefs.find(tok->str());
+            }
+        } else if (tok->str() == "enum") {
+            while (Token::Match(tok, "%name%|:|::"))
+                tok = tok->next();
+            if (!tok)
+                break;
+            if (tok->str() == "{")
+                tok = tok->link();
         }
+    }
 
-        // function returning pointer to function
-        else if (Token::Match(tokOffset, "( * %type% (") &&
-                 Token::simpleMatch(tokOffset->linkAt(3), ") ) (") &&
-                 Token::Match(tokOffset->linkAt(3)->linkAt(2), ") ;|,")) {
-            functionRetFuncPtr = true;
+    if (!typedefs.empty())
+    {
+        // remove typedefs
+        for (auto &t: typedefs) {
+            if (t.second.replaceFailed()) {
+                syntaxError(t.second.getTypedefToken());
+            } else {
+                const Token* const typedefToken = t.second.getTypedefToken();
+                TypedefInfo typedefInfo;
+                typedefInfo.name = t.second.name();
+                typedefInfo.filename = list.file(typedefToken);
+                typedefInfo.lineNumber = typedefToken->linenr();
+                typedefInfo.column = typedefToken->column();
+                if (Token::Match(typedefToken->next(), "struct|enum|class|union %name% {") && typedefToken->strAt(2) == typedefInfo.name) {
+                    typedefInfo.tagLine = typedefToken->tokAt(2)->linenr();
+                    typedefInfo.tagColumn = typedefToken->tokAt(2)->column();
+                }
+                typedefInfo.used = t.second.isUsed();
+                typedefInfo.isFunctionPointer = isFunctionPointer(t.second.nameToken());
+                if (typedefInfo.isFunctionPointer) {
+                    const Token* tok = typedefToken;
+                    while (tok != t.second.endToken()) {
+                        TypedefToken ttok;
+                        ttok.name = tok->str();
+                        ttok.lineNumber = tok->linenr();
+                        ttok.column = tok->column();
+                        typedefInfo.typedefInfoTokens.emplace_back(ttok);
+                        tok = tok->next();
+                    }
+                }
+                mTypedefInfo.push_back(std::move(typedefInfo));
 
-            tokOffset = tokOffset->tokAt(3);
-            typeName = tokOffset->previous();
-            argStart = tokOffset;
-            argEnd = tokOffset->link();
+                t.second.removeDeclaration();
+            }
+        }
 
-            argFuncRetStart = argEnd->tokAt(2);
-            if (!argFuncRetStart)
-                syntaxError(tokOffset);
+        while (Token::Match(list.front(), "; %any%"))
+            list.front()->deleteThis();
+    }
 
-            argFuncRetEnd = argFuncRetStart->link();
-            if (!argFuncRetEnd)
-                syntaxError(tokOffset);
+    validate();
 
-            tok = argFuncRetEnd->next();
-        } else if (Token::Match(tokOffset, "( * ( %type% ) (")) {
-            functionRetFuncPtr = true;
+    simplifyTypedefCpp();
+}
 
-            tokOffset = tokOffset->tokAt(5);
-            typeName = tokOffset->tokAt(-2);
-            argStart = tokOffset;
-            argEnd = tokOffset->link();
-            if (!argEnd)
-                syntaxError(arrayStart);
+static Token* simplifyTypedefCopyTokens(Token* to, const Token* fromStart, const Token* toEnd, const Token* location) {
+    Token* ret = TokenList::copyTokens(to, fromStart, toEnd);
+    for (Token* tok = to->next(); tok != ret->next(); tok = tok->next()) {
+        tok->linenr(location->linenr());
+        tok->column(location->column());
+        tok->isSimplifiedTypedef(true);
+    }
+    return ret;
+}
 
-            argFuncRetStart = argEnd->tokAt(2);
-            if (!argFuncRetStart)
-                syntaxError(tokOffset);
+static Token* simplifyTypedefInsertToken(Token* tok, const std::string& str, const Token* location) {
+    tok = tok->insertToken(str);
+    tok->linenr(location->linenr());
+    tok->column(location->column());
+    tok->isSimplifiedTypedef(true);
+    return tok;
+}
 
-            argFuncRetEnd = argFuncRetStart->link();
-            if (!argFuncRetEnd)
-                syntaxError(tokOffset);
+// TODO: rename - it is not C++ specific
+void Tokenizer::simplifyTypedefCpp()
+{
+    const bool cpp = isCPP();
+    bool isNamespace = false;
+    std::string className, fullClassName;
+    bool hasClass = false;
+    bool goback = false;
 
-            tok = argFuncRetEnd->next();
-        }
+    // add global namespace
+    std::vector<Space> spaceInfo(1);
 
-        // pointer/reference to array
-        else if (Token::Match(tokOffset, "( *|& %type% ) [")) {
-            ptrToArray = (tokOffset->next()->str() == "*");
-            refToArray = !ptrToArray;
-            tokOffset = tokOffset->tokAt(2);
-            typeName = tokOffset;
-            arrayStart = tokOffset->tokAt(2);
-            arrayEnd = arrayStart->link();
-            if (!arrayEnd)
-                syntaxError(arrayStart);
+    const std::time_t maxTime = mSettings.typedefMaxTime > 0 ? std::time(nullptr) + mSettings.typedefMaxTime: 0;
+    ProgressReporter progressReporter(mErrorLogger, mSettings.reportProgress, list.getSourceFilePath(), "Tokenize (typedef)");
 
-            tok = arrayEnd->next();
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        progressReporter.report(tok->progressValue());
+
+        if (Settings::terminated())
+            return;
+
+        if (maxTime > 0 && std::time(nullptr) > maxTime) {
+            if (mSettings.debugwarnings) {
+                ErrorMessage::FileLocation loc(list.getFiles()[0], 0, 0);
+                ErrorMessage errmsg({std::move(loc)},
+                                    "",
+                                    Severity::debug,
+                                    "Typedef simplification instantiation maximum time exceeded",
+                                    "typedefMaxTime",
+                                    Certainty::normal);
+                mErrorLogger.reportErr(errmsg);
+            }
+            return;
         }
 
-        // pointer to class member
-        else if (Token::Match(tokOffset, "( %type% :: * %type% ) ;")) {
-            tokOffset = tokOffset->tokAt(2);
-            namespaceStart = tokOffset->previous();
-            namespaceEnd = tokOffset;
-            ptrMember = true;
-            tokOffset = tokOffset->tokAt(2);
-            typeName = tokOffset;
-            tok = tokOffset->tokAt(2);
+        if (goback) {
+            //jump back once, see the comment at the end of the function
+            goback = false;
+            tok = tok->previous();
         }
 
-        // unhandled typedef, skip it and continue
-        else {
-            unsupportedTypedef(typeDef);
-            tok = deleteInvalidTypedef(typeDef);
-            if (tok == list.front())
-                //now the next token to process is 'tok', not 'tok->next()';
-                goback = true;
+        if (tok->str() != "typedef") {
+            if (Token::simpleMatch(tok, "( typedef")) {
+                // Skip typedefs inside parentheses (#2453 and #4002)
+                tok = tok->next();
+            } else if (Token::Match(tok, "class|struct|namespace %any%") &&
+                       (!tok->previous() || tok->strAt(-1) != "enum")) {
+                isNamespace = (tok->str() == "namespace");
+                hasClass = true;
+                className = tok->strAt(1);
+                const Token *tok1 = tok->next();
+                fullClassName = className;
+                while (Token::Match(tok1, "%name% :: %name%")) {
+                    tok1 = tok1->tokAt(2);
+                    fullClassName += " :: " + tok1->str();
+                }
+            } else if (hasClass && tok->str() == ";") {
+                hasClass = false;
+            } else if (hasClass && tok->str() == "{") {
+                if (!isNamespace)
+                    spaceInfo.back().recordTypes.insert(fullClassName);
+
+                Space info;
+                info.isNamespace = isNamespace;
+                info.className = className;
+                info.bodyEnd = tok->link();
+                info.bodyEnd2 = tok->link();
+                spaceInfo.push_back(std::move(info));
+
+                hasClass = false;
+            } else if (spaceInfo.size() > 1 && tok->str() == "}" && spaceInfo.back().bodyEnd == tok) {
+                spaceInfo.pop_back();
+            }
             continue;
         }
 
-        bool done = false;
-        bool ok = true;
+        // pull struct, union, enum or class definition out of typedef
+        // use typedef name for unnamed struct, union, enum or class
+        const Token* tokClass = tok->next();
+        while (Token::Match(tokClass, "const|volatile"))
+            tokClass = tokClass->next();
+        if (Token::Match(tokClass, "struct|enum|union|class %type%| {|:")) {
+            Token *tok1 = splitDefinitionFromTypedef(tok, &mUnnamedCount);
+            if (!tok1)
+                continue;
+            tok = tok1;
+        }
 
-        while (!done) {
-            std::string pattern = typeName->str();
-            int scope = 0;
-            bool simplifyType = false;
-            bool inMemberFunc = false;
-            int memberScope = 0;
-            bool globalScope = false;
-            int classLevel = spaceInfo.size();
+        /** @todo add support for union */
+        if (Token::Match(tok->next(), "enum %type% %type% ;") && tok->strAt(2) == tok->strAt(3)) {
+            tok->deleteNext(3);
+            tok->deleteThis();
+            if (tok->next())
+                tok->deleteThis();
+            //now the next token to process is 'tok', not 'tok->next()';
+            goback = true;
+            continue;
+        }
 
-            for (Token *tok2 = tok; tok2; tok2 = tok2->next()) {
-                if (Settings::terminated())
-                    return;
+        Token *typeName;
+        Token *typeStart = nullptr;
+        Token *typeEnd = nullptr;
+        Token *argStart = nullptr;
+        Token *argEnd = nullptr;
+        Token *arrayStart = nullptr;
+        Token *arrayEnd = nullptr;
+        Token *specStart = nullptr;
+        Token *specEnd = nullptr;
+        Token *typeDef = tok;
+        Token *argFuncRetStart = nullptr;
+        Token *argFuncRetEnd = nullptr;
+        Token *funcStart = nullptr;
+        Token *funcEnd = nullptr;
+        Token *tokOffset = tok->next();
+        bool function = false;
+        bool functionPtr = false;
+        bool functionRetFuncPtr = false;
+        bool functionPtrRetFuncPtr = false;
+        bool ptrToArray = false;
+        bool refToArray = false;
+        bool ptrMember = false;
+        bool typeOf = false;
+        const Token *namespaceStart = nullptr;
+        Token *namespaceEnd = nullptr;
 
-                if (tok2->link()) { // Pre-check for performance
-                    // check for end of scope
-                    if (tok2->str() == "}") {
-                        // check for end of member function
-                        if (inMemberFunc) {
-                            --memberScope;
-                            if (memberScope == 0)
-                                inMemberFunc = false;
-                        }
+        // check for invalid input
+        if (!tokOffset || tokOffset->isControlFlowKeyword())
+            syntaxError(tok);
 
-                        if (classLevel > 0 && tok2 == spaceInfo[classLevel - 1].bodyEnd) {
-                            --classLevel;
-                            pattern.clear();
+        if (tokOffset->str() == "::") {
+            typeStart = tokOffset;
+            tokOffset = tokOffset->next();
 
-                            for (int i = classLevel; i < spaceInfo.size(); ++i)
-                                pattern += (spaceInfo[i].className + " :: ");
+            while (Token::Match(tokOffset, "%type% ::"))
+                tokOffset = tokOffset->tokAt(2);
 
-                            pattern += typeName->str();
-                        } else {
-                            if (scope == 0)
-                                break;
-                            --scope;
-                        }
-                    }
+            typeEnd = tokOffset;
 
-                    // check for member functions
-                    else if (isCPP() && Token::Match(tok2, ")|] const| {")) {
-                        const Token *temp = tok2;
-                        while (temp && temp->str() == "]" && temp->link() && temp->link()->previous())
-                            temp = temp->link()->previous();
-                        if (!temp || !temp->link() || !temp->link()->previous())
-                            continue;
-                        const Token *func = temp->link()->previous();
-                        if (temp->str() != ")")
-                            continue;
-                        if (!func || !func->previous()) // Ticket #4239
-                            continue;
+            if (Token::Match(tokOffset, "%type%"))
+                tokOffset = tokOffset->next();
+        } else if (Token::Match(tokOffset, "%type% ::")) {
+            typeStart = tokOffset;
 
-                        /** @todo add support for multi-token operators */
-                        if (func->previous()->str() == "operator")
-                            func = func->previous();
+            do {
+                tokOffset = tokOffset->tokAt(2);
+            } while (Token::Match(tokOffset, "%type% ::"));
 
-                        if (!func->previous())
-                            syntaxError(func);
+            typeEnd = tokOffset;
 
-                        // check for qualifier
-                        if (func->previous()->str() == "::") {
-                            // check for available and matching class name
-                            if (!spaceInfo.empty() && classLevel < spaceInfo.size() &&
-                                func->strAt(-2) == spaceInfo[classLevel].className) {
-                                memberScope = 0;
-                                inMemberFunc = true;
-                            }
-                        }
-                    }
+            if (Token::Match(tokOffset, "%type%"))
+                tokOffset = tokOffset->next();
+        } else if (Token::Match(tokOffset, "%type%")) {
+            typeStart = tokOffset;
 
-                    // check for entering a new scope
-                    else if (tok2->str() == "{") {
-                        // check for entering a new namespace
-                        if (isCPP() && tok2->strAt(-2) == "namespace") {
-                            if (classLevel < spaceInfo.size() &&
-                                spaceInfo[classLevel].isNamespace &&
-                                spaceInfo[classLevel].className == tok2->previous()->str()) {
-                                spaceInfo[classLevel].bodyEnd = tok2->link();
-                                ++classLevel;
-                                pattern.clear();
-                                for (int i = classLevel; i < spaceInfo.size(); ++i)
-                                    pattern += spaceInfo[i].className + " :: ";
-
-                                pattern += typeName->str();
-                            }
-                            ++scope;
-                        }
+            while (Token::Match(tokOffset, "const|struct|enum %type%") ||
+                   (tokOffset->next() && tokOffset->next()->isStandardType() && !Token::Match(tokOffset->next(), "%name% ;")))
+                tokOffset = tokOffset->next();
 
-                        // keep track of scopes within member function
-                        if (inMemberFunc)
-                            ++memberScope;
+            typeEnd = tokOffset;
+            if (!Token::Match(tokOffset->next(), "%name% ;"))
+                tokOffset = tokOffset->next();
 
-                        ++scope;
-                    }
+            while (Token::Match(tokOffset, "%type%") &&
+                   (tokOffset->isStandardType() || Token::Match(tokOffset, "unsigned|signed")) &&
+                   !Token::Match(tokOffset->next(), "%name% ;")) {
+                typeEnd = tokOffset;
+                tokOffset = tokOffset->next();
+            }
+
+            bool atEnd = false;
+            while (!atEnd) {
+                if (tokOffset && tokOffset->str() == "::") {
+                    typeEnd = tokOffset;
+                    tokOffset = tokOffset->next();
                 }
 
-                // check for operator typedef
-                /** @todo add support for multi-token operators */
-                else if (isCPP() &&
-                         tok2->str() == "operator" &&
-                         tok2->next() &&
-                         tok2->next()->str() == typeName->str() &&
-                         tok2->linkAt(2) &&
-                         tok2->strAt(2) == "(" &&
-                         Token::Match(tok2->linkAt(2), ") const| {")) {
-                    // check for qualifier
-                    if (tok2->previous()->str() == "::") {
-                        // check for available and matching class name
-                        if (!spaceInfo.empty() && classLevel < spaceInfo.size() &&
-                            tok2->strAt(-2) == spaceInfo[classLevel].className) {
-                            tok2 = tok2->next();
-                            simplifyType = true;
-                        }
-                    }
-                }
-
-                // check for typedef that can be substituted
-                else if (Token::simpleMatch(tok2, pattern.c_str()) ||
-                         (inMemberFunc && tok2->str() == typeName->str())) {
-                    // member function class variables don't need qualification
-                    if (!(inMemberFunc && tok2->str() == typeName->str()) && pattern.find("::") != std::string::npos) { // has a "something ::"
-                        Token *start = tok2;
-                        int count = 0;
-                        int back = classLevel - 1;
-                        bool good = true;
-                        // check for extra qualification
-                        while (back >= 0) {
-                            Token *qualificationTok = start->tokAt(-2);
-                            if (!Token::Match(qualificationTok, "%type% ::"))
-                                break;
-                            if (qualificationTok->str() == spaceInfo[back].className) {
-                                start = qualificationTok;
-                                back--;
-                                count++;
-                            } else {
-                                good = false;
-                                break;
-                            }
-                        }
-                        // check global namespace
-                        if (good && back == 0 && start->strAt(-1) == "::")
-                            good = false;
-
-                        if (good) {
-                            // remove any extra qualification if present
-                            while (count) {
-                                tok2->tokAt(-3)->deleteNext(2);
-                                --count;
-                            }
-
-                            // remove global namespace if present
-                            if (tok2->strAt(-1) == "::") {
-                                tok2->tokAt(-2)->deleteNext();
-                                globalScope = true;
-                            }
-
-                            // remove qualification if present
-                            for (int i = classLevel; i < spaceInfo.size(); ++i) {
-                                tok2->deleteNext(2);
-                            }
-                            simplifyType = true;
-                        }
-                    } else {
-                        if (tok2->strAt(-1) == "::") {
-                            int relativeSpaceInfoSize = spaceInfo.size();
-                            Token * tokBeforeType = tok2->previous();
-                            while (relativeSpaceInfoSize != 0 &&
-                                   tokBeforeType && tokBeforeType->str() == "::" &&
-                                   tokBeforeType->strAt(-1) == spaceInfo[relativeSpaceInfoSize-1].className) {
-                                tokBeforeType = tokBeforeType->tokAt(-2);
-                                --relativeSpaceInfoSize;
-                            }
-                            if (tokBeforeType && tokBeforeType->str() != "::") {
-                                Token::eraseTokens(tokBeforeType, tok2);
-                                simplifyType = true;
-                            }
-                        } else if (Token::Match(tok2->previous(), "case|;|{|} %type% :")) {
-                            tok2 = tok2->next();
-                        } else if (duplicateTypedef(&tok2, typeName, typeDef)) {
-                            // skip to end of scope if not already there
-                            if (tok2->str() != "}") {
-                                while (tok2->next()) {
-                                    if (tok2->next()->str() == "{")
-                                        tok2 = tok2->linkAt(1)->previous();
-                                    else if (tok2->next()->str() == "}")
-                                        break;
-
-                                    tok2 = tok2->next();
-                                }
-                            }
-                        } else if (Token::Match(tok2->tokAt(-2), "%type% *|&")) {
-                            // Ticket #5868: Don't substitute variable names
-                        } else if (tok2->previous()->str() != ".") {
-                            simplifyType = true;
-                        }
-                    }
-                }
-
-                if (simplifyType) {
-                    // can't simplify 'operator functionPtr ()' and 'functionPtr operator ... ()'
-                    if (functionPtr && (tok2->previous()->str() == "operator" ||
-                                        (tok2->next() && tok2->next()->str() == "operator"))) {
-                        simplifyType = false;
-                        tok2 = tok2->next();
-                        continue;
-                    }
-
-                    // There are 2 categories of typedef substitutions:
-                    // 1. variable declarations that preserve the variable name like
-                    //    global, local, and function parameters
-                    // 2. not variable declarations that have no name like derived
-                    //    classes, casts, operators, and template parameters
-
-                    // try to determine which category this substitution is
-                    bool inCast = false;
-                    bool inTemplate = false;
-                    bool inOperator = false;
-                    bool inSizeof = false;
-
-                    const bool sameStartEnd = (typeStart == typeEnd);
-
-                    // check for derived class: class A : some_typedef {
-                    const bool isDerived = Token::Match(tok2->previous(), "public|protected|private %type% {|,");
-
-                    // check for cast: (some_typedef) A or static_cast<some_typedef>(A)
-                    // todo: check for more complicated casts like: (const some_typedef *)A
-                    if ((tok2->previous()->str() == "(" && tok2->next()->str() == ")" && tok2->strAt(-2) != "sizeof") ||
-                        (tok2->previous()->str() == "<" && Token::simpleMatch(tok2->next(), "> (")) ||
-                        Token::Match(tok2->tokAt(-2), "( const %name% )"))
-                        inCast = true;
-
-                    // check for template parameters: t<some_typedef> t1
-                    else if (Token::Match(tok2->previous(), "<|,") &&
-                             Token::Match(tok2->next(), "&|*| &|*| >|,"))
-                        inTemplate = true;
-
-                    else if (Token::Match(tok2->tokAt(-2), "sizeof ( %type% )"))
-                        inSizeof = true;
-
-                    // check for operator
-                    if (tok2->strAt(-1) == "operator" ||
-                        Token::simpleMatch(tok2->tokAt(-2), "operator const"))
-                        inOperator = true;
-
-                    if (typeStart->str() == "typename" && tok2->strAt(-1)=="typename") {
-                        // Remove one typename if it is already contained in the goal
-                        typeStart = typeStart->next();
-                    }
-
-                    // skip over class or struct in derived class declaration
-                    bool structRemoved = false;
-                    if (isDerived && Token::Match(typeStart, "class|struct")) {
-                        if (typeStart->str() == "struct")
-                            structRemoved = true;
-                        typeStart = typeStart->next();
-                    }
-                    if (Token::Match(typeStart, "struct|class") && Token::Match(tok2, "%name% ::"))
-                        typeStart = typeStart->next();
-
-                    if (sameStartEnd)
-                        typeEnd = typeStart;
-
-                    // start substituting at the typedef name by replacing it with the type
-                    tok2->str(typeStart->str());
-
-                    // restore qualification if it was removed
-                    if (typeStart->str() == "struct" || structRemoved) {
-                        if (structRemoved)
-                            tok2 = tok2->previous();
-
-                        if (globalScope) {
-                            tok2->insertToken("::");
-                            tok2 = tok2->next();
-                        }
-
-                        for (int i = classLevel; i < spaceInfo.size(); ++i) {
-                            tok2->insertToken(spaceInfo[i].className);
-                            tok2 = tok2->next();
-                            tok2->insertToken("::");
-                            tok2 = tok2->next();
-                        }
-                    }
-
-                    // add remainder of type
-                    tok2 = TokenList::copyTokens(tok2, typeStart->next(), typeEnd);
-
-                    if (!pointers.empty()) {
-                        for (const std::string &p : pointers) {
-                            tok2->insertToken(p);
-                            tok2 = tok2->next();
-                        }
-                    }
-
-                    if (funcStart && funcEnd) {
-                        tok2->insertToken("(");
-                        tok2 = tok2->next();
-                        Token *tok3 = tok2;
-                        tok2 = TokenList::copyTokens(tok2, funcStart, funcEnd);
-
-                        if (!inCast)
-                            tok2 = processFunc(tok2, inOperator);
-
-                        if (!tok2)
-                            break;
-
-                        tok2->insertToken(")");
-                        tok2 = tok2->next();
-                        Token::createMutualLinks(tok2, tok3);
-
-                        tok2 = TokenList::copyTokens(tok2, argStart, argEnd);
-
-                        if (specStart) {
-                            Token *spec = specStart;
-                            tok2->insertToken(spec->str());
-                            tok2 = tok2->next();
-                            while (spec != specEnd) {
-                                spec = spec->next();
-                                tok2->insertToken(spec->str());
-                                tok2 = tok2->next();
-                            }
-                        }
-                    }
-
-                    else if (functionPtr || function) {
-                        // don't add parentheses around function names because it
-                        // confuses other simplifications
-                        bool needParen = true;
-                        if (!inTemplate && function && tok2->next() && tok2->next()->str() != "*")
-                            needParen = false;
-                        if (needParen) {
-                            tok2->insertToken("(");
-                            tok2 = tok2->next();
-                        }
-                        Token *tok3 = tok2;
-                        if (namespaceStart) {
-                            const Token *tok4 = namespaceStart;
-
-                            while (tok4 != namespaceEnd) {
-                                tok2->insertToken(tok4->str());
-                                tok2 = tok2->next();
-                                tok4 = tok4->next();
-                            }
-                            tok2->insertToken(namespaceEnd->str());
-                            tok2 = tok2->next();
-                        }
-                        if (functionPtr) {
-                            tok2->insertToken("*");
-                            tok2 = tok2->next();
-                        }
-
-                        if (!inCast)
-                            tok2 = processFunc(tok2, inOperator);
-
-                        if (needParen) {
-                            if (!tok2)
-                                syntaxError(nullptr);
-
-                            tok2->insertToken(")");
-                            tok2 = tok2->next();
-                            Token::createMutualLinks(tok2, tok3);
-                        }
-                        if (!tok2)
-                            syntaxError(nullptr);
-
-                        tok2 = TokenList::copyTokens(tok2, argStart, argEnd);
-                        if (inTemplate) {
-                            if (!tok2)
-                                syntaxError(nullptr);
-
-                            tok2 = tok2->next();
-                        }
-
-                        if (specStart) {
-                            Token *spec = specStart;
-                            tok2->insertToken(spec->str());
-                            tok2 = tok2->next();
-                            while (spec != specEnd) {
-                                spec = spec->next();
-                                tok2->insertToken(spec->str());
-                                tok2 = tok2->next();
-                            }
-                        }
-                    } else if (functionRetFuncPtr || functionPtrRetFuncPtr) {
-                        tok2->insertToken("(");
-                        tok2 = tok2->next();
-                        Token *tok3 = tok2;
-                        tok2->insertToken("*");
-                        tok2 = tok2->next();
-
-                        Token * tok4 = nullptr;
-                        if (functionPtrRetFuncPtr) {
-                            tok2->insertToken("(");
-                            tok2 = tok2->next();
-                            tok4 = tok2;
-                            tok2->insertToken("*");
-                            tok2 = tok2->next();
-                        }
-
-                        // skip over variable name if there
-                        if (!inCast) {
-                            if (!tok2 || !tok2->next())
-                                syntaxError(nullptr);
-
-                            if (tok2->next()->str() != ")")
-                                tok2 = tok2->next();
-                        }
-
-                        if (tok4 && functionPtrRetFuncPtr) {
-                            tok2->insertToken(")");
-                            tok2 = tok2->next();
-                            Token::createMutualLinks(tok2, tok4);
-                        }
-
-                        tok2 = TokenList::copyTokens(tok2, argStart, argEnd);
-
-                        tok2->insertToken(")");
-                        tok2 = tok2->next();
-                        Token::createMutualLinks(tok2, tok3);
-
-                        tok2 = TokenList::copyTokens(tok2, argFuncRetStart, argFuncRetEnd);
-                    } else if (ptrToArray || refToArray) {
-                        tok2->insertToken("(");
-                        tok2 = tok2->next();
-                        Token *tok3 = tok2;
-
-                        if (ptrToArray)
-                            tok2->insertToken("*");
-                        else
-                            tok2->insertToken("&");
-                        tok2 = tok2->next();
-
-                        // skip over name
-                        if (tok2->next() && tok2->next()->str() != ")") {
-                            if (tok2->next()->str() != "(")
-                                tok2 = tok2->next();
-
-                            // check for function and skip over args
-                            if (tok2 && tok2->next() && tok2->next()->str() == "(")
-                                tok2 = tok2->next()->link();
-
-                            // check for array
-                            if (tok2 && tok2->next() && tok2->next()->str() == "[")
-                                tok2 = tok2->next()->link();
-                        } else {
-                            // syntax error
-                        }
-
-                        tok2->insertToken(")");
-                        Token::createMutualLinks(tok2->next(), tok3);
-                    } else if (ptrMember) {
-                        if (Token::simpleMatch(tok2, "* (")) {
-                            tok2->insertToken("*");
-                            tok2 = tok2->next();
-                        } else {
-                            // This is the case of casting operator.
-                            // Name is not available, and () should not be
-                            // inserted
-                            const bool castOperator = inOperator && Token::Match(tok2, "%type% (");
-                            Token *openParenthesis = nullptr;
-
-                            if (!castOperator) {
-                                tok2->insertToken("(");
-                                tok2 = tok2->next();
-
-                                openParenthesis = tok2;
-                            }
-
-                            const Token *tok4 = namespaceStart;
-
-                            while (tok4 != namespaceEnd) {
-                                tok2->insertToken(tok4->str());
-                                tok2 = tok2->next();
-                                tok4 = tok4->next();
-                            }
-                            tok2->insertToken(namespaceEnd->str());
-                            tok2 = tok2->next();
-
-                            tok2->insertToken("*");
-                            tok2 = tok2->next();
-
-                            if (openParenthesis) {
-                                // Skip over name, if any
-                                if (Token::Match(tok2->next(), "%name%"))
-                                    tok2 = tok2->next();
-
-                                tok2->insertToken(")");
-                                tok2 = tok2->next();
-
-                                Token::createMutualLinks(tok2, openParenthesis);
-                            }
-                        }
-                    } else if (typeOf) {
-                        tok2 = TokenList::copyTokens(tok2, argStart, argEnd);
-                    } else if (Token::Match(tok2, "%name% [")) {
-                        while (Token::Match(tok2, "%name%|] [")) {
-                            tok2 = tok2->linkAt(1);
-                        }
-                        tok2 = tok2->previous();
-                    }
-
-                    if (arrayStart && arrayEnd) {
-                        do {
-                            if (!tok2->next())
-                                syntaxError(tok2); // can't recover so quit
-
-                            if (!inCast && !inSizeof && !inTemplate)
-                                tok2 = tok2->next();
-
-                            if (tok2->str() == "const")
-                                tok2 = tok2->next();
-
-                            // reference or pointer to array?
-                            if (tok2->str() == "&" || tok2->str() == "*") {
-                                tok2 = tok2->previous();
-                                tok2->insertToken("(");
-                                Token *tok3 = tok2->next();
-
-                                // handle missing variable name
-                                if (tok2->strAt(3) == ")" || tok2->strAt(3) == ",")
-                                    tok2 = tok2->tokAt(2);
-                                else
-                                    tok2 = tok2->tokAt(3);
-                                if (!tok2)
-                                    syntaxError(nullptr);
-
-                                while (tok2->strAt(1) == "::")
-                                    tok2 = tok2->tokAt(2);
-
-                                // skip over function parameters
-                                if (tok2->strAt(1) == "(") {
-                                    tok2 = tok2->linkAt(1);
-
-                                    if (tok2->strAt(1) == "const")
-                                        tok2 = tok2->next();
-                                }
-
-                                tok2->insertToken(")");
-                                tok2 = tok2->next();
-                                Token::createMutualLinks(tok2, tok3);
-                            }
-
-                            if (!tok2->next())
-                                syntaxError(tok2); // can't recover so quit
-
-                            // skip over array dimensions
-                            while (tok2->next()->str() == "[")
-                                tok2 = tok2->linkAt(1);
-
-                            tok2 = TokenList::copyTokens(tok2, arrayStart, arrayEnd);
-                            if (!tok2->next())
-                                syntaxError(tok2);
-
-                            if (tok2->str() == "=") {
-                                if (!tok2->next())
-                                    syntaxError(tok2);
-                                if (tok2->next()->str() == "{")
-                                    tok2 = tok2->next()->link()->next();
-                                else if (tok2->next()->str().at(0) == '\"')
-                                    tok2 = tok2->tokAt(2);
-                            }
-                        } while (Token::Match(tok2, ", %name% ;|=|,"));
-                    }
-
-                    simplifyType = false;
-                }
-                if (!tok2)
-                    break;
-            }
-
-            if (!tok)
-                syntaxError(nullptr);
-
-            if (tok->str() == ";")
-                done = true;
-            else if (tok->str() == ",") {
-                arrayStart = nullptr;
-                arrayEnd = nullptr;
-                tokOffset = tok->next();
-                pointers.clear();
-
-                while (Token::Match(tokOffset, "*|&")) {
-                    pointers.push_back(tokOffset->str());
-                    tokOffset = tokOffset->next();
-                }
-
-                if (Token::Match(tokOffset, "%type%")) {
-                    typeName = tokOffset;
-                    tokOffset = tokOffset->next();
-
-                    if (tokOffset && tokOffset->str() == "[") {
-                        arrayStart = tokOffset;
-
-                        for (;;) {
-                            while (tokOffset->next() && !Token::Match(tokOffset->next(), ";|,"))
-                                tokOffset = tokOffset->next();
-
-                            if (!tokOffset->next())
-                                return; // invalid input
-                            else if (tokOffset->next()->str() == ";")
-                                break;
-                            else if (tokOffset->str() == "]")
-                                break;
-                            else
-                                tokOffset = tokOffset->next();
-                        }
-
-                        arrayEnd = tokOffset;
-                        tokOffset = tokOffset->next();
-                    }
-
-                    if (Token::Match(tokOffset, ";|,"))
-                        tok = tokOffset;
-                    else {
-                        // we encountered a typedef we don't support yet so just continue
-                        done = true;
-                        ok = false;
-                    }
-                } else {
-                    // we encountered a typedef we don't support yet so just continue
-                    done = true;
-                    ok = false;
-                }
-            } else {
-                // something is really wrong (internal error)
-                done = true;
-                ok = false;
-            }
-        }
-
-        if (ok) {
-            // remove typedef
-            Token::eraseTokens(typeDef, tok);
-
-            if (typeDef != list.front()) {
-                tok = typeDef->previous();
-                tok->deleteNext();
-                //no need to remove last token in the list
-                if (tok->tokAt(2))
-                    tok->deleteNext();
-            } else {
-                list.front()->deleteThis();
-                //no need to remove last token in the list
-                if (list.front()->next())
-                    list.front()->deleteThis();
-                tok = list.front();
-                //now the next token to process is 'tok', not 'tok->next()';
-                goback = true;
+                if (Token::Match(tokOffset, "%type%") &&
+                    tokOffset->next() && !Token::Match(tokOffset->next(), "[|;|,|(")) {
+                    typeEnd = tokOffset;
+                    tokOffset = tokOffset->next();
+                } else if (Token::simpleMatch(tokOffset, "const (")) {
+                    typeEnd = tokOffset;
+                    tokOffset = tokOffset->next();
+                    atEnd = true;
+                } else
+                    atEnd = true;
             }
-        }
-    }
-}
+        } else
+            continue; // invalid input
 
-namespace {
-    struct ScopeInfo3 {
-        ScopeInfo3(const std::string &name_, const Token *bodyEnd_) : name(name_), bodyEnd(bodyEnd_) {}
-        const std::string name;
-        const Token * const bodyEnd;
-        std::set<std::string> usingNamespaces;
-    };
+        // check for invalid input
+        if (!tokOffset)
+            syntaxError(tok);
 
-    std::string getScopeName(const std::list<ScopeInfo3> &scopeInfo)
-    {
-        std::string ret;
-        for (const ScopeInfo3 &i : scopeInfo) {
-            if (!i.name.empty())
-                ret += (ret.empty() ? "" : " :: ") + i.name;
-        }
-        return ret;
-    }
+        // check for template
+        if (!isC() && tokOffset->str() == "<") {
+            typeEnd = tokOffset->findClosingBracket();
 
-    void setScopeInfo(Token *tok, std::list<ScopeInfo3> *scopeInfo, bool all = false)
-    {
-        while (tok->str() == "}" && !scopeInfo->empty() && tok == scopeInfo->back().bodyEnd)
-            scopeInfo->pop_back();
-        if (!Token::Match(tok, "namespace|class|struct|union %name% {|:|::")) {
-            // check for using namespace
-            if (Token::Match(tok, "using namespace %name% ;|::")) {
-                const Token * tok1 = tok->tokAt(2);
-                std::string nameSpace;
-                while (tok1 && tok1->str() != ";") {
-                    if (!nameSpace.empty())
-                        nameSpace += " ";
-                    nameSpace += tok1->str();
-                    tok1 = tok1->next();
-                }
-                scopeInfo->back().usingNamespaces.insert(nameSpace);
-            }
-            // check for member function
-            else if (tok->str() == "{") {
-                bool added = false;
-                Token *tok1 = tok;
-                while (Token::Match(tok1->previous(), "const|volatile|final|override|&|&&|noexcept"))
-                    tok1 = tok1->previous();
-                if (tok1 && tok1->previous() && tok1->strAt(-1) == ")") {
-                    tok1 = tok1->linkAt(-1);
-                    if (Token::Match(tok1->previous(), "throw|noexcept")) {
-                        tok1 = tok1->previous();
-                        while (Token::Match(tok1->previous(), "const|volatile|final|override|&|&&|noexcept"))
-                            tok1 = tok1->previous();
-                        if (tok1->strAt(-1) != ")")
-                            return;
-                    } else if (Token::Match(tok->tokAt(-2), ":|, %name%")) {
-                        tok1 = tok1->tokAt(-2);
-                        if (tok1->strAt(-1) != ")")
-                            return;
-                    }
-                    if (tok1->strAt(-1) == ">")
-                        tok1 = tok1->previous()->findOpeningBracket();
-                    if (tok1 && Token::Match(tok1->tokAt(-3), "%name% :: %name%")) {
-                        tok1 = tok1->tokAt(-2);
-                        std::string scope = tok1->strAt(-1);
-                        while (Token::Match(tok1->tokAt(-2), ":: %name%")) {
-                            scope = tok1->strAt(-3) + " :: " + scope;
-                            tok1 = tok1->tokAt(-2);
-                        }
-                        scopeInfo->emplace_back(scope, tok->link());
-                        added = true;
-                    }
-                }
+            while (typeEnd && Token::Match(typeEnd->next(), ":: %type%"))
+                typeEnd = typeEnd->tokAt(2);
 
-                if (all && !added)
-                    scopeInfo->emplace_back("", tok->link());
+            if (!typeEnd) {
+                // internal error
+                return;
             }
-            return;
-        }
 
-        tok = tok->next();
-        std::string classname = tok->str();
-        while (Token::Match(tok, "%name% :: %name%")) {
-            tok = tok->tokAt(2);
-            classname += " :: " + tok->str();
-        }
-        tok = tok->next();
-        if (tok && tok->str() == ":") {
-            while (tok && !Token::Match(tok, ";|{"))
-                tok = tok->next();
+            while (Token::Match(typeEnd->next(), "const|volatile"))
+                typeEnd = typeEnd->next();
+
+            tok = typeEnd;
+            tokOffset = tok->next();
         }
-        if (tok && tok->str() == "{") {
-            scopeInfo->emplace_back(classname,tok->link());
+
+        std::list<std::string> pointers;
+        // check for pointers and references
+        while (Token::Match(tokOffset, "*|&|&&|const")) {
+            pointers.push_back(tokOffset->str());
+            tokOffset = tokOffset->next();
         }
-    }
 
-    Token *findSemicolon(Token *tok)
-    {
-        int level = 0;
+        // check for invalid input
+        if (!tokOffset)
+            syntaxError(tok);
 
-        for (; tok && (level > 0 || tok->str() != ";"); tok = tok->next()) {
-            if (tok->str() == "{")
-                ++level;
-            else if (level > 0 && tok->str() == "}")
-                --level;
-        }
+        if (tokOffset->isName() && !tokOffset->isKeyword()) {
+            // found the type name
+            typeName = tokOffset;
+            tokOffset = tokOffset->next();
 
-        return tok;
-    }
+            // check for array
+            while (tokOffset && tokOffset->str() == "[") {
+                if (!arrayStart)
+                    arrayStart = tokOffset;
+                arrayEnd = tokOffset->link();
+                tokOffset = arrayEnd->next();
+            }
 
-    bool usingMatch(
-        const Token *nameToken,
-        const std::string &scope,
-        Token **tok,
-        const std::string &scope1,
-        const std::list<ScopeInfo3> &scopeList1)
-    {
-        Token *tok1 = *tok;
+            // check for end or another
+            if (Token::Match(tokOffset, ";|,"))
+                tok = tokOffset;
 
-        if (tok1 && tok1->str() != nameToken->str())
-            return false;
+            // or a function typedef
+            else if (tokOffset && tokOffset->str() == "(") {
+                Token *tokOffset2 = nullptr;
+                if (Token::Match(tokOffset, "( *|%name%")) {
+                    tokOffset2 = tokOffset->next();
+                    if (tokOffset2->str() == "typename")
+                        tokOffset2 = tokOffset2->next();
+                    while (Token::Match(tokOffset2, "%type% ::"))
+                        tokOffset2 = tokOffset2->tokAt(2);
+                }
 
-        // skip this using
-        if (tok1 == nameToken) {
-            *tok = findSemicolon(tok1);
-            return false;
-        }
+                // unhandled typedef, skip it and continue
+                if (typeName->str() == "void") {
+                    unsupportedTypedef(typeDef);
+                    tok = deleteInvalidTypedef(typeDef);
+                    if (tok == list.front())
+                        //now the next token to process is 'tok', not 'tok->next()';
+                        goback = true;
+                    continue;
+                }
 
-        // skip other using with this name
-        if (tok1->strAt(-1) == "using") {
-            // fixme: this is wrong
-            // skip to end of scope
-            if (scopeList1.back().bodyEnd)
-                *tok = scopeList1.back().bodyEnd->previous();
-            return false;
-        }
+                // function pointer
+                if (Token::Match(tokOffset2, "* %name% ) (")) {
+                    // name token wasn't a name, it was part of the type
+                    typeEnd = typeEnd->next();
+                    functionPtr = true;
+                    funcStart = funcEnd = tokOffset2; // *
+                    tokOffset = tokOffset2->tokAt(3); // (
+                    typeName = tokOffset->tokAt(-2);
+                    argStart = tokOffset;
+                    argEnd = tokOffset->link();
+                    tok = argEnd->next();
+                }
 
-        if (Token::Match(tok1->tokAt(-1), "class|struct|union|enum")) {
-            // fixme
-            return false;
-        }
+                // function
+                else if (TokenList::isFunctionHead(tokOffset->link(), ";,")) {
+                    function = true;
+                    if (tokOffset->link()->strAt(1) == "const") {
+                        specStart = tokOffset->link()->next();
+                        specEnd = specStart;
+                    }
+                    argStart = tokOffset;
+                    argEnd = tokOffset->link();
+                    tok = argEnd->next();
+                    if (specStart)
+                        tok = tok->next();
+                }
 
-        // get qualification
-        std::string qualification;
-        const Token* tok2 = tok1;
-        std::string::size_type index = scope.size();
-        std::string::size_type new_index = std::string::npos;
-        bool match = true;
-        while (tok2->strAt(-1) == "::") {
-            std::string last;
-            if (match && !scope1.empty()) {
-                new_index = scope1.rfind(' ', index - 1);
-                if (new_index != std::string::npos)
-                    last = scope1.substr(new_index, index - new_index);
-                else if (!qualification.empty())
-                    last.clear();
+                // syntax error
                 else
-                    last = scope1;
-            } else
-                match = false;
-            if (match && tok2->strAt(-2) == last)
-                index = new_index;
-            else {
-                if (!qualification.empty())
-                    qualification = " :: " + qualification;
-                qualification = tok2->strAt(-2) + qualification;
+                    syntaxError(tok);
             }
-            tok2 = tok2->tokAt(-2);
-        }
-
-        std::string fullScope1 = scope1;
-        if (!scope1.empty() && !qualification.empty())
-            fullScope1 += " :: ";
-        fullScope1 += qualification;
-
-        if (scope == fullScope1)
-            return true;
 
-        // check using namespace
-        if (!scopeList1.back().usingNamespaces.empty()) {
-            if (qualification.empty()) {
-                if (scopeList1.back().usingNamespaces.find(scope) != scopeList1.back().usingNamespaces.end())
-                    return true;
-            } else {
-                for (auto ns : scopeList1.back().usingNamespaces) {
-                    if (scope == ns + " :: " + qualification)
-                        return true;
-                }
+            // unhandled typedef, skip it and continue
+            else {
+                unsupportedTypedef(typeDef);
+                tok = deleteInvalidTypedef(typeDef);
+                if (tok == list.front())
+                    //now the next token to process is 'tok', not 'tok->next()';
+                    goback = true;
+                continue;
             }
         }
 
-        std::string newScope1 = scope1;
-
-        // scopes didn't match so try higher scopes
-        index = newScope1.size();
-        while (!newScope1.empty()) {
-            std::string::size_type separator = newScope1.rfind(" :: ", index - 1);
-            if (separator != std::string::npos)
-                newScope1 = newScope1.substr(0, separator);
-            else
-                newScope1.clear();
-
-            std::string newFullScope1 = newScope1;
-            if (!newScope1.empty() && !qualification.empty())
-                newFullScope1 += " :: ";
-            newFullScope1 += qualification;
-
-            if (scope == newFullScope1)
-                return true;
+        // typeof: typedef typeof ( ... ) type;
+        else if (Token::simpleMatch(tokOffset->previous(), "typeof (") &&
+                 Token::Match(tokOffset->link(), ") %type% ;")) {
+            argStart = tokOffset;
+            argEnd = tokOffset->link();
+            typeName = tokOffset->link()->next();
+            tok = typeName->next();
+            typeOf = true;
         }
 
-        return false;
-    }
-} // namespace
-
-bool Tokenizer::simplifyUsing()
-{
-    bool substitute = false;
-    std::list<ScopeInfo3> scopeList;
-    struct Using {
-        Using(Token *start, Token *end) : startTok(start), endTok(end) { }
-        Token *startTok;
-        Token *endTok;
-    };
-    std::list<Using> usingList;
-
-    scopeList.emplace_back("", nullptr);
+        // function: typedef ... ( ... type )( ... );
+        //           typedef ... (( ... type )( ... ));
+        //           typedef ... ( * ( ... type )( ... ));
+        else if (tokOffset->str() == "(" && (
+                     (tokOffset->link() && Token::Match(tokOffset->link()->previous(), "%type% ) (") &&
+                      Token::Match(tokOffset->link()->linkAt(1), ") const|volatile|;")) ||
+                     (Token::simpleMatch(tokOffset, "( (") &&
+                      tokOffset->next() && Token::Match(tokOffset->linkAt(1)->previous(), "%type% ) (") &&
+                      Token::Match(tokOffset->linkAt(1)->linkAt(1), ") const|volatile| ) ;|,")) ||
+                     (Token::simpleMatch(tokOffset, "( * (") &&
+                      tokOffset->linkAt(2) && Token::Match(tokOffset->linkAt(2)->previous(), "%type% ) (") &&
+                      Token::Match(tokOffset->linkAt(2)->linkAt(1), ") const|volatile| ) ;|,")))) {
+            if (tokOffset->strAt(1) == "(")
+                tokOffset = tokOffset->next();
+            else if (Token::simpleMatch(tokOffset, "( * (")) {
+                pointers.emplace_back("*");
+                tokOffset = tokOffset->tokAt(2);
+            }
 
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (mErrorLogger && !list.getFiles().empty())
-            mErrorLogger->reportProgress(list.getFiles()[0], "Tokenize (using)", tok->progressValue());
+            if (tokOffset->link()->strAt(-2) == "*")
+                functionPtr = true;
+            else
+                function = true;
+            funcStart = tokOffset->next();
+            tokOffset = tokOffset->link();
+            funcEnd = tokOffset->tokAt(-2);
+            typeName = tokOffset->previous();
+            argStart = tokOffset->next();
+            argEnd = tokOffset->linkAt(1);
+            if (!argEnd)
+                syntaxError(argStart);
+            const Token* tok2 = argEnd->next();
+            while (tok2 && (tok2->isKeyword() || tok2->str() == ")"))
+                tok2 = tok2->next();
+            if (!Token::simpleMatch(tok2, ";"))
+                syntaxError(tok2);
 
-        if (Settings::terminated())
-            return substitute;
+            tok = argEnd->next();
+            Token *spec = tok;
+            if (Token::Match(spec, "const|volatile")) {
+                specStart = spec;
+                specEnd = spec;
+                while (Token::Match(spec->next(), "const|volatile")) {
+                    specEnd = spec->next();
+                    spec = specEnd;
+                }
+                tok = specEnd->next();
+            }
+            if (!tok)
+                syntaxError(specEnd);
 
-        if (Token::Match(tok, "{|}|namespace|class|struct|union") ||
-            Token::Match(tok, "using namespace %name% ;|::")) {
-            setScopeInfo(tok, &scopeList);
+            if (tok->str() == ")")
+                tok = tok->next();
         }
 
-        // skip template declarations
-        if (Token::Match(tok, "template < !!>")) {
-            Token *endToken = TemplateSimplifier::findTemplateDeclarationEnd(tok);
-            if (endToken)
-                tok = endToken;
-            continue;
+        else if (Token::Match(tokOffset, "( %type% (")) {
+            function = true;
+            if (tokOffset->link()->next()) {
+                tok = tokOffset->link()->next();
+                tokOffset = tokOffset->tokAt(2);
+                typeName = tokOffset->previous();
+                argStart = tokOffset;
+                argEnd = tokOffset->link();
+            } else {
+                // internal error
+                continue;
+            }
         }
 
-        // look for non-template type aliases
-        if (!(tok->strAt(-1) != ">" &&
-              (Token::Match(tok, "using %name% = ::| %name%") ||
-               (Token::Match(tok, "using %name% [ [") &&
-                Token::Match(tok->linkAt(2), "] ] = ::| %name%")))))
-            continue;
+        // pointer to function returning pointer to function
+        else if (Token::Match(tokOffset, "( * ( * %type% ) (") &&
+                 Token::simpleMatch(tokOffset->linkAt(6), ") ) (") &&
+                 Token::Match(tokOffset->linkAt(6)->linkAt(2), ") ;|,")) {
+            functionPtrRetFuncPtr = true;
 
-        std::list<ScopeInfo3> scopeList1;
-        scopeList1.emplace_back("", nullptr);
-        std::string name = tok->strAt(1);
-        const Token *nameToken = tok->next();
-        std::string scope = getScopeName(scopeList);
-        Token *usingStart = tok;
-        Token *start;
-        if (tok->strAt(2) == "=")
-            start = tok->tokAt(3);
-        else
-            start = tok->linkAt(2)->tokAt(3);
-        Token *usingEnd = findSemicolon(start);
-        if (!usingEnd)
-            continue;
+            tokOffset = tokOffset->tokAt(6);
+            typeName = tokOffset->tokAt(-2);
+            argStart = tokOffset;
+            argEnd = tokOffset->link();
+            if (!argEnd)
+                syntaxError(arrayStart);
 
-        // Move struct defined in using out of using.
-        // using T = struct t { }; => struct t { }; using T = struct t;
-        // fixme: this doesn't handle attributes
-        if (Token::Match(start, "struct|union|enum %name%| {")) {
-            if (start->strAt(1) != "{") {
-                Token *structEnd = start->linkAt(2);
-                structEnd->insertToken(";", "");
-                TokenList::copyTokens(structEnd->next(), tok, start->next());
-                usingStart = structEnd->tokAt(2);
-                nameToken = usingStart->next();
-                if (usingStart->strAt(2) == "=")
-                    start = usingStart->tokAt(3);
-                else
-                    start = usingStart->linkAt(2)->tokAt(3);
-                usingEnd = findSemicolon(start);
-                tok->deleteThis();
-                tok->deleteThis();
-                tok->deleteThis();
-                tok = usingStart;
-            } else {
-                Token *structEnd = start->linkAt(1);
-                structEnd->insertToken(";", "");
-                std::string newName;
-                if (structEnd->strAt(2) == ";")
-                    newName = name;
-                else
-                    newName = "Unnamed" + MathLib::toString(mUnnamedCount++);
-                TokenList::copyTokens(structEnd->next(), tok, start);
-                structEnd->tokAt(5)->insertToken(newName, "");
-                start->insertToken(newName, "");
+            argFuncRetStart = argEnd->tokAt(2);
+            argFuncRetEnd = argFuncRetStart->link();
+            if (!argFuncRetEnd)
+                syntaxError(argFuncRetStart);
 
-                usingStart = structEnd->tokAt(2);
-                nameToken = usingStart->next();
-                if (usingStart->strAt(2) == "=")
-                    start = usingStart->tokAt(3);
-                else
-                    start = usingStart->linkAt(2)->tokAt(3);
-                usingEnd = findSemicolon(start);
-                tok->deleteThis();
-                tok->deleteThis();
-                tok->deleteThis();
-                tok = usingStart;
-            }
+            tok = argFuncRetEnd->next();
         }
 
-        // remove 'typename' and 'template'
-        else if (start->str() == "typename") {
-            start->deleteThis();
-            Token *temp = start;
-            while (Token::Match(temp, "%name% ::"))
-                temp = temp->tokAt(2);
-            if (Token::Match(temp, "template %name%"))
-                temp->deleteThis();
-        }
+        // function returning pointer to function
+        else if (Token::Match(tokOffset, "( * %type% (") &&
+                 Token::simpleMatch(tokOffset->linkAt(3), ") ) (") &&
+                 Token::Match(tokOffset->linkAt(3)->linkAt(2), ") ;|,")) {
+            functionRetFuncPtr = true;
 
-        // Unfortunately we have to start searching from the beginning
-        // of the token stream because templates are instantiated at
-        // the end of the token stream and it may be used before then.
-        std::string scope1;
-        bool skip = false; // don't erase type aliases we can't parse
-        for (Token* tok1 = list.front(); tok1; tok1 = tok1->next()) {
-            if ((Token::Match(tok1, "{|}|namespace|class|struct|union") && tok1->strAt(-1) != "using") ||
-                Token::Match(tok1, "using namespace %name% ;|::")) {
-                setScopeInfo(tok1, &scopeList1, true);
-                scope1 = getScopeName(scopeList1);
-                continue;
-            }
+            tokOffset = tokOffset->tokAt(3);
+            typeName = tokOffset->previous();
+            argStart = tokOffset;
+            argEnd = tokOffset->link();
 
-            // skip template definitions
-            if (Token::Match(tok1, "template < !!>")) {
-                Token *endToken = TemplateSimplifier::findTemplateDeclarationEnd(tok1);
-                if (endToken)
-                    tok1 = endToken;
-                continue;
-            }
+            argFuncRetStart = argEnd->tokAt(2);
+            if (!argFuncRetStart)
+                syntaxError(tokOffset);
 
-            if (!usingMatch(nameToken, scope, &tok1, scope1, scopeList1))
-                continue;
+            argFuncRetEnd = argFuncRetStart->link();
+            if (!argFuncRetEnd)
+                syntaxError(tokOffset);
 
-            // remove the qualification
-            std::string fullScope = scope;
-            while (tok1->strAt(-1) == "::") {
-                if (fullScope == tok1->strAt(-2)) {
-                    tok1->deletePrevious();
-                    tok1->deletePrevious();
-                    break;
-                } else {
-                    const std::string::size_type idx = fullScope.rfind(" ");
+            tok = argFuncRetEnd->next();
+        } else if (Token::Match(tokOffset, "( * ( %type% ) (")) {
+            functionRetFuncPtr = true;
 
-                    if (idx == std::string::npos)
-                        break;
+            tokOffset = tokOffset->tokAt(5);
+            typeName = tokOffset->tokAt(-2);
+            argStart = tokOffset;
+            argEnd = tokOffset->link();
+            if (!argEnd)
+                syntaxError(arrayStart);
 
-                    if (tok1->strAt(-2) == fullScope.substr(idx + 1)) {
-                        tok1->deletePrevious();
-                        tok1->deletePrevious();
-                        fullScope.resize(idx - 3);
-                    } else
-                        break;
-                }
-            }
+            argFuncRetStart = argEnd->tokAt(2);
+            if (!argFuncRetStart)
+                syntaxError(tokOffset);
 
-            Token * arrayStart = nullptr;
+            argFuncRetEnd = argFuncRetStart->link();
+            if (!argFuncRetEnd)
+                syntaxError(tokOffset);
 
-            // parse the type
-            Token *type = start;
-            if (type->str() == "::") {
-                type = type->next();
-                while (Token::Match(type, "%type% ::"))
-                    type = type->tokAt(2);
-                if (Token::Match(type, "%type%"))
-                    type = type->next();
-            } else if (Token::Match(type, "%type% ::")) {
-                do {
-                    type = type->tokAt(2);
-                } while (Token::Match(type, "%type% ::"));
-                if (Token::Match(type, "%type%"))
-                    type = type->next();
-            } else if (Token::Match(type, "%type%")) {
-                while (Token::Match(type, "const|struct|union|enum %type%") ||
-                       (type->next() && type->next()->isStandardType()))
-                    type = type->next();
+            tok = argFuncRetEnd->next();
+        }
 
-                type = type->next();
+        // pointer/reference to array
+        else if (Token::Match(tokOffset, "( *|& %type% ) [")) {
+            ptrToArray = (tokOffset->strAt(1) == "*");
+            refToArray = !ptrToArray;
+            tokOffset = tokOffset->tokAt(2);
+            typeName = tokOffset;
+            arrayStart = tokOffset->tokAt(2);
+            arrayEnd = arrayStart->link();
+            if (!arrayEnd)
+                syntaxError(arrayStart);
 
-                while (Token::Match(type, "%type%") &&
-                       (type->isStandardType() || Token::Match(type, "unsigned|signed"))) {
-                    type = type->next();
-                }
+            tok = arrayEnd->next();
+        }
 
-                bool atEnd = false;
-                while (!atEnd) {
-                    if (type && type->str() == "::") {
-                        type = type->next();
-                    }
+        // pointer to class member
+        else if (Token::Match(tokOffset, "( %type% :: * %type% ) ;")) {
+            tokOffset = tokOffset->tokAt(2);
+            namespaceStart = tokOffset->previous();
+            namespaceEnd = tokOffset;
+            ptrMember = true;
+            tokOffset = tokOffset->tokAt(2);
+            typeName = tokOffset;
+            tok = tokOffset->tokAt(2);
+        }
 
-                    if (Token::Match(type, "%type%") &&
-                        type->next() && !Token::Match(type->next(), "[|;|,|(")) {
-                        type = type->next();
-                    } else if (Token::simpleMatch(type, "const (")) {
-                        type = type->next();
-                        atEnd = true;
-                    } else
-                        atEnd = true;
-                }
-            } else
-                syntaxError(type);
+        // unhandled typedef, skip it and continue
+        else {
+            unsupportedTypedef(typeDef);
+            tok = deleteInvalidTypedef(typeDef);
+            if (tok == list.front())
+                //now the next token to process is 'tok', not 'tok->next()';
+                goback = true;
+            continue;
+        }
 
-            // check for invalid input
-            if (!type)
-                syntaxError(tok1);
+        bool done = false;
+        bool ok = true;
 
-            // check for template
-            if (type->str() == "<") {
-                type = type->findClosingBracket();
+        TypedefInfo typedefInfo;
+        typedefInfo.name = typeName->str();
+        typedefInfo.filename = list.file(typeName);
+        typedefInfo.lineNumber = typeDef->linenr();
+        typedefInfo.column = typeDef->column();
+        if (Token::Match(typeDef->next(), "struct|enum|class|union %name% {") && typeDef->strAt(2) == typedefInfo.name) {
+            typedefInfo.tagLine = typeDef->tokAt(2)->linenr();
+            typedefInfo.tagColumn = typeDef->tokAt(2)->column();
+        }
+        typedefInfo.used = false;
+        typedefInfo.isFunctionPointer = isFunctionPointer(typeName);
+        if (typedefInfo.isFunctionPointer) {
+            const Token* t = typeDef;
+            while (t != tok) {
+                TypedefToken ttok;
+                ttok.name = t->str();
+                ttok.lineNumber = t->linenr();
+                ttok.column = t->column();
+                typedefInfo.typedefInfoTokens.emplace_back(ttok);
+                t = t->next();
+            }
+        }
+        mTypedefInfo.push_back(std::move(typedefInfo));
 
-                while (type && Token::Match(type->next(), ":: %type%"))
-                    type = type->tokAt(2);
+        while (!done) {
+            std::string pattern = typeName->str();
+            int scope = 0;
+            bool simplifyType = false;
+            bool inMemberFunc = false;
+            int memberScope = 0;
+            bool globalScope = false;
+            int classLevel = spaceInfo.size();
+            bool inTypeDef = false;
+            bool inEnum = false;
+            std::string removed;
+            std::string classPath;
+            for (size_t i = 1; i < spaceInfo.size(); ++i) {
+                if (!classPath.empty())
+                    classPath += " :: ";
+                classPath += spaceInfo[i].className;
+            }
 
-                if (!type) {
-                    syntaxError(tok1);
-                }
+            for (Token *tok2 = tok; tok2; tok2 = tok2->next()) {
+                if (Settings::terminated())
+                    return;
 
-                while (Token::Match(type->next(), "const|volatile"))
-                    type = type->next();
+                removed.clear();
 
-                type = type->next();
-            }
+                if (Token::simpleMatch(tok2, "typedef"))
+                    inTypeDef = true;
 
-            // check for pointers and references
-            std::list<std::string> pointers;
-            while (Token::Match(type, "*|&|&&|const")) {
-                pointers.push_back(type->str());
-                type = type->next();
-            }
+                if (inTypeDef && Token::simpleMatch(tok2, ";"))
+                    inTypeDef = false;
 
-            // check for array
-            if (type && type->str() == "[") {
-                do {
-                    if (!arrayStart)
-                        arrayStart = type;
+                // Check for variable declared with the same name
+                if (!inTypeDef && spaceInfo.size() == 1 && Token::Match(tok2->previous(), "%name%") &&
+                    !tok2->previous()->isKeyword()) {
+                    Token* varDecl = tok2;
+                    while (Token::Match(varDecl, "*|&|&&|const"))
+                        varDecl = varDecl->next();
+                    if (Token::Match(varDecl, "%name% ;|,|)|=") && varDecl->str() == typeName->str()) {
+                        // Skip to the next closing brace
+                        if (Token::Match(varDecl, "%name% ) {")) { // is argument variable
+                            tok2 = varDecl->linkAt(2)->next();
+                        } else {
+                            tok2 = varDecl;
+                            while (tok2 && !Token::simpleMatch(tok2, "}")) {
+                                if (Token::Match(tok2, "(|{|["))
+                                    tok2 = tok2->link();
+                                tok2 = tok2->next();
+                            }
+                        }
+                        if (!tok2)
+                            break;
+                        continue;
+                    }
+                }
 
-                    bool atEnd = false;
-                    while (!atEnd) {
-                        while (type->next() && !Token::Match(type->next(), ";|,")) {
-                            type = type->next();
+                if (tok2->link()) { // Pre-check for performance
+                    // check for end of scope
+                    if (tok2->str() == "}") {
+                        // check for end of member function
+                        if (inMemberFunc) {
+                            --memberScope;
+                            if (memberScope == 0)
+                                inMemberFunc = false;
                         }
+                        inEnum = false;
 
-                        if (!type->next())
-                            syntaxError(type); // invalid input
-                        else if (type->next()->str() == ";")
-                            atEnd = true;
-                        else if (type->str() == "]")
-                            atEnd = true;
-                        else
-                            type = type->next();
-                    }
+                        if (classLevel > 1 && tok2 == spaceInfo[classLevel - 1].bodyEnd2) {
+                            --classLevel;
+                            pattern.clear();
 
-                    type = type->next();
-                } while (type && type->str() == "[");
-            }
+                            for (std::size_t i = classLevel; i < spaceInfo.size(); ++i)
+                                pattern += (spaceInfo[i].className + " :: ");
 
-            Token* after = tok1->next();
-            // check if type was parsed
-            if (type && type == usingEnd) {
-                // check for array syntax and add type around variable
-                if (arrayStart) {
-                    if (Token::Match(tok1->next(), "%name%")) {
-                        TokenList::copyTokens(tok1->next(), arrayStart, usingEnd->previous());
-                        TokenList::copyTokens(tok1, start, arrayStart->previous());
-                        tok1->deleteThis();
-                        substitute = true;
-                    }
-                } else {
-                    // just replace simple type aliases
-                    TokenList::copyTokens(tok1, start, usingEnd->previous());
-                    tok1->deleteThis();
-                    substitute = true;
-                }
-            } else {
-                skip = true;
-                if (mSettings->debugwarnings && mErrorLogger) {
-                    std::string str;
-                    for (Token *tok3 = usingStart; tok3 && tok3 != usingEnd; tok3 = tok3->next()) {
-                        if (!str.empty())
-                            str += ' ';
-                        str += tok3->str();
+                            pattern += typeName->str();
+                        } else {
+                            if (scope == 0 && !(classLevel > 1 && tok2 == spaceInfo[classLevel - 1].bodyEnd))
+                                break;
+                            scope = std::max(scope - 1, 0);
+                        }
                     }
-                    str += " ;";
-                    std::list<const Token *> callstack(1, usingStart);
-                    mErrorLogger->reportErr(ErrorLogger::ErrorMessage(callstack, &list, Severity::debug, "debug",
-                                            "Failed to parse \'" + str + "\'. The checking continues anyway.", false));
-                }
-            }
-            tok1 = after;
-        }
-
-        if (!skip)
-            usingList.emplace_back(usingStart, usingEnd);
-    }
 
-    // delete all used type alias definitions
-    for (std::list<Using>::reverse_iterator it = usingList.rbegin(); it != usingList.rend(); ++it) {
-        Token *usingStart = it->startTok;
-        Token *usingEnd = it->endTok;
-        if (usingStart->previous()) {
-            if (usingEnd->next())
-                Token::eraseTokens(usingStart->previous(), usingEnd->next());
-            else {
-                Token::eraseTokens(usingStart->previous(), usingEnd);
-                usingEnd->deleteThis();
-            }
-        } else {
-            if (usingEnd->next()) {
-                Token::eraseTokens(usingStart, usingEnd->next());
-                usingStart->deleteThis();
-            } else {
-                // this is the only code being checked so leave ';'
-                Token::eraseTokens(usingStart, usingEnd);
-                usingStart->deleteThis();
-            }
-        }
-    }
+                    // check for member functions
+                    else if (cpp && tok2->str() == "(" && TokenList::isFunctionHead(tok2, "{:")) {
+                        const Token *func = tok2->previous();
 
-    return substitute;
-}
-void Tokenizer::simplifyMulAndParens()
-{
-    if (!list.front())
-        return;
-    for (Token *tok = list.front()->tokAt(3); tok; tok = tok->next()) {
-        if (!tok->isName())
-            continue;
-        //fix ticket #2784 - improved by ticket #3184
-        int closedPars = 0;
-        Token *tokend = tok->next();
-        Token *tokbegin = tok->previous();
-        while (tokend && tokend->str() == ")") {
-            ++closedPars;
-            tokend = tokend->next();
-        }
-        if (!tokend || !(tokend->isAssignmentOp()))
-            continue;
-        while (Token::Match(tokbegin, "&|(")) {
-            if (tokbegin->str() == "&") {
-                if (Token::Match(tokbegin->tokAt(-2), "[;{}&(] *")) {
-                    //remove '* &'
-                    tokbegin = tokbegin->tokAt(-2);
-                    tokbegin->deleteNext(2);
-                } else if (Token::Match(tokbegin->tokAt(-3), "[;{}&(] * (")) {
-                    if (closedPars == 0)
-                        break;
-                    --closedPars;
-                    //remove ')'
-                    tok->deleteNext();
-                    //remove '* ( &'
-                    tokbegin = tokbegin->tokAt(-3);
-                    tokbegin->deleteNext(3);
-                } else
-                    break;
-            } else if (tokbegin->str() == "(") {
-                if (closedPars == 0)
-                    break;
+                        /** @todo add support for multi-token operators */
+                        if (func->strAt(-1) == "operator")
+                            func = func->previous();
 
-                //find consecutive opening parentheses
-                int openPars = 0;
-                while (tokbegin && tokbegin->str() == "(" && openPars <= closedPars) {
-                    ++openPars;
-                    tokbegin = tokbegin->previous();
-                }
-                if (!tokbegin || openPars > closedPars)
-                    break;
+                        if (!func->previous())
+                            syntaxError(func);
 
-                if ((openPars == closedPars && Token::Match(tokbegin, "[;{}]")) ||
-                    Token::Match(tokbegin->tokAt(-2), "[;{}&(] * &") ||
-                    Token::Match(tokbegin->tokAt(-3), "[;{}&(] * ( &")) {
-                    //remove the excessive parentheses around the variable
-                    while (openPars > 0) {
-                        tok->deleteNext();
-                        tokbegin->deleteNext();
-                        --closedPars;
-                        --openPars;
+                        // check for qualifier
+                        if (Token::Match(func->tokAt(-2), "%name% ::")) {
+                            int offset = -2;
+                            while (Token::Match(func->tokAt(offset - 2), "%name% ::"))
+                                offset -= 2;
+                            // check for available and matching class name
+                            if (spaceInfo.size() > 1 && classLevel < spaceInfo.size() &&
+                                func->strAt(offset) == spaceInfo[classLevel].className) {
+                                memberScope = 0;
+                                inMemberFunc = true;
+                            }
+                        }
                     }
-                } else
-                    break;
-            }
-        }
-    }
-}
 
-bool Tokenizer::createTokens(std::istream &code,
-                             const std::string& FileName)
-{
-    // make sure settings specified
-    assert(mSettings);
-
-    return list.createTokens(code, FileName);
-}
+                    // check for entering a new scope
+                    else if (tok2->str() == "{") {
+                        // check for entering a new namespace
+                        if (cpp) {
+                            if (tok2->strAt(-2) == "namespace") {
+                                if (classLevel < spaceInfo.size() &&
+                                    spaceInfo[classLevel].isNamespace &&
+                                    spaceInfo[classLevel].className == tok2->strAt(-1)) {
+                                    spaceInfo[classLevel].bodyEnd2 = tok2->link();
+                                    ++classLevel;
+                                    pattern.clear();
+                                    for (std::size_t i = classLevel; i < spaceInfo.size(); ++i)
+                                        pattern += spaceInfo[i].className + " :: ";
+
+                                    pattern += typeName->str();
+                                }
+                                ++scope;
+                            }
+                            if (isEnumStart(tok2))
+                                inEnum = true;
+                        }
 
-void Tokenizer::createTokens(const simplecpp::TokenList *tokenList)
-{
-    // make sure settings specified
-    assert(mSettings);
-    list.createTokens(tokenList);
-}
+                        // keep track of scopes within member function
+                        if (inMemberFunc)
+                            ++memberScope;
 
-bool Tokenizer::simplifyTokens1(const std::string &configuration)
-{
-    // Fill the map mTypeSize..
-    fillTypeSizes();
+                        ++scope;
+                    }
+                }
 
-    mConfiguration = configuration;
+                // check for operator typedef
+                /** @todo add support for multi-token operators */
+                else if (cpp &&
+                         tok2->str() == "operator" &&
+                         tok2->next() &&
+                         tok2->strAt(1) == typeName->str() &&
+                         tok2->linkAt(2) &&
+                         tok2->strAt(2) == "(" &&
+                         Token::Match(tok2->linkAt(2), ") const| {")) {
+                    // check for qualifier
+                    if (tok2->strAt(-1) == "::") {
+                        // check for available and matching class name
+                        if (spaceInfo.size() > 1 && classLevel < spaceInfo.size() &&
+                            tok2->strAt(-2) == spaceInfo[classLevel].className) {
+                            tok2 = tok2->next();
+                            simplifyType = true;
+                        }
+                    }
+                }
 
-    if (!simplifyTokenList1(list.getFiles().front().c_str()))
-        return false;
+                else if (Token::Match(tok2->previous(), "class|struct %name% [:{]")) {
+                    // don't replace names in struct/class definition
+                }
 
-    if (mTimerResults) {
-        Timer t("Tokenizer::simplifyTokens1::createAst", mSettings->showtime, mTimerResults);
-        list.createAst();
-        list.validateAst();
-    } else {
-        list.createAst();
-        list.validateAst();
-    }
+                // check for typedef that can be substituted
+                else if ((tok2->isNameOnly() || (tok2->isName() && (tok2->isExpandedMacro() || tok2->isInline() || tok2->isExternC()))) &&
+                         (Token::simpleMatch(tok2, pattern.c_str(), pattern.size()) ||
+                          (inMemberFunc && tok2->str() == typeName->str()))) {
+                    // member function class variables don't need qualification
+                    if (!(inMemberFunc && tok2->str() == typeName->str()) && pattern.find("::") != std::string::npos) { // has a "something ::"
+                        Token *start = tok2;
+                        int count = 0;
+                        int back = classLevel - 1;
+                        bool good = true;
+                        // check for extra qualification
+                        while (back >= 1) {
+                            Token *qualificationTok = start->tokAt(-2);
+                            if (!Token::Match(qualificationTok, "%type% ::"))
+                                break;
+                            if (qualificationTok->str() == spaceInfo[back].className) {
+                                start = qualificationTok;
+                                back--;
+                                count++;
+                            } else {
+                                good = false;
+                                break;
+                            }
+                        }
+                        // check global namespace
+                        if (good && back == 1 && start->strAt(-1) == "::")
+                            good = false;
 
-    if (mTimerResults) {
-        Timer t("Tokenizer::simplifyTokens1::createSymbolDatabase", mSettings->showtime, mTimerResults);
-        createSymbolDatabase();
-    } else {
-        createSymbolDatabase();
-    }
+                        if (good) {
+                            // remove any extra qualification if present
+                            while (count) {
+                                if (!removed.empty())
+                                    removed.insert(0, " ");
+                                removed.insert(0, tok2->strAt(-2) + " " + tok2->strAt(-1));
+                                tok2->tokAt(-3)->deleteNext(2);
+                                --count;
+                            }
 
-    // Use symbol database to identify rvalue references. Split && to & &. This is safe, since it doesn't delete any tokens (which might be referenced by symbol database)
-    for (const Variable* var : mSymbolDatabase->variableList()) {
-        if (var && var->isRValueReference()) {
-            Token* endTok = const_cast<Token*>(var->typeEndToken());
-            endTok->str("&");
-            endTok->astOperand1(nullptr);
-            endTok->astOperand2(nullptr);
-            endTok->insertToken("&");
-            endTok->next()->scope(endTok->scope());
-        }
-    }
+                            // remove global namespace if present
+                            if (tok2->strAt(-1) == "::") {
+                                removed.insert(0, ":: ");
+                                tok2->tokAt(-2)->deleteNext();
+                                globalScope = true;
+                            }
 
-    if (mTimerResults) {
-        Timer t("Tokenizer::simplifyTokens1::setValueType", mSettings->showtime, mTimerResults);
-        mSymbolDatabase->setValueTypeInTokenList(true);
-    } else {
-        mSymbolDatabase->setValueTypeInTokenList(true);
-    }
+                            // remove qualification if present
+                            for (std::size_t i = classLevel; i < spaceInfo.size(); ++i) {
+                                if (!removed.empty())
+                                    removed += " ";
+                                removed += (tok2->str() + " " + tok2->strAt(1));
+                                tok2->deleteThis();
+                                tok2->deleteThis();
+                            }
+                            simplifyType = true;
+                        }
+                    } else {
+                        if (tok2->strAt(-1) == "::") {
+                            int relativeSpaceInfoSize = spaceInfo.size();
+                            Token * tokBeforeType = tok2->previous();
+                            while (relativeSpaceInfoSize > 1 &&
+                                   tokBeforeType && tokBeforeType->str() == "::" &&
+                                   tokBeforeType->strAt(-1) == spaceInfo[relativeSpaceInfoSize-1].className) {
+                                tokBeforeType = tokBeforeType->tokAt(-2);
+                                --relativeSpaceInfoSize;
+                            }
+                            if (tokBeforeType && tokBeforeType->str() != "::") {
+                                Token::eraseTokens(tokBeforeType, tok2);
+                                simplifyType = true;
+                            }
+                        } else if (Token::Match(tok2->previous(), "case|;|{|} %type% :")) {
+                            tok2 = tok2->next();
+                        } else if (duplicateTypedef(tok2, typeName, typeDef)) {
+                            // skip to end of scope if not already there
+                            if (tok2->str() != "}") {
+                                while (tok2->next()) {
+                                    if (tok2->strAt(1) == "{")
+                                        tok2 = tok2->linkAt(1)->previous();
+                                    else if (tok2->strAt(1) == "}")
+                                        break;
 
-    if (mTimerResults) {
-        Timer t("Tokenizer::simplifyTokens1::ValueFlow", mSettings->showtime, mTimerResults);
-        ValueFlow::setValues(&list, mSymbolDatabase, mErrorLogger, mSettings);
-    } else {
-        ValueFlow::setValues(&list, mSymbolDatabase, mErrorLogger, mSettings);
-    }
+                                    tok2 = tok2->next();
+                                }
+                            }
+                        } else if (Token::Match(tok2->tokAt(-2), "%type% *|&")) {
+                            // Ticket #5868: Don't substitute variable names
+                        } else if (tok2->strAt(-1) != ".") {
+                            simplifyType = (TypedefSimplifier::canReplaceStatic(tok2) != 0);
+                        }
+                    }
+                }
 
-    mSymbolDatabase->setArrayDimensionsUsingValueFlow();
+                simplifyType = simplifyType && (!inEnum || !Token::simpleMatch(tok2->next(), "="));
+                simplifyType = simplifyType && !(Token::simpleMatch(tok2->next(), "<") && Token::simpleMatch(typeEnd, ">"));
 
-    printDebugOutput(1);
+                if (simplifyType) {
+                    mTypedefInfo.back().used = true;
 
-    return true;
-}
+                    // can't simplify 'operator functionPtr ()' and 'functionPtr operator ... ()'
+                    if (functionPtr && (tok2->strAt(-1) == "operator" ||
+                                        (tok2->next() && tok2->strAt(1) == "operator"))) {
+                        simplifyType = false;
+                        tok2 = tok2->next();
+                        continue;
+                    }
 
-bool Tokenizer::tokenize(std::istream &code,
-                         const char FileName[],
-                         const std::string &configuration)
-{
-    if (!createTokens(code, FileName))
-        return false;
+                    // There are 2 categories of typedef substitutions:
+                    // 1. variable declarations that preserve the variable name like
+                    //    global, local, and function parameters
+                    // 2. not variable declarations that have no name like derived
+                    //    classes, casts, operators, and template parameters
 
-    return simplifyTokens1(configuration);
-}
-//---------------------------------------------------------------------------
+                    // try to determine which category this substitution is
+                    bool inCast = false;
+                    bool inTemplate = false;
+                    bool inOperator = false;
+                    bool inSizeof = false;
 
-void Tokenizer::findComplicatedSyntaxErrorsInTemplates()
-{
-    validate();
-    mTemplateSimplifier->checkComplicatedSyntaxErrorsInTemplates();
-}
+                    const bool sameStartEnd = (typeStart == typeEnd);
 
-void Tokenizer::checkForEnumsWithTypedef()
-{
-    for (const Token *tok = list.front(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "enum %name% {")) {
-            tok = tok->tokAt(2);
-            const Token *tok2 = Token::findsimplematch(tok, "typedef", tok->link());
-            if (tok2)
-                syntaxError(tok2);
-            tok = tok->link();
-        }
-    }
-}
+                    // check for derived class: class A : some_typedef {
+                    const bool isDerived = Token::Match(tok2->previous(), "public|protected|private|: %type% {|,");
 
-void Tokenizer::fillTypeSizes()
-{
-    mTypeSize.clear();
-    mTypeSize["char"] = 1;
-    mTypeSize["_Bool"] = mSettings->sizeof_bool;
-    mTypeSize["bool"] = mSettings->sizeof_bool;
-    mTypeSize["short"] = mSettings->sizeof_short;
-    mTypeSize["int"] = mSettings->sizeof_int;
-    mTypeSize["long"] = mSettings->sizeof_long;
-    mTypeSize["float"] = mSettings->sizeof_float;
-    mTypeSize["double"] = mSettings->sizeof_double;
-    mTypeSize["wchar_t"] = mSettings->sizeof_wchar_t;
-    mTypeSize["size_t"] = mSettings->sizeof_size_t;
-    mTypeSize["*"] = mSettings->sizeof_pointer;
-}
+                    // check for cast: (some_typedef) A or static_cast<some_typedef>(A)
+                    // todo: check for more complicated casts like: (const some_typedef *)A
+                    if ((tok2->strAt(-1) == "(" && tok2->strAt(1) == ")" && tok2->strAt(-2) != "sizeof") ||
+                        (tok2->strAt(-1) == "<" && Token::simpleMatch(tok2->next(), "> (")) ||
+                        Token::Match(tok2->tokAt(-2), "( const %name% )"))
+                        inCast = true;
 
-void Tokenizer::combineOperators()
-{
-    const bool cpp = isCPP();
+                    // check for template parameters: t<some_typedef> t1
+                    else if (Token::Match(tok2->previous(), "<|,") &&
+                             Token::Match(tok2->next(), "&|*| &|*| >|,"))
+                        inTemplate = true;
 
-    // Combine tokens..
-    for (Token *tok = list.front(); tok && tok->next(); tok = tok->next()) {
-        const char c1 = tok->str()[0];
+                    else if (Token::Match(tok2->tokAt(-2), "sizeof ( %type% )"))
+                        inSizeof = true;
 
-        if (tok->str().length() == 1 && tok->next()->str().length() == 1) {
-            const char c2 = tok->next()->str()[0];
+                    // check for operator
+                    if (tok2->strAt(-1) == "operator" ||
+                        Token::simpleMatch(tok2->tokAt(-2), "operator const"))
+                        inOperator = true;
 
-            // combine +-*/ and =
-            if (c2 == '=' && (std::strchr("+-*/%|^=!<>", c1))) {
-                // skip templates
-                if (cpp && tok->str() == ">") {
-                    const Token *opening = tok->findOpeningBracket();
-                    if (opening) {
-                        if (Token::Match(opening->previous(), "%name%"))
-                            continue;
+                    if (typeStart->str() == "typename" && tok2->strAt(-1)=="typename") {
+                        // Remove one typename if it is already contained in the goal
+                        typeStart = typeStart->next();
                     }
-                }
-                tok->str(tok->str() + c2);
-                tok->deleteNext();
-                continue;
-            }
-        } else if (tok->next()->str() == "=") {
-            if (tok->str() == ">>") {
-                tok->str(">>=");
-                tok->deleteNext();
-            } else if (tok->str() == "<<") {
-                tok->str("<<=");
-                tok->deleteNext();
-            }
-        } else if (cpp && (c1 == 'p' || c1 == '_') &&
-                   Token::Match(tok, "private|protected|public|__published : !!:")) {
-            bool simplify = false;
-            int par = 0;
-            for (const Token *prev = tok->previous(); prev; prev = prev->previous()) {
-                if (prev->str() == ")") {
-                    ++par;
-                } else if (prev->str() == "(") {
-                    if (par == 0U)
-                        break;
-                    --par;
-                }
-                if (par != 0U || prev->str() == "(")
-                    continue;
-                if (Token::Match(prev, "[;{}]")) {
-                    simplify = true;
-                    break;
-                }
-                if (prev->isName() && prev->isUpperCaseName())
-                    continue;
-                if (prev->isName() && endsWith(prev->str(), ':'))
-                    simplify = true;
-                break;
-            }
-            if (simplify) {
-                tok->str(tok->str() + ":");
-                tok->deleteNext();
-            }
-        } else if (tok->str() == "->") {
-            // If the preceding sequence is "( & %name% )", replace it by "%name%"
-            Token *t = tok->tokAt(-4);
-            if (Token::Match(t, "( & %name% )")) {
-                t->deleteThis();
-                t->deleteThis();
-                t->deleteNext();
-            }
-
-            tok->str(".");
-            tok->originalName("->");
-        }
-    }
-}
-
-void Tokenizer::combineStringAndCharLiterals()
-{
-    // Combine strings
-    for (Token *tok = list.front();
-         tok;
-         tok = tok->next()) {
-        if (tok->str()[0] != '"')
-            continue;
-
-        tok->str(simplifyString(tok->str()));
-        while (tok->next() && tok->next()->tokType() == Token::eString) {
-            // Two strings after each other, combine them
-            tok->concatStr(simplifyString(tok->next()->str()));
-            tok->deleteNext();
-        }
-    }
-}
-
-void Tokenizer::concatenateNegativeNumberAndAnyPositive()
-{
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (!Token::Match(tok, "?|:|,|(|[|{|return|case|sizeof|%op% +|-") || tok->tokType() == Token::eIncDecOp)
-            continue;
-
-        while (tok->str() != ">" && tok->next() && tok->next()->str() == "+")
-            tok->deleteNext();
-
-        if (Token::Match(tok->next(), "- %num%")) {
-            tok->deleteNext();
-            tok->next()->str("-" + tok->next()->str());
-        }
-    }
-}
 
-void Tokenizer::simplifyExternC()
-{
-    if (isC())
-        return;
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (Token::simpleMatch(tok, "extern \"C\"")) {
-            if (tok->strAt(2) == "{") {
-                tok->linkAt(2)->deleteThis();
-                tok->deleteNext(2);
-            } else
-                tok->deleteNext();
-            tok->deleteThis();
-        }
-    }
-}
+                    // skip over class or struct in derived class declaration
+                    bool structRemoved = false;
+                    if ((isDerived || inTemplate) && Token::Match(typeStart, "class|struct")) {
+                        if (typeStart->str() == "struct")
+                            structRemoved = true;
+                        typeStart = typeStart->next();
+                    }
+                    if (Token::Match(typeStart, "struct|class|union") && Token::Match(tok2, "%name% ::"))
+                        typeStart = typeStart->next();
 
-void Tokenizer::simplifyRoundCurlyParentheses()
-{
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        while (Token::Match(tok, "[;{}:] ( {") &&
-               Token::simpleMatch(tok->linkAt(2), "} ) ;")) {
-            if (tok->str() == ":" && !Token::Match(tok->tokAt(-2),"[;{}] %type% :"))
-                break;
-            Token *end = tok->linkAt(2)->tokAt(-3);
-            if (Token::Match(end, "[;{}] %num%|%str% ;"))
-                end->deleteNext(2);
-            tok->linkAt(2)->previous()->deleteNext(3);
-            tok->deleteNext(2);
-        }
-        if (Token::Match(tok, "( { %bool%|%char%|%num%|%str%|%name% ; } )")) {
-            tok->deleteNext();
-            tok->deleteThis();
-            tok->deleteNext(3);
-        }
-    }
-}
+                    if (sameStartEnd)
+                        typeEnd = typeStart;
 
-void Tokenizer::simplifySQL()
-{
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (!Token::simpleMatch(tok, "__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL"))
-            continue;
+                    // Is this a "T()" expression where T is a pointer type?
+                    const bool isPointerTypeCall = !inOperator && Token::Match(tok2, "%name% ( )") && !pointers.empty();
 
-        const Token *end = findSQLBlockEnd(tok);
-        if (end == nullptr)
-            syntaxError(nullptr);
+                    // start substituting at the typedef name by replacing it with the type
+                    const Token* location = tok2;
+                    for (Token* tok3 = typeStart; tok3 && (tok3->str() != ";"); tok3 = tok3->next())
+                        tok3->isSimplifiedTypedef(true);
+                    if (isPointerTypeCall) {
+                        tok2->deleteThis();
+                        tok2 = simplifyTypedefInsertToken(tok2, "0", location);
+                        simplifyTypedefInsertToken(tok2->next(), "0", location);
+                    }
+                    if (Token::Match(tok2->tokAt(-1), "class|struct|union") && tok2->strAt(-1) == typeStart->str())
+                        tok2->deletePrevious();
 
-        const std::string instruction = tok->stringifyList(end);
-        // delete all tokens until the embedded SQL block end
-        Token::eraseTokens(tok, end);
+                    if (cpp && Token::Match(tok2->previous(), "using %name% ::|;")) {
+                        tok2->previous()->str("typedef");
+                        tok2->insertToken(tok2->str());
+                    }
+                    tok2->str(typeStart->str());
 
-        // insert "asm ( "instruction" ) ;"
-        tok->str("asm");
-        // it can happen that 'end' is NULL when wrong code is inserted
-        if (!tok->next())
-            tok->insertToken(";");
-        tok->insertToken(")");
-        tok->insertToken("\"" + instruction + "\"");
-        tok->insertToken("(");
-        // jump to ';' and continue
-        tok = tok->tokAt(3);
-    }
-}
+                    // restore qualification if it was removed
+                    if (Token::Match(typeStart, "class|struct|union") || structRemoved) {
+                        if (structRemoved)
+                            tok2 = tok2->previous();
 
-void Tokenizer::simplifyArrayAccessSyntax()
-{
-    // 0[a] -> a[0]
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (tok->isNumber() && Token::Match(tok, "%num% [ %name% ]")) {
-            const std::string number(tok->str());
-            Token* indexTok = tok->tokAt(2);
-            tok->str(indexTok->str());
-            tok->varId(indexTok->varId());
-            indexTok->str(number);
-        }
-    }
-}
+                        if (globalScope) {
+                            tok2 = simplifyTypedefInsertToken(tok2, "::", location);
+                        }
 
-void Tokenizer::simplifyParameterVoid()
-{
-    for (Token* tok = list.front(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "%name% ( void )"))
-            tok->next()->deleteNext();
-    }
-}
+                        for (std::size_t i = classLevel; i < spaceInfo.size(); ++i) {
+                            tok2 = simplifyTypedefInsertToken(tok2, spaceInfo[i].className, location);
+                            tok2 = simplifyTypedefInsertToken(tok2, "::", location);
+                        }
+                    }
 
-void Tokenizer::simplifyRedundantConsecutiveBraces()
-{
-    // Remove redundant consecutive braces, i.e. '.. { { .. } } ..' -> '.. { .. } ..'.
-    for (Token *tok = list.front(); tok;) {
-        if (Token::simpleMatch(tok, "= {")) {
-            tok = tok->linkAt(1);
-        } else if (Token::simpleMatch(tok, "{ {") && Token::simpleMatch(tok->next()->link(), "} }")) {
-            //remove internal parentheses
-            tok->next()->link()->deleteThis();
-            tok->deleteNext();
-        } else
-            tok = tok->next();
-    }
-}
+                    // add some qualification back if needed
+                    Token *start = tok2;
+                    std::string removed1 = removed;
+                    std::string::size_type idx = removed1.rfind(" ::");
+
+                    if (idx != std::string::npos)
+                        removed1.resize(idx);
+                    if (removed1 == classPath && !removed1.empty()) {
+                        for (auto it = spaceInfo.crbegin(); it != spaceInfo.crend(); ++it) {
+                            if (it->recordTypes.find(start->str()) != it->recordTypes.end()) {
+                                std::string::size_type spaceIdx = 0;
+                                std::string::size_type startIdx = 0;
+                                while ((spaceIdx = removed1.find(' ', startIdx)) != std::string::npos) {
+                                    simplifyTypedefInsertToken(tok2->previous(), removed1.substr(startIdx, spaceIdx - startIdx), location);
+                                    startIdx = spaceIdx + 1;
+                                }
+                                simplifyTypedefInsertToken(tok2->previous(), removed1.substr(startIdx), location);
+                                simplifyTypedefInsertToken(tok2->previous(), "::", location);
+                                break;
+                            }
+                            idx = removed1.rfind(" ::");
+                            if (idx == std::string::npos)
+                                break;
 
-void Tokenizer::simplifyDoublePlusAndDoubleMinus()
-{
-    // Convert - - into + and + - into -
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        while (tok->next()) {
-            if (tok->str() == "+") {
-                if (tok->next()->str()[0] == '-') {
-                    tok = tok->next();
-                    if (tok->str().size() == 1) {
-                        tok = tok->previous();
-                        tok->str("-");
-                        tok->deleteNext();
-                    } else if (tok->isNumber()) {
-                        tok->str(tok->str().substr(1));
-                        tok = tok->previous();
-                        tok->str("-");
+                            removed1.resize(idx);
+                        }
                     }
-                    continue;
-                }
-            } else if (tok->str() == "-") {
-                if (tok->next()->str()[0] == '-') {
-                    tok = tok->next();
-                    if (tok->str().size() == 1) {
-                        tok = tok->previous();
-                        tok->str("+");
-                        tok->deleteNext();
-                    } else if (tok->isNumber()) {
-                        tok->str(tok->str().substr(1));
-                        tok = tok->previous();
-                        tok->str("+");
+                    Token* constTok = Token::simpleMatch(tok2->previous(), "const") ? tok2->previous() : nullptr;
+                    // add remainder of type
+                    tok2 = simplifyTypedefCopyTokens(tok2, typeStart->next(), typeEnd, location);
+
+                    if (!pointers.empty()) {
+                        for (const std::string &p : pointers)
+                            // cppcheck-suppress useStlAlgorithm
+                            tok2 = simplifyTypedefInsertToken(tok2, p, location);
+                        if (constTok && !functionPtr) {
+                            tok2 = simplifyTypedefInsertToken(tok2, "const", location);
+                            constTok->deleteThis();
+                            location = constTok;
+                        }
                     }
-                    continue;
-                }
-            }
 
-            break;
-        }
-    }
-}
+                    if (funcStart && funcEnd) {
+                        tok2 = simplifyTypedefInsertToken(tok2, "(", location);
+                        Token *paren = tok2;
+                        tok2 = simplifyTypedefCopyTokens(tok2, funcStart, funcEnd, location);
 
-/** Specify array size if it hasn't been given */
+                        if (!inCast)
+                            tok2 = processFunc(tok2, inOperator);
 
-void Tokenizer::arraySize()
-{
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (!tok->isName() || !Token::Match(tok, "%var% [ ] ="))
-            continue;
-        bool addlength = false;
-        if (Token::Match(tok, "%var% [ ] = { %str% } ;")) {
-            Token *t = tok->tokAt(3);
-            t->deleteNext();
-            t->next()->deleteNext();
-            addlength = true;
-        }
+                        if (!tok2)
+                            break;
 
-        if (addlength || Token::Match(tok, "%var% [ ] = %str% ;")) {
-            tok = tok->next();
-            const int sz = Token::getStrSize(tok->tokAt(3));
-            tok->insertToken(MathLib::toString(sz));
-            tok = tok->tokAt(5);
-        }
+                        while (Token::Match(tok2, "%name%|] ["))
+                            tok2 = tok2->linkAt(1);
 
-        else if (Token::Match(tok, "%var% [ ] = {")) {
-            MathLib::biguint sz = 1;
-            tok = tok->next();
-            Token *end = tok->linkAt(3);
-            for (Token *tok2 = tok->tokAt(4); tok2 && tok2 != end; tok2 = tok2->next()) {
-                if (tok2->link() && Token::Match(tok2, "{|(|[|<")) {
-                    if (tok2->str() == "[" && tok2->link()->strAt(1) == "=") { // designated initializer
-                        if (Token::Match(tok2, "[ %num% ]"))
-                            sz = std::max(sz, MathLib::toULongNumber(tok2->strAt(1)) + 1U);
-                        else {
-                            sz = 0;
-                            break;
+                        tok2 = simplifyTypedefInsertToken(tok2, ")", location);
+                        Token::createMutualLinks(tok2, paren);
+
+                        tok2 = simplifyTypedefCopyTokens(tok2, argStart, argEnd, location);
+
+                        if (specStart) {
+                            Token *spec = specStart;
+                            tok2 = simplifyTypedefInsertToken(tok2, spec->str(), location);
+                            while (spec != specEnd) {
+                                spec = spec->next();
+                                tok2 = simplifyTypedefInsertToken(tok2, spec->str(), location);
+                            }
                         }
                     }
-                    tok2 = tok2->link();
-                } else if (tok2->str() == ",") {
-                    if (!Token::Match(tok2->next(), "[},]"))
-                        ++sz;
-                    else {
-                        tok2 = tok2->previous();
-                        tok2->deleteNext();
-                    }
-                }
-            }
 
-            if (sz != 0)
-                tok->insertToken(MathLib::toString(sz));
+                    else if (functionPtr || function) {
+                        // don't add parentheses around function names because it
+                        // confuses other simplifications
+                        bool needParen = true;
+                        if (!inTemplate && function && tok2->next() && tok2->strAt(1) != "*")
+                            needParen = false;
+                        if (needParen) {
+                            tok2 = simplifyTypedefInsertToken(tok2, "(", location);
+                        }
+                        Token *tok3 = tok2;
+                        if (namespaceStart) {
+                            const Token *tok4 = namespaceStart;
 
-            tok = end->next() ? end->next() : end;
-        }
-    }
-}
+                            while (tok4 != namespaceEnd) {
+                                tok2 = simplifyTypedefInsertToken(tok2, tok4->str(), location);
+                                tok4 = tok4->next();
+                            }
+                            tok2 = simplifyTypedefInsertToken(tok2, namespaceEnd->str(), location);
+                        }
+                        if (functionPtr) {
+                            tok2 = simplifyTypedefInsertToken(tok2, "*", location);
+                        }
 
-static Token *skipTernaryOp(Token *tok)
-{
-    int colonLevel = 1;
-    while (nullptr != (tok = tok->next())) {
-        if (tok->str() == "?") {
-            ++colonLevel;
-        } else if (tok->str() == ":") {
-            --colonLevel;
-            if (colonLevel == 0) {
-                tok = tok->next();
-                break;
-            }
-        }
-        if (tok->link() && Token::Match(tok, "[(<]"))
-            tok = tok->link();
-        else if (Token::Match(tok->next(), "[{};)]"))
-            break;
-    }
-    if (colonLevel > 0) // Ticket #5214: Make sure the ':' matches the proper '?'
-        return nullptr;
-    return tok;
-}
+                        if (!inCast)
+                            tok2 = processFunc(tok2, inOperator);
 
-const Token * Tokenizer::startOfExecutableScope(const Token * tok)
-{
-    if (tok->str() != ")")
-        return nullptr;
+                        if (needParen) {
+                            if (!tok2)
+                                syntaxError(nullptr);
 
-    tok = isFunctionHead(tok, ":{", true);
+                            tok2 = simplifyTypedefInsertToken(tok2, ")", location);
+                            Token::createMutualLinks(tok2, tok3);
+                        }
+                        if (!tok2)
+                            syntaxError(nullptr);
 
-    if (Token::Match(tok, ": %name% [({]")) {
-        while (Token::Match(tok, "[:,] %name% [({]"))
-            tok = tok->linkAt(2)->next();
-    }
+                        tok2 = simplifyTypedefCopyTokens(tok2, argStart, argEnd, location);
+                        if (inTemplate) {
+                            tok2 = tok2->next();
+                        }
 
-    return (tok && tok->str() == "{") ? tok : nullptr;
-}
+                        if (specStart) {
+                            Token *spec = specStart;
+                            tok2 = simplifyTypedefInsertToken(tok2, spec->str(), location);
+                            while (spec != specEnd) {
+                                spec = spec->next();
+                                tok2 = simplifyTypedefInsertToken(tok2, spec->str(), location);
+                            }
+                        }
+                    } else if (functionRetFuncPtr || functionPtrRetFuncPtr) {
+                        tok2 = simplifyTypedefInsertToken(tok2, "(", location);
+                        Token *tok3 = tok2;
+                        tok2 = simplifyTypedefInsertToken(tok2, "*", location);
 
+                        Token * tok4 = nullptr;
+                        if (functionPtrRetFuncPtr) {
+                            tok2 = simplifyTypedefInsertToken(tok2, "(", location);
+                            tok4 = tok2;
+                            tok2 = simplifyTypedefInsertToken(tok2, "*", location);
+                        }
 
-/** simplify labels and case|default in the code: add a ";" if not already in.*/
+                        // skip over variable name if there
+                        if (!inCast) {
+                            if (!tok2 || !tok2->next())
+                                syntaxError(nullptr);
 
-void Tokenizer::simplifyLabelsCaseDefault()
-{
-    const bool cpp = isCPP();
-    bool executablescope = false;
-    int indentLevel = 0;
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        // Simplify labels in the executable scope..
-        Token *start = const_cast<Token *>(startOfExecutableScope(tok));
-        if (start) {
-            tok = start;
-            executablescope = true;
-        }
+                            if (tok2->strAt(1) != ")")
+                                tok2 = tok2->next();
+                        }
 
-        if (!executablescope)
-            continue;
+                        if (tok4 && functionPtrRetFuncPtr) {
+                            tok2 = simplifyTypedefInsertToken(tok2,")", location);
+                            Token::createMutualLinks(tok2, tok4);
+                        }
 
-        if (tok->str() == "{") {
-            if (tok->previous()->str() == "=")
-                tok = tok->link();
-            else
-                ++indentLevel;
-        } else if (tok->str() == "}") {
-            --indentLevel;
-            if (indentLevel == 0) {
-                executablescope = false;
-                continue;
-            }
-        } else if (Token::Match(tok, "(|["))
-            tok = tok->link();
+                        tok2 = simplifyTypedefCopyTokens(tok2, argStart, argEnd, location);
 
-        if (Token::Match(tok, "[;{}:] case")) {
-            while (nullptr != (tok = tok->next())) {
-                if (Token::Match(tok, "(|[")) {
-                    tok = tok->link();
-                } else if (tok->str() == "?") {
-                    Token *tok1 = skipTernaryOp(tok);
-                    if (!tok1) {
-                        syntaxError(tok);
-                    }
-                    tok = tok1;
-                }
-                if (Token::Match(tok->next(),"[:{};]"))
-                    break;
-            }
-            if (!tok)
-                break;
-            if (tok->str() != "case" && tok->next() && tok->next()->str() == ":") {
-                tok = tok->next();
-                if (!tok->next())
-                    syntaxError(tok);
-                if (tok->next()->str() != ";" && tok->next()->str() != "case")
-                    tok->insertToken(";");
-                else
-                    tok = tok->previous();
-            } else {
-                syntaxError(tok);
-            }
-        } else if (Token::Match(tok, "[;{}] %name% : !!;")) {
-            if (!cpp || !Token::Match(tok->next(), "class|struct|enum")) {
-                tok = tok->tokAt(2);
-                tok->insertToken(";");
-            }
-        }
-    }
-}
+                        tok2 = simplifyTypedefInsertToken(tok2, ")", location);
+                        Token::createMutualLinks(tok2, tok3);
+
+                        tok2 = simplifyTypedefCopyTokens(tok2, argFuncRetStart, argFuncRetEnd, location);
+                    } else if (ptrToArray || refToArray) {
+                        tok2 = simplifyTypedefInsertToken(tok2, "(", location);
+                        Token *tok3 = tok2;
+
+                        if (ptrToArray)
+                            tok2 = simplifyTypedefInsertToken(tok2, "*", location);
+                        else
+                            tok2 = simplifyTypedefInsertToken(tok2, "&", location);
 
+                        bool hasName = false;
+                        // skip over name
+                        if (tok2->next() && tok2->strAt(1) != ")" && tok2->strAt(1) != "," &&
+                            tok2->strAt(1) != ">") {
+                            hasName = true;
+                            if (tok2->strAt(1) != "(")
+                                tok2 = tok2->next();
 
-void Tokenizer::simplifyCaseRange()
-{
-    for (Token* tok = list.front(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "case %num% ... %num% :")) {
-            const MathLib::bigint start = MathLib::toLongNumber(tok->strAt(1));
-            MathLib::bigint end = MathLib::toLongNumber(tok->strAt(3));
-            end = std::min(start + 50, end); // Simplify it 50 times at maximum
-            if (start < end) {
-                tok = tok->tokAt(2);
-                tok->str(":");
-                tok->insertToken("case");
-                for (MathLib::bigint i = end-1; i > start; i--) {
-                    tok->insertToken(":");
-                    tok->insertToken(MathLib::toString(i));
-                    tok->insertToken("case");
-                }
-            }
-        } else if (Token::Match(tok, "case %char% ... %char% :")) {
-            const char start = tok->strAt(1)[1];
-            const char end = tok->strAt(3)[1];
-            if (start < end) {
-                tok = tok->tokAt(2);
-                tok->str(":");
-                tok->insertToken("case");
-                for (char i = end - 1; i > start; i--) {
-                    tok->insertToken(":");
-                    if (i == '\\') {
-                        tok->insertToken(std::string("\'\\") + i + '\'');
-                    } else {
-                        tok->insertToken(std::string(1, '\'') + i + '\'');
-                    }
-                    tok->insertToken("case");
-                }
-            }
-        }
-    }
-}
+                            // check for function and skip over args
+                            if (tok2 && tok2->next() && tok2->strAt(1) == "(")
+                                tok2 = tok2->linkAt(1);
 
-void Tokenizer::calculateScopes()
-{
-    for (auto tok = list.front(); tok; tok = tok->next())
-        tok->scopeInfo(nullptr);
+                            // check for array
+                            if (tok2 && tok2->next() && tok2->strAt(1) == "[")
+                                tok2 = tok2->linkAt(1);
+                        }
 
-    std::string nextScopeNameAddition;
-    std::shared_ptr<ScopeInfo2> primaryScope = std::make_shared<ScopeInfo2>("", nullptr);
-    list.front()->scopeInfo(primaryScope);
+                        simplifyTypedefInsertToken(tok2, ")", location);
+                        Token::createMutualLinks(tok2->next(), tok3);
 
-    for (Token* tok = list.front(); tok; tok = tok->next()) {
-        if (tok == list.front() || !tok->scopeInfo()) {
-            if (tok != list.front())
-                tok->scopeInfo(tok->previous()->scopeInfo());
+                        if (!hasName)
+                            tok2 = tok2->next();
+                    } else if (ptrMember) {
+                        if (Token::simpleMatch(tok2, "* (")) {
+                            tok2 = simplifyTypedefInsertToken(tok2, "*", location);
+                        } else {
+                            // This is the case of casting operator.
+                            // Name is not available, and () should not be
+                            // inserted
+                            const bool castOperator = inOperator && Token::Match(tok2, "%type% (");
+                            Token *openParenthesis = nullptr;
 
-            if (Token::Match(tok, "using namespace %name% ::|<|;")) {
-                std::string usingNamespaceName;
-                for (const Token* namespaceNameToken = tok->tokAt(2);
-                     !Token::simpleMatch(namespaceNameToken, ";");
-                     namespaceNameToken = namespaceNameToken->next()) {
-                    usingNamespaceName += namespaceNameToken->str();
-                    usingNamespaceName += " ";
-                }
-                if (usingNamespaceName.length() > 0)
-                    usingNamespaceName = usingNamespaceName.substr(0, usingNamespaceName.length() - 1);
-                tok->scopeInfo()->usingNamespaces.insert(usingNamespaceName);
-            } else if (Token::Match(tok, "namespace|class|struct|union %name% {|::|:|<")) {
-                for (Token* nameTok = tok->next(); nameTok && !Token::Match(nameTok, "{|:"); nameTok = nameTok->next()) {
-                    if (Token::Match(nameTok, ";|<")) {
-                        nextScopeNameAddition = "";
-                        break;
-                    }
-                    nextScopeNameAddition.append(nameTok->str());
-                    nextScopeNameAddition.append(" ");
-                }
-                if (nextScopeNameAddition.length() > 0)
-                    nextScopeNameAddition = nextScopeNameAddition.substr(0, nextScopeNameAddition.length() - 1);
-            }
+                            if (!castOperator) {
+                                tok2 = simplifyTypedefInsertToken(tok2, "(", location);
 
-            if (Token::simpleMatch(tok, "{")) {
-                // This might be the opening of a member function
-                Token *tok1 = tok;
-                while (Token::Match(tok1->previous(), "const|volatile|final|override|&|&&|noexcept"))
-                    tok1 = tok1->previous();
-                if (tok1 && tok1->previous() && tok1->strAt(-1) == ")") {
-                    bool member = true;
-                    tok1 = tok1->linkAt(-1);
-                    if (Token::Match(tok1->previous(), "throw|noexcept")) {
-                        tok1 = tok1->previous();
-                        while (Token::Match(tok1->previous(), "const|volatile|final|override|&|&&|noexcept"))
-                            tok1 = tok1->previous();
-                        if (tok1->strAt(-1) != ")")
-                            member = false;
-                    } else if (Token::Match(tok->tokAt(-2), ":|, %name%")) {
-                        tok1 = tok1->tokAt(-2);
-                        if (tok1->strAt(-1) != ")")
-                            member = false;
-                    }
-                    if (member) {
-                        if (tok1->strAt(-1) == ">")
-                            tok1 = tok1->previous()->findOpeningBracket();
-                        if (tok1 && Token::Match(tok1->tokAt(-3), "%name% :: %name%")) {
-                            tok1 = tok1->tokAt(-2);
-                            std::string scope = tok1->strAt(-1);
-                            while (Token::Match(tok1->tokAt(-2), ":: %name%")) {
-                                scope = tok1->strAt(-3) + " :: " + scope;
-                                tok1 = tok1->tokAt(-2);
+                                openParenthesis = tok2;
                             }
 
-                            if (!nextScopeNameAddition.empty() && !scope.empty())
-                                nextScopeNameAddition += " :: ";
-                            nextScopeNameAddition += scope;
-                        }
-                    }
-                }
+                            const Token *tok4 = namespaceStart;
 
-                // New scope is opening, record it here
-                std::shared_ptr<ScopeInfo2> newScopeInfo = std::make_shared<ScopeInfo2>(tok->scopeInfo()->name, tok->link(), tok->scopeInfo()->usingNamespaces);
+                            while (tok4 != namespaceEnd) {
+                                tok2 = simplifyTypedefInsertToken(tok2, tok4->str(), location);
+                                tok4 = tok4->next();
+                            }
+                            tok2 = simplifyTypedefInsertToken(tok2, namespaceEnd->str(), location);
 
-                if (newScopeInfo->name != "" && nextScopeNameAddition != "")
-                    newScopeInfo->name.append(" :: ");
-                newScopeInfo->name.append(nextScopeNameAddition);
-                nextScopeNameAddition = "";
+                            tok2 = simplifyTypedefInsertToken(tok2, "*", location);
 
-                if (tok->link())
-                    tok->link()->scopeInfo(tok->scopeInfo());
-                tok->scopeInfo(newScopeInfo);
-            }
-        }
-    }
-}
+                            if (openParenthesis) {
+                                // Skip over name, if any
+                                if (Token::Match(tok2->next(), "%name%"))
+                                    tok2 = tok2->next();
 
-void Tokenizer::simplifyTemplates()
-{
-    if (isC())
-        return;
+                                tok2 = simplifyTypedefInsertToken(tok2, ")", location);
 
-    mTemplateSimplifier->simplifyTemplates(
-#ifdef MAXTIME
-        mMaxTime,
-#else
-        0, // ignored
-#endif
-        mCodeWithTemplates);
-}
-//---------------------------------------------------------------------------
+                                Token::createMutualLinks(tok2, openParenthesis);
+                            }
+                        }
+                    } else if (typeOf) {
+                        tok2 = simplifyTypedefCopyTokens(tok2, argStart, argEnd, location);
+                    } else if (Token::Match(tok2, "%name% [")) {
+                        while (Token::Match(tok2, "%name%|] [")) {
+                            tok2 = tok2->linkAt(1);
+                        }
+                        tok2 = tok2->previous();
+                    }
 
+                    if (arrayStart && arrayEnd) {
+                        do {
+                            if (!tok2->next())
+                                syntaxError(tok2); // can't recover so quit
 
-static bool setVarIdParseDeclaration(const Token **tok, const std::map<std::string,int> &variableId, bool executableScope, bool cpp, bool c)
-{
-    const Token *tok2 = *tok;
-    if (!tok2->isName())
-        return false;
+                            if (!inCast && !inSizeof && !inTemplate)
+                                tok2 = tok2->next();
 
-    int typeCount = 0;
-    int singleNameCount = 0;
-    bool hasstruct = false;   // Is there a "struct" or "class"?
-    bool bracket = false;
-    bool ref = false;
-    while (tok2) {
-        if (tok2->isName()) {
-            if (cpp && Token::Match(tok2, "namespace|public|private|protected"))
-                return false;
-            if (Token::Match(tok2, "struct|union|enum") || (!c && Token::Match(tok2, "class|typename"))) {
-                hasstruct = true;
-                typeCount = 0;
-                singleNameCount = 0;
-            } else if (tok2->str() == "const") {
-                ;  // just skip "const"
-            } else if (!hasstruct && variableId.find(tok2->str()) != variableId.end() && tok2->previous()->str() != "::") {
-                ++typeCount;
-                tok2 = tok2->next();
-                if (!tok2 || tok2->str() != "::")
-                    break;
-            } else {
-                if (tok2->str() != "void" || Token::Match(tok2, "void const| *|(")) // just "void" cannot be a variable type
-                    ++typeCount;
-                ++singleNameCount;
-            }
-        } else if (!c && ((TemplateSimplifier::templateParameters(tok2) > 0) ||
-                          Token::simpleMatch(tok2, "< >") /* Ticket #4764 */)) {
-            const Token *start = *tok;
-            if (Token::Match(start->previous(), "%or%|%oror%|&&|&|^|+|-|*|/"))
-                return false;
-            const Token * const closingBracket = tok2->findClosingBracket();
-            if (closingBracket == nullptr) { /* Ticket #8151 */
-                throw tok2;
-            }
-            tok2 = closingBracket;
-            if (tok2->str() != ">")
-                break;
-            singleNameCount = 1;
-            if (Token::Match(tok2, "> %name% %or%|%oror%|&&|&|^|+|-|*|/") && !Token::Match(tok2, "> const [*&]"))
-                return false;
-            if (Token::Match(tok2, "> %name% )")) {
-                if (Token::Match(tok2->linkAt(2)->previous(), "if|for|while ("))
-                    return false;
-                if (!Token::Match(tok2->linkAt(2)->previous(), "%name% ("))
-                    return false;
-            }
-        } else if (Token::Match(tok2, "&|&&")) {
-            ref = !bracket;
-        } else if (singleNameCount == 1 && Token::Match(tok2, "( [*&]") && Token::Match(tok2->link()->next(), "(|[")) {
-            bracket = true; // Skip: Seems to be valid pointer to array or function pointer
-        } else if (tok2->str() == "::") {
-            singleNameCount = 0;
-        } else if (tok2->str() != "*" && tok2->str() != "::") {
-            break;
-        }
-        tok2 = tok2->next();
-    }
+                            if (tok2->str() == "const")
+                                tok2 = tok2->next();
 
-    if (tok2) {
-        bool isLambdaArg = false;
-        {
-            const Token *tok3 = (*tok)->previous();
-            if (tok3 && tok3->str() == ",") {
-                while (tok3 && !Token::Match(tok3,";|(|[|{")) {
-                    if (Token::Match(tok3, ")|]"))
-                        tok3 = tok3->link();
-                    tok3 = tok3->previous();
-                }
+                            // reference or pointer to array?
+                            if (Token::Match(tok2, "&|*|&&")) {
+                                tok2 = tok2->previous();
+                                Token *tok3 = simplifyTypedefInsertToken(tok2, "(", location);
 
-                if (tok3 && executableScope && Token::Match(tok3->previous(), "%name% (")) {
-                    const Token *fdecl = tok3->previous();
-                    int count = 0;
-                    while (Token::Match(fdecl, "%name%|*")) {
-                        fdecl = fdecl->previous();
-                        count++;
-                    }
-                    if (!Token::Match(fdecl, "[;{}] %name%") || count <= 1)
-                        return false;
-                }
-            }
+                                // handle missing variable name
+                                if (Token::Match(tok3, "( *|&|&& *|&|&& %name%"))
+                                    tok2 = tok3->tokAt(3);
+                                else if (Token::Match(tok2->tokAt(3), "[(),;]"))
+                                    tok2 = tok2->tokAt(2);
+                                else if (Token::simpleMatch(tok2->tokAt(3), ">"))
+                                    tok2 = tok2->tokAt(2);
+                                else
+                                    tok2 = tok2->tokAt(3);
+                                if (!tok2)
+                                    syntaxError(nullptr);
 
-            if (cpp && tok3 && Token::simpleMatch(tok3->previous(), "] (") && Token::simpleMatch(tok3->link(), ") {"))
-                isLambdaArg = true;
-        }
+                                while (tok2->strAt(1) == "::")
+                                    tok2 = tok2->tokAt(2);
 
+                                // skip over function parameters
+                                if (tok2->str() == "(")
+                                    tok2 = tok2->link();
 
-        *tok = tok2;
+                                if (tok2->strAt(1) == "(")
+                                    tok2 = tok2->linkAt(1);
 
-        // In executable scopes, references must be assigned
-        // Catching by reference is an exception
-        if (executableScope && ref && !isLambdaArg) {
-            if (Token::Match(tok2, "(|=|{|:"))
-                ;   // reference is assigned => ok
-            else if (tok2->str() != ")" || tok2->link()->strAt(-1) != "catch")
-                return false;   // not catching by reference => not declaration
-        }
-    }
+                                // skip over const/noexcept
+                                while (Token::Match(tok2->next(), "const|noexcept")) {
+                                    tok2 = tok2->next();
+                                    if (Token::Match(tok2->next(), "( true|false )"))
+                                        tok2 = tok2->tokAt(3);
+                                }
 
-    // Check if array declaration is valid (#2638)
-    // invalid declaration: AAA a[4] = 0;
-    if (typeCount >= 2 && executableScope && tok2 && tok2->str() == "[") {
-        const Token *tok3 = tok2->link()->next();
-        while (tok3 && tok3->str() == "[") {
-            tok3 = tok3->link()->next();
-        }
-        if (Token::Match(tok3, "= %num%"))
-            return false;
-    }
+                                tok2 = simplifyTypedefInsertToken(tok2, ")", location);
+                                Token::createMutualLinks(tok2, tok3);
+                            }
 
-    return (typeCount >= 2 && tok2 && Token::Match(tok2->tokAt(-2), "!!:: %type%"));
-}
+                            if (!tok2->next())
+                                syntaxError(tok2); // can't recover so quit
 
+                            // skip over array dimensions
+                            while (tok2->strAt(1) == "[")
+                                tok2 = tok2->linkAt(1);
 
-void Tokenizer::setVarIdStructMembers(Token **tok1,
-                                      std::map<int, std::map<std::string, int> >& structMembers,
-                                      nonneg int *varId)
-{
-    Token *tok = *tok1;
+                            tok2 = simplifyTypedefCopyTokens(tok2, arrayStart, arrayEnd, location);
+                            if (!tok2->next())
+                                syntaxError(tok2);
 
-    if (Token::Match(tok, "%name% = { . %name% =")) {
-        const int struct_varid = tok->varId();
-        if (struct_varid == 0)
-            return;
+                            if (Token::Match(tok2, "] ; %name% = {") && tok2->next()->isSplittedVarDeclEq())
+                                tok2->deleteNext(2);
 
-        std::map<std::string, int>& members = structMembers[struct_varid];
+                            if (tok2->str() == "=") {
+                                if (tok2->strAt(1) == "{")
+                                    tok2 = tok2->linkAt(1)->next();
+                                else if (tok2->strAt(1).at(0) == '\"')
+                                    tok2 = tok2->tokAt(2);
+                            }
+                        } while (Token::Match(tok2, ", %name% ;|=|,"));
+                    }
 
-        tok = tok->tokAt(3);
-        while (tok->str() != "}") {
-            if (Token::Match(tok, "{|[|("))
-                tok = tok->link();
-            if (Token::Match(tok->previous(), "[,{] . %name% =")) {
-                tok = tok->next();
-                const std::map<std::string, int>::iterator it = members.find(tok->str());
-                if (it == members.end()) {
-                    members[tok->str()] = ++(*varId);
-                    tok->varId(*varId);
-                } else {
-                    tok->varId(it->second);
+                    simplifyType = false;
                 }
+                if (!tok2)
+                    break;
             }
-            tok = tok->next();
-        }
-
-        return;
-    }
 
-    while (Token::Match(tok->next(), ")| . %name% !!(")) {
-        // Don't set varid for trailing return type
-        if (tok->strAt(1) == ")" && tok->linkAt(1)->previous()->isName() &&
-            isFunctionHead(tok->linkAt(1), "{|;")) {
-            tok = tok->tokAt(3);
-            continue;
-        }
-        const int struct_varid = tok->varId();
-        tok = tok->tokAt(2);
-        if (struct_varid == 0)
-            continue;
+            if (!tok)
+                syntaxError(nullptr);
 
-        if (tok->str() == ".")
-            tok = tok->next();
+            if (tok->str() == ";")
+                done = true;
+            else if (tok->str() == ",") {
+                arrayStart = nullptr;
+                arrayEnd = nullptr;
+                tokOffset = tok->next();
+                pointers.clear();
 
-        // Don't set varid for template function
-        if (TemplateSimplifier::templateParameters(tok->next()) > 0)
-            break;
+                while (Token::Match(tokOffset, "*|&")) {
+                    pointers.push_back(tokOffset->str());
+                    tokOffset = tokOffset->next();
+                }
 
-        std::map<std::string, int>& members = structMembers[struct_varid];
-        const std::map<std::string, int>::iterator it = members.find(tok->str());
-        if (it == members.end()) {
-            members[tok->str()] = ++(*varId);
-            tok->varId(*varId);
-        } else {
-            tok->varId(it->second);
-        }
-    }
-    // tok can't be null
-    *tok1 = tok;
-}
+                if (Token::Match(tokOffset, "%type%")) {
+                    typeName = tokOffset;
+                    tokOffset = tokOffset->next();
 
+                    if (tokOffset && tokOffset->str() == "[") {
+                        arrayStart = tokOffset;
 
-void Tokenizer::setVarIdClassDeclaration(const Token * const startToken,
-        const VariableMap &variableMap,
-        const nonneg int scopeStartVarId,
-        std::map<int, std::map<std::string,int> >& structMembers)
-{
-    // end of scope
-    const Token * const endToken = startToken->link();
+                        for (;;) {
+                            while (tokOffset->next() && !Token::Match(tokOffset->next(), ";|,"))
+                                tokOffset = tokOffset->next();
 
-    // determine class name
-    std::string className;
-    for (const Token *tok = startToken->previous(); tok; tok = tok->previous()) {
-        if (!tok->isName() && tok->str() != ":")
-            break;
-        if (Token::Match(tok, "class|struct|enum %type% [:{]")) {
-            className = tok->next()->str();
-            break;
-        }
-    }
+                            if (!tokOffset->next())
+                                return; // invalid input
+                            if (tokOffset->strAt(1) == ";")
+                                break;
+                            if (tokOffset->str() == "]")
+                                break;
+                            tokOffset = tokOffset->next();
+                        }
 
-    // replace varids..
-    int indentlevel = 0;
-    bool initList = false;
-    bool inEnum = false;
-    const Token *initListArgLastToken = nullptr;
-    for (Token *tok = startToken->next(); tok != endToken; tok = tok->next()) {
-        if (!tok)
-            syntaxError(nullptr);
-        if (initList) {
-            if (tok == initListArgLastToken)
-                initListArgLastToken = nullptr;
-            else if (!initListArgLastToken &&
-                     Token::Match(tok->previous(), "%name%|>|>> {|(") &&
-                     Token::Match(tok->link(), "}|) ,|{"))
-                initListArgLastToken = tok->link();
-        }
-        if (tok->str() == "{") {
-            inEnum = isEnumStart(tok);
-            if (initList && !initListArgLastToken)
-                initList = false;
-            ++indentlevel;
-        } else if (tok->str() == "}") {
-            --indentlevel;
-            inEnum = false;
-        } else if (initList && indentlevel == 0 && Token::Match(tok->previous(), "[,:] %name% [({]")) {
-            const std::map<std::string, int>::const_iterator it = variableMap.find(tok->str());
-            if (it != variableMap.end()) {
-                tok->varId(it->second);
-            }
-        } else if (tok->isName() && tok->varId() <= scopeStartVarId) {
-            if (indentlevel > 0 || initList) {
-                if (Token::Match(tok->previous(), "::|.") && tok->strAt(-2) != "this" && !Token::simpleMatch(tok->tokAt(-5), "( * this ) ."))
-                    continue;
-                if (!tok->next())
-                    syntaxError(nullptr);
-                if (tok->next()->str() == "::") {
-                    if (tok->str() == className)
-                        tok = tok->tokAt(2);
-                    else
-                        continue;
-                }
+                        arrayEnd = tokOffset;
+                        tokOffset = tokOffset->next();
+                    }
 
-                if (!inEnum) {
-                    const std::map<std::string, int>::const_iterator it = variableMap.find(tok->str());
-                    if (it != variableMap.end()) {
-                        tok->varId(it->second);
-                        setVarIdStructMembers(&tok, structMembers, variableMap.getVarId());
+                    if (Token::Match(tokOffset, ";|,"))
+                        tok = tokOffset;
+                    else {
+                        // we encountered a typedef we don't support yet so just continue
+                        done = true;
+                        ok = false;
                     }
+                } else {
+                    // we encountered a typedef we don't support yet so just continue
+                    done = true;
+                    ok = false;
                 }
+            } else {
+                // something is really wrong (internal error)
+                done = true;
+                ok = false;
             }
-        } else if (indentlevel == 0 && tok->str() == ":" && !initListArgLastToken)
-            initList = true;
-    }
-}
-
-
+        }
 
-// Update the variable ids..
-// Parse each function..
-void Tokenizer::setVarIdClassFunction(const std::string &classname,
-                                      Token * const startToken,
-                                      const Token * const endToken,
-                                      const std::map<std::string, int> &varlist,
-                                      std::map<int, std::map<std::string, int> >& structMembers,
-                                      nonneg int *varId_)
-{
-    for (Token *tok2 = startToken; tok2 && tok2 != endToken; tok2 = tok2->next()) {
-        if (tok2->varId() != 0 || !tok2->isName())
-            continue;
-        if (Token::Match(tok2->tokAt(-2), ("!!" + classname + " ::").c_str()))
-            continue;
-        if (Token::Match(tok2->tokAt(-4), "%name% :: %name% ::")) // Currently unsupported
-            continue;
-        if (Token::Match(tok2->tokAt(-2), "!!this .") && !Token::simpleMatch(tok2->tokAt(-5), "( * this ) ."))
-            continue;
+        if (ok) {
+            // remove typedef
+            Token::eraseTokens(typeDef, tok);
 
-        const std::map<std::string,int>::const_iterator it = varlist.find(tok2->str());
-        if (it != varlist.end()) {
-            tok2->varId(it->second);
-            setVarIdStructMembers(&tok2, structMembers, varId_);
+            if (typeDef != list.front()) {
+                tok = typeDef->previous();
+                tok->deleteNext();
+                //no need to remove last token in the list
+                if (tok->tokAt(2))
+                    tok->deleteNext();
+            } else {
+                list.front()->deleteThis();
+                //no need to remove last token in the list
+                if (list.front()->next())
+                    list.front()->deleteThis();
+                tok = list.front();
+                //now the next token to process is 'tok', not 'tok->next()';
+                goback = true;
+            }
         }
     }
 }
 
+namespace {
+    struct ScopeInfo3 {
+        enum Type : std::uint8_t { Global, Namespace, Record, MemberFunction, Other };
+        ScopeInfo3() : parent(nullptr), type(Global), bodyStart(nullptr), bodyEnd(nullptr) {}
+        ScopeInfo3(ScopeInfo3 *parent_, Type type_, std::string name_, const Token *bodyStart_, const Token *bodyEnd_)
+            : parent(parent_), type(type_), name(std::move(name_)), bodyStart(bodyStart_), bodyEnd(bodyEnd_) {
+            if (name.empty())
+                return;
+            fullName = name;
+            ScopeInfo3 *scope = parent;
+            while (scope && scope->parent) {
+                if (scope->name.empty())
+                    break;
+                fullName.insert(0, " :: ");
+                fullName.insert(0, scope->name);
+                scope = scope->parent;
+            }
+        }
+        ScopeInfo3 *parent;
+        std::list<ScopeInfo3> children;
+        Type type;
+        std::string fullName;
+        std::string name;
+        const Token * bodyStart;
+        const Token * bodyEnd;
+        std::set<std::string> usingNamespaces;
+        std::set<std::string> recordTypes;
+        std::set<std::string> baseTypes;
 
+        ScopeInfo3 *addChild(Type scopeType, std::string scopeName, const Token *bodyStartToken, const Token *bodyEndToken) {
+            children.emplace_back(this, scopeType, std::move(scopeName), bodyStartToken, bodyEndToken);
+            return &children.back();
+        }
 
-void Tokenizer::setVarId()
-{
-    // Clear all variable ids
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (tok->isName())
-            tok->varId(0);
-    }
-
-    setPodTypes();
-
-    setVarIdPass1();
-
-    setVarIdPass2();
-}
+        bool hasChild(const std::string &childName) const {
+            return std::any_of(children.cbegin(), children.cend(), [&](const ScopeInfo3& child) {
+                return child.name == childName;
+            });
+        }
 
+        const ScopeInfo3 * findInChildren(const std::string & scope) const {
+            for (const auto & child : children) {
+                if (child.type == Record && (child.name == scope || child.fullName == scope))
+                    return &child;
 
-// Variable declarations can't start with "return" etc.
-#define NOTSTART_C "case", "default", "goto", "NOT", "return", "sizeof", "typedef"
-static const std::set<std::string> notstart_c = { NOTSTART_C };
-static const std::set<std::string> notstart_cpp = { NOTSTART_C,
-                                                    "delete", "friend", "new", "throw", "using", "virtual", "explicit", "const_cast", "dynamic_cast", "reinterpret_cast", "static_cast", "template"
-                                                  };
+                const ScopeInfo3 * temp = child.findInChildren(scope);
+                if (temp)
+                    return temp;
+            }
+            return nullptr;
+        }
 
-void Tokenizer::setVarIdPass1()
-{
-    // Variable declarations can't start with "return" etc.
-    const std::set<std::string>& notstart = (isC()) ? notstart_c : notstart_cpp;
+        const ScopeInfo3 * findScope(const std::string & scope) const {
+            const ScopeInfo3 * tempScope = this;
+            while (tempScope) {
+                // check children
+                auto it = std::find_if(tempScope->children.cbegin(), tempScope->children.cend(), [&](const ScopeInfo3& child) {
+                    return &child != this && child.type == Record && (child.name == scope || child.fullName == scope);
+                });
+                if (it != tempScope->children.end())
+                    return &*it;
+                // check siblings for same name
+                if (tempScope->parent) {
+                    for (const auto &sibling : tempScope->parent->children) {
+                        if (sibling.name == tempScope->name && &sibling != this) {
+                            const ScopeInfo3 * temp = sibling.findInChildren(scope);
+                            if (temp)
+                                return temp;
+                        }
+                    }
+                }
+                tempScope = tempScope->parent;
+            }
+            return nullptr;
+        }
 
-    VariableMap variableMap;
-    std::map<int, std::map<std::string, int> > structMembers;
+        bool findTypeInBase(const std::string &scope) const {
+            if (scope.empty())
+                return false;
+            // check in base types first
+            if (baseTypes.find(scope) != baseTypes.end())
+                return true;
+            // check in base types base types
+            for (const std::string & base : baseTypes) {
+                const ScopeInfo3 * baseScope = findScope(base);
+                // bail on uninstantiated recursive template
+                if (baseScope == this)
+                    return false;
+                if (baseScope && baseScope->fullName == scope)
+                    return true;
+                if (baseScope && baseScope->findTypeInBase(scope))
+                    return true;
+            }
+            return false;
+        }
 
-    std::stack<VarIdScopeInfo> scopeStack;
+        ScopeInfo3 * findScope(const ScopeInfo3 * scope) {
+            if (scope->bodyStart == bodyStart)
+                return this;
+            for (auto & child : children) {
+                ScopeInfo3 * temp = child.findScope(scope);
+                if (temp)
+                    return temp;
+            }
+            return nullptr;
+        }
+    };
 
-    scopeStack.push(VarIdScopeInfo());
-    std::stack<const Token *> functionDeclEndStack;
-    const Token *functionDeclEndToken = nullptr;
-    bool initlist = false;
-    bool inlineFunction = false;
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (tok->isOp())
-            continue;
-        if (tok == functionDeclEndToken) {
-            functionDeclEndStack.pop();
-            functionDeclEndToken = functionDeclEndStack.empty() ? nullptr : functionDeclEndStack.top();
-            if (tok->str() == ":")
-                initlist = true;
-            else if (tok->str() == ";") {
-                if (!variableMap.leaveScope())
-                    cppcheckError(tok);
-            } else if (tok->str() == "{")
-                scopeStack.push(VarIdScopeInfo(true, scopeStack.top().isStructInit || tok->strAt(-1) == "=", /*isEnum=*/false, *variableMap.getVarId()));
-        } else if (!initlist && tok->str()=="(") {
-            const Token * newFunctionDeclEnd = nullptr;
-            if (!scopeStack.top().isExecutable)
-                newFunctionDeclEnd = isFunctionHead(tok, "{:;");
+    void setScopeInfo(Token *tok, ScopeInfo3 *&scopeInfo, bool debug=false)
+    {
+        if (!tok)
+            return;
+        if (tok->str() == "{" && scopeInfo->parent && tok == scopeInfo->bodyStart)
+            return;
+        if (tok->str() == "}") {
+            if (scopeInfo->parent && tok == scopeInfo->bodyEnd)
+                scopeInfo = scopeInfo->parent;
             else {
-                Token const * const tokenLinkNext = tok->link()->next();
-                if (tokenLinkNext && tokenLinkNext->str() == "{") // might be for- or while-loop or if-statement
-                    newFunctionDeclEnd = tokenLinkNext;
+                // Try to find parent scope
+                ScopeInfo3 *parent = scopeInfo->parent;
+                while (parent && parent->bodyEnd != tok)
+                    parent = parent->parent;
+                if (parent) {
+                    scopeInfo = parent;
+                    if (debug)
+                        throw std::runtime_error("Internal error: unmatched }");
+                }
             }
-            if (newFunctionDeclEnd && newFunctionDeclEnd != functionDeclEndToken) {
-                functionDeclEndStack.push(newFunctionDeclEnd);
-                functionDeclEndToken = newFunctionDeclEnd;
-                variableMap.enterScope();
+            return;
+        }
+        if (!Token::Match(tok, "namespace|class|struct|union %name% {|:|::|<")) {
+            // check for using namespace
+            if (Token::Match(tok, "using namespace %name% ;|::")) {
+                const Token * tok1 = tok->tokAt(2);
+                std::string nameSpace;
+                while (tok1 && tok1->str() != ";") {
+                    if (!nameSpace.empty())
+                        nameSpace += " ";
+                    nameSpace += tok1->str();
+                    tok1 = tok1->next();
+                }
+                scopeInfo->usingNamespaces.insert(std::move(nameSpace));
             }
-        } else if (Token::Match(tok, "{|}")) {
-            inlineFunction = false;
-
-            const Token * const startToken = (tok->str() == "{") ? tok : tok->link();
-
-            // parse anonymous unions as part of the current scope
-            if (!Token::Match(startToken->previous(), "union|struct|enum {") &&
-                !(initlist && Token::Match(startToken->previous(), "%name%|>|>>") && Token::Match(startToken->link(), "} ,|{"))) {
-
-                if (tok->str() == "{") {
-                    bool isExecutable;
-                    const Token *prev = tok->previous();
-                    while (Token::Match(prev, "%name%|."))
-                        prev = prev->previous();
-                    const bool isLambda = prev && prev->str() == ")" && Token::simpleMatch(prev->link()->previous(), "] (");
-                    if ((!isLambda && (tok->strAt(-1) == ")" || Token::Match(tok->tokAt(-2), ") %type%"))) ||
-                        (initlist && tok->strAt(-1) == "}")) {
-                        isExecutable = true;
+            // check for member function
+            else if (tok->str() == "{") {
+                bool added = false;
+                Token *tok1 = tok;
+                while (Token::Match(tok1->previous(), "const|volatile|final|override|&|&&|noexcept"))
+                    tok1 = tok1->previous();
+                if (tok1->previous() && (tok1->strAt(-1) == ")" || tok->strAt(-1) == "}")) {
+                    tok1 = tok1->linkAt(-1);
+                    if (Token::Match(tok1->previous(), "throw|noexcept (")) {
+                        tok1 = tok1->previous();
+                        while (Token::Match(tok1->previous(), "const|volatile|final|override|&|&&|noexcept"))
+                            tok1 = tok1->previous();
+                        if (tok1->strAt(-1) != ")")
+                            return;
+                        tok1 = tok1->linkAt(-1);
                     } else {
-                        isExecutable = ((scopeStack.top().isExecutable || initlist || tok->strAt(-1) == "else") &&
-                                        !isClassStructUnionEnumStart(tok));
-                        if (!(scopeStack.top().isStructInit || tok->strAt(-1) == "="))
-                            variableMap.enterScope();
+                        while (Token::Match(tok1->tokAt(-2), ":|, %name%")) {
+                            tok1 = tok1->tokAt(-2);
+                            if (tok1->strAt(-1) != ")" && tok1->strAt(-1) != "}")
+                                return;
+                            tok1 = tok1->linkAt(-1);
+                        }
                     }
-                    initlist = false;
-                    scopeStack.push(VarIdScopeInfo(isExecutable, scopeStack.top().isStructInit || tok->strAt(-1) == "=", isEnumStart(tok), *variableMap.getVarId()));
-                } else { /* if (tok->str() == "}") */
-                    bool isNamespace = false;
-                    for (const Token *tok1 = tok->link()->previous(); tok1 && tok1->isName(); tok1 = tok1->previous()) {
-                        if (tok1->str() == "namespace") {
-                            isNamespace = true;
-                            break;
+                    if (tok1->strAt(-1) == ">")
+                        tok1 = tok1->previous()->findOpeningBracket();
+                    if (tok1 && (Token::Match(tok1->tokAt(-3), "%name% :: %name%") ||
+                                 Token::Match(tok1->tokAt(-4), "%name% :: ~ %name%"))) {
+                        tok1 = tok1->tokAt(-2);
+                        if (tok1->str() == "~")
+                            tok1 = tok1->previous();
+                        std::string scope = tok1->strAt(-1);
+                        while (Token::Match(tok1->tokAt(-2), ":: %name%")) {
+                            scope = tok1->strAt(-3) + " :: " + scope;
+                            tok1 = tok1->tokAt(-2);
                         }
+                        scopeInfo = scopeInfo->addChild(ScopeInfo3::MemberFunction, std::move(scope), tok, tok->link());
+                        added = true;
                     }
-                    // Set variable ids in class declaration..
-                    if (!initlist && !isC() && !scopeStack.top().isExecutable && tok->link() && !isNamespace) {
-                        setVarIdClassDeclaration(tok->link(),
-                                                 variableMap,
-                                                 scopeStack.top().startVarid,
-                                                 structMembers);
+                    // inline member function
+                    else if ((scopeInfo->type == ScopeInfo3::Record || scopeInfo->type == ScopeInfo3::Namespace) && tok1 && Token::Match(tok1->tokAt(-1), "%name% (")) {
+                        std::string scope = scopeInfo->name + "::" + tok1->strAt(-1);
+                        scopeInfo = scopeInfo->addChild(ScopeInfo3::MemberFunction, std::move(scope), tok, tok->link());
+                        added = true;
                     }
+                }
 
-                    if (!scopeStack.top().isStructInit) {
-                        variableMap.leaveScope();
-                    }
+                if (!added)
+                    scopeInfo = scopeInfo->addChild(ScopeInfo3::Other, "", tok, tok->link());
+            }
+            return;
+        }
 
-                    scopeStack.pop();
-                    if (scopeStack.empty()) {  // should be impossible
-                        scopeStack.push(VarIdScopeInfo());
+        const bool record = Token::Match(tok, "class|struct|union %name%");
+        tok = tok->next();
+        std::string classname = tok->str();
+        while (Token::Match(tok, "%name% :: %name%")) {
+            tok = tok->tokAt(2);
+            classname += " :: " + tok->str();
+        }
+
+        // add record type to scope info
+        if (record)
+            scopeInfo->recordTypes.insert(classname);
+        tok = tok->next();
+
+        // skip template parameters
+        if (tok && tok->str() == "<") {
+            tok = tok->findClosingBracket();
+            if (tok)
+                tok = tok->next();
+        }
+
+        // get base class types
+        std::set<std::string> baseTypes;
+        if (tok && tok->str() == ":") {
+            do {
+                tok = tok->next();
+                while (Token::Match(tok, "public|protected|private|virtual"))
+                    tok = tok->next();
+                std::string base;
+                while (tok && !Token::Match(tok, ";|,|{")) {
+                    if (!base.empty())
+                        base += ' ';
+                    base += tok->str();
+                    tok = tok->next();
+                    // add template parameters
+                    if (tok && tok->str() == "<") {
+                        const Token* endTok = tok->findClosingBracket();
+                        if (endTok) {
+                            endTok = endTok->next();
+                            while (tok != endTok) {
+                                base += tok->str();
+                                tok = tok->next();
+                            }
+                        }
                     }
                 }
-            }
+                baseTypes.insert(std::move(base));
+            } while (tok && !Token::Match(tok, ";|{"));
         }
 
-        if (!scopeStack.top().isStructInit &&
-            (tok == list.front() ||
-             Token::Match(tok, "[;{}]") ||
-             (tok->str() == "(" && isFunctionHead(tok,"{")) ||
-             (tok->str() == "(" && !scopeStack.top().isExecutable && isFunctionHead(tok,";:")) ||
-             (tok->str() == "," && (!scopeStack.top().isExecutable || inlineFunction)) ||
-             (tok->isName() && endsWith(tok->str(), ':')))) {
+        if (tok && tok->str() == "{") {
+            scopeInfo = scopeInfo->addChild(record ? ScopeInfo3::Record : ScopeInfo3::Namespace, std::move(classname), tok, tok->link());
+            scopeInfo->baseTypes = std::move(baseTypes);
+        }
+    }
 
-            // No variable declarations in sizeof
-            if (Token::simpleMatch(tok->previous(), "sizeof (")) {
-                continue;
-            }
+    Token *findSemicolon(Token *tok)
+    {
+        int level = 0;
 
-            if (Settings::terminated())
-                return;
+        for (; tok && (level > 0 || tok->str() != ";"); tok = tok->next()) {
+            if (tok->str() == "{")
+                ++level;
+            else if (level > 0 && tok->str() == "}")
+                --level;
+        }
 
-            // locate the variable name..
-            const Token *tok2 = (tok->isName()) ? tok : tok->next();
+        return tok;
+    }
 
-            // private: protected: public: etc
-            while (tok2 && endsWith(tok2->str(), ':')) {
-                tok2 = tok2->next();
-            }
-            if (!tok2)
-                break;
+    bool usingMatch(
+        const Token *nameToken,
+        const std::string &scope,
+        Token *&tok,
+        const std::string &scope1,
+        const ScopeInfo3 *currentScope,
+        const ScopeInfo3 *memberClassScope)
+    {
+        Token *tok1 = tok;
 
-            // Variable declaration can't start with "return", etc
-            if (notstart.find(tok2->str()) != notstart.end())
-                continue;
+        if (tok1 && tok1->str() != nameToken->str())
+            return false;
 
-            if (!isC() && Token::simpleMatch(tok2, "const new"))
-                continue;
+        // skip this using
+        if (tok1 == nameToken) {
+            tok = findSemicolon(tok1);
+            return false;
+        }
 
-            bool decl;
-            try { /* Ticket #8151 */
-                decl = setVarIdParseDeclaration(&tok2, variableMap.map(), scopeStack.top().isExecutable, isCPP(), isC());
-            } catch (const Token * errTok) {
-                syntaxError(errTok);
-            }
-            if (decl) {
-                if (tok->str() == "(" && isFunctionHead(tok,"{") && scopeStack.top().isExecutable)
-                    inlineFunction = true;
+        // skip other using with this name
+        if (tok1->strAt(-1) == "using") {
+            // fixme: this is wrong
+            // skip to end of scope
+            if (currentScope->bodyEnd)
+                tok = const_cast<Token*>(currentScope->bodyEnd->previous());
+            return false;
+        }
 
-                const Token* prev2 = tok2->previous();
-                if (Token::Match(prev2, "%type% [;[=,)]") && tok2->previous()->str() != "const")
-                    ;
-                else if (Token::Match(prev2, "%type% :") && tok->strAt(-1) == "for")
-                    ;
-                else if (Token::Match(prev2, "%type% ( !!)") && Token::simpleMatch(tok2->link(), ") ;")) {
-                    // In C++ , a variable can't be called operator+ or something like that.
-                    if (isCPP() &&
-                        prev2->isOperatorKeyword())
-                        continue;
+        if (tok1->tokAt(-1)->tokType() == Token::eType || tok1->tokAt(-1)->tokType() == Token::eName)
+            return false;
 
-                    const Token *tok3 = tok2->next();
-                    if (!tok3->isStandardType() && tok3->str() != "void" && !Token::Match(tok3, "struct|union|class %type%") && tok3->str() != "." && !Token::Match(tok2->link()->previous(), "[&*]")) {
-                        if (!scopeStack.top().isExecutable) {
-                            // Detecting initializations with () in non-executable scope is hard and often impossible to be done safely. Thus, only treat code as a variable that definitely is one.
-                            decl = false;
-                            bool rhs = false;
-                            for (; tok3; tok3 = tok3->nextArgumentBeforeCreateLinks2()) {
-                                if (tok3->str() == "=") {
-                                    rhs = true;
-                                    continue;
-                                }
+        if (Token::Match(tok1->tokAt(-1), "class|struct|union|enum|namespace")) {
+            // fixme
+            return false;
+        }
 
-                                if (tok3->str() == ",") {
-                                    rhs = false;
-                                    continue;
-                                }
+        if (Token::simpleMatch(tok1->tokAt(-2), "> ::")) {
+            return false;
+        }
 
-                                if (rhs)
-                                    continue;
+        if (Token::Match(tok1, "%name% (") && TokenList::isFunctionHead(tok1->next(), "{;:")) {
+            if (Token::Match(tok1->previous(), "%name%") && !tok1->previous()->isControlFlowKeyword())
+                return false;
+            if (Token::Match(tok1->previous(), ">|>>") && tok1->linkAt(-1))
+                return false;
+            if (Token::Match(tok1->previous(), "*|&|&&")) {
+                const Token* prev = tok1->previous();
+                while (Token::Match(prev, "%name%|*|&|&&|::") && !prev->isControlFlowKeyword())
+                    prev = prev->previous();
+                if (Token::Match(prev, ">|>>") && tok1->linkAt(-1))
+                    return false;
+                if (Token::Match(prev, "[;{}] %name%"))
+                    return false;
+            }
+        }
 
-                                if (tok3->isLiteral() ||
-                                    (tok3->isName() && variableMap.hasVariable(tok3->str())) ||
-                                    tok3->isOp() ||
-                                    tok3->str() == "(" ||
-                                    notstart.find(tok3->str()) != notstart.end()) {
-                                    decl = true;
-                                    break;
-                                }
-                            }
-                        }
-                    } else
-                        decl = false;
-                } else if (isCPP() && Token::Match(prev2, "%type% {") && Token::simpleMatch(tok2->link(), "} ;")) { // C++11 initialization style
-                    if (Token::Match(prev2, "do|try|else") || Token::Match(prev2->tokAt(-2), "struct|class|:"))
-                        continue;
-                } else
-                    decl = false;
+        // get qualification
+        std::string qualification;
+        const Token* tok2 = tok1;
+        std::string::size_type index = scope.size();
+        std::string::size_type new_index = std::string::npos;
+        bool match = true;
+        while (Token::Match(tok2->tokAt(-2), "%name% ::") && !tok2->tokAt(-2)->isKeyword()) {
+            std::string last;
+            if (match && !scope1.empty()) {
+                new_index = scope1.rfind(' ', index - 1);
+                if (new_index != std::string::npos)
+                    last = scope1.substr(new_index, index - new_index);
+                else if (!qualification.empty())
+                    last.clear();
+                else
+                    last = scope1;
+            } else
+                match = false;
+            if (match && tok2->strAt(-2) == last)
+                index = new_index;
+            else {
+                if (!qualification.empty())
+                    qualification = " :: " + qualification;
+                qualification = tok2->strAt(-2) + qualification;
+            }
+            tok2 = tok2->tokAt(-2);
+        }
 
-                if (decl) {
-                    variableMap.addVariable(prev2->str());
+        std::string fullScope1 = scope1;
+        if (!scope1.empty() && !qualification.empty())
+            fullScope1 += " :: ";
+        fullScope1 += qualification;
 
-                    // set varid for template parameters..
-                    tok = tok->next();
-                    while (Token::Match(tok, "%name%|::"))
-                        tok = tok->next();
-                    if (tok && tok->str() == "<") {
-                        const Token *end = tok->findClosingBracket();
-                        while (tok != end) {
-                            if (tok->isName()) {
-                                const std::map<std::string, int>::const_iterator it = variableMap.find(tok->str());
-                                if (it != variableMap.end())
-                                    tok->varId(it->second);
-                            }
-                            tok = tok->next();
-                        }
-                    }
+        if (scope == fullScope1)
+            return true;
 
-                    tok = tok2->previous();
+        const ScopeInfo3 *scopeInfo = memberClassScope ? memberClassScope : currentScope;
+
+        // check in base types
+        if (qualification.empty() && scopeInfo->findTypeInBase(scope))
+            return true;
+
+        // check using namespace
+        const ScopeInfo3 * tempScope = scopeInfo;
+        while (tempScope) {
+            //if (!tempScope->parent->usingNamespaces.empty()) {
+            const std::set<std::string>& usingNS = tempScope->usingNamespaces;
+            if (!usingNS.empty()) {
+                if (qualification.empty()) {
+                    if (usingNS.find(scope) != usingNS.end())
+                        return true;
+                } else {
+                    const std::string suffix = " :: " + qualification;
+                    if (std::any_of(usingNS.cbegin(), usingNS.cend(), [&](const std::string& ns) {
+                        return scope == ns + suffix;
+                    }))
+                        return true;
                 }
             }
+            tempScope = tempScope->parent;
         }
 
-        if (tok->isName()) {
-            // don't set variable id after a struct|enum|union
-            if (Token::Match(tok->previous(), "struct|enum|union") || (isCPP() && tok->strAt(-1) == "class"))
-                continue;
-
-            if (!isC()) {
-                if (tok->previous() && tok->previous()->str() == "::")
-                    continue;
-                if (tok->next() && tok->next()->str() == "::")
-                    continue;
-                if (Token::simpleMatch(tok->tokAt(-2), ":: template"))
-                    continue;
-            }
+        std::string newScope1 = scope1;
 
-            // function declaration inside executable scope? Function declaration is of form: type name "(" args ")"
-            if (scopeStack.top().isExecutable && Token::Match(tok, "%name% [,)]")) {
-                bool par = false;
-                const Token *start, *end;
+        // scopes didn't match so try higher scopes
+        index = newScope1.size();
+        while (!newScope1.empty()) {
+            const std::string::size_type separator = newScope1.rfind(" :: ", index - 1);
+            if (separator != std::string::npos)
+                newScope1.resize(separator);
+            else
+                newScope1.clear();
 
-                // search begin of function declaration
-                for (start = tok; Token::Match(start, "%name%|*|&|,|("); start = start->previous()) {
-                    if (start->str() == "(") {
-                        if (par)
-                            break;
-                        par = true;
-                    }
-                    if (Token::Match(start, "[(,]")) {
-                        if (!Token::Match(start, "[(,] %type% %name%|*|&"))
-                            break;
-                    }
-                    if (start->varId() > 0)
-                        break;
-                }
+            std::string newFullScope1 = newScope1;
+            if (!newScope1.empty() && !qualification.empty())
+                newFullScope1 += " :: ";
+            newFullScope1 += qualification;
 
-                // search end of function declaration
-                for (end = tok->next(); Token::Match(end, "%name%|*|&|,"); end = end->next()) {}
+            if (scope == newFullScope1)
+                return true;
+        }
 
-                // there are tokens which can't appear at the begin of a function declaration such as "return"
-                const bool isNotstartKeyword = start->next() && notstart.find(start->next()->str()) != notstart.end();
+        return false;
+    }
 
-                // now check if it is a function declaration
-                if (Token::Match(start, "[;{}] %type% %name%|*") && par && Token::simpleMatch(end, ") ;") && !isNotstartKeyword)
-                    // function declaration => don't set varid
-                    continue;
-            }
+    std::string memberFunctionScope(const Token *tok)
+    {
+        std::string qualification;
+        const Token *qualTok = tok->strAt(-2) == "~" ? tok->tokAt(-4) : tok->tokAt(-3);
+        while (Token::Match(qualTok, "%type% ::")) {
+            if (!qualification.empty())
+                qualification = " :: " + qualification;
+            qualification = qualTok->str() + qualification;
+            qualTok = qualTok->tokAt(-2);
+        }
+        return qualification;
+    }
 
-            if (!scopeStack.top().isEnum) {
-                const std::map<std::string, int>::const_iterator it = variableMap.find(tok->str());
-                if (it != variableMap.end()) {
-                    tok->varId(it->second);
-                    setVarIdStructMembers(&tok, structMembers, variableMap.getVarId());
-                }
-            }
-        } else if (Token::Match(tok, "::|. %name%")) {
-            // Don't set varid after a :: or . token
-            tok = tok->next();
-        } else if (tok->str() == ":" && Token::Match(tok->tokAt(-2), "class %type%")) {
-            do {
-                tok = tok->next();
-            } while (tok && (tok->isName() || tok->str() == ","));
-            if (!tok)
+    const Token * memberFunctionEnd(const Token *tok)
+    {
+        if (tok->str() != "(")
+            return nullptr;
+        const Token *end = tok->link()->next();
+        while (end) {
+            if (end->str() == "{" && !Token::Match(end->tokAt(-2), ":|, %name%"))
+                return end;
+            if (end->str() == ";")
                 break;
-            tok = tok->previous();
+            end = end->next();
         }
+        return nullptr;
     }
+} // namespace
 
-    mVarId = *variableMap.getVarId();
+bool Tokenizer::isMemberFunction(const Token *openParen)
+{
+    return (Token::Match(openParen->tokAt(-2), ":: %name% (") ||
+            Token::Match(openParen->tokAt(-3), ":: ~ %name% (")) &&
+           TokenList::isFunctionHead(openParen, "{:");
 }
 
-namespace {
-    struct Member {
-        Member(const std::list<std::string> &s, const std::list<const Token *> &ns, Token *t) : usingnamespaces(ns), scope(s), tok(t) {}
-        std::list<const Token *> usingnamespaces;
-        std::list<std::string> scope;
-        Token *tok;
-    };
+static bool scopesMatch(const std::string &scope1, const std::string &scope2, const ScopeInfo3 *globalScope)
+{
+    if (scope1.empty() || scope2.empty())
+        return false;
+
+    // check if scopes match
+    if (scope1 == scope2)
+        return true;
+
+    // check if scopes only differ by global qualification
+    if (scope1 == (":: " + scope2)) {
+        std::string::size_type end = scope2.find_first_of(' ');
+        if (end == std::string::npos)
+            end = scope2.size();
+        if (globalScope->hasChild(scope2.substr(0, end)))
+            return true;
+    } else if (scope2 == (":: " + scope1)) {
+        std::string::size_type end = scope1.find_first_of(' ');
+        if (end == std::string::npos)
+            end = scope1.size();
+        if (globalScope->hasChild(scope1.substr(0, end)))
+            return true;
+    }
+
+    return false;
 }
 
-static std::string getScopeName(const std::list<ScopeInfo2> &scopeInfo)
-{
-    std::string ret;
-    for (const ScopeInfo2 &si : scopeInfo)
-        ret += (ret.empty() ? "" : " :: ") + (si.name);
-    return ret;
+static unsigned int tokDistance(const Token* tok1, const Token* tok2) { // use when index() is not available yet
+    unsigned int dist = 0;
+    const Token* tok = tok1;
+    while (tok != tok2) {
+        ++dist;
+        tok = tok->next();
+    }
+    return dist;
 }
 
-static Token * matchMemberName(const std::list<std::string> &scope, const Token *nsToken, Token *memberToken, const std::list<ScopeInfo2> &scopeInfo)
+static const Token* skipConstVolatileBackwards(const Token* tok) {
+    while (Token::Match(tok, "const|volatile"))
+        tok = tok->previous();
+    return tok;
+}
+
+bool Tokenizer::simplifyUsing()
 {
-    std::list<ScopeInfo2>::const_iterator scopeIt = scopeInfo.begin();
+    if (!isCPP())
+        return false;
 
-    // Current scope..
-    for (std::list<std::string>::const_iterator it = scope.begin(); it != scope.end(); ++it) {
-        if (scopeIt == scopeInfo.end() || scopeIt->name != *it)
-            return nullptr;
-        ++scopeIt;
+    // simplify using N::x; to using x = N::x;
+    for (Token* tok = list.front(); tok; tok = tok->next()) {
+        if (!Token::Match(tok, "using ::| %name% ::"))
+            continue;
+        const Token* ns = tok->tokAt(tok->strAt(1) == "::" ? 2 : 1);
+        if (ns->isKeyword())
+            continue;
+        Token* end = tok->tokAt(3);
+        while (end && !Token::Match(end, "[;,]")) {
+            if (end->str() == "<") // skip template args
+                end = end->findClosingBracket();
+            else
+                end = end->next();
+        }
+        if (!end)
+            continue;
+        if (!end->tokAt(-1)->isNameOnly() || end->tokAt(-2)->isLiteral()) // e.g. operator=, operator""sv
+            continue;
+        tok->insertToken(end->strAt(-1))->insertToken("=")->isSimplifiedTypedef(true);
+        if (end->str() == ",") { // comma-separated list
+            end->str(";");
+            end->insertToken("using");
+        }
+        tok = end;
     }
 
-    // using namespace..
-    if (nsToken) {
-        while (Token::Match(nsToken, "%name% ::")) {
-            if (scopeIt != scopeInfo.end() && nsToken->str() == scopeIt->name) {
-                nsToken = nsToken->tokAt(2);
-                ++scopeIt;
-            } else {
-                return nullptr;
+    const unsigned int maxReplacementTokens = 1000; // limit the number of tokens we replace
+
+    bool substitute = false;
+    ScopeInfo3 scopeInfo;
+    ScopeInfo3 *currentScope = &scopeInfo;
+    struct Using {
+        Using(Token *start, Token *end) : startTok(start), endTok(end) {}
+        Token *startTok;
+        Token *endTok;
+    };
+    std::list<Using> usingList;
+
+    ProgressReporter progressReporter(mErrorLogger, mSettings.reportProgress, list.getSourceFilePath(), "Tokenize (using)");
+
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        progressReporter.report(tok->progressValue());
+
+        if (Settings::terminated())
+            return substitute;
+
+        if (Token::Match(tok, "enum class|struct")) {
+            Token *bodyStart = tok;
+            while (Token::Match(bodyStart, "%name%|:|::|<")) {
+                if (bodyStart->str() == "<")
+                    bodyStart = bodyStart->findClosingBracket();
+                bodyStart = bodyStart ? bodyStart->next() : nullptr;
             }
+            if (Token::simpleMatch(bodyStart, "{"))
+                tok = bodyStart->link();
+            continue;
         }
-        if (!Token::Match(nsToken, "%name% ;"))
-            return nullptr;
-        if (scopeIt == scopeInfo.end() || nsToken->str() != scopeIt->name)
-            return nullptr;
-        ++scopeIt;
-    }
 
-    // Parse member tokens..
-    while (scopeIt != scopeInfo.end()) {
-        if (!Token::Match(memberToken, "%name% ::|<"))
-            return nullptr;
-        if (memberToken->str() != scopeIt->name)
-            return nullptr;
-        if (memberToken->next()->str() == "<") {
-            memberToken = memberToken->next()->findClosingBracket();
-            if (!Token::simpleMatch(memberToken, "> ::"))
-                return nullptr;
+        if (Token::Match(tok, "{|}|namespace|class|struct|union") ||
+            Token::Match(tok, "using namespace %name% ;|::")) {
+            try {
+                setScopeInfo(tok, currentScope, mSettings.debugwarnings);
+            } catch (const std::runtime_error &) {
+                reportError(tok, Severity::debug, "simplifyUsingUnmatchedBodyEnd",
+                            "simplifyUsing: unmatched body end");
+            }
+            continue;
         }
-        memberToken = memberToken->tokAt(2);
-        ++scopeIt;
-    }
 
-    return Token::Match(memberToken, "~| %name%") ? memberToken : nullptr;
-}
+        // skip template declarations
+        if (Token::Match(tok, "template < !!>")) {
+            // add template record type to scope info
+            const Token *end = tok->next()->findClosingBracket();
+            if (end && Token::Match(end->next(), "class|struct|union %name%"))
+                currentScope->recordTypes.insert(end->strAt(2));
+
+            Token *declEndToken = TemplateSimplifier::findTemplateDeclarationEnd(tok);
+            if (declEndToken)
+                tok = declEndToken;
+            continue;
+        }
 
-static Token * matchMemberName(const Member &member, const std::list<ScopeInfo2> &scopeInfo)
-{
-    if (scopeInfo.empty())
-        return nullptr;
+        // look for non-template type aliases
+        if (!(tok->strAt(-1) != ">" &&
+              (Token::Match(tok, "using %name% = ::| %name%") ||
+               (Token::Match(tok, "using %name% [ [") &&
+                Token::Match(tok->linkAt(2), "] ] = ::| %name%")))))
+            continue;
 
-    // Does this member match without "using namespace"..
-    Token *ret = matchMemberName(member.scope, nullptr, member.tok, scopeInfo);
-    if (ret)
-        return ret;
+        const std::string& name = tok->strAt(1);
+        const Token *nameToken = tok->next();
+        std::string scope = currentScope->fullName;
+        Token *usingStart = tok;
+        Token *start;
+        if (tok->strAt(2) == "=") {
+            if (currentScope->type == ScopeInfo3::Record && tok->tokAt(2)->isSimplifiedTypedef())  // don't simplify within class definition
+                continue;
+            start = tok->tokAt(3);
+        }
+        else
+            start = tok->linkAt(2)->tokAt(3);
+        Token *usingEnd = findSemicolon(start);
+        if (!usingEnd)
+            continue;
 
-    // Try to match member using the "using namespace ..." namespaces..
-    for (const Token *ns : member.usingnamespaces) {
-        ret = matchMemberName(member.scope, ns, member.tok, scopeInfo);
-        if (ret)
-            return ret;
-    }
+        // Move struct defined in using out of using.
+        // using T = struct t { }; => struct t { }; using T = struct t;
+        // fixme: this doesn't handle attributes
+        if (Token::Match(start, "class|struct|union|enum %name%| {|:")) {
+            Token *structEnd = start->tokAt(1);
+            const bool hasName = Token::Match(structEnd, "%name%");
+
+            // skip over name if present
+            if (hasName)
+                structEnd = structEnd->next();
+
+            // skip over base class information
+            if (structEnd->str() == ":") {
+                structEnd = structEnd->next(); // skip over ":"
+                while (structEnd && structEnd->str() != "{")
+                    structEnd = structEnd->next();
+                if (!structEnd)
+                    continue;
+            }
 
-    return nullptr;
-}
+            // use link to go to end
+            structEnd = structEnd->link();
 
-static Token * matchMemberVarName(const Member &var, const std::list<ScopeInfo2> &scopeInfo)
-{
-    Token *tok = matchMemberName(var, scopeInfo);
-    return Token::Match(tok, "%name% !!(") ? tok : nullptr;
-}
+            // add ';' after end of struct
+            structEnd->insertToken(";");
 
-static Token * matchMemberFunctionName(const Member &func, const std::list<ScopeInfo2> &scopeInfo)
-{
-    Token *tok = matchMemberName(func, scopeInfo);
-    return Token::Match(tok, "~| %name% (") ? tok : nullptr;
-}
+            // add name for anonymous struct
+            if (!hasName) {
+                std::string newName;
+                if (structEnd->strAt(2) == ";")
+                    newName = name;
+                else
+                    newName = "Unnamed" + std::to_string(mUnnamedCount++);
+                TokenList::copyTokens(structEnd->next(), tok, start);
+                structEnd->tokAt(5)->insertToken(newName);
+                start->insertToken(newName);
+            } else
+                TokenList::copyTokens(structEnd->next(), tok, start->next());
+
+            // add using after end of struct
+            usingStart = structEnd->tokAt(2);
+            nameToken = usingStart->next();
+            if (usingStart->strAt(2) == "=")
+                start = usingStart->tokAt(3);
+            else
+                start = usingStart->linkAt(2)->tokAt(3);
+            usingEnd = findSemicolon(start);
+
+            // delete original using before struct
+            tok->deleteThis();
+            tok->deleteThis();
+            tok->deleteThis();
+            tok = usingStart;
+        }
+
+        // remove 'typename' and 'template'
+        else if (start->str() == "typename") {
+            start->deleteThis();
+            Token *temp = start;
+            while (Token::Match(temp, "%name% ::"))
+                temp = temp->tokAt(2);
+            if (Token::Match(temp, "template %name%"))
+                temp->deleteThis();
+        }
+
+        if (usingEnd)
+            tok = usingEnd;
+
+        if (Token::Match(start, "class|struct|union|enum"))
+            start = start->next();
+
+        // Unfortunately we have to start searching from the beginning
+        // of the token stream because templates are instantiated at
+        // the end of the token stream and it may be used before then.
+        ScopeInfo3 scopeInfo1;
+        ScopeInfo3 *currentScope1 = &scopeInfo1;
+        Token *startToken = list.front();
+        const Token *endToken = nullptr;
+        bool inMemberFunc = false;
+        const ScopeInfo3 * memberFuncScope = nullptr;
+        const Token * memberFuncEnd = nullptr;
+
+        // We can limit the search to the current function when the type alias
+        // is defined in that function.
+        if (currentScope->type == ScopeInfo3::Other ||
+            currentScope->type == ScopeInfo3::MemberFunction) {
+            scopeInfo1 = scopeInfo;
+            currentScope1 = scopeInfo1.findScope(currentScope);
+            if (!currentScope1)
+                return substitute; // something bad happened
+            startToken = usingEnd->next();
+            endToken = currentScope->bodyEnd->next();
+            if (currentScope->type == ScopeInfo3::MemberFunction) {
+                const ScopeInfo3 * temp = currentScope->findScope(currentScope->fullName);
+                if (temp) {
+                    inMemberFunc = true;
+                    memberFuncScope = temp;
+                    memberFuncEnd = endToken;
+                }
+            }
+        }
+
+        bool isTypedefInfoAdded = false; // TODO should we add a separate mUsingInfo?
+
+        std::string scope1 = currentScope1->fullName;
+        bool skip = false; // don't erase type aliases we can't parse
+        Token *enumOpenBrace = nullptr;
+        for (Token* tok1 = startToken; !skip && tok1 && tok1 != endToken; tok1 = tok1->next()) {
+            // skip enum body
+            if (tok1 && tok1 == enumOpenBrace) {
+                tok1 = tok1->link();
+                enumOpenBrace = nullptr;
+                continue;
+            }
+
+            if ((Token::Match(tok1, "{|}|namespace|class|struct|union") && tok1->strAt(-1) != "using") ||
+                Token::Match(tok1, "using namespace %name% ;|::")) {
+                try {
+                    setScopeInfo(tok1, currentScope1, mSettings.debugwarnings);
+                } catch (const std::runtime_error &) {
+                    reportError(tok1, Severity::debug, "simplifyUsingUnmatchedBodyEnd",
+                                "simplifyUsing: unmatched body end");
+                }
+                scope1 = currentScope1->fullName;
+                if (inMemberFunc && memberFuncEnd && tok1 == memberFuncEnd) {
+                    inMemberFunc = false;
+                    memberFuncScope = nullptr;
+                    memberFuncEnd = nullptr;
+                }
+                continue;
+            }
+
+            // skip template definitions
+            if (Token::Match(tok1, "template < !!>")) {
+                Token *declEndToken = TemplateSimplifier::findTemplateDeclarationEnd(tok1);
+                if (declEndToken)
+                    tok1 = declEndToken;
+                continue;
+            }
 
-void Tokenizer::setVarIdPass2()
-{
-    std::map<int, std::map<std::string, int> > structMembers;
+            // check for enum with body
+            if (tok1->str() == "enum") {
+                if (Token::Match(tok1, "enum class|struct"))
+                    tok1 = tok1->next();
+                Token *defStart = tok1;
+                while (Token::Match(defStart, "%name%|::|:"))
+                    defStart = defStart->next();
+                if (Token::simpleMatch(defStart, "{"))
+                    enumOpenBrace = defStart;
+                continue;
+            }
 
-    // Member functions and variables in this source
-    std::list<Member> allMemberFunctions;
-    std::list<Member> allMemberVars;
-    if (!isC()) {
-        std::map<const Token *, std::string> endOfScope;
-        std::list<std::string> scope;
-        std::list<const Token *> usingnamespaces;
-        for (Token *tok = list.front(); tok; tok = tok->next()) {
-            if (!tok->previous() || Token::Match(tok->previous(), "[;{}]")) {
-                if (Token::Match(tok, "using namespace %name% ::|;")) {
-                    Token *endtok = tok->tokAt(2);
-                    while (Token::Match(endtok, "%name% ::"))
-                        endtok = endtok->tokAt(2);
-                    if (Token::Match(endtok, "%name% ;"))
-                        usingnamespaces.push_back(tok->tokAt(2));
-                    tok = endtok;
-                    continue;
-                } else if (Token::Match(tok, "namespace %name% {")) {
-                    scope.push_back(tok->strAt(1));
-                    endOfScope[tok->linkAt(2)] = tok->strAt(1);
+            // check for member function and adjust scope
+            if (isMemberFunction(tok1)) {
+                if (!scope1.empty())
+                    scope1 += " :: ";
+                scope1 += memberFunctionScope(tok1);
+                const ScopeInfo3 * temp = currentScope1->findScope(scope1);
+                if (temp) {
+                    const Token *end = memberFunctionEnd(tok1);
+                    if (end) {
+                        inMemberFunc = true;
+                        memberFuncScope = temp;
+                        memberFuncEnd = end;
+                    }
                 }
+                continue;
             }
+            if (inMemberFunc && memberFuncScope) {
+                if (!usingMatch(nameToken, scope, tok1, scope1, currentScope1, memberFuncScope))
+                    continue;
+            } else if (!usingMatch(nameToken, scope, tok1, scope1, currentScope1, nullptr))
+                continue;
 
-            if (tok->str() == "}") {
-                const std::map<const Token *, std::string>::iterator it = endOfScope.find(tok);
-                if (it != endOfScope.end())
-                    scope.remove(it->second);
+            if (!isTypedefInfoAdded && Token::Match(tok1, "%name% (")) {
+                isTypedefInfoAdded = true;
+                TypedefInfo usingInfo;
+                usingInfo.name = name;
+                usingInfo.filename = list.file(nameToken);
+                usingInfo.lineNumber = nameToken->linenr();
+                usingInfo.column = nameToken->column();
+                usingInfo.used = true;
+                usingInfo.isFunctionPointer = false;
+                mTypedefInfo.push_back(std::move(usingInfo));
+            }
+
+            const auto nReplace = tokDistance(start, usingEnd);
+            if (nReplace > maxReplacementTokens) {
+                simplifyUsingError(usingStart, usingEnd);
+                continue;
             }
 
-            Token* const tok1 = tok;
-            if (Token::Match(tok->previous(), "!!:: %name% :: ~| %name%"))
-                tok = tok->next();
-            else if (Token::Match(tok->previous(), "!!:: %name% <") && Token::Match(tok->next()->findClosingBracket(),"> :: ~| %name%"))
-                tok = tok->next()->findClosingBracket()->next();
-            else
-                continue;
+            // remove the qualification
+            std::string fullScope = scope;
+            std::string removed;
+            while (Token::Match(tok1->tokAt(-2), "%name% ::") && !tok1->tokAt(-2)->isKeyword()) {
+                removed = (tok1->strAt(-2) + " :: ") + removed;
+                if (fullScope == tok1->strAt(-2)) {
+                    tok1->deletePrevious();
+                    tok1->deletePrevious();
+                    break;
+                }
+                const std::string::size_type idx = fullScope.rfind("::");
 
-            while (Token::Match(tok, ":: ~| %name%")) {
-                tok = tok->next();
-                if (tok->str() == "~")
-                    tok = tok->next();
-                else if (Token::Match(tok, "%name% <") && Token::Match(tok->next()->findClosingBracket(),"> :: ~| %name%"))
-                    tok = tok->next()->findClosingBracket()->next();
-                else if (Token::Match(tok, "%name% ::"))
-                    tok = tok->next();
-                else
+                if (idx == std::string::npos)
+                    break;
+
+                if (tok1->strAt(-2) == fullScope.substr(idx + 3)) {
+                    tok1->deletePrevious();
+                    tok1->deletePrevious();
+                    fullScope.resize(idx - 1);
+                } else
                     break;
             }
-            if (!tok->next())
-                syntaxError(tok);
-            if (Token::Match(tok, "%name% ("))
-                allMemberFunctions.emplace_back(scope, usingnamespaces, tok1);
-            else
-                allMemberVars.emplace_back(scope, usingnamespaces, tok1);
-        }
-    }
 
-    std::list<ScopeInfo2> scopeInfo;
+            // remove global namespace if present
+            if (tok1->strAt(-1) == "::") {
+                removed.insert(0, ":: ");
+                tok1->deletePrevious();
+            }
 
-    // class members..
-    std::map<std::string, std::map<std::string, int> > varsByClass;
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        while (tok->str() == "}" && !scopeInfo.empty() && tok == scopeInfo.back().bodyEnd)
-            scopeInfo.pop_back();
+            Token * arrayStart = nullptr;
+            Token * fpArgList = nullptr;
+            Token * fpQual = nullptr;
 
-        if (!Token::Match(tok, "namespace|class|struct %name% {|:|::"))
-            continue;
+            // parse the type
+            Token *type = start;
+            if (type->str() == "::") {
+                type = type->next();
+                while (Token::Match(type, "%type% ::"))
+                    type = type->tokAt(2);
+                if (Token::Match(type, "%type%"))
+                    type = type->next();
+            } else if (Token::Match(type, "%type% ::")) {
+                do {
+                    type = type->tokAt(2);
+                } while (Token::Match(type, "%type% ::"));
+                if (Token::Match(type, "%type%"))
+                    type = type->next();
+            } else if (Token::Match(type, "%type%")) {
+                while (Token::Match(type, "const|class|struct|union|enum %type%") ||
+                       (type->next() && type->next()->isStandardType()))
+                    type = type->next();
 
-        const std::string &scopeName(getScopeName(scopeInfo));
-        const std::string scopeName2(scopeName.empty() ? std::string() : (scopeName + " :: "));
+                type = type->next();
 
-        std::list<const Token *> classnameTokens;
-        classnameTokens.push_back(tok->next());
-        const Token* tokStart = tok->tokAt(2);
-        while (Token::Match(tokStart, ":: %name%")) {
-            classnameTokens.push_back(tokStart->next());
-            tokStart = tokStart->tokAt(2);
-        }
+                while (Token::Match(type, "%type%") &&
+                       (type->isStandardType() || Token::Match(type, "unsigned|signed"))) {
+                    type = type->next();
+                }
 
-        std::string classname;
-        for (const Token *it : classnameTokens)
-            classname += (classname.empty() ? "" : " :: ") + it->str();
+                bool atEnd = false;
+                while (!atEnd) {
+                    if (type && type->str() == "::") {
+                        type = type->next();
+                    }
 
-        std::map<std::string, int> &thisClassVars = varsByClass[scopeName2 + classname];
-        while (Token::Match(tokStart, ":|::|,|%name%")) {
-            if (Token::Match(tokStart, "%name% <")) {
-                tokStart = tokStart->next()->findClosingBracket();
-                if (tokStart)
-                    tokStart = tokStart->next();
-                continue;
-            }
-            if (Token::Match(tokStart, "%name% ,|{")) {
-                const std::map<std::string, int>& baseClassVars = varsByClass[tokStart->str()];
-                thisClassVars.insert(baseClassVars.begin(), baseClassVars.end());
-            }
-            tokStart = tokStart->next();
-        }
-        if (!Token::simpleMatch(tokStart, "{"))
-            continue;
+                    if (Token::Match(type, "%type%") &&
+                        type->next() && !Token::Match(type->next(), "[|,|(")) {
+                        type = type->next();
+                    } else if (Token::simpleMatch(type, "const (")) {
+                        type = type->next();
+                        atEnd = true;
+                    } else
+                        atEnd = true;
+                }
+            } else
+                syntaxError(type);
 
-        // What member variables are there in this class?
-        for (const Token *it : classnameTokens)
-            scopeInfo.emplace_back(it->str(), tokStart->link());
+            // check for invalid input
+            if (!type)
+                syntaxError(tok1);
 
-        for (Token *tok2 = tokStart->next(); tok2 && tok2 != tokStart->link(); tok2 = tok2->next()) {
-            // skip parentheses..
-            if (tok2->link()) {
-                if (tok2->str() == "{") {
-                    if (tok2->strAt(-1) == ")" || tok2->strAt(-2) == ")")
-                        setVarIdClassFunction(scopeName2 + classname, tok2, tok2->link(), thisClassVars, structMembers, &mVarId);
-                    tok2 = tok2->link();
-                } else if (tok2->str() == "(" && tok2->link()->strAt(1) != "(") {
-                    tok2 = tok2->link();
+            // check for template
+            if (type->str() == "<") {
+                type = type->findClosingBracket();
 
-                    // Skip initialization list
-                    while (Token::Match(tok2, ") [:,] %name% ("))
-                        tok2 = tok2->linkAt(3);
+                while (type && Token::Match(type->next(), ":: %type%"))
+                    type = type->tokAt(2);
+
+                if (!type) {
+                    syntaxError(tok1);
                 }
-            }
 
-            // Found a member variable..
-            else if (tok2->varId() > 0)
-                thisClassVars[tok2->str()] = tok2->varId();
-        }
+                while (Token::Match(type->next(), "const|volatile"))
+                    type = type->next();
 
-        // Are there any member variables in this class?
-        if (thisClassVars.empty())
-            continue;
+                type = type->next();
+            }
 
-        // Member variables
-        for (const Member &var : allMemberVars) {
-            Token *tok2 = matchMemberVarName(var, scopeInfo);
-            if (!tok2)
-                continue;
-            tok2->varId(thisClassVars[tok2->str()]);
-        }
+            // check for pointers and references
+            std::list<std::string> pointers;
+            while (Token::Match(type, "*|&|&&|const")) {
+                pointers.push_back(type->str());
+                type = type->next();
+            }
 
-        if (isC() || tok->str() == "namespace")
-            continue;
+            // check for array
+            if (type && type->str() == "[") {
+                do {
+                    if (!arrayStart)
+                        arrayStart = type;
 
-        // Set variable ids in member functions for this class..
-        for (const Member &func : allMemberFunctions) {
-            Token *tok2 = matchMemberFunctionName(func, scopeInfo);
-            if (!tok2)
-                continue;
+                    bool atEnd = false;
+                    while (!atEnd) {
+                        while (type->next() && !Token::Match(type->next(), ";|,")) {
+                            type = type->next();
+                        }
 
-            if (tok2->str() == "~")
-                tok2 = tok2->linkAt(2);
-            else
-                tok2 = tok2->linkAt(1);
+                        if (!type->next())
+                            syntaxError(type); // invalid input
+                        else if (type->strAt(1) == ";")
+                            atEnd = true;
+                        else if (type->str() == "]")
+                            atEnd = true;
+                        else
+                            type = type->next();
+                    }
 
-            // If this is a function implementation.. add it to funclist
-            Token * start = const_cast<Token *>(isFunctionHead(tok2, "{"));
-            if (start) {
-                setVarIdClassFunction(classname, start, start->link(), thisClassVars, structMembers, &mVarId);
+                    type = type->next();
+                } while (type && type->str() == "[");
             }
 
-            if (Token::Match(tok2, ") %name% ("))
-                tok2 = tok2->linkAt(2);
+            // check for function pointer
+            if (type && type->str() == "(") {
+                if (Token::simpleMatch(type->link(), ") (")) {
+                    fpArgList = type->link()->next();
+                    fpQual = type;
+                    type = type->link()->linkAt(1)->next();
+                } else if (type->link()->next() == usingEnd) {
+                    fpArgList = type;
+                    type = usingEnd;
+                }
+            }
 
-            // constructor with initializer list
-            if (!Token::Match(tok2, ") : ::| %name%"))
-                continue;
+            // make sure we are in a good state
+            if (!tok1 || !tok1->next())
+                break; // bail
 
-            Token *tok3 = tok2;
-            while (Token::Match(tok3, "[)}] [,:]")) {
-                tok3 = tok3->tokAt(2);
-                if (Token::Match(tok3, ":: %name%"))
-                    tok3 = tok3->next();
-                while (Token::Match(tok3, "%name% :: %name%"))
-                    tok3 = tok3->tokAt(2);
-                if (!Token::Match(tok3, "%name% (|{|<"))
-                    break;
+            Token* after = tok1->next();
+            // check if type was parsed
+            if (type && type == usingEnd) {
+                // check for array syntax and add type around variable
+                if (arrayStart) {
+                    if (Token::Match(tok1->next(), "%name%")) {
+                        TokenList::copyTokens(tok1->next(), arrayStart, usingEnd->previous());
+                        TokenList::copyTokens(tok1, start, arrayStart->previous());
+                        tok1->deleteThis();
+                        substitute = true;
+                    }
+                } else if (fpArgList && fpQual && Token::Match(tok1->next(), "%name%")) {
+                    // function pointer
+                    const bool isFuncDecl = Token::simpleMatch(tok1->tokAt(2), "(");
+                    TokenList::copyTokens(tok1->next(), fpArgList, usingEnd->previous());
+                    Token* const copyEnd = TokenList::copyTokens(tok1, start, fpQual->link()->previous());
+                    Token* leftPar = copyEnd->previous();
+                    while (leftPar->str() != "(")
+                        leftPar = leftPar->previous();
+                    Token* const insertTok = isFuncDecl ? copyEnd->linkAt(2) : copyEnd->next();
+                    Token* const rightPar = insertTok->insertToken(")");
+                    Token::createMutualLinks(leftPar, rightPar);
+                    tok1->deleteThis();
+                    substitute = true;
+                } else if (fpArgList && !fpQual && Token::Match(tok1->next(), "* const| %name%")) {
+                    // function pointer
+                    Token* const dest = tok1->tokAt(tok1->strAt(2) == "const" ? 3 : 2);
+                    Token* const copyEndArgs = TokenList::copyTokens(dest, fpArgList, usingEnd->previous());
+                    Token* const copyEndRet = TokenList::copyTokens(tok1, start, fpArgList->previous());
+                    Token* const leftPar = copyEndRet->insertToken("(");
+                    Token* const rightPar = copyEndArgs->link()->tokAt(-1)->insertToken(")");
+                    Token::createMutualLinks(leftPar, rightPar);
+                    tok1->deleteThis();
+                    substitute = true;
+                } else {
+                    // add some qualification back if needed
+                    std::string removed1 = std::move(removed);
+                    std::string::size_type idx = removed1.rfind(" ::");
+                    if (idx != std::string::npos)
+                        removed1.resize(idx);
+                    if (scopesMatch(removed1, scope, &scopeInfo1)) {
+                        ScopeInfo3 * tempScope = currentScope;
+                        while (tempScope->parent) {
+                            if (tempScope->recordTypes.find(start->str()) != tempScope->recordTypes.end()) {
+                                std::string::size_type spaceIdx = 0;
+                                std::string::size_type startIdx = 0;
+                                while ((spaceIdx = removed1.find(' ', startIdx)) != std::string::npos) {
+                                    tok1->previous()->insertToken(removed1.substr(startIdx, spaceIdx - startIdx));
+                                    startIdx = spaceIdx + 1;
+                                }
+                                tok1->previous()->insertToken(removed1.substr(startIdx));
+                                tok1->previous()->insertToken("::");
+                                break;
+                            }
+                            idx = removed1.rfind(" ::");
+                            if (idx == std::string::npos)
+                                break;
+
+                            removed1.resize(idx);
+                            tempScope = tempScope->parent;
+                        }
+                    }
+
+                    // Is this a "T(...)" expression where T is a pointer type?
+                    if (Token::Match(tok1, "%name% [({]") && !pointers.empty() && !Token::simpleMatch(skipConstVolatileBackwards(tok1->tokAt(-1)), ".")) {
+                        tok1->tokAt(1)->str("(");
+                        tok1->linkAt(1)->str(")");
+                        if (tok1->linkAt(1) == tok1->tokAt(2)) { // T() or T{}
+                            Token* tok2 = tok1->linkAt(1);
+                            tok1->deleteThis();
+                            TokenList::copyTokens(tok1, start, usingEnd->previous());
+                            tok2->insertToken("0");
+                            after = tok2->next();
+                        }
+                        else { // functional-style cast
+                            Token* tok2 = tok1->linkAt(1);
+                            tok1->originalName(tok1->str());
+                            tok1->isSimplifiedTypedef(true);
+                            tok1->str("(");
+                            Token* tok3 = TokenList::copyTokens(tok1, start, usingEnd->previous());
+                            tok3->insertToken(")");
+                            Token::createMutualLinks(tok1, tok3->next());
+                            after = tok2->next();
+                        }
+                    }
+                    else { // just replace simple type aliases
+                        TokenList::copyTokens(tok1, start, usingEnd->previous());
+                        tok1->deleteThis();
+                    }
+                    substitute = true;
+                }
+            } else {
+                skip = true;
+                simplifyUsingError(usingStart, usingEnd);
+            }
+            tok1 = after->previous();
+        }
 
-                // set varid
-                const std::map<std::string, int>::const_iterator varpos = thisClassVars.find(tok3->str());
-                if (varpos != thisClassVars.end())
-                    tok3->varId(varpos->second);
+        if (!skip)
+            usingList.emplace_back(usingStart, usingEnd);
+    }
 
-                // goto end of var
-                if (tok3->strAt(1) == "<") {
-                    tok3 = tok3->next()->findClosingBracket();
-                    if (tok3 && tok3->next() && tok3->next()->link())
-                        tok3 = tok3->next()->link();
-                } else
-                    tok3 = tok3->linkAt(1);
-            }
-            if (Token::Match(tok3, ")|} {")) {
-                setVarIdClassFunction(classname, tok2, tok3->next()->link(), thisClassVars, structMembers, &mVarId);
+    // delete all used type alias definitions
+    for (auto it = usingList.rbegin(); it != usingList.rend(); ++it) {
+        Token *usingStart = it->startTok;
+        Token *usingEnd = it->endTok;
+        if (usingStart->previous()) {
+            Token::eraseTokens(usingStart->previous(), usingEnd->next());
+        } else {
+            if (usingEnd->next()) {
+                Token::eraseTokens(usingStart, usingEnd->next());
+                usingStart->deleteThis();
+            } else {
+                // this is the only code being checked so leave ';'
+                Token::eraseTokens(usingStart, usingEnd);
+                usingStart->deleteThis();
             }
         }
     }
+
+    return substitute;
 }
 
-static void linkBrackets(const Tokenizer * const tokenizer, std::stack<const Token*>& type, std::stack<Token*>& links, Token * const token, const char open, const char close)
+void Tokenizer::simplifyUsingError(const Token* usingStart, const Token* usingEnd)
 {
-    if (token->str()[0] == open) {
-        links.push(token);
-        type.push(token);
-    } else if (token->str()[0] == close) {
-        if (links.empty()) {
-            // Error, { and } don't match.
-            tokenizer->unmatchedToken(token);
+    if (mSettings.debugwarnings) {
+        std::string str;
+        for (const Token *tok = usingStart; tok && tok != usingEnd; tok = tok->next()) {
+            if (!str.empty())
+                str += ' ';
+            str += tok->str();
         }
-        if (type.top()->str()[0] != open) {
-            tokenizer->unmatchedToken(type.top());
-        }
-        type.pop();
-
-        Token::createMutualLinks(links.top(), token);
-        links.pop();
+        str += " ;";
+        std::list<const Token *> callstack(1, usingStart);
+        mErrorLogger.reportErr(ErrorMessage(callstack, &list, Severity::debug, "simplifyUsing",
+                                            "Failed to parse \'" + str + "\'. The checking continues anyway.", Certainty::normal));
     }
 }
 
-void Tokenizer::createLinks()
+bool Tokenizer::simplifyTokens1(const std::string &configuration, int fileIndex)
 {
-    std::stack<const Token*> type;
-    std::stack<Token*> links1;
-    std::stack<Token*> links2;
-    std::stack<Token*> links3;
-    for (Token *token = list.front(); token; token = token->next()) {
-        if (token->link()) {
-            token->link(nullptr);
-        }
+    // Fill the map mTypeSize..
+    fillTypeSizes();
+
+    mConfiguration = configuration;
+
+    if (mTimerResults) {
+        Timer t("Tokenizer::simplifyTokens1::simplifyTokenList1", mSettings.showtime, mTimerResults);
+        if (!simplifyTokenList1(list.getFiles().front().c_str()))
+            return false;
+    } else {
+        if (!simplifyTokenList1(list.getFiles().front().c_str()))
+            return false;
+    }
+
+    const ShowTime showTime = mTimerResults ? mSettings.showtime : ShowTime::NONE;
+
+    Timer::run("Tokenizer::simplifyTokens1::createAst", showTime, mTimerResults, [&]() {
+        list.createAst();
+        list.validateAst(mSettings.debugnormal);
+    });
 
-        linkBrackets(this, type, links1, token, '{', '}');
+    Timer::run("Tokenizer::simplifyTokens1::createSymbolDatabase", showTime, mTimerResults, [&]() {
+        createSymbolDatabase();
+    });
+
+    Timer::run("Tokenizer::simplifyTokens1::setValueType", showTime, mTimerResults, [&]() {
+        mSymbolDatabase->setValueTypeInTokenList(false);
+        mSymbolDatabase->setValueTypeInTokenList(true);
+    });
+
+    if (!mSettings.buildDir.empty())
+        Summaries::create(*this, configuration, fileIndex);
 
-        linkBrackets(this, type, links2, token, '(', ')');
+    // TODO: apply this through Settings::ValueFlowOptions
+    // TODO: do not run valueflow if no checks are being performed at all - e.g. unusedFunctions only
+    // TODO: log message when this is active?
+    const char* disableValueflowEnv = std::getenv("DISABLE_VALUEFLOW");
+    const bool doValueFlow = !disableValueflowEnv || (std::strcmp(disableValueflowEnv, "1") != 0);
 
-        linkBrackets(this, type, links3, token, '[', ']');
+    if (doValueFlow) {
+        Timer::run("Tokenizer::simplifyTokens1::ValueFlow", showTime, mTimerResults, [&]() {
+            ValueFlow::setValues(list, *mSymbolDatabase, mErrorLogger, mSettings, mTimerResults);
+        });
+
+        arraySizeAfterValueFlow();
     }
 
-    if (!links1.empty()) {
-        // Error, { and } don't match.
-        unmatchedToken(links1.top());
+    // Warn about unhandled character literals
+    if (mSettings.severity.isEnabled(Severity::portability)) {
+        for (const Token *tok = tokens(); tok; tok = tok->next()) {
+            if (tok->tokType() == Token::eChar && tok->values().empty()) {
+                try {
+                    simplecpp::characterLiteralToLL(tok->str());
+                } catch (const std::runtime_error &e) {
+                    unhandledCharLiteral(tok, e.what());
+                }
+            }
+        }
     }
 
-    if (!links2.empty()) {
-        // Error, ( and ) don't match.
-        unmatchedToken(links2.top());
+    if (doValueFlow) {
+        mSymbolDatabase->setArrayDimensionsUsingValueFlow();
     }
 
-    if (!links3.empty()) {
-        // Error, [ and ] don't match.
-        unmatchedToken(links3.top());
+    printDebugOutput(std::cout);
+
+    return true;
+}
+
+//---------------------------------------------------------------------------
+
+void Tokenizer::findComplicatedSyntaxErrorsInTemplates()
+{
+    validate();
+    mTemplateSimplifier->checkComplicatedSyntaxErrorsInTemplates();
+}
+
+void Tokenizer::checkForEnumsWithTypedef()
+{
+    for (const Token *tok = list.front(); tok; tok = tok->next()) {
+        if (Token::Match(tok, "enum %name% {")) {
+            tok = tok->tokAt(2);
+            const Token *tok2 = Token::findsimplematch(tok, "typedef", tok->link());
+            if (tok2)
+                syntaxError(tok2);
+            tok = tok->link();
+        }
     }
 }
 
-void Tokenizer::createLinks2()
+void Tokenizer::fillTypeSizes()
 {
-    if (isC())
-        return;
+    mTypeSize.clear();
+    mTypeSize["char"] = 1;
+    mTypeSize["_Bool"] = mSettings.platform.sizeof_bool;
+    mTypeSize["bool"] = mSettings.platform.sizeof_bool;
+    mTypeSize["short"] = mSettings.platform.sizeof_short;
+    mTypeSize["int"] = mSettings.platform.sizeof_int;
+    mTypeSize["long"] = mSettings.platform.sizeof_long;
+    mTypeSize["long long"] = mSettings.platform.sizeof_long_long;
+    mTypeSize["float"] = mSettings.platform.sizeof_float;
+    mTypeSize["double"] = mSettings.platform.sizeof_double;
+    mTypeSize["long double"] = mSettings.platform.sizeof_long_double;
+    mTypeSize["wchar_t"] = mSettings.platform.sizeof_wchar_t;
+    mTypeSize["size_t"] = mSettings.platform.sizeof_size_t;
+    mTypeSize["*"] = mSettings.platform.sizeof_pointer;
+}
 
-    const Token * templateToken = nullptr;
-    bool isStruct = false;
+void Tokenizer::combineOperators()
+{
+    const bool cpp = isCPP();
 
-    std::stack<Token*> type;
-    for (Token *token = list.front(); token; token = token->next()) {
-        if (Token::Match(token, "%name%|> %name% [:<]"))
-            isStruct = true;
-        else if (Token::Match(token, "[;{}]"))
-            isStruct = false;
+    // Combine tokens..
+    for (Token *tok = list.front(); tok && tok->next(); tok = tok->next()) {
+        const char c1 = tok->str()[0];
 
-        if (token->link()) {
-            if (Token::Match(token, "{|[|("))
-                type.push(token);
-            else if (!type.empty() && Token::Match(token, "}|]|)")) {
-                while (type.top()->str() == "<") {
-                    if (templateToken && templateToken->next() == type.top())
-                        templateToken = nullptr;
-                    type.pop();
+        if (tok->str().length() == 1 && tok->strAt(1).length() == 1) {
+            const char c2 = tok->strAt(1)[0];
+
+            // combine +-*/ and =
+            if (c2 == '=' && (std::strchr("+-*/%|^=!<>", c1)) && !Token::Match(tok->previous(), "%type% *")) {
+                // skip templates
+                if (cpp && (tok->str() == ">" || Token::simpleMatch(tok->previous(), "> *"))) {
+                    const Token* opening =
+                        tok->str() == ">" ? tok->findOpeningBracket() : tok->previous()->findOpeningBracket();
+                    if (opening && Token::Match(opening->previous(), "%name%"))
+                        continue;
                 }
-                type.pop();
-            } else
-                token->link(nullptr);
-        } else if (!templateToken && !isStruct && Token::Match(token, "%oror%|&&|;")) {
-            if (Token::Match(token, "&& [,>]"))
+                tok->str(tok->str() + c2);
+                tok->deleteNext();
                 continue;
-            // If there is some such code:  A<B||C>..
-            // Then this is probably a template instantiation if either "B" or "C" has comparisons
-            if (token->tokType() == Token::eLogicalOp && !type.empty() && type.top()->str() == "<") {
-                const Token *prev = token->previous();
-                bool foundComparison = false;
-                while (Token::Match(prev, "%name%|%num%|%str%|%cop%|)|]") && prev != type.top()) {
-                    if (prev->str() == ")" || prev->str() == "]")
-                        prev = prev->link();
-                    else if (prev->tokType() == Token::eLogicalOp)
-                        break;
-                    else if (prev->isComparisonOp())
-                        foundComparison = true;
-                    prev = prev->previous();
-                }
-                if (prev == type.top() && foundComparison)
-                    continue;
-                const Token *next = token->next();
-                foundComparison = false;
-                while (Token::Match(next, "%name%|%num%|%str%|%cop%|(|[") && next->str() != ">") {
-                    if (next->str() == "(" || next->str() == "[")
-                        next = next->link();
-                    else if (next->tokType() == Token::eLogicalOp)
+            }
+        } else if (tok->strAt(1) == "=") {
+            if (tok->str() == ">>") {
+                tok->str(">>=");
+                tok->deleteNext();
+            } else if (tok->str() == "<<") {
+                tok->str("<<=");
+                tok->deleteNext();
+            }
+        } else if (cpp && (c1 == 'p' || c1 == '_') &&
+                   Token::Match(tok, "private|protected|public|__published : !!:")) {
+            bool simplify = false;
+            int par = 0;
+            for (const Token *prev = tok->previous(); prev; prev = prev->previous()) {
+                if (prev->str() == ")") {
+                    ++par;
+                } else if (prev->str() == "(") {
+                    if (par == 0U)
                         break;
-                    else if (next->isComparisonOp())
-                        foundComparison = true;
-                    next = next->next();
+                    --par;
                 }
-                if (next && next->str() == ">" && foundComparison)
+                if (par != 0U || prev->str() == "(")
                     continue;
-            }
-
-            while (!type.empty() && type.top()->str() == "<") {
-                const Token* end = type.top()->findClosingBracket();
-                if (Token::Match(end, "> %comp%|;|.|=|{"))
-                    break;
-                // Variable declaration
-                if (Token::Match(end, "> %var% ;") && (type.top()->tokAt(-2) == nullptr || Token::Match(type.top()->tokAt(-2), ";|}|{")))
+                if (Token::Match(prev, "[;{}]")) {
+                    simplify = true;
                     break;
-                type.pop();
-            }
-        } else if (token->str() == "<" &&
-                   ((token->previous() && token->previous()->isName() && !token->previous()->varId()) ||
-                    Token::Match(token->next(), ">|>>"))) {
-            type.push(token);
-            if (!templateToken && (token->previous()->str() == "template"))
-                templateToken = token;
-        } else if (token->str() == ">" || token->str() == ">>") {
-            if (type.empty() || type.top()->str() != "<") // < and > don't match.
-                continue;
-            Token * const top1 = type.top();
-            type.pop();
-            Token * const top2 = type.empty() ? nullptr : type.top();
-            type.push(top1);
-            if (!top2 || top2->str() != "<") {
-                if (token->str() == ">>")
-                    continue;
-                if (token->next() &&
-                    !Token::Match(token->next(), "%name%|%comp%|&|&&|*|::|,|(|)|{|}|;|[|:|.|=") &&
-                    !Token::simpleMatch(token->next(), "...") &&
-                    !Token::Match(token->next(), "&& %name% ="))
+                }
+                if (prev->isName() && prev->isUpperCaseName())
                     continue;
+                if (prev->isName() && endsWith(prev->str(), ':'))
+                    simplify = true;
+                break;
             }
-            // if > is followed by [ .. "new a<b>[" is expected
-            // unless this is from varidiac expansion
-            if (token->strAt(1) == "[" && !Token::simpleMatch(token->tokAt(-1), "... >")) {
-                Token *prev = type.top()->previous();
-                while (prev && Token::Match(prev->previous(), ":: %name%"))
-                    prev = prev->tokAt(-2);
-                if (prev && prev->str() != "new")
-                    prev = prev->previous();
-                if (!prev || prev->str() != "new")
-                    continue;
+            if (simplify) {
+                tok->str(tok->str() + ":");
+                tok->tokType(Token::Type::eKeyword); // we need to preserve the keyword type after setting a non-keyword string
+                tok->deleteNext();
             }
-
-            if (token->str() == ">>") {
-                type.pop();
-                type.pop();
-                Token::createMutualLinks(top2, token);
-                if (top1 == templateToken || top2 == templateToken)
-                    templateToken = nullptr;
+        } else if (tok->str() == "->") {
+            // If the preceding sequence is "( & %name% )", replace it by "%name%"
+            Token* t = tok->tokAt(-4);
+            if (Token::Match(t, "( & %name% )") && !Token::simpleMatch(t->previous(), ">")) {
+                t->deleteThis();
+                t->deleteThis();
+                t->deleteNext();
+                tok->str(".");
             } else {
-                type.pop();
-                if (Token::Match(token, "> %name%") && Token::Match(top1->tokAt(-2), "%op% %name% <"))
-                    continue;
-                Token::createMutualLinks(top1, token);
-                if (top1 == templateToken)
-                    templateToken = nullptr;
-            }
-        }
-    }
-}
-
-void Tokenizer::sizeofAddParentheses()
-{
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (!Token::Match(tok, "sizeof !!("))
-            continue;
-        if (tok->next()->isLiteral() || Token::Match(tok->next(), "%name%|*|~|!|&")) {
-            Token *endToken = tok->next();
-            while (Token::simpleMatch(endToken, "* *"))
-                endToken = endToken->next();
-            while (Token::Match(endToken->next(), "%name%|%num%|%str%|[|(|.|::|++|--|!|~") || (Token::Match(endToken, "%type% * %op%|?|:|const|;|,"))) {
-                if (Token::Match(endToken->next(), "(|["))
-                    endToken = endToken->linkAt(1);
-                else
-                    endToken = endToken->next();
-            }
-
-            // Add ( after sizeof and ) behind endToken
-            tok->insertToken("(");
-            endToken->insertToken(")");
-            Token::createMutualLinks(tok->next(), endToken->next());
+                tok->str(".");
+                tok->originalName("->");
+            }
         }
     }
 }
 
-bool Tokenizer::simplifySizeof()
+void Tokenizer::combineStringAndCharLiterals()
 {
-    // Locate variable declarations and calculate the size
-    std::map<int, int> sizeOfVar;
-    std::map<int, const Token *> declTokOfVar;
-    for (const Token *tok = list.front(); tok; tok = tok->next()) {
-        if (tok->varId() != 0 && sizeOfVar.find(tok->varId()) == sizeOfVar.end()) {
-            const int varId = tok->varId();
-            if (Token::Match(tok->tokAt(-3), "[;{}(,] %type% * %name% [;,)]") ||
-                Token::Match(tok->tokAt(-4), "[;{}(,] const %type% * %name% [;),]") ||
-                Token::Match(tok->tokAt(-2), "[;{}(,] %type% %name% [;),]") ||
-                Token::Match(tok->tokAt(-3), "[;{}(,] const %type% %name% [;),]")) {
-                const int size = sizeOfType(tok->previous());
-                if (size == 0) {
-                    continue;
-                }
-
-                sizeOfVar[varId] = size;
-                declTokOfVar[varId] = tok;
-            }
-
-            else if (Token::Match(tok->previous(), "%type% %name% [ %num% ] [[;=]") ||
-                     Token::Match(tok->tokAt(-2), "%type% * %name% [ %num% ] [[;=]")) {
-                int size = sizeOfType(tok->previous());
-                if (size == 0)
-                    continue;
+    // Combine strings
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (!isStringLiteral(tok->str()))
+            continue;
 
-                const Token* tok2 = tok->next();
-                do {
-                    const MathLib::bigint num = MathLib::toLongNumber(tok2->strAt(1));
-                    if (num<0)
-                        break;
-                    size *= num;
-                    tok2 = tok2->tokAt(3);
-                } while (Token::Match(tok2, "[ %num% ]"));
-                if (Token::Match(tok2, "[;=]")) {
-                    sizeOfVar[varId] = size;
-                    declTokOfVar[varId] = tok;
-                }
-                if (!tok2) {
-                    syntaxError(tok);
-                }
-                tok = tok2;
-            }
+        tok->str(simplifyString(tok->str()));
 
-            else if (Token::Match(tok->previous(), "%type% %name% [ %num% ] [,)]") ||
-                     Token::Match(tok->tokAt(-2), "%type% * %name% [ %num% ] [,)]")) {
-                Token tempTok;
-                tempTok.str("*");
-                sizeOfVar[varId] = sizeOfType(&tempTok);
-                declTokOfVar[varId] = tok;
+        while (Token::Match(tok->next(), "%str%") || Token::Match(tok->next(), "_T|_TEXT|TEXT ( %str% )")) {
+            if (tok->next()->isName()) {
+                if (!mSettings.platform.isWindows())
+                    break;
+                tok->deleteNext(2);
+                tok->next()->deleteNext();
             }
+            // Two strings after each other, combine them
+            tok->concatStr(simplifyString(tok->strAt(1)));
+            tok->deleteNext();
         }
     }
+}
 
-    bool ret = false;
+void Tokenizer::concatenateNegativeNumberAndAnyPositive()
+{
     for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (tok->str() != "sizeof")
+        if (!Token::Match(tok, "?|:|,|(|[|{|return|case|sizeof|%op% +|-") || tok->tokType() == Token::eIncDecOp)
             continue;
 
-        if (Token::simpleMatch(tok->next(), "...")) {
-            //tok->deleteNext(3);
-            tok->deleteNext();
-        }
-
-        // sizeof('x')
-        if (Token::Match(tok->next(), "( %char% )")) {
-            tok->deleteNext();
-            tok->deleteThis();
-            tok->deleteNext();
-            std::ostringstream sz;
-            sz << ((isC()) ? mSettings->sizeof_int : 1);
-            tok->str(sz.str());
-            ret = true;
+        if (tok->findOpeningBracket())
             continue;
-        }
 
-        // sizeof ("text")
-        if (Token::Match(tok->next(), "( %str% )")) {
+        while (tok->str() != ">" && tok->next() && tok->strAt(1) == "+" && (!Token::Match(tok->tokAt(2), "%name% (|;") || Token::Match(tok, "%op%")))
             tok->deleteNext();
-            tok->deleteThis();
-            tok->deleteNext();
-            std::ostringstream ostr;
-            ostr << (Token::getStrLength(tok) + 1);
-            tok->str(ostr.str());
-            ret = true;
-            continue;
-        }
 
-        // sizeof(type *) => sizeof(*)
-        if (Token::Match(tok->next(), "( %type% * )")) {
-            tok->next()->deleteNext();
+        if (Token::Match(tok->next(), "+|- %num%")) {
+            std::string prefix = tok->strAt(1);
+            tok->deleteNext();
+            tok->next()->str(prefix + tok->strAt(1));
         }
+    }
+}
 
-        if (Token::simpleMatch(tok->next(), "( * )")) {
-            tok->str(MathLib::toString(sizeOfType(tok->tokAt(2))));
-            tok->deleteNext(3);
-            ret = true;
-        }
+void Tokenizer::simplifyExternC()
+{
+    if (isC())
+        return;
 
-        // sizeof( a )
-        else if (Token::Match(tok->next(), "( %var% )")) {
-            const std::map<int, int>::const_iterator sizeOfVarPos = sizeOfVar.find(tok->tokAt(2)->varId());
-            if (sizeOfVarPos != sizeOfVar.end()) {
-                tok->deleteNext();
-                tok->deleteThis();
-                tok->deleteNext();
-                tok->str(MathLib::toString(sizeOfVarPos->second));
-                ret = true;
+    // Add attributes to all tokens within `extern "C"` inlines and blocks, and remove the `extern "C"` tokens.
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (Token::Match(tok, "extern \"C\"|\"C++\"")) {
+            Token *tok2 = tok->next();
+            const bool isExtC = tok->strAt(1).size() == 3;
+            if (tok->strAt(2) == "{") {
+                tok2 = tok2->next(); // skip {
+                while ((tok2 = tok2->next()) && tok2 != tok->linkAt(2))
+                    tok2->isExternC(isExtC);
+                tok->linkAt(2)->deleteThis(); // }
+                tok->deleteNext(2); // "C" {
             } else {
-                // don't try to replace size of variable if variable has
-                // similar name with type (#329)
+                while ((tok2 = tok2->next()) && !Token::Match(tok2, "[;{]"))
+                    tok2->isExternC(isExtC);
+                tok->deleteNext(); // "C"
             }
+            tok->deleteThis(); // extern
         }
+    }
+}
 
-        else if (Token::Match(tok->next(), "( %type% )")) {
-            const int size = sizeOfType(tok->tokAt(2));
-            if (size > 0) {
-                tok->str(MathLib::toString(size));
-                tok->deleteNext(3);
-                ret = true;
-            }
+void Tokenizer::simplifyCompoundStatements()
+{
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        while (Token::Match(tok, "[;{}:] ( {") &&
+               Token::simpleMatch(tok->linkAt(2), "} ) ;")) {
+            if (tok->str() == ":" && !Token::Match(tok->tokAt(-2),"[;{}] %type% :"))
+                break;
+            Token *end = tok->linkAt(2)->tokAt(-3);
+            if (Token::Match(end, "[;{}] %num%|%str% ;"))
+                end->deleteNext(2);
+            tok->linkAt(2)->previous()->deleteNext(3);
+            tok->deleteNext(2);
+        }
+        if (Token::Match(tok, "( { %bool%|%char%|%num%|%str%|%name% ; } )")) {
+            tok->deleteNext();
+            tok->deleteThis();
+            tok->deleteNext(3);
         }
+        else if (tok->str() == "(")
+            tok = tok->link();
+    }
+}
 
-        else if (Token::simpleMatch(tok->next(), "( *") || Token::Match(tok->next(), "( %name% [")) {
-            int derefs = 0;
+void Tokenizer::simplifySQL()
+{
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (!Token::simpleMatch(tok, "__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL"))
+            continue;
 
-            const Token* nametok = tok->tokAt(2);
-            if (nametok->str() == "*") {
-                do {
-                    nametok = nametok->next();
-                    derefs++;
-                } while (nametok && nametok->str() == "*");
+        const Token *end = findSQLBlockEnd(tok);
+        if (end == nullptr)
+            syntaxError(nullptr);
 
-                if (!Token::Match(nametok, "%name% )"))
-                    continue;
-            } else {
-                const Token* tok2 = nametok->next();
-                do {
-                    tok2 = tok2->link()->next();
-                    derefs++;
-                } while (tok2 && tok2->str() == "[");
+        const std::string instruction = tok->stringifyList(end);
+        // delete all tokens until the embedded SQL block end
+        Token::eraseTokens(tok, end);
 
-                if (!tok2 || tok2->str() != ")")
-                    continue;
-            }
+        // insert "asm ( "instruction" ) ;"
+        tok->str("asm");
+        // it can happen that 'end' is NULL when wrong code is inserted
+        if (!tok->next())
+            tok->insertToken(";");
+        tok->insertToken(")");
+        tok->insertToken("\"" + instruction + "\"");
+        tok->insertToken("(");
+        // jump to ';' and continue
+        tok = tok->tokAt(3);
+    }
+}
 
-            // Some default value
-            MathLib::biguint size = 0;
-
-            const int varid = nametok->varId();
-            if (derefs != 0 && varid != 0 && declTokOfVar.find(varid) != declTokOfVar.end()) {
-                // Try to locate variable declaration..
-                const Token *decltok = declTokOfVar[varid];
-                if (Token::Match(decltok->previous(), "%type%|* %name% [")) {
-                    size = sizeOfType(decltok->previous());
-                } else if (Token::Match(decltok->tokAt(-2), "%type% * %name%")) {
-                    size = sizeOfType(decltok->tokAt(-2));
-                }
-                // Multi-dimensional array..
-                if (Token::Match(decltok, "%name% [") && Token::simpleMatch(decltok->linkAt(1), "] [")) {
-                    const Token *tok2 = decltok;
-                    for (int i = 0; i < derefs; i++)
-                        tok2 = tok2->linkAt(1); // Skip all dimensions that are dereferenced before the sizeof call
-                    while (Token::Match(tok2, "] [ %num% ]")) {
-                        size *= MathLib::toULongNumber(tok2->strAt(2));
-                        tok2 = tok2->linkAt(1);
-                    }
-                    if (Token::simpleMatch(tok2, "] ["))
-                        continue;
-                }
-            } else if (nametok->strAt(1) == "[" && nametok->isStandardType()) {
-                size = sizeOfType(nametok);
-                if (size == 0)
-                    continue;
-                const Token *tok2 = nametok->next();
-                while (Token::Match(tok2, "[ %num% ]")) {
-                    size *= MathLib::toULongNumber(tok2->strAt(1));
-                    tok2 = tok2->link()->next();
-                }
-                if (!tok2 || tok2->str() != ")")
-                    continue;
-            }
+void Tokenizer::simplifyParenthesizedLibraryFunctions()
+{
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (!Token::simpleMatch(tok, ") ("))
+            continue;
+        Token *rpar = tok, *lpar = tok->link();
+        if (!lpar || (Token::Match(lpar->previous(), "%name%") && !Token::Match(lpar->previous(), "return|delete|throw")))
+            continue;
+        const Token *ftok = rpar->previous();
+        if (mSettings.library.isNotLibraryFunction(ftok))
+            continue;
+        lpar->deleteThis();
+        rpar->deleteThis();
+    }
+}
 
-            if (size > 0) {
-                tok->str(MathLib::toString(size));
-                Token::eraseTokens(tok, tok->next()->link()->next());
-                ret = true;
-            }
+void Tokenizer::simplifyArrayAccessSyntax()
+{
+    // 0[a] -> a[0]
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (tok->isNumber() && Token::Match(tok, "%num% [ %name% ]")) {
+            const std::string number(tok->str());
+            Token* indexTok = tok->tokAt(2);
+            tok->str(indexTok->str());
+            tok->varId(indexTok->varId());
+            indexTok->str(number);
         }
     }
-    return ret;
 }
 
-bool Tokenizer::simplifyTokenList1(const char FileName[])
+void Tokenizer::simplifyParameterVoid()
 {
-    if (Settings::terminated())
-        return false;
+    for (Token* tok = list.front(); tok; tok = tok->next()) {
+        if (Token::Match(tok, "%name% ( void )") && !Token::Match(tok, "sizeof|decltype|typeof|return")) {
+            tok->next()->deleteNext();
+            tok->next()->setRemovedVoidParameter(true);
+        }
+    }
+}
 
-    // if MACRO
+void Tokenizer::simplifyRedundantConsecutiveBraces()
+{
+    // Remove redundant consecutive braces, i.e. '.. { { .. } } ..' -> '.. { .. } ..'.
+    for (Token *tok = list.front(); tok;) {
+        if (Token::simpleMatch(tok, "= {")) {
+            tok = tok->linkAt(1);
+        } else if (Token::simpleMatch(tok, "{ {") && Token::simpleMatch(tok->linkAt(1), "} }")) {
+            //remove internal parentheses
+            tok->linkAt(1)->deleteThis();
+            tok->deleteNext();
+        } else
+            tok = tok->next();
+    }
+}
+
+void Tokenizer::simplifyDoublePlusAndDoubleMinus()
+{
+    // Convert - - into + and + - into -
     for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "if|for|while|BOOST_FOREACH %name% (")) {
-            if (Token::simpleMatch(tok, "for each")) {
-                // 'for each ( )' -> 'asm ( )'
-                tok->str("asm");
-                tok->deleteNext();
-            } else if (tok->strAt(1) == "constexpr") {
-                tok->deleteNext();
-                tok->isConstexpr(true);
-            } else {
-                syntaxError(tok);
+        while (tok->next()) {
+            if (tok->str() == "+") {
+                if (tok->strAt(1)[0] == '-') {
+                    tok = tok->next();
+                    if (tok->str().size() == 1) {
+                        tok = tok->previous();
+                        tok->str("-");
+                        tok->deleteNext();
+                    } else if (tok->isNumber()) {
+                        tok->str(tok->str().substr(1));
+                        tok = tok->previous();
+                        tok->str("-");
+                    }
+                    continue;
+                }
+            } else if (tok->str() == "-") {
+                if (tok->strAt(1)[0] == '-') {
+                    tok = tok->next();
+                    if (tok->str().size() == 1) {
+                        tok = tok->previous();
+                        tok->str("+");
+                        tok->deleteNext();
+                    } else if (tok->isNumber()) {
+                        tok->str(tok->str().substr(1));
+                        tok = tok->previous();
+                        tok->str("+");
+                    }
+                    continue;
+                }
             }
+
+            break;
         }
     }
+}
 
-    // Is there C++ code in C file?
-    validateC();
-
-    // remove MACRO in variable declaration: MACRO int x;
-    removeMacroInVarDecl();
-
-    // Combine strings and character literals, e.g. L"string", L'c', "string1" "string2"
-    combineStringAndCharLiterals();
+/** Specify array size if it hasn't been given */
 
-    // replace inline SQL with "asm()" (Oracle PRO*C). Ticket: #1959
-    simplifySQL();
+void Tokenizer::arraySize()
+{
+    auto getStrTok = [](Token* tok, bool addLength, Token*& endStmt) -> Token* {
+        if (addLength) {
+            endStmt = tok->tokAt(5);
+            return tok->tokAt(4);
+        }
+        if (Token::Match(tok, "%var% [ ] =")) {
+            tok = tok->tokAt(4);
+            int parCount = 0;
+            while (Token::simpleMatch(tok, "(")) {
+                ++parCount;
+                tok = tok->next();
+            }
+            if (Token::Match(tok, "%str%")) {
+                endStmt = tok->tokAt(parCount + 1);
+                return tok;
+            }
+        }
+        return nullptr;
+    };
 
-    createLinks();
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (!tok->isName() || !Token::Match(tok, "%var% [ ] ="))
+            continue;
+        bool addlength = false;
+        if (Token::Match(tok->previous(), "!!* %var% [ ] = { %str% } ;")) {
+            Token *t = tok->tokAt(3);
+            t->deleteNext();
+            t->next()->deleteNext();
+            addlength = true;
+        }
 
-    simplifyHeaders();
+        Token* endStmt{};
+        if (const Token* strTok = getStrTok(tok, addlength, endStmt)) {
+            const int sz = Token::getStrArraySize(strTok);
+            tok->next()->insertToken(std::to_string(sz));
+            tok = endStmt;
+        }
 
-    // Remove __asm..
-    simplifyAsm();
+        else if (Token::Match(tok, "%var% [ ] = {")) {
+            MathLib::biguint sz = 1;
+            tok = tok->next();
+            Token *end = tok->linkAt(3);
+            for (Token *tok2 = tok->tokAt(4); tok2 && tok2 != end; tok2 = tok2->next()) {
+                if (tok2->link() && Token::Match(tok2, "{|(|[|<")) {
+                    if (tok2->str() == "[" && tok2->link()->strAt(1) == "=") { // designated initializer
+                        if (Token::Match(tok2, "[ %num% ]"))
+                            sz = std::max(sz, MathLib::toBigUNumber(tok2->tokAt(1)) + 1U);
+                        else {
+                            sz = 0;
+                            break;
+                        }
+                    }
+                    tok2 = tok2->link();
+                } else if (tok2->str() == ",") {
+                    if (!Token::Match(tok2->next(), "[},]"))
+                        ++sz;
+                    else {
+                        tok2 = tok2->previous();
+                        tok2->deleteNext();
+                    }
+                }
+            }
 
-    // foo < bar < >> => foo < bar < > >
-    if (isCPP())
-        mTemplateSimplifier->fixAngleBrackets();
+            if (sz != 0)
+                tok->insertToken(MathLib::toString(sz));
 
-    // Bail out if code is garbage
-    if (mTimerResults) {
-        Timer t("Tokenizer::tokenize::findGarbageCode", mSettings->showtime, mTimerResults);
-        findGarbageCode();
-    } else {
-        findGarbageCode();
+            tok = end->next() ? end->next() : end;
+        }
     }
+}
 
-    checkConfiguration();
+// cppcheck-suppress functionConst
+void Tokenizer::arraySizeAfterValueFlow()
+{
+    // After ValueFlow, adjust array sizes.
+    for (const Variable* var: mSymbolDatabase->variableList()) {
+        if (!var || !var->isArray())
+            continue;
+        if (!Token::Match(var->nameToken(), "%name% [ ] = { ["))
+            continue;
+        MathLib::bigint maxIndex = -1;
+        const Token* const startToken = var->nameToken()->tokAt(4);
+        const Token* const endToken = startToken->link();
+        for (const Token* tok = startToken; tok != endToken; tok = tok->next()) {
+            if (!Token::Match(tok, "[{,] [") || !Token::simpleMatch(tok->linkAt(1), "] ="))
+                continue;
+            const Token* expr = tok->next()->astOperand1();
+            if (expr && expr->hasKnownIntValue())
+                maxIndex = std::max(maxIndex, expr->getKnownIntValue());
+        }
+        if (maxIndex >= 0) {
+            // insert array size
+            auto* tok = const_cast<Token*>(var->nameToken()->next());
+            tok->insertToken(MathLib::toString(maxIndex + 1));
+            // ast
+            tok->astOperand2(tok->next());
+            // Token::scope
+            tok->next()->scope(tok->scope());
+            // Value flow
+            ValueFlow::Value value(maxIndex + 1);
+            value.setKnown();
+            tok->next()->addValue(value);
+            // Set array dimensions
+            Dimension d;
+            d.num = maxIndex + 1;
+            std::vector<Dimension> dimensions{d};
+            const_cast<Variable*>(var)->setDimensions(dimensions);
+        }
+    }
+}
 
-    // if (x) MACRO() ..
-    for (const Token *tok = list.front(); tok; tok = tok->next()) {
-        if (Token::simpleMatch(tok, "if (")) {
-            tok = tok->next()->link();
-            if (Token::Match(tok, ") %name% (") &&
-                tok->next()->isUpperCaseName() &&
-                Token::Match(tok->linkAt(2), ") {|else")) {
-                syntaxError(tok->next());
+static Token *skipTernaryOp(Token *tok)
+{
+    int colonLevel = 1;
+    while (nullptr != (tok = tok->next())) {
+        if (tok->str() == "?") {
+            ++colonLevel;
+        } else if (tok->str() == ":") {
+            --colonLevel;
+            if (colonLevel == 0) {
+                tok = tok->next();
+                break;
             }
         }
+        if (tok->link() && Token::Match(tok, "[(<]"))
+            tok = tok->link();
+        else if (Token::Match(tok->next(), "[{};)]"))
+            break;
     }
+    if (colonLevel > 0) // Ticket #5214: Make sure the ':' matches the proper '?'
+        return nullptr;
+    return tok;
+}
 
-    if (Settings::terminated())
-        return false;
-
-    // convert C++17 style nested namespaces to old style namespaces
-    simplifyNestedNamespace();
-
-    // simplify namespace aliases
-    simplifyNamespaceAliases();
-
-    // Remove [[attribute]]
-    simplifyCPPAttribute();
-
-    // remove __attribute__((?))
-    simplifyAttribute();
-
-    // simplify cppcheck attributes __cppcheck_?__(?)
-    simplifyCppcheckAttribute();
+// Skips until the colon at the end of the case label, the argument must point to the "case" token.
+// In case of success returns the colon token.
+// In case of failure returns the token that caused the error.
+static Token *skipCaseLabel(Token *tok)
+{
+    assert(tok->str() == "case");
+    while (nullptr != (tok = tok->next())) {
+        if (Token::Match(tok, "(|["))
+            tok = tok->link();
+        else if (tok->str() == "?") {
+            Token * tok1 = skipTernaryOp(tok);
+            if (!tok1)
+                return tok;
+            tok = tok1;
+        }
+        if (Token::Match(tok, "[:{};]"))
+            return tok;
+    }
+    return nullptr;
+}
 
-    // Combine tokens..
-    combineOperators();
+const Token * Tokenizer::startOfExecutableScope(const Token * tok)
+{
+    if (tok->str() != ")")
+        return nullptr;
 
-    // Simplify the C alternative tokens (and, or, etc.)
-    simplifyCAlternativeTokens();
+    tok = TokenList::isFunctionHead(tok, ":{");
 
-    // replace 'sin(0)' to '0' and other similar math expressions
-    simplifyMathExpressions();
+    if (Token::Match(tok, ": %name% [({]")) {
+        while (Token::Match(tok, "[:,] %name% [({]"))
+            tok = tok->linkAt(2)->next();
+    }
 
-    // combine "- %num%"
-    concatenateNegativeNumberAndAnyPositive();
+    return (tok && tok->str() == "{") ? tok : nullptr;
+}
 
-    // remove extern "C" and extern "C" {}
-    if (isCPP())
-        simplifyExternC();
 
-    // simplify weird but legal code: "[;{}] ( { code; } ) ;"->"[;{}] code;"
-    simplifyRoundCurlyParentheses();
+/** simplify labels and case|default in the code: add a ";" if not already in.*/
 
-    // check for simple syntax errors..
-    for (const Token *tok = list.front(); tok; tok = tok->next()) {
-        if (Token::simpleMatch(tok, "> struct {") &&
-            Token::simpleMatch(tok->linkAt(2), "} ;")) {
-            syntaxError(tok);
+void Tokenizer::simplifyLabelsCaseDefault()
+{
+    const bool cpp = isCPP();
+    bool executablescope = false;
+    int indentLevel = 0;
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        // Simplify labels in the executable scope..
+        auto *start = const_cast<Token *>(startOfExecutableScope(tok));
+        if (start) {
+            tok = start;
+            executablescope = true;
         }
-    }
 
-    if (!simplifyAddBraces())
-        return false;
+        if (!executablescope)
+            continue;
 
-    sizeofAddParentheses();
+        if (tok->str() == "{") {
+            if (tok->strAt(-1) == "=")
+                tok = tok->link();
+            else
+                ++indentLevel;
+        } else if (tok->str() == "}") {
+            --indentLevel;
+            if (indentLevel == 0) {
+                executablescope = false;
+                continue;
+            }
+        } else if (Token::Match(tok, "(|["))
+            tok = tok->link();
 
-    // Simplify: 0[foo] -> *(foo)
-    for (Token* tok = list.front(); tok; tok = tok->next()) {
-        if (Token::simpleMatch(tok, "0 [") && tok->linkAt(1)) {
-            tok->str("*");
-            tok->next()->str("(");
-            tok->linkAt(1)->str(")");
+        if (Token::Match(tok, "[;{}:] case")) {
+            tok = skipCaseLabel(tok->next());
+            if (!tok)
+                break;
+            if (tok->str() != ":" || tok->strAt(-1) == "case" || !tok->next())
+                syntaxError(tok);
+            if (tok->strAt(1) != ";" && tok->strAt(1) != "case")
+                tok->insertToken(";");
+            else
+                tok = tok->previous();
+        } else if (Token::Match(tok, "[;{}] %name% : !!;")) {
+            if (!cpp || !Token::Match(tok->next(), "class|struct|enum")) {
+                tok = tok->tokAt(2);
+                tok->insertToken(";");
+            }
         }
     }
+}
 
-    if (Settings::terminated())
-        return false;
-
-    // Remove __declspec()
-    simplifyDeclspec();
-    validate();
-
-    // Remove "inline", "register", and "restrict"
-    simplifyKeyword();
 
-    // simplify simple calculations inside <..>
-    if (isCPP()) {
-        Token *lt = nullptr;
-        for (Token *tok = list.front(); tok; tok = tok->next()) {
-            if (Token::Match(tok, "[;{}]"))
-                lt = nullptr;
-            else if (Token::Match(tok, "%type% <"))
-                lt = tok->next();
-            else if (lt && Token::Match(tok, ">|>> %name%|::|(")) {
-                const Token * const end = tok;
-                for (tok = lt; tok != end; tok = tok->next()) {
-                    if (tok->isNumber())
-                        TemplateSimplifier::simplifyNumericCalculations(tok);
+void Tokenizer::simplifyCaseRange()
+{
+    for (Token* tok = list.front(); tok; tok = tok->next()) {
+        if (Token::Match(tok, "case %num%|%char% ... %num%|%char% :")) {
+            const MathLib::bigint start = MathLib::toBigNumber(tok->tokAt(1));
+            MathLib::bigint end = MathLib::toBigNumber(tok->tokAt(3));
+            end = std::min(start + 50, end); // Simplify it 50 times at maximum
+            if (start < end) {
+                tok = tok->tokAt(2);
+                tok->str(":");
+                tok->insertToken("case");
+                for (MathLib::bigint i = end-1; i > start; i--) {
+                    tok->insertToken(":");
+                    tok->insertToken(MathLib::toString(i));
+                    tok->insertToken("case");
                 }
-                lt = tok->next();
             }
         }
     }
+}
 
-    // Convert K&R function declarations to modern C
-    simplifyVarDecl(true);
-    simplifyFunctionParameters();
-
-    // simplify case ranges (gcc extension)
-    simplifyCaseRange();
-
-    // simplify labels and 'case|default'-like syntaxes
-    simplifyLabelsCaseDefault();
-
-    // simplify '[;{}] * & ( %any% ) =' to '%any% ='
-    simplifyMulAndParens();
-
-    if (!isC() && !mSettings->library.markupFile(FileName)) {
-        findComplicatedSyntaxErrorsInTemplates();
-    }
-
-    if (Settings::terminated())
-        return false;
-
-    // remove calling conventions __cdecl, __stdcall..
-    simplifyCallingConvention();
-
-
-    // remove some unhandled macros in global scope
-    removeMacrosInGlobalScope();
+void Tokenizer::calculateScopes()
+{
+    for (auto *tok = list.front(); tok; tok = tok->next())
+        tok->scopeInfo(nullptr);
 
-    // remove undefined macro in class definition:
-    // class DLLEXPORT Fred { };
-    // class Fred FINAL : Base { };
-    removeMacroInClassDef();
+    std::string nextScopeNameAddition;
+    std::shared_ptr<ScopeInfo2> primaryScope = std::make_shared<ScopeInfo2>("", nullptr);
+    list.front()->scopeInfo(std::move(primaryScope));
 
-    // That call here fixes #7190
-    validate();
+    for (Token* tok = list.front(); tok; tok = tok->next()) {
+        if (tok == list.front() || !tok->scopeInfo()) {
+            if (tok != list.front())
+                tok->scopeInfo(tok->previous()->scopeInfo());
 
-    // remove unnecessary member qualification..
-    removeUnnecessaryQualification();
+            if (Token::Match(tok, "using namespace %name% ::|<|;")) {
+                std::string usingNamespaceName;
+                for (const Token* namespaceNameToken = tok->tokAt(2);
+                     namespaceNameToken && namespaceNameToken->str() != ";";
+                     namespaceNameToken = namespaceNameToken->next()) {
+                    usingNamespaceName += namespaceNameToken->str();
+                    usingNamespaceName += " ";
+                }
+                if (!usingNamespaceName.empty())
+                    usingNamespaceName.pop_back();
+                tok->scopeInfo()->usingNamespaces.insert(std::move(usingNamespaceName));
+            } else if (Token::Match(tok, "namespace|class|struct|union %name% {|::|:|<")) {
+                for (Token* nameTok = tok->next(); nameTok && !Token::Match(nameTok, "{|:"); nameTok = nameTok->next()) {
+                    if (Token::Match(nameTok, ";|<")) {
+                        nextScopeNameAddition = "";
+                        break;
+                    }
+                    nextScopeNameAddition.append(nameTok->str());
+                    nextScopeNameAddition.append(" ");
+                }
+                if (!nextScopeNameAddition.empty())
+                    nextScopeNameAddition.pop_back();
+            }
 
-    // convert Microsoft memory functions
-    simplifyMicrosoftMemoryFunctions();
+            if (Token::simpleMatch(tok, "{")) {
+                // This might be the opening of a member function
+                Token *tok1 = tok;
+                while (Token::Match(tok1->previous(), "const|volatile|final|override|&|&&|noexcept"))
+                    tok1 = tok1->previous();
+                if (tok1->previous() && tok1->strAt(-1) == ")") {
+                    bool member = true;
+                    tok1 = tok1->linkAt(-1);
+                    if (Token::Match(tok1->previous(), "throw|noexcept")) {
+                        tok1 = tok1->previous();
+                        while (Token::Match(tok1->previous(), "const|volatile|final|override|&|&&|noexcept"))
+                            tok1 = tok1->previous();
+                        if (tok1->strAt(-1) != ")")
+                            member = false;
+                    } else if (Token::Match(tok->tokAt(-2), ":|, %name%")) {
+                        tok1 = tok1->tokAt(-2);
+                        if (tok1->strAt(-1) != ")")
+                            member = false;
+                    }
+                    if (member) {
+                        if (tok1->strAt(-1) == ">")
+                            tok1 = tok1->previous()->findOpeningBracket();
+                        if (tok1 && Token::Match(tok1->tokAt(-3), "%name% :: %name%")) {
+                            tok1 = tok1->tokAt(-2);
+                            std::string scope = tok1->strAt(-1);
+                            while (Token::Match(tok1->tokAt(-2), ":: %name%")) {
+                                scope = tok1->strAt(-3) + " :: " + scope;
+                                tok1 = tok1->tokAt(-2);
+                            }
 
-    // convert Microsoft string functions
-    simplifyMicrosoftStringFunctions();
+                            if (!nextScopeNameAddition.empty() && !scope.empty())
+                                nextScopeNameAddition += " :: ";
+                            nextScopeNameAddition += scope;
+                        }
+                    }
+                }
 
-    if (Settings::terminated())
-        return false;
+                // New scope is opening, record it here
+                std::shared_ptr<ScopeInfo2> newScopeInfo = std::make_shared<ScopeInfo2>(tok->scopeInfo()->name, tok->link(), tok->scopeInfo()->usingNamespaces);
 
-    // Remove Qt signals and slots
-    simplifyQtSignalsSlots();
+                if (!newScopeInfo->name.empty() && !nextScopeNameAddition.empty())
+                    newScopeInfo->name.append(" :: ");
+                newScopeInfo->name.append(nextScopeNameAddition);
+                nextScopeNameAddition = "";
 
-    // remove Borland stuff..
-    simplifyBorland();
+                if (tok->link())
+                    tok->link()->scopeInfo(tok->scopeInfo());
+                tok->scopeInfo(std::move(newScopeInfo));
+            }
+        }
+    }
+}
 
-    // syntax error: enum with typedef in it
-    checkForEnumsWithTypedef();
+void Tokenizer::simplifyTemplates()
+{
+    if (isC())
+        return;
 
-    // Add parentheses to ternary operator where necessary
-    prepareTernaryOpForAST();
+    const std::time_t maxTime = mSettings.templateMaxTime > 0 ? std::time(nullptr) + mSettings.templateMaxTime : 0;
+    mTemplateSimplifier->simplifyTemplates(
+        maxTime);
+}
+//---------------------------------------------------------------------------
 
-    // Change initialisation of variable to assignment
-    simplifyInitVar();
 
-    // Split up variable declarations.
-    simplifyVarDecl(false);
+namespace {
+    /** Class used in Tokenizer::setVarIdPass1 */
+    class VariableMap {
+    private:
+        std::unordered_map<std::string, nonneg int> mVariableId;
+        std::unordered_map<std::string, nonneg int> mVariableId_global;
+        std::stack<std::vector<std::pair<std::string, nonneg int>>> mScopeInfo;
+        mutable nonneg int mVarId{};
+    public:
+        VariableMap() = default;
+        void enterScope();
+        bool leaveScope();
+        void addVariable(const std::string& varname, bool globalNamespace);
+        bool hasVariable(const std::string& varname) const {
+            return mVariableId.find(varname) != mVariableId.end();
+        }
+
+        const std::unordered_map<std::string, nonneg int>& map(bool global) const {
+            return global ? mVariableId_global : mVariableId;
+        }
+        nonneg int& getVarId() {
+            return mVarId;
+        }
+    };
+}
 
-    // typedef..
-    if (mTimerResults) {
-        Timer t("Tokenizer::tokenize::simplifyTypedef", mSettings->showtime, mTimerResults);
-        simplifyTypedef();
-    } else {
-        simplifyTypedef();
-    }
 
-    // using A = B;
-    while (simplifyUsing())
-        ;
+void VariableMap::enterScope()
+{
+    mScopeInfo.emplace(/*std::vector<std::pair<std::string, nonneg int>>()*/);
+}
 
-    // Add parentheses to ternary operator where necessary
-    // TODO: this is only necessary if one typedef simplification had a comma and was used within ?:
-    // If typedef handling is refactored and moved to symboldatabase someday we can remove this
-    prepareTernaryOpForAST();
+bool VariableMap::leaveScope()
+{
+    if (mScopeInfo.empty())
+        return false;
 
-    for (Token* tok = list.front(); tok;) {
-        if (Token::Match(tok, "union|struct|class union|struct|class"))
-            tok->deleteNext();
+    for (const std::pair<std::string, nonneg int>& outerVariable : mScopeInfo.top()) {
+        if (outerVariable.second != 0)
+            mVariableId[outerVariable.first] = outerVariable.second;
         else
-            tok = tok->next();
+            mVariableId.erase(outerVariable.first);
     }
+    mScopeInfo.pop();
+    return true;
+}
 
-    // class x y {
-    if (isCPP() && mSettings->isEnabled(Settings::INFORMATION)) {
-        for (const Token *tok = list.front(); tok; tok = tok->next()) {
-            if (Token::Match(tok, "class %type% %type% [:{]")) {
-                unhandled_macro_class_x_y(tok);
-            }
-        }
+void VariableMap::addVariable(const std::string& varname, bool globalNamespace)
+{
+    if (mScopeInfo.empty()) {
+        mVariableId[varname] = ++mVarId;
+        if (globalNamespace)
+            mVariableId_global[varname] = mVariableId[varname];
+        return;
     }
+    const auto it = mVariableId.find(varname);
+    if (it == mVariableId.end()) {
+        mScopeInfo.top().emplace_back(varname, 0);
+        mVariableId[varname] = ++mVarId;
+        if (globalNamespace)
+            mVariableId_global[varname] = mVariableId[varname];
+        return;
+    }
+    mScopeInfo.top().emplace_back(varname, it->second);
+    it->second = ++mVarId;
+}
 
-    // catch bad typedef canonicalization
-    //
-    // to reproduce bad typedef, download upx-ucl from:
-    // http://packages.debian.org/sid/upx-ucl
-    // analyse the file src/stub/src/i386-linux.elf.interp-main.c
-    validate();
-
-    // The simplify enum have inner loops
-    if (Settings::terminated())
+/**
+ * @throws Token* thrown when closing brackets are missing
+ */
+static bool setVarIdParseDeclaration(Token*& tok, const VariableMap& variableMap, bool executableScope, Standards::cstd_t cStandard)
+{
+    const Token* const tok1 = tok;
+    Token* tok2 = tok;
+    if (!tok2->isName() || (tok2->tokType() != Token::eType && tok2->tokType() != Token::eName && tok2->tokType() != Token::eKeyword))
         return false;
 
-    // Put ^{} statements in asm()
-    simplifyAsm2();
+    nonneg int typeCount = 0;
+    nonneg int singleNameCount = 0;
+    bool hasstruct = false;   // Is there a "struct" or "class"?
+    bool bracket = false;
+    bool ref = false;
+    while (tok2) {
+        if (tok2->isName()) {
+            if (Token::simpleMatch(tok2, "alignas (")) {
+                tok2 = tok2->linkAt(1)->next();
+                continue;
+            }
+            if (tok2->isCpp() && Token::Match(tok2, "namespace|public|private|protected"))
+                return false;
+            bool isC23 = tok2->isC() && cStandard >= Standards::C23;
+            if (((tok2->isCpp() || isC23) && Token::Match(tok2, "decltype|typeof (")) ||
+                (tok2->isC() && Token::simpleMatch(tok2, "__typeof ("))) {
+                typeCount = 1;
+                tok2 = tok2->linkAt(1)->next();
+                continue;
+            }
+            if (Token::Match(tok2, "struct|union|enum") || (tok2->isCpp() && Token::Match(tok2, "class|typename"))) {
+                hasstruct = true;
+                typeCount = 0;
+                singleNameCount = 0;
+            } else if (Token::Match(tok2, "const|extern")) {
+                // just skip "const", "extern"
+            } else if (!hasstruct && variableMap.map(false).count(tok2->str()) && tok2->strAt(-1) != "::") {
+                ++typeCount;
+                tok2 = tok2->next();
+                if (!tok2 || tok2->str() != "::")
+                    break;
+            } else {
+                if (tok2->str() != "void" || Token::Match(tok2, "void const| *|(")) // just "void" cannot be a variable type
+                    ++typeCount;
+                ++singleNameCount;
+            }
+        } else if (tok2->isCpp() && ((TemplateSimplifier::templateParameters(tok2) > 0) ||
+                                     Token::simpleMatch(tok2, "< >") /* Ticket #4764 */)) {
+            const Token *start = tok;
+            if (Token::Match(start->previous(), "%or%|%oror%|&&|&|^|+|-|*|/"))
+                return false;
+            Token* const closingBracket = tok2->findClosingBracket();
+            if (closingBracket == nullptr) { /* Ticket #8151 */
+                throw tok2;
+            }
+            tok2 = closingBracket;
+            if (tok2->str() != ">")
+                break;
+            singleNameCount = 1;
+            if (Token::Match(tok2, "> %name% %or%|%oror%|&&|&|^|+|-|*|/") && !Token::Match(tok2, "> const [*&]"))
+                return false;
+            if (Token::Match(tok2, "> %name% )")) {
+                if (Token::Match(tok2->linkAt(2)->previous(), "if|for|while ("))
+                    return false;
+                if (!Token::Match(tok2->linkAt(2)->previous(), "%name%|] ("))
+                    return false;
+            }
+        } else if (Token::Match(tok2, "&|&&")) {
+            ref = !bracket;
+        } else if (singleNameCount >= 1 && Token::Match(tok2, "( [*&]") && Token::Match(tok2->link(), ") (|[")) {
+            for (const Token* tok3 = tok2->tokAt(2); Token::Match(tok3, "!!)"); tok3 = tok3->next()) {
+                if (Token::Match(tok3, "(|["))
+                    tok3 = tok3->link();
+                if (tok3->str() == ",")
+                    return false;
+            }
+            bracket = true; // Skip: Seems to be valid pointer to array or function pointer
+        } else if (singleNameCount >= 1 && Token::Match(tok2, "( * %name% [") && Token::Match(tok2->linkAt(3), "] ) [;,]") && !variableMap.map(false).count(tok2->strAt(2))) {
+            bracket = true;
+        } else if (singleNameCount >= 1 && tok2->previous() && tok2->previous()->isStandardType() && Token::Match(tok2, "( *|&| %name% ) ;")) {
+            bracket = true;
+        } else if (tok2->str() == "::") {
+            singleNameCount = 0;
+        } else if (tok2->str() != "*" && tok2->str() != "...") {
+            break;
+        }
+        tok2 = tok2->next();
+    }
 
-    // @..
-    simplifyAt();
+    if (tok2) {
+        bool isLambdaArg = false;
+        {
+            const Token *tok3 = tok->previous();
+            if (tok3 && tok3->str() == ",") {
+                while (tok3 && !Token::Match(tok3,";|(|[|{")) {
+                    if (Token::Match(tok3, ")|]"))
+                        tok3 = tok3->link();
+                    tok3 = tok3->previous();
+                }
 
-    // When the assembly code has been cleaned up, no @ is allowed
-    for (const Token *tok = list.front(); tok; tok = tok->next()) {
-        if (tok->str() == "(") {
-            const Token *tok1 = tok;
-            tok = tok->link();
-            if (!tok)
-                syntaxError(tok1);
-        } else if (tok->str() == "@") {
-            syntaxError(tok);
+                if (tok3 && executableScope && Token::Match(tok3->previous(), "%name% (")) {
+                    const Token *fdecl = tok3->previous();
+                    int count = 0;
+                    while (Token::Match(fdecl, "%name%|*")) {
+                        fdecl = fdecl->previous();
+                        count++;
+                    }
+                    if (!Token::Match(fdecl, "[;{}] %name%") || count <= 1)
+                        return false;
+                }
+            }
+
+            if (tok3 && tok3->isCpp() && Token::simpleMatch(tok3->previous(), "] (") &&
+                (Token::simpleMatch(tok3->link(), ") {") || Token::Match(tok3->link(), ") . %name%")))
+                isLambdaArg = true;
         }
-    }
 
-    // Order keywords "static" and "const"
-    simplifyStaticConst();
 
-    // convert platform dependent types to standard types
-    // 32 bits: size_t -> unsigned long
-    // 64 bits: size_t -> unsigned long long
-    list.simplifyPlatformTypes();
+        tok = tok2;
 
-    // collapse compound standard types into a single token
-    // unsigned long long int => long (with _isUnsigned=true,_isLong=true)
-    list.simplifyStdType();
+        // In executable scopes, references must be assigned
+        // Catching by reference is an exception
+        if (executableScope && ref && !isLambdaArg) {
+            if (Token::Match(tok2, "(|=|{|:"))
+                ;   // reference is assigned => ok
+            else if (tok2->str() != ")" || tok2->link()->strAt(-1) != "catch")
+                return false;   // not catching by reference => not declaration
+        }
+    }
 
-    if (Settings::terminated())
-        return false;
+    // Check if array declaration is valid (#2638)
+    // invalid declaration: AAA a[4] = 0;
+    if (typeCount >= 2 && executableScope && Token::Match(tok2, ")| [")) {
+        const Token *tok3 = tok2->str() == ")" ? tok2->next() : tok2;
+        while (tok3 && tok3->str() == "[") {
+            tok3 = tok3->link()->next();
+        }
+        if (Token::Match(tok3, "= %num%"))
+            return false;
+        if (bracket && Token::Match(tok1->previous(), "[(,]") && Token::Match(tok3, ",|)|%cop%"))
+            return false;
+    }
 
-    // simplify bit fields..
-    simplifyBitfields();
+    return (typeCount >= 2 && tok2 && Token::Match(tok2->tokAt(-2), "!!:: %type%"));
+}
 
-    if (Settings::terminated())
-        return false;
 
-    // struct simplification "struct S {} s; => struct S { } ; S s ;
-    simplifyStructDecl();
+static void setVarIdStructMembers(Token *&tok1,
+                                  std::map<nonneg int, std::map<std::string, nonneg int>>& structMembers,
+                                  nonneg int &varId)
+{
+    Token *tok = tok1;
 
-    if (Settings::terminated())
-        return false;
+    if (Token::Match(tok, "%name% = { . %name% =|{")) {
+        const nonneg int struct_varid = tok->varId();
+        if (struct_varid == 0)
+            return;
 
-    // x = ({ 123; });  =>   { x = 123; }
-    simplifyAssignmentBlock();
+        std::map<std::string, nonneg int>& members = structMembers[struct_varid];
 
-    if (Settings::terminated())
-        return false;
+        tok = tok->tokAt(3);
+        while (tok->str() != "}") {
+            if (Token::Match(tok, "{|[|("))
+                tok = tok->link();
+            if (Token::Match(tok->previous(), "[,{] . %name% =|{")) {
+                tok = tok->next();
+                const auto it = utils::as_const(members).find(tok->str());
+                if (it == members.cend()) {
+                    members[tok->str()] = ++varId;
+                    tok->varId(varId);
+                } else {
+                    tok->varId(it->second);
+                }
+            }
+            tok = tok->next();
+        }
 
-    simplifyVariableMultipleAssign();
+        return;
+    }
 
-    // Collapse operator name tokens into single token
-    // operator = => operator=
-    simplifyOperatorName();
+    while (Token::Match(tok->next(), ")| . %name% !!(")) {
+        // Don't set varid for trailing return type
+        if (tok->strAt(1) == ")" && Token::Match(tok->linkAt(1)->tokAt(-1), "%name%|]") && !tok->linkAt(1)->tokAt(-1)->isKeyword() &&
+            TokenList::isFunctionHead(tok->linkAt(1), "{;")) {
+            tok = tok->tokAt(3);
+            continue;
+        }
+        const nonneg int struct_varid = tok->varId();
+        tok = tok->tokAt(2);
+        if (struct_varid == 0)
+            continue;
 
-    // Remove redundant parentheses
-    simplifyRedundantParentheses();
+        if (tok->str() == ".")
+            tok = tok->next();
 
-    if (isCPP())
-        simplifyTypeIntrinsics();
+        // Don't set varid for template function
+        if (TemplateSimplifier::templateParameters(tok->next()) > 0)
+            break;
 
-    if (!isC()) {
-        // Handle templates..
-        if (mTimerResults) {
-            Timer t("Tokenizer::tokenize::simplifyTemplates", mSettings->showtime, mTimerResults);
-            simplifyTemplates();
+        std::map<std::string, nonneg int>& members = structMembers[struct_varid];
+        const auto it = utils::as_const(members).find(tok->str());
+        if (it == members.cend()) {
+            members[tok->str()] = ++varId;
+            tok->varId(varId);
         } else {
-            simplifyTemplates();
+            tok->varId(it->second);
         }
-
-        // The simplifyTemplates have inner loops
-        if (Settings::terminated())
-            return false;
-
-        // sometimes the "simplifyTemplates" fail and then unsimplified
-        // function calls etc remain. These have the "wrong" syntax. So
-        // this function will just fix so that the syntax is corrected.
-        validate(); // #6847 - invalid code
-        mTemplateSimplifier->cleanupAfterSimplify();
     }
+    // tok can't be null
+    tok1 = tok;
+}
 
-    // Simplify pointer to standard types (C only)
-    simplifyPointerToStandardType();
-
-    // simplify function pointers
-    simplifyFunctionPointers();
+static void addTemplateVarIdUsage(const std::string &tokstr,
+                                  const std::map<std::string, std::set<std::string>>& templateVarUsage,
+                                  const std::unordered_map<std::string, nonneg int>& variableMap,
+                                  std::set<nonneg int>& templateVarIdUsage) {
+    const auto v = templateVarUsage.find(tokstr);
+    if (v != templateVarUsage.end()) {
+        for (const std::string& varname: v->second) {
+            const auto it = variableMap.find(varname);
+            if (it != variableMap.end())
+                templateVarIdUsage.insert(it->second);
+        }
+    }
+}
 
-    // Change initialisation of variable to assignment
-    simplifyInitVar();
+static bool setVarIdClassDeclaration(Token* const startToken,
+                                     VariableMap& variableMap,
+                                     const nonneg int scopeStartVarId,
+                                     const std::map<std::string, std::set<std::string>>& templateVarUsage,
+                                     std::map<nonneg int, std::map<std::string, nonneg int>>& structMembers,
+                                     std::set<nonneg int>& templateVarIdUsage)
+{
+    // end of scope
+    const Token* const endToken = startToken->link();
 
-    // Split up variable declarations.
-    simplifyVarDecl(false);
+    // determine class name
+    std::string className;
+    for (const Token *tok = startToken->previous(); tok; tok = tok->previous()) {
+        if (!tok->isName() && tok->str() != ":")
+            break;
+        if (Token::Match(tok, "class|struct|enum %type% [:{]")) {
+            className = tok->strAt(1);
+            break;
+        }
+    }
 
-    validate(); // #6772 "segmentation fault (invalid code) in Tokenizer::setVarId"
+    // replace varids..
+    int indentlevel = 0;
+    bool initList = false;
+    bool inEnum = false;
+    const Token *initListArgLastToken = nullptr;
+    for (Token *tok = startToken->next(); tok != endToken; tok = tok->next()) {
+        if (!tok)
+            return false;
+        if (initList) {
+            if (tok == initListArgLastToken)
+                initListArgLastToken = nullptr;
+            else if (!initListArgLastToken &&
+                     Token::Match(tok->previous(), "%name%|>|>> {|(") &&
+                     Token::Match(tok->link(), "}|) ,|{"))
+                initListArgLastToken = tok->link();
+        }
+        if (tok->str() == "{") {
+            inEnum = isEnumStart(tok);
+            if (!inEnum && isClassStructUnionEnumStart(tok)) { // nested type
+                tok = tok->link();
+                continue;
+            }
+            if (initList && !initListArgLastToken)
+                initList = false;
+            ++indentlevel;
+        } else if (tok->str() == "}") {
+            --indentlevel;
+            inEnum = false;
+        } else if (initList && indentlevel == 0 && Token::Match(tok->previous(), "[,:] %name% [({]")) {
+            const auto it = variableMap.map(false).find(tok->str());
+            if (it != variableMap.map(false).end()) {
+                tok->varId(it->second);
+            }
+        } else if (tok->isName() && tok->varId() <= scopeStartVarId) {
+            if (indentlevel > 0 || initList) {
+                if (Token::Match(tok->previous(), "::|.") && tok->strAt(-2) != "this" && !Token::simpleMatch(tok->tokAt(-5), "( * this ) ."))
+                    continue;
+                if (!tok->next())
+                    return false;
+                if (tok->strAt(1) == "::") {
+                    if (tok->str() == className)
+                        tok = tok->tokAt(2);
+                    else
+                        continue;
+                }
 
-    if (mTimerResults) {
-        Timer t("Tokenizer::tokenize::setVarId", mSettings->showtime, mTimerResults);
-        setVarId();
-    } else {
-        setVarId();
+                if (!inEnum) {
+                    const auto it = variableMap.map(false).find(tok->str());
+                    if (it != variableMap.map(false).end()) {
+                        tok->varId(it->second);
+                        setVarIdStructMembers(tok, structMembers, variableMap.getVarId());
+                    } else if (tok->str().back() == '>') {
+                        addTemplateVarIdUsage(tok->str(), templateVarUsage, variableMap.map(false), templateVarIdUsage);
+                    }
+                }
+            }
+        } else if (indentlevel == 0 && tok->str() == ":" && !initListArgLastToken)
+            initList = true;
     }
+    return true;
+}
 
-    // Link < with >
-    createLinks2();
 
-    // specify array size
-    arraySize();
 
-    // The simplify enum might have inner loops
-    if (Settings::terminated())
-        return false;
+// Update the variable ids..
+// Parse each function..
+void Tokenizer::setVarIdClassFunction(const std::string &classname,
+                                      Token * const startToken,
+                                      const Token * const endToken,
+                                      const std::map<std::string, nonneg int> &varlist,
+                                      std::map<nonneg int, std::map<std::string, nonneg int>>& structMembers,
+                                      nonneg int &varId_)
+{
+    const auto pos = classname.rfind(' '); // TODO handle multiple scopes
+    const std::string lastScope = classname.substr(pos == std::string::npos ? 0 : pos + 1);
+    for (Token *tok2 = startToken; tok2 && tok2 != endToken; tok2 = tok2->next()) {
+        if (tok2->varId() != 0 || !tok2->isName())
+            continue;
+        if (Token::Match(tok2->tokAt(-2), ("!!" + lastScope + " ::").c_str()))
+            continue;
+        if (Token::Match(tok2->tokAt(-4), "%name% :: %name% ::")) // Currently unsupported
+            continue;
+        if (Token::Match(tok2->tokAt(-2), "!!this .") && !Token::simpleMatch(tok2->tokAt(-5), "( * this ) ."))
+            continue;
+        if (Token::Match(tok2, "%name% ::"))
+            continue;
 
-    // Add std:: in front of std classes, when using namespace std; was given
-    simplifyNamespaceStd();
+        const auto it = varlist.find(tok2->str());
+        if (it != varlist.end()) {
+            tok2->varId(it->second);
+            setVarIdStructMembers(tok2, structMembers, varId_);
+        }
+    }
+}
 
-    // Change initialisation of variable to assignment
-    simplifyInitVar();
 
-    simplifyDoublePlusAndDoubleMinus();
 
-    simplifyArrayAccessSyntax();
+void Tokenizer::setVarId()
+{
+    // Clear all variable ids
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (tok->isName())
+            tok->varId(0);
+    }
 
-    Token::assignProgressValues(list.front());
+    setVarIdPass1();
 
-    removeRedundantSemicolons();
+    setPodTypes();
 
-    simplifyParameterVoid();
+    setVarIdPass2();
+}
 
-    simplifyRedundantConsecutiveBraces();
 
-    simplifyEmptyNamespaces();
+// Variable declarations can't start with "return" etc.
+#define NOTSTART_C "NOT", "case", "default", "goto", "not", "return", "sizeof", "typedef"
+static const std::unordered_set<std::string> notstart_c = { NOTSTART_C };
+static const std::unordered_set<std::string> notstart_cpp = { NOTSTART_C,
+                                                              "delete", "friend", "new", "throw", "using", "virtual", "explicit", "const_cast", "dynamic_cast", "reinterpret_cast", "static_cast", "template"
+};
 
-    elseif();
+void Tokenizer::setVarIdPass1()
+{
+    const bool cpp = isCPP();
+    // Variable declarations can't start with "return" etc.
+    const std::unordered_set<std::string>& notstart = (isC()) ? notstart_c : notstart_cpp;
 
-    SimplifyNamelessRValueReferences();
+    VariableMap variableMap;
+    std::map<nonneg int, std::map<std::string, nonneg int>> structMembers;
 
-    validate();
+    std::stack<VarIdScopeInfo> scopeStack;
 
-    list.front()->assignIndexes();
+    scopeStack.emplace(/*VarIdScopeInfo()*/);
+    std::stack<const Token *> functionDeclEndStack;
+    const Token *functionDeclEndToken = nullptr;
+    bool initlist = false;
+    bool inlineFunction = false;
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (tok->isOp())
+            continue;
+        if (cpp && Token::simpleMatch(tok, "template <")) {
+            Token* closingBracket = tok->next()->findClosingBracket();
+            if (closingBracket)
+                tok = closingBracket;
+            continue;
+        }
 
-    return true;
-}
+        if (tok == functionDeclEndToken) {
+            functionDeclEndStack.pop();
+            functionDeclEndToken = functionDeclEndStack.empty() ? nullptr : functionDeclEndStack.top();
+            if (tok->str() == ":")
+                initlist = true;
+            else if (tok->str() == ";") {
+                if (!variableMap.leaveScope())
+                    cppcheckError(tok);
+            } else if (tok->str() == "{") {
+                scopeStack.emplace(true, scopeStack.top().isStructInit || tok->strAt(-1) == "=", /*isEnum=*/ false, variableMap.getVarId());
 
-bool Tokenizer::simplifyTokenList2()
-{
-    // clear the _functionList so it can't contain dead pointers
-    deleteSymbolDatabase();
+                // check if this '{' is a start of an "if" body
+                const Token * ifToken = tok->previous();
+                if (ifToken && ifToken->str() == ")")
+                    ifToken = ifToken->link();
+                else
+                    ifToken = nullptr;
+                if (ifToken)
+                    ifToken = ifToken->previous();
+                if (ifToken && ifToken->str() == "if") {
+                    // open another scope to differentiate between variables declared in the "if" condition and in the "if" body
+                    variableMap.enterScope();
+                }
+            }
+        } else if (!initlist && tok->str()=="(") {
+            const Token * newFunctionDeclEnd = nullptr;
+            if (!scopeStack.top().isExecutable)
+                newFunctionDeclEnd = TokenList::isFunctionHead(tok, "{:;");
+            else {
+                const Token* tokenLinkNext = tok->link()->next();
+                if (Token::simpleMatch(tokenLinkNext, ".")) { // skip trailing return type
+                    tokenLinkNext = tokenLinkNext->next();
+                    while (Token::Match(tokenLinkNext, "%name%|::")) {
+                        tokenLinkNext = tokenLinkNext->next();
+                        if (Token::simpleMatch(tokenLinkNext, "<") && tokenLinkNext->link())
+                            tokenLinkNext = tokenLinkNext->link()->next();
+                    }
+                }
+                if (tokenLinkNext && tokenLinkNext->str() == "{") // might be for- or while-loop or if-statement
+                    newFunctionDeclEnd = tokenLinkNext;
+            }
+            if (newFunctionDeclEnd && newFunctionDeclEnd != functionDeclEndToken) {
+                functionDeclEndStack.push(newFunctionDeclEnd);
+                functionDeclEndToken = newFunctionDeclEnd;
+                variableMap.enterScope();
+            }
+        } else if (Token::Match(tok, "{|}")) {
+            inlineFunction = false;
 
-    // Clear AST,ValueFlow. These will be created again at the end of this function.
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        tok->clearAst();
-        tok->clearValueFlow();
-    }
+            const Token * const startToken = (tok->str() == "{") ? tok : tok->link();
 
-    // Convert e.g. atol("0") into 0
-    simplifyMathFunctions();
+            // parse anonymous namespaces as part of the current scope
+            if (!Token::Match(startToken->previous(), "union|struct|enum|namespace {") &&
+                !(initlist && Token::Match(startToken->previous(), "%name%|>|>>|(") && Token::Match(startToken->link(), "} ,|{|)|..."))) {
 
-    // f(x=g())   =>   x=g(); f(x)
-    simplifyAssignmentInFunctionCall();
+                if (tok->str() == "{") {
+                    bool isExecutable;
+                    const Token *prev = tok->previous();
+                    while (Token::Match(prev, "%name%|."))
+                        prev = prev->previous();
+                    const bool isLambda = prev && prev->str() == ")" && Token::simpleMatch(prev->link()->previous(), "] (");
+                    if ((!isLambda && (tok->strAt(-1) == ")" || Token::Match(tok->tokAt(-2), ") %type%"))) ||
+                        (initlist && tok->strAt(-1) == "}")) {
+                        isExecutable = true;
+                    } else {
+                        isExecutable = ((scopeStack.top().isExecutable || initlist || tok->strAt(-1) == "else") &&
+                                        !isClassStructUnionEnumStart(tok));
+                        if (!(scopeStack.top().isStructInit || tok->strAt(-1) == "="))
+                            variableMap.enterScope();
+                    }
+                    const bool isStructInit = scopeStack.top().isStructInit || tok->strAt(-1) == "=" || (initlist && !Token::Match(tok->tokAt(-1), ")|}|..."));
+                    scopeStack.emplace(isExecutable, isStructInit, isEnumStart(tok), variableMap.getVarId());
+                    initlist = false;
+                } else { /* if (tok->str() == "}") */
+                    bool isNamespace = false;
+                    for (const Token *tok1 = tok->link()->previous(); tok1 && tok1->isName(); tok1 = tok1->previous()) {
+                        if (tok1->str() == "namespace") {
+                            isNamespace = true;
+                            break;
+                        }
+                    }
+                    // Set variable ids in class declaration..
+                    if (!initlist && !isC() && !scopeStack.top().isExecutable && tok->link() && !isNamespace) {
+                        if (!setVarIdClassDeclaration(tok->link(),
+                                                      variableMap,
+                                                      scopeStack.top().startVarid,
+                                                      mTemplateSimplifier->getUsedVariables(),
+                                                      structMembers,
+                                                      mTemplateVarIdUsage)) {
+                            syntaxError(nullptr);
+                        }
+                    }
 
-    // ";a+=b;" => ";a=a+b;"
-    simplifyCompoundAssignment();
+                    if (!scopeStack.top().isStructInit) {
+                        variableMap.leaveScope();
 
-    simplifyCharAt();
+                        // check if this '}' is an end of an "else" body or an "if" body without an "else" part
+                        const Token * ifToken = startToken->previous();
+                        if (ifToken && ifToken->str() == ")")
+                            ifToken = ifToken->link()->previous();
+                        else
+                            ifToken = nullptr;
+                        if (startToken->strAt(-1) == "else" || (ifToken && ifToken->str() == "if" && tok->strAt(1) != "else")) {
+                            // leave the extra scope used to differentiate between variables declared in the "if" condition and in the "if" body
+                            variableMap.leaveScope();
+                        }
+                    }
 
-    // simplify references
-    simplifyReference();
+                    scopeStack.pop();
+                    if (scopeStack.empty()) {  // should be impossible
+                        scopeStack.emplace(/*VarIdScopeInfo()*/);
+                    }
+                }
+            }
+        }
 
-    simplifyStd();
+        if ((!scopeStack.top().isStructInit &&
+             (tok == list.front() ||
+              Token::Match(tok, "[;{}]") ||
+              (tok->str() == "(" && !scopeStack.top().isExecutable && TokenList::isFunctionHead(tok,";:")) ||
+              (tok->str() == "," && (!scopeStack.top().isExecutable || inlineFunction || !tok->previous()->varId())) ||
+              (tok->isName() && endsWith(tok->str(), ':')))) ||
+            (tok->str() == "(" && TokenList::isFunctionHead(tok, "{"))) {
 
-    if (Settings::terminated())
-        return false;
+            // No variable declarations in sizeof
+            if (Token::simpleMatch(tok->previous(), "sizeof (")) {
+                continue;
+            }
 
-    simplifySizeof();
+            if (Settings::terminated())
+                return;
 
-    simplifyUndefinedSizeArray();
+            // locate the variable name..
+            Token* tok2 = (tok->isName()) ? tok : tok->next();
 
-    simplifyCasts();
+            // private: protected: public: etc
+            while (tok2 && endsWith(tok2->str(), ':')) {
+                tok2 = tok2->next();
+            }
+            if (!tok2)
+                break;
 
-    // Simplify simple calculations before replace constants, this allows the replacement of constants that are calculated
-    // e.g. const static int value = sizeof(X)/sizeof(Y);
-    simplifyCalculations();
+            // Variable declaration can't start with "return", etc
+            if (notstart.find(tok2->str()) != notstart.end())
+                continue;
 
-    if (Settings::terminated())
-        return false;
+            if (!isC() && Token::simpleMatch(tok2, "const new"))
+                continue;
 
-    // Replace "*(ptr + num)" => "ptr[num]"
-    simplifyOffsetPointerDereference();
+            bool decl;
+            if (cpp && mSettings.standards.cpp >= Standards::CPP17 && Token::Match(tok, "[(;{}] const| auto &|&&| [")) {
+                // Structured bindings
+                tok2 = Token::findsimplematch(tok, "[");
+                if ((Token::simpleMatch(tok->previous(), "for (") && Token::simpleMatch(tok2->link(), "] :")) ||
+                    Token::simpleMatch(tok2->link(), "] =")) {
+                    while (tok2 && tok2->str() != "]") {
+                        if (Token::Match(tok2, "%name% [,]]"))
+                            variableMap.addVariable(tok2->str(), false);
+                        tok2 = tok2->next();
+                    }
+                    continue;
+                }
+            }
 
-    // Replace "&str[num]" => "(str + num)"
-    simplifyOffsetPointerReference();
+            try { /* Ticket #8151 */
+                decl = setVarIdParseDeclaration(tok2, variableMap, scopeStack.top().isExecutable, mSettings.standards.c);
+            } catch (const Token * errTok) {
+                syntaxError(errTok);
+            }
 
-    removeRedundantAssignment();
+            if (tok->str() == "(" && TokenList::isFunctionHead(tok, "{") && scopeStack.top().isExecutable)
+                inlineFunction = true;
 
-    simplifyRealloc();
+            if (decl) {
+                if (cpp) {
+                    for (const Token* tok3 = tok->next(); tok3->isName(); tok3 = tok3->next()) {
+                        addTemplateVarIdUsage(tok3->str(),
+                                              mTemplateSimplifier->getUsedVariables(),
+                                              variableMap.map(false),
+                                              mTemplateVarIdUsage);
+                        addTemplateVarIdUsage(tok3->str(),
+                                              mTemplateSimplifier->getUsedVariables(),
+                                              variableMap.map(true),
+                                              mTemplateVarIdUsage);
+                        if (!tok3->next())
+                            syntaxError(tok3);
+                    }
+                }
 
-    // Change initialisation of variable to assignment
-    simplifyInitVar();
+                Token *declTypeTok = nullptr;
+                if (cpp || mSettings.standards.c >= Standards::C23) {
+                    declTypeTok = Token::findmatch(tok, "decltype|typeof (", tok2);
+                } else {
+                    declTypeTok = Token::findsimplematch(tok, "__typeof (", tok2);
+                }
 
-    // Simplify variable declarations
-    simplifyVarDecl(false);
+                if (declTypeTok) {
+                    for (Token *declTok = declTypeTok->linkAt(1); declTok != declTypeTok; declTok = declTok->previous()) {
+                        if (declTok->isName() && !Token::Match(declTok->previous(), "::|.") && variableMap.hasVariable(declTok->str()))
+                            declTok->varId(variableMap.map(false).find(declTok->str())->second);
+                    }
+                }
 
-    simplifyErrNoInWhile();
-    simplifyIfAndWhileAssign();
-    simplifyRedundantParentheses();
-    simplifyNestedStrcat();
-    simplifyFuncInWhile();
+                const Token* prev2 = tok2->previous();
+                if (Token::Match(prev2, "%type% [;[=,)]") && tok2->strAt(-1) != "const")
+                    ;
+                else if (Token::Match(prev2, "%type% [:({]") && tok->strAt(-1) == "for")
+                    ;
+                else if (Token::Match(prev2, "%type% ( !!)") && Token::simpleMatch(tok2->link(), ") ;")) {
+                    // In C++ , a variable can't be called operator+ or something like that.
+                    if (cpp &&
+                        prev2->isOperatorKeyword())
+                        continue;
 
-    simplifyIfAndWhileAssign();
+                    const Token *tok3 = tok2->next();
+                    if (!tok3->isStandardType() && tok3->str() != "void" && !Token::Match(tok3, "struct|union|class %type%") && tok3->str() != "." && !Token::Match(tok2->link()->previous(), "[&*]")) {
+                        if (!scopeStack.top().isExecutable) {
+                            // Detecting initializations with () in non-executable scope is hard and often impossible to be done safely. Thus, only treat code as a variable that definitely is one.
+                            decl = false;
+                            bool rhs = false;
+                            for (; tok3; tok3 = tok3->nextArgumentBeforeCreateLinks2()) {
+                                if (tok3->str() == "=") {
+                                    rhs = true;
+                                    continue;
+                                }
 
-    // replace strlen(str)
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "strlen ( %str% )")) {
-            tok->str(MathLib::toString(Token::getStrLength(tok->tokAt(2))));
-            tok->deleteNext(3);
-        }
-    }
+                                if (tok3->str() == ",") {
+                                    rhs = false;
+                                    continue;
+                                }
 
-    bool modified = true;
-    while (modified) {
-        if (Settings::terminated())
-            return false;
+                                if (rhs)
+                                    continue;
 
-        modified = false;
-        modified |= simplifyConditions();
-        modified |= simplifyFunctionReturn();
-        modified |= simplifyKnownVariables();
-        modified |= simplifyStrlen();
+                                if (tok3->isLiteral() ||
+                                    (tok3->isName() && (variableMap.hasVariable(tok3->str()) ||
+                                                        (tok3->strAt(-1) == "(" && Token::simpleMatch(tok3->next(), "(") && !Token::simpleMatch(tok3->linkAt(1)->next(), "(")))) ||
+                                    tok3->isOp() ||
+                                    tok3->str() == "(" ||
+                                    notstart.find(tok3->str()) != notstart.end()) {
+                                    decl = true;
+                                    break;
+                                }
+                            }
+                        }
+                    } else
+                        decl = false;
+                } else if (cpp && Token::Match(prev2, "%type% {") && Token::simpleMatch(tok2->link(), "} ;")) { // C++11 initialization style
+                    if (tok2->link() != tok2->next() && // add value-initialized variable T x{};
+                        (Token::Match(prev2, "do|try|else") || Token::Match(prev2->tokAt(-2), "struct|class|:")))
+                        continue;
+                } else
+                    decl = false;
 
-        modified |= removeRedundantConditions();
-        modified |= simplifyRedundantParentheses();
-        modified |= simplifyConstTernaryOp();
-        modified |= simplifyCalculations();
-        validate();
-    }
+                if (decl) {
+                    if (isC() && Token::Match(prev2->previous(), "&|&&"))
+                        syntaxErrorC(prev2, prev2->strAt(-2) + prev2->strAt(-1) + " " + prev2->str());
+                    variableMap.addVariable(prev2->str(), scopeStack.size() <= 1);
+
+                    if (Token::simpleMatch(tok->previous(), "for (") && Token::Match(prev2, "%name% [=[({,]")) {
+                        for (const Token *tok3 = prev2->next(); tok3 && tok3->str() != ";"; tok3 = tok3->next()) {
+                            if (Token::Match(tok3, "[([]"))
+                                tok3 = tok3->link();
+                            if (Token::Match(tok3, ", %name% [=[({,;]"))
+                                variableMap.addVariable(tok3->strAt(1), false);
+                        }
+                    }
 
-    // simplify redundant loops
-    simplifyWhile0();
-    removeRedundantFor();
+                    // set varid for template parameters..
+                    tok = tok->next();
+                    while (Token::Match(tok, "%name%|::"))
+                        tok = tok->next();
+                    if (tok && tok->str() == "<") {
+                        const Token *end = tok->findClosingBracket();
+                        while (tok != end) {
+                            if (tok->isName() && !(Token::simpleMatch(tok->next(), "<") &&
+                                                   Token::Match(tok->tokAt(-1), ":: %name%"))) {
+                                const auto it = variableMap.map(false).find(tok->str());
+                                if (it != variableMap.map(false).end())
+                                    tok->varId(it->second);
+                            }
+                            tok = tok->next();
+                        }
+                    }
 
-    // Remove redundant parentheses in return..
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        while (Token::simpleMatch(tok, "return (")) {
-            Token *tok2 = tok->next()->link();
-            if (Token::simpleMatch(tok2, ") ;")) {
-                tok->deleteNext();
-                tok2->deleteThis();
-            } else {
-                break;
+                    tok = tok2->previous();
+                }
             }
         }
-    }
-
-    simplifyReturnStrncat();
-
-    removeRedundantAssignment();
-
-    simplifyComma();
 
-    removeRedundantSemicolons();
-
-    simplifyFlowControl();
-
-    simplifyRedundantConsecutiveBraces();
+        if (tok->isName() && !tok->isKeyword() && !tok->isStandardType()) {
+            // don't set variable id after a struct|enum|union
+            if (Token::Match(tok->previous(), "struct|enum|union") || (cpp && tok->strAt(-1) == "class"))
+                continue;
 
-    simplifyEmptyNamespaces();
+            bool globalNamespace = false;
+            if (!isC()) {
+                if (tok->previous() && tok->strAt(-1) == "::") {
+                    if (Token::Match(tok->tokAt(-2), ")|]|%name%"))
+                        continue;
+                    globalNamespace = true;
+                }
+                if (tok->next() && tok->strAt(1) == "::")
+                    continue;
+                if (Token::simpleMatch(tok->tokAt(-2), ":: template"))
+                    continue;
+            }
 
-    simplifyMathFunctions();
+            if (tok->str().back() == '>') {
+                addTemplateVarIdUsage(tok->str(),
+                                      mTemplateSimplifier->getUsedVariables(),
+                                      variableMap.map(globalNamespace),
+                                      mTemplateVarIdUsage);
+            }
 
-    validate();
+            // function declaration inside executable scope? Function declaration is of form: type name "(" args ")"
+            if (scopeStack.top().isExecutable && !scopeStack.top().isStructInit && Token::Match(tok, "%name% [,)[]")) {
+                bool par = false;
+                const Token* start;
+                Token* end;
 
-    Token::assignProgressValues(list.front());
+                // search begin of function declaration
+                for (start = tok; Token::Match(start, "%name%|*|&|,|("); start = start->previous()) {
+                    if (start->str() == "(") {
+                        if (par)
+                            break;
+                        par = true;
+                    }
+                    if (Token::Match(start, "[(,]")) {
+                        if (!Token::Match(start, "[(,] %type% %name%|*|&"))
+                            break;
+                    }
+                    if (start->varId() > 0)
+                        break;
+                }
 
-    list.createAst();
-    // needed for #7208 (garbage code) and #7724 (ast max depth limit)
-    list.validateAst();
+                // search end of function declaration
+                for (end = tok->next(); Token::Match(end, "%name%|*|&|,|[|]|%num%"); end = end->next()) {}
 
-    // Create symbol database and then remove const keywords
-    createSymbolDatabase();
-    mSymbolDatabase->setValueTypeInTokenList(true);
+                // there are tokens which can't appear at the begin of a function declaration such as "return"
+                const bool isNotstartKeyword = start->next() && notstart.find(start->strAt(1)) != notstart.end();
 
-    ValueFlow::setValues(&list, mSymbolDatabase, mErrorLogger, mSettings);
+                // now check if it is a function (pointer) declaration
+                if ((Token::simpleMatch(start, ") (") || Token::Match(start, "[;{}] %type% %name%|*")) && par && Token::Match(end, ") [;=]") && !isNotstartKeyword) {
+                    // function declaration => don't set varid
+                    tok = end;
+                    continue;
+                }
+            }
 
-    if (Settings::terminated())
-        return false;
+            if (tok->varId() == 0 && (!scopeStack.top().isEnum || !(Token::Match(tok->previous(), "{|,") && Token::Match(tok->next(), ",|=|}"))) &&
+                !Token::simpleMatch(tok->next(), ": ;") && !(tok->tokAt(-1) && Token::Match(tok->tokAt(-2), "{|, ."))) {
+                const auto it = variableMap.map(globalNamespace).find(tok->str());
+                if (it != variableMap.map(globalNamespace).end()) {
+                    tok->varId(it->second);
+                    setVarIdStructMembers(tok, structMembers, variableMap.getVarId());
+                }
+            }
+        } else if (Token::Match(tok, "::|. %name%") && Token::Match(tok->previous(), ")|]|>|%name%")) {
+            // Don't set varid after a :: or . token
+            tok = tok->next();
+        } else if (tok->str() == ":" && Token::Match(tok->tokAt(-2), "class %type%")) {
+            do {
+                tok = tok->next();
+            } while (tok && (tok->isName() || tok->str() == ","));
+            if (!tok)
+                break;
+            tok = tok->previous();
+        }
+    }
 
-    printDebugOutput(2);
+    mVarId = variableMap.getVarId();
+}
 
-    return true;
+namespace {
+    struct Member {
+        Member(std::list<std::string> s, std::list<const Token *> ns, Token *t) : usingnamespaces(std::move(ns)), scope(std::move(s)), tok(t) {}
+        std::list<const Token *> usingnamespaces;
+        std::list<std::string> scope;
+        Token *tok;
+    };
 }
-//---------------------------------------------------------------------------
 
-void Tokenizer::printDebugOutput(int simplification) const
+static std::string getScopeName(const std::list<ScopeInfo2> &scopeInfo)
 {
-    const bool debug = (simplification != 1U && mSettings->debugSimplified) ||
-                       (simplification != 2U && mSettings->debugnormal);
+    std::string ret;
+    for (const ScopeInfo2 &si : scopeInfo)
+        ret += (ret.empty() ? "" : " :: ") + (si.name);
+    return ret;
+}
 
-    if (debug && list.front()) {
-        list.front()->printOut(nullptr, list.getFiles());
+static Token * matchMemberName(const std::list<std::string> &scope, const Token *nsToken, Token *memberToken, const std::list<ScopeInfo2> &scopeInfo)
+{
+    auto scopeIt = scopeInfo.cbegin();
 
-        if (mSettings->xml)
-            std::cout << "<debug>" << std::endl;
+    // Current scope..
+    for (auto it = scope.cbegin(); it != scope.cend(); ++it) {
+        if (scopeIt == scopeInfo.cend() || scopeIt->name != *it)
+            return nullptr;
+        ++scopeIt;
+    }
 
-        if (mSymbolDatabase) {
-            if (mSettings->xml)
-                mSymbolDatabase->printXml(std::cout);
-            else if (mSettings->verbose) {
-                mSymbolDatabase->printOut("Symbol database");
+    // using namespace..
+    if (nsToken) {
+        while (Token::Match(nsToken, "%name% ::")) {
+            if (scopeIt != scopeInfo.end() && nsToken->str() == scopeIt->name) {
+                nsToken = nsToken->tokAt(2);
+                ++scopeIt;
+            } else {
+                return nullptr;
             }
         }
+        if (!Token::Match(nsToken, "%name% ;"))
+            return nullptr;
+        if (scopeIt == scopeInfo.end() || nsToken->str() != scopeIt->name)
+            return nullptr;
+        ++scopeIt;
+    }
 
-        if (mSettings->verbose)
-            list.front()->printAst(mSettings->verbose, mSettings->xml, std::cout);
-
-        list.front()->printValueFlow(mSettings->xml, std::cout);
-
-        if (mSettings->xml)
-            std::cout << "</debug>" << std::endl;
+    // Parse member tokens..
+    while (scopeIt != scopeInfo.end()) {
+        if (!Token::Match(memberToken, "%name% ::|<"))
+            return nullptr;
+        if (memberToken->str() != scopeIt->name)
+            return nullptr;
+        if (memberToken->strAt(1) == "<") {
+            memberToken = memberToken->next()->findClosingBracket();
+            if (!Token::simpleMatch(memberToken, "> ::"))
+                return nullptr;
+        }
+        memberToken = memberToken->tokAt(2);
+        ++scopeIt;
     }
 
-    if (mSymbolDatabase && simplification == 2U && mSettings->debugwarnings) {
-        printUnknownTypes();
+    return Token::Match(memberToken, "~| %name%") ? memberToken : nullptr;
+}
 
-        // the typeStartToken() should come before typeEndToken()
-        for (const Variable *var : mSymbolDatabase->variableList()) {
-            if (!var)
-                continue;
+static Token * matchMemberName(const Member &member, const std::list<ScopeInfo2> &scopeInfo)
+{
+    if (scopeInfo.empty())
+        return nullptr;
 
-            const Token * typetok = var->typeStartToken();
-            while (typetok && typetok != var->typeEndToken())
-                typetok = typetok->next();
+    // Does this member match without "using namespace"..
+    Token *ret = matchMemberName(member.scope, nullptr, member.tok, scopeInfo);
+    if (ret)
+        return ret;
 
-            if (typetok != var->typeEndToken()) {
-                reportError(var->typeStartToken(),
-                            Severity::debug,
-                            "debug",
-                            "Variable::typeStartToken() of variable '" + var->name() + "' is not located before Variable::typeEndToken(). The location of the typeStartToken() is '" + var->typeStartToken()->str() + "' at line " + MathLib::toString(var->typeStartToken()->linenr()));
-            }
-        }
+    // Try to match member using the "using namespace ..." namespaces..
+    for (const Token *ns : member.usingnamespaces) {
+        ret = matchMemberName(member.scope, ns, member.tok, scopeInfo);
+        if (ret)
+            return ret;
     }
+
+    return nullptr;
 }
 
-void Tokenizer::dump(std::ostream &out) const
+static Token * matchMemberVarName(const Member &var, const std::list<ScopeInfo2> &scopeInfo)
 {
-    // Create a xml data dump.
-    // The idea is not that this will be readable for humans. It's a
-    // data dump that 3rd party tools could load and get useful info from.
-
-    // tokens..
-    out << "  <tokenlist>" << std::endl;
-    for (const Token *tok = list.front(); tok; tok = tok->next()) {
-        out << "    <token id=\"" << tok << "\" file=\"" << ErrorLogger::toxml(list.file(tok)) << "\" linenr=\"" << tok->linenr() << "\" column=\"" << tok->column() << "\"";
-        out << " str=\"" << ErrorLogger::toxml(tok->str()) << '\"';
-        out << " scope=\"" << tok->scope() << '\"';
-        if (tok->isName()) {
-            out << " type=\"name\"";
-            if (tok->isUnsigned())
-                out << " isUnsigned=\"true\"";
-            else if (tok->isSigned())
-                out << " isSigned=\"true\"";
-        } else if (tok->isNumber()) {
-            out << " type=\"number\"";
-            if (MathLib::isInt(tok->str()))
-                out << " isInt=\"True\"";
-            if (MathLib::isFloat(tok->str()))
-                out << " isFloat=\"True\"";
-        } else if (tok->tokType() == Token::eString)
-            out << " type=\"string\" strlen=\"" << Token::getStrLength(tok) << '\"';
-        else if (tok->tokType() == Token::eChar)
-            out << " type=\"char\"";
-        else if (tok->isBoolean())
-            out << " type=\"boolean\"";
-        else if (tok->isOp()) {
-            out << " type=\"op\"";
-            if (tok->isArithmeticalOp())
-                out << " isArithmeticalOp=\"True\"";
-            else if (tok->isAssignmentOp())
-                out << " isAssignmentOp=\"True\"";
-            else if (tok->isComparisonOp())
-                out << " isComparisonOp=\"True\"";
-            else if (tok->tokType() == Token::eLogicalOp)
-                out << " isLogicalOp=\"True\"";
-        }
-        if (tok->isExpandedMacro())
-            out << " isExpandedMacro=\"True\"";
-        if (tok->link())
-            out << " link=\"" << tok->link() << '\"';
-        if (tok->varId() > 0)
-            out << " varId=\"" << MathLib::toString(tok->varId()) << '\"';
-        if (tok->variable())
-            out << " variable=\"" << tok->variable() << '\"';
-        if (tok->function())
-            out << " function=\"" << tok->function() << '\"';
-        if (!tok->values().empty())
-            out << " values=\"" << &tok->values() << '\"';
-        if (tok->type())
-            out << " type-scope=\"" << tok->type()->classScope << '\"';
-        if (tok->astParent())
-            out << " astParent=\"" << tok->astParent() << '\"';
-        if (tok->astOperand1())
-            out << " astOperand1=\"" << tok->astOperand1() << '\"';
-        if (tok->astOperand2())
-            out << " astOperand2=\"" << tok->astOperand2() << '\"';
-        if (!tok->originalName().empty())
-            out << " originalName=\"" << tok->originalName() << '\"';
-        if (tok->valueType()) {
-            const std::string vt = tok->valueType()->dump();
-            if (!vt.empty())
-                out << ' ' << vt;
-        }
-        out << "/>" << std::endl;
+    Token *tok = matchMemberName(var, scopeInfo);
+    if (Token::Match(tok, "%name%")) {
+        if (!tok->next() || tok->strAt(1) != "(" || (tok->tokAt(2) && tok->tokAt(2)->isLiteral()))
+            return tok;
     }
-    out << "  </tokenlist>" << std::endl;
+    return nullptr;
+}
 
-    mSymbolDatabase->printXml(out);
-    if (list.front())
-        list.front()->printValueFlow(true, out);
+static Token * matchMemberFunctionName(const Member &func, const std::list<ScopeInfo2> &scopeInfo)
+{
+    Token *tok = matchMemberName(func, scopeInfo);
+    return Token::Match(tok, "~| %name% (") ? tok : nullptr;
 }
 
-void Tokenizer::simplifyHeaders()
+template<typename T>
+static T* skipInitializerList(T* tok)
 {
-    // TODO : can we remove anything in headers here? Like unused declarations.
-    // Maybe if --dump is used we want to have _everything_.
-
-    if (mSettings->checkHeaders && mSettings->checkUnusedTemplates)
-        // Full analysis. All information in the headers are kept.
-        return;
-
-    const bool checkHeaders = mSettings->checkHeaders;
-    const bool removeUnusedIncludedFunctions = !mSettings->checkHeaders;
-    const bool removeUnusedIncludedClasses   = !mSettings->checkHeaders;
-    const bool removeUnusedIncludedTemplates = !mSettings->checkUnusedTemplates || !mSettings->checkHeaders;
-    const bool removeUnusedTemplates = !mSettings->checkUnusedTemplates;
+    T* const start = tok;
+    while (Token::Match(tok, "[:,] ::| %name%")) {
+        tok = tok->tokAt(tok->strAt(1) == "::" ? 1 : 2);
+        while (Token::Match(tok, ":: %name%"))
+            tok = tok->tokAt(2);
+        if (!Token::Match(tok, "[({<]") || !tok->link())
+            return start;
+        const bool isTemplate = tok->str() == "<";
+        tok = tok->link()->next();
+        if (isTemplate && tok && tok->link())
+            tok = tok->link()->next();
+    }
+    return tok;
+}
 
-    // We want to remove selected stuff from the headers but not *everything*.
-    // The intention here is to not damage the analysis of the source file.
-    // You should get all warnings in the source file.
+void Tokenizer::setVarIdPass2()
+{
+    std::map<nonneg int, std::map<std::string, nonneg int>> structMembers;
 
-    // TODO: Remove unused types/variables/etc in headers..
+    // Member functions and variables in this source
+    std::list<Member> allMemberFunctions;
+    std::list<Member> allMemberVars;
+    if (!isC()) {
+        std::map<const Token *, std::string> endOfScope;
+        std::list<std::string> scope;
+        std::list<const Token *> usingnamespaces;
+        for (Token *tok = list.front(); tok; tok = tok->next()) {
+            if (!tok->previous() || Token::Match(tok->previous(), "[;{}]")) {
+                if (Token::Match(tok, "using namespace %name% ::|;")) {
+                    Token *endtok = tok->tokAt(2);
+                    while (Token::Match(endtok, "%name% ::"))
+                        endtok = endtok->tokAt(2);
+                    if (Token::Match(endtok, "%name% ;"))
+                        usingnamespaces.push_back(tok->tokAt(2));
+                    tok = endtok;
+                    continue;
+                }
+                if (Token::Match(tok, "namespace %name% {")) {
+                    scope.push_back(tok->strAt(1));
+                    endOfScope[tok->linkAt(2)] = tok->strAt(1);
+                }
+            }
 
-    // functions and types to keep
-    std::set<std::string> keep;
-    for (const Token *tok = list.front(); tok; tok = tok->next()) {
-        if (!tok->isName())
-            continue;
+            if (tok->str() == "}") {
+                const auto it = utils::as_const(endOfScope).find(tok);
+                if (it != endOfScope.cend())
+                    scope.remove(it->second);
+            }
 
-        if (checkHeaders && tok->fileIndex() != 0)
-            continue;
+            Token* const tok1 = tok;
+            if (Token::Match(tok, "%name% :: ~| %name%"))
+                tok = tok->next();
+            else if (Token::Match(tok, "%name% <") && Token::Match(tok->next()->findClosingBracket(),"> :: ~| %name%"))
+                tok = tok->next()->findClosingBracket()->next();
+            else if (usingnamespaces.empty() || tok->varId() || !tok->isName() || tok->isStandardType() || tok->tokType() == Token::eKeyword || tok->tokType() == Token::eBoolean ||
+                     Token::Match(tok->previous(), ".|namespace|class|struct|&|&&|*|> %name%") || Token::Match(tok->previous(), "%type%| %name% ( %type%|)") || Token::Match(tok, "public:|private:|protected:") ||
+                     (!tok->next() && Token::Match(tok->previous(), "}|; %name%")))
+                continue;
 
-        if (Token::Match(tok, "%name% (") && !Token::simpleMatch(tok->linkAt(1), ") {")) {
-            keep.insert(tok->str());
-            continue;
-        }
+            if (tok->strAt(-1) == "::" && tok->tokAt(-2) && tok->tokAt(-2)->isName())
+                continue;
 
-        if (Token::Match(tok, "%name% %name%|::|*|&|<")) {
-            keep.insert(tok->str());
+            while (Token::Match(tok, ":: ~| %name%")) {
+                tok = tok->next();
+                if (tok->str() == "~")
+                    tok = tok->next();
+                else if (Token::Match(tok, "%name% <") && Token::Match(tok->next()->findClosingBracket(),"> :: ~| %name%"))
+                    tok = tok->next()->findClosingBracket()->next();
+                else if (Token::Match(tok, "%name% ::"))
+                    tok = tok->next();
+                else
+                    break;
+            }
+            if (!tok->next())
+                syntaxError(tok);
+            if (Token::Match(tok, "%name% (") && !(tok->tokAt(2) && tok->tokAt(2)->isLiteral()))
+                allMemberFunctions.emplace_back(scope, usingnamespaces, tok1);
+            else
+                allMemberVars.emplace_back(scope, usingnamespaces, tok1);
         }
     }
 
-    const std::set<std::string> functionStart{"static", "const", "unsigned", "signed", "void", "bool", "char", "short", "int", "long", "float", "*"};
+    std::list<ScopeInfo2> scopeInfo;
 
+    // class members..
+    std::map<std::string, std::map<std::string, nonneg int>> varsByClass;
     for (Token *tok = list.front(); tok; tok = tok->next()) {
-        const bool isIncluded = (tok->fileIndex() != 0);
+        while (tok->str() == "}" && !scopeInfo.empty() && tok == scopeInfo.back().bodyEnd)
+            scopeInfo.pop_back();
 
-        // Remove executable code
-        if (isIncluded && !mSettings->checkHeaders && tok->str() == "{") {
-            // TODO: We probably need to keep the executable code if this function is called from the source file.
-            const Token *prev = tok->previous();
-            while (prev && prev->isName())
-                prev = prev->previous();
-            if (Token::simpleMatch(prev, ")")) {
-                // Replace all tokens from { to } with a ";".
-                Token::eraseTokens(tok,tok->link()->next());
-                tok->str(";");
-                tok->link(nullptr);
+        if (!Token::Match(tok, "namespace|class|struct %name% {|:|::|<"))
+            continue;
+
+        const std::string &scopeName(getScopeName(scopeInfo));
+        const std::string scopeName2(scopeName.empty() ? std::string() : (scopeName + " :: "));
+
+        std::list<const Token*> classnameTokens{ tok->next() };
+        Token* tokStart = tok->tokAt(2);
+        while (Token::Match(tokStart, ":: %name%") || tokStart->str() == "<") {
+            if (tokStart->str() == "<") {
+                // skip the template part
+                Token* closeTok = tokStart->findClosingBracket();
+                if (!closeTok)
+                    syntaxError(tok);
+                tokStart = closeTok->next();
+            } else {
+                classnameTokens.push_back(tokStart->next());
+                tokStart = tokStart->tokAt(2);
             }
+            if (!tokStart)
+                syntaxError(tok);
         }
 
-        if (Token::Match(tok, "[;{}]")) {
-            // Remove unused function declarations
-            if (isIncluded && removeUnusedIncludedFunctions) {
-                while (1) {
-                    Token *start = tok->next();
-                    while (start && functionStart.find(start->str()) != functionStart.end())
-                        start = start->next();
-                    if (Token::Match(start, "%name% (") && Token::Match(start->linkAt(1), ") const| ;") && keep.find(start->str()) == keep.end())
-                        Token::eraseTokens(tok, start->linkAt(1)->tokAt(2));
-                    else
+        std::string classname;
+        for (const Token *it : classnameTokens)
+            classname += (classname.empty() ? "" : " :: ") + it->str();
+
+        std::map<std::string, nonneg int> &thisClassVars = varsByClass[scopeName2 + classname];
+        while (Token::Match(tokStart, ":|::|,|%name%")) {
+            if (Token::Match(tokStart, "%name% <")) { // TODO: why skip templates?
+                tokStart = tokStart->next()->findClosingBracket();
+                if (tokStart)
+                    tokStart = tokStart->next();
+                continue;
+            }
+            if (Token::Match(tokStart, "%name% ,|{")) {
+                std::string baseClassName = tokStart->str();
+                const Token* baseStart = tokStart;
+                while (Token::Match(baseStart->tokAt(-2), "%name% ::")) { // build base class name
+                    baseClassName.insert(0, baseStart->strAt(-2) + " :: ");
+                    baseStart = baseStart->tokAt(-2);
+                }
+                std::string scopeName3(scopeName2);
+                while (!scopeName3.empty()) {
+                    std::string name = scopeName3 + baseClassName;
+                    if (varsByClass.find(name) != varsByClass.end()) {
+                        baseClassName = std::move(name);
+                        break;
+                    }
+                    // Remove last scope name
+                    if (scopeName3.size() <= 8)
                         break;
+                    scopeName3.erase(scopeName3.size() - 4);
+                    const std::string::size_type pos = scopeName3.rfind(" :: ");
+                    if (pos == std::string::npos)
+                        break;
+                    scopeName3.erase(pos + 4);
                 }
+                const std::map<std::string, nonneg int>& baseClassVars = varsByClass[baseClassName];
+                thisClassVars.insert(baseClassVars.cbegin(), baseClassVars.cend());
             }
+            tokStart = tokStart->next();
+        }
+        if (!Token::simpleMatch(tokStart, "{"))
+            continue;
 
-            if (isIncluded && removeUnusedIncludedClasses) {
-                if (Token::Match(tok, "[;{}] class|struct %name% [:{]") && keep.find(tok->strAt(2)) == keep.end()) {
-                    // Remove this class/struct
-                    const Token *endToken = tok->tokAt(3);
-                    if (endToken->str() == ":") {
-                        endToken = endToken->next();
-                        while (Token::Match(endToken, "%name%|,"))
-                            endToken = endToken->next();
+        // What member variables are there in this class?
+        std::transform(classnameTokens.cbegin(), classnameTokens.cend(), std::back_inserter(scopeInfo), [&](const Token* tok) {
+            return ScopeInfo2(tok->str(), tokStart->link());
+        });
+
+        for (Token *tok2 = tokStart->next(); tok2 && tok2 != tokStart->link(); tok2 = tok2->next()) {
+            // skip parentheses..
+            if (tok2->link()) {
+                if (tok2->str() == "(") {
+                    Token *funcstart = const_cast<Token*>(TokenList::isFunctionHead(tok2, "{"));
+                    if (funcstart) {
+                        setVarIdClassFunction(scopeName2 + classname, funcstart, funcstart->link(), thisClassVars, structMembers, mVarId);
+                        tok2 = funcstart->link();
+                        continue;
                     }
-                    if (endToken && endToken->str() == "{" && Token::simpleMatch(endToken->link(), "} ;"))
-                        Token::eraseTokens(tok, endToken->link()->next());
                 }
-            }
+                if (tok2->str() == "{" && !Token::simpleMatch(tok2->previous(), "union")) {
+                    if (tok2->strAt(-1) == ")")
+                        setVarIdClassFunction(scopeName2 + classname, tok2, tok2->link(), thisClassVars, structMembers, mVarId);
+                    tok2 = tok2->link();
+                } else if (Token::Match(tok2, "( %name%|)")) {
+                    tok2 = tok2->link();
 
-            if (removeUnusedTemplates || (isIncluded && removeUnusedIncludedTemplates)) {
-                if (Token::Match(tok->next(), "template < %name%")) {
-                    const Token *tok2 = tok->tokAt(3);
-                    while (Token::Match(tok2, "%name% %name% [,=>]") || Token::Match(tok2, "typename ... %name% [,>]")) {
-                        if (Token::simpleMatch(tok2, "typename ..."))
-                            tok2 = tok2->tokAt(3);
-                        else
-                            tok2 = tok2->tokAt(2);
-                        if (Token::Match(tok2, "= %name% [,>]"))
-                            tok2 = tok2->tokAt(2);
-                        if (tok2->str() == ",")
-                            tok2 = tok2->next();
-                    }
-                    if (Token::Match(tok2, "> class|struct %name% [;:{]") && keep.find(tok2->strAt(2)) == keep.end()) {
-                        const Token *endToken = tok2->tokAt(3);
-                        if (endToken->str() == ":") {
-                            endToken = endToken->next();
-                            while (Token::Match(endToken, "%name%|,"))
-                                endToken = endToken->next();
-                        }
-                        if (endToken && endToken->str() == "{")
-                            endToken = endToken->link()->next();
-                        if (endToken && endToken->str() == ";")
-                            Token::eraseTokens(tok, endToken);
-                    } else if (Token::Match(tok2, "> %type% %name% (") && Token::simpleMatch(tok2->linkAt(3), ") {") && keep.find(tok2->strAt(2)) == keep.end()) {
-                        const Token *endToken = tok2->linkAt(3)->linkAt(1)->next();
-                        Token::eraseTokens(tok, endToken);
+                    // Skip initialization list
+                    if (Token::simpleMatch(tok2, ") :")) {
+                        tok2 = skipInitializerList(tok2->next());
+                        if (Token::simpleMatch(tok2, "{"))
+                            tok2 = tok2->link();
                     }
                 }
             }
+
+            // Found a member variable..
+            else if (tok2->varId() > 0)
+                thisClassVars[tok2->str()] = tok2->varId();
         }
-    }
-}
 
-void Tokenizer::removeMacrosInGlobalScope()
-{
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (tok->str() == "(") {
-            tok = tok->link();
-            if (Token::Match(tok, ") %type% {") &&
-                !Token::Match(tok->next(), "const|namespace|class|struct|union|noexcept|override|final|volatile"))
-                tok->deleteNext();
+        // Are there any member variables in this class?
+        if (thisClassVars.empty())
+            continue;
+
+        // Member variables
+        for (const Member &var : allMemberVars) {
+            Token *tok2 = matchMemberVarName(var, scopeInfo);
+            if (!tok2)
+                continue;
+            if (tok2->varId() == 0)
+                tok2->varId(thisClassVars[tok2->str()]);
         }
 
-        if (Token::Match(tok, "%type%") && tok->isUpperCaseName() &&
-            (!tok->previous() || Token::Match(tok->previous(), "[;{}]") || (tok->previous()->isName() && endsWith(tok->previous()->str(), ':')))) {
-            const Token *tok2 = tok->next();
-            if (tok2 && tok2->str() == "(")
-                tok2 = tok2->link()->next();
+        if (isC() || tok->str() == "namespace")
+            continue;
 
-            // Several unknown macros...
-            while (Token::Match(tok2, "%type% (") && tok2->isUpperCaseName())
-                tok2 = tok2->linkAt(1)->next();
+        // Set variable ids in member functions for this class..
+        for (const Member &func : allMemberFunctions) {
+            Token *tok2 = matchMemberFunctionName(func, scopeInfo);
+            if (!tok2)
+                continue;
 
-            if (Token::Match(tok, "%name% (") && Token::Match(tok2, "%name% *|&|::|<| %name%") && !Token::Match(tok2, "namespace|class|struct|union"))
-                unknownMacroError(tok);
+            if (tok2->str() == "~")
+                tok2 = tok2->linkAt(2);
+            else
+                tok2 = tok2->linkAt(1);
 
-            if (Token::Match(tok, "%type% (") && Token::Match(tok2, "%type% (") && !Token::Match(tok2, "noexcept|throw") && isFunctionHead(tok2->next(), ":;{"))
-                unknownMacroError(tok);
+            // If this is a function implementation.. add it to funclist
+            Token * start = const_cast<Token *>(TokenList::isFunctionHead(tok2, "{"));
+            if (start) {
+                setVarIdClassFunction(classname, start, start->link(), thisClassVars, structMembers, mVarId);
+            }
 
-            // remove unknown macros before namespace|class|struct|union
-            if (Token::Match(tok2, "namespace|class|struct|union")) {
-                // is there a "{" for?
-                const Token *tok3 = tok2;
-                while (tok3 && !Token::Match(tok3,"[;{}()]"))
-                    tok3 = tok3->next();
-                if (tok3 && tok3->str() == "{") {
-                    Token::eraseTokens(tok, tok2);
-                    tok->deleteThis();
-                }
+            if (Token::Match(tok2, ") %name% ("))
+                tok2 = tok2->linkAt(2);
+
+            // constructor with initializer list
+            if (!Token::Match(tok2, ") : ::| %name%"))
                 continue;
-            }
 
-            // replace unknown macros before foo(
-            /*
-                        if (Token::Match(tok2, "%type% (") && isFunctionHead(tok2->next(), "{")) {
-                            std::string typeName;
-                            for (const Token* tok3 = tok; tok3 != tok2; tok3 = tok3->next())
-                                typeName += tok3->str();
-                            Token::eraseTokens(tok, tok2);
-                            tok->str(typeName);
-                        }
-            */
-            // remove unknown macros before foo::foo(
-            if (Token::Match(tok2, "%type% :: %type%")) {
-                const Token *tok3 = tok2;
-                while (Token::Match(tok3, "%type% :: %type% ::"))
+            Token *tok3 = tok2;
+            while (Token::Match(tok3, "[)}] [,:]")) {
+                tok3 = tok3->tokAt(2);
+                if (Token::Match(tok3, ":: %name%"))
+                    tok3 = tok3->next();
+                while (Token::Match(tok3, "%name% :: %name%"))
                     tok3 = tok3->tokAt(2);
-                if (Token::Match(tok3, "%type% :: %type% (") && tok3->str() == tok3->strAt(2)) {
-                    Token::eraseTokens(tok, tok2);
-                    tok->deleteThis();
-                }
-                continue;
-            }
-        }
+                if (!Token::Match(tok3, "%name% (|{|<"))
+                    break;
 
-        // Skip executable scopes
-        if (tok->str() == "{") {
-            const Token *prev = tok->previous();
-            while (prev && prev->isName())
-                prev = prev->previous();
-            if (prev && prev->str() == ")")
-                tok = tok->link();
+                // set varid
+                const auto varpos = utils::as_const(thisClassVars).find(tok3->str());
+                if (varpos != thisClassVars.end())
+                    tok3->varId(varpos->second);
+
+                // goto end of var
+                if (tok3->strAt(1) == "<") {
+                    tok3 = tok3->next()->findClosingBracket();
+                    if (tok3 && tok3->next() && tok3->linkAt(1))
+                        tok3 = tok3->linkAt(1);
+                } else
+                    tok3 = tok3->linkAt(1);
+            }
+            if (Token::Match(tok3, ")|} {")) {
+                setVarIdClassFunction(classname, tok2, tok3->linkAt(1), thisClassVars, structMembers, mVarId);
+            }
         }
     }
 }
 
-//---------------------------------------------------------------------------
-
-void Tokenizer::removeMacroInClassDef()
+static void linkBrackets(const Tokenizer & tokenizer, std::stack<const Token*>& type, std::stack<Token*>& links, Token * const token, const char open, const char close)
 {
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (!Token::Match(tok, "class|struct %name% %name% {|:"))
-            continue;
+    if (token->str()[0] == open) {
+        links.push(token);
+        type.push(token);
+    } else if (token->str()[0] == close) {
+        if (links.empty()) {
+            // Error, { and } don't match.
+            tokenizer.unmatchedToken(token);
+        }
+        if (type.top()->str()[0] != open) {
+            tokenizer.unmatchedToken(type.top());
+        }
+        type.pop();
 
-        const bool nextIsUppercase = tok->next()->isUpperCaseName();
-        const bool afterNextIsUppercase = tok->tokAt(2)->isUpperCaseName();
-        if (nextIsUppercase && !afterNextIsUppercase)
-            tok->deleteNext();
-        else if (!nextIsUppercase && afterNextIsUppercase)
-            tok->next()->deleteNext();
+        Token::createMutualLinks(links.top(), token);
+        links.pop();
     }
 }
 
-//---------------------------------------------------------------------------
-
-void Tokenizer::removeMacroInVarDecl()
+void Tokenizer::createLinks()
 {
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "[;{}] %name% (") && tok->next()->isUpperCaseName()) {
-            // goto ')' parentheses
-            const Token *tok2 = tok;
-            int parlevel = 0;
-            while (tok2) {
-                if (tok2->str() == "(")
-                    ++parlevel;
-                else if (tok2->str() == ")") {
-                    if (--parlevel <= 0)
-                        break;
-                }
-                tok2 = tok2->next();
-            }
-            tok2 = tok2 ? tok2->next() : nullptr;
-
-            // check if this is a variable declaration..
-            const Token *tok3 = tok2;
-            while (tok3 && tok3->isUpperCaseName())
-                tok3 = tok3->next();
-            if (tok3 && (tok3->isStandardType() || Token::Match(tok3,"const|static|struct|union|class")))
-                Token::eraseTokens(tok,tok2);
+    std::stack<const Token*> type;
+    std::stack<Token*> links1;
+    std::stack<Token*> links2;
+    std::stack<Token*> links3;
+    for (Token *token = list.front(); token; token = token->next()) {
+        if (token->link()) {
+            token->link(nullptr);
         }
+
+        linkBrackets(*this, type, links1, token, '{', '}');
+
+        linkBrackets(*this, type, links2, token, '(', ')');
+
+        linkBrackets(*this, type, links3, token, '[', ']');
     }
-}
-//---------------------------------------------------------------------------
 
-void Tokenizer::removeRedundantAssignment()
-{
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (tok->str() == "{")
-            tok = tok->link();
+    if (!links1.empty()) {
+        // Error, { and } don't match.
+        unmatchedToken(links1.top());
+    }
 
-        const Token * const start = const_cast<Token *>(startOfExecutableScope(tok));
-        if (start) {
-            tok = start->previous();
-            // parse in this function..
-            std::set<int> localvars;
-            const Token * const end = tok->next()->link();
-            for (Token * tok2 = tok->next(); tok2 && tok2 != end; tok2 = tok2->next()) {
-                // skip local class or struct
-                if (Token::Match(tok2, "class|struct %type% {|:")) {
-                    // skip to '{'
-                    tok2 = tok2->tokAt(2);
-                    while (tok2 && tok2->str() != "{")
-                        tok2 = tok2->next();
+    if (!links2.empty()) {
+        // Error, ( and ) don't match.
+        unmatchedToken(links2.top());
+    }
 
-                    if (tok2)
-                        tok2 = tok2->link(); // skip local class or struct
-                    else
-                        return;
-                } else if (Token::Match(tok2, "[;{}] %type% * %name% ;") && tok2->next()->str() != "return") {
-                    tok2 = tok2->tokAt(3);
-                    localvars.insert(tok2->varId());
-                } else if (Token::Match(tok2, "[;{}] %type% %name% ;") && tok2->next()->isStandardType()) {
-                    tok2 = tok2->tokAt(2);
-                    localvars.insert(tok2->varId());
-                } else if (tok2->varId() &&
-                           !Token::Match(tok2->previous(), "[;{}] %name% = %char%|%num%|%name% ;")) {
-                    localvars.erase(tok2->varId());
-                }
-            }
-            localvars.erase(0);
-            if (!localvars.empty()) {
-                for (Token *tok2 = tok->next(); tok2 && tok2 != end;) {
-                    if (Token::Match(tok2, "[;{}] %type% %name% ;") && localvars.find(tok2->tokAt(2)->varId()) != localvars.end()) {
-                        tok2->deleteNext(3);
-                    } else if ((Token::Match(tok2, "[;{}] %type% * %name% ;") &&
-                                localvars.find(tok2->tokAt(3)->varId()) != localvars.end()) ||
-                               (Token::Match(tok2, "[;{}] %name% = %any% ;") &&
-                                localvars.find(tok2->next()->varId()) != localvars.end())) {
-                        tok2->deleteNext(4);
-                    } else
-                        tok2 = tok2->next();
-                }
-            }
-        }
+    if (!links3.empty()) {
+        // Error, [ and ] don't match.
+        unmatchedToken(links3.top());
     }
 }
 
-void Tokenizer::simplifyRealloc()
+void Tokenizer::createLinks2()
 {
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "(|[") ||
-            (tok->str() == "{" && tok->previous() && tok->previous()->str() == "="))
-            tok = tok->link();
-        else if (Token::Match(tok, "[;{}] %name% = realloc (")) {
-            tok = tok->tokAt(3);
-            if (Token::simpleMatch(tok->next(), "( 0 ,")) {
-                //no "x = realloc(0,);"
-                if (!Token::simpleMatch(tok->next()->link(), ") ;") || tok->next()->link()->previous() == tok->tokAt(3))
+    if (isC())
+        return;
+
+    bool isStruct = false;
+
+    std::stack<Token*> type;
+    std::stack<Token*> templateTokens;
+    for (Token *token = list.front(); token; token = token->next()) {
+        if (Token::Match(token, "%name%|> %name% [:<]"))
+            isStruct = true;
+        else if (Token::Match(token, "[;{}]"))
+            isStruct = false;
+
+        if (token->link()) {
+            if (Token::Match(token, "{|[|("))
+                type.push(token);
+            else if (!type.empty() && Token::Match(token, "}|]|)")) {
+                while (type.top()->str() == "<") {
+                    if (!templateTokens.empty() && templateTokens.top()->next() == type.top())
+                        templateTokens.pop();
+                    type.pop();
+                }
+                type.pop();
+            }
+        } else if (templateTokens.empty() && !isStruct && Token::Match(token, "%oror%|&&|;")) {
+            if (Token::Match(token, "&& [,>]"))
+                continue;
+            // If there is some such code:  A<B||C>..
+            // Then this is probably a template instantiation if either "B" or "C" has comparisons
+            if (token->tokType() == Token::eLogicalOp && !type.empty() && type.top()->str() == "<") {
+                const Token *prev = token->previous();
+                bool foundComparison = false;
+                while (Token::Match(prev, "%name%|%num%|%str%|%cop%|)|]") && prev != type.top()) {
+                    if (prev->str() == ")" || prev->str() == "]")
+                        prev = prev->link();
+                    else if (prev->tokType() == Token::eLogicalOp)
+                        break;
+                    else if (prev->isComparisonOp())
+                        foundComparison = true;
+                    prev = prev->previous();
+                }
+                if (prev == type.top() && foundComparison)
+                    continue;
+                const Token *next = token->next();
+                foundComparison = false;
+                while (Token::Match(next, "%name%|%num%|%str%|%cop%|(|[") && next->str() != ">") {
+                    if (next->str() == "(" || next->str() == "[")
+                        next = next->link();
+                    else if (next->tokType() == Token::eLogicalOp)
+                        break;
+                    else if (next->isComparisonOp())
+                        foundComparison = true;
+                    next = next->next();
+                }
+                if (next && next->str() == ">" && foundComparison)
                     continue;
+            }
 
-                // delete "0 ,"
-                tok->next()->deleteNext(2);
+            while (!type.empty() && type.top()->str() == "<") {
+                const Token* end = type.top()->findClosingBracket();
+                if (Token::Match(end, "> %comp%|;|.|=|{|(|)|::"))
+                    break;
+                // Variable declaration
+                if (Token::Match(end, "> %var% ;") && (type.top()->tokAt(-2) == nullptr || Token::Match(type.top()->tokAt(-2), ";|}|{")))
+                    break;
+                type.pop();
+            }
+        } else if (token->str() == "<" &&
+                   ((token->previous() && (token->previous()->isTemplate() ||
+                                           (token->previous()->isName() && !token->previous()->varId()) ||
+                                           (token->strAt(-1) == "]" && (!Token::Match(token->linkAt(-1)->previous(), "%name%|)") || token->linkAt(-1)->previous()->isKeyword())) ||
+                                           (token->strAt(-1) == ")" && token->linkAt(-1)->strAt(-1) == "operator"))) ||
+                    Token::Match(token->next(), ">|>>"))) {
+            type.push(token);
+            if (token->strAt(-1) == "template")
+                templateTokens.push(token);
+        } else if (token->str() == ">" || token->str() == ">>") {
+            if (type.empty() || type.top()->str() != "<") // < and > don't match.
+                continue;
+            Token * const top1 = type.top();
+            type.pop();
+            Token * const top2 = type.empty() ? nullptr : type.top();
+            type.push(top1);
+            if (!top2 || top2->str() != "<") {
+                if (token->str() == ">>")
+                    continue;
+                if (!Token::Match(token->next(), "%name%|%cop%|%assign%|::|,|(|)|{|}|;|[|]|:|.|=|?|...") &&
+                    !Token::Match(token->next(), "&& %name% ="))
+                    continue;
+            }
 
-                // Change function name "realloc" to "malloc"
-                tok->str("malloc");
-                tok = tok->next()->link();
+            if (token->str() == ">>" && top1 && top2) {
+                type.pop();
+                type.pop();
+                // Split the angle brackets
+                token->str(">");
+                Token::createMutualLinks(top1, token->insertTokenBefore(">"));
+                Token::createMutualLinks(top2, token);
+                if (templateTokens.size() == 2 && (top1 == templateTokens.top() || top2 == templateTokens.top())) {
+                    templateTokens.pop();
+                    templateTokens.pop();
+                }
             } else {
-                Token *tok2 = tok->next()->link()->tokAt(-2);
-                //no "x = realloc(,0);"
-                if (!Token::simpleMatch(tok2, ", 0 ) ;") || tok2 == tok->tokAt(2))
+                type.pop();
+                if (Token::Match(token, "> %name%") && !token->next()->isKeyword() &&
+                    Token::Match(top1->tokAt(-2), "%op% %name% <") && top1->strAt(-2) != "<" &&
+                    (templateTokens.empty() || top1 != templateTokens.top()))
                     continue;
-
-                //remove ", 0"
-                tok2 = tok2->previous();
-                tok2->deleteNext(2);
-                //change "realloc" to "free"
-                tok->str("free");
-                //insert "0" after "var ="
-                tok = tok->previous();
-                tok->insertToken("0");
-                //move "var = 0" between "free(...)" and ";"
-                tok2 = tok2->next();
-                Token::move(tok->previous(), tok->next(), tok2);
-                //add missing ";" after "free(...)"
-                tok2->insertToken(";");
-                //goto before last ";" and continue
-                tok = tok->next();
+                Token::createMutualLinks(top1, token);
+                if (!templateTokens.empty() && top1 == templateTokens.top())
+                    templateTokens.pop();
             }
         }
     }
 }
 
-void Tokenizer::simplifyEmptyNamespaces()
+void Tokenizer::markCppCasts()
 {
     if (isC())
         return;
-
-    bool goback = false;
-    for (Token *tok = list.front(); tok; tok = tok ? tok->next() : nullptr) {
-        if (goback) {
-            tok = tok->previous();
-            goback = false;
-        }
-        if (Token::Match(tok, "(|[|{")) {
-            tok = tok->link();
-            continue;
+    for (Token* tok = list.front(); tok; tok = tok->next()) {
+        if (Token::Match(tok, "const_cast|dynamic_cast|reinterpret_cast|static_cast")) {
+            if (!Token::simpleMatch(tok->next(), "<") || !Token::simpleMatch(tok->linkAt(1), "> ("))
+                syntaxError(tok);
+            tok = tok->linkAt(1)->next();
+            tok->isCast(true);
         }
-        if (!Token::Match(tok, "namespace %name% {"))
+    }
+
+}
+
+void Tokenizer::sizeofAddParentheses()
+{
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (!Token::Match(tok, "sizeof !!("))
             continue;
-        if (tok->strAt(3) == "}") {
-            tok->deleteNext(3);             // remove '%name% { }'
-            if (!tok->previous()) {
-                // remove 'namespace' or replace it with ';' if isolated
-                tok->deleteThis();
-                goback = true;
-            } else {                    // '%any% namespace %any%'
-                tok = tok->previous();  // goto previous token
-                tok->deleteNext();      // remove next token: 'namespace'
+        if (tok->next()->isLiteral() || Token::Match(tok->next(), "%name%|*|~|!|&")) {
+            Token *endToken = tok->next();
+            while (Token::simpleMatch(endToken, "* *"))
+                endToken = endToken->next();
+            while (Token::Match(endToken->next(), "%name%|%num%|%str%|[|(|.|::|++|--|!|~") || (Token::Match(endToken, "%type% * %op%|?|:|const|;|,"))) {
+                if (Token::Match(endToken->next(), "(|["))
+                    endToken = endToken->linkAt(1);
+                else
+                    endToken = endToken->next();
             }
-        } else {
-            tok = tok->tokAt(2);
+
+            // Add ( after sizeof and ) behind endToken
+            tok->insertToken("(");
+            endToken->insertToken(")");
+            Token::createMutualLinks(tok->next(), endToken->next());
         }
     }
 }
 
-void Tokenizer::simplifyFlowControl()
+bool Tokenizer::simplifyTokenList1(const char FileName[])
 {
-    for (Token *begin = list.front(); begin; begin = begin->next()) {
+    if (Settings::terminated())
+        return false;
+
+    // if MACRO
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (Token::Match(tok, "if|for|while %name% (")) {
+            if (Token::simpleMatch(tok, "for each")) {
+                // 'for each (x in y )' -> 'for (x : y)'
+                if (Token* in = Token::findsimplematch(tok->tokAt(2), "in", tok->linkAt(2)))
+                    in->str(":");
+                tok->deleteNext();
+            } else if (tok->strAt(1) == "constexpr") {
+                tok->deleteNext();
+                tok->isConstexpr(true);
+            } else {
+                syntaxError(tok);
+            }
+        }
+    }
 
-        if (Token::Match(begin, "(|[") ||
-            (begin->str() == "{" && begin->previous() && begin->strAt(-1) == "="))
-            begin = begin->link();
+    // Is there C++ code in C file?
+    validateC();
 
-        //function scope
-        if (!Token::simpleMatch(begin, ") {") && !Token::Match(begin, ") %name% {"))
-            continue;
+    // Combine strings and character literals, e.g. L"string", L'c', "string1" "string2"
+    combineStringAndCharLiterals();
 
-        Token* end = begin->linkAt(1+(begin->next()->str() == "{" ? 0 : 1));
-        int indentLevel = 0;
-        bool stilldead = false;
+    // replace inline SQL with "asm()" (Oracle PRO*C). Ticket: #1959
+    simplifySQL();
 
-        for (Token *tok = begin; tok && tok != end; tok = tok->next()) {
-            if (Token::Match(tok, "(|[")) {
-                tok = tok->link();
-                continue;
-            }
+    createLinks();
 
-            if (tok->str() == "{") {
-                if (tok->previous() && tok->previous()->str() == "=") {
-                    tok = tok->link();
-                    continue;
-                }
-                ++indentLevel;
-            } else if (tok->str() == "}") {
-                if (indentLevel == 0)
-                    break;
-                --indentLevel;
-                if (stilldead) {
-                    eraseDeadCode(tok, nullptr);
-                    if (indentLevel == 1 || tok->next()->str() != "}" || !Token::Match(tok->next()->link()->previous(), ";|{|}|do {"))
-                        stilldead = false;
-                    continue;
-                }
-            }
+    // replace library function calls such as (std::min)(a, b) with std::min(a, b)
+    simplifyParenthesizedLibraryFunctions();
+
+    // Simplify debug intrinsics
+    simplifyDebug();
+
+    removePragma();
+
+    // Simplify the C alternative tokens (and, or, etc.)
+    simplifyCAlternativeTokens();
+
+    simplifyFunctionTryCatch();
+
+    simplifyHeadersAndUnusedTemplates();
+
+    // Remove __asm..
+    simplifyAsm();
 
-            if (indentLevel == 0)
-                continue;
+    // foo < bar < >> => foo < bar < > >
+    if (isCPP() || mSettings.daca)
+        splitTemplateRightAngleBrackets(!isCPP());
 
-            if (Token::Match(tok,"continue|break ;")) {
-                tok = tok->next();
-                eraseDeadCode(tok, nullptr);
-
-            } else if (Token::Match(tok,"return|goto") ||
-                       (Token::Match(tok->previous(), "[;{}] %name% (") &&
-                        mSettings->library.isnoreturn(tok)) ||
-                       (isCPP() && tok->str() == "throw")) {
-                if (tok->next()->str() == "}")
-                    syntaxError(tok->next()); // invalid code like in #6731
-                //TODO: ensure that we exclude user-defined 'exit|abort|throw', except for 'noreturn'
-                //catch the first ';'
-                for (Token *tok2 = tok->next(); tok2; tok2 = tok2->next()) {
-                    if (Token::Match(tok2, "(|[")) {
-                        tok2 = tok2->link();
-                    } else if (tok2->str() == ";") {
-                        tok = tok2;
-                        eraseDeadCode(tok, nullptr);
-                        break;
-                    } else if (Token::Match(tok2, "[{}]"))
-                        break;
-                }
-                //if everything is removed, then remove also the code after an inferior scope
-                //only if the actual scope is not special
-                if (indentLevel > 1 && tok->next()->str() == "}" && Token::Match(tok->next()->link()->previous(), ";|{|}|do {"))
-                    stilldead = true;
-            }
-        }
-        begin = end;
-    }
-}
+    // Remove extra "template" tokens that are not used by cppcheck
+    removeExtraTemplateKeywords();
 
+    simplifySpaceshipOperator();
 
-bool Tokenizer::removeRedundantConditions()
-{
-    // Return value for function. Set to true if there are any simplifications
-    bool ret = false;
+    // @..
+    simplifyAt();
 
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (!Token::Match(tok, "if ( %bool% ) {"))
-            continue;
+    // Remove __declspec()
+    simplifyDeclspec();
 
-        // Find matching else
-        Token *elseTag = tok->linkAt(4)->next();
+    // Remove "inline", "register", and "restrict"
+    simplifyKeyword();
 
-        const bool boolValue = (tok->strAt(2) == "true");
+    // Remove [[attribute]]
+    simplifyCPPAttribute();
 
-        // Handle if with else
-        if (Token::simpleMatch(elseTag, "else {")) {
-            // Handle else
-            if (!boolValue) {
-                // Convert "if( false ) {aaa;} else {bbb;}" => "{bbb;}"
+    // remove __attribute__((?))
+    simplifyAttribute();
 
-                //remove '(false)'
-                tok->deleteNext(3);
-                //delete dead code inside scope
-                eraseDeadCode(tok, elseTag);
-                //remove 'else'
-                elseTag->deleteThis();
-                //remove 'if'
-                tok->deleteThis();
-            } else {
-                // Convert "if( true ) {aaa;} else {bbb;}" => "{aaa;}"
-                const Token *end = elseTag->next()->link()->next();
+    validate();
 
-                // Remove "else { bbb; }"
-                elseTag = elseTag->previous();
-                eraseDeadCode(elseTag, end);
+    const ShowTime showTime = mTimerResults ? mSettings.showtime : ShowTime::NONE;
 
-                // Remove "if( true )"
-                tok->deleteNext(3);
-                tok->deleteThis();
-            }
+    // Bail out if code is garbage
+    Timer::run("Tokenizer::simplifyTokens1::simplifyTokenList1::findGarbageCode", showTime, mTimerResults, [&]() {
+        findGarbageCode();
+    });
 
-            ret = true;
-        }
+    if (Settings::terminated())
+        return false;
 
-        // Handle if without else
-        else {
-            if (!boolValue) {
-                //remove '(false)'
-                tok->deleteNext(3);
-                //delete dead code inside scope
-                eraseDeadCode(tok, elseTag);
-                //remove 'if'
-                tok->deleteThis();
-            } else {
-                // convert "if( true ) {aaa;}" => "{aaa;}"
-                tok->deleteNext(3);
-                tok->deleteThis();
-            }
+    // convert C++17 style nested namespaces to old style namespaces
+    simplifyNestedNamespace();
 
-            ret = true;
-        }
-    }
+    // convert c++20 coroutines
+    simplifyCoroutines();
 
-    return ret;
-}
+    // simplify namespace aliases
+    simplifyNamespaceAliases();
 
-void Tokenizer::removeRedundantFor()
-{
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "[;{}] for ( %name% = %num% ; %name% < %num% ; ++| %name% ++| ) {") ||
-            Token::Match(tok, "[;{}] for ( %type% %name% = %num% ; %name% < %num% ; ++| %name% ++| ) {")) {
-            // Same variable name..
-            const Token* varTok = tok->tokAt(3);
-            const bool type = varTok->next()->isName();
-            if (type)
-                varTok = varTok->next();
-            const std::string varname(varTok->str());
-            const int varid(varTok->varId());
-            if (varname != varTok->strAt(4))
-                continue;
-            const Token *vartok2 = tok->linkAt(2)->previous();
-            if (vartok2->str() == "++")
-                vartok2 = vartok2->previous();
-            else if (vartok2->strAt(-1) != "++")
-                continue;
-            if (varname != vartok2->str())
-                continue;
+    // simplify cppcheck attributes __cppcheck_?__(?)
+    simplifyCppcheckAttribute();
 
-            // Check that the difference of the numeric values is 1
-            const MathLib::bigint num1(MathLib::toLongNumber(varTok->strAt(2)));
-            const MathLib::bigint num2(MathLib::toLongNumber(varTok->strAt(6)));
-            if (num1 + 1 != num2)
-                continue;
+    // Combine tokens..
+    combineOperators();
 
-            // check how loop variable is used in loop..
-            bool read = false;
-            bool write = false;
-            const Token* end = tok->linkAt(2)->next()->link();
-            for (const Token *tok2 = tok->linkAt(2); tok2 != end; tok2 = tok2->next()) {
-                if (tok2->str() == varname) {
-                    if (tok2->previous()->isArithmeticalOp() &&
-                        tok2->next() &&
-                        (tok2->next()->isArithmeticalOp() || tok2->next()->str() == ";")) {
-                        read = true;
-                    } else {
-                        read = write = true;
-                        break;
-                    }
-                }
-            }
+    // combine "- %num%"
+    concatenateNegativeNumberAndAnyPositive();
 
-            // Simplify loop if loop variable isn't written
-            if (!write) {
-                Token* bodyBegin = tok->linkAt(2)->next();
-                // remove "for ("
-                tok->deleteNext(2);
+    // remove extern "C" and extern "C" {}
+    if (isCPP())
+        simplifyExternC();
 
-                // If loop variable is read then keep assignment before
-                // loop body..
-                if (type) {
-                    tok->insertToken("{");
-                    Token::createMutualLinks(tok->next(), bodyBegin->link());
-                    bodyBegin->deleteThis();
-                    tok = tok->tokAt(6);
-                } else if (read) {
-                    // goto ";"
-                    tok = tok->tokAt(4);
-                } else {
-                    // remove "x = 0 ;"
-                    tok->deleteNext(4);
-                }
+    validate();
 
-                // remove "x < 1 ; x ++ )"
-                tok->deleteNext(7);
+    // simplify compound statements: "[;{}] ( { code; } ) ;"->"[;{}] code;"
+    simplifyCompoundStatements();
 
-                if (!type) {
-                    // Add assignment after the loop body so the loop variable
-                    // get the correct end value
-                    Token *tok2 = tok->next()->link();
-                    tok2->insertToken(";");
-                    tok2->insertToken(MathLib::toString(num2));
-                    tok2->insertToken("=");
-                    tok2->insertToken(varname);
-                    tok2->next()->varId(varid);
-                }
-            }
-        }
-    }
-}
+    if (!simplifyAddBraces())
+        return false;
 
+    sizeofAddParentheses();
 
-void Tokenizer::removeRedundantSemicolons()
-{
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (tok->link() && tok->str() == "(") {
-            tok = tok->link();
-            continue;
-        }
-        for (;;) {
-            if (Token::simpleMatch(tok, "; ;")) {
-                tok->deleteNext();
-            } else if (Token::simpleMatch(tok, "; { ; }")) {
-                tok->deleteNext(3);
-            } else {
-                break;
-            }
+    // Simplify: 0[foo] -> *(foo)
+    for (Token* tok = list.front(); tok; tok = tok->next()) {
+        if (Token::simpleMatch(tok, "0 [") && tok->linkAt(1)) {
+            tok->str("*");
+            tok->next()->str("(");
+            tok->linkAt(1)->str(")");
         }
     }
-}
 
+    if (Settings::terminated())
+        return false;
 
-bool Tokenizer::simplifyAddBraces()
-{
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        Token const * tokRet=simplifyAddBracesToCommand(tok);
-        if (!tokRet)
-            return false;
-    }
-    return true;
-}
+    validate();
 
-Token *Tokenizer::simplifyAddBracesToCommand(Token *tok)
-{
-    Token * tokEnd=tok;
-    if (Token::Match(tok,"for|switch|BOOST_FOREACH")) {
-        tokEnd=simplifyAddBracesPair(tok,true);
-    } else if (tok->str()=="while") {
-        Token *tokPossibleDo=tok->previous();
-        if (Token::simpleMatch(tok->previous(), "{"))
-            tokPossibleDo = nullptr;
-        else if (Token::simpleMatch(tokPossibleDo,"}"))
-            tokPossibleDo = tokPossibleDo->link();
-        if (!tokPossibleDo || tokPossibleDo->strAt(-1) != "do")
-            tokEnd=simplifyAddBracesPair(tok,true);
-    } else if (tok->str()=="do") {
-        tokEnd=simplifyAddBracesPair(tok,false);
-        if (tokEnd!=tok) {
-            // walk on to next token, i.e. "while"
-            // such that simplifyAddBracesPair does not close other braces
-            // before the "while"
-            if (tokEnd) {
-                tokEnd=tokEnd->next();
-                if (!tokEnd || tokEnd->str()!="while") // no while
-                    syntaxError(tok);
+    // simplify simple calculations inside <..>
+    if (isCPP()) {
+        Token *lt = nullptr;
+        for (Token *tok = list.front(); tok; tok = tok->next()) {
+            if (Token::Match(tok, "[;{}]"))
+                lt = nullptr;
+            else if (Token::Match(tok, "%type% <"))
+                lt = tok->next();
+            else if (lt && Token::Match(tok, ">|>> %name%|::|(")) {
+                const Token * const end = tok;
+                for (tok = lt; tok != end; tok = tok->next()) {
+                    if (tok->isNumber())
+                        TemplateSimplifier::simplifyNumericCalculations(tok);
+                }
+                lt = tok->next();
             }
         }
-    } else if (tok->str()=="if" && !Token::simpleMatch(tok->tokAt(-2), "operator \"\"")) {
-        tokEnd=simplifyAddBracesPair(tok,true);
-        if (!tokEnd)
-            return nullptr;
-        if (tokEnd->strAt(1) == "else") {
-            Token * tokEndNextNext= tokEnd->tokAt(2);
-            if (!tokEndNextNext || tokEndNextNext->str() == "}")
-                syntaxError(tokEndNextNext);
-            if (tokEndNextNext->str() == "if")
-                // do not change "else if ..." to "else { if ... }"
-                tokEnd=simplifyAddBracesToCommand(tokEndNextNext);
-            else
-                tokEnd=simplifyAddBracesPair(tokEnd->next(),false);
-        }
     }
 
-    return tokEnd;
-}
-
-Token *Tokenizer::simplifyAddBracesPair(Token *tok, bool commandWithCondition)
-{
-    Token * tokCondition=tok->next();
-    if (!tokCondition) // Missing condition
-        return tok;
+    // Convert K&R function declarations to modern C
+    simplifyVarDecl(true);
+    simplifyFunctionParameters();
 
-    Token *tokAfterCondition=tokCondition;
-    if (commandWithCondition) {
-        if (tokCondition->str()=="(")
-            tokAfterCondition=tokCondition->link();
-        else
-            syntaxError(tok); // Bad condition
+    // simplify case ranges (gcc extension)
+    simplifyCaseRange();
 
-        if (!tokAfterCondition || tokAfterCondition->strAt(1) == "]")
-            syntaxError(tok); // Bad condition
+    // simplify labels and 'case|default'-like syntaxes
+    simplifyLabelsCaseDefault();
 
-        tokAfterCondition=tokAfterCondition->next();
-        if (!tokAfterCondition || Token::Match(tokAfterCondition, ")|}|,")) {
-            // No tokens left where to add braces around
-            return tok;
-        }
+    if (!isC() && !mSettings.library.markupFile(FileName)) {
+        findComplicatedSyntaxErrorsInTemplates();
     }
-    Token * tokBracesEnd=nullptr;
-    if (tokAfterCondition->str()=="{") {
-        // already surrounded by braces
-        tokBracesEnd=tokAfterCondition->link();
-    } else if (Token::simpleMatch(tokAfterCondition, "try {") &&
-               Token::simpleMatch(tokAfterCondition->linkAt(1), "} catch (")) {
-        tokAfterCondition->previous()->insertToken("{");
-        Token * tokOpenBrace = tokAfterCondition->previous();
-        Token * tokEnd = tokAfterCondition->linkAt(1)->linkAt(2)->linkAt(1);
-        if (!tokEnd) {
-            syntaxError(tokAfterCondition);
-        }
-        tokEnd->insertToken("}");
-        Token * tokCloseBrace = tokEnd->next();
 
-        Token::createMutualLinks(tokOpenBrace, tokCloseBrace);
-        tokBracesEnd = tokCloseBrace;
-    } else if (Token::Match(tokAfterCondition, "%name% : {")) {
-        tokAfterCondition->previous()->insertToken("{");
-        tokAfterCondition->linkAt(2)->insertToken("}");
-        tokBracesEnd = tokAfterCondition->linkAt(2)->next();
-        Token::createMutualLinks(tokAfterCondition->previous(), tokBracesEnd);
-    } else {
-        Token * tokEnd = simplifyAddBracesToCommand(tokAfterCondition);
-        if (!tokEnd) // Ticket #4887
-            return tok;
-        if (tokEnd->str()!="}") {
-            // Token does not end with brace
-            // Look for ; to add own closing brace after it
-            while (tokEnd && !Token::Match(tokEnd, ";|)|}")) {
-                if (tokEnd->tokType()==Token::eBracket || tokEnd->str() == "(") {
-                    tokEnd = tokEnd->link();
-                    if (!tokEnd) {
-                        // Inner bracket does not close
-                        return tok;
-                    }
-                }
-                tokEnd=tokEnd->next();
-            }
-            if (!tokEnd || tokEnd->str() != ";") {
-                // No trailing ;
-                return tok;
-            }
-        }
+    if (Settings::terminated())
+        return false;
 
-        tokAfterCondition->previous()->insertToken("{");
-        Token * tokOpenBrace=tokAfterCondition->previous();
+    // remove calling conventions __cdecl, __stdcall..
+    simplifyCallingConvention();
 
-        tokEnd->insertToken("}");
-        Token * TokCloseBrace=tokEnd->next();
+    addSemicolonAfterUnknownMacro();
+
+    // remove some unhandled macros in global scope
+    removeMacrosInGlobalScope();
+
+    // remove undefined macro in class definition:
+    // class DLLEXPORT Fred { };
+    // class Fred FINAL : Base { };
+    removeMacroInClassDef();
+
+    // That call here fixes #7190
+    validate();
+
+    // remove unnecessary member qualification..
+    removeUnnecessaryQualification();
 
-        Token::createMutualLinks(tokOpenBrace,TokCloseBrace);
-        tokBracesEnd=TokCloseBrace;
-    }
+    // convert Microsoft memory functions
+    simplifyMicrosoftMemoryFunctions();
 
-    return tokBracesEnd;
-}
+    // convert Microsoft string functions
+    simplifyMicrosoftStringFunctions();
 
-void Tokenizer::simplifyCompoundAssignment()
-{
-    // Simplify compound assignments:
-    // "a+=b" => "a = a + b"
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (!Token::Match(tok, "[;{}] (| *| (| %name%"))
-            continue;
-        if (tok->next()->str() == "return")
-            continue;
-        // backup current token..
-        Token * const tok1 = tok;
+    if (Settings::terminated())
+        return false;
 
-        if (tok->next()->str() == "*")
-            tok = tok->next();
+    // remove Borland stuff..
+    simplifyBorland();
 
-        if (tok->next() && tok->next()->str() == "(") {
-            tok = tok->next()->link()->next();
-        } else {
-            // variable..
-            tok = tok->tokAt(2);
-            while (Token::Match(tok, ". %name%") ||
-                   Token::Match(tok, "[|(")) {
-                if (tok->str() == ".")
-                    tok = tok->tokAt(2);
-                else {
-                    // goto "]" or ")"
-                    tok = tok->link();
+    // syntax error: enum with typedef in it
+    checkForEnumsWithTypedef();
 
-                    // goto next token..
-                    tok = tok ? tok->next() : nullptr;
-                }
-            }
-        }
-        if (!tok)
-            break;
+    // Add parentheses to ternary operator where necessary
+    prepareTernaryOpForAST();
 
-        // Is current token at a compound assignment: +=|-=|.. ?
-        const std::string &str = tok->str();
-        std::string op;  // operator used in assignment
-        if (tok->isAssignmentOp() && str.size() == 2)
-            op = str.substr(0, 1);
-        else if (tok->isAssignmentOp() && str.size() == 3)
-            op = str.substr(0, 2);
-        else {
-            tok = tok1;
-            continue;
-        }
+    // Change initialisation of variable to assignment
+    simplifyInitVar();
 
-        // Remove the whole statement if it says: "+=0;", "-=0;", "*=1;" or "/=1;"
-        if (Token::Match(tok, "+=|-= 0 ;") ||
-            Token::simpleMatch(tok, "|= 0 ;") ||
-            Token::Match(tok, "*=|/= 1 ;")) {
-            tok = tok1;
-            while (tok->next()->str() != ";")
-                tok->deleteNext();
-        } else {
-            // Enclose the rhs in parentheses..
-            if (!Token::Match(tok->tokAt(2), "[;)]")) {
-                // Only enclose rhs in parentheses if there is some operator
-                bool someOperator = false;
-                for (Token *tok2 = tok->next(); tok2; tok2 = tok2->next()) {
-                    if (tok2->link() && Token::Match(tok2, "{|[|("))
-                        tok2 = tok2->link();
+    // Split up variable declarations.
+    simplifyVarDecl(false);
 
-                    if (Token::Match(tok2->next(), "[;)]")) {
-                        if (someOperator) {
-                            tok->insertToken("(");
-                            tok2->insertToken(")");
-                            Token::createMutualLinks(tok->next(), tok2->next());
-                        }
-                        break;
-                    }
+    reportUnknownMacros();
 
-                    someOperator |= (tok2->isOp() || tok2->str() == "?");
-                }
-            }
+    simplifyTypedefLHS();
 
-            // simplify the compound assignment..
-            tok->str("=");
-            tok->insertToken(op);
+    // typedef..
+    Timer::run("Tokenizer::simplifyTokens1::simplifyTokenList1::simplifyTypedef", showTime, mTimerResults, [&]() {
+        simplifyTypedef();
+    });
 
-            std::stack<Token *> tokend;
-            for (Token *tok2 = tok->previous(); tok2 && tok2 != tok1; tok2 = tok2->previous()) {
-                // Don't duplicate ++ and --. Put preincrement in lhs. Put
-                // postincrement in rhs.
-                if (tok2->tokType() == Token::eIncDecOp) {
-                    // pre increment/decrement => don't copy
-                    if (tok2->next()->isName()) {
-                        continue;
-                    }
+    // using A = B;
+    while (simplifyUsing())
+        ;
 
-                    // post increment/decrement => move from lhs to rhs
-                    tok->insertToken(tok2->str());
-                    tok2->deleteThis();
-                    continue;
-                }
+    // Add parentheses to ternary operator where necessary
+    // TODO: this is only necessary if one typedef simplification had a comma and was used within ?:
+    // If typedef handling is refactored and moved to symboldatabase someday we can remove this
+    prepareTernaryOpForAST();
 
-                // Copy token from lhs to rhs
-                tok->insertToken(tok2->str());
-                tok->next()->varId(tok2->varId());
-                if (Token::Match(tok->next(), "]|)|}"))
-                    tokend.push(tok->next());
-                else if (Token::Match(tok->next(), "(|[|{")) {
-                    Token::createMutualLinks(tok->next(), tokend.top());
-                    tokend.pop();
-                }
+    // class x y {
+    if (isCPP() && mSettings.severity.isEnabled(Severity::information)) {
+        for (const Token *tok = list.front(); tok; tok = tok->next()) {
+            if (Token::Match(tok, "class %type% %type% [:{]")) {
+                unhandled_macro_class_x_y(tok, tok->str(), tok->strAt(1), tok->strAt(2), tok->strAt(3));
             }
         }
     }
-}
 
-bool Tokenizer::simplifyConditions()
-{
-    bool ret = false;
+    // catch bad typedef canonicalization
+    //
+    // to reproduce bad typedef, download upx-ucl from:
+    // http://packages.debian.org/sid/upx-ucl
+    // analyse the file src/stub/src/i386-linux.elf.interp-main.c
+    validate();
 
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "! %bool%|%num%")) {
-            tok->deleteThis();
-            if (Token::Match(tok, "0|false"))
-                tok->str("true");
-            else
-                tok->str("false");
+    // The simplify enum have inner loops
+    if (Settings::terminated())
+        return false;
 
-            ret = true;
-        }
+    // Put ^{} statements in asm()
+    simplifyAsm2();
 
-        if (Token::simpleMatch(tok, "&& true &&")) {
-            tok->deleteNext(2);
-            ret = true;
+    // When the assembly code has been cleaned up, no @ is allowed
+    for (const Token *tok = list.front(); tok; tok = tok->next()) {
+        if (tok->str() == "(") {
+            const Token *tok1 = tok;
+            tok = tok->link();
+            if (!tok)
+                syntaxError(tok1);
+        } else if (tok->str() == "@") {
+            syntaxError(tok);
         }
+    }
 
-        else if (Token::simpleMatch(tok, "|| false ||")) {
-            tok->deleteNext(2);
-            ret = true;
-        }
+    // Order keywords "static" and "const"
+    simplifyStaticConst();
 
-        else if (Token::Match(tok, "(|&& true && true &&|)")) {
-            tok->deleteNext(2);
-            ret = true;
-        }
+    // convert platform dependent types to standard types
+    // 32 bits: size_t -> unsigned long
+    // 64 bits: size_t -> unsigned long long
+    list.simplifyPlatformTypes();
 
-        else if (Token::Match(tok, "%oror%|( false %oror% false %oror%|)")) {
-            tok->deleteNext(2);
-            ret = true;
-        }
+    // collapse compound standard types into a single token
+    // unsigned long long int => long (with _isUnsigned=true,_isLong=true)
+    list.simplifyStdType();
 
-        else if (Token::simpleMatch(tok, "( true ||") ||
-                 Token::simpleMatch(tok, "( false &&")) {
-            Token::eraseTokens(tok->next(), tok->link());
-            ret = true;
-        }
+    if (Settings::terminated())
+        return false;
 
-        else if (Token::simpleMatch(tok, "|| true )") ||
-                 Token::simpleMatch(tok, "&& false )")) {
-            tok = tok->next();
-            Token::eraseTokens(tok->next()->link(), tok);
-            ret = true;
-        }
+    // simplify bit fields..
+    simplifyBitfields();
 
-        else if (Token::simpleMatch(tok, "&& false &&") ||
-                 Token::simpleMatch(tok, "|| true ||")) {
-            //goto '('
-            Token *tok2 = tok;
-            while (tok2->previous()) {
-                if (tok2->previous()->str() == ")")
-                    tok2 = tok2->previous()->link();
-                else {
-                    tok2 = tok2->previous();
-                    if (tok2->str() == "(")
-                        break;
-                }
-            }
-            if (!tok2)
-                continue;
-            //move tok to 'true|false' position
-            tok = tok->next();
-            //remove everything before 'true|false'
-            Token::eraseTokens(tok2, tok);
-            //remove everything after 'true|false'
-            Token::eraseTokens(tok, tok2->link());
-            ret = true;
-        }
+    if (Settings::terminated())
+        return false;
 
-        // Change numeric constant in condition to "true" or "false"
-        if (Token::Match(tok, "if|while ( %num% )|%oror%|&&")) {
-            tok->tokAt(2)->str((tok->strAt(2) != "0") ? "true" : "false");
-            ret = true;
-        }
-        if (Token::Match(tok, "&&|%oror% %num% )|%oror%|&&")) {
-            tok->next()->str((tok->next()->str() != "0") ? "true" : "false");
-            ret = true;
-        }
+    // struct simplification "struct S {} s; => struct S { } ; S s ;
+    simplifyStructDecl();
 
-        // Reduce "(%num% == %num%)" => "(true)"/"(false)"
-        if (Token::Match(tok, "&&|%oror%|(") &&
-            (Token::Match(tok->next(), "%num% %any% %num%") ||
-             Token::Match(tok->next(), "%bool% %any% %bool%")) &&
-            Token::Match(tok->tokAt(4), "&&|%oror%|)|?")) {
-            std::string cmp = tok->strAt(2);
-            bool result = false;
-            if (tok->next()->isNumber()) {
-                // Compare numbers
+    if (Settings::terminated())
+        return false;
 
-                if (cmp == "==" || cmp == "!=") {
-                    const std::string& op1(tok->next()->str());
-                    const std::string& op2(tok->strAt(3));
+    // x = ({ 123; });  =>   { x = 123; }
+    simplifyAssignmentBlock();
 
-                    bool eq = false;
-                    if (MathLib::isInt(op1) && MathLib::isInt(op2))
-                        eq = (MathLib::toLongNumber(op1) == MathLib::toLongNumber(op2));
-                    else {
-                        eq = (op1 == op2);
+    if (Settings::terminated())
+        return false;
 
-                        // It is inconclusive whether two unequal float representations are numerically equal
-                        if (!eq && MathLib::isFloat(op1))
-                            cmp.clear();
-                    }
+    simplifyVariableMultipleAssign();
 
-                    if (cmp == "==")
-                        result = eq;
-                    else
-                        result = !eq;
-                } else {
-                    const double op1 = MathLib::toDoubleNumber(tok->next()->str());
-                    const double op2 = MathLib::toDoubleNumber(tok->strAt(3));
-                    if (cmp == ">=")
-                        result = (op1 >= op2);
-                    else if (cmp == ">")
-                        result = (op1 > op2);
-                    else if (cmp == "<=")
-                        result = (op1 <= op2);
-                    else if (cmp == "<")
-                        result = (op1 < op2);
-                    else
-                        cmp.clear();
-                }
-            } else {
-                // Compare boolean
-                const bool op1 = (tok->next()->str() == std::string("true"));
-                const bool op2 = (tok->strAt(3) == std::string("true"));
-
-                if (cmp == "==")
-                    result = (op1 == op2);
-                else if (cmp == "!=")
-                    result = (op1 != op2);
-                else if (cmp == ">=")
-                    result = (op1 >= op2);
-                else if (cmp == ">")
-                    result = (op1 > op2);
-                else if (cmp == "<=")
-                    result = (op1 <= op2);
-                else if (cmp == "<")
-                    result = (op1 < op2);
-                else
-                    cmp.clear();
-            }
+    // Collapse operator name tokens into single token
+    // operator = => operator=
+    simplifyOperatorName();
 
-            if (! cmp.empty()) {
-                tok = tok->next();
-                tok->deleteNext(2);
+    // Remove redundant parentheses
+    simplifyRedundantParentheses();
 
-                tok->str(result ? "true" : "false");
-                ret = true;
-            }
-        }
+    if (isCPP()) {
+        simplifyTypeIntrinsics();
+
+        // Handle templates..
+        Timer::run("Tokenizer::simplifyTokens1::simplifyTokenList1::simplifyTemplates", showTime, mTimerResults, [&]() {
+            simplifyTemplates();
+        });
+
+        // The simplifyTemplates have inner loops
+        if (Settings::terminated())
+            return false;
+
+        validate(); // #6847 - invalid code
     }
 
-    return ret;
-}
+    // Simplify pointer to standard types (C only)
+    simplifyPointerToStandardType();
 
-bool Tokenizer::simplifyConstTernaryOp()
-{
-    bool ret = false;
-    const Token *templateParameterEnd = nullptr; // The end of the current template parameter list, if any
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (tok->str() == "<" && TemplateSimplifier::templateParameters(tok))
-            templateParameterEnd = tok->findClosingBracket();
-        if (tok == templateParameterEnd)
-            templateParameterEnd = nullptr; // End of the current template parameter list
-        if (tok->str() != "?")
-            continue;
+    // simplify function pointers
+    simplifyFunctionPointers();
 
-        if (!Token::Match(tok->tokAt(-2), "<|=|,|(|[|{|}|;|case|return %bool%|%num%") &&
-            !Token::Match(tok->tokAt(-4), "<|=|,|(|[|{|}|;|case|return ( %bool%|%num% )"))
-            continue;
+    // Change initialisation of variable to assignment
+    simplifyInitVar();
+
+    // Split up variable declarations.
+    simplifyVarDecl(false);
 
-        const int offset = (tok->previous()->str() == ")") ? 2 : 1;
+    elseif();
 
-        if (tok->strAt(-2*offset) == "<") {
-            if (isC() || !TemplateSimplifier::templateParameters(tok->tokAt(-2*offset)))
-                continue; // '<' is less than; the condition is not a constant
-        }
+    validate(); // #6772 "segmentation fault (invalid code) in Tokenizer::setVarId"
 
-        // Find the token ":" then go to the next token
-        Token *colon = skipTernaryOp(tok);
-        if (!colon || colon->previous()->str() != ":" || !colon->next())
-            continue;
+    Timer::run("Tokenizer::simplifyTokens1::simplifyTokenList1::setVarId", showTime, mTimerResults, [&](){
+        setVarId();
+    });
 
-        //handle the GNU extension: "x ? : y" <-> "x ? x : y"
-        if (colon->previous() == tok->next())
-            tok->insertToken(tok->strAt(-offset));
+    // Link < with >
+    createLinks2();
 
-        // go back before the condition, if possible
-        tok = tok->tokAt(-2);
-        if (offset == 2) {
-            // go further back before the "("
-            tok = tok->tokAt(-2);
-            //simplify the parentheses
-            tok->deleteNext();
-            tok->next()->deleteNext();
-        }
+    // Mark C++ casts
+    markCppCasts();
 
-        if (Token::Match(tok->next(), "false|0")) {
-            // Use code after colon, remove code before it.
-            Token::eraseTokens(tok, colon);
+    // specify array size
+    arraySize();
 
-            tok = tok->next();
-            ret = true;
-        }
+    // The simplify enum might have inner loops
+    if (Settings::terminated())
+        return false;
 
-        // The condition is true. Delete the operator after the ":"..
-        else {
-            // delete the condition token and the "?"
-            tok->deleteNext(2);
+    // Add std:: in front of std classes, when using namespace std; was given
+    simplifyNamespaceStd();
 
-            int ternaryOplevel = 0;
-            for (const Token *endTok = colon; endTok; endTok = endTok->next()) {
-                if (Token::Match(endTok, "(|[|{"))
-                    endTok = endTok->link();
-                else if (endTok->str() == "<" && (endTok->strAt(1) == ">" || TemplateSimplifier::templateParameters(endTok)))
-                    endTok = endTok->findClosingBracket();
-                else if (endTok->str() == "?")
-                    ++ternaryOplevel;
-                else if (Token::Match(endTok, ")|}|]|;|,|:|>")) {
-                    if (endTok->str() == ":" && ternaryOplevel)
-                        --ternaryOplevel;
-                    else if (endTok->str() == ">" && !templateParameterEnd)
-                        ;
-                    else {
-                        Token::eraseTokens(colon->tokAt(-2), endTok);
-                        ret = true;
-                        break;
-                    }
-                }
-            }
-        }
-    }
-    return ret;
+    // Change initialisation of variable to assignment
+    simplifyInitVar();
+
+    simplifyDoublePlusAndDoubleMinus();
+
+    simplifyArrayAccessSyntax();
+
+    Token::assignProgressValues(list.front());
+
+    removeRedundantSemicolons();
+
+    simplifyParameterVoid();
+
+    simplifyRedundantConsecutiveBraces();
+
+    simplifyEmptyNamespaces();
+
+    simplifyIfSwitchForInit();
+
+    simplifyOverloadedOperators();
+
+    validate();
+
+    list.front()->assignIndexes();
+
+    return true;
 }
+//---------------------------------------------------------------------------
+
+void Tokenizer::printDebugOutput(std::ostream &out) const
+{
+    if (!list.front())
+        return;
+
+    const bool debug = mSettings.debugSimplified || mSettings.debugnormal || mSettings.debugsymdb || mSettings.debugast || mSettings.debugvalueflow;
+    if (!debug)
+        return;
+
+    const bool xml = (mSettings.outputFormat == Settings::OutputFormat::xml);
 
-void Tokenizer::simplifyUndefinedSizeArray()
-{
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "%type%")) {
-            Token *tok2 = tok->next();
-            while (tok2 && tok2->str() == "*")
-                tok2 = tok2->next();
-            if (!Token::Match(tok2, "%name% [ ] ;|["))
-                continue;
+    if (xml)
+        out << "<debug>" << std::endl;
 
-            tok = tok2->previous();
-            Token *end = tok2->next();
-            int count = 0;
-            do {
-                end = end->tokAt(2);
-                ++count;
-            } while (Token::Match(end, "[ ] [;=[]"));
-            if (Token::Match(end, "[;=]")) {
-                do {
-                    tok2->deleteNext(2);
-                    tok->insertToken("*");
-                } while (--count);
-                tok = end;
-            } else
-                tok = tok->tokAt(3);
-        }
+    if (mSettings.debugSimplified || mSettings.debugnormal)
+        list.front()->printOut(out, xml, nullptr, list.getFiles());
+
+    if (mSymbolDatabase) {
+        if (xml)
+            mSymbolDatabase->printXml(out);
+        else if (mSettings.debugsymdb)
+            mSymbolDatabase->printOut("Symbol database");
     }
+
+    if (mSettings.debugast)
+        list.front()->printAst(xml, list.getFiles(), out);
+
+    if (mSettings.debugvalueflow)
+        list.front()->printValueFlow(list.getFiles(), xml, out);
+
+    if (xml)
+        out << "</debug>" << std::endl;
 }
 
-void Tokenizer::simplifyCasts()
+void Tokenizer::dump(std::ostream &out) const
 {
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        // Don't remove cast in such cases:
-        // *((char *)a + 1) = 0;
-        // Remove cast when casting a function pointer:
-        // (*(void (*)(char *))fp)(x);
-        if (!tok->isName() &&
-            Token::simpleMatch(tok->next(), "* (") &&
-            !Token::Match(tok->linkAt(2), ") %name%|&")) {
-            tok = tok->linkAt(2);
-            continue;
+    // Create a xml data dump.
+    // The idea is not that this will be readable for humans. It's a
+    // data dump that 3rd party tools could load and get useful info from.
+
+    std::string outs;
+
+    std::set<const Library::Container*> containers;
+
+    outs += "  <directivelist>";
+    outs += '\n';
+    for (const Directive &dir : mDirectives) {
+        outs += "    <directive ";
+        outs += "file=\"";
+        outs += ErrorLogger::toxml(Path::getRelativePath(dir.file, mSettings.basePaths));
+        outs += "\" ";
+        outs += "linenr=\"";
+        outs += std::to_string(dir.linenr);
+        outs += "\" ";
+        // str might contain characters such as '"', '<' or '>' which
+        // could result in invalid XML, so run it through toxml().
+        outs += "str=\"";
+        outs += ErrorLogger::toxml(dir.str);
+        outs +="\">";
+        outs += '\n';
+        for (const auto & strToken : dir.strTokens) {
+            outs += "      <token ";
+            outs += "column=\"";
+            outs += std::to_string(strToken.column);
+            outs += "\" ";
+            outs += "str=\"";
+            outs += ErrorLogger::toxml(strToken.tokStr);
+            outs +="\"/>";
+            outs += '\n';
+        }
+        outs += "    </directive>";
+        outs += '\n';
+    }
+    outs += "  </directivelist>";
+    outs += '\n';
+
+    // tokens..
+    outs += "  <tokenlist>";
+    outs += '\n';
+    for (const Token *tok = list.front(); tok; tok = tok->next()) {
+        outs += "    <token id=\"";
+        outs += id_string(tok);
+        outs += "\" file=\"";
+        outs += ErrorLogger::toxml(list.file(tok));
+        outs += "\" linenr=\"";
+        outs += std::to_string(tok->linenr());
+        outs += "\" column=\"";
+        outs += std::to_string(tok->column());
+        outs += "\"";
+
+        outs += " str=\"";
+        outs += ErrorLogger::toxml(tok->str());
+        outs += '\"';
+
+        outs += " scope=\"";
+        outs += id_string(tok->scope());
+        outs += '\"';
+        if (tok->isName()) {
+            outs += " type=\"name\"";
+            if (tok->isUnsigned())
+                outs += " isUnsigned=\"true\"";
+            else if (tok->isSigned())
+                outs += " isSigned=\"true\"";
+        } else if (tok->isNumber()) {
+            outs += " type=\"number\"";
+            if (MathLib::isInt(tok->str()))
+                outs += " isInt=\"true\"";
+            if (MathLib::isFloat(tok->str()))
+                outs += " isFloat=\"true\"";
+        } else if (tok->tokType() == Token::eString) {
+            outs += " type=\"string\" strlen=\"";
+            outs += std::to_string(Token::getStrLength(tok));
+            outs += '\"';
         }
-        // #3935 : don't remove cast in such cases:
-        // ((char *)a)[1] = 0;
-        if (tok->str() == "(" && Token::simpleMatch(tok->link(), ") [")) {
-            tok = tok->link();
-            continue;
+        else if (tok->tokType() == Token::eChar)
+            outs += " type=\"char\"";
+        else if (tok->isBoolean())
+            outs += " type=\"boolean\"";
+        else if (tok->isOp()) {
+            outs += " type=\"op\"";
+            if (tok->isArithmeticalOp())
+                outs += " isArithmeticalOp=\"true\"";
+            else if (tok->isAssignmentOp())
+                outs += " isAssignmentOp=\"true\"";
+            else if (tok->isComparisonOp())
+                outs += " isComparisonOp=\"true\"";
+            else if (tok->tokType() == Token::eLogicalOp)
+                outs += " isLogicalOp=\"true\"";
+        }
+        if (tok->isCast())
+            outs += " isCast=\"true\"";
+        if (tok->isExternC())
+            outs += " externLang=\"C\"";
+        if (tok->isExpandedMacro())
+            outs += " macroName=\"" + tok->getMacroName() + "\"";
+        if (tok->isTemplateArg()) {
+            outs += " isTemplateArg=\"true\"";
+            outs += " templateArgFileIndex=\"" + std::to_string(tok->templateArgFileIndex()) + "\"";
+            outs += " templateArgLineNumber=\"" + std::to_string(tok->templateArgLineNumber()) + "\"";
+            outs += " templateArgColumn=\"" + std::to_string(tok->templateArgColumn()) + "\"";
+        }
+        if (tok->isRemovedVoidParameter())
+            outs += " isRemovedVoidParameter=\"true\"";
+        if (tok->isSplittedVarDeclComma())
+            outs += " isSplittedVarDeclComma=\"true\"";
+        if (tok->isSplittedVarDeclEq())
+            outs += " isSplittedVarDeclEq=\"true\"";
+        if (tok->isImplicitInt())
+            outs += " isImplicitInt=\"true\"";
+        if (tok->isComplex())
+            outs += " isComplex=\"true\"";
+        if (tok->isRestrict())
+            outs += " isRestrict=\"true\"";
+        if (tok->isAtomic())
+            outs += " isAtomic=\"true\"";
+        if (tok->isAttributeExport())
+            outs += " isAttributeExport=\"true\"";
+        if (tok->isAttributeMaybeUnused())
+            outs += " isAttributeMaybeUnused=\"true\"";
+        if (tok->isAttributeUnused())
+            outs += " isAttributeUnused=\"true\"";
+        if (tok->isAttributeFallthrough())
+            outs += " isAttributeFallthrough=\"true\"";
+        if (tok->isInitBracket())
+            outs += " isInitBracket=\"true\"";
+        if (tok->isAnonymous())
+            outs += " isAnonymous=\"true\"";
+        if (tok->hasAttributeAlignas()) {
+            const std::vector<std::string>& a = tok->getAttributeAlignas();
+            outs += " alignas=\"" + ErrorLogger::toxml(a[0]) + "\"";
+            if (a.size() > 1)
+                // we could write all alignas expressions but currently we only need 2
+                outs += " alignas2=\"" + ErrorLogger::toxml(a[1]) + "\"";
+        }
+        if (tok->link()) {
+            outs += " link=\"";
+            outs += id_string(tok->link());
+            outs += '\"';
+        }
+        if (tok->varId() > 0) {
+            outs += " varId=\"";
+            outs += std::to_string(tok->varId());
+            outs += '\"';
+        }
+        if (tok->exprId() > 0) {
+            outs += " exprId=\"";
+            outs += std::to_string(tok->exprId());
+            outs += '\"';
+        }
+        if (tok->variable()) {
+            outs += " variable=\"";
+            outs += id_string(tok->variable());
+            outs += '\"';
+        }
+        if (tok->function()) {
+            outs += " function=\"";
+            outs += id_string(tok->function());
+            outs += '\"';
+        }
+        if (!tok->values().empty()) {
+            outs += " values=\"";
+            outs += id_string(&tok->values());
+            outs += '\"';
+        }
+        if (tok->type()) {
+            outs += " type-scope=\"";
+            outs += id_string(tok->type()->classScope);
+            outs += '\"';
+        }
+        if (tok->astParent()) {
+            outs += " astParent=\"";
+            outs += id_string(tok->astParent());
+            outs += '\"';
+        }
+        if (tok->astOperand1()) {
+            outs += " astOperand1=\"";
+            outs += id_string(tok->astOperand1());
+            outs += '\"';
+        }
+        if (tok->astOperand2()) {
+            outs += " astOperand2=\"";
+            outs += id_string(tok->astOperand2());
+            outs += '\"';
+        }
+        if (!tok->originalName().empty()) {
+            outs += " originalName=\"";
+            outs += tok->originalName();
+            outs += '\"';
         }
-        // #4164 : ((unsigned char)1) => (1)
-        if (Token::Match(tok->next(), "( %type% ) %num%") && tok->next()->link()->previous()->isStandardType()) {
-            const MathLib::bigint value = MathLib::toLongNumber(tok->next()->link()->next()->str());
-            int bits = mSettings->char_bit * mTypeSize[tok->next()->link()->previous()->str()];
-            if (!tok->tokAt(2)->isUnsigned() && bits > 0)
-                bits--;
-            if (bits < 31 && value >= 0 && value < (1LL << bits)) {
-                tok->linkAt(1)->next()->isCast(true);
-                Token::eraseTokens(tok, tok->next()->link()->next());
+        if (tok->valueType()) {
+            const std::string vt = tok->valueType()->dump();
+            if (!vt.empty()) {
+                outs += ' ';
+                outs += vt;
+            }
+            containers.insert(tok->valueType()->container);
+        }
+        if (!tok->varId() && tok->scope()->isExecutable() && Token::Match(tok, "%name% (")) {
+            if (mSettings.library.isnoreturn(tok))
+                outs += " noreturn=\"true\"";
+        }
+
+        outs += "/>";
+        outs += '\n';
+    }
+    outs += "  </tokenlist>";
+    outs += '\n';
+
+    out << outs;
+    outs.clear();
+
+    if (mSymbolDatabase)
+        mSymbolDatabase->printXml(out);
+
+    containers.erase(nullptr);
+    if (!containers.empty()) {
+        outs += "  <containers>";
+        outs += '\n';
+        for (const Library::Container* c: containers) {
+            outs += "    <container id=\"";
+            outs += id_string(c);
+            outs += "\" array-like-index-op=\"";
+            outs += bool_to_string(c->arrayLike_indexOp);
+            outs += "\" ";
+            outs += "std-string-like=\"";
+            outs += bool_to_string(c->stdStringLike);
+            outs += "\"";
+            if (c->functions.empty()) {
+                outs += "/>\n";
+                continue;
             }
-            continue;
+            outs += ">\n";
+            for (const auto& fp: c->functions) {
+                std::string action;
+                std::string yield;
+                if (fp.second.action != Library::Container::Action::NO_ACTION)
+                    action = " action=\"" + Library::Container::toString(fp.second.action) + "\"";
+                if (fp.second.yield != Library::Container::Yield::NO_YIELD)
+                    yield = " yield=\"" + Library::Container::toString(fp.second.yield) + "\"";
+                if (!action.empty() || !yield.empty())
+                    outs += "      <f name=\"" + fp.first + "\"" + action + yield + "/>\n";
+            }
+            outs += "    </container>\n";
         }
+        outs += "  </containers>";
+        outs += '\n';
+    }
 
-        while ((Token::Match(tok->next(), "( %type% *| *| *|&| ) *|&| %name%") && (tok->str() != ")" || tok->tokAt(2)->isStandardType())) ||
-               Token::Match(tok->next(), "( const| %type% * *| *|&| ) *|&| %name%") ||
-               Token::Match(tok->next(), "( const| %type% %type% *| *| *|&| ) *|&| %name%") ||
-               (!tok->isName() && (Token::Match(tok->next(), "( %type% * *| *|&| ) (") ||
-                                   Token::Match(tok->next(), "( const| %type% %type% * *| *|&| ) (")))) {
-            if (tok->isName() && tok->str() != "return")
-                break;
+    if (list.front())
+        list.front()->printValueFlow(list.getFiles(), true, out);
 
-            if (isCPP() && tok->strAt(-1) == "operator")
-                break;
+    outs += dumpTypedefInfo();
 
-            // Remove cast..
-            Token::eraseTokens(tok, tok->next()->link()->next());
+    outs += mTemplateSimplifier->dump();
+    if (!mTemplateVarIdUsage.empty()) {
+        outs += "  <template-varid-usage>\n";
+        for (nonneg int id: mTemplateVarIdUsage)
+            outs += "    <var id=\"" + std::to_string(id) + "\"/>\n";
+        outs += "  </template-varid-usage>\n";
+    }
 
-            // Set isCasted flag.
-            Token *tok2 = tok->next();
-            if (!Token::Match(tok2, "%name% [|."))
-                tok2->isCast(true);
-            else {
-                // TODO: handle more complex expressions
-                tok2->next()->isCast(true);
-            }
+    out << outs;
+}
 
-            // Remove '* &'
-            if (Token::simpleMatch(tok, "* &")) {
-                tok->deleteNext();
-                tok->deleteThis();
-            }
+std::string Tokenizer::dumpTypedefInfo() const
+{
+    if (mTypedefInfo.empty())
+        return "";
+    std::string outs = "  <typedef-info>";
+    outs += '\n';
+    for (const TypedefInfo &typedefInfo: mTypedefInfo) {
+        const bool toks = !typedefInfo.typedefInfoTokens.empty();
+        outs += "    <info";
 
-            if (tok->str() == ")" && tok->link()->previous()) {
-                // If there was another cast before this, go back
-                // there to check it also. e.g. "(int)(char)x"
-                tok = tok->link()->previous();
-            }
-        }
+        outs += " name=\"";
+        outs += typedefInfo.name;
+        outs += "\"";
 
-        // Replace pointer casts of 0.. "(char *)0" => "0"
-        while (Token::Match(tok->next(), "( %type% %type%| * *| ) 0")) {
-            tok->linkAt(1)->next()->isCast(true);
-            Token::eraseTokens(tok, tok->next()->link()->next());
-            if (tok->str() == ")" && tok->link()->previous()) {
-                // If there was another cast before this, go back
-                // there to check it also. e.g. "(char*)(char*)0"
-                tok = tok->link()->previous();
-            }
-        }
+        outs += " file=\"";
+        outs += ErrorLogger::toxml(typedefInfo.filename);
+        outs += "\"";
 
-        if (Token::Match(tok->next(), "dynamic_cast|reinterpret_cast|const_cast|static_cast <")) {
-            Token *tok2 = tok->linkAt(2);
-            if (!Token::simpleMatch(tok2, "> ("))
-                break;
+        outs += " line=\"";
+        outs += std::to_string(typedefInfo.lineNumber);
+        outs += "\"";
+
+        outs += " column=\"";
+        outs += std::to_string(typedefInfo.column);
+        outs += "\"";
+        if (typedefInfo.tagLine > -1 && typedefInfo.tagColumn > -1) {
+            outs += " tagline=\"";
+            outs += std::to_string(typedefInfo.tagLine);
+            outs += "\"";
+
+            outs += " tagcolumn=\"";
+            outs += std::to_string(typedefInfo.tagColumn);
+            outs += "\"";
+        }
+        outs += " used=\"";
+        outs += std::to_string(typedefInfo.used?1:0);
+        outs += "\"";
 
-            tok2->tokAt(2)->isCast(true);
-            Token::eraseTokens(tok, tok2->next());
+        outs += " isFunctionPointer=\"";
+        outs += std::to_string(typedefInfo.isFunctionPointer);
+        outs += "\"";
+        if (toks)
+            outs += ">";
+        else
+            outs += "/>";
+        outs += '\n';
+        for (const auto& t : typedefInfo.typedefInfoTokens) {
+            outs += "      <token ";
+            outs += "line=\"";
+            outs += std::to_string(t.lineNumber);
+            outs += "\" ";
+            outs += "column=\"";
+            outs += std::to_string(t.column);
+            outs += "\" ";
+            outs += "str=\"";
+            outs += ErrorLogger::toxml(t.name);
+            outs += "\"/>";
+            outs += '\n';
         }
+        if (toks)
+            outs += "    </info>\n";
     }
-}
+    outs += "  </typedef-info>";
+    outs += '\n';
 
+    return outs;
+}
 
-void Tokenizer::simplifyFunctionParameters()
+void Tokenizer::simplifyHeadersAndUnusedTemplates()
 {
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (tok->link() && Token::Match(tok, "{|[|(")) {
-            tok = tok->link();
-        }
-
-        // Find the function e.g. foo( x ) or foo( x, y )
-        else if (Token::Match(tok, "%name% ( %name% [,)]") &&
-                 !(tok->strAt(-1) == ":" || tok->strAt(-1) == ",")) {
-            // We have found old style function, now we need to change it
+    if (mSettings.checkHeaders && mSettings.checkUnusedTemplates)
+        // Full analysis. All information in the headers are kept.
+        return;
 
-            // First step: Get list of argument names in parentheses
-            std::map<std::string, Token *> argumentNames;
-            bool bailOut = false;
-            Token * tokparam = nullptr;
+    const bool checkHeaders = mSettings.checkHeaders;
+    const bool removeUnusedIncludedFunctions = !mSettings.checkHeaders;
+    const bool removeUnusedIncludedClasses   = !mSettings.checkHeaders;
+    const bool removeUnusedIncludedTemplates = !mSettings.checkUnusedTemplates || !mSettings.checkHeaders;
+    const bool removeUnusedTemplates = !mSettings.checkUnusedTemplates;
 
-            //take count of the function name..
-            const std::string& funcName(tok->str());
+    // checkHeaders:
+    //
+    // If it is true then keep all code in the headers. It's possible
+    // to remove unused types/variables if false positives / false
+    // negatives can be avoided.
+    //
+    // If it is false, then we want to remove selected stuff from the
+    // headers but not *everything*. The intention here is to not damage
+    // the analysis of the source file. You should get all warnings in
+    // the source file. You should not get false positives.
 
-            //floating token used to check for parameters
-            Token *tok1 = tok;
+    // functions and types to keep
+    std::set<std::string> keep;
+    for (const Token *tok = list.front(); tok; tok = tok->next()) {
+        if (tok->isCpp() && Token::simpleMatch(tok, "template <")) {
+            const Token *closingBracket = tok->next()->findClosingBracket();
+            if (Token::Match(closingBracket, "> class|struct %name% {"))
+                tok = closingBracket->linkAt(3);
+        }
 
-            while (nullptr != (tok1 = tok1->tokAt(2))) {
-                if (!Token::Match(tok1, "%name% [,)]")) {
-                    bailOut = true;
-                    break;
-                }
+        if (!tok->isName() || tok->isKeyword())
+            continue;
 
-                //same parameters: take note of the parameter
-                if (argumentNames.find(tok1->str()) != argumentNames.end())
-                    tokparam = tok1;
-                else if (tok1->str() != funcName)
-                    argumentNames[tok1->str()] = tok1;
-                else {
-                    if (tok1->next()->str() == ")") {
-                        if (tok1->previous()->str() == ",") {
-                            tok1 = tok1->tokAt(-2);
-                            tok1->deleteNext(2);
-                        } else {
-                            tok1 = tok1->previous();
-                            tok1->deleteNext();
-                            bailOut = true;
-                            break;
-                        }
-                    } else {
-                        tok1 = tok1->tokAt(-2);
-                        tok1->next()->deleteNext(2);
-                    }
-                }
+        if (!checkHeaders && tok->fileIndex() != 0)
+            continue;
 
-                if (tok1->next()->str() == ")") {
-                    tok1 = tok1->tokAt(2);
-                    //expect at least a type name after round brace..
-                    if (!tok1 || !tok1->isName())
-                        bailOut = true;
-                    break;
-                }
-            }
+        if (Token::Match(tok, "%name% (") && !Token::simpleMatch(tok->linkAt(1), ") {")) {
+            keep.insert(tok->str());
+            continue;
+        }
 
-            //goto '('
-            tok = tok->next();
+        if (Token::Match(tok, "%name% %name%|::|*|&|<")) {
+            keep.insert(tok->str());
+        }
+    }
 
-            if (bailOut) {
-                tok = tok->link();
-                continue;
-            }
+    const std::set<std::string> functionStart{"static", "const", "unsigned", "signed", "void", "bool", "char", "short", "int", "long", "float", "*"};
+    bool goBack = false;
 
-            tok1 = tok->link()->next();
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        const bool isIncluded = (tok->fileIndex() != 0);
 
-            // there should be the sequence '; {' after the round parentheses
-            for (const Token* tok2 = tok1; tok2; tok2 = tok2->next()) {
-                if (Token::simpleMatch(tok2, "; {"))
-                    break;
-                else if (tok2->str() == "{") {
-                    bailOut = true;
-                    break;
-                }
-            }
+        if (goBack) {
+            tok = tok->previous();
+        }
+        goBack = false;
 
-            if (bailOut) {
-                tok = tok->link();
-                continue;
+        // Remove executable code
+        if (isIncluded && !mSettings.checkHeaders && tok->str() == "{") {
+            // TODO: We probably need to keep the executable code if this function is called from the source file.
+            const Token *prev = tok->previous();
+            while (prev && prev->isName())
+                prev = prev->previous();
+            if (Token::simpleMatch(prev, ")")) {
+                // Replace all tokens from { to } with a ";".
+                Token::eraseTokens(tok,tok->link()->next());
+                tok->str(";");
+                tok->link(nullptr);
             }
+        }
 
-            // Last step: check out if the declarations between ')' and '{' match the parameters list
-            std::map<std::string, Token *> argumentNames2;
-
-            while (tok1 && tok1->str() != "{") {
-                if (Token::Match(tok1, "(|)")) {
-                    bailOut = true;
-                    break;
-                }
-                if (tok1->str() == ";") {
-                    if (tokparam) {
-                        syntaxError(tokparam);
-                    }
-                    Token *tok2 = tok1->previous();
-                    while (tok2->str() == "]")
-                        tok2 = tok2->link()->previous();
-
-                    //it should be a name..
-                    if (!tok2->isName()) {
-                        bailOut = true;
-                        break;
-                    }
-
-                    if (argumentNames2.find(tok2->str()) != argumentNames2.end()) {
-                        //same parameter names...
-                        syntaxError(tok1);
+        if (!tok->previous() || Token::Match(tok->previous(), "[;{}]")) {
+            // Remove unused function declarations
+            if (isIncluded && removeUnusedIncludedFunctions) {
+                while (true) {
+                    Token *start = tok;
+                    while (start && functionStart.find(start->str()) != functionStart.end())
+                        start = start->next();
+                    if (Token::Match(start, "%name% (") && Token::Match(start->linkAt(1), ") const| ;") && keep.find(start->str()) == keep.end()) {
+                        Token::eraseTokens(tok, start->linkAt(1)->tokAt(2));
+                        tok->deleteThis();
                     } else
-                        argumentNames2[tok2->str()] = tok2;
-
-                    if (argumentNames.find(tok2->str()) == argumentNames.end()) {
-                        //non-matching parameter... bailout
-                        bailOut = true;
                         break;
-                    }
                 }
-                tok1 = tok1->next();
             }
 
-            if (bailOut || !tok1) {
-                tok = tok->link();
-                continue;
-            }
-
-            //the two containers may not hold the same size...
-            //in that case, the missing parameters are defined as 'int'
-            if (argumentNames.size() != argumentNames2.size()) {
-                //move back 'tok1' to the last ';'
-                tok1 = tok1->previous();
-                for (std::map<std::string, Token *>::iterator it = argumentNames.begin(); it != argumentNames.end(); ++it) {
-                    if (argumentNames2.find(it->first) == argumentNames2.end()) {
-                        //add the missing parameter argument declaration
-                        tok1->insertToken(";");
-                        tok1->insertToken(it->first);
-                        //register the change inside argumentNames2
-                        argumentNames2[it->first] = tok1->next();
-                        tok1->insertToken("int");
+            if (isIncluded && removeUnusedIncludedClasses) {
+                if (Token::Match(tok, "class|struct %name% [:{]") && keep.find(tok->strAt(1)) == keep.end()) {
+                    // Remove this class/struct
+                    const Token *endToken = tok->tokAt(2);
+                    if (endToken->str() == ":") {
+                        endToken = endToken->next();
+                        while (Token::Match(endToken, "%name%|,"))
+                            endToken = endToken->next();
+                    }
+                    if (endToken && endToken->str() == "{" && Token::simpleMatch(endToken->link(), "} ;")) {
+                        Token::eraseTokens(tok, endToken->link()->next());
+                        tok->deleteThis();
                     }
                 }
             }
 
-            while (tok->str() != ")") {
-                //initialize start and end tokens to be moved
-                Token *declStart = argumentNames2[tok->next()->str()];
-                Token *declEnd = declStart;
-                while (declStart->previous()->str() != ";" && declStart->previous()->str() != ")")
-                    declStart = declStart->previous();
-                while (declEnd->next()->str() != ";" && declEnd->next()->str() != "{")
-                    declEnd = declEnd->next();
-
-                //remove ';' after declaration
-                declEnd->deleteNext();
-
-                //replace the parameter name in the parentheses with all the declaration
-                Token::replace(tok->next(), declStart, declEnd);
-
-                //since there are changes to tokens, put tok where tok1 is
-                tok = declEnd->next();
+            if (removeUnusedTemplates || (isIncluded && removeUnusedIncludedTemplates)) {
+                if (Token::Match(tok, "template < %name%")) {
+                    const Token *closingBracket = tok->next()->findClosingBracket();
+                    if (Token::Match(closingBracket, "> class|struct %name% [;:{]") && keep.find(closingBracket->strAt(2)) == keep.end()) {
+                        const Token *endToken = closingBracket->tokAt(3);
+                        if (endToken->str() == ":") {
+                            endToken = endToken->next();
+                            while (Token::Match(endToken, "%name%|,"))
+                                endToken = endToken->next();
+                        }
+                        if (endToken && endToken->str() == "{")
+                            endToken = endToken->link()->next();
+                        if (endToken && endToken->str() == ";") {
+                            Token::eraseTokens(tok, endToken);
+                            tok->deleteThis();
+                        }
+                    } else if (Token::Match(closingBracket, "> %type% %name% (") && Token::simpleMatch(closingBracket->linkAt(3), ") {") && keep.find(closingBracket->strAt(2)) == keep.end()) {
+                        const Token *endToken = closingBracket->linkAt(3)->linkAt(1)->next();
+                        Token::eraseTokens(tok, endToken);
+                        tok->deleteThis();
+                        goBack = true;
+                    }
+                }
             }
-            //goto forward and continue
-            tok = tok->next()->link();
         }
     }
 }
 
-void Tokenizer::simplifyPointerToStandardType()
+void Tokenizer::removeExtraTemplateKeywords()
 {
-    if (!isC())
-        return;
+    if (isCPP()) {
+        for (Token *tok = list.front(); tok; tok = tok->next()) {
+            if (Token::Match(tok, "%name%|>|) .|:: template %name%")) {
+                tok->next()->deleteNext();
+                Token* templateName = tok->tokAt(2);
+                while (Token::Match(templateName, "%name%|::")) {
+                    templateName->isTemplate(true);
+                    templateName = templateName->next();
+                }
+                if (!templateName)
+                    syntaxError(tok);
+                if (Token::Match(templateName->previous(), "operator %op%|(")) {
+                    templateName->isTemplate(true);
+                    if (templateName->str() == "(" && templateName->link())
+                        templateName->link()->isTemplate(true);
+                }
+            }
+        }
+    }
+}
 
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (!Token::Match(tok, "& %name% [ 0 ] !!["))
-            continue;
+static std::string getExpression(const Token *tok)
+{
+    std::string line;
+    for (const Token *prev = tok->previous(); prev && !Token::Match(prev, "[;{}]"); prev = prev->previous())
+        line = prev->str() + " " + line;
+    line += "!!!" + tok->str() + "!!!";
+    for (const Token *next = tok->next(); next && !Token::Match(next, "[;{}]"); next = next->next())
+        line += " " + next->str();
+    return line;
+}
 
-        if (!Token::Match(tok->previous(), "[,(=]"))
-            continue;
+void Tokenizer::splitTemplateRightAngleBrackets(bool check)
+{
+    std::vector<std::pair<std::string, int>> vars;
 
-        // Remove '[ 0 ]' suffix
-        Token::eraseTokens(tok->next(), tok->tokAt(5));
-        // Remove '&' prefix
-        tok = tok->previous();
-        if (!tok)
-            break;
-        tok->deleteNext();
+    int scopeLevel = 0;
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (tok->str() == "{")
+            ++scopeLevel;
+        else if (tok->str() == "}") {
+            vars.erase(std::remove_if(vars.begin(), vars.end(), [scopeLevel](const std::pair<std::string, int>& v) {
+                return v.second == scopeLevel;
+            }), vars.end());
+            --scopeLevel;
+        }
+        if (Token::Match(tok, "[;{}] %type% %type% [;,=]") && tok->next()->isStandardType())
+            vars.emplace_back(tok->strAt(2), scopeLevel);
+
+        // Ticket #6181: normalize C++11 template parameter list closing syntax
+        if (tok->previous() && tok->str() == "<" && TemplateSimplifier::templateParameters(tok) && std::none_of(vars.begin(), vars.end(), [&](const std::pair<std::string, int>& v) {
+            return v.first == tok->strAt(-1);
+        })) {
+            Token *endTok = tok->findClosingBracket();
+            if (check) {
+                if (Token::Match(endTok, ">>|>>="))
+                    reportError(tok, Severity::debug, "dacaWrongSplitTemplateRightAngleBrackets", "bad closing bracket for !!!<!!!: " + getExpression(tok), false);
+                continue;
+            }
+            if (endTok && endTok->str() == ">>") {
+                endTok->str(">");
+                endTok->insertToken(">");
+            } else if (endTok && endTok->str() == ">>=") {
+                endTok->str(">");
+                endTok->insertToken("=");
+                endTok->insertToken(">");
+            }
+        } else if (Token::Match(tok, "class|struct|union|=|:|public|protected|private %name% <") && std::none_of(vars.begin(), vars.end(), [&](const std::pair<std::string, int>& v) {
+            return v.first == tok->strAt(1);
+        })) {
+            Token *endTok = tok->tokAt(2)->findClosingBracket();
+            if (check) {
+                if (Token::simpleMatch(endTok, ">>"))
+                    reportError(tok, Severity::debug, "dacaWrongSplitTemplateRightAngleBrackets", "bad closing bracket for !!!<!!!: " + getExpression(tok), false);
+                continue;
+            }
+            if (Token::Match(endTok, ">> ;|{|%type%")) {
+                endTok->str(">");
+                endTok->insertToken(">");
+            }
+        }
     }
 }
 
-void Tokenizer::simplifyFunctionPointers()
+void Tokenizer::removeMacrosInGlobalScope()
 {
     for (Token *tok = list.front(); tok; tok = tok->next()) {
-        // #2873 - do not simplify function pointer usage here:
-        // (void)(xy(*p)(0));
-        if (Token::simpleMatch(tok, ") (")) {
-            tok = tok->next()->link();
-            continue;
+        if (tok->str() == "(") {
+            tok = tok->link();
+            if (Token::Match(tok, ") %type% {") &&
+                !tok->next()->isStandardType() &&
+                !tok->next()->isKeyword() &&
+                !Token::Match(tok->next(), "override|final") &&
+                tok->next()->isUpperCaseName())
+                tok->deleteNext();
         }
 
-        // check for function pointer cast
-        if (Token::Match(tok, "( %type% %type%| *| *| ( * ) (") ||
-            Token::Match(tok, "static_cast < %type% %type%| *| *| ( * ) (")) {
-            Token *tok1 = tok;
+        if (Token::Match(tok, "%type%") && tok->isUpperCaseName() &&
+            (!tok->previous() || Token::Match(tok->previous(), "[;{}]") || (tok->previous()->isName() && endsWith(tok->strAt(-1), ':')))) {
+            const Token *tok2 = tok->next();
+            if (tok2 && tok2->str() == "(")
+                tok2 = tok2->link()->next();
 
-            if (isCPP() && tok1->str() == "static_cast")
-                tok1 = tok1->next();
+            // Several unknown macros...
+            while (Token::Match(tok2, "%type% (") && tok2->isUpperCaseName())
+                tok2 = tok2->linkAt(1)->next();
 
-            tok1 = tok1->next();
+            if (Token::Match(tok, "%name% (") && Token::Match(tok2, "%name% *|&|::|<| %name%") &&
+                !Token::Match(tok2, "requires|namespace|class|struct|union|private:|protected:|public:"))
+                unknownMacroError(tok);
 
-            if (Token::Match(tok1->next(), "%type%"))
-                tok1 = tok1->next();
+            if (Token::Match(tok, "%type% (") && Token::Match(tok2, "%type% (") && !Token::Match(tok2, "noexcept|throw") && TokenList::isFunctionHead(tok2->next(), ":;{"))
+                unknownMacroError(tok);
 
-            while (tok1->next()->str() == "*")
-                tok1 = tok1->next();
+            // remove unknown macros before namespace|class|struct|union
+            if (Token::Match(tok2, "namespace|class|struct|union")) {
+                // is there a "{" for?
+                const Token *tok3 = tok2;
+                while (tok3 && !Token::Match(tok3,"[;{}()]"))
+                    tok3 = tok3->next();
+                if (tok3 && tok3->str() == "{") {
+                    Token::eraseTokens(tok, tok2);
+                    tok->deleteThis();
+                }
+                continue;
+            }
 
-            // check that the cast ends
-            if (!Token::Match(tok1->linkAt(4), ") )|>"))
+            // replace unknown macros before foo(
+            /*
+                        if (Token::Match(tok2, "%type% (") && TokenList::isFunctionHead(tok2->next(), "{")) {
+                            std::string typeName;
+                            for (const Token* tok3 = tok; tok3 != tok2; tok3 = tok3->next())
+                                typeName += tok3->str();
+                            Token::eraseTokens(tok, tok2);
+                            tok->str(typeName);
+                        }
+             */
+            // remove unknown macros before foo::foo(
+            if (Token::Match(tok2, "%type% :: %type%")) {
+                const Token *tok3 = tok2;
+                while (Token::Match(tok3, "%type% :: %type% ::"))
+                    tok3 = tok3->tokAt(2);
+                if (Token::Match(tok3, "%type% :: %type% (") && tok3->str() == tok3->strAt(2)) {
+                    Token::eraseTokens(tok, tok2);
+                    tok->deleteThis();
+                }
                 continue;
+            }
+        }
 
-            // ok simplify this function pointer cast to an ordinary pointer cast
-            tok1->deleteNext();
-            tok1->next()->deleteNext();
-            Token::eraseTokens(tok1->next(), tok1->linkAt(2)->next());
-            continue;
+        // Skip executable scopes
+        if (tok->str() == "{") {
+            const Token *prev = tok->previous();
+            while (prev && prev->isName())
+                prev = prev->previous();
+            if (prev && prev->str() == ")")
+                tok = tok->link();
         }
+    }
+}
 
-        // check for start of statement
-        else if (tok->previous() && !Token::Match(tok->previous(), "{|}|;|,|(|public:|protected:|private:"))
-            continue;
+//---------------------------------------------------------------------------
 
-        if (Token::Match(tok, "delete|else|return|throw|typedef"))
-            continue;
+void Tokenizer::removePragma()
+{
+    if (isC() && mSettings.standards.c == Standards::C89)
+        return;
+    if (isCPP() && mSettings.standards.cpp == Standards::CPP03)
+        return;
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        while (Token::simpleMatch(tok, "_Pragma (")) {
+            Token::eraseTokens(tok, tok->linkAt(1)->next());
+            tok->deleteThis();
+        }
+    }
+}
 
-        while (Token::Match(tok, "%type%|:: %type%|::"))
-            tok = tok->next();
+//---------------------------------------------------------------------------
 
-        Token *tok2 = (tok && tok->isName()) ? tok->next() : nullptr;
-        while (Token::Match(tok2, "*|&"))
-            tok2 = tok2->next();
-        if (!tok2 || tok2->str() != "(")
-            continue;
-        while (Token::Match(tok2, "(|:: %type%"))
-            tok2 = tok2->tokAt(2);
-        if (!Token::Match(tok2, "(|:: * *| %name%"))
+void Tokenizer::removeMacroInClassDef()
+{
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (!Token::Match(tok, "class|struct %name% %name% final| {|:"))
             continue;
-        tok2 = tok2->tokAt(2);
-        if (tok2->str() == "*")
-            tok2 = tok2->next();
-        while (Token::Match(tok2, "%type%|:: %type%|::"))
-            tok2 = tok2->next();
 
-        if (!Token::Match(tok2, "%name% ) (") &&
-            !Token::Match(tok2, "%name% [ ] ) (") &&
-            !(Token::Match(tok2, "%name% (") && Token::simpleMatch(tok2->linkAt(1), ") ) (")))
-            continue;
+        const bool nextIsUppercase = tok->next()->isUpperCaseName();
+        const bool afterNextIsUppercase = tok->tokAt(2)->isUpperCaseName();
+        if (nextIsUppercase && !afterNextIsUppercase)
+            tok->deleteNext();
+        else if (!nextIsUppercase && afterNextIsUppercase)
+            tok->next()->deleteNext();
+    }
+}
 
-        while (tok->str() != "(")
-            tok = tok->next();
+//---------------------------------------------------------------------------
 
-        // check that the declaration ends
-        if (!tok || !tok->link() || !tok->link()->next()) {
-            syntaxError(nullptr);
-        }
-        Token *endTok = tok->link()->next()->link();
-        if (Token::simpleMatch(endTok, ") throw ("))
-            endTok = endTok->linkAt(2);
-        if (!Token::Match(endTok, ") const|volatile| const|volatile| ;|,|)|=|[|{"))
+void Tokenizer::addSemicolonAfterUnknownMacro()
+{
+    if (!isCPP())
+        return;
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (tok->str() != ")")
             continue;
-
-        while (Token::Match(endTok->next(), "const|volatile"))
-            endTok->deleteNext();
-
-        // ok simplify this function pointer to an ordinary pointer
-        Token::eraseTokens(tok->link(), endTok->next());
-        tok->link()->deleteThis();
-        while (Token::Match(tok, "( %type% ::"))
-            tok->deleteNext(2);
-        tok->deleteThis();
+        const Token *macro = tok->link() ? tok->link()->previous() : nullptr;
+        if (!macro || !macro->isName())
+            continue;
+        if (Token::simpleMatch(tok, ") try") && !Token::Match(macro, "if|for|while"))
+            tok->insertToken(";");
+        else if (Token::simpleMatch(tok, ") using"))
+            tok->insertToken(";");
     }
 }
+//---------------------------------------------------------------------------
 
-
-bool Tokenizer::simplifyFunctionReturn()
+void Tokenizer::simplifyEmptyNamespaces()
 {
-    std::map<std::string, const Token*> functions;
+    if (isC())
+        return;
 
-    for (const Token *tok = tokens(); tok; tok = tok->next()) {
-        if (tok->str() == "{")
+    bool goback = false;
+    for (Token *tok = list.front(); tok; tok = tok ? tok->next() : nullptr) {
+        if (goback) {
+            tok = tok->previous();
+            goback = false;
+        }
+        if (Token::Match(tok, "(|[|{")) {
             tok = tok->link();
+            continue;
+        }
+        if (!Token::Match(tok, "namespace %name%| {"))
+            continue;
+        const bool isAnonymousNS = tok->strAt(1) == "{";
+        if (tok->strAt(3 - isAnonymousNS) == "}") {
+            tok->deleteNext(3 - isAnonymousNS); // remove '%name%| { }'
+            if (!tok->previous()) {
+                // remove 'namespace' or replace it with ';' if isolated
+                tok->deleteThis();
+                goback = true;
+            } else {                    // '%any% namespace %any%'
+                tok = tok->previous();  // goto previous token
+                tok->deleteNext();      // remove next token: 'namespace'
+                if (tok->str() == "{") {
+                    // Go back in case we were within a namespace that's empty now
+                    tok = tok->tokAt(-2) ? tok->tokAt(-2) : tok->previous();
+                    goback = true;
+                }
+            }
+        } else {
+            tok = tok->tokAt(2 - isAnonymousNS);
+        }
+    }
+}
 
-        else if (Token::Match(tok, "%name% ( ) { return %bool%|%char%|%num%|%str% ; }") && tok->strAt(-1) != "::") {
-            const Token* const any = tok->tokAt(5);
-            functions[tok->str()] = any;
-            tok = any;
+void Tokenizer::removeRedundantSemicolons()
+{
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (tok->link() && tok->str() == "(") {
+            tok = tok->link();
+            continue;
+        }
+        for (;;) {
+            if (Token::simpleMatch(tok, "; ;")) {
+                tok->deleteNext();
+            } else if (Token::simpleMatch(tok, "; { ; }")) {
+                tok->deleteNext(3);
+            } else {
+                break;
+            }
         }
     }
+}
 
-    if (functions.empty())
-        return false;
 
-    bool ret = false;
+bool Tokenizer::simplifyAddBraces()
+{
     for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "(|[|=|return|%op% %name% ( ) ;|]|)|%cop%")) {
-            tok = tok->next();
-            auto it = functions.find(tok->str());
-            if (it != functions.cend()) {
-                tok->str(it->second->str());
-                tok->deleteNext(2);
-                ret = true;
+        Token const * tokRet=simplifyAddBracesToCommand(tok);
+        if (!tokRet)
+            return false;
+    }
+    return true;
+}
+
+Token *Tokenizer::simplifyAddBracesToCommand(Token *tok)
+{
+    Token * tokEnd=tok;
+    if (Token::Match(tok,"for|switch|BOOST_FOREACH")) {
+        tokEnd=simplifyAddBracesPair(tok,true);
+    } else if (tok->str()=="while") {
+        Token *tokPossibleDo=tok->previous();
+        if (Token::simpleMatch(tok->previous(), "{"))
+            tokPossibleDo = nullptr;
+        else if (Token::simpleMatch(tokPossibleDo,"}"))
+            tokPossibleDo = tokPossibleDo->link();
+        if (!tokPossibleDo || tokPossibleDo->strAt(-1) != "do")
+            tokEnd=simplifyAddBracesPair(tok,true);
+    } else if (tok->str()=="do") {
+        tokEnd=simplifyAddBracesPair(tok,false);
+        if (tokEnd!=tok) {
+            // walk on to next token, i.e. "while"
+            // such that simplifyAddBracesPair does not close other braces
+            // before the "while"
+            if (tokEnd) {
+                tokEnd=tokEnd->next();
+                if (!tokEnd || tokEnd->str()!="while") // no while
+                    syntaxError(tok);
             }
         }
+    } else if (tok->str()=="if" && !Token::simpleMatch(tok->tokAt(-2), "operator \"\"")) {
+        tokEnd=simplifyAddBracesPair(tok,true);
+        if (!tokEnd)
+            return nullptr;
+        if (tokEnd->strAt(1) == "else") {
+            Token * tokEndNextNext= tokEnd->tokAt(2);
+            if (!tokEndNextNext || tokEndNextNext->str() == "}")
+                syntaxError(tokEndNextNext);
+            if (tokEndNextNext->str() == "if")
+                // do not change "else if ..." to "else { if ... }"
+                tokEnd=simplifyAddBracesToCommand(tokEndNextNext);
+            else
+                tokEnd=simplifyAddBracesPair(tokEnd->next(),false);
+        }
     }
 
-    return ret;
+    return tokEnd;
 }
 
-void Tokenizer::simplifyVarDecl(const bool only_k_r_fpar)
+Token *Tokenizer::simplifyAddBracesPair(Token *tok, bool commandWithCondition)
 {
-    simplifyVarDecl(list.front(), nullptr, only_k_r_fpar);
-}
+    Token * tokCondition=tok->next();
+    if (!tokCondition) // Missing condition
+        return tok;
 
-void Tokenizer::simplifyVarDecl(Token * tokBegin, const Token * const tokEnd, const bool only_k_r_fpar)
-{
-    const bool isCPP11  = mSettings->standards.cpp >= Standards::CPP11;
+    Token *tokAfterCondition=tokCondition;
+    if (commandWithCondition) {
+        if (tokCondition->str()=="(")
+            tokAfterCondition=tokCondition->link();
+        else
+            syntaxError(tok); // Bad condition
 
-    // Split up variable declarations..
-    // "int a=4;" => "int a; a=4;"
-    bool finishedwithkr = true;
-    for (Token *tok = tokBegin; tok != tokEnd; tok = tok->next()) {
-        if (Token::simpleMatch(tok, "= {")) {
-            tok = tok->next()->link();
+        if (!tokAfterCondition || tokAfterCondition->strAt(1) == "]")
+            syntaxError(tok); // Bad condition
+
+        tokAfterCondition=tokAfterCondition->next();
+        if (!tokAfterCondition || Token::Match(tokAfterCondition, ")|}|,")) {
+            // No tokens left where to add braces around
+            return tok;
         }
-        if (!tok) {
-            syntaxError(tokBegin);
+    }
+    // Skip labels
+    Token * tokStatement = tokAfterCondition;
+    while (true) {
+        if (Token::Match(tokStatement, "%name% :"))
+            tokStatement = tokStatement->tokAt(2);
+        else if (tokStatement->str() == "case") {
+            tokStatement = skipCaseLabel(tokStatement);
+            if (!tokStatement)
+                return tok;
+            if (tokStatement->str() != ":")
+                syntaxError(tokStatement);
+            tokStatement = tokStatement->next();
+        } else
+            break;
+        if (!tokStatement)
+            return tok;
+    }
+    Token * tokBracesEnd=nullptr;
+    if (tokStatement->str() == "{") {
+        // already surrounded by braces
+        if (tokStatement != tokAfterCondition) {
+            // Move the opening brace before labels
+            Token::move(tokStatement, tokStatement, tokAfterCondition->previous());
         }
-        if (only_k_r_fpar && finishedwithkr) {
-            if (Token::Match(tok, "(|[|{")) {
-                tok = tok->link();
-                if (tok->next() && Token::Match(tok, ") !!{"))
-                    tok = tok->next();
-                else
-                    continue;
-            } else
-                continue;
-        } else if (tok->str() == "(") {
-            if (isCPP()) {
-                for (Token * tok2 = tok; tok2 && tok2 != tok->link(); tok2 = tok2->next()) {
-                    if (Token::Match(tok2, "[(,] [")) {
-                        // lambda function at tok2->next()
-                        // find start of lambda body
-                        Token * lambdaBody = tok2;
-                        while (lambdaBody && lambdaBody != tok2->link() && lambdaBody->str() != "{")
-                            lambdaBody = lambdaBody->next();
-                        if (lambdaBody && lambdaBody != tok2->link() && lambdaBody->link())
-                            simplifyVarDecl(lambdaBody, lambdaBody->link()->next(), only_k_r_fpar);
+        tokBracesEnd = tokStatement->link();
+    } else if (Token::simpleMatch(tokStatement, "try {") &&
+               Token::simpleMatch(tokStatement->linkAt(1), "} catch (")) {
+        tokAfterCondition->previous()->insertToken("{");
+        Token * tokOpenBrace = tokAfterCondition->previous();
+        Token * tokEnd = tokStatement->linkAt(1)->linkAt(2)->linkAt(1);
+        if (!tokEnd) {
+            syntaxError(tokStatement);
+        }
+        tokEnd->insertToken("}");
+        Token * tokCloseBrace = tokEnd->next();
+        tokCloseBrace->column(tokEnd->column());
+
+        Token::createMutualLinks(tokOpenBrace, tokCloseBrace);
+        tokBracesEnd = tokCloseBrace;
+    } else {
+        Token * tokEnd = simplifyAddBracesToCommand(tokStatement);
+        if (!tokEnd) // Ticket #4887
+            return tok;
+        if (tokEnd->str()!="}") {
+            // Token does not end with brace
+            // Look for ; to add own closing brace after it
+            while (tokEnd && !Token::Match(tokEnd, ";|)|}")) {
+                if (tokEnd->tokType()==Token::eBracket || tokEnd->str() == "(") {
+                    tokEnd = tokEnd->link();
+                    if (!tokEnd) {
+                        // Inner bracket does not close
+                        return tok;
                     }
                 }
+                tokEnd=tokEnd->next();
+            }
+            if (!tokEnd || tokEnd->str() != ";") {
+                // No trailing ;
+                if (tokStatement->isUpperCaseName())
+                    unknownMacroError(tokStatement);
+                else
+                    syntaxError(tokStatement);
             }
-            tok = tok->link();
-        }
-
-        if (!tok)
-            syntaxError(nullptr); // #7043 invalid code
-        if (tok->previous() && !Token::Match(tok->previous(), "{|}|;|)|public:|protected:|private:"))
-            continue;
-        if (Token::simpleMatch(tok, "template <"))
-            continue;
-
-        Token *type0 = tok;
-        if (!Token::Match(type0, "::|extern| %type%"))
-            continue;
-        if (Token::Match(type0, "else|return|public:|protected:|private:"))
-            continue;
-        if (isCPP11 && type0->str() == "using")
-            continue;
-        if (isCPP() && type0->str() == "namespace")
-            continue;
-
-        bool isconst = false;
-        bool isstatic = false;
-        Token *tok2 = type0;
-        int typelen = 1;
-
-        if (Token::Match(tok2, "::|extern")) {
-            tok2 = tok2->next();
-            typelen++;
         }
 
-        //check if variable is declared 'const' or 'static' or both
-        while (tok2) {
-            if (!Token::Match(tok2, "const|static") && Token::Match(tok2, "%type% const|static")) {
-                tok2 = tok2->next();
-                ++typelen;
-            }
+        tokAfterCondition->previous()->insertToken("{");
+        Token * tokOpenBrace=tokAfterCondition->previous();
 
-            if (tok2->str() == "const")
-                isconst = true;
+        tokEnd->insertToken("}");
+        Token * tokCloseBrace=tokEnd->next();
+        tokCloseBrace->column(tokEnd->column());
 
-            else if (tok2->str() == "static")
-                isstatic = true;
+        Token::createMutualLinks(tokOpenBrace,tokCloseBrace);
+        tokBracesEnd=tokCloseBrace;
+    }
 
-            else if (Token::Match(tok2, "%type% :: %type%")) {
-                tok2 = tok2->next();
-                ++typelen;
-            }
+    return tokBracesEnd;
+}
 
-            else
-                break;
+void Tokenizer::simplifyFunctionParameters()
+{
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (tok->link() && Token::Match(tok, "{|[|(")) {
+            tok = tok->link();
+        }
 
-            if (tok2->strAt(1) == "*")
-                break;
+        // Find the function e.g. foo( x ) or foo( x, y )
+        else if (Token::Match(tok, "%name% ( %name% [,)]") && !Token::Match(tok->tokAt(-1), ":|,|::|=")) {
+            // We have found old style function, now we need to change it
 
-            if (Token::Match(tok2->next(), "& %name% ,"))
-                break;
+            // First step: Get list of argument names in parentheses
+            std::map<std::string, Token *> argumentNames;
+            bool bailOut = false;
+            const Token * tokparam = nullptr;
 
-            tok2 = tok2->next();
-            ++typelen;
-        }
+            //take count of the function name..
+            const std::string& funcName(tok->str());
 
-        // strange looking variable declaration => don't split up.
-        if (Token::Match(tok2, "%type% *|&| %name% , %type% *|&| %name%"))
-            continue;
+            //floating token used to check for parameters
+            Token *tok1 = tok;
 
-        if (Token::Match(tok2, "struct|union|class %type%")) {
-            tok2 = tok2->next();
-            ++typelen;
-        }
+            while (nullptr != (tok1 = tok1->tokAt(2))) {
+                if (!Token::Match(tok1, "%name% [,)]")) {
+                    bailOut = true;
+                    break;
+                }
 
-        // check for qualification..
-        if (Token::Match(tok2,  ":: %type%")) {
-            ++typelen;
-            tok2 = tok2->next();
-        }
+                //same parameters: take note of the parameter
+                if (argumentNames.find(tok1->str()) != argumentNames.end())
+                    tokparam = tok1;
+                else if (tok1->str() != funcName)
+                    argumentNames[tok1->str()] = tok1;
+                else {
+                    if (tok1->strAt(1) == ")") {
+                        if (tok1->strAt(-1) == ",") {
+                            tok1 = tok1->tokAt(-2);
+                            tok1->deleteNext(2);
+                        } else {
+                            tok1 = tok1->previous();
+                            tok1->deleteNext();
+                            bailOut = true;
+                            break;
+                        }
+                    } else {
+                        tok1 = tok1->tokAt(-2);
+                        tok1->next()->deleteNext(2);
+                    }
+                }
 
-        //skip combinations of templates and namespaces
-        while (!isC() && (Token::Match(tok2, "%type% <") || Token::Match(tok2, "%type% ::"))) {
-            if (tok2->next()->str() == "<" && !TemplateSimplifier::templateParameters(tok2->next())) {
-                tok2 = nullptr;
-                break;
+                if (tok1->strAt(1) == ")") {
+                    tok1 = tok1->tokAt(2);
+                    //expect at least a type name after round brace..
+                    if (!tok1 || !tok1->isName())
+                        bailOut = true;
+                    break;
+                }
             }
-            typelen += 2;
-            tok2 = tok2->tokAt(2);
-            if (tok2 && tok2->previous()->str() == "::")
-                continue;
-            int indentlevel = 0;
-            int parens = 0;
 
-            for (Token *tok3 = tok2; tok3; tok3 = tok3->next()) {
-                ++typelen;
+            //goto '('
+            tok = tok->next();
 
-                if (!parens && tok3->str() == "<") {
-                    ++indentlevel;
-                } else if (!parens && tok3->str() == ">") {
-                    if (indentlevel == 0) {
-                        tok2 = tok3->next();
-                        break;
-                    }
-                    --indentlevel;
-                } else if (!parens && tok3->str() == ">>") {
-                    if (indentlevel <= 1) {
-                        tok2 = tok3->next();
-                        break;
-                    }
-                    indentlevel -= 2;
-                } else if (tok3->str() == "(") {
-                    ++parens;
-                } else if (tok3->str() == ")") {
-                    if (!parens) {
-                        tok2 = nullptr;
-                        break;
-                    }
-                    --parens;
-                } else if (tok3->str() == ";") {
+            if (bailOut) {
+                tok = tok->link();
+                continue;
+            }
+
+            tok1 = tok->link()->next();
+
+            // there should be the sequence '; {' after the round parentheses
+            for (const Token* tok2 = tok1; tok2; tok2 = tok2->next()) {
+                if (Token::simpleMatch(tok2, "; {"))
+                    break;
+                if (tok2->str() == "{") {
+                    bailOut = true;
                     break;
                 }
             }
 
-            if (Token::Match(tok2,  ":: %type%")) {
-                ++typelen;
-                tok2 = tok2->next();
+            if (bailOut) {
+                tok = tok->link();
+                continue;
             }
-        }
 
-        //pattern: "%type% *| ... *| const| %name% ,|="
-        if (Token::Match(tok2, "%type%") ||
-            (tok2 && tok2->previous() && tok2->previous()->str() == ">")) {
-            Token *varName = tok2;
-            if (!tok2->previous() || tok2->previous()->str() != ">")
-                varName = varName->next();
-            else
-                --typelen;
-            //skip all the pointer part
-            bool isPointerOrRef = false;
-            while (Token::simpleMatch(varName, "*") || Token::Match(varName, "& %name% ,")) {
-                isPointerOrRef = true;
-                varName = varName->next();
-            }
+            // Last step: check out if the declarations between ')' and '{' match the parameters list
+            std::map<std::string, Token *> argumentNames2;
 
-            while (Token::Match(varName, "%type% %type%")) {
-                if (varName->str() != "const") {
-                    ++typelen;
+            while (tok1 && tok1->str() != "{") {
+                if (Token::Match(tok1, "(|)")) {
+                    bailOut = true;
+                    break;
                 }
-                varName = varName->next();
-            }
-            //non-VLA case
-            if (Token::Match(varName, "%name% ,|=")) {
-                if (varName->str() != "operator") {
-                    tok2 = varName->next(); // The ',' or '=' token
+                if (tok1->str() == ";") {
+                    if (tokparam) {
+                        syntaxError(tokparam);
+                    }
+                    Token *tok2 = tok1->previous();
+                    while (tok2->str() == "]")
+                        tok2 = tok2->link()->previous();
 
-                    if (tok2->str() == "=" && (isstatic || (isconst && !isPointerOrRef))) {
-                        //do not split const non-pointer variables..
-                        while (tok2 && tok2->str() != "," && tok2->str() != ";") {
-                            if (Token::Match(tok2, "{|(|["))
-                                tok2 = tok2->link();
-                            const Token *tok3 = tok2;
-                            if (!isC() && tok2->str() == "<" && TemplateSimplifier::templateParameters(tok2) > 0) {
-                                tok2 = tok2->findClosingBracket();
-                            }
-                            if (!tok2)
-                                syntaxError(tok3); // #6881 invalid code
-                            tok2 = tok2->next();
-                        }
-                        if (tok2 && tok2->str() == ";")
-                            tok2 = nullptr;
+                    //it should be a name..
+                    if (!tok2->isName()) {
+                        bailOut = true;
+                        break;
                     }
-                } else
-                    tok2 = nullptr;
-            }
 
-            //VLA case
-            else if (Token::Match(varName, "%name% [")) {
-                tok2 = varName->next();
+                    if (argumentNames2.find(tok2->str()) != argumentNames2.end()) {
+                        //same parameter names...
+                        syntaxError(tok1);
+                    } else
+                        argumentNames2[tok2->str()] = tok2;
 
-                while (Token::Match(tok2->link(), "] ,|=|["))
-                    tok2 = tok2->link()->next();
-                if (!Token::Match(tok2, "=|,"))
-                    tok2 = nullptr;
-                if (tok2 && tok2->str() == "=") {
-                    while (tok2 && tok2->str() != "," && tok2->str() != ";") {
-                        if (Token::Match(tok2, "{|(|["))
-                            tok2 = tok2->link();
-                        tok2 = tok2->next();
+                    if (argumentNames.find(tok2->str()) == argumentNames.end()) {
+                        //non-matching parameter... bailout
+                        bailOut = true;
+                        break;
                     }
-                    if (tok2 && tok2->str() == ";")
-                        tok2 = nullptr;
                 }
+                tok1 = tok1->next();
             }
 
-            // brace initialization
-            else if (Token::Match(varName, "%name% {")) {
-                tok2 = varName->next();
-                tok2 = tok2->link();
-                if (tok2)
-                    tok2 = tok2->next();
-                if (tok2 && tok2->str() != ",")
-                    tok2 = nullptr;
+            if (bailOut || !tok1) {
+                tok = tok->link();
+                continue;
             }
 
-            // parenthesis, functions can't be declared like:
-            // int f1(a,b), f2(c,d);
-            // so if there is a comma assume this is a variable declaration
-            else if (Token::Match(varName, "%name% (") && Token::simpleMatch(varName->linkAt(1), ") ,")) {
-                tok2 = varName->linkAt(1)->next();
+            //the two containers may not hold the same size...
+            //in that case, the missing parameters are defined as 'int'
+            if (argumentNames.size() != argumentNames2.size()) {
+                //move back 'tok1' to the last ';'
+                tok1 = tok1->previous();
+                for (const std::pair<const std::string, Token *>& argumentName : argumentNames) {
+                    if (argumentNames2.find(argumentName.first) == argumentNames2.end()) {
+                        //add the missing parameter argument declaration
+                        tok1->insertToken(";");
+                        tok1->insertToken(argumentName.first);
+                        //register the change inside argumentNames2
+                        argumentNames2[argumentName.first] = tok1->next();
+                        tok1->insertToken("int");
+                    }
+                }
             }
 
-            else
-                tok2 = nullptr;
-        } else {
-            tok2 = nullptr;
-        }
-
-        if (!tok2) {
-            if (only_k_r_fpar)
-                finishedwithkr = false;
-            continue;
-        }
-
-        if (tok2->str() == ",") {
-            tok2->str(";");
-            //TODO: should we have to add also template '<>' links?
-            TokenList::insertTokens(tok2, type0, typelen);
-        }
-
-        else {
-            Token *eq = tok2;
+            while (tok->str() != ")") {
+                //initialize start and end tokens to be moved
+                Token *declStart = argumentNames2[tok->strAt(1)];
+                Token *declEnd = declStart;
+                while (declStart->strAt(-1) != ";" && declStart->strAt(-1) != ")")
+                    declStart = declStart->previous();
+                while (declEnd->strAt(1) != ";" && declEnd->strAt(1) != "{")
+                    declEnd = declEnd->next();
 
-            while (tok2) {
-                if (Token::Match(tok2, "{|(|["))
-                    tok2 = tok2->link();
+                //remove ';' after declaration
+                declEnd->deleteNext();
 
-                else if (!isC() && tok2->str() == "<" && tok2->previous()->isName() && !tok2->previous()->varId())
-                    tok2 = tok2->findClosingBracket();
+                //replace the parameter name in the parentheses with all the declaration
+                Token::replace(tok->next(), declStart, declEnd);
 
-                else if (std::strchr(";,", tok2->str()[0])) {
-                    // "type var ="   =>   "type var; var ="
-                    const Token *varTok = type0->tokAt(typelen);
-                    while (Token::Match(varTok, "*|&|const|volatile"))
-                        varTok = varTok->next();
-                    if (!varTok)
-                        syntaxError(tok2); // invalid code
-                    TokenList::insertTokens(eq, varTok, 2);
-                    eq->str(";");
+                //since there are changes to tokens, put tok where tok1 is
+                tok = declEnd->next();
 
-                    // "= x, "   =>   "= x; type "
-                    if (tok2->str() == ",") {
-                        tok2->str(";");
-                        TokenList::insertTokens(tok2, type0, typelen);
-                    }
-                    break;
-                }
-                if (tok2)
-                    tok2 = tok2->next();
+                //fix up line number
+                if (tok->str() == ",")
+                    tok->linenr(tok->previous()->linenr());
             }
+            //goto forward and continue
+            tok = tok->linkAt(1);
         }
-        finishedwithkr = (only_k_r_fpar && tok2 && tok2->strAt(1) == "{");
     }
 }
 
-void Tokenizer::simplifyStaticConst()
+void Tokenizer::simplifyPointerToStandardType()
 {
-    // This function will simplify the token list so that the qualifiers "extern", "static"
-    // and "const" appear in the same order as in the array below.
-    const std::string qualifiers[] = {"extern", "static", "const"};
+    if (!isC())
+        return;
 
-    // Move 'const' before all other qualifiers and types and then
-    // move 'static' before all other qualifiers and types, ...
     for (Token *tok = list.front(); tok; tok = tok->next()) {
-        bool continue2 = false;
-        for (int i = 0; i < sizeof(qualifiers)/sizeof(qualifiers[0]); i++) {
+        if (!Token::Match(tok, "& %name% [ 0 ] !!["))
+            continue;
 
-            // Keep searching for a qualifier
-            if (!tok->next() || tok->next()->str() != qualifiers[i])
-                continue;
+        if (!Token::Match(tok->previous(), "[,(=]"))
+            continue;
 
-            // Look backwards to find the beginning of the declaration
-            Token* leftTok = tok;
-            bool behindOther = false;
-            for (; leftTok; leftTok = leftTok->previous()) {
-                for (int j = 0; j <= i; j++) {
-                    if (leftTok->str() == qualifiers[j]) {
-                        behindOther = true;
-                        break;
-                    }
-                }
-                if (behindOther)
-                    break;
-                if (!Token::Match(leftTok, "%type%|struct|::") ||
-                    (isCPP() && Token::Match(leftTok, "private:|protected:|public:|operator|template"))) {
-                    break;
-                }
-            }
+        // Remove '[ 0 ]' suffix
+        Token::eraseTokens(tok->next(), tok->tokAt(5));
+        // Remove '&' prefix
+        tok = tok->previous();
+        if (!tok)
+            break;
+        tok->deleteNext();
+    }
+}
 
-            // The token preceding the declaration should indicate the start of a declaration
-            if (leftTok == tok)
-                continue;
+void Tokenizer::simplifyFunctionPointers()
+{
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        // #2873 - do not simplify function pointer usage here:
+        // (void)(xy(*p)(0));
+        if (Token::simpleMatch(tok, ") (")) {
+            tok = tok->linkAt(1);
+            continue;
+        }
 
-            if (leftTok && !behindOther && !Token::Match(leftTok, ";|{|}|(|,|private:|protected:|public:")) {
-                continue2 = true;
-                break;
-            }
+        // check for function pointer cast
+        if (Token::Match(tok, "( %type% %type%| *| *| ( * ) (") ||
+            Token::Match(tok, "static_cast < %type% %type%| *| *| ( * ) (")) {
+            Token *tok1 = tok;
 
-            // Move the qualifier to the left-most position in the declaration
-            tok->deleteNext();
-            if (!leftTok) {
-                list.front()->insertToken(qualifiers[i], emptyString, false);
-                list.front()->swapWithNext();
-                tok = list.front();
-            } else if (leftTok->next()) {
-                leftTok->next()->insertToken(qualifiers[i], emptyString, true);
-                tok = leftTok->next();
-            } else {
-                leftTok->insertToken(qualifiers[i]);
-                tok = leftTok;
-            }
-        }
-        if (continue2)
-            continue;
-    }
-}
+            if (tok1->isCpp() && tok1->str() == "static_cast")
+                tok1 = tok1->next();
+
+            tok1 = tok1->next();
+
+            if (Token::Match(tok1->next(), "%type%"))
+                tok1 = tok1->next();
+
+            while (tok1->strAt(1) == "*")
+                tok1 = tok1->next();
+
+            // check that the cast ends
+            if (!Token::Match(tok1->linkAt(4), ") )|>"))
+                continue;
 
-void Tokenizer::simplifyIfAndWhileAssign()
-{
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (!Token::Match(tok->next(), "if|while ("))
+            // ok simplify this function pointer cast to an ordinary pointer cast
+            tok1->deleteNext();
+            tok1->next()->deleteNext();
+            Token::eraseTokens(tok1->next(), tok1->linkAt(2)->next());
             continue;
+        }
 
-        const Token* tokAt3 = tok->tokAt(3);
-        if (!Token::Match(tokAt3, "!| (| %name% =") &&
-            !Token::Match(tokAt3, "!| (| %name% . %name% =") &&
-            !Token::Match(tokAt3, "0 == (| %name% =") &&
-            !Token::Match(tokAt3, "0 == (| %name% . %name% ="))
+        // check for start of statement
+        if (tok->previous() && !Token::Match(tok->previous(), "{|}|;|,|(|public:|protected:|private:"))
             continue;
 
-        // simplifying a "while(cond) { }" condition ?
-        const bool iswhile(tok->next()->str() == "while");
-
-        // simplifying a "do { } while(cond);" condition ?
-        const bool isDoWhile = iswhile && Token::simpleMatch(tok, "}") && Token::simpleMatch(tok->link()->previous(), "do");
-        Token* openBraceTok = tok->link();
-
-        // delete the "if|while"
-        tok->deleteNext();
-
-        // Remember if there is a "!" or not. And delete it if there are.
-        const bool isNot(Token::Match(tok->tokAt(2), "!|0"));
-        if (isNot)
-            tok->next()->deleteNext((tok->strAt(2) == "0") ? 2 : 1);
+        if (Token::Match(tok, "delete|else|return|throw|typedef"))
+            continue;
 
-        // Delete parentheses.. and remember how many there are with
-        // their links.
-        std::stack<Token *> braces;
-        while (tok->next()->str() == "(") {
-            braces.push(tok->next()->link());
-            tok->deleteNext();
-        }
+        while (Token::Match(tok, "%type%|:: %type%|::"))
+            tok = tok->next();
 
-        // Skip the "%name% = ..."
-        Token *tok2;
-        for (tok2 = tok->next(); tok2; tok2 = tok2->next()) {
-            if (tok2->str() == "(")
-                tok2 = tok2->link();
-            else if (tok2->str() == ")")
-                break;
-        }
+        Token *tok2 = (tok && tok->isName()) ? tok->next() : nullptr;
+        while (Token::Match(tok2, "*|&"))
+            tok2 = tok2->next();
+        if (!tok2 || tok2->str() != "(")
+            continue;
+        while (Token::Match(tok2, "(|:: %type%"))
+            tok2 = tok2->tokAt(2);
+        if (!Token::Match(tok2, "(|:: * *| %name%"))
+            continue;
+        tok2 = tok2->tokAt(2);
+        if (tok2->str() == "*")
+            tok2 = tok2->next();
+        while (Token::Match(tok2, "%type%|:: %type%|::"))
+            tok2 = tok2->next();
 
-        // Insert "; if|while ( .."
-        tok2 = tok2->previous();
-        if (tok->strAt(2) == ".") {
-            tok2->insertToken(tok->strAt(3));
-            tok2->next()->varId(tok->tokAt(3)->varId());
-            tok2->insertToken(".");
-        }
-        tok2->insertToken(tok->next()->str());
-        tok2->next()->varId(tok->next()->varId());
+        if (!isFunctionPointer(tok2) &&
+            !Token::Match(tok2, "%name% [ ] ) (") &&
+            !(Token::Match(tok2, "%name% (") && Token::simpleMatch(tok2->linkAt(1), ") ) (")))
+            continue;
 
-        while (! braces.empty()) {
-            tok2->insertToken("(");
-            Token::createMutualLinks(tok2->next(), braces.top());
-            braces.pop();
-        }
+        while (tok && tok->str() != "(")
+            tok = tok->next();
 
-        if (isNot)
-            tok2->next()->insertToken("!");
-        tok2->insertToken(iswhile ? "while" : "if");
-        if (isDoWhile) {
-            tok2->insertToken("}");
-            Token::createMutualLinks(openBraceTok, tok2->next());
+        // check that the declaration ends
+        if (!tok || !tok->link() || !tok->link()->next()) {
+            syntaxError(nullptr);
         }
+        Token *endTok = tok->link()->linkAt(1);
+        if (Token::simpleMatch(endTok, ") throw ("))
+            endTok = endTok->linkAt(2);
+        if (!Token::Match(endTok, ") const|volatile| const|volatile| ;|,|)|=|[|{"))
+            continue;
 
-        tok2->insertToken(";");
+        while (Token::Match(endTok->next(), "const|volatile"))
+            endTok->deleteNext();
 
-        // delete the extra "}"
-        if (isDoWhile)
+        // ok simplify this function pointer to an ordinary pointer
+        if (Token::simpleMatch(tok->link()->previous(), ") )")) {
+            // Function returning function pointer
+            // void (*dostuff(void))(void) {}
+            Token::eraseTokens(tok->link(), endTok->next());
+            tok->link()->deleteThis();
             tok->deleteThis();
+        } else {
+            Token::eraseTokens(tok->link()->linkAt(1), endTok->next());
 
-        // If it's a while loop, insert the assignment in the loop
-        if (iswhile && !isDoWhile) {
-            int indentlevel = 0;
-            Token *tok3 = tok2;
-
-            for (; tok3; tok3 = tok3->next()) {
-                if (tok3->str() == "{")
-                    ++indentlevel;
-                else if (tok3->str() == "}") {
-                    if (indentlevel <= 1)
+            // remove variable names
+            int indent = 0;
+            for (Token* tok3 = tok->link()->tokAt(2); Token::Match(tok3, "%name%|*|&|[|(|)|::|,|<"); tok3 = tok3->next()) {
+                if (tok3->str() == ")" && --indent < 0)
+                    break;
+                if (tok3->str() == "<" && tok3->link())
+                    tok3 = tok3->link();
+                else if (Token::Match(tok3, "["))
+                    tok3 = tok3->link();
+                else if (tok3->str() == "(") {
+                    tok3 = tok3->link();
+                    if (Token::simpleMatch(tok3, ") (")) {
+                        tok3 = tok3->next();
+                        ++indent;
+                    } else
                         break;
-                    --indentlevel;
                 }
+                if (Token::Match(tok3, "%type%|*|&|> %name% [,)[]"))
+                    tok3->deleteNext();
             }
 
-            if (tok3 && indentlevel == 1) {
-                tok3 = tok3->previous();
-                std::stack<Token *> braces2;
-
-                for (tok2 = tok2->next(); tok2 && tok2 != tok; tok2 = tok2->previous()) {
-                    tok3->insertToken(tok2->str());
-                    Token *newTok = tok3->next();
-
-                    newTok->varId(tok2->varId());
-                    newTok->fileIndex(tok2->fileIndex());
-                    newTok->linenr(tok2->linenr());
-
-                    // link() new tokens manually
-                    if (tok2->link()) {
-                        if (Token::Match(newTok, "}|)|]|>")) {
-                            braces2.push(newTok);
-                        } else {
-                            Token::createMutualLinks(newTok, braces2.top());
-                            braces2.pop();
-                        }
-                    }
-                }
-            }
+            // TODO Keep this info
+            while (Token::Match(tok, "( %type% ::"))
+                tok->deleteNext(2);
         }
     }
 }
 
-void Tokenizer::simplifyVariableMultipleAssign()
+void Tokenizer::simplifyVarDecl(const bool only_k_r_fpar)
 {
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "%name% = %name% = %num%|%name% ;")) {
-            // skip intermediate assignments
-            Token *tok2 = tok->previous();
-            while (tok2 &&
-                   tok2->str() == "=" &&
-                   Token::Match(tok2->previous(), "%name%")) {
-                tok2 = tok2->tokAt(-2);
-            }
-
-            if (!tok2 || tok2->str() != ";") {
-                continue;
-            }
-
-            Token *stopAt = tok->tokAt(2);
-            const Token *valueTok = stopAt->tokAt(2);
-            const std::string& value(valueTok->str());
-            tok2 = tok2->next();
-
-            while (tok2 != stopAt) {
-                tok2->next()->insertToken(";");
-                tok2->next()->insertToken(value);
-                tok2 = tok2->tokAt(4);
-            }
-        }
-    }
+    simplifyVarDecl(list.front(), nullptr, only_k_r_fpar);
 }
 
-// Binary operators simplification map
-static const std::map<std::string, std::string> cAlternativeTokens = {
-    std::make_pair("and", "&&")
-    , std::make_pair("and_eq", "&=")
-    , std::make_pair("bitand", "&")
-    , std::make_pair("bitor", "|")
-    , std::make_pair("not_eq", "!=")
-    , std::make_pair("or", "||")
-    , std::make_pair("or_eq", "|=")
-    , std::make_pair("xor", "^")
-    , std::make_pair("xor_eq", "^=")
-};
-
-// Simplify the C alternative tokens:
-//  and      =>     &&
-//  and_eq   =>     &=
-//  bitand   =>     &
-//  bitor    =>     |
-//  compl    =>     ~
-//  not      =>     !
-//  not_eq   =>     !=
-//  or       =>     ||
-//  or_eq    =>     |=
-//  xor      =>     ^
-//  xor_eq   =>     ^=
-bool Tokenizer::simplifyCAlternativeTokens()
+// cppcheck-suppress functionConst - has side effects
+void Tokenizer::simplifyVarDecl(Token * tokBegin, const Token * const tokEnd, const bool only_k_r_fpar)
 {
-    /* executable scope level */
-    int executableScopeLevel = 0;
+    const bool cpp = isCPP();
+    const bool isCPP11 = cpp && (mSettings.standards.cpp >= Standards::CPP11);
 
-    bool ret = false;
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (tok->str() == "{") {
-            if (executableScopeLevel > 0 || Token::simpleMatch(tok->previous(), ") {"))
-                ++executableScopeLevel;
-            continue;
-        }
+    // Split up variable declarations..
+    // "int a=4;" => "int a; a=4;"
+    bool finishedwithkr = true;
+    bool scopeDecl = false;
+    for (Token *tok = tokBegin; tok != tokEnd; tok = tok->next()) {
+        if (Token::Match(tok, "{|;"))
+            scopeDecl = false;
+        if (cpp) {
+            if (Token::Match(tok, "class|struct|namespace|union"))
+                scopeDecl = true;
+            if (Token::Match(tok, "decltype|noexcept (")) {
+                tok = tok->linkAt(1);
+                // skip decltype(...){...}
+                if (tok && Token::simpleMatch(tok->previous(), ") {"))
+                    tok = tok->link();
+            } else if (Token::simpleMatch(tok, "= {") ||
+                       (!scopeDecl && Token::Match(tok, "%name%|> {") &&
+                        !Token::Match(tok, "else|try|do|const|constexpr|override|volatile|noexcept"))) {
+                if (!tok->linkAt(1))
+                    syntaxError(tokBegin);
+                // Check for lambdas before skipping
+                if (Token::Match(tok->tokAt(-2), ") . %name%")) { // trailing return type
+                    // TODO: support lambda without parameter clause?
+                    Token* lambdaStart = tok->linkAt(-2)->previous();
+                    if (Token::simpleMatch(lambdaStart, "]"))
+                        lambdaStart = lambdaStart->link();
+                    Token* lambdaEnd = findLambdaEndScope(lambdaStart);
+                    if (lambdaEnd)
+                        simplifyVarDecl(lambdaEnd->link()->next(), lambdaEnd, only_k_r_fpar);
+                } else {
+                    for (Token* tok2 = tok->next(); tok2 != tok->linkAt(1); tok2 = tok2->next()) {
+                        Token* lambdaEnd = findLambdaEndScope(tok2);
+                        if (!lambdaEnd)
+                            continue;
+                        simplifyVarDecl(lambdaEnd->link()->next(), lambdaEnd, only_k_r_fpar);
+                    }
+                }
+                tok = tok->linkAt(1);
+            }
 
-        if (tok->str() == "}") {
-            if (executableScopeLevel > 0)
-                --executableScopeLevel;
-            continue;
+        } else if (Token::simpleMatch(tok, "= {")) {
+            tok = tok->linkAt(1);
         }
-
-        if (!tok->isName())
-            continue;
-
-        const std::map<std::string, std::string>::const_iterator cOpIt = cAlternativeTokens.find(tok->str());
-        if (cOpIt != cAlternativeTokens.end()) {
-            if (!Token::Match(tok->previous(), "%name%|%num%|%char%|)|]|> %name% %name%|%num%|%char%|%op%|("))
-                continue;
-            if (Token::Match(tok->next(), "%assign%|%or%|%oror%|&&|*|/|%|^"))
-                continue;
-            tok->str(cOpIt->second);
-            ret = true;
-        } else if (Token::Match(tok, "not|compl")) {
-            // Don't simplify 'not p;' (in case 'not' is a type)
-            if (!Token::Match(tok->next(), "%name%|(") ||
-                Token::Match(tok->previous(), "[;{}]") ||
-                (executableScopeLevel == 0U && tok->strAt(-1) == "("))
+        if (!tok) {
+            syntaxError(tokBegin);
+        }
+        if (only_k_r_fpar && finishedwithkr) {
+            if (Token::Match(tok, "(|[|{")) {
+                tok = tok->link();
+                if (tok->next() && Token::Match(tok, ") !!{"))
+                    tok = tok->next();
+                else
+                    continue;
+            } else
                 continue;
-            tok->str((tok->str() == "not") ? "!" : "~");
-            ret = true;
+        } else if (tok->str() == "(") {
+            if (cpp) {
+                for (Token * tok2 = tok; tok2 && tok2 != tok->link(); tok2 = tok2->next()) {
+                    if (Token::Match(tok2, "[(,] [")) {
+                        // lambda function at tok2->next()
+                        // find start of lambda body
+                        Token * lambdaBody = tok2;
+                        while (lambdaBody && lambdaBody != tok2->link() && lambdaBody->str() != "{")
+                            lambdaBody = lambdaBody->next();
+                        if (lambdaBody && lambdaBody != tok2->link() && lambdaBody->link())
+                            simplifyVarDecl(lambdaBody, lambdaBody->link()->next(), only_k_r_fpar);
+                    }
+                }
+            }
+            tok = tok->link();
         }
-    }
-    return ret;
-}
-
-// int i(0); => int i; i = 0;
-// int i(0), j; => int i; i = 0; int j;
-void Tokenizer::simplifyInitVar()
-{
-    if (isC())
-        return;
 
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (!tok->isName() || (tok->previous() && !Token::Match(tok->previous(), "[;{}]")))
+        if (!tok)
+            syntaxError(nullptr); // #7043 invalid code
+        if (tok->previous() && !Token::Match(tok->previous(), "{|}|;|)|public:|protected:|private:"))
+            continue;
+        if (Token::simpleMatch(tok, "template <"))
             continue;
 
-        if (tok->str() == "return")
+        Token *type0 = tok;
+        if (!Token::Match(type0, "::|extern| %type%"))
+            continue;
+        if (Token::Match(type0, "else|return|public:|protected:|private:"))
+            continue;
+        if (isCPP11 && type0->str() == "using")
+            continue;
+        if (cpp && Token::Match(type0, "namespace|delete"))
             continue;
 
-        if (Token::Match(tok, "class|struct|union| %type% *| %name% ( &| %any% ) ;")) {
-            tok = initVar(tok);
-        } else if (Token::Match(tok, "%type% *| %name% ( %type% (")) {
-            const Token* tok2 = tok->tokAt(2);
-            if (!tok2->link())
-                tok2 = tok2->next();
-            if (!tok2->link() || (tok2->link()->strAt(1) == ";" && !Token::simpleMatch(tok2->linkAt(2), ") (")))
-                tok = initVar(tok);
-        } else if (Token::Match(tok, "class|struct|union| %type% *| %name% ( &| %any% ) ,")) {
-            Token *tok1 = tok->tokAt(5);
-            while (tok1->str() != ",")
-                tok1 = tok1->next();
-            tok1->str(";");
+        bool isconst = false;
+        bool isstatic = false;
+        Token *tok2 = type0;
+        int typelen = 1;
 
-            const int numTokens = (Token::Match(tok, "class|struct|union")) ? 2U : 1U;
-            TokenList::insertTokens(tok1, tok, numTokens);
-            tok = initVar(tok);
+        if (Token::Match(tok2, "::|extern")) {
+            tok2 = tok2->next();
+            typelen++;
         }
-    }
-}
-
-Token * Tokenizer::initVar(Token * tok)
-{
-    // call constructor of class => no simplification
-    if (Token::Match(tok, "class|struct|union")) {
-        if (tok->strAt(2) != "*")
-            return tok;
 
-        tok = tok->next();
-    } else if (!tok->isStandardType() && tok->next()->str() != "*")
-        return tok;
-
-    // goto variable name..
-    tok = tok->next();
-    if (tok->str() == "*")
-        tok = tok->next();
+        //check if variable is declared 'const' or 'static' or both
+        while (tok2) {
+            if (!Token::Match(tok2, "const|static|constexpr") && Token::Match(tok2, "%type% const|static")) {
+                tok2 = tok2->next();
+                ++typelen;
+            }
 
-    // sizeof is not a variable name..
-    if (tok->str() == "sizeof")
-        return tok;
+            if (Token::Match(tok2, "const|constexpr"))
+                isconst = true;
 
-    // check initializer..
-    if (tok->tokAt(2)->isStandardType() || tok->strAt(2) == "void")
-        return tok;
-    else if (!tok->tokAt(2)->isNumber() && !Token::Match(tok->tokAt(2), "%type% (") && tok->strAt(2) != "&" && tok->tokAt(2)->varId() == 0)
-        return tok;
+            else if (Token::Match(tok2, "static|constexpr"))
+                isstatic = true;
 
-    // insert '; var ='
-    tok->insertToken(";");
-    tok->next()->insertToken(tok->str());
-    tok->tokAt(2)->varId(tok->varId());
-    tok = tok->tokAt(2);
-    tok->insertToken("=");
+            else if (Token::Match(tok2, "%type% :: %type%")) {
+                tok2 = tok2->next();
+                ++typelen;
+            }
 
-    // goto '('..
-    tok = tok->tokAt(2);
+            else
+                break;
 
-    // delete ')'
-    tok->link()->deleteThis();
+            if (tok2->strAt(1) == "*")
+                break;
 
-    // delete this
-    tok->deleteThis();
+            if (Token::Match(tok2->next(), "& %name% ,"))
+                break;
 
-    return tok;
-}
+            tok2 = tok2->next();
+            ++typelen;
+        }
 
+        // strange looking variable declaration => don't split up.
+        if (Token::Match(tok2, "%type% *|&| %name% , %type% *|&| %name%"))
+            continue;
 
-bool Tokenizer::simplifyKnownVariables()
-{
-    // return value for function. Set to true if any simplifications are made
-    bool ret = false;
+        if (Token::Match(tok2, "struct|union|class %type%")) {
+            tok2 = tok2->next();
+            ++typelen;
+        }
 
-    // constants..
-    {
-        std::unordered_map<int, std::string> constantValues;
-        std::map<int, Token*> constantVars;
-        std::unordered_map<int, std::list<Token*>> constantValueUsages;
-        bool goback = false;
-        for (Token *tok = list.front(); tok; tok = tok->next()) {
-            if (goback) {
-                tok = tok->previous();
-                goback = false;
-            }
-            // Reference to variable
-            if (Token::Match(tok, "%type%|* & %name% = %name% ;")) {
-                Token *start = tok->previous();
-                while (Token::Match(start,"%type%|*|&"))
-                    start = start->previous();
-                if (!Token::Match(start,"[;{}]"))
-                    continue;
-                const Token *reftok = tok->tokAt(2);
-                const Token *vartok = reftok->tokAt(2);
-                int level = 0;
-                for (Token *tok2 = tok->tokAt(6); tok2; tok2 = tok2->next()) {
-                    if (tok2->str() == "{") {
-                        ++level;
-                    } else if (tok2->str() == "}") {
-                        if (level <= 0)
-                            break;
-                        --level;
-                    } else if (tok2->varId() == reftok->varId()) {
-                        tok2->str(vartok->str());
-                        tok2->varId(vartok->varId());
-                    }
-                }
-                Token::eraseTokens(start, tok->tokAt(6));
-                tok = start;
+        // check for qualification..
+        if (Token::Match(tok2,  ":: %type%")) {
+            ++typelen;
+            tok2 = tok2->next();
+        }
+
+        //skip combinations of templates and namespaces
+        while (!isC() && (Token::Match(tok2, "%type% <") || Token::Match(tok2, "%type% ::"))) {
+            if (tok2->strAt(1) == "<" && !TemplateSimplifier::templateParameters(tok2->next())) {
+                tok2 = nullptr;
+                break;
             }
+            typelen += 2;
+            tok2 = tok2->tokAt(2);
+            if (tok2 && tok2->strAt(-1) == "::")
+                continue;
+            int indentlevel = 0;
+            int parens = 0;
+
+            for (Token *tok3 = tok2; tok3; tok3 = tok3->next()) {
+                ++typelen;
 
-            if (tok->isName() && (Token::Match(tok, "static| const| static| %type% const| %name% = %any% ;") ||
-                                  Token::Match(tok, "static| const| static| %type% const| %name% ( %any% ) ;"))) {
-                bool isconst = false;
-                for (const Token *tok2 = tok; (tok2->str() != "=") && (tok2->str() != "("); tok2 = tok2->next()) {
-                    if (tok2->str() == "const") {
-                        isconst = true;
+                if (!parens && tok3->str() == "<") {
+                    ++indentlevel;
+                } else if (!parens && tok3->str() == ">") {
+                    if (indentlevel == 0) {
+                        tok2 = tok3->next();
+                        break;
+                    }
+                    --indentlevel;
+                } else if (!parens && tok3->str() == ">>") {
+                    if (indentlevel <= 1) {
+                        tok2 = tok3->next();
+                        break;
+                    }
+                    indentlevel -= 2;
+                } else if (tok3->str() == "(") {
+                    ++parens;
+                } else if (tok3->str() == ")") {
+                    if (!parens) {
+                        tok2 = nullptr;
                         break;
                     }
+                    --parens;
+                } else if (tok3->str() == ";") {
+                    break;
                 }
-                if (!isconst)
-                    continue;
+            }
 
-                Token *tok1 = tok;
+            if (Token::Match(tok2,  ":: %type%")) {
+                ++typelen;
+                tok2 = tok2->next();
+            }
 
-                // start of statement
-                if (tok != list.front() && !Token::Match(tok->previous(),";|{|}|private:|protected:|public:"))
-                    continue;
-                // skip "const" and "static"
-                while (Token::Match(tok, "const|static"))
-                    tok = tok->next();
-                // pod type
-                if (!tok->isStandardType())
-                    continue;
+            // east const
+            if (Token::simpleMatch(tok2, "const"))
+                isconst = true;
+        }
 
-                Token * const vartok = (tok->next() && tok->next()->str() == "const") ? tok->tokAt(2) : tok->next();
-                const Token * const valuetok = vartok->tokAt(2);
-                if (Token::Match(valuetok, "%bool%|%char%|%num%|%str% )| ;")) {
-                    // record a constant value for this variable
-                    constantValues[vartok->varId()] = valuetok->str();
-                    constantVars[vartok->varId()] = tok1;
-                }
-            } else if (tok->varId()) {
-                // find the entry for the known variable, if any.  Exclude the location where the variable is assigned with next == "="
-                if (constantValues.find(tok->varId()) != constantValues.end() && tok->next()->str() != "=") {
-                    constantValueUsages[tok->varId()].push_back(tok);
-                }
+        //pattern: "%type% *| ... *| const| %name% ,|="
+        if (Token::Match(tok2, "%type%") ||
+            (tok2 && tok2->previous() && tok2->strAt(-1) == ">")) {
+            Token *varName = tok2;
+            if (!tok2->previous() || tok2->strAt(-1) != ">")
+                varName = varName->next();
+            else
+                --typelen;
+            if (cpp && Token::Match(varName, "public:|private:|protected:|using"))
+                continue;
+            //skip all the pointer part
+            bool isPointerOrRef = false;
+            while (Token::simpleMatch(varName, "*") || Token::Match(varName, "& %name% ,")) {
+                isPointerOrRef = true;
+                varName = varName->next();
             }
-        }
 
-        for (auto constantVar = constantVars.rbegin(); constantVar != constantVars.rend(); constantVar++) {
-            bool referenceFound = false;
-            std::list<Token*> usageList = constantValueUsages[constantVar->first];
-            for (Token* usage : usageList) {
-                // check if any usages of each known variable are a reference
-                if (Token::Match(usage->tokAt(-2), "(|[|,|{|return|%op% & %varid%", constantVar->first)) {
-                    referenceFound = true;
-                    break;
+            while (Token::Match(varName, "%type% %type%")) {
+                if (varName->str() != "const" && varName->str() != "volatile") {
+                    ++typelen;
                 }
+                varName = varName->next();
+            }
+            // Function pointer
+            if (Token::simpleMatch(varName, "( *") &&
+                isFunctionPointer(varName->link()->previous()) &&
+                Token::simpleMatch(varName->link()->linkAt(1), ") =")) {
+                Token *endDecl = varName->link()->linkAt(1);
+                varName = varName->link()->previous();
+                endDecl->insertToken(";");
+                endDecl = endDecl->next();
+                endDecl->next()->isSplittedVarDeclEq(true);
+                endDecl->insertToken(varName->str());
+                if (!varName->getMacroName().empty())
+                    endDecl->next()->setMacroName(varName->getMacroName());
+                continue;
             }
+            //non-VLA case
+            if (Token::Match(varName, "%name% ,|=")) {
+                if (varName->str() != "operator") {
+                    tok2 = varName->next(); // The ',' or '=' token
 
-            if (!referenceFound) {
-                // replace all usages of non-referenced known variables with their value
-                for (Token* usage : usageList) {
-                    usage->str(constantValues[constantVar->first]);
-                }
+                    if (tok2->str() == "=" && (isstatic || (isconst && !isPointerOrRef))) {
+                        //do not split const non-pointer variables..
+                        while (tok2 && tok2->str() != "," && tok2->str() != ";") {
+                            if (Token::Match(tok2, "{|(|["))
+                                tok2 = tok2->link();
+                            const Token *tok3 = tok2;
+                            if (!isC() && tok2->str() == "<" && TemplateSimplifier::templateParameters(tok2) > 0) {
+                                tok2 = tok2->findClosingBracket();
+                            }
+                            if (!tok2)
+                                syntaxError(tok3); // #6881 invalid code
+                            tok2 = tok2->next();
+                        }
+                        if (tok2 && tok2->str() == ";")
+                            tok2 = nullptr;
+                    }
+                } else
+                    tok2 = nullptr;
+            }
 
-                Token* startTok = constantVar->second;
-                // remove variable assignment statement
-                while (startTok->next()->str() != ";")
-                    startTok->deleteNext();
-                startTok->deleteNext();
+            //VLA case
+            else if (Token::Match(varName, "%name% [")) {
+                tok2 = varName->next();
 
-                // #8579 if we can we want another token to delete startTok. if we can't it doesn't matter
-                if (startTok->previous()) {
-                    startTok->previous()->deleteNext();
-                } else if (startTok->next()) {
-                    startTok->next()->deletePrevious();
-                } else {
-                    startTok->deleteThis();
+                while (Token::Match(tok2->link(), "] [,=[{]"))
+                    tok2 = tok2->link()->next();
+                if (!Token::Match(tok2, "[=,{]"))
+                    tok2 = nullptr;
+                if (tok2 && tok2->str() == "=") {
+                    while (tok2 && tok2->str() != "," && tok2->str() != ";") {
+                        if (Token::Match(tok2, "{|(|["))
+                            tok2 = tok2->link();
+                        tok2 = tok2->next();
+                    }
+                    if (tok2 && tok2->str() == ";")
+                        tok2 = nullptr;
                 }
-                startTok = nullptr;
-
-                constantVar->second = nullptr;
-                ret = true;
             }
-        }
-    }
 
-    // variable id for local, float/double, array variables
-    std::set<int> localvars;
-    std::set<int> floatvars;
-    std::set<int> arrays;
-
-    // auto variables..
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        // Search for a block of code
-        Token * const start = const_cast<Token *>(startOfExecutableScope(tok));
-        if (!start)
-            continue;
+            // brace initialization
+            else if (Token::Match(varName, "%name% {")) {
+                tok2 = varName->next();
+                tok2 = tok2->link();
+                if (tok2)
+                    tok2 = tok2->next();
+                if (tok2 && tok2->str() != ",")
+                    tok2 = nullptr;
+            }
 
-        for (const Token *tok2 = start->previous(); tok2 && !Token::Match(tok2, "[;{}]"); tok2 = tok2->previous()) {
-            if (tok2->varId() != 0)
-                localvars.insert(tok2->varId());
-        }
-
-        tok = start;
-        // parse the block of code..
-        int indentlevel = 0;
-        Token *tok2 = tok;
-        for (; tok2; tok2 = tok2->next()) {
-            if (Token::Match(tok2, "[;{}] %type% %name%|*")) {
-                bool isfloat = false;
-                bool ispointer = false;
-                const Token *vartok = tok2->next();
-                while (Token::Match(vartok, "%name%|* %name%|*")) {
-                    if (Token::Match(vartok, "float|double"))
-                        isfloat = true;
-                    if (vartok->str() == "*")
-                        ispointer = true;
-                    vartok = vartok->next();
+            // function declaration
+            else if (Token::Match(varName, "%name% (")) {
+                Token* commaTok = varName->linkAt(1)->next();
+                while (Token::Match(commaTok, "const|noexcept|override|final")) {
+                    commaTok = commaTok->next();
+                    if (Token::Match(commaTok, "( true|false )"))
+                        commaTok = commaTok->link()->next();
                 }
-                if (Token::Match(vartok, "%var% ;|["))
-                    localvars.insert(vartok->varId());
-                if (isfloat && !ispointer && Token::Match(vartok, "%var% ;"))
-                    floatvars.insert(vartok->varId());
-                if (Token::Match(vartok, "%var% ["))
-                    arrays.insert(vartok->varId());
+                tok2 = Token::simpleMatch(commaTok, ",") ? commaTok : nullptr;
             }
 
-            if (tok2->str() == "{")
-                ++indentlevel;
+            else
+                tok2 = nullptr;
+        } else {
+            tok2 = nullptr;
+        }
 
-            else if (tok2->str() == "}") {
-                --indentlevel;
-                if (indentlevel <= 0)
-                    break;
-            }
+        if (!tok2) {
+            if (only_k_r_fpar)
+                finishedwithkr = false;
+            continue;
+        }
+
+        if (tok2->str() == ",") {
+            tok2->str(";");
+            tok2->isSplittedVarDeclComma(true);
+            //TODO: should we have to add also template '<>' links?
+            TokenList::insertTokens(tok2, type0, typelen);
+        }
 
-            else if (Token::simpleMatch(tok2, "for ("))
-                tok2 = tok2->next()->link();
+        else {
+            Token *eq = tok2;
 
-            else if (tok2->previous()->str() != "*" && !Token::Match(tok2->tokAt(-2), "* --|++") &&
-                     (Token::Match(tok2, "%name% = %bool%|%char%|%num%|%str%|%name% ;") ||
-                      Token::Match(tok2, "%name% [ %num%| ] = %str% ;") ||
-                      Token::Match(tok2, "%name% = & %name% ;") ||
-                      (Token::Match(tok2, "%name% = & %name% [ 0 ] ;") && arrays.find(tok2->tokAt(3)->varId()) != arrays.end()))) {
-                const int varid = tok2->varId();
-                if (varid == 0)
-                    continue;
+            while (tok2) {
+                if (Token::Match(tok2, "{|(|["))
+                    tok2 = tok2->link();
 
-                if (Token::Match(tok2->previous(), "[;{}]") && localvars.find(varid) == localvars.end())
-                    continue;
+                else if (!isC() && tok2->str() == "<" && ((tok2->previous()->isName() && !tok2->previous()->varId()) || tok2->strAt(-1) == "]"))
+                    tok2 = tok2->findClosingBracket();
 
-                // initialization of static variable => the value is not *known*
-                {
-                    bool isstatic = false;
-                    const Token *decl = tok2->previous();
-                    while (decl && (decl->isName() || decl->str() == "*")) {
-                        if (decl->str() == "static") {
-                            isstatic = true;
-                            break;
-                        }
-                        decl = decl->previous();
+                else if (std::strchr(";,", tok2->str()[0])) {
+                    // "type var ="   =>   "type var; var ="
+                    const Token *varTok = type0->tokAt(typelen);
+                    while (Token::Match(varTok, "%name%|*|& %name%|*|&"))
+                        varTok = varTok->next();
+                    if (!varTok)
+                        syntaxError(tok2); // invalid code
+                    if (eq->str() == "=") {
+                        TokenList::insertTokens(eq, varTok, 2);
+                        eq->str(";");
+                        eq->isSplittedVarDeclEq(true);
                     }
-                    if (isstatic)
-                        continue;
-                }
 
-                // skip loop variable
-                if (Token::Match(tok2->tokAt(-2), "(|:: %type%")) {
-                    const Token *tok3 = tok2->previous();
-                    do {
-                        tok3 = tok3->tokAt(-2);
-                    } while (Token::Match(tok3->previous(), ":: %type%"));
-                    if (Token::Match(tok3->tokAt(-2), "for ( %type%"))
-                        continue;
+                    // "= x, "   =>   "= x; type "
+                    if (tok2->str() == ",") {
+                        tok2->str(";");
+                        tok2->isSplittedVarDeclComma(true);
+                        TokenList::insertTokens(tok2, type0, typelen);
+                    }
+                    break;
                 }
+                if (tok2)
+                    tok2 = tok2->next();
+            }
+        }
+        finishedwithkr = (only_k_r_fpar && tok2 && tok2->strAt(1) == "{");
+    }
+}
 
-                // struct name..
-                if (Token::Match(tok2, "%varid% = &| %varid%", tok2->varId()))
-                    continue;
-
-                const std::string structname = Token::Match(tok2->tokAt(-3), "[;{}] %name% .") ?
-                                               std::string(tok2->strAt(-2) + " .") :
-                                               std::string();
-
-                const Token * const valueToken = tok2->tokAt(2);
-
-                std::string value;
-                nonneg int valueVarId = 0;
-
-                Token *tok3 = nullptr;
-                bool valueIsPointer = false;
-
-                // there could be a hang here if tok2 is moved back by the function calls below for some reason
-                if (Settings::terminated())
-                    return false;
+void Tokenizer::simplifyStaticConst()
+{
+    // This function will simplify the token list so that the qualifiers "extern", "static"
+    // and "const" appear in the same order as in the array below.
+    static const std::array<std::string, 3> qualifiers = {"extern", "static", "const"};
 
-                if (!simplifyKnownVariablesGetData(varid, &tok2, &tok3, value, valueVarId, valueIsPointer, floatvars.find(tok2->varId()) != floatvars.end()))
-                    continue;
+    // Move 'const' before all other qualifiers and types and then
+    // move 'static' before all other qualifiers and types, ...
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        bool continue2 = false;
+        for (std::size_t i = 0; i < qualifiers.size(); i++) {
 
-                if (valueVarId > 0 && arrays.find(valueVarId) != arrays.end())
-                    continue;
+            // Keep searching for a qualifier
+            if (!tok->next() || tok->strAt(1) != qualifiers[i])
+                continue;
 
-                ret |= simplifyKnownVariablesSimplify(&tok2, tok3, varid, structname, value, valueVarId, valueIsPointer, valueToken, indentlevel);
+            // Look backwards to find the beginning of the declaration
+            Token* leftTok = tok;
+            bool behindOther = false;
+            for (; leftTok; leftTok = leftTok->previous()) {
+                behindOther = std::any_of(qualifiers.cbegin(), qualifiers.cbegin() + i + 1, [&](const std::string& q) {
+                    return q == leftTok->str();
+                });
+                if (behindOther)
+                    break;
+                if (isCPP() && Token::simpleMatch(leftTok, ">")) {
+                    Token* opening = leftTok->findOpeningBracket();
+                    if (opening) {
+                        leftTok = opening;
+                        continue;
+                    }
+                }
+                if (!Token::Match(leftTok, "%type%|struct|::") ||
+                    (isCPP() && Token::Match(leftTok, "private:|protected:|public:|operator|template"))) {
+                    break;
+                }
             }
 
-            else if (Token::Match(tok2, "strcpy|sprintf ( %name% , %str% ) ;")) {
-                const int varid(tok2->tokAt(2)->varId());
-                if (varid == 0)
-                    continue;
+            // The token preceding the declaration should indicate the start of a declaration
+            if (leftTok == tok)
+                continue;
 
-                const Token * const valueToken = tok2->tokAt(4);
-                std::string value(valueToken->str());
-                if (tok2->str() == "sprintf") {
-                    std::string::size_type n = 0;
-                    while ((n = value.find("%%", n)) != std::string::npos) {
-                        // Replace "%%" with "%" - erase the first '%' and continue past the second '%'
-                        value.erase(n, 1);
-                        ++n;
-                    }
-                }
-                const int valueVarId(0);
-                const bool valueIsPointer(false);
-                Token *tok3 = tok2->tokAt(6);
-                ret |= simplifyKnownVariablesSimplify(&tok2, tok3, varid, emptyString, value, valueVarId, valueIsPointer, valueToken, indentlevel);
+            if (leftTok && !behindOther && !Token::Match(leftTok, ";|{|}|(|,|private:|protected:|public:")) {
+                continue2 = true;
+                break;
+            }
 
-                // there could be a hang here if tok2 was moved back by the function call above for some reason
-                if (Settings::terminated())
-                    return false;
+            // Move the qualifier to the left-most position in the declaration
+            const int column = tok->next()->column();
+            tok->deleteNext();
+            if (!leftTok) {
+                list.front()->insertToken(qualifiers[i]);
+                list.front()->swapWithNext();
+                list.front()->column(column);
+                tok = list.front();
+            } else if (leftTok->next()) {
+                leftTok->next()->insertTokenBefore(qualifiers[i]);
+                leftTok->next()->column(column);
+                tok = leftTok->next();
+            } else {
+                leftTok->insertToken(qualifiers[i]);
+                leftTok->next()->column(column);
+                tok = leftTok;
             }
         }
-
-        if (tok2)
-            tok = tok2->previous();
+        if (continue2)
+            continue;
     }
-
-    return ret;
 }
 
-bool Tokenizer::simplifyKnownVariablesGetData(nonneg int varid, Token **_tok2, Token **_tok3, std::string &value, nonneg int &valueVarId, bool &valueIsPointer, bool floatvar)
+void Tokenizer::simplifyVariableMultipleAssign()
 {
-    Token *tok2 = *_tok2;
-    Token *tok3 = nullptr;
-
-    if (Token::simpleMatch(tok2->tokAt(-2), "for (")) {
-        // only specific for loops is handled
-        if (!Token::Match(tok2, "%varid% = %num% ; %varid% <|<= %num% ; ++| %varid% ++| ) {", varid))
-            return false;
-
-        // is there a "break" in the for loop?
-        bool hasbreak = false;
-        const Token* end4 = tok2->linkAt(-1)->linkAt(1);
-        for (const Token *tok4 = tok2->previous()->link(); tok4 != end4; tok4 = tok4->next()) {
-            if (tok4->str() == "break") {
-                hasbreak = true;
-                break;
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (Token::Match(tok, "%name% = %name% = %num%|%name% ;")) {
+            // skip intermediate assignments
+            Token *tok2 = tok->previous();
+            while (tok2 &&
+                   tok2->str() == "=" &&
+                   Token::Match(tok2->previous(), "%name%")) {
+                tok2 = tok2->tokAt(-2);
             }
-        }
-        if (hasbreak)
-            return false;
-
-        // no break => the value of the counter value is known after the for loop..
-        const Token* compareTok = tok2->tokAt(5);
-        if (compareTok->str() == "<") {
-            value = compareTok->next()->str();
-            valueVarId = compareTok->next()->varId();
-        } else
-            value = MathLib::toString(MathLib::toLongNumber(compareTok->next()->str()) + 1);
-
-        // Skip for-body..
-        tok3 = tok2->previous()->link()->next()->link()->next();
-    } else {
-        value = tok2->strAt(2);
-        valueVarId = tok2->tokAt(2)->varId();
-        if (tok2->strAt(1) == "[") {
-            value = tok2->next()->link()->strAt(2);
-            valueVarId = 0;
-        } else if (value == "&") {
-            value = tok2->strAt(3);
-            valueVarId = tok2->tokAt(3)->varId();
 
-            // *ptr = &var; *ptr = 5;
-            // equals
-            // var = 5; not *var = 5;
-            if (tok2->strAt(4) == ";")
-                valueIsPointer = true;
-        }
+            if (!tok2 || tok2->str() != ";") {
+                continue;
+            }
 
-        // Add a '.0' to a decimal value and therefore convert it to an floating point number.
-        else if (MathLib::isDec(tok2->strAt(2)) && floatvar) {
-            value += ".0";
-        }
+            Token *stopAt = tok->tokAt(2);
+            const Token *valueTok = stopAt->tokAt(2);
+            const std::string& value(valueTok->str());
+            tok2 = tok2->next();
 
-        // float variable: convert true/false to 1.0 / 0.0
-        else if (tok2->tokAt(2)->isBoolean() && floatvar) {
-            value = (value == "true") ? "1.0" : "0.0";
+            while (tok2 != stopAt) {
+                tok2->next()->insertToken(";");
+                tok2->next()->insertToken(value);
+                tok2 = tok2->tokAt(4);
+            }
         }
-
-        if (Token::simpleMatch(tok2->next(), "= &"))
-            tok2 = tok2->tokAt(3);
-
-        tok3 = tok2->next();
     }
-    *_tok2 = tok2;
-    *_tok3 = tok3;
-    return true;
 }
 
-bool Tokenizer::simplifyKnownVariablesSimplify(Token **tok2, Token *tok3, nonneg int varid, const std::string &structname, std::string &value, nonneg int valueVarId, bool valueIsPointer, const Token * const valueToken, int indentlevel) const
-{
-    const bool pointeralias(valueToken->isName() || Token::Match(valueToken, "& %name% ["));
-    const bool varIsGlobal = (indentlevel == 0);
-    const bool printDebug = mSettings->debugwarnings;
-
-    if (mErrorLogger && !list.getFiles().empty())
-        mErrorLogger->reportProgress(list.getFiles()[0], "Tokenize (simplifyKnownVariables)", tok3->progressValue());
+// Binary operators simplification map
+static const std::unordered_map<std::string, std::string> cAlternativeTokens = {
+    std::make_pair("and", "&&")
+    , std::make_pair("and_eq", "&=")
+    , std::make_pair("bitand", "&")
+    , std::make_pair("bitor", "|")
+    , std::make_pair("not_eq", "!=")
+    , std::make_pair("or", "||")
+    , std::make_pair("or_eq", "|=")
+    , std::make_pair("xor", "^")
+    , std::make_pair("xor_eq", "^=")
+};
 
-    if (isMaxTime())
-        return false;
+// Simplify the C alternative tokens:
+//  and      =>     &&
+//  and_eq   =>     &=
+//  bitand   =>     &
+//  bitor    =>     |
+//  compl    =>     ~
+//  not      =>     !
+//  not_eq   =>     !=
+//  or       =>     ||
+//  or_eq    =>     |=
+//  xor      =>     ^
+//  xor_eq   =>     ^=
+bool Tokenizer::simplifyCAlternativeTokens()
+{
+    /* executable scope level */
+    int executableScopeLevel = 0;
 
-    bool ret = false;
+    std::vector<Token *> alt;
+    bool replaceAll = false;  // replace all or none
 
-    Token* bailOutFromLoop = nullptr;
-    int indentlevel3 = indentlevel;
-    bool ret3 = false;
-    for (; tok3; tok3 = tok3->next()) {
-        if (tok3->str() == "{") {
-            ++indentlevel3;
-        } else if (tok3->str() == "}") {
-            --indentlevel3;
-            if (indentlevel3 < indentlevel) {
-                if (Token::Match((*tok2)->tokAt(-7), "%type% * %name% ; %name% = & %name% ;") &&
-                    (*tok2)->strAt(-5) == (*tok2)->strAt(-3)) {
-                    (*tok2) = (*tok2)->tokAt(-4);
-                    Token::eraseTokens((*tok2), (*tok2)->tokAt(6));
-                }
-                break;
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (tok->str() == ")") {
+            if (const Token *end = TokenList::isFunctionHead(tok, "{")) {
+                ++executableScopeLevel;
+                tok = const_cast<Token *>(end);
+                continue;
             }
         }
 
-        // Stop if there is a pointer alias and a shadow variable is
-        // declared in an inner scope (#3058)
-        if (valueIsPointer && tok3->varId() > 0 &&
-            tok3->previous() && (tok3->previous()->isName() || tok3->previous()->str() == "*") &&
-            valueToken->str() == "&" &&
-            valueToken->next() &&
-            valueToken->next()->isName() &&
-            tok3->str() == valueToken->next()->str() &&
-            tok3->varId() > valueToken->next()->varId()) {
-            // more checking if this is a variable declaration
-            bool decl = true;
-            for (const Token *tok4 = tok3->previous(); tok4; tok4 = tok4->previous()) {
-                if (Token::Match(tok4, "[;{}]"))
-                    break;
-
-                else if (tok4->isName()) {
-                    if (tok4->varId() > 0) {
-                        decl = false;
-                        break;
-                    }
-                }
-
-                else if (!Token::Match(tok4, "[&*]")) {
-                    decl = false;
-                    break;
-                }
-            }
-            if (decl)
-                break;
+        if (tok->str() == "{") {
+            if (executableScopeLevel > 0)
+                ++executableScopeLevel;
+            continue;
         }
 
-        // Stop if label is found
-        if (Token::Match(tok3, "; %type% : ;"))
-            break;
-
-        // Stop if break/continue is found ..
-        if (Token::Match(tok3, "break|continue"))
-            break;
-        if ((indentlevel3 > 1 || !Token::simpleMatch(Token::findsimplematch(tok3,";"), "; }")) && tok3->str() == "return")
-            ret3 = true;
-        if (ret3 && tok3->str() == ";")
-            break;
+        if (tok->str() == "}") {
+            if (executableScopeLevel > 0)
+                --executableScopeLevel;
+            continue;
+        }
 
-        if (pointeralias && Token::Match(tok3, ("!!= " + value).c_str()))
-            break;
+        if (!tok->isName())
+            continue;
 
-        // Stop if a loop is found
-        if (pointeralias && Token::Match(tok3, "do|for|while"))
-            break;
+        const auto cOpIt = cAlternativeTokens.find(tok->str());
+        if (cOpIt != cAlternativeTokens.end()) {
+            alt.push_back(tok);
 
-        // Stop if unknown function call is seen and the variable is global: it might be
-        // changed by the function call
-        if (varIsGlobal && tok3->str() == ")" && tok3->link() &&
-            Token::Match(tok3->link()->tokAt(-2), "[;{}] %name% (") &&
-            !Token::Match(tok3->link()->previous(), "if|for|while|switch|BOOST_FOREACH"))
-            break;
+            // Is this a variable declaration..
+            if (isC() && Token::Match(tok->previous(), "%type%|* %name% [;,=]"))
+                return false;
 
-        // Stop if something like 'while (--var)' is found
-        if (Token::Match(tok3, "for|while|do")) {
-            const Token *endpar = tok3->next()->link();
-            if (Token::simpleMatch(endpar, ") {"))
-                endpar = endpar->next()->link();
-            bool bailout = false;
-            for (const Token *tok4 = tok3; tok4 && tok4 != endpar; tok4 = tok4->next()) {
-                if (Token::Match(tok4, "++|-- %varid%", varid) ||
-                    Token::Match(tok4, "%varid% ++|--|=", varid)) {
-                    bailout = true;
-                    break;
-                }
+            if (!Token::Match(tok->previous(), "%name%|%num%|%char%|%str%|)|]|> %name% %name%|%num%|%char%|%op%|%str%|("))
+                continue;
+            if (Token::Match(tok->next(), "%assign%|%or%|%oror%|&&|*|/|%|^") && !Token::Match(tok->previous(), "%num%|%char%|) %name% *"))
+                continue;
+            if (executableScopeLevel == 0 && Token::Match(tok, "%name% (")) {
+                const Token *start = tok;
+                while (Token::Match(start, "%name%|*"))
+                    start = start->previous();
+                if (!start || Token::Match(start, "[;}]"))
+                    continue;
             }
-            if (bailout)
-                break;
-        }
+            replaceAll = true;
+        } else if (Token::Match(tok, "not|compl")) {
+            alt.push_back(tok);
 
-        if (bailOutFromLoop) {
-            // This could be a loop, skip it, but only if it doesn't contain
-            // the variable we are checking for. If it contains the variable
-            // we will bail out.
-            if (tok3->varId() == varid) {
-                // Continue
-                //tok2 = bailOutFromLoop;
-                break;
-            } else if (tok3 == bailOutFromLoop) {
-                // We have skipped the loop
-                bailOutFromLoop = nullptr;
+            if ((Token::Match(tok->previous(), "%assign%") || Token::Match(tok->next(), "%num%")) && !Token::Match(tok->next(), ".|->")) {
+                replaceAll = true;
                 continue;
             }
 
-            continue;
-        } else if (tok3->str() == "{" && tok3->previous()->str() == ")") {
-            // There is a possible loop after the assignment. Try to skip it.
-            if (tok3->previous()->link() &&
-                tok3->previous()->link()->strAt(-1) != "if")
-                bailOutFromLoop = tok3->link();
-            continue;
-        }
-
-        // Variable used in realloc (see Ticket #1649)
-        if (Token::Match(tok3, "%name% = realloc ( %name% ,") &&
-            tok3->varId() == varid &&
-            tok3->tokAt(4)->varId() == varid) {
-            tok3->tokAt(4)->str(value);
-            ret = true;
-        }
-
-        // condition "(|&&|%OROR% %varid% )|&&|%OROR%|;
-        if (!Token::Match(tok3->previous(), "( %name% )") &&
-            Token::Match(tok3->previous(), "&&|(|%oror% %varid% &&|%oror%|)|;", varid)) {
-            tok3->str(value);
-            tok3->varId(valueVarId);
-            ret = true;
-        }
+            // Don't simplify 'not p;' (in case 'not' is a type)
+            if (!Token::Match(tok->next(), "%name%|(") ||
+                Token::Match(tok->previous(), "[;{}]") ||
+                (executableScopeLevel == 0U && tok->strAt(-1) == "("))
+                continue;
 
-        // parameter in function call..
-        if (tok3->varId() == varid && Token::Match(tok3->previous(), "[(,] %name% [,)]")) {
-            // If the parameter is passed by value then simplify it
-            if (isFunctionParameterPassedByValue(tok3)) {
-                tok3->str(value);
-                tok3->varId(valueVarId);
-                ret = true;
-            }
+            replaceAll = true;
         }
+    }
 
-        // Variable is used somehow in a non-defined pattern => bail out
-        if (tok3->varId() == varid) {
-            // This is a really generic bailout so let's try to avoid this.
-            // There might be lots of false negatives.
-            if (printDebug) {
-                // FIXME: Fix all the debug warnings for values and then
-                // remove this bailout
-                if (pointeralias)
-                    break;
-
-                // suppress debug-warning when calling member function
-                if (Token::Match(tok3->next(), ". %name% ("))
-                    break;
-
-                // suppress debug-warning when assignment
-                if (tok3->strAt(1) == "=")
-                    break;
-
-                // taking address of variable..
-                if (Token::Match(tok3->tokAt(-2), "return|= & %name% ;"))
-                    break;
-
-                // parameter in function call..
-                if (Token::Match(tok3->tokAt(-2), "%name% ( %name% ,|)") ||
-                    Token::Match(tok3->previous(), ", %name% ,|)"))
-                    break;
+    if (!replaceAll)
+        return false;
 
-                // conditional increment
-                if (Token::Match(tok3->tokAt(-3), ") { ++|--") ||
-                    Token::Match(tok3->tokAt(-2), ") { %name% ++|--"))
-                    break;
+    for (Token *tok: alt) {
+        const auto cOpIt = cAlternativeTokens.find(tok->str());
+        if (cOpIt != cAlternativeTokens.end())
+            tok->str(cOpIt->second);
+        else if (tok->str() == "not")
+            tok->str("!");
+        else
+            tok->str("~");
+    }
 
-                reportError(tok3, Severity::debug, "debug",
-                            "simplifyKnownVariables: bailing out (variable="+tok3->str()+", value="+value+")");
-            }
+    return !alt.empty();
+}
 
-            break;
-        }
+// int i(0); => int i; i = 0;
+// int i(0), j; => int i; i = 0; int j;
+void Tokenizer::simplifyInitVar()
+{
+    if (isC())
+        return;
 
-        // Using the variable in condition..
-        if (Token::Match(tok3->previous(), ("if ( " + structname + " %varid% %cop%|)").c_str(), varid) ||
-            Token::Match(tok3, ("( " + structname + " %varid% %comp%").c_str(), varid) ||
-            Token::Match(tok3, ("%comp%|!|= " + structname + " %varid% %cop%|)|;").c_str(), varid) ||
-            Token::Match(tok3->previous(), "strlen|free ( %varid% )", varid)) {
-            if (value[0] == '\"' && tok3->previous()->str() != "strlen") {
-                // bail out if value is a string unless if it's just given
-                // as parameter to strlen
-                break;
-            }
-            if (!structname.empty()) {
-                tok3->deleteNext(2);
-            }
-            if (Token::Match(valueToken, "& %name% ;")) {
-                tok3->insertToken("&");
-                tok3 = tok3->next();
-            }
-            tok3 = tok3->next();
-            tok3->str(value);
-            tok3->varId(valueVarId);
-            ret = true;
-        }
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (!tok->isName() || (tok->previous() && !Token::Match(tok->previous(), "[;{}]")))
+            continue;
 
-        // pointer alias used in condition..
-        if (Token::Match(valueToken,"& %name% ;") && Token::Match(tok3, ("( * " + structname + " %varid% %cop%").c_str(), varid)) {
-            tok3->deleteNext();
-            if (!structname.empty())
-                tok3->deleteNext(2);
-            tok3 = tok3->next();
-            tok3->str(value);
-            tok3->varId(valueVarId);
-            ret = true;
-        }
+        if (tok->str() == "return")
+            continue;
 
-        // Delete pointer alias
-        if (isCPP() && pointeralias && (tok3->str() == "delete") && tok3->next() &&
-            (Token::Match(tok3->next(), "%varid% ;", varid) ||
-             Token::Match(tok3->next(), "[ ] %varid%", varid))) {
-            tok3 = (tok3->next()->str() == "[") ? tok3->tokAt(3) : tok3->next();
-            tok3->str(value);
-            tok3->varId(valueVarId);
-            ret = true;
-        }
+        if (Token::Match(tok, "%type% *|&| %name% (|{")) {
+            bool isNamespace = Token::simpleMatch(tok, "namespace");
+            while (tok && !Token::Match(tok, "(|{"))
+                tok = tok->next();
+            if (isNamespace)
+                continue;
+            if (tok)
+                tok->isInitBracket(true);
+            /* tok = initVar(tok);
+               } else if (Token::Match(tok, "%type% *| %name% ( %type% (")) {
+               const Token* tok2 = tok->tokAt(2);
+               if (!tok2->link())
+                tok2 = tok2->next();
+               if (!tok2->link() || (tok2->link()->strAt(1) == ";" && !Token::simpleMatch(tok2->linkAt(2), ") (")))
+                tok = initVar(tok);
+               } else if (Token::Match(tok, "class|struct|union| %type% *| %name% ( &| %any% ) ,") && tok->str() != "new") {
+               Token *tok1 = tok->tokAt(5);
+               while (tok1->str() != ",")
+                tok1 = tok1->next();
+               tok1->str(";");
 
-        // Variable is used in function call..
-        if (Token::Match(tok3, ("%name% ( " + structname + " %varid% ,").c_str(), varid)) {
-            static const char * const functionName[] = {
-                // always simplify
-                "strcmp", "strdup",
-                // don't simplify buffer value
-                "memcmp","memcpy","memmove","memset","strcpy","strncmp","strncpy"
-            };
-            for (int i = 0; i < (sizeof(functionName) / sizeof(*functionName)); ++i) {
-                if (valueVarId == 0U && i >= 2)
-                    break;
-                if (tok3->str() == functionName[i]) {
-                    Token *par1 = tok3->tokAt(2);
-                    if (!structname.empty()) {
-                        par1->deleteNext();
-                        par1->deleteThis();
-                    }
-                    par1->str(value);
-                    par1->varId(valueVarId);
-                    break;
-                }
-            }
+               const int numTokens = (Token::Match(tok, "class|struct|union")) ? 2 : 1;
+               TokenList::insertTokens(tok1, tok, numTokens);
+               tok = initVar(tok); */
         }
+    }
+}
 
-        // Variable is used as 2nd parameter in function call..
-        if (Token::Match(tok3, ("%name% ( %any% , " + structname + " %varid% ,|)").c_str(), varid)) {
-            static const char * const functionName[] = {
-                // always simplify
-                "strcmp","strcpy","strncmp","strncpy",
-                // don't simplify buffer value
-                "memcmp","memcpy","memmove"
-            };
-            for (int i = 0; i < (sizeof(functionName) / sizeof(*functionName)); ++i) {
-                if (valueVarId == 0U && i >= 4)
-                    break;
-                if (tok3->str() == functionName[i]) {
-                    Token *par = tok3->tokAt(4);
-                    if (!structname.empty()) {
-                        par->deleteNext();
-                        par->deleteThis();
-                    }
-                    par->str(value);
-                    par->varId(valueVarId);
-                    break;
-                }
-            }
-        }
+Token * Tokenizer::initVar(Token * tok)
+{
+    // call constructor of class => no simplification
+    if (Token::Match(tok, "class|struct|union")) {
+        if (tok->strAt(2) != "*")
+            return tok;
 
-        // array usage
-        if (value[0] != '\"' && Token::Match(tok3, ("[(,] " + structname + " %varid% [|%cop%").c_str(), varid)) {
-            if (!structname.empty()) {
-                tok3->deleteNext(2);
-            }
-            tok3 = tok3->next();
-            tok3->str(value);
-            tok3->varId(valueVarId);
-            ret = true;
-        }
+        tok = tok->next();
+    } else if (!tok->isStandardType() && tok->str() != "auto" && tok->strAt(1) != "*")
+        return tok;
 
-        // The >> operator is sometimes used to assign a variable in C++
-        if (isCPP() && Token::Match(tok3, (">> " + structname + " %varid%").c_str(), varid)) {
-            // bailout for such code:   ; std :: cin >> i ;
-            const Token *prev = tok3->previous();
-            while (prev && prev->str() != "return" && Token::Match(prev, "%name%|::|*"))
-                prev = prev->previous();
-            if (Token::Match(prev, ";|{|}|>>"))
-                break;
-        }
+    // goto variable name..
+    tok = tok->next();
+    if (tok->str() == "*")
+        tok = tok->next();
 
-        // Variable is used in calculation..
-        if (((tok3->previous()->varId() > 0) && Token::Match(tok3, ("& " + structname + " %varid%").c_str(), varid)) ||
-            (Token::Match(tok3, ("[=+-*/%^|[] " + structname + " %varid% [=?+-*/%^|;])]").c_str(), varid) && !Token::Match(tok3, ("= " + structname + " %name% =").c_str())) ||
-            Token::Match(tok3, ("[(=+-*/%^|[] " + structname + " %varid% <<|>>").c_str(), varid) ||
-            Token::Match(tok3, ("<<|>> " + structname + " %varid% %cop%|;|]|)").c_str(), varid) ||
-            Token::Match(tok3->previous(), ("[=+-*/%^|[] ( " + structname + " %varid% !!=").c_str(), varid)) {
-            if (value[0] == '\"')
-                break;
-            if (!structname.empty()) {
-                tok3->deleteNext(2);
-                ret = true;
-            }
-            tok3 = tok3->next();
-            if (tok3->str() != value)
-                ret = true;
-            tok3->str(value);
-            tok3->varId(valueVarId);
-            if (tok3->previous()->str() == "*" && (valueIsPointer || Token::Match(valueToken, "& %name% ;"))) {
-                tok3 = tok3->previous();
-                tok3->deleteThis();
-                ret = true;
-            } else if (Token::Match(valueToken, "& %name% ;"))
-                tok3->insertToken("&", emptyString, true);
-        }
-
-        if (Token::simpleMatch(tok3, "= {")) {
-            const Token* const end4 = tok3->linkAt(1);
-            for (const Token *tok4 = tok3; tok4 != end4; tok4 = tok4->next()) {
-                if (Token::Match(tok4, "{|, %varid% ,|}", varid)) {
-                    tok4->next()->str(value);
-                    tok4->next()->varId(valueVarId);
-                    ret = true;
-                }
-            }
-        }
-
-        // Using the variable in for-condition..
-        if (Token::simpleMatch(tok3, "for (")) {
-            for (Token *tok4 = tok3->tokAt(2); tok4; tok4 = tok4->next()) {
-                if (Token::Match(tok4, "(|)"))
-                    break;
+    // sizeof is not a variable name..
+    if (tok->str() == "sizeof")
+        return tok;
 
-                // Replace variable used in condition..
-                if (Token::Match(tok4, "; %name% <|<=|!= %name% ; ++| %name% ++| )")) {
-                    const Token *inctok = tok4->tokAt(5);
-                    if (inctok->str() == "++")
-                        inctok = inctok->next();
-                    if (inctok->varId() == varid)
-                        break;
+    // check initializer..
+    if (tok->tokAt(2)->isStandardType() || tok->strAt(2) == "void")
+        return tok;
+    if (!tok->tokAt(2)->isNumber() && !Token::Match(tok->tokAt(2), "%type% (|{") && tok->strAt(2) != "&" && tok->tokAt(2)->varId() == 0)
+        return tok;
 
-                    if (tok4->next()->varId() == varid) {
-                        tok4->next()->str(value);
-                        tok4->next()->varId(valueVarId);
-                        ret = true;
-                    }
-                    if (tok4->tokAt(3)->varId() == varid) {
-                        tok4->tokAt(3)->str(value);
-                        tok4->tokAt(3)->varId(valueVarId);
-                        ret = true;
-                    }
-                }
-            }
-        }
+    // insert '; var ='
+    tok->insertToken(";");
+    tok->next()->insertToken(tok->str());
+    tok->next()->isSplittedVarDeclEq(true);
+    tok->tokAt(2)->varId(tok->varId());
+    tok = tok->tokAt(2);
+    tok->insertToken("=");
 
-        if (indentlevel == indentlevel3 && Token::Match(tok3->next(), "%varid% ++|--", varid) && MathLib::isInt(value)) {
-            const std::string op(tok3->strAt(2));
-            if (Token::Match(tok3, "[{};] %any% %any% ;")) {
-                tok3->deleteNext(3);
-            } else {
-                tok3 = tok3->next();
-                tok3->str(value);
-                tok3->varId(valueVarId);
-                tok3->deleteNext();
-            }
-            value = MathLib::incdec(value, op);
-            if (!Token::simpleMatch((*tok2)->tokAt(-2), "for (")) {
-                (*tok2)->tokAt(2)->str(value);
-                (*tok2)->tokAt(2)->varId(valueVarId);
-            }
-            ret = true;
-        }
+    // goto '('..
+    tok = tok->tokAt(2);
 
-        if (indentlevel == indentlevel3 && Token::Match(tok3->next(), "++|-- %varid%", varid) && MathLib::isInt(value) &&
-            !Token::Match(tok3->tokAt(3), "[.[]")) {
-            value = MathLib::incdec(value, tok3->next()->str());
-            (*tok2)->tokAt(2)->str(value);
-            (*tok2)->tokAt(2)->varId(valueVarId);
-            if (Token::Match(tok3, "[;{}] %any% %any% ;")) {
-                tok3->deleteNext(3);
-            } else {
-                tok3->deleteNext();
-                tok3->next()->str(value);
-                tok3->next()->varId(valueVarId);
-            }
-            tok3 = tok3->next();
-            ret = true;
-        }
+    // delete ')'
+    tok->link()->deleteThis();
 
-        // return variable..
-        if (Token::Match(tok3, "return %varid% %any%", varid) &&
-            valueToken->str() != "&" &&
-            (tok3->tokAt(2)->isExtendedOp() || tok3->strAt(2) == ";") &&
-            value[0] != '\"') {
-            tok3->next()->str(value);
-            tok3->next()->varId(valueVarId);
-        }
+    // delete this
+    tok->deleteThis();
 
-        else if (pointeralias && Token::Match(tok3, "return * %varid% ;", varid) && value[0] != '\"') {
-            tok3->deleteNext();
-            tok3->next()->str(value);
-            tok3->next()->varId(valueVarId);
-        }
-    }
-    return ret;
+    return tok;
 }
 
-
 void Tokenizer::elseif()
 {
     for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (!Token::simpleMatch(tok, "else if"))
+        if (tok->str() != "else")
+            continue;
+
+        if (!Token::Match(tok->previous(), ";|}"))
+            syntaxError(tok->previous());
+
+        if (!Token::Match(tok->next(), "%name%"))
             continue;
 
+        if (tok->strAt(1) != "if")
+            unknownMacroError(tok->next());
+
         for (Token *tok2 = tok; tok2; tok2 = tok2->next()) {
             if (Token::Match(tok2, "(|{|["))
                 tok2 = tok2->link();
 
             if (Token::Match(tok2, "}|;")) {
-                if (tok2->next() && tok2->next()->str() != "else") {
-                    tok->insertToken("{");
-                    tok2->insertToken("}");
+                if (tok2->next() && tok2->strAt(1) != "else") {
+                    tok->insertToken("{")->isSimplifiedScope(true);
+                    tok2->insertToken("}")->isSimplifiedScope(true);
                     Token::createMutualLinks(tok->next(), tok2->next());
                     break;
                 }
@@ -7894,6 +7974,67 @@ void Tokenizer::elseif()
 }
 
 
+void Tokenizer::simplifyIfSwitchForInit()
+{
+    if (!isCPP() || mSettings.standards.cpp < Standards::CPP17)
+        return;
+
+    const bool forInit = (mSettings.standards.cpp >= Standards::CPP20);
+
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (!Token::Match(tok, "if|switch|for ("))
+            continue;
+
+        Token *semicolon = tok->tokAt(2);
+        while (!Token::Match(semicolon, "[;)]")) {
+            if (Token::Match(semicolon, "(|{|[") && semicolon->link())
+                semicolon = semicolon->link();
+            semicolon = semicolon->next();
+        }
+        if (semicolon->str() != ";")
+            continue;
+
+        if (tok->str() ==  "for") {
+            if (!forInit)
+                continue;
+
+            // Is it a for range..
+            const Token *tok2 = semicolon->next();
+            bool rangeFor = false;
+            while (!Token::Match(tok2, "[;)]")) {
+                if (tok2->str() == "(")
+                    tok2 = tok2->link();
+                else if (!rangeFor && tok2->str() == "?")
+                    break;
+                else if (tok2->str() == ":")
+                    rangeFor = true;
+                tok2 = tok2->next();
+            }
+            if (!rangeFor || tok2->str() != ")")
+                continue;
+        }
+
+        Token *endpar = tok->linkAt(1);
+        if (!Token::simpleMatch(endpar, ") {"))
+            continue;
+
+        Token *endscope = endpar->linkAt(1);
+        if (Token::simpleMatch(endscope, "} else {"))
+            endscope = endscope->linkAt(2);
+
+        // Simplify, the initialization expression is broken out..
+        semicolon->insertToken(tok->str());
+        semicolon->next()->insertToken("(");
+        Token::createMutualLinks(semicolon->tokAt(2), endpar);
+        tok->deleteNext();
+        tok->str("{");
+        endscope->insertToken("}");
+        Token::createMutualLinks(tok, endscope->next());
+        tok->isSimplifiedScope(true);
+    }
+}
+
+
 bool Tokenizer::simplifyRedundantParentheses()
 {
     bool ret = false;
@@ -7901,9 +8042,11 @@ bool Tokenizer::simplifyRedundantParentheses()
         if (tok->str() != "(")
             continue;
 
-        if (isCPP() && Token::simpleMatch(tok->previous(), "} (") &&
-            Token::Match(tok->previous()->link()->previous(), "%name%|> {"))
-            continue;
+        if (tok->isCpp() && Token::simpleMatch(tok->previous(), "} (")) {
+            const Token* plp = tok->linkAt(-1)->previous();
+            if (Token::Match(plp, "%name%|>|] {") || (Token::simpleMatch(plp, ")") && Token::simpleMatch(plp->link()->previous(), "]")))
+                continue;
+        }
 
         if (Token::simpleMatch(tok, "( {"))
             continue;
@@ -7913,25 +8056,31 @@ bool Tokenizer::simplifyRedundantParentheses()
             continue;
         }
 
+        // Do not simplify if there is comma inside parentheses..
+        if (Token::Match(tok->previous(), "%op% (") || Token::Match(tok->link(), ") %op%")) {
+            bool innerComma = false;
+            for (const Token *inner = tok->link()->previous(); inner != tok; inner = inner->previous()) {
+                if (inner->str() == ")")
+                    inner = inner->link();
+                if (inner->str() == ",") {
+                    innerComma = true;
+                    break;
+                }
+            }
+            if (innerComma)
+                continue;
+        }
+
         // !!operator = ( x ) ;
         if (tok->strAt(-2) != "operator" &&
-            tok->previous() && tok->previous()->str() == "=" &&
-            tok->next() && tok->next()->str() != "{" &&
+            tok->previous() && tok->strAt(-1) == "=" &&
+            tok->next() && tok->strAt(1) != "{" &&
             Token::simpleMatch(tok->link(), ") ;")) {
             tok->link()->deleteThis();
             tok->deleteThis();
             continue;
         }
 
-        while (Token::simpleMatch(tok, "( (") &&
-               tok->link() && tok->link()->previous() == tok->next()->link()) {
-            // We have "(( *something* ))", remove the inner
-            // parentheses
-            tok->deleteNext();
-            tok->link()->tokAt(-2)->deleteNext();
-            ret = true;
-        }
-
         if (isCPP() && Token::Match(tok->tokAt(-2), "[;{}=(] new (") && Token::Match(tok->link(), ") [;,{}[]")) {
             // Remove the parentheses in "new (type)" constructs
             tok->link()->deleteThis();
@@ -7953,7 +8102,7 @@ bool Tokenizer::simplifyRedundantParentheses()
             ret = true;
         }
 
-        if (Token::Match(tok->previous(), "[(,;{}] ( %name% (") &&
+        if (Token::Match(tok->previous(), "[(,;{}] ( %name% (") && !tok->next()->isKeyword() &&
             tok->link()->previous() == tok->linkAt(2)) {
             // We have "( func ( *something* ))", remove the outer
             // parentheses
@@ -7972,7 +8121,7 @@ bool Tokenizer::simplifyRedundantParentheses()
 
         if (!Token::simpleMatch(tok->tokAt(-2), "operator delete") &&
             Token::Match(tok->previous(), "delete|; (") &&
-            (tok->previous()->str() != "delete" || tok->next()->varId() > 0) &&
+            (tok->strAt(-1) != "delete" || tok->next()->varId() > 0) &&
             Token::Match(tok->link(), ") ;|,")) {
             tok->link()->deleteThis();
             tok->deleteThis();
@@ -8001,20 +8150,8 @@ bool Tokenizer::simplifyRedundantParentheses()
             ret = true;
         }
 
-        if (Token::simpleMatch(tok->previous(), "? (") && Token::simpleMatch(tok->link(), ") :")) {
-            const Token *tok2 = tok->next();
-            while (tok2 && (Token::Match(tok2,"%bool%|%num%|%name%") || tok2->isArithmeticalOp()))
-                tok2 = tok2->next();
-            if (tok2 && tok2->str() == ")") {
-                tok->link()->deleteThis();
-                tok->deleteThis();
-                ret = true;
-                continue;
-            }
-        }
-
         while (Token::Match(tok->previous(), "[{([,] ( !!{") &&
-               Token::Match(tok->link(), ") [;,])]") &&
+               Token::Match(tok->link(), ") [;,])] !!{") &&
                !Token::simpleMatch(tok->tokAt(-2), "operator ,") && // Ticket #5709
                !Token::findsimplematch(tok, ",", tok->link())) {
             // We have "( ... )", remove the parentheses
@@ -8030,11 +8167,11 @@ bool Tokenizer::simplifyRedundantParentheses()
             ret = true;
         }
 
-        // Simplify "!!operator !!%name%|)|>|>> ( %num%|%bool% ) %op%|;|,|)"
+        // Simplify "!!operator !!%name%|)|]|>|>> ( %num%|%bool% ) %op%|;|,|)"
         if (Token::Match(tok, "( %bool%|%num% ) %cop%|;|,|)") &&
             tok->strAt(-2) != "operator" &&
             tok->previous() &&
-            !Token::Match(tok->previous(), "%name%|)") &&
+            !Token::Match(tok->previous(), "%name%|)|]") &&
             (!(isCPP() && Token::Match(tok->previous(),">|>>")))) {
             tok->link()->deleteThis();
             tok->deleteThis();
@@ -8047,7 +8184,7 @@ bool Tokenizer::simplifyRedundantParentheses()
             while (Token::Match(tok2, "%type%|static|const|extern") && tok2->str() != "operator") {
                 tok2 = tok2->previous();
             }
-            if (tok2 && !Token::Match(tok2, "[;,{]")) {
+            if (tok2 && !Token::Match(tok2, "[;{]")) {
                 // Not a variable declaration
             } else {
                 tok->deleteThis();
@@ -8068,320 +8205,43 @@ void Tokenizer::simplifyTypeIntrinsics()
         { "__has_trivial_constructor", "has_trivial_constructor" },
         { "__has_trivial_copy", "has_trivial_copy" },
         { "__has_trivial_destructor", "has_trivial_destructor" },
-        { "__has_virtual_destructor", "has_virtual_destructor" },
-        { "__is_abstract", "is_abstract" },
-        { "__is_aggregate", "is_aggregate" },
-        { "__is_assignable", "is_assignable" },
-        { "__is_base_of", "is_base_of" },
-        { "__is_class", "is_class" },
-        { "__is_constructible", "is_constructible" },
-        { "__is_convertible_to", "is_convertible_to" },
-        { "__is_destructible", "is_destructible" },
-        { "__is_empty", "is_empty" },
-        { "__is_enum", "is_enum" },
-        { "__is_final", "is_final" },
-        { "__is_nothrow_assignable", "is_nothrow_assignable" },
-        { "__is_nothrow_constructible", "is_nothrow_constructible" },
-        { "__is_nothrow_destructible", "is_nothrow_destructible" },
-        { "__is_pod", "is_pod" },
-        { "__is_polymorphic", "is_polymorphic" },
-        { "__is_trivially_assignable", "is_trivially_assignable" },
-        { "__is_trivially_constructible", "is_trivially_constructible" },
-        { "__is_union", "is_union" },
-    };
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (!Token::Match(tok, "%name% ("))
-            continue;
-        auto p = intrinsics.find(tok->str());
-        if (p == intrinsics.end())
-            continue;
-        Token * end = tok->next()->link();
-        Token * prev = tok->previous();
-        tok->str(p->second);
-        prev->insertToken("::");
-        prev->insertToken("std");
-        tok->next()->str("<");
-        end->str(">");
-        end->insertToken("}");
-        end->insertToken("{");
-        Token::createMutualLinks(end->tokAt(1), end->tokAt(2));
-    }
-}
-
-void Tokenizer::simplifyCharAt()
-{
-    // Replace "string"[0] with 's'
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "%str% [ %num% ]")) {
-            const MathLib::bigint index = MathLib::toLongNumber(tok->strAt(2));
-            // Check within range
-            if (index >= 0 && index <= Token::getStrLength(tok)) {
-                tok->str("'" + Token::getCharAt(tok, index) + "'");
-                tok->deleteNext(3);
-            }
-        }
-    }
-}
-
-void Tokenizer::simplifyReference()
-{
-    if (isC())
-        return;
-
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        // starting executable scope..
-        Token *start = const_cast<Token *>(startOfExecutableScope(tok));
-        if (start) {
-            tok = start;
-            // replace references in this scope..
-            Token * const end = tok->link();
-            for (Token *tok2 = tok; tok2 && tok2 != end; tok2 = tok2->next()) {
-                // found a reference..
-                if (Token::Match(tok2, "[;{}] %type% & %name% (|= %name% )| ;")) {
-                    const int refId = tok2->tokAt(3)->varId();
-                    if (!refId)
-                        continue;
-
-                    // replace reference in the code..
-                    for (Token *tok3 = tok2->tokAt(7); tok3 && tok3 != end; tok3 = tok3->next()) {
-                        if (tok3->varId() == refId) {
-                            tok3->str(tok2->strAt(5));
-                            tok3->varId(tok2->tokAt(5)->varId());
-                        }
-                    }
-
-                    tok2->deleteNext(6+(tok2->strAt(6)==")" ? 1 : 0));
-                }
-            }
-            tok = end;
-        }
-    }
-}
-
-bool Tokenizer::simplifyCalculations()
-{
-    return mTemplateSimplifier->simplifyCalculations(nullptr, nullptr, false);
-}
-
-void Tokenizer::simplifyOffsetPointerDereference()
-{
-    // Replace "*(str + num)" => "str[num]" and
-    // Replace "*(str - num)" => "str[-num]"
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (!tok->isName() && !tok->isLiteral()
-            && !Token::Match(tok, "]|)|++|--")
-            && Token::Match(tok->next(), "* ( %name% +|- %num%|%name% )")) {
-
-            // remove '* ('
-            tok->deleteNext(2);
-
-            // '+'->'['
-            tok = tok->tokAt(2);
-            Token* const openBraceTok = tok;
-            const bool isNegativeIndex = (tok->str() == "-");
-            tok->str("[");
-
-            // Insert a "-" in front of the number or variable
-            if (isNegativeIndex) {
-                if (tok->next()->isName()) {
-                    tok->insertToken("-");
-                    tok = tok->next();
-                } else
-                    tok->next()->str(std::string("-") + tok->next()->str());
-            }
-
-            tok = tok->tokAt(2);
-            tok->str("]");
-            Token::createMutualLinks(openBraceTok, tok);
-        }
-    }
-}
-
-void Tokenizer::simplifyOffsetPointerReference()
-{
-    std::set<int> pod;
-    for (const Token *tok = list.front(); tok; tok = tok->next()) {
-        if (tok->isStandardType()) {
-            tok = tok->next();
-            while (tok && (tok->str() == "*" || tok->isName())) {
-                if (tok->varId() > 0) {
-                    pod.insert(tok->varId());
-                    break;
-                }
-                tok = tok->next();
-            }
-            if (!tok)
-                break;
-        }
-    }
-
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (!Token::Match(tok, "%num%|%name%|]|)") &&
-            (Token::Match(tok->next(), "& %name% [ %num%|%name% ] !!["))) {
-            tok = tok->next();
-
-            if (tok->next()->varId()) {
-                if (pod.find(tok->next()->varId()) == pod.end()) {
-                    tok = tok->tokAt(5);
-                    if (!tok)
-                        syntaxError(tok);
-                    continue;
-                }
-            }
-
-            // '&' => '('
-            tok->str("(");
-
-            tok = tok->next();
-            // '[' => '+'
-            tok->deleteNext();
-            tok->insertToken("+");
-
-            tok = tok->tokAt(3);
-            //remove ']'
-            tok->str(")");
-            Token::createMutualLinks(tok->tokAt(-4), tok);
-        }
-    }
-}
-
-void Tokenizer::simplifyNestedStrcat()
-{
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (! Token::Match(tok, "[;{}] strcat ( strcat (")) {
-            continue;
-        }
-
-        // find inner strcat call
-        Token *tok2 = tok->tokAt(3);
-        while (Token::simpleMatch(tok2, "strcat ( strcat"))
-            tok2 = tok2->tokAt(2);
-
-        if (tok2->strAt(3) != ",")
-            continue;
-
-        // If we have this code:
-        //   strcat(strcat(dst, foo), bar);
-        // We move this part of code before all strcat() calls: strcat(dst, foo)
-        // And place "dst" token where the code was.
-        Token *prevTok = tok2->previous();
-
-        // Move tokens to new place
-        Token::move(tok2, tok2->next()->link(), tok);
-        tok = tok2->next()->link();
-
-        // Insert the "dst" token
-        prevTok->insertToken(tok2->strAt(2));
-        prevTok->next()->varId(tok2->tokAt(2)->varId());
-
-        // Insert semicolon after the moved strcat()
-        tok->insertToken(";");
-    }
-}
-
-// Check if this statement is a duplicate definition.  A duplicate
-// definition will hide the enumerator within it's scope so just
-// skip the entire scope of the duplicate.
-bool Tokenizer::duplicateDefinition(Token ** tokPtr)
-{
-    // check for an end of definition
-    const Token * tok = *tokPtr;
-    if (tok && Token::Match(tok->next(), ";|,|[|=|)|>")) {
-        const Token * end = tok->next();
-
-        if (end->str() == "[") {
-            end = end->link()->next();
-        } else if (end->str() == ",") {
-            // check for function argument
-            if (Token::Match(tok->previous(), "(|,"))
-                return false;
-
-            // find end of definition
-            int level = 0;
-            while (end->next() && (!Token::Match(end->next(), ";|)|>") ||
-                                   (end->next()->str() == ")" && level == 0))) {
-                if (end->next()->str() == "(")
-                    ++level;
-                else if (end->next()->str() == ")")
-                    --level;
-
-                end = end->next();
-            }
-        } else if (end->str() == ")") {
-            // check for function argument
-            if (tok->previous()->str() == ",")
-                return false;
-        }
-
-        if (end) {
-            if (Token::simpleMatch(end, ") {")) { // function parameter ?
-                // make sure it's not a conditional
-                if (Token::Match(end->link()->previous(), "if|for|while|switch|BOOST_FOREACH") || Token::Match(end->link()->tokAt(-2), ":|,"))
-                    return false;
-
-                // look backwards
-                if (tok->previous()->str() == "enum" ||
-                    (Token::Match(tok->previous(), "%type%") &&
-                     tok->previous()->str() != "return") ||
-                    Token::Match(tok->tokAt(-2), "%type% &|*")) {
-                    // duplicate definition so skip entire function
-                    *tokPtr = end->next()->link();
-                    return true;
-                }
-            } else if (end->str() == ">") { // template parameter ?
-                // look backwards
-                if (tok->previous()->str() == "enum" ||
-                    (Token::Match(tok->previous(), "%type%") &&
-                     tok->previous()->str() != "return")) {
-                    // duplicate definition so skip entire template
-                    while (end && end->str() != "{")
-                        end = end->next();
-                    if (end) {
-                        *tokPtr = end->link();
-                        return true;
-                    }
-                }
-            } else {
-                if (Token::Match(tok->previous(), "enum|,"))
-                    return true;
-                else if (Token::Match(tok->previous(), "%type%")) {
-                    // look backwards
-                    const Token *back = tok;
-                    while (back && back->isName())
-                        back = back->previous();
-                    if (!back || (Token::Match(back, "[(,;{}]") && !Token::Match(back->next(),"return|throw")))
-                        return true;
-                }
-            }
-        }
-    }
-    return false;
-}
-
-static const std::set<std::string> stdFunctionsPresentInC = {
-    "strcat",
-    "strcpy",
-    "strncat",
-    "strncpy",
-    "free",
-    "malloc",
-    "strdup"
-};
-
-void Tokenizer::simplifyStd()
-{
-    if (isC())
-        return;
-
+        { "__has_virtual_destructor", "has_virtual_destructor" },
+        { "__is_abstract", "is_abstract" },
+        { "__is_aggregate", "is_aggregate" },
+        { "__is_assignable", "is_assignable" },
+        { "__is_base_of", "is_base_of" },
+        { "__is_class", "is_class" },
+        { "__is_constructible", "is_constructible" },
+        { "__is_convertible_to", "is_convertible_to" },
+        { "__is_destructible", "is_destructible" },
+        { "__is_empty", "is_empty" },
+        { "__is_enum", "is_enum" },
+        { "__is_final", "is_final" },
+        { "__is_nothrow_assignable", "is_nothrow_assignable" },
+        { "__is_nothrow_constructible", "is_nothrow_constructible" },
+        { "__is_nothrow_destructible", "is_nothrow_destructible" },
+        { "__is_pod", "is_pod" },
+        { "__is_polymorphic", "is_polymorphic" },
+        { "__is_trivially_assignable", "is_trivially_assignable" },
+        { "__is_trivially_constructible", "is_trivially_constructible" },
+        { "__is_union", "is_union" },
+    };
     for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (tok->str() != "std")
+        if (!Token::Match(tok, "%name% ("))
             continue;
-
-        if (Token::Match(tok->previous(), "[(,{};] std :: %name% (") &&
-            stdFunctionsPresentInC.find(tok->strAt(2)) != stdFunctionsPresentInC.end()) {
-            tok->deleteNext();
-            tok->deleteThis();
-        }
+        auto p = intrinsics.find(tok->str());
+        if (p == intrinsics.end())
+            continue;
+        Token * end = tok->linkAt(1);
+        Token * prev = tok->previous();
+        tok->str(p->second);
+        prev->insertToken("::");
+        prev->insertToken("std");
+        tok->next()->str("<");
+        end->str(">");
+        end->insertToken("}");
+        end->insertToken("{");
+        Token::createMutualLinks(end->tokAt(1), end->tokAt(2));
     }
 }
 
@@ -8391,29 +8251,24 @@ void Tokenizer::simplifyStd()
 
 //---------------------------------------------------------------------------
 
-bool Tokenizer::IsScopeNoReturn(const Token *endScopeToken, bool *unknown) const
+bool Tokenizer::isScopeNoReturn(const Token *endScopeToken, bool *unknown) const
 {
     std::string unknownFunc;
-    const bool ret = mSettings->library.isScopeNoReturn(endScopeToken,&unknownFunc);
+    const bool ret = mSettings.library.isScopeNoReturn(endScopeToken,&unknownFunc);
+    if (!unknownFunc.empty() && mSettings.summaryReturn.find(unknownFunc) != mSettings.summaryReturn.end()) {
+        return false;
+    }
     if (unknown)
         *unknown = !unknownFunc.empty();
-    if (!unknownFunc.empty() && mSettings->checkLibrary && mSettings->isEnabled(Settings::INFORMATION)) {
-        // Is function global?
-        bool globalFunction = true;
+    if (!unknownFunc.empty() && mSettings.checkLibrary) {
+        bool warn = true;
         if (Token::simpleMatch(endScopeToken->tokAt(-2), ") ; }")) {
             const Token * const ftok = endScopeToken->linkAt(-2)->previous();
-            if (ftok &&
-                ftok->isName() &&
-                ftok->function() &&
-                ftok->function()->nestedIn &&
-                ftok->function()->nestedIn->type != Scope::eGlobal) {
-                globalFunction = false;
-            }
+            if (ftok && (ftok->type() || ftok->function() || ftok->variable())) // constructor call
+                warn = false;
         }
 
-        // don't warn for nonglobal functions (class methods, functions hidden in namespaces) since they can't be configured yet
-        // FIXME: when methods and namespaces can be configured properly, remove the "globalFunction" check
-        if (globalFunction) {
+        if (warn) {
             reportError(endScopeToken->previous(),
                         Severity::information,
                         "checkLibraryNoReturn",
@@ -8425,270 +8280,17 @@ bool Tokenizer::IsScopeNoReturn(const Token *endScopeToken, bool *unknown) const
 
 //---------------------------------------------------------------------------
 
-bool Tokenizer::isFunctionParameterPassedByValue(const Token *fpar) const
-{
-    // TODO: If symbol database is available, use it.
-    const Token *ftok;
-
-    // Look at function call, what parameter number is it?
-    int parameter = 1;
-    for (ftok = fpar->previous(); ftok; ftok = ftok->previous()) {
-        if (ftok->str() == "(")
-            break;
-        else if (ftok->str() == ")")
-            ftok = ftok->link();
-        else if (ftok->str() == ",")
-            ++parameter;
-        else if (Token::Match(ftok, "[;{}]"))
-            break;
-    }
-
-    // Is this a function call?
-    if (ftok && Token::Match(ftok->tokAt(-2), "[;{}=] %name% (")) {
-        const std::string& functionName(ftok->previous()->str());
-
-        if (functionName == "return")
-            return true;
-
-        // Locate function declaration..
-        for (const Token *tok = tokens(); tok; tok = tok->next()) {
-            if (tok->str() == "{")
-                tok = tok->link();
-            else if (Token::Match(tok, "%type% (") && tok->str() == functionName) {
-                // Goto parameter
-                tok = tok->tokAt(2);
-                int par = 1;
-                while (tok && par < parameter) {
-                    if (tok->str() == ")")
-                        break;
-                    if (tok->str() == ",")
-                        ++par;
-                    tok = tok->next();
-                }
-                if (!tok)
-                    return false;
-
-                // If parameter was found, determine if it's passed by value
-                if (par == parameter) {
-                    bool knowntype = false;
-                    while (tok && tok->isName()) {
-                        knowntype |= tok->isStandardType();
-                        knowntype |= (tok->str() == "struct");
-                        tok = tok->next();
-                    }
-                    if (!tok || !knowntype)
-                        return false;
-                    if (tok->str() != "," && tok->str() != ")")
-                        return false;
-                    return true;
-                }
-            }
-        }
-    }
-    return false;
-}
-
-//---------------------------------------------------------------------------
-
-void Tokenizer::eraseDeadCode(Token *begin, const Token *end)
-{
-    if (!begin)
-        return;
-    const bool isgoto = Token::Match(begin->tokAt(-2), "goto %name% ;");
-    int indentlevel = 1;
-    int indentcase = 0;
-    int indentswitch = 0;
-    int indentlabel = 0;
-    int roundbraces = 0;
-    int indentcheck = 0;
-    std::vector<int> switchindents;
-    bool checklabel = false;
-    Token *tok = begin;
-    Token *tokcheck = nullptr;
-    while (tok->next() && tok->next() != end) {
-        if (tok->next()->str() == "(") {
-            ++roundbraces;
-            tok->deleteNext();
-            continue;
-        } else if (tok->next()->str() == ")") {
-            if (!roundbraces)
-                break;  //too many ending round parentheses
-            --roundbraces;
-            tok->deleteNext();
-            continue;
-        }
-
-        if (roundbraces) {
-            tok->deleteNext();
-            continue;
-        }
-
-        if (Token::Match(tok, "[{};] switch (")) {
-            if (!checklabel) {
-                if (!indentlabel) {
-                    //remove 'switch ( ... )'
-                    Token::eraseTokens(tok, tok->linkAt(2)->next());
-                } else {
-                    tok = tok->linkAt(2);
-                }
-                if (tok->next()->str() == "{") {
-                    ++indentswitch;
-                    indentcase = indentlevel + 1;
-                    switchindents.push_back(indentcase);
-                }
-            } else {
-                tok = tok->linkAt(2);
-                if (Token::simpleMatch(tok, ") {")) {
-                    ++indentswitch;
-                    indentcase = indentlevel + 1;
-                    switchindents.push_back(indentcase);
-                }
-            }
-        } else if (tok->next()->str() == "{") {
-            ++indentlevel;
-            if (!checklabel) {
-                checklabel = true;
-                tokcheck = tok;
-                indentcheck = indentlevel;
-                indentlabel = 0;
-            }
-            tok = tok->next();
-        } else if (tok->next()->str() == "}") {
-            --indentlevel;
-            if (!indentlevel)
-                break;
-
-            if (!checklabel) {
-                tok->deleteNext();
-            } else {
-                if (indentswitch && indentlevel == indentcase)
-                    --indentlevel;
-                if (indentlevel < indentcheck) {
-                    const Token *end2 = tok->next();
-                    tok = end2->link()->previous();  //return to initial '{'
-                    if (indentswitch && Token::simpleMatch(tok, ") {") && Token::Match(tok->link()->tokAt(-2), "[{};] switch ("))
-                        tok = tok->link()->tokAt(-2);       //remove also 'switch ( ... )'
-                    Token::eraseTokens(tok, end2->next());
-                    checklabel = false;
-                    tokcheck = nullptr;
-                    indentcheck = 0;
-                } else {
-                    tok = tok->next();
-                }
-            }
-            if (indentswitch && indentlevel <= indentcase) {
-                --indentswitch;
-                switchindents.pop_back();
-                if (!indentswitch)
-                    indentcase = 0;
-                else
-                    indentcase = switchindents[indentswitch-1];
-            }
-        } else if (Token::Match(tok, "[{};:] case")) {
-            const Token *tok2 = Token::findsimplematch(tok->next(), ": ;", end);
-            if (!tok2) {
-                tok->deleteNext();
-                continue;
-            }
-            if (indentlevel == 1)
-                break;      //it seems like the function was called inside a case-default block.
-            if (indentlevel == indentcase)
-                ++indentlevel;
-            tok2 = tok2->next();
-            if (!checklabel || !indentswitch) {
-                Token::eraseTokens(tok, tok2->next());
-            } else {
-                tok = const_cast<Token *>(tok2);
-            }
-        }  else if (Token::Match(tok, "[{};] default : ;")) {
-            if (indentlevel == 1)
-                break;      //it seems like the function was called inside a case-default block.
-            if (indentlevel == indentcase)
-                ++indentlevel;
-            if (!checklabel || !indentswitch) {
-                tok->deleteNext(3);
-            } else {
-                tok = tok->tokAt(3);
-            }
-        } else if (Token::Match(tok, "[{};] %name% : ;") && tok->next()->str() != "default") {
-            if (checklabel) {
-                indentlabel = indentlevel;
-                tok = tokcheck->next();
-                checklabel = false;
-                indentlevel = indentcheck;
-            } else {
-                if (indentswitch) {
-                    //Before stopping the function, since the 'switch()'
-                    //instruction is removed, there's no sense to keep the
-                    //case instructions. Remove them, if there are any.
-                    Token *tok2 = tok->tokAt(3);
-                    int indentlevel2 = indentlevel;
-                    while (tok2->next() && tok2->next() != end) {
-                        if (Token::Match(tok2->next(), "{|[|(")) {
-                            tok2 = tok2->next()->link();
-                        } else if (Token::Match(tok2, "[{};:] case")) {
-                            const Token *tok3 = Token::findsimplematch(tok2->next(), ": ;", end);
-                            if (!tok3) {
-                                tok2 = tok2->next();
-                                continue;
-                            }
-                            Token::eraseTokens(tok2, tok3->next());
-                        } else if (Token::Match(tok2, "[{};] default : ;")) {
-                            tok2->deleteNext(3);
-                        } else if (tok2->next()->str() == "}") {
-                            --indentlevel2;
-                            if (indentlevel2 <= indentcase)
-                                break;
-                            tok2 = tok2->next();
-                        } else {
-                            tok2 = tok2->next();
-                        }
-                    }
-                }
-                break;  //stop removing tokens, we arrived to the label.
-            }
-        } else if (isgoto && Token::Match(tok, "[{};] do|while|for|BOOST_FOREACH")) {
-            //it's possible that code inside loop is not dead,
-            //because of the possible presence of the label pointed by 'goto'
-            const Token *start = tok->tokAt(2);
-            if (start && start->str() == "(")
-                start = start->link()->next();
-            if (start && start->str() == "{") {
-                std::string labelpattern = "[{};] " + begin->previous()->str() + " : ;";
-                bool simplify = true;
-                for (Token *tok2 = start->next(); tok2 != start->link(); tok2 = tok2->next()) {
-                    if (Token::Match(tok2, labelpattern.c_str())) {
-                        simplify = false;
-                        break;
-                    }
-                }
-                //bailout for now
-                if (!simplify)
-                    break;
-            }
-            tok->deleteNext();
-        } else {
-            // no need to keep the other strings, remove them.
-            if (tok->strAt(1) == "while") {
-                if (tok->str() == "}" && tok->link()->strAt(-1) == "do")
-                    tok->link()->previous()->deleteThis();
-            }
-            tok->deleteNext();
-        }
-    }
-}
-
-//---------------------------------------------------------------------------
-
 void Tokenizer::syntaxError(const Token *tok, const std::string &code) const
 {
-    printDebugOutput(0);
+    if (mSettings.debugSimplified || mSettings.debugnormal)
+        printDebugOutput(std::cout);
     throw InternalError(tok, code.empty() ? "syntax error" : "syntax error: " + code, InternalError::SYNTAX);
 }
 
 void Tokenizer::unmatchedToken(const Token *tok) const
 {
-    printDebugOutput(0);
+    if (mSettings.debugSimplified || mSettings.debugnormal)
+        printDebugOutput(std::cout);
     throw InternalError(tok,
                         "Unmatched '" + tok->str() + "'. Configuration: '" + mConfiguration + "'.",
                         InternalError::SYNTAX);
@@ -8696,41 +8298,58 @@ void Tokenizer::unmatchedToken(const Token *tok) const
 
 void Tokenizer::syntaxErrorC(const Token *tok, const std::string &what) const
 {
-    printDebugOutput(0);
-    throw InternalError(tok, "Code '"+what+"' is invalid C code. Use --std or --language to configure the language.", InternalError::SYNTAX);
+    if (mSettings.debugSimplified || mSettings.debugnormal)
+        printDebugOutput(std::cout);
+    throw InternalError(tok, "Code '"+what+"' is invalid C code.", "Use --std, -x or --language to enforce C++. Or --cpp-header-probe to identify C++ headers via the Emacs marker.", InternalError::SYNTAX);
 }
 
 void Tokenizer::unknownMacroError(const Token *tok1) const
 {
-    printDebugOutput(0);
+    if (mSettings.debugSimplified || mSettings.debugnormal)
+        printDebugOutput(std::cout);
     throw InternalError(tok1, "There is an unknown macro here somewhere. Configuration is required. If " + tok1->str() + " is a macro then please configure it.", InternalError::UNKNOWN_MACRO);
 }
 
-void Tokenizer::unhandled_macro_class_x_y(const Token *tok) const
+void Tokenizer::unhandled_macro_class_x_y(const Token *tok, const std::string& type, const std::string& x, const std::string& y, const std::string& bracket) const
 {
     reportError(tok,
                 Severity::information,
                 "class_X_Y",
                 "The code '" +
-                tok->str() + " " +
-                tok->strAt(1) + " " +
-                tok->strAt(2) + " " +
-                tok->strAt(3) + "' is not handled. You can use -I or --include to add handling of this code.");
+                type + " " +
+                x + " " +
+                y + " " +
+                bracket + "' is not handled. You can use -I or --include to add handling of this code.");
 }
 
-void Tokenizer::macroWithSemicolonError(const Token *tok, const std::string &macroName) const
+void Tokenizer::invalidConstFunctionTypeError(const Token *tok) const
 {
     reportError(tok,
-                Severity::information,
-                "macroWithSemicolon",
-                "Ensure that '" + macroName + "' is defined either using -I, --include or -D.");
+                Severity::portability,
+                "invalidConstFunctionType",
+                "It is unspecified behavior to const qualify a function type.");
 }
 
 void Tokenizer::cppcheckError(const Token *tok) const
 {
-    printDebugOutput(0);
+    printDebugOutput(std::cout);
     throw InternalError(tok, "Analysis failed. If the code is valid then please report this failure.", InternalError::INTERNAL);
 }
+
+void Tokenizer::unhandledCharLiteral(const Token *tok, const std::string& msg) const
+{
+    std::string s = tok ? (" " + tok->str()) : "";
+    for (std::size_t i = 0; i < s.size(); ++i) {
+        if (static_cast<unsigned char>(s[i]) >= 0x80)
+            s.clear();
+    }
+
+    reportError(tok,
+                Severity::portability,
+                "nonStandardCharLiteral",
+                "Non-standard character literal" + s + ". " + msg);
+}
+
 /**
  * Helper function to check whether number is equal to integer constant X
  * or floating point pattern X.0
@@ -8739,10 +8358,10 @@ void Tokenizer::cppcheckError(const Token *tok) const
  * @param floatConstant the string with stringified float constant to check against
  * @return true in case s is equal to X or X.0 and false otherwise.
  */
-static bool isNumberOneOf(const std::string &s, const MathLib::bigint& intConstant, const char* floatConstant)
+static bool isNumberOneOf(const std::string &s, MathLib::bigint intConstant, const char* floatConstant)
 {
     if (MathLib::isInt(s)) {
-        if (MathLib::toLongNumber(s) == intConstant)
+        if (MathLib::toBigNumber(s) == intConstant)
             return true;
     } else if (MathLib::isFloat(s)) {
         if (MathLib::toString(MathLib::toDoubleNumber(s)) == floatConstant)
@@ -8751,366 +8370,18 @@ static bool isNumberOneOf(const std::string &s, const MathLib::bigint& intConsta
     return false;
 }
 
-// ------------------------------------------------------------------------
-// Helper function to check whether number is zero (0 or 0.0 or 0E+0) or not?
-// @param s the string to check
-// @return true in case s is zero and false otherwise.
-// ------------------------------------------------------------------------
-bool Tokenizer::isZeroNumber(const std::string &s)
-{
-    return isNumberOneOf(s, 0L, "0.0");
-}
-
 // ------------------------------------------------------------------------
 // Helper function to check whether number is one (1 or 0.1E+1 or 1E+0) or not?
-// @param s the string to check
-// @return true in case s is one and false otherwise.
-// ------------------------------------------------------------------------
-bool Tokenizer::isOneNumber(const std::string &s)
-{
-    if (!MathLib::isPositive(s))
-        return false;
-    return isNumberOneOf(s, 1L, "1.0");
-}
-
-// ------------------------------------------------------------------------
-// Helper function to check whether number is two (2 or 0.2E+1 or 2E+0) or not?
-// @param s the string to check
-// @return true in case s is two and false otherwise.
-// ------------------------------------------------------------------------
-bool Tokenizer::isTwoNumber(const std::string &s)
-{
-    if (!MathLib::isPositive(s))
-        return false;
-    return isNumberOneOf(s, 2L, "2.0");
-}
-
-// ------------------------------------------------------
-// Simplify math functions.
-// It simplifies the following functions: atol(), fmin(),
-// fminl(), fminf(), fmax(), fmaxl(), fmaxf(), pow(),
-// powf(), powl(), cbrt(), cbrtl(), cbtrf(), sqrt(),
-// sqrtf(), sqrtl(), exp(), expf(), expl(), exp2(),
-// exp2f(), exp2l(), log2(), log2f(), log2l(), log1p(),
-// log1pf(), log1pl(), log10(), log10l(), log10f(),
-// log(), logf(), logl(), logb(), logbf(), logbl(), acosh()
-// acoshf(), acoshl(), acos(), acosf(), acosl(), cosh()
-// coshf(), coshf(), cos(), cosf(), cosl(), erfc(),
-// erfcf(), erfcl(), ilogb(), ilogbf(), ilogbf(), erf(),
-// erfl(), erff(), asin(), asinf(), asinf(), asinh(),
-// asinhf(), asinhl(), tan(), tanf(), tanl(), tanh(),
-// tanhf(), tanhl(), atan(), atanf(), atanl(), atanh(),
-// atanhf(), atanhl(), expm1(), expm1l(), expm1f(), sin(),
-// sinf(), sinl(), sinh(), sinhf(), sinhl()
-// in the tokenlist.
-//
-// Reference:
-// - http://www.cplusplus.com/reference/cmath/
-// ------------------------------------------------------
-void Tokenizer::simplifyMathFunctions()
-{
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (tok->isName() && !tok->varId() && tok->strAt(1) == "(") { // precondition for function
-            bool simplifcationMade = false;
-            if (Token::Match(tok, "atol ( %str% )")) { //@todo Add support for atoll()
-                if (Token::simpleMatch(tok->tokAt(-2), "std ::")) {
-                    tok = tok->tokAt(-2);// set token index two steps back
-                    tok->deleteNext(2);  // delete "std ::"
-                }
-                const std::string& strNumber = tok->tokAt(2)->strValue(); // get number
-                const bool isNotAnInteger = (!MathLib::isInt(strNumber));// check: is not an integer
-                if (strNumber.empty() || isNotAnInteger) {
-                    // Ignore strings which we can't convert
-                    continue;
-                }
-                // Convert string into a number and insert into token list
-                tok->str(MathLib::toString(MathLib::toLongNumber(strNumber)));
-                // remove ( %num% )
-                tok->deleteNext(3);
-                simplifcationMade = true;
-            } else if (Token::Match(tok, "sqrt|sqrtf|sqrtl|cbrt|cbrtf|cbrtl ( %num% )")) {
-                // Simplify: sqrt(0) = 0 and cbrt(0) == 0
-                //           sqrt(1) = 1 and cbrt(1) == 1
-                // get number string
-                const std::string& parameter(tok->strAt(2));
-                // is parameter 0 ?
-                if (isZeroNumber(parameter)) {
-                    tok->deleteNext(3);  // delete tokens
-                    tok->str("0"); // insert result into token list
-                    simplifcationMade = true;
-                } else if (isOneNumber(parameter)) {
-                    tok->deleteNext(3);  // delete tokens
-                    tok->str("1"); // insert result into token list
-                    simplifcationMade = true;
-                }
-            } else if (Token::Match(tok, "exp|expf|expl|exp2|exp2f|exp2l|cos|cosf|cosl|cosh|coshf|coshl|erfc|erfcf|erfcl ( %num% )")) {
-                // Simplify: exp[f|l](0)  = 1 and exp2[f|l](0) = 1
-                //           cosh[f|l](0) = 1 and cos[f|l](0)  = 1
-                //           erfc[f|l](0) = 1
-                // get number string
-                const std::string& parameter(tok->strAt(2));
-                // is parameter 0 ?
-                if (isZeroNumber(parameter)) {
-                    tok->deleteNext(3);  // delete tokens
-                    tok->str("1"); // insert result into token list
-                    simplifcationMade = true;
-                }
-            } else if (Token::Match(tok, "log1p|log1pf|log1pl|sin|sinf|sinl|sinh|sinhf|sinhl|erf|erff|erfl|asin|asinf|asinl|asinh|asinhf|asinhl|tan|tanf|tanl|tanh|tanhf|tanhl|atan|atanf|atanl|atanh|atanhf|atanhl|expm1|expm1f|expm1l ( %num% )")) {
-                // Simplify: log1p[f|l](0) = 0 and sin[f|l](0)  = 0
-                //           sinh[f|l](0)  = 0 and erf[f|l](0)  = 0
-                //           asin[f|l](0)  = 0 and sinh[f|l](0) = 0
-                //           tan[f|l](0)   = 0 and tanh[f|l](0) = 0
-                //           atan[f|l](0)  = 0 and atanh[f|l](0)= 0
-                //           expm1[f|l](0) = 0
-                // get number string
-                const std::string& parameter(tok->strAt(2));
-                // is parameter 0 ?
-                if (isZeroNumber(parameter)) {
-                    tok->deleteNext(3);  // delete tokens
-                    tok->str("0"); // insert result into token list
-                    simplifcationMade = true;
-                }
-            } else if (Token::Match(tok, "log2|log2f|log2l|log|logf|logl|log10|log10f|log10l|logb|logbf|logbl|acosh|acoshf|acoshl|acos|acosf|acosl|ilogb|ilogbf|ilogbl ( %num% )")) {
-                // Simplify: log2[f|l](1)  = 0 , log10[f|l](1)  = 0
-                //           log[f|l](1)   = 0 , logb10[f|l](1) = 0
-                //           acosh[f|l](1) = 0 , acos[f|l](1)   = 0
-                //           ilogb[f|l](1) = 0
-                // get number string
-                const std::string& parameter(tok->strAt(2));
-                // is parameter 1 ?
-                if (isOneNumber(parameter)) {
-                    tok->deleteNext(3);  // delete tokens
-                    tok->str("0"); // insert result into token list
-                    simplifcationMade = true;
-                }
-            } else if (Token::Match(tok, "fmin|fminl|fminf ( %num% , %num% )")) {
-                // @todo if one of the parameters is NaN the other is returned
-                // e.g. printf ("fmin (NaN, -1.0) = %f\n", fmin(NaN,-1.0));
-                // e.g. printf ("fmin (-1.0, NaN) = %f\n", fmin(-1.0,NaN));
-                const std::string& strLeftNumber(tok->strAt(2));
-                const std::string& strRightNumber(tok->strAt(4));
-                const bool isLessEqual =  MathLib::isLessEqual(strLeftNumber, strRightNumber);
-                // case: left <= right ==> insert left
-                if (isLessEqual) {
-                    tok->str(strLeftNumber); // insert e.g. -1.0
-                    tok->deleteNext(5);      // delete e.g. fmin ( -1.0, 1.0 )
-                    simplifcationMade = true;
-                } else { // case left > right ==> insert right
-                    tok->str(strRightNumber); // insert e.g. 0.0
-                    tok->deleteNext(5);       // delete e.g. fmin ( 1.0, 0.0 )
-                    simplifcationMade = true;
-                }
-            } else if (Token::Match(tok, "fmax|fmaxl|fmaxf ( %num% , %num% )")) {
-                // @todo if one of the parameters is NaN the other is returned
-                // e.g. printf ("fmax (NaN, -1.0) = %f\n", fmax(NaN,-1.0));
-                // e.g. printf ("fmax (-1.0, NaN) = %f\n", fmax(-1.0,NaN));
-                const std::string& strLeftNumber(tok->strAt(2));
-                const std::string& strRightNumber(tok->strAt(4));
-                const bool isLessEqual =  MathLib::isLessEqual(strLeftNumber, strRightNumber);
-                // case: left <= right ==> insert right
-                if (isLessEqual) {
-                    tok->str(strRightNumber);// insert e.g. 1.0
-                    tok->deleteNext(5);      // delete e.g. fmax ( -1.0, 1.0 )
-                    simplifcationMade = true;
-                } else { // case left > right ==> insert left
-                    tok->str(strLeftNumber);  // insert e.g. 1.0
-                    tok->deleteNext(5);       // delete e.g. fmax ( 1.0, 0.0 )
-                    simplifcationMade = true;
-                }
-            } else if (Token::Match(tok, "pow|powf|powl (")) {
-                if (Token::Match(tok->tokAt(2), "%num% , %num% )")) {
-                    // In case of pow ( 0 , anyNumber > 0): It can be simplified to 0
-                    // In case of pow ( 0 , 0 ): It simplified to 1
-                    // In case of pow ( 1 , anyNumber ): It simplified to 1
-                    const std::string& leftNumber(tok->strAt(2)); // get the left parameter
-                    const std::string& rightNumber(tok->strAt(4)); // get the right parameter
-                    const bool isLeftNumberZero = isZeroNumber(leftNumber);
-                    const bool isLeftNumberOne = isOneNumber(leftNumber);
-                    const bool isRightNumberZero = isZeroNumber(rightNumber);
-                    if (isLeftNumberZero && !isRightNumberZero && MathLib::isPositive(rightNumber)) { // case: 0^(y) = 0 and y > 0
-                        tok->deleteNext(5); // delete tokens
-                        tok->str("0");  // insert simplified result
-                        simplifcationMade = true;
-                    } else if (isLeftNumberZero && isRightNumberZero) { // case: 0^0 = 1
-                        tok->deleteNext(5); // delete tokens
-                        tok->str("1");  // insert simplified result
-                        simplifcationMade = true;
-                    } else if (isLeftNumberOne) { // case 1^(y) = 1
-                        tok->deleteNext(5); // delete tokens
-                        tok->str("1");  // insert simplified result
-                        simplifcationMade = true;
-                    }
-                }
-                if (Token::Match(tok->tokAt(2), "%any% , %num% )")) {
-                    // In case of pow( x , 1 ): It can be simplified to x.
-                    const std::string& leftParameter(tok->strAt(2)); // get the left parameter
-                    const std::string& rightNumber(tok->strAt(4)); // get right number
-                    if (isOneNumber(rightNumber)) { // case: x^(1) = x
-                        tok->str(leftParameter);  // insert simplified result
-                        tok->deleteNext(5); // delete tokens
-                        simplifcationMade = true;
-                    } else if (isZeroNumber(rightNumber)) { // case: x^(0) = 1
-                        tok->deleteNext(5); // delete tokens
-                        tok->str("1");  // insert simplified result
-                        simplifcationMade = true;
-                    }
-                }
-            }
-            // Jump back to begin of statement if a simplification was performed
-            if (simplifcationMade) {
-                while (tok->previous() && tok->str() != ";") {
-                    tok = tok->previous();
-                }
-            }
-        }
-    }
-}
-
-void Tokenizer::simplifyComma()
-{
-    bool inReturn = false;
-
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-
-        // skip enums
-        if (Token::Match(tok, "enum class|struct| %name%| :|{")) {
-            skipEnumBody(&tok);
-        }
-        if (!tok)
-            syntaxError(nullptr); // invalid code like in #4195
-
-        if (Token::Match(tok, "(|[") || Token::Match(tok->previous(), "%name%|= {")) {
-            tok = tok->link();
-            continue;
-        }
-
-        if (Token::simpleMatch(tok, "= (") && Token::simpleMatch(tok->linkAt(1), ") {")) {
-            tok = tok->linkAt(1)->linkAt(1);
-            continue;
-        }
-
-        // Skip unhandled template specifiers..
-        if (tok->link() && tok->str() == "<")
-            tok = tok->link();
-
-        if (tok->str() == "return" && Token::Match(tok->previous(), "[;{}]"))
-            inReturn = true;
-
-        if (inReturn && Token::Match(tok, "[;{}?:]"))
-            inReturn = false;
-
-        if (!tok->next() || tok->str() != ",")
-            continue;
-
-        // We must not accept just any keyword, e.g. accepting int
-        // would cause function parameters to corrupt.
-        if (isCPP() && tok->strAt(1) == "delete") {
-            // Handle "delete a, delete b;"
-            tok->str(";");
-        }
-
-        if (isCPP() && Token::Match(tok->tokAt(-2), "delete %name% , %name% ;") &&
-            tok->next()->varId() != 0) {
-            // Handle "delete a, b;" - convert to delete a; b;
-            tok->str(";");
-        } else if (!inReturn && tok->tokAt(-2)) {
-            bool replace = false;
-            for (Token *tok2 = tok->previous(); tok2; tok2 = tok2->previous()) {
-                if (tok2->str() == "=") {
-                    // Handle "a = 0, b = 0;"
-                    replace = true;
-                } else if (isCPP() && (Token::Match(tok2, "delete %name%") ||
-                                       Token::Match(tok2, "delete [ ] %name%"))) {
-                    // Handle "delete a, a = 0;"
-                    replace = true;
-                } else if (Token::Match(tok2, "[?:;,{}()]")) {
-                    if (replace && Token::Match(tok2, "[;{}]"))
-                        tok->str(";");
-                    break;
-                }
-            }
-        }
-
-        // find token where return ends and also count commas
-        if (inReturn) {
-            Token *startFrom = nullptr;    // "[;{}]" token before "return"
-            Token *endAt = nullptr;        // first ";" token after "[;{}] return"
-
-            // find "; return" pattern before comma
-            for (Token *tok2 = tok->previous(); tok2; tok2 = tok2->previous()) {
-                if (tok2->str() == "return") {
-                    startFrom = tok2->previous();
-                    break;
-                }
-            }
-            if (!startFrom)
-                // to be very sure...
-                return;
-            int commaCounter = 0;
-            for (Token *tok2 = startFrom->next(); tok2; tok2 = tok2->next()) {
-                if (tok2->str() == ";") {
-                    endAt = tok2;
-                    break;
-
-                } else if (Token::Match(tok2, "(|[") ||
-                           (tok2->str() == "{" && tok2->previous() && tok2->previous()->str() == "=")) {
-                    tok2 = tok2->link();
-
-                } else if (tok2->str() == ",") {
-                    ++commaCounter;
-                }
-            }
-
-            if (!endAt)
-                //probably a syntax error
-                return;
-
-            if (commaCounter) {
-                // change tokens:
-                // "; return a ( ) , b ( ) , c ;"
-                // to
-                // "; a ( ) ; b ( ) ; return c ;"
-
-                // remove "return"
-                startFrom->deleteNext();
-                for (Token *tok2 = startFrom->next(); tok2 != endAt; tok2 = tok2->next()) {
-                    if (Token::Match(tok2, "(|[") ||
-                        (tok2->str() == "{" && tok2->previous() && tok2->previous()->str() == "=")) {
-                        tok2 = tok2->link();
-
-                    } else if (tok2->str() == ",") {
-                        tok2->str(";");
-                        --commaCounter;
-                        if (commaCounter == 0) {
-                            tok2->insertToken("return");
-                        }
-                    }
-                }
-                tok = endAt;
-            }
-        }
-    }
-}
-
-void Tokenizer::checkConfiguration() const
-{
-    if (!mSettings->checkConfiguration)
-        return;
-    for (const Token *tok = tokens(); tok; tok = tok->next()) {
-        if (!Token::Match(tok, "%name% ("))
-            continue;
-        if (tok->isControlFlowKeyword())
-            continue;
-        for (const Token *tok2 = tok->tokAt(2); tok2 && tok2->str() != ")"; tok2 = tok2->next()) {
-            if (tok2->str() == ";") {
-                macroWithSemicolonError(tok, tok->str());
-                break;
-            }
-            if (Token::Match(tok2, "(|{"))
-                tok2 = tok2->link();
-        }
-    }
+// @param s the string to check
+// @return true in case s is one and false otherwise.
+// ------------------------------------------------------------------------
+bool Tokenizer::isOneNumber(const std::string &s)
+{
+    if (!MathLib::isPositive(s))
+        return false;
+    return isNumberOneOf(s, 1L, "1.0");
 }
+// ------------------------------------------------------------------------
 
 void Tokenizer::validateC() const
 {
@@ -9136,7 +8407,7 @@ void Tokenizer::validateC() const
             syntaxErrorC(tok, "template<...");
         if (Token::Match(tok, "%name% :: %name%"))
             syntaxErrorC(tok, tok->str() + tok->strAt(1) + tok->strAt(2));
-        if (Token::Match(tok, "class|namespace %name% [:{]"))
+        if (Token::Match(tok, "class|namespace %name% :|::|{"))
             syntaxErrorC(tok, tok->str() + tok->strAt(1) + tok->strAt(2));
     }
 }
@@ -9158,7 +8429,7 @@ void Tokenizer::validate() const
             if (tok->link() == nullptr)
                 cppcheckError(tok);
 
-            if (linkTokens.empty() == true)
+            if (linkTokens.empty())
                 cppcheckError(tok);
 
             if (tok->link() != linkTokens.top())
@@ -9200,85 +8471,370 @@ static const Token *findUnmatchedTernaryOp(const Token * const begin, const Toke
     return ternaryOp.empty() ? nullptr : ternaryOp.top();
 }
 
-void Tokenizer::findGarbageCode() const
+static bool isCPPAttribute(const Token * tok)
+{
+    return Token::simpleMatch(tok, "[ [") && tok->link() && tok->link()->previous() == tok->linkAt(1);
+}
+
+static bool isAlignAttribute(const Token * tok)
+{
+    return Token::simpleMatch(tok, "alignas (") && tok->linkAt(1);
+}
+
+template<typename T>
+static T* skipCPPOrAlignAttribute(T * tok)
+{
+    if (isCPPAttribute(tok))
+        return tok->link();
+    if (isAlignAttribute(tok)) {
+        return tok->linkAt(1);
+    }
+    return tok;
+}
+
+static bool isNonMacro(const Token* tok)
+{
+    if (tok->isKeyword() || tok->isStandardType())
+        return true;
+    if (cAlternativeTokens.count(tok->str()) > 0)
+        return true;
+    if (startsWith(tok->str(), "__")) // attribute/annotation
+        return true;
+    if (Token::simpleMatch(tok, "alignas ("))
+        return true;
+    return false;
+}
+
+void Tokenizer::reportUnknownMacros() const
 {
-    // initialization: = {
+    // Report unknown macros used in expressions "%name% %num%"
     for (const Token *tok = tokens(); tok; tok = tok->next()) {
-        if (!Token::simpleMatch(tok, "= {"))
-            continue;
-        if (Token::simpleMatch(tok->linkAt(1), "} ("))
-            syntaxError(tok->linkAt(1));
+        if (Token::Match(tok, "%name% %num%")) {
+            // A keyword is not an unknown macro
+            if (tok->isKeyword())
+                continue;
+
+            if (Token::Match(tok->previous(), "%op%|("))
+                unknownMacroError(tok);
+        }
+    }
+
+    // Report unknown macros before } "{ .. if (x) MACRO }"
+    for (const Token *tok = tokens(); tok; tok = tok->next()) {
+        if (Token::Match(tok, ")|; %name% } !!)")) {
+            if (tok->link() && !Token::simpleMatch(tok->link()->tokAt(-1), "if"))
+                continue;
+            const Token* prev = tok->linkAt(2);
+            while (Token::simpleMatch(prev, "{"))
+                prev = prev->previous();
+            if (Token::Match(prev, ";|)"))
+                unknownMacroError(tok->next());
+        }
     }
 
-    // Inside [] there can't be ; or various keywords
+    // Report unknown macros that contain several statements "MACRO(a;b;c)"
     for (const Token *tok = tokens(); tok; tok = tok->next()) {
-        if (tok->str() != "[")
+        if (!Token::Match(tok, "%name% ("))
+            continue;
+        if (!tok->isUpperCaseName())
             continue;
-        for (const Token *inner = tok->next(); inner != tok->link(); inner = inner->next()) {
-            if (Token::Match(inner, "(|["))
+        const Token *endTok = tok->linkAt(1);
+        for (const Token *inner = tok->tokAt(2); inner != endTok; inner = inner->next()) {
+            if (Token::Match(inner, "[[({]"))
                 inner = inner->link();
-            else if (Token::Match(inner, ";|goto|return|typedef"))
-                syntaxError(inner);
+            else if (inner->str() == ";")
+                unknownMacroError(tok);
         }
     }
 
-    // UNKNOWN_MACRO(return)
+    // Report unknown macros that contain struct initialization "MACRO(a, .b=3)"
     for (const Token *tok = tokens(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "throw|return )") && Token::Match(tok->linkAt(1)->previous(), "%name% ("))
-            unknownMacroError(tok->linkAt(1)->previous());
+        if (!Token::Match(tok, "%name% ("))
+            continue;
+        const Token *endTok = tok->linkAt(1);
+        for (const Token *inner = tok->tokAt(2); inner != endTok; inner = inner->next()) {
+            if (Token::Match(inner, "[[({]"))
+                inner = inner->link();
+            else if (Token::Match(inner->previous(), "[,(] . %name% =|{"))
+                unknownMacroError(tok);
+        }
     }
 
-    // UNKNOWN_MACRO(return)
+    const bool cpp = isCPP();
+
+    // Report unknown macros in non-executable scopes..
+    std::set<std::string> possible;
     for (const Token *tok = tokens(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "%name% throw|return") && std::isupper(tok->str()[0]))
-            unknownMacroError(tok);
+        // Skip executable scopes..
+        if (tok->str() == "{") {
+            const Token *prev = tok->previous();
+            while (prev && prev->isName())
+                prev = prev->previous();
+            if (prev && prev->str() == ")")
+                tok = tok->link();
+            else
+                possible.clear();
+        } else if (tok->str() == "}")
+            possible.clear();
+
+        if (Token::Match(tok, "%name% (") && tok->isUpperCaseName() && Token::simpleMatch(tok->linkAt(1), ") (") && Token::simpleMatch(tok->linkAt(1)->linkAt(1), ") {")) {
+            // A keyword is not an unknown macro
+            if (tok->isKeyword())
+                continue;
+
+            const Token *bodyStart = tok->linkAt(1)->linkAt(1)->tokAt(2);
+            const Token *bodyEnd = tok->link();
+            for (const Token *tok2 = bodyStart; tok2 && tok2 != bodyEnd; tok2 = tok2->next()) {
+                if (Token::Match(tok2, "if|switch|for|while|return"))
+                    unknownMacroError(tok);
+            }
+        } else if (Token::Match(tok, "%name% (") && tok->isUpperCaseName() && Token::Match(tok->linkAt(1), ") %name% (") && Token::Match(tok->linkAt(1)->linkAt(2), ") [;{]")) {
+            if (!(tok->linkAt(1)->next() && tok->linkAt(1)->next()->isKeyword())) { // e.g. noexcept(true)
+                if (possible.count(tok->str()) == 0)
+                    possible.insert(tok->str());
+                else
+                    unknownMacroError(tok);
+            }
+        } else if (cpp && Token::Match(tok, "public|private|protected %name% :")) {
+            unknownMacroError(tok->next());
+        }
     }
 
-    // Assign/increment/decrement literal
+    // String concatenation with unknown macros
     for (const Token *tok = tokens(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "!!) %num%|%str%|%char% %assign%|++|--"))
-            syntaxError(tok, tok->next()->str() + " " + tok->strAt(2));
+        if ((Token::Match(tok, "%str% %name% (") && Token::Match(tok->linkAt(2), ") %str%")) ||
+            (Token::Match(tok, "%str% %name% %str%") && !(startsWith(tok->strAt(1), "PRI") || startsWith(tok->strAt(1), "SCN")))) { // TODO: implement macros in std.cfg
+            if (tok->next()->isKeyword())
+                continue;
+            unknownMacroError(tok->next());
+        }
+        if (Token::Match(tok, "[(,] %name% (") && Token::Match(tok->linkAt(2), ") %name% %name%|,|)")) {
+            if (tok->next()->isKeyword() || tok->linkAt(2)->next()->isKeyword())
+                continue;
+            if (cAlternativeTokens.count(tok->linkAt(2)->strAt(1)) > 0)
+                continue;
+            if (startsWith(tok->strAt(1), "__")) // attribute/annotation
+                continue;
+            if (tok->next()->isStandardType() && !tok->linkAt(2)->next()->isStandardType())
+                unknownMacroError(tok->linkAt(2)->next());
+            else
+                unknownMacroError(tok->next());
+        }
+    }
+
+    // Report unknown macros without commas or operators inbetween statements: MACRO1() MACRO2()
+    for (const Token* tok = tokens(); tok; tok = tok->next()) {
+        if (!Token::Match(tok, "%name% ("))
+            continue;
+        if (isNonMacro(tok) && !tok->isStandardType())
+            continue;
+
+        const Token* endTok = tok->linkAt(1);
+        if (!Token::Match(endTok, ") %name% (|."))
+            continue;
+
+        const Token* tok2 = endTok->next();
+        if (isNonMacro(tok2))
+            continue;
+
+        if (tok2->strAt(1) == "(") {
+            if (Token::Match(tok->previous(), "%name%|::|>"))
+                continue;
+        }
+
+        unknownMacroError(tok->isStandardType() ? tok2 : tok);
     }
+}
+
+void Tokenizer::findGarbageCode() const
+{
+    const bool cpp = isCPP();
+    const bool isCPP11 = cpp && mSettings.standards.cpp >= Standards::CPP11;
+
+    static const std::unordered_set<std::string> nonConsecutiveKeywords{ "break",
+                                                                         "continue",
+                                                                         "for",
+                                                                         "goto",
+                                                                         "if",
+                                                                         "return",
+                                                                         "switch",
+                                                                         "throw",
+                                                                         "typedef",
+                                                                         "while" };
 
     for (const Token *tok = tokens(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "if|while|for|switch")) { // if|while|for|switch (EXPR) { ... }
-            if (tok->previous() && !Token::Match(tok->previous(), "%name%|:|;|{|}|(|)|,")) {
-                if (!Token::simpleMatch(tok->tokAt(-2), "operator \"\" if"))
-                    syntaxError(tok);
+        // initialization: = {
+        if (Token::simpleMatch(tok, "= {") && Token::simpleMatch(tok->linkAt(1), "} ("))
+            syntaxError(tok->linkAt(1));
+
+        // Inside [] there can't be ; or various keywords
+        else if (tok->str() == "[") {
+            for (const Token* inner = tok->next(); inner != tok->link(); inner = inner->next()) {
+                if (Token::Match(inner, "(|[|{"))
+                    inner = inner->link();
+                else if (Token::Match(inner, ";|goto|return|typedef"))
+                    syntaxError(inner);
             }
-            if (Token::Match(tok->previous(), "[(,]"))
-                continue;
-            if (!Token::Match(tok->next(), "( !!)"))
+        }
+
+        // array assignment
+        else if (Token::Match(tok, "%assign% [") && Token::simpleMatch(tok->linkAt(1), "] ;"))
+            syntaxError(tok, tok->str() + "[...];");
+
+        else if (Token::Match(tok, "[({<] %assign%"))
+            syntaxError(tok);
+
+        else if (Token::Match(tok, "%assign% >"))
+            syntaxError(tok);
+
+        else if (Token::Match(tok, "[`\\@]"))
+            syntaxError(tok);
+
+        // UNKNOWN_MACRO(return)
+        if (tok->isKeyword() && Token::Match(tok, "throw|return )") && Token::Match(tok->linkAt(1)->previous(), "%name% ("))
+            unknownMacroError(tok->linkAt(1)->previous());
+
+        // UNKNOWN_MACRO(return)
+        else if (!tok->isKeyword() && (Token::Match(tok, "%name% return") || (isCPP() && Token::Match(tok, "%name% throw"))))
+            unknownMacroError(tok);
+
+        // Assign/increment/decrement literal
+        else if (Token::Match(tok, "!!) %num%|%str%|%char% %assign%|++|--")) {
+            if (!cpp || mSettings.standards.cpp < Standards::CPP20 || !Token::Match(tok->previous(), "%name% : %num% ="))
+                syntaxError(tok, tok->strAt(1) + " " + tok->strAt(2));
+        }
+        else if (Token::simpleMatch(tok, ") return") && !Token::Match(tok->link()->previous(), "if|while|for (")) {
+            if (tok->link()->previous() && tok->link()->previous()->isUpperCaseName())
+                unknownMacroError(tok->link()->previous());
+            else
                 syntaxError(tok);
-            if (tok->str() != "for") {
-                if (isGarbageExpr(tok->next(), tok->linkAt(1), mSettings->standards.cpp>=Standards::cppstd_t::CPP17))
+        }
+
+        if (tok->isControlFlowKeyword()) {
+            if (Token::Match(tok, "if|while|for|switch")) { // if|while|for|switch (EXPR) { ... }
+                if (tok->previous() && !Token::Match(tok->previous(), "%name%|:|;|{|}|)")) {
+                    if (Token::Match(tok->previous(), "[,(]")) {
+                        const Token *prev = tok->previous();
+                        while (prev && prev->str() != "(") {
+                            if (prev->str() == ")")
+                                prev = prev->link();
+                            prev = prev->previous();
+                        }
+                        if (prev && Token::Match(prev->previous(), "%name% ("))
+                            unknownMacroError(prev->previous());
+                    }
+                    if (!Token::simpleMatch(tok->tokAt(-2), "operator \"\" if"))
+                        syntaxError(tok);
+                }
+                if (!Token::Match(tok->next(), "( !!)"))
                     syntaxError(tok);
+                if (Token::simpleMatch(tok->linkAt(1), ") }")) {
+                    syntaxError(tok->linkAt(1)->next());
+                }
+                if (tok->str() != "for") {
+                    if (isGarbageExpr(tok->next(), tok->linkAt(1), cpp && (mSettings.standards.cpp>=Standards::cppstd_t::CPP17)))
+                        syntaxError(tok);
+                }
+            }
+            if (Token::simpleMatch(tok, "do {")) {
+                if (!Token::simpleMatch(tok->linkAt(1), "} while ("))
+                    syntaxError(tok->linkAt(1));
+                if (!Token::simpleMatch(tok->linkAt(1)->linkAt(2), ") ;"))
+                    syntaxError(tok->linkAt(1)->linkAt(2));
+            }
+            // if (x) MACRO() ..
+            if (Token::simpleMatch(tok, "if (")) {
+                const Token* tok2 = tok->linkAt(1);
+                if (Token::Match(tok2, ") %name% (") && tok2->next()->isUpperCaseName() &&
+                    Token::Match(tok2->linkAt(2), ") {|else"))
+                    syntaxError(tok2->next());
+            }
+        }
+
+        // keyword keyword
+        if (tok->isKeyword() && nonConsecutiveKeywords.count(tok->str()) != 0) {
+            if (Token::Match(tok, "%name% %name%") && nonConsecutiveKeywords.count(tok->strAt(1)) == 1)
+                syntaxError(tok);
+            const Token* prev = tok;
+            while (prev && prev->isName())
+                prev = prev->previous();
+            if (Token::Match(prev, "%op%|%num%|%str%|%char%")) {
+                if (!Token::simpleMatch(tok->tokAt(-2), "operator \"\" if") &&
+                    !Token::simpleMatch(tok->tokAt(-2), "extern \"C\"") &&
+                    !Token::simpleMatch(prev, "> typedef"))
+                    syntaxError(tok, prev == tok->previous() ? (prev->str() + " " + tok->str()) : (prev->str() + " .. " + tok->str()));
             }
         }
+        else if (tok->isStandardType() && tok->next() && tok->str() == tok->strAt(1) && tok->str() != "long")
+            syntaxError(tok);
     }
 
-    // keyword keyword
-    const std::set<std::string> nonConsecutiveKeywords{"break",
-        "continue",
-        "for",
-        "goto",
-        "if",
-        "return",
-        "switch",
-        "throw",
-        "typedef",
-        "while"};
+    // invalid struct declaration
     for (const Token *tok = tokens(); tok; tok = tok->next()) {
-        if (!tok->isName() || nonConsecutiveKeywords.count(tok->str()) == 0)
-            continue;
-        if (Token::Match(tok, "%name% %name%") && nonConsecutiveKeywords.count(tok->next()->str()) == 1)
-            syntaxError(tok);
-        const Token *prev = tok;
-        while (prev && prev->isName())
-            prev = prev->previous();
-        if (Token::Match(prev, "%op%|%num%|%str%|%char%")) {
-            if (!Token::simpleMatch(tok->tokAt(-2), "operator \"\" if"))
-                syntaxError(tok, prev == tok->previous() ? (prev->str() + " " + tok->str()) : (prev->str() + " .. " + tok->str()));
+        if (Token::Match(tok, "struct|class|enum %name%| {") && (!tok->previous() || Token::Match(tok->previous(), "[;{}]"))) {
+            const Token *tok2 = tok->linkAt(tok->next()->isName() ? 2 : 1);
+            if (Token::Match(tok2, "} %op%")) {
+                tok2 = tok2->next();
+                if (!Token::Match(tok2, "*|&|&&"))
+                    syntaxError(tok2, "Unexpected token '" + tok2->str() + "'");
+                while (Token::Match(tok2, "*|&|&&"))
+                    tok2 = tok2->next();
+                if (!Token::Match(tok2, "%name%"))
+                    syntaxError(tok2, "Unexpected token '" + (tok2 ? tok2->str() : "") + "'");
+            }
+        }
+        if (tok->str() == "enum") {
+            if (Token::Match(tok->next(), ": %num%| {"))
+                syntaxError(tok->tokAt(2), "Unexpected token '" + tok->strAt(2) + "'");
+            if (const Token* start = SymbolDatabase::isEnumDefinition(tok)) {
+                int nEquals = 0;
+                for (const Token* tok2 = start->next(); tok2 && tok2 != start->link(); tok2 = tok2->next()) {
+                    if (Token::simpleMatch(tok2, "sizeof (")) {
+                        tok2 = tok2->linkAt(1);
+                        continue;
+                    }
+                    if (const Token* lam = findLambdaEndTokenWithoutAST(tok2)) {
+                        tok2 = lam;
+                        continue;
+                    }
+                    if (tok2->str() == ";")
+                        syntaxError(tok2);
+                    if (tok2->str() == "=")
+                        ++nEquals;
+                    else if (tok2->str() == ",")
+                        nEquals = 0;
+                    if (nEquals > 1)
+                        syntaxError(tok2);
+                }
+            }
+        }
+    }
+
+    // Keywords in global scope
+    static const std::unordered_set<std::string> nonGlobalKeywords{"break",
+                                                                   "continue",
+                                                                   "for",
+                                                                   "goto",
+                                                                   "if",
+                                                                   "return",
+                                                                   "switch",
+                                                                   "while",
+                                                                   "try",
+                                                                   "catch"};
+    for (const Token *tok = tokens(); tok; tok = tok->next()) {
+        if (tok->str() == "{")
+            tok = tok->link();
+        else if (tok->isKeyword() && nonGlobalKeywords.count(tok->str()) && !Token::Match(tok->tokAt(-2), "operator %str%"))
+            syntaxError(tok, "keyword '" + tok->str() + "' is not allowed in global scope");
+    }
+    for (const Token *tok = tokens(); tok; tok = tok->next()) {
+        if (tok->str() == "{" && isClassStructUnionEnumStart(tok)) {
+            for (const Token* tok2 = tok->next(); tok2 != tok->link(); tok2 = tok2->next()) {
+                if (tok2->str() == "{")
+                    tok2 = tok2->link();
+                else if (tok2->isKeyword() && nonGlobalKeywords.count(tok2->str()) && !Token::Match(tok2->tokAt(-2), "operator %str%"))
+                    syntaxError(tok2, "keyword '" + tok2->str() + "' is not allowed in class/struct/union/enum scope");
+            }
         }
     }
 
@@ -9294,7 +8850,7 @@ void Tokenizer::findGarbageCode() const
             if (!tok)
                 syntaxError(switchToken);
             // Look for the end of the switch statement, i.e. the first semi-colon or '}'
-            for (; tok ; tok = tok->next()) {
+            for (; tok; tok = tok->next()) {
                 if (tok->str() == "{") {
                     tok = tok->link();
                 }
@@ -9314,32 +8870,41 @@ void Tokenizer::findGarbageCode() const
         }
     }
 
-    for (const Token *tok = tokens(); tok ; tok = tok->next()) {
+    for (const Token *tok = tokens(); tok; tok = tok->next()) {
         if (!Token::simpleMatch(tok, "for (")) // find for loops
             continue;
         // count number of semicolons
-        int semicolons = 0;
-        const Token* const startTok = tok;
-        tok = tok->next()->link()->previous(); // find ")" of the for-loop
-        // walk backwards until we find the beginning (startTok) of the for() again
-        for (; tok != startTok; tok = tok->previous()) {
+        int semicolons = 0, colons = 0;
+        const Token* const endTok = tok->linkAt(1);
+        for (tok = tok->tokAt(2); tok != endTok; tok = tok->next()) {
+            if (const Token* lam = findLambdaEndTokenWithoutAST(tok)) {
+                tok = lam;
+                continue;
+            }
             if (tok->str() == ";") { // do the counting
                 semicolons++;
-            } else if (tok->str() == ")") { // skip pairs of ( )
+            } else if (tok->str() == ":") {
+                if (tok->strAt(-1) == ",")
+                    syntaxError(tok);
+                colons++;
+            } else if (tok->str() == "(") { // skip pairs of ( )
                 tok = tok->link();
             }
         }
         // if we have an invalid number of semicolons inside for( ), assume syntax error
-        if ((semicolons == 1) || (semicolons > 2)) {
+        if (semicolons > 2)
+            syntaxError(tok);
+        if (semicolons == 1 && !(cpp && mSettings.standards.cpp >= Standards::CPP20))
+            syntaxError(tok);
+        if (semicolons == 0 && colons == 0)
             syntaxError(tok);
-        }
     }
 
     // Operators without operands..
     const Token *templateEndToken = nullptr;
     for (const Token *tok = tokens(); tok; tok = tok->next()) {
         if (!templateEndToken) {
-            if (tok->str() == "<" && isCPP())
+            if (tok->str() == "<" && cpp)
                 templateEndToken = tok->findClosingBracket();
         } else {
             if (templateEndToken == tok)
@@ -9347,25 +8912,67 @@ void Tokenizer::findGarbageCode() const
             if (Token::Match(tok, "> %cop%"))
                 continue;
         }
-        if (Token::Match(tok, "%or%|%oror%|==|!=|+|-|/|!|>=|<=|~|^|++|--|::|sizeof|throw|decltype|typeof {|if|else|try|catch|while|do|for|return|switch|break|namespace"))
-            syntaxError(tok);
-        if (Token::Match(tok, "( %any% )") && tok->next()->isKeyword() && !Token::simpleMatch(tok->next(), "void"))
+        // skip C++ attributes [[...]]
+        if (isCPP11 && (isCPPAttribute(tok) || isAlignAttribute(tok))) {
+            tok = skipCPPOrAlignAttribute(tok);
+            continue;
+        }
+        {
+            bool match1 = Token::Match(tok, "%or%|%oror%|==|!=|+|-|/|!|>=|<=|~|^|++|--|::|sizeof");
+            bool match2 = Token::Match(tok->next(), "{|if|else|while|do|for|return|switch|break");
+            if (cpp) {
+                match1 = match1 || Token::Match(tok, "throw|decltype|typeof");
+                match2 = match2 || Token::Match(tok->next(), "try|catch|namespace");
+            }
+            if (match1 && !tok->isIncDecOp()) {
+                match2 = match2 || Token::Match(tok->next(), "%assign%");
+            }
+            if (match1 && match2)
+                syntaxError(tok);
+        }
+        if (Token::Match(tok, "%or%|%oror%|~|^|!|%comp%|+|-|/|%")) {
+            std::string code;
+            if (Token::Match(tok->next(), ")|]|}"))
+                code = tok->str() + tok->strAt(1);
+            if (Token::simpleMatch(tok->next(), "( )"))
+                code = tok->str() + "()";
+            if (!code.empty()) {
+                if (isC() || (tok->str() != ">" && !Token::simpleMatch(tok->previous(), "operator")))
+                    syntaxError(tok, code);
+            }
+        }
+        if (Token::Match(tok, "%num%|%bool%|%char%|%str% %num%|%bool%|%char%|%str%|::") && !Token::Match(tok, "%str% %str%"))
             syntaxError(tok);
-        if (Token::Match(tok, "%num%|%bool%|%char%|%str% %num%|%bool%|%char%|%str%") && !Token::Match(tok, "%str% %str%"))
+        if (Token::Match(tok, "%num%|%bool%|%char%|%str% {|(")) {
+            if (tok->strAt(1) == "(")
+                syntaxError(tok);
+            else if (!(tok->tokType() == Token::Type::eString && Token::simpleMatch(tok->tokAt(-1), "extern")) &&
+                     !(tok->tokType() == Token::Type::eBoolean && cpp && Token::simpleMatch(tok->tokAt(-1), "requires")))
+                syntaxError(tok);
+        }
+        if (Token::Match(tok, "( ) %num%|%bool%|%char%|%str%"))
             syntaxError(tok);
         if (Token::Match(tok, "%assign% typename|class %assign%"))
             syntaxError(tok);
+        if (Token::Match(tok, "%assign% [;)}]") && (!cpp || !Token::simpleMatch(tok->previous(), "operator")))
+            syntaxError(tok);
+        if (Token::Match(tok, "; %assign%"))
+            syntaxError(tok);
+        if (Token::Match(tok, "%assign% %name%") && tok->next()->isControlFlowKeyword())
+            syntaxError(tok);
         if (Token::Match(tok, "%cop%|=|,|[ %or%|%oror%|/|%"))
             syntaxError(tok);
-        if (Token::Match(tok, ";|(|[ %comp%"))
+        if (Token::Match(tok, "[;([{] %comp%|%oror%|%or%|%|/"))
             syntaxError(tok);
-        if (Token::Match(tok, "%cop%|= ]") && !(isCPP() && Token::Match(tok->previous(), "[|, &|= ]")))
+        if (Token::Match(tok, "%cop%|= ]") && !Token::simpleMatch(tok, "*") && !(cpp && Token::Match(tok->previous(), "%type%|[|,|%num% &|=|> ]")))
             syntaxError(tok);
-        if (Token::Match(tok, "[+-] [;,)]}]") && !(isCPP() && Token::Match(tok->previous(), "operator [+-] ;")))
+        if (Token::Match(tok, "[+-] [;,)]}]") && !(cpp && Token::simpleMatch(tok->previous(), "operator")))
             syntaxError(tok);
         if (Token::simpleMatch(tok, ",") &&
             !Token::Match(tok->tokAt(-2), "[ = , &|%name%")) {
-            if (Token::Match(tok->previous(), "(|[|{|<|%assign%|%or%|%oror%|==|!=|+|-|/|!|>=|<=|~|^|::|sizeof|throw|decltype|typeof"))
+            if (Token::Match(tok->previous(), "(|[|{|<|%assign%|%or%|%oror%|==|!=|+|-|/|!|>=|<=|~|^|::|sizeof"))
+                syntaxError(tok);
+            if (cpp && Token::Match(tok->previous(), "throw|decltype|typeof"))
                 syntaxError(tok);
             if (Token::Match(tok->next(), ")|]|>|%assign%|%or%|%oror%|==|!=|/|>=|<=|&&"))
                 syntaxError(tok);
@@ -9373,13 +8980,110 @@ void Tokenizer::findGarbageCode() const
         if (Token::simpleMatch(tok, ".") &&
             !Token::simpleMatch(tok->previous(), ".") &&
             !Token::simpleMatch(tok->next(), ".") &&
-            !Token::Match(tok->previous(), "{|, . %name% [=.]") &&
+            !Token::Match(tok->previous(), "{|, . %name% =|.|[|{") &&
+            !(tok->previous() && tok->previous()->isLiteral()) &&
             !Token::Match(tok->previous(), ", . %name%")) {
             if (!Token::Match(tok->previous(), "%name%|)|]|>|}"))
                 syntaxError(tok, tok->strAt(-1) + " " + tok->str() + " " + tok->strAt(1));
             if (!Token::Match(tok->next(), "%name%|*|~"))
                 syntaxError(tok, tok->strAt(-1) + " " + tok->str() + " " + tok->strAt(1));
         }
+        if (Token::Match(tok, ".|-> .|->"))
+            syntaxError(tok);
+        if (Token::Match(tok, "[{,] . %name%") && !Token::Match(tok->tokAt(3), "[.=[{]"))
+            syntaxError(tok->next());
+        if (Token::Match(tok, "%name% %op% %name%") && !tok->isKeyword() && tok->next()->isIncDecOp())
+            syntaxError(tok->next());
+        if (!tok->isKeyword() && Token::Match(tok, "%name% .|-> %name% %name%") && !tok->tokAt(2)->isKeyword()) {
+            if (tok->tokAt(3)->isUpperCaseName())
+                unknownMacroError(tok->tokAt(3));
+            else
+                syntaxError(tok);
+        }
+        if (Token::Match(tok, "[!|+-/%^~] )|]"))
+            syntaxError(tok);
+        if (Token::Match(tok, "==|!=|<=|>= %comp%") && tok->strAt(-1) != "operator")
+            syntaxError(tok, tok->str() + " " + tok->strAt(1));
+        if (Token::simpleMatch(tok, "::") && (!Token::Match(tok->next(), "%name%|*|~") ||
+                                              (tok->next()->isKeyword() && !Token::Match(tok->next(), "new|delete|operator"))))
+            syntaxError(tok);
+        if (Token::Match(tok, "& %comp%|&&|%oror%|&|%or%") && tok->strAt(1) != ">")
+            syntaxError(tok);
+        if (Token::Match(tok, "%comp%|&&|%oror%|&|%or% }") && tok->str() != ">")
+            syntaxError(tok);
+        if (Token::Match(tok, "^ %op%") && !Token::Match(tok->next(), "[>*+-!~]"))
+            syntaxError(tok);
+        if (Token::Match(tok, ": [)]=]"))
+            syntaxError(tok);
+        if (Token::Match(tok, "typedef [,;:]"))
+            syntaxError(tok);
+        if (Token::Match(tok, "? %assign%"))
+            syntaxError(tok);
+        if (Token::Match(tok, "[!~+-/] %comp%") &&
+            !(cpp && Token::Match(tok->next(), "[<>]") && Token::simpleMatch(tok->tokAt(-1), "operator")))
+            syntaxError(tok);
+        if (Token::Match(tok, "%comp% {") && (!cpp || tok->str() != ">"))
+            syntaxError(tok);
+        if (Token::Match(tok, "] %name%") && (!cpp || !(tok->tokAt(1)->isKeyword() || (tok->tokAt(-1) && Token::simpleMatch(tok->tokAt(-2), "delete ["))))) {
+            if (tok->next()->isUpperCaseName())
+                unknownMacroError(tok->next());
+            else
+                syntaxError(tok);
+        }
+
+        if (tok->link() && Token::Match(tok, "[([]") && (!tok->tokAt(-1) || !tok->tokAt(-1)->isControlFlowKeyword())) {
+            const Token* const end = tok->link();
+            for (const Token* inner = tok->next(); inner != end; inner = inner->next()) {
+                if (inner->str() == "{")
+                    inner = inner->link();
+                else if (inner->str() == ";" || (Token::simpleMatch(inner, ", ,") && (!cpp || !Token::simpleMatch(inner->previous(), "operator")))) {
+                    if (tok->tokAt(-1) && tok->tokAt(-1)->isUpperCaseName())
+                        unknownMacroError(tok->tokAt(-1));
+                    else
+                        syntaxError(inner);
+                }
+            }
+        }
+
+        if ((!cpp || !Token::simpleMatch(tok->previous(), "operator")) && Token::Match(tok, "[,;] ,"))
+            syntaxError(tok);
+        if (tok->str() == "typedef") {
+            for (const Token* tok2 = tok->next(); tok2 && tok2->str() != ";"; tok2 = tok2->next()) {
+                if (tok2->str() == "{") {
+                    tok2 = tok2->link();
+                    continue;
+                }
+                if (isUnevaluated(tok2)) {
+                    tok2 = tok2->linkAt(1);
+                    continue;
+                }
+                if (!tok2->next() || tok2->isControlFlowKeyword() || Token::Match(tok2, "typedef|static|."))
+                    syntaxError(tok);
+                if (Token::Match(tok2, "%name% %name%") && tok2->str() == tok2->strAt(1)) {
+                    if (Token::simpleMatch(tok2->tokAt(2), ";"))
+                        continue;
+                    if (tok2->isStandardType() && tok2->str() == "long")
+                        continue;
+                    if (Token::Match(tok2->tokAt(-1), "enum|struct|union") || (isCPP() && Token::Match(tok2->tokAt(-1), "class|::")))
+                        continue;
+                    syntaxError(tok2);
+                }
+            }
+        }
+        if (cpp && tok->str() == "namespace") {
+            if (tok->tokAt(-1) && !Token::Match(tok->tokAt(-1), ";|{|}|using|inline")) {
+                if (tok->tokAt(-1)->isUpperCaseName())
+                    unknownMacroError(tok->tokAt(-1));
+                else if (tok->linkAt(-1) && tok->linkAt(-1)->tokAt(-1) && tok->linkAt(-1)->tokAt(-1)->isUpperCaseName())
+                    unknownMacroError(tok->linkAt(-1)->tokAt(-1));
+                else
+                    syntaxError(tok);
+            }
+            if (!tok->next() || (Token::Match(tok->next(), "%name% =") && !Token::Match(tok->tokAt(3), "::|%name%")))
+                syntaxError(tok);
+        }
+        if (cpp && tok->str() == "using" && !Token::Match(tok->next(), "::|%name%"))
+            syntaxError(tok);
     }
 
     // ternary operator without :
@@ -9393,7 +9097,7 @@ void Tokenizer::findGarbageCode() const
     // Code must end with } ; ) NAME
     if (!Token::Match(list.back(), "%name%|;|}|)"))
         syntaxError(list.back());
-    if (list.back()->str() == ")" && !Token::Match(list.back()->link()->previous(), "%name% ("))
+    if (list.back()->str() == ")" && !Token::Match(list.back()->link()->previous(), "%name%|> ("))
         syntaxError(list.back());
     for (const Token *end = list.back(); end && end->isName(); end = end->previous()) {
         if (Token::Match(end, "void|char|short|int|long|float|double|const|volatile|static|inline|struct|class|enum|union|template|sizeof|case|break|continue|typedef"))
@@ -9403,24 +9107,31 @@ void Tokenizer::findGarbageCode() const
         syntaxError(list.back()->previous());
 
     // Garbage templates..
-    if (isCPP()) {
+    if (cpp) {
         for (const Token *tok = tokens(); tok; tok = tok->next()) {
+            if (Token::simpleMatch(tok, "< >") && !(Token::Match(tok->tokAt(-1), "%name%") || (tok->tokAt(-1) && Token::Match(tok->tokAt(-2), "operator %op%"))))
+                syntaxError(tok);
+            if (Token::simpleMatch(tok, ": template") && !Token::Match(tok->tokAt(-1), "public|private|protected"))
+                syntaxError(tok);
+            if (Token::Match(tok, "> class|struct|union {") && Token::simpleMatch(tok->linkAt(2), "} ;"))
+                syntaxError(tok);
             if (!Token::simpleMatch(tok, "template <"))
                 continue;
-            if (tok->previous() && !Token::Match(tok->previous(), "[:;{})>]")) {
+            if (!tok->tokAt(2) || tok->tokAt(2)->isLiteral())
+                syntaxError(tok);
+            if (tok->previous() && !Token::Match(tok->previous(), ":|,|;|{|}|)|<|>|\"C++\"")) {
                 if (tok->previous()->isUpperCaseName())
                     unknownMacroError(tok->previous());
                 else
                     syntaxError(tok);
             }
-            const Token * const tok1 = tok;
-            tok = tok->next()->findClosingBracket();
-            if (!tok)
-                syntaxError(tok1);
-            if (!Token::Match(tok, ">|>> ::|...| %name%") &&
-                !Token::Match(tok, ">|>> [ [ %name%") &&
-                !Token::Match(tok, "> >|*"))
-                syntaxError(tok->next() ? tok->next() : tok1);
+            const Token * const tok1 = tok->next()->findClosingBracket();
+            if (!tok1)
+                syntaxError(tok);
+            if (!Token::Match(tok1, ">|>> ::|...| %name%") &&
+                !Token::Match(tok1, ">|>> [ [ %name%") &&
+                !Token::Match(tok1, "> >|*"))
+                syntaxError(tok1->next() ? tok1->next() : tok);
         }
     }
 
@@ -9457,7 +9168,7 @@ std::string Tokenizer::simplifyString(const std::string &source)
         int sz = 0;    // size of stringdata
         if (str[i+1] == 'x') {
             sz = 2;
-            while (sz < 4 && std::isxdigit((unsigned char)str[i+sz]))
+            while (sz < 4 && std::isxdigit(static_cast<unsigned char>(str[i+sz])))
                 sz++;
             if (sz > 2) {
                 std::istringstream istr(str.substr(i+2, sz-2));
@@ -9469,139 +9180,75 @@ std::string Tokenizer::simplifyString(const std::string &source)
                 sz++;
             std::istringstream istr(str.substr(i+1, sz-1));
             istr >> std::oct >> c;
-            str = str.substr(0,i) + (char)c + str.substr(i+sz);
+            str = str.replace(i, sz, std::string(1U, static_cast<char>(c)));
             continue;
         }
 
         if (sz <= 2)
             i++;
         else if (i+sz < str.size())
-            str.replace(i, sz, std::string(1U, (char)c));
+            str.replace(i, sz, std::string(1U, static_cast<char>(c)));
         else
             str.replace(i, str.size() - i - 1U, "a");
     }
-
-    return str;
-}
-
-void Tokenizer::simplifyWhile0()
-{
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        // while (0)
-        const bool while0(Token::Match(tok->previous(), "[{};] while ( 0|false )"));
-
-        // for (0) - not banal, ticket #3140
-        const bool for0((Token::Match(tok->previous(), "[{};] for ( %name% = %num% ; %name% < %num% ;") &&
-                         tok->strAt(2) == tok->strAt(6) && tok->strAt(4) == tok->strAt(8)) ||
-                        (Token::Match(tok->previous(), "[{};] for ( %type% %name% = %num% ; %name% < %num% ;") &&
-                         tok->strAt(3) == tok->strAt(7) && tok->strAt(5) == tok->strAt(9)));
-
-        if (!while0 && !for0)
-            continue;
-
-        if (while0 && tok->previous()->str() == "}") {
-            // find "do"
-            Token *tok2 = tok->previous()->link();
-            tok2 = tok2->previous();
-            if (tok2 && tok2->str() == "do") {
-                const bool flowmatch = Token::findmatch(tok2, "continue|break", tok) != nullptr;
-                // delete "do ({)"
-                tok2->deleteThis();
-                if (!flowmatch)
-                    tok2->deleteThis();
-
-                // delete "(}) while ( 0 ) (;)"
-                tok = tok->previous();
-                tok->deleteNext(4);  // while ( 0 )
-                if (tok->next() && tok->next()->str() == ";")
-                    tok->deleteNext(); // ;
-                if (!flowmatch)
-                    tok->deleteThis(); // }
-
-                continue;
-            }
-        }
-
-        // remove "while (0) { .. }"
-        if (Token::simpleMatch(tok->next()->link(), ") {")) {
-            Token *end = tok->next()->link(), *old_prev = tok->previous();
-            end = end->next()->link();
-            if (Token::Match(tok, "for ( %name% ="))
-                old_prev = end->link();
-            eraseDeadCode(old_prev, end->next());
-            if (old_prev && old_prev->next())
-                tok = old_prev->next();
-            else
-                break;
-        }
-    }
+
+    return str;
 }
 
-void Tokenizer::simplifyErrNoInWhile()
+void Tokenizer::simplifyFunctionTryCatch()
 {
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (tok->str() != "errno")
-            continue;
+    if (!isCPP())
+        return;
 
-        Token *endpar = nullptr;
-        if (Token::Match(tok->previous(), "&& errno == EINTR ) { ;| }"))
-            endpar = tok->tokAt(3);
-        else if (Token::Match(tok->tokAt(-2), "&& ( errno == EINTR ) ) { ;| }"))
-            endpar = tok->tokAt(4);
-        else
+    for (Token * tok = list.front(); tok; tok = tok->next()) {
+        if (!Token::Match(tok, "try {|:"))
+            continue;
+        const Token* par = tok->previous();
+        while (par && par->isKeyword())
+            par = par->previous();
+        if (!TokenList::isFunctionHead(par, "try")) // TODO: this is supposed to a list of characters and not strings
             continue;
 
-        if (Token::simpleMatch(endpar->link()->previous(), "while (")) {
-            Token *tok1 = tok->previous();
-            if (tok1->str() == "(")
-                tok1 = tok1->previous();
+        Token* tryStartToken = skipInitializerList(tok->next());
 
-            // erase "&& errno == EINTR"
-            tok1 = tok1->previous();
-            Token::eraseTokens(tok1, endpar);
+        if (!Token::simpleMatch(tryStartToken, "{"))
+            syntaxError(tryStartToken, "Invalid function-try-catch block code. Did not find '{' for try body.");
 
-            // tok is invalid.. move to endpar
-            tok = endpar;
+        // find the end of the last catch block
+        Token * const tryEndToken = tryStartToken->link();
+        Token * endToken = tryEndToken;
+        while (Token::simpleMatch(endToken, "} catch (")) {
+            endToken = endToken->linkAt(2)->next();
+            if (!endToken)
+                break;
+            if (endToken->str() != "{") {
+                endToken = nullptr;
+                break;
+            }
+            endToken = endToken->link();
         }
+        if (!endToken || endToken == tryEndToken)
+            continue;
+
+        tok->previous()->insertToken("{");
+        endToken->insertToken("}");
+        Token::createMutualLinks(tok->previous(), endToken->next());
     }
 }
 
-
-void Tokenizer::simplifyFuncInWhile()
+static bool isAnonymousEnum(const Token* tok)
 {
-    int count = 0;
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (!Token::Match(tok, "while ( %name% ( %name% ) ) {"))
-            continue;
-
-        Token *func = tok->tokAt(2);
-        const Token * const var = tok->tokAt(4);
-        Token * const end = tok->next()->link()->next()->link();
-
-        const int varid = ++mVarId; // Create new variable
-        const std::string varname("cppcheck:r" + MathLib::toString(++count));
-        tok->str("int");
-        tok->next()->insertToken(varname);
-        tok->tokAt(2)->varId(varid);
-        tok->insertToken("while");
-        tok->insertToken(";");
-        tok->insertToken(")");
-        tok->insertToken(var->str());
-        tok->next()->varId(var->varId());
-        tok->insertToken("(");
-        tok->insertToken(func->str());
-        tok->insertToken("=");
-        tok->insertToken(varname);
-        tok->next()->varId(varid);
-        Token::createMutualLinks(tok->tokAt(4), tok->tokAt(6));
-        end->previous()->insertToken(varname);
-        end->previous()->varId(varid);
-        end->previous()->insertToken("=");
-        Token::move(func, func->tokAt(3), end->previous());
-        end->previous()->insertToken(";");
-
-        tok = end;
+    if (!Token::Match(tok, "enum {|:"))
+        return false;
+    if (tok->index() > 2 && Token::Match(tok->tokAt(-3), "using %name% ="))
+        return false;
+    const Token* end = tok->next();
+    if (end->str() == ":") {
+        end = end->next();
+        while (Token::Match(end, "%name%|::"))
+            end = end->next();
     }
+    return end && Token::Match(end->link(), "} (| %type%| )| [*,;[({=]");
 }
 
 void Tokenizer::simplifyStructDecl()
@@ -9611,45 +9258,54 @@ void Tokenizer::simplifyStructDecl()
     // A counter that is used when giving unique names for anonymous structs.
     int count = 0;
 
-    // Skip simplification of unions in class definition
-    std::stack<bool> skip; // true = in function, false = not in function
-    skip.push(false);
-
     // Add names for anonymous structs
     for (Token *tok = list.front(); tok; tok = tok->next()) {
         if (!tok->isName())
             continue;
         // check for anonymous struct/union
         if (Token::Match(tok, "struct|union {")) {
-            if (Token::Match(tok->next()->link(), "} const| *|&| const| %type% ,|;|[|(|{|=")) {
-                tok->insertToken("Anonymous" + MathLib::toString(count++));
+            if (Token::Match(tok->linkAt(1), "} const| *|&| const| %type% ,|;|[|(|{|=")) {
+                tok->insertToken("Anonymous" + std::to_string(count++));
             }
         }
         // check for derived anonymous class/struct
         else if (cpp && Token::Match(tok, "class|struct :")) {
             const Token *tok1 = Token::findsimplematch(tok, "{");
             if (tok1 && Token::Match(tok1->link(), "} const| *|&| const| %type% ,|;|[|(|{")) {
-                tok->insertToken("Anonymous" + MathLib::toString(count++));
+                tok->insertToken("Anonymous" + std::to_string(count++));
             }
         }
         // check for anonymous enum
-        else if ((Token::simpleMatch(tok, "enum {") &&
-                  !Token::Match(tok->tokAt(-3), "using %name% =") &&
-                  Token::Match(tok->next()->link(), "} %type%| ,|;|[|(|{")) ||
-                 (Token::Match(tok, "enum : %type% {") && Token::Match(tok->linkAt(3), "} %type%| ,|;|[|(|{"))) {
-            tok->insertToken("Anonymous" + MathLib::toString(count++));
+        else if (isAnonymousEnum(tok)) {
+            Token *start = tok->strAt(1) == ":" ? tok->linkAt(3) : tok->linkAt(1);
+            if (start && Token::Match(start->next(), "( %type% )")) {
+                start->linkAt(1)->deleteThis();
+                start->next()->deleteThis();
+            }
+            tok->insertToken("Anonymous" + std::to_string(count++));
         }
     }
 
+    // "{" token for current scope
+    std::stack<const Token*> scopeStart;
+    const Token* functionEnd = nullptr;
+
     for (Token *tok = list.front(); tok; tok = tok->next()) {
 
         // check for start of scope and determine if it is in a function
-        if (tok->str() == "{")
-            skip.push(Token::Match(tok->previous(), "const|)"));
+        if (tok->str() == "{") {
+            scopeStart.push(tok);
+            if (!functionEnd && Token::Match(tok->previous(), "const|)"))
+                functionEnd = tok->link();
+        }
 
         // end of scope
-        else if (tok->str() == "}" && !skip.empty())
-            skip.pop();
+        else if (tok->str() == "}") {
+            if (!scopeStart.empty())
+                scopeStart.pop();
+            if (tok == functionEnd)
+                functionEnd = nullptr;
+        }
 
         // check for named struct/union
         else if (Token::Match(tok, "class|struct|union|enum %type% :|{")) {
@@ -9659,121 +9315,97 @@ void Tokenizer::simplifyStructDecl()
             const Token * const type = tok->next();
             Token *next = tok->tokAt(2);
 
-            while (next && next->str() != "{")
+            while (next && !Token::Match(next, "[{;]"))
                 next = next->next();
-            if (!next)
+            if (!next || next->str() == ";")
                 continue;
-            skip.push(false);
-            tok = next->link();
-            if (!tok)
+            Token* after = next->link();
+            if (!after)
                 break; // see #4869 segmentation fault in Tokenizer::simplifyStructDecl (invalid code)
-            Token *restart = next;
 
             // check for named type
-            if (Token::Match(tok->next(), "const| *|&| const| %type% ,|;|[|=|(|{")) {
-                tok->insertToken(";");
-                tok = tok->next();
+            if (Token::Match(after->next(), "const|static|volatile| *|&| const| (| %type% )| ,|;|[|=|(|{")) {
+                after->insertToken(";");
+                after = after->next();
                 while (!Token::Match(start, "struct|class|union|enum")) {
-                    tok->insertToken(start->str());
-                    tok = tok->next();
+                    after->insertToken(start->str());
+                    after = after->next();
+                    after->column(start->column());
                     start->deleteThis();
                 }
-                if (!tok)
+                tok = start;
+                if (!after)
                     break; // see #4869 segmentation fault in Tokenizer::simplifyStructDecl (invalid code)
-                tok->insertToken(type->str());
+                after->insertToken(type->str());
+                after->next()->column(type->column());
                 if (start->str() != "class") {
-                    tok->insertToken(start->str());
-                    tok = tok->next();
+                    after->insertToken(start->str());
+                    after = after->next();
+                    after->column(start->column());
                 }
 
-                tok = tok->tokAt(2);
+                after = after->tokAt(2);
+
+                if (Token::Match(after, "( %type% )")) {
+                    after->link()->deleteThis();
+                    after->deleteThis();
+                }
 
                 // check for initialization
-                if (tok && (tok->next()->str() == "(" || tok->next()->str() == "{")) {
-                    tok->insertToken("=");
-                    tok = tok->next();
+                bool isFuncDecl = Token::Match(after, "%name% (") && Token::simpleMatch(after->linkAt(1), ") {");
+                if (Token::Match(after, "%any% (|{") && !isFuncDecl) {
+                    after->insertToken("=");
+                    after = after->next();
+                    const bool isEnum = start->str() == "enum";
+                    if (!isEnum && cpp) {
+                        after->insertToken(type->str());
+                        after = after->next();
+                    }
 
-                    if (start->str() == "enum") {
-                        if (tok->next()->str() == "{") {
-                            tok->next()->str("(");
-                            tok->linkAt(1)->str(")");
+                    if (isEnum) {
+                        if (Token::Match(after->next(), "{ !!}")) {
+                            after->next()->str("(");
+                            after->linkAt(1)->str(")");
                         }
                     }
                 }
             }
-
-            tok = restart;
         }
 
         // check for anonymous struct/union
-        else if (Token::Match(tok, "struct|union {")) {
-            const bool inFunction = skip.top();
-            skip.push(false);
-            Token *tok1 = tok;
-
-            Token *restart = tok->next();
-            tok = tok->next()->link();
-
+        else {
             // unnamed anonymous struct/union so possibly remove it
-            if (tok && tok->next() && tok->next()->str() == ";") {
-                if (inFunction && tok1->str() == "union") {
-                    // Try to create references in the union..
-                    Token *tok2 = tok1->tokAt(2);
-                    while (tok2) {
-                        if (Token::Match(tok2, "%type% %name% ;"))
-                            tok2 = tok2->tokAt(3);
-                        else
+            bool done = false;
+            while (!done && Token::Match(tok, "struct|union {") && Token::simpleMatch(tok->linkAt(1), "} ;")) {
+                done = true;
+
+                // is this a class/struct/union scope?
+                bool isClassStructUnionScope = false;
+                if (!scopeStart.empty()) {
+                    for (const Token* tok2 = scopeStart.top()->previous(); tok2 && !Token::Match(tok2, "[;{}]"); tok2 = tok2->previous()) {
+                        if (Token::Match(tok2, "class|struct|union")) {
+                            isClassStructUnionScope = true;
                             break;
-                    }
-                    if (!Token::simpleMatch(tok2, "} ;"))
-                        continue;
-                    Token *vartok = nullptr;
-                    tok2 = tok1->tokAt(2);
-                    while (Token::Match(tok2, "%type% %name% ;")) {
-                        if (!vartok) {
-                            vartok = tok2->next();
-                            tok2 = tok2->tokAt(3);
-                        } else {
-                            tok2->insertToken("&");
-                            tok2 = tok2->tokAt(2);
-                            tok2->insertToken(vartok->str());
-                            tok2->next()->varId(vartok->varId());
-                            tok2->insertToken("=");
-                            tok2 = tok2->tokAt(4);
                         }
                     }
                 }
 
-                // don't remove unnamed anonymous unions from a class, struct or union
-                if (!(!inFunction && tok1->str() == "union") && !Token::Match(tok1->tokAt(-3), "using %name% =")) {
-                    skip.pop();
-                    tok1->deleteThis();
-                    if (tok1->next() == tok) {
-                        tok1->deleteThis();
-                        tok = tok1;
-                    } else
-                        tok1->deleteThis();
-                    restart = tok1->previous();
+                // remove unnamed anonymous struct/union
+                // * not in class/struct/union scopes
+                if (Token::simpleMatch(tok->linkAt(1), "} ;") && !isClassStructUnionScope && tok->str() != "union") {
+                    tok->linkAt(1)->previous()->deleteNext(2);
+                    tok->deleteNext();
                     tok->deleteThis();
-                    if (tok->next())
-                        tok->deleteThis();
+                    done = false;
                 }
             }
-
-            if (!restart) {
-                simplifyStructDecl();
-                return;
-            } else if (!restart->next())
-                return;
-
-            tok = restart;
         }
     }
 }
 
 void Tokenizer::simplifyCallingConvention()
 {
-    const bool windows = mSettings->isWindowsPlatform();
+    const bool windows = mSettings.platform.isWindows();
 
     for (Token *tok = list.front(); tok; tok = tok->next()) {
         while (Token::Match(tok, "__cdecl|__stdcall|__fastcall|__thiscall|__clrcall|__syscall|__pascal|__fortran|__far|__near") || (windows && Token::Match(tok, "WINAPI|APIENTRY|CALLBACK"))) {
@@ -9782,25 +9414,101 @@ void Tokenizer::simplifyCallingConvention()
     }
 }
 
+static bool isAttribute(const Token* tok, bool gcc) {
+    return gcc ? Token::Match(tok, "__attribute__|__attribute (") : Token::Match(tok, "__declspec|_declspec (");
+}
+
+static Token* getTokenAfterAttributes(Token* tok, bool gccattr) {
+    Token* after = tok;
+    while (isAttribute(after, gccattr))
+        after = after->linkAt(1)->next();
+    return after;
+}
+
+static Token* getVariableTokenAfterAttributes(Token* tok) {
+    Token *vartok = nullptr;
+    Token *after = getTokenAfterAttributes(tok, true);
+
+    // check if after variable name
+    if (Token::Match(after, "[;={]")) {
+        Token *prev = tok->previous();
+        while (Token::simpleMatch(prev, "]"))
+            prev = prev->link()->previous();
+        if (Token::Match(prev, "%type%"))
+            vartok = prev;
+    }
+
+
+    // check if before variable name
+    else {
+        while (Token::Match(after->next(), "const|volatile|static|*|&|&&|%type%")) {
+            after = after->next();
+        }
+        if (Token::Match(after, "%name%")) {
+            vartok = after;
+        }
+    }
+
+    return vartok;
+}
+
+Token* Tokenizer::getAttributeFuncTok(Token* tok, bool gccattr) const {
+    if (!Token::Match(tok, "%name% ("))
+        return nullptr;
+    Token* const after = getTokenAfterAttributes(tok, gccattr);
+    if (!after)
+        syntaxError(tok);
+
+    if (Token::Match(after, "%name%|*|&|(")) {
+        Token *ftok = after;
+        while (Token::Match(ftok, "%name%|::|<|*|& !!(")) {
+            if (ftok->str() == "<") {
+                ftok = ftok->findClosingBracket();
+                if (!ftok)
+                    break;
+            }
+            ftok = ftok->next();
+        }
+        if (Token::simpleMatch(ftok, "( *"))
+            ftok = ftok->tokAt(2);
+        if (Token::Match(ftok, "%name% (|)"))
+            return ftok;
+    } else if (Token::Match(after, "[;{=:]")) {
+        Token *prev = tok->previous();
+        while (Token::Match(prev, "%name%"))
+            prev = prev->previous();
+        if (Token::simpleMatch(prev, ")")) {
+            if (Token::Match(prev->link()->previous(), "%name% ("))
+                return prev->link()->previous();
+            if (isFunctionPointer(prev->link()->tokAt(-2)))
+                return prev->link()->tokAt(-2);
+        }
+        if (Token::simpleMatch(prev, ")") && Token::Match(prev->link()->tokAt(-2), "operator %op% (") && isCPP())
+            return prev->link()->tokAt(-2);
+        if ((!prev || Token::Match(prev, "[;{}*]")) && Token::Match(tok->previous(), "%name%"))
+            return tok->previous();
+    }
+    return nullptr;
+}
+
 void Tokenizer::simplifyDeclspec()
 {
     for (Token *tok = list.front(); tok; tok = tok->next()) {
-        while (Token::Match(tok, "__declspec|_declspec (") && tok->next()->link() && tok->next()->link()->next()) {
-            if (Token::Match(tok->tokAt(2), "noreturn|nothrow")) {
-                Token *tok1 = tok->next()->link()->next();
-                while (tok1 && !Token::Match(tok1, "%name%")) {
-                    tok1 = tok1->next();
-                }
-                if (tok1) {
+        while (isAttribute(tok, false)) {
+            if (Token::Match(tok->tokAt(2), "noreturn|nothrow|dllexport")) {
+                Token *functok = getAttributeFuncTok(tok, false);
+                if (functok) {
                     if (tok->strAt(2) == "noreturn")
-                        tok1->isAttributeNoreturn(true);
+                        functok->isAttributeNoreturn(true);
+                    else if (tok->strAt(2) == "nothrow")
+                        functok->isAttributeNothrow(true);
                     else
-                        tok1->isAttributeNothrow(true);
+                        functok->isAttributeExport(true);
                 }
             } else if (tok->strAt(2) == "property")
-                tok->next()->link()->insertToken("__property");
+                tok->linkAt(1)->insertToken("__property");
 
-            Token::eraseTokens(tok, tok->next()->link()->next());
+            Token::eraseTokens(tok, tok->linkAt(1)->next());
             tok->deleteThis();
         }
     }
@@ -9809,82 +9517,49 @@ void Tokenizer::simplifyDeclspec()
 void Tokenizer::simplifyAttribute()
 {
     for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "%type% (") && !mSettings->library.isNotLibraryFunction(tok)) {
-            if (mSettings->library.isFunctionConst(tok->str(), true))
+        if (!tok->isKeyword() && Token::Match(tok, "%type% (") && !mSettings.library.isNotLibraryFunction(tok)) {
+            if (mSettings.library.isFunctionConst(tok->str(), true))
                 tok->isAttributePure(true);
-            if (mSettings->library.isFunctionConst(tok->str(), false))
+            if (mSettings.library.isFunctionConst(tok->str(), false))
                 tok->isAttributeConst(true);
         }
-        while (Token::Match(tok, "__attribute__|__attribute (") && tok->next()->link() && tok->next()->link()->next()) {
-            if (Token::Match(tok->tokAt(2), "( constructor|__constructor__")) {
-                // prototype for constructor is: void func(void);
-                if (!tok->next()->link()->next())
-                    syntaxError(tok);
-
-                if (tok->next()->link()->next()->str() == "void") { // __attribute__((constructor)) void func() {}
-                    if (!tok->next()->link()->next()->next())
-                        syntaxError(tok);
-
-                    tok->next()->link()->next()->next()->isAttributeConstructor(true);
-                } else if (tok->next()->link()->next()->str() == ";" && tok->linkAt(-1) && tok->previous()->link()->previous()) // void func() __attribute__((constructor));
-                    tok->previous()->link()->previous()->isAttributeConstructor(true);
-                else // void __attribute__((constructor)) func() {}
-                    tok->next()->link()->next()->isAttributeConstructor(true);
-            }
-
-            else if (Token::Match(tok->tokAt(2), "( destructor|__destructor__")) {
-                // prototype for destructor is: void func(void);
-                if (!tok->next()->link()->next())
-                    syntaxError(tok);
-
-                if (tok->next()->link()->next()->str() == "void") // __attribute__((destructor)) void func() {}
-                    tok->next()->link()->next()->next()->isAttributeDestructor(true);
-                else if (tok->next()->link()->next()->str() == ";" && tok->linkAt(-1) && tok->previous()->link()->previous()) // void func() __attribute__((destructor));
-                    tok->previous()->link()->previous()->isAttributeDestructor(true);
-                else // void __attribute__((destructor)) func() {}
-                    tok->next()->link()->next()->isAttributeDestructor(true);
-            }
+        while (isAttribute(tok, true)) {
+            Token *functok = getAttributeFuncTok(tok, true);
 
-            else if (Token::Match(tok->tokAt(2), "( unused|__unused__|used|__used__ )")) {
-                Token *vartok = nullptr;
+            for (Token *attr = tok->tokAt(2); attr->str() != ")"; attr = attr->next()) {
+                if (Token::Match(attr, "%name% ("))
+                    attr = attr->linkAt(1);
 
-                // check if after variable name
-                if (Token::Match(tok->next()->link()->next(), ";|=")) {
-                    if (Token::Match(tok->previous(), "%type%"))
-                        vartok = tok->previous();
+                if (Token::Match(attr, "[(,] constructor|__constructor__ [,()]")) {
+                    if (!functok)
+                        syntaxError(tok);
+                    functok->isAttributeConstructor(true);
                 }
 
-                // check if before variable name
-                else if (Token::Match(tok->next()->link()->next(), "%type%"))
-                    vartok = tok->next()->link()->next();
-
-                if (vartok) {
-                    const std::string &attribute(tok->strAt(3));
-                    if (attribute.find("unused") != std::string::npos)
-                        vartok->isAttributeUnused(true);
-                    else
-                        vartok->isAttributeUsed(true);
+                else if (Token::Match(attr, "[(,] destructor|__destructor__ [,()]")) {
+                    if (!functok)
+                        syntaxError(tok);
+                    functok->isAttributeDestructor(true);
                 }
-            }
-
-            else if (Token::Match(tok->tokAt(2), "( pure|__pure__|const|__const__|noreturn|__noreturn__|nothrow|__nothrow__|warn_unused_result )")) {
-                Token *functok = nullptr;
-
-                // type func(...) __attribute__((attribute));
-                if (tok->previous() && tok->previous()->link() && Token::Match(tok->previous()->link()->previous(), "%name% ("))
-                    functok = tok->previous()->link()->previous();
 
-                // type __attribute__((attribute)) func() { }
-                else {
-                    Token *tok2 = tok->next()->link();
-                    while (Token::Match(tok2, ") __attribute__|__attribute ("))
-                        tok2 = tok2->linkAt(2);
-                    if (Token::Match(tok2, ") %name% ("))
-                        functok = tok2->next();
+                else if (Token::Match(attr, "[(,] unused|__unused__|used|__used__ [,)]")) {
+                    Token *vartok = getVariableTokenAfterAttributes(tok);
+                    if (!vartok)
+                        vartok = functok;
+                    if (vartok) {
+                        const std::string &attribute(attr->strAt(1));
+                        if (attribute.find("unused") != std::string::npos)
+                            vartok->isAttributeUnused(true);
+                        else
+                            vartok->isAttributeUsed(true);
+                    }
                 }
 
-                if (functok) {
-                    const std::string &attribute(tok->strAt(3));
+                else if (Token::Match(attr, "[(,] pure|__pure__|const|__const__|noreturn|__noreturn__|nothrow|__nothrow__|warn_unused_result [,)]")) {
+                    if (!functok)
+                        syntaxError(tok);
+
+                    const std::string &attribute(attr->strAt(1));
                     if (attribute.find("pure") != std::string::npos)
                         functok->isAttributePure(true);
                     else if (attribute.find("const") != std::string::npos)
@@ -9896,13 +9571,23 @@ void Tokenizer::simplifyAttribute()
                     else if (attribute.find("warn_unused_result") != std::string::npos)
                         functok->isAttributeNodiscard(true);
                 }
-            }
 
-            else if (Token::simpleMatch(tok->previous(), "} __attribute__ ( ( packed )")) {
-                tok->previous()->isAttributePacked(true);
+                else if (Token::Match(attr, "[(,] packed [,)]") && Token::simpleMatch(tok->previous(), "}"))
+                    tok->previous()->isAttributePacked(true);
+
+                else if (functok && Token::simpleMatch(attr, "( __visibility__ ( \"default\" ) )"))
+                    functok->isAttributeExport(true);
+
+                else if (Token::Match(attr, "[(,] cleanup ( %name% )")) {
+                    Token *vartok = getVariableTokenAfterAttributes(tok);
+                    if (vartok) {
+                        const std::string& funcname = attr->strAt(3);
+                        vartok->addAttributeCleanup(funcname);
+                    }
+                }
             }
 
-            Token::eraseTokens(tok, tok->next()->link()->next());
+            Token::eraseTokens(tok, tok->linkAt(1)->next());
             tok->deleteThis();
         }
     }
@@ -9915,8 +9600,8 @@ void Tokenizer::simplifyCppcheckAttribute()
             continue;
         if (!tok->previous())
             continue;
-        const std::string &attr = tok->previous()->str();
-        if (attr.compare(0, 11, "__cppcheck_") != 0) // TODO: starts_with("__cppcheck_")
+        const std::string &attr = tok->strAt(-1);
+        if (!startsWith(attr, "__cppcheck_"))
             continue;
         if (attr.compare(attr.size()-2, 2, "__") != 0) // TODO: ends_with("__")
             continue;
@@ -9924,15 +9609,17 @@ void Tokenizer::simplifyCppcheckAttribute()
         Token *vartok = tok->link();
         while (Token::Match(vartok->next(), "%name%|*|&|::")) {
             vartok = vartok->next();
-            if (Token::Match(vartok, "%name% (") && vartok->str().compare(0,11,"__cppcheck_") == 0)
+            if (Token::Match(vartok, "%name% (") && startsWith(vartok->str(),"__cppcheck_"))
                 vartok = vartok->linkAt(1);
         }
 
         if (vartok->isName()) {
             if (Token::Match(tok->previous(), "__cppcheck_low__ ( %num% )"))
-                vartok->setCppcheckAttribute(TokenImpl::CppcheckAttributes::Type::LOW, MathLib::toLongNumber(tok->next()->str()));
+                vartok->setCppcheckAttribute(Token::CppcheckAttributesType::LOW,
+                                             MathLib::toBigNumber(tok->tokAt(1)));
             else if (Token::Match(tok->previous(), "__cppcheck_high__ ( %num% )"))
-                vartok->setCppcheckAttribute(TokenImpl::CppcheckAttributes::Type::HIGH, MathLib::toLongNumber(tok->next()->str()));
+                vartok->setCppcheckAttribute(Token::CppcheckAttributesType::HIGH,
+                                             MathLib::toBigNumber(tok->tokAt(1)));
         }
 
         // Delete cppcheck attribute..
@@ -9949,51 +9636,174 @@ void Tokenizer::simplifyCppcheckAttribute()
 
 void Tokenizer::simplifyCPPAttribute()
 {
-    if (mSettings->standards.cpp < Standards::CPP11 || isC())
+    // According to cppreference alignas is a c21 feature however the macro is often available when compiling c11
+    const bool hasAlignas = ((isCPP() && mSettings.standards.cpp >= Standards::CPP11) || (isC() && mSettings.standards.c >= Standards::C11));
+    const bool hasCppAttribute = ((isCPP() && mSettings.standards.cpp >= Standards::CPP11) || (isC() && mSettings.standards.c >= Standards::C23));
+    const bool hasMaybeUnused =((isCPP() && mSettings.standards.cpp >= Standards::CPP17) || (isC() && mSettings.standards.c >= Standards::C23));
+    const bool hasMaybeUnusedUnderscores = (isC() && mSettings.standards.c >= Standards::C23);
+
+    if (!hasAlignas && !hasCppAttribute)
         return;
 
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (!tok->link() || !Token::Match(tok, "[ [ %name%"))
+    for (Token *tok = list.front(); tok;) {
+        if (!isCPPAttribute(tok) && !isAlignAttribute(tok)) {
+            tok = tok->next();
             continue;
-        if (Token::Match(tok->tokAt(2), "noreturn|nodiscard")) {
-            const Token * head = tok->link()->next();
-            while (Token::Match(head, "%name%|::|*|&"))
-                head = head->next();
-            if (head && head->str() == "(" && isFunctionHead(head, "{|;")) {
-                if (tok->strAt(2) == "noreturn")
+        }
+        if (isCPPAttribute(tok)) {
+            if (!hasCppAttribute) {
+                tok = skipCPPOrAlignAttribute(tok)->next();
+                continue;
+            }
+            if (Token::findsimplematch(tok->tokAt(2), "noreturn", tok->link())) {
+                Token * head = skipCPPOrAlignAttribute(tok)->next();
+                while (isCPPAttribute(head) || isAlignAttribute(head))
+                    head = skipCPPOrAlignAttribute(head)->next();
+                while (Token::Match(head, "%name%|::|*|&|<|>|,")) // skip return type
+                    head = head->next();
+                if (head && head->str() == "(" && (TokenList::isFunctionHead(head, "{;") || Token::simpleMatch(head->link(), ") __attribute__"))) {
                     head->previous()->isAttributeNoreturn(true);
-                else
+                }
+            } else if (Token::findsimplematch(tok->tokAt(2), "nodiscard", tok->link())) {
+                Token * head = skipCPPOrAlignAttribute(tok)->next();
+                while (isCPPAttribute(head) || isAlignAttribute(head))
+                    head = skipCPPOrAlignAttribute(head)->next();
+                while (Token::Match(head, "%name%|::|*|&|<|>|,"))
+                    head = head->next();
+                if (head && head->str() == "(" && TokenList::isFunctionHead(head, "{;")) {
                     head->previous()->isAttributeNodiscard(true);
+                }
+            } else if (Token::findsimplematch(tok->tokAt(2), "fallthrough", tok->link()) || Token::findsimplematch(tok->tokAt(2), "__fallthrough__", tok->link())) {
+                Token * head = skipCPPOrAlignAttribute(tok)->next();
+                while (isCPPAttribute(head) || isAlignAttribute(head))
+                    head = skipCPPOrAlignAttribute(head)->next();
+                while (head && head->str() == ";") // we have semicollon after the attribute which would be removed in 'removeRedundantSemicolons()' so we skip it
+                    head = head->next();
+                if (head)
+                    head->isAttributeFallthrough(true);
+            } else if ((hasMaybeUnusedUnderscores && Token::findsimplematch(tok->tokAt(2), "__maybe_unused__", tok->link()))
+                       || (hasMaybeUnused && Token::findsimplematch(tok->tokAt(2), "maybe_unused", tok->link()))) {
+                Token* head = skipCPPOrAlignAttribute(tok)->next();
+                while (isCPPAttribute(head) || isAlignAttribute(head))
+                    head = skipCPPOrAlignAttribute(head)->next();
+
+                if (!head)
+                    syntaxError(tok);
+
+                if (Token::simpleMatch(head, ";")) {
+                    Token *backTok = tok;
+                    while (Token::Match(backTok, "]|[|)")) {
+                        if (Token::Match(backTok, "]|)"))
+                            backTok = backTok->link();
+                        backTok = backTok->previous();
+                    }
+                    if (Token::Match(backTok, "%name%")) {
+                        backTok->isAttributeMaybeUnused(true);
+                    }
+                } else {
+                    while (Token::Match(head->next(), "%name%|::|*|&|&&"))
+                        head = head->next();
+                    if (Token::Match(head, "%name%") && !Token::Match(head, "auto ["))
+                        head->isAttributeMaybeUnused(true);
+                    else if (Token::Match(tok->previous(), "%name%") && Token::Match(tok->link(), "] [;={]")) {
+                        tok->previous()->isAttributeMaybeUnused(true);
+                    } else if (Token::simpleMatch(head->next(), "[")) {
+                        head = head->next();
+                        const Token *end = head->link();
+                        for (head = head->next(); head != end; head = head->next()) {
+                            if (Token::Match(head, "%name%")) {
+                                head->isAttributeMaybeUnused(true);
+                            }
+                        }
+                    }
+                }
+            } else if (Token::findsimplematch(tok->tokAt(2), "unused", tok->link())) {
+                Token* head = skipCPPOrAlignAttribute(tok)->next();
+                while (isCPPAttribute(head) || isAlignAttribute(head))
+                    head = skipCPPOrAlignAttribute(head)->next();
+                if (!head)
+                    syntaxError(tok);
+                head->isAttributeUnused(true);
+            } else if (Token::Match(tok->previous(), ") [ [ expects|ensures|assert default|audit|axiom| : %name% <|<=|>|>= %num% ] ]")) {
+                const Token *vartok = tok->tokAt(4);
+                if (vartok->str() == ":")
+                    vartok = vartok->next();
+                Token *argtok = tok->tokAt(-2);
+                while (argtok && argtok->str() != "(") {
+                    if (argtok->str() == vartok->str())
+                        break;
+                    if (argtok->str() == ")")
+                        argtok = argtok->link();
+                    argtok = argtok->previous();
+                }
+                if (argtok && argtok->str() == vartok->str()) {
+                    if (vartok->strAt(1) == ">=")
+                        argtok->setCppcheckAttribute(Token::CppcheckAttributesType::LOW,
+                                                     MathLib::toBigNumber(vartok->tokAt(2)));
+                    else if (vartok->strAt(1) == ">")
+                        argtok->setCppcheckAttribute(Token::CppcheckAttributesType::LOW,
+                                                     MathLib::toBigNumber(vartok->tokAt(2)) + 1);
+                    else if (vartok->strAt(1) == "<=")
+                        argtok->setCppcheckAttribute(Token::CppcheckAttributesType::HIGH,
+                                                     MathLib::toBigNumber(vartok->tokAt(2)));
+                    else if (vartok->strAt(1) == "<")
+                        argtok->setCppcheckAttribute(Token::CppcheckAttributesType::HIGH,
+                                                     MathLib::toBigNumber(vartok->tokAt(2)) - 1);
+                }
             }
-        } else if (Token::Match(tok->previous(), ") [ [ expects|ensures|assert default|audit|axiom| : %name% <|<=|>|>= %num% ] ]")) {
-            const Token *vartok = tok->tokAt(4);
-            if (vartok->str() == ":")
-                vartok = vartok->next();
-            Token *argtok = tok->tokAt(-2);
-            while (argtok && argtok->str() != "(") {
-                if (argtok->str() == vartok->str())
-                    break;
-                if (argtok->str() == ")")
-                    argtok = argtok->link();
-                argtok = argtok->previous();
-            }
-            if (argtok && argtok->str() == vartok->str()) {
-                if (vartok->next()->str() == ">=")
-                    argtok->setCppcheckAttribute(TokenImpl::CppcheckAttributes::Type::LOW, MathLib::toLongNumber(vartok->strAt(2)));
-                else if (vartok->next()->str() == ">")
-                    argtok->setCppcheckAttribute(TokenImpl::CppcheckAttributes::Type::LOW, MathLib::toLongNumber(vartok->strAt(2))+1);
-                else if (vartok->next()->str() == "<=")
-                    argtok->setCppcheckAttribute(TokenImpl::CppcheckAttributes::Type::HIGH, MathLib::toLongNumber(vartok->strAt(2)));
-                else if (vartok->next()->str() == "<")
-                    argtok->setCppcheckAttribute(TokenImpl::CppcheckAttributes::Type::HIGH, MathLib::toLongNumber(vartok->strAt(2))-1);
-            }
-        }
-        Token::eraseTokens(tok, tok->link()->next());
+        } else {
+            // alignas(expr)
+
+            if (!hasAlignas) {
+                tok = skipCPPOrAlignAttribute(tok)->next();
+                continue;
+            }
+
+            // alignment requirements could be checked here
+
+            Token* atok = nullptr;
+            if (Token::Match(tok->previous(), "%name%"))
+                atok = tok->previous();
+            else if (Token::simpleMatch(tok->previous(), "]")) {
+                atok = tok;
+                while (atok && Token::simpleMatch(atok->previous(), "]")) {
+                    atok = atok->linkAt(-1);
+                    atok = atok ? atok->previous() : nullptr;
+                }
+                if (!Token::Match(atok, "%name%"))
+                    atok = nullptr;
+            } else {
+                atok = tok;
+                while (isCPPAttribute(atok) || isAlignAttribute(atok))
+                    atok = skipCPPOrAlignAttribute(atok)->next();
+                atok = atok ? getVariableTokenAfterAttributes(atok) : atok;
+            }
+            if (atok) {
+                std::string a;
+                for (const Token* t = tok->tokAt(2); t && t->str() != ")"; t = t->next())
+                    a += " " + t->str();
+                if (a.size() > 1)
+                    atok->addAttributeAlignas(a.substr(1));
+            }
+        }
+        Token::eraseTokens(tok, skipCPPOrAlignAttribute(tok)->next());
         tok->deleteThis();
     }
 }
 
-static const std::set<std::string> keywords = {
+void Tokenizer::simplifySpaceshipOperator()
+{
+    if (isCPP() && mSettings.standards.cpp >= Standards::CPP20) {
+        for (Token *tok = list.front(); tok && tok->next(); tok = tok->next()) {
+            if (Token::simpleMatch(tok, "<= >")) {
+                tok->str("<=>");
+                tok->deleteNext();
+            }
+        }
+    }
+}
+
+static const std::unordered_set<std::string> keywords = {
     "inline"
     , "_inline"
     , "__inline"
@@ -10015,17 +9825,29 @@ void Tokenizer::simplifyKeyword()
     // linux kernel code at least uses "_inline" as struct member name at some
     // places.
 
-    const bool c99 = isC() && mSettings->standards.c >= Standards::C99;
-    const bool cpp11 = isCPP() && mSettings->standards.cpp >= Standards::CPP11;
+    const bool c99 = isC() && mSettings.standards.c >= Standards::C99;
+    const bool cpp11 = isCPP() && mSettings.standards.cpp >= Standards::CPP11;
+    const bool cpp20 = isCPP() && mSettings.standards.cpp >= Standards::CPP20;
 
     for (Token *tok = list.front(); tok; tok = tok->next()) {
         if (keywords.find(tok->str()) != keywords.end()) {
             // Don't remove struct members
-            if (!Token::simpleMatch(tok->previous(), "."))
+            if (!Token::simpleMatch(tok->previous(), ".")) {
+                const bool isinline = (tok->str().find("inline") != std::string::npos);
+                const bool isrestrict = (tok->str().find("restrict") != std::string::npos);
+                if (isinline || isrestrict) {
+                    for (Token *temp = tok->next(); Token::Match(temp, "%name%"); temp = temp->next()) {
+                        if (isinline)
+                            temp->isInline(true);
+                        if (isrestrict)
+                            temp->isRestrict(true);
+                    }
+                }
                 tok->deleteThis(); // Simplify..
+            }
         }
 
-        if (isC() || mSettings->standards.cpp == Standards::CPP03) {
+        if (isC() || mSettings.standards.cpp == Standards::CPP03) {
             if (tok->str() == "auto")
                 tok->deleteThis();
         }
@@ -10036,33 +9858,73 @@ void Tokenizer::simplifyKeyword()
             tok->deleteNext();
 
         if (c99) {
-            while (tok->str() == "restrict")
+            auto getTypeTokens = [tok]() {
+                std::vector<Token*> ret;
+                for (Token *temp = tok; Token::Match(temp, "%name%"); temp = temp->previous()) {
+                    if (!temp->isKeyword())
+                        ret.emplace_back(temp);
+                }
+                for (Token *temp = tok->next(); Token::Match(temp, "%name%"); temp = temp->next()) {
+                    if (!temp->isKeyword())
+                        ret.emplace_back(temp);
+                }
+                return ret;
+            };
+
+            if (tok->str() == "restrict") {
+                for (Token* temp: getTypeTokens())
+                    temp->isRestrict(true);
                 tok->deleteThis();
+            }
 
-            if (mSettings->standards.c >= Standards::C11) {
-                while (tok->str() == "_Atomic")
+            if (mSettings.standards.c >= Standards::C11) {
+                while (tok->str() == "_Atomic") {
+                    if (Token::simpleMatch(tok->next(), "(")) {
+                        tok->linkAt(1)->deleteThis();
+                        tok->next()->deleteThis();
+                    }
+                    for (Token* temp: getTypeTokens())
+                        temp->isAtomic(true);
                     tok->deleteThis();
+                }
             }
         }
 
         else if (cpp11) {
-            if (tok->str() == "constexpr") {
+            if (cpp20 && tok->str() == "consteval") {
                 tok->originalName(tok->str());
-                tok->str("const");
+                tok->str("constexpr");
+            } else if (cpp20 && tok->str() == "constinit") {
+                tok->deleteThis();
             }
 
             // final:
             // 1) struct name final { };   <- struct is final
-            if (Token::Match(tok->previous(), "struct|class|union %type% final [:{]")) {
-                tok->deleteNext();
+            if (Token::Match(tok->previous(), "struct|class|union %type%")) {
+                Token* finalTok = tok->next();
+                if (tok->isUpperCaseName() && Token::Match(finalTok, "%type%") && finalTok->str() != "final") {
+                    tok = finalTok;
+                    finalTok = finalTok->next();
+                }
+                if (Token::simpleMatch(finalTok, "<")) { // specialization
+                    finalTok = finalTok->findClosingBracket();
+                    if (finalTok)
+                        finalTok = finalTok->next();
+                }
+                if (Token::Match(finalTok, "final [:{]")) {
+                    finalTok->deleteThis();
+                    tok->previous()->isFinalType(true);
+                }
             }
 
             // noexcept -> noexcept(true)
             // 2) void f() noexcept; -> void f() noexcept(true);
-            else if (Token::Match(tok, ") noexcept :|{|;|const|override|final")) {
+            else if (Token::Match(tok, ") const|override|final| noexcept :|{|;|,|const|override|final")) {
                 // Insertion is done in inverse order
                 // The brackets are linked together accordingly afterwards
-                Token * tokNoExcept = tok->next();
+                Token* tokNoExcept = tok->next();
+                while (tokNoExcept->str() != "noexcept")
+                    tokNoExcept = tokNoExcept->next();
                 tokNoExcept->insertToken(")");
                 Token * braceEnd = tokNoExcept->next();
                 tokNoExcept->insertToken("true");
@@ -10082,41 +9944,32 @@ void Tokenizer::simplifyKeyword()
     }
 }
 
-void Tokenizer::simplifyAssignmentInFunctionCall()
+static Token* setTokenDebug(Token* start, TokenDebug td)
 {
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (tok->str() == "(")
-            tok = tok->link();
-
-        // Find 'foo(var='. Exclude 'assert(var=' to allow tests to check that assert(...) does not contain side-effects
-        else if (Token::Match(tok, "[;{}] %name% ( %name% =") &&
-                 Token::simpleMatch(tok->linkAt(2), ") ;") &&
-                 !Token::Match(tok->next(), "assert|while")) {
-            const std::string& funcname(tok->next()->str());
-            Token* const vartok = tok->tokAt(3);
-
-            // Goto ',' or ')'..
-            for (Token *tok2 = vartok->tokAt(2); tok2; tok2 = tok2->next()) {
-                if (tok2->link() && Token::Match(tok2, "(|[|{"))
-                    tok2 = tok2->link();
-                else if (tok2->str() == ";")
-                    break;
-                else if (Token::Match(tok2, ")|,")) {
-                    tok2 = tok2->previous();
-
-                    tok2->insertToken(vartok->str());
-                    tok2->next()->varId(vartok->varId());
-
-                    tok2->insertToken("(");
-                    Token::createMutualLinks(tok2->next(), tok->linkAt(2));
-
-                    tok2->insertToken(funcname);
-                    tok2->insertToken(";");
+    if (!start->link())
+        return nullptr;
+    Token* end = start->link();
+    start->deleteThis();
+    for (Token* tok = start; tok != end; tok = tok->next()) {
+        tok->setTokenDebug(td);
+    }
+    end->deleteThis();
+    return end;
+}
 
-                    Token::eraseTokens(tok, vartok);
-                    break;
-                }
-            }
+void Tokenizer::simplifyDebug()
+{
+    if (!mSettings.debugnormal && !mSettings.debugwarnings)
+        return;
+    static const std::unordered_map<std::string, TokenDebug> m = {{"debug_valueflow", TokenDebug::ValueFlow},
+        {"debug_valuetype", TokenDebug::ValueType}};
+    for (Token* tok = list.front(); tok; tok = tok->next()) {
+        if (!Token::Match(tok, "%name% ("))
+            continue;
+        auto it = m.find(tok->str());
+        if (it != m.end()) {
+            tok->deleteThis();
+            tok = setTokenDebug(tok, it->second);
         }
     }
 }
@@ -10125,7 +9978,7 @@ void Tokenizer::simplifyAssignmentBlock()
 {
     for (Token *tok = list.front(); tok; tok = tok->next()) {
         if (Token::Match(tok, "[;{}] %name% = ( {")) {
-            const std::string &varname = tok->next()->str();
+            const std::string &varname = tok->strAt(1);
 
             // goto the "} )"
             int indentlevel = 0;
@@ -10145,7 +9998,7 @@ void Tokenizer::simplifyAssignmentBlock()
                 tok2 = tok2->tokAt(-3);
                 if (Token::Match(tok2, "[;{}] %num%|%name% ;")) {
                     tok2->insertToken("=");
-                    tok2->insertToken(tok->next()->str());
+                    tok2->insertToken(tok->strAt(1));
                     tok2->next()->varId(tok->next()->varId());
                     tok->deleteNext(3);
                     tok2->tokAt(5)->deleteNext();
@@ -10161,12 +10014,12 @@ void Tokenizer::simplifyAsm()
     std::string instruction;
     for (Token *tok = list.front(); tok; tok = tok->next()) {
         if (Token::Match(tok, "__asm|_asm|asm {") &&
-            tok->next()->link()->next()) {
-            instruction = tok->tokAt(2)->stringifyList(tok->next()->link());
-            Token::eraseTokens(tok, tok->next()->link()->next());
+            tok->linkAt(1)->next()) {
+            instruction = tok->tokAt(2)->stringifyList(tok->linkAt(1));
+            Token::eraseTokens(tok, tok->linkAt(1)->next());
         }
 
-        else if (Token::Match(tok, "asm|__asm|__asm__ volatile|__volatile|__volatile__| (")) {
+        else if (Token::Match(tok, "asm|__asm|__asm__ volatile|__volatile|__volatile__|goto|inline| (")) {
             // Goto "("
             Token *partok = tok->next();
             if (partok->str() != "(")
@@ -10179,7 +10032,7 @@ void Tokenizer::simplifyAsm()
             Token *endasm = tok->next();
             const Token *firstSemiColon = nullptr;
             int comment = 0;
-            while (Token::Match(endasm, "%num%|%name%|,|:|;") || (endasm && endasm->linenr() == comment)) {
+            while (Token::Match(endasm, "%num%|%name%|,|:|;|*|(") || (endasm && (endasm->isLiteral() || endasm->linenr() == comment))) {
                 if (Token::Match(endasm, "_asm|__asm|__endasm"))
                     break;
                 if (endasm->str() == ";") {
@@ -10187,6 +10040,11 @@ void Tokenizer::simplifyAsm()
                     if (!firstSemiColon)
                         firstSemiColon = endasm;
                 }
+                if (endasm->str() == "(") {
+                    if (!firstSemiColon)
+                        endasm = endasm->link();
+                    break;
+                }
                 endasm = endasm->next();
             }
             if (Token::simpleMatch(endasm, "__endasm")) {
@@ -10197,7 +10055,15 @@ void Tokenizer::simplifyAsm()
             } else if (firstSemiColon) {
                 instruction = tok->next()->stringifyList(firstSemiColon);
                 Token::eraseTokens(tok, firstSemiColon);
+            } else if (Token::Match(endasm, ") { !!}")) {
+                tok->deleteThis();
+                tok = endasm->tokAt(2);
+                endasm = endasm->linkAt(1);
+                instruction = tok->stringifyList(endasm);
+                Token::eraseTokens(tok, endasm);
             } else if (!endasm) {
+                if (!tok->next())
+                    syntaxError(tok);
                 instruction = tok->next()->stringifyList(endasm);
                 Token::eraseTokens(tok, endasm);
                 tok->insertToken(";");
@@ -10208,6 +10074,11 @@ void Tokenizer::simplifyAsm()
         else
             continue;
 
+        if (Token::Match(tok->previous(), ") %name% %name% (")) {
+            tok->deleteThis();
+            continue;
+        }
+
         // insert "asm ( "instruction" )"
         tok->str("asm");
         if (tok->strAt(1) != ";" && tok->strAt(1) != "{")
@@ -10221,7 +10092,7 @@ void Tokenizer::simplifyAsm()
 
         //move the new tokens in the same line as ";" if available
         tok = tok->tokAt(2);
-        if (tok->next() && tok->next()->str() == ";" &&
+        if (tok->next() && tok->strAt(1) == ";" &&
             tok->next()->linenr() != tok->linenr()) {
             const int endposition = tok->next()->linenr();
             tok = tok->tokAt(-3);
@@ -10251,7 +10122,7 @@ void Tokenizer::simplifyAsm2()
                 start = start->previous();
             }
 
-            const Token *last = tok->next()->link();
+            const Token *last = tok->linkAt(1);
             if (Token::simpleMatch(last, ") {"))
                 last = last->linkAt(1);
             last = last->next();
@@ -10264,7 +10135,7 @@ void Tokenizer::simplifyAsm2()
             if (start && last) {
                 std::string asmcode;
                 while (start->next() != last) {
-                    asmcode += start->next()->str();
+                    asmcode += start->strAt(1);
                     start->deleteNext();
                 }
                 if (last->str() == "}")
@@ -10286,32 +10157,41 @@ void Tokenizer::simplifyAt()
     std::set<std::string> var;
 
     for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "%name% @ %num% ;")) {
-            var.insert(tok->str());
-            tok->isAtAddress(true);
-            Token::eraseTokens(tok,tok->tokAt(3));
-        }
-        if (Token::Match(tok, "%name% @ %num% : %num% ;")) {
-            var.insert(tok->str());
-            tok->isAtAddress(true);
-            Token::eraseTokens(tok,tok->tokAt(5));
-        }
-        if (Token::Match(tok, "%name% @ %name% : %num% ;") && var.find(tok->strAt(2)) != var.end()) {
-            var.insert(tok->str());
-            tok->isAtAddress(true);
-            Token::eraseTokens(tok,tok->tokAt(5));
-        }
+        if (Token::Match(tok, "%name%|]|) @ %num%|%name%|%str%|(")) {
+            const Token *end = tok->tokAt(2);
+            if (end->isLiteral())
+                end = end->next();
+            else if (end->str() == "(") {
+                int par = 0;
+                while ((end = end->next()) != nullptr) {
+                    if (end->str() == "(")
+                        par++;
+                    else if (end->str() == ")") {
+                        if (--par < 0)
+                            break;
+                    }
+                }
+                end = end ? end->next() : nullptr;
+            } else if (var.find(end->str()) != var.end())
+                end = end->next();
+            else
+                continue;
 
-        // array declaration
-        if (Token::Match(tok, "] @ %num% ;")) {
-            tok->isAtAddress(true);
-            Token::eraseTokens(tok,tok->tokAt(3));
+            if (Token::Match(end, ": %num% ;"))
+                end = end->tokAt(2);
+
+            if (Token::Match(end, "[;=]")) {
+                if (tok->isName())
+                    var.insert(tok->str());
+                tok->isAtAddress(true);
+                Token::eraseTokens(tok, end);
+            }
         }
 
         // keywords in compiler from cosmic software for STM8
         // TODO: Should use platform configuration.
         if (Token::Match(tok, "@ builtin|eeprom|far|inline|interrupt|near|noprd|nostack|nosvf|packed|stack|svlreg|tiny|vector")) {
-            tok->str(tok->next()->str() + "@");
+            tok->str(tok->strAt(1) + "@");
             tok->deleteNext();
         }
     }
@@ -10320,60 +10200,72 @@ void Tokenizer::simplifyAt()
 // Simplify bitfields
 void Tokenizer::simplifyBitfields()
 {
-    bool goback = false;
+    std::size_t anonymousBitfieldCounter = 0;
     for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (goback) {
-            goback = false;
-            tok = tok->previous();
-        }
         Token *last = nullptr;
 
+        if (Token::simpleMatch(tok, "for ("))
+            tok = tok->linkAt(1);
+
         if (!Token::Match(tok, ";|{|}|public:|protected:|private:"))
             continue;
 
-        bool isEnum = false;
-        if (tok->str() == "}") {
-            const Token *type = tok->link()->previous();
-            while (type && type->isName()) {
-                if (type->str() == "enum") {
-                    isEnum = true;
-                    break;
-                }
-                type = type->previous();
-            }
-        }
-
-        if (Token::Match(tok->next(), "const| %type% %name% :") &&
+        const bool isEnum = tok->str() == "}" && isEnumStart(tok->link());
+
+        const auto tooLargeError = [this](const Token *tok) {
+            const auto max = std::numeric_limits<short>::max();
+            reportError(tok,
+                        Severity::warning,
+                        "tooLargeBitField",
+                        "Bit-field size exceeds max number of bits " + std::to_string(max));
+        };
+
+        Token* typeTok = tok->next();
+        while (Token::Match(typeTok, "const|volatile"))
+            typeTok = typeTok->next();
+        if (Token::Match(typeTok, ":: %name%"))
+            typeTok = typeTok->next();
+        while (Token::Match(typeTok, "%name% :: %name%"))
+            typeTok = typeTok->tokAt(2);
+        if (Token::Match(typeTok, "%type% %name% :") &&
             !Token::Match(tok->next(), "case|public|protected|private|class|struct") &&
             !Token::simpleMatch(tok->tokAt(2), "default :")) {
-            Token *tok1 = (tok->next()->str() == "const") ? tok->tokAt(3) : tok->tokAt(2);
-            if (Token::Match(tok1, "%name% : %num% ;"))
-                tok1->setBits(MathLib::toLongNumber(tok1->strAt(2)));
+            Token *tok1 = typeTok->next();
+            if (Token::Match(tok1, "%name% : %num% [;=,]"))
+                if (!tok1->setBits(MathLib::toBigNumber(tok1->tokAt(2))))
+                    tooLargeError(tok1->tokAt(2));
             if (tok1 && tok1->tokAt(2) &&
                 (Token::Match(tok1->tokAt(2), "%bool%|%num%") ||
                  !Token::Match(tok1->tokAt(2), "public|protected|private| %type% ::|<|,|{|;"))) {
-                while (tok1->next() && !Token::Match(tok1->next(), "[;,)]{}]")) {
+                while (tok1->next() && !Token::Match(tok1->next(), "[;,)]{}=]")) {
                     if (Token::Match(tok1->next(), "[([]"))
-                        Token::eraseTokens(tok1, tok1->next()->link());
+                        Token::eraseTokens(tok1, tok1->linkAt(1));
                     tok1->deleteNext();
                 }
 
                 last = tok1->next();
             }
         } else if (isEnum && Token::Match(tok, "} %name%| : %num% ;")) {
-            if (tok->next()->str() == ":") {
+            if (tok->strAt(1) == ":") {
                 tok->deleteNext(2);
                 tok->insertToken("Anonymous");
             } else {
                 tok->next()->deleteNext(2);
             }
-        } else if (Token::Match(tok->next(), "const| %type% : %num%|%bool% ;") &&
-                   tok->next()->str() != "default") {
-            const int offset = (tok->next()->str() == "const") ? 1 : 0;
-            if (!Token::Match(tok->tokAt(3 + offset), "[{};()]")) {
-                tok->deleteNext(4 + offset);
-                goback = true;
-            }
+        } else if (Token::Match(typeTok, "%type% : %num%|%bool% ;") &&
+                   typeTok->str() != "default") {
+            const std::size_t id = anonymousBitfieldCounter++;
+            const std::string name = "anonymous@" + std::to_string(id);
+            Token *newTok = typeTok->insertToken(name);
+            newTok->isAnonymous(true);
+            bool failed;
+            if (newTok->tokAt(2)->isBoolean())
+                failed = !newTok->setBits(newTok->strAt(2) == "true");
+            else
+                failed = !newTok->setBits(MathLib::toBigNumber(newTok->tokAt(2)));
+            if (failed)
+                tooLargeError(newTok->tokAt(2));
+            newTok->deleteNext(2);
         }
 
         if (last && last->str() == ",") {
@@ -10390,55 +10282,17 @@ void Tokenizer::simplifyBitfields()
     }
 }
 
+static bool isStdContainerOrIterator(const Token* tok, const Settings& settings)
+{
+    const Library::Container* ctr = settings.library.detectContainerOrIterator(tok, nullptr, /*withoutStd*/ true);
+    return ctr && startsWith(ctr->startPattern, "std ::");
+}
 
-// Types and objects in std namespace that are neither functions nor templates
-static const std::set<std::string> stdTypes = {
-    "string", "wstring", "u16string", "u32string",
-    "iostream", "ostream", "ofstream", "ostringstream",
-    "istream", "ifstream", "istringstream", "fstream", "stringstream",
-    "wstringstream", "wistringstream", "wostringstream", "wstringbuf",
-    "stringbuf", "streambuf", "ios", "filebuf", "ios_base",
-    "exception", "bad_exception", "bad_alloc",
-    "logic_error", "domain_error", "invalid_argument_", "length_error",
-    "out_of_range", "runtime_error", "range_error", "overflow_error", "underflow_error",
-    "locale",
-    "cout", "cerr", "clog", "cin",
-    "wcerr", "wcin", "wclog", "wcout",
-    "endl", "ends", "flush",
-    "boolalpha", "noboolalpha", "showbase", "noshowbase",
-    "showpoint", "noshowpoint", "showpos", "noshowpos",
-    "skipws", "noskipws", "unitbuf", "nounitbuf", "uppercase", "nouppercase",
-    "dec", "hex", "oct",
-    "fixed", "scientific",
-    "internal", "left", "right",
-    "fpos", "streamoff", "streampos", "streamsize"
-};
-
-static const std::set<std::string> stdTemplates = {
-    "array", "basic_string", "bitset", "deque", "list", "map", "multimap",
-    "priority_queue", "queue", "set", "multiset", "stack", "vector", "pair",
-    "iterator", "iterator_traits",
-    "unordered_map", "unordered_multimap", "unordered_set", "unordered_multiset",
-    "tuple", "function"
-};
-static const std::set<std::string> stdFunctions = {
-    "getline",
-    "for_each", "find", "find_if", "find_end", "find_first_of",
-    "adjacent_find", "count", "count_if", "mismatch", "equal", "search", "search_n",
-    "copy", "copy_backward", "swap", "swap_ranges", "iter_swap", "transform", "replace",
-    "replace_if", "replace_copy", "replace_copy_if", "fill", "fill_n", "generate", "generate_n", "remove",
-    "remove_if", "remove_copy", "remove_copy_if",
-    "unique", "unique_copy", "reverse", "reverse_copy",
-    "rotate", "rotate_copy", "random_shuffle", "partition", "stable_partition",
-    "sort", "stable_sort", "partial_sort", "partial_sort_copy", "nth_element",
-    "lower_bound", "upper_bound", "equal_range", "binary_search", "merge", "inplace_merge", "includes",
-    "set_union", "set_intersection", "set_difference",
-    "set_symmetric_difference", "push_heap", "pop_heap", "make_heap", "sort_heap",
-    "min", "max", "min_element", "max_element", "lexicographical_compare", "next_permutation", "prev_permutation",
-    "advance", "back_inserter", "distance", "front_inserter", "inserter",
-    "make_pair", "make_shared", "make_tuple"
-};
-
+static bool isStdSmartPointer(const Token* tok, const Settings& settings)
+{
+    const Library::SmartPointer* ptr = settings.library.detectSmartPointer(tok, /*withoutStd*/ true);
+    return ptr && startsWith(ptr->name, "std::");
+}
 
 // Add std:: in front of std classes, when using namespace std; was given
 void Tokenizer::simplifyNamespaceStd()
@@ -10446,48 +10300,47 @@ void Tokenizer::simplifyNamespaceStd()
     if (!isCPP())
         return;
 
-    const bool isCPP11  = mSettings->standards.cpp == Standards::CPP11;
-
     std::set<std::string> userFunctions;
 
-    for (const Token* tok = Token::findsimplematch(list.front(), "using namespace std ;"); tok; tok = tok->next()) {
+    for (Token* tok = Token::findsimplematch(list.front(), "using namespace std ;"); tok; tok = tok->next()) {
         bool insert = false;
         if (Token::Match(tok, "enum class|struct| %name%| :|{")) { // Don't replace within enum definitions
-            skipEnumBody(&tok);
+            skipEnumBody(tok);
         }
-        if (!Token::Match(tok->previous(), ".|::")) {
-            if (Token::Match(tok, "%name% (")) {
-                if (isFunctionHead(tok->next(), "{"))
+        if (!tok->isName() || tok->isKeyword() || tok->isStandardType() || tok->varId())
+            continue;
+        if (Token::Match(tok->previous(), ".|::|namespace"))
+            continue;
+        if (Token::simpleMatch(tok->next(), "(")) {
+            if (TokenList::isFunctionHead(tok->next(), "{"))
+                userFunctions.insert(tok->str());
+            else if (TokenList::isFunctionHead(tok->next(), ";")) {
+                const Token *start = tok;
+                while (Token::Match(start->previous(), "%type%|*|&"))
+                    start = start->previous();
+                if (start != tok && start->isName() && !start->isKeyword() && (!start->previous() || Token::Match(start->previous(), "[;{}]")))
                     userFunctions.insert(tok->str());
-                else if (isFunctionHead(tok->next(), ";")) {
-                    const Token *start = tok;
-                    while (Token::Match(start->previous(), "%type%|*|&"))
-                        start = start->previous();
-                    if (start != tok && start->isName() && (!start->previous() || Token::Match(start->previous(), "[;{}]")))
-                        userFunctions.insert(tok->str());
-                }
-                if (userFunctions.find(tok->str()) == userFunctions.end() && stdFunctions.find(tok->str()) != stdFunctions.end())
-                    insert = true;
-            } else if (Token::Match(tok, "%name% <") && stdTemplates.find(tok->str()) != stdTemplates.end())
-                insert = true;
-            else if (tok->isName() && !tok->varId() && !Token::Match(tok->next(), "(|<") && stdTypes.find(tok->str()) != stdTypes.end())
+            }
+            if (userFunctions.find(tok->str()) == userFunctions.end() && mSettings.library.matchArguments(tok, "std::" + tok->str()))
                 insert = true;
-        }
+        } else if (Token::simpleMatch(tok->next(), "<") &&
+                   (isStdContainerOrIterator(tok, mSettings) || isStdSmartPointer(tok, mSettings)))
+            insert = true;
+        else if (mSettings.library.hasAnyTypeCheck("std::" + tok->str()) ||
+                 mSettings.library.podtype("std::" + tok->str()) ||
+                 isStdContainerOrIterator(tok, mSettings))
+            insert = true;
 
         if (insert) {
             tok->previous()->insertToken("std");
             tok->previous()->linenr(tok->linenr()); // For stylistic reasons we put the std:: in the same line as the following token
             tok->previous()->fileIndex(tok->fileIndex());
             tok->previous()->insertToken("::");
-        } else if (isCPP11 && Token::Match(tok, "!!:: tr1 ::"))
-            tok->next()->str("std");
+        }
     }
 
     for (Token* tok = list.front(); tok; tok = tok->next()) {
-        if (isCPP11 && Token::simpleMatch(tok, "std :: tr1 ::"))
-            Token::eraseTokens(tok, tok->tokAt(3));
-
-        else if (Token::simpleMatch(tok, "using namespace std ;")) {
+        if (Token::simpleMatch(tok, "using namespace std ;")) {
             Token::eraseTokens(tok, tok->tokAt(4));
             tok->deleteThis();
         }
@@ -10498,7 +10351,7 @@ void Tokenizer::simplifyNamespaceStd()
 void Tokenizer::simplifyMicrosoftMemoryFunctions()
 {
     // skip if not Windows
-    if (!mSettings->isWindowsPlatform())
+    if (!mSettings.platform.isWindows())
         return;
 
     for (Token *tok = list.front(); tok; tok = tok->next()) {
@@ -10520,7 +10373,7 @@ void Tokenizer::simplifyMicrosoftMemoryFunctions()
                 Token *tok2 = tok1->nextArgument(); // Third argument
 
                 if (tok2)
-                    Token::move(tok1->previous(), tok2->tokAt(-2), tok->next()->link()->previous()); // Swap third with second argument
+                    Token::move(tok1->previous(), tok2->tokAt(-2), tok->linkAt(1)->previous()); // Swap third with second argument
             }
         } else if (Token::Match(tok, "ZeroMemory|RtlZeroMemory|RtlZeroBytes|RtlSecureZeroMemory")) {
             // ZeroMemory(dst, len) -> memset(dst, 0, len)
@@ -10593,15 +10446,15 @@ namespace {
 void Tokenizer::simplifyMicrosoftStringFunctions()
 {
     // skip if not Windows
-    if (!mSettings->isWindowsPlatform())
+    if (!mSettings.platform.isWindows())
         return;
 
-    const bool ansi = mSettings->platformType == Settings::Win32A;
+    const bool ansi = (mSettings.platform.type == Platform::Type::Win32A); // TODO: check for UNICODE define instead
     for (Token *tok = list.front(); tok; tok = tok->next()) {
         if (tok->strAt(1) != "(")
             continue;
 
-        const std::map<std::string, triplet>::const_iterator match = apis.find(tok->str());
+        const auto match = apis.find(tok->str());
         if (match!=apis.end()) {
             tok->str(ansi ? match->second.mbcs : match->second.unicode);
             tok->originalName(match->first);
@@ -10609,13 +10462,16 @@ void Tokenizer::simplifyMicrosoftStringFunctions()
             tok->deleteNext();
             tok->deleteThis();
             tok->deleteNext();
-            if (!ansi)
+            if (!ansi) {
                 tok->isLong(true);
+                if (tok->str()[0] != 'L')
+                    tok->str("L" + tok->str());
+            }
             while (Token::Match(tok->next(), "_T|_TEXT|TEXT ( %char%|%str% )")) {
                 tok->next()->deleteNext();
                 tok->next()->deleteThis();
                 tok->next()->deleteNext();
-                tok->concatStr(tok->next()->str());
+                tok->concatStr(tok->strAt(1));
                 tok->deleteNext();
             }
         }
@@ -10626,7 +10482,7 @@ void Tokenizer::simplifyMicrosoftStringFunctions()
 void Tokenizer::simplifyBorland()
 {
     // skip if not Windows
-    if (!mSettings->isWindowsPlatform())
+    if (!mSettings.platform.isWindows())
         return;
     if (isC())
         return;
@@ -10674,86 +10530,30 @@ void Tokenizer::simplifyBorland()
     }
 }
 
-// Remove Qt signals and slots
-void Tokenizer::simplifyQtSignalsSlots()
-{
-    if (isC())
-        return;
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        // check for emit which can be outside of class
-        if (Token::Match(tok, "emit|Q_EMIT %name% (") &&
-            Token::simpleMatch(tok->linkAt(2), ") ;")) {
-            tok->deleteThis();
-        } else if (!Token::Match(tok, "class %name% :"))
-            continue;
-
-        if (tok->previous() && tok->previous()->str() == "enum") {
-            tok = tok->tokAt(2);
-            continue;
-        }
-
-        // count { and } for tok2
-        int indentlevel = 0;
-        for (Token *tok2 = tok; tok2; tok2 = tok2->next()) {
-            if (tok2->str() == "{") {
-                ++indentlevel;
-                if (indentlevel == 1)
-                    tok = tok2;
-                else
-                    tok2 = tok2->link();
-            } else if (tok2->str() == "}") {
-                if (indentlevel<2)
-                    break;
-                else
-                    --indentlevel;
-            }
-            if (tok2->strAt(1) == "Q_OBJECT")
-                tok2->deleteNext();
-
-            if (Token::Match(tok2->next(), "public|protected|private slots|Q_SLOTS :")) {
-                tok2 = tok2->next();
-                tok2->str(tok2->str() + ":");
-                tok2->deleteNext(2);
-                tok2 = tok2->previous();
-            } else if (Token::Match(tok2->next(), "signals|Q_SIGNALS :")) {
-                tok2 = tok2->next();
-                tok2->str("protected:");
-                tok2->deleteNext();
-            } else if (Token::Match(tok2->next(), "emit|Q_EMIT %name% (") &&
-                       Token::simpleMatch(tok2->linkAt(3), ") ;")) {
-                tok2->deleteNext();
-            }
-        }
-    }
-}
-
 void Tokenizer::createSymbolDatabase()
 {
     if (!mSymbolDatabase)
-        mSymbolDatabase = new SymbolDatabase(this, mSettings, mErrorLogger);
+        mSymbolDatabase = new SymbolDatabase(*this);
     mSymbolDatabase->validate();
 }
 
-void Tokenizer::deleteSymbolDatabase()
-{
-    delete mSymbolDatabase;
-    mSymbolDatabase = nullptr;
-}
-
-static bool operatorEnd(const Token * tok)
+bool Tokenizer::operatorEnd(const Token * tok)
 {
     if (tok && tok->str() == ")") {
+        if (TokenList::isFunctionHead(tok, "{;?:["))
+            return true;
+
         tok = tok->next();
-        while (tok && !Token::Match(tok, "[=;{),]")) {
-            if (Token::Match(tok, "const|volatile")) {
+        while (tok && !Token::Match(tok, "[=;{}),]")) {
+            if (Token::Match(tok, "const|volatile|override")) {
                 tok = tok->next();
             } else if (tok->str() == "noexcept") {
                 tok = tok->next();
                 if (tok && tok->str() == "(") {
                     tok = tok->link()->next();
                 }
-            } else if (tok->str() == "throw" && tok->next() && tok->next()->str() == "(") {
-                tok = tok->next()->link()->next();
+            } else if (tok->str() == "throw" && tok->next() && tok->strAt(1) == "(") {
+                tok = tok->linkAt(1)->next();
             }
             // unknown macros ") MACRO {" and ") MACRO(...) {"
             else if (tok->isUpperCaseName()) {
@@ -10761,7 +10561,10 @@ static bool operatorEnd(const Token * tok)
                 if (tok && tok->str() == "(") {
                     tok = tok->link()->next();
                 }
-            } else
+            } else if (Token::Match(tok, "%op% !!(") ||
+                       (Token::Match(tok, "%op% (") && !TokenList::isFunctionHead(tok->next(), "{")))
+                break;
+            else
                 return false;
         }
 
@@ -10777,8 +10580,10 @@ void Tokenizer::simplifyOperatorName()
         return;
 
     for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "using|:: operator %op% ;")) {
+        if (Token::Match(tok, "using|:: operator %op%|%name% ;")) {
             tok->next()->str("operator" + tok->strAt(2));
+            tok->next()->tokType(Token::Type::eKeyword); // we need to preserve the keyword type after setting a non-keyword string
+            // TODO: tok->next()->isOperatorKeyword(true);
             tok->next()->deleteNext();
             continue;
         }
@@ -10786,6 +10591,13 @@ void Tokenizer::simplifyOperatorName()
         if (tok->str() != "operator")
             continue;
         // operator op
+        if (Token::Match(tok, "operator %op% (") && !operatorEnd(tok->linkAt(2))) {
+            tok->str(tok->str() + tok->strAt(1));
+            tok->tokType(Token::Type::eKeyword); // we need to preserve the keyword type after setting a non-keyword string
+            // TODO: tok->isOperatorKeyword(true);
+            tok->deleteNext();
+            continue;
+        }
         std::string op;
         Token *par = tok->next();
         bool done = false;
@@ -10802,8 +10614,10 @@ void Tokenizer::simplifyOperatorName()
                 done = false;
             } else if (Token::Match(par, ".|%op%|,")) {
                 // check for operator in template
+                if (par->str() == "," && !op.empty())
+                    break;
                 if (!(Token::Match(par, "<|>") && !op.empty())) {
-                    op += par->str();
+                    op += par->str() == "." ? par->originalName() : par->str();
                     par = par->next();
                     done = false;
                 }
@@ -10822,25 +10636,71 @@ void Tokenizer::simplifyOperatorName()
                 }
                 op += ")";
                 par = par->next();
+                if (Token::simpleMatch(par, "...")) {
+                    op.clear();
+                    par = nullptr;
+                    break;
+                }
                 done = false;
-            } else if (Token::Match(par, "\"\" %name% (")) {
+            } else if (Token::Match(par, "\"\" %name% )| (|;|<")) {
                 op += "\"\"";
                 op += par->strAt(1);
                 par = par->tokAt(2);
+                if (par->str() == ")") {
+                    par->link()->deleteThis();
+                    par = par->next();
+                    par->deletePrevious();
+                    tok = par->tokAt(-3);
+                }
+                done = true;
+            } else if (par->str() == "::") {
+                op += par->str();
+                par = par->next();
+                done = false;
+            } else if (par->str() == ";" || par->str() == ")") {
                 done = true;
+            } else if (par->str() != "(") {
+                syntaxError(par, "operator");
             }
         }
 
-        if (par && (Token::Match(par, "<|>") || isFunctionHead(par, "{|;"))) {
-            tok->str("operator" + op);
-            Token::eraseTokens(tok, par);
+        const bool returnsRef = Token::simpleMatch(par, "( & (") && tok->next()->isName();
+        if (par && !op.empty()) {
+            if (returnsRef) {
+                Token* tok_op = par->next()->insertToken("operator" + op);
+                // TODO: tok_op->tokType(Token::Type::eKeyword); // the given token is not a keyword but should be treated as such
+                tok_op->isOperatorKeyword(true);
+                tok->deleteThis();
+            }
+            else {
+                tok->str("operator" + op);
+                tok->tokType(Token::Type::eKeyword); // we need to preserve the keyword type after setting a non-keyword string
+                // TODO: tok->isOperatorKeyword(true);
+                Token::eraseTokens(tok, par);
+            }
         }
 
-        if (!op.empty())
+        if (!op.empty() && !returnsRef)
+            tok->isOperatorKeyword(true);
+    }
+
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (Token::Match(tok, "%op% %str% %name%")) {
+            const std::string name = tok->strAt(2);
+            Token * const str = tok->next();
+            str->deleteNext();
+            tok->insertToken("operator\"\"" + name);
+            tok = tok->next();
             tok->isOperatorKeyword(true);
+            tok->insertToken("(");
+            str->insertToken(")");
+            Token::createMutualLinks(tok->next(), str->next());
+            str->insertToken(std::to_string(Token::getStrLength(str)));
+            str->insertToken(",");
+        }
     }
 
-    if (mSettings->debugwarnings) {
+    if (mSettings.debugwarnings) {
         const Token *tok = list.front();
 
         while ((tok = Token::findsimplematch(tok, "operator")) != nullptr) {
@@ -10851,6 +10711,81 @@ void Tokenizer::simplifyOperatorName()
     }
 }
 
+void Tokenizer::simplifyOverloadedOperators()
+{
+    if (isC())
+        return;
+    std::set<std::string> classNames;
+    std::set<nonneg int> classVars;
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (!tok->isName())
+            continue;
+
+        if (Token::simpleMatch(tok, "this ) (") && Token::simpleMatch(tok->tokAt(-2), "( *")) {
+            tok = tok->next();
+            tok->insertToken("operator()");
+            tok->insertToken(".");
+            continue;
+        }
+
+        // Get classes that have operator() member
+        if (Token::Match(tok, "class|struct %name% [:{]")) {
+            int indent = 0;
+            for (const Token *tok2 = tok->next(); tok2; tok2 = tok2->next()) {
+                if (tok2->str() == "}")
+                    break;
+                if (indent == 0 && tok2->str() == ";")
+                    break;
+                if (tok2->str() == "{") {
+                    if (indent == 0)
+                        ++indent;
+                    else
+                        tok2 = tok2->link();
+                } else if (indent == 1 && Token::simpleMatch(tok2, "operator() (") && TokenList::isFunctionHead(tok2->next(), ";{")) {
+                    classNames.insert(tok->strAt(1));
+                    break;
+                }
+            }
+        }
+
+        // Get variables that have operator() member
+        if (Token::Match(tok, "%type% &| %var%") && classNames.find(tok->str()) != classNames.end()) {
+            tok = tok->next();
+            while (!tok->isName())
+                tok = tok->next();
+            classVars.insert(tok->varId());
+        }
+
+        // Simplify operator() calls
+        if (Token::Match(tok, "%var% (") && classVars.find(tok->varId()) != classVars.end()) {
+            // constructor init list..
+            if (Token::Match(tok->previous(), "[:,]")) {
+                const Token *start = tok->previous();
+                while (Token::simpleMatch(start, ",")) {
+                    if (Token::simpleMatch(start->previous(), ")"))
+                        start = start->linkAt(-1);
+                    else
+                        break;
+                    if (Token::Match(start->previous(), "%name%"))
+                        start = start->tokAt(-2);
+                    else
+                        break;
+                }
+                const Token *after = tok->linkAt(1);
+                while (Token::Match(after, ")|} , %name% (|{"))
+                    after = after->linkAt(3);
+
+                // Do not simplify initlist
+                if (Token::simpleMatch(start, ":") && Token::simpleMatch(after, ") {"))
+                    continue;
+            }
+
+            tok->insertToken("operator()");
+            tok->insertToken(".");
+        }
+    }
+}
+
 // remove unnecessary member qualification..
 void Tokenizer::removeUnnecessaryQualification()
 {
@@ -10860,7 +10795,7 @@ void Tokenizer::removeUnnecessaryQualification()
     std::vector<Space> classInfo;
     for (Token *tok = list.front(); tok; tok = tok->next()) {
         if (Token::Match(tok, "class|struct|namespace %type% :|{") &&
-            (!tok->previous() || tok->previous()->str() != "enum")) {
+            (!tok->previous() || tok->strAt(-1) != "enum")) {
             Space info;
             info.isNamespace = tok->str() == "namespace";
             tok = tok->next();
@@ -10871,12 +10806,12 @@ void Tokenizer::removeUnnecessaryQualification()
             if (!tok)
                 return;
             info.bodyEnd = tok->link();
-            classInfo.push_back(info);
+            classInfo.push_back(std::move(info));
         } else if (!classInfo.empty()) {
             if (tok == classInfo.back().bodyEnd)
                 classInfo.pop_back();
             else if (tok->str() == classInfo.back().className &&
-                     !classInfo.back().isNamespace && tok->previous()->str() != ":" &&
+                     !classInfo.back().isNamespace && tok->strAt(-1) != ":" &&
                      (Token::Match(tok, "%type% :: ~| %type% (") ||
                       Token::Match(tok, "%type% :: operator"))) {
                 const Token *tok1 = tok->tokAt(3);
@@ -10922,235 +10857,6 @@ void Tokenizer::removeUnnecessaryQualification()
     }
 }
 
-void Tokenizer::simplifyReturnStrncat()
-{
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (Token::simpleMatch(tok, "return strncat (") &&
-            Token::simpleMatch(tok->linkAt(2), ") ;") &&
-            tok->strAt(3) != ")" && tok->strAt(3) != ",") {
-
-            //first argument
-            Token *tok2 = tok->tokAt(3);
-
-            //check if there are at least three arguments
-            for (int i = 0; i < 2; ++i) {
-                tok2 = tok2->nextArgument();
-                if (!tok2) {
-                    tok = tok->linkAt(2)->next();
-                    break;
-                }
-            }
-            if (!tok2)
-                continue;
-
-            tok2 = tok2->nextArgument();
-            //we want only three arguments
-            if (tok2) {
-                tok = tok->linkAt(2)->next();
-                continue;
-            }
-
-            // Remove 'return'
-            tok->deleteThis();
-
-            // Add 'return arg1 ;' after 'strncat(arg1, arg2, arg3);'
-            tok = tok->next();
-
-            tok2 = tok->link()->next();
-            tok2->insertToken(";");
-
-            //the last token of the first argument before ','
-            const Token * const end = tok->next()->nextArgument()->tokAt(-2);
-
-            //all the first argument is copied
-            TokenList::copyTokens(tok2, tok->next(), end);
-            tok2->insertToken("return");
-        }
-    }
-}
-
-void Tokenizer::printUnknownTypes() const
-{
-    if (!mSymbolDatabase)
-        return;
-
-    std::multimap<std::string, const Token *> unknowns;
-
-    for (int i = 1; i <= mVarId; ++i) {
-        const Variable *var = mSymbolDatabase->getVariableFromVarId(i);
-        if (!var)
-            continue;
-        // is unknown type?
-        if (var->type() || var->typeStartToken()->isStandardType())
-            continue;
-
-        std::string name;
-        const Token * nameTok;
-
-        // single token type?
-        if (var->typeStartToken() == var->typeEndToken()) {
-            nameTok = var->typeStartToken();
-            name = nameTok->str();
-        }
-
-        // complicated type
-        else {
-            const Token *tok = var->typeStartToken();
-            int level = 0;
-
-            nameTok =  tok;
-
-            while (tok) {
-                // skip pointer and reference part of type
-                if (level == 0 && Token::Match(tok, "*|&"))
-                    break;
-
-                name += tok->str();
-
-                if (Token::Match(tok, "struct|union|enum"))
-                    name += " ";
-
-                // pointers and references are OK in template
-                else if (tok->str() == "<")
-                    ++level;
-                else if (tok->str() == ">")
-                    --level;
-
-                if (tok == var->typeEndToken())
-                    break;
-
-                tok = tok->next();
-            }
-        }
-
-        unknowns.insert(std::pair<std::string, const Token *>(name, nameTok));
-    }
-
-    if (!unknowns.empty()) {
-        std::string last;
-        int count = 0;
-
-        for (std::multimap<std::string, const Token *>::const_iterator it = unknowns.begin(); it != unknowns.end(); ++it) {
-            // skip types is std namespace because they are not interesting
-            if (it->first.find("std::") != 0) {
-                if (it->first != last) {
-                    last = it->first;
-                    count = 1;
-                    reportError(it->second, Severity::debug, "debug", "Unknown type \'" + it->first + "\'.");
-                } else {
-                    if (count < 3) // limit same type to 3
-                        reportError(it->second, Severity::debug, "debug", "Unknown type \'" + it->first + "\'.");
-                    count++;
-                }
-            }
-        }
-    }
-}
-
-void Tokenizer::simplifyMathExpressions()
-{
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-
-        //simplify Pythagorean trigonometric identity: pow(sin(x),2)+pow(cos(x),2) = 1
-        //                                             pow(cos(x),2)+pow(sin(x),2) = 1
-        // @todo: sin(x) * sin(x) + cos(x) * cos(x) = 1
-        //        cos(x) * cos(x) + sin(x) * sin(x) = 1
-        //simplify Hyperbolic identity: pow(sinh(x),2)-pow(cosh(x),2) = -1
-        //                              pow(cosh(x),2)-pow(sinh(x),2) = -1
-        // @todo: sinh(x) * sinh(x) - cosh(x) * cosh(x) = -1
-        //        cosh(x) * cosh(x) - sinh(x) * sinh(x) = -1
-        if (Token::Match(tok, "pow|powf|powl (")) {
-            if (Token::Match(tok->tokAt(2), "sin|sinf|sinl (")) {
-                Token * const tok2 = tok->linkAt(3);
-                if (!Token::Match(tok2, ") , %num% ) + pow|powf|powl ( cos|cosf|cosl ("))
-                    continue;
-                const std::string& leftExponent = tok2->strAt(2);
-                if (!isTwoNumber(leftExponent))
-                    continue; // left exponent is not 2
-                const Token * const tok3 = tok2->tokAt(8);
-                Token * const tok4 = tok3->link();
-                if (!Token::Match(tok4, ") , %num% )"))
-                    continue;
-                const std::string& rightExponent = tok4->strAt(2);
-                if (!isTwoNumber(rightExponent))
-                    continue; // right exponent is not 2
-                if (tok->tokAt(3)->stringifyList(tok2->next()) == tok3->stringifyList(tok4->next())) {
-                    Token::eraseTokens(tok, tok4->tokAt(4));
-                    tok->str("1");
-                }
-            } else if (Token::Match(tok->tokAt(2), "cos|cosf|cosl (")) {
-                Token * const tok2 = tok->linkAt(3);
-                if (!Token::Match(tok2, ") , %num% ) + pow|powf|powl ( sin|sinf|sinl ("))
-                    continue;
-                const std::string& leftExponent = tok2->strAt(2);
-                if (!isTwoNumber(leftExponent))
-                    continue; // left exponent is not 2
-                const Token * const tok3 = tok2->tokAt(8);
-                Token * const tok4 = tok3->link();
-                if (!Token::Match(tok4, ") , %num% )"))
-                    continue;
-                const std::string& rightExponent = tok4->strAt(2);
-                if (!isTwoNumber(rightExponent))
-                    continue; // right exponent is not 2
-                if (tok->tokAt(3)->stringifyList(tok2->next()) == tok3->stringifyList(tok4->next())) {
-                    Token::eraseTokens(tok, tok4->tokAt(4));
-                    tok->str("1");
-                }
-            } else if (Token::Match(tok->tokAt(2), "sinh|sinhf|sinhl (")) {
-                Token * const tok2 = tok->linkAt(3);
-                if (!Token::Match(tok2, ") , %num% ) - pow|powf|powl ( cosh|coshf|coshl ("))
-                    continue;
-                const std::string& leftExponent = tok2->strAt(2);
-                if (!isTwoNumber(leftExponent))
-                    continue; // left exponent is not 2
-                const Token * const tok3 = tok2->tokAt(8);
-                Token * const tok4 = tok3->link();
-                if (!Token::Match(tok4, ") , %num% )"))
-                    continue;
-                const std::string& rightExponent = tok4->strAt(2);
-                if (!isTwoNumber(rightExponent))
-                    continue; // right exponent is not 2
-                if (tok->tokAt(3)->stringifyList(tok2->next()) == tok3->stringifyList(tok4->next())) {
-                    Token::eraseTokens(tok, tok4->tokAt(4));
-                    tok->str("-1");
-                }
-            } else if (Token::Match(tok->tokAt(2), "cosh|coshf|coshl (")) {
-                Token * const tok2 = tok->linkAt(3);
-                if (!Token::Match(tok2, ") , %num% ) - pow|powf|powl ( sinh|sinhf|sinhl ("))
-                    continue;
-                const std::string& leftExponent = tok2->strAt(2);
-                if (!isTwoNumber(leftExponent))
-                    continue; // left exponent is not 2
-                const Token * const tok3 = tok2->tokAt(8);
-                Token * const tok4 = tok3->link();
-                if (!Token::Match(tok4, ") , %num% )"))
-                    continue;
-                const std::string& rightExponent = tok4->strAt(2);
-                if (!isTwoNumber(rightExponent))
-                    continue; // right exponent is not 2
-                if (tok->tokAt(3)->stringifyList(tok2->next()) == tok3->stringifyList(tok4->next())) {
-                    Token::eraseTokens(tok, tok4->tokAt(4));
-                    tok->str("-1");
-                }
-            }
-        }
-    }
-}
-
-bool Tokenizer::simplifyStrlen()
-{
-    // replace strlen(str)
-    bool modified=false;
-    for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "strlen ( %str% )")) {
-            tok->str(MathLib::toString(Token::getStrLength(tok->tokAt(2))));
-            tok->deleteNext(3);
-            modified=true;
-        }
-    }
-    return modified;
-}
-
 void Tokenizer::prepareTernaryOpForAST()
 {
     // http://en.cppreference.com/w/cpp/language/operator_precedence says about ternary operator:
@@ -11181,38 +10887,33 @@ void Tokenizer::prepareTernaryOpForAST()
             }
             if (parenthesesNeeded && tok2 && tok2->str() == ":") {
                 tok->insertToken("(");
-                tok2->insertToken(")", emptyString, true);
+                tok2->insertTokenBefore(")");
                 Token::createMutualLinks(tok->next(), tok2->previous());
             }
         }
     }
 }
 
-void Tokenizer::reportError(const Token* tok, const Severity::SeverityType severity, const std::string& id, const std::string& msg, bool inconclusive) const
+void Tokenizer::reportError(const Token* tok, const Severity severity, const std::string& id, const std::string& msg, bool inconclusive) const
 {
     const std::list<const Token*> callstack(1, tok);
     reportError(callstack, severity, id, msg, inconclusive);
 }
 
-void Tokenizer::reportError(const std::list<const Token*>& callstack, Severity::SeverityType severity, const std::string& id, const std::string& msg, bool inconclusive) const
+void Tokenizer::reportError(const std::list<const Token*>& callstack, Severity severity, const std::string& id, const std::string& msg, bool inconclusive) const
 {
-    const ErrorLogger::ErrorMessage errmsg(callstack, &list, severity, id, msg, inconclusive);
-    if (mErrorLogger)
-        mErrorLogger->reportErr(errmsg);
-    else
-        Check::reportError(errmsg);
+    const ErrorMessage errmsg(callstack, &list, severity, id, msg, inconclusive ? Certainty::inconclusive : Certainty::normal);
+    mErrorLogger.reportErr(errmsg);
 }
 
 void Tokenizer::setPodTypes()
 {
-    if (!mSettings)
-        return;
     for (Token *tok = list.front(); tok; tok = tok->next()) {
-        if (!tok->isName())
+        if (!tok->isName() || tok->varId())
             continue;
 
         // pod type
-        const struct Library::PodType *podType = mSettings->library.podtype(tok->str());
+        const Library::PodType *podType = mSettings.library.podtype(tok->str());
         if (podType) {
             const Token *prev = tok->previous();
             while (prev && prev->isName())
@@ -11224,17 +10925,6 @@ void Tokenizer::setPodTypes()
     }
 }
 
-void Tokenizer::SimplifyNamelessRValueReferences()
-{
-    // Simplify nameless rValue references - named ones are simplified later
-    for (Token* tok = list.front(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "&& [,)]")) {
-            tok->str("&");
-            tok->insertToken("&");
-        }
-    }
-}
-
 const Token *Tokenizer::findSQLBlockEnd(const Token *tokSQLStart)
 {
     const Token *tokLastEnd = nullptr;
@@ -11293,6 +10983,29 @@ void Tokenizer::simplifyNestedNamespace()
     }
 }
 
+void Tokenizer::simplifyCoroutines()
+{
+    if (!isCPP() || mSettings.standards.cpp < Standards::CPP20)
+        return;
+    for (Token *tok = list.front(); tok; tok = tok->next()) {
+        if (!tok->isName() || !Token::Match(tok, "co_return|co_yield|co_await"))
+            continue;
+        Token *end = tok->next();
+        while (end && end->str() != ";") {
+            if (Token::Match(end, "[({[]"))
+                end = end->link();
+            else if (Token::Match(end, "[)]}]"))
+                break;
+            end = end->next();
+        }
+        if (Token::simpleMatch(end, ";")) {
+            tok->insertToken("(");
+            end->previous()->insertToken(")");
+            Token::createMutualLinks(tok->next(), end->previous());
+        }
+    }
+}
+
 static bool sameTokens(const Token *first, const Token *last, const Token *other)
 {
     while (other && first->str() == other->str()) {
@@ -11305,6 +11018,18 @@ static bool sameTokens(const Token *first, const Token *last, const Token *other
     return false;
 }
 
+static bool alreadyHasNamespace(const Token *first, const Token *last, const Token *end)
+{
+    while (end && last->str() == end->str()) {
+        if (first == last)
+            return true;
+        last = last->previous();
+        end = end->previous();
+    }
+
+    return false;
+}
+
 static Token * deleteAlias(Token * tok)
 {
     Token::eraseTokens(tok, Token::findsimplematch(tok, ";"));
@@ -11326,23 +11051,37 @@ void Tokenizer::simplifyNamespaceAliases()
     int scope = 0;
 
     for (Token *tok = list.front(); tok; tok = tok->next()) {
+        bool isPrev{};
         if (tok->str() == "{")
             scope++;
         else if (tok->str() == "}")
             scope--;
-        else if (Token::Match(tok, "namespace %name% =")) {
-            const std::string name(tok->next()->str());
+        else if (Token::Match(tok, "namespace %name% =") || (isPrev = Token::Match(tok->previous(), "namespace %name% ="))) {
+            if (isPrev)
+                tok = tok->previous();
+            if (tok->tokAt(-1) && !Token::Match(tok->tokAt(-1), "[;{}]"))
+                syntaxError(tok->tokAt(-1));
+            const std::string name(tok->strAt(1));
             Token * tokNameStart = tok->tokAt(3);
             Token * tokNameEnd = tokNameStart;
 
-            while (tokNameEnd && tokNameEnd->next() && tokNameEnd->next()->str() != ";")
+            while (tokNameEnd && tokNameEnd->next() && tokNameEnd->strAt(1) != ";") {
+                if (tokNameEnd->str() == "(") {
+                    if (tokNameEnd->previous()->isName())
+                        unknownMacroError(tokNameEnd->previous());
+                    else
+                        syntaxError(tokNameEnd);
+                }
                 tokNameEnd = tokNameEnd->next();
+            }
 
             if (!tokNameEnd)
                 return; // syntax error
 
             int endScope = scope;
             Token * tokLast = tokNameEnd->next();
+            if (!tokLast)
+                return;
             Token * tokNext = tokLast->next();
             Token * tok2 = tokNext;
 
@@ -11358,28 +11097,32 @@ void Tokenizer::simplifyNamespaceAliases()
                             // delete duplicate
                             tok2 = deleteAlias(tok2->previous());
                             continue;
-                        } else {
-                            // conflicting declaration (syntax error)
-                            if (endScope == scope) {
-                                // delete conflicting declaration
-                                tok2 = deleteAlias(tok2->previous());
-                            }
+                        }
+                        // conflicting declaration (syntax error)
+                        // cppcheck-suppress duplicateBranch - remove when TODO below is addressed
+                        if (endScope == scope) {
+                            // delete conflicting declaration
+                            tok2 = deleteAlias(tok2->previous());
+                        }
 
-                            // new declaration
-                            else {
-                                // TODO: use the new alias in this scope
-                                tok2 = deleteAlias(tok2->previous());
-                            }
-                            continue;
+                        // new declaration
+                        else {
+                            // TODO: use the new alias in this scope
+                            tok2 = deleteAlias(tok2->previous());
                         }
+                        continue;
                     }
 
-                    tok2->str(tokNameStart->str());
-                    Token * tok3 = tokNameStart;
-                    while (tok3 != tokNameEnd) {
-                        tok2->insertToken(tok3->next()->str());
-                        tok2 = tok2->next();
-                        tok3 = tok3->next();
+                    if (tok2->strAt(1) == "::" && !alreadyHasNamespace(tokNameStart, tokNameEnd, tok2)) {
+                        if (Token::simpleMatch(tok2->tokAt(-1), "::") && tokNameStart->str() == "::")
+                            tok2->deletePrevious();
+                        tok2->str(tokNameStart->str());
+                        Token * tok3 = tokNameStart;
+                        while (tok3 != tokNameEnd) {
+                            tok2->insertToken(tok3->strAt(1));
+                            tok2 = tok2->next();
+                            tok3 = tok3->next();
+                        }
                     }
                 }
                 tok2 = tok2->next();
@@ -11402,46 +11145,38 @@ void Tokenizer::simplifyNamespaceAliases()
     }
 }
 
-
-Tokenizer::VariableMap::VariableMap() : mVarId(0) {}
-
-void Tokenizer::VariableMap::enterScope()
+void Tokenizer::setDirectives(std::list<Directive> directives)
 {
-    mScopeInfo.push(std::list<std::pair<std::string, int>>());
+    mDirectives = std::move(directives);
 }
 
-bool Tokenizer::VariableMap::leaveScope()
+bool Tokenizer::hasIfdef(const Token *start, const Token *end) const
 {
-    if (mScopeInfo.empty())
-        return false;
-
-    for (const std::pair<std::string, int> &outerVariable : mScopeInfo.top()) {
-        if (outerVariable.second != 0)
-            mVariableId[outerVariable.first] = outerVariable.second;
-        else
-            mVariableId.erase(outerVariable.first);
-    }
-    mScopeInfo.pop();
-    return true;
+    const auto& directives = mDirectives;
+    return std::any_of(directives.cbegin(), directives.cend(), [&](const Directive& d) {
+        return startsWith(d.str, "#if") &&
+               d.linenr >= start->linenr() &&
+               d.linenr <= end->linenr() &&
+               start->fileIndex() < list.getFiles().size() &&
+               d.file == list.getFiles()[start->fileIndex()];
+    });
 }
 
-void Tokenizer::VariableMap::addVariable(const std::string &varname)
+bool Tokenizer::isPacked(const Token * bodyStart) const
 {
-    if (mScopeInfo.empty()) {
-        mVariableId[varname] = ++mVarId;
-        return;
-    }
-    std::map<std::string, int>::iterator it = mVariableId.find(varname);
-    if (it == mVariableId.end()) {
-        mScopeInfo.top().push_back(std::pair<std::string, int>(varname, 0));
-        mVariableId[varname] = ++mVarId;
-        return;
-    }
-    mScopeInfo.top().push_back(std::pair<std::string, int>(varname, it->second));
-    it->second = ++mVarId;
+    const auto& directives = mDirectives;
+    // TODO: should this return true if the #pragma exists in any line before the start token?
+    return std::any_of(directives.cbegin(), directives.cend(), [&](const Directive& d) {
+        return d.linenr < bodyStart->linenr() && d.str == "#pragma pack(1)" && d.file == list.getFiles().front();
+    });
 }
 
-bool Tokenizer::VariableMap::hasVariable(const std::string &varname) const
+void Tokenizer::getErrorMessages(ErrorLogger& errorLogger, const Settings& settings)
 {
-    return mVariableId.find(varname) != mVariableId.end();
+    TokenList tokenlist{settings, Standards::Language::C};
+    Tokenizer tokenizer(std::move(tokenlist), errorLogger);
+    tokenizer.invalidConstFunctionTypeError(nullptr);
+    // checkLibraryNoReturn
+    tokenizer.unhandled_macro_class_x_y(nullptr, "", "", "", "");
+    tokenizer.unhandledCharLiteral(nullptr, "");
 }
diff --git a/lib/tokenize.h b/lib/tokenize.h
index ddffb8a881b..94f08f9f68e 100644
--- a/lib/tokenize.h
+++ b/lib/tokenize.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,24 +22,24 @@
 //---------------------------------------------------------------------------
 
 #include "config.h"
-#include "errorlogger.h"
 #include "tokenlist.h"
 
-#include <ctime>
+#include <cstdint>
+#include <iosfwd>
 #include <list>
 #include <map>
+#include <set>
 #include <string>
-#include <stack>
+#include <vector>
 
 class Settings;
 class SymbolDatabase;
-class TimerResults;
+class TimerResultsIntf;
 class Token;
 class TemplateSimplifier;
-
-namespace simplecpp {
-    class TokenList;
-}
+class ErrorLogger;
+struct Directive;
+enum class Severity : std::uint8_t;
 
 /// @addtogroup Core
 /// @{
@@ -47,47 +47,13 @@ namespace simplecpp {
 /** @brief The main purpose is to tokenize the source code. It also has functions that simplify the token list */
 class CPPCHECKLIB Tokenizer {
 
-    friend class TestSimplifyTokens;
-    friend class TestSimplifyTypedef;
-    friend class TestSimplifyUsing;
-    friend class TestTokenizer;
     friend class SymbolDatabase;
-    friend class TestSimplifyTemplate;
-    friend class TemplateSimplifier;
-
-    /** Class used in Tokenizer::setVarIdPass1 */
-    class VariableMap {
-    private:
-        std::map<std::string, int> mVariableId;
-        std::stack<std::list<std::pair<std::string,int> > > mScopeInfo;
-        mutable nonneg int mVarId;
-    public:
-        VariableMap();
-        void enterScope();
-        bool leaveScope();
-        void addVariable(const std::string &varname);
-        bool hasVariable(const std::string &varname) const;
-        std::map<std::string,int>::const_iterator find(const std::string &varname) const {
-            return mVariableId.find(varname);
-        }
-        std::map<std::string,int>::const_iterator end() const {
-            return mVariableId.end();
-        }
-        const std::map<std::string,int> &map() const {
-            return mVariableId;
-        }
-        nonneg int *getVarId() const {
-            return &mVarId;
-        }
-    };
-
 
 public:
-    Tokenizer();
-    Tokenizer(const Settings * settings, ErrorLogger *errorLogger);
+    Tokenizer(TokenList tokenList, ErrorLogger &errorLogger);
     ~Tokenizer();
 
-    void setTimerResults(TimerResults *tr) {
+    void setTimerResults(TimerResultsIntf *tr) {
         mTimerResults = tr;
     }
 
@@ -107,204 +73,107 @@ class CPPCHECKLIB Tokenizer {
      * \param unknown set to true if it's unknown if the scope is noreturn
      * \return true if scope ends with a function call that might be 'noreturn'
      */
-    bool IsScopeNoReturn(const Token *endScopeToken, bool *unknown = nullptr) const;
+    bool isScopeNoReturn(const Token *endScopeToken, bool *unknown = nullptr) const;
 
-    bool createTokens(std::istream &code, const std::string& FileName);
-    void createTokens(const simplecpp::TokenList *tokenList);
+    bool simplifyTokens1(const std::string &configuration, int fileIndex=0);
 
-    bool simplifyTokens1(const std::string &configuration);
-    /**
-     * Tokenize code
-     * @param code input stream for code, e.g.
-     * \code
-     * #file "p.h"
-     * class Foo
-     * {
-     * private:
-     * void Bar();
-     * };
-     *
-     * #endfile
-     * void Foo::Bar()
-     * {
-     * }
-     * \endcode
-     *
-     * @param FileName The filename
-     * @param configuration E.g. "A" for code where "#ifdef A" is true
-     * @return false if source code contains syntax errors
-     */
-    bool tokenize(std::istream &code,
-                  const char FileName[],
-                  const std::string &configuration = emptyString);
+    bool isVarUsedInTemplate(nonneg int id) const {
+        return mTemplateVarIdUsage.count(id) != 0;
+    }
 
+private:
     /** Set variable id */
     void setVarId();
     void setVarIdPass1();
     void setVarIdPass2();
 
     /**
-    * Basic simplification of tokenlist
-    *
-    * @param FileName The filename to run; used to do
-    * markup checks.
-    *
-    * @return false if there is an error that requires aborting
-    * the checking of this file.
-    */
+     * Basic simplification of tokenlist
+     *
+     * @param FileName The filename to run; used to do
+     * markup checks.
+     *
+     * @return false if there is an error that requires aborting
+     * the checking of this file.
+     */
     bool simplifyTokenList1(const char FileName[]);
 
-    void SimplifyNamelessRValueReferences();
-
-    /**
-    * Most aggressive simplification of tokenlist
-    *
-    * @return false if there is an error that requires aborting
-    * the checking of this file.
-    */
-    bool simplifyTokenList2();
-
     /**
      * If --check-headers=no has been given; then remove unneeded code in headers.
      * - All executable code.
      * - Unused types/variables/etc
      */
-    void simplifyHeaders();
+    void simplifyHeadersAndUnusedTemplates();
 
     /**
-     * Deletes dead code between 'begin' and 'end'.
-     * In general not everything can be erased, such as:
-     * - code after labels;
-     * - code outside the scope where the function is called;
-     * - code after a change of scope caused by 'switch(...);'
-     *   instructions, like 'case %any%;' or 'default;'
-     * Also, if the dead code contains a 'switch' block
-     * and inside it there's a label, the function removes all
-     * the 'switch(..)' tokens and every occurrence of 'case %any%; | default;'
-     * expression, such as the 'switch' block is reduced to a simple block.
-     *
-     * @param begin Tokens after this have a possibility to be erased.
-     * @param end Tokens before this have a possibility to be erased.
+     * Remove extra "template" keywords that are not used by Cppcheck
      */
-    static void eraseDeadCode(Token *begin, const Token *end);
+    void removeExtraTemplateKeywords();
 
-    /**
-     * Simplify '* & ( %name% ) =' or any combination of '* &' and '()'
-     * parentheses around '%name%' to '%name% ='
+
+protected:
+    /** Split up template right angle brackets.
+     * foo < bar < >> => foo < bar < > >
      */
-    void simplifyMulAndParens();
+    void splitTemplateRightAngleBrackets(bool check);
 
+public:
     /**
      * Calculates sizeof value for given type.
      * @param type Token which will contain e.g. "int", "*", or string.
      * @return sizeof for given type, or 0 if it can't be calculated.
      */
-    nonneg int sizeOfType(const Token *type) const;
-
-    /**
-     * Try to determine if function parameter is passed by value by looking
-     * at the function declaration.
-     * @param fpar token for function parameter in the function call
-     * @return true if the parameter is passed by value. if unsure, false is returned
-     */
-    bool isFunctionParameterPassedByValue(const Token *fpar) const;
+    nonneg int sizeOfType(const Token* type) const;
+    nonneg int sizeOfType(const std::string& type) const;
 
-    /** Simplify assignment in function call "f(x=g());" => "x=g();f(x);"
-     */
-    void simplifyAssignmentInFunctionCall();
+private:
+    void simplifyDebug();
 
     /** Simplify assignment where rhs is a block : "x=({123;});" => "{x=123;}" */
     void simplifyAssignmentBlock();
 
-    /**
-     * Simplify constant calculations such as "1+2" => "3"
-     * @return true if modifications to token-list are done.
-     *         false if no modifications are done.
-     */
-    bool simplifyCalculations();
-
-    /**
-     * Simplify dereferencing a pointer offset by a number:
-     *     "*(ptr + num)" => "ptr[num]"
-     *     "*(ptr - num)" => "ptr[-num]"
-     */
-    void simplifyOffsetPointerDereference();
-
-    /**
-       * Simplify referencing a pointer offset:
-       *     "Replace "&str[num]" => "(str + num)"
-       */
-    void simplifyOffsetPointerReference();
-
     /** Insert array size where it isn't given */
     void arraySize();
+    void arraySizeAfterValueFlow();
 
     /** Simplify labels and 'case|default' syntaxes.
-      */
+     */
     void simplifyLabelsCaseDefault();
 
     /** simplify case ranges (gcc extension)
-      */
+     */
     void simplifyCaseRange();
 
     /** Remove macros in global scope */
     void removeMacrosInGlobalScope();
 
-    /** Remove undefined macro in class definition:
-      * class DLLEXPORT Fred { };
-      * class Fred FINAL : Base { };
-      */
-    void removeMacroInClassDef();
-
-    /** Remove unknown macro in variable declarations: PROGMEM char x; */
-    void removeMacroInVarDecl();
+    void addSemicolonAfterUnknownMacro();
 
-    /** Remove redundant assignment */
-    void removeRedundantAssignment();
+    // Remove C99 and CPP11 _Pragma(str)
+    void removePragma();
 
-    /** Simplifies some realloc usage like
-      * 'x = realloc (0, n);' => 'x = malloc(n);'
-      * 'x = realloc (y, 0);' => 'x = 0; free(y);'
-      */
-    void simplifyRealloc();
+    /** Remove undefined macro in class definition:
+     * class DLLEXPORT Fred { };
+     * class Fred FINAL : Base { };
+     */
+    void removeMacroInClassDef();
 
     /** Add parentheses for sizeof: sizeof x => sizeof(x) */
     void sizeofAddParentheses();
 
-    /**
-     * Replace sizeof() to appropriate size.
-     * @return true if modifications to token-list are done.
-     *         false if no modifications are done.
-     */
-    bool simplifySizeof();
-
     /**
      * Simplify variable declarations (split up)
      * \param only_k_r_fpar Only simplify K&R function parameters
      */
-    void simplifyVarDecl(const bool only_k_r_fpar);
-    void simplifyVarDecl(Token * tokBegin, const Token * const tokEnd, const bool only_k_r_fpar);
+    void simplifyVarDecl( bool only_k_r_fpar);
+    void simplifyVarDecl(Token * tokBegin, const Token * tokEnd, bool only_k_r_fpar);
 
     /**
      * Simplify variable initialization
      * '; int *p(0);' => '; int *p = 0;'
      */
     void simplifyInitVar();
-    Token * initVar(Token * tok);
-
-    /**
-     * Simplify easy constant '?:' operation
-     * Example: 0 ? (2/0) : 0 => 0
-     * @return true if something is modified
-     *         false if nothing is done.
-     */
-    bool simplifyConstTernaryOp();
-
-    /**
-     * Simplify compound assignments
-     * Example: ";a+=b;" => ";a=a+b;"
-     */
-    void simplifyCompoundAssignment();
+    RET_NONNULL static Token* initVar(Token* tok);
 
     /**
      * Simplify the location of "static" and "const" qualifiers in
@@ -314,20 +183,13 @@ class CPPCHECKLIB Tokenizer {
      */
     void simplifyStaticConst();
 
-    /**
-     * Simplify assignments in "if" and "while" conditions
-     * Example: "if(a=b);" => "a=b;if(a);"
-     * Example: "while(a=b) { f(a); }" => "a = b; while(a){ f(a); a = b; }"
-     * Example: "do { f(a); } while(a=b);" => "do { f(a); a = b; } while(a);"
-     */
-    void simplifyIfAndWhileAssign();
-
     /**
      * Simplify multiple assignments.
      * Example: "a = b = c = 0;" => "a = 0; b = 0; c = 0;"
      */
     void simplifyVariableMultipleAssign();
 
+protected:
     /**
      * Simplify the 'C Alternative Tokens'
      * Examples:
@@ -337,14 +199,7 @@ class CPPCHECKLIB Tokenizer {
      */
     bool simplifyCAlternativeTokens();
 
-    /**
-     * Simplify comma into a semicolon when possible:
-     * - "delete a, delete b" => "delete a; delete b;"
-     * - "a = 0, b = 0;" => "a = 0; b = 0;"
-     * - "return a(), b;" => "a(); return b;"
-     */
-    void simplifyComma();
-
+private:
     /** Add braces to an if-block, for-block, etc.
      * @return true if no syntax errors
      */
@@ -374,88 +229,40 @@ class CPPCHECKLIB Tokenizer {
      * typedef A mytype;
      * A c;
      */
+protected:
     void simplifyTypedef();
-
-    /**
-     */
-    bool simplifyUsing();
-
-    /**
-     * Simplify casts
-     */
-    void simplifyCasts();
-
-    /**
-     * Change (multiple) arrays to (multiple) pointers.
-     */
-    void simplifyUndefinedSizeArray();
-
+private:
+    void simplifyTypedefCpp();
     /**
-     * A simplify function that replaces a variable with its value in cases
-     * when the value is known. e.g. "x=10; if(x)" => "x=10;if(10)"
-     *
-     * @return true if modifications to token-list are done.
-     *         false if no modifications are done.
+     * Move typedef token to the left og the expression
      */
-    bool simplifyKnownVariables();
+    void simplifyTypedefLHS();
 
     /**
-     * Utility function for simplifyKnownVariables. Get data about an
-     * assigned variable.
      */
-    static bool simplifyKnownVariablesGetData(nonneg int varid, Token **_tok2, Token **_tok3, std::string &value, nonneg int &valueVarId, bool &valueIsPointer, bool floatvar);
+    static bool isMemberFunction(const Token *openParen);
 
     /**
-     * utility function for simplifyKnownVariables. Perform simplification
-     * of a given variable
      */
-    bool simplifyKnownVariablesSimplify(Token **tok2, Token *tok3, nonneg int varid, const std::string &structname, std::string &value, nonneg int valueVarId, bool valueIsPointer, const Token * const valueToken, int indentlevel) const;
+public:
+    bool simplifyUsing();
+private:
+    void simplifyUsingError(const Token* usingStart, const Token* usingEnd);
 
     /** Simplify useless C++ empty namespaces, like: 'namespace %name% { }'*/
     void simplifyEmptyNamespaces();
 
-    /** Simplify redundant code placed after control flow statements :
-     * 'return', 'throw', 'goto', 'break' and 'continue'
-     */
-    void simplifyFlowControl();
-
-    /** Expand nested strcat() calls. */
-    void simplifyNestedStrcat();
-
     /** Simplify "if else" */
     void elseif();
 
-    /** Simplify conditions
-     * @return true if something is modified
-     *         false if nothing is done.
-     */
-    bool simplifyConditions();
-
-    /** Remove redundant code, e.g. if( false ) { int a; } should be
-     * removed, because it is never executed.
-     * @return true if something is modified
-     *         false if nothing is done.
-     */
-    bool removeRedundantConditions();
-
-    /**
-     * Remove redundant for:
-     * "for (x=0;x<1;x++) { }" => "{ x = 1; }"
-     */
-    void removeRedundantFor();
-
+    /** Simplify C++17/C++20 if/switch/for initialization expression */
+    void simplifyIfSwitchForInit();
 
     /**
      * Reduces "; ;" to ";", except in "( ; ; )"
      */
     void removeRedundantSemicolons();
 
-    /** Simplify function calls - constant return value
-     * @return true if something is modified
-     *         false if nothing is done.
-     */
-    bool simplifyFunctionReturn();
-
     /** Struct simplification
      * "struct S { } s;" => "struct S { }; S s;"
      */
@@ -473,17 +280,18 @@ class CPPCHECKLIB Tokenizer {
      */
     bool simplifyRedundantParentheses();
 
-    void simplifyCharAt();
-
-    /** Simplify references */
-    void simplifyReference();
-
     /**
      * Simplify functions like "void f(x) int x; {"
      * into "void f(int x) {"
      */
     void simplifyFunctionParameters();
 
+    /** Simplify function level try blocks:
+     *  Convert "void f() try {} catch (int) {}"
+     *  to "void f() { try {} catch (int) {} }"
+     */
+    void simplifyFunctionTryCatch();
+
     /**
      * Simplify templates
      */
@@ -499,34 +307,29 @@ class CPPCHECKLIB Tokenizer {
 
     void fillTypeSizes();
 
+protected:
     void combineOperators();
 
     void combineStringAndCharLiterals();
 
+private:
     void concatenateNegativeNumberAndAnyPositive();
 
     void simplifyExternC();
 
-    void simplifyRoundCurlyParentheses();
+    void simplifyCompoundStatements();
 
     void simplifyTypeIntrinsics();
 
     void simplifySQL();
 
+    void simplifyParenthesizedLibraryFunctions();
+
     void checkForEnumsWithTypedef();
 
     void findComplicatedSyntaxErrorsInTemplates();
 
-    /**
-     * Simplify e.g. 'atol("0")' into '0'
-     */
-    void simplifyMathFunctions();
-
-    /**
-     * Simplify e.g. 'sin(0)' into '0'
-     */
-    void simplifyMathExpressions();
-
+protected:
     /**
      * Modify strings in the token list by replacing hex and oct
      * values. E.g. "\x61" -> "a" and "\000" -> "\0"
@@ -535,45 +338,13 @@ class CPPCHECKLIB Tokenizer {
      */
     static std::string simplifyString(const std::string &source);
 
-    /**
-     * is token pointing at function head?
-     * @param tok         A '(' or ')' token in a possible function head
-     * @param endsWith    string after function head
-     * @return token matching with endsWith if syntax seems to be a function head else nullptr
-     */
-    const Token * isFunctionHead(const Token *tok, const std::string &endsWith) const;
+public:
+    bool hasIfdef(const Token *start, const Token *end) const;
 
-    /**
-     * is token pointing at function head?
-     * @param tok         A '(' or ')' token in a possible function head
-     * @param endsWith    string after function head
-     * @param cpp         c++ code
-     * @return token matching with endsWith if syntax seems to be a function head else nullptr
-     */
-    static const Token * isFunctionHead(const Token *tok, const std::string &endsWith, bool cpp);
+    bool isPacked(const Token * bodyStart) const;
 
 private:
 
-    /**
-     * simplify "while (0)"
-     */
-    void simplifyWhile0();
-
-    /**
-     * Simplify while(func() && errno==EINTR)
-     */
-    void simplifyErrNoInWhile();
-
-    /**
-     * Simplify while(func(f))
-     */
-    void simplifyFuncInWhile();
-
-    /**
-     * Remove "std::" before some function names
-     */
-    void simplifyStd();
-
     /** Simplify pointer to standard type (C only) */
     void simplifyPointerToStandardType();
 
@@ -584,8 +355,9 @@ class CPPCHECKLIB Tokenizer {
      * Send error message to error logger about internal bug.
      * @param tok the token that this bug concerns.
      */
-    void cppcheckError(const Token *tok) const;
+    NORETURN void cppcheckError(const Token *tok) const;
 
+protected:
     /**
      * Setup links for tokens so that one can call Token::link().
      */
@@ -596,40 +368,58 @@ class CPPCHECKLIB Tokenizer {
      */
     void createLinks2();
 
+private:
+    /**
+     * Set isCast() for C++ casts
+     */
+    void markCppCasts();
+
 public:
 
-    /** Syntax error */
-    void syntaxError(const Token *tok, const std::string &code = "") const;
+    /** Syntax error
+     * @throws InternalError thrown unconditionally
+     */
+    NORETURN void syntaxError(const Token *tok, const std::string &code = "") const;
 
-    /** Syntax error. Unmatched character. */
-    void unmatchedToken(const Token *tok) const;
+    /** Syntax error. Unmatched character.
+     * @throws InternalError thrown unconditionally
+     */
+    NORETURN void unmatchedToken(const Token *tok) const;
 
-    /** Syntax error. C++ code in C file. */
-    void syntaxErrorC(const Token *tok, const std::string &what) const;
+private:
+    /** Syntax error. C++ code in C file.
+     * @throws InternalError thrown unconditionally
+     */
+    NORETURN void syntaxErrorC(const Token *tok, const std::string &what) const;
 
-    /** Warn about unknown macro(s), configuration is recommended */
-    void unknownMacroError(const Token *tok1) const;
+    /** Warn about unknown macro(s), configuration is recommended
+     * @throws InternalError thrown unconditionally
+     */
+    NORETURN void unknownMacroError(const Token *tok1) const;
 
-private:
+    void unhandledCharLiteral(const Token *tok, const std::string& msg) const;
 
     /** Report that there is an unhandled "class x y {" code */
-    void unhandled_macro_class_x_y(const Token *tok) const;
+    void unhandled_macro_class_x_y(const Token *tok, const std::string& type, const std::string& x, const std::string& y, const std::string& bracket) const;
 
-    /** Check configuration (unknown macros etc) */
-    void checkConfiguration() const;
-    void macroWithSemicolonError(const Token *tok, const std::string &macroName) const;
+    void invalidConstFunctionTypeError(const Token *tok) const;
 
     /**
      * Is there C++ code in C file?
      */
     void validateC() const;
 
+protected:
     /**
      * assert that tokens are ok - used during debugging for example
      * to catch problems in simplifyTokenList1/2.
      */
     void validate() const;
 
+private:
+    /** Detect unknown macros and throw unknownMacro */
+    void reportUnknownMacros() const;
+
     /** Detect garbage code and call syntaxError() if found. */
     void findGarbageCode() const;
 
@@ -651,11 +441,19 @@ class CPPCHECKLIB Tokenizer {
      */
     void simplifyAttribute();
 
+    /** Get function token for a attribute */
+    Token* getAttributeFuncTok(Token* tok, bool gccattr) const;
+
     /**
      * Remove \__cppcheck\__ ((?))
      */
     void simplifyCppcheckAttribute();
 
+protected:
+    /** Simplify c++20 spaceship operator */
+    void simplifySpaceshipOperator();
+
+private:
     /**
      * Remove keywords "volatile", "inline", "register", and "restrict"
      */
@@ -692,29 +490,24 @@ class CPPCHECKLIB Tokenizer {
     void simplifyNamespaceStd();
 
     /**
-    * Convert Microsoft memory functions
-    * CopyMemory(dst, src, len) -> memcpy(dst, src, len)
-    * FillMemory(dst, len, val) -> memset(dst, val, len)
-    * MoveMemory(dst, src, len) -> memmove(dst, src, len)
-    * ZeroMemory(dst, len) -> memset(dst, 0, len)
-    */
+     * Convert Microsoft memory functions
+     * CopyMemory(dst, src, len) -> memcpy(dst, src, len)
+     * FillMemory(dst, len, val) -> memset(dst, val, len)
+     * MoveMemory(dst, src, len) -> memmove(dst, src, len)
+     * ZeroMemory(dst, len) -> memset(dst, 0, len)
+     */
     void simplifyMicrosoftMemoryFunctions();
 
     /**
-    * Convert Microsoft string functions
-    * _tcscpy -> strcpy
-    */
+     * Convert Microsoft string functions
+     * _tcscpy -> strcpy
+     */
     void simplifyMicrosoftStringFunctions();
 
     /**
-      * Remove Borland code
-      */
-    void simplifyBorland();
-
-    /**
-     * Remove Qt signals and slots
+     * Remove Borland code
      */
-    void simplifyQtSignalsSlots();
+    void simplifyBorland();
 
     /**
      * Collapse operator name tokens into single token
@@ -722,16 +515,13 @@ class CPPCHECKLIB Tokenizer {
      */
     void simplifyOperatorName();
 
-    /**
-    * Remove [[attribute]] (C++11 and later) from TokenList
-    */
-    void simplifyCPPAttribute();
+    /** simplify overloaded operators: 'obj(123)' => 'obj . operator() ( 123 )' */
+    void simplifyOverloadedOperators();
 
     /**
-     * Replace strlen(str)
-     * @return true if any replacement took place, false else
-     * */
-    bool simplifyStrlen();
+     * Remove [[attribute]] (C++11, C23) from TokenList
+     */
+    void simplifyCPPAttribute();
 
     /**
      * Convert namespace aliases
@@ -744,85 +534,57 @@ class CPPCHECKLIB Tokenizer {
     void simplifyNestedNamespace();
 
     /**
-    * Prepare ternary operators with parentheses so that the AST can be created
-    * */
-    void prepareTernaryOpForAST();
+     * Simplify coroutines - just put parentheses around arguments for
+     * co_* keywords so they can be handled like function calls in data
+     * flow.
+     */
+    void simplifyCoroutines();
 
+protected:
     /**
-     * check for duplicate enum definition
-     */
-    static bool duplicateDefinition(Token **tokPtr);
+     * Prepare ternary operators with parentheses so that the AST can be created
+     * */
+    void prepareTernaryOpForAST();
 
+private:
     /**
      * report error message
      */
-    void reportError(const Token* tok, const Severity::SeverityType severity, const std::string& id, const std::string& msg, bool inconclusive = false) const;
-    void reportError(const std::list<const Token*>& callstack, Severity::SeverityType severity, const std::string& id, const std::string& msg, bool inconclusive = false) const;
+    void reportError(const Token* tok, Severity severity, const std::string& id, const std::string& msg, bool inconclusive = false) const;
+    void reportError(const std::list<const Token*>& callstack, Severity severity, const std::string& id, const std::string& msg, bool inconclusive = false) const;
 
-    bool duplicateTypedef(Token **tokPtr, const Token *name, const Token *typeDef) const;
+    bool duplicateTypedef(Token *&tokPtr, const Token *name, const Token *typeDef) const;
 
     void unsupportedTypedef(const Token *tok) const;
 
-    void setVarIdClassDeclaration(const Token * const startToken,
-                                  const VariableMap &variableMap,
-                                  const nonneg int scopeStartVarId,
-                                  std::map<int, std::map<std::string,int> >& structMembers);
-
-    void setVarIdStructMembers(Token **tok1,
-                               std::map<int, std::map<std::string, int> >& structMembers,
-                               nonneg int *varId);
-
-    void setVarIdClassFunction(const std::string &classname,
-                               Token * const startToken,
-                               const Token * const endToken,
-                               const std::map<std::string,int> &varlist,
-                               std::map<int, std::map<std::string,int> >& structMembers,
-                               nonneg int *varId_);
-
-    /**
-     * Simplify e.g. 'return(strncat(temp,"a",1));' into
-     * strncat(temp,"a",1); return temp;
-     */
-    void simplifyReturnStrncat();
-
-    /**
-     * Output list of unknown types.
-     */
-    void printUnknownTypes() const;
+    static void setVarIdClassFunction(const std::string &classname,
+                                      Token * startToken,
+                                      const Token * endToken,
+                                      const std::map<std::string, nonneg int> &varlist,
+                                      std::map<nonneg int, std::map<std::string, nonneg int>>& structMembers,
+                                      nonneg int &varId_);
 
     /** Find end of SQL (or PL/SQL) block */
     static const Token *findSQLBlockEnd(const Token *tokSQLStart);
 
-public:
-
-    /** Was there templates in the code? */
-    bool codeWithTemplates() const {
-        return mCodeWithTemplates;
-    }
-
-
-    void setSettings(const Settings *settings) {
-        mSettings = settings;
-        list.setSettings(settings);
-    }
+    static bool operatorEnd(const Token * tok);
 
+public:
     const SymbolDatabase *getSymbolDatabase() const {
         return mSymbolDatabase;
     }
     void createSymbolDatabase();
-    void deleteSymbolDatabase();
 
     /** print --debug output if debug flags match the simplification:
-     * 0=unknown/both simplifications
-     * 1=1st simplifications
-     * 2=2nd simplifications
      */
-    void printDebugOutput(int simplification) const;
+    void printDebugOutput(std::ostream &out) const;
 
     void dump(std::ostream &out) const;
 
+private:
     Token *deleteInvalidTypedef(Token *typeDef);
 
+public:
     /**
      * Get variable count.
      * @return number of variables
@@ -840,46 +602,38 @@ class CPPCHECKLIB Tokenizer {
         return list.front();
     }
 
-    /**
-    * Helper function to check whether number is zero (0 or 0.0 or 0E+0) or not?
-    * @param s the string to check
-    * @return true in case is is zero and false otherwise.
-    */
-    static bool isZeroNumber(const std::string &s);
+    Token* tokens() {
+        return list.front();
+    }
 
     /**
-    * Helper function to check whether number is one (1 or 0.1E+1 or 1E+0) or not?
-    * @param s the string to check
-    * @return true in case is is one and false otherwise.
-    */
+     * Helper function to check whether number is one (1 or 0.1E+1 or 1E+0) or not?
+     * @param s the string to check
+     * @return true in case it is one and false otherwise.
+     */
     static bool isOneNumber(const std::string &s);
 
     /**
-    * Helper function to check whether number is two (2 or 0.2E+1 or 2E+0) or not?
-    * @param s the string to check
-    * @return true in case is is two and false otherwise.
-    */
-    static bool isTwoNumber(const std::string &s);
+     * Helper function to check for start of function execution scope.
+     * Do not use this in checks.  Use the symbol database.
+     * @param tok pointer to end parentheses of parameter list
+     * @return pointer to start brace of function scope or nullptr if not start.
+     */
+    static const Token * startOfExecutableScope(const Token * tok);
 
     /**
-    * Helper function to check for start of function execution scope.
-    * Do not use this in checks.  Use the symbol database.
-    * @param tok pointer to end parentheses of parameter list
-    * @return pointer to start brace of function scope or nullptr if not start.
-    */
-    static const Token * startOfExecutableScope(const Token * tok);
+     * Helper function to check whether tok is the declaration of a function pointer
+     * @param tok the Token to check
+     * @return true in case tok is a function pointer and false otherwise.
+     */
+    static bool isFunctionPointer(const Token* tok);
 
-#ifdef MAXTIME
-    bool isMaxTime() const {
-        return (std::time(0) > mMaxTime);
-#else
-    static bool isMaxTime() {
-        return false;
-#endif
+    const Settings &getSettings() const {
+        return mSettings;
     }
 
-    const Settings *getSettings() const {
-        return mSettings;
+    ErrorLogger &getErrorLogger() {
+        return mErrorLogger;
     }
 
     void calculateScopes();
@@ -890,13 +644,19 @@ class CPPCHECKLIB Tokenizer {
     /** Disable assignment operator */
     Tokenizer &operator=(const Tokenizer &) = delete;
 
+    void setDirectives(std::list<Directive> directives);
+
+    std::string dumpTypedefInfo() const;
+
+    static void getErrorMessages(ErrorLogger& errorLogger, const Settings& settings);
 private:
-    Token *processFunc(Token *tok2, bool inOperator) const;
+    const Token *processFunc(const Token *tok2, bool inOperator) const;
+    Token *processFunc(Token *tok2, bool inOperator);
 
     /**
-    * Get new variable id.
-    * @return new variable id
-    */
+     * Get new variable id.
+     * @return new variable id
+     */
     nonneg int newVarId() {
         return ++mVarId;
     }
@@ -905,15 +665,19 @@ class CPPCHECKLIB Tokenizer {
     void setPodTypes();
 
     /** settings */
-    const Settings * mSettings;
+    const Settings & mSettings;
 
     /** errorlogger */
-    ErrorLogger* const mErrorLogger;
+    ErrorLogger& mErrorLogger;
 
     /** Symbol database that all checks etc can use */
-    SymbolDatabase *mSymbolDatabase;
+    SymbolDatabase* mSymbolDatabase{};
+
+protected:
+    TemplateSimplifier * const mTemplateSimplifier;
 
-    TemplateSimplifier *mTemplateSimplifier;
+private:
+    std::set<nonneg int> mTemplateVarIdUsage;
 
     /** E.g. "A" for code where "#ifdef A" is true. This is used to
         print additional information in error situations. */
@@ -922,27 +686,36 @@ class CPPCHECKLIB Tokenizer {
     /** sizeof information for known types */
     std::map<std::string, int> mTypeSize;
 
+    struct TypedefToken {
+        std::string name;
+        int lineNumber;
+        int column;
+    };
+    struct TypedefInfo {
+        std::string name;
+        std::string filename;
+        int lineNumber;
+        int column;
+        int tagLine{-1};
+        int tagColumn{-1};
+        bool used;
+        bool isFunctionPointer;
+        std::vector<TypedefToken> typedefInfoTokens;
+    };
+    std::vector<TypedefInfo> mTypedefInfo;
+
+    std::list<Directive> mDirectives;
+
     /** variable count */
-    nonneg int mVarId;
+    nonneg int mVarId{};
 
     /** unnamed count "Unnamed0", "Unnamed1", "Unnamed2", ... */
-    nonneg int mUnnamedCount;
+    nonneg int mUnnamedCount{};
 
     /**
-     * was there any templates? templates that are "unused" are
-     * removed from the token list
+     * timer results
      */
-    bool mCodeWithTemplates;
-
-    /**
-     * TimerResults
-     */
-    TimerResults *mTimerResults;
-
-#ifdef MAXTIME
-    /** Tokenizer maxtime */
-    const std::time_t mMaxTime;
-#endif
+    TimerResultsIntf* mTimerResults{};
 };
 
 /// @}
diff --git a/lib/tokenlist.cpp b/lib/tokenlist.cpp
index 48b9122187b..55ca98c628c 100644
--- a/lib/tokenlist.cpp
+++ b/lib/tokenlist.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,32 +17,47 @@
  */
 
 //---------------------------------------------------------------------------
+
 #include "tokenlist.h"
 
+#include "astutils.h"
 #include "errorlogger.h"
-#include "mathlib.h"
+#include "errortypes.h"
+#include "keywords.h"
+#include "library.h"
 #include "path.h"
+#include "platform.h"
 #include "settings.h"
+#include "standards.h"
 #include "token.h"
 
-#include <simplecpp.h>
+#include <algorithm>
+#include <cassert>
 #include <cctype>
-#include <cstring>
+#include <cstdint>
+#include <exception>
+#include <functional>
+#include <iostream>
+#include <iterator>
+#include <utility>
 #include <set>
 #include <stack>
+#include <unordered_set>
+
+#include <simplecpp.h>
 
 // How many compileExpression recursions are allowed?
 // For practical code this could be endless. But in some special torture test
 // there needs to be a limit.
-static const int AST_MAX_DEPTH = 50;
+static constexpr int AST_MAX_DEPTH = 150;
 
 
-TokenList::TokenList(const Settings* settings) :
-    mTokensFrontBack(),
-    mSettings(settings),
-    mIsC(false),
-    mIsCpp(false)
+TokenList::TokenList(const Settings& settings, Standards::Language lang)
+    : mTokensFrontBack(new TokensFrontBack)
+    , mSettings(settings)
 {
+    assert(lang != Standards::Language::None);
+    mLang = lang;
 }
 
 TokenList::~TokenList()
@@ -55,7 +70,8 @@ TokenList::~TokenList()
 const std::string& TokenList::getSourceFilePath() const
 {
     if (getFiles().empty()) {
-        return emptyString;
+        static const std::string s_empty_string;
+        return s_empty_string;
     }
     return getFiles()[0];
 }
@@ -65,35 +81,40 @@ const std::string& TokenList::getSourceFilePath() const
 // Deallocate lists..
 void TokenList::deallocateTokens()
 {
-    deleteTokens(mTokensFrontBack.front);
-    mTokensFrontBack.front = nullptr;
-    mTokensFrontBack.back = nullptr;
+    if (mTokensFrontBack) {
+        deleteTokens(mTokensFrontBack->front);
+        mTokensFrontBack->front = nullptr;
+        mTokensFrontBack->back = nullptr;
+    }
+    // TODO: clear mOrigFiles?
     mFiles.clear();
 }
 
-int TokenList::appendFileIfNew(const std::string &fileName)
+// TODO: also update mOrigFiles?
+int TokenList::appendFileIfNew(std::string fileName)
 {
+    assert(!fileName.empty());
+
     // Has this file been tokenized already?
-    for (int i = 0; i < mFiles.size(); ++i)
-        if (Path::sameFileName(mFiles[i], fileName))
-            return i;
+    auto it = std::find_if(mFiles.cbegin(), mFiles.cend(), [&](const std::string& f) {
+        return Path::sameFileName(f, fileName);
+    });
+    if (it != mFiles.cend())
+        return static_cast<int>(std::distance(mFiles.cbegin(), it));
+
+    assert(mTokensFrontBack->front == nullptr); // has no effect if tokens have already been created
 
     // The "mFiles" vector remembers what files have been tokenized..
-    mFiles.push_back(fileName);
+    mFiles.push_back(std::move(fileName));
 
-    // Update mIsC and mIsCpp properties
-    if (mFiles.size() == 1) { // Update only useful if first file added to _files
-        if (!mSettings) {
-            mIsC = Path::isC(getSourceFilePath());
-            mIsCpp = Path::isCPP(getSourceFilePath());
-        } else {
-            mIsC = mSettings->enforcedLang == Settings::C || (mSettings->enforcedLang == Settings::None && Path::isC(getSourceFilePath()));
-            mIsCpp = mSettings->enforcedLang == Settings::CPP || (mSettings->enforcedLang == Settings::None && Path::isCPP(getSourceFilePath()));
-        }
-    }
     return mFiles.size() - 1;
 }
 
+void TokenList::clangSetOrigFiles()
+{
+    mOrigFiles = mFiles;
+}
+
 void TokenList::deleteTokens(Token *tok)
 {
     while (tok) {
@@ -107,7 +128,7 @@ void TokenList::deleteTokens(Token *tok)
 // add a token.
 //---------------------------------------------------------------------------
 
-void TokenList::addtoken(std::string str, const nonneg int lineno, const nonneg int fileno, bool split)
+void TokenList::addtoken(const std::string& str, const nonneg int lineno, const nonneg int column, const nonneg int fileno, bool split)
 {
     if (str.empty())
         return;
@@ -118,95 +139,66 @@ void TokenList::addtoken(std::string str, const nonneg int lineno, const nonneg
         size_t end = 0;
         while ((end = str.find("##", begin)) != std::string::npos) {
             addtoken(str.substr(begin, end - begin), lineno, fileno, false);
-            addtoken("##", lineno, fileno, false);
+            addtoken("##", lineno, column, fileno, false);
             begin = end+2;
         }
         if (begin != 0) {
-            addtoken(str.substr(begin), lineno, fileno, false);
+            addtoken(str.substr(begin), lineno, column, fileno, false);
             return;
         }
     }
 
-    // Replace hexadecimal value with decimal
-    const bool isHex = MathLib::isIntHex(str) ;
-    if (isHex || MathLib::isOct(str) || MathLib::isBin(str)) {
-        // TODO: It would be better if TokenList didn't simplify hexadecimal numbers
-        std::string suffix;
-        if (isHex &&
-            str.size() == (2 + mSettings->int_bit / 4) &&
-            (str[2] >= '8') &&  // includes A-F and a-f
-            MathLib::getSuffix(str).empty()
-           )
-            suffix = "U";
-        str = MathLib::value(str).str() + suffix;
-    }
-
-    if (mTokensFrontBack.back) {
-        mTokensFrontBack.back->insertToken(str);
+    if (mTokensFrontBack->back) {
+        mTokensFrontBack->back->insertToken(str);
     } else {
-        mTokensFrontBack.front = new Token(&mTokensFrontBack);
-        mTokensFrontBack.back = mTokensFrontBack.front;
-        mTokensFrontBack.back->str(str);
+        mTokensFrontBack->front = new Token(*this, mTokensFrontBack);
+        mTokensFrontBack->back = mTokensFrontBack->front;
+        mTokensFrontBack->back->str(str);
     }
 
-    if (isCPP() && str == "delete")
-        mTokensFrontBack.back->isKeyword(true);
-    mTokensFrontBack.back->linenr(lineno);
-    mTokensFrontBack.back->fileIndex(fileno);
+    mTokensFrontBack->back->linenr(lineno);
+    mTokensFrontBack->back->column(column);
+    mTokensFrontBack->back->fileIndex(fileno);
 }
 
-void TokenList::addtoken(std::string str, const Token *locationTok)
+void TokenList::addtoken(const std::string& str, const Token *locationTok)
 {
     if (str.empty())
         return;
 
-    // Replace hexadecimal value with decimal
-    const bool isHex = MathLib::isIntHex(str) ;
-    if (isHex || MathLib::isOct(str) || MathLib::isBin(str)) {
-        // TODO: It would be better if TokenList didn't simplify hexadecimal numbers
-        std::string suffix;
-        if (isHex &&
-            str.size() == (2 + mSettings->int_bit / 4) &&
-            (str[2] >= '8') &&  // includes A-F and a-f
-            MathLib::getSuffix(str).empty()
-           )
-            suffix = "U";
-        str = MathLib::value(str).str() + suffix;
-    }
-
-    if (mTokensFrontBack.back) {
-        mTokensFrontBack.back->insertToken(str);
+    if (mTokensFrontBack->back) {
+        mTokensFrontBack->back->insertToken(str);
     } else {
-        mTokensFrontBack.front = new Token(&mTokensFrontBack);
-        mTokensFrontBack.back = mTokensFrontBack.front;
-        mTokensFrontBack.back->str(str);
+        mTokensFrontBack->front = new Token(*this, mTokensFrontBack);
+        mTokensFrontBack->back = mTokensFrontBack->front;
+        mTokensFrontBack->back->str(str);
     }
 
-    if (isCPP() && str == "delete")
-        mTokensFrontBack.back->isKeyword(true);
-    mTokensFrontBack.back->linenr(locationTok->linenr());
-    mTokensFrontBack.back->column(locationTok->column());
-    mTokensFrontBack.back->fileIndex(locationTok->fileIndex());
+    mTokensFrontBack->back->linenr(locationTok->linenr());
+    mTokensFrontBack->back->column(locationTok->column());
+    mTokensFrontBack->back->fileIndex(locationTok->fileIndex());
 }
 
-void TokenList::addtoken(const Token * tok, const nonneg int lineno, const nonneg int fileno)
+void TokenList::addtoken(const Token * tok, const nonneg int lineno, const nonneg int column, const nonneg int fileno)
 {
     if (tok == nullptr)
         return;
 
-    if (mTokensFrontBack.back) {
-        mTokensFrontBack.back->insertToken(tok->str(), tok->originalName());
+    if (mTokensFrontBack->back) {
+        mTokensFrontBack->back->insertToken(tok->str(), tok->originalName());
     } else {
-        mTokensFrontBack.front = new Token(&mTokensFrontBack);
-        mTokensFrontBack.back = mTokensFrontBack.front;
-        mTokensFrontBack.back->str(tok->str());
+        mTokensFrontBack->front = new Token(*this, mTokensFrontBack);
+        mTokensFrontBack->back = mTokensFrontBack->front;
+        mTokensFrontBack->back->str(tok->str());
         if (!tok->originalName().empty())
-            mTokensFrontBack.back->originalName(tok->originalName());
+            mTokensFrontBack->back->originalName(tok->originalName());
     }
 
-    mTokensFrontBack.back->linenr(lineno);
-    mTokensFrontBack.back->fileIndex(fileno);
-    mTokensFrontBack.back->flags(tok->flags());
+    mTokensFrontBack->back->linenr(lineno);
+    mTokensFrontBack->back->column(column);
+    mTokensFrontBack->back->fileIndex(fileno);
+    mTokensFrontBack->back->flags(tok->flags());
+    mTokensFrontBack->back->tokType(tok->tokType());
 }
 
 void TokenList::addtoken(const Token *tok, const Token *locationTok)
@@ -214,20 +206,21 @@ void TokenList::addtoken(const Token *tok, const Token *locationTok)
     if (tok == nullptr || locationTok == nullptr)
         return;
 
-    if (mTokensFrontBack.back) {
-        mTokensFrontBack.back->insertToken(tok->str(), tok->originalName());
+    if (mTokensFrontBack->back) {
+        mTokensFrontBack->back->insertToken(tok->str(), tok->originalName());
     } else {
-        mTokensFrontBack.front = new Token(&mTokensFrontBack);
-        mTokensFrontBack.back = mTokensFrontBack.front;
-        mTokensFrontBack.back->str(tok->str());
+        mTokensFrontBack->front = new Token(*this, mTokensFrontBack);
+        mTokensFrontBack->back = mTokensFrontBack->front;
+        mTokensFrontBack->back->str(tok->str());
         if (!tok->originalName().empty())
-            mTokensFrontBack.back->originalName(tok->originalName());
+            mTokensFrontBack->back->originalName(tok->originalName());
     }
 
-    mTokensFrontBack.back->flags(tok->flags());
-    mTokensFrontBack.back->linenr(locationTok->linenr());
-    mTokensFrontBack.back->column(locationTok->column());
-    mTokensFrontBack.back->fileIndex(locationTok->fileIndex());
+    mTokensFrontBack->back->flags(tok->flags());
+    mTokensFrontBack->back->linenr(locationTok->linenr());
+    mTokensFrontBack->back->column(locationTok->column());
+    mTokensFrontBack->back->fileIndex(locationTok->fileIndex());
+    mTokensFrontBack->back->tokType(tok->tokType());
 }
 
 void TokenList::addtoken(const Token *tok)
@@ -235,20 +228,23 @@ void TokenList::addtoken(const Token *tok)
     if (tok == nullptr)
         return;
 
-    if (mTokensFrontBack.back) {
-        mTokensFrontBack.back->insertToken(tok->str(), tok->originalName());
+    if (mTokensFrontBack->back) {
+        mTokensFrontBack->back->insertToken(tok->str(), tok->originalName(), tok->getMacroName());
     } else {
-        mTokensFrontBack.front = new Token(&mTokensFrontBack);
-        mTokensFrontBack.back = mTokensFrontBack.front;
-        mTokensFrontBack.back->str(tok->str());
+        mTokensFrontBack->front = new Token(*this, mTokensFrontBack);
+        mTokensFrontBack->back = mTokensFrontBack->front;
+        mTokensFrontBack->back->str(tok->str());
         if (!tok->originalName().empty())
-            mTokensFrontBack.back->originalName(tok->originalName());
+            mTokensFrontBack->back->originalName(tok->originalName());
+        if (!tok->getMacroName().empty())
+            mTokensFrontBack->back->setMacroName(tok->getMacroName());
     }
 
-    mTokensFrontBack.back->flags(tok->flags());
-    mTokensFrontBack.back->linenr(tok->linenr());
-    mTokensFrontBack.back->column(tok->column());
-    mTokensFrontBack.back->fileIndex(tok->fileIndex());
+    mTokensFrontBack->back->flags(tok->flags());
+    mTokensFrontBack->back->linenr(tok->linenr());
+    mTokensFrontBack->back->column(tok->column());
+    mTokensFrontBack->back->fileIndex(tok->fileIndex());
+    mTokensFrontBack->back->tokType(tok->tokType());
 }
 
 
@@ -270,6 +266,7 @@ Token *TokenList::copyTokens(Token *dest, const Token *first, const Token *last,
         tok2->tokType(tok->tokType());
         tok2->flags(tok->flags());
         tok2->varId(tok->varId());
+        tok2->setTokenDebug(tok->getTokenDebug());
 
         // Check for links and fix them up
         if (Token::Match(tok2, "(|[|{"))
@@ -297,9 +294,12 @@ Token *TokenList::copyTokens(Token *dest, const Token *first, const Token *last,
 
 void TokenList::insertTokens(Token *dest, const Token *src, nonneg int n)
 {
+    // TODO: put the linking in a helper?
     std::stack<Token *> link;
 
     while (n > 0) {
+        if (!src)
+            throw InternalError(dest, std::string(__func__) + ": invalid source range", InternalError::INTERNAL);
         dest->insertToken(src->str(), src->originalName());
         dest = dest->next();
 
@@ -317,137 +317,134 @@ void TokenList::insertTokens(Token *dest, const Token *src, nonneg int n)
         dest->varId(src->varId());
         dest->tokType(src->tokType());
         dest->flags(src->flags());
+        if (!src->getMacroName().empty())
+            dest->setMacroName(src->getMacroName());
         src  = src->next();
         --n;
     }
 }
 
-//---------------------------------------------------------------------------
-// Tokenize - tokenizes a given file.
 //---------------------------------------------------------------------------
 
-bool TokenList::createTokens(std::istream &code, const std::string& file0)
+bool TokenList::createTokensFromBuffer(const char* data, size_t size)
 {
-    appendFileIfNew(file0);
+    return createTokensFromBufferInternal(data, size, mFiles.empty() ? "" : *mFiles.cbegin());
+}
+
+//---------------------------------------------------------------------------
 
+bool TokenList::createTokensFromBufferInternal(const char* data, size_t size, const std::string& file0)
+{
     simplecpp::OutputList outputList;
-    simplecpp::TokenList tokens(code, mFiles, file0, &outputList);
+    simplecpp::TokenList tokens({data, size}, mFiles, file0, &outputList);
 
-    createTokens(&tokens);
+    createTokens(std::move(tokens));
 
     return outputList.empty();
 }
 
 //---------------------------------------------------------------------------
 
-void TokenList::createTokens(const simplecpp::TokenList *tokenList)
+// NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
+void TokenList::createTokens(simplecpp::TokenList&& tokenList)
 {
-    if (tokenList->cfront())
-        mOrigFiles = mFiles = tokenList->cfront()->location.files;
-    else
-        mFiles.clear();
+    // TODO: what to do if the list has been filled already? clear mTokensFrontBack?
 
-    mIsC = mIsCpp = false;
-    if (!mFiles.empty()) {
-        mIsC = Path::isC(getSourceFilePath());
-        mIsCpp = Path::isCPP(getSourceFilePath());
+    // tokenList.cfront() might be NULL if the file contained nothing to tokenize so we need to check the files instead
+    if (!tokenList.getFiles().empty()) {
+        // this is a copy
+        // TODO: this points to mFiles when called from createTokens(std::istream &, const std::string&)
+        mOrigFiles = mFiles = tokenList.getFiles();
     }
-    if (mSettings && mSettings->enforcedLang != Settings::None) {
-        mIsC = (mSettings->enforcedLang == Settings::C);
-        mIsCpp = (mSettings->enforcedLang == Settings::CPP);
+    else {
+        // TODO: clear mOrigFiles?
+        mFiles.clear();
     }
 
-    for (const simplecpp::Token *tok = tokenList->cfront(); tok; tok = tok->next) {
+    for (const simplecpp::Token *tok = tokenList.cfront(); tok;) {
 
+        // TODO: move from TokenList
         std::string str = tok->str();
 
-        // Replace hexadecimal value with decimal
-        // TODO: Remove this
-        const bool isHex = MathLib::isIntHex(str) ;
-        if (isHex || MathLib::isOct(str) || MathLib::isBin(str)) {
-            // TODO: It would be better if TokenList didn't simplify hexadecimal numbers
-            std::string suffix;
-            if (isHex &&
-                mSettings &&
-                str.size() == (2 + mSettings->int_bit / 4) &&
-                (str[2] >= '8') &&  // includes A-F and a-f
-                MathLib::getSuffix(str).empty()
-               )
-                suffix = "U";
-            str = MathLib::value(str).str() + suffix;
-        }
-
         // Float literal
         if (str.size() > 1 && str[0] == '.' && std::isdigit(str[1]))
             str = '0' + str;
 
-        if (mTokensFrontBack.back) {
-            mTokensFrontBack.back->insertToken(str);
+        if (mTokensFrontBack->back) {
+            mTokensFrontBack->back->insertToken(str);
         } else {
-            mTokensFrontBack.front = new Token(&mTokensFrontBack);
-            mTokensFrontBack.back = mTokensFrontBack.front;
-            mTokensFrontBack.back->str(str);
+            mTokensFrontBack->front = new Token(*this, mTokensFrontBack);
+            mTokensFrontBack->back = mTokensFrontBack->front;
+            mTokensFrontBack->back->str(str);
         }
 
-        if (isCPP() && mTokensFrontBack.back->str() == "delete")
-            mTokensFrontBack.back->isKeyword(true);
-        mTokensFrontBack.back->fileIndex(tok->location.fileIndex);
-        mTokensFrontBack.back->linenr(tok->location.line);
-        mTokensFrontBack.back->column(tok->location.col);
-        mTokensFrontBack.back->isExpandedMacro(!tok->macro.empty());
+        mTokensFrontBack->back->fileIndex(tok->location.fileIndex);
+        mTokensFrontBack->back->linenr(tok->location.line);
+        mTokensFrontBack->back->column(tok->location.col);
+        if (!tok->macro.empty())
+            mTokensFrontBack->back->setMacroName(tok->macro);
+
+        tok = tok->next;
+        if (tok)
+            tokenList.deleteToken(tok->previous);
     }
 
-    if (mSettings && mSettings->relativePaths) {
+    if (mSettings.relativePaths) {
         for (std::string & mFile : mFiles)
-            mFile = Path::getRelativePath(mFile, mSettings->basePaths);
+            mFile = Path::getRelativePath(mFile, mSettings.basePaths);
     }
 
-    Token::assignProgressValues(mTokensFrontBack.front);
+    Token::assignProgressValues(mTokensFrontBack->front);
 }
 
 //---------------------------------------------------------------------------
 
-unsigned long long TokenList::calculateChecksum() const
+std::size_t TokenList::calculateHash() const
 {
-    unsigned long long checksum = 0;
+    std::string hashData;
     for (const Token* tok = front(); tok; tok = tok->next()) {
-        const unsigned int subchecksum1 = tok->flags() + tok->varId() + tok->tokType();
-        unsigned int subchecksum2 = 0;
-        for (char i : tok->str())
-            subchecksum2 += (unsigned int)i;
-        if (!tok->originalName().empty()) {
-            for (char i : tok->originalName())
-                subchecksum2 += (unsigned int) i;
-        }
-
-        checksum ^= ((static_cast<unsigned long long>(subchecksum1) << 32) | subchecksum2);
-
-        const bool bit1 = (checksum & 1) != 0;
-        checksum >>= 1;
-        if (bit1)
-            checksum |= (1ULL << 63);
+        hashData += std::to_string(tok->flags());
+        hashData += std::to_string(tok->varId());
+        hashData += std::to_string(tok->tokType());
+        hashData += tok->str();
+        hashData += tok->originalName();
     }
-    return checksum;
+    return (std::hash<std::string>{})(hashData);
 }
 
 
 //---------------------------------------------------------------------------
 
-struct AST_state {
-    std::stack<Token*> op;
-    int depth;
-    int inArrayAssignment;
-    bool cpp;
-    int assign;
-    bool inCase; // true from case to :
-    explicit AST_state(bool cpp) : depth(0), inArrayAssignment(0), cpp(cpp), assign(0), inCase(false) {}
-};
+namespace {
+    struct AST_state {
+        std::stack<Token*> op;
+        int depth{};
+        int inArrayAssignment{};
+        bool cpp;
+        int assign{};
+        bool inCase{}; // true from case to :
+        bool inGeneric{};
+        bool stopAtColon{}; // help to properly parse ternary operators
+        const Token* functionCallEndPar{};
+        explicit AST_state(bool cpp) : cpp(cpp) {}
+    };
+}
 
-static Token * skipDecl(Token *tok)
+static Token* skipDecl(Token* tok, std::vector<Token*>* inner = nullptr)
 {
+    auto isDecltypeFuncParam = [](const Token* tok) -> bool {
+        if (!Token::simpleMatch(tok, ")"))
+            return false;
+        tok = tok->next();
+        while (Token::Match(tok, "*|&|&&|const"))
+            tok = tok->next();
+        if (Token::simpleMatch(tok, "("))
+            tok = tok->link()->next();
+        return Token::Match(tok, "%name%| ,|)");
+    };
+
     if (!Token::Match(tok->previous(), "( %name%"))
         return tok;
-
     Token *vartok = tok;
     while (Token::Match(vartok, "%name%|*|&|::|<")) {
         if (vartok->str() == "<") {
@@ -455,15 +452,19 @@ static Token * skipDecl(Token *tok)
                 vartok = vartok->link();
             else
                 return tok;
-        } else if (Token::Match(vartok, "%name% [:=]")) {
+        } else if (Token::Match(vartok, "%var% [:=({]")) {
             return vartok;
+        } else if (Token::Match(vartok, "decltype|typeof (") && !isDecltypeFuncParam(tok->linkAt(1))) {
+            if (inner)
+                inner->push_back(vartok->tokAt(2));
+            return vartok->linkAt(1)->next();
         }
         vartok = vartok->next();
     }
     return tok;
 }
 
-static bool iscast(const Token *tok)
+static bool iscast(const Token *tok, bool cpp)
 {
     if (!Token::Match(tok, "( ::| %name%"))
         return false;
@@ -471,10 +472,14 @@ static bool iscast(const Token *tok)
     if (Token::simpleMatch(tok->link(), ") ( )"))
         return false;
 
-    if (tok->previous() && tok->previous()->isName() && tok->previous()->str() != "return")
+    if (Token::Match(tok->link(), ") %assign%|,|..."))
+        return false;
+
+    if (tok->previous() && tok->previous()->isName() && !Token::Match(tok->previous(), "return|case") &&
+        (!cpp || !Token::Match(tok->previous(), "delete|throw")))
         return false;
 
-    if (Token::simpleMatch(tok->previous(), ">") && tok->previous()->link())
+    if (Token::simpleMatch(tok->previous(), ">") && tok->linkAt(-1))
         return false;
 
     if (Token::Match(tok, "( (| typeof (") && Token::Match(tok->link(), ") %num%"))
@@ -483,7 +488,10 @@ static bool iscast(const Token *tok)
     if (Token::Match(tok->link(), ") }|)|]|;"))
         return false;
 
-    if (Token::Match(tok->link(), ") %cop%") && !Token::Match(tok->link(), ") [&*+-~]"))
+    if (Token::Match(tok->link(), ") ++|-- [;)]"))
+        return false;
+
+    if (Token::Match(tok->link(), ") %cop%") && !Token::Match(tok->link(), ") [&*+-~!]"))
         return false;
 
     if (Token::Match(tok->previous(), "= ( %name% ) {") && tok->next()->varId() == 0)
@@ -493,6 +501,8 @@ static bool iscast(const Token *tok)
     for (const Token *tok2 = tok->next(); tok2; tok2 = tok2->next()) {
         if (tok2->varId() != 0)
             return false;
+        if (cpp && !type && tok2->str() == "new")
+            return false;
 
         while (tok2->link() && Token::Match(tok2, "(|[|<"))
             tok2 = tok2->link()->next();
@@ -500,15 +510,26 @@ static bool iscast(const Token *tok)
         if (tok2->str() == ")") {
             if (Token::simpleMatch(tok2, ") (") && Token::simpleMatch(tok2->linkAt(1), ") ."))
                 return true;
-            return type || tok2->strAt(-1) == "*" || Token::simpleMatch(tok2, ") ~") ||
-                   (Token::Match(tok2, ") %any%") &&
-                    !tok2->next()->isOp() &&
-                    !Token::Match(tok2->next(), "[[]);,?:.]"));
+            if (Token::simpleMatch(tok2, ") {") && !type) {
+                const Token *tok3 = tok2->linkAt(1);
+                while (tok3 != tok2 && Token::Match(tok3, "[{}]"))
+                    tok3 = tok3->previous();
+                return tok3->str() != ";";
+            }
+            const bool res = type || tok2->strAt(-1) == "*" || Token::simpleMatch(tok2, ") ~") ||
+                             (Token::Match(tok2, ") %any%") &&
+                              (!tok2->next()->isOp() || Token::Match(tok2->next(), "!|~|++|--")) &&
+                              !Token::Match(tok2->next(), "[[]);,?:.]"));
+            return res;
         }
-        if (!Token::Match(tok2, "%name%|*|&|::"))
+
+        if (Token::Match(tok2, "&|&& )"))
+            return true;
+
+        if (!Token::Match(tok2, "%name%|*|::"))
             return false;
 
-        if (tok2->isStandardType() && (tok2->next()->str() != "(" || Token::Match(tok2->next(), "( * *| )")))
+        if (tok2->isStandardType() && (tok2->strAt(1) != "(" || Token::Match(tok2->next(), "( * *| )")))
             type = true;
     }
 
@@ -540,46 +561,92 @@ static Token * findCppTypeInitPar(Token *tok)
 }
 
 // X{} X<Y>{} etc
-static bool iscpp11init_impl(const Token * const tok);
+static bool iscpp11init_impl(const Token * tok);
 static bool iscpp11init(const Token * const tok)
 {
-    if (tok->isCpp11init() == TokenImpl::Cpp11init::UNKNOWN)
+    if (tok->isCpp11init() == Token::Cpp11init::UNKNOWN)
         tok->setCpp11init(iscpp11init_impl(tok));
-    return tok->isCpp11init() == TokenImpl::Cpp11init::CPP11INIT;
+    return tok->isCpp11init() == Token::Cpp11init::CPP11INIT;
 }
 
 static bool iscpp11init_impl(const Token * const tok)
 {
+    if (Token::simpleMatch(tok, "{") && Token::simpleMatch(tok->link()->previous(), "; }"))
+        return false;
     const Token *nameToken = tok;
     while (nameToken && nameToken->str() == "{") {
-        if (nameToken->isCpp11init() != TokenImpl::Cpp11init::UNKNOWN)
-            return nameToken->isCpp11init() == TokenImpl::Cpp11init::CPP11INIT;
+        if (nameToken->isCpp11init() != Token::Cpp11init::UNKNOWN)
+            return nameToken->isCpp11init() == Token::Cpp11init::CPP11INIT;
         nameToken = nameToken->previous();
-        if (nameToken && nameToken->str() == "," && Token::simpleMatch(nameToken->previous(), "} ,"))
-            nameToken = nameToken->linkAt(-1);
     }
     if (!nameToken)
         return false;
+    if (nameToken->str() == ")" && Token::simpleMatch(nameToken->link()->previous(), "decltype (") &&
+        !Token::simpleMatch(nameToken->link()->tokAt(-2), "."))
+        nameToken = nameToken->link()->previous();
+    if (Token::simpleMatch(nameToken, ", {"))
+        return true;
     if (nameToken->str() == ">" && nameToken->link())
         nameToken = nameToken->link()->previous();
+    if (Token::Match(nameToken, "]|*")) {
+        const Token* newTok = nameToken->link() ? nameToken->link()->previous() : nameToken->previous();
+        while (Token::Match(newTok, "%type%|::|*") && !newTok->isKeyword())
+            newTok = newTok->previous();
+        if (Token::simpleMatch(newTok, "new"))
+            return true;
+    }
+
+    auto isCaseStmt = [](const Token* colonTok) {
+        if (!Token::Match(colonTok->tokAt(-1), "%name%|%num%|%char%|) :"))
+            return false;
+        if (const Token* castTok = colonTok->linkAt(-1)) {
+            if (Token::simpleMatch(castTok->astParent(), "case"))
+                return true;
+        }
+        if (findParent(colonTok->previous(), [](const Token *parent){
+            return parent->str() == "case";
+        }))
+            return true;
+        const Token* caseTok = colonTok->tokAt(-2);
+        while (caseTok && Token::Match(caseTok->tokAt(-1), "::|%name%"))
+            caseTok = caseTok->tokAt(-1);
+        return Token::simpleMatch(caseTok, "case");
+    };
 
     const Token *endtok = nullptr;
-    if (Token::Match(nameToken, "%name% { !!["))
+    if (Token::Match(nameToken, "%name%|return|: {") && !isCaseStmt(nameToken) &&
+        (!Token::simpleMatch(nameToken->tokAt(2), "[") || findLambdaEndScope(nameToken->tokAt(2))))
         endtok = nameToken->linkAt(1);
     else if (Token::Match(nameToken,"%name% <") && Token::simpleMatch(nameToken->linkAt(1),"> {"))
         endtok = nameToken->linkAt(1)->linkAt(1);
+    else if (Token::Match(nameToken->previous(), "%name%|> ( {"))
+        endtok = nameToken->linkAt(1);
+    else if (Token::simpleMatch(nameToken, "decltype") && nameToken->linkAt(1))
+        endtok = nameToken->linkAt(1)->linkAt(1);
     else
         return false;
-    if (Token::Match(nameToken, "else|try|do|const|override|volatile|&|&&"))
+    if (Token::Match(nameToken, "else|try|do|const|constexpr|override|volatile|&|&&"))
         return false;
-    if (Token::simpleMatch(nameToken->previous(), "namespace"))
+    if (Token::simpleMatch(nameToken->previous(), ". void {") && nameToken->previous()->originalName() == "->")
+        return false; // trailing return type. The only function body that can contain no semicolon is a void function.
+    if (Token::simpleMatch(nameToken->previous(), "namespace") || Token::simpleMatch(nameToken, "namespace") /*anonymous namespace*/)
         return false;
+    if (precedes(nameToken->next(), endtok) && !Token::Match(nameToken, "return|:")) {
+        // If there is semicolon between {..} this is not a initlist
+        for (const Token *tok2 = nameToken->next(); tok2 != endtok; tok2 = tok2->next()) {
+            if (tok2->str() == ";")
+                return false;
+            const Token * lambdaEnd = findLambdaEndScope(tok2);
+            if (lambdaEnd)
+                tok2 = lambdaEnd;
+        }
+    }
     // There is no initialisation for example here: 'class Fred {};'
     if (!Token::simpleMatch(endtok, "} ;"))
         return true;
     const Token *prev = nameToken;
-    while (Token::Match(prev, "%name%|::|:|<|>")) {
-        if (Token::Match(prev, "class|struct"))
+    while (Token::Match(prev, "%name%|::|:|<|>|(|)|,|%num%|%cop%|...")) {
+        if (Token::Match(prev, "class|struct|union|enum"))
             return false;
 
         prev = prev->previous();
@@ -587,33 +654,73 @@ static bool iscpp11init_impl(const Token * const tok)
     return true;
 }
 
-static void compileUnaryOp(Token *&tok, AST_state& state, void(*f)(Token *&tok, AST_state& state))
+static bool isQualifier(const Token* tok)
+{
+    while (Token::Match(tok, "&|&&|*"))
+        tok = tok->next();
+    return Token::Match(tok, "{|;");
+}
+
+/**
+ * @throws InternalError thrown if maximum AST depth is exceeded
+ */
+static void compileUnaryOp(Token *&tok, AST_state& state, void (*f)(Token *&tok, AST_state& state))
 {
     Token *unaryop = tok;
     if (f) {
         tok = tok->next();
         state.depth++;
-        if (tok && state.depth <= AST_MAX_DEPTH)
+        if (state.depth > AST_MAX_DEPTH)
+            throw InternalError(tok, "maximum AST depth exceeded", InternalError::AST);
+        if (tok)
             f(tok, state);
         state.depth--;
     }
 
-    if (!state.op.empty()) {
+    if (!state.op.empty() && (!precedes(state.op.top(), unaryop) || unaryop->isIncDecOp() || Token::Match(unaryop, "[({[]"))) { // nullary functions, empty lists/arrays
         unaryop->astOperand1(state.op.top());
         state.op.pop();
     }
     state.op.push(unaryop);
 }
 
-static void compileBinOp(Token *&tok, AST_state& state, void(*f)(Token *&tok, AST_state& state))
+static void skipGenericType(Token *&tok)
+{
+    Token *skip = tok;
+    while (Token::Match(skip, "%name%|*|:|(")) {
+        if (skip->link()) {
+            skip = skip->link()->next();
+            continue;
+        }
+        if (Token::simpleMatch(skip, ":")) {
+            tok = skip->next();
+            return;
+        }
+        skip = skip->next();
+    }
+}
+
+/**
+ * @throws InternalError thrown if maximum AST depth is exceeded
+ */
+static void compileBinOp(Token *&tok, AST_state& state, void (*f)(Token *&tok, AST_state& state))
 {
     Token *binop = tok;
     if (f) {
         tok = tok->next();
+        if (Token::simpleMatch(binop, ",") && state.inGeneric)
+            skipGenericType(tok);
+        const bool inGenericSaved = state.inGeneric;
+        state.inGeneric = false;
+        if (Token::Match(binop, "::|. ~"))
+            tok = tok->next();
         state.depth++;
         if (tok && state.depth <= AST_MAX_DEPTH)
             f(tok, state);
+        if (state.depth > AST_MAX_DEPTH)
+            throw InternalError(tok, "maximum AST depth exceeded", InternalError::AST);
         state.depth--;
+        state.inGeneric = inGenericSaved;
     }
 
     // TODO: Should we check if op is empty.
@@ -632,6 +739,9 @@ static void compileBinOp(Token *&tok, AST_state& state, void(*f)(Token *&tok, AS
 
 static void compileExpression(Token *&tok, AST_state& state);
 
+/**
+ * @throws InternalError thrown if unexpected tokens are encountered
+ */
 static void compileTerm(Token *&tok, AST_state& state)
 {
     if (!tok)
@@ -654,11 +764,16 @@ static void compileTerm(Token *&tok, AST_state& state)
             tok = tok->next();
         } while (Token::Match(tok, "%name%|%str%"));
     } else if (tok->isName()) {
-        if (Token::Match(tok, "return|case") || (state.cpp && tok->str() == "throw")) {
+        if (Token::Match(tok, "return|case") || (state.cpp && (tok->str() == "throw"))) {
             if (tok->str() == "case")
                 state.inCase = true;
+            const bool tokIsReturn = tok->str() == "return";
+            const bool stopAtColon = state.stopAtColon;
+            state.stopAtColon=true;
             compileUnaryOp(tok, state, compileExpression);
-            state.op.pop();
+            state.stopAtColon=stopAtColon;
+            if (tokIsReturn)
+                state.op.pop();
             if (state.inCase && Token::simpleMatch(tok, ": ;")) {
                 state.inCase = false;
                 tok = tok->next();
@@ -666,7 +781,7 @@ static void compileTerm(Token *&tok, AST_state& state)
         } else if (Token::Match(tok, "sizeof !!(")) {
             compileUnaryOp(tok, state, compileExpression);
             state.op.pop();
-        } else if (state.cpp && findCppTypeInitPar(tok))  { // int(0), int*(123), ..
+        } else if (state.cpp && findCppTypeInitPar(tok)) {  // int(0), int*(123), ..
             tok = findCppTypeInitPar(tok);
             state.op.push(tok);
             tok = tok->tokAt(2);
@@ -675,48 +790,100 @@ static void compileTerm(Token *&tok, AST_state& state)
             tok = tok->next();
             if (tok->str() == "<")
                 tok = tok->link()->next();
-            if (Token::Match(tok, "{ . %name% =")) {
+
+            if (Token::Match(tok, "{ . %name% =|{")) {
+                const Token* end = tok->link();
                 const int inArrayAssignment = state.inArrayAssignment;
                 state.inArrayAssignment = 1;
                 compileBinOp(tok, state, compileExpression);
                 state.inArrayAssignment = inArrayAssignment;
+                if (tok == end)
+                    tok = tok->next();
+                else
+                    throw InternalError(tok, "Syntax error. Unexpected tokens in designated initializer.", InternalError::AST);
             }
         } else if (!state.cpp || !Token::Match(tok, "new|delete %name%|*|&|::|(|[")) {
-            tok = skipDecl(tok);
-            while (tok->next() && tok->next()->isName())
-                tok = tok->next();
+            std::vector<Token*> inner;
+            tok = skipDecl(tok, &inner);
+            for (Token* tok3 : inner) {
+                AST_state state1(state.cpp);
+                compileExpression(tok3, state1);
+            }
+            bool repeat = true;
+            while (repeat) {
+                repeat = false;
+                if (Token::Match(tok->next(), "%name%")) {
+                    tok = tok->next();
+                    repeat = true;
+                }
+                if (Token::simpleMatch(tok->next(), "<") && Token::Match(tok->linkAt(1), "> %name%")) {
+                    tok = tok->linkAt(1)->next();
+                    repeat = true;
+                }
+            }
             state.op.push(tok);
             if (Token::Match(tok, "%name% <") && tok->linkAt(1))
                 tok = tok->linkAt(1);
-            else if (Token::Match(tok, "%name% ..."))
+            else if (Token::Match(tok, "%name% ...") || (state.op.size() == 1 && state.depth == 0 && Token::Match(tok->tokAt(-3), "!!& ) ( %name% ) =")))
                 tok = tok->next();
             tok = tok->next();
             if (Token::Match(tok, "%str%")) {
                 while (Token::Match(tok, "%name%|%str%"))
                     tok = tok->next();
             }
+            if (Token::Match(tok, "%name% %assign%"))
+                tok = tok->next();
         }
     } else if (tok->str() == "{") {
         const Token *prev = tok->previous();
-        if (Token::simpleMatch(prev, ") {") && iscast(prev->link()))
+        if (Token::simpleMatch(prev, ") {") && iscast(prev->link(), state.cpp))
             prev = prev->link()->previous();
         if (Token::simpleMatch(tok->link(),"} [")) {
             tok = tok->next();
-        } else if (state.cpp && iscpp11init(tok)) {
-            if (state.op.empty() || Token::Match(tok->previous(), "[{,]"))
-                compileUnaryOp(tok, state, compileExpression);
-            else
+        } else if ((state.cpp && iscpp11init(tok)) || Token::simpleMatch(tok->previous(), "] {")) {
+            Token *const end = tok->link();
+            if (state.op.empty() || Token::Match(tok->previous(), "[{,]") || Token::Match(tok->tokAt(-2), "%name% (")) {
+                if (Token::Match(tok->tokAt(-1), "!!, { . %name% =|{") && !Token::simpleMatch(tok->tokAt(-1), "(")) {
+                    const int inArrayAssignment = state.inArrayAssignment;
+                    state.inArrayAssignment = 1;
+                    compileBinOp(tok, state, compileExpression);
+                    state.inArrayAssignment = inArrayAssignment;
+                } else if (Token::simpleMatch(tok, "{ }")) {
+                    state.op.push(tok);
+                    tok = tok->next();
+                } else {
+                    compileUnaryOp(tok, state, compileExpression);
+                    if (precedes(tok,end)) // typically for something like `MACRO(x, { if (c) { ... } })`, where end is the last curly, and tok is the open curly for the if
+                        tok = end;
+                }
+            } else if (tok->next() == end) {
+                tok->astOperand1(state.op.top());
+                state.op.pop();
+                tok = tok->next();
+            } else
                 compileBinOp(tok, state, compileExpression);
-            if (Token::Match(tok, "} ,|:"))
+            if (tok != end)
+                throw InternalError(tok, "Syntax error. Unexpected tokens in initializer.", InternalError::AST);
+            if (tok->next())
                 tok = tok->next();
-        } else if (!state.inArrayAssignment && !Token::simpleMatch(prev, "=")) {
+        } else if (state.cpp && Token::Match(tok->tokAt(-2), "%name% ( {") && !Token::findsimplematch(tok, ";", tok->link())) {
+            if (Token::simpleMatch(tok, "{ }"))
+                tok = tok->tokAt(2);
+            else {
+                Token *tok1 = tok;
+                state.inArrayAssignment++;
+                compileUnaryOp(tok, state, compileExpression);
+                state.inArrayAssignment--;
+                tok = tok1->link()->next();
+            }
+        } else if ((!state.inArrayAssignment && !Token::simpleMatch(prev, "=")) || Token::simpleMatch(prev, "?")) {
             state.op.push(tok);
             tok = tok->link()->next();
         } else {
             if (tok->link() != tok->next()) {
                 state.inArrayAssignment++;
                 compileUnaryOp(tok, state, compileExpression);
-                while (Token::Match(tok, "} [,};]") && state.inArrayAssignment > 0) {
+                if (Token::Match(tok, "} [,};]") && state.inArrayAssignment > 0) {
                     tok = tok->next();
                     state.inArrayAssignment--;
                 }
@@ -733,42 +900,78 @@ static void compileScope(Token *&tok, AST_state& state)
     compileTerm(tok, state);
     while (tok) {
         if (tok->str() == "::") {
-            Token *binop = tok;
-            tok = tok->next();
-            if (tok && tok->str() == "~") // Jump over ~ of destructor definition
-                tok = tok->next();
-            if (tok)
-                compileTerm(tok, state);
-
-            if (binop->previous() && (binop->previous()->isName() || (binop->previous()->link() && binop->strAt(-1) == ">")))
-                compileBinOp(binop, state, nullptr);
+            const Token *lastOp = state.op.empty() ? nullptr : state.op.top();
+            if (Token::Match(lastOp, ":: %name%"))
+                lastOp = lastOp->next();
+            if (Token::Match(lastOp, "%name%") &&
+                (lastOp->next() == tok || (Token::Match(lastOp, "%name% <") && lastOp->linkAt(1) && tok == lastOp->linkAt(1)->next())))
+                compileBinOp(tok, state, compileTerm);
             else
-                compileUnaryOp(binop, state, nullptr);
+                compileUnaryOp(tok, state, compileTerm);
         } else break;
     }
 }
 
 static bool isPrefixUnary(const Token* tok, bool cpp)
 {
+    if (cpp && Token::simpleMatch(tok->previous(), "* [") && Token::simpleMatch(tok->link(), "] {")) {
+        for (const Token* prev = tok->previous(); Token::Match(prev, "%name%|::|*|&|>|>>"); prev = prev->previous()) {
+            if (Token::Match(prev, ">|>>")) {
+                if (!prev->link())
+                    break;
+                prev = prev->link();
+            }
+            if (prev->str() == "new")
+                return false;
+        }
+    }
     if (!tok->previous()
-        || ((Token::Match(tok->previous(), "(|[|{|%op%|;|}|?|:|,|.|return|::") || (cpp && tok->strAt(-1) == "throw"))
+        || ((Token::Match(tok->previous(), "(|[|{|%op%|;|?|:|,|.|case|return|::") || (cpp && tok->strAt(-1) == "throw"))
             && (tok->previous()->tokType() != Token::eIncDecOp || tok->tokType() == Token::eIncDecOp)))
         return true;
 
+    if (tok->strAt(-1) == "}") {
+        const Token* parent = tok->linkAt(-1)->tokAt(-1);
+        return !Token::Match(parent, "%type%") || parent->isKeyword();
+    }
+
     if (tok->str() == "*" && tok->previous()->tokType() == Token::eIncDecOp && isPrefixUnary(tok->previous(), cpp))
         return true;
 
-    return tok->strAt(-1) == ")" && iscast(tok->linkAt(-1));
+    return tok->strAt(-1) == ")" && iscast(tok->linkAt(-1), cpp);
 }
 
+/**
+ * @throws InternalError thrown if unexpected tokens are encountered
+ */
 static void compilePrecedence2(Token *&tok, AST_state& state)
 {
-    compileScope(tok, state);
+    auto doCompileScope = [&](const Token* tok) -> bool {
+        const bool isStartOfCpp11Init = state.cpp && tok && tok->str() == "{" && iscpp11init(tok);
+        if (isStartOfCpp11Init || Token::simpleMatch(tok, "(")) {
+            tok = tok->previous();
+            while (Token::simpleMatch(tok, "*"))
+                tok = tok->previous();
+            while (tok && Token::Match(tok->previous(), ":: %type%"))
+                tok = tok->tokAt(-2);
+            if (tok && !tok->isKeyword())
+                tok = tok->previous();
+            return !Token::Match(tok, "new ::| %type%");
+        }
+        return !findLambdaEndTokenWithoutAST(tok);
+    };
+
+    bool isNew = true;
+    if (doCompileScope(tok)) {
+        compileScope(tok, state);
+        isNew = false;
+    }
     while (tok) {
         if (tok->tokType() == Token::eIncDecOp && !isPrefixUnary(tok, state.cpp)) {
             compileUnaryOp(tok, state, compileScope);
         } else if (tok->str() == "...") {
-            state.op.push(tok);
+            if (!Token::simpleMatch(tok->previous(), ")"))
+                state.op.push(tok);
             tok = tok->next();
             break;
         } else if (tok->str() == "." && tok->strAt(1) != "*") {
@@ -776,25 +979,53 @@ static void compilePrecedence2(Token *&tok, AST_state& state)
                 state.op.push(tok);
                 tok = tok->tokAt(3);
                 break;
-            } else
+            }
+            if (!Token::Match(tok->tokAt(-1), "[{,]"))
                 compileBinOp(tok, state, compileScope);
+            else
+                compileUnaryOp(tok, state, compileScope);
         } else if (tok->str() == "[") {
-            if (state.cpp && isPrefixUnary(tok, state.cpp) && Token::Match(tok->link(), "] (|{")) { // Lambda
+            if (state.cpp && isPrefixUnary(tok, /*cpp*/ true) && Token::Match(tok->link(), "] (|{|<")) { // Lambda
                 // What we do here:
                 // - Nest the round bracket under the square bracket.
                 // - Nest what follows the lambda (if anything) with the lambda opening [
                 // - Compile the content of the lambda function as separate tree (this is done later)
                 // this must be consistent with isLambdaCaptureList
                 Token* const squareBracket = tok;
-                if (Token::simpleMatch(squareBracket->link(), "] (")) {
-                    Token* const roundBracket = squareBracket->link()->next();
+                // Parse arguments in the capture list
+                if (tok->strAt(1) != "]") {
+                    Token* tok2 = tok->next();
+                    AST_state state2(state.cpp);
+                    compileExpression(tok2, state2);
+                    if (!state2.op.empty()) {
+                        squareBracket->astOperand2(state2.op.top());
+                    }
+                }
+
+                const bool hasTemplateArg = Token::simpleMatch(squareBracket->link(), "] <") &&
+                                            Token::simpleMatch(squareBracket->link()->linkAt(1), "> (");
+                if (Token::simpleMatch(squareBracket->link(), "] (") || hasTemplateArg) {
+                    Token* const roundBracket = hasTemplateArg ? squareBracket->link()->linkAt(1)->next() : squareBracket->link()->next();
                     Token* curlyBracket = roundBracket->link()->next();
-                    if (Token::Match(curlyBracket, "mutable|const"))
+                    while (Token::Match(curlyBracket, "mutable|const|constexpr|consteval"))
                         curlyBracket = curlyBracket->next();
-                    if (curlyBracket && curlyBracket->originalName() == "->") {
-                        while (Token::Match(curlyBracket, "%name%|.|::|&|*"))
+                    if (Token::simpleMatch(curlyBracket, "noexcept")) {
+                        if (Token::simpleMatch(curlyBracket->next(), "(")) {
+                            AST_state state2(state.cpp);
+                            Token *tok2 = curlyBracket->tokAt(2);
+                            compileExpression(tok2, state2);
+                            curlyBracket = curlyBracket->linkAt(1)->next();
+                        } else
                             curlyBracket = curlyBracket->next();
                     }
+                    if (curlyBracket && curlyBracket->originalName() == "->") {
+                        if (Token::simpleMatch(curlyBracket->next(), "decltype (")) {
+                            AST_state state2(state.cpp);
+                            Token *tok2 = curlyBracket->tokAt(3);
+                            compileExpression(tok2, state2);
+                        }
+                        curlyBracket = findTypeEnd(curlyBracket->next());
+                    }
                     if (curlyBracket && curlyBracket->str() == "{") {
                         squareBracket->astOperand1(roundBracket);
                         roundBracket->astOperand1(curlyBracket);
@@ -806,28 +1037,59 @@ static void compilePrecedence2(Token *&tok, AST_state& state)
                     Token* const curlyBracket = squareBracket->link()->next();
                     squareBracket->astOperand1(curlyBracket);
                     state.op.push(squareBracket);
-                    tok = curlyBracket->link()->next();
+                    tok = curlyBracket->link() ? curlyBracket->link()->next() : nullptr;
                     continue;
                 }
             }
 
-            const Token* const tok2 = tok;
-            if (tok->strAt(1) != "]")
+            Token* const tok2 = tok;
+            if (tok->strAt(1) != "]") {
                 compileBinOp(tok, state, compileExpression);
+                if (Token::Match(tok2->previous(), "%type%|* [") && Token::Match(tok, "] { !!}")) {
+                    tok = tok->next();
+                    Token* const tok3 = tok;
+                    compileBinOp(tok, state, compileExpression);
+                    if (tok != tok3->link())
+                        throw InternalError(tok, "Syntax error in {..}", InternalError::AST);
+                    tok = tok->next();
+                    continue;
+                }
+            }
             else
                 compileUnaryOp(tok, state, compileExpression);
             tok = tok2->link()->next();
-        } else if (tok->str() == "(" && (!iscast(tok) || Token::Match(tok->previous(), "if|while|for|switch|catch"))) {
+        } else if ((Token::simpleMatch(tok->tokAt(-1), "requires {") && tok->tokAt(-1)->isKeyword())
+                   || (Token::simpleMatch(tok->tokAt(-1), ")")
+                       && tok->linkAt(-1)
+                       && Token::simpleMatch(tok->linkAt(-1)->tokAt(-1), "requires (") && tok->linkAt(-1)->tokAt(-1)->isKeyword())) {
+            if (!tok->link())
+                throw InternalError(tok, "Syntax error, token has no link.", InternalError::AST);
+            tok->astOperand1(state.op.top());
+            state.op.pop();
+            state.op.push(tok);
+            tok = tok->link()->next();
+            continue;
+        } else if (Token::simpleMatch(tok, "( {") && Token::simpleMatch(tok->linkAt(1)->previous(), "; } )") &&
+                   !Token::Match(tok->previous(), "%name% (")) {
+            state.op.push(tok->next());
+            tok = tok->link()->next();
+            continue;
+        } else if (tok->str() == "(" &&
+                   (!iscast(tok, state.cpp) || Token::Match(tok->previous(), "if|while|for|switch|catch"))) {
+            const bool inGenericSaved = state.inGeneric;
+            if (Token::simpleMatch(tok->previous(), "_Generic"))
+                state.inGeneric = true;
             Token* tok2 = tok;
             tok = tok->next();
             const bool opPrevTopSquare = !state.op.empty() && state.op.top() && state.op.top()->str() == "[";
             const std::size_t oldOpSize = state.op.size();
             compileExpression(tok, state);
             tok = tok2;
-            if ((tok->previous() && tok->previous()->isName() && (!Token::Match(tok->previous(), "return|case") && (!state.cpp || !Token::Match(tok->previous(), "throw|delete"))))
+            if ((oldOpSize > 0 && (isNew || Token::simpleMatch(tok->previous(), "} (")))
+                || (tok->previous() && tok->previous()->isName() && !Token::Match(tok->previous(), "return|case") && (!state.cpp || !Token::Match(tok->previous(), "throw|delete")))
                 || (tok->strAt(-1) == "]" && (!state.cpp || !Token::Match(tok->linkAt(-1)->previous(), "new|delete")))
                 || (tok->strAt(-1) == ">" && tok->linkAt(-1))
-                || (tok->strAt(-1) == ")" && !iscast(tok->linkAt(-1))) // Don't treat brackets to clarify precedence as function calls
+                || (tok->strAt(-1) == ")" && !iscast(tok->linkAt(-1), state.cpp)) // Don't treat brackets to clarify precedence as function calls
                 || (tok->strAt(-1) == "}" && opPrevTopSquare)) {
                 const bool operandInside = oldOpSize < state.op.size();
                 if (operandInside)
@@ -835,15 +1097,35 @@ static void compilePrecedence2(Token *&tok, AST_state& state)
                 else
                     compileUnaryOp(tok, state, nullptr);
             }
+            state.inGeneric = inGenericSaved;
+            tok = tok->link()->next();
+            if (Token::simpleMatch(tok, "::"))
+                compileBinOp(tok, state, compileScope);
+        } else if (iscast(tok, state.cpp) && Token::simpleMatch(tok->link(), ") {") &&
+                   Token::simpleMatch(tok->link()->linkAt(1), "} [")) {
+            Token *cast = tok;
             tok = tok->link()->next();
+            Token *tok1 = tok;
+            compileUnaryOp(tok, state, compileExpression);
+            cast->astOperand1(tok1);
+            tok = tok1->link()->next();
         } else if (state.cpp && tok->str() == "{" && iscpp11init(tok)) {
+            Token* end = tok->link();
             if (Token::simpleMatch(tok, "{ }"))
-                compileUnaryOp(tok, state, compileExpression);
+            {
+                compileUnaryOp(tok, state, nullptr);
+                tok = tok->next();
+            }
             else
+            {
                 compileBinOp(tok, state, compileExpression);
-            if (Token::simpleMatch(tok, "}"))
-                tok = tok->next();
-        } else break;
+            }
+            if (tok == end)
+                tok = end->next();
+            else
+                throw InternalError(tok, "Syntax error. Unexpected tokens in initializer.", InternalError::AST);
+        } else
+            break;
     }
 }
 
@@ -863,11 +1145,15 @@ static void compilePrecedence3(Token *&tok, AST_state& state)
                 }
             }
             compileUnaryOp(tok, state, compilePrecedence3);
-        } else if (tok->str() == "(" && iscast(tok)) {
+        } else if (tok->str() == "(" && iscast(tok, state.cpp)) {
             Token* castTok = tok;
             castTok->isCast(true);
             tok = tok->link()->next();
+            const int inArrayAssignment = state.inArrayAssignment;
+            if (tok && tok->str() == "{")
+                state.inArrayAssignment = 1;
             compilePrecedence3(tok, state);
+            state.inArrayAssignment = inArrayAssignment;
             compileUnaryOp(castTok, state, nullptr);
         } else if (state.cpp && Token::Match(tok, "new %name%|::|(")) {
             Token* newtok = tok;
@@ -876,9 +1162,14 @@ static void compilePrecedence3(Token *&tok, AST_state& state)
             if (tok->str() == "(") {
                 if (Token::Match(tok, "( &| %name%") && Token::Match(tok->link(), ") ( %type%") && Token::simpleMatch(tok->link()->linkAt(1), ") ("))
                     tok = tok->link()->next();
-                if (Token::Match(tok->link(), ") ::| %type%"))
+                if (Token::Match(tok->link(), ") ::| %type%")) {
+                    if (Token::Match(tok, "( !!)")) {
+                        Token *innerTok = tok->next();
+                        AST_state innerState(true);
+                        compileExpression(innerTok, innerState);
+                    }
                     tok = tok->link()->next();
-                else if (Token::Match(tok, "( %type%") && Token::Match(tok->link(), ") [();,[]")) {
+                } else if (Token::Match(tok, "( %type%") && Token::Match(tok->link(), ") [();,[]")) {
                     tok = tok->next();
                     innertype = true;
                 } else if (Token::Match(tok, "( &| %name%") && Token::simpleMatch(tok->link(), ") (")) {
@@ -889,6 +1180,22 @@ static void compilePrecedence3(Token *&tok, AST_state& state)
                     continue;
                 }
             }
+
+            Token* leftToken = tok;
+            if (Token::simpleMatch(tok, "::")) {
+                tok->astOperand1(tok->next());
+                tok = tok->next();
+            }
+            else {
+                while (Token::Match(tok->next(), ":: %name%")) {
+                    Token* scopeToken = tok->next(); //The ::
+                    scopeToken->astOperand1(leftToken);
+                    scopeToken->astOperand2(scopeToken->next());
+                    leftToken = scopeToken;
+                    tok = scopeToken->next();
+                }
+            }
+
             state.op.push(tok);
             while (Token::Match(tok, "%name%|*|&|<|::")) {
                 if (tok->link())
@@ -899,13 +1206,17 @@ static void compilePrecedence3(Token *&tok, AST_state& state)
                 state.op.push(tok->next());
                 tok = tok->link()->next();
                 compileBinOp(tok, state, compilePrecedence2);
-            } else if (tok && (tok->str() == "[" || tok->str() == "(" || tok->str() == "{"))
+            } else if (Token::Match(tok, "(|{|["))
                 compilePrecedence2(tok, state);
             else if (innertype && Token::simpleMatch(tok, ") [")) {
                 tok = tok->next();
                 compilePrecedence2(tok, state);
             }
             compileUnaryOp(newtok, state, nullptr);
+            if (Token::simpleMatch(newtok->previous(), ":: new")) {
+                newtok->previous()->astOperand1(newtok);
+                state.op.pop();
+            }
             if (innertype && Token::simpleMatch(tok, ") ,"))
                 tok = tok->next();
         } else if (state.cpp && Token::Match(tok, "delete %name%|*|&|::|(|[")) {
@@ -915,6 +1226,10 @@ static void compilePrecedence3(Token *&tok, AST_state& state)
                 tok = tok->link()->next();
             compilePrecedence3(tok, state);
             compileUnaryOp(tok2, state, nullptr);
+            if (Token::simpleMatch(tok2->previous(), ":: delete")) {
+                tok2->previous()->astOperand1(tok2);
+                state.op.pop();
+            }
         }
         // TODO: Handle sizeof
         else break;
@@ -935,7 +1250,7 @@ static void compileMulDiv(Token *&tok, AST_state& state)
 {
     compilePointerToElem(tok, state);
     while (tok) {
-        if (Token::Match(tok, "[/%]") || (tok->str() == "*" && !tok->astOperand1())) {
+        if (Token::Match(tok, "[/%]") || (tok->str() == "*" && !tok->astOperand1() && !isQualifier(tok))) {
             if (Token::Match(tok, "* [*,)]")) {
                 Token* tok2 = tok->next();
                 while (tok2->next() && tok2->str() == "*")
@@ -970,16 +1285,26 @@ static void compileShift(Token *&tok, AST_state& state)
     }
 }
 
-static void compileRelComp(Token *&tok, AST_state& state)
+static void compileThreewayComp(Token *&tok, AST_state& state)
 {
     compileShift(tok, state);
     while (tok) {
-        if (Token::Match(tok, "<|<=|>=|>") && !tok->link()) {
+        if (tok->str() == "<=>") {
             compileBinOp(tok, state, compileShift);
         } else break;
     }
 }
 
+static void compileRelComp(Token *&tok, AST_state& state)
+{
+    compileThreewayComp(tok, state);
+    while (tok) {
+        if (Token::Match(tok, "<|<=|>=|>") && !tok->link()) {
+            compileBinOp(tok, state, compileThreewayComp);
+        } else break;
+    }
+}
+
 static void compileEqComp(Token *&tok, AST_state& state)
 {
     compileRelComp(tok, state);
@@ -994,7 +1319,7 @@ static void compileAnd(Token *&tok, AST_state& state)
 {
     compileEqComp(tok, state);
     while (tok) {
-        if (tok->str() == "&" && !tok->astOperand1()) {
+        if (tok->str() == "&" && !tok->astOperand1() && !isQualifier(tok)) {
             Token* tok2 = tok->next();
             if (!tok2)
                 break;
@@ -1033,7 +1358,16 @@ static void compileLogicAnd(Token *&tok, AST_state& state)
 {
     compileOr(tok, state);
     while (tok) {
-        if (tok->str() == "&&") {
+        if (tok->str() == "&&" && !isQualifier(tok)) {
+            if (!tok->astOperand1()) {
+                Token* tok2 = tok->next();
+                if (!tok2)
+                    break;
+                if (state.cpp && Token::Match(tok2, ",|)")) {
+                    tok = tok2;
+                    break; // rValue reference
+                }
+            }
             compileBinOp(tok, state, compileOr);
         } else break;
     }
@@ -1055,13 +1389,18 @@ static void compileAssignTernary(Token *&tok, AST_state& state)
     while (tok) {
         if (tok->isAssignmentOp()) {
             state.assign++;
+            const Token *tok1 = tok->next();
             compileBinOp(tok, state, compileAssignTernary);
+            if (Token::simpleMatch(tok1, "{") && tok == tok1->link() && tok->next())
+                tok = tok->next();
             if (state.assign > 0)
                 state.assign--;
         } else if (tok->str() == "?") {
             // http://en.cppreference.com/w/cpp/language/operator_precedence says about ternary operator:
             //       "The expression in the middle of the conditional operator (between ? and :) is parsed as if parenthesized: its precedence relative to ?: is ignored."
             // Hence, we rely on Tokenizer::prepareTernaryOpForAST() to add such parentheses where necessary.
+            const bool stopAtColon = state.stopAtColon;
+            state.stopAtColon = false;
             if (tok->strAt(1) == ":") {
                 state.op.push(nullptr);
             }
@@ -1069,12 +1408,15 @@ static void compileAssignTernary(Token *&tok, AST_state& state)
             state.assign = 0;
             compileBinOp(tok, state, compileAssignTernary);
             state.assign = assign;
+            state.stopAtColon = stopAtColon;
         } else if (tok->str() == ":") {
             if (state.depth == 1U && state.inCase) {
                 state.inCase = false;
                 tok = tok->next();
                 break;
             }
+            if (state.stopAtColon)
+                break;
             if (state.assign > 0)
                 break;
             compileBinOp(tok, state, compileAssignTernary);
@@ -1091,93 +1433,127 @@ static void compileComma(Token *&tok, AST_state& state)
                 tok = tok->next();
             else
                 compileBinOp(tok, state, compileAssignTernary);
+        } else if (tok->str() == ";" && state.functionCallEndPar && tok->index() < state.functionCallEndPar->index()) {
+            compileBinOp(tok, state, compileAssignTernary);
         } else break;
     }
 }
 
+/**
+ * @throws InternalError thrown if maximum AST depth is exceeded
+ */
 static void compileExpression(Token *&tok, AST_state& state)
 {
     if (state.depth > AST_MAX_DEPTH)
-        return; // ticket #5592
+        throw InternalError(tok, "maximum AST depth exceeded", InternalError::AST); // ticket #5592
     if (tok)
         compileComma(tok, state);
 }
 
-static bool isLambdaCaptureList(const Token * tok)
+const Token* isLambdaCaptureList(const Token * tok)
 {
     // a lambda expression '[x](y){}' is compiled as:
     // [
     // `-(  <<-- optional
     //   `-{
     // see compilePrecedence2
-    if (tok->str() != "[")
-        return false;
+    if (!Token::simpleMatch(tok, "["))
+        return nullptr;
     if (!Token::Match(tok->link(), "] (|{"))
-        return false;
+        return nullptr;
     if (Token::simpleMatch(tok->astOperand1(), "{") && tok->astOperand1() == tok->link()->next())
-        return true;
+        return tok->astOperand1();
     if (!tok->astOperand1() || tok->astOperand1()->str() != "(")
-        return false;
+        return nullptr;
     const Token * params = tok->astOperand1();
-    if (!params || !params->astOperand1() || params->astOperand1()->str() != "{")
-        return false;
-    return true;
+    if (!Token::simpleMatch(params->astOperand1(), "{"))
+        return nullptr;
+    return params->astOperand1();
 }
 
-static Token * createAstAtToken(Token *tok, bool cpp);
+const Token* findLambdaEndTokenWithoutAST(const Token* tok) {
+    if (!(Token::simpleMatch(tok, "[") && tok->link()))
+        return nullptr;
+    tok = tok->link()->next();
+    if (Token::simpleMatch(tok, "(") && tok->link())
+        tok = tok->link()->next();
+    if (Token::simpleMatch(tok, "mutable"))
+        tok = tok->next();
+    if (Token::Match(tok, ".|->")) { // trailing return type
+        tok = tok->next();
+        while (Token::Match(tok, "%type%|%name%|::|&|&&|*|<|(")) {
+            if (tok->link())
+                tok = tok->link()->next();
+            else
+                tok = tok->next();
+        }
+    }
+    if (!(Token::simpleMatch(tok, "{") && tok->link()))
+        return nullptr;
+    return tok->link()->next();
+}
+
+static Token * createAstAtToken(Token *tok);
 
 // Compile inner expressions inside inner ({..}) and lambda bodies
 static void createAstAtTokenInner(Token * const tok1, const Token *endToken, bool cpp)
 {
-    for (Token *tok = tok1; tok && tok != endToken; tok = tok ? tok->next() : nullptr) {
+    for (Token* tok = tok1; precedes(tok, endToken); tok = tok ? tok->next() : nullptr) {
         if (tok->str() == "{" && !iscpp11init(tok)) {
-            if (Token::simpleMatch(tok->astOperand1(), ","))
-                continue;
-            if (Token::simpleMatch(tok->previous(), "( {"))
-                ;
-            // struct assignment
-            else if (Token::simpleMatch(tok->previous(), ") {") && Token::simpleMatch(tok->linkAt(-1), "( struct"))
-                continue;
-            // Lambda function
-            else if (Token::simpleMatch(tok->astParent(), "(") &&
-                     Token::simpleMatch(tok->astParent()->astParent(), "[") &&
-                     tok->astParent()->astParent()->astOperand1() &&
-                     tok == tok->astParent()->astParent()->astOperand1()->astOperand1())
-                ;
-            else {
-                // function argument is initializer list?
-                const Token *parent = tok->astParent();
-                while (Token::simpleMatch(parent, ","))
-                    parent = parent->astParent();
-                if (!parent || !Token::Match(parent->previous(), "%name% ("))
-                    // not function argument..
-                    continue;
-            }
-
-            if (Token::simpleMatch(tok->previous(), "( { ."))
-                break;
-
             const Token * const endToken2 = tok->link();
-            for (; tok && tok != endToken && tok != endToken2; tok = tok ? tok->next() : nullptr)
-                tok = createAstAtToken(tok, cpp);
-        } else if (tok->str() == "[") {
+            bool hasAst = false;
+            for (const Token *inner = tok->next(); inner != endToken2; inner = inner->next()) {
+                if (inner->astOperand1()) {
+                    hasAst = true;
+                    break;
+                }
+                if (tok->isConstOp())
+                    break;
+                if (inner->str() == "{")
+                    inner = inner->link();
+            }
+            if (!hasAst) {
+                for (; tok && tok != endToken && tok != endToken2; tok = tok ? tok->next() : nullptr)
+                    tok = createAstAtToken(tok);
+            }
+        } else if (cpp && tok->str() == "[") {
             if (isLambdaCaptureList(tok)) {
                 tok = tok->astOperand1();
                 if (tok->str() == "(")
                     tok = tok->astOperand1();
                 const Token * const endToken2 = tok->link();
+                tok = tok->next();
                 for (; tok && tok != endToken && tok != endToken2; tok = tok ? tok->next() : nullptr)
-                    tok = createAstAtToken(tok, cpp);
+                    tok = createAstAtToken(tok);
+            }
+        }
+        else if (Token::simpleMatch(tok, "( * ) [")) {
+            bool hasAst = false;
+            for (const Token* tok2 = tok->linkAt(3); tok2 != tok; tok2 = tok2->previous()) {
+                if (tok2->astParent() || tok2->astOperand1() || tok2->astOperand2()) {
+                    hasAst = true;
+                    break;
+                }
+            }
+            if (!hasAst) {
+                Token *const startTok = tok = tok->tokAt(4);
+                const Token* const endtok = startTok->linkAt(-1);
+                AST_state state(cpp);
+                compileExpression(tok, state);
+                createAstAtTokenInner(startTok, endtok, cpp);
             }
         }
     }
 }
 
-static Token * findAstTop(Token *tok1, Token *tok2)
+static Token * findAstTop(Token *tok1, const Token *tok2)
 {
     for (Token *tok = tok1; tok && (tok != tok2); tok = tok->next()) {
-        if (tok->astParent() || tok->astOperand1() || tok->astOperand2())
-            return tok->astTop();
+        if (tok->astParent() || tok->astOperand1() || tok->astOperand2()) {
+            while (tok->astParent() && tok->astParent()->index() >= tok1->index() && tok->astParent()->index() <= tok2->index())
+                tok = tok->astParent();
+            return tok;
+        }
         if (Token::simpleMatch(tok, "( {"))
             tok = tok->link();
     }
@@ -1190,31 +1566,158 @@ static Token * findAstTop(Token *tok1, Token *tok2)
     return nullptr;
 }
 
-static Token * createAstAtToken(Token *tok, bool cpp)
+static Token *skipMethodDeclEnding(Token *tok)
 {
-    if (Token::simpleMatch(tok, "for (")) {
-        Token *tok2 = skipDecl(tok->tokAt(2));
-        Token *init1 = nullptr;
-        Token * const endPar = tok->next()->link();
-        while (tok2 && tok2 != endPar && tok2->str() != ";") {
-            if (tok2->str() == "<" && tok2->link()) {
-                tok2 = tok2->link();
-                if (!tok2)
+    if (tok->str() != ")")
+        tok = tok->previous();
+    if (!tok || tok->str() != ")")
+        return nullptr;
+    Token *const tok2 = const_cast<Token*>(TokenList::isFunctionHead(tok, ";{"));
+    if (tok2 && tok->next() != tok2)
+        return tok2;
+    return nullptr;
+}
+
+/**
+ * @throws InternalError thrown in case of syntax error
+ */
+static Token * createAstAtToken(Token *tok)
+{
+    const bool cpp = tok->isCpp();
+    // skip function pointer declaration
+    if (Token::Match(tok, "%type% %type%") && !Token::Match(tok, "return|throw|new|delete")) {
+        Token* tok2 = tok->tokAt(2);
+        // skip type tokens and qualifiers etc
+        while (Token::Match(tok2, "%type%|*|&"))
+            tok2 = tok2->next();
+        if (Token::Match(tok2, "%var% [;,)]"))
+            return tok2;
+    }
+    if (Token::Match(tok, "enum class| %name%| :")) {
+        if (Token::simpleMatch(tok->next(), "class"))
+            tok = tok->next();
+        if (Token::Match(tok->next(), "%name%"))
+            tok = tok->next();
+        return tok->next();
+    }
+    if (Token *const endTok = skipMethodDeclEnding(tok)) {
+        Token *tok2 = tok;
+        do {
+            tok2 = tok2->next();
+            tok2->setCpp11init(false);
+            if (Token::Match(tok2, "decltype|noexcept (")) {
+                AST_state state(cpp);
+                Token *tok3 = tok2->tokAt(2);
+                compileExpression(tok3, state);
+                tok2 = tok2->linkAt(1);
+            }
+        } while (tok2 != endTok && !precedes(endTok, tok2));
+        return endTok;
+    }
+    if (Token::Match(tok, "%type%") && !Token::Match(tok, "return|throw|if|while|new|delete")) {
+        bool isStandardTypeOrQualifier = false;
+        Token* type = tok;
+        while (Token::Match(type, "%type%|*|&|<")) {
+            if (type->isName() && (type->isStandardType() || Token::Match(type, "const|mutable|static|volatile")))
+                isStandardTypeOrQualifier = true;
+            if (type->str() == "<") {
+                if (type->link())
+                    type = type->link();
+                else
                     break;
-            } else if (Token::Match(tok2, "%name% %op%|(|[|.|:|::") || Token::Match(tok2->previous(), "[(;{}] %cop%|(")) {
-                init1 = tok2;
+            }
+            type = type->next();
+        }
+        if (isStandardTypeOrQualifier && Token::Match(type, "%var% [;,)]"))
+            return type;
+        if (Token::Match(type, "( * *| %var%") &&
+            Token::Match(type->link()->previous(), "%var%|] ) (") &&
+            Token::Match(type->link()->linkAt(1), ") [;,)]"))
+            return type->link()->linkAt(1)->next();
+    }
+
+    if (Token::simpleMatch(tok, "for (")) {
+        if (cpp && Token::Match(tok, "for ( const| auto &|&&| [")) {
+            Token *decl = Token::findsimplematch(tok, "[");
+            if (Token::simpleMatch(decl->link(), "] :")) {
                 AST_state state1(cpp);
-                compileExpression(tok2, state1);
-                if (Token::Match(tok2, ";|)"))
-                    break;
-                init1 = nullptr;
+                while (decl->str() != "]") {
+                    if (Token::Match(decl, "%name% ,|]")) {
+                        state1.op.push(decl);
+                    } else if (decl->str() == ",") {
+                        if (!state1.op.empty()) {
+                            decl->astOperand1(state1.op.top());
+                            state1.op.pop();
+                        }
+                        if (!state1.op.empty()) {
+                            state1.op.top()->astOperand2(decl);
+                            state1.op.pop();
+                        }
+                        state1.op.push(decl);
+                    }
+                    decl = decl->next();
+                }
+                if (state1.op.size() > 1) {
+                    Token *lastName = state1.op.top();
+                    state1.op.pop();
+                    state1.op.top()->astOperand2(lastName);
+                }
+                decl = decl->next();
+
+                Token *colon = decl;
+                compileExpression(decl, state1);
+
+                tok->next()->astOperand1(tok);
+                tok->next()->astOperand2(colon);
+
+                return decl;
+            }
+        }
+
+        std::vector<Token*> inner;
+        Token* tok2 = skipDecl(tok->tokAt(2), &inner);
+        for (Token* tok3 : inner) {
+            AST_state state1(cpp);
+            compileExpression(tok3, state1);
+        }
+        Token *init1 = nullptr;
+        Token * const endPar = tok->linkAt(1);
+        if (tok2 == tok->tokAt(2) && Token::Match(tok2, "%op%|(")) {
+            init1 = tok2;
+            AST_state state1(cpp);
+            compileExpression(tok2, state1);
+            if (Token::Match(init1, "( !!{")) {
+                for (Token *tok3 = init1; tok3 && tok3 != tok3->link(); tok3 = tok3->next()) {
+                    if (tok3->astParent()) {
+                        while (tok3->astParent())
+                            tok3 = tok3->astParent();
+                        init1 = tok3;
+                        break;
+                    }
+                    if (!Token::Match(tok3, "%op%|(|["))
+                        init1 = tok3;
+                }
+            }
+        } else {
+            while (tok2 && tok2 != endPar && tok2->str() != ";") {
+                if (tok2->str() == "<" && tok2->link()) {
+                    tok2 = tok2->link();
+                } else if (Token::Match(tok2, "%name% )| %op%|(|[|{|.|:|::") || Token::Match(tok2->previous(), "[(;{}] %cop%|(")) {
+                    init1 = tok2;
+                    AST_state state1(cpp);
+                    compileExpression(tok2, state1);
+                    if (Token::Match(tok2, ";|)"))
+                        break;
+                    init1 = nullptr;
+                }
+                if (!tok2) // #7109 invalid code
+                    return nullptr;
+                tok2 = tok2->next();
             }
-            if (!tok2) // #7109 invalid code
-                return nullptr;
-            tok2 = tok2->next();
         }
         if (!tok2 || tok2->str() != ";") {
             if (tok2 == endPar && init1) {
+                createAstAtTokenInner(init1->next(), endPar, cpp);
                 tok->next()->astOperand2(init1);
                 tok->next()->astOperand1(tok);
             }
@@ -1231,26 +1734,34 @@ static Token * createAstAtToken(Token *tok, bool cpp)
         Token * const semicolon2 = tok2;
         if (!semicolon2)
             return nullptr; // invalid code #7235
-        tok2 = tok2->next();
-        AST_state state3(cpp);
-        if (Token::simpleMatch(tok2, "( {")) {
-            state3.op.push(tok2->next());
-            tok2 = tok2->link()->next();
+
+        if (semicolon2->str() == ";") {
+            tok2 = tok2->next();
+            AST_state state3(cpp);
+            if (Token::simpleMatch(tok2, "( {")) {
+                state3.op.push(tok2->next());
+                tok2 = tok2->link()->next();
+            }
+            compileExpression(tok2, state3);
+
+            tok2 = findAstTop(semicolon1->next(), semicolon2);
+            if (tok2)
+                semicolon2->astOperand1(tok2);
+            tok2 = findAstTop(semicolon2->next(), endPar);
+            if (tok2)
+                semicolon2->astOperand2(tok2);
+            else if (!state3.op.empty())
+                semicolon2->astOperand2(state3.op.top());
+            semicolon1->astOperand2(semicolon2);
+        } else {
+            if (!cpp || state2.op.empty() || !Token::simpleMatch(state2.op.top(), ":"))
+                throw InternalError(tok, "syntax error", InternalError::SYNTAX);
+
+            semicolon1->astOperand2(state2.op.top());
         }
-        compileExpression(tok2, state3);
 
         if (init != semicolon1)
             semicolon1->astOperand1(init->astTop());
-        tok2 = findAstTop(semicolon1->next(), semicolon2);
-        if (tok2)
-            semicolon2->astOperand1(tok2);
-        tok2 = findAstTop(semicolon2->next(), endPar);
-        if (tok2)
-            semicolon2->astOperand2(tok2);
-        else if (!state3.op.empty())
-            semicolon2->astOperand2(state3.op.top());
-
-        semicolon1->astOperand2(semicolon2);
         tok->next()->astOperand1(tok);
         tok->next()->astOperand2(semicolon1);
 
@@ -1259,62 +1770,81 @@ static Token * createAstAtToken(Token *tok, bool cpp)
         return endPar;
     }
 
-    if (cpp && Token::Match(tok, "if|switch (")) {
-        Token *semicolon = nullptr;
-        Token *tok2;
-        for (tok2 = tok->tokAt(2); tok2 && tok2->str() != ")"; tok2 = tok2->next()) {
-            if (tok2->str() == ";") {
-                if (semicolon)
-                    break;
-                semicolon = tok2;
-            }
-            if (tok2->str() == "(")
-                tok2 = tok2->link();
-        }
-        if (semicolon && tok2 == tok->linkAt(1)) {
-            tok2 = skipDecl(tok->tokAt(2));
-            Token *init1 = tok2;
-            AST_state state1(cpp);
-            compileExpression(tok2, state1);
-
-            tok2 = semicolon->next();
-            Token *expr1 = tok2;
-            AST_state state2(cpp);
-            compileExpression(tok2, state2);
-
-            semicolon->astOperand1(findAstTop(init1, semicolon->previous()));
-            semicolon->astOperand2(findAstTop(expr1, tok2));
-            tok->next()->astOperand1(tok);
-            tok->next()->astOperand2(semicolon);
-        }
-    }
-
     if (Token::simpleMatch(tok, "( {"))
         return tok;
 
     if (Token::Match(tok, "%type% <") && tok->linkAt(1) && !Token::Match(tok->linkAt(1), "> [({]"))
         return tok->linkAt(1);
 
-    if (Token::Match(tok, "%type% %name%|*|&|::") && tok->str() != "return") {
-        bool decl = false;
+    if (cpp && !tok->isKeyword() && Token::Match(tok, "%type% ::|<|%name%")) {
+        Token *tok2 = tok;
+        while (true) {
+            if (Token::Match(tok2, "%name%|> :: %name%"))
+                tok2 = tok2->tokAt(2);
+            else if (Token::Match(tok2, "%name% <") && tok2->linkAt(1))
+                tok2 = tok2->linkAt(1);
+            else
+                break;
+        }
+        if (Token::Match(tok2, "%name%|> %name% {") && tok2->next()->varId() && iscpp11init(tok2->tokAt(2))) {
+            Token *const tok1 = tok = tok2->next();
+            AST_state state(cpp);
+            compileExpression(tok, state);
+            createAstAtTokenInner(tok1->next(), tok1->linkAt(1), cpp);
+            return tok;
+        }
+    }
+
+    if ((Token::Match(tok, "%type% %name%|*|&|&&|::") && !Token::Match(tok, "return|new|delete")) ||
+        (Token::Match(tok, ":: %type%") && !tok->next()->isKeyword())) {
+        int typecount = tok->str() == "::" ? 1 : 0;
         Token *typetok = tok;
-        while (Token::Match(typetok, "%type%|::|*|&")) {
-            if (typetok->isStandardType() || Token::Match(typetok, "struct|const|static"))
-                decl = true;
+        while (Token::Match(typetok, "%type%|::|*|&|&&|<")) {
+            if (typetok->isName() && !Token::simpleMatch(typetok->previous(), "::"))
+                typecount++;
+            if (typetok->str() == "<") {
+                if (Token* closing = typetok->findClosingBracket()) {
+                    typetok = closing->next();
+                    continue;
+                }
+                break;
+            }
             typetok = typetok->next();
         }
-        if (decl && Token::Match(typetok->previous(), "[*&] %var% ="))
+        if (Token::Match(typetok, "%var% =") && typetok->varId())
             tok = typetok;
+
+        // Do not create AST for function declaration
+        if (typetok &&
+            typecount >= 2 &&
+            !Token::Match(tok, "return|throw") &&
+            Token::Match(typetok->previous(), "%name% ( !!*") &&
+            typetok->previous()->varId() == 0 &&
+            (!typetok->previous()->isKeyword() || typetok->previous()->isOperatorKeyword()) &&
+            (skipMethodDeclEnding(typetok->link()) || Token::Match(typetok->link(), ") ;|{")))
+            return typetok;
     }
 
-    if (Token::Match(tok, "return|case") || (cpp && tok->str() == "throw") || !tok->previous() || Token::Match(tok, "%name% %op%|(|[|.|::|<|?|;") || Token::Match(tok->previous(), "[;{}] %cop%|++|--|( !!{")) {
+    if (Token::Match(tok, "return|case") ||
+        (cpp && tok->str() == "throw") ||
+        !tok->previous() ||
+        Token::Match(tok, "%name% %op%|(|[|.|::|<|?|;") ||
+        (cpp && Token::Match(tok, "%name% {") && iscpp11init(tok->next())) ||
+        Token::Match(tok->previous(), "[;{}:] %cop%|++|--|( !!{") ||
+        Token::Match(tok->previous(), "[;{}] %num%|%str%|%char%") ||
+        Token::Match(tok->previous(), "[;{}] delete new") ||
+        (cpp && Token::Match(tok->previous(), "[;{}] ["))) {
         if (cpp && (Token::Match(tok->tokAt(-2), "[;{}] new|delete %name%") || Token::Match(tok->tokAt(-3), "[;{}] :: new|delete %name%")))
             tok = tok->previous();
 
         Token * const tok1 = tok;
         AST_state state(cpp);
+        if (Token::Match(tok, "%name% ("))
+            state.functionCallEndPar = tok->linkAt(1);
+        if (Token::simpleMatch(tok->tokAt(-1), "::") && (!tok->tokAt(-2) || !tok->tokAt(-2)->isName()))
+            tok = tok->tokAt(-1);
         compileExpression(tok, state);
-        const Token * const endToken = tok;
+        Token * const endToken = tok;
         if (endToken == tok1 || !endToken)
             return tok1;
 
@@ -1324,38 +1854,83 @@ static Token * createAstAtToken(Token *tok, bool cpp)
     }
 
     if (cpp && tok->str() == "{" && iscpp11init(tok)) {
+        Token * const tok1 = tok;
         AST_state state(cpp);
         compileExpression(tok, state);
-        return tok;
+        Token* const endToken = tok;
+        if (endToken == tok1 || !endToken)
+            return tok1;
+
+        createAstAtTokenInner(tok1->next(), endToken, cpp);
+        return endToken->previous();
     }
 
     return tok;
 }
 
-void TokenList::createAst()
+void TokenList::createAst() const
 {
-    for (Token *tok = mTokensFrontBack.front; tok; tok = tok ? tok->next() : nullptr) {
-        tok = createAstAtToken(tok, isCPP());
+    for (Token *tok = mTokensFrontBack->front; tok; tok = tok ? tok->next() : nullptr) {
+        Token* const nextTok = createAstAtToken(tok);
+        if (precedes(nextTok, tok))
+            throw InternalError(tok, "Syntax Error: Infinite loop when creating AST.", InternalError::AST);
+        tok = nextTok;
     }
+    for (Token *tok = mTokensFrontBack->front; tok; tok = tok ? tok->next() : nullptr) {
+        if (tok->astParent())
+            continue;
+        if (!tok->astOperand1() && !tok->astOperand2())
+            continue;
+        visitAstNodes(tok, [&](Token* child) {
+            child->astTop(tok);
+            return ChildrenToVisit::op1_and_op2;
+        });
+    }
+}
+
+namespace {
+    struct OnException {
+        std::function<void()> f;
+
+        ~OnException() {
+#ifndef _MSC_VER
+#if defined(__cpp_lib_uncaught_exceptions)
+            const bool b = std::uncaught_exceptions() > 0;
+#else
+            const bool b = std::uncaught_exception();
+#endif
+            if (b)
+                f();
+#endif
+        }
+    };
 }
 
-void TokenList::validateAst() const
+void TokenList::validateAst(bool print) const
 {
+    OnException oe{[&] {
+            if (print)
+                mTokensFrontBack->front->printOut(std::cout);
+        }};
     // Check for some known issues in AST to avoid crash/hang later on
-    std::set < const Token* > safeAstTokens; // list of "safe" AST tokens without endless recursion
-    for (const Token *tok = mTokensFrontBack.front; tok; tok = tok->next()) {
+    std::set<const Token*> safeAstTokens;    // list of "safe" AST tokens without endless recursion
+    for (const Token *tok = mTokensFrontBack->front; tok; tok = tok->next()) {
         // Syntax error if binary operator only has 1 operand
         if ((tok->isAssignmentOp() || tok->isComparisonOp() || Token::Match(tok,"[|^/%]")) && tok->astOperand1() && !tok->astOperand2())
             throw InternalError(tok, "Syntax Error: AST broken, binary operator has only one operand.", InternalError::AST);
 
         // Syntax error if we encounter "?" with operand2 that is not ":"
-        if (tok->astOperand2() && tok->str() == "?" && tok->astOperand2()->str() != ":")
-            throw InternalError(tok, "Syntax Error: AST broken, ternary operator lacks ':'.", InternalError::AST);
+        if (tok->str() == "?") {
+            if (!tok->astOperand1() || !tok->astOperand2())
+                throw InternalError(tok, "AST broken, ternary operator missing operand(s)", InternalError::AST);
+            if (tok->astOperand2()->str() != ":")
+                throw InternalError(tok, "Syntax Error: AST broken, ternary operator lacks ':'.", InternalError::AST);
+        }
 
         // Check for endless recursion
         const Token* parent = tok->astParent();
         if (parent) {
-            std::set < const Token* > astTokens; // list of anchestors
+            std::set<const Token*> astTokens;    // list of ancestors
             astTokens.insert(tok);
             do {
                 if (safeAstTokens.find(parent) != safeAstTokens.end())
@@ -1364,21 +1939,34 @@ void TokenList::validateAst() const
                     throw InternalError(tok, "AST broken: endless recursion from '" + tok->str() + "'", InternalError::AST);
                 astTokens.insert(parent);
             } while ((parent = parent->astParent()) != nullptr);
-            safeAstTokens.insert(astTokens.begin(), astTokens.end());
+            safeAstTokens.insert(astTokens.cbegin(), astTokens.cend());
         } else if (tok->str() == ";") {
             safeAstTokens.clear();
         } else {
             safeAstTokens.insert(tok);
         }
 
+        // Don't check templates
+        if (tok->str() == "<" && tok->link()) {
+            tok = tok->link();
+            continue;
+        }
+        if (tok->isCast()) {
+            if (!tok->astOperand2() && precedes(tok->astOperand1(), tok))
+                throw InternalError(tok, "AST broken: '" + tok->str() + "' has improper operand.", InternalError::AST);
+            if (tok->astOperand1() && tok->link()) { // skip casts (not part of the AST)
+                tok = tok->link();
+                continue;
+            }
+        }
+
+        if (findLambdaEndToken(tok)) { // skip lambda captures
+            tok = tok->link();
+            continue;
+        }
+
         // Check binary operators
         if (Token::Match(tok, "%or%|%oror%|%assign%|%comp%")) {
-            // Skip lambda captures
-            if (Token::Match(tok, "= ,|]"))
-                continue;
-            // Don't check templates
-            if (tok->link())
-                continue;
             // Skip pure virtual functions
             if (Token::simpleMatch(tok->previous(), ") = 0"))
                 continue;
@@ -1397,6 +1985,38 @@ void TokenList::validateAst() const
             if (!tok->astOperand1() || !tok->astOperand2())
                 throw InternalError(tok, "Syntax Error: AST broken, binary operator '" + tok->str() + "' doesn't have two operands.", InternalError::AST);
         }
+
+        if (Token::Match(tok, "++|--") && !tok->astOperand1()) {
+            throw InternalError(tok, "Syntax Error: AST broken, operator '" + tok->str() + "' doesn't have an operand.", InternalError::AST);
+        }
+
+        // Check control blocks and asserts
+        if (Token::Match(tok->previous(), "if|while|for|switch|assert|ASSERT (")) {
+            if (!tok->astOperand1() || !tok->astOperand2())
+                throw InternalError(tok,
+                                    "Syntax Error: AST broken, '" + tok->strAt(-1) +
+                                    "' doesn't have two operands.",
+                                    InternalError::AST);
+        }
+        if (tok->str() == "case" && !tok->astOperand1()) {
+            throw InternalError(tok,
+                                "Syntax Error: AST broken, 'case' doesn't have an operand.",
+                                InternalError::AST);
+        }
+
+        // Check member access
+        if (Token::Match(tok, "%var% .")) {
+            if (!tok->astParent()) {
+                throw InternalError(
+                          tok, "Syntax Error: AST broken, '" + tok->str() + "' doesn't have a parent.", InternalError::AST);
+            }
+            if (!tok->next()->astOperand1() || !tok->next()->astOperand2()) {
+                const std::string& op =
+                    tok->next()->originalName().empty() ? tok->strAt(1) : tok->next()->originalName();
+                throw InternalError(
+                          tok, "Syntax Error: AST broken, '" + op + "' doesn't have two operands.", InternalError::AST);
+            }
+        }
     }
 }
 
@@ -1412,14 +2032,14 @@ const std::string& TokenList::file(const Token *tok) const
 
 std::string TokenList::fileLine(const Token *tok) const
 {
-    return ErrorLogger::ErrorMessage::FileLocation(tok, this).stringify();
+    return ErrorMessage::FileLocation(tok, this).stringify();
 }
 
 bool TokenList::validateToken(const Token* tok) const
 {
     if (!tok)
         return true;
-    for (const Token *t = mTokensFrontBack.front; t; t = t->next()) {
+    for (const Token *t = mTokensFrontBack->front; t; t = t->next()) {
         if (tok==t)
             return true;
     }
@@ -1428,17 +2048,17 @@ bool TokenList::validateToken(const Token* tok) const
 
 void TokenList::simplifyPlatformTypes()
 {
-    const bool isCPP11  = mSettings->standards.cpp >= Standards::CPP11;
+    const bool isCPP11 = isCPP() && (mSettings.standards.cpp >= Standards::CPP11);
 
-    enum { isLongLong, isLong, isInt } type;
+    enum : std::uint8_t { isLongLong, isLong, isInt } type;
 
     /** @todo This assumes a flat address space. Not true for segmented address space (FAR *). */
 
-    if (mSettings->sizeof_size_t == mSettings->sizeof_long)
+    if (mSettings.platform.sizeof_size_t == mSettings.platform.sizeof_long)
         type = isLong;
-    else if (mSettings->sizeof_size_t == mSettings->sizeof_long_long)
+    else if (mSettings.platform.sizeof_size_t == mSettings.platform.sizeof_long_long)
         type = isLongLong;
-    else if (mSettings->sizeof_size_t == mSettings->sizeof_int)
+    else if (mSettings.platform.sizeof_size_t == mSettings.platform.sizeof_int)
         type = isInt;
     else
         return;
@@ -1463,7 +2083,7 @@ void TokenList::simplifyPlatformTypes()
         if (tok->str() == "::") {
             tok->deleteThis();
         } else if (tok->str() == "std") {
-            if (tok->next()->str() != "::")
+            if (tok->strAt(1) != "::")
                 continue;
             inStd = true;
             tok->deleteNext();
@@ -1491,13 +2111,13 @@ void TokenList::simplifyPlatformTypes()
         }
     }
 
-    const std::string platform_type(mSettings->platformString());
+    const std::string platform_type(mSettings.platform.toString());
 
     for (Token *tok = front(); tok; tok = tok->next()) {
         if (tok->tokType() != Token::eType && tok->tokType() != Token::eName)
             continue;
 
-        const Library::PlatformType * const platformtype = mSettings->library.platform_type(tok->str(), platform_type);
+        const Library::PlatformType * const platformtype = mSettings.library.platform_type(tok->str(), platform_type);
 
         if (platformtype) {
             // check for namespace
@@ -1509,40 +2129,83 @@ void TokenList::simplifyPlatformTypes()
                 tok = tok->previous();
                 tok->deleteThis();
             }
+            tok->originalName(tok->str());
+            const bool isFunctionalPtrCast = (platformtype->mConstPtr || platformtype->mPointer || platformtype->mPtrPtr) &&
+                                             Token::Match(tok, "%name% [({]") && !Token::simpleMatch(tok->linkAt(1), ") (");
+            Token* start = isFunctionalPtrCast ? tok->tokAt(1) : nullptr;
+            Token* end = isFunctionalPtrCast ? tok->linkAt(1) : nullptr;
             Token *typeToken;
-            if (platformtype->_const_ptr) {
+            if (platformtype->mConstPtr) {
                 tok->str("const");
-                tok->insertToken("*");
-                tok->insertToken(platformtype->mType);
+                tok->isSimplifiedTypedef(true);
+                tok->insertToken("*")->isSimplifiedTypedef(true);
+                tok->insertToken(platformtype->mType)->isSimplifiedTypedef(true);
                 typeToken = tok;
-            } else if (platformtype->_pointer) {
+            } else if (platformtype->mPointer) {
                 tok->str(platformtype->mType);
+                tok->isSimplifiedTypedef(true);
                 typeToken = tok;
-                tok->insertToken("*");
-            } else if (platformtype->_ptr_ptr) {
+                tok->insertToken("*")->isSimplifiedTypedef(true);
+            } else if (platformtype->mPtrPtr) {
                 tok->str(platformtype->mType);
+                tok->isSimplifiedTypedef(true);
                 typeToken = tok;
-                tok->insertToken("*");
-                tok->insertToken("*");
+                tok->insertToken("*")->isSimplifiedTypedef(true);
+                tok->insertToken("*")->isSimplifiedTypedef(true);
             } else {
-                tok->originalName(tok->str());
                 tok->str(platformtype->mType);
+                tok->isSimplifiedTypedef(true);
                 typeToken = tok;
             }
-            if (platformtype->_signed)
+            if (platformtype->mSigned)
                 typeToken->isSigned(true);
-            if (platformtype->_unsigned)
+            if (platformtype->mUnsigned)
                 typeToken->isUnsigned(true);
-            if (platformtype->_long)
+            if (platformtype->mLong)
                 typeToken->isLong(true);
+
+            if (isFunctionalPtrCast) {
+                start->str("(");
+                end->str(")");
+                if (end == start->tokAt(1))
+                    end->insertTokenBefore("0");
+                end = start->insertTokenBefore(")");
+                start = tok->insertTokenBefore("(");
+                start->isSimplifiedTypedef(true);
+                Token::createMutualLinks(start, end);
+            }
         }
     }
 }
 
 void TokenList::simplifyStdType()
 {
+    auto isVarDeclC = [](const Token* tok) -> bool {
+        if (!Token::simpleMatch(tok, "}"))
+            return false;
+        tok = tok->link()->previous();
+        while (Token::Match(tok, "%name%")) {
+            if (Token::Match(tok, "struct|union|enum"))
+                return true;
+            tok = tok->previous();
+        }
+        return false;
+    };
+
     for (Token *tok = front(); tok; tok = tok->next()) {
-        if (Token::Match(tok, "char|short|int|long|unsigned|signed|double|float") || (mSettings->standards.c >= Standards::C99 && Token::Match(tok, "complex|_Complex"))) {
+
+        if (isC() && Token::Match(tok, "const|extern *|&|%name%") && (!tok->previous() || Token::Match(tok->previous(), "[;{}]"))) {
+            if (Token::Match(tok->next(), "%name% !!;"))
+                continue;
+            if (isVarDeclC(tok->previous()))
+                continue;
+
+            tok->insertToken("int");
+            tok->next()->isImplicitInt(true);
+            continue;
+        }
+
+        if (Token::Match(tok, "char|short|int|long|unsigned|signed|double|float") || (isC() && (mSettings.standards.c >= Standards::C99) && Token::Match(tok, "complex|_Complex"))) {
             bool isFloat= false;
             bool isSigned = false;
             bool isUnsigned = false;
@@ -1565,7 +2228,7 @@ void TokenList::simplifyStdType()
                 else if (Token::Match(tok2, "float|double")) {
                     isFloat = true;
                     typeSpec = tok2;
-                } else if (mSettings->standards.c >= Standards::C99 && Token::Match(tok2, "complex|_Complex"))
+                } else if (isC() && (mSettings.standards.c >= Standards::C99) && Token::Match(tok2, "complex|_Complex"))
                     isComplex = !isFloat || tok2->str() == "_Complex" || Token::Match(tok2->next(), "*|&|%name%"); // Ensure that "complex" is not the variables name
                 else if (Token::Match(tok2, "char|int")) {
                     if (!typeSpec)
@@ -1579,6 +2242,7 @@ void TokenList::simplifyStdType()
                     tok->str("int");
                     tok->isSigned(isSigned);
                     tok->isUnsigned(isUnsigned);
+                    tok->isImplicitInt(true);
                 }
             } else {
                 typeSpec->isLong(typeSpec->isLong() || (isFloat && countLong == 1) || countLong > 1);
@@ -1600,3 +2264,96 @@ void TokenList::simplifyStdType()
     }
 }
 
+bool TokenList::isKeyword(const std::string &str) const
+{
+    if (isCPP()) {
+        const auto &cpp_keywords = Keywords::getAll(mSettings.standards.cpp);
+        const bool b = cpp_keywords.find(str) != cpp_keywords.end();
+        if (b) {
+            // TODO: integrate into keywords?
+            // types and literals are not handled as keywords
+            static const std::unordered_set<std::string> cpp_types = {"bool", "false", "true"};
+            if (cpp_types.find(str) != cpp_types.end())
+                return false;
+        }
+        return b;
+    }
+
+    const auto &c_keywords = Keywords::getAll(mSettings.standards.c);
+    const bool b = c_keywords.find(str) != c_keywords.end();
+    if (b) {
+        // TODO: integrate into Keywords?
+        // types are not handled as keywords
+        static const std::unordered_set<std::string> c_types = {"char", "double", "float", "int", "long", "short"};
+        if (c_types.find(str) != c_types.end())
+            return false;
+    }
+    return b;
+}
+
+bool TokenList::isC() const
+{
+    return mLang == Standards::Language::C;
+}
+
+bool TokenList::isCPP() const
+{
+    return mLang == Standards::Language::CPP;
+}
+
+const Token * TokenList::isFunctionHead(const Token *tok, const std::string &endsWith)
+{
+    if (!tok)
+        return nullptr;
+    if (tok->str() == "(")
+        tok = tok->link();
+    if (tok->str() != ")")
+        return nullptr;
+    if (!tok->isCpp() && !Token::Match(tok->link()->previous(), "%name%|(|)"))
+        return nullptr;
+    if (Token::Match(tok, ") ;|{|[")) {
+        tok = tok->next();
+        while (tok && tok->str() == "[" && tok->link()) {
+            if (endsWith.find(tok->str()) != std::string::npos)
+                return tok;
+            tok = tok->link()->next();
+        }
+        return (tok && endsWith.find(tok->str()) != std::string::npos) ? tok : nullptr;
+    }
+    if (tok->isCpp() && tok->str() == ")") {
+        tok = tok->next();
+        while (Token::Match(tok, "const|noexcept|override|final|volatile|mutable|&|&& !!(") ||
+               (Token::Match(tok, "%name% !!(") && tok->isUpperCaseName()))
+            tok = tok->next();
+        if (tok && tok->str() == ")")
+            tok = tok->next();
+        while (tok && tok->str() == "[")
+            tok = tok->link()->next();
+        if (Token::Match(tok, "throw|noexcept ("))
+            tok = tok->linkAt(1)->next();
+        if (Token::Match(tok, "%name% (") && tok->isUpperCaseName())
+            tok = tok->linkAt(1)->next();
+        if (tok && tok->originalName() == "->") { // trailing return type
+            for (tok = tok->next(); tok && !Token::Match(tok, ";|{|override|final|}|)|]"); tok = tok->next())
+                if (tok->link() && Token::Match(tok, "<|[|("))
+                    tok = tok->link();
+        }
+        while (Token::Match(tok, "override|final !!(") ||
+               (Token::Match(tok, "%name% !!(") && tok->isUpperCaseName()))
+            tok = tok->next();
+        if (Token::Match(tok, "= 0|default|delete ;"))
+            tok = tok->tokAt(2);
+        if (Token::simpleMatch(tok, "requires")) {
+            for (tok = tok->next(); tok && !Token::Match(tok, ";|{|}|)|]"); tok = tok->next()) {
+                if (tok->link() && Token::Match(tok, "<|[|("))
+                    tok = tok->link();
+                if (Token::simpleMatch(tok, "bool {"))
+                    tok = tok->linkAt(1);
+            }
+        }
+        if (tok && tok->str() == ":" && !Token::Match(tok->next(), "%name%|::"))
+            return nullptr;
+        return (tok && endsWith.find(tok->str()) != std::string::npos) ? tok : nullptr;
+    }
+    return nullptr;
+}
diff --git a/lib/tokenlist.h b/lib/tokenlist.h
index 58c1fbcd68a..48cf5d99547 100644
--- a/lib/tokenlist.h
+++ b/lib/tokenlist.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,13 +22,16 @@
 //---------------------------------------------------------------------------
 
 #include "config.h"
-#include "token.h"
+#include "standards.h"
 
+#include <cstddef>
+#include <cstdint>
+#include <memory>
 #include <string>
 #include <vector>
 
-class Settings;
 class Token;
+class Settings;
 
 namespace simplecpp {
     class TokenList;
@@ -37,31 +40,32 @@ namespace simplecpp {
 /// @addtogroup Core
 /// @{
 
+/**
+ * @brief This struct stores pointers to the front and back tokens of the list this token is in.
+ */
+struct TokensFrontBack {
+    Token *front{};
+    Token* back{};
+};
+
 class CPPCHECKLIB TokenList {
 public:
-    explicit TokenList(const Settings* settings);
+    explicit TokenList(const Settings& settings, Standards::Language lang);
     ~TokenList();
 
-    void setSettings(const Settings *settings) {
-        mSettings = settings;
-    }
+    TokenList(const TokenList &) = delete;
+    TokenList &operator=(const TokenList &) = delete;
 
-    const Settings *getSettings() const {
-        return mSettings;
-    }
+    TokenList(TokenList&& other) NOEXCEPT = default;
 
     /** @return the source file path. e.g. "file.cpp" */
     const std::string& getSourceFilePath() const;
 
-    /** Is the code C. Used for bailouts */
-    bool isC() const {
-        return mIsC;
-    }
+    /** @return true if the code is C */
+    bool isC() const;
 
-    /** Is the code CPP. Used for bailouts */
-    bool isCPP() const {
-        return mIsCpp;
-    }
+    /** @return true if the code is C++ */
+    bool isCPP() const;
 
     /**
      * Delete all tokens in given token list
@@ -69,10 +73,10 @@ class CPPCHECKLIB TokenList {
      */
     static void deleteTokens(Token *tok);
 
-    void addtoken(std::string str, const nonneg int lineno, const nonneg int fileno, bool split = false);
-    void addtoken(std::string str, const Token *locationTok);
+    void addtoken(const std::string& str, nonneg int lineno, nonneg int column, nonneg int fileno, bool split = false);
+    void addtoken(const std::string& str, const Token *locationTok);
 
-    void addtoken(const Token *tok, const nonneg int lineno, const nonneg int fileno);
+    void addtoken(const Token *tok, nonneg int lineno, nonneg int column, nonneg int fileno);
     void addtoken(const Token *tok, const Token *locationTok);
     void addtoken(const Token *tok);
 
@@ -86,7 +90,7 @@ class CPPCHECKLIB TokenList {
      * @param one_line true=>copy all tokens to the same line as dest. false=>copy all tokens to dest while keeping the 'line breaks'
      * @return new location of last token copied
      */
-    static Token *copyTokens(Token *dest, const Token *first, const Token *last, bool one_line = true);
+    RET_NONNULL static Token *copyTokens(Token *dest, const Token *first, const Token *last, bool one_line = true);
 
     /**
      * Create tokens from code.
@@ -94,33 +98,41 @@ class CPPCHECKLIB TokenList {
      * - multiline strings are not handled.
      * - UTF in the code are not handled.
      * - comments are not handled.
-     * @param code input stream for code
-     * @param file0 source file name
      */
-    bool createTokens(std::istream &code, const std::string& file0 = emptyString);
+    bool createTokensFromBuffer(const uint8_t* data, size_t size) {
+        return createTokensFromBuffer(reinterpret_cast<const char*>(data), size);
+    }
+    bool createTokensFromBuffer(const char* data, size_t size);
+    template<size_t size>
+    // cppcheck-suppress unusedFunction - used in tests only
+    bool createTokensFromString(const char (&data)[size]) {
+        return createTokensFromBuffer(data, size-1);
+    }
 
-    void createTokens(const simplecpp::TokenList *tokenList);
+    void createTokens(simplecpp::TokenList&& tokenList);
 
     /** Deallocate list */
     void deallocateTokens();
 
     /** append file name if seen the first time; return its index in any case */
-    int appendFileIfNew(const std::string &fileName);
+    int appendFileIfNew(std::string fileName);
 
     /** get first token of list */
     const Token *front() const {
-        return mTokensFrontBack.front;
+        return mTokensFrontBack->front;
     }
+    // NOLINTNEXTLINE(readability-make-member-function-const) - do not allow usage of mutable pointer from const object
     Token *front() {
-        return mTokensFrontBack.front;
+        return mTokensFrontBack->front;
     }
 
     /** get last token of list */
     const Token *back() const {
-        return mTokensFrontBack.back;
+        return mTokensFrontBack->back;
     }
+    // NOLINTNEXTLINE(readability-make-member-function-const) - do not allow usage of mutable pointer from const object
     Token *back() {
-        return mTokensFrontBack.back;
+        return mTokensFrontBack->back;
     }
 
     /**
@@ -149,21 +161,22 @@ class CPPCHECKLIB TokenList {
     std::string fileLine(const Token *tok) const;
 
     /**
-    * Calculates a 64-bit checksum of the token list used to compare
-    * multiple token lists with each other as quickly as possible.
-    */
-    unsigned long long calculateChecksum() const;
+     * Calculates a hash of the token list used to compare multiple
+     * token lists with each other as quickly as possible.
+     */
+    std::size_t calculateHash() const;
 
     /**
      * Create abstract syntax tree.
+     * @throws InternalError thrown if encountering an infinite loop in AST creation
      */
-    void createAst();
+    void createAst() const;
 
     /**
      * Check abstract syntax tree.
-     * Throws InternalError on failure
+     * @throws InternalError thrown if validation fails
      */
-    void validateAst() const;
+    void validateAst(bool print) const;
 
     /**
      * Verify that the given token is an element of the tokenlist.
@@ -186,16 +199,27 @@ class CPPCHECKLIB TokenList {
      */
     void simplifyStdType();
 
-private:
+    void clangSetOrigFiles();
 
-    /** Disable copy constructor, no implementation */
-    TokenList(const TokenList &);
+    bool isKeyword(const std::string &str) const;
 
-    /** Disable assignment operator, no implementation */
-    TokenList &operator=(const TokenList &);
+    /**
+     * is token pointing at function head?
+     * @param tok         A '(' or ')' token in a possible function head
+     * @param endsWith    string after function head
+     * @return token matching with endsWith if syntax seems to be a function head else nullptr
+     */
+    static const Token * isFunctionHead(const Token *tok, const std::string &endsWith);
+
+    const Settings& getSettings() const {
+        return mSettings;
+    }
+
+private:
+    bool createTokensFromBufferInternal(const char* data, std::size_t size, const std::string& file0);
 
     /** Token list */
-    TokensFrontBack mTokensFrontBack;
+    std::shared_ptr<TokensFrontBack> mTokensFrontBack;
 
     /** filenames for the tokenized source code (source + included) */
     std::vector<std::string> mFiles;
@@ -204,13 +228,16 @@ class CPPCHECKLIB TokenList {
     std::vector<std::string> mOrigFiles;
 
     /** settings */
-    const Settings* mSettings;
+    const Settings& mSettings;
 
     /** File is known to be C/C++ code */
-    bool mIsC, mIsCpp;
+    Standards::Language mLang{Standards::Language::None};
 };
 
 /// @}
 
+const Token* isLambdaCaptureList(const Token* tok);
+const Token* findLambdaEndTokenWithoutAST(const Token* tok);
+
 //---------------------------------------------------------------------------
 #endif // tokenlistH
diff --git a/lib/tokenrange.h b/lib/tokenrange.h
new file mode 100644
index 00000000000..f4b462534f9
--- /dev/null
+++ b/lib/tokenrange.h
@@ -0,0 +1,83 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+//---------------------------------------------------------------------------
+#ifndef tokenrangeH
+#define tokenrangeH
+//---------------------------------------------------------------------------
+
+#include "config.h"
+
+#include <cstddef>
+#include <iterator>
+#include <type_traits>
+
+class Token;
+
+template<typename T, REQUIRES("T must be a Token class", std::is_convertible<T*, const Token*> )>
+class TokenRangeBase {
+    T* mFront;
+    T* mBack;
+
+public:
+    TokenRangeBase(T* front, T* back) : mFront(front), mBack(back) {}
+
+    struct TokenIterator {
+        using iterator_category = std::forward_iterator_tag;
+        using value_type = T*;
+        using difference_type = std::ptrdiff_t;
+        using pointer = void;
+        using reference = T*;
+
+        T* mt;
+        TokenIterator() : mt(nullptr) {}
+        explicit TokenIterator(T* t) : mt(t) {}
+        TokenIterator& operator++() {
+            mt = mt->next();
+            return *this;
+        }
+        bool operator==(const TokenIterator& b) const {
+            return mt == b.mt;
+        }
+        bool operator!=(const TokenIterator& b) const {
+            return mt != b.mt;
+        }
+        T* operator*() const {
+            return mt;
+        }
+    };
+
+    TokenIterator begin() const {
+        return TokenIterator(mFront);
+    }
+    TokenIterator end() const {
+        return TokenIterator(mBack);
+    }
+};
+
+class TokenRange : public TokenRangeBase<Token> {
+public:
+    TokenRange(Token* front, Token* back) : TokenRangeBase<Token>(front, back) {}
+};
+
+class ConstTokenRange : public TokenRangeBase<const Token> {
+public:
+    ConstTokenRange(const Token* front, const Token* back) : TokenRangeBase<const Token>(front, back) {}
+};
+
+#endif // tokenrangeH
diff --git a/lib/utils.cpp b/lib/utils.cpp
new file mode 100644
index 00000000000..b840fc3194b
--- /dev/null
+++ b/lib/utils.cpp
@@ -0,0 +1,200 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "utils.h"
+
+#include <algorithm>
+#include <cctype>
+#include <stack>
+#include <utility>
+
+
+int caseInsensitiveStringCompare(const std::string &lhs, const std::string &rhs)
+{
+    if (lhs.size() != rhs.size())
+        return (lhs.size() < rhs.size()) ? -1 : 1;
+    for (unsigned int i = 0; i < lhs.size(); ++i) {
+        const int c1 = std::toupper(lhs[i]);
+        const int c2 = std::toupper(rhs[i]);
+        if (c1 != c2)
+            return (c1 < c2) ? -1 : 1;
+    }
+    return 0;
+}
+
+bool isValidGlobPattern(const std::string& pattern)
+{
+    int consecutiveAsterisks = 0;
+    for (auto i = pattern.cbegin(); i != pattern.cend(); ++i) {
+        if (*i == '*') {
+            ++consecutiveAsterisks;
+            if (consecutiveAsterisks > 2) {
+                return false;
+            }
+        } else if (*i == '?') {
+            if (consecutiveAsterisks > 0) {
+                return false;
+            }
+        } else {
+            consecutiveAsterisks = 0;
+        }
+    }
+    return true;
+}
+
+bool matchglob(const std::string& pattern, const std::string& name, bool caseInsensitive)
+{
+    const char* p = pattern.c_str();
+    const char* n = name.c_str();
+    std::stack<std::pair<const char*, const char*>, std::vector<std::pair<const char*, const char*>>> backtrack;
+
+    for (;;) {
+        bool matching = true;
+        while (*p != '\0' && matching) {
+            switch (*p) {
+            case '*':
+                // Step forward until we match the next character after *
+                while (*n != '\0' && *n != p[1]) {
+                    n++;
+                }
+                if (*n != '\0') {
+                    // If this isn't the last possibility, save it for later
+                    backtrack.emplace(p, n);
+                }
+                break;
+            case '?':
+                // Any character matches unless we're at the end of the name
+                if (*n != '\0') {
+                    n++;
+                } else {
+                    matching = false;
+                }
+                break;
+            default:
+                // Non-wildcard characters match literally
+                if (*n == *p) {
+                    n++;
+                } else if (caseInsensitive && tolower(*n) == tolower(*p)) {
+                    n++;
+                } else {
+                    matching = false;
+                }
+                break;
+            }
+            p++;
+        }
+
+        // If we haven't failed matching and we've reached the end of the name, then success
+        if (matching && *n == '\0') {
+            return true;
+        }
+
+        // If there are no other paths to try, then fail
+        if (backtrack.empty()) {
+            return false;
+        }
+
+        // Restore pointers from backtrack stack
+        p = backtrack.top().first;
+        n = backtrack.top().second;
+        backtrack.pop();
+
+        // Advance name pointer by one because the current position didn't work
+        n++;
+    }
+}
+
+void strTolower(std::string& str)
+{
+    // This wrapper exists because Sun's CC does not allow a static_cast
+    // from extern "C" int(*)(int) to int(*)(int).
+    std::transform(str.cbegin(), str.cend(), str.begin(), [](int c) {
+        return std::tolower(c);
+    });
+}
+
+std::string trim(const std::string& s, const std::string& t)
+{
+    const std::string::size_type beg = s.find_first_not_of(t);
+    if (beg == std::string::npos)
+        return "";
+    const std::string::size_type end = s.find_last_not_of(t);
+    return s.substr(beg, end - beg + 1);
+}
+
+void findAndReplace(std::string &source, const std::string &searchFor, const std::string &replaceWith)
+{
+    std::string::size_type index = 0;
+    while ((index = source.find(searchFor, index)) != std::string::npos) {
+        source.replace(index, searchFor.length(), replaceWith);
+        index += replaceWith.length();
+    }
+}
+
+std::string replaceEscapeSequences(const std::string &source) {
+    std::string result;
+    result.reserve(source.size());
+    for (std::size_t i = 0; i < source.size(); ++i) {
+        if (source[i] != '\\' || i + 1 >= source.size())
+            result += source[i];
+        else {
+            ++i;
+            if (source[i] == 'n') {
+                result += '\n';
+            } else if (source[i] == 'r') {
+                result += '\r';
+            } else if (source[i] == 't') {
+                result += '\t';
+            } else if (source[i] == 'x') {
+                std::string value = "0";
+                if (i + 1 < source.size() && std::isxdigit(source[i+1]))
+                    value += source[i++ + 1];
+                if (i + 1 < source.size() && std::isxdigit(source[i+1]))
+                    value += source[i++ + 1];
+                result += static_cast<char>(std::stoi(value, nullptr, 16));
+            } else if (source[i] == '0') {
+                std::string value = "0";
+                if (i + 1 < source.size() && source[i+1] >= '0' && source[i+1] <= '7')
+                    value += source[i++ + 1];
+                if (i + 1 < source.size() && source[i+1] >= '0' && source[i+1] <= '7')
+                    value += source[i++ + 1];
+                result += static_cast<char>(std::stoi(value, nullptr, 8));
+            } else {
+                result += source[i];
+            }
+        }
+    }
+    return result;
+}
+
+
+std::vector<std::string> splitString(const std::string& str, char sep)
+{
+    std::vector<std::string> l;
+
+    std::string::size_type pos1 = 0;
+    std::string::size_type pos2;
+    while (true) {
+        pos2 = str.find(sep, pos1);
+        l.push_back(str.substr(pos1, pos2 - pos1));
+        if (pos2 == std::string::npos)
+            break;
+        pos1 = pos2 + 1;
+    }
+    return l;
+}
diff --git a/lib/utils.h b/lib/utils.h
index 62953e42b98..6f410af3dbc 100644
--- a/lib/utils.h
+++ b/lib/utils.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,14 +21,96 @@
 #define utilsH
 //---------------------------------------------------------------------------
 
+#include "config.h"
+
 #include <algorithm>
-#include <cctype>
+#include <array>
 #include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <initializer_list>
+#include <limits>
+#include <stdexcept>
 #include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+struct SelectMapKeys {
+    template<class Pair>
+    // NOLINTNEXTLINE(readability-const-return-type) - false positive
+    typename Pair::first_type operator()(const Pair& p) const {
+        return p.first;
+    }
+};
+
+struct SelectMapValues {
+    template<class Pair>
+    typename Pair::second_type operator()(const Pair& p) const {
+        return p.second;
+    }
+};
+
+struct OnExit {
+    std::function<void()> f;
+
+    ~OnExit() {
+        f();
+    }
+};
+
+template<class Range, class T>
+bool contains(const Range& r, const T& x)
+{
+    return std::find(r.cbegin(), r.cend(), x) != r.cend();
+}
+
+template<class T>
+bool contains(const std::initializer_list<T>& r, const T& x)
+{
+    return std::find(r.begin(), r.end(), x) != r.end();
+}
+
+template<class T, class U>
+bool contains(const std::initializer_list<T>& r, const U& x)
+{
+    return std::find(r.begin(), r.end(), x) != r.end();
+}
+
+template<class T, class ... Ts>
+inline std::array<T, sizeof...(Ts) + 1> makeArray(T x, Ts... xs)
+{
+    return {std::move(x), std::move(xs)...};
+}
+
+// Enum hash for C++11. This is not needed in C++14
+struct EnumClassHash {
+    template<typename T>
+    std::size_t operator()(T t) const
+    {
+        return static_cast<std::size_t>(t);
+    }
+};
+
+inline bool startsWith(const std::string& str, const char start[], std::size_t startlen)
+{
+    return str.compare(0, startlen, start) == 0;
+}
+
+template<std::size_t N>
+bool startsWith(const std::string& str, const char (&start)[N])
+{
+    return startsWith(str, start, N - 1);
+}
+
+inline bool startsWith(const std::string& str, const std::string& start)
+{
+    return startsWith(str, start.c_str(), start.length());
+}
 
 inline bool endsWith(const std::string &str, char c)
 {
-    return str[str.size()-1U] == c;
+    return !str.empty() && str.back() == c;
 }
 
 inline bool endsWith(const std::string &str, const char end[], std::size_t endlen)
@@ -36,6 +118,80 @@ inline bool endsWith(const std::string &str, const char end[], std::size_t endle
     return (str.size() >= endlen) && (str.compare(str.size()-endlen, endlen, end)==0);
 }
 
+template<std::size_t N>
+bool endsWith(const std::string& str, const char (&end)[N])
+{
+    return endsWith(str, end, N - 1);
+}
+
+inline bool endsWith(const std::string& str, const std::string& end)
+{
+    return endsWith(str, end.c_str(), end.length());
+}
+
+inline static bool isPrefixStringCharLiteral(const std::string &str, char q, const std::string& p)
+{
+    // str must be at least the prefix plus the start and end quote
+    if (str.length() < p.length() + 2)
+        return false;
+
+    // check for end quote
+    if (!endsWith(str, q))
+        return false;
+
+    // check for start quote
+    if (str[p.size()] != q)
+        return false;
+
+    // check for prefix
+    if (str.compare(0, p.size(), p) != 0)
+        return false;
+
+    return true;
+}
+
+inline static bool isStringCharLiteral(const std::string &str, char q)
+{
+    // early out to avoid the loop
+    if (!endsWith(str, q))
+        return false;
+
+    static const std::array<std::string, 5> suffixes{"", "u8", "u", "U", "L"};
+    return std::any_of(suffixes.cbegin(), suffixes.cend(), [&](const std::string& p) {
+        return isPrefixStringCharLiteral(str, q, p);
+    });
+}
+
+inline static bool isStringLiteral(const std::string &str)
+{
+    return isStringCharLiteral(str, '"');
+}
+
+inline static bool isCharLiteral(const std::string &str)
+{
+    return isStringCharLiteral(str, '\'');
+}
+
+inline static std::string getStringCharLiteral(const std::string &str, char q)
+{
+    const std::size_t quotePos = str.find(q);
+    return str.substr(quotePos + 1U, str.size() - quotePos - 2U);
+}
+
+inline static std::string getStringLiteral(const std::string &str)
+{
+    if (isStringLiteral(str))
+        return getStringCharLiteral(str, '"');
+    return "";
+}
+
+inline static std::string getCharLiteral(const std::string &str)
+{
+    if (isCharLiteral(str))
+        return getStringCharLiteral(str, '\'');
+    return "";
+}
+
 inline static const char *getOrdinalText(int i)
 {
     if (i == 1)
@@ -47,45 +203,240 @@ inline static const char *getOrdinalText(int i)
     return "th";
 }
 
-inline static int caseInsensitiveStringCompare(const std::string &lhs, const std::string &rhs)
+CPPCHECKLIB int caseInsensitiveStringCompare(const std::string& lhs, const std::string& rhs);
+
+CPPCHECKLIB bool isValidGlobPattern(const std::string& pattern);
+
+CPPCHECKLIB bool matchglob(const std::string& pattern, const std::string& name, bool caseInsensitive = false);
+
+CPPCHECKLIB void strTolower(std::string& str);
+
+template<typename T, typename std::enable_if<std::is_signed<T>::value, bool>::type=true>
+bool strToInt(const std::string& str, T &num, std::string* err = nullptr)
 {
-    if (lhs.size() != rhs.size())
-        return (lhs.size() < rhs.size()) ? -1 : 1;
-    for (unsigned int i = 0; i < lhs.size(); ++i) {
-        const int c1 = std::toupper(lhs[i]);
-        const int c2 = std::toupper(rhs[i]);
-        if (c1 != c2)
-            return (c1 < c2) ? -1 : 1;
+    long long tmp;
+    try {
+        std::size_t idx = 0;
+        tmp = std::stoll(str, &idx);
+        if (idx != str.size()) {
+            if (err)
+                *err = "not an integer";
+            return false;
+        }
+    } catch (const std::out_of_range&) {
+        if (err)
+            *err = "out of range (stoll)";
+        return false;
+    } catch (const std::invalid_argument &) {
+        if (err)
+            *err = "not an integer";
+        return false;
+    }
+    if (str.front() == '-' && std::numeric_limits<T>::min() == 0) {
+        if (err)
+            *err = "needs to be positive";
+        return false;
     }
-    return 0;
+    if (tmp < std::numeric_limits<T>::min() || tmp > std::numeric_limits<T>::max()) {
+        if (err)
+            *err = "out of range (limits)";
+        return false;
+    }
+    num = static_cast<T>(tmp);
+    return true;
 }
 
-#define UNUSED(x) (void)(x)
+template<typename T, typename std::enable_if<std::is_unsigned<T>::value, bool>::type=true>
+bool strToInt(const std::string& str, T &num, std::string* err = nullptr)
+{
+    unsigned long long tmp;
+    try {
+        std::size_t idx = 0;
+        tmp = std::stoull(str, &idx);
+        if (idx != str.size()) {
+            if (err)
+                *err = "not an integer";
+            return false;
+        }
+    } catch (const std::out_of_range&) {
+        if (err)
+            *err = "out of range (stoull)";
+        return false;
+    } catch (const std::invalid_argument &) {
+        if (err)
+            *err = "not an integer";
+        return false;
+    }
+    if (str.front() == '-') {
+        if (err)
+            *err = "needs to be positive";
+        return false;
+    }
+    if (tmp > std::numeric_limits<T>::max()) {
+        if (err)
+            *err = "out of range (limits)";
+        return false;
+    }
+    num = tmp;
+    return true;
+}
 
-// Use the nonneg macro when you want to assert that a variable/argument is not negative
-#ifdef __CPPCHECK__
-#define nonneg   __cppcheck_low__(0)
-#elif defined(NONNEG)
-// Enable non-negative values checking
-// TODO : investigate using annotations/contracts for stronger value checking
-#define nonneg   unsigned
-#else
-// Disable non-negative values checking
-#define nonneg
-#endif
+/**
+ * @throws std::runtime_error thrown if conversion failed
+ */
+template<typename T>
+T strToInt(const std::string& str)
+{
+    T tmp = 0;
+    std::string err;
+    if (!strToInt(str, tmp, &err))
+        throw std::runtime_error("converting '" + str + "' to integer failed - " + err);
+    return tmp;
+}
 
-#if defined(__has_feature)
-#if __has_feature(address_sanitizer)
-#define ASAN 1
-#endif
-#endif
+/**
+ *  Simple helper function:
+ * \return size of array
+ * */
+template<typename T, int size>
+std::size_t getArrayLength(const T (& /*unused*/)[size])
+{
+    return size;
+}
+
+/**
+ * @brief get id string. i.e. for dump files
+ * it will be a hexadecimal output.
+ */
+static inline std::string id_string_i(std::uintptr_t l)
+{
+    if (!l)
+        return "0";
 
-#ifndef ASAN
-#ifdef  __SANITIZE_ADDRESS__
-#define ASAN 1
+    static constexpr int ptr_size = sizeof(void*);
+
+    // two characters of each byte / contains terminating \0
+    static constexpr int buf_size = (ptr_size * 2) + 1;
+
+    char buf[buf_size];
+
+    // needs to be signed so we don't underflow in padding loop
+    int idx = buf_size - 1;
+    buf[idx] = '\0';
+
+    while (l != 0)
+    {
+        char c;
+        const std::uintptr_t temp = l % 16; // get the remainder
+        if (temp < 10) {
+            // 0-9
+            c = '0' + temp;
+        }
+        else {
+            // a-f
+            c = 'a' + (temp - 10);
+        }
+        buf[--idx] = c; // store in reverse order
+        l = l / 16;
+    }
+
+    return &buf[idx];
+}
+
+static inline std::string id_string(const void* p)
+{
+    return id_string_i(reinterpret_cast<std::uintptr_t>(p));
+}
+
+static inline const char* bool_to_string(bool b)
+{
+    return b ? "true" : "false";
+}
+
+/**
+ * Remove heading and trailing whitespaces from the input parameter.
+ * If string is all spaces/tabs, return empty string.
+ * @param s The string to trim.
+ * @param t The characters to trim.
+ */
+CPPCHECKLIB std::string trim(const std::string& s, const std::string& t = " \t");
+
+/**
+ * Replace all occurrences of searchFor with replaceWith in the
+ * given source.
+ * @param source The string to modify
+ * @param searchFor What should be searched for
+ * @param replaceWith What will replace the found item
+ */
+CPPCHECKLIB void findAndReplace(std::string &source, const std::string &searchFor, const std::string &replaceWith);
+
+/**
+ * Replace all escape sequences in the given string.
+ * @param source The string that contains escape sequences
+ */
+CPPCHECKLIB std::string replaceEscapeSequences(const std::string &source);
+
+namespace cppcheck
+{
+    NORETURN inline void unreachable()
+    {
+#if defined(__GNUC__)
+        __builtin_unreachable();
+#elif defined(_MSC_VER)
+        __assume(false);
 #else
-#define ASAN 0
-#endif
+#error "no unreachable implementation"
 #endif
+    }
+}
+
+template<typename T>
+static inline T* default_if_null(T* p, T* def)
+{
+    return p ? p : def;
+}
+
+template<typename T>
+static inline T* empty_if_null(T* p)
+{
+    return default_if_null(p, "");
+}
+
+/**
+ * Split string by given separator.
+ * @param str The string to split
+ * @param sep The separator
+ * @return The list of separate strings (including empty ones). The whole input string if no separator found.
+ */
+CPPCHECKLIB std::vector<std::string> splitString(const std::string& str, char sep);
+
+namespace utils {
+    /**
+     * Drop-in replacement for C++17's std::as_const
+     * @param t  The function forms the lvalue reference to const type of this argument.
+     */
+    template<class T>
+    constexpr typename std::add_const<T>::type & as_const(T& t) noexcept
+    {
+        static_assert(!std::is_const<T>::value, "object is already const");
+        // NOLINTNEXTLINE(bugprone-return-const-ref-from-parameter) - potential false positive
+        return t;
+    }
+
+    // Thread-unsafe memoization
+    template<class F, class R=decltype(std::declval<F>()())>
+    static inline std::function<R()> memoize(F f)
+    {
+        bool init = false;
+        R result{};
+        return [=]() mutable -> R {
+            if (init)
+                return result;
+            result = f();
+            init = true;
+            return result;
+        };
+    }
+}
 
 #endif
diff --git a/lib/valueflow.cpp b/lib/valueflow.cpp
index 5fe9f9b81b7..f7e057da58f 100644
--- a/lib/valueflow.cpp
+++ b/lib/valueflow.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -67,7 +67,7 @@
  * ===============================
  *
  * In forward value flow analysis we know a value and see what happens when we are stepping the program forward. Like
- * normal execution. The valueFlowForwardVariable is used in this analysis.
+ * normal execution. The valueFlowForward is used in this analysis.
  *
  * In reverse value flow analysis we know the value of a variable at line X. And try to "execute backwards" to determine
  * possible values before line X. The valueFlowReverse is used in this analysis.
@@ -77,112 +77,91 @@
 
 #include "valueflow.h"
 
+#include "analyzer.h"
 #include "astutils.h"
+#include "calculate.h"
+#include "checkuninitvar.h"
+#include "config.h"
 #include "errorlogger.h"
+#include "errortypes.h"
+#include "findtoken.h"
+#include "forwardanalyzer.h"
+#include "infer.h"
 #include "library.h"
 #include "mathlib.h"
+#include "path.h"
 #include "platform.h"
+#include "programmemory.h"
+#include "reverseanalyzer.h"
 #include "settings.h"
+#include "smallvector.h"
+#include "sourcelocation.h"
 #include "standards.h"
 #include "symboldatabase.h"
+#include "timer.h"
 #include "token.h"
 #include "tokenlist.h"
 #include "utils.h"
-#include "path.h"
+#include "valueptr.h"
+#include "vfvalue.h"
+
+#include "vf_analyzers.h"
+#include "vf_common.h"
+#include "vf_settokenvalue.h"
 
 #include <algorithm>
+#include <array>
 #include <cassert>
-#include <cstddef>
+#include <chrono>
+#include <cstdint>
+#include <cstring>
 #include <functional>
+#include <initializer_list>
 #include <iterator>
 #include <limits>
 #include <map>
+#include <memory>
 #include <set>
-#include <stack>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
 #include <vector>
 
-static const int TIMEOUT = 10; // Do not repeat ValueFlow analysis more than 10 seconds
-
-namespace {
-    struct ProgramMemory {
-        std::map<int, ValueFlow::Value> values;
-
-        void setValue(nonneg int varid, const ValueFlow::Value &value) {
-            values[varid] = value;
-        }
-
-        bool getIntValue(nonneg int varid, MathLib::bigint* result) const {
-            const std::map<int, ValueFlow::Value>::const_iterator it = values.find(varid);
-            const bool found = it != values.end() && it->second.isIntValue();
-            if (found)
-                *result = it->second.intvalue;
-            return found;
-        }
-
-        void setIntValue(nonneg int varid, MathLib::bigint value) {
-            values[varid] = ValueFlow::Value(value);
-        }
-
-        bool getTokValue(nonneg int varid, const Token** result) const {
-            const std::map<int, ValueFlow::Value>::const_iterator it = values.find(varid);
-            const bool found = it != values.end() && it->second.isTokValue();
-            if (found)
-                *result = it->second.tokvalue;
-            return found;
-        }
-
-        bool hasValue(nonneg int varid) {
-            return values.find(varid) != values.end();
-        }
-
-        void swap(ProgramMemory &pm) {
-            values.swap(pm.values);
-        }
-
-        void clear() {
-            values.clear();
-        }
-
-        bool empty() const {
-            return values.empty();
-        }
-
-        void replace(const ProgramMemory &pm) {
-            for (auto&& p:pm.values)
-                values[p.first] = p.second;
-        }
-
-        void insert(const ProgramMemory &pm) {
-            for (auto&& p:pm.values)
-                values.insert(p);
-        }
-    };
+static void bailoutInternal(const std::string& type,
+                            const TokenList& tokenlist,
+                            ErrorLogger& errorLogger,
+                            const Token* tok,
+                            const std::string& what,
+                            const std::string& file,
+                            int line,
+                            std::string function)
+{
+    if (function.find("operator") != std::string::npos)
+        function = "(valueFlow)";
+    ErrorMessage::FileLocation loc(tok, &tokenlist);
+    const std::string location = Path::stripDirectoryPart(file) + ":" + std::to_string(line) + ":";
+    ErrorMessage errmsg({std::move(loc)},
+                        tokenlist.getSourceFilePath(),
+                        Severity::debug,
+                        (file.empty() ? "" : location) + function + " bailout: " + what,
+                        type,
+                        Certainty::normal);
+    errorLogger.reportErr(errmsg);
 }
 
-static void execute(const Token *expr,
-                    ProgramMemory * const programMemory,
-                    MathLib::bigint *result,
-                    bool *error);
+#define bailout2(type, tokenlist, errorLogger, tok, what)                                                              \
+    bailoutInternal((type), (tokenlist), (errorLogger), (tok), (what), __FILE__, __LINE__, __func__)
 
-static void bailoutInternal(TokenList *tokenlist, ErrorLogger *errorLogger, const Token *tok, const std::string &what, const std::string &file, int line, const std::string &function)
-{
-    std::list<ErrorLogger::ErrorMessage::FileLocation> callstack(1, ErrorLogger::ErrorMessage::FileLocation(tok, tokenlist));
-    ErrorLogger::ErrorMessage errmsg(callstack, tokenlist->getSourceFilePath(), Severity::debug,
-                                     Path::stripDirectoryPart(file) + ":" + MathLib::toString(line) + ":" + function + " bailout: " + what, "valueFlowBailout", false);
-    errorLogger->reportErr(errmsg);
-}
+#define bailout(tokenlist, errorLogger, tok, what)                                                                     \
+    bailout2("valueFlowBailout", (tokenlist), (errorLogger), (tok), (what))
 
-#if (defined __cplusplus) && __cplusplus >= 201103L
-#define bailout(tokenlist, errorLogger, tok, what) bailoutInternal(tokenlist, errorLogger, tok, what, __FILE__, __LINE__, __func__)
-#elif (defined __GNUC__) || (defined __clang__) || (defined _MSC_VER)
-#define bailout(tokenlist, errorLogger, tok, what) bailoutInternal(tokenlist, errorLogger, tok, what, __FILE__, __LINE__, __FUNCTION__)
-#else
-#define bailout(tokenlist, errorLogger, tok, what) bailoutInternal(tokenlist, errorLogger, tok, what, __FILE__, __LINE__, "(valueFlow)")
-#endif
+#define bailoutIncompleteVar(tokenlist, errorLogger, tok, what)                                                        \
+    bailoutInternal("valueFlowBailoutIncompleteVar", (tokenlist), (errorLogger), (tok), (what), "", 0, __func__)
 
-static void changeKnownToPossible(std::list<ValueFlow::Value> &values, int indirect=-1)
+static void changeKnownToPossible(std::list<ValueFlow::Value>& values, int indirect = -1)
 {
-    for (ValueFlow::Value& v: values) {
+    for (ValueFlow::Value& v : values) {
         if (indirect >= 0 && v.indirect != indirect)
             continue;
         v.changeKnownToPossible();
@@ -204,25 +183,6 @@ static void lowerToPossible(std::list<ValueFlow::Value>& values, int indirect =
     removeImpossible(values, indirect);
 }
 
-static void lowerToInconclusive(std::list<ValueFlow::Value>& values, const Settings* settings, int indirect = -1)
-{
-    if (settings->inconclusive) {
-        removeImpossible(values, indirect);
-        for (ValueFlow::Value& v : values) {
-            if (indirect >= 0 && v.indirect != indirect)
-                continue;
-            v.setInconclusive();
-        }
-    } else {
-        // Remove all values if the inconclusive flags is not set
-        values.remove_if([&](const ValueFlow::Value& v) {
-            if (indirect >= 0 && v.indirect != indirect)
-                return false;
-            return true;
-        });
-    }
-}
-
 static void changePossibleToKnown(std::list<ValueFlow::Value>& values, int indirect = -1)
 {
     for (ValueFlow::Value& v : values) {
@@ -236,44 +196,17 @@ static void changePossibleToKnown(std::list<ValueFlow::Value>& values, int indir
     }
 }
 
-/**
- * Is condition always false when variable has given value?
- * \param condition   top ast token in condition
- * \param programMemory   program memory
- */
-static bool conditionIsFalse(const Token *condition, const ProgramMemory &programMemory)
+static bool isNonConditionalPossibleIntValue(const ValueFlow::Value& v)
 {
-    if (!condition)
+    if (v.conditional)
         return false;
-    if (condition->str() == "&&") {
-        return conditionIsFalse(condition->astOperand1(), programMemory) ||
-               conditionIsFalse(condition->astOperand2(), programMemory);
-    }
-    ProgramMemory progmem(programMemory);
-    MathLib::bigint result = 0;
-    bool error = false;
-    execute(condition, &progmem, &result, &error);
-    return !error && result == 0;
-}
-
-/**
- * Is condition always true when variable has given value?
- * \param condition   top ast token in condition
- * \param programMemory   program memory
- */
-static bool conditionIsTrue(const Token *condition, const ProgramMemory &programMemory)
-{
-    if (!condition)
+    if (v.condition)
         return false;
-    if (condition->str() == "||") {
-        return conditionIsTrue(condition->astOperand1(), programMemory) ||
-               conditionIsTrue(condition->astOperand2(), programMemory);
-    }
-    ProgramMemory progmem(programMemory);
-    bool error = false;
-    MathLib::bigint result = 0;
-    execute(condition, &progmem, &result, &error);
-    return !error && result == 1;
+    if (!v.isPossible())
+        return false;
+    if (!v.isIntValue())
+        return false;
+    return true;
 }
 
 static void setValueUpperBound(ValueFlow::Value& value, bool upper)
@@ -293,40 +226,48 @@ static void setValueBound(ValueFlow::Value& value, const Token* tok, bool invert
     }
 }
 
-static void setConditionalValues(const Token *tok,
-                                 bool invert,
+static void setConditionalValue(ValueFlow::Value& value, const Token* tok, MathLib::bigint i)
+{
+    assert(value.isIntValue());
+    value.intvalue = i;
+    value.assumeCondition(tok);
+    value.setPossible();
+}
+
+static void setConditionalValues(const Token* tok,
+                                 bool lhs,
                                  MathLib::bigint value,
-                                 ValueFlow::Value &true_value,
-                                 ValueFlow::Value &false_value)
+                                 ValueFlow::Value& true_value,
+                                 ValueFlow::Value& false_value)
 {
     if (Token::Match(tok, "==|!=|>=|<=")) {
-        true_value = ValueFlow::Value{tok, value};
+        setConditionalValue(true_value, tok, value);
         const char* greaterThan = ">=";
         const char* lessThan = "<=";
-        if (invert)
+        if (lhs)
             std::swap(greaterThan, lessThan);
-        if (Token::simpleMatch(tok, greaterThan)) {
-            false_value = ValueFlow::Value{tok, value - 1};
-        } else if (Token::simpleMatch(tok, lessThan)) {
-            false_value = ValueFlow::Value{tok, value + 1};
+        if (Token::simpleMatch(tok, greaterThan, strlen(greaterThan))) {
+            setConditionalValue(false_value, tok, value - 1);
+        } else if (Token::simpleMatch(tok, lessThan, strlen(lessThan))) {
+            setConditionalValue(false_value, tok, value + 1);
         } else {
-            false_value = ValueFlow::Value{tok, value};
+            setConditionalValue(false_value, tok, value);
         }
     } else {
         const char* greaterThan = ">";
         const char* lessThan = "<";
-        if (invert)
+        if (lhs)
             std::swap(greaterThan, lessThan);
-        if (Token::simpleMatch(tok, greaterThan)) {
-            true_value = ValueFlow::Value{tok, value + 1};
-            false_value = ValueFlow::Value{tok, value};
-        } else if (Token::simpleMatch(tok, lessThan)) {
-            true_value = ValueFlow::Value{tok, value - 1};
-            false_value = ValueFlow::Value{tok, value};
+        if (Token::simpleMatch(tok, greaterThan, strlen(greaterThan))) {
+            setConditionalValue(true_value, tok, value + 1);
+            setConditionalValue(false_value, tok, value);
+        } else if (Token::simpleMatch(tok, lessThan, strlen(lessThan))) {
+            setConditionalValue(true_value, tok, value - 1);
+            setConditionalValue(false_value, tok, value);
         }
     }
-    setValueBound(true_value, tok, invert);
-    setValueBound(false_value, tok, !invert);
+    setValueBound(true_value, tok, lhs);
+    setValueBound(false_value, tok, !lhs);
 }
 
 static bool isSaturated(MathLib::bigint value)
@@ -334,1010 +275,429 @@ static bool isSaturated(MathLib::bigint value)
     return value == std::numeric_limits<MathLib::bigint>::max() || value == std::numeric_limits<MathLib::bigint>::min();
 }
 
-static const Token *parseCompareInt(const Token *tok, ValueFlow::Value &true_value, ValueFlow::Value &false_value)
+static void parseCompareEachInt(
+    const Token* tok,
+    const std::function<void(const Token* varTok, ValueFlow::Value true_value, ValueFlow::Value false_value)>& each,
+    const std::function<std::vector<ValueFlow::Value>(const Token*)>& evaluate)
 {
     if (!tok->astOperand1() || !tok->astOperand2())
-        return nullptr;
-    if (Token::Match(tok, "%comp%")) {
-        if (tok->astOperand1()->hasKnownIntValue()) {
-            MathLib::bigint value = tok->astOperand1()->values().front().intvalue;
-            if (isSaturated(value))
-                return nullptr;
-            setConditionalValues(tok, true, value, true_value, false_value);
-            return tok->astOperand2();
-        } else if (tok->astOperand2()->hasKnownIntValue()) {
-            MathLib::bigint value = tok->astOperand2()->values().front().intvalue;
-            if (isSaturated(value))
-                return nullptr;
-            setConditionalValues(tok, false, value, true_value, false_value);
-            return tok->astOperand1();
-        }
-    }
-    return nullptr;
-}
-
-static void programMemoryParseCondition(ProgramMemory& pm, const Token* tok, const Token* endTok, const Settings* settings, bool then)
-{
-    if (Token::Match(tok, "==|>=|<=|<|>|!=")) {
-        if (then && !Token::Match(tok, "==|>=|<="))
-            return;
-        if (!then && !Token::Match(tok, "<|>|!="))
-            return;
-        ValueFlow::Value truevalue;
-        ValueFlow::Value falsevalue;
-        const Token* vartok = parseCompareInt(tok, truevalue, falsevalue);
-        if (!vartok)
-            return;
-        if (vartok->varId() == 0)
-            return;
-        if (!truevalue.isIntValue())
-            return;
-        if (isVariableChanged(tok->next(), endTok, vartok->varId(), false, settings, true))
-            return;
-        pm.setIntValue(vartok->varId(),  then ? truevalue.intvalue : falsevalue.intvalue);
-    } else if (Token::Match(tok, "%var%")) {
-        if (tok->varId() == 0)
-            return;
-        if (then && !astIsPointer(tok) && !astIsBool(tok))
-            return;
-        if (isVariableChanged(tok->next(), endTok, tok->varId(), false, settings, true))
-            return;
-        pm.setIntValue(tok->varId(), then);
-    } else if (Token::simpleMatch(tok, "!")) {
-        programMemoryParseCondition(pm, tok->astOperand1(), endTok, settings, !then);
-    } else if (then && Token::simpleMatch(tok, "&&")) {
-        programMemoryParseCondition(pm, tok->astOperand1(), endTok, settings, then);
-        programMemoryParseCondition(pm, tok->astOperand2(), endTok, settings, then);
-    } else if (!then && Token::simpleMatch(tok, "||")) {
-        programMemoryParseCondition(pm, tok->astOperand1(), endTok, settings, then);
-        programMemoryParseCondition(pm, tok->astOperand2(), endTok, settings, then);
-    }
-}
-
-static void fillProgramMemoryFromConditions(ProgramMemory& pm, const Scope* scope, const Token* endTok, const Settings* settings)
-{
-    if (!scope)
         return;
-    if (!scope->isLocal())
-        return;
-    assert(scope != scope->nestedIn);
-    fillProgramMemoryFromConditions(pm, scope->nestedIn, endTok, settings);
-    if (scope->type == Scope::eIf || scope->type == Scope::eWhile || scope->type == Scope::eElse) {
-        const Token * bodyStart = scope->bodyStart;
-        if (scope->type == Scope::eElse) {
-            if (!Token::simpleMatch(bodyStart->tokAt(-2), "} else {"))
-                return;
-            bodyStart = bodyStart->linkAt(-2);
+    if (tok->isComparisonOp()) {
+        std::vector<ValueFlow::Value> value1 = evaluate(tok->astOperand1());
+        std::vector<ValueFlow::Value> value2 = evaluate(tok->astOperand2());
+        if (!value1.empty() && !value2.empty()) {
+            if (tok->astOperand1()->hasKnownIntValue())
+                value2.clear();
+            if (tok->astOperand2()->hasKnownIntValue())
+                value1.clear();
+        }
+        for (const ValueFlow::Value& v1 : value1) {
+            if (isSaturated(v1.intvalue) || astIsFloat(tok->astOperand2(), /*unknown*/ false))
+                continue;
+            ValueFlow::Value true_value = v1;
+            ValueFlow::Value false_value = v1;
+            setConditionalValues(tok, true, v1.intvalue, true_value, false_value);
+            each(tok->astOperand2(), std::move(true_value), std::move(false_value));
+        }
+        for (const ValueFlow::Value& v2 : value2) {
+            if (isSaturated(v2.intvalue) || astIsFloat(tok->astOperand1(), /*unknown*/ false))
+                continue;
+            ValueFlow::Value true_value = v2;
+            ValueFlow::Value false_value = v2;
+            setConditionalValues(tok, false, v2.intvalue, true_value, false_value);
+            each(tok->astOperand1(), std::move(true_value), std::move(false_value));
         }
-        const Token * condEndTok = bodyStart->previous();
-        if (!Token::simpleMatch(condEndTok, ") {"))
-            return;
-        const Token * condStartTok = condEndTok->link();
-        if (!condStartTok)
-            return;
-        if (!Token::Match(condStartTok->previous(), "if|while ("))
-            return;
-        const Token * condTok = condStartTok->astOperand2();
-        programMemoryParseCondition(pm, condTok, endTok, settings, scope->type != Scope::eElse);
     }
 }
 
-static void fillProgramMemoryFromConditions(ProgramMemory& pm, const Token* tok, const Settings* settings)
+static void parseCompareEachInt(
+    const Token* tok,
+    const std::function<void(const Token* varTok, ValueFlow::Value true_value, ValueFlow::Value false_value)>& each)
 {
-    fillProgramMemoryFromConditions(pm, tok->scope(), tok, settings);
+    parseCompareEachInt(tok, each, [](const Token* t) -> std::vector<ValueFlow::Value> {
+        if (const ValueFlow::Value* v = t->getKnownValue(ValueFlow::Value::ValueType::INT))
+            return {*v};
+        std::vector<ValueFlow::Value> result;
+        std::copy_if(t->values().cbegin(), t->values().cend(), std::back_inserter(result), [&](const ValueFlow::Value& v) {
+            if (v.path < 1)
+                return false;
+            if (!isNonConditionalPossibleIntValue(v))
+                return false;
+            return true;
+        });
+        return result;
+    });
 }
 
-static void fillProgramMemoryFromAssignments(ProgramMemory& pm, const Token* tok, const ProgramMemory& state, std::unordered_map<nonneg int, ValueFlow::Value> vars)
+const Token* ValueFlow::parseCompareInt(const Token* tok,
+                                        ValueFlow::Value& true_value,
+                                        ValueFlow::Value& false_value,
+                                        const std::function<std::vector<MathLib::bigint>(const Token*)>& evaluate)
 {
-    int indentlevel = 0;
-    for (const Token *tok2 = tok; tok2; tok2 = tok2->previous()) {
-        bool setvar = false;
-        if (Token::Match(tok2, "[;{}] %var% = %var% ;")) {
-            for (auto&& p:vars) {
-                if (p.first != tok2->next()->varId())
-                    continue;
-                const Token *vartok = tok2->tokAt(3);
-                pm.setValue(vartok->varId(), p.second);
-                setvar = true;
-            }
-        }
-        if (!setvar && (Token::Match(tok2, "[;{}] %var% =") ||
-                        Token::Match(tok2, "[;{}] const| %type% %var% ("))) {
-            const Token *vartok = tok2->next();
-            while (vartok->next()->isName())
-                vartok = vartok->next();
-            if (!pm.hasValue(vartok->varId())) {
-                MathLib::bigint result = 0;
-                bool error = false;
-                execute(vartok->next()->astOperand2(), &pm, &result, &error);
-                if (!error)
-                    pm.setIntValue(vartok->varId(), result);
-            }
-        }
-
-        if (tok2->str() == "{") {
-            if (indentlevel <= 0)
-                break;
-            --indentlevel;
-        }
-        if (tok2->str() == "}") {
-            const Token *cond = tok2->link();
-            cond = Token::simpleMatch(cond->previous(), ") {") ? cond->linkAt(-1) : nullptr;
-            if (cond && conditionIsFalse(cond->astOperand2(), state))
-                tok2 = cond->previous();
-            else if (cond && conditionIsTrue(cond->astOperand2(), state)) {
-                ++indentlevel;
-                continue;
-            } else
-                break;
-        }
-    }
+    const Token* result = nullptr;
+    parseCompareEachInt(
+        tok,
+        [&](const Token* vartok, ValueFlow::Value true_value2, ValueFlow::Value false_value2) {
+        if (result)
+            return;
+        result = vartok;
+        true_value = std::move(true_value2);
+        false_value = std::move(false_value2);
+    },
+        [&](const Token* t) -> std::vector<ValueFlow::Value> {
+        std::vector<ValueFlow::Value> r;
+        std::vector<MathLib::bigint> v = evaluate(t);
+
+        std::transform(v.cbegin(), v.cend(), std::back_inserter(r), [&](MathLib::bigint i) {
+            return ValueFlow::Value{i};
+        });
+        return r;
+    });
+    return result;
 }
 
-/**
- * Get program memory by looking backwards from given token.
- */
-static ProgramMemory getProgramMemory(const Token *tok, nonneg int varid, const ValueFlow::Value &value)
+const Token *ValueFlow::parseCompareInt(const Token *tok, ValueFlow::Value &true_value, ValueFlow::Value &false_value)
 {
-    ProgramMemory programMemory;
-    if (value.tokvalue)
-        fillProgramMemoryFromConditions(programMemory, value.tokvalue, nullptr);
-    if (value.condition)
-        fillProgramMemoryFromConditions(programMemory, value.condition, nullptr);
-    programMemory.setValue(varid, value);
-    if (value.varId)
-        programMemory.setIntValue(value.varId, value.varvalue);
-    const ProgramMemory state = programMemory;
-    fillProgramMemoryFromAssignments(programMemory, tok, state, {{varid, value}});
-    return programMemory;
-}
-
-/**
- * Should value be skipped because it's hidden inside && || or ?: expression.
- * Example: ((x!=NULL) && (*x == 123))
- * If 'valuetok' points at the x in '(*x == 123)'. Then the '&&' will be returned.
- * @param valuetok original variable token
- * @return NULL=>don't skip, non-NULL=>The operator token that cause the skip. For instance the '&&'.
- * */
-static const Token * skipValueInConditionalExpression(const Token * const valuetok)
-{
-    // Walk up the ast
-    const Token *prev = valuetok;
-    for (const Token *tok = valuetok->astParent(); tok; tok = tok->astParent()) {
-        const bool prevIsLhs = (prev == tok->astOperand1());
-        prev = tok;
-
-        if (prevIsLhs || !Token::Match(tok, "%oror%|&&|?|:"))
-            continue;
-
-        if (tok->hasKnownIntValue())
-            return tok;
-
-        // Is variable protected in LHS..
-        bool bailout = false;
-        visitAstNodes(tok->astOperand1(), [&](const Token *tok2) {
-            if (tok2->str() == ".")
-                return ChildrenToVisit::none;
-            // A variable is seen..
-            if (tok2 != valuetok && tok2->variable() &&
-                (tok2->varId() == valuetok->varId() || (!tok2->variable()->isArgument() && !tok2->hasKnownIntValue()))) {
-                // TODO: limit this bailout
-                bailout = true;
-                return ChildrenToVisit::done;
-            }
-            return ChildrenToVisit::op1_and_op2;
-        });
-        if (bailout)
-            return tok;
-    }
-    return nullptr;
+    return parseCompareInt(tok, true_value, false_value, [](const Token* t) -> std::vector<MathLib::bigint> {
+        if (const ValueFlow::Value* v = t->getKnownValue(Value::ValueType::INT))
+            return {v->intvalue};
+        return std::vector<MathLib::bigint>{};
+    });
 }
 
-static bool isEscapeScope(const Token* tok, TokenList * tokenlist, bool unknown = false)
+static bool isEscapeScope(const Token* tok, const Settings& settings, bool unknown = false)
 {
     if (!Token::simpleMatch(tok, "{"))
         return false;
     // TODO this search for termTok in all subscopes. It should check the end of the scope.
-    const Token * termTok = Token::findmatch(tok, "return|continue|break|throw|goto", tok->link());
+    const Token* termTok = Token::findmatch(tok, "return|continue|break|throw|goto", tok->link());
     if (termTok && termTok->scope() == tok->scope())
         return true;
     std::string unknownFunction;
-    if (tokenlist && tokenlist->getSettings()->library.isScopeNoReturn(tok->link(), &unknownFunction))
+    if (settings.library.isScopeNoReturn(tok->link(), &unknownFunction))
         return unknownFunction.empty() || unknown;
     return false;
 }
 
-static bool bailoutSelfAssignment(const Token * const tok)
+void ValueFlow::combineValueProperties(const ValueFlow::Value &value1, const ValueFlow::Value &value2, ValueFlow::Value &result)
 {
-    const Token *parent = tok;
-    while (parent) {
-        const Token *op = parent;
-        parent = parent->astParent();
+    if (value1.isKnown() && value2.isKnown())
+        result.setKnown();
+    else if (value1.isImpossible() || value2.isImpossible())
+        result.setImpossible();
+    else if (value1.isInconclusive() || value2.isInconclusive())
+        result.setInconclusive();
+    else
+        result.setPossible();
+    if (value1.tokvalue)
+        result.tokvalue = value1.tokvalue;
+    else if (value2.tokvalue)
+        result.tokvalue = value2.tokvalue;
+    if (value1.isSymbolicValue()) {
+        result.valueType = value1.valueType;
+        result.tokvalue = value1.tokvalue;
+    }
+    if (value2.isSymbolicValue()) {
+        result.valueType = value2.valueType;
+        result.tokvalue = value2.tokvalue;
+    }
+    if (value1.isIteratorValue())
+        result.valueType = value1.valueType;
+    if (value2.isIteratorValue())
+        result.valueType = value2.valueType;
+    result.condition = value1.condition ? value1.condition : value2.condition;
+    result.varId = (value1.varId != 0) ? value1.varId : value2.varId;
+    result.varvalue = (result.varId == value1.varId) ? value1.varvalue : value2.varvalue;
+    result.errorPath = (value1.errorPath.empty() ? value2 : value1).errorPath;
+    result.safe = value1.safe || value2.safe;
+    if (value1.bound == ValueFlow::Value::Bound::Point || value2.bound == ValueFlow::Value::Bound::Point) {
+        if (value1.bound == ValueFlow::Value::Bound::Upper || value2.bound == ValueFlow::Value::Bound::Upper)
+            result.bound = ValueFlow::Value::Bound::Upper;
+        if (value1.bound == ValueFlow::Value::Bound::Lower || value2.bound == ValueFlow::Value::Bound::Lower)
+            result.bound = ValueFlow::Value::Bound::Lower;
+    }
+    if (value1.path != value2.path)
+        result.path = -1;
+    else
+        result.path = value1.path;
+}
 
-        // Assignment where lhs variable exists in rhs => return true
-        if (parent                         != nullptr      &&
-            parent->astOperand2()          == op           &&
-            parent->astOperand1()          != nullptr      &&
-            parent->str()                  == "=") {
-            for (const Token *lhs = parent->astOperand1(); lhs; lhs = lhs->astOperand1()) {
-                if (lhs->varId() == tok->varId())
-                    return true;
-                if (lhs->astOperand2() && lhs->astOperand2()->varId() == tok->varId())
-                    return true;
+static void valueFlowNumber(TokenList &tokenlist, const Settings& settings)
+{
+    for (Token *tok = tokenlist.front(); tok;) {
+        tok = ValueFlow::valueFlowSetConstantValue(tok, settings);
+    }
+
+    if (tokenlist.isCPP() || settings.standards.c >= Standards::C23) {
+        for (Token *tok = tokenlist.front(); tok; tok = tok->next()) {
+            if (tok->isName() && !tok->varId() && Token::Match(tok, "%bool%")) {
+                ValueFlow::Value value(tok->str() == "true");
+                if (!tok->isTemplateArg())
+                    value.setKnown();
+                setTokenValue(tok, std::move(value), settings);
+            } else if (Token::Match(tok, "[(,] NULL [,)]")) {
+                // NULL function parameters are not simplified in the
+                // normal tokenlist
+                ValueFlow::Value value(0);
+                if (!tok->isTemplateArg())
+                    value.setKnown();
+                setTokenValue(tok->next(), std::move(value), settings);
             }
         }
     }
-    return false;
 }
 
-static ValueFlow::Value castValue(ValueFlow::Value value, const ValueType::Sign sign, nonneg int bit)
+static void valueFlowString(TokenList& tokenlist, const Settings& settings)
 {
-    if (value.isFloatValue()) {
-        value.valueType = ValueFlow::Value::INT;
-        if (value.floatValue >= std::numeric_limits<int>::min() && value.floatValue <= std::numeric_limits<int>::max()) {
-            value.intvalue = value.floatValue;
-        } else { // don't perform UB
-            value.intvalue = 0;
-        }
-    }
-    if (bit < MathLib::bigint_bits) {
-        const MathLib::biguint one = 1;
-        value.intvalue &= (one << bit) - 1;
-        if (sign == ValueType::Sign::SIGNED && value.intvalue & (one << (bit - 1))) {
-            value.intvalue |= ~((one << bit) - 1ULL);
+    for (Token* tok = tokenlist.front(); tok; tok = tok->next()) {
+        if (tok->tokType() == Token::eString) {
+            ValueFlow::Value strvalue;
+            strvalue.valueType = ValueFlow::Value::ValueType::TOK;
+            strvalue.tokvalue = tok;
+            strvalue.setKnown();
+            setTokenValue(tok, std::move(strvalue), settings);
         }
     }
-    return value;
 }
 
-static void combineValueProperties(const ValueFlow::Value &value1, const ValueFlow::Value &value2, ValueFlow::Value *result)
+static const Token* findTypeEnd(const Token* tok)
 {
-    if (value1.isKnown() && value2.isKnown())
-        result->setKnown();
-    else if (value1.isImpossible() || value2.isImpossible())
-        result->setImpossible();
-    else if (value1.isInconclusive() || value2.isInconclusive())
-        result->setInconclusive();
-    else
-        result->setPossible();
-    result->condition = value1.condition ? value1.condition : value2.condition;
-    result->varId = (value1.varId != 0U) ? value1.varId : value2.varId;
-    result->varvalue = (result->varId == value1.varId) ? value1.varvalue : value2.varvalue;
-    result->errorPath = (value1.errorPath.empty() ? value2 : value1).errorPath;
-    result->safe = value1.safe || value2.safe;
+    while (Token::Match(tok, "%name%|::|<|(|*|&|&&") && !tok->isVariable()) {
+        if (tok->link())
+            tok = tok->link();
+        tok = tok->next();
+    }
+    return tok;
 }
 
-
-static const Token *getCastTypeStartToken(const Token *parent)
+static std::vector<const Token*> evaluateType(const Token* start, const Token* end)
 {
-    // TODO: This might be a generic utility function?
-    if (!parent || parent->str() != "(")
-        return nullptr;
-    if (!parent->astOperand2() && Token::Match(parent,"( %name%"))
-        return parent->next();
-    if (parent->astOperand2() && Token::Match(parent->astOperand1(), "const_cast|dynamic_cast|reinterpret_cast|static_cast <"))
-        return parent->astOperand1()->tokAt(2);
-    return nullptr;
+    if (!start)
+        return {};
+    if (!end)
+        return {};
+    std::vector<const Token*> result;
+    for (const Token* tok = start; tok != end; tok = tok->next()) {
+        if (!Token::Match(tok, "%name%|::|<|(|*|&|&&"))
+            return {};
+        if (Token::simpleMatch(tok, "decltype (")) {
+            if (Token::Match(tok->next(), "( %name% )")) {
+                const Token* vartok = tok->tokAt(2);
+                if (vartok->function() && !vartok->variable()) {
+                    result.push_back(vartok);
+                } else {
+                    auto t = Token::typeDecl(vartok);
+                    if (!t.first || !t.second)
+                        return {};
+                    auto inner = evaluateType(t.first, t.second);
+                    if (inner.empty())
+                        return {};
+                    result.insert(result.end(), inner.begin(), inner.end());
+                }
+            } else if (Token::Match(tok->next(), "( %name% (|{") && Token::Match(tok->linkAt(3), "}|) )")) {
+                const Token* ftok = tok->tokAt(3);
+                auto t = Token::typeDecl(ftok);
+                if (!t.first || !t.second)
+                    return {};
+                auto inner = evaluateType(t.first, t.second);
+                if (inner.empty())
+                    return {};
+                result.insert(result.end(), inner.begin(), inner.end());
+            } else {
+                // We cant evaluate the decltype so bail
+                return {};
+            }
+            tok = tok->linkAt(1);
+
+        } else {
+            if (tok->link()) {
+                auto inner = evaluateType(tok->next(), tok->link());
+                if (inner.empty())
+                    return {};
+                result.push_back(tok);
+                result.insert(result.end(), inner.begin(), inner.end());
+                tok = tok->link();
+            }
+            result.push_back(tok);
+        }
+    }
+    return result;
 }
 
-/** Set token value for cast */
-static void setTokenValueCast(Token *parent, const ValueType &valueType, const ValueFlow::Value &value, const Settings *settings);
+static bool hasUnknownType(const std::vector<const Token*>& toks)
+{
+    if (toks.empty())
+        return true;
+    return std::any_of(toks.begin(), toks.end(), [&](const Token* tok) {
+        if (!tok)
+            return true;
+        if (Token::Match(tok, "const|volatile|&|*|&&|%type%|::"))
+            return false;
+        if (Token::Match(tok, "%name% :: %name%"))
+            return false;
+        if (tok->type())
+            return false;
+        return true;
+    });
+}
 
-/** set ValueFlow value and perform calculations if possible */
-static void setTokenValue(Token* tok, const ValueFlow::Value &value, const Settings *settings)
+static void stripCV(std::vector<const Token*>& toks)
 {
-    if (!tok->addValue(value))
+    auto it =
+        std::find_if(toks.begin(), toks.end(), [&](const Token* tok) {
+        return !Token::Match(tok, "const|volatile");
+    });
+    if (it == toks.begin())
         return;
+    toks.erase(toks.begin(), it);
+}
 
-    Token *parent = tok->astParent();
-    if (!parent)
-        return;
+static std::vector<std::vector<const Token*>> evaluateTemplateArgs(const Token* tok)
+{
+    std::vector<std::vector<const Token*>> result;
+    while (tok) {
+        const Token* next = tok->nextTemplateArgument();
+        const Token* end = next ? next->previous() : findTypeEnd(tok);
+        result.push_back(evaluateType(tok, end));
+        tok = next;
+    }
+    return result;
+}
 
-    if (value.isContainerSizeValue()) {
-        // .empty, .size, +"abc", +'a'
-        if (parent->str() == "+") {
-            for (const ValueFlow::Value &value1 : parent->astOperand1()->values()) {
-                for (const ValueFlow::Value &value2 : parent->astOperand2()->values()) {
-                    ValueFlow::Value result;
-                    result.valueType = ValueFlow::Value::ValueType::CONTAINER_SIZE;
-                    if (value1.isContainerSizeValue() && value2.isContainerSizeValue())
-                        result.intvalue = value1.intvalue + value2.intvalue;
-                    else if (value1.isContainerSizeValue() && value2.isTokValue() && value2.tokvalue->tokType() == Token::eString)
-                        result.intvalue = value1.intvalue + Token::getStrLength(value2.tokvalue);
-                    else if (value2.isContainerSizeValue() && value1.isTokValue() && value1.tokvalue->tokType() == Token::eString)
-                        result.intvalue = Token::getStrLength(value1.tokvalue) + value2.intvalue;
-                    else
-                        continue;
+static void valueFlowTypeTraits(TokenList& tokenlist, const Settings& settings)
+{
+    std::unordered_map<std::string, std::function<ValueFlow::Value(std::vector<std::vector<const Token*>> args)>> eval;
+    eval["is_void"] = [&](std::vector<std::vector<const Token*>> args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        stripCV(args[0]);
+        if (args[0].size() == 1 && args[0][0]->str() == "void")
+            return ValueFlow::Value(1);
+        if (!hasUnknownType(args[0]))
+            return ValueFlow::Value(0);
+        return ValueFlow::Value::unknown();
+    };
+    eval["is_lvalue_reference"] = [&](const std::vector<std::vector<const Token*>>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        if (args[0].back()->str() == "&")
+            return ValueFlow::Value(1);
+        if (!hasUnknownType(args[0]))
+            return ValueFlow::Value(0);
+        return ValueFlow::Value::unknown();
+    };
+    eval["is_rvalue_reference"] = [&](const std::vector<std::vector<const Token*>>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        if (args[0].back()->str() == "&&")
+            return ValueFlow::Value(1);
+        if (!hasUnknownType(args[0]))
+            return ValueFlow::Value(0);
+        return ValueFlow::Value::unknown();
+    };
+    eval["is_reference"] = [&](const std::vector<std::vector<const Token*>>& args) {
+        if (args.size() != 1)
+            return ValueFlow::Value::unknown();
+        ValueFlow::Value isRValue = eval["is_rvalue_reference"](args);
+        if (isRValue.isUninitValue() || isRValue.intvalue == 1)
+            return isRValue;
+        return eval["is_lvalue_reference"](args);
+    };
+    for (Token* tok = tokenlist.front(); tok; tok = tok->next()) {
+
+        if (!Token::Match(tok, "std :: %name% <"))
+            continue;
+        Token* templateTok = tok->tokAt(3);
+        Token* updateTok = nullptr;
+        std::string traitName = tok->strAt(2);
+        if (endsWith(traitName, "_v")) {
+            traitName.pop_back();
+            traitName.pop_back();
+            updateTok = tok->next();
+        } else if (Token::simpleMatch(templateTok->link(), "> { }") ||
+                   Token::simpleMatch(templateTok->link(), "> :: value")) {
+            updateTok = templateTok->link()->next();
+        }
+        if (!updateTok)
+            continue;
+        if (updateTok->hasKnownIntValue())
+            continue;
+        if (eval.count(traitName) == 0)
+            continue;
+        auto args = evaluateTemplateArgs(templateTok->next());
+        if (std::any_of(args.begin(), args.end(), [](const std::vector<const Token*>& arg) {
+            return arg.empty();
+        }))
+            continue;
+        ValueFlow::Value value = eval[traitName](std::move(args));
+        if (value.isUninitValue())
+            continue;
+        value.setKnown();
+        ValueFlow::setTokenValue(updateTok, std::move(value), settings);
+    }
+}
 
-                    combineValueProperties(value1, value2, &result);
+static void valueFlowArray(TokenList& tokenlist, const Settings& settings)
+{
+    std::map<nonneg int, const Token*> constantArrays;
 
-                    setTokenValue(parent, result, settings);
-                }
+    for (Token* tok = tokenlist.front(); tok; tok = tok->next()) {
+        if (tok->varId() > 0) {
+            // array
+            const auto it = utils::as_const(constantArrays).find(tok->varId());
+            if (it != constantArrays.end()) {
+                ValueFlow::Value value;
+                value.valueType = ValueFlow::Value::ValueType::TOK;
+                value.tokvalue = it->second;
+                value.setKnown();
+                setTokenValue(tok, std::move(value), settings);
             }
-        }
 
+            // const array decl
+            else if (tok->variable() && tok->variable()->isArray() && tok->variable()->isConst() &&
+                     tok->variable()->nameToken() == tok && Token::Match(tok, "%var% [ %num%| ] = {")) {
+                Token* rhstok = tok->linkAt(1)->tokAt(2);
+                constantArrays[tok->varId()] = rhstok;
+                tok = rhstok->link();
+            }
 
-        else if (Token::Match(parent, ". %name% (") && parent->astParent() == parent->tokAt(2) && parent->astOperand1() && parent->astOperand1()->valueType()) {
-            const Library::Container *c = parent->astOperand1()->valueType()->container;
-            const Library::Container::Yield yields = c ? c->getYield(parent->strAt(1)) : Library::Container::Yield::NO_YIELD;
-            if (yields == Library::Container::Yield::SIZE) {
-                ValueFlow::Value v(value);
-                v.valueType = ValueFlow::Value::ValueType::INT;
-                setTokenValue(parent->astParent(), v, settings);
-            } else if (yields == Library::Container::Yield::EMPTY) {
-                ValueFlow::Value v(value);
-                v.intvalue = !v.intvalue;
-                v.valueType = ValueFlow::Value::ValueType::INT;
-                setTokenValue(parent->astParent(), v, settings);
+            // pointer = array
+            else if (tok->variable() && tok->variable()->isArray() && Token::simpleMatch(tok->astParent(), "=") &&
+                     astIsRHS(tok) && tok->astParent()->astOperand1() && tok->astParent()->astOperand1()->variable() &&
+                     tok->astParent()->astOperand1()->variable()->isPointer()) {
+                ValueFlow::Value value;
+                value.valueType = ValueFlow::Value::ValueType::TOK;
+                value.tokvalue = tok;
+                value.setKnown();
+                setTokenValue(tok, std::move(value), settings);
             }
+            continue;
         }
 
-        return;
-    }
-
-    if (value.isLifetimeValue()) {
-        if (value.lifetimeKind == ValueFlow::Value::LifetimeKind::Iterator && astIsIterator(parent)) {
-            setTokenValue(parent,value,settings);
-        } else if (astIsPointer(tok) && astIsPointer(parent) &&
-                   (parent->isArithmeticalOp() || Token::Match(parent, "( %type%"))) {
-            setTokenValue(parent,value,settings);
+        if (Token::Match(tok, "const %type% %var% [ %num%| ] = {")) {
+            Token* vartok = tok->tokAt(2);
+            Token* rhstok = vartok->linkAt(1)->tokAt(2);
+            constantArrays[vartok->varId()] = rhstok;
+            tok = rhstok->link();
+            continue;
         }
-        return;
-    }
 
-    if (value.isUninitValue()) {
-        ValueFlow::Value pvalue = value;
-        if (parent->isUnaryOp("&")) {
-            pvalue.indirect++;
-            setTokenValue(parent, pvalue, settings);
-        } else if (Token::Match(parent, ". %var%") && parent->astOperand1() == tok) {
-            if (parent->originalName() == "->" && pvalue.indirect > 0)
-                pvalue.indirect--;
-            setTokenValue(parent->astOperand2(), pvalue, settings);
-        } else if (Token::Match(parent->astParent(), ". %var%") && parent->astParent()->astOperand1() == parent) {
-            if (parent->astParent()->originalName() == "->" && pvalue.indirect > 0)
-                pvalue.indirect--;
-            setTokenValue(parent->astParent()->astOperand2(), pvalue, settings);
-        } else if (parent->isUnaryOp("*") && pvalue.indirect > 0) {
-            pvalue.indirect--;
-            setTokenValue(parent, pvalue, settings);
+        if (Token::Match(tok, "const char %var% [ %num%| ] = %str% ;")) {
+            Token* vartok = tok->tokAt(2);
+            Token* strtok = vartok->linkAt(1)->tokAt(2);
+            constantArrays[vartok->varId()] = strtok;
+            tok = strtok->next();
+            continue;
         }
-        return;
-    }
-
-    // cast..
-    if (const Token *castType = getCastTypeStartToken(parent)) {
-        if (astIsPointer(tok) && value.valueType == ValueFlow::Value::INT &&
-            Token::simpleMatch(parent->astOperand1(), "dynamic_cast"))
-            return;
-        const ValueType &valueType = ValueType::parseDecl(castType, settings);
-        setTokenValueCast(parent, valueType, value, settings);
     }
+}
 
-    else if (parent->str() == ":") {
-        setTokenValue(parent,value,settings);
-    }
+static bool isNonZero(const Token* tok)
+{
+    return tok && (!tok->hasKnownIntValue() || tok->getKnownIntValue() != 0);
+}
 
-    else if (parent->str() == "?" && tok->str() == ":" && tok == parent->astOperand2() && parent->astOperand1()) {
-        // is condition always true/false?
-        if (parent->astOperand1()->hasKnownValue()) {
-            const ValueFlow::Value &condvalue = parent->astOperand1()->values().front();
-            const bool cond(condvalue.isTokValue() || (condvalue.isIntValue() && condvalue.intvalue != 0));
-            if (cond && !tok->astOperand1()) { // true condition, no second operator
-                setTokenValue(parent, condvalue, settings);
-            } else {
-                const Token *op = cond ? tok->astOperand1() : tok->astOperand2();
-                if (!op) // #7769 segmentation fault at setTokenValue()
-                    return;
-                const std::list<ValueFlow::Value> &values = op->values();
-                if (std::find(values.begin(), values.end(), value) != values.end())
-                    setTokenValue(parent, value, settings);
-            }
-        } else {
-            // is condition only depending on 1 variable?
-            int varId = 0;
-            bool ret = false;
-            visitAstNodes(parent->astOperand1(),
-            [&](const Token *t) {
-                if (t->varId()) {
-                    if (varId > 0 || value.varId != 0U)
-                        ret = true;
-                    varId = t->varId();
-                } else if (t->str() == "(" && Token::Match(t->previous(), "%name%"))
-                    ret = true; // function call
-                return ret ? ChildrenToVisit::done : ChildrenToVisit::op1_and_op2;
-            });
-            if (ret)
-                return;
-
-            ValueFlow::Value v(value);
-            v.conditional = true;
-            v.changeKnownToPossible();
-
-            if (varId)
-                v.varId = varId;
-
-            setTokenValue(parent, v, settings);
-        }
-    }
-
-    // Calculations..
-    else if ((parent->isArithmeticalOp() || parent->isComparisonOp() || (parent->tokType() == Token::eBitOp) || (parent->tokType() == Token::eLogicalOp)) &&
-             parent->astOperand1() &&
-             parent->astOperand2()) {
-
-        const bool noninvertible = parent->isComparisonOp() || Token::Match(parent, "%|/|&|%or%");
-
-        // Skip operators with impossible values that are not invertible
-        if (noninvertible && value.isImpossible())
-            return;
-
-        // known result when a operand is 0.
-        if (Token::Match(parent, "[&*]") && value.isKnown() && value.isIntValue() && value.intvalue==0) {
-            setTokenValue(parent, value, settings);
-            return;
-        }
-
-        // known result when a operand is true.
-        if (Token::simpleMatch(parent, "&&") && value.isKnown() && value.isIntValue() && value.intvalue==0) {
-            setTokenValue(parent, value, settings);
-            return;
-        }
-
-        // known result when a operand is false.
-        if (Token::simpleMatch(parent, "||") && value.isKnown() && value.isIntValue() && value.intvalue!=0) {
-            setTokenValue(parent, value, settings);
-            return;
-        }
-
-        for (const ValueFlow::Value &value1 : parent->astOperand1()->values()) {
-            if (noninvertible && value1.isImpossible())
-                continue;
-            if (!value1.isIntValue() && !value1.isFloatValue() && !value1.isTokValue())
-                continue;
-            if (value1.isTokValue() && (!parent->isComparisonOp() || value1.tokvalue->tokType() != Token::eString))
-                continue;
-            for (const ValueFlow::Value &value2 : parent->astOperand2()->values()) {
-                if (noninvertible && value2.isImpossible())
-                    continue;
-                if (!value2.isIntValue() && !value2.isFloatValue() && !value2.isTokValue())
-                    continue;
-                if (value2.isTokValue() && (!parent->isComparisonOp() || value2.tokvalue->tokType() != Token::eString || value1.isTokValue()))
-                    continue;
-                if (value1.isKnown() || value2.isKnown() || value1.varId == 0U || value2.varId == 0U ||
-                    (value1.varId == value2.varId && value1.varvalue == value2.varvalue && value1.isIntValue() &&
-                     value2.isIntValue())) {
-                    ValueFlow::Value result(0);
-                    combineValueProperties(value1, value2, &result);
-                    const float floatValue1 = value1.isIntValue() ? value1.intvalue : value1.floatValue;
-                    const float floatValue2 = value2.isIntValue() ? value2.intvalue : value2.floatValue;
-                    switch (parent->str()[0]) {
-                    case '+':
-                        if (value1.isTokValue() || value2.isTokValue())
-                            break;
-                        if (value1.isFloatValue() || value2.isFloatValue()) {
-                            result.valueType = ValueFlow::Value::FLOAT;
-                            result.floatValue = floatValue1 + floatValue2;
-                        } else {
-                            result.intvalue = value1.intvalue + value2.intvalue;
-                        }
-                        setTokenValue(parent, result, settings);
-                        break;
-                    case '-':
-                        if (value1.isTokValue() || value2.isTokValue())
-                            break;
-                        if (value1.isFloatValue() || value2.isFloatValue()) {
-                            result.valueType = ValueFlow::Value::FLOAT;
-                            result.floatValue = floatValue1 - floatValue2;
-                        } else {
-                            result.intvalue = value1.intvalue - value2.intvalue;
-                        }
-                        setTokenValue(parent, result, settings);
-                        break;
-                    case '*':
-                        if (value1.isTokValue() || value2.isTokValue())
-                            break;
-                        if (value1.isFloatValue() || value2.isFloatValue()) {
-                            result.valueType = ValueFlow::Value::FLOAT;
-                            result.floatValue = floatValue1 * floatValue2;
-                        } else {
-                            result.intvalue = value1.intvalue * value2.intvalue;
-                        }
-                        setTokenValue(parent, result, settings);
-                        break;
-                    case '/':
-                        if (value1.isTokValue() || value2.isTokValue() || value2.intvalue == 0)
-                            break;
-                        if (value1.isFloatValue() || value2.isFloatValue()) {
-                            result.valueType = ValueFlow::Value::FLOAT;
-                            result.floatValue = floatValue1 / floatValue2;
-                        } else {
-                            result.intvalue = value1.intvalue / value2.intvalue;
-                        }
-                        setTokenValue(parent, result, settings);
-                        break;
-                    case '%':
-                        if (!value1.isIntValue() || !value2.isIntValue())
-                            break;
-                        if (value2.intvalue == 0)
-                            break;
-                        result.intvalue = value1.intvalue % value2.intvalue;
-                        setTokenValue(parent, result, settings);
-                        break;
-                    case '=':
-                        if (parent->str() == "==") {
-                            if ((value1.isIntValue() && value2.isTokValue()) ||
-                                (value1.isTokValue() && value2.isIntValue())) {
-                                result.intvalue = 0;
-                                setTokenValue(parent, result, settings);
-                            } else if (value1.isIntValue() && value2.isIntValue()) {
-                                result.intvalue = value1.intvalue == value2.intvalue;
-                                setTokenValue(parent, result, settings);
-                            }
-                        }
-                        break;
-                    case '!':
-                        if (parent->str() == "!=") {
-                            if ((value1.isIntValue() && value2.isTokValue()) ||
-                                (value1.isTokValue() && value2.isIntValue())) {
-                                result.intvalue = 1;
-                                setTokenValue(parent, result, settings);
-                            } else if (value1.isIntValue() && value2.isIntValue()) {
-                                result.intvalue = value1.intvalue != value2.intvalue;
-                                setTokenValue(parent, result, settings);
-                            }
-                        }
-                        break;
-                    case '>': {
-                        const bool f = value1.isFloatValue() || value2.isFloatValue();
-                        if (!f && !value1.isIntValue() && !value2.isIntValue())
-                            break;
-                        if (parent->str() == ">")
-                            result.intvalue = f ? (floatValue1 > floatValue2) : (value1.intvalue > value2.intvalue);
-                        else if (parent->str() == ">=")
-                            result.intvalue = f ? (floatValue1 >= floatValue2) : (value1.intvalue >= value2.intvalue);
-                        else if (!f && parent->str() == ">>" && value1.intvalue >= 0 && value2.intvalue >= 0 && value2.intvalue < MathLib::bigint_bits)
-                            result.intvalue = value1.intvalue >> value2.intvalue;
-                        else
-                            break;
-                        setTokenValue(parent, result, settings);
-                        break;
-                    }
-                    case '<': {
-                        const bool f = value1.isFloatValue() || value2.isFloatValue();
-                        if (!f && !value1.isIntValue() && !value2.isIntValue())
-                            break;
-                        if (parent->str() == "<")
-                            result.intvalue = f ? (floatValue1 < floatValue2) : (value1.intvalue < value2.intvalue);
-                        else if (parent->str() == "<=")
-                            result.intvalue = f ? (floatValue1 <= floatValue2) : (value1.intvalue <= value2.intvalue);
-                        else if (!f && parent->str() == "<<" && value1.intvalue >= 0 && value2.intvalue >= 0 && value2.intvalue < MathLib::bigint_bits)
-                            result.intvalue = value1.intvalue << value2.intvalue;
-                        else
-                            break;
-                        setTokenValue(parent, result, settings);
-                        break;
-                    }
-                    case '&':
-                        if (!value1.isIntValue() || !value2.isIntValue())
-                            break;
-                        if (parent->str() == "&")
-                            result.intvalue = value1.intvalue & value2.intvalue;
-                        else
-                            result.intvalue = value1.intvalue && value2.intvalue;
-                        setTokenValue(parent, result, settings);
-                        break;
-                    case '|':
-                        if (!value1.isIntValue() || !value2.isIntValue())
-                            break;
-                        if (parent->str() == "|")
-                            result.intvalue = value1.intvalue | value2.intvalue;
-                        else
-                            result.intvalue = value1.intvalue || value2.intvalue;
-                        setTokenValue(parent, result, settings);
-                        break;
-                    case '^':
-                        if (!value1.isIntValue() || !value2.isIntValue())
-                            break;
-                        result.intvalue = value1.intvalue ^ value2.intvalue;
-                        setTokenValue(parent, result, settings);
-                        break;
-                    default:
-                        // unhandled operator, do nothing
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
-    // !
-    else if (parent->str() == "!") {
-        for (const ValueFlow::Value &val : tok->values()) {
-            if (!val.isIntValue())
-                continue;
-            ValueFlow::Value v(val);
-            v.intvalue = !v.intvalue;
-            setTokenValue(parent, v, settings);
-        }
-    }
-
-    // ~
-    else if (parent->str() == "~") {
-        for (const ValueFlow::Value &val : tok->values()) {
-            if (!val.isIntValue())
-                continue;
-            ValueFlow::Value v(val);
-            v.intvalue = ~v.intvalue;
-            int bits = 0;
-            if (settings &&
-                tok->valueType() &&
-                tok->valueType()->sign == ValueType::Sign::UNSIGNED &&
-                tok->valueType()->pointer == 0) {
-                if (tok->valueType()->type == ValueType::Type::INT)
-                    bits = settings->int_bit;
-                else if (tok->valueType()->type == ValueType::Type::LONG)
-                    bits = settings->long_bit;
-            }
-            if (bits > 0 && bits < MathLib::bigint_bits)
-                v.intvalue &= (((MathLib::biguint)1)<<bits) - 1;
-            setTokenValue(parent, v, settings);
-        }
-    }
-
-    // unary minus
-    else if (parent->isUnaryOp("-")) {
-        for (const ValueFlow::Value &val : tok->values()) {
-            if (!val.isIntValue() && !val.isFloatValue())
-                continue;
-            ValueFlow::Value v(val);
-            if (v.isIntValue())
-                v.intvalue = -v.intvalue;
-            else
-                v.floatValue = -v.floatValue;
-            setTokenValue(parent, v, settings);
-        }
-    }
-
-    // Array element
-    else if (parent->str() == "[" && parent->isBinaryOp()) {
-        for (const ValueFlow::Value &value1 : parent->astOperand1()->values()) {
-            if (!value1.isTokValue())
-                continue;
-            for (const ValueFlow::Value &value2 : parent->astOperand2()->values()) {
-                if (!value2.isIntValue())
-                    continue;
-                if (value1.varId == 0U || value2.varId == 0U ||
-                    (value1.varId == value2.varId && value1.varvalue == value2.varvalue)) {
-                    ValueFlow::Value result(0);
-                    result.condition = value1.condition ? value1.condition : value2.condition;
-                    result.setInconclusive(value1.isInconclusive() | value2.isInconclusive());
-                    result.varId = (value1.varId != 0U) ? value1.varId : value2.varId;
-                    result.varvalue = (result.varId == value1.varId) ? value1.intvalue : value2.intvalue;
-                    if (value1.valueKind == value2.valueKind)
-                        result.valueKind = value1.valueKind;
-                    if (value1.tokvalue->tokType() == Token::eString) {
-                        const std::string s = value1.tokvalue->strValue();
-                        const MathLib::bigint index = value2.intvalue;
-                        if (index == s.size()) {
-                            result.intvalue = 0;
-                            setTokenValue(parent, result, settings);
-                        } else if (index >= 0 && index < s.size()) {
-                            result.intvalue = s[index];
-                            setTokenValue(parent, result, settings);
-                        }
-                    } else if (value1.tokvalue->str() == "{") {
-                        MathLib::bigint index = value2.intvalue;
-                        const Token *element = value1.tokvalue->next();
-                        while (index > 0 && element->str() != "}") {
-                            if (element->str() == ",")
-                                --index;
-                            if (Token::Match(element, "[{}()[]]"))
-                                break;
-                            element = element->next();
-                        }
-                        if (Token::Match(element, "%num% [,}]")) {
-                            result.intvalue = MathLib::toLongNumber(element->str());
-                            setTokenValue(parent, result, settings);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-static void setTokenValueCast(Token *parent, const ValueType &valueType, const ValueFlow::Value &value, const Settings *settings)
-{
-    if (valueType.pointer)
-        setTokenValue(parent,value,settings);
-    else if (valueType.type == ValueType::Type::CHAR)
-        setTokenValue(parent, castValue(value, valueType.sign, settings->char_bit), settings);
-    else if (valueType.type == ValueType::Type::SHORT)
-        setTokenValue(parent, castValue(value, valueType.sign, settings->short_bit), settings);
-    else if (valueType.type == ValueType::Type::INT)
-        setTokenValue(parent, castValue(value, valueType.sign, settings->int_bit), settings);
-    else if (valueType.type == ValueType::Type::LONG)
-        setTokenValue(parent, castValue(value, valueType.sign, settings->long_bit), settings);
-    else if (valueType.type == ValueType::Type::LONGLONG)
-        setTokenValue(parent, castValue(value, valueType.sign, settings->long_long_bit), settings);
-    else if (value.isIntValue()) {
-        const long long charMax = settings->signedCharMax();
-        const long long charMin = settings->signedCharMin();
-        if (charMin <= value.intvalue && value.intvalue <= charMax) {
-            // unknown type, but value is small so there should be no truncation etc
-            setTokenValue(parent,value,settings);
-        }
-    }
-}
-
-static nonneg int getSizeOfType(const Token *typeTok, const Settings *settings)
-{
-    const std::string &typeStr = typeTok->str();
-    if (typeStr == "char")
-        return 1;
-    else if (typeStr == "short")
-        return settings->sizeof_short;
-    else if (typeStr == "int")
-        return settings->sizeof_int;
-    else if (typeStr == "long")
-        return typeTok->isLong() ? settings->sizeof_long_long : settings->sizeof_long;
-    else if (typeStr == "wchar_t")
-        return settings->sizeof_wchar_t;
-    else
-        return 0;
-}
-
-static size_t getSizeOf(const ValueType &vt, const Settings *settings)
-{
-    if (vt.pointer)
-        return settings->sizeof_pointer;
-    else if (vt.type == ValueType::Type::CHAR)
-        return 1;
-    else if (vt.type == ValueType::Type::SHORT)
-        return settings->sizeof_short;
-    else if (vt.type == ValueType::Type::WCHAR_T)
-        return settings->sizeof_wchar_t;
-    else if (vt.type == ValueType::Type::INT)
-        return settings->sizeof_int;
-    else if (vt.type == ValueType::Type::LONG)
-        return settings->sizeof_long;
-    else if (vt.type == ValueType::Type::LONGLONG)
-        return settings->sizeof_long_long;
-    else if (vt.type == ValueType::Type::FLOAT)
-        return settings->sizeof_float;
-    else if (vt.type == ValueType::Type::DOUBLE)
-        return settings->sizeof_double;
-
-    return 0;
-}
-
-// Handle various constants..
-static Token * valueFlowSetConstantValue(Token *tok, const Settings *settings, bool cpp)
-{
-    if ((tok->isNumber() && MathLib::isInt(tok->str())) || (tok->tokType() == Token::eChar)) {
-        ValueFlow::Value value(MathLib::toLongNumber(tok->str()));
-        if (!tok->isTemplateArg())
-            value.setKnown();
-        setTokenValue(tok, value, settings);
-    } else if (tok->isNumber() && MathLib::isFloat(tok->str())) {
-        ValueFlow::Value value;
-        value.valueType = ValueFlow::Value::FLOAT;
-        value.floatValue = MathLib::toDoubleNumber(tok->str());
-        if (!tok->isTemplateArg())
-            value.setKnown();
-        setTokenValue(tok, value, settings);
-    } else if (tok->enumerator() && tok->enumerator()->value_known) {
-        ValueFlow::Value value(tok->enumerator()->value);
-        if (!tok->isTemplateArg())
-            value.setKnown();
-        setTokenValue(tok, value, settings);
-    } else if (tok->str() == "NULL" || (cpp && tok->str() == "nullptr")) {
-        ValueFlow::Value value(0);
-        if (!tok->isTemplateArg())
-            value.setKnown();
-        setTokenValue(tok, value, settings);
-    } else if (Token::simpleMatch(tok, "sizeof (")) {
-        const Token *tok2 = tok->tokAt(2);
-        // skip over tokens to find variable or type
-        while (Token::Match(tok2, "%name% ::|.|[")) {
-            if (tok2->next()->str() == "[")
-                tok2 = tok2->linkAt(1)->next();
-            else
-                tok2 = tok2->tokAt(2);
-        }
-        if (Token::simpleMatch(tok, "sizeof ( *")) {
-            const ValueType *vt = tok->tokAt(2)->valueType();
-            const size_t sz = vt ? getSizeOf(*vt, settings) : 0;
-            if (sz > 0) {
-                ValueFlow::Value value(sz);
-                if (!tok2->isTemplateArg() && settings->platformType != cppcheck::Platform::Unspecified)
-                    value.setKnown();
-                setTokenValue(tok->next(), value, settings);
-            }
-        } else if (tok2->enumerator() && tok2->enumerator()->scope) {
-            long long size = settings->sizeof_int;
-            const Token * type = tok2->enumerator()->scope->enumType;
-            if (type) {
-                size = getSizeOfType(type, settings);
-            }
-            ValueFlow::Value value(size);
-            if (!tok2->isTemplateArg() && settings->platformType != cppcheck::Platform::Unspecified)
-                value.setKnown();
-            setTokenValue(tok, value, settings);
-            setTokenValue(tok->next(), value, settings);
-        } else if (tok2->type() && tok2->type()->isEnumType()) {
-            long long size = settings->sizeof_int;
-            if (tok2->type()->classScope) {
-                const Token * type = tok2->type()->classScope->enumType;
-                if (type) {
-                    size = getSizeOfType(type, settings);
-                }
-            }
-            ValueFlow::Value value(size);
-            if (!tok2->isTemplateArg() && settings->platformType != cppcheck::Platform::Unspecified)
-                value.setKnown();
-            setTokenValue(tok, value, settings);
-            setTokenValue(tok->next(), value, settings);
-        } else if (Token::Match(tok, "sizeof ( %var% ) / sizeof (") && tok->next()->astParent() == tok->tokAt(4)) {
-            // Get number of elements in array
-            const Token *sz1 = tok->tokAt(2);
-            const Token *sz2 = tok->tokAt(7);
-            const int varid1 = sz1->varId();
-            if (varid1 &&
-                sz1->variable() &&
-                sz1->variable()->isArray() &&
-                !sz1->variable()->dimensions().empty() &&
-                sz1->variable()->dimensionKnown(0) &&
-                (Token::Match(sz2, "* %varid% )", varid1) || Token::Match(sz2, "%varid% [ 0 ] )", varid1))) {
-                ValueFlow::Value value(sz1->variable()->dimension(0));
-                if (!tok2->isTemplateArg() && settings->platformType != cppcheck::Platform::Unspecified)
-                    value.setKnown();
-                setTokenValue(tok->tokAt(4), value, settings);
-            }
-        } else if (Token::Match(tok2, "%var% )")) {
-            const Variable *var = tok2->variable();
-            // only look for single token types (no pointers or references yet)
-            if (var && var->typeStartToken() == var->typeEndToken()) {
-                // find the size of the type
-                size_t size = 0;
-                if (var->isEnumType()) {
-                    size = settings->sizeof_int;
-                    if (var->type()->classScope && var->type()->classScope->enumType)
-                        size = getSizeOfType(var->type()->classScope->enumType, settings);
-                } else if (var->valueType()) {
-                    size = getSizeOf(*var->valueType(), settings);
-                } else if (!var->type()) {
-                    size = getSizeOfType(var->typeStartToken(), settings);
-                }
-                // find the number of elements
-                size_t count = 1;
-                for (size_t i = 0; i < var->dimensions().size(); ++i) {
-                    if (var->dimensionKnown(i))
-                        count *= var->dimension(i);
-                    else
-                        count = 0;
-                }
-                if (size && count > 0) {
-                    ValueFlow::Value value(count * size);
-                    if (settings->platformType != cppcheck::Platform::Unspecified)
-                        value.setKnown();
-                    setTokenValue(tok, value, settings);
-                    setTokenValue(tok->next(), value, settings);
-                }
-            }
-        } else if (!tok2->type()) {
-            const ValueType &vt = ValueType::parseDecl(tok2,settings);
-            const size_t sz = getSizeOf(vt, settings);
-            if (sz > 0) {
-                ValueFlow::Value value(sz);
-                if (!tok2->isTemplateArg() && settings->platformType != cppcheck::Platform::Unspecified)
-                    value.setKnown();
-                setTokenValue(tok->next(), value, settings);
-            }
-        }
-        // skip over enum
-        tok = tok->linkAt(1);
-    }
-    return tok->next();
-}
-
-
-static void valueFlowNumber(TokenList *tokenlist)
-{
-    for (Token *tok = tokenlist->front(); tok;) {
-        tok = valueFlowSetConstantValue(tok, tokenlist->getSettings(), tokenlist->isCPP());
-    }
-
-    if (tokenlist->isCPP()) {
-        for (Token *tok = tokenlist->front(); tok; tok = tok->next()) {
-            if (tok->isName() && !tok->varId() && Token::Match(tok, "false|true")) {
-                ValueFlow::Value value(tok->str() == "true");
-                if (!tok->isTemplateArg())
-                    value.setKnown();
-                setTokenValue(tok, value, tokenlist->getSettings());
-            } else if (Token::Match(tok, "[(,] NULL [,)]")) {
-                // NULL function parameters are not simplified in the
-                // normal tokenlist
-                ValueFlow::Value value(0);
-                if (!tok->isTemplateArg())
-                    value.setKnown();
-                setTokenValue(tok->next(), value, tokenlist->getSettings());
-            }
-        }
-    }
-}
-
-static void valueFlowString(TokenList *tokenlist)
-{
-    for (Token *tok = tokenlist->front(); tok; tok = tok->next()) {
-        if (tok->tokType() == Token::eString) {
-            ValueFlow::Value strvalue;
-            strvalue.valueType = ValueFlow::Value::TOK;
-            strvalue.tokvalue = tok;
-            strvalue.setKnown();
-            setTokenValue(tok, strvalue, tokenlist->getSettings());
-        }
-    }
-}
-
-static void valueFlowArray(TokenList *tokenlist)
-{
-    std::map<int, const Token *> constantArrays;
-
-    for (Token *tok = tokenlist->front(); tok; tok = tok->next()) {
-        if (tok->varId() > 0U) {
-            // array
-            const std::map<int, const Token *>::const_iterator it = constantArrays.find(tok->varId());
-            if (it != constantArrays.end()) {
-                ValueFlow::Value value;
-                value.valueType = ValueFlow::Value::TOK;
-                value.tokvalue = it->second;
-                value.setKnown();
-                setTokenValue(tok, value, tokenlist->getSettings());
-            }
-
-            // pointer = array
-            else if (tok->variable() &&
-                     tok->variable()->isArray() &&
-                     Token::simpleMatch(tok->astParent(), "=") &&
-                     tok == tok->astParent()->astOperand2() &&
-                     tok->astParent()->astOperand1() &&
-                     tok->astParent()->astOperand1()->variable() &&
-                     tok->astParent()->astOperand1()->variable()->isPointer()) {
-                ValueFlow::Value value;
-                value.valueType = ValueFlow::Value::TOK;
-                value.tokvalue = tok;
-                value.setKnown();
-                setTokenValue(tok, value, tokenlist->getSettings());
-            }
-            continue;
-        }
-
-        if (Token::Match(tok, "const %type% %var% [ %num%| ] = {")) {
-            const Token *vartok = tok->tokAt(2);
-            const Token *rhstok = vartok->next()->link()->tokAt(2);
-            constantArrays[vartok->varId()] = rhstok;
-            tok = rhstok->link();
-            continue;
-        }
-
-        else if (Token::Match(tok, "const char %var% [ %num%| ] = %str% ;")) {
-            const Token *vartok = tok->tokAt(2);
-            const Token *strtok = vartok->next()->link()->tokAt(2);
-            constantArrays[vartok->varId()] = strtok;
-            tok = strtok->next();
-            continue;
-        }
-    }
-}
-
-static bool isNonZero(const Token *tok)
-{
-    return tok && (!tok->hasKnownIntValue() || tok->values().front().intvalue != 0);
-}
-
-static const Token *getOtherOperand(const Token *tok)
+static const Token* getOtherOperand(const Token* tok)
 {
     if (!tok)
         return nullptr;
@@ -1350,15 +710,15 @@ static const Token *getOtherOperand(const Token *tok)
     return nullptr;
 }
 
-static void valueFlowArrayBool(TokenList *tokenlist)
+static void valueFlowArrayBool(TokenList& tokenlist, const Settings& settings)
 {
-    for (Token *tok = tokenlist->front(); tok; tok = tok->next()) {
+    for (Token* tok = tokenlist.front(); tok; tok = tok->next()) {
         if (tok->hasKnownIntValue())
             continue;
-        const Variable *var = nullptr;
+        const Variable* var = nullptr;
         bool known = false;
-        std::list<ValueFlow::Value>::const_iterator val =
-            std::find_if(tok->values().begin(), tok->values().end(), std::mem_fn(&ValueFlow::Value::isTokValue));
+        const auto val =
+            std::find_if(tok->values().cbegin(), tok->values().cend(), std::mem_fn(&ValueFlow::Value::isTokValue));
         if (val == tok->values().end()) {
             var = tok->variable();
             known = true;
@@ -1378,14 +738,95 @@ static void valueFlowArrayBool(TokenList *tokenlist)
             ValueFlow::Value value{1};
             if (known)
                 value.setKnown();
-            setTokenValue(tok, value, tokenlist->getSettings());
+            setTokenValue(tok, std::move(value), settings);
+        }
+    }
+}
+
+static void valueFlowArrayElement(TokenList& tokenlist, const Settings& settings)
+{
+    for (Token* tok = tokenlist.front(); tok; tok = tok->next()) {
+        if (tok->hasKnownIntValue())
+            continue;
+        const Token* indexTok = nullptr;
+        const Token* arrayTok = nullptr;
+        if (Token::simpleMatch(tok, "[") && tok->isBinaryOp()) {
+            indexTok = tok->astOperand2();
+            arrayTok = tok->astOperand1();
+        } else if (Token::Match(tok->tokAt(-2), ". %name% (") && astIsContainer(tok->tokAt(-2)->astOperand1())) {
+            arrayTok = tok->tokAt(-2)->astOperand1();
+            const Library::Container* container = getLibraryContainer(arrayTok);
+            if (!container || container->stdAssociativeLike)
+                continue;
+            const Library::Container::Yield yield = container->getYield(tok->strAt(-1));
+            if (yield != Library::Container::Yield::AT_INDEX)
+                continue;
+            indexTok = tok->astOperand2();
+        }
+
+        if (!indexTok || !arrayTok)
+            continue;
+
+        for (const ValueFlow::Value& arrayValue : arrayTok->values()) {
+            if (!arrayValue.isTokValue())
+                continue;
+            if (arrayValue.isImpossible())
+                continue;
+            for (const ValueFlow::Value& indexValue : indexTok->values()) {
+                if (!indexValue.isIntValue())
+                    continue;
+                if (indexValue.isImpossible())
+                    continue;
+                if (!arrayValue.isKnown() && !indexValue.isKnown() && arrayValue.varId != 0 && indexValue.varId != 0 &&
+                    !(arrayValue.varId == indexValue.varId && arrayValue.varvalue == indexValue.varvalue))
+                    continue;
+
+                ValueFlow::Value result(0);
+                result.condition = arrayValue.condition ? arrayValue.condition : indexValue.condition;
+                result.setInconclusive(arrayValue.isInconclusive() || indexValue.isInconclusive());
+                result.varId = (arrayValue.varId != 0) ? arrayValue.varId : indexValue.varId;
+                result.varvalue = (result.varId == arrayValue.varId) ? arrayValue.intvalue : indexValue.intvalue;
+                if (arrayValue.valueKind == indexValue.valueKind)
+                    result.valueKind = arrayValue.valueKind;
+
+                result.errorPath.insert(result.errorPath.end(),
+                                        arrayValue.errorPath.cbegin(),
+                                        arrayValue.errorPath.cend());
+                result.errorPath.insert(result.errorPath.end(),
+                                        indexValue.errorPath.cbegin(),
+                                        indexValue.errorPath.cend());
+
+                const MathLib::bigint index = indexValue.intvalue;
+
+                if (arrayValue.tokvalue->tokType() == Token::eString) {
+                    const std::string s = arrayValue.tokvalue->strValue();
+                    if (index == s.size()) {
+                        result.intvalue = 0;
+                        setTokenValue(tok, std::move(result), settings);
+                    } else if (index >= 0 && index < s.size()) {
+                        result.intvalue = s[static_cast<std::size_t>(index)];
+                        setTokenValue(tok, std::move(result), settings);
+                    }
+                } else if (Token::simpleMatch(arrayValue.tokvalue, "{")) {
+                    std::vector<const Token*> args = getArguments(arrayValue.tokvalue);
+                    if (index < 0 || index >= args.size())
+                        continue;
+                    const Token* arg = args[static_cast<std::size_t>(index)];
+                    const ValueFlow::Value* v = arg->getKnownValue(ValueFlow::Value::ValueType::INT);
+                    if (v) {
+                        result.intvalue = v->intvalue;
+                        result.errorPath.insert(result.errorPath.end(), v->errorPath.cbegin(), v->errorPath.cend());
+                        setTokenValue(tok, std::move(result), settings);
+                    }
+                }
+            }
         }
     }
 }
 
-static void valueFlowPointerAlias(TokenList *tokenlist)
+static void valueFlowPointerAlias(TokenList& tokenlist, const Settings& settings)
 {
-    for (Token *tok = tokenlist->front(); tok; tok = tok->next()) {
+    for (Token* tok = tokenlist.front(); tok; tok = tok->next()) {
         // not address of
         if (!tok->isUnaryOp("&"))
             continue;
@@ -1395,7 +836,7 @@ static void valueFlowPointerAlias(TokenList *tokenlist)
             continue;
 
         // child should be some buffer or variable
-        const Token *vartok = tok->astOperand1();
+        const Token* vartok = tok->astOperand1();
         while (vartok) {
             if (vartok->str() == "[")
                 vartok = vartok->astOperand1();
@@ -1408,50 +849,15 @@ static void valueFlowPointerAlias(TokenList *tokenlist)
             continue;
 
         ValueFlow::Value value;
-        value.valueType = ValueFlow::Value::TOK;
+        value.valueType = ValueFlow::Value::ValueType::TOK;
         value.tokvalue = tok;
-        setTokenValue(tok, value, tokenlist->getSettings());
-    }
-}
-
-static void valueFlowPointerAliasDeref(TokenList *tokenlist)
-{
-    for (Token *tok = tokenlist->front(); tok; tok = tok->next()) {
-        if (!tok->isUnaryOp("*"))
-            continue;
-        if (!astIsPointer(tok->astOperand1()))
-            continue;
-
-        const Token* lifeTok = nullptr;
-        ErrorPath errorPath;
-        for (const ValueFlow::Value& v:tok->astOperand1()->values()) {
-            if (!v.isLocalLifetimeValue())
-                continue;
-            lifeTok = v.tokvalue;
-            errorPath = v.errorPath;
-        }
-        if (!lifeTok)
-            continue;
-        if (lifeTok->varId() == 0)
-            continue;
-        const Variable * var = lifeTok->variable();
-        if (!var)
-            continue;
-        if (!var->isConst() && isVariableChanged(lifeTok->next(), tok, lifeTok->varId(), !var->isLocal(), tokenlist->getSettings(), tokenlist->isCPP()))
-            continue;
-        for (const ValueFlow::Value& v:lifeTok->values()) {
-            if (v.isLifetimeValue())
-                continue;
-            ValueFlow::Value value = v;
-            value.errorPath.insert(value.errorPath.begin(), errorPath.begin(), errorPath.end());
-            setTokenValue(tok, value, tokenlist->getSettings());
-        }
+        setTokenValue(tok, std::move(value), settings);
     }
 }
 
-static void valueFlowBitAnd(TokenList *tokenlist)
+static void valueFlowBitAnd(TokenList& tokenlist, const Settings& settings)
 {
-    for (Token *tok = tokenlist->front(); tok; tok = tok->next()) {
+    for (Token* tok = tokenlist.front(); tok; tok = tok->next()) {
         if (tok->str() != "&")
             continue;
 
@@ -1463,27 +869,27 @@ static void valueFlowBitAnd(TokenList *tokenlist)
 
         MathLib::bigint number;
         if (MathLib::isInt(tok->astOperand1()->str()))
-            number = MathLib::toLongNumber(tok->astOperand1()->str());
+            number = MathLib::toBigNumber(tok->astOperand1());
         else if (MathLib::isInt(tok->astOperand2()->str()))
-            number = MathLib::toLongNumber(tok->astOperand2()->str());
+            number = MathLib::toBigNumber(tok->astOperand2());
         else
             continue;
 
         int bit = 0;
-        while (bit <= (MathLib::bigint_bits - 2) && ((((MathLib::bigint)1) << bit) < number))
+        while (bit <= (MathLib::bigint_bits - 2) && ((static_cast<MathLib::bigint>(1) << bit) < number))
             ++bit;
 
-        if ((((MathLib::bigint)1) << bit) == number) {
-            setTokenValue(tok, ValueFlow::Value(0), tokenlist->getSettings());
-            setTokenValue(tok, ValueFlow::Value(number), tokenlist->getSettings());
+        if ((static_cast<MathLib::bigint>(1) << bit) == number) {
+            setTokenValue(tok, ValueFlow::Value(0), settings);
+            setTokenValue(tok, ValueFlow::Value(number), settings);
         }
     }
 }
 
-static void valueFlowSameExpressions(TokenList *tokenlist)
+static void valueFlowSameExpressions(TokenList& tokenlist, const Settings& settings)
 {
-    for (Token *tok = tokenlist->front(); tok; tok = tok->next()) {
-        if (tok->hasKnownValue())
+    for (Token* tok = tokenlist.front(); tok; tok = tok->next()) {
+        if (tok->hasKnownIntValue())
             continue;
 
         if (!tok->astOperand1() || !tok->astOperand2())
@@ -1495,149 +901,40 @@ static void valueFlowSameExpressions(TokenList *tokenlist)
         if (!astIsIntegral(tok->astOperand1(), false) && !astIsIntegral(tok->astOperand2(), false))
             continue;
 
-        ValueFlow::Value val;
+        long long val;
 
         if (Token::Match(tok, "==|>=|<=|/")) {
-            val = ValueFlow::Value(1);
-            val.setKnown();
+            val = 1;
         }
-
-        if (Token::Match(tok, "!=|>|<|%|-")) {
-            val = ValueFlow::Value(0);
-            val.setKnown();
+        else if (Token::Match(tok, "!=|>|<|%|-")) {
+            val = 0;
         }
-
-        if (!val.isKnown())
+        else
             continue;
 
-        if (isSameExpression(tokenlist->isCPP(), false, tok->astOperand1(), tok->astOperand2(), tokenlist->getSettings()->library, true, true, &val.errorPath)) {
-            setTokenValue(tok, val, tokenlist->getSettings());
+        ValueFlow::Value value(val);
+        value.setKnown();
+
+        if (isSameExpression(false, tok->astOperand1(), tok->astOperand2(), settings, true, true, &value.errorPath)) {
+            setTokenValue(tok, std::move(value), settings);
         }
     }
 }
 
-static void valueFlowTerminatingCondition(TokenList *tokenlist, SymbolDatabase* symboldatabase, ErrorLogger *errorLogger, const Settings *settings)
+static bool getExpressionRange(const Token* expr, MathLib::bigint* minvalue, MathLib::bigint* maxvalue)
 {
-    const bool cpp = symboldatabase->isCPP();
-    typedef std::pair<const Token*, const Scope*> Condition;
-    for (const Scope * scope : symboldatabase->functionScopes) {
-        bool skipFunction = false;
-        std::vector<Condition> conds;
-        for (const Token* tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
-            if (tok->isIncompleteVar()) {
-                if (settings->debugwarnings)
-                    bailout(tokenlist, errorLogger, tok, "Skipping function due to incomplete variable " + tok->str());
-                skipFunction = true;
-                break;
-            }
-            if (!Token::simpleMatch(tok, "if ("))
-                continue;
-            // Skip known values
-            if (tok->next()->hasKnownValue())
-                continue;
-            const Token * condTok = tok->next();
-            if (!Token::simpleMatch(condTok->link(), ") {"))
-                continue;
-            const Token * blockTok = condTok->link()->tokAt(1);
-            // Check if the block terminates early
-            if (!isEscapeScope(blockTok, tokenlist))
-                continue;
-            // Check if any variables are modified in scope
-            bool bail = false;
-            for (const Token * tok2=condTok->next(); tok2 != condTok->link(); tok2 = tok2->next()) {
-                const Variable * var = tok2->variable();
-                if (!var)
-                    continue;
-                if (!var->scope())
-                    continue;
-                const Token * endToken = var->scope()->bodyEnd;
-                if (!var->isLocal() && !var->isConst() && !var->isArgument()) {
-                    bail = true;
-                    break;
-                }
-                if (var->isStatic() && !var->isConst()) {
-                    bail = true;
-                    break;
-                }
-                if (!var->isConst() && var->declEndToken() && isVariableChanged(var->declEndToken()->next(), endToken, tok2->varId(), false, settings, cpp)) {
-                    bail = true;
-                    break;
-                }
-            }
-            if (bail)
-                continue;
-            // TODO: Handle multiple conditions
-            if (Token::Match(condTok->astOperand2(), "%oror%|%or%|&|&&"))
-                continue;
-            const Scope * condScope = nullptr;
-            for (const Scope * parent = condTok->scope(); parent; parent = parent->nestedIn) {
-                if (parent->type == Scope::eIf ||
-                    parent->type == Scope::eWhile ||
-                    parent->type == Scope::eSwitch) {
-                    condScope = parent;
-                    break;
-                }
-            }
-            conds.emplace_back(condTok->astOperand2(), condScope);
-        }
-        if (skipFunction)
-            break;
-        for (Condition cond:conds) {
-            if (!cond.first)
-                continue;
-            Token *const startToken = cond.first->findExpressionStartEndTokens().second->next();
-            for (Token* tok = startToken; tok != scope->bodyEnd; tok = tok->next()) {
-                if (!Token::Match(tok, "%comp%"))
-                    continue;
-                // Skip known values
-                if (tok->hasKnownValue())
-                    continue;
-                if (cond.second) {
-                    bool bail = true;
-                    for (const Scope * parent = tok->scope()->nestedIn; parent; parent = parent->nestedIn) {
-                        if (parent == cond.second) {
-                            bail = false;
-                            break;
-                        }
-                    }
-                    if (bail)
-                        continue;
-                }
-                ErrorPath errorPath;
-                if (isOppositeCond(true, cpp, tok, cond.first, settings->library, true, true, &errorPath)) {
-                    ValueFlow::Value val(1);
-                    val.setKnown();
-                    val.condition = cond.first;
-                    val.errorPath = errorPath;
-                    val.errorPath.emplace_back(cond.first, "Assuming condition '" + cond.first->expressionString() + "' is false");
-                    setTokenValue(tok, val, tokenlist->getSettings());
-                } else if (isSameExpression(cpp, true, tok, cond.first, settings->library, true, true, &errorPath)) {
-                    ValueFlow::Value val(0);
-                    val.setKnown();
-                    val.condition = cond.first;
-                    val.errorPath = errorPath;
-                    val.errorPath.emplace_back(cond.first, "Assuming condition '" + cond.first->expressionString() + "' is false");
-                    setTokenValue(tok, val, tokenlist->getSettings());
-                }
-            }
-        }
-    }
-}
-
-static bool getExpressionRange(const Token *expr, MathLib::bigint *minvalue, MathLib::bigint *maxvalue)
-{
-    if (expr->hasKnownIntValue()) {
+    if (const ValueFlow::Value* v = expr->getKnownValue(ValueFlow::Value::ValueType::INT)) {
         if (minvalue)
-            *minvalue = expr->values().front().intvalue;
+            *minvalue = v->intvalue;
         if (maxvalue)
-            *maxvalue = expr->values().front().intvalue;
+            *maxvalue = v->intvalue;
         return true;
     }
 
     if (expr->str() == "&" && expr->astOperand1() && expr->astOperand2()) {
         MathLib::bigint vals[4];
-        bool lhsHasKnownRange = getExpressionRange(expr->astOperand1(), &vals[0], &vals[1]);
-        bool rhsHasKnownRange = getExpressionRange(expr->astOperand2(), &vals[2], &vals[3]);
+        const bool lhsHasKnownRange = getExpressionRange(expr->astOperand1(), &vals[0], &vals[1]);
+        const bool rhsHasKnownRange = getExpressionRange(expr->astOperand2(), &vals[2], &vals[3]);
         if (!lhsHasKnownRange && !rhsHasKnownRange)
             return false;
         if (!lhsHasKnownRange || !rhsHasKnownRange) {
@@ -1660,11 +957,12 @@ static bool getExpressionRange(const Token *expr, MathLib::bigint *minvalue, Mat
             return false;
         if (vals[2] <= 0)
             return false;
-        bool lhsHasKnownRange = getExpressionRange(expr->astOperand1(), &vals[0], &vals[1]);
+        const bool lhsHasKnownRange = getExpressionRange(expr->astOperand1(), &vals[0], &vals[1]);
         if (lhsHasKnownRange && vals[0] < 0)
             return false;
         // If lhs has unknown value, it must be unsigned
-        if (!lhsHasKnownRange && (!expr->astOperand1()->valueType() || expr->astOperand1()->valueType()->sign != ValueType::Sign::UNSIGNED))
+        if (!lhsHasKnownRange &&
+            (!expr->astOperand1()->valueType() || expr->astOperand1()->valueType()->sign != ValueType::Sign::UNSIGNED))
             return false;
         if (minvalue)
             *minvalue = 0;
@@ -1676,22 +974,22 @@ static bool getExpressionRange(const Token *expr, MathLib::bigint *minvalue, Mat
     return false;
 }
 
-static void valueFlowRightShift(TokenList *tokenList, const Settings* settings)
+static void valueFlowRightShift(TokenList& tokenList, const Settings& settings)
 {
-    for (Token *tok = tokenList->front(); tok; tok = tok->next()) {
+    for (Token* tok = tokenList.front(); tok; tok = tok->next()) {
         if (tok->str() != ">>")
             continue;
 
-        if (tok->hasKnownValue())
+        if (tok->hasKnownIntValue())
             continue;
 
         if (!tok->astOperand1() || !tok->astOperand2())
             continue;
 
-        if (!tok->astOperand2()->hasKnownValue())
+        if (!tok->astOperand2()->hasKnownIntValue())
             continue;
 
-        const MathLib::bigint rhsvalue = tok->astOperand2()->values().front().intvalue;
+        const MathLib::bigint rhsvalue = tok->astOperand2()->getKnownIntValue();
         if (rhsvalue < 0)
             continue;
 
@@ -1701,22 +999,22 @@ static void valueFlowRightShift(TokenList *tokenList, const Settings* settings)
         if (!tok->astOperand2()->valueType() || !tok->astOperand2()->valueType()->isIntegral())
             continue;
 
-        MathLib::bigint lhsmax=0;
+        MathLib::bigint lhsmax = 0;
         if (!getExpressionRange(tok->astOperand1(), nullptr, &lhsmax))
             continue;
         if (lhsmax < 0)
             continue;
-        int lhsbits;
+        std::uint8_t lhsbits;
         if ((tok->astOperand1()->valueType()->type == ValueType::Type::CHAR) ||
             (tok->astOperand1()->valueType()->type == ValueType::Type::SHORT) ||
             (tok->astOperand1()->valueType()->type == ValueType::Type::WCHAR_T) ||
             (tok->astOperand1()->valueType()->type == ValueType::Type::BOOL) ||
             (tok->astOperand1()->valueType()->type == ValueType::Type::INT))
-            lhsbits = settings->int_bit;
+            lhsbits = settings.platform.int_bit; // TODO: needs to use the proper *_bit fo each type
         else if (tok->astOperand1()->valueType()->type == ValueType::Type::LONG)
-            lhsbits = settings->long_bit;
+            lhsbits = settings.platform.long_bit;
         else if (tok->astOperand1()->valueType()->type == ValueType::Type::LONGLONG)
-            lhsbits = settings->long_long_bit;
+            lhsbits = settings.platform.long_long_bit;
         else
             continue;
         if (rhsvalue >= lhsbits || rhsvalue >= MathLib::bigint_bits || (1ULL << rhsvalue) <= lhsmax)
@@ -1724,94 +1022,234 @@ static void valueFlowRightShift(TokenList *tokenList, const Settings* settings)
 
         ValueFlow::Value val(0);
         val.setKnown();
-        setTokenValue(tok, val, tokenList->getSettings());
+        setTokenValue(tok, std::move(val), settings);
     }
 }
 
-static void valueFlowOppositeCondition(SymbolDatabase *symboldatabase, const Settings *settings)
+static std::vector<MathLib::bigint> minUnsignedValue(const Token* tok, int depth = 8)
 {
-    for (const Scope &scope : symboldatabase->scopeList) {
-        if (scope.type != Scope::eIf)
-            continue;
-        Token *tok = const_cast<Token *>(scope.classDef);
-        if (!Token::simpleMatch(tok, "if ("))
+    std::vector<MathLib::bigint> result;
+    if (!tok)
+        return result;
+    if (depth < 0)
+        return result;
+    if (const ValueFlow::Value* v = tok->getKnownValue(ValueFlow::Value::ValueType::INT)) {
+        result = {v->intvalue};
+    } else if (!Token::Match(tok, "-|%|&|^") && tok->isConstOp() && tok->astOperand1() && tok->astOperand2()) {
+        std::vector<MathLib::bigint> op1 = minUnsignedValue(tok->astOperand1(), depth - 1);
+        if (!op1.empty()) {
+            std::vector<MathLib::bigint> op2 = minUnsignedValue(tok->astOperand2(), depth - 1);
+            if (!op2.empty()) {
+                result = calculate<std::vector<MathLib::bigint>>(tok->str(), op1.front(), op2.front());
+            }
+        }
+    }
+    if (result.empty() && astIsUnsigned(tok))
+        result = {0};
+    return result;
+}
+
+static bool isConvertedToIntegral(const Token* tok, const Settings& settings)
+{
+    if (!tok)
+        return false;
+    std::vector<ValueType> parentTypes = getParentValueTypes(tok, settings);
+    if (parentTypes.empty())
+        return false;
+    const ValueType& vt = parentTypes.front();
+    return vt.type != ValueType::UNKNOWN_INT && vt.isIntegral();
+}
+
+static bool isSameToken(const Token* tok1, const Token* tok2)
+{
+    if (!tok1 || !tok2)
+        return false;
+    if (tok1->exprId() != 0 && tok1->exprId() == tok2->exprId())
+        return true;
+    if (tok1->hasKnownIntValue() && tok2->hasKnownIntValue())
+        return tok1->getKnownIntValue() == tok2->getKnownIntValue();
+    return false;
+}
+
+static void valueFlowImpossibleValues(TokenList& tokenList, const Settings& settings)
+{
+    for (Token* tok = tokenList.front(); tok; tok = tok->next()) {
+        if (tok->hasKnownIntValue())
             continue;
-        const Token *cond1 = tok->next()->astOperand2();
-        if (!cond1 || !cond1->isComparisonOp())
+        if (Token::Match(tok, "%bool%"))
             continue;
-        const bool cpp = symboldatabase->isCPP();
-        Token *tok2 = tok->linkAt(1);
-        while (Token::simpleMatch(tok2, ") {")) {
-            tok2 = tok2->linkAt(1);
-            if (!Token::simpleMatch(tok2, "} else { if ("))
-                break;
-            Token *ifOpenBraceTok = tok2->tokAt(4);
-            Token *cond2 = ifOpenBraceTok->astOperand2();
-            if (!cond2 || !cond2->isComparisonOp())
+        if (astIsBool(tok) || Token::Match(tok, "%comp%")) {
+            ValueFlow::Value lower{-1};
+            lower.bound = ValueFlow::Value::Bound::Upper;
+            lower.setImpossible();
+            setTokenValue(tok, std::move(lower), settings);
+
+            ValueFlow::Value upper{2};
+            upper.bound = ValueFlow::Value::Bound::Lower;
+            upper.setImpossible();
+            setTokenValue(tok, std::move(upper), settings);
+        } else if (astIsUnsigned(tok) && !astIsPointer(tok)) {
+            std::vector<MathLib::bigint> minvalue = minUnsignedValue(tok);
+            if (minvalue.empty())
                 continue;
-            if (isOppositeCond(true, cpp, cond1, cond2, settings->library, true, true)) {
-                ValueFlow::Value value(1);
-                value.setKnown();
-                setTokenValue(cond2, value, settings);
+            ValueFlow::Value value{std::max<MathLib::bigint>(0, minvalue.front()) - 1};
+            value.bound = ValueFlow::Value::Bound::Upper;
+            value.setImpossible();
+            setTokenValue(tok, std::move(value), settings);
+        }
+        if (Token::simpleMatch(tok, "?") && Token::Match(tok->astOperand1(), "<|<=|>|>=")) {
+            const Token* condTok = tok->astOperand1();
+            const Token* branchesTok = tok->astOperand2();
+
+            auto tokens = makeArray(condTok->astOperand1(), condTok->astOperand2());
+            auto branches = makeArray(branchesTok->astOperand1(), branchesTok->astOperand2());
+            bool flipped = false;
+            if (std::equal(tokens.cbegin(), tokens.cend(), branches.crbegin(), &isSameToken))
+                flipped = true;
+            else if (!std::equal(tokens.cbegin(), tokens.cend(), branches.cbegin(), &isSameToken))
+                continue;
+            std::vector<ValueFlow::Value> values;
+            for (const Token* tok2 : tokens) {
+                if (const ValueFlow::Value* v = tok2->getKnownValue(ValueFlow::Value::ValueType::INT)) {
+                    values.emplace_back(*v);
+                } else {
+                    ValueFlow::Value symValue{};
+                    symValue.valueType = ValueFlow::Value::ValueType::SYMBOLIC;
+                    symValue.tokvalue = tok2;
+                    values.push_back(std::move(symValue));
+                    std::copy_if(tok2->values().cbegin(),
+                                 tok2->values().cend(),
+                                 std::back_inserter(values),
+                                 [](const ValueFlow::Value& v) {
+                        if (!v.isKnown())
+                            return false;
+                        return v.isSymbolicValue();
+                    });
+                }
+            }
+            const bool isMin = Token::Match(condTok, "<|<=") ^ flipped;
+            for (ValueFlow::Value& value : values) {
+                value.setImpossible();
+                if (isMin) {
+                    value.intvalue++;
+                    value.bound = ValueFlow::Value::Bound::Lower;
+                } else {
+                    value.intvalue--;
+                    value.bound = ValueFlow::Value::Bound::Upper;
+                }
+                setTokenValue(tok, std::move(value), settings);
+            }
+
+        } else if (Token::simpleMatch(tok, "%") && tok->astOperand2() && tok->astOperand2()->hasKnownIntValue()) {
+            ValueFlow::Value value{tok->astOperand2()->getKnownIntValue()};
+            value.bound = ValueFlow::Value::Bound::Lower;
+            value.setImpossible();
+            setTokenValue(tok, std::move(value), settings);
+        } else if (Token::Match(tok, "abs|labs|llabs|fabs|fabsf|fabsl (")) {
+            ValueFlow::Value value{-1};
+            value.bound = ValueFlow::Value::Bound::Upper;
+            value.setImpossible();
+            setTokenValue(tok->next(), std::move(value), settings);
+        } else if (Token::Match(tok, ". data|c_str (") && astIsContainerOwned(tok->astOperand1())) {
+            const Library::Container* container = getLibraryContainer(tok->astOperand1());
+            if (!container)
+                continue;
+            if (!container->stdStringLike)
+                continue;
+            if (container->view)
+                continue;
+            ValueFlow::Value value{0};
+            value.setImpossible();
+            setTokenValue(tok->tokAt(2), std::move(value), settings);
+        } else if (Token::Match(tok, "make_shared|make_unique <") && Token::simpleMatch(tok->linkAt(1), "> (")) {
+            ValueFlow::Value value{0};
+            value.setImpossible();
+            setTokenValue(tok->linkAt(1)->next(), std::move(value), settings);
+        } else if ((tokenList.isCPP() && Token::simpleMatch(tok, "this")) || tok->isUnaryOp("&")) {
+            ValueFlow::Value value{0};
+            value.setImpossible();
+            setTokenValue(tok, std::move(value), settings);
+        } else if (tok->variable() && tok->variable()->isArray() && !tok->variable()->isArgument() &&
+                   !tok->variable()->isStlType()) {
+            ValueFlow::Value value{0};
+            value.setImpossible();
+            setTokenValue(tok, std::move(value), settings);
+        } else if (tok->isIncompleteVar() && tok->astParent() && tok->astParent()->isUnaryOp("-") &&
+                   isConvertedToIntegral(tok->astParent(), settings)) {
+            ValueFlow::Value value{0};
+            value.setImpossible();
+            setTokenValue(tok, std::move(value), settings);
+        }
+    }
+}
+
+static void valueFlowEnumValue(SymbolDatabase & symboldatabase, const Settings & settings)
+{
+    for (Scope & scope : symboldatabase.scopeList) {
+        if (scope.type != ScopeType::eEnum)
+            continue;
+        MathLib::bigint value = 0;
+        bool prev_enum_is_known = true;
+
+        for (Enumerator & enumerator : scope.enumeratorList) {
+            if (enumerator.start) {
+                auto* rhs = const_cast<Token*>(enumerator.start->previous()->astOperand2());
+                ValueFlow::valueFlowConstantFoldAST(rhs, settings);
+                if (rhs && rhs->hasKnownIntValue()) {
+                    enumerator.value = rhs->getKnownIntValue();
+                    enumerator.value_known = true;
+                    value = enumerator.value + 1;
+                    prev_enum_is_known = true;
+                } else
+                    prev_enum_is_known = false;
+            } else if (prev_enum_is_known) {
+                enumerator.value = value++;
+                enumerator.value_known = true;
             }
-            tok2 = ifOpenBraceTok->link();
         }
     }
 }
 
-static void valueFlowGlobalConstVar(TokenList* tokenList, const Settings *settings)
+static void valueFlowGlobalConstVar(TokenList& tokenList, const Settings& settings)
 {
     // Get variable values...
     std::map<const Variable*, ValueFlow::Value> vars;
-    for (const Token* tok = tokenList->front(); tok; tok = tok->next()) {
+    for (const Token* tok = tokenList.front(); tok; tok = tok->next()) {
         if (!tok->variable())
             continue;
         // Initialization...
-        if (tok == tok->variable()->nameToken() &&
-            !tok->variable()->isVolatile() &&
-            !tok->variable()->isArgument() &&
-            tok->variable()->isConst() &&
-            tok->valueType() &&
-            tok->valueType()->isIntegral() &&
-            tok->valueType()->pointer == 0 &&
-            tok->valueType()->constness == 1 &&
-            Token::Match(tok, "%name% =") &&
-            tok->next()->astOperand2() &&
-            tok->next()->astOperand2()->hasKnownIntValue()) {
-            vars[tok->variable()] = tok->next()->astOperand2()->values().front();
+        if (tok == tok->variable()->nameToken() && !tok->variable()->isVolatile() && !tok->variable()->isArgument() &&
+            tok->variable()->isConst() && tok->valueType() && tok->valueType()->isIntegral() &&
+            tok->valueType()->pointer == 0 && tok->valueType()->constness == 1 && Token::Match(tok, "%name% =") &&
+            tok->next()->astOperand2() && tok->next()->astOperand2()->hasKnownIntValue()) {
+            vars[tok->variable()] = *tok->next()->astOperand2()->getKnownValue(ValueFlow::Value::ValueType::INT);
         }
     }
 
     // Set values..
-    for (Token* tok = tokenList->front(); tok; tok = tok->next()) {
+    for (Token* tok = tokenList.front(); tok; tok = tok->next()) {
         if (!tok->variable())
             continue;
-        std::map<const Variable*, ValueFlow::Value>::const_iterator var = vars.find(tok->variable());
+        const auto var = utils::as_const(vars).find(tok->variable());
         if (var == vars.end())
             continue;
         setTokenValue(tok, var->second, settings);
     }
 }
 
-static void valueFlowGlobalStaticVar(TokenList *tokenList, const Settings *settings)
+static void valueFlowGlobalStaticVar(TokenList& tokenList, const Settings& settings)
 {
     // Get variable values...
-    std::map<const Variable *, ValueFlow::Value> vars;
-    for (const Token *tok = tokenList->front(); tok; tok = tok->next()) {
+    std::map<const Variable*, ValueFlow::Value> vars;
+    for (const Token* tok = tokenList.front(); tok; tok = tok->next()) {
         if (!tok->variable())
             continue;
         // Initialization...
-        if (tok == tok->variable()->nameToken() &&
-            tok->variable()->isStatic() &&
-            !tok->variable()->isConst() &&
-            tok->valueType() &&
-            tok->valueType()->isIntegral() &&
-            tok->valueType()->pointer == 0 &&
-            tok->valueType()->constness == 0 &&
-            Token::Match(tok, "%name% =") &&
-            tok->next()->astOperand2() &&
+        if (tok == tok->variable()->nameToken() && tok->variable()->isStatic() && !tok->variable()->isConst() &&
+            tok->valueType() && tok->valueType()->isIntegral() && tok->valueType()->pointer == 0 &&
+            tok->valueType()->constness == 0 && Token::Match(tok, "%name% =") && tok->next()->astOperand2() &&
             tok->next()->astOperand2()->hasKnownIntValue()) {
-            vars[tok->variable()] = tok->next()->astOperand2()->values().front();
+            vars[tok->variable()] = *tok->next()->astOperand2()->getKnownValue(ValueFlow::Value::ValueType::INT);
         } else {
             // If variable is written anywhere in TU then remove it from vars
             if (!tok->astParent())
@@ -1821,9 +1259,9 @@ static void valueFlowGlobalStaticVar(TokenList *tokenList, const Settings *setti
             else if (tok->astParent()->isAssignmentOp()) {
                 if (tok == tok->astParent()->astOperand1())
                     vars.erase(tok->variable());
-                else if (tokenList->isCPP() && Token::Match(tok->astParent()->tokAt(-2), "& %name% ="))
+                else if (tok->isCpp() && Token::Match(tok->astParent()->tokAt(-2), "& %name% ="))
                     vars.erase(tok->variable());
-            } else if (isLikelyStreamRead(tokenList->isCPP(), tok->astParent())) {
+            } else if (isLikelyStreamRead(tok->astParent())) {
                 vars.erase(tok->variable());
             } else if (Token::Match(tok->astParent(), "[(,]"))
                 vars.erase(tok->variable());
@@ -1831,2525 +1269,3004 @@ static void valueFlowGlobalStaticVar(TokenList *tokenList, const Settings *setti
     }
 
     // Set values..
-    for (Token *tok = tokenList->front(); tok; tok = tok->next()) {
+    for (Token* tok = tokenList.front(); tok; tok = tok->next()) {
         if (!tok->variable())
             continue;
-        std::map<const Variable *, ValueFlow::Value>::const_iterator var = vars.find(tok->variable());
+        const auto var = utils::as_const(vars).find(tok->variable());
         if (var == vars.end())
             continue;
         setTokenValue(tok, var->second, settings);
     }
 }
 
-static void valueFlowForward(Token* startToken,
-                             const Token* endToken,
-                             const Token* exprTok,
+static Analyzer::Result valueFlowForward(Token* startToken,
+                                         const Token* endToken,
+                                         const Token* exprTok,
+                                         ValueFlow::Value value,
+                                         const TokenList& tokenlist,
+                                         ErrorLogger& errorLogger,
+                                         const Settings& settings,
+                                         SourceLocation loc = SourceLocation::current())
+{
+    if (settings.debugnormal)
+        setSourceLocation(value, loc, startToken);
+    return valueFlowGenericForward(startToken,
+                                   endToken,
+                                   makeAnalyzer(exprTok, std::move(value), settings),
+                                   tokenlist,
+                                   errorLogger,
+                                   settings);
+}
+
+static Analyzer::Result valueFlowForward(Token* startToken,
+                                         const Token* endToken,
+                                         const Token* exprTok,
+                                         std::list<ValueFlow::Value> values,
+                                         const TokenList& tokenlist,
+                                         ErrorLogger& errorLogger,
+                                         const Settings& settings,
+                                         SourceLocation loc = SourceLocation::current())
+{
+    Analyzer::Result result{};
+    for (ValueFlow::Value& v : values) {
+        result.update(valueFlowForward(startToken, endToken, exprTok, std::move(v), tokenlist, errorLogger, settings, loc));
+    }
+    return result;
+}
+
+static Analyzer::Result valueFlowForward(Token* startToken,
+                                         const Token* exprTok,
+                                         ValueFlow::Value v,
+                                         const TokenList& tokenlist,
+                                         ErrorLogger& errorLogger,
+                                         const Settings& settings,
+                                         SourceLocation loc = SourceLocation::current())
+{
+    const Token* endToken = nullptr;
+    const Function* f = Scope::nestedInFunction(startToken->scope());
+    if (f && f->functionScope)
+        endToken = f->functionScope->bodyEnd;
+    if (!endToken && exprTok && exprTok->variable() && !exprTok->variable()->isLocal())
+        endToken = startToken->scope()->bodyEnd;
+    return valueFlowForward(startToken, endToken, exprTok, std::move(v), tokenlist, errorLogger, settings, loc);
+}
+
+static Analyzer::Result valueFlowForwardRecursive(Token* top,
+                                                  const Token* exprTok,
+                                                  std::list<ValueFlow::Value> values,
+                                                  const TokenList& tokenlist,
+                                                  ErrorLogger& errorLogger,
+                                                  const Settings& settings,
+                                                  SourceLocation loc = SourceLocation::current())
+{
+    Analyzer::Result result{};
+    for (ValueFlow::Value& v : values) {
+        if (settings.debugnormal)
+            setSourceLocation(v, loc, top);
+        result.update(
+            valueFlowGenericForward(top, makeAnalyzer(exprTok, std::move(v), settings), tokenlist, errorLogger, settings));
+    }
+    return result;
+}
+
+static void valueFlowReverse(Token* tok,
+                             const Token* const endToken,
+                             const Token* const varToken,
                              std::list<ValueFlow::Value> values,
-                             const bool constValue,
-                             const bool subFunction,
-                             TokenList* const tokenlist,
-                             ErrorLogger* const errorLogger,
-                             const Settings* settings);
-
-static void valueFlowReverse(TokenList *tokenlist,
-                             Token *tok,
-                             const Token * const varToken,
+                             const TokenList& tokenlist,
+                             ErrorLogger& errorLogger,
+                             const Settings& settings,
+                             SourceLocation loc = SourceLocation::current())
+{
+    for (ValueFlow::Value& v : values) {
+        if (settings.debugnormal)
+            setSourceLocation(v, loc, tok);
+        valueFlowGenericReverse(tok,
+                                endToken,
+                                makeReverseAnalyzer(varToken, std::move(v), settings),
+                                tokenlist,
+                                errorLogger,
+                                settings);
+    }
+}
+
+// Deprecated
+static void valueFlowReverse(const TokenList& tokenlist,
+                             Token* tok,
+                             const Token* const varToken,
                              ValueFlow::Value val,
-                             ValueFlow::Value val2,
-                             ErrorLogger *errorLogger,
-                             const Settings *settings)
+                             ErrorLogger& errorLogger,
+                             const Settings& settings,
+                             SourceLocation loc = SourceLocation::current())
 {
-    const MathLib::bigint    num        = val.intvalue;
-    const Variable * const   var        = varToken->variable();
-    if (!var)
-        return;
+    valueFlowReverse(tok, nullptr, varToken, {std::move(val)}, tokenlist, errorLogger, settings, loc);
+}
+
+static bool isConditionKnown(const Token* tok, bool then)
+{
+    const char* op = "||";
+    if (then)
+        op = "&&";
+    const Token* parent = tok->astParent();
+    while (parent && (parent->str() == op || parent->str() == "!" || parent->isCast()))
+        parent = parent->astParent();
+    const Token* top = tok->astTop();
+    if (Token::Match(top->previous(), "if|while|for ("))
+        return parent == top || Token::simpleMatch(parent, ";");
+    return parent && parent->str() != op;
+}
 
-    const int                varid      = varToken->varId();
-    const Token * const      startToken = var->nameToken();
+enum class LifetimeCapture : std::uint8_t { Undefined, ByValue, ByReference };
 
-    for (Token *tok2 = tok->previous(); ; tok2 = tok2->previous()) {
-        if (!tok2 ||
-            tok2 == startToken ||
-            (tok2->str() == "{" && tok2->scope()->type == Scope::ScopeType::eFunction)) {
-            break;
-        }
+static std::string lifetimeType(const Token *tok, const ValueFlow::Value *val)
+{
+    if (!val)
+        return "object";
+    switch (val->lifetimeKind) {
+    case ValueFlow::Value::LifetimeKind::Lambda:
+        return "lambda";
+    case ValueFlow::Value::LifetimeKind::Iterator:
+        return "iterator";
+    case ValueFlow::Value::LifetimeKind::Object:
+    case ValueFlow::Value::LifetimeKind::SubObject:
+    case ValueFlow::Value::LifetimeKind::Address:
+        if (astIsPointer(tok))
+            return "pointer";
+        if (Token::simpleMatch(tok, "=") && astIsPointer(tok->astOperand2()))
+            return "pointer";
+        return "object";
+    }
+
+    cppcheck::unreachable();
+}
 
-        if (tok2->varId() == varid) {
-            if (tok2->hasKnownValue())
+std::string ValueFlow::lifetimeMessage(const Token *tok, const ValueFlow::Value *val, ErrorPath &errorPath)
+{
+    const Token *tokvalue = val ? val->tokvalue : nullptr;
+    const Variable *tokvar = tokvalue ? tokvalue->variable() : nullptr;
+    const Token *vartok = tokvar ? tokvar->nameToken() : nullptr;
+    const bool classVar = tokvar ? (!tokvar->isLocal() && !tokvar->isArgument() && !tokvar->isGlobal()) : false;
+    std::string type = lifetimeType(tok, val);
+    std::string msg = type;
+    if (vartok) {
+        if (!classVar)
+            errorPath.emplace_back(vartok, "Variable created here.");
+        const Variable * var = vartok->variable();
+        if (var) {
+            std::string submessage;
+            switch (val->lifetimeKind) {
+            case ValueFlow::Value::LifetimeKind::SubObject:
+            case ValueFlow::Value::LifetimeKind::Object:
+            case ValueFlow::Value::LifetimeKind::Address:
+                if (type == "pointer")
+                    submessage = " to local variable";
+                else
+                    submessage = " that points to local variable";
                 break;
-            // bailout: assignment
-            if (Token::Match(tok2->previous(), "!!* %name% =")) {
-                Token* assignTok = const_cast<Token*>(tok2->next()->astOperand2());
-                if (!assignTok->hasKnownValue()) {
-                    std::list<ValueFlow::Value> values = {val};
-                    setTokenValue(assignTok, val, settings);
-                    if (val2.condition) {
-                        setTokenValue(assignTok, val2, settings);
-                        values.push_back(val2);
-                    }
-                    const Token* startForwardToken = nextAfterAstRightmostLeaf(tok2->next());
-                    const Token* endForwardToken = tok->scope() ? tok->scope()->bodyEnd : tok;
-                    valueFlowForward(const_cast<Token*>(startForwardToken),
-                                     endForwardToken,
-                                     assignTok,
-                                     values,
-                                     false,
-                                     false,
-                                     tokenlist,
-                                     errorLogger,
-                                     settings);
-                }
-                if (settings->debugwarnings)
-                    bailout(tokenlist, errorLogger, tok2, "assignment of " + tok2->str());
+            case ValueFlow::Value::LifetimeKind::Lambda:
+                submessage = " that captures local variable";
                 break;
-            }
-
-            // increment/decrement
-            int inc = 0;
-            if (Token::Match(tok2->previous(), "[;{}] %name% ++|-- ;"))
-                inc = (tok2->strAt(1)=="++") ? -1 : 1;
-            else if (Token::Match(tok2->tokAt(-2), "[;{}] ++|-- %name% ;"))
-                inc = (tok2->strAt(-1)=="++") ? -1 : 1;
-            else if (Token::Match(tok2->previous(), "++|-- %name%") || Token::Match(tok2, "%name% ++|--")) {
-                if (settings->debugwarnings)
-                    bailout(tokenlist, errorLogger, tok2, "increment/decrement of " + tok2->str());
+            case ValueFlow::Value::LifetimeKind::Iterator:
+                submessage = " to local container";
                 break;
             }
-            if (inc != 0) {
-                val.intvalue += inc;
-                const std::string info(tok2->str() + " is " + std::string(inc==1 ? "decremented" : "incremented") + ", before this " + (inc==1?"decrement":"increment") + " the value is " + val.infoString());
-                val.errorPath.emplace_back(tok2, info);
-            }
+            if (classVar)
+                submessage.replace(submessage.find("local"), 5, "member");
+            msg += submessage + " '" + var->name() + "'";
+        }
+    }
+    return msg;
+}
 
-            // compound assignment
-            if (Token::Match(tok2->previous(), "[;{}] %var% %assign%") && tok2->next()->str() != "=") {
-                const Token * const assignToken = tok2->next();
-                const Token * const rhsToken = assignToken->astOperand2();
-                if (!rhsToken || !rhsToken->hasKnownIntValue()) {
-                    if (settings->debugwarnings)
-                        bailout(tokenlist, errorLogger, tok2, "compound assignment, rhs value is not known");
-                    break;
-                }
-                const MathLib::bigint rhsValue =  rhsToken->values().front().intvalue;
-                if (assignToken->str() == "+=")
-                    val.intvalue -= rhsValue;
-                else if (assignToken->str() == "-=")
-                    val.intvalue += rhsValue;
-                else if (assignToken->str() == "*=" && rhsValue != 0)
-                    val.intvalue /= rhsValue;
-                else {
-                    if (settings->debugwarnings)
-                        bailout(tokenlist, errorLogger, tok2, "compound assignment " + tok2->str());
-                    break;
-                }
+std::vector<ValueFlow::Value> ValueFlow::getLifetimeObjValues(const Token* tok, bool inconclusive, MathLib::bigint path)
+{
+    std::vector<ValueFlow::Value> result;
+    auto pred = [&](const ValueFlow::Value& v) {
+        if (!v.isLocalLifetimeValue() && !(path != 0 && v.isSubFunctionLifetimeValue()))
+            return false;
+        if (!inconclusive && v.isInconclusive())
+            return false;
+        if (!v.tokvalue)
+            return false;
+        if (path >= 0 && v.path != 0 && v.path != path)
+            return false;
+        return true;
+    };
+    std::copy_if(tok->values().cbegin(), tok->values().cend(), std::back_inserter(result), pred);
+    return result;
+}
 
-                const std::string info("Compound assignment '" + assignToken->str() + "', before assignment value is " + val.infoString());
-                val.errorPath.emplace_back(tok2, info);
-            }
+static bool hasUniqueOwnership(const Token* tok)
+{
+    if (!tok)
+        return false;
+    const Variable* var = tok->variable();
+    if (var && var->isArray() && !var->isArgument())
+        return true;
+    if (astIsPointer(tok))
+        return false;
+    if (astIsUniqueSmartPointer(tok))
+        return true;
+    if (astIsContainerOwned(tok))
+        return true;
+    return false;
+}
 
-            // bailout: variable is used in rhs in assignment to itself
-            if (bailoutSelfAssignment(tok2)) {
-                if (settings->debugwarnings)
-                    bailout(tokenlist, errorLogger, tok2, "variable " + tok2->str() + " is used in rhs in assignment to itself");
-                break;
-            }
+// Check if dereferencing an object that doesn't have unique ownership
+static bool derefShared(const Token* tok)
+{
+    if (!tok)
+        return false;
+    if (!tok->isUnaryOp("*") && tok->str() != "[" && tok->str() != ".")
+        return false;
+    if (tok->str() == "." && tok->originalName() != "->")
+        return false;
+    const Token* ptrTok = tok->astOperand1();
+    return !hasUniqueOwnership(ptrTok);
+}
 
-            if (Token::Match(tok2->previous(), "sizeof|.")) {
-                const Token *prev = tok2->previous();
-                while (Token::Match(prev,"%name%|.") && prev->str() != "sizeof")
-                    prev = prev->previous();
-                if (prev && prev->str() == "sizeof")
-                    continue;
-            }
+ValueFlow::Value ValueFlow::getLifetimeObjValue(const Token *tok, bool inconclusive)
+{
+    std::vector<ValueFlow::Value> values = ValueFlow::getLifetimeObjValues(tok, inconclusive);
+    // There should only be one lifetime
+    if (values.size() != 1)
+        return ValueFlow::Value{};
+    return std::move(values.front());
+}
 
-            // assigned by subfunction?
-            bool inconclusive = false;
-            if (isVariableChangedByFunctionCall(tok2, std::max(val.indirect, val2.indirect), settings, &inconclusive)) {
-                if (settings->debugwarnings)
-                    bailout(tokenlist, errorLogger, tok2, "possible assignment of " + tok2->str() + " by subfunction");
-                break;
+template<class Predicate>
+static std::vector<ValueFlow::LifetimeToken> getLifetimeTokens(const Token* tok,
+                                                               bool escape,
+                                                               ErrorPath errorPath,
+                                                               Predicate pred,
+                                                               const Settings& settings,
+                                                               int depth = 20)
+{
+    if (!tok)
+        return std::vector<ValueFlow::LifetimeToken> {};
+    if (Token::simpleMatch(tok, "..."))
+        return std::vector<ValueFlow::LifetimeToken>{};
+    const Variable *var = tok->variable();
+    if (pred(tok))
+        return {{tok, std::move(errorPath)}};
+    if (depth < 0)
+        return {{tok, std::move(errorPath)}};
+    if (var && var->declarationId() == tok->varId()) {
+        if (var->isReference() || var->isRValueReference()) {
+            const Token * const varDeclEndToken = var->declEndToken();
+            if (!varDeclEndToken)
+                return {{tok, true, std::move(errorPath)}};
+            if (var->isArgument()) {
+                errorPath.emplace_back(varDeclEndToken, "Passed to reference.");
+                return {{tok, true, std::move(errorPath)}};
             }
-            // Impossible values can't be inconclusive
-            if (val.isImpossible() || val2.isImpossible())
-                break;
-            val.setInconclusive(inconclusive);
-            val2.setInconclusive(inconclusive);
-
-            // skip if variable is conditionally used in ?: expression
-            if (const Token *parent = skipValueInConditionalExpression(tok2)) {
-                if (settings->debugwarnings)
-                    bailout(tokenlist,
-                            errorLogger,
-                            tok2,
-                            "no simplification of " + tok2->str() + " within " + (Token::Match(parent,"[?:]") ? "?:" : parent->str()) + " expression");
-                continue;
+            if (Token::Match(varDeclEndToken, "=|{")) {
+                errorPath.emplace_back(varDeclEndToken, "Assigned to reference.");
+                const Token *vartok = varDeclEndToken->astOperand2();
+                const bool temporary = isTemporary(vartok, nullptr, true);
+                const bool nonlocal = var->isStatic() || var->isGlobal();
+                if (vartok == tok || (nonlocal && temporary) ||
+                    (!escape && (var->isConst() || var->isRValueReference()) && temporary))
+                    return {{tok, true, std::move(errorPath)}};
+                if (vartok)
+                    return getLifetimeTokens(vartok, escape, std::move(errorPath), pred, settings, depth - 1);
+            } else if (Token::simpleMatch(var->nameToken()->astParent(), ":") &&
+                       var->nameToken()->astParent()->astParent() &&
+                       Token::simpleMatch(var->nameToken()->astParent()->astParent()->previous(), "for (")) {
+                errorPath.emplace_back(var->nameToken(), "Assigned to reference.");
+                const Token* vartok = var->nameToken();
+                if (vartok == tok)
+                    return {{tok, true, std::move(errorPath)}};
+                const Token* contok = var->nameToken()->astParent()->astOperand2();
+                if (astIsContainer(contok))
+                    return ValueFlow::LifetimeToken::setAddressOf(
+                        getLifetimeTokens(contok, escape, std::move(errorPath), pred, settings, depth - 1),
+                        false);
+                return std::vector<ValueFlow::LifetimeToken>{};
+            } else {
+                return std::vector<ValueFlow::LifetimeToken> {};
             }
-
-            // do-while condition, break in the loop body
-            {
-                const Token *parent = tok2->astParent();
-                while (parent && !Token::simpleMatch(parent->previous(), "while ("))
-                    parent = parent->astParent();
-                if (parent && Token::simpleMatch(parent->tokAt(-2), "} while (") && Token::simpleMatch(parent->linkAt(-2)->previous(), "do {")) {
-                    bool breakBailout = false;
-                    for (const Token *iftok = parent->linkAt(-2); iftok != parent; iftok = iftok->next()) {
-                        if (!Token::simpleMatch(iftok, "if ("))
-                            continue;
-                        if (!Token::simpleMatch(iftok->linkAt(1), ") { break"))
-                            continue;
-                        ProgramMemory programMemory;
-                        programMemory.setIntValue(varid, num);
-                        if (conditionIsTrue(iftok->next()->astOperand2(), programMemory)) {
-                            breakBailout = true;
-                            break;
-                        }
+        }
+    } else if (Token::Match(tok->previous(), "%name% (")) {
+        const Function *f = tok->previous()->function();
+        if (f) {
+            if (!Function::returnsReference(f))
+                return {{tok, std::move(errorPath)}};
+            std::vector<ValueFlow::LifetimeToken> result;
+            std::vector<const Token*> returns = Function::findReturns(f);
+            for (const Token* returnTok : returns) {
+                if (returnTok == tok)
+                    continue;
+                for (ValueFlow::LifetimeToken& lt : getLifetimeTokens(returnTok, escape, errorPath, pred, settings, depth - returns.size())) {
+                    const Token* argvarTok = lt.token;
+                    const Variable* argvar = argvarTok->variable();
+                    const Token* argTok = nullptr;
+                    if (argvar && argvar->isArgument() && (argvar->isReference() || argvar->isRValueReference())) {
+                        const int n = getArgumentPos(argvar, f);
+                        if (n < 0)
+                            return std::vector<ValueFlow::LifetimeToken> {};
+                        std::vector<const Token*> args = getArguments(tok->previous());
+                        // TODO: Track lifetimes of default parameters
+                        if (n >= args.size())
+                            return std::vector<ValueFlow::LifetimeToken> {};
+                        argTok = args[n];
+                        lt.errorPath.emplace_back(returnTok, "Return reference.");
+                        lt.errorPath.emplace_back(tok->previous(), "Called function passing '" + argTok->expressionString() + "'.");
+                    } else if (Token::Match(tok->tokAt(-2), ". %name% (") && !derefShared(tok->tokAt(-2)) &&
+                               exprDependsOnThis(argvarTok)) {
+                        argTok = tok->tokAt(-2)->astOperand1();
+                        lt.errorPath.emplace_back(returnTok, "Return reference that depends on 'this'.");
+                        lt.errorPath.emplace_back(tok->previous(),
+                                                  "Calling member function on '" + argTok->expressionString() + "'.");
                     }
-                    if (breakBailout) {
-                        if (settings->debugwarnings)
-                            bailout(tokenlist,
-                                    errorLogger,
-                                    tok2,
-                                    "no simplification of " + tok2->str() + " in do-while condition since there is a break in the loop body");
-                        break;
+                    if (argTok) {
+                        std::vector<ValueFlow::LifetimeToken> arglts = ValueFlow::LifetimeToken::setInconclusive(
+                            getLifetimeTokens(argTok, escape, std::move(lt.errorPath), pred, settings, depth - returns.size()),
+                            returns.size() > 1);
+                        result.insert(result.end(), arglts.cbegin(), arglts.cend());
                     }
                 }
             }
-
-            setTokenValue(tok2, val, settings);
-            if (val2.condition)
-                setTokenValue(tok2,val2, settings);
-            if (tok2 == var->nameToken())
-                break;
-        }
-
-        // skip sizeof etc..
-        if (tok2->str() == ")" && Token::Match(tok2->link()->previous(), "sizeof|typeof|typeid ("))
-            tok2 = tok2->link();
-
-        // goto label
-        if (Token::Match(tok2, "[;{}] %name% :")) {
-            if (settings->debugwarnings)
-                bailout(tokenlist, errorLogger, tok2->next(), "variable " + var->name() + " stopping on goto label");
-            break;
+            return result;
         }
-
-        if (tok2->str() == "}") {
-            const Token *vartok = Token::findmatch(tok2->link(), "%varid%", tok2, varid);
-            while (Token::Match(vartok, "%name% = %num% ;") && !vartok->tokAt(2)->getValue(num))
-                vartok = Token::findmatch(vartok->next(), "%varid%", tok2, varid);
-            if (vartok) {
-                if (settings->debugwarnings) {
-                    std::string errmsg = "variable ";
-                    errmsg += var->name() + " ";
-                    errmsg += "stopping on }";
-                    bailout(tokenlist, errorLogger, tok2, errmsg);
-                }
-                break;
-            } else {
-                tok2 = tok2->link();
-            }
-        } else if (tok2->str() == "{") {
-            // if variable is assigned in loop don't look before the loop
-            if (tok2->previous() &&
-                (Token::simpleMatch(tok2->previous(), "do") ||
-                 (tok2->strAt(-1) == ")" && Token::Match(tok2->linkAt(-1)->previous(), "for|while (")))) {
-
-                const Token *start = tok2;
-                const Token *end   = start->link();
-                if (isVariableChanged(start,end,varid,var->isGlobal(),settings, tokenlist->isCPP())) {
-                    if (settings->debugwarnings)
-                        bailout(tokenlist, errorLogger, tok2, "variable " + var->name() + " is assigned in loop. so valueflow analysis bailout when start of loop is reached.");
-                    break;
-                }
+        if (Token::Match(tok->tokAt(-2), ". %name% (") && tok->tokAt(-2)->originalName() != "->" && astIsContainer(tok->tokAt(-2)->astOperand1())) {
+            const Library::Container* library = getLibraryContainer(tok->tokAt(-2)->astOperand1());
+            const Library::Container::Yield y = library->getYield(tok->strAt(-1));
+            if (y == Library::Container::Yield::AT_INDEX || y == Library::Container::Yield::ITEM) {
+                errorPath.emplace_back(tok->previous(), "Accessing container.");
+                return ValueFlow::LifetimeToken::setAddressOf(
+                    getLifetimeTokens(tok->tokAt(-2)->astOperand1(), escape, std::move(errorPath), pred, settings, depth - 1),
+                    false);
             }
+        }
+    } else if (Token::Match(tok, ".|::|[") || tok->isUnaryOp("*")) {
 
-            // Global variable : stop when leaving the function scope
-            if (!var->isLocal()) {
-                if (!Token::Match(tok2->previous(), ")|else|do {"))
-                    break;
-                if ((tok2->previous()->str() == ")") &&
-                    !Token::Match(tok2->linkAt(-1)->previous(), "if|for|while ("))
+        const Token *vartok = tok;
+        while (vartok) {
+            if (vartok->str() == "[" || vartok->isUnaryOp("*"))
+                vartok = vartok->astOperand1();
+            else if (vartok->str() == ".") {
+                if (!Token::simpleMatch(vartok->astOperand1(), ".") &&
+                    !(vartok->astOperand2() && vartok->astOperand2()->valueType() && vartok->astOperand2()->valueType()->reference != Reference::None))
+                    vartok = vartok->astOperand1();
+                else
                     break;
             }
-        } else if (tok2->str() == ";") {
-            const Token *parent = tok2->previous();
-            while (parent && !Token::Match(parent, "return|break|continue|goto"))
-                parent = parent->astParent();
-            // reaching a break/continue/return
-            if (parent) {
-                if (settings->debugwarnings)
-                    bailout(tokenlist, errorLogger, tok2, "variable " + var->name() + " stopping on " + parent->str());
+            else if (vartok->str() == "::")
+                vartok = vartok->astOperand2();
+            else
                 break;
-            }
         }
 
-        if (Token::Match(tok2, "%name% (") && !Token::simpleMatch(tok2->linkAt(1), ") {")) {
-            // bailout: global non-const variables
-            if (!(var->isLocal() || var->isArgument()) && !var->isConst()) {
-                if (settings->debugwarnings)
-                    bailout(tokenlist, errorLogger, tok, "global variable " + var->name());
-                return;
+        if (!vartok)
+            return {{tok, std::move(errorPath)}};
+        if (derefShared(vartok->astParent())) {
+            for (const ValueFlow::Value &v : vartok->values()) {
+                if (!v.isLocalLifetimeValue())
+                    continue;
+                if (v.tokvalue == tok)
+                    continue;
+                errorPath.insert(errorPath.end(), v.errorPath.cbegin(), v.errorPath.cend());
+                return ValueFlow::LifetimeToken::setAddressOf(
+                    getLifetimeTokens(v.tokvalue, escape, std::move(errorPath), pred, settings, depth - 1),
+                    false);
             }
-        }
+        } else {
+            return ValueFlow::LifetimeToken::setAddressOf(
+                getLifetimeTokens(vartok, escape, std::move(errorPath), pred, settings, depth - 1), false);
+        }
+    } else if (Token::simpleMatch(tok, "{") && getArgumentStart(tok) &&
+               !Token::simpleMatch(getArgumentStart(tok), ",") && getArgumentStart(tok)->valueType()) {
+        const Token* vartok = getArgumentStart(tok);
+        auto vts = getParentValueTypes(tok, settings);
+        auto it = std::find_if(vts.cbegin(), vts.cend(), [&](const ValueType& vt) {
+            return vt.isTypeEqual(vartok->valueType());
+        });
+        if (it != vts.end())
+            return getLifetimeTokens(vartok, escape, std::move(errorPath), pred, settings, depth - 1);
     }
+    return {{tok, std::move(errorPath)}};
 }
 
-static bool isConditionKnown(const Token* tok, bool then)
+std::vector<ValueFlow::LifetimeToken> ValueFlow::getLifetimeTokens(const Token* tok, const Settings& settings, bool escape, ErrorPath errorPath)
 {
-    const char* op = "||";
-    if (then)
-        op = "&&";
-    const Token* parent = tok->astParent();
-    while (parent && parent->str() == op)
-        parent = parent->astParent();
-    return (parent && parent->str() == "(");
+    return getLifetimeTokens(tok, escape, std::move(errorPath), [](const Token*) {
+        return false;
+    }, settings);
 }
 
-static void valueFlowBeforeCondition(TokenList *tokenlist, SymbolDatabase *symboldatabase, ErrorLogger *errorLogger, const Settings *settings)
+bool ValueFlow::hasLifetimeToken(const Token* tok, const Token* lifetime, const Settings& settings)
 {
-    for (const Scope * scope : symboldatabase->functionScopes) {
-        for (Token* tok = const_cast<Token*>(scope->bodyStart); tok != scope->bodyEnd; tok = tok->next()) {
-            MathLib::bigint num = 0;
-            const Token *vartok = nullptr;
-            if (tok->isComparisonOp() && tok->astOperand1() && tok->astOperand2()) {
-                if (tok->astOperand1()->isName() && tok->astOperand2()->hasKnownIntValue()) {
-                    vartok = tok->astOperand1();
-                    num = tok->astOperand2()->values().front().intvalue;
-                } else if (tok->astOperand1()->hasKnownIntValue() && tok->astOperand2()->isName()) {
-                    vartok = tok->astOperand2();
-                    num = tok->astOperand1()->values().front().intvalue;
-                } else {
-                    continue;
-                }
-            } else if (Token::Match(tok->previous(), "if|while ( %name% %oror%|&&|)") ||
-                       Token::Match(tok, "%oror%|&& %name% %oror%|&&|)")) {
-                vartok = tok->next();
-                num = 0;
-            } else if (Token::Match(tok, "[!?]") && Token::Match(tok->astOperand1(), "%name%")) {
-                vartok = tok->astOperand1();
-                num = 0;
-            } else {
-                continue;
-            }
-
-            int varid = vartok->varId();
-            const Variable * const var = vartok->variable();
-
-            if (varid == 0U || !var)
-                continue;
-
-            if (tok->str() == "?" && tok->isExpandedMacro()) {
-                if (settings->debugwarnings)
-                    bailout(tokenlist, errorLogger, tok, "variable " + var->name() + ", condition is defined in macro");
-                continue;
-            }
-
-            // bailout: for/while-condition, variable is changed in while loop
-            for (const Token *tok2 = tok; tok2; tok2 = tok2->astParent()) {
-                if (tok2->astParent() || tok2->str() != "(" || !Token::simpleMatch(tok2->link(), ") {"))
-                    continue;
-
-                // Variable changed in 3rd for-expression
-                if (Token::simpleMatch(tok2->previous(), "for (")) {
-                    if (tok2->astOperand2() && tok2->astOperand2()->astOperand2() && isVariableChanged(tok2->astOperand2()->astOperand2(), tok2->link(), varid, var->isGlobal(), settings, tokenlist->isCPP())) {
-                        varid = 0U;
-                        if (settings->debugwarnings)
-                            bailout(tokenlist, errorLogger, tok, "variable " + var->name() + " used in loop");
-                    }
-                }
-
-                // Variable changed in loop code
-                if (Token::Match(tok2->previous(), "for|while (")) {
-                    const Token * const start = tok2->link()->next();
-                    const Token * const end   = start->link();
-
-                    if (isVariableChanged(start,end,varid,var->isGlobal(),settings, tokenlist->isCPP())) {
-                        varid = 0U;
-                        if (settings->debugwarnings)
-                            bailout(tokenlist, errorLogger, tok, "variable " + var->name() + " used in loop");
-                    }
-                }
+    bool result = false;
+    getLifetimeTokens(tok, false, ErrorPath{}, [&](const Token* tok2) {
+        result = tok2->exprId() == lifetime->exprId();
+        return result;
+    }, settings);
+    return result;
+}
 
-                // if,macro => bailout
-                else if (Token::simpleMatch(tok2->previous(), "if (") && tok2->previous()->isExpandedMacro()) {
-                    varid = 0U;
-                    if (settings->debugwarnings)
-                        bailout(tokenlist, errorLogger, tok, "variable " + var->name() + ", condition is defined in macro");
-                }
-            }
-            if (varid == 0U)
-                continue;
+static const Token* getLifetimeToken(const Token* tok, ErrorPath& errorPath, const Settings& settings, bool* addressOf = nullptr)
+{
+    std::vector<ValueFlow::LifetimeToken> lts = ValueFlow::getLifetimeTokens(tok, settings);
+    if (lts.size() != 1)
+        return nullptr;
+    if (lts.front().inconclusive)
+        return nullptr;
+    if (addressOf)
+        *addressOf = lts.front().addressOf;
+    errorPath.insert(errorPath.end(), lts.front().errorPath.cbegin(), lts.front().errorPath.cend());
+    return lts.front().token;
+}
 
-            // extra logic for unsigned variables 'i>=1' => possible value can also be 0
-            if (Token::Match(tok, "<|>")) {
-                if (num != 0)
-                    continue;
-                if (!var->typeStartToken()->isUnsigned())
-                    continue;
-            }
-            ValueFlow::Value val(tok, num);
-            val.varId = varid;
-            ValueFlow::Value val2;
-            if (num==1U && Token::Match(tok,"<=|>=")) {
-                if (var->typeStartToken()->isUnsigned()) {
-                    val2 = ValueFlow::Value(tok,0);
-                    val2.varId = varid;
-                }
-            }
-            Token* startTok = tok->astParent() ? tok->astParent() : tok->previous();
-            valueFlowReverse(tokenlist, startTok, vartok, val, val2, errorLogger, settings);
-        }
-    }
+const Variable* ValueFlow::getLifetimeVariable(const Token* tok, ErrorPath& errorPath, const Settings& settings, bool* addressOf)
+{
+    const Token* tok2 = getLifetimeToken(tok, errorPath, settings, addressOf);
+    if (tok2 && tok2->variable())
+        return tok2->variable();
+    return nullptr;
 }
 
-static void removeValues(std::list<ValueFlow::Value> &values, const std::list<ValueFlow::Value> &valuesToRemove)
+const Variable* ValueFlow::getLifetimeVariable(const Token* tok, const Settings& settings)
 {
-    for (std::list<ValueFlow::Value>::iterator it = values.begin(); it != values.end();) {
-        const bool found = std::any_of(valuesToRemove.cbegin(), valuesToRemove.cend(),
-        [=](const ValueFlow::Value &v2) {
-            return it->intvalue == v2.intvalue;
-        });
-        if (found)
-            values.erase(it++);
-        else
-            ++it;
-    }
+    ErrorPath errorPath;
+    return getLifetimeVariable(tok, errorPath, settings, nullptr);
 }
 
-static void valueFlowAST(Token *tok, nonneg int varid, const ValueFlow::Value &value, const Settings *settings)
+static bool isNotLifetimeValue(const ValueFlow::Value& val)
 {
-    if (!tok)
-        return;
-    if (tok->varId() == varid)
-        setTokenValue(tok, value, settings);
-    valueFlowAST(tok->astOperand1(), varid, value, settings);
-    if (tok->str() == "&&" && tok->astOperand1() && tok->astOperand1()->getValue(0)) {
-        ProgramMemory pm;
-        pm.setValue(varid,value);
-        if (conditionIsFalse(tok->astOperand1(), pm))
-            return;
-    } else if (tok->str() == "||" && tok->astOperand1()) {
-        const std::list<ValueFlow::Value> &values = tok->astOperand1()->values();
-        const bool nonzero = std::any_of(values.cbegin(), values.cend(),
-        [=](const ValueFlow::Value &v) {
-            return v.intvalue != 0;
-        });
-        if (!nonzero)
-            return;
-        ProgramMemory pm;
-        pm.setValue(varid,value);
-        if (conditionIsTrue(tok->astOperand1(), pm))
-            return;
-    }
-    valueFlowAST(tok->astOperand2(), varid, value, settings);
+    return !val.isLifetimeValue();
 }
 
-/** if known variable is changed in loop body, change it to a possible value */
-static bool handleKnownValuesInLoop(const Token                 *startToken,
-                                    const Token                 *endToken,
-                                    std::list<ValueFlow::Value> *values,
-                                    nonneg int                  varid,
-                                    bool                        globalvar,
-                                    const Settings              *settings)
+static bool isLifetimeOwned(const ValueType* vtParent)
 {
-    const bool isChanged = isVariableChanged(startToken, endToken, varid, globalvar, settings, true);
-    if (!isChanged)
-        return false;
-    lowerToPossible(*values);
-    return isChanged;
+    if (vtParent->container)
+        return !vtParent->container->view;
+    return vtParent->type == ValueType::CONTAINER;
 }
 
-static bool evalAssignment(ValueFlow::Value &lhsValue, const std::string &assign, const ValueFlow::Value &rhsValue)
+static bool isLifetimeOwned(const ValueType *vt, const ValueType *vtParent)
 {
-    if (lhsValue.isIntValue()) {
-        if (assign == "+=")
-            lhsValue.intvalue += rhsValue.intvalue;
-        else if (assign == "-=")
-            lhsValue.intvalue -= rhsValue.intvalue;
-        else if (assign == "*=")
-            lhsValue.intvalue *= rhsValue.intvalue;
-        else if (assign == "/=") {
-            if (rhsValue.intvalue == 0)
-                return false;
-            else
-                lhsValue.intvalue /= rhsValue.intvalue;
-        } else if (assign == "%=") {
-            if (rhsValue.intvalue == 0)
-                return false;
-            else
-                lhsValue.intvalue %= rhsValue.intvalue;
-        } else if (assign == "&=")
-            lhsValue.intvalue &= rhsValue.intvalue;
-        else if (assign == "|=")
-            lhsValue.intvalue |= rhsValue.intvalue;
-        else if (assign == "^=")
-            lhsValue.intvalue ^= rhsValue.intvalue;
-        else
-            return false;
-    } else if (lhsValue.isFloatValue()) {
-        if (assign == "+=")
-            lhsValue.floatValue += rhsValue.intvalue;
-        else if (assign == "-=")
-            lhsValue.floatValue -= rhsValue.intvalue;
-        else if (assign == "*=")
-            lhsValue.floatValue *= rhsValue.intvalue;
-        else if (assign == "/=")
-            lhsValue.floatValue /= rhsValue.intvalue;
-        else
-            return false;
-    } else {
+    if (!vtParent)
+        return false;
+    if (isLifetimeOwned(vtParent))
+        return true;
+    if (!vt)
         return false;
+    // If converted from iterator to pointer then the iterator is most likely a pointer
+    if (vtParent->pointer == 1 && vt->pointer == 0 && vt->type == ValueType::ITERATOR)
+        return false;
+    if (vt->type != ValueType::UNKNOWN_TYPE && vtParent->type != ValueType::UNKNOWN_TYPE) {
+        if (vt->pointer != vtParent->pointer)
+            return true;
+        if (vt->type != vtParent->type) {
+            if (vtParent->type == ValueType::RECORD)
+                return true;
+            if (isLifetimeOwned(vtParent))
+                return true;
+        }
     }
-    return true;
+
+    return false;
 }
 
-// Check if its an alias of the variable or is being aliased to this variable
-static bool isAliasOf(const Variable * var, const Token *tok, nonneg int varid, const std::list<ValueFlow::Value>& values)
+static bool isLifetimeBorrowed(const ValueType *vt, const ValueType *vtParent)
 {
-    if (tok->varId() == varid)
+    if (!vtParent)
         return false;
-    if (tok->varId() == 0)
+    if (!vt)
         return false;
-    if (isAliasOf(tok, varid))
+    if (vt->pointer > 0 && vt->pointer == vtParent->pointer)
         return true;
-    if (!var->isPointer())
-        return false;
-    // Search through non value aliases
-    for (const ValueFlow::Value &val : values) {
-        if (!val.isNonValue())
-            continue;
-        if (val.isInconclusive())
-            continue;
-        if (val.isLifetimeValue() && !val.isLocalLifetimeValue())
-            continue;
-        if (val.isLifetimeValue() && val.lifetimeKind != ValueFlow::Value::LifetimeKind::Address)
-            continue;
-        if (!Token::Match(val.tokvalue, ".|&|*|%var%"))
-            continue;
-        if (astHasVar(val.tokvalue, tok->varId()))
+    if (vtParent->container && vtParent->container->view)
+        return true;
+    if (vt->type != ValueType::UNKNOWN_TYPE && vtParent->type != ValueType::UNKNOWN_TYPE && vtParent->container == vt->container) {
+        if (vtParent->pointer > vt->pointer)
+            return true;
+        if (vtParent->pointer < vt->pointer && vtParent->isIntegral())
+            return true;
+        ValueType temp = *vtParent;
+        if ((temp.constness & 1) && !(vt->constness & 1)) // allow assignment to const/volatile
+            temp.constness &= ~1;
+        if ((temp.volatileness & 1) && !(vt->volatileness & 1))
+            temp.volatileness &= ~1;
+        if (temp.str() == vt->str())
             return true;
     }
+
     return false;
 }
 
-static std::set<int> getIndirections(const std::list<ValueFlow::Value>& values)
+static const Token* skipCVRefs(const Token* tok, const Token* endTok)
 {
-    std::set<int> result;
-    std::transform(values.begin(), values.end(), std::inserter(result, result.end()), [](const ValueFlow::Value& v) {
-        return std::max(0, v.indirect);
-    });
-    return result;
+    while (tok != endTok && Token::Match(tok, "const|volatile|auto|&|&&"))
+        tok = tok->next();
+    return tok;
 }
 
-static void valueFlowForwardExpression(Token* startToken,
-                                       const Token* endToken,
-                                       const Token* exprTok,
-                                       const std::list<ValueFlow::Value>& values,
-                                       const TokenList* const tokenlist,
-                                       const Settings* settings)
+static bool isNotEqual(std::pair<const Token*, const Token*> x, std::pair<const Token*, const Token*> y)
 {
-    FwdAnalysis fwdAnalysis(tokenlist->isCPP(), settings->library);
-    for (const FwdAnalysis::KnownAndToken read : fwdAnalysis.valueFlow(exprTok, startToken, endToken)) {
-        for (const ValueFlow::Value& value : values) {
-            // Don't set inconclusive values
-            if (value.isInconclusive())
-                continue;
-            ValueFlow::Value v = value;
-            if (v.isImpossible()) {
-                if (read.known)
-                    continue;
-            } else if (!read.known) {
-                v.valueKind = ValueFlow::Value::ValueKind::Possible;
-            }
-            setTokenValue(const_cast<Token*>(read.token), v, settings);
+    const Token* start1 = x.first;
+    const Token* start2 = y.first;
+    if (start1 == nullptr || start2 == nullptr)
+        return false;
+    while (start1 != x.second && start2 != y.second) {
+        const Token* tok1 = skipCVRefs(start1, x.second);
+        if (tok1 != start1) {
+            start1 = tok1;
+            continue;
+        }
+        const Token* tok2 = skipCVRefs(start2, y.second);
+        if (tok2 != start2) {
+            start2 = tok2;
+            continue;
         }
+        if (start1->str() != start2->str())
+            return true;
+        start1 = start1->next();
+        start2 = start2->next();
     }
+    start1 = skipCVRefs(start1, x.second);
+    start2 = skipCVRefs(start2, y.second);
+    return !(start1 == x.second && start2 == y.second);
+}
+static bool isNotEqual(std::pair<const Token*, const Token*> x, const std::string& y, bool cpp, const Settings& settings)
+{
+    TokenList tokenList(settings, cpp ? Standards::Language::CPP : Standards::Language::C);
+    tokenList.createTokensFromBuffer(y.data(), y.size()); // TODO: check result?
+    return isNotEqual(x, std::make_pair(tokenList.front(), tokenList.back()));
+}
+static bool isNotEqual(std::pair<const Token*, const Token*> x, const ValueType* y, bool cpp, const Settings& settings)
+{
+    if (y == nullptr)
+        return false;
+    if (y->originalTypeName.empty())
+        return false;
+    return isNotEqual(x, y->originalTypeName, cpp, settings);
 }
 
-static bool valueFlowForwardVariable(Token* const startToken,
-                                     const Token* const endToken,
-                                     const Variable* const var,
-                                     const nonneg int varid,
-                                     std::list<ValueFlow::Value> values,
-                                     const bool constValue,
-                                     const bool subFunction,
-                                     TokenList* const tokenlist,
-                                     ErrorLogger* const errorLogger,
-                                     const Settings* const settings)
+static bool isDifferentType(const Token* src, const Token* dst, const Settings& settings)
 {
-    int indentlevel = 0;
-    int number_of_if = 0;
-    int varusagelevel = -1;
-    bool returnStatement = false;  // current statement is a return, stop analysis at the ";"
-    bool read = false;  // is variable value read?
+    const Type* t = Token::typeOf(src);
+    const Type* parentT = Token::typeOf(dst);
+    if (t && parentT) {
+        if (t->classDef && parentT->classDef && t->classDef != parentT->classDef)
+            return true;
+    } else {
+        std::pair<const Token*, const Token*> decl = Token::typeDecl(src);
+        std::pair<const Token*, const Token*> parentdecl = Token::typeDecl(dst);
+        const bool isCpp = (src && src->isCpp()) || (dst && dst->isCpp());
+        if (isNotEqual(decl, parentdecl) && !(isCpp && (Token::simpleMatch(decl.first, "auto") || Token::simpleMatch(parentdecl.first, "auto"))))
+            return true;
+        if (isNotEqual(decl, dst->valueType(), isCpp, settings))
+            return true;
+        if (isNotEqual(parentdecl, src->valueType(), isCpp, settings))
+            return true;
+    }
+    return false;
+}
 
-    if (values.empty())
+bool ValueFlow::isLifetimeBorrowed(const Token *tok, const Settings &settings)
+{
+    if (!tok)
         return true;
-
-    for (Token *tok2 = startToken; tok2 && tok2 != endToken; tok2 = tok2->next()) {
-        if (values.empty())
+    if (tok->str() == ",")
+        return true;
+    if (!tok->astParent())
+        return true;
+    const Token* parent = nullptr;
+    const ValueType* vt = tok->valueType();
+    std::vector<ValueType> vtParents = getParentValueTypes(tok, settings, &parent);
+    for (const ValueType& vtParent : vtParents) {
+        if (isLifetimeBorrowed(vt, &vtParent))
             return true;
-        if (indentlevel >= 0 && tok2->str() == "{")
-            ++indentlevel;
-        else if (indentlevel >= 0 && tok2->str() == "}") {
-            --indentlevel;
-            if (indentlevel <= 0 && isReturnScope(tok2, settings) && Token::Match(tok2->link()->previous(), "else|) {")) {
-                const Token *condition = tok2->link();
-                const bool iselse = Token::simpleMatch(condition->tokAt(-2), "} else {");
-                if (iselse)
-                    condition = condition->linkAt(-2);
-                if (condition && Token::simpleMatch(condition->previous(), ") {"))
-                    condition = condition->linkAt(-1)->astOperand2();
-                else
-                    condition = nullptr;
-                if (!condition) {
-                    if (settings->debugwarnings)
-                        bailout(
-                            tokenlist,
-                            errorLogger,
-                            tok2,
-                            "variable " + var->name() +
-                            " valueFlowForwardVariable, bailing out since it's unknown if conditional return is executed");
-                    return false;
-                }
+        if (isLifetimeOwned(vt, &vtParent))
+            return false;
+    }
+    if (parent) {
+        if (isDifferentType(tok, parent, settings))
+            return false;
+    }
+    return true;
+}
 
-                bool bailoutflag = false;
-                const Token * const start1 = iselse ? tok2->link()->linkAt(-2) : nullptr;
-                for (std::list<ValueFlow::Value>::iterator it = values.begin(); it != values.end();) {
-                    if (!iselse && conditionIsTrue(condition, getProgramMemory(condition->astParent(), varid, *it))) {
-                        bailoutflag = true;
-                        break;
-                    }
-                    if (iselse && conditionIsFalse(condition, getProgramMemory(condition->astParent(), varid, *it))) {
-                        bailoutflag = true;
-                        break;
-                    }
-                    if (iselse && it->isPossible() && isVariableChanged(start1, start1->link(), varid, var->isGlobal(), settings, tokenlist->isCPP()))
-                        values.erase(it++);
-                    else
-                        ++it;
-                }
-                if (bailoutflag) {
-                    if (settings->debugwarnings)
-                        bailout(tokenlist,
-                                errorLogger,
-                                tok2,
-                                "variable " + var->name() +
-                                " valueFlowForwardVariable, conditional return is assumed to be executed");
-                    return false;
-                }
+static void valueFlowLifetimeFunction(Token *tok, const TokenList &tokenlist, ErrorLogger &errorLogger, const Settings &settings);
 
-                if (values.empty())
-                    return true;
-            } else if (indentlevel <= 0 &&
-                       Token::simpleMatch(tok2->link()->previous(), "else {") &&
-                       !isReturnScope(tok2->link()->tokAt(-2), settings) &&
-                       isVariableChanged(tok2->link(), tok2, varid, var->isGlobal(), settings, tokenlist->isCPP())) {
-                lowerToPossible(values);
-            }
-        }
+static void valueFlowLifetimeConstructor(Token *tok,
+                                         const TokenList &tokenlist,
+                                         ErrorLogger &errorLogger,
+                                         const Settings &settings);
 
-        // skip lambda functions
-        // TODO: handle lambda functions
-        if (tok2->str() == "[" && findLambdaEndToken(tok2)) {
-            Token *lambdaEndToken = const_cast<Token *>(findLambdaEndToken(tok2));
-            if (isVariableChanged(lambdaEndToken->link(), lambdaEndToken, varid, var->isGlobal(), settings, tokenlist->isCPP()))
-                return false;
-            // Don't skip lambdas for lifetime values
-            if (!std::all_of(values.begin(), values.end(), std::mem_fn(&ValueFlow::Value::isLifetimeValue))) {
-                tok2 = lambdaEndToken;
-                continue;
+static bool isRangeForScope(const Scope* scope)
+{
+    if (!scope)
+        return false;
+    if (scope->type != ScopeType::eFor)
+        return false;
+    if (!scope->bodyStart)
+        return false;
+    if (!Token::simpleMatch(scope->bodyStart->previous(), ") {"))
+        return false;
+    return Token::simpleMatch(scope->bodyStart->linkAt(-1)->astOperand2(), ":");
+}
+
+static const Token* getEndOfVarScope(const Variable* var)
+{
+    if (!var)
+        return nullptr;
+    const Scope* innerScope = var->scope();
+    const Scope* outerScope = innerScope;
+    if (var->typeStartToken() && var->typeStartToken()->scope())
+        outerScope = var->typeStartToken()->scope();
+    if (!innerScope && outerScope)
+        innerScope = outerScope;
+    if (!innerScope || !outerScope)
+        return nullptr;
+    if (!innerScope->isExecutable())
+        return nullptr;
+    // If the variable is defined in a for/while initializer then we want to
+    // pick one token after the end so forward analysis can analyze the exit
+    // conditions
+    if (innerScope != outerScope && outerScope->isExecutable() && innerScope->isLoopScope() &&
+        !isRangeForScope(innerScope))
+        return innerScope->bodyEnd->next();
+    return innerScope->bodyEnd;
+}
+
+const Token* ValueFlow::getEndOfExprScope(const Token* tok, const Scope* defaultScope, bool smallest)
+{
+    const Token* end = nullptr;
+    bool local = false;
+    visitAstNodes(tok, [&](const Token* child) {
+        if (const Variable* var = child->variable()) {
+            local |= var->isLocal();
+            if (var->isLocal() || var->isArgument()) {
+                const Token* varEnd = getEndOfVarScope(var);
+                if (!end || (smallest ? precedes(varEnd, end) : succeeds(varEnd, end)))
+                    end = varEnd;
+
+                const Token* top = var->nameToken()->astTop();
+                if (Token::simpleMatch(top->tokAt(-1), "if (")) { // variable declared in if (...)
+                    const Token* elseTok = top->link()->linkAt(1);
+                    if (Token::simpleMatch(elseTok, "} else {") && tok->scope()->isNestedIn(elseTok->tokAt(2)->scope()))
+                        end = tok->scope()->bodyEnd;
+                }
             }
         }
-
-        if (Token::Match(tok2, "[;{}] %name% :") || tok2->str() == "case") {
-            lowerToPossible(values);
-            tok2 = tok2->tokAt(2);
-            continue;
+        return ChildrenToVisit::op1_and_op2;
+    });
+    if (!end && defaultScope)
+        end = defaultScope->bodyEnd;
+    if (!end) {
+        const Scope* scope = tok->scope();
+        if (scope)
+            end = scope->bodyEnd;
+        // If there is no local variables then pick the function scope
+        if (!local) {
+            while (scope && scope->isLocal())
+                scope = scope->nestedIn;
+            if (scope && scope->isExecutable())
+                end = scope->bodyEnd;
         }
+    }
+    return end;
+}
 
-        else if ((var->isGlobal() || tok2->str() == "asm") && Token::Match(tok2, "%name% (") && Token::Match(tok2->linkAt(1), ") !!{")) {
-            return false;
-        }
+static void valueFlowForwardLifetime(Token * tok, const TokenList &tokenlist, ErrorLogger &errorLogger, const Settings &settings)
+{
+    // Forward lifetimes to constructed variable
+    if (Token::Match(tok->previous(), "%var% {|(") && isVariableDecl(tok->previous())) {
+        std::list<ValueFlow::Value> values = tok->values();
+        values.remove_if(&isNotLifetimeValue);
+        valueFlowForward(nextAfterAstRightmostLeaf(tok), ValueFlow::getEndOfExprScope(tok), tok->previous(), std::move(values), tokenlist, errorLogger, settings);
+        return;
+    }
+    Token *parent = tok->astParent();
+    while (parent && parent->str() == ",")
+        parent = parent->astParent();
+    if (!parent)
+        return;
+    // Assignment
+    if (parent->str() == "=" && (!parent->astParent() || Token::simpleMatch(parent->astParent(), ";"))) {
+        // Rhs values..
+        if (!parent->astOperand2() || parent->astOperand2()->values().empty())
+            return;
 
-        // Skip sizeof etc
-        else if (Token::Match(tok2, "sizeof|typeof|typeid ("))
-            tok2 = tok2->linkAt(1);
+        if (!ValueFlow::isLifetimeBorrowed(parent->astOperand2(), settings))
+            return;
 
-        else if (Token::simpleMatch(tok2, "else {")) {
-            // Should scope be skipped because variable value is checked?
-            const Token *condition = tok2->linkAt(-1);
-            condition = condition ? condition->linkAt(-1) : nullptr;
-            condition = condition ? condition->astOperand2() : nullptr;
+        const Token* expr = getLHSVariableToken(parent);
+        if (!expr)
+            return;
 
-            const bool skipelse = std::any_of(values.cbegin(), values.cend(),
-            [=](const ValueFlow::Value &v) {
-                return conditionIsTrue(condition, getProgramMemory(tok2, varid, v));
-            });
-            if (skipelse) {
-                tok2 = tok2->linkAt(1);
-                continue;
-            }
-        }
+        if (expr->exprId() == 0)
+            return;
 
-        else if (Token::simpleMatch(tok2, "do {")) {
-            const Token *start = tok2->next();
-            const Token *end   = start->link();
-            if (Token::simpleMatch(end, "} while ("))
-                end = end->linkAt(2);
+        const Token* endOfVarScope = ValueFlow::getEndOfExprScope(expr);
 
-            if (isVariableChanged(start, end, varid, var->isGlobal(), settings, tokenlist->isCPP())) {
-                if (settings->debugwarnings)
-                    bailout(tokenlist,
-                            errorLogger,
-                            tok2,
-                            "variable " + var->name() + " valueFlowForwardVariable, assignment in do-while");
-                return false;
-            }
+        // Only forward lifetime values
+        std::list<ValueFlow::Value> values = parent->astOperand2()->values();
+        values.remove_if(&isNotLifetimeValue);
+        // Dont forward lifetimes that overlap
+        values.remove_if([&](const ValueFlow::Value& value) {
+            return findAstNode(value.tokvalue, [&](const Token* child) {
+                return child->exprId() == expr->exprId();
+            });
+        });
 
-            handleKnownValuesInLoop(start, end, &values, varid, var->isGlobal(), settings);
-        }
+        // Skip RHS
+        Token* nextExpression = nextAfterAstRightmostLeaf(parent);
 
-        // conditional block of code that assigns variable..
-        else if (!tok2->varId() && Token::Match(tok2, "%name% (") && Token::simpleMatch(tok2->linkAt(1), ") {")) {
-            // is variable changed in condition?
-            for (int i:getIndirections(values)) {
-                Token* tokChanged = findVariableChanged(tok2->next(), tok2->next()->link(), i, varid, var->isGlobal(), settings, tokenlist->isCPP());
-                if (tokChanged != nullptr) {
-                    // Set the value before bailing
-                    if (tokChanged->varId() == varid) {
-                        for (const ValueFlow::Value &v : values) {
-                            if (!v.isNonValue())
-                                continue;
-                            setTokenValue(tokChanged, v, settings);
-                        }
-                    }
-                    values.remove_if([&](const ValueFlow::Value& v) {
-                        return v.indirect == i;
-                    });
-                }
-            }
-            if (values.empty()) {
-                if (settings->debugwarnings)
-                    bailout(tokenlist,
-                            errorLogger,
-                            tok2,
-                            "variable " + var->name() + " valueFlowForwardVariable, assignment in condition");
-                return false;
-            }
+        if (expr->exprId() > 0) {
+            valueFlowForward(nextExpression, endOfVarScope->next(), expr, values, tokenlist, errorLogger, settings);
 
-            // if known variable is changed in loop body, change it to a possible value..
-            if (Token::Match(tok2, "for|while")) {
-                if (handleKnownValuesInLoop(tok2, tok2->linkAt(1)->linkAt(1), &values, varid, var->isGlobal(), settings))
-                    number_of_if++;
+            for (ValueFlow::Value& val : values) {
+                if (val.lifetimeKind == ValueFlow::Value::LifetimeKind::Address)
+                    val.lifetimeKind = ValueFlow::Value::LifetimeKind::SubObject;
             }
-
-            // Set values in condition
-            for (Token* tok3 = tok2->tokAt(2); tok3 != tok2->next()->link(); tok3 = tok3->next()) {
-                if (tok3->varId() == varid) {
-                    for (const ValueFlow::Value &v : values)
-                        setTokenValue(tok3, v, settings);
-                } else if (Token::Match(tok3, "%oror%|&&|?|;")) {
-                    break;
+            // TODO: handle `[`
+            if (Token::simpleMatch(parent->astOperand1(), ".")) {
+                const Token* parentLifetime =
+                    getParentLifetime(parent->astOperand1()->astOperand2(), settings.library);
+                if (parentLifetime && parentLifetime->exprId() > 0) {
+                    valueFlowForward(nextExpression, endOfVarScope, parentLifetime, std::move(values), tokenlist, errorLogger, settings);
                 }
             }
+        }
+        // Constructor
+    } else if (Token::simpleMatch(parent, "{") && !isScopeBracket(parent)) {
+        valueFlowLifetimeConstructor(parent, tokenlist, errorLogger, settings);
+        valueFlowForwardLifetime(parent, tokenlist, errorLogger, settings);
+        // Function call
+    } else if (Token::Match(parent->previous(), "%name% (")) {
+        valueFlowLifetimeFunction(parent->previous(), tokenlist, errorLogger, settings);
+        valueFlowForwardLifetime(parent, tokenlist, errorLogger, settings);
+        // Variable
+    } else if (tok->variable() && tok->variable()->scope()) {
+        const Variable *var = tok->variable();
+        const Token *endOfVarScope = var->scope()->bodyEnd;
 
-            const Token * const condTok = tok2->next()->astOperand2();
-            const bool condAlwaysTrue = (condTok && condTok->hasKnownIntValue() && condTok->values().front().intvalue != 0);
-            const bool condAlwaysFalse = (condTok && condTok->hasKnownIntValue() && condTok->values().front().intvalue == 0);
-
-            // Should scope be skipped because variable value is checked?
-            std::list<ValueFlow::Value> truevalues;
-            std::list<ValueFlow::Value> falsevalues;
-            for (const ValueFlow::Value &v : values) {
-                if (condAlwaysTrue) {
-                    truevalues.push_back(v);
-                    continue;
-                }
-                if (condAlwaysFalse) {
-                    falsevalues.push_back(v);
-                    continue;
-                }
-                // TODO: Compute program from tokvalue first
-                ProgramMemory programMemory = getProgramMemory(tok2, varid, v);
-                const bool isTrue = conditionIsTrue(condTok, programMemory);
-                const bool isFalse = conditionIsFalse(condTok, programMemory);
-
-                if (isTrue)
-                    truevalues.push_back(v);
-                if (isFalse)
-                    falsevalues.push_back(v);
-
-            }
-            if (!truevalues.empty() || !falsevalues.empty()) {
-                // '{'
-                const Token * const startToken1 = tok2->linkAt(1)->next();
-
-                bool vfresult = valueFlowForwardVariable(startToken1->next(),
-                                startToken1->link(),
-                                var,
-                                varid,
-                                truevalues,
-                                constValue,
-                                subFunction,
-                                tokenlist,
-                                errorLogger,
-                                settings);
+        std::list<ValueFlow::Value> values = tok->values();
+        Token *nextExpression = nextAfterAstRightmostLeaf(parent);
+        // Only forward lifetime values
+        values.remove_if(&isNotLifetimeValue);
+        valueFlowForward(nextExpression, endOfVarScope, tok, std::move(values), tokenlist, errorLogger, settings);
+        // Cast
+    } else if (parent->isCast()) {
+        std::list<ValueFlow::Value> values = tok->values();
+        // Only forward lifetime values
+        values.remove_if(&isNotLifetimeValue);
+        for (ValueFlow::Value& value:values)
+            setTokenValue(parent, std::move(value), settings);
+        valueFlowForwardLifetime(parent, tokenlist, errorLogger, settings);
+    }
+}
 
-                if (!condAlwaysFalse && isVariableChanged(startToken1, startToken1->link(), varid, var->isGlobal(), settings, tokenlist->isCPP())) {
-                    removeValues(values, truevalues);
-                    lowerToPossible(values);
-                }
+struct LifetimeStore {
+    const Token* argtok{};
+    std::string message;
+    ValueFlow::Value::LifetimeKind type = ValueFlow::Value::LifetimeKind::Object;
+    ErrorPath errorPath;
+    bool inconclusive{};
+    bool forward = true;
 
-                // goto '}'
-                tok2 = startToken1->link();
+    LifetimeStore() = default;
 
-                if (isReturnScope(tok2, settings) || !vfresult) {
-                    if (condAlwaysTrue)
-                        return false;
-                    removeValues(values, truevalues);
-                }
+    LifetimeStore(const Token* argtok,
+                  std::string message,
+                  ValueFlow::Value::LifetimeKind type = ValueFlow::Value::LifetimeKind::Object,
+                  bool inconclusive = false)
+        : argtok(argtok),
+        message(std::move(message)),
+        type(type),
+        inconclusive(inconclusive)
+    {}
 
-                if (Token::simpleMatch(tok2, "} else {")) {
-                    const Token * const startTokenElse = tok2->tokAt(2);
-
-                    vfresult = valueFlowForwardVariable(startTokenElse->next(),
-                                                        startTokenElse->link(),
-                                                        var,
-                                                        varid,
-                                                        falsevalues,
-                                                        constValue,
-                                                        subFunction,
-                                                        tokenlist,
-                                                        errorLogger,
-                                                        settings);
-
-                    if (!condAlwaysTrue && isVariableChanged(startTokenElse, startTokenElse->link(), varid, var->isGlobal(), settings, tokenlist->isCPP())) {
-                        removeValues(values, falsevalues);
-                        lowerToPossible(values);
-                    }
+    template<class F>
+    static void forEach(const TokenList& tokenlist,
+                        ErrorLogger& errorLogger,
+                        const Settings& settings,
+                        const std::vector<const Token*>& argtoks,
+                        const std::string& message,
+                        ValueFlow::Value::LifetimeKind type,
+                        F f) {
+        std::set<Token*> forwardToks;
+        for (const Token* arg : argtoks) {
+            LifetimeStore ls{arg, message, type};
+            ls.forward = false;
+            f(ls);
+            if (ls.forwardTok)
+                forwardToks.emplace(ls.forwardTok);
+        }
+        for (auto* tok : forwardToks) {
+            valueFlowForwardLifetime(tok, tokenlist, errorLogger, settings);
+        }
+    }
 
-                    // goto '}'
-                    tok2 = startTokenElse->link();
+    static LifetimeStore fromFunctionArg(const Function * f, const Token *tok, const Variable *var, const TokenList &tokenlist, const Settings& settings, ErrorLogger &errorLogger) {
+        if (!var)
+            return LifetimeStore{};
+        if (!var->isArgument())
+            return LifetimeStore{};
+        const int n = getArgumentPos(var, f);
+        if (n < 0)
+            return LifetimeStore{};
+        std::vector<const Token *> args = getArguments(tok);
+        if (n >= args.size()) {
+            if (settings.debugwarnings)
+                bailout(tokenlist,
+                        errorLogger,
+                        tok,
+                        "Argument mismatch: Function '" + tok->str() + "' returning lifetime from argument index " +
+                        std::to_string(n) + " but only " + std::to_string(args.size()) +
+                        " arguments are available.");
+            return LifetimeStore{};
+        }
+        const Token *argtok2 = args[n];
+        return LifetimeStore{argtok2, "Passed to '" + tok->expressionString() + "'.", ValueFlow::Value::LifetimeKind::Object};
+    }
 
-                    if (isReturnScope(tok2, settings) || !vfresult) {
-                        if (condAlwaysFalse)
-                            return false;
-                        removeValues(values, falsevalues);
-                    }
-                }
-                if (values.empty())
-                    return false;
+    template<class Predicate>
+    bool byRef(Token* tok,
+               const TokenList& tokenlist,
+               ErrorLogger& errorLogger,
+               const Settings& settings,
+               const Predicate& pred,
+               SourceLocation loc = SourceLocation::current())
+    {
+        if (!argtok)
+            return false;
+        bool update = false;
+        for (const ValueFlow::LifetimeToken& lt : ValueFlow::getLifetimeTokens(argtok, settings)) {
+            if (!settings.certainty.isEnabled(Certainty::inconclusive) && lt.inconclusive)
                 continue;
-            }
-
-            Token * const start = tok2->linkAt(1)->next();
-            Token * const end   = start->link();
-            const bool varusage = (indentlevel >= 0 && constValue && number_of_if == 0U) ?
-                                  isVariableChanged(start,end,varid,var->isGlobal(),settings, tokenlist->isCPP()) :
-                                  (nullptr != Token::findmatch(start, "%varid%", end, varid));
-            if (!read) {
-                read = bool(nullptr != Token::findmatch(tok2, "%varid% !!=", end, varid));
-            }
-            if (varusage) {
-                varusagelevel = indentlevel;
-
-                if (indentlevel < 0 && tok2->str() == "switch")
-                    return false;
-
-                // TODO: don't check noreturn scopes
-                if (read && (number_of_if > 0U || Token::findmatch(tok2, "%varid%", start, varid))) {
-                    // Set values in condition
-                    const Token * const condend = tok2->linkAt(1);
-                    for (Token *condtok = tok2; condtok != condend; condtok = condtok->next()) {
-                        if (condtok->varId() == varid) {
-                            for (const ValueFlow::Value &v : values)
-                                setTokenValue(condtok, v, settings);
-                        }
-                        if (Token::Match(condtok, "%oror%|&&|?|;"))
-                            break;
-                    }
-                    if (settings->debugwarnings)
-                        bailout(tokenlist, errorLogger, tok2, "variable " + var->name() + " is assigned in conditional code");
-                    return false;
-                }
-
-                if (var->isStatic()) {
-                    if (settings->debugwarnings)
-                        bailout(tokenlist, errorLogger, tok2, "variable " + var->name() + " bailout when conditional code that contains var is seen");
-                    return false;
-                }
-
-                // Forward known values in the else branch
-                if (Token::simpleMatch(end, "} else {")) {
-                    std::list<ValueFlow::Value> knownValues;
-                    std::copy_if(values.begin(), values.end(), std::back_inserter(knownValues), std::mem_fn(&ValueFlow::Value::isKnown));
-                    valueFlowForwardVariable(end->tokAt(2),
-                                             end->linkAt(2),
-                                             var,
-                                             varid,
-                                             knownValues,
-                                             constValue,
-                                             subFunction,
-                                             tokenlist,
-                                             errorLogger,
-                                             settings);
-                }
-
-                // Remove conditional values
-                std::list<ValueFlow::Value>::iterator it;
-                for (it = values.begin(); it != values.end();) {
-                    if (it->condition || it->conditional || it->isImpossible())
-                        values.erase(it++);
-                    else {
-                        it->changeKnownToPossible();
-                        ++it;
-                    }
-                }
-            }
-
-            // stop after conditional return scopes that are executed
-            if (isReturnScope(end, settings)) {
-                std::list<ValueFlow::Value>::iterator it;
-                for (it = values.begin(); it != values.end();) {
-                    if (conditionIsTrue(tok2->next()->astOperand2(), getProgramMemory(tok2, varid, *it)))
-                        values.erase(it++);
-                    else
-                        ++it;
-                }
-                if (values.empty())
-                    return false;
-            }
-
-            // noreturn scopes..
-            if ((number_of_if > 0 || Token::findmatch(tok2, "%varid%", start, varid)) &&
-                (isEscapeScope(start, tokenlist) ||
-                 (Token::simpleMatch(end,"} else {") && isEscapeScope(end->tokAt(2), tokenlist)))) {
-                if (settings->debugwarnings)
-                    bailout(tokenlist, errorLogger, tok2, "variable " + var->name() + ". noreturn conditional scope.");
+            if (!lt.token)
                 return false;
-            }
-
-            if (isVariableChanged(start, end, varid, var->isGlobal(), settings, tokenlist->isCPP())) {
-                if ((!read || number_of_if == 0) &&
-                    Token::simpleMatch(tok2, "if (") &&
-                    !(Token::simpleMatch(end, "} else {") &&
-                      isEscapeScope(end->tokAt(2), tokenlist))) {
-                    ++number_of_if;
-                    tok2 = end;
-                } else {
-                    // loop that conditionally set variable and then break => either loop condition is
-                    // redundant or the variable can be unchanged after the loop.
-                    bool loopCondition = false;
-                    if (Token::simpleMatch(tok2, "while (") && Token::Match(tok2->next()->astOperand2(), "%op%"))
-                        loopCondition = true;
-                    else if (Token::simpleMatch(tok2, "for (") &&
-                             Token::simpleMatch(tok2->next()->astOperand2(), ";") &&
-                             Token::simpleMatch(tok2->next()->astOperand2()->astOperand2(), ";") &&
-                             Token::Match(tok2->next()->astOperand2()->astOperand2()->astOperand1(), "%op%"))
-                        loopCondition = true;
-
-                    bool bail = true;
-                    if (loopCondition) {
-                        const Token *tok3 = Token::findmatch(start, "%varid%", end, varid);
-                        if (Token::Match(tok3, "%varid% =", varid) &&
-                            tok3->scope()->bodyEnd                &&
-                            Token::Match(tok3->scope()->bodyEnd->tokAt(-3), "[;}] break ;") &&
-                            !Token::findmatch(tok3->next(), "%varid%", end, varid)) {
-                            bail = false;
-                            tok2 = end;
-                        }
-                    }
+            if (!pred(lt.token))
+                return false;
+            ErrorPath er = errorPath;
+            er.insert(er.end(), lt.errorPath.cbegin(), lt.errorPath.cend());
+            er.emplace_back(argtok, message);
 
-                    if (bail) {
-                        if (settings->debugwarnings)
-                            bailout(tokenlist, errorLogger, tok2, "variable " + var->name() + " is assigned in conditional code");
-                        return false;
-                    }
-                }
-            }
+            ValueFlow::Value value;
+            value.valueType = ValueFlow::Value::ValueType::LIFETIME;
+            value.lifetimeScope = ValueFlow::Value::LifetimeScope::Local;
+            value.tokvalue = lt.token;
+            value.errorPath = std::move(er);
+            value.lifetimeKind = type;
+            value.setInconclusive(lt.inconclusive || inconclusive);
+            // Don't add the value a second time
+            if (std::find(tok->values().cbegin(), tok->values().cend(), value) != tok->values().cend())
+                return false;
+            if (settings.debugnormal)
+                setSourceLocation(value, loc, tok);
+            setTokenValue(tok, std::move(value), settings);
+            update = true;
         }
+        if (update && forward)
+            forwardLifetime(tok, tokenlist, errorLogger, settings);
+        return update;
+    }
 
-        else if (Token::Match(tok2, "assert|ASSERT (") && Token::simpleMatch(tok2->linkAt(1), ") ;")) {
-            const Token * const arg = tok2->next()->astOperand2();
-            if (arg != nullptr && arg->str() != ",") {
-                // Should scope be skipped because variable value is checked?
-                for (std::list<ValueFlow::Value>::iterator it = values.begin(); it != values.end();) {
-                    if (conditionIsFalse(arg, getProgramMemory(tok2, varid, *it)))
-                        values.erase(it++);
-                    else
-                        ++it;
-                }
-            }
-        }
+    bool byRef(Token* tok,
+               const TokenList& tokenlist,
+               ErrorLogger& errorLogger,
+               const Settings& settings,
+               SourceLocation loc = SourceLocation::current())
+    {
+        return byRef(
+            tok,
+            tokenlist,
+            errorLogger,
+            settings,
+            [](const Token*) {
+            return true;
+        },
+            loc);
+    }
 
-        else if (tok2->str() == "}" && indentlevel == varusagelevel) {
-            ++number_of_if;
+    template<class Predicate>
+    bool byVal(Token* tok,
+               const TokenList& tokenlist,
+               ErrorLogger& errorLogger,
+               const Settings& settings,
+               const Predicate& pred,
+               SourceLocation loc = SourceLocation::current())
+    {
+        if (!argtok)
+            return false;
+        bool update = false;
+        if (argtok->values().empty()) {
+            ErrorPath er;
+            er.emplace_back(argtok, message);
+            for (const ValueFlow::LifetimeToken& lt : ValueFlow::getLifetimeTokens(argtok, settings)) {
+                if (!settings.certainty.isEnabled(Certainty::inconclusive) && lt.inconclusive)
+                    continue;
 
-            // Set "conditional" flag for all values
-            removeImpossible(values);
-            std::list<ValueFlow::Value>::iterator it;
-            for (it = values.begin(); it != values.end(); ++it) {
-                it->conditional = true;
-                it->changeKnownToPossible();
-            }
+                const Variable* var = lt.token->variable();
+                if (!var || !var->isArgument())
+                    continue;
 
-            if (Token::simpleMatch(tok2,"} else {"))
-                tok2 = tok2->linkAt(2);
-        }
-
-        else if (Token::Match(tok2, "break|continue|goto")) {
-            const Scope *scope = tok2->scope();
-            if (indentlevel > 0) {
-                const Token *tok3 = tok2->tokAt(2);
-                int indentlevel2 = indentlevel;
-                while (indentlevel2 > 0 &&
-                       tok3->str() == "}" &&
-                       Token::Match(tok3->link()->previous(), "!!)")) {
-                    indentlevel2--;
-                    tok3 = tok3->next();
-                    if (tok3 && tok3->str() == ";")
-                        tok3 = tok3->next();
-                }
-                if (indentlevel2 > 0)
+                ValueFlow::Value value;
+                value.valueType = ValueFlow::Value::ValueType::LIFETIME;
+                value.tokvalue = lt.token;
+                value.capturetok = argtok;
+                value.errorPath = er;
+                value.lifetimeKind = type;
+                value.setInconclusive(inconclusive || lt.inconclusive);
+                value.lifetimeScope = ValueFlow::Value::LifetimeScope::Argument;
+
+                // Don't add the value a second time
+                if (std::find(tok->values().cbegin(), tok->values().cend(), value) != tok->values().cend())
                     continue;
-                scope = tok3->scope();
-                indentlevel = 0;
+                if (settings.debugnormal)
+                    setSourceLocation(value, loc, tok);
+                setTokenValue(tok, std::move(value), settings);
+                update = true;
             }
-            if (tok2->str() == "break") {
-                if (scope && scope->type == Scope::eSwitch) {
-                    tok2 = const_cast<Token *>(scope->bodyEnd);
-                    if (tok2 == endToken)
-                        break;
-                    --indentlevel;
-                    lowerToPossible(values);
+        }
+        for (const ValueFlow::Value &v : argtok->values()) {
+            if (!v.isLifetimeValue())
+                continue;
+            const Token *tok3 = v.tokvalue;
+            for (const ValueFlow::LifetimeToken& lt : ValueFlow::getLifetimeTokens(tok3, settings)) {
+                if (!settings.certainty.isEnabled(Certainty::inconclusive) && lt.inconclusive)
                     continue;
-                }
+                if (!lt.token)
+                    return false;
+                if (!pred(lt.token))
+                    return false;
+                ErrorPath er = v.errorPath;
+                er.insert(er.end(), lt.errorPath.cbegin(), lt.errorPath.cend());
+                er.emplace_back(argtok, message);
+                er.insert(er.end(), errorPath.cbegin(), errorPath.cend());
+
+                ValueFlow::Value value;
+                value.valueType = ValueFlow::Value::ValueType::LIFETIME;
+                value.lifetimeScope = v.lifetimeScope;
+                value.path = v.path;
+                value.tokvalue = lt.token;
+                value.capturetok = argtok;
+                value.errorPath = std::move(er);
+                value.lifetimeKind = type;
+                value.setInconclusive(lt.inconclusive || v.isInconclusive() || inconclusive);
+                // Don't add the value a second time
+                if (std::find(tok->values().cbegin(), tok->values().cend(), value) != tok->values().cend())
+                    continue;
+                if (settings.debugnormal)
+                    setSourceLocation(value, loc, tok);
+                setTokenValue(tok, std::move(value), settings);
+                update = true;
             }
-            if (settings->debugwarnings)
-                bailout(tokenlist, errorLogger, tok2, "variable " + var->name() + ". noreturn conditional scope.");
-            return false;
         }
+        if (update && forward)
+            forwardLifetime(tok, tokenlist, errorLogger, settings);
+        return update;
+    }
 
-        else if (indentlevel <= 0 && Token::Match(tok2, "return|throw|setjmp|longjmp"))
-            returnStatement = true;
-
-        else if (returnStatement && tok2->str() == ";")
-            return false;
+    bool byVal(Token* tok,
+               const TokenList& tokenlist,
+               ErrorLogger& errorLogger,
+               const Settings& settings,
+               SourceLocation loc = SourceLocation::current())
+    {
+        return byVal(
+            tok,
+            tokenlist,
+            errorLogger,
+            settings,
+            [](const Token*) {
+            return true;
+        },
+            loc);
+    }
 
-        // If a ? is seen and it's known that the condition is true/false..
-        else if (tok2->str() == "?") {
-            if (subFunction && (astIsPointer(tok2->astOperand1()) || astIsIntegral(tok2->astOperand1(), false))) {
-                tok2 = const_cast<Token*>(nextAfterAstRightmostLeaf(tok2));
-                if (settings->debugwarnings)
-                    bailout(tokenlist,
-                            errorLogger,
-                            tok2,
-                            "variable " + var->name() + " valueFlowForwardVariable, skip ternary in subfunctions");
+    template<class Predicate>
+    bool byDerefCopy(Token* tok,
+                     const TokenList& tokenlist,
+                     ErrorLogger& errorLogger,
+                     const Settings& settings,
+                     Predicate pred,
+                     SourceLocation loc = SourceLocation::current()) const
+    {
+        bool update = false;
+        if (!settings.certainty.isEnabled(Certainty::inconclusive) && inconclusive)
+            return update;
+        if (!argtok)
+            return update;
+        if (!tok)
+            return update;
+        for (const ValueFlow::Value &v : argtok->values()) {
+            if (!v.isLifetimeValue())
                 continue;
-            }
-            const Token *condition = tok2->astOperand1();
-            Token *op2 = tok2->astOperand2();
-            if (!condition || !op2) // Ticket #6713
+            const Token *tok2 = v.tokvalue;
+            ErrorPath er = v.errorPath;
+            const Variable *var = ValueFlow::getLifetimeVariable(tok2, er, settings);
+            // TODO: the inserted data is never used
+            er.insert(er.end(), errorPath.cbegin(), errorPath.cend());
+            if (!var)
                 continue;
-
-            if (condition->hasKnownIntValue()) {
-                const ValueFlow::Value &condValue = condition->values().front();
-                Token *expr = (condValue.intvalue != 0) ? op2->astOperand1() : op2->astOperand2();
-                for (const ValueFlow::Value &v : values)
-                    valueFlowAST(expr, varid, v, settings);
-                if (isVariableChangedByFunctionCall(expr, 0, varid, settings, nullptr))
-                    lowerToPossible(values, 0);
-                if (isVariableChangedByFunctionCall(expr, 1, varid, settings, nullptr))
-                    lowerToPossible(values, 1);
-            } else {
-                for (const ValueFlow::Value &v : values) {
-                    const ProgramMemory programMemory(getProgramMemory(tok2, varid, v));
-                    if (conditionIsTrue(condition, programMemory))
-                        valueFlowAST(op2->astOperand1(), varid, v, settings);
-                    else if (conditionIsFalse(condition, programMemory))
-                        valueFlowAST(op2->astOperand2(), varid, v, settings);
-                    else
-                        valueFlowAST(op2, varid, v, settings);
-                }
-
-                const Token * const expr0 = op2->astOperand1() ? op2->astOperand1() : tok2->astOperand1();
-                const Token * const expr1 = op2->astOperand2();
-
-                const std::pair<const Token *, const Token *> startEnd0 = expr0->findExpressionStartEndTokens();
-                const std::pair<const Token *, const Token *> startEnd1 = expr1->findExpressionStartEndTokens();
-                const bool changed0 = isVariableChanged(startEnd0.first, startEnd0.second->next(), varid, var->isGlobal(), settings, tokenlist->isCPP());
-                const bool changed1 = isVariableChanged(startEnd1.first, startEnd1.second->next(), varid, var->isGlobal(), settings, tokenlist->isCPP());
-
-                if (changed0 && changed1) {
-                    if (settings->debugwarnings)
-                        bailout(tokenlist,
-                                errorLogger,
-                                tok2,
-                                "variable " + var->name() + " valueFlowForwardVariable, changed in both : expressions");
-                    return false;
+            const Token * const varDeclEndToken = var->declEndToken();
+            if (!varDeclEndToken)
+                continue;
+            for (const Token *tok3 = tok; tok3 && tok3 != varDeclEndToken; tok3 = tok3->previous()) {
+                if (tok3->varId() == var->declarationId()) {
+                    update |= LifetimeStore{tok3, message, type, inconclusive}
+                    .byVal(tok, tokenlist, errorLogger, settings, pred, loc);
+                    break;
                 }
-
-                if (changed0 || changed1)
-                    lowerToPossible(values);
             }
+        }
+        return update;
+    }
 
-            // Skip conditional expressions..
-            const Token * const questionToken = tok2;
-            while (tok2->astOperand1() || tok2->astOperand2()) {
-                if (tok2->astOperand2())
-                    tok2 = tok2->astOperand2();
-                else if (tok2->isUnaryPreOp())
-                    tok2 = tok2->astOperand1();
-                else
-                    break;
-            }
-            tok2 = tok2->next();
+    bool byDerefCopy(Token* tok,
+                     const TokenList& tokenlist,
+                     ErrorLogger& errorLogger,
+                     const Settings& settings,
+                     SourceLocation loc = SourceLocation::current()) const
+    {
+        return byDerefCopy(
+            tok,
+            tokenlist,
+            errorLogger,
+            settings,
+            [](const Token*) {
+            return true;
+        },
+            loc);
+    }
 
-            if (isVariableChanged(questionToken, questionToken->astOperand2(), varid, false, settings, tokenlist->isCPP()) &&
-                isVariableChanged(questionToken->astOperand2(), tok2, varid, false, settings, tokenlist->isCPP())) {
-                if (settings->debugwarnings)
-                    bailout(tokenlist,
-                            errorLogger,
-                            tok2,
-                            "variable " + var->name() + " valueFlowForwardVariable, assignment in condition");
-                return false;
+private:
+    // cppcheck-suppress naming-privateMemberVariable
+    Token* forwardTok{};
+    void forwardLifetime(Token* tok, const TokenList& tokenlist, ErrorLogger& errorLogger, const Settings& settings) {
+        forwardTok = tok;
+        valueFlowForwardLifetime(tok, tokenlist, errorLogger, settings);
+    }
+};
 
-            }
+static bool hasBorrowingVariables(const std::list<Variable>& vars, const std::vector<const Token*>& args, int depth = 10)
+{
+    if (depth < 0)
+        return true;
+    return std::any_of(vars.cbegin(), vars.cend(), [&](const Variable& var) {
+        if (const ValueType* vt = var.valueType()) {
+            if (vt->pointer > 0 &&
+                std::none_of(args.begin(), args.end(), [vt](const Token* arg) {
+                return arg->valueType() && arg->valueType()->type == vt->type;
+            }))
+                return false;
+            if (vt->pointer > 0)
+                return true;
+            if (vt->reference != Reference::None)
+                return true;
+            if (vt->isPrimitive())
+                return false;
+            if (vt->isEnum())
+                return false;
+            // TODO: Check container inner type
+            if (vt->type == ValueType::CONTAINER && vt->container)
+                return vt->container->view;
+            if (vt->typeScope)
+                return hasBorrowingVariables(vt->typeScope->varlist, args, depth - 1);
         }
+        return true;
+    });
+}
 
-        else if (tok2->varId() == varid) {
-            // compound assignment, known value in rhs
-            if (Token::Match(tok2->previous(), "!!* %name% %assign%") &&
-                tok2->next()->str() != "=" &&
-                tok2->next()->astOperand2() &&
-                tok2->next()->astOperand2()->hasKnownIntValue()) {
-
-                const ValueFlow::Value &rhsValue = tok2->next()->astOperand2()->values().front();
-                const std::string &assign = tok2->next()->str();
-                std::list<ValueFlow::Value>::iterator it;
-                // Erase values that are not int values..
-                for (it = values.begin(); it != values.end();) {
-                    if (!evalAssignment(*it, assign, rhsValue)) {
-                        it = values.erase(it);
-                    } else {
-                        const std::string info("Compound assignment '" + assign + "', assigned value is " + it->infoString());
-                        it->errorPath.emplace_back(tok2, info);
-
-                        ++it;
-                    }
-
-                }
-                if (values.empty()) {
-                    if (settings->debugwarnings)
-                        bailout(tokenlist, errorLogger, tok2, "compound assignment of " + tok2->str());
-                    return false;
+static void valueFlowLifetimeUserConstructor(Token* tok,
+                                             const Function* constructor,
+                                             const std::string& name,
+                                             const std::vector<const Token*>& args,
+                                             const TokenList& tokenlist,
+                                             ErrorLogger& errorLogger,
+                                             const Settings& settings)
+{
+    if (!constructor)
+        return;
+    std::unordered_map<const Token*, const Variable*> argToParam;
+    for (std::size_t i = 0; i < args.size(); i++)
+        argToParam[args[i]] = constructor->getArgumentVar(i);
+    if (const Token* initList = constructor->constructorMemberInitialization()) {
+        std::unordered_map<const Variable*, LifetimeCapture> paramCapture;
+        for (const Token* tok2 : astFlatten(initList->astOperand2(), ",")) {
+            if (!Token::simpleMatch(tok2, "("))
+                continue;
+            if (!tok2->astOperand1())
+                continue;
+            if (!tok2->astOperand2())
+                continue;
+            const Variable* var = tok2->astOperand1()->variable();
+            const Token* expr = tok2->astOperand2();
+            if (!var)
+                continue;
+            if (!ValueFlow::isLifetimeBorrowed(expr, settings))
+                continue;
+            const Variable* argvar = ValueFlow::getLifetimeVariable(expr, settings);
+            if (var->isReference() || var->isRValueReference()) {
+                if (argvar && argvar->isArgument() && (argvar->isReference() || argvar->isRValueReference())) {
+                    paramCapture[argvar] = LifetimeCapture::ByReference;
                 }
-            }
-
-            // bailout: assignment
-            else if (Token::Match(tok2->previous(), "!!* %name% %assign%")) {
-                // simplify rhs
-                std::stack<Token *> rhs;
-                rhs.push(tok2->next()->astOperand2());
-                while (!rhs.empty()) {
-                    Token *rtok = rhs.top();
-                    rhs.pop();
-                    if (!rtok)
+            } else {
+                bool found = false;
+                for (const ValueFlow::Value& v : expr->values()) {
+                    if (!v.isLifetimeValue())
+                        continue;
+                    if (v.path > 0)
                         continue;
-                    if (rtok->str() == "(" && Token::Match(rtok->astOperand1(), "sizeof|typeof|typeid"))
+                    if (!v.tokvalue)
                         continue;
-                    if (Token::Match(rtok, "++|--|?|:|;|,"))
+                    const Variable* lifeVar = v.tokvalue->variable();
+                    if (!lifeVar)
                         continue;
-                    if (rtok->varId() == varid) {
-                        for (const ValueFlow::Value &v : values)
-                            setTokenValue(rtok, v, settings);
+                    LifetimeCapture c = LifetimeCapture::Undefined;
+                    if (!v.isArgumentLifetimeValue() && (lifeVar->isReference() || lifeVar->isRValueReference()))
+                        c = LifetimeCapture::ByReference;
+                    else if (v.isArgumentLifetimeValue())
+                        c = LifetimeCapture::ByValue;
+                    if (c != LifetimeCapture::Undefined) {
+                        paramCapture[lifeVar] = c;
+                        found = true;
                     }
-                    rhs.push(rtok->astOperand1());
-                    rhs.push(rtok->astOperand2());
-                }
-                if (settings->debugwarnings)
-                    bailout(tokenlist, errorLogger, tok2, "assignment of " + tok2->str());
-                return false;
-            }
-
-            // bailout: possible assignment using >>
-            if (isLikelyStreamRead(tokenlist->isCPP(), tok2->previous())) {
-                if (settings->debugwarnings)
-                    bailout(tokenlist, errorLogger, tok2, "Possible assignment of " + tok2->str() + " using " + tok2->strAt(-1));
-                return false;
-            }
-
-            // skip if variable is conditionally used in ?: expression
-            if (const Token *parent = skipValueInConditionalExpression(tok2)) {
-                if (settings->debugwarnings)
-                    bailout(tokenlist,
-                            errorLogger,
-                            tok2,
-                            "no simplification of " + tok2->str() + " within " + (Token::Match(parent,"[?:]") ? "?:" : parent->str()) + " expression");
-                const Token *astTop = parent->astTop();
-                if (Token::simpleMatch(astTop->astOperand1(), "for ("))
-                    tok2 = astTop->link();
-
-                // bailout if address of var is taken..
-                if (tok2->astParent() && tok2->astParent()->isUnaryOp("&")) {
-                    if (settings->debugwarnings)
-                        bailout(tokenlist, errorLogger, tok2, "Taking address of " + tok2->str());
-                    return false;
                 }
+                if (!found && argvar && argvar->isArgument())
+                    paramCapture[argvar] = LifetimeCapture::ByValue;
+            }
+        }
+        // TODO: Use SubExpressionAnalyzer for members
+        LifetimeStore::forEach(tokenlist,
+                               errorLogger,
+                               settings,
+                               args,
+                               "Passed to constructor of '" + name + "'.",
+                               ValueFlow::Value::LifetimeKind::SubObject,
+                               [&](LifetimeStore& ls) {
+            const Variable* paramVar = argToParam.at(ls.argtok);
+            if (paramCapture.count(paramVar) == 0)
+                return;
+            const LifetimeCapture c = paramCapture.at(paramVar);
+            if (c == LifetimeCapture::ByReference)
+                ls.byRef(tok, tokenlist, errorLogger, settings);
+            else
+                ls.byVal(tok, tokenlist, errorLogger, settings);
+        });
+    } else if (hasBorrowingVariables(constructor->nestedIn->varlist, args)) {
+        LifetimeStore::forEach(tokenlist,
+                               errorLogger,
+                               settings,
+                               args,
+                               "Passed to constructor of '" + name + "'.",
+                               ValueFlow::Value::LifetimeKind::SubObject,
+                               [&](LifetimeStore& ls) {
+            ls.inconclusive = true;
+            const Variable* var = argToParam.at(ls.argtok);
+            if (var && !var->isConst() && var->isReference())
+                ls.byRef(tok, tokenlist, errorLogger, settings);
+            else
+                ls.byVal(tok, tokenlist, errorLogger, settings);
+        });
+    }
+}
 
+static void valueFlowLifetimeFunction(Token *tok, const TokenList &tokenlist, ErrorLogger &errorLogger, const Settings &settings)
+{
+    if (!Token::Match(tok, "%name% ("))
+        return;
+    Token* memtok = nullptr;
+    if (Token::Match(tok->astParent(), ". %name% (") && astIsRHS(tok))
+        memtok = tok->astParent()->astOperand1();
+    const int returnContainer = settings.library.returnValueContainer(tok);
+    if (returnContainer >= 0) {
+        std::vector<const Token *> args = getArguments(tok);
+        for (int argnr = 1; argnr <= args.size(); ++argnr) {
+            const Library::ArgumentChecks::IteratorInfo *i = settings.library.getArgIteratorInfo(tok, argnr);
+            if (!i)
                 continue;
+            if (i->container != returnContainer)
+                continue;
+            const Token * const argTok = args[argnr - 1];
+            bool forward = false;
+            for (ValueFlow::Value val : argTok->values()) {
+                if (!val.isLifetimeValue())
+                    continue;
+                val.errorPath.emplace_back(argTok, "Passed to '" + tok->str() + "'.");
+                setTokenValue(tok->next(), std::move(val), settings);
+                forward = true;
             }
-
-            {
-                // Is variable usage protected by && || ?:
-                const Token *tok3 = tok2;
-                const Token *parent = tok3->astParent();
-                while (parent && !Token::Match(parent, "%oror%|&&|:")) {
-                    tok3 = parent;
-                    parent = parent->astParent();
-                }
-                const bool conditional = parent && (parent->str() == ":" || parent->astOperand2() == tok3);
-
-                for (const ValueFlow::Value &v : values) {
-                    if (!conditional || !v.conditional)
-                        setTokenValue(tok2, v, settings);
-                }
-            }
-
-            // increment/decrement
-            if (Token::Match(tok2->previous(), "++|-- %name%") || Token::Match(tok2, "%name% ++|--")) {
-                std::list<ValueFlow::Value>::iterator it;
-                // Erase values that are not int values..
-                for (it = values.begin(); it != values.end();) {
-                    if (!it->isIntValue())
-                        it = values.erase(it);
-                    else
-                        ++it;
-                }
-                if (values.empty()) {
-                    if (settings->debugwarnings)
-                        bailout(tokenlist, errorLogger, tok2, "increment/decrement of " + tok2->str());
-                    return false;
-                }
-                const bool pre   = Token::Match(tok2->previous(), "++|--");
-                Token * const op = pre ? tok2->previous() : tok2->next();
-                const bool inc   = (op->str() == "++");
-                // Perform increment/decrement..
-                for (it = values.begin(); it != values.end(); ++it) {
-                    if (!pre)
-                        setTokenValue(op, *it, settings);
-                    it->intvalue += (inc ? 1 : -1);
-                    if (pre)
-                        setTokenValue(op, *it, settings);
-                    const std::string info(tok2->str() + " is " + std::string(inc ? "incremented" : "decremented") + "', new value is " + it->infoString());
-                    it->errorPath.emplace_back(tok2, info);
-                }
-            }
-
-            // bailout if address of var is taken..
-            if (tok2->astParent() && tok2->astParent()->isUnaryOp("&")) {
-                if (settings->debugwarnings)
-                    bailout(tokenlist, errorLogger, tok2, "Taking address of " + tok2->str());
-                return false;
-            }
-
-            // bailout if reference is created..
-            if (tok2->astParent() && Token::Match(tok2->astParent()->tokAt(-2), "& %name% =")) {
-                if (settings->debugwarnings)
-                    bailout(tokenlist, errorLogger, tok2, "Reference of " + tok2->str());
-                return false;
+            // Check if lifetime is available to avoid adding the lifetime twice
+            if (forward) {
+                valueFlowForwardLifetime(tok, tokenlist, errorLogger, settings);
+                break;
             }
-
-            // bailout if its stream..
-            if (isLikelyStream(tokenlist->isCPP(), tok2)) {
-                if (settings->debugwarnings)
-                    bailout(tokenlist, errorLogger, tok2, "Stream used: " + tok2->str());
-                return false;
+        }
+    } else if (Token::Match(tok->tokAt(-2), "std :: ref|cref|tie|front_inserter|back_inserter")) {
+        for (const Token *argtok : getArguments(tok)) {
+            LifetimeStore{argtok, "Passed to '" + tok->str() + "'.", ValueFlow::Value::LifetimeKind::Object}.byRef(
+                tok->next(), tokenlist, errorLogger, settings);
+        }
+    } else if (Token::Match(tok->tokAt(-2), "std :: make_tuple|tuple_cat|make_pair|make_reverse_iterator|next|prev|move|bind")) {
+        for (const Token *argtok : getArguments(tok)) {
+            LifetimeStore{argtok, "Passed to '" + tok->str() + "'.", ValueFlow::Value::LifetimeKind::Object}.byVal(
+                tok->next(), tokenlist, errorLogger, settings);
+        }
+    } else if (memtok && Token::Match(tok->astParent(), ". push_back|push_front|insert|push|assign") &&
+               astIsNonStringContainer(memtok)) {
+        std::vector<const Token *> args = getArguments(tok);
+        const std::size_t n = args.size();
+        if (n > 1 && Token::typeStr(args[n - 2]) == Token::typeStr(args[n - 1]) &&
+            ((astIsIterator(args[n - 2]) && astIsIterator(args[n - 1])) ||
+             (astIsPointer(args[n - 2]) && astIsPointer(args[n - 1])))) {
+            LifetimeStore{
+                args.back(), "Added to container '" + memtok->str() + "'.", ValueFlow::Value::LifetimeKind::Object}
+            .byDerefCopy(memtok, tokenlist, errorLogger, settings);
+        } else if (!args.empty() && ValueFlow::isLifetimeBorrowed(args.back(), settings)) {
+            LifetimeStore{
+                args.back(), "Added to container '" + memtok->str() + "'.", ValueFlow::Value::LifetimeKind::Object}
+            .byVal(memtok, tokenlist, errorLogger, settings);
+        }
+    } else if (tok->function()) {
+        const Function *f = tok->function();
+        if (f->isConstructor()) {
+            valueFlowLifetimeUserConstructor(tok->next(), f, tok->str(), getArguments(tok), tokenlist, errorLogger, settings);
+            return;
+        }
+        if (Function::returnsReference(f))
+            return;
+        std::vector<const Token*> returns = Function::findReturns(f);
+        const bool inconclusive = returns.size() > 1;
+        bool update = false;
+        for (const Token* returnTok : returns) {
+            if (returnTok == tok)
+                continue;
+            const Variable *returnVar = ValueFlow::getLifetimeVariable(returnTok, settings);
+            if (returnVar && returnVar->isArgument() && (returnVar->isConst() || !isVariableChanged(returnVar, settings))) {
+                LifetimeStore ls = LifetimeStore::fromFunctionArg(f, tok, returnVar, tokenlist, settings, errorLogger);
+                ls.inconclusive = inconclusive;
+                ls.forward = false;
+                update |= ls.byVal(tok->next(), tokenlist, errorLogger, settings);
             }
-
-            // assigned by subfunction?
-            for (int i:getIndirections(values)) {
-                bool inconclusive = false;
-                if (isVariableChangedByFunctionCall(tok2, i, settings, &inconclusive)) {
-                    values.remove_if([&](const ValueFlow::Value& v) {
-                        return v.indirect <= i;
-                    });
+            for (const ValueFlow::Value &v : returnTok->values()) {
+                if (!v.isLifetimeValue())
+                    continue;
+                if (!v.tokvalue)
+                    continue;
+                if (memtok &&
+                    (contains({ValueFlow::Value::LifetimeScope::ThisPointer, ValueFlow::Value::LifetimeScope::ThisValue},
+                              v.lifetimeScope) ||
+                     exprDependsOnThis(v.tokvalue))) {
+                    LifetimeStore ls = LifetimeStore{memtok,
+                                                     "Passed to member function '" + tok->expressionString() + "'.",
+                                                     ValueFlow::Value::LifetimeKind::Object};
+                    ls.inconclusive = inconclusive;
+                    ls.forward = false;
+                    ls.errorPath = v.errorPath;
+                    ls.errorPath.emplace_front(returnTok, "Return " + lifetimeType(returnTok, &v) + ".");
+                    int thisIndirect = v.lifetimeScope == ValueFlow::Value::LifetimeScope::ThisValue ? 0 : 1;
+                    if (derefShared(memtok->astParent()))
+                        thisIndirect--;
+                    if (thisIndirect == -1)
+                        update |= ls.byDerefCopy(tok->next(), tokenlist, errorLogger, settings);
+                    else if (thisIndirect == 0)
+                        update |= ls.byVal(tok->next(), tokenlist, errorLogger, settings);
+                    else if (thisIndirect == 1)
+                        update |= ls.byRef(tok->next(), tokenlist, errorLogger, settings);
+                    continue;
                 }
-                if (inconclusive)
-                    lowerToInconclusive(values, settings, i);
-            }
-            if (values.empty()) {
-                if (settings->debugwarnings)
-                    bailout(tokenlist, errorLogger, tok2, "possible assignment of " + tok2->str() + " by subfunction");
-                return false;
-            }
-            if (tok2->strAt(1) == "." && tok2->next()->originalName() != "->") {
-                lowerToInconclusive(values, settings);
-                if (!settings->inconclusive) {
-                    if (settings->debugwarnings)
-                        bailout(tokenlist, errorLogger, tok2, "possible assignment of " + tok2->str() + " by member function");
-                    return false;
+                const Variable *var = v.tokvalue->variable();
+                LifetimeStore ls = LifetimeStore::fromFunctionArg(f, tok, var, tokenlist, settings, errorLogger);
+                if (!ls.argtok)
+                    continue;
+                ls.forward = false;
+                ls.inconclusive = inconclusive;
+                ls.errorPath = v.errorPath;
+                ls.errorPath.emplace_front(returnTok, "Return " + lifetimeType(returnTok, &v) + ".");
+                if (!v.isArgumentLifetimeValue() && (var->isReference() || var->isRValueReference())) {
+                    update |= ls.byRef(tok->next(), tokenlist, errorLogger, settings);
+                } else if (v.isArgumentLifetimeValue()) {
+                    update |= ls.byVal(tok->next(), tokenlist, errorLogger, settings);
                 }
             }
-            // Variable changed
-            for (int i:getIndirections(values)) {
-                // Remove uninitialized values if modified
-                if (isVariableChanged(tok2, i, settings, tokenlist->isCPP()))
-                    values.remove_if([&](const ValueFlow::Value& v) {
-                    return v.isUninitValue() && v.indirect <= i;
-                });
-            }
-        } else if (isAliasOf(var, tok2, varid, values) && isVariableChanged(tok2, 0, settings, tokenlist->isCPP())) {
-            if (settings->debugwarnings)
-                bailout(tokenlist, errorLogger, tok2, "Alias variable was modified.");
-            // Bail at the end of the statement if its in an assignment
-            const Token * top = tok2->astTop();
-            if (Token::Match(top, "%assign%") && astHasToken(top->astOperand1(), tok2))
-                returnStatement = true;
-            else
-                return false;
         }
-
-        // Lambda function
-        if (Token::simpleMatch(tok2, "= [") &&
-            Token::simpleMatch(tok2->linkAt(1), "] (") &&
-            Token::simpleMatch(tok2->linkAt(1)->linkAt(1), ") {")) {
-            const Token *bodyStart = tok2->linkAt(1)->linkAt(1)->next();
-            if (isVariableChanged(bodyStart, bodyStart->link(), varid, var->isGlobal(), settings, tokenlist->isCPP())) {
-                if (settings->debugwarnings)
-                    bailout(tokenlist,
-                            errorLogger,
-                            tok2,
-                            "valueFlowForwardVariable, " + var->name() + " is changed in lambda function");
-                return false;
+        if (update)
+            valueFlowForwardLifetime(tok->next(), tokenlist, errorLogger, settings);
+    } else if (tok->valueType()) {
+        // TODO: Propagate lifetimes with library functions
+        if (settings.library.getFunction(tok->previous()))
+            return;
+        if (Token::simpleMatch(tok->astParent(), "."))
+            return;
+        // Assume constructing the valueType
+        valueFlowLifetimeConstructor(tok->next(), tokenlist, errorLogger, settings);
+        valueFlowForwardLifetime(tok->next(), tokenlist, errorLogger, settings);
+    } else {
+        const std::string& retVal = settings.library.returnValue(tok);
+        if (startsWith(retVal, "arg")) {
+            std::size_t iArg{};
+            try {
+                iArg = strToInt<std::size_t>(retVal.substr(3));
+            } catch (...) {
+                return;
+            }
+            std::vector<const Token*> args = getArguments(tok);
+            if (iArg > 0 && iArg <= args.size()) {
+                const Token* varTok = args[iArg - 1];
+                if (varTok->variable() && varTok->variable()->isLocal())
+                    LifetimeStore{ varTok, "Passed to '" + tok->str() + "'.", ValueFlow::Value::LifetimeKind::Address }.byRef(
+                        tok->next(), tokenlist, errorLogger, settings);
             }
         }
-
     }
-    return true;
 }
 
-static const Token* parseBinaryIntOp(const Token* expr, MathLib::bigint& known)
+static bool isScope(const Token* tok)
 {
-    if (!expr)
-        return nullptr;
-    if (!expr->astOperand1() || !expr->astOperand2())
-        return nullptr;
-    const Token* knownTok = nullptr;
-    const Token* varTok = nullptr;
-    if (expr->astOperand1()->hasKnownIntValue() && !expr->astOperand2()->hasKnownIntValue()) {
-        varTok = expr->astOperand2();
-        knownTok = expr->astOperand1();
-    } else if (expr->astOperand2()->hasKnownIntValue() && !expr->astOperand1()->hasKnownIntValue()) {
-        varTok = expr->astOperand1();
-        knownTok = expr->astOperand2();
-    }
-    if (knownTok)
-        known = knownTok->values().front().intvalue;
-    return varTok;
+    if (!tok)
+        return false;
+    if (!Token::simpleMatch(tok, "{"))
+        return false;
+    const Scope* scope = tok->scope();
+    if (!scope)
+        return false;
+    if (!scope->bodyStart)
+        return false;
+    return scope->bodyStart == tok;
 }
 
-template <class F>
-void transformIntValues(std::list<ValueFlow::Value>& values, F f)
+static const Function* findConstructor(const Scope* scope, const Token* tok, const std::vector<const Token*>& args)
 {
-    std::transform(values.begin(), values.end(), values.begin(), [&](ValueFlow::Value x) {
-        if (x.isIntValue())
-            x.intvalue = f(x.intvalue);
-        return x;
-    });
+    if (!tok)
+        return nullptr;
+    const Function* f = tok->function();
+    if (!f && tok->astOperand1())
+        f = tok->astOperand1()->function();
+    // Search for a constructor
+    if (!f || !f->isConstructor()) {
+        f = nullptr;
+        std::vector<const Function*> candidates;
+        for (const Function& function : scope->functionList) {
+            if (function.minArgCount() > args.size())
+                continue;
+            if (!function.isConstructor())
+                continue;
+            candidates.push_back(&function);
+        }
+        // TODO: Narrow the candidates
+        if (candidates.size() == 1)
+            f = candidates.front();
+    }
+    if (!f)
+        return nullptr;
+    return f;
 }
 
-static const Token* solveExprValues(const Token* expr, std::list<ValueFlow::Value>& values)
+static void valueFlowLifetimeClassConstructor(Token* tok,
+                                              const Type* t,
+                                              const TokenList& tokenlist,
+                                              ErrorLogger& errorLogger,
+                                              const Settings& settings)
 {
-    MathLib::bigint intval;
-    const Token* binaryTok = parseBinaryIntOp(expr, intval);
-    if (binaryTok && expr->str().size() == 1) {
-        switch (expr->str()[0]) {
-        case '+': {
-            transformIntValues(values, [&](MathLib::bigint x) {
-                return x - intval;
-            });
-            return solveExprValues(binaryTok, values);
-        }
-        case '*': {
-            transformIntValues(values, [&](MathLib::bigint x) {
-                return x / intval;
-            });
-            return solveExprValues(binaryTok, values);
-        }
-        case '^': {
-            transformIntValues(values, [&](MathLib::bigint x) {
-                return x ^ intval;
+    if (!Token::Match(tok, "(|{"))
+        return;
+    if (isScope(tok))
+        return;
+    if (!t) {
+        if (tok->valueType() && tok->valueType()->type != ValueType::RECORD)
+            return;
+        if (tok->str() != "{" && !Token::Match(tok->previous(), "%var% (") && !isVariableDecl(tok->previous()))
+            return;
+        // If the type is unknown then assume it captures by value in the
+        // constructor, but make each lifetime inconclusive
+        std::vector<const Token*> args = getArguments(tok);
+        LifetimeStore::forEach(tokenlist,
+                               errorLogger,
+                               settings,
+                               args,
+                               "Passed to initializer list.",
+                               ValueFlow::Value::LifetimeKind::SubObject,
+                               [&](LifetimeStore& ls) {
+            ls.inconclusive = true;
+            ls.byVal(tok, tokenlist, errorLogger, settings);
+        });
+        return;
+    }
+    const Scope* scope = t->classScope;
+    if (!scope)
+        return;
+    // Aggregate constructor
+    if (t->derivedFrom.empty() && (t->isClassType() || t->isStructType())) {
+        std::vector<const Token*> args = getArguments(tok);
+        if (scope->numConstructors == 0) {
+            auto it = scope->varlist.cbegin();
+            LifetimeStore::forEach(
+                tokenlist,
+                errorLogger,
+                settings,
+                args,
+                "Passed to constructor of '" + t->name() + "'.",
+                ValueFlow::Value::LifetimeKind::SubObject,
+                [&](LifetimeStore& ls) {
+                const bool isDesignatedInitializerArg = isDesignatedInitializer(ls.argtok->astOperand1());
+                // Skip static variable
+                it = std::find_if(it, scope->varlist.cend(), [&](const Variable &var) {
+                    if (var.isStatic())
+                        return false;
+                    if (!isDesignatedInitializerArg)
+                        return true;
+                    return var.name() == ls.argtok->astOperand1()->astOperand1()->str();
+                });
+                if (it == scope->varlist.cend())
+                    return;
+                if (isDesignatedInitializerArg)
+                    ls.argtok = ls.argtok->astOperand2();
+                const Variable &var = *it;
+                if (ls.argtok->valueType() && ls.argtok->valueType()->pointer &&
+                    var.valueType() && var.valueType()->container && var.valueType()->container->stdStringLike && !var.valueType()->container->view)
+                    return; // TODO: check in isLifetimeBorrowed()?
+                if (var.isReference() || var.isRValueReference()) {
+                    ls.byRef(tok, tokenlist, errorLogger, settings);
+                } else if (ValueFlow::isLifetimeBorrowed(ls.argtok, settings)) {
+                    ls.byVal(tok, tokenlist, errorLogger, settings);
+                }
+                if (isDesignatedInitializerArg) // TODO: handle mixed initialization?
+                    it = scope->varlist.cbegin();
+                else
+                    it++;
             });
-            return solveExprValues(binaryTok, values);
-        }
+        } else {
+            const Function* constructor = findConstructor(scope, tok, args);
+            valueFlowLifetimeUserConstructor(tok, constructor, t->name(), args, tokenlist, errorLogger, settings);
         }
     }
-    return expr;
 }
 
-static void valueFlowForward(Token* startToken,
-                             const Token* endToken,
-                             const Token* exprTok,
-                             std::list<ValueFlow::Value> values,
-                             const bool constValue,
-                             const bool subFunction,
-                             TokenList* const tokenlist,
-                             ErrorLogger* const errorLogger,
-                             const Settings* settings)
-{
-    const Token* expr = solveExprValues(exprTok, values);
-    if (Token::Match(expr, "%var%")) {
-        valueFlowForwardVariable(startToken,
-                                 endToken,
-                                 expr->variable(),
-                                 expr->varId(),
-                                 values,
-                                 constValue,
-                                 subFunction,
-                                 tokenlist,
-                                 errorLogger,
-                                 settings);
-    } else {
-        valueFlowForwardExpression(startToken, endToken, expr, values, tokenlist, settings);
+static void valueFlowLifetimeConstructor(Token* tok, const TokenList& tokenlist, ErrorLogger& errorLogger, const Settings& settings)
+{
+    if (!Token::Match(tok, "(|{"))
+        return;
+    if (isScope(tok))
+        return;
+    std::vector<ValueType> vts;
+    if (tok->valueType()) {
+        vts = {*tok->valueType()};
+    } else if (Token::Match(tok->previous(), "%var% {|(") && isVariableDecl(tok->previous()) &&
+               tok->previous()->valueType()) {
+        vts = {*tok->previous()->valueType()};
+    } else if (Token::simpleMatch(tok, "{") && !Token::Match(tok->previous(), "%name%")) {
+        vts = getParentValueTypes(tok, settings);
+    }
+
+    for (const ValueType& vt : vts) {
+        if (vt.pointer > 0) {
+            std::vector<const Token*> args = getArguments(tok);
+            LifetimeStore::forEach(tokenlist,
+                                   errorLogger,
+                                   settings,
+                                   args,
+                                   "Passed to initializer list.",
+                                   ValueFlow::Value::LifetimeKind::SubObject,
+                                   [&](LifetimeStore& ls) {
+                ls.byVal(tok, tokenlist, errorLogger, settings);
+            });
+        } else if (vt.container && vt.type == ValueType::CONTAINER) {
+            std::vector<const Token*> args = getArguments(tok);
+            if (args.size() == 1 && vt.container->view && astIsContainerOwned(args.front())) {
+                LifetimeStore{args.front(), "Passed to container view.", ValueFlow::Value::LifetimeKind::SubObject}
+                .byRef(tok, tokenlist, errorLogger, settings);
+            } else if (args.size() == 2 && (astIsIterator(args[0]) || astIsIterator(args[1]))) {
+                LifetimeStore::forEach(
+                    tokenlist,
+                    errorLogger,
+                    settings,
+                    args,
+                    "Passed to initializer list.",
+                    ValueFlow::Value::LifetimeKind::SubObject,
+                    [&](const LifetimeStore& ls) {
+                    ls.byDerefCopy(tok, tokenlist, errorLogger, settings);
+                });
+            } else if (vt.container->hasInitializerListConstructor) {
+                LifetimeStore::forEach(tokenlist,
+                                       errorLogger,
+                                       settings,
+                                       args,
+                                       "Passed to initializer list.",
+                                       ValueFlow::Value::LifetimeKind::SubObject,
+                                       [&](LifetimeStore& ls) {
+                    ls.byVal(tok, tokenlist, errorLogger, settings);
+                });
+            }
+        } else {
+            const Type* t = nullptr;
+            if (vt.typeScope && vt.typeScope->definedType)
+                t = vt.typeScope->definedType;
+            else
+                t = Token::typeOf(tok->previous());
+            valueFlowLifetimeClassConstructor(tok, t, tokenlist, errorLogger, settings);
+        }
     }
 }
 
-static std::vector<const Token*> findReturns(const Function* f)
-{
-    std::vector<const Token*> result;
-    const Scope* scope = f->functionScope;
-    if (!scope)
-        return result;
-    for (const Token* tok = scope->bodyStart->next(); tok && tok != scope->bodyEnd; tok = tok->next()) {
-        if (tok->str() == "{" && tok->scope() &&
-            (tok->scope()->type == Scope::eLambda || tok->scope()->type == Scope::eClass)) {
-            tok = tok->link();
-            continue;
+struct Lambda {
+    explicit Lambda(const Token* tok)
+    {
+        if (!Token::simpleMatch(tok, "[") || !tok->link())
+            return;
+        capture = tok;
+
+        if (Token::simpleMatch(capture->link(), "] (")) {
+            arguments = capture->link()->next();
         }
-        if (Token::simpleMatch(tok->astParent(), "return")) {
-            result.push_back(tok);
+        const Token * afterArguments = arguments ? arguments->link()->next() : capture->link()->next();
+        if (afterArguments && afterArguments->originalName() == "->") {
+            returnTok = afterArguments->next();
+            bodyTok = Token::findsimplematch(returnTok, "{");
+        } else if (Token::simpleMatch(afterArguments, "{")) {
+            bodyTok = afterArguments;
         }
-        // Skip lambda functions since the scope may not be set correctly
-        const Token* lambdaEndToken = findLambdaEndToken(tok);
-        if (lambdaEndToken) {
-            tok = lambdaEndToken;
+        for (const Token* c:getCaptures()) {
+            if (Token::Match(c, "this !!.")) {
+                explicitCaptures[c->variable()] = std::make_pair(c, LifetimeCapture::ByReference);
+            } else if (Token::simpleMatch(c, "* this")) {
+                explicitCaptures[c->next()->variable()] = std::make_pair(c->next(), LifetimeCapture::ByValue);
+            } else if (c->variable()) {
+                explicitCaptures[c->variable()] = std::make_pair(c, LifetimeCapture::ByValue);
+            } else if (c->isUnaryOp("&") && Token::Match(c->astOperand1(), "%var%")) {
+                explicitCaptures[c->astOperand1()->variable()] =
+                    std::make_pair(c->astOperand1(), LifetimeCapture::ByReference);
+            } else {
+                const std::string& s = c->expressionString();
+                if (s == "=")
+                    implicitCapture = LifetimeCapture::ByValue;
+                else if (s == "&")
+                    implicitCapture = LifetimeCapture::ByReference;
+            }
         }
     }
-    return result;
-}
 
-static int getArgumentPos(const Variable *var, const Function *f)
+    const Token* capture{};
+    const Token* arguments{};
+    const Token* returnTok{};
+    const Token* bodyTok{};
+    std::unordered_map<const Variable*, std::pair<const Token*, LifetimeCapture>> explicitCaptures;
+    LifetimeCapture implicitCapture = LifetimeCapture::Undefined;
+
+    std::vector<const Token*> getCaptures() const {
+        return getArguments(capture);
+    }
+
+    bool isLambda() const {
+        return capture && bodyTok;
+    }
+};
+
+static bool isDecayedPointer(const Token *tok)
 {
-    auto arg_it = std::find_if(f->argumentList.begin(), f->argumentList.end(), [&](const Variable &v) {
-        return v.nameToken() == var->nameToken();
-    });
-    if (arg_it == f->argumentList.end())
-        return -1;
-    return std::distance(f->argumentList.begin(), arg_it);
+    if (!tok)
+        return false;
+    if (!tok->astParent())
+        return false;
+    if (Token::simpleMatch(tok->astParent(), "=") && astIsRHS(tok))
+        return true;
+    if (astIsPointer(tok->astParent()) && !Token::simpleMatch(tok->astParent(), "return"))
+        return true;
+    if (tok->astParent()->isConstOp())
+        return true;
+    if (!Token::simpleMatch(tok->astParent(), "return"))
+        return false;
+    return astIsPointer(tok->astParent()) || astIsContainerView(tok->astParent());
 }
 
-std::string lifetimeType(const Token *tok, const ValueFlow::Value *val)
+static bool isConvertedToView(const Token* tok, const Settings& settings)
 {
-    std::string result;
-    if (!val)
-        return "object";
-    switch (val->lifetimeKind) {
-    case ValueFlow::Value::LifetimeKind::Lambda:
-        result = "lambda";
-        break;
-    case ValueFlow::Value::LifetimeKind::Iterator:
-        result = "iterator";
-        break;
-    case ValueFlow::Value::LifetimeKind::Object:
-    case ValueFlow::Value::LifetimeKind::Address:
-        if (astIsPointer(tok))
-            result = "pointer";
-        else
-            result = "object";
-        break;
-    }
-    return result;
+    std::vector<ValueType> vtParents = getParentValueTypes(tok, settings);
+    return std::any_of(vtParents.cbegin(), vtParents.cend(), [&](const ValueType& vt) {
+        if (!vt.container)
+            return false;
+        return vt.container->view;
+    });
 }
 
-std::string lifetimeMessage(const Token *tok, const ValueFlow::Value *val, ErrorPath &errorPath)
+static bool isContainerOfPointers(const Token* tok, const Settings& settings)
 {
-    const Token *tokvalue = val ? val->tokvalue : nullptr;
-    const Variable *tokvar = tokvalue ? tokvalue->variable() : nullptr;
-    const Token *vartok = tokvar ? tokvar->nameToken() : nullptr;
-    std::string type = lifetimeType(tok, val);
-    std::string msg = type;
-    if (vartok) {
-        errorPath.emplace_back(vartok, "Variable created here.");
-        const Variable * var = vartok->variable();
-        if (var) {
-            switch (val->lifetimeKind) {
-            case ValueFlow::Value::LifetimeKind::Object:
-            case ValueFlow::Value::LifetimeKind::Address:
-                if (type == "pointer")
-                    msg += " to local variable";
-                else
-                    msg += " that points to local variable";
-                break;
-            case ValueFlow::Value::LifetimeKind::Lambda:
-                msg += " that captures local variable";
-                break;
-            case ValueFlow::Value::LifetimeKind::Iterator:
-                msg += " to local container";
-                break;
-            }
-            msg += " '" + var->name() + "'";
-        }
+    if (!tok)
+    {
+        return true;
     }
-    return msg;
+
+    ValueType vt = ValueType::parseDecl(tok, settings);
+    return vt.pointer > 0;
 }
 
-ValueFlow::Value getLifetimeObjValue(const Token *tok)
+static void valueFlowLifetime(TokenList &tokenlist, ErrorLogger &errorLogger, const Settings &settings)
 {
-    ValueFlow::Value result;
-    auto pred = [](const ValueFlow::Value &v) {
-        if (!v.isLocalLifetimeValue())
-            return false;
-        if (v.isInconclusive())
-            return false;
-        if (!v.tokvalue->variable())
-            return false;
-        return true;
-    };
-    auto it = std::find_if(tok->values().begin(), tok->values().end(), pred);
-    if (it == tok->values().end())
-        return result;
-    result = *it;
-    // There should only be one lifetime
-    if (std::find_if(std::next(it), tok->values().end(), pred) != tok->values().end())
-        return result;
-    return result;
-}
+    for (Token *tok = tokenlist.front(); tok; tok = tok->next()) {
+        if (!tok->scope())
+            continue;
+        if (tok->scope()->type == ScopeType::eGlobal)
+            continue;
+        Lambda lam(tok);
+        // Lambdas
+        if (lam.isLambda()) {
+            const Scope * bodyScope = lam.bodyTok->scope();
 
-std::vector<LifetimeToken> getLifetimeTokens(const Token* tok, ValueFlow::Value::ErrorPath errorPath, int depth)
-{
-    if (!tok)
-        return std::vector<LifetimeToken> {};
-    const Variable *var = tok->variable();
-    if (depth < 0)
-        return {{tok, std::move(errorPath)}};
-    if (var && var->declarationId() == tok->varId()) {
-        if (var->isReference() || var->isRValueReference()) {
-            if (!var->declEndToken())
-                return {{tok, true, std::move(errorPath)}};
-            if (var->isArgument()) {
-                errorPath.emplace_back(var->declEndToken(), "Passed to reference.");
-                return {{tok, true, std::move(errorPath)}};
-            } else if (Token::simpleMatch(var->declEndToken(), "=")) {
-                errorPath.emplace_back(var->declEndToken(), "Assigned to reference.");
-                const Token *vartok = var->declEndToken()->astOperand2();
-                if (vartok == tok)
-                    return {{tok, true, std::move(errorPath)}};
-                if (vartok)
-                    return getLifetimeTokens(vartok, std::move(errorPath), depth - 1);
-            } else {
-                return std::vector<LifetimeToken> {};
+            std::set<const Scope *> scopes;
+            // Avoid capturing a variable twice
+            std::set<nonneg int> varids;
+            bool capturedThis = false;
+
+            auto isImplicitCapturingVariable = [&](const Token *varTok) {
+                const Variable *var = varTok->variable();
+                if (!var)
+                    return false;
+                if (varids.count(var->declarationId()) > 0)
+                    return false;
+                if (!var->isLocal() && !var->isArgument())
+                    return false;
+                const Scope *scope = var->scope();
+                if (!scope)
+                    return false;
+                if (scopes.count(scope) > 0)
+                    return false;
+                if (scope->isNestedIn(bodyScope))
+                    return false;
+                scopes.insert(scope);
+                varids.insert(var->declarationId());
+                return true;
+            };
+
+            bool update = false;
+            auto captureVariable = [&](const Token* tok2, LifetimeCapture c, const std::function<bool(const Token*)> &pred) {
+                if (varids.count(tok->varId()) > 0)
+                    return;
+                if (c == LifetimeCapture::ByReference) {
+                    LifetimeStore ls{
+                        tok2, "Lambda captures variable by reference here.", ValueFlow::Value::LifetimeKind::Lambda};
+                    ls.forward = false;
+                    update |= ls.byRef(tok, tokenlist, errorLogger, settings, pred);
+                } else if (c == LifetimeCapture::ByValue) {
+                    LifetimeStore ls{
+                        tok2, "Lambda captures variable by value here.", ValueFlow::Value::LifetimeKind::Lambda};
+                    ls.forward = false;
+                    update |= ls.byVal(tok, tokenlist, errorLogger, settings, pred);
+                    pred(tok2);
+                }
+            };
+
+            auto captureThisVariable = [&](const Token* tok2, LifetimeCapture c) {
+                ValueFlow::Value value;
+                value.valueType = ValueFlow::Value::ValueType::LIFETIME;
+                if (c == LifetimeCapture::ByReference)
+                    value.lifetimeScope = ValueFlow::Value::LifetimeScope::ThisPointer;
+                else if (c == LifetimeCapture::ByValue)
+                    value.lifetimeScope = ValueFlow::Value::LifetimeScope::ThisValue;
+                value.tokvalue = tok2;
+                value.errorPath.emplace_back(tok2, "Lambda captures the 'this' variable here.");
+                value.lifetimeKind = ValueFlow::Value::LifetimeKind::Lambda;
+                capturedThis = true;
+                // Don't add the value a second time
+                if (std::find(tok->values().cbegin(), tok->values().cend(), value) != tok->values().cend())
+                    return;
+                setTokenValue(tok, std::move(value), settings);
+                update |= true;
+            };
+
+            // Handle explicit capture
+            for (const auto& p:lam.explicitCaptures) {
+                const Variable* var = p.first;
+                const Token* tok2 = p.second.first;
+                const LifetimeCapture c = p.second.second;
+                if (Token::Match(tok2, "this !!.")) {
+                    captureThisVariable(tok2, c);
+                } else if (var) {
+                    captureVariable(tok2, c, [](const Token*) {
+                        return true;
+                    });
+                    varids.insert(var->declarationId());
+                }
             }
+
+            auto isImplicitCapturingThis = [&](const Token* tok2) {
+                if (capturedThis)
+                    return false;
+                if (Token::simpleMatch(tok2, "this"))
+                    return true;
+                if (tok2->variable()) {
+                    if (Token::simpleMatch(tok2->previous(), "."))
+                        return false;
+                    const Variable* var = tok2->variable();
+                    if (var->isLocal())
+                        return false;
+                    if (var->isArgument())
+                        return false;
+                    return exprDependsOnThis(tok2);
+                }
+                if (Token::simpleMatch(tok2, "("))
+                    return exprDependsOnThis(tok2);
+                return false;
+            };
+
+            for (const Token * tok2 = lam.bodyTok; tok2 != lam.bodyTok->link(); tok2 = tok2->next()) {
+                if (isImplicitCapturingThis(tok2)) {
+                    captureThisVariable(tok2, LifetimeCapture::ByReference);
+                } else if (tok2->variable()) {
+                    captureVariable(tok2, lam.implicitCapture, isImplicitCapturingVariable);
+                }
+            }
+            if (update)
+                valueFlowForwardLifetime(tok, tokenlist, errorLogger, settings);
         }
-    } else if (Token::Match(tok->previous(), "%name% (")) {
-        const Function *f = tok->previous()->function();
-        if (f) {
-            if (!Function::returnsReference(f))
-                return {{tok, std::move(errorPath)}};
-            std::vector<LifetimeToken> result;
-            std::vector<const Token*> returns = findReturns(f);
-            for (const Token* returnTok : returns) {
-                if (returnTok == tok)
+        // address of
+        else if (tok->isUnaryOp("&")) {
+            if (Token::simpleMatch(tok->astParent(), "*"))
+                continue;
+            if (Token::simpleMatch(tok->astOperand1(), "[")) {
+                const Token* const op1 = tok->astOperand1()->astOperand1();
+                const Token* tok2 = op1;
+                while (Token::simpleMatch(tok2, "."))
+                    tok2 = tok2->astOperand2();
+                if (tok2 && tok2 != op1 && (!tok2->variable() || !tok2->variable()->isArray()) && !(tok2->valueType() && tok2->valueType()->container))
                     continue;
-                for (LifetimeToken& lt : getLifetimeTokens(returnTok, std::move(errorPath), depth - 1)) {
-                    const Token* argvarTok = lt.token;
-                    const Variable* argvar = argvarTok->variable();
-                    if (!argvar)
+            }
+            for (const ValueFlow::LifetimeToken& lt : ValueFlow::getLifetimeTokens(tok->astOperand1(), settings)) {
+                if (!settings.certainty.isEnabled(Certainty::inconclusive) && lt.inconclusive)
+                    continue;
+                ErrorPath errorPath = lt.errorPath;
+                errorPath.emplace_back(tok, "Address of variable taken here.");
+
+                ValueFlow::Value value;
+                value.valueType = ValueFlow::Value::ValueType::LIFETIME;
+                value.lifetimeScope = ValueFlow::Value::LifetimeScope::Local;
+                value.tokvalue = lt.token;
+                value.errorPath = std::move(errorPath);
+                if (lt.addressOf || astIsPointer(lt.token) || !Token::Match(lt.token->astParent(), ".|["))
+                    value.lifetimeKind = ValueFlow::Value::LifetimeKind::Address;
+                value.setInconclusive(lt.inconclusive);
+                setTokenValue(tok, std::move(value), settings);
+
+                valueFlowForwardLifetime(tok, tokenlist, errorLogger, settings);
+            }
+        }
+        // Converting to container view
+        else if (astIsContainerOwned(tok) && isConvertedToView(tok, settings)) {
+            LifetimeStore ls =
+                LifetimeStore{tok, "Converted to container view", ValueFlow::Value::LifetimeKind::SubObject};
+            ls.byRef(tok, tokenlist, errorLogger, settings);
+            valueFlowForwardLifetime(tok, tokenlist, errorLogger, settings);
+        }
+        // container lifetimes
+        else if (astIsContainer(tok)) {
+            Token * parent = astParentSkipParens(tok);
+            if (!parent)
+                continue;
+            if (!Token::Match(parent, ". %name% (") && !Token::Match(parent->previous(), "%name% ("))
+                continue;
+
+            // Skip if its a free function that doesnt yield an iterator to the container
+            if (Token::Match(parent->previous(), "%name% (") &&
+                !contains({Library::Container::Yield::START_ITERATOR, Library::Container::Yield::END_ITERATOR},
+                          astFunctionYield(parent->previous(), settings)))
+                continue;
+
+            ValueFlow::Value master;
+            master.valueType = ValueFlow::Value::ValueType::LIFETIME;
+            master.lifetimeScope = ValueFlow::Value::LifetimeScope::Local;
+
+            if (astIsIterator(parent->tokAt(2))) {
+                master.errorPath.emplace_back(parent->tokAt(2), "Iterator to container is created here.");
+                master.lifetimeKind = ValueFlow::Value::LifetimeKind::Iterator;
+            } else if (astIsIterator(parent) && Token::Match(parent->previous(), "%name% (") &&
+                       contains({Library::Container::Yield::START_ITERATOR, Library::Container::Yield::END_ITERATOR},
+                                astFunctionYield(parent->previous(), settings))) {
+                master.errorPath.emplace_back(parent, "Iterator to container is created here.");
+                master.lifetimeKind = ValueFlow::Value::LifetimeKind::Iterator;
+            } else if ((astIsPointer(parent->tokAt(2)) &&
+                        !isContainerOfPointers(tok->valueType()->containerTypeToken, settings)) ||
+                       Token::Match(parent->next(), "data|c_str")) {
+                master.errorPath.emplace_back(parent->tokAt(2), "Pointer to container is created here.");
+                master.lifetimeKind = ValueFlow::Value::LifetimeKind::Object;
+            } else {
+                continue;
+            }
+
+            std::vector<const Token*> toks;
+            if (tok->isUnaryOp("*") || parent->originalName() == "->") {
+                for (const ValueFlow::Value& v : tok->values()) {
+                    if (!v.isLocalLifetimeValue())
                         continue;
-                    if (argvar->isArgument() && (argvar->isReference() || argvar->isRValueReference())) {
-                        int n = getArgumentPos(argvar, f);
-                        if (n < 0)
-                            return std::vector<LifetimeToken> {};
-                        const Token* argTok = getArguments(tok->previous()).at(n);
-                        lt.errorPath.emplace_back(returnTok, "Return reference.");
-                        lt.errorPath.emplace_back(tok->previous(), "Called function passing '" + argTok->str() + "'.");
-                        std::vector<LifetimeToken> arglts = LifetimeToken::setInconclusive(
-                                                                getLifetimeTokens(argTok, std::move(lt.errorPath), depth - 1), returns.size() > 1);
-                        result.insert(result.end(), arglts.begin(), arglts.end());
-                    }
+                    if (v.lifetimeKind != ValueFlow::Value::LifetimeKind::Address)
+                        continue;
+                    if (!v.tokvalue)
+                        continue;
+                    toks.push_back(v.tokvalue);
                 }
+            } else if (astIsContainerView(tok)) {
+                for (const ValueFlow::Value& v : tok->values()) {
+                    if (!v.isLocalLifetimeValue())
+                        continue;
+                    if (!v.tokvalue)
+                        continue;
+                    if (!astIsContainerOwned(v.tokvalue))
+                        continue;
+                    toks.push_back(v.tokvalue);
+                }
+            } else {
+                toks = {tok};
             }
-            return result;
-        } else if (Token::Match(tok->tokAt(-2), ". %name% (") && astIsContainer(tok->tokAt(-2)->astOperand1())) {
-            const Library::Container* library = getLibraryContainer(tok->tokAt(-2)->astOperand1());
-            Library::Container::Yield y = library->getYield(tok->previous()->str());
-            if (y == Library::Container::Yield::AT_INDEX || y == Library::Container::Yield::ITEM) {
-                errorPath.emplace_back(tok->previous(), "Accessing container.");
-                return LifetimeToken::setAddressOf(
-                           getLifetimeTokens(tok->tokAt(-2)->astOperand1(), std::move(errorPath), depth - 1), false);
+
+            for (const Token* tok2 : toks) {
+                for (const ReferenceToken& rt : tok2->refs(false)) {
+                    ValueFlow::Value value = master;
+                    value.tokvalue = rt.token;
+                    value.errorPath.insert(value.errorPath.begin(), rt.errors.cbegin(), rt.errors.cend());
+                    if (Token::simpleMatch(parent, "("))
+                        setTokenValue(parent, std::move(value), settings);
+                    else
+                        setTokenValue(parent->tokAt(2), std::move(value), settings);
+
+                    if (!rt.token->variable()) {
+                        LifetimeStore ls = LifetimeStore{
+                            rt.token, master.errorPath.back().second, ValueFlow::Value::LifetimeKind::Object};
+                        ls.byRef(parent->tokAt(2), tokenlist, errorLogger, settings);
+                    }
+                }
             }
+            valueFlowForwardLifetime(parent->tokAt(2), tokenlist, errorLogger, settings);
         }
-    } else if (Token::Match(tok, ".|::|[")) {
-        const Token *vartok = tok;
-        while (vartok) {
-            if (vartok->str() == "[" || vartok->originalName() == "->")
-                vartok = vartok->astOperand1();
-            else if (vartok->str() == "." || vartok->str() == "::")
-                vartok = vartok->astOperand2();
-            else
-                break;
+        // Check constructors
+        else if (Token::Match(tok, "=|return|%name%|{|,|> {") && !isScope(tok->next())) {
+            valueFlowLifetimeConstructor(tok->next(), tokenlist, errorLogger, settings);
+        }
+        // Check function calls
+        else if (Token::Match(tok, "%name% (") && !Token::simpleMatch(tok->linkAt(1), ") {")) {
+            valueFlowLifetimeFunction(tok, tokenlist, errorLogger, settings);
         }
+        // Unique pointer lifetimes
+        else if (astIsUniqueSmartPointer(tok) && astIsLHS(tok) && Token::simpleMatch(tok->astParent(), ". get ( )")) {
+            Token* ptok = tok->astParent()->tokAt(2);
+            ErrorPath errorPath = {{ptok, "Raw pointer to smart pointer created here."}};
+            ValueFlow::Value value;
+            value.valueType = ValueFlow::Value::ValueType::LIFETIME;
+            value.lifetimeScope = ValueFlow::Value::LifetimeScope::Local;
+            value.lifetimeKind = ValueFlow::Value::LifetimeKind::SubObject;
+            value.tokvalue = tok;
+            value.errorPath = std::move(errorPath);
+            setTokenValue(ptok, std::move(value), settings);
+            valueFlowForwardLifetime(ptok, tokenlist, errorLogger, settings);
+        }
+        // Check variables
+        else if (tok->variable()) {
+            ErrorPath errorPath;
+            const Variable * var = ValueFlow::getLifetimeVariable(tok, errorPath, settings);
+            if (!var)
+                continue;
+            if (var->nameToken() == tok)
+                continue;
+            if (var->isArray() && !var->isStlType() && !var->isArgument() && isDecayedPointer(tok)) {
+                errorPath.emplace_back(tok, "Array decayed to pointer here.");
 
-        if (!vartok)
-            return {{tok, std::move(errorPath)}};
-        const Variable *tokvar = vartok->variable();
-        if (!astIsContainer(vartok) && !(tokvar && tokvar->isArray()) &&
-            (Token::Match(vartok->astParent(), "[|*") || vartok->astParent()->originalName() == "->")) {
-            for (const ValueFlow::Value &v : vartok->values()) {
-                if (!v.isLocalLifetimeValue())
-                    continue;
-                errorPath.insert(errorPath.end(), v.errorPath.begin(), v.errorPath.end());
-                return getLifetimeTokens(v.tokvalue, std::move(errorPath));
+                ValueFlow::Value value;
+                value.valueType = ValueFlow::Value::ValueType::LIFETIME;
+                value.lifetimeScope = ValueFlow::Value::LifetimeScope::Local;
+                value.tokvalue = var->nameToken();
+                value.errorPath = std::move(errorPath);
+                setTokenValue(tok, std::move(value), settings);
+
+                valueFlowForwardLifetime(tok, tokenlist, errorLogger, settings);
             }
-        } else {
-            return LifetimeToken::setAddressOf(getLifetimeTokens(vartok, std::move(errorPath)),
-                                               !(astIsContainer(vartok) && Token::simpleMatch(vartok->astParent(), "[")));
+        }
+        // Forward any lifetimes
+        else if (std::any_of(tok->values().cbegin(), tok->values().cend(), std::mem_fn(&ValueFlow::Value::isLifetimeValue))) {
+            valueFlowForwardLifetime(tok, tokenlist, errorLogger, settings);
         }
     }
-    return {{tok, std::move(errorPath)}};
-}
-
-static const Token* getLifetimeToken(const Token* tok, ValueFlow::Value::ErrorPath& errorPath, bool* addressOf = nullptr)
-{
-    std::vector<LifetimeToken> lts = getLifetimeTokens(tok);
-    if (lts.size() != 1)
-        return nullptr;
-    if (lts.front().inconclusive)
-        return nullptr;
-    if (addressOf)
-        *addressOf = lts.front().addressOf;
-    errorPath.insert(errorPath.end(), lts.front().errorPath.begin(), lts.front().errorPath.end());
-    return lts.front().token;
-}
-
-const Variable* getLifetimeVariable(const Token* tok, ValueFlow::Value::ErrorPath& errorPath, bool* addressOf)
-{
-    const Token* tok2 = getLifetimeToken(tok, errorPath, addressOf);
-    if (tok2 && tok2->variable())
-        return tok2->variable();
-    return nullptr;
 }
 
-static bool isNotLifetimeValue(const ValueFlow::Value& val)
-{
-    return !val.isLifetimeValue();
-}
-
-static bool isLifetimeOwned(const ValueType *vt, const ValueType *vtParent)
+static bool isStdMoveOrStdForwarded(Token * tok, ValueFlow::Value::MoveKind * moveKind, Token ** varTok = nullptr)
 {
-    if (!vtParent)
-        return false;
-    if (!vt) {
-        if (vtParent->type == ValueType::CONTAINER)
-            return true;
+    if (tok->str() != "std")
         return false;
-    }
-    if (vt->type != ValueType::UNKNOWN_TYPE && vtParent->type != ValueType::UNKNOWN_TYPE) {
-        if (vt->pointer != vtParent->pointer)
-            return true;
-        if (vt->type != vtParent->type) {
-            if (vtParent->type == ValueType::RECORD)
-                return true;
-            if (vtParent->type == ValueType::CONTAINER)
-                return true;
+    ValueFlow::Value::MoveKind kind = ValueFlow::Value::MoveKind::NonMovedVariable;
+    Token * variableToken = nullptr;
+    if (Token::Match(tok, "std :: move ( %var% )")) {
+        variableToken = tok->tokAt(4);
+        kind = ValueFlow::Value::MoveKind::MovedVariable;
+    } else if (Token::simpleMatch(tok, "std :: forward <")) {
+        Token * const leftAngle = tok->tokAt(3);
+        Token * rightAngle = leftAngle->link();
+        if (Token::Match(rightAngle, "> ( %var% )")) {
+            variableToken = rightAngle->tokAt(2);
+            kind = ValueFlow::Value::MoveKind::ForwardedVariable;
         }
     }
-
-    return false;
-}
-
-static bool isLifetimeBorrowed(const ValueType *vt, const ValueType *vtParent)
-{
-    if (!vtParent)
+    if (!variableToken)
         return false;
-    if (!vt)
+    if (variableToken->strAt(2) == ".") // Only partially moved
         return false;
-    if (vt->type != ValueType::UNKNOWN_TYPE && vtParent->type != ValueType::UNKNOWN_TYPE) {
-        if (vtParent->pointer > vt->pointer)
-            return true;
-        if (vtParent->pointer < vt->pointer && vtParent->isIntegral())
-            return true;
-    }
-
-    return false;
+    if (variableToken->valueType() && variableToken->valueType()->type >= ValueType::Type::VOID)
+        return false;
+    if (moveKind != nullptr)
+        *moveKind = kind;
+    if (varTok != nullptr)
+        *varTok = variableToken;
+    return true;
 }
 
-bool isLifetimeBorrowed(const Token *tok, const Settings *settings)
+static bool isOpenParenthesisMemberFunctionCallOfVarId(const Token * openParenthesisToken, nonneg int varId)
 {
-    if (!tok)
-        return true;
-    if (Token::simpleMatch(tok, ","))
-        return true;
-    if (!tok->astParent())
-        return true;
-    if (!Token::Match(tok->astParent()->previous(), "%name% (") && !Token::simpleMatch(tok->astParent(), ",")) {
-        if (!Token::simpleMatch(tok, "{")) {
-            const ValueType *vt = tok->valueType();
-            const ValueType *vtParent = tok->astParent()->valueType();
-            if (isLifetimeBorrowed(vt, vtParent))
-                return true;
-            if (isLifetimeOwned(vt, vtParent))
-                return false;
-        }
-        const Type *t = Token::typeOf(tok);
-        const Type *parentT = Token::typeOf(tok->astParent());
-        if (t && parentT && t->classDef && parentT->classDef && t->classDef != parentT->classDef) {
-            return false;
-        }
-    } else if (Token::Match(tok->astParent()->tokAt(-3), "%var% . push_back|push_front|insert|push (") &&
-               astIsContainer(tok->astParent()->tokAt(-3))) {
-        const ValueType *vt = tok->valueType();
-        const ValueType *vtCont = tok->astParent()->tokAt(-3)->valueType();
-        if (!vtCont->containerTypeToken)
-            return true;
-        ValueType vtParent = ValueType::parseDecl(vtCont->containerTypeToken, settings);
-        if (isLifetimeBorrowed(vt, &vtParent))
-            return true;
-        if (isLifetimeOwned(vt, &vtParent))
-            return false;
-    }
-
-    return true;
+    const Token * varTok = openParenthesisToken->tokAt(-3);
+    return Token::Match(varTok, "%varid% . %name% (", varId) &&
+           varTok->next()->originalName().empty();
 }
 
-static void valueFlowLifetimeFunction(Token *tok, TokenList *tokenlist, ErrorLogger *errorLogger, const Settings *settings);
-
-static void valueFlowLifetimeConstructor(Token *tok,
-        TokenList *tokenlist,
-        ErrorLogger *errorLogger,
-        const Settings *settings);
+static Token* findOpenParentesisOfMove(Token* moveVarTok)
+{
+    Token* tok = moveVarTok;
+    while (tok && tok->str() != "(")
+        tok = tok->previous();
+    return tok;
+}
 
-static void valueFlowForwardLifetime(Token * tok, TokenList *tokenlist, ErrorLogger *errorLogger, const Settings *settings)
+static Token* findEndOfFunctionCallForParameter(Token* parameterToken)
 {
-    Token *parent = tok->astParent();
-    while (parent && (parent->isArithmeticalOp() || parent->str() == ","))
+    if (!parameterToken)
+        return nullptr;
+    Token* parent = parameterToken->astParent();
+    while (parent && !parent->isOp() && !Token::Match(parent, "[({]"))
         parent = parent->astParent();
     if (!parent)
-        return;
-    // Assignment
-    if (parent->str() == "=" && (!parent->astParent() || Token::simpleMatch(parent->astParent(), ";"))) {
-        const Variable *var = getLHSVariable(parent);
-        if (!var)
-            return;
-
-        const Token * endOfVarScope = nullptr;
-        if (!var->isLocal())
-            endOfVarScope = tok->scope()->bodyEnd;
-        else
-            endOfVarScope = var->typeStartToken()->scope()->bodyEnd;
-
-        // Rhs values..
-        if (!parent->astOperand2() || parent->astOperand2()->values().empty())
-            return;
-
-        if (!isLifetimeBorrowed(parent->astOperand2(), settings))
-            return;
-
-        std::list<ValueFlow::Value> values = parent->astOperand2()->values();
-
-        // Static variable initialisation?
-        if (var->isStatic() && var->nameToken() == parent->astOperand1())
-            lowerToPossible(values);
-
-        // Skip RHS
-        const Token *nextExpression = nextAfterAstRightmostLeaf(parent);
-
-        // Only forward lifetime values
-        values.remove_if(&isNotLifetimeValue);
-        valueFlowForwardVariable(const_cast<Token*>(nextExpression),
-                                 endOfVarScope,
-                                 var,
-                                 var->declarationId(),
-                                 values,
-                                 false,
-                                 false,
-                                 tokenlist,
-                                 errorLogger,
-                                 settings);
-
-        if (tok->astTop() && Token::simpleMatch(tok->astTop()->previous(), "for (") &&
-            Token::simpleMatch(tok->astTop()->link(), ") {")) {
-            Token *start = tok->astTop()->link()->next();
-            valueFlowForwardVariable(
-                start, start->link(), var, var->declarationId(), values, false, false, tokenlist, errorLogger, settings);
-        }
-        // Constructor
-    } else if (Token::simpleMatch(parent, "{") && !isScopeBracket(parent)) {
-        valueFlowLifetimeConstructor(parent, tokenlist, errorLogger, settings);
-        valueFlowForwardLifetime(parent, tokenlist, errorLogger, settings);
-        // Function call
-    } else if (Token::Match(parent->previous(), "%name% (")) {
-        valueFlowLifetimeFunction(parent->previous(), tokenlist, errorLogger, settings);
-        valueFlowForwardLifetime(parent, tokenlist, errorLogger, settings);
-        // Variable
-    } else if (tok->variable()) {
-        const Variable *var = tok->variable();
-        if (!var->typeStartToken() || !var->typeStartToken()->scope())
-            return;
-        const Token *endOfVarScope = var->typeStartToken()->scope()->bodyEnd;
-
-        std::list<ValueFlow::Value> values = tok->values();
-        const Token *nextExpression = nextAfterAstRightmostLeaf(parent);
-        // Only forward lifetime values
-        values.remove_if(&isNotLifetimeValue);
-        valueFlowForwardVariable(const_cast<Token*>(nextExpression),
-                                 endOfVarScope,
-                                 var,
-                                 var->declarationId(),
-                                 values,
-                                 false,
-                                 false,
-                                 tokenlist,
-                                 errorLogger,
-                                 settings);
-    }
+        return nullptr;
+    return nextAfterAstRightmostLeaf(parent);
 }
 
-struct LifetimeStore {
-    const Token *argtok;
-    std::string message;
-    ValueFlow::Value::LifetimeKind type;
-    ErrorPath errorPath;
-    bool inconclusive;
-
-    LifetimeStore()
-        : argtok(nullptr), message(), type(), errorPath(), inconclusive(false)
-    {}
-
-    LifetimeStore(const Token *argtok,
-                  const std::string &message,
-                  ValueFlow::Value::LifetimeKind type = ValueFlow::Value::LifetimeKind::Object,
-                  bool inconclusive = false)
-        : argtok(argtok), message(message), type(type), errorPath(), inconclusive(inconclusive)
-    {}
-
-    static LifetimeStore fromFunctionArg(const Function * f, Token *tok, const Variable *var, TokenList *tokenlist, ErrorLogger *errorLogger) {
-        if (!var)
-            return LifetimeStore{};
-        if (!var->isArgument())
-            return LifetimeStore{};
-        int n = getArgumentPos(var, f);
-        if (n < 0)
-            return LifetimeStore{};
-        std::vector<const Token *> args = getArguments(tok);
-        if (n >= args.size()) {
-            if (tokenlist->getSettings()->debugwarnings)
-                bailout(tokenlist,
-                        errorLogger,
-                        tok,
-                        "Argument mismatch: Function '" + tok->str() + "' returning lifetime from argument index " +
-                        std::to_string(n) + " but only " + std::to_string(args.size()) +
-                        " arguments are available.");
-            return LifetimeStore{};
-        }
-        const Token *argtok2 = args[n];
-        return LifetimeStore{argtok2, "Passed to '" + tok->str() + "'.", ValueFlow::Value::LifetimeKind::Object};
-    }
-
-    template <class Predicate>
-    void byRef(Token *tok, TokenList *tokenlist, ErrorLogger *errorLogger, const Settings *settings, Predicate pred) const {
-        if (!settings->inconclusive && inconclusive)
-            return;
-        if (!argtok)
-            return;
-        for (const LifetimeToken& lt : getLifetimeTokens(argtok)) {
-            if (!settings->inconclusive && lt.inconclusive)
-                continue;
-            ErrorPath er = errorPath;
-            er.insert(er.end(), lt.errorPath.begin(), lt.errorPath.end());
-            if (!lt.token)
-                return;
-            if (!pred(lt.token))
-                return;
-            er.emplace_back(argtok, message);
-
-            ValueFlow::Value value;
-            value.valueType = ValueFlow::Value::LIFETIME;
-            value.lifetimeScope = ValueFlow::Value::LifetimeScope::Local;
-            value.tokvalue = lt.token;
-            value.errorPath = std::move(er);
-            value.lifetimeKind = type;
-            value.setInconclusive(lt.inconclusive || inconclusive);
-            // Don't add the value a second time
-            if (std::find(tok->values().begin(), tok->values().end(), value) != tok->values().end())
-                return;
-            setTokenValue(tok, value, tokenlist->getSettings());
-            valueFlowForwardLifetime(tok, tokenlist, errorLogger, settings);
+static void valueFlowAfterMove(const TokenList& tokenlist, const SymbolDatabase& symboldatabase, ErrorLogger& errorLogger, const Settings& settings)
+{
+    if (!tokenlist.isCPP() || settings.standards.cpp < Standards::CPP11)
+        return;
+    for (const Scope * scope : symboldatabase.functionScopes) {
+        if (!scope)
+            continue;
+        const Token * start = scope->bodyStart;
+        if (scope->function) {
+            const Token * memberInitializationTok = scope->function->constructorMemberInitialization();
+            if (memberInitializationTok)
+                start = memberInitializationTok;
         }
-    }
 
-    void byRef(Token *tok, TokenList *tokenlist, ErrorLogger *errorLogger, const Settings *settings) const {
-        byRef(tok, tokenlist, errorLogger, settings, [](const Token *) {
-            return true;
-        });
-    }
+        for (auto* tok = const_cast<Token*>(start); tok != scope->bodyEnd; tok = tok->next()) {
+            Token * varTok;
+            if (Token::Match(tok, "%var% . reset|clear (") && tok->next()->originalName().empty()) {
+                varTok = tok;
 
-    template <class Predicate>
-    void byVal(Token *tok, TokenList *tokenlist, ErrorLogger *errorLogger, const Settings *settings, Predicate pred) const {
-        if (!settings->inconclusive && inconclusive)
-            return;
-        if (!argtok)
-            return;
-        if (argtok->values().empty()) {
-            ErrorPath er;
-            er.emplace_back(argtok, message);
-            const Variable *var = getLifetimeVariable(argtok, er);
-            if (var && var->isArgument()) {
-                ValueFlow::Value value;
-                value.valueType = ValueFlow::Value::LIFETIME;
-                value.lifetimeScope = ValueFlow::Value::LifetimeScope::Argument;
-                value.tokvalue = var->nameToken();
-                value.errorPath = er;
-                value.lifetimeKind = type;
-                value.setInconclusive(inconclusive);
-                // Don't add the value a second time
-                if (std::find(tok->values().begin(), tok->values().end(), value) != tok->values().end())
-                    return;
-                setTokenValue(tok, value, tokenlist->getSettings());
-                valueFlowForwardLifetime(tok, tokenlist, errorLogger, settings);
-            }
-        }
-        for (const ValueFlow::Value &v : argtok->values()) {
-            if (!v.isLifetimeValue())
-                continue;
-            const Token *tok3 = v.tokvalue;
-            for (const LifetimeToken& lt : getLifetimeTokens(tok3)) {
-                if (!settings->inconclusive && lt.inconclusive)
+                const Variable *var = tok->variable();
+                if (!var || (!var->isLocal() && !var->isArgument()))
                     continue;
-                ErrorPath er = v.errorPath;
-                er.insert(er.end(), lt.errorPath.begin(), lt.errorPath.end());
-                if (!lt.token)
-                    return;
-                if (!pred(lt.token))
-                    return;
-                er.emplace_back(argtok, message);
-                er.insert(er.end(), errorPath.begin(), errorPath.end());
 
                 ValueFlow::Value value;
-                value.valueType = ValueFlow::Value::LIFETIME;
-                value.lifetimeScope = v.lifetimeScope;
-                value.tokvalue = lt.token;
-                value.errorPath = std::move(er);
-                value.lifetimeKind = type;
-                value.setInconclusive(lt.inconclusive || v.isInconclusive() || inconclusive);
-                // Don't add the value a second time
-                if (std::find(tok->values().begin(), tok->values().end(), value) != tok->values().end())
-                    continue;
-                setTokenValue(tok, value, tokenlist->getSettings());
-                valueFlowForwardLifetime(tok, tokenlist, errorLogger, settings);
-            }
-        }
-    }
-
-    void byVal(Token *tok, TokenList *tokenlist, ErrorLogger *errorLogger, const Settings *settings) const {
-        byVal(tok, tokenlist, errorLogger, settings, [](const Token *) {
-            return true;
-        });
-    }
+                value.valueType = ValueFlow::Value::ValueType::MOVED;
+                value.moveKind = ValueFlow::Value::MoveKind::NonMovedVariable;
+                value.errorPath.emplace_back(tok, "Calling " + tok->next()->expressionString() + " makes " + tok->str() + " 'non-moved'");
+                value.setKnown();
 
-    template <class Predicate>
-    void byDerefCopy(Token *tok, TokenList *tokenlist, ErrorLogger *errorLogger, const Settings *settings, Predicate pred) const {
-        if (!settings->inconclusive && inconclusive)
-            return;
-        if (!argtok)
-            return;
-        for (const ValueFlow::Value &v : argtok->values()) {
-            if (!v.isLifetimeValue())
+                setTokenValue(tok, value, settings);
+                if (var->scope()) {
+                    const Token* const endOfVarScope = var->scope()->bodyEnd;
+                    valueFlowForward(tok->next(), endOfVarScope, tok, std::move(value), tokenlist, errorLogger, settings);
+                }
+                continue;
+            }
+            ValueFlow::Value::MoveKind moveKind;
+            if (!isStdMoveOrStdForwarded(tok, &moveKind, &varTok))
+                continue;
+            const nonneg int varId = varTok->varId();
+            // x is not MOVED after assignment if code is:  x = ... std::move(x) .. ;
+            const Token *parent = tok->astParent();
+            while (parent && parent->str() != "=" && parent->str() != "return" &&
+                   !(parent->str() == "(" && isOpenParenthesisMemberFunctionCallOfVarId(parent, varId)))
+                parent = parent->astParent();
+            if (parent &&
+                (parent->str() == "return" || // MOVED in return statement
+                 parent->str() == "(")) // MOVED in self assignment, isOpenParenthesisMemberFunctionCallOfVarId == true
                 continue;
-            const Token *tok2 = v.tokvalue;
-            ErrorPath er = v.errorPath;
-            const Variable *var = getLifetimeVariable(tok2, er);
-            er.insert(er.end(), errorPath.begin(), errorPath.end());
-            if (!var)
+            if (parent && parent->astOperand1() && parent->astOperand1()->varId() == varId)
                 continue;
-            for (const Token *tok3 = tok; tok3 && tok3 != var->declEndToken(); tok3 = tok3->previous()) {
-                if (tok3->varId() == var->declarationId()) {
-                    LifetimeStore{tok3, message, type, inconclusive} .byVal(tok, tokenlist, errorLogger, settings, pred);
-                    break;
+            const Token* const endOfVarScope = ValueFlow::getEndOfExprScope(varTok);
+
+            Token* openParentesisOfMove = findOpenParentesisOfMove(varTok);
+            Token* endOfFunctionCall = findEndOfFunctionCallForParameter(openParentesisOfMove);
+            if (endOfFunctionCall) {
+                if (endOfFunctionCall->str() == ")") {
+                    Token* ternaryColon = endOfFunctionCall->link()->astParent();
+                    while (Token::simpleMatch(ternaryColon, "("))
+                        ternaryColon = ternaryColon->astParent();
+                    if (Token::simpleMatch(ternaryColon, ":")) {
+                        endOfFunctionCall = ternaryColon->astOperand2();
+                        if (Token::simpleMatch(endOfFunctionCall, "("))
+                            endOfFunctionCall = endOfFunctionCall->link();
+                    }
                 }
+                ValueFlow::Value value;
+                value.valueType = ValueFlow::Value::ValueType::MOVED;
+                value.moveKind = moveKind;
+                if (moveKind == ValueFlow::Value::MoveKind::MovedVariable)
+                    value.errorPath.emplace_back(tok, "Calling std::move(" + varTok->str() + ")");
+                else // if (moveKind == ValueFlow::Value::ForwardedVariable)
+                    value.errorPath.emplace_back(tok, "Calling std::forward(" + varTok->str() + ")");
+                value.setKnown();
+
+                valueFlowForward(endOfFunctionCall, endOfVarScope, varTok, std::move(value), tokenlist, errorLogger, settings);
             }
         }
     }
+}
+
+static const Token* findIncompleteVar(const Token* start, const Token* end)
+{
+    for (const Token* tok = start; tok != end; tok = tok->next()) {
+        if (tok->isIncompleteVar())
+            return tok;
+    }
+    return nullptr;
+}
+
+static ValueFlow::Value makeConditionValue(long long val,
+                                           const Token* condTok,
+                                           bool assume,
+                                           bool impossible,
+                                           const Settings& settings,
+                                           SourceLocation loc = SourceLocation::current())
+{
+    ValueFlow::Value v(val);
+    v.setKnown();
+    if (impossible) {
+        v.intvalue = !v.intvalue;
+        v.setImpossible();
+    }
+    v.condition = condTok;
+    if (assume)
+        v.errorPath.emplace_back(condTok, "Assuming condition '" + condTok->expressionString() + "' is true");
+    else
+        v.errorPath.emplace_back(condTok, "Assuming condition '" + condTok->expressionString() + "' is false");
+    if (settings.debugnormal)
+        setSourceLocation(v, loc, condTok);
+    return v;
+}
 
-    void byDerefCopy(Token *tok, TokenList *tokenlist, ErrorLogger *errorLogger, const Settings *settings) const {
-        byDerefCopy(tok, tokenlist, errorLogger, settings, [](const Token *) {
+static std::vector<const Token*> getConditions(const Token* tok, const char* op)
+{
+    std::vector<const Token*> conds = {tok};
+    if (tok->str() == op) {
+        std::vector<const Token*> args = astFlatten(tok, op);
+        std::copy_if(args.cbegin(), args.cend(), std::back_inserter(conds), [&](const Token* tok2) {
+            if (tok2->exprId() == 0)
+                return false;
+            if (tok2->hasKnownIntValue())
+                return false;
+            if (Token::Match(tok2, "%var%|.") && !astIsBool(tok2))
+                return false;
             return true;
         });
     }
-};
+    return conds;
+}
 
-static void valueFlowLifetimeFunction(Token *tok, TokenList *tokenlist, ErrorLogger *errorLogger, const Settings *settings)
+static bool isBreakOrContinueScope(const Token* endToken)
 {
-    if (!Token::Match(tok, "%name% ("))
-        return;
-    if (Token::Match(tok->tokAt(-2), "std :: ref|cref|tie|front_inserter|back_inserter")) {
-        for (const Token *argtok : getArguments(tok)) {
-            LifetimeStore{argtok, "Passed to '" + tok->str() + "'.", ValueFlow::Value::LifetimeKind::Object} .byRef(
-                tok->next(), tokenlist, errorLogger, settings);
-        }
-    } else if (Token::Match(tok->tokAt(-2), "std :: make_tuple|tuple_cat|make_pair|make_reverse_iterator|next|prev|move")) {
-        for (const Token *argtok : getArguments(tok)) {
-            LifetimeStore{argtok, "Passed to '" + tok->str() + "'.", ValueFlow::Value::LifetimeKind::Object} .byVal(
-                tok->next(), tokenlist, errorLogger, settings);
+    if (!Token::simpleMatch(endToken, "}"))
+        return false;
+    return Token::Match(endToken->tokAt(-2), "break|continue ;");
+}
+
+static const Scope* getLoopScope(const Token* tok)
+{
+    if (!tok)
+        return nullptr;
+    const Scope* scope = tok->scope();
+    while (scope && scope->type != ScopeType::eWhile && scope->type != ScopeType::eFor && scope->type != ScopeType::eDo)
+        scope = scope->nestedIn;
+    return scope;
+}
+
+//
+static void valueFlowConditionExpressions(const TokenList& tokenlist,
+                                          const SymbolDatabase& symboldatabase,
+                                          ErrorLogger& errorLogger,
+                                          const Settings& settings)
+{
+    if (!settings.daca && !settings.vfOptions.doConditionExpressionAnalysis) {
+        if (settings.debugwarnings) {
+            ErrorMessage::FileLocation loc(tokenlist.getSourceFilePath(), 0, 0);
+            const ErrorMessage errmsg(
+                {std::move(loc)},
+                tokenlist.getSourceFilePath(),
+                Severity::debug,
+                "Analysis of condition expressions is disabled. Use --check-level=exhaustive to enable it.",
+                "normalCheckLevelConditionExpressions",
+                Certainty::normal);
+            errorLogger.reportErr(errmsg);
         }
-    } else if (Token::Match(tok->tokAt(-2), "%var% . push_back|push_front|insert|push|assign") &&
-               astIsContainer(tok->tokAt(-2))) {
-        Token *vartok = tok->tokAt(-2);
-        std::vector<const Token *> args = getArguments(tok);
-        std::size_t n = args.size();
-        if (n > 1 && Token::typeStr(args[n - 2]) == Token::typeStr(args[n - 1]) &&
-            (((astIsIterator(args[n - 2]) && astIsIterator(args[n - 1])) ||
-              (astIsPointer(args[n - 2]) && astIsPointer(args[n - 1]))))) {
-            LifetimeStore{args.back(), "Added to container '" + vartok->str() + "'.", ValueFlow::Value::LifetimeKind::Object} .byDerefCopy(
-                vartok, tokenlist, errorLogger, settings);
-        } else if (!args.empty() && isLifetimeBorrowed(args.back(), settings)) {
-            LifetimeStore{args.back(), "Added to container '" + vartok->str() + "'.", ValueFlow::Value::LifetimeKind::Object} .byVal(
-                vartok, tokenlist, errorLogger, settings);
+        return;
+    }
+
+    for (const Scope* scope : symboldatabase.functionScopes) {
+        if (const Token* incompleteTok = findIncompleteVar(scope->bodyStart, scope->bodyEnd)) {
+            if (settings.debugwarnings)
+                bailoutIncompleteVar(tokenlist,
+                                     errorLogger,
+                                     incompleteTok,
+                                     "Skipping function due to incomplete variable " + incompleteTok->str());
+            continue;
         }
-    } else if (tok->function()) {
-        const Function *f = tok->function();
-        if (Function::returnsReference(f))
-            return;
-        std::vector<const Token*> returns = findReturns(f);
-        const bool inconclusive = returns.size() > 1;
-        for (const Token* returnTok : returns) {
-            if (returnTok == tok)
+
+        if (settings.daca && !settings.vfOptions.doConditionExpressionAnalysis)
+            continue;
+
+        for (auto* tok = const_cast<Token*>(scope->bodyStart); tok != scope->bodyEnd; tok = tok->next()) {
+            if (!Token::simpleMatch(tok, "if ("))
                 continue;
-            const Variable *returnVar = returnTok->variable();
-            if (returnVar && returnVar->isArgument() && (returnVar->isConst() || !isVariableChanged(returnVar, settings, tokenlist->isCPP()))) {
-                LifetimeStore ls = LifetimeStore::fromFunctionArg(f, tok, returnVar, tokenlist, errorLogger);
-                ls.inconclusive = inconclusive;
-                ls.byVal(tok->next(), tokenlist, errorLogger, settings);
+            Token* parenTok = tok->next();
+            if (!Token::simpleMatch(parenTok->link(), ") {"))
+                continue;
+            const Token* condTok = parenTok->astOperand2();
+            if (condTok->exprId() == 0)
+                continue;
+            if (condTok->hasKnownIntValue())
+                continue;
+            if (!isConstExpression(condTok, settings.library))
+                continue;
+            const bool isOp = condTok->isComparisonOp() || condTok->tokType() == Token::eLogicalOp;
+            const bool is1 = isOp || astIsBool(condTok);
+
+            Token* blockTok = parenTok->link()->tokAt(1);
+            Token* startTok = blockTok;
+            // Inner condition
+            {
+                for (const Token* condTok2 : getConditions(condTok, "&&")) {
+                    if (is1) {
+                        const bool isBool = astIsBool(condTok2) || Token::Match(condTok2, "%comp%|%oror%|&&");
+                        auto a1 = makeSameExpressionAnalyzer(
+                            condTok2,
+                            makeConditionValue(1, condTok2, /*assume*/ true, !isBool, settings),
+                            settings); // don't set '1' for non-boolean expressions
+                        valueFlowGenericForward(startTok, startTok->link(), a1, tokenlist, errorLogger, settings);
+                    }
+
+                    auto a2 = makeOppositeExpressionAnalyzer(true,
+                                                             condTok2,
+                                                             makeConditionValue(0, condTok2, true, false, settings),
+                                                             settings);
+                    valueFlowGenericForward(startTok, startTok->link(), a2, tokenlist, errorLogger, settings);
+                }
             }
-            for (const ValueFlow::Value &v : returnTok->values()) {
-                if (!v.isLifetimeValue())
-                    continue;
-                if (!v.tokvalue)
-                    continue;
-                const Variable *var = v.tokvalue->variable();
-                LifetimeStore ls = LifetimeStore::fromFunctionArg(f, tok, var, tokenlist, errorLogger);
-                if (!ls.argtok)
-                    continue;
-                ls.inconclusive = inconclusive;
-                ls.errorPath = v.errorPath;
-                ls.errorPath.emplace_front(returnTok, "Return " + lifetimeType(returnTok, &v) + ".");
-                if (var->isReference() || var->isRValueReference()) {
-                    ls.byRef(tok->next(), tokenlist, errorLogger, settings);
-                } else if (v.isArgumentLifetimeValue()) {
-                    ls.byVal(tok->next(), tokenlist, errorLogger, settings);
+
+            std::vector<const Token*> conds = getConditions(condTok, "||");
+            if (conds.empty())
+                continue;
+
+            // Check else block
+            if (Token::simpleMatch(startTok->link(), "} else {")) {
+                startTok = startTok->link()->tokAt(2);
+                for (const Token* condTok2 : conds) {
+                    auto a1 = makeSameExpressionAnalyzer(condTok2,
+                                                         makeConditionValue(0, condTok2, false, false, settings),
+                                                         settings);
+                    valueFlowGenericForward(startTok, startTok->link(), a1, tokenlist, errorLogger, settings);
+
+                    if (is1) {
+                        auto a2 =
+                            makeOppositeExpressionAnalyzer(true,
+                                                           condTok2,
+                                                           makeConditionValue(isOp, condTok2, false, false, settings),
+                                                           settings);
+                        valueFlowGenericForward(startTok, startTok->link(), a2, tokenlist, errorLogger, settings);
+                    }
+                }
+            }
+
+            // Check if the block terminates early
+            if (isEscapeScope(blockTok, settings)) {
+                const Scope* scope2 = scope;
+                // If escaping a loop then only use the loop scope
+                if (isBreakOrContinueScope(blockTok->link())) {
+                    scope2 = getLoopScope(blockTok->link());
+                    if (!scope2)
+                        continue;
+                }
+                for (const Token* condTok2 : conds) {
+                    auto a1 = makeSameExpressionAnalyzer(condTok2,
+                                                         makeConditionValue(0, condTok2, false, false, settings),
+                                                         settings);
+                    valueFlowGenericForward(startTok->link()->next(), scope2->bodyEnd, a1, tokenlist, errorLogger, settings);
+
+                    if (is1) {
+                        auto a2 = makeOppositeExpressionAnalyzer(true,
+                                                                 condTok2,
+                                                                 makeConditionValue(1, condTok2, false, false, settings),
+                                                                 settings);
+                        valueFlowGenericForward(startTok->link()->next(),
+                                                scope2->bodyEnd,
+                                                a2,
+                                                tokenlist,
+                                                errorLogger,
+                                                settings);
+                    }
                 }
             }
         }
     }
 }
 
-static void valueFlowLifetimeConstructor(Token* tok,
-        const Type* t,
-        TokenList* tokenlist,
-        ErrorLogger* errorLogger,
-        const Settings* settings)
+static bool isTruncated(const ValueType* src, const ValueType* dst, const Settings& settings)
 {
-    if (!t)
-        return;
-    if (!Token::Match(tok, "(|{"))
-        return;
-    const Scope* scope = t->classScope;
-    if (!scope)
-        return;
-    // Only support aggregate constructors for now
-    if (scope->numConstructors == 0 && t->derivedFrom.empty() && (t->isClassType() || t->isStructType())) {
-        std::vector<const Token*> args = getArguments(tok);
-        std::size_t i = 0;
-        for (const Variable& var : scope->varlist) {
-            if (i >= args.size())
-                break;
-            const Token* argtok = args[i];
-            LifetimeStore ls{
-                argtok, "Passed to constructor of '" + t->name() + "'.", ValueFlow::Value::LifetimeKind::Object};
-            if (var.isReference() || var.isRValueReference()) {
-                ls.byRef(tok, tokenlist, errorLogger, settings);
-            } else {
-                ls.byVal(tok, tokenlist, errorLogger, settings);
-            }
-            i++;
-        }
+    if (src->pointer > 0 || dst->pointer > 0)
+        return src->pointer != dst->pointer;
+    if (src->smartPointer && dst->smartPointer)
+        return false;
+    if ((src->isIntegral() && dst->isIntegral()) || (src->isFloat() && dst->isFloat())) {
+        const size_t srcSize = src->getSizeOf(settings, ValueType::Accuracy::LowerBound, ValueType::SizeOf::Pointer);
+        const size_t dstSize = dst->getSizeOf(settings, ValueType::Accuracy::LowerBound, ValueType::SizeOf::Pointer);
+        if (srcSize > dstSize)
+            return true;
+        if (srcSize == dstSize && src->sign != dst->sign)
+            return true;
+    } else if (src->type == dst->type) {
+        if (src->type == ValueType::Type::RECORD)
+            return src->typeScope != dst->typeScope;
+    } else {
+        return true;
     }
+    return false;
 }
-static void valueFlowLifetimeConstructor(Token* tok, TokenList* tokenlist, ErrorLogger* errorLogger, const Settings* settings)
+
+static void setSymbolic(ValueFlow::Value& value, const Token* tok)
 {
-    if (!Token::Match(tok, "(|{"))
-        return;
-    Token* parent = tok->astParent();
-    while (Token::simpleMatch(parent, ","))
-        parent = parent->astParent();
-    if (Token::simpleMatch(parent, "{") && (astIsContainer(parent->astParent()) || astIsPointer(parent->astParent()))) {
-        valueFlowLifetimeConstructor(tok, Token::typeOf(parent->previous()), tokenlist, errorLogger, settings);
-    } else if (Token::simpleMatch(tok, "{") && (astIsContainer(parent) || astIsPointer(parent))) {
-        std::vector<const Token *> args = getArguments(tok);
-        for (const Token *argtok : args) {
-            LifetimeStore ls{argtok, "Passed to initializer list.", ValueFlow::Value::LifetimeKind::Object};
-            ls.byVal(tok, tokenlist, errorLogger, settings);
-        }
-    } else if (const Type* t = Token::typeOf(tok->previous())) {
-        valueFlowLifetimeConstructor(tok, t, tokenlist, errorLogger, settings);
-    }
+    assert(tok && tok->exprId() > 0 && "Missing expr id for symbolic value");
+    value.valueType = ValueFlow::Value::ValueType::SYMBOLIC;
+    value.tokvalue = tok;
 }
 
-struct Lambda {
-    explicit Lambda(const Token * tok)
-        : capture(nullptr), arguments(nullptr), returnTok(nullptr), bodyTok(nullptr) {
-        if (!Token::simpleMatch(tok, "[") || !tok->link())
-            return;
-        capture = tok;
+static ValueFlow::Value makeSymbolic(const Token* tok, MathLib::bigint delta = 0)
+{
+    ValueFlow::Value value;
+    value.setKnown();
+    setSymbolic(value, tok);
+    value.intvalue = delta;
+    return value;
+}
 
-        if (Token::simpleMatch(capture->link(), "] (")) {
-            arguments = capture->link()->next();
-        }
-        const Token * afterArguments = arguments ? arguments->link()->next() : capture->link()->next();
-        if (afterArguments && afterArguments->originalName() == "->") {
-            returnTok = afterArguments->next();
-            bodyTok = Token::findsimplematch(returnTok, "{");
-        } else if (Token::simpleMatch(afterArguments, "{")) {
-            bodyTok = afterArguments;
-        }
-    }
+static std::set<nonneg int> getVarIds(const Token* tok)
+{
+    std::set<nonneg int> result;
+    visitAstNodes(tok, [&](const Token* child) {
+        if (child->varId() > 0)
+            result.insert(child->varId());
+        return ChildrenToVisit::op1_and_op2;
+    });
+    return result;
+}
+
+static void valueFlowSymbolic(const TokenList& tokenlist, const SymbolDatabase& symboldatabase, ErrorLogger& errorLogger, const Settings& settings)
+{
+    for (const Scope* scope : symboldatabase.functionScopes) {
+        for (auto* tok = const_cast<Token*>(scope->bodyStart); tok != scope->bodyEnd; tok = tok->next()) {
+            if (!Token::simpleMatch(tok, "="))
+                continue;
+            if (tok->astParent())
+                continue;
+            if (!tok->astOperand1())
+                continue;
+            if (!tok->astOperand2())
+                continue;
+            if (tok->astOperand1()->hasKnownIntValue())
+                continue;
+            if (tok->astOperand2()->hasKnownIntValue())
+                continue;
+            if (tok->astOperand1()->exprId() == 0)
+                continue;
+            if (tok->astOperand2()->exprId() == 0)
+                continue;
+            if (!isConstExpression(tok->astOperand2(), settings.library))
+                continue;
+            if (tok->astOperand1()->valueType() && tok->astOperand2()->valueType()) {
+                if (isTruncated(
+                        tok->astOperand2()->valueType(), tok->astOperand1()->valueType(), settings))
+                    continue;
+            } else if (isDifferentType(tok->astOperand2(), tok->astOperand1(), settings)) {
+                continue;
+            }
+            const std::set<nonneg int> rhsVarIds = getVarIds(tok->astOperand2());
+            const std::vector<const Variable*> vars = getLHSVariables(tok);
+            if (std::any_of(vars.cbegin(), vars.cend(), [&](const Variable* var) {
+                if (rhsVarIds.count(var->declarationId()) > 0)
+                    return true;
+                if (var->isLocal())
+                    return var->isStatic();
+                return !var->isArgument();
+            }))
+                continue;
 
-    const Token * capture;
-    const Token * arguments;
-    const Token * returnTok;
-    const Token * bodyTok;
+            if (findAstNode(tok, [](const Token* child) {
+                return child->isIncompleteVar();
+            }))
+                continue;
 
-    bool isLambda() const {
-        return capture && bodyTok;
+            Token* start = nextAfterAstRightmostLeaf(tok);
+            const Token* end = ValueFlow::getEndOfExprScope(tok->astOperand1(), scope);
+
+            ValueFlow::Value rhs = makeSymbolic(tok->astOperand2());
+            rhs.errorPath.emplace_back(tok,
+                                       tok->astOperand1()->expressionString() + " is assigned '" +
+                                       tok->astOperand2()->expressionString() + "' here.");
+            valueFlowForward(start, end, tok->astOperand1(), std::move(rhs), tokenlist, errorLogger, settings);
+
+            ValueFlow::Value lhs = makeSymbolic(tok->astOperand1());
+            lhs.errorPath.emplace_back(tok,
+                                       tok->astOperand1()->expressionString() + " is assigned '" +
+                                       tok->astOperand2()->expressionString() + "' here.");
+            valueFlowForward(start, end, tok->astOperand2(), std::move(lhs), tokenlist, errorLogger, settings);
+        }
     }
-};
+}
 
-static bool isDecayedPointer(const Token *tok, const Settings *settings)
+static const Token* isStrlenOf(const Token* tok, const Token* expr, int depth = 10)
 {
+    if (depth < 0)
+        return nullptr;
     if (!tok)
-        return false;
-    if (astIsPointer(tok->astParent()) && !Token::simpleMatch(tok->astParent(), "return"))
-        return true;
-    if (Token::Match(tok->astParent(), "%cop%"))
-        return true;
-    if (!Token::simpleMatch(tok->astParent(), "return"))
-        return false;
-    if (!tok->scope())
-        return false;
-    if (!tok->scope()->function)
-        return false;
-    if (!tok->scope()->function->retDef)
-        return false;
-    // TODO: Add valuetypes to return types of functions
-    ValueType vt = ValueType::parseDecl(tok->scope()->function->retDef, settings);
-    if (vt.pointer > 0)
-        return true;
-    return false;
+        return nullptr;
+    if (!expr)
+        return nullptr;
+    if (expr->exprId() == 0)
+        return nullptr;
+    if (Token::simpleMatch(tok->previous(), "strlen (")) {
+        if (tok->astOperand2()->exprId() == expr->exprId())
+            return tok;
+    } else {
+        for (const ValueFlow::Value& v : tok->values()) {
+            if (!v.isSymbolicValue())
+                continue;
+            if (!v.isKnown())
+                continue;
+            if (v.intvalue != 0)
+                continue;
+            if (const Token* next = isStrlenOf(v.tokvalue, expr, depth - 1))
+                return next;
+        }
+    }
+    return nullptr;
 }
 
-static void valueFlowLifetime(TokenList *tokenlist, SymbolDatabase*, ErrorLogger *errorLogger, const Settings *settings)
+static void valueFlowSymbolicOperators(const SymbolDatabase& symboldatabase, const Settings& settings)
 {
-    for (Token *tok = tokenlist->front(); tok; tok = tok->next()) {
-        if (!tok->scope())
-            continue;
-        if (tok->scope()->type == Scope::eGlobal)
-            continue;
-        Lambda lam(tok);
-        // Lamdas
-        if (lam.isLambda()) {
-            const Scope * bodyScope = lam.bodyTok->scope();
-
-            std::set<const Scope *> scopes;
-
-            auto isCapturingVariable = [&](const Token *varTok) {
-                const Variable *var = varTok->variable();
-                if (!var)
-                    return false;
-                const Scope *scope = var->scope();
-                if (!scope)
-                    return false;
-                if (scopes.count(scope) > 0)
-                    return false;
-                if (scope->isNestedIn(bodyScope))
-                    return false;
-                scopes.insert(scope);
-                return true;
-            };
+    for (const Scope* scope : symboldatabase.functionScopes) {
+        for (auto* tok = const_cast<Token*>(scope->bodyStart); tok != scope->bodyEnd; tok = tok->next()) {
+            if (tok->hasKnownIntValue())
+                continue;
 
-            // TODO: Handle explicit capture
-            bool captureByRef = Token::Match(lam.capture, "[ & ]");
-            bool captureByValue = Token::Match(lam.capture, "[ = ]");
+            if (Token::Match(tok, "abs|labs|llabs|fabs|fabsf|fabsl (")) {
+                const Token* arg = tok->next()->astOperand2();
+                if (!arg)
+                    continue;
+                if (arg->exprId() == 0)
+                    continue;
+                ValueFlow::Value c = inferCondition(">=", arg, 0);
+                if (!c.isKnown())
+                    continue;
 
-            for (const Token * tok2 = lam.bodyTok; tok2 != lam.bodyTok->link(); tok2 = tok2->next()) {
-                ErrorPath errorPath;
-                if (captureByRef) {
-                    LifetimeStore{tok2, "Lambda captures variable by reference here.", ValueFlow::Value::LifetimeKind::Lambda} .byRef(
-                        tok, tokenlist, errorLogger, settings, isCapturingVariable);
-                } else if (captureByValue) {
-                    LifetimeStore{tok2, "Lambda captures variable by value here.", ValueFlow::Value::LifetimeKind::Lambda} .byVal(
-                        tok, tokenlist, errorLogger, settings, isCapturingVariable);
+                ValueFlow::Value v = makeSymbolic(arg);
+                v.errorPath = std::move(c.errorPath);
+                v.errorPath.emplace_back(tok, "Passed to " + tok->str());
+                if (c.intvalue == 0)
+                    v.setImpossible();
+                else
+                    v.setKnown();
+                setTokenValue(tok->next(), std::move(v), settings);
+            } else if (Token::Match(tok, "*|/|<<|>>|^|+|-|%or%")) {
+                if (!tok->astOperand1())
+                    continue;
+                if (!tok->astOperand2())
+                    continue;
+                if (!astIsIntegral(tok->astOperand1(), false) && !astIsIntegral(tok->astOperand2(), false))
+                    continue;
+                const ValueFlow::Value* constant = nullptr;
+                const Token* vartok = nullptr;
+                if (const ValueFlow::Value* v = tok->astOperand1()->getKnownValue(ValueFlow::Value::ValueType::INT)) {
+                    constant = v;
+                    vartok = tok->astOperand2();
                 }
-            }
-        }
-        // address of
-        else if (tok->isUnaryOp("&")) {
-            for (const LifetimeToken& lt : getLifetimeTokens(tok->astOperand1())) {
-                if (!settings->inconclusive && lt.inconclusive)
+                if (const ValueFlow::Value* v = tok->astOperand2()->getKnownValue(ValueFlow::Value::ValueType::INT)) {
+                    constant = v;
+                    vartok = tok->astOperand1();
+                }
+                if (!constant)
                     continue;
-                ErrorPath errorPath = lt.errorPath;
-                errorPath.emplace_back(tok, "Address of variable taken here.");
-
-                ValueFlow::Value value;
-                value.valueType = ValueFlow::Value::ValueType::LIFETIME;
-                value.lifetimeScope = ValueFlow::Value::LifetimeScope::Local;
-                value.tokvalue = lt.token;
-                value.errorPath = std::move(errorPath);
-                if (astIsPointer(lt.token) || !Token::Match(lt.token->astParent(), ".|["))
-                    value.lifetimeKind = ValueFlow::Value::LifetimeKind::Address;
-                value.setInconclusive(lt.inconclusive);
-                setTokenValue(tok, value, tokenlist->getSettings());
-
-                valueFlowForwardLifetime(tok, tokenlist, errorLogger, settings);
+                if (!vartok)
+                    continue;
+                if (vartok->exprId() == 0)
+                    continue;
+                if (Token::Match(tok, "<<|>>|/|-") && !astIsLHS(vartok))
+                    continue;
+                if (Token::Match(tok, "<<|>>|^|+|-|%or%") && constant->intvalue != 0)
+                    continue;
+                if (Token::Match(tok, "*|/") && constant->intvalue != 1)
+                    continue;
+                std::vector<ValueFlow::Value> values = {makeSymbolic(vartok)};
+                std::unordered_set<nonneg int> ids = {vartok->exprId()};
+                std::copy_if(vartok->values().cbegin(),
+                             vartok->values().cend(),
+                             std::back_inserter(values),
+                             [&](const ValueFlow::Value& v) {
+                    if (!v.isSymbolicValue())
+                        return false;
+                    if (!v.tokvalue)
+                        return false;
+                    return ids.insert(v.tokvalue->exprId()).second;
+                });
+                for (ValueFlow::Value& v : values)
+                    setTokenValue(tok, std::move(v), settings);
+            } else if (Token::simpleMatch(tok, "[")) {
+                const Token* arrayTok = tok->astOperand1();
+                const Token* indexTok = tok->astOperand2();
+                if (!arrayTok)
+                    continue;
+                if (!indexTok)
+                    continue;
+                for (const ValueFlow::Value& value : indexTok->values()) {
+                    if (!value.isSymbolicValue())
+                        continue;
+                    if (value.intvalue != 0)
+                        continue;
+                    const Token* strlenTok = isStrlenOf(value.tokvalue, arrayTok);
+                    if (!strlenTok)
+                        continue;
+                    ValueFlow::Value v = value;
+                    v.bound = ValueFlow::Value::Bound::Point;
+                    v.valueType = ValueFlow::Value::ValueType::INT;
+                    v.errorPath.emplace_back(strlenTok, "Return index of first '\\0' character in string");
+                    setTokenValue(tok, std::move(v), settings);
+                }
             }
         }
-        // container lifetimes
-        else if (astIsContainer(tok)) {
-            Token * parent = astParentSkipParens(tok);
-            if (!Token::Match(parent, ". %name% ("))
-                continue;
+    }
+}
 
-            LifetimeStore ls;
+struct SymbolicInferModel : InferModel {
+    const Token* expr;
+    explicit SymbolicInferModel(const Token* tok) : expr(tok) {
+        assert(expr->exprId() != 0);
+    }
+    bool match(const ValueFlow::Value& value) const override
+    {
+        return value.isSymbolicValue() && value.tokvalue && value.tokvalue->exprId() == expr->exprId();
+    }
+    ValueFlow::Value yield(MathLib::bigint value) const override
+    {
+        ValueFlow::Value result(value);
+        result.valueType = ValueFlow::Value::ValueType::SYMBOLIC;
+        result.tokvalue = expr;
+        result.setKnown();
+        return result;
+    }
+};
 
-            if (astIsIterator(parent->tokAt(2)))
-                ls = LifetimeStore{tok, "Iterator to container is created here.", ValueFlow::Value::LifetimeKind::Iterator};
-            else if (astIsPointer(parent->tokAt(2)) || Token::Match(parent->next(), "data|c_str"))
-                ls = LifetimeStore{tok, "Pointer to container is created here.", ValueFlow::Value::LifetimeKind::Object};
-            else
+static void valueFlowSymbolicInfer(const SymbolDatabase& symboldatabase, const Settings& settings)
+{
+    for (const Scope* scope : symboldatabase.functionScopes) {
+        for (auto* tok = const_cast<Token*>(scope->bodyStart); tok != scope->bodyEnd; tok = tok->next()) {
+            if (!Token::Match(tok, "-|%comp%"))
                 continue;
-
-            // Dereferencing
-            if (tok->isUnaryOp("*") || parent->originalName() == "->")
-                ls.byDerefCopy(parent->tokAt(2), tokenlist, errorLogger, settings);
-            else
-                ls.byRef(parent->tokAt(2), tokenlist, errorLogger, settings);
-
-        }
-        // Check constructors
-        else if (Token::Match(tok, "=|return|%type%|%var% {")) {
-            valueFlowLifetimeConstructor(tok->next(), tokenlist, errorLogger, settings);
-        }
-        // Check function calls
-        else if (Token::Match(tok, "%name% (")) {
-            valueFlowLifetimeFunction(tok, tokenlist, errorLogger, settings);
-        }
-        // Check variables
-        else if (tok->variable()) {
-            ErrorPath errorPath;
-            const Variable * var = getLifetimeVariable(tok, errorPath);
-            if (!var)
+            if (tok->hasKnownIntValue())
                 continue;
-            if (var->nameToken() == tok)
+            if (!tok->astOperand1())
+                continue;
+            if (!tok->astOperand2())
+                continue;
+            if (tok->astOperand1()->exprId() == 0)
+                continue;
+            if (tok->astOperand2()->exprId() == 0)
+                continue;
+            if (tok->astOperand1()->hasKnownIntValue())
+                continue;
+            if (tok->astOperand2()->hasKnownIntValue())
+                continue;
+            if (astIsFloat(tok->astOperand1(), false))
+                continue;
+            if (astIsFloat(tok->astOperand2(), false))
                 continue;
-            if (var->isArray() && !var->isStlType() && !var->isArgument() && isDecayedPointer(tok, settings)) {
-                errorPath.emplace_back(tok, "Array decayed to pointer here.");
-
-                ValueFlow::Value value;
-                value.valueType = ValueFlow::Value::ValueType::LIFETIME;
-                value.lifetimeScope = ValueFlow::Value::LifetimeScope::Local;
-                value.tokvalue = var->nameToken();
-                value.errorPath = errorPath;
-                setTokenValue(tok, value, tokenlist->getSettings());
 
-                valueFlowForwardLifetime(tok, tokenlist, errorLogger, settings);
+            std::vector<ValueFlow::Value> values;
+            {
+                SymbolicInferModel leftModel{tok->astOperand1()};
+                values = infer(leftModel, tok->str(), 0, tok->astOperand2()->values());
+            }
+            if (values.empty()) {
+                SymbolicInferModel rightModel{tok->astOperand2()};
+                values = infer(rightModel, tok->str(), tok->astOperand1()->values(), 0);
+            }
+            for (ValueFlow::Value& value : values) {
+                setTokenValue(tok, std::move(value), settings);
             }
         }
     }
 }
 
-static bool isStdMoveOrStdForwarded(Token * tok, ValueFlow::Value::MoveKind * moveKind, Token ** varTok = nullptr)
-{
-    if (tok->str() != "std")
-        return false;
-    ValueFlow::Value::MoveKind kind = ValueFlow::Value::MoveKind::NonMovedVariable;
-    Token * variableToken = nullptr;
-    if (Token::Match(tok, "std :: move ( %var% )")) {
-        variableToken = tok->tokAt(4);
-        kind = ValueFlow::Value::MoveKind::MovedVariable;
-    } else if (Token::simpleMatch(tok, "std :: forward <")) {
-        const Token * const leftAngle = tok->tokAt(3);
-        Token * rightAngle = leftAngle->link();
-        if (Token::Match(rightAngle, "> ( %var% )")) {
-            variableToken = rightAngle->tokAt(2);
-            kind = ValueFlow::Value::MoveKind::ForwardedVariable;
+/**
+ * @throws InternalError thrown if start token precedes end token
+ */
+template<class ContainerOfValue>
+static void valueFlowForwardConst(Token* start,
+                                  const Token* end,
+                                  const Variable* var,
+                                  const ContainerOfValue& values,
+                                  const Settings& settings,
+                                  int /*unused*/ = 0)
+{
+    if (!precedes(start, end))
+        throw InternalError(var->nameToken(), "valueFlowForwardConst: start token does not precede the end token.");
+    for (Token* tok = start; tok != end; tok = tok->next()) {
+        if (tok->varId() == var->declarationId()) {
+            for (const ValueFlow::Value& value : values)
+                setTokenValue(tok, value, settings);
+        } else {
+            [&] {
+                // Follow references
+                const auto& refs = tok->refs();
+                auto it = std::find_if(refs.cbegin(), refs.cend(), [&](const ReferenceToken& ref) {
+                    return ref.token->varId() == var->declarationId();
+                });
+                if (it != refs.end()) {
+                    for (ValueFlow::Value value : values) {
+                        if (refs.size() > 1)
+                            value.setInconclusive();
+                        value.errorPath.insert(value.errorPath.end(), it->errors.cbegin(), it->errors.cend());
+                        setTokenValue(tok, std::move(value), settings);
+                    }
+                    return;
+                }
+                // Follow symbolic values
+                for (const ValueFlow::Value& v : tok->values()) {
+                    if (!v.isSymbolicValue())
+                        continue;
+                    if (!v.tokvalue)
+                        continue;
+                    if (v.tokvalue->varId() != var->declarationId())
+                        continue;
+                    for (ValueFlow::Value value : values) {
+                        if (!v.isKnown() && value.isImpossible())
+                            continue;
+                        if (v.intvalue != 0) {
+                            if (!value.isIntValue())
+                                continue;
+                            value.intvalue += v.intvalue;
+                        }
+                        if (!value.isImpossible())
+                            value.valueKind = v.valueKind;
+                        value.bound = v.bound;
+                        value.errorPath.insert(value.errorPath.end(), v.errorPath.cbegin(), v.errorPath.cend());
+                        setTokenValue(tok, std::move(value), settings);
+                    }
+                }
+            }();
         }
     }
-    if (!variableToken)
-        return false;
-    if (variableToken->strAt(2) == ".") // Only partially moved
-        return false;
-
-    if (moveKind != nullptr)
-        *moveKind = kind;
-    if (varTok != nullptr)
-        *varTok = variableToken;
-    return true;
 }
 
-static bool isOpenParenthesisMemberFunctionCallOfVarId(const Token * openParenthesisToken, nonneg int varId)
+static void valueFlowForwardConst(Token* start,
+                                  const Token* end,
+                                  const Variable* var,
+                                  const std::initializer_list<ValueFlow::Value>& values,
+                                  const Settings& settings)
 {
-    const Token * varTok = openParenthesisToken->tokAt(-3);
-    return Token::Match(varTok, "%varid% . %name% (", varId) &&
-           varTok->next()->originalName() == emptyString;
+    valueFlowForwardConst(start, end, var, values, settings, 0);
 }
 
-static const Token * findOpenParentesisOfMove(const Token * moveVarTok)
+static ValueFlow::Value::Bound findVarBound(const Variable* var,
+                                            const Token* start,
+                                            const Token* end,
+                                            const Settings& settings)
 {
-    const Token * tok = moveVarTok;
-    while (tok && tok->str() != "(")
-        tok = tok->previous();
-    return tok;
+    ValueFlow::Value::Bound result = ValueFlow::Value::Bound::Point;
+    const Token* next = start;
+    while ((next = findExpressionChangedSkipDeadCode(
+                var->nameToken(), next->next(), end, settings, &evaluateKnownValues))) {
+        ValueFlow::Value::Bound b = ValueFlow::Value::Bound::Point;
+        if (next->varId() != var->declarationId())
+            return ValueFlow::Value::Bound::Point;
+        if (Token::simpleMatch(next->astParent(), "++"))
+            b = ValueFlow::Value::Bound::Lower;
+        else if (Token::simpleMatch(next->astParent(), "--"))
+            b = ValueFlow::Value::Bound::Upper;
+        else
+            return ValueFlow::Value::Bound::Point;
+        if (result == ValueFlow::Value::Bound::Point)
+            result = b;
+        else if (result != b)
+            return ValueFlow::Value::Bound::Point;
+    }
+    return result;
 }
 
-static const Token * findEndOfFunctionCallForParameter(const Token * parameterToken)
+static bool isInitialVarAssign(const Token* tok)
 {
-    if (!parameterToken)
-        return nullptr;
-    const Token * parent = parameterToken->astParent();
-    while (parent && !parent->isOp() && parent->str() != "(")
-        parent = parent->astParent();
-    if (!parent)
-        return nullptr;
-    return nextAfterAstRightmostLeaf(parent);
+    if (!tok)
+        return false;
+    if (!tok->variable())
+        return false;
+    if (tok->variable()->nameToken() == tok)
+        return true;
+    const Token* prev = tok->tokAt(2);
+    if (!Token::Match(prev, "%var% ; %var%"))
+        return false;
+    return tok->varId() == prev->varId() && tok->variable()->nameToken() == prev;
 }
 
-static void valueFlowAfterMove(TokenList *tokenlist, SymbolDatabase* symboldatabase, ErrorLogger *errorLogger, const Settings *settings)
+static void valueFlowForwardAssign(Token* const tok,
+                                   const Token* expr,
+                                   std::vector<const Variable*> vars,
+                                   std::list<ValueFlow::Value> values,
+                                   const bool init,
+                                   const TokenList& tokenlist,
+                                   ErrorLogger& errorLogger,
+                                   const Settings& settings)
 {
-    if (!tokenlist->isCPP() || settings->standards.cpp < Standards::CPP11)
+    if (Token::simpleMatch(tok->astParent(), "return"))
         return;
-    for (const Scope * scope : symboldatabase->functionScopes) {
-        if (!scope)
-            continue;
-        const Token * start = scope->bodyStart;
-        if (scope->function) {
-            const Token * memberInitializationTok = scope->function->constructorMemberInitialization();
-            if (memberInitializationTok)
-                start = memberInitializationTok;
-        }
-
-        for (Token* tok = const_cast<Token*>(start); tok != scope->bodyEnd; tok = tok->next()) {
-            Token * varTok;
-            if (Token::Match(tok, "%var% . reset|clear (") && tok->next()->originalName() == emptyString) {
-                varTok = tok;
-                ValueFlow::Value value;
-                value.valueType = ValueFlow::Value::ValueType::MOVED;
-                value.moveKind = ValueFlow::Value::MoveKind::NonMovedVariable;
-                value.errorPath.emplace_back(tok, "Calling " + tok->next()->expressionString() + " makes " + tok->str() + " 'non-moved'");
-                value.setKnown();
-                std::list<ValueFlow::Value> values;
-                values.push_back(value);
-
-                const Variable *var = varTok->variable();
-                if (!var || (!var->isLocal() && !var->isArgument()))
-                    continue;
-                const int varId = varTok->varId();
-                const Token * const endOfVarScope = var->typeStartToken()->scope()->bodyEnd;
-                setTokenValue(varTok, value, settings);
-                valueFlowForwardVariable(
-                    varTok->next(), endOfVarScope, var, varId, values, false, false, tokenlist, errorLogger, settings);
-                continue;
-            }
-            ValueFlow::Value::MoveKind moveKind;
-            if (!isStdMoveOrStdForwarded(tok, &moveKind, &varTok))
-                continue;
-            const int varId = varTok->varId();
-            // x is not MOVED after assignment if code is:  x = ... std::move(x) .. ;
-            const Token *parent = tok->astParent();
-            while (parent && parent->str() != "=" && parent->str() != "return" &&
-                   !(parent->str() == "(" && isOpenParenthesisMemberFunctionCallOfVarId(parent, varId)))
-                parent = parent->astParent();
-            if (parent &&
-                (parent->str() == "return" || // MOVED in return statement
-                 parent->str() == "(")) // MOVED in self assignment, isOpenParenthesisMemberFunctionCallOfVarId == true
-                continue;
-            if (parent && parent->astOperand1() && parent->astOperand1()->varId() == varId)
-                continue;
-            const Variable *var = varTok->variable();
-            if (!var)
-                continue;
-            const Token * const endOfVarScope = var->typeStartToken()->scope()->bodyEnd;
-
-            ValueFlow::Value value;
-            value.valueType = ValueFlow::Value::ValueType::MOVED;
-            value.moveKind = moveKind;
-            if (moveKind == ValueFlow::Value::MoveKind::MovedVariable)
-                value.errorPath.emplace_back(tok, "Calling std::move(" + varTok->str() + ")");
-            else // if (moveKind == ValueFlow::Value::ForwardedVariable)
-                value.errorPath.emplace_back(tok, "Calling std::forward(" + varTok->str() + ")");
-            value.setKnown();
-            std::list<ValueFlow::Value> values;
-            values.push_back(value);
-            const Token * openParentesisOfMove = findOpenParentesisOfMove(varTok);
-            const Token * endOfFunctionCall = findEndOfFunctionCallForParameter(openParentesisOfMove);
-            if (endOfFunctionCall)
-                valueFlowForwardVariable(const_cast<Token*>(endOfFunctionCall),
-                                         endOfVarScope,
-                                         var,
-                                         varId,
-                                         values,
-                                         false,
-                                         false,
-                                         tokenlist,
-                                         errorLogger,
-                                         settings);
-        }
-    }
-}
-
-static void valueFlowForwardAssign(Token * const               tok,
-                                   const Variable * const      var,
-                                   std::list<ValueFlow::Value> values,
-                                   const bool                  constValue,
-                                   const bool                  init,
-                                   TokenList * const           tokenlist,
-                                   ErrorLogger * const         errorLogger,
-                                   const Settings * const      settings)
-{
-    const Token * const endOfVarScope = var->typeStartToken()->scope()->bodyEnd;
-    if (std::any_of(values.begin(), values.end(), std::mem_fn(&ValueFlow::Value::isLifetimeValue))) {
+    const Token* endOfVarScope = ValueFlow::getEndOfExprScope(expr);
+    if (std::any_of(values.cbegin(), values.cend(), std::mem_fn(&ValueFlow::Value::isLifetimeValue))) {
         valueFlowForwardLifetime(tok, tokenlist, errorLogger, settings);
         values.remove_if(std::mem_fn(&ValueFlow::Value::isLifetimeValue));
     }
-    if (!var->isPointer() && !var->isSmartPointer())
+    if (std::all_of(
+            vars.cbegin(), vars.cend(), [&](const Variable* var) {
+        return !var->isPointer() && !var->isSmartPointer();
+    }))
         values.remove_if(std::mem_fn(&ValueFlow::Value::isTokValue));
     if (tok->astParent()) {
-        for (std::list<ValueFlow::Value>::iterator it = values.begin(); it != values.end(); ++it) {
-            const std::string info = "Assignment '" + tok->astParent()->expressionString() + "', assigned value is " + it->infoString();
-            it->errorPath.emplace_back(tok, info);
+        for (ValueFlow::Value& value : values) {
+            std::string valueKind;
+            if (value.valueKind == ValueFlow::Value::ValueKind::Impossible) {
+                if (value.bound == ValueFlow::Value::Bound::Point)
+                    valueKind = "never ";
+                else if (value.bound == ValueFlow::Value::Bound::Lower)
+                    valueKind = "less than ";
+                else if (value.bound == ValueFlow::Value::Bound::Upper)
+                    valueKind = "greater than ";
+            }
+            std::string info = "Assignment '" + tok->astParent()->expressionString() + "', assigned value is " + valueKind + value.infoString();
+            value.errorPath.emplace_back(tok, std::move(info));
         }
     }
 
-    if (tokenlist->isCPP() && Token::Match(var->typeStartToken(), "bool|_Bool")) {
-        std::list<ValueFlow::Value>::iterator it;
-        for (it = values.begin(); it != values.end(); ++it) {
-            if (it->isIntValue())
-                it->intvalue = (it->intvalue != 0);
-            if (it->isTokValue())
-                it ->intvalue = (it->tokvalue != nullptr);
+    if (tokenlist.isCPP() && vars.size() == 1 && Token::Match(vars.front()->typeStartToken(), "bool|_Bool")) {
+        for (ValueFlow::Value& value : values) {
+            if (value.isImpossible())
+                continue;
+            if (value.isIntValue())
+                value.intvalue = (value.intvalue != 0);
+            if (value.isTokValue())
+                value.intvalue = (value.tokvalue != nullptr);
         }
     }
 
     // Static variable initialisation?
-    if (var->isStatic() && init)
+    if (vars.size() == 1 && vars.front()->isStatic() && !vars.front()->isConst() && init)
+        lowerToPossible(values);
+
+    // is volatile
+    if (std::any_of(vars.cbegin(), vars.cend(), [&](const Variable* var) {
+        return var->isVolatile();
+    }))
         lowerToPossible(values);
 
     // Skip RHS
-    const Token * nextExpression = tok->astParent() ? nextAfterAstRightmostLeaf(tok->astParent()) : tok->next();
-
-    if (std::any_of(values.begin(), values.end(), std::mem_fn(&ValueFlow::Value::isTokValue))) {
-        std::list<ValueFlow::Value> tokvalues;
-        std::copy_if(values.begin(),
-                     values.end(),
-                     std::back_inserter(tokvalues),
-                     std::mem_fn(&ValueFlow::Value::isTokValue));
-        valueFlowForwardVariable(const_cast<Token*>(nextExpression),
-                                 endOfVarScope,
-                                 var,
-                                 var->declarationId(),
-                                 tokvalues,
-                                 constValue,
-                                 false,
-                                 tokenlist,
-                                 errorLogger,
-                                 settings);
-        values.remove_if(std::mem_fn(&ValueFlow::Value::isTokValue));
-    }
-    for (ValueFlow::Value& value:values)
+    Token* nextExpression = tok->astParent() ? nextAfterAstRightmostLeaf(tok->astParent()) : tok->next();
+    if (!nextExpression)
+        return;
+
+    for (ValueFlow::Value& value : values) {
+        if (value.isSymbolicValue())
+            continue;
+        if (value.isTokValue())
+            continue;
         value.tokvalue = tok;
-    valueFlowForwardVariable(const_cast<Token*>(nextExpression),
-                             endOfVarScope,
-                             var,
-                             var->declarationId(),
-                             values,
-                             constValue,
-                             false,
-                             tokenlist,
-                             errorLogger,
-                             settings);
+    }
+    // Const variable
+    if (expr->variable() && expr->variable()->isConst() && !expr->variable()->isReference()) {
+        auto it = std::remove_if(values.begin(), values.end(), [](const ValueFlow::Value& value) {
+            if (!value.isKnown())
+                return false;
+            if (value.isIntValue())
+                return true;
+            if (value.isFloatValue())
+                return true;
+            if (value.isContainerSizeValue())
+                return true;
+            if (value.isIteratorValue())
+                return true;
+            return false;
+        });
+        std::list<ValueFlow::Value> constValues;
+        constValues.splice(constValues.end(), values, it, values.end());
+        valueFlowForwardConst(nextExpression, endOfVarScope, expr->variable(), constValues, settings);
+    }
+    if (isInitialVarAssign(expr)) {
+        // Check if variable is only incremented or decremented
+        ValueFlow::Value::Bound b = findVarBound(expr->variable(), nextExpression, endOfVarScope, settings);
+        if (b != ValueFlow::Value::Bound::Point) {
+            auto knownValueIt = std::find_if(values.begin(), values.end(), [](const ValueFlow::Value& value) {
+                if (!value.isKnown())
+                    return false;
+                return value.isIntValue();
+            });
+            if (knownValueIt != values.end()) {
+                ValueFlow::Value value = *knownValueIt;
+                value.bound = b;
+                value.invertRange();
+                value.setImpossible();
+                valueFlowForwardConst(nextExpression, endOfVarScope, expr->variable(), {std::move(value)}, settings);
+            }
+        }
+    }
+    valueFlowForward(nextExpression, endOfVarScope, expr, std::move(values), tokenlist, errorLogger, settings);
 }
 
-static std::list<ValueFlow::Value> truncateValues(std::list<ValueFlow::Value> values, const ValueType *valueType, const Settings *settings)
+static void valueFlowForwardAssign(Token* const tok,
+                                   const Variable* const var,
+                                   const std::list<ValueFlow::Value>& values,
+                                   const bool /*unused*/,
+                                   const bool init,
+                                   const TokenList& tokenlist,
+                                   ErrorLogger& errorLogger,
+                                   const Settings& settings)
 {
-    if (!valueType || !valueType->isIntegral())
+    valueFlowForwardAssign(tok, var->nameToken(), {var}, values, init, tokenlist, errorLogger, settings);
+}
+
+static std::list<ValueFlow::Value> truncateValues(std::list<ValueFlow::Value> values,
+                                                  const ValueType* dst,
+                                                  const ValueType* src,
+                                                  const Settings& settings)
+{
+    if (!dst || !dst->isIntegral())
         return values;
 
-    const size_t sz = getSizeOf(*valueType, settings);
+    const size_t sz = dst->getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer);
+
+    if (src) {
+        const size_t osz = src->getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer);
+        if (osz >= sz && dst->sign == ValueType::Sign::SIGNED && src->sign == ValueType::Sign::UNSIGNED) {
+            values.remove_if([&](const ValueFlow::Value& value) {
+                if (!value.isIntValue())
+                    return false;
+                if (!value.isImpossible())
+                    return false;
+                if (value.bound != ValueFlow::Value::Bound::Upper)
+                    return false;
+                if (osz == sz && value.intvalue < 0)
+                    return true;
+                if (osz > sz)
+                    return true;
+                return false;
+            });
+        }
+    }
 
     for (ValueFlow::Value &value : values) {
+        // Don't truncate impossible values since those can be outside of the valid range
+        if (value.isImpossible())
+            continue;
         if (value.isFloatValue()) {
-            value.intvalue = value.floatValue;
-            value.valueType = ValueFlow::Value::INT;
+            value.intvalue = static_cast<MathLib::bigint>(value.floatValue);
+            value.valueType = ValueFlow::Value::ValueType::INT;
         }
 
-        if (value.isIntValue() && sz > 0 && sz < 8) {
-            const MathLib::biguint unsignedMaxValue = (1ULL << (sz * 8)) - 1ULL;
-            const MathLib::biguint signBit = 1ULL << (sz * 8 - 1);
-            value.intvalue &= unsignedMaxValue;
-            if (valueType->sign == ValueType::Sign::SIGNED && (value.intvalue & signBit))
-                value.intvalue |= ~unsignedMaxValue;
+        if (value.isIntValue() && sz > 0 && sz < sizeof(MathLib::biguint))
+            value.intvalue = ValueFlow::truncateIntValue(value.intvalue, sz, dst->sign);
+    }
+    return values;
+}
+
+static bool isVariableInit(const Token *tok)
+{
+    if (!tok)
+        return false;
+    if (!Token::Match(tok->previous(), "%var% (|{"))
+        return false;
+    if (!tok->isBinaryOp() && !(tok->astOperand1() && tok->link() == tok->next()))
+        return false;
+    if (Token::simpleMatch(tok->astOperand2(), ","))
+        return false;
+    const Variable* var = tok->astOperand1()->variable();
+    if (!var)
+        return false;
+    if (var->nameToken() != tok->astOperand1())
+        return false;
+    const ValueType* vt = var->valueType();
+    if (!vt)
+        return false;
+    if (vt->type < ValueType::Type::VOID)
+        return false;
+    return true;
+}
+
+// Return true if two associative containers intersect
+template<class C1, class C2>
+static bool intersects(const C1& c1, const C2& c2)
+{
+    if (c1.size() > c2.size())
+        return intersects(c2, c1);
+    // NOLINTNEXTLINE(readability-use-anyofallof) - TODO: fix if possible / also Cppcheck false negative
+    for (auto&& x : c1) {
+        if (c2.find(x) != c2.end())
+            return true;
+    }
+    return false;
+}
+
+static void valueFlowAfterAssign(const TokenList &tokenlist,
+                                 const SymbolDatabase& symboldatabase,
+                                 ErrorLogger &errorLogger,
+                                 const Settings &settings,
+                                 const std::set<const Scope*>& skippedFunctions)
+{
+    for (const Scope * scope : symboldatabase.functionScopes) {
+        if (skippedFunctions.count(scope))
+            continue;
+        std::unordered_map<nonneg int, std::unordered_set<nonneg int>> backAssigns;
+        for (auto* tok = const_cast<Token*>(scope->bodyStart); tok != scope->bodyEnd; tok = tok->next()) {
+            if (!tok->scope()->isExecutable()) {
+                tok = const_cast<Token*>(tok->scope()->bodyEnd); // skip local type definition
+                continue;
+            }
+
+            // Assignment
+            bool isInit = false;
+            if (tok->str() != "=" && !(isInit = isVariableInit(tok)))
+                continue;
+
+            if (tok->astParent() && !((tok->astParent()->str() == ";" && astIsLHS(tok)) || tok->astParent()->str() == "*"))
+                continue;
+
+            // Lhs should be a variable
+            if (!tok->astOperand1() || !tok->astOperand1()->exprId())
+                continue;
+            std::vector<const Variable*> vars = getLHSVariables(tok);
+
+            // Rhs values..
+            Token* rhs = tok->astOperand2();
+            if (!rhs && isInit)
+                rhs = tok;
+            if (!rhs || rhs->values().empty())
+                continue;
+
+            std::list<ValueFlow::Value> values = truncateValues(
+                rhs->values(), tok->astOperand1()->valueType(), rhs->valueType(), settings);
+            // Remove known values
+            std::set<ValueFlow::Value::ValueType> types;
+            if (tok->astOperand1()->hasKnownValue()) {
+                for (const ValueFlow::Value& value:tok->astOperand1()->values()) {
+                    if (value.isKnown() && !value.isSymbolicValue())
+                        types.insert(value.valueType);
+                }
+            }
+            values.remove_if([&](const ValueFlow::Value& value) {
+                return types.count(value.valueType) > 0;
+            });
+            // Remove container size if its not a container
+            if (!astIsContainer(tok->astOperand2()))
+                values.remove_if([&](const ValueFlow::Value& value) {
+                    return value.valueType == ValueFlow::Value::ValueType::CONTAINER_SIZE;
+                });
+            // Remove symbolic values that are the same as the LHS
+            values.remove_if([&](const ValueFlow::Value& value) {
+                if (value.isSymbolicValue() && value.tokvalue)
+                    return value.tokvalue->exprId() == tok->astOperand1()->exprId();
+                return false;
+            });
+            // Find references to LHS in RHS
+            auto isIncremental = [&](const Token* tok2) -> bool {
+                return findAstNode(tok2,
+                                   [&](const Token* child) {
+                    return child->exprId() == tok->astOperand1()->exprId();
+                });
+            };
+            // Check symbolic values as well
+            const bool incremental = isIncremental(tok->astOperand2()) ||
+                                     std::any_of(values.cbegin(), values.cend(), [&](const ValueFlow::Value& value) {
+                if (!value.isSymbolicValue())
+                    return false;
+                return isIncremental(value.tokvalue);
+            });
+            // Remove values from the same assignment if it is incremental
+            if (incremental) {
+                values.remove_if([&](const ValueFlow::Value& value) {
+                    if (value.tokvalue)
+                        return value.tokvalue == tok->astOperand2();
+                    return false;
+                });
+            }
+            // If assignment copy by value, remove Uninit values..
+            if ((tok->astOperand1()->valueType() && tok->astOperand1()->valueType()->pointer == 0) ||
+                (tok->astOperand1()->variable() && tok->astOperand1()->variable()->isReference() && tok->astOperand1()->variable()->nameToken() == tok->astOperand1()))
+                values.remove_if([&](const ValueFlow::Value& value) {
+                    return value.isUninitValue();
+                });
+            if (values.empty())
+                continue;
+            const bool init = vars.size() == 1 && (vars.front()->nameToken() == tok->astOperand1() || tok->isSplittedVarDeclEq());
+            valueFlowForwardAssign(
+                rhs, tok->astOperand1(), std::move(vars), values, init, tokenlist, errorLogger, settings);
+            // Back propagate symbolic values
+            if (tok->astOperand1()->exprId() > 0) {
+                Token* start = nextAfterAstRightmostLeaf(tok);
+                const Token* end = scope->bodyEnd;
+                // Collect symbolic ids
+                std::unordered_set<nonneg int> ids;
+                for (const ValueFlow::Value& value : values) {
+                    if (!value.isSymbolicValue())
+                        continue;
+                    if (!value.tokvalue)
+                        continue;
+                    if (value.tokvalue->exprId() == 0)
+                        continue;
+                    ids.insert(value.tokvalue->exprId());
+                }
+                for (ValueFlow::Value value : values) {
+                    if (!value.isSymbolicValue())
+                        continue;
+                    const Token* expr = value.tokvalue;
+                    value.intvalue = -value.intvalue;
+                    value.tokvalue = tok->astOperand1();
+
+                    // Skip if it intersects with an already assigned symbol
+                    auto& s = backAssigns[value.tokvalue->exprId()];
+                    if (intersects(s, ids))
+                        continue;
+                    s.insert(expr->exprId());
+
+                    value.errorPath.emplace_back(tok,
+                                                 tok->astOperand1()->expressionString() + " is assigned '" +
+                                                 tok->astOperand2()->expressionString() + "' here.");
+                    valueFlowForward(start, end, expr, std::move(value), tokenlist, errorLogger, settings);
+                }
+            }
         }
     }
-    return values;
 }
 
-static bool isLiteralNumber(const Token *tok, bool cpp)
+static std::vector<const Variable*> getVariables(const Token* tok)
 {
-    return tok->isNumber() || tok->str() == "NULL" || (cpp && Token::Match(tok, "false|true|nullptr"));
+    std::vector<const Variable*> result;
+    visitAstNodes(tok, [&](const Token* child) {
+        if (child->variable())
+            result.push_back(child->variable());
+        return ChildrenToVisit::op1_and_op2;
+    });
+    return result;
 }
 
-static void valueFlowAfterAssign(TokenList *tokenlist, SymbolDatabase* symboldatabase, ErrorLogger *errorLogger, const Settings *settings)
+static void valueFlowAfterSwap(const TokenList& tokenlist,
+                               const SymbolDatabase& symboldatabase,
+                               ErrorLogger& errorLogger,
+                               const Settings& settings)
 {
-    for (const Scope * scope : symboldatabase->functionScopes) {
-        std::set<int> aliased;
-        for (Token* tok = const_cast<Token*>(scope->bodyStart); tok != scope->bodyEnd; tok = tok->next()) {
-            // Alias
-            if (tok->isUnaryOp("&")) {
-                aliased.insert(tok->astOperand1()->varId());
+    for (const Scope* scope : symboldatabase.functionScopes) {
+        for (auto* tok = const_cast<Token*>(scope->bodyStart); tok != scope->bodyEnd; tok = tok->next()) {
+            if (!Token::simpleMatch(tok, "swap ("))
                 continue;
-            }
-
-            // Assignment
-            if ((tok->str() != "=") || (tok->astParent()))
-                continue;
-
-            // Lhs should be a variable
-            if (!tok->astOperand1() || !tok->astOperand1()->varId() || tok->astOperand1()->hasKnownValue())
+            if (!Token::simpleMatch(tok->next()->astOperand2(), ","))
                 continue;
-            const int varid = tok->astOperand1()->varId();
-            if (aliased.find(varid) != aliased.end())
+            std::vector<Token*> args = astFlatten(tok->next()->astOperand2(), ",");
+            if (args.size() != 2)
                 continue;
-            const Variable *var = tok->astOperand1()->variable();
-            if (!var || (!var->isLocal() && !var->isGlobal() && !var->isArgument()))
+            if (args[0]->exprId() == 0)
                 continue;
-
-            // Rhs values..
-            if (!tok->astOperand2() || tok->astOperand2()->values().empty())
+            if (args[1]->exprId() == 0)
                 continue;
-
-            std::list<ValueFlow::Value> values = truncateValues(tok->astOperand2()->values(), tok->astOperand1()->valueType(), settings);
-            const bool constValue = isLiteralNumber(tok->astOperand2(), tokenlist->isCPP());
-            const bool init = var->nameToken() == tok->astOperand1();
-            valueFlowForwardAssign(tok->astOperand2(), var, values, constValue, init, tokenlist, errorLogger, settings);
+            for (int i = 0; i < 2; i++) {
+                std::vector<const Variable*> vars = getVariables(args[0]);
+                const std::list<ValueFlow::Value>& values = args[0]->values();
+                valueFlowForwardAssign(args[0], args[1], std::move(vars), values, false, tokenlist, errorLogger, settings);
+                std::swap(args[0], args[1]);
+            }
         }
     }
 }
@@ -4375,7 +4292,7 @@ static bool isBreakScope(const Token* const endToken)
     return Token::findmatch(endToken->link(), "break|goto", endToken);
 }
 
-static ValueFlow::Value asImpossible(ValueFlow::Value v)
+ValueFlow::Value ValueFlow::asImpossible(ValueFlow::Value v)
 {
     v.invertRange();
     v.setImpossible();
@@ -4384,617 +4301,850 @@ static ValueFlow::Value asImpossible(ValueFlow::Value v)
 
 static void insertImpossible(std::list<ValueFlow::Value>& values, const std::list<ValueFlow::Value>& input)
 {
-    std::transform(input.begin(), input.end(), std::back_inserter(values), &asImpossible);
+    std::transform(input.cbegin(), input.cend(), std::back_inserter(values), &ValueFlow::asImpossible);
 }
 
-static std::vector<const Variable*> getExprVariables(const Token* expr,
-        const TokenList* tokenlist,
-        const SymbolDatabase* symboldatabase,
-        const Settings* settings)
+static void insertNegateKnown(std::list<ValueFlow::Value>& values, const std::list<ValueFlow::Value>& input)
 {
-    std::vector<const Variable*> result;
-    FwdAnalysis fwdAnalysis(tokenlist->isCPP(), settings->library);
-    std::set<int> varids = fwdAnalysis.getExprVarIds(expr);
-    std::transform(varids.begin(), varids.end(), std::back_inserter(result), [&](int id) {
-        return symboldatabase->getVariableFromVarId(id);
-    });
-    return result;
+    for (ValueFlow::Value value:input) {
+        if (!value.isIntValue() && !value.isContainerSizeValue())
+            continue;
+        value.intvalue = !value.intvalue;
+        value.setKnown();
+        values.push_back(std::move(value));
+    }
 }
 
-struct ValueFlowConditionHandler {
+struct ConditionHandler {
     struct Condition {
-        const Token *vartok;
+        const Token* vartok{};
         std::list<ValueFlow::Value> true_values;
         std::list<ValueFlow::Value> false_values;
+        bool inverted = false;
+        // Whether to insert impossible values for the condition or only use possible values
+        bool impossible = true;
 
-        Condition() : vartok(nullptr), true_values(), false_values() {}
+        bool isBool() const {
+            return astIsBool(vartok);
+        }
+
+        static MathLib::bigint findPath(const std::list<ValueFlow::Value>& values)
+        {
+            auto it = std::find_if(values.cbegin(), values.cend(), [](const ValueFlow::Value& v) {
+                return v.path > 0;
+            });
+            if (it == values.end())
+                return 0;
+            assert(std::all_of(it, values.end(), [&](const ValueFlow::Value& v) {
+                return v.path == 0 || v.path == it->path;
+            }));
+            return it->path;
+        }
+
+        MathLib::bigint getPath() const
+        {
+            assert(std::abs(findPath(true_values) - findPath(false_values)) == 0);
+            return findPath(true_values) | findPath(false_values);
+        }
+
+        Token* getContextAndValues(Token* condTok,
+                                   std::list<ValueFlow::Value>& thenValues,
+                                   std::list<ValueFlow::Value>& elseValues,
+                                   bool known = false) const
+        {
+            const MathLib::bigint path = getPath();
+            const bool allowKnown = path == 0;
+            const bool allowImpossible = impossible && allowKnown;
+
+            bool inverted2 = inverted;
+            Token* ctx = skipNotAndCasts(condTok, &inverted2);
+            bool then = !inverted || !inverted2;
+
+            if (!Token::Match(condTok, "!=|=|(|.") && condTok != vartok) {
+                thenValues.insert(thenValues.end(), true_values.cbegin(), true_values.cend());
+                if (allowImpossible && (known || isConditionKnown(ctx, !then)))
+                    insertImpossible(elseValues, false_values);
+            }
+            if (!Token::Match(condTok, "==|!")) {
+                elseValues.insert(elseValues.end(), false_values.cbegin(), false_values.cend());
+                if (allowImpossible && (known || isConditionKnown(ctx, then))) {
+                    insertImpossible(thenValues, true_values);
+                    if (isBool())
+                        insertNegateKnown(thenValues, true_values);
+                }
+            }
+
+            if (inverted2)
+                std::swap(thenValues, elseValues);
+
+            return ctx;
+        }
     };
-    std::function<bool(Token* start, const Token* stop, const Token* exprTok, const std::list<ValueFlow::Value>& values, bool constValue)>
-    forward;
-    std::function<Condition(Token *tok)> parse;
-
-    void afterCondition(TokenList *tokenlist,
-                        SymbolDatabase *symboldatabase,
-                        ErrorLogger *errorLogger,
-                        const Settings *settings) const {
-        for (const Scope *scope : symboldatabase->functionScopes) {
-            std::set<unsigned> aliased;
-            for (Token *tok = const_cast<Token *>(scope->bodyStart); tok != scope->bodyEnd; tok = tok->next()) {
+
+    virtual std::vector<Condition> parse(const Token* tok, const Settings& settings) const = 0;
+
+    virtual Analyzer::Result forward(Token* start,
+                                     const Token* stop,
+                                     const Token* exprTok,
+                                     const std::list<ValueFlow::Value>& values,
+                                     TokenList& tokenlist,
+                                     ErrorLogger& errorLogger,
+                                     const Settings& settings,
+                                     SourceLocation loc = SourceLocation::current()) const
+    {
+        return valueFlowForward(start->next(), stop, exprTok, values, tokenlist, errorLogger, settings, loc);
+    }
+
+    virtual Analyzer::Result forward(Token* top,
+                                     const Token* exprTok,
+                                     const std::list<ValueFlow::Value>& values,
+                                     TokenList& tokenlist,
+                                     ErrorLogger& errorLogger,
+                                     const Settings& settings,
+                                     SourceLocation loc = SourceLocation::current()) const
+    {
+        return valueFlowForwardRecursive(top, exprTok, values, tokenlist, errorLogger, settings, loc);
+    }
+
+    virtual void reverse(Token* start,
+                         const Token* endToken,
+                         const Token* exprTok,
+                         const std::list<ValueFlow::Value>& values,
+                         TokenList& tokenlist,
+                         ErrorLogger& errorLogger,
+                         const Settings& settings,
+                         SourceLocation loc = SourceLocation::current()) const
+    {
+        valueFlowReverse(start, endToken, exprTok, values, tokenlist, errorLogger, settings, loc);
+    }
+
+    void traverseCondition(const SymbolDatabase& symboldatabase,
+                           const Settings& settings,
+                           const std::set<const Scope*>& skippedFunctions,
+                           const std::function<void(const Condition& cond, Token* tok, const Scope* scope)>& f) const
+    {
+        for (const Scope *scope : symboldatabase.functionScopes) {
+            if (skippedFunctions.count(scope))
+                continue;
+            for (auto *tok = const_cast<Token *>(scope->bodyStart); tok != scope->bodyEnd; tok = tok->next()) {
                 if (Token::Match(tok, "if|while|for ("))
                     continue;
+                if (Token::Match(tok, ":|;|,"))
+                    continue;
 
-                if (Token::Match(tok, "= & %var% ;"))
-                    aliased.insert(tok->tokAt(2)->varId());
                 const Token* top = tok->astTop();
-                if (!top)
-                    continue;
 
-                if (!Token::Match(top->previous(), "if|while|for (") && !Token::Match(tok->astParent(), "&&|%oror%"))
+                if (!Token::Match(top->previous(), "if|while|for (") && !Token::Match(tok->astParent(), "&&|%oror%|?|!"))
                     continue;
+                for (const Condition& cond : parse(tok, settings)) {
+                    if (!cond.vartok)
+                        continue;
+                    if (cond.vartok->exprId() == 0)
+                        continue;
+                    if (cond.vartok->hasKnownIntValue())
+                        continue;
+                    if (cond.true_values.empty() || cond.false_values.empty())
+                        continue;
+                    if (!isConstExpression(cond.vartok, settings.library))
+                        continue;
+                    f(cond, tok, scope);
+                }
+            }
+        }
+    }
 
-                Condition cond = parse(tok);
-                if (!cond.vartok)
-                    continue;
-                if (cond.true_values.empty() || cond.false_values.empty())
-                    continue;
+    void beforeCondition(TokenList& tokenlist,
+                         const SymbolDatabase& symboldatabase,
+                         ErrorLogger& errorLogger,
+                         const Settings& settings,
+                         const std::set<const Scope*>& skippedFunctions) const {
+        traverseCondition(symboldatabase, settings, skippedFunctions, [&](const Condition& cond, Token* tok, const Scope*) {
+            if (cond.vartok->exprId() == 0)
+                return;
 
-                if (exprDependsOnThis(cond.vartok))
-                    continue;
-                std::vector<const Variable*> vars = getExprVariables(cond.vartok, tokenlist, symboldatabase, settings);
-                if (std::any_of(vars.begin(), vars.end(), [](const Variable* var) {
-                return !var;
-            }))
-                continue;
-                if (!vars.empty() && (vars.front()))
-                    if (std::any_of(vars.begin(), vars.end(), [&](const Variable* var) {
-                    return var && aliased.find(var->declarationId()) != aliased.end();
-                    })) {
-                    if (settings->debugwarnings)
+            // If condition is known then don't propagate value
+            if (tok->hasKnownIntValue())
+                return;
+
+            Token* top = tok->astTop();
+
+            if (Token::Match(top, "%assign%"))
+                return;
+            if (Token::Match(cond.vartok->astParent(), "%assign%|++|--"))
+                return;
+
+            if (Token::simpleMatch(tok->astParent(), "?") && tok->astParent()->isExpandedMacro()) {
+                if (settings.debugwarnings)
+                    bailout(tokenlist,
+                            errorLogger,
+                            tok,
+                            "variable '" + cond.vartok->expressionString() + "', condition is defined in macro");
+                return;
+            }
+
+            // if,macro => bailout
+            if (Token::simpleMatch(top->previous(), "if (") && top->previous()->isExpandedMacro()) {
+                if (settings.debugwarnings)
+                    bailout(tokenlist,
+                            errorLogger,
+                            tok,
+                            "variable '" + cond.vartok->expressionString() + "', condition is defined in macro");
+                return;
+            }
+
+            if (cond.true_values.empty() && cond.false_values.empty())
+                return;
+
+            std::list<ValueFlow::Value> values = cond.true_values;
+            if (cond.true_values != cond.false_values)
+                values.insert(values.end(), cond.false_values.cbegin(), cond.false_values.cend());
+
+            // extra logic for unsigned variables 'i>=1' => possible value can also be 0
+            if (Token::Match(tok, "<|>|<=|>=")) {
+                if (cond.vartok->valueType() && cond.vartok->valueType()->sign != ValueType::Sign::UNSIGNED)
+                    return;
+
+                values.remove_if([](const ValueFlow::Value& v) {
+                    if (v.isIntValue())
+                        return v.intvalue != 0;
+                    return false;
+                });
+            }
+            if (values.empty())
+                return;
+
+            // bailout: for/while-condition, variable is changed in while loop
+            if (Token::Match(top->previous(), "for|while (") && Token::simpleMatch(top->link(), ") {")) {
+
+                // Variable changed in 3rd for-expression
+                if (Token::simpleMatch(top->previous(), "for (")) {
+                    if (top->astOperand2() && top->astOperand2()->astOperand2() &&
+                        findExpressionChanged(
+                            cond.vartok, top->astOperand2()->astOperand2(), top->link(), settings)) {
+                        if (settings.debugwarnings)
+                            bailout(tokenlist,
+                                    errorLogger,
+                                    tok,
+                                    "variable '" + cond.vartok->expressionString() + "' used in loop");
+                        return;
+                    }
+                }
+
+                // Variable changed in loop code
+                const Token* const start = top->strAt(-1) == "for" ? top->astOperand2() : top; // skip init statement
+                const Token* const block = top->link()->next();
+                const Token* const end = block->link();
+
+                if (findExpressionChanged(cond.vartok, start, end, settings)) {
+                    // If its reassigned in loop then analyze from the end
+                    if (!Token::Match(tok, "%assign%|++|--") &&
+                        findExpression(cond.vartok->exprId(), start, end, [&](const Token* tok2) {
+                        return Token::Match(tok2->astParent(), "%assign%") && astIsLHS(tok2);
+                    }) && !findEscapeStatement(block->scope(), settings.library)) {
+                        // Start at the end of the loop body
+                        Token* bodyTok = top->link()->next();
+                        reverse(bodyTok->link(), bodyTok, cond.vartok, values, tokenlist, errorLogger, settings);
+                    }
+                    if (settings.debugwarnings)
                         bailout(tokenlist,
                                 errorLogger,
-                                cond.vartok,
-                                "variable is aliased so we just skip all valueflow after condition");
-                    continue;
+                                tok,
+                                "variable '" + cond.vartok->expressionString() + "' used in loop");
+                    return;
                 }
+            }
 
-                if (Token::Match(tok->astParent(), "%oror%|&&")) {
-                    Token *parent = tok->astParent();
-                    const std::string &op(parent->str());
-
-                    if (parent->astOperand1() == tok && ((op == "&&" && Token::Match(tok, "==|>=|<=|!")) ||
-                                                         (op == "||" && Token::Match(tok, "%name%|!=")))) {
-                        for (; parent && parent->str() == op; parent = parent->astParent()) {
-                            std::stack<Token *> tokens;
-                            tokens.push(parent->astOperand2());
-                            bool assign = false;
-                            while (!tokens.empty()) {
-                                Token *rhstok = tokens.top();
-                                tokens.pop();
-                                if (!rhstok)
-                                    continue;
-                                tokens.push(rhstok->astOperand1());
-                                tokens.push(rhstok->astOperand2());
-                                if (isSameExpression(
-                                        tokenlist->isCPP(), false, cond.vartok, rhstok, settings->library, true, false))
-                                    setTokenValue(rhstok, cond.true_values.front(), settings);
-                                else if (Token::Match(rhstok, "++|--|=") && isSameExpression(tokenlist->isCPP(),
-                                         false,
-                                         cond.vartok,
-                                         rhstok->astOperand1(),
-                                         settings->library,
-                                         true,
-                                         false)) {
-                                    assign = true;
-                                    break;
-                                }
-                            }
-                            if (assign)
-                                break;
-                            while (parent->astParent() && parent == parent->astParent()->astOperand2())
-                                parent = parent->astParent();
-                        }
-                    }
+            Token* startTok = nullptr;
+            if (astIsRHS(tok))
+                startTok = tok->astParent();
+            else if (astIsLHS(tok))
+                startTok = previousBeforeAstLeftmostLeaf(tok->astParent());
+            if (!startTok)
+                startTok = tok->previous();
+
+            reverse(startTok, nullptr, cond.vartok, values, tokenlist, errorLogger, settings);
+        });
+    }
+
+    static Token* skipNotAndCasts(Token* tok, bool* inverted = nullptr)
+    {
+        for (; tok->astParent(); tok = tok->astParent()) {
+            if (Token::simpleMatch(tok->astParent(), "!")) {
+                if (inverted)
+                    *inverted ^= true;
+                continue;
+            }
+            if (Token::Match(tok->astParent(), "==|!=")) {
+                const Token* sibling = tok->astSibling();
+                if (sibling->hasKnownIntValue() && (astIsBool(tok) || astIsBool(sibling))) {
+                    const bool value = !!sibling->getKnownIntValue();
+                    if (inverted)
+                        *inverted ^= value == Token::simpleMatch(tok->astParent(), "!=");
+                    continue;
                 }
+            }
+            if (tok->astParent()->isCast() && astIsBool(tok->astParent()))
+                continue;
+            return tok;
+        }
+        return tok;
+    }
 
-                if (top && Token::Match(top->previous(), "if|while (") && !top->previous()->isExpandedMacro()) {
-                    // does condition reassign variable?
-                    if (tok != top->astOperand2() && Token::Match(top->astOperand2(), "%oror%|&&") &&
-                        isVariablesChanged(top, top->link(), 0, vars, settings, tokenlist->isCPP())) {
-                        if (settings->debugwarnings)
-                            bailout(tokenlist, errorLogger, tok, "assignment in condition");
-                        continue;
-                    }
+    static void fillFromPath(ProgramMemory& pm, const Token* top, MathLib::bigint path, const Settings& settings)
+    {
+        if (path < 1)
+            return;
+        visitAstNodes(top, [&](const Token* tok) {
+            const ValueFlow::Value* v = ValueFlow::findValue(tok->values(), settings, [&](const ValueFlow::Value& v) {
+                return v.path == path && isNonConditionalPossibleIntValue(v);
+            });
+            if (v == nullptr)
+                return ChildrenToVisit::op1_and_op2;
+            pm.setValue(tok, *v);
+            return ChildrenToVisit::op1_and_op2;
+        });
+    }
+
+    void afterCondition(TokenList& tokenlist,
+                        const SymbolDatabase& symboldatabase,
+                        ErrorLogger& errorLogger,
+                        const Settings& settings,
+                        const std::set<const Scope*>& skippedFunctions) const {
+        traverseCondition(symboldatabase, settings, skippedFunctions, [&](const Condition& cond, Token* condTok, const Scope* scope) {
+            const MathLib::bigint path = cond.getPath();
+            const bool allowKnown = path == 0;
 
-                    std::list<ValueFlow::Value> thenValues;
-                    std::list<ValueFlow::Value> elseValues;
+            std::list<ValueFlow::Value> thenValues;
+            std::list<ValueFlow::Value> elseValues;
 
-                    if (!Token::Match(tok, "!=|=") && tok != cond.vartok) {
-                        thenValues.insert(thenValues.end(), cond.true_values.begin(), cond.true_values.end());
-                        if (isConditionKnown(tok, false))
-                            insertImpossible(elseValues, cond.false_values);
+            Token* ctx = cond.getContextAndValues(condTok, thenValues, elseValues);
+
+            if (Token::Match(ctx->astParent(), "%oror%|&&")) {
+                Token* parent = ctx->astParent();
+                if (astIsRHS(ctx) && astIsLHS(parent) && parent->astParent() &&
+                    parent->str() == parent->astParent()->str())
+                    parent = parent->astParent();
+                else if (!astIsLHS(ctx)) {
+                    parent = nullptr;
+                }
+                if (parent) {
+                    std::vector<Token*> nextExprs = {parent->astOperand2()};
+                    if (astIsLHS(parent) && parent->astParent() && parent->astParent()->str() == parent->str()) {
+                        nextExprs.push_back(parent->astParent()->astOperand2());
                     }
-                    if (!Token::Match(tok, "==|!")) {
-                        elseValues.insert(elseValues.end(), cond.false_values.begin(), cond.false_values.end());
-                        if (isConditionKnown(tok, true))
-                            insertImpossible(thenValues, cond.true_values);
+                    std::list<ValueFlow::Value> andValues;
+                    std::list<ValueFlow::Value> orValues;
+                    cond.getContextAndValues(condTok, andValues, orValues, true);
+
+                    const std::string& op(parent->str());
+                    std::list<ValueFlow::Value> values;
+                    if (op == "&&")
+                        values = std::move(andValues);
+                    else if (op == "||")
+                        values = std::move(orValues);
+                    if (allowKnown && (Token::Match(condTok, "==|!=") || cond.isBool()))
+                        changePossibleToKnown(values);
+                    if (astIsFloat(cond.vartok, false) ||
+                        (!cond.vartok->valueType() &&
+                         std::all_of(values.cbegin(), values.cend(), [](const ValueFlow::Value& v) {
+                        return v.isIntValue() || v.isFloatValue();
+                    })))
+                        values.remove_if([&](const ValueFlow::Value& v) {
+                            return v.isImpossible();
+                        });
+                    for (Token* start:nextExprs) {
+                        Analyzer::Result r = forward(start, cond.vartok, values, tokenlist, errorLogger, settings);
+                        if (r.terminate != Analyzer::Terminate::None || r.action.isModified())
+                            return;
                     }
+                }
+            }
 
-                    // start token of conditional code
-                    Token* startTokens[] = {nullptr, nullptr};
-
-                    // if astParent is "!" we need to invert codeblock
-                    {
-                        const Token *tok2 = tok;
-                        while (tok2->astParent()) {
-                            const Token *parent = tok2->astParent();
-                            while (parent && parent->str() == "&&")
-                                parent = parent->astParent();
-                            if (parent && (parent->str() == "!" || Token::simpleMatch(parent, "== false"))) {
-                                std::swap(thenValues, elseValues);
-                            }
-                            tok2 = parent;
+            {
+                const Token* tok2 = condTok;
+                std::string op;
+                bool mixedOperators = false;
+                while (tok2->astParent()) {
+                    const Token* parent = tok2->astParent();
+                    if (Token::Match(parent, "%oror%|&&")) {
+                        if (op.empty()) {
+                            op = parent->str();
+                        } else if (op != parent->str()) {
+                            mixedOperators = true;
+                            break;
                         }
                     }
+                    if (parent->str() == "!") {
+                        op = (op == "&&" ? "||" : "&&");
+                    }
+                    tok2 = parent;
+                }
 
-                    // determine startToken(s)
-                    if (Token::simpleMatch(top->link(), ") {"))
-                        startTokens[0] = top->link()->next();
-                    if (Token::simpleMatch(top->link()->linkAt(1), "} else {"))
-                        startTokens[1] = top->link()->linkAt(1)->tokAt(2);
+                if (mixedOperators) {
+                    return;
+                }
+            }
 
-                    int changeBlock = -1;
+            Token* top = condTok->astTop();
 
-                    for (int i = 0; i < 2; i++) {
-                        const Token *const startToken = startTokens[i];
-                        if (!startToken)
-                            continue;
-                        std::list<ValueFlow::Value>& values = (i == 0 ? thenValues : elseValues);
-                        valueFlowSetConditionToKnown(tok, values, i == 0);
+            if (top->previous()->isExpandedMacro()) {
+                for (std::list<ValueFlow::Value>* values : {&thenValues, &elseValues}) {
+                    for (ValueFlow::Value& v : *values)
+                        v.macro = true;
+                }
+            }
 
-                        // TODO: The endToken should not be startTokens[i]->link() in the valueFlowForwardVariable call
-                        if (forward(startTokens[i], startTokens[i]->link(), cond.vartok, values, true))
-                            changeBlock = i;
-                        changeKnownToPossible(values);
-                    }
-                    // TODO: Values changed in noreturn blocks should not bail
-                    if (changeBlock >= 0 && !Token::simpleMatch(top->previous(), "while (")) {
-                        if (settings->debugwarnings)
-                            bailout(tokenlist,
-                                    errorLogger,
-                                    startTokens[changeBlock]->link(),
-                                    "valueFlowAfterCondition: " + cond.vartok->expressionString() +
-                                    " is changed in conditional block");
+            Token* condTop = ctx->astParent();
+            {
+                bool inverted2 = false;
+                while (Token::Match(condTop, "%oror%|&&")) {
+                    Token* parent = skipNotAndCasts(condTop, &inverted2)->astParent();
+                    if (!parent)
+                        break;
+                    condTop = parent;
+                }
+                if (inverted2)
+                    std::swap(thenValues, elseValues);
+            }
+
+            if (!condTop)
+                return;
+
+            if (Token::simpleMatch(condTop, "?")) {
+                Token* colon = condTop->astOperand2();
+                forward(colon->astOperand1(), cond.vartok, thenValues, tokenlist, errorLogger, settings);
+                forward(colon->astOperand2(), cond.vartok, elseValues, tokenlist, errorLogger, settings);
+                // TODO: Handle after condition
+                return;
+            }
+
+            if (condTop != top && condTop->str() != ";")
+                return;
+
+            if (!Token::Match(top->previous(), "if|while|for ("))
+                return;
+
+            if (top->strAt(-1) == "for") {
+                if (!Token::Match(condTok, "%comp%"))
+                    return;
+                if (!Token::simpleMatch(condTok->astParent(), ";"))
+                    return;
+                const Token* stepTok = getStepTok(top);
+                if (cond.vartok->varId() == 0)
+                    return;
+                if (!cond.vartok->variable())
+                    return;
+                if (!Token::Match(stepTok, "++|--"))
+                    return;
+                std::set<ValueFlow::Value::Bound> bounds;
+                for (const ValueFlow::Value& v : thenValues) {
+                    if (v.bound != ValueFlow::Value::Bound::Point && v.isImpossible())
                         continue;
+                    bounds.insert(v.bound);
+                }
+                if (Token::simpleMatch(stepTok, "++") && bounds.count(ValueFlow::Value::Bound::Lower) > 0)
+                    return;
+                if (Token::simpleMatch(stepTok, "--") && bounds.count(ValueFlow::Value::Bound::Upper) > 0)
+                    return;
+                const Token* childTok = condTok->astOperand1();
+                if (!childTok)
+                    childTok = condTok->astOperand2();
+                if (!childTok)
+                    return;
+                if (childTok->varId() != cond.vartok->varId())
+                    return;
+                const Token* startBlock = top->link()->next();
+                if (isVariableChanged(startBlock,
+                                      startBlock->link(),
+                                      cond.vartok->varId(),
+                                      cond.vartok->variable()->isGlobal(),
+                                      settings))
+                    return;
+                // Check if condition in for loop is always false
+                const Token* initTok = getInitTok(top);
+                ProgramMemory pm;
+                fillFromPath(pm, initTok, path, settings);
+                fillFromPath(pm, condTok, path, settings);
+                execute(initTok, pm, nullptr, nullptr, settings);
+                MathLib::bigint result = 1;
+                execute(condTok, pm, &result, nullptr, settings);
+                if (result == 0)
+                    return;
+                // Remove condition since for condition is not redundant
+                for (std::list<ValueFlow::Value>* values : {&thenValues, &elseValues}) {
+                    for (ValueFlow::Value& v : *values) {
+                        v.condition = nullptr;
+                        v.conditional = true;
                     }
+                }
+            }
 
-                    // After conditional code..
-                    if (Token::simpleMatch(top->link(), ") {")) {
-                        Token *after = top->link()->linkAt(1);
-                        std::string unknownFunction;
-                        if (settings->library.isScopeNoReturn(after, &unknownFunction)) {
-                            if (settings->debugwarnings && !unknownFunction.empty())
-                                bailout(tokenlist, errorLogger, after, "possible noreturn scope");
-                            continue;
-                        }
+            bool deadBranch[] = {false, false};
+            // start token of conditional code
+            Token* startTokens[] = {nullptr, nullptr};
+            // determine startToken(s)
+            if (Token::simpleMatch(top->link(), ") {"))
+                startTokens[0] = top->link()->next();
+            if (Token::simpleMatch(top->link()->linkAt(1), "} else {"))
+                startTokens[1] = top->link()->linkAt(1)->tokAt(2);
 
-                        bool dead_if = isReturnScope(after, settings) ||
-                                       (tok->astParent() && Token::simpleMatch(tok->astParent()->previous(), "while (") &&
-                                        !isBreakScope(after));
-                        bool dead_else = false;
+            int changeBlock = -1;
+            int bailBlock = -1;
 
-                        if (Token::simpleMatch(after, "} else {")) {
-                            after = after->linkAt(2);
-                            if (Token::simpleMatch(after->tokAt(-2), ") ; }")) {
-                                if (settings->debugwarnings)
-                                    bailout(tokenlist, errorLogger, after, "possible noreturn scope");
-                                continue;
-                            }
-                            dead_else = isReturnScope(after, settings);
-                        }
+            for (int i = 0; i < 2; i++) {
+                const Token* const startToken = startTokens[i];
+                if (!startToken)
+                    continue;
+                std::list<ValueFlow::Value>& values = (i == 0 ? thenValues : elseValues);
+                if (allowKnown)
+                    valueFlowSetConditionToKnown(condTok, values, i == 0);
+
+                Analyzer::Result r = forward(startTokens[i], startTokens[i]->link(), cond.vartok, values, tokenlist, errorLogger, settings);
+                deadBranch[i] = r.terminate == Analyzer::Terminate::Escape;
+                if (r.action.isModified() && !deadBranch[i])
+                    changeBlock = i;
+                if (r.terminate != Analyzer::Terminate::None && r.terminate != Analyzer::Terminate::Escape &&
+                    r.terminate != Analyzer::Terminate::Modified)
+                    bailBlock = i;
+                changeKnownToPossible(values);
+            }
+            if (changeBlock >= 0 && !Token::simpleMatch(top->previous(), "while (")) {
+                if (settings.debugwarnings)
+                    bailout(tokenlist,
+                            errorLogger,
+                            startTokens[changeBlock]->link(),
+                            "valueFlowAfterCondition: " + cond.vartok->expressionString() +
+                            " is changed in conditional block");
+                return;
+            }
+            if (bailBlock >= 0) {
+                if (settings.debugwarnings)
+                    bailout(tokenlist,
+                            errorLogger,
+                            startTokens[bailBlock]->link(),
+                            "valueFlowAfterCondition: bailing in conditional block");
+                return;
+            }
 
-                        if (dead_if && dead_else)
-                            continue;
+            // After conditional code..
+            if (Token::simpleMatch(top->link(), ") {")) {
+                Token* after = top->link()->linkAt(1);
+                bool dead_if = deadBranch[0];
+                bool dead_else = deadBranch[1];
+                const Token* unknownFunction = nullptr;
+                if (condTok->astParent() && Token::Match(top->previous(), "while|for ("))
+                    dead_if = !isBreakScope(after);
+                else if (!dead_if)
+                    dead_if = isReturnScope(after, settings.library, &unknownFunction);
+
+                if (!dead_if && unknownFunction) {
+                    if (settings.debugwarnings)
+                        bailout(tokenlist, errorLogger, unknownFunction, "possible noreturn scope");
+                    return;
+                }
 
-                        std::list<ValueFlow::Value> values;
-                        if (dead_if) {
-                            values = elseValues;
-                        } else if (dead_else) {
-                            values = thenValues;
-                        } else {
-                            std::copy_if(thenValues.begin(),
-                                         thenValues.end(),
-                                         std::back_inserter(values),
-                                         std::mem_fn(&ValueFlow::Value::isPossible));
-                            std::copy_if(elseValues.begin(),
-                                         elseValues.end(),
-                                         std::back_inserter(values),
-                                         std::mem_fn(&ValueFlow::Value::isPossible));
-                        }
+                if (Token::simpleMatch(after, "} else {")) {
+                    after = after->linkAt(2);
+                    unknownFunction = nullptr;
+                    if (!dead_else)
+                        dead_else = isReturnScope(after, settings.library, &unknownFunction);
+                    if (!dead_else && unknownFunction) {
+                        if (settings.debugwarnings)
+                            bailout(tokenlist, errorLogger, unknownFunction, "possible noreturn scope");
+                        return;
+                    }
+                }
 
-                        if (!values.empty()) {
-                            if ((dead_if || dead_else) && !Token::Match(tok->astParent(), "&&|&")) {
-                                valueFlowSetConditionToKnown(tok, values, true);
-                                valueFlowSetConditionToKnown(tok, values, false);
-                            }
-                            // TODO: constValue could be true if there are no assignments in the conditional blocks and
-                            //       perhaps if there are no && and no || in the condition
-                            bool constValue = false;
-                            forward(after, top->scope()->bodyEnd, cond.vartok, values, constValue);
+                if (dead_if && dead_else)
+                    return;
+
+                std::list<ValueFlow::Value> values;
+                if (dead_if) {
+                    values = std::move(elseValues);
+                } else if (dead_else) {
+                    values = std::move(thenValues);
+                } else {
+                    std::copy_if(thenValues.cbegin(),
+                                 thenValues.cend(),
+                                 std::back_inserter(values),
+                                 std::mem_fn(&ValueFlow::Value::isPossible));
+                    std::copy_if(elseValues.cbegin(),
+                                 elseValues.cend(),
+                                 std::back_inserter(values),
+                                 std::mem_fn(&ValueFlow::Value::isPossible));
+                }
+
+                if (values.empty())
+                    return;
+
+                if (dead_if || dead_else) {
+                    const Token* parent = condTok->astParent();
+                    // Skip the not operator
+                    while (Token::simpleMatch(parent, "!"))
+                        parent = parent->astParent();
+                    bool possible = false;
+                    if (Token::Match(parent, "&&|%oror%")) {
+                        const std::string& op(parent->str());
+                        while (parent && parent->str() == op)
+                            parent = parent->astParent();
+                        if (Token::simpleMatch(parent, "!") || Token::simpleMatch(parent, "== false"))
+                            possible = op == "||";
+                        else
+                            possible = op == "&&";
+                    }
+                    if (possible) {
+                        values.remove_if(std::mem_fn(&ValueFlow::Value::isImpossible));
+                        changeKnownToPossible(values);
+                    } else if (allowKnown) {
+                        valueFlowSetConditionToKnown(condTok, values, true);
+                        valueFlowSetConditionToKnown(condTok, values, false);
+                    }
+                }
+                if (values.empty())
+                    return;
+                const bool isKnown = std::any_of(values.cbegin(), values.cend(), [&](const ValueFlow::Value& v) {
+                    return v.isKnown() || v.isImpossible();
+                });
+                if (isKnown && isBreakOrContinueScope(after)) {
+                    const Scope* loopScope = getLoopScope(cond.vartok);
+                    if (loopScope) {
+                        Analyzer::Result r = forward(after, loopScope->bodyEnd, cond.vartok, values, tokenlist, errorLogger, settings);
+                        if (r.terminate != Analyzer::Terminate::None)
+                            return;
+                        if (r.action.isModified())
+                            return;
+                        auto* start = const_cast<Token*>(loopScope->bodyEnd);
+                        if (Token::simpleMatch(start, "} while (")) {
+                            start = start->tokAt(2);
+                            forward(start, start->link(), cond.vartok, values, tokenlist, errorLogger, settings);
+                            start = start->link();
                         }
+                        values.remove_if(std::mem_fn(&ValueFlow::Value::isImpossible));
+                        changeKnownToPossible(values);
                     }
                 }
+                forward(after, ValueFlow::getEndOfExprScope(cond.vartok, scope), cond.vartok, values, tokenlist, errorLogger, settings);
             }
-        }
+        });
     }
+    virtual ~ConditionHandler() = default;
+    ConditionHandler(const ConditionHandler&) = default;
+protected:
+    ConditionHandler() = default;
 };
 
-static void valueFlowAfterCondition(TokenList *tokenlist,
-                                    SymbolDatabase *symboldatabase,
-                                    ErrorLogger *errorLogger,
-                                    const Settings *settings)
-{
-    ValueFlowConditionHandler handler;
-    handler.forward = [&](Token* start,
-                          const Token* stop,
-                          const Token* vartok,
-                          const std::list<ValueFlow::Value>& values,
-    bool constValue) {
-        valueFlowForward(start->next(), stop, vartok, values, constValue, false, tokenlist, errorLogger, settings);
-        std::vector<const Variable*> vars = getExprVariables(vartok, tokenlist, symboldatabase, settings);
-        return isVariablesChanged(start, stop, 0, vars, settings, tokenlist->isCPP());
-    };
-    handler.parse = [&](const Token *tok) {
-        ValueFlowConditionHandler::Condition cond;
-        ValueFlow::Value true_value;
-        ValueFlow::Value false_value;
-        const Token *vartok = parseCompareInt(tok, true_value, false_value);
-        if (vartok) {
+static void valueFlowCondition(const ValuePtr<ConditionHandler>& handler,
+                               TokenList& tokenlist,
+                               SymbolDatabase& symboldatabase,
+                               ErrorLogger& errorLogger,
+                               const Settings& settings,
+                               const std::set<const Scope*>& skippedFunctions)
+{
+    handler->beforeCondition(tokenlist, symboldatabase, errorLogger, settings, skippedFunctions);
+    handler->afterCondition(tokenlist, symboldatabase, errorLogger, settings, skippedFunctions);
+}
+
+struct SimpleConditionHandler : ConditionHandler {
+    std::vector<Condition> parse(const Token* tok, const Settings& /*settings*/) const override {
+
+        std::vector<Condition> conds;
+        parseCompareEachInt(tok, [&](const Token* vartok, ValueFlow::Value true_value, ValueFlow::Value false_value) {
+            if (vartok->hasKnownIntValue())
+                return;
             if (vartok->str() == "=" && vartok->astOperand1() && vartok->astOperand2())
                 vartok = vartok->astOperand1();
-            cond.true_values.push_back(true_value);
-            cond.false_values.push_back(false_value);
+            Condition cond;
+            cond.true_values.push_back(std::move(true_value));
+            cond.false_values.push_back(std::move(false_value));
             cond.vartok = vartok;
-            return cond;
-        }
-
-        if (tok->str() == "!") {
-            vartok = tok->astOperand1();
-
-        } else if (tok->astParent() && (Token::Match(tok->astParent(), "%oror%|&&") ||
-                                        Token::Match(tok->astParent()->previous(), "if|while ("))) {
-            if (Token::simpleMatch(tok, "="))
-                vartok = tok->astOperand1();
-            else if (!Token::Match(tok, "%comp%|%assign%"))
-                vartok = tok;
-        }
-
-        if (!vartok)
-            return cond;
-        cond.true_values.emplace_back(tok, 0LL);
-        cond.false_values.emplace_back(tok, 0LL);
-        cond.vartok = vartok;
-
-        return cond;
-    };
-    handler.afterCondition(tokenlist, symboldatabase, errorLogger, settings);
-}
-
-static void execute(const Token *expr,
-                    ProgramMemory * const programMemory,
-                    MathLib::bigint *result,
-                    bool *error)
-{
-    if (!expr)
-        *error = true;
-
-    else if (expr->hasKnownIntValue()) {
-        *result = expr->values().front().intvalue;
-    }
-
-    else if (expr->isNumber()) {
-        *result = MathLib::toLongNumber(expr->str());
-        if (MathLib::isFloat(expr->str()))
-            *error = true;
-    }
-
-    else if (expr->varId() > 0) {
-        if (!programMemory->getIntValue(expr->varId(), result))
-            *error = true;
-    }
-
-    else if (expr->isComparisonOp()) {
-        MathLib::bigint result1(0), result2(0);
-        execute(expr->astOperand1(), programMemory, &result1, error);
-        execute(expr->astOperand2(), programMemory, &result2, error);
-        if (expr->str() == "<")
-            *result = result1 < result2;
-        else if (expr->str() == "<=")
-            *result = result1 <= result2;
-        else if (expr->str() == ">")
-            *result = result1 > result2;
-        else if (expr->str() == ">=")
-            *result = result1 >= result2;
-        else if (expr->str() == "==")
-            *result = result1 == result2;
-        else if (expr->str() == "!=")
-            *result = result1 != result2;
-    }
-
-    else if (expr->isAssignmentOp()) {
-        execute(expr->astOperand2(), programMemory, result, error);
-        if (!expr->astOperand1() || !expr->astOperand1()->varId())
-            *error = true;
-        if (*error)
-            return;
+            conds.push_back(std::move(cond));
+        });
+        if (!conds.empty())
+            return conds;
 
-        if (expr->str() == "=") {
-            programMemory->setIntValue(expr->astOperand1()->varId(), *result);
-            return;
-        }
+        const Token* vartok = nullptr;
 
-        long long intValue;
-        if (!programMemory->getIntValue(expr->astOperand1()->varId(), &intValue)) {
-            *error = true;
-            return;
-        }
-        if (expr->str() == "+=")
-            programMemory->setIntValue(expr->astOperand1()->varId(), intValue + *result);
-        else if (expr->str() == "-=")
-            programMemory->setIntValue(expr->astOperand1()->varId(), intValue - *result);
-        else if (expr->str() == "*=")
-            programMemory->setIntValue(expr->astOperand1()->varId(), intValue * *result);
-        else if (expr->str() == "/=" && *result != 0)
-            programMemory->setIntValue(expr->astOperand1()->varId(), intValue / *result);
-        else if (expr->str() == "%=" && *result != 0)
-            programMemory->setIntValue(expr->astOperand1()->varId(), intValue % *result);
-        else if (expr->str() == "&=")
-            programMemory->setIntValue(expr->astOperand1()->varId(), intValue & *result);
-        else if (expr->str() == "|=")
-            programMemory->setIntValue(expr->astOperand1()->varId(), intValue | *result);
-        else if (expr->str() == "^=")
-            programMemory->setIntValue(expr->astOperand1()->varId(), intValue ^ *result);
-    }
-
-    else if (Token::Match(expr, "++|--")) {
-        if (!expr->astOperand1() || expr->astOperand1()->varId() == 0U)
-            *error = true;
-        else {
-            long long intValue;
-            if (!programMemory->getIntValue(expr->astOperand1()->varId(), &intValue))
-                *error = true;
-            else {
-                if (intValue == 0 &&
-                    expr->str() == "--" &&
-                    expr->astOperand1()->variable() &&
-                    expr->astOperand1()->variable()->typeStartToken()->isUnsigned())
-                    *error = true; // overflow
-                *result = intValue + (expr->str() == "++" ? 1 : -1);
-                programMemory->setIntValue(expr->astOperand1()->varId(), *result);
-            }
-        }
-    }
+        if (tok->str() == "!") {
+            vartok = tok->astOperand1();
 
-    else if (expr->isArithmeticalOp() && expr->astOperand1() && expr->astOperand2()) {
-        MathLib::bigint result1(0), result2(0);
-        execute(expr->astOperand1(), programMemory, &result1, error);
-        execute(expr->astOperand2(), programMemory, &result2, error);
-        if (expr->str() == "+")
-            *result = result1 + result2;
-        else if (expr->str() == "-")
-            *result = result1 - result2;
-        else if (expr->str() == "*") {
-            if (result2 && (result1 > std::numeric_limits<MathLib::bigint>::max()/result2))
-                *error = true;
-            else
-                *result = result1 * result2;
-        } else if (result2 == 0)
-            *error = true;
-        else if (expr->str() == "/")
-            *result = result1 / result2;
-        else if (expr->str() == "%")
-            *result = result1 % result2;
-        else if (expr->str() == "<<")  {
-            if (result2 < 0 || result1 < 0 || result2 >= MathLib::bigint_bits)  { // don't perform UB
-                *error= true;
-            } else {
-                *result = result1 << result2;
-            }
-        } else if (expr->str() == ">>") {
-            if (result2 < 0) { // don't perform UB
-                *error=true;
-            } else {
-                *result = result1 >> result2;
-            }
+        } else if (tok->astParent() && (Token::Match(tok->astParent(), "%oror%|&&|?") ||
+                                        Token::Match(tok->astParent()->previous(), "if|while ("))) {
+            if (Token::simpleMatch(tok, "="))
+                vartok = tok->astOperand1();
+            else if (!Token::Match(tok, "%comp%|%assign%"))
+                vartok = tok;
         }
-    }
 
-    else if (expr->str() == "&&") {
-        bool error1 = false;
-        execute(expr->astOperand1(), programMemory, result, &error1);
-        if (!error1 && *result == 0)
-            *result = 0;
-        else {
-            bool error2 = false;
-            execute(expr->astOperand2(), programMemory, result, &error2);
-            if (error1 && error2)
-                *error = true;
-            if (error2)
-                *result = 1;
-            else
-                *result = !!*result;
-        }
-    }
+        if (!vartok)
+            return {};
+        Condition cond;
+        cond.true_values.emplace_back(tok, 0LL);
+        cond.false_values.emplace_back(tok, 0LL);
+        cond.vartok = vartok;
 
-    else if (expr->str() == "||") {
-        execute(expr->astOperand1(), programMemory, result, error);
-        if (*result == 0 && *error == false)
-            execute(expr->astOperand2(), programMemory, result, error);
+        return {std::move(cond)};
     }
+};
 
-    else if (expr->str() == "!") {
-        execute(expr->astOperand1(), programMemory, result, error);
-        *result = !(*result);
+struct IteratorInferModel : InferModel {
+    virtual ValueFlow::Value::ValueType getType() const = 0;
+    bool match(const ValueFlow::Value& value) const override {
+        return value.valueType == getType();
+    }
+    ValueFlow::Value yield(MathLib::bigint value) const override
+    {
+        ValueFlow::Value result(value);
+        result.valueType = getType();
+        result.setKnown();
+        return result;
     }
+};
 
-    else if (expr->str() == "," && expr->astOperand1() && expr->astOperand2()) {
-        execute(expr->astOperand1(), programMemory, result, error);
-        execute(expr->astOperand2(), programMemory, result, error);
+struct EndIteratorInferModel : IteratorInferModel {
+    ValueFlow::Value::ValueType getType() const override {
+        return ValueFlow::Value::ValueType::ITERATOR_END;
     }
+};
 
-    else if (expr->str() == "[" && expr->astOperand1() && expr->astOperand2()) {
-        const Token *tokvalue = nullptr;
-        if (!programMemory->getTokValue(expr->astOperand1()->varId(), &tokvalue)) {
-            auto tokvalue_it = std::find_if(expr->astOperand1()->values().begin(),
-                                            expr->astOperand1()->values().end(),
-                                            std::mem_fn(&ValueFlow::Value::isTokValue));
-            if (tokvalue_it == expr->astOperand1()->values().end()) {
-                *error = true;
-                return;
-            }
-            tokvalue = tokvalue_it->tokvalue;
-        }
-        if (!tokvalue || !tokvalue->isLiteral()) {
-            *error = true;
-            return;
-        }
-        const std::string strValue = tokvalue->strValue();
-        MathLib::bigint index = 0;
-        execute(expr->astOperand2(), programMemory, &index, error);
-        if (index >= 0 && index < strValue.size())
-            *result = strValue[index];
-        else if (index == strValue.size())
-            *result = 0;
-        else
-            *error = true;
+struct StartIteratorInferModel : IteratorInferModel {
+    ValueFlow::Value::ValueType getType() const override {
+        return ValueFlow::Value::ValueType::ITERATOR_END;
     }
+};
 
-    else
-        *error = true;
+static bool isIntegralOnlyOperator(const Token* tok) {
+    return Token::Match(tok, "%|<<|>>|&|^|~|%or%");
 }
 
-static bool isInBounds(const ValueFlow::Value& value, MathLib::bigint x)
+static bool isIntegralOrPointer(const Token* tok)
 {
-    if (value.intvalue == x)
-        return true;
-    if (value.bound == ValueFlow::Value::Bound::Lower && value.intvalue > x)
-        return false;
-    if (value.bound == ValueFlow::Value::Bound::Upper && value.intvalue < x)
+    if (!tok)
         return false;
-    // Checking for equality is not necessary since we already know the value is not equal
-    if (value.bound == ValueFlow::Value::Bound::Point)
+    if (astIsIntegral(tok, false))
+        return true;
+    if (astIsPointer(tok))
+        return true;
+    if (Token::Match(tok, "NULL|nullptr"))
+        return true;
+    if (tok->valueType())
         return false;
-    return true;
-}
-
-static const ValueFlow::Value* proveNotEqual(const std::list<ValueFlow::Value>& values, MathLib::bigint x)
-{
-    const ValueFlow::Value* result = nullptr;
-    for (const ValueFlow::Value& value : values) {
-        if (value.valueType != ValueFlow::Value::INT)
-            continue;
-        if (result && !isInBounds(value, result->intvalue))
-            continue;
-        if (value.isImpossible()) {
-            if (value.intvalue == x)
-                return &value;
-            if (!isInBounds(value, x))
-                continue;
-            result = &value;
-        } else {
-            if (value.intvalue == x)
-                return nullptr;
-            if (!isInBounds(value, x))
-                continue;
-            result = nullptr;
-        }
-    }
-    return result;
+    // These operators only work on integers
+    if (isIntegralOnlyOperator(tok))
+        return true;
+    if (isIntegralOnlyOperator(tok->astParent()))
+        return true;
+    if (Token::Match(tok, "+|-|*|/") && tok->isBinaryOp())
+        return isIntegralOrPointer(tok->astOperand1()) && isIntegralOrPointer(tok->astOperand2());
+    return false;
 }
 
-static void valueFlowInferCondition(TokenList* tokenlist,
-                                    const Settings* settings)
+static void valueFlowInferCondition(TokenList& tokenlist, const Settings& settings)
 {
-    for (Token* tok = tokenlist->front(); tok; tok = tok->next()) {
+    for (Token* tok = tokenlist.front(); tok; tok = tok->next()) {
         if (!tok->astParent())
             continue;
-        if (tok->hasKnownValue())
+        if (tok->hasKnownIntValue())
             continue;
-        if (Token::Match(tok, "%var%") && (Token::Match(tok->astParent(), "?|&&|!|%oror%") ||
-                                           Token::Match(tok->astParent()->previous(), "if|while ("))) {
-            const ValueFlow::Value* result = proveNotEqual(tok->values(), 0);
-            if (!result)
-                continue;
-            ValueFlow::Value value = *result;
-            value.intvalue = 1;
-            value.setKnown();
-            setTokenValue(tok, value, settings);
-        } else if (Token::Match(tok, "==|!=")) {
-            MathLib::bigint val = 0;
-            const Token* varTok = nullptr;
-            if (tok->astOperand1()->hasKnownIntValue()) {
-                val = tok->astOperand1()->values().front().intvalue;
-                varTok = tok->astOperand2();
-            } else if (tok->astOperand2()->hasKnownIntValue()) {
-                val = tok->astOperand2()->values().front().intvalue;
-                varTok = tok->astOperand1();
+        if (Token::Match(tok, "%comp%|-") && tok->astOperand1() && tok->astOperand2()) {
+            if (astIsIterator(tok->astOperand1()) || astIsIterator(tok->astOperand2())) {
+                static const std::array<ValuePtr<InferModel>, 2> iteratorModels = {EndIteratorInferModel{},
+                                                                                   StartIteratorInferModel{}};
+                for (const ValuePtr<InferModel>& model : iteratorModels) {
+                    std::vector<ValueFlow::Value> result =
+                        infer(model, tok->str(), tok->astOperand1()->values(), tok->astOperand2()->values());
+                    for (ValueFlow::Value value : result) {
+                        value.valueType = ValueFlow::Value::ValueType::INT;
+                        setTokenValue(tok, std::move(value), settings);
+                    }
+                }
+            } else if (isIntegralOrPointer(tok->astOperand1()) && isIntegralOrPointer(tok->astOperand2())) {
+                std::vector<ValueFlow::Value> result =
+                    infer(makeIntegralInferModel(), tok->str(), tok->astOperand1()->values(), tok->astOperand2()->values());
+                for (ValueFlow::Value& value : result) {
+                    setTokenValue(tok, std::move(value), settings);
+                }
             }
-            if (!varTok)
-                continue;
-            if (varTok->hasKnownIntValue())
-                continue;
-            const ValueFlow::Value* result = proveNotEqual(varTok->values(), val);
-            if (!result)
+        } else if (Token::Match(tok->astParent(), "?|&&|!|%oror%") ||
+                   Token::Match(tok->astParent()->previous(), "if|while (") ||
+                   (astIsPointer(tok) && isUsedAsBool(tok, settings))) {
+            std::vector<ValueFlow::Value> result = infer(makeIntegralInferModel(), "!=", tok->values(), 0);
+            if (result.size() != 1)
                 continue;
-            ValueFlow::Value value = *result;
-            value.intvalue = tok->str() == "!=";
-            value.setKnown();
-            setTokenValue(tok, value, settings);
+            setTokenValue(tok, std::move(result.front()), settings);
         }
     }
 }
 
-static bool valueFlowForLoop1(const Token *tok, int * const varid, MathLib::bigint * const num1, MathLib::bigint * const num2, MathLib::bigint * const numAfter)
-{
-    tok = tok->tokAt(2);
-    if (!Token::Match(tok, "%type%| %var% ="))
-        return false;
-    const Token * const vartok = Token::Match(tok, "%var% =") ? tok : tok->next();
-    *varid = vartok->varId();
-    tok = vartok->tokAt(2);
-    const Token * const num1tok = Token::Match(tok, "%num% ;") ? tok : nullptr;
-    if (num1tok)
-        *num1 = MathLib::toLongNumber(num1tok->str());
-    while (Token::Match(tok, "%name%|%num%|%or%|+|-|*|/|&|[|]|("))
-        tok = (tok->str() == "(") ? tok->link()->next() : tok->next();
-    if (!tok || tok->str() != ";")
-        return false;
-    tok = tok->next();
-    const Token *num2tok = nullptr;
-    if (Token::Match(tok, "%varid% <|<=|!=", vartok->varId())) {
-        tok = tok->next();
-        num2tok = tok->astOperand2();
-        if (num2tok && num2tok->str() == "(" && !num2tok->astOperand2())
-            num2tok = num2tok->astOperand1();
-        if (!Token::Match(num2tok, "%num% ;|%oror%")) // TODO: || enlarges the scope of the condition, so it should not cause FP, but it should no lnger be part of this pattern as soon as valueFlowForLoop2 can handle an unknown RHS of || better
-            num2tok = nullptr;
+struct SymbolicConditionHandler : SimpleConditionHandler {
+
+    static bool isNegatedBool(const Token* tok)
+    {
+        if (!Token::simpleMatch(tok, "!"))
+            return false;
+        return (astIsBool(tok->astOperand1()));
     }
-    if (!num2tok)
-        return false;
-    *num2 = MathLib::toLongNumber(num2tok->str()) - ((tok->str()=="<=") ? 0 : 1);
-    *numAfter = *num2 + 1;
-    if (!num1tok)
-        *num1 = *num2;
-    while (tok && tok->str() != ";")
-        tok = tok->next();
-    if (!Token::Match(tok, "; %varid% ++ ) {", vartok->varId()) && !Token::Match(tok, "; ++ %varid% ) {", vartok->varId()))
-        return false;
-    return true;
-}
+
+    static const Token* skipNot(const Token* tok)
+    {
+        if (!Token::simpleMatch(tok, "!"))
+            return tok;
+        return tok->astOperand1();
+    }
+
+    std::vector<Condition> parse(const Token* tok, const Settings& settings) const override
+    {
+        if (!Token::Match(tok, "%comp%"))
+            return {};
+        if (tok->hasKnownIntValue())
+            return {};
+        if (!tok->astOperand1() || tok->astOperand1()->hasKnownIntValue() || tok->astOperand1()->isLiteral())
+            return {};
+        if (!tok->astOperand2() || tok->astOperand2()->hasKnownIntValue() || tok->astOperand2()->isLiteral())
+            return {};
+        if (!isConstExpression(tok, settings.library))
+            return {};
+
+        std::vector<Condition> result;
+        auto addCond = [&](const Token* lhsTok, const Token* rhsTok, bool inverted) {
+            for (int i = 0; i < 2; i++) {
+                const bool lhs = i == 0;
+                const Token* vartok = lhs ? lhsTok : rhsTok;
+                const Token* valuetok = lhs ? rhsTok : lhsTok;
+                if (valuetok->exprId() == 0)
+                    continue;
+                if (valuetok->hasKnownSymbolicValue(vartok))
+                    continue;
+                if (vartok->hasKnownSymbolicValue(valuetok))
+                    continue;
+                ValueFlow::Value true_value;
+                ValueFlow::Value false_value;
+                setConditionalValues(tok, !lhs, 0, true_value, false_value);
+                setSymbolic(true_value, valuetok);
+                setSymbolic(false_value, valuetok);
+
+                Condition cond;
+                cond.true_values = {std::move(true_value)};
+                cond.false_values = {std::move(false_value)};
+                cond.vartok = vartok;
+                cond.inverted = inverted;
+                result.push_back(std::move(cond));
+            }
+        };
+        addCond(tok->astOperand1(), tok->astOperand2(), false);
+        if (Token::Match(tok, "==|!=") && (isNegatedBool(tok->astOperand1()) || isNegatedBool(tok->astOperand2()))) {
+            const Token* lhsTok = skipNot(tok->astOperand1());
+            const Token* rhsTok = skipNot(tok->astOperand2());
+            addCond(lhsTok, rhsTok, !(isNegatedBool(tok->astOperand1()) && isNegatedBool(tok->astOperand2())));
+        }
+        return result;
+    }
+};
 
 static bool valueFlowForLoop2(const Token *tok,
                               ProgramMemory *memory1,
                               ProgramMemory *memory2,
-                              ProgramMemory *memoryAfter)
+                              ProgramMemory *memoryAfter,
+                              const Settings& settings)
 {
     // for ( firstExpression ; secondExpression ; thirdExpression )
     const Token *firstExpression  = tok->next()->astOperand2()->astOperand1();
@@ -5004,17 +5154,17 @@ static bool valueFlowForLoop2(const Token *tok,
     ProgramMemory programMemory;
     MathLib::bigint result(0);
     bool error = false;
-    execute(firstExpression, &programMemory, &result, &error);
+    execute(firstExpression, programMemory, &result, &error, settings);
     if (error)
         return false;
-    execute(secondExpression, &programMemory, &result, &error);
+    execute(secondExpression, programMemory, &result, &error, settings);
     if (result == 0) // 2nd expression is false => no looping
         return false;
     if (error) {
         // If a variable is reassigned in second expression, return false
         bool reassign = false;
         visitAstNodes(secondExpression,
-        [&](const Token *t) {
+                      [&](const Token *t) {
             if (t->str() == "=" && t->astOperand1() && programMemory.hasValue(t->astOperand1()->varId()))
                 // TODO: investigate what variable is assigned.
                 reassign = true;
@@ -5027,33 +5177,51 @@ static bool valueFlowForLoop2(const Token *tok,
     ProgramMemory startMemory(programMemory);
     ProgramMemory endMemory;
 
-    int maxcount = 10000;
+    int maxcount = settings.vfOptions.maxForLoopCount;
     while (result != 0 && !error && --maxcount > 0) {
         endMemory = programMemory;
-        execute(thirdExpression, &programMemory, &result, &error);
+        execute(thirdExpression, programMemory, &result, &error, settings);
         if (!error)
-            execute(secondExpression, &programMemory, &result, &error);
+            execute(secondExpression, programMemory, &result, &error, settings);
     }
+    // TODO: add bailout message
 
-    memory1->swap(startMemory);
+    if (memory1)
+        memory1->swap(startMemory);
     if (!error) {
-        memory2->swap(endMemory);
-        memoryAfter->swap(programMemory);
+        if (memory2)
+            memory2->swap(endMemory);
+        if (memoryAfter)
+            memoryAfter->swap(programMemory);
     }
 
     return true;
 }
 
-static void valueFlowForLoopSimplify(Token * const bodyStart, const nonneg int varid, bool globalvar, const MathLib::bigint value, TokenList *tokenlist, ErrorLogger *errorLogger, const Settings *settings)
+static void valueFlowForLoopSimplify(Token* const bodyStart,
+                                     const Token* expr,
+                                     bool globalvar,
+                                     const MathLib::bigint value,
+                                     const TokenList& tokenlist,
+                                     ErrorLogger& errorLogger,
+                                     const Settings& settings)
 {
+    // TODO: Refactor this to use arbitrary expressions
+    assert(expr->varId() > 0);
     const Token * const bodyEnd = bodyStart->link();
 
     // Is variable modified inside for loop
-    if (isVariableChanged(bodyStart, bodyEnd, varid, globalvar, settings, tokenlist->isCPP()))
+    if (isVariableChanged(bodyStart, bodyEnd, expr->varId(), globalvar, settings))
+        return;
+
+    if (const Token* escape = findEscapeStatement(bodyStart->scope(), settings.library)) {
+        if (settings.debugwarnings)
+            bailout(tokenlist, errorLogger, escape, "For loop variable bailout on escape statement");
         return;
+    }
 
     for (Token *tok2 = bodyStart->next(); tok2 != bodyEnd; tok2 = tok2->next()) {
-        if (tok2->varId() == varid) {
+        if (tok2->varId() == expr->varId()) {
             const Token * parent = tok2->astParent();
             while (parent) {
                 const Token * const p = parent;
@@ -5067,22 +5235,22 @@ static void valueFlowForLoopSimplify(Token * const bodyStart, const nonneg int v
                 }
             }
             if (parent) {
-                if (settings->debugwarnings)
+                if (settings.debugwarnings)
                     bailout(tokenlist, errorLogger, tok2, "For loop variable " + tok2->str() + " stopping on ?");
                 continue;
             }
 
             ValueFlow::Value value1(value);
             value1.varId = tok2->varId();
-            setTokenValue(tok2, value1, settings);
+            setTokenValue(tok2, std::move(value1), settings);
         }
 
         if (Token::Match(tok2, "%oror%|&&")) {
-            const ProgramMemory programMemory(getProgramMemory(tok2->astTop(), varid, ValueFlow::Value(value)));
-            if ((tok2->str() == "&&" && !conditionIsTrue(tok2->astOperand1(), programMemory)) ||
-                (tok2->str() == "||" && !conditionIsFalse(tok2->astOperand1(), programMemory))) {
+            const ProgramMemory programMemory(getProgramMemory(tok2->astTop(), expr, ValueFlow::Value(value), settings));
+            if ((tok2->str() == "&&" && !conditionIsTrue(tok2->astOperand1(), programMemory, settings)) ||
+                (tok2->str() == "||" && !conditionIsFalse(tok2->astOperand1(), programMemory, settings))) {
                 // Skip second expression..
-                const Token *parent = tok2;
+                Token *parent = tok2;
                 while (parent && parent->str() == tok2->str())
                     parent = parent->astParent();
                 // Jump to end of condition
@@ -5093,43 +5261,45 @@ static void valueFlowForLoopSimplify(Token * const bodyStart, const nonneg int v
                         tok2 = tok2->linkAt(1);
                 }
             }
-
         }
-        if ((tok2->str() == "&&" && conditionIsFalse(tok2->astOperand1(), getProgramMemory(tok2->astTop(), varid, ValueFlow::Value(value)))) ||
-            (tok2->str() == "||" && conditionIsTrue(tok2->astOperand1(), getProgramMemory(tok2->astTop(), varid, ValueFlow::Value(value)))))
+        const Token* vartok = expr;
+        const Token* rml = nextAfterAstRightmostLeaf(vartok);
+        if (rml)
+            vartok = rml->str() == "]" ? rml : rml->previous();
+        if (vartok->str() == "]" && vartok->link()->previous())
+            vartok = vartok->link()->previous();
+
+        if ((tok2->str() == "&&" &&
+             conditionIsFalse(tok2->astOperand1(),
+                              getProgramMemory(tok2->astTop(), expr, ValueFlow::Value(value), settings),
+                              settings)) ||
+            (tok2->str() == "||" &&
+             conditionIsTrue(tok2->astOperand1(),
+                             getProgramMemory(tok2->astTop(), expr, ValueFlow::Value(value), settings),
+                             settings)))
             break;
 
-        else if (Token::simpleMatch(tok2, ") {") && Token::findmatch(tok2->link(), "%varid%", tok2, varid)) {
-            if (Token::findmatch(tok2, "continue|break|return", tok2->linkAt(1), varid)) {
-                if (settings->debugwarnings)
-                    bailout(tokenlist, errorLogger, tok2, "For loop variable bailout on conditional continue|break|return");
-                break;
-            }
-            if (settings->debugwarnings)
-                bailout(tokenlist, errorLogger, tok2, "For loop variable skipping conditional scope");
-            tok2 = tok2->next()->link();
-            if (Token::simpleMatch(tok2, "} else {")) {
-                if (Token::findmatch(tok2, "continue|break|return", tok2->linkAt(2), varid)) {
-                    if (settings->debugwarnings)
-                        bailout(tokenlist, errorLogger, tok2, "For loop variable bailout on conditional continue|break|return");
-                    break;
+        if (Token::simpleMatch(tok2, ") {")) {
+            if (vartok->varId() && Token::findmatch(tok2->link(), "%varid%", tok2, vartok->varId())) {
+                if (settings.debugwarnings)
+                    bailout(tokenlist, errorLogger, tok2, "For loop variable skipping conditional scope");
+                tok2 = tok2->linkAt(1);
+                if (Token::simpleMatch(tok2, "} else {")) {
+                    tok2 = tok2->linkAt(2);
                 }
-
-                tok2 = tok2->linkAt(2);
             }
-        }
-
-        else if (Token::simpleMatch(tok2, ") {")) {
-            if (settings->debugwarnings)
-                bailout(tokenlist, errorLogger, tok2, "For loop skipping {} code");
-            tok2 = tok2->linkAt(1);
-            if (Token::simpleMatch(tok2, "} else {"))
-                tok2 = tok2->linkAt(2);
+            else {
+                if (settings.debugwarnings)
+                    bailout(tokenlist, errorLogger, tok2, "For loop skipping {} code");
+                tok2 = tok2->linkAt(1);
+                if (Token::simpleMatch(tok2, "} else {"))
+                    tok2 = tok2->linkAt(2);
+            }
         }
     }
 }
 
-static void valueFlowForLoopSimplifyAfter(Token *fortok, nonneg int varid, const MathLib::bigint num, TokenList *tokenlist, ErrorLogger *errorLogger, const Settings *settings)
+static void valueFlowForLoopSimplifyAfter(Token* fortok, nonneg int varid, const MathLib::bigint num, const TokenList& tokenlist, ErrorLogger & errorLogger, const Settings& settings)
 {
     const Token *vartok = nullptr;
     for (const Token *tok = fortok; tok; tok = tok->next()) {
@@ -5144,144 +5314,260 @@ static void valueFlowForLoopSimplifyAfter(Token *fortok, nonneg int varid, const
     const Variable *var = vartok->variable();
     const Token *endToken = nullptr;
     if (var->isLocal())
-        endToken = var->typeStartToken()->scope()->bodyEnd;
+        endToken = var->scope()->bodyEnd;
     else
         endToken = fortok->scope()->bodyEnd;
 
-    std::list<ValueFlow::Value> values;
-    values.emplace_back(num);
-    values.back().errorPath.emplace_back(fortok,"After for loop, " + var->name() + " has value " + values.back().infoString());
+    Token* blockTok = fortok->linkAt(1)->linkAt(1);
+    if (blockTok != endToken) {
+        ValueFlow::Value v{num};
+        v.errorPath.emplace_back(fortok,"After for loop, " + var->name() + " has value " + v.infoString());
 
-    valueFlowForwardVariable(
-        fortok->linkAt(1)->linkAt(1)->next(), endToken, var, varid, values, false, false, tokenlist, errorLogger, settings);
+        valueFlowForward(blockTok->next(), endToken, vartok, std::move(v), tokenlist, errorLogger, settings);
+    }
 }
 
-static void valueFlowForLoop(TokenList *tokenlist, SymbolDatabase* symboldatabase, ErrorLogger *errorLogger, const Settings *settings)
+static void valueFlowForLoop(const TokenList &tokenlist, const SymbolDatabase& symboldatabase, ErrorLogger &errorLogger, const Settings &settings)
 {
-    for (const Scope &scope : symboldatabase->scopeList) {
-        if (scope.type != Scope::eFor)
+    for (const Scope &scope : symboldatabase.scopeList) {
+        if (scope.type != ScopeType::eFor)
             continue;
 
-        Token* tok = const_cast<Token*>(scope.classDef);
-        Token* const bodyStart = const_cast<Token*>(scope.bodyStart);
+        auto* tok = const_cast<Token*>(scope.classDef);
+        auto* const bodyStart = const_cast<Token*>(scope.bodyStart);
 
         if (!Token::simpleMatch(tok->next()->astOperand2(), ";") ||
             !Token::simpleMatch(tok->next()->astOperand2()->astOperand2(), ";"))
             continue;
 
-        int varid(0);
-        MathLib::bigint num1(0), num2(0), numAfter(0);
-
-        if (valueFlowForLoop1(tok, &varid, &num1, &num2, &numAfter)) {
-            if (num1 <= num2) {
-                valueFlowForLoopSimplify(bodyStart, varid, false, num1, tokenlist, errorLogger, settings);
-                valueFlowForLoopSimplify(bodyStart, varid, false, num2, tokenlist, errorLogger, settings);
-                valueFlowForLoopSimplifyAfter(tok, varid, numAfter, tokenlist, errorLogger, settings);
-            } else
-                valueFlowForLoopSimplifyAfter(tok, varid, num1, tokenlist, errorLogger, settings);
+        nonneg int varid;
+        bool knownInitValue, partialCond;
+        MathLib::bigint initValue, stepValue, lastValue;
+
+        if (extractForLoopValues(tok, varid, knownInitValue, initValue, partialCond, stepValue, lastValue)) {
+            const bool executeBody = !knownInitValue || initValue <= lastValue;
+            const Token* vartok = Token::findmatch(tok, "%varid%", bodyStart, varid);
+            if (executeBody && vartok) {
+                std::list<ValueFlow::Value> initValues;
+                initValues.emplace_back(initValue, ValueFlow::Value::Bound::Lower);
+                initValues.push_back(ValueFlow::asImpossible(initValues.back()));
+                Analyzer::Result result = valueFlowForward(bodyStart, bodyStart->link(), vartok, std::move(initValues), tokenlist, errorLogger, settings);
+
+                if (!result.action.isModified()) {
+                    std::list<ValueFlow::Value> lastValues;
+                    lastValues.emplace_back(lastValue, ValueFlow::Value::Bound::Upper);
+                    lastValues.back().conditional = true;
+                    lastValues.push_back(ValueFlow::asImpossible(lastValues.back()));
+                    if (stepValue != 1)
+                        lastValues.pop_front();
+                    valueFlowForward(bodyStart, bodyStart->link(), vartok, std::move(lastValues), tokenlist, errorLogger, settings);
+                }
+            }
+            const MathLib::bigint afterValue = executeBody ? lastValue + stepValue : initValue;
+            valueFlowForLoopSimplifyAfter(tok, varid, afterValue, tokenlist, errorLogger, settings);
         } else {
             ProgramMemory mem1, mem2, memAfter;
-            if (valueFlowForLoop2(tok, &mem1, &mem2, &memAfter)) {
-                std::map<int, ValueFlow::Value>::const_iterator it;
-                for (it = mem1.values.begin(); it != mem1.values.end(); ++it) {
-                    if (!it->second.isIntValue())
+            if (valueFlowForLoop2(tok, &mem1, &mem2, &memAfter, settings)) {
+                for (const auto& p : mem1) {
+                    if (!p.second.isIntValue())
+                        continue;
+                    if (p.second.isImpossible())
+                        continue;
+                    if (p.first.tok->varId() == 0)
                         continue;
-                    valueFlowForLoopSimplify(bodyStart, it->first, false, it->second.intvalue, tokenlist, errorLogger, settings);
+                    valueFlowForLoopSimplify(bodyStart, p.first.tok, false, p.second.intvalue, tokenlist, errorLogger, settings);
                 }
-                for (it = mem2.values.begin(); it != mem2.values.end(); ++it) {
-                    if (!it->second.isIntValue())
+                for (const auto& p : mem2) {
+                    if (!p.second.isIntValue())
                         continue;
-                    valueFlowForLoopSimplify(bodyStart, it->first, false, it->second.intvalue, tokenlist, errorLogger, settings);
+                    if (p.second.isImpossible())
+                        continue;
+                    if (p.first.tok->varId() == 0)
+                        continue;
+                    valueFlowForLoopSimplify(bodyStart, p.first.tok, false, p.second.intvalue, tokenlist, errorLogger, settings);
                 }
-                for (it = memAfter.values.begin(); it != memAfter.values.end(); ++it) {
-                    if (!it->second.isIntValue())
+                for (const auto& p : memAfter) {
+                    if (!p.second.isIntValue())
+                        continue;
+                    if (p.second.isImpossible())
+                        continue;
+                    if (p.first.tok->varId() == 0)
                         continue;
-                    valueFlowForLoopSimplifyAfter(tok, it->first, it->second.intvalue, tokenlist, errorLogger, settings);
+                    valueFlowForLoopSimplifyAfter(tok, p.first.getExpressionId(), p.second.intvalue, tokenlist, errorLogger, settings);
                 }
             }
         }
     }
 }
 
-static void valueFlowInjectParameter(TokenList* tokenlist, ErrorLogger* errorLogger, const Settings* settings, const Variable* arg, const Scope* functionScope, const std::list<ValueFlow::Value>& argvalues)
+template<class Key, class F>
+static bool productParams(const Settings& settings, const std::unordered_map<Key, std::list<ValueFlow::Value>>& vars, F f)
+{
+    using Args = std::vector<std::unordered_map<Key, ValueFlow::Value>>;
+    Args args(1);
+    // Compute cartesian product of all arguments
+    for (const auto& p : vars) {
+        if (p.second.empty())
+            continue;
+        args.back()[p.first] = p.second.front();
+    }
+    bool bail = false;
+    int max = settings.vfOptions.maxSubFunctionArgs;
+    for (const auto& p : vars) {
+        if (args.size() > max) {
+            bail = true;
+            break;
+        }
+        if (p.second.empty())
+            continue;
+        std::for_each(std::next(p.second.begin()), p.second.end(), [&](const ValueFlow::Value& value) {
+            Args new_args;
+            for (auto arg : args) {
+                if (value.path != 0) {
+                    for (const auto& q : arg) {
+                        if (q.first == p.first)
+                            continue;
+                        if (q.second.path == 0)
+                            continue;
+                        if (q.second.path != value.path)
+                            return;
+                    }
+                }
+                arg[p.first] = value;
+                new_args.push_back(std::move(arg));
+            }
+            std::copy(new_args.cbegin(), new_args.cend(), std::back_inserter(args));
+        });
+    }
+
+    if (args.size() > max) {
+        bail = true;
+        args.resize(max);
+        // TODO: add bailout message
+    }
+
+    for (const auto& arg : args) {
+        if (arg.empty())
+            continue;
+        // Make sure all arguments are the same path
+        const MathLib::bigint path = arg.cbegin()->second.path;
+        if (std::any_of(arg.cbegin(), arg.cend(), [&](const std::pair<Key, ValueFlow::Value>& p) {
+            return p.second.path != path;
+        }))
+            continue;
+        f(arg);
+    }
+    return !bail;
+}
+
+static void valueFlowInjectParameter(const TokenList& tokenlist,
+                                     ErrorLogger& errorLogger,
+                                     const Settings& settings,
+                                     const Scope* functionScope,
+                                     const std::unordered_map<const Variable*, std::list<ValueFlow::Value>>& vars)
+{
+    const bool r = productParams(settings, vars, [&](const std::unordered_map<const Variable*, ValueFlow::Value>& arg) {
+        auto a = makeMultiValueFlowAnalyzer(arg, settings);
+        valueFlowGenericForward(const_cast<Token*>(functionScope->bodyStart),
+                                functionScope->bodyEnd,
+                                a,
+                                tokenlist,
+                                errorLogger,
+                                settings);
+    });
+    if (!r) {
+        std::string fname = "<unknown>";
+        if (const Function* f = functionScope->function)
+            fname = f->name();
+        if (settings.debugwarnings)
+            bailout(tokenlist, errorLogger, functionScope->bodyStart, "Too many argument passed to " + fname);
+    }
+}
+
+static void valueFlowInjectParameter(const TokenList& tokenlist,
+                                     ErrorLogger& errorLogger,
+                                     const Settings& settings,
+                                     const Variable* arg,
+                                     const Scope* functionScope,
+                                     std::list<ValueFlow::Value> argvalues)
 {
     // Is argument passed by value or const reference, and is it a known non-class type?
     if (arg->isReference() && !arg->isConst() && !arg->isClass())
         return;
 
     // Set value in function scope..
-    const int varid2 = arg->declarationId();
+    const nonneg int varid2 = arg->declarationId();
     if (!varid2)
         return;
 
-    valueFlowForwardVariable(const_cast<Token*>(functionScope->bodyStart->next()),
-                             functionScope->bodyEnd,
-                             arg,
-                             varid2,
-                             argvalues,
-                             false,
-                             true,
-                             tokenlist,
-                             errorLogger,
-                             settings);
+    valueFlowForward(const_cast<Token*>(functionScope->bodyStart->next()),
+                     functionScope->bodyEnd,
+                     arg->nameToken(),
+                     std::move(argvalues),
+                     tokenlist,
+                     errorLogger,
+                     settings);
 }
 
-static void valueFlowSwitchVariable(TokenList *tokenlist, SymbolDatabase* symboldatabase, ErrorLogger *errorLogger, const Settings *settings)
+static void valueFlowSwitchVariable(const TokenList& tokenlist,
+                                    const SymbolDatabase& symboldatabase,
+                                    ErrorLogger& errorLogger,
+                                    const Settings& settings)
 {
-    for (const Scope &scope : symboldatabase->scopeList) {
-        if (scope.type != Scope::ScopeType::eSwitch)
+    for (const Scope& scope : symboldatabase.scopeList) {
+        if (scope.type != ScopeType::eSwitch)
             continue;
         if (!Token::Match(scope.classDef, "switch ( %var% ) {"))
             continue;
-        const Token *vartok = scope.classDef->tokAt(2);
-        const Variable *var = vartok->variable();
+        const Token* vartok = scope.classDef->tokAt(2);
+        const Variable* var = vartok->variable();
         if (!var)
             continue;
 
         // bailout: global non-const variables
         if (!(var->isLocal() || var->isArgument()) && !var->isConst()) {
-            if (settings->debugwarnings)
+            if (settings.debugwarnings)
                 bailout(tokenlist, errorLogger, vartok, "switch variable " + var->name() + " is global");
             continue;
         }
 
-        for (Token *tok = scope.bodyStart->next(); tok != scope.bodyEnd; tok = tok->next()) {
+        for (const Token* tok = scope.bodyStart->next(); tok != scope.bodyEnd; tok = tok->next()) {
             if (tok->str() == "{") {
                 tok = tok->link();
                 continue;
             }
             if (Token::Match(tok, "case %num% :")) {
                 std::list<ValueFlow::Value> values;
-                values.emplace_back(MathLib::toLongNumber(tok->next()->str()));
+                values.emplace_back(MathLib::toBigNumber(tok->tokAt(1)));
                 values.back().condition = tok;
-                const std::string info("case " + tok->next()->str() + ": " + vartok->str() + " is " + tok->next()->str() + " here.");
-                values.back().errorPath.emplace_back(tok, info);
+                values.back().errorPath.emplace_back(tok,
+                                                     "case " + tok->strAt(1) + ": " + vartok->str() + " is " +
+                                                     tok->strAt(1) + " here.");
                 bool known = false;
-                if ((Token::simpleMatch(tok->previous(), "{") || Token::simpleMatch(tok->tokAt(-2), "break ;")) && !Token::Match(tok->tokAt(3), ";| case"))
+                if ((Token::simpleMatch(tok->previous(), "{") || Token::simpleMatch(tok->tokAt(-2), "break ;")) &&
+                    !Token::Match(tok->tokAt(3), ";| case"))
                     known = true;
                 while (Token::Match(tok->tokAt(3), ";| case %num% :")) {
                     known = false;
                     tok = tok->tokAt(3);
                     if (!tok->isName())
                         tok = tok->next();
-                    values.emplace_back(MathLib::toLongNumber(tok->next()->str()));
+                    values.emplace_back(MathLib::toBigNumber(tok->tokAt(1)));
                     values.back().condition = tok;
-                    const std::string info2("case " + tok->next()->str() + ": " + vartok->str() + " is " + tok->next()->str() + " here.");
-                    values.back().errorPath.emplace_back(tok, info2);
+                    values.back().errorPath.emplace_back(tok,
+                                                         "case " + tok->strAt(1) + ": " + vartok->str() + " is " +
+                                                         tok->strAt(1) + " here.");
                 }
-                for (std::list<ValueFlow::Value>::const_iterator val = values.begin(); val != values.end(); ++val) {
-                    valueFlowReverse(tokenlist,
-                                     const_cast<Token*>(scope.classDef),
-                                     vartok,
-                                     *val,
-                                     ValueFlow::Value(),
-                                     errorLogger,
-                                     settings);
+                for (auto val = values.cbegin(); val != values.cend(); ++val) {
+                    valueFlowReverse(tokenlist, const_cast<Token*>(scope.classDef), vartok, *val, errorLogger, settings);
                 }
                 if (vartok->variable()->scope()) {
                     if (known)
                         values.back().setKnown();
-                    valueFlowForwardVariable(tok->tokAt(3),
+
+                    // FIXME We must check if there is a return. See #9276
+                    /*
+                       valueFlowForwardVariable(tok->tokAt(3),
                                              vartok->variable()->scope()->bodyEnd,
                                              vartok->variable(),
                                              vartok->varId(),
@@ -5291,155 +5577,14 @@ static void valueFlowSwitchVariable(TokenList *tokenlist, SymbolDatabase* symbol
                                              tokenlist,
                                              errorLogger,
                                              settings);
+                     */
                 }
             }
         }
     }
 }
 
-static void setTokenValues(Token *tok, const std::list<ValueFlow::Value> &values, const Settings *settings)
-{
-    for (const ValueFlow::Value &value : values) {
-        if (value.isIntValue())
-            setTokenValue(tok, value, settings);
-    }
-}
-
-static bool evaluate(const Token *expr, const std::vector<std::list<ValueFlow::Value>> &values, std::list<ValueFlow::Value> *result)
-{
-    if (!expr)
-        return false;
-
-    // strlen(arg)..
-    if (expr->str() == "(" && Token::Match(expr->previous(), "strlen ( %name% )")) {
-        const Token *arg = expr->next();
-        if (arg->str().compare(0,3,"arg") != 0 || arg->str().size() != 4)
-            return false;
-        const char n = arg->str()[3];
-        if (n < '1' || n - '1' >= values.size())
-            return false;
-        for (const ValueFlow::Value &argvalue : values[n - '1']) {
-            if (argvalue.isTokValue() && argvalue.tokvalue->tokType() == Token::eString) {
-                ValueFlow::Value res(argvalue); // copy all "inconclusive", "condition", etc attributes
-                // set return value..
-                res.valueType = ValueFlow::Value::INT;
-                res.tokvalue = nullptr;
-                res.intvalue = Token::getStrLength(argvalue.tokvalue);
-                result->emplace_back(std::move(res));
-            }
-        }
-        return !result->empty();
-    }
-
-    // unary operands
-    if (expr->astOperand1() && !expr->astOperand2()) {
-        std::list<ValueFlow::Value> opvalues;
-        if (!evaluate(expr->astOperand1(), values, &opvalues))
-            return false;
-        if (expr->str() == "+") {
-            result->swap(opvalues);
-            return true;
-        }
-        if (expr->str() == "-") {
-            for (ValueFlow::Value v: opvalues) {
-                if (v.isIntValue()) {
-                    v.intvalue = -v.intvalue;
-                    result->emplace_back(std::move(v));
-                }
-            }
-            return true;
-        }
-        return false;
-    }
-    // binary/ternary operands
-    if (expr->astOperand1() && expr->astOperand2()) {
-        std::list<ValueFlow::Value> lhsValues, rhsValues;
-        if (!evaluate(expr->astOperand1(), values, &lhsValues))
-            return false;
-        if (expr->str() != "?" && !evaluate(expr->astOperand2(), values, &rhsValues))
-            return false;
-
-        for (const ValueFlow::Value &val1 : lhsValues) {
-            if (!val1.isIntValue())
-                continue;
-            if (expr->str() == "?") {
-                rhsValues.clear();
-                const Token *expr2 = val1.intvalue ? expr->astOperand2()->astOperand1() : expr->astOperand2()->astOperand2();
-                if (!evaluate(expr2, values, &rhsValues))
-                    continue;
-                result->insert(result->end(), rhsValues.begin(), rhsValues.end());
-                continue;
-            }
-
-            for (const ValueFlow::Value &val2 : rhsValues) {
-                if (!val2.isIntValue())
-                    continue;
-
-                if (val1.varId != 0 && val2.varId != 0) {
-                    if (val1.varId != val2.varId || val1.varvalue != val2.varvalue)
-                        continue;
-                }
-
-                if (expr->str() == "+")
-                    result->emplace_back(ValueFlow::Value(val1.intvalue + val2.intvalue));
-                else if (expr->str() == "-")
-                    result->emplace_back(ValueFlow::Value(val1.intvalue - val2.intvalue));
-                else if (expr->str() == "*")
-                    result->emplace_back(ValueFlow::Value(val1.intvalue * val2.intvalue));
-                else if (expr->str() == "/" && val2.intvalue != 0)
-                    result->emplace_back(ValueFlow::Value(val1.intvalue / val2.intvalue));
-                else if (expr->str() == "%" && val2.intvalue != 0)
-                    result->emplace_back(ValueFlow::Value(val1.intvalue % val2.intvalue));
-                else if (expr->str() == "&")
-                    result->emplace_back(ValueFlow::Value(val1.intvalue & val2.intvalue));
-                else if (expr->str() == "|")
-                    result->emplace_back(ValueFlow::Value(val1.intvalue | val2.intvalue));
-                else if (expr->str() == "^")
-                    result->emplace_back(ValueFlow::Value(val1.intvalue ^ val2.intvalue));
-                else if (expr->str() == "==")
-                    result->emplace_back(ValueFlow::Value(val1.intvalue == val2.intvalue));
-                else if (expr->str() == "!=")
-                    result->emplace_back(ValueFlow::Value(val1.intvalue != val2.intvalue));
-                else if (expr->str() == "<")
-                    result->emplace_back(ValueFlow::Value(val1.intvalue < val2.intvalue));
-                else if (expr->str() == ">")
-                    result->emplace_back(ValueFlow::Value(val1.intvalue > val2.intvalue));
-                else if (expr->str() == ">=")
-                    result->emplace_back(ValueFlow::Value(val1.intvalue >= val2.intvalue));
-                else if (expr->str() == "<=")
-                    result->emplace_back(ValueFlow::Value(val1.intvalue <= val2.intvalue));
-                else if (expr->str() == "&&")
-                    result->emplace_back(ValueFlow::Value(val1.intvalue && val2.intvalue));
-                else if (expr->str() == "||")
-                    result->emplace_back(ValueFlow::Value(val1.intvalue || val2.intvalue));
-                else if (expr->str() == "<<")
-                    result->emplace_back(ValueFlow::Value(val1.intvalue << val2.intvalue));
-                else if (expr->str() == ">>")
-                    result->emplace_back(ValueFlow::Value(val1.intvalue >> val2.intvalue));
-                else
-                    return false;
-                combineValueProperties(val1, val2, &result->back());
-            }
-        }
-        return !result->empty();
-    }
-    if (expr->str().compare(0,3,"arg")==0) {
-        *result = values[expr->str()[3] - '1'];
-        return true;
-    }
-    if (expr->isNumber()) {
-        result->emplace_back(ValueFlow::Value(MathLib::toLongNumber(expr->str())));
-        result->back().setKnown();
-        return true;
-    } else if (expr->tokType() == Token::eChar) {
-        result->emplace_back(ValueFlow::Value(MathLib::toLongNumber(expr->str())));
-        result->back().setKnown();
-        return true;
-    }
-    return false;
-}
-
-static std::list<ValueFlow::Value> getFunctionArgumentValues(const Token *argtok)
+static std::list<ValueFlow::Value> getFunctionArgumentValues(const Token* argtok)
 {
     std::list<ValueFlow::Value> argvalues(argtok->values());
     removeImpossible(argvalues);
@@ -5450,324 +5595,484 @@ static std::list<ValueFlow::Value> getFunctionArgumentValues(const Token *argtok
     return argvalues;
 }
 
-static void valueFlowLibraryFunction(Token *tok, const std::string &returnValue, const Settings *settings)
+static void valueFlowLibraryFunction(Token* tok, const std::string& returnValue, const Settings& settings)
 {
-    std::vector<std::list<ValueFlow::Value>> argValues;
-    for (const Token *argtok : getArguments(tok->previous())) {
-        argValues.emplace_back(getFunctionArgumentValues(argtok));
-        if (argValues.back().empty())
-            return;
+    std::unordered_map<nonneg int, std::list<ValueFlow::Value>> argValues;
+    int argn = 1;
+    for (const Token* argtok : getArguments(tok->previous())) {
+        argValues[argn] = getFunctionArgumentValues(argtok);
+        argn++;
     }
     if (returnValue.find("arg") != std::string::npos && argValues.empty())
         return;
-
-    TokenList tokenList(settings);
-    {
-        const std::string code = "return " + returnValue + ";";
-        std::istringstream istr(code);
-        if (!tokenList.createTokens(istr))
+    productParams(settings, argValues, [&](const std::unordered_map<nonneg int, ValueFlow::Value>& arg) {
+        ValueFlow::Value value = evaluateLibraryFunction(arg, returnValue, settings, tok->isCpp());
+        if (value.isUninitValue())
             return;
-    }
-
-    // combine operators, set links, etc..
-    std::stack<Token *> lpar;
-    for (Token *tok2 = tokenList.front(); tok2; tok2 = tok2->next()) {
-        if (Token::Match(tok2, "[!<>=] =")) {
-            tok2->str(tok2->str() + "=");
-            tok2->deleteNext();
-        } else if (tok2->str() == "(")
-            lpar.push(tok2);
-        else if (tok2->str() == ")") {
-            if (lpar.empty())
-                return;
-            Token::createMutualLinks(lpar.top(), tok2);
-            lpar.pop();
+        ValueFlow::Value::ValueKind kind = ValueFlow::Value::ValueKind::Known;
+        for (auto&& p : arg) {
+            if (p.second.isPossible())
+                kind = p.second.valueKind;
+            if (p.second.isInconclusive()) {
+                kind = p.second.valueKind;
+                break;
+            }
         }
-    }
-    if (!lpar.empty())
-        return;
-
-    // Evaluate expression
-    tokenList.createAst();
-    std::list<ValueFlow::Value> results;
-    if (evaluate(tokenList.front()->astOperand1(), argValues, &results))
-        setTokenValues(tok, results, settings);
+        if (value.isImpossible() && kind != ValueFlow::Value::ValueKind::Known)
+            return;
+        if (!value.isImpossible())
+            value.valueKind = kind;
+        setTokenValue(tok, std::move(value), settings);
+    });
 }
 
-static void valueFlowSubFunction(TokenList* tokenlist, ErrorLogger* errorLogger, const Settings* settings)
+static void valueFlowSubFunction(const TokenList& tokenlist,
+                                 const SymbolDatabase& symboldatabase,
+                                 ErrorLogger& errorLogger,
+                                 const Settings& settings)
 {
-    for (Token *tok = tokenlist->front(); tok; tok = tok->next()) {
-        if (!Token::Match(tok, "%name% ("))
+    int id = 0;
+    for (auto it = symboldatabase.functionScopes.crbegin(); it != symboldatabase.functionScopes.crend(); ++it) {
+        const Scope* scope = *it;
+        const Function* function = scope->function;
+        if (!function)
             continue;
+        for (auto* tok = const_cast<Token*>(scope->bodyStart); tok != scope->bodyEnd; tok = tok->next()) {
+            if (tok->isKeyword() || !Token::Match(tok, "%name% ("))
+                continue;
 
-        const Function * const calledFunction = tok->function();
-        if (!calledFunction) {
-            // library function?
-            const std::string& returnValue(settings->library.returnValue(tok));
-            if (!returnValue.empty())
-                valueFlowLibraryFunction(tok->next(), returnValue, settings);
-            continue;
-        }
+            const Function* const calledFunction = tok->function();
+            if (!calledFunction) {
+                // library function?
+                const std::string& returnValue(settings.library.returnValue(tok));
+                if (!returnValue.empty())
+                    valueFlowLibraryFunction(tok->next(), returnValue, settings);
+                continue;
+            }
 
-        const Scope * const calledFunctionScope = calledFunction->functionScope;
-        if (!calledFunctionScope)
-            continue;
+            const Scope* const calledFunctionScope = calledFunction->functionScope;
+            if (!calledFunctionScope)
+                continue;
 
-        // TODO: Rewrite this. It does not work well to inject 1 argument at a time.
-        const std::vector<const Token *> &callArguments = getArguments(tok);
-        for (int argnr = 0U; argnr < callArguments.size(); ++argnr) {
-            const Token *argtok = callArguments[argnr];
-            // Get function argument
-            const Variable * const argvar = calledFunction->getArgumentVar(argnr);
-            if (!argvar)
-                break;
+            id++;
+            std::unordered_map<const Variable*, std::list<ValueFlow::Value>> argvars;
+            // TODO: Rewrite this. It does not work well to inject 1 argument at a time.
+            const std::vector<const Token*>& callArguments = getArguments(tok);
+            for (int argnr = 0U; argnr < callArguments.size(); ++argnr) {
+                const Token* argtok = callArguments[argnr];
+                // Get function argument
+                const Variable* const argvar = calledFunction->getArgumentVar(argnr);
+                if (!argvar)
+                    break;
 
-            // passing value(s) to function
-            std::list<ValueFlow::Value> argvalues(getFunctionArgumentValues(argtok));
+                // passing value(s) to function
+                std::list<ValueFlow::Value> argvalues(getFunctionArgumentValues(argtok));
 
-            // Don't forward lifetime values
-            argvalues.remove_if(std::mem_fn(&ValueFlow::Value::isLifetimeValue));
+                // Remove non-local lifetimes
+                argvalues.remove_if([](const ValueFlow::Value& v) {
+                    if (v.isLifetimeValue())
+                        return !v.isLocalLifetimeValue() && !v.isSubFunctionLifetimeValue();
+                    return false;
+                });
+                // Remove uninit values if argument is passed by value
+                if (argtok->variable() && !argtok->variable()->isPointer() && argvalues.size() == 1 &&
+                    argvalues.front().isUninitValue()) {
+                    if (CheckUninitVar::isVariableUsage(argtok, settings.library, false, CheckUninitVar::Alloc::NO_ALLOC, 0))
+                        continue;
+                }
 
-            if (argvalues.empty())
-                continue;
+                if (argvalues.empty())
+                    continue;
 
-            // Error path..
-            for (ValueFlow::Value &v : argvalues) {
-                const std::string nr = MathLib::toString(argnr + 1) + getOrdinalText(argnr + 1);
-
-                v.errorPath.emplace_back(argtok,
-                                         "Calling function '" +
-                                         calledFunction->name() +
-                                         "', " +
-                                         nr +
-                                         " argument '" +
-                                         argtok->expressionString() +
-                                         "' value is " +
-                                         v.infoString());
-            }
+                // Error path..
+                for (ValueFlow::Value& v : argvalues) {
+                    const std::string nr = std::to_string(argnr + 1) + getOrdinalText(argnr + 1);
+
+                    v.errorPath.emplace_back(argtok,
+                                             "Calling function '" + calledFunction->name() + "', " + nr + " argument '" +
+                                             argtok->expressionString() + "' value is " + v.infoString());
+                    v.path = (256 * v.path) + (id % 256);
+                    // Change scope of lifetime values
+                    if (v.isLifetimeValue())
+                        v.lifetimeScope = ValueFlow::Value::LifetimeScope::SubFunction;
+                }
 
-            // passed values are not "known"..
-            lowerToPossible(argvalues);
+                // passed values are not "known"..
+                lowerToPossible(argvalues);
 
-            valueFlowInjectParameter(tokenlist, errorLogger, settings, argvar, calledFunctionScope, argvalues);
-            // FIXME: We need to rewrite the valueflow analysis to better handle multiple arguments
-            if (!argvalues.empty())
-                break;
+                argvars[argvar] = std::move(argvalues);
+            }
+            valueFlowInjectParameter(tokenlist, errorLogger, settings, calledFunctionScope, argvars);
         }
     }
 }
 
-static void valueFlowFunctionDefaultParameter(TokenList *tokenlist, SymbolDatabase* symboldatabase, ErrorLogger *errorLogger, const Settings *settings)
+static void valueFlowFunctionDefaultParameter(const TokenList& tokenlist, const SymbolDatabase& symboldatabase, ErrorLogger& errorLogger, const Settings& settings)
 {
-    if (!tokenlist->isCPP())
+    if (!tokenlist.isCPP())
         return;
 
-    for (const Scope* scope : symboldatabase->functionScopes) {
+    for (const Scope* scope : symboldatabase.functionScopes) {
         const Function* function = scope->function;
         if (!function)
             continue;
-        for (std::size_t arg = function->minArgCount(); arg < function->argCount(); arg++) {
+        for (nonneg int arg = function->minArgCount(); arg < function->argCount(); arg++) {
             const Variable* var = function->getArgumentVar(arg);
-            if (var && var->hasDefault() && Token::Match(var->nameToken(), "%var% = %num%|%str% [,)]")) {
+            if (var && var->hasDefault() && Token::Match(var->nameToken(), "%var% = %num%|%str%|%char%|%name% [,)]")) {
                 const std::list<ValueFlow::Value> &values = var->nameToken()->tokAt(2)->values();
                 std::list<ValueFlow::Value> argvalues;
                 for (const ValueFlow::Value &value : values) {
+                    if (!value.isKnown())
+                        continue;
                     ValueFlow::Value v(value);
                     v.defaultArg = true;
-                    v.changeKnownToPossible();
-                    if (v.isPossible())
-                        argvalues.push_back(v);
+                    v.setPossible();
+                    argvalues.push_back(std::move(v));
                 }
                 if (!argvalues.empty())
-                    valueFlowInjectParameter(tokenlist, errorLogger, settings, var, scope, argvalues);
+                    valueFlowInjectParameter(tokenlist, errorLogger, settings, var, scope, std::move(argvalues));
             }
         }
     }
 }
 
-static bool isKnown(const Token * tok)
+static const ValueFlow::Value* getKnownValueFromToken(const Token* tok)
+{
+    if (!tok)
+        return nullptr;
+    auto it = std::find_if(tok->values().begin(), tok->values().end(), [&](const ValueFlow::Value& v) {
+        return (v.isIntValue() || v.isContainerSizeValue() || v.isFloatValue()) && v.isKnown();
+    });
+    if (it == tok->values().end())
+        return nullptr;
+    return std::addressof(*it);
+}
+
+static std::vector<ValueFlow::Value> getCommonValuesFromTokens(const std::vector<const Token*>& toks)
+{
+    if (toks.empty())
+        return {};
+    std::vector<ValueFlow::Value> result;
+    std::copy_if(toks.front()->values().begin(),
+                 toks.front()->values().end(),
+                 std::back_inserter(result),
+                 [&](const ValueFlow::Value& v) {
+        if (!v.isKnown() && !v.isImpossible())
+            return false;
+        return (v.isIntValue() || v.isContainerSizeValue() || v.isFloatValue());
+    });
+    std::for_each(toks.begin() + 1, toks.end(), [&](const Token* tok) {
+        auto it = std::remove_if(result.begin(), result.end(), [&](const ValueFlow::Value& v) {
+            return std::none_of(tok->values().begin(), tok->values().end(), [&](const ValueFlow::Value& v2) {
+                return v.equalValue(v2) && v.valueKind == v2.valueKind;
+            });
+        });
+        result.erase(it, result.end());
+    });
+    return result;
+}
+
+static void setFunctionReturnValue(const Function* f,
+                                   Token* tok,
+                                   ValueFlow::Value v,
+                                   const Settings& settings,
+                                   bool known = true)
 {
-    return tok && tok->hasKnownIntValue();
+    if (f->hasVirtualSpecifier()) {
+        if (v.isImpossible())
+            return;
+        v.setPossible();
+    } else if (!v.isImpossible() && known) {
+        v.setKnown();
+    }
+    v.errorPath.emplace_back(tok, "Calling function '" + f->name() + "' returns " + v.toString());
+    setTokenValue(tok, std::move(v), settings);
 }
 
-static void valueFlowFunctionReturn(TokenList *tokenlist, ErrorLogger *errorLogger)
+static void valueFlowFunctionReturn(TokenList& tokenlist, ErrorLogger& errorLogger, const Settings& settings)
 {
-    for (Token *tok = tokenlist->back(); tok; tok = tok->previous()) {
-        if (tok->str() != "(" || !tok->astOperand1() || !tok->astOperand1()->function())
+    for (Token* tok = tokenlist.back(); tok; tok = tok->previous()) {
+        if (tok->str() != "(" || !tok->astOperand1() || tok->isCast())
+            continue;
+
+        const Function* function = nullptr;
+        if (Token::Match(tok->previous(), "%name% ("))
+            function = tok->previous()->function();
+        else
+            function = tok->astOperand1()->function();
+        if (!function)
+            continue;
+        // TODO: Check if member variable is a pointer or reference
+        if (function->isImplicitlyVirtual() && !function->hasFinalSpecifier())
             continue;
 
         if (tok->hasKnownValue())
             continue;
 
-        // Arguments..
-        std::vector<MathLib::bigint> parvalues;
-        if (tok->astOperand2()) {
-            const Token *partok = tok->astOperand2();
-            while (partok && partok->str() == "," && isKnown(partok->astOperand2()))
-                partok = partok->astOperand1();
-            if (!isKnown(partok))
-                continue;
-            parvalues.push_back(partok->values().front().intvalue);
-            partok = partok->astParent();
-            while (partok && partok->str() == ",") {
-                parvalues.push_back(partok->astOperand2()->values().front().intvalue);
-                partok = partok->astParent();
-            }
-            if (partok != tok)
-                continue;
+        std::vector<const Token*> returns = Function::findReturns(function);
+        if (returns.empty())
+            continue;
+
+        bool hasKnownValue = false;
+
+        for (const ValueFlow::Value& v : getCommonValuesFromTokens(returns)) {
+            setFunctionReturnValue(function, tok, v, settings, false);
+            if (v.isKnown())
+                hasKnownValue = true;
         }
 
-        // Get scope and args of function
-        const Function * const function = tok->astOperand1()->function();
-        const Scope * const functionScope = function->functionScope;
-        if (!functionScope || !Token::simpleMatch(functionScope->bodyStart, "{ return")) {
-            if (functionScope && tokenlist->getSettings()->debugwarnings && Token::findsimplematch(functionScope->bodyStart, "return", functionScope->bodyEnd))
-                bailout(tokenlist, errorLogger, tok, "function return; nontrivial function body");
+        if (hasKnownValue)
             continue;
-        }
+
+        // Arguments..
+        std::vector<const Token*> arguments = getArguments(tok);
 
         ProgramMemory programMemory;
-        for (std::size_t i = 0; i < parvalues.size(); ++i) {
-            const Variable * const arg = function->getArgumentVar(i);
-            if (!arg || !Token::Match(arg->typeStartToken(), "%type% %name% ,|)")) {
-                if (tokenlist->getSettings()->debugwarnings)
+        for (std::size_t i = 0; i < arguments.size(); ++i) {
+            const Variable* const arg = function->getArgumentVar(i);
+            if (!arg) {
+                if (settings.debugwarnings)
                     bailout(tokenlist, errorLogger, tok, "function return; unhandled argument type");
                 programMemory.clear();
                 break;
             }
-            programMemory.setIntValue(arg->declarationId(), parvalues[i]);
+            const ValueFlow::Value* v = getKnownValueFromToken(arguments[i]);
+            if (!v)
+                continue;
+            programMemory.setValue(arg->nameToken(), *v);
         }
-        if (programMemory.empty() && !parvalues.empty())
+        if (programMemory.empty() && !arguments.empty())
             continue;
+        std::vector<ValueFlow::Value> values = execute(function->functionScope, programMemory, settings);
+        for (const ValueFlow::Value& v : values) {
+            if (v.isUninitValue())
+                continue;
+            setFunctionReturnValue(function, tok, v, settings);
+        }
+    }
+}
 
-        // Determine return value of subfunction..
-        MathLib::bigint result = 0;
-        bool error = false;
-        execute(functionScope->bodyStart->next()->astOperand1(),
-                &programMemory,
-                &result,
-                &error);
-        if (!error) {
-            ValueFlow::Value v(result);
-            if (function->hasVirtualSpecifier())
-                v.setPossible();
-            else
-                v.setKnown();
-            setTokenValue(tok, v, tokenlist->getSettings());
+static bool needsInitialization(const Variable* var)
+{
+    if (!var)
+        return false;
+    if (var->hasDefault())
+        return false;
+    if (var->isPointer())
+        return true;
+    if (var->type() && var->type()->isUnionType())
+        return false;
+    if (!var->nameToken()->isCpp())
+        return true;
+    if (var->type() && var->type()->needInitialization == Type::NeedInitialization::True)
+        return true;
+    if (var->valueType()) {
+        if (var->valueType()->isPrimitive())
+            return true;
+        if (var->valueType()->type == ValueType::Type::POD)
+            return true;
+        if (var->valueType()->type == ValueType::Type::ITERATOR)
+            return true;
+        if (var->isStlType() && var->isArray()) {
+            if (const Token* ctt = var->valueType()->containerTypeToken) {
+                if (ctt->isStandardType())
+                    return true;
+                const Type* ct = ctt->type();
+                if (ct && ct->needInitialization == Type::NeedInitialization::True)
+                    return true;
+            }
         }
     }
+    return false;
 }
 
-static void valueFlowUninit(TokenList *tokenlist, SymbolDatabase * /*symbolDatabase*/, ErrorLogger *errorLogger, const Settings *settings)
+static void addToErrorPath(ValueFlow::Value& value, const ValueFlow::Value& from)
 {
-    for (Token *tok = tokenlist->front(); tok; tok = tok->next()) {
-        if (!Token::Match(tok,"[;{}] %type%"))
-            continue;
+    std::unordered_set<const Token*> locations;
+    std::transform(value.errorPath.cbegin(),
+                   value.errorPath.cend(),
+                   std::inserter(locations, locations.begin()),
+                   [](const ErrorPathItem& e) {
+        return e.first;
+    });
+    if (from.condition && !value.condition)
+        value.condition = from.condition;
+    std::copy_if(from.errorPath.cbegin(),
+                 from.errorPath.cend(),
+                 std::back_inserter(value.errorPath),
+                 [&](const ErrorPathItem& e) {
+        return locations.insert(e.first).second;
+    });
+}
+
+static std::vector<Token*> findAllUsages(const Variable* var,
+                                         Token* start,
+                                         const Library& library)
+{
+    // std::vector<Token*> result;
+    const Scope* scope = var->scope();
+    if (!scope)
+        return {};
+    return findTokensSkipDeadCode(library, start, scope->bodyEnd, [&](const Token* tok) {
+        return tok->varId() == var->declarationId();
+    });
+}
+
+static Token* findStartToken(const Variable* var, Token* start, const Library& library)
+{
+    std::vector<Token*> uses = findAllUsages(var, start, library);
+    if (uses.empty())
+        return start;
+    Token* first = uses.front();
+    if (Token::findmatch(start, "goto|asm|setjmp|longjmp", first))
+        return start;
+    if (first != var->nameToken()) {
+        // if this is lhs in assignment then set first to the first token in LHS expression
+        Token* temp = first;
+        while (Token::Match(temp->astParent(), "[&*(]") && precedes(temp->astParent(), temp))
+            temp = temp->astParent();
+        if (Token::simpleMatch(temp->astParent(), "=") && precedes(temp, temp->astParent()))
+            first = temp;
+    }
+    // If there is only one usage
+    if (uses.size() == 1)
+        return first->previous();
+    const Scope* scope = first->scope();
+    // If first usage is in variable scope
+    if (scope == var->scope()) {
+        bool isLoopExpression = false;
+        for (const Token* parent = first; parent; parent = parent->astParent()) {
+            if (Token::simpleMatch(parent->astParent(), ";") &&
+                Token::simpleMatch(parent->astParent()->astParent(), ";") &&
+                Token::simpleMatch(parent->astParent()->astParent()->astParent(), "(") &&
+                Token::simpleMatch(parent->astParent()->astParent()->astParent()->astOperand1(), "for (") &&
+                parent == parent->astParent()->astParent()->astParent()->astOperand2()->astOperand2()->astOperand2()) {
+                isLoopExpression = true;
+            }
+        }
+        return isLoopExpression ? start : first->previous();
+    }
+    // If all uses are in the same scope
+    if (std::all_of(uses.begin() + 1, uses.end(), [&](const Token* tok) {
+        return tok->scope() == scope;
+    }))
+        return first->previous();
+    // Compute the outer scope
+    while (scope && scope->nestedIn != var->scope()) {
+        if (scope->type == ScopeType::eLambda && !Token::simpleMatch(scope->bodyEnd, "} ("))
+            return start;
+        scope = scope->nestedIn;
+    }
+    if (!scope || (scope->type == ScopeType::eLambda && !Token::simpleMatch(scope->bodyEnd, "} (")))
+        return start;
+    auto* tok = const_cast<Token*>(scope->bodyStart);
+    if (!tok)
+        return start;
+    if (Token::simpleMatch(tok->tokAt(-2), "} else {"))
+        tok = tok->linkAt(-2);
+    if (Token::simpleMatch(tok->previous(), ") {"))
+        return tok->linkAt(-1)->previous();
+    return tok;
+}
+
+static void valueFlowUninit(TokenList& tokenlist, ErrorLogger& errorLogger, const Settings& settings)
+{
+    for (Token *tok = tokenlist.front(); tok; tok = tok->next()) {
         if (!tok->scope()->isExecutable())
             continue;
-        const Token *vardecl = tok->next();
-        bool stdtype = false;
-        bool pointer = false;
-        while (Token::Match(vardecl, "%name%|::|*") && vardecl->varId() == 0) {
-            stdtype |= vardecl->isStandardType();
-            pointer |= vardecl->str() == "*";
-            vardecl = vardecl->next();
-        }
-        // if (!stdtype && !pointer)
-        // continue;
-        if (!Token::Match(vardecl, "%var% ;"))
+        if (!Token::Match(tok, "%var% ;|["))
             continue;
-        if (Token::Match(vardecl, "%varid% ; %varid% =", vardecl->varId()))
+        const Variable* var = tok->variable();
+        if (!var)
             continue;
-        const Variable *var = vardecl->variable();
-        if (!var || var->nameToken() != vardecl)
+        if (var->nameToken() != tok || var->isInit())
             continue;
-        if ((!var->isPointer() && var->type() && var->type()->needInitialization != Type::NeedInitialization::True) ||
-            !var->isLocal() || var->isStatic() || var->isExtern() || var->isReference() || var->isThrow())
+        if (!needsInitialization(var))
             continue;
-        if (!var->type() && !stdtype && !pointer)
+        if (!var->isLocal() || var->isStatic() || var->isExtern() || var->isReference() || var->isThrow())
             continue;
 
         ValueFlow::Value uninitValue;
         uninitValue.setKnown();
-        uninitValue.valueType = ValueFlow::Value::UNINIT;
-        uninitValue.tokvalue = vardecl;
-        std::list<ValueFlow::Value> values;
-        values.push_back(uninitValue);
-
-        const bool constValue = true;
-        const bool subFunction = false;
-
-        valueFlowForwardVariable(vardecl->next(),
-                                 vardecl->scope()->bodyEnd,
-                                 var,
-                                 vardecl->varId(),
-                                 values,
-                                 constValue,
-                                 subFunction,
-                                 tokenlist,
-                                 errorLogger,
-                                 settings);
-    }
-}
+        uninitValue.valueType = ValueFlow::Value::ValueType::UNINIT;
+        uninitValue.tokvalue = tok;
+        if (var->isArray())
+            uninitValue.indirect = var->dimensions().size();
 
-static bool hasContainerSizeGuard(const Token *tok, nonneg int containerId)
-{
-    for (; tok && tok->astParent(); tok = tok->astParent()) {
-        const Token *parent = tok->astParent();
-        if (tok != parent->astOperand2())
-            continue;
-        if (!Token::Match(parent, "%oror%|&&|?"))
+        bool partial = false;
+
+        Token* start = findStartToken(var, tok->next(), settings.library);
+
+        std::map<Token*, ValueFlow::Value> partialReads;
+        if (const Scope* scope = var->typeScope()) {
+            if (Token::findsimplematch(scope->bodyStart, "union", scope->bodyEnd))
+                continue;
+            for (const Variable& memVar : scope->varlist) {
+                if (!memVar.isPublic())
+                    continue;
+                // Skip array since we can't track partial initialization from nested subexpressions
+                if (memVar.isArray())
+                    continue;
+                if (!needsInitialization(&memVar)) {
+                    if (!var->isPointer())
+                        partial = true;
+                    continue;
+                }
+                auto partialReadsAnalyzer = std::make_shared<PartialReadContainer>();
+                auto analyzer = makeMemberExpressionAnalyzer(memVar.nameToken()->str(), tok, uninitValue, partialReadsAnalyzer, settings);
+                valueFlowGenericForward(start, tok->scope()->bodyEnd, analyzer, tokenlist, errorLogger, settings);
+
+                for (auto&& p : *partialReadsAnalyzer) {
+                    Token* tok2 = p.first;
+                    const ValueFlow::Value& v = p.second;
+                    // Try to insert into map
+                    auto pp = partialReads.emplace(tok2, v);
+                    ValueFlow::Value& v2 = pp.first->second;
+                    const bool inserted = pp.second;
+                    // Merge the two values if it is already in map
+                    if (!inserted) {
+                        if (v.valueType != v2.valueType)
+                            continue;
+                        addToErrorPath(v2, v);
+                    }
+                    v2.subexpressions.push_back(memVar.nameToken()->str());
+                }
+            }
+        }
+
+        for (auto&& p : partialReads) {
+            Token* tok2 = p.first;
+            ValueFlow::Value& v = p.second;
+
+            setTokenValue(tok2, std::move(v), settings);
+        }
+
+        if (partial)
             continue;
-        // is container found in lhs?
-        bool found = false;
-        visitAstNodes(parent->astOperand1(),
-        [&](const Token *t) {
-            if (t->varId() == containerId)
-                found = true;
-            return found ? ChildrenToVisit::done : ChildrenToVisit::op1_and_op2;
-        });
-        if (found)
-            return true;
+
+        valueFlowForward(start, tok->scope()->bodyEnd, var->nameToken(), std::move(uninitValue), tokenlist, errorLogger, settings);
     }
-    return false;
 }
 
-static bool isContainerSize(const Token* tok)
-{
-    if (!Token::Match(tok, "%var% . %name% ("))
-        return false;
-    if (!astIsContainer(tok))
-        return false;
-    if (tok->valueType()->container && tok->valueType()->container->getYield(tok->strAt(2)) == Library::Container::Yield::SIZE)
-        return true;
-    if (Token::Match(tok->tokAt(2), "size|length ( )"))
-        return true;
-    return false;
-}
+static bool isContainerSizeChanged(const Token* expr,
+                                   const Token* start,
+                                   const Token* end,
+                                   int indirect,
+                                   const Settings& settings,
+                                   int depth = 20);
 
-static bool isContainerEmpty(const Token* tok)
+static bool isContainerSizeChangedByFunction(const Token* tok,
+                                             int indirect,
+                                             const Settings& settings,
+                                             int depth = 20)
 {
-    if (!Token::Match(tok, "%var% . %name% ("))
+    if (!tok->valueType())
         return false;
     if (!astIsContainer(tok))
         return false;
-    if (tok->valueType()->container && tok->valueType()->container->getYield(tok->strAt(2)) == Library::Container::Yield::EMPTY)
-        return true;
-    if (Token::simpleMatch(tok->tokAt(2), "empty ( )"))
-        return true;
-    return false;
-}
-
-static bool isContainerSizeChanged(nonneg int varId, const Token *start, const Token *end, int depth = 20);
-
-static bool isContainerSizeChangedByFunction(const Token *tok, int depth = 20)
-{
-    if (!tok->valueType() || !tok->valueType()->container)
-        return false;
     // If we are accessing an element then we are not changing the container size
     if (Token::Match(tok, "%name% . %name% (")) {
-        Library::Container::Yield yield = tok->valueType()->container->getYield(tok->strAt(2));
+        const Library::Container::Yield yield = getLibraryContainer(tok)->getYield(tok->strAt(2));
         if (yield != Library::Container::Yield::NO_YIELD)
             return false;
     }
@@ -5775,19 +6080,22 @@ static bool isContainerSizeChangedByFunction(const Token *tok, int depth = 20)
         return false;
 
     // address of variable
-    const bool addressOf = tok->astParent() && tok->astParent()->isUnaryOp("&");
+    const bool addressOf = tok->valueType()->pointer || (tok->astParent() && tok->astParent()->isUnaryOp("&"));
 
     int narg;
     const Token * ftok = getTokenArgumentFunction(tok, narg);
     if (!ftok)
         return false; // not a function => variable not changed
     const Function * fun = ftok->function();
-    if (fun) {
+    if (fun && !fun->isImplicitlyVirtual()) {
         const Variable *arg = fun->getArgumentVar(narg);
         if (arg) {
-            if (!arg->isReference() && !addressOf)
+            const bool isPointer = addressOf || indirect > 0;
+            if (!arg->isReference() && !isPointer)
+                return false;
+            if (!isPointer && arg->isConst())
                 return false;
-            if (arg->isConst())
+            if (arg->valueType() && arg->valueType()->constness == 1)
                 return false;
             const Scope * scope = fun->functionScope;
             if (scope) {
@@ -5795,320 +6103,742 @@ static bool isContainerSizeChangedByFunction(const Token *tok, int depth = 20)
                 if (!arg->nameToken())
                     return false;
                 if (depth > 0)
-                    return isContainerSizeChanged(arg->declarationId(), scope->bodyStart, scope->bodyEnd, depth - 1);
-            }
+                    return isContainerSizeChanged(arg->nameToken(),
+                                                  scope->bodyStart,
+                                                  scope->bodyEnd,
+                                                  addressOf ? indirect + 1 : indirect,
+                                                  settings,
+                                                  depth - 1);
+            }
+            // Don't know => Safe guess
+            return true;
         }
     }
 
     bool inconclusive = false;
-    const bool isChanged = isVariableChangedByFunctionCall(tok, 0, nullptr, &inconclusive);
+    const bool isChanged = isVariableChangedByFunctionCall(tok, indirect, settings, &inconclusive);
     return (isChanged || inconclusive);
 }
 
-static void valueFlowContainerReverse(Token *tok, nonneg int containerId, const ValueFlow::Value &value, const Settings *settings)
+static const Token* parseBinaryIntOp(const Token* expr,
+                                     const std::function<std::vector<MathLib::bigint>(const Token*)>& eval,
+                                     MathLib::bigint& known)
 {
-    while (nullptr != (tok = tok->previous())) {
-        if (Token::Match(tok, "[{}]"))
-            break;
-        if (Token::Match(tok, "return|break|continue"))
-            break;
-        if (tok->varId() != containerId)
-            continue;
-        if (Token::Match(tok, "%name% ="))
-            break;
-        if (isContainerSizeChangedByFunction(tok))
-            break;
-        if (!tok->valueType() || !tok->valueType()->container)
-            break;
-        if (Token::Match(tok, "%name% . %name% (") && tok->valueType()->container->getAction(tok->strAt(2)) != Library::Container::Action::NO_ACTION)
-            break;
-        if (!hasContainerSizeGuard(tok, containerId))
-            setTokenValue(tok, value, settings);
+    if (!expr)
+        return nullptr;
+    if (!expr->astOperand1() || !expr->astOperand2())
+        return nullptr;
+    if (expr->astOperand1()->exprId() == 0 && expr->astOperand2()->exprId() == 0)
+        return nullptr;
+    std::vector<MathLib::bigint> x1 = eval(expr->astOperand1());
+    if (expr->astOperand1()->exprId() == 0 && x1.empty())
+        return nullptr;
+    std::vector<MathLib::bigint> x2 = eval(expr->astOperand2());
+    if (expr->astOperand2()->exprId() == 0 && x2.empty())
+        return nullptr;
+    const Token* varTok = nullptr;
+    if (!x1.empty() && x2.empty()) {
+        varTok = expr->astOperand2();
+        known = x1.front();
+    } else if (x1.empty() && !x2.empty()) {
+        varTok = expr->astOperand1();
+        known = x2.front();
     }
+    return varTok;
 }
 
-static void valueFlowContainerForward(Token *tok, nonneg int containerId, ValueFlow::Value value, const Settings *settings, bool cpp)
+const Token* ValueFlow::solveExprValue(const Token* expr,
+                                       const std::function<std::vector<MathLib::bigint>(const Token*)>& eval,
+                                       ValueFlow::Value& value)
 {
-    while (nullptr != (tok = tok->next())) {
-        if (Token::Match(tok, "[{}]"))
-            break;
-        if (Token::Match(tok, "while|for (")) {
-            const Token *start = tok->linkAt(1)->next();
-            if (!Token::simpleMatch(start->link(), "{"))
-                break;
-            if (isContainerSizeChanged(containerId, start, start->link()))
-                break;
+    if (!expr)
+        return nullptr;
+    if (!value.isIntValue() && !value.isIteratorValue() && !value.isSymbolicValue())
+        return expr;
+    if (value.isSymbolicValue() && !Token::Match(expr, "+|-"))
+        return expr;
+    MathLib::bigint intval = 0;
+    const Token* binaryTok = parseBinaryIntOp(expr, eval, intval);
+    const bool rhs = astIsRHS(binaryTok);
+    // If its on the rhs, then -1 multiplication is needed, which is not possible with simple delta analysis used currently for symbolic values
+    if (value.isSymbolicValue() && rhs && Token::simpleMatch(expr, "-"))
+        return expr;
+    if (binaryTok && expr->str().size() == 1) {
+        switch (expr->str()[0]) {
+        case '+': {
+            value.intvalue -= intval;
+            return ValueFlow::solveExprValue(binaryTok, eval, value);
         }
-        if (Token::simpleMatch(tok, ") {") && Token::Match(tok->link()->previous(), "while|for|if (")) {
-            const Token *start = tok->next();
-            if (isContainerSizeChanged(containerId, start, start->link()))
-                break;
-            tok = start->link();
-            if (Token::simpleMatch(tok, "} else {")) {
-                start = tok->tokAt(2);
-                if (isContainerSizeChanged(containerId, start, start->link()))
-                    break;
-                tok = start->link();
-            }
+        case '-': {
+            if (rhs)
+                value.intvalue = intval - value.intvalue;
+            else
+                value.intvalue += intval;
+            return ValueFlow::solveExprValue(binaryTok, eval, value);
         }
-        if (tok->varId() != containerId)
-            continue;
-        if (Token::Match(tok, "%name% ="))
-            break;
-        if (Token::Match(tok, "%name% +=")) {
-            if (!tok->valueType() || !tok->valueType()->container || !tok->valueType()->container->stdStringLike)
-                break;
-            const Token *rhs = tok->next()->astOperand2();
-            if (rhs->tokType() == Token::eString)
-                value.intvalue += Token::getStrLength(rhs);
-            else if (rhs->valueType() && rhs->valueType()->container && rhs->valueType()->container->stdStringLike) {
-                bool found = false;
-                for (const ValueFlow::Value &rhsval : rhs->values()) {
-                    if (rhsval.isKnown() && rhsval.isContainerSizeValue()) {
-                        value.intvalue += rhsval.intvalue;
-                        found = true;
-                    }
-                }
-                if (!found)
-                    break;
-            } else
+        case '*': {
+            if (intval == 0)
                 break;
+            value.intvalue /= intval;
+            return ValueFlow::solveExprValue(binaryTok, eval, value);
+        }
+        case '^': {
+            value.intvalue ^= intval;
+            return ValueFlow::solveExprValue(binaryTok, eval, value);
+        }
         }
-        if (isLikelyStreamRead(cpp, tok->astParent()))
-            break;
-        if (isContainerSizeChangedByFunction(tok))
-            break;
-        if (!tok->valueType() || !tok->valueType()->container)
-            break;
-        if (Token::Match(tok, "%name% . %name% (") && tok->valueType()->container->getAction(tok->strAt(2)) != Library::Container::Action::NO_ACTION)
-            break;
-        if (!hasContainerSizeGuard(tok, containerId))
-            setTokenValue(tok, value, settings);
     }
+    return expr;
+}
+
+bool ValueFlow::isContainerSizeChanged(const Token* tok, int indirect, const Settings& settings, int depth)
+{
+    if (!tok)
+        return false;
+    if (!tok->valueType() || !tok->valueType()->container)
+        return true;
+    if (astIsLHS(tok) && Token::Match(tok->astParent(), "%assign%|<<"))
+        return true;
+    if (astIsLHS(tok) && Token::simpleMatch(tok->astParent(), "["))
+        return tok->valueType()->container->stdAssociativeLike;
+    const Library::Container::Action action = astContainerAction(tok, settings.library);
+    switch (action) {
+    case Library::Container::Action::RESIZE:
+    case Library::Container::Action::CLEAR:
+    case Library::Container::Action::PUSH:
+    case Library::Container::Action::POP:
+    case Library::Container::Action::CHANGE:
+    case Library::Container::Action::INSERT:
+    case Library::Container::Action::ERASE:
+    case Library::Container::Action::APPEND:
+        return true;
+    case Library::Container::Action::NO_ACTION:
+        // Is this an unknown member function call?
+        if (astIsLHS(tok) && Token::Match(tok->astParent(), ". %name% (")) {
+            const Library::Container::Yield yield = astContainerYield(tok, settings.library);
+            return yield == Library::Container::Yield::NO_YIELD;
+        }
+        break;
+    case Library::Container::Action::FIND:
+    case Library::Container::Action::FIND_CONST:
+    case Library::Container::Action::CHANGE_CONTENT:
+    case Library::Container::Action::CHANGE_INTERNAL:
+        break;
+    }
+    return isContainerSizeChangedByFunction(tok, indirect, settings, depth);
 }
 
-static bool isContainerSizeChanged(nonneg int varId, const Token *start, const Token *end, int depth)
+static bool isContainerSizeChanged(const Token* expr,
+                                   const Token* start,
+                                   const Token* end,
+                                   int indirect,
+                                   const Settings& settings,
+                                   int depth)
 {
     for (const Token *tok = start; tok != end; tok = tok->next()) {
-        if (tok->varId() != varId)
+        if (tok->exprId() != expr->exprId() && !isAliasOf(tok, expr))
             continue;
-        if (!tok->valueType() || !tok->valueType()->container)
-            return true;
-        if (Token::Match(tok, "%name% %assign%|<<"))
-            return true;
-        if (Token::Match(tok, "%name% . %name% (")) {
-            Library::Container::Action action = tok->valueType()->container->getAction(tok->strAt(2));
-            switch (action) {
-            case Library::Container::Action::RESIZE:
-            case Library::Container::Action::CLEAR:
-            case Library::Container::Action::PUSH:
-            case Library::Container::Action::POP:
-            case Library::Container::Action::CHANGE:
-            case Library::Container::Action::INSERT:
-            case Library::Container::Action::ERASE:
-            case Library::Container::Action::CHANGE_INTERNAL:
-                return true;
-            case Library::Container::Action::NO_ACTION: // might be unknown action
-                return true;
-            case Library::Container::Action::FIND:
-            case Library::Container::Action::CHANGE_CONTENT:
-                break;
-            };
-        }
-        if (isContainerSizeChangedByFunction(tok, depth))
+        if (ValueFlow::isContainerSizeChanged(tok, indirect, settings, depth))
             return true;
     }
     return false;
 }
 
-static void valueFlowSmartPointer(TokenList *tokenlist, ErrorLogger * errorLogger, const Settings *settings)
+static void valueFlowSmartPointer(TokenList &tokenlist, ErrorLogger & errorLogger, const Settings &settings)
 {
-    for (Token *tok = tokenlist->front(); tok; tok = tok->next()) {
+    for (Token *tok = tokenlist.front(); tok; tok = tok->next()) {
         if (!tok->scope())
             continue;
         if (!tok->scope()->isExecutable())
             continue;
-        if (!tok->variable())
-            continue;
-        const Variable * var = tok->variable();
-        if (!var->isSmartPointer())
+        if (!astIsSmartPointer(tok))
             continue;
-        if (var->nameToken() == tok) {
-            if (Token::Match(tok, "%var% (|{") && tok->next()->astOperand2() && tok->next()->astOperand2()->str() != ",") {
-                Token * inTok = tok->next()->astOperand2();
-                std::list<ValueFlow::Value> values = inTok->values();
-                const bool constValue = inTok->isNumber();
-                valueFlowForwardAssign(inTok, var, values, constValue, true, tokenlist, errorLogger, settings);
-
-            } else if (Token::Match(tok, "%var% ;")) {
-                std::list<ValueFlow::Value> values;
-                ValueFlow::Value v(0);
-                v.setKnown();
-                values.push_back(v);
-                valueFlowForwardAssign(tok, var, values, false, true, tokenlist, errorLogger, settings);
+        if (tok->variable() && Token::Match(tok, "%var% (|{|;")) {
+            const Variable* var = tok->variable();
+            if (!var->isSmartPointer())
+                continue;
+            if (var->nameToken() == tok) {
+                if (Token::Match(tok, "%var% (|{") && tok->next()->astOperand2() &&
+                    tok->next()->astOperand2()->str() != ",") {
+                    Token* inTok = tok->next()->astOperand2();
+                    const std::list<ValueFlow::Value>& values = inTok->values();
+                    const bool constValue = inTok->isNumber();
+                    valueFlowForwardAssign(inTok, var, values, constValue, true, tokenlist, errorLogger, settings);
+
+                } else if (Token::Match(tok, "%var% ;")) {
+                    ValueFlow::Value v(0);
+                    v.setKnown();
+                    valueFlowForwardAssign(tok, var, {std::move(v)}, false, true, tokenlist, errorLogger, settings);
+                }
             }
-        } else if (Token::Match(tok, "%var% . reset (") && tok->next()->originalName() != "->") {
-            if (Token::simpleMatch(tok->tokAt(3), "( )")) {
-                std::list<ValueFlow::Value> values;
+        } else if (astIsLHS(tok) && Token::Match(tok->astParent(), ". %name% (") &&
+                   tok->astParent()->originalName() != "->") {
+            std::vector<const Variable*> vars = getVariables(tok);
+            Token* ftok = tok->astParent()->tokAt(2);
+            if (Token::simpleMatch(tok->astParent(), ". reset (")) {
+                if (Token::simpleMatch(ftok, "( )")) {
+                    ValueFlow::Value v(0);
+                    v.setKnown();
+                    valueFlowForwardAssign(ftok, tok, std::move(vars), {std::move(v)}, false, tokenlist, errorLogger, settings);
+                } else {
+                    tok->removeValues(std::mem_fn(&ValueFlow::Value::isIntValue));
+                    Token* inTok = ftok->astOperand2();
+                    if (!inTok)
+                        continue;
+                    const std::list<ValueFlow::Value>& values = inTok->values();
+                    valueFlowForwardAssign(inTok, tok, std::move(vars), values, false, tokenlist, errorLogger, settings);
+                }
+            } else if (Token::simpleMatch(tok->astParent(), ". release ( )")) {
+                const Token* parent = ftok->astParent();
+                bool hasParentReset = false;
+                while (parent) {
+                    if (Token::Match(parent->tokAt(-2), ". release|reset (") &&
+                        parent->tokAt(-2)->astOperand1()->exprId() == tok->exprId()) {
+                        hasParentReset = true;
+                        break;
+                    }
+                    parent = parent->astParent();
+                }
+                if (hasParentReset)
+                    continue;
                 ValueFlow::Value v(0);
                 v.setKnown();
-                values.push_back(v);
-                valueFlowForwardAssign(tok->tokAt(4), var, values, false, false, tokenlist, errorLogger, settings);
-            } else {
-                tok->removeValues(std::mem_fn(&ValueFlow::Value::isIntValue));
-                Token * inTok = tok->tokAt(3)->astOperand2();
-                if (!inTok)
-                    continue;
-                std::list<ValueFlow::Value> values = inTok->values();
-                const bool constValue = inTok->isNumber();
-                valueFlowForwardAssign(inTok, var, values, constValue, false, tokenlist, errorLogger, settings);
-            }
-        } else if (Token::Match(tok, "%var% . release ( )") && tok->next()->originalName() != "->") {
-            std::list<ValueFlow::Value> values;
+                valueFlowForwardAssign(ftok, tok, std::move(vars), {std::move(v)}, false, tokenlist, errorLogger, settings);
+            } else if (Token::simpleMatch(tok->astParent(), ". get ( )")) {
+                ValueFlow::Value v = makeSymbolic(tok);
+                setTokenValue(tok->astParent()->tokAt(2), std::move(v), settings);
+            }
+        } else if (Token::Match(tok->previous(), "%name%|> (|{") && astIsSmartPointer(tok) &&
+                   astIsSmartPointer(tok->astOperand1())) {
+            std::vector<const Token*> args = getArguments(tok);
+            if (args.empty())
+                continue;
+            for (const ValueFlow::Value& v : args.front()->values())
+                setTokenValue(tok, v, settings);
+        }
+    }
+}
+
+static Library::Container::Yield findIteratorYield(Token* tok, const Token*& ftok, const Settings& settings)
+{
+    auto yield = astContainerYield(tok, settings.library, &ftok);
+    if (ftok)
+        return yield;
+
+    if (!tok->astParent())
+        return yield;
+
+    // begin/end free functions
+    return astFunctionYield(tok->astParent()->previous(), settings, &ftok);
+}
+
+static void valueFlowIterators(TokenList& tokenlist, const Settings& settings)
+{
+    for (Token* tok = tokenlist.front(); tok; tok = tok->next()) {
+        if (!tok->scope())
+            continue;
+        if (!tok->scope()->isExecutable())
+            continue;
+        if (!astIsContainer(tok))
+            continue;
+        const Token* ftok = nullptr;
+        const Library::Container::Yield yield = findIteratorYield(tok, ftok, settings);
+        if (!ftok)
+            continue;
+        if (yield == Library::Container::Yield::START_ITERATOR) {
+            ValueFlow::Value v(0);
+            v.setKnown();
+            v.valueType = ValueFlow::Value::ValueType::ITERATOR_START;
+            setTokenValue(const_cast<Token*>(ftok)->next(), std::move(v), settings);
+        } else if (yield == Library::Container::Yield::END_ITERATOR) {
             ValueFlow::Value v(0);
             v.setKnown();
-            values.push_back(v);
-            valueFlowForwardAssign(tok->tokAt(4), var, values, false, false, tokenlist, errorLogger, settings);
+            v.valueType = ValueFlow::Value::ValueType::ITERATOR_END;
+            setTokenValue(const_cast<Token*>(ftok)->next(), std::move(v), settings);
+        }
+    }
+}
+
+static std::list<ValueFlow::Value> getIteratorValues(std::list<ValueFlow::Value> values,
+                                                     const ValueFlow::Value::ValueKind* kind = nullptr)
+{
+    values.remove_if([&](const ValueFlow::Value& v) {
+        if (kind && v.valueKind != *kind)
+            return true;
+        return !v.isIteratorValue();
+    });
+    return values;
+}
+
+struct IteratorConditionHandler : SimpleConditionHandler {
+    std::vector<Condition> parse(const Token* tok, const Settings& /*settings*/) const override {
+        Condition cond;
+
+        if (Token::Match(tok, "==|!=")) {
+            if (!tok->astOperand1() || !tok->astOperand2())
+                return {};
+
+            constexpr ValueFlow::Value::ValueKind kind = ValueFlow::Value::ValueKind::Known;
+            std::list<ValueFlow::Value> values = getIteratorValues(tok->astOperand1()->values(), &kind);
+            if (!values.empty()) {
+                cond.vartok = tok->astOperand2();
+            } else {
+                values = getIteratorValues(tok->astOperand2()->values(), &kind);
+                if (!values.empty())
+                    cond.vartok = tok->astOperand1();
+            }
+            for (ValueFlow::Value& v:values) {
+                v.setPossible();
+                v.assumeCondition(tok);
+            }
+            cond.true_values = values;
+            cond.false_values = std::move(values);
+        }
+
+        return {std::move(cond)};
+    }
+};
+
+static void valueFlowIteratorInfer(TokenList& tokenlist, const Settings& settings)
+{
+    for (Token* tok = tokenlist.front(); tok; tok = tok->next()) {
+        if (!tok->scope())
+            continue;
+        if (!tok->scope()->isExecutable())
+            continue;
+        std::list<ValueFlow::Value> values = getIteratorValues(tok->values());
+        values.remove_if([&](const ValueFlow::Value& v) {
+            if (!v.isImpossible())
+                return true;
+            if (!v.condition)
+                return true;
+            if (v.bound != ValueFlow::Value::Bound::Point)
+                return true;
+            if (v.isIteratorEndValue() && v.intvalue <= 0)
+                return true;
+            if (v.isIteratorStartValue() && v.intvalue >= 0)
+                return true;
+            return false;
+        });
+        for (ValueFlow::Value& v : values) {
+            v.setPossible();
+            if (v.isIteratorStartValue())
+                v.intvalue++;
+            if (v.isIteratorEndValue())
+                v.intvalue--;
+            setTokenValue(tok, std::move(v), settings);
         }
     }
 }
 
-static void valueFlowContainerSize(TokenList *tokenlist, SymbolDatabase* symboldatabase, ErrorLogger * /*errorLogger*/, const Settings *settings)
+static std::vector<ValueFlow::Value> getContainerValues(const Token* tok)
+{
+    std::vector<ValueFlow::Value> values;
+    if (tok) {
+        std::copy_if(tok->values().cbegin(),
+                     tok->values().cend(),
+                     std::back_inserter(values),
+                     std::mem_fn(&ValueFlow::Value::isContainerSizeValue));
+    }
+    return values;
+}
+
+static ValueFlow::Value makeContainerSizeValue(MathLib::bigint s, bool known = true)
+{
+    ValueFlow::Value value(s);
+    value.valueType = ValueFlow::Value::ValueType::CONTAINER_SIZE;
+    if (known)
+        value.setKnown();
+    return value;
+}
+
+static std::vector<ValueFlow::Value> makeContainerSizeValue(const Token* tok, bool known = true)
+{
+    if (const ValueFlow::Value* v = tok->getKnownValue(ValueFlow::Value::ValueType::INT))
+        return {makeContainerSizeValue(v->intvalue, known)};
+    return {};
+}
+
+static std::vector<ValueFlow::Value> getContainerSizeFromConstructorArgs(const std::vector<const Token*>& args,
+                                                                         const Library::Container* container,
+                                                                         bool known)
+{
+    if (astIsIntegral(args[0], false)) { // { count, i } or { count }
+        if (args.size() == 1 || (args.size() > 1 && !astIsIntegral(args[1], false)))
+            return {makeContainerSizeValue(args[0], known)};
+    } else if (astIsContainer(args[0]) && args.size() == 1) { // copy constructor
+        return getContainerValues(args[0]);
+    } else if (isIteratorPair(args)) {
+        std::vector<ValueFlow::Value> result = getContainerValues(args[0]);
+        if (!result.empty())
+            return result;
+        // (ptr, ptr + size)
+        if (astIsPointer(args[0]) && args[0]->exprId() != 0) {
+            // (ptr, ptr) is empty
+            // TODO: Use lifetime values to check if it points to the same address
+            if (args[0]->exprId() == args[1]->exprId())
+                return {makeContainerSizeValue(MathLib::bigint{0}, known)};
+            // TODO: Insert iterator positions for pointers
+            if (Token::simpleMatch(args[1], "+")) {
+                nonneg int const eid = args[0]->exprId();
+                const Token* vartok = args[1]->astOperand1();
+                const Token* sizetok = args[1]->astOperand2();
+                if (sizetok->exprId() == eid)
+                    std::swap(vartok, sizetok);
+                if (vartok->exprId() == eid && sizetok->hasKnownIntValue())
+                    return {makeContainerSizeValue(sizetok, known)};
+            }
+        }
+    } else if (container->stdStringLike) {
+        if (astIsPointer(args[0])) {
+            if (args.size() == 1 && args[0]->tokType() == Token::Type::eString)
+                return {makeContainerSizeValue(Token::getStrLength(args[0]), known)};
+            if (args.size() == 1 && args[0]->variable() && args[0]->variable()->isArray() &&
+                args[0]->variable()->isConst() && args[0]->variable()->dimensions().size() == 1 && args[0]->variable()->dimensions()[0].known)
+                return {makeContainerSizeValue(args[0]->variable()->dimensions()[0].num, known)};
+            if (args.size() == 2 && astIsIntegral(args[1], false)) // { char*, count }
+                return {makeContainerSizeValue(args[1], known)};
+        } else if (astIsContainer(args[0])) {
+            if (args.size() == 1) // copy constructor { str }
+                return getContainerValues(args[0]);
+            if (args.size() == 3) // { str, pos, count }
+                return {makeContainerSizeValue(args[2], known)};
+            // TODO: { str, pos }, { ..., alloc }
+        }
+    }
+    return {};
+}
+
+static bool valueFlowIsSameContainerType(const ValueType& contType, const Token* tok, bool isView, const Settings& settings)
+{
+    if (!tok || !tok->valueType())
+        return true;
+    if (!tok->valueType()->containerTypeToken)
+        return !isView;
+
+    const ValueType tokType = ValueType::parseDecl(tok->valueType()->containerTypeToken, settings);
+    return contType.isTypeEqual(&tokType) || tokType.type == ValueType::Type::UNKNOWN_TYPE;
+}
+
+static std::vector<ValueFlow::Value> getInitListSize(const Token* tok,
+                                                     const ValueType* valueType,
+                                                     const Settings& settings,
+                                                     bool known = true)
+{
+    std::vector<const Token*> args = getArguments(tok);
+    if (args.empty())
+        return {makeContainerSizeValue(MathLib::bigint{0}, known)};
+    bool initList = tok->str() == "{";
+    // Try to disambiguate init list from constructor
+    if (initList && args.size() < 4) {
+        initList = !isIteratorPair(args);
+        const Token* containerTypeToken = valueType->containerTypeToken;
+        if (valueType->container->stdStringLike) {
+            initList = astIsGenericChar(args[0]) && !astIsPointer(args[0]);
+        } else if (containerTypeToken) {
+            ValueType vt = ValueType::parseDecl(containerTypeToken, settings);
+            if (vt.pointer > 0 && astIsPointer(args[0]))
+                initList = true;
+            else if (vt.type == ValueType::ITERATOR && astIsIterator(args[0]))
+                initList = true;
+            else if (vt.isIntegral() && astIsIntegral(args[0], false))
+                initList = true;
+            else if (args.size() == 1 && valueFlowIsSameContainerType(vt, tok->astOperand2(), valueType->container->view, settings))
+                initList = false; // copy ctor
+            else if (args.size() == 2 && (!args[0]->valueType() || !args[1]->valueType())) // might be unknown iterators
+                initList = false;
+        }
+    }
+    if (!initList)
+        return getContainerSizeFromConstructorArgs(args, valueType->container, known);
+    return {makeContainerSizeValue(args.size(), known)};
+}
+
+static std::vector<ValueFlow::Value> getContainerSizeFromConstructor(const Token* tok,
+                                                                     const ValueType* valueType,
+                                                                     const Settings& settings,
+                                                                     bool known = true)
+{
+    std::vector<const Token*> args = getArguments(tok);
+    if (args.empty())
+        return {makeContainerSizeValue(MathLib::bigint{0}, known)};
+    // Init list in constructor
+    if (args.size() == 1 && Token::simpleMatch(args[0], "{"))
+        return getInitListSize(args[0], valueType, settings, known);
+    return getContainerSizeFromConstructorArgs(args, valueType->container, known);
+}
+
+static void valueFlowContainerSetTokValue(const TokenList& tokenlist, ErrorLogger& errorLogger, const Settings& settings, const Token* tok, Token* initList)
+{
+    ValueFlow::Value value;
+    value.valueType = ValueFlow::Value::ValueType::TOK;
+    value.tokvalue = initList;
+    if (astIsContainerString(tok) && Token::simpleMatch(initList, "{") && Token::Match(initList->astOperand2(), "%str%")) {
+        value.tokvalue = initList->astOperand2();
+    }
+    value.setKnown();
+    Token* start = initList->link() ? initList->link() : initList->next();
+    if (tok->variable() && tok->variable()->isConst()) {
+        valueFlowForwardConst(start, tok->variable()->scope()->bodyEnd, tok->variable(), {std::move(value)}, settings);
+    } else {
+        valueFlowForward(start, tok, std::move(value), tokenlist, errorLogger, settings);
+    }
+}
+
+static const Scope* getFunctionScope(const Scope* scope) {
+    while (scope && scope->type != ScopeType::eFunction)
+        scope = scope->nestedIn;
+    return scope;
+}
+
+static void valueFlowContainerSize(const TokenList& tokenlist,
+                                   const SymbolDatabase& symboldatabase,
+                                   ErrorLogger& errorLogger,
+                                   const Settings& settings,
+                                   const std::set<const Scope*>& skippedFunctions)
 {
     // declaration
-    for (const Variable *var : symboldatabase->variableList()) {
-        if (!var || !var->isLocal() || var->isPointer() || var->isReference())
+    for (const Variable *var : symboldatabase.variableList()) {
+        if (!var)
+            continue;
+        if (!var->scope() || !var->scope()->bodyEnd || !var->scope()->bodyStart)
             continue;
         if (!var->valueType() || !var->valueType()->container)
             continue;
-        if (!Token::Match(var->nameToken(), "%name% ;"))
+        if (!astIsContainer(var->nameToken()))
             continue;
-        if (var->nameToken()->hasKnownValue())
+        if (skippedFunctions.count(getFunctionScope(var->scope())))
             continue;
-        ValueFlow::Value value(0);
+
+        bool known = true;
+        MathLib::bigint size = 0;
+        const bool nonLocal = !var->isLocal() || var->isPointer() || var->isReference() || var->isStatic();
+        bool constSize = var->isConst() && !nonLocal;
+        bool staticSize = false;
         if (var->valueType()->container->size_templateArgNo >= 0) {
-            if (var->dimensions().size() == 1 && var->dimensions().front().tok && var->dimensions().front().tok->hasKnownIntValue())
-                value.intvalue = var->dimensions().front().tok->getKnownIntValue();
-            else
+            staticSize = true;
+            constSize = true;
+            size = -1;
+            if (var->dimensions().size() == 1) {
+                const Dimension& dim = var->dimensions().front();
+                if (dim.known) {
+                    size = dim.num;
+                } else if (dim.tok && dim.tok->hasKnownIntValue() && dim.tok->strAt(1) == ">") {
+                    size = dim.tok->getKnownIntValue();
+                }
+            }
+            if (size < 0)
                 continue;
         }
-        value.valueType = ValueFlow::Value::ValueType::CONTAINER_SIZE;
-        value.setKnown();
-        valueFlowContainerForward(var->nameToken()->next(), var->declarationId(), value, settings, tokenlist->isCPP());
+        if (!staticSize && nonLocal)
+            continue;
+        auto* nameToken = const_cast<Token*>(var->nameToken());
+        if (nameToken->hasKnownValue(ValueFlow::Value::ValueType::CONTAINER_SIZE))
+            continue;
+        if (!staticSize) {
+            if (!Token::Match(nameToken, "%name% ;") &&
+                !(Token::Match(nameToken, "%name% {") && Token::simpleMatch(nameToken->linkAt(1), "} ;")) &&
+                !Token::Match(nameToken, "%name% ("))
+                continue;
+        }
+        if (Token::Match(nameToken->astTop()->previous(), "for|while"))
+            known = !isVariableChanged(var, settings);
+        std::vector<ValueFlow::Value> values{ValueFlow::Value{size}};
+        values.back().valueType = ValueFlow::Value::ValueType::CONTAINER_SIZE;
+        if (known)
+            values.back().setKnown();
+        if (!staticSize) {
+            if (Token::simpleMatch(nameToken->next(), "{")) {
+                Token* initList = nameToken->next();
+                valueFlowContainerSetTokValue(tokenlist, errorLogger, settings, nameToken, initList);
+                values = getInitListSize(initList, var->valueType(), settings, known);
+            } else if (Token::simpleMatch(nameToken->next(), "(")) {
+                const Token* constructorArgs = nameToken->next();
+                values = getContainerSizeFromConstructor(constructorArgs, var->valueType(), settings, known);
+            }
+        }
+
+        if (constSize) {
+            valueFlowForwardConst(nameToken->next(), var->scope()->bodyEnd, var, values, settings);
+            continue;
+        }
+
+        for (const ValueFlow::Value& value : values) {
+            valueFlowForward(nameToken->next(), var->nameToken(), value, tokenlist, errorLogger, settings);
+        }
     }
 
+    auto forwardMinimumContainerSize = [&](MathLib::bigint size, Token* opTok, const Token* exprTok) -> void {
+        if (size == 0)
+            return;
+
+        ValueFlow::Value value(size - 1);
+        value.valueType = ValueFlow::Value::ValueType::CONTAINER_SIZE;
+        value.bound = ValueFlow::Value::Bound::Upper;
+        value.setImpossible();
+        Token* next = nextAfterAstRightmostLeaf(opTok);
+        if (!next)
+            next = opTok->next();
+        valueFlowForward(next, exprTok, std::move(value), tokenlist, errorLogger, settings);
+    };
+
     // after assignment
-    for (const Scope *functionScope : symboldatabase->functionScopes) {
-        for (const Token *tok = functionScope->bodyStart; tok != functionScope->bodyEnd; tok = tok->next()) {
+    for (const Scope *functionScope : symboldatabase.functionScopes) {
+        for (auto* tok = const_cast<Token*>(functionScope->bodyStart); tok != functionScope->bodyEnd; tok = tok->next()) {
             if (Token::Match(tok, "%name%|;|{|} %var% = %str% ;")) {
-                const Token *containerTok = tok->next();
-                if (containerTok && containerTok->valueType() && containerTok->valueType()->container && containerTok->valueType()->container->stdStringLike) {
+                Token* containerTok = tok->next();
+                if (containerTok->exprId() == 0)
+                    continue;
+                if (containerTok->valueType() && containerTok->valueType()->container &&
+                    containerTok->valueType()->container->stdStringLike) {
+                    valueFlowContainerSetTokValue(tokenlist, errorLogger, settings, containerTok, containerTok->tokAt(2));
                     ValueFlow::Value value(Token::getStrLength(containerTok->tokAt(2)));
                     value.valueType = ValueFlow::Value::ValueType::CONTAINER_SIZE;
                     value.setKnown();
-                    valueFlowContainerForward(containerTok->next(), containerTok->varId(), value, settings, tokenlist->isCPP());
+                    valueFlowForward(containerTok->next(), containerTok, std::move(value), tokenlist, errorLogger, settings);
                 }
+            } else if (Token::Match(tok->previous(), ">|return (|{") && astIsContainer(tok) && getLibraryContainer(tok)->size_templateArgNo < 0) {
+                std::vector<ValueFlow::Value> values;
+                if (Token::simpleMatch(tok, "{")) {
+                    values = getInitListSize(tok, tok->valueType(), settings, true);
+                    ValueFlow::Value value;
+                    value.valueType = ValueFlow::Value::ValueType::TOK;
+                    value.tokvalue = tok;
+                    value.setKnown();
+                    values.push_back(std::move(value));
+                } else if (Token::simpleMatch(tok, "(")) {
+                    const Token* constructorArgs = tok;
+                    values = getContainerSizeFromConstructor(constructorArgs, tok->valueType(), settings, true);
+                }
+                for (const ValueFlow::Value& value : values)
+                    setTokenValue(tok, value, settings);
             }
-        }
-    }
-
-    // conditional conditionSize
-    for (const Scope &scope : symboldatabase->scopeList) {
-        if (scope.type != Scope::ScopeType::eIf) // TODO: while
-            continue;
-        for (const Token *tok = scope.classDef; tok && tok->str() != "{"; tok = tok->next()) {
-            if (!tok->isName() || !tok->valueType() || tok->valueType()->type != ValueType::CONTAINER || !tok->valueType()->container)
-                continue;
-
-            const Token *conditionToken;
-            MathLib::bigint intval;
-
-            if (Token::Match(tok, "%name% . %name% (")) {
-                if (tok->valueType()->container->getYield(tok->strAt(2)) == Library::Container::Yield::SIZE) {
-                    const Token *parent = tok->tokAt(3)->astParent();
-                    if (!parent || !parent->isComparisonOp() || !parent->astOperand2())
-                        continue;
-                    if (parent->astOperand1()->hasKnownIntValue())
-                        intval = parent->astOperand1()->values().front().intvalue;
-                    else if (parent->astOperand2()->hasKnownIntValue())
-                        intval = parent->astOperand2()->values().front().intvalue;
-                    else
-                        continue;
-                    conditionToken = parent;
-                } else if (tok->valueType()->container->getYield(tok->strAt(2)) == Library::Container::Yield::EMPTY) {
-                    conditionToken = tok->tokAt(3);
-                    intval = 0;
-                } else {
+            else if (Token::Match(tok->previous(), ",|(") && (Token::Match(tok, "{|%str%") || settings.library.detectContainer(tok))) {
+                if (Token* argTok = tok->previous()->astOperand2()) {
+                    int nArg{};
+                    if (const Token* funcTok = getTokenArgumentFunction(argTok, nArg)) {
+                        if (const Function* func = funcTok->function()) {
+                            if (const Variable* var = func->getArgumentVar(nArg)) {
+                                if (var->valueType() && var->valueType()->container && var->valueType()->container->size_templateArgNo < 0) {
+                                    auto values = argTok->tokType() == Token::Type::eString
+                                        ? std::vector<ValueFlow::Value>{makeContainerSizeValue(Token::getStrLength(argTok))}
+                                    : getInitListSize(argTok, var->valueType(), settings, true);
+                                    ValueFlow::Value tokValue;
+                                    tokValue.valueType = ValueFlow::Value::ValueType::TOK;
+                                    tokValue.tokvalue = argTok;
+                                    tokValue.setKnown();
+                                    values.push_back(std::move(tokValue));
+
+                                    for (const ValueFlow::Value& value : values)
+                                        setTokenValue(argTok, value, settings);
+                                }
+                            }
+                        }
+                    }
+                }
+            } else if (Token::Match(tok, ";|{|} %var% =") && Token::Match(tok->tokAt(2)->astOperand2(), "[({]") &&
+                       // init list
+                       ((tok->tokAt(2) == tok->tokAt(2)->astOperand2()->astParent() && !tok->tokAt(2)->astOperand2()->astOperand2() && tok->tokAt(2)->astOperand2()->str() == "{") ||
+                        // constructor
+                        (!Token::simpleMatch(tok->tokAt(2)->astOperand2()->astOperand1(), ".") && settings.library.detectContainer(tok->tokAt(3))))) {
+                Token* containerTok = tok->next();
+                if (containerTok->exprId() == 0)
                     continue;
+                if (astIsContainer(containerTok) && containerTok->valueType()->container->size_templateArgNo < 0) {
+                    Token* rhs = tok->tokAt(2)->astOperand2();
+                    std::vector<ValueFlow::Value> values = getInitListSize(rhs, containerTok->valueType(), settings);
+                    valueFlowContainerSetTokValue(tokenlist, errorLogger, settings, containerTok, rhs);
+                    for (const ValueFlow::Value& value : values)
+                        valueFlowForward(containerTok->next(), containerTok, value, tokenlist, errorLogger, settings);
                 }
-            } else if (tok->valueType()->container->stdStringLike && Token::Match(tok, "%name% ==|!= %str%") && tok->next()->astOperand2() == tok->tokAt(2)) {
-                intval = Token::getStrLength(tok->tokAt(2));
-                conditionToken = tok->next();
-            } else {
-                continue;
+            } else if (Token::Match(tok, ". %name% (") && tok->astOperand1() && tok->astOperand1()->valueType() &&
+                       tok->astOperand1()->valueType()->container) {
+                const Token* containerTok = tok->astOperand1();
+                if (containerTok->exprId() == 0)
+                    continue;
+                if (containerTok->variable() && containerTok->variable()->isArray())
+                    continue;
+                const Library::Container::Action action = containerTok->valueType()->container->getAction(tok->strAt(1));
+                if (action == Library::Container::Action::CLEAR) {
+                    ValueFlow::Value value(0);
+                    value.valueType = ValueFlow::Value::ValueType::CONTAINER_SIZE;
+                    value.setKnown();
+                    valueFlowForward(tok->next(), containerTok, std::move(value), tokenlist, errorLogger, settings);
+                } else if (action == Library::Container::Action::RESIZE && tok->tokAt(2)->astOperand2() &&
+                           tok->tokAt(2)->astOperand2()->hasKnownIntValue()) {
+                    ValueFlow::Value value(*tok->tokAt(2)->astOperand2()->getKnownValue(ValueFlow::Value::ValueType::INT));
+                    value.valueType = ValueFlow::Value::ValueType::CONTAINER_SIZE;
+                    value.setKnown();
+                    valueFlowForward(tok->linkAt(2), containerTok, std::move(value), tokenlist, errorLogger, settings);
+                } else if (action == Library::Container::Action::PUSH && !isIteratorPair(getArguments(tok->tokAt(2)))) {
+                    ValueFlow::Value value(0);
+                    value.valueType = ValueFlow::Value::ValueType::CONTAINER_SIZE;
+                    value.setImpossible();
+                    valueFlowForward(tok->linkAt(2), containerTok, std::move(value), tokenlist, errorLogger, settings);
+                }
+                // TODO: handle more actions?
+
+            } else if (tok->str() == "+=" && astIsContainer(tok->astOperand1())) {
+                const Token* containerTok = tok->astOperand1();
+                const Token* valueTok = tok->astOperand2();
+                const MathLib::bigint size = ValueFlow::valueFlowGetStrLength(valueTok);
+                forwardMinimumContainerSize(size, tok, containerTok);
+
+            } else if (tok->str() == "=" && Token::simpleMatch(tok->astOperand2(), "+") && astIsContainerString(tok)) {
+                const Token* tok2 = tok->astOperand2();
+                MathLib::bigint size = 0;
+                while (Token::simpleMatch(tok2, "+") && tok2->astOperand2()) {
+                    size += ValueFlow::valueFlowGetStrLength(tok2->astOperand2());
+                    tok2 = tok2->astOperand1();
+                }
+                size += ValueFlow::valueFlowGetStrLength(tok2);
+                forwardMinimumContainerSize(size, tok, tok->astOperand1());
             }
-
-            ValueFlow::Value value(conditionToken, intval);
-            value.valueType = ValueFlow::Value::ValueType::CONTAINER_SIZE;
-
-            // possible value before condition
-            valueFlowContainerReverse(const_cast<Token *>(scope.classDef), tok->varId(), value, settings);
         }
     }
 }
 
-static void valueFlowContainerAfterCondition(TokenList *tokenlist,
-        SymbolDatabase *symboldatabase,
-        ErrorLogger *errorLogger,
-        const Settings *settings)
-{
-    ValueFlowConditionHandler handler;
-    handler.forward =
-    [&](Token* start, const Token* stop, const Token* vartok, const std::list<ValueFlow::Value>& values, bool) {
-        // TODO: Forward multiple values
-        if (values.empty())
-            return false;
-        const Variable* var = vartok->variable();
-        if (!var)
-            return false;
-        valueFlowContainerForward(start, var->declarationId(), values.front(), settings, tokenlist->isCPP());
-        return isContainerSizeChanged(var->declarationId(), start, stop);
-    };
-    handler.parse = [&](const Token *tok) {
-        ValueFlowConditionHandler::Condition cond;
-        ValueFlow::Value true_value;
-        ValueFlow::Value false_value;
-        const Token *vartok = parseCompareInt(tok, true_value, false_value);
-        if (vartok) {
-            vartok = vartok->tokAt(-3);
-            if (!isContainerSize(vartok))
-                return cond;
-            true_value.valueType = ValueFlow::Value::CONTAINER_SIZE;
-            false_value.valueType = ValueFlow::Value::CONTAINER_SIZE;
-            cond.true_values.push_back(true_value);
-            cond.false_values.push_back(false_value);
+struct ContainerConditionHandler : ConditionHandler {
+    std::vector<Condition> parse(const Token* tok, const Settings& settings) const override
+    {
+        std::vector<Condition> conds;
+        parseCompareEachInt(tok, [&](const Token* vartok, ValueFlow::Value true_value, ValueFlow::Value false_value) {
+            vartok = settings.library.getContainerFromYield(vartok, Library::Container::Yield::SIZE);
+            if (!vartok)
+                return;
+            true_value.valueType = ValueFlow::Value::ValueType::CONTAINER_SIZE;
+            false_value.valueType = ValueFlow::Value::ValueType::CONTAINER_SIZE;
+            Condition cond;
+            cond.true_values.push_back(std::move(true_value));
+            cond.false_values.push_back(std::move(false_value));
             cond.vartok = vartok;
-            return cond;
-        }
+            conds.push_back(std::move(cond));
+        });
+        if (!conds.empty())
+            return conds;
+
+        const Token* vartok = nullptr;
 
         // Empty check
         if (tok->str() == "(") {
-            vartok = tok->tokAt(-3);
+            vartok = settings.library.getContainerFromYield(tok, Library::Container::Yield::EMPTY);
             // TODO: Handle .size()
-            if (!isContainerEmpty(vartok))
-                return cond;
+            if (!vartok)
+                return {};
             const Token *parent = tok->astParent();
             while (parent) {
-                if (Token::Match(parent, "%comp%|!"))
-                    return cond;
+                if (Token::Match(parent, "%comp%"))
+                    return {};
                 parent = parent->astParent();
             }
             ValueFlow::Value value(tok, 0LL);
             value.valueType = ValueFlow::Value::ValueType::CONTAINER_SIZE;
+            Condition cond;
             cond.true_values.emplace_back(value);
             cond.false_values.emplace_back(std::move(value));
             cond.vartok = vartok;
-            return cond;
+            cond.inverted = true;
+            return {std::move(cond)};
         }
         // String compare
         if (Token::Match(tok, "==|!=")) {
@@ -6121,44 +6851,95 @@ static void valueFlowContainerAfterCondition(TokenList *tokenlist,
                 vartok = tok->astOperand1();
             }
             if (!strtok)
-                return cond;
+                return {};
             if (!astIsContainer(vartok))
-                return cond;
+                return {};
             ValueFlow::Value value(tok, Token::getStrLength(strtok));
             value.valueType = ValueFlow::Value::ValueType::CONTAINER_SIZE;
+            Condition cond;
             cond.false_values.emplace_back(value);
             cond.true_values.emplace_back(std::move(value));
             cond.vartok = vartok;
-            return cond;
+            cond.impossible = false;
+            return {std::move(cond)};
         }
-        return cond;
-    };
-    handler.afterCondition(tokenlist, symboldatabase, errorLogger, settings);
-}
-
-static void valueFlowFwdAnalysis(const TokenList *tokenlist, const Settings *settings)
-{
-    for (const Token *tok = tokenlist->front(); tok; tok = tok->next()) {
-        if (tok->str() != "=" || !tok->astOperand1() || !tok->astOperand2())
-            continue;
-        if (!tok->scope()->isExecutable())
-            continue;
-        if (!tok->astOperand2()->hasKnownIntValue())
-            continue;
-        ValueFlow::Value v(tok->astOperand2()->values().front());
-        v.errorPath.emplace_back(tok, tok->astOperand1()->expressionString() + " is assigned value " + MathLib::toString(v.intvalue));
-        const Token *startToken = tok->findExpressionStartEndTokens().second->next();
-        const Scope *functionScope = tok->scope();
-        while (functionScope->nestedIn && functionScope->nestedIn->isExecutable())
-            functionScope = functionScope->nestedIn;
-        const Token *endToken = functionScope->bodyEnd;
-        valueFlowForwardExpression(const_cast<Token*>(startToken), endToken, tok->astOperand1(), {v}, tokenlist, settings);
+        return {};
     }
-}
+};
 
-static void valueFlowDynamicBufferSize(TokenList *tokenlist, SymbolDatabase *symboldatabase, ErrorLogger *errorLogger, const Settings *settings)
+static void valueFlowDynamicBufferSize(const TokenList& tokenlist, const SymbolDatabase& symboldatabase, ErrorLogger& errorLogger, const Settings& settings)
 {
-    for (const Scope *functionScope : symboldatabase->functionScopes) {
+    auto getBufferSizeFromAllocFunc = [&](const Token* funcTok) -> MathLib::bigint {
+        MathLib::bigint sizeValue = -1;
+        const Library::AllocFunc* allocFunc = settings.library.getAllocFuncInfo(funcTok);
+        if (!allocFunc)
+            allocFunc = settings.library.getReallocFuncInfo(funcTok);
+        if (!allocFunc || allocFunc->bufferSize == Library::AllocFunc::BufferSize::none)
+            return sizeValue;
+
+        const std::vector<const Token*> args = getArguments(funcTok);
+
+        const Token* const arg1 = (args.size() >= allocFunc->bufferSizeArg1) ? args[allocFunc->bufferSizeArg1 - 1] : nullptr;
+        const Token* const arg2 = (args.size() >= allocFunc->bufferSizeArg2) ? args[allocFunc->bufferSizeArg2 - 1] : nullptr;
+
+        switch (allocFunc->bufferSize) {
+        case Library::AllocFunc::BufferSize::none:
+            break;
+        case Library::AllocFunc::BufferSize::malloc:
+            if (arg1 && arg1->hasKnownIntValue())
+                sizeValue = arg1->getKnownIntValue();
+            break;
+        case Library::AllocFunc::BufferSize::calloc:
+            if (arg1 && arg2 && arg1->hasKnownIntValue() && arg2->hasKnownIntValue())
+                sizeValue = arg1->getKnownIntValue() * arg2->getKnownIntValue();
+            break;
+        case Library::AllocFunc::BufferSize::strdup:
+            if (arg1 && arg1->hasKnownValue()) {
+                const ValueFlow::Value& value = arg1->values().back();
+                if (value.isTokValue() && value.tokvalue->tokType() == Token::eString)
+                    sizeValue = Token::getStrLength(value.tokvalue) + 1; // Add one for the null terminator
+            }
+            break;
+        }
+        return sizeValue;
+    };
+
+    auto getBufferSizeFromNew = [&](const Token* newTok) -> MathLib::bigint {
+        MathLib::bigint sizeValue = -1, numElem = -1;
+
+        if (newTok && newTok->astOperand1()) { // number of elements
+            const Token* bracTok = nullptr, *typeTok = nullptr;
+            if (newTok->astOperand1()->str() == "[")
+                bracTok = newTok->astOperand1();
+            else if (Token::Match(newTok->astOperand1(), "(|{")) {
+                if (newTok->astOperand1()->astOperand1() && newTok->astOperand1()->astOperand1()->str() == "[")
+                    bracTok = newTok->astOperand1()->astOperand1();
+                else
+                    typeTok = newTok->astOperand1()->astOperand1();
+            }
+            else
+                typeTok = newTok->astOperand1();
+            if (bracTok && bracTok->astOperand2() && bracTok->astOperand2()->hasKnownIntValue())
+                numElem = bracTok->astOperand2()->getKnownIntValue();
+            else if (Token::Match(typeTok, "%type%"))
+                numElem = 1;
+        }
+
+        if (numElem >= 0 && newTok->astParent() && newTok->astParent()->isAssignmentOp()) { // size of the allocated type
+            const Token* typeTok = newTok->astParent()->astOperand1(); // TODO: implement fallback for e.g. "auto p = new Type;"
+            if (!typeTok || !typeTok->varId())
+                typeTok = newTok->astParent()->previous(); // hack for "int** z = ..."
+            if (typeTok && typeTok->valueType()) {
+                const auto sizeOf = typeTok->valueType()->pointer > 1 ? ValueType::SizeOf::Pointer : ValueType::SizeOf::Pointee;
+                const size_t typeSize = typeTok->valueType()->getSizeOf(settings, ValueType::Accuracy::ExactOrZero, sizeOf);
+                if (typeSize > 0 || numElem == 0)
+                    sizeValue = numElem * typeSize;
+            }
+        }
+        return sizeValue;
+    };
+
+    for (const Scope *functionScope : symboldatabase.functionScopes) {
         for (const Token *tok = functionScope->bodyStart; tok != functionScope->bodyEnd; tok = tok->next()) {
             if (!Token::Match(tok, "[;{}] %var% ="))
                 continue;
@@ -6172,40 +6953,11 @@ static void valueFlowDynamicBufferSize(TokenList *tokenlist, SymbolDatabase *sym
             if (!rhs)
                 continue;
 
-            if (!Token::Match(rhs->previous(), "%name% ("))
-                continue;
-
-            const Library::AllocFunc *allocFunc = settings->library.getAllocFuncInfo(rhs->previous());
-            if (!allocFunc)
-                allocFunc = settings->library.getReallocFuncInfo(rhs->previous());
-            if (!allocFunc || allocFunc->bufferSize == Library::AllocFunc::BufferSize::none)
+            const bool isNew = rhs->isCpp() && rhs->str() == "new";
+            if (!isNew && !Token::Match(rhs->previous(), "%name% ("))
                 continue;
 
-            const std::vector<const Token *> args = getArguments(rhs->previous());
-
-            const Token * const arg1 = (args.size() >= allocFunc->bufferSizeArg1) ? args[allocFunc->bufferSizeArg1 - 1] : nullptr;
-            const Token * const arg2 = (args.size() >= allocFunc->bufferSizeArg2) ? args[allocFunc->bufferSizeArg2 - 1] : nullptr;
-
-            MathLib::bigint sizeValue = -1;
-            switch (allocFunc->bufferSize) {
-            case Library::AllocFunc::BufferSize::none:
-                break;
-            case Library::AllocFunc::BufferSize::malloc:
-                if (arg1 && arg1->hasKnownIntValue())
-                    sizeValue = arg1->getKnownIntValue();
-                break;
-            case Library::AllocFunc::BufferSize::calloc:
-                if (arg1 && arg2 && arg1->hasKnownIntValue() && arg2->hasKnownIntValue())
-                    sizeValue = arg1->getKnownIntValue() * arg2->getKnownIntValue();
-                break;
-            case Library::AllocFunc::BufferSize::strdup:
-                if (arg1 && arg1->hasKnownValue()) {
-                    const ValueFlow::Value &value = arg1->values().back();
-                    if (value.isTokValue() && value.tokvalue->tokType() == Token::eString)
-                        sizeValue = Token::getStrLength(value.tokvalue) + 1; // Add one for the null terminator
-                }
-                break;
-            };
+            const MathLib::bigint sizeValue = isNew ? getBufferSizeFromNew(rhs) : getBufferSizeFromAllocFunc(rhs->previous());
             if (sizeValue < 0)
                 continue;
 
@@ -6213,91 +6965,30 @@ static void valueFlowDynamicBufferSize(TokenList *tokenlist, SymbolDatabase *sym
             value.errorPath.emplace_back(tok->tokAt(2), "Assign " + tok->strAt(1) + ", buffer with size " + MathLib::toString(sizeValue));
             value.valueType = ValueFlow::Value::ValueType::BUFFER_SIZE;
             value.setKnown();
-            const std::list<ValueFlow::Value> values{value};
-            valueFlowForwardVariable(const_cast<Token*>(rhs),
-                                     functionScope->bodyEnd,
-                                     tok->next()->variable(),
-                                     tok->next()->varId(),
-                                     values,
-                                     true,
-                                     false,
-                                     tokenlist,
-                                     errorLogger,
-                                     settings);
-        }
-    }
-}
-
-static bool getMinMaxValues(const ValueType *vt, const cppcheck::Platform &platform, MathLib::bigint *minValue, MathLib::bigint *maxValue)
-{
-    if (!vt || !vt->isIntegral() || vt->pointer)
-        return false;
-
-    int bits;
-    switch (vt->type) {
-    case ValueType::Type::BOOL:
-        bits = 1;
-        break;
-    case ValueType::Type::CHAR:
-        bits = platform.char_bit;
-        break;
-    case ValueType::Type::SHORT:
-        bits = platform.short_bit;
-        break;
-    case ValueType::Type::INT:
-        bits = platform.int_bit;
-        break;
-    case ValueType::Type::LONG:
-        bits = platform.long_bit;
-        break;
-    case ValueType::Type::LONGLONG:
-        bits = platform.long_long_bit;
-        break;
-    default:
-        return false;
-    };
-
-    if (bits == 1) {
-        *minValue = 0;
-        *maxValue = 1;
-    } else if (bits < 62) {
-        if (vt->sign == ValueType::Sign::UNSIGNED) {
-            *minValue = 0;
-            *maxValue = (1LL << bits) - 1;
-        } else {
-            *minValue = -(1LL << (bits - 1));
-            *maxValue = (1LL << (bits - 1)) - 1;
-        }
-    } else if (bits == 64) {
-        if (vt->sign == ValueType::Sign::UNSIGNED) {
-            *minValue = 0;
-            *maxValue = LLONG_MAX; // todo max unsigned value
-        } else {
-            *minValue = LLONG_MIN;
-            *maxValue = LLONG_MAX;
+            valueFlowForward(const_cast<Token*>(rhs), functionScope->bodyEnd, tok->next(), std::move(value), tokenlist, errorLogger, settings);
         }
-    } else {
-        return false;
     }
-
-    return true;
 }
 
-static bool getMinMaxValues(const std::string &typestr, const Settings *settings, MathLib::bigint *minvalue, MathLib::bigint *maxvalue)
+static bool getMinMaxValues(const std::string& typestr,
+                            const Settings& settings,
+                            bool cpp,
+                            MathLib::bigint& minvalue,
+                            MathLib::bigint& maxvalue)
 {
-    TokenList typeTokens(settings);
-    std::istringstream istr(typestr+";");
-    if (!typeTokens.createTokens(istr))
+    TokenList typeTokens(settings, cpp ? Standards::Language::CPP : Standards::Language::C);
+    const std::string str(typestr + ";");
+    if (!typeTokens.createTokensFromBuffer(str.data(), str.size()))
         return false;
     typeTokens.simplifyPlatformTypes();
     typeTokens.simplifyStdType();
-    const ValueType &vt = ValueType::parseDecl(typeTokens.front(), settings);
-    return getMinMaxValues(&vt, *settings, minvalue, maxvalue);
+    const ValueType& vt = ValueType::parseDecl(typeTokens.front(), settings);
+    return ValueFlow::getMinMaxValues(&vt, settings.platform, minvalue, maxvalue);
 }
 
-static void valueFlowSafeFunctions(TokenList *tokenlist, SymbolDatabase *symboldatabase, ErrorLogger *errorLogger, const Settings *settings)
+static void valueFlowSafeFunctions(const TokenList& tokenlist, const SymbolDatabase& symboldatabase, ErrorLogger& errorLogger, const Settings& settings)
 {
-    for (const Scope *functionScope : symboldatabase->functionScopes) {
+    for (const Scope *functionScope : symboldatabase.functionScopes) {
         if (!functionScope->bodyStart)
             continue;
         const Function *function = functionScope->function;
@@ -6305,7 +6996,7 @@ static void valueFlowSafeFunctions(TokenList *tokenlist, SymbolDatabase *symbold
             continue;
 
         const bool safe = function->isSafe(settings);
-        const bool all = safe && settings->platformType != cppcheck::Platform::PlatformType::Unspecified;
+        const bool all = safe && settings.platform.type != Platform::Type::Unspecified;
 
         for (const Variable &arg : function->argumentList) {
             if (!arg.nameToken() || !arg.valueType())
@@ -6324,13 +7015,13 @@ static void valueFlowSafeFunctions(TokenList *tokenlist, SymbolDatabase *symbold
                 argValues.back().errorPath.emplace_back(arg.nameToken(), "Assuming " + arg.name() + " size is 1000000");
                 argValues.back().safe = true;
                 for (const ValueFlow::Value &value : argValues)
-                    valueFlowContainerForward(const_cast<Token*>(functionScope->bodyStart), arg.declarationId(), value, settings, tokenlist->isCPP());
+                    valueFlowForward(const_cast<Token*>(functionScope->bodyStart), arg.nameToken(), value, tokenlist, errorLogger, settings);
                 continue;
             }
 
             MathLib::bigint low, high;
-            bool isLow = arg.nameToken()->getCppcheckAttribute(TokenImpl::CppcheckAttributes::Type::LOW, &low);
-            bool isHigh = arg.nameToken()->getCppcheckAttribute(TokenImpl::CppcheckAttributes::Type::HIGH, &high);
+            bool isLow = arg.nameToken()->getCppcheckAttribute(Token::CppcheckAttributesType::LOW, low);
+            bool isHigh = arg.nameToken()->getCppcheckAttribute(Token::CppcheckAttributesType::HIGH, high);
 
             if (!isLow && !isHigh && !all)
                 continue;
@@ -6340,7 +7031,7 @@ static void valueFlowSafeFunctions(TokenList *tokenlist, SymbolDatabase *symbold
 
             if ((!isLow || !isHigh) && all) {
                 MathLib::bigint minValue, maxValue;
-                if (getMinMaxValues(arg.valueType(), *settings, &minValue, &maxValue)) {
+                if (ValueFlow::getMinMaxValues(arg.valueType(), settings.platform, minValue, maxValue)) {
                     if (!isLow)
                         low = minValue;
                     if (!isHigh)
@@ -6350,24 +7041,21 @@ static void valueFlowSafeFunctions(TokenList *tokenlist, SymbolDatabase *symbold
                     std::list<ValueFlow::Value> argValues;
                     argValues.emplace_back(0);
                     argValues.back().valueType = ValueFlow::Value::ValueType::FLOAT;
-                    argValues.back().floatValue = isLow ? low : -1E25f;
+                    argValues.back().floatValue = isLow ? static_cast<double>(low) : -1E25;
                     argValues.back().errorPath.emplace_back(arg.nameToken(), "Safe checks: Assuming argument has value " + MathLib::toString(argValues.back().floatValue));
                     argValues.back().safe = true;
                     argValues.emplace_back(0);
                     argValues.back().valueType = ValueFlow::Value::ValueType::FLOAT;
-                    argValues.back().floatValue = isHigh ? high : 1E25f;
+                    argValues.back().floatValue = isHigh ? static_cast<double>(high) : 1E25;
                     argValues.back().errorPath.emplace_back(arg.nameToken(), "Safe checks: Assuming argument has value " + MathLib::toString(argValues.back().floatValue));
                     argValues.back().safe = true;
-                    valueFlowForwardVariable(const_cast<Token*>(functionScope->bodyStart->next()),
-                                             functionScope->bodyEnd,
-                                             &arg,
-                                             arg.declarationId(),
-                                             argValues,
-                                             false,
-                                             false,
-                                             tokenlist,
-                                             errorLogger,
-                                             settings);
+                    valueFlowForward(const_cast<Token*>(functionScope->bodyStart->next()),
+                                     functionScope->bodyEnd,
+                                     arg.nameToken(),
+                                     std::move(argValues),
+                                     tokenlist,
+                                     errorLogger,
+                                     settings);
                     continue;
                 }
             }
@@ -6385,39 +7073,52 @@ static void valueFlowSafeFunctions(TokenList *tokenlist, SymbolDatabase *symbold
             }
 
             if (!argValues.empty())
-                valueFlowForwardVariable(const_cast<Token*>(functionScope->bodyStart->next()),
-                                         functionScope->bodyEnd,
-                                         &arg,
-                                         arg.declarationId(),
-                                         argValues,
-                                         false,
-                                         false,
-                                         tokenlist,
-                                         errorLogger,
-                                         settings);
+                valueFlowForward(const_cast<Token*>(functionScope->bodyStart->next()),
+                                 functionScope->bodyEnd,
+                                 arg.nameToken(),
+                                 std::move(argValues),
+                                 tokenlist,
+                                 errorLogger,
+                                 settings);
         }
     }
 }
 
-static void valueFlowUnknownFunctionReturn(TokenList *tokenlist, const Settings *settings)
+static void valueFlowUnknownFunctionReturn(TokenList& tokenlist, const Settings& settings)
 {
-    if (settings->checkUnknownFunctionReturn.empty())
+    if (!tokenlist.front())
         return;
-    for (Token *tok = tokenlist->front(); tok; tok = tok->next()) {
-        if (!tok->astParent() || tok->str() != "(")
-            continue;
-        if (!Token::Match(tok->previous(), "%name%"))
+    for (Token* tok = tokenlist.front()->next(); tok; tok = tok->next()) {
+        if (!tok->astParent() || tok->str() != "(" || !tok->previous()->isName())
             continue;
-        if (settings->checkUnknownFunctionReturn.find(tok->previous()->str()) == settings->checkUnknownFunctionReturn.end())
+
+        if (const auto* f = settings.library.getAllocFuncInfo(tok->astOperand1())) {
+            if (f->noFail) {
+                // Allocation function that cannot fail
+            } else if (settings.library.returnValueType(tok->astOperand1()).find('*') != std::string::npos) {
+                // Allocation function that returns a pointer
+                ValueFlow::Value value(0);
+                value.setPossible();
+                value.errorPath.emplace_back(tok, "Assuming allocation function fails");
+                if (Library::ismemory(f->groupId))
+                    value.unknownFunctionReturn = ValueFlow::Value::UnknownFunctionReturn::outOfMemory;
+                else
+                    value.unknownFunctionReturn = ValueFlow::Value::UnknownFunctionReturn::outOfResources;
+                setTokenValue(tok, std::move(value), settings);
+                continue;
+            }
+        }
+
+        if (settings.checkUnknownFunctionReturn.find(tok->strAt(-1)) == settings.checkUnknownFunctionReturn.end())
             continue;
-        std::vector<MathLib::bigint> unknownValues = settings->library.unknownReturnValues(tok->astOperand1());
+        std::vector<MathLib::bigint> unknownValues = settings.library.unknownReturnValues(tok->astOperand1());
         if (unknownValues.empty())
             continue;
 
         // Get min/max values for return type
-        const std::string &typestr = settings->library.returnValueType(tok->previous());
+        const std::string& typestr = settings.library.returnValueType(tok->previous());
         MathLib::bigint minvalue, maxvalue;
-        if (!getMinMaxValues(typestr, settings, &minvalue, &maxvalue))
+        if (!getMinMaxValues(typestr, settings, tok->isCpp(), minvalue, maxvalue))
             continue;
 
         for (MathLib::bigint value : unknownValues) {
@@ -6425,121 +7126,308 @@ static void valueFlowUnknownFunctionReturn(TokenList *tokenlist, const Settings
                 value = minvalue;
             else if (value > maxvalue)
                 value = maxvalue;
-            setTokenValue(const_cast<Token *>(tok), ValueFlow::Value(value), settings);
-        }
-    }
-}
-
-ValueFlow::Value::Value(const Token* c, long long val)
-    : valueType(INT),
-      bound(Bound::Point),
-      intvalue(val),
-      tokvalue(nullptr),
-      floatValue(0.0),
-      moveKind(MoveKind::NonMovedVariable),
-      varvalue(val),
-      condition(c),
-      varId(0U),
-      safe(false),
-      conditional(false),
-      defaultArg(false),
-      indirect(0),
-      lifetimeKind(LifetimeKind::Object),
-      lifetimeScope(LifetimeScope::Local),
-      valueKind(ValueKind::Possible)
-{
-    errorPath.emplace_back(c, "Assuming that condition '" + c->expressionString() + "' is not redundant");
-}
-
-std::string ValueFlow::Value::infoString() const
-{
-    switch (valueType) {
-    case INT:
-        return MathLib::toString(intvalue);
-    case TOK:
-        return tokvalue->str();
-    case FLOAT:
-        return MathLib::toString(floatValue);
-    case MOVED:
-        return "<Moved>";
-    case UNINIT:
-        return "<Uninit>";
-    case BUFFER_SIZE:
-    case CONTAINER_SIZE:
-        return "size=" + MathLib::toString(intvalue);
-    case LIFETIME:
-        return "lifetime=" + tokvalue->str();
-    };
-    throw InternalError(nullptr, "Invalid ValueFlow Value type");
+            setTokenValue(tok, ValueFlow::Value(value), settings);
+        }
+    }
+}
+
+static void valueFlowDebug(TokenList& tokenlist, ErrorLogger& errorLogger, const Settings& settings)
+{
+    if (!settings.debugnormal && !settings.debugwarnings)
+        return;
+    for (Token* tok = tokenlist.front(); tok; tok = tok->next()) {
+        if (tok->getTokenDebug() != TokenDebug::ValueFlow)
+            continue;
+        if (tok->astParent() && tok->astParent()->getTokenDebug() == TokenDebug::ValueFlow)
+            continue;
+        for (const ValueFlow::Value& v : tok->values()) {
+            std::string msg = "The value is " + debugString(v);
+            ErrorPath errorPath = v.errorPath;
+            errorPath.insert(errorPath.end(), v.debugPath.cbegin(), v.debugPath.cend());
+            errorPath.emplace_back(tok, "");
+            errorLogger.reportErr({std::move(errorPath), &tokenlist, Severity::debug, "valueFlow", msg, CWE{0}, Certainty::normal});
+        }
+    }
 }
 
-const ValueFlow::Value *ValueFlow::valueFlowConstantFoldAST(Token *expr, const Settings *settings)
+const ValueFlow::Value *ValueFlow::valueFlowConstantFoldAST(Token *expr, const Settings &settings)
 {
     if (expr && expr->values().empty()) {
         valueFlowConstantFoldAST(expr->astOperand1(), settings);
         valueFlowConstantFoldAST(expr->astOperand2(), settings);
-        valueFlowSetConstantValue(expr, settings, true /* TODO: this is a guess */);
+        valueFlowSetConstantValue(expr, settings);
     }
     return expr && expr->hasKnownValue() ? &expr->values().front() : nullptr;
 }
 
-static std::size_t getTotalValues(TokenList *tokenlist)
+struct ValueFlowState {
+    explicit ValueFlowState(TokenList& tokenlist,
+                            SymbolDatabase& symboldatabase,
+                            ErrorLogger& errorLogger,
+                            const Settings& settings)
+        : tokenlist(tokenlist), symboldatabase(symboldatabase), errorLogger(errorLogger), settings(settings)
+    {}
+
+    TokenList& tokenlist;
+    SymbolDatabase& symboldatabase;
+    ErrorLogger& errorLogger;
+    const Settings& settings;
+    std::set<const Scope*> skippedFunctions;
+};
+
+struct ValueFlowPass {
+    ValueFlowPass() = default;
+    ValueFlowPass(const ValueFlowPass&) = default;
+    // Name of pass
+    virtual const char* name() const = 0;
+    // Run the pass
+    virtual void run(const ValueFlowState& state) const = 0;
+    // Returns true if pass needs C++
+    virtual bool cpp() const = 0;
+    virtual ~ValueFlowPass() noexcept = default;
+};
+
+struct ValueFlowPassRunner {
+    using Clock = std::chrono::steady_clock;
+    using TimePoint = std::chrono::time_point<Clock>;
+    explicit ValueFlowPassRunner(ValueFlowState state, TimerResultsIntf* timerResults = nullptr)
+        : state(std::move(state)), stop(TimePoint::max()), timerResults(timerResults)
+    {
+        setSkippedFunctions();
+        setStopTime();
+    }
+
+    bool run_once(std::initializer_list<ValuePtr<ValueFlowPass>> passes) const
+    {
+        return std::any_of(passes.begin(), passes.end(), [&](const ValuePtr<ValueFlowPass>& pass) {
+            return run(pass);
+        });
+    }
+
+    bool run(std::initializer_list<ValuePtr<ValueFlowPass>> passes) const
+    {
+        std::size_t values = 0;
+        std::size_t n = state.settings.vfOptions.maxIterations;
+        while (n > 0 && values != getTotalValues()) {
+            values = getTotalValues();
+            const std::string passnum = std::to_string(state.settings.vfOptions.maxIterations - n + 1);
+            if (std::any_of(passes.begin(), passes.end(), [&](const ValuePtr<ValueFlowPass>& pass) {
+                ProgressReporter progressReporter(state.errorLogger, state.settings.reportProgress >= 0, state.tokenlist.getSourceFilePath(), std::string("ValueFlow::") + pass->name() + (' ' + passnum));
+                return run(pass);
+            }))
+                return true;
+            --n;
+        }
+        if (state.settings.debugwarnings) {
+            if (n == 0 && values != getTotalValues()) {
+                ErrorMessage::FileLocation loc(state.tokenlist.getFiles()[0], 0, 0);
+                ErrorMessage errmsg({std::move(loc)},
+                                    "",
+                                    Severity::debug,
+                                    "ValueFlow maximum iterations exceeded",
+                                    "valueFlowMaxIterations",
+                                    Certainty::normal);
+                state.errorLogger.reportErr(errmsg);
+            }
+        }
+        return false;
+    }
+
+    bool run(const ValuePtr<ValueFlowPass>& pass) const
+    {
+        auto start = Clock::now();
+        if (start > stop) {
+            // TODO: add bailout message
+            return true;
+        }
+        if (!state.tokenlist.isCPP() && pass->cpp())
+            return false;
+        if (timerResults) {
+            Timer t(pass->name(), state.settings.showtime, timerResults);
+            pass->run(state);
+        } else {
+            pass->run(state);
+        }
+        return false;
+    }
+
+    std::size_t getTotalValues() const
+    {
+        std::size_t n = 1;
+        for (Token* tok = state.tokenlist.front(); tok; tok = tok->next())
+            n += tok->values().size();
+        return n;
+    }
+
+    void setSkippedFunctions()
+    {
+        if (state.settings.vfOptions.maxIfCount > 0) {
+            for (const Scope* functionScope : state.symboldatabase.functionScopes) {
+                int countIfScopes = 0;
+                std::vector<const Scope*> scopes{functionScope};
+                while (!scopes.empty()) {
+                    const Scope* s = scopes.back();
+                    scopes.pop_back();
+                    for (const Scope* s2 : s->nestedList) {
+                        scopes.emplace_back(s2);
+                        if (s2->type == ScopeType::eIf)
+                            ++countIfScopes;
+                    }
+                }
+                if (countIfScopes > state.settings.vfOptions.maxIfCount) {
+                    state.skippedFunctions.emplace(functionScope);
+
+                    if (state.settings.severity.isEnabled(Severity::information)) {
+                        const std::string& functionName = functionScope->className;
+                        std::list<ErrorMessage::FileLocation> callstack(
+                            1,
+                            ErrorMessage::FileLocation(functionScope->bodyStart, &state.tokenlist));
+                        const ErrorMessage errmsg(std::move(callstack),
+                                                  state.tokenlist.getSourceFilePath(),
+                                                  Severity::information,
+                                                  "Limiting ValueFlow analysis in function '" + functionName + "' since it is too complex. "
+                                                  "Please specify --check-level=exhaustive to perform full analysis.",
+                                                  "checkLevelNormal", // TODO: use more specific ID
+                                                  Certainty::normal);
+                        state.errorLogger.reportErr(errmsg);
+                    }
+                }
+            }
+        }
+    }
+
+    void setStopTime()
+    {
+        if (state.settings.vfOptions.maxTime >= 0)
+            stop = Clock::now() + std::chrono::seconds{state.settings.vfOptions.maxTime};
+    }
+
+    ValueFlowState state;
+    TimePoint stop;
+    TimerResultsIntf* timerResults;
+};
+
+template<class F>
+struct ValueFlowPassAdaptor : ValueFlowPass {
+    const char* mName = nullptr;
+    bool mCPP = false;
+    F mRun;
+    ValueFlowPassAdaptor(const char* pname, bool pcpp, F prun) : ValueFlowPass(), mName(pname), mCPP(pcpp), mRun(prun) {}
+    const char* name() const override {
+        return mName;
+    }
+    void run(const ValueFlowState& state) const override
+    {
+        mRun(state.tokenlist, state.symboldatabase, state.errorLogger, state.settings, state.skippedFunctions);
+    }
+    bool cpp() const override {
+        return mCPP;
+    }
+};
+
+template<class F>
+static ValueFlowPassAdaptor<F> makeValueFlowPassAdaptor(const char* name, bool cpp, F run)
 {
-    std::size_t n = 1;
-    for (Token *tok = tokenlist->front(); tok; tok = tok->next())
-        n += tok->values().size();
-    return n;
+    return {name, cpp, run};
 }
 
-void ValueFlow::setValues(TokenList *tokenlist, SymbolDatabase* symboldatabase, ErrorLogger *errorLogger, const Settings *settings)
+#define VALUEFLOW_ADAPTOR(cpp, ...)                                                                                    \
+    makeValueFlowPassAdaptor(#__VA_ARGS__,                                                                             \
+                             (cpp),                                                                                      \
+                             [](TokenList& tokenlist,                                                                  \
+                                SymbolDatabase& symboldatabase,                                                        \
+                                ErrorLogger& errorLogger,                                                              \
+                                const Settings& settings,                                                              \
+                                const std::set<const Scope*>& skippedFunctions) {                                      \
+        (void)tokenlist;                                                                      \
+        (void)symboldatabase;                                                                 \
+        (void)errorLogger;                                                                    \
+        (void)settings;                                                                       \
+        (void)skippedFunctions;                                                               \
+        __VA_ARGS__;                                                                          \
+    })
+
+#define VFA(...) VALUEFLOW_ADAPTOR(false, __VA_ARGS__)
+#define VFA_CPP(...) VALUEFLOW_ADAPTOR(true, __VA_ARGS__)
+
+void ValueFlow::setValues(TokenList& tokenlist,
+                          SymbolDatabase& symboldatabase,
+                          ErrorLogger& errorLogger,
+                          const Settings& settings,
+                          TimerResultsIntf* timerResults)
 {
-    for (Token *tok = tokenlist->front(); tok; tok = tok->next())
+    ProgressReporter progressReporter(errorLogger, settings.reportProgress, tokenlist.getSourceFilePath(), "ValueFlow");
+
+    for (Token* tok = tokenlist.front(); tok; tok = tok->next())
         tok->clearValueFlow();
 
-    valueFlowNumber(tokenlist);
-    valueFlowString(tokenlist);
-    valueFlowArray(tokenlist);
-    valueFlowUnknownFunctionReturn(tokenlist, settings);
-    valueFlowGlobalConstVar(tokenlist, settings);
-    valueFlowGlobalStaticVar(tokenlist, settings);
-    valueFlowPointerAlias(tokenlist);
-    valueFlowLifetime(tokenlist, symboldatabase, errorLogger, settings);
-    valueFlowFunctionReturn(tokenlist, errorLogger);
-    valueFlowBitAnd(tokenlist);
-    valueFlowSameExpressions(tokenlist);
-    valueFlowFwdAnalysis(tokenlist, settings);
-
-    std::size_t values = 0;
-    std::size_t n = 4;
-    while (n > 0 && values < getTotalValues(tokenlist)) {
-        values = getTotalValues(tokenlist);
-        valueFlowPointerAliasDeref(tokenlist);
-        valueFlowArrayBool(tokenlist);
-        valueFlowRightShift(tokenlist, settings);
-        valueFlowOppositeCondition(symboldatabase, settings);
-        valueFlowTerminatingCondition(tokenlist, symboldatabase, errorLogger, settings);
-        valueFlowBeforeCondition(tokenlist, symboldatabase, errorLogger, settings);
-        valueFlowAfterMove(tokenlist, symboldatabase, errorLogger, settings);
-        valueFlowAfterAssign(tokenlist, symboldatabase, errorLogger, settings);
-        valueFlowAfterCondition(tokenlist, symboldatabase, errorLogger, settings);
-        valueFlowInferCondition(tokenlist, settings);
-        valueFlowSwitchVariable(tokenlist, symboldatabase, errorLogger, settings);
-        valueFlowForLoop(tokenlist, symboldatabase, errorLogger, settings);
-        valueFlowSubFunction(tokenlist, errorLogger, settings);
-        valueFlowFunctionDefaultParameter(tokenlist, symboldatabase, errorLogger, settings);
-        valueFlowUninit(tokenlist, symboldatabase, errorLogger, settings);
-        if (tokenlist->isCPP()) {
-            valueFlowSmartPointer(tokenlist, errorLogger, settings);
-            valueFlowContainerSize(tokenlist, symboldatabase, errorLogger, settings);
-            valueFlowContainerAfterCondition(tokenlist, symboldatabase, errorLogger, settings);
-        }
-        valueFlowSafeFunctions(tokenlist, symboldatabase, errorLogger, settings);
-        n--;
-    }
-
-    valueFlowDynamicBufferSize(tokenlist, symboldatabase, errorLogger, settings);
-}
+    // commas in init..
+    for (Token* tok = tokenlist.front(); tok; tok = tok->next()) {
+        if (tok->str() != "{" || !tok->astOperand1())
+            continue;
+        for (Token* tok2 = tok->next(); tok2 != tok->link(); tok2 = tok2->next()) {
+            if (tok2->link() && Token::Match(tok2, "[{[(<]"))
+                tok2 = tok2->link();
+            else if (tok2->str() == ",")
+                tok2->isInitComma(true);
+        }
+    }
+
+    ValueFlowPassRunner runner{ValueFlowState{tokenlist, symboldatabase, errorLogger, settings}, timerResults};
+    runner.run_once({
+        VFA(valueFlowEnumValue(symboldatabase, settings)),
+        VFA(valueFlowNumber(tokenlist, settings)),
+        VFA(valueFlowString(tokenlist, settings)),
+        VFA(valueFlowTypeTraits(tokenlist, settings)),
+        VFA(valueFlowArray(tokenlist, settings)),
+        VFA(valueFlowUnknownFunctionReturn(tokenlist, settings)),
+        VFA(valueFlowGlobalConstVar(tokenlist, settings)),
+        VFA(valueFlowEnumValue(symboldatabase, settings)),
+        VFA(valueFlowGlobalStaticVar(tokenlist, settings)),
+        VFA(valueFlowPointerAlias(tokenlist, settings)),
+        VFA(valueFlowLifetime(tokenlist, errorLogger, settings)),
+        VFA(valueFlowSymbolic(tokenlist, symboldatabase, errorLogger, settings)),
+        VFA(valueFlowBitAnd(tokenlist, settings)),
+        VFA(valueFlowSameExpressions(tokenlist, settings)),
+        VFA(valueFlowConditionExpressions(tokenlist, symboldatabase, errorLogger, settings)),
+    });
+
+    runner.run({
+        VFA(valueFlowImpossibleValues(tokenlist, settings)),
+        VFA(valueFlowSymbolicOperators(symboldatabase, settings)),
+        VFA(valueFlowCondition(SymbolicConditionHandler{}, tokenlist, symboldatabase, errorLogger, settings, skippedFunctions)),
+        VFA(valueFlowSymbolicInfer(symboldatabase, settings)),
+        VFA(valueFlowArrayBool(tokenlist, settings)),
+        VFA(valueFlowArrayElement(tokenlist, settings)),
+        VFA(valueFlowRightShift(tokenlist, settings)),
+        VFA_CPP(
+            valueFlowCondition(ContainerConditionHandler{}, tokenlist, symboldatabase, errorLogger, settings, skippedFunctions)),
+        VFA(valueFlowAfterAssign(tokenlist, symboldatabase, errorLogger, settings, skippedFunctions)),
+        VFA_CPP(valueFlowAfterSwap(tokenlist, symboldatabase, errorLogger, settings)),
+        VFA(valueFlowCondition(SimpleConditionHandler{}, tokenlist, symboldatabase, errorLogger, settings, skippedFunctions)),
+        VFA(valueFlowInferCondition(tokenlist, settings)),
+        VFA(valueFlowSwitchVariable(tokenlist, symboldatabase, errorLogger, settings)),
+        VFA(valueFlowForLoop(tokenlist, symboldatabase, errorLogger, settings)),
+        VFA(valueFlowSubFunction(tokenlist, symboldatabase, errorLogger, settings)),
+        VFA(valueFlowFunctionReturn(tokenlist, errorLogger, settings)),
+        VFA(valueFlowLifetime(tokenlist, errorLogger, settings)),
+        VFA(valueFlowFunctionDefaultParameter(tokenlist, symboldatabase, errorLogger, settings)),
+        VFA(valueFlowUninit(tokenlist, errorLogger, settings)),
+        VFA_CPP(valueFlowAfterMove(tokenlist, symboldatabase, errorLogger, settings)),
+        VFA_CPP(valueFlowSmartPointer(tokenlist, errorLogger, settings)),
+        VFA_CPP(valueFlowIterators(tokenlist, settings)),
+        VFA_CPP(
+            valueFlowCondition(IteratorConditionHandler{}, tokenlist, symboldatabase, errorLogger, settings, skippedFunctions)),
+        VFA_CPP(valueFlowIteratorInfer(tokenlist, settings)),
+        VFA_CPP(valueFlowContainerSize(tokenlist, symboldatabase, errorLogger, settings, skippedFunctions)),
+        VFA(valueFlowSafeFunctions(tokenlist, symboldatabase, errorLogger, settings)),
+    });
 
+    runner.run_once({
+        VFA(valueFlowDynamicBufferSize(tokenlist, symboldatabase, errorLogger, settings)),
+        VFA(valueFlowDebug(tokenlist, errorLogger, settings)), // TODO: add option to print it after each step/iteration
+    });
+}
 
 std::string ValueFlow::eitherTheConditionIsRedundant(const Token *condition)
 {
@@ -6556,3 +7444,77 @@ std::string ValueFlow::eitherTheConditionIsRedundant(const Token *condition)
     }
     return "Either the condition '" + condition->expressionString() + "' is redundant";
 }
+
+const ValueFlow::Value* ValueFlow::findValue(const std::list<ValueFlow::Value>& values,
+                                             const Settings& settings,
+                                             const std::function<bool(const ValueFlow::Value&)> &pred)
+{
+    const ValueFlow::Value* ret = nullptr;
+    for (const ValueFlow::Value& v : values) {
+        if (pred(v)) {
+            if (!ret || ret->isInconclusive() || (ret->condition && !v.isInconclusive()))
+                ret = &v;
+            if (!ret->isInconclusive() && !ret->condition)
+                break;
+        }
+    }
+    if (ret) {
+        if (ret->isInconclusive() && !settings.certainty.isEnabled(Certainty::inconclusive))
+            return nullptr;
+        if (ret->condition && !settings.severity.isEnabled(Severity::warning))
+            return nullptr;
+    }
+    return ret;
+}
+
+// TODO: returns a single value at most - no need for std::vector
+static std::vector<ValueFlow::Value> isOutOfBoundsImpl(const ValueFlow::Value& size,
+                                                       const Token* indexTok,
+                                                       bool condition)
+{
+    if (!indexTok)
+        return {};
+    const ValueFlow::Value* indexValue = indexTok->getMaxValue(condition, size.path);
+    if (!indexValue)
+        return {};
+    if (indexValue->intvalue >= size.intvalue)
+        return {*indexValue};
+    if (!condition)
+        return {};
+    // TODO: Use a better way to decide if the variable in unconstrained
+    if (!indexTok->variable() || !indexTok->variable()->isArgument())
+        return {};
+    if (std::any_of(indexTok->values().cbegin(), indexTok->values().cend(), [&](const ValueFlow::Value& v) {
+        return v.isSymbolicValue() && v.isPossible() && v.bound == ValueFlow::Value::Bound::Upper;
+    }))
+        return {};
+    if (indexValue->bound != ValueFlow::Value::Bound::Lower)
+        return {};
+    if (size.bound == ValueFlow::Value::Bound::Lower)
+        return {};
+    // Checking for underflow doesn't mean it could be out of bounds
+    if (indexValue->intvalue == 0)
+        return {};
+    ValueFlow::Value value = inferCondition(">=", indexTok, indexValue->intvalue);
+    if (!value.isKnown())
+        return {};
+    if (value.intvalue == 0)
+        return {};
+    value.intvalue = size.intvalue;
+    value.bound = ValueFlow::Value::Bound::Lower;
+    return {std::move(value)};
+}
+
+// TODO: return single value at most - no need for std::vector
+std::vector<ValueFlow::Value> ValueFlow::isOutOfBounds(const Value& size, const Token* indexTok, bool possible)
+{
+    ValueFlow::Value inBoundsValue = inferCondition("<", indexTok, size.intvalue);
+    if (inBoundsValue.isKnown() && inBoundsValue.intvalue != 0)
+        return {};
+    std::vector<ValueFlow::Value> result = isOutOfBoundsImpl(size, indexTok, false);
+    if (!result.empty())
+        return result;
+    if (!possible)
+        return result;
+    return isOutOfBoundsImpl(size, indexTok, true);
+}
diff --git a/lib/valueflow.h b/lib/valueflow.h
index 3f686bfd541..f701f55c418 100644
--- a/lib/valueflow.h
+++ b/lib/valueflow.h
@@ -1,6 +1,6 @@
-/*
+/* -*- C++ -*-
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -22,8 +22,10 @@
 //---------------------------------------------------------------------------
 
 #include "config.h"
-#include "utils.h"
+#include "errortypes.h"
+#include "mathlib.h"
 
+#include <functional>
 #include <list>
 #include <string>
 #include <utility>
@@ -32,335 +34,100 @@
 class ErrorLogger;
 class Settings;
 class SymbolDatabase;
+class TimerResultsIntf;
 class Token;
 class TokenList;
 class Variable;
+class Scope;
 
-namespace ValueFlow {
-    struct increment {
-        template <class T>
-        void operator()(T& x) const {
-            x++;
-        }
-    };
-    struct decrement {
-        template <class T>
-        void operator()(T& x) const {
-            x--;
-        }
-    };
-    class CPPCHECKLIB Value {
-    public:
-        typedef std::pair<const Token *, std::string> ErrorPathItem;
-        typedef std::list<ErrorPathItem> ErrorPath;
-
-        explicit Value(long long val = 0)
-            : valueType(ValueType::INT),
-              bound(Bound::Point),
-              intvalue(val),
-              tokvalue(nullptr),
-              floatValue(0.0),
-              moveKind(MoveKind::NonMovedVariable),
-              varvalue(val),
-              condition(nullptr),
-              varId(0U),
-              safe(false),
-              conditional(false),
-              defaultArg(false),
-              indirect(0),
-              lifetimeKind(LifetimeKind::Object),
-              lifetimeScope(LifetimeScope::Local),
-              valueKind(ValueKind::Possible)
-        {}
-        Value(const Token *c, long long val);
-
-        bool equalValue(const ValueFlow::Value& rhs) const {
-            if (valueType != rhs.valueType)
-                return false;
-            switch (valueType) {
-            case ValueType::INT:
-                if (intvalue != rhs.intvalue)
-                    return false;
-                break;
-            case ValueType::TOK:
-                if (tokvalue != rhs.tokvalue)
-                    return false;
-                break;
-            case ValueType::FLOAT:
-                // TODO: Write some better comparison
-                if (floatValue > rhs.floatValue || floatValue < rhs.floatValue)
-                    return false;
-                break;
-            case ValueType::MOVED:
-                if (moveKind != rhs.moveKind)
-                    return false;
-                break;
-            case ValueType::UNINIT:
-                break;
-            case ValueType::BUFFER_SIZE:
-                if (intvalue != rhs.intvalue)
-                    return false;
-                break;
-            case ValueType::CONTAINER_SIZE:
-                if (intvalue != rhs.intvalue)
-                    return false;
-                break;
-            case ValueType::LIFETIME:
-                if (tokvalue != rhs.tokvalue)
-                    return false;
-            }
-            return true;
-        }
-
-        template <class F>
-        void visitValue(F f) {
-            switch (valueType) {
-            case ValueType::INT:
-            case ValueType::BUFFER_SIZE:
-            case ValueType::CONTAINER_SIZE: {
-                f(intvalue);
-                break;
-            }
-            case ValueType::FLOAT: {
-                f(floatValue);
-                break;
-            }
-            case ValueType::UNINIT:
-            case ValueType::TOK:
-            case ValueType::LIFETIME:
-            case ValueType::MOVED:
-                break;
-            }
-        }
-
-        bool operator==(const Value &rhs) const {
-            if (!equalValue(rhs))
-                return false;
-
-            return varvalue == rhs.varvalue &&
-                   condition == rhs.condition &&
-                   varId == rhs.varId &&
-                   conditional == rhs.conditional &&
-                   defaultArg == rhs.defaultArg &&
-                   indirect == rhs.indirect &&
-                   valueKind == rhs.valueKind;
-        }
-
-        bool operator!=(const Value &rhs) const {
-            return !(*this == rhs);
-        }
-
-        void decreaseRange() {
-            if (bound == Bound::Lower)
-                visitValue(increment{});
-            else if (bound == Bound::Upper)
-                visitValue(decrement{});
-        }
-
-        void invertRange() {
-            if (bound == Bound::Lower)
-                bound = Bound::Upper;
-            else if (bound == Bound::Upper)
-                bound = Bound::Lower;
-            decreaseRange();
-        }
-
-        std::string infoString() const;
-
-        enum ValueType { INT, TOK, FLOAT, MOVED, UNINIT, CONTAINER_SIZE, LIFETIME, BUFFER_SIZE } valueType;
-        bool isIntValue() const {
-            return valueType == ValueType::INT;
-        }
-        bool isTokValue() const {
-            return valueType == ValueType::TOK;
-        }
-        bool isFloatValue() const {
-            return valueType == ValueType::FLOAT;
-        }
-        bool isMovedValue() const {
-            return valueType == ValueType::MOVED;
-        }
-        bool isUninitValue() const {
-            return valueType == ValueType::UNINIT;
-        }
-        bool isContainerSizeValue() const {
-            return valueType == ValueType::CONTAINER_SIZE;
-        }
-        bool isLifetimeValue() const {
-            return valueType == ValueType::LIFETIME;
-        }
-        bool isBufferSizeValue() const {
-            return valueType == ValueType::BUFFER_SIZE;
-        }
-
-        bool isLocalLifetimeValue() const {
-            return valueType == ValueType::LIFETIME && lifetimeScope == LifetimeScope::Local;
-        }
-
-        bool isArgumentLifetimeValue() const {
-            return valueType == ValueType::LIFETIME && lifetimeScope == LifetimeScope::Argument;
-        }
-
-        bool isNonValue() const {
-            return isMovedValue() || isUninitValue() || isLifetimeValue();
-        }
+namespace ValueFlow
+{
+    class Value;
+}
 
-        /** The value bound  */
-        enum class Bound { Upper, Lower, Point } bound;
+namespace ValueFlow {
+    /// Constant folding of expression. This can be used before the full ValueFlow has been executed (ValueFlow::setValues).
+    const Value * valueFlowConstantFoldAST(Token *expr, const Settings &settings);
 
-        /** int value */
-        long long intvalue;
+    /// Perform valueflow analysis.
+    void setValues(TokenList& tokenlist,
+                   SymbolDatabase& symboldatabase,
+                   ErrorLogger& errorLogger,
+                   const Settings& settings,
+                   TimerResultsIntf* timerResults);
 
-        /** token value - the token that has the value. this is used for pointer aliases, strings, etc. */
-        const Token *tokvalue;
+    std::string eitherTheConditionIsRedundant(const Token *condition);
 
-        /** float value */
-        double floatValue;
+    const Value* findValue(const std::list<Value>& values,
+                           const Settings& settings,
+                           const std::function<bool(const Value&)> &pred);
 
-        /** kind of moved  */
-        enum class MoveKind {NonMovedVariable, MovedVariable, ForwardedVariable} moveKind;
+    std::vector<Value> isOutOfBounds(const Value& size, const Token* indexTok, bool possible = true);
 
-        /** For calculated values - variable value that calculated value depends on */
-        long long varvalue;
+    Value asImpossible(Value v);
 
-        /** Condition that this value depends on */
-        const Token *condition;
+    bool isContainerSizeChanged(const Token* tok, int indirect, const Settings& settings, int depth = 20);
 
+    struct LifetimeToken {
+        const Token* token{};
         ErrorPath errorPath;
+        bool addressOf{};
+        bool inconclusive{};
 
-        /** For calculated values - varId that calculated value depends on */
-        nonneg int varId;
-
-        /** value relies on safe checking */
-        bool safe;
-
-        /** Conditional value */
-        bool conditional;
-
-        /** Is this value passed as default parameter to the function? */
-        bool defaultArg;
-
-        int indirect;
-
-        enum class LifetimeKind {Object, Lambda, Iterator, Address} lifetimeKind;
-
-        enum class LifetimeScope { Local, Argument } lifetimeScope;
-
-        static const char * toString(MoveKind moveKind) {
-            switch (moveKind) {
-            case MoveKind::NonMovedVariable:
-                return "NonMovedVariable";
-            case MoveKind::MovedVariable:
-                return "MovedVariable";
-            case MoveKind::ForwardedVariable:
-                return "ForwardedVariable";
-            }
-            return "";
-        }
-
-        /** How known is this value */
-        enum class ValueKind {
-            /** This value is possible, other unlisted values may also be possible */
-            Possible,
-            /** Only listed values are possible */
-            Known,
-            /** Inconclusive */
-            Inconclusive,
-            /** Listed values are impossible */
-            Impossible
-        } valueKind;
-
-        void setKnown() {
-            valueKind = ValueKind::Known;
-        }
-
-        bool isKnown() const {
-            return valueKind == ValueKind::Known;
-        }
-
-        void setPossible() {
-            valueKind = ValueKind::Possible;
-        }
+        LifetimeToken() = default;
 
-        bool isPossible() const {
-            return valueKind == ValueKind::Possible;
-        }
-
-        bool isImpossible() const {
-            return valueKind == ValueKind::Impossible;
-        }
-
-        void setImpossible() {
-            valueKind = ValueKind::Impossible;
-        }
-
-        void setInconclusive(bool inconclusive = true) {
-            if (inconclusive)
-                valueKind = ValueKind::Inconclusive;
-        }
+        LifetimeToken(const Token* token, ErrorPath errorPath)
+            : token(token), errorPath(std::move(errorPath))
+        {}
 
-        bool isInconclusive() const {
-            return valueKind == ValueKind::Inconclusive;
-        }
+        LifetimeToken(const Token* token, bool addressOf, ErrorPath errorPath)
+            : token(token), errorPath(std::move(errorPath)), addressOf(addressOf)
+        {}
 
-        void changeKnownToPossible() {
-            if (isKnown())
-                valueKind = ValueKind::Possible;
+        static std::vector<LifetimeToken> setAddressOf(std::vector<LifetimeToken> v, bool b) {
+            for (LifetimeToken& x : v)
+                x.addressOf = b;
+            return v;
         }
 
-        bool errorSeverity() const {
-            return !condition && !defaultArg;
+        static std::vector<LifetimeToken> setInconclusive(std::vector<LifetimeToken> v, bool b) {
+            for (LifetimeToken& x : v)
+                x.inconclusive = b;
+            return v;
         }
     };
 
-    /// Constant folding of expression. This can be used before the full ValueFlow has been executed (ValueFlow::setValues).
-    const ValueFlow::Value * valueFlowConstantFoldAST(Token *expr, const Settings *settings);
+    const Token *parseCompareInt(const Token *tok, Value &true_value, Value &false_value, const std::function<std::vector<MathLib::bigint>(const Token*)>& evaluate);
+    const Token *parseCompareInt(const Token *tok, Value &true_value, Value &false_value);
 
-    /// Perform valueflow analysis.
-    void setValues(TokenList *tokenlist, SymbolDatabase* symboldatabase, ErrorLogger *errorLogger, const Settings *settings);
+    const Token* solveExprValue(const Token* expr,
+                                const std::function<std::vector<MathLib::bigint>(const Token*)>& eval,
+                                Value& value);
 
-    std::string eitherTheConditionIsRedundant(const Token *condition);
-}
+    std::vector<LifetimeToken> getLifetimeTokens(const Token* tok,
+                                                 const Settings& settings,
+                                                 bool escape = false,
+                                                 ErrorPath errorPath = ErrorPath{});
 
-struct LifetimeToken {
-    const Token* token;
-    bool addressOf;
-    ValueFlow::Value::ErrorPath errorPath;
-    bool inconclusive;
+    bool hasLifetimeToken(const Token* tok, const Token* lifetime, const Settings& settings);
 
-    LifetimeToken() : token(nullptr), addressOf(false), errorPath(), inconclusive(false) {}
+    const Variable* getLifetimeVariable(const Token* tok, ErrorPath& errorPath, const Settings& settings, bool* addressOf = nullptr);
 
-    LifetimeToken(const Token* token, ValueFlow::Value::ErrorPath errorPath)
-        : token(token), addressOf(false), errorPath(std::move(errorPath)), inconclusive(false)
-    {}
+    const Variable* getLifetimeVariable(const Token* tok, const Settings& settings);
 
-    LifetimeToken(const Token* token, bool addressOf, ValueFlow::Value::ErrorPath errorPath)
-        : token(token), addressOf(addressOf), errorPath(std::move(errorPath)), inconclusive(false)
-    {}
+    bool isLifetimeBorrowed(const Token *tok, const Settings &settings);
 
-    static std::vector<LifetimeToken> setAddressOf(std::vector<LifetimeToken> v, bool b) {
-        for (LifetimeToken& x : v)
-            x.addressOf = b;
-        return v;
-    }
+    std::string lifetimeMessage(const Token *tok, const Value *val, ErrorPath &errorPath);
 
-    static std::vector<LifetimeToken> setInconclusive(std::vector<LifetimeToken> v, bool b) {
-        for (LifetimeToken& x : v)
-            x.inconclusive = b;
-        return v;
-    }
-};
+    CPPCHECKLIB Value getLifetimeObjValue(const Token *tok, bool inconclusive = false);
 
-std::vector<LifetimeToken> getLifetimeTokens(const Token* tok, ValueFlow::Value::ErrorPath errorPath = ValueFlow::Value::ErrorPath{}, int depth = 20);
+    CPPCHECKLIB std::vector<Value> getLifetimeObjValues(const Token* tok,
+                                                        bool inconclusive = false,
+                                                        MathLib::bigint path = 0);
 
-const Variable* getLifetimeVariable(const Token* tok, ValueFlow::Value::ErrorPath& errorPath, bool* addressOf = nullptr);
+    const Token* getEndOfExprScope(const Token* tok, const Scope* defaultScope = nullptr, bool smallest = true);
 
-bool isLifetimeBorrowed(const Token *tok, const Settings *settings);
-
-std::string lifetimeType(const Token *tok, const ValueFlow::Value *val);
-
-std::string lifetimeMessage(const Token *tok, const ValueFlow::Value *val, ValueFlow::Value::ErrorPath &errorPath);
-
-ValueFlow::Value getLifetimeObjValue(const Token *tok);
+    void combineValueProperties(const Value& value1, const Value& value2, Value& result);
+}
 
 #endif // valueflowH
diff --git a/lib/valueptr.h b/lib/valueptr.h
new file mode 100644
index 00000000000..5e0bea0196b
--- /dev/null
+++ b/lib/valueptr.h
@@ -0,0 +1,100 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+//---------------------------------------------------------------------------
+#ifndef valueptrH
+#define valueptrH
+//---------------------------------------------------------------------------
+
+#include "config.h"
+
+#include <memory>
+
+template<class T>
+class CPPCHECKLIB ValuePtr {
+    template<class U>
+    struct cloner {
+        static T* apply(const T* x) {
+            return new U(*static_cast<const U*>(x));
+        }
+    };
+
+public:
+    using pointer = T*;
+    using element_type = T;
+    // cppcheck-suppress simplifyUsing - TODO: fix this
+    using cloner_type = decltype(&cloner<T>::apply);
+
+    ValuePtr() : mPtr(nullptr), mClone() {}
+
+    template<class U>
+    // cppcheck-suppress noExplicitConstructor
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    ValuePtr(const U& value) : mPtr(cloner<U>::apply(&value)), mClone(&cloner<U>::apply)
+    {}
+
+    ValuePtr(const ValuePtr& rhs) : mPtr(nullptr), mClone(rhs.mClone) {
+        if (rhs) {
+            mPtr.reset(mClone(rhs.get()));
+        }
+    }
+    ValuePtr(ValuePtr&& rhs) NOEXCEPT : mPtr(std::move(rhs.mPtr)), mClone(std::move(rhs.mClone)) {}
+
+    T* get() NOEXCEPT {
+        return mPtr.get();
+    }
+    const T* get() const NOEXCEPT {
+        return mPtr.get();
+    }
+
+    T& operator*() {
+        return *get();
+    }
+    const T& operator*() const {
+        return *get();
+    }
+
+    T* operator->() NOEXCEPT {
+        return get();
+    }
+    const T* operator->() const NOEXCEPT {
+        return get();
+    }
+
+    void swap(ValuePtr& rhs) NOEXCEPT {
+        using std::swap;
+        swap(mPtr, rhs.mPtr);
+        swap(mClone, rhs.mClone);
+    }
+
+    ValuePtr<T>& operator=(ValuePtr rhs) & {
+        swap(rhs);
+        return *this;
+    }
+
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    operator bool() const NOEXCEPT {
+        return !!mPtr;
+    }
+
+private:
+    std::shared_ptr<T> mPtr;
+    cloner_type mClone;
+};
+
+#endif
diff --git a/lib/version.h b/lib/version.h
index c819a0bf32e..2a64885ffa8 100644
--- a/lib/version.h
+++ b/lib/version.h
@@ -1,14 +1,28 @@
-#define CPPCHECK_MAJOR 1
-#define CPPCHECK_MINOR 89
-#define CPPCHECK_DEVMINOR 90
-
-#define STRINGIFY(x) STRING(x)
-#define STRING(VER) #VER
-#if CPPCHECK_MINOR == CPPCHECK_DEVMINOR
-#define CPPCHECK_VERSION_STRING STRINGIFY(CPPCHECK_MAJOR) "." STRINGIFY(CPPCHECK_DEVMINOR)
-#define CPPCHECK_VERSION CPPCHECK_MAJOR,CPPCHECK_MINOR,0,0
-#else
-#define CPPCHECK_VERSION_STRING STRINGIFY(CPPCHECK_MAJOR) "." STRINGIFY(CPPCHECK_DEVMINOR) " dev"
-#define CPPCHECK_VERSION CPPCHECK_MAJOR,CPPCHECK_MINOR,99,0
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef versionH
+#define versionH
+
+#define CPPCHECK_VERSION_STRING "2.21 dev"
+#define CPPCHECK_VERSION 2,20,99,0
+
+#define LEGALCOPYRIGHT L"Copyright (C) 2007-2026 Cppcheck team."
+
 #endif
-#define LEGALCOPYRIGHT L"Copyright (C) 2007-2019 Cppcheck team."
diff --git a/lib/version.rc b/lib/version.rc
index cff2debd7c0..bf438f314b1 100644
--- a/lib/version.rc
+++ b/lib/version.rc
@@ -1,34 +1,34 @@
-#include "version.h"
-#include "winresrc.h"
-
-VS_VERSION_INFO VERSIONINFO
- FILEVERSION CPPCHECK_VERSION
- PRODUCTVERSION CPPCHECK_VERSION
- FILEFLAGSMASK 0x17L
-#ifdef _DEBUG
- FILEFLAGS (0x1L|VS_FF_PRERELEASE)
-#else
- FILEFLAGS (0x0L|VS_FF_PRERELEASE)
-#endif
- FILEOS VOS__WINDOWS32
- FILETYPE VFT_DLL
- FILESUBTYPE VFT2_UNKNOWN
-BEGIN
-    BLOCK "StringFileInfo"
-    BEGIN
-        BLOCK "040904b0"
-        BEGIN
-            VALUE "FileDescription", "cppcheck core library"
-            VALUE "FileVersion", CPPCHECK_VERSION_STRING
-            VALUE "InternalName", "cppcheck"
-            VALUE "LegalCopyright", LEGALCOPYRIGHT
-            VALUE "OriginalFilename", "cppcheck.exe"
-            VALUE "ProductName", "cppcheck core library"
-            VALUE "ProductVersion", CPPCHECK_VERSION_STRING
-        END
-    END
-    BLOCK "VarFileInfo"
-    BEGIN
-        VALUE "Translation", 0x409, 1200
-    END
-END
+#include "version.h"
+#include "winresrc.h"
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION CPPCHECK_VERSION
+ PRODUCTVERSION CPPCHECK_VERSION
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS (0x1L|VS_FF_PRERELEASE)
+#else
+ FILEFLAGS (0x0L|VS_FF_PRERELEASE)
+#endif
+ FILEOS VOS__WINDOWS32
+ FILETYPE VFT_DLL
+ FILESUBTYPE VFT2_UNKNOWN
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "FileDescription", "cppcheck core library"
+            VALUE "FileVersion", CPPCHECK_VERSION_STRING
+            VALUE "InternalName", "cppcheck"
+            VALUE "LegalCopyright", LEGALCOPYRIGHT
+            VALUE "OriginalFilename", "cppcheck.exe"
+            VALUE "ProductName", "cppcheck core library"
+            VALUE "ProductVersion", CPPCHECK_VERSION_STRING
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
diff --git a/lib/vf_analyzers.cpp b/lib/vf_analyzers.cpp
new file mode 100644
index 00000000000..58fbe0b6d61
--- /dev/null
+++ b/lib/vf_analyzers.cpp
@@ -0,0 +1,1612 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "vf_analyzers.h"
+
+#include "analyzer.h"
+#include "astutils.h"
+#include "calculate.h"
+#include "config.h"
+#include "library.h"
+#include "mathlib.h"
+#include "programmemory.h"
+#include "smallvector.h"
+#include "settings.h"
+#include "symboldatabase.h"
+#include "token.h"
+#include "utils.h"
+#include "vfvalue.h"
+#include "valueptr.h"
+#include "valueflow.h"
+
+#include "vf_common.h"
+#include "vf_settokenvalue.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <functional>
+#include <initializer_list>
+#include <iterator>
+#include <list>
+#include <set>
+#include <type_traits>
+
+static bool isDereferenceOp(const Token* tok)
+{
+    if (!tok)
+        return false;
+    if (!tok->astOperand1())
+        return false;
+    if (tok->str() == "*")
+        return true;
+    return tok->str() == "." && tok->originalName() == "->";
+}
+
+struct ValueFlowAnalyzer : Analyzer {
+    const Settings& settings;
+    ProgramMemoryState pms;
+
+    explicit ValueFlowAnalyzer(const Settings& s) : settings(s), pms(settings) {}
+
+    virtual const ValueFlow::Value* getValue(const Token* tok) const = 0;
+    virtual ValueFlow::Value* getValue(const Token* tok) = 0;
+
+    virtual void makeConditional() = 0;
+
+    virtual void addErrorPath(const Token* tok, const std::string& s) = 0;
+
+    virtual bool match(const Token* tok) const = 0;
+
+    virtual bool internalMatch(const Token* /*tok*/) const {
+        return false;
+    }
+
+    virtual bool isAlias(const Token* tok, bool& inconclusive) const = 0;
+
+    using ProgramState = ProgramMemory::Map;
+
+    virtual ProgramState getProgramState() const = 0;
+
+    virtual int getIndirect(const Token* tok) const {
+        const ValueFlow::Value* value = getValue(tok);
+        if (value)
+            return value->indirect;
+        return 0;
+    }
+
+    virtual bool isGlobal() const {
+        return false;
+    }
+    virtual bool dependsOnThis() const {
+        return false;
+    }
+    virtual bool isClassVariable() const {
+        return false;
+    }
+
+    const Settings& getSettings() const {
+        return settings;
+    }
+
+    struct ConditionState {
+        bool dependent = true;
+        bool unknown = true;
+
+        bool isUnknownDependent() const {
+            return unknown && dependent;
+        }
+    };
+
+    ConditionState analyzeCondition(const Token* tok, int depth = 20) const
+    {
+        if (!tok)
+            return {};
+        if (depth < 0)
+            return {};
+        depth--;
+        if (analyze(tok, Direction::Forward).isRead()) {
+            ConditionState result;
+            result.dependent = true;
+            result.unknown = false;
+            return result;
+        }
+        if (tok->hasKnownIntValue() || tok->isLiteral()) {
+            ConditionState result;
+            result.dependent = false;
+            result.unknown = false;
+            return result;
+        }
+        if (Token::Match(tok, "%cop%")) {
+            if (isLikelyStream(tok->astOperand1())) {
+                ConditionState result;
+                result.dependent = false;
+                return result;
+            }
+            ConditionState lhs = analyzeCondition(tok->astOperand1(), depth - 1);
+            if (lhs.isUnknownDependent() || !tok->astOperand2())
+                return lhs;
+            ConditionState rhs = analyzeCondition(tok->astOperand2(), depth - 1);
+            if (rhs.isUnknownDependent())
+                return rhs;
+            ConditionState result;
+            if (Token::Match(tok, "%comp%"))
+                result.dependent = lhs.dependent && rhs.dependent;
+            else
+                result.dependent = lhs.dependent || rhs.dependent;
+            result.unknown = lhs.unknown || rhs.unknown;
+            return result;
+        }
+        if (Token::Match(tok->previous(), "%name% (")) {
+            std::vector<const Token*> args = getArguments(tok->previous());
+            if (Token::Match(tok->tokAt(-2), ". %name% (")) {
+                args.push_back(tok->tokAt(-2)->astOperand1());
+            }
+            ConditionState result;
+            result.dependent = std::any_of(args.cbegin(), args.cend(), [&](const Token* arg) {
+                ConditionState cs = analyzeCondition(arg, depth - 1);
+                return cs.dependent;
+            });
+            if (result.dependent) {
+                // Check if we can evaluate the function
+                if (!evaluate(Evaluate::Integral, tok).empty())
+                    result.unknown = false;
+            }
+            return result;
+        }
+
+        std::unordered_map<nonneg int, const Token*> symbols = getSymbols(tok);
+        ConditionState result;
+        result.dependent = false;
+        for (auto&& p : symbols) {
+            const Token* arg = p.second;
+            ConditionState cs = analyzeCondition(arg, depth - 1);
+            result.dependent = cs.dependent;
+            if (result.dependent)
+                break;
+        }
+        if (result.dependent) {
+            // Check if we can evaluate the token
+            if (!evaluate(Evaluate::Integral, tok).empty())
+                result.unknown = false;
+        }
+        return result;
+    }
+
+    static ValueFlow::Value::MoveKind isMoveOrForward(const Token* tok)
+    {
+        if (!tok)
+            return ValueFlow::Value::MoveKind::NonMovedVariable;
+        const Token* parent = tok->astParent();
+        if (!Token::simpleMatch(parent, "("))
+            return ValueFlow::Value::MoveKind::NonMovedVariable;
+        const Token* ftok = parent->astOperand1();
+        if (!ftok)
+            return ValueFlow::Value::MoveKind::NonMovedVariable;
+        if (Token::simpleMatch(ftok->astOperand1(), "std :: move"))
+            return ValueFlow::Value::MoveKind::MovedVariable;
+        if (Token::simpleMatch(ftok->astOperand1(), "std :: forward"))
+            return ValueFlow::Value::MoveKind::ForwardedVariable;
+        // TODO: Check for cast
+        return ValueFlow::Value::MoveKind::NonMovedVariable;
+    }
+
+    virtual Action isModified(const Token* tok) const {
+        const ValueFlow::Value* value = getValue(tok);
+        if (value) {
+            // Moving a moved value won't change the moved value
+            if (value->isMovedValue() && isMoveOrForward(tok) != ValueFlow::Value::MoveKind::NonMovedVariable)
+                return Action::Read;
+            // Inserting elements to container won't change the lifetime
+            if (astIsContainer(tok) && value->isLifetimeValue() &&
+                contains({Library::Container::Action::PUSH,
+                          Library::Container::Action::INSERT,
+                          Library::Container::Action::APPEND,
+                          Library::Container::Action::CHANGE_INTERNAL},
+                         astContainerAction(tok, getSettings().library)))
+                return Action::Read;
+        }
+        bool inconclusive = false;
+        if (isVariableChangedByFunctionCall(tok, getIndirect(tok), getSettings(), &inconclusive))
+            return Action::Read | Action::Invalid;
+        if (inconclusive)
+            return Action::Read | Action::Inconclusive;
+        if (isVariableChanged(tok, getIndirect(tok), getSettings())) {
+            if (Token::Match(tok->astParent(), "*|[|.|++|--"))
+                return Action::Read | Action::Invalid;
+            // Check if its assigned to the same value
+            if (value && !value->isImpossible() && Token::simpleMatch(tok->astParent(), "=") && astIsLHS(tok) &&
+                astIsIntegral(tok->astParent()->astOperand2(), false)) {
+                std::vector<MathLib::bigint> result = evaluateInt(tok->astParent()->astOperand2());
+                if (!result.empty() && value->equalTo(result.front()))
+                    return Action::Idempotent;
+            }
+            return Action::Invalid;
+        }
+        return Action::Read;
+    }
+
+    virtual Action isAliasModified(const Token* tok, int indirect = -1) const {
+        // Lambda function call
+        if (Token::Match(tok, "%var% ("))
+            // TODO: Check if modified in the lambda function
+            return Action::Invalid;
+        if (indirect == -1) {
+            indirect = 0;
+            if (const ValueType* vt = tok->valueType()) {
+                indirect = vt->pointer;
+                if (vt->type == ValueType::ITERATOR)
+                    ++indirect;
+                const Token* tok2 = tok;
+                while (Token::simpleMatch(tok2->astParent(), "[")) {
+                    tok2 = tok2->astParent();
+                    --indirect;
+                }
+                indirect = std::max(indirect, 0);
+            }
+        }
+        for (int i = 0; i <= indirect; ++i)
+            if (isVariableChanged(tok, i, getSettings()))
+                return Action::Invalid;
+        return Action::None;
+    }
+
+    virtual Action isThisModified(const Token* tok) const {
+        if (isThisChanged(tok, 0, getSettings()))
+            return Action::Invalid;
+        return Action::None;
+    }
+
+    virtual Action isWritable(const Token* tok, Direction d) const {
+        const ValueFlow::Value* value = getValue(tok);
+        if (!value)
+            return Action::None;
+        if (!(value->isIntValue() || value->isFloatValue() || value->isSymbolicValue() || value->isLifetimeValue()))
+            return Action::None;
+        const Token* parent = tok->astParent();
+        // Only if its invertible
+        if (value->isImpossible() && !Token::Match(parent, "+=|-=|*=|++|--"))
+            return Action::None;
+        if (value->isLifetimeValue()) {
+            if (value->lifetimeKind != ValueFlow::Value::LifetimeKind::Iterator)
+                return Action::None;
+            if (!Token::Match(parent, "++|--|+="))
+                return Action::None;
+            return Action::Read | Action::Write;
+        }
+        if (parent && parent->isAssignmentOp() && astIsLHS(tok)) {
+            const Token* rhs = parent->astOperand2();
+            std::vector<MathLib::bigint> result = evaluateInt(rhs);
+            if (!result.empty()) {
+                ValueFlow::Value rhsValue{result.front()};
+                Action a;
+                if (!evalAssignment(*value, getAssign(parent, d), rhsValue))
+                    a = Action::Invalid;
+                else
+                    a = Action::Write;
+                if (parent->str() != "=") {
+                    a |= Action::Read | Action::Incremental;
+                } else {
+                    if (!value->isImpossible() && value->equalValue(rhsValue))
+                        a = Action::Idempotent;
+                    if (tok->exprId() != 0 &&
+                        findAstNode(rhs, [&](const Token* child) {
+                        return tok->exprId() == child->exprId();
+                    }))
+                        a |= Action::Incremental;
+                }
+                return a;
+            }
+        }
+
+        // increment/decrement
+        if (Token::Match(tok->astParent(), "++|--")) {
+            return Action::Read | Action::Write | Action::Incremental;
+        }
+        return Action::None;
+    }
+
+    virtual void writeValue(ValueFlow::Value* value, const Token* tok, Direction d) const {
+        if (!value)
+            return;
+        if (!tok->astParent())
+            return;
+        // Lifetime value doesn't change
+        if (value->isLifetimeValue())
+            return;
+        if (tok->astParent()->isAssignmentOp()) {
+            const Token* rhs = tok->astParent()->astOperand2();
+            std::vector<MathLib::bigint> result = evaluateInt(rhs);
+            assert(!result.empty());
+            ValueFlow::Value rhsValue{result.front()};
+            if (evalAssignment(*value, getAssign(tok->astParent(), d), rhsValue)) {
+                std::string info("Compound assignment '" + tok->astParent()->str() + "', assigned value is " +
+                                 value->infoString());
+                if (tok->astParent()->str() == "=")
+                    value->errorPath.clear();
+                value->errorPath.emplace_back(tok, std::move(info));
+            } else {
+                assert(false && "Writable value cannot be evaluated");
+                // TODO: Don't set to zero
+                value->intvalue = 0;
+            }
+        } else if (tok->astParent()->tokType() == Token::eIncDecOp) {
+            bool inc = tok->astParent()->str() == "++";
+            const std::string opName(inc ? "incremented" : "decremented");
+            if (d == Direction::Reverse)
+                inc = !inc;
+            value->intvalue += (inc ? 1 : -1);
+
+            /* Truncate value */
+            const ValueType *dst = tok->valueType();
+            if (dst) {
+                const size_t sz = dst->getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer);
+                if (sz > 0 && sz < sizeof(MathLib::biguint)) {
+                    MathLib::bigint newvalue = ValueFlow::truncateIntValue(value->intvalue, sz, dst->sign);
+
+                    /* Handle overflow/underflow for value bounds */
+                    if (value->bound != ValueFlow::Value::Bound::Point) {
+                        if ((newvalue > value->intvalue && !inc) || (newvalue < value->intvalue && inc))
+                            value->invertBound();
+                    }
+
+                    value->intvalue = newvalue;
+                }
+
+                value->errorPath.emplace_back(tok, tok->str() + " is " + opName + "', new value is " + value->infoString());
+            }
+        }
+    }
+
+    virtual bool useSymbolicValues() const {
+        return true;
+    }
+
+    virtual void internalUpdate(Token* /*tok*/, const ValueFlow::Value& /*v*/, Direction /*d*/)
+    {
+        assert(false && "Internal update unimplemented.");
+    }
+
+private:
+    // Returns Action::Match if its an exact match, return Action::Read if it partially matches the lifetime
+    Action analyzeLifetime(const Token* tok) const
+    {
+        if (!tok)
+            return Action::None;
+        if (match(tok))
+            return Action::Match;
+        if (Token::simpleMatch(tok, ".") && analyzeLifetime(tok->astOperand1()) != Action::None)
+            return Action::Read;
+        if (astIsRHS(tok) && Token::simpleMatch(tok->astParent(), "."))
+            return analyzeLifetime(tok->astParent());
+        return Action::None;
+    }
+
+    std::unordered_map<nonneg int, const Token*> getSymbols(const Token* tok) const
+    {
+        std::unordered_map<nonneg int, const Token*> result;
+        if (!tok)
+            return result;
+        for (const ValueFlow::Value& v : tok->values()) {
+            if (!v.isSymbolicValue())
+                continue;
+            if (v.isImpossible())
+                continue;
+            if (!v.tokvalue)
+                continue;
+            if (v.tokvalue->exprId() == 0)
+                continue;
+            if (match(v.tokvalue))
+                continue;
+            result[v.tokvalue->exprId()] = v.tokvalue;
+        }
+        return result;
+    }
+
+    Action isGlobalModified(const Token* tok) const
+    {
+        if (tok->function()) {
+            if (!tok->function()->isConstexpr() && !isConstFunctionCall(tok, getSettings().library))
+                return Action::Invalid;
+        } else if (getSettings().library.getFunction(tok)) {
+            // Assume library function doesn't modify user-global variables
+            return Action::None;
+        } else if (Token::simpleMatch(tok->astParent(), ".") && astIsContainer(tok->astParent()->astOperand1())) {
+            // Assume container member function doesn't modify user-global variables
+            return Action::None;
+        } else if (tok->tokType() == Token::eType && astIsPrimitive(tok->next())) {
+            // Function cast does not modify global variables
+            return Action::None;
+        } else if (!tok->isKeyword() && Token::Match(tok, "%name% (")) {
+            return Action::Invalid;
+        }
+        return Action::None;
+    }
+
+    static const std::string& invertAssign(const std::string& assign)
+    {
+        static std::unordered_map<std::string, std::string> lookup = {{"=", "="},
+            {"+=", "-="},
+            {"-=", "+="},
+            {"*=", "/="},
+            {"/=", "*="},
+            {"<<=", ">>="},
+            {">>=", "<<="},
+            {"^=", "^="}};
+        auto it = lookup.find(assign);
+        if (it == lookup.end()) {
+            static const std::string s_empty_string;
+            return s_empty_string;
+        }
+        return it->second;
+    }
+
+    static const std::string& getAssign(const Token* tok, Direction d)
+    {
+        if (d == Direction::Forward)
+            return tok->str();
+        return invertAssign(tok->str());
+    }
+
+    template<class T, class U>
+    static void assignValueIfMutable(T& x, const U& y)
+    {
+        x = y;
+    }
+
+    template<class T, class U>
+    static void assignValueIfMutable(const T& /*unused*/, const U& /*unused*/)
+    {}
+
+    static std::string removeAssign(const std::string& assign) {
+        return std::string{assign.cbegin(), assign.cend() - 1};
+    }
+
+    template<class T, class U>
+    static T calculateAssign(const std::string& assign, const T& x, const U& y, bool* error = nullptr)
+    {
+        if (assign.empty() || assign.back() != '=') {
+            if (error)
+                *error = true;
+            return T{};
+        }
+        if (assign == "=")
+            return static_cast<T>(y);
+        return calculate<T, T>(removeAssign(assign), x, y, error);
+    }
+
+    template<class Value, REQUIRES("Value must ValueFlow::Value", std::is_convertible<Value&, const ValueFlow::Value&> )>
+    static bool evalAssignment(Value& lhsValue, const std::string& assign, const ValueFlow::Value& rhsValue)
+    {
+        bool error = false;
+        if (lhsValue.isSymbolicValue() && rhsValue.isIntValue()) {
+            if (assign != "+=" && assign != "-=")
+                return false;
+            assignValueIfMutable(lhsValue.intvalue, calculateAssign(assign, lhsValue.intvalue, rhsValue.intvalue, &error));
+        } else if (lhsValue.isIntValue() && rhsValue.isIntValue()) {
+            assignValueIfMutable(lhsValue.intvalue, calculateAssign(assign, lhsValue.intvalue, rhsValue.intvalue, &error));
+        } else if (lhsValue.isFloatValue() && rhsValue.isIntValue()) {
+            assignValueIfMutable(lhsValue.floatValue,
+                                 calculateAssign(assign, lhsValue.floatValue, rhsValue.intvalue, &error));
+        } else {
+            return false;
+        }
+        return !error;
+    }
+
+    const Token* findMatch(const Token* tok) const
+    {
+        return findAstNode(tok, [&](const Token* child) {
+            return match(child);
+        });
+    }
+
+    bool isSameSymbolicValue(const Token* tok, ValueFlow::Value* value = nullptr) const
+    {
+        if (!useSymbolicValues())
+            return false;
+        if (Token::Match(tok, "%assign%"))
+            return false;
+        const ValueFlow::Value* currValue = getValue(tok);
+        if (!currValue)
+            return false;
+        // If the same symbolic value is already there then skip
+        if (currValue->isSymbolicValue() &&
+            std::any_of(tok->values().cbegin(), tok->values().cend(), [&](const ValueFlow::Value& v) {
+            return v.isSymbolicValue() && currValue->equalValue(v);
+        }))
+            return false;
+        const bool isPoint = currValue->bound == ValueFlow::Value::Bound::Point && currValue->isIntValue();
+        const bool exact = !currValue->isIntValue() || currValue->isImpossible();
+        for (const ValueFlow::Value& v : tok->values()) {
+            if (!v.isSymbolicValue())
+                continue;
+            if (currValue->equalValue(v))
+                continue;
+            const bool toImpossible = v.isImpossible() && currValue->isKnown();
+            if (!v.isKnown() && !toImpossible)
+                continue;
+            if (exact && v.intvalue != 0 && !isPoint)
+                continue;
+            if (astIsUnsigned(tok) != astIsUnsigned(v.tokvalue))
+                continue;
+            std::vector<MathLib::bigint> r;
+            ValueFlow::Value::Bound bound = currValue->bound;
+            if (match(v.tokvalue)) {
+                r = {currValue->intvalue};
+            } else if (!exact && findMatch(v.tokvalue)) {
+                r = evaluate(Evaluate::Integral, v.tokvalue, tok);
+                if (bound == ValueFlow::Value::Bound::Point)
+                    bound = v.bound;
+            }
+            if (!r.empty()) {
+                if (value) {
+                    value->errorPath.insert(value->errorPath.end(), v.errorPath.cbegin(), v.errorPath.cend());
+                    value->intvalue = r.front() + v.intvalue;
+                    if (toImpossible)
+                        value->setImpossible();
+                    value->bound = bound;
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+
+    Action analyzeMatch(const Token* tok, Direction d) const {
+        const Token* parent = tok->astParent();
+        if (d == Direction::Reverse && isGlobal() && !dependsOnThis() && Token::Match(parent, ". %name% (")) {
+            Action a = isGlobalModified(parent->next());
+            if (a != Action::None)
+                return a;
+        }
+        if ((astIsPointer(tok) || astIsSmartPointer(tok)) &&
+            (Token::Match(parent, "*|[") || (parent && parent->originalName() == "->")) && getIndirect(tok) <= 0)
+            return Action::Read;
+
+        Action w = isWritable(tok, d);
+        if (w != Action::None)
+            return w;
+
+        // Check for modifications by function calls
+        return isModified(tok);
+    }
+
+    Action analyzeToken(const Token* ref, const Token* tok, Direction d, bool inconclusiveRef) const {
+        if (!ref)
+            return Action::None;
+        // If its an inconclusiveRef then ref != tok
+        assert(!inconclusiveRef || ref != tok);
+        bool inconclusive = false;
+        if (match(ref)) {
+            if (inconclusiveRef) {
+                Action a = isModified(tok);
+                if (a.isModified() || a.isInconclusive())
+                    return Action::Inconclusive;
+            } else {
+                return analyzeMatch(tok, d) | Action::Match;
+            }
+        } else if (isDereferenceOp(ref) && !match(ref->astOperand1())) {
+            const Token* lifeTok = nullptr;
+            for (const ValueFlow::Value& v:ref->astOperand1()->values()) {
+                if (!v.isLocalLifetimeValue())
+                    continue;
+                if (v.conditional)
+                    continue;
+                if (lifeTok)
+                    return Action::None;
+                lifeTok = v.tokvalue;
+            }
+            if (!lifeTok)
+                return Action::None;
+            Action la = analyzeLifetime(lifeTok);
+            if (la.matches()) {
+                Action a = Action::Read;
+                if (isModified(tok).isModified())
+                    a = Action::Invalid;
+                if (Token::Match(tok->astParent(), "%assign%") && astIsLHS(tok))
+                    a |= Action::Invalid;
+                if (inconclusiveRef && a.isModified())
+                    return Action::Inconclusive;
+                return a;
+            }
+            if (la.isRead()) {
+                return isAliasModified(tok);
+            }
+            return Action::None;
+
+        } else if (isAlias(ref, inconclusive)) {
+            inconclusive |= inconclusiveRef;
+            Action a = isAliasModified(tok);
+            if (inconclusive && a.isModified())
+                return Action::Inconclusive;
+            return a;
+        }
+        if (isSameSymbolicValue(ref))
+            return Action::Read | Action::SymbolicMatch;
+
+        return Action::None;
+    }
+
+    Action analyze(const Token* tok, Direction d) const override {
+        if (invalid())
+            return Action::Invalid;
+        // Follow references
+        // TODO: avoid copy
+        auto refs = tok->refs();
+        const bool inconclusiveRefs = refs.size() != 1;
+        if (std::none_of(refs.cbegin(), refs.cend(), [&](const ReferenceToken& ref) {
+            return tok == ref.token;
+        }))
+            refs.emplace_back(ReferenceToken{tok, {}});
+        for (const ReferenceToken& ref:refs) {
+            Action a = analyzeToken(ref.token, tok, d, inconclusiveRefs && ref.token != tok);
+            if (internalMatch(ref.token))
+                a |= Action::Internal;
+            if (a != Action::None)
+                return a;
+        }
+        if (dependsOnThis() && exprDependsOnThis(tok, !isClassVariable()))
+            return isThisModified(tok);
+
+        // bailout: global non-const variables
+        if (isGlobal() && !dependsOnThis() && Token::Match(tok, "%name% (") && !tok->variable() &&
+            !Token::simpleMatch(tok->linkAt(1), ") {")) {
+            return isGlobalModified(tok);
+        }
+        return Action::None;
+    }
+
+    template<class F>
+    std::vector<MathLib::bigint> evaluateInt(const Token* tok, F getProgramMemory) const
+    {
+        if (const ValueFlow::Value* v = tok->getKnownValue(ValueFlow::Value::ValueType::INT))
+            return {static_cast<int>(v->intvalue)};
+        std::vector<MathLib::bigint> result;
+        ProgramMemory pm = getProgramMemory();
+        if (Token::Match(tok, "&&|%oror%")) {
+            if (conditionIsTrue(tok, pm, getSettings()))
+                result.push_back(1);
+            if (conditionIsFalse(tok, std::move(pm), getSettings()))
+                result.push_back(0);
+        } else {
+            MathLib::bigint out = 0;
+            bool error = false;
+            execute(tok, pm, &out, &error, getSettings());
+            if (!error)
+                result.push_back(out);
+        }
+        return result;
+    }
+
+    std::vector<MathLib::bigint> evaluateInt(const Token* tok) const
+    {
+        return evaluateInt(tok, [&] {
+            return ProgramMemory{getProgramState()};
+        });
+    }
+
+    std::vector<MathLib::bigint> evaluate(Evaluate e, const Token* tok, const Token* ctx = nullptr) const override
+    {
+        if (e == Evaluate::Integral) {
+            return evaluateInt(tok, [&] {
+                return pms.get(tok, ctx, getProgramState());
+            });
+        }
+        if (e == Evaluate::ContainerEmpty) {
+            const ValueFlow::Value* value = ValueFlow::findValue(tok->values(), settings, [](const ValueFlow::Value& v) {
+                return v.isKnown() && v.isContainerSizeValue();
+            });
+            if (value)
+                return {value->intvalue == 0};
+            ProgramMemory pm = pms.get(tok, ctx, getProgramState());
+            MathLib::bigint out = 0;
+            if (pm.getContainerEmptyValue(tok->exprId(), out))
+                return {static_cast<int>(out)};
+            return {};
+        }
+        return {};
+    }
+
+    void assume(const Token* tok, bool state, unsigned int flags) override {
+        // Update program state
+        pms.removeModifiedVars(tok);
+        pms.addState(tok, getProgramState());
+        pms.assume(tok, state, flags & Assume::ContainerEmpty);
+
+        bool isCondBlock = false;
+        const Token* parent = tok->astParent();
+        if (parent) {
+            isCondBlock = Token::Match(parent->previous(), "if|while (");
+        }
+
+        if (isCondBlock) {
+            const Token* startBlock = parent->link()->next();
+            if (Token::simpleMatch(startBlock, ";") && Token::simpleMatch(parent->tokAt(-2), "} while ("))
+                startBlock = parent->linkAt(-2);
+            const Token* endBlock = startBlock->link();
+            if (state) {
+                pms.removeModifiedVars(endBlock);
+                pms.addState(endBlock->previous(), getProgramState());
+            } else {
+                if (Token::simpleMatch(endBlock, "} else {"))
+                    pms.addState(endBlock->linkAt(2)->previous(), getProgramState());
+            }
+        }
+
+        if (!(flags & Assume::Quiet)) {
+            if (flags & Assume::ContainerEmpty) {
+                std::string s = state ? "empty" : "not empty";
+                addErrorPath(tok, "Assuming container is " + s);
+            } else {
+                std::string s = bool_to_string(state);
+                addErrorPath(tok, "Assuming condition is " + s);
+            }
+        }
+        if (!(flags & Assume::Absolute))
+            makeConditional();
+    }
+
+    void updateState(const Token* tok) override
+    {
+        // Update program state
+        pms.removeModifiedVars(tok);
+        pms.addState(tok, getProgramState());
+    }
+
+    void update(Token* tok, Action a, Direction d) override {
+        ValueFlow::Value* value = getValue(tok);
+        if (!value)
+            return;
+        ValueFlow::Value localValue;
+        if (a.isSymbolicMatch()) {
+            // Make a copy of the value to modify it
+            localValue = *value;
+            value = &localValue;
+            isSameSymbolicValue(tok, &localValue);
+        }
+        if (a.isInternal())
+            internalUpdate(tok, *value, d);
+        // Read first when moving forward
+        if (d == Direction::Forward && a.isRead())
+            setTokenValue(tok, *value, getSettings());
+        if (a.isInconclusive())
+            (void)lowerToInconclusive();
+        if (a.isWrite() && tok->astParent()) {
+            writeValue(value, tok, d);
+        }
+        // Read last when moving in reverse
+        if (d == Direction::Reverse && a.isRead())
+            setTokenValue(tok, *value, getSettings());
+    }
+
+    ValuePtr<Analyzer> reanalyze(Token* /*tok*/, const std::string& /*msg*/) const override {
+        return {};
+    }
+};
+
+static bool bifurcate(const Token* tok, const std::set<nonneg int>& varids, const Settings& settings, int depth = 20);
+
+static bool bifurcateVariableChanged(const Variable* var,
+                                     const std::set<nonneg int>& varids,
+                                     const Token* start,
+                                     const Token* end,
+                                     const Settings& settings,
+                                     int depth = 20)
+{
+    bool result = false;
+    const Token* tok = start;
+    while ((tok = findVariableChanged(
+                tok->next(), end, var->isPointer(), var->declarationId(), var->isGlobal(), settings))) {
+        if (Token::Match(tok->astParent(), "%assign%")) {
+            if (!bifurcate(tok->astParent()->astOperand2(), varids, settings, depth - 1))
+                return true;
+        } else {
+            result = true;
+        }
+    }
+    return result;
+}
+
+static bool bifurcate(const Token* tok, const std::set<nonneg int>& varids, const Settings& settings, int depth)
+{
+    if (depth < 0)
+        return false;
+    if (!tok)
+        return true;
+    if (tok->hasKnownIntValue())
+        return true;
+    if (tok->isConstOp())
+        return bifurcate(tok->astOperand1(), varids, settings, depth) && bifurcate(tok->astOperand2(), varids, settings, depth);
+    if (tok->varId() != 0) {
+        if (varids.count(tok->varId()) > 0)
+            return true;
+        const Variable* var = tok->variable();
+        if (!var)
+            return false;
+        if (!var->isLocal() && !var->isArgument())
+            return false;
+        const Token* start = var->declEndToken();
+        if (!start)
+            return false;
+        if (start->strAt(-1) == ")" || start->strAt(-1) == "}")
+            return false;
+        if (Token::Match(start, "; %varid% =", var->declarationId()))
+            start = start->tokAt(2);
+        if (var->isConst() || !bifurcateVariableChanged(var, varids, start, tok, settings, depth))
+            return var->isArgument() || bifurcate(start->astOperand2(), varids, settings, depth - 1);
+        return false;
+    }
+    return false;
+}
+
+// Check if its an alias of the variable or is being aliased to this variable
+template<typename V>
+static bool isAliasOf(const Variable * var, const Token *tok, nonneg int varid, const V& values, bool* inconclusive = nullptr)
+{
+    if (tok->varId() == varid)
+        return false;
+    if (tok->varId() == 0)
+        return false;
+    if (isAliasOf(tok, varid, inconclusive))
+        return true;
+    if (var && !var->isPointer())
+        return false;
+    // Search through non value aliases
+    return std::any_of(values.begin(), values.end(), [&](const ValueFlow::Value& val) {
+        if (!val.isNonValue())
+            return false;
+        if (val.isInconclusive())
+            return false;
+        if (val.isLifetimeValue() && !val.isLocalLifetimeValue())
+            return false;
+        if (val.isLifetimeValue() && val.lifetimeKind != ValueFlow::Value::LifetimeKind::Address)
+            return false;
+        if (!Token::Match(val.tokvalue, ".|&|*|%var%"))
+            return false;
+        return astHasVar(val.tokvalue, tok->varId());
+    });
+}
+
+struct MultiValueFlowAnalyzer : ValueFlowAnalyzer {
+    class SelectValueFromVarIdMapRange {
+        using M = std::unordered_map<nonneg int, ValueFlow::Value>;
+
+        struct Iterator {
+            using iterator_category = std::forward_iterator_tag;
+            using value_type = const ValueFlow::Value;
+            using pointer = value_type *;
+            using reference = value_type &;
+            using difference_type = std::ptrdiff_t;
+
+            explicit Iterator(const M::const_iterator & it)
+                : mIt(it) {}
+
+            reference operator*() const {
+                return mIt->second;
+            }
+
+            pointer operator->() const {
+                return &mIt->second;
+            }
+
+            Iterator &operator++() {
+                // cppcheck-suppress postfixOperator - forward iterator needs to perform post-increment
+                mIt++;
+                return *this;
+            }
+
+            friend bool operator==(const Iterator &a, const Iterator &b) {
+                return a.mIt == b.mIt;
+            }
+
+            friend bool operator!=(const Iterator &a, const Iterator &b) {
+                return a.mIt != b.mIt;
+            }
+
+        private:
+            M::const_iterator mIt;
+        };
+
+    public:
+        explicit SelectValueFromVarIdMapRange(const M *m)
+            : mMap(m) {}
+
+        Iterator begin() const {
+            return Iterator(mMap->begin());
+        }
+        Iterator end() const {
+            return Iterator(mMap->end());
+        }
+
+    private:
+        const M *mMap;
+    };
+
+    std::unordered_map<nonneg int, ValueFlow::Value> values;
+    std::unordered_map<nonneg int, const Variable*> vars;
+
+    MultiValueFlowAnalyzer(const std::unordered_map<const Variable*, ValueFlow::Value>& args, const Settings& set)
+        : ValueFlowAnalyzer(set) {
+        for (const auto& p:args) {
+            const auto declId = p.first->declarationId();
+            if (declId == 0)
+                continue; // TODO: should never happen?
+            values[declId] = p.second;
+            vars[declId] = p.first;
+        }
+    }
+
+    virtual const std::unordered_map<nonneg int, const Variable*>& getVars() const {
+        return vars;
+    }
+
+    const ValueFlow::Value* getValue(const Token* tok) const override {
+        if (tok->varId() == 0)
+            return nullptr;
+        auto it = values.find(tok->varId());
+        if (it == values.end())
+            return nullptr;
+        return &it->second;
+    }
+    ValueFlow::Value* getValue(const Token* tok) override {
+        if (tok->varId() == 0)
+            return nullptr;
+        auto it = values.find(tok->varId());
+        if (it == values.end())
+            return nullptr;
+        return &it->second;
+    }
+
+    void makeConditional() override {
+        for (auto&& p:values) {
+            p.second.conditional = true;
+        }
+    }
+
+    void addErrorPath(const Token* tok, const std::string& s) override {
+        for (auto&& p:values) {
+            p.second.errorPath.emplace_back(tok, s);
+        }
+    }
+
+    bool isAlias(const Token* tok, bool& inconclusive) const override {
+        const auto range = SelectValueFromVarIdMapRange(&values);
+
+        for (const auto& p:getVars()) {
+            nonneg int const varid = p.first;
+            const Variable* var = p.second;
+            if (tok->varId() == varid)
+                return true;
+            if (isAliasOf(var, tok, varid, range, &inconclusive))
+                return true;
+        }
+        return false;
+    }
+
+    bool lowerToPossible() override {
+        for (auto&& p:values) {
+            if (p.second.isImpossible())
+                return false;
+            p.second.changeKnownToPossible();
+        }
+        return true;
+    }
+    bool lowerToInconclusive() override {
+        for (auto&& p:values) {
+            if (p.second.isImpossible())
+                return false;
+            p.second.setInconclusive();
+        }
+        return true;
+    }
+
+    bool isConditional() const override {
+        for (auto&& p:values) {
+            if (p.second.conditional)
+                return true;
+            if (p.second.condition)
+                return !p.second.isImpossible();
+        }
+        return false;
+    }
+
+    bool stopOnCondition(const Token* condTok) const override {
+        if (isConditional())
+            return true;
+        if (!condTok->hasKnownIntValue() && values.count(condTok->varId()) == 0) {
+            const auto& values_ = condTok->values();
+            return std::any_of(values_.cbegin(), values_.cend(), [](const ValueFlow::Value& v) {
+                return v.isSymbolicValue() && Token::Match(v.tokvalue, "%oror%|&&");
+            });
+        }
+        return false;
+    }
+
+    bool updateScope(const Token* endBlock, bool /*modified*/) const override {
+        const Scope* scope = endBlock->scope();
+        if (!scope)
+            return false;
+        if (scope->type == ScopeType::eLambda) {
+            return std::all_of(values.cbegin(), values.cend(), [](const std::pair<nonneg int, ValueFlow::Value>& p) {
+                return p.second.isLifetimeValue();
+            });
+        }
+        if (scope->type == ScopeType::eIf || scope->type == ScopeType::eElse || scope->type == ScopeType::eWhile ||
+            scope->type == ScopeType::eFor) {
+            auto pred = [](const ValueFlow::Value& value) {
+                if (value.isKnown())
+                    return true;
+                if (value.isImpossible())
+                    return true;
+                if (value.isLifetimeValue())
+                    return true;
+                return false;
+            };
+            if (std::all_of(values.cbegin(), values.cend(), std::bind(pred, std::bind(SelectMapValues{}, std::placeholders::_1))))
+                return true;
+            if (isConditional())
+                return false;
+            const Token* condTok = getCondTokFromEnd(endBlock);
+            std::set<nonneg int> varids;
+            std::transform(getVars().cbegin(), getVars().cend(), std::inserter(varids, varids.begin()), SelectMapKeys{});
+            return bifurcate(condTok, varids, getSettings());
+        }
+
+        return false;
+    }
+
+    bool match(const Token* tok) const override {
+        return values.count(tok->varId()) > 0;
+    }
+
+    ProgramState getProgramState() const override {
+        ProgramState ps;
+        for (const auto& p : values) {
+            const Variable* var = vars.at(p.first);
+            if (!var)
+                continue;
+            assert(var->nameToken());
+            ps[var->nameToken()] = p.second;
+        }
+        return ps;
+    }
+};
+
+ValuePtr<Analyzer> makeMultiValueFlowAnalyzer(const std::unordered_map<const Variable*, ValueFlow::Value>& args, const Settings& settings)
+{
+    return MultiValueFlowAnalyzer{args, settings};
+}
+
+struct SingleValueFlowAnalyzer : ValueFlowAnalyzer {
+    std::unordered_map<nonneg int, const Variable*> varids;
+    std::unordered_map<nonneg int, const Variable*> aliases;
+    ValueFlow::Value value;
+
+    SingleValueFlowAnalyzer(ValueFlow::Value v, const Settings& s) : ValueFlowAnalyzer(s), value(std::move(v)) {}
+
+    const std::unordered_map<nonneg int, const Variable*>& getVars() const {
+        return varids;
+    }
+
+    const std::unordered_map<nonneg int, const Variable*>& getAliasedVars() const {
+        return aliases;
+    }
+
+    const ValueFlow::Value* getValue(const Token* /*tok*/) const override {
+        return &value;
+    }
+    ValueFlow::Value* getValue(const Token* /*tok*/) override {
+        return &value;
+    }
+
+    void makeConditional() override {
+        value.conditional = true;
+    }
+
+    bool useSymbolicValues() const override
+    {
+        if (value.isUninitValue())
+            return false;
+        if (value.isLifetimeValue())
+            return false;
+        return true;
+    }
+
+    void addErrorPath(const Token* tok, const std::string& s) override {
+        value.errorPath.emplace_back(tok, s);
+    }
+
+    template<class T>
+    struct SingleRange {
+        T* x;
+        T* begin() const {
+            return x;
+        }
+        T* end() const {
+            return x+1;
+        }
+    };
+
+    template<class T>
+    static SingleRange<T> MakeSingleRange(T& x)
+    {
+        return {&x};
+    }
+
+    bool isAlias(const Token* tok, bool& inconclusive) const override {
+        if (value.isLifetimeValue())
+            return false;
+        for (const auto& m: {
+            std::ref(getVars()), std::ref(getAliasedVars())
+        }) {
+            for (const auto& p:m.get()) {
+                nonneg int const varid = p.first;
+                const Variable* var = p.second;
+                if (tok->varId() == varid)
+                    return true;
+                if (isAliasOf(var, tok, varid, MakeSingleRange(value), &inconclusive))
+                    return true;
+            }
+        }
+        return false;
+    }
+
+    bool isGlobal() const override {
+        const auto& vars = getVars();
+        return std::any_of(vars.cbegin(), vars.cend(), [] (const std::pair<nonneg int, const Variable*>& p) {
+            const Variable* var = p.second;
+            return !var->isLocal() && !var->isArgument() && !var->isConst();
+        });
+    }
+
+    bool lowerToPossible() override {
+        if (value.isImpossible())
+            return false;
+        value.changeKnownToPossible();
+        return true;
+    }
+    bool lowerToInconclusive() override {
+        if (value.isImpossible())
+            return false;
+        value.setInconclusive();
+        return true;
+    }
+
+    bool isConditional() const override {
+        if (value.conditional)
+            return true;
+        if (value.condition)
+            return !value.isKnown() && !value.isImpossible();
+        return false;
+    }
+
+    bool stopOnCondition(const Token* condTok) const override
+    {
+        if (value.isNonValue())
+            return false;
+        if (value.isImpossible())
+            return false;
+        if (isConditional() && !value.isKnown())
+            return true;
+        if (value.isSymbolicValue())
+            return false;
+        ConditionState cs = analyzeCondition(condTok);
+        return cs.isUnknownDependent();
+    }
+
+    bool updateScope(const Token* endBlock, bool /*modified*/) const override {
+        const Scope* scope = endBlock->scope();
+        if (!scope)
+            return false;
+        if (scope->type == ScopeType::eLambda)
+            return value.isLifetimeValue();
+        if (scope->type == ScopeType::eIf || scope->type == ScopeType::eElse || scope->type == ScopeType::eWhile ||
+            scope->type == ScopeType::eFor) {
+            if (value.isKnown() || value.isImpossible())
+                return true;
+            if (value.isLifetimeValue())
+                return true;
+            if (isConditional())
+                return false;
+            const Token* condTok = getCondTokFromEnd(endBlock);
+            std::set<nonneg int> varids2;
+            std::transform(getVars().cbegin(), getVars().cend(), std::inserter(varids2, varids2.begin()), SelectMapKeys{});
+            return bifurcate(condTok, varids2, getSettings());
+        }
+
+        return false;
+    }
+
+private:
+    ValuePtr<Analyzer> reanalyze(Token* tok, const std::string& msg) const override {
+        ValueFlow::Value newValue = value;
+        newValue.errorPath.emplace_back(tok, msg);
+        return makeAnalyzer(tok, std::move(newValue), settings);
+    }
+};
+
+struct ExpressionAnalyzer : SingleValueFlowAnalyzer {
+    const Token* expr;
+    bool local = true;
+    bool unknown{};
+    bool dependOnThis{};
+    bool uniqueExprId{};
+
+    ExpressionAnalyzer(const Token* e, ValueFlow::Value val, const Settings& s)
+        : SingleValueFlowAnalyzer(std::move(val), s),
+        expr(e)
+    {
+
+        assert(e && e->exprId() != 0 && "Not a valid expression");
+        dependOnThis = exprDependsOnThis(expr);
+        setupExprVarIds(expr);
+        if (value.isSymbolicValue()) {
+            dependOnThis |= exprDependsOnThis(value.tokvalue);
+            setupExprVarIds(value.tokvalue);
+        }
+        uniqueExprId =
+            expr->isUniqueExprId() && (Token::Match(expr, "%cop%") || !isVariableChanged(expr, 0, s));
+    }
+
+    static bool nonLocal(const Variable* var, bool deref) {
+        return !var || (!var->isLocal() && !var->isArgument()) || (deref && var->isArgument() && var->isPointer()) ||
+               var->isStatic() || var->isReference() || var->isExtern();
+    }
+
+    void setupExprVarIds(const Token* start, int depth = 0) {
+        if (depth > settings.vfOptions.maxExprVarIdDepth) {
+            // TODO: add bailout message
+            return;
+        }
+        visitAstNodes(start, [&](const Token* tok) {
+            const bool top = depth == 0 && tok == start;
+            const bool ispointer = astIsPointer(tok) || astIsSmartPointer(tok) || astIsIterator(tok);
+            if (!top || !ispointer || value.indirect != 0) {
+                for (const ValueFlow::Value& v : tok->values()) {
+                    if (!(v.isLocalLifetimeValue() || (ispointer && v.isSymbolicValue() && v.isKnown())))
+                        continue;
+                    if (!v.tokvalue)
+                        continue;
+                    if (v.tokvalue == tok)
+                        continue;
+                    setupExprVarIds(v.tokvalue, depth + 1);
+                }
+            }
+            if (depth == 0 && tok->isIncompleteVar()) {
+                // TODO: Treat incomplete var as global, but we need to update
+                // the alias variables to just expr ids instead of requiring
+                // Variable
+                unknown = true;
+                return ChildrenToVisit::none;
+            }
+            if (tok->varId() > 0) {
+                varids[tok->varId()] = tok->variable();
+                if (!Token::simpleMatch(tok->previous(), ".")) {
+                    const Variable* var = tok->variable();
+                    if (var && var->isReference() && var->isLocal() && Token::Match(var->nameToken(), "%var% [=(]") &&
+                        !isGlobalData(var->nameToken()->next()->astOperand2()))
+                        return ChildrenToVisit::none;
+                    const bool deref = tok->astParent() &&
+                                       (tok->astParent()->isUnaryOp("*") ||
+                                        (tok->astParent()->str() == "[" && tok == tok->astParent()->astOperand1()));
+                    local &= !nonLocal(tok->variable(), deref);
+                }
+            }
+            return ChildrenToVisit::op1_and_op2;
+        });
+    }
+
+    virtual bool skipUniqueExprIds() const {
+        return true;
+    }
+
+    bool invalid() const override {
+        if (skipUniqueExprIds() && uniqueExprId)
+            return true;
+        return unknown;
+    }
+
+    ProgramState getProgramState() const override {
+        ProgramState ps;
+        ps[expr] = value;
+        return ps;
+    }
+
+    bool match(const Token* tok) const override {
+        return tok->exprId() == expr->exprId();
+    }
+
+    bool dependsOnThis() const override {
+        return dependOnThis;
+    }
+
+    bool isGlobal() const override {
+        return !local;
+    }
+
+    bool isClassVariable() const override
+    {
+        if (expr->variable()) {
+            const Variable* var = expr->variable();
+            return !var->isLocal() && !var->isArgument() && !var->isStatic() && !var->isGlobal();
+        }
+        return expr->varId() > 0;
+    }
+
+    Action isAliasModified(const Token* tok, int indirect) const override {
+        if (value.isSymbolicValue() && tok->exprId() == value.tokvalue->exprId())
+            indirect = 0;
+        return SingleValueFlowAnalyzer::isAliasModified(tok, indirect);
+    }
+};
+
+struct SameExpressionAnalyzer : ExpressionAnalyzer {
+    SameExpressionAnalyzer(const Token* e, ValueFlow::Value val, const Settings& s)
+        : ExpressionAnalyzer(e, std::move(val), s)
+    {}
+
+    bool skipUniqueExprIds() const override {
+        return false;
+    }
+
+    bool match(const Token* tok) const override
+    {
+        return isSameExpression(true, expr, tok, getSettings(), true, true);
+    }
+};
+
+ValuePtr<Analyzer> makeSameExpressionAnalyzer(const Token* e, ValueFlow::Value val, const Settings& s)
+{
+    return SameExpressionAnalyzer{e, std::move(val), s};
+}
+
+struct OppositeExpressionAnalyzer : ExpressionAnalyzer {
+    bool isNot{};
+
+    OppositeExpressionAnalyzer(bool pIsNot, const Token* e, ValueFlow::Value val, const Settings& s)
+        : ExpressionAnalyzer(e, std::move(val), s), isNot(pIsNot)
+    {}
+
+    bool skipUniqueExprIds() const override {
+        return false;
+    }
+
+    bool match(const Token* tok) const override {
+        return isOppositeCond(isNot, expr, tok, getSettings(), true, true);
+    }
+};
+
+ValuePtr<Analyzer> makeOppositeExpressionAnalyzer(bool pIsNot, const Token* e, ValueFlow::Value val, const Settings& s)
+{
+    return OppositeExpressionAnalyzer{pIsNot, e, std::move(val), s};
+}
+
+struct SubExpressionAnalyzer : ExpressionAnalyzer {
+    using PartialReadContainer = std::vector<std::pair<Token *, ValueFlow::Value>>;
+    // A shared_ptr is used so partial reads can be captured even after forking
+    std::shared_ptr<PartialReadContainer> partialReads;
+
+    SubExpressionAnalyzer(const Token* e, ValueFlow::Value val, const Settings& s)
+        : ExpressionAnalyzer(e, std::move(val), s), partialReads(std::make_shared<PartialReadContainer>())
+    {}
+
+    SubExpressionAnalyzer(const Token* e, ValueFlow::Value val, const std::shared_ptr<PartialReadContainer>& p, const Settings& s)
+        : ExpressionAnalyzer(e, std::move(val), s), partialReads(p)
+    {}
+
+    virtual bool submatch(const Token* tok, bool exact = true) const = 0;
+
+    bool isAlias(const Token* tok, bool& inconclusive) const override
+    {
+        if (tok->exprId() == expr->exprId() && tok->astParent() && submatch(tok->astParent(), false))
+            return false;
+        return ExpressionAnalyzer::isAlias(tok, inconclusive);
+    }
+
+    bool match(const Token* tok) const override
+    {
+        return tok->astOperand1() && tok->astOperand1()->exprId() == expr->exprId() && submatch(tok);
+    }
+    bool internalMatch(const Token* tok) const override
+    {
+        return tok->exprId() == expr->exprId() && !(astIsLHS(tok) && submatch(tok->astParent(), false));
+    }
+    void internalUpdate(Token* tok, const ValueFlow::Value& v, Direction /*d*/) override
+    {
+        partialReads->emplace_back(tok, v);
+    }
+
+private:
+    // No reanalysis for subexpression
+    ValuePtr<Analyzer> reanalyze(Token* /*tok*/, const std::string& /*msg*/) const override {
+        return {};
+    }
+};
+
+struct MemberExpressionAnalyzer : SubExpressionAnalyzer {
+    std::string varname;
+
+    MemberExpressionAnalyzer(std::string varname, const Token* e, ValueFlow::Value val, const std::shared_ptr<PartialReadContainer>& p, const Settings& s)
+        : SubExpressionAnalyzer(e, std::move(val), p, s), varname(std::move(varname))
+    {}
+
+    bool submatch(const Token* tok, bool exact) const override
+    {
+        if (!Token::Match(tok, ". %var%"))
+            return false;
+        if (!exact)
+            return true;
+        return tok->strAt(1) == varname;
+    }
+};
+
+ValuePtr<Analyzer> makeMemberExpressionAnalyzer(std::string varname, const Token* e, ValueFlow::Value val, const std::shared_ptr<PartialReadContainer>& p, const Settings& s)
+{
+    return MemberExpressionAnalyzer{std::move(varname), e, std::move(val), p, s};
+}
+
+struct ContainerExpressionAnalyzer : ExpressionAnalyzer {
+    ContainerExpressionAnalyzer(const Token* expr, ValueFlow::Value val, const Settings& s)
+        : ExpressionAnalyzer(expr, std::move(val), s)
+    {}
+
+    bool match(const Token* tok) const override {
+        return tok->exprId() == expr->exprId() || (astIsIterator(tok) && isAliasOf(tok, expr->exprId()));
+    }
+
+    Action isWritable(const Token* tok, Direction /*d*/) const override
+    {
+        if (astIsIterator(tok))
+            return Action::None;
+        if (!getValue(tok))
+            return Action::None;
+        if (!tok->valueType())
+            return Action::None;
+        if (!astIsContainer(tok))
+            return Action::None;
+        const Token* parent = tok->astParent();
+        const Library::Container* container = getLibraryContainer(tok);
+
+        if (container->stdStringLike && Token::simpleMatch(parent, "+=") && astIsLHS(tok) && parent->astOperand2()) {
+            const Token* rhs = parent->astOperand2();
+            if (rhs->tokType() == Token::eString)
+                return Action::Read | Action::Write | Action::Incremental;
+            const Library::Container* rhsContainer = getLibraryContainer(rhs);
+            if (rhsContainer && rhsContainer->stdStringLike) {
+                if (std::any_of(rhs->values().cbegin(), rhs->values().cend(), [&](const ValueFlow::Value &rhsval) {
+                    return rhsval.isKnown() && rhsval.isContainerSizeValue();
+                }))
+                    return Action::Read | Action::Write | Action::Incremental;
+            }
+        } else if (astIsLHS(tok) && Token::Match(tok->astParent(), ". %name% (")) {
+            const Library::Container::Action action = container->getAction(tok->astParent()->strAt(1));
+            if (action == Library::Container::Action::PUSH || action == Library::Container::Action::POP || action == Library::Container::Action::APPEND) { // TODO: handle more actions?
+                std::vector<const Token*> args = getArguments(tok->tokAt(3));
+                bool isVariadic = false;
+                if (const Library::Function* libFunc = settings.library.getFunction(tok->tokAt(2))) {
+                    const auto& argChecks = libFunc->argumentChecks;
+                    isVariadic = argChecks.find(-1) != argChecks.end() && argChecks.at(-1).variadic;
+                }
+                if (args.size() < 2 || action == Library::Container::Action::APPEND || isVariadic)
+                    return Action::Read | Action::Write | Action::Incremental;
+            }
+        }
+        return Action::None;
+    }
+
+    void writeValue(ValueFlow::Value* val, const Token* tok, Direction d) const override {
+        if (!val)
+            return;
+        if (!tok->astParent())
+            return;
+        if (!tok->valueType())
+            return;
+        if (!astIsContainer(tok))
+            return;
+        const Token* parent = tok->astParent();
+        const Library::Container* container = getLibraryContainer(tok);
+        MathLib::bigint n = 0;
+
+        if (container->stdStringLike && Token::simpleMatch(parent, "+=") && parent->astOperand2()) {
+            const Token* rhs = parent->astOperand2();
+            const Library::Container* rhsContainer = getLibraryContainer(rhs);
+            if (rhs->tokType() == Token::eString)
+                n = Token::getStrLength(rhs);
+            else if (rhsContainer && rhsContainer->stdStringLike) {
+                auto it = std::find_if(rhs->values().begin(), rhs->values().end(), [&](const ValueFlow::Value& rhsval) {
+                    return rhsval.isKnown() && rhsval.isContainerSizeValue();
+                });
+                if (it != rhs->values().end())
+                    n = it->intvalue;
+            }
+        } else if (astIsLHS(tok) && Token::Match(tok->astParent(), ". %name% (")) {
+            const Library::Container::Action action = container->getAction(tok->astParent()->strAt(1));
+            switch (action) {
+            case Library::Container::Action::PUSH:
+                n = 1;
+                break;
+            case Library::Container::Action::POP:
+                n = -1;
+                break;
+            case Library::Container::Action::APPEND: {
+                std::vector<const Token*> args = getArguments(tok->astParent()->tokAt(2));
+                if (args.size() == 1) // TODO: handle overloads
+                    n = ValueFlow::valueFlowGetStrLength(tok->astParent()->tokAt(3));
+                if (n == 0) // TODO: handle known empty append
+                    val->setPossible();
+                break;
+            }
+            default:
+                break;
+            }
+        }
+        if (d == Direction::Reverse)
+            val->intvalue -= n;
+        else
+            val->intvalue += n;
+    }
+
+    int getIndirect(const Token* tok) const override
+    {
+        if (tok->valueType()) {
+            return tok->valueType()->pointer;
+        }
+        return ValueFlowAnalyzer::getIndirect(tok);
+    }
+
+    Action isModified(const Token* tok) const override {
+        // An iterator won't change the container size
+        if (astIsIterator(tok))
+            return Action::Read;
+        if (Token::Match(tok->astParent(), "%assign%") && astIsLHS(tok))
+            return Action::Invalid;
+        if (isLikelyStreamRead(tok->astParent()))
+            return Action::Invalid;
+        if (astIsContainer(tok) && ValueFlow::isContainerSizeChanged(tok, getIndirect(tok), getSettings()))
+            return Action::Read | Action::Invalid;
+        return Action::Read;
+    }
+};
+
+static const Token* solveExprValue(const Token* expr, ValueFlow::Value& value)
+{
+    return ValueFlow::solveExprValue(
+        expr,
+        [](const Token* tok) -> std::vector<MathLib::bigint> {
+        if (const ValueFlow::Value* v = tok->getKnownValue(ValueFlow::Value::ValueType::INT))
+            return {v->intvalue};
+        return {};
+    },
+        value);
+}
+
+ValuePtr<Analyzer> makeAnalyzer(const Token* exprTok, ValueFlow::Value value, const Settings& settings)
+{
+    if (value.isContainerSizeValue())
+        return ContainerExpressionAnalyzer(exprTok, std::move(value), settings);
+    const Token* expr = solveExprValue(exprTok, value);
+    return ExpressionAnalyzer(expr, std::move(value), settings);
+}
+
+ValuePtr<Analyzer> makeReverseAnalyzer(const Token* exprTok, ValueFlow::Value value, const Settings& settings)
+{
+    if (value.isContainerSizeValue())
+        return ContainerExpressionAnalyzer(exprTok, std::move(value), settings);
+    return ExpressionAnalyzer(exprTok, std::move(value), settings);
+}
diff --git a/lib/vf_analyzers.h b/lib/vf_analyzers.h
new file mode 100644
index 00000000000..e9b4b92a753
--- /dev/null
+++ b/lib/vf_analyzers.h
@@ -0,0 +1,51 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef vfAnalyzers
+#define vfAnalyzers
+
+#include "analyzer.h"
+#include "valueptr.h"
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+class Token;
+class Variable;
+class Settings;
+namespace ValueFlow {
+    class Value;
+}
+
+ValuePtr<Analyzer> makeMultiValueFlowAnalyzer(const std::unordered_map<const Variable*, ValueFlow::Value>& args, const Settings& settings);
+
+ValuePtr<Analyzer> makeSameExpressionAnalyzer(const Token* e, ValueFlow::Value val, const Settings& s);
+
+ValuePtr<Analyzer> makeOppositeExpressionAnalyzer(bool pIsNot, const Token* e, ValueFlow::Value val, const Settings& s);
+
+using PartialReadContainer = std::vector<std::pair<Token *, ValueFlow::Value>>;
+ValuePtr<Analyzer> makeMemberExpressionAnalyzer(std::string varname, const Token* e, ValueFlow::Value val, const std::shared_ptr<PartialReadContainer>& p, const Settings& s);
+
+ValuePtr<Analyzer> makeAnalyzer(const Token* exprTok, ValueFlow::Value value, const Settings& settings);
+
+ValuePtr<Analyzer> makeReverseAnalyzer(const Token* exprTok, ValueFlow::Value value, const Settings& settings);
+
+#endif // vfAnalyzers
diff --git a/lib/vf_common.cpp b/lib/vf_common.cpp
new file mode 100644
index 00000000000..46059985b0b
--- /dev/null
+++ b/lib/vf_common.cpp
@@ -0,0 +1,403 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "vf_common.h"
+
+#include "astutils.h"
+#include "mathlib.h"
+#include "path.h"
+#include "platform.h"
+#include "settings.h"
+#include "standards.h"
+#include "symboldatabase.h"
+#include "token.h"
+#include "vfvalue.h"
+
+#include "vf_settokenvalue.h"
+
+#include <climits>
+#include <cstddef>
+#include <cstdint>
+#include <exception>
+#include <limits>
+#include <utility>
+#include <vector>
+
+namespace ValueFlow
+{
+    bool getMinMaxValues(const ValueType *vt, const Platform &platform, MathLib::bigint &minValue, MathLib::bigint &maxValue)
+    {
+        if (!vt || !vt->isIntegral() || vt->pointer)
+            return false;
+
+        std::uint8_t bits;
+        switch (vt->type) {
+        case ValueType::Type::BOOL:
+            bits = 1;
+            break;
+        case ValueType::Type::CHAR:
+            bits = platform.char_bit;
+            break;
+        case ValueType::Type::SHORT:
+            bits = platform.short_bit;
+            break;
+        case ValueType::Type::INT:
+            bits = platform.int_bit;
+            break;
+        case ValueType::Type::LONG:
+            bits = platform.long_bit;
+            break;
+        case ValueType::Type::LONGLONG:
+            bits = platform.long_long_bit;
+            break;
+        default:
+            return false;
+        }
+
+        if (bits == 1) {
+            minValue = 0;
+            maxValue = 1;
+        } else if (bits < 62) {
+            if (vt->sign == ValueType::Sign::UNSIGNED) {
+                minValue = 0;
+                maxValue = (1LL << bits) - 1;
+            } else {
+                minValue = -(1LL << (bits - 1));
+                maxValue = (1LL << (bits - 1)) - 1;
+            }
+        } else if (bits == 64) {
+            if (vt->sign == ValueType::Sign::UNSIGNED) {
+                minValue = 0;
+                maxValue = LLONG_MAX; // todo max unsigned value
+            } else {
+                minValue = LLONG_MIN;
+                maxValue = LLONG_MAX;
+            }
+        } else {
+            return false;
+        }
+
+        return true;
+    }
+
+    MathLib::bigint truncateIntValue(MathLib::bigint value, size_t value_size, const ValueType::Sign dst_sign)
+    {
+        if (value_size == 0)
+            return value;
+
+        const MathLib::biguint unsignedMaxValue = std::numeric_limits<MathLib::biguint>::max() >> ((sizeof(unsignedMaxValue) - value_size) * 8);
+        const MathLib::biguint signBit = 1ULL << ((value_size * 8) - 1);
+        value &= unsignedMaxValue;
+        if (dst_sign == ValueType::Sign::SIGNED && (value & signBit))
+            value |= ~unsignedMaxValue;
+
+        return value;
+    }
+
+    static nonneg int getSizeOfType(const Token *typeTok, const Settings &settings)
+    {
+        const ValueType &valueType = ValueType::parseDecl(typeTok, settings);
+
+        return valueType.getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer);
+    }
+
+    // Handle various constants..
+    Token * valueFlowSetConstantValue(Token *tok, const Settings &settings)
+    {
+        if ((tok->isNumber() && MathLib::isInt(tok->str())) || (tok->tokType() == Token::eChar)) {
+            try {
+                MathLib::bigint signedValue = MathLib::toBigNumber(tok);
+                const ValueType* vt = tok->valueType();
+                if (vt && vt->sign == ValueType::UNSIGNED && signedValue < 0
+                    && vt->getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer)
+                    < sizeof(MathLib::bigint)) {
+                    MathLib::bigint minValue{}, maxValue{};
+                    if (getMinMaxValues(tok->valueType(), settings.platform, minValue, maxValue))
+                        signedValue += maxValue + 1;
+                }
+                Value value(signedValue);
+                if (!tok->isTemplateArg())
+                    value.setKnown();
+                setTokenValue(tok, std::move(value), settings);
+            } catch (const std::exception & /*e*/) {
+                // Bad character literal
+            }
+        } else if (tok->isNumber() && MathLib::isFloat(tok->str())) {
+            Value value;
+            value.valueType = Value::ValueType::FLOAT;
+            value.floatValue = MathLib::toDoubleNumber(tok);
+            if (!tok->isTemplateArg())
+                value.setKnown();
+            setTokenValue(tok, std::move(value), settings);
+        } else if (tok->enumerator() && tok->enumerator()->value_known) {
+            Value value(tok->enumerator()->value);
+            if (!tok->isTemplateArg())
+                value.setKnown();
+            setTokenValue(tok, std::move(value), settings);
+        } else if (tok->str() == "NULL" || ((tok->isCpp() || settings.standards.c >= Standards::C23) && tok->str() == "nullptr")) {
+            Value value(0);
+            if (!tok->isTemplateArg())
+                value.setKnown();
+            setTokenValue(tok, std::move(value), settings);
+        } else if (Token::simpleMatch(tok, "sizeof (")) {
+            if (tok->next()->astOperand2() && !tok->next()->astOperand2()->isLiteral() && tok->next()->astOperand2()->valueType() &&
+                (tok->next()->astOperand2()->valueType()->pointer == 0 || // <- TODO this is a bailout, abort when there are array->pointer conversions
+                 (tok->next()->astOperand2()->variable() && !tok->next()->astOperand2()->variable()->isArray())) &&
+                !tok->next()->astOperand2()->valueType()->isEnum()) { // <- TODO this is a bailout, handle enum with non-int types
+                const size_t sz = tok->next()->astOperand2()->valueType()->getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer);
+                if (sz) {
+                    Value value(sz);
+                    value.setKnown();
+                    setTokenValue(tok->next(), std::move(value), settings);
+                    return tok->linkAt(1);
+                }
+            }
+
+            const Token *tok2 = tok->tokAt(2);
+            // skip over tokens to find variable or type
+            while (tok2 && !tok2->isStandardType() && Token::Match(tok2, "%name% ::|.|[")) {
+                if (tok2->strAt(1) == "[")
+                    tok2 = tok2->linkAt(1)->next();
+                else
+                    tok2 = tok2->tokAt(2);
+            }
+            if (Token::simpleMatch(tok, "sizeof ( *")) {
+                const ValueType *vt = tok->tokAt(2)->valueType();
+                const size_t sz = vt ? vt->getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer)
+                                     : 0;
+                if (sz > 0) {
+                    Value value(sz);
+                    if (!tok2->isTemplateArg() && settings.platform.type != Platform::Type::Unspecified)
+                        value.setKnown();
+                    setTokenValue(tok->next(), std::move(value), settings);
+                }
+            } else if (tok2->enumerator() && tok2->enumerator()->scope) {
+                long long size = settings.platform.sizeof_int;
+                const Token * type = tok2->enumerator()->scope->enumType;
+                if (type) {
+                    size = getSizeOfType(type, settings);
+                    if (size == 0)
+                        tok->linkAt(1);
+                }
+                Value value(size);
+                if (!tok2->isTemplateArg() && settings.platform.type != Platform::Type::Unspecified)
+                    value.setKnown();
+                setTokenValue(tok, value, settings);
+                setTokenValue(tok->next(), std::move(value), settings);
+            } else if (tok2->type() && tok2->type()->isEnumType()) {
+                long long size = settings.platform.sizeof_int;
+                if (tok2->type()->classScope) {
+                    const Token * type = tok2->type()->classScope->enumType;
+                    if (type) {
+                        size = getSizeOfType(type, settings);
+                    }
+                }
+                Value value(size);
+                if (!tok2->isTemplateArg() && settings.platform.type != Platform::Type::Unspecified)
+                    value.setKnown();
+                setTokenValue(tok, value, settings);
+                setTokenValue(tok->next(), std::move(value), settings);
+            } else if (Token::Match(tok, "sizeof ( %var% ) /") && tok->next()->astParent() == tok->tokAt(4) &&
+                       tok->tokAt(4)->astOperand2() && Token::simpleMatch(tok->tokAt(4)->astOperand2()->previous(), "sizeof (")) {
+                // Get number of elements in array
+                const Token *sz1 = tok->tokAt(2);
+                const Token *sz2 = tok->tokAt(4)->astOperand2(); // left parenthesis of sizeof on rhs
+                const nonneg int varid1 = sz1->varId();
+                if (varid1 &&
+                    sz1->variable() &&
+                    sz1->variable()->isArray() &&
+                    !sz1->variable()->dimensions().empty() &&
+                    sz1->variable()->dimensionKnown(0) &&
+                    Token::Match(sz2->astOperand2(), "*|[") && Token::Match(sz2->astOperand2()->astOperand1(), "%varid%", varid1)) {
+                    Value value(sz1->variable()->dimension(0));
+                    if (!tok2->isTemplateArg() && settings.platform.type != Platform::Type::Unspecified)
+                        value.setKnown();
+                    setTokenValue(tok->tokAt(4), std::move(value), settings);
+                }
+            } else if (Token::Match(tok2, "%var% )")) {
+                const Variable *var = tok2->variable();
+                // only look for single token types (no pointers or references yet)
+                if (var && var->typeStartToken() == var->typeEndToken()) {
+                    // find the size of the type
+                    size_t size = 0;
+                    if (var->isEnumType()) {
+                        size = settings.platform.sizeof_int;
+                        if (var->type()->classScope && var->type()->classScope->enumType)
+                            size = getSizeOfType(var->type()->classScope->enumType, settings);
+                    } else if (var->valueType()) {
+                        size = var->valueType()->getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer);
+                    } else if (!var->type()) {
+                        size = getSizeOfType(var->typeStartToken(), settings);
+                    }
+                    // find the number of elements
+                    size_t count = 1;
+                    for (size_t i = 0; i < var->dimensions().size(); ++i) {
+                        if (var->dimensionKnown(i))
+                            count *= var->dimension(i);
+                        else
+                            count = 0;
+                    }
+                    if (size && count > 0) {
+                        Value value(count * size);
+                        if (settings.platform.type != Platform::Type::Unspecified)
+                            value.setKnown();
+                        setTokenValue(tok, value, settings);
+                        setTokenValue(tok->next(), std::move(value), settings);
+                    }
+                }
+            } else if (tok2->tokType() == Token::eString) {
+                const size_t sz = Token::getStrSize(tok2, settings);
+                if (sz > 0) {
+                    Value value(sz);
+                    value.setKnown();
+                    setTokenValue(tok->next(), std::move(value), settings);
+                }
+            } else if (tok2->tokType() == Token::eChar) {
+                nonneg int sz = 0;
+                if (tok2->isCpp() && settings.standards.cpp >= Standards::CPP20 && tok2->isUtf8())
+                    sz = 1;
+                else if (tok2->isUtf16())
+                    sz = 2;
+                else if (tok2->isUtf32())
+                    sz = 4;
+                else if (tok2->isLong())
+                    sz = settings.platform.sizeof_wchar_t;
+                else if ((!tok2->isCpp() && tok2->isCChar()) || (tok2->isCMultiChar()))
+                    sz = settings.platform.sizeof_int;
+                else
+                    sz = 1;
+
+                if (sz > 0) {
+                    Value value(sz);
+                    value.setKnown();
+                    setTokenValue(tok->next(), std::move(value), settings);
+                }
+            } else if (!tok2->type()) {
+                const ValueType& vt = ValueType::parseDecl(tok2, settings);
+                size_t sz = vt.getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer);
+                const Token* brac = tok2->astParent();
+                while (Token::simpleMatch(brac, "[")) {
+                    const Token* num = brac->astOperand2();
+                    if (num && ((num->isNumber() && MathLib::isInt(num->str())) || num->tokType() == Token::eChar)) {
+                        try {
+                            const MathLib::biguint dim = MathLib::toBigUNumber(num);
+                            sz *= dim;
+                            brac = brac->astParent();
+                            continue;
+                        }
+                        catch (const std::exception& /*e*/) {
+                            // Bad integer literal
+                        }
+                    }
+                    sz = 0;
+                    break;
+                }
+                if (sz > 0) {
+                    Value value(sz);
+                    if (!tok2->isTemplateArg() && settings.platform.type != Platform::Type::Unspecified)
+                        value.setKnown();
+                    setTokenValue(tok->next(), std::move(value), settings);
+                }
+            }
+            // skip over enum
+            tok = tok->linkAt(1);
+        } else if (Token::Match(tok, "%name% [{(] [)}]") && (tok->isStandardType() ||
+                                                             (tok->variable() && tok->variable()->nameToken() == tok &&
+                                                              (tok->variable()->isPointer() || (tok->variable()->valueType() && tok->variable()->valueType()->isIntegral()))))) {
+            Value value(0);
+            if (!tok->isTemplateArg())
+                value.setKnown();
+            setTokenValue(tok->next(), std::move(value), settings);
+        } else if (Token::simpleMatch(tok, "= { }")) {
+            const Token* lhs = tok->astOperand1();
+            if (lhs && lhs->valueType() && (lhs->valueType()->isIntegral() || lhs->valueType()->pointer > 0)) {
+                Value value(0);
+                value.setKnown();
+                setTokenValue(tok->next(), std::move(value), settings);
+            }
+        }
+        return tok->next();
+    }
+
+    Value castValue(Value value, const ValueType::Sign sign, nonneg int bit)
+    {
+        if (value.isFloatValue()) {
+            value.valueType = Value::ValueType::INT;
+            if (value.floatValue >= std::numeric_limits<int>::min() && value.floatValue <= std::numeric_limits<int>::max()) {
+                value.intvalue = static_cast<MathLib::bigint>(value.floatValue);
+            } else { // don't perform UB
+                value.intvalue = 0;
+            }
+        }
+        if (bit < MathLib::bigint_bits) {
+            constexpr MathLib::biguint one = 1;
+            value.intvalue &= (one << bit) - 1;
+            if (sign == ValueType::Sign::SIGNED && value.intvalue & (one << (bit - 1))) {
+                value.intvalue |= ~((one << bit) - 1ULL);
+            }
+        }
+        return value;
+    }
+
+    std::string debugString(const Value& v)
+    {
+        std::string kind;
+        switch (v.valueKind) {
+
+        case Value::ValueKind::Impossible:
+        case Value::ValueKind::Known:
+            kind = "always";
+            break;
+        case Value::ValueKind::Inconclusive:
+            kind = "inconclusive";
+            break;
+        case Value::ValueKind::Possible:
+            kind = "possible";
+            break;
+        }
+        return kind + " " + v.toString();
+    }
+
+    void setSourceLocation(Value& v,
+                           SourceLocation ctx,
+                           const Token* tok,
+                           SourceLocation local)
+    {
+        std::string file = ctx.file_name();
+        if (file.empty())
+            return;
+        std::string s = Path::stripDirectoryPart(file) + ":" + std::to_string(ctx.line()) + ": " + ctx.function_name() +
+                        " => " + local.function_name() + ": " + debugString(v);
+        v.debugPath.emplace_back(tok, std::move(s));
+    }
+
+    MathLib::bigint valueFlowGetStrLength(const Token* tok)
+    {
+        if (tok->tokType() == Token::eString)
+            return Token::getStrLength(tok);
+        if (astIsGenericChar(tok) || tok->tokType() == Token::eChar)
+            return 1;
+        if (const Value* v = tok->getKnownValue(Value::ValueType::CONTAINER_SIZE))
+            return v->intvalue;
+        if (const Value* v = tok->getKnownValue(Value::ValueType::TOK)) {
+            if (v->tokvalue != tok)
+                return valueFlowGetStrLength(v->tokvalue);
+        }
+        return 0;
+    }
+}
diff --git a/lib/vf_common.h b/lib/vf_common.h
new file mode 100644
index 00000000000..3ed36e6c47f
--- /dev/null
+++ b/lib/vf_common.h
@@ -0,0 +1,59 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef vfCommonH
+#define vfCommonH
+
+#include "config.h"
+#include "mathlib.h"
+#include "sourcelocation.h"
+#include "symboldatabase.h"
+
+#include <cstddef>
+#include <string>
+
+class Token;
+class Settings;
+class Platform;
+
+namespace ValueFlow
+{
+    class Value;
+}
+
+namespace ValueFlow
+{
+    bool getMinMaxValues(const ValueType* vt, const Platform& platform, MathLib::bigint& minValue, MathLib::bigint& maxValue);
+
+    MathLib::bigint truncateIntValue(MathLib::bigint value, size_t value_size, ValueType::Sign dst_sign);
+
+    Token * valueFlowSetConstantValue(Token *tok, const Settings &settings);
+
+    Value castValue(Value value, ValueType::Sign sign, nonneg int bit);
+
+    std::string debugString(const Value& v);
+
+    void setSourceLocation(Value& v,
+                           SourceLocation ctx,
+                           const Token* tok,
+                           SourceLocation local = SourceLocation::current());
+
+    MathLib::bigint valueFlowGetStrLength(const Token* tok);
+}
+
+#endif // vfCommonH
diff --git a/lib/vf_settokenvalue.cpp b/lib/vf_settokenvalue.cpp
new file mode 100644
index 00000000000..12acc01dedd
--- /dev/null
+++ b/lib/vf_settokenvalue.cpp
@@ -0,0 +1,730 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "vf_settokenvalue.h"
+
+#include "astutils.h"
+#include "calculate.h"
+#include "config.h"
+#include "library.h"
+#include "mathlib.h"
+#include "platform.h"
+#include "settings.h"
+#include "symboldatabase.h"
+#include "token.h"
+#include "utils.h"
+#include "valueflow.h"
+#include "vfvalue.h"
+
+#include "vf_common.h"
+
+#include <algorithm>
+#include <climits>
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <list>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+namespace ValueFlow
+{
+    static Library::Container::Yield getContainerYield(Token* tok, const Settings& settings, Token*& parent)
+    {
+        if (Token::Match(tok, ". %name% (") && tok->astParent() == tok->tokAt(2) && tok->astOperand1() &&
+            tok->astOperand1()->valueType()) {
+            const Library::Container* c = getLibraryContainer(tok->astOperand1());
+            parent = tok->astParent();
+            return c ? c->getYield(tok->strAt(1)) : Library::Container::Yield::NO_YIELD;
+        }
+        if (Token::Match(tok->previous(), "%name% (")) {
+            parent = tok;
+            if (const Library::Function* f = settings.library.getFunction(tok->previous())) {
+                return f->containerYield;
+            }
+        }
+        return Library::Container::Yield::NO_YIELD;
+    }
+
+    static Value truncateImplicitConversion(Token* parent, const Value& value, const Settings& settings)
+    {
+        if (!value.isIntValue() && !value.isFloatValue())
+            return value;
+        if (!parent)
+            return value;
+        if (!parent->isBinaryOp())
+            return value;
+        if (!parent->isConstOp())
+            return value;
+        if (!astIsIntegral(parent->astOperand1(), false))
+            return value;
+        if (!astIsIntegral(parent->astOperand2(), false))
+            return value;
+        const ValueType* vt1 = parent->astOperand1()->valueType();
+        const ValueType* vt2 = parent->astOperand2()->valueType();
+        // If the sign is the same there is no truncation
+        if (vt1->sign == vt2->sign)
+            return value;
+        const size_t n1 = vt1->getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer);
+        const size_t n2 = vt2->getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer);
+        ValueType::Sign sign = ValueType::Sign::UNSIGNED;
+        if (n1 < n2)
+            sign = vt2->sign;
+        else if (n1 > n2)
+            sign = vt1->sign;
+        Value v = castValue(value, sign, std::max(n1, n2) * 8);
+        v.wideintvalue = value.intvalue;
+        return v;
+    }
+
+    static const Token *getCastTypeStartToken(const Token *parent, const Settings& settings)
+    {
+        // TODO: This might be a generic utility function?
+        if (!Token::Match(parent, "{|("))
+            return nullptr;
+        // Functional cast
+        if (parent->isBinaryOp() && Token::Match(parent->astOperand1(), "%type% (|{") &&
+            parent->astOperand1()->tokType() == Token::eType && astIsPrimitive(parent))
+            return parent->astOperand1();
+        if (parent->str() != "(")
+            return nullptr;
+        if (!parent->astOperand2() && Token::Match(parent, "( %name%|::")) {
+            const Token* ftok = parent->next();
+            if (ftok->isStandardType())
+                return ftok;
+            if (Token::simpleMatch(ftok, "::"))
+                ftok = ftok->next();
+            while (Token::Match(ftok, "%name% ::"))
+                ftok = ftok->tokAt(2);
+            if (settings.library.isNotLibraryFunction(ftok))
+                return parent->next();
+        }
+        if (parent->astOperand2() && Token::Match(parent->astOperand1(), "const_cast|dynamic_cast|reinterpret_cast|static_cast <"))
+            return parent->astOperand1()->tokAt(2);
+        return nullptr;
+    }
+
+    static bool isNumeric(const Value& value) {
+        return value.isIntValue() || value.isFloatValue();
+    }
+
+    static void setTokenValueCast(Token *parent, const ValueType &valueType, Value value, const Settings &settings)
+    {
+        if (valueType.pointer || value.isImpossible())
+            setTokenValue(parent,std::move(value),settings);
+        else if (valueType.type == ValueType::Type::CHAR)
+            setTokenValue(parent, castValue(std::move(value), valueType.sign, settings.platform.char_bit), settings);
+        else if (valueType.type == ValueType::Type::SHORT)
+            setTokenValue(parent, castValue(std::move(value), valueType.sign, settings.platform.short_bit), settings);
+        else if (valueType.type == ValueType::Type::INT)
+            setTokenValue(parent, castValue(std::move(value), valueType.sign, settings.platform.int_bit), settings);
+        else if (valueType.type == ValueType::Type::LONG)
+            setTokenValue(parent, castValue(std::move(value), valueType.sign, settings.platform.long_bit), settings);
+        else if (valueType.type == ValueType::Type::LONGLONG)
+            setTokenValue(parent, castValue(std::move(value), valueType.sign, settings.platform.long_long_bit), settings);
+        else if (valueType.isFloat() && isNumeric(value)) {
+            if (value.isIntValue())
+                value.floatValue = static_cast<double>(value.intvalue);
+            value.valueType = Value::ValueType::FLOAT;
+            setTokenValue(parent, std::move(value), settings);
+        } else if (value.isIntValue()) {
+            const long long charMax = settings.platform.signedCharMax();
+            const long long charMin = settings.platform.signedCharMin();
+            if (charMin <= value.intvalue && value.intvalue <= charMax) {
+                // unknown type, but value is small so there should be no truncation etc
+                setTokenValue(parent,std::move(value),settings);
+            }
+        }
+    }
+
+    // does the operation cause a loss of information?
+    static bool isNonInvertibleOperation(const Token* tok)
+    {
+        return !Token::Match(tok, "+|-");
+    }
+
+    static bool isComputableValue(const Token* parent, const Value& value)
+    {
+        const bool noninvertible = isNonInvertibleOperation(parent);
+        if (noninvertible && value.isImpossible())
+            return false;
+        if (!value.isIntValue() && !value.isFloatValue() && !value.isTokValue() && !value.isIteratorValue())
+            return false;
+        if (value.isIteratorValue() && !Token::Match(parent, "+|-"))
+            return false;
+        if (value.isTokValue() && (!parent->isComparisonOp() || !Token::Match(value.tokvalue, "{|%str%")))
+            return false;
+        return true;
+    }
+
+    /** Set token value for cast */
+    static bool isCompatibleValueTypes(Value::ValueType x, Value::ValueType y)
+    {
+        static const std::unordered_map<Value::ValueType,
+                                        std::unordered_set<Value::ValueType, EnumClassHash>,
+                                        EnumClassHash>
+        compatibleTypes = {
+            {Value::ValueType::INT,
+             {Value::ValueType::FLOAT,
+              Value::ValueType::SYMBOLIC,
+              Value::ValueType::TOK}},
+            {Value::ValueType::FLOAT, {Value::ValueType::INT}},
+            {Value::ValueType::TOK, {Value::ValueType::INT}},
+            {Value::ValueType::ITERATOR_START, {Value::ValueType::INT}},
+            {Value::ValueType::ITERATOR_END, {Value::ValueType::INT}},
+        };
+        if (x == y)
+            return true;
+        auto it = compatibleTypes.find(x);
+        if (it == compatibleTypes.end())
+            return false;
+        return it->second.count(y) > 0;
+    }
+
+    static bool isCompatibleValues(const Value& value1, const Value& value2)
+    {
+        if (value1.isSymbolicValue() && value2.isSymbolicValue() && value1.tokvalue->exprId() != value2.tokvalue->exprId())
+            return false;
+        if (!isCompatibleValueTypes(value1.valueType, value2.valueType))
+            return false;
+        if (value1.isKnown() || value2.isKnown())
+            return true;
+        if (value1.isImpossible() || value2.isImpossible())
+            return false;
+        if (value1.varId == 0 || value2.varId == 0)
+            return true;
+        if (value1.varId == value2.varId && value1.varvalue == value2.varvalue && value1.isIntValue() && value2.isIntValue())
+            return true;
+        return false;
+    }
+
+    /** set ValueFlow value and perform calculations if possible */
+    void setTokenValue(Token* tok,
+                       Value value,
+                       const Settings& settings,
+                       SourceLocation loc)
+    {
+        // Skip setting values that are too big since its ambiguous
+        if (!value.isImpossible() && value.isIntValue() && value.intvalue < 0 && astIsUnsigned(tok)
+            && tok->valueType()->getSizeOf(settings, ValueType::Accuracy::LowerBound, ValueType::SizeOf::Pointer)
+            >= sizeof(MathLib::bigint))
+            return;
+
+        if (!value.isImpossible() && value.isIntValue())
+            value = truncateImplicitConversion(tok->astParent(), value, settings);
+
+        if (settings.debugnormal)
+            setSourceLocation(value, loc, tok);
+
+        if (!tok->addValue(value))
+            return;
+
+        if (value.path < 0)
+            return;
+
+        Token *parent = tok->astParent();
+        if (!parent)
+            return;
+
+        if (Token::simpleMatch(parent, ",") && !parent->isInitComma() && astIsRHS(tok)) {
+            const Token* callParent = findParent(parent, [](const Token* p) {
+                return !Token::simpleMatch(p, ",");
+            });
+            // Ensure that the comma isn't a function call
+            if (!callParent || (!Token::Match(callParent->previous(), "%name%|> (") && !Token::simpleMatch(callParent, "{") &&
+                                (!Token::Match(callParent, "( %name%") || settings.library.isNotLibraryFunction(callParent->next())) &&
+                                !(callParent->str() == "(" && (Token::simpleMatch(callParent->astOperand1(), "*") || Token::Match(callParent->astOperand1(), "%name%|("))))) {
+                setTokenValue(parent, std::move(value), settings);
+                return;
+            }
+        }
+
+        if (Token::simpleMatch(parent, "=") && astIsRHS(tok)) {
+            setTokenValue(parent, value, settings);
+            if (!value.isUninitValue())
+                return;
+        }
+
+        if (value.isContainerSizeValue() && astIsContainer(tok)) {
+            // .empty, .size, +"abc", +'a'
+            if (Token::Match(parent, "+|==|!=") && parent->astOperand1() && parent->astOperand2()) {
+                for (const Value &value1 : parent->astOperand1()->values()) {
+                    if (value1.isImpossible())
+                        continue;
+                    for (const Value &value2 : parent->astOperand2()->values()) {
+                        if (value2.isImpossible())
+                            continue;
+                        if (value1.path != value2.path)
+                            continue;
+                        Value result;
+                        if (Token::Match(parent, "%comp%"))
+                            result.valueType = Value::ValueType::INT;
+                        else
+                            result.valueType = Value::ValueType::CONTAINER_SIZE;
+
+                        if (value1.isContainerSizeValue() && value2.isContainerSizeValue())
+                            result.intvalue = calculate(parent->str(), value1.intvalue, value2.intvalue);
+                        else if (value1.isContainerSizeValue() && value2.isTokValue() && value2.tokvalue->tokType() == Token::eString)
+                            result.intvalue = calculate(parent->str(), value1.intvalue, MathLib::bigint(Token::getStrLength(value2.tokvalue)));
+                        else if (value2.isContainerSizeValue() && value1.isTokValue() && value1.tokvalue->tokType() == Token::eString)
+                            result.intvalue = calculate(parent->str(), MathLib::bigint(Token::getStrLength(value1.tokvalue)), value2.intvalue);
+                        else
+                            continue;
+
+                        combineValueProperties(value1, value2, result);
+
+                        if (Token::simpleMatch(parent, "==") && result.intvalue)
+                            continue;
+                        if (Token::simpleMatch(parent, "!=") && !result.intvalue)
+                            continue;
+
+                        setTokenValue(parent, std::move(result), settings);
+                    }
+                }
+            }
+            Token* next = nullptr;
+            const Library::Container::Yield yields = getContainerYield(parent, settings, next);
+            if (yields == Library::Container::Yield::SIZE) {
+                value.valueType = Value::ValueType::INT;
+                setTokenValue(next, std::move(value), settings);
+            } else if (yields == Library::Container::Yield::EMPTY) {
+                const Value::Bound bound = value.bound;
+                const long long intvalue = value.intvalue;
+                value.valueType = Value::ValueType::INT;
+                value.bound = Value::Bound::Point;
+                if (value.isImpossible()) {
+                    if (intvalue == 0)
+                        value.setKnown();
+                    else if ((bound == Value::Bound::Upper && intvalue > 0) ||
+                             (bound == Value::Bound::Lower && intvalue < 0)) {
+                        value.intvalue = 0;
+                        value.setKnown();
+                    } else
+                        value.setPossible();
+                } else {
+                    value.intvalue = !value.intvalue;
+                }
+                setTokenValue(next, std::move(value), settings);
+            }
+            return;
+        }
+
+        if (value.isLifetimeValue()) {
+            if (!isLifetimeBorrowed(parent, settings))
+                return;
+            if (value.lifetimeKind == Value::LifetimeKind::Iterator && astIsIterator(parent)) {
+                setTokenValue(parent,std::move(value),settings);
+            } else if (astIsPointer(tok) && astIsPointer(parent) && !parent->isUnaryOp("*") &&
+                       (parent->isArithmeticalOp() || parent->isCast())) {
+                setTokenValue(parent,std::move(value),settings);
+            }
+            return;
+        }
+
+        if (value.isUninitValue()) {
+            if (Token::Match(tok, ". %var%"))
+                setTokenValue(tok->next(), value, settings);
+            if (parent->isCast()) {
+                setTokenValue(parent, std::move(value), settings);
+                return;
+            }
+            if (!value.subexpressions.empty() && Token::Match(parent, ". %var%")) {
+                if (contains(value.subexpressions, parent->strAt(1)))
+                    value.subexpressions.clear();
+                else
+                    return;
+            }
+            if (parent->isUnaryOp("&")) {
+                value.indirect++;
+                setTokenValue(parent, std::move(value), settings);
+            } else if (Token::Match(parent, ". %var%") && parent->astOperand1() == tok && parent->astOperand2()) {
+                if (parent->originalName() == "->" && value.indirect > 0)
+                    value.indirect--;
+                setTokenValue(parent->astOperand2(), std::move(value), settings);
+            } else if (Token::Match(parent->astParent(), ". %var%") && parent->astParent()->astOperand1() == parent) {
+                if (parent->astParent()->originalName() == "->" && value.indirect > 0)
+                    value.indirect--;
+                setTokenValue(parent->astParent()->astOperand2(), std::move(value), settings);
+            } else if (parent->isUnaryOp("*") && value.indirect > 0) {
+                value.indirect--;
+                setTokenValue(parent, std::move(value), settings);
+            }
+            return;
+        }
+
+        // cast..
+        if (const Token *castType = getCastTypeStartToken(parent, settings)) {
+            if (contains({Value::ValueType::INT, Value::ValueType::SYMBOLIC}, value.valueType) &&
+                Token::simpleMatch(parent->astOperand1(), "dynamic_cast"))
+                return;
+            const ValueType &valueType = ValueType::parseDecl(castType, settings);
+            if (value.isImpossible() && value.isIntValue() && value.intvalue < 0
+                && astIsUnsigned(tok) && valueType.sign == ValueType::SIGNED && tok->valueType()
+                && tok->valueType()->getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer)
+                >= valueType.getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer))
+                return;
+            setTokenValueCast(parent, valueType, std::move(value), settings);
+        }
+
+        else if (parent->str() == ":") {
+            setTokenValue(parent,std::move(value),settings);
+        }
+
+        else if (parent->str() == "?" && tok->str() == ":" && tok == parent->astOperand2() && parent->astOperand1()) {
+            // is condition always true/false?
+            if (parent->astOperand1()->hasKnownValue()) {
+                const Value &condvalue = parent->astOperand1()->values().front();
+                const bool cond(condvalue.isTokValue() || (condvalue.isIntValue() && condvalue.intvalue != 0));
+                if (cond && !tok->astOperand1()) { // true condition, no second operator
+                    setTokenValue(parent, condvalue, settings);
+                } else {
+                    const Token *op = cond ? tok->astOperand1() : tok->astOperand2();
+                    if (!op) // #7769 segmentation fault at setTokenValue()
+                        return;
+                    const std::list<Value> &values = op->values();
+                    if (std::find(values.cbegin(), values.cend(), value) != values.cend())
+                        setTokenValue(parent, std::move(value), settings);
+                }
+            } else if (!value.isImpossible()) {
+                // is condition only depending on 1 variable?
+                nonneg int varId = 0;
+                bool ret = false;
+                visitAstNodes(parent->astOperand1(),
+                              [&](const Token *t) {
+                    if (t->varId()) {
+                        if (varId > 0 || value.varId != 0)
+                            ret = true;
+                        varId = t->varId();
+                    } else if (t->str() == "(" && Token::Match(t->previous(), "%name%"))
+                        ret = true; // function call
+                    return ret ? ChildrenToVisit::done : ChildrenToVisit::op1_and_op2;
+                });
+                if (ret)
+                    return;
+
+                value.conditional = true;
+                value.changeKnownToPossible();
+
+                setTokenValue(parent, std::move(value), settings);
+            }
+        }
+
+        else if (parent->str() == "?" && value.isIntValue() && tok == parent->astOperand1() && value.isKnown() &&
+                 parent->astOperand2() && parent->astOperand2()->astOperand1() && parent->astOperand2()->astOperand2()) {
+            const std::list<Value> &values = (value.intvalue == 0
+                ? parent->astOperand2()->astOperand2()->values()
+                : parent->astOperand2()->astOperand1()->values());
+
+            for (const Value &v : values)
+                setTokenValue(parent, v, settings);
+        }
+
+        // Offset of non null pointer is not null also
+        else if (astIsPointer(tok) && Token::Match(parent, "+|-") &&
+                 (parent->astOperand2() == nullptr || !astIsPointer(parent->astOperand2())) &&
+                 value.isIntValue() && value.isImpossible() && value.intvalue == 0) {
+            setTokenValue(parent, std::move(value), settings);
+        }
+
+        // Calculations..
+        else if ((parent->isArithmeticalOp() || parent->isComparisonOp() || (parent->tokType() == Token::eBitOp) ||
+                  (parent->tokType() == Token::eLogicalOp)) &&
+                 parent->astOperand1() && parent->astOperand2()) {
+
+            const bool noninvertible = isNonInvertibleOperation(parent);
+
+            // Skip operators with impossible values that are not invertible
+            if (noninvertible && value.isImpossible())
+                return;
+
+            if (!value.isImpossible() && value.isIntValue() &&
+                ((Token::Match(parent, "[&*]") && astIsIntegral(parent, true) && value.intvalue == 0) ||
+                 (Token::simpleMatch(parent, "&&") && value.intvalue == 0) ||
+                 (Token::simpleMatch(parent, "||") && value.intvalue != 0))) {
+                value.bound = Value::Bound::Point;
+                setTokenValue(parent, std::move(value), settings);
+                return;
+            }
+
+            for (const Value &value1 : parent->astOperand1()->values()) {
+                if (!isComputableValue(parent, value1))
+                    continue;
+                for (const Value &value2 : parent->astOperand2()->values()) {
+                    if (value1.path != value2.path && value1.path != 0 && value2.path != 0)
+                        continue;
+                    if (!isComputableValue(parent, value2))
+                        continue;
+                    if (value1.isIteratorValue() && value2.isIteratorValue())
+                        continue;
+                    if (!isCompatibleValues(value1, value2))
+                        continue;
+                    Value result(0);
+                    combineValueProperties(value1, value2, result);
+                    if (astIsFloat(parent, false)) {
+                        if (!result.isIntValue() && !result.isFloatValue())
+                            continue;
+                        result.valueType = Value::ValueType::FLOAT;
+                    }
+                    const bool isFloat = value1.isFloatValue() || value2.isFloatValue();
+                    if (isFloat && Token::Match(parent, "&|^|%|<<|>>|==|!=|%or%"))
+                        continue;
+                    const auto intValue1 = [&]() -> MathLib::bigint {
+                        return value1.isFloatValue() ? static_cast<MathLib::bigint>(value1.floatValue) : value1.intvalue;
+                    };
+                    const auto intValue2 = [&]() -> MathLib::bigint {
+                        return value2.isFloatValue() ? static_cast<MathLib::bigint>(value2.floatValue) : value2.intvalue;
+                    };
+                    if (Token::Match(parent, "==|!=")) {
+                        if ((value1.isIntValue() && value2.isTokValue()) || (value1.isTokValue() && value2.isIntValue())) {
+                            if (parent->str() == "==")
+                                result.intvalue = 0;
+                            else if (parent->str() == "!=")
+                                result.intvalue = 1;
+                        } else if (value1.isIntValue() && value2.isIntValue()) {
+                            bool error = false;
+                            result.intvalue = calculate(parent->str(), intValue1(), intValue2(), &error);
+                            if (error)
+                                continue;
+                        } else if (value1.isTokValue() && value2.isTokValue() &&
+                                   (astIsContainer(parent->astOperand1()) || astIsContainer(parent->astOperand2()))) {
+                            const Token* tok1 = value1.tokvalue;
+                            const Token* tok2 = value2.tokvalue;
+                            bool equal = false;
+                            if (Token::Match(tok1, "%str%") && Token::Match(tok2, "%str%")) {
+                                equal = tok1->str() == tok2->str();
+                            } else if (Token::simpleMatch(tok1, "{") && Token::simpleMatch(tok2, "{")) {
+                                std::vector<const Token*> args1 = getArguments(tok1);
+                                std::vector<const Token*> args2 = getArguments(tok2);
+                                if (args1.size() == args2.size()) {
+                                    if (!std::all_of(args1.begin(), args1.end(), std::mem_fn(&Token::hasKnownIntValue)))
+                                        continue;
+                                    if (!std::all_of(args2.begin(), args2.end(), std::mem_fn(&Token::hasKnownIntValue)))
+                                        continue;
+                                    equal = std::equal(args1.begin(),
+                                                       args1.end(),
+                                                       args2.begin(),
+                                                       [&](const Token* atok, const Token* btok) {
+                                        return atok->getKnownIntValue() ==
+                                               btok->getKnownIntValue();
+                                    });
+                                } else {
+                                    equal = false;
+                                }
+                            } else {
+                                continue;
+                            }
+                            result.intvalue = parent->str() == "==" ? equal : !equal;
+                        } else {
+                            continue;
+                        }
+                        setTokenValue(parent, std::move(result), settings);
+                    } else if (Token::Match(parent, "%op%")) {
+                        if (Token::Match(parent, "%comp%")) {
+                            if (!isFloat && !value1.isIntValue() && !value2.isIntValue())
+                                continue;
+                        } else {
+                            if (value1.isTokValue() || value2.isTokValue())
+                                break;
+                        }
+                        bool error = false;
+                        if (isFloat) {
+                            const double floatValue1 = value1.isFloatValue() ? value1.floatValue : static_cast<double>(value1.intvalue);
+                            const double floatValue2 = value2.isFloatValue() ? value2.floatValue : static_cast<double>(value2.intvalue);
+                            auto val = calculate(parent->str(), floatValue1, floatValue2, &error);
+                            if (result.isFloatValue()) {
+                                result.floatValue = val;
+                            } else {
+                                result.intvalue = static_cast<MathLib::bigint>(val);
+                            }
+                        } else {
+                            auto val = calculate(parent->str(), intValue1(), intValue2(), &error);
+                            if (result.isFloatValue()) {
+                                result.floatValue = static_cast<double>(val);
+                            } else {
+                                result.intvalue = val;
+                            }
+                        }
+                        if (error)
+                            continue;
+                        // If the bound comes from the second value then invert the bound when subtracting
+                        if (Token::simpleMatch(parent, "-") && value2.bound == result.bound &&
+                            value2.bound != Value::Bound::Point)
+                            result.invertBound();
+                        setTokenValue(parent, std::move(result), settings);
+                    }
+                }
+            }
+        }
+
+        // !
+        else if (parent->str() == "!") {
+            for (const Value &val : tok->values()) {
+                if (!val.isIntValue())
+                    continue;
+                if (val.isImpossible() && val.intvalue != 0)
+                    continue;
+                Value v(val);
+                if (val.isImpossible())
+                    v.setKnown();
+                else
+                    v.intvalue = !v.intvalue;
+                setTokenValue(parent, std::move(v), settings);
+            }
+        }
+
+        // ~
+        else if (parent->str() == "~") {
+            for (const Value &val : tok->values()) {
+                if (!val.isIntValue())
+                    continue;
+                Value v(val);
+                v.intvalue = ~v.intvalue;
+                std::uint8_t bits = 0;
+                if (tok->valueType() &&
+                    tok->valueType()->sign == ValueType::Sign::UNSIGNED &&
+                    tok->valueType()->pointer == 0) {
+                    if (tok->valueType()->type == ValueType::Type::INT)
+                        bits = settings.platform.int_bit;
+                    else if (tok->valueType()->type == ValueType::Type::LONG)
+                        bits = settings.platform.long_bit;
+                }
+                if (bits > 0 && bits < MathLib::bigint_bits)
+                    v.intvalue &= (1ULL<<bits) - 1;
+                setTokenValue(parent, std::move(v), settings);
+            }
+        }
+
+        // unary minus
+        else if (parent->isUnaryOp("-")) {
+            for (const Value &val : tok->values()) {
+                if (!val.isIntValue() && !val.isFloatValue())
+                    continue;
+                Value v(val);
+                if (v.isIntValue()) {
+                    if (v.intvalue == LLONG_MIN)
+                        // Value can't be inverted
+                        continue;
+                    v.intvalue = -v.intvalue;
+                } else
+                    v.floatValue = -v.floatValue;
+                v.invertBound();
+                setTokenValue(parent, std::move(v), settings);
+            }
+        }
+
+        // increment
+        else if (parent->str() == "++") {
+            for (const Value &val : tok->values()) {
+                if (!val.isIntValue() && !val.isFloatValue() && !val.isSymbolicValue())
+                    continue;
+                Value v(val);
+                if (parent == tok->previous()) {
+                    if (v.isIntValue() || v.isSymbolicValue()) {
+                        const ValueType *dst = tok->valueType();
+                        if (dst) {
+                            const size_t sz = dst->getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer);
+                            MathLib::bigint newvalue = ValueFlow::truncateIntValue(v.intvalue + 1, sz, dst->sign);
+                            if (v.bound != ValueFlow::Value::Bound::Point) {
+                                if (newvalue < v.intvalue) {
+                                    v.invertBound();
+                                    newvalue -= 2;
+                                }
+                            }
+                            v.intvalue = newvalue;
+                        } else {
+                            v.intvalue = v.intvalue + 1;
+                        }
+                    }
+                    else
+                        v.floatValue = v.floatValue + 1.0;
+                }
+                setTokenValue(parent, std::move(v), settings);
+            }
+        }
+
+        // decrement
+        else if (parent->str() == "--") {
+            for (const Value &val : tok->values()) {
+                if (!val.isIntValue() && !val.isFloatValue() && !val.isSymbolicValue())
+                    continue;
+                Value v(val);
+                if (parent == tok->previous()) {
+                    if (v.isIntValue() || v.isSymbolicValue()) {
+                        const ValueType *dst = tok->valueType();
+                        if (dst) {
+                            const size_t sz = dst->getSizeOf(settings, ValueType::Accuracy::ExactOrZero, ValueType::SizeOf::Pointer);
+                            MathLib::bigint newvalue = ValueFlow::truncateIntValue(v.intvalue - 1, sz, dst->sign);
+                            if (v.bound != ValueFlow::Value::Bound::Point) {
+                                if (newvalue > v.intvalue) {
+                                    v.invertBound();
+                                    newvalue += 2;
+                                }
+                            }
+                            v.intvalue = newvalue;
+                        } else {
+                            v.intvalue = v.intvalue - 1;
+                        }
+                    }
+                    else
+                        v.floatValue = v.floatValue - 1.0;
+                }
+                setTokenValue(parent, std::move(v), settings);
+            }
+        }
+
+        // C++ init
+        else if (parent->str() == "{" && Token::simpleMatch(parent->previous(), "= {") &&
+                 Token::simpleMatch(parent->link(), "} ;")) {
+            const Token* lhs = parent->previous()->astOperand1();
+            if (lhs && lhs->valueType()) {
+                if (lhs->valueType()->isIntegral() || lhs->valueType()->isFloat() || (lhs->valueType()->pointer > 0 && value.isIntValue())) {
+                    setTokenValue(parent, std::move(value), settings);
+                }
+            }
+        }
+
+        else if (Token::Match(parent, ":: %name%") && parent->astOperand2() == tok) {
+            setTokenValue(parent, std::move(value), settings);
+        }
+
+        // Calling std::size or std::empty on an array
+        else if (value.isTokValue() && Token::simpleMatch(value.tokvalue, "{") && tok->variable() &&
+                 tok->variable()->isArray() && Token::Match(parent->previous(), "%name% (") && astIsRHS(tok)) {
+            std::vector<const Token*> args = getArguments(value.tokvalue);
+            if (const Library::Function* f = settings.library.getFunction(parent->previous())) {
+                if (f->containerYield == Library::Container::Yield::SIZE) {
+                    value.valueType = Value::ValueType::INT;
+                    value.intvalue = args.size();
+                    setTokenValue(parent, std::move(value), settings);
+                } else if (f->containerYield == Library::Container::Yield::EMPTY) {
+                    value.intvalue = args.empty();
+                    value.valueType = Value::ValueType::INT;
+                    setTokenValue(parent, std::move(value), settings);
+                }
+            }
+        }
+
+        // C++ constructor
+        else if (value.isIntValue() && parent->str() == "{" && parent->valueType() && (parent->valueType()->isIntegral() || parent->valueType()->pointer > 0)) {
+            setTokenValue(parent, std::move(value), settings);
+        }
+    }
+}
diff --git a/lib/vf_settokenvalue.h b/lib/vf_settokenvalue.h
new file mode 100644
index 00000000000..65722d5a0ac
--- /dev/null
+++ b/lib/vf_settokenvalue.h
@@ -0,0 +1,36 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef vfSetTokenValueH
+#define vfSetTokenValueH
+
+#include "sourcelocation.h"
+
+class Token;
+class Settings;
+namespace ValueFlow { class Value; }
+
+namespace ValueFlow
+{
+    void setTokenValue(Token* tok,
+                       Value value,
+                       const Settings& settings,
+                       SourceLocation loc = SourceLocation::current());
+}
+
+#endif // vfSetTokenValueH
diff --git a/lib/vfvalue.cpp b/lib/vfvalue.cpp
new file mode 100644
index 00000000000..308b42b91d1
--- /dev/null
+++ b/lib/vfvalue.cpp
@@ -0,0 +1,200 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "vfvalue.h"
+
+#include "mathlib.h"
+#include "token.h"
+#include "utils.h"
+
+#include <sstream>
+#include <string>
+
+namespace ValueFlow {
+    Value::Value(const Token *c, MathLib::bigint val, Bound b)
+        : bound(b),
+        safe(false),
+        conditional(false),
+        macro(false),
+        defaultArg(false),
+        intvalue(val),
+        varvalue(val),
+        condition(c) {
+        errorPath.emplace_back(c, "Assuming that condition '" + c->expressionString() + "' is not redundant");
+    }
+
+    void Value::assumeCondition(const Token *tok) {
+        condition = tok;
+        errorPath.emplace_back(tok, "Assuming that condition '" + tok->expressionString() + "' is not redundant");
+    }
+
+    std::string Value::toString() const {
+        std::stringstream ss;
+        if (this->isImpossible())
+            ss << "!";
+        if (this->bound == Bound::Lower)
+            ss << ">=";
+        if (this->bound == Bound::Upper)
+            ss << "<=";
+        switch (this->valueType) {
+        case ValueType::INT:
+            ss << this->intvalue;
+            break;
+        case ValueType::TOK:
+            ss << this->tokvalue->str();
+            break;
+        case ValueType::FLOAT:
+            ss << MathLib::toString(this->floatValue);
+            break;
+        case ValueType::MOVED:
+            ss << toString(this->moveKind);
+            break;
+        case ValueType::UNINIT:
+            ss << "Uninit";
+            break;
+        case ValueType::BUFFER_SIZE:
+        case ValueType::CONTAINER_SIZE:
+            ss << "size=" << this->intvalue;
+            break;
+        case ValueType::ITERATOR_START:
+            ss << "start=" << this->intvalue;
+            break;
+        case ValueType::ITERATOR_END:
+            ss << "end=" << this->intvalue;
+            break;
+        case ValueType::LIFETIME:
+            ss << "lifetime[" << toString(this->lifetimeKind) << "]=("
+               << this->tokvalue->expressionString() << ")";
+            break;
+        case ValueType::SYMBOLIC:
+            ss << "symbolic=(" << this->tokvalue->expressionString();
+            if (this->intvalue > 0)
+                ss << "+" << this->intvalue;
+            else if (this->intvalue < 0)
+                ss << "-" << -this->intvalue;
+            ss << ")";
+            break;
+        }
+        if (this->indirect > 0)
+            for (int i = 0; i < this->indirect; i++)
+                ss << "*";
+        if (this->path > 0)
+            ss << "@" << this->path;
+        return ss.str();
+    }
+
+    std::string Value::infoString() const {
+        switch (valueType) {
+        case ValueType::INT:
+            return MathLib::toString(intvalue);
+        case ValueType::TOK:
+            return tokvalue->str();
+        case ValueType::FLOAT:
+            return MathLib::toString(floatValue);
+        case ValueType::MOVED:
+            return "<Moved>";
+        case ValueType::UNINIT:
+            return "<Uninit>";
+        case ValueType::BUFFER_SIZE:
+        case ValueType::CONTAINER_SIZE:
+            return "size=" + MathLib::toString(intvalue);
+        case ValueType::ITERATOR_START:
+            return "start=" + MathLib::toString(intvalue);
+        case ValueType::ITERATOR_END:
+            return "end=" + MathLib::toString(intvalue);
+        case ValueType::LIFETIME:
+            return "lifetime=" + tokvalue->str();
+        case ValueType::SYMBOLIC:
+        {
+            std::string result = "symbolic=" + tokvalue->expressionString();
+            if (intvalue > 0)
+                result += "+" + MathLib::toString(intvalue);
+            else if (intvalue < 0)
+                result += "-" + MathLib::toString(-intvalue);
+            return result;
+        }
+        }
+        cppcheck::unreachable();
+    }
+
+    const char *Value::toString(MoveKind moveKind) {
+        switch (moveKind) {
+        case MoveKind::NonMovedVariable:
+            return "NonMovedVariable";
+        case MoveKind::MovedVariable:
+            return "MovedVariable";
+        case MoveKind::ForwardedVariable:
+            return "ForwardedVariable";
+        }
+        return "";
+    }
+
+    const char *Value::toString(LifetimeKind lifetimeKind) {
+        switch (lifetimeKind) {
+        case LifetimeKind::Object:
+            return "Object";
+        case LifetimeKind::SubObject:
+            return "SubObject";
+        case LifetimeKind::Lambda:
+            return "Lambda";
+        case LifetimeKind::Iterator:
+            return "Iterator";
+        case LifetimeKind::Address:
+            return "Address";
+        }
+        return "";
+    }
+
+    bool Value::sameToken(const Token *tok1, const Token *tok2) {
+        if (tok1 == tok2)
+            return true;
+        if (!tok1)
+            return false;
+        if (tok1->exprId() == 0 || tok2->exprId() == 0)
+            return false;
+        return tok1->exprId() == tok2->exprId();
+    }
+
+    const char *Value::toString(LifetimeScope lifetimeScope) {
+        switch (lifetimeScope) {
+        case LifetimeScope::Local:
+            return "Local";
+        case LifetimeScope::Argument:
+            return "Argument";
+        case LifetimeScope::SubFunction:
+            return "SubFunction";
+        case LifetimeScope::ThisPointer:
+            return "ThisPointer";
+        case LifetimeScope::ThisValue:
+            return "ThisValue";
+        }
+        return "";
+    }
+
+    const char *Value::toString(Bound bound) {
+        switch (bound) {
+        case Bound::Point:
+            return "Point";
+        case Bound::Upper:
+            return "Upper";
+        case Bound::Lower:
+            return "Lower";
+        }
+        return "";
+    }
+}
diff --git a/lib/vfvalue.h b/lib/vfvalue.h
new file mode 100644
index 00000000000..8a473143b68
--- /dev/null
+++ b/lib/vfvalue.h
@@ -0,0 +1,436 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+//---------------------------------------------------------------------------
+#ifndef vfvalueH
+#define vfvalueH
+//---------------------------------------------------------------------------
+
+#include "config.h"
+#include "errortypes.h"
+#include "mathlib.h"
+
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+FORCE_WARNING_CLANG_PUSH("-Wpadded")
+
+class Token;
+
+namespace ValueFlow
+{
+    class CPPCHECKLIB Value {
+    public:
+        enum class Bound : std::uint8_t { Upper, Lower, Point };
+
+        explicit Value(MathLib::bigint val = 0, Bound b = Bound::Point) :
+            bound(b),
+            safe(false),
+            conditional(false),
+            macro(false),
+            defaultArg(false),
+            intvalue(val),
+            varvalue(val),
+            wideintvalue(val)
+        {}
+        Value(const Token* c, MathLib::bigint val, Bound b = Bound::Point);
+
+        static Value unknown() {
+            Value v;
+            v.valueType = ValueType::UNINIT;
+            return v;
+        }
+
+        bool equalValue(const ValueFlow::Value& rhs) const {
+            if (valueType != rhs.valueType)
+                return false;
+            switch (valueType) {
+            case ValueType::INT:
+            case ValueType::CONTAINER_SIZE:
+            case ValueType::BUFFER_SIZE:
+            case ValueType::ITERATOR_START:
+            case ValueType::ITERATOR_END:
+                if (intvalue != rhs.intvalue)
+                    return false;
+                break;
+            case ValueType::TOK:
+                if (tokvalue != rhs.tokvalue)
+                    return false;
+                break;
+            case ValueType::FLOAT:
+                if (floatValue > rhs.floatValue || floatValue < rhs.floatValue || std::signbit(floatValue) != std::signbit(rhs.floatValue))
+                    return false;
+                break;
+            case ValueType::MOVED:
+                if (moveKind != rhs.moveKind)
+                    return false;
+                break;
+            case ValueType::UNINIT:
+                break;
+            case ValueType::LIFETIME:
+                if (tokvalue != rhs.tokvalue)
+                    return false;
+                break;
+            case ValueType::SYMBOLIC:
+                if (!sameToken(tokvalue, rhs.tokvalue))
+                    return false;
+                if (intvalue != rhs.intvalue)
+                    return false;
+                break;
+            }
+            return true;
+        }
+
+        template<class T, class F>
+        static void visitValue(T& self, F f) {
+            switch (self.valueType) {
+            case ValueType::INT:
+            case ValueType::SYMBOLIC:
+            case ValueType::BUFFER_SIZE:
+            case ValueType::CONTAINER_SIZE:
+            case ValueType::ITERATOR_START:
+            case ValueType::ITERATOR_END: {
+                f(self.intvalue);
+                break;
+            }
+            case ValueType::FLOAT: {
+                f(self.floatValue);
+                break;
+            }
+            case ValueType::UNINIT:
+            case ValueType::TOK:
+            case ValueType::LIFETIME:
+            case ValueType::MOVED:
+                break;
+            }
+        }
+
+        struct compareVisitor {
+            struct innerVisitor {
+                template<class Compare, class T, class U>
+                void operator()(bool& result, Compare compare, T x, U y) const {
+                    result = compare(x, y);
+                }
+            };
+            template<class Compare, class T>
+            void operator()(bool& result, const Value& rhs, Compare compare, T x) const {
+                visitValue(rhs,
+                           std::bind(innerVisitor{}, std::ref(result), std::move(compare), x, std::placeholders::_1));
+            }
+        };
+
+        template<class Compare>
+        bool compareValue(const Value& rhs, Compare compare) const {
+            assert((!this->isSymbolicValue() && !rhs.isSymbolicValue()) ||
+                   (this->valueType == rhs.valueType && sameToken(this->tokvalue, rhs.tokvalue)));
+            bool result = false;
+            visitValue(
+                *this,
+                std::bind(compareVisitor{}, std::ref(result), std::ref(rhs), std::move(compare), std::placeholders::_1));
+            return result;
+        }
+
+        bool operator==(const Value &rhs) const {
+            if (!equalValue(rhs))
+                return false;
+
+            return varvalue == rhs.varvalue &&
+                   condition == rhs.condition &&
+                   varId == rhs.varId &&
+                   conditional == rhs.conditional &&
+                   defaultArg == rhs.defaultArg &&
+                   indirect == rhs.indirect &&
+                   valueKind == rhs.valueKind;
+        }
+
+        bool operator!=(const Value &rhs) const {
+            return !(*this == rhs);
+        }
+
+        template<class T, REQUIRES("T must be an arithmetic type", std::is_arithmetic<T> )>
+        bool equalTo(const T& x) const {
+            bool result = false;
+            visitValue(*this, std::bind(equalVisitor{}, std::ref(result), x, std::placeholders::_1));
+            return result;
+        }
+
+        void decreaseRange() {
+            if (bound == Bound::Lower)
+                visitValue(*this, increment{});
+            else if (bound == Bound::Upper)
+                visitValue(*this, decrement{});
+        }
+
+        void invertBound() {
+            if (bound == Bound::Lower)
+                bound = Bound::Upper;
+            else if (bound == Bound::Upper)
+                bound = Bound::Lower;
+        }
+
+        void invertRange() {
+            invertBound();
+            decreaseRange();
+        }
+
+        void assumeCondition(const Token* tok);
+
+        std::string infoString() const;
+
+        std::string toString() const;
+
+        enum class ValueType : std::uint8_t {
+            INT,
+            TOK,
+            FLOAT,
+            MOVED,
+            UNINIT,
+            CONTAINER_SIZE,
+            LIFETIME,
+            BUFFER_SIZE,
+            ITERATOR_START,
+            ITERATOR_END,
+            SYMBOLIC
+        } valueType = ValueType::INT;
+        bool isIntValue() const {
+            return valueType == ValueType::INT;
+        }
+        bool isTokValue() const {
+            return valueType == ValueType::TOK;
+        }
+        bool isFloatValue() const {
+            return valueType == ValueType::FLOAT;
+        }
+        bool isMovedValue() const {
+            return valueType == ValueType::MOVED;
+        }
+        bool isUninitValue() const {
+            return valueType == ValueType::UNINIT;
+        }
+        bool isContainerSizeValue() const {
+            return valueType == ValueType::CONTAINER_SIZE;
+        }
+        bool isLifetimeValue() const {
+            return valueType == ValueType::LIFETIME;
+        }
+        bool isBufferSizeValue() const {
+            return valueType == ValueType::BUFFER_SIZE;
+        }
+        bool isIteratorValue() const {
+            return valueType == ValueType::ITERATOR_START || valueType == ValueType::ITERATOR_END;
+        }
+        bool isIteratorStartValue() const {
+            return valueType == ValueType::ITERATOR_START;
+        }
+        bool isIteratorEndValue() const {
+            return valueType == ValueType::ITERATOR_END;
+        }
+        bool isSymbolicValue() const {
+            return valueType == ValueType::SYMBOLIC;
+        }
+
+        bool isLocalLifetimeValue() const {
+            return valueType == ValueType::LIFETIME && lifetimeScope == LifetimeScope::Local;
+        }
+
+        bool isArgumentLifetimeValue() const {
+            return valueType == ValueType::LIFETIME && lifetimeScope == LifetimeScope::Argument;
+        }
+
+        bool isSubFunctionLifetimeValue() const {
+            return valueType == ValueType::LIFETIME && lifetimeScope == LifetimeScope::SubFunction;
+        }
+
+        bool isNonValue() const {
+            return isMovedValue() || isUninitValue() || isLifetimeValue();
+        }
+
+        /** The value bound  */
+        Bound bound = Bound::Point;
+
+        /** value relies on safe checking */
+        // cppcheck-suppress premium-misra-cpp-2023-12.2.1
+        bool safe : 1;
+
+        /** Conditional value */
+        bool conditional : 1;
+
+        /** Value is is from an expanded macro */
+        bool macro : 1;
+
+        /** Is this value passed as default parameter to the function? */
+        bool defaultArg : 1;
+
+        long long : 4; // padding
+
+        /** kind of moved  */
+        enum class MoveKind : std::uint8_t { NonMovedVariable, MovedVariable, ForwardedVariable } moveKind = MoveKind::NonMovedVariable;
+
+        enum class LifetimeScope : std::uint8_t { Local, Argument, SubFunction, ThisPointer, ThisValue } lifetimeScope = LifetimeScope::Local;
+
+        enum class LifetimeKind : std::uint8_t {
+            // Pointer points to a member of lifetime
+            Object,
+            // A member of object points to the lifetime
+            SubObject,
+            // Lambda has captured lifetime(similar to SubObject)
+            Lambda,
+            // Iterator points to the lifetime of a container(similar to Object)
+            Iterator,
+            // A pointer that holds the address of the lifetime
+            Address
+        } lifetimeKind = LifetimeKind::Object;
+
+        /** How known is this value */
+        enum class ValueKind : std::uint8_t {
+            /** This value is possible, other unlisted values may also be possible */
+            Possible,
+            /** Only listed values are possible */
+            Known,
+            /** Inconclusive */
+            Inconclusive,
+            /** Listed values are impossible */
+            Impossible
+        } valueKind = ValueKind::Possible;
+
+        std::int8_t indirect{}; // TODO: can we reduce the size?
+
+        /** int value (or sometimes bool value?) */
+        MathLib::bigint intvalue{};
+
+        /** token value - the token that has the value. this is used for pointer aliases, strings, etc. */
+        const Token* tokvalue{};
+
+        /** float value */
+        double floatValue{};
+
+        /** For calculated values - variable value that calculated value depends on */
+        MathLib::bigint varvalue{};
+
+        /** Condition that this value depends on */
+        const Token* condition{};
+
+        ErrorPath errorPath;
+
+        ErrorPath debugPath; // TODO: make lighter by default
+
+        /** For calculated values - varId that calculated value depends on */
+        nonneg int varId{};
+
+        enum class UnknownFunctionReturn : std::uint8_t {
+            no,             // not unknown function return
+            outOfMemory,    // out of memory
+            outOfResources, // out of resource
+            other           // other
+        };
+        UnknownFunctionReturn unknownFunctionReturn{UnknownFunctionReturn::no};
+
+        long long : 24; // padding
+
+        /** Path id */
+        MathLib::bigint path{};
+
+        /** int value before implicit truncation */
+        MathLib::bigint wideintvalue{};
+
+        std::vector<std::string> subexpressions;
+
+        // Set to where a lifetime is captured by value
+        const Token* capturetok{};
+
+        RET_NONNULL static const char* toString(MoveKind moveKind);
+        RET_NONNULL static const char* toString(LifetimeKind lifetimeKind);
+        RET_NONNULL static const char* toString(LifetimeScope lifetimeScope);
+        RET_NONNULL static const char* toString(Bound bound);
+
+        void setKnown() {
+            valueKind = ValueKind::Known;
+        }
+
+        bool isKnown() const {
+            return valueKind == ValueKind::Known;
+        }
+
+        void setPossible() {
+            valueKind = ValueKind::Possible;
+        }
+
+        bool isPossible() const {
+            return valueKind == ValueKind::Possible;
+        }
+
+        bool isImpossible() const {
+            return valueKind == ValueKind::Impossible;
+        }
+
+        void setImpossible() {
+            valueKind = ValueKind::Impossible;
+        }
+
+        void setInconclusive(bool inconclusive = true) {
+            if (inconclusive)
+                valueKind = ValueKind::Inconclusive;
+        }
+
+        bool isInconclusive() const {
+            return valueKind == ValueKind::Inconclusive;
+        }
+
+        void changeKnownToPossible() {
+            if (isKnown())
+                valueKind = ValueKind::Possible;
+        }
+
+        bool errorSeverity() const {
+            return !condition && !defaultArg;
+        }
+
+        static bool sameToken(const Token* tok1, const Token* tok2);
+
+    private:
+        struct equalVisitor {
+            template<class T, class U>
+            void operator()(bool& result, T x, U y) const {
+                result = !(x > y || x < y);
+            }
+        };
+
+        struct increment {
+            template<class T>
+            void operator()(T& x) const {
+                x++;
+            }
+        };
+        struct decrement {
+            template<class T>
+            void operator()(T& x) const {
+                x--;
+            }
+        };
+    };
+}
+
+FORCE_WARNING_CLANG_POP
+
+#endif // vfvalueH
diff --git a/lib/xml.h b/lib/xml.h
new file mode 100644
index 00000000000..e5591fafbfd
--- /dev/null
+++ b/lib/xml.h
@@ -0,0 +1,51 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef xmlH
+#define xmlH
+
+#include "config.h"
+#include "path.h"
+
+#if defined(__GNUC__) && (__GNUC__ >= 14)
+SUPPRESS_WARNING_GCC_PUSH("-Wsuggest-attribute=returns_nonnull")
+#endif
+SUPPRESS_WARNING_GCC_PUSH("-Wuseless-cast")
+SUPPRESS_WARNING_CLANG_PUSH("-Wzero-as-null-pointer-constant")
+SUPPRESS_WARNING_CLANG_PUSH("-Wsuggest-destructor-override")
+SUPPRESS_WARNING_CLANG_PUSH("-Winconsistent-missing-destructor-override")
+
+#include <tinyxml2.h> // IWYU pragma: export
+
+SUPPRESS_WARNING_CLANG_POP
+SUPPRESS_WARNING_CLANG_POP
+SUPPRESS_WARNING_CLANG_POP
+SUPPRESS_WARNING_GCC_POP
+#if defined(__GNUC__) && (__GNUC__ >= 14)
+SUPPRESS_WARNING_GCC_POP
+#endif
+
+inline static tinyxml2::XMLError xml_LoadFile(tinyxml2::XMLDocument& doc, const char* filename)
+{
+    // tinyxml2 will fail with a misleading XML_ERROR_FILE_READ_ERROR when you try to load a directory as a XML file
+    if (Path::isDirectory(filename))
+        return tinyxml2::XMLError::XML_ERROR_FILE_NOT_FOUND;
+    return doc.LoadFile(filename);
+}
+
+#endif // xmlH
diff --git a/lsan-suppr.txt b/lsan-suppr.txt
new file mode 100644
index 00000000000..bf8389f247e
--- /dev/null
+++ b/lsan-suppr.txt
@@ -0,0 +1 @@
+leak:libpcre.so
\ No newline at end of file
diff --git a/man/CMakeLists.txt b/man/CMakeLists.txt
new file mode 100644
index 00000000000..be9720d23fb
--- /dev/null
+++ b/man/CMakeLists.txt
@@ -0,0 +1,7 @@
+if (BUILD_MANPAGE)
+    find_program(XSLTPROC NAMES xsltproc REQUIRED)
+    set(DB2MAN "/usr/share/sgml/docbook/stylesheet/xsl/nwalsh/manpages/docbook.xsl")
+    set(MAN_SOURCE "${CMAKE_CURRENT_SOURCE_DIR}/cppcheck.1.xml")
+    add_custom_target(man ${XSLTPROC} --nonet --param man.charmap.use.subset "0" ${DB2MAN} ${MAN_SOURCE}
+        DEPENDS ${MAN_SOURCE})
+endif()
\ No newline at end of file
diff --git a/man/build-html.sh b/man/build-html.sh
new file mode 100755
index 00000000000..d9c4aa1c9c3
--- /dev/null
+++ b/man/build-html.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+echo Building $1.html
+pandoc $1.md -o $1.html -s --number-sections --toc --css manual.css
diff --git a/man/build-pdf.sh b/man/build-pdf.sh
new file mode 100755
index 00000000000..648b010645d
--- /dev/null
+++ b/man/build-pdf.sh
@@ -0,0 +1,32 @@
+#!/bin/sh
+# This uses installed fonts, which vary between systems
+# Segoe UI and Consolas are standard in Windows 10, DejaVu is more common on Linux
+echo Building $1.pdf
+
+MainFont="Segoe UI"
+MonoFont="Consolas"
+
+is_font_installed() {
+    fontname=$1
+    fc-list | grep -i "$fontname" >/dev/null
+}
+
+if ! is_font_installed "$MainFont"; then
+    MainFont="DejaVu Sans"
+fi
+if ! is_font_installed "$MonoFont"; then
+    MonoFont="DejaVu Sans Mono"
+fi
+
+# echo Using $MainFont / $MonoFont
+
+pandoc $1.md -o $1.pdf -s --number-sections --toc \
+    --pdf-engine=xelatex \
+    --listings \
+    -f markdown \
+    -V mainfont="$MainFont" \
+    -V monofont="$MonoFont" \
+    -V geometry:a4paper \
+    -V geometry:margin=2.4cm \
+    -V subparagraph \
+    -H manual-style.tex
diff --git a/man/buildman.sh b/man/buildman.sh
index 5a0713a2ea6..cd198071ff5 100755
--- a/man/buildman.sh
+++ b/man/buildman.sh
@@ -1,9 +1,10 @@
 #!/bin/sh
 # To install required tools in debian:
 # sudo apt-get install pandoc texlive-latex-base texlive-fonts-recommended texlive-latex-extra
+# For Windows you can use the MiKTeX installer https://miktex.org/download
 
-pandoc manual.md -o manual.pdf -s --number-sections
-pandoc manual.md -o manual.html -s --number-sections
+./build-pdf.sh manual
+./build-html.sh manual
 
-pandoc reference-cfg-format.md -o reference-cfg-format.pdf -s --number-sections
-pandoc reference-cfg-format.md -o reference-cfg-format.html -s --number-sections
+./build-pdf.sh reference-cfg-format
+./build-html.sh reference-cfg-format
diff --git a/man/checkers/constParameterPointer.md b/man/checkers/constParameterPointer.md
new file mode 100644
index 00000000000..82e649d8844
--- /dev/null
+++ b/man/checkers/constParameterPointer.md
@@ -0,0 +1,85 @@
+# constParameterPointer
+
+**Message**: Parameter 'x' can be declared as pointer to const<br/>
+**Category**: Robustness<br/>
+**Severity**: Style<br/>
+**Language**: C/C++
+
+## Description
+
+This checker identifies function parameters that are pointers which are never used to modify the data they point to. Such parameters can be declared as "pointer to const" to improve code clarity and prevent accidental modifications.
+
+The checker analyzes pointer parameters and detects when:
+- The pointer is dereferenced only for reading values (not writing)
+- The pointer is used in comparisons or logical operations
+- The pointer is passed to functions that expect const pointers
+- The pointer arithmetic is performed without modifying the pointed-to data
+
+This warning helps improve code quality by:
+- Making the intent clear that the function will not modify the pointed-to data
+- Enabling compiler optimizations
+- Preventing accidental modifications
+- Improving const-correctness
+
+## Motivation
+
+This checker improves const-correctness. Const-correct code is more robust and easier to understand.
+
+## How to fix
+
+Add the `const` keyword to the parameter declaration to indicate that the pointed-to data will not be modified.
+
+Before:
+```cpp
+void printValue(int* p) {
+    printf("%d\n", *p);  // Only reading the value
+}
+
+int findMax(int* arr, size_t size) {
+    int max = arr[0];
+    for (size_t i = 1; i < size; i++) {
+        if (arr[i] > max) {  // Only reading array elements
+            max = arr[i];
+        }
+    }
+    return max;
+}
+
+bool isEqual(char* str1, char* str2) {
+    return strcmp(str1, str2) == 0;  // Only reading strings
+}
+```
+
+After:
+```cpp
+void printValue(const int* p) {
+    printf("%d\n", *p);  // Clearly indicates read-only access
+}
+
+int findMax(const int* arr, size_t size) {
+    int max = arr[0];
+    for (size_t i = 1; i < size; i++) {
+        if (arr[i] > max) {
+            max = arr[i];
+        }
+    }
+    return max;
+}
+
+bool isEqual(const char* str1, const char* str2) {
+    return strcmp(str1, str2) == 0;  // Standard library functions expect const char*
+}
+```
+
+## Related checkers
+
+- `constParameter` - for non-pointer parameters that can be const
+- `constParameterReference` - for reference parameters that can be const
+- `constParameterCallback` - for callback function parameters that can be const
+- `constVariablePointer` - for local pointer variables that can be const
+
+## Notes
+
+- This check is disabled for virtual functions and callback functions where changing the signature might break polymorphism or function pointer compatibility
+- The checker may suggest callback-specific warnings when a function is used as a callback, indicating that const-ification might require casting function pointers
+- Template functions are handled carefully to avoid false positives in generic code
\ No newline at end of file
diff --git a/man/checkers/cstyleCast.md b/man/checkers/cstyleCast.md
new file mode 100644
index 00000000000..52da49adad2
--- /dev/null
+++ b/man/checkers/cstyleCast.md
@@ -0,0 +1,54 @@
+
+# cstyleCast
+
+**Message**: C-style pointer casting<br/>
+**Category**: Modernization<br/>
+**Severity**: Style<br/>
+**Language**: C++, not applicable for C code
+
+## Description
+
+Many developers feel that it's best to replace C casts with C++ casts.
+
+There are several advantages with C++ casts:
+ * they permit only certain conversions
+ * they express the intent
+ * they are easy to identify
+
+This checker is about C casts that converts to/from a pointer or reference.
+
+**Note:** More "noisy" warnings exists that warn about all C casts. For instance Clang has
+`-Wold-style-cast` and there is also such checking in Misra C++.
+
+Dangerous conversions are covered by other warnings so this ID `cstyleCast` is primarily about
+writing warnings for casts that are currently safe.
+
+# Motivation
+
+The motivation of this checker is to modernize c++ code.
+
+## How to fix
+
+You can use C++ casts such as `static_cast` to fix these warnings.
+
+The `dynamic_cast` should rarelly be used to fix these warnings because dangerousTypeCast is
+reported when that can be a good idea.
+
+Before:
+```cpp
+struct Base{};
+struct Derived: public Base {};
+void foo(Base* base) {
+    Base *p = (Base*)derived; // <- cstyleCast, cast from derived object to base object is safe now
+}
+```
+
+After:
+```cpp
+struct Base{};
+struct Derived: public Base {};
+void foo(Base* base) {
+    Derived *p = static_cast<Derived*>(base);
+}
+```
+The `static_cast` ensures that there will not be loss of constness in the future.
diff --git a/man/checkers/dangerousTypeCast.md b/man/checkers/dangerousTypeCast.md
new file mode 100644
index 00000000000..79538103db5
--- /dev/null
+++ b/man/checkers/dangerousTypeCast.md
@@ -0,0 +1,43 @@
+
+# dangerousTypeCast
+
+**Message**: Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast<br/>
+**Category**: Type Safety<br/>
+**Severity**: Warning<br/>
+**Language**: C++, not applicable for C code
+
+## Motivation
+
+C style casts can be dangerous in many ways:
+ * loss of precision
+ * loss of sign
+ * loss of constness
+ * invalid type conversion
+
+## Philosophy
+
+This checker warns about old style C casts that perform type conversions that can be invalid.
+
+This checker is not about readability. It is about safety.
+
+## How to fix
+
+You can use `dynamic_cast` or `static_cast` to fix these warnings.
+
+Before:
+```cpp
+struct Base{};
+struct Derived: public Base {};
+void foo(Base* base) {
+    Derived *p = (Derived*)base; // <- can be invalid
+}
+```
+
+After:
+```cpp
+struct Base{};
+struct Derived: public Base {};
+void foo(Base* base) {
+    Derived *p = dynamic_cast<Derived*>(base);
+}
+```
diff --git a/man/checkers/duplicateExpressionTernary.md b/man/checkers/duplicateExpressionTernary.md
new file mode 100644
index 00000000000..706ad85e2ac
--- /dev/null
+++ b/man/checkers/duplicateExpressionTernary.md
@@ -0,0 +1,65 @@
+# duplicateExpressionTernary
+
+**Message**: Same expression in both branches of ternary operator<br/>
+**Category**: Logic<br/>
+**Severity**: Style<br/>
+**Language**: C/C++
+
+## Description
+
+This checker detects when syntactically identical expressions appear in both the true and false branches of a ternary operator (`condition ? true_expr : false_expr`).
+
+The warning is triggered when:
+- The second and third operands of a ternary operator are syntactically identical expressions
+- This includes cases where variables are referenced through aliases that resolve to the same expression
+
+## Motivation
+
+The same expression indicates that there might be some logic error or copy-paste mistake.
+
+## Examples
+
+### Problematic code
+
+```cpp
+// Same expression in both branches
+int result = condition ? x : x;  // Warning: duplicateExpressionTernary
+
+// Same variable referenced through alias
+const int c = a;
+int result = condition ? a : c;  // Warning: duplicateExpressionTernary
+```
+
+### Fixed code
+
+```cpp
+// Different expressions in branches
+int result = condition ? x : y;  // OK
+```
+
+## How to fix
+
+1. **Check for copy-paste errors**: Verify that both branches are supposed to have the same expression
+2. **Use different expressions**: If the branches should differ, update one of them
+3. **Simplify the code**: If both branches are intentionally the same, remove the ternary operator entirely
+
+Before:
+```cpp
+int getValue(bool flag) {
+    return flag ? computeValue() : computeValue();  // Same computation in both branches
+}
+```
+
+After:
+```cpp
+int getValue(bool flag) {
+    return computeValue();  // Simplified - condition doesn't matter
+}
+```
+
+Or if the branches should differ:
+```cpp
+int getValue(bool flag) {
+    return flag ? computeValue() : computeAlternativeValue();  // Different computations
+}
+```
diff --git a/man/checkers/duplicateValueTernary.md b/man/checkers/duplicateValueTernary.md
new file mode 100644
index 00000000000..06e9f8e9be7
--- /dev/null
+++ b/man/checkers/duplicateValueTernary.md
@@ -0,0 +1,77 @@
+# duplicateValueTernary
+
+**Message**: Same value in both branches of ternary operator<br/>
+**Category**: Logic<br/>
+**Severity**: Style<br/>
+**Language**: C/C++
+
+## Description
+
+This checker detects when both branches of a ternary operator (`condition ? true_expr : false_expr`) evaluate to the same value, even though the expressions themselves may be syntactically different.
+
+The warning is triggered when:
+- The second and third operands of a ternary operator evaluate to the same constant value
+- The expressions are constant statements that don't change during evaluation
+- The expressions have different syntax but equivalent values
+
+However, no warning is generated when:
+- The expressions have different values on different platforms
+- Variables are modified between evaluations
+- The expressions involve non-constant computations
+
+## Motivation
+
+The same value indicates that there might be some logic error or copy-paste mistake.
+
+## Examples
+
+### Problematic code
+
+```cpp
+// Different expressions, same value
+int result = condition ? (int)1 : 1;  // Warning: duplicateValueTernary
+
+// Different cast syntax, same value
+int result = condition ? 1 : (int)1;  // Warning: duplicateValueTernary
+```
+
+### Fixed code
+
+```cpp
+// Different values in branches
+int result = condition ? 1 : 2;  // OK
+
+// Simplified - condition doesn't matter
+int result = 1;  // OK - removed unnecessary ternary
+
+// Platform-dependent values are allowed
+int size = is_64bit ? sizeof(long) : sizeof(int);  // OK - may differ on platforms
+```
+
+## How to fix
+
+1. **Check for logic errors**: Verify if both branches should actually have the same value
+2. **Simplify the code**: If both branches always have the same value, remove the ternary operator
+3. **Use different values**: If the branches should differ, update one of them
+4. **Remove unnecessary casts**: If the difference is only in casting, consider if the cast is needed
+
+Before:
+```cpp
+int getValue(bool flag) {
+    return flag ? (int)42 : 42;  // Same value, different expressions
+}
+```
+
+After (simplified):
+```cpp
+int getValue(bool flag) {
+    return 42;  // Simplified - condition doesn't affect result
+}
+```
+
+Or (if branches should differ):
+```cpp
+int getValue(bool flag) {
+    return flag ? 42 : 0;  // Different values for different conditions
+}
+```
diff --git a/man/checkers/functionConst.md b/man/checkers/functionConst.md
new file mode 100644
index 00000000000..acbc0e1dfd4
--- /dev/null
+++ b/man/checkers/functionConst.md
@@ -0,0 +1,101 @@
+# functionConst
+
+**Message**: Technically the member function 'x' can be const<br/>
+**Category**: Robustness<br/>
+**Severity**: Style (Inconclusive)<br/>
+**Language**: C++
+
+## Description
+
+This checker identifies member functions that do not modify any member variables and therefore could be declared as `const`. A const member function promises not to modify the object's state and enables the function to be called on const objects.
+
+The danger is that a const member function is allowed to have side effects outside the object. If you create a member function that formats the hard drive using
+system calls it might be technically possible to make the function const, but is it "correct"? Using a const object is not supposed to have side effects.
+
+For methods that has no side effects whatsoever; making them const is recommended.
+
+The checker analyzes member functions and detects when:
+- The function only reads member variables (never writes to them)
+- The function only calls other const member functions
+- The function only modifies parameters passed by reference or pointer (not member variables)
+- The function performs operations that don't change the object's logical state
+
+This warning is marked as **inconclusive** because while the function can technically be made const, it may not always be "correct".
+
+This warning helps improve code quality by:
+- Making the function's non-modifying nature explicit
+- Enabling the function to be called on const objects
+- Improving const-correctness throughout the codebase
+- Helping with compiler optimizations
+- Making code intentions clearer to other developers
+
+## Motivation
+
+The motivation of this checker is to improve robustness by making the code more const-correct.
+
+## How to fix
+
+Add the `const` keyword after the function signature to indicate that the function does not modify the object's state.
+
+Before:
+```cpp
+class Rectangle {
+    int width, height;
+public:
+    int getWidth() { return width; }
+    int getHeight() { return height; }
+    int getArea() { return width * height; }
+
+    void printInfo() {
+        std::cout << "Width: " << width << ", Height: " << height << std::endl;
+    }
+
+    bool isSquare() {
+        return width == height;
+    }
+
+    void copyDataTo(Rectangle& other) {
+        other.width = width;
+        other.height = height;
+    }
+};
+```
+
+After:
+```cpp
+class Rectangle {
+    int width, height;
+public:
+    int getWidth() const { return width; }
+    int getHeight() const { return height; }
+    int getArea() const { return width * height; }
+
+    void printInfo() const {
+        std::cout << "Width: " << width << ", Height: " << height << std::endl;
+    }
+
+    bool isSquare() const {
+        return width == height;
+    }
+
+    void copyDataTo(Rectangle& other) const {
+        other.width = width;
+        other.height = height;
+    }
+};
+```
+
+## Related checkers
+
+- `functionStatic` - for member functions that can be declared static
+- `constParameter` - for function parameters that can be const
+- `constParameterReference` - for reference parameters that can be const
+- `constParameterPointer` - for pointer parameters that can be const
+- `constVariable` - for local variables that can be const
+- `constVariableReference` - for local reference variables that can be const
+
+## Notes
+
+- This check is marked as **inconclusive** because the decision to make a function const should also consider the conceptual design
+- Virtual functions should be carefully considered before making them const, as this affects the entire inheritance hierarchy
+- Think about whether the function's purpose is to query state (should be const) or to perform an action (may not need to be const)
diff --git a/man/checkers/functionStatic.md b/man/checkers/functionStatic.md
new file mode 100644
index 00000000000..896dd2c936e
--- /dev/null
+++ b/man/checkers/functionStatic.md
@@ -0,0 +1,64 @@
+# functionStatic
+
+**Message**: The member function 'x' can be static<br/>
+**Category**: Readability<br/>
+**Severity**: Style<br/>
+**Language**: C++
+
+## Description
+
+This checker identifies member functions that do not access any non-static member variables or call any non-static member functions. Such functions can be declared as `static` to indicate that they don't require an object instance to operate.
+
+This warning helps improve code quality by:
+- Making the function's independence from object state explicit
+- Enabling the function to be called without creating an object instance
+- Clarifying the function's scope and dependencies
+
+## Motivation
+
+The motivation of this checker is to improve readability.
+
+## How to fix
+
+Add the `static` keyword to the function declaration to indicate that it doesn't require an object instance.
+
+Before:
+```cpp
+class Calculator {
+public:
+    int add(int a, int b) {
+        return a + b;  // Only uses parameters
+    }
+
+    void printMessage() {
+        std::cout << "Hello World" << std::endl;  // Uses no instance data
+    }
+
+    bool isValidNumber(int num) {
+        return num > 0 && num < 1000;  // Pure function
+    }
+};
+```
+
+After:
+```cpp
+class Calculator {
+public:
+    static int add(int a, int b) {
+        return a + b;  // Can be called as Calculator::add(5, 3)
+    }
+
+    static void printMessage() {
+        std::cout << "Hello World" << std::endl;  // Can be called without instance
+    }
+
+    static bool isValidNumber(int num) {
+        return num > 0 && num < 1000;  // Clearly indicates no state dependency
+    }
+};
+```
+
+## Related checkers
+
+- `functionConst` - for member functions that can be declared const
+
diff --git a/man/checkers/premium-misra-config.md b/man/checkers/premium-misra-config.md
new file mode 100644
index 00000000000..367e45a2b44
--- /dev/null
+++ b/man/checkers/premium-misra-config.md
@@ -0,0 +1,50 @@
+# premium-misra-config
+
+**Message**: Unknown constant x, please review cppcheck options<br/>
+**Category**: Configuration<br/>
+**Severity**: Information<br/>
+**Language**: C and C++
+
+## Description
+
+The `premium-misra-config` message indicates that MISRA checking cannot be performed properly due to missing type information or incomplete code analysis. This typically occurs when the Cppcheck configuration is insufficient for proper code understanding.
+
+These warnings from Cppcheck do not indicate a bug in your code. These warnings indicate that the Cppcheck configuration is not working properly for MISRA analysis.
+
+When MISRA checking requires complete type information to analyze code compliance, missing includes, defines, or other configuration issues can prevent the checker from understanding the code structure needed for accurate MISRA rule evaluation.
+
+## How to fix
+
+The warning is typically reported when MISRA checking encounters code that cannot be properly analyzed due to configuration issues:
+
+```cpp
+// Missing type information may prevent MISRA analysis
+typedef some_unknown_type my_type_t;  // If some_unknown_type is not defined
+my_type_t variable;                   // MISRA rules cannot be properly checked
+```
+
+Identify which identifier name the warning is about. The warning message will complain about a specific name.
+
+Determine where Cppcheck should find the declaration/definition of that identifier name.
+
+### Missing includes
+
+Check if the necessary header(s) are included. You can add `--enable=missingInclude` to get warnings about missing includes.
+```bash
+cppcheck --enable=missingInclude file.c
+```
+
+Ensure all include directories are specified:
+
+```bash
+cppcheck -I/path/to/includes file.c
+```
+
+### Preprocessor defines
+
+If the code depends on preprocessor macros that are not defined:
+
+```bash
+cppcheck -DMISSING_MACRO=value file.c
+```
+
diff --git a/man/checkers/preprocessorErrorDirective.md b/man/checkers/preprocessorErrorDirective.md
new file mode 100644
index 00000000000..44fcb4c1a28
--- /dev/null
+++ b/man/checkers/preprocessorErrorDirective.md
@@ -0,0 +1,55 @@
+
+# preprocessorErrorDirective
+
+**Message**: #error message<br/>
+**Category**: Configuration<br/>
+**Severity**: Error<br/>
+**Language**: C and C++
+
+## Description
+
+The `#error` directive is a preprocessor instruction in C and C++ that explicitly generates a compilation error. It is typically used as a safeguard to prevent compilation under incorrect conditions—like unsupported configurations, platforms, or missing defines.
+
+These warnings from Cppcheck do not indicate a bug in your code. These warnings indicate that the Cppcheck configuration is not working.
+
+## How to fix
+
+The warning is typically reported for an `#error` directive that is located inside some conditional preprocessor block (`#if..`, `#else`, etc):
+```cpp
+#ifndef __BYTE_ORDER__
+#error Byte order is not defined
+#endif
+```
+
+The code here is correct and you should not try to change it.
+
+Somehow it will be necessary to define `__BYTE_ORDER__` in Cppcheck analysis.
+
+### gcc compiler macro
+If you compile your code with gcc and the macro is provided by gcc, then you can define all gcc-macros using these commands:
+```
+echo x > dummy.c
+gcc -dM -E dummy.c > gcc-macros.h
+```
+The gcc-macros.h that is generated can be included in cppcheck using the `--include` option:
+```
+cppcheck --include=gcc-macros.h  ....
+```
+
+### library macro
+If the macro that is needed is defined in some library header it might be possible to fix the issue by using an extra `--library` option:
+```
+cppcheck --library=foo .....
+```
+
+### manually defined macro
+To define extra macros manually you can use `-D`:
+```
+cppcheck -D__BYTE_ORDER__=123 .....
+```
+
+### use --force or --max-configs
+You can let Cppcheck try to resolve the required defines:
+```
+cppcheck --force .....
+```
diff --git a/man/checkers/truncLongCast.md b/man/checkers/truncLongCast.md
new file mode 100644
index 00000000000..7157a5b6627
--- /dev/null
+++ b/man/checkers/truncLongCast.md
@@ -0,0 +1,50 @@
+# truncLongCastAssignment and truncLongCastReturn
+
+**Message**: int result is assigned to long variable. If the variable is long to avoid loss of information, then you have loss of information.<br/>
+**Category**: Type Safety<br/>
+**Severity**: Style<br/>
+**Language**: C/C++
+
+## Description
+
+This checker warns when a calculation has type 'int' and it could potentially overflow that and the result is implicitly or explicitly converted to a larger
+integer type after the loss of information has already occured.
+
+## Motivation
+
+The motivation of this checker is to catch bugs. Unintentional loss of information.
+
+## How to fix
+
+You can fix these warnings by:
+1. Add explicit cast to avoid loss of information
+2. Explicitly truncate the result
+3. Change type of assigned variable
+
+Before:
+```cpp
+void foo(int32_t y) {
+    int64_t x = y * y; // <- warning
+}
+```
+
+After (explicit cast):
+```cpp
+void foo(int32_t y) {
+    int64_t x = (int64_t)y * y; // <- 64-bit multiplication
+}
+```
+
+After (explicitly truncate the result):
+```cpp
+void foo(int32_t y) {
+    int64_t x = (int32_t)(y * y); // redundant cast makes it explicit that your intention is to truncate the result to 32-bit
+}
+```
+
+After (change type of assigned variable):
+```cpp
+void foo(int32_t y) {
+    int32_t x = y * y;
+}
+```
\ No newline at end of file
diff --git a/man/checkers/unknownMacro.md b/man/checkers/unknownMacro.md
new file mode 100644
index 00000000000..52599215d89
--- /dev/null
+++ b/man/checkers/unknownMacro.md
@@ -0,0 +1,68 @@
+
+# unknownMacro
+
+**Message**: There is an unknown macro here somewhere. Configuration is required. If AAA is a macro then please configure it. [unknownMacro]
+<br/>
+**Category**: Configuration<br/>
+**Severity**: Error<br/>
+**Language**: C and C++
+
+## Description
+
+Cppcheck has found code that is confusing and does not know how to analyze it. This is a critical
+error, the analysis of the whole translation unit is aborted. Such error in a header file can mean
+that analysis of many source files are aborted.
+
+Your code is probably OK but you need to configure Cppcheck to make Cppcheck understand the code
+better.
+
+## How to fix
+
+Review the configuration.
+
+If Cppcheck warns about a macro that is defined in a 3rd party library, and there is a cfg file for
+that, then a `--library=` option may be a proper solution.
+
+If Cppcheck warns about a macro that is defined in a header that should be included, make sure that
+this header is included properly. Cppcheck must have the include path.
+
+If Cppcheck warns about a compiler keyword add a `-D` that defines this keyword somehow. I.e. if
+cppcheck should just ignore the keyword then an `-DKEYWORD=` option is suggested.
+
+## Example
+
+### Example code 1
+```
+    fprintf(stderr, "Generating up to " F_U64 " sequences and up to " F_U64 " bases.\n", nSeqs, nBases);
+```
+
+Warning:
+
+canu-2.2/src/seqrequester/src/seqrequester/generate.H:72:41: error: There is an unknown macro here somewhere. Configuration is required. If F_U64 is a macro then please configure it. [unknownMacro]
+
+Fix:
+
+Somehow `F_U64` must be specified for Cppcheck to be able to analyse this properly. Either:
+ * Add `-DF_U64="x"` to explicitly tell Cppcheck what it should replace F_U64 with. Or;
+ * Add `-I..` so that headers are included properly.
+ * If the symbol is defined in a 3rd party library adding a corresponding `--library=` might solve such issue.
+
+### Example code 2
+```
+BOTAN_FUNC_ISA("crypto")
+void AES_128::hw_aes_encrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const
+```
+
+Warning:
+
+botan-2.19.5+dfsg/src/lib/block/aes/aes_power8/aes_power8.cpp:103:1: error: There is an unknown macro here somewhere. Configuration is required. If BOTAN_FUNC_ISA is a macro then please configure it. [unknownMacro]
+
+Fix:
+
+Somehow `BOTAN_FUNC_ISA` must be specified for Cppcheck to be able to analyse this properly. Either:
+ * Add `-DBOTAN_FUNC_ISA(X)=` to explicitly tell Cppcheck that BOTAN_FUNC_ISA("crypto") should be ignored. Or;
+ * Add `-I..` so that headers are included properly.
+ * If the symbol is defined in a 3rd party library adding a corresponding `--library=` might solve such issue.
+
+
+
diff --git a/man/cppcheck.1.xml b/man/cppcheck.1.xml
index 497ad3d1c15..db3a5a9baa6 100644
--- a/man/cppcheck.1.xml
+++ b/man/cppcheck.1.xml
@@ -105,6 +105,9 @@ man(1), man(7), http://www.tldp.org/HOWTO/Man-Page/
       <arg choice="opt">
         <option>-U&lt;id&gt;</option>
       </arg>
+      <arg choice="opt">
+        <option>--disable=&lt;id&gt;</option>
+      </arg>
       <arg choice="opt">
         <option>--enable=&lt;id&gt;</option>
       </arg>
@@ -120,9 +123,18 @@ man(1), man(7), http://www.tldp.org/HOWTO/Man-Page/
       <arg choice="opt">
         <option>--file-list=&lt;file&gt;</option>
       </arg>
+      <arg choice="opt">
+        <option>--filesdir</option>
+      </arg>
       <arg choice="opt">
         <option>--force</option>
       </arg>
+      <arg choice="opt">
+        <option>--fsigned-char</option>
+      </arg>
+      <arg choice="opt">
+        <option>--funsigned-char</option>
+      </arg>
       <arg choice="opt">
         <option>--help</option>
       </arg>
@@ -180,12 +192,18 @@ man(1), man(7), http://www.tldp.org/HOWTO/Man-Page/
       <arg choice="opt">
         <option>--report-progress</option>
       </arg>
+      <arg choice="opt">
+        <option>--report-type=&lt;type&gt;</option>
+      </arg>
       <arg choice="opt">
         <option>--rule=&lt;rule&gt;</option>
       </arg>
       <arg choice="opt">
         <option>--rule-file=&lt;file&gt;</option>
       </arg>
+      <arg choice="opt">
+        <option>--showtime=&lt;mode&gt;</option>
+      </arg>
       <arg choice="opt">
         <option>--std=&lt;id&gt;</option>
       </arg>
@@ -272,18 +290,36 @@ Example: -DDEBUG=1 -D__cplusplus</para>
 Example: '-UDEBUG'</para>
         </listitem>
       </varlistentry>
+      <varlistentry>
+        <term>
+          <option>--disable=&lt;id&gt;</option>
+        </term>
+        <listitem>
+          <para>Disable individual checks. Please refer to the documentation of --enable=&lt;id&gt; for further details.
+          </para>
+        </listitem>
+      </varlistentry>
       <varlistentry>
         <term>
           <option>--enable=&lt;id&gt;</option>
         </term>
         <listitem>
           <para>Enable additional checks. The available ids are:
-            <glosslist><glossentry><glossterm>all</glossterm><glossdef><para>Enable all checks. It is recommended to only use
+            <glosslist>
+              <glossentry><glossterm>all</glossterm><glossdef><para>Enable all checks. It is recommended to only use
                   --enable=all when the whole program is scanned, because this
-                  enables unusedFunction.</para></glossdef></glossentry><glossentry><glossterm>warning</glossterm><glossdef><para>Enable warning messages</para></glossdef></glossentry><glossentry><glossterm>style</glossterm><glossdef><para>Enable all coding style checks. All messages with the
+                  enables unusedFunction.</para></glossdef></glossentry>
+              <glossentry><glossterm>warning</glossterm><glossdef><para>Enable warning messages</para></glossdef></glossentry>
+              <glossentry><glossterm>style</glossterm><glossdef><para>Enable all coding style checks. All messages with the
                   severities 'style', 'performance' and 'portability' are
-                  enabled.</para></glossdef></glossentry><glossentry><glossterm>performance</glossterm><glossdef><para>Enable performance messages</para></glossdef></glossentry><glossentry><glossterm>portability</glossterm><glossdef><para>Enable portability messages</para></glossdef></glossentry><glossentry><glossterm>information</glossterm><glossdef><para>Enable information messages</para></glossdef></glossentry><glossentry><glossterm>unusedFunction</glossterm><glossdef><para>Check for unused functions. It is recommend to only
-                  enable this when the whole program is scanned</para></glossdef></glossentry><glossentry><glossterm>missingInclude</glossterm><glossdef><para>Warn if there are missing includes. For detailed information use --check-config</para></glossdef></glossentry></glosslist>
+                  enabled.</para></glossdef></glossentry>
+              <glossentry><glossterm>performance</glossterm><glossdef><para>Enable performance messages</para></glossdef></glossentry>
+              <glossentry><glossterm>portability</glossterm><glossdef><para>Enable portability messages</para></glossdef></glossentry>
+              <glossentry><glossterm>information</glossterm><glossdef><para>Enable information messages</para></glossdef></glossentry>
+              <glossentry><glossterm>unusedFunction</glossterm><glossdef><para>Check for unused functions. It is recommend to only
+                  enable this when the whole program is scanned</para></glossdef></glossentry>
+              <glossentry><glossterm>missingInclude</glossterm><glossdef><para>Warn if there are missing includes</para></glossdef></glossentry>
+            </glosslist>
             By default none of the additional checks are enabled. Several ids can be given if you separate them with commas, e.g. --enable=style,unusedFunction. See also --std
           </para>
         </listitem>
@@ -323,6 +359,14 @@ Example: '-UDEBUG'</para>
           <para>Specify the files to check in a text file. One filename per line. When file is -, the file list will be read from standard input.</para>
         </listitem>
       </varlistentry>
+      <varlistentry>
+        <term>
+          <option>--filesdir</option>
+        </term>
+        <listitem>
+          <para>Print the built-in FILESDIR.</para>
+        </listitem>
+      </varlistentry>
       <varlistentry>
         <term>
           <option>-f</option>
@@ -335,6 +379,22 @@ Example: '-UDEBUG'</para>
 default. If used together with --max-configs=, the last option is the one that is effective.</para>
         </listitem>
       </varlistentry>
+      <varlistentry>
+        <term>
+            <option>--fsigned-char</option>
+        </term>
+        <listitem>
+            <para>Treat char type as signed. This overrides previous --platform options and is overridden by following ones.</para>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>
+          <option>--funsigned-char</option>
+        </term>
+        <listitem>
+          <para>Treat char type as unsigned. This overrides previous --platform options and is overridden by following ones.</para>
+        </listitem>
+      </varlistentry>
       <varlistentry>
         <term>
           <option>-h</option>
@@ -462,7 +522,7 @@ There are false positives with this option. Each result must be carefully invest
       </varlistentry>
       <varlistentry>
         <term>
-          <option>--max-ctu-depths=&lt;limit&gt;</option>
+          <option>--max-ctu-depth=&lt;limit&gt;</option>
         </term>
         <listitem>
           <para>Maximum depth in whole program analysis. Default is 2.</para>
@@ -474,7 +534,13 @@ There are false positives with this option. Each result must be carefully invest
         </term>
         <listitem>
           <para>Specifies platform specific types and sizes.The available platforms are:
-            <glosslist><glossentry><glossterm>unix32</glossterm><glossdef><para>32 bit unix variant</para></glossdef></glossentry><glossentry><glossterm>unix64</glossterm><glossdef><para>64 bit unix variant</para></glossdef></glossentry><glossentry><glossterm>win32A</glossterm><glossdef><para>32 bit Windows ASCII character encoding</para></glossdef></glossentry><glossentry><glossterm>win32W</glossterm><glossdef><para>32 bit Windows UNICODE character encoding</para></glossdef></glossentry><glossentry><glossterm>win64</glossterm><glossdef><para>64 bit Windows</para></glossdef></glossentry></glosslist>
+            <glosslist>
+              <glossentry><glossterm>unix32</glossterm><glossdef><para>32 bit unix variant</para></glossdef></glossentry>
+              <glossentry><glossterm>unix64</glossterm><glossdef><para>64 bit unix variant</para></glossdef></glossentry>
+              <glossentry><glossterm>win32A</glossterm><glossdef><para>32 bit Windows ASCII character encoding</para></glossdef></glossentry>
+              <glossentry><glossterm>win32W</glossterm><glossdef><para>32 bit Windows UNICODE character encoding</para></glossdef></glossentry>
+              <glossentry><glossterm>win64</glossterm><glossdef><para>64 bit Windows</para></glossdef></glossentry>
+            </glosslist>
             By default the platform which was used to compile Cppcheck is used.
           </para>
         </listitem>
@@ -515,6 +581,26 @@ There are false positives with this option. Each result must be carefully invest
           <para>Report progress when checking a file.</para>
         </listitem>
       </varlistentry>
+      <varlistentry>
+        <term>
+          <option>--report-type=&lt;type&gt;</option>
+        </term>
+        <listitem>
+          <para>Add guideline and classification fields for specified coding standard. The available report types are:
+            <glosslist>
+              <glossentry><glossterm>normal</glossterm><glossdef><para>Default, only show cppcheck error ID and severity)</para></glossdef></glossentry>
+              <glossentry><glossterm>autosar</glossterm><glossdef><para>Autosar</para></glossdef></glossentry>
+              <glossentry><glossterm>cert-c-2016</glossterm><glossdef><para>Cert C 2016</para></glossdef></glossentry>
+              <glossentry><glossterm>cert-cpp-2016</glossterm><glossdef><para>Cert C++ 2016</para></glossdef></glossentry>
+              <glossentry><glossterm>misra-c-2012</glossterm><glossdef><para>Misra C 2012</para></glossdef></glossentry>
+              <glossentry><glossterm>misra-c-2023</glossterm><glossdef><para>Misra C 2023</para></glossdef></glossentry>
+              <glossentry><glossterm>misra-c-2025</glossterm><glossdef><para>Misra C 2025</para></glossdef></glossentry>
+              <glossentry><glossterm>misra-cpp-2008</glossterm><glossdef><para>Misra C++ 2008</para></glossdef></glossentry>
+              <glossentry><glossterm>misra-cpp-2023</glossterm><glossdef><para>Misra C++ 2023</para></glossdef></glossentry>
+            </glosslist>
+          </para>
+        </listitem>
+      </varlistentry>
       <varlistentry>
         <term>
           <option>--rule=&lt;rule&gt;</option>
@@ -531,14 +617,39 @@ There are false positives with this option. Each result must be carefully invest
           <para>Use given rule XML file. See https://sourceforge.net/projects/cppcheck/files/Articles/ for more info about the syntax. This command is only available if cppcheck was compiled with HAVE_RULES=yes.</para>
         </listitem>
       </varlistentry>
+      <varlistentry>
+        <term>
+          <option>--showtime=&lt;mode&gt;</option>
+        </term>
+        <listitem>
+          <para>Show timing information. The available mode are:
+            <glosslist>
+              <glossentry><glossterm>none</glossterm><glossdef><para>Show nothing (default)</para></glossdef></glossentry>
+              <glossentry><glossterm>file</glossterm><glossdef><para>Show for each processed file</para></glossdef></glossentry>
+              <glossentry><glossterm>file-total</glossterm><glossdef><para>Show total time only for each processed file</para></glossdef></glossentry>
+              <glossentry><glossterm>summary</glossterm><glossdef><para>Show a summary at the end</para></glossdef></glossentry>
+              <glossentry><glossterm>top5_file</glossterm><glossdef><para>Show the top 5 for each processed file</para></glossdef></glossentry>
+              <glossentry><glossterm>top5_summary</glossterm><glossdef><para>Show the top 5 summary at the end</para></glossdef></glossentry>
+            </glosslist>
+          </para>
+        </listitem>
+      </varlistentry>
       <varlistentry>
         <term>
           <option>--std=&lt;id&gt;</option>
         </term>
         <listitem>
           <para>Set standard. The available options are:
-            <glosslist><glossentry><glossterm>posix</glossterm><glossdef><para>POSIX compatible code</para></glossdef></glossentry><glossentry><glossterm>c89</glossterm><glossdef><para>C code is C89 compatible</para></glossdef></glossentry><glossentry><glossterm>c99</glossterm><glossdef><para>C code is C99 compatible</para></glossdef></glossentry><glossentry><glossterm>c11</glossterm><glossdef><para>C code is C11 compatible (default)</para></glossdef></glossentry><glossentry><glossterm>c++03</glossterm><glossdef><para>C++ code is C++03 compatible</para></glossdef></glossentry><glossentry><glossterm>c++11</glossterm><glossdef><para>C++ code is C++11 compatible (default)</para></glossdef></glossentry></glosslist>
-            Example to set more than one standards: 'cppcheck --std=c99 --std=posix file.cpp'
+            <glosslist>
+              <glossentry><glossterm>c89</glossterm><glossdef><para>C code is C89 compatible</para></glossdef></glossentry>
+              <glossentry><glossterm>c99</glossterm><glossdef><para>C code is C99 compatible</para></glossdef></glossentry>
+              <glossentry><glossterm>c11</glossterm><glossdef><para>C code is C11 compatible (default)</para></glossdef></glossentry>
+              <glossentry><glossterm>c++03</glossterm><glossdef><para>C++ code is C++03 compatible</para></glossdef></glossentry>
+              <glossentry><glossterm>c++11</glossterm><glossdef><para>C++ code is C++11 compatible</para></glossdef></glossentry>
+              <glossentry><glossterm>c++14</glossterm><glossdef><para>C++ code is C++14 compatible</para></glossdef></glossentry>
+              <glossentry><glossterm>c++17</glossterm><glossdef><para>C++ code is C++17 compatible</para></glossdef></glossentry>
+              <glossentry><glossterm>c++20</glossterm><glossdef><para>C++ code is C++20 compatible (default)</para></glossdef></glossentry>
+            </glosslist>
           </para>
         </listitem>
       </varlistentry>
@@ -610,7 +721,7 @@ There are false positives with this option. Each result must be carefully invest
           <option>--xml-version=&lt;version&gt;</option>
         </term>
         <listitem>
-          <para>Select the XML file version. Currently versions 1 and 2 are available. The default version is 1.</para>
+          <para>Select the XML file version. Also implies --xml. Currently only version 2 is available. The default version is 2.</para>
         </listitem>
       </varlistentry>
     </variablelist>
diff --git a/man/manual-ja.docbook b/man/manual-ja.docbook
index 2fa180636f0..1c13d3d0526 100644
--- a/man/manual-ja.docbook
+++ b/man/manual-ja.docbook
@@ -1360,9 +1360,9 @@ Checking minsize.c...
         <programlisting># cppcheck noreturn.c
 Checking noreturn.c...</programlisting>
 
-        <para>しかし、<literal>--check-library</literal> と<literal>--enable=information</literal>をつかうとエラーが出力されます。:</para>
+        <para>しかし、<literal>--check-library</literal> をつかうとエラーが出力されます。:</para>
 
-        <programlisting># cppcheck --check-library --enable=information noreturn.c
+        <programlisting># cppcheck --check-library noreturn.c
 Checking noreturn.c...
 [noreturn.c:7]: (information) --check-library: Function ZeroMemory() should have &lt;noreturn&gt; configuration
 </programlisting>
diff --git a/man/manual-premium.md b/man/manual-premium.md
new file mode 100644
index 00000000000..9f2e5992537
--- /dev/null
+++ b/man/manual-premium.md
@@ -0,0 +1,1421 @@
+---
+title: Cppcheck Premium manual
+author: Cppcheck team, Cppcheck Solutions AB
+lang: en
+documentclass: report
+---
+
+# Introduction
+
+Cppcheck is an analysis tool for C/C++ code. It provides unique code analysis to detect bugs and focuses on detecting 
+undefined behaviour and dangerous coding constructs. The goal is to detect only real errors in the code, and generate 
+as few false positives (wrongly reported warnings) as possible. Cppcheck is designed to analyze your C/C++ code even
+if it has non-standard syntax, as is common in for example embedded projects.
+
+Supported code and platforms:
+
+- Cppcheck checks non-standard code that contains various compiler extensions, inline assembly code, etc.
+- Cppcheck should be compilable by any compiler that supports C++11 or later.
+- Cppcheck is cross platform and is used in various posix/windows/etc environments.
+
+The checks in Cppcheck are not perfect. There are bugs that should be found, that Cppcheck fails to detect.
+
+## About static analysis
+
+The kinds of bugs that you can find with static analysis are:
+
+- Undefined behavior
+- Using dangerous code patterns
+- Coding style
+
+There are many bugs that you can not find with static analysis. Static analysis tools do not have human knowledge about
+what your program is intended to do. If the output from your program is valid but unexpected then in most cases this is
+not detected by static analysis tools. For instance, if your small program writes "Helo" on the screen instead of "Hello"
+it is unlikely that any tool will complain about that.
+
+Static analysis should be used as a complement in your quality assurance. It does not replace any of;
+
+- Careful design
+- Testing
+- Dynamic analysis
+- Fuzzing
+
+# Getting started
+
+## GUI
+
+It is not required but creating a new project file is a good first step. There are a few options you can tweak to get
+good results.
+
+In the project settings dialog, the first option you see is "Import project". It is recommended that you use this
+feature if you can. Cppcheck can import:
+
+- Visual studio solution / project
+- Compile database, which can be generated from CMake/qbs/etc build files
+- Borland C++ Builder 6
+
+When you have filled out the project settings and clicked on OK, the Cppcheck analysis will start.
+
+## Command line
+
+### First test
+
+Here is some simple code:
+
+    int main()
+    {
+        char a[10];
+        a[10] = 0;
+        return 0;
+    }
+
+If you save that into file1.c and execute:
+
+    cppcheck file1.c
+
+The output from Cppcheck will then be:
+
+    Checking file1.c...
+    [file1.c:4]: (error) Array 'a[10]' index 10 out of bounds
+
+### Checking all files in a folder
+
+Normally a program has many source files. Cppcheck can check all source files in a directory:
+
+    cppcheck path
+
+If "path" is a folder, then Cppcheck will recursively check all source files in this folder:
+
+    Checking path/file1.cpp...
+    1/2 files checked 50% done
+    Checking path/file2.cpp...
+    2/2 files checked 100% done
+
+### Check files manually or use project file
+
+With Cppcheck you can check files manually by specifying files/paths to check and settings. Or you can use a build 
+environment, such as CMake or Visual Studio.
+
+We don't know which approach (project file or manual configuration) will give you the best results. It is recommended 
+that you try both. It is possible that you will get different results so that to find the largest amount of bugs you 
+need to use both approaches. Later chapters will describe this in more detail.
+
+### Check files matching a given file filter
+
+With `--file-filter=<str>` you can configure file filter(s) and then only those files matching the filter will be checked.
+
+You can use `**`, `*` and `?` in the file filter pattern.  
+`**`: matches zero or more characters, including path separators  
+`*`: matches zero or more characters, excluding path separators  
+`?`: matches any single character except path separators
+
+For example, this command below means that `src/test1.cpp` could be checked, but `src/file2.cpp` and `src/test/file1.cpp` will not be checked:
+
+    cppcheck src/ --file-filter=src/test*
+
+Cppcheck first collects all files in the specified directory, then applies the filter. Therefore, the filter pattern
+must include the directory path you specified.
+
+A common use case for `--file-filter` is to check a project, but only check certain files:
+
+    cppcheck --project=compile_commands.json --file-filter=src/*.c
+
+Typically a `compile_commands.json` contains absolute paths. However no matter if `compile_commands.json` contains absolute paths or relative paths, the option `--file-filter=src/*.c` would mean that:
+ * a file with relative path `test1.c` is not checked.
+ * a file with relative path `src/test2.c` can be checked.
+ * a file with relative path `src/test3.cpp` is not checked.
+
+### Ignore files matching a given pattern
+
+With `-i <str>` you can configure filename/directory patterns that should be ignored.
+
+A file that is ignored will not be checked directly (the complete translation unit is skipped). Any header #include'd from a source file which is not ignored is checked indirectly, regardless if the header is ignored.
+
+> *Note*: If you want to filter out warnings for a header file then `-i` will not work. Use suppressions instead.
+
+You can use `**`, `*` and `?` in the pattern to specify excluded folders/files.  
+`**`: matches zero or more characters, including path separators  
+`*`: matches zero or more characters, excluding path separators  
+`?`: matches any single character except path separators
+
+A use case for `-i` is to check a project, but exclude certain files/folders:
+
+    cppcheck --project=compile_commands.json -itest
+
+Typically a `compile_commands.json` contains absolute paths. However no matter if `compile_commands.json` contains absolute paths or relative paths, the option `-itest` would mean that:
+ * a file with relative path `test1.cpp` can be checked.
+ * a file with relative path `test/somefile.cpp` is not checked
+
+### Clang parser (experimental)
+
+By default Cppcheck uses an internal C/C++ parser. However there is an experimental option to use the Clang parser instead.
+
+Install `clang`. Then use Cppcheck option `--clang`.
+
+Cppcheck executes clang with the -ast-dump option, imports the output, converts it to Cppcheck's internal format, and then
+performs standard analysis.
+
+You can also pass a custom Clang executable to the option by using for example `--clang=clang-10`. You can also pass it 
+with a path. On Windows it will append the `.exe` extension unless you use a path.
+
+## Severities
+
+The possible severities for messages are:
+
+**error**
+
+when code is executed there is either undefined behavior or other error, such as a memory leak or resource leak
+
+**warning**
+
+when code is executed there might be undefined behavior
+
+**style**
+
+stylistic issues, such as unused functions, redundant code, constness, operator precedence, possible mistakes.
+
+**performance**
+
+run time performance suggestions based on common knowledge, though it is not certain any measurable speed difference 
+will be achieved by fixing these messages.
+
+**portability**
+
+portability warnings. Implementation defined behavior. 64-bit portability. Some undefined behavior that probably works 
+"as you want", etc.
+
+**information**
+
+configuration problems, which does not relate to the syntactical correctness, but the used Cppcheck configuration could 
+be improved.
+
+## Possible speedup analysis of template code
+
+Cppcheck instantiates the templates in your code.
+
+If your templates are recursive, this can lead to slow analysis and high memory usage. Cppcheck will write information
+messages when there are potential problems.
+
+Example code:
+
+    template <int i>
+    void a()
+    {
+        a<i+1>();
+    }
+
+    void foo()
+    {
+        a<0>();
+    }
+
+Cppcheck output:
+
+    test.cpp:4:5: information: TemplateSimplifier: max template
+    recursion (100) reached for template 'a<101>'. You might
+    want to limit Cppcheck recursion. [templateRecursion]
+        a<i+1>();
+        ^
+
+As you can see Cppcheck has instantiated `a<i+1>` until `a<101>` was reached
+and then it bails out.
+
+To limit template recursion you can:
+
+- add template specialisation
+- configure Cppcheck, which can be done in the GUI project file dialog
+
+Example code with template specialisation:
+
+    template <int i>
+    void a()
+    {
+        a<i+1>();
+    }
+
+    void foo()
+    {
+        a<0>();
+    }
+
+    #ifdef __cppcheck__
+    template<> void a<3>() {}
+    #endif
+
+You can pass `-D__cppcheck__` when checking this code.
+
+
+# Cppcheck build folder
+
+Using a Cppcheck build folder is not mandatory but it is recommended.
+
+Cppcheck save analyzer information in that folder.
+
+The advantages are:
+
+- It speeds up the analysis as it makes incremental analysis possible. Only changed files are analyzed when you recheck.
+- Whole program analysis also when multiple threads are used.
+
+On the command line you configure that through `--cppcheck-build-dir=path`. Example:
+
+    mkdir b
+
+    # All files are analyzed
+    cppcheck --cppcheck-build-dir=b src
+
+    # Faster! Results of unchanged files are reused
+    cppcheck --cppcheck-build-dir=b src
+
+In the GUI it is configured in the project settings.
+
+# Importing a project
+
+You can import some project files and build configurations into Cppcheck.
+
+## Cppcheck GUI project
+
+You can import and use Cppcheck GUI project files in the command line tool:
+
+    cppcheck --project=foobar.cppcheck
+
+The Cppcheck GUI has a few options that are not available in the command line directly. To use these options you can import a GUI project file. 
+The command line tool usage is kept intentionally simple and the options are therefore limited.
+
+To ignore certain folders in the project you can use `-i`. This will skip the analysis of source files in the `foo` folder.
+
+    cppcheck --project=foobar.cppcheck -ifoo
+
+## CMake
+
+Generate a compile database (a JSON file containing compilation commands for each source file):
+
+    cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON .
+
+The file `compile_commands.json` is created in the current folder. Now run Cppcheck like this:
+
+    cppcheck --project=compile_commands.json
+
+To ignore certain folders you can use `-i`. This will skip analysis of source files in the `foo` folder.
+
+    cppcheck --project=compile_commands.json -ifoo
+
+
+## Visual Studio
+
+You can run Cppcheck on individual project files (\*.vcxproj) or on a whole solution (\*.sln)
+
+Running Cppcheck on an entire Visual Studio solution:
+
+    cppcheck --project=foobar.sln
+
+Running Cppcheck on a Visual Studio project:
+
+    cppcheck --project=foobar.vcxproj
+
+Both options will analyze all available configurations in the project(s).
+Limiting on a single configuration:
+
+    cppcheck --project=foobar.sln "--project-configuration=Release|Win32"
+
+In the `Cppcheck GUI` you have the option to only analyze a single debug configuration. If you want to use this option on the command line, then create a `Cppcheck GUI` project with this activated and then import the GUI project file on the command line.
+
+To ignore certain folders in the project you can use `-i`. This will skip analysis of source files in the `foo` folder.
+
+    cppcheck --project=foobar.vcxproj -ifoo
+
+## C++ Builder 6
+
+Running Cppcheck on a C++ Builder 6 project:
+
+    cppcheck --project=foobar.bpr
+
+
+To ignore certain folders in the project you can use `-i`. This will skip analysis of source files in the `foo` folder.
+
+    cppcheck --project=foobar.bpr -ifoo
+
+## Other
+
+If you can generate a compile database, then it is possible to import that in Cppcheck.
+
+In Linux you can use for instance the `bear` (build ear) utility to generate a compile database from arbitrary build tools:
+
+    bear -- make
+
+# Preprocessor Settings
+
+If you use `--project` then Cppcheck will automatically use the preprocessor settings in the imported project file and
+likely you don't have to configure anything extra.
+
+If you don't use `--project` then a bit of manual preprocessor configuration might be required. However Cppcheck has
+automatic configuration of defines.
+
+## Automatic configuration of preprocessor defines
+
+Cppcheck automatically test different combinations of preprocessor defines to achieve as high coverage in the analysis
+as possible.
+
+Here is a file that has 3 bugs (when x,y,z are assigned).
+
+    #ifdef A
+        x=100/0;
+        #ifdef B
+            y=100/0;
+        #endif
+    #else
+        z=100/0;
+    #endif
+
+    #ifndef C
+    #error C must be defined
+    #endif
+
+The flag `-D` tells Cppcheck that a name is defined. Cppcheck will only analyze configurations that
+contain this define.
+
+The flag `-U` tells Cppcheck that a name is not defined. Cppcheck will only analyze configurations
+that does not contain this define.
+
+The flag `--force` and `--max-configs` is used to control how many combinations are checked. When `-D` is used,
+Cppcheck will only check 1 configuration unless these are used.
+
+Example:
+
+    # test all configurations
+    # all bugs are found
+    cppcheck test.c
+
+    # only test configuration "-DA"
+    # No bug is found (#error)
+    cppcheck -DA test.c
+
+    # only test configuration "-DA -DC"
+    # The first bug is found
+    cppcheck -DA -DC test.c
+
+    # The configuration "-DC" is tested
+    # The last bug is found
+    cppcheck -UA test.c
+
+    # All configurations with "-DA" are tested
+    # The two first bugs are found
+    cppcheck --force -DA test.c
+
+
+## Include paths
+
+To add an include path, use `-I`, followed by the path.
+
+Cppcheck's preprocessor basically handles includes like any other preprocessor. However, while other preprocessors 
+stop working when they encounter a missing header, Cppcheck will just print an information message and continues 
+parsing the code.
+
+The purpose of this behaviour is that Cppcheck is meant to work without necessarily seeing the entire code. 
+Actually, it is recommended to not give all include paths. 
+While it is useful for Cppcheck to see the declaration of a class when checking the implementation of its members, 
+passing standard library headers is discouraged, because the analysis will not work fully and lead to a longer checking 
+time. For such cases, .cfg files are the preferred way to provide information about the implementation of functions and 
+types to Cppcheck, see below for more information.
+
+# Platform
+
+You should use a platform configuration that matches your target environment.
+
+By default Cppcheck uses native platform configuration that works well if your code is compiled and executed locally.
+
+Cppcheck has builtin configurations for Unix and Windows targets. You can easily use these with the `--platform` command line flag.
+
+You can also create your own custom platform configuration in a XML file. Here is an example:
+
+    <?xml version="1"?>
+    <platform>
+      <char_bit>8</char_bit>
+      <default-sign>signed</default-sign>
+      <sizeof>
+        <short>2</short>
+        <int>4</int>
+        <long>4</long>
+        <long-long>8</long-long>
+        <float>4</float>
+        <double>8</double>
+        <long-double>12</long-double>
+        <pointer>4</pointer>
+        <size_t>4</size_t>
+        <wchar_t>2</wchar_t>
+      </sizeof>
+    </platform>
+
+# C/C++ Standard
+
+Use `--std` on the command line to specify a C/C++ standard.
+
+Cppcheck assumes that the code is compatible with the latest C/C++ standard, but it is possible to override this.
+
+The available options are:
+
+- c89: C code is C89 compatible
+- c99: C code is C99 compatible
+- c11: C code is C11 compatible
+- c17: C code is C17 compatible
+- c23: C code is C23 compatible (default)
+- c++03: C++ code is C++03 compatible
+- c++11: C++ code is C++11 compatible
+- c++14: C++ code is C++14 compatible
+- c++17: C++ code is C++17 compatible
+- c++20: C++ code is C++20 compatible
+- c++23: C++ code is C++23 compatible
+- c++26: C++ code is C++26 compatible (default)
+
+# Cppcheck build dir
+
+It's a good idea to use a Cppcheck build dir. On the command line use `--cppcheck-build-dir`. In
+the GUI, the build dir is configured in the project options.
+
+Rechecking code will be much faster. Cppcheck does not analyse unchanged code. The old warnings are
+loaded from the build dir and reported again.
+
+Whole program analysis does not work when multiple threads are used; unless you use a cppcheck
+build dir. For instance, the unusedFunction warnings require whole program analysis.
+
+# Suppressions
+
+If you want to filter out certain errors from being generated, then it is possible to suppress these.
+
+If you encounter a false positive, please report it to the Cppcheck team so that the issue can be
+fixed.
+
+## Plain text suppressions
+
+The format for an error suppression is one of:
+
+    [error id]:[filename]:[line]
+    [error id]:[filename2]
+    [error id]
+
+The `error id` is the id that you want to suppress. The id of a warning is shown in brackets in the normal cppcheck text output.
+
+The `error id` and `filename` patterns may contain `**`, `*` or `?`.  
+`**`: matches zero or more characters, including path separators  
+`*`: matches zero or more characters, excluding path separators  
+`?`: matches any single character except path separators
+
+It is recommended to use forward-slash `/` in the filename pattern as path separator on all operating systems.
+
+### Command line suppression
+
+The `--suppress=` command line option is used to specify suppressions on the command line. Example:
+
+    cppcheck --suppress=memleak:src/file1.cpp src/
+
+### Suppressions in a file
+
+You can create a suppressions file for example as follows:
+
+    // suppress memleak and exceptNew errors in the file src/file1.cpp
+    memleak:src/file1.cpp
+    exceptNew:src/file1.cpp
+
+    uninitvar // suppress all uninitvar errors in all files
+
+Note that you may add empty lines and comments in the suppressions file.
+Comments must start with `#` or `//` and be at the start of the line, or after the suppression line.
+
+The usage of the suppressions file is as follows:
+
+    cppcheck --suppressions-list=suppressions.txt src/
+
+## XML suppressions
+
+You can specify suppressions in a XML file, for example as follows:
+
+    <?xml version="1.0"?>
+    <suppressions>
+      <suppress>
+        <id>uninitvar</id>
+        <fileName>src/file1.c</fileName>
+        <lineNumber>10</lineNumber>
+        <symbolName>var</symbolName>
+      </suppress>
+    </suppressions>
+
+The `id` and `fileName` patterns may contain `**`, `*` or `?`.
+`**`: matches zero or more characters, including path separators
+`*`: matches zero or more characters, excluding path separators
+`?`: matches any single character except path separators
+
+The XML format is extensible and may be extended with further attributes in the future.
+
+The usage of the suppressions file is as follows:
+
+    cppcheck --suppress-xml=suppressions.xml src/
+
+## Inline suppressions
+
+Suppressions can also be added directly in the code by adding comments that contain special keywords. 
+Note that adding comments sacrifices the readability of the code somewhat.
+
+This code will normally generate an error message:
+
+    void f() {
+        char arr[5];
+        arr[10] = 0;
+    }
+
+The output is:
+
+    cppcheck test.c
+    [test.c:3]: (error) Array 'arr[5]' index 10 out of bounds
+
+To activate inline suppressions:
+
+    cppcheck --inline-suppr test.c
+
+### Format
+
+You can suppress a warning `aaaa` with:
+
+    // cppcheck-suppress aaaa
+
+Suppressing multiple ids in one comment by using []:
+
+    // cppcheck-suppress [aaaa, bbbb]
+
+Suppressing warnings `aaaa` on a block of code:
+
+    // cppcheck-suppress-begin aaaa
+    ...
+    // cppcheck-suppress-end aaaa
+
+Suppressing multiple ids on a block of code:
+
+    // cppcheck-suppress-begin [aaaa, bbbb]
+    ...
+    // cppcheck-suppress-end [aaaa, bbbb]
+
+Suppressing warnings `aaaa` for a whole file:
+
+    // cppcheck-suppress-file aaaa
+
+Suppressing multiple ids for a whole file:
+
+    // cppcheck-suppress-file [aaaa, bbbb]
+
+Suppressing warnings `aaaa` where macro is used:
+
+    // cppcheck-suppress-macro aaaa
+    #define MACRO ...
+    ...
+    x = MACRO; // <- aaaa warnings are suppressed here
+
+
+Suppressing multiple ids where macro is used:
+
+    // cppcheck-suppress-macro [aaaa, bbbb]
+    #define MACRO ...
+    ...
+    x = MACRO; // <- aaaa and bbbb warnings are suppressed here
+
+### Comment before code or on same line
+
+The comment can be put before the code or at the same line as the code.
+
+Before the code:
+
+    void f() {
+        char arr[5];
+
+        // cppcheck-suppress arrayIndexOutOfBounds
+        arr[10] = 0;
+    }
+
+Or at the same line as the code:
+
+    void f() {
+        char arr[5];
+
+        arr[10] = 0;  // cppcheck-suppress arrayIndexOutOfBounds
+    }
+
+In this example there are 2 lines with code and 1 suppression comment. The suppression comment only applies to 1 line: `a = b + c;`.
+
+    void f() {
+        a = b + c; // cppcheck-suppress abc
+        d = e + f;
+    }
+
+As a special case for backwards compatibility, if you have a `{` on its own line and a suppression comment after that, then that will suppress warnings for both the current and next line. This example will suppress `abc` warnings both for `{` and for `a = b + c;`:
+
+    void f()
+    { // cppcheck-suppress abc
+        a = b + c;
+    }
+
+### Multiple suppressions
+
+For a line of code there might be several warnings you want to suppress.
+
+There are several options;
+
+Using 2 suppression comments before code:
+
+    void f() {
+        char arr[5];
+
+        // cppcheck-suppress arrayIndexOutOfBounds
+        // cppcheck-suppress zerodiv
+        arr[10] = arr[10] / 0;
+    }
+
+Using 1 suppression comment before the code:
+
+    void f() {
+        char arr[5];
+
+        // cppcheck-suppress[arrayIndexOutOfBounds,zerodiv]
+        arr[10] = arr[10] / 0;
+    }
+
+Suppression comment on the same line as the code:
+
+    void f() {
+        char arr[5];
+
+        arr[10] = arr[10] / 0;  // cppcheck-suppress[arrayIndexOutOfBounds,zerodiv]
+    }
+
+
+### Symbol name
+
+You can specify that the inline suppression only applies to a specific symbol:
+
+    // cppcheck-suppress aaaa symbolName=arr
+
+Or:
+
+    // cppcheck-suppress[aaaa symbolName=arr, bbbb]
+
+### Comment about suppression
+
+You can write comments about a suppression as follows:
+
+    // cppcheck-suppress[warningid] some comment
+    // cppcheck-suppress warningid ; some comment
+    // cppcheck-suppress warningid // some comment
+
+# XML output
+
+Cppcheck can generate output in XML format. Use `--xml` to enable this format.
+
+A sample command to check a file and output errors in the XML format:
+
+    cppcheck --xml file1.cpp
+
+Here is a sample report:
+
+    <?xml version="1.0" encoding="UTF-8"?>
+    <results version="2">
+      <cppcheck version="1.66"/>
+      <errors>
+        <error id="someError" severity="error" msg="short error text"
+           verbose="long error text" inconclusive="true" cwe="312">
+          <location file0="file.c" file="file.h" line="1"/>
+       </error>
+      </errors>
+    </results>
+
+## The `<error>` element
+
+Each error is reported in a `<error>` element. Attributes:
+
+**id**
+
+id of error, and which are valid symbolnames
+
+**severity**
+
+error/warning/style/performance/portability/information
+
+**msg**
+
+the error message in short format
+
+**verbose**
+
+the error message in long format
+
+**inconclusive**
+
+this attribute is only used when the error message is inconclusive
+
+**cwe**
+
+CWE ID for the problem; note that this attribute is only used when the CWE ID for the message is known
+
+**remark**
+
+Optional attribute. The related remark/justification from a remark comment.
+
+## The `<location>` element
+
+All locations related to an error are listed with `<location>` elements. The primary location is listed first.
+
+Attributes:
+
+**file**
+
+filename, both relative and absolute paths are possible
+
+**file0**
+
+name of the source file (optional)
+
+**line**
+
+line number
+
+**info**
+
+short information for each location (optional)
+
+# Reformatting the text output
+
+If you want to reformat the output so that it looks different, then you can use templates.
+
+## Predefined output formats
+
+To get Visual Studio compatible output you can use --template=vs:
+
+    cppcheck --template=vs samples/arrayIndexOutOfBounds/bad.c
+
+This output will look like this:
+
+    Checking samples/arrayIndexOutOfBounds/bad.c ...
+    samples/arrayIndexOutOfBounds/bad.c(6): error: Array
+    'a[2]' accessed at index 2, which is out of bounds.
+
+To get gcc compatible output you can use --template=gcc:
+
+    cppcheck --template=gcc samples/arrayIndexOutOfBounds/bad.c
+
+The output will look like this:
+
+    Checking samples/arrayIndexOutOfBounds/bad.c ...
+    samples/arrayIndexOutOfBounds/bad.c:6:6: warning: Array
+    'a[2]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]
+    a[2] = 0;
+      ^
+
+## User defined output format (single line)
+
+You can write your own pattern. For instance:
+
+    cppcheck \
+    --template="{file}:{line}:{column}: {severity}:{message}" \
+    samples/arrayIndexOutOfBounds/bad.c
+
+The output will then look like this:
+
+    Checking samples/arrayIndexOutOfBounds/bad.c ...
+    samples/arrayIndexOutOfBounds/bad.c:6:6: error: Array
+    'a[2]' accessed at index 2, which is out of bounds.
+
+A comma separated format:
+
+    cppcheck \
+    --template="{file},{line},{severity},{id},{message}" \
+    samples/arrayIndexOutOfBounds/bad.c
+
+The output will look like this:
+
+    Checking samples/arrayIndexOutOfBounds/bad.c ...
+    samples/arrayIndexOutOfBounds/bad.c,6,error,arrayIndexOutOfBounds,
+    Array 'a[2]' accessed at index 2, which is out of bounds.
+
+## User defined output format (multi line)
+
+Many warnings have multiple locations. Example code:
+
+    void f(int *p)
+    {
+        *p = 3;       // line 3
+    }
+
+    int main()
+    {
+        int *p = 0;   // line 8
+        f(p);         // line 9
+        return 0;
+    }
+
+There is a possible null pointer dereference at line 3. 
+Cppcheck can show how it came to that conclusion by showing extra location information. 
+You need to use both --template and --template-location at the command line, for example:
+
+    cppcheck \
+    --template="{file}:{line}: {severity}: {message}\n{code}" \
+    --template-location="{file}:{line}: note: {info}\n{code}" multiline.c
+
+The output from Cppcheck is:
+
+    Checking multiline.c ...
+    multiline.c:3: warning: Possible null pointer dereference: p
+        *p = 3;
+         ^
+    multiline.c:8: note: Assignment 'p=0', assigned value is 0
+        int *p = 0;
+                 ^
+    multiline.c:9: note: Calling function 'f', 1st argument 'p' value is 0
+        f(p);
+          ^
+    multiline.c:3: note: Null pointer dereference
+        *p = 3;
+         ^
+
+The first line in the warning is formatted by the --template format.
+
+The other lines in the warning are formatted by the --template-location format.
+
+### Format specifiers for --template
+
+The available specifiers for --template are:
+
+**{file}**
+
+File name
+
+**{line}**
+
+Line number
+
+**{column}**
+
+Column number
+
+**{callstack}**
+
+Write all locations. Each location is written in [{file}:{line}] format and the locations are separated by ->. For instance it might look like: [multiline.c:8] -> [multiline.c:9] -> [multiline.c:3]
+
+**{inconclusive:text}**
+
+If warning is inconclusive, then the given text is written. The given text can be any text that does not contain }. Example: {inconclusive:inconclusive,}
+
+**{severity}**
+
+error/warning/style/performance/portability/information
+
+**{message}**
+
+The warning message
+
+**{id}**
+
+Warning id
+
+**{remark}**
+
+The remark text if a remark comment has been provided
+
+**{code}**
+
+The real code
+
+**\\t**
+
+Tab
+
+**\\n**
+
+Newline
+
+**\\r**
+
+Carriage return
+
+### Format specifiers for --template-location
+
+The available specifiers for `--template-location` are:
+
+**{file}**
+
+File name
+
+**{line}**
+
+Line number
+
+**{column}**
+
+Column number
+
+**{info}**
+
+Information message about the current location
+
+**{code}**
+
+The real code
+
+**\\t**
+
+Tab
+
+**\\n**
+
+Newline
+
+**\\r**
+
+Carriage return
+
+# Justifications for warnings in the report
+
+You can add remark comments in the source code that justify why there is a warning/violation.
+
+Such a remark comment shall:
+
+- start with REMARK.
+- can either be added above the source code that generates the warning, or after the code on the same line.
+
+Example code:
+
+    void foo(void) {
+        // REMARK Initialize x with 0
+        int x = 0;
+    }
+
+In Cppcheck text output the remarks are not shown by default, you can use `--template` option `{remark}` to show remarks:
+
+    $ ./cppcheck --enable=style \
+    --template="{file}:{line}: {message} [{id}]\\n{remark}" test1.c
+
+    Checking test1.c ...
+    test1.c:4: Variable 'x' is assigned a value that is never used. [unreadVariable]
+    Initialize x with 0
+
+In xml output the comment text is provided in a "remark" attribute:
+
+    $ ./cppcheck --enable=style --xml test1.c
+    ....
+    remark="Initialize x with 0"
+    ....
+
+# Addons
+
+Addons are scripts that analyse Cppcheck dump files to check compatibility with secure coding standards and to locate issues.
+
+Cppcheck is distributed with a few addons which are listed below.
+
+## Supported addons
+
+### namingng.py
+
+[namingng.py](https://github.com/danmar/cppcheck/blob/main/addons/namingng.py) allows you to configure and check naming conventions.
+
+You need to have a configuration file that defines your naming conventions. By default the filename `namingng.config.json` is used but there is an option so you can use any filename you want.
+
+Example configuration of naming conventions:
+```
+{
+   "RE_VARNAME": ["[a-z]*[a-zA-Z0-9_]*\\Z"],
+   "RE_PRIVATE_MEMBER_VARIABLE": null,
+   "RE_FUNCTIONNAME": ["[a-z0-9A-Z]*\\Z"],
+   "_comment": "comments can be added to the config with underscore-prefixed keys",
+   "include_guard": {
+       "input": "path",
+       "prefix": "GUARD_",
+       "case": "upper",
+       "max_linenr": 5,
+       "RE_HEADERFILE": "[^/].*\\.h\\Z",
+       "required": true
+   },
+   "var_prefixes": {"uint32_t": "ui32"},
+   "function_prefixes": {"uint16_t": "ui16",
+                         "uint32_t": "ui32"}
+}
+```
+
+### threadsafety.py
+
+[threadsafety.py](https://github.com/danmar/cppcheck/blob/main/addons/threadsafety.py) analyses Cppcheck dump files to locate thread safety issues like static local objects used by multiple threads.
+
+### y2038.py
+
+[y2038.py](https://github.com/danmar/cppcheck/blob/main/addons/y2038.py) checks source code for [year 2038 problem](https://en.wikipedia.org/wiki/Year_2038_problem) safety.
+
+## Running Addons
+
+Addons can be executed with the `--addon` option:
+
+    cppcheck --addon=namingng.py somefile.c
+
+Likewise, if you have created your own script you can execute that:
+
+    cppcheck --addon=mychecks.py somefile.c
+
+You can configure how you want to execute an addon in a json file. For example:
+
+    {
+        "script": "mychecks.py",
+        "args": [
+            "--some-option"
+        ],
+        "ctu": false
+    }
+
+To use that json file to execute your addon use the --addon option:
+
+    cppcheck --addon=mychecks.json somefile.c
+
+Cppcheck search for addons in the local folder first and then in the installation folder. A different path can be specified explicitly, for instance:
+
+    cppcheck --addon=path/to/my-addon.py somefile.c
+
+# Library configuration
+
+When external libraries are used, such as WinAPI, POSIX, gtk, Qt, etc, Cppcheck has no information about functions, types, or macros contained in those libraries. Cppcheck then fails to detect various problems in the code, or might even abort the analysis. But this can be fixed by using the appropriate configuration files.
+
+Cppcheck already contains configurations for several libraries. They can be loaded as described below. Note that the configuration for the standard libraries of C and C++, std.cfg, is always loaded by cppcheck. If you create or update a configuration file for a popular library, we would appreciate if you supplied it to the cppcheck project.
+
+## Using a .cfg file
+
+To use a .cfg file shipped with cppcheck, pass the `--library=<lib>` option. The table below shows the currently existing libraries:
+
+| .cfg file         | Library       | Comment       |
+| ----------------- | ------------- | ------------- |
+| avr.cfg           |               |               |
+| bento4.cfg        | [Bento4](http://www.bento4.com/) | |
+| boost.cfg         | [Boost](http://www.boost.org/) | |
+| bsd.cfg           | [BSD](https://www.freebsd.org/) | |
+| cairo.cfg         | [cairo](https://www.cairographics.org/) | |
+| cppcheck-lib.cfg  | [Cppcheck](http://cppcheck.net/) | Used in selfcheck of |
+|                   |               |the Cppcheck code base |
+| cppunit.cfg       | [CppUnit](https://sourceforge.net/projects/cppunit/) | |
+| dpdk.cfg          |               |               |
+| embedded_sql.cfg  |               |               |
+| emscripten.cfg | | |
+| ginac.cfg | | |
+| gnu.cfg | [GNU](https://www.gnu.org/) | |
+| googletest.cfg | [GoogleTest](https://github.com/google/googletest) | |
+| gtk.cfg | [GTK](https://www.gtk.org/) | |
+| icu.cfg | | |
+| kde.cfg | [KDE](https://kde.org/) | |
+| libcerror.cfg | [libcerror](https://github.com/libyal/libcerror) | |
+| libcurl.cfg | [libcurl](https://curl.se/libcurl/) | |
+| libsigc++.cfg | [libsigc++](https://github.com/libsigcplusplus/libsigcplusplus) | |
+| lua.cfg | | |
+| mfc.cfg | [MFC](https://learn.microsoft.com/en-us/cpp/mfc/mfc-desktop-applications) | |
+| microsoft_atl.cfg | [ATL](https://learn.microsoft.com/en-us/cpp/atl/active-template-library-atl-concepts) | |
+| microsoft_sal.cfg | [SAL annotations](https://learn.microsoft.com/en-us/cpp/c-runtime-library/sal-annotations) | |
+| microsoft_unittest.cfg | [CppUnitTest](https://learn.microsoft.com/en-us/visualstudio/test/microsoft-visualstudio-testtools-cppunittestframework-api-reference) | |
+| motif.cfg | | |
+| nspr.cfg | | |
+| ntl.cfg | | |
+| opencv2.cfg | [OpenCV](https://opencv.org/) | |
+| opengl.cfg | [OpenGL](https://opengl.org/) | |
+| openmp.cfg | [OpenMP](https://www.openmp.org/) | |
+| openssl.cfg | [OpenSSL](https://www.openssl.org/) | |
+| pcre.cfg | [PCRE](https://pcre.org/) | |
+| posix.cfg | [POSIX](https://pubs.opengroup.org/onlinepubs/9699919799/) | |
+| python.cfg | | |
+| qt.cfg | [Qt](https://doc.qt.io/qt.html) | |
+| ruby.cfg | | |
+| sdl.cfg | | |
+| sfml.cfg | | |
+| sqlite3.cfg | [SQLite](https://www.sqlite.org/) | |
+| std.cfg | C/C++ standard library | Loaded by default |
+| tinyxml2.cfg | [TinyXML-2](https://github.com/leethomason/tinyxml2) | |
+| vcl.cfg | | |
+| windows.cfg | [Win32 API](https://learn.microsoft.com/en-us/windows/win32/) | |
+| wxsqlite3.cfg | | |
+| wxsvg.cfg | | |
+| wxwidgets.cfg | [wxWidgets](https://www.wxwidgets.org/) | |
+| zephyr.cfg | | |
+| zlib.cfg | [zlib](https://www.zlib.net) | |
+
+## Creating a custom .cfg file
+
+You can create and use your own .cfg files for your projects. Use `--check-library` to get hints about what you should configure.
+
+You can use the `Library Editor` in the `Cppcheck GUI` to edit configuration files. It is available in the `View` menu.
+
+The .cfg file format is documented in the `Reference: Cppcheck .cfg format` (https://cppcheck.sourceforge.io/reference-cfg-format.pdf) document.
+
+# HTML Report
+
+You can convert the XML output from Cppcheck into a HTML report. You'll need Python and the pygments module (<http://pygments.org/>) for this to work. In the Cppcheck source tree there is a folder htmlreport that contains a script that transforms a Cppcheck XML file into HTML output.
+
+This command generates the help screen:
+
+    htmlreport/cppcheck-htmlreport -h
+
+The output screen says:
+
+    Usage: cppcheck-htmlreport [options]
+
+    Options:
+       -h, --help      show this help message and exit
+       --file=FILE     The cppcheck xml output file to read defects from.
+                       Default is reading from stdin.
+       --report-dir=REPORT_DIR
+                       The directory where the html report content is written.
+       --source-dir=SOURCE_DIR|URL
+                       Base directory where source code files can be found, or
+                       a URL to a remote GitHub/GitLab repository including a
+                       branch, e.g.:
+                         --source-dir=https://github.com/<username>/<repo>/blob/<branch>/
+
+Example usage:
+
+    cppcheck gui/test.cpp --xml 2> err.xml
+    cppcheck-htmlreport --file=err.xml --report-dir=test1 --source-dir=.
+
+or
+    cppcheck gui/test.cpp --xml 2> err.xml
+    cppcheck-htmlreport --file=err.xml --report-dir=test1 \
+         --source-dir=https://github.com/<username>/<repo>/blob/<branch>/
+
+## Choosing Between Local Annotated HTML and Remote Repository Links
+
+cppcheck-htmlreport supports two modes for linking to source files:
+ - Local annotated HTML files (default when `--source-dir` is a filesystem path)
+ - Remote GitHub/GitLab links (when `--source-dir` is a URL)
+
+Pointing `--source-dir` to a filesystem path generates local annotated HTML files.
+This is useful when you need a fully self-contained report that works offline,
+includes inline annotations, and is ideal for small or medium projects where
+generation is fast.
+Using a remote GitHub/GitLab URL avoids generating per-file HTML and keeps the
+summary report lightweight and fast to produce. This mode is ideal when the
+source is already hosted online and local duplication is unnecessary.
+Remote mode is especially helpful when the HTML report may be public or widely
+distributed but the source code should remain private, since access control is
+handled by the hosting service.
+In general, local mode fits air-gapped environments, while remote mode works
+best for CI workflows and large or private repositories.
+
+# Check Level
+
+## Reduced
+
+The "reduced" check level performs a limited data flow analysis. If developers
+want to run cppcheck directly during development and require faster results
+than "normal" provides then this reduced checking can be an option.
+
+## Normal
+
+The "normal" check level is chosen by default. Our aim is that this checking level will provide an effective checking in "reasonable" time.
+
+The "normal" check level should be useful during active development:
+
+- checking files while you edit them.
+- block changes to the repo
+- etc
+
+## Exhaustive
+
+When you can wait longer for the results you can enable the "exhaustive" checking, by using the option `--check-level=exhaustive`.
+
+Exhaustive checking level should be useful for scenarios where you can wait for results. For instance:
+
+- nightly builds
+- etc
+
+# Speeding up analysis
+
+## Limit preprocessor configurations
+
+For performance reasons it might be a good idea to limit preprocessor configurations to check.
+
+## Limit ValueFlow: max if count
+
+The command line option `--performance-valueflow-max-if-count` adjusts the max count for number of if in a function.
+
+When that limit is exceeded there is a limitation of data flow in that function. It is not drastic:
+
+- Analysis of other functions are not affected.
+- It's only for some specific data flow analysis, we have data flow analysis that is always executed.
+- All checks are always executed. There can still be plenty of warnings in the limited function.
+
+There is data flow analysis that slows down exponentially when number of if increase. And the limit is intended to avoid that
+analysis time explodes.
+
+## GUI options
+
+In the GUI there are various options to limit analysis.
+
+In the GUI:
+
+- Open the project dialog.
+- In the "Analysis" tab there are several options.
+
+If you want to use these limitations on the command line also you can import the GUI project file with --project.
+
+# Cppcheck Premium
+
+## Bug hunting
+
+This is analysis that is more noisy than normal analysis. Most warnings will be false positives (cppcheck will wrongly claim that there are bugs). The design goal is to not have more than roughly 5 - 10 false positives in each file.
+
+It is not intended to be used in normal CI or regular static analysis by developers. The noise makes it useless for that.
+
+It is intended to be used when you are looking for bugs and you really can accept noise. For example:
+
+- You have developed a brand new feature and want to ensure that there are no bugs.
+- Maybe as part of release testing your product you can run bug hunting on modified files.
+- Etc
+
+Technically, analysis that is "sound" will detect all bugs. Analysis that is "soundy" has the goal to detect most bugs and it tries to keep the noise at an reasonable level.
+
+The Cppcheck bug hunting analysis is "soundy".
+
+Command:
+
+    cppcheck --premium=bughunting ....
+
+## Coding standards
+
+Command to activate Autosar checkers:
+
+    cppcheck --premium=autosar ....
+
+Command to activate Cert C checkers:
+
+    cppcheck --premium=cert-c ....
+
+Command to activate Cert C++ checkers:
+
+    cppcheck --premium=cert-c++ ....
+
+Command to activate Misra C 2012 checkers:
+
+    cppcheck --premium=misra-c-2012 ....
+
+Command to activate Misra C 2023 checkers:
+
+    cppcheck --premium=misra-c-2023 ....
+
+Command to activate Misra C 2025 checkers:
+
+    cppcheck --premium=misra-c-2025 ....
+
+Command to activate Misra C++ 2008 checkers:
+
+    cppcheck --premium=misra-c++-2008 ....
+
+Command to activate Misra C++ 2023 checkers:
+
+    cppcheck --premium=misra-c++-2023 ....
+
+### Checking all C and C++ files
+
+The `cert-c` and `misra-c-*` coding standards target C and therefore the checkers only check C files by default.
+
+The `autosar`, `cert-c++` and `misra-c++-*` coding standards target C++ and therefore the checkers only check C++ files by default.
+
+If you want to check all files you can append ":all" to the coding standard. Example:
+
+    # Misra C checkers are executed on C files, not on C++ files
+    cppcheck --premium=misra-c-2025 path
+
+    # Misra C checkers are executed on C and C++ files
+    cppcheck --premium=misra-c-2025:all path
+
+
+## Compliance report
+
+### Graphical user interface
+
+Run a analysis with some coding standards enabled. After that you can click on
+the `Compliance report...` in the `File` menu.
+
+### Command line
+
+There is a tool `compliance-report` that is distributed with Cppcheck Premium. To see
+all available options run `compliance-report` in a terminal with no options.
+
+Below is example usage to generate a Misra C 2012 compliance report.
+
+`cppcheck --premium=misra-c-2012 --xml-version=3 src 2> results.xml`
+
+`compliance-report --misra-c-2012 --project-name=Device --project-version=2.3 --output-file=report.html results.xml`
+
+Description of the options:
+
+- `--misra-c-2012`: Generate a compliance report for misra-c-2012
+- `--project-name`: The name of the project
+- `--project-version`: The version of the project
+- `--output-file`: html filename that the report should be written to
+- `results.xml`: The xml output from cppcheck
+
+## Metrics
+
+To generate metrics add option `--premium=metrics`. The metrics are saved in the xml v3 report.
+Example:
+
+    cppcheck --premium=metrics test.c --xml-version=3 2> res.xml
+
+We provide a small simple python script that creates a metrics report in CSV format:
+
+    python3 HISReport.py -f res.xml -j path/to/cppcheck-id-mapping.json -o test.csv
+
+the `cppcheck-id-mapping.json` is provided in the cppcheck premium installation folder, i.e.
+`/opt/cppcheckpremium` or `C:\Program Files\Cppcheck Premium`.
+
+We do not have a ready-made solution to generate a html/pdf report. You can easily tweak our
+HISReport.py script so that it generates html and get the report exactly as you want.
+
+## Licenses
+
+### Commercial Terms
+
+Information about Cppcheck Premium licenses:
+https://www.cppcheck.com/plans-pricing
+
+### Installation / Registration
+
+This is described on the Cppcheck Premium website:
+https://www.cppcheck.com
+
+### License file path
+
+There are predefined paths where the premium addon search for license files. If you want to
+provide an arbitrary license file path on the command line you can use the option
+`--premium-license-file`. Example:
+
+    cppcheck --premium-license-file=path/to/file.lic test.cpp
+
+If an explicit path is provided like this then premium addon does not search for license
+files in the predefined paths.
+
+### Troubleshooting
+
+#### Step 1: check premiumaddon debug output
+
+If your license does not work you can get some details about the license validation by executing
+premiumaddon binary with the `--debug` option.
+
+Windows:
+
+    premiumaddon.exe --debug
+
+Linux/Mac:
+
+    premiumaddon --debug
+
+These commands can be executed from an arbitrary folder.
+
+#### Step 2: clean up cppcheck build dir
+
+Command line:
+If you use --cppcheck-build-dir then remove all files in the specified folder and recheck.
+
+Cppcheck GUI:
+The GUI normally by default creates a cppcheck build dir. Clear all results and recheck.
+You can clear all results by clicking on the brush icon in the toolbar. Or by open `Edit` menu and selecting menu item `Clear results`.
+
+#### Step 3: remove cppcheck-premium-loc files
+
+If you have cppcheck-premium-loc files in your project folders those should be removed.
+
+If such files are generated during analysis, then review your scripts to check why those files are generated.
+
diff --git a/man/manual-style.tex b/man/manual-style.tex
new file mode 100644
index 00000000000..72187c11be8
--- /dev/null
+++ b/man/manual-style.tex
@@ -0,0 +1,32 @@
+\usepackage{titlesec}
+\usepackage{fancyvrb,newverbs,xcolor}
+\usepackage{xcolor}
+
+\titleformat{\chapter}[display]   
+{\normalfont\huge\bfseries}{\chaptertitlename\ \thechapter}{20pt}{\Huge}   
+\titlespacing*{\chapter}{0pt}{-20pt}{20pt}
+
+
+\definecolor{Light}{HTML}{EEEEEE}
+\let\oldtexttt\texttt
+\renewcommand{\texttt}[1]{
+  \colorbox{Light}{\oldtexttt{#1}}
+}
+
+\lstset{
+    basicstyle=\ttfamily,
+    backgroundcolor=\color{Light},
+    xleftmargin=10pt,
+    frame=lrtb,
+    framesep=10pt,
+    framerule=0pt,
+    showspaces=false,
+    showstringspaces=false,
+    showtabs=false,
+    tabsize=2,
+    captionpos=b,
+    breaklines=true,
+    breakatwhitespace=true,
+    breakautoindent=true,
+    linewidth=\textwidth
+}
diff --git a/man/manual.css b/man/manual.css
new file mode 100644
index 00000000000..206be6cbeec
--- /dev/null
+++ b/man/manual.css
@@ -0,0 +1,86 @@
+/* stylelint-disable */
+html{line-height:1.15;-webkit-text-size-adjust:100%}body{margin:0}main{display:block}h1{font-size:2em;margin:.67em 0}hr{box-sizing:content-box;height:0;overflow:visible}pre{font-family:monospace,monospace;font-size:1em}a{background-color:transparent}abbr[title]{border-bottom:none;text-decoration:underline;text-decoration:underline dotted}b,strong{font-weight:bolder}code,kbd,samp{font-family:monospace,monospace;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}img{border-style:none}button,input,optgroup,select,textarea{font-family:inherit;font-size:100%;line-height:1.15;margin:0}button,input{overflow:visible}button,select{text-transform:none}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button}[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner,button::-moz-focus-inner{border-style:none;padding:0}[type=button]:-moz-focusring,[type=reset]:-moz-focusring,[type=submit]:-moz-focusring,button:-moz-focusring{outline:1px dotted ButtonText}fieldset{padding:.35em .75em .625em}legend{box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal}progress{vertical-align:baseline}textarea{overflow:auto}[type=checkbox],[type=radio]{box-sizing:border-box;padding:0}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}[type=search]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}details{display:block}summary{display:list-item}[hidden],template{display:none}
+/* stylelint-enable */
+
+html {
+	-moz-osx-font-smoothing: grayscale;
+	-webkit-font-smoothing: antialiased;
+}
+
+body {
+	background-color: #fff;
+	color: #333;
+	font-family: -apple-system,BlinkMacSystemFont,Segoe UI,Helvetica,Arial,sans-serif,Apple Color Emoji,Segoe UI Emoji;
+	font-size: 16px;
+	font-weight: 400;
+	line-height: 1.5;
+    max-width: 1012px;
+	margin: 20px auto;
+    border: 1px solid #eaecef;
+    padding: 20px 100px;
+	overflow-x: hidden;
+}
+
+a {
+    color: #0366d6;
+    text-decoration: none;
+    
+}
+
+a:hover, a:focus {
+    text-decoration: underline;
+    
+}
+
+h1, h2, h3, h4, h5, h6 {
+	font-weight: 600;
+	line-height: 1.25;
+	margin-top: 24px;
+    margin-bottom: 16px;
+}
+
+h1 {
+	font-size: 2em;
+}
+
+h2 {
+	font-size: 1.5em;
+}
+
+h3 {
+	font-size: 1.25em;
+}
+
+h4, h5, h6 {
+	font-size: 1.1em;
+}
+
+h1, h2 {
+    padding-bottom: 0.3em;
+    border-bottom: 1px solid #eaecef;
+}
+
+pre {
+    padding: 16px;
+    background-color: #f6f8fa;
+    border-radius: 6px;
+    line-height: 1.45;
+    font-size: 85%;
+    margin-top: 0;
+    margin-bottom: 16px;
+    overflow: auto;
+}
+
+code {
+    font-family: SFMono-Regular,Consolas,Liberation Mono,Menlo,monospace;
+    background-color: #f6f8fa;
+    font-size: 100%;
+    word-break: normal;
+    white-space: pre;
+}
+
+ol, ul {
+    padding-left: 2em;
+    margin-top: 0;
+    margin-bottom: 16px;
+}
diff --git a/man/manual.md b/man/manual.md
index 252e5d7fcc0..dc07026dc2b 100644
--- a/man/manual.md
+++ b/man/manual.md
@@ -1,28 +1,45 @@
 ---
 title: Cppcheck manual
-subtitle: Version 1.90 dev
+subtitle: Version 2.21 dev
 author: Cppcheck team
 lang: en
-toc: true
 documentclass: report
 ---
 
 # Introduction
 
-Cppcheck is an analysis tool for C/C++ code. It provides unique code analysis to detect bugs and focuses on detecting undefined behaviour and dangerous coding constructs. The goal is to detect only real errors in the code (i.e. have very few false positives).
+Cppcheck is an analysis tool for C/C++ code. It provides unique code analysis to detect bugs and focuses on detecting 
+undefined behaviour and dangerous coding constructs. The goal is to detect only real errors in the code, and generate 
+as few false positives (wrongly reported warnings) as possible. Cppcheck is designed to analyze your C/C++ code even
+if it has non-standard syntax, as is common in for example embedded projects.
 
 Supported code and platforms:
 
-- You can check non-standard code that contains various compiler extensions, inline assembly code, etc.
-- Cppcheck should be compilable by any C++ compiler that handles the latest C++ standard.
-- Cppcheck should work on any platform that has sufficient CPU and memory.
+- Cppcheck checks non-standard code that contains various compiler extensions, inline assembly code, etc.
+- Cppcheck should be compilable by any compiler that supports C++11 or later.
+- Cppcheck is cross platform and is used in various posix/windows/etc environments.
 
-Please understand that there are limits of Cppcheck. Cppcheck is rarely wrong about reported errors. But there are
-many bugs that it doesn't detect.
+The checks in Cppcheck are not perfect. There are bugs that should be found, that Cppcheck fails to detect.
 
-You will find more bugs in your software by testing your software carefully, than by using Cppcheck. You will find
-more bugs in your software by instrumenting your software, than by using Cppcheck. But Cppcheck can still detect some
-of the bugs that you miss when testing and instrumenting your software.
+## About static analysis
+
+The kinds of bugs that you can find with static analysis are:
+
+- Undefined behavior
+- Using dangerous code patterns
+- Coding style
+
+There are many bugs that you can not find with static analysis. Static analysis tools do not have human knowledge about
+what your program is intended to do. If the output from your program is valid but unexpected then in most cases this is
+not detected by static analysis tools. For instance, if your small program writes "Helo" on the screen instead of "Hello"
+it is unlikely that any tool will complain about that.
+
+Static analysis should be used as a complement in your quality assurance. It does not replace any of;
+
+- Careful design
+- Testing
+- Dynamic analysis
+- Fuzzing
 
 # Getting started
 
@@ -35,16 +52,16 @@ In the project settings dialog, the first option you see is "Import project". It
 feature if you can. Cppcheck can import:
 
 - Visual studio solution / project
-- Compile database (can be generated from cmake/qbs/etc build files)
+- Compile database, which can be generated from CMake/qbs/etc build files
 - Borland C++ Builder 6
 
-When you have filled out the project settings and click on OK; the Cppcheck analysis will start.
+When you have filled out the project settings and clicked on OK, the Cppcheck analysis will start.
 
 ## Command line
 
 ### First test
 
-Here is a simple code
+Here is some simple code:
 
     int main()
     {
@@ -57,18 +74,18 @@ If you save that into file1.c and execute:
 
     cppcheck file1.c
 
-The output from cppcheck will then be:
+The output from Cppcheck will then be:
 
     Checking file1.c...
     [file1.c:4]: (error) Array 'a[10]' index 10 out of bounds
 
 ### Checking all files in a folder
 
-Normally a program has many source files. And you want to check them all. Cppcheck can check all source files in a directory:
+Normally a program has many source files. Cppcheck can check all source files in a directory:
 
     cppcheck path
 
-If "path" is a folder then cppcheck will recursively check all source files in this folder.
+If "path" is a folder, then Cppcheck will recursively check all source files in this folder:
 
     Checking path/file1.cpp...
     1/2 files checked 50% done
@@ -77,27 +94,71 @@ If "path" is a folder then cppcheck will recursively check all source files in t
 
 ### Check files manually or use project file
 
-With Cppcheck you can check files manually, by specifying files/paths to check and settings. Or you can use a project file (cmake/visual studio/etc).
+With Cppcheck you can check files manually by specifying files/paths to check and settings. Or you can use a build 
+environment, such as CMake or Visual Studio.
+
+We don't know which approach (project file or manual configuration) will give you the best results. It is recommended 
+that you try both. It is possible that you will get different results so that to find the largest amount of bugs you 
+need to use both approaches. Later chapters will describe this in more detail.
+
+### Check files matching a given file filter
+
+With `--file-filter=<str>` you can configure file filter(s) and then only those files matching the filter will be checked.
+
+You can use `**`, `*` and `?` in the file filter pattern.  
+`**`: matches zero or more characters, including path separators  
+`*`: matches zero or more characters, excluding path separators  
+`?`: matches any single character except path separators
+
+For example, this command below means that `src/test1.cpp` could be checked, but `src/file2.cpp` and `src/test/file1.cpp` will not be checked:
+
+    cppcheck src/ --file-filter=src/test*
+
+Cppcheck first collects all files in the specified directory, then applies the filter. Therefore, the filter pattern
+must include the directory path you specified.
+
+A common use case for `--file-filter` is to check a project, but only check certain files:
+
+    cppcheck --project=compile_commands.json --file-filter=src/*.c
+
+Typically a `compile_commands.json` contains absolute paths. However no matter if `compile_commands.json` contains absolute paths or relative paths, the option `--file-filter=src/*.c` would mean that:
+ * a file with relative path `test1.c` is not checked.
+ * a file with relative path `src/test2.c` can be checked.
+ * a file with relative path `src/test3.cpp` is not checked.
+
+### Ignore files matching a given pattern
+
+With `-i <str>` you can configure filename/directory patterns that should be ignored.
 
-We don't know which approach (project file or manual configuration) will give you the best results. It is recommended that you try both. It is possible that you will get different results so that to find most bugs you need to use both approaches.
+A file that is ignored will not be checked directly (the complete translation unit is skipped). Any header #include'd from a source file which is not ignored is checked indirectly, regardless if the header is ignored.
 
-Later chapters will describe this in more detail.
+> *Note*: If you want to filter out warnings for a header file then `-i` will not work. Use suppressions instead.
 
-### Excluding a file or folder from checking
+You can use `**`, `*` and `?` in the pattern to specify excluded folders/files.  
+`**`: matches zero or more characters, including path separators  
+`*`: matches zero or more characters, excluding path separators  
+`?`: matches any single character except path separators
 
-To exclude a file or folder, there are two options. The first option is to only provide the paths and files you want to check.
+A use case for `-i` is to check a project, but exclude certain files/folders:
 
-    cppcheck src/a src/b
+    cppcheck --project=compile_commands.json -itest
 
-All files under src/a and src/b are then checked.
+Typically a `compile_commands.json` contains absolute paths. However no matter if `compile_commands.json` contains absolute paths or relative paths, the option `-itest` would mean that:
 
-The second option is to use -i, with it you specify files/paths to ignore. With this command no files in src/c are checked:
+ * a file with relative path `test1.cpp` can be checked.
+ * a file with relative path `test/somefile.cpp` is not checked
 
-    cppcheck -isrc/c src
+### Clang parser (experimental)
 
-This option does not currently work with the `--project` option and is only valid when supplying an input directory. To ignore multiple directories supply the -i multiple times. The following command ignores both the src/b and src/c directories.
+By default Cppcheck uses an internal C/C++ parser. However there is an experimental option to use the Clang parser instead.
 
-    cppcheck -isrc/b -isrc/c
+Install `clang`. Then use Cppcheck option `--clang`.
+
+Cppcheck executes clang with the -ast-dump option, imports the output, converts it to Cppcheck's internal format, and then
+performs standard analysis.
+
+You can also pass a custom Clang executable to the option by using for example `--clang=clang-10`. You can also pass it 
+with a path. On Windows it will append the `.exe` extension unless you use a path.
 
 ## Severities
 
@@ -105,29 +166,111 @@ The possible severities for messages are:
 
 **error**
 
-used when bugs are found
+when code is executed there is either undefined behavior or other error, such as a memory leak or resource leak
 
 **warning**
 
-suggestions about defensive programming to prevent bugs
+when code is executed there might be undefined behavior
 
 **style**
 
-stylistic issues related to code cleanup (unused functions, redundant code, constness, and such)
+stylistic issues, such as unused functions, redundant code, constness, operator precedence, possible mistakes.
 
 **performance**
 
-Suggestions for making the code faster. These suggestions are only based on common knowledge. It is not certain you'll get any measurable difference in speed by fixing these messages.
+run time performance suggestions based on common knowledge, though it is not certain any measurable speed difference 
+will be achieved by fixing these messages.
 
 **portability**
 
-portability warnings. 64-bit portability. code might work different on different compilers. etc.
+portability warnings. Implementation defined behavior. 64-bit portability. Some undefined behavior that probably works 
+"as you want", etc.
 
 **information**
 
-Configuration problems. The recommendation is to only enable these during configuration.
+configuration problems, which does not relate to the syntactical correctness, but the used Cppcheck configuration could 
+be improved.
+
+## Possible speedup analysis of template code
+
+Cppcheck instantiates the templates in your code.
+
+If your templates are recursive, this can lead to slow analysis and high memory usage. Cppcheck will write information
+messages when there are potential problems.
+
+Example code:
+
+    template <int i>
+    void a()
+    {
+        a<i+1>();
+    }
+
+    void foo()
+    {
+        a<0>();
+    }
+
+Cppcheck output:
+
+    test.cpp:4:5: information: TemplateSimplifier: max template
+    recursion (100) reached for template 'a<101>'. You might
+    want to limit Cppcheck recursion. [templateRecursion]
+        a<i+1>();
+        ^
+
+As you can see Cppcheck has instantiated `a<i+1>` until `a<101>` was reached
+and then it bails out.
+
+To limit template recursion you can:
 
-# Importing project
+- add template specialisation
+- configure Cppcheck, which can be done in the GUI project file dialog
+
+Example code with template specialisation:
+
+    template <int i>
+    void a()
+    {
+        a<i+1>();
+    }
+
+    void foo()
+    {
+        a<0>();
+    }
+
+    #ifdef __cppcheck__
+    template<> void a<3>() {}
+    #endif
+
+You can pass `-D__cppcheck__` when checking this code.
+
+
+# Cppcheck build folder
+
+Using a Cppcheck build folder is not mandatory but it is recommended.
+
+Cppcheck save analyzer information in that folder.
+
+The advantages are:
+
+- It speeds up the analysis as it makes incremental analysis possible. Only changed files are analyzed when you recheck.
+- Whole program analysis also when multiple threads are used.
+
+On the command line you configure that through `--cppcheck-build-dir=path`. Example:
+
+    mkdir b
+
+    # All files are analyzed
+    cppcheck --cppcheck-build-dir=b src
+
+    # Faster! Results of unchanged files are reused
+    cppcheck --cppcheck-build-dir=b src
+
+In the GUI it is configured in the project settings.
+
+# Importing a project
 
 You can import some project files and build configurations into Cppcheck.
 
@@ -137,18 +280,33 @@ You can import and use Cppcheck GUI project files in the command line tool:
 
     cppcheck --project=foobar.cppcheck
 
-The Cppcheck GUI has a few options that are not available in the command line directly. To use these options you can import a GUI project file. We want to keep the command line tool usage simple and limit the options by intention.
+The Cppcheck GUI has a few options that are not available in the command line directly. To use these options you can import a GUI project file. 
+The command line tool usage is kept intentionally simple and the options are therefore limited.
+
+To ignore certain folders in the project you can use `-i`. This will skip the analysis of source files in the `foo` folder.
 
-## CMake
+    cppcheck --project=foobar.cppcheck -ifoo
 
-Generate a compile database:
+## Compilation database (cmake etc)
+
+Many build systems can generate a compilation database (a JSON file containing compilation commands for each source file).
+Example `cmake` command to generate the file:
 
     cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON .
 
-The file `compile_commands.json` is created in the current folder. Now run Cppcheck like this:
+When you have a `compile_commands.json` file you can run Cppcheck like this:
 
     cppcheck --project=compile_commands.json
 
+By default only 1 configuration is checked because that is consistent with the compilation. If you want to check more configurations you can use `--max-configs` or `--force`. For example:
+
+    cppcheck --project=compile_commands.json --force
+
+To ignore certain folders you can use `-i`. This will skip analysis of source files in the `foo` folder.
+
+    cppcheck --project=compile_commands.json -ifoo
+
+
 ## Visual Studio
 
 You can run Cppcheck on individual project files (\*.vcxproj) or on a whole solution (\*.sln)
@@ -161,7 +319,16 @@ Running Cppcheck on a Visual Studio project:
 
     cppcheck --project=foobar.vcxproj
 
-In the `Cppcheck GUI` you have the choice to only analyze a single debug configuration. If you want to use this choice on the command line then create a `Cppcheck GUI` project with this activated and then import the GUI project file on the command line.
+Both options will analyze all available configurations in the project(s).
+Limiting on a single configuration:
+
+    cppcheck --project=foobar.sln "--project-configuration=Release|Win32"
+
+In the `Cppcheck GUI` you have the option to only analyze a single debug configuration. If you want to use this option on the command line, then create a `Cppcheck GUI` project with this activated and then import the GUI project file on the command line.
+
+To ignore certain folders in the project you can use `-i`. This will skip analysis of source files in the `foo` folder.
+
+    cppcheck --project=foobar.vcxproj -ifoo
 
 ## C++ Builder 6
 
@@ -169,21 +336,112 @@ Running Cppcheck on a C++ Builder 6 project:
 
     cppcheck --project=foobar.bpr
 
+
+To ignore certain folders in the project you can use `-i`. This will skip analysis of source files in the `foo` folder.
+
+    cppcheck --project=foobar.bpr -ifoo
+
 ## Other
 
-If you can generate a compile database then it's possible to import that in Cppcheck.
+If you generate a compilation database, then it is possible to import that in Cppcheck.
+
+### Makefile
+
+In Linux you can convert a Makefile to a compile_commands.json using for instance `bear` (build ear) utility:
+
+    bear -- make
+
+If you don't use Linux; there are python scripts that converts a Makefile into a compilation database.
+
+# Preprocessor Settings
 
-In Linux you can use for instance the `bear` (build ear) utility to generate a compile database from arbitrary build tools:
+If you use `--project` then Cppcheck will automatically use the preprocessor settings in the imported project file and
+likely you don't have to configure anything extra.
 
-    bear make
+If you don't use `--project` then a bit of manual preprocessor configuration might be required. However Cppcheck has
+automatic configuration of defines.
+
+## Automatic configuration of preprocessor defines
+
+Cppcheck automatically test different combinations of preprocessor defines to achieve as high coverage in the analysis
+as possible.
+
+Here is a file that has 3 bugs (when x,y,z are assigned).
+
+    #ifdef A
+        x=100/0;
+        #ifdef B
+            y=100/0;
+        #endif
+    #else
+        z=100/0;
+    #endif
+
+    #ifndef C
+    #error C must be defined
+    #endif
+
+The flag `-D` tells Cppcheck that a name is defined. Cppcheck will only analyze configurations that
+contain this define.
+
+The flag `-U` tells Cppcheck that a name is not defined. Cppcheck will only analyze configurations
+that does not contain this define.
+
+The flag `--force` and `--max-configs` is used to control how many combinations are checked. When `-D` is used,
+Cppcheck will only check 1 configuration unless these are used.
+
+Example:
+
+    # test all configurations
+    # all bugs are found
+    cppcheck test.c
+
+    # only test configuration "-DA"
+    # No bug is found; because C is not defined the #error will cause a preprocessor error
+    cppcheck -DA test.c
+
+    # only test configuration "-DA -DC"
+    # The first bug is found
+    cppcheck -DA -DC test.c
+
+    # Test all configurations that does not define "A"
+    # The last bug is found
+    cppcheck -UA test.c
+
+    # All configurations with "-DA" are tested
+    # The two first bugs are found
+    cppcheck --force -DA test.c
+
+    # only test 1 valid configuration
+    # Bug(s) will be found
+    cppcheck --max-configs=1 test.c
+
+    # test 2 valid configurations with "X" defined.
+    # Bug(s) will be found
+    cppcheck --max-configs=2 -DX test.c
+
+## Include paths
+
+To add an include path, use `-I`, followed by the path.
+
+Cppcheck's preprocessor basically handles includes like any other preprocessor. However, while other preprocessors 
+stop working when they encounter a missing header, Cppcheck will just print an information message and continues 
+parsing the code.
+
+The purpose of this behaviour is that Cppcheck is meant to work without necessarily seeing the entire code. 
+Actually, it is recommended to not give all include paths. 
+While it is useful for Cppcheck to see the declaration of a class when checking the implementation of its members, 
+passing standard library headers is discouraged, because the analysis will not work fully and lead to a longer checking 
+time. For such cases, .cfg files are the preferred way to provide information about the implementation of functions and 
+types to Cppcheck, see below for more information.
 
 # Platform
 
-You should use a platform configuration that match your target.
+You should use a platform configuration that matches your target environment.
 
 By default Cppcheck uses native platform configuration that works well if your code is compiled and executed locally.
 
-Cppcheck has builtin configurations for Unix and Windows targets. You can easily use these with the --platform command line flag.
+Cppcheck has builtin configurations for Unix and Windows targets. You can easily use these with the `--platform` command line flag.
 
 You can also create your own custom platform configuration in a XML file. Here is an example:
 
@@ -205,94 +463,88 @@ You can also create your own custom platform configuration in a XML file. Here i
       </sizeof>
     </platform>
 
-# Preprocessor Settings
-
-If you use `--project` then Cppcheck will use the preprocessor settings from the imported project. Otherwise you'll probably want to configure the include paths, defines, etc.
-
-## Defines
-
-Here is a file that has 2 preprocessor configurations (with A defined and without A defined):
-
-    #ifdef A
-        x = y;
-    #else
-        x = z;
-    #endif
-
-By default Cppcheck will check all preprocessor configurations (except those that have #error in them). So the above code will by default be analyzed both with `A` defined and without `A` defined.
-
-You can use `-D` to change this. When you use `-D`, cppcheck will by default only check the given configuration and nothing else. This is how compilers work. But you can use `--force` or `--max-configs` to override the number of configurations.
-
-Check all configurations:
-
-    cppcheck file.c
-
-Only check the configuration A:
+# C/C++ Standard
 
-    cppcheck -DA file.c
+Use `--std` on the command line to specify a C/C++ standard.
 
-Check all configurations when macro A is defined
+Cppcheck assumes that the code is compatible with the latest C/C++ standard, but it is possible to override this.
 
-    cppcheck -DA --force file.c
+The available options are:
 
-Another useful flag might be `-U`. It tells Cppcheck that a macro is not defined. Example usage:
+- c89: C code is C89 compatible
+- c99: C code is C99 compatible
+- c11: C code is C11 compatible
+- c17: C code is C17 compatible
+- c23: C code is C23 compatible (default)
+- c++03: C++ code is C++03 compatible
+- c++11: C++ code is C++11 compatible
+- c++14: C++ code is C++14 compatible
+- c++17: C++ code is C++17 compatible
+- c++20: C++ code is C++20 compatible
+- c++23: C++ code is C++23 compatible
+- c++26: C++ code is C++26 compatible (default)
 
-    cppcheck -UX file.c
+# Cppcheck build dir
 
-That will mean that X is not defined. Cppcheck will not check what happens when X is defined.
+It's a good idea to use a Cppcheck build dir. On the command line use `--cppcheck-build-dir`. In
+the GUI, the build dir is configured in the project options.
 
-## Include paths
-
-To add an include path, use `-I`, followed by the path.
-
-Cppcheck's preprocessor basically handles includes like any other preprocessor. However, while other preprocessors stop working when they encounter a missing header, cppcheck will just print an information message and continues parsing the code.
+Rechecking code will be much faster. Cppcheck does not analyse unchanged code. The old warnings are
+loaded from the build dir and reported again.
 
-The purpose of this behaviour is that cppcheck is meant to work without necessarily seeing the entire code. Actually, it is recommended to not give all include paths. While it is useful for cppcheck to see the declaration of a class when checking the implementation of its members, passing standard library headers is highly discouraged because it will result in worse results and longer checking time. For such cases, .cfg files (see below) are the better way to provide information about the implementation of functions and types to cppcheck.
+Whole program analysis does not work when multiple threads are used; unless you use a cppcheck
+build dir. For instance, the unusedFunction warnings require whole program analysis.
 
 # Suppressions
 
-If you want to filter out certain errors you can suppress these.
+If you want to filter out certain errors from being generated, then it is possible to suppress these.
 
-Please note that if you see a false positive then we (the Cppcheck team) want that you report it so we can fix it.
+If you encounter a false positive, please report it to the Cppcheck team so that the issue can be
+fixed.
 
 ## Plain text suppressions
 
-You can suppress certain types of errors. The format for such a suppression is one of:
+The format for an error suppression is one of:
 
     [error id]:[filename]:[line]
     [error id]:[filename2]
     [error id]
 
-The `error id` is the id that you want to suppress. The easiest way to get it is to use the --template=gcc command line flag. The id is shown in brackets.
+The `error id` is the id that you want to suppress. The id of a warning is shown in brackets in the normal cppcheck text output.
 
-The filename may include the wildcard characters \* or ?, which match any sequence of characters or any single character respectively. It is recommended that you use "/" as path separator on all operating systems.
+The `error id` and `filename` patterns may contain `**`, `*` or `?`.  
+`**`: matches zero or more characters, including path separators  
+`*`: matches zero or more characters, excluding path separators  
+`?`: matches any single character except path separators
 
-## Command line suppression
+It is recommended to use forward-slash `/` in the filename pattern as path separator on all operating systems.
+
+### Command line suppression
 
 The `--suppress=` command line option is used to specify suppressions on the command line. Example:
 
     cppcheck --suppress=memleak:src/file1.cpp src/
 
-## Suppressions in a file
+### Suppressions in a file
 
-You can create a suppressions file. Example:
+You can create a suppressions file for example as follows:
 
     // suppress memleak and exceptNew errors in the file src/file1.cpp
     memleak:src/file1.cpp
     exceptNew:src/file1.cpp
 
-    // suppress all uninitvar errors in all files
-    uninitvar
+    uninitvar // suppress all uninitvar errors in all files
 
 Note that you may add empty lines and comments in the suppressions file.
+Comments must start with `#` or `//` and be at the start of the line, or after the suppression line.
 
-You can use the suppressions file like this:
+The usage of the suppressions file is as follows:
 
     cppcheck --suppressions-list=suppressions.txt src/
 
 ## XML suppressions
 
-You can specify suppressions in a XML file. Example file:
+You can specify suppressions in a XML file, for example as follows:
 
     <?xml version="1.0"?>
     <suppressions>
@@ -304,15 +556,21 @@ You can specify suppressions in a XML file. Example file:
       </suppress>
     </suppressions>
 
+The `id` and `fileName` patterns may contain `**`, `*` or `?`.
+`**`: matches zero or more characters, including path separators
+`*`: matches zero or more characters, excluding path separators
+`?`: matches any single character except path separators
+
 The XML format is extensible and may be extended with further attributes in the future.
 
-You can use the suppressions file like this:
+The usage of the suppressions file is as follows:
 
     cppcheck --suppress-xml=suppressions.xml src/
 
 ## Inline suppressions
 
-Suppressions can also be added directly in the code by adding comments that contain special keywords. Before adding such comments, consider that the code readability is sacrificed a little.
+Suppressions can also be added directly in the code by adding comments that contain special keywords. 
+Note that adding comments sacrifices the readability of the code somewhat.
 
 This code will normally generate an error message:
 
@@ -326,7 +584,60 @@ The output is:
     cppcheck test.c
     [test.c:3]: (error) Array 'arr[5]' index 10 out of bounds
 
-To suppress the error message, a comment can be added:
+To activate inline suppressions:
+
+    cppcheck --inline-suppr test.c
+
+### Format
+
+You can suppress a warning `aaaa` with:
+
+    // cppcheck-suppress aaaa
+
+Suppressing multiple ids in one comment by using []:
+
+    // cppcheck-suppress [aaaa, bbbb]
+
+Suppressing warnings `aaaa` on a block of code:
+
+    // cppcheck-suppress-begin aaaa
+    ...
+    // cppcheck-suppress-end aaaa
+
+Suppressing multiple ids on a block of code:
+
+    // cppcheck-suppress-begin [aaaa, bbbb]
+    ...
+    // cppcheck-suppress-end [aaaa, bbbb]
+
+Suppressing warnings `aaaa` for a whole file:
+
+    // cppcheck-suppress-file aaaa
+
+Suppressing multiple ids for a whole file:
+
+    // cppcheck-suppress-file [aaaa, bbbb]
+
+Suppressing warnings `aaaa` where macro is used:
+
+    // cppcheck-suppress-macro aaaa
+    #define MACRO ...
+    ...
+    x = MACRO; // <- aaaa warnings are suppressed here
+
+
+Suppressing multiple ids where macro is used:
+
+    // cppcheck-suppress-macro [aaaa, bbbb]
+    #define MACRO ...
+    ...
+    x = MACRO; // <- aaaa and bbbb warnings are suppressed here
+
+### Comment before code or on same line
+
+The comment can be put before the code or at the same line as the code.
+
+Before the code:
 
     void f() {
         char arr[5];
@@ -335,18 +646,93 @@ To suppress the error message, a comment can be added:
         arr[10] = 0;
     }
 
-Now the `--inline-suppr` flag can be used to suppress the warning. No error is reported when invoking cppcheck this way:
+Or at the same line as the code:
 
-    cppcheck --inline-suppr test.c
+    void f() {
+        char arr[5];
+
+        arr[10] = 0;  // cppcheck-suppress arrayIndexOutOfBounds
+    }
+
+The suppression comment and the line of code may be separated by additional comments or empty lines:
+
+    void f() {
+        char arr[5];
+
+        // cppcheck-suppress arrayIndexOutOfBounds
+
+        arr[10] = 0;
+
+        // cppcheck-suppress arrayIndexOutOfBounds
+        // Set the tenth element of arr to zero
+        arr[10] = 0;
+    }
+
+In the example below there are 2 lines with code and 1 suppression comment. The suppression comment only applies to 1 line: `a = b + c;`.
+
+    void f() {
+        a = b + c; // cppcheck-suppress abc
+        d = e + f;
+    }
+
+As a special case for backwards compatibility, if you have a `{` on its own line and a suppression comment after that, then that will suppress warnings for both the current and next line. This example will suppress `abc` warnings both for `{` and for `a = b + c;`:
+
+    void f()
+    { // cppcheck-suppress abc
+        a = b + c;
+    }
+
+### Multiple suppressions
+
+For a line of code there might be several warnings you want to suppress.
+
+There are several options;
+
+Using 2 suppression comments before code:
+
+    void f() {
+        char arr[5];
+
+        // cppcheck-suppress arrayIndexOutOfBounds
+        // cppcheck-suppress zerodiv
+        arr[10] = arr[10] / 0;
+    }
+
+Using 1 suppression comment before the code:
+
+    void f() {
+        char arr[5];
+
+        // cppcheck-suppress[arrayIndexOutOfBounds,zerodiv]
+        arr[10] = arr[10] / 0;
+    }
+
+Suppression comment on the same line as the code:
+
+    void f() {
+        char arr[5];
+
+        arr[10] = arr[10] / 0;  // cppcheck-suppress[arrayIndexOutOfBounds,zerodiv]
+    }
+
+
+### Symbol name
 
 You can specify that the inline suppression only applies to a specific symbol:
 
-    // cppcheck-suppress arrayIndexOutOfBounds symbolName=arr
+    // cppcheck-suppress aaaa symbolName=arr
 
-You can write comments for the suppress, however is recommended to use ; or // to specify where they start:
+Or:
 
-    // cppcheck-suppress arrayIndexOutOfBounds ; some comment
-    // cppcheck-suppress arrayIndexOutOfBounds // some comment
+    // cppcheck-suppress[aaaa symbolName=arr, bbbb]
+
+### Comment about suppression
+
+You can write comments about a suppression as follows:
+
+    // cppcheck-suppress[warningid] some comment
+    // cppcheck-suppress warningid ; some comment
+    // cppcheck-suppress warningid // some comment
 
 # XML output
 
@@ -375,7 +761,7 @@ Each error is reported in a `<error>` element. Attributes:
 
 **id**
 
-id of error. These are always valid symbolnames.
+id of error, and which are valid symbolnames
 
 **severity**
 
@@ -395,7 +781,11 @@ this attribute is only used when the error message is inconclusive
 
 **cwe**
 
-CWE ID for the problem. This attribute is only used when the CWE ID for the message is known.
+CWE ID for the problem; note that this attribute is only used when the CWE ID for the message is known
+
+**remark**
+
+Optional attribute. The related remark/justification from a remark comment.
 
 ## The `<location>` element
 
@@ -405,7 +795,7 @@ Attributes:
 
 **file**
 
-filename. both relative and absolute paths are possible.
+filename, both relative and absolute paths are possible
 
 **file0**
 
@@ -421,7 +811,7 @@ short information for each location (optional)
 
 # Reformatting the text output
 
-If you want to reformat the output so it looks different you can use templates.
+If you want to reformat the output so that it looks different, then you can use templates.
 
 ## Predefined output formats
 
@@ -432,7 +822,8 @@ To get Visual Studio compatible output you can use --template=vs:
 This output will look like this:
 
     Checking samples/arrayIndexOutOfBounds/bad.c ...
-    samples/arrayIndexOutOfBounds/bad.c(6): error: Array 'a[2]' accessed at index 2, which is out of bounds.
+    samples/arrayIndexOutOfBounds/bad.c(6): error: Array
+    'a[2]' accessed at index 2, which is out of bounds.
 
 To get gcc compatible output you can use --template=gcc:
 
@@ -441,29 +832,36 @@ To get gcc compatible output you can use --template=gcc:
 The output will look like this:
 
     Checking samples/arrayIndexOutOfBounds/bad.c ...
-    samples/arrayIndexOutOfBounds/bad.c:6:6: warning: Array 'a[2]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]
+    samples/arrayIndexOutOfBounds/bad.c:6:6: warning: Array
+    'a[2]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]
     a[2] = 0;
       ^
 
 ## User defined output format (single line)
 
-You can write your own pattern. For instance, to get warning messages that are formatted like old gcc such format can be used:
+You can write your own pattern. For instance:
 
-    cppcheck --template="{file}:{line}: {severity}: {message}" samples/arrayIndexOutOfBounds/bad.c
+    cppcheck \
+    --template="{file}:{line}:{column}: {severity}:{message}" \
+    samples/arrayIndexOutOfBounds/bad.c
 
-The output will look like this:
+The output will then look like this:
 
     Checking samples/arrayIndexOutOfBounds/bad.c ...
-    samples/arrayIndexOutOfBounds/bad.c:6: error: Array 'a[2]' accessed at index 2, which is out of bounds.
+    samples/arrayIndexOutOfBounds/bad.c:6:6: error: Array
+    'a[2]' accessed at index 2, which is out of bounds.
 
 A comma separated format:
 
-    cppcheck --template="{file},{line},{severity},{id},{message}" samples/arrayIndexOutOfBounds/bad.c
+    cppcheck \
+    --template="{file},{line},{severity},{id},{message}" \
+    samples/arrayIndexOutOfBounds/bad.c
 
 The output will look like this:
 
     Checking samples/arrayIndexOutOfBounds/bad.c ...
-    samples/arrayIndexOutOfBounds/bad.c,6,error,arrayIndexOutOfBounds,Array 'a[2]' accessed at index 2, which is out of bounds.
+    samples/arrayIndexOutOfBounds/bad.c,6,error,arrayIndexOutOfBounds,
+    Array 'a[2]' accessed at index 2, which is out of bounds.
 
 ## User defined output format (multi line)
 
@@ -481,11 +879,13 @@ Many warnings have multiple locations. Example code:
         return 0;
     }
 
-There is a possible null pointer dereference at line 3. Cppcheck can show how it came to that conclusion by showing extra location information. You need to use both --template and --template-location at the command line.
-
-Example command:
+There is a possible null pointer dereference at line 3. 
+Cppcheck can show how it came to that conclusion by showing extra location information. 
+You need to use both --template and --template-location at the command line, for example:
 
-    cppcheck --template="{file}:{line}: {severity}: {message}\n{code}" --template-location="{file}:{line}: note: {info}\n{code}" multiline.c
+    cppcheck \
+    --template="{file}:{line}: {severity}: {message}\n{code}" \
+    --template-location="{file}:{line}: note: {info}\n{code}" multiline.c
 
 The output from Cppcheck is:
 
@@ -529,7 +929,7 @@ Write all locations. Each location is written in [{file}:{line}] format and the
 
 **{inconclusive:text}**
 
-If warning is inconclusive then the given text is written. The given text can be any arbitrary text that does not contain }. Example: {inconclusive:inconclusive,}
+If warning is inconclusive, then the given text is written. The given text can be any text that does not contain }. Example: {inconclusive:inconclusive,}
 
 **{severity}**
 
@@ -543,9 +943,13 @@ The warning message
 
 Warning id
 
+**{remark}**
+
+The remark text if a remark comment has been provided
+
 **{code}**
 
-The real code.
+The real code
 
 **\\t**
 
@@ -577,11 +981,11 @@ Column number
 
 **{info}**
 
-Information message about current location
+Information message about the current location
 
 **{code}**
 
-The real code.
+The real code
 
 **\\t**
 
@@ -595,60 +999,204 @@ Newline
 
 Carriage return
 
-# Addons
+# Justifications for warnings in the report
 
-Addons are scripts with extra checks. Cppcheck is distributed with a few addons.
+You can add remark comments in the source code that justify why there is a warning/violation.
 
-## Running Addons
+Such a remark comment shall:
+
+- start with REMARK.
+- can either be added above the source code that generates the warning, or after the code on the same line.
+
+Example code:
 
-Addons are standalone scripts that are executed separately.
+    void foo(void) {
+        // REMARK Initialize x with 0
+        int x = 0;
+    }
+
+In Cppcheck text output the remarks are not shown by default, you can use `--template` option `{remark}` to show remarks:
+
+    $ ./cppcheck --enable=style \
+    --template="{file}:{line}: {message} [{id}]\\n{remark}" test1.c
+
+    Checking test1.c ...
+    test1.c:4: Variable 'x' is assigned a value that is never used. [unreadVariable]
+    Initialize x with 0
+
+In xml output the comment text is provided in a "remark" attribute:
+
+    $ ./cppcheck --enable=style --xml test1.c
+    ....
+    remark="Initialize x with 0"
+    ....
+
+# Addons
 
-To manually run an addon:
+Addons are scripts that analyse Cppcheck dump files to check compatibility with secure coding standards and to locate issues.
 
-    cppcheck --dump somefile.c
-    python misc.py somefile.c.dump
+Cppcheck is distributed with a few addons which are listed below.
 
-To run the same addon through Cppcheck directly:
+## Supported addons
 
-    cppcheck --addon=misc.py somefile.c
+### misra.py
 
-Some addons need extra arguments. For example misra.py can be executed manually like this:
+[misra.py](https://github.com/danmar/cppcheck/blob/main/addons/misra.py) is used to verify compliance with MISRA C 2012, a proprietary set of guidelines to avoid questionable code, developed for embedded systems.
 
-    cppcheck --dump somefile.c
-    python misra.py --rule-texts=misra.txt somefile.c.dump
+The misra.py script does not provide rule texts, those should be downloaded from [MISRA](https://gitlab.com/MISRA/MISRA-C/MISRA-C-2012/tools)
 
-You can configure how you want to execute an addon in a json file, for example put this in misra.json:
+To load the rule texts, create a configuration file. Example `misra.json`:
 
     {
         "script": "misra.py",
-        "args": [ "--rule-texts=misra.txt" ]
+        "args": [
+            "--rule-texts=misra_c_2012__headlines_for_cppcheck - AMD1+AMD2.txt"
+        ],
+        "ctu": true
     }
 
-And then the configuration can be executed on the cppcheck command line:
+To use that `misra.json` in Cppcheck analysis, use option `--addon=misra.json`:
 
-    cppcheck --addon=misra.json somefile.c
+    cppcheck --addon=misra.json --enable=style somefile.c
 
-## Help about an addon
+Misra checkers in open source Cppcheck only cover MISRA rules partially and for full coverage use Cppcheck Premium.
 
-You can read about how to use a Cppcheck addon by looking in the addon. The comments at the top of the file should have a description.
+### namingng.py
 
-# Library configuration
+[namingng.py](https://github.com/danmar/cppcheck/blob/main/addons/namingng.py) allows you to configure and check naming conventions.
+
+You need to have a configuration file that defines your naming conventions. By default the filename `namingng.config.json` is used but there is an option so you can use any filename you want.
+
+Example configuration of naming conventions:
+```
+{
+   "RE_VARNAME": ["[a-z]*[a-zA-Z0-9_]*\\Z"],
+   "RE_PRIVATE_MEMBER_VARIABLE": null,
+   "RE_FUNCTIONNAME": ["[a-z0-9A-Z]*\\Z"],
+   "_comment": "comments can be added to the config with underscore-prefixed keys",
+   "include_guard": {
+       "input": "path",
+       "prefix": "GUARD_",
+       "case": "upper",
+       "max_linenr": 5,
+       "RE_HEADERFILE": "[^/].*\\.h\\Z",
+       "required": true
+   },
+   "var_prefixes": {"uint32_t": "ui32"},
+   "function_prefixes": {"uint16_t": "ui16",
+                         "uint32_t": "ui32"}
+}
+```
+
+### threadsafety.py
+
+[threadsafety.py](https://github.com/danmar/cppcheck/blob/main/addons/threadsafety.py) analyses Cppcheck dump files to locate thread safety issues like static local objects used by multiple threads.
+
+### y2038.py
+
+[y2038.py](https://github.com/danmar/cppcheck/blob/main/addons/y2038.py) checks source code for [year 2038 problem](https://en.wikipedia.org/wiki/Year_2038_problem) safety.
+
+## Running Addons
+
+Addons can be executed with the `--addon` option:
+
+    cppcheck --addon=namingng.py somefile.c
+
+Likewise, if you have created your own script you can execute that:
 
-When external libraries are used, such as WinAPI, POSIX, gtk, Qt, etc, Cppcheck doesn't know how the external functions behave. Cppcheck then fails to detect various problems such as leaks, buffer overflows, possible null pointer dereferences, etc. But this can be fixed with configuration files.
+    cppcheck --addon=mychecks.py somefile.c
+
+You can configure how you want to execute an addon in a json file. For example:
+
+    {
+        "script": "mychecks.py",
+        "args": [
+            "--some-option"
+        ],
+        "ctu": false
+    }
 
-Cppcheck already contains configurations for several libraries. They can be loaded as described below. Note that the configuration for the standard libraries of C and C++, std.cfg, is always loaded by cppcheck. If you create or update a configuration file for a popular library, we would appreciate if you upload it to us.
+To use that json file to execute your addon use the --addon option:
 
-## Using your own custom .cfg file
+    cppcheck --addon=mychecks.json somefile.c
 
-You can create and use your own .cfg files for your projects. Use `--check-library` and `--enable=information` to get hints about what you should configure.
+Cppcheck search for addons in the local folder first and then in the installation folder. A different path can be specified explicitly, for instance:
+
+    cppcheck --addon=path/to/my-addon.py somefile.c
+
+# Library configuration
+
+When external libraries are used, such as WinAPI, POSIX, gtk, Qt, etc, Cppcheck has no information about functions, types, or macros contained in those libraries. Cppcheck then fails to detect various problems in the code, or might even abort the analysis. But this can be fixed by using the appropriate configuration files.
+
+Cppcheck already contains configurations for several libraries. They can be loaded as described below. Note that the configuration for the standard libraries of C and C++, std.cfg, is always loaded by cppcheck. If you create or update a configuration file for a popular library, we would appreciate if you supplied it to the cppcheck project.
+
+## Using a .cfg file
+
+To use a .cfg file shipped with cppcheck, pass the `--library=<lib>` option. The table below shows the currently existing libraries:
+
+| .cfg file         | Library       | Comment       |
+| ----------------- | ------------- | ------------- |
+| avr.cfg           |               |               |
+| bento4.cfg        | [Bento4](http://www.bento4.com/) | |
+| boost.cfg         | [Boost](http://www.boost.org/) | |
+| bsd.cfg           | [BSD](https://www.freebsd.org/) | |
+| cairo.cfg         | [cairo](https://www.cairographics.org/) | |
+| cppcheck-lib.cfg  | [Cppcheck](http://cppcheck.net/) | Used in selfcheck of |
+|                   |               |the Cppcheck code base |
+| cppunit.cfg       | [CppUnit](https://sourceforge.net/projects/cppunit/) | |
+| dpdk.cfg          |               |               |
+| embedded_sql.cfg  |               |               |
+| emscripten.cfg | | |
+| ginac.cfg | | |
+| gnu.cfg | [GNU](https://www.gnu.org/) | |
+| googletest.cfg | [GoogleTest](https://github.com/google/googletest) | |
+| gtk.cfg | [GTK](https://www.gtk.org/) | |
+| icu.cfg | | |
+| kde.cfg | [KDE](https://kde.org/) | |
+| libcerror.cfg | [libcerror](https://github.com/libyal/libcerror) | |
+| libcurl.cfg | [libcurl](https://curl.se/libcurl/) | |
+| libsigc++.cfg | [libsigc++](https://github.com/libsigcplusplus/libsigcplusplus) | |
+| lua.cfg | | |
+| mfc.cfg | [MFC](https://learn.microsoft.com/en-us/cpp/mfc/mfc-desktop-applications) | |
+| microsoft_atl.cfg | [ATL](https://learn.microsoft.com/en-us/cpp/atl/active-template-library-atl-concepts) | |
+| microsoft_sal.cfg | [SAL annotations](https://learn.microsoft.com/en-us/cpp/c-runtime-library/sal-annotations) | |
+| microsoft_unittest.cfg | [CppUnitTest](https://learn.microsoft.com/en-us/visualstudio/test/microsoft-visualstudio-testtools-cppunittestframework-api-reference) | |
+| motif.cfg | | |
+| nspr.cfg | | |
+| ntl.cfg | | |
+| opencv2.cfg | [OpenCV](https://opencv.org/) | |
+| opengl.cfg | [OpenGL](https://opengl.org/) | |
+| openmp.cfg | [OpenMP](https://www.openmp.org/) | |
+| openssl.cfg | [OpenSSL](https://www.openssl.org/) | |
+| pcre.cfg | [PCRE](https://pcre.org/) | |
+| posix.cfg | [POSIX](https://pubs.opengroup.org/onlinepubs/9699919799/) | |
+| python.cfg | | |
+| qt.cfg | [Qt](https://doc.qt.io/qt.html) | |
+| ruby.cfg | | |
+| sdl.cfg | | |
+| sfml.cfg | | |
+| sqlite3.cfg | [SQLite](https://www.sqlite.org/) | |
+| std.cfg | C/C++ standard library | Loaded by default |
+| tinyxml2.cfg | [TinyXML-2](https://github.com/leethomason/tinyxml2) | |
+| vcl.cfg | | |
+| windows.cfg | [Win32 API](https://learn.microsoft.com/en-us/windows/win32/) | |
+| wxsqlite3.cfg | | |
+| wxsvg.cfg | | |
+| wxwidgets.cfg | [wxWidgets](https://www.wxwidgets.org/) | |
+| zephyr.cfg | | |
+| zlib.cfg | [zlib](https://www.zlib.net) | |
+
+## Creating a custom .cfg file
+
+You can create and use your own .cfg files for your projects. Use `--check-library` to get hints about what you should configure.
 
 You can use the `Library Editor` in the `Cppcheck GUI` to edit configuration files. It is available in the `View` menu.
 
-The .cfg file format is documented in the `Reference: Cppcheck .cfg format` (http://cppcheck.sf.net/reference-cfg-format.pdf) document.
+The .cfg file format is documented in the `Reference: Cppcheck .cfg format` (https://cppcheck.sourceforge.io/reference-cfg-format.pdf) document.
 
 # HTML Report
 
-You can convert the XML output from cppcheck into a HTML report. You'll need Python and the pygments module (<http://pygments.org/)> for this to work. In the Cppcheck source tree there is a folder htmlreport that contains a script that transforms a Cppcheck XML file into HTML output.
+You can convert the XML output from Cppcheck into a HTML report. You'll need Python and the pygments module (<http://pygments.org/>) for this to work. In the Cppcheck source tree there is a folder htmlreport that contains a script that transforms a Cppcheck XML file into HTML output.
 
 This command generates the help screen:
 
@@ -664,10 +1212,94 @@ The output screen says:
                        Default is reading from stdin.
        --report-dir=REPORT_DIR
                        The directory where the html report content is written.
-       --source-dir=SOURCE_DIR
-                       Base directory where source code files can be found.
+       --source-dir=SOURCE_DIR|URL
+                       Base directory where source code files can be found, or
+                       a URL to a remote GitHub/GitLab repository including a
+                       branch, e.g.:
+                         --source-dir=https://github.com/<username>/<repo>/blob/<branch>/
+
+Example usage:
+
+    cppcheck gui/test.cpp --xml 2> err.xml
+    cppcheck-htmlreport --file=err.xml --report-dir=test1 --source-dir=.
+
+or
+    cppcheck gui/test.cpp --xml 2> err.xml
+    cppcheck-htmlreport --file=err.xml --report-dir=test1 \
+         --source-dir=https://github.com/<username>/<repo>/blob/<branch>/
+
+## Choosing Between Local Annotated HTML and Remote Repository Links
+
+cppcheck-htmlreport supports two modes for linking to source files:
+ - Local annotated HTML files (default when `--source-dir` is a filesystem path)
+ - Remote GitHub/GitLab links (when `--source-dir` is a URL)
+
+Pointing `--source-dir` to a filesystem path generates local annotated HTML files.
+This is useful when you need a fully self-contained report that works offline,
+includes inline annotations, and is ideal for small or medium projects where
+generation is fast.
+Using a remote GitHub/GitLab URL avoids generating per-file HTML and keeps the
+summary report lightweight and fast to produce. This mode is ideal when the
+source is already hosted online and local duplication is unnecessary.
+Remote mode is especially helpful when the HTML report may be public or widely
+distributed but the source code should remain private, since access control is
+handled by the hosting service.
+In general, local mode fits air-gapped environments, while remote mode works
+best for CI workflows and large or private repositories.
+
+# Check Level
+
+## Reduced
+
+The "reduced" check level performs a limited data flow analysis. If developers
+want to run cppcheck directly during development and require faster results
+than "normal" provides then this reduced checking can be an option.
+
+## Normal
+
+The "normal" check level is chosen by default. Our aim is that this checking level will provide an effective checking in "reasonable" time.
+
+The "normal" check level should be useful during active development:
+
+- checking files while you edit them.
+- block changes to the repo
+- etc
+
+## Exhaustive
+
+When you can wait longer for the results you can enable the "exhaustive" checking, by using the option `--check-level=exhaustive`.
+
+Exhaustive checking level should be useful for scenarios where you can wait for results. For instance:
+
+- nightly builds
+- etc
+
+# Speeding up analysis
+
+## Limit preprocessor configurations
+
+For performance reasons it might be a good idea to limit preprocessor configurations to check.
+
+## Limit ValueFlow: max if count
+
+The command line option `--performance-valueflow-max-if-count` adjusts the max count for number of if in a function.
+
+When that limit is exceeded there is a limitation of data flow in that function. It is not drastic:
+
+- Analysis of other functions are not affected.
+- It's only for some specific data flow analysis, we have data flow analysis that is always executed.
+- All checks are always executed. There can still be plenty of warnings in the limited function.
+
+There is data flow analysis that slows down exponentially when number of if increase. And the limit is intended to avoid that
+analysis time explodes.
+
+## GUI options
+
+In the GUI there are various options to limit analysis.
+
+In the GUI:
 
-An example usage:
+- Open the project dialog.
+- In the "Analysis" tab there are several options.
 
-    ./cppcheck gui/test.cpp --xml 2> err.xml
-    htmlreport/cppcheck-htmlreport --file=err.xml --report-dir=test1 --source-dir=.
+If you want to use these limitations on the command line also you can import the GUI project file with --project.
diff --git a/man/reference-cfg-format.md b/man/reference-cfg-format.md
index 8e24e949744..3067d0a8f2c 100644
--- a/man/reference-cfg-format.md
+++ b/man/reference-cfg-format.md
@@ -1,9 +1,8 @@
 ---
 title: Cppcheck .cfg format
-subtitle: Version 1.90 dev
+subtitle: Version 2.21 dev
 author: Cppcheck team
 lang: en
-toc: true
 documentclass: report
 ---
 
@@ -90,7 +89,7 @@ If instead `dostuff` takes care of the memory then this can be configured with:
       </memory>
     </def>
 
-The `<use>` configuration has no logical purpose. You will get the same warnings without it. Use it to silence --check-library information messages.
+The `<use>` configuration has no logical purpose. You will get the same warnings without it. Use it to silence `--check-library` information messages.
 
 # Function behavior
 
@@ -157,21 +156,40 @@ If you provide a configuration file then Cppcheck detects the bug:
     Checking uninit.c...
     [uninit.c:5]: (error) Uninitialized variable: buffer2
 
-Note that this implies for pointers that the memory they point at has to be initialized, too.
+Below windows.cfg is shown:
 
-Here is the minimal windows.cfg:
+Version 1:
 
     <?xml version="1.0"?>
     <def>
       <function name="CopyMemory">
         <arg nr="1"/>
         <arg nr="2">
+          <not-null/>
           <not-uninit/>
         </arg>
         <arg nr="3"/>
       </function>
     </def>
 
+Version 2:
+
+    <?xml version="1.0"?>
+    <def>
+      <function name="CopyMemory">
+        <arg nr="1"/>
+        <arg nr="2">
+          <not-uninit indirect="2"/>
+        </arg>
+        <arg nr="3"/>
+      </function>
+    </def>
+
+
+Version 1: If `indirect` attribute is not used then the level of indirection is determined automatically. The `<not-null/>` tells Cppcheck that the pointer must be initialized. The `<not-uninit/>` tells Cppcheck to check 1 extra level. This configuration means that both the pointer and the data must be initialized.
+
+Version 2: The `indirect` attribute can be set to explicitly control the level of indirection used in checking. Setting `indirect` to `0` means no uninitialized memory is allowed. Setting it to `1` allows a pointer to uninitialized memory. Setting it to `2` allows a pointer to pointer to uninitialized memory.
+
 ### Null pointers
 
 Cppcheck assumes it's ok to pass NULL pointers to functions. Here is an example program:
@@ -245,6 +263,21 @@ printf - format string follows the printf rules
 
 scanf - format string follows the scanf rules
 
+### Container inputs
+
+If this is a free function for containers(like for `std::size` or `std::erase_if`) then the `<container>` tag can be used to specify the `yield` or `action`. Here is an example of `std::size`:
+
+    <function name="std::size">
+        <noreturn>false</noreturn>
+        <use-retval/>
+        <leak-ignore/>
+        <container yields="size"/>
+        <returnValue type="size_t"/>
+        <arg nr="1" direction="in">
+            <not-uninit/>
+        </arg>
+    </function>
+
 ### Value range
 
 The valid values can be defined. Imagine:
@@ -284,6 +317,7 @@ Some example expressions you can use in the valid element:
 0:  =>  all values that are greater or equal to 0 are valid
 0,2:32  =>  the value 0 and all values between 2 and 32 are valid
 -1.5:5.6  =>  all values between -1.5 and 5.6 are valid
+!0.0  =>  all values are accepted, except 0.0
 
 ### `<minsize>`
 
@@ -363,9 +397,9 @@ In theory, if ZeroMemory terminates the program then there is no bug. Cppcheck t
     $ cppcheck noreturn.c
     Checking noreturn.c...
 
-However if you use `--check-library` and `--enable=information` you'll get this:
+However if you use `--check-library` you'll get this:
 
-    $ cppcheck --check-library --enable=information noreturn.c
+    $ cppcheck --check-library noreturn.c
     Checking noreturn.c...
     [noreturn.c:7]: (information) --check-library: Function ZeroMemory() should have <noreturn> configuration
 
@@ -484,6 +518,24 @@ The first argument that the function takes is a pointer. It must not be a null p
 
 The second argument the function takes is a pointer. It must not be null. And it must point at initialized data. Using `<not-null>` and `<not-uninit>` is correct. Moreover it must point at a zero-terminated string so `<strz>` is also used.
 
+# `<type-checks>`; check or suppress
+
+The `<type-checks>`configuration tells Cppcheck to show or suppress warnings for a certain type.
+
+Example:
+
+    <?xml version="1.0"?>
+    <def>
+      <type-checks>
+        <unusedvar>
+          <check>foo</check>
+          <suppress>bar</suppress>
+        </unusedvar>
+      </type-checks>
+    </def>
+
+In the `unusedvar` checking the `foo` type will be checked. Warnings for `bar` type variables will be suppressed.
+
 # `<define>`
 
 Libraries can be used to define preprocessor macros as well. For example:
@@ -527,6 +579,10 @@ The size of the type is specified in bytes. Possible values for the "sign" attri
 
 A lot of C++ libraries, among those the STL itself, provide containers with very similar functionality. Libraries can be used to tell cppcheck about their behaviour. Each container needs a unique ID. It can optionally have a startPattern, which must be a valid Token::Match pattern and an endPattern that is compared to the linked token of the first token with such a link. The optional attribute "inherits" takes an ID from a previously defined container.
 
+The `hasInitializerListConstructor` attribute can be set when the container has a constructor taking an initializer list.
+
+The `view` attribute can be set when the container is a view, which means it borrows the lifetime of another container.
+
 Inside the `<container>` tag, functions can be defined inside of the tags `<size>`, `<access>` and `<other>` (on your choice). Each of them can specify an action like "resize" and/or the result it yields, for example "end-iterator".
 
 The following example provides a definition for std::vector, based on the definition of "stdContainer" (not shown):
diff --git a/man/writing-addons.md b/man/writing-addons.md
new file mode 100644
index 00000000000..e593c2e9cce
--- /dev/null
+++ b/man/writing-addons.md
@@ -0,0 +1,408 @@
+---
+title: Writing addons
+subtitle: Version 2.21 dev
+author: Cppcheck team
+lang: en
+documentclass: report
+---
+
+# Introduction
+
+This document provides an overview about writing Cppcheck addons.
+
+
+# Overview of data
+
+## Tokens
+
+See class `Token` in cppcheckdata.py
+
+Cppcheck splits the code up in tokens: operators, numbers, identifiers, etc.
+
+Example C code:
+
+    ab = a + b;
+
+Addon code:
+
+    import cppcheck
+
+    @cppcheck.checker
+    def func(cfg, data):
+        for token in cfg.tokenlist:
+            print(token.str)
+
+Output:
+
+    $ cppcheck --dump test.c
+    $ python3 runaddon.py myaddon.py test.c.dump
+    Checking 1.c.dump...
+    Checking 1.c.dump, config ...
+    ab
+    =
+    a
+    +
+    b
+    ;
+
+The `cfg.tokenlist` does not always match the raw input code exactly. For instance:
+ * The `cfg.tokenlist` is preprocessed.
+ * There is no typedefs in `cfg.tokenlist`.
+ * C++ templates are instantiated when possible in `cfg.tokenlist`.
+ * Variable declarations are sometimes split up.
+ * If you don't write {} around the body for a if/else/while/for etc then those are inserted in the `cfg.tokenlist`.
+ * ...
+
+There are various properties in the `Token` class and some of those will be discussed below.
+
+
+## AST - Abstract syntax tree
+
+Cppcheck creates a syntax tree for every expression.
+
+Example C code:
+
+    ab = a + b;
+
+Addon code:
+
+    import cppcheck
+
+    @cppcheck.checker
+    def func(cfg, data):
+        for token in cfg.tokenlist:
+            out = token.str
+            if token.astParent:
+                out += f' parent:"{token.astParent.str}"'
+            if token.astOperand1:
+                out += f' astOperand1:"{token.astOperand1.str}"'
+            if token.astOperand2:
+                out += f' astOperand2:"{token.astOperand2.str}"'
+            print(out)
+
+Output:
+
+    $ cppcheck --dump test.c
+    $ python3 runaddon.py myaddon.py test.c.dump
+    Checking 1.c.dump...
+    Checking 1.c.dump, config ...
+    ab parent:"="
+    = astOperand1:"ab" astOperand2:"+"
+    a parent:"+"
+    + parent:"=" astOperand1:"a" astOperand2:"b"
+    b parent:"+"
+    ;
+
+## ValueType
+
+Data type of expressions are provided by `class ValueType` in cppcheckdata.py.
+
+Example C code:
+
+    short a;
+    a = a + 10;
+
+Addon code:
+
+    import cppcheck
+
+    @cppcheck.checker
+    def func(cfg, data):
+        for token in cfg.tokenlist:
+            print(f'{token.str} : {token.valueType}')
+
+Output:
+
+    $ cppcheck --dump test.c
+    $ python3 runaddon.py myaddon.py test.c.dump
+    Checking 1.c.dump...
+    Checking 1.c.dump, config ...
+    short : None
+    a : ValueType(type='short', sign='signed', bits=0, typeScopeId=None, originalTypeName=None, constness=0, pointer=0)
+    ; : None
+    a : ValueType(type='short', sign='signed', bits=0, typeScopeId=None, originalTypeName=None, constness=0, pointer=0)
+    = : ValueType(type='short', sign='signed', bits=0, typeScopeId=None, originalTypeName=None, constness=0, pointer=0)
+    a : ValueType(type='short', sign='signed', bits=0, typeScopeId=None, originalTypeName=None, constness=0, pointer=0)
+    + : ValueType(type='int', sign='signed', bits=0, typeScopeId=None, originalTypeName=None, constness=0, pointer=0)
+    10 : ValueType(type='int', sign='signed', bits=0, typeScopeId=None, originalTypeName=None, constness=0, pointer=0)
+    ; : None
+
+The `pointer` property is a simple counter.
+
+    int p    =>  pointer=0
+    int *p   =>  pointer=1
+    int **p  =>  pointer=2
+
+The `constness` property is a bitmask.
+
+    int * *                     =>  constness=0
+    const int * *               =>  constness=1
+    int * const *               =>  constness=2
+    int * * const               =>  constness=4
+    const int * const *         =>  constness=3
+    const int * const * const   =>  constness=7
+
+
+## Variable
+
+Information about a variable is provided by `class Variable` in cppcheckdata.py.
+
+Example code:
+
+    short a[10];
+    a[0] = 0;
+
+
+Addon code:
+
+    import cppcheck
+    
+    @cppcheck.checker
+    def func(cfg, data):
+        for token in cfg.tokenlist:
+            print(f'{token.str} : {token.variable}')
+
+Output:
+
+    $ cppcheck --dump test.c
+    $ python3 runaddon.py myaddon.py test.c.dump
+    Checking 1.c.dump...
+    Checking 1.c.dump, config ...
+    a : Variable(Id='0x55f432fc1580', nameTokenId='0x55f432fe0850', typeStartTokenId='0x55f432fc0eb0', typeEndTokenId='0x55f432fc0eb0', access='Global', scopeId='0x55f432fe0360', isArgument=False, isArray=True, isClass=False, isConst=False, isGlobal=True, isExtern=False, isLocal=False, isPointer=False, isReference=False, isStatic=False, constness=0)
+    [ : None
+    10 : None
+    ] : None
+    ; : None
+    a : Variable(Id='0x55f432fc1580', nameTokenId='0x55f432fe0850', typeStartTokenId='0x55f432fc0eb0', typeEndTokenId='0x55f432fc0eb0', access='Global', scopeId='0x55f432fe0360', isArgument=False, isArray=True, isClass=False, isConst=False, isGlobal=True, isExtern=False, isLocal=False, isPointer=False, isReference=False, isStatic=False, constness=0)
+    [ : None
+    0 : None
+    ] : None
+    = : None
+    0 : None
+    ; : None
+
+
+## Scope
+
+See `class Scope` in cppcheckdata.py.
+
+Every token is in some scope.
+
+If you see {} in the code then that is a scope of some kind. There is one scope that is not surrounded by {}; the global scope.
+
+Example c code:
+
+    int x;
+    void foo()
+    {
+        if (x)
+        {
+            x = 0;
+        }
+    }
+
+Example addon #1 (list all scopes):
+
+    import cppcheck
+    
+    @cppcheck.checker
+    def func(cfg, data):
+        for scope in cfg.scopes:
+            print(scope.type)
+    
+Output:
+
+    $ cppcheck --dump test.c
+    $ python3 runaddon.py myaddon.py test.c.dump
+    Checking 1.c.dump...
+    Checking 1.c.dump, config ...
+    Global
+    Function
+    If
+
+Example addon #2 (show scope for each token):
+
+    import cppcheck
+    
+    @cppcheck.checker
+    def func(cfg, data):
+        for token in cfg.tokenlist:
+            print(f'{token.str} : {scope.type}')
+    
+Output:
+
+    $ cppcheck --dump test.c
+    $ python3 runaddon.py myaddon.py test.c.dump
+    Checking 1.c.dump...
+    Checking 1.c.dump, config ...
+    int : Global
+    x : Global
+    ; : Global
+    void : Global
+    foo : Global
+    ( : Global
+    ) : Global
+    { : Function
+    if : Function
+    ( : Function
+    x : Function
+    ) : Function
+    { : If
+    x : If
+    = : If
+    0 : If
+    ; : If
+    } : If
+    } : Function
+    
+### Special tokenlist tweaks and else if
+
+The `cfg.tokenlist` has some tweaks. In C/C++ code it is optional to use `{` and `}` around the if/else/for/while body,
+if the body is only a single statement. However Cppcheck adds "{" and "}" tokens if those are missing.
+
+One more tweak is that in cfg.tokenlist there is no "else if" scope.
+
+Example C code:
+
+    void foo(int x)
+    {
+        if (x > 0)
+            --x;
+        else if (x < 0)
+            ++x;
+    }
+
+The tokens in the `cfg.tokenlist` will look like this:
+
+    void foo(int x)
+    {
+        if (x > 0)
+        {
+            --x;
+        }
+        else
+        {
+            if (x < 0)
+            {
+                ++x;
+            }
+        }
+    }
+
+And there are 2 "If" scopes here. And 1 "Else" scope.
+
+
+## Function
+
+The class `Function` in cppcheckdata.py represents a function that is declared somewhere.
+
+Example code:
+
+    void foo(int x);
+
+    void bar()
+    {
+        foo(1);
+    }
+
+
+Example addon #1:
+
+    import cppcheck
+    
+    @cppcheck.checker
+    def func(cfg, data):
+        for token in cfg.tokenlist:
+            print(f'{token.str} : {token.function}')
+    
+Output:
+
+    void : None
+    foo : Function(Id='0x55c5f9330f60', tokenId='0', tokenDefId='0x55c5f93510d0', name='foo', type='Function', isVirtual=False, isImplicitlyVirtual=False, isInlineKeyword=False, isStatic=False, argumentId={1: '0x55c5f9351260'})
+    ( : None
+    int : None
+    x : None
+    ) : None
+    ; : None
+    void : None
+    bar : Function(Id='0x55c5f9331040', tokenId='0x55c5f93314a0', tokenDefId='0x55c5f93314a0', name='bar', type='Function', isVirtual=False, isImplicitlyVirtual=False, isInlineKeyword=False, isStatic=False, argumentId={})
+    ( : None
+    ) : None
+    { : None
+    foo : Function(Id='0x55c5f9330f60', tokenId='0', tokenDefId='0x55c5f93510d0', name='foo', type='Function', isVirtual=False, isImplicitlyVirtual=False, isInlineKeyword=False, isStatic=False, argumentId={1: '0x55c5f9351260'})
+    ( : None
+    1 : None
+    ) : None
+    ; : None
+    } : None
+    
+
+## Value flow
+
+For Cppcheck, by default variables and expressions have "unknown" values. If the value is only constrained by the data type that is typically not enough information to write warnings with precision. Unless all the values possible in the data type are bad.
+
+In Cppcheck terminology an expression will have a "possible" value if Cppcheck can determine that there will be a specific value in some control flow paths.
+
+In Cppcheck terminology an expression will have a "known" value if Cppcheck can determine that there will be a specific value in all control flow paths.
+
+An expression can have several "possible" values. But it can't have several "known" values.
+
+Example code:
+
+    void foo(int x)  // <- values of x is only constrained by data type. there are no "possible" or "known" values here.
+    {
+        a = x;  // <- assuming that condition below is not redundant, x can have value 2.
+        if (x == 2)
+        {
+            b = x + 2;  // <- value of x is always 2 when this code is executed. It's "known".
+        }
+        else
+        {
+            c = x;
+        }
+        d = x + 10;  // <- value of x can be 2 when this code is executed. It's "possible".
+    }
+
+Addon:
+
+    import cppcheck
+    
+    @cppcheck.checker
+    def func(cfg, data):
+        for token in cfg.tokenlist:
+            if token.values:
+                print(f'line {token.linenr} str="{token.str}"')
+                for value in token.values:
+                    print(f'    {value}')
+
+Output:
+
+    $ ../cppcheck --dump 1.c ; python3 runaddon.py myaddon.py 1.c.dump 
+    Checking 1.c ...
+    Checking 1.c.dump...
+    Checking 1.c.dump, config ...
+    line 3 str="="
+        Value(intvalue=2, tokvalue=None, floatvalue=None, containerSize=None, condition=4, valueKind='possible', inconclusive=False)
+    line 3 str="x"
+        Value(intvalue=2, tokvalue=None, floatvalue=None, containerSize=None, condition=4, valueKind='possible', inconclusive=False)
+    line 4 str="2"
+        Value(intvalue=2, tokvalue=None, floatvalue=None, containerSize=None, condition=None, valueKind='known', inconclusive=False)
+    line 6 str="="
+        Value(intvalue=4, tokvalue=None, floatvalue=None, containerSize=None, condition=4, valueKind='known', inconclusive=False)
+    line 6 str="x"
+        Value(intvalue=2, tokvalue=None, floatvalue=None, containerSize=None, condition=4, valueKind='known', inconclusive=False)
+    line 6 str="+"
+        Value(intvalue=4, tokvalue=None, floatvalue=None, containerSize=None, condition=4, valueKind='known', inconclusive=False)
+    line 6 str="2"
+        Value(intvalue=2, tokvalue=None, floatvalue=None, containerSize=None, condition=None, valueKind='known', inconclusive=False)
+    line 12 str="="
+        Value(intvalue=12, tokvalue=None, floatvalue=None, containerSize=None, condition=4, valueKind='possible', inconclusive=False)
+    line 12 str="x"
+        Value(intvalue=2, tokvalue=None, floatvalue=None, containerSize=None, condition=4, valueKind='possible', inconclusive=False)
+    line 12 str="+"
+        Value(intvalue=12, tokvalue=None, floatvalue=None, containerSize=None, condition=4, valueKind='possible', inconclusive=False)
+    line 12 str="10"
+        Value(intvalue=10, tokvalue=None, floatvalue=None, containerSize=None, condition=None, valueKind='known', inconclusive=False)
+    
+If the value is determined from a condition then the attribute `condition` points out the line that has the condition.
+
diff --git a/man/writing-rules-3.docbook b/man/writing-rules-3.docbook
index cb5b56787f2..76792cd069b 100644
--- a/man/writing-rules-3.docbook
+++ b/man/writing-rules-3.docbook
@@ -185,7 +185,7 @@ void CheckOther::invalidFunctionUsage()
                     {
                         // convert next token into a number
                         MathLib::bigint radix;
-                        radix = MathLib::toLongNumber(tok2-&gt;strAt(1));
+                        radix = MathLib::toBigNumber(tok2-&gt;strAt(1));
 
                         // invalid radix?
                         if (!(radix == 0 || (radix &gt;= 2 &amp;&amp; radix &lt;= 36)))
diff --git a/naming.json b/naming.json
index ef93af6d0a4..ca8bfe8a392 100644
--- a/naming.json
+++ b/naming.json
@@ -1,8 +1,9 @@
 {
     "script": "addons/naming.py",
     "args": [
-        "--private-member-variable=m[A-Z].*"
-        "--var=[a-z].*",
-        "--function=[a-z].*"
+        "--private-member-variable=m[A-Z].*",
+        "--var=[_a-z].*",
+        "--const=[_a-zA-Z].*",
+        "--function=[a-zA-Z].*"
     ]
 }
diff --git a/oss-fuzz/Makefile b/oss-fuzz/Makefile
index 81cf654222c..5055ba71a8e 100644
--- a/oss-fuzz/Makefile
+++ b/oss-fuzz/Makefile
@@ -1,24 +1,376 @@
-#
-# fuzzer clients
-# ====================
-#
-# Local libfuzzer client:
-# make CXX=clang++-6.0 CXXFLAGS="-fsanitize=address" fuzz-client
+# This file is generated by dmake, do not edit.
 
-CPPCHECK_DIR=..
-INCLUDE_DIR=-I ${CPPCHECK_DIR}/lib -I ${CPPCHECK_DIR}/externals/simplecpp -I ${CPPCHECK_DIR}/externals/tinyxml -I ${CPPCHECK_DIR}/externals
-SRC_FILES=main.cpp type2.cpp ${CPPCHECK_DIR}/externals/simplecpp/simplecpp.cpp ${CPPCHECK_DIR}/externals/tinyxml/tinyxml2.cpp ${CPPCHECK_DIR}/lib/*.cpp
+# make CXX=clang++ MATCHCOMPILER=yes CXXOPTS="-O1 -fno-omit-frame-pointer -gline-tables-only -fsanitize=address -fsanitize-address-use-after-scope" CPPOPTS="-DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION -DHAVE_BOOST" LIB_FUZZING_ENGINE="-fsanitize=fuzzer" oss-fuzz-client
 
-all:	oss-fuzz-client	translate
+MATCHCOMPILER=yes
+ifndef MATCHCOMPILER
+    MATCHCOMPILER=
+endif
+# use match compiler
+ifeq ($(MATCHCOMPILER),yes)
+    # Find available Python interpreter
+    ifeq ($(PYTHON_INTERPRETER),)
+        PYTHON_INTERPRETER := $(shell which python3)
+    endif
+    ifeq ($(PYTHON_INTERPRETER),)
+        PYTHON_INTERPRETER := $(shell which python)
+    endif
+    ifeq ($(PYTHON_INTERPRETER),)
+        $(error Did not find a Python interpreter)
+    endif
+    ifdef VERIFY
+        matchcompiler_S := $(shell $(PYTHON_INTERPRETER) ../tools/matchcompiler.py --read-dir ../lib --verify)
+    else
+        matchcompiler_S := $(shell $(PYTHON_INTERPRETER) ../tools/matchcompiler.py --read-dir ../lib)
+    endif
+    libcppdir:=build
+else ifeq ($(MATCHCOMPILER),)
+    libcppdir:=lib
+else
+    $(error invalid MATCHCOMPILER value '$(MATCHCOMPILER)')
+endif
 
-oss-fuzz-client:	main.cpp	type2.cpp	type2.h
-	${CXX} -std=c++11 -g ${CXXFLAGS} -o oss-fuzz-client ${INCLUDE_DIR} ${SRC_FILES} -lFuzzingEngine
+INCS=-I../lib -isystem../externals/simplecpp -isystem../externals/tinyxml2 -isystem../externals/picojson
 
-fuzz-client:	main.cpp	type2.cpp	type2.h
-	${CXX} -std=c++11 -g -O1 ${CXXFLAGS} -fsanitize=fuzzer -o fuzz-client ${INCLUDE_DIR} ${SRC_FILES}
+override CXXFLAGS+=-std=c++11 -g -w
+override CPPFLAGS+=$(INCS)
 
-translate:	translate.cpp	type2.cpp	type2.h
-	g++ -o translate type2.cpp translate.cpp
+override CXXFLAGS += $(CXXOPTS)
+override CPPFLAGS += $(CPPOPTS)
+override LDFLAGS += $(LDOPTS)
+
+LIBOBJ =      $(libcppdir)/valueflow.o \
+              $(libcppdir)/tokenize.o \
+              $(libcppdir)/symboldatabase.o \
+              $(libcppdir)/addoninfo.o \
+              $(libcppdir)/analyzerinfo.o \
+              $(libcppdir)/astutils.o \
+              $(libcppdir)/check.o \
+              $(libcppdir)/check64bit.o \
+              $(libcppdir)/checkassert.o \
+              $(libcppdir)/checkautovariables.o \
+              $(libcppdir)/checkbool.o \
+              $(libcppdir)/checkbufferoverrun.o \
+              $(libcppdir)/checkclass.o \
+              $(libcppdir)/checkcondition.o \
+              $(libcppdir)/checkers.o \
+              $(libcppdir)/checkersidmapping.o \
+              $(libcppdir)/checkersreport.o \
+              $(libcppdir)/checkexceptionsafety.o \
+              $(libcppdir)/checkfunctions.o \
+              $(libcppdir)/checkinternal.o \
+              $(libcppdir)/checkio.o \
+              $(libcppdir)/checkleakautovar.o \
+              $(libcppdir)/checkmemoryleak.o \
+              $(libcppdir)/checknullpointer.o \
+              $(libcppdir)/checkother.o \
+              $(libcppdir)/checkpostfixoperator.o \
+              $(libcppdir)/checksizeof.o \
+              $(libcppdir)/checkstl.o \
+              $(libcppdir)/checkstring.o \
+              $(libcppdir)/checktype.o \
+              $(libcppdir)/checkuninitvar.o \
+              $(libcppdir)/checkunusedfunctions.o \
+              $(libcppdir)/checkunusedvar.o \
+              $(libcppdir)/checkvaarg.o \
+              $(libcppdir)/clangimport.o \
+              $(libcppdir)/color.o \
+              $(libcppdir)/cppcheck.o \
+              $(libcppdir)/ctu.o \
+              $(libcppdir)/errorlogger.o \
+              $(libcppdir)/errortypes.o \
+              $(libcppdir)/findtoken.o \
+              $(libcppdir)/forwardanalyzer.o \
+              $(libcppdir)/fwdanalysis.o \
+              $(libcppdir)/importproject.o \
+              $(libcppdir)/infer.o \
+              $(libcppdir)/keywords.o \
+              $(libcppdir)/library.o \
+              $(libcppdir)/mathlib.o \
+              $(libcppdir)/path.o \
+              $(libcppdir)/pathanalysis.o \
+              $(libcppdir)/pathmatch.o \
+              $(libcppdir)/platform.o \
+              $(libcppdir)/preprocessor.o \
+              $(libcppdir)/programmemory.o \
+              $(libcppdir)/regex.o \
+              $(libcppdir)/reverseanalyzer.o \
+              $(libcppdir)/sarifreport.o \
+              $(libcppdir)/settings.o \
+              $(libcppdir)/standards.o \
+              $(libcppdir)/summaries.o \
+              $(libcppdir)/suppressions.o \
+              $(libcppdir)/templatesimplifier.o \
+              $(libcppdir)/timer.o \
+              $(libcppdir)/token.o \
+              $(libcppdir)/tokenlist.o \
+              $(libcppdir)/utils.o \
+              $(libcppdir)/vf_analyzers.o \
+              $(libcppdir)/vf_common.o \
+              $(libcppdir)/vf_settokenvalue.o \
+              $(libcppdir)/vfvalue.o
+
+EXTOBJ =      simplecpp.o \
+              tinyxml2.o
+
+oss-fuzz-client: $(EXTOBJ) $(LIBOBJ) main.o type2.o
+	${CXX} ${CXXFLAGS} -o $@ $^ ${LIB_FUZZING_ENGINE}
+
+no-fuzz: $(EXTOBJ) $(LIBOBJ) main_nofuzz.o type2.o
+	${CXX} ${CXXFLAGS} -o $@ $^
+
+translate: translate.o type2.o
+	${CXX} -std=c++11 -g ${CXXFLAGS} -o $@ type2.cpp translate.cpp
 
 clean:
-	rm -f oss-fuzz-client fuzz-client translate
+	rm -f *.o build/*.o oss-fuzz-client no-fuzz translate
+
+preprare-samples:
+	rm -rf samples
+	mkdir -p samples
+	cp -R ../samples .
+	find ./samples -type f -name '*.txt' -exec rm -vf {} \;
+
+do-fuzz: oss-fuzz-client preprare-samples
+	mkdir -p corpus
+	./oss-fuzz-client -only_ascii=1 -timeout=5 -detect_leaks=0 corpus samples ../test/cli/fuzz-crash ../test/cli/fuzz-crash_c ../test/cli/fuzz-timeout
+
+dedup-corpus: oss-fuzz-client preprare-samples
+	mv corpus corpus_
+	mkdir -p corpus
+	./oss-fuzz-client -only_ascii=1 -timeout=5 -detect_leaks=0 corpus corpus_ samples ../test/cli/fuzz-crash ../test/cli/fuzz-crash_c ../test/cli/fuzz-timeout -merge=1
+
+# jobs:
+# ./oss-fuzz-client -only_ascii=1 -timeout=5 -detect_leaks=0 corpus samples ../test/cli/fuzz-crash ../test/cli/fuzz-crash_c ../test/cli/fuzz-timeout -workers=12 -jobs=9
+
+# minimize:
+# ./oss-fuzz-client -only_ascii=1 -timeout=5 -detect_leaks=0 -minimize_crash=1 crash-0123456789abcdef
+
+simplecpp.o: ../externals/simplecpp/simplecpp.cpp ../externals/simplecpp/simplecpp.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -w -c -o $@ ../externals/simplecpp/simplecpp.cpp
+
+tinyxml2.o: ../externals/tinyxml2/tinyxml2.cpp ../externals/tinyxml2/tinyxml2.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -w -D_LARGEFILE_SOURCE -c -o $@ ../externals/tinyxml2/tinyxml2.cpp
+
+$(libcppdir)/valueflow.o: ../lib/valueflow.cpp ../lib/addoninfo.h ../lib/analyzer.h ../lib/astutils.h ../lib/calculate.h ../lib/check.h ../lib/checkers.h ../lib/checkuninitvar.h ../lib/config.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/findtoken.h ../lib/forwardanalyzer.h ../lib/infer.h ../lib/library.h ../lib/mathlib.h ../lib/path.h ../lib/platform.h ../lib/programmemory.h ../lib/reverseanalyzer.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/timer.h ../lib/token.h ../lib/tokenlist.h ../lib/utils.h ../lib/valueflow.h ../lib/valueptr.h ../lib/vf_analyzers.h ../lib/vf_common.h ../lib/vf_settokenvalue.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/valueflow.cpp
+
+$(libcppdir)/tokenize.o: ../lib/tokenize.cpp ../externals/simplecpp/simplecpp.h ../lib/addoninfo.h ../lib/astutils.h ../lib/checkers.h ../lib/config.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/path.h ../lib/platform.h ../lib/preprocessor.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/summaries.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/timer.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/valueflow.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/tokenize.cpp
+
+$(libcppdir)/symboldatabase.o: ../lib/symboldatabase.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/checkers.h ../lib/config.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/keywords.h ../lib/library.h ../lib/mathlib.h ../lib/path.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/valueflow.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/symboldatabase.cpp
+
+$(libcppdir)/addoninfo.o: ../lib/addoninfo.cpp ../externals/picojson/picojson.h ../lib/addoninfo.h ../lib/config.h ../lib/json.h ../lib/path.h ../lib/standards.h ../lib/utils.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/addoninfo.cpp
+
+$(libcppdir)/analyzerinfo.o: ../lib/analyzerinfo.cpp ../externals/tinyxml2/tinyxml2.h ../lib/analyzerinfo.h ../lib/config.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/filesettings.h ../lib/mathlib.h ../lib/path.h ../lib/platform.h ../lib/standards.h ../lib/utils.h ../lib/xml.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/analyzerinfo.cpp
+
+$(libcppdir)/astutils.o: ../lib/astutils.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkclass.h ../lib/checkers.h ../lib/config.h ../lib/errortypes.h ../lib/findtoken.h ../lib/infer.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/utils.h ../lib/valueflow.h ../lib/valueptr.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/astutils.cpp
+
+$(libcppdir)/check.o: ../lib/check.cpp ../lib/addoninfo.h ../lib/check.h ../lib/checkers.h ../lib/config.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/standards.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/check.cpp
+
+$(libcppdir)/check64bit.o: ../lib/check64bit.cpp ../lib/addoninfo.h ../lib/check.h ../lib/check64bit.h ../lib/checkers.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/check64bit.cpp
+
+$(libcppdir)/checkassert.o: ../lib/checkassert.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkassert.h ../lib/checkers.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkassert.cpp
+
+$(libcppdir)/checkautovariables.o: ../lib/checkautovariables.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkautovariables.h ../lib/checkers.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/valueflow.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkautovariables.cpp
+
+$(libcppdir)/checkbool.o: ../lib/checkbool.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkbool.h ../lib/checkers.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkbool.cpp
+
+$(libcppdir)/checkbufferoverrun.o: ../lib/checkbufferoverrun.cpp ../externals/tinyxml2/tinyxml2.h ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkbufferoverrun.h ../lib/checkers.h ../lib/config.h ../lib/ctu.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/path.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/valueflow.h ../lib/vfvalue.h ../lib/xml.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkbufferoverrun.cpp
+
+$(libcppdir)/checkclass.o: ../lib/checkclass.cpp ../externals/tinyxml2/tinyxml2.h ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkclass.h ../lib/checkers.h ../lib/config.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/path.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h ../lib/xml.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkclass.cpp
+
+$(libcppdir)/checkcondition.o: ../lib/checkcondition.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkcondition.h ../lib/checkers.h ../lib/checkother.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkcondition.cpp
+
+$(libcppdir)/checkers.o: ../lib/checkers.cpp ../lib/checkers.h ../lib/config.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkers.cpp
+
+$(libcppdir)/checkersidmapping.o: ../lib/checkersidmapping.cpp ../lib/checkers.h ../lib/config.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkersidmapping.cpp
+
+$(libcppdir)/checkersreport.o: ../lib/checkersreport.cpp ../lib/addoninfo.h ../lib/checkers.h ../lib/checkersreport.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/standards.h ../lib/utils.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkersreport.cpp
+
+$(libcppdir)/checkexceptionsafety.o: ../lib/checkexceptionsafety.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkers.h ../lib/checkexceptionsafety.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkexceptionsafety.cpp
+
+$(libcppdir)/checkfunctions.o: ../lib/checkfunctions.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkers.h ../lib/checkfunctions.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/valueflow.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkfunctions.cpp
+
+$(libcppdir)/checkinternal.o: ../lib/checkinternal.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkers.h ../lib/checkinternal.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkinternal.cpp
+
+$(libcppdir)/checkio.o: ../lib/checkio.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkers.h ../lib/checkio.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkio.cpp
+
+$(libcppdir)/checkleakautovar.o: ../lib/checkleakautovar.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkers.h ../lib/checkleakautovar.h ../lib/checkmemoryleak.h ../lib/checknullpointer.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkleakautovar.cpp
+
+$(libcppdir)/checkmemoryleak.o: ../lib/checkmemoryleak.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkers.h ../lib/checkmemoryleak.h ../lib/config.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkmemoryleak.cpp
+
+$(libcppdir)/checknullpointer.o: ../lib/checknullpointer.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkers.h ../lib/checknullpointer.h ../lib/config.h ../lib/ctu.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/findtoken.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/valueflow.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checknullpointer.cpp
+
+$(libcppdir)/checkother.o: ../lib/checkother.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkers.h ../lib/checkother.h ../lib/config.h ../lib/errortypes.h ../lib/fwdanalysis.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/valueflow.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkother.cpp
+
+$(libcppdir)/checkpostfixoperator.o: ../lib/checkpostfixoperator.cpp ../lib/addoninfo.h ../lib/check.h ../lib/checkers.h ../lib/checkpostfixoperator.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkpostfixoperator.cpp
+
+$(libcppdir)/checksizeof.o: ../lib/checksizeof.cpp ../lib/addoninfo.h ../lib/check.h ../lib/checkers.h ../lib/checksizeof.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checksizeof.cpp
+
+$(libcppdir)/checkstl.o: ../lib/checkstl.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkers.h ../lib/checknullpointer.h ../lib/checkstl.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/pathanalysis.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/valueflow.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkstl.cpp
+
+$(libcppdir)/checkstring.o: ../lib/checkstring.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkers.h ../lib/checkstring.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkstring.cpp
+
+$(libcppdir)/checktype.o: ../lib/checktype.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkers.h ../lib/checktype.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/valueflow.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checktype.cpp
+
+$(libcppdir)/checkuninitvar.o: ../lib/checkuninitvar.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkers.h ../lib/checknullpointer.h ../lib/checkuninitvar.h ../lib/config.h ../lib/ctu.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkuninitvar.cpp
+
+$(libcppdir)/checkunusedfunctions.o: ../lib/checkunusedfunctions.cpp ../externals/tinyxml2/tinyxml2.h ../lib/addoninfo.h ../lib/analyzerinfo.h ../lib/astutils.h ../lib/checkers.h ../lib/checkunusedfunctions.h ../lib/config.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/path.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h ../lib/xml.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkunusedfunctions.cpp
+
+$(libcppdir)/checkunusedvar.o: ../lib/checkunusedvar.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkers.h ../lib/checkunusedvar.h ../lib/config.h ../lib/errortypes.h ../lib/fwdanalysis.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/valueflow.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkunusedvar.cpp
+
+$(libcppdir)/checkvaarg.o: ../lib/checkvaarg.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/check.h ../lib/checkers.h ../lib/checkvaarg.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/checkvaarg.cpp
+
+$(libcppdir)/clangimport.o: ../lib/clangimport.cpp ../lib/clangimport.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/clangimport.cpp
+
+$(libcppdir)/color.o: ../lib/color.cpp ../lib/color.h ../lib/config.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/color.cpp
+
+$(libcppdir)/cppcheck.o: ../lib/cppcheck.cpp ../externals/picojson/picojson.h ../externals/simplecpp/simplecpp.h ../lib/addoninfo.h ../lib/analyzerinfo.h ../lib/check.h ../lib/checkers.h ../lib/checkunusedfunctions.h ../lib/clangimport.h ../lib/color.h ../lib/config.h ../lib/cppcheck.h ../lib/ctu.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/filesettings.h ../lib/json.h ../lib/library.h ../lib/mathlib.h ../lib/path.h ../lib/platform.h ../lib/preprocessor.h ../lib/regex.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/suppressions.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/timer.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/valueflow.h ../lib/version.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/cppcheck.cpp
+
+$(libcppdir)/ctu.o: ../lib/ctu.cpp ../externals/tinyxml2/tinyxml2.h ../lib/astutils.h ../lib/check.h ../lib/config.h ../lib/ctu.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/path.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h ../lib/xml.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/ctu.cpp
+
+$(libcppdir)/errorlogger.o: ../lib/errorlogger.cpp ../externals/tinyxml2/tinyxml2.h ../lib/addoninfo.h ../lib/check.h ../lib/checkers.h ../lib/color.h ../lib/config.h ../lib/cppcheck.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/path.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/standards.h ../lib/suppressions.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h ../lib/xml.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/errorlogger.cpp
+
+$(libcppdir)/errortypes.o: ../lib/errortypes.cpp ../lib/config.h ../lib/errortypes.h ../lib/utils.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/errortypes.cpp
+
+$(libcppdir)/findtoken.o: ../lib/findtoken.cpp ../lib/astutils.h ../lib/config.h ../lib/errortypes.h ../lib/findtoken.h ../lib/library.h ../lib/mathlib.h ../lib/smallvector.h ../lib/standards.h ../lib/templatesimplifier.h ../lib/token.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/findtoken.cpp
+
+$(libcppdir)/forwardanalyzer.o: ../lib/forwardanalyzer.cpp ../lib/addoninfo.h ../lib/analyzer.h ../lib/astutils.h ../lib/checkers.h ../lib/config.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/forwardanalyzer.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenlist.h ../lib/utils.h ../lib/valueptr.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/forwardanalyzer.cpp
+
+$(libcppdir)/fwdanalysis.o: ../lib/fwdanalysis.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/checkers.h ../lib/config.h ../lib/errortypes.h ../lib/fwdanalysis.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/fwdanalysis.cpp
+
+$(libcppdir)/importproject.o: ../lib/importproject.cpp ../externals/picojson/picojson.h ../externals/tinyxml2/tinyxml2.h ../lib/addoninfo.h ../lib/checkers.h ../lib/config.h ../lib/errortypes.h ../lib/filesettings.h ../lib/importproject.h ../lib/json.h ../lib/library.h ../lib/mathlib.h ../lib/path.h ../lib/pathmatch.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/standards.h ../lib/suppressions.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h ../lib/xml.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/importproject.cpp
+
+$(libcppdir)/infer.o: ../lib/infer.cpp ../lib/calculate.h ../lib/config.h ../lib/errortypes.h ../lib/infer.h ../lib/mathlib.h ../lib/smallvector.h ../lib/templatesimplifier.h ../lib/token.h ../lib/utils.h ../lib/valueptr.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/infer.cpp
+
+$(libcppdir)/keywords.o: ../lib/keywords.cpp ../lib/config.h ../lib/keywords.h ../lib/standards.h ../lib/utils.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/keywords.cpp
+
+$(libcppdir)/library.o: ../lib/library.cpp ../externals/tinyxml2/tinyxml2.h ../lib/astutils.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/path.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h ../lib/xml.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/library.cpp
+
+$(libcppdir)/mathlib.o: ../lib/mathlib.cpp ../externals/simplecpp/simplecpp.h ../lib/config.h ../lib/errortypes.h ../lib/mathlib.h ../lib/smallvector.h ../lib/templatesimplifier.h ../lib/token.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/mathlib.cpp
+
+$(libcppdir)/path.o: ../lib/path.cpp ../externals/simplecpp/simplecpp.h ../lib/config.h ../lib/path.h ../lib/standards.h ../lib/utils.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/path.cpp
+
+$(libcppdir)/pathanalysis.o: ../lib/pathanalysis.cpp ../lib/astutils.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/pathanalysis.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/pathanalysis.cpp
+
+$(libcppdir)/pathmatch.o: ../lib/pathmatch.cpp ../lib/config.h ../lib/path.h ../lib/pathmatch.h ../lib/standards.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/pathmatch.cpp
+
+$(libcppdir)/platform.o: ../lib/platform.cpp ../externals/tinyxml2/tinyxml2.h ../lib/config.h ../lib/mathlib.h ../lib/path.h ../lib/platform.h ../lib/standards.h ../lib/utils.h ../lib/xml.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/platform.cpp
+
+$(libcppdir)/preprocessor.o: ../lib/preprocessor.cpp ../externals/simplecpp/simplecpp.h ../lib/addoninfo.h ../lib/checkers.h ../lib/config.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/path.h ../lib/platform.h ../lib/preprocessor.h ../lib/settings.h ../lib/standards.h ../lib/suppressions.h ../lib/utils.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/preprocessor.cpp
+
+$(libcppdir)/programmemory.o: ../lib/programmemory.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/calculate.h ../lib/checkers.h ../lib/config.h ../lib/errortypes.h ../lib/infer.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/programmemory.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenlist.h ../lib/utils.h ../lib/valueflow.h ../lib/valueptr.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/programmemory.cpp
+
+$(libcppdir)/regex.o: ../lib/regex.cpp ../lib/config.h ../lib/regex.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/regex.cpp
+
+$(libcppdir)/reverseanalyzer.o: ../lib/reverseanalyzer.cpp ../lib/addoninfo.h ../lib/analyzer.h ../lib/astutils.h ../lib/checkers.h ../lib/config.h ../lib/errortypes.h ../lib/forwardanalyzer.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/reverseanalyzer.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/utils.h ../lib/valueptr.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/reverseanalyzer.cpp
+
+$(libcppdir)/sarifreport.o: ../lib/sarifreport.cpp ../externals/picojson/picojson.h ../lib/addoninfo.h ../lib/check.h ../lib/checkers.h ../lib/config.h ../lib/cppcheck.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/json.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/sarifreport.h ../lib/settings.h ../lib/standards.h ../lib/utils.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/sarifreport.cpp
+
+$(libcppdir)/settings.o: ../lib/settings.cpp ../externals/picojson/picojson.h ../lib/addoninfo.h ../lib/checkers.h ../lib/config.h ../lib/errortypes.h ../lib/json.h ../lib/library.h ../lib/mathlib.h ../lib/path.h ../lib/platform.h ../lib/settings.h ../lib/standards.h ../lib/summaries.h ../lib/suppressions.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/settings.cpp
+
+$(libcppdir)/standards.o: ../lib/standards.cpp ../externals/simplecpp/simplecpp.h ../lib/config.h ../lib/standards.h ../lib/utils.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/standards.cpp
+
+$(libcppdir)/summaries.o: ../lib/summaries.cpp ../lib/addoninfo.h ../lib/analyzerinfo.h ../lib/checkers.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/path.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/summaries.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/summaries.cpp
+
+$(libcppdir)/suppressions.o: ../lib/suppressions.cpp ../externals/tinyxml2/tinyxml2.h ../lib/addoninfo.h ../lib/checkers.h ../lib/config.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/filesettings.h ../lib/library.h ../lib/mathlib.h ../lib/path.h ../lib/pathmatch.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/standards.h ../lib/suppressions.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h ../lib/xml.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/suppressions.cpp
+
+$(libcppdir)/templatesimplifier.o: ../lib/templatesimplifier.cpp ../lib/addoninfo.h ../lib/checkers.h ../lib/config.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/standards.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenize.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/templatesimplifier.cpp
+
+$(libcppdir)/timer.o: ../lib/timer.cpp ../lib/config.h ../lib/timer.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/timer.cpp
+
+$(libcppdir)/token.o: ../lib/token.cpp ../externals/simplecpp/simplecpp.h ../lib/addoninfo.h ../lib/astutils.h ../lib/checkers.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenlist.h ../lib/tokenrange.h ../lib/utils.h ../lib/valueflow.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/token.cpp
+
+$(libcppdir)/tokenlist.o: ../lib/tokenlist.cpp ../externals/simplecpp/simplecpp.h ../lib/addoninfo.h ../lib/astutils.h ../lib/checkers.h ../lib/config.h ../lib/errorlogger.h ../lib/errortypes.h ../lib/keywords.h ../lib/library.h ../lib/mathlib.h ../lib/path.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/standards.h ../lib/templatesimplifier.h ../lib/token.h ../lib/tokenlist.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/tokenlist.cpp
+
+$(libcppdir)/utils.o: ../lib/utils.cpp ../lib/config.h ../lib/utils.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/utils.cpp
+
+$(libcppdir)/vf_analyzers.o: ../lib/vf_analyzers.cpp ../lib/addoninfo.h ../lib/analyzer.h ../lib/astutils.h ../lib/calculate.h ../lib/checkers.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/programmemory.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/utils.h ../lib/valueflow.h ../lib/valueptr.h ../lib/vf_analyzers.h ../lib/vf_common.h ../lib/vf_settokenvalue.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/vf_analyzers.cpp
+
+$(libcppdir)/vf_common.o: ../lib/vf_common.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/checkers.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/path.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/utils.h ../lib/vf_common.h ../lib/vf_settokenvalue.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/vf_common.cpp
+
+$(libcppdir)/vf_settokenvalue.o: ../lib/vf_settokenvalue.cpp ../lib/addoninfo.h ../lib/astutils.h ../lib/calculate.h ../lib/checkers.h ../lib/config.h ../lib/errortypes.h ../lib/library.h ../lib/mathlib.h ../lib/platform.h ../lib/settings.h ../lib/smallvector.h ../lib/sourcelocation.h ../lib/standards.h ../lib/symboldatabase.h ../lib/templatesimplifier.h ../lib/token.h ../lib/utils.h ../lib/valueflow.h ../lib/vf_common.h ../lib/vf_settokenvalue.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/vf_settokenvalue.cpp
+
+$(libcppdir)/vfvalue.o: ../lib/vfvalue.cpp ../lib/config.h ../lib/errortypes.h ../lib/mathlib.h ../lib/smallvector.h ../lib/templatesimplifier.h ../lib/token.h ../lib/utils.h ../lib/vfvalue.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $(libcppdir)/vfvalue.cpp
+
+
+type2.o: type2.cpp type2.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ type2.cpp
+
+translate.o: translate.cpp type2.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ translate.cpp
+
+main.o: main.cpp type2.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ main.cpp
+
+main_nofuzz.o: main.cpp type2.h
+	$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -DNO_FUZZ -c -o $@ main.cpp
diff --git a/oss-fuzz/main.cpp b/oss-fuzz/main.cpp
index c564a97879b..e1bd5952966 100644
--- a/oss-fuzz/main.cpp
+++ b/oss-fuzz/main.cpp
@@ -1,44 +1,107 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
 
 #include "cppcheck.h"
-#include "type2.h"
+#include "errorlogger.h"
+#include "errortypes.h"
+#include "filesettings.h"
+#include "settings.h"
+#include "suppressions.h"
+
+#include <string>
 
+#ifndef NO_FUZZ
+#include <cstddef>
+#include <cstdint>
 
-class CppcheckExecutor : public ErrorLogger {
-private:
-    CppCheck cppcheck;
+#include "type2.h"
+#else
+#include <cstdlib>
+#include <fstream>
+#include <sstream>
+#endif
 
+class DummyErrorLogger : public ErrorLogger {
 public:
-    CppcheckExecutor()
-        : ErrorLogger()
-        , cppcheck(*this, false) {
-        cppcheck.settings().addEnabled("all");
-        cppcheck.settings().inconclusive = true;
-    }
+    void reportOut(const std::string& /*outmsg*/, Color /*c*/) override {}
+    void reportErr(const ErrorMessage& /*msg*/) override {}
+    void reportProgress(const std::string& /*filename*/,
+                        const char /*stage*/[],
+                        const std::size_t /*value*/) override {}
+    void reportMetric(const std::string & /*metric*/) override {}
+};
 
-    void run(const std::string &code) {
-        cppcheck.check("test.cpp", code);
-    }
+static Settings create_settings()
+{
+    // TODO: load std.cfg
+    Settings s;
+    s.templateFormat = "{bold}{file}:{line}:{column}: {red}{inconclusive:{magenta}}{severity}:{inconclusive: inconclusive:}{default} {message} [{id}]{reset}\\n{code}";
+    s.templateLocation = "{bold}{file}:{line}:{column}: {dim}note:{reset} {info}\\n{code}";
+    s.addEnabled("all");
+    s.certainty.setEnabled(Certainty::inconclusive, true);
+    return s;
+}
+static const Settings s_settings = create_settings();
+static DummyErrorLogger s_errorLogger;
+static const FileWithDetails s_file("test.cpp", Standards::Language::CPP, 0);
 
-    void reportOut(const std::string &outmsg) { }
-    void reportErr(const ErrorLogger::ErrorMessage &msg) {}
-    void reportProgress(const std::string& filename,
-                        const char stage[],
-                        const unsigned int value) {}
-};
+static void doCheck(const uint8_t *data, size_t dataSize)
+{
+    Suppressions supprs;
+    CppCheck cppcheck(s_settings, supprs, s_errorLogger, nullptr, false, nullptr);
+    cppcheck.checkBuffer(s_file, reinterpret_cast<const char*>(data), dataSize);
+}
 
+#ifndef NO_FUZZ
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t dataSize);
 
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t dataSize)
+int LLVMFuzzerTestOneInput(const uint8_t *data, size_t dataSize)
 {
     if (dataSize < 10000) {
         const std::string code = generateCode2(data, dataSize);
-        //std::ofstream fout("code.cpp");
-        //fout << code;
-        //fout.close();
-
-        CppcheckExecutor cppcheckExecutor;
-        cppcheckExecutor.run(code);
+        doCheck(reinterpret_cast<const unsigned char*>(code.data()), code.size());
     }
     return 0;
 }
+#else
+int main(int argc, char * argv[])
+{
+    if (argc < 2 || argc > 3)
+        return EXIT_FAILURE;
+
+    std::ifstream f(argv[1]);
+    if (!f.is_open())
+        return EXIT_FAILURE;
+
+    std::ostringstream oss;
+    oss << f.rdbuf();
+
+    if (!f.good())
+        return EXIT_FAILURE;
+
+    const int cnt = (argc == 3) ? std::stoi(argv[2]) : 1;
+
+    const std::string code = oss.str();
+    for (int i = 0; i < cnt; ++i)
+        doCheck(reinterpret_cast<const unsigned char*>(code.data()), code.size());
+
+    return EXIT_SUCCESS;
+}
+#endif
 
 
diff --git a/oss-fuzz/translate.cpp b/oss-fuzz/translate.cpp
index 6167ffceddd..5ebddd269fe 100644
--- a/oss-fuzz/translate.cpp
+++ b/oss-fuzz/translate.cpp
@@ -1,6 +1,23 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2022 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
 
-#include <fstream>
 #include <iostream>
+#include <fstream>
 
 #include "type2.h"
 
@@ -22,7 +39,7 @@ int main(int argc, char **argv)
     std::string str((std::istreambuf_iterator<char>(f)),
                     std::istreambuf_iterator<char>());
 
-    std::cout << generateCode2((const uint8_t *)str.data(), str.size()) << std::endl;
+    std::cout << generateCode2(reinterpret_cast<const uint8_t *>(str.data()), str.size()) << std::endl;
 
     return 0;
 }
diff --git a/oss-fuzz/type2.cpp b/oss-fuzz/type2.cpp
index d5cc04d151f..e337864ed6c 100644
--- a/oss-fuzz/type2.cpp
+++ b/oss-fuzz/type2.cpp
@@ -1,8 +1,24 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
 
-#include <sstream>
 #include "type2.h"
 
-
+#include <cstring>
 
 static int getValue(const uint8_t *data, size_t dataSize, uint8_t maxValue, bool *done = nullptr)
 {
@@ -35,27 +51,28 @@ static std::string generateExpression2_lvalue(const uint8_t *data, size_t dataSi
     return "var" + std::to_string(1 + getValue(data, dataSize, 5));
 }
 
-static std::string generateExpression2_Op(const uint8_t *data, size_t dataSize, int numberOfGlobalConstants)
+static std::string generateExpression2_Op(const uint8_t *data, size_t dataSize, uint8_t numberOfGlobalConstants)
 {
-    std::ostringstream code;
+    std::string code;
     switch (getValue(data, dataSize, 3)) {
     case 0:
-        code << generateExpression2_lvalue(data, dataSize);
+        code += generateExpression2_lvalue(data, dataSize);
         break;
     case 1:
-        code << "globalconstant" << (1 + getValue(data, dataSize, numberOfGlobalConstants));
+        code += "globalconstant";
+        code += (1 + getValue(data, dataSize, numberOfGlobalConstants));
         break;
     case 2:
-        code << (getValue(data, dataSize, 0x80) * 0x80 + getValue(data, dataSize, 0x80));
+        code += (getValue(data, dataSize, 0x80) * 0x80 + getValue(data, dataSize, 0x80));
         break;
-    };
-    return code.str();
+    }
+    return code;
 }
 
-static std::string generateExpression2_Expr(const uint8_t *data, size_t dataSize, int numberOfGlobalConstants, int depth=0)
+static std::string generateExpression2_Expr(const uint8_t *data, size_t dataSize, uint8_t numberOfGlobalConstants, int depth=0)
 {
     ++depth;
-    const unsigned int type = (depth > 3) ? 0 : getValue(data, dataSize, 3);
+    const int type = (depth > 3) ? 0 : getValue(data, dataSize, 3);
     const char binop[] = "=<>+-*/%&|^";
     const char *unop[] = {"++","--","()","~"};
 
@@ -69,25 +86,29 @@ static std::string generateExpression2_Expr(const uint8_t *data, size_t dataSize
                                 generateExpression2_Expr(data, dataSize, numberOfGlobalConstants, depth);
         const std::string rhs = generateExpression2_Expr(data, dataSize, numberOfGlobalConstants, depth);
 
-        return lhs + op + rhs;
+        std::string ret = lhs + op + rhs;
+        if (depth > 1 && op == '=')
+            ret = "(" + ret + ")";
+
+        return ret;
     }
     case 2: {
         const char *u = unop[getValue(data,dataSize,sizeof(unop)/sizeof(*unop))];
-        if (u == std::string("()"))
+        if (strcmp(u, "()") == 0)
             return "(" + generateExpression2_Expr(data, dataSize, numberOfGlobalConstants, depth) + ")";
-        else if (u == std::string("++") || u == std::string("--"))
+        else if (strcmp(u, "++") == 0 || strcmp(u, "--") == 0)
             return u + generateExpression2_lvalue(data, dataSize);
         return u + generateExpression2_Expr(data, dataSize, numberOfGlobalConstants, depth);
     }
     default:
         break;
-    };
+    }
 
     return "0";
 }
 
 
-static std::string generateExpression2_Cond(const uint8_t *data, size_t dataSize, int numberOfGlobalConstants)
+static std::string generateExpression2_Cond(const uint8_t *data, size_t dataSize, uint8_t numberOfGlobalConstants)
 {
     const char *comp[] = {"==", "!=", "<", "<=", ">", ">="};
     const int i = getValue(data, dataSize, 6);
@@ -105,16 +126,18 @@ static std::string functionStart()
 }
 
 static std::string generateExpression2_conditionalCode(const std::string &indent,
-        const uint8_t *data,
-        size_t dataSize,
-        int numberOfGlobalConstants)
+                                                       const uint8_t *data,
+                                                       size_t dataSize,
+                                                       uint8_t numberOfGlobalConstants)
 {
-    std::ostringstream code;
+    std::string code;
 
     if (indent.empty())
-        code << functionStart();
-    else
-        code << indent << "{\n";
+        code += functionStart();
+    else {
+        code += indent;
+        code += "{\n";
+    }
 
     for (int line = 0; line < 4 || indent.empty(); ++line) {
         bool done = false;
@@ -129,57 +152,80 @@ static std::string generateExpression2_conditionalCode(const std::string &indent
                           ((type1 >= 5) ? mostLikelyType : type1);
 
         if (type2 == 0) {
-            code << indent << "    var" << getValue(data, dataSize, 5) << "=" << generateExpression2_Expr(data, dataSize, numberOfGlobalConstants) << ";\n";
+            code += indent;
+            code += "    var";
+            code += getValue(data, dataSize, 5);
+            code += "=";
+            code += generateExpression2_Expr(data, dataSize, numberOfGlobalConstants);
+            code += ";\n";
         } else if (type2 == 1) {
-            code << indent << "    if (" << generateExpression2_Cond(data, dataSize, numberOfGlobalConstants) << ")\n";
-            code << generateExpression2_conditionalCode(indent + "    ", data, dataSize, numberOfGlobalConstants);
+            code += indent;
+            code += "    if (";
+            code += generateExpression2_Cond(data, dataSize, numberOfGlobalConstants);
+            code += ")\n";
+            code += generateExpression2_conditionalCode(indent + "    ", data, dataSize, numberOfGlobalConstants);
         } else if (type2 == 2) {
-            code << indent << "    if (" << generateExpression2_Cond(data, dataSize, numberOfGlobalConstants) << ")\n";
-            code << generateExpression2_conditionalCode(indent + "    ", data, dataSize, numberOfGlobalConstants);
-            code << indent << "    else\n";
-            code << generateExpression2_conditionalCode(indent + "    ", data, dataSize, numberOfGlobalConstants);
+            code += indent;
+            code += "    if (";
+            code += generateExpression2_Cond(data, dataSize, numberOfGlobalConstants);
+            code += ")\n";
+            code += generateExpression2_conditionalCode(indent + "    ", data, dataSize, numberOfGlobalConstants);
+            code += indent;
+            code += "    else\n";
+            code += generateExpression2_conditionalCode(indent + "    ", data, dataSize, numberOfGlobalConstants);
         } else if (type2 == 3) {
-            code << indent << "    while (" << generateExpression2_Cond(data, dataSize, numberOfGlobalConstants) << ")\n";
-            code << generateExpression2_conditionalCode(indent + "    ", data, dataSize, numberOfGlobalConstants);
+            code += indent;
+            code += "    while (";
+            code += generateExpression2_Cond(data, dataSize, numberOfGlobalConstants);
+            code += ")\n";
+            code += generateExpression2_conditionalCode(indent + "    ", data, dataSize, numberOfGlobalConstants);
         } else if (type2 == 4) {
-            code << indent << "    return " << generateExpression2_Expr(data, dataSize, numberOfGlobalConstants) << ";\n";
-            if (indent.empty())
-                code << "}\n\n" << functionStart();
+            code += indent;
+            code += "    return ";
+            code += generateExpression2_Expr(data, dataSize, numberOfGlobalConstants);
+            code += ";\n";
+            if (indent.empty()) {
+                code += "}\n\n";
+                code += functionStart();
+            }
             else
                 break;
         }
     }
 
-    if (!indent.empty())
-        code << indent << "}\n";
-    else
-        code << "    return 0;\n}\n";
-    return code.str();
+    if (!indent.empty()) {
+        code += indent;
+        code += "}\n";
+    }
+    else {
+        code += "    return 0;\n}\n";
+    }
+    return code;
 }
 
 std::string generateCode2(const uint8_t *data, size_t dataSize)
 {
-    std::ostringstream code;
+    std::string code;
 
     // create global constants
-    constexpr int numberOfGlobalConstants = 0;
+    constexpr uint8_t numberOfGlobalConstants = 0;
     /*
-      const int numberOfGlobalConstants = getValue(data, dataSize, 5);
-      for (int nr = 1; nr <= numberOfGlobalConstants; nr++) {
+       const int numberOfGlobalConstants = getValue(data, dataSize, 5);
+       for (int nr = 1; nr <= numberOfGlobalConstants; nr++) {
         const char *types[4] = {"char", "int", "long long", "float"};
         code << "const " << types[getValue(data, dataSize, 4)] << " globalconstant" << nr << " = " << generateExpression2_Expr(data, dataSize, nr - 1) << ";\n";
-      }
-    */
+       }
+     */
 
-    code << "int var1 = 1;\n"
-         "int var2 = 0;\n"
-         "int var3 = 1;\n"
-         "int var4 = 0;\n"
-         "int var5 = -1;\n\n";
+    code += "int var1 = 1;\n"
+            "int var2 = 0;\n"
+            "int var3 = 1;\n"
+            "int var4 = 0;\n"
+            "int var5 = -1;\n\n";
 
-    code << generateExpression2_conditionalCode("", data, dataSize, numberOfGlobalConstants);
+    code += generateExpression2_conditionalCode("", data, dataSize, numberOfGlobalConstants);
 
-    return code.str();
+    return code;
 }
 
 
diff --git a/oss-fuzz/type2.h b/oss-fuzz/type2.h
index 36bd9a68256..f382cbd9ef0 100644
--- a/oss-fuzz/type2.h
+++ b/oss-fuzz/type2.h
@@ -1,3 +1,20 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
 
 #pragma once
 
diff --git a/philosophy.md b/philosophy.md
index a5eb9189e10..af61a1cd38f 100644
--- a/philosophy.md
+++ b/philosophy.md
@@ -1,53 +1,64 @@
 
-Cppcheck Philosophy
-===================
+# Cppcheck Philosophy
 
 It is important that everybody in the Cppcheck team has a consistent idea about how this tool should work.
 
-This is a static analyser tool. When it comes to writing warnings, quality is much more important than quantity.
+This is a static analyzer tool.
 
+## Usability
 
-No false positives
-------------------
+Usability is very important. It's more important that Cppcheck is usable than finding all bugs.
+ - We don't want to have tons of configurations options.
+ - It's very important that warning messages are well written and with enough details.
+ - Speed is very important. --check-level=exhaustive can be used when user accept slow analysis.
+
+## Normal analysis - No false positives
 
 A fundamental goal is "no false positives".
 
 It is not possible to achieve "no false positives" completely. One case where false positives are OK is when the code is garbage.
 
-If the code is written as it is by design, then our goal is to not warn.
+If the code is written as it is by design, then our goal is to not show any false positives.
 
-If it is not known if there is a problem, then in general we need to bailout. We can only warn when we see that there is a problem.
+If it is not known if there is a problem, then in general we need to bailout to avoid false positives. We can only warn when we see that there is a problem.
 
 Stylistic checks are much more prone to false positives and therefore we should avoid writing stylistic checks mostly.
 
+Reporting issues in Trac:
+ - If you see a false negative; report that as an enhancement.
+ - If you see a false positive; report that as a defect.
+
+### Inconclusive messages
+
+If cppcheck can't determine that there is a problem or not, then the analysis is inconclusive.
+
+If the user enables inconclusive warnings and we guess that the probability there is a real problem is at least 50-50 then it's OK to write a inconclusive warning.
 
-No configuration
-----------------
+Inconclusive messages shall not be used for new checks which are just being developed. There `settings.experimental` can be used.
+
+
+## No configuration
 
 We want that a user can run Cppcheck without explicit -D and -I configuration.
 
 When this happens the false positives should be avoided. The user can reduce false negatives with configuration.
 
 
-Allow compiler extensions
--------------------------
+## Allow compiler extensions
 
 This is not just a tool for mainstream gcc/msvc c/c++ developers. If you can compile the code with a C/C++ compiler then our goal is that Cppcheck can check it.
 
 
-C++ language
-------------
+## C++ language
 
-Our goal is to be highly portable. Users must be able to compile Cppcheck with GCC 4.6 or MSVS 2013.
+Our goal is to be highly portable. Users must be able to compile Cppcheck with GCC 4.8 or Visual Studio 2013.
 
-No C++14 is allowed. A subset of the C++11 is allowed.
+No C++14 is allowed. A subset of C++11 is allowed.
 
 
-No dependencies
----------------
+## Avoid dependencies
 
 We are very careful about dependencies.
 
 
 
-
diff --git a/platforms/aix_ppc64.xml b/platforms/aix_ppc64.xml
index 15062d6da6e..3abf639e62a 100644
--- a/platforms/aix_ppc64.xml
+++ b/platforms/aix_ppc64.xml
@@ -3,6 +3,7 @@
   <char_bit>8</char_bit>
   <default-sign>unsigned</default-sign>
   <sizeof>
+    <bool>1</bool>
     <short>2</short>
     <int>4</int>
     <long>8</long>
diff --git a/platforms/arm32-wchar_t2.xml b/platforms/arm32-wchar_t2.xml
index 21e6d54c624..218a08cc13d 100644
--- a/platforms/arm32-wchar_t2.xml
+++ b/platforms/arm32-wchar_t2.xml
@@ -3,6 +3,7 @@
   <char_bit>8</char_bit>
   <default-sign>unsigned</default-sign>
   <sizeof>
+    <bool>1</bool>
     <short>2</short>
     <int>4</int>
     <long>4</long>
diff --git a/platforms/arm32-wchar_t4.xml b/platforms/arm32-wchar_t4.xml
index 3aefa7ba5c9..6a7d2e38d1b 100644
--- a/platforms/arm32-wchar_t4.xml
+++ b/platforms/arm32-wchar_t4.xml
@@ -3,6 +3,7 @@
   <char_bit>8</char_bit>
   <default-sign>unsigned</default-sign>
   <sizeof>
+    <bool>1</bool>
     <short>2</short>
     <int>4</int>
     <long>4</long>
diff --git a/platforms/arm64-wchar_t2.xml b/platforms/arm64-wchar_t2.xml
index 7f2ce2d9e7b..2b0cff4989f 100644
--- a/platforms/arm64-wchar_t2.xml
+++ b/platforms/arm64-wchar_t2.xml
@@ -3,6 +3,7 @@
   <char_bit>8</char_bit>
   <default-sign>unsigned</default-sign>
   <sizeof>
+    <bool>1</bool>
     <short>2</short>
     <int>4</int>
     <long>4</long>
diff --git a/platforms/arm64-wchar_t4.xml b/platforms/arm64-wchar_t4.xml
index 94bb9723372..35183bb089c 100644
--- a/platforms/arm64-wchar_t4.xml
+++ b/platforms/arm64-wchar_t4.xml
@@ -3,6 +3,7 @@
   <char_bit>8</char_bit>
   <default-sign>unsigned</default-sign>
   <sizeof>
+    <bool>1</bool>
     <short>2</short>
     <int>4</int>
     <long>4</long>
diff --git a/platforms/cppcheck-platforms.rng b/platforms/cppcheck-platforms.rng
index 642ada19815..a0c99247c2d 100644
--- a/platforms/cppcheck-platforms.rng
+++ b/platforms/cppcheck-platforms.rng
@@ -9,43 +9,39 @@
 				<data type="NCName"/>
 			</element>
 			<element name="sizeof">
-				<zeroOrMore>
-					<choice>
-						<element name="bool">
-							<data type="integer"/>
-						</element>
-						<element name="short">
-							<data type="integer"/>
-						</element>
-						<element name="int">
-							<data type="integer"/>
-						</element>
-						<element name="long">
-							<data type="integer"/>
-						</element>
-						<element name="long-long">
-							<data type="integer"/>
-						</element>
-						<element name="float">
-							<data type="integer"/>
-						</element>
-						<element name="double">
-							<data type="integer"/>
-						</element>
-						<element name="long-double">
-							<data type="integer"/>
-						</element>
-						<element name="pointer">
-							<data type="integer"/>
-						</element>
-						<element name="size_t">
-							<data type="integer"/>
-						</element>
-						<element name="wchar_t">
-							<data type="integer"/>
-						</element>
-					</choice>
-				</zeroOrMore>
+				<element name="bool">
+					<data type="integer"/>
+				</element>
+				<element name="short">
+					<data type="integer"/>
+				</element>
+				<element name="int">
+					<data type="integer"/>
+				</element>
+				<element name="long">
+					<data type="integer"/>
+				</element>
+				<element name="long-long">
+					<data type="integer"/>
+				</element>
+				<element name="float">
+					<data type="integer"/>
+				</element>
+				<element name="double">
+					<data type="integer"/>
+				</element>
+				<element name="long-double">
+					<data type="integer"/>
+				</element>
+				<element name="pointer">
+					<data type="integer"/>
+				</element>
+				<element name="size_t">
+					<data type="integer"/>
+				</element>
+				<element name="wchar_t">
+					<data type="integer"/>
+				</element>
 			</element>
 		</element>
 	</start>
diff --git a/platforms/cray_sv1.xml b/platforms/cray_sv1.xml
index 478f4afaf45..1c26bc21d0e 100644
--- a/platforms/cray_sv1.xml
+++ b/platforms/cray_sv1.xml
@@ -3,6 +3,7 @@
   <char_bit>8</char_bit>
   <default-sign>unsigned</default-sign>
   <sizeof>
+    <bool>1</bool>
     <short>2</short>
     <int>8</int>
     <long>8</long>
diff --git a/platforms/unix64-unsigned.xml b/platforms/elbrus-e1cp.xml
similarity index 95%
rename from platforms/unix64-unsigned.xml
rename to platforms/elbrus-e1cp.xml
index 21d97b61150..818c2841580 100644
--- a/platforms/unix64-unsigned.xml
+++ b/platforms/elbrus-e1cp.xml
@@ -3,6 +3,7 @@
   <char_bit>8</char_bit>
   <default-sign>unsigned</default-sign>
   <sizeof>
+    <bool>1</bool>
     <short>2</short>
     <int>4</int>
     <long>8</long>
diff --git a/platforms/unix32-unsigned.xml b/platforms/mips32.xml
similarity index 70%
rename from platforms/unix32-unsigned.xml
rename to platforms/mips32.xml
index bc4ca0e8954..c8fb46d40a1 100644
--- a/platforms/unix32-unsigned.xml
+++ b/platforms/mips32.xml
@@ -1,17 +1,18 @@
 <?xml version="1.0"?>
 <platform>
   <char_bit>8</char_bit>
-  <default-sign>unsigned</default-sign>
+  <default-sign>signed</default-sign>
   <sizeof>
+    <bool>1</bool>
     <short>2</short>
     <int>4</int>
     <long>4</long>
     <long-long>8</long-long>
     <float>4</float>
     <double>8</double>
-    <long-double>12</long-double>
+    <long-double>8</long-double>
     <pointer>4</pointer>
     <size_t>4</size_t>
-    <wchar_t>2</wchar_t>
+    <wchar_t>4</wchar_t>
   </sizeof>
 </platform>
diff --git a/platforms/msp430_eabi_large_datamodel.xml b/platforms/msp430_eabi_large_datamodel.xml
index 0f632de117c..18465323e9b 100644
--- a/platforms/msp430_eabi_large_datamodel.xml
+++ b/platforms/msp430_eabi_large_datamodel.xml
@@ -3,6 +3,7 @@
   <char_bit>8</char_bit>
   <default-sign>signed</default-sign>
   <sizeof>
+    <bool>1</bool>
     <short>2</short>
     <int>2</int>
     <long>4</long>
diff --git a/platforms/pic16.xml b/platforms/pic16.xml
new file mode 100644
index 00000000000..44fa44caa9e
--- /dev/null
+++ b/platforms/pic16.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0"?>
+<platform>
+  <char_bit>8</char_bit>
+  <default-sign>unsigned</default-sign>
+  <sizeof>
+    <bool>1</bool>
+    <short>2</short>
+    <int>2</int>
+    <long>4</long>
+    <long-long>8</long-long>
+    <float>4</float>
+    <double>4</double>
+    <long-double>8</long-double>
+    <pointer>2</pointer>
+    <size_t>2</size_t>
+    <wchar_t>2</wchar_t>
+  </sizeof>
+</platform>
diff --git a/platforms/pic8-enhanced.xml b/platforms/pic8-enhanced.xml
new file mode 100644
index 00000000000..a5cd45e35c8
--- /dev/null
+++ b/platforms/pic8-enhanced.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0"?>
+<platform>
+  <char_bit>8</char_bit>
+  <default-sign>unsigned</default-sign>
+  <sizeof>
+    <bool>1</bool>
+    <short>2</short>
+    <int>2</int>
+    <long>4</long>
+    <long-long>8</long-long>
+    <float>4</float>
+    <double>4</double>
+    <long-double>4</long-double>
+    <pointer>2</pointer>
+    <size_t>2</size_t>
+    <wchar_t>2</wchar_t>
+  </sizeof>
+</platform>
diff --git a/platforms/pic8.xml b/platforms/pic8.xml
new file mode 100644
index 00000000000..b855cbefc2c
--- /dev/null
+++ b/platforms/pic8.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0"?>
+<platform>
+  <char_bit>8</char_bit>
+  <default-sign>unsigned</default-sign>
+  <sizeof>
+    <bool>1</bool>
+    <short>2</short>
+    <int>2</int>
+    <long>4</long>
+    <long-long>4</long-long>
+    <float>4</float>
+    <double>4</double>
+    <long-double>4</long-double>
+    <pointer>2</pointer>
+    <size_t>2</size_t>
+    <wchar_t>2</wchar_t>
+  </sizeof>
+</platform>
diff --git a/pylintrc_travis b/pylintrc_travis
deleted file mode 100644
index adcbdb8ed75..00000000000
--- a/pylintrc_travis
+++ /dev/null
@@ -1,10 +0,0 @@
-# Just the severe stuff...
-[MESSAGES CONTROL]
-disable=C,R,W
-[REPORTS]
-reports=no
-[TYPECHECK]
-# See https://stackoverflow.com/questions/10300082/how-to-prevent-python-pylint-complaining-about-socket-class-sendall-method
-ignored-classes=SQLObject,_socketobject
-[MASTER]
-init-hook='import sys; sys.path.append("./addons")'
diff --git a/readme.md b/readme.md
index 6d90141aadd..a34dad2a57a 100644
--- a/readme.md
+++ b/readme.md
@@ -1,8 +1,9 @@
 # **Cppcheck** 
 
-|Linux Build Status|Windows Build Status|Coverity Scan Build Status|
-|:--:|:--:|:--:|
-|[![Linux Build Status](https://img.shields.io/travis/danmar/cppcheck/master.svg?label=Linux%20build)](https://travis-ci.org/danmar/cppcheck)|[![Windows Build Status](https://img.shields.io/appveyor/ci/danmar/cppcheck/master.svg?label=Windows%20build)](https://ci.appveyor.com/project/danmar/cppcheck/branch/master)|[![Coverity Scan Build Status](https://img.shields.io/coverity/scan/512.svg)](https://scan.coverity.com/projects/512)|
+|release-windows|OSS-Fuzz|Coverity Scan Build Status|include-what-you-use|License|
+|:--:|:--:|:--:|:--:|:--:|
+|[![release-windows](https://github.com/danmar/cppcheck/actions/workflows/release-windows.yml/badge.svg?branch=main)](https://github.com/danmar/cppcheck/actions/workflows/release-windows.yml)|[![OSS-Fuzz](https://oss-fuzz-build-logs.storage.googleapis.com/badges/cppcheck.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:cppcheck)|[![Coverity Scan Build Status](https://img.shields.io/coverity/scan/512.svg)](https://scan.coverity.com/projects/512)|[![include-what-you-use](https://github.com/danmar/cppcheck/actions/workflows/iwyu.yml/badge.svg?branch=main)](https://github.com/danmar/cppcheck/actions/workflows/iwyu.yml)|[![License](https://img.shields.io/badge/license-GPL3.0-blue.svg)](https://opensource.org/licenses/GPL-3.0)
+
 
 ## About the name
 
@@ -12,53 +13,82 @@ Despite the name, Cppcheck is designed for both C and C++.
 
 ## Manual
 
-A manual is available [online](http://cppcheck.sourceforge.net/manual.pdf).
+A manual is available [online](https://cppcheck.sourceforge.io/manual.pdf).
+
+## Donate CPU
+
+Cppcheck is a hobby project with limited resources. You can help us by donating CPU (1 core, which is the default, or as many as you like. Use the `-j` flag to use more cores). It is simple:
+
+ 1. Download (and extract) Cppcheck source code.
+ 2. Run (Linux/MacOS example):
+    ```
+    cd cppcheck/
+    python3 -m venv .venv
+    source .venv/bin/activate
+
+    pip install -r tools/donate-cpu-requirements.txt
+    ./tools/donate-cpu.py
+    ```
+
+The script will analyse debian source code and upload the results to a cppcheck server. We need these results both to improve Cppcheck and to detect regressions.
+
+You can stop the script whenever you like with Ctrl C.
 
 ## Compiling
 
-Any C++11 compiler should work. For compilers with partial C++11 support it may work. If your compiler has the C++11 features that are available in Visual Studio 2013 / GCC 4.6 then it will work.
+Cppcheck requires a C++ compiler with (partial) C++11 support. Minimum required versions are GCC 5.1 / Clang 3.5 / AppleClang 6.0 / Visual Studio 2015.
 
-To build the GUI, you need Qt.
+To build the GUI application, you need to use the CMake build system.
 
 When building the command line tool, [PCRE](http://www.pcre.org/) is optional. It is used if you build with rules.
 
 There are multiple compilation choices:
-* qmake - cross platform build tool
-* cmake - cross platform build tool
-* Windows: Visual Studio (VS 2013 and above)
-* Windows: Qt Creator + mingw
-* gnu make
-* g++ 4.6 (or later)
-* clang++
+* CMake - cross platform build tool
+* (Windows) Visual Studio
+* (Windows) Qt Creator + MinGW
+* GNU compilers - via make or directly
 
-### cmake
+The minimum required Python version is 3.7.
+
+### CMake
+
+The minimum required version is CMake 3.22.
 
 Example, compiling Cppcheck with cmake:
 
 ```shell
-mkdir build
-cd build
-cmake ..
-cmake --build .
+cmake -S . -B build
+cmake --build build
 ```
 
-If you want to compile the GUI you can use the flag
+If you want to compile the GUI you can use the flag.
 -DBUILD_GUI=ON
 
-For rules support (requires pcre) use the flag
+For rules support (requires pcre) use the flag.
 -DHAVE_RULES=ON
 
 For release builds it is recommended that you use:
 -DUSE_MATCHCOMPILER=ON
 
-### qmake
+For building the tests use the flag.
+-DBUILD_TESTING=ON
+
+Using cmake you can generate project files for Visual Studio,XCode,etc.
+
+#### Building a specific configuration
 
-You can use the gui/gui.pro file to build the GUI.
+For single-configuration generators (like "Unix Makefiles") you can generate and build a specific configuration (e.g. "RelWithDebInfo") using:
 
 ```shell
-cd gui
-qmake
-make
+cmake -S . -B build_RelWithDebInfo -DCMAKE_BUILD_TYPE=RelWithDebInfo ..
+cmake --build build_RelWithDebInfo --config RelWithDebInfo
+```
+
+For multi-configuration generators (like "Visual Studio 17 2022") the same is achieved using:
+
+```shell
+cmake -S . -B build
+cmake --build build --config RelWithDebInfo
 ```
 
 ### Visual Studio
@@ -67,12 +97,88 @@ Use the cppcheck.sln file. The file is configured for Visual Studio 2019, but th
 
 To compile with rules, select "Release-PCRE" or "Debug-PCRE" configuration. pcre.lib (pcre64.lib for x64 builds) and pcre.h are expected to be in /externals then. A current version of PCRE for Visual Studio can be obtained using [vcpkg](https://github.com/microsoft/vcpkg).
 
+### Visual Studio (from command line)
+
+If you do not wish to use the Visual Studio IDE, you can compile cppcheck from the command line the following command.
+
+```shell
+msbuild cppcheck.sln
+```
+
+### VS Code (on Windows)
+
+Install MSYS2 to get GNU toolchain with g++ and gdb (https://www.msys2.org/).
+Create a settings.json file in the .vscode folder with the following content (adjust path as necessary):
+
+```
+{
+    "terminal.integrated.shell.windows": "C:\\msys64\\usr\\bin\\bash.exe",
+    "terminal.integrated.shellArgs.windows": [
+        "--login",
+    ],
+    "terminal.integrated.env.windows": {
+        "CHERE_INVOKING": "1",
+        "MSYSTEM": "MINGW64",
+    }
+}
+```
+
+Run "make" in the terminal to build cppcheck.
+
+For debugging create a launch.json file in the .vscode folder with the following content, which covers configuration for debugging cppcheck and misra.py:
+
+```
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "cppcheck",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${workspaceFolder}/cppcheck.exe",
+            "args": [
+                "--dump",
+                "${workspaceFolder}/addons/test/misra/misra-test.c"
+            ],
+            "stopAtEntry": false,
+            "cwd": "${workspaceFolder}",
+            "environment": [],
+            "externalConsole": true,
+            "MIMode": "gdb",
+            "miDebuggerPath": "C:/msys64/mingw64/bin/gdb.exe",
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing for gdb",
+                    "text": "-enable-pretty-printing",
+                    "ignoreFailures": true
+                }
+            ]
+        },
+        {
+            "name": "misra.py",
+            "type": "python",
+            "request": "launch",
+            "program": "${workspaceFolder}/addons/misra.py",
+            "console": "integratedTerminal",
+            "args": [
+                "${workspaceFolder}/addons/test/misra/misra-test.c.dump"
+            ]
+        }
+    ]
+}
+```
+
 ### Qt Creator + MinGW
 
 The PCRE dll is needed to build the CLI. It can be downloaded here:
 http://software-download.name/pcre-library-windows/
 
-### GNU make
+### GNU compilers
+
+#### GNU make
 
 Simple, unoptimized build (no dependencies):
 
@@ -80,44 +186,56 @@ Simple, unoptimized build (no dependencies):
 make
 ```
 
+You can use `CXXOPTS`, `CPPOPTS` and `LDOPTS` to append to the existing `CXXFLAGS`, `CPPFLAGS` and `LDFLAGS` instead of overriding them.
+
 The recommended release build is:
 
 ```shell
-make MATCHCOMPILER=yes FILESDIR=/usr/share/cppcheck HAVE_RULES=yes CXXFLAGS="-O2 -DNDEBUG -Wall -Wno-sign-compare -Wno-unused-function"
+make MATCHCOMPILER=yes FILESDIR=/usr/share/cppcheck HAVE_RULES=yes CXXOPTS="-O2" CPPOPTS="-DNDEBUG"
 ```
 
-Flags:
+#### g++ (for experts)
 
-1.  `MATCHCOMPILER=yes`
-    Python is used to optimise cppcheck. The Token::Match patterns are converted into C++ code at compile time.
+If you just want to build Cppcheck without dependencies then you can use this command:
 
-2.  `FILESDIR=/usr/share/cppcheck`
-    Specify folder where cppcheck files are installed (addons, cfg, platform)
+```shell
+g++ -o cppcheck -std=c++11 -Iexternals -Iexternals/simplecpp -Iexternals/tinyxml2 -Iexternals/picojson -Ilib -Ifrontend frontend/*.cpp cli/*.cpp lib/*.cpp externals/simplecpp/simplecpp.cpp externals/tinyxml2/tinyxml2.cpp
+```
 
-3.  `HAVE_RULES=yes`
-    Enable rules (PCRE is required if this is used)
+#### Flags
 
-4.  `CXXFLAGS="-O2 -DNDEBUG -Wall -Wno-sign-compare -Wno-unused-function"`
-    Enables most compiler optimizations, disables cppcheck-internal debugging code and enables basic compiler warnings.
+-  `MATCHCOMPILER=yes`
+   Several `Token` matching patterns are converted into more efficient C++ code at compile time (requires Python to be installed).
 
-### g++ (for experts)
+-  `FILESDIR=/usr/share/cppcheck`
+   Specifies the folder where cppcheck files (addons, cfg, platform) are installed to.
 
-If you just want to build Cppcheck without dependencies then you can use this command:
+-  `HAVE_RULES=yes`
+   Enables rules (requires PCRE to be installed).
 
-```shell
-g++ -o cppcheck -std=c++11 -Iexternals -Iexternals/simplecpp -Iexternals/tinyxml -Ilib cli/*.cpp lib/*.cpp externals/simplecpp/simplecpp.cpp externals/tinyxml/*.cpp
-```
+-  `CXXOPTS="-O2"`
+   Enables most compiler optimizations.
 
-If you want to use `--rule` and `--rule-file` then dependencies are needed:
+-  `CPPOPTS="-DNDEBUG"`
+   Disables assertions.
 
-```shell
-g++ -o cppcheck -std=c++11 -lpcre -DHAVE_RULES -Ilib -Iexternals -Iexternals/simplecpp -Iexternals/tinyxml cli/*.cpp lib/*.cpp externals/simplecpp/simplecpp.cpp externals/tinyxml/*.cpp
-```
+-  `HAVE_BOOST=yes`
+   Enables usage of more efficient container from Boost (requires Boost to be installed).
 
 ### MinGW
 
 ```shell
-mingw32-make LDFLAGS=-lshlwapi
+mingw32-make
+```
+
+If you encounter the following error with `MATCHCOMPILER=yes` you need to specify your Python interpreter via `PYTHON_INTERPRETER`.
+
+```
+process_begin: CreateProcess(NULL, which python3, ...) failed.
+makefile:24: pipe: No error
+process_begin: CreateProcess(NULL, which python, ...) failed.
+makefile:27: pipe: No error
+makefile:30: *** Did not find a Python interpreter.  Stop.
 ```
 
 ### Other Compiler/IDE
@@ -135,6 +253,43 @@ make CXX=i586-mingw32msvc-g++ LDFLAGS="-lshlwapi" RDYNAMIC=""
 mv cppcheck cppcheck.exe
 ```
 
+## Packages
+
+Besides building yourself on the platform of your choice there are also several ways to obtain pre-built packages.<br/>
+
+### Official
+
+Official packages are maintained by the Cppcheck team.
+
+- (Windows) An official Windows installer is available via the official Cppcheck SourceForge page: https://cppcheck.sourceforge.io.
+- (Windows) Official builds of the current development versions are available via the [release-windows](https://github.com/danmar/cppcheck/actions/workflows/release-windows.yml) workflow. They are built nightly for the `main` branch and for each commit for release branches. As these are development versions please refrain from using these in production environments!
+  - A portable package (i.e. does not require installation) is available as the `portable` artifact. This is still a work-in-progress - see https://trac.cppcheck.net/ticket/10771 for details.
+  - An installer is available via the `installer` artifact.
+- (Multi-Platform) A premium version with additional features provided by the original author of Cppcheck is available for purchase via https://www.cppcheck.com.
+
+### Third-party
+
+Third-party packages are ***not*** maintained by the Cppcheck team but their respective packagers.
+
+*Note:* The following list is purely informational and listed in no particular order.
+
+*Note:* Please always try to obtain the package from the primary official source of your operating system/distro first and make sure you are getting the latest released/tagged version (see https://github.com/danmar/cppcheck/tags). Some packages might not carry the latest patch version though.
+
+*Note:* Some issues might be related to additional patches carried by the builds in these packages or by the packaging itself. Please try to verify the issue with an official build before reporting it upstream. Otherwise you might need toreport it to the respective maintainer of the package.
+
+- (Windows / Outdated) A portable package is available via https://portableapps.com/apps/development/cppcheck-portable.
+- (Windows / Outdated) A package is available via https://community.chocolatey.org/packages/cppcheck.
+- (Windows / Outdated) A package is available via https://winget.run/pkg/Cppcheck/Cppcheck.
+- (Windows) A package is available via https://scoop.sh/#/apps?q=cppcheck.
+- (Linux/Unix) Many major distros offer Cppcheck packages via their integrated package managers (`yum`, `apt`, `pacman`, etc.). See https://pkgs.org/search/?q=cppcheck or https://repology.org/project/cppcheck for an overview.
+- (Linux/Unix) Unless you are using a "rolling" distro, it is likely that they are not carrying the latest version. There are several external (mainly unsupported) repositories like AUR (ArchLinux), PPA (ubuntu), EPEL (CentOS/Fedora) etc. which might provide up-to-date packages. 
+- (Linux/Unix / Outdated) The Canonical Snapcraft packages (https://snapcraft.io/cppcheck / https://snapcraft.io/cppcheckgui) are unmaintained and contain very old (development) versions. Please refrain from using them! See https://trac.cppcheck.net/ticket/11641 for more details.
+- (MacOS) A package is available via Homebrew (`brew`). See https://formulae.brew.sh/formula/cppcheck.
+- (MacOS) A package is available via https://ports.macports.org/port/cppcheck.
+- (Multi-Platform) A package is available via https://anaconda.org/conda-forge/cppcheck.
+- (Multi-Platform) A package is available via https://conan.io/center/recipes/cppcheck.
+- Packages are also available from various download portals (mainly the Windows installer - sometimes re-packaged).
+
 ## Webpage
 
-http://cppcheck.sourceforge.net/
+https://cppcheck.sourceforge.io/
diff --git a/readme.txt b/readme.txt
deleted file mode 100644
index eecdac06bb0..00000000000
--- a/readme.txt
+++ /dev/null
@@ -1,116 +0,0 @@
-=========
-Cppcheck
-=========
-
-
-About
-
-    The original name of this program is "C++check" but it was later changed to "cppcheck".
-
-Manual
-
-    A manual is available online:
-    http://cppcheck.sourceforge.net/manual.pdf
-
-Compiling
-
-    Any C++11 compiler should work. For compilers with partial C++11 support it may work. If
-    your compiler has the C++11 features that are available in Visual Studio 2013 / GCC 4.6
-    then it will work.
-
-    To build the GUI, you need Qt.
-
-    When building the command line tool, PCRE is optional. It is used if you build with rules.
-
-    There are multiple compilation choices:
-      * qmake - cross platform build tool
-      * cmake - cross platform build tool
-      * Windows: Visual Studio
-      * Windows: Qt Creator + mingw
-      * gnu make
-      * g++ 4.6 (or later)
-      * clang++
-
-    cmake
-    =====
-        Example, compiling Cppcheck with cmake:
-            mkdir build
-            cd build
-            cmake ..
-            cmake --build .
-
-        If you want to compile the GUI you can use the flag
-        -DBUILD_GUI=ON
-
-        For rules support (requires pcre) use the flag
-        -DHAVE_RULES=ON
-
-        For release builds it is recommended that you use:
-        -DUSE_MATCHCOMPILER=ON
-
-    qmake
-    =====
-        You can use the gui/gui.pro file to build the GUI.
-            cd gui
-            qmake
-            make
-
-    Visual Studio
-    =============
-        Use the cppcheck.sln file. The file is configured for Visual Studio 2019, but the platform
-        toolset can be changed easily to older or newer versions. The solution contains platform
-        targets for both x86 and x64.
-
-        To compile with rules, select "Release-PCRE" or "Debug-PCRE" configuration.
-        pcre.lib (pcre64.lib for x64 builds) and pcre.h are expected to be in /externals then.
-        A current version of PCRE for Visual Studio can be obtained using vcpkg:
-        https://github.com/microsoft/vcpkg
-
-    Qt Creator + mingw
-    ==================
-        The PCRE dll is needed to build the CLI. It can be downloaded here:
-            http://software-download.name/pcre-library-windows/
-
-    gnu make
-    ========
-        Simple build (no dependencies):
-            make
-
-        The recommended release build is:
-            make MATCHCOMPILER=yes FILESDIR=/usr/share/cppcheck HAVE_RULES=yes
-
-        Flags:
-        MATCHCOMPILER=yes               : Python is used to optimise cppcheck at compile time
-        FILESDIR=/usr/share/cppcheck    : Specify folder where cppcheck files are installed
-        HAVE_RULES=yes                  : Enable rules (pcre is required if this is used)
-
-    g++ (for experts)
-    =================
-        If you just want to build Cppcheck without dependencies then you can use this command:
-            g++ -o cppcheck -std=c++11 -Iexternals -Iexternals/simplecpp -Iexternals/tinyxml -Ilib cli/*.cpp lib/*.cpp externals/simplecpp/simplecpp.cpp externals/tinyxml/*.cpp
-
-        If you want to use --rule and --rule-file then dependencies are needed:
-            g++ -o cppcheck -std=c++11 -lpcre -DHAVE_RULES -Ilib -Iexternals -Iexternals/simplecpp -Iexternals/tinyxml cli/*.cpp lib/*.cpp externals/simplecpp/simplecpp.cpp externals/tinyxml/*.cpp
-
-    mingw
-    =====
-        The "LDFLAGS=-lshlwapi" is needed when building with mingw
-            mingw32-make LDFLAGS=-lshlwapi
-
-    other compilers/ide
-    ===================
-
-        1. Create a empty project file / makefile.
-        2. Add all cpp files in the cppcheck cli and lib folders to the project file / makefile.
-        3. Add all cpp files in the externals folders to the project file / makefile.
-        4. Compile.
-
-Cross compiling Win32 (CLI) version of Cppcheck in Linux
-
-    sudo apt-get install mingw32
-    make CXX=i586-mingw32msvc-g++ LDFLAGS="-lshlwapi"
-    mv cppcheck cppcheck.exe
-
-Webpage
-
-    http://cppcheck.sourceforge.net/
diff --git a/readmeja.md b/readmeja.md
index 92f5f3ffcc1..6d9dae60c95 100644
--- a/readmeja.md
+++ b/readmeja.md
@@ -12,23 +12,22 @@
 
 ## マニュアル
 
-マニュアルは[オンライン上に](http://cppcheck.sourceforge.net/manual.pdf)あります。
+マニュアルは[オンライン上に](https://cppcheck.sourceforge.io/manual.pdf)あります。
 
 ## ビルド
 
-C++11に対応したコンパイラが利用できます。部分的にC++11にサポートしたコンパイラも利用できるかもしれません。もし、あなたのコンパイラがVisual Studio 2013や GCC 4.6で利用できるC++11機能がサポートされているなら、そのコンパイラが利用できます。
+C++11に対応したコンパイラが利用できます。部分的にC++11にサポートしたコンパイラも利用できるかもしれません。もし、あなたのコンパイラがVisual Studio 2013や GCC 4.8で利用できるC++11機能がサポートされているなら、そのコンパイラが利用できます。
 
 GUIも利用する場合、Qtライブラリが必要です。
 
 コマンドラインツールをビルドする場合、[PCRE](http://www.pcre.org/)はオプションです。これはルールを作成するために利用します。
 
 コンパイル上の選択肢がいくつかあります。
-* qmake - クロスプラットフォームのビルドツール
 * cmake - クロスプラットフォームのビルドツール
 * Windows: Visual Studio (VS 2013 またはそれ以上)
 * Windows: Qt Creator + mingw
 * gnu make
-* g++ 4.6 (またはそれ以上)
+* g++ 4.8 (またはそれ以上)
 * clang++
 
 ### cmake
@@ -51,16 +50,6 @@ CppcheckのGUIが必要な場合次のフラグを指定します。
 pcreが必要になりますが、正規表現のルールサポートが必要な場合次のフラグを指定します。
 -DHAVE_RULES=ON
 
-### qmake
-
-GUIをビルドするには、gui/gui.proファイルが利用できます。
-
-```shell
-cd gui
-qmake
-make
-```
-
 ### Visual Studio
 
 cppcheck.slnファイルが利用できます。このファイルは、Visual Studio 2019向けです。しかし、このプラットフォームツールセットはこれより新しいバージョンまたは古いバージョン向けに変更できます。このソルーションには、プラットフォームターゲットとしてx86とx64があります。
@@ -83,7 +72,7 @@ make
 推奨するリリースビルド方法:
 
 ```shell
-make MATCHCOMPILER=yes FILESDIR=/usr/share/cppcheck HAVE_RULES=yes CXXFLAGS="-O2 -DNDEBUG -Wall -Wno-sign-compare -Wno-unused-function"
+make MATCHCOMPILER=yes FILESDIR=/usr/share/cppcheck HAVE_RULES=yes CXXOPTS="-O2 -DNDEBUG"
 ```
 
 フラグ:
@@ -97,7 +86,7 @@ cppcheckの設定ファイル(addon や cfg や platform)を置くディレク
 3. `HAVE_RULES=yes`
 ルール機能の有効化 (ルール機能には PCRE が必要です)設定です。
 
-4. `CXXFLAGS="-O2 -DNDEBUG -Wall -Wno-sign-compare -Wno-unused-function"`
+4. `CXXOPTS="-O2 -DNDEBUG"`
 ほとんどのコンパイラの最適化オプション、cppcheckの内部デバッグコードの無効化、基本的なコンパイラ警告の有効化
 
 ### g++ (エキスパート向け)
@@ -105,19 +94,19 @@ cppcheckの設定ファイル(addon や cfg や platform)を置くディレク
 依存関係なく Cppcheckをビルドしたい場合、次のコマンドを利用できます。
 
 ```shell
-g++ -o cppcheck -std=c++11 -Iexternals -Iexternals/simplecpp -Iexternals/tinyxml -Ilib cli/*.cpp lib/*.cpp externals/simplecpp/simplecpp.cpp externals/tinyxml/*.cpp
+g++ -o cppcheck -std=c++11 -Iexternals -Iexternals/simplecpp -Iexternals/tinyxml2 -Ilib cli/*.cpp lib/*.cpp externals/simplecpp/simplecpp.cpp externals/tinyxml2/*.cpp
 ```
 
 `--rule` や `--rule-file` を利用する場合、依存ライブラリが必要です。
 
 ```shell
-g++ -o cppcheck -std=c++11 -lpcre -DHAVE_RULES -Iexternals -Iexternals/simplecpp -Iexternals/tinyxml -Ilib cli/*.cpp lib/*.cpp externals/simplecpp/simplecpp.cpp externals/tinyxml/*.cpp
+g++ -o cppcheck -std=c++11 -lpcre -DHAVE_RULES -Iexternals -Iexternals/simplecpp -Iexternals/tinyxml2 -Ilib cli/*.cpp lib/*.cpp externals/simplecpp/simplecpp.cpp externals/tinyxml2/*.cpp
 ```
 
 ### MinGW
 
 ```shell
-mingw32-make LDFLAGS=-lshlwapi
+mingw32-make
 ```
 
 ### その他のコンパイラ/IDE
@@ -137,4 +126,4 @@ mv cppcheck cppcheck.exe
 
 ## Webページ
 
-http://cppcheck.sourceforge.net/
+https://cppcheck.sourceforge.io/
diff --git a/releasenotes.txt b/releasenotes.txt
new file mode 100644
index 00000000000..f80ee8dc42d
--- /dev/null
+++ b/releasenotes.txt
@@ -0,0 +1,23 @@
+
+Release Notes for Cppcheck 2.21
+
+Major bug fixes & crashes:
+-
+
+New checks:
+-
+
+C/C++ support:
+-
+
+GUI:
+-
+
+Changed interface:
+-
+
+Infrastructure & dependencies:
+-
+
+Other:
+-
diff --git a/requirements.txt b/requirements.txt
index ed9594d29c7..2ecb430828a 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1 +1 @@
-pcre,https://ftp.pcre.org/pub/pcre/pcre-8.43.tar.gz -H sha256:0b8e7465dc5e98c757cc3650a20a7843ee4c3edf50aaf60bb33fd879690d2c73
+pcre,pfultz2/pcre@8.45 -H sha256:d6f7182602a775a7d500a0cedca6449af0400c6493951513046d17615ed0bf11
diff --git a/rules/error-reporting.xml b/rules/error-reporting.xml
deleted file mode 100644
index 2813c9bba65..00000000000
--- a/rules/error-reporting.xml
+++ /dev/null
@@ -1,10 +0,0 @@
-<?xml version="1.0"?>
-<rule version="1">
-    <pattern>Severity :: fromString \( "\w+" \)</pattern>
-    <message>
-        <id>ConstantSeverityFromString</id>
-        <severity>style</severity>
-        <summary>Constant severity lookups should be done via
-Severity::constant.</summary>
-    </message>
-</rule>
diff --git a/rules/token-matching.xml b/rules/token-matching.xml
deleted file mode 100644
index 457cafb776f..00000000000
--- a/rules/token-matching.xml
+++ /dev/null
@@ -1,36 +0,0 @@
-<?xml version="1.0"?>
-<rules>
-    <rule version="1">
-        <pattern>Token :: (?:findm|(?:simple|)M)atch \([^,]+,\s+"(?:\s+|[^"]+?\s+")</pattern>
-        <message>
-            <id>TokenMatchSpacing</id>
-            <severity>style</severity>
-            <summary>Useless extra spacing for Token::*Match.</summary>
-        </message>
-    </rule>
-    <rule version="1">
-        <pattern>(?U)Token :: Match \([^,]+,\s+"[^%|!\[\]]+"</pattern>
-        <message>
-            <id>UseTokensimpleMatch</id>
-            <severity>error</severity>
-            <summary>Token::simpleMatch should be used to match tokens
-without special pattern requirements.</summary>
-        </message>
-    </rule>
-    <rule version="1">
-        <pattern>\b[\w_]+ \. tokAt \( 0 \)</pattern>
-        <message>
-            <id>TokentokAt0</id>
-            <severity>error</severity>
-            <summary>tok->tokAt(0) is a slow way to say tok.</summary>
-        </message>
-    </rule>
-    <rule version="1">
-        <pattern>\b[\w_]+ \. strAt \( 0 \)</pattern>
-        <message>
-            <id>TokenstrAt0</id>
-            <severity>error</severity>
-            <summary>tok->strAt(0) is a slow way to say tok->str()</summary>
-        </message>
-    </rule>
-</rules>
diff --git a/runastyle b/runastyle
deleted file mode 100755
index 050cacf51f2..00000000000
--- a/runastyle
+++ /dev/null
@@ -1,79 +0,0 @@
-#!/bin/bash
-# The version check in this script is used to avoid commit battles
-# between different developers that use different astyle versions as
-# different versions might have different output (this has happened in
-# the past).
-
-# If project management wishes to take a newer astyle version into use
-# just change this string to match the start of astyle version string.
-ASTYLE_VERSION="3.0.1"
-ASTYLE="${ASTYLE-astyle}"
-
-DETECTED_VERSION=$("$ASTYLE" --version 2>&1 | awk '{ print $NF; }')
-if [ "$DETECTED_VERSION" != "${ASTYLE_VERSION}" ]; then
-  echo "You should use version: ${ASTYLE_VERSION}"
-  echo "Detected version: ${DETECTED_VERSION}"
-  exit 1
-fi
-
-RCFILE=.astylerc
-
-#
-# Functions to format C/C++ source code
-#
-function formatCplusplus {
-  "$ASTYLE" --options=$RCFILE "$1"
-}
-function formatCplusplusRecursive {
-  RCFILE=.astylerc
-  "$ASTYLE" --options=$RCFILE --recursive "$1"
-}
-
-#
-# Function to format XML files
-#
-function formatXML {
-  xmllint --format -o "$1_" "$1"
-  if cmp -s "$1_" "$1"; then
-    rm -f "$1_"
-    echo Unchanged $1
-  else
-    mv -f "$1_" "$1"
-    echo Formatted $1
-  fi
-}
-
-formatCplusplus "cli/*.cpp"
-formatCplusplus "cli/*.h"
-formatCplusplus "democlient/*.cpp"
-formatCplusplus "gui/*.cpp"
-formatCplusplus "gui/*.h"
-formatCplusplusRecursive "gui/test/*.cpp"
-formatCplusplusRecursive "gui/test/*.h"
-formatCplusplus "lib/*.cpp"
-formatCplusplus "lib/*.h"
-formatCplusplus "oss-fuzz/*.cpp"
-formatCplusplus "oss-fuzz/*.h"
-formatCplusplus "test/*.cpp"
-formatCplusplus "test/cfg/*.c"
-formatCplusplus "test/cfg/*.cpp"
-formatCplusplus "test/*.h"
-formatCplusplus "tools/*.cpp"
-formatCplusplusRecursive "tools/*.h"
-formatCplusplusRecursive "samples/*.c"
-formatCplusplusRecursive "samples/*.cpp"
-
-# format config files
-# TODO: use other tool than xmllint? use tabs instead of spaces?
-for CFGFILE in cfg/*.cfg
-do
-  formatXML "$CFGFILE"
-done
-for PLATFORMFILE in platforms/*.xml
-do
-  formatXML "$PLATFORMFILE"
-done
-
-formatXML man/cppcheck.1.xml
-formatXML cppcheck-errors.rng
-formatXML rules/*.xml
diff --git a/runastyle.bat b/runastyle.bat
deleted file mode 100644
index dc181045779..00000000000
--- a/runastyle.bat
+++ /dev/null
@@ -1,65 +0,0 @@
-@REM Script to run AStyle on the sources
-@REM The version check in this script is used to avoid commit battles
-@REM between different developers that use different astyle versions as
-@REM different versions might have different output (this has happened in
-@REM the past).
-
-@REM If project management wishes to take a newer astyle version into use
-@REM just change this string to match the start of astyle version string.
-@SET ASTYLE_VERSION="Artistic Style Version 3.0.1"
-@SET ASTYLE="astyle"
-
-@SET DETECTED_VERSION=""
-@FOR /F "tokens=*" %%i IN ('%ASTYLE% --version') DO SET DETECTED_VERSION=%%i
-@ECHO %DETECTED_VERSION% | FINDSTR /B /C:%ASTYLE_VERSION% > nul && (
-    ECHO "%DETECTED_VERSION%" matches %ASTYLE_VERSION%
-) || (
-    ECHO You should use: %ASTYLE_VERSION%
-    ECHO Detected: "%DETECTED_VERSION%"
-    GOTO EXIT_ERROR
-)
-
-@SET RCFILE=.astylerc
-
-%ASTYLE% --options=%RCFILE% cli/*.cpp
-%ASTYLE% --options=%RCFILE% cli/*.h
-%ASTYLE% --options=%RCFILE% democlient/*.cpp
-%ASTYLE% --options=%RCFILE% gui/*.cpp
-%ASTYLE% --options=%RCFILE% gui/*.h
-%ASTYLE% --options=%RCFILE% -r gui/test/*.cpp
-%ASTYLE% --options=%RCFILE% -r gui/test/*.h
-%ASTYLE% --options=%RCFILE% lib/*.cpp
-%ASTYLE% --options=%RCFILE% lib/*.h
-%ASTYLE% --options=%RCFILE% test/*.cpp
-%ASTYLE% --options=%RCFILE% test/cfg/*.c
-%ASTYLE% --options=%RCFILE% test/cfg/*.cpp
-%ASTYLE% --options=%RCFILE% test/*.h
-
-%ASTYLE% --options=%RCFILE% -r tools/*.cpp
-%ASTYLE% --options=%RCFILE% -r tools/*.h
-
-%ASTYLE% --options=%RCFILE% -r samples/*.c
-%ASTYLE% --options=%RCFILE% -r samples/*.cpp
-
-@REM Format configuration files
-@SET XMLLINT=xmllint
-WHERE %XMLLINT%
-@IF %ERRORLEVEL% NEQ 0 (
-    ECHO WARNING: %XMLLINT% was not found. Skipping configuration file formatting!
-) ELSE (
-    PUSHD "cfg"
-    FOR /F "tokens=* delims=" %%f IN ('DIR /B *.cfg') DO @CALL :runxmllint "%%f"
-    POPD
-)
-
-@GOTO :EOF
-
-:EXIT_ERROR
-EXIT /B 1
-
-@REM Function that formats one XML file
-@REM Argument: %1: XML-File to format
-:runxmllint
-    xmllint --format -o "%~1_" "%~1"
-    MOVE /Y "%~1_" "%~1"
-@GOTO :EOF
diff --git a/runformat b/runformat
new file mode 100755
index 00000000000..f823229ecc7
--- /dev/null
+++ b/runformat
@@ -0,0 +1,56 @@
+#!/bin/bash
+#
+# uncrustify-0.80.1 is used to format cppcheck source code.
+#
+# 1. Download source code: https://github.com/uncrustify/uncrustify/archive/refs/tags/uncrustify-0.80.1.zip
+#    It's important that all Cppcheck developers use the exact same version so we don't get a "format battle".
+# 2. Building:
+#    - Linux: mkdir build && cd build && cmake -DCMAKE_BUILD_TYPE=Release .. && make
+#    - Windows: mkdir build && cd build && cmake -G"NMake Makefiles" -DCMAKE_BUILD_TYPE=Release .. && nmake
+# 3. Ensure that the binary "uncrustify" is found by runformat. Either:
+#    - you can put uncrustify in your PATH
+#    - you can create an environment variable UNCRUSTIFY that has the full path of the binary
+
+UNCRUSTIFY_VERSION="0.80.1"
+UNCRUSTIFY="${UNCRUSTIFY-uncrustify}"
+
+DETECTED_VERSION=$("$UNCRUSTIFY" --version 2>&1 | grep -o -E '[0-9.]+')
+if [ "$DETECTED_VERSION" != "${UNCRUSTIFY_VERSION}" ]; then
+  echo "You should use version: ${UNCRUSTIFY_VERSION}"
+  echo "Detected version: ${DETECTED_VERSION}"
+  exit 1
+fi
+
+# OS variables
+[ $(uname -s) = "Darwin" ] && export OSX=1 && export UNIX=1
+[ $(uname -s) = "Linux" ] && export LINUX=1 && export UNIX=1
+uname -s | grep -q "_NT-" && export WINDOWS=1
+
+if [ $OSX ]
+then
+  export CPUCOUNT=$(sysctl -n hw.ncpu)
+elif [ $LINUX ]
+then
+  export CPUCOUNT=$(nproc)
+else
+  export CPUCOUNT="1"
+fi
+
+function formatCplusplus {
+  find $1 -iname '*.h' \
+      -o -iname '*.c' \
+      -o -iname '*.cpp' \
+      | xargs -n 1 -P $CPUCOUNT -I{} -t $UNCRUSTIFY -c .uncrustify.cfg --no-backup {}
+
+}
+
+ls */*.cpp */*.h | xargs -n 1 -P $CPUCOUNT -I{} -t $UNCRUSTIFY -c .uncrustify.cfg -l CPP --no-backup --replace {}
+
+#formatCplusplus cli/
+#formatCplusplus democlient/
+#formatCplusplus gui/
+#formatCplusplus lib/
+#formatCplusplus oss-fuzz/
+#formatCplusplus test/
+#formatCplusplus tools/
+#formatCplusplus samples/
diff --git a/samples/AssignmentAddressToInteger/bad.c b/samples/AssignmentAddressToInteger/bad.c
index ab4704fedaa..0910cf0c902 100644
--- a/samples/AssignmentAddressToInteger/bad.c
+++ b/samples/AssignmentAddressToInteger/bad.c
@@ -1,4 +1,4 @@
-int foo(int *p)
+static int foo(int *p)
 {
     int a = p;
     return a + 4;
@@ -8,4 +8,5 @@ int main()
 {
     int i[10];
     foo(i);
+    return 0;
 }
diff --git a/samples/AssignmentAddressToInteger/good.c b/samples/AssignmentAddressToInteger/good.c
index 32b68628ca8..ca2bdd961ff 100644
--- a/samples/AssignmentAddressToInteger/good.c
+++ b/samples/AssignmentAddressToInteger/good.c
@@ -1,4 +1,4 @@
-int* foo(int *p)
+static int* foo(int *p)
 {
     return p + 4;
 }
@@ -7,4 +7,5 @@ int main()
 {
     int i[10];
     foo(i);
+    return 0;
 }
diff --git a/samples/accessMoved/bad.cpp b/samples/accessMoved/bad.cpp
new file mode 100644
index 00000000000..bab99668ea8
--- /dev/null
+++ b/samples/accessMoved/bad.cpp
@@ -0,0 +1,9 @@
+void foo(std::string);
+
+int main()
+{
+    std::string s = "test";
+    foo(std::move(s));
+
+    std::cout << s << std::endl;
+}
diff --git a/samples/accessMoved/good.cpp b/samples/accessMoved/good.cpp
new file mode 100644
index 00000000000..1dbc465db13
--- /dev/null
+++ b/samples/accessMoved/good.cpp
@@ -0,0 +1,9 @@
+void foo(std::string);
+
+int main()
+{
+    std::string s = "test";
+    foo(s);
+
+    std::cout << s << std::endl;
+}
diff --git a/samples/accessMoved/out.txt b/samples/accessMoved/out.txt
new file mode 100644
index 00000000000..1f04563d6da
--- /dev/null
+++ b/samples/accessMoved/out.txt
@@ -0,0 +1,9 @@
+samples\accessMoved\bad.cpp:8:18: warning: Access of moved variable 's'. [accessMoved]
+    std::cout << s << std::endl;
+                 ^
+samples\accessMoved\bad.cpp:6:9: note: Calling std::move(s)
+    foo(std::move(s));
+        ^
+samples\accessMoved\bad.cpp:8:18: note: Access of moved variable 's'.
+    std::cout << s << std::endl;
+                 ^
diff --git a/samples/arrayIndexOutOfBounds/out.txt b/samples/arrayIndexOutOfBounds/out.txt
deleted file mode 100644
index bb8c14037bf..00000000000
--- a/samples/arrayIndexOutOfBounds/out.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-samples\arrayIndexOutOfBounds\bad.c:7:6: error: Array 'a[2]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]
-    a[2] = 0;
-     ^
diff --git a/samples/arrayIndexOutOfBounds/bad.c b/samples/arrayIndexOutOfBounds_1/bad.c
similarity index 100%
rename from samples/arrayIndexOutOfBounds/bad.c
rename to samples/arrayIndexOutOfBounds_1/bad.c
diff --git a/samples/arrayIndexOutOfBounds/good.c b/samples/arrayIndexOutOfBounds_1/good.c
similarity index 100%
rename from samples/arrayIndexOutOfBounds/good.c
rename to samples/arrayIndexOutOfBounds_1/good.c
diff --git a/samples/arrayIndexOutOfBounds_1/out.txt b/samples/arrayIndexOutOfBounds_1/out.txt
new file mode 100644
index 00000000000..c1ed04774d8
--- /dev/null
+++ b/samples/arrayIndexOutOfBounds_1/out.txt
@@ -0,0 +1,3 @@
+samples\arrayIndexOutOfBounds_1\bad.c:7:6: error: Array 'a[2]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]
+    a[2] = 0;
+     ^
diff --git a/samples/arrayIndexOutOfBounds_2/bad.c b/samples/arrayIndexOutOfBounds_2/bad.c
new file mode 100644
index 00000000000..169a2d1dea3
--- /dev/null
+++ b/samples/arrayIndexOutOfBounds_2/bad.c
@@ -0,0 +1,8 @@
+int main()
+{
+    int a[2];
+    int i;
+    for (i = 0; i < 3; i++)
+        a[i] = 0;
+    return a[0];
+}
diff --git a/samples/arrayIndexOutOfBounds_2/good.c b/samples/arrayIndexOutOfBounds_2/good.c
new file mode 100644
index 00000000000..62fa9eb55d2
--- /dev/null
+++ b/samples/arrayIndexOutOfBounds_2/good.c
@@ -0,0 +1,8 @@
+int main()
+{
+    int a[3];
+    int i;
+    for (i = 0; i < 3; i++)
+        a[i] = 0;
+    return a[0];
+}
diff --git a/samples/arrayIndexOutOfBounds_2/out.txt b/samples/arrayIndexOutOfBounds_2/out.txt
new file mode 100644
index 00000000000..9fcc517dedd
--- /dev/null
+++ b/samples/arrayIndexOutOfBounds_2/out.txt
@@ -0,0 +1,9 @@
+samples\arrayIndexOutOfBounds_2\bad.c:6:10: error: Array 'a[2]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]
+        a[i] = 0;
+         ^
+samples\arrayIndexOutOfBounds_2\bad.c:5:19: note: Assuming that condition 'i<3' is not redundant
+    for (i = 0; i < 3; i++)
+                  ^
+samples\arrayIndexOutOfBounds_2\bad.c:6:10: note: Array index out of bounds
+        a[i] = 0;
+         ^
diff --git a/samples/autoVariables/bad.c b/samples/autoVariables/bad.c
index c1871886612..9f4d0641049 100644
--- a/samples/autoVariables/bad.c
+++ b/samples/autoVariables/bad.c
@@ -1,4 +1,4 @@
-void foo(int **a)
+static void foo(int **a)
 {
     int b = 1;
     *a = &b;
@@ -8,4 +8,5 @@ int main()
 {
     int *c;
     foo(&c);
+    return 0;
 }
diff --git a/samples/autoVariables/good.c b/samples/autoVariables/good.c
index 61cb17e42da..d94869262f7 100644
--- a/samples/autoVariables/good.c
+++ b/samples/autoVariables/good.c
@@ -1,4 +1,4 @@
-void foo(int **a)
+static void foo(int **a)
 {
     int b = 1;
     **a = b;
@@ -9,4 +9,5 @@ int main()
     int b;
     int *c = &b;
     foo(&c);
+    return 0;
 }
diff --git a/samples/bufferAccessOutOfBounds/bad.c b/samples/bufferAccessOutOfBounds/bad.c
index 169a2d1dea3..e52bdb6a195 100644
--- a/samples/bufferAccessOutOfBounds/bad.c
+++ b/samples/bufferAccessOutOfBounds/bad.c
@@ -1,8 +1,7 @@
+#include <stdio.h>
 int main()
 {
-    int a[2];
-    int i;
-    for (i = 0; i < 3; i++)
-        a[i] = 0;
-    return a[0];
+    char str[5];
+    strcpy(str, "0123456789abcdef");
+    return 0;
 }
diff --git a/samples/bufferAccessOutOfBounds/good.c b/samples/bufferAccessOutOfBounds/good.c
index 62fa9eb55d2..21bcabab1af 100644
--- a/samples/bufferAccessOutOfBounds/good.c
+++ b/samples/bufferAccessOutOfBounds/good.c
@@ -1,8 +1,7 @@
+#include <stdio.h>
 int main()
 {
-    int a[3];
-    int i;
-    for (i = 0; i < 3; i++)
-        a[i] = 0;
-    return a[0];
+    char str[10];
+    snprintf(str, 10, "%s", "abc");
+    return 0;
 }
diff --git a/samples/bufferAccessOutOfBounds/out.txt b/samples/bufferAccessOutOfBounds/out.txt
index f166c371f0f..11c9d04a597 100644
--- a/samples/bufferAccessOutOfBounds/out.txt
+++ b/samples/bufferAccessOutOfBounds/out.txt
@@ -1,3 +1,3 @@
-samples\bufferAccessOutOfBounds\bad.c:6:10: error: Array 'a[2]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]
-        a[i] = 0;
-         ^
+samples\bufferAccessOutOfBounds\bad.c:5:12: error: Buffer is accessed out of bounds: str [bufferAccessOutOfBounds]
+    strcpy(str, "0123456789abcdef");
+           ^
diff --git a/samples/erase/out.txt b/samples/erase/out.txt
deleted file mode 100644
index d6f3852b657..00000000000
--- a/samples/erase/out.txt
+++ /dev/null
@@ -1,24 +0,0 @@
-samples\erase\bad.cpp:9:32: error: Using iterator to local container 'items' that may be invalid. [invalidContainer]
-    for (iter = items.begin(); iter != items.end(); ++iter) {
-                               ^
-samples\erase\bad.cpp:9:17: note: Iterator to container is created here.
-    for (iter = items.begin(); iter != items.end(); ++iter) {
-                ^
-samples\erase\bad.cpp:10:19: note: Assuming condition is true.
-        if (*iter == 2) {
-                  ^
-samples\erase\bad.cpp:10:19: note: Assuming condition is true.
-        if (*iter == 2) {
-                  ^
-samples\erase\bad.cpp:9:37: note: Assuming condition is true.
-    for (iter = items.begin(); iter != items.end(); ++iter) {
-                                    ^
-samples\erase\bad.cpp:11:13: note: After calling 'erase', iterators or references to the container's data may be invalid .
-            items.erase(iter);
-            ^
-samples\erase\bad.cpp:4:22: note: Variable created here.
-    std::vector<int> items;
-                     ^
-samples\erase\bad.cpp:9:32: note: Using iterator to local container 'items' that may be invalid.
-    for (iter = items.begin(); iter != items.end(); ++iter) {
-                               ^
diff --git a/samples/incorrectLogicOperator/bad.c b/samples/incorrectLogicOperator/bad.c
new file mode 100644
index 00000000000..c3f80d8a71f
--- /dev/null
+++ b/samples/incorrectLogicOperator/bad.c
@@ -0,0 +1,6 @@
+
+static void foo(int x) {
+    if (x >= 0 || x <= 10) {}
+}
+
+dummy=foo();
diff --git a/samples/incorrectLogicOperator/good.c b/samples/incorrectLogicOperator/good.c
new file mode 100644
index 00000000000..0dc96bd8a28
--- /dev/null
+++ b/samples/incorrectLogicOperator/good.c
@@ -0,0 +1,6 @@
+
+static void foo(int x) {
+    if (x >= 0 && x <= 10) {}
+}
+
+dummy=foo();
diff --git a/samples/incorrectLogicOperator/out.txt b/samples/incorrectLogicOperator/out.txt
new file mode 100644
index 00000000000..e6cf2c5f76f
--- /dev/null
+++ b/samples/incorrectLogicOperator/out.txt
@@ -0,0 +1,3 @@
+samples\incorrectLogicOperator\bad.c:3:16: warning: Logical disjunction always evaluates to true: x >= 0 || x <= 10. [incorrectLogicOperator]
+    if (x >= 0 || x <= 10) {}
+               ^
diff --git a/samples/erase/bad.cpp b/samples/invalidContainer/bad.cpp
similarity index 100%
rename from samples/erase/bad.cpp
rename to samples/invalidContainer/bad.cpp
diff --git a/samples/erase/good.cpp b/samples/invalidContainer/good.cpp
similarity index 100%
rename from samples/erase/good.cpp
rename to samples/invalidContainer/good.cpp
diff --git a/samples/invalidContainer/out.txt b/samples/invalidContainer/out.txt
new file mode 100644
index 00000000000..767cf898643
--- /dev/null
+++ b/samples/invalidContainer/out.txt
@@ -0,0 +1,24 @@
+samples\invalidContainer\bad.cpp:9:32: error: inconclusive: Using iterator to local container 'items' that may be invalid. [invalidContainer]
+    for (iter = items.begin(); iter != items.end(); ++iter) {
+                               ^
+samples\invalidContainer\bad.cpp:9:28: note: Iterator to container is created here.
+    for (iter = items.begin(); iter != items.end(); ++iter) {
+                           ^
+samples\invalidContainer\bad.cpp:10:19: note: Assuming condition is true.
+        if (*iter == 2) {
+                  ^
+samples\invalidContainer\bad.cpp:10:19: note: Assuming condition is true.
+        if (*iter == 2) {
+                  ^
+samples\invalidContainer\bad.cpp:9:37: note: Assuming condition is true.
+    for (iter = items.begin(); iter != items.end(); ++iter) {
+                                    ^
+samples\invalidContainer\bad.cpp:11:19: note: After calling 'erase', iterators or references to the container's data may be invalid .
+            items.erase(iter);
+                  ^
+samples\invalidContainer\bad.cpp:4:22: note: Variable created here.
+    std::vector<int> items;
+                     ^
+samples\invalidContainer\bad.cpp:9:32: note: Using iterator to local container 'items' that may be invalid.
+    for (iter = items.begin(); iter != items.end(); ++iter) {
+                               ^
diff --git a/samples/memleak/bad.c b/samples/memleak/bad.c
index c61a8309cbf..47797f7b08e 100644
--- a/samples/memleak/bad.c
+++ b/samples/memleak/bad.c
@@ -1,9 +1,11 @@
 #include <stdlib.h>
 int main()
 {
-    int result;
+    int result = 0;
     char *a = malloc(10);
-    a[0] = 0;
-    result = a[0];
+    if (a) {
+        a[0] = 0;
+        result = a[0];
+    }
     return result;
 }
diff --git a/samples/memleak/good.c b/samples/memleak/good.c
index 862f35fc7f9..8bf183ab961 100644
--- a/samples/memleak/good.c
+++ b/samples/memleak/good.c
@@ -1,10 +1,12 @@
 #include <stdlib.h>
 int main()
 {
-    int result;
+    int result = 0;
     char *a = malloc(10);
-    a[0] = 0;
-    result = a[0];
-    free(a);
+    if (a) {
+        a[0] = 0;
+        result = a[0];
+        free(a);
+    }
     return result;
 }
diff --git a/samples/memleak/out.txt b/samples/memleak/out.txt
index 263ac1b1a08..1165e14d299 100644
--- a/samples/memleak/out.txt
+++ b/samples/memleak/out.txt
@@ -1,3 +1,3 @@
-samples/memleak/bad.c:8:5: error: Memory leak: a [memleak]
+samples\memleak\bad.c:10:5: error: Memory leak: a [memleak]
     return result;
     ^
diff --git a/samples/multiCondition/bad.c b/samples/multiCondition/bad.c
new file mode 100644
index 00000000000..dd352a189bf
--- /dev/null
+++ b/samples/multiCondition/bad.c
@@ -0,0 +1,11 @@
+static void f(bool b)
+{
+    if (b) {}
+    else if (!b) {}
+}
+
+int main()
+{
+    f(true);
+    return 0;
+}
diff --git a/samples/multiCondition/good.c b/samples/multiCondition/good.c
new file mode 100644
index 00000000000..715844f85ca
--- /dev/null
+++ b/samples/multiCondition/good.c
@@ -0,0 +1,11 @@
+static void f(bool b)
+{
+    if (b) {}
+    else {}
+}
+
+int main()
+{
+    f(true);
+    return 0;
+}
\ No newline at end of file
diff --git a/samples/multiCondition/out.txt b/samples/multiCondition/out.txt
new file mode 100644
index 00000000000..8753c103594
--- /dev/null
+++ b/samples/multiCondition/out.txt
@@ -0,0 +1,9 @@
+samples\multiCondition\bad.c:4:14: style: Expression is always true because 'else if' condition is opposite to previous condition at line 3. [multiCondition]
+    else if (!b) {}
+             ^
+samples\multiCondition\bad.c:3:9: note: first condition
+    if (b) {}
+        ^
+samples\multiCondition\bad.c:4:14: note: else if condition is opposite to first condition
+    else if (!b) {}
+             ^
diff --git a/samples/outOfBounds/bad.c b/samples/outOfBounds/bad.c
deleted file mode 100644
index b34db614c57..00000000000
--- a/samples/outOfBounds/bad.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <stdio.h>
-int main()
-{
-    char str[5];
-    strcpy(str, "0123456789abcdef");
-}
diff --git a/samples/outOfBounds/good.c b/samples/outOfBounds/good.c
deleted file mode 100644
index a103928f90d..00000000000
--- a/samples/outOfBounds/good.c
+++ /dev/null
@@ -1,6 +0,0 @@
-#include <stdio.h>
-int main()
-{
-    char str[10];
-    snprintf(str, 10, "%s", "abc");
-}
diff --git a/samples/outOfBounds/out.txt b/samples/outOfBounds/out.txt
deleted file mode 100644
index 9ce3af4a5a8..00000000000
--- a/samples/outOfBounds/out.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-samples\outOfBounds\bad.c:5:12: error: Buffer is accessed out of bounds: str [bufferAccessOutOfBounds]
-    strcpy(str, "0123456789abcdef");
-           ^
diff --git a/samples/passedByValue_1/bad.cpp b/samples/passedByValue_1/bad.cpp
new file mode 100644
index 00000000000..413b4327a74
--- /dev/null
+++ b/samples/passedByValue_1/bad.cpp
@@ -0,0 +1,11 @@
+class C
+{
+public:
+    explicit C(std::string s)
+    : _s(s)
+    {
+    }
+    void foo();
+private:
+    std::string _s;
+};
\ No newline at end of file
diff --git a/samples/passedByValue_1/good.cpp b/samples/passedByValue_1/good.cpp
new file mode 100644
index 00000000000..fd1f1450d17
--- /dev/null
+++ b/samples/passedByValue_1/good.cpp
@@ -0,0 +1,11 @@
+class C
+{
+public:
+    explicit C(std::string s)
+    : _s(std::move(s))
+    {
+    }
+    void foo();
+private:
+    std::string _s;
+};
\ No newline at end of file
diff --git a/samples/passedByValue_1/out.txt b/samples/passedByValue_1/out.txt
new file mode 100644
index 00000000000..07228031d62
--- /dev/null
+++ b/samples/passedByValue_1/out.txt
@@ -0,0 +1,3 @@
+samples\passedByValue_1\bad.cpp:4:28: performance: Function parameter 's' should be passed by const reference. [passedByValue]
+    explicit C(std::string s)
+                           ^
diff --git a/samples/passedByValue_2/bad.cpp b/samples/passedByValue_2/bad.cpp
new file mode 100644
index 00000000000..29da7fe9036
--- /dev/null
+++ b/samples/passedByValue_2/bad.cpp
@@ -0,0 +1,10 @@
+bool foo(std::string s)
+{
+    return s.empty();
+}
+
+int main()
+{
+    std::string s;
+    foo(s);
+}
diff --git a/samples/passedByValue_2/good.cpp b/samples/passedByValue_2/good.cpp
new file mode 100644
index 00000000000..bd3a941a45b
--- /dev/null
+++ b/samples/passedByValue_2/good.cpp
@@ -0,0 +1,10 @@
+bool foo(const std::string& s)
+{
+    return s.empty();
+}
+
+int main()
+{
+    std::string s;
+    foo(s);
+}
diff --git a/samples/passedByValue_2/out.txt b/samples/passedByValue_2/out.txt
new file mode 100644
index 00000000000..af76b252ad1
--- /dev/null
+++ b/samples/passedByValue_2/out.txt
@@ -0,0 +1,3 @@
+samples\passedByValue_2\bad.cpp:1:22: performance: Function parameter 's' should be passed by const reference. [passedByValue]
+bool foo(std::string s)
+                     ^
diff --git a/samples/resourceLeak/bad.c b/samples/resourceLeak/bad.c
index b517297a1b1..4595f10f4a4 100644
--- a/samples/resourceLeak/bad.c
+++ b/samples/resourceLeak/bad.c
@@ -1,7 +1,7 @@
 #include <stdio.h>
 int main()
 {
-    FILE *a = fopen("good.c", "r");
+    const FILE *a = fopen("good.c", "r");
     if (!a)
         return 0;
 
diff --git a/samples/syntaxError/bad.c b/samples/syntaxError/bad.c
index 3316e50dbc9..25b30b6943f 100644
--- a/samples/syntaxError/bad.c
+++ b/samples/syntaxError/bad.c
@@ -1,5 +1,6 @@
 int main()
 {
+    return 0;
 #ifdef A
 }
 #endif
diff --git a/samples/syntaxError/good.c b/samples/syntaxError/good.c
index 0686f8ecbea..ecec51baf56 100644
--- a/samples/syntaxError/good.c
+++ b/samples/syntaxError/good.c
@@ -2,4 +2,5 @@ int main()
 {
 #ifndef A
 #endif
+    return 0;
 }
diff --git a/samples/unreadVariable/bad.cpp b/samples/unreadVariable/bad.cpp
new file mode 100644
index 00000000000..456304ad64a
--- /dev/null
+++ b/samples/unreadVariable/bad.cpp
@@ -0,0 +1,7 @@
+void foo(const std::string&, const std::string&);
+
+int main()
+{
+    std::string s1 = "test1", s2 = "test2";
+    foo(s1, s1);
+}
diff --git a/samples/unreadVariable/good.cpp b/samples/unreadVariable/good.cpp
new file mode 100644
index 00000000000..0b9871d8a33
--- /dev/null
+++ b/samples/unreadVariable/good.cpp
@@ -0,0 +1,7 @@
+void foo(const std::string&, const std::string&);
+
+int main()
+{
+    std::string s1 = "test1", s2 = "test2";
+    foo(s1, s2);
+}
diff --git a/samples/unreadVariable/out.txt b/samples/unreadVariable/out.txt
new file mode 100644
index 00000000000..1797e13dbbe
--- /dev/null
+++ b/samples/unreadVariable/out.txt
@@ -0,0 +1,3 @@
+samples\unreadVariable\bad.cpp:5:34: style: Variable 's2' is assigned a value that is never used. [unreadVariable]
+    std::string s1 = "test1", s2 = "test2";
+                                 ^
diff --git a/selfcheck.sh b/selfcheck.sh
new file mode 100755
index 00000000000..7f919334c18
--- /dev/null
+++ b/selfcheck.sh
@@ -0,0 +1,39 @@
+#!/bin/sh
+
+selfcheck_options="-q -j$(nproc) --std=c++11 --template=selfcheck --showtime=file-total -D__GNUC__ --error-exitcode=1 --inline-suppr --suppressions-list=.selfcheck_suppressions --library=gnu --inconclusive --enable=style,performance,portability,warning,missingInclude,information --exception-handling --debug-warnings --check-level=exhaustive"
+cppcheck_options="-D__CPPCHECK__ -DCHECK_INTERNAL -DHAVE_RULES --library=cppcheck-lib -Ilib -Iexternals/simplecpp/ -Iexternals/tinyxml2"
+gui_options="-DQT_VERSION=0x060000 -DQ_MOC_OUTPUT_REVISION=68 -DQT_CHARTS_LIB -DQT_MOC_HAS_STRINGDATA --library=qt"
+naming_options="--addon-python=$(command -v python) --addon=naming.json"
+
+if [ -n "$1" ]; then
+  selfcheck_options="$selfcheck_options $1"
+fi
+
+mkdir_cmd=$(command -v mkdir)
+rm_cmd=$(command -v rm)
+
+# clear PATH to prevent unintentional process invocations
+export PATH=
+
+ec=0
+
+# self check externals
+./cppcheck $selfcheck_options externals || ec=1
+# self check lib/cli
+$mkdir_cmd b1
+./cppcheck $selfcheck_options $cppcheck_options --cppcheck-build-dir=b1 $naming_options frontend || ec=1
+./cppcheck $selfcheck_options $cppcheck_options --cppcheck-build-dir=b1 $naming_options -Ifrontend cli || ec=1
+./cppcheck $selfcheck_options $cppcheck_options --cppcheck-build-dir=b1 $naming_options --enable=internal lib || ec=1
+# check gui with qt settings
+$mkdir_cmd b2
+./cppcheck $selfcheck_options $cppcheck_options $gui_options --cppcheck-build-dir=b2 $naming_options -Icmake.output/gui -Ifrontend -Igui gui/*.cpp cmake.output/gui || ec=1
+# self check test and tools
+./cppcheck $selfcheck_options $cppcheck_options -Ifrontend -Icli test/*.cpp || ec=1
+./cppcheck $selfcheck_options $cppcheck_options -Icli tools/dmake/*.cpp || ec=1
+# triage
+./cppcheck $selfcheck_options $cppcheck_options $gui_options -Icmake.output/tools/triage -Igui tools/triage/*.cpp cmake.output/tools/triage || ec=1
+
+$rm_cmd -rf b2
+$rm_cmd -rf b1
+
+exit $ec
\ No newline at end of file
diff --git a/selfcheck_san.sh b/selfcheck_san.sh
new file mode 100755
index 00000000000..5c8fef353c2
--- /dev/null
+++ b/selfcheck_san.sh
@@ -0,0 +1,58 @@
+#!/bin/sh
+
+cmake_output="$1"
+selfcheck_options_extra="$2"
+
+selfcheck_options="-q -j$(nproc) --std=c++11 --template=selfcheck --showtime=file-total -D__GNUC__ --error-exitcode=1 --inline-suppr --suppressions-list=.selfcheck_suppressions --library=gnu --inconclusive --enable=style,performance,portability,warning,missingInclude,information --exception-handling --debug-warnings --check-level=exhaustive"
+selfcheck_options="$selfcheck_options $selfcheck_options_extra"
+cppcheck_options="-D__CPPCHECK__ -DCHECK_INTERNAL -DHAVE_RULES --library=cppcheck-lib -Ilib -Iexternals/simplecpp/ -Iexternals/tinyxml2"
+qt_options="--library=qt -DQT_VERSION=0x060000 -DQ_MOC_OUTPUT_REVISION=69 -DQT_MOC_HAS_STRINGDATA"
+qt_options="$qt_options --suppress=autoNoType:*/moc_*.cpp --suppress=symbolDatabaseWarning:*/moc_*.cpp"
+naming_options="--addon-python=$(command -v python) --addon=naming.json"
+
+# clear PATH to prevent unintentional process invocations
+export PATH=
+
+ec=0
+
+$cmake_output/bin/cppcheck $selfcheck_options \
+  externals \
+  || ec=1
+
+$cmake_output/bin/cppcheck $selfcheck_options $cppcheck_options $naming_options \
+  frontend \
+  || ec=1
+
+$cmake_output/bin/cppcheck $selfcheck_options $cppcheck_options $naming_options \
+  -Ifrontend \
+  cli \
+  || ec=1
+
+$cmake_output/bin/cppcheck $selfcheck_options $cppcheck_options $naming_options \
+  --enable=internal \
+  lib \
+  || ec=1
+
+$cmake_output/bin/cppcheck $selfcheck_options $cppcheck_options $naming_options $qt_options \
+  --suppress=constVariablePointer:*/moc_*.cpp \
+  -DQT_CHARTS_LIB \
+  -I$cmake_output/gui -Ifrontend -Igui \
+  gui/*.cpp $cmake_output/gui \
+  || ec=1
+
+$cmake_output/bin/cppcheck $selfcheck_options $cppcheck_options \
+  -Icli -Ifrontend \
+  test/*.cpp \
+  || ec=1
+
+$cmake_output/bin/cppcheck $selfcheck_options $cppcheck_options \
+  -Icli \
+  tools/dmake/*.cpp \
+  || ec=1
+
+$cmake_output/bin/cppcheck $selfcheck_options $cppcheck_options $qt_options \
+  -I$cmake_output/tools/triage -Igui \
+  tools/triage/*.cpp $cmake_output/tools/triage \
+  || ec=1
+
+exit $ec
\ No newline at end of file
diff --git a/test/.clang-tidy b/test/.clang-tidy
new file mode 100644
index 00000000000..1f832f2d39e
--- /dev/null
+++ b/test/.clang-tidy
@@ -0,0 +1,7 @@
+---
+InheritParentConfig: true
+CheckOptions:
+  #- key:             bugprone-unused-return-value.CheckedFunctions
+  #  value:           '::.*'
+  - key:             bugprone-unused-return-value.AllowCastToVoid
+    value:           'true'
\ No newline at end of file
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index ab38e615498..14f3a8eac17 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,128 +1,198 @@
-if (BUILD_TESTS)
-
-    cmake_policy(SET CMP0064 NEW)
-    cmake_policy(SET CMP0057 NEW)
-
-    include(CTest)
-
-    find_package(Threads REQUIRED)
-    include(ProcessorCount)
-    ProcessorCount(N)
-    set(CTEST_PARALLEL_LEVEL ${N} CACHE STRING "CTest parallel level")
-    add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -j ${CTEST_PARALLEL_LEVEL} -C ${CMAKE_CFG_INTDIR} --timeout 90)
-
-    include_directories(${PROJECT_SOURCE_DIR}/lib/ ${PROJECT_SOURCE_DIR}/cli/)
-    include_directories(SYSTEM ${PROJECT_SOURCE_DIR}/externals/tinyxml)
-    include_directories(${PROJECT_SOURCE_DIR}/externals/simplecpp/)
+if (BUILD_TESTING)
+    add_subdirectory(signal)
+    add_subdirectory(seh)
 
     file(GLOB hdrs "*.h")
     file(GLOB srcs "*.cpp")
+    list(APPEND testrunner_SOURCES ${hdrs} ${srcs})
 
-    add_executable(testrunner ${hdrs} ${srcs} $<TARGET_OBJECTS:lib_objs> $<TARGET_OBJECTS:cli_objs> $<TARGET_OBJECTS:tinyxml_objs> $<TARGET_OBJECTS:simplecpp_objs>)
-    if (HAVE_RULES)
-        target_link_libraries(testrunner pcre)
-    endif()
-
-    add_custom_target(copy_cfg ALL
-        COMMENT "Copying cfg files")
-    add_custom_command(
-        TARGET copy_cfg
-        COMMAND ${CMAKE_COMMAND} -E copy_directory "${PROJECT_SOURCE_DIR}/cfg"
-            "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/cfg")
-
+    add_executable(testrunner ${testrunner_SOURCES})
+    target_link_libraries(testrunner cppcheck-core tinyxml2 picojson simplecpp frontend cli)
     if (WIN32 AND NOT BORLAND)
-        target_link_libraries(testrunner Shlwapi.lib)
-    endif()
-
-    add_dependencies(testrunner copy_cfg)
-    add_dependencies(check testrunner cppcheck)
-
-    set(SKIP_TESTS "" CACHE STRING "A list of tests to skip")
-
-    function(add_fixture NAME)
-        if (${NAME} IN_LIST SKIP_TESTS)
+        if(NOT MINGW)
+            target_link_libraries(testrunner Shlwapi.lib)
         else()
-            add_test(NAME ${NAME} COMMAND testrunner ${NAME} WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
+            target_link_libraries(testrunner shlwapi)
         endif()
-    endfunction()
+    endif()
+    target_link_libraries(testrunner ${CMAKE_THREAD_LIBS_INIT})
+    if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+        # (void) in ASSERT_THROW* macros might trigger this
+        target_compile_options_safe(testrunner -Wno-useless-cast)
+    endif()
+    if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        # $ is used in dinit() designated initialization helper
+        target_compile_options_safe(testrunner -Wno-dollar-in-identifier-extension)
+    endif()
 
-    function(fixture_cost NAME COST)
-        if(TEST ${NAME})
-            set_tests_properties(${NAME} PROPERTIES COST ${COST})
-        endif()
-    endfunction()
+    if (NOT CMAKE_DISABLE_PRECOMPILE_HEADERS)
+        target_precompile_headers(testrunner PRIVATE precompiled.h)
+    endif()
 
-    foreach(SRC ${srcs})
-        file(STRINGS ${SRC} FIXTURE_LINE REGEX "TestFixture\\(" LIMIT_COUNT 1)
-        if(FIXTURE_LINE MATCHES "TestFixture\\(\"([a-zA-z0-9]+)\"\\)")
-            add_fixture(${CMAKE_MATCH_1})
-        endif()
-    endforeach()
+    add_dependencies(testrunner copy_cfg)
+    add_dependencies(testrunner copy_addons)
+    add_dependencies(testrunner copy_platforms)
+    if (NOT DISABLE_DMAKE)
+        add_dependencies(testrunner run-dmake)
+    endif()
 
-    function(add_cfg CFG_TEST)
-        set(options INCONCLUSIVE)
-        set(oneValueArgs PLATFORM NAME)
-        set(multiValueArgs LIBRARY)
+    if (LIBXML2_XMLLINT_EXECUTABLE)
+        # TODO: run the CMake implementation of the tests
+        # TODO: get rid of the copy
+        add_custom_target(checkcfg ${CMAKE_COMMAND} -E copy $<TARGET_FILE:cppcheck> ${CMAKE_SOURCE_DIR}
+                COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/cfg/runtests.sh
+                DEPENDS cppcheck validateCFG)
+    endif()
 
-        cmake_parse_arguments(PARSE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-        if(PARSE_LIBRARY)
-            string(REPLACE ";" "," LIBRARY "${PARSE_LIBRARY}")
-        else()
+    if (REGISTER_TESTS)
+        # CMAKE_MATCH_<n> usage for if (MATCHES) requires CMake 3.9
+
+        find_package(Threads REQUIRED)
+        include(ProcessorCount)
+        ProcessorCount(N)
+        set(CTEST_PARALLEL_LEVEL ${N} CACHE STRING "CTest parallel level")
+        # the macos-* runners are sporadically much slower than other runners so chose a high timeout
+        set(CTEST_TIMEOUT 130 CACHE STRING "CTest timeout")
+        add_custom_target(check ${CMAKE_CTEST_COMMAND} --output-on-failure -j ${CTEST_PARALLEL_LEVEL} -C ${CMAKE_CFG_INTDIR} --timeout ${CTEST_TIMEOUT}
+                DEPENDS testrunner cppcheck)
+
+        set(SKIP_TESTS "" CACHE STRING "A list of tests to skip")
+
+        function(add_fixture NAME)
+            if (${NAME} IN_LIST SKIP_TESTS)
+            elseif(TEST ${NAME})
+            else()
+                add_test(NAME ${NAME} COMMAND $<TARGET_FILE:testrunner> ${NAME} WORKING_DIRECTORY ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
+            endif()
+        endfunction()
+
+        foreach(SRC ${srcs})
+            file(STRINGS ${SRC} FIXTURE_LINE REGEX "^REGISTER_TEST\\([a-zA-z0-9]+\\)$")
+            foreach(_fixture_line ${FIXTURE_LINE})
+                if(_fixture_line MATCHES "^REGISTER_TEST\\(([a-zA-z0-9]+)\\)$")
+                    add_fixture(${CMAKE_MATCH_1})
+                endif()
+            endforeach()
+        endforeach()
+
+        function(add_cfg CFG_TEST)
+            set(oneValueArgs PLATFORM NAME)
+            set(multiValueArgs ADD_LIBRARY)
+
+            cmake_parse_arguments(PARSE "" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
             get_filename_component(LIBRARY ${CFG_TEST} NAME_WE)
+            # TODO: get rid of this
+            if(PARSE_ADD_LIBRARY)
+                string(REPLACE ";" "," ADD_LIBRARY "${PARSE_ADD_LIBRARY}")
+                set(LIBRARY "${ADD_LIBRARY},${LIBRARY}")
+            endif()
+            set(PLATFORM unix64)
+            if(PARSE_PLATFORM)
+                set(PLATFORM ${PARSE_PLATFORM})
+            endif()
+            if(PARSE_NAME)
+                set(TEST_NAME ${PARSE_NAME})
+            else()
+                string(MAKE_C_IDENTIFIER ${CFG_TEST} TEST_NAME)
+            endif()
+            if ("cfg-${TEST_NAME}" IN_LIST SKIP_TESTS)
+            else()
+                # TODO: add syntax check
+                add_test(NAME cfg-${TEST_NAME}
+                        COMMAND $<TARGET_FILE:cppcheck>
+                        --library=${LIBRARY}
+                        --check-library
+                        --check-level=exhaustive
+                        --platform=${PLATFORM}
+                        --enable=style,information
+                        --inconclusive
+                        --force
+                        --error-exitcode=1
+                        --inline-suppr
+                        --debug-warnings
+                        --suppress=checkersReport
+                        ${CMAKE_CURRENT_SOURCE_DIR}/cfg/${CFG_TEST}
+                )
+            endif()
+        endfunction()
+        # TODO: glob this
+        add_cfg(boost.cpp)
+        add_cfg(bsd.c)
+        add_cfg(cairo.c)
+        add_cfg(cppunit.cpp)
+        add_cfg(emscripten.cpp)
+        # TODO: posix needs to specified first or it has a different mmap() config
+        # TODO: get rid of posix dependency
+        add_cfg(gnu.c ADD_LIBRARY posix)
+        add_cfg(googletest.cpp)
+        add_cfg(gtk.c)
+        add_cfg(kde.cpp ADD_LIBRARY qt)
+        add_cfg(libcurl.c)
+        add_cfg(libsigc++.cpp)
+        add_cfg(lua.c)
+        add_cfg(mfc.cpp)
+        add_cfg(opencv2.cpp)
+        add_cfg(openmp.c)
+        add_cfg(openssl.c)
+        add_cfg(posix.c)
+        add_cfg(python.c)
+        add_cfg(qt.cpp)
+        add_cfg(selinux.c)
+        add_cfg(sqlite3.c)
+        add_cfg(std.c)
+        add_cfg(std.cpp)
+        add_cfg(windows.cpp NAME windows32A PLATFORM win32A)
+        add_cfg(windows.cpp NAME windows32W PLATFORM win32W)
+        add_cfg(windows.cpp NAME windows64 PLATFORM win64)
+        add_cfg(wxwidgets.cpp)
+
+        function(fixture_cost NAME COST)
+            if(TEST ${NAME})
+                set_tests_properties(${NAME} PROPERTIES COST ${COST})
+            endif()
+        endfunction()
+
+        # Set cost of the more expensive tests to help improve parallel scheduling
+        # of tests
+        #
+        # To collect data to update this list remove "<cmake-build-folder>/Testing/Temporary/CTestCostData.txt",
+        # disable the fixture_cost() statements below and run a Debug build with "ctest -j1" several times.
+        # Afterwards run it with "ctest -j11" and immediately cancel the run and update the list accordingly to the
+        # first eleven tests chosen.
+        #
+        # NOTE: The TestProcessExecutor* tests are not the slowest but they invoke processes which max out the system
+        # and negatively impact the run-time of the other tests
+        if (TRUE)
+            fixture_cost(TestProcessExecutorFiles 2.00)
+            fixture_cost(TestProcessExecutorFS 2.00)
+            fixture_cost(TestCondition 1.30)
+            fixture_cost(TestStl 1.30)
+            fixture_cost(TestTokenizer 1.30)
+            fixture_cost(cfg-std_c 1.20)
+            fixture_cost(cfg-std_cpp 1.20)
+            fixture_cost(TestAutoVariables 1.20)
+            fixture_cost(TestUninitVar 1.20)
+            fixture_cost(TestSimplifyTemplate 1.15)
+            fixture_cost(TestIO 1.15)
+            fixture_cost(TestBufferOverrun 1.15)
+            fixture_cost(TestClass 1.15)
+            fixture_cost(TestNullPointer 1.15)
+            fixture_cost(TestSuppressions 1.15)
+            fixture_cost(TestLeakAutoVar 1.10)
+            fixture_cost(TestSingleExecutorFS 1.10)
+            fixture_cost(TestLeakAutoVarRecursiveCountLimit 1.05)
+            fixture_cost(TestThreadExecutorFS 1.05)
+            fixture_cost(TestThreadExecutorFiles 1.05)
+            fixture_cost(TestSymbolDatabase 1.05)
+            fixture_cost(TestSingleExecutorFiles 1.05)
+            fixture_cost(TestOther 1.05)
+            fixture_cost(TestValueFlow 1.05)
+            fixture_cost(cfg-wxwidgets_cpp 1.05)
+            fixture_cost(cfg-posix_c 1.05)
+            fixture_cost(cfg-windows32A 1.03)
+            fixture_cost(cfg-windows32W 1.03)
+            fixture_cost(cfg-windows64 1.03)
+            fixture_cost(TestUnusedVar 1.03)
         endif()
-        set(PLATFORM unix64)
-        if(PARSE_PLATFORM)
-            set(PLATFORM ${PARSE_PLATFORM})
-        endif()
-        if(PARSE_NAME)
-            set(TEST_NAME ${PARSE_NAME})
-        else()
-            string(MAKE_C_IDENTIFIER ${CFG_TEST} TEST_NAME)
-        endif()
-        set(INCONCLUSIVE)
-        if(PARSE_INCONCLUSIVE)
-            set(INCONCLUSIVE "--inconclusive")
-        endif()
-        if (${TEST_NAME} IN_LIST SKIP_TESTS)
-        else()
-            add_test(NAME cfg-${TEST_NAME} 
-                    COMMAND $<TARGET_FILE:cppcheck>
-                    --check-library
-                    --platform=${PLATFORM}
-                    --library=${LIBRARY}
-                    --enable=information
-                    --enable=style
-                    --error-exitcode=1
-                    --suppress=missingIncludeSystem
-                    --inline-suppr 
-                    ${INCONCLUSIVE}
-                    ${CMAKE_CURRENT_SOURCE_DIR}/cfg/${CFG_TEST}
-            )
-        endif()
-    endfunction()
-    add_cfg(boost.cpp INCONCLUSIVE)
-    add_cfg(bsd.c)
-    add_cfg(gnu.c LIBRARY posix gnu)
-    add_cfg(gtk.c)
-    add_cfg(libcurl.c)
-    add_cfg(lua.c)
-    add_cfg(openmp.c)
-    add_cfg(posix.c)
-    add_cfg(python.c)
-    add_cfg(qt.cpp)
-    add_cfg(sqlite3.c INCONCLUSIVE)
-    add_cfg(std.c INCONCLUSIVE)
-    add_cfg(std.cpp INCONCLUSIVE)
-    add_cfg(windows.cpp INCONCLUSIVE NAME windows32A PLATFORM win32A)
-    add_cfg(windows.cpp INCONCLUSIVE NAME windows32W PLATFORM win32W)
-    add_cfg(windows.cpp INCONCLUSIVE NAME windows64 PLATFORM win64)
-    add_cfg(wxwidgets.cpp INCONCLUSIVE)
-
-    # Set cost of the more expensive tests to help improve parallel scheduling
-    # of tests
-    fixture_cost(TestIO 20)
-    fixture_cost(cfg-std_c 8)
-    fixture_cost(TestThreadExecutor 5)
-    fixture_cost(TestLeakAutoVar 4)
-    fixture_cost(TestTokenizer 4)
+    endif()
 endif()
diff --git a/test/cfg/boost.cpp b/test/cfg/boost.cpp
index a83f7e604c5..7e724a8b472 100644
--- a/test/cfg/boost.cpp
+++ b/test/cfg/boost.cpp
@@ -2,29 +2,41 @@
 // Test library configuration for boost.cfg
 //
 // Usage:
-// $ cppcheck --check-library --enable=information --error-exitcode=1 --suppress=missingIncludeSystem --inline-suppr test/cfg/boost.cpp
+// $ cppcheck --check-library --library=boost --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/boost.cpp
 // =>
 // No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
 //
 
-#include <boost/config.hpp>
+// cppcheck-suppress-file valueFlowBailout
+
+#include <cstdio>
+#include <new>
+#include <tuple>
+
+#include <boost/config.hpp> // IWYU pragma: keep
 #include <boost/math/special_functions/round.hpp>
-#include <boost/endian/conversion.hpp>
-#include <boost/bind.hpp>
-#include <boost/function.hpp>
+#include <boost/endian/conversion.hpp> // IWYU pragma: keep
+#include <boost/bind/bind.hpp>
+#include <boost/function.hpp> // IWYU pragma: keep
+#include <boost/smart_ptr/scoped_array.hpp>
+#include <boost/thread/mutex.hpp> // IWYU pragma: keep
+#include <boost/thread/lock_guard.hpp>
+#include <boost/test/unit_test.hpp> // IWYU pragma: keep
+#include <boost/core/scoped_enum.hpp>
+#include <boost/foreach.hpp>
 
+#include <cstdlib>
+#include <set>
+#include <vector>
 
 BOOST_FORCEINLINE void boost_forceinline_test()
-{
-}
+{}
 
 BOOST_NOINLINE void boost_noinline_test()
-{
-}
+{}
 
 BOOST_NORETURN void boost_noreturn_test()
-{
-}
+{}
 
 void print_hello()
 {
@@ -33,10 +45,8 @@ void print_hello()
 
 void valid_code(boost::function<void(void)> &pf_print_hello)
 {
-    if (BOOST_LIKELY(1)) {
-    }
-    if (BOOST_UNLIKELY(0)) {
-    }
+    if (BOOST_LIKELY(1)) {}
+    if (BOOST_UNLIKELY(0)) {}
 
     int int1 = 5;
     boost::endian::endian_reverse_inplace(int1);
@@ -44,7 +54,7 @@ void valid_code(boost::function<void(void)> &pf_print_hello)
     pf_print_hello = boost::bind(print_hello);
 }
 
-void ignoredReturnValue(char * buf)
+void ignoredReturnValue()
 {
     // cppcheck-suppress ignoredReturnValue
     boost::math::round(1.5);
@@ -67,3 +77,125 @@ void uninitvar()
     // cppcheck-suppress uninitvar
     (void)boost::math::round(intUninit2);
 }
+
+void throwexception(int * buf)
+{
+    if (!buf)
+        boost::throw_exception(std::bad_alloc());
+    *buf = 0;
+}
+
+void throwexception2(int * buf)
+{
+    if (!buf)
+        BOOST_THROW_EXCEPTION(std::bad_alloc());
+    *buf = 0;
+}
+
+void macros()
+{
+#define DECL(z, n, text) text ## n = n;
+    BOOST_PP_REPEAT(5, DECL, int x)
+
+    BOOST_SCOPED_ENUM_DECLARE_BEGIN(future_errc) {
+        // cppcheck-suppress valueFlowBailoutIncompleteVar
+        no_state
+    }
+    BOOST_SCOPED_ENUM_DECLARE_END(future_errc)
+}
+
+void containerOutOfBounds_scoped_array(std::size_t n) // #12356
+{
+    boost::scoped_array<int> d(new int[n] {});
+    for (std::size_t i = 0; i < n; i++)
+        if (d[i]) {}
+}
+
+void lock_guard_finiteLifetime(boost::mutex& m)
+{
+    // cppcheck-suppress unusedScopedObject
+    boost::lock_guard<boost::mutex>{ m };
+}
+
+void test_BOOST_FOREACH_1(std::vector<int> data)
+{
+    BOOST_FOREACH(int i, data) {
+        // cppcheck-suppress invalidContainerLoop
+        data.push_back(123);
+    }
+}
+
+void test_BOOST_FOREACH_2(std::set<int> data)
+{
+    BOOST_FOREACH(int i, data) {
+        // don't warn for std::set
+        data.insert(123);
+    }
+}
+
+void test_BOOST_FOREACH_3(std::vector<int> data)
+{
+    BOOST_FOREACH(const int& i, data) {
+        // cppcheck-suppress invalidContainerLoop
+        data.erase(data.begin());
+    }
+}
+
+// Check single line usage
+void test_BOOST_FOREACH_4(std::vector<int> data)
+{
+    BOOST_FOREACH(const int& i, data)
+        // cppcheck-suppress invalidContainerLoop
+        data.clear();
+}
+
+// Container returned as result of a function -> Be quiet
+std::vector<int> get_data();
+void test_BOOST_FOREACH_5()
+{
+    std::set<int> data;
+    BOOST_FOREACH(const int& i, get_data())
+        data.insert(i);
+}
+
+// Break after modification (#4788)
+void test_BOOST_FOREACH_6(std::vector<int> data)
+{
+    BOOST_FOREACH(int i, data) {
+        data.push_back(123);
+        break;
+    }
+}
+
+void test_require()
+{
+    int *some_int = static_cast<int*>(std::malloc(sizeof(int)));
+    int *some_other_int = static_cast<int*>(malloc(sizeof(int)));
+    BOOST_REQUIRE(some_int);
+    BOOST_TEST_REQUIRE(some_other_int);
+    *some_int = 42;
+    *some_other_int = 42;
+    std::free(some_int);
+    free(some_other_int);
+}
+
+BOOST_AUTO_TEST_SUITE(my_auto_test_suite)
+
+BOOST_AUTO_TEST_CASE(test_message_macros)
+{
+    bool my_bool = false;
+    BOOST_WARN_MESSAGE(my_bool, "warn");
+    BOOST_CHECK_MESSAGE(my_bool, "check");
+    BOOST_REQUIRE_MESSAGE(my_bool, "require");
+
+    BOOST_WARN_MESSAGE(my_bool, "my_bool was: " << my_bool);
+}
+
+using test_types_w_tuples = std::tuple<int, long, unsigned char>;
+BOOST_AUTO_TEST_CASE_TEMPLATE(my_tuple_test, T, test_types_w_tuples)
+{
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
+    BOOST_TEST(sizeof(T) == 4U);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/cfg/bsd.c b/test/cfg/bsd.c
index 725f6cfe175..3cb39c14810 100644
--- a/test/cfg/bsd.c
+++ b/test/cfg/bsd.c
@@ -1,31 +1,82 @@
 // Test library configuration for bsd.cfg
 //
 // Usage:
-// $ cppcheck --library=bsd --check-library --enable=information --error-exitcode=1 --suppress=missingIncludeSystem --inline-suppr test/cfg/bsd.c
+// $ cppcheck --check-library --library=bsd --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/bsd.c
 // =>
 // No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
 //
 
+// cppcheck-suppress-file valueFlowBailout
+
 #include <string.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <sys/time.h>
+#include <sys/uio.h>
+
+void nullPointer_setbuffer(FILE *stream, char *buf, size_t size)
+{
+    // cppcheck-suppress nullPointer
+    (void) setbuffer(NULL, buf, size);
+    (void) setbuffer(stream, NULL, size);
+    (void) setbuffer(stream, buf, size);
+}
+
+void nullPointer_setlinebuf(FILE *stream)
+{
+    // cppcheck-suppress nullPointer
+    (void)setlinebuf(NULL);
+    (void)setlinebuf(stream);
+}
 
 // #9323, #9331
 void verify_timercmp(struct timeval t)
 {
+    // TODO cppcheck-suppress duplicateExpression
     (void)timercmp(&t, &t, <);
+    // TODO cppcheck-suppress duplicateExpression
     (void)timercmp(&t, &t, <=);
     (void)timercmp(&t, &t, ==);
     (void)timercmp(&t, &t, !=);
+    // TODO cppcheck-suppress duplicateExpression
     (void)timercmp(&t, &t, >=);
+    // TODO cppcheck-suppress duplicateExpression
     (void)timercmp(&t, &t, >);
 }
 
+ssize_t nullPointer_readv(int fd, const struct iovec *iov, int iovcnt)
+{
+    // cppcheck-suppress nullPointer
+    (void)readv(fd,NULL,iovcnt);
+    return readv(fd,iov,iovcnt);
+}
+
+ssize_t nullPointer_writev(int fd, const struct iovec *iov, int iovcnt)
+{
+    // cppcheck-suppress nullPointer
+    (void)writev(fd,NULL,iovcnt);
+    return writev(fd,iov,iovcnt);
+}
+
+ssize_t nullPointer_preadv(int fd, const struct iovec *iov, int iovcnt, off_t offset)
+{
+    // cppcheck-suppress nullPointer
+    (void)preadv(fd,NULL,iovcnt,offset);
+    return preadv(fd,iov,iovcnt,offset);
+}
+
+ssize_t nullPointer_pwritev(int fd, const struct iovec *iov, int iovcnt, off_t offset)
+{
+    // cppcheck-suppress nullPointer
+    (void)pwritev(fd,NULL,iovcnt,offset);
+    return pwritev(fd,iov,iovcnt,offset);
+}
+
 // False negative: #9346
 void uninitvar_timercmp(struct timeval t)
 {
     struct timeval uninit;
+    // cppcheck-suppress uninitvar
     (void)timercmp(&t, &uninit, <);
     (void)timercmp(&uninit, &t, <=);
     (void)timercmp(&uninit, &uninit, ==);
@@ -33,6 +84,7 @@ void uninitvar_timercmp(struct timeval t)
 
 void nullPointer_timercmp(struct timeval t)
 {
+    // cppcheck-suppress constVariablePointer
     struct timeval *p=0;
     // cppcheck-suppress nullPointer
     (void)timercmp(&t, p, <);
@@ -45,15 +97,15 @@ void nullPointer_timercmp(struct timeval t)
 // size_t strlcat(char *dst, const char *src, size_t size);
 void uninitvar_strlcat(char *Ct, const char *S, size_t N)
 {
-    char *ct;
-    char *s;
+    char *ct1, *ct2;
+    char *s1, *s2;
     size_t n1, n2;
     // cppcheck-suppress uninitvar
-    (void)strlcat(ct,s,n1);
+    (void)strlcat(ct1,s1,n1);
     // cppcheck-suppress uninitvar
-    (void)strlcat(ct,S,N);
+    (void)strlcat(ct2,S,N);
     // cppcheck-suppress uninitvar
-    (void)strlcat(Ct,s,N);
+    (void)strlcat(Ct,s2,N);
     // cppcheck-suppress uninitvar
     (void)strlcat(Ct,S,n2);
 
@@ -99,3 +151,32 @@ void uninitvar(void)
     // cppcheck-suppress uninitvar
     (void) arc4random_uniform(uint32Uninit);
 }
+
+void arrayIndexOutOfBounds(void)
+{
+    char * pAlloc = calloc(2, 3);
+    // cppcheck-suppress nullPointerOutOfMemory
+    pAlloc[5] = 'a';
+    // cppcheck-suppress arrayIndexOutOfBounds
+    // cppcheck-suppress nullPointerOutOfMemory
+    pAlloc[6] = 1;
+    // cppcheck-suppress memleakOnRealloc
+    pAlloc = reallocarray(pAlloc, 3, 3);
+    pAlloc[8] = 'a';
+    // cppcheck-suppress arrayIndexOutOfBounds
+    pAlloc[9] = 1;
+    free(pAlloc);
+}
+
+void reallocarray_memleak(void) {
+    char *a = (char *)malloc(10);
+    // cppcheck-suppress [memleakOnRealloc, unreadVariable]
+    a = reallocarray(a, 100, 2);
+    // cppcheck-suppress memleak
+}
+
+void reallocarray_notused(void)
+{
+    // cppcheck-suppress [leakReturnValNotUsed, ignoredReturnValue]
+    reallocarray(NULL, 10, 10);
+}
diff --git a/test/cfg/cairo.c b/test/cfg/cairo.c
index 27702c0dc7f..b8c518225a0 100644
--- a/test/cfg/cairo.c
+++ b/test/cfg/cairo.c
@@ -2,13 +2,16 @@
 // Test library configuration for cairo.cfg
 //
 // Usage:
-// $ cppcheck --check-library --library=cairo --enable=information --error-exitcode=1 --inline-suppr --suppress=missingIncludeSystem test/cfg/cairo.c
+// $ cppcheck --check-library --library=cairo --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/cairo.c
 // =>
 // No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
 //
 
 #include <cairo.h>
 
+#if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 2, 3)
+#endif
+
 void validCode(cairo_surface_t *target)
 {
     cairo_t * cairo1 = cairo_create(target);
diff --git a/test/cfg/cppunit.cpp b/test/cfg/cppunit.cpp
new file mode 100644
index 00000000000..b5e9826a25d
--- /dev/null
+++ b/test/cfg/cppunit.cpp
@@ -0,0 +1,59 @@
+// Test library configuration for cppunit.cfg
+//
+// Usage:
+// $ cppcheck --check-library --library=cppunit --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/cppunit.cpp
+// =>
+// No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
+//
+
+// cppcheck-suppress-file valueFlowBailout
+
+#include <string>
+
+#include <cppunit/Exception.h>
+#include <cppunit/Portability.h>
+#include <cppunit/TestAssert.h>
+
+void cppunit_assert_equal(int x, double y)
+{
+    CPPUNIT_ASSERT(true);
+    CPPUNIT_ASSERT(false);
+    CPPUNIT_ASSERT(1 < 2);
+
+    CPPUNIT_ASSERT_MESSAGE("Test failed", true);
+    CPPUNIT_ASSERT_MESSAGE("Test failed", false);
+    CPPUNIT_ASSERT_MESSAGE("Test failed", 1 < 2);
+
+    CPPUNIT_ASSERT_EQUAL(1, 2);
+    CPPUNIT_ASSERT_EQUAL(true, 3 == x);
+
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test failed", 1, 4);
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test failed", true, 4 == x);
+
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(1.0, 2.0, 1e-7);
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(1.0, y, 1e-7);
+
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Test failed", 1.0, 2.0, 1e-7);
+    CPPUNIT_ASSERT_DOUBLES_EQUAL_MESSAGE("Test failed", 1.0, y, 1e-7);
+}
+
+void cppunit_throw()
+{
+    CPPUNIT_ASSERT_NO_THROW(1 + 1);
+    CPPUNIT_ASSERT_NO_THROW_MESSAGE("Unexpected throw", 1 + 1);
+    CPPUNIT_ASSERT_THROW(1 + 1, CPPUNIT_NS::Exception);
+    CPPUNIT_ASSERT_THROW_MESSAGE("Did not throw", 1 + 1, CPPUNIT_NS::Exception);
+}
+
+void cppunit_assertion_assert()
+{
+    CPPUNIT_ASSERT_ASSERTION_FAIL(true);
+    CPPUNIT_ASSERT_ASSERTION_FAIL_MESSAGE("hello", false);
+    CPPUNIT_ASSERT_ASSERTION_PASS(false);
+    CPPUNIT_ASSERT_ASSERTION_PASS_MESSAGE("goodbye", true);
+}
+
+void cppunit_assert_fail()
+{
+    CPPUNIT_FAIL("This fails");
+}
diff --git a/test/cfg/emscripten.cpp b/test/cfg/emscripten.cpp
new file mode 100644
index 00000000000..7b19c01c79b
--- /dev/null
+++ b/test/cfg/emscripten.cpp
@@ -0,0 +1,92 @@
+
+// Test library configuration for emscripten.cfg
+//
+// Usage:
+// $ cppcheck --check-library --library=emscripten --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/emscripten.cpp
+// =>
+// No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
+//
+
+#include <stdio.h>
+#include <emscripten.h>
+
+void em_asm_test()
+{
+    // inline some JavaScript
+    EM_ASM(alert('hello'); );
+    MAIN_THREAD_EM_ASM(alert('hello main thread'); );
+
+    // pass parameters to JavaScript
+    EM_ASM(
+    {
+        console.log('I received: ' + [$0, $1]);
+    },
+        100, 35.5);
+
+    // pass a string to JavaScript
+    EM_ASM({console.log('hello ' + UTF8ToString($0))}, "world!");
+}
+
+void em_asm_int_test()
+{
+    // cppcheck-suppress unreadVariable
+    const int x = EM_ASM_INT({
+        return $0 + 42;
+    }, 100);
+
+    // cppcheck-suppress unreadVariable
+    const int y = MAIN_THREAD_EM_ASM_INT({return 2;});
+}
+
+void em_asm_double_test()
+{
+    // cppcheck-suppress unreadVariable
+    const double x = EM_ASM_DOUBLE({
+        return $0 + 1.0;
+    }, 2.0);
+
+    // cppcheck-suppress unreadVariable
+    const double y = MAIN_THREAD_EM_ASM_DOUBLE({return 1.0;});
+}
+
+void em_asm_ptr_test()
+{
+    void* ptr = EM_ASM_PTR({
+        return stringToNewUTF8("Hello");
+    });
+    printf("%s", static_cast<const char*>(ptr));
+    free(ptr);
+}
+
+void em_asm_ptr_memleak_test()
+{
+    const char *str = static_cast<char*>(EM_ASM_PTR({
+        return stringToNewUTF8("Hello");
+    }));
+    // cppcheck-suppress nullPointerOutOfMemory
+    printf("%s", str);
+
+    // cppcheck-suppress memleak
+}
+
+void main_thread_em_asm_ptr_test()
+{
+    // cppcheck-suppress leakReturnValNotUsed
+    MAIN_THREAD_EM_ASM_PTR(
+        return stringToNewUTF8("Hello");
+        );
+}
+
+EM_JS(void, two_alerts, (), {
+    alert('hai');
+    alert('bai');
+});
+EM_JS(void, take_args, (int x, float y), {
+    console.log('I received: ' + [x, y]);
+});
+
+void em_js_test()
+{
+    two_alerts();
+    take_args(100, 35.5);
+}
diff --git a/test/cfg/generate-cfg-tests.sh b/test/cfg/generate-cfg-tests.sh
deleted file mode 100755
index 3162f1c5b30..00000000000
--- a/test/cfg/generate-cfg-tests.sh
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/bash
-cd ~/cppcheck
-make generate_cfg_tests
-./generate_cfg_tests cfg/avr.cfg > test/cfg/generated-cfg-tests-avr.cpp
-./generate_cfg_tests cfg/bsd.cfg > test/cfg/generated-cfg-tests-bsd.cpp
-./generate_cfg_tests cfg/gnu.cfg > test/cfg/generated-cfg-tests-gnu.cpp
-./generate_cfg_tests cfg/motif.cfg > test/cfg/generated-cfg-tests-motif.cpp
-./generate_cfg_tests cfg/posix.cfg > test/cfg/generated-cfg-tests-posix.cpp
-./generate_cfg_tests cfg/qt.cfg > test/cfg/generated-cfg-tests-qt.cpp
-./generate_cfg_tests cfg/sdl.cfg > test/cfg/generated-cfg-tests-sdl.cpp
-./generate_cfg_tests cfg/sfml.cfg > test/cfg/generated-cfg-tests-sfml.cpp
-./generate_cfg_tests cfg/std.cfg > test/cfg/generated-cfg-tests-std.cpp
-./generate_cfg_tests cfg/windows.cfg > test/cfg/generated-cfg-tests-windows.cpp
-./generate_cfg_tests cfg/wxwidgets.cfg > test/cfg/generated-cfg-tests-wxwidgets.cpp
diff --git a/test/cfg/gnu.c b/test/cfg/gnu.c
index f4895e16e67..14dfcc7700f 100644
--- a/test/cfg/gnu.c
+++ b/test/cfg/gnu.c
@@ -2,53 +2,241 @@
 // Test library configuration for gnu.cfg
 //
 // Usage:
-// $ cppcheck --check-library --library=gnu --enable=information --enable=style --error-exitcode=1 --suppress=missingIncludeSystem --inline-suppr test/cfg/gnu.c
+// $ cppcheck --check-library --library=gnu --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/gnu.c
 // =>
 // No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
 //
 
+// cppcheck-suppress-file [valueFlowBailout,purgedConfiguration]
+
+#define _GNU_SOURCE
+
 #include <string.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdarg.h>
-#include <sys/time.h>
-#ifndef __CYGWIN__
+#include <sys/types.h>
+#include <pwd.h>
+#include <sys/mman.h>
+#include <sys/sem.h>
+#include <wchar.h>
+#include <execinfo.h>
+#if !defined(__CYGWIN__) && !defined(__APPLE__)
 #include <sys/epoll.h>
 #endif
+#include <strings.h>
+#ifdef __gnu_linux__
+#include <error.h>
+#endif
+#include <unistd.h>
+#include <getopt.h>
+#include <netdb.h>
+#if !defined(__APPLE__)
+#include <byteswap.h>
+#include <features.h>
+#endif
+#include <sys/socket.h>
+#include <time.h>
+#include <stddef.h>
+
+#ifdef __gnu_linux__
+void unreachableCode_error(void) // #11197
+{
+    error(1, 0, ""); // will call exit() if the first parameter is non-zero
+    // cppcheck-suppress unusedVariable
+    // TODO cppcheck-suppress unreachableCode
+    int i;
+}
+#endif
+
+
+int deallocuse_backtrace(int size) {
+    void **buffer = (void **)malloc(sizeof(void *) * size);
+    free(buffer);
+    // cppcheck-suppress deallocuse
+    // cppcheck-suppress nullPointerOutOfMemory
+    int numEntries = backtrace(buffer, size);
+    return numEntries;
+}
+
+#if !defined(__APPLE__)
+void leakReturnValNotUsed_get_current_dir_name(void)
+{
+    // cppcheck-suppress leakReturnValNotUsed
+    get_current_dir_name();
+}
+
+void memleak_get_current_dir_name0(void)
+{
+    const char *const name = get_current_dir_name();
+    if (name)
+    {
+        // cppcheck-suppress memleak
+        return;
+    }
+}
+
+void memleak_get_current_dir_name1(void)
+{
+    const char *const name = get_current_dir_name();
+    if (name)
+    {
+        free(name);
+        return;
+    }
+}
+
+int nullPointer_gethostbyname2_r(const char* name, int af, struct hostent* ret, const char* buf, size_t buflen, struct hostent** result, const int* h_errnop)
+{
+    // cppcheck-suppress nullPointer
+    (void) gethostbyname2_r(NULL, af, ret, buf, buflen, result, h_errnop);
+    // cppcheck-suppress nullPointer
+    (void) gethostbyname2_r(name, af, NULL, buf, buflen, result, h_errnop);
+    // cppcheck-suppress nullPointer
+    (void) gethostbyname2_r(name, af, ret, NULL, buflen, result, h_errnop);
+    // cppcheck-suppress nullPointer
+    (void) gethostbyname2_r(name, af, ret, buf, buflen, NULL, h_errnop);
+    // cppcheck-suppress nullPointer
+    (void) gethostbyname2_r(name, af, ret, buf, buflen, result, NULL);
+    return gethostbyname2_r(name, af, ret, buf, buflen, result, h_errnop);
+}
+
+int nullPointer_gethostbyname_r(const char* name, struct hostent* ret, const char* buf, size_t buflen, struct hostent** result, const int* h_errnop)
+{
+    // cppcheck-suppress nullPointer
+    (void) gethostbyname_r(NULL, ret, buf, buflen, result, h_errnop);
+    // cppcheck-suppress nullPointer
+    (void) gethostbyname_r(name, NULL, buf, buflen, result, h_errnop);
+    // cppcheck-suppress nullPointer
+    (void) gethostbyname_r(name, ret, NULL, buflen, result, h_errnop);
+    // cppcheck-suppress nullPointer
+    (void) gethostbyname_r(name, ret, buf, buflen, NULL, h_errnop);
+    // cppcheck-suppress nullPointer
+    (void) gethostbyname_r(name, ret, buf, buflen, result, NULL);
+    return gethostbyname_r(name, ret, buf, buflen, result, h_errnop);
+}
+
+int nullPointer_gethostbyaddr_r(const void* addr, socklen_t len, int type, struct hostent* ret, const char* buf, size_t buflen, struct hostent** result, const int* h_errnop)
+{
+    // cppcheck-suppress nullPointer
+    (void) gethostbyaddr_r(NULL, len, type, ret, buf, buflen, result, h_errnop);
+    // cppcheck-suppress nullPointer
+    (void) gethostbyaddr_r(addr, len, type, NULL, buf, buflen, result, h_errnop);
+    // cppcheck-suppress nullPointer
+    (void) gethostbyaddr_r(addr, len, type, ret, NULL, buflen, result, h_errnop);
+    // cppcheck-suppress nullPointer
+    (void) gethostbyaddr_r(addr, len, type, ret, buf, buflen, NULL, h_errnop);
+    // cppcheck-suppress nullPointer
+    (void) gethostbyaddr_r(addr, len, type, ret, buf, buflen, result, NULL);
+    return gethostbyaddr_r(addr, len, type, ret, buf, buflen, result, h_errnop);
+}
+#endif
+
+int nullPointer_getopt_long(int argc, char **argv, const char *optstring,
+                            const struct option *longopts, int *longindex)
+{
+    // cppcheck-suppress nullPointer
+    (void) getopt_long(argc, argv, NULL, longopts, longindex);
+    // cppcheck-suppress nullPointer
+    (void) getopt_long(argc, argv, optstring, NULL, longindex);
+    // cppcheck-suppress nullPointer
+    (void) getopt_long(argc, NULL, optstring, longopts, longindex);
+    return getopt_long(argc, argv, optstring, longopts, longindex);
+}
+
+int nullPointer_getopt_long_only(int argc, char* const* argv, const char* optstring,
+                                 const struct option* longopts, int* longindex)
+{
+    // cppcheck-suppress nullPointer
+    (void) getopt_long_only(argc, NULL, optstring, longopts, longindex);
+    // cppcheck-suppress nullPointer
+    (void) getopt_long_only(argc, argv, NULL, longopts, longindex);
+    // cppcheck-suppress nullPointer
+    (void) getopt_long_only(argc, argv, optstring, NULL, longindex);
+    return getopt_long_only(argc, argv, optstring, longopts, longindex);
+}
+
+#if !defined(__APPLE__)
+int nullPointer_getservent_r(struct servent *restrict result_buf, const char *restrict buf, size_t buflen, struct servent **restrict result)
+{
+    // cppcheck-suppress nullPointer
+    (void) getservent_r(NULL, buf, buflen, result);
+    // cppcheck-suppress nullPointer
+    (void) getservent_r(result_buf, NULL, buflen, result);
+    // cppcheck-suppress nullPointer
+    (void) getservent_r(result_buf, buf, buflen, NULL);
+    return getservent_r(result_buf, buf, buflen, result);
+}
+
+void *bufferAccessOutOfBounds_memrchr(const void *s, int c, size_t n)
+{
+    const char buf[42]={0};
+    (void)memrchr(buf,c,42);
+    // cppcheck-suppress bufferAccessOutOfBounds
+    (void)memrchr(buf,c,43);
+    return memrchr(s,c,n);
+}
+#endif
 
-// #9323, #9331
-void syntaxError_timercmp(struct timeval t)
+void knownConditionTrueFalse_ffsl(long i)
 {
-    (void)timercmp(&t, &t, <);
-    (void)timercmp(&t, &t, <=);
-    (void)timercmp(&t, &t, ==);
-    (void)timercmp(&t, &t, !=);
-    (void)timercmp(&t, &t, >=);
-    (void)timercmp(&t, &t, >);
+    // ffs() returns the position of the first bit set, or 0 if no bits are set in i.
+    const int x = ffsl(0);
+    // cppcheck-suppress knownConditionTrueFalse
+    if (x == 0) {}
+    if (ffsl(i) == 0) {}
 }
 
-// False negative: #9346
-void uninitvar_timercmp(struct timeval t)
+void knownConditionTrueFalse_ffsll(long long i)
 {
-    struct timeval uninit;
-    (void)timercmp(&t, &uninit, <);
-    (void)timercmp(&uninit, &t, <=);
-    (void)timercmp(&uninit, &uninit, ==);
+    // ffs() returns the position of the first bit set, or 0 if no bits are set in i.
+    const int x = ffsll(0);
+    // cppcheck-suppress knownConditionTrueFalse
+    if (x == 0) {}
+    if (ffsll(i) == 0) {}
 }
 
-void nullPointer_timercmp(struct timeval t)
+#if !defined(__APPLE__)
+int nullPointer_semtimedop(int semid, struct sembuf *sops, size_t nsops, const struct timespec *timeout)
 {
-    struct timeval *p=0;
+    (void) semtimedop(semid, sops, nsops, NULL); // If the timeout argument is NULL, then semtimedop() behaves exactly like semop().
+    (void) semtimedop(semid, sops, nsops, timeout);
     // cppcheck-suppress nullPointer
-    (void)timercmp(&t, p, <);
+    return semtimedop(semid, NULL, nsops, timeout);
+}
+
+void *nullPointer_mempcpy(void *dest, const void *src, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void) mempcpy(NULL,src,n);
+    // cppcheck-suppress nullPointer
+    (void) mempcpy(dest,NULL,n);
+    return mempcpy(dest,src,n);
+}
+
+wchar_t *nullPointer_wmempcpy(wchar_t *dest, const wchar_t *src, size_t n)
+{
     // cppcheck-suppress nullPointer
-    (void)timercmp(p, &t, <=);
+    (void) wmempcpy(NULL,src,n);
     // cppcheck-suppress nullPointer
-    (void)timercmp(p, p, ==);
+    (void) wmempcpy(dest,NULL,n);
+    return wmempcpy(dest,src,n);
 }
 
+int uninitvar_getpw(uid_t uid, char *buf)
+{
+    uid_t someUid;
+    // cppcheck-suppress getpwCalled
+    (void)getpw(uid, buf);
+    // cppcheck-suppress getpwCalled
+    // cppcheck-suppress uninitvar
+    return getpw(someUid, buf);
+}
+#endif
+
 // Declaration necessary because there is no specific / portable header.
+// https://www.eyrie.org/~eagle/software/rra-c-util/xmalloc.html
 extern void *xcalloc(size_t nmemb, size_t size);
 extern void *xmalloc(size_t size);
 extern void *xrealloc(void *block, size_t newsize);
@@ -108,12 +296,20 @@ int no_resourceLeak_mkostemp_02(char *template, int flags)
     return mkostemp(template, flags);
 }
 
-void valid_code(int argInt1, va_list valist_arg)
+void valid_code(int argInt1, va_list valist_arg, const int * parg)
 {
     char *p;
 
     if (__builtin_expect(argInt1, 0)) {}
     if (__builtin_expect_with_probability(argInt1 + 1, 2, 0.5)) {}
+#ifdef __GLIBC__
+    if (__glibc_unlikely(argInt1 != 0)) {}
+    if (__glibc_likely(parg != NULL)) {}
+#endif
+    const void *ax1 = __builtin_assume_aligned(parg, 16);
+    printf("%p", ax1);
+    const void *ax2 = __builtin_assume_aligned(parg, 32, 8);
+    printf("%p", ax2);
 
     p = (char *)malloc(10);
     free(p);
@@ -140,6 +336,36 @@ void valid_code(int argInt1, va_list valist_arg)
 
     printf("%d", 0b010);
     printf("%d", __extension__ 0b10001000);
+
+    if (__alignof__(int) == 4) {}
+
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
+    const void * p_mmap = mmap(NULL, 1, PROT_NONE, MAP_ANONYMOUS | MAP_SHARED, -1, 0);
+    printf("%p", p_mmap);
+    // cppcheck-suppress nullPointerOutOfMemory
+    munmap(p_mmap, 1);
+
+    uint16_t i16_1 = 0, i16_2;
+    // cppcheck-suppress unreadVariable
+    i16_2 = __builtin_bswap16(i16_1++);
+    uint32_t i32_1 = 0, i32_2;
+    // cppcheck-suppress unreadVariable
+    i32_2 = __builtin_bswap32(i32_1++);
+    uint64_t i64_1 = 0, i64_2;
+    // cppcheck-suppress unreadVariable
+    i64_2 = __builtin_bswap64(i64_1++);
+
+#if !defined(__APPLE__)
+    // cppcheck-suppress zerodiv
+    // cppcheck-suppress unreadVariable
+    i16_1 /= bswap_16(0x1234) - 0x3412;
+    // cppcheck-suppress zerodiv
+    // cppcheck-suppress unreadVariable
+    i32_1 /= bswap_32(0x12345678) - 0x78563412;
+    // cppcheck-suppress zerodiv
+    // cppcheck-suppress unreadVariable
+    i64_1 /= bswap_64(0x023456789abcde0f) - 0x0fdebc9a78563402;
+#endif
 }
 
 void ignoreleak(void)
@@ -155,18 +381,77 @@ void memleak_asprintf(char **ptr, const char *fmt, const int arg)
     if (-1 != asprintf(ptr,fmt,arg)) {
         free(ptr);
     }
-    if (-1 != asprintf(ptr,fmt,arg)) {
-        // TODO: Related to #8980 cppcheck-suppress memleak
+    if (-1 != asprintf(ptr,fmt,arg)) {}
+}
+
+void memleak_asprintf2() { // #12186
+    char* p = malloc(5);
+    // cppcheck-suppress memleak
+    (void)asprintf(&p, "%s", "test");
+    // cppcheck-suppress memleak
+}
+
+void memleak_asprintf3() {
+    char* p = malloc(5);
+    // cppcheck-suppress memleak
+    asprintf(&p, "%s", "test");
+    free(p);
+}
+
+void memleak_asprintf4(char** p) {
+    asprintf(p, "%s", "test");
+}
+
+void memleak_asprintf5(char* p) {
+    asprintf(&p, "%s", "test");
+    // cppcheck-suppress memleak
+}
+
+void memleak_asprintf6(const char* fmt, const int arg) {
+    char* ptr;
+    if (-1 == asprintf(&ptr, fmt, arg))
+        return;
+    printf("%s", ptr);
+    free(ptr);
+}
+
+void memleak_asprintf7(const char* fmt, const int arg) {
+    char* ptr;
+    if (asprintf(&ptr, fmt, arg) != -1) {
+        printf("%s", ptr);
+        free(ptr);
+    }
+    else
+        return;
+}
+
+void memleak_asprintf8(const char *fmt, const int arg) // #12204
+{
+    char* ptr;
+    int ret = asprintf(&ptr, fmt, arg);
+    if (-1 == ret) {
+        return;
     }
+    printf("%s", ptr);
+    free(ptr);
 }
 
 void memleak_xmalloc()
 {
     char *p = (char*)xmalloc(10);
+    // cppcheck-suppress nullPointerOutOfMemory
     p[9] = 0;
     // cppcheck-suppress memleak
 }
 
+void memleak_mmap()
+{
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
+    const void * p_mmap = mmap(NULL, 1, PROT_NONE, MAP_ANONYMOUS | MAP_SHARED, -1, 0);
+    printf("%p", p_mmap);
+    // cppcheck-suppress memleak
+}
+
 void uninitvar__builtin_memset(void)
 {
     void *s;
@@ -185,21 +470,25 @@ void bufferAccessOutOfBounds__builtin_memset(void)
 
 void bufferAccessOutOfBounds()
 {
-    char buf[2] = "a";
+    const char buf[2] = "a";
     // This is valid
     sethostname(buf, 2);
     // cppcheck-suppress bufferAccessOutOfBounds
     sethostname(buf, 4);
 
     char * pAlloc1 = xcalloc(2, 4);
+    // cppcheck-suppress nullPointerOutOfMemory
     memset(pAlloc1, 0, 8);
     // cppcheck-suppress bufferAccessOutOfBounds
+    // cppcheck-suppress nullPointerOutOfMemory
     memset(pAlloc1, 0, 9);
     free(pAlloc1);
 
     char * pAlloc2 = xmalloc(4);
+    // cppcheck-suppress nullPointerOutOfMemory
     memset(pAlloc2, 0, 4);
     // cppcheck-suppress bufferAccessOutOfBounds
+    // cppcheck-suppress nullPointerOutOfMemory
     memset(pAlloc2, 0, 5);
 
     pAlloc2 = xrealloc(pAlloc2, 10);
@@ -210,13 +499,14 @@ void bufferAccessOutOfBounds()
     free(pAlloc2);
 }
 
+#if !defined(__APPLE__)
 void leakReturnValNotUsed()
 {
-    // cppcheck-suppress unreadVariable
+    // cppcheck-suppress [unreadVariable, constVariablePointer]
     char* ptr = (char*)strdupa("test");
     // cppcheck-suppress ignoredReturnValue
     strdupa("test");
-    // cppcheck-suppress unreadVariable
+    // cppcheck-suppress [unreadVariable, constVariablePointer]
     char* ptr2 = (char*)strndupa("test", 1);
     // cppcheck-suppress ignoredReturnValue
     strndupa("test", 1);
@@ -229,8 +519,9 @@ void leakReturnValNotUsed()
     if (42 == __builtin_expect(42, 0))
         return;
 }
+#endif
 
-#ifndef __CYGWIN__
+#if !defined(__CYGWIN__) && !defined(__APPLE__)
 int nullPointer_epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
 {
     // no warning is expected
@@ -241,6 +532,7 @@ int nullPointer_epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
     //          Remove (deregister) the target file descriptor fd from the
     //          epoll instance referred to by epfd.  The event is ignored and
     //          can be NULL.
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
     return epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
 }
 #endif
diff --git a/test/cfg/googletest.cpp b/test/cfg/googletest.cpp
new file mode 100644
index 00000000000..eaec730136d
--- /dev/null
+++ b/test/cfg/googletest.cpp
@@ -0,0 +1,95 @@
+
+// Test library configuration for googletest.cfg
+//
+// Usage:
+// $ cppcheck --check-library --library=googletest --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/googletest.cpp
+// =>
+// No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
+//
+
+// cppcheck-suppress-file valueFlowBailout
+
+#include <gmock/gmock-generated-matchers.h>
+#include <gtest/gtest.h>
+
+
+namespace ExampleNamespace {
+    constexpr long long TOLERANCE = 10;
+
+    // #9397 syntaxError when MATCHER_P is not known
+    // cppcheck-suppress symbolDatabaseWarning
+    MATCHER_P(ExampleMatcherPTest, expected, "")
+    {
+        // cppcheck-suppress valueFlowBailoutIncompleteVar
+        return ((arg <= (expected + TOLERANCE)) && (arg >= (expected - TOLERANCE)));
+    }
+
+    // syntaxError when MATCHER is not known
+    // cppcheck-suppress symbolDatabaseWarning
+    MATCHER(ExampleMatcherTest, "")
+    {
+        return (arg == TOLERANCE);
+    }
+
+    // syntaxError when TYPED_TEST is not known
+    TYPED_TEST (ExampleTypedTest, cppcheck_test)
+    {
+    }
+
+    // syntaxError when TYPED_TEST_P is not known
+    TYPED_TEST_P (ExampleTypedTestP, cppcheck)
+    {
+    }
+}
+
+TEST(ASSERT, ASSERT)
+{
+    int *a = (int*)calloc(10,sizeof(int)); // cppcheck-suppress cstyleCast
+    ASSERT_TRUE(a != nullptr);
+
+    a[0] = 10;
+
+    free(a);
+}
+
+// Avoid syntax error: https://sourceforge.net/p/cppcheck/discussion/general/thread/6ccc7283e2/
+TEST(test_cppcheck, cppcheck)
+{
+    TestStruct<int> it;
+    ASSERT_THROW(it.operator->(), std::out_of_range);
+}
+
+// #9964 - avoid compareBoolExpressionWithInt false positive
+TEST(Test, assert_false_fp)
+{
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
+    ASSERT_FALSE(errno < 0);
+}
+
+// Check that conditions in the ASSERT_* macros are processed correctly.
+TEST(Test, warning_in_assert_macros)
+{
+    int i = 5;
+    int j = 6;
+
+    // cppcheck-suppress knownConditionTrueFalse
+    ASSERT_TRUE(i == 5);
+    // cppcheck-suppress knownConditionTrueFalse
+    ASSERT_FALSE(i != 5);
+    // cppcheck-suppress duplicateExpression
+    ASSERT_EQ(i, i);
+    ASSERT_NE(i, j); // expected knownConditionTrueFalse...
+    ASSERT_LT(i, j); // expected knownConditionTrueFalse...
+    // cppcheck-suppress duplicateExpression
+    ASSERT_LE(i, i);
+    ASSERT_GT(j, i); // expected knownConditionTrueFalse
+    // cppcheck-suppress duplicateExpression
+    ASSERT_GE(i, i);
+
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
+    unsigned int u = errno;
+    // cppcheck-suppress [unsignedPositive]
+    ASSERT_GE(u, 0);
+    // cppcheck-suppress [unsignedLessThanZero]
+    ASSERT_LT(u, 0);
+}
diff --git a/test/cfg/gtk.c b/test/cfg/gtk.c
index e89d9085452..3e4e5b1cb06 100644
--- a/test/cfg/gtk.c
+++ b/test/cfg/gtk.c
@@ -2,25 +2,34 @@
 // Test library configuration for gtk.cfg
 //
 // Usage:
-// $ cppcheck --check-library --enable=information --inconclusive --error-exitcode=1 --suppress=missingIncludeSystem --inline-suppr --library=gtk test/cfg/gtk.cpp
+// $ cppcheck --check-library --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr --library=gtk test/cfg/gtk.c
 // =>
 // No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
 //
 
-#include <gtk/gtk.h>
+#include <stdio.h>
 #include <glib.h>
+#include <glib/gtypes.h>
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
 
+#if GLIB_CHECK_VERSION(2, 3, 4)
+#endif
+#if GTK_CHECK_VERSION(4, 5, 6)
+#endif
+#if ATK_CHECK_VERSION(2, 3, 6)
+#endif
 
-void validCode(int argInt)
+void validCode(int argInt, GHashTableIter * hash_table_iter, GHashTable * hash_table)
 {
+    g_assert_cmpint(4 + 1, >=, 5);
+    g_assert_cmpstr("test", ==, "test");
+
     // if G_UNLIKELY is not defined this results in a syntax error
-    if G_UNLIKELY(argInt == 1) {
-    } else if (G_UNLIKELY(argInt == 2)) {
-    }
+    if G_UNLIKELY(argInt == 1) {} else if (G_UNLIKELY(argInt == 2)) {}
 
-    if G_LIKELY(argInt == 0) {
-    } else if (G_LIKELY(argInt == -1)) {
-    }
+    if G_LIKELY(argInt == 0) {} else if (G_LIKELY(argInt == -1)) {}
 
     printf("%s", _("test"));
     printf("%s", Q_("a|test"));
@@ -29,11 +38,13 @@ void validCode(int argInt)
     gpointer gpt = g_malloc(4);
     printf("%p", gpt);
     g_free(gpt);
+    // cppcheck-suppress deallocuse
     g_assert(gpt);
     if (!gpt) {
         // cppcheck-suppress checkLibraryNoReturn
         g_assert_not_reached();
     }
+    // cppcheck-suppress constVariablePointer
     gpointer p = GINT_TO_POINTER(1);
     int i = GPOINTER_TO_INT(p);
     // cppcheck-suppress knownConditionTrueFalse
@@ -51,6 +62,7 @@ void validCode(int argInt)
     printf("%s", pGchar1);
     g_free(pGchar1);
 
+    // cppcheck-suppress unusedAllocatedMemory
     GError * pGerror = g_error_new(1, -2, "a %d", 1);
     g_error_free(pGerror);
 
@@ -59,15 +71,25 @@ void validCode(int argInt)
         gsize result_val = 1;
         g_once_init_leave(&init_val, result_val);
     }
+
+    g_hash_table_iter_replace(hash_table_iter, g_strdup("test"));
+    g_hash_table_insert(hash_table, g_strdup("key"), g_strdup("value"));
+    g_hash_table_replace(hash_table, g_strdup("key"), g_strdup("value"));
+
+    // NULL is handled graciously
+    char* str = g_strdup(NULL);
+    if (g_strcmp0(str, NULL) || g_strcmp0(NULL, str))
+        // cppcheck-suppress valueFlowBailout // TODO: caused by <pure/>?
+        printf("%s", str);
+    g_free(str);
 }
 
 void g_malloc_test()
 {
-    // cppcheck-suppress ignoredReturnValue
     // cppcheck-suppress leakReturnValNotUsed
     g_malloc(8);
 
-    gpointer gpt = g_malloc(1);
+    gconstpointer gpt = g_malloc(1);
 
     printf("%p", gpt);
 
@@ -76,11 +98,10 @@ void g_malloc_test()
 
 void g_malloc0_test()
 {
-    // cppcheck-suppress ignoredReturnValue
     // cppcheck-suppress leakReturnValNotUsed
     g_malloc0(8);
 
-    gpointer gpt = g_malloc0(1);
+    gconstpointer gpt = g_malloc0(1);
 
     printf("%p", gpt);
 
@@ -89,11 +110,10 @@ void g_malloc0_test()
 
 void g_malloc_n_test()
 {
-    // cppcheck-suppress ignoredReturnValue
     // cppcheck-suppress leakReturnValNotUsed
     g_malloc_n(8, 1);
 
-    gpointer gpt = g_malloc_n(1, 2);
+    gconstpointer gpt = g_malloc_n(1, 2);
 
     printf("%p", gpt);
 
@@ -102,11 +122,10 @@ void g_malloc_n_test()
 
 void g_malloc0_n_test()
 {
-    // cppcheck-suppress ignoredReturnValue
     // cppcheck-suppress leakReturnValNotUsed
     g_malloc0_n(8, 1);
 
-    gpointer gpt = g_malloc0_n(1, 2);
+    gconstpointer gpt = g_malloc0_n(1, 2);
 
     printf("%p", gpt);
 
@@ -115,11 +134,10 @@ void g_malloc0_n_test()
 
 void g_try_malloc_test()
 {
-    // cppcheck-suppress ignoredReturnValue
     // cppcheck-suppress leakReturnValNotUsed
     g_try_malloc(8);
 
-    gpointer gpt = g_try_malloc(1);
+    gconstpointer gpt = g_try_malloc(1);
 
     printf("%p", gpt);
 
@@ -128,11 +146,10 @@ void g_try_malloc_test()
 
 void g_try_malloc0_test()
 {
-    // cppcheck-suppress ignoredReturnValue
     // cppcheck-suppress leakReturnValNotUsed
     g_try_malloc0(8);
 
-    gpointer gpt = g_try_malloc0(1);
+    gconstpointer gpt = g_try_malloc0(1);
 
     printf("%p", gpt);
 
@@ -141,11 +158,10 @@ void g_try_malloc0_test()
 
 void g_try_malloc_n_test()
 {
-    // cppcheck-suppress ignoredReturnValue
     // cppcheck-suppress leakReturnValNotUsed
     g_try_malloc_n(8, 1);
 
-    gpointer gpt = g_try_malloc_n(1, 2);
+    gconstpointer gpt = g_try_malloc_n(1, 2);
 
     printf("%p", gpt);
 
@@ -154,11 +170,10 @@ void g_try_malloc_n_test()
 
 void g_try_malloc0_n_test()
 {
-    // cppcheck-suppress ignoredReturnValue
     // cppcheck-suppress leakReturnValNotUsed
     g_try_malloc0_n(8, 1);
 
-    gpointer gpt = g_try_malloc0_n(1, 2);
+    gconstpointer gpt = g_try_malloc0_n(1, 2);
 
     printf("%p", gpt);
 
@@ -227,6 +242,25 @@ void g_assert_test()
     g_assert(a = 5);
 }
 
+void g_assert_true_false_test()
+{
+    gboolean t = TRUE;
+    gboolean f = FALSE;
+    g_assert_true(t);
+    // cppcheck-suppress checkLibraryNoReturn
+    g_assert_false(f);
+}
+
+void g_assert_null_nonnull_test()
+{
+    char * gpt = g_malloc(1);
+    g_assert_nonnull(gpt);
+    gpt[0] = 0;
+    g_free(gpt);
+    // cppcheck-suppress checkLibraryNoReturn
+    g_assert_null(NULL);
+}
+
 void g_print_test()
 {
     // cppcheck-suppress invalidPrintfArgType_uint
@@ -255,7 +289,7 @@ void g_new_test()
     // cppcheck-suppress leakReturnValNotUsed
     g_new(struct a, 1);
 
-    struct a * pNew2 = g_new(struct a, 2);
+    const struct a * pNew2 = g_new(struct a, 2);
     printf("%p", pNew2);
     // cppcheck-suppress memleak
 }
@@ -266,7 +300,7 @@ void g_new_if_test()
         int b;
     };
 
-    struct a * pNew3;
+    const struct a * pNew3;
     if (pNew3 = g_new(struct a, 6)) {
         printf("%p", pNew3);
     }
@@ -286,7 +320,7 @@ void g_new0_test()
     // cppcheck-suppress leakReturnValNotUsed
     g_new0(struct a, 1);
 
-    struct a * pNew2 = g_new0(struct a, 2);
+    const struct a * pNew2 = g_new0(struct a, 2);
     printf("%p", pNew2);
     // cppcheck-suppress memleak
 }
@@ -304,7 +338,7 @@ void g_try_new_test()
     // cppcheck-suppress leakReturnValNotUsed
     g_try_new(struct a, 1);
 
-    struct a * pNew2 = g_try_new(struct a, 2);
+    const struct a * pNew2 = g_try_new(struct a, 2);
     printf("%p", pNew2);
     // cppcheck-suppress memleak
 }
@@ -321,7 +355,7 @@ void g_try_new0_test()
     // cppcheck-suppress leakReturnValNotUsed
     g_try_new0(struct a, 1);
 
-    struct a * pNew2 = g_try_new0(struct a, 2);
+    const struct a * pNew2 = g_try_new0(struct a, 2);
     printf("%p", pNew2);
     // cppcheck-suppress memleak
 }
@@ -364,11 +398,10 @@ void g_error_new_test()
     printf("%p", pNew1);
     g_error_free(pNew1);
 
-    // cppcheck-suppress ignoredReturnValue
     // cppcheck-suppress leakReturnValNotUsed
     g_error_new(1, -2, "a %d", 1);
 
-    GError * pNew2 = g_error_new(1, -2, "a %d", 1);
+    const GError * pNew2 = g_error_new(1, -2, "a %d", 1);
     printf("%p", pNew2);
     // cppcheck-suppress memleak
 }
@@ -390,14 +423,161 @@ void g_once_init_enter_leave_test()
     gsize * init_val3 = NULL;
     // cppcheck-suppress nullPointer
     if (g_once_init_enter(init_val3)) {
+        gsize* init_val31 = NULL;
         // cppcheck-suppress nullPointer
-        g_once_init_leave(init_val3, 1);
+        g_once_init_leave(init_val31, 1);
     }
 
     gsize * init_val4;
     // cppcheck-suppress uninitvar
     if (g_once_init_enter(init_val4)) {
+        gsize * init_val5;
         // cppcheck-suppress uninitvar
-        g_once_init_leave(init_val4, 1);
+        g_once_init_leave(init_val5, 1);
     }
 }
+
+void g_strchug_g_strchomp_test(gchar * str1)
+{
+    g_strchug(str1);
+    g_strchomp(str1);
+    g_strchug(g_strchomp(str1));
+    gchar * str2;
+    // cppcheck-suppress uninitvar
+    g_strchug(str2);
+    gchar * str3;
+    // cppcheck-suppress uninitvar
+    g_strchomp(str3);
+}
+
+void g_abort_test()
+{
+    g_abort();
+    //cppcheck-suppress unreachableCode
+    printf("Never reached");
+}
+
+gchar* g_strchug_string_free_test(GString* t) // #12301
+{
+    gchar* p = g_strchug(g_string_free(t, FALSE));
+    return p;
+}
+
+void g_variant_test() {
+    // valid
+    GVariant *pGvariant = g_variant_new("i", 1);
+    printf("%p\n", pGvariant);
+    g_variant_unref(pGvariant);
+
+    // cppcheck-suppress leakReturnValNotUsed
+    g_variant_new("i", 1);
+
+    const GVariant *pGvariant1 = g_variant_new("i", 1);
+    printf("%p\n", pGvariant1);
+
+    GVariant *pGvariant2 = g_variant_parse(
+        NULL, "{'Test': <{'Test1': <uint32 1>}>}", NULL, NULL, NULL);
+    printf("%p\n", pGvariant2);
+    g_variant_unref(pGvariant2);
+
+    GVariantBuilder builder;
+    g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT);
+    g_variant_builder_add(&builder, "{sv}", "String",
+                          g_variant_new_string("String"));
+    g_variant_builder_add(&builder, "{sv}", "Byte", g_variant_new_byte(8));
+    g_variant_builder_add(&builder, "{sv}", "Int16", g_variant_new_int16(-16));
+    g_variant_builder_add(&builder, "{sv}", "Int32", g_variant_new_int32(-32));
+    g_variant_builder_add(&builder, "{sv}", "Int64", g_variant_new_int64(-64));
+    g_variant_builder_add(&builder, "{sv}", "Double", g_variant_new_double(1.0));
+    g_variant_builder_add(&builder, "{sv}", "UInt16", g_variant_new_uint16(16));
+    g_variant_builder_add(&builder, "{sv}", "UInt32", g_variant_new_uint32(32));
+    g_variant_builder_add(&builder, "{sv}", "UInt64", g_variant_new_uint64(64));
+    g_variant_builder_add(&builder, "{sv}", "Boolean",
+                            g_variant_new_boolean(TRUE));
+    g_variant_builder_add(&builder, "{sv}", "TakenString",
+                            g_variant_new_take_string(g_strdup("Owned string")));
+    g_variant_builder_add(&builder, "{sv}", "PrintfString",
+                            g_variant_new_printf("Formatted %d", 1));
+    g_variant_builder_add_value(
+        &builder, g_variant_new("{sv}", "String",
+                                g_variant_new_string("Owned string 2")));
+    g_variant_builder_add_parsed(&builder, "{'String', <'Owned string 3'>}");
+    GVariant *variant_dict = g_variant_builder_end(&builder);
+    printf("%p\n", variant_dict);
+    g_variant_unref(variant_dict);
+
+    GVariantBuilder builder_complex;
+    g_variant_builder_init(&builder_complex, G_VARIANT_TYPE("(sa(sa(sis)))"));
+    g_variant_builder_add(&builder_complex, "s", "OuterTest");
+    g_variant_builder_open(&builder_complex, G_VARIANT_TYPE("a(sa(sis))"));
+    g_variant_builder_open(&builder_complex, G_VARIANT_TYPE("(sa(sis))"));
+    g_variant_builder_add(&builder_complex, "s", "MiddelTest");
+    g_variant_builder_open(&builder_complex, G_VARIANT_TYPE("a(sis)"));
+    g_variant_builder_add(&builder_complex, "(sis)", "InnerTest", 1, "Value");
+    g_variant_builder_close(&builder_complex); // "a(sis)"
+    g_variant_builder_close(&builder_complex); // "(sa(sis))"
+    g_variant_builder_close(&builder_complex); // "a(sa(sis))"
+    GVariant *variant_complex =
+        g_variant_builder_end(&builder_complex); // "(sa(sa(sis)))"
+    printf("%p\n", variant_complex);
+    g_variant_unref(variant_complex);
+
+    // leak from pGvariant1
+    // cppcheck-suppress memleak
+}
+
+void g_queue_test() {
+    // cppcheck-suppress leakReturnValNotUsed
+    g_queue_new();
+
+    GQueue *queue = g_queue_new();
+    g_queue_push_head(queue, "test");
+    g_queue_push_tail(queue, "test");
+    // cppcheck-suppress ignoredReturnValue
+    g_queue_get_length(queue);
+    // cppcheck-suppress ignoredReturnValue
+    g_queue_is_empty(queue);
+    // cppcheck-suppress ignoredReturnValue
+    g_queue_peek_head(queue);
+    // cppcheck-suppress ignoredReturnValue
+    g_queue_peek_tail(queue);
+    // cppcheck-suppress ignoredReturnValue
+    g_queue_pop_head(queue);
+    // cppcheck-suppress ignoredReturnValue
+    g_queue_pop_tail(queue);
+
+    GQueue *copy_queue = g_queue_copy(queue);
+    g_queue_free(queue);
+    printf("%p\n", copy_queue);
+    g_queue_free(copy_queue);
+
+    GQueue *queue2 = g_queue_new();
+    g_queue_push_head(queue2, g_strdup("test"));
+    g_queue_push_tail(queue2, g_strdup("test"));
+    printf("%p\n", queue2);
+    g_queue_free_full(queue2, g_free);
+
+    const GQueue *queue3 = g_queue_new();
+    printf("%p\n", queue3);
+    // cppcheck-suppress memleak
+}
+
+void g_tree_test() {
+    // cppcheck-suppress leakReturnValNotUsed
+    g_tree_new((GCompareFunc)g_strcmp0);
+
+    GTree *tree = g_tree_new((GCompareFunc)g_strcmp0);
+    g_tree_insert(tree, "banana", "yellow");
+    g_tree_insert(tree, "apple", "red");
+    g_tree_insert(tree, "grape", "purple");
+    // cppcheck-suppress ignoredReturnValue
+    g_tree_nnodes(tree);
+    g_tree_remove(tree, "test");
+    // cppcheck-suppress ignoredReturnValue
+    g_tree_lookup(tree, "banana");
+    g_tree_destroy(tree);
+
+    const GTree *tree2 = g_tree_new((GCompareFunc)g_strcmp0);
+    printf("%p\n", tree2);
+    // cppcheck-suppress memleak
+}
diff --git a/test/cfg/kde.cpp b/test/cfg/kde.cpp
new file mode 100644
index 00000000000..71533ca781f
--- /dev/null
+++ b/test/cfg/kde.cpp
@@ -0,0 +1,86 @@
+
+// Test library configuration for kde.cfg
+//
+// Usage:
+// $ cppcheck --check-library --library=kde --library=qt --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/kde.cpp
+// =>
+// No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
+//
+
+#include <cstdio>
+#include <KDE/KGlobal>
+#include <KDE/KConfigGroup>
+#include <klocalizedstring.h>
+#include <kpluginfactory.h>
+
+class k_global_static_testclass1 {};
+K_GLOBAL_STATIC(k_global_static_testclass1, k_global_static_testinstance1);
+
+void valid_code(const KConfigGroup& cfgGroup)
+{
+    const k_global_static_testclass1 * pk_global_static_testclass1 = k_global_static_testinstance1;
+    printf("%p", pk_global_static_testclass1);
+
+    bool entryTest = cfgGroup.readEntry("test", false);
+    if (entryTest) {}
+}
+
+void ignoredReturnValue(const KConfigGroup& cfgGroup)
+{
+    // cppcheck-suppress ignoredReturnValue
+    cfgGroup.readEntry("test", "default");
+    // cppcheck-suppress ignoredReturnValue
+    cfgGroup.readEntry("test");
+}
+
+void i18n_test()
+{
+    (void)i18n("Text");
+    (void)xi18n("Text");
+    (void)ki18n("Text");
+    (void)i18nc("Text", "Context");
+    (void)xi18nc("Text", "Context");
+    (void)ki18nc("Text", "Context");
+}
+
+class PluginWithoutMetaData : public QObject
+{
+    Q_OBJECT
+public:
+    // Add a default arg to make sure we do not get an ambiguity compiler error
+    explicit PluginWithoutMetaData(const QObject *, const QVariantList &args = {})
+    : QObject()
+    {
+        Q_UNUSED(args)
+    };
+};
+
+K_PLUGIN_CLASS(PluginWithoutMetaData)
+
+class StaticSimplePluginClass : public QObject
+{
+    Q_OBJECT
+
+public:
+    // Next to the assertion below, ensure that we have no ambiguity!
+    explicit StaticSimplePluginClass(QObject *parent, const QString &data = {})
+    : QObject(parent)
+    {
+        // We have added a default arg, but KPluginFactory should still provide the valid metadata instead of the default one
+        data = QString("foo");
+    }
+};
+K_PLUGIN_CLASS_WITH_JSON(StaticSimplePluginClass, "data/jsonplugin.json")
+
+class ClipboardPlugin : public Purpose::PluginBase
+{
+    Q_OBJECT
+public:
+    using PluginBase::PluginBase;
+    Purpose::Job *createJob() const override
+    {
+        return new ClipboardJob(nullptr);
+    }
+};
+
+K_PLUGIN_FACTORY_WITH_JSON(Clipboard, "clipboardplugin.json", foo)
diff --git a/test/cfg/libcurl.c b/test/cfg/libcurl.c
index 7205905f8e0..07fd26b031f 100644
--- a/test/cfg/libcurl.c
+++ b/test/cfg/libcurl.c
@@ -2,11 +2,13 @@
 // Test library configuration for libcurl.cfg
 //
 // Usage:
-// $ cppcheck --check-library --library=libcurl --enable=information --error-exitcode=1 --inline-suppr --suppress=missingIncludeSystem test/cfg/libcurl.c
+// $ cppcheck --check-library --library=libcurl --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/libcurl.c
 // =>
 // No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
 //
 
+// cppcheck-suppress-file valueFlowBailout
+
 #include <curl/curl.h>
 #include <stdio.h>
 
@@ -15,6 +17,7 @@ void validCode()
     CURL *curl = curl_easy_init();
     if (curl) {
         CURLcode res;
+        // cppcheck-suppress valueFlowBailoutIncompleteVar
         curl_easy_setopt(curl, CURLOPT_URL, "http://example.com");
         res = curl_easy_perform(curl);
         if (res != CURLE_OK) {
@@ -33,6 +36,7 @@ void validCode()
     }
 }
 
+// cppcheck-suppress constParameterPointer
 void ignoredReturnValue(CURL * handle)
 {
     // cppcheck-suppress ignoredReturnValue
@@ -41,21 +45,21 @@ void ignoredReturnValue(CURL * handle)
 
 void resourceLeak_curl_easy_init()
 {
-    CURL *curl = curl_easy_init();
+    const CURL *curl = curl_easy_init();
     printf("%p", curl);
     // cppcheck-suppress resourceLeak
 }
 
 void resourceLeak_curl_easy_duphandle(CURL * handle)
 {
-    CURL *curl = curl_easy_duphandle(handle);
+    const CURL *curl = curl_easy_duphandle(handle);
     printf("%p", curl);
     // cppcheck-suppress resourceLeak
 }
 
 void memleak_curl_easy_escape(CURL * handle)
 {
-    char * pStr = curl_easy_escape(handle, "a", 1);
+    const char * pStr = curl_easy_escape(handle, "a", 1);
     if (pStr)
         printf("%s", pStr);
     // cppcheck-suppress memleak
@@ -76,8 +80,8 @@ void nullPointer(CURL * handle)
 
 void uninitvar(CURL * handle)
 {
-    char * bufInit[10] = {0};
-    char * bufUninit;
+    const char * bufInit[10] = {0};
+    const char * bufUninit;
     size_t len;
 
     curl_easy_send(handle, bufInit, 10, &len);
diff --git a/test/cfg/libsigc++.cpp b/test/cfg/libsigc++.cpp
new file mode 100644
index 00000000000..499e36d839a
--- /dev/null
+++ b/test/cfg/libsigc++.cpp
@@ -0,0 +1,31 @@
+
+// Test library configuration for libsigc++.cfg
+//
+// Usage:
+// $ cppcheck --check-library --library=libsigc++ --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/libsigc++.cpp
+// =>
+// No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
+//
+
+#include <sigc++/sigc++.h> // IWYU pragma: keep
+#include <sigc++/functors/mem_fun.h>
+#include <sigc++/functors/slot.h>
+#include <sigc++/trackable.h>
+
+struct struct1 : public sigc::trackable {
+    void func1(int) const {}
+};
+
+void valid_code()
+{
+    const struct1 my_sruct1;
+    sigc::slot<void, int> sl = sigc::mem_fun(my_sruct1, &struct1::func1);
+    if (sl) {}
+}
+
+void ignoredReturnValue()
+{
+    const struct1 my_sruct1;
+    // cppcheck-suppress ignoredReturnValue
+    sigc::mem_fun(my_sruct1, &struct1::func1);
+}
diff --git a/test/cfg/lua.c b/test/cfg/lua.c
index 6f254cc12cd..8555bc1d876 100644
--- a/test/cfg/lua.c
+++ b/test/cfg/lua.c
@@ -2,7 +2,7 @@
 // Test library configuration for lua.cfg
 //
 // Usage:
-// $ cppcheck --check-library --library=lua --enable=information --error-exitcode=1 --inline-suppr --suppress=missingIncludeSystem test/cfg/lua.c
+// $ cppcheck --check-library --library=lua --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/lua.c
 // =>
 // No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
 //
diff --git a/test/cfg/mfc.cpp b/test/cfg/mfc.cpp
new file mode 100644
index 00000000000..84a7d868971
--- /dev/null
+++ b/test/cfg/mfc.cpp
@@ -0,0 +1,26 @@
+
+// Test library configuration for mfc.cfg
+
+#include <afxwin.h>
+
+
+class MyClass1 : public CObject {
+    DECLARE_DYNAMIC(MyClass1)
+public:
+    MyClass1() {}
+};
+IMPLEMENT_DYNAMIC(MyClass1, CObject)
+
+class MyClass2 : public CObject {
+    DECLARE_DYNCREATE(MyClass2)
+public:
+    MyClass2() {}
+};
+IMPLEMENT_DYNCREATE(MyClass2, CObject)
+
+class MyClass3 : public CObject {
+    DECLARE_SERIAL(MyClass3)
+public:
+    MyClass3() {}
+};
+IMPLEMENT_SERIAL(MyClass3, CObject, 42)
diff --git a/test/cfg/opencv2.cpp b/test/cfg/opencv2.cpp
new file mode 100644
index 00000000000..6e79caab8d0
--- /dev/null
+++ b/test/cfg/opencv2.cpp
@@ -0,0 +1,51 @@
+
+// Test library configuration for opencv2.cfg
+//
+// Usage:
+// $ cppcheck --check-library --library=opencv2 --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/opencv2.cpp
+// =>
+// No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
+//
+
+// cppcheck-suppress-file valueFlowBailout
+
+#include <iostream>
+#include <opencv2/opencv.hpp>
+
+
+void validCode(const char* argStr)
+{
+    cv::Mat image;
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
+    image = cv::imread(argStr, cv::IMREAD_COLOR);
+    if (!image.data) {
+        printf("No image data \n");
+        return;
+    }
+    cv::namedWindow("Display Image", cv::WINDOW_AUTOSIZE);
+    cv::imshow("Display Image", image);
+    cv::waitKey(0);
+
+    cv::String cvStr("Hello");
+    cvStr += " World";
+    std::cout << cvStr;
+
+    // cppcheck-suppress [cstyleCast, unusedAllocatedMemory]
+    char * pBuf = (char *)cv::fastMalloc(20);
+    cv::fastFree(pBuf);
+}
+
+void ignoredReturnValue()
+{
+    // cppcheck-suppress ignoredReturnValue
+    cv::imread("42.png");
+}
+
+void memleak()
+{
+    // cppcheck-suppress cstyleCast
+    const char * pBuf = (char *)cv::fastMalloc(1000);
+    // cppcheck-suppress [uninitdata, valueFlowBailoutIncompleteVar, nullPointerOutOfMemory]
+    std::cout << pBuf;
+    // cppcheck-suppress memleak
+}
diff --git a/test/cfg/openmp.c b/test/cfg/openmp.c
index b7a9f8e6100..709e4dad18a 100644
--- a/test/cfg/openmp.c
+++ b/test/cfg/openmp.c
@@ -2,7 +2,7 @@
 // Test library configuration for openmp.cfg
 //
 // Usage:
-// $ cppcheck --check-library --library=openmp --enable=information --error-exitcode=1 --inline-suppr --suppress=missingIncludeSystem test/cfg/openmp.c
+// $ cppcheck --check-library --library=openmp --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/openmp.c
 // =>
 // No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
 //
@@ -15,6 +15,7 @@ void validCode()
     int arr[20] = { 0 };
     #pragma omp parallel for
     for (int i = 0; i < 20; ++i) {
+        // cppcheck-suppress unreadVariable
         arr[i] = i * i;
     }
 
@@ -25,7 +26,7 @@ void validCode()
 
 void memleak_omp_target_alloc()
 {
-    char * pChars = (char *) omp_target_alloc(2, 0);
+    const char * pChars = (char *) omp_target_alloc(2, 0);
     printf("pChars: %p", pChars);
     // cppcheck-suppress memleak
 }
diff --git a/test/cfg/openssl.c b/test/cfg/openssl.c
new file mode 100644
index 00000000000..edfc4dd04a8
--- /dev/null
+++ b/test/cfg/openssl.c
@@ -0,0 +1,70 @@
+
+// Test library configuration for openssl.cfg
+//
+// Usage:
+// $ cppcheck --check-library --library=openssl --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/openssl.c
+// =>
+// No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
+//
+
+#include <openssl/bio.h>
+#include <openssl/evp.h>
+//#include <openssl/types.h>
+#include <stdio.h>
+#include <string.h>
+
+void valid_code(BIO * bio)
+{
+    BIO_printf(bio, "%d\n", 1);
+}
+
+// Example for encrypting a string using IDEA (from https://www.openssl.org/docs/man1.1.1/man3/EVP_CIPHER_CTX_new.html)
+int valid_code_do_crypt(const char *outfile)
+{
+    unsigned char outbuf[1024];
+    int outlen, tmplen;
+    const unsigned char key[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+    const unsigned char iv[] = {1,2,3,4,5,6,7,8};
+    const char intext[] = "Some Crypto Text";
+    EVP_CIPHER_CTX *ctx;
+    FILE *out;
+
+    ctx = EVP_CIPHER_CTX_new();
+    // cppcheck-suppress checkLibraryFunction
+    EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv);
+
+    if (!EVP_EncryptUpdate(ctx, outbuf, &outlen, intext, strlen(intext))) {
+        /* Error */
+        EVP_CIPHER_CTX_free(ctx);
+        return 0;
+    }
+    if (!EVP_EncryptFinal_ex(ctx, outbuf + outlen, &tmplen)) {
+        /* Error */
+        EVP_CIPHER_CTX_free(ctx);
+        return 0;
+    }
+    outlen += tmplen;
+    EVP_CIPHER_CTX_free(ctx);
+
+    out = fopen(outfile, "wb");
+    if (out == NULL) {
+        /* Error */
+        return 0;
+    }
+    fwrite(outbuf, 1, outlen, out);
+    fclose(out);
+    return 1;
+}
+
+void invalidPrintfArgType_test(BIO * bio)
+{
+    // cppcheck-suppress invalidPrintfArgType_sint
+    BIO_printf(bio, "%d\n", 5U);
+}
+
+void EVP_CIPHER_CTX_new_test()
+{
+    const EVP_CIPHER_CTX * ctx = EVP_CIPHER_CTX_new();
+    printf("%p", ctx);
+    // cppcheck-suppress resourceLeak
+}
diff --git a/test/cfg/posix.c b/test/cfg/posix.c
index 0649b300a7b..2e53d171dec 100644
--- a/test/cfg/posix.c
+++ b/test/cfg/posix.c
@@ -2,26 +2,871 @@
 // Test library configuration for posix.cfg
 //
 // Usage:
-// $ cppcheck --check-library --library=posix --enable=information --error-exitcode=1 --inline-suppr --suppress=missingIncludeSystem test/cfg/posix.c
+// $ cppcheck --check-library --library=posix --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/posix.c
 // =>
 // No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
 //
 
-#include <stdlib.h>
+// cppcheck-suppress-file [valueFlowBailout]
+
+#define _BSD_SOURCE
+#define _XOPEN_SOURCE // wcwidth
+
+#include <aio.h>
 #include <stdio.h> // <- FILE
 #include <dirent.h>
 #include <sys/mman.h>
 #include <sys/socket.h>
+#include <sys/sem.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <grp.h>
+#include <pwd.h>
 #include <dlfcn.h>
 #include <fcntl.h>
-// unavailable on some linux systems #include <ndbm.h>
+// #include <ndbm.h> // unavailable on some linux systems
 #include <netdb.h>
 #include <regex.h>
 #include <time.h>
-#include <unistd.h>
 #include <pthread.h>
 #include <syslog.h>
 #include <stdarg.h>
+#include <ctype.h>
+#include <stdbool.h>
+#include <string.h>
+#include <strings.h>
+#if defined(__APPLE__)
+#include <xlocale.h>
+#endif
+#if !defined(__APPLE__)
+#include <mqueue.h>
+#endif
+#include <stdlib.h>
+#include <unistd.h>
+#include <wchar.h>
+#include <sys/stat.h>
+#include <utime.h>
+#include <stddef.h>
+
+
+#if !defined(__APPLE__)
+void nullPointer_mq_timedsend(mqd_t mqdes, const char* msg_ptr, size_t msg_len, unsigned msg_prio, const struct timespec* abs_timeout) {
+    // cppcheck-suppress nullPointer
+    (void) mq_timedsend(mqdes, NULL, msg_len, msg_prio, abs_timeout);
+    // cppcheck-suppress nullPointer
+    (void) mq_timedsend(mqdes, msg_ptr, msg_len, msg_prio, NULL);
+}
+#endif
+
+#if __TRACE_H__ // <trace.h>
+
+void nullPointer_posix_trace_event(trace_event_id_t event_id, const void* restrictdata_ptr, size_t data_len)
+{
+    // cppcheck-suppress nullPointer
+    (void) posix_trace_event(event_id, NULL, data_len);
+    (void) posix_trace_event(event_id, restrictdata_ptr, 0);
+}
+
+void nullPointer_posix_trace_trygetnext_event(trace_id_t trid,
+                                              struct posix_trace_event_info *event,
+                                              void *data, size_t num_bytes,
+                                              size_t *data_len, int *unavailable)
+{
+    // cppcheck-suppress nullPointer
+    (void) posix_trace_trygetnext_event(trid, NULL, data, num_bytes, data_len, unavailable);
+    // cppcheck-suppress nullPointer
+    (void) posix_trace_trygetnext_event(trid, event, NULL, num_bytes, data_len, unavailable);
+    // cppcheck-suppress nullPointer
+    (void) posix_trace_trygetnext_event(trid, event, data, num_bytes, NULL, unavailable);
+    // cppcheck-suppress nullPointer
+    (void) posix_trace_trygetnext_event(trid, event, data, num_bytes, data_len, NULL);
+}
+
+int nullPointer_posix_trace_timedgetnext_event(trace_id_t trid, struct posix_trace_event_info *restrict event, void *restrict data, size_t num_bytes, size_t *restrict data_len, int *restrict unavailable, const struct timespec *restrict abstime)
+{
+    // cppcheck-suppress nullPointer
+    (void) posix_trace_timedgetnext_event(trid, NULL, data, num_bytes, data_len, unavailable, abstime);
+    // cppcheck-suppress nullPointer
+    (void) posix_trace_timedgetnext_event(trid, event, NULL, num_bytes, data_len, unavailable, abstime);
+    // cppcheck-suppress nullPointer
+    (void) posix_trace_timedgetnext_event(trid, event, data, num_bytes, NULL, unavailable, abstime);
+    // cppcheck-suppress nullPointer
+    (void) posix_trace_timedgetnext_event(trid, event, data, num_bytes, data_len, NULL, abstime);
+    // cppcheck-suppress nullPointer
+    (void) posix_trace_timedgetnext_event(trid, event, data, num_bytes, data_len, unavailable, NULL);
+    return posix_trace_timedgetnext_event(trid, event, data, num_bytes, data_len, unavailable, abstime);
+}
+
+int nullPointer_posix_trace_getnext_event(trace_id_t trid, struct posix_trace_event_info *restrict event, const void *restrict data, size_t num_bytes, size_t *restrict data_len, int *restrict unavailable)
+{
+    // cppcheck-suppress nullPointer
+    (void) posix_trace_getnext_event(trid, NULL, data, num_bytes, data_len, unavailable);
+    // cppcheck-suppress nullPointer
+    (void) posix_trace_getnext_event(trid, event, NULL, num_bytes, data_len, unavailable);
+    // cppcheck-suppress nullPointer
+    (void) posix_trace_getnext_event(trid, event, data, num_bytes, NULL, unavailable);
+    // cppcheck-suppress nullPointer
+    (void) posix_trace_getnext_event(trid, event, data, num_bytes, data_len, NULL);
+    return posix_trace_getnext_event(trid, event, data, num_bytes, data_len, unavailable);
+}
+#endif // __TRACE_H__
+
+size_t nullPointer_strxfrm_l(char *restrict dest, const char *restrict src, size_t count, locale_t locale)
+{
+    (void)strxfrm_l(dest, src, count, locale);
+    // In case the 3rd argument is 0, the 1st argument is permitted to be a null pointer. (#6306)
+    (void)strxfrm_l(NULL, src, 0, locale);
+    (void)strxfrm_l(NULL, src, 1, locale);
+    (void)strxfrm_l(NULL, src, count, locale);
+    // cppcheck-suppress nullPointer
+    return strxfrm_l(dest, NULL, count, locale);
+}
+
+void nullPointer_pthread_attr_getstack(const pthread_attr_t *attr, void *stackaddr, size_t stacksize) {
+    // cppcheck-suppress nullPointer
+    (void) pthread_attr_getstack(NULL, &stackaddr, &stacksize);
+    // cppcheck-suppress nullPointer
+    (void) pthread_attr_getstack(attr, NULL, &stacksize);
+    // cppcheck-suppress nullPointer
+    (void) pthread_attr_getstack(attr, &stackaddr, NULL);
+    // cppcheck-suppress nullPointer
+    (void) pthread_attr_getstack(NULL, NULL, &stacksize);
+    // cppcheck-suppress nullPointer
+    (void) pthread_attr_getstack(NULL, &stackaddr, NULL);
+    // cppcheck-suppress nullPointer
+    (void) pthread_attr_getstack(attr, NULL, NULL);
+    // cppcheck-suppress nullPointer
+    (void) pthread_attr_getstack(NULL, NULL, NULL);
+}
+
+void nullPointer_pthread_attr_setstack(const pthread_attr_t *attr) {
+    // cppcheck-suppress nullPointer
+    (void) pthread_attr_setstack(NULL, NULL, 0);
+    (void) pthread_attr_setstack(attr, NULL, 0);
+    // cppcheck-suppress nullPointer
+    // cppcheck-suppress intToPointerCast
+    (void) pthread_attr_setstack(NULL, (void*) 1, 0);
+}
+
+#ifndef __linux__
+void nullPointer_setkey(const char *key)
+{
+    // cppcheck-suppress nullPointer
+    setkey(NULL);
+}
+
+void nullPointer_encrypt(const char block[64], int edflag)
+{
+    // cppcheck-suppress nullPointer
+    encrypt(NULL, edflag);
+    encrypt(block, edflag);
+}
+#endif
+
+int nullPointer_getopt(int argc, char* const argv[], const char* optstring)
+{
+    // cppcheck-suppress nullPointer
+    (void) getopt(argc, NULL, optstring);
+    // cppcheck-suppress nullPointer
+    (void) getopt(argc, argv, NULL);
+    return getopt(argc, argv, optstring);
+}
+
+#if !defined(__APPLE__)
+int invalidFunctionArgStr_mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio)
+{
+    // No warning is expected for:
+    const char msg = '0';
+    (void) mq_send(mqdes, &msg, 1, 0);
+    return mq_send(mqdes, msg_ptr, msg_len, 0);
+}
+#endif
+
+void invalidFunctionArgStr_mbsnrtowcs(void)
+{
+    wchar_t wenough[10];
+    mbstate_t s;
+    memset (&s, '\0', sizeof (s));
+    const char* cp = "ABC";
+    wcscpy (wenough, L"DEF");
+    // No warning is expected for - #11119
+    if (mbsnrtowcs (wenough, &cp, 1, 10, &s) != 1 || wcscmp (wenough, L"AEF") != 0) {}
+}
+
+struct tm * ignoredReturnValue_localtime(const time_t *tp)
+{
+    // cppcheck-suppress [ignoredReturnValue,localtimeCalled]
+    localtime(tp);
+    // cppcheck-suppress localtimeCalled
+    return localtime(tp);
+}
+
+int nullPointer_getpwuid_r(uid_t uid, struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result)
+{
+    // cppcheck-suppress nullPointer
+    (void) getpwuid_r(uid, NULL, buffer, bufsize, result);
+    // cppcheck-suppress nullPointer
+    (void) getpwuid_r(uid, pwd, NULL, bufsize, result);
+    // cppcheck-suppress nullPointer
+    (void) getpwuid_r(uid, pwd, buffer, bufsize, NULL);
+    return getpwuid_r(uid, pwd, buffer, bufsize, result);
+}
+
+int nullPointer_getpwnam_r(const char *name, struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result)
+{
+    // cppcheck-suppress nullPointer
+    (void) getpwnam_r(NULL, pwd, buffer, bufsize, result);
+    // cppcheck-suppress nullPointer
+    (void) getpwnam_r(name, NULL, buffer, bufsize, result);
+    // cppcheck-suppress nullPointer
+    (void) getpwnam_r(name, pwd, NULL, bufsize, result);
+    // cppcheck-suppress nullPointer
+    (void) getpwnam_r(name, pwd, buffer, bufsize, NULL);
+    return getpwnam_r(name, pwd, buffer, bufsize, result);
+}
+
+#if !defined(__APPLE__)
+int nullPointer_fgetpwent_r(FILE *restrict stream, const struct passwd *restrict pwbuf, char *restrict buf, size_t buflen, struct passwd **restrict pwbufp)
+{
+    // cppcheck-suppress nullPointer
+    (void) fgetpwent_r(NULL, pwbuf, buf, buflen, pwbufp);
+    // cppcheck-suppress nullPointer
+    (void) fgetpwent_r(stream, NULL, buf, buflen, pwbufp);
+    // cppcheck-suppress nullPointer
+    (void) fgetpwent_r(stream, pwbuf, NULL, buflen, pwbufp);
+    // cppcheck-suppress nullPointer
+    (void) fgetpwent_r(stream, pwbuf, buf, buflen, NULL);
+    return fgetpwent_r(stream, pwbuf, buf, buflen, pwbufp);
+}
+
+int nullPointer_getpwent_r(const struct passwd *restrict pwbuf, char *restrict buf, size_t buflen, struct passwd **restrict pwbufp)
+{
+    // cppcheck-suppress nullPointer
+    (void) getpwent_r(NULL, buf, buflen, pwbufp);
+    // cppcheck-suppress nullPointer
+    (void) getpwent_r(pwbuf, NULL, buflen, pwbufp);
+    // cppcheck-suppress nullPointer
+    (void) getpwent_r(pwbuf, buf, buflen, NULL);
+    return getpwent_r(pwbuf, buf, buflen, pwbufp);
+}
+#endif
+
+int nullPointer_getgrgid_r(gid_t gid, struct group *restrict grp, char *restrict buf, size_t buflen, struct group **restrict result)
+{
+    // cppcheck-suppress nullPointer
+    (void) getgrgid_r(gid, NULL, buf, buflen, result);
+    // cppcheck-suppress nullPointer
+    (void) getgrgid_r(gid, grp, NULL, buflen, result);
+    // cppcheck-suppress nullPointer
+    (void) getgrgid_r(gid, grp, buf, buflen, NULL);
+    return getgrgid_r(gid, grp, buf, buflen, result);
+}
+
+int nullPointer_getgrnam_r(const char *restrict name, struct group *restrict grp, char *restrict buf, size_t buflen, struct group **restrict result)
+{
+    // cppcheck-suppress nullPointer
+    (void) getgrnam_r(NULL, grp, buf, buflen, result);
+    // cppcheck-suppress nullPointer
+    (void) getgrnam_r(name, NULL, buf, buflen, result);
+    // cppcheck-suppress nullPointer
+    (void) getgrnam_r(name, grp, NULL, buflen, result);
+    // cppcheck-suppress nullPointer
+    (void) getgrnam_r(name, grp, buf, buflen, NULL);
+    return getgrnam_r(name, grp, buf, buflen, result);
+}
+
+void knownConditionTrueFalse_ffs(int i)
+{
+    // ffs() returns the position of the first bit set, or 0 if no bits are set in i.
+    const int x = ffs(0);
+    // cppcheck-suppress knownConditionTrueFalse
+    if (x == 0) {} // always true
+    // cppcheck-suppress knownConditionTrueFalse
+    if (x == 1) {} // always false
+    if (ffs(i) == 0) {}
+}
+
+ssize_t nullPointer_readlink(const char *path, char *buf, size_t bufsiz)
+{
+    // cppcheck-suppress nullPointer
+    (void)readlink(NULL, buf, bufsiz);
+    // cppcheck-suppress nullPointer
+    (void)readlink(path, NULL, bufsiz);
+    return readlink(path, buf, bufsiz);
+}
+
+int nullPointer_readlinkat(int dirfd, const char *pathname, char *buf, size_t bufsiz)
+{
+    // cppcheck-suppress nullPointer
+    (void) readlinkat(dirfd, NULL, buf, bufsiz);
+    // cppcheck-suppress nullPointer
+    (void) readlinkat(dirfd, pathname, NULL, bufsiz);
+    return readlinkat(dirfd, pathname, buf, bufsiz);
+}
+
+ssize_t nullPointer_recv(int sockfd, void *buf, size_t len, int flags)
+{
+    // cppcheck-suppress nullPointer
+    (void) recv(sockfd, NULL, len, flags);
+    return recv(sockfd, buf, len, flags);
+}
+
+ssize_t nullPointer_recvfrom(int sockfd, void *buf, size_t len, int flags,
+                             struct sockaddr *src_addr, socklen_t *addrlen)
+{
+    // If src_addr is not NULL, and the underlying protocol provides the source address, this source address is filled in.
+    (void) recvfrom(sockfd, buf, len, flags, NULL, addrlen);
+    (void) recvfrom(sockfd, buf, len, flags, src_addr, NULL);
+    (void) recvfrom(sockfd, buf, len, flags, NULL, NULL);
+    // cppcheck-suppress nullPointer
+    (void) recvfrom(sockfd, NULL, len, flags, src_addr, addrlen);
+    return recvfrom(sockfd, buf, len, flags, src_addr, addrlen);
+}
+int nullPointer_semop(int semid, struct sembuf *sops, size_t nsops)
+{
+    // cppcheck-suppress nullPointer
+    (void)semop(semid, NULL, nsops);
+    return semop(semid, sops, nsops);
+}
+
+int nullPointer_socketpair(int domain, int t, int protocol, int sv[2])
+{
+    // cppcheck-suppress nullPointer
+    (void) socketpair(domain, t, protocol, NULL);
+    return socketpair(domain, t, protocol, sv);
+}
+
+void nullPointer_lcong48(const unsigned short param[7])
+{
+    // cppcheck-suppress nullPointer
+    (void) lcong48(NULL);
+    return lcong48(param);
+}
+
+long int nullPointer_jrand48(unsigned short xsubi[3])
+{
+    // cppcheck-suppress nullPointer
+    (void) jrand48(NULL);
+    return jrand48(xsubi);
+}
+
+long int nullPointer_nrand48(unsigned short xsubi[3])
+{
+    // cppcheck-suppress nullPointer
+    (void) nrand48(NULL);
+    return nrand48(xsubi);
+}
+
+double nullPointer_erand48(unsigned short xsubi[3])
+{
+    // cppcheck-suppress nullPointer
+    (void) erand48(NULL);
+    return erand48(xsubi);
+}
+
+struct non_const_parameter_erand48_struct { unsigned short xsubi[3]; };
+// No warning is expected that dat can be const
+double non_const_parameter_erand48(struct non_const_parameter_erand48_struct *dat)
+{
+    return erand48(dat->xsubi);
+}
+
+unsigned short *nullPointer_seed48(const unsigned short seed16v[3])
+{
+    // cppcheck-suppress nullPointer
+    (void) seed48(NULL);
+    return seed48(seed16v);
+}
+
+int nullPointer_getlogin_r(char *buf, size_t bufsize)
+{
+    // cppcheck-suppress nullPointer
+    (void)getlogin_r(NULL,bufsize);
+    return getlogin_r(buf,bufsize);
+}
+
+ssize_t uninitvar_pread(int fd, void *buf, size_t nbyte, off_t offset)
+{
+    int Fd;
+    // cppcheck-suppress uninitvar
+    (void)pread(Fd,buf,nbyte,offset);
+    size_t Nbyte;
+    // cppcheck-suppress uninitvar
+    (void)pread(fd,buf,Nbyte,offset);
+    off_t Offset;
+    // cppcheck-suppress uninitvar
+    (void)pread(fd,buf,nbyte,Offset);
+    return pread(fd,buf,nbyte,offset);
+}
+
+ssize_t nullPointer_pwrite(int fd, const void *buf, size_t nbyte, off_t offset)
+{
+    // cppcheck-suppress nullPointer
+    (void)pwrite(fd,NULL,nbyte,offset);
+    return pwrite(fd,buf,nbyte,offset);
+}
+
+int nullPointer_ttyname_r(int fd, char *buf, size_t buflen)
+{
+    // cppcheck-suppress nullPointer
+    (void)ttyname_r(fd,NULL,buflen);
+    return ttyname_r(fd,buf,buflen);
+}
+
+size_t bufferAccessOutOfBounds_wcsnrtombs(char *restrict dest, const wchar_t **restrict src, size_t nwc, size_t len, mbstate_t *restrict ps)
+{
+    char buf[42];
+    (void)wcsnrtombs(buf,src,nwc,42,ps);
+    // cppcheck-suppress bufferAccessOutOfBounds
+    (void)wcsnrtombs(buf,src,nwc,43,ps);
+    return wcsnrtombs(dest,src,nwc,len,ps);
+}
+
+size_t nullPointer_wcsnrtombs(char *restrict dest, const wchar_t **restrict src, size_t nwc, size_t len, mbstate_t *restrict ps)
+{
+    // It is allowed to set the first arg to NULL
+    (void)wcsnrtombs(NULL,src,nwc,len,ps);
+    // cppcheck-suppress nullPointer
+    (void)wcsnrtombs(dest,NULL,nwc,len,ps);
+    // It is allowed to set the last arg to NULL
+    (void)wcsnrtombs(dest,src,nwc,len,NULL);
+    return wcsnrtombs(dest,src,nwc,len,ps);
+}
+
+int nullPointer_wcsncasecmp(const wchar_t *s1, const wchar_t *s2, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)wcsncasecmp(NULL,s2,n);
+    // cppcheck-suppress nullPointer
+    (void)wcsncasecmp(s1,NULL,n);
+    return wcsncasecmp(s1,s2,n);
+}
+
+int uninitvar_wcwidth(const wchar_t c)
+{
+    wchar_t wc;
+    // cppcheck-suppress uninitvar
+    (void)wcwidth(wc);
+    // No warning is expected
+    return wcwidth(c);
+}
+
+int nullPointer_wcsnlen(const wchar_t *s, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)wcsnlen(NULL, n);
+    // No warning is expected
+    return wcsnlen(s, n);
+}
+
+size_t bufferAccessOutOfBounds_wcsnlen(void) // #10997
+{
+    const wchar_t buf[2]={L'4',L'2'};
+    size_t len = wcsnlen(buf,2);
+    // TODO cppcheck-suppress bufferAccessOutOfBounds
+    len+=wcsnlen(buf,3);
+    return len;
+}
+
+int nullPointer_gethostname(char *s, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)gethostname(NULL, n);
+    // No warning is expected
+    return gethostname(s, n);
+}
+
+int nullPointer_wcswidth(const wchar_t *s, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)wcswidth(NULL, n);
+    // No warning is expected
+    return wcswidth(s, n);
+}
+
+int nullPointer_aio_cancel(int fd, struct aiocb *aiocbp)
+{
+    // No warning is expected
+    (void)aio_cancel(fd, NULL);
+    // No warning is expected
+    return aio_cancel(fd, aiocbp);
+}
+
+int nullPointer_aio_fsync(int op, struct aiocb *aiocbp)
+{
+    // cppcheck-suppress nullPointer
+    (void)aio_fsync(op, NULL);
+    // No warning is expected
+    return aio_fsync(op, aiocbp);
+}
+
+ssize_t nullPointer_aio_return(struct aiocb *aiocbp)
+{
+    // cppcheck-suppress nullPointer
+    (void)aio_return(NULL);
+    // No warning is expected
+    return aio_return(aiocbp);
+}
+
+int nullPointer_aio_error(const struct aiocb *aiocbp)
+{
+    // cppcheck-suppress nullPointer
+    (void)aio_error(NULL);
+    // No warning is expected
+    return aio_error(aiocbp);
+}
+
+int nullPointer_aio_read(struct aiocb *aiocbp)
+{
+    // cppcheck-suppress nullPointer
+    (void)aio_read(NULL);
+    // No warning is expected
+    return aio_read(aiocbp);
+}
+
+int nullPointer_aio_write(struct aiocb *aiocbp)
+{
+    // cppcheck-suppress nullPointer
+    (void)aio_write(NULL);
+    // No warning is expected
+    return aio_write(aiocbp);
+}
+
+int nullPointer_aio_suspend(const struct aiocb *const aiocb_list[], int nitems, const struct timespec *restrict timeout)
+{
+    // cppcheck-suppress nullPointer
+    (void)aio_suspend(NULL, nitems, timeout);
+    // No warning is expected
+    return aio_suspend(aiocb_list, nitems, timeout);
+}
+
+#if !defined(__linux__) && !defined(__APPLE__)
+// Note: Since glibc 2.28, this function symbol is no longer available to newly linked applications.
+void invalidFunctionArg_llseek(int fd, loff_t offset, int origin)
+{
+    // cppcheck-suppress llseekCalled
+    // cppcheck-suppress invalidFunctionArg
+    (void)llseek(-1, offset, SEEK_SET);
+    // cppcheck-suppress llseekCalled
+    // cppcheck-suppress invalidFunctionArg
+    (void)llseek(fd, offset, -1);
+    // cppcheck-suppress llseekCalled
+    // cppcheck-suppress invalidFunctionArg
+    (void)llseek(fd, offset, 3);
+    // cppcheck-suppress llseekCalled
+    // cppcheck-suppress invalidFunctionArg
+    (void)llseek(fd, offset, 42+SEEK_SET);
+    // cppcheck-suppress llseekCalled
+    // cppcheck-suppress invalidFunctionArg
+    (void)llseek(fd, offset, SEEK_SET+42);
+    // No invalidFunctionArg warning is expected for
+    // cppcheck-suppress llseekCalled
+    (void)llseek(0, offset, origin);
+    // cppcheck-suppress llseekCalled
+    (void)llseek(fd, offset, origin);
+    // cppcheck-suppress llseekCalled
+    (void)llseek(fd, offset, SEEK_SET);
+    // cppcheck-suppress llseekCalled
+    (void)llseek(fd, offset, SEEK_CUR);
+    // cppcheck-suppress llseekCalled
+    (void)llseek(fd, offset, SEEK_END);
+}
+
+void invalidFunctionArg_lseek64(int fd, off_t offset, int origin)
+{
+    // cppcheck-suppress invalidFunctionArg
+    (void)lseek64(-1, offset, SEEK_SET);
+    // cppcheck-suppress invalidFunctionArg
+    (void)lseek64(fd, offset, -1);
+    // cppcheck-suppress invalidFunctionArg
+    (void)lseek64(fd, offset, 3);
+    // cppcheck-suppress invalidFunctionArg
+    (void)lseek64(fd, offset, 42+SEEK_SET);
+    // cppcheck-suppress invalidFunctionArg
+    (void)lseek64(fd, offset, SEEK_SET+42);
+    // No warning is expected for
+    (void)lseek64(0, offset, origin);
+    (void)lseek64(fd, offset, origin);
+    (void)lseek64(fd, offset, SEEK_SET);
+    (void)lseek64(fd, offset, SEEK_CUR);
+    (void)lseek64(fd, offset, SEEK_END);
+}
+#endif
+
+void invalidFunctionArg_lseek(int fd, off_t offset, int origin)
+{
+    // cppcheck-suppress invalidFunctionArg
+    (void)lseek(-1, offset, SEEK_SET);
+    // cppcheck-suppress invalidFunctionArg
+    (void)lseek(fd, offset, -1);
+    // cppcheck-suppress invalidFunctionArg
+    (void)lseek(fd, offset, 3);
+    // cppcheck-suppress invalidFunctionArg
+    (void)lseek(fd, offset, 42+SEEK_SET);
+    // cppcheck-suppress invalidFunctionArg
+    (void)lseek(fd, offset, SEEK_SET+42);
+    // No warning is expected for
+    (void)lseek(0, offset, origin);
+    (void)lseek(fd, offset, origin);
+    (void)lseek(fd, offset, SEEK_SET);
+    (void)lseek(fd, offset, SEEK_CUR);
+    (void)lseek(fd, offset, SEEK_END);
+}
+
+void invalidFunctionArg_fseeko(FILE* stream, off_t offset, int origin)
+{
+    // cppcheck-suppress invalidFunctionArg
+    (void)fseeko(stream, offset, -1);
+    // cppcheck-suppress invalidFunctionArg
+    (void)fseeko(stream, offset, 3);
+    // cppcheck-suppress invalidFunctionArg
+    (void)fseeko(stream, offset, 42+SEEK_SET);
+    // cppcheck-suppress invalidFunctionArg
+    (void)fseeko(stream, offset, SEEK_SET+42);
+    // No warning is expected for
+    (void)fseeko(stream, offset, origin);
+    (void)fseeko(stream, offset, SEEK_SET);
+    (void)fseeko(stream, offset, SEEK_CUR);
+    (void)fseeko(stream, offset, SEEK_END);
+}
+
+wchar_t *nullPointer_wcpncpy(wchar_t *dest, const wchar_t *src, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)wcpncpy(NULL, src, n);
+    // cppcheck-suppress nullPointer
+    (void)wcpncpy(dest, NULL, n);
+    return wcpncpy(dest, src, n);
+}
+
+int nullPointer_utimes(const char *path, const struct timeval times[2])
+{
+    // cppcheck-suppress nullPointer
+    // cppcheck-suppress utimesCalled
+    (void)utimes(NULL, times);
+    // cppcheck-suppress utimesCalled
+    return utimes(path, times);
+}
+
+char * overlappingWriteFunction_stpcpy(char *src, char *dest)
+{
+    // No warning shall be shown:
+    (void) stpcpy(dest, src);
+    // cppcheck-suppress overlappingWriteFunction
+    return stpcpy(src, src);
+}
+
+int nullPointer_strcasecmp(const char *a, const char *b)
+{
+    // No warning shall be shown:
+    (void) strcasecmp(a, b);
+    // cppcheck-suppress nullPointer
+    (void) strcasecmp(a, NULL);
+    // cppcheck-suppress nullPointer
+    return strcasecmp(NULL, b);
+}
+
+int nullPointer_strncasecmp(const char *a, const char *b, size_t n)
+{
+    // No warning shall be shown:
+    (void) strncasecmp(a, b, n);
+    // cppcheck-suppress nullPointer
+    (void) strncasecmp(a, NULL, n);
+    // cppcheck-suppress nullPointer
+    return strncasecmp(NULL, b, n);
+}
+
+int nullPointer_bcmp(const void *a, const void *b, size_t n)
+{
+    // No nullPointer warning shall be shown:
+    // cppcheck-suppress bcmpCalled
+    (void) bcmp(a, b, n);
+    // cppcheck-suppress nullPointer
+    // cppcheck-suppress bcmpCalled
+    (void) bcmp(a, NULL, n);
+    // cppcheck-suppress nullPointer
+    // cppcheck-suppress bcmpCalled
+    return bcmp(NULL, b, n);
+}
+
+void nullPointer_bzero(void *s, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    // cppcheck-suppress bzeroCalled
+    bzero(NULL,n);
+    // No nullPointer-warning shall be shown:
+    // cppcheck-suppress bzeroCalled
+    bzero(s,n);
+}
+
+void bufferAccessOutOfBounds_bzero(void *s, size_t n)
+{
+    char buf[42];
+    // cppcheck-suppress bufferAccessOutOfBounds
+    // cppcheck-suppress bzeroCalled
+    bzero(buf,43);
+    // cppcheck-suppress bzeroCalled
+    bzero(buf,42);
+    // No nullPointer-warning shall be shown:
+    // cppcheck-suppress bzeroCalled
+    bzero(s,n);
+}
+
+size_t bufferAccessOutOfBounds_strnlen(const char *s, size_t maxlen)
+{
+    const char buf[2]={'4','2'};
+    size_t len = strnlen(buf,2);
+    // cppcheck-suppress bufferAccessOutOfBounds
+    len+=strnlen(buf,3);
+    return len;
+}
+
+void bufferAccessOutOfBounds_wcpncpy()
+{
+    wchar_t s[16];
+    wcpncpy(s, L"abc", 16);
+    // cppcheck-suppress bufferAccessOutOfBounds
+    wcpncpy(s, L"abc", 17);
+}
+
+size_t nullPointer_strnlen(const char *s, size_t maxlen)
+{
+    // No warning shall be shown:
+    (void) strnlen(s, maxlen);
+    // cppcheck-suppress nullPointer
+    return strnlen(NULL, maxlen);
+}
+
+char * nullPointer_stpcpy(const char *src, char *dest)
+{
+    // No warning shall be shown:
+    (void) stpcpy(dest, src);
+    // cppcheck-suppress nullPointer
+    (void) stpcpy(dest, NULL);
+    // cppcheck-suppress nullPointer
+    return stpcpy(NULL, src);
+}
+
+char * nullPointer_strsep(char **stringptr, char *delim)
+{
+    // No warning shall be shown:
+    (void) strsep(stringptr, delim);
+    // cppcheck-suppress nullPointer
+    (void) strsep(stringptr, NULL);
+    // cppcheck-suppress nullPointer
+    return strsep(NULL, delim);
+}
+
+void overlappingWriteFunction_bcopy(char *buf, const size_t count)
+{
+    // No warning shall be shown:
+    // cppcheck-suppress bcopyCalled
+    bcopy(&buf[0], &buf[3], count); // size is not known
+    // cppcheck-suppress bcopyCalled
+    bcopy(&buf[0], &buf[3], 3U);    // no-overlap
+    // cppcheck-suppress bcopyCalled
+    bcopy(&buf[0], &buf[3], 4U);    // The result is correct, even when both areas overlap.
+}
+
+void nullPointer_bcopy(const void *src, void *dest, size_t n)
+{
+    // No warning shall be shown:
+    // cppcheck-suppress bcopyCalled
+    bcopy(src, dest, n);
+    // cppcheck-suppress bcopyCalled
+    // cppcheck-suppress nullPointer
+    bcopy(NULL, dest, n);
+    // cppcheck-suppress bcopyCalled
+    // cppcheck-suppress nullPointer
+    bcopy(src, NULL, n);
+}
+
+void overlappingWriteFunction_memccpy(const unsigned char *src, unsigned char *dest, int c, size_t count)
+{
+    // No warning shall be shown:
+    (void)memccpy(dest, src, c, count);
+    (void)memccpy(dest, src, 42, count);
+    // cppcheck-suppress overlappingWriteFunction
+    (void)memccpy(dest, dest, c, 4);
+    // cppcheck-suppress overlappingWriteFunction
+    (void)memccpy(dest, dest+3, c, 4);
+}
+
+void overlappingWriteFunction_stpncpy(char *src, char *dest, ssize_t n)
+{
+    // No warning shall be shown:
+    (void) stpncpy(dest, src, n);
+    // cppcheck-suppress overlappingWriteFunction
+    (void)stpncpy(src, src+3, 4);
+}
+
+wchar_t* overlappingWriteFunction_wcpncpy(wchar_t *src, wchar_t *dest, ssize_t n)
+{
+    // No warning shall be shown:
+    (void) wcpncpy(dest, src, n);
+    // cppcheck-suppress overlappingWriteFunction
+    return wcpncpy(src, src+3, 4);
+}
+
+void overlappingWriteFunction_swab(char *src, char *dest, ssize_t n)
+{
+    // No warning shall be shown:
+    swab(src, dest, n);
+    // cppcheck-suppress overlappingWriteFunction
+    swab(src, src+3, 4);
+}
+
+void bufferAccessOutOfBounds_swab(char *src, char *dest, ssize_t n)
+{
+    // No warning shall be shown:
+    swab(dest, src, n);
+    const char srcBuf[42] = {0};
+    char destBuf[42] = {0};
+    swab(srcBuf, dest, 42);
+    // cppcheck-suppress bufferAccessOutOfBounds
+    swab(srcBuf, dest, 43);
+    swab(src, destBuf, 42);
+    // cppcheck-suppress bufferAccessOutOfBounds
+    swab(src, destBuf, 43);
+}
+
+void nullPointer_swab(char *src, char *dest, ssize_t n)
+{
+    // No warning shall be shown:
+    swab(dest, src, n);
+    // cppcheck-suppress nullPointer
+    swab(NULL, dest, n);
+    // cppcheck-suppress nullPointer
+    swab(src, NULL, n);
+}
+
+bool invalidFunctionArgBool_isascii(bool b, int c)
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)isascii(b);
+    // cppcheck-suppress invalidFunctionArgBool
+    return isascii(c != 0);
+}
+
+void uninitvar_putenv(char * envstr)
+{
+    // No warning is expected
+    (void)putenv(envstr);
+
+    char * p;
+    // cppcheck-suppress uninitvar
+    (void)putenv(p);
+}
+
+void nullPointer_putenv(char * envstr)
+{
+    // No warning is expected
+    (void)putenv(envstr);
+
+    char * p=NULL;
+    // cppcheck-suppress nullPointer
+    (void)putenv(p);
+}
 
 void memleak_scandir(void)
 {
@@ -39,7 +884,7 @@ void memleak_scandir(void)
        which is allocated via malloc(3).  If filter is NULL, all entries are
        selected.*/
 
-    // TODO: cppcheck-suppress memleak
+    // cppcheck-suppress memleak
 }
 
 void no_memleak_scandir(void)
@@ -60,6 +905,7 @@ void validCode(va_list valist_arg1, va_list valist_arg2)
     void *ptr;
     if (posix_memalign(&ptr, sizeof(void *), sizeof(void *)) == 0)
         free(ptr);
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
     syslog(LOG_ERR, "err %u", 0U);
     syslog(LOG_WARNING, "warn %d %d", 5, 1);
     vsyslog(LOG_EMERG, "emerg %d", valist_arg1);
@@ -71,6 +917,41 @@ void validCode(va_list valist_arg1, va_list valist_arg2)
     }
 }
 
+typedef struct {
+    size_t N;
+    int* data;
+} S_memalign;
+
+S_memalign* posix_memalign_memleak(size_t n) { // #12248
+    S_memalign* s = malloc(sizeof(*s));
+    // cppcheck-suppress nullPointerOutOfMemory
+    s->N = n;
+    if (0 != posix_memalign((void**)&s->data, 16, n * sizeof(int))) {
+        free(s);
+        return NULL;
+    }
+    // cppcheck-suppress nullPointerOutOfMemory
+    memset(s->data, 0, n * sizeof(int));
+    return s;
+}
+
+ssize_t nullPointer_send(int socket, const void *buf, size_t len, int flags)
+{
+    // cppcheck-suppress nullPointer
+    (void) send(socket, NULL, len, flags);
+    return send(socket, buf, len, flags);
+}
+
+ssize_t nullPointer_sendto(int socket, const void *message, size_t length,
+                           int flags, const struct sockaddr *dest_addr,
+                           socklen_t dest_len)
+{
+    // cppcheck-suppress nullPointer
+    (void) sendto(socket, NULL, length, flags, dest_addr, dest_len);
+    (void) sendto(socket, message, length, flags, NULL, dest_len);
+    return sendto(socket, message, length, flags, dest_addr, dest_len);
+}
+
 void bufferAccessOutOfBounds(int fd)
 {
     char a[5];
@@ -113,7 +994,6 @@ void nullPointer(char *p, int fd, pthread_mutex_t mutex)
     mkdir(p, 0);
     getcwd(0, 0);
     // cppcheck-suppress nullPointer
-    // cppcheck-suppress readdirCalled
     readdir(0);
     // cppcheck-suppress nullPointer
     // cppcheck-suppress utimeCalled
@@ -133,7 +1013,6 @@ void nullPointer(char *p, int fd, pthread_mutex_t mutex)
     // cppcheck-suppress unreadVariable
     // cppcheck-suppress nullPointer
     int ret = access(NULL, 0);
-    // cppcheck-suppress ignoredReturnValue
     // cppcheck-suppress leakReturnValNotUsed
     // cppcheck-suppress nullPointer
     fdopen(fd, NULL);
@@ -155,28 +1034,164 @@ void nullPointer(char *p, int fd, pthread_mutex_t mutex)
     pthread_mutex_unlock(NULL);
 }
 
-void memleak_getaddrinfo()
+// cppcheck-suppress constParameterCallback
+void* f_returns_NULL(void* arg)
+{
+    return NULL;
+}
+
+void nullPointer_pthread_create() // #12396
+{
+    pthread_t thread;
+    pthread_create(&thread, NULL, (void* (*)(void*))f_returns_NULL, NULL);
+}
+
+void memleak_getaddrinfo() // #6994
 {
-    //TODO: nothing to report yet, see http://sourceforge.net/p/cppcheck/discussion/general/thread/d9737d5d/
     struct addrinfo * res=NULL;
     getaddrinfo("node", NULL, NULL, &res);
     freeaddrinfo(res);
+    getaddrinfo("node", NULL, NULL, &res);
+    // cppcheck-suppress memleak
+}
+
+void memleak_getaddrinfo_if() // #12506
+{
+    struct addrinfo hints = {};
+    struct addrinfo* addrs;
+    int err = getaddrinfo("example.com", "https", &hints, &addrs);
+    if (err != 0) {}
+    else {
+        freeaddrinfo(addrs);
+    }
+}
+
+void memleak_getaddrinfo_if2() // #12996
+{
+    struct addrinfo *addrs = NULL;
+    if (getaddrinfo("a", "b", NULL, &addrs)) {
+        return;
+    }
+    freeaddrinfo(addrs);
 }
 
 void memleak_mmap(int fd)
 {
-    // cppcheck-suppress unreadVariable
+    // cppcheck-suppress [unusedAllocatedMemory, unreadVariable, constVariablePointer]
     void *addr = mmap(NULL, 255, PROT_NONE, MAP_PRIVATE, fd, 0);
     // cppcheck-suppress memleak
 }
 
+void * memleak_mmap2() // #8327
+{
+    void * data = mmap(NULL, 10, PROT_READ, MAP_PRIVATE, 1, 0);
+    if (data != MAP_FAILED)
+        return data;
+    return NULL;
+}
+
+void memleak_getline() { // #11043
+    char *line = NULL;
+    size_t size = 0;
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
+    getline(&line, &size, stdin);
+    // cppcheck-suppress memleak
+    line = NULL;
+    getline(&line, &size, stdin);
+    // cppcheck-suppress memleak
+    line = NULL;
+}
+
+void memleak_getline_array(FILE* stream) { // #12498
+    char* a[2] = { 0 };
+    size_t n;
+    getline(&a[0], &n, stream);
+    getline(&a[1], &n, stream);
+    free(a[0]);
+    free(a[1]);
+}
+
+void memleak_getdelim(int delim) {
+    char *line = NULL;
+    size_t size = 0;
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
+    getdelim(&line, &size, delim, stdin);
+    // cppcheck-suppress memleak
+    line = NULL;
+    getdelim(&line, &size, delim, stdin);
+    // cppcheck-suppress memleak
+    line = NULL;
+}
+
+void memleak_getdelim_array(FILE* stream, int delim) {
+    char* a[2] = { 0 };
+    size_t n;
+    getdelim(&a[0], &n, delim, stream);
+    getdelim(&a[1], &n, delim, stream);
+    free(a[0]);
+    free(a[1]);
+}
+
+void * identicalCondition_mmap(int fd, size_t size) // #9940
+{
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
+    void* buffer = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+    if (buffer == MAP_FAILED) {
+        return NULL;
+    }
+    return buffer;
+}
+
+int munmap_no_double_free(int tofd, // #11396
+                          int fromfd,
+                          size_t len)
+{
+    int rc;
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
+    const void* fptr = mmap(NULL,len,PROT_READ|PROT_WRITE,MAP_SHARED,fromfd,(off_t)0);
+    if (fptr == MAP_FAILED) {
+        return -1;
+    }
+
+    void* tptr = mmap(NULL,len,PROT_READ|PROT_WRITE,MAP_SHARED,tofd,(off_t)0);
+    if (tptr == MAP_FAILED) {
+        // cppcheck-suppress memleak
+        return -1;
+    }
+
+    // cppcheck-suppress nullPointerOutOfMemory
+    memcpy(tptr,fptr,len);
+
+    // cppcheck-suppress nullPointerOutOfMemory
+    if ((rc = munmap(fptr,len)) != 0) {
+        // cppcheck-suppress memleak
+        return -1;
+    }
+
+    // cppcheck-suppress nullPointerOutOfMemory
+    if ((rc = munmap(tptr,len)) != 0) {
+        return -1;
+    }
+
+    return rc;
+}
+
 void resourceLeak_fdopen(int fd)
 {
-    // cppcheck-suppress unreadVariable
+    // cppcheck-suppress [unreadVariable, constVariablePointer]
     FILE *f = fdopen(fd, "r");
     // cppcheck-suppress resourceLeak
 }
 
+void resourceLeak_fdopen2(const char* fn) // #2767
+{
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
+    int fi = open(fn, O_RDONLY);
+    FILE* fd = fdopen(fi, "r");
+    // cppcheck-suppress nullPointerOutOfResources
+    fclose(fd);
+}
+
 void resourceLeak_mkstemp(char *template)
 {
     // cppcheck-suppress unreadVariable
@@ -197,14 +1212,14 @@ int no_resourceLeak_mkstemp_02(char *template)
 
 void resourceLeak_fdopendir(int fd)
 {
-    // cppcheck-suppress unreadVariable
+    // cppcheck-suppress [unreadVariable, constVariablePointer]
     DIR* leak1 = fdopendir(fd);
     // cppcheck-suppress resourceLeak
 }
 
 void resourceLeak_opendir(void)
 {
-    // cppcheck-suppress unreadVariable
+    // cppcheck-suppress [unreadVariable, constVariablePointer]
     DIR* leak1 = opendir("abc");
     // cppcheck-suppress resourceLeak
 }
@@ -218,14 +1233,14 @@ void resourceLeak_socket(void)
 
 void resourceLeak_open1(void)
 {
-    // cppcheck-suppress unreadVariable
+    // cppcheck-suppress [unreadVariable,valueFlowBailoutIncompleteVar]
     int fd = open("file", O_RDWR | O_CREAT);
     // cppcheck-suppress resourceLeak
 }
 
 void resourceLeak_open2(void)
 {
-    // cppcheck-suppress unreadVariable
+    // cppcheck-suppress [unreadVariable,valueFlowBailoutIncompleteVar]
     int fd = open("file", O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
     // cppcheck-suppress resourceLeak
 }
@@ -233,37 +1248,33 @@ void resourceLeak_open2(void)
 void noleak(int x, int y, int z)
 {
     DIR *p1 = fdopendir(x);
+    // cppcheck-suppress nullPointerOutOfResources
     closedir(p1);
     DIR *p2 = opendir("abc");
+    // cppcheck-suppress nullPointerOutOfResources
     closedir(p2);
     int s = socket(AF_INET,SOCK_STREAM,0);
     close(s);
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
     int fd1 = open("a", O_RDWR | O_CREAT);
     close(fd1);
     int fd2 = open("a", O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
     close(fd2);
-    /* TODO: add configuration for open/fdopen
-        // #2830
-        int fd = open("path", O_RDONLY);
-        FILE *f = fdopen(fd, "rt");
-        fclose(f);
-    */
 }
 
 
 // unused return value
 
-void ignoredReturnValue(void *addr, int fd)
+void ignoredReturnValue(const void *addr, int fd)
 {
-    // cppcheck-suppress ignoredReturnValue
     // cppcheck-suppress leakReturnValNotUsed
     mmap(addr, 255, PROT_NONE, MAP_PRIVATE, fd, 0);
     // cppcheck-suppress ignoredReturnValue
-    setuid(42);
-    // cppcheck-suppress ignoredReturnValue
     getuid();
     // cppcheck-suppress ignoredReturnValue
     access("filename", 1);
+    // no ignoredReturnValue shall be shown for
+    setuid(42);
 }
 
 
@@ -297,7 +1308,7 @@ void uninitvar(int fd)
     char buf[2];
     int decimal, sign;
     double d;
-    void *p;
+    const void *p;
     pthread_mutex_t mutex, mutex1, mutex2, mutex3;
     // cppcheck-suppress uninitvar
     write(x1,"ab",2);
@@ -320,29 +1331,27 @@ void uninitvar(int fd)
     regcomp(&reg, pattern, cflags2);
     regerror(0, &reg, 0, 0);
 #ifndef __CYGWIN__
-    // cppcheck-suppress uninitvar
-    // cppcheck-suppress unreadVariable
-    // cppcheck-suppress ecvtCalled
+    // cppcheck-suppress [uninitvar, unreadVariable, ecvtCalled, constVariablePointer]
     char *buffer = ecvt(d, 11, &decimal, &sign);
 #endif
     // cppcheck-suppress gcvtCalled
     gcvt(3.141, 2, buf);
 
-    char *filename;
-    struct utimbuf *times;
+    const char *filename1, *filename2;
+    const struct utimbuf *times;
     // cppcheck-suppress uninitvar
     // cppcheck-suppress utimeCalled
-    utime(filename, times);
-    struct timeval times1[2];
+    utime(filename1, times);
+    // cppcheck-suppress constVariable
+    struct utimbuf times1[2];
     // cppcheck-suppress uninitvar
     // cppcheck-suppress utimeCalled
-    utime(filename, times1);
+    utime(filename2, times1);
 
     // cppcheck-suppress unreadVariable
     // cppcheck-suppress uninitvar
     int access_ret = access("file", x3);
 
-    // cppcheck-suppress ignoredReturnValue
     // cppcheck-suppress leakReturnValNotUsed
     // cppcheck-suppress uninitvar
     fdopen(x4, "rw");
@@ -378,19 +1387,20 @@ void uninitvar_types(void)
 {
     // cppcheck-suppress unassignedVariable
     blkcnt_t b;
-    // cppcheck-suppress uninitvar
+    // cppcheck-suppress [uninitvar,constStatement]
     b + 1;
 
     struct dirent d;
-    // TODO cppcheck-suppress uninitvar
+    // cppcheck-suppress [uninitvar,constStatement]
     d.d_ino + 1;
 }
 
-void timet_h(struct timespec* ptp1)
+void timet_h(const struct timespec* ptp1)
 {
     clockid_t clk_id1, clk_id2, clk_id3;
+    // cppcheck-suppress constVariablePointer
     struct timespec* ptp;
-    // cppcheck-suppress uninitvar
+    // cppcheck-suppress [uninitvar,valueFlowBailoutIncompleteVar]
     clock_settime(CLOCK_REALTIME, ptp);
     // cppcheck-suppress uninitvar
     clock_settime(clk_id1, ptp);
@@ -398,7 +1408,7 @@ void timet_h(struct timespec* ptp1)
     clock_settime(clk_id2, ptp1);
 
     struct timespec tp;
-    // TODO cppcheck-suppress uninitvar
+    // FIXME cppcheck-suppress uninitvar
     clock_settime(CLOCK_REALTIME, &tp); // #6577 - false negative
     // cppcheck-suppress uninitvar
     clock_settime(clk_id3, &tp);
@@ -416,21 +1426,21 @@ void dl(const char* libname, const char* func)
     // cppcheck-suppress resourceLeak
     lib = dlopen(libname, RTLD_LAZY);
     const char* funcname;
-    // cppcheck-suppress uninitvar
-    // cppcheck-suppress unreadVariable
+    // cppcheck-suppress [uninitvar, unreadVariable, constVariablePointer]
     void* sym = dlsym(lib, funcname);
     // cppcheck-suppress ignoredReturnValue
     dlsym(lib, "foo");
+    // cppcheck-suppress unassignedVariable
     void* uninit;
     // cppcheck-suppress uninitvar
     dlclose(uninit);
     // cppcheck-suppress resourceLeak
 }
 
-void asctime_r_test(struct tm * tm, char * bufSizeUnknown)
+void asctime_r_test(const struct tm * tm, char * bufSizeUnknown)
 {
     struct tm tm_uninit_data;
-    struct tm * tm_uninit_pointer;
+    const struct tm * tm_uninit_pointer;
     char bufSize5[5];
     char bufSize25[25];
     char bufSize26[26];
@@ -458,10 +1468,10 @@ void asctime_r_test(struct tm * tm, char * bufSizeUnknown)
     asctime_r(tm, bufSizeUnknown);
 }
 
-void ctime_r_test(time_t * timep, char * bufSizeUnknown)
+void ctime_r_test(const time_t * timep, char * bufSizeUnknown)
 {
     time_t time_t_uninit_data;
-    time_t * time_t_uninit_pointer;
+    const time_t * time_t_uninit_pointer;
     char bufSize5[5];
     char bufSize25[25];
     char bufSize26[26];
@@ -488,3 +1498,13 @@ void ctime_r_test(time_t * timep, char * bufSizeUnknown)
     // cppcheck-suppress ctime_rCalled
     ctime_r(timep, bufSizeUnknown);
 }
+
+void invalidFunctionArg_nice(int inc)
+{
+    // cppcheck-suppress invalidFunctionArg
+    nice(-21);
+    nice(-20);
+    nice(19);
+    // cppcheck-suppress invalidFunctionArg
+    nice(+20);
+}
diff --git a/test/cfg/python.c b/test/cfg/python.c
index 011e140b5f7..165afd4744f 100644
--- a/test/cfg/python.c
+++ b/test/cfg/python.c
@@ -2,7 +2,7 @@
 // Test library configuration for python.cfg
 //
 // Usage:
-// $ cppcheck --check-library --library=python --enable=information --error-exitcode=1 --inline-suppr --suppress=missingIncludeSystem test/cfg/python.c
+// $ cppcheck --check-library --library=python --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/python.c
 // =>
 // No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
 //
@@ -10,6 +10,7 @@
 #define PY_SSIZE_T_CLEAN
 #include <Python.h> // should be the first include
 #include <stdio.h>
+#include <stdlib.h>
 
 void validCode(PyObject * pPyObjArg)
 {
@@ -25,8 +26,10 @@ void validCode(PyObject * pPyObjArg)
     Py_CLEAR(pPyObjNULL);
     (void)PyErr_NewException("text", NULL, NULL);
 
+    // cppcheck-suppress unusedAllocatedMemory
     char * pBuf1 = PyMem_Malloc(5);
     PyMem_Free(pBuf1);
+    // cppcheck-suppress unusedAllocatedMemory
     int * pIntBuf1 = PyMem_New(int, 10);
     PyMem_Free(pIntBuf1);
 }
@@ -41,13 +44,14 @@ void nullPointer()
 
 void PyMem_Malloc_memleak()
 {
-    char * pBuf1 = PyMem_Malloc(1);
+    const char * pBuf1 = PyMem_Malloc(1);
     printf("%p", pBuf1);
     // cppcheck-suppress memleak
 }
 
 void PyMem_Malloc_mismatchAllocDealloc()
 {
+    // cppcheck-suppress unusedAllocatedMemory
     char * pBuf1 = PyMem_Malloc(10);
     // cppcheck-suppress mismatchAllocDealloc
     free(pBuf1);
@@ -55,7 +59,7 @@ void PyMem_Malloc_mismatchAllocDealloc()
 
 void PyMem_New_memleak()
 {
-    char * pBuf1 = PyMem_New(char, 5);
+    const char * pBuf1 = PyMem_New(char, 5);
     printf("%p", pBuf1);
     // cppcheck-suppress memleak
 }
diff --git a/test/cfg/qt.cpp b/test/cfg/qt.cpp
index d0fea0779ed..4c6c881b752 100644
--- a/test/cfg/qt.cpp
+++ b/test/cfg/qt.cpp
@@ -2,24 +2,192 @@
 // Test library configuration for qt.cfg
 //
 // Usage:
-// $ cppcheck --check-library --enable=information --inconclusive --error-exitcode=1 --suppress=missingIncludeSystem --inline-suppr --library=qt test/cfg/qt.cpp
+// $ cppcheck --check-library --library=qt --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/qt.cpp
 // =>
 // No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
 //
 
+// cppcheck-suppress-file valueFlowBailout
+
 #include <QObject>
 #include <QString>
 #include <QVector>
 #include <QStack>
 #include <QByteArray>
 #include <QList>
-#include <QLinkedList>
+#include <QMap>
+#include <QMultiMap>
+#include <QQueue>
+#include <QSet>
 #include <QtPlugin>
 #include <QFile>
-#include <cstdio>
 #include <QCoreApplication>
 #include <QLoggingCategory>
+#include <QTest>
+#include <QRect>
+#include <QRectF>
+#include <QSize>
+#include <QSizeF>
+#include <QPoint>
+#include <QPointF>
+#include <QRegion>
+#include <QTransform>
+#include <QDir>
+
+// TODO: this is actually avilable via Core5Compat but I could not get it to work with pkg-config
+#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
+#include <QLinkedList>
+#endif
+
+#include <cstdio>
+
+int ignoredReturnValue_QSize_height(const QSize &s)
+{
+    // cppcheck-suppress ignoredReturnValue
+    s.height();
+    return s.height();
+}
+
+int ignoredReturnValue_QSize_width(const QSize &s)
+{
+    // cppcheck-suppress ignoredReturnValue
+    s.width();
+    return s.width();
+}
+
+
+void ignoredReturnValue_QDir(const QString& dirname)
+{
+    QDir dir(dirname);
+
+    // cppcheck-suppress ignoredReturnValue
+    dir.exists("abc");
 
+    // cppcheck-suppress ignoredReturnErrorCode
+    dir.mkdir("abc");
+
+    // cppcheck-suppress ignoredReturnValue
+    dir.count();
+
+    // cppcheck-suppress ignoredReturnValue
+    dir.filePath("abc");
+
+    // cppcheck-suppress ignoredReturnValue
+    dir.entryList();
+}
+
+
+void unusedVariable_QTransform()
+{
+    // cppcheck-suppress unusedVariable
+    QTransform a;
+}
+
+void unreadVariable_QRegion(const int x, const QRegion::RegionType type, const QPolygon &polygon, const QBitmap &bm, const QRegion &region, const Qt::FillRule fillRule)
+{
+    // cppcheck-suppress unusedVariable
+    QRegion a;
+    // cppcheck-suppress unreadVariable
+    QRegion b{};
+    // cppcheck-suppress unreadVariable
+    QRegion c{x,x,x,x};
+    // cppcheck-suppress unreadVariable
+    QRegion d{x,x,x,x, type};
+    // cppcheck-suppress unreadVariable
+    QRegion e{polygon, fillRule};
+    // cppcheck-suppress unreadVariable
+    QRegion f{bm};
+    // cppcheck-suppress unreadVariable
+    QRegion g{region};
+}
+
+void unreadVariable_QPoint(const QPoint &s)
+{
+    // cppcheck-suppress unusedVariable
+    QPoint a;
+    // cppcheck-suppress unreadVariable
+    QPoint b{};
+    // cppcheck-suppress unreadVariable
+    QPoint c{4, 2};
+    // cppcheck-suppress unreadVariable
+    QPoint d(4, 2);
+    // cppcheck-suppress unreadVariable
+    QPoint e(s);
+}
+
+void unreadVariable_QPointF(const QPointF &s)
+{
+    // cppcheck-suppress unusedVariable
+    QPointF a;
+    // cppcheck-suppress unreadVariable
+    QPointF b{};
+    // cppcheck-suppress unreadVariable
+    QPointF c{4.2, 4.2};
+    // cppcheck-suppress unreadVariable
+    QPointF d(4.2, 4.2);
+    // cppcheck-suppress unreadVariable
+    QPointF e(s);
+}
+
+void unreadVariable_QSizeF(const QSize &s)
+{
+    // cppcheck-suppress unusedVariable
+    QSizeF a;
+    // cppcheck-suppress unreadVariable
+    QSizeF b{};
+    // cppcheck-suppress unreadVariable
+    QSizeF c{4.2, 4.2};
+    // cppcheck-suppress unreadVariable
+    QSizeF d(4.2, 4.2);
+    // cppcheck-suppress unreadVariable
+    QSizeF e(s);
+}
+
+void unreadVariable_QSize(const QSize &s)
+{
+    // cppcheck-suppress unusedVariable
+    QSize a;
+    // cppcheck-suppress unreadVariable
+    QSize b{};
+    // cppcheck-suppress unreadVariable
+    QSize c{4, 2};
+    // cppcheck-suppress unreadVariable
+    QSize d(4, 2);
+    // cppcheck-suppress unreadVariable
+    QSize e(s);
+}
+
+void unreadVariable_QRect(const QPoint &topLeft, const QSize &size, const QPoint &bottomRight, const int x) {
+    // cppcheck-suppress unusedVariable
+    QRect a;
+    // cppcheck-suppress unreadVariable
+    QRect b{};
+    // cppcheck-suppress unreadVariable
+    QRect c(0, 0, 100, 50);
+    // cppcheck-suppress unreadVariable
+    QRect d(x, x, x, x);
+    // cppcheck-suppress unreadVariable
+    QRect e(topLeft, size);
+    // cppcheck-suppress unreadVariable
+    QRect f(topLeft, bottomRight);
+}
+
+void unreadVariable_QRectF(const QPointF &topLeft, const QSizeF &size, const QPointF &bottomRight, const QRectF &rect, const qreal x) {
+    // cppcheck-suppress unusedVariable
+    QRectF a;
+    // cppcheck-suppress unreadVariable
+    QRectF b{};
+    // cppcheck-suppress unreadVariable
+    QRectF c(0.0, 0.0, 100.0, 50.0);
+    // cppcheck-suppress unreadVariable
+    QRectF d(x, x, x, x);
+    // cppcheck-suppress unreadVariable
+    QRectF e(topLeft, size);
+    // cppcheck-suppress unreadVariable
+    QRectF f(topLeft, bottomRight);
+    // cppcheck-suppress unreadVariable
+    QRectF g(rect);
+}
 
 void QString1(QString s)
 {
@@ -29,10 +197,10 @@ void QString1(QString s)
     }
 }
 
-int QString2()
+bool QString2()
 {
     QString s;
-    // FIXME cppcheck-suppress reademptycontainer
+    // cppcheck-suppress knownConditionTrueFalse
     return s.size();
 }
 
@@ -40,7 +208,7 @@ QString::iterator QString3()
 {
     QString qstring1;
     QString qstring2;
-    // cppcheck-suppress iterators2
+    // cppcheck-suppress mismatchingContainers
     for (QString::iterator it = qstring1.begin(); it != qstring2.end(); ++it)
     {}
 
@@ -49,6 +217,43 @@ QString::iterator QString3()
     return it;
 }
 
+void QString4()
+{
+    // cppcheck-suppress unusedVariable
+    QString qs;
+}
+
+// cppcheck-suppress passedByValue
+bool QString5(QString s) { // #10710
+    return s.isEmpty();
+}
+
+// cppcheck-suppress passedByValue
+QStringList QString6(QString s) {
+    return QStringList{ "*" + s + "*" };
+}
+
+// cppcheck-suppress passedByValue
+bool QString7(QString s, const QString& l) {
+    return l.startsWith(s);
+}
+
+void QString_split(const char* name) { // #12998
+    // cppcheck-suppress valueFlowBailoutIncompleteVar // FIXME
+    QStringList qsl = QString(name).split(';', Qt::SkipEmptyParts);
+    if (qsl.isEmpty()) {}
+}
+
+namespace NTestStd // #12355
+{
+    using namespace std;
+    QString QString_std(QString s)
+    {
+        s.replace("abc", "def");
+        return s;
+    }
+}
+
 void QByteArray1(QByteArray byteArrayArg)
 {
     for (int i = 0; i <= byteArrayArg.size(); ++i) {
@@ -88,15 +293,14 @@ void QList1(QList<int> intListArg)
     QList<QString> qstringList2 = {"one", "two"};
     (void)qstringList2[1];
     qstringList2.clear();
-    // TODO: cppcheck-suppress containerOutOfBounds #9243
+    // cppcheck-suppress containerOutOfBounds
     (void)qstringList2[1];
 
     QList<QString> qstringList3;
     qstringList3 << "one" << "two";
-    // FIXME: The following containerOutOfBounds suppression is wrong #9242
-    // Please remove the suppression as soon as this is fixed
-    // cppcheck-suppress containerOutOfBounds
     (void)qstringList3[1];
+    // FIXME: The following should have a containerOutOfBounds suppression #9242
+    (void)qstringList3[3];
     // cppcheck-suppress ignoredReturnValue
     qstringList3.startsWith("one");
     // cppcheck-suppress ignoredReturnValue
@@ -118,25 +322,38 @@ void QList1(QList<int> intListArg)
     qstringList4.append("a");
     (void)qstringList4[0];
     qstringList4.clear();
-    // TODO: cppcheck-suppress containerOutOfBounds #9243
+    // cppcheck-suppress containerOutOfBounds
     (void)qstringList4[0];
 }
 
+QList<int> QList2() { // #10556
+    QList<int> v;
+
+    for (int i = 0; i < 4; ++i)
+    {
+        v.append(i);
+        (void)v.at(i);
+    }
+    return v;
+}
+
 QList<int>::iterator QList3()
 {
     QList<int> qlist1;
     QList<int> qlist2;
-    // cppcheck-suppress iterators2
+    // cppcheck-suppress mismatchingContainers
     for (QList<int>::iterator it = qlist1.begin(); it != qlist2.end(); ++it)
     {}
 
     QList<int>::iterator it = qlist1.begin();
-    // TODO: cppcheck-suppress returnDanglingLifetime
+    // cppcheck-suppress returnDanglingLifetime
     return it;
 }
 
+#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
 void QLinkedList1()
 {
+    // cppcheck-suppress unreadVariable
     QLinkedList<QString> qstringLinkedList1{"one", "two"};
 
     QLinkedList<QString> qstringLinkedList2 = {"one", "two"};
@@ -162,14 +379,15 @@ QLinkedList<int>::iterator QLinkedList3()
 {
     QLinkedList<int> intQLinkedList1;
     QLinkedList<int> intQLinkedList2;
-    // cppcheck-suppress iterators2
+    // cppcheck-suppress mismatchingContainers
     for (QLinkedList<int>::iterator it = intQLinkedList1.begin(); it != intQLinkedList2.end(); ++it)
     {}
 
     QLinkedList<int>::iterator it = intQLinkedList1.begin();
-    // TODO: cppcheck-suppress returnDanglingLifetime
+    // cppcheck-suppress returnDanglingLifetime
     return it;
 }
+#endif
 
 void QStringList1(QStringList stringlistArg)
 {
@@ -195,10 +413,9 @@ void QStringList1(QStringList stringlistArg)
 
     QStringList qstringlist3;
     qstringlist3 << "one" << "two";
-    // FIXME: The following containerOutOfBounds suppression is wrong #9242
-    // Please remove the suppression as soon as this is fixed
-    // cppcheck-suppress containerOutOfBounds
     (void)qstringlist3[1];
+    // FIXME: The following should have a containerOutOfBounds suppression #9242
+    (void)qstringlist3[3];
     // cppcheck-suppress ignoredReturnValue
     qstringlist3.startsWith("one");
     // cppcheck-suppress ignoredReturnValue
@@ -219,7 +436,7 @@ QStringList::iterator QStringList2()
 {
     QStringList qstringlist1;
     QStringList qstringlist2;
-    // cppcheck-suppress iterators2
+    // cppcheck-suppress mismatchingContainers
     for (QStringList::iterator it = qstringlist1.begin(); it != qstringlist2.end(); ++it)
     {}
 
@@ -249,10 +466,9 @@ void QVector1(QVector<int> intVectorArg)
 
     QVector<QString> qstringVector3;
     qstringVector3 << "one" << "two";
-    // FIXME: The following containerOutOfBounds suppression is wrong #9242
-    // Please remove the suppression as soon as this is fixed
-    // cppcheck-suppress containerOutOfBounds
     (void)qstringVector3[1];
+    // FIXME: The following should have a containerOutOfBounds suppression #9242
+    (void)qstringVector3[3];
     // cppcheck-suppress ignoredReturnValue
     qstringVector3.startsWith("one");
     // cppcheck-suppress ignoredReturnValue
@@ -273,15 +489,30 @@ QVector<int>::iterator QVector2()
 {
     QVector<int> qvector1;
     QVector<int> qvector2;
-    // cppcheck-suppress iterators2
+    // cppcheck-suppress mismatchingContainers
     for (QVector<int>::iterator it = qvector1.begin(); it != qvector2.end(); ++it)
     {}
 
     QVector<int>::iterator it = qvector1.begin();
-    // TODO cppcheck-suppress returnDanglingLifetime
+    // cppcheck-suppress returnDanglingLifetime
     return it;
 }
 
+// cppcheck-suppress passedByValue
+void duplicateExpression_QString_Compare(QString style) //#8723
+{
+    // cppcheck-suppress [duplicateExpression,valueFlowBailoutIncompleteVar]
+    if (style.compare( "x", Qt::CaseInsensitive ) == 0 || style.compare( "x", Qt::CaseInsensitive ) == 0)
+    {}
+}
+
+void QVector_uninit()
+{
+    int i;
+    // cppcheck-suppress [uninitvar, unreadVariable]
+    QVector<int> v(i);
+}
+
 void QStack1(QStack<int> intStackArg)
 {
     for (int i = 0; i <= intStackArg.size(); ++i) {
@@ -302,10 +533,9 @@ void QStack1(QStack<int> intStackArg)
 
     QStack<QString> qstringStack2;
     qstringStack2 << "one" << "two";
-    // FIXME: The following containerOutOfBounds suppression is wrong #9242
-    // Please remove the suppression as soon as this is fixed
-    // cppcheck-suppress containerOutOfBounds
     (void)qstringStack2[1];
+    // FIXME: The following should have a containerOutOfBounds suppression #9242
+    (void)qstringStack2[3];
     // cppcheck-suppress ignoredReturnValue
     qstringStack2.startsWith("one");
     // cppcheck-suppress ignoredReturnValue
@@ -326,12 +556,12 @@ QStack<int>::iterator QStack2()
 {
     QStack<int> qstack1;
     QStack<int> qstack2;
-    // cppcheck-suppress iterators2
+    // cppcheck-suppress mismatchingContainers
     for (QStack<int>::iterator it = qstack1.begin(); it != qstack2.end(); ++it)
     {}
 
     QStack<int>::iterator it = qstack1.begin();
-    // TODO cppcheck-suppress returnDanglingLifetime
+    // cppcheck-suppress returnDanglingLifetime
     return it;
 }
 
@@ -345,7 +575,7 @@ void QStack3()
 }
 
 // Verify that Qt macros do not result in syntax errors, false positives or other issues.
-class MacroTest1: public QObject {
+class MacroTest1 : public QObject {
     Q_OBJECT
     Q_PLUGIN_METADATA(IID "com.foo.bar" FILE "test.json")
 
@@ -364,25 +594,31 @@ class MacroTest2 {
 
 void MacroTest2_test()
 {
-    // TODO: remove suppression when #9002 is fixed
-    // cppcheck-suppress checkLibraryFunction
     QString str = MacroTest2::tr("hello");
     QByteArray ba = str.toLatin1();
     printf(ba.data());
 
+#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
 #ifndef QT_NO_DEPRECATED
-    // TODO: remove suppression when #9002 is fixed
-    // cppcheck-suppress checkLibraryFunction
     str = MacroTest2::trUtf8("test2");
     ba = str.toLatin1();
     printf(ba.data());
 #endif
+#endif
 }
 
-void validCode(int * pIntPtr)
+void MacroTest3()
 {
-    if (QFile::exists("test")) {
-    }
+    QByteArray message = QByteArrayLiteral("Test1");
+    message += QByteArrayLiteral("Test2");
+    QVERIFY2(2 >= 0, message.constData());
+}
+
+// cppcheck-suppress constParameterReference
+void validCode(int * pIntPtr, QString & qstrArg, double d)
+{
+    Q_UNUSED(d)
+    if (QFile::exists("test")) {}
 
     if (pIntPtr != Q_NULLPTR) {
         *pIntPtr = 5;
@@ -392,8 +628,7 @@ void validCode(int * pIntPtr)
         forever {
         }
     } else if (pIntPtr && *pIntPtr == 2) {
-        Q_FOREVER {
-        }
+        Q_FOREVER {}
     }
 
     if (Q_LIKELY(pIntPtr)) {}
@@ -401,9 +636,21 @@ void validCode(int * pIntPtr)
 
     printf(QT_TR_NOOP("Hi"));
 
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
     Q_DECLARE_LOGGING_CATEGORY(logging_category_test);
     QT_FORWARD_DECLARE_CLASS(forwardDeclaredClass);
     QT_FORWARD_DECLARE_STRUCT(forwardDeclaredStruct);
+
+    //#9650
+    QString qstr1(qstrArg);
+    if (qstr1.length() == 1) {} else {
+        qstr1.chop(1);
+        if (qstr1.length() == 1) {}
+    }
+    if (qstr1.length() == 1) {} else {
+        qstr1.remove(1, 0);
+        if (qstr1.length() == 1) {}
+    }
 }
 
 void ignoredReturnValue()
@@ -428,3 +675,213 @@ void nullPointer(int * pIntPtr)
         *pIntPtr = 3;
     }
 }
+
+namespace {
+    class C : public QObject {
+        Q_OBJECT
+    public:
+        explicit C(QObject* parent = nullptr) : QObject(parent) {}
+        void signal() {}
+    };
+    class D : public QObject {
+        Q_OBJECT
+    public:
+        D() {
+            connect(new C(this), &C::signal, this, &D::slot);
+        }
+        void slot() {};
+    };
+
+    // findFunction11
+    class Fred : public QObject {
+        Q_OBJECT
+    private slots:
+        void foo();
+    };
+    // cppcheck-suppress functionStatic
+    void Fred::foo() {}
+
+    // bitfields14
+    class X {
+    signals:
+    };
+
+    // simplifyQtSignalsSlots1
+    class Counter1 : public QObject {
+        Q_OBJECT
+    public:
+        Counter1() {
+            m_value = 0;
+        }
+        int value() const {
+            return m_value;
+        }
+    public slots:
+        void setValue(int value);
+    signals:
+        void valueChanged(int newValue);
+    private:
+        int m_value;
+    };
+    void Counter1::setValue(int value) {
+        if (value != m_value) {
+            m_value = value;
+            emit valueChanged(value);
+        }
+    }
+
+    class Counter2 : public QObject {
+        Q_OBJECT
+    public:
+        Counter2() {
+            m_value = 0;
+        }
+        int value() const {
+            return m_value;
+        }
+    public Q_SLOTS:
+        void setValue(int value);
+    Q_SIGNALS:
+        void valueChanged(int newValue);
+    private:
+        int m_value;
+    };
+    void Counter2::setValue(int value) {
+        if (value != m_value) {
+            m_value = value;
+            emit valueChanged(value);
+        }
+    }
+
+    class MyObject1 : public QObject {
+        MyObject1() {}
+        ~MyObject1() {}
+    public slots:
+    signals:
+        // cppcheck-suppress functionStatic
+        void test() {}
+    };
+
+    class MyObject2 : public QObject {
+        Q_OBJECT
+    public slots:
+    };
+
+    // simplifyQtSignalsSlots2
+    namespace Foo { class Bar; }
+    class Foo::Bar : public QObject { private slots: };
+
+    // Q_PROPERTY with templates inducing a ',' should not produce a preprocessorErrorDirective
+    class AssocProperty : public QObject {
+    public:
+        Q_PROPERTY(QHash<QString, int> hash READ hash WRITE setHash)
+    };
+}
+
+struct SEstimateSize {
+    inline const QString& get() const {
+        return m;
+    }
+    QString m;
+};
+
+class QString;
+
+void dontCrashEstimateSize(const SEstimateSize& s) {
+    // cppcheck-suppress redundantCopyLocalConst
+    QString q = s.get();
+    if (!q.isNull()) {}
+}
+
+bool knownConditionTrueFalse_QString_count(const QString& s) // #11036
+{
+    if (!s.isEmpty() && s.count("abc") == 0)
+        return false;
+    return true;
+}
+
+void unusedVariable_qtContainers() // #10689
+{
+    // cppcheck-suppress unusedVariable
+    QMap<int, int> qm;
+    // cppcheck-suppress unusedVariable
+    QSet<int> qs;
+    // cppcheck-suppress unusedVariable
+    QMultiMap<int, int> qmm;
+    // cppcheck-suppress unusedVariable
+    QQueue<int> qq;
+    // cppcheck-suppress unusedVariable
+    QLatin1String ql1s;
+}
+
+void unreadVariable_QMapIterator(QMap<QString, QObject*>& m)
+{
+    auto it = m.find("abc"); // #12662
+    if (it != m.end()) {
+        // cppcheck-suppress checkLibraryFunction // TODO
+        delete it.value();
+        // cppcheck-suppress checkLibraryFunction
+        it.value() = new QObject();
+    }
+}
+
+void constVariablePointer_QVector(QVector<int*>& qv, int* p)
+{
+    qv.push_back(p); // #12661
+}
+
+void constParameterPointer_QHash_insert(QHash<int*, int*>& qh, int* k, int* v)
+{
+    qh.insert(k, v); // #13902
+}
+
+bool constParameterPointer_QHash_find(const QHash<int*, int*>& qh, int* k)
+{
+    auto it = qh.find(k);
+    return it != qh.end();
+}
+
+bool constParameterPointer_QHash_contains(const QHash<int*, int*>& qh, int* k)
+{
+    return qh.contains(k);
+}
+
+int constParameterPointer_QHash_count(const QHash<int*, int*>& qh, int* k)
+{
+    return qh.count(k);
+}
+
+const QString& unassignedVariable_static_QString() // #12935
+{
+    static QString qs;
+    return qs;
+}
+
+struct BQObject_missingOverride { // #13406
+    Q_OBJECT
+};
+
+struct DQObject_missingOverride : BQObject_missingOverride {
+    Q_OBJECT
+};
+
+namespace {
+    class TestUnusedFunction : public QObject { // #13236
+        TestUnusedFunction();
+        void doStuff();
+    };
+
+    TestUnusedFunction::TestUnusedFunction() {
+        QObject::connect(this, SIGNAL(doStuff()), SLOT(doStuff()));
+    }
+
+    // cppcheck-suppress functionStatic
+    void TestUnusedFunction::doStuff() {} // Should not warn here with unusedFunction
+}
+
+int qdateIsValid()
+{
+    QDate qd(1,1,2025);
+    Q_ASSERT(qd.isValid()); // Should not warn here with assertWithSideEffect
+    return qd.month(); 
+}
diff --git a/test/cfg/runtests.sh b/test/cfg/runtests.sh
index b487c734df8..c8c1515e66c 100755
--- a/test/cfg/runtests.sh
+++ b/test/cfg/runtests.sh
@@ -2,303 +2,661 @@
 set -e # abort on error
 #set -x # be verbose
 
-if [[ $(pwd) == */test/cfg ]] ; then # we are in test/cfg
-	CPPCHECK="../../cppcheck"
-	DIR=""
-	CFG="../../cfg/"
-else # assume we are in repo root
-	CPPCHECK="./cppcheck"
-	DIR=test/cfg/
-	CFG="cfg/"
+# TODO: do not bail out on first error - always run all tests and return error instead
+
+function exit_if_strict {
+    if [ -n "${STRICT}" ] && [ "${STRICT}" -eq 1 ]; then
+      exit 1
+    fi
+}
+
+echo "Checking for pkg-config..."
+if pkg-config --version; then
+  HAS_PKG_CONFIG=1
+  echo "pkg-config found."
+else
+  HAS_PKG_CONFIG=0
+  echo "pkg-config is not available, skipping all syntax checks."
+  exit_if_strict
 fi
 
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"/
+CPPCHECK="$DIR"../../cppcheck
+CFG="$DIR"../../cfg/
+
+# TODO: remove missingInclude disabling when it no longer is implied by --enable=information
 # Cppcheck options
-CPPCHECK_OPT='--check-library --enable=information --enable=style --error-exitcode=-1 --suppress=missingIncludeSystem --inline-suppr --template="{file}:{line}:{severity}:{id}:{message}"'
+# need to suppress unmatchedSuppression in case valueFlowBailout is not reported
+CPPCHECK_OPT=(
+    "--check-library"
+    "--platform=unix64"
+    "--enable=style,information"
+    "--inconclusive"
+    "--force"
+    "--check-level=exhaustive"
+    "--error-exitcode=-1"
+    "--inline-suppr"
+    "--template=\"{file}:{line}:{severity}:{id}:{message}\""
+    "--debug-warnings"
+    "--suppress=checkersReport")
 
 # Compiler settings
 CXX=g++
-CXX_OPT='-fsyntax-only -std=c++0x -Wno-format -Wno-format-security'
+CXX_OPT=("-fsyntax-only" "-w" "-std=c++2a")
 CC=gcc
-CC_OPT='-Wno-format -Wno-nonnull -Wno-implicit-function-declaration -Wno-deprecated-declarations -Wno-format-security -Wno-nonnull -fsyntax-only'
+CC_OPT=("-fsyntax-only" "-w" "-std=c11")
+
+IWYU_OPTS=("-Xiwyu" "--no_fwd_decls" "-Xiwyu" "--update_comments")
+
+function get_pkg_config_cflags {
+    # TODO: get rid of the error enabling/disabling?
+    set +e
+    PKGCONFIG=$(pkg-config --cflags "$@")
+    PKGCONFIG_RETURNCODE=$?
+    set -e
+    if [ $PKGCONFIG_RETURNCODE -ne 0 ]; then
+        PKGCONFIG=
+    else
+        # make sure the config is not empty when no flags were found - happens with e.g. libssl and sqlite3
+        if [ -z "$PKGCONFIG" ]; then
+            PKGCONFIG=" "
+        fi
+    fi
+    echo "$PKGCONFIG"
+}
+
+function iwyu_run {
+    # TODO: convert -I includes provided by pkg-config to -isystem so IWYU does not produce warnings for system headers
+    ${IWYU} "${IWYU_OPTS[@]}" "${IWYU_CLANG_INC}" "$@"
+}
+
+function cc_syntax {
+    if [ -z "$IWYU" ]; then
+        ${CC} "${CC_OPT[@]}" "$@"
+    else
+        iwyu_run "${CC_OPT[@]}" "$@"
+    fi
+}
+
+function cxx_syntax {
+    if [ -z "$IWYU" ]; then
+        ${CXX} "${CXX_OPT[@]}" "$@"
+    else
+        iwyu_run "${CXX_OPT[@]}" "$@"
+    fi
+}
+
+function cppcheck_run {
+    if [ -z "$IWYU" ]; then
+        "${CPPCHECK}" "${CPPCHECK_OPT[@]}" "$@"
+    fi
+}
 
 # posix.c
-${CC} ${CC_OPT} ${DIR}posix.c
-${CPPCHECK} ${CPPCHECK_OPT} --library=posix  ${DIR}posix.c
+function posix_fn {
+    echo "POSIX assumed to be present, checking syntax with ${CC} now."
+    cc_syntax ${DIR}posix.c
+}
 
 # gnu.c
-${CC} ${CC_OPT} -D_GNU_SOURCE ${DIR}gnu.c
-${CPPCHECK} ${CPPCHECK_OPT} --library=posix,gnu ${DIR}gnu.c
+function gnu_fn {
+    echo "GNU assumed to be present, checking syntax with ${CC} now."
+    cc_syntax ${DIR}gnu.c
+}
 
 # qt.cpp
-set +e
-pkg-config --version
-PKGCONFIG_RETURNCODE=$?
-set -e
-if [ $PKGCONFIG_RETURNCODE -ne 0 ]; then
-    echo "pkg-config needed to retrieve Qt configuration is not available, skipping syntax check."
-else
-    set +e
-    QTCONFIG=$(pkg-config --cflags Qt5Core)
-    QTCONFIG_RETURNCODE=$?
-    set -e
-    if [ $QTCONFIG_RETURNCODE -eq 0 ]; then
-        QTBUILDCONFIG=$(pkg-config --variable=qt_config Qt5Core)
-        [[ $QTBUILDCONFIG =~ (^|[[:space:]])reduce_relocations($|[[:space:]]) ]] && QTCONFIG="${QTCONFIG} -fPIC"
-        set +e
-        echo -e "#include <QString>" | ${CXX} ${CXX_OPT} ${QTCONFIG} -x c++ -
-        QTCHECK_RETURNCODE=$?
-        set -e
-        if [ $QTCHECK_RETURNCODE -ne 0 ]; then
-            echo "Qt not completely present or not working, skipping syntax check with ${CXX}."
+function qt_fn {
+    if [ $HAS_PKG_CONFIG -eq 1 ]; then
+        # TODO: check syntax with Qt5 and Qt6?
+        QTCONFIG=$(get_pkg_config_cflags Qt6Core Qt6Test Qt6Gui)
+        if [ -z "$QTCONFIG" ]; then
+          QTCONFIG=$(get_pkg_config_cflags Qt5Core Qt5Test Qt5Gui)
+          if [ -n "$QTCONFIG" ]; then
+            QTBUILDCONFIG=$(pkg-config --variable=qt_config Qt5Core Qt5Test Qt5Gui)
+            [[ $QTBUILDCONFIG =~ (^|[[:space:]])reduce_relocations($|[[:space:]]) ]] && QTCONFIG="${QTCONFIG} -fPIC"
+          fi
         else
-            echo "Qt found and working, checking syntax with ${CXX} now."
-            ${CXX} ${CXX_OPT} ${QTCONFIG} ${DIR}qt.cpp
+          QTBUILDCONFIG=$(pkg-config --variable=qt_config Qt6Core Qt6Test Qt6Gui)
+          QTCONFIG="${QTCONFIG} -fPIC"
+        fi
+        if [ -n "$QTCONFIG" ]; then
+            # TODO: get rid of the error enabling/disabling?
+            set +e
+            echo -e "#include <QString>" | ${CXX} "${CXX_OPT[@]}" ${QTCONFIG} -x c++ -
+            QTCHECK_RETURNCODE=$?
+            set -e
+            if [ $QTCHECK_RETURNCODE -ne 0 ]; then
+                echo "Qt not completely present or not working, skipping syntax check with ${CXX}."
+                exit_if_strict
+            else
+                echo "Qt found and working, checking syntax with ${CXX} now."
+                cxx_syntax ${QTCONFIG} ${DIR}qt.cpp
+            fi
+        else
+            echo "Qt not present, skipping syntax check with ${CXX}."
+            exit_if_strict
         fi
     fi
-fi
-${CPPCHECK} ${CPPCHECK_OPT} --inconclusive --library=qt ${DIR}qt.cpp
+}
 
 # bsd.c
-${CPPCHECK} ${CPPCHECK_OPT} --library=bsd ${DIR}bsd.c
+function bsd_fn {
+    # TODO: add syntax check
+    true
+}
 
 # std.c
-${CC} ${CC_OPT} ${DIR}std.c
-${CPPCHECK} ${CPPCHECK_OPT} --inconclusive ${DIR}std.c
-${CXX} ${CXX_OPT} ${DIR}std.cpp
-${CPPCHECK} ${CPPCHECK_OPT} --inconclusive ${DIR}std.cpp
+function std_c_fn {
+    echo "C standard library assumed to be present, checking syntax with ${CC} now."
+    cc_syntax "${DIR}"std.c
+}
+
+# std.cpp
+function std_cpp_fn {
+    echo "C++ standard library assumed to be present, checking syntax with ${CXX} now."
+    cxx_syntax "${DIR}"std.cpp
+}
 
 # windows.cpp
-# Syntax check via g++ does not work because it can not find a valid windows.h
-#${CXX} ${CXX_OPT} ${DIR}windows.cpp
-${CPPCHECK} ${CPPCHECK_OPT} --inconclusive --platform=win32A  ${DIR}windows.cpp
-${CPPCHECK} ${CPPCHECK_OPT} --inconclusive --platform=win32W  ${DIR}windows.cpp
-${CPPCHECK} ${CPPCHECK_OPT} --inconclusive --platform=win64  ${DIR}windows.cpp
+function windows_fn {
+    # TODO: Syntax check via g++ does not work because it can not find a valid windows.h
+    #cxx_syntax ${DIR}windows.cpp
+    true
+}
+
+# mfc.cpp
+function mfc_fn {
+    # TODO: Add syntax check
+    true
+}
 
 # wxwidgets.cpp
-set +e
-WXCONFIG=$(wx-config --cxxflags)
-WXCONFIG_RETURNCODE=$?
-set -e
-if [ $WXCONFIG_RETURNCODE -ne 0 ]; then
-    echo "wx-config does not work, skipping syntax check for wxWidgets tests."
-else
+function wxwidgets_fn {
+    # TODO: get rid of the error enabling/disabling?
     set +e
-    echo -e "#include <wx/filefn.h>\n#include <wx/app.h>\n#include <wx/artprov.h>\n#include <wx/version.h>\n#if wxVERSION_NUMBER<2950\n#error \"Old version\"\n#endif" | ${CXX} ${CXX_OPT} ${WXCONFIG} -x c++ -
-    WXCHECK_RETURNCODE=$?
+    WXCONFIG=$(wx-config --cxxflags)
+    WXCONFIG_RETURNCODE=$?
     set -e
-    if [ $WXCHECK_RETURNCODE -ne 0 ]; then
-        echo "wxWidgets not completely present (with GUI classes) or not working, skipping syntax check with ${CXX}."
+    if [ $WXCONFIG_RETURNCODE -ne 0 ]; then
+        echo "wx-config does not work, skipping syntax check for wxWidgets tests."
+        exit_if_strict
     else
-        echo "wxWidgets found, checking syntax with ${CXX} now."
-        ${CXX} ${CXX_OPT} ${WXCONFIG} -Wno-deprecated-declarations ${DIR}wxwidgets.cpp
-    fi
-fi
-${CPPCHECK} ${CPPCHECK_OPT} --inconclusive --library=wxwidgets -f ${DIR}wxwidgets.cpp
-
-# gtk.c
-set +e
-pkg-config --version
-PKGCONFIG_RETURNCODE=$?
-set -e
-if [ $PKGCONFIG_RETURNCODE -ne 0 ]; then
-    echo "pkg-config needed to retrieve GTK+ configuration is not available, skipping syntax check."
-else
-    set +e
-    GTKCONFIG=$(pkg-config --cflags gtk+-3.0)
-    GTKCONFIG_RETURNCODE=$?
-    set -e
-    if [ $GTKCONFIG_RETURNCODE -ne 0 ]; then
+        # TODO: get rid of the error enabling/disabling?
         set +e
-        GTKCONFIG=$(pkg-config --cflags gtk+-2.0)
-        GTKCONFIG_RETURNCODE=$?
+        echo -e "#include <wx/filefn.h>\n#include <wx/app.h>\n#include <wx/artprov.h>\n#include <wx/version.h>\n#if wxVERSION_NUMBER<2950\n#error \"Old version\"\n#endif" | ${CXX} "${CXX_OPT[@]}"  ${WXCONFIG} -x c++ -
+        WXCHECK_RETURNCODE=$?
         set -e
+        if [ $WXCHECK_RETURNCODE -ne 0 ]; then
+            echo "wxWidgets not completely present (with GUI classes) or not working, skipping syntax check with ${CXX}."
+            exit_if_strict
+        else
+            echo "wxWidgets found, checking syntax with ${CXX} now."
+            cxx_syntax ${WXCONFIG} -Wno-deprecated-declarations "${DIR}"wxwidgets.cpp
+        fi
     fi
-    if [ $GTKCONFIG_RETURNCODE -eq 0 ]; then
-        set +e
-        echo -e "#include <gtk/gtk.h>" | ${CC} ${CC_OPT} ${GTKCONFIG} -x c -
-        GTKCHECK_RETURNCODE=$?
-        set -e
-        if [ $GTKCHECK_RETURNCODE -ne 0 ]; then
-            echo "GTK+ not completely present or not working, skipping syntax check with ${CXX}."
+}
+
+# gtk.c
+function gtk_fn {
+    if [ $HAS_PKG_CONFIG -eq 1 ]; then
+        GTKCONFIG=$(get_pkg_config_cflags gtk+-3.0)
+        if [ -z "$GTKCONFIG" ]; then
+            GTKCONFIG=$(get_pkg_config_cflags gtk+-2.0)
+        fi
+        if [ -n "$GTKCONFIG" ]; then
+            # TODO: get rid of the error enabling/disabling?
+            set +e
+            echo -e "#include <gtk/gtk.h>" | ${CC} "${CC_OPT[@]}" ${GTKCONFIG} -x c -
+            GTKCHECK_RETURNCODE=$?
+            set -e
+            if [ $GTKCHECK_RETURNCODE -ne 0 ]; then
+                echo "GTK+ not completely present or not working, skipping syntax check with ${CC}."
+                exit_if_strict
+            else
+                echo "GTK+ found and working, checking syntax with ${CC} now."
+                cc_syntax ${GTKCONFIG} "${DIR}"gtk.c
+            fi
         else
-            echo "GTK+ found and working, checking syntax with ${CXX} now."
-            ${CC} ${CC_OPT} ${GTKCONFIG} ${DIR}gtk.c
+            echo "GTK+ not present, skipping syntax check with ${CC}."
+            exit_if_strict
         fi
     fi
-fi
-${CPPCHECK} ${CPPCHECK_OPT} --inconclusive --library=gtk -f ${DIR}gtk.c
+}
 
 # boost.cpp
-set +e
-echo -e "#include <boost/config.hpp>" | ${CXX} ${CXX_OPT} -x c++ -
-BOOSTCHECK_RETURNCODE=$?
-set -e
-if [ ${BOOSTCHECK_RETURNCODE} -ne 0 ]; then
-    echo "Boost not completely present or not working, skipping syntax check with ${CXX}."
-else
-    echo "Boost found and working, checking syntax with ${CXX} now."
-    ${CXX} ${CXX_OPT} ${DIR}boost.cpp
-fi
-${CPPCHECK} ${CPPCHECK_OPT} --inconclusive --library=boost ${DIR}boost.cpp
-
-# sqlite3.c
-set +e
-pkg-config --version
-PKGCONFIG_RETURNCODE=$?
-set -e
-if [ $PKGCONFIG_RETURNCODE -ne 0 ]; then
-    echo "pkg-config needed to retrieve SQLite3 configuration is not available, skipping syntax check."
-else
+function boost_fn {
+    # TODO: get rid of the error enabling/disabling?
     set +e
-    SQLITE3CONFIG=$(pkg-config --cflags sqlite3)
-    SQLITE3CONFIG_RETURNCODE=$?
+    echo -e "#include <boost/config.hpp>" | ${CXX} "${CXX_OPT[@]}" -x c++ -
+    BOOSTCHECK_RETURNCODE=$?
     set -e
-    if [ $SQLITE3CONFIG_RETURNCODE -eq 0 ]; then
-        set +e
-        echo -e "#include <sqlite3.h>" | ${CC} ${CC_OPT} ${SQLITE3CONFIG} -x c -
-        SQLITE3CHECK_RETURNCODE=$?
-        set -e
-        if [ $SQLITE3CHECK_RETURNCODE -ne 0 ]; then
-            echo "SQLite3 not completely present or not working, skipping syntax check with ${CC}."
+    if [ ${BOOSTCHECK_RETURNCODE} -ne 0 ]; then
+        echo "Boost not completely present or not working, skipping syntax check with ${CXX}."
+        exit_if_strict
+    else
+        echo "Boost found and working, checking syntax with ${CXX} now."
+        cxx_syntax "${DIR}"boost.cpp
+    fi
+}
+
+# sqlite3.c
+function sqlite3_fn {
+    if [ $HAS_PKG_CONFIG -eq 1 ]; then
+        SQLITE3CONFIG=$(get_pkg_config_cflags sqlite3)
+        if [ -n "$SQLITE3CONFIG" ]; then
+            # TODO: get rid of the error enabling/disabling?
+            set +e
+            echo -e "#include <sqlite3.h>" | ${CC} "${CC_OPT[@]}" ${SQLITE3CONFIG} -x c -
+            SQLITE3CHECK_RETURNCODE=$?
+            set -e
+            if [ $SQLITE3CHECK_RETURNCODE -ne 0 ]; then
+                echo "SQLite3 not completely present or not working, skipping syntax check with ${CC}."
+                exit_if_strict
+            else
+                echo "SQLite3 found and working, checking syntax with ${CC} now."
+                cc_syntax ${SQLITE3CONFIG} "${DIR}"sqlite3.c
+            fi
         else
-            echo "SQLite3 found and working, checking syntax with ${CC} now."
-            ${CC} ${CC_OPT} ${SQLITE3CONFIG} ${DIR}sqlite3.c
+            echo "SQLite3 not present, skipping syntax check with ${CC}."
+            exit_if_strict
         fi
     fi
-fi
-${CPPCHECK} ${CPPCHECK_OPT} --inconclusive --library=sqlite3 ${DIR}sqlite3.c
+}
 
 # openmp.c
-${CC} ${CC_OPT} -fopenmp ${DIR}openmp.c
-${CPPCHECK} ${CPPCHECK_OPT} --library=openmp ${DIR}openmp.c
+function openmp_fn {
+    # TODO: omp.h not found with IWYU
+    # MacOS compiler has no OpenMP by default
+    if ! command -v sw_vers; then
+      echo "OpenMP assumed to be present, checking syntax with ${CC} now."
+      cc_syntax -fopenmp ${DIR}openmp.c
+    fi
+}
 
 # python.c
-set +e
-pkg-config --version
-PKGCONFIG_RETURNCODE=$?
-set -e
-if [ $PKGCONFIG_RETURNCODE -ne 0 ]; then
-    echo "pkg-config needed to retrieve Python 3 configuration is not available, skipping syntax check."
-else
-    set +e
-    PYTHON3CONFIG=$(pkg-config --cflags python3)
-    PYTHON3CONFIG_RETURNCODE=$?
-    set -e
-    if [ $PYTHON3CONFIG_RETURNCODE -eq 0 ]; then
-        set +e
-        echo -e "#include <Python.h>" | ${CC} ${CC_OPT} ${PYTHON3CONFIG} -x c -
-        PYTHON3CONFIG_RETURNCODE=$?
-        set -e
-        if [ $PYTHON3CONFIG_RETURNCODE -ne 0 ]; then
-            echo "Python 3 not completely present or not working, skipping syntax check with ${CC}."
+function python_fn {
+    if [ $HAS_PKG_CONFIG -eq 1 ]; then
+        PYTHON3CONFIG=$(get_pkg_config_cflags python3)
+        if [ -n "$PYTHON3CONFIG" ]; then
+            # TODO: get rid of the error enabling/disabling?
+            set +e
+            echo -e "#include <Python.h>" | ${CC} "${CC_OPT[@]}" ${PYTHON3CONFIG} -x c -
+            PYTHON3CONFIG_RETURNCODE=$?
+            set -e
+            if [ $PYTHON3CONFIG_RETURNCODE -ne 0 ]; then
+                echo "Python 3 not completely present or not working, skipping syntax check with ${CC}."
+                exit_if_strict
+            else
+                echo "Python 3 found and working, checking syntax with ${CC} now."
+                cc_syntax ${PYTHON3CONFIG} "${DIR}"python.c
+            fi
         else
-            echo "Python 3 found and working, checking syntax with ${CC} now."
-            ${CC} ${CC_OPT} ${PYTHON3CONFIG} ${DIR}python.c
+            echo "Python 3 not present, skipping syntax check with ${CC}."
+            exit_if_strict
         fi
     fi
-fi
-${CPPCHECK} ${CPPCHECK_OPT} --library=python ${DIR}python.c
+}
 
 # lua.c
-set +e
-pkg-config --version
-PKGCONFIG_RETURNCODE=$?
-set -e
-if [ $PKGCONFIG_RETURNCODE -ne 0 ]; then
-    echo "pkg-config needed to retrieve Lua configuration is not available, skipping syntax check."
-else
-    set +e
-    LUACONFIG=$(pkg-config --cflags lua-5.3)
-    LUACONFIG_RETURNCODE=$?
-    set -e
-    if [ $LUACONFIG_RETURNCODE -eq 0 ]; then
-        set +e
-        echo -e "#include <lua.h>" | ${CC} ${CC_OPT} ${LUACONFIG} -x c -
-        LUACONFIG_RETURNCODE=$?
-        set -e
-        if [ $LUACONFIG_RETURNCODE -ne 0 ]; then
-            echo "Lua not completely present or not working, skipping syntax check with ${CC}."
+function lua_fn {
+    if [ $HAS_PKG_CONFIG -eq 1 ]; then
+        LUACONFIG=$(get_pkg_config_cflags lua)
+        if [ -z "$LUACONFIG" ]; then
+            LUACONFIG=$(get_pkg_config_cflags lua-5.3)
+        fi
+        if [ -n "$LUACONFIG" ]; then
+            # TODO: get rid of the error enabling/disabling?
+            set +e
+            echo -e "#include <lua.h>" | ${CC} "${CC_OPT[@]}" ${LUACONFIG} -x c -
+            LUACONFIG_RETURNCODE=$?
+            set -e
+            if [ $LUACONFIG_RETURNCODE -ne 0 ]; then
+                echo "Lua not completely present or not working, skipping syntax check with ${CC}."
+                exit_if_strict
+            else
+                echo "Lua found and working, checking syntax with ${CC} now."
+                cc_syntax ${LUACONFIG} "${DIR}"lua.c
+            fi
         else
-            echo "Lua found and working, checking syntax with ${CC} now."
-            ${CC} ${CC_OPT} ${LUACONFIG} ${DIR}lua.c
+            echo "Lua not present, skipping syntax check with ${CC}."
+            exit_if_strict
         fi
     fi
-fi
-${CPPCHECK} ${CPPCHECK_OPT} --library=lua ${DIR}lua.c
+}
 
 # libcurl.c
-set +e
-pkg-config --version
-PKGCONFIG_RETURNCODE=$?
-set -e
-if [ $PKGCONFIG_RETURNCODE -ne 0 ]; then
-    echo "pkg-config needed to retrieve libcurl configuration is not available, skipping syntax check."
-else
-    set +e
-    LIBCURLCONFIG=$(pkg-config --cflags libcurl)
-    LIBCURLCONFIG_RETURNCODE=$?
-    set -e
-    if [ $LIBCURLCONFIG_RETURNCODE -eq 0 ]; then
-        set +e
-        echo -e "#include <curl/curl.h>" | ${CC} ${CC_OPT} ${LIBCURLCONFIG} -x c -
-        LIBCURLCONFIG_RETURNCODE=$?
-        set -e
-        if [ $LIBCURLCONFIG_RETURNCODE -ne 0 ]; then
-            echo "libcurl not completely present or not working, skipping syntax check with ${CC}."
+function libcurl_fn {
+    if [ $HAS_PKG_CONFIG -eq 1 ]; then
+        LIBCURLCONFIG=$(get_pkg_config_cflags libcurl)
+        if [ -n "$LIBCURLCONFIG" ]; then
+            # TODO: get rid of the error enabling/disabling?
+            set +e
+            echo -e "#include <curl/curl.h>" | ${CC} "${CC_OPT[@]}" ${LIBCURLCONFIG} -x c -
+            LIBCURLCONFIG_RETURNCODE=$?
+            set -e
+            if [ $LIBCURLCONFIG_RETURNCODE -ne 0 ]; then
+                echo "libcurl not completely present or not working, skipping syntax check with ${CC}."
+                exit_if_strict
+            else
+                echo "libcurl found and working, checking syntax with ${CC} now."
+                cc_syntax ${LIBCURLCONFIG} "${DIR}"libcurl.c
+            fi
         else
-            echo "libcurl found and working, checking syntax with ${CC} now."
-            ${CC} ${CC_OPT} ${LIBCURLCONFIG} ${DIR}libcurl.c
+            echo "libcurl not present, skipping syntax check with ${CC}."
+            exit_if_strict
         fi
     fi
-fi
-${CPPCHECK} ${CPPCHECK_OPT} --library=libcurl ${DIR}libcurl.c
+}
 
 # cairo.c
-set +e
-pkg-config --version
-PKGCONFIG_RETURNCODE=$?
-set -e
-if [ $PKGCONFIG_RETURNCODE -ne 0 ]; then
-    echo "pkg-config needed to retrieve cairo configuration is not available, skipping syntax check."
-else
+function cairo_fn {
+    if [ $HAS_PKG_CONFIG -eq 1 ]; then
+        CAIROCONFIG=$(get_pkg_config_cflags cairo)
+        if [ -n "$CAIROCONFIG" ]; then
+            # TODO: get rid of the error enabling/disabling?
+            set +e
+            echo -e "#include <cairo.h>" | ${CC} "${CC_OPT[@]}" ${CAIROCONFIG} -x c -
+            CAIROCONFIG_RETURNCODE=$?
+            set -e
+            if [ $CAIROCONFIG_RETURNCODE -ne 0 ]; then
+                echo "cairo not completely present or not working, skipping syntax check with ${CC}."
+                exit_if_strict
+            else
+                echo "cairo found and working, checking syntax with ${CC} now."
+                cc_syntax ${CAIROCONFIG} "${DIR}"cairo.c
+            fi
+        else
+            echo "cairo not present, skipping syntax check with ${CC}."
+            exit_if_strict
+        fi
+    fi
+}
+
+# googletest.cpp
+function googletest_fn {
+    # TODO: add syntax check
+    true
+}
+
+# kde.cpp
+function kde_fn {
+    # TODO: get rid of the error enabling/disabling?
     set +e
-    CAIROCONFIG=$(pkg-config --cflags cairo)
-    CAIROCONFIG_RETURNCODE=$?
+    KDECONFIG=$(kde4-config --path include)
+    KDECONFIG_RETURNCODE=$?
     set -e
-    if [ $CAIROCONFIG_RETURNCODE -eq 0 ]; then
-        set +e
-        echo -e "#include <cairo.h>" | ${CC} ${CC_OPT} ${CAIROCONFIG} -x c -
-        CAIROCONFIG_RETURNCODE=$?
-        set -e
-        if [ $CAIROCONFIG_RETURNCODE -ne 0 ]; then
-            echo "cairo not completely present or not working, skipping syntax check with ${CC}."
+    if [ $KDECONFIG_RETURNCODE -ne 0 ]; then
+        echo "kde4-config does not work, skipping syntax check."
+        exit_if_strict
+    else
+        KDEQTCONFIG=$(get_pkg_config_cflags QtCore)
+        if [ -n "$KDEQTCONFIG" ]; then
+            echo "Suitable Qt not present, Qt is necessary for KDE. Skipping syntax check."
+            exit_if_strict
         else
-            echo "cairo found and working, checking syntax with ${CC} now."
-            ${CC} ${CC_OPT} ${CAIROCONFIG} ${DIR}cairo.c
+            # TODO: get rid of the error enabling/disabling?
+            set +e
+            echo -e "#include <KDE/KGlobal>\n" | ${CXX} "${CXX_OPT[@]}" -isystem${KDECONFIG} ${KDEQTCONFIG} -x c++ -
+            KDECHECK_RETURNCODE=$?
+            set -e
+            if [ $KDECHECK_RETURNCODE -ne 0 ]; then
+                echo "KDE headers not completely present or not working, skipping syntax check with ${CXX}."
+                exit_if_strict
+            else
+                echo "KDE found, checking syntax with ${CXX} now."
+                cxx_syntax -isystem${KDECONFIG} ${KDEQTCONFIG} "${DIR}"kde.cpp
+            fi
         fi
     fi
-fi
-${CPPCHECK} ${CPPCHECK_OPT} --library=cairo ${DIR}cairo.c
+}
+
+# libsigc++.cpp
+function libsigcpp_fn {
+    if [ $HAS_PKG_CONFIG -eq 1 ]; then
+        LIBSIGCPPCONFIG=$(get_pkg_config_cflags sigc++-2.0)
+        if [ -n "$LIBSIGCPPCONFIG" ]; then
+            # TODO: get rid of the error enabling/disabling?
+            set +e
+            echo -e "#include <sigc++/sigc++.h>\n" | ${CXX} "${CXX_OPT[@]}" ${LIBSIGCPPCONFIG} -x c++ -
+            LIBSIGCPPCONFIG_RETURNCODE=$?
+            set -e
+            if [ $LIBSIGCPPCONFIG_RETURNCODE -ne 0 ]; then
+                echo "libsigc++ not completely present or not working, skipping syntax check with ${CXX}."
+                exit_if_strict
+            else
+                echo "libsigc++ found and working, checking syntax with ${CXX} now."
+                cxx_syntax ${LIBSIGCPPCONFIG} "${DIR}"libsigc++.cpp
+            fi
+        else
+            echo "libsigc++ not present, skipping syntax check with ${CXX}."
+            exit_if_strict
+        fi
+    fi
+}
+
+# openssl.c
+function openssl_fn {
+    if [ $HAS_PKG_CONFIG -eq 1 ]; then
+        OPENSSLCONFIG=$(get_pkg_config_cflags libssl)
+        if [ -n "$OPENSSLCONFIG" ]; then
+            # TODO: get rid of the error enabling/disabling?
+            set +e
+            echo -e "#include <openssl/ssl.h>" | ${CC} "${CC_OPT[@]}" ${OPENSSLCONFIG} -x c -
+            OPENSSLCONFIG_RETURNCODE=$?
+            set -e
+            if [ $OPENSSLCONFIG_RETURNCODE -ne 0 ]; then
+                echo "OpenSSL not completely present or not working, skipping syntax check with ${CC}."
+                exit_if_strict
+            else
+                echo "OpenSSL found and working, checking syntax with ${CC} now."
+                cc_syntax ${OPENSSLCONFIG} "${DIR}"openssl.c
+            fi
+        else
+            echo "OpenSSL not present, skipping syntax check with ${CC}."
+            exit_if_strict
+        fi
+    fi
+}
+
+# opencv2.cpp
+function opencv2_fn {
+    if [ $HAS_PKG_CONFIG -eq 1 ]; then
+        OPENCVCONFIG=$(get_pkg_config_cflags opencv)
+        if [ -n "$OPENCVCONFIG" ]; then
+            # TODO: get rid of the error enabling/disabling?
+            set +e
+            echo -e "#include <opencv2/opencv.hpp>\n" | ${CXX} "${CXX_OPT[@]}"  ${OPENCVCONFIG} -x c++ -
+            OPENCVCONFIG_RETURNCODE=$?
+            set -e
+            if [ $OPENCVCONFIG_RETURNCODE -ne 0 ]; then
+                echo "OpenCV not completely present or not working, skipping syntax check with ${CXX}."
+                exit_if_strict
+            else
+                echo "OpenCV found and working, checking syntax with ${CXX} now."
+                cxx_syntax ${OPENCVCONFIG} "${DIR}"opencv2.cpp
+            fi
+        else
+            echo "OpenCV not present, skipping syntax check with ${CXX}."
+            exit_if_strict
+        fi
+    fi
+}
+
+# cppunit.cpp
+function cppunit_fn {
+    if [ $HAS_PKG_CONFIG -eq 1 ]; then
+        if ! pkg-config cppunit; then
+            echo "cppunit not found, skipping syntax check for cppunit"
+            exit_if_strict
+        else
+            echo "cppunit found, checking syntax with ${CXX} now."
+            cxx_syntax -Wno-deprecated-declarations "${DIR}"cppunit.cpp
+        fi
+    fi
+}
+
+# emscripten.cpp
+function emscripten_fn {
+    # TODO: Syntax check via g++ does not work because it can not find a valid emscripten.h
+    # cxx_syntax ${DIR}emscripten.cpp
+    true
+}
+
+# selinux.c
+function selinux_fn {
+    # TODO: add syntax check
+    true
+}
+
+function check_file {
+    f=$(basename "$1")
+    lib="${f%%.*}"
+    case $f in
+        boost.cpp)
+            boost_fn
+            cppcheck_run --library="$lib" "${DIR}""$f"
+            ;;
+        bsd.c)
+            bsd_fn
+            cppcheck_run --library="$lib" "${DIR}""$f"
+            ;;
+        cairo.c)
+            cairo_fn
+            cppcheck_run --library="$lib" "${DIR}""$f"
+            ;;
+        cppunit.cpp)
+            cppunit_fn
+            cppcheck_run --library="$lib" "${DIR}""$f"
+            ;;
+        emscripten.cpp)
+            emscripten_fn
+            cppcheck_run --library="$lib" "${DIR}""$f"
+            ;;
+        gnu.c)
+            gnu_fn
+            # TODO: posix needs to specified first or it has a different mmap() config
+            # TODO: get rid of posix dependency
+            cppcheck_run --library=posix,"$lib" "${DIR}"gnu.c
+            ;;
+        googletest.cpp)
+            googletest_fn
+            cppcheck_run --library="$lib" "${DIR}""$f"
+            ;;
+        gtk.c)
+            gtk_fn
+            cppcheck_run --library="$lib" "${DIR}""$f"
+            ;;
+        kde.cpp)
+            # TODO: "kde-4config" is no longer commonly available in recent distros
+            #kde_fn
+           cppcheck_run --library="$lib" --library=qt "${DIR}""$f"
+            ;;
+        libcurl.c)
+            libcurl_fn
+            cppcheck_run --library="$lib" "${DIR}""$f"
+            ;;
+        libsigc++.cpp)
+            libsigcpp_fn
+            cppcheck_run --library="$lib" "${DIR}""$f"
+            ;;
+        lua.c)
+            lua_fn
+            cppcheck_run --library="$lib" "${DIR}""$f"
+            ;;
+        mfc.cpp)
+            mfc_fn
+            cppcheck_run --platform=win64 --library="$lib" "${DIR}""$f"
+            ;;
+        opencv2.cpp)
+            # TODO: "opencv.pc" is not commonly available in distros
+            #opencv2_fn
+            cppcheck_run --library="$lib" "${DIR}""$f"
+            ;;
+        openmp.c)
+            openmp_fn
+            cppcheck_run --library="$lib" "${DIR}""$f"
+            ;;
+        openssl.c)
+            openssl_fn
+            cppcheck_run --library="$lib" "${DIR}""$f"
+            ;;
+        posix.c)
+            posix_fn
+            cppcheck_run --library="$lib" "${DIR}""$f"
+            ;;
+        python.c)
+            python_fn
+            cppcheck_run --library="$lib" "${DIR}""$f"
+            ;;
+        qt.cpp)
+            qt_fn
+            cppcheck_run --library="$lib" "${DIR}""$f"
+            ;;
+        selinux.c)
+            selinux_fn
+            cppcheck_run --library="$lib" "${DIR}""$f"
+            ;;
+        sqlite3.c)
+            sqlite3_fn
+            cppcheck_run --library="$lib" "${DIR}""$f"
+            ;;
+        std.c)
+            std_c_fn
+            cppcheck_run "${DIR}""$f"
+            ;;
+        std.cpp)
+            std_cpp_fn
+            cppcheck_run "${DIR}""$f"
+            ;;
+        windows.cpp)
+            windows_fn
+            cppcheck_run --platform=win32A --library="$lib" "${DIR}""$f"
+            cppcheck_run --platform=win32W --library="$lib" "${DIR}""$f"
+            cppcheck_run --platform=win64  --library="$lib" "${DIR}""$f"
+            ;;
+        wxwidgets.cpp)
+            wxwidgets_fn
+            cppcheck_run --library="$lib" "${DIR}""$f"
+            ;;
+        *)
+          echo "Unhandled file $f"
+          exit_if_strict
+    esac
+}
+
+function check_files
+{
+for f in "$@"
+do
+    check_file "$f"
+done
+}
 
 # Check the syntax of the defines in the configuration files
-set +e
-xmlstarlet --version
-XMLSTARLET_RETURNCODE=$?
-set -e
-if [ $XMLSTARLET_RETURNCODE -ne 0 ]; then
-    echo "xmlstarlet needed to extract defines, skipping defines check."
+function check_defines_syntax
+{
+    if ! xmlstarlet --version; then
+        echo "xmlstarlet needed to extract defines, skipping defines check."
+        exit_if_strict
+    else
+        for configfile in "${CFG}"*.cfg; do
+            echo "Checking defines in $configfile"
+            # Disable debugging output temporarily since there could be many defines
+            set +x
+            # XMLStarlet returns 1 if no elements were found which is no problem here
+            EXTRACTED_DEFINES=$(xmlstarlet sel -t -m '//define' -c . -n <"$configfile" || true)
+            EXTRACTED_DEFINES=$(echo "$EXTRACTED_DEFINES" | sed 's/<define name="/#define /g' | sed 's/" value="/ /g' | sed 's/"\/>//g')
+            echo "$EXTRACTED_DEFINES" | gcc -fsyntax-only -xc -Werror -
+        done
+    fi
+}
+
+if [ $# -eq 0  ]
+then
+    check_files "${DIR}"*.{c,cpp}
+    check_defines_syntax
 else
-    for configfile in ${CFG}*.cfg; do
-        echo "Checking defines in $configfile"
-        # Disable debugging output temporarily since there could be many defines
-        set +x
-        # XMLStarlet returns 1 if no elements were found which is no problem here
-        set +e
-        EXTRACTED_DEFINES=$(xmlstarlet sel -t -m '//define' -c . -n <$configfile)
-        set -e
-        EXTRACTED_DEFINES=$(echo "$EXTRACTED_DEFINES" | sed 's/<define name="/#define /g' | sed 's/" value="/ /g' | sed 's/"\/>//g')
-        echo "$EXTRACTED_DEFINES" | gcc -fsyntax-only -xc -Werror -
-    done
+    check_files "$@"
 fi
 
 echo SUCCESS
diff --git a/test/cfg/selinux.c b/test/cfg/selinux.c
new file mode 100644
index 00000000000..361af4d9c08
--- /dev/null
+++ b/test/cfg/selinux.c
@@ -0,0 +1,306 @@
+
+// Test library configuration for selinux.cfg
+//
+// Usage:
+// $ cppcheck --check-library --library=selinux --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/selinux.c
+// =>
+// No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
+//
+
+#include <stdio.h>
+
+#include <selinux/restorecon.h>
+#include <selinux/get_default_type.h>
+#include <selinux/label.h>
+#include <selinux/context.h>
+#include <selinux/get_context_list.h>
+#include <selinux/avc.h>
+
+void restorecon(void)
+{
+    // cppcheck-suppress [ignoredReturnValue, nullPointer, invalidFunctionArgBool]
+    selinux_restorecon(NULL, true);
+
+    selinux_restorecon_set_sehandle(NULL);
+
+    // cppcheck-suppress ignoredReturnValue
+    selinux_restorecon_default_handle();
+
+    // cppcheck-suppress [ignoredReturnValue, nullPointer]
+    selinux_restorecon_set_alt_rootpath(NULL);
+
+    // cppcheck-suppress nullPointer
+    selinux_restorecon_set_exclude_list(NULL);
+
+    // cppcheck-suppress ignoredReturnValue
+    selinux_restorecon_get_skipped_errors();
+
+    struct dir_xattr **arg3;
+    // cppcheck-suppress [ignoredReturnValue, nullPointer, invalidFunctionArgBool, uninitvar]
+    selinux_restorecon_xattr(NULL, true, &arg3);
+}
+
+void get_default_type_fail(void)
+{
+    // cppcheck-suppress ignoredReturnValue
+    selinux_default_type_path();
+
+    char *type1;
+    // FIXME: report ignoredReturnValue
+    // cppcheck-suppress [nullPointer]
+    get_default_type(NULL, &type1);
+
+    char **type2;
+    // FIXME: report ignoredReturnValue
+    // cppcheck-suppress [uninitvar]
+    get_default_type("object_r", type2);
+
+    // cppcheck-suppress memleak
+}
+
+void get_default_type_success(void)
+{
+    char *type = NULL;
+    int err = get_default_type("object_r", &type);
+    if (err != 0)
+        return;
+    free(type);
+}
+
+void selabel_fail1(void)
+{
+    // cppcheck-suppress [unreadVariable, constVariablePointer]
+    struct selabel_handle *hnd = selabel_open(SELABEL_CTX_FILE, NULL, 1);
+
+    // cppcheck-suppress resourceLeak
+}
+
+void selabel_fail2(void)
+{
+    struct selabel_handle *hnd = selabel_open(SELABEL_CTX_FILE, NULL, 0);
+
+    char *ctx;
+    // cppcheck-suppress nullPointerOutOfResources
+    selabel_lookup(hnd, &ctx, "/", 0);
+
+    // cppcheck-suppress nullPointerOutOfResources
+    selabel_close(hnd);
+
+    // cppcheck-suppress memleak
+}
+
+void selabel_success(void)
+{
+    struct selabel_handle *hnd = selabel_open(SELABEL_CTX_FILE, NULL, 0);
+
+    char *ctx;
+    // cppcheck-suppress nullPointerOutOfResources
+    selabel_lookup(hnd, &ctx, "/", 0);
+
+    freecon(ctx);
+
+    // cppcheck-suppress nullPointerOutOfResources
+    (void)selabel_cmp(hnd, hnd);
+
+    // cppcheck-suppress nullPointerOutOfResources
+    selabel_stats(hnd);
+
+    // cppcheck-suppress nullPointerOutOfResources
+    selabel_close(hnd);
+}
+
+void context_fail1(void)
+{
+    // cppcheck-suppress [unreadVariable, nullPointer]
+    context_t con = context_new(NULL);
+
+    // cppcheck-suppress memleak
+}
+
+void context_fail2(void)
+{
+    // cppcheck-suppress unreadVariable
+    context_t con = context_new("kernel");
+
+    // cppcheck-suppress memleak
+}
+
+void context_success(void)
+{
+    context_t con = context_new("system_u:system_r:kernel_t:s0");
+
+    printf("%s: %s %s %s %s\n", context_str(con),
+           context_type_get(con), context_range_get(con),
+           context_role_get(con), context_user_get(con));
+
+    (void)context_type_set(con, "init_t");
+
+    context_free(con);
+}
+
+void get_ordered_context_list_fail1(void)
+{
+    char **ret;
+    // cppcheck-suppress nullPointer
+    get_ordered_context_list(NULL, NULL, &ret);
+
+    // cppcheck-suppress memleak
+}
+
+void get_ordered_context_list_fail2(void)
+{
+    char **ret;
+    get_ordered_context_list("root", NULL, &ret);
+
+    // cppcheck-suppress mismatchAllocDealloc
+    freecon((void*)ret);
+}
+
+void get_ordered_context_list_success1(void)
+{
+    char **ret;
+    get_ordered_context_list("root", NULL, &ret);
+    freeconary(ret);
+}
+
+void get_default_context_with_rolelevel_fail1(void)
+{
+    char *ctx;
+    // cppcheck-suppress nullPointer
+    get_default_context_with_rolelevel("root", NULL, "s0", "system_u:system_r:init_t:s0", &ctx);
+
+    // cppcheck-suppress memleak
+}
+
+void get_default_context_with_rolelevel_fail2(void)
+{
+    char *ctx;
+    get_default_context_with_rolelevel("root", "sysadm_r", NULL, NULL, &ctx);
+
+    // cppcheck-suppress mismatchAllocDealloc
+    freeconary((void*)ctx);
+}
+
+void get_default_context_with_rolelevel_success1(void)
+{
+    char *ctx;
+    get_default_context_with_rolelevel("root", "sysadm_r", NULL, NULL, &ctx);
+    freecon(ctx);
+}
+
+void selinux_status_fail1(void)
+{
+    // cppcheck-suppress [invalidFunctionArg, ignoredReturnValue]
+    selinux_status_open(-1);
+    // TODO: report leak
+}
+
+void selinux_status_success1(void)
+{
+    (void)selinux_status_open(0);
+    (void)selinux_status_updated();
+    selinux_status_close();
+}
+
+void realpath_not_final_fail1(void)
+{
+    char buf[64];
+    // cppcheck-suppress bufferAccessOutOfBounds
+    (void)realpath_not_final("/root", buf);
+}
+
+void realpath_not_final_success1(void)
+{
+#define PATH_MAX 4096
+    char buf[PATH_MAX + 1];
+    // cppcheck-suppress ignoredReturnValue
+    realpath_not_final("/root", buf);
+}
+
+void selinux_getpolicytype_fail1(void)
+{
+    // cppcheck-suppress nullPointer
+    selinux_getpolicytype(NULL);
+}
+
+void selinux_getpolicytype_fail2(void)
+{
+    char *type;
+    (void)selinux_getpolicytype(&type);
+
+    // cppcheck-suppress memleak
+}
+
+void selinux_check_access_fail1(void)
+{
+    const char *msg = "Hello World!";
+    // cppcheck-suppress [ignoredReturnValue, nullPointer]
+    selinux_check_access("foo", "bar", NULL, "baz", msg);
+}
+
+void selinux_check_access_success1(void)
+{
+    (void)selinux_check_access("kernel", "init", "file", "write", NULL);
+}
+
+void selinux_trans_to_raw_context_fail1(void)
+{
+    // FIXME: report ignoredReturnValue
+    // cppcheck-suppress nullPointer
+    selinux_trans_to_raw_context("kernel", NULL);
+}
+
+void selinux_trans_to_raw_context_fail2(void)
+{
+    char *ctx;
+    // FIXME: report ignoredReturnValue
+    selinux_trans_to_raw_context("kernel", &ctx);
+
+    // cppcheck-suppress memleak
+}
+
+void selinux_trans_to_raw_context_success1(void)
+{
+    char *ctx;
+    (void)selinux_trans_to_raw_context("kernel", &ctx);
+    free(ctx);
+}
+
+void getseuserbyname_fail1(void)
+{
+    char *seuser, *level;
+    // cppcheck-suppress nullPointer
+    getseuserbyname(NULL, &seuser, &level);
+    free(seuser);
+
+    // cppcheck-suppress memleak
+}
+
+void getseuserbyname_fail2(void)
+{
+    char *seuser, *level;
+    getseuserbyname("root", &seuser, &level);
+    free(level);
+
+    // FIXME: report memleak
+}
+
+void getseuserbyname_success1(void)
+{
+    char *seuser, *level;
+    getseuserbyname("root", &seuser, &level);
+    free(seuser);
+    free(level);
+}
+
+void danger1(void)
+{
+    // cppcheck-suppress selinux_reset_configCalled
+    selinux_reset_config();
+}
+
+void danger2(void)
+{
+    // cppcheck-suppress [security_disableCalled, ignoredReturnValue]
+    security_disable();
+}
diff --git a/test/cfg/sqlite3.c b/test/cfg/sqlite3.c
index 0437951dd6c..093a1378b4e 100644
--- a/test/cfg/sqlite3.c
+++ b/test/cfg/sqlite3.c
@@ -2,7 +2,7 @@
 // Test library configuration for sqlite3.cfg
 //
 // Usage:
-// $ cppcheck --check-library --library=sqlite3 --enable=information --error-exitcode=1 --inline-suppr --suppress=missingIncludeSystem test/cfg/sqlite3.c
+// $ cppcheck --check-library --library=sqlite3 --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/sqlite3.c
 // =>
 // No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
 //
@@ -16,7 +16,7 @@ void validCode()
 
     int rc = sqlite3_open("/db", &db);
     if (rc != SQLITE_OK) {
-        fprintf(stderr, "Error opening sqlite3 db: %s\n", sqlite3_errmsg(db));
+        printf("Error opening sqlite3 db: %s\n", sqlite3_errmsg(db));
         sqlite3_close(db);
     } else {
         sqlite3_close(db);
@@ -24,7 +24,6 @@ void validCode()
 
     {
         char * buf = sqlite3_malloc(10);
-        // cppcheck-suppress invalidPrintfArgType_uint
         printf("size: %ull\n", sqlite3_msize(buf));
         sqlite3_free(buf);
     }
@@ -44,10 +43,24 @@ void resourceLeak_sqlite3_open()
     sqlite3 * db;
 
     sqlite3_open("/db", &db);
-    // TODO: cppcheck-suppress resourceLeak
+    // cppcheck-suppress resourceLeak
 }
 
-void ignoredReturnValue(char * buf)
+void resourceLeak_sqlite3_open_v2(const char* Filename, int Flags, int Timeout, const char* Vfs) { // #12951, don't crash
+    sqlite3* handle;
+    const int ret = sqlite3_open_v2(Filename, &handle, Flags, Vfs);
+    if (SQLITE_OK != ret) {}
+    if (Timeout > 0) {}
+    // cppcheck-suppress resourceLeak
+}
+
+void nullPointer_sqlite3_open_v2(const char* filename, int flags) { // #13078
+    sqlite3* handle;
+    sqlite3_open_v2(filename, &handle, flags, NULL);
+    sqlite3_close_v2(handle);
+}
+
+void ignoredReturnValue(const char * buf)
 {
     // cppcheck-suppress leakReturnValNotUsed
     sqlite3_malloc(10);
diff --git a/test/cfg/std.c b/test/cfg/std.c
index 6992358a2d6..af0b30e03b2 100644
--- a/test/cfg/std.c
+++ b/test/cfg/std.c
@@ -2,11 +2,13 @@
 // Test library configuration for std.cfg
 //
 // Usage:
-// $ cppcheck --check-library --enable=information --error-exitcode=1 --suppress=missingIncludeSystem --inline-suppr test/cfg/std.c
+// $ cppcheck --check-library --library=std --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/std.c
 // =>
 // No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
 //
 
+// cppcheck-suppress-file [valueFlowBailout,purgedConfiguration]
+
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -19,14 +21,189 @@
 #include <wctype.h>
 #include <fenv.h>
 #include <setjmp.h>
+#define __STDC_WANT_LIB_EXT1__ 1
 #include <time.h>
 #include <stdbool.h>
-#include <stdint.h>
+#ifndef __STDC_NO_THREADS__
+#include <threads.h>
+#endif
 #include <inttypes.h>
+#include <float.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <alloca.h>
+#include <locale.h>
+#include <signal.h>
+#include <complex.h>
+#include <math.h>
+#include <stddef.h>
+
+void test_int32_min() {
+    // cppcheck-suppress shiftNegativeLHS
+    // cppcheck-suppress shiftTooManyBits ; tests that INT32_MIN is a 32-bit expression (not 64-bit expression)
+    (void)(INT32_MIN >> 40);
+}
+
+void test_int64_min() {
+    // cppcheck-suppress compareValueOutOfTypeRangeError ; tests that INT64_MIN is a signed expression
+    if (INT64_MIN < 0) {}
+}
+
+size_t invalidFunctionArgStr_wcslen(void)
+{
+    const wchar_t terminated0[] = L"ABCDEF49620910";
+    const wchar_t terminated1[3] = { L'a', L'b', L'\0' };
+    const wchar_t notTerminated[3] = { L'a', L'b', L'c' };
+    // cppcheck-suppress invalidFunctionArgStr
+    (void) wcslen(notTerminated);
+    (void) wcslen(terminated0);
+    return wcslen(terminated1);
+}
+
+int invalidFunctionArgStr_strcpn(void)
+{
+    const char str1[] = "ABCDEF49620910";
+    const char str2[] = "42";
+    const char pattern[3] = { -42, -43, -44 };
+    // cppcheck-suppress invalidFunctionArgStr
+    (void) strcspn(str1, pattern);
+    return strcspn(str1, str2);
+}
+
+void invalidFunctionArgStr_strncat(void)
+{
+    char str1[20];
+    strcpy (str1,"test");
+    const char src = '/';
+    // No warning is expected for
+    strncat (str1, &src, 1);
+    puts (str1);
+}
+
+char * invalidFunctionArgStr_strpbrk( const char *p )
+{
+    const char search[] = { -42, -43, -44 };
+    const char pattern[3] = { -42, -43, -44 };
+    (void) strpbrk( "abc42", "42" );
+    // cppcheck-suppress invalidFunctionArgStr
+    (void) strpbrk( search, "42" );
+    // cppcheck-suppress invalidFunctionArgStr
+    (void) strpbrk( search, pattern );
+    // cppcheck-suppress invalidFunctionArgStr
+    return strpbrk( p, pattern );
+}
+
+int invalidFunctionArgStr_strncmp( const char *p )
+{
+    const char string[] = "foo";
+    char other[5] = { 0 };
+    memcpy(other, "foo", 4);
+    if (strncmp(other, string, 5) != 0) {}
+
+    // No warning is expected for:
+    const char emdash[3] = { -42, -43, -44 };
+    return strncmp( p, emdash, 3 );
+}
+
+float invalidFunctionArg_float_remquo (float x, float y, int* quo )
+{
+    // cppcheck-suppress invalidFunctionArg
+    (void) remquo(x,0.0f,quo);
+    // cppcheck-suppress invalidFunctionArg
+    (void) remquof(x,0.0f,quo);
+    return remquo(x,y,quo);
+}
+
+double invalidFunctionArg_double_remquo (double x, double y, int* quo )
+{
+    // cppcheck-suppress invalidFunctionArg
+    (void) remquo(x,0.0,quo);
+    // cppcheck-suppress invalidFunctionArg
+    (void) remquo(x,0.0f,quo);
+    // cppcheck-suppress invalidFunctionArg
+    (void) remquo(x,0.0L,quo);
+    return remquo(x,y,quo);
+}
+
+double invalidFunctionArg_long_double_remquo (long double x, long double y, int* quo )
+{
+    // cppcheck-suppress invalidFunctionArg
+    (void) remquo(x,0.0L,quo);
+    // cppcheck-suppress invalidFunctionArg
+    (void) remquol(x,0.0L,quo);
+    return remquo(x,y,quo);
+}
+
+void invalidFunctionArg_remainderl(long double f1, long double f2)
+{
+    // cppcheck-suppress invalidFunctionArg
+    (void)remainderl(f1,0.0);
+    // cppcheck-suppress invalidFunctionArg
+    (void)remainderl(f1,0.0L);
+    (void)remainderl(f1,f2);
+}
+
+void invalidFunctionArg_remainder(double f1, double f2)
+{
+    // cppcheck-suppress invalidFunctionArg
+    (void)remainder(f1,0.0);
+    (void)remainder(f1,f2);
+}
+
+void invalidFunctionArg_remainderf(float f1, float f2)
+{
+    // cppcheck-suppress invalidFunctionArg
+    (void)remainderf(f1,0.0);
+    // cppcheck-suppress invalidFunctionArg
+    (void)remainderf(f1,0.0f);
+    (void)remainderf(f1,f2);
+}
+
+int qsort_cmpfunc (const void * a, const void * b) {
+    return (*(int*)a - *(int*)b);
+}
+void nullPointer_qsort(void *base, size_t n, size_t size, int (*cmp)(const void *, const void *))
+{
+    // cppcheck-suppress nullPointer
+    qsort(NULL, n, size, qsort_cmpfunc);
+    // cppcheck-suppress nullPointer
+    qsort(base, n, size, NULL);
+    qsort(base, n, size, qsort_cmpfunc);
+}
+
+// As with all bounds-checked functions, localtime_s is only guaranteed to be available if __STDC_LIB_EXT1__ is defined by the implementation and if the user defines __STDC_WANT_LIB_EXT1__ to the integer constant 1 before including time.h.
+#ifdef __STDC_LIB_EXT1__
+void uninitvar_localtime_s(const time_t *restrict time, struct tm *restrict result)
+{
+    const time_t *restrict Time;
+    // cppcheck-suppress uninitvar
+    (void)localtime_s(Time, result);
+    (void)localtime_s(time, result);
+}
+
+void nullPointer_localtime_s(const time_t *restrict time, struct tm *restrict result)
+{
+    // cppcheck-suppress nullPointer
+    (void)localtime_s(NULL, result);
+    // cppcheck-suppress nullPointer
+    (void)localtime_s(time, NULL);
+    (void)localtime_s(time, result);
+}
+#endif // __STDC_LIB_EXT1__
+
+size_t bufferAccessOutOfBounds_wcsrtombs(char * dest, const wchar_t ** src, size_t len, mbstate_t * ps)
+{
+    char buf[42];
+    (void)wcsrtombs(buf,src,42,ps);
+    // cppcheck-suppress bufferAccessOutOfBounds
+    (void)wcsrtombs(buf,src,43,ps);
+    return wcsrtombs(dest,src,len,ps);
+}
 
 void bufferAccessOutOfBounds(void)
 {
     char a[5];
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
     fgets(a,5,stdin);
     // cppcheck-suppress bufferAccessOutOfBounds
     fgets(a,6,stdin);
@@ -44,8 +221,10 @@ void bufferAccessOutOfBounds(void)
     // cppcheck-suppress bufferAccessOutOfBounds
     // TODO cppcheck-suppress redundantCopy
     strcpy(a, "abcde");
+#ifdef __STDC_LIB_EXT1__
     // cppcheck-suppress bufferAccessOutOfBounds
     strcpy_s(a, 10, "abcdefghij");
+#endif
     // TODO cppcheck-suppress redundantCopy
     // cppcheck-suppress terminateStrncpy
     strncpy(a,"abcde",5);
@@ -57,6 +236,7 @@ void bufferAccessOutOfBounds(void)
     strncpy(a,"a",6);
     // TODO cppcheck-suppress redundantCopy
     strncpy(a,"abcdefgh",4);
+#ifdef __STDC_LIB_EXT1__
     // valid call
     strncpy_s(a,5,"abcd",5);
     // string will be truncated, error is returned, but no buffer overflow
@@ -70,6 +250,7 @@ void bufferAccessOutOfBounds(void)
     strncat_s(a,10,"1",2);
     // TODO cppcheck-suppress bufferAccessOutOfBounds
     strncat_s(a,5,"1",5);
+#endif
     fread(a,1,5,stdin);
     // cppcheck-suppress bufferAccessOutOfBounds
     fread(a,1,6,stdin);
@@ -78,12 +259,77 @@ void bufferAccessOutOfBounds(void)
     fread(a,1,6,stdout);
 
     char * pAlloc1 = aligned_alloc(8, 16);
+    // cppcheck-suppress nullPointerOutOfMemory
     memset(pAlloc1, 0, 16);
     // cppcheck-suppress bufferAccessOutOfBounds
+    // cppcheck-suppress nullPointerOutOfMemory
     memset(pAlloc1, 0, 17);
     free(pAlloc1);
 }
 
+wchar_t* nullPointer_fgetws(wchar_t* buffer, int n, FILE* stream)
+{
+    // cppcheck-suppress nullPointer
+    (void)fgetws(NULL,n,stream);
+    // cppcheck-suppress nullPointer
+    (void)fgetws(buffer,n,NULL);
+    // No warning is expected
+    return fgetws(buffer, n, stream);
+}
+
+char* nullPointer_fgets(char *buffer, int n, FILE *stream)
+{
+    // cppcheck-suppress nullPointer
+    (void)fgets(NULL,n,stream);
+    // cppcheck-suppress nullPointer
+    (void)fgets(buffer,n,NULL);
+    // No warning is expected
+    return fgets(buffer, n, stream);
+}
+
+void memleak_aligned_alloc(void)
+{
+    // cppcheck-suppress [unusedAllocatedMemory, unreadVariable, constVariablePointer]
+    char * alignedBuf = aligned_alloc(8, 16);
+    // cppcheck-suppress memleak
+}
+
+void pointerLessThanZero_aligned_alloc(void)
+{
+    char * alignedBuf = aligned_alloc(8, 16);
+    // cppcheck-suppress pointerLessThanZero
+    if (alignedBuf < 0) return;
+    free(alignedBuf);
+
+    // no warning is expected for
+    alignedBuf = aligned_alloc(8, 16);
+    if (alignedBuf == 0) return;
+    free(alignedBuf);
+
+    // no warning is expected for
+    alignedBuf = aligned_alloc(8, 16);
+    if (alignedBuf) free(alignedBuf);
+}
+
+void unusedRetVal_aligned_alloc(void)
+{
+    // cppcheck-suppress leakReturnValNotUsed
+    aligned_alloc(8, 16);
+}
+
+void uninitvar_aligned_alloc(size_t alignment, size_t size)
+{
+    size_t uninitVar1, uninitVar2, uninitVar3;
+    // cppcheck-suppress uninitvar
+    free(aligned_alloc(uninitVar1, size));
+    // cppcheck-suppress uninitvar
+    free(aligned_alloc(alignment, uninitVar2));
+    // cppcheck-suppress uninitvar
+    free(aligned_alloc(uninitVar3, uninitVar3));
+    // no warning is expected
+    free(aligned_alloc(alignment, size));
+}
+
 void bufferAccessOutOfBounds_libraryDirectionConfiguration(void)
 {
     // This tests whether the argument to isdigit() is configured with direction "in". This allows
@@ -96,17 +342,30 @@ void bufferAccessOutOfBounds_libraryDirectionConfiguration(void)
     arr[c] = 'x';
 }
 
+void internalError_libraryDirectionConfiguration(char* str) { // #12824
+    const char* s = str;
+    char* end = str;
+    if (1) {
+        // cppcheck-suppress unreadVariable
+        unsigned long val = strtoul(&s[1], &end, 10);
+    }
+}
+
 void arrayIndexOutOfBounds()
 {
     char * pAlloc1 = aligned_alloc(8, 16);
+    // cppcheck-suppress nullPointerOutOfMemory
     pAlloc1[15] = '\0';
     // cppcheck-suppress arrayIndexOutOfBounds
+    // cppcheck-suppress nullPointerOutOfMemory
     pAlloc1[16] = '1';
     free(pAlloc1);
 
     char * pAlloc2 = malloc(9);
+    // cppcheck-suppress nullPointerOutOfMemory
     pAlloc2[8] = 'a';
     // cppcheck-suppress arrayIndexOutOfBounds
+    // cppcheck-suppress nullPointerOutOfMemory
     pAlloc2[9] = 'a';
 
     // #1379
@@ -123,20 +382,17 @@ void arrayIndexOutOfBounds()
     free(pAlloc2);
 
     char * pAlloc3 = calloc(2,3);
+    // cppcheck-suppress nullPointerOutOfMemory
     pAlloc3[5] = 'a';
     // cppcheck-suppress arrayIndexOutOfBounds
+    // cppcheck-suppress nullPointerOutOfMemory
     pAlloc3[6] = 1;
-    // cppcheck-suppress memleakOnRealloc
-    pAlloc3 = reallocarray(pAlloc3, 3,3);
-    pAlloc3[8] = 'a';
-    // cppcheck-suppress arrayIndexOutOfBounds
-    pAlloc3[9] = 1;
     free(pAlloc3);
 }
 
 void resourceLeak_tmpfile(void)
 {
-    // cppcheck-suppress unreadVariable
+    // cppcheck-suppress [unreadVariable, constVariablePointer]
     FILE * fp = tmpfile();
     // cppcheck-suppress resourceLeak
 }
@@ -180,10 +436,12 @@ void nullpointer(int value)
     puts(0);
     // cppcheck-suppress nullPointer
     fp=fopen(0,0);
+    // cppcheck-suppress nullPointerOutOfResources
     fclose(fp);
     fp = 0;
     // No FP
-    fflush(0);
+    fflush(0); // If stream is a null pointer, all streams are flushed.
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
     fp = freopen(0,"abc",stdin);
     fclose(fp);
     fp = NULL;
@@ -197,8 +455,10 @@ void nullpointer(int value)
     frexp(1.0,0);
     // cppcheck-suppress nullPointer
     fsetpos(0,0);
+#ifdef _WIN32 // not available on non-Windows compilers
     // cppcheck-suppress nullPointer
     itoa(123,0,10);
+#endif
     putchar(0);
     // cppcheck-suppress ignoredReturnValue
     // cppcheck-suppress nullPointer
@@ -244,24 +504,30 @@ void nullpointer(int value)
     // cppcheck-suppress ignoredReturnValue
     // cppcheck-suppress nullPointer
     wcscmp(0,0);
+#ifdef __STDC_LIB_EXT1__
     // cppcheck-suppress nullPointer
     strcpy_s(0,1,1);
     // cppcheck-suppress nullPointer
     strcpy_s(1,1,0);
+#endif
     // cppcheck-suppress nullPointer
     strncpy(0,0,1);
+#ifdef __STDC_LIB_EXT1__
     // cppcheck-suppress nullPointer
     strncpy_s(0,1,1,1);
     // cppcheck-suppress nullPointer
     strncpy_s(1,1,0,1);
+#endif
     // cppcheck-suppress nullPointer
     wcsncpy(0,0,1);
     // cppcheck-suppress nullPointer
     strncat(0,0,1);
+#ifdef __STDC_LIB_EXT1__
     // cppcheck-suppress nullPointer
     strncat_s(0,1,1,1);
     // cppcheck-suppress nullPointer
     strncat_s(1,1,0,1);
+#endif
     // cppcheck-suppress nullPointer
     wcsncat(0,0,1);
     // cppcheck-suppress ignoredReturnValue
@@ -315,13 +581,66 @@ void nullpointer(int value)
     wscanf(L"%i", NULL);
 }
 
-void nullpointerMemchr1(char *p, char *s)
+void nullPointer_wcsftime(wchar_t* ptr, size_t maxsize, const wchar_t* format, const struct tm* timeptr)
+{
+    // cppcheck-suppress nullPointer
+    (void)wcsftime(NULL, maxsize, format, timeptr);
+    // cppcheck-suppress nullPointer
+    (void)wcsftime(ptr, maxsize, NULL, timeptr);
+    // cppcheck-suppress nullPointer
+    (void)wcsftime(ptr, maxsize, format, NULL);
+    (void)wcsftime(ptr, maxsize, format, timeptr);
+}
+
+void bufferAccessOutOfBounds_wcsftime(wchar_t* ptr, size_t maxsize, const wchar_t* format, const struct tm* timeptr)
+{
+    wchar_t buf[42];
+    (void)wcsftime(buf, 42, format, timeptr);
+    // TODO cppcheck-suppress bufferAccessOutOfBounds
+    (void)wcsftime(buf, 43, format, timeptr);
+    (void)wcsftime(ptr, maxsize, format, timeptr);
+}
+
+void bufferAccessOutOfBounds_wcsncpy()
+{
+    wchar_t s[16];
+    wcsncpy(s, L"abc", 16);
+    // cppcheck-suppress bufferAccessOutOfBounds
+    wcsncpy(s, L"abc", 17);
+}
+
+int nullPointer_wcsncmp(const wchar_t* s1, const wchar_t* s2, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void) wcsncmp(NULL,s2,n);
+    // cppcheck-suppress nullPointer
+    (void) wcsncmp(s1,NULL,n);
+    return wcsncmp(s1,s2,n);
+}
+
+wchar_t* nullPointer_wcsncpy(wchar_t *s, const wchar_t *cs, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void) wcsncpy(NULL,cs,n);
+    // cppcheck-suppress nullPointer
+    (void) wcsncpy(s,NULL,n);
+    return wcsncpy(s,cs,n);
+}
+
+size_t nullPointer_strlen(const char *s)
+{
+    // cppcheck-suppress nullPointer
+    (void) strlen(NULL);
+    return strlen(s);
+}
+
+void nullpointerMemchr1(char *p, const char *s)
 {
     p = memchr(s, 'p', strlen(s));
     (void)p;
 }
 
-void nullpointerMemchr2(char *p, char *s)
+void nullpointerMemchr2(char *p, const char *s)
 {
     p = memchr(s, 0, strlen(s));
     (void)p;
@@ -329,22 +648,30 @@ void nullpointerMemchr2(char *p, char *s)
 
 void nullPointer_memchr(char *p)
 {
-    char *s = 0;
+    const char *s = 0;
     // cppcheck-suppress nullPointer
     p = memchr(s, 0, strlen(s));
     (void)p;
 }
 
-void nullPointer_memcmp(char *p)
+void nullPointer_vsnprintf(const char * format, ...)
 {
-    // cppcheck-suppress nullPointer
-    (void)memcmp(p, 0, 123);
-}
-
-void nullPointer_wmemcmp(wchar_t *p)
-{
-    // cppcheck-suppress nullPointer
-    (void)wmemcmp(p, 0, 123);
+    va_list args;
+    // valid
+    char buffer[256];
+    va_start(args, format);
+    vsnprintf(buffer, 256, format, args);
+    printf("%s", buffer);
+    va_end(args);
+    // valid
+    va_start(args, format);
+    vsnprintf(NULL, 0, format, args);
+    va_end(args);
+    // invalid
+    va_start(args, format);
+    // TODO #9410 cppcheck-suppress nullPointer
+    vsnprintf(NULL, 10, format, args);
+    va_end(args);
 }
 
 // uninit pointers
@@ -365,6 +692,7 @@ void uninitvar_clearerr(void)
 
 void uninitvar_fclose(void)
 {
+    // cppcheck-suppress unassignedVariable
     FILE *fp;
     // cppcheck-suppress uninitvar
     fclose(fp);
@@ -376,32 +704,34 @@ void uninitvar_fopen(void)
     FILE *fp;
     // cppcheck-suppress uninitvar
     fp = fopen(filename, "rt");
+    // cppcheck-suppress nullPointerOutOfResources
     fclose(fp);
     // cppcheck-suppress uninitvar
     fp = fopen("filename.txt", mode);
+    // cppcheck-suppress nullPointerOutOfResources
     fclose(fp);
 }
 
 void uninitvar_feof(void)
 {
-    FILE *fp;
+    FILE *fp1, *fp2;
     // cppcheck-suppress ignoredReturnValue
     // cppcheck-suppress uninitvar
-    feof(fp);
+    feof(fp1);
 
     // cppcheck-suppress uninitvar
-    (void)feof(fp);
+    (void)feof(fp2);
 }
 
 void uninitvar_ferror(void)
 {
-    FILE *fp;
+    FILE *fp1, *fp2;
     // cppcheck-suppress ignoredReturnValue
     // cppcheck-suppress uninitvar
-    ferror(fp);
+    ferror(fp1);
 
     // cppcheck-suppress uninitvar
-    (void)ferror(fp);
+    (void)ferror(fp2);
 }
 
 void uninitvar_fflush(void)
@@ -428,7 +758,9 @@ void uninitvar_fgetpos(void)
 
     fp = fopen("filename","rt");
     // cppcheck-suppress uninitvar
+    // cppcheck-suppress nullPointerOutOfResources
     fgetpos(fp,ppos);
+    // cppcheck-suppress nullPointerOutOfResources
     fclose(fp);
 }
 
@@ -436,13 +768,15 @@ void uninitvar_fsetpos(void)
 {
     FILE *fp;
     fpos_t pos;
-    fpos_t *ppos;
+    const fpos_t *ppos;
     // cppcheck-suppress uninitvar
     fsetpos(fp,&pos);
 
     fp = fopen("filename","rt");
     // cppcheck-suppress uninitvar
+    // cppcheck-suppress nullPointerOutOfResources
     fsetpos(fp,ppos);
+    // cppcheck-suppress nullPointerOutOfResources
     fclose(fp);
 }
 
@@ -453,6 +787,7 @@ void uninitvar_fgets(void)
     char *str;
     int n;
 
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
     fgets(buf,10,stdin);
 
     // cppcheck-suppress uninitvar
@@ -470,6 +805,7 @@ void uninitvar_fputc(void)
     int i;
     FILE *fp;
 
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
     fputc('a', stdout);
 
     // cppcheck-suppress uninitvar
@@ -484,6 +820,7 @@ void uninitvar_fputs(void)
     const char *s;
     FILE *fp;
 
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
     fputs("a", stdout);
 
     // cppcheck-suppress uninitvar
@@ -574,6 +911,63 @@ void uninitvar_acosh(void)
     (void)acoshl(ld);
 }
 
+void invalidFunctionArg_acosh(void)
+{
+    float f = .999f;
+    // cppcheck-suppress invalidFunctionArg
+    (void)acoshf(f);
+    f = 1.0f;
+    (void)acoshf(f);
+
+    double d = .999;
+    // cppcheck-suppress invalidFunctionArg
+    (void)acosh(d);
+    d = 1.0;
+    (void)acosh(d);
+
+    long double ld = .999L;
+    // cppcheck-suppress invalidFunctionArg
+    (void)acoshl(ld);
+    ld = 1.0;
+    (void)acoshl(ld);
+}
+
+void invalidFunctionArg_atanh(void)
+{
+    float f = 1.00001f;
+    // cppcheck-suppress invalidFunctionArg
+    (void)atanhf(f);
+    f = 1.0f;
+    (void)atanhf(f);
+    f = -1.0f;
+    (void)atanhf(f);
+    f = -1.00001f;
+    // cppcheck-suppress invalidFunctionArg
+    (void)atanhf(f);
+
+    double d = 1.00001;
+    // cppcheck-suppress invalidFunctionArg
+    (void)atanh(d);
+    d = 1.0;
+    (void)atanh(d);
+    d = -1.0;
+    (void)atanh(d);
+    d = -1.00001;
+    // cppcheck-suppress invalidFunctionArg
+    (void)atanh(d);
+
+    long double ld = 1.00001L;
+    // cppcheck-suppress invalidFunctionArg
+    (void)atanhl(ld);
+    ld = 1.0L;
+    (void)atanhl(ld);
+    ld = -1.0L;
+    (void)atanhl(ld);
+    ld = -1.00001L;
+    // cppcheck-suppress invalidFunctionArg
+    (void)atanhl(ld);
+}
+
 void uninitvar_asctime(void)
 {
     const struct tm *tm;
@@ -582,6 +976,7 @@ void uninitvar_asctime(void)
     (void)asctime(tm);
 }
 
+#ifdef __STDC_LIB_EXT1__
 void uninitvar_asctime_s(void)
 {
     const struct tm *tm;
@@ -590,6 +985,7 @@ void uninitvar_asctime_s(void)
     // cppcheck-suppress asctime_sCalled
     asctime_s(buf, sizeof(buf), tm);
 }
+#endif
 
 void uninitvar_assert(void)
 {
@@ -752,8 +1148,8 @@ void uninitvar_casinh(void)
 void uninitvar_wcsftime(wchar_t* ptr)
 {
     size_t maxsize;
-    wchar_t* format;
-    struct tm* timeptr;
+    const wchar_t* format;
+    const struct tm* timeptr;
     // cppcheck-suppress uninitvar
     (void)wcsftime(ptr, maxsize, format, timeptr);
 }
@@ -841,7 +1237,7 @@ void uninitvar_feraiseexcept(void)
 
 void uninitvar_fesetenv(void)
 {
-    fenv_t* envp;
+    const fenv_t* envp;
     // cppcheck-suppress uninitvar
     (void)fesetenv(envp);
 }
@@ -862,7 +1258,7 @@ void uninitvar_fetestexcept(void)
 
 void uninitvar_feupdateenv(void)
 {
-    fenv_t* envp;
+    const fenv_t* envp;
     // cppcheck-suppress uninitvar
     (void)feupdateenv(envp);
 }
@@ -974,28 +1370,29 @@ void uninitvar_atan2(void)
 
 void uninitvar_atof(void)
 {
-    char * c;
+    const char * c;
     // cppcheck-suppress uninitvar
     (void)atof(c);
 }
 
 void uninitvar_atol(void)
 {
-    char * c;
+    const char * c1, *c2, *c3;
     // cppcheck-suppress uninitvar
-    (void)atoi(c);
+    (void)atoi(c1);
 
     // cppcheck-suppress uninitvar
-    (void)atol(c);
+    (void)atol(c2);
 
     // cppcheck-suppress uninitvar
-    (void)atoll(c);
+    (void)atoll(c3);
 }
 
 void uninitvar_calloc(void)
 {
     size_t nitems;
     size_t size;
+    // cppcheck-suppress unusedAllocatedMemory
     // cppcheck-suppress uninitvar
     int * p = (int*) calloc(nitems, size);
     free(p);
@@ -1108,7 +1505,7 @@ void uninitvar_ccosh(void)
 
 void uninitvar_ctime(void)
 {
-    time_t *tp;
+    const time_t *tp;
     // cppcheck-suppress uninitvar
     (void)ctime(tp);
 }
@@ -1367,15 +1764,23 @@ void uninitvar_fmod(void)
     (void)fmodl(ld1,ld2);
 }
 
-void uninitvar_fprintf(FILE *Stream, char *Format, int Argument)
+void nullPointer_fprintf(FILE *Stream, const char *Format, int Argument)
 {
-    FILE *stream;
-    char *format1, *format2;
+    // cppcheck-suppress nullPointer
+    (void)fprintf(Stream, NULL, Argument);
+    // no warning is expected
+    (void)fprintf(Stream, Format, Argument);
+}
+
+void uninitvar_fprintf(FILE *Stream, const char *Format, int Argument)
+{
+    FILE *stream1, *stream2;
+    const char *format1, *format2;
     int argument1, argument2;
     // cppcheck-suppress uninitvar
-    (void)fprintf(stream, format1, argument1);
+    (void)fprintf(stream1, format1, argument1);
     // cppcheck-suppress uninitvar
-    (void)fprintf(stream, Format, Argument);
+    (void)fprintf(stream2, Format, Argument);
     // cppcheck-suppress uninitvar
     (void)fprintf(Stream, format2, Argument);
     // cppcheck-suppress uninitvar
@@ -1385,16 +1790,23 @@ void uninitvar_fprintf(FILE *Stream, char *Format, int Argument)
     (void)fprintf(Stream, Format, Argument);
 }
 
+void nullPointer_vfprintf(FILE *Stream, const char *Format, va_list Arg)
+{
+    // cppcheck-suppress nullPointer
+    (void)vfprintf(Stream, NULL, Arg);
+    (void)vfprintf(Stream, Format, Arg);
+}
+
 void uninitvar_vfprintf(FILE *Stream, const char *Format, va_list Arg)
 {
-    FILE *stream;
-    char *format1, *format2;
+    FILE *stream1, *stream2;
+    const char *format1, *format2;
     va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
-    (void)vfprintf(stream, format1, arg);
+    (void)vfprintf(stream1, format1, arg);
     // cppcheck-suppress uninitvar
-    (void)vfprintf(stream, Format, Arg);
+    (void)vfprintf(stream2, Format, Arg);
     // cppcheck-suppress uninitvar
     (void)vfprintf(Stream, format2, Arg);
 
@@ -1404,16 +1816,23 @@ void uninitvar_vfprintf(FILE *Stream, const char *Format, va_list Arg)
     (void)vfprintf(Stream, Format, arg);
 }
 
-void uninitvar_vfwprintf(FILE *Stream, wchar_t *Format, va_list Arg)
+void nullPointer_vfwprintf(FILE *Stream, const wchar_t *Format, va_list Arg)
 {
-    FILE *stream;
-    wchar_t *format1, *format2;
+    // cppcheck-suppress nullPointer
+    (void)vfwprintf(Stream, NULL, Arg);
+    (void)vfwprintf(Stream, Format, Arg);
+}
+
+void uninitvar_vfwprintf(FILE *Stream, const wchar_t *Format, va_list Arg)
+{
+    FILE *stream1, *stream2;
+    const wchar_t *format1, *format2;
     va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
-    (void)vfwprintf(stream, format1, arg);
+    (void)vfwprintf(stream1, format1, arg);
     // cppcheck-suppress uninitvar
-    (void)vfwprintf(stream, Format, Arg);
+    (void)vfwprintf(stream2, Format, Arg);
     // cppcheck-suppress uninitvar
     (void)vfwprintf(Stream, format2, Arg);
 
@@ -1433,7 +1852,7 @@ void uninitvar_fputwc(void)
 
 void uninitvar_fputws(void)
 {
-    wchar_t *string;
+    const wchar_t *string;
     FILE *stream;
     // cppcheck-suppress uninitvar
     (void)fputws(string,stream);
@@ -1452,15 +1871,15 @@ void uninitvar_fread(void)
 void uninitvar_free(void)
 {
     // cppcheck-suppress unassignedVariable
-    void *block;
+    const void *block;
     // cppcheck-suppress uninitvar
     free(block);
 }
 
 void uninitvar_freopen(void)
 {
-    char *filename;
-    char *mode;
+    const char *filename;
+    const char *mode;
     FILE *stream;
     // cppcheck-suppress uninitvar
     FILE * p = freopen(filename,mode,stream);
@@ -1503,7 +1922,7 @@ void uninitvar_hypot(void)
 void uninitvar_fscanf(void)
 {
     FILE *stream;
-    char *format;
+    const char *format;
     int i;
     // cppcheck-suppress uninitvar
     (void)fscanf(stream,format,i);
@@ -1512,7 +1931,7 @@ void uninitvar_fscanf(void)
 void uninitvar_vfscanf(void)
 {
     FILE *stream;
-    char * format;
+    const char * format;
     va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
@@ -1522,7 +1941,7 @@ void uninitvar_vfscanf(void)
 void uninitvar_vfwscanf(void)
 {
     FILE *stream;
-    wchar_t *format;
+    const wchar_t *format;
     va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
@@ -1557,7 +1976,7 @@ void uninitvar_fwide(void)
 
 void uninitvar_fwrite(void)
 {
-    void *ptr;
+    const void *ptr;
     size_t size;
     size_t nobj;
     FILE *stream;
@@ -1567,7 +1986,7 @@ void uninitvar_fwrite(void)
 
 void uninitvar_mblen(void)
 {
-    char *string;
+    const char *string;
     size_t size;
     // cppcheck-suppress uninitvar
     (void)mblen(string,size);
@@ -1576,7 +1995,7 @@ void uninitvar_mblen(void)
 void uninitvar_mbtowc(void)
 {
     wchar_t* pwc;
-    char* pmb;
+    const char* pmb;
     size_t max;
     // cppcheck-suppress uninitvar
     (void)mbtowc(pwc,pmb,max);
@@ -1584,13 +2003,13 @@ void uninitvar_mbtowc(void)
 
 void uninitvar_mbrlen(const char* p, size_t m, mbstate_t* s)
 {
-    char* pmb;
+    const char* pmb1, *pmb2;
     size_t max1, max2;
     mbstate_t* ps1, *ps2;
     // cppcheck-suppress uninitvar
-    (void)mbrlen(pmb,max1,ps1);
+    (void)mbrlen(pmb1,max1,ps1);
     // cppcheck-suppress uninitvar
-    (void)mbrlen(pmb,m,s);
+    (void)mbrlen(pmb2,m,s);
     // cppcheck-suppress uninitvar
     (void)mbrlen(p,max2,s);
     // cppcheck-suppress uninitvar
@@ -1617,28 +2036,49 @@ void uninitvar_btowc(void)
 
 void uninitvar_mbsinit(void)
 {
-    mbstate_t* ps;
+    const mbstate_t* ps;
     // cppcheck-suppress uninitvar
     (void)mbsinit(ps);
 }
 
-void uninitvar_mbstowcs(void)
+void uninitvar_mbstowcs(wchar_t* d, const char* s, size_t m)
 {
-    wchar_t *ws;
-    char *s;
-    size_t n;
+    wchar_t *dest;
+    const char *src;
+    size_t max;
+
     // cppcheck-suppress uninitvar
-    (void)mbstowcs(ws,s,n);
+    (void)mbstowcs(dest,s,m);
+    // cppcheck-suppress uninitvar
+    (void)mbstowcs(d,src,m);
+    // cppcheck-suppress uninitvar
+    (void)mbstowcs(d,s,max);
+
+    // No warning is expected
+    (void)mbstowcs(d,s,m);
+
+    wchar_t buf[100];
+    (void)mbstowcs(buf,s,100);
 }
 
-void uninitvar_mbsrtowcs(void)
+void uninitvar_mbsrtowcs(wchar_t* d, const char** s, size_t m, mbstate_t *p)
 {
     wchar_t* dest;
     const char* src;
     size_t max;
     mbstate_t* ps;
+
+    // cppcheck-suppress uninitvar
+    (void)mbsrtowcs(dest,s,m,p);
+    // cppcheck-suppress uninitvar
+    (void)mbsrtowcs(d,&src,m,p);
+    // cppcheck-suppress uninitvar
+    (void)mbsrtowcs(d,s,max,p);
     // cppcheck-suppress uninitvar
-    (void)mbsrtowcs(dest,&src,max,ps);
+    (void)mbsrtowcs(d,s,m,ps);
+
+    // No warning is expected
+    (void)mbsrtowcs(d,s,m,p);
 }
 
 void uninitvar_wctob(void)
@@ -1659,7 +2099,7 @@ void uninitvar_wctomb(void)
 void uninitvar_wcstombs(void)
 {
     char *mbstr;
-    wchar_t *wcstr;
+    const wchar_t *wcstr;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)wcstombs(mbstr,wcstr,n);
@@ -1697,11 +2137,13 @@ void uninitvar_ungetwc(void)
 
 void uninitvar_getenv(void)
 {
-    char *name;
+    const char *name;
     // cppcheck-suppress uninitvar
     (void)getenv(name);
 }
 
+#if defined(_WIN32) || (__STDC_VERSION__ < 201112L)
+// since glibc 2.16 gets() is no longer available starting when >= C11
 void uninitvar_gets(void)
 {
     char *buffer;
@@ -1709,10 +2151,11 @@ void uninitvar_gets(void)
     // cppcheck-suppress uninitvar
     (void)gets(buffer);
 }
+#endif
 
 void uninitvar_gmtime(void)
 {
-    time_t *tp;
+    const time_t *tp;
     // cppcheck-suppress uninitvar
     (void)gmtime(tp);
 }
@@ -1917,21 +2360,21 @@ void uninitvar_towupper(void)
 
 void uninitvar_wctrans(void)
 {
-    char* property;
+    const char* property;
     // cppcheck-suppress uninitvar
     (void)wctrans(property);
 }
 
 void uninitvar_wctype(void)
 {
-    char* property;
+    const char* property;
     // cppcheck-suppress uninitvar
     (void)wctype(property);
 }
 
 void ignorereturn(void)
 {
-    char szNumbers[] = "2001 60c0c0 -1101110100110100100000 0x6fffff";
+    const char szNumbers[] = "2001 60c0c0 -1101110100110100100000 0x6fffff";
     char * pEnd;
     strtol(szNumbers,&pEnd,10);
 }
@@ -2122,7 +2565,7 @@ void uninitvar_ldiv(void)
 
 void uninitvar_localtime(void)
 {
-    time_t *tp;
+    const time_t *tp;
     // cppcheck-suppress uninitvar
     (void)localtime(tp);
 }
@@ -2309,13 +2752,13 @@ void uninitvar_islessgreater(void)
 
 void uninitvar_nan(void)
 {
-    char *tagp;
+    const char *tagp1, *tagp2, *tagp3;
     // cppcheck-suppress uninitvar
-    (void)nanf(tagp);
+    (void)nanf(tagp1);
     // cppcheck-suppress uninitvar
-    (void)nan(tagp);
+    (void)nan(tagp2);
     // cppcheck-suppress uninitvar
-    (void)nanl(tagp);
+    (void)nanl(tagp3);
 }
 
 void uninitvar_isnan(void)
@@ -2455,6 +2898,7 @@ void uninitvar_longjmp(void)
 void uninitvar_malloc(void)
 {
     size_t size;
+    // cppcheck-suppress unusedAllocatedMemory
     // cppcheck-suppress uninitvar
     int *p = (int*)malloc(size);
     free(p);
@@ -2470,16 +2914,25 @@ void uninitvar_alloca(void)
 
 void uninitvar_memchr(void)
 {
-    void *cs;
+    const void *cs;
     int c;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)memchr(cs,c,n);
 }
 
+void *bufferAccessOutOfBounds_memchr(const void *s, int c, size_t n)
+{
+    const char buf[42]={0};
+    (void)memchr(buf,c,42);
+    // cppcheck-suppress bufferAccessOutOfBounds
+    (void)memchr(buf,c,43);
+    return memchr(s,c,n);
+}
+
 void uninitvar_wmemchr(void)
 {
-    wchar_t *cs;
+    const wchar_t *cs;
     wchar_t c;
     size_t n;
     // cppcheck-suppress uninitvar
@@ -2488,8 +2941,8 @@ void uninitvar_wmemchr(void)
 
 void uninitvar_memcmp(void)
 {
-    void *s1;
-    void *s2;
+    const void *s1;
+    const void *s2;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)memcmp(s1,s2,n);
@@ -2497,8 +2950,8 @@ void uninitvar_memcmp(void)
 
 void uninitvar_wmemcmp(void)
 {
-    wchar_t *s1;
-    wchar_t *s2;
+    const wchar_t *s1;
+    const wchar_t *s2;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)wmemcmp(s1,s2,n);
@@ -2507,7 +2960,7 @@ void uninitvar_wmemcmp(void)
 void uninitvar_memcpy(void)
 {
     void *ct;
-    void *cs;
+    const void *cs;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)memcpy(ct,cs,n);
@@ -2516,7 +2969,7 @@ void uninitvar_memcpy(void)
 void uninitvar_wmemcpy(void)
 {
     wchar_t *cs;
-    wchar_t *c;
+    const wchar_t *c;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)wmemcpy(cs,c,n);
@@ -2552,7 +3005,7 @@ void uninitvar_memset(void)
 void uninitvar_wmemset(void)
 {
     wchar_t *cs;
-    wchar_t  c;
+    wchar_t c;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)wmemset(cs,c,n);
@@ -2563,10 +3016,6 @@ void uninitvar_mktime(void)
     struct tm *tp;
     // cppcheck-suppress uninitvar
     (void)mktime(tp);
-
-    struct tmx *tpx;
-    // cppcheck-suppress uninitvar
-    (void)mkxtime(tpx);
 }
 
 void uninitvar_modf(void)
@@ -2589,7 +3038,7 @@ void uninitvar_modf(void)
 
 void uninitvar_perror(void)
 {
-    char *string;
+    const char *string;
     // cppcheck-suppress uninitvar
     (void)perror(string);
 }
@@ -2657,9 +3106,9 @@ void uninitvar_remquo(void)
     (void)remquol(ld1,ld2,i3);
 }
 
-void uninitvar_printf(char *Format, int Argument)
+void uninitvar_printf(const char *Format, int Argument)
 {
-    char * format_1, * format_2, * format_3;
+    const char * format_1, * format_2, * format_3;
     int argument1, argument2;
     // no warning is expected
     (void)printf("x");
@@ -2676,9 +3125,9 @@ void uninitvar_printf(char *Format, int Argument)
     (void)printf(Format,Argument);
 }
 
-void uninitvar_vprintf(char *Format, va_list Arg)
+void uninitvar_vprintf(const char *Format, va_list Arg)
 {
-    char * format1, *format2;
+    const char * format1, *format2;
     va_list arg1, arg2;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
@@ -2692,10 +3141,22 @@ void uninitvar_vprintf(char *Format, va_list Arg)
     (void)vprintf(Format,arg2);
 }
 
-void uninitvar_vwprintf(wchar_t *Format, va_list Arg)
+#if defined(_WIN32) || (__STDC_VERSION__ < 199901L)
+// strdup() is POSIX since glibc 2.10 - it is also not available on Linux compiler starting with C99
+void memleak_strdup (const char *s) // #9328
 {
-    wchar_t * format1, * format2;
-    va_list arg;
+    const char *s1 = strdup(s);
+    // cppcheck-suppress nullPointerOutOfMemory
+    printf("%s",s1);
+    free(s);     // s1 is not freed
+    // cppcheck-suppress memleak
+}
+#endif
+
+void uninitvar_vwprintf(const wchar_t *Format, va_list Arg)
+{
+    const wchar_t * format1, * format2;
+    va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
     (void)vwprintf(format1,arg);
@@ -2708,14 +3169,24 @@ void uninitvar_vwprintf(wchar_t *Format, va_list Arg)
     (void)vwprintf(Format,arg);
 }
 
+void nullPointer_bsearch(const void* key, const void* base, size_t num, size_t size)
+{
+    // cppcheck-suppress nullPointer
+    (void)bsearch(NULL,base,num,size,(int (*)(const void*,const void*))strcmp);
+    // cppcheck-suppress nullPointer
+    (void)bsearch(key,NULL,num,size,(int (*)(const void*,const void*))strcmp);
+    // No warning is expected
+    (void)bsearch(key,base,num,size,(int (*)(const void*,const void*))strcmp);
+}
+
 void uninitvar_bsearch(void)
 {
-    void* key;
-    void* base;
+    const void* key;
+    const void* base;
     size_t num;
     size_t size;
     // cppcheck-suppress uninitvar
-    (void)bsearch(key,base,num,size,(int(*)(const void*,const void*)) strcmp);
+    (void)bsearch(key,base,num,size,(int (*)(const void*,const void*))strcmp);
 }
 
 void uninitvar_qsort(void)
@@ -2724,7 +3195,7 @@ void uninitvar_qsort(void)
     size_t n;
     size_t size;
     // cppcheck-suppress uninitvar
-    (void)qsort(base,n,size, (int(*)(const void*,const void*)) strcmp);
+    (void)qsort(base,n,size, (int (*)(const void*,const void*))strcmp);
 }
 
 void uninitvar_putc(void)
@@ -2761,15 +3232,15 @@ void uninitvar_realloc(void)
 
 void uninitvar_remove(void)
 {
-    char *s;
+    const char *s;
     // cppcheck-suppress uninitvar
     (void)remove(s);
 }
 
 void uninitvar_rename(void)
 {
-    char *s1;
-    char *s2;
+    const char *s1;
+    const char *s2;
     // cppcheck-suppress uninitvar
     (void)rename(s1,s2);
 }
@@ -2855,16 +3326,20 @@ void uninitvar_raise(void)
 
 void uninitvar_scanf(void)
 {
-    char *format;
+    const char *format;
     char str[42];
     // cppcheck-suppress uninitvar
     (void)scanf(format, str);
+
+    // no warning is expected (#9347)
+    int i;
+    sscanf("0", "%d", &i);
 }
 
 void uninitvar_vsscanf(void)
 {
-    char *s;
-    char *format;
+    const char *s;
+    const char *format;
     va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
@@ -2873,8 +3348,8 @@ void uninitvar_vsscanf(void)
 
 void uninitvar_vswscanf(void)
 {
-    wchar_t *s;
-    wchar_t *format;
+    const wchar_t *s;
+    const wchar_t *format;
     va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
@@ -2883,7 +3358,7 @@ void uninitvar_vswscanf(void)
 
 void uninitvar_vscanf(void)
 {
-    char *format;
+    const char *format;
     va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
@@ -2892,19 +3367,43 @@ void uninitvar_vscanf(void)
 
 void uninitvar_vwscanf(void)
 {
-    wchar_t *format;
+    const wchar_t *format;
     va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
     (void)vwscanf(format,arg);
 }
 
+void nullPointer_setbuf(FILE *stream, char *buf)
+{
+    // cppcheck-suppress nullPointer
+    setbuf(NULL,buf);
+    setbuf(stream,NULL);
+    setbuf(stream,buf);
+}
+
+int bufferAccessOutOfBounds_setvbuf(FILE* stream, int mode, size_t size)
+{
+    char buf[42]={0};
+    // cppcheck-suppress bufferAccessOutOfBounds
+    (void) setvbuf(stream, buf, mode, 43);
+    return setvbuf(stream, buf, mode, 42);
+}
+
+int nullPointer_setvbuf(FILE* stream, char *buf, int mode, size_t size)
+{
+    // cppcheck-suppress nullPointer
+    (void) setvbuf(NULL, buf, mode, size);
+    (void) setvbuf(stream, NULL, mode, size);
+    return setvbuf(stream, buf, mode, size);
+}
+
 void uninitvar_setbuf(void)
 {
     FILE *stream;
     char *buf;
     // cppcheck-suppress uninitvar
-    (void)setbuf(stream,buf);
+    setbuf(stream,buf);
 }
 
 void uninitvar_setvbuf(void)
@@ -2920,11 +3419,11 @@ void uninitvar_setvbuf(void)
 void uninitvar_strcat(char *dest, const char * const source)
 {
     char *deststr1, *deststr2;
-    char *srcstr;
+    const char *srcstr1, *srcstr2;
     // cppcheck-suppress uninitvar
-    (void)strcat(deststr1,srcstr);
+    (void)strcat(deststr1,srcstr1);
     // cppcheck-suppress uninitvar
-    (void)strcat(dest,srcstr);
+    (void)strcat(dest,srcstr2);
     // cppcheck-suppress uninitvar
     (void)strcat(deststr2,source);
 
@@ -2932,12 +3431,34 @@ void uninitvar_strcat(char *dest, const char * const source)
     (void)strcat(dest,source);
 }
 
+void nullPointer_strcpy(char *dest, const char * const source)
+{
+    // cppcheck-suppress nullPointer
+    (void)strcpy(NULL,source);
+    // cppcheck-suppress nullPointer
+    (void)strcpy(dest,NULL);
+
+    // no warning shall be shown for
+    (void)strcpy(dest,source);
+}
+
+void nullPointer_strcat(char *dest, const char * const source)
+{
+    // cppcheck-suppress nullPointer
+    (void)strcat(NULL,source);
+    // cppcheck-suppress nullPointer
+    (void)strcat(dest,NULL);
+
+    // no warning shall be shown for
+    (void)strcat(dest,source);
+}
+
 void bufferAccessOutOfBounds_strcat(char *dest, const char * const source)
 {
     char buf4[4] = {0};
     const char * const srcstr3 = "123";
     const char * const srcstr4 = "1234";
-    // @todo #8599 cppcheck-suppress bufferAccessOutOfBounds
+    // cppcheck-suppress bufferAccessOutOfBounds
     (void)strcat(buf4,srcstr4); // off by one issue: strcat is appends \0' at the end
 
     // no warning shall be shown for
@@ -2949,7 +3470,7 @@ void bufferAccessOutOfBounds_strcat(char *dest, const char * const source)
 void uninitvar_wcscat(wchar_t *dest, const wchar_t * const source)
 {
     wchar_t *deststr_1, *deststr_2;
-    wchar_t *srcstr_1, *srcstr_2;
+    const wchar_t *srcstr_1, *srcstr_2;
     // cppcheck-suppress uninitvar
     (void)wcscat(deststr_1,srcstr_1);
     // cppcheck-suppress uninitvar
@@ -2972,13 +3493,13 @@ void uninitvar_wcrtomb(void)
 
 void uninitvar_strchr(void)
 {
-    char *cs;
+    const char *cs;
     int c;
     // cppcheck-suppress uninitvar
     (void)strchr(cs,c);
 }
 
-void invalidFunctionArg_strchr(char *cs, int c)
+void invalidFunctionArg_strchr(const char *cs, int c)
 {
     // cppcheck-suppress invalidFunctionArg
     (void)strchr(cs,-1);
@@ -2991,108 +3512,271 @@ void invalidFunctionArg_strchr(char *cs, int c)
     (void)strchr(cs, 256);
 }
 
+void invalidFunctionArg_log10(float f, double d, const long double ld)
+{
+    // cppcheck-suppress invalidFunctionArg
+    // cppcheck-suppress wrongmathcall
+    (void)log10f(0.0f);
+    (void)log10f(1.4013e-45f); // note: calculated by nextafterf(0.0f, 1.0f);
+    (void)log10f(f);
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
+    (void)log10f(FLT_MAX);
+
+    // cppcheck-suppress invalidFunctionArg
+    // cppcheck-suppress wrongmathcall
+    (void)log10(0.0);
+    (void)log10(4.94066e-324); // note: calculated by nextafterf(0.0, 1.0);
+    (void)log10(d);
+    (void)log10(DBL_MAX);
+
+    // cppcheck-suppress invalidFunctionArg
+    // cppcheck-suppress wrongmathcall
+    (void)log10l(0.0L);
+    (void)log10l(4.94066e-324L); // note: calculated by nextafterf(0.0L, 1.0L);
+    (void)log10l(ld);
+    (void)log10l(LDBL_MAX);
+}
+
+void invalidFunctionArg_log(float f, double d, const long double ld)
+{
+    // cppcheck-suppress invalidFunctionArg
+    // cppcheck-suppress wrongmathcall
+    (void)logf(0.0f);
+    (void)logf(1.4013e-45f); // note: calculated by nextafterf(0.0f, 1.0f);
+    (void)logf(f);
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
+    (void)logf(FLT_MAX);
+
+    // cppcheck-suppress invalidFunctionArg
+    // cppcheck-suppress wrongmathcall
+    (void)log(0.0);
+    (void)log(4.94066e-324); // note: calculated by nextafterf(0.0, 1.0);
+    (void)log(d);
+    (void)log(DBL_MAX);
+
+    // cppcheck-suppress invalidFunctionArg
+    // cppcheck-suppress wrongmathcall
+    (void)logl(0.0L);
+    (void)logl(4.94066e-324L); // note: calculated by nextafterf(0.0L, 1.0L);
+    (void)logl(ld);
+    (void)logl(LDBL_MAX);
+}
+
+void invalidFunctionArg_log2(float f, double d, const long double ld)
+{
+    // cppcheck-suppress invalidFunctionArg
+    // cppcheck-suppress wrongmathcall
+    (void)log2f(0.0f);
+    (void)log2f(1.4013e-45f); // note: calculated by nextafterf(0.0f, 1.0f);
+    (void)log2f(f);
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
+    (void)log2f(FLT_MAX);
+
+    // cppcheck-suppress invalidFunctionArg
+    // cppcheck-suppress wrongmathcall
+    (void)log2(0.0);
+    (void)log2(4.94066e-324); // note: calculated by nextafterf(0.0, 1.0);
+    (void)log2(d);
+    (void)log2(DBL_MAX);
+
+    // cppcheck-suppress invalidFunctionArg
+    // cppcheck-suppress wrongmathcall
+    (void)log2l(0.0L);
+    (void)log2l(4.94066e-324L); // note: calculated by nextafterf(0.0L, 1.0L);
+    (void)log2l(ld);
+    (void)log2l(LDBL_MAX);
+}
+
 void uninitvar_wcschr(void)
 {
-    wchar_t *cs;
+    const wchar_t *cs;
     wchar_t c;
     // cppcheck-suppress uninitvar
     (void)wcschr(cs,c);
 }
 
-void uninitvar_strcmp(void)
+void nullPointer_strcmp(const char *s1, const char *s2)
 {
-    char *str1;
-    char *str2;
+    // cppcheck-suppress nullPointer
+    (void)strcmp(NULL,s2);
+    // cppcheck-suppress nullPointer
+    (void)strcmp(s1,NULL);
+    (void)strcmp(s1,s2);
+}
+
+void uninitvar_strcmp(const char *s1, const char *s2)
+{
+    const char *str1;
+    const char *str2;
+    const char *str3;
+    const char *str4;
+
+    // cppcheck-suppress uninitvar
+    (void)strcmp(str1,s2);
     // cppcheck-suppress uninitvar
-    (void)strcmp(str1,str2);
+    (void)strcmp(s1,str2);
+    // cppcheck-suppress uninitvar
+    (void)strcmp(str3,str4);
+
+    // No warning is expected
+    (void)strcmp(s1,s2);
 }
 
-void uninitvar_wcscmp(void)
+void uninitvar_wcscmp(const wchar_t *s1, const wchar_t *s2)
 {
-    wchar_t *str1;
-    wchar_t *str2;
+    const wchar_t *str1;
+    const wchar_t *str2;
+    const wchar_t *str3;
+    const wchar_t *str4;
+
     // cppcheck-suppress uninitvar
-    (void)wcscmp(str1,str2);
+    (void)wcscmp(str1,s2);
+    // cppcheck-suppress uninitvar
+    (void)wcscmp(s1,str2);
+    // cppcheck-suppress uninitvar
+    (void)wcscmp(str3,str4);
+
+    // No warning is expected
+    (void)wcscmp(s1,s2);
 }
 
-void uninitvar_strcpy(void)
+void uninitvar_strcpy(char *d, const char *s)
 {
-    char *str1;
-    char *str2;
+    char *dest1, *dest2;
+    const char *src1, *src2;
+
+    // cppcheck-suppress uninitvar
+    (void)strcpy(dest1,s);
+    // cppcheck-suppress uninitvar
+    (void)strcpy(d,src1);
     // cppcheck-suppress uninitvar
-    (void)strcpy(str1,str2);
+    (void)strcpy(dest2,src2);
+
+    // No warning is expected
+    (void)strcpy(d,s);
 }
 
-void uninitvar_strcpy_s(char * strDest)
+#ifdef __STDC_LIB_EXT1__
+void uninitvar_strcpy_s(char * strDest, ssize_t s, const char *source)
 {
     char *strUninit1;
-    char *strUninit2;
+    const char *strUninit2;
+    ssize_t size;
+
     // cppcheck-suppress uninitvar
     (void)strcpy_s(strUninit1, 1, "a");
     // cppcheck-suppress uninitvar
     (void)strcpy_s(strDest, 1, strUninit2);
+    // cppcheck-suppress uninitvar
+    (void)strcpy_s(strDest, size, "a");
+
+    // No warning is expected
+    (void)strcpy_s(strDest, s, source);
 }
+#endif
 
-void uninitvar_wcscpy(void)
+void uninitvar_wcscpy(wchar_t *d, const wchar_t*s)
 {
-    wchar_t *str1;
-    wchar_t *str2;
+    wchar_t *dest1, *dest2;
+    const wchar_t *src1, *src2;
+
     // cppcheck-suppress uninitvar
-    (void)wcscpy(str1,str2);
+    (void)wcscpy(dest1,s);
+    // cppcheck-suppress uninitvar
+    (void)wcscpy(d,src1);
+    // cppcheck-suppress uninitvar
+    (void)wcscpy(dest2,src2);
+
+    // No warning is expected
+    (void)wcscpy(d,s);
+}
+
+size_t bufferAccessOutOfBounds_strftime(char *s, size_t max, const char *fmt, const struct tm *p)
+{
+    char buf[42] = {0};
+    // cppcheck-suppress bufferAccessOutOfBounds
+    (void) strftime(buf,43,fmt,p);
+    (void) strftime(buf,max,fmt,p);
+    return strftime(buf,42,fmt,p);
+}
+
+size_t nullPointer_strftime(char *s, size_t max, const char *fmt, const struct tm *p)
+{
+    // cppcheck-suppress nullPointer
+    (void) strftime(NULL,max,fmt,p);
+    // cppcheck-suppress nullPointer
+    (void) strftime(s,max,NULL,p);
+    // cppcheck-suppress nullPointer
+    (void) strftime(s,max,fmt,NULL);
+    return strftime(s,max,fmt,p);
 }
 
 void uninitvar_strftime(void)
 {
     char *s;
     size_t max;
-    char *fmt;
-    struct tm *p;
+    const char *fmt;
+    const struct tm *p;
     // cppcheck-suppress uninitvar
     (void)strftime(s,max,fmt,p);
-
-    struct tmx *px;
-    // cppcheck-suppress uninitvar
-    (void)strfxtime(s,max,fmt,px);
 }
 
-void uninitvar_strlen(void)
+void uninitvar_strlen(const char *str)
 {
-    char *s;
+    const char *s;
     // cppcheck-suppress uninitvar
     (void)strlen(s);
+
+    const char x;
+    const char *xPtr = &x;
+    // cppcheck-suppress uninitvar
+    (void)strlen(xPtr);
+
+    // No warning is expected
+    (void)strlen(str);
 }
 
 void uninitvar_wcslen(void)
 {
-    wchar_t *s;
+    const wchar_t *s;
     // cppcheck-suppress uninitvar
     (void)wcslen(s);
 }
 
-void uninitvar_strncpy(void)
+//char * strncpy ( char * destination, const char * source, size_t num );
+void uninitvar_strncpy(char * dest, const char * src, size_t num)
 {
-    char *s;
-    char *ct;
+    char *d;
+    const char *s;
     size_t n;
+
+    // cppcheck-suppress uninitvar
+    (void)strncpy(d,src,num);
+    // cppcheck-suppress uninitvar
+    (void)strncpy(dest,s,num);
     // cppcheck-suppress uninitvar
-    (void)strncpy(s,ct,n);
+    (void)strncpy(dest,src,n);
+
+    // No warning is expected for
+    (void)strncpy(dest,src,num);
 }
 
-void uninitvar_strncpy_s(char *Ct, size_t N1, char *S, size_t N2)
+#ifdef __STDC_LIB_EXT1__
+void uninitvar_strncpy_s(char *Ct, size_t N1, const char *S, size_t N2)
 {
     char dest[42];
-    char *s;
+    const char *s1, *s2;
     size_t n1;
     size_t n2;
     size_t n3;
     size_t n4;
 
     // cppcheck-suppress uninitvar
-    (void)strncpy_s(dest,n1,s,n2);
+    (void)strncpy_s(dest,n1,s1,n2);
     // cppcheck-suppress uninitvar
     (void)strncpy_s(Ct,n3,S,N2);
     // cppcheck-suppress uninitvar
-    (void)strncpy_s(Ct,N1,s,N2);
+    (void)strncpy_s(Ct,N1,s2,N2);
     // cppcheck-suppress uninitvar
     (void)strncpy_s(Ct,N1,S,n4);
 
@@ -3100,45 +3784,67 @@ void uninitvar_strncpy_s(char *Ct, size_t N1, char *S, size_t N2)
     (void)strncpy_s(Ct,N1,S,N2);
     (void)strncpy_s(dest,N1,S,N2);
 }
+#endif
 
 void uninitvar_strpbrk(void)
 {
-    char *cs;
-    char *ct;
+    const char *cs;
+    const char *ct;
     // cppcheck-suppress uninitvar
     (void)strpbrk(cs,ct);
 }
 
-void uninitvar_strncat(char *Ct, char *S, size_t N)
+// char * strncat ( char * destination, const char * source, size_t num );
+void uninitvar_strncat(char *d, const char *s, size_t n)
 {
-    char *ct_1, *ct_2;
-    char *s;
-    size_t n1, n2;
-    // cppcheck-suppress uninitvar
-    (void)strncat(ct_1,s,n1);
+    char *dest;
+    const char *src;
+    size_t num;
+
     // cppcheck-suppress uninitvar
-    (void)strncat(ct_2,S,N);
+    (void)strncat(dest,s,n);
     // cppcheck-suppress uninitvar
-    (void)strncat(Ct,s,N);
+    (void)strncat(d,src,n);
     // cppcheck-suppress uninitvar
-    (void)strncat(Ct,S,n2);
+    (void)strncat(d,s,num);
+
+    // no warning is expected for
+    (void)strncat(d,s,n);
+}
 
+void nullPointer_strncat(char *d, const char *s, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)strncat(NULL,s,n);
+    // cppcheck-suppress nullPointer
+    (void)strncat(d,NULL,n);
     // no warning is expected for
-    (void)strncat(Ct,S,N);
+    (void)strncat(d,s,n);
 }
 
+void nullPointer_strncpy(char *d, const char *s, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)strncpy(NULL,s,n);
+    // cppcheck-suppress nullPointer
+    (void)strncpy(d,NULL,n);
+    // no warning is expected for
+    (void)strncpy(d,s,n);
+}
+
+#ifdef __STDC_LIB_EXT1__
 // errno_t strcat_s(char *restrict dest, rsize_t destsz, const char *restrict src); // since C11
-void uninitvar_strcat_s(char *Ct, size_t N, char *S)
+void uninitvar_strcat_s(char *Ct, size_t N, const char *S)
 {
     char *ct_1, *ct_2;
-    char *s;
+    const char *s1, *s2;
     size_t n1, n2;
     // cppcheck-suppress uninitvar
-    (void)strcat_s(ct_1,n1,s);
+    (void)strcat_s(ct_1,n1,s1);
     // cppcheck-suppress uninitvar
     (void)strcat_s(ct_2,N,S);
     // cppcheck-suppress uninitvar
-    (void)strcat_s(Ct,N,s);
+    (void)strcat_s(Ct,N,s2);
     // cppcheck-suppress uninitvar
     (void)strcat_s(Ct,n2,S);
 
@@ -3147,17 +3853,17 @@ void uninitvar_strcat_s(char *Ct, size_t N, char *S)
 }
 
 // errno_t wcscat_s(wchar_t *restrict dest, rsize_t destsz, const wchar_t *restrict src); // since C11
-void uninitvar_wcscat_s(wchar_t *Ct, size_t N, wchar_t *S)
+void uninitvar_wcscat_s(wchar_t *Ct, size_t N, const wchar_t *S)
 {
     wchar_t *ct_1, *ct_2;
-    wchar_t *s;
+    const wchar_t *s1, *s2;
     size_t n1, n2;
     // cppcheck-suppress uninitvar
-    (void)wcscat_s(ct_1,n1,s);
+    (void)wcscat_s(ct_1,n1,s1);
     // cppcheck-suppress uninitvar
     (void)wcscat_s(ct_2,N,S);
     // cppcheck-suppress uninitvar
-    (void)wcscat_s(Ct,N,s);
+    (void)wcscat_s(Ct,N,s2);
     // cppcheck-suppress uninitvar
     (void)wcscat_s(Ct,n2,S);
 
@@ -3165,41 +3871,42 @@ void uninitvar_wcscat_s(wchar_t *Ct, size_t N, wchar_t *S)
     (void) wcscat_s(Ct,N,S);
 }
 
-void uninitvar_strncat_s(char *Ct, size_t N1, char *S, size_t N2)
+void uninitvar_strncat_s(char *Ct, size_t N1, const char *S, size_t N2)
 {
     char *ct_1, *ct_2;
-    char *s;
+    const char *s1, *s2;
     size_t n1;
     size_t n2;
     size_t n3;
     size_t n4;
 
     // cppcheck-suppress uninitvar
-    (void)strncat_s(ct_1,n1,s,n2);
+    (void)strncat_s(ct_1,n1,s1,n2);
     // cppcheck-suppress uninitvar
     (void)strncat_s(ct_2,N1,S,N2);
     // cppcheck-suppress uninitvar
     (void)strncat_s(Ct,n3,S,N2);
     // cppcheck-suppress uninitvar
-    (void)strncat_s(Ct,N1,s,N2);
+    (void)strncat_s(Ct,N1,s2,N2);
     // cppcheck-suppress uninitvar
     (void)strncat_s(Ct,N1,S,n4);
 
     // no warning is expected for
     (void)strncat_s(Ct,N1,S,N2);
 }
+#endif
 
-void uninitvar_wcsncat(wchar_t *Ct, wchar_t *S, size_t N)
+void uninitvar_wcsncat(wchar_t *Ct, const wchar_t *S, size_t N)
 {
     wchar_t *ct_1, *ct_2;
-    wchar_t *s;
+    const wchar_t *s1, *s2;
     size_t n1, n2;
     // cppcheck-suppress uninitvar
-    (void)wcsncat(ct_1,s,n1);
+    (void)wcsncat(ct_1,s1,n1);
     // cppcheck-suppress uninitvar
     (void)wcsncat(ct_2,S,N);
     // cppcheck-suppress uninitvar
-    (void)wcsncat(Ct,s,N);
+    (void)wcsncat(Ct,s2,N);
     // cppcheck-suppress uninitvar
     (void)wcsncat(Ct,S,n2);
 
@@ -3207,35 +3914,34 @@ void uninitvar_wcsncat(wchar_t *Ct, wchar_t *S, size_t N)
     (void)wcsncat(Ct,S,N);
 }
 
-void uninitvar_strncmp(char *Ct, char *S, size_t N)
+void uninitvar_strncmp(const char *Ct, const char *S, size_t N)
 {
-    char *ct;
-    char *s;
-    size_t n1, n2;
-    // cppcheck-suppress uninitvar
-    (void)strncmp(ct,s,n1);
+    const char *ct;
+    const char *s;
+    size_t n1;
+
     // cppcheck-suppress uninitvar
     (void)strncmp(ct,S,N);
     // cppcheck-suppress uninitvar
     (void)strncmp(Ct,s,N);
     // cppcheck-suppress uninitvar
-    (void)strncmp(Ct,S,n2);
+    (void)strncmp(Ct,S,n1);
 
     // no warning is expected for
     (void)strncmp(Ct,S,N);
 }
 
-void uninitvar_wcsncmp(wchar_t *Ct, wchar_t *S, size_t N)
+void uninitvar_wcsncmp(const wchar_t *Ct, const wchar_t *S, size_t N)
 {
-    wchar_t *ct;
-    wchar_t *s;
+    const wchar_t *ct1, *ct2;
+    const wchar_t *s1, *s2;
     size_t n1, n2;
     // cppcheck-suppress uninitvar
-    (void)wcsncmp(ct,s,n1);
+    (void)wcsncmp(ct1,s1,n1);
     // cppcheck-suppress uninitvar
-    (void)wcsncmp(ct,S,N);
+    (void)wcsncmp(ct2,S,N);
     // cppcheck-suppress uninitvar
-    (void)wcsncmp(Ct,s,N);
+    (void)wcsncmp(Ct,s2,N);
     // cppcheck-suppress uninitvar
     (void)wcsncmp(Ct,S,n2);
 
@@ -3245,24 +3951,24 @@ void uninitvar_wcsncmp(wchar_t *Ct, wchar_t *S, size_t N)
 
 void uninitvar_strstr(void)
 {
-    char *cs;
-    char *ct;
+    const char *cs;
+    const char *ct;
     // cppcheck-suppress uninitvar
     (void)strstr(cs,ct);
 }
 
 void uninitvar_wcsstr(void)
 {
-    wchar_t *cs;
-    wchar_t *ct;
+    const wchar_t *cs;
+    const wchar_t *ct;
     // cppcheck-suppress uninitvar
     (void)wcsstr(cs,ct);
 }
 
 void uninitvar_strspn(void)
 {
-    char *cs;
-    char *ct;
+    const char *cs;
+    const char *ct;
     // cppcheck-suppress uninitvar
     (void)strspn(cs,ct);
 }
@@ -3270,16 +3976,98 @@ void uninitvar_strspn(void)
 void uninitvar_strxfrm(void)
 {
     char *ds;
-    char *ss;
+    const char *ss;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)strxfrm(ds,ss,n);
 }
 
+void bufferAccessOutOfBounds_strxfrm(void)
+{
+    const char src[3] = "abc";
+    char dest[1] = "a";
+    // cppcheck-suppress invalidFunctionArgStr
+    (void)strxfrm(dest,src,1);
+    // cppcheck-suppress [bufferAccessOutOfBounds,invalidFunctionArgStr]
+    (void)strxfrm(dest,src,2);
+    // cppcheck-suppress [bufferAccessOutOfBounds,invalidFunctionArgStr]
+    (void)strxfrm(dest,src,3);
+}
+
+void bufferAccessOutOfBounds_strncmp(void)
+{
+    const char src[3] = "abc";
+    const char dest[1] = "a";
+    (void)strncmp(dest,src,1);
+    (void)strncmp(dest,src,2);
+    (void)strncmp(dest,src,3);
+}
+
+void nullPointer_wmemcmp(const wchar_t* s1, const wchar_t* s2, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)wmemcmp(NULL,s2,n);
+    // cppcheck-suppress nullPointer
+    (void)wmemcmp(s1,NULL,n);
+    (void)wmemcmp(s1,s2,n);
+}
+
+void nullPointer_wmemmove(wchar_t* s1, const wchar_t* s2, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)wmemmove(NULL,s2,n);
+    // cppcheck-suppress nullPointer
+    (void)wmemmove(s1,NULL,n);
+    (void)wmemmove(s1,s2,n);
+}
+
+void nullPointer_wmemset(wchar_t* s, wchar_t c, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)wmemset(NULL,c,n);
+    (void)wmemset(s,c,n);
+}
+
+void nullPointer_memmove(void *s1, void *s2, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)memmove(NULL,s2,n);
+    // cppcheck-suppress nullPointer
+    (void)memmove(s1,NULL,n);
+    (void)memmove(s1,s2,n);
+}
+
+void nullPointer_memcmp(const void *s1, const void *s2, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)memcmp(NULL,s2,n);
+    // cppcheck-suppress nullPointer
+    (void)memcmp(s1,NULL,n);
+    (void)memcmp(s1,s2,n);
+}
+
+void nullPointer_memcpy(void *s1, const void *s2, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)memcpy(NULL,s2,n);
+    // cppcheck-suppress nullPointer
+    (void)memcpy(s1,NULL,n);
+    (void)memcpy(s1,s2,n);
+}
+
+void nullPointer_strncmp(const char *s1, const char *s2, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)strncmp(NULL,s2,n);
+    // cppcheck-suppress nullPointer
+    (void)strncmp(s1,NULL,n);
+    (void)strncmp(s1,s2,n);
+}
+
 void uninitvar_wcsxfrm(void)
 {
     wchar_t *ds;
-    wchar_t *ss;
+    const wchar_t *ss;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)wcsxfrm(ds,ss,n);
@@ -3287,8 +4075,8 @@ void uninitvar_wcsxfrm(void)
 
 void uninitvar_wcsspn(void)
 {
-    wchar_t *ds;
-    wchar_t *ss;
+    const wchar_t *ds;
+    const wchar_t *ss;
     // cppcheck-suppress uninitvar
     (void)wcsspn(ds,ss);
 }
@@ -3296,7 +4084,7 @@ void uninitvar_wcsspn(void)
 void uninitvar_setlocale(void)
 {
     int category;
-    char* locale;
+    const char* locale;
     // cppcheck-suppress uninitvar
     (void)setlocale(category,locale);
 }
@@ -3310,24 +4098,24 @@ void uninitvar_strerror(void)
 
 void uninitvar_strcspn(void)
 {
-    char *cs;
-    char *ct;
+    const char *cs;
+    const char *ct;
     // cppcheck-suppress uninitvar
     (void)strcspn(cs,ct);
 }
 
 void uninitvar_wcscspn(void)
 {
-    wchar_t *cs;
-    wchar_t *ct;
+    const wchar_t *cs;
+    const wchar_t *ct;
     // cppcheck-suppress uninitvar
     (void)wcscspn(cs,ct);
 }
 
 void uninitvar_wcspbrk(void)
 {
-    wchar_t *cs;
-    wchar_t *ct;
+    const wchar_t *cs;
+    const wchar_t *ct;
     // cppcheck-suppress uninitvar
     (void)wcspbrk(cs,ct);
 }
@@ -3335,7 +4123,7 @@ void uninitvar_wcspbrk(void)
 void uninitvar_wcsncpy(void)
 {
     wchar_t *cs;
-    wchar_t *ct;
+    const wchar_t *ct;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)wcsncpy(cs,ct,n);
@@ -3343,31 +4131,39 @@ void uninitvar_wcsncpy(void)
 
 void uninitvar_strcoll(void)
 {
-    char *cs;
-    char *ct;
+    const char *cs;
+    const char *ct;
     // cppcheck-suppress uninitvar
     (void)strcoll(cs,ct);
 }
 
 void uninitvar_wcscoll(void)
 {
-    wchar_t *cs;
-    wchar_t *ct;
+    const wchar_t *cs;
+    const wchar_t *ct;
     // cppcheck-suppress uninitvar
     (void)wcscoll(cs,ct);
 }
 
-void uninitvar_strrchr(void)
+//const char * strrchr ( const char * str, int character );
+//      char * strrchr (       char * str, int character );
+void uninitvar_strrchr(const char * s, int c)
 {
-    char * str;
-    int c;
+    const char * str;
+    int character;
+
     // cppcheck-suppress uninitvar
     (void)strrchr(str,c);
+    // cppcheck-suppress uninitvar
+    (void)strrchr(s,character);
+
+    // No warning is expected for
+    (void)strrchr(s,c);
 }
 
 void uninitvar_wcsrchr(void)
 {
-    wchar_t* ws;
+    const wchar_t* ws;
     wchar_t wc;
     // cppcheck-suppress uninitvar
     (void)wcsrchr(ws,wc);
@@ -3386,47 +4182,47 @@ void uninitvar_wcsrtombs(void)
 void uninitvar_strtok(void)
 {
     char *s;
-    char *ct;
+    const char *ct;
     // cppcheck-suppress uninitvar
     (void)strtok(s,ct);
 }
 
 void uninitvar_strtoimax(void)
 {
-    const char *s;
-    char **endp;
-    int base;
+    const char *s1, *s2;
+    char **endp1, **endp2;
+    int base1, base2;
     // cppcheck-suppress uninitvar
-    (void)strtoimax(s,endp,base);
+    (void)strtoimax(s1,endp1,base1);
     // cppcheck-suppress uninitvar
-    (void)strtoumax(s,endp,base);
+    (void)strtoumax(s2,endp2,base2);
 }
 
 void uninitvar_strtof(void)
 {
-    const char *s;
-    char **endp;
+    const char *s1, *s2, *s3;
+    char **endp1, **endp2, **endp3;
     // cppcheck-suppress uninitvar
-    (void)strtof(s,endp);
+    (void)strtof(s1,endp1);
     // cppcheck-suppress uninitvar
-    (void)strtod(s,endp);
+    (void)strtod(s2,endp2);
     // cppcheck-suppress uninitvar
-    (void)strtold(s,endp);
+    (void)strtold(s3,endp3);
 }
 
 void uninitvar_strtol(void)
 {
-    const char *s;
-    char **endp;
-    int base;
+    const char *s1, *s2, *s3, *s4;
+    char **endp1, **endp2, **endp3, **endp4;
+    int base1, base2, base3, base4;
     // cppcheck-suppress uninitvar
-    (void)strtol(s,endp,base);
+    (void)strtol(s1,endp1,base1);
     // cppcheck-suppress uninitvar
-    (void)strtoll(s,endp,base);
+    (void)strtoll(s2,endp2,base2);
     // cppcheck-suppress uninitvar
-    (void)strtoul(s,endp,base);
+    (void)strtoul(s3,endp3,base3);
     // cppcheck-suppress uninitvar
-    (void)strtoull(s,endp,base);
+    (void)strtoull(s4,endp4,base4);
 }
 
 void uninitvar_time(void)
@@ -3443,30 +4239,58 @@ void uninitvar_tmpnam(void)
     (void)tmpnam(s);
 }
 
-void uninitvar_tolower(void)
+void uninitvar_tolower(int character)
 {
-    int c;
+    int c1;
     // cppcheck-suppress uninitvar
-    (void)tolower(c);
+    (void)tolower(c1);
+
+    int c2;
+    // cppcheck-suppress constVariablePointer
+    int *pc=&c2;
+    // cppcheck-suppress uninitvar
+    (void)tolower(*pc);
+
+    // No warning is expected
+    (void)tolower(character);
+
+    // cppcheck-suppress constVariablePointer
+    int *pChar = &character;
+    // No warning is expected
+    (void)tolower(*pChar);
 }
 
-void uninitvar_toupper(void)
+void uninitvar_toupper(int character)
 {
-    int c;
+    int c1;
     // cppcheck-suppress uninitvar
-    (void)toupper(c);
+    (void)toupper(c1);
+
+    int c2;
+    // cppcheck-suppress constVariablePointer
+    int *pc=&c2;
+    // cppcheck-suppress uninitvar
+    (void)toupper(*pc);
+
+    // No warning is expected
+    (void)toupper(character);
+
+    // cppcheck-suppress constVariablePointer
+    int *pChar = &character;
+    // No warning is expected
+    (void)toupper(*pChar);
 }
 
 void uninitvar_wcstof(void)
 {
-    const wchar_t *s;
-    wchar_t **endp;
+    const wchar_t *s1, *s2, *s3;
+    wchar_t **endp1, **endp2, **endp3;
     // cppcheck-suppress uninitvar
-    (void)wcstof(s,endp);
+    (void)wcstof(s1,endp1);
     // cppcheck-suppress uninitvar
-    (void)wcstod(s,endp);
+    (void)wcstod(s2,endp2);
     // cppcheck-suppress uninitvar
-    (void)wcstold(s,endp);
+    (void)wcstold(s3,endp3);
 }
 
 void uninitvar_mbrtowc(void)
@@ -3490,31 +4314,31 @@ void uninitvar_wcstok(void)
 
 void uninitvar_wcstoimax(void)
 {
-    const wchar_t *s;
-    wchar_t ** endp;
-    int base;
+    const wchar_t *s1, *s2;
+    wchar_t ** endp1, **endp2;
+    int base1, base2;
     // cppcheck-suppress uninitvar
-    (void)wcstoimax(s,endp,base);
+    (void)wcstoimax(s1,endp1,base1);
     // cppcheck-suppress uninitvar
-    (void)wcstoumax(s,endp,base);
+    (void)wcstoumax(s2,endp2,base2);
 }
 
 void uninitvar_wcstol(void)
 {
-    const wchar_t *s;
+    const wchar_t *s1, *s2, *s3, *s4;
     wchar_t ** endp;
-    int base;
+    int base1, base2, base3, base4;
     // cppcheck-suppress uninitvar
-    (void)wcstol(s,endp,base);
+    (void)wcstol(s1,endp,base1);
     // cppcheck-suppress uninitvar
-    (void)wcstoll(s,endp,base);
+    (void)wcstoll(s2,endp,base2);
     // cppcheck-suppress uninitvar
-    (void)wcstoul(s,endp,base);
+    (void)wcstoul(s3,endp,base3);
     // cppcheck-suppress uninitvar
-    (void)wcstoull(s,endp,base);
+    (void)wcstoull(s4,endp,base4);
 }
 
-void uninitvar_wprintf(wchar_t *Format, int Argument)
+void uninitvar_wprintf(const wchar_t *Format, int Argument)
 {
     const wchar_t *format1, *format2, *format3;
     int argument1, argument2;
@@ -3531,7 +4355,7 @@ void uninitvar_wprintf(wchar_t *Format, int Argument)
     (void)wprintf(Format);
 }
 
-void uninitvar_sprintf(char *S, char *Format, int Argument)
+void uninitvar_sprintf(char *S, const char *Format, int Argument)
 {
     char *s1, *s2;
     const char *format1, *format2;
@@ -3581,11 +4405,18 @@ void valid_vsprintf_helper(const char * format, ...)
 void valid_vsprintf()
 {
     // buffer will contain "2\0" => no bufferAccessOutOfBounds
-    // cppcheck-suppress checkLibraryFunction
-    // cppcheck-suppress checkLibraryNoReturn
     valid_vsprintf_helper("%1.0f", 2.0f);
 }
 
+int nullPointer_vswprintf(wchar_t* restrict ws, size_t s, const wchar_t* restrict format, va_list ap)
+{
+    // cppcheck-suppress nullPointer
+    vswprintf(NULL, s,format, ap);
+    // cppcheck-suppress nullPointer
+    vswprintf(ws, s,NULL, ap);
+    return vswprintf(ws, s,format, ap);
+}
+
 void uninitvar_vswprintf(void)
 {
     wchar_t *s;
@@ -3606,18 +4437,18 @@ void uninitvar_fwprintf(void)
     (void)fwprintf(stream,format,i);
 }
 
-void uninitvar_snprintf(char *S, size_t N, char *Format, int Int)
+void uninitvar_snprintf(char *S, size_t N, const char *Format, int Int)
 {
     size_t n1,n2;
-    char *format;
+    const char *format1, *format2;
     int i1, i2;
     char *s1, *s2;
     // cppcheck-suppress uninitvar
-    (void)snprintf(s1,n1,format,i1);
+    (void)snprintf(s1,n1,format1,i1);
     // cppcheck-suppress uninitvar
     (void)snprintf(S,n2,Format,Int); // n is uninitialized
     // cppcheck-suppress uninitvar
-    (void)snprintf(S,N,format,Int); // format is uninitialized
+    (void)snprintf(S,N,format2,Int); // format is uninitialized
     // cppcheck-suppress uninitvar
     (void)snprintf(S,N,Format,i2); // i is uninitialized
     // cppcheck-suppress uninitvar
@@ -3627,11 +4458,11 @@ void uninitvar_snprintf(char *S, size_t N, char *Format, int Int)
     (void)snprintf(S,N,Format,Int);
 }
 
-void uninitvar_vsnprintf(char *S, size_t N, char *Format, va_list Arg)
+void uninitvar_vsnprintf(char *S, size_t N, const char *Format, va_list Arg)
 {
     char *s1, *s2;
     size_t n1, n2;
-    char *format1, *format2;
+    const char *format1, *format2;
     va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
@@ -3651,29 +4482,40 @@ void uninitvar_vsnprintf(char *S, size_t N, char *Format, va_list Arg)
 
 void uninitvar_wscanf(void)
 {
-    wchar_t *format;
+    const wchar_t *format1, *format2;
     int i;
     // cppcheck-suppress uninitvar
-    (void)wscanf(format);
+    (void)wscanf(format1);
     // cppcheck-suppress uninitvar
-    (void)wscanf(format,&i);
+    (void)wscanf(format2,&i);
 }
 
-void uninitvar_sscanf(void)
+void uninitvar_sscanf(const char *s, const char *f, int i, int *ip)
 {
-    char *string;
+    const char *string1, *string2, *string3;
     const char * format;
-    int i;
+    int *pInteger;
+
+    // cppcheck-suppress uninitvar
+    (void)sscanf(string1,f);
     // cppcheck-suppress uninitvar
-    (void)sscanf(string,format);
+    (void)sscanf(string2,f,i);
     // cppcheck-suppress uninitvar
-    (void)sscanf(string,format,&i);
+    (void)sscanf(string3,f,ip);
+    // cppcheck-suppress uninitvar
+    (void)sscanf(s,format,&i);
+    // cppcheck-suppress uninitvar
+    (void)sscanf(s,f,pInteger);
+
+    // No warning is expected
+    (void)sscanf(s,f,&i);
+    (void)sscanf(s,f,ip);
 }
 
 void uninitvar_fwscanf(void)
 {
     FILE* stream;
-    wchar_t* format1, *format2;
+    const wchar_t* format1, *format2;
     int i;
     // cppcheck-suppress uninitvar
     (void)fwscanf(stream,format1);
@@ -3683,8 +4525,8 @@ void uninitvar_fwscanf(void)
 
 void uninitvar_swscanf(void)
 {
-    wchar_t* s;
-    wchar_t* format1, *format2;
+    const wchar_t* s;
+    const wchar_t* format1, *format2;
     int i;
     // cppcheck-suppress uninitvar
     (void)swscanf(s,format1);
@@ -3694,19 +4536,31 @@ void uninitvar_swscanf(void)
 
 void uninitvar_system(void)
 {
-    char *c;
+    const char *c;
     // cppcheck-suppress uninitvar
     (void)system(c);
 }
 
-void uninitvar_zonetime(void)
+void nullPointer_system(const char *c)
 {
-    time_t *tp;
-    int zone;
-    // cppcheck-suppress uninitvar
-    (void)zonetime(tp,zone);
+    // If a null pointer is given, command processor is checked for existence
+    (void)system(NULL);
+    (void)system(c);
 }
 
+#ifndef __STDC_NO_THREADS__
+int nullPointer_mtx_timedlock( mtx_t *restrict mutex, const struct timespec *restrict time_point )
+{
+    // cppcheck-suppress nullPointer
+    (void) mtx_timedlock(NULL, time_point);
+    // cppcheck-suppress nullPointer
+    (void) mtx_timedlock(mutex, NULL);
+    return mtx_timedlock(mutex, time_point);
+}
+#endif
+
+#ifdef _WIN32
+/* itoa() is not ANSI-C and not implemented by all compilers */
 void uninitvar_itoa(void)
 {
     int value;
@@ -3715,6 +4569,7 @@ void uninitvar_itoa(void)
     // cppcheck-suppress uninitvar
     (void)itoa(value,str,base);
 }
+#endif
 
 #ifdef __STD_UTF_16__
 void uninitvar_c16rtomb(void)
@@ -3729,7 +4584,7 @@ void uninitvar_c16rtomb(void)
 void uninitvar_mbrtoc16(void)
 {
     char16_t * pc16;
-    char * pmb;
+    const char * pmb;
     size_t max;
     mbstate_t * ps;
     // cppcheck-suppress uninitvar
@@ -3750,7 +4605,7 @@ void uninitvar_c32rtomb(void)
 void uninitvar_mbrtoc32(void)
 {
     char32_t * pc32;
-    char * pmb;
+    const char * pmb;
     size_t max;
     mbstate_t * ps;
     // cppcheck-suppress uninitvar
@@ -3768,11 +4623,133 @@ void invalidFunctionArgBool_abs(bool b, double x, double y)
     (void)abs(x<y); // #5635
 }
 
+int invalidFunctionArgBool_tolower(bool b, int c)
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)tolower(b);
+    // cppcheck-suppress invalidFunctionArgBool
+    return tolower(c != 0);
+}
+
+int invalidFunctionArgBool_toupper(bool b, int c)
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)toupper(b);
+    // cppcheck-suppress invalidFunctionArgBool
+    return toupper(c != 0);
+}
+
+bool invalidFunctionArgBool_iscntrl(bool b, int c)
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)iscntrl(b);
+    // cppcheck-suppress invalidFunctionArgBool
+    return iscntrl(c != 0);
+}
+
+bool invalidFunctionArgBool_isalpha(bool b, int c)
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)isalpha(b);
+    // cppcheck-suppress invalidFunctionArgBool
+    return isalpha(c != 0);
+}
+
+bool invalidFunctionArgBool_isalnum(bool b, int c)
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)isalnum(b);
+    // cppcheck-suppress invalidFunctionArgBool
+    return isalnum(c != 0);
+}
+
+bool invalidFunctionArgBool_isspace(bool b, int c)
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)isspace(b);
+    // cppcheck-suppress invalidFunctionArgBool
+    return isspace(c != 0);
+}
+
+bool invalidFunctionArgBool_isdigit(bool b, int c)
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)isdigit(b);
+    // cppcheck-suppress invalidFunctionArgBool
+    return isdigit(c != 0);
+}
+
+bool invalidFunctionArgBool_isgraph(bool b, int c)
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)isgraph(b);
+    // cppcheck-suppress invalidFunctionArgBool
+    return isgraph(c != 0);
+}
+
+bool invalidFunctionArgBool_islower(bool b, int c)
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)islower(b);
+    // cppcheck-suppress invalidFunctionArgBool
+    return islower(c != 0);
+}
+
+bool invalidFunctionArgBool_iswcntrl(bool b, wint_t c)
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)iswcntrl(b);
+    // cppcheck-suppress invalidFunctionArgBool
+    return iswcntrl(c != 0);
+}
+
+bool invalidFunctionArgBool_isprint(bool b, int c)
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)isprint(b);
+    // cppcheck-suppress invalidFunctionArgBool
+    return isprint(c != 0);
+}
+
+bool invalidFunctionArgBool_isblank(bool b, int c)
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)isblank(b);
+    // cppcheck-suppress invalidFunctionArgBool
+    return isblank(c != 0);
+}
+
+bool invalidFunctionArgBool_ispunct(bool b, int c)
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)ispunct(b);
+    // cppcheck-suppress invalidFunctionArgBool
+    return ispunct(c != 0);
+}
+
+bool invalidFunctionArgBool_isupper(bool b, int c)
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)isupper(b);
+    // cppcheck-suppress invalidFunctionArgBool
+    return isupper(c != 0);
+}
+
+bool invalidFunctionArgBool_isxdigit(bool b, int c)
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)isxdigit(b);
+    // cppcheck-suppress invalidFunctionArgBool
+    return isxdigit(c != 0);
+}
+
 void invalidFunctionArg(char c)
 {
+#ifdef __STDC_LIB_EXT1__
     // cppcheck-suppress asctime_sCalled
     // cppcheck-suppress invalidFunctionArg
     asctime_s(1, 24, 1);
+#endif
 
     /* cppcheck-suppress invalidFunctionArg */
     (void)isalnum(256);
@@ -3900,8 +4877,10 @@ void invalidFunctionArg(char c)
     (void)toupper(0);
     (void)toupper(255);
 
+#ifdef __STDC_LIB_EXT1__
     /* cppcheck-suppress invalidFunctionArg */
     (void)strcpy_s(1,0,"a");
+#endif
 }
 
 void invalidFunctionArgString(char c)
@@ -3930,9 +4909,14 @@ void ignoredReturnValue_abs(int i)
     abs(-100);
 }
 
+int clamp(int, int, int, int); // #13599
+void ignoredReturnValue_clamp(int a, int b, int c, int d) {
+    clamp(a, b, c, d); // not a library function
+}
+
 void nullPointer_asctime(void)
 {
-    struct tm *tm = 0;
+    const struct tm *tm = 0;
     // cppcheck-suppress asctimeCalled
     // cppcheck-suppress nullPointer
     (void)asctime(tm);
@@ -3941,9 +4925,10 @@ void nullPointer_asctime(void)
     (void)asctime(0);
 }
 
+#ifdef __STDC_LIB_EXT1__
 void nullPointer_asctime_s(void)
 {
-    struct tm *tm = 0;
+    const struct tm *tm = 0;
     char * buf = NULL;
     // cppcheck-suppress asctime_sCalled
     // cppcheck-suppress nullPointer
@@ -3952,17 +4937,7 @@ void nullPointer_asctime_s(void)
     // cppcheck-suppress nullPointer
     asctime_s(1, 26, tm);
 }
-
-void nullPointer_wcsftime(size_t maxsize)
-{
-    wchar_t* ptr = 0;
-    wchar_t* format = 0;
-    struct tm* timeptr = 0;
-    // cppcheck-suppress nullPointer
-    (void)wcsftime(ptr,maxsize,format,timeptr);
-    // cppcheck-suppress nullPointer
-    (void)wcsftime(0,maxsize,0,0);
-}
+#endif
 
 void nullPointer_fegetenv(void)
 {
@@ -3993,7 +4968,7 @@ void nullPointer_feholdexcept(void)
 
 void nullPointer_fesetenv(void)
 {
-    fenv_t* envp = 0;
+    const fenv_t* envp = 0;
     // cppcheck-suppress nullPointer
     (void)fesetenv(envp);
     // cppcheck-suppress nullPointer
@@ -4002,16 +4977,46 @@ void nullPointer_fesetenv(void)
 
 void nullPointer_fesetexceptflag(int excepts)
 {
-    fexcept_t* flagp = 0;
+    const fexcept_t* flagp = 0;
     // cppcheck-suppress nullPointer
     (void)fesetexceptflag(flagp,excepts);
     // cppcheck-suppress nullPointer
     (void)fesetexceptflag(0,excepts);
 }
 
+void invalidFunctionArg_fesetexceptflag(const fexcept_t* flagp, int excepts)
+{
+    (void)fesetexceptflag(flagp, excepts);
+    // cppcheck-suppress invalidFunctionArg
+    (void)fesetexceptflag(flagp, 0);
+    (void)fesetexceptflag(flagp, FE_DIVBYZERO);
+    (void)fesetexceptflag(flagp, FE_INEXACT);
+    (void)fesetexceptflag(flagp, FE_INVALID);
+    (void)fesetexceptflag(flagp, FE_OVERFLOW);
+    (void)fesetexceptflag(flagp, FE_UNDERFLOW);
+    (void)fesetexceptflag(flagp, FE_ALL_EXCEPT);
+    // cppcheck-suppress invalidFunctionArg
+    (void)fesetexceptflag(flagp, FE_ALL_EXCEPT+1);
+}
+
+void invalidFunctionArg_fetestexcept(int excepts)
+{
+    (void)fetestexcept(excepts);
+    // cppcheck-suppress invalidFunctionArg
+    (void)fetestexcept(0);
+    (void)fetestexcept(FE_DIVBYZERO);
+    (void)fetestexcept(FE_INEXACT);
+    (void)fetestexcept(FE_INVALID);
+    (void)fetestexcept(FE_OVERFLOW);
+    (void)fetestexcept(FE_UNDERFLOW);
+    (void)fetestexcept(FE_ALL_EXCEPT);
+    // cppcheck-suppress invalidFunctionArg
+    (void)fetestexcept(FE_ALL_EXCEPT+1);
+}
+
 void nullPointer_feupdateenv(void)
 {
-    fenv_t* envp = 0;
+    const fenv_t* envp = 0;
     // cppcheck-suppress nullPointer
     (void)feupdateenv(envp);
     // cppcheck-suppress nullPointer
@@ -4026,7 +5031,7 @@ void nullPointer_atexit(void)
 
 void nullPointer_atof(void)
 {
-    char * c = 0;
+    const char * c = 0;
     // cppcheck-suppress nullPointer
     (void)atof(c);
     // cppcheck-suppress nullPointer
@@ -4042,7 +5047,7 @@ void invalidPrintfArgType_printf(void)
     // #7016
     uint8_t n = 7;
     // TODO cppcheck-suppress invalidPrintfArgType_uint
-    printf("%"PRIi16"\n", n);
+    printf("%" PRIi16 "\n", n);
 }
 
 
diff --git a/test/cfg/std.cpp b/test/cfg/std.cpp
index 0647ec14b76..7e406ca2187 100644
--- a/test/cfg/std.cpp
+++ b/test/cfg/std.cpp
@@ -2,31 +2,1058 @@
 // Test library configuration for std.cfg
 //
 // Usage:
-// $ cppcheck --check-library --enable=information --error-exitcode=1 --suppress=missingIncludeSystem --inline-suppr test/cfg/std.cpp
+// $ cppcheck --check-library --library=std --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/std.cpp
 // =>
 // No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
 //
 
-#include <cstring>
-#include <cstdio>
-#include <cstdlib>
-#include <ctime>
-#include <cctype>
-#include <complex>
+// cppcheck-suppress-file valueFlowBailout
+
+#include <algorithm> // IWYU pragma: keep
+#include <array>
+#include <bitset>
 #include <cassert>
-#include <cwchar>
+#include <cctype>
 #include <cfenv>
-#include <csetjmp>
+#include <cinttypes>
+#include <clocale>
 #include <cmath>
+#include <complex>
+#include <csetjmp>
 #include <csignal>
-#include <iostream>
-#include <iomanip>
-#include <cinttypes>
-#include <istream>
-#include <fstream>
-#include <vector>
 #include <cstdarg>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#define __STDC_WANT_LIB_EXT1__ 1
+#include <ctime>
+#include <cwchar>
+#include <cwctype>
+#include <deque>
+#include <exception>
+#include <filesystem>
+#include <fstream>
 #include <functional>
+#ifndef __STDC_NO_THREADS__
+    #include <threads.h>
+#endif
+#include <iomanip>
+#include <ios> // IWYU pragma: keep
+#include <iostream>
+#include <istream> // IWYU pragma: keep
+#include <iterator>
+#include <list> // IWYU pragma: keep
+#include <locale>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <numeric>
+#include <queue>
+#include <set>
+#include <sstream>
+#include <stdexcept>
+#include <streambuf> // IWYU pragma: keep
+#include <string>
+#include <string_view>
+#include <system_error>
+#include <tuple>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <variant>
+#include <vector>
+#include <version> // IWYU pragma: keep
+#ifdef __cpp_lib_span
+#include <span>
+#endif
+#ifdef __cpp_lib_format
+#include <format>
+#endif
+
+#if __cplusplus <= 201402L
+void unreachableCode_std_unexpected(int &x)
+{
+    // cppcheck-suppress unexpectedCalled
+    std::unexpected();
+    // cppcheck-suppress unreachableCode
+    x=42;
+}
+#endif
+
+#ifdef __cpp_lib_clamp
+int ignoredReturnValue_std_clamp(const int x)
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::clamp(x, 1, -1);
+    return std::clamp(x, 1, -1);
+}
+void knownConditionTrueFalse_std_clamp(const int x)
+{
+    // cppcheck-suppress knownConditionTrueFalse
+    if(std::clamp(-2, -1, 1) == -1){}
+    // cppcheck-suppress knownConditionTrueFalse
+    if(std::clamp(2, -1, 1) == 1){}
+    // cppcheck-suppress knownConditionTrueFalse
+    if(std::clamp(0, -1, 1) == 0){}
+    if(std::clamp(x, 0, 2)){}
+}
+#endif // __cpp_lib_clamp
+
+void unreachableCode_std_terminate(int &x)
+{
+    std::terminate();
+    // cppcheck-suppress unreachableCode
+    x=42;
+}
+
+bool ignoredReturnValue_std_filesystem_exists(const std::filesystem::path &path, std::error_code& ec)
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::filesystem::exists(path);
+    // cppcheck-suppress ignoredReturnValue
+    std::filesystem::exists(path, ec);
+    const bool b {std::filesystem::exists(path)};
+    return b && std::filesystem::exists(path, ec);
+}
+
+// https://en.cppreference.com/w/cpp/io/manip/quoted
+void uninitvar_std_quoted(std::stringstream &ss, const std::string &input, const char delim, const char escape)
+{
+    ss << std::quoted(input);
+    ss << std::quoted(input, delim);
+    ss << std::quoted(input, delim, escape);
+    char delimChar;
+    // cppcheck-suppress uninitvar
+    ss << std::quoted(input, delimChar);
+    char escapeChar;
+    // cppcheck-suppress uninitvar
+    ss << std::quoted(input, delim, escapeChar);
+}
+
+int zerodiv_ldexp()
+{
+    int i = std::ldexp(0.0, 42.0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_ilogb()
+{
+    int i = std::ilogb(1.0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_hypot()
+{
+    int i = std::hypot(0.0, 0.0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_fmod()
+{
+    int i = std::fmod(0.0, 42.0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_fmin()
+{
+    int i = std::fmin(0.0, 0.0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_fmax()
+{
+    int i = std::fmax(0.0, 0.0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_floor()
+{
+    int i = std::floor(0.0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_fabs()
+{
+    int i = std::fabs(-0.0) + std::fabs(+0.0) + std::fabs(0.0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_fdim()
+{
+    int i = std::fdim(1.0, 1.0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_trunc()
+{
+    int i = std::trunc(0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_ceil()
+{
+    int i = std::ceil(0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_sqrt()
+{
+    int i = std::sqrt(0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_cbrt()
+{
+    int i = std::cbrt(0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_erf()
+{
+    int i = std::erf(0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_erfc()
+{
+    int i = std::erfc(42);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_asin()
+{
+    int i = std::asin(0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_acos()
+{
+    int i = std::acos(1);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_asinh()
+{
+    int i = std::asinh(0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_acosh()
+{
+    int i = std::acosh(1);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_log1p()
+{
+    int i = std::log1p(0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_nearbyint()
+{
+    int i = std::nearbyint(0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_round()
+{
+    int i = std::round(0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_sinh()
+{
+    int i = std::sinh(0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_tanh()
+{
+    int i = std::tanh(0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_atanh()
+{
+    int i = std::atanh(0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_atan()
+{
+    int i = std::atan(0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_sin()
+{
+    int i = std::sin(0)+std::sin(M_PI)+std::sin(2*M_PI);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int zerodiv_expm1()
+{
+    int i = std::expm1(0);
+    // cppcheck-suppress zerodiv
+    return 42 / i;
+}
+
+int moduloofone_cos()
+{
+    int i = std::cos(0);
+    // cppcheck-suppress moduloofone
+    return 42 % i;
+}
+
+int moduloofone_exp()
+{
+    int i = std::exp(0);
+    // cppcheck-suppress moduloofone
+    return 42 % i;
+}
+
+int moduloofone_exp2()
+{
+    int i = std::exp2(0);
+    // cppcheck-suppress moduloofone
+    return 42 % i;
+}
+
+int moduloofone_pow()
+{
+    int i = std::pow(2, 0);
+    // cppcheck-suppress moduloofone
+    return 42 % i;
+}
+
+char* invalidFunctionArgStr_strncpy(char * destination)
+{
+    // Copies the first num characters of source to destination.
+    // If the end of the source C string (which is signaled by a null-character)
+    // is found before num characters have been copied, destination
+    // is padded with zeros until a total of num characters have been written to it.
+    const char source = 'x';
+    const std::size_t num = 1U;
+    return strncpy(destination, &source, num);
+}
+
+void invalidFunctionArgStr_fprintf(FILE *stream, const char *format)
+{
+    const char formatBuf[] = {'%','d'};
+    // cppcheck-suppress invalidFunctionArgStr
+    (void)fprintf(stream,formatBuf,42);
+    (void)fprintf(stream,format,42);
+}
+
+void invalidFunctionArgStr_fopen(const char * const fileName, const char * const mode)
+{
+    const char fileNameBuf[] = {'f','i','l','e'};
+    const char modeBuf[] = {'r'};
+    // cppcheck-suppress invalidFunctionArgStr
+    FILE *fp = fopen(fileName, modeBuf);
+    // cppcheck-suppress nullPointerOutOfResources
+    fclose(fp);
+    // cppcheck-suppress invalidFunctionArgStr
+    fp = fopen(fileNameBuf, mode);
+    // cppcheck-suppress nullPointerOutOfResources
+    fclose(fp);
+}
+
+float invalidFunctionArg_remquo (float x, float y, int* quo )
+{
+    // cppcheck-suppress invalidFunctionArg
+    (void) std::remquo(x,0.0f,quo);
+    // cppcheck-suppress invalidFunctionArg
+    (void) std::remquof(x,0.0f,quo);
+    return std::remquo(x,y,quo);
+}
+
+double invalidFunctionArg_remquo (double x, double y, int* quo )
+{
+    // cppcheck-suppress invalidFunctionArg
+    (void) std::remquo(x,0.0,quo);
+    // cppcheck-suppress invalidFunctionArg
+    (void) std::remquo(x,0.0f,quo);
+    // cppcheck-suppress invalidFunctionArg
+    (void) std::remquo(x,0.0L,quo);
+    return std::remquo(x,y,quo);
+}
+
+double invalidFunctionArg_remquo (long double x, long double y, int* quo )
+{
+    // cppcheck-suppress invalidFunctionArg
+    (void) std::remquo(x,0.0L,quo);
+    // cppcheck-suppress invalidFunctionArg
+    (void) std::remquol(x,0.0L,quo);
+    return std::remquo(x,y,quo);
+}
+
+void invalidFunctionArg_remainderl(long double f1, long double f2)
+{
+    // cppcheck-suppress invalidFunctionArg
+    (void)std::remainderl(f1,0.0);
+    // cppcheck-suppress invalidFunctionArg
+    (void)std::remainderl(f1,0.0L);
+    (void)std::remainderl(f1,f2);
+}
+
+void invalidFunctionArg_remainder(double f1, double f2)
+{
+    // cppcheck-suppress invalidFunctionArg
+    (void)std::remainder(f1,0.0);
+    (void)std::remainder(f1,f2);
+}
+
+void invalidFunctionArg_remainderf(float f1, float f2)
+{
+    // cppcheck-suppress invalidFunctionArg
+    (void)std::remainderf(f1,0.0);
+    // cppcheck-suppress invalidFunctionArg
+    (void)std::remainderf(f1,0.0f);
+    (void)std::remainderf(f1,f2);
+}
+
+void uninitvar_std_fstream_open(std::fstream &fs, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)
+{
+    std::string s;
+    const char *ptr;
+    std::ios_base::openmode m;
+
+    fs.open(s, mode);
+    // cppcheck-suppress uninitvar
+    fs.open(ptr, mode);
+    // TODO cppcheck-suppress uninitvar
+    fs.open(filename, m);
+    // TODO cppcheck-suppress uninitvar
+    fs.open(strFileName, m);
+    fs.open(s);
+    // TODO cppcheck-suppress uninitvar
+    fs.open(ptr);
+}
+
+void uninitvar_std_ifstream_open(std::ifstream &ifs, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)
+{
+    std::string s;
+    const char *ptr;
+    std::ios_base::openmode m;
+
+    ifs.open(s, mode);
+    // cppcheck-suppress uninitvar
+    ifs.open(ptr, mode);
+    // TODO cppcheck-suppress uninitvar
+    ifs.open(filename, m);
+    // TODO cppcheck-suppress uninitvar
+    ifs.open(strFileName, m);
+    ifs.open(s);
+    // TODO cppcheck-suppress uninitvar
+    ifs.open(ptr);
+}
+
+void uninitvar_std_ofstream_open(std::ofstream &os, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)
+{
+    std::string s;
+    const char *ptr;
+    std::ios_base::openmode m;
+
+    os.open(s, mode);
+    // cppcheck-suppress uninitvar
+    os.open(ptr, mode);
+    // TODO cppcheck-suppress uninitvar
+    os.open(filename, m);
+    // TODO cppcheck-suppress uninitvar
+    os.open(strFileName, m);
+    os.open(s);
+    // TODO cppcheck-suppress uninitvar
+    os.open(ptr);
+}
+
+void uninitvar_std_ofstream_precision(std::ofstream& os)
+{
+    std::streamsize s;
+    // cppcheck-suppress uninitvar
+    os.precision(s);
+}
+
+void nullPointer_std_filebuf_open(std::filebuf &fb, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)
+{
+    // cppcheck-suppress nullPointer
+    (void)fb.open(nullptr, mode);
+    (void)fb.open(filename, mode);
+    (void)fb.open(strFileName, mode);
+}
+
+void nullPointer_std_ofstream_open(std::ofstream &os, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)
+{
+    // cppcheck-suppress nullPointer
+    os.open(nullptr, mode);
+    os.open(filename, mode);
+    os.open(strFileName, mode);
+    // cppcheck-suppress nullPointer
+    os.open(nullptr);
+    os.open(filename);
+    os.open(strFileName);
+}
+
+void nullPointer_std_fstream_open(std::fstream &fs, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)
+{
+    // cppcheck-suppress nullPointer
+    fs.open(nullptr, mode);
+    fs.open(filename, mode);
+    fs.open(strFileName, mode);
+    // cppcheck-suppress nullPointer
+    fs.open(nullptr);
+    fs.open(filename);
+    fs.open(strFileName);
+}
+
+void nullPointer_std_ifstream_open(std::ifstream &is, const std::string &strFileName, const char* filename, std::ios_base::openmode mode)
+{
+    // cppcheck-suppress nullPointer
+    is.open(nullptr, mode);
+    is.open(filename, mode);
+    is.open(strFileName, mode);
+    // cppcheck-suppress nullPointer
+    is.open(nullptr);
+    is.open(filename);
+    is.open(strFileName);
+}
+
+void bufferAccessOutOfBounds_std_fstream_write(std::fstream &fs, const char* s, std::streamsize n)
+{
+    const char buf[42] = {0};
+    (void)fs.write(buf,42);
+    // cppcheck-suppress bufferAccessOutOfBounds
+    (void)fs.write(buf,43);
+    (void)fs.write(buf,n);
+    (void)fs.write(s,n);
+}
+
+void bufferAccessOutOfBounds_std_ostream_write(std::ostream &os, const char* s, std::streamsize n)
+{
+    const char buf[42] = {0};
+    (void)os.write(buf,42);
+    // cppcheck-suppress bufferAccessOutOfBounds
+    (void)os.write(buf,43);
+    (void)os.write(buf,n);
+    (void)os.write(s,n);
+}
+
+void bufferAccessOutOfBounds_std_ostringstream_write(std::ostringstream &oss, const char* s, std::streamsize n)
+{
+    const char buf[42] = {0};
+    (void)oss.write(buf,42);
+    // cppcheck-suppress bufferAccessOutOfBounds
+    (void)oss.write(buf,43);
+    (void)oss.write(buf,n);
+    (void)oss.write(s,n);
+}
+
+void bufferAccessOutOfBounds_std_ofstream_write(std::ofstream &os, const char* s, std::streamsize n)
+{
+    const char buf[42] = {0};
+    (void)os.write(buf,42);
+    // cppcheck-suppress bufferAccessOutOfBounds
+    (void)os.write(buf,43);
+    (void)os.write(buf,n);
+    (void)os.write(s,n);
+}
+
+// cppcheck-suppress constParameterReference // TODO: FP
+void bufferAccessOutOfBounds_std_ifstream_get(std::ifstream& in, std::streambuf& sb)
+{
+    char cBuf[10];
+    // cppcheck-suppress bufferAccessOutOfBounds
+    in.getline(cBuf, 100);
+    // cppcheck-suppress bufferAccessOutOfBounds
+    in.read(cBuf, 100);
+    // cppcheck-suppress bufferAccessOutOfBounds
+    in.readsome(cBuf, 100);
+    // cppcheck-suppress bufferAccessOutOfBounds
+    in.get(cBuf, 100);
+    // cppcheck-suppress bufferAccessOutOfBounds
+    in.get(cBuf, 100, 'a');
+    // cppcheck-suppress bufferAccessOutOfBounds
+    in.getline(cBuf, 100, 'a');
+
+    in.get(sb, 'a');
+
+    in.close();
+}
+
+void invalidFunctionArg_fesetexceptflag(const fexcept_t* flagp, int excepts)
+{
+    (void)std::fesetexceptflag(flagp, excepts);
+    // cppcheck-suppress invalidFunctionArg
+    (void)std::fesetexceptflag(flagp, 0);
+    (void)std::fesetexceptflag(flagp, FE_DIVBYZERO);
+    (void)std::fesetexceptflag(flagp, FE_INEXACT);
+    (void)std::fesetexceptflag(flagp, FE_INVALID);
+    (void)std::fesetexceptflag(flagp, FE_OVERFLOW);
+    (void)std::fesetexceptflag(flagp, FE_UNDERFLOW);
+    (void)std::fesetexceptflag(flagp, FE_ALL_EXCEPT);
+    // cppcheck-suppress invalidFunctionArg
+    (void)std::fesetexceptflag(flagp, FE_ALL_EXCEPT+1);
+}
+
+void invalidFunctionArg_fetestexcept(int excepts)
+{
+    (void)std::fetestexcept(excepts);
+    // cppcheck-suppress invalidFunctionArg
+    (void)std::fetestexcept(0);
+    (void)std::fetestexcept(FE_DIVBYZERO);
+    (void)std::fetestexcept(FE_INEXACT);
+    (void)std::fetestexcept(FE_INVALID);
+    (void)std::fetestexcept(FE_OVERFLOW);
+    (void)std::fetestexcept(FE_UNDERFLOW);
+    (void)std::fetestexcept(FE_ALL_EXCEPT);
+    // cppcheck-suppress invalidFunctionArg
+    (void)std::fetestexcept(FE_ALL_EXCEPT+1);
+}
+
+void nullPointer_fprintf(FILE *Stream, const char *Format, int Argument)
+{
+    // cppcheck-suppress nullPointer
+    (void)std::fprintf(Stream, nullptr, Argument);
+    // no warning is expected
+    (void)std::fprintf(Stream, Format, Argument);
+}
+
+void bufferAccessOutOfBounds_wcsftime(wchar_t* ptr, size_t maxsize, const wchar_t* format, const struct tm* timeptr)
+{
+    wchar_t buf[42];
+    (void)std::wcsftime(buf, 42, format, timeptr);
+    // TODO cppcheck-suppress bufferAccessOutOfBounds
+    (void)std::wcsftime(buf, 43, format, timeptr);
+    (void)std::wcsftime(ptr, maxsize, format, timeptr);
+}
+
+int qsort_cmpfunc (const void * a, const void * b) {
+    return (*static_cast<const int*>(a) - *static_cast<const int*>(b));
+}
+void nullPointer_qsort(void *base, std::size_t n, std::size_t size, int (*cmp)(const void *, const void *))
+{
+    // cppcheck-suppress nullPointer
+    std::qsort(nullptr, n, size, qsort_cmpfunc);
+    // cppcheck-suppress nullPointer
+    std::qsort(base, n, size, nullptr);
+    std::qsort(base, n, size, qsort_cmpfunc);
+}
+
+void nullPointer_vfprintf(FILE *Stream, const char *Format, va_list Arg)
+{
+    // cppcheck-suppress nullPointer
+    (void)std::vfprintf(Stream, nullptr, Arg);
+    (void)std::vfprintf(Stream, Format, Arg);
+}
+
+void nullPointer_vfwprintf(FILE *Stream, const wchar_t *Format, va_list Arg)
+{
+    // cppcheck-suppress nullPointer
+    (void)std::vfwprintf(Stream, nullptr, Arg);
+    (void)std::vfwprintf(Stream, Format, Arg);
+}
+
+void *bufferAccessOutOfBounds_memchr(void *s, int c, size_t n)
+{
+    char buf[42]={0};
+    (void)std::memchr(buf,c,42);
+    // cppcheck-suppress bufferAccessOutOfBounds
+    (void)std::memchr(buf,c,43);
+    return std::memchr(s,c,n);
+}
+
+// As with all bounds-checked functions, localtime_s is only guaranteed to be available if __STDC_LIB_EXT1__ is defined by the implementation and if the user defines __STDC_WANT_LIB_EXT1__ to the integer constant 1 before including time.h.
+#ifdef __STDC_LIB_EXT1__
+void uninitvar_localtime_s(const std::time_t *restrict time, struct tm *restrict result)
+{
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
+    const std::time_t *restrict Time;
+    // TODO cppcheck-suppress uninitvar
+    (void)std::localtime_s(Time, result);
+    (void)std::localtime_s(time, result);
+}
+
+void nullPointer_localtime_s(const std::time_t *restrict time, struct tm *restrict result)
+{
+    // cppcheck-suppress nullPointer
+    (void)std::localtime_s(NULL, result);
+    // cppcheck-suppress nullPointer
+    (void)std::localtime_s(time, NULL);
+    (void)std::localtime_s(time, result);
+}
+
+void memleak_localtime_s(const std::time_t *restrict time, struct tm *restrict result) // #9258
+{
+    const time_t t = time(0);
+    const struct tm* const now = new tm();
+    if (localtime_s(now, &t) == 0) {
+        // cppcheck-suppress valueFlowBailoutIncompleteVar
+        std::cout << now->tm_mday << std::endl;
+    }
+    // cppcheck-suppress memleak
+}
+#endif // __STDC_LIB_EXT1__
+
+size_t nullPointer_strftime(char *s, size_t max, const char *fmt, const struct tm *p)
+{
+    // cppcheck-suppress nullPointer
+    (void) std::strftime(NULL,max,fmt,p);
+    // cppcheck-suppress nullPointer
+    (void) std::strftime(s,max,NULL,p);
+    // cppcheck-suppress nullPointer
+    (void) std::strftime(s,max,fmt,NULL);
+    return std::strftime(s,max,fmt,p);
+}
+
+size_t bufferAccessOutOfBounds_wcsrtombs(char * dest, const wchar_t ** src, size_t len, mbstate_t * ps)
+{
+    char buf[42];
+    (void)std::wcsrtombs(buf,src,42,ps);
+    // cppcheck-suppress bufferAccessOutOfBounds
+    (void)std::wcsrtombs(buf,src,43,ps);
+    return std::wcsrtombs(dest,src,len,ps);
+}
+
+void deallocuse_wcrtomb(char *buff) { // #13119
+    free(buff);
+    // cppcheck-suppress deallocuse
+    wcrtomb(buff, L'x', nullptr);
+}
+
+void invalidFunctionArg_std_string_substr(const std::string &str, std::size_t pos, std::size_t len) {
+    // cppcheck-suppress invalidFunctionArg
+    (void)str.substr(-1,len);
+    // cppcheck-suppress invalidFunctionArg
+    (void)str.substr(pos,-1);
+    // no warning is expected for
+    (void)str.substr(pos,len);
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
+    (void)str.substr(pos, std::string::npos);
+}
+
+void invalidFunctionArg_std_wstring_substr(const std::wstring &str, std::size_t pos, std::size_t len) {
+    // cppcheck-suppress invalidFunctionArg
+    (void)str.substr(-1,len);
+    // cppcheck-suppress invalidFunctionArg
+    (void)str.substr(pos,-1);
+    // no warning is expected for
+    (void)str.substr(pos,len);
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
+    (void)str.substr(pos, std::wstring::npos);
+}
+
+double invalidFunctionArg_log10(double d = 0.0) {
+    // cppcheck-suppress invalidFunctionArg
+    return log10(d);
+}
+
+void uninitvar_std_next(const std::vector<int> &v, int count)
+{
+    // No warning shall be shown:
+    if (std::next(v.begin()) != v.end()) {}
+    if (std::next(v.begin(), count) != v.end()) {}
+
+    std::vector<int>::iterator it;
+    // cppcheck-suppress uninitvar
+    if (std::next(it) != v.end()) {}
+
+    std::vector<int>::const_iterator const_it;
+    // cppcheck-suppress uninitvar
+    if (std::next(const_it) != v.end()) {}
+
+    std::vector<int>::reverse_iterator rit;
+    // cppcheck-suppress uninitvar
+    if (std::next(rit) != v.rend()) {}
+
+    std::vector<int>::const_reverse_iterator const_rit;
+    // cppcheck-suppress uninitvar
+    if (std::next(const_rit) != v.rend()) {}
+}
+
+void uninitvar_std_prev(const std::vector<int> &v, int count)
+{
+    // No warning shall be shown:
+    if (std::prev(v.begin()) != v.end()) {}
+    if (std::prev(v.begin(), count) != v.end()) {}
+
+    std::vector<int>::iterator it;
+    // cppcheck-suppress uninitvar
+    if (std::prev(it) != v.end()) {}
+
+    std::vector<int>::const_iterator const_it;
+    // cppcheck-suppress uninitvar
+    if (std::prev(const_it) != v.end()) {}
+
+    std::vector<int>::reverse_iterator rit;
+    // cppcheck-suppress uninitvar
+    if (std::prev(rit) != v.rend()) {}
+
+    std::vector<int>::const_reverse_iterator const_rit;
+    // cppcheck-suppress uninitvar
+    if (std::prev(const_rit) != v.rend()) {}
+}
+
+void overlappingWriteFunction_wcscat(wchar_t *src, wchar_t *dest)
+{
+    // No warning shall be shown:
+    (void)wcscat(dest, src);
+    // cppcheck-suppress overlappingWriteFunction
+    (void)wcscat(src, src);
+}
+
+void overlappingWriteFunction_wcsxfrm(wchar_t *s1, const wchar_t *s2, size_t n)
+{
+    // No warning shall be shown:
+    (void)wcsxfrm(s1, s2, n);
+}
+
+char * overlappingWriteFunction_strcat(char *src, char *dest)
+{
+    // No warning shall be shown:
+    (void)strcat(dest, src);
+    // cppcheck-suppress overlappingWriteFunction
+    return strcat(src, src);
+}
+
+int nullPointer_wcsncmp(const wchar_t* s1, const wchar_t* s2, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void) std::wcsncmp(NULL,s2,n);
+    // cppcheck-suppress nullPointer
+    (void) std::wcsncmp(s1,NULL,n);
+    return std::wcsncmp(s1,s2,n);
+}
+
+wchar_t* nullPointer_wcsncpy(wchar_t *s, const wchar_t *cs, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void) std::wcsncpy(NULL,cs,n);
+    // cppcheck-suppress nullPointer
+    (void) std::wcsncpy(s,NULL,n);
+    return std::wcsncpy(s,cs,n);
+}
+
+char * overlappingWriteFunction_strncat(const char *src, char *dest, const std::size_t count)
+{
+    // No warning shall be shown:
+    (void)strncat(dest, src, 42);
+    (void)strncat(dest, src, count);
+    (void)strncat(dest, dest, count);
+    // cppcheck-suppress overlappingWriteFunction
+    (void)strncat(dest, dest+1, 2);
+    char buffer[] = "strncat";
+    // cppcheck-suppress overlappingWriteFunction
+    return strncat(buffer, buffer + 1, 3);
+}
+
+wchar_t * overlappingWriteFunction_wcsncat(const wchar_t *src, wchar_t *dest, const std::size_t count)
+{
+    // No warning shall be shown:
+    (void)wcsncat(dest, src, 42);
+    (void)wcsncat(dest, src, count);
+    (void)wcsncat(dest, dest, count);
+    // cppcheck-suppress overlappingWriteFunction
+    (void)wcsncat(dest, dest+1, 2);
+    wchar_t buffer[] = L"strncat";
+    // cppcheck-suppress overlappingWriteFunction
+    return wcsncat(buffer, buffer + 1, 3);
+}
+
+wchar_t * overlappingWriteFunction_wcscpy(wchar_t *src, wchar_t *dest)
+{
+    // No warning shall be shown:
+    (void)wcscpy(dest, src);
+    const wchar_t * destBuf = dest;
+    // TODO-cppcheck-suppress overlappingWriteFunction  #10355
+    (void)wcscpy(dest, destBuf);
+    // cppcheck-suppress overlappingWriteFunction
+    return wcscpy(src, src);
+}
+
+wchar_t * overlappingWriteFunction_wcsncpy(wchar_t *buf, const std::size_t count)
+{
+    // No warning shall be shown:
+    (void)wcsncpy(&buf[0], &buf[3], count); // size is not known
+    (void)wcsncpy(&buf[0], &buf[3], 3U);    // no-overlap
+    // cppcheck-suppress overlappingWriteFunction
+    return wcsncpy(&buf[0], &buf[3], 4U);
+}
+
+char * overlappingWriteFunction_strncpy(char *buf, const std::size_t count)
+{
+    // No warning shall be shown:
+    (void)strncpy(&buf[0], &buf[3], count); // size is not known
+    (void)strncpy(&buf[0], &buf[3], 3U);    // no-overlap
+    // cppcheck-suppress overlappingWriteFunction
+    return strncpy(&buf[0], &buf[3], 4U);
+}
+
+void * overlappingWriteFunction_memmove(void)
+{
+    // No warning shall be shown:
+    char str[] = "memmove handles overlapping data well";
+    return memmove(str,str+3,4);
+}
+
+std::bitset<10> std_bitset_test_ignoredReturnValue()
+{
+    std::bitset<10> b1("1111010000");
+    // cppcheck-suppress ignoredReturnValue
+    b1.test(2);
+    return b1;
+}
+
+std::bitset<10> std_bitset_all_ignoredReturnValue()
+{
+    std::bitset<10> b1("1111010000");
+    // cppcheck-suppress ignoredReturnValue
+    b1.all();
+    return b1;
+}
+
+std::bitset<10> std_bitset_none_ignoredReturnValue()
+{
+    std::bitset<10> b1("1111010000");
+    // cppcheck-suppress ignoredReturnValue
+    b1.none();
+    return b1;
+}
+
+std::bitset<10> std_bitset_any_ignoredReturnValue()
+{
+    std::bitset<10> b1("1111010000");
+    // cppcheck-suppress ignoredReturnValue
+    b1.any();
+    return b1;
+}
+
+std::bitset<10> std_bitset_size_ignoredReturnValue()
+{
+    std::bitset<10> b1("1111010000");
+    // cppcheck-suppress ignoredReturnValue
+    b1.size();
+    return b1;
+}
+
+std::bitset<10> std_bitset_count_ignoredReturnValue()
+{
+    std::bitset<10> b1("1111010000");
+    // cppcheck-suppress ignoredReturnValue
+    b1.count();
+    return b1;
+}
+
+void std_unordered_set_count_ignoredReturnValue(const std::unordered_set<int>& u)
+{
+    int i;
+    // cppcheck-suppress [uninitvar, ignoredReturnValue]
+    u.count(i);
+}
+
+void std_unordered_map_count_ignoredReturnValue(const std::unordered_map<int, int>& u)
+{
+    int i;
+    // cppcheck-suppress [uninitvar, ignoredReturnValue]
+    u.count(i);
+}
+
+void std_multimap_count_ignoredReturnValue(const std::multimap<int, int>& m)
+{
+    int i;
+    // cppcheck-suppress [uninitvar, ignoredReturnValue]
+    m.count(i);
+}
+
+void std_unordered_map_insert_unnitvar(std::unordered_set<int>& u)
+{
+    int i;
+    // cppcheck-suppress uninitvar
+    u.insert(i);
+}
+
+void std_unordered_map_emplace_unnitvar(std::unordered_set<int>& u)
+{
+    int i;
+    // cppcheck-suppress uninitvar
+    u.emplace(i);
+}
+
+int std_map_find_constref(std::map<int, int>& m) // #11857
+{
+    std::map<int, int>& r = m;
+    std::map<int, int>::iterator it = r.find(42);
+    int* p = &it->second;
+    return ++*p;
+}
+
+void std_rotate_constref(std::vector<int>& v) // #13657
+{
+    std::rotate(v.begin(), v.begin() + 1, v.begin() + 2);
+}
+
+void std_queue_front_ignoredReturnValue(const std::queue<int>& q) {
+    // cppcheck-suppress ignoredReturnValue
+    q.front();
+}
+
+void std_priority_queue_top_ignoredReturnValue(const std::priority_queue<int>& pq) {
+    // cppcheck-suppress ignoredReturnValue
+    pq.top();
+}
+
+void std_tie_ignoredReturnValue(int a, int b)
+{
+    std::set<int> s;
+    std::set<int>::iterator it;
+    bool success;
+    std::tie(it, success) = s.insert(1);
+    // cppcheck-suppress ignoredReturnValue
+    std::tie();
+    // cppcheck-suppress ignoredReturnValue
+    std::tie(a, b);
+}
+
+void std_exception_ignoredReturnValue(const std::exception& e)
+{
+    // cppcheck-suppress ignoredReturnValue
+    e.what();
+}
+
+void valid_code()
+{
+    std::vector<int> vecInt{0, 1, 2};
+    std::fill_n(vecInt.begin(), 2, 0);
+    vecInt.push_back(1);
+    vecInt.pop_back();
+}
 
 void returnValue_std_isgreater(void)
 {
@@ -175,8 +1202,8 @@ void uninitvar_isxdigit(void)
 void uninitvar_proj(void)
 {
     double d;
+    // cppcheck-suppress uninitvar
     const std::complex<double> dc(d,d);
-    // TODO cppcheck-suppress uninitvar
     (void)std::proj(dc);
 }
 
@@ -296,8 +1323,8 @@ void uninitvar_asinh(void)
 void uninitvar_wcsftime(wchar_t* ptr)
 {
     size_t maxsize;
-    wchar_t* format;
-    struct tm* timeptr;
+    const wchar_t* format;
+    const struct tm* timeptr;
     // cppcheck-suppress uninitvar
     (void)std::wcsftime(ptr, maxsize, format, timeptr);
 }
@@ -409,22 +1436,22 @@ void uninitvar_atan2(void)
 
 void uninitvar_atof(void)
 {
-    char * c;
+    const char * c;
     // cppcheck-suppress uninitvar
     (void)std::atof(c);
 }
 
 void uninitvar_atol(void)
 {
-    char * c;
+    const char * c1, *c2, *c3;
     // cppcheck-suppress uninitvar
-    (void)std::atoi(c);
+    (void)std::atoi(c1);
 
     // cppcheck-suppress uninitvar
-    (void)std::atol(c);
+    (void)std::atol(c2);
 
     // cppcheck-suppress uninitvar
-    (void)std::atoll(c);
+    (void)std::atoll(c3);
 }
 
 void uninitvar_ceil(void)
@@ -511,16 +1538,16 @@ void uninitvar_cosh(void)
 
 void uninitvar_feraiseexcept(void)
 {
-    int excepts;
+    int expects;
     // cppcheck-suppress uninitvar
-    (void)std::feraiseexcept(excepts);
+    (void)std::feraiseexcept(expects);
 }
 
-void uninitvar_fesetexceptflag(fexcept_t* flagp)
+void uninitvar_fesetexceptflag(const fexcept_t* flagp)
 {
-    int excepts;
+    int expects;
     // cppcheck-suppress uninitvar
-    (void)std::fesetexceptflag(flagp, excepts);
+    (void)std::fesetexceptflag(flagp, expects);
 }
 
 void uninitvar_feclearexcept(void)
@@ -532,7 +1559,7 @@ void uninitvar_feclearexcept(void)
 
 void uninitvar_fesetenv(void)
 {
-    fenv_t* envp;
+    const fenv_t* envp;
     // cppcheck-suppress uninitvar
     (void)std::fesetenv(envp);
 }
@@ -553,14 +1580,14 @@ void uninitvar_fetestexcept(void)
 
 void uninitvar_feupdateenv(void)
 {
-    fenv_t* envp;
+    const fenv_t* envp;
     // cppcheck-suppress uninitvar
     (void)std::feupdateenv(envp);
 }
 
 void uninitvar_ctime(void)
 {
-    time_t *tp;
+    const time_t *tp;
     // cppcheck-suppress uninitvar
     (void)std::ctime(tp);
 }
@@ -704,6 +1731,7 @@ void uninitvar_fdim(void)
 
 void uninitvar_fclose(void)
 {
+    // cppcheck-suppress unassignedVariable
     FILE *stream;
     // cppcheck-suppress uninitvar
     (void)std::fclose(stream);
@@ -829,22 +1857,23 @@ void uninitvar_fmod(void)
 
 void uninitar_fopen(void)
 {
-    char *filename;
-    char *mode;
+    const char *filename;
+    const char *mode;
     // cppcheck-suppress uninitvar
     FILE * fp = std::fopen(filename, mode);
+    // cppcheck-suppress nullPointerOutOfResources
     fclose(fp);
 }
 
-void uninitar_fprintf(FILE *Stream, char *Format, int Argument)
+void uninitar_fprintf(FILE *Stream, const char *Format, int Argument)
 {
-    FILE *stream;
-    char *format1, *format2;
+    FILE *stream1, *stream2;
+    const char *format1, *format2;
     int argument1, argument2;
     // cppcheck-suppress uninitvar
-    (void)std::fprintf(stream, format1, argument1);
+    (void)std::fprintf(stream1, format1, argument1);
     // cppcheck-suppress uninitvar
-    (void)std::fprintf(stream, Format, Argument);
+    (void)std::fprintf(stream2, Format, Argument);
     // cppcheck-suppress uninitvar
     (void)std::fprintf(Stream, format2, Argument);
     // cppcheck-suppress uninitvar
@@ -856,14 +1885,14 @@ void uninitar_fprintf(FILE *Stream, char *Format, int Argument)
 
 void uninitar_vfprintf(FILE *Stream, const char *Format, va_list Arg)
 {
-    FILE *stream;
-    char *format1, *format2;
+    FILE *stream1, *stream2;
+    const char *format1, *format2;
     va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
-    (void)std::vfprintf(stream, format1, arg);
+    (void)std::vfprintf(stream1, format1, arg);
     // cppcheck-suppress uninitvar
-    (void)std::vfprintf(stream, Format, Arg);
+    (void)std::vfprintf(stream2, Format, Arg);
     // cppcheck-suppress uninitvar
     (void)std::vfprintf(Stream, format2, Arg);
 
@@ -873,16 +1902,16 @@ void uninitar_vfprintf(FILE *Stream, const char *Format, va_list Arg)
     (void)std::vfprintf(Stream, Format, arg);
 }
 
-void uninitar_vfwprintf(FILE *Stream, wchar_t *Format, va_list Arg)
+void uninitar_vfwprintf(FILE *Stream, const wchar_t *Format, va_list Arg)
 {
-    FILE *stream;
-    wchar_t *format1, *format2;
+    FILE *stream1, *stream2;
+    const wchar_t *format1, *format2;
     va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
-    (void)std::vfwprintf(stream, format1, arg);
+    (void)std::vfwprintf(stream1, format1, arg);
     // cppcheck-suppress uninitvar
-    (void)std::vfwprintf(stream, Format, Arg);
+    (void)std::vfwprintf(stream2, Format, Arg);
     // cppcheck-suppress uninitvar
     (void)std::vfwprintf(Stream, format2, Arg);
 
@@ -910,7 +1939,7 @@ void uninitvar_fputwc(void)
 
 void uninitvar_fputs(void)
 {
-    char *string;
+    const char *string;
     FILE *stream;
     // cppcheck-suppress uninitvar
     (void)std::fputs(string,stream);
@@ -918,7 +1947,7 @@ void uninitvar_fputs(void)
 
 void uninitvar_fputws(void)
 {
-    wchar_t *string;
+    const wchar_t *string;
     FILE *stream;
     // cppcheck-suppress uninitvar
     (void)std::fputws(string,stream);
@@ -944,12 +1973,12 @@ void uninitvar_free(void)
 
 void uninitvar_freopen(void)
 {
-    char *filename;
-    char *mode;
+    const char *filename;
+    const char *mode;
     FILE *stream;
     // cppcheck-suppress uninitvar
     FILE * p = std::freopen(filename,mode,stream);
-    free(p);
+    std::fclose(p);
 }
 
 void uninitvar_frexp(void)
@@ -988,7 +2017,7 @@ void uninitvar_hypot(void)
 void uninitvar_fscanf(void)
 {
     FILE *stream;
-    char *format;
+    const char *format;
     int i;
     // cppcheck-suppress uninitvar
     (void)std::fscanf(stream,format,i);
@@ -997,7 +2026,7 @@ void uninitvar_fscanf(void)
 void uninitvar_vfscanf(void)
 {
     FILE *stream;
-    char *format;
+    const char *format;
     va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
@@ -1007,7 +2036,7 @@ void uninitvar_vfscanf(void)
 void uninitvar_vfwscanf(void)
 {
     FILE *stream;
-    wchar_t *format;
+    const wchar_t *format;
     va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
@@ -1023,14 +2052,129 @@ void uninitvar_fseek(void)
     (void)std::fseek(stream,offset,origin);
 }
 
+void invalidFunctionArg_fseek(FILE* stream, long int offset, int origin)
+{
+    // cppcheck-suppress invalidFunctionArg
+    (void)std::fseek(stream, offset, -1);
+    // cppcheck-suppress invalidFunctionArg
+    (void)std::fseek(stream, offset, 3);
+    // cppcheck-suppress invalidFunctionArg
+    (void)std::fseek(stream, offset, 42+SEEK_SET);
+    // cppcheck-suppress invalidFunctionArg
+    (void)std::fseek(stream, offset, SEEK_SET+42);
+    // No warning is expected for
+    (void)std::fseek(stream, offset, origin);
+    (void)std::fseek(stream, offset, SEEK_SET);
+    (void)std::fseek(stream, offset, SEEK_CUR);
+    (void)std::fseek(stream, offset, SEEK_END);
+}
+
+void invalidFunctionArgBool_fseek(FILE* stream, long int offset, int origin)
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)std::fseek(stream, offset, true);
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)std::fseek(stream, offset, false);
+}
+
 void uninitvar_fsetpos(void)
 {
     FILE* stream;
-    fpos_t *ptr;
+    const fpos_t *ptr;
     // cppcheck-suppress uninitvar
     (void)std::fsetpos(stream,ptr);
 }
 
+wchar_t* nullPointer_fgetws(wchar_t* buffer, int n, FILE* stream)
+{
+    // cppcheck-suppress nullPointer
+    (void)std::fgetws(NULL,n,stream);
+    // cppcheck-suppress nullPointer
+    (void)std::fgetws(buffer,n,NULL);
+    // No warning is expected
+    return std::fgetws(buffer, n, stream);
+}
+
+void nullPointer_wmemcmp(const wchar_t* s1, const wchar_t* s2, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)std::wmemcmp(NULL,s2,n);
+    // cppcheck-suppress nullPointer
+    (void)std::wmemcmp(s1,NULL,n);
+    (void)std::wmemcmp(s1,s2,n);
+}
+
+
+void nullPointer_memcmp(const void *s1, const void *s2, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)std::memcmp(NULL,s2,n);
+    // cppcheck-suppress nullPointer
+    (void)std::memcmp(s1,NULL,n);
+    (void)std::memcmp(s1,s2,n);
+}
+
+void nullPointer_strncat(char *d, const char *s, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)std::strncat(NULL,s,n);
+    // cppcheck-suppress nullPointer
+    (void)std::strncat(d,NULL,n);
+    // no warning is expected for
+    (void)std::strncat(d,s,n);
+}
+
+void nullPointer_strcpy(char *dest, const char * const source)
+{
+    // cppcheck-suppress nullPointer
+    (void)std::strcpy(NULL,source);
+    // cppcheck-suppress nullPointer
+    (void)std::strcpy(dest,NULL);
+
+    // no warning shall be shown for
+    (void)std::strcpy(dest,source);
+}
+
+void nullPointer_strcat(char *dest, const char * const source)
+{
+    // cppcheck-suppress nullPointer
+    (void)std::strcat(NULL,source);
+    // cppcheck-suppress nullPointer
+    (void)std::strcat(dest,NULL);
+
+    // no warning shall be shown for
+    (void)std::strcat(dest,source);
+}
+
+void nullPointer_strncpy(char *d, const char *s, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)std::strncpy(NULL,s,n);
+    // cppcheck-suppress nullPointer
+    (void)std::strncpy(d,NULL,n);
+    // no warning is expected for
+    (void)std::strncpy(d,s,n);
+}
+
+void nullPointer_strncmp(const char *s1, const char *s2, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)std::strncmp(NULL,s2,n);
+    // cppcheck-suppress nullPointer
+    (void)std::strncmp(s1,NULL,n);
+    (void)std::strncmp(s1,s2,n);
+}
+
+char* nullPointer_fgets(char *buffer, int n, FILE *stream)
+{
+    // cppcheck-suppress nullPointer
+    (void)std::fgets(NULL,n,stream);
+    // cppcheck-suppress nullPointer
+    (void)std::fgets(buffer,n,NULL);
+    // No warning is expected
+    return std::fgets(buffer, n, stream);
+}
+
 void uninitvar_fgets(void)
 {
     char *buffer;
@@ -1066,7 +2210,7 @@ void uninitvar_fwide(void)
 
 void uninitvar_fwrite(void)
 {
-    void *ptr;
+    const void *ptr;
     size_t size;
     size_t nobj;
     FILE *stream;
@@ -1076,7 +2220,7 @@ void uninitvar_fwrite(void)
 
 void uninitvar_mblen(void)
 {
-    char *string;
+    const char *string;
     size_t size;
     // cppcheck-suppress uninitvar
     (void)std::mblen(string,size);
@@ -1085,7 +2229,7 @@ void uninitvar_mblen(void)
 void uninitvar_mbtowc(void)
 {
     wchar_t* pwc;
-    char* pmb;
+    const char* pmb;
     size_t max;
     // cppcheck-suppress uninitvar
     (void)std::mbtowc(pwc,pmb,max);
@@ -1093,13 +2237,13 @@ void uninitvar_mbtowc(void)
 
 void uninitvar_mbrlen(const char* p, size_t m, mbstate_t* s)
 {
-    char* pmb;
+    const char* pmb1, *pmb2;
     size_t max1, max2;
     mbstate_t* ps1, *ps2;
     // cppcheck-suppress uninitvar
-    (void)std::mbrlen(pmb,max1,ps1);
+    (void)std::mbrlen(pmb1,max1,ps1);
     // cppcheck-suppress uninitvar
-    (void)std::mbrlen(pmb,m,s);
+    (void)std::mbrlen(pmb2,m,s);
     // cppcheck-suppress uninitvar
     (void)std::mbrlen(p,max2,s);
     // cppcheck-suppress uninitvar
@@ -1126,7 +2270,7 @@ void uninitvar_btowc(void)
 
 void uninitvar_mbsinit(void)
 {
-    mbstate_t* ps;
+    const mbstate_t* ps;
     // cppcheck-suppress uninitvar
     (void)std::mbsinit(ps);
 }
@@ -1134,7 +2278,7 @@ void uninitvar_mbsinit(void)
 void uninitvar_mbstowcs(void)
 {
     wchar_t *ws;
-    char *s;
+    const char *s;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)std::mbstowcs(ws,s,n);
@@ -1168,7 +2312,7 @@ void uninitvar_wctomb(void)
 void uninitvar_wcstombs(void)
 {
     char *mbstr;
-    wchar_t *wcstr;
+    const wchar_t *wcstr;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)std::wcstombs(mbstr,wcstr,n);
@@ -1206,14 +2350,14 @@ void uninitvar_ungetwc(void)
 
 void uninitvar_getenv(void)
 {
-    char *name;
+    const char *name;
     // cppcheck-suppress uninitvar
     (void)std::getenv(name);
 }
 
 void uninitvar_gmtime(void)
 {
-    time_t *tp;
+    const time_t *tp;
     // cppcheck-suppress uninitvar
     (void)std::gmtime(tp);
 }
@@ -1348,14 +2492,14 @@ void uninitvar_towupper(void)
 
 void uninitvar_wctrans(void)
 {
-    char* property;
+    const char* property;
     // cppcheck-suppress uninitvar
     (void)std::wctrans(property);
 }
 
 void uninitvar_wctype(void)
 {
-    char* property;
+    const char* property;
     // cppcheck-suppress uninitvar
     (void)std::wctype(property);
 }
@@ -1389,6 +2533,54 @@ void uninitvar_ldexp(void)
     (void)std::ldexp(ldc,e3);
 }
 
+void invalidFunctionArg_lgamma(float f, double d, long double ld)
+{
+    (void)lgamma(d);
+    // TODO cppcheck-suppress invalidFunctionArg
+    (void)lgamma(-0.1);
+    // cppcheck-suppress invalidFunctionArg
+    (void)lgamma(0.0);
+    (void)lgamma(0.1);
+
+    (void)lgammaf(f);
+    // TODO cppcheck-suppress invalidFunctionArg
+    (void)lgammaf(-0.1f);
+    // cppcheck-suppress invalidFunctionArg
+    (void)lgammaf(0.0f);
+    (void)lgammaf(0.1f);
+
+    (void)lgammal(ld);
+    // TODO cppcheck-suppress invalidFunctionArg
+    (void)lgammal(-0.1L);
+    // cppcheck-suppress invalidFunctionArg
+    (void)lgammal(0.0L);
+    (void)lgammal(0.1L);
+}
+
+void invalidFunctionArg_tgamma(float f, double d, long double ld)
+{
+    (void)tgamma(d);
+    // TODO cppcheck-suppress invalidFunctionArg
+    (void)tgamma(-0.1);
+    // cppcheck-suppress invalidFunctionArg
+    (void)tgamma(0.0);
+    (void)tgamma(0.1);
+
+    (void)tgammaf(f);
+    // TODO cppcheck-suppress invalidFunctionArg
+    (void)tgammaf(-0.1f);
+    // cppcheck-suppress invalidFunctionArg
+    (void)tgammaf(0.0f);
+    (void)tgammaf(0.1f);
+
+    (void)tgammal(ld);
+    // TODO cppcheck-suppress invalidFunctionArg
+    (void)tgammal(-0.1L);
+    // cppcheck-suppress invalidFunctionArg
+    (void)tgammal(0.0L);
+    (void)tgammal(0.1L);
+}
+
 void uninitvar_lgamma(void)
 {
     float f;
@@ -1479,11 +2671,25 @@ void uninitvar_llround(void)
     (void)std::llroundl(ld);
 }
 
+void unusedScopedObject_std_monostate(void)
+{
+    // cppcheck-suppress unusedScopedObject
+    std::monostate{};
+}
+
+void unusedScopedObject_std_logic_error()
+{
+    // cppcheck-suppress unusedScopedObject
+    std::logic_error("abc");
+}
+
 void uninitvar_srand(void)
 {
     unsigned int seed;
     // cppcheck-suppress uninitvar
     (void)std::srand(seed);
+    // cppcheck-suppress ignoredReturnValue
+    std::rand();
 }
 
 void uninitvar_ldiv(void)
@@ -1501,7 +2707,7 @@ void uninitvar_ldiv(void)
 
 void uninitvar_localtime(void)
 {
-    time_t *tp;
+    const time_t *tp;
     // cppcheck-suppress uninitvar
     (void)std::localtime(tp);
 }
@@ -1536,6 +2742,13 @@ void uninitvar_fpclassify(void)
     (void)std::fpclassify(ld);
 }
 
+void bool_isfinite(float f)
+{
+    // cppcheck-suppress compareBoolExpressionWithInt
+    // cppcheck-suppress compareValueOutOfTypeRangeError
+    if (std::isfinite(f)==123) {}
+}
+
 void uninitvar_isfinite(void)
 {
     float f;
@@ -1551,6 +2764,13 @@ void uninitvar_isfinite(void)
     (void)std::isfinite(ld);
 }
 
+void bool_isgreater(float f1, float f2)
+{
+    // cppcheck-suppress compareBoolExpressionWithInt
+    // cppcheck-suppress compareValueOutOfTypeRangeError
+    if (std::isgreater(f1,f2)==123) {}
+}
+
 void uninitvar_isgreater(void)
 {
     float f1,f2;
@@ -1566,6 +2786,13 @@ void uninitvar_isgreater(void)
     (void)std::isgreater(ld1,ld2);
 }
 
+void bool_isgreaterequal(float f1, float f2)
+{
+    // cppcheck-suppress compareBoolExpressionWithInt
+    // cppcheck-suppress compareValueOutOfTypeRangeError
+    if (std::isgreaterequal(f1, f2)==123) {}
+}
+
 void uninitvar_isgreaterequal(void)
 {
     float f1,f2;
@@ -1581,6 +2808,13 @@ void uninitvar_isgreaterequal(void)
     (void)std::isgreaterequal(ld1,ld2);
 }
 
+void bool_isinf(float f)
+{
+    // cppcheck-suppress compareBoolExpressionWithInt
+    // cppcheck-suppress compareValueOutOfTypeRangeError
+    if (std::isinf(f)==123) {}
+}
+
 void uninitvar_isinf(void)
 {
     double d;
@@ -1650,13 +2884,13 @@ void uninitvar_islessgreater(void)
 
 void uninitvar_nan(void)
 {
-    char *tagp;
+    const char *tagp1, *tagp2, *tagp3;
     // cppcheck-suppress uninitvar
-    (void)std::nanf(tagp);
+    (void)std::nanf(tagp1);
     // cppcheck-suppress uninitvar
-    (void)std::nan(tagp);
+    (void)std::nan(tagp2);
     // cppcheck-suppress uninitvar
-    (void)std::nanl(tagp);
+    (void)std::nanl(tagp3);
 }
 
 void uninitvar_isnan(void)
@@ -1796,7 +3030,7 @@ void uninitvar_longjmp(void)
 void uninitvar_malloc(void)
 {
     size_t size;
-    // cppcheck-suppress uninitvar
+    // cppcheck-suppress [uninitvar, cstyleCast, unusedAllocatedMemory]
     int *p = (int*)std::malloc(size);
     free(p);
 }
@@ -1821,8 +3055,8 @@ void uninitvar_wmemchr(void)
 
 void uninitvar_memcmp(void)
 {
-    void *s1;
-    void *s2;
+    const void *s1;
+    const void *s2;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)std::memcmp(s1,s2,n);
@@ -1830,8 +3064,8 @@ void uninitvar_memcmp(void)
 
 void uninitvar_wmemcmp(void)
 {
-    wchar_t *s1;
-    wchar_t *s2;
+    const wchar_t *s1;
+    const wchar_t *s2;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)std::wmemcmp(s1,s2,n);
@@ -1840,7 +3074,7 @@ void uninitvar_wmemcmp(void)
 void uninitvar_memcpy(void)
 {
     void *ct;
-    void *cs;
+    const void *cs;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)std::memcpy(ct,cs,n);
@@ -1849,7 +3083,7 @@ void uninitvar_memcpy(void)
 void uninitvar_wmemcpy(void)
 {
     wchar_t *cs;
-    wchar_t *c;
+    const wchar_t *c;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)std::wmemcpy(cs,c,n);
@@ -1858,7 +3092,7 @@ void uninitvar_wmemcpy(void)
 void uninitvar_memmove(void)
 {
     void *ct;
-    void *cs;
+    const void *cs;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)std::memmove(ct,cs,n);
@@ -1885,7 +3119,7 @@ void uninitvar_memset(void)
 void uninitvar_wmemset(void)
 {
     wchar_t *cs;
-    wchar_t  c;
+    wchar_t c;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)std::wmemset(cs,c,n);
@@ -1918,7 +3152,7 @@ void uninivar_modf(void)
 
 void uninivar_perror(void)
 {
-    char *string;
+    const char *string;
     // cppcheck-suppress uninitvar
     (void)std::perror(string);
 }
@@ -1971,9 +3205,9 @@ void uninitvar_remquo(void)
     (void)std::remquol(ld1,ld2,i3);
 }
 
-void uninivar_printf(char *Format, int Argument)
+void uninivar_printf(const char *Format, int Argument)
 {
-    char * format_1, * format_2, * format_3;
+    const char * format_1, * format_2, * format_3;
     int argument1, argument2;
     // no warning is expected
     (void)std::printf("x");
@@ -1990,9 +3224,9 @@ void uninivar_printf(char *Format, int Argument)
     (void)std::printf(Format,Argument);
 }
 
-void uninivar_vprintf(char *Format, va_list Arg)
+void uninivar_vprintf(const char *Format, va_list Arg)
 {
-    char * format1, *format2;
+    const char * format1, *format2;
     va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
@@ -2006,9 +3240,9 @@ void uninivar_vprintf(char *Format, va_list Arg)
     (void)std::vprintf(Format,arg);
 }
 
-void uninivar_vwprintf(wchar_t *Format, va_list Arg)
+void uninivar_vwprintf(const wchar_t *Format, va_list Arg)
 {
-    wchar_t * format1, *format2;
+    const wchar_t * format1, *format2;
     va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
@@ -2024,12 +3258,25 @@ void uninivar_vwprintf(wchar_t *Format, va_list Arg)
 
 void uninivar_bsearch(void)
 {
-    void* key;
-    void* base;
+    const void* key;
+    const void* base;
     size_t num;
     size_t size;
-    // cppcheck-suppress uninitvar
-    (void)std::bsearch(key,base,num,size,(int(*)(const void*,const void*)) strcmp);
+    // cppcheck-suppress [uninitvar, cstyleCast]
+    (void)std::bsearch(key,base,num,size,(int (*)(const void*,const void*))strcmp);
+}
+
+void minsize_bsearch(const void* key, const void* base,
+                     size_t num, size_t size,
+                     int (*compar)(const void*,const void*))
+{
+    const int Base[3] = {42, 43, 44};
+
+    (void)std::bsearch(key,Base,2,size,(int (*)(const void*,const void*))strcmp); // cppcheck-suppress cstyleCast
+    (void)std::bsearch(key,Base,3,size,(int (*)(const void*,const void*))strcmp); // cppcheck-suppress cstyleCast
+    (void)std::bsearch(key,Base,4,size,(int (*)(const void*,const void*))strcmp); // cppcheck-suppress cstyleCast
+
+    (void)std::bsearch(key,base,2,size,(int (*)(const void*,const void*))strcmp); // cppcheck-suppress cstyleCast
 }
 
 void uninitvar_qsort(void)
@@ -2038,7 +3285,42 @@ void uninitvar_qsort(void)
     size_t n;
     size_t size;
     // cppcheck-suppress uninitvar
-    (void)std::qsort(base,n,size, (int(*)(const void*,const void*)) strcmp);
+    (void)std::qsort(base,n,size, (int (*)(const void*,const void*))strcmp); // cppcheck-suppress cstyleCast
+}
+
+void uninitvar_stable_sort(std::vector<int>& v)
+{
+    std::vector<int>::iterator end;
+    // cppcheck-suppress uninitvar
+    std::stable_sort(v.begin(), end);
+}
+
+void uninitvar_merge(const std::vector<int>& a, const std::vector<int>& b)
+{
+    std::vector<int>::iterator dst;
+    // cppcheck-suppress uninitvar
+    std::merge(a.begin(), a.end(), b.begin(), b.end(), dst);
+}
+
+void uninitvar_push_heap(std::vector<int>& v)
+{
+    std::vector<int>::iterator end;
+    // cppcheck-suppress uninitvar
+    std::push_heap(v.begin(), end);
+}
+
+void uninitvar_copy_n(const std::vector<int>& v)
+{
+    std::vector<int>::iterator dst;
+    // cppcheck-suppress [uninitvar, invalidFunctionArg]
+    std::copy_n(v.begin(), -1, dst);
+}
+
+void uninitvar_iota(std::vector<int>& v)
+{
+    int i;
+    // cppcheck-suppress uninitvar
+    std::iota(v.begin(), v.end(), i);
 }
 
 void uninitvar_putc(void)
@@ -2073,7 +3355,7 @@ void uninitvar_putwchar(void)
 
 void uninitvar_puts(void)
 {
-    char *s;
+    const char *s;
     // cppcheck-suppress uninitvar
     (void)std::puts(s);
 }
@@ -2089,15 +3371,15 @@ void uninitvar_realloc(void)
 
 void uninitvar_remove(void)
 {
-    char *s;
+    const char *s;
     // cppcheck-suppress uninitvar
     (void)std::remove(s);
 }
 
 void uninitvar_rename(void)
 {
-    char *s1;
-    char *s2;
+    const char *s1;
+    const char *s2;
     // cppcheck-suppress uninitvar
     (void)std::rename(s1,s2);
 }
@@ -2183,7 +3465,7 @@ void uninivar_raise(void)
 
 void uninivar_scanf(void)
 {
-    char *format;
+    const char *format;
     char str[42];
     // cppcheck-suppress uninitvar
     (void)std::scanf(format, str);
@@ -2191,8 +3473,8 @@ void uninivar_scanf(void)
 
 void uninivar_vsscanf(void)
 {
-    char *s;
-    char *format;
+    const char *s;
+    const char *format;
     va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
@@ -2201,8 +3483,8 @@ void uninivar_vsscanf(void)
 
 void uninivar_vswscanf(void)
 {
-    wchar_t *s;
-    wchar_t *format;
+    const wchar_t *s;
+    const wchar_t *format;
     va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
@@ -2211,7 +3493,7 @@ void uninivar_vswscanf(void)
 
 void uninivar_vscanf(void)
 {
-    char *format;
+    const char *format;
     va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
@@ -2220,19 +3502,43 @@ void uninivar_vscanf(void)
 
 void uninivar_vwscanf(void)
 {
-    wchar_t *format;
+    const wchar_t *format;
     va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
     (void)std::vwscanf(format,arg);
 }
 
-void uninivar_setbuf(void)
+void uninivar_setbuf(void)
+{
+    FILE *stream;
+    char *buf;
+    // cppcheck-suppress uninitvar
+    (void)std::setbuf(stream,buf);
+}
+
+void nullPointer_setbuf(FILE *stream, char *buf)
+{
+    // cppcheck-suppress nullPointer
+    std::setbuf(NULL,buf);
+    std::setbuf(stream,NULL);
+    std::setbuf(stream,buf);
+}
+
+int bufferAccessOutOfBounds_setvbuf(FILE* stream, int mode, size_t size)
+{
+    char buf[42]={0};
+    // cppcheck-suppress bufferAccessOutOfBounds
+    (void) std::setvbuf(stream, buf, mode, 43);
+    return std::setvbuf(stream, buf, mode, 42);
+}
+
+int nullPointer_setvbuf(FILE* stream, char *buf, int mode, size_t size)
 {
-    FILE *stream;
-    char *buf;
-    // cppcheck-suppress uninitvar
-    (void)std::setbuf(stream,buf);
+    // cppcheck-suppress nullPointer
+    (void) std::setvbuf(NULL, buf, mode, size);
+    (void) std::setvbuf(stream, NULL, mode, size);
+    return std::setvbuf(stream, buf, mode, size);
 }
 
 void uninivar_setvbuf(void)
@@ -2248,11 +3554,11 @@ void uninivar_setvbuf(void)
 void uninitvar_strcat(char *dest, const char * const source)
 {
     char *deststr1, *deststr2;
-    char *srcstr;
+    const char *srcstr1, *srcstr2;
     // cppcheck-suppress uninitvar
-    (void)std::strcat(deststr1,srcstr);
+    (void)std::strcat(deststr1,srcstr1);
     // cppcheck-suppress uninitvar
-    (void)std::strcat(dest,srcstr);
+    (void)std::strcat(dest,srcstr2);
     // cppcheck-suppress uninitvar
     (void)std::strcat(deststr2,source);
 
@@ -2263,11 +3569,11 @@ void uninitvar_strcat(char *dest, const char * const source)
 void uninitvar_wcscat(wchar_t *dest, const wchar_t * const source)
 {
     wchar_t *deststr_1, *deststr_2;
-    wchar_t *srcstr;
+    const wchar_t *srcstr1, *srcstr2;
     // cppcheck-suppress uninitvar
-    (void)std::wcscat(deststr_1,srcstr);
+    (void)std::wcscat(deststr_1,srcstr1);
     // cppcheck-suppress uninitvar
-    (void)std::wcscat(dest,srcstr);
+    (void)std::wcscat(dest,srcstr2);
     // cppcheck-suppress uninitvar
     (void)std::wcscat(deststr_2,source);
 
@@ -2286,7 +3592,7 @@ void uninivar_wcrtomb(void)
 
 void uninivar_strchr(void)
 {
-    char *cs;
+    const char *cs;
     int c;
     // cppcheck-suppress uninitvar
     (void)std::strchr(cs,c);
@@ -2294,7 +3600,7 @@ void uninivar_strchr(void)
 
 void uninivar_wcschr(void)
 {
-    wchar_t *cs;
+    const wchar_t *cs;
     wchar_t c;
     // cppcheck-suppress uninitvar
     (void)std::wcschr(cs,c);
@@ -2302,16 +3608,16 @@ void uninivar_wcschr(void)
 
 void uninivar_strcmp(void)
 {
-    char *str1;
-    char *str2;
+    const char *str1;
+    const char *str2;
     // cppcheck-suppress uninitvar
     (void)std::strcmp(str1,str2);
 }
 
 void uninivar_wcscmp(void)
 {
-    wchar_t *str1;
-    wchar_t *str2;
+    const wchar_t *str1;
+    const wchar_t *str2;
     // cppcheck-suppress uninitvar
     (void)std::wcscmp(str1,str2);
 }
@@ -2319,7 +3625,7 @@ void uninivar_wcscmp(void)
 void uninivar_strcpy(void)
 {
     char *str1;
-    char *str2;
+    const char *str2;
     // cppcheck-suppress uninitvar
     (void)std::strcpy(str1,str2);
 }
@@ -2327,7 +3633,7 @@ void uninivar_strcpy(void)
 void uninivar_wcscpy(void)
 {
     wchar_t *str1;
-    wchar_t *str2;
+    const wchar_t *str2;
     // cppcheck-suppress uninitvar
     (void)std::wcscpy(str1,str2);
 }
@@ -2336,22 +3642,22 @@ void uninivar_strftime(void)
 {
     char *s;
     size_t max;
-    char *fmt;
-    struct tm *p;
+    const char *fmt;
+    const struct tm *p;
     // cppcheck-suppress uninitvar
     (void)std::strftime(s,max,fmt,p);
 }
 
 void uninivar_strlen(void)
 {
-    char *s;
+    const char *s;
     // cppcheck-suppress uninitvar
     (void)std::strlen(s);
 }
 
 void uninivar_wcslen(void)
 {
-    wchar_t *s;
+    const wchar_t *s;
     // cppcheck-suppress uninitvar
     (void)std::wcslen(s);
 }
@@ -2359,7 +3665,7 @@ void uninivar_wcslen(void)
 void uninivar_strncpy(void)
 {
     char *s;
-    char *ct;
+    const char *ct;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)std::strncpy(s,ct,n);
@@ -2367,23 +3673,23 @@ void uninivar_strncpy(void)
 
 void uninivar_strpbrk(void)
 {
-    char *cs;
-    char *ct;
+    const char *cs;
+    const char *ct;
     // cppcheck-suppress uninitvar
     (void)std::strpbrk(cs,ct);
 }
 
-void uninivar_strncat(char *Ct, char *S, size_t N)
+void uninivar_strncat(char *Ct, const char *S, size_t N)
 {
     char *ct_1, *ct_2;
-    char *s;
+    const char *s1, *s2;
     size_t n1, n2;
     // cppcheck-suppress uninitvar
-    (void)std::strncat(ct_1,s,n1);
+    (void)std::strncat(ct_1,s1,n1);
     // cppcheck-suppress uninitvar
     (void)std::strncat(ct_2,S,N);
     // cppcheck-suppress uninitvar
-    (void)std::strncat(Ct,s,N);
+    (void)std::strncat(Ct,s2,N);
     // cppcheck-suppress uninitvar
     (void)std::strncat(Ct,S,n2);
 
@@ -2391,17 +3697,17 @@ void uninivar_strncat(char *Ct, char *S, size_t N)
     (void)std::strncat(Ct,S,N);
 }
 
-void uninivar_wcsncat(wchar_t *Ct, wchar_t *S, size_t N)
+void uninivar_wcsncat(wchar_t *Ct, const wchar_t *S, size_t N)
 {
     wchar_t *ct_1, *ct_2;
-    wchar_t *s;
+    const wchar_t *s1, *s2;
     size_t n1, n2;
     // cppcheck-suppress uninitvar
-    (void)std::wcsncat(ct_1,s,n1);
+    (void)std::wcsncat(ct_1,s1,n1);
     // cppcheck-suppress uninitvar
     (void)std::wcsncat(ct_2,S,N);
     // cppcheck-suppress uninitvar
-    (void)std::wcsncat(Ct,s,N);
+    (void)std::wcsncat(Ct,s2,N);
     // cppcheck-suppress uninitvar
     (void)std::wcsncat(Ct,S,n2);
 
@@ -2409,17 +3715,17 @@ void uninivar_wcsncat(wchar_t *Ct, wchar_t *S, size_t N)
     (void)std::wcsncat(Ct,S,N);
 }
 
-void uninivar_strncmp(char *Ct, char *S, size_t N)
+void uninivar_strncmp(const char *Ct, const char *S, size_t N)
 {
-    char *ct;
-    char *s;
+    const char *ct1, *ct2;
+    const char *s1, *s2;
     size_t n1, n2;
     // cppcheck-suppress uninitvar
-    (void)std::strncmp(ct,s,n1);
+    (void)std::strncmp(ct1,s1,n1);
     // cppcheck-suppress uninitvar
-    (void)std::strncmp(ct,S,N);
+    (void)std::strncmp(ct2,S,N);
     // cppcheck-suppress uninitvar
-    (void)std::strncmp(Ct,s,N);
+    (void)std::strncmp(Ct,s2,N);
     // cppcheck-suppress uninitvar
     (void)std::strncmp(Ct,S,n2);
 
@@ -2427,17 +3733,17 @@ void uninivar_strncmp(char *Ct, char *S, size_t N)
     (void)std::strncmp(Ct,S,N);
 }
 
-void uninivar_wcsncmp(wchar_t *Ct, wchar_t *S, size_t N)
+void uninivar_wcsncmp(const wchar_t *Ct, const wchar_t *S, size_t N)
 {
-    wchar_t *ct;
-    wchar_t *s;
+    const wchar_t *ct1, *ct2;
+    const wchar_t *s1, *s2;
     size_t n1, n2;
     // cppcheck-suppress uninitvar
-    (void)std::wcsncmp(ct,s,n1);
+    (void)std::wcsncmp(ct1,s1,n1);
     // cppcheck-suppress uninitvar
-    (void)std::wcsncmp(ct,S,N);
+    (void)std::wcsncmp(ct2,S,N);
     // cppcheck-suppress uninitvar
-    (void)std::wcsncmp(Ct,s,N);
+    (void)std::wcsncmp(Ct,s2,N);
     // cppcheck-suppress uninitvar
     (void)std::wcsncmp(Ct,S,n2);
 
@@ -2448,7 +3754,7 @@ void uninivar_wcsncmp(wchar_t *Ct, wchar_t *S, size_t N)
 void uninivar_strstr(void)
 {
     char *cs;
-    char *ct;
+    const char *ct;
     // cppcheck-suppress uninitvar
     (void)std::strstr(cs,ct);
 }
@@ -2456,15 +3762,15 @@ void uninivar_strstr(void)
 void uninivar_wcsstr(void)
 {
     wchar_t *cs;
-    wchar_t *ct;
+    const wchar_t *ct;
     // cppcheck-suppress uninitvar
     (void)std::wcsstr(cs,ct);
 }
 
 void uninivar_strspn(void)
 {
-    char *cs;
-    char *ct;
+    const char *cs;
+    const char *ct;
     // cppcheck-suppress uninitvar
     (void)std::strspn(cs,ct);
 }
@@ -2472,7 +3778,7 @@ void uninivar_strspn(void)
 void uninivar_strxfrm(void)
 {
     char *ds;
-    char *ss;
+    const char *ss;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)std::strxfrm(ds,ss,n);
@@ -2481,7 +3787,7 @@ void uninivar_strxfrm(void)
 void uninivar_wcsxfrm(void)
 {
     wchar_t *ds;
-    wchar_t *ss;
+    const wchar_t *ss;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)std::wcsxfrm(ds,ss,n);
@@ -2489,8 +3795,8 @@ void uninivar_wcsxfrm(void)
 
 void uninivar_wcsspn(void)
 {
-    wchar_t *ds;
-    wchar_t *ss;
+    const wchar_t *ds;
+    const wchar_t *ss;
     // cppcheck-suppress uninitvar
     (void)std::wcsspn(ds,ss);
 }
@@ -2498,7 +3804,7 @@ void uninivar_wcsspn(void)
 void uninivar_setlocale(void)
 {
     int category;
-    char* locale;
+    const char* locale;
     // cppcheck-suppress uninitvar
     (void)std::setlocale(category,locale);
 }
@@ -2511,24 +3817,24 @@ void uninivar_strerror(void)
 
 void uninivar_strcspn(void)
 {
-    char *cs;
-    char *ct;
+    const char *cs;
+    const char *ct;
     // cppcheck-suppress uninitvar
     (void)std::strcspn(cs,ct);
 }
 
 void uninivar_wcscspn(void)
 {
-    wchar_t *cs;
-    wchar_t *ct;
+    const wchar_t *cs;
+    const wchar_t *ct;
     // cppcheck-suppress uninitvar
     (void)std::wcscspn(cs,ct);
 }
 
 void uninivar_wcspbrk(void)
 {
-    wchar_t *cs;
-    wchar_t *ct;
+    const wchar_t *cs;
+    const wchar_t *ct;
     // cppcheck-suppress uninitvar
     (void)std::wcspbrk(cs,ct);
 }
@@ -2536,7 +3842,7 @@ void uninivar_wcspbrk(void)
 void uninivar_wcsncpy(void)
 {
     wchar_t *cs;
-    wchar_t *ct;
+    const wchar_t *ct;
     size_t n;
     // cppcheck-suppress uninitvar
     (void)std::wcsncpy(cs,ct,n);
@@ -2544,23 +3850,23 @@ void uninivar_wcsncpy(void)
 
 void uninivar_strcoll(void)
 {
-    char *cs;
-    char *ct;
+    const char *cs;
+    const char *ct;
     // cppcheck-suppress uninitvar
     (void)std::strcoll(cs,ct);
 }
 
 void uninivar_wcscoll(void)
 {
-    wchar_t *cs;
-    wchar_t *ct;
+    const wchar_t *cs;
+    const wchar_t *ct;
     // cppcheck-suppress uninitvar
     (void)std::wcscoll(cs,ct);
 }
 
 void uninivar_strrchr(void)
 {
-    char * str;
+    const char * str;
     int c;
     // cppcheck-suppress uninitvar
     (void)std::strrchr(str,c);
@@ -2587,55 +3893,56 @@ void uninivar_wcsrtombs(void)
 void uninivar_strtok(void)
 {
     char *s;
-    char *ct;
+    const char *ct;
     // cppcheck-suppress uninitvar
     (void)std::strtok(s,ct);
 }
 
 void uninivar_strtoimax(void)
 {
-    const char *s;
-    char **endp;
-    int base;
+    const char *s1, *s2;
+    char **endp1, **endp2;
+    int base1, base2;
     // cppcheck-suppress uninitvar
-    (void)std::strtoimax(s,endp,base);
+    (void)std::strtoimax(s1,endp1,base1);
     // cppcheck-suppress uninitvar
-    (void)std::strtoumax(s,endp,base);
+    (void)std::strtoumax(s2,endp2,base2);
 }
 
 void uninivar_strtof(void)
 {
-    const char *s;
-    char **endp;
+    const char *s1, *s2, *s3;
+    char **endp1, **endp2, **endp3;
     // cppcheck-suppress uninitvar
-    (void)std::strtof(s,endp);
+    (void)std::strtof(s1,endp1);
     // cppcheck-suppress uninitvar
-    (void)std::strtod(s,endp);
+    (void)std::strtod(s2,endp2);
     // cppcheck-suppress uninitvar
-    (void)std::strtold(s,endp);
+    (void)std::strtold(s3,endp3);
 }
 
 void uninivar_strtol(void)
 {
-    const char *s;
-    char **endp;
-    int base;
+    const char *s1,*s2,*s3,*s4,*s5,*s6,*s7,*s8;
+    char **endp1, **endp2, **endp3, **endp4, **endp5, **endp6, **endp7, **endp8;
+    int base1, base2, base3, base4, base5, base6, base7, base8;
+
     // cppcheck-suppress uninitvar
-    (void)std::strtol(s,endp,base);
+    (void)std::strtol(s1,endp1,base1);
     // cppcheck-suppress uninitvar
-    (void)std::strtoll(s,endp,base);
+    (void)std::strtoll(s2,endp2,base2);
     // cppcheck-suppress uninitvar
-    (void)std::strtoul(s,endp,base);
+    (void)std::strtoul(s3,endp3,base3);
     // cppcheck-suppress uninitvar
-    (void)std::strtoull(s,endp,base);
+    (void)std::strtoull(s4,endp4,base4);
     // cppcheck-suppress uninitvar
-    (void)std::strtoimax(s,endp,base);
+    (void)std::strtoimax(s5,endp5,base5);
     // cppcheck-suppress uninitvar
-    (void)strtoimax(s,endp,base);
+    (void)strtoimax(s6,endp6,base6);
     // cppcheck-suppress uninitvar
-    (void)std::strtoumax(s,endp,base);
+    (void)std::strtoumax(s7,endp7,base7);
     // cppcheck-suppress uninitvar
-    (void)strtoumax(s,endp,base);
+    (void)strtoumax(s8,endp8,base8);
 }
 
 void uninitvar_time(void)
@@ -2668,14 +3975,14 @@ void uninivar_toupper(void)
 
 void uninivar_wcstof(void)
 {
-    const wchar_t *s;
-    wchar_t **endp;
+    const wchar_t *s1, *s2, *s3;
+    wchar_t **endp1, **endp2, **endp3;
     // cppcheck-suppress uninitvar
-    (void)std::wcstof(s,endp);
+    (void)std::wcstof(s1,endp1);
     // cppcheck-suppress uninitvar
-    (void)std::wcstod(s,endp);
+    (void)std::wcstod(s2,endp2);
     // cppcheck-suppress uninitvar
-    (void)std::wcstold(s,endp);
+    (void)std::wcstold(s3,endp3);
 }
 
 void uninivar_stoX(void)
@@ -2815,50 +4122,50 @@ void uninivar_wcstok(void)
 
 void uninivar_wcstoimax(void)
 {
-    const wchar_t *s;
-    wchar_t ** endp;
-    int base;
+    const wchar_t *s1, *s2;
+    wchar_t ** endp1, **endp2;
+    int base1, base2;
     // cppcheck-suppress uninitvar
-    (void)std::wcstoimax(s,endp,base);
+    (void)std::wcstoimax(s1,endp1,base1);
     // cppcheck-suppress uninitvar
-    (void)std::wcstoumax(s,endp,base);
+    (void)std::wcstoumax(s2,endp2,base2);
 }
 
 void uninivar_wcstol(void)
 {
-    const wchar_t *s;
-    wchar_t ** endp;
-    int base;
+    const wchar_t *s1,*s2,*s3,*s4,*s5,*s6,*s7,*s8;
+    wchar_t **endp1, **endp2, **endp3, **endp4, **endp5, **endp6, **endp7, **endp8;
+    int base1, base2, base3, base4, base5, base6, base7, base8;
     // cppcheck-suppress uninitvar
-    (void)std::wcstol(s,endp,base);
+    (void)std::wcstol(s1,endp1,base1);
     // cppcheck-suppress uninitvar
-    (void)std::wcstoll(s,endp,base);
+    (void)std::wcstoll(s2,endp2,base2);
     // cppcheck-suppress uninitvar
-    (void)std::wcstoul(s,endp,base);
+    (void)std::wcstoul(s3,endp3,base3);
     // cppcheck-suppress uninitvar
-    (void)std::wcstoull(s,endp,base);
+    (void)std::wcstoull(s4,endp4,base4);
     // cppcheck-suppress uninitvar
-    (void)std::wcstoimax(s,endp,base);
+    (void)std::wcstoimax(s5,endp5,base5);
     // cppcheck-suppress uninitvar
-    (void)wcstoimax(s,endp,base);
+    (void)wcstoimax(s6,endp6,base6);
     // cppcheck-suppress uninitvar
-    (void)std::wcstoumax(s,endp,base);
+    (void)std::wcstoumax(s7,endp7,base7);
     // cppcheck-suppress uninitvar
-    (void)wcstoumax(s,endp,base);
+    (void)wcstoumax(s8,endp8,base8);
 }
 
-void uninitvar_wprintf(wchar_t *Format, int Argument)
+void uninitvar_wprintf(const wchar_t *Format, int Argument)
 {
-    const wchar_t *format;
+    const wchar_t *format1, *format2, *format3;
     int argument1, argument2;
     // cppcheck-suppress uninitvar
-    (void)std::wprintf(format,argument1);
+    (void)std::wprintf(format1,argument1);
     // cppcheck-suppress uninitvar
-    (void)std::wprintf(format);
+    (void)std::wprintf(format2);
     // cppcheck-suppress uninitvar
     (void)std::wprintf(Format,argument2);
     // cppcheck-suppress uninitvar
-    (void)std::wprintf(format,Argument);
+    (void)std::wprintf(format3,Argument);
     // no warning is expected
     (void)std::wprintf(Format,Argument);
     (void)std::wprintf(Format);
@@ -2892,6 +4199,14 @@ void uninitvar_vsprintf(void)
     (void)std::vsprintf(s,format,arg);
 }
 
+void nullPointer_vsprintf(va_list arg,const char *format)
+{
+    char *s = NULL;
+    (void)std::vsprintf(s,format,arg); // Its allowed to provide 's' as NULL pointer
+    // cppcheck-suppress nullPointer
+    (void)std::vsprintf(s,NULL,arg);
+}
+
 void uninitvar_vswprintf(void)
 {
     wchar_t *s;
@@ -2912,18 +4227,18 @@ void uninivar_fwprintf(void)
     (void)std::fwprintf(stream,format,i);
 }
 
-void uninivar_snprintf(char *S, size_t N, char *Format, int Int)
+void uninivar_snprintf(char *S, size_t N, const char *Format, int Int)
 {
     size_t n1, n2;
-    char *format;
+    const char *format1, *format2;
     int i1, i2;
     char *s1, *s2;
     // cppcheck-suppress uninitvar
-    (void)std::snprintf(s1,n1,format,i1);
+    (void)std::snprintf(s1,n1,format1,i1);
     // cppcheck-suppress uninitvar
     (void)std::snprintf(S,n2,Format,Int); // n is uninitialized
     // cppcheck-suppress uninitvar
-    (void)std::snprintf(S,N,format,Int); // format is uninitialized
+    (void)std::snprintf(S,N,format2,Int); // format is uninitialized
     // cppcheck-suppress uninitvar
     (void)std::snprintf(S,N,Format,i2); // i is uninitialized
     // cppcheck-suppress uninitvar
@@ -2933,21 +4248,21 @@ void uninivar_snprintf(char *S, size_t N, char *Format, int Int)
     (void)std::snprintf(S,N,Format,Int);
 }
 
-void uninivar_vsnprintf(char *S, size_t N, char *Format, va_list Arg)
+void uninivar_vsnprintf(char *S, size_t N, const char *Format, va_list Arg)
 {
     char *s1, *s2;
     size_t n1, n2;
-    char *format;
+    const char *format1, *format2;
     va_list arg;
     // cppcheck-suppress va_list_usedBeforeStarted
     // cppcheck-suppress uninitvar
-    (void)std::vsnprintf(s1,n1,format,arg);
+    (void)std::vsnprintf(s1,n1,format1,arg);
     // cppcheck-suppress uninitvar
     (void)std::vsnprintf(s2,N,Format,Arg);
     // cppcheck-suppress uninitvar
     (void)std::vsnprintf(S,n2,Format,Arg);
     // cppcheck-suppress uninitvar
-    (void)std::vsnprintf(S,N,format,Arg);
+    (void)std::vsnprintf(S,N,format2,Arg);
 
     // no warning is expected for
     (void)std::vsnprintf(S,N,Format,Arg);
@@ -2957,29 +4272,29 @@ void uninivar_vsnprintf(char *S, size_t N, char *Format, va_list Arg)
 
 void uninivar_wscanf(void)
 {
-    wchar_t *format;
+    const wchar_t *format1, *format2;
     int i;
     // cppcheck-suppress uninitvar
-    (void)std::wscanf(format);
+    (void)std::wscanf(format1);
     // cppcheck-suppress uninitvar
-    (void)std::wscanf(format,&i);
+    (void)std::wscanf(format2,&i);
 }
 
 void uninivar_sscanf(void)
 {
-    char *string;
+    const char *string1, *string2;
     const char * format;
     int i;
     // cppcheck-suppress uninitvar
-    (void)std::sscanf(string,format);
+    (void)std::sscanf(string1,format);
     // cppcheck-suppress uninitvar
-    (void)std::sscanf(string,format,&i);
+    (void)std::sscanf(string2,format,&i);
 }
 
 void uninivar_fwscanf(void)
 {
     FILE* stream;
-    wchar_t* format1, *format2;
+    const wchar_t* format1, *format2;
     int i;
     // cppcheck-suppress uninitvar
     (void)std::fwscanf(stream,format1);
@@ -2989,8 +4304,8 @@ void uninivar_fwscanf(void)
 
 void uninivar_swscanf(void)
 {
-    wchar_t* s;
-    wchar_t* format1, *format2;
+    const wchar_t* s;
+    const wchar_t* format1, *format2;
     int i;
     // cppcheck-suppress uninitvar
     (void)std::swscanf(s,format1);
@@ -3000,15 +4315,55 @@ void uninivar_swscanf(void)
 
 void uninitvar_system(void)
 {
-    char *c;
+    const char *c;
     // cppcheck-suppress uninitvar
     (void)std::system(c);
 }
 
+#ifndef __STDC_NO_THREADS__
+
+void nullPointer_mtx_destroy(mtx_t *mutex )
+{
+    // cppcheck-suppress nullPointer
+    mtx_destroy(nullptr);
+    mtx_destroy(mutex);
+}
+
+void nullPointer_mtx_lock( mtx_t *mutex )
+{
+    // cppcheck-suppress nullPointer
+    mtx_lock(nullptr);
+    mtx_lock(mutex);
+}
+
+void nullPointer_mtx_trylock( mtx_t *mutex )
+{
+    // cppcheck-suppress nullPointer
+    mtx_trylock(nullptr);
+    mtx_trylock(mutex);
+}
+
+int nullPointer_mtx_timedlock( mtx_t *mutex, const struct timespec *time_point )
+{
+    // cppcheck-suppress nullPointer
+    (void) mtx_timedlock(nullptr, time_point);
+    // cppcheck-suppress nullPointer
+    (void) mtx_timedlock(mutex, nullptr);
+    return mtx_timedlock(mutex, time_point);
+}
+#endif
+
+void nullPointer_system(const char *c)
+{
+    // If a null pointer is given, command processor is checked for existence
+    (void)std::system(NULL);
+    (void)std::system(c);
+}
+
 void uninitvar_setw(void)
 {
     int i;
-    // cppcheck-suppress uninitvar
+    // cppcheck-suppress [uninitvar,valueFlowBailoutIncompleteVar]
     std::cout << std::setw(i);
 }
 
@@ -3016,6 +4371,7 @@ void uninitvar_setiosflags(void)
 {
     std::ios_base::fmtflags mask;
     // TODO cppcheck-suppress uninitvar
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
     std::cout << std::setiosflags(mask); // #6987 - false negative
 }
 
@@ -3023,13 +4379,14 @@ void uninitvar_resetiosflags(void)
 {
     std::ios_base::fmtflags mask;
     // TODO cppcheck-suppress uninitvar
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
     std::cout << std::resetiosflags(mask); // #6987 - false negative
 }
 
 void uninitvar_setfill(void)
 {
     char c;
-    // cppcheck-suppress uninitvar
+    // cppcheck-suppress [uninitvar,valueFlowBailoutIncompleteVar]
     std::cout << std::setfill(c);
 
     wchar_t wc;
@@ -3040,17 +4397,18 @@ void uninitvar_setfill(void)
 void uninitvar_setprecision(void)
 {
     int p;
-    // cppcheck-suppress uninitvar
+    // cppcheck-suppress [uninitvar,valueFlowBailoutIncompleteVar]
     std::cout << std::setprecision(p);
 }
 
 void uninitvar_setbase(void)
 {
     int p;
-    // cppcheck-suppress uninitvar
+    // cppcheck-suppress [uninitvar,valueFlowBailoutIncompleteVar]
     std::cout << std::setbase(p);
 }
 
+// cppcheck-suppress passedByValue
 void uninitvar_find(std::string s)
 {
     // testing of size_t find (const string& str, size_t pos = 0)
@@ -3102,13 +4460,13 @@ void uninivar_istream_read(std::istream &f)
     f.read(buffer, size);
 }
 
-void uninitvar_string_compare(std::string &teststr, std::wstring &testwstr)
+void uninitvar_string_compare(const std::string &teststr, const std::wstring &testwstr)
 {
-    char *pStrUninit;
+    const char *pStrUninit;
     // cppcheck-suppress uninitvar
     (void)teststr.compare(pStrUninit);
 
-    wchar_t *pWStrUninit;
+    const wchar_t *pWStrUninit;
     // cppcheck-suppress uninitvar
     (void)testwstr.compare(pWStrUninit);
 }
@@ -3131,6 +4489,7 @@ void ignoredReturnValue_abs(int i)
     std::abs(-199);
 }
 
+// cppcheck-suppress passedByValue
 void ignoredReturnValue_string_compare(std::string teststr, std::wstring testwstr)
 {
     // cppcheck-suppress ignoredReturnValue
@@ -3139,6 +4498,19 @@ void ignoredReturnValue_string_compare(std::string teststr, std::wstring testwst
     testwstr.compare(L"wtest");
 }
 
+// cppcheck-suppress constParameterReference
+void ignoredReturnValue_container_access(std::string& s, std::string_view& sv, std::vector<int>& v)
+{
+    // cppcheck-suppress ignoredReturnValue
+    s.begin();
+    // cppcheck-suppress ignoredReturnValue
+    v.end();
+    // cppcheck-suppress ignoredReturnValue
+    sv.front();
+    // cppcheck-suppress ignoredReturnValue
+    s.at(0);
+}
+
 void ignoredReturnValue_locale_global(const std::locale& loc)
 {
     // no ignoredReturnValue shall be shown for
@@ -3163,9 +4535,31 @@ void nullPointer_istream_read(std::istream &f)
     f.read(NULL, 10);
 }
 
+std::size_t nullPointer_strxfrm(char *dest, const char *src, std::size_t count)
+{
+    (void)strxfrm(dest, src, count);
+    // In case the 3rd argument is 0, the 1st argument is permitted to be a null pointer. (#6306)
+    (void)strxfrm(nullptr, src, 0);
+    (void)strxfrm(nullptr, src, 1);
+    (void)strxfrm(nullptr, src, count);
+    // cppcheck-suppress nullPointer
+    return strxfrm(dest, nullptr, count);
+}
+
+std::size_t nullPointer_wcsxfrm(wchar_t *dest, const wchar_t *src, std::size_t count)
+{
+    (void)wcsxfrm(dest, src, count);
+    // In case the 3rd argument is 0, the 1st argument is permitted to be a null pointer. (#6306)
+    (void)wcsxfrm(nullptr, src, 0);
+    (void)wcsxfrm(nullptr, src, 1);
+    (void)wcsxfrm(nullptr, src, count);
+    // cppcheck-suppress nullPointer
+    return wcsxfrm(dest, nullptr, count);
+}
+
 void nullPointer_asctime(void)
 {
-    struct tm *tm = 0;
+    const struct tm *tm = 0;
     // cppcheck-suppress asctimeCalled
     // cppcheck-suppress nullPointer
     (void)std::asctime(tm);
@@ -3174,15 +4568,15 @@ void nullPointer_asctime(void)
     (void)std::asctime(0);
 }
 
-void nullPointer_wcsftime(size_t maxsize)
+void nullPointer_wcsftime(wchar_t* ptr, size_t maxsize, const wchar_t* format, const struct tm* timeptr)
 {
-    wchar_t* ptr = 0;
-    wchar_t* format = 0;
-    struct tm* timeptr = 0;
     // cppcheck-suppress nullPointer
-    (void)std::wcsftime(ptr,maxsize,format,timeptr);
+    (void)std::wcsftime(NULL, maxsize, format, timeptr);
+    // cppcheck-suppress nullPointer
+    (void)std::wcsftime(ptr, maxsize, NULL, timeptr);
     // cppcheck-suppress nullPointer
-    (void)std::wcsftime(0,maxsize,0,0);
+    (void)std::wcsftime(ptr, maxsize, format, NULL);
+    (void)std::wcsftime(ptr, maxsize, format, timeptr);
 }
 
 void nullPointer_fegetenv(void)
@@ -3194,13 +4588,13 @@ void nullPointer_fegetenv(void)
     (void)std::fegetenv(0);
 }
 
-void nullPointer_fegetexceptflag(int excepts)
+void nullPointer_fegetexceptflag(int expects)
 {
     fexcept_t* flagp = 0;
     // cppcheck-suppress nullPointer
-    (void)std::fegetexceptflag(flagp,excepts);
+    (void)std::fegetexceptflag(flagp,expects);
     // cppcheck-suppress nullPointer
-    (void)std::fegetexceptflag(0,excepts);
+    (void)std::fegetexceptflag(0,expects);
 }
 
 void nullPointer_feholdexcept(void)
@@ -3214,25 +4608,25 @@ void nullPointer_feholdexcept(void)
 
 void nullPointer_fesetenv(void)
 {
-    fenv_t* envp = 0;
+    const fenv_t* envp = 0;
     // cppcheck-suppress nullPointer
     (void)std::fesetenv(envp);
     // cppcheck-suppress nullPointer
     (void)std::fesetenv(0);
 }
 
-void nullPointer_fesetexceptflag(int excepts)
+void nullPointer_fesetexceptflag(int expects)
 {
-    fexcept_t* flagp = 0;
+    const fexcept_t* flagp = 0;
     // cppcheck-suppress nullPointer
-    (void)std::fesetexceptflag(flagp,excepts);
+    (void)std::fesetexceptflag(flagp,expects);
     // cppcheck-suppress nullPointer
-    (void)std::fesetexceptflag(0,excepts);
+    (void)std::fesetexceptflag(0,expects);
 }
 
 void nullPointer_feupdateenv(void)
 {
-    fenv_t* envp = 0;
+    const fenv_t* envp = 0;
     // cppcheck-suppress nullPointer
     (void)std::feupdateenv(envp);
     // cppcheck-suppress nullPointer
@@ -3247,23 +4641,45 @@ void nullPointer_atexit(void)
 
 void nullPointer_atof(void)
 {
-    char * c = 0;
+    const char * c = 0;
     // cppcheck-suppress nullPointer
     (void)std::atof(c);
     // cppcheck-suppress nullPointer
     (void)std::atof(0);
 }
 
-void nullPointer_memcmp(char *p)
+void nullPointer_memcpy(void *s1, const void *s2, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)std::memcpy(NULL,s2,n);
+    // cppcheck-suppress nullPointer
+    (void)std::memcpy(s1,NULL,n);
+    (void)std::memcpy(s1,s2,n);
+}
+
+void nullPointer_memmove(void *s1, void *s2, size_t n)
+{
+    // cppcheck-suppress nullPointer
+    (void)std::memmove(NULL,s2,n);
+    // cppcheck-suppress nullPointer
+    (void)std::memmove(s1,NULL,n);
+    (void)std::memmove(s1,s2,n);
+}
+
+void nullPointer_wmemmove(wchar_t* s1, const wchar_t* s2, size_t n)
 {
     // cppcheck-suppress nullPointer
-    (void)std::memcmp(p, 0, 123);
+    (void)std::wmemmove(NULL,s2,n);
+    // cppcheck-suppress nullPointer
+    (void)std::wmemmove(s1,NULL,n);
+    (void)std::wmemmove(s1,s2,n);
 }
 
-void nullPointer_wmemcmp(wchar_t *p)
+void nullPointer_wmemset(wchar_t* s, wchar_t c, size_t n)
 {
     // cppcheck-suppress nullPointer
-    (void)std::wmemcmp(p, 0, 123);
+    (void)std::wmemset(NULL,c,n);
+    (void)std::wmemset(s,c,n);
 }
 
 ///////////////////////////////////////////////////////////////////////
@@ -3273,7 +4689,7 @@ void nullPointer_wmemcmp(wchar_t *p)
 #include <algorithm>
 #include <list>
 
-#define pred    [](int i){return i==0;}
+#define pred    [] (int i) {return i==0;}
 
 
 void stdalgorithm(const std::list<int> &ints1, const std::list<int> &ints2)
@@ -3285,6 +4701,12 @@ void stdalgorithm(const std::list<int> &ints1, const std::list<int> &ints2)
     // cppcheck-suppress mismatchingContainers
     if (std::find(ints1.begin(), ints1.end(), 123) == ints2.end()) {}
 
+    // #9455
+    std::list<int>::const_iterator uninitItBegin;
+    std::list<int>::const_iterator uninitItEnd;
+    // cppcheck-suppress uninitvar
+    if (std::find(uninitItBegin, uninitItEnd, 123) == uninitItEnd) {}
+
     // <!-- InputIterator std::find_if(InputIterator first, InputIterator last, UnaryPredicate val) -->
     // cppcheck-suppress mismatchingContainers
     // cppcheck-suppress ignoredReturnValue
@@ -3327,10 +4749,8 @@ void stdalgorithm(const std::list<int> &ints1, const std::list<int> &ints2)
     // <!-- Function std::for_each(InputIterator first, InputIterator last, Function func) -->
     // cppcheck-suppress mismatchingContainers
     std::for_each(ints1.begin(), ints2.end(), [](int i) {});
-
 }
 
-
 void getline()
 {
     // #837
@@ -3353,6 +4773,12 @@ void getline()
     in.close();
 }
 
+// cppcheck-suppress passedByValue
+void stream_write(std::ofstream& s, std::vector<char> v) {
+    if (v.empty()) {}
+    s.write(v.data(), v.size());
+}
+
 void stdstring()
 {
     std::string s;
@@ -3361,6 +4787,11 @@ void stdstring()
 
     // valid
     s.assign("a");
+
+#ifdef __cpp_lib_starts_ends_with
+    // cppcheck-suppress ignoredReturnValue
+    s.starts_with("abc");
+#endif
 }
 
 void stdvector()
@@ -3415,8 +4846,490 @@ void stdbind()
     // TODO cppcheck-suppress ignoredReturnValue #9369
     std::bind(stdbind_helper, 1);
 
-    // cppcheck-suppress unreadVariable
+    // TODO cppcheck-suppress unreadVariable
+    // cppcheck-suppress autoNoType
     auto f1 = std::bind(stdbind_helper, _1);
-    // cppcheck-suppress unreadVariable
+    // TODO cppcheck-suppress unreadVariable
+    // cppcheck-suppress autoNoType
     auto f2 = std::bind(stdbind_helper, 10);
 }
+
+int stdexchange() {
+    int i;
+    // cppcheck-suppress uninitvar
+    int j = std::exchange(i, 5);
+    return j;
+}
+
+class A
+{
+    std::vector<std::string> m_str;
+
+public:
+
+    A() {}
+
+    // cppcheck-suppress functionConst
+    void begin_const_iterator(void)
+    {
+        for (std::vector<std::string>::const_iterator it = m_str.begin(); it != m_str.end(); ++it) {;}
+    }
+    // cppcheck-suppress functionConst
+    void cbegin_const_iterator(void)
+    {
+        for (std::vector<std::string>::const_iterator it = m_str.cbegin(); it != m_str.cend(); ++it) {;}
+    }
+    // cppcheck-suppress functionConst
+    void crbegin_const_iterator(void)
+    {
+        for (std::vector<std::string>::const_reverse_iterator it = m_str.crbegin(); it != m_str.crend(); ++it) {;}
+    }
+    // cppcheck-suppress functionConst
+    void rbegin_const_iterator(void)
+    {
+        for (std::vector<std::string>::const_reverse_iterator it = m_str.rbegin(); it != m_str.rend(); ++it) {;}
+    }
+    // cppcheck-suppress functionConst
+    void cbegin_auto(void)
+    {
+        for (auto it = m_str.cbegin(); it != m_str.cend(); ++it) {;}
+    }
+    void baz_begin_no_const_iterator(void)
+    {
+        for (std::vector<std::string>::iterator it = m_str.begin(); it != m_str.end(); ++it) {;}
+    }
+    void rbegin_no_const_iterator(void)
+    {
+        for (std::vector<std::string>::reverse_iterator it = m_str.rbegin(); it != m_str.rend(); ++it) {;}
+    }
+};
+
+void addressof(int a)
+{
+    // cppcheck-suppress ignoredReturnValue
+    std::addressof(a);
+}
+
+void string_view_unused(std::string_view v)
+{
+    // cppcheck-suppress ignoredReturnValue
+    v.substr(1, 3);
+}
+
+// cppcheck-suppress passedByValue
+void string_substr(std::string s)
+{
+    // cppcheck-suppress ignoredReturnValue
+    s.substr(1, 3);
+}
+
+#ifndef __cpp_lib_span
+#warning "This compiler does not support std::span"
+#else
+void stdspan()
+{
+
+    std::vector<int> vec{1,2,3,4};
+    std::span spn{vec};
+    // cppcheck-suppress unreadVariable
+    std::span spn2 = spn;
+
+    //cppcheck-suppress ignoredReturnValue
+    spn.begin();
+    //cppcheck-suppress ignoredReturnValue
+    spn.end();
+    //cppcheck-suppress ignoredReturnValue
+    spn.rbegin();
+
+    //cppcheck-suppress ignoredReturnValue
+    spn.front();
+    //cppcheck-suppress ignoredReturnValue
+    spn.back();
+    //cppcheck-suppress constStatement
+    spn[0];
+    //cppcheck-suppress ignoredReturnValue
+    spn.data();
+    //cppcheck-suppress ignoredReturnValue
+    spn.size();
+    //cppcheck-suppress ignoredReturnValue
+    spn.size_bytes();
+    //cppcheck-suppress ignoredReturnValue
+    spn.empty();
+    //cppcheck-suppress ignoredReturnValue
+    spn.first(2);
+    //cppcheck-suppress ignoredReturnValue
+    spn.last(2);
+    //cppcheck-suppress ignoredReturnValue
+    spn.subspan(1, 2);
+    spn.subspan<1>();
+
+    static constexpr std::array<int, 2> arr{1, 2};
+    constexpr std::span spn3{arr};
+    spn3.first<1>();
+    spn3.last<1>();
+    spn3.subspan<1, 1>();
+}
+
+std::span<const int> returnDanglingLifetime_std_span0() {
+    static int a[10]{};
+    return a;
+}
+
+std::span<const int> returnDanglingLifetime_std_span1() {
+    static std::vector<int> v;
+    return v;
+}
+#endif
+
+void beginEnd()
+{
+    std::vector<int> v;
+
+    //cppcheck-suppress ignoredReturnValue
+    std::begin(v);
+    //cppcheck-suppress ignoredReturnValue
+    std::rbegin(v);
+    //cppcheck-suppress ignoredReturnValue
+    std::cbegin(v);
+    //cppcheck-suppress ignoredReturnValue
+    std::crbegin(v);
+
+    //cppcheck-suppress ignoredReturnValue
+    std::end(v);
+    //cppcheck-suppress ignoredReturnValue
+    std::rend(v);
+    //cppcheck-suppress ignoredReturnValue
+    std::cend(v);
+    //cppcheck-suppress ignoredReturnValue
+    std::crend(v);
+
+    // cppcheck-suppress constVariable
+    int arr[4];
+
+    //cppcheck-suppress ignoredReturnValue
+    std::begin(arr);
+    //cppcheck-suppress ignoredReturnValue
+    std::rbegin(arr);
+    //cppcheck-suppress ignoredReturnValue
+    std::cbegin(arr);
+    //cppcheck-suppress ignoredReturnValue
+    std::crbegin(arr);
+
+    //cppcheck-suppress ignoredReturnValue
+    std::end(arr);
+    //cppcheck-suppress ignoredReturnValue
+    std::rend(arr);
+    //cppcheck-suppress ignoredReturnValue
+    std::cend(arr);
+    //cppcheck-suppress ignoredReturnValue
+    std::crend(arr);
+}
+
+void smartPtr_get()
+{
+    std::unique_ptr<int> p;
+    //cppcheck-suppress ignoredReturnValue
+    p.get();
+    //cppcheck-suppress nullPointer
+    *p = 1;
+}
+
+void smartPtr_get2(std::vector<std::unique_ptr<int>>& v)
+{
+    // cppcheck-suppress autoNoType
+    for (auto& u : v) {
+        int* p = u.get();
+        *p = 0;
+    }
+}
+
+bool smartPtr_get3(size_t n, size_t i) { // #12748
+    std::unique_ptr<int[]> buf = std::make_unique<int[]>(n);
+    const int* p = buf.get() + i;
+    return p != nullptr;
+}
+
+void smartPtr_reset()
+{
+    std::unique_ptr<int> p(new int());
+    p.reset(nullptr);
+    //cppcheck-suppress nullPointer
+    *p = 1;
+}
+
+void smartPtr_release()
+{
+    std::unique_ptr<int> p{ new int() };
+    //cppcheck-suppress ignoredReturnValue
+    p.release();
+    //cppcheck-suppress nullPointer
+    *p = 1;
+}
+
+void std_vector_data_arithmetic()
+{
+    std::vector<char> buf;
+    buf.resize(1);
+    memcpy(buf.data() + 0, "", 1);
+}
+
+void memleak_std_malloc() // #12332
+{
+    //cppcheck-suppress [unreadVariable, constVariablePointer, unusedAllocatedMemory]
+    void* p = std::malloc(1);
+    //cppcheck-suppress memleak
+}
+
+void memleak_std_realloc(void* block, size_t newsize)
+{
+    //cppcheck-suppress [unreadVariable, constVariablePointer]
+    void* p = std::realloc(block, newsize);
+    //cppcheck-suppress memleak
+}
+
+void unusedAllocatedMemory_std_free()
+{
+    // cppcheck-suppress unusedAllocatedMemory
+    void* p = std::malloc(1);
+    std::free(p);
+}
+
+std::string global_scope_std() // #12355
+{
+    ::std::stringstream ss;
+    return ss.str();
+}
+
+::std::size_t global_scope_std2() // #12378
+{
+    std::vector<::std::size_t> v;
+    // cppcheck-suppress containerOutOfBounds
+    return v.front();
+}
+
+void unique_lock_const_ref(std::mutex& m)
+{
+    std::unique_lock lock(m);
+}
+
+void eraseIteratorOutOfBounds_std_deque(std::deque<int>& x) // #8690
+{
+    // cppcheck-suppress eraseIteratorOutOfBounds
+    x.erase(x.end());
+}
+
+void assertWithSideEffect_system()
+{
+    // cppcheck-suppress [assertWithSideEffect,checkLibraryNoReturn] // TODO: #8329
+    assert(std::system("abc"));
+}
+
+void assertWithSideEffect_std_map_at(const std::map<int, int>& m) // #12695
+{
+    // cppcheck-suppress checkLibraryNoReturn
+    assert(m.at(0));
+}
+
+void assertWithSideEffect_std_unique_ptr_get(std::unique_ptr<int>& p)
+{
+    // cppcheck-suppress checkLibraryNoReturn
+    assert(p.get());
+}
+
+void assertWithSideEffect_std_begin(const std::vector<std::string>& v) {
+    // cppcheck-suppress checkLibraryFunction // TODO
+    assert(std::is_sorted(std::begin(v), std::end(v), [](const std::string& a, const std::string& b) {
+        return a.size() < b.size();
+    })); // cppcheck-suppress checkLibraryNoReturn
+}
+
+void assertWithSideEffect_std_prev_next(const std::vector<int>& v, std::vector<int>::const_iterator it) {
+    assert(std::prev(it, 1) == v.begin());
+    // cppcheck-suppress checkLibraryNoReturn
+    assert(std::next(it, 1) == v.end());
+}
+
+std::vector<int> containerOutOfBounds_push_back() { // #12775
+    std::vector<int> v;
+    for (int i = 0; i < 4; ++i) {
+        v.push_back(i);
+        (void)v[i];
+    }
+    return v;
+}
+
+template<typename T>
+void constVariablePointer_push_back(std::vector<T*>& d, const std::vector<T*>& s) {
+    for (const auto& e : s) {
+        T* newE = new T(*e);
+        d.push_back(newE);
+    }
+}
+
+struct S_constVariablePointer_wstring { // #14575
+    std::wstring m;
+    const std::wstring& get() const { return m; }
+};
+
+S_constVariablePointer_wstring* g_constVariablePointer_wstring();
+
+void h_constVariablePointer_wstring(const wchar_t*);
+
+void f_constVariablePointer_wstring() {
+    S_constVariablePointer_wstring* s = g_constVariablePointer_wstring(); // cppcheck-suppress constVariablePointer
+    h_constVariablePointer_wstring(s->get().c_str());
+}
+
+std::streampos constParameterPointer_istream_tellg(std::istream* p) { // #13801
+    return p->tellg();
+}
+
+void constParameterPointer_unique_ptr_reset(std::unique_ptr<int>& u, int* p) {
+    u.reset(p);
+}
+
+bool constParameterPointer_map_contains(const std::map<int*, int>& m, int* p) {
+#if __cplusplus >= 202002L
+    return m.contains(p);
+#else
+    return m.count(p) > 0;
+#endif
+}
+
+// cppcheck-suppress constParameterReference
+void constParameterReference_push_back(std::vector<std::string>& v, std::string& s) { // #12661
+    v.push_back(s);
+}
+
+// cppcheck-suppress constParameterReference
+void constParameterReference_assign(std::vector<int>& v, int& r) {
+    v.assign(5, r);
+}
+
+// cppcheck-suppress constParameterReference
+void constParameterReference_insert(std::list<int>& l, int& r) {
+    l.insert(l.end(), r);
+    l.insert(l.end(), 5, r);
+}
+
+const char* variableScope_cstr_dummy(const char* q); // #12812
+std::size_t variableScope_cstr(const char* p) {
+    std::string s;
+    if (!p) {
+        s = "abc";
+        p = variableScope_cstr_dummy(s.c_str());
+    }
+    return std::strlen(p);
+}
+
+void unusedvar_stringstream(const char* p)
+{
+    // cppcheck-suppress unreadVariable
+    std::istringstream istr(p);
+    // cppcheck-suppress unreadVariable
+    std::ostringstream ostr(p);
+    // cppcheck-suppress unreadVariable
+    std::stringstream sstr(p);
+}
+
+void unusedvar_stdcomplex()
+{
+    // cppcheck-suppress unusedVariable
+    std::complex<double> z1;
+    // cppcheck-suppress unreadVariable
+    std::complex<double> z2(0.0, 0.0);
+}
+
+int passedByValue_std_array1(std::array<int, 2> a)
+{
+    return a[0] + a[1];
+}
+
+// cppcheck-suppress passedByValue
+int passedByValue_std_array2(std::array<int, 200> a)
+{
+    return a[0] + a[1];
+}
+
+int passedByValue_std_bitset1(std::bitset<4> bs) // #12961
+{
+    return bs.size();
+}
+
+// cppcheck-suppress passedByValue
+int passedByValue_std_bitset2(std::bitset<256> bs)
+{
+    return bs.size();
+}
+
+struct S_std_as_const { // #12974
+    // cppcheck-suppress functionConst
+    void f() {
+        for (const int i : std::as_const(l)) {}
+    }
+    std::list<int> l;
+};
+
+#if __cpp_lib_format
+void unreadVariable_std_format_error(char * c)
+{
+    // cppcheck-suppress unreadVariable
+    std::format_error x(c);
+}
+#endif
+
+void eraseIteratorOutOfBounds_std_list1()
+{
+    std::list<int> a;
+    std::list<int>::iterator p = a.begin();
+    // cppcheck-suppress eraseIteratorOutOfBounds
+    a.erase(p);
+}
+int eraseIteratorOutOfBounds_std_list2()
+{
+    std::list<int> a;
+    std::list<int>::iterator p = a.begin();
+    std::list<int>::iterator q = p;
+    // cppcheck-suppress eraseIteratorOutOfBounds
+    a.erase(q);
+    return *q;
+}
+
+void containerOutOfBounds_std_string(std::string &var) { // #11403
+    std::string s0{"x"};
+    // cppcheck-suppress containerOutOfBounds
+    var+= s0[2];
+
+    std::string s1{ R"(x)" };
+    // cppcheck-suppress containerOutOfBounds
+    var+= s1[2];
+
+    std::string s2 = R"--(XYZ)--";
+    // cppcheck-suppress containerOutOfBounds
+    var+= s2[3];
+
+    std::string s3 = {R"--(XYZ)--"};
+    // cppcheck-suppress containerOutOfBounds
+    var+= s3[3];
+
+    const char *x = R"--(XYZ)--";
+    std::string s4(x);
+    // TODO cppcheck-suppress containerOutOfBounds
+    var+= s4[3];
+
+    std::string s5{x};
+    // TODO cppcheck-suppress containerOutOfBounds
+    var+= s5[3];
+}
+
+int containerOutOfBounds_std_initializer_list_access(const std::vector<int>& v) {
+    // cppcheck-suppress containerOutOfBounds
+    return v[2];
+}
+
+int containerOutOfBounds_std_initializer_list() { // #14340
+    std::initializer_list<int> x{ 1, 2 };
+    // cppcheck-suppress derefInvalidIterator
+    int i = *x.end();
+    return i + containerOutOfBounds_std_initializer_list_access(x);
+}
diff --git a/test/cfg/windows.cpp b/test/cfg/windows.cpp
index d2a82e6acd5..f92c9941d81 100644
--- a/test/cfg/windows.cpp
+++ b/test/cfg/windows.cpp
@@ -2,14 +2,218 @@
 // Test library configuration for windows.cfg
 //
 // Usage:
-// $ cppcheck --check-library --library=windows --enable=information --error-exitcode=1 --inline-suppr --suppress=missingIncludeSystem test/cfg/windows.cpp
+// $ cppcheck --check-library --library=windows --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/windows.cpp
 // =>
 // No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
 //
 
-#include <windows.h>
+// cppcheck-suppress-file [valueFlowBailout,purgedConfiguration]
+
+#include <Windows.h>
+#include <WinCon.h>
+#include <SetupAPI.h>
+#include <cstdio>
 #include <direct.h>
-#include <stdlib.h>
+#include <evntrace.h>
+#include <cstdlib>
+#include <ctime>
+#include <memory.h>
+#include <mbstring.h>
+#include <tchar.h>
+#include <wchar.h>
+#include <atlstr.h>
+#include <string>
+
+bool UpdateTraceACalled(TRACEHANDLE traceHandle, LPCSTR loggerName, EVENT_TRACE_PROPERTIES* pProperties)
+{
+    // cppcheck-suppress UpdateTraceACalled
+    return UpdateTraceA(traceHandle, loggerName, pProperties) != ERROR_SUCCESS;
+}
+bool UpdateTraceWCalled(TRACEHANDLE traceHandle, LPCWSTR loggerName, EVENT_TRACE_PROPERTIES* pProperties)
+{
+    // cppcheck-suppress UpdateTraceWCalled
+    return UpdateTraceW(traceHandle, loggerName, pProperties) != ERROR_SUCCESS;
+}
+
+void invalidHandle_CreateFile(LPCWSTR lpFileName)
+{
+    HANDLE file = CreateFile(lpFileName, GENERIC_READ, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
+
+    // INVALID_HANDLE_VALUE is not the same as 0
+    if (file != INVALID_HANDLE_VALUE && file) {}
+
+    // cppcheck-suppress resourceLeak
+}
+
+void invalid_socket()
+{
+    SOCKET sock = socket(AF_INET, SOCK_RAW, IPPROTO_TCP);
+
+    // INVALID_SOCKET is not the same as 0
+    if (sock != INVALID_SOCKET && sock) {}
+
+    // cppcheck-suppress resourceLeak
+}
+
+void invalid_socket_noleak(int a, int t, int p) { // #14155
+    SOCKET s = socket(a, t, p);
+    if (s == INVALID_SOCKET)
+        return;
+    closesocket(s);
+}
+
+void resourceLeak_OpenThread(const DWORD dwDesiredAccess, const BOOL bInheritHandle, const DWORD dwThreadId)
+{
+    HANDLE proc = OpenThread(dwDesiredAccess, bInheritHandle, dwThreadId);
+    if (proc != INVALID_HANDLE_VALUE) {}
+    // cppcheck-suppress resourceLeak
+}
+
+void resourceLeak_OpenProcess(const DWORD dwDesiredAccess, const BOOL bInheritHandle, const DWORD dwProcessId)
+{
+    HANDLE proc = OpenProcess(dwDesiredAccess, bInheritHandle, dwProcessId);
+    if (proc != INVALID_HANDLE_VALUE) {}
+    // cppcheck-suppress resourceLeak
+}
+
+/// https://learn.microsoft.com/en-us/windows/console/flushconsoleinputbuffer
+BOOL unreachableCode_FlushConsoleInputBuffer(int &val)
+{
+    const BOOL retVal = FlushConsoleInputBuffer(GetStdHandle(STD_INPUT_HANDLE));
+    // still reachable after call FlushConsoleInputBuffer()
+    val = 42;
+    return retVal;
+}
+
+/// https://learn.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-getmodulefilenamew
+std::string constVariable_GetModuleFileName(void) {
+    char path[42];
+    if (GetModuleFileNameA(NULL, path, sizeof(path))==0)
+        return std::string();
+    return std::string{path};
+}
+
+int stringCompare_mbscmp(const unsigned char *string1, const unsigned char *string2)
+{
+    // cppcheck-suppress stringCompare
+    (void) _mbscmp(string1, string1);
+    const unsigned char x[] = "x";
+    // cppcheck-suppress stringCompare
+    (void) _mbscmp(x, x);
+    return _mbscmp(string1, string2);
+}
+
+int stringCompare_mbscmp_l(const unsigned char *string1, const unsigned char *string2, _locale_t locale)
+{
+    // cppcheck-suppress stringCompare
+    (void) _mbscmp_l(string1, string1, locale);
+    const unsigned char x[] = "x";
+    // cppcheck-suppress stringCompare
+    (void) _mbscmp_l(x, x, locale);
+    return _mbscmp_l(string1, string2, locale);
+}
+
+int ignoredReturnValue__wtoi_l(const wchar_t *str, _locale_t locale)
+{
+    // cppcheck-suppress ignoredReturnValue
+    _wtoi_l(str,locale);
+    return _wtoi_l(str,locale);
+}
+
+int ignoredReturnValue__atoi_l(const char *str, _locale_t locale)
+{
+    // cppcheck-suppress ignoredReturnValue
+    _atoi_l(str,locale);
+    return _atoi_l(str,locale);
+}
+
+void invalidFunctionArg__fseeki64(FILE* stream, __int64 offset, int origin)
+{
+    // cppcheck-suppress invalidFunctionArg
+    (void)_fseeki64(stream, offset, -1);
+    // cppcheck-suppress invalidFunctionArg
+    (void)_fseeki64(stream, offset, 3);
+    // cppcheck-suppress invalidFunctionArg
+    (void)_fseeki64(stream, offset, 42+SEEK_SET);
+    // cppcheck-suppress invalidFunctionArg
+    (void)_fseeki64(stream, offset, SEEK_SET+42);
+    // No warning is expected for
+    (void)_fseeki64(stream, offset, origin);
+    (void)_fseeki64(stream, offset, SEEK_SET);
+    (void)_fseeki64(stream, offset, SEEK_CUR);
+    (void)_fseeki64(stream, offset, SEEK_END);
+}
+
+void invalidFunctionArgBool__fseeki64(FILE* stream, __int64 offset)
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)_fseeki64(stream, offset, true);
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)_fseeki64(stream, offset, false);
+}
+
+unsigned char * overlappingWriteFunction__mbscat(unsigned char *src, unsigned char *dest)
+{
+    // No warning shall be shown:
+    (void)_mbscat(dest, src);
+    // cppcheck-suppress overlappingWriteFunction
+    return _mbscat(src, src);
+}
+
+void* overlappingWriteFunction__memccpy(const unsigned char *src, unsigned char *dest, int c, size_t count)
+{
+    // No warning shall be shown:
+    (void)_memccpy(dest, src, c, count);
+    (void)_memccpy(dest, src, 42, count);
+    // cppcheck-suppress overlappingWriteFunction
+    (void) _memccpy(dest, dest, c, 4);
+    // cppcheck-suppress overlappingWriteFunction
+    return _memccpy(dest, dest+3, c, 4);
+}
+
+unsigned char * overlappingWriteFunction__mbscpy(unsigned char *src, unsigned char *dest)
+{
+    // No warning shall be shown:
+    (void)_mbscpy(dest, src);
+    // cppcheck-suppress overlappingWriteFunction
+    return _mbscpy(src, src);
+}
+
+void overlappingWriteFunction__swab(char *src, char *dest, int n)
+{
+    // No warning shall be shown:
+    _swab(dest, src, n);
+    // cppcheck-suppress overlappingWriteFunction
+    _swab(src, src+3, 4);
+}
+
+SYSTEM_INFO uninitvar_GetSystemInfo()
+{
+    // No warning is expected
+    SYSTEM_INFO SystemInfo;
+    GetSystemInfo(&SystemInfo);
+    return SystemInfo;
+}
+
+void uninitvar__putenv(const char * envstr)
+{
+    // No warning is expected
+    (void)_putenv(envstr);
+
+    const char * p;
+    // cppcheck-suppress uninitvar
+    (void)_putenv(p);
+}
+
+void nullPointer__putenv(const char * envstr)
+{
+    // No warning is expected
+    (void)_putenv(envstr);
+
+    const char * p=NULL;
+    // cppcheck-suppress nullPointer
+    (void)_putenv(p);
+}
 
 void invalidFunctionArg__getcwd(char * buffer)
 {
@@ -21,6 +225,48 @@ void invalidFunctionArg__getcwd(char * buffer)
     }
     free(buffer);
 }
+// DWORD GetPrivateProfileString(
+//  [in]  LPCTSTR lpAppName,
+//  [in]  LPCTSTR lpKeyName,
+//  [in]  LPCTSTR lpDefault,
+//  [out] LPTSTR  lpReturnedString,
+//  [in]  DWORD   nSize,
+//  [in]  LPCTSTR lpFileName)
+void nullPointer_GetPrivateProfileString(LPCTSTR lpAppName,
+                                         LPCTSTR lpKeyName,
+                                         LPCTSTR lpDefault,
+                                         LPTSTR lpReturnedString,
+                                         DWORD nSize,
+                                         LPCTSTR lpFileName)
+{
+    // No warning is expected
+    (void)GetPrivateProfileString(lpAppName, lpKeyName, lpDefault, lpReturnedString, nSize, lpFileName);
+
+    // No warning is expected for 1st arg as nullptr
+    (void)GetPrivateProfileString(nullptr, lpKeyName, lpDefault, lpReturnedString, nSize, lpFileName);
+    // No warning is expected for 2nd arg as nullptr
+    (void)GetPrivateProfileString(lpAppName, nullptr, lpDefault, lpReturnedString, nSize, lpFileName);
+}
+
+void nullPointer__get_timezone(long *sec)
+{
+    // No warning is expected
+    (void)_get_timezone(sec);
+
+    long *pSec = NULL;
+    // cppcheck-suppress nullPointer
+    (void)_get_timezone(pSec);
+}
+
+void nullPointer__get_daylight(int *h)
+{
+    // No warning is expected
+    (void)_get_daylight(h);
+
+    int *pHours = NULL;
+    // cppcheck-suppress nullPointer
+    (void)_get_daylight(pHours);
+}
 
 void validCode()
 {
@@ -33,16 +279,17 @@ void validCode()
     hSemaphore1 = CreateSemaphore(NULL, 0, 1, NULL);
     CloseHandle(hSemaphore1);
     HANDLE hSemaphore2;
+    // cppcheck-suppress valueFlowBailoutIncompleteVar
     hSemaphore2 = CreateSemaphoreEx(NULL, 0, 1, NULL, 0, SEMAPHORE_ALL_ACCESS);
     CloseHandle(hSemaphore2);
     HANDLE hSemaphore3;
-    hSemaphore3 = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, "sem");
+    hSemaphore3 = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, L"sem");
     CloseHandle(hSemaphore3);
 
     // Valid lstrcat usage, but with warning because it is deprecated
     char buf[30] = "hello world";
-    // cppcheck-suppress lstrcatCalled
-    lstrcat(buf, "test");
+    // cppcheck-suppress lstrcatACalled
+    lstrcatA(buf, "test");
 
     // cppcheck-suppress strlwrCalled
     strlwr(buf);
@@ -53,14 +300,14 @@ void validCode()
     HANDLE hMutex1;
     hMutex1 = CreateMutex(NULL, TRUE, NULL);
     if (hMutex1) {
-        ReleaseMutex(hMutex);
+        ReleaseMutex(hMutex1);
     }
     CloseHandle(hMutex1);
     HANDLE hMutex2;
     hMutex2 = CreateMutexEx(NULL, NULL, 0, MUTEX_ALL_ACCESS);
     CloseHandle(hMutex2);
     HANDLE hMutex3;
-    hMutex3 = OpenMutex(MUTEX_ALL_ACCESS, FALSE, "sem");
+    hMutex3 = OpenMutex(MUTEX_ALL_ACCESS, FALSE, _T("sem"));
     CloseHandle(hMutex3);
 
     // Valid Module usage, no leaks, valid arguments
@@ -90,9 +337,11 @@ void validCode()
         CloseHandle(event);
     }
 
+    // cppcheck-suppress unusedAllocatedMemory
     void *pMem1 = _malloca(1);
     _freea(pMem1);
     // Memory from _alloca must not be freed
+    // cppcheck-suppress _allocaCalled
     void *pMem2 = _alloca(10);
     memset(pMem2, 0, 10);
 
@@ -104,7 +353,7 @@ void validCode()
 
     PSID pEveryoneSID = NULL;
     SID_IDENTIFIER_AUTHORITY SIDAuthWorld = SECURITY_WORLD_SID_AUTHORITY;
-    AllocateAndInitializeSid(&SIDAuthWorld, 1, SECURITY_WORLD_RID, 0, 0, 0, 0, 0, 0, 0, &pEveryoneSID)
+    AllocateAndInitializeSid(&SIDAuthWorld, 1, SECURITY_WORLD_RID, 0, 0, 0, 0, 0, 0, 0, &pEveryoneSID);
     FreeSid(pEveryoneSID);
 
     LPVOID pMem = HeapAlloc(GetProcessHeap(), 0, 10);
@@ -130,12 +379,12 @@ void validCode()
     _tprintf(TEXT("%s"), bufTC);
     _stprintf(bufTC, TEXT("%d"), 1);
     _tprintf(TEXT("%s"), bufTC);
-    _stprintf(bufTC, _countof(bufTC), TEXT("%d"), 2);
+    _stprintf(bufTC, TEXT("%d"), 2);
     _tprintf(TEXT("%s"), bufTC);
 
     GetUserName(NULL, &dwordInit);
     dwordInit = 10;
-    GetUserName(bufTC, _countof(bufTC));
+    GetUserName(bufTC, &dwordInit);
 
     WSADATA wsaData = {0};
     WSAStartup(2, &wsaData);
@@ -148,7 +397,7 @@ void validCode()
     WSACleanup();
 
     wordInit = MAKEWORD(1, 2);
-    // cppcheck-suppress redundantAssignment
+    // TODO cppcheck-suppress redundantAssignment
     dwordInit = MAKELONG(1, 2);
     // cppcheck-suppress redundantAssignment
     wordInit = LOWORD(dwordInit);
@@ -156,6 +405,7 @@ void validCode()
     wordInit = HIWORD(dwordInit);
     // cppcheck-suppress redundantAssignment
     byteInit = HIBYTE(wordInit);
+    // cppcheck-suppress knownConditionTrueFalse
     if (byteInit) {}
 
     bool boolVar;
@@ -173,7 +423,7 @@ void validCode()
     SecureZeroMemory(byteBuf, sizeof(byteBuf));
     RtlFillMemory(byteBuf, sizeof(byteBuf), 0xff);
 
-    // cppcheck-suppress LocalAllocCalled
+    // cppcheck-suppress [LocalAllocCalled, unusedAllocatedMemory]
     HLOCAL pLocalAlloc = LocalAlloc(1, 2);
     LocalFree(pLocalAlloc);
 
@@ -187,11 +437,15 @@ void validCode()
     __noop(1, "test", NULL);
     __nop();
 
+    // cppcheck-suppress unusedAllocatedMemory
     void * pAlloc1 = _aligned_malloc(100, 2);
     _aligned_free(pAlloc1);
 
     ::PostMessage(nullptr, WM_QUIT, 0, 0);
 
+    printf("%zu", __alignof(int));
+    printf("%zu", _alignof(double));
+
     // Valid Library usage, no leaks, valid arguments
     HINSTANCE hInstLib = LoadLibrary(L"My.dll");
     FreeLibrary(hInstLib);
@@ -221,7 +475,7 @@ void bufferAccessOutOfBounds()
 
     uint8_t byteBuf[5] = {0};
     uint8_t byteBuf2[10] = {0};
-    // TODO ticket #8412 cppcheck-suppress ignoredReturnValue
+    // cppcheck-suppress ignoredReturnValue
     // cppcheck-suppress bufferAccessOutOfBounds
     RtlEqualMemory(byteBuf, byteBuf2, 20);
     // cppcheck-suppress ignoredReturnValue
@@ -251,20 +505,23 @@ void bufferAccessOutOfBounds()
     // cppcheck-suppress bufferAccessOutOfBounds
     FillMemory(byteBuf, sizeof(byteBuf)+1, 0x01);
 
-    char * pAlloc1 = _malloca(32);
+    char * pAlloc1 = static_cast<char*>(_malloca(32));
+    // cppcheck-suppress nullPointerOutOfMemory
     memset(pAlloc1, 0, 32);
     // cppcheck-suppress bufferAccessOutOfBounds
+    // cppcheck-suppress nullPointerOutOfMemory
     memset(pAlloc1, 0, 33);
     _freea(pAlloc1);
 }
 
 void mismatchAllocDealloc()
 {
-    char * pChar = _aligned_malloc(100, 2);
+    char * pChar = static_cast<char*>(_aligned_malloc(100, 2));
     // cppcheck-suppress mismatchAllocDealloc
     free(pChar);
 
-    pChar = _malloca(32);
+    // cppcheck-suppress unusedAllocatedMemory
+    pChar = static_cast<char*>(_malloca(32));
     // cppcheck-suppress mismatchAllocDealloc
     _aligned_free(pChar);
 }
@@ -272,14 +529,14 @@ void mismatchAllocDealloc()
 void nullPointer()
 {
     HANDLE hSemaphore;
-    // cppcheck-suppress nullPointer
+    // cppcheck-suppress [nullPointer,valueFlowBailoutIncompleteVar]
     hSemaphore = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, NULL);
     CloseHandle(hSemaphore);
 
     // cppcheck-suppress lstrcatCalled
     // cppcheck-suppress nullPointer
-    lstrcat(NULL, "test");
-    char buf[10] = "\0";
+    lstrcat(NULL, _T("test"));
+    TCHAR buf[10] = _T("\0");
     // cppcheck-suppress lstrcatCalled
     // cppcheck-suppress nullPointer
     lstrcat(buf, NULL);
@@ -342,14 +599,14 @@ void nullPointer()
     // cppcheck-suppress nullPointer
     getpeername(socketInit, &sockaddrUninit, pIntNull);
     // cppcheck-suppress nullPointer
-    getsockopt(sockInit, 1, 2, NULL, &intInit);
+    getsockopt(socketInit, 1, 2, NULL, &intInit);
     // cppcheck-suppress nullPointer
-    getsockopt(sockInit, 1, 2, charArray, pIntNull);
+    getsockopt(socketInit, 1, 2, charArray, pIntNull);
 }
 
 void memleak_malloca()
 {
-    // cppcheck-suppress unreadVariable
+    // cppcheck-suppress [unusedAllocatedMemory, unreadVariable, constVariablePointer]
     void *pMem = _malloca(10);
     // cppcheck-suppress memleak
 }
@@ -358,8 +615,8 @@ void memleak_AllocateAndInitializeSid()
 {
     PSID pEveryoneSID = NULL;
     SID_IDENTIFIER_AUTHORITY SIDAuthWorld = SECURITY_WORLD_SID_AUTHORITY;
-    AllocateAndInitializeSid(&SIDAuthWorld, 1, SECURITY_WORLD_RID, 0, 0, 0, 0, 0, 0, 0, &pEveryoneSID)
-    // TODO: enable when #6994 is implemented cppcheck-suppress memleak
+    AllocateAndInitializeSid(&SIDAuthWorld, 1, SECURITY_WORLD_RID, 0, 0, 0, 0, 0, 0, 0, &pEveryoneSID);
+    // cppcheck-suppress memleak
 }
 
 void memleak_HeapAlloc()
@@ -375,7 +632,7 @@ void memleak_HeapAlloc()
 void memleak_LocalAlloc()
 {
     LPTSTR pszBuf;
-    // cppcheck-suppress LocalAllocCalled
+    // cppcheck-suppress [LocalAllocCalled, cstyleCast, valueFlowBailoutIncompleteVar]
     pszBuf = (LPTSTR)LocalAlloc(LPTR, MAX_PATH*sizeof(TCHAR));
     (void)LocalSize(pszBuf);
     (void)LocalFlags(pszBuf);
@@ -384,6 +641,20 @@ void memleak_LocalAlloc()
     // cppcheck-suppress memleak
 }
 
+void memleak_dupenv_s() // #10646
+{
+    char* pValue;
+    size_t len;
+    errno_t err = _dupenv_s(&pValue, &len, "pathext");
+    if (err) return;
+    printf("pathext = %s\n", pValue);
+    free(pValue);
+    err = _dupenv_s(&pValue, &len, "nonexistentvariable");
+    if (err) return;
+    printf("nonexistentvariable = %s\n", pValue);
+    // cppcheck-suppress memleak
+}
+
 void resourceLeak_CreateSemaphoreA()
 {
     HANDLE hSemaphore;
@@ -395,7 +666,7 @@ void resourceLeak_CreateSemaphoreA()
 void resourceLeak_CreateSemaphoreEx()
 {
     HANDLE hSemaphore;
-    // cppcheck-suppress unreadVariable
+    // cppcheck-suppress [unreadVariable,valueFlowBailoutIncompleteVar]
     hSemaphore = CreateSemaphoreEx(NULL, 0, 1, NULL, 0, SEMAPHORE_ALL_ACCESS);
     // cppcheck-suppress resourceLeak
 }
@@ -403,8 +674,8 @@ void resourceLeak_CreateSemaphoreEx()
 void resourceLeak_OpenSemaphore()
 {
     HANDLE hSemaphore;
-    // cppcheck-suppress unreadVariable
-    hSemaphore = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, "sem");
+    // cppcheck-suppress [unreadVariable,valueFlowBailoutIncompleteVar]
+    hSemaphore = OpenSemaphore(SEMAPHORE_ALL_ACCESS, TRUE, _T("sem"));
     // cppcheck-suppress resourceLeak
 }
 
@@ -419,8 +690,8 @@ void resourceLeak_CreateMutexA()
 void resourceLeak_CreateMutexEx()
 {
     HANDLE hMutex;
-    // cppcheck-suppress unreadVariable
-    hMutex = CreateMutexEx(NULL, "sem", 0, MUTEX_ALL_ACCESS);
+    // cppcheck-suppress [unreadVariable,valueFlowBailoutIncompleteVar]
+    hMutex = CreateMutexEx(NULL, _T("sem"), 0, MUTEX_ALL_ACCESS);
     // cppcheck-suppress resourceLeak
 }
 
@@ -428,7 +699,7 @@ void resourceLeak_OpenMutex()
 {
     HANDLE hMutex;
     // cppcheck-suppress unreadVariable
-    hMutex = OpenMutex(MUTEX_ALL_ACCESS, TRUE, "sem");
+    hMutex = OpenMutex(MUTEX_ALL_ACCESS, TRUE, _T("sem"));
     // cppcheck-suppress resourceLeak
 }
 
@@ -437,8 +708,8 @@ void resourceLeak_LoadLibrary()
     HINSTANCE hInstLib;
     hInstLib = ::LoadLibrary(L"My.dll");
     typedef BOOL (WINAPI *fpFunc)();
-    // cppcheck-suppress unreadVariable
-    fpFunc pFunc = GetProcAddress(hInstLib, "name");
+    // cppcheck-suppress [unreadVariable, cstyleCast]
+    fpFunc pFunc = (fpFunc)GetProcAddress(hInstLib, "name");
     // cppcheck-suppress resourceLeak
 }
 
@@ -461,7 +732,7 @@ void resourceLeak_CreateEventExA()
 void resourceLeak_OpenEventW()
 {
     HANDLE hEvent;
-    // cppcheck-suppress unreadVariable
+    // cppcheck-suppress [unreadVariable,valueFlowBailoutIncompleteVar]
     hEvent = OpenEventW(EVENT_ALL_ACCESS, TRUE, L"testevent");
     // cppcheck-suppress resourceLeak
 }
@@ -474,11 +745,11 @@ void resourceLeak_socket()
     // cppcheck-suppress resourceLeak
 }
 
-void ignoredReturnValue()
+void ignoredReturnValue(FILE* fp)
 {
     // cppcheck-suppress leakReturnValNotUsed
     CreateSemaphoreW(NULL, 0, 1, NULL);
-    // cppcheck-suppress leakReturnValNotUsed
+    // cppcheck-suppress [leakReturnValNotUsed,valueFlowBailoutIncompleteVar]
     CreateSemaphoreExA(NULL, 0, 1, NULL, 0, SEMAPHORE_ALL_ACCESS);
     // cppcheck-suppress leakReturnValNotUsed
     OpenSemaphoreA(SEMAPHORE_ALL_ACCESS, TRUE, "sem");
@@ -507,29 +778,27 @@ void ignoredReturnValue()
     // cppcheck-suppress leakReturnValNotUsed
     CreateEventEx(NULL, L"test", CREATE_EVENT_INITIAL_SET, EVENT_MODIFY_STATE);
 
-    // cppcheck-suppress ignoredReturnValue
     // cppcheck-suppress leakReturnValNotUsed
     _malloca(10);
     // cppcheck-suppress ignoredReturnValue
+    // cppcheck-suppress _allocaCalled
     _alloca(5);
 
     // cppcheck-suppress ignoredReturnValue
     GetLastError();
 
     // cppcheck-suppress ignoredReturnValue
-    GetProcessHeap()
-    // cppcheck-suppress ignoredReturnValue
+    GetProcessHeap();
     // cppcheck-suppress leakReturnValNotUsed
     HeapAlloc(GetProcessHeap(), 0, 10);
-    // cppcheck-suppress ignoredReturnValue
-    // cppcheck-suppress leakReturnValNotUsed
-    HeapReAlloc(GetProcessHeap(), 0, 1, 0);
+    // cppcheck-suppress [leakReturnValNotUsed, nullPointer]
+    HeapReAlloc(GetProcessHeap(), 0, nullptr, 0);
 
     // cppcheck-suppress leakReturnValNotUsed
     socket(1, 2, 3);
 
     // cppcheck-suppress ignoredReturnValue
-    _fileno(stdio);
+    _fileno(fp);
 
     // cppcheck-suppress lstrlenCalled
     // cppcheck-suppress ignoredReturnValue
@@ -543,9 +812,9 @@ void invalidFunctionArg()
     hSemaphore = CreateSemaphore(NULL, 0, 0, NULL);
     CloseHandle(hSemaphore);
     // cppcheck-suppress invalidFunctionArgBool
-    hSemaphore = CreateSemaphore(NULL, 0, 1, true);
+    hSemaphore = CreateSemaphore(NULL, 0, 1, false);
     CloseHandle(hSemaphore);
-    // cppcheck-suppress invalidFunctionArg
+    // cppcheck-suppress [invalidFunctionArg,valueFlowBailoutIncompleteVar]
     hSemaphore = CreateSemaphoreEx(NULL, 0, 0, NULL, 0, SEMAPHORE_ALL_ACCESS);
     CloseHandle(hSemaphore);
     // cppcheck-suppress invalidFunctionArg
@@ -557,15 +826,15 @@ void invalidFunctionArg()
     hMutex = CreateMutex(NULL, TRUE, false);
     CloseHandle(hMutex);
     // cppcheck-suppress invalidFunctionArgBool
-    hMutex = CreateMutex(NULL, FALSE, true);
+    hMutex = CreateMutex(NULL, FALSE, false);
     CloseHandle(hMutex);
     // cppcheck-suppress invalidFunctionArg
     hMutex = CreateMutexEx(NULL, NULL, 3, MUTEX_ALL_ACCESS);
     CloseHandle(hMutex);
 
     //Incorrect: 2. parameter to LoadLibraryEx() must be NULL
-    // cppcheck-suppress invalidFunctionArg
-    HINSTANCE hInstLib = LoadLibraryEx(L"My.dll", 1, 0);
+    // cppcheck-suppress [invalidFunctionArg, intToPointerCast]
+    HINSTANCE hInstLib = LoadLibraryEx(L"My.dll", HANDLE(1), 0);
     FreeLibrary(hInstLib);
 
     // cppcheck-suppress invalidFunctionArg
@@ -573,40 +842,45 @@ void invalidFunctionArg()
     _freea(pMem);
     // FIXME cppcheck-suppress unreadVariable
     // cppcheck-suppress invalidFunctionArg
+    // cppcheck-suppress _allocaCalled
     pMem = _alloca(-5);
 }
 
 void uninitvar()
 {
+    // cppcheck-suppress unassignedVariable
     HANDLE hSemaphore;
     // cppcheck-suppress uninitvar
     CloseHandle(hSemaphore);
 
-    char buf[10];
+    TCHAR buf[10];
     // cppcheck-suppress lstrcatCalled
     // cppcheck-suppress uninitvar
-    lstrcat(buf, "test");
-    buf[0] = '\0';
-    char buf2[2];
+    lstrcat(buf, _T("test"));
+    buf[0] = _T('\0');
+    // TODO cppcheck-suppress constVariable
+    TCHAR buf2[2];
     // cppcheck-suppress lstrcatCalled
     // cppcheck-suppress uninitvar
     lstrcat(buf, buf2);
 
+    // cppcheck-suppress unassignedVariable
     HANDLE hMutex1, hMutex2;
     // cppcheck-suppress uninitvar
     ReleaseMutex(hMutex1);
     // cppcheck-suppress uninitvar
     CloseHandle(hMutex2);
 
-    HANDLE hEvent;
+    // cppcheck-suppress unassignedVariable
+    HANDLE hEvent1, hEvent2, hEvent3, hEvent4;
     // cppcheck-suppress uninitvar
-    PulseEvent(hEvent);
+    PulseEvent(hEvent1);
     // cppcheck-suppress uninitvar
-    ResetEvent(hEvent);
+    ResetEvent(hEvent2);
     // cppcheck-suppress uninitvar
-    SetEvent(hEvent);
+    SetEvent(hEvent3);
     // cppcheck-suppress uninitvar
-    CloseHandle(hEvent);
+    CloseHandle(hEvent4);
 
     char buf_uninit1[10];
     char buf_uninit2[10];
@@ -621,9 +895,9 @@ void uninitvar()
     // cppcheck-suppress uninitvar
     SetLastError(dwordUninit);
 
-    DWORD dwordUninit;
+    DWORD dwordUninit2;
     // cppcheck-suppress uninitvar
-    GetUserName(NULL, &dwordUninit);
+    GetUserName(NULL, &dwordUninit2);
 
     FILE *pFileUninit;
     // cppcheck-suppress uninitvar
@@ -631,6 +905,10 @@ void uninitvar()
     _fileno(pFileUninit);
 }
 
+void unreferencedParameter(int i) {
+    UNREFERENCED_PARAMETER(i);
+}
+
 void errorPrintf()
 {
     char bufC[50];
@@ -752,32 +1030,31 @@ void oppositeInnerCondition_SUCCEEDED_FAILED(HRESULT hr)
 {
     if (SUCCEEDED(hr)) {
         // TODO ticket #8596 cppcheck-suppress oppositeInnerCondition
-        if (FAILED(hr)) {
-        }
+        if (FAILED(hr)) {}
     }
 }
 
 /*HANDLE WINAPI CreateThread(
-  _In_opt_  LPSECURITY_ATTRIBUTES  lpThreadAttributes,
-  _In_      SIZE_T                 dwStackSize,
-  _In_      LPTHREAD_START_ROUTINE lpStartAddress,
-  _In_opt_  LPVOID                 lpParameter,
-  _In_      DWORD                  dwCreationFlags,
-  _Out_opt_ LPDWORD                lpThreadId
-);*/
-HANDLE test_CreateThread(LPSECURITY_ATTRIBUTES  lpThreadAttributes,
-                         SIZE_T                 dwStackSize,
+   _In_opt_  LPSECURITY_ATTRIBUTES  lpThreadAttributes,
+   _In_      SIZE_T                 dwStackSize,
+   _In_      LPTHREAD_START_ROUTINE lpStartAddress,
+   _In_opt_  LPVOID                 lpParameter,
+   _In_      DWORD                  dwCreationFlags,
+   _Out_opt_ LPDWORD                lpThreadId
+   );*/
+HANDLE test_CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes,
+                         SIZE_T dwStackSize,
                          LPTHREAD_START_ROUTINE lpStartAddress,
-                         LPVOID                 lpParameter,
-                         DWORD                  dwCreationFlags,
-                         LPDWORD                lpThreadId)
+                         LPVOID lpParameter,
+                         DWORD dwCreationFlags,
+                         LPDWORD lpThreadId)
 {
     // Create uninitialized variables
-    LPSECURITY_ATTRIBUTES  uninit_lpThreadAttributes;
-    SIZE_T                 uninit_dwStackSize;
+    LPSECURITY_ATTRIBUTES uninit_lpThreadAttributes;
+    SIZE_T uninit_dwStackSize;
     LPTHREAD_START_ROUTINE uninit_lpStartAddress;
-    LPVOID                 uninit_lpParameter;
-    DWORD                  uninit_dwCreationFlags;
+    LPVOID uninit_lpParameter;
+    DWORD uninit_dwCreationFlags;
 
     // cppcheck-suppress leakReturnValNotUsed
     // cppcheck-suppress uninitvar
@@ -811,13 +1088,11 @@ HANDLE test_CreateThread(LPSECURITY_ATTRIBUTES  lpThreadAttributes,
 unsigned char * uninitvar_mbscat(unsigned char *strDestination, const unsigned char *strSource)
 {
     unsigned char *uninit_deststr;
-    unsigned char *uninit_srcstr;
-    // cppcheck-suppress uninitvar
-    (void)_mbscat(uninit_deststr,uninit_srcstr);
+    const unsigned char *uninit_srcstr1, *uninit_srcstr2;
     // cppcheck-suppress uninitvar
-    (void)_mbscat(strDestination,uninit_srcstr);
+    (void)_mbscat(uninit_deststr,uninit_srcstr1);
     // cppcheck-suppress uninitvar
-    (void)_mbscat(uninit_deststr,uninit_deststr);
+    (void)_mbscat(strDestination,uninit_srcstr2);
 
     // no warning shall be shown for
     return _mbscat(strDestination,strSource);
@@ -836,11 +1111,11 @@ unsigned char * nullPointer_mbscat(unsigned char *strDestination, const unsigned
 }
 
 // errno_t _mbscat_s(unsigned char *strDestination, size_t numberOfElements, const unsigned char *strSource );
-error_t uninitvar_mbscat_s(unsigned char *strDestination, size_t numberOfElements, const unsigned char *strSource)
+errno_t uninitvar_mbscat_s(unsigned char *strDestination, size_t numberOfElements, const unsigned char *strSource)
 {
     unsigned char *uninit_strDestination;
     size_t uninit_numberOfElements;
-    unsigned char *uninit_strSource;
+    const unsigned char *uninit_strSource;
 
     // cppcheck-suppress uninitvar
     (void)_mbscat_s(uninit_strDestination, numberOfElements, strSource);
@@ -854,7 +1129,7 @@ error_t uninitvar_mbscat_s(unsigned char *strDestination, size_t numberOfElement
 }
 
 // errno_t _mbscat_s(unsigned char *strDestination, size_t numberOfElements, const unsigned char *strSource );
-error_t nullPointer_mbscat_s(unsigned char *strDestination, size_t numberOfElements, const unsigned char *strSource)
+errno_t nullPointer_mbscat_s(unsigned char *strDestination, size_t numberOfElements, const unsigned char *strSource)
 {
     // cppcheck-suppress nullPointer
     (void)_mbscat_s(0, numberOfElements, strSource);
@@ -865,8 +1140,9 @@ error_t nullPointer_mbscat_s(unsigned char *strDestination, size_t numberOfEleme
     return _mbscat_s(strDestination, numberOfElements, strSource);
 }
 
+#if !UNICODE
 // errno_t _strncpy_s_l(char *strDest, size_t numberOfElements, const char *strSource, size_t count, _locale_t locale);
-error_t uninitvar__strncpy_s_l(char *strDest, size_t numberOfElements, const char *strSource, size_t count, _locale_t locale)
+errno_t uninitvar__strncpy_s_l(char *strDest, size_t numberOfElements, const char *strSource, size_t count, _locale_t locale)
 {
     size_t uninit_numberOfElements;
     const char *uninit_strSource;
@@ -886,8 +1162,7 @@ error_t uninitvar__strncpy_s_l(char *strDest, size_t numberOfElements, const cha
     return _strncpy_s_l(strDest, numberOfElements, strSource, count, locale);
 }
 
-// errno_t _strncpy_s_l(char *strDest, size_t numberOfElements, const char *strSource, size_t count, _locale_t locale);
-error_t nullPointer__strncpy_s_l(char *strDest, size_t numberOfElements, const char *strSource, size_t count, _locale_t locale)
+errno_t nullPointer__strncpy_s_l(char *strDest, size_t numberOfElements, const char *strSource, size_t count, _locale_t locale)
 {
     // cppcheck-suppress nullPointer
     (void)_strncpy_s_l(0, numberOfElements, strSource, count, locale);
@@ -897,8 +1172,9 @@ error_t nullPointer__strncpy_s_l(char *strDest, size_t numberOfElements, const c
     // no warning shall be shown for
     return _strncpy_s_l(strDest, numberOfElements, strSource, count, locale);
 }
+#endif
 
-void GetShortPathName_validCode(TCHAR* lpszPath)
+void GetShortPathName_validCode(const TCHAR* lpszPath)
 {
     long length = GetShortPathName(lpszPath, NULL, 0);
     if (length == 0) {
@@ -908,21 +1184,53 @@ void GetShortPathName_validCode(TCHAR* lpszPath)
     TCHAR* buffer = new TCHAR[length];
     length = GetShortPathName(lpszPath, buffer, length);
     if (length == 0) {
-        delete [] buffer;
+        delete[] buffer;
         _tprintf(TEXT("error"));
         return;
     }
     _tprintf(TEXT("long name = %s short name = %s"), lpszPath, buffer);
-    delete [] buffer;
-}
-
-class MyClass :public CObject {
-    DECLARE_DYNAMIC(MyClass)
-    DECLARE_DYNCREATE(MyClass)
-    DECLARE_SERIAL(MyClass)
-public:
-    MyClass() {}
-};
-IMPLEMENT_DYNAMIC(MyClass, CObject)
-IMPLEMENT_DYNCREATE(MyClass, CObject)
-IMPLEMENT_SERIAL(MyClass,CObject, 42)
+    delete[] buffer;
+}
+
+void invalidPrintfArgType_StructMember(double d) { // #9672
+    typedef struct { CString st; } my_struct_t;
+
+    my_struct_t my_struct;
+    // cppcheck-suppress invalidPrintfArgType_sint
+    my_struct.st.Format(_T("%d"), d);
+}
+
+BOOL MyEnableWindow(HWND hWnd, BOOL bEnable) {
+    return EnableWindow(hWnd, bEnable);
+}
+
+int SEH_filter(unsigned int code, struct _EXCEPTION_POINTERS* ep);
+int SEH_throwing_func();
+
+void SEH_knownConditionTrueFalse() { // #8434
+    int r = 0;
+    __try {
+        r = SEH_throwing_func();
+    }
+    __except (SEH_filter(GetExceptionCode(), GetExceptionInformation())) {
+        r = 1;
+    }
+    if (r == 0) {}
+}
+
+void SEH_unusedLabel() { // #13233
+    __try {
+    }
+    __finally {
+    }
+}
+
+HWND constParameterPointer_CreateWindow(void* param) { // #14560
+    return CreateWindow(L"MessageWnd", NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, NULL, NULL, param);
+}
+
+void constParameterPointer_SetupDiGetDeviceInstanceId(HDEVINFO info, SP_DEVINFO_DATA *data) {
+    const DWORD buffer_size = 256;
+    TCHAR buffer[buffer_size];
+    SetupDiGetDeviceInstanceId(info, data, buffer, buffer_size, NULL);
+}
diff --git a/test/cfg/wxwidgets.cpp b/test/cfg/wxwidgets.cpp
index a848331839f..c25dfa8e1b4 100644
--- a/test/cfg/wxwidgets.cpp
+++ b/test/cfg/wxwidgets.cpp
@@ -2,28 +2,999 @@
 // Test library configuration for wxwidgets.cfg
 //
 // Usage:
-// $ ./cppcheck --check-library --enable=information --enable=style --error-exitcode=1 --suppress=missingIncludeSystem --inline-suppr '--template="{file}:{line}:{severity}:{id}:{message}"' --inconclusive --library=wxwidgets -f test/cfg/wxwidgets.cpp
+// $ ./cppcheck --check-library --library=wxwidgets --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/wxwidgets.cpp
 // =>
 // No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
 //
 
+// cppcheck-suppress-file valueFlowBailout
+// cppcheck-suppress-file purgedConfiguration
+
 #include <wx/wx.h>
+#include <wx/accel.h>
+#include <wx/any.h>
 #include <wx/app.h>
-#include <wx/log.h>
-#include <wx/filefn.h>
-#include <wx/spinctrl.h>
+#include <wx/archive.h>
 #include <wx/artprov.h>
+#include <wx/bitmap.h>
+#if wxCHECK_VERSION(3, 1, 6)  // wxWidets-3.1.6 or higher
+#include <wx/bmpbndl.h>
+#endif
+#include <wx/brush.h>
 #include <wx/calctrl.h>
+#include <wx/colour.h>
 #include <wx/combo.h>
-#include <wx/icon.h>
-#include <wx/bitmap.h>
+#include <wx/cursor.h>
+#include <wx/dc.h>
 #include <wx/dataview.h>
-#include <wx/memory.h>
+#include <wx/datetime.h>
+#include <wx/dc.h>
+#include <wx/dynarray.h>
+#include <wx/filefn.h>
+#include <wx/font.h>
+#include <wx/fontenum.h>
+#include <wx/fontutil.h>
 #include <wx/frame.h>
+#include <wx/gbsizer.h>
+#include <wx/gdicmn.h>
+#include <wx/geometry.h>
+#include <wx/graphics.h>
+#include <wx/grid.h>
+#include <wx/icon.h>
+#include <wx/iconbndl.h>
+#include <wx/iconloc.h>
+#include <wx/image.h>
+#include <wx/imaggif.h>
+#include <wx/imagiff.h>
+#include <wx/imagjpeg.h>
+#include <wx/imagpcx.h>
+#include <wx/log.h>
 #include <wx/menu.h>
-#include <wx/stattext.h>
+#include <wx/memory.h>
+#include <wx/mimetype.h>
+#if defined(__WXMSW__)
+#include <wx/msw/ole/automtn.h>
+#include <wx/metafile.h>
+#include <wx/msw/ole/oleutils.h>
+#endif
+#include <wx/palette.h>
+#include <wx/pen.h>
+#include <wx/position.h>
+#include <wx/propgrid/property.h>
+#include <wx/regex.h>
+#include <wx/region.h>
+#include <wx/renderer.h>
+#include <wx/settings.h>
+#include <wx/spinctrl.h>
 #include <wx/sizer.h>
 #include <wx/string.h>
+#include <wx/sysopt.h>
+#include <wx/tarstrm.h>
+#include <wx/textctrl.h>
+#include <wx/unichar.h>
+#include <wx/ustring.h>
+#include <wx/variant.h>
+#include <wx/vector.h>
+#include <wx/versioninfo.h>
+#include <wx/wrapsizer.h>
+#include <wx/zipstrm.h>
+
+#if wxCHECK_VERSION(3, 1, 6)  // wxWidets-3.1.6 or higher
+void unreadVariable_wxBitmapBundle(const wxBitmap &bmp, const wxIcon &icon, const wxImage &image, const char *const * xpm, const wxBitmapBundle &bundle)
+{
+    // cppcheck-suppress unusedVariable
+    wxBitmapBundle a;
+    // cppcheck-suppress unreadVariable
+    wxBitmapBundle b(bmp);
+    // cppcheck-suppress unreadVariable
+    wxBitmapBundle c(icon);
+    // cppcheck-suppress unreadVariable
+    wxBitmapBundle d(image);
+    // cppcheck-suppress unreadVariable
+    wxBitmapBundle e(xpm);
+    // cppcheck-suppress unreadVariable
+    wxBitmapBundle f(bundle);
+}
+#endif
+
+#if wxCHECK_VERSION(3, 1, 3)  // wxWidets-3.1.3 or higher
+void unreadVariable_wxDCTextBgModeChanger(wxDC &dc)
+{
+    // cppcheck-suppress unreadVariable
+    wxDCTextBgModeChanger a(dc);
+}
+
+void unreadVariable_wxDCTextBgColourChanger(wxDC &dc, const wxColour &colour)
+{
+    // cppcheck-suppress unreadVariable
+    wxDCTextBgColourChanger a(dc);
+    // cppcheck-suppress unreadVariable
+    wxDCTextBgColourChanger b(dc, colour);
+}
+#endif
+
+void unreadVariable_wxZipEntry(const wxZipEntry &entry)
+{
+    // cppcheck-suppress unreadVariable
+    wxZipEntry a(entry);
+}
+
+void unreadVariable_wxTarEntry(const wxTarEntry &entry)
+{
+    // cppcheck-suppress unreadVariable
+    wxTarEntry a(entry);
+}
+
+void unreadVariable_wxDCTextColourChanger(wxDC &dc, const wxColour &colour)
+{
+    // cppcheck-suppress unreadVariable
+    wxDCTextColourChanger a(dc);
+    // cppcheck-suppress unreadVariable
+    wxDCTextColourChanger b(dc, colour);
+}
+
+void unreadVariable_wxDCPenChanger(wxDC &dc, const wxPen &pen)
+{
+    // cppcheck-suppress unreadVariable
+    wxDCPenChanger a(dc, pen);
+}
+
+void unreadVariable_wxDCFontChanger(wxDC &dc, const wxFont &font)
+{
+    // cppcheck-suppress unreadVariable
+    wxDCFontChanger a(dc);
+    // cppcheck-suppress unreadVariable
+    wxDCFontChanger b(dc, font);
+}
+
+void unreadVariable_wxDCBrushChanger(wxDC &dc, const wxBrush &brush)
+{
+    // cppcheck-suppress unreadVariable
+    wxDCBrushChanger a(dc, brush);
+}
+
+void unreadVariable_wxGBSpan(const int x)
+{
+    // cppcheck-suppress unusedVariable
+    wxGBSpan a;
+    // cppcheck-suppress unreadVariable
+    wxGBSpan b(x, x);
+}
+
+void unreadVariable_wxGBPosition(const int x)
+{
+    // cppcheck-suppress unusedVariable
+    wxGBPosition a;
+    // cppcheck-suppress unreadVariable
+    wxGBPosition b(x, x);
+}
+
+void unreadVariable_wxWrapSizer(const int x)
+{
+    // cppcheck-suppress unreadVariable
+    wxWrapSizer a(x, x);
+}
+
+void unreadVariable_wxGridBagSizer(const int x)
+{
+    // cppcheck-suppress unreadVariable
+    wxGridBagSizer a(x, x);
+}
+
+void unreadVariable_wxGBSizerItem(const int x, const wxGBPosition &pos)
+{
+    // cppcheck-suppress unreadVariable
+    wxGBSizerItem a(x, x, pos);
+}
+
+void unreadVariable_wxSizerItem(const int x)
+{
+    // cppcheck-suppress unreadVariable
+    wxSizerItem a(x, x);
+}
+
+void unreadVariable_wxFlexGridSizer(const int x)
+{
+    // cppcheck-suppress unreadVariable
+    wxFlexGridSizer a(x, x, x);
+}
+
+void unreadVariable_wxBoxSizer(const int orient)
+{
+    // cppcheck-suppress unreadVariable
+    wxBoxSizer a(orient);
+}
+
+void unreadVariable_wxGridSizer(int x)
+{
+    // cppcheck-suppress unreadVariable
+    wxGridSizer a(x, x, x);
+}
+
+void unreadVariable_wxStaticBoxSizer(wxStaticBox *box, const int orient, wxWindow *parent, const wxString &label)
+{
+    // cppcheck-suppress unreadVariable
+    wxStaticBoxSizer a(box, orient);
+    // cppcheck-suppress unreadVariable
+    wxStaticBoxSizer b(orient, parent);
+    // cppcheck-suppress unreadVariable
+    wxStaticBoxSizer c(orient, parent, label);
+}
+
+void unusedVariable_wxDelegateRendererNative()
+{
+    // cppcheck-suppress unusedVariable
+    wxDelegateRendererNative a;
+}
+
+void unusedVariable_wxHeaderButtonParams()
+{
+    // cppcheck-suppress unusedVariable
+    wxHeaderButtonParams a;
+}
+
+void unusedVariable_wxRegionIterator()
+{
+    // cppcheck-suppress unusedVariable
+    wxRegionIterator a;
+}
+
+void unusedVariable_wxRegionContain()
+{
+    // cppcheck-suppress unusedVariable
+    wxRegionContain a;
+}
+
+void unusedVariable_wxPalette()
+{
+    // cppcheck-suppress unusedVariable
+    wxPalette a;
+}
+
+void unusedVariable_wxJPEGHandler()
+{
+    // cppcheck-suppress unusedVariable
+    wxJPEGHandler a;
+}
+
+void unusedVariable_wxGIFHandler()
+{
+    // cppcheck-suppress unusedVariable
+    wxGIFHandler a;
+}
+
+void unusedVariable_wxPCXHandler()
+{
+    // cppcheck-suppress unusedVariable
+    wxPCXHandler a;
+}
+
+void unusedVariable_wxIFFHandler()
+{
+    // cppcheck-suppress unusedVariable
+    wxIFFHandler a;
+}
+
+void unusedVariable_wxGraphicsBrush()
+{
+    // cppcheck-suppress unusedVariable
+    wxGraphicsBrush a;
+}
+
+void unusedVariable_wxGraphicsMatrix()
+{
+    // cppcheck-suppress unusedVariable
+    wxGraphicsMatrix a;
+}
+
+void unusedVariable_wxGraphicsFont()
+{
+    // cppcheck-suppress unusedVariable
+    wxGraphicsFont a;
+}
+
+void unusedVariable_wxIconBundle()
+{
+    // cppcheck-suppress unusedVariable
+    wxIconBundle a;
+}
+
+void unusedVariable_wxStdDialogButtonSizer()
+{
+    // cppcheck-suppress unusedVariable
+    wxStdDialogButtonSizer a;
+}
+
+void unusedVariable_wxColourDatabase()
+{
+    // cppcheck-suppress unusedVariable
+    wxColourDatabase a;
+}
+
+void unusedVariable_wxFontEnumerator()
+{
+    // cppcheck-suppress unusedVariable
+    wxFontEnumerator a;
+}
+
+void unusedVariable_wxCursor()
+{
+    // cppcheck-suppress unusedVariable
+    wxCursor a;
+}
+
+void unusedVariable_wxBitmapHandler()
+{
+    // cppcheck-suppress unusedVariable
+    wxBitmapHandler a;
+}
+
+void unusedVariable_wxNativeFontInfo()
+{
+    // cppcheck-suppress unusedVariable
+    wxNativeFontInfo a;
+}
+
+void unreadVariable_wxDCClipper(wxDC &dc, const wxRegion &region)
+{
+    // cppcheck-suppress unreadVariable
+    wxDCClipper a(dc, region);
+}
+
+void unreadVariable_wxMask(const wxBitmap &bmp, int x, const wxColour & colour)
+{
+    // cppcheck-suppress unusedVariable
+    wxMask a;
+    // cppcheck-suppress unreadVariable
+    wxMask b(bmp);
+    // cppcheck-suppress unreadVariable
+    wxMask c(bmp, x);
+    // cppcheck-suppress unreadVariable
+    wxMask d(bmp, colour);
+}
+
+void unreadVariable_wxGraphicsGradientStops()
+{
+    // cppcheck-suppress unusedVariable
+    wxGraphicsGradientStops a;
+    // cppcheck-suppress unreadVariable
+    wxGraphicsGradientStops b(wxTransparentColour);
+    // cppcheck-suppress unreadVariable
+    wxGraphicsGradientStops c(wxTransparentColour, wxTransparentColour);
+}
+
+void unreadVariable_wxGraphicsGradientStop()
+{
+    // cppcheck-suppress unusedVariable
+    wxGraphicsGradientStop a;
+    // cppcheck-suppress unreadVariable
+    wxGraphicsGradientStop b(wxTransparentColour);
+    // cppcheck-suppress unreadVariable
+    wxGraphicsGradientStop c(wxTransparentColour, 0.42);
+}
+
+void unusedVariable_wxFontMetrics()
+{
+    // cppcheck-suppress unusedVariable
+    wxFontMetrics a;
+}
+
+void unusedVariable_wxIconLocation()
+{
+    // cppcheck-suppress unusedVariable
+    wxIconLocation a;
+}
+
+void unreadVariable_wxIcon(const wxIcon &icon, const wxIconLocation &loc, const char *const *ptr)
+{
+    // cppcheck-suppress unusedVariable
+    wxIcon a;
+    // cppcheck-suppress unreadVariable
+    wxIcon b(icon);
+    // cppcheck-suppress unreadVariable
+    wxIcon c(loc);
+    // cppcheck-suppress unreadVariable
+    wxIcon d(ptr);
+}
+
+void unreadVariable_wxImage(const wxImage &image, const int x)
+{
+    // cppcheck-suppress unusedVariable
+    wxImage a;
+    // cppcheck-suppress unreadVariable
+    wxImage b(image);
+    // cppcheck-suppress unreadVariable
+    wxImage c(x, x);
+    // cppcheck-suppress unreadVariable
+    wxImage d(x, x, true);
+}
+
+void unreadVariable_wxUString(const wxUString &str, const wxChar32 *strPtr)
+{
+    // cppcheck-suppress unusedVariable
+    wxUString a;
+    // cppcheck-suppress unreadVariable
+    wxUString b(str);
+    // cppcheck-suppress unreadVariable
+    wxUString c(strPtr);
+}
+
+void unreadVariable_wxAny(const wxVariant &variant, const wxAny &any)
+{
+    // cppcheck-suppress unusedVariable
+    wxAny a;
+    // cppcheck-suppress unreadVariable
+    wxAny b(42);
+    // cppcheck-suppress unreadVariable
+    wxAny c(variant);
+    // cppcheck-suppress unreadVariable
+    wxAny d(any);
+}
+
+void unreadVariable_wxVariant(wxVariantData *data,
+                              const wxString &name,
+                              const wxVariant &variant,
+                              const wxAny &any,
+                              const wxChar *valuePtr,
+                              const wxString &valueStr,
+                              const wxChar charValue,
+                              long lValue,
+                              bool bvalue)
+{
+    // cppcheck-suppress unusedVariable
+    wxVariant a;
+    // cppcheck-suppress unreadVariable
+    wxVariant b(data);
+    // cppcheck-suppress unreadVariable
+    wxVariant c(data, name);
+    // cppcheck-suppress unreadVariable
+    wxVariant d(variant);
+    // cppcheck-suppress unreadVariable
+    wxVariant e(any);
+    // cppcheck-suppress unreadVariable
+    wxVariant f(valuePtr);
+    // cppcheck-suppress unreadVariable
+    wxVariant g(valuePtr, name);
+    // cppcheck-suppress unreadVariable
+    wxVariant h(valueStr);
+    // cppcheck-suppress unreadVariable
+    wxVariant i(valueStr, name);
+    // cppcheck-suppress unreadVariable
+    wxVariant j(charValue);
+    // cppcheck-suppress unreadVariable
+    wxVariant k(charValue, name);
+    // cppcheck-suppress unreadVariable
+    wxVariant l(lValue);
+    // cppcheck-suppress unreadVariable
+    wxVariant m(lValue, name);
+    // cppcheck-suppress unreadVariable
+    wxVariant n(bvalue);
+    // cppcheck-suppress unreadVariable
+    wxVariant o(bvalue, name);
+}
+
+#if defined(__WXMSW__)
+
+void unusedVariable_wxMetafile()
+{
+    // cppcheck-suppress unusedVariable
+    wxMetafile a;
+}
+
+void unusedVariable_wxVariantDataErrorCode()
+{
+    // cppcheck-suppress unusedVariable
+    wxVariantDataErrorCode a;
+}
+void unusedVariable_wxVariantDataCurrency()
+{
+    // cppcheck-suppress unusedVariable
+    wxVariantDataCurrency a;
+}
+void unusedVariable_wxVariantDataSafeArray()
+{
+    // cppcheck-suppress unusedVariable
+    wxVariantDataSafeArray a;
+}
+#endif
+
+void unreadVariable_wxBitmap(const wxBitmap &bmp, const char bits[], const int x, const wxSize &sz)
+{
+    // cppcheck-suppress unusedVariable
+    wxBitmap a;
+    // cppcheck-suppress unreadVariable
+    wxBitmap b(bmp);
+    // cppcheck-suppress unreadVariable
+    wxBitmap c(bits, x, x);
+    // cppcheck-suppress unreadVariable
+    wxBitmap d(bits, x, x, x);
+    // cppcheck-suppress unreadVariable
+    wxBitmap e(x, x);
+    // cppcheck-suppress unreadVariable
+    wxBitmap f(x, x, x);
+    // cppcheck-suppress unreadVariable
+    wxBitmap g(sz);
+    // cppcheck-suppress unreadVariable
+    wxBitmap h(sz, x);
+}
+
+void unusedVariable_wxChar()
+{
+    // cppcheck-suppress unusedVariable
+    wxChar a;
+}
+
+void unusedVariable_wxUniChar(const int c)
+{
+    // cppcheck-suppress unusedVariable
+    wxUniChar a;
+    // cppcheck-suppress unreadVariable
+    wxUniChar b(c);
+}
+
+void unusedVariable_wxSystemOptions()
+{
+    // cppcheck-suppress unusedVariable
+    wxSystemOptions a;
+}
+
+void unusedVariable_wxSystemSettings()
+{
+    // cppcheck-suppress unusedVariable
+    wxSystemSettings a;
+}
+
+void unusedVariable_wxPenList()
+{
+    // cppcheck-suppress unusedVariable
+    wxPenList a;
+}
+
+void unusedVariable_wxPen(const wxColour &colour, int width, const wxPenStyle style, const wxPen &pen)
+{
+    // cppcheck-suppress unusedVariable
+    wxPen a;
+    // cppcheck-suppress unreadVariable
+    wxPen b(colour, width);
+    // cppcheck-suppress unreadVariable
+    wxPen c(colour, width, style);
+    // cppcheck-suppress unreadVariable
+    wxPen d(pen);
+}
+
+void unusedVariable_wxBrush(const wxColour &color, const wxBrushStyle style, const wxBitmap &bmp, const wxBrush &brush)
+{
+    // cppcheck-suppress unusedVariable
+    wxBrush a;
+    // cppcheck-suppress unreadVariable
+    wxBrush b(color, style);
+    // cppcheck-suppress unreadVariable
+    wxBrush c(bmp);
+    // cppcheck-suppress unreadVariable
+    wxBrush d(brush);
+}
+
+void unusedVariable_wxFontList()
+{
+    // cppcheck-suppress unusedVariable
+    wxFontList a;
+}
+
+void unusedVariable_wxFontInfo(const double pointSize, const wxSize &sz)
+{
+    // cppcheck-suppress unusedVariable
+    wxFontInfo a;
+    // cppcheck-suppress unreadVariable
+    wxFontInfo b(pointSize);
+    // cppcheck-suppress unreadVariable
+    wxFontInfo c(sz);
+}
+
+void unusedVariable_wxFont(const wxFont &font,
+                           const wxFontInfo &fontInfo,
+                           const int pointSize,
+                           const wxFontFamily family,
+                           const wxFontStyle style,
+                           const wxFontWeight weight,
+                           const bool underline,
+                           const wxString &faceName,
+                           const wxFontEncoding encoding)
+{
+    // cppcheck-suppress unusedVariable
+    wxFont a;
+    // cppcheck-suppress unreadVariable
+    wxFont b(font);
+    // cppcheck-suppress unreadVariable
+    wxFont c(fontInfo);
+    // cppcheck-suppress unreadVariable
+    wxFont d(pointSize, family, style, weight);
+    // cppcheck-suppress unreadVariable
+    wxFont e(pointSize, family, style, weight, underline);
+    // cppcheck-suppress unreadVariable
+    wxFont f(pointSize, family, style, weight, underline, faceName);
+    // cppcheck-suppress unreadVariable
+    wxFont g(pointSize, family, style, weight, underline, faceName, encoding);
+}
+
+void unusedVariable_wxVector()
+{
+    // cppcheck-suppress unusedVariable
+    wxVector<int> a;
+}
+
+void unusedVariable_wxArrayInt()
+{
+    // cppcheck-suppress unusedVariable
+    wxArrayInt a;
+}
+
+void unusedVariable_wxArrayDouble()
+{
+    // cppcheck-suppress unusedVariable
+    wxArrayDouble a;
+}
+
+void unusedVariable_wxArrayShort()
+{
+    // cppcheck-suppress unusedVariable
+    wxArrayShort a;
+}
+
+void unusedVariable_wxArrayString()
+{
+    // cppcheck-suppress unusedVariable
+    wxArrayString a;
+}
+
+void unusedVariable_wxArrayPtrVoid()
+{
+    // cppcheck-suppress unusedVariable
+    wxArrayPtrVoid a;
+}
+
+void unreadVariable_wxColour(const unsigned char uc, const wxString &name, const unsigned long colRGB, const wxColour &colour)
+{
+    // cppcheck-suppress unusedVariable
+    wxColour a;
+    // cppcheck-suppress unreadVariable
+    wxColour b(uc, uc, uc);
+    // cppcheck-suppress unreadVariable
+    wxColour c(uc, uc, uc, uc);
+    // cppcheck-suppress unreadVariable
+    wxColour d(name);
+    // cppcheck-suppress unreadVariable
+    wxColour e(colRGB);
+    // cppcheck-suppress unreadVariable
+    wxColour f(colour);
+}
+
+void unreadVariable_wxPoint2DInt(const wxInt32 x, const wxPoint2DInt& pti, const wxPoint &pt)
+{
+    // cppcheck-suppress unusedVariable
+    wxPoint2DInt a;
+    // cppcheck-suppress unreadVariable
+    wxPoint2DInt b(x, x);
+    // cppcheck-suppress unreadVariable
+    wxPoint2DInt c(pti);
+    // cppcheck-suppress unreadVariable
+    wxPoint2DInt d(pt);
+}
+
+void unreadVariable_wxPoint2DDouble(const wxDouble x, const wxPoint2DDouble& ptd, const wxPoint2DInt& pti, const wxPoint &pt)
+{
+    // cppcheck-suppress unusedVariable
+    wxPoint2DDouble a;
+    // cppcheck-suppress unreadVariable
+    wxPoint2DDouble b(x, x);
+    // cppcheck-suppress unreadVariable
+    wxPoint2DDouble c(ptd);
+    // cppcheck-suppress unreadVariable
+    wxPoint2DDouble d(pti);
+    // cppcheck-suppress unreadVariable
+    wxPoint2DDouble e(pt);
+}
+
+void unusedVariable_wxAcceleratorEntry()
+{
+    // cppcheck-suppress unusedVariable
+    wxAcceleratorEntry a;
+}
+
+void unreadVariable_wxDateSpan(const int x)
+{
+    // cppcheck-suppress unusedVariable
+    wxDateSpan a;
+    // cppcheck-suppress unreadVariable
+    wxDateSpan b{x};
+    // cppcheck-suppress unreadVariable
+    wxDateSpan c{x, x};
+    // cppcheck-suppress unreadVariable
+    wxDateSpan d{x, x, x};
+    // cppcheck-suppress unreadVariable
+    wxDateSpan e{x, x, x, x};
+}
+
+void unreadVariable_wxTimeSpan(const long x, const wxLongLong y)
+{
+    // cppcheck-suppress unusedVariable
+    wxTimeSpan a;
+    // cppcheck-suppress unreadVariable
+    wxTimeSpan b{};
+    // cppcheck-suppress unreadVariable
+    wxTimeSpan c{x};
+    // cppcheck-suppress unreadVariable
+    wxTimeSpan d{x, x};
+    // cppcheck-suppress unreadVariable
+    wxTimeSpan e{x, x, y};
+    // cppcheck-suppress unreadVariable
+    wxTimeSpan f{x, x, y, y};
+}
+
+void unreadVariable_wxFileType(const wxFileTypeInfo &info)
+{
+    // cppcheck-suppress unreadVariable
+    wxFileType a(info);
+}
+
+void unreadVariable_wxPosition(const int x)
+{
+    // cppcheck-suppress unusedVariable
+    wxPosition a;
+    // cppcheck-suppress unreadVariable
+    wxPosition b{};
+    // cppcheck-suppress unreadVariable
+    wxPosition c{x,x};
+}
+
+void unreadVariable_wxRegEx(const wxString &expr, const int flags)
+{
+    // cppcheck-suppress unusedVariable
+    wxRegEx a;
+    // cppcheck-suppress unreadVariable
+    wxRegEx b{expr};
+    // cppcheck-suppress unreadVariable
+    wxRegEx c{expr, flags};
+}
+
+void unreadVariable_wxRegion(const wxCoord x, const wxPoint &pt, const wxRect &rect, const wxRegion &region, const wxBitmap &bmp)
+{
+    // cppcheck-suppress unusedVariable
+    wxRegion a;
+    // cppcheck-suppress unreadVariable
+    wxRegion b{};
+    // cppcheck-suppress unreadVariable
+    wxRegion c{x,x,x,x};
+    // cppcheck-suppress unreadVariable
+    wxRegion d{pt,pt};
+    // cppcheck-suppress unreadVariable
+    wxRegion e{rect};
+    // cppcheck-suppress unreadVariable
+    wxRegion f{region};
+    // cppcheck-suppress unreadVariable
+    wxRegion g{bmp};
+}
+
+void unreadVariable_wxVersionInfo(const wxString &name, const int major, const int minor, const int micro, const wxString &description, const wxString &copyright)
+{
+    // cppcheck-suppress unusedVariable
+    wxVersionInfo a;
+    // cppcheck-suppress unreadVariable
+    wxVersionInfo b(name);
+    // cppcheck-suppress unreadVariable
+    wxVersionInfo c(name, major);
+    // cppcheck-suppress unreadVariable
+    wxVersionInfo d(name, major, minor);
+    // cppcheck-suppress unreadVariable
+    wxVersionInfo e(name, major, minor, micro);
+    // cppcheck-suppress unreadVariable
+    wxVersionInfo f(name, major, minor, micro, description);
+    // cppcheck-suppress unreadVariable
+    wxVersionInfo g(name, major, minor, micro, description, copyright);
+}
+
+void unreadVariable_wxSize(const wxSize &s)
+{
+    // cppcheck-suppress unusedVariable
+    wxSize a;
+    // cppcheck-suppress unreadVariable
+    wxSize b{};
+    // cppcheck-suppress unreadVariable
+    wxSize c{4, 2};
+    // cppcheck-suppress unreadVariable
+    wxSize d(4, 2);
+    // cppcheck-suppress unreadVariable
+    wxSize e(s);
+}
+
+void unreadVariable_wxPoint(const wxRealPoint &rp, const int x, const int y)
+{
+    // cppcheck-suppress unusedVariable
+    wxPoint a;
+    // cppcheck-suppress unreadVariable
+    wxPoint b{};
+    // cppcheck-suppress unreadVariable
+    wxPoint c{4, 2};
+    // cppcheck-suppress unreadVariable
+    wxPoint d(4, 2);
+    // cppcheck-suppress unreadVariable
+    wxPoint e{x, 2};
+    // cppcheck-suppress unreadVariable
+    wxPoint f(4, y);
+    // cppcheck-suppress unreadVariable
+    wxPoint g(rp);
+}
+
+void unreadVariable_wxRealPoint(const wxPoint &pt, const double x, const double y)
+{
+    // cppcheck-suppress unusedVariable
+    wxRealPoint a;
+    // cppcheck-suppress unreadVariable
+    wxRealPoint b{};
+    // cppcheck-suppress unreadVariable
+    wxRealPoint c{4.0, 2.0};
+    // cppcheck-suppress unreadVariable
+    wxRealPoint d(4.0, 2.0);
+    // cppcheck-suppress unreadVariable
+    wxRealPoint e{x, 2.0};
+    // cppcheck-suppress unreadVariable
+    wxRealPoint f(4.0, y);
+    // cppcheck-suppress unreadVariable
+    wxRealPoint g(pt);
+}
+
+void unreadVariable_wxRect(const int x, const wxPoint &pt, const wxSize &sz)
+{
+    // cppcheck-suppress unusedVariable
+    wxRect a;
+    // cppcheck-suppress unreadVariable
+    wxRect b{};
+    // cppcheck-suppress unreadVariable
+    wxRect c{x,x,x,x};
+    // cppcheck-suppress unreadVariable
+    wxRect d{pt,sz};
+    // cppcheck-suppress unreadVariable
+    wxRect e{sz};
+    // cppcheck-suppress unreadVariable
+    wxRect f(x,x,x,x);
+    // cppcheck-suppress unreadVariable
+    wxRect g(pt,sz);
+    // cppcheck-suppress unreadVariable
+    wxRect h(sz);
+}
+
+void uninitvar_wxRegEx_GetMatch(const wxRegEx &obj, size_t *start, size_t *len, size_t index)
+{
+    size_t s,l;
+    size_t *sPtr,*lPtr;
+    // cppcheck-suppress uninitvar
+    (void)obj.GetMatch(&s,lPtr);
+    // TODO cppcheck-suppress uninitvar
+    (void)obj.GetMatch(sPtr,&l);
+    (void)obj.GetMatch(&s,&l);
+    (void)obj.GetMatch(start,len);
+    (void)obj.GetMatch(start,len,0);
+    (void)obj.GetMatch(start,len,index);
+}
+
+#ifdef __VISUALC__
+// Ensure no duplicateBreak warning is issued after wxLogApiError() calls.
+// This function does not terminate execution.
+bool duplicateBreak_wxLogApiError(const wxString &msg, const HRESULT &hr, wxString &str)
+{
+    if (hr) {
+        wxLogApiError(msg,hr);
+        str = "fail";
+        return false;
+    }
+    return true;
+}
+#endif
+
+void argDirection_wxString_ToDouble(const wxString &str)
+{
+    // No warning is expected. Ensure both arguments are treated
+    // as output by library configuration
+    double value;
+    const bool convOk = str.ToDouble(&value);
+    if (convOk && value <= 42.0) {}
+}
+
+void argDirection_wxString_ToCDouble(const wxString &str)
+{
+    // No warning is expected. Ensure both arguments are treated
+    // as output by library configuration
+    double value;
+    const bool convOk = str.ToCDouble(&value);
+    if (convOk && value <= 42.0) {}
+}
+
+void argDirection_wxTextCtrl_GetSelection(const wxTextCtrl *const textCtrl)
+{
+    // No warning is expected. Ensure both arguments are treated
+    // as output by library configuration
+    long start;
+    long end;
+    textCtrl->GetSelection(&start, &end);
+    if (start > 0 && end > 0) {}
+}
+
+void useRetval_wxString_MakeCapitalized(wxString &str)
+{
+    // No warning is expected for
+    str.MakeCapitalized();
+}
+
+void useRetval_wxString_MakeLower(wxString &str)
+{
+    // No warning is expected for
+    str.MakeLower();
+}
+
+void useRetval_wxString_MakeUpper(wxString &str)
+{
+    // No warning is expected for
+    str.MakeUpper();
+}
+
+wxString containerOutOfBounds_wxArrayString(void)
+{
+    wxArrayString a;
+    a.Add("42");
+    a.Clear();
+    // TODO: wxArrayString is defined to be a vector
+    // TODO: cppcheck-suppress containerOutOfBounds
+    return a[0];
+}
+
+int containerOutOfBounds_wxArrayInt(void)
+{
+    wxArrayInt a;
+    a.Add(42);
+    a.Clear();
+    // TODO: wxArrayString is defined to be a vector
+    // TODO: cppcheck-suppress containerOutOfBounds
+    return a[0];
+}
+
+void ignoredReturnValue_wxDC_GetSize(const wxDC &dc, wxCoord *width, wxCoord *height)
+{
+    // No warning is expected for
+    dc.GetSize(width, height);
+    // No warning is expected for
+    (void)dc.GetSize();
+}
+
+void ignoredReturnValue_wxDC_GetSizeMM(const wxDC &dc, wxCoord *width, wxCoord *height)
+{
+    // No warning is expected for
+    dc.GetSizeMM(width, height);
+    // Now warning is expected for
+    (void)dc.GetSizeMM();
+}
+
+void ignoredReturnValue_wxPanel_Layout(wxPanel* panel) { // #14403
+    panel->Layout();
+}
+
+wxSizerItem* invalidFunctionArgBool_wxSizer_Add(wxSizer *sizer, wxWindow * window, const wxSizerFlags &flags)
+{
+    // No warning is expected for
+    return sizer->Add(window,flags);
+}
+
+bool invalidFunctionArgBool_wxPGProperty_Hide(wxPGProperty *pg, bool hide, int flags)
+{
+    // cppcheck-suppress invalidFunctionArgBool
+    (void)pg->Hide(hide, true);
+    // No warning is expected for
+    return pg->Hide(hide, flags);
+}
+
+wxTextCtrlHitTestResult nullPointer_wxTextCtrl_HitTest(const wxTextCtrl& txtCtrl, const wxPoint& pos)
+{
+    // no nullPointer-warning is expected
+    return txtCtrl.HitTest(pos, NULL);
+}
 
 void validCode()
 {
@@ -143,8 +1114,9 @@ void invalidFunctionArg(const wxString &str)
 void uninitvar(wxWindow &w)
 {
     wxLogLevel logLevelUninit;
+    // cppcheck-suppress constVariable
     char cBufUninit[10];
-    char *pcUninit;
+    const char *pcUninit;
     bool uninitBool;
     // cppcheck-suppress uninitvar
     wxLogGeneric(logLevelUninit, "test");
@@ -160,9 +1132,9 @@ void uninitvar_wxStaticText(wxStaticText &s)
 {
     // no warning
     s.Wrap(-1);
-    bool uninitBool;
+    int uninitInt;
     // cppcheck-suppress uninitvar
-    s.Wrap(uninitBool);
+    s.Wrap(uninitInt);
 }
 
 void uninitvar_wxString_NumberConversion(const wxString &str, const int numberBase)
@@ -217,10 +1189,10 @@ void deprecatedFunctions_wxDataViewCustomRenderer(wxDataViewCustomRenderer &data
     dataViewCustomRenderer.LeftClick(cursor, cell, model, item, col);
 }
 
-void deprecatedFunctions(wxApp &a,
+void deprecatedFunctions([[maybe_unused]] wxApp &a,
                          const wxString &s,
-                         wxArtProvider *artProvider,
-                         wxCalendarCtrl &calenderCtrl,
+                         [[maybe_unused]] wxArtProvider *artProvider,
+                         [[maybe_unused]] wxCalendarCtrl &calenderCtrl,
                          wxComboCtrl &comboCtrl,
                          wxChar * path)
 {
@@ -232,7 +1204,7 @@ void deprecatedFunctions(wxApp &a,
 #if wxCHECK_VERSION(3, 1, 0)  // wxWidets-3.1.0 or higher:
     // Some functions are not available anymore in newer versions
 
-    // @todo cppcheck-suppress ShowPopupCalled
+    // cppcheck-suppress ShowPopupCalled
     comboCtrl.ShowPopup();
 #else
     // cppcheck-suppress InsertCalled
@@ -305,7 +1277,7 @@ wxString::iterator wxString_test3()
 {
     wxString wxString1;
     wxString wxString2;
-    // cppcheck-suppress iterators2
+    // cppcheck-suppress mismatchingContainers
     for (wxString::iterator it = wxString1.begin(); it != wxString2.end(); ++it)
     {}
 
@@ -313,3 +1285,9 @@ wxString::iterator wxString_test3()
     // cppcheck-suppress returnDanglingLifetime
     return it;
 }
+
+wxGrid::wxGridSelectionModes get_wxGridSelectionModes()
+{
+    // cppcheck-suppress valueFlowBailoutIncompleteVar // TODO: configure enum #8183
+    return wxGrid::wxGridSelectCells;
+}
diff --git a/test/cli/QML-Samples-TableView/README b/test/cli/QML-Samples-TableView/README
new file mode 100644
index 00000000000..fed52488ade
--- /dev/null
+++ b/test/cli/QML-Samples-TableView/README
@@ -0,0 +1,2 @@
+Downloaded from here:
+https://github.com/HamedMasafi/QML-Samples
diff --git a/test/cli/QML-Samples-TableView/TableColumn.qml b/test/cli/QML-Samples-TableView/TableColumn.qml
new file mode 100644
index 00000000000..a29f2a7b109
--- /dev/null
+++ b/test/cli/QML-Samples-TableView/TableColumn.qml
@@ -0,0 +1,11 @@
+import QtQuick 2.0
+import QtQuick.Layouts 1.12
+import QtQuick.Controls 2.12
+import QtQml.Models 2.12
+
+QtObject {
+    property string title
+    property string role
+    property bool fillWidth: false
+    property int size: -1
+}
diff --git a/test/cli/QML-Samples-TableView/TableRow.qml b/test/cli/QML-Samples-TableView/TableRow.qml
new file mode 100644
index 00000000000..2b1c7b0c46f
--- /dev/null
+++ b/test/cli/QML-Samples-TableView/TableRow.qml
@@ -0,0 +1,25 @@
+import QtQuick 2.0
+import QtQuick.Layouts 1.12
+import QtQuick.Controls 2.12
+import QtQml.Models 2.12
+
+ItemDelegate {
+    height: 40
+    width: parent.width
+    property bool isHeader: false
+    RowLayout {
+        property var _d: model
+        anchors.fill: parent
+        anchors.leftMargin: 9
+
+        Repeater {
+            model: root.columns
+            Label {
+                text: parent.parent.isHeader ? modelData.title : parent._d[modelData.role]
+                Layout.fillWidth: modelData.fillWidth
+                Layout.preferredWidth: modelData.size !== '*'
+                                       ? modelData.size : 20
+            }
+        }
+    }
+}
diff --git a/test/cli/QML-Samples-TableView/TableView.pro b/test/cli/QML-Samples-TableView/TableView.pro
new file mode 100644
index 00000000000..4dc16d5dc3b
--- /dev/null
+++ b/test/cli/QML-Samples-TableView/TableView.pro
@@ -0,0 +1,27 @@
+QT += quick
+
+CONFIG += c++11
+
+# You can make your code fail to compile if it uses deprecated APIs.
+# In order to do so, uncomment the following line.
+#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
+
+SOURCES += \
+        main.cpp \
+        samplemodel.cpp
+
+RESOURCES += qml.qrc
+
+# Additional import path used to resolve QML modules in Qt Creator's code model
+QML_IMPORT_PATH =
+
+# Additional import path used to resolve QML modules just for Qt Quick Designer
+QML_DESIGNER_IMPORT_PATH =
+
+# Default rules for deployment.
+qnx: target.path = /tmp/$${TARGET}/bin
+else: unix:!android: target.path = /opt/$${TARGET}/bin
+!isEmpty(target.path): INSTALLS += target
+
+HEADERS += \
+    samplemodel.h
diff --git a/test/cli/QML-Samples-TableView/TableView.qml b/test/cli/QML-Samples-TableView/TableView.qml
new file mode 100644
index 00000000000..a30b7c8d737
--- /dev/null
+++ b/test/cli/QML-Samples-TableView/TableView.qml
@@ -0,0 +1,30 @@
+import QtQuick 2.0
+import QtQuick.Layouts 1.12
+import QtQuick.Controls 2.12
+import QtQml.Models 2.12
+
+Item {
+    id: root
+
+    property alias model: tableView.model
+    default property list<TableColumn> columns
+
+    TableRow {
+        id: header
+        anchors.left: parent.left
+        anchors.right: parent.right
+        anchors.top: parent.top
+        background: null
+        isHeader: true
+        height: 60
+    }
+
+    ListView {
+        id: tableView
+        clip: true
+
+        anchors.fill: parent
+        anchors.topMargin: header.height
+        delegate: TableRow {}
+    }
+}
diff --git a/test/cli/QML-Samples-TableView/main.cpp b/test/cli/QML-Samples-TableView/main.cpp
new file mode 100644
index 00000000000..21d72bf21e8
--- /dev/null
+++ b/test/cli/QML-Samples-TableView/main.cpp
@@ -0,0 +1,21 @@
+#include <QtGui/QGuiApplication>
+#include <QtQml/QQmlApplicationEngine>
+#include "samplemodel.h"
+
+int main(int argc, char *argv[])
+{
+    QGuiApplication app(argc, argv);
+
+    QQmlApplicationEngine engine;
+    qmlRegisterType<SampleModel>("Test", 1, 0, "SampleModel");
+
+    const QUrl url(QStringLiteral("qrc:/main.qml"));
+    QObject::connect(&engine, &QQmlApplicationEngine::objectCreated,
+                     &app, [url](QObject *obj, const QUrl &objUrl) {
+        if (!obj && url == objUrl)
+            QCoreApplication::exit(-1);
+    }, Qt::QueuedConnection);
+    engine.load(url);
+
+    return app.exec();
+}
diff --git a/test/cli/QML-Samples-TableView/main.qml b/test/cli/QML-Samples-TableView/main.qml
new file mode 100644
index 00000000000..6a8cc43f9cf
--- /dev/null
+++ b/test/cli/QML-Samples-TableView/main.qml
@@ -0,0 +1,37 @@
+import QtQuick 2.12
+import QtQuick.Window 2.12
+import Test 1.0
+import '.' as Here
+
+Window {
+    width: 640
+    height: 480
+    visible: true
+    title: qsTr("Hello World")
+
+    Component.onCompleted: sampleModel.fillSampleData(50)
+    SampleModel {
+        id: sampleModel
+    }
+
+    Here.TableView {
+        anchors.fill: parent
+        model: sampleModel
+
+        TableColumn {
+            title: qsTr("Id")
+            role: 'id'
+            size: 30
+        }
+        TableColumn {
+            title: qsTr("Name")
+            role: 'name'
+            fillWidth: true
+        }
+        TableColumn {
+            title: qsTr("Grade")
+            role: 'grade'
+            size: 50
+        }
+    }
+}
diff --git a/test/cli/QML-Samples-TableView/qml.qrc b/test/cli/QML-Samples-TableView/qml.qrc
new file mode 100644
index 00000000000..cf94b15b8fb
--- /dev/null
+++ b/test/cli/QML-Samples-TableView/qml.qrc
@@ -0,0 +1,8 @@
+<RCC>
+    <qresource prefix="/">
+        <file>main.qml</file>
+        <file>TableView.qml</file>
+        <file>TableRow.qml</file>
+        <file>TableColumn.qml</file>
+    </qresource>
+</RCC>
diff --git a/test/cli/QML-Samples-TableView/samplemodel.cpp b/test/cli/QML-Samples-TableView/samplemodel.cpp
new file mode 100644
index 00000000000..7032d37a771
--- /dev/null
+++ b/test/cli/QML-Samples-TableView/samplemodel.cpp
@@ -0,0 +1,66 @@
+#include "samplemodel.h"
+
+#include <QDebug>
+#include <QRandomGenerator>
+
+SampleModel::SampleModel(QObject *parent) : QAbstractListModel(parent)
+{}
+
+int SampleModel::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent)
+    return _data.size();
+}
+
+QVariant SampleModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid())
+        return QVariant();
+    if (index.row() < 0 || index.row() > _data.count() - 1)
+        return QVariant();
+
+    auto row = _data.at(index.row());
+
+    switch (role) {
+    case IdRole:
+        return index.row();
+
+    case NameRole:
+        return row.first;
+
+    case GradeRole:
+        return row.second;
+    }
+
+    return QVariant();
+}
+
+QHash<int, QByteArray> SampleModel::roleNames() const
+{
+    return {
+        {IdRole, "id"},
+        {NameRole, "name"},
+        {GradeRole, "grade"}
+    };
+}
+
+void SampleModel::fillSampleData(int size)
+{
+    QString abs = "qwertyuiopasdfghjklzxcvbnm";
+    QRandomGenerator r;
+    for (auto i = 0; i < size; i++) {
+        Row row;
+        auto nameLen = r.bounded(3, 8);
+        QString name;
+        for (int c = 0; c < nameLen; ++c)
+            name.append(abs.at(r.bounded(0, abs.size() - 1)));
+
+        row.first = name;
+        row.second = r.bounded(0, 20);
+        _data.append(row);
+    }
+
+    qDebug() << _data.size() << "item(s) added as sample data";
+    beginInsertRows(QModelIndex(), 0, _data.size() - 1);
+    endInsertRows();
+}
diff --git a/test/cli/QML-Samples-TableView/samplemodel.h b/test/cli/QML-Samples-TableView/samplemodel.h
new file mode 100644
index 00000000000..2bb9107e55a
--- /dev/null
+++ b/test/cli/QML-Samples-TableView/samplemodel.h
@@ -0,0 +1,30 @@
+#ifndef SAMPLEMODEL_H
+#define SAMPLEMODEL_H
+
+#include <QAbstractListModel>
+
+class SampleModel : public QAbstractListModel
+{
+    Q_OBJECT
+
+    typedef QPair<QString, int> Row;
+    QList<Row> _data;
+
+public:
+    enum Role {
+        IdRole = Qt::UserRole + 1,
+        NameRole,
+        GradeRole
+    };
+
+    SampleModel(QObject *parent = nullptr);
+
+    int rowCount(const QModelIndex &parent) const;
+    QVariant data(const QModelIndex &index, int role) const;
+    QHash<int, QByteArray> roleNames() const;
+
+public slots:
+    void fillSampleData(int size);
+};
+
+#endif // SAMPLEMODEL_H
diff --git a/test/cli/clang-import_test.py b/test/cli/clang-import_test.py
new file mode 100644
index 00000000000..e4ec19a5ada
--- /dev/null
+++ b/test/cli/clang-import_test.py
@@ -0,0 +1,305 @@
+
+# python -m pytest test-clang-import.py
+
+import os
+import re
+import subprocess
+import sys
+import pytest
+from testutils import cppcheck, assert_cppcheck
+
+try:
+    # TODO: handle exitcode?
+    subprocess.call(['clang', '--version'])
+except OSError:
+    pytest.skip("'clang' does not exist", allow_module_level=True)
+
+
+# the IDs differ with Visual Studio
+if sys.platform == 'win32':
+    pytest.skip(allow_module_level=True)
+
+
+def __get_debug_section(title, stdout):
+    s = re.sub(r'0x[0-9a-fA-F]+', '0x12345678', stdout)
+    s = re.sub(r'nestedIn: Struct', 'nestedIn: Class', s)
+    s = re.sub(r'classDef: struct', 'classDef: class', s)
+    s = re.sub(r'isInline: [a-z]+', 'isInline: ---', s)
+    s = re.sub(r'needInitialization: .*', 'needInitialization: ---', s)
+    s = re.sub(r'functionOf: .*', 'functionOf: ---', s)
+    s = re.sub(r'0x12345678 Struct', '0x12345678 Class', s)
+
+    if title == '##AST':
+        # TODO set types
+        s = re.sub(r"return '[a-zA-Z0-9: *]+'", "return", s)
+
+    pos1 = s.find(title)
+    assert pos1 > 0, 'title not found'
+    pos1 = s.find('\n', pos1) + 1
+    assert pos1 > 0
+    pos2 = s.find("\n##", pos1)
+    if pos2 < 0:
+        return s[pos1:]
+    return s[pos1:pos2-1]
+
+
+def __check_symbol_database(tmpdir, code):
+    testfile = os.path.join(tmpdir, 'test.cpp')
+    with open(testfile, 'w+t') as f:
+        f.write(code)
+    ret1, stdout1, _ = cppcheck(['-q', '--clang', '--debug-symdb', testfile])
+    ret2, stdout2, _ = cppcheck(['-q', '--debug-symdb', testfile])
+    assert 0 == ret1, stdout1
+    assert 0 == ret2, stdout2
+    assert __get_debug_section('### Symbol database', stdout1) == __get_debug_section('### Symbol database', stdout2)
+
+
+def __check_ast(tmpdir, code):
+    testfile = os.path.join(tmpdir, 'test.cpp')
+    with open(testfile, 'w+t') as f:
+        f.write(code)
+    ret1, stdout1, _ = cppcheck(['-q', '--clang', '--debug-ast', testfile])
+    ret2, stdout2, _ = cppcheck(['-q', '--debug-ast', testfile])
+    assert 0 == ret1, stdout1
+    assert 0 == ret2, stdout1
+    assert __get_debug_section('##AST', stdout1) == __get_debug_section('##AST', stdout2)
+
+
+
+def test_symbol_database_1(tmpdir):
+    __check_symbol_database(tmpdir, 'int main(){return 0;}')
+
+def test_symbol_database_2(tmpdir):
+    __check_symbol_database(tmpdir, 'struct Foo { void f(); }; void Foo::f() {}')
+
+def test_symbol_database_3(tmpdir):
+    __check_symbol_database(tmpdir, 'struct Fred { int a; }; int b; void f(int c, int d) { int e; }')
+
+def test_symbol_database_4(tmpdir):
+    __check_symbol_database(tmpdir, 'void f(const int x) {}')
+
+def test_symbol_database_5(tmpdir):
+    __check_symbol_database(tmpdir, 'void f(int);')
+
+def test_symbol_database_6(tmpdir):
+    __check_symbol_database(tmpdir, 'inline static int foo(int x) { return x; }')
+
+def test_symbol_database_7(tmpdir):
+    __check_symbol_database(tmpdir, 'struct S {int x;}; void f(struct S *s) {}')
+
+def test_symbol_database_class_access_1(tmpdir):
+    __check_symbol_database(tmpdir, 'class Fred { void foo ( ) {} } ;')
+
+def test_symbol_database_class_access_2(tmpdir):
+    __check_symbol_database(tmpdir, 'class Fred { protected: void foo ( ) {} } ;')
+
+def test_symbol_database_class_access_3(tmpdir):
+    __check_symbol_database(tmpdir, 'class Fred { public: void foo ( ) {} } ;')
+
+def test_symbol_database_operator(tmpdir):
+    __check_symbol_database(tmpdir, 'struct Fred { void operator=(int x); };')
+
+def test_symbol_database_struct_1(tmpdir):
+    __check_symbol_database(tmpdir, 'struct S {};')
+
+def test_ast_calculations(tmpdir):
+    __check_ast(tmpdir, 'int x = 5; int y = (x + 4) * 2;')
+    __check_ast(tmpdir, 'long long dostuff(int x) { return x ? 3 : 5; }')
+
+def test_ast_control_flow(tmpdir):
+    __check_ast(tmpdir, 'void foo(int x) { if (x > 5){} }')
+    __check_ast(tmpdir, 'int dostuff() { for (int x = 0; x < 10; x++); }')
+    __check_ast(tmpdir, 'void foo(int x) { switch (x) {case 1: break; } }')
+    __check_ast(tmpdir, 'void foo(int a, int b, int c) { foo(a,b,c); }')
+
+def test_ast(tmpdir):
+    __check_ast(tmpdir, 'struct S { int x; }; S* foo() { return new S(); }')
+
+def test_log(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt'):
+        pass
+
+    args = ['--clang', test_file]
+    out_lines = [
+        'Checking {} ...'.format(test_file).replace('\\', '/'),
+    ]
+
+    assert_cppcheck(args, ec_exp=0, err_exp=[], out_exp=out_lines)
+
+
+def test_warning(tmpdir):  # #12424
+    test_file = os.path.join(tmpdir, 'test_2')
+    with open(test_file, 'wt') as f:
+        f.write('''void f() {}''')
+
+    exitcode, stdout, stderr = cppcheck(['-q', '--enable=warning', '--clang', test_file])
+    assert exitcode == 0, stderr # do not assert
+    assert stdout == ''
+    assert stderr == ''
+
+
+def __test_cmd(tmp_path, file_name, extra_args, stdout_exp_1, content=''):
+    test_file = tmp_path / file_name
+    with open(test_file, 'wt') as f:
+        f.write(content)
+
+    args = [
+        '--enable=information',
+        '--verbose',
+        '--clang',
+        file_name
+    ]
+
+    args += extra_args
+
+    if stdout_exp_1:
+        stdout_exp_1 += ' '
+
+    exitcode, stdout, stderr = cppcheck(args, cwd=tmp_path)
+    assert exitcode == 0, stderr if not stdout else stdout
+    assert stderr == ''
+    assert stdout.splitlines() == [
+        'Checking {} ...'.format(file_name),
+        'clang -fsyntax-only -Xclang -ast-dump -fno-color-diagnostics {}{}'.format(stdout_exp_1, file_name)
+    ]
+
+
+def test_cmd_c(tmp_path):
+    __test_cmd(tmp_path, 'test.c', [], '-x c')
+
+
+def test_cmd_cpp(tmp_path):
+    __test_cmd(tmp_path, 'test.cpp', [], '-x c++')
+
+
+# files with unknown extensions are treated as C++
+def test_cmd_unk(tmp_path):
+    __test_cmd(tmp_path, 'test.cplusplus', [], '-x c++')
+
+
+# headers are treated as C by default
+def test_cmd_hdr(tmp_path):
+    __test_cmd(tmp_path, 'test.h', [], '-x c')
+
+
+def test_cmd_hdr_probe(tmp_path):
+    __test_cmd(tmp_path, 'test.h', ['--cpp-header-probe'], '-x c++', '// -*- C++ -*-')
+
+
+def test_cmd_inc(tmp_path):
+    inc_path = tmp_path / 'inc'
+    os.makedirs(inc_path)
+    __test_cmd(tmp_path, 'test.cpp',['-Iinc'], '-x c++ -Iinc/')
+
+
+def test_cmd_def(tmp_path):
+    __test_cmd(tmp_path, 'test.cpp',['-DDEF'], '-x c++ -DDEF=1')
+
+
+def test_cmd_include(tmp_path):
+    inc_file = tmp_path / 'inc.h'
+    with open(inc_file, 'wt'):
+        pass
+    __test_cmd(tmp_path, 'test.cpp',['--include=inc.h'], '-x c++ --include inc.h')
+
+
+def test_cmd_enforce_c(tmp_path):  # #13128
+    __test_cmd(tmp_path, 'test.cpp',['-x', 'c'], '-x c')
+
+
+def test_cmd_enforce_cpp(tmp_path):  # #13128
+    __test_cmd(tmp_path, 'test.c',['-x', 'c++'], '-x c++')
+
+
+def test_cmd_std_c(tmp_path):  # #13129
+    __test_cmd(tmp_path, 'test.cpp',['--std=c89', '--std=c++14'], '-x c++ -std=c++14')
+
+
+# TODO: remove when we inject the build-dir into all tests
+def test_cmd_std_c_builddir(tmp_path):  # #13129
+    build_dir = tmp_path / 'b1'
+    os.makedirs(build_dir)
+    __test_cmd(tmp_path, 'test.cpp',['--std=c89', '--std=c++14', '--cppcheck-build-dir={}'.format(build_dir)], '-x c++ -std=c++14')
+
+
+def test_cmd_std_cpp(tmp_path):  # #13129
+    __test_cmd(tmp_path, 'test.c',['--std=c89', '--std=c++14'], '-x c -std=c89')
+
+
+def test_cmd_std_c_enforce(tmp_path):  # #13128/#13129
+    __test_cmd(tmp_path, 'test.cpp',['--language=c', '--std=c89', '--std=c++14'], '-x c -std=c89')
+
+
+def test_cmd_std_cpp_enforce(tmp_path):  # #13128/#13129
+    __test_cmd(tmp_path, 'test.c',['--language=c++', '--std=c89', '--std=c++14'], '-x c++ -std=c++14')
+
+
+def test_cmd_std_c_enforce_alias(tmp_path):  # #13128/#13129/#13130
+    __test_cmd(tmp_path, 'test.c',['--language=c', '--std=gnu99', '--std=gnu++11'], '-x c -std=gnu99')
+
+
+def test_cmd_std_c_enforce_alias_2(tmp_path):  # #13128/#13129/#13130
+    __test_cmd(tmp_path, 'test.c',['--language=c', '--std=iso9899:1999', '--std=gnu++11'], '-x c -std=iso9899:1999')
+
+
+def test_cmd_std_cpp_enforce_alias(tmp_path):  # #13128/#13129/#13130
+    __test_cmd(tmp_path, 'test.c',['--language=c++', '--std=gnu99', '--std=gnu++11'], '-x c++ -std=gnu++11')
+
+
+def test_debug_clang_output(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write(
+"""
+void f() {}
+""")
+
+    args = [
+        '-q',
+        '--clang',
+        '--debug-clang-output',
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stderr if not stdout else stdout
+    assert stderr == ''
+    assert stdout.startswith('TranslationUnitDecl'), stdout
+    assert stdout.find(str(test_file)) != -1, stdout
+
+
+def test_debug_clang_output_failure_exitcode(tmp_path):
+    # the given code will cause clang to fail with an exitcode
+    #
+    # Failed to execute 'clang -fsyntax-only -Xclang -ast-dump -fno-color-diagnostics -x c++ a.cpp 2>&1' - (exitcode: 1 / output: a.cpp:3:12: error: indirection requires pointer operand ('int' invalid)
+    # 3 |     (void)(*0);
+    # |            ^~
+    # 1 error generated.
+    # TranslationUnitDecl 0x6127d5d9d4e8 <<invalid sloc>> <invalid sloc>
+    # ...
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write(
+"""void f()
+{
+    (void)(*0);
+}
+""")
+
+    args = [
+        '-q',
+        '--clang',
+        '--debug-clang-output',
+        '--no-cppcheck-build-dir',  # TODO: test without this?
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stderr if not stdout else stdout
+    stderr_lines = stderr.splitlines()
+    assert len(stderr_lines) > 5, stderr_lines
+    assert (stderr_lines[0] ==
+            "Failed to execute 'clang -fsyntax-only -Xclang -ast-dump -fno-color-diagnostics -x c {} 2>&1' - (exitcode: 1 / output: {}:3:12: error: indirection requires pointer operand ('int' invalid)".format(test_file, test_file))
+    assert stdout.find('TranslationUnitDecl') != -1, stdout
+    assert stdout.find(str(test_file)) != -1, stdout
\ No newline at end of file
diff --git a/test/cli/dumpfile_test.py b/test/cli/dumpfile_test.py
new file mode 100644
index 00000000000..932c4363a30
--- /dev/null
+++ b/test/cli/dumpfile_test.py
@@ -0,0 +1,134 @@
+# python -m pytest dumpfile_test.py
+
+import json
+import os
+import pathlib
+
+from testutils import cppcheck
+import xml.etree.ElementTree as ET
+
+
+def test_libraries(tmpdir):  #13701
+    test_file = str(tmpdir / 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write('x=1;\n')
+
+    args = ['--library=posix', '--dump', test_file]
+    _, _, _ = cppcheck(args)
+
+    dumpfile = test_file + '.dump'
+    assert os.path.isfile(dumpfile)
+    with open(dumpfile, 'rt') as f:
+        dump = f.read()
+    assert '<library lib="posix"/>' in dump
+    assert dump.find('<library lib="posix"/>') < dump.find('<dump cfg=')
+
+
+def __test_language(tmp_path, file_ext, exp_lang, force_lang=None):
+    test_file = tmp_path / ('test.' + file_ext)
+    with open(test_file, 'wt'):
+        pass
+
+    args = [
+        '--dump',
+        str(test_file)
+    ]
+    if force_lang:
+        args += ['--language=' + force_lang]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout if stdout else stderr
+
+    dump_s = pathlib.Path(str(test_file) + '.dump').read_text()
+
+    dump_xml = ET.fromstring(dump_s)
+    assert 'language' in dump_xml.attrib
+    assert dump_xml.attrib['language'] == exp_lang
+
+
+def test_language_c(tmp_path):
+    __test_language(tmp_path, 'c', exp_lang='c')
+
+
+def test_language_c_force_c(tmp_path):
+    __test_language(tmp_path, 'c', force_lang='c', exp_lang='c')
+
+
+def test_language_c_force_cpp(tmp_path):
+    __test_language(tmp_path, 'c', force_lang='c++', exp_lang='cpp')
+
+
+def test_language_cpp(tmp_path):
+    __test_language(tmp_path, 'cpp', exp_lang='cpp')
+
+
+def test_language_cpp_force_cpp(tmp_path):
+    __test_language(tmp_path, 'cpp', force_lang='c++', exp_lang='cpp')
+
+
+def test_language_cpp_force_c(tmp_path):
+    __test_language(tmp_path, 'cpp', force_lang='c', exp_lang='c')
+
+
+# headers default to C
+def test_language_h(tmp_path):
+    __test_language(tmp_path, 'h', exp_lang='c')
+
+
+def test_language_h_force_c(tmp_path):
+    __test_language(tmp_path, 'h', force_lang='c', exp_lang='c')
+
+
+def test_language_h_force_cpp(tmp_path):
+    __test_language(tmp_path, 'h', force_lang='c++', exp_lang='cpp')
+
+
+# files with unknown extensions default to C++
+def test_language_unk(tmp_path):
+    __test_language(tmp_path, 'src', exp_lang='cpp')
+
+
+def test_language_unk_force_c(tmp_path):
+    __test_language(tmp_path, 'src', force_lang='c', exp_lang='c')
+
+
+def test_language_unk_force_cpp(tmp_path):
+    __test_language(tmp_path, 'src', force_lang='c++', exp_lang='cpp')
+
+
+def test_duplicate_file_entries(tmpdir):  #13333
+    test_file = str(tmpdir / 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write('x=1;\n')
+
+    project_file = str(tmpdir / 'compile_commands.json')
+    with open(project_file, 'wt') as f:
+        f.write(json.dumps([{
+               "file": test_file,
+               "directory": str(tmpdir),
+               "command": "cc -c test.c"
+            },{
+               "file": test_file,
+               "directory": str(tmpdir),
+               "command": "cc -c test.c"
+            }]))
+
+    args = ['--project=compile_commands.json', '--dump']
+    _, _, _ = cppcheck(args, cwd=str(tmpdir))
+
+    assert os.path.isfile(test_file + '.dump')
+    assert os.path.isfile(test_file + '.1.dump')
+
+
+def test_container_methods(tmpdir):
+    test_file = str(tmpdir / 'test.cpp')
+    with open(test_file, 'wt') as f:
+        f.write('std::string s;\n')
+
+    exitcode, _, stderr = cppcheck(['--dump', '.'], cwd=str(tmpdir))
+    assert exitcode == 0, stderr
+
+    dumpfile = test_file + '.dump'
+    with open(dumpfile, 'rt') as f:
+        dump = f.read()
+    assert '<f name="emplace" action="push" yield="iterator"/>' in dump
diff --git a/test/cli/fuzz-crash/crash-039028704ca27187fc3228e9fa01ca30a8434e7a b/test/cli/fuzz-crash/crash-039028704ca27187fc3228e9fa01ca30a8434e7a
new file mode 100644
index 00000000000..7dab9f7d28a
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-039028704ca27187fc3228e9fa01ca30a8434e7a
@@ -0,0 +1 @@
+_ 1p;
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-0400fbfed5c89e368e436dbac630db0f80db94bd b/test/cli/fuzz-crash/crash-0400fbfed5c89e368e436dbac630db0f80db94bd
new file mode 100644
index 00000000000..d6e9b32be37
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-0400fbfed5c89e368e436dbac630db0f80db94bd
@@ -0,0 +1 @@
+typedef i(*const type2)();typedef t(ty)();(v ty)type2()
diff --git a/test/cli/fuzz-crash/crash-04f8bc02d0683e12579485090f4a2cbc55d3c955 b/test/cli/fuzz-crash/crash-04f8bc02d0683e12579485090f4a2cbc55d3c955
new file mode 100644
index 00000000000..1e6a05d0ae6
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-04f8bc02d0683e12579485090f4a2cbc55d3c955
@@ -0,0 +1 @@
+b f(){using e}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-0f0efd6e66bd115fc0aabbfe6503230b31de5f24 b/test/cli/fuzz-crash/crash-0f0efd6e66bd115fc0aabbfe6503230b31de5f24
new file mode 100644
index 00000000000..a011f109bd7
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-0f0efd6e66bd115fc0aabbfe6503230b31de5f24
@@ -0,0 +1 @@
+d f(t*a){a[a[3]]}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-0fc87af032255dddcea3248798a6e19ab49b231a b/test/cli/fuzz-crash/crash-0fc87af032255dddcea3248798a6e19ab49b231a
new file mode 100644
index 00000000000..46f648c018c
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-0fc87af032255dddcea3248798a6e19ab49b231a
@@ -0,0 +1 @@
+{template<~>tu<0>}tu=c<F
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-15d71125ba17344f02417a9d46443cdaa30aa17f b/test/cli/fuzz-crash/crash-15d71125ba17344f02417a9d46443cdaa30aa17f
new file mode 100644
index 00000000000..5d268fdf158
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-15d71125ba17344f02417a9d46443cdaa30aa17f
@@ -0,0 +1 @@
+t m(){int a[]i for(;;)}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-19219d7e7dfe8202248cd22229cdd9a2fd87a78a b/test/cli/fuzz-crash/crash-19219d7e7dfe8202248cd22229cdd9a2fd87a78a
new file mode 100644
index 00000000000..b0042052db2
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-19219d7e7dfe8202248cd22229cdd9a2fd87a78a
@@ -0,0 +1 @@
+n::template u
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-19269c327fd82c6db8f9f2b0c47c645a721ff55a b/test/cli/fuzz-crash/crash-19269c327fd82c6db8f9f2b0c47c645a721ff55a
new file mode 100644
index 00000000000..ac4c5f2b1de
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-19269c327fd82c6db8f9f2b0c47c645a721ff55a
@@ -0,0 +1 @@
+n eu<#F A<>;template<#m<>eu=i
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-1b9524a7fa25529c34c06b04372efd44e72ccfdc b/test/cli/fuzz-crash/crash-1b9524a7fa25529c34c06b04372efd44e72ccfdc
new file mode 100644
index 00000000000..802e88e43fc
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-1b9524a7fa25529c34c06b04372efd44e72ccfdc
@@ -0,0 +1 @@
+(h l).h
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-1bcbece2593792b0d34fb8f5dbacbae22decd082 b/test/cli/fuzz-crash/crash-1bcbece2593792b0d34fb8f5dbacbae22decd082
new file mode 100644
index 00000000000..c95fb490043
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-1bcbece2593792b0d34fb8f5dbacbae22decd082
@@ -0,0 +1 @@
+enum{A=0()7=F};
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-1c67200986f8cd9788ccf3dbb764d49cb67819b1 b/test/cli/fuzz-crash/crash-1c67200986f8cd9788ccf3dbb764d49cb67819b1
new file mode 100644
index 00000000000..06055955e6b
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-1c67200986f8cd9788ccf3dbb764d49cb67819b1
@@ -0,0 +1 @@
+e U U,i
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-20efd8856e04ca1fced9daa93837ae3384bb5e62 b/test/cli/fuzz-crash/crash-20efd8856e04ca1fced9daa93837ae3384bb5e62
new file mode 100644
index 00000000000..bc4d567d733
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-20efd8856e04ca1fced9daa93837ae3384bb5e62
@@ -0,0 +1 @@
+assert({:=;})
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-2490dbc1880f2d7883c1b634deee8da3805186f8 b/test/cli/fuzz-crash/crash-2490dbc1880f2d7883c1b634deee8da3805186f8
new file mode 100644
index 00000000000..60a55bed0b9
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-2490dbc1880f2d7883c1b634deee8da3805186f8
@@ -0,0 +1 @@
+i a;m t(=a[]);m e(){a[]=0}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-26edfe9761d3b681c841dfe80398847dee332f83 b/test/cli/fuzz-crash/crash-26edfe9761d3b681c841dfe80398847dee332f83
new file mode 100644
index 00000000000..ca4faea1d2e
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-26edfe9761d3b681c841dfe80398847dee332f83
@@ -0,0 +1 @@
+[]<i
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-28733cc31fd7f5d636beeaa3fa2bc30779fc6487 b/test/cli/fuzz-crash/crash-28733cc31fd7f5d636beeaa3fa2bc30779fc6487
new file mode 100644
index 00000000000..adf0f71ff8f
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-28733cc31fd7f5d636beeaa3fa2bc30779fc6487
@@ -0,0 +1 @@
+assert({:=4;})
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-2adde1da09b2db453c18898785b78024adb02c78 b/test/cli/fuzz-crash/crash-2adde1da09b2db453c18898785b78024adb02c78
new file mode 100644
index 00000000000..ee90f9ea13d
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-2adde1da09b2db453c18898785b78024adb02c78
@@ -0,0 +1 @@
+S namespace d=S;e namespace d=a
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-2cf8ffd04628a7c025bb07074462a51c1284dff0 b/test/cli/fuzz-crash/crash-2cf8ffd04628a7c025bb07074462a51c1284dff0
new file mode 100644
index 00000000000..ffa34fb944d
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-2cf8ffd04628a7c025bb07074462a51c1284dff0
@@ -0,0 +1 @@
+//REMARK /
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-3275671bf6888060270f902458ff36c711718e22 b/test/cli/fuzz-crash/crash-3275671bf6888060270f902458ff36c711718e22
new file mode 100644
index 00000000000..c4057bba583
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-3275671bf6888060270f902458ff36c711718e22
@@ -0,0 +1 @@
+v o(ia){$ i;for(i:)a=[]0;}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-34c8d34fd4607de810d8d5bec881b40d37533181 b/test/cli/fuzz-crash/crash-34c8d34fd4607de810d8d5bec881b40d37533181
new file mode 100644
index 00000000000..9c0ebaea86e
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-34c8d34fd4607de810d8d5bec881b40d37533181
@@ -0,0 +1 @@
+t<e<:template<>e=c>n
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-3997cb1cad0af26035d36ca1a01ece07ca3fd114 b/test/cli/fuzz-crash/crash-3997cb1cad0af26035d36ca1a01ece07ca3fd114
new file mode 100644
index 00000000000..fe21ddcbfa4
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-3997cb1cad0af26035d36ca1a01ece07ca3fd114
@@ -0,0 +1 @@
+b=1;t o(){& &&&}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-3de394576af6f9f7ca95bdd282075d06f980252f b/test/cli/fuzz-crash/crash-3de394576af6f9f7ca95bdd282075d06f980252f
new file mode 100644
index 00000000000..7122cb87302
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-3de394576af6f9f7ca95bdd282075d06f980252f
@@ -0,0 +1 @@
+t o(){for(u*e,:c)t c=e;}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-3ea64296c8518edb538e0047c3eba0792d5deeba b/test/cli/fuzz-crash/crash-3ea64296c8518edb538e0047c3eba0792d5deeba
new file mode 100644
index 00000000000..a12e6966bd5
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-3ea64296c8518edb538e0047c3eba0792d5deeba
@@ -0,0 +1 @@
+n i(){t i;for(i=0;i<3;++);}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-43fe82a87d6a7f34f000cbbc90b63ad1a58e3dcd b/test/cli/fuzz-crash/crash-43fe82a87d6a7f34f000cbbc90b63ad1a58e3dcd
new file mode 100644
index 00000000000..ac43489b2c0
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-43fe82a87d6a7f34f000cbbc90b63ad1a58e3dcd
@@ -0,0 +1 @@
+d o(){t&a=*&a}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-44b5d1f53328660cbcb6e90793eae2ff8ffc4893 b/test/cli/fuzz-crash/crash-44b5d1f53328660cbcb6e90793eae2ff8ffc4893
new file mode 100644
index 00000000000..c45497a8601
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-44b5d1f53328660cbcb6e90793eae2ff8ffc4893
@@ -0,0 +1 @@
+typedef q r[];r A
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-49338578888313fd087eb219d248c9aaf4ea9d0b b/test/cli/fuzz-crash/crash-49338578888313fd087eb219d248c9aaf4ea9d0b
new file mode 100644
index 00000000000..484bdfe4ca3
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-49338578888313fd087eb219d248c9aaf4ea9d0b
@@ -0,0 +1 @@
+;namespace d=S;r namespace d=X
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-4ad024d4f64dfd58d73a3296173fe13860fb8b70 b/test/cli/fuzz-crash/crash-4ad024d4f64dfd58d73a3296173fe13860fb8b70
new file mode 100644
index 00000000000..7aaf95a8378
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-4ad024d4f64dfd58d73a3296173fe13860fb8b70
@@ -0,0 +1 @@
+n f(){auto x=i->o x}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-4d4e80f09d4733a9f724282d60ee4e3c3a143b61 b/test/cli/fuzz-crash/crash-4d4e80f09d4733a9f724282d60ee4e3c3a143b61
new file mode 100644
index 00000000000..de445fa92bf
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-4d4e80f09d4733a9f724282d60ee4e3c3a143b61
@@ -0,0 +1 @@
+d o(i*a){n b;*a=&b;if(a)r{}}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-522f048722bf5f33fa10a32a4c5253d1dc8b01d5 b/test/cli/fuzz-crash/crash-522f048722bf5f33fa10a32a4c5253d1dc8b01d5
new file mode 100644
index 00000000000..4f6def81102
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-522f048722bf5f33fa10a32a4c5253d1dc8b01d5
@@ -0,0 +1 @@
+C(){o y=>::*}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-58e1517a74e314553e8eef249268cec29493235b b/test/cli/fuzz-crash/crash-58e1517a74e314553e8eef249268cec29493235b
new file mode 100644
index 00000000000..935f807a15f
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-58e1517a74e314553e8eef249268cec29493235b
@@ -0,0 +1 @@
+n a(){!!=!!?:b}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-5ac13e244448ff767f6596c220edb9ef7b61fa6d b/test/cli/fuzz-crash/crash-5ac13e244448ff767f6596c220edb9ef7b61fa6d
new file mode 100644
index 00000000000..7bbc08cfd6d
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-5ac13e244448ff767f6596c220edb9ef7b61fa6d
@@ -0,0 +1 @@
+template<>struct t<>();
diff --git a/test/cli/fuzz-crash/crash-5db88ae1610f5a9782ea78af206f9cd87b6708dd b/test/cli/fuzz-crash/crash-5db88ae1610f5a9782ea78af206f9cd87b6708dd
new file mode 100644
index 00000000000..8026606c85c
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-5db88ae1610f5a9782ea78af206f9cd87b6708dd
@@ -0,0 +1 @@
+{for(typedef;);}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-66bd8440a699d270b323367978dab020dd1da3ff b/test/cli/fuzz-crash/crash-66bd8440a699d270b323367978dab020dd1da3ff
new file mode 100644
index 00000000000..bdae8e1eded
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-66bd8440a699d270b323367978dab020dd1da3ff
@@ -0,0 +1 @@
+enum{C={;}=e};
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-68f8e0ba3d73255e879027ffd2dd39bf8cc34120 b/test/cli/fuzz-crash/crash-68f8e0ba3d73255e879027ffd2dd39bf8cc34120
new file mode 100644
index 00000000000..fd4f065e79c
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-68f8e0ba3d73255e879027ffd2dd39bf8cc34120
@@ -0,0 +1 @@
+v f(){B?1::s:t}
diff --git a/test/cli/fuzz-crash/crash-69570c88fc79e9a66ce2f2c729b455eaa237f3d2 b/test/cli/fuzz-crash/crash-69570c88fc79e9a66ce2f2c729b455eaa237f3d2
new file mode 100644
index 00000000000..a901d0c5c07
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-69570c88fc79e9a66ce2f2c729b455eaa237f3d2
@@ -0,0 +1 @@
+o oo(){extern oo();}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-6eadb507c9ee93d9500028a9be2d183d1518f26b b/test/cli/fuzz-crash/crash-6eadb507c9ee93d9500028a9be2d183d1518f26b
new file mode 100644
index 00000000000..2c7ce45bc97
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-6eadb507c9ee93d9500028a9be2d183d1518f26b
@@ -0,0 +1 @@
+i a;u n(;a[]),n(){a[]=0}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-772965250be2580c7c52f024c15fd5c8a9bb13c7 b/test/cli/fuzz-crash/crash-772965250be2580c7c52f024c15fd5c8a9bb13c7
new file mode 100644
index 00000000000..a010a5fcfcc
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-772965250be2580c7c52f024c15fd5c8a9bb13c7
@@ -0,0 +1 @@
+enum{C=e;=U};
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-77a4e4ffd476997f06f67e4a18b5d4eedfa71900 b/test/cli/fuzz-crash/crash-77a4e4ffd476997f06f67e4a18b5d4eedfa71900
new file mode 100644
index 00000000000..f0766577f5c
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-77a4e4ffd476997f06f67e4a18b5d4eedfa71900
@@ -0,0 +1 @@
+n i(){t i=0-::-t}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-78bcf47420424bf607f6697cf84ddd84b4dfbeb9 b/test/cli/fuzz-crash/crash-78bcf47420424bf607f6697cf84ddd84b4dfbeb9
new file mode 100644
index 00000000000..89b2cab671d
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-78bcf47420424bf607f6697cf84ddd84b4dfbeb9
@@ -0,0 +1 @@
+assert(a~--)
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-7bac85061edab7fdce2889f02ea3a044242a3920 b/test/cli/fuzz-crash/crash-7bac85061edab7fdce2889f02ea3a044242a3920
new file mode 100644
index 00000000000..d9de20d6e55
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-7bac85061edab7fdce2889f02ea3a044242a3920
@@ -0,0 +1 @@
+a,typedef U typedef,U,i
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-7c3e963c9c28dab506696d0dbe8aaf8772d5302f b/test/cli/fuzz-crash/crash-7c3e963c9c28dab506696d0dbe8aaf8772d5302f
new file mode 100644
index 00000000000..ff8d3a2d0ac
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-7c3e963c9c28dab506696d0dbe8aaf8772d5302f
@@ -0,0 +1 @@
+h>teu<""e<>;template<F=F>teu=d
diff --git a/test/cli/fuzz-crash/crash-7d409757e9b94fc2eb23758b655e056ec3dd9d09 b/test/cli/fuzz-crash/crash-7d409757e9b94fc2eb23758b655e056ec3dd9d09
new file mode 100644
index 00000000000..8b8929bc573
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-7d409757e9b94fc2eb23758b655e056ec3dd9d09
@@ -0,0 +1 @@
+_asm
diff --git a/test/cli/fuzz-crash/crash-7ead2ccf9be8b03b2d9c8c82891f58081390a560 b/test/cli/fuzz-crash/crash-7ead2ccf9be8b03b2d9c8c82891f58081390a560
new file mode 100644
index 00000000000..0de3f6a49b3
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-7ead2ccf9be8b03b2d9c8c82891f58081390a560
@@ -0,0 +1 @@
+n m(){int a[];a=[]}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-81a29a4459dee76d10e452690f3e52fa0172852f b/test/cli/fuzz-crash/crash-81a29a4459dee76d10e452690f3e52fa0172852f
new file mode 100644
index 00000000000..5579544ce3e
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-81a29a4459dee76d10e452690f3e52fa0172852f
@@ -0,0 +1 @@
+{s for(typedef:;){}}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-82986578453ec2056069c70846571775b10dfbcb b/test/cli/fuzz-crash/crash-82986578453ec2056069c70846571775b10dfbcb
new file mode 100644
index 00000000000..d658e27570f
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-82986578453ec2056069c70846571775b10dfbcb
@@ -0,0 +1 @@
+namespace d=S
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-889549c7af3edaaf3e6e6f0783a42f4bcab7167e b/test/cli/fuzz-crash/crash-889549c7af3edaaf3e6e6f0783a42f4bcab7167e
new file mode 100644
index 00000000000..69d0b174b03
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-889549c7af3edaaf3e6e6f0783a42f4bcab7167e
@@ -0,0 +1 @@
+{enum{A=s()0=s};}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-8a24e81ac1d7627233a227e6cc156dd20d57b058 b/test/cli/fuzz-crash/crash-8a24e81ac1d7627233a227e6cc156dd20d57b058
new file mode 100644
index 00000000000..8810b86ac93
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-8a24e81ac1d7627233a227e6cc156dd20d57b058
@@ -0,0 +1 @@
+r*register
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-8b9b108955146efbdae71f7167251da89d1e18c4 b/test/cli/fuzz-crash/crash-8b9b108955146efbdae71f7167251da89d1e18c4
new file mode 100644
index 00000000000..dcf55359979
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-8b9b108955146efbdae71f7167251da89d1e18c4
@@ -0,0 +1 @@
+{enum{A=s(u)0=s};}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-8e34edab2458422d12e1b796686205a80760dbcb b/test/cli/fuzz-crash/crash-8e34edab2458422d12e1b796686205a80760dbcb
new file mode 100644
index 00000000000..581bcb4dae7
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-8e34edab2458422d12e1b796686205a80760dbcb
@@ -0,0 +1 @@
+typedef e*(C)()const C;
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-9054eec11c4eb2cccf3ae02cdc3469fae5f8d9ae b/test/cli/fuzz-crash/crash-9054eec11c4eb2cccf3ae02cdc3469fae5f8d9ae
new file mode 100644
index 00000000000..5a088af4bda
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-9054eec11c4eb2cccf3ae02cdc3469fae5f8d9ae
@@ -0,0 +1 @@
+(c*8s){}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-9a91d3da4e19336af500b94b2405831ed0fc1585 b/test/cli/fuzz-crash/crash-9a91d3da4e19336af500b94b2405831ed0fc1585
new file mode 100644
index 00000000000..fac1475e560
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-9a91d3da4e19336af500b94b2405831ed0fc1585
@@ -0,0 +1 @@
+template<>>a{}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-9e4f80a23bc966f25e874df655f600478dca3b87 b/test/cli/fuzz-crash/crash-9e4f80a23bc966f25e874df655f600478dca3b87
new file mode 100644
index 00000000000..dc5e7b97e16
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-9e4f80a23bc966f25e874df655f600478dca3b87
@@ -0,0 +1 @@
+__thread<>e
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-9eb2c9e545b361a17d74ccd4e8c933ca65542b12 b/test/cli/fuzz-crash/crash-9eb2c9e545b361a17d74ccd4e8c933ca65542b12
new file mode 100644
index 00000000000..8d7829b6343
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-9eb2c9e545b361a17d74ccd4e8c933ca65542b12
@@ -0,0 +1 @@
+{template<>i}template<>fact2(){fact2<3>()}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-9ef938bba7d752386e24f2438c73cec66f6b972b b/test/cli/fuzz-crash/crash-9ef938bba7d752386e24f2438c73cec66f6b972b
new file mode 100644
index 00000000000..57d23881507
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-9ef938bba7d752386e24f2438c73cec66f6b972b
@@ -0,0 +1 @@
+o n(){r<>items;t iter;for(&&){iter=items.g}}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-a03d001b1336e191debffcde652ce5fb63d0a7d6 b/test/cli/fuzz-crash/crash-a03d001b1336e191debffcde652ce5fb63d0a7d6
new file mode 100644
index 00000000000..0a3ef8a3bb2
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-a03d001b1336e191debffcde652ce5fb63d0a7d6
@@ -0,0 +1 @@
+(c[?=3:4])p
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-a3cfaec435c6df0f6c3cfc83f052abd42c75ba4d b/test/cli/fuzz-crash/crash-a3cfaec435c6df0f6c3cfc83f052abd42c75ba4d
new file mode 100644
index 00000000000..e3569504de1
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-a3cfaec435c6df0f6c3cfc83f052abd42c75ba4d
@@ -0,0 +1 @@
+typedef C();typedef const C*(*func2)();d(func2())
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-a431ec7f7379fc460eaa6284627091ded6c0d696 b/test/cli/fuzz-crash/crash-a431ec7f7379fc460eaa6284627091ded6c0d696
new file mode 100644
index 00000000000..ee0a7d32082
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-a431ec7f7379fc460eaa6284627091ded6c0d696
@@ -0,0 +1 @@
+{for(typedef,typedef;);}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-a76710eb5c80761456679c5be64482f1ef332556 b/test/cli/fuzz-crash/crash-a76710eb5c80761456679c5be64482f1ef332556
new file mode 100644
index 00000000000..c819faeb807
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-a76710eb5c80761456679c5be64482f1ef332556
@@ -0,0 +1 @@
+i n(){$ i;f a;for(i:++)a=[]i;}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-adb20a108c3686d79bc9bd0e4025445e3a35fa49 b/test/cli/fuzz-crash/crash-adb20a108c3686d79bc9bd0e4025445e3a35fa49
new file mode 100644
index 00000000000..98e8746abd0
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-adb20a108c3686d79bc9bd0e4025445e3a35fa49
@@ -0,0 +1 @@
+template<#p<>tu< <>tu=e
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-be54fe1da04e7a624214b58f3b572b87082a2e93 b/test/cli/fuzz-crash/crash-be54fe1da04e7a624214b58f3b572b87082a2e93
new file mode 100644
index 00000000000..e263f9d8c66
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-be54fe1da04e7a624214b58f3b572b87082a2e93
@@ -0,0 +1 @@
+(({}namespace d=n));
diff --git a/test/cli/fuzz-crash/crash-c021b973c9f8692ff1ea73710209a4129dc7a834 b/test/cli/fuzz-crash/crash-c021b973c9f8692ff1ea73710209a4129dc7a834
new file mode 100644
index 00000000000..411936bf04e
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-c021b973c9f8692ff1ea73710209a4129dc7a834
@@ -0,0 +1 @@
+typedef const C;C(public C<i)
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-c36b9a5f7fce91031cb578ef591f90d48d95a7f4 b/test/cli/fuzz-crash/crash-c36b9a5f7fce91031cb578ef591f90d48d95a7f4
new file mode 100644
index 00000000000..094721301b9
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-c36b9a5f7fce91031cb578ef591f90d48d95a7f4
@@ -0,0 +1 @@
+c<a<s>s=t,{;{}}>l
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-c540e04fe675639b7ead821efc2f5c037b6c89e0 b/test/cli/fuzz-crash/crash-c540e04fe675639b7ead821efc2f5c037b6c89e0
new file mode 100644
index 00000000000..f2fb80ecd28
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-c540e04fe675639b7ead821efc2f5c037b6c89e0
@@ -0,0 +1 @@
+o o(){i n;for(i x:v)n=n+<1;}
diff --git a/test/cli/fuzz-crash/crash-cb1d71440b24712fdf0bdcee43b9b3f1bc35c0d0 b/test/cli/fuzz-crash/crash-cb1d71440b24712fdf0bdcee43b9b3f1bc35c0d0
new file mode 100644
index 00000000000..37d2ba6564c
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-cb1d71440b24712fdf0bdcee43b9b3f1bc35c0d0
@@ -0,0 +1 @@
+(n@()###);
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-cd91802f0554ab425b82191389c9db2be0d50040 b/test/cli/fuzz-crash/crash-cd91802f0554ab425b82191389c9db2be0d50040
new file mode 100644
index 00000000000..b2a885a35d3
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-cd91802f0554ab425b82191389c9db2be0d50040
@@ -0,0 +1 @@
+{f F<{enum{E=1};}>}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-d6609399a4398aed92f5ac9e53aa0554d9f8bbd6 b/test/cli/fuzz-crash/crash-d6609399a4398aed92f5ac9e53aa0554d9f8bbd6
new file mode 100644
index 00000000000..1563d4c95bd
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-d6609399a4398aed92f5ac9e53aa0554d9f8bbd6
@@ -0,0 +1 @@
+_(){w((char)=e)}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-e000709d155e9c993795748ba31fddacbd5a86ac b/test/cli/fuzz-crash/crash-e000709d155e9c993795748ba31fddacbd5a86ac
new file mode 100644
index 00000000000..6f94840a159
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-e000709d155e9c993795748ba31fddacbd5a86ac
@@ -0,0 +1 @@
+{for(()s)}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-e4a26f2d7d0a73836bf086f54e48204d8914b95a b/test/cli/fuzz-crash/crash-e4a26f2d7d0a73836bf086f54e48204d8914b95a
new file mode 100644
index 00000000000..ba39dbb8588
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-e4a26f2d7d0a73836bf086f54e48204d8914b95a
@@ -0,0 +1 @@
+t i(){for(;;f&++)}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-e6c12e56d9711d24fc9a4355e7d35fc23fbf0ff4 b/test/cli/fuzz-crash/crash-e6c12e56d9711d24fc9a4355e7d35fc23fbf0ff4
new file mode 100644
index 00000000000..7249082ff90
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-e6c12e56d9711d24fc9a4355e7d35fc23fbf0ff4
@@ -0,0 +1 @@
+struct B{o a;B<>{0,{}}}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-ee5250480d7bc4bed7520d96a50d8501632a8997 b/test/cli/fuzz-crash/crash-ee5250480d7bc4bed7520d96a50d8501632a8997
new file mode 100644
index 00000000000..55f38493a42
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-ee5250480d7bc4bed7520d96a50d8501632a8997
@@ -0,0 +1 @@
+$(){using}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-ef635709a2489083534cd422e6a089daab23ec64 b/test/cli/fuzz-crash/crash-ef635709a2489083534cd422e6a089daab23ec64
new file mode 100644
index 00000000000..6274e3a27a1
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-ef635709a2489083534cd422e6a089daab23ec64
@@ -0,0 +1 @@
+#pragma asm
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-f158d32510f6eba5e1aa06ed8ef689b88da33a95 b/test/cli/fuzz-crash/crash-f158d32510f6eba5e1aa06ed8ef689b88da33a95
new file mode 100644
index 00000000000..52272b364ea
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-f158d32510f6eba5e1aa06ed8ef689b88da33a95
@@ -0,0 +1 @@
+enum{a=1{}=d};
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-f4ec019b9a1f357d036a9bc3c2cb6fb10a0c3ded b/test/cli/fuzz-crash/crash-f4ec019b9a1f357d036a9bc3c2cb6fb10a0c3ded
new file mode 100644
index 00000000000..7f948841a94
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-f4ec019b9a1f357d036a9bc3c2cb6fb10a0c3ded
@@ -0,0 +1 @@
+o k(){t*data;{memcpy(data,,sizeof\)}}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-faa56134676fb5d021ad69c8ac526d65debcfdb1 b/test/cli/fuzz-crash/crash-faa56134676fb5d021ad69c8ac526d65debcfdb1
new file mode 100644
index 00000000000..26613dccc82
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-faa56134676fb5d021ad69c8ac526d65debcfdb1
@@ -0,0 +1 @@
+{for(typedef U typedef{};);}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash/crash-fb09b3314f55a502c8dd27f3f114122c71dd207e b/test/cli/fuzz-crash/crash-fb09b3314f55a502c8dd27f3f114122c71dd207e
new file mode 100644
index 00000000000..3a017fdb2e0
--- /dev/null
+++ b/test/cli/fuzz-crash/crash-fb09b3314f55a502c8dd27f3f114122c71dd207e
@@ -0,0 +1 @@
+;namespace b=i;;namespace b={}
diff --git a/test/cli/fuzz-crash/leak-9543188fae87abc4409106e1918d6424efe0d68a b/test/cli/fuzz-crash/leak-9543188fae87abc4409106e1918d6424efe0d68a
new file mode 100644
index 00000000000..58448756115
--- /dev/null
+++ b/test/cli/fuzz-crash/leak-9543188fae87abc4409106e1918d6424efe0d68a
@@ -0,0 +1 @@
+v f(*){e=t&&}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash_c/crash-18b7d7437e79f7e1b843b676e0c3beaf4929d043 b/test/cli/fuzz-crash_c/crash-18b7d7437e79f7e1b843b676e0c3beaf4929d043
new file mode 100644
index 00000000000..6a015200e02
--- /dev/null
+++ b/test/cli/fuzz-crash_c/crash-18b7d7437e79f7e1b843b676e0c3beaf4929d043
@@ -0,0 +1 @@
+v(){p?1:p..}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash_c/crash-24c217c96d177b8dff4028bce639756d6a8c6088 b/test/cli/fuzz-crash_c/crash-24c217c96d177b8dff4028bce639756d6a8c6088
new file mode 100644
index 00000000000..161962b6fe4
--- /dev/null
+++ b/test/cli/fuzz-crash_c/crash-24c217c96d177b8dff4028bce639756d6a8c6088
@@ -0,0 +1 @@
+f(S=n){n*,n&&}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash_c/crash-493bda132c00d17406b5e661e034867029a1fac1 b/test/cli/fuzz-crash_c/crash-493bda132c00d17406b5e661e034867029a1fac1
new file mode 100644
index 00000000000..1cff3b66c8d
--- /dev/null
+++ b/test/cli/fuzz-crash_c/crash-493bda132c00d17406b5e661e034867029a1fac1
@@ -0,0 +1 @@
+v(){union{a i;for(i=0;!i;);};}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash_c/crash-77c74a5f04704110ab5f71b753a623f2d28440bc b/test/cli/fuzz-crash_c/crash-77c74a5f04704110ab5f71b753a623f2d28440bc
new file mode 100644
index 00000000000..b00cf975b74
--- /dev/null
+++ b/test/cli/fuzz-crash_c/crash-77c74a5f04704110ab5f71b753a623f2d28440bc
@@ -0,0 +1 @@
+class r::_
\ No newline at end of file
diff --git a/test/cli/fuzz-crash_c/crash-7af21bec1d9be105742fdcb336514aae26ab4425 b/test/cli/fuzz-crash_c/crash-7af21bec1d9be105742fdcb336514aae26ab4425
new file mode 100644
index 00000000000..6620c0d315f
--- /dev/null
+++ b/test/cli/fuzz-crash_c/crash-7af21bec1d9be105742fdcb336514aae26ab4425
@@ -0,0 +1,2 @@
+i
+class q::_
\ No newline at end of file
diff --git a/test/cli/fuzz-crash_c/crash-8367ada820697bc89f56262df59bdf457b62c808 b/test/cli/fuzz-crash_c/crash-8367ada820697bc89f56262df59bdf457b62c808
new file mode 100644
index 00000000000..08345550d64
--- /dev/null
+++ b/test/cli/fuzz-crash_c/crash-8367ada820697bc89f56262df59bdf457b62c808
@@ -0,0 +1 @@
+i(){s a;for(;;)y{for(;;);};}
diff --git a/test/cli/fuzz-crash_c/crash-85219ec46607233cec457b54a209ded59c333f46 b/test/cli/fuzz-crash_c/crash-85219ec46607233cec457b54a209ded59c333f46
new file mode 100644
index 00000000000..54d804c62d4
--- /dev/null
+++ b/test/cli/fuzz-crash_c/crash-85219ec46607233cec457b54a209ded59c333f46
@@ -0,0 +1 @@
+n(){o?5:t++m}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash_c/crash-bbf4e88b43fa24873e63d39ab04ef8d3fd00e344 b/test/cli/fuzz-crash_c/crash-bbf4e88b43fa24873e63d39ab04ef8d3fd00e344
new file mode 100644
index 00000000000..e9da81bd248
--- /dev/null
+++ b/test/cli/fuzz-crash_c/crash-bbf4e88b43fa24873e63d39ab04ef8d3fd00e344
@@ -0,0 +1 @@
+f(){int a[5];memset(a,5)}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash_c/crash-c43160a021f72643e229bb61306240d0dbf2c9bd b/test/cli/fuzz-crash_c/crash-c43160a021f72643e229bb61306240d0dbf2c9bd
new file mode 100644
index 00000000000..92c19cc05b5
--- /dev/null
+++ b/test/cli/fuzz-crash_c/crash-c43160a021f72643e229bb61306240d0dbf2c9bd
@@ -0,0 +1 @@
+f(a b){do{if(b){}}while(e)x}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash_c/crash-dbd2b8fcc4fecd0b7bdde1f5938711075a35d242 b/test/cli/fuzz-crash_c/crash-dbd2b8fcc4fecd0b7bdde1f5938711075a35d242
new file mode 100644
index 00000000000..3cabdd2f6fc
--- /dev/null
+++ b/test/cli/fuzz-crash_c/crash-dbd2b8fcc4fecd0b7bdde1f5938711075a35d242
@@ -0,0 +1 @@
+{assert({f=a})}
\ No newline at end of file
diff --git a/test/cli/fuzz-crash_c/crash-dd1289f81f5aaf90167595c5402e6cda2be505be b/test/cli/fuzz-crash_c/crash-dd1289f81f5aaf90167595c5402e6cda2be505be
new file mode 100644
index 00000000000..056f4456bfd
--- /dev/null
+++ b/test/cli/fuzz-crash_c/crash-dd1289f81f5aaf90167595c5402e6cda2be505be
@@ -0,0 +1 @@
+d(){A a;n=do{}while(N)t}
\ No newline at end of file
diff --git a/test/cli/fuzz-timeout/minimized-from-179e5b42a7b0ba41a088e7972bdb13dde18ef4d1 b/test/cli/fuzz-timeout/minimized-from-179e5b42a7b0ba41a088e7972bdb13dde18ef4d1
new file mode 100644
index 00000000000..9118d58da24
--- /dev/null
+++ b/test/cli/fuzz-timeout/minimized-from-179e5b42a7b0ba41a088e7972bdb13dde18ef4d1
@@ -0,0 +1 @@
+d f(*){*:b&&}
\ No newline at end of file
diff --git a/test/cli/fuzz-timeout/oom-0c8e70d5adb08986635b786737dbb5e6ac098f22 b/test/cli/fuzz-timeout/oom-0c8e70d5adb08986635b786737dbb5e6ac098f22
new file mode 100644
index 00000000000..54d37965b04
--- /dev/null
+++ b/test/cli/fuzz-timeout/oom-0c8e70d5adb08986635b786737dbb5e6ac098f22
@@ -0,0 +1 @@
+template<8<>e=e<>>f
\ No newline at end of file
diff --git a/test/cli/fuzz-timeout/oom-756ab636471bffa2430290f58776f1f6d8754ab1 b/test/cli/fuzz-timeout/oom-756ab636471bffa2430290f58776f1f6d8754ab1
new file mode 100644
index 00000000000..a945de7b7c4
--- /dev/null
+++ b/test/cli/fuzz-timeout/oom-756ab636471bffa2430290f58776f1f6d8754ab1
@@ -0,0 +1 @@
+template< <>t=t<>>d
\ No newline at end of file
diff --git a/test/cli/fuzz-timeout/oom-e19261c78d73cf172308f6c33df68642dfd7b679 b/test/cli/fuzz-timeout/oom-e19261c78d73cf172308f6c33df68642dfd7b679
new file mode 100644
index 00000000000..f0d2b9c00b2
--- /dev/null
+++ b/test/cli/fuzz-timeout/oom-e19261c78d73cf172308f6c33df68642dfd7b679
@@ -0,0 +1 @@
+template<~>tu<2>tu=<tu<0&tu<0&n
\ No newline at end of file
diff --git a/test/cli/fuzz-timeout/timeout-0ee5eed9abd34e9d23640a5b82dd724affd05b79 b/test/cli/fuzz-timeout/timeout-0ee5eed9abd34e9d23640a5b82dd724affd05b79
new file mode 100644
index 00000000000..5f9465da55e
--- /dev/null
+++ b/test/cli/fuzz-timeout/timeout-0ee5eed9abd34e9d23640a5b82dd724affd05b79
@@ -0,0 +1 @@
+;new t()
\ No newline at end of file
diff --git a/test/cli/fuzz-timeout/timeout-7795aa299fc0c2bafe3a152785d55b039d4f339c b/test/cli/fuzz-timeout/timeout-7795aa299fc0c2bafe3a152785d55b039d4f339c
new file mode 100644
index 00000000000..579dddd02b3
--- /dev/null
+++ b/test/cli/fuzz-timeout/timeout-7795aa299fc0c2bafe3a152785d55b039d4f339c
@@ -0,0 +1 @@
+ e<>(){F+0+0+++++++++++++++++++++++++++++++++++++++++5;}
\ No newline at end of file
diff --git a/test/cli/fuzz-timeout/timeout-8229bbbfcf6f3ab98a6c23bfb1421ffd611c3657 b/test/cli/fuzz-timeout/timeout-8229bbbfcf6f3ab98a6c23bfb1421ffd611c3657
new file mode 100644
index 00000000000..685ac840459
--- /dev/null
+++ b/test/cli/fuzz-timeout/timeout-8229bbbfcf6f3ab98a6c23bfb1421ffd611c3657
@@ -0,0 +1,8 @@
+int bhar()
+{
+    int a[2];
+    ift i;  
+    for (i = 0; i < 3; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^~^^^^^^^^^^^^^^^^^^&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&size_t^^^^^^^^^^^^^^^^^^i++)
+        a[i] = 1;
+    rewurn a[0];
+}
diff --git a/test/cli/fuzz-timeout/timeout-90ec15c5629f957bf2d497bc9f60c57f252bd2ae b/test/cli/fuzz-timeout/timeout-90ec15c5629f957bf2d497bc9f60c57f252bd2ae
new file mode 100644
index 00000000000..23ac243e4ab
--- /dev/null
+++ b/test/cli/fuzz-timeout/timeout-90ec15c5629f957bf2d497bc9f60c57f252bd2ae
@@ -0,0 +1 @@
+ ama typedef f  m ef ef dz e dz e e ef   ef  m ef dz e,,,,m  ef dz e,,,,,K 
\ No newline at end of file
diff --git a/test/cli/fuzz-timeout/timeout-9598595ae3c480b58773e85cd4e4d52b1dc37038 b/test/cli/fuzz-timeout/timeout-9598595ae3c480b58773e85cd4e4d52b1dc37038
new file mode 100644
index 00000000000..1fb47f839a8
--- /dev/null
+++ b/test/cli/fuzz-timeout/timeout-9598595ae3c480b58773e85cd4e4d52b1dc37038
@@ -0,0 +1 @@
+i f(n*a){n b=0;*a=b;%*a=b;--------------------b}
\ No newline at end of file
diff --git a/test/cli/fuzz-timeout/timeout-98121de84d1c09fdfd3697cdedcdd69bf6abc15d b/test/cli/fuzz-timeout/timeout-98121de84d1c09fdfd3697cdedcdd69bf6abc15d
new file mode 100644
index 00000000000..aad51f01fe5
--- /dev/null
+++ b/test/cli/fuzz-timeout/timeout-98121de84d1c09fdfd3697cdedcdd69bf6abc15d
@@ -0,0 +1 @@
+typedef static i i,n.i
\ No newline at end of file
diff --git a/test/cli/fuzz-timeout/timeout-a0b9848dd6e98677a0a96c5fc50ad571ed5a7092 b/test/cli/fuzz-timeout/timeout-a0b9848dd6e98677a0a96c5fc50ad571ed5a7092
new file mode 100644
index 00000000000..2f29da2e360
--- /dev/null
+++ b/test/cli/fuzz-timeout/timeout-a0b9848dd6e98677a0a96c5fc50ad571ed5a7092
@@ -0,0 +1,2 @@
+t i(){int
+t,?:0::::}
\ No newline at end of file
diff --git a/test/cli/fuzz-timeout/timeout-faa72062ab3f26df7305d72eed55a69f7f0dfbf0 b/test/cli/fuzz-timeout/timeout-faa72062ab3f26df7305d72eed55a69f7f0dfbf0
new file mode 100644
index 00000000000..f2a7a35935a
--- /dev/null
+++ b/test/cli/fuzz-timeout/timeout-faa72062ab3f26df7305d72eed55a69f7f0dfbf0
@@ -0,0 +1 @@
+typedef q k k k q,q k,q,k,q,k,q k,q,k,q,k,;
\ No newline at end of file
diff --git a/test/cli/fuzz_test.py b/test/cli/fuzz_test.py
new file mode 100644
index 00000000000..f1dbcd2983e
--- /dev/null
+++ b/test/cli/fuzz_test.py
@@ -0,0 +1,46 @@
+import os
+import subprocess
+
+from testutils import cppcheck
+
+__script_dir = os.path.dirname(os.path.abspath(__file__))
+
+
+def test_fuzz_crash():
+    failures = {}
+
+    fuzz_crash_dir = os.path.join(__script_dir, 'fuzz-crash')
+    for f in os.listdir(fuzz_crash_dir):
+        ret, stdout, stderr = cppcheck(['-q', '--language=c++', '--enable=all', '--inconclusive', f], cwd=fuzz_crash_dir)
+        if ret != 0:
+            failures[f] = stdout + stderr
+
+    assert failures == {}
+
+
+def test_fuzz_crash_c():
+    failures = {}
+
+    fuzz_crash_dir = os.path.join(__script_dir, 'fuzz-crash_c')
+    # TODO: remove check if we have test data
+    if not os.path.exists(fuzz_crash_dir):
+        return
+    for f in os.listdir(fuzz_crash_dir):
+        ret, stdout, stderr = cppcheck(['-q', '--language=c', '--enable=all', '--inconclusive', f], cwd=fuzz_crash_dir)
+        if ret != 0:
+            failures[f] = stdout + stderr
+
+    assert failures == {}
+
+
+def test_fuzz_timeout():
+    failures = []
+
+    fuzz_timeout_dir = os.path.join(__script_dir, 'fuzz-timeout')
+    for f in os.listdir(fuzz_timeout_dir):
+        try:
+            cppcheck(['-q', '--language=c++', '--enable=all', '--inconclusive', f], cwd=fuzz_timeout_dir, timeout=5)
+        except subprocess.TimeoutExpired:
+            failures.append(f)
+
+    assert failures == []
diff --git a/test/cli/helloworld/helloworld.sln b/test/cli/helloworld/helloworld.sln
index 679d073e4e8..0ac036b35d4 100644
--- a/test/cli/helloworld/helloworld.sln
+++ b/test/cli/helloworld/helloworld.sln
@@ -1,31 +1,31 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.27130.2027
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "helloworld", "helloworld.vcxproj", "{7319858B-261C-4F0D-B022-92BB896242DD}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|x64 = Debug|x64
-		Debug|x86 = Debug|x86
-		Release|x64 = Release|x64
-		Release|x86 = Release|x86
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{7319858B-261C-4F0D-B022-92BB896242DD}.Debug|x64.ActiveCfg = Debug|x64
-		{7319858B-261C-4F0D-B022-92BB896242DD}.Debug|x64.Build.0 = Debug|x64
-		{7319858B-261C-4F0D-B022-92BB896242DD}.Debug|x86.ActiveCfg = Debug|Win32
-		{7319858B-261C-4F0D-B022-92BB896242DD}.Debug|x86.Build.0 = Debug|Win32
-		{7319858B-261C-4F0D-B022-92BB896242DD}.Release|x64.ActiveCfg = Release|x64
-		{7319858B-261C-4F0D-B022-92BB896242DD}.Release|x64.Build.0 = Release|x64
-		{7319858B-261C-4F0D-B022-92BB896242DD}.Release|x86.ActiveCfg = Release|Win32
-		{7319858B-261C-4F0D-B022-92BB896242DD}.Release|x86.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {C787A78A-D377-4103-9389-2594C573ED55}
-	EndGlobalSection
-EndGlobal
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 15
+VisualStudioVersion = 15.0.27130.2027
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "helloworld", "helloworld.vcxproj", "{7319858B-261C-4F0D-B022-92BB896242DD}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{7319858B-261C-4F0D-B022-92BB896242DD}.Debug|x64.ActiveCfg = Debug|x64
+		{7319858B-261C-4F0D-B022-92BB896242DD}.Debug|x64.Build.0 = Debug|x64
+		{7319858B-261C-4F0D-B022-92BB896242DD}.Debug|x86.ActiveCfg = Debug|Win32
+		{7319858B-261C-4F0D-B022-92BB896242DD}.Debug|x86.Build.0 = Debug|Win32
+		{7319858B-261C-4F0D-B022-92BB896242DD}.Release|x64.ActiveCfg = Release|x64
+		{7319858B-261C-4F0D-B022-92BB896242DD}.Release|x64.Build.0 = Release|x64
+		{7319858B-261C-4F0D-B022-92BB896242DD}.Release|x86.ActiveCfg = Release|Win32
+		{7319858B-261C-4F0D-B022-92BB896242DD}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {C787A78A-D377-4103-9389-2594C573ED55}
+	EndGlobalSection
+EndGlobal
diff --git a/test/cli/helloworld/helloworld.vcxproj b/test/cli/helloworld/helloworld.vcxproj
index e65715e1729..170e34ef855 100644
--- a/test/cli/helloworld/helloworld.vcxproj
+++ b/test/cli/helloworld/helloworld.vcxproj
@@ -1,123 +1,123 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <VCProjectVersion>15.0</VCProjectVersion>
-    <ProjectGuid>{7319858B-261C-4F0D-B022-92BB896242DD}</ProjectGuid>
-    <RootNamespace>helloworld</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0.16299.0</WindowsTargetPlatformVersion>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
-    <CharacterSet>MultiByte</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>MultiByte</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
-    <CharacterSet>MultiByte</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>MultiByte</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="Shared">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup />
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <SDLCheck>true</SDLCheck>
-      <ConformanceMode>true</ConformanceMode>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <SDLCheck>true</SDLCheck>
-      <ConformanceMode>true</ConformanceMode>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>true</SDLCheck>
-      <ConformanceMode>true</ConformanceMode>
-    </ClCompile>
-    <Link>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>true</SDLCheck>
-      <ConformanceMode>true</ConformanceMode>
-    </ClCompile>
-    <Link>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClCompile Include="main.c" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{7319858B-261C-4F0D-B022-92BB896242DD}</ProjectGuid>
+    <RootNamespace>helloworld</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0.16299.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="main.c" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
 </Project>
\ No newline at end of file
diff --git a/test/cli/helloworld/main.c b/test/cli/helloworld/main.c
index f2518a3efc5..c5b94db7aa0 100644
--- a/test/cli/helloworld/main.c
+++ b/test/cli/helloworld/main.c
@@ -1,8 +1,11 @@
 #include <stdio.h>
 
-int main() {
+int main(void) {
     (void)printf("Hello world!\n");
-    x = 3 / 0; // ERROR
+    int x = 3 / 0; (void)x; // ERROR
     return 0;
 }
 
+#ifdef SOME_CONFIG
+void foo();
+#endif
diff --git a/test/cli/helloworld_test.py b/test/cli/helloworld_test.py
new file mode 100644
index 00000000000..7ccc113af43
--- /dev/null
+++ b/test/cli/helloworld_test.py
@@ -0,0 +1,394 @@
+
+# python -m pytest test-helloworld.py
+
+import os
+import re
+import glob
+import json
+import shutil
+import xml.etree.ElementTree as ET
+
+import pytest
+
+from testutils import create_gui_project_file, cppcheck
+
+__script_dir = os.path.dirname(os.path.abspath(__file__))
+__proj_dir = os.path.join(__script_dir, 'helloworld')
+
+
+# Get Visual Studio configurations checking a file
+# Checking {file} {config}...
+def __getVsConfigs(stdout, filename):
+    ret = []
+    for line in stdout.split('\n'):
+        if not line.startswith('Checking %s ' % filename):
+            continue
+        if not line.endswith('...'):
+            continue
+        res = re.match(r'.* ([A-Za-z0-9|]+)...', line)
+        if res:
+            ret.append(res.group(1))
+    ret.sort()
+    return ' '.join(ret)
+
+def test_relative_path():
+    args = [
+        '--template=cppcheck1',
+        'helloworld'
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    filename = os.path.join('helloworld', 'main.c')
+    assert ret == 0, stdout
+    assert stderr == '[%s:5]: (error) Division by zero.\n' % filename
+
+
+def test_local_path():
+    args = [
+        '--template=cppcheck1',
+        '.'
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__proj_dir)
+    assert ret == 0, stdout
+    assert stderr == '[main.c:5]: (error) Division by zero.\n'
+
+def test_absolute_path():
+    args = [
+        '--template=cppcheck1',
+        __proj_dir
+    ]
+    ret, stdout, stderr = cppcheck(args)
+    filename = os.path.join(__proj_dir, 'main.c')
+    assert ret == 0, stdout
+    assert stderr == '[%s:5]: (error) Division by zero.\n' % filename
+
+def test_addon_local_path():
+    args = [
+        '--addon=misra',
+        '--enable=style',
+        '--template=cppcheck1',
+        '.'
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__proj_dir)
+    assert ret == 0, stdout
+    assert stderr == ('[main.c:5]: (error) Division by zero.\n'
+                      '[main.c:4]: (style) misra violation (use --rule-texts=<file> to get proper output)\n')
+
+def test_addon_local_path_not_enable():
+    args = [
+        '--addon=misra',
+        '--template=cppcheck1',
+        '.'
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__proj_dir)
+    assert ret == 0, stdout
+    assert stderr == '[main.c:5]: (error) Division by zero.\n'
+
+def test_addon_absolute_path():
+    args = [
+        '--addon=misra',
+        '--enable=style',
+        '--template=cppcheck1',
+        __proj_dir
+    ]
+    ret, stdout, stderr = cppcheck(args)
+    filename = os.path.join(__proj_dir, 'main.c')
+    assert ret == 0, stdout
+    assert stderr == ('[%s:5]: (error) Division by zero.\n'
+                      '[%s:4]: (style) misra violation (use --rule-texts=<file> to get proper output)\n' % (filename, filename))
+
+def test_addon_relative_path():
+    args = [
+        '--addon=misra',
+        '--enable=style',
+        '--template=cppcheck1',
+        'helloworld'
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    filename = os.path.join('helloworld', 'main.c')
+    assert ret == 0, stdout
+    assert stdout == ('Checking %s ...\n'
+                      'Checking %s: SOME_CONFIG=SOME_CONFIG...\n' % (filename, filename))
+    assert stderr == ('[%s:5]: (error) Division by zero.\n'
+                      '[%s:4]: (style) misra violation (use --rule-texts=<file> to get proper output)\n' % (filename, filename))
+
+def test_addon_with_gui_project(tmp_path):
+    shutil.copytree(os.path.join(__script_dir, 'helloworld'), tmp_path / 'helloworld')
+    project_file = os.path.join('helloworld', 'test.cppcheck')
+    create_gui_project_file(tmp_path / project_file, paths=['.'], addon='misra')
+    args = [
+        '--template=cppcheck1',
+        '--enable=style',
+        '--project={}'.format(project_file)
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=tmp_path)
+    filename = os.path.join('helloworld', 'main.c')
+    assert ret == 0, stdout
+    assert stdout.strip().split('\n') == [
+        'Checking %s ...' % filename,
+        'Checking %s: SOME_CONFIG=SOME_CONFIG...' % filename
+    ]
+    assert stderr == ('[%s:5]: (error) Division by zero.\n'
+                      '[%s:4]: (style) misra violation (use --rule-texts=<file> to get proper output)\n' % (filename, filename))
+
+def test_basepath_relative_path():
+    args = [
+        'helloworld',
+        '--template=cppcheck1',
+        '-rp=helloworld'
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    assert ret == 0, stdout
+    assert stderr == '[main.c:5]: (error) Division by zero.\n'
+
+def test_basepath_absolute_path():
+    args = [
+        '--template=cppcheck1',
+        __proj_dir,
+        '-rp=' + __proj_dir
+    ]
+    ret, stdout, stderr = cppcheck(args)
+    assert ret == 0, stdout
+    assert stderr == '[main.c:5]: (error) Division by zero.\n'
+
+def __test_vs_project_local_path(extra_args=None, exp_vs_cfg='Debug|Win32 Debug|x64 Release|Win32 Release|x64'):
+    args = [
+        '--template=cppcheck1',
+        '--project=helloworld.vcxproj'
+    ]
+    if extra_args:
+        args += extra_args
+    ret, stdout, stderr = cppcheck(args, cwd=__proj_dir)
+    assert ret == 0, stdout
+    assert __getVsConfigs(stdout, 'main.c') == exp_vs_cfg
+    assert stderr == '[main.c:5]: (error) Division by zero.\n'
+
+def test_vs_project_local_path():
+    __test_vs_project_local_path()
+
+def test_vs_project_local_path_select_one():
+    __test_vs_project_local_path(['--project-configuration=Release|Win32'], 'Release|Win32')
+
+def test_vs_project_local_path_select_one_multiple():
+    __test_vs_project_local_path(['--project-configuration=Debug|Win32', '--project-configuration=Release|Win32'], 'Release|Win32')
+
+def test_vs_project_local_path_no_analyze_all():
+    __test_vs_project_local_path(['--no-analyze-all-vs-configs'], 'Debug|Win32')
+
+def test_vs_project_relative_path():
+    args = [
+        '--template=cppcheck1',
+        '--project=' + os.path.join(__proj_dir, 'helloworld.vcxproj')
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    filename = os.path.join(__proj_dir, 'main.c')
+    assert ret == 0, stdout
+    assert __getVsConfigs(stdout, filename) == 'Debug|Win32 Debug|x64 Release|Win32 Release|x64'
+    assert stderr == '[%s:5]: (error) Division by zero.\n' % filename
+
+def test_vs_project_absolute_path():
+    args = [
+        '--template=cppcheck1',
+        '--project=' + os.path.join(__proj_dir, 'helloworld.vcxproj')
+    ]
+    ret, stdout, stderr = cppcheck(args)
+    filename = os.path.join(__proj_dir, 'main.c')
+    assert ret == 0, stdout
+    assert __getVsConfigs(stdout, filename) == 'Debug|Win32 Debug|x64 Release|Win32 Release|x64'
+    assert stderr == '[%s:5]: (error) Division by zero.\n' % filename
+
+def __test_cppcheck_project_local_path(extra_args=None, exp_vs_cfg='Debug|x64'):
+    args = [
+        '--template=cppcheck1',
+        '--platform=win64',
+        '--project=helloworld.cppcheck'
+    ]
+    if extra_args:
+        args += extra_args
+    ret, stdout, stderr = cppcheck(args, cwd=__proj_dir)
+    assert ret == 0, stdout
+    assert __getVsConfigs(stdout, 'main.c') == exp_vs_cfg
+    assert stderr == '[main.c:5]: (error) Division by zero.\n'
+
+def test_cppcheck_project_local_path():
+    __test_cppcheck_project_local_path()
+
+@pytest.mark.xfail  # TODO: no source files found
+def test_cppcheck_project_local_path_select_one():
+    __test_cppcheck_project_local_path(['--project-configuration=Release|Win32'], 'Release|Win32')
+
+@pytest.mark.xfail  # TODO: no source files found
+def test_cppcheck_project_local_path_select_one_multiple():
+    __test_cppcheck_project_local_path(['--project-configuration=Debug|Win32', '--project-configuration=Release|Win32'], 'Release|Win32')
+
+def test_cppcheck_project_local_path_analyze_all():
+    __test_cppcheck_project_local_path(['--analyze-all-vs-configs'], 'Debug|Win32 Debug|x64 Release|Win32 Release|x64')
+
+def test_cppcheck_project_relative_path():
+    args = [
+        '--template=cppcheck1',
+        '--platform=win64',
+        '--project=' + os.path.join('helloworld', 'helloworld.cppcheck')
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    filename = os.path.join('helloworld', 'main.c')
+    assert ret == 0, stdout
+    assert __getVsConfigs(stdout, filename) == 'Debug|x64'
+    assert stderr == '[%s:5]: (error) Division by zero.\n' % filename
+
+def test_cppcheck_project_absolute_path():
+    args = [
+        '--template=cppcheck1',
+        '--platform=win64',
+        '--project=' + os.path.join(__proj_dir, 'helloworld.cppcheck')
+    ]
+    ret, stdout, stderr = cppcheck(args)
+    filename = os.path.join(__proj_dir, 'main.c')
+    assert ret == 0, stdout
+    assert __getVsConfigs(stdout, filename) == 'Debug|x64'
+    assert stderr == '[%s:5]: (error) Division by zero.\n' % filename
+
+def test_suppress_command_line_related():
+    args = [
+        '--suppress=zerodiv:' + os.path.join('helloworld', 'main.c'),
+        'helloworld'
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    assert ret == 0, stdout
+    assert stderr == ''
+
+def test_suppress_command_line_absolute():
+    args = [
+        '--suppress=zerodiv:' + os.path.join(__proj_dir, 'main.c'),
+        __proj_dir
+    ]
+    ret, stdout, stderr = cppcheck(args)
+    assert ret == 0, stdout
+    assert stderr == ''
+
+def test_suppress_project_relative(tmp_path):
+    shutil.copytree(os.path.join(__script_dir, 'helloworld'), tmp_path / 'helloworld')
+    project_file = os.path.join('helloworld', 'test.cppcheck')
+    create_gui_project_file(tmp_path / project_file,
+                            paths=['.'],
+                            suppressions=[{'fileName':'main.c', 'id':'zerodiv'}])
+
+    args = [
+        '--project={}'.format(project_file)
+    ]
+
+    ret, stdout, stderr = cppcheck(args, cwd=tmp_path)
+    assert ret == 0, stdout
+    assert stderr == ''
+
+
+def test_suppress_project_absolute(tmp_path):
+    shutil.copytree(os.path.join(__script_dir, 'helloworld'), tmp_path / 'helloworld')
+    project_file = tmp_path / 'helloworld' / 'test.cppcheck'
+    create_gui_project_file(project_file,
+                            paths=['.'],
+                            suppressions=[{'fileName':'main.c', 'id':'zerodiv'}])
+
+    args = [
+        '--project={}'.format(project_file)
+    ]
+
+    ret, stdout, stderr = cppcheck(args)
+    assert ret == 0, stdout
+    assert stderr == ''
+
+def test_exclude():
+    args = [
+        '-i' + 'helloworld',
+        '--platform=win64',
+        '--project=' + os.path.join('helloworld', 'helloworld.cppcheck')
+    ]
+    ret, stdout, _ = cppcheck(args, cwd=__script_dir)
+    assert ret == 1
+    lines = stdout.splitlines()
+    assert lines == [
+        'cppcheck: error: no C or C++ source files found.',
+        'cppcheck: all paths were ignored'
+    ]
+
+
+def test_build_dir_dump_output(tmpdir):
+    args = [
+        f'--cppcheck-build-dir={tmpdir}',
+        '--addon=misra',
+        'helloworld'
+    ]
+
+    cppcheck(args)
+    cppcheck(args)
+
+    filename = f'{tmpdir}/main.a1.*.dump'
+    filelist = glob.glob(filename)
+    assert(len(filelist) == 0)
+
+
+def test_checkers_report(tmpdir):
+    filename = os.path.join(tmpdir, '1.txt')
+    args = [
+        f'--checkers-report={filename}',
+        '--no-cppcheck-build-dir',  # TODO: remove this
+        'helloworld'
+    ]
+
+    cppcheck(args, cwd=__script_dir)
+
+    with open(filename, 'rt') as f:
+        data = f.read().splitlines()
+        assert 'No   CheckAutoVariables::assignFunctionArg                     require:style,warning' in data, json.dumps(data, indent=4)
+        assert 'Yes  CheckAutoVariables::autoVariables' in data, json.dumps(data, indent=4)
+
+    args += [
+        '--enable=style'
+    ]
+    cppcheck(args, cwd=__script_dir)
+    with open(filename, 'rt') as f:
+        data = f.read().splitlines()
+        # checker has been activated by --enable=style
+        assert 'Yes  CheckAutoVariables::assignFunctionArg' in data, json.dumps(data, indent=4)
+
+
+def test_missing_include_system():  # #11283
+    args = [
+        '--enable=missingInclude',
+        '--suppress=zerodiv',
+        '--template=simple',
+        'helloworld'
+    ]
+
+    _, _, stderr = cppcheck(args, cwd=__script_dir)
+    assert stderr.replace('\\', '/') == 'helloworld/main.c:1:2: information: Include file: <stdio.h> not found. Please note: Standard library headers do not need to be provided to get proper results. [missingIncludeSystem]\n'
+
+
+def test_sarif():
+    args = [
+        '--output-format=sarif',
+        'helloworld'
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    assert ret == 0, stdout
+    res = json.loads(stderr)
+    assert res['version'] == '2.1.0'
+    assert res['runs'][0]['results'][0]['locations'][0]['physicalLocation']['artifactLocation']['uri'] == 'helloworld/main.c'
+    assert res['runs'][0]['results'][0]['ruleId'] == 'zerodiv'
+    assert res['runs'][0]['tool']['driver']['rules'][0]['id'] == 'zerodiv'
+    assert res['runs'][0]['tool']['driver']['rules'][0]['properties']['precision'] == 'high'
+    assert res['runs'][0]['tool']['driver']['rules'][0]['properties']['security-severity'] == '9.9'
+    assert 'security' in res['runs'][0]['tool']['driver']['rules'][0]['properties']['tags']
+    assert re.match(r'[0-9]+(.[0-9]+)+', res['runs'][0]['tool']['driver']['semanticVersion'])
+    assert 'level' in res['runs'][0]['tool']['driver']['rules'][0]['defaultConfiguration'] # #13885
+    assert res['runs'][0]['tool']['driver']['rules'][0]['shortDescription']['text'] == ''
+    assert res['runs'][0]['results'][0]['message']['text'] == 'Division by zero.'
+    assert res['runs'][0]['tool']['driver']['rules'][0]['properties']['problem.severity'] == 'error'
+
+
+def test_xml_checkers_report():
+    test_file = os.path.join(__proj_dir, 'main.c')
+    args = ['--xml-version=3', '--enable=all', test_file]
+
+    exitcode, _, stderr = cppcheck(args)
+    assert exitcode == 0
+    assert ET.fromstring(stderr) is not None
diff --git a/test/cli/inline-suppress-polyspace_test.py b/test/cli/inline-suppress-polyspace_test.py
new file mode 100644
index 00000000000..889bf231ef3
--- /dev/null
+++ b/test/cli/inline-suppress-polyspace_test.py
@@ -0,0 +1,63 @@
+
+# python -m pytest inline-suppress-polyspace_test.py
+
+import os
+from testutils import assert_cppcheck
+
+__script_dir = os.path.dirname(os.path.abspath(__file__))
+
+
+def test_unmatched_polyspace_suppression(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write('int f(void); /* polyspace MISRA2012:8.2 */\n')
+
+    args = ['--addon=misra', '--template=simple', '--enable=style,information', '--inline-suppr', 'test.c']
+
+    out_exp = ['Checking test.c ...']
+    err_exp = ['test.c:1:0: information: Unmatched suppression: misra-c2012-8.2 [unmatchedPolyspaceSuppression]']
+
+    assert_cppcheck(args, ec_exp=0, err_exp=err_exp, out_exp=out_exp, cwd=str(tmp_path))
+
+
+def test_1(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write('int f(); /* polyspace MISRA2012:8.2 */\n')
+
+    args = ['--addon=misra', '--template=simple', '--enable=style,information', '--inline-suppr', 'test.c']
+
+    out_exp = ['Checking test.c ...']
+    err_exp = []
+
+    assert_cppcheck(args, ec_exp=0, err_exp=err_exp, out_exp=out_exp, cwd=str(tmp_path))
+
+
+def test_block(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write('/* polyspace +1 MISRA2012:8.2 */\n'
+                'int f();\n' # <- suppression applies to this line
+                'int g();\n') # <- suppression does not apply to this line
+
+    args = ['--addon=misra', '--template=simple', '--enable=style,information', '--inline-suppr', 'test.c']
+
+    out_exp = ['Checking test.c ...']
+    err_exp = ['test.c:3:6: style: misra violation (use --rule-texts=<file> to get proper output) [misra-c2012-8.2]']
+
+    assert_cppcheck(args, ec_exp=0, err_exp=err_exp, out_exp=out_exp, cwd=str(tmp_path))
+
+
+def test_begin_end(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write('/* polyspace-begin MISRA2012:8.2 */\n'
+                'int f();\n'
+                '/* polyspace-end MISRA2012:8.2 */\n')
+
+    args = ['--addon=misra', '--template=simple', '--enable=style,information', '--inline-suppr', 'test.c']
+
+    out_exp = ['Checking test.c ...']
+    err_exp = []
+
+    assert_cppcheck(args, ec_exp=0, err_exp=err_exp, out_exp=out_exp, cwd=str(tmp_path))
diff --git a/test/cli/inline-suppress_test.py b/test/cli/inline-suppress_test.py
new file mode 100644
index 00000000000..7b8be839df4
--- /dev/null
+++ b/test/cli/inline-suppress_test.py
@@ -0,0 +1,560 @@
+
+# python -m pytest inline-suppress_test.py
+
+import json
+import os
+import pytest
+import sys
+import time
+from testutils import cppcheck
+
+__script_dir = os.path.dirname(os.path.abspath(__file__))
+__proj_inline_suppres_path = 'proj-inline-suppress' + os.path.sep
+
+
+def __create_unused_function_compile_commands(tmpdir):
+    prjpath = os.path.realpath(os.path.join(__script_dir, 'proj-inline-suppress-unusedFunction'))
+    j = [{'directory': prjpath,
+          'command': '/usr/bin/c++ -I"' + prjpath + '" -o "' + os.path.join(prjpath, 'B.cpp.o') + '" -c "' + os.path.join(prjpath, 'B.cpp') + '"',
+          'file': os.path.join(prjpath, 'B.cpp')},
+         {'directory': prjpath,
+          'command': '/usr/bin/c++ -I"' + prjpath + '" -o "' + os.path.join(prjpath, 'A.cpp.o') + '" -c "' + os.path.join(prjpath, 'A.cpp') + '"',
+          'file': os.path.join(prjpath, 'A.cpp')}]
+    compdb_path = os.path.join(tmpdir, 'proj-inline-suppress-unusedFunction')
+    os.makedirs(compdb_path)
+    compile_commands = os.path.join(compdb_path, 'compile_commands.json')
+    with open(compile_commands, 'wt') as f:
+        f.write(json.dumps(j, indent=4))
+    return compile_commands
+
+
+def test_1():
+    args = [
+        '-q',
+        '--template=simple',
+        '--inline-suppr',
+        'proj-inline-suppress'
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    assert stderr == ''
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+def test_2():
+    args = [
+        '-q',
+        '--template=simple',
+        'proj-inline-suppress'
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    assert lines == [
+        '{}3.cpp:4:19: error: Division by zero. [zerodiv]'.format(__proj_inline_suppres_path)
+    ]
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+def test_xml():
+    args = [
+        '-q',
+        '--template=simple',
+        '--inline-suppr',
+        '--xml-version=3',
+        'proj-inline-suppress'
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    assert '<suppression errorId="some_warning_id" fileName="proj-inline-suppress/2.c" lineNumber="2" inline="true" comment="there should be a unmatchedSuppression warning about this" />' in stderr
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+def test_unmatched_suppression():
+    args = [
+        '-q',
+        '--template=simple',
+        '--inline-suppr',
+        '--enable=information',
+        '--error-exitcode=1',
+        '{}2.c'.format(__proj_inline_suppres_path)
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    assert lines == [
+        '{}2.c:2:0: information: Unmatched suppression: some_warning_id [unmatchedSuppression]'.format(__proj_inline_suppres_path)
+    ]
+    assert stdout == ''
+    assert ret == 1, stdout
+
+
+def test_unmatched_suppression_path_with_extra_stuff():
+    args = [
+        '-q',
+        '--template=simple',
+        '--inline-suppr',
+        '--enable=information',
+        '--error-exitcode=1',
+        '{}2.c'.format(__proj_inline_suppres_path)
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    assert lines == [
+        '{}2.c:2:0: information: Unmatched suppression: some_warning_id [unmatchedSuppression]'.format(__proj_inline_suppres_path)
+    ]
+    assert stdout == ''
+    assert ret == 1, stdout
+
+
+def test_backwards_compatibility():
+    args = [
+        '-q',
+        '--template=simple',
+        '{}3.cpp'.format(__proj_inline_suppres_path)
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    assert lines == [
+        '{}3.cpp:4:19: error: Division by zero. [zerodiv]'.format(__proj_inline_suppres_path)
+    ]
+    assert stdout == ''
+    assert ret == 0, stdout
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--inline-suppr',
+        '{}3.cpp'.format(__proj_inline_suppres_path)
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    assert lines == []
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+def __test_compile_commands_unused_function(tmpdir, use_j):
+    compdb_file = __create_unused_function_compile_commands(tmpdir)
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=all',
+        '--error-exitcode=1',
+        '--project={}'.format(compdb_file)
+    ]
+    if use_j:
+        args.append('-j2')
+    else:
+        args.append('-j1')
+    ret, stdout, stderr = cppcheck(args)
+    proj_path_sep = os.path.join(__script_dir, 'proj-inline-suppress-unusedFunction') + os.path.sep
+    lines = stderr.splitlines()
+    assert lines == [
+        "{}B.cpp:6:9: style: The function 'unusedFunctionTest' is never used. [unusedFunction]".format(proj_path_sep)
+    ]
+    assert stdout == ''
+    assert ret == 1, stdout
+
+
+def test_compile_commands_unused_function(tmpdir):
+    __test_compile_commands_unused_function(tmpdir, False)
+
+
+@pytest.mark.skip  # unusedFunction does not work with -j
+def test_compile_commands_unused_function_j(tmpdir):
+    __test_compile_commands_unused_function(tmpdir, True)
+
+
+def __test_compile_commands_unused_function_suppression(tmpdir, use_j):
+    compdb_file = __create_unused_function_compile_commands(tmpdir)
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=all',
+        '--inline-suppr',
+        '--error-exitcode=1',
+        '--project={}'.format(compdb_file)
+    ]
+    if use_j:
+        args.append('-j2')
+    else:
+        args.append('-j1')
+    ret, stdout, stderr = cppcheck(args)
+    lines = stderr.splitlines()
+    assert lines == []
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+def test_compile_commands_unused_function_suppression(tmpdir):
+    __test_compile_commands_unused_function_suppression(tmpdir, False)
+
+
+@pytest.mark.skip  # unusedFunction does not work with -j
+def test_compile_commands_unused_function_suppression_j(tmpdir):
+    __test_compile_commands_unused_function_suppression(tmpdir, True)
+
+
+def test_unmatched_suppression_ifdef():
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=information',
+        '--inline-suppr',
+        '-DNO_ZERO_DIV',
+        'trac5704/trac5704a.c'
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    assert lines == []
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+def test_unmatched_suppression_ifdef_0():
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=information',
+        '--inline-suppr',
+        'trac5704/trac5704b.c'
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    assert lines == []
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+def test_build_dir(tmpdir):
+    args = [
+        '-q',
+        '--template=simple',
+        '--cppcheck-build-dir={}'.format(tmpdir),
+        '--enable=all',
+        '--inline-suppr',
+        '{}4.c'.format(__proj_inline_suppres_path)
+    ]
+
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    assert lines == []
+    assert stdout == ''
+    assert ret == 0, stdout
+
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    assert lines == []
+    assert stdout == ''
+    assert ret == 0, stdout
+
+def test_build_dir_jobs_suppressions(tmpdir): #14064
+    args = [
+        '-q',
+        '--template=simple',
+        '--cppcheck-build-dir={}'.format(tmpdir),
+        '--enable=style',
+        '--inline-suppr',
+        '-j4',
+        'reanalysis'
+    ]
+
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    assert lines == []
+    assert stdout == ''
+    assert ret == 0, stdout
+
+    a1Path = os.path.join(tmpdir, 'd.a1')
+    assert os.path.exists(a1Path)
+    mtimeOld = os.path.getmtime(a1Path)
+
+    time.sleep(1)
+
+    for _ in range(1, 10):
+        cppcheck(args, cwd=__script_dir)
+
+    mtimeNew = os.path.getmtime(a1Path)
+    assert mtimeOld == mtimeNew
+
+
+def __test_build_dir_unused_template(tmpdir, extra_args):
+    args = [
+        '-q',
+        '--template=simple',
+        '--cppcheck-build-dir={}'.format(tmpdir),
+        '--enable=all',
+        '--inline-suppr',
+        '{}template.cpp'.format(__proj_inline_suppres_path)
+    ]
+
+    args = args + extra_args
+
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    assert lines == []
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+def test_build_dir_unused_template(tmpdir):
+    __test_build_dir_unused_template(tmpdir, ['-j1', '--no-cppcheck-build-dir'])
+
+
+def test_build_dir_unused_template_j_thread(tmpdir):
+    __test_build_dir_unused_template(tmpdir, ['-j2', '--executor=thread'])
+
+
+@pytest.mark.skipif(sys.platform == 'win32', reason='ProcessExecutor not available on Windows')
+def test_build_dir_unused_template_j_process(tmpdir):
+    __test_build_dir_unused_template(tmpdir, ['-j2', '--executor=process'])
+
+
+def test_suppress_unmatched_inline_suppression():  # 11172
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=information',
+        '--suppress=unmatchedSuppression',
+        '--inline-suppr',
+        '{}2.c'.format(__proj_inline_suppres_path)
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    assert lines == []
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+@pytest.mark.skip  # TODO: this test makes no sense
+@pytest.mark.xfail(strict=True)  # no error as inline suppressions are currently not being propagated back
+def test_duplicate(tmpdir):
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=all',
+        '--inline-suppr',
+        'proj-inline-suppress/duplicate.cpp'
+    ]
+
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    assert stderr.splitlines() == []
+    assert stdout.splitlines() == [
+        "cppcheck: error: suppression 'unreadVariable' already exists"
+    ]
+    assert ret == 0, stdout
+
+
+# no error as inline suppressions are handled separately
+def __test_duplicate_cmd(tmpdir, extra_args):
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=all',
+        '--inline-suppr',
+        '--suppress=unreadVariable',
+        'proj-inline-suppress/4.c'
+    ]
+
+    args = args + extra_args
+
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    # this is the suppression provided via the command-line which is unused because only the inline suppression is being matched
+    assert lines == [
+        'nofile:0:0: information: Unmatched suppression: unreadVariable [unmatchedSuppression]'
+    ]
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+@pytest.mark.skip  # TODO: behavior of duplicate suppressions across inline and non-inline is currently undefined
+def test_duplicate_cmd(tmp_path):
+    __test_duplicate_cmd(tmp_path, ['-j1'])
+
+
+@pytest.mark.skip  # TODO: behavior of duplicate suppressions across inline and non-inline is currently undefined
+def test_duplicate_cmd_j(tmp_path):
+    __test_duplicate_cmd(tmp_path, ['-j2'])
+
+
+# no error as inline suppressions are handled separately
+def __test_duplicate_file(tmp_path, extra_args):
+    suppr_file =  tmp_path / 'suppressions'
+    with open(suppr_file, 'wt') as f:
+        f.write('unreadVariable')
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=all',
+        '--inline-suppr',
+        '--suppressions-list={}'.format(suppr_file),
+        'proj-inline-suppress/4.c'
+    ]
+
+    args = args + extra_args
+
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    # this is the suppression provided via the suppression file which is unused because only the inline suppression is being matched
+    assert lines == [
+        'nofile:0:0: information: Unmatched suppression: unreadVariable [unmatchedSuppression]'
+    ]
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+@pytest.mark.skip  # TODO: behavior of duplicate suppressions across inline and non-inline is currently undefined
+def test_duplicate_file(tmpdir):
+    __test_duplicate_file(tmpdir, ['-j1'])
+
+
+@pytest.mark.skip  # TODO: behavior of duplicate suppressions across inline and non-inline is currently undefined
+def test_duplicate_file_j(tmpdir):
+    __test_duplicate_file(tmpdir, ['-j2'])
+
+
+# reporting of inline unusedFunction is deferred
+def __test_unused_function_unmatched(tmpdir, extra_args):
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=all',
+        '--inline-suppr',
+        'proj-inline-suppress/unusedFunctionUnmatched.cpp'
+    ]
+
+    args += extra_args
+
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    lines.sort()
+    assert lines == [
+        '{}unusedFunctionUnmatched.cpp:5:0: information: Unmatched suppression: uninitvar [unmatchedSuppression]'.format(__proj_inline_suppres_path),
+        '{}unusedFunctionUnmatched.cpp:5:0: information: Unmatched suppression: unusedFunction [unmatchedSuppression]'.format(__proj_inline_suppres_path)
+    ]
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+def test_unused_function_unmatched(tmpdir):
+    __test_unused_function_unmatched(tmpdir, ['-j1', '--no-cppcheck-build-dir'])
+
+
+@pytest.mark.xfail(strict=True)  # TODO: check error - do not work with -j2
+def test_unused_function_unmatched_j(tmpdir):
+    __test_unused_function_unmatched(tmpdir, ['-j2', '--no-cppcheck-build-dir'])
+
+
+def test_unused_function_unmatched_builddir(tmpdir):
+    build_dir = os.path.join(tmpdir, 'b1')
+    os.mkdir(build_dir)
+    __test_unused_function_unmatched(tmpdir, ['-j1', '--cppcheck-build-dir={}'.format(build_dir)])
+
+
+def test_unused_function_unmatched_builddir_j_thread(tmpdir):
+    build_dir = os.path.join(tmpdir, 'b1')
+    os.mkdir(build_dir)
+    __test_unused_function_unmatched(tmpdir, ['-j2', '--cppcheck-build-dir={}'.format(build_dir), '--executor=thread'])
+
+
+@pytest.mark.skipif(sys.platform == 'win32', reason='ProcessExecutor not available on Windows')
+def test_unused_function_unmatched_builddir_j_process(tmpdir):
+    build_dir = os.path.join(tmpdir, 'b1')
+    os.mkdir(build_dir)
+    __test_unused_function_unmatched(tmpdir, ['-j2', '--cppcheck-build-dir={}'.format(build_dir), '--executor=process'])
+
+
+# do not report unmatched unusedFunction inline suppressions when unusedFunction check is disabled
+def test_unused_function_disabled_unmatched():
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=warning,information',
+        '--inline-suppr',
+        'proj-inline-suppress/unusedFunctionUnmatched.cpp'
+    ]
+
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    assert stderr.splitlines() == [
+        '{}unusedFunctionUnmatched.cpp:5:0: information: Unmatched suppression: uninitvar [unmatchedSuppression]'.format(__proj_inline_suppres_path)
+    ]
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+def test_unmatched_cfg():
+    # make sure we do not report unmatched inline suppressions from inactive code blocks
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=warning,information',
+        '--inline-suppr',
+        'proj-inline-suppress/cfg.c'
+    ]
+
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    assert stderr.splitlines() == [
+        '{}cfg.c:5:0: information: Unmatched suppression: id [unmatchedSuppression]'.format(__proj_inline_suppres_path),
+        '{}cfg.c:9:0: information: Unmatched suppression: id [unmatchedSuppression]'.format(__proj_inline_suppres_path),
+    ]
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+# do not report unmatched unusedFunction inline suppressions when unusedFunction check is disabled
+# unusedFunction is disabled when -j2 is specified without a builddir
+def test_unused_function_disabled_unmatched_j():
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=warning,information',
+        '--inline-suppr',
+        '-j2',
+        '--no-cppcheck-build-dir',
+        'proj-inline-suppress/unusedFunctionUnmatched.cpp'
+    ]
+
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    assert stderr.splitlines() == [
+        '{}unusedFunctionUnmatched.cpp:5:0: information: Unmatched suppression: uninitvar [unmatchedSuppression]'.format(__proj_inline_suppres_path)
+    ]
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+# do not report unmatched misra-* inline suppressions when misra is not provided
+def test_misra_disabled_unmatched():  #14232
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=warning,information',
+        '--inline-suppr',
+        'proj-inline-suppress/misraUnmatched.c'
+    ]
+
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    assert stderr.splitlines() == [
+        '{}misraUnmatched.c:5:0: information: Unmatched suppression: uninitvar [unmatchedSuppression]'.format(__proj_inline_suppres_path)
+    ]
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+# do not report unmatched premium-* inline suppressions when application is not premium
+def test_premium_disabled_unmatched():  #13663
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=warning,information',
+        '--inline-suppr',
+        'proj-inline-suppress/premiumUnmatched.cpp'
+    ]
+
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    assert stderr.splitlines() == [
+        '{}premiumUnmatched.cpp:5:0: information: Unmatched suppression: uninitvar [unmatchedSuppression]'.format(__proj_inline_suppres_path)
+    ]
+    assert stdout == ''
+    assert ret == 0, stdout
\ No newline at end of file
diff --git a/test/cli/lookup_test.py b/test/cli/lookup_test.py
new file mode 100644
index 00000000000..cab96a7f6bb
--- /dev/null
+++ b/test/cli/lookup_test.py
@@ -0,0 +1,1002 @@
+import os
+import sys
+import pytest
+import shutil
+import json
+
+from testutils import cppcheck_ex, cppcheck, __lookup_cppcheck_exe
+
+def __remove_std_lookup_log(l : list, exepath):
+    l.remove("looking for library 'std.cfg'")
+    l.remove("looking for library '{}/std.cfg'".format(exepath))
+    l.remove("looking for library '{}/cfg/std.cfg'".format(exepath))
+    return l
+
+
+def __create_gui_project(tmpdir):
+    file_name = 'test.c'
+    test_file = os.path.join(tmpdir, file_name)
+    with open(test_file, 'wt'):
+        pass
+
+    project_file = os.path.join(tmpdir, 'project.cppcheck')
+    with open(project_file, 'wt') as f:
+        f.write(
+"""<?xml version="1.0" encoding="UTF-8"?>
+<project version="1">
+    <paths>
+        <dir name="{}"/>
+    </paths>
+</project>""".format(test_file)
+        )
+
+    return project_file, test_file
+
+
+def __create_compdb(tmpdir):
+    file_name = 'test.c'
+    test_file = os.path.join(tmpdir, file_name)
+    with open(test_file, 'wt'):
+        pass
+
+    compilation_db = [
+        {
+            "directory": str(tmpdir),
+            "command": "c++ -o {}.o -c {}".format(os.path.basename(file_name), file_name),
+            "file": file_name,
+            "output": "{}.o".format(os.path.basename(file_name))
+        }
+    ]
+
+    compile_commands = os.path.join(tmpdir, 'compile_commands.json')
+    with open(compile_commands, 'wt') as f:
+        f.write(json.dumps(compilation_db))
+
+    return compile_commands, test_file
+
+
+def test_lib_lookup(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, stderr, exe = cppcheck_ex(['--debug-lookup=library', '--library=gnu', test_file])
+    exepath = os.path.dirname(exe)
+    if sys.platform == 'win32':
+        exepath = exepath.replace('\\', '/')
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = __remove_std_lookup_log(stdout.splitlines(), exepath)
+    assert lines == [
+        "looking for library 'gnu.cfg'",
+        "looking for library '{}/gnu.cfg'".format(exepath),
+        "looking for library '{}/cfg/gnu.cfg'".format(exepath),
+        'Checking {} ...'.format(test_file)
+    ]
+
+
+def test_lib_lookup_ext(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, stderr, exe = cppcheck_ex(['--debug-lookup=library', '--library=gnu.cfg', test_file])
+    exepath = os.path.dirname(exe)
+    if sys.platform == 'win32':
+        exepath = exepath.replace('\\', '/')
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = __remove_std_lookup_log(stdout.splitlines(), exepath)
+    assert lines == [
+        "looking for library 'gnu.cfg'",
+        "looking for library '{}/gnu.cfg'".format(exepath),
+        "looking for library '{}/cfg/gnu.cfg'".format(exepath),
+        'Checking {} ...'.format(test_file)
+    ]
+
+
+def test_lib_lookup_notfound(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, _, exe = cppcheck_ex(['--debug-lookup=library', '--library=none', test_file])
+    exepath = os.path.dirname(exe)
+    if sys.platform == 'win32':
+        exepath = exepath.replace('\\', '/')
+    assert exitcode == 1, stdout
+    lines = __remove_std_lookup_log(stdout.splitlines(), exepath)
+    assert lines == [
+        # TODO: specify which folder is actually used for lookup here
+        "looking for library 'none.cfg'",
+        "looking for library '{}/none.cfg'".format(exepath),
+        "looking for library '{}/cfg/none.cfg'".format(exepath),
+        "library not found: 'none'",
+        "cppcheck: Failed to load library configuration file 'none'. File not found"
+    ]
+
+
+def test_lib_lookup_notfound_project(tmpdir):  # #13938
+    project_file, _ = __create_gui_project(tmpdir)
+
+    exitcode, stdout, _, exe = cppcheck_ex(['--debug-lookup=library', '--library=none', '--project={}'.format(project_file)])
+    exepath = os.path.dirname(exe)
+    if sys.platform == 'win32':
+        exepath = exepath.replace('\\', '/')
+    assert exitcode == 1, stdout
+    lines = __remove_std_lookup_log(stdout.splitlines(), exepath)
+    assert lines == [
+        # TODO: needs to look relative to the project first
+        # TODO: specify which folder is actually used for lookup here
+        "looking for library 'none.cfg'",
+        "looking for library '{}/none.cfg'".format(exepath),
+        "looking for library '{}/cfg/none.cfg'".format(exepath),
+        "library not found: 'none'",
+        "cppcheck: Failed to load library configuration file 'none'. File not found"
+    ]
+
+
+def test_lib_lookup_notfound_compdb(tmpdir):
+    compdb_file, _ = __create_compdb(tmpdir)
+
+    exitcode, stdout, _, exe = cppcheck_ex(['--debug-lookup=library', '--library=none', '--project={}'.format(compdb_file)])
+    exepath = os.path.dirname(exe)
+    if sys.platform == 'win32':
+        exepath = exepath.replace('\\', '/')
+    assert exitcode == 1, stdout
+    lines = __remove_std_lookup_log(stdout.splitlines(), exepath)
+    assert lines == [
+        # TODO: specify which folder is actually used for lookup here
+        "looking for library 'none.cfg'",
+        "looking for library '{}/none.cfg'".format(exepath),
+        "looking for library '{}/cfg/none.cfg'".format(exepath),
+        "library not found: 'none'",
+        "cppcheck: Failed to load library configuration file 'none'. File not found"
+    ]
+
+
+def test_lib_lookup_ext_notfound(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, stderr, exe = cppcheck_ex(['--debug-lookup=library', '--library=none.cfg', test_file])
+    exepath = os.path.dirname(exe)
+    if sys.platform == 'win32':
+        exepath = exepath.replace('\\', '/')
+    assert exitcode == 1, stdout if stdout else stderr
+    lines = __remove_std_lookup_log(stdout.splitlines(), exepath)
+    assert lines == [
+        "looking for library 'none.cfg'",
+        "looking for library '{}/none.cfg'".format(exepath),
+        "looking for library '{}/cfg/none.cfg'".format(exepath),
+        "library not found: 'none.cfg'",
+        "cppcheck: Failed to load library configuration file 'none.cfg'. File not found"
+    ]
+
+
+def test_lib_lookup_relative_notfound(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, stderr, exe = cppcheck_ex(['--debug-lookup=library', '--library=config/gnu.xml', test_file])
+    exepath = os.path.dirname(exe)
+    if sys.platform == 'win32':
+        exepath = exepath.replace('\\', '/')
+    assert exitcode == 1, stdout if stdout else stderr
+    lines = __remove_std_lookup_log(stdout.splitlines(), exepath)
+    assert lines == [
+        "looking for library 'config/gnu.xml'",
+        "looking for library '{}/config/gnu.xml'".format(exepath),
+        "looking for library '{}/cfg/config/gnu.xml'".format(exepath),
+        "library not found: 'config/gnu.xml'",
+        "cppcheck: Failed to load library configuration file 'config/gnu.xml'. File not found"
+    ]
+
+
+def test_lib_lookup_relative_noext_notfound(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, stderr, exe = cppcheck_ex(['--debug-lookup=library', '--library=config/gnu', test_file])
+    exepath = os.path.dirname(exe)
+    if sys.platform == 'win32':
+        exepath = exepath.replace('\\', '/')
+    assert exitcode == 1, stdout if stdout else stderr
+    lines = __remove_std_lookup_log(stdout.splitlines(), exepath)
+    assert lines == [
+        "looking for library 'config/gnu.cfg'",
+        "looking for library '{}/config/gnu.cfg'".format(exepath),
+        "looking for library '{}/cfg/config/gnu.cfg'".format(exepath),
+        "library not found: 'config/gnu'",
+        "cppcheck: Failed to load library configuration file 'config/gnu'. File not found"
+    ]
+
+
+def test_lib_lookup_absolute(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    cfg_file = os.path.join(tmpdir, 'test.cfg')
+    with open(cfg_file, 'wt') as f:
+        f.write('''
+<?xml version="1.0"?>
+<def format="2">
+</def>
+        ''')
+
+    exitcode, stdout, stderr, exe = cppcheck_ex(['--debug-lookup=library', '--library={}'.format(cfg_file), test_file])
+    exepath = os.path.dirname(exe)
+    if sys.platform == 'win32':
+        exepath = exepath.replace('\\', '/')
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = __remove_std_lookup_log(stdout.splitlines(), exepath)
+    assert lines == [
+        "looking for library '{}'".format(cfg_file),
+        'Checking {} ...'.format(test_file)
+    ]
+
+
+def test_lib_lookup_absolute_notfound(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    cfg_file = os.path.join(tmpdir, 'test.cfg')
+
+    exitcode, stdout, _, exe = cppcheck_ex(['--debug-lookup=library', '--library={}'.format(cfg_file), test_file])
+    exepath = os.path.dirname(exe)
+    if sys.platform == 'win32':
+        exepath = exepath.replace('\\', '/')
+    assert exitcode == 1, stdout
+    lines = __remove_std_lookup_log(stdout.splitlines(), exepath)
+    assert lines == [
+        "looking for library '{}'".format(cfg_file),
+        "library not found: '{}'".format(cfg_file),
+        "cppcheck: Failed to load library configuration file '{}'. File not found".format(cfg_file)
+    ]
+
+
+def test_lib_lookup_nofile(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    # make sure we do not produce an error when the attempted lookup path is a directory and not a file
+    gtk_cfg_dir = os.path.join(tmpdir, 'gtk.cfg')
+    os.mkdir(gtk_cfg_dir)
+
+    exitcode, stdout, stderr, exe = cppcheck_ex(['--debug-lookup=library', '--library=gtk', test_file], cwd=tmpdir)
+    exepath = os.path.dirname(exe)
+    if sys.platform == 'win32':
+        exepath = exepath.replace('\\', '/')
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = __remove_std_lookup_log(stdout.splitlines(), exepath)
+    assert lines == [
+        "looking for library 'gtk.cfg'",
+        "looking for library '{}/gtk.cfg'".format(exepath),
+        "looking for library '{}/cfg/gtk.cfg'".format(exepath),
+        'Checking {} ...'.format(test_file)
+    ]
+
+
+# make sure we bail out when we encounter an invalid file
+def test_lib_lookup_invalid(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    gnu_cfg_file = os.path.join(tmpdir, 'gnu.cfg')
+    with open(gnu_cfg_file, 'wt') as f:
+        f.write('''{}''')
+
+    exitcode, stdout, stderr, exe = cppcheck_ex(['--debug-lookup=library', '--library=gnu', test_file], cwd=tmpdir)
+    exepath = os.path.dirname(exe)
+    if sys.platform == 'win32':
+        exepath = exepath.replace('\\', '/')
+    assert exitcode == 1, stdout if stdout else stderr
+    lines = __remove_std_lookup_log(stdout.splitlines(), exepath)
+    assert lines == [
+        "looking for library 'gnu.cfg'",
+        "library not found: 'gnu'",
+        "Error=XML_ERROR_PARSING_TEXT ErrorID=8 (0x8) Line number=1",  # TODO: log the failure before saying the library was not found
+        "cppcheck: Failed to load library configuration file 'gnu'. Bad XML"
+    ]
+
+
+def test_lib_lookup_multi(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, stderr, exe = cppcheck_ex(['--debug-lookup=library', '--library=posix,gnu', test_file])
+    exepath = os.path.dirname(exe)
+    if sys.platform == 'win32':
+        exepath = exepath.replace('\\', '/')
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = __remove_std_lookup_log(stdout.splitlines(), exepath)
+    assert lines == [
+        "looking for library 'posix.cfg'",
+        "looking for library '{}/posix.cfg'".format(exepath),
+        "looking for library '{}/cfg/posix.cfg'".format(exepath),
+        "looking for library 'gnu.cfg'",
+        "looking for library '{}/gnu.cfg'".format(exepath),
+        "looking for library '{}/cfg/gnu.cfg'".format(exepath),
+        'Checking {} ...'.format(test_file)
+    ]
+
+
+def test_platform_lookup_builtin(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, stderr = cppcheck(['--debug-lookup=platform', '--platform=unix64', test_file])
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    # built-in platform are not being looked up
+    assert lines == [
+        'Checking {} ...'.format(test_file)
+    ]
+
+
+@pytest.mark.skip  # TODO: fails when not run from the root folder
+def test_platform_lookup(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, stderr = cppcheck(['--debug-lookup=platform', '--platform=avr8', test_file])
+    cwd = os.getcwd()
+    if sys.platform == 'win32':
+        cwd = cwd.replace('\\', '/')
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for platform 'avr8'",
+        "try to load platform file '{}/avr8.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/avr8.xml".format(cwd, cwd),
+        "try to load platform file '{}/platforms/avr8.xml' ... Success".format(cwd),
+        'Checking {} ...'.format(test_file)
+    ]
+
+
+@pytest.mark.skip  # TODO: fails when not run from the root folder
+def test_platform_lookup_ext(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, stderr = cppcheck(['--debug-lookup=platform', '--platform=avr8.xml', test_file])
+    cwd = os.getcwd()
+    if sys.platform == 'win32':
+        cwd = cwd.replace('\\', '/')
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for platform 'avr8.xml'",
+        "try to load platform file '{}/avr8.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/avr8.xml".format(cwd, cwd),
+        "try to load platform file '{}/platforms/avr8.xml' ... Success".format(cwd),
+        'Checking {} ...'.format(test_file)
+    ]
+
+
+def test_platform_lookup_path(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    cppcheck = 'cppcheck' # No path
+    path = os.path.dirname(__lookup_cppcheck_exe())
+    env = os.environ.copy()
+    env['PATH'] = path
+    exitcode, stdout, stderr, _ = cppcheck_ex(args=['--debug-lookup=platform', '--platform=avr8.xml', test_file], cppcheck_exe=cppcheck, cwd=str(tmpdir), env=env)
+    assert exitcode == 0, stdout if stdout else stderr
+    def format_path(p):
+        return p.replace('\\', '/').replace('"', '\'')
+    def try_fail(f):
+        f = format_path(f)
+        return "try to load platform file '{}' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}".format(f, f)
+    def try_success(f):
+        f = format_path(f)
+        return "try to load platform file '{}' ... Success".format(f)
+    lines = stdout.replace('\\', '/').replace('"', '\'').splitlines()
+    assert lines == [
+        "looking for platform 'avr8.xml'",
+        try_fail(os.path.join(tmpdir, 'avr8.xml')),
+        try_fail(os.path.join(tmpdir, 'platforms', 'avr8.xml')),
+        try_fail(os.path.join(path, 'avr8.xml')),
+        try_success(os.path.join(path, 'platforms', 'avr8.xml')),
+        'Checking {} ...'.format(format_path(test_file))
+    ]
+
+
+def test_platform_lookup_notfound(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, _, exe = cppcheck_ex(['--debug-lookup=platform', '--platform=none', test_file])
+    cwd = os.getcwd()
+    exepath = os.path.dirname(exe)
+    if sys.platform == 'win32':
+        cwd = cwd.replace('\\', '/')
+        exepath = exepath.replace('\\', '/')
+    assert exitcode == 1, stdout
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for platform 'none'",
+        "try to load platform file '{}/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/none.xml".format(cwd, cwd),
+        "try to load platform file '{}/platforms/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/platforms/none.xml".format(cwd, cwd),
+        "try to load platform file '{}/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/none.xml".format(exepath, exepath),
+        "try to load platform file '{}/platforms/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/platforms/none.xml".format(exepath, exepath),
+        "cppcheck: error: unrecognized platform: 'none'."
+    ]
+
+
+# TODO: test with invalid file in project path
+# TODO: test with non-file in project path
+def test_platform_lookup_notfound_project(tmpdir):  # #13939
+    project_file, _ = __create_gui_project(tmpdir)
+    project_path = os.path.dirname(project_file)
+
+    exitcode, stdout, _, exe = cppcheck_ex(['--debug-lookup=platform', '--platform=none', '--project={}'.format(project_file)])
+    cwd = os.getcwd()
+    exepath = os.path.dirname(exe)
+    if sys.platform == 'win32':
+        cwd = cwd.replace('\\', '/')
+        exepath = exepath.replace('\\', '/')
+        project_path = project_path.replace('\\', '/')
+    assert exitcode == 1, stdout
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for platform 'none'",
+        "try to load platform file '{}/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/none.xml".format(project_path, project_path),
+        "try to load platform file '{}/platforms/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/platforms/none.xml".format(project_path, project_path),
+        # TODO: the following lookups are in CWD - is this intended?
+        "try to load platform file '{}/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/none.xml".format(cwd, cwd),
+        "try to load platform file '{}/platforms/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/platforms/none.xml".format(cwd, cwd),
+        "try to load platform file '{}/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/none.xml".format(exepath, exepath),
+        "try to load platform file '{}/platforms/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/platforms/none.xml".format(exepath, exepath),
+        "cppcheck: error: unrecognized platform: 'none'."
+    ]
+
+
+def test_platform_lookup_notfound_compdb(tmpdir):
+    compdb_file, _ = __create_compdb(tmpdir)
+
+    exitcode, stdout, _, exe = cppcheck_ex(['--debug-lookup=platform', '--platform=none', '--project={}'.format(compdb_file)])
+    cwd = os.getcwd()
+    exepath = os.path.dirname(exe)
+    if sys.platform == 'win32':
+        cwd = cwd.replace('\\', '/')
+        exepath = exepath.replace('\\', '/')
+    assert exitcode == 1, stdout
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for platform 'none'",
+        "try to load platform file '{}/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/none.xml".format(cwd, cwd),
+        "try to load platform file '{}/platforms/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/platforms/none.xml".format(cwd, cwd),
+        "try to load platform file '{}/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/none.xml".format(exepath, exepath),
+        "try to load platform file '{}/platforms/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/platforms/none.xml".format(exepath, exepath),
+        "cppcheck: error: unrecognized platform: 'none'."
+    ]
+
+
+def test_platform_lookup_ext_notfound(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, stderr, exe = cppcheck_ex(['--debug-lookup=platform', '--platform=none.xml', test_file])
+    cwd = os.getcwd()
+    exepath = os.path.dirname(exe)
+    if sys.platform == 'win32':
+        cwd = cwd.replace('\\', '/')
+        exepath = exepath.replace('\\', '/')
+    assert exitcode == 1, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for platform 'none.xml'",
+        "try to load platform file '{}/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/none.xml".format(cwd, cwd),
+        "try to load platform file '{}/platforms/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/platforms/none.xml".format(cwd, cwd),
+        "try to load platform file '{}/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/none.xml".format(exepath, exepath),
+        "try to load platform file '{}/platforms/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/platforms/none.xml".format(exepath, exepath),
+        "cppcheck: error: unrecognized platform: 'none.xml'."
+    ]
+
+
+def test_platform_lookup_relative_notfound(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, stderr, exe = cppcheck_ex(['--debug-lookup=platform', '--platform=platform/none.xml', test_file])
+    cwd = os.getcwd()
+    exepath = os.path.dirname(exe)
+    if sys.platform == 'win32':
+        cwd = cwd.replace('\\', '/')
+        exepath = exepath.replace('\\', '/')
+    assert exitcode == 1, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for platform 'platform/none.xml'",
+        "try to load platform file '{}/platform/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/platform/none.xml".format(cwd, cwd),
+        "try to load platform file '{}/platforms/platform/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/platforms/platform/none.xml".format(cwd, cwd),
+        "try to load platform file '{}/platform/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/platform/none.xml".format(exepath, exepath),
+        "try to load platform file '{}/platforms/platform/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/platforms/platform/none.xml".format(exepath, exepath),
+        "cppcheck: error: unrecognized platform: 'platform/none.xml'."
+    ]
+
+
+def test_platform_lookup_relative_noext_notfound(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, stderr, exe = cppcheck_ex(['--debug-lookup=platform', '--platform=platform/none', test_file])
+    cwd = os.getcwd()
+    exepath = os.path.dirname(exe)
+    if sys.platform == 'win32':
+        cwd = cwd.replace('\\', '/')
+        exepath = exepath.replace('\\', '/')
+    assert exitcode == 1, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for platform 'platform/none'",
+        "try to load platform file '{}/platform/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/platform/none.xml".format(cwd, cwd),
+        "try to load platform file '{}/platforms/platform/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/platforms/platform/none.xml".format(cwd, cwd),
+        "try to load platform file '{}/platform/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/platform/none.xml".format(exepath, exepath),
+        "try to load platform file '{}/platforms/platform/none.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/platforms/platform/none.xml".format(exepath, exepath),
+        "cppcheck: error: unrecognized platform: 'platform/none'."
+    ]
+
+
+def test_platform_lookup_absolute(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    platform_file = os.path.join(tmpdir, 'test.xml')
+    with open(platform_file, 'wt') as f:
+        f.write('''
+<platform format="2"/>
+        ''')
+
+    exitcode, stdout, stderr = cppcheck(['--debug-lookup=platform', '--platform={}'.format(platform_file), test_file])
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for platform '{}'".format(platform_file),
+        "try to load platform file '{}' ... Success".format(platform_file),
+        'Checking {} ...'.format(test_file)
+    ]
+
+
+def test_platform_lookup_absolute_notfound(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    platform_file = os.path.join(tmpdir, 'test.xml')
+
+    exitcode, stdout, stderr = cppcheck(['--debug-lookup=platform', '--platform={}'.format(platform_file), test_file])
+    assert exitcode == 1, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for platform '{}'".format(platform_file),
+        "try to load platform file '{}' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}".format(platform_file, platform_file),
+        "cppcheck: error: unrecognized platform: '{}'.".format(platform_file)
+    ]
+
+
+@pytest.mark.skip  # TODO: fails when not run from the root folder
+def test_platform_lookup_nofile(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    # make sure we do not produce an error when the attempted lookup path is a directory and not a file
+    avr8_cfg_dir = os.path.join(tmpdir, 'avr8.xml')
+    os.mkdir(avr8_cfg_dir)
+
+    exitcode, stdout, stderr = cppcheck(['--debug-lookup=platform', '--platform=avr8', test_file])
+    cwd = os.getcwd()
+    if sys.platform == 'win32':
+        cwd = cwd.replace('\\', '/')
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for platform 'avr8'",
+        "try to load platform file '{}/avr8.xml' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={}/avr8.xml".format(cwd, cwd),
+        "try to load platform file '{}/platforms/avr8.xml' ... Success".format(cwd),
+        'Checking {}1 ...'.format(test_file)
+    ]
+
+
+def test_platform_lookup_invalid(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    avr8_file = os.path.join(tmpdir, 'avr8.xml')
+    with open(avr8_file, 'wt') as f:
+        f.write('''{}''')
+
+    exitcode, stdout, stderr = cppcheck(['--debug-lookup=platform', '--platform=avr8', test_file], cwd=tmpdir)
+    cwd = str(tmpdir)
+    if sys.platform == 'win32':
+        cwd = cwd.replace('\\', '/')
+    assert exitcode == 1, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for platform 'avr8'",
+        "try to load platform file '{}/avr8.xml' ... Error=XML_ERROR_PARSING_TEXT ErrorID=8 (0x8) Line number=1".format(cwd),
+        "cppcheck: error: unrecognized platform: 'avr8'."
+    ]
+
+
+def test_addon_lookup(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, stderr, exe = cppcheck_ex(['--debug-lookup=addon', '--addon=misra', test_file])
+    exepath = os.path.dirname(exe)
+    exepath_sep = exepath + os.path.sep
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for addon 'misra.py'",
+        "looking for addon '{}misra.py'".format(exepath_sep),
+        "looking for addon '{}addons/misra.py'".format(exepath_sep),  # TODO: mixed separators
+        'Checking {} ...'.format(test_file)
+    ]
+
+
+def test_addon_lookup_ext(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, stderr, exe = cppcheck_ex(['--debug-lookup=addon', '--addon=misra.py', test_file])
+    exepath = os.path.dirname(exe)
+    exepath_sep = exepath + os.path.sep
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for addon 'misra.py'",
+        "looking for addon '{}misra.py'".format(exepath_sep),
+        "looking for addon '{}addons/misra.py'".format(exepath_sep),  # TODO: mixed separators
+        'Checking {} ...'.format(test_file)
+    ]
+
+
+def test_addon_lookup_notfound(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, _, exe = cppcheck_ex(['--debug-lookup=addon', '--addon=none', test_file])
+    exepath = os.path.dirname(exe)
+    exepath_sep = exepath + os.path.sep
+    assert exitcode == 1, stdout
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for addon 'none.py'",
+        "looking for addon '{}none.py'".format(exepath_sep),
+        "looking for addon '{}addons/none.py'".format(exepath_sep),  # TODO: mixed separators
+        'Did not find addon none.py'
+    ]
+
+
+def test_addon_lookup_notfound_project(tmpdir):  # #13940 / #13941
+    project_file, _ = __create_gui_project(tmpdir)
+
+    exitcode, stdout, _, exe = cppcheck_ex(['--debug-lookup=addon', '--addon=none', '--project={}'.format(project_file)])
+    exepath = os.path.dirname(exe)
+    exepath_sep = exepath + os.path.sep
+    assert exitcode == 1, stdout
+    lines = stdout.splitlines()
+    assert lines == [
+        # TODO: needs to look relative to the project file first
+        "looking for addon 'none.py'",
+        "looking for addon '{}none.py'".format(exepath_sep),
+        "looking for addon '{}addons/none.py'".format(exepath_sep),  # TODO: mixed separators
+        'Did not find addon none.py'
+    ]
+
+
+def test_addon_lookup_notfound_compdb(tmpdir):
+    compdb_file, _ = __create_compdb(tmpdir)
+
+    exitcode, stdout, _, exe = cppcheck_ex(['--debug-lookup=addon', '--addon=none', '--project={}'.format(compdb_file)])
+    exepath = os.path.dirname(exe)
+    exepath_sep = exepath + os.path.sep
+    assert exitcode == 1, stdout
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for addon 'none.py'",
+        "looking for addon '{}none.py'".format(exepath_sep),
+        "looking for addon '{}addons/none.py'".format(exepath_sep),  # TODO: mixed separators
+        'Did not find addon none.py'
+    ]
+
+
+def test_addon_lookup_ext_notfound(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, _, exe = cppcheck_ex(['--debug-lookup=addon', '--addon=none.py', test_file])
+    exepath = os.path.dirname(exe)
+    exepath_sep = exepath + os.path.sep
+    assert exitcode == 1, stdout
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for addon 'none.py'",
+        "looking for addon '{}none.py'".format(exepath_sep),
+        "looking for addon '{}addons/none.py'".format(exepath_sep),  # TODO: mixed separators
+        'Did not find addon none.py'
+    ]
+
+
+def test_addon_lookup_relative_notfound(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, _, exe = cppcheck_ex(['--debug-lookup=addon', '--addon=addon/misra.py', test_file])
+    exepath = os.path.dirname(exe)
+    exepath_sep = exepath + os.path.sep
+    assert exitcode == 1, stdout
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for addon 'addon/misra.py'",
+        "looking for addon '{}addon/misra.py'".format(exepath_sep),
+        "looking for addon '{}addons/addon/misra.py'".format(exepath_sep),  # TODO: mixed separators
+        'Did not find addon addon/misra.py'
+    ]
+
+
+def test_addon_lookup_relative_noext_notfound(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, _, exe = cppcheck_ex(['--debug-lookup=addon', '--addon=addon/misra', test_file])
+    exepath = os.path.dirname(exe)
+    exepath_sep = exepath + os.path.sep
+    assert exitcode == 1, stdout
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for addon 'addon/misra.py'",
+        "looking for addon '{}addon/misra.py'".format(exepath_sep),
+        "looking for addon '{}addons/addon/misra.py'".format(exepath_sep),  # TODO: mixed separators
+        'Did not find addon addon/misra.py'
+    ]
+
+
+def test_addon_lookup_absolute(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    addon_file = os.path.join(tmpdir, 'test.py')
+    with open(addon_file, 'wt') as f:
+        f.write('''''')
+
+    exitcode, stdout, stderr = cppcheck(['--debug-lookup=addon', '--addon={}'.format(addon_file), test_file])
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for addon '{}'".format(addon_file),
+        'Checking {} ...'.format(test_file)
+    ]
+
+
+def test_addon_lookup_absolute_notfound(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    addon_file = os.path.join(tmpdir, 'test.py')
+
+    exitcode, stdout, stderr = cppcheck(['--debug-lookup=addon', '--addon={}'.format(addon_file), test_file])
+    assert exitcode == 1, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for addon '{}'".format(addon_file),
+        'Did not find addon {}'.format(addon_file)
+    ]
+
+
+def test_addon_lookup_nofile(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    # make sure we do not produce an error when the attempted lookup path is a directory and not a file
+    misra_dir = os.path.join(tmpdir, 'misra')
+    os.mkdir(misra_dir)
+    misra_cfg_dir = os.path.join(tmpdir, 'misra.py')
+    os.mkdir(misra_cfg_dir)
+
+    exitcode, stdout, stderr, exe = cppcheck_ex(['--debug-lookup=addon', '--addon=misra', test_file])
+    exepath = os.path.dirname(exe)
+    exepath_sep = exepath + os.path.sep
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for addon 'misra.py'",
+        "looking for addon '{}misra.py'".format(exepath_sep),
+        "looking for addon '{}addons/misra.py'".format(exepath_sep),  # TODO: mixed separators
+        'Checking {} ...'.format(test_file)
+    ]
+
+
+# make sure we bail out when we encounter an invalid file
+def test_addon_lookup_invalid(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    misra_py_file = os.path.join(tmpdir, 'misra.py')
+    with open(misra_py_file, 'wt') as f:
+        f.write('''<def/>''')
+
+    exitcode, stdout, stderr = cppcheck(['--debug-lookup=addon', '--addon=misra', test_file], cwd=tmpdir)
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for addon 'misra.py'",
+        'Checking {} ...'.format(test_file)  # TODO: should bail out
+    ]
+
+
+def test_config_lookup(tmpdir):
+    cppcheck_exe = __lookup_cppcheck_exe()
+    bin_dir = os.path.dirname(cppcheck_exe)
+    tmp_cppcheck_exe = shutil.copy2(cppcheck_exe, tmpdir)
+    if sys.platform == 'win32':
+        shutil.copy2(os.path.join(bin_dir, 'cppcheck-core.dll'), tmpdir)
+    shutil.copytree(os.path.join(bin_dir, 'cfg'), os.path.join(tmpdir, 'cfg'))
+
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    config_file = os.path.join(tmpdir, 'cppcheck.cfg')
+    with open(config_file, 'wt') as f:
+        f.write('{}')
+
+    exitcode, stdout, stderr, exe = cppcheck_ex(['--debug-lookup=config', test_file], cwd=tmpdir, cppcheck_exe=tmp_cppcheck_exe)
+    exepath = os.path.dirname(exe)
+    exepath_sep = exepath + os.path.sep
+    exepath_sep = exepath_sep.replace('\\', '/')
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for '{}cppcheck.cfg'".format(exepath_sep),
+        'Checking {} ...'.format(test_file)
+    ]
+
+
+def test_config_lookup_notfound(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    exitcode, stdout, stderr, exe = cppcheck_ex(['--debug-lookup=config', test_file])
+    exepath = os.path.dirname(exe)
+    exepath_sep = exepath + os.path.sep
+    exepath_sep = exepath_sep.replace('\\', '/')
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for '{}cppcheck.cfg'".format(exepath_sep),
+        'no configuration found',
+        'Checking {} ...'.format(test_file)
+    ]
+
+
+def test_config_invalid(tmpdir):
+    cppcheck_exe = __lookup_cppcheck_exe()
+    bin_dir = os.path.dirname(cppcheck_exe)
+    tmp_cppcheck_exe = shutil.copy2(cppcheck_exe, tmpdir)
+    if sys.platform == 'win32':
+        shutil.copy2(os.path.join(bin_dir, 'cppcheck-core.dll'), tmpdir)
+    shutil.copytree(os.path.join(bin_dir, 'cfg'), os.path.join(tmpdir, 'cfg'))
+
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    config_file = os.path.join(tmpdir, 'cppcheck.cfg')
+    with open(config_file, 'wt'):
+        pass
+
+    exitcode, stdout, stderr, exe = cppcheck_ex(['--debug-lookup=config', test_file], cwd=tmpdir, cppcheck_exe=tmp_cppcheck_exe)
+    exepath = os.path.dirname(exe)
+    exepath_sep = exepath + os.path.sep
+    exepath_sep = exepath_sep.replace('\\', '/')
+    assert exitcode == 1, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        "looking for '{}cppcheck.cfg'".format(exepath_sep),
+        'cppcheck: error: could not load cppcheck.cfg - not a valid JSON - syntax error at line 1 near: '
+    ]
+
+# TODO: test with FILESDIR
+
+@pytest.mark.parametrize("type,file", [("addon", "misra.py"), ("config", "cppcheck.cfg"), ("library", "gnu.cfg"), ("platform", "avr8.xml")])
+def test_lookup_path(tmpdir, type, file):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    cppcheck = 'cppcheck' # No path
+    path = os.path.dirname(__lookup_cppcheck_exe())
+    env = os.environ.copy()
+    env['PATH'] = path + (';' if sys.platform == 'win32' else ':') + env.get('PATH', '')
+    if type == 'config':
+        with open(os.path.join(path, "cppcheck.cfg"), 'wt') as f:
+            f.write('{}')
+        exitcode, stdout, stderr, _ = cppcheck_ex(args=[f'--debug-lookup={type}', test_file], cppcheck_exe=cppcheck, cwd=str(tmpdir), env=env)
+        os.remove(os.path.join(path, "cppcheck.cfg")) # clean up otherwise other tests may fail
+    else:
+        exitcode, stdout, stderr, _ = cppcheck_ex(args=[f'--debug-lookup={type}', f'--{type}={file}', test_file], cppcheck_exe=cppcheck, cwd=str(tmpdir), env=env)
+    assert exitcode == 0, stdout if stdout else stderr
+    def format_path(p):
+        return p.replace('\\', '/').replace('"', '\'')
+    lines = format_path(stdout).splitlines()
+
+    if type == 'addon':
+        def try_fail(f):
+            return f"looking for {type} '{format_path(f)}'"
+        def try_success(f):
+            return f"looking for {type} '{format_path(f)}'"
+        assert lines == [
+            f"looking for {type} '{file}'",
+            try_fail(os.path.join(path, file)),
+            try_success(os.path.join(path, 'addons', file)),
+            f'Checking {format_path(test_file)} ...'
+        ]
+    elif type == 'config':
+        def try_success(f):
+            return f"looking for '{format_path(f)}'"
+        assert lines == [
+            try_success(os.path.join(path, file)),
+            f'Checking {format_path(test_file)} ...'
+        ]
+    elif type == 'platform':
+        def try_fail(f):
+            f = format_path(f)
+            return f"try to load {type} file '{f}' ... Error=XML_ERROR_FILE_NOT_FOUND ErrorID=3 (0x3) Line number=0: filename={f}"
+        def try_success(f):
+            f = format_path(f)
+            return f"try to load {type} file '{f}' ... Success"
+        assert lines == [
+            f"looking for {type} '{file}'",
+            try_fail(os.path.join(tmpdir, file)),
+            try_fail(os.path.join(tmpdir, 'platforms', file)),
+            try_fail(os.path.join(path, file)),
+            try_success(os.path.join(path, 'platforms', file)),
+            f'Checking {format_path(test_file)} ...'
+        ]
+    elif type == 'library':
+        def try_fail(f):
+            return f"looking for {type} '{format_path(f)}'"
+        def try_success(f):
+            return f"looking for {type} '{format_path(f)}'"
+        assert lines == [
+            f"looking for {type} 'std.cfg'",
+            try_fail(os.path.join(path, 'std.cfg')),
+            try_success(os.path.join(path, 'cfg', 'std.cfg')),
+            f"looking for {type} '{file}'",
+            try_fail(os.path.join(path, file)),
+            try_success(os.path.join(path, 'cfg', file)),
+            f'Checking {format_path(test_file)} ...'
+        ]
+    else:
+        assert False, type + " not tested properly"
\ No newline at end of file
diff --git a/test/cli/metrics_test.py b/test/cli/metrics_test.py
new file mode 100644
index 00000000000..6f5c7041dab
--- /dev/null
+++ b/test/cli/metrics_test.py
@@ -0,0 +1,78 @@
+# python -m pytest metrics_test.py
+
+import os
+from testutils import cppcheck
+
+__script_dir = os.path.dirname(os.path.abspath(__file__))
+__addon_output = """
+{"metric":{"fileName":"1.cpp","function":"write","id":"HISCall","lineNumber":6,"value":2}}
+{"metric":{"fileName":"1.cpp","function":"write","id":"HISGoto","lineNumber":6,"value":0}}
+{"metric":{"fileName":"1.cpp","function":"write","id":"HISLevel","lineNumber":6,"value":2}}
+{"metric":{"fileName":"1.cpp","function":"write","id":"HISParam","lineNumber":6,"value":2}}
+{"metric":{"fileName":"1.cpp","function":"write","id":"HISPath","lineNumber":6,"value":3}}
+{"metric":{"fileName":"1.cpp","function":"write","id":"HISReturn","lineNumber":6,"value":0}}
+{"metric":{"fileName":"1.cpp","function":"write","id":"HISStmt","lineNumber":6,"value":15}}
+{"metric":{"fileName":"1.cpp","function":"write","id":"cyclomaticComplexity","lineNumber":6,"value":3}}
+"""
+__addon_source = f'print("""{__addon_output}""")'
+__expected_xml = [
+    '<metric fileName="1.cpp" function="write" id="HISCall" lineNumber="6" value="2"/>',
+    '<metric fileName="1.cpp" function="write" id="HISGoto" lineNumber="6" value="0"/>',
+    '<metric fileName="1.cpp" function="write" id="HISLevel" lineNumber="6" value="2"/>',
+    '<metric fileName="1.cpp" function="write" id="HISParam" lineNumber="6" value="2"/>',
+    '<metric fileName="1.cpp" function="write" id="HISPath" lineNumber="6" value="3"/>',
+    '<metric fileName="1.cpp" function="write" id="HISReturn" lineNumber="6" value="0"/>',
+    '<metric fileName="1.cpp" function="write" id="HISStmt" lineNumber="6" value="15"/>',
+    '<metric fileName="1.cpp" function="write" id="cyclomaticComplexity" lineNumber="6" value="3"/>'
+]
+
+def __create_addon(tmpdir):
+    path = os.path.join(tmpdir, 'addon.py')
+    with open(path, 'w') as file:
+        file.write(__addon_source)
+    return path
+
+def __create_source_file(tmpdir):
+    path = os.path.join(tmpdir, 'test.c')
+    with open(path, 'w') as _:
+        pass
+    return path
+
+def test_dummy_metrics_xml_report(tmpdir):
+    output_file = os.path.join(tmpdir, "results.xml")
+    source_path = __create_source_file(tmpdir)
+    addon_path = __create_addon(tmpdir)
+    args = [
+        f'--output-file={output_file}',
+        f'--addon={addon_path}',
+        '--xml-version=3',
+        source_path
+    ]
+
+    ret, stdout, stderr = cppcheck(args)
+    assert ret == 0
+    assert stderr == ''
+    assert stdout == f'Checking {source_path} ...\n'
+
+    with open(output_file, 'r') as file:
+        xml = file.read()
+
+    for expected in __expected_xml:
+        assert xml.find(expected) >= 0
+
+def test_dummy_metrics_stdout(tmpdir):
+    source_path = __create_source_file(tmpdir)
+    addon_path = __create_addon(tmpdir)
+    args = [
+        f'--addon={addon_path}',
+        '--xml-version=3',
+        source_path
+    ]
+
+    ret, stdout, stderr = cppcheck(args)
+    assert ret == 0
+    assert stdout == f'Checking {source_path} ...\n'
+
+    for expected in __expected_xml:
+        assert stderr.find(expected) >= 0
+
diff --git a/test/cli/more-projects_test.py b/test/cli/more-projects_test.py
new file mode 100644
index 00000000000..73d738d9cfb
--- /dev/null
+++ b/test/cli/more-projects_test.py
@@ -0,0 +1,1077 @@
+# python -m pytest test-more-projects.py
+import json
+import os
+import pytest
+import sys
+from testutils import cppcheck, assert_cppcheck
+
+__script_dir = os.path.dirname(os.path.abspath(__file__))
+
+def test_project_force_U(tmpdir):
+    # 10018
+    # -U does not work with compile_commands.json
+    with open(os.path.join(tmpdir, 'bug1.cpp'), 'wt') as f:
+        f.write("""
+                int x = 123 / 0;
+                #ifdef MACRO1
+                int y = 1000 / 0;
+                #endif
+                """)
+
+    compile_commands = os.path.join(tmpdir, 'compile_commands.json')
+
+    compilation_db = [
+        {"directory": str(tmpdir),
+         "command": "c++ -o bug1.o -c bug1.cpp",
+         "file": "bug1.cpp",
+         "output": "bug1.o"}
+    ]
+
+    with open(compile_commands, 'wt') as f:
+        f.write(json.dumps(compilation_db))
+
+    # Without -U => both bugs are found
+    ret, stdout, stderr = cppcheck(['--project=' + compile_commands, '--force', '-rp=' + str(tmpdir), '--template=cppcheck1'])
+    assert ret == 0, stdout
+    assert (stderr == '[bug1.cpp:2]: (error) Division by zero.\n'
+                      '[bug1.cpp:4]: (error) Division by zero.\n')
+
+    # With -U => only first bug is found
+    ret, stdout, stderr = cppcheck(['--project=' + compile_commands, '--force', '-UMACRO1', '-rp=' + str(tmpdir), '--template=cppcheck1'])
+    assert ret == 0, stdout
+    assert stderr == '[bug1.cpp:2]: (error) Division by zero.\n'
+
+
+def __write_cppcheck_project_file(tmpdir, platform=None, importproject=None):
+    project_file = os.path.join(tmpdir, 'Project.cppcheck')
+
+    if platform is not None:
+        platform = '<platform>{}</platform>'.format(platform)
+    if importproject is not None:
+        platform = '<importproject>{}</importproject>'.format(importproject)
+
+    with open(project_file, 'wt') as f:
+        f.write(
+"""<?xml version="1.0" encoding="UTF-8"?>
+<project version="1">
+    {}
+    {}
+    <paths>
+        <dir name="."/>
+    </paths>
+</project>""".format(platform, importproject)
+        )
+
+    return project_file
+
+
+def test_project_custom_platform(tmpdir):
+    """
+    import cppcheck project that contains a custom platform file
+    """
+    project_file = __write_cppcheck_project_file(tmpdir, platform='p1.xml')
+
+    with open(os.path.join(tmpdir, 'p1.xml'), 'wt') as f:
+        f.write('<?xml version="1.0"?>\n<platform/>')
+
+    with open(os.path.join(tmpdir, '1.c'), 'wt') as f:
+        f.write("int x;")
+
+    ret, stdout, stderr = cppcheck(['--project=' + project_file, '--template=cppcheck1', '-q'])
+    assert ret == 0, stdout
+    assert stdout == ''
+    assert stderr == ''
+
+
+def test_project_empty_platform(tmpdir):
+    """
+    import cppcheck project that contains an empty platform type
+    """
+    project_file = __write_cppcheck_project_file(tmpdir, platform='')
+
+    with open(os.path.join(tmpdir, '1.c'), 'wt') as f:
+        f.write("int x;")
+
+    ret, stdout, stderr = cppcheck(['--project=' + project_file, '--template=cppcheck1', '-q'])
+    assert ret == 0, stdout
+    assert stdout == ''
+    assert stderr == ''
+
+
+def test_project_unspecified_platform(tmpdir):
+    """
+    import cppcheck project that contains the deprecated platform type "Unspecified"
+    """
+    project_file = __write_cppcheck_project_file(tmpdir, platform='Unspecified')
+
+    with open(os.path.join(tmpdir, '1.c'), 'wt') as f:
+        f.write("int x;")
+
+    ret, stdout, stderr = cppcheck(['--project=' + project_file, '--template=cppcheck1', '-q'])
+    assert ret == 1, stdout
+    assert stdout == "cppcheck: error: unrecognized platform: 'Unspecified'.\n"
+    assert stderr == ''
+
+
+def test_project_unknown_platform(tmpdir):
+    """
+    import cppcheck project that contains an unknown platform type
+    """
+    project_file = __write_cppcheck_project_file(tmpdir, platform='dummy')
+
+    with open(os.path.join(tmpdir, '1.c'), 'wt') as f:
+        f.write("int x;")
+
+    ret, stdout, stderr = cppcheck(['--project=' + project_file, '--template=cppcheck1'])
+    assert ret == 1, stdout
+    assert stdout == "cppcheck: error: unrecognized platform: 'dummy'.\n"
+    assert stderr == ''
+
+
+def test_project_empty_fields(tmpdir):
+    """
+    import cppcheck project that contains all empty fields - make sure there are no crashes
+    """
+    project_file = os.path.join(tmpdir, 'Project.cppcheck')
+
+    with open(project_file, 'wt') as f:
+        f.write(
+"""<?xml version="1.0" encoding="UTF-8"?>
+<project version="1">
+  <root/>
+  <builddir/>
+  <includedir/>
+  <includedir>
+    <dir/>
+  </includedir>
+  <defines/>
+  <defines>
+    <define/>
+  </defines>
+  <undefines/>
+  <undefines>
+    <undefine/>
+  </undefines>
+  <importproject/>
+  <paths/>
+  <paths>
+    <dir/>
+  </paths>
+  <exclude/>
+  <exclude>
+    <path/>
+  </exclude>
+  <function-contracts/>
+  <variable-contracts/>
+  <ignore/>
+  <ignore>
+    <path/>
+  </ignore>
+  <libraries/>
+  <libraries>
+    <library/>
+  </libraries>
+  <suppressions/>
+  <suppressions>
+    <suppression/>
+  </suppressions>
+  <vs-configurations/>
+  <vs-configurations>
+    <config/>
+  </vs-configurations>
+  <platform/>
+  <analyze-all-vs-configs/>
+  <parser/>
+  <addons/>
+  <addons>
+    <addon/>
+  </addons>
+  <tags/>
+  <tools/>
+  <tools>
+    <tool/>
+  </tools>
+  <check-headers/>
+  <check-unused-templates/>
+  <max-ctu-depth/>
+  <max-template-recursion/>
+  <check-unknown-function-return-values/>
+  <safe-checks/>
+  <safe-checks>
+    <class-public/>
+    <external-functions/>
+    <internal-functions/>
+    <external-variables/>
+  </safe-checks>
+  <tag-warnings/>
+  <bug-hunting/>
+  <cert-c-int-precision/>
+  <coding-standards/>
+  <coding-standards>
+    <coding-standard/>
+  </coding-standards>
+</project>""")
+
+    ret, stdout, stderr = cppcheck(['--project=' + project_file, '--template=cppcheck1'])
+    assert ret == 1, stdout # do not crash
+    assert stdout == 'cppcheck: error: no C or C++ source files found.\n'
+    assert stderr == ''
+
+
+def test_project_missing_subproject(tmpdir):
+    """
+    import cppcheck project that contains an unknown platform type
+    """
+    project_file = __write_cppcheck_project_file(tmpdir, importproject='dummy.json')
+
+    ret, stdout, stderr = cppcheck(['--project=' + project_file, '--template=cppcheck1'])
+    assert ret == 1, stdout
+    assert stdout == "cppcheck: error: failed to open project '{}/dummy.json'. The file does not exist.\n".format(str(tmpdir).replace('\\', '/'))
+    assert stderr == ''
+
+
+def test_project_std(tmpdir):
+    with open(os.path.join(tmpdir, 'bug1.cpp'), 'wt') as f:
+        f.write("""
+                #if __cplusplus == 201402L
+                int x = 123 / 0;
+                #endif
+                """)
+
+    compile_commands = os.path.join(tmpdir, 'compile_commands.json')
+
+    compilation_db = [
+        {
+            "directory": str(tmpdir),
+            "command": "c++ -o bug1.o -c bug1.cpp -std=c++14",
+            "file": "bug1.cpp",
+            "output": "bug1.o"
+        }
+    ]
+
+    with open(compile_commands, 'wt') as f:
+        f.write(json.dumps(compilation_db))
+
+    ret, stdout, stderr = cppcheck(['--project=' + compile_commands, '--enable=all', '-rp=' + str(tmpdir), '--template=cppcheck1'])
+    assert ret == 0, stdout
+    assert (stderr == '[bug1.cpp:3]: (error) Division by zero.\n')
+
+
+
+@pytest.mark.skip() # clang-tidy is not available in all cases
+def test_clang_tidy(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        f.write("""
+                int main(int argc)
+                {
+                  (void)argc;
+                }
+                """)
+
+    project_file = os.path.join(tmpdir, 'test.cppcheck')
+    with open(project_file, 'wt') as f:
+        f.write(
+            """<?xml version="1.0" encoding="UTF-8"?>
+<project version="1">
+  <paths>
+   <dir name="{}"/>
+  </paths>>
+  <tools>
+    <tool>clang-tidy</tool>
+  </tools>
+</project>""".format(test_file))
+
+    args = ['--project={}'.format(project_file)]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    lines = stdout.splitlines()
+    # TODO: should detect clang-tidy issue
+    assert len(lines) == 1
+    assert lines == [
+        'Checking {} ...'.format(test_file)
+    ]
+    assert stderr == ''
+
+
+@pytest.mark.parametrize("file_filter", [
+    ['--file-filter=test.cpp'],
+    ['--file-filter=*.cpp'],
+    ['--file-filter=+', 'test.cpp'],
+    ['--file-filter=+', '*.cpp'],
+])
+def test_project_file_filter(tmpdir, file_filter):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        pass
+
+    project_file = os.path.join(tmpdir, 'test.cppcheck')
+    with open(project_file, 'wt') as f:
+        f.write(
+            """<?xml version="1.0" encoding="UTF-8"?>
+<project>
+    <paths>
+        <dir name="{}"/>
+    </paths>
+</project>""".format(test_file))
+
+    args = file_filter + ['--project={}'.format(project_file)]
+    out_lines = [
+        'Checking {} ...'.format(test_file)
+    ]
+
+    assert_cppcheck(args, ec_exp=0, err_exp=[], out_exp=out_lines)
+
+
+@pytest.mark.parametrize("file_filter", [
+    ['--file-filter=*.cpp'],
+    ['--file-filter=+', '*.cpp'],
+])
+def test_project_file_filter_cpp(tmpdir, file_filter):
+    test_file_1 = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file_1, 'wt') as f:
+        pass
+    test_file_2 = os.path.join(tmpdir, 'test.c')
+    with open(test_file_2, 'wt') as f:
+        pass
+
+    project_file = os.path.join(tmpdir, 'test.cppcheck')
+    with open(project_file, 'wt') as f:
+        f.write(
+            """<?xml version="1.0" encoding="UTF-8"?>
+<project>
+    <paths>
+        <dir name="{}"/>
+        <dir name="{}"/>
+    </paths>
+</project>""".format(test_file_1, test_file_2))
+
+    args = file_filter + ['--project={}'.format(project_file)]
+    out_lines = [
+        'Checking {} ...'.format(test_file_1)
+    ]
+
+    assert_cppcheck(args, ec_exp=0, err_exp=[], out_exp=out_lines)
+
+
+@pytest.mark.parametrize("file_filter", [
+    ['--file-filter=*.c'],
+    ['--file-filter=+', '*.c'],
+])
+def test_project_file_filter_c(tmpdir, file_filter):
+    test_file_1 = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file_1, 'wt') as f:
+        pass
+    test_file_2 = os.path.join(tmpdir, 'test.c')
+    with open(test_file_2, 'wt') as f:
+        pass
+
+    project_file = os.path.join(tmpdir, 'test.cppcheck')
+    with open(project_file, 'wt') as f:
+        f.write(
+            """<?xml version="1.0" encoding="UTF-8"?>
+<project>
+    <paths>
+        <dir name="{}"/>
+        <dir name="{}"/>
+    </paths>
+</project>""".format(test_file_1, test_file_2))
+
+    args = file_filter + ['--project={}'.format(project_file)]
+    out_lines = [
+        'Checking {} ...'.format(test_file_2)
+    ]
+
+    assert_cppcheck(args, ec_exp=0, err_exp=[], out_exp=out_lines)
+
+
+def test_project_relpath_file_filter_abspath(tmpdir):
+    """
+    relative paths in project file, absolute path in file filter
+    """
+    test_file_cpp = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file_cpp, 'wt') as f:
+        pass
+    test_file_c = os.path.join(tmpdir, 'test.c')
+    with open(test_file_c, 'wt') as f:
+        pass
+
+    project_file = os.path.join(tmpdir, 'test.cppcheck')
+    with open(project_file, 'wt') as f:
+        f.write(
+            """<?xml version="1.0" encoding="UTF-8"?>
+<project>
+    <paths>
+        <dir name="test.cpp"/>
+        <dir name="test.c"/>
+    </paths>
+</project>""")
+
+    out_lines = [
+        'Checking test.c ...'
+    ]
+
+    args = ['--file-filter={}'.format(test_file_c), '--project=test.cppcheck']
+    assert_cppcheck(args, ec_exp=0, err_exp=[], out_exp=out_lines, cwd=tmpdir)
+
+
+def test_project_abspath_file_filter_relpath(tmpdir):
+    """
+    absolute paths in project file, relative path in file filter
+    """
+    test_file_cpp = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file_cpp, 'wt') as f:
+        pass
+    test_file_c = os.path.join(tmpdir, 'test.c')
+    with open(test_file_c, 'wt') as f:
+        pass
+
+    project_file = os.path.join(tmpdir, 'test.cppcheck')
+    with open(project_file, 'wt') as f:
+        f.write(
+            """<?xml version="1.0" encoding="UTF-8"?>
+<project>
+    <paths>
+        <dir name="{}"/>
+        <dir name="{}"/>
+    </paths>
+</project>""".format(test_file_c, test_file_cpp))
+
+    out_lines = [
+        'Checking {} ...'.format(test_file_c)
+    ]
+
+    args = ['--file-filter=test.c', '--project=test.cppcheck']
+    assert_cppcheck(args, ec_exp=0, err_exp=[], out_exp=out_lines, cwd=tmpdir)
+
+
+def test_project_pathmatch_other_cwd(tmpdir):
+    """
+    mixed relative and absolute paths in project file and on command line, executed in a different directory
+    """
+    test_root = tmpdir
+    test_cwd = os.path.join(test_root, 'cwd')
+    test_dir_1 = os.path.join(test_root, 'a')
+    test_dir_2 = os.path.join(test_root, 'b')
+    test_dir_3 = os.path.join(test_cwd, 'b')
+
+    os.mkdir(test_cwd)
+    os.mkdir(test_dir_1)
+    os.mkdir(test_dir_2)
+    os.mkdir(test_dir_3)
+
+    test_file_1 = os.path.join(test_dir_1, 'a-abs.c')
+    with open(test_file_1, 'wt') as f:
+        pass
+
+    test_file_2 = os.path.join(test_dir_1, 'a-rel.c')
+    with open(test_file_2, 'wt') as f:
+        pass
+
+    test_file_3 = os.path.join(test_dir_2, 'b-abs.c')
+    with open(test_file_3, 'wt') as f:
+        pass
+
+    test_file_4 = os.path.join(test_dir_2, 'b-rel.c')
+    with open(test_file_4, 'wt') as f:
+        pass
+
+    test_file_5 = os.path.join(test_dir_3, 'b-abs.c')
+    with open(test_file_5, 'wt') as f:
+        pass
+
+    test_file_6 = os.path.join(test_dir_3, 'b-rel.c')
+    with open(test_file_6, 'wt') as f:
+        pass
+
+    project_file = os.path.join(test_root, 'test.cppcheck')
+    with open(project_file, 'wt') as f:
+        f.write(
+            """<?xml version="1.0" encoding="UTF-8"?>
+<project>
+    <exclude>
+        <path name="./?/"/>
+    </exclude>
+    <paths>
+        <dir name="{}"/>
+        <dir name="a/a-rel.c"/>
+        <dir name="{}"/>
+        <dir name="b/b-rel.c"/>
+        <dir name="{}"/>
+        <dir name="cwd/b/b-rel.c"/>
+    </paths>
+</project>""".format(test_file_1, test_file_3, test_file_5))
+
+    out_lines = [
+        'Checking {} ...'.format(test_file_5),
+        'Checking {} ...'.format(os.path.join("..", "cwd", "b", "b-rel.c")),
+    ]
+
+    args = ['--file-filter={}/*/?/**.c*'.format(test_root), '--project=../test.cppcheck']
+    exitcode, stdout, stderr = cppcheck(args, cwd=test_cwd)
+    stdout_lines = stdout.splitlines()
+    assert 0 == exitcode
+    assert '' == stderr
+    assert 4 == len(stdout_lines)
+    assert set(out_lines) <= set(stdout_lines)
+
+
+def test_project_file_filter_no_match(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        pass
+
+    project_file = os.path.join(tmpdir, 'test.cppcheck')
+    with open(project_file, 'wt') as f:
+        f.write(
+            """<?xml version="1.0" encoding="UTF-8"?>
+<project>
+    <paths>
+        <dir name="{}"/>
+    </paths>
+</project>""".format(test_file))
+
+    args = ['--file-filter=*.c', '--project={}'.format(project_file)]
+    out_lines = [
+        'cppcheck: error: could not find any files matching the filter:*.c'
+    ]
+
+    assert_cppcheck(args, ec_exp=1, err_exp=[], out_exp=out_lines)
+
+
+def test_project_file_order(tmpdir):
+    test_file_a = os.path.join(tmpdir, 'a.c')
+    with open(test_file_a, 'wt'):
+        pass
+    test_file_b = os.path.join(tmpdir, 'b.c')
+    with open(test_file_b, 'wt'):
+        pass
+    test_file_c = os.path.join(tmpdir, 'c.c')
+    with open(test_file_c, 'wt'):
+        pass
+    test_file_d = os.path.join(tmpdir, 'd.c')
+    with open(test_file_d, 'wt'):
+        pass
+
+    project_file = os.path.join(tmpdir, 'test.cppcheck')
+    with open(project_file, 'wt') as f:
+        f.write(
+            """<?xml version="1.0" encoding="UTF-8"?>
+<project>
+    <paths>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+    </paths>
+</project>""".format(test_file_c, test_file_d, test_file_b, test_file_a))
+
+    args = ['--project={}'.format(project_file), '-j1']
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file_c),
+        '1/4 files checked 25% done',
+        'Checking {} ...'.format(test_file_d),
+        '2/4 files checked 50% done',
+        'Checking {} ...'.format(test_file_b),
+        '3/4 files checked 75% done',
+        'Checking {} ...'.format(test_file_a),
+        '4/4 files checked 100% done'
+    ]
+    assert stderr == ''
+
+
+def test_project_file_duplicate(tmpdir):
+    test_file_a = os.path.join(tmpdir, 'a.c')
+    with open(test_file_a, 'wt'):
+        pass
+
+    project_file = os.path.join(tmpdir, 'test.cppcheck')
+    with open(project_file, 'wt') as f:
+        f.write(
+            """<?xml version="1.0" encoding="UTF-8"?>
+<project>
+    <paths>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+    </paths>
+</project>""".format(test_file_a, test_file_a, tmpdir))
+
+    args = ['--project={}'.format(project_file)]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file_a)
+    ]
+    assert stderr == ''
+
+
+def test_project_file_duplicate_2(tmpdir):
+    test_file_a = os.path.join(tmpdir, 'a.c')
+    with open(test_file_a, 'wt'):
+        pass
+    test_file_b = os.path.join(tmpdir, 'b.c')
+    with open(test_file_b, 'wt'):
+        pass
+    test_file_c = os.path.join(tmpdir, 'c.c')
+    with open(test_file_c, 'wt'):
+        pass
+
+    project_file = os.path.join(tmpdir, 'test.cppcheck')
+    with open(project_file, 'wt') as f:
+        f.write(
+            """<?xml version="1.0" encoding="UTF-8"?>
+<project>
+    <paths>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+    </paths>
+</project>""".format(test_file_c, test_file_a, test_file_b, tmpdir, test_file_b, test_file_c, test_file_a, tmpdir))
+
+    args = ['--project={}'.format(project_file), '-j1']
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file_c),
+        '1/3 files checked 33% done',
+        'Checking {} ...'.format(test_file_a),
+        '2/3 files checked 66% done',
+        'Checking {} ...'.format(test_file_b),
+        '3/3 files checked 100% done'
+    ]
+    assert stderr == ''
+
+
+def test_project_file_duplicate_3(tmpdir):  # #12834
+    test_file_a = os.path.join(tmpdir, 'a.c')
+    with open(test_file_a, 'wt'):
+        pass
+
+    # multiple ways to specify the same file
+    in_file_a = 'a.c'
+    in_file_b = os.path.join('.', 'a.c')
+    in_file_c = os.path.join('dummy', '..', 'a.c')
+    in_file_d = os.path.join(tmpdir, 'a.c')
+    in_file_e = os.path.join(tmpdir, '.', 'a.c')
+    in_file_f = os.path.join(tmpdir, 'dummy', '..', 'a.c')
+
+    project_file = os.path.join(tmpdir, 'test.cppcheck')
+    with open(project_file, 'wt') as f:
+        f.write(
+            """<?xml version="1.0" encoding="UTF-8"?>
+<project>
+    <paths>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+    </paths>
+</project>""".format(in_file_a, in_file_b, in_file_c, in_file_d, in_file_e, in_file_f, tmpdir))
+
+    args = ['--project={}'.format(project_file)]
+
+    exitcode, stdout, stderr = cppcheck(args, cwd=tmpdir)
+    assert exitcode == 0
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file_a)
+    ]
+    assert stderr == ''
+
+
+@pytest.mark.skipif(sys.platform != 'win32', reason="requires Windows")
+def test_project_file_duplicate_4(tmpdir):  # #12834
+    test_file_a = os.path.join(tmpdir, 'a.c')
+    with open(test_file_a, 'wt'):
+        pass
+
+    # multiple ways to specify the same file
+    in_file_a = 'a.c'
+    in_file_b = os.path.join('.', 'a.c')
+    in_file_c = os.path.join('dummy', '..', 'a.c')
+    in_file_d = os.path.join(tmpdir, 'a.c')
+    in_file_e = os.path.join(tmpdir, '.', 'a.c')
+    in_file_f = os.path.join(tmpdir, 'dummy', '..', 'a.c')
+
+    args1 = [in_file_a, in_file_b, in_file_c, in_file_d, in_file_e, in_file_f, str(tmpdir)]
+    args2 = []
+    for a in args1:
+        args2.append(a.replace('\\', '/'))
+
+    project_file = os.path.join(tmpdir, 'test.cppcheck')
+    with open(project_file, 'wt') as f:
+        f.write(
+            """<?xml version="1.0" encoding="UTF-8"?>
+<project>
+    <paths>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+        <dir name="{}"/>
+    </paths>
+</project>""".format(in_file_a, in_file_b, in_file_c, in_file_d, in_file_e, in_file_f, tmpdir,
+                     args2[0], args2[1], args2[2], args2[3], args2[4], args2[5], args2[6]))
+
+    args = ['--project={}'.format(project_file)]
+
+    exitcode, stdout, stderr = cppcheck(args, cwd=tmpdir)
+    assert exitcode == 0
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file_a)
+    ]
+    assert stderr == ''
+
+def test_project_file_ignore(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        pass
+
+    project_file = os.path.join(tmpdir, 'test.cppcheck')
+    with open(project_file, 'wt') as f:
+        f.write(
+            """<?xml version="1.0" encoding="UTF-8"?>
+<project>
+    <paths>
+        <dir name="{}"/>
+    </paths>
+</project>""".format(test_file))
+
+    args = ['-itest.cpp', '--project={}'.format(project_file)]
+    out_lines = [
+        'cppcheck: error: could not find or open any of the paths given.',
+        'cppcheck: Maybe all paths were ignored?'
+    ]
+
+    assert_cppcheck(args, ec_exp=1, err_exp=[], out_exp=out_lines)
+
+
+def test_project_file_ignore_2(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        pass
+
+    project_file = os.path.join(tmpdir, 'test.cppcheck')
+    with open(project_file, 'wt') as f:
+        f.write(
+            """<?xml version="1.0" encoding="UTF-8"?>
+<project>
+    <paths>
+        <dir name="{}"/>
+    </paths>
+    <exclude>
+        <path name="test.cpp"/>
+    </exclude>
+</project>""".format(test_file))
+
+    args = ['--project={}'.format(project_file)]
+    out_lines = [
+        'cppcheck: error: could not find or open any of the paths given.',
+        'cppcheck: Maybe all paths were ignored?'
+    ]
+
+    assert_cppcheck(args, ec_exp=1, err_exp=[], out_exp=out_lines)
+
+
+def test_project_file_ignore_3(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        pass
+
+    project_file = os.path.join(tmpdir, 'test.cppcheck')
+    with open(project_file, 'wt') as f:
+        f.write(
+            """<?xml version="1.0" encoding="UTF-8"?>
+<project>
+    <paths>
+        <dir name="{}"/>
+    </paths>
+    <ignore>
+        <path name="test.cpp"/>
+    </ignore>
+</project>""".format(test_file))
+
+    args = ['--project={}'.format(project_file)]
+    out_lines = [
+        'cppcheck: error: could not find or open any of the paths given.',
+        'cppcheck: Maybe all paths were ignored?'
+    ]
+
+    assert_cppcheck(args, ec_exp=1, err_exp=[], out_exp=out_lines)
+
+
+def test_json_file_ignore(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        pass
+
+    compilation_db = [
+        {"directory": str(tmpdir),
+         "command": "c++ -o bug1.o -c bug1.cpp",
+         "file": "test.cpp",
+         "output": "test.o"}
+    ]
+
+    project_file = os.path.join(tmpdir, 'test.json')
+    with open(project_file, 'wt') as f:
+        f.write(json.dumps(compilation_db))
+
+    args = ['-itest.cpp', '--project={}'.format(project_file)]
+    out_lines = [
+        'cppcheck: error: no C or C++ source files found.',
+        'cppcheck: all paths were ignored'
+    ]
+
+    assert_cppcheck(args, ec_exp=1, err_exp=[], out_exp=out_lines)
+
+
+def test_json_file_ignore_2(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        pass
+
+    compilation_db = [
+        {"directory": str(tmpdir),
+         "command": "c++ -o bug1.o -c bug1.cpp",
+         "file": "test.cpp",
+         "output": "test.o"}
+    ]
+
+    project_file = os.path.join(tmpdir, 'test.json')
+    with open(project_file, 'wt') as f:
+        f.write(json.dumps(compilation_db))
+
+    args = ['-i{}'.format(test_file), '--project={}'.format(project_file)]
+    out_lines = [
+        'cppcheck: error: no C or C++ source files found.',
+        'cppcheck: all paths were ignored'
+    ]
+
+    assert_cppcheck(args, ec_exp=1, err_exp=[], out_exp=out_lines)
+
+
+@pytest.mark.xfail(strict=True)
+def test_project_D(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        f.write("""
+#ifndef __GNUC__
+#error "requirement not met"
+#endif
+                """)
+
+    project_file = os.path.join(tmpdir, 'test.cppcheck')
+    with open(project_file, 'wt') as f:
+        f.write(
+            """
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="1">
+  <paths>
+   <dir name="{}"/>
+  </paths>
+</project>
+            """.format(test_file))
+
+    args = [
+        '--project=' + project_file,
+        '--template=simple',
+    ]
+    arg_D = ['-D__GNUC__']
+
+    out_expected = [
+        'Checking {} ...'.format(test_file),
+        'Checking {}: __GNUC__=1...'.format(test_file)
+    ]
+
+    args1 = args + arg_D
+    ret, stdout, stderr = cppcheck(args1)
+    assert stdout.splitlines() == out_expected
+    assert stderr.splitlines() == []
+    assert ret == 0, stdout
+
+    # TODO: -D__GNUC__ is lost
+    args2 = arg_D + args
+    ret, stdout, stderr = cppcheck(args2)
+    assert stdout.splitlines() == out_expected
+    assert stderr.splitlines() == []
+    assert ret == 0, stdout
+
+
+def test_compdb_D(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        f.write("""
+#ifndef __GNUC__
+#error "requirement not met"
+#endif
+                """)
+
+    compile_commands = os.path.join(tmpdir, 'compile_commands.json')
+    compilation_db = [
+        {"directory": str(tmpdir),
+         "command": "c++ -o test.o -c test.cpp",
+         "file": "test.cpp",
+         "output": "test.o"}
+    ]
+    with open(compile_commands, 'wt') as f:
+        f.write(json.dumps(compilation_db))
+
+    args = [
+        '--project=' + compile_commands,
+        '--template=simple',
+        ]
+    arg_D = ['-D__GNUC__']
+
+    out_expected = [
+        'Checking {} ...'.format(test_file),
+        'Checking {}: __GNUC__=1;...'.format(test_file)  # TODO: get rid of extra ;
+    ]
+
+    args1 = args + arg_D
+    ret, stdout, stderr = cppcheck(args1)
+    assert stdout.splitlines() == out_expected
+    assert stderr.splitlines() == []
+    assert ret == 0, stdout
+
+    args2 = arg_D + args
+    ret, stdout, stderr = cppcheck(args2)
+    assert stdout.splitlines() == out_expected
+    assert stderr.splitlines() == []
+    assert ret == 0, stdout
+
+
+def test_shared_items_project():
+    solution_file = os.path.join('shared-items-project', 'Solution.sln')
+
+    args = [
+        '--platform=win64',
+        '--project={}'.format(solution_file),
+        '--project-configuration=Release|x64'
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    assert exitcode == 0
+
+    # Assume no errors, and that shared items code files have been checked as well
+    assert '2/2 files checked ' in stdout  # only perform partial check since -j2 does not report a percentage right now
+    assert stderr == ''
+
+
+def test_project_file_nested(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt'):
+        pass
+
+    level3_file = tmp_path / 'level3.cppcheck'
+    with open(level3_file, 'wt') as f:
+        f.write(
+"""<project>
+    <paths>
+        <dir name="{}"/>
+    </paths>
+</project>""".format(test_file))
+
+    level2_file = tmp_path / 'level2.cppcheck'
+    with open(level2_file, 'wt') as f:
+        f.write(
+"""<project>
+    <importproject>level3.cppcheck</importproject>
+</project>""")
+
+    level1_file = tmp_path / 'level1.cppcheck'
+    with open(level1_file, 'wt') as f:
+        f.write(
+"""<project>
+    <importproject>level2.cppcheck</importproject>
+</project>""")
+
+    args = ['--project={}'.format(level1_file)]
+    out_lines = [
+        'cppcheck: error: nested Cppcheck GUI projects are not supported.'
+    ]
+
+    assert_cppcheck(args, ec_exp=1, err_exp=[], out_exp=out_lines)
+
+
+def test_project_file_no_analyze_all_vs_configs(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt'):
+        pass
+
+    project_path = tmp_path / 'project.cppcheck'
+    with open(project_path, 'wt') as f:
+        f.write(
+"""<project>
+    <analyze-all-vs-configs>false</analyze-all-vs-configs>
+    <paths>
+        <dir name="."/>
+    </paths>
+</project>""")
+
+    ret, stdout, stderr = cppcheck(['--project=' + str(project_path)])
+    assert ret == 0, stdout
+    assert stderr == ''
+
+
+@pytest.mark.parametrize("j,executor", [
+    (1, "thread"),
+    (2, "thread"),
+    (2, "process"),
+])
+def test_project_progress(tmp_path, j, executor):
+    if sys.platform == 'win32' and executor == "process":
+        pytest.skip("process executor not supported on Windows")
+
+    code = 'x = 1;'
+    with open(tmp_path / 'test1.c', 'wt') as f:
+        f.write(code)
+    with open(tmp_path / 'test2.c', 'wt') as f:
+        f.write(code)
+
+    compilation_db = [
+        {"directory": str(tmp_path),
+         "command": "gcc -c test1.c",
+         "file": "test1.c",
+         "output": "test1.o"},
+        {"directory": str(tmp_path),
+         "command": "gcc -c test2.c",
+         "file": "test2.c",
+         "output": "test2.o"},
+    ]
+
+    project_file = tmp_path / 'compile_commands.json'
+
+    with open(project_file, 'wt') as f:
+        f.write(json.dumps(compilation_db))
+
+    _, stdout, _ = cppcheck([f'--project={project_file}', f'-j{j}', f'--executor={executor}'])
+    assert '1/2 files checked 50% done' in stdout
+    assert '2/2 files checked 100% done' in stdout
diff --git a/test/cli/other_test.py b/test/cli/other_test.py
new file mode 100644
index 00000000000..8f543924ae7
--- /dev/null
+++ b/test/cli/other_test.py
@@ -0,0 +1,4366 @@
+
+# python -m pytest test-other.py
+
+import os
+import sys
+import pytest
+import glob
+import json
+import subprocess
+import shutil
+
+from testutils import cppcheck, assert_cppcheck, cppcheck_ex, __lookup_cppcheck_exe
+from xml.etree import ElementTree
+
+
+def __remove_verbose_log(l : list):
+    l.remove('Defines:')
+    l.remove('Undefines:')
+    l.remove('Includes:')
+    l.remove('Platform:native')
+    return l
+
+
+def test_missing_include(tmpdir):  # #11283
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write("""
+#include "test.h"
+""")
+
+    args = ['--enable=missingInclude', '--template=simple', test_file]
+
+    _, _, stderr = cppcheck(args)
+    assert stderr == '{}:2:2: information: Include file: "test.h" not found. [missingInclude]\n'.format(test_file)
+
+
+def __test_missing_include_check_config(tmpdir, use_j):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write("""
+                #include "test.h"
+                """)
+
+    # TODO: -rp is not working requiring the full path in the assert
+    args = '--check-config -rp={} {}'.format(tmpdir, test_file)
+    if use_j:
+        args = '-j2 ' + args
+
+    _, _, stderr = cppcheck(args.split())
+    assert stderr == '' # --check-config no longer reports the missing includes
+
+
+def test_missing_include_check_config(tmpdir):
+    __test_missing_include_check_config(tmpdir, False)
+
+
+def test_missing_include_check_config_j(tmpdir):
+    __test_missing_include_check_config(tmpdir, True)
+
+
+def test_missing_include_inline_suppr(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write("""
+                // cppcheck-suppress missingInclude
+                #include "missing.h"
+                // cppcheck-suppress missingIncludeSystem
+                #include <missing2.h>
+                """)
+
+    args = ['--enable=missingInclude', '--inline-suppr', test_file]
+
+    _, _, stderr = cppcheck(args)
+    assert stderr == ''
+
+
+def test_preprocessor_error(tmpdir):
+    test_file = os.path.join(tmpdir, '10866.c')
+    with open(test_file, 'wt') as f:
+        f.write('#error test\nx=1;\n')
+    exitcode, _, stderr = cppcheck(['--error-exitcode=1', test_file])
+    assert 'preprocessorErrorDirective' in stderr
+    assert exitcode != 0
+
+
+__ANSI_BOLD = "\x1b[1m"
+__ANSI_FG_RED = "\x1b[31m"
+__ANSI_FG_DEFAULT = "\x1b[39m"
+__ANSI_FG_RESET = "\x1b[0m"
+
+
+@pytest.mark.parametrize("env,color_expected", [({"CLICOLOR_FORCE":"1"}, True), ({"NO_COLOR": "1", "CLICOLOR_FORCE":"1"}, False)])
+def test_color_non_tty(tmpdir, env, color_expected):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write('#error test\nx=1;\n')
+    exitcode, stdout, stderr = cppcheck([test_file], env=env)
+
+    assert exitcode == 0, stdout if stdout else stderr
+    assert stderr
+    assert (__ANSI_BOLD in stderr) == color_expected
+    assert (__ANSI_FG_RED in stderr) == color_expected
+    assert (__ANSI_FG_DEFAULT in stderr) == color_expected
+    assert (__ANSI_FG_RESET in stderr) == color_expected
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="TTY not supported in Windows")
+@pytest.mark.parametrize("env,color_expected", [({}, True), ({"NO_COLOR": "1"}, False)])
+def test_color_tty(tmpdir, env, color_expected):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write('#error test\nx=1;\n')
+    exitcode, stdout, stderr = cppcheck([test_file], env=env, tty=True)
+
+    assert exitcode == 0, stdout if stdout else stderr
+    assert stderr
+    assert (__ANSI_BOLD in stderr) == color_expected
+    assert (__ANSI_FG_RED in stderr) == color_expected
+    assert (__ANSI_FG_DEFAULT in stderr) == color_expected
+    assert (__ANSI_FG_RESET in stderr) == color_expected
+
+
+def test_invalid_library(tmpdir):
+    args = ['--library=none', '--library=posix', '--library=none2', 'file.c']
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 1
+    assert (stdout == "cppcheck: Failed to load library configuration file 'none'. File not found\n"
+                      "cppcheck: Failed to load library configuration file 'none2'. File not found\n")
+    assert stderr == ""
+
+
+def test_message_j(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write("")
+
+    args = ['-j2', test_file]
+
+    _, stdout, _ = cppcheck(args)
+    assert stdout == "Checking {} ...\n".format(test_file) # we were adding stray \0 characters at the end
+
+# TODO: test missing std.cfg
+
+
+def test_progress(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write("""
+                int main(int argc)
+                {
+                }
+                """)
+
+    args = ['--report-progress=0', '--enable=all', '--inconclusive', '-j1', test_file]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout if stdout else stderr
+    pos = stdout.find('\n')
+    assert(pos != -1)
+    pos += 1
+    assert stdout[:pos] == "Checking {} ...\n".format(test_file)
+    assert (stdout[pos:] ==
+            "progress: Tokenize (typedef) 0%\n"
+            "progress: Tokenize (typedef) 12%\n"
+            "progress: Tokenize (typedef) 25%\n"
+            "progress: Tokenize (typedef) 37%\n"
+            "progress: Tokenize (typedef) 50%\n"
+            "progress: Tokenize (typedef) 62%\n"
+            "progress: Tokenize (typedef) 75%\n"
+            "progress: Tokenize (typedef) 87%\n"
+            "progress: Tokenize (typedef) 100%\n"
+            "progress: SymbolDatabase (find all scopes) 0%\n"
+            "progress: SymbolDatabase (find all scopes) 12%\n"
+            "progress: SymbolDatabase (find all scopes) 87%\n"
+            "progress: SymbolDatabase (find all scopes) 100%\n"
+            "progress: ValueFlow 0%\n"
+            "progress: ValueFlow::valueFlowImpossibleValues(tokenlist, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowImpossibleValues(tokenlist, settings) 1 100%\n"
+            "progress: ValueFlow::valueFlowSymbolicOperators(symboldatabase, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowSymbolicOperators(symboldatabase, settings) 1 100%\n"
+            "progress: ValueFlow::valueFlowCondition(SymbolicConditionHandler{}, tokenlist, symboldatabase, errorLogger, settings, skippedFunctions) 1 0%\n"
+            "progress: ValueFlow::valueFlowCondition(SymbolicConditionHandler{}, tokenlist, symboldatabase, errorLogger, settings, skippedFunctions) 1 100%\n"
+            "progress: ValueFlow::valueFlowSymbolicInfer(symboldatabase, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowSymbolicInfer(symboldatabase, settings) 1 100%\n"
+            "progress: ValueFlow::valueFlowArrayBool(tokenlist, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowArrayBool(tokenlist, settings) 1 100%\n"
+            "progress: ValueFlow::valueFlowArrayElement(tokenlist, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowArrayElement(tokenlist, settings) 1 100%\n"
+            "progress: ValueFlow::valueFlowRightShift(tokenlist, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowRightShift(tokenlist, settings) 1 100%\n"
+            "progress: ValueFlow::valueFlowCondition(ContainerConditionHandler{}, tokenlist, symboldatabase, errorLogger, settings, skippedFunctions) 1 0%\n"
+            "progress: ValueFlow::valueFlowCondition(ContainerConditionHandler{}, tokenlist, symboldatabase, errorLogger, settings, skippedFunctions) 1 100%\n"
+            "progress: ValueFlow::valueFlowAfterAssign(tokenlist, symboldatabase, errorLogger, settings, skippedFunctions) 1 0%\n"
+            "progress: ValueFlow::valueFlowAfterAssign(tokenlist, symboldatabase, errorLogger, settings, skippedFunctions) 1 100%\n"
+            "progress: ValueFlow::valueFlowAfterSwap(tokenlist, symboldatabase, errorLogger, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowAfterSwap(tokenlist, symboldatabase, errorLogger, settings) 1 100%\n"
+            "progress: ValueFlow::valueFlowCondition(SimpleConditionHandler{}, tokenlist, symboldatabase, errorLogger, settings, skippedFunctions) 1 0%\n"
+            "progress: ValueFlow::valueFlowCondition(SimpleConditionHandler{}, tokenlist, symboldatabase, errorLogger, settings, skippedFunctions) 1 100%\n"
+            "progress: ValueFlow::valueFlowInferCondition(tokenlist, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowInferCondition(tokenlist, settings) 1 100%\n"
+            "progress: ValueFlow::valueFlowSwitchVariable(tokenlist, symboldatabase, errorLogger, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowSwitchVariable(tokenlist, symboldatabase, errorLogger, settings) 1 100%\n"
+            "progress: ValueFlow::valueFlowForLoop(tokenlist, symboldatabase, errorLogger, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowForLoop(tokenlist, symboldatabase, errorLogger, settings) 1 100%\n"
+            "progress: ValueFlow::valueFlowSubFunction(tokenlist, symboldatabase, errorLogger, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowSubFunction(tokenlist, symboldatabase, errorLogger, settings) 1 100%\n"
+            "progress: ValueFlow::valueFlowFunctionReturn(tokenlist, errorLogger, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowFunctionReturn(tokenlist, errorLogger, settings) 1 100%\n"
+            "progress: ValueFlow::valueFlowLifetime(tokenlist, errorLogger, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowLifetime(tokenlist, errorLogger, settings) 1 100%\n"
+            "progress: ValueFlow::valueFlowFunctionDefaultParameter(tokenlist, symboldatabase, errorLogger, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowFunctionDefaultParameter(tokenlist, symboldatabase, errorLogger, settings) 1 100%\n"
+            "progress: ValueFlow::valueFlowUninit(tokenlist, errorLogger, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowUninit(tokenlist, errorLogger, settings) 1 100%\n"
+            "progress: ValueFlow::valueFlowAfterMove(tokenlist, symboldatabase, errorLogger, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowAfterMove(tokenlist, symboldatabase, errorLogger, settings) 1 100%\n"
+            "progress: ValueFlow::valueFlowSmartPointer(tokenlist, errorLogger, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowSmartPointer(tokenlist, errorLogger, settings) 1 100%\n"
+            "progress: ValueFlow::valueFlowIterators(tokenlist, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowIterators(tokenlist, settings) 1 100%\n"
+            "progress: ValueFlow::valueFlowCondition(IteratorConditionHandler{}, tokenlist, symboldatabase, errorLogger, settings, skippedFunctions) 1 0%\n"
+            "progress: ValueFlow::valueFlowCondition(IteratorConditionHandler{}, tokenlist, symboldatabase, errorLogger, settings, skippedFunctions) 1 100%\n"
+            "progress: ValueFlow::valueFlowIteratorInfer(tokenlist, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowIteratorInfer(tokenlist, settings) 1 100%\n"
+            "progress: ValueFlow::valueFlowContainerSize(tokenlist, symboldatabase, errorLogger, settings, skippedFunctions) 1 0%\n"
+            "progress: ValueFlow::valueFlowContainerSize(tokenlist, symboldatabase, errorLogger, settings, skippedFunctions) 1 100%\n"
+            "progress: ValueFlow::valueFlowSafeFunctions(tokenlist, symboldatabase, errorLogger, settings) 1 0%\n"
+            "progress: ValueFlow::valueFlowSafeFunctions(tokenlist, symboldatabase, errorLogger, settings) 1 100%\n"
+            "progress: ValueFlow 100%\n"
+            "progress: Run checkers 0%\n"
+            "progress: Run checkers 100%\n"
+            )
+    assert stderr == ""
+
+
+def test_progress_j(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write("""
+                int main(int argc)
+                {
+                }
+                """)
+
+    args = ['--report-progress=0', '--enable=all', '--inconclusive', '-j2', '--disable=unusedFunction', test_file]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout if stdout else stderr
+    assert stdout == "Checking {} ...\n".format(test_file)
+    assert stderr == ""
+
+
+def test_execute_addon_failure_py_auto(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        f.write("""
+                void f();
+                """)
+
+    args = ['--addon=naming', test_file]
+
+    # provide empty PATH environment variable so python is not found and execution of addon fails
+    env = {'PATH': ''}
+    _, _, stderr = cppcheck(args, env)
+    assert stderr == '{}:0:0: error: Bailing out from analysis: Checking file failed: Failed to auto detect python [internalError]\n\n^\n'.format(test_file)
+
+
+def test_execute_addon_failure_py_notexist(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        f.write("""
+                void f();
+                """)
+
+    # specify non-existent python executable so execution of addon fails
+    args = ['--addon=naming', '--addon-python=python5.x', test_file]
+
+    _, _, stderr = cppcheck(args)
+    ec = 1 if os.name == 'nt' else 127
+    assert stderr == "{}:0:0: error: Bailing out from analysis: Checking file failed: Failed to execute addon 'naming' - exitcode is {} [internalError]\n\n^\n".format(test_file, ec)
+
+
+def test_execute_addon_failure_json_notexist(tmpdir):
+    # specify non-existent python executable so execution of addon fails
+    addon_json = os.path.join(tmpdir, 'addon.json')
+    with open(addon_json, 'wt') as f:
+        f.write(json.dumps({'executable': 'notexist'}))
+
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        f.write("""
+                void f();
+                """)
+
+    args = [
+        '--addon={}'.format(addon_json),
+        test_file
+    ]
+
+    _, _, stderr = cppcheck(args)
+    ec = 1 if os.name == 'nt' else 127
+    assert stderr == "{}:0:0: error: Bailing out from analysis: Checking file failed: Failed to execute addon 'addon.json' - exitcode is {} [internalError]\n\n^\n".format(test_file, ec)
+
+
+@pytest.mark.skipif(sys.platform != "win32", reason="Windows specific issue")
+def test_execute_addon_path_with_spaces(tmpdir):
+    addon_json = os.path.join(tmpdir, 'addon.json')
+    addon_dir = os.path.join(tmpdir, 'A Folder')
+    addon_script = os.path.join(addon_dir, 'addon.bat')
+
+    with open(addon_json, 'wt') as f:
+        f.write(json.dumps({'executable': addon_script }))
+
+    os.makedirs(addon_dir, exist_ok=True)
+
+    with open(addon_script, 'wt') as f:
+        f.write('@echo {"file":"1.c","linenr":1,"column":1,"severity":"error","message":"hello world","errorId":"hello","addon":"test"}')
+
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        pass
+
+    args = [
+        '--addon={}'.format(addon_json),
+        test_file,
+    ]
+
+    _, _, stderr = cppcheck(args)
+
+    # Make sure the full command is used
+    assert '1.c:1:1: error: hello world [test-hello]\n' in stderr
+
+
+def test_execute_addon_failure_json_ctu_notexist(tmpdir):
+    # specify non-existent python executable so execution of addon fails
+    addon_json = os.path.join(tmpdir, 'addon.json')
+    with open(addon_json, 'wt') as f:
+        f.write(json.dumps({
+            'executable': 'notexist',
+            'ctu': True
+        }))
+
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        f.write("""
+                void f(); """)
+
+    args = [
+        '--template=simple',
+        '--addon={}'.format(addon_json),
+        test_file
+    ]
+
+    _, _, stderr = cppcheck(args)
+    ec = 1 if os.name == 'nt' else 127
+    assert stderr.splitlines() == [
+        "{}:0:0: error: Bailing out from analysis: Checking file failed: Failed to execute addon 'addon.json' - exitcode is {} [internalError]".format(test_file, ec),
+        ":0:0: error: Bailing out from analysis: Whole program analysis failed: Failed to execute addon 'addon.json' - exitcode is {} [internalError]".format(ec)
+    ]
+
+
+def test_execute_addon_file0(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write('void foo() {}\n')
+
+    args = ['--xml', '--addon=misra', '--enable=style', test_file]
+
+    _, _, stderr = cppcheck(args)
+    assert 'misra-c2012-8.2' in stderr
+    assert '.dump' not in stderr
+
+
+# TODO: find a test case which always fails
+@pytest.mark.skip
+def test_internal_error(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        f.write("""
+#include <cstdio>
+
+void f() {
+    double gc = 3333.3333;
+    char stat[80];
+    sprintf(stat,"'%2.1f'",gc);
+}
+                """)
+
+    args = [test_file]
+
+    _, _, stderr = cppcheck(args)
+    assert stderr == '{}:0:0: error: Bailing from out analysis: Checking file failed: converting \'1f\' to integer failed - not an integer [internalError]\n\n^\n'.format(test_file)
+
+
+def test_addon_ctu_exitcode(tmpdir):
+    """ #12440 - Misra ctu violations found => exit code should be non-zero """
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write("""typedef enum { BLOCK =  0x80U, } E;""")
+    args = ['--addon=misra', '--enable=style', '--error-exitcode=1', test_file]
+    exitcode, _, stderr = cppcheck(args)
+    assert '2.3' in stderr, stderr
+    assert exitcode == 1
+
+
+# TODO: test with -j2
+def test_addon_misra(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        f.write("""
+typedef int MISRA_5_6_VIOLATION;
+        """)
+
+    args = ['--addon=misra', '--enable=all', '--disable=unusedFunction', '-j1', test_file]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file)
+    ]
+    assert stderr == '{}:2:1: style: misra violation (use --rule-texts=<file> to get proper output) [misra-c2012-2.3]\ntypedef int MISRA_5_6_VIOLATION;\n^\n'.format(test_file)
+
+
+def test_addon_y2038(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    # TODO: trigger warning
+    with open(test_file, 'wt') as f:
+        f.write("""
+extern void f()
+{
+    time_t t = std::time(nullptr);
+    (void)t;
+}
+        """)
+
+    args = ['--addon=y2038', '--enable=all', '--disable=unusedFunction', '--template=simple', test_file]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file)
+    ]
+    assert stderr == '{}:4:21: warning: time is Y2038-unsafe [y2038-unsafe-call]\n'.format(test_file)
+
+
+def test_addon_threadsafety(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        f.write("""
+extern const char* f()
+{
+    return strerror(1);
+}
+        """)
+
+    args = ['--addon=threadsafety', '--enable=all', '--disable=unusedFunction', '--template=simple', test_file]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file)
+    ]
+    assert stderr == '{}:4:12: warning: strerror is MT-unsafe [threadsafety-unsafe-call]\n'.format(test_file)
+
+
+def test_addon_naming(tmpdir):
+    # the addon does nothing without a config
+    addon_file = os.path.join(tmpdir, 'naming1.json')
+    with open(addon_file, 'wt') as f:
+        f.write("""
+{
+    "script": "addons/naming.py",
+    "args": [
+        "--var=[_a-z].*"
+    ]
+}
+                """)
+
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        f.write("""
+int Var;
+        """)
+
+    args = ['--addon={}'.format(addon_file), '--enable=all', '--disable=unusedFunction', '--template=simple', test_file]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file)
+    ]
+    assert stderr == '{}:2:1: style: Variable Var violates naming convention [naming-varname]\n'.format(test_file)
+
+
+def test_addon_namingng(tmpdir):
+    addon_file = os.path.join(tmpdir, 'namingng.json')
+    addon_config_file = os.path.join(tmpdir, 'namingng.config.json')
+    with open(addon_file, 'wt') as f:
+        f.write("""
+{
+    "script": "addons/namingng.py",
+    "args": [
+        "--configfile=%s"
+    ]
+}
+                """%(addon_config_file).replace('\\','\\\\'))
+
+    with open(addon_config_file, 'wt') as f:
+        f.write("""
+{
+    "RE_FILE": [
+        "[^/]*[a-z][a-z0-9_]*[a-z0-9]\\.c\\Z"
+    ],
+    "RE_CLASS_NAME": ["[a-z][a-z0-9_]*[a-z0-9]\\Z"],
+    "RE_NAMESPACE": ["[a-z][a-z0-9_]*[a-z0-9]\\Z"],
+    "RE_VARNAME": ["[a-z][a-z0-9_]*[a-z0-9]\\Z"],
+    "RE_PUBLIC_MEMBER_VARIABLE": ["[a-z][a-z0-9_]*[a-z0-9]\\Z"],
+    "RE_PRIVATE_MEMBER_VARIABLE": {
+        ".*_tmp\\Z":[true,"illegal suffix _tmp"],
+        "priv_.*\\Z":[false,"required prefix priv_ missing"]
+    },
+    "RE_GLOBAL_VARNAME": ["[a-z][a-z0-9_]*[a-z0-9]\\Z"],
+    "RE_FUNCTIONNAME": ["[a-z][a-z0-9_]*[a-z0-9]\\Z"],
+    "include_guard": {
+        "input": "basename",
+        "prefix": "_",
+        "suffix": "",
+        "case": "upper",
+        "max_linenr": 5,
+        "RE_HEADERFILE": ".*\\.h\\Z",
+        "required": true
+    },
+    "var_prefixes": {"uint32_t": "ui32"},
+    "function_prefixes": {"uint16_t": "ui16",
+                          "uint32_t": "ui32"},
+    "skip_one_char_variables": false
+}
+                """.replace('\\','\\\\'))
+
+    test_unguarded_include_file_basename = 'test_unguarded.h'
+    test_unguarded_include_file = os.path.join(tmpdir, test_unguarded_include_file_basename)
+    with open(test_unguarded_include_file, 'wt') as f:
+        f.write("""
+void InvalidFunctionUnguarded();
+""")
+
+    test_include_file_basename = '_test.h'
+    test_include_file = os.path.join(tmpdir, test_include_file_basename)
+    with open(test_include_file, 'wt') as f:
+        f.write("""
+#ifndef TEST_H
+#define TEST_H
+
+void InvalidFunction();
+extern int _invalid_extern_global;
+
+#include "{}"
+
+#endif
+""".format(test_unguarded_include_file))
+
+    test_file_basename = 'test_.cpp'
+    test_file = os.path.join(tmpdir, test_file_basename)
+    with open(test_file, 'wt') as f:
+        f.write("""
+#include "%s"
+
+void invalid_function_();
+void _invalid_function();
+void valid_function1();
+void valid_function2(int _invalid_arg);
+void valid_function3(int invalid_arg_);
+void valid_function4(int valid_arg32);
+void valid_function5(uint32_t invalid_arg32);
+void valid_function6(uint32_t ui32_valid_arg);
+uint16_t invalid_function7(int valid_arg);
+uint16_t ui16_valid_function8(int valid_arg);
+
+int _invalid_global;
+static int _invalid_static_global;
+
+class _clz {
+public:
+    _clz() : _invalid_public(0), _invalid_private(0), priv_good(0), priv_bad_tmp(0) { }
+    int _invalid_public;
+private:
+    char _invalid_private;
+    int priv_good;
+    int priv_bad_tmp;
+};
+
+namespace _invalid_namespace { }
+        """%(test_include_file_basename))
+
+    args = ['--addon='+addon_file, '--verbose', '--enable=all', '--disable=unusedFunction', test_file]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = __remove_verbose_log(stdout.splitlines())
+    assert lines == [
+        'Checking {} ...'.format(test_file)
+    ]
+    lines = [line for line in stderr.splitlines() if line != '']
+    expect = [
+        '{}:0:0: style: File name {} violates naming convention [namingng-namingConvention]'.format(test_include_file,test_include_file_basename),
+        '^',
+        '{}:2:9: style: include guard naming violation; TEST_H != _TEST_H [namingng-includeGuardName]'.format(test_include_file),
+        '#ifndef TEST_H',
+        '        ^',
+        '{}:5:6: style: Function InvalidFunction violates naming convention [namingng-namingConvention]'.format(test_include_file),
+        'void InvalidFunction();',
+        '     ^',
+        '{}:6:12: style: Global variable _invalid_extern_global violates naming convention [namingng-namingConvention]'.format(test_include_file),
+        'extern int _invalid_extern_global;',
+        '           ^',
+
+        '{}:0:0: style: File name {} violates naming convention [namingng-namingConvention]'.format(test_unguarded_include_file,test_unguarded_include_file_basename),
+        '^',
+        '{}:0:0: style: Missing include guard [namingng-includeGuardMissing]'.format(test_unguarded_include_file),
+        '^',
+        '{}:2:6: style: Function InvalidFunctionUnguarded violates naming convention [namingng-namingConvention]'.format(test_unguarded_include_file),
+        'void InvalidFunctionUnguarded();',
+        '     ^',
+
+        '{}:0:0: style: File name {} violates naming convention [namingng-namingConvention]'.format(test_file,test_file_basename),
+        '^',
+        '{}:7:26: style: Variable _invalid_arg violates naming convention [namingng-namingConvention]'.format(test_file),
+        'void valid_function2(int _invalid_arg);',
+        '                         ^',
+        '{}:8:26: style: Variable invalid_arg_ violates naming convention [namingng-namingConvention]'.format(test_file),
+        'void valid_function3(int invalid_arg_);',
+        '                         ^',
+        '{}:10:31: style: Variable invalid_arg32 violates naming convention [namingng-namingConvention]'.format(test_file),
+        'void valid_function5(uint32_t invalid_arg32);',
+        '                              ^',
+        '{}:4:6: style: Function invalid_function_ violates naming convention [namingng-namingConvention]'.format(test_file),
+        'void invalid_function_();',
+        '     ^',
+        '{}:5:6: style: Function _invalid_function violates naming convention [namingng-namingConvention]'.format(test_file),
+        'void _invalid_function();',
+        '     ^',
+        '{}:12:10: style: Function invalid_function7 violates naming convention [namingng-namingConvention]'.format(test_file),
+        'uint16_t invalid_function7(int valid_arg);',
+        '         ^',
+        '{}:15:5: style: Global variable _invalid_global violates naming convention [namingng-namingConvention]'.format(test_file),
+        'int _invalid_global;',
+        '    ^',
+        '{}:16:12: style: Global variable _invalid_static_global violates naming convention [namingng-namingConvention]'.format(test_file),
+        'static int _invalid_static_global;',
+        '           ^',
+        '{}:20:5: style: Class Constructor _clz violates naming convention [namingng-namingConvention]'.format(test_file),
+        '    _clz() : _invalid_public(0), _invalid_private(0), priv_good(0), priv_bad_tmp(0) { }',
+        '    ^',
+        '{}:21:9: style: Public member variable _invalid_public violates naming convention [namingng-namingConvention]'.format(test_file),
+        '    int _invalid_public;',
+        '        ^',
+        '{}:23:10: style: Private member variable _invalid_private violates naming convention: required prefix priv_ missing [namingng-namingConvention]'.format(test_file),
+        '    char _invalid_private;',
+        '         ^',
+        '{}:25:9: style: Private member variable priv_bad_tmp violates naming convention: illegal suffix _tmp [namingng-namingConvention]'.format(test_file),
+        '    int priv_bad_tmp;',
+        '        ^',
+        '{}:28:11: style: Namespace _invalid_namespace violates naming convention [namingng-namingConvention]'.format(test_file),
+        'namespace _invalid_namespace { }',
+        '          ^',
+    ]
+    # test sorted lines; the order of messages may vary and is not of importance
+    lines.sort()
+    expect.sort()
+    assert lines == expect
+
+
+# TODO: test with -j2
+def test_addon_namingng_config(tmpdir):
+    addon_file = os.path.join(tmpdir, 'namingng.json')
+    addon_config_file = os.path.join(tmpdir, 'namingng.config.json')
+    with open(addon_file, 'wt') as f:
+        f.write("""
+{
+    "script": "addons/namingng.py",
+    "args": [
+        "--configfile=%s"
+    ]
+}
+                """%(addon_config_file).replace('\\','\\\\'))
+
+    with open(addon_config_file, 'wt') as f:
+        f.write("""
+{
+    "RE_FILE": "[^/]*[a-z][a-z0-9_]*[a-z0-9]\\.c\\Z",
+    "RE_NAMESPACE": false,
+    "RE_VARNAME": ["+bad pattern","[a-z]_good_pattern\\Z","(parentheses?"],
+    "RE_PRIVATE_MEMBER_VARIABLE": "[a-z][a-z0-9_]*[a-z0-9]\\Z",
+    "RE_PUBLIC_MEMBER_VARIABLE": {
+        "tmp_.*\\Z":[true,"illegal prefix tmp_"],
+        "bad_.*\\Z":true,
+        "public_.*\\Z":[false],
+        "pub_.*\\Z":[0,"required prefix pub_ missing"]
+    },
+    "RE_GLOBAL_VARNAME": "[a-z][a-z0-9_]*[a-z0-9]\\Z",
+    "RE_FUNCTIONNAME": "[a-z][a-z0-9_]*[a-z0-9]\\Z",
+    "RE_CLASS_NAME": "[a-z][a-z0-9_]*[a-z0-9]\\Z",
+    "_comment1": "these should all be arrays, or null, or not set",
+
+    "include_guard": true,
+    "var_prefixes": ["bad"],
+    "function_prefixes": false,
+    "_comment2": "these should all be dict",
+
+    "skip_one_char_variables": "false",
+    "_comment3": "this should be bool",
+
+    "RE_VAR_NAME": "typo"
+}
+                """.replace('\\','\\\\'))
+
+    test_file_basename = 'test.c'
+    test_file = os.path.join(tmpdir, test_file_basename)
+    with open(test_file, 'a'):
+        # only create the file
+        pass
+
+    args = ['--addon='+addon_file, '--verbose', '--enable=all', '-j1', test_file]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout if stdout else stderr
+
+    lines = __remove_verbose_log(stdout.splitlines())
+    assert lines == [
+        'Checking {} ...'.format(test_file)
+    ]
+    lines = stderr.splitlines()
+    # ignore the first line, stating that the addon failed to run properly
+    lines.pop(0)
+    assert lines == [
+        "Output:",
+        "config error: RE_FILE must be list (not str), or not set",
+        "config error: RE_NAMESPACE must be list or dict (not bool), or not set",
+        "config error: include_guard must be dict (not bool), or not set",
+        "config error: item '+bad pattern' of 'RE_VARNAME' is not a valid regular expression: nothing to repeat at position 0",
+        "config error: item '(parentheses?' of 'RE_VARNAME' is not a valid regular expression: missing ), unterminated subpattern at position 0",
+        "config error: var_prefixes must be dict (not list), or not set",
+        "config error: RE_PRIVATE_MEMBER_VARIABLE must be list or dict (not str), or not set",
+        "config error: item 'bad_.*\\Z' of 'RE_PUBLIC_MEMBER_VARIABLE' must be an array [bool,string]",
+        "config error: item 'public_.*\\Z' of 'RE_PUBLIC_MEMBER_VARIABLE' must be an array [bool,string]",
+        "config error: item 'pub_.*\\Z' of 'RE_PUBLIC_MEMBER_VARIABLE' must be an array [bool,string]",
+        "config error: RE_GLOBAL_VARNAME must be list or dict (not str), or not set",
+        "config error: RE_FUNCTIONNAME must be list or dict (not str), or not set",
+        "config error: function_prefixes must be dict (not bool), or not set",
+        "config error: RE_CLASS_NAME must be list or dict (not str), or not set",
+        "config error: skip_one_char_variables must be bool (not str), or not set",
+        "config error: unknown config key 'RE_VAR_NAME' [internalError]",
+        "",
+        "^",
+    ]
+
+
+def test_addon_findcasts(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        f.write("""
+        extern void f(char c)
+        {
+            int i = (int)c;
+            (void)i;
+        }
+        """)
+
+    args = ['--addon=findcasts', '--enable=all', '--disable=unusedFunction', '--template=simple', test_file]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file)
+    ]
+    assert stderr == '{}:4:21: information: found a cast [findcasts-cast]\n'.format(test_file)
+
+
+def test_addon_misc(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        f.write("""
+extern void f()
+{
+    const char* c[] = {"a" "b"};
+}
+        """)
+
+    args = ['--addon=misc', '--enable=all', '--disable=unusedFunction', '--template=simple', test_file]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file)
+    ]
+    assert stderr == '{}:4:28: style: String concatenation in array initialization, missing comma? [misc-stringConcatInArrayInit]\n'.format(test_file)
+
+
+def test_invalid_addon_json(tmpdir):
+    addon_file = os.path.join(tmpdir, 'addon1.json')
+    with open(addon_file, 'wt') as f:
+        f.write("""
+                """)
+
+    test_file = os.path.join(tmpdir, 'file.cpp')
+    with open(test_file, 'wt'):
+        pass
+
+    args = ['--addon={}'.format(addon_file), test_file]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 1
+    lines = stdout.splitlines()
+    assert lines == [
+        'Loading {} failed. syntax error at line 2 near: '.format(addon_file)
+    ]
+    assert stderr == ''
+
+
+def test_invalid_addon_py(tmpdir):
+    addon_file = os.path.join(tmpdir, 'addon1.py')
+    with open(addon_file, 'wt') as f:
+        f.write("""
+raise Exception()
+                """)
+
+    test_file = os.path.join(tmpdir, 'file.cpp')
+    with open(test_file, 'wt') as f:
+        f.write("""
+typedef int MISRA_5_6_VIOLATION;
+                """)
+
+    args = ['--addon={}'.format(addon_file), '--enable=all', '--disable=unusedFunction', test_file]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0  # TODO: needs to be 1
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file)
+    ]
+    assert stderr == "{}:0:0: error: Bailing out from analysis: Checking file failed: Failed to execute addon 'addon1' - exitcode is 1 [internalError]\n\n^\n".format(test_file)
+
+
+# TODO: test with -j2
+def test_invalid_addon_py_verbose(tmpdir):
+    addon_file = os.path.join(tmpdir, 'addon1.py')
+    with open(addon_file, 'wt') as f:
+        f.write("""
+raise Exception()
+                """)
+
+    test_file = os.path.join(tmpdir, 'file.cpp')
+    with open(test_file, 'wt') as f:
+        f.write("""
+typedef int MISRA_5_6_VIOLATION;
+                """)
+
+    args = ['--addon={}'.format(addon_file), '--enable=all', '--disable=unusedFunction', '--verbose', '-j1', test_file]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0  # TODO: needs to be 1
+    lines = __remove_verbose_log(stdout.splitlines())
+    assert lines == [
+        'Checking {} ...'.format(test_file)
+    ]
+    """
+/tmp/pytest-of-user/pytest-11/test_invalid_addon_py_20/file.cpp:0:0: error: Bailing out from analysis: Checking file failed: Failed to execute addon 'addon1' - exitcode is 1: python3 /home/user/CLionProjects/cppcheck/addons/runaddon.py /tmp/pytest-of-user/pytest-11/test_invalid_addon_py_20/addon1.py --cli /tmp/pytest-of-user/pytest-11/test_invalid_addon_py_20/file.cpp.24762.dump
+Output:
+Traceback (most recent call last):
+  File "/home/user/CLionProjects/cppcheck/addons/runaddon.py", line 8, in <module>
+    runpy.run_path(addon, run_name='__main__')
+  File "<frozen runpy>", line 291, in run_path
+  File "<frozen runpy>", line 98, in _run_module_code
+  File "<frozen runpy>", line 88, in _run_code
+  File "/tmp/pytest-of-user/pytest-11/test_invalid_addon_py_20/addon1.py", line 2, in <module>
+    raise Exception()
+Exceptio [internalError]
+    """
+    # /tmp/pytest-of-user/pytest-10/test_invalid_addon_py_20/file.cpp:0:0: error: Bailing out from analysis: Checking file failed: Failed to execute addon 'addon1' - exitcode is 256.: python3 /home/user/CLionProjects/cppcheck/addons/runaddon.py /tmp/pytest-of-user/pytest-10/test_invalid_addon_py_20/addon1.py --cli /tmp/pytest-of-user/pytest-10/test_invalid_addon_py_20/file.cpp.24637.dump
+    assert stderr.startswith("{}:0:0: error: Bailing out from analysis: Checking file failed: Failed to execute addon 'addon1' - exitcode is 1: ".format(test_file))
+    assert stderr.count('Output:\nTraceback')
+    assert stderr.endswith('raise Exception()\nException [internalError]\n\n^\n')
+
+
+def test_addon_result(tmpdir):
+    addon_file = os.path.join(tmpdir, 'addon1.py')
+    with open(addon_file, 'wt') as f:
+        f.write("""
+print("Checking ...")
+print("")
+print('{"file": "test.cpp", "linenr": 1, "column": 1, "severity": "style", "message": "msg", "addon": "addon1", "errorId": "id", "extra": ""}')
+print('{"loc": [{"file": "test.cpp", "linenr": 1, "column": 1, "info": ""}], "severity": "style", "message": "msg", "addon": "addon1", "errorId": "id", "extra": ""}')
+                """)
+
+    test_file = os.path.join(tmpdir, 'file.cpp')
+    with open(test_file, 'wt') as f:
+        f.write("""
+typedef int MISRA_5_6_VIOLATION;
+                """)
+
+    args = ['--addon={}'.format(addon_file), '--enable=all', '--disable=unusedFunction', test_file]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0  # TODO: needs to be 1
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file)
+    ]
+    assert stderr == 'test.cpp:1:1: style: msg [addon1-id]\n\n^\n'
+
+
+# TODO: test with -j2
+# #11483
+def __test_unused_function_include(tmpdir, extra_args):
+    test_cpp_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_cpp_file, 'wt') as f:
+        f.write("""
+                #include "test.h"
+                """)
+
+    test_h_file = os.path.join(tmpdir, 'test.h')
+    with open(test_h_file, 'wt') as f:
+        f.write("""
+                class A {
+                public:
+                    void f() {}
+                    // cppcheck-suppress unusedFunction
+                    void f2() {}
+                };
+                """)
+
+    args = [
+        '--enable=unusedFunction',
+        '--inline-suppr',
+        '--template=simple',
+        '-j1',
+        test_cpp_file
+    ]
+
+    args += extra_args
+
+    _, _, stderr = cppcheck(args)
+    assert stderr == "{}:4:26: style: The function 'f' is never used. [unusedFunction]\n".format(test_h_file)
+
+
+def test_unused_function_include(tmpdir):
+    __test_unused_function_include(tmpdir, [])
+
+
+# TODO: test with multiple files
+def __test_showtime(tmp_path, showtime, exp_len, exp_last, extra_args=None):
+    test_file = tmp_path / 'test.cpp'
+    with open(test_file, 'wt') as f:
+        f.write(
+"""
+void f()
+{
+    (void)(*((int*)0)); // cppcheck-suppress nullPointer
+}
+""")
+
+    args = [
+        f'--showtime={showtime}',
+        '--quiet',
+        '--inline-suppr',
+        str(test_file)
+    ]
+
+    if extra_args:
+        args += extra_args
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0
+    lines = stdout.splitlines()
+    if 'cppcheck internal API usage' in stdout:
+        exp_len += 1
+    assert len(lines) == exp_len
+    idx_last = exp_len-1
+    if idx_last:
+        assert lines[0] == ''
+    for i in range(1, idx_last):
+        assert 'avg.' in lines[i]
+    assert lines[idx_last].startswith(exp_last)
+    assert stderr == ''
+
+
+def test_showtime_top5_file(tmp_path):
+    __test_showtime(tmp_path, 'top5_file', 7, 'Check time: ')
+
+
+# TODO: remove extra args when --executor=process works works
+def test_showtime_top5_summary(tmp_path):
+    __test_showtime(tmp_path, 'top5_summary', 7, 'Overall time: ', ['-j1'])
+
+
+# TODO: remove when --executor=process works works
+def test_showtime_top5_summary_j_thread(tmp_path):
+    __test_showtime(tmp_path, 'top5_summary', 7, 'Overall time: ', ['-j2', '--executor=thread'])
+
+
+# TODO: remove override when fixed
+@pytest.mark.skipif(sys.platform == 'win32', reason="requires ProcessExecutor")
+@pytest.mark.xfail(strict=True)  # TODO: need to transfer the timer results to parent process - see #4452
+def test_showtime_top5_summary_j_process(tmp_path):
+    __test_showtime(tmp_path, 'top5_summary', 7, 'Overall time: ', ['-j2', '--executor=process'])
+
+
+def test_showtime_file(tmp_path):
+    __test_showtime(tmp_path, 'file', 79, 'Check time: ')
+
+
+# TODO: remove extra args when --executor=process works works
+def test_showtime_summary(tmp_path):
+    __test_showtime(tmp_path, 'summary', 79, 'Overall time: ', ['-j1'])
+
+
+# TODO: remove when --executor=process works works
+def test_showtime_summary_j_thread(tmp_path):
+    __test_showtime(tmp_path, 'summary', 79, 'Overall time: ', ['-j2', '--executor=thread'])
+
+
+# TODO: remove override when fixed
+@pytest.mark.skipif(sys.platform == 'win32', reason="requires ProcessExecutor")
+@pytest.mark.xfail(strict=True)  # TODO: need to transfer the timer results to parent process - see #4452
+def test_showtime_summary_j_process(tmp_path):
+    __test_showtime(tmp_path, 'summary', 79, 'Overall time: ', ['-j2', '--executor=process'])
+
+
+def test_showtime_file_total(tmp_path):
+    __test_showtime(tmp_path, 'file-total', 1, 'Check time: ')
+
+
+def test_missing_addon(tmpdir):
+    args = ['--addon=misra3', '--addon=misra', '--addon=misra2', 'file.c']
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 1
+    lines = stdout.splitlines()
+    lines.sort()
+    assert lines == [
+        'Did not find addon misra2.py',
+        'Did not find addon misra3.py'
+    ]
+    assert stderr == ""
+
+
+def test_file_filter(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt'):
+        pass
+
+    args = ['--file-filter=*.cpp', test_file]
+    out_lines = [
+        'Checking {} ...'.format(test_file)
+    ]
+
+    assert_cppcheck(args, ec_exp=0, err_exp=[], out_exp=out_lines)
+
+
+def test_file_filter_2(tmpdir):
+    test_file_1 = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file_1, 'wt'):
+        pass
+    test_file_2 = os.path.join(tmpdir, 'test.c')
+    with open(test_file_2, 'wt'):
+        pass
+
+    args = ['--file-filter=*.cpp', test_file_1, test_file_2]
+    out_lines = [
+        'Checking {} ...'.format(test_file_1)
+    ]
+
+    assert_cppcheck(args, ec_exp=0, err_exp=[], out_exp=out_lines)
+
+
+def test_file_filter_3(tmpdir):
+    test_file_1 = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file_1, 'wt'):
+        pass
+    test_file_2 = os.path.join(tmpdir, 'test.c')
+    with open(test_file_2, 'wt'):
+        pass
+
+    args = ['--file-filter=*.c', test_file_1, test_file_2]
+    out_lines = [
+        'Checking {} ...'.format(test_file_2)
+    ]
+
+    assert_cppcheck(args, ec_exp=0, err_exp=[], out_exp=out_lines)
+
+
+def test_file_filter_no_match(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt'):
+        pass
+
+    args = ['--file-filter=*.c', test_file]
+    out_lines = [
+        'cppcheck: error: could not find any files matching the filter:*.c'
+    ]
+
+    assert_cppcheck(args, ec_exp=1, err_exp=[], out_exp=out_lines)
+
+
+def test_file_order(tmpdir):
+    test_file_a = os.path.join(tmpdir, 'a.c')
+    with open(test_file_a, 'wt'):
+        pass
+    test_file_b = os.path.join(tmpdir, 'b.c')
+    with open(test_file_b, 'wt'):
+        pass
+    test_file_c = os.path.join(tmpdir, 'c.c')
+    with open(test_file_c, 'wt'):
+        pass
+    test_file_d = os.path.join(tmpdir, 'd.c')
+    with open(test_file_d, 'wt'):
+        pass
+
+    args = [test_file_c, test_file_d, test_file_b, test_file_a, '-j1']
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file_c),
+        '1/4 files checked 25% done',
+        'Checking {} ...'.format(test_file_d),
+        '2/4 files checked 50% done',
+        'Checking {} ...'.format(test_file_b),
+        '3/4 files checked 75% done',
+        'Checking {} ...'.format(test_file_a),
+        '4/4 files checked 100% done'
+    ]
+    assert stderr == ''
+
+
+def test_markup(tmpdir):
+    test_file_1 = os.path.join(tmpdir, 'test_1.qml')
+    with open(test_file_1, 'wt'):
+        pass
+    test_file_2 = os.path.join(tmpdir, 'test_2.cpp')
+    with open(test_file_2, 'wt'):
+        pass
+    test_file_3 = os.path.join(tmpdir, 'test_3.qml')
+    with open(test_file_3, 'wt'):
+        pass
+    test_file_4 = os.path.join(tmpdir, 'test_4.cpp')
+    with open(test_file_4, 'wt'):
+        pass
+
+    args = ['--library=qt', test_file_1, test_file_2, test_file_3, test_file_4, '-j1']
+    out_lines = [
+        'Checking {} ...'.format(test_file_2),
+        '1/4 files checked 25% done',
+        'Checking {} ...'.format(test_file_4),
+        '2/4 files checked 50% done',
+        'Checking {} ...'.format(test_file_1),
+        '3/4 files checked 75% done',
+        'Checking {} ...'.format(test_file_3),
+        '4/4 files checked 100% done'
+    ]
+
+    assert_cppcheck(args, ec_exp=0, err_exp=[], out_exp=out_lines)
+
+
+def test_markup_j(tmpdir):
+    test_file_1 = os.path.join(tmpdir, 'test_1.qml')
+    with open(test_file_1, 'wt'):
+        pass
+    test_file_2 = os.path.join(tmpdir, 'test_2.cpp')
+    with open(test_file_2, 'wt'):
+        pass
+    test_file_3 = os.path.join(tmpdir, 'test_3.qml')
+    with open(test_file_3, 'wt'):
+        pass
+    test_file_4 = os.path.join(tmpdir, 'test_4.cpp')
+    with open(test_file_4, 'wt'):
+        pass
+
+    args = ['--library=qt', '-j2', test_file_1, test_file_2, test_file_3, test_file_4]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+
+    assert sorted(lines) == [
+        '1/4 files checked 25% done',
+        '2/4 files checked 50% done',
+        '3/4 files checked 75% done',
+        '4/4 files checked 100% done',
+        'Checking {} ...'.format(test_file_1),
+        'Checking {} ...'.format(test_file_2),
+        'Checking {} ...'.format(test_file_3),
+        'Checking {} ...'.format(test_file_4)
+    ]
+    assert stderr == ''
+
+
+def test_valueflow_debug(tmpdir):
+    test_file_cpp = os.path.join(tmpdir, 'test_1.cpp')
+    with open(test_file_cpp, 'wt') as f:
+        f.write("""
+#include "test.h"
+
+void f()
+{
+    int i = 0;
+}
+"""
+                )
+    test_file_h = os.path.join(tmpdir, 'test.h')
+    with open(test_file_h, 'wt') as f:
+        f.write("""
+#include "test2.h"
+inline void f1()
+{
+    int i = 0;
+}
+"""
+                )
+    test_file_h_2 = os.path.join(tmpdir, 'test2.h')
+    with open(test_file_h_2, 'wt') as f:
+        f.write("""
+inline void f2()
+{
+    int i = 0;
+}
+"""
+                )
+
+    args = ['--debug', test_file_cpp]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout if stdout else stderr
+    if sys.platform == "win32":
+        stdout = stdout.replace('/', '\\')
+    assert f'Checking {test_file_cpp} ...' in stdout
+    stdout = stdout.replace(f'Checking {test_file_cpp} ...\n', '').strip()
+    assert stdout == '''##file {}
+2: void f2 ( )
+3: {{
+4: int i@var1 ; i@var1 = 0 ;
+5: }}
+
+##file {}
+
+1:
+2:
+3: void f1 ( )
+4: {{
+5: int i@var2 ; i@var2 = 0 ;
+6: }}
+
+##file {}
+
+1:
+2:
+3:
+4: void f ( )
+5: {{
+6: int i@var3 ; i@var3 = 0 ;
+7: }}
+
+
+
+##Value flow
+File {}
+Line 4
+  = always 0
+  0 always 0
+File {}
+Line 5
+  = always 0
+  0 always 0
+File {}
+Line 6
+  = always 0
+  0 always 0'''.format(test_file_h_2, test_file_h, test_file_cpp,
+                       test_file_h_2, test_file_h, test_file_cpp)
+    assert stderr == ''
+
+
+def test_file_duplicate(tmpdir):
+    test_file_a = os.path.join(tmpdir, 'a.c')
+    with open(test_file_a, 'wt'):
+        pass
+
+    args = [test_file_a, test_file_a, str(tmpdir)]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file_a)
+    ]
+    assert stderr == ''
+
+
+def test_file_duplicate_2(tmpdir):
+    test_file_a = os.path.join(tmpdir, 'a.c')
+    with open(test_file_a, 'wt'):
+        pass
+    test_file_b = os.path.join(tmpdir, 'b.c')
+    with open(test_file_b, 'wt'):
+        pass
+    test_file_c = os.path.join(tmpdir, 'c.c')
+    with open(test_file_c, 'wt'):
+        pass
+
+    args = [test_file_c, test_file_a, test_file_b, str(tmpdir), test_file_b, test_file_c, test_file_a, str(tmpdir), '-j1']
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file_c),
+        '1/3 files checked 33% done',
+        'Checking {} ...'.format(test_file_a),
+        '2/3 files checked 66% done',
+        'Checking {} ...'.format(test_file_b),
+        '3/3 files checked 100% done'
+    ]
+    assert stderr == ''
+
+
+def test_file_duplicate_3(tmpdir):  # #12834
+    test_file_a = os.path.join(tmpdir, 'a.c')
+    with open(test_file_a, 'wt'):
+        pass
+
+    # multiple ways to specify the same file
+    in_file_a = 'a.c'
+    in_file_b = os.path.join('.', 'a.c')
+    in_file_c = os.path.join('dummy', '..', 'a.c')
+    in_file_d = os.path.join(tmpdir, 'a.c')
+    in_file_e = os.path.join(tmpdir, '.', 'a.c')
+    in_file_f = os.path.join(tmpdir, 'dummy', '..', 'a.c')
+
+    args = [in_file_a, in_file_b, in_file_c, in_file_d, in_file_e, in_file_f, str(tmpdir)]
+
+    exitcode, stdout, stderr = cppcheck(args, cwd=tmpdir)
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format('a.c')
+    ]
+    assert stderr == ''
+
+
+@pytest.mark.skipif(sys.platform != 'win32', reason="requires Windows")
+def test_file_duplicate_4(tmpdir):  # #12834
+    test_file_a = os.path.join(tmpdir, 'a.c')
+    with open(test_file_a, 'wt'):
+        pass
+
+    # multiple ways to specify the same file
+    in_file_a = 'a.c'
+    in_file_b = os.path.join('.', 'a.c')
+    in_file_c = os.path.join('dummy', '..', 'a.c')
+    in_file_d = os.path.join(tmpdir, 'a.c')
+    in_file_e = os.path.join(tmpdir, '.', 'a.c')
+    in_file_f = os.path.join(tmpdir, 'dummy', '..', 'a.c')
+
+    args1 = [in_file_a, in_file_b, in_file_c, in_file_d, in_file_e, in_file_f, str(tmpdir)]
+    args2 = []
+    for a in args1:
+        args2.append(a.replace('\\', '/'))
+    args = args1 + args2
+
+    exitcode, stdout, stderr = cppcheck(args, cwd=tmpdir)
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format('a.c')
+    ]
+    assert stderr == ''
+
+
+def test_file_ignore(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt'):
+        pass
+
+    args = ['-itest.cpp', test_file]
+    out_lines = [
+        'cppcheck: error: could not find or open any of the paths given.',
+        'cppcheck: Maybe all paths were ignored?'
+    ]
+
+    assert_cppcheck(args, ec_exp=1, err_exp=[], out_exp=out_lines)
+
+
+def test_build_dir_j_memleak(tmpdir): #12111
+    build_dir = os.path.join(tmpdir, 'build-dir')
+    os.mkdir(build_dir)
+
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        f.write('int main() {}')
+
+    args = ['--cppcheck-build-dir={}'.format(build_dir), '-j2', test_file]
+    out_lines = [
+        'Checking {} ...'.format(test_file)
+    ]
+
+    assert_cppcheck(args, ec_exp=0, err_exp=[], out_exp=out_lines)
+
+
+def __test_addon_json_invalid(tmpdir, addon_json, expected):
+    addon_file = os.path.join(tmpdir, 'invalid.json')
+    with open(addon_file, 'wt') as f:
+        f.write(addon_json)
+
+    test_file = os.path.join(tmpdir, 'file.cpp')
+    with open(test_file, 'wt'):
+        pass
+
+    args = ['--addon={}'.format(addon_file), test_file]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 1
+    lines = stdout.splitlines()
+    assert len(lines) == 1
+    assert lines == [
+        'Loading {} failed. {}'.format(addon_file, expected)
+    ]
+    assert stderr == ''
+
+
+def test_addon_json_invalid_no_obj(tmpdir):
+    __test_addon_json_invalid(tmpdir, json.dumps([]), "JSON is not an object.")
+
+
+def test_addon_json_invalid_args_1(tmpdir):
+    __test_addon_json_invalid(tmpdir, json.dumps({'args':0}), "'args' must be an array.")
+
+
+def test_addon_json_invalid_args_2(tmpdir):
+    __test_addon_json_invalid(tmpdir, json.dumps({'args':[0]}), "'args' entry is not a string.")
+
+
+def test_addon_json_invalid_ctu(tmpdir):
+    __test_addon_json_invalid(tmpdir, json.dumps({'ctu':0}), "'ctu' must be a boolean.")
+
+
+def test_addon_json_invalid_python(tmpdir):
+    __test_addon_json_invalid(tmpdir, json.dumps({'python':0}), "'python' must be a string.")
+
+
+def test_addon_json_invalid_executable(tmpdir):
+    __test_addon_json_invalid(tmpdir, json.dumps({'executable':0}), "'executable' must be a string.")
+
+
+def test_addon_json_invalid_script_1(tmpdir):
+    __test_addon_json_invalid(tmpdir, json.dumps({'Script':''}), "'script' is missing.")
+
+
+def test_addon_json_invalid_script_2(tmpdir):
+    __test_addon_json_invalid(tmpdir, json.dumps({'script':0}), "'script' must be a string.")
+
+
+def test_unknown_extension(tmpdir):
+    test_file = os.path.join(tmpdir, 'test_2')
+    with open(test_file, 'wt') as f:
+        f.write('''
+void f() { }
+''')
+
+    exitcode, stdout, stderr = cppcheck(['-q', test_file])
+    assert exitcode == 0, stdout if stdout else stderr
+    assert stdout == ''
+    assert stderr == ''
+
+
+def test_rule_file_define_multiple(tmpdir):
+    rule_file = os.path.join(tmpdir, 'rule_file.xml')
+    with open(rule_file, 'wt') as f:
+        f.write("""
+<rules>
+    <rule>
+        <tokenlist>define</tokenlist>
+        <pattern>DEF_1</pattern>
+        <message>
+            <severity>error</severity>
+            <id>ruleId1</id>
+        </message>
+    </rule>
+    <rule>
+        <tokenlist>define</tokenlist>
+        <pattern>DEF_2</pattern>
+        <message>
+            <severity>error</severity>
+            <id>ruleId2</id>
+            <summary>define2</summary>
+        </message>
+    </rule>
+</rules>""")
+
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write('''
+#define DEF_1
+#define DEF_2
+void f() { }
+''')
+
+    exitcode, stdout, stderr = cppcheck(['--template=simple', '--rule-file={}'.format(rule_file), '-DDEF_3', test_file])
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file),
+        'Processing rule: DEF_1',
+        'Processing rule: DEF_2',
+        'Checking {}: DEF_3=1...'.format(test_file)
+    ]
+    lines = stderr.splitlines()
+    assert lines == [
+        "{}:2:0: error: found 'DEF_1' [ruleId1]".format(test_file),
+        "{}:3:0: error: define2 [ruleId2]".format(test_file)
+    ]
+
+
+def test_rule_file_define(tmpdir):
+    rule_file = os.path.join(tmpdir, 'rule_file.xml')
+    with open(rule_file, 'wt') as f:
+        f.write("""
+<rule>
+    <tokenlist>define</tokenlist>
+    <pattern>DEF_.</pattern>
+</rule>
+""")
+
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write('''
+#define DEF_1
+#define DEF_2
+void f() { }
+''')
+
+    exitcode, stdout, stderr = cppcheck(['--template=simple', '--rule-file={}'.format(rule_file), '-DDEF_3', test_file])
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file),
+        'Processing rule: DEF_.',
+        'Checking {}: DEF_3=1...'.format(test_file)
+    ]
+    lines = stderr.splitlines()
+    assert lines == [
+        "{}:2:0: style: found 'DEF_1' [rule]".format(test_file),
+        "{}:3:0: style: found 'DEF_2' [rule]".format(test_file)
+    ]
+
+
+def test_rule_file_normal(tmpdir):
+    rule_file = os.path.join(tmpdir, 'rule_file.xml')
+    with open(rule_file, 'wt') as f:
+        f.write("""
+<rule>
+    <pattern>int</pattern>
+</rule>
+""")
+
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write('''
+#define DEF_1
+#define DEF_2
+typedef int i32;
+void f(i32) { }
+''')
+
+    exitcode, stdout, stderr = cppcheck(['--template=simple', '--rule-file={}'.format(rule_file), test_file])
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file),
+        'Processing rule: int',
+    ]
+    lines = stderr.splitlines()
+    assert lines == [
+        "{}:5:0: style: found 'int' [rule]".format(test_file)
+    ]
+
+
+def test_rule_file_raw(tmpdir):
+    rule_file = os.path.join(tmpdir, 'rule_file.xml')
+    with open(rule_file, 'wt') as f:
+        f.write("""
+<rule>
+    <tokenlist>raw</tokenlist>
+    <pattern>i32</pattern>
+</rule>
+""")
+
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write('''
+#define DEF_1
+#define DEF_2
+typedef int i32;
+void f(i32) { }
+''')
+
+    exitcode, stdout, stderr = cppcheck(['--template=simple', '--rule-file={}'.format(rule_file), test_file])
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file),
+        'Processing rule: i32',
+    ]
+    lines = stderr.splitlines()
+    assert lines == [
+        "{}:4:0: style: found 'i32' [rule]".format(test_file),
+        "{}:5:0: style: found 'i32' [rule]".format(test_file)
+    ]
+
+
+def test_rule(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write('''
+#define DEF_1
+#define DEF_2
+void f() { }
+''')
+
+    exitcode, stdout, stderr = cppcheck(['--template=simple', '--rule=f', test_file])
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == [
+        'Checking {} ...'.format(test_file),
+        'Processing rule: f',
+    ]
+    lines = stderr.splitlines()
+    assert lines == [
+        "{}:4:0: style: found 'f' [rule]".format(test_file)
+    ]
+
+
+def test_rule_multiple_files(tmpdir):
+    stderr_exp = []
+    for i in range(10):
+        test_file = os.path.join(tmpdir, f'test_{i}.c')
+        stderr_exp.append("{}:4:0: style: found 'f' [rule]".format(test_file))
+        with open(test_file, 'wt') as f:
+            f.write('''
+#define DEF_1
+#define DEF_2
+void f() { }
+''')
+
+    exitcode, stdout, stderr = cppcheck(['-q', '--template=simple', '--rule=f', str(tmpdir)])
+    assert exitcode == 0, stdout if stdout else stderr
+    assert stdout.splitlines() == []
+    lines = stderr.splitlines()
+    lines.sort()
+    stderr_exp.sort()
+    assert lines == stderr_exp
+
+
+def test_filelist(tmpdir):
+    list_dir = os.path.join(tmpdir, 'list-dir')
+    os.mkdir(list_dir)
+
+    with open(os.path.join(list_dir, 'aaa.c'), 'wt'):
+        pass
+    with open(os.path.join(list_dir, 'zzz.c'), 'wt'):
+        pass
+    with open(os.path.join(list_dir, 'valueflow.cpp'), 'wt'):
+        pass
+    with open(os.path.join(list_dir, 'vfvalue.cpp'), 'wt'):
+        pass
+    with open(os.path.join(list_dir, 'vf_enumvalue.cpp'), 'wt'):
+        pass
+    with open(os.path.join(list_dir, 'vf_analyze.h'), 'wt'):
+        pass
+
+    sub_dir_1 = os.path.join(list_dir, 'valueflow')
+    os.mkdir(sub_dir_1)
+    with open(os.path.join(sub_dir_1, 'file.cpp'), 'wt'):
+        pass
+    with open(os.path.join(sub_dir_1, 'file.c'), 'wt'):
+        pass
+    with open(os.path.join(sub_dir_1, 'file.h'), 'wt'):
+        pass
+
+    sub_dir_2 = os.path.join(list_dir, 'vfvalue')
+    os.mkdir(sub_dir_2)
+    with open(os.path.join(sub_dir_2, 'file.cpp'), 'wt'):
+        pass
+    with open(os.path.join(sub_dir_2, 'file.c'), 'wt'):
+        pass
+    with open(os.path.join(sub_dir_2, 'file.h'), 'wt'):
+        pass
+
+    sub_dir_3 = os.path.join(list_dir, 'vf_enumvalue')
+    os.mkdir(sub_dir_3)
+    with open(os.path.join(sub_dir_3, 'file.cpp'), 'wt'):
+        pass
+    with open(os.path.join(sub_dir_3, 'file.c'), 'wt'):
+        pass
+    with open(os.path.join(sub_dir_3, 'file.h'), 'wt'):
+        pass
+
+    # TODO: -rp is not applied to "Checking" messages
+    #exitcode, stdout, stderr = cppcheck(['-j1', '-rp', list_dir])
+    exitcode, stdout, stderr = cppcheck(['-j1', '.'], cwd=list_dir)
+    assert exitcode == 0, stdout if stdout else stderr
+    if sys.platform == "win32":
+        stdout = stdout.replace('\\', '/')
+    lines = stdout.splitlines()
+    expected = [
+        'Checking aaa.c ...',
+        'Checking valueflow.cpp ...',
+        'Checking valueflow/file.c ...',
+        'Checking valueflow/file.cpp ...',
+        'Checking vf_enumvalue.cpp ...',
+        'Checking vf_enumvalue/file.c ...',
+        'Checking vf_enumvalue/file.cpp ...',
+        'Checking vfvalue.cpp ...',
+        'Checking vfvalue/file.c ...',
+        'Checking vfvalue/file.cpp ...',
+        'Checking zzz.c ...'
+    ]
+    assert len(expected), len(lines)
+    for i in range(1, len(expected)+1):
+        lines.remove('{}/{} files checked {}% done'.format(i, len(expected), int(100 * i // len(expected))))
+    assert lines == expected
+
+
+def test_markup_lang(tmpdir):
+    test_file_1 = os.path.join(tmpdir, 'test_1.qml')
+    with open(test_file_1, 'wt'):
+        pass
+    test_file_2 = os.path.join(tmpdir, 'test_2.cpp')
+    with open(test_file_2, 'wt'):
+        pass
+
+    # do not assert processing markup file with enforced language
+    args = [
+        '--library=qt',
+        '--enable=unusedFunction',
+        '--language=c++',
+        '-j1',
+        test_file_1,
+        test_file_2
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout if stdout else stderr
+
+
+def test_cpp_probe(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.h')
+    with open(test_file, 'wt') as f:
+        f.writelines([
+            'class A {};'
+        ])
+
+    args = ['-q', '--template=simple', '--cpp-header-probe', '--verbose', test_file]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout if stdout else stderr
+    lines = stdout.splitlines()
+    assert lines == []
+    lines = stderr.splitlines()
+    assert lines == [
+        # TODO: fix that awkward format
+        "{}:1:1: error: Code 'classA{{' is invalid C code.: Use --std, -x or --language to enforce C++. Or --cpp-header-probe to identify C++ headers via the Emacs marker. [syntaxError]".format(test_file)
+    ]
+
+
+def test_cpp_probe_2(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.h')
+    with open(test_file, 'wt') as f:
+        f.writelines([
+            '// -*- C++ -*-',
+            'class A {};'
+        ])
+
+    args = ['-q', '--template=simple', '--cpp-header-probe', test_file]
+
+    assert_cppcheck(args, ec_exp=0, err_exp=[], out_exp=[])
+
+
+def test_config_invalid(tmpdir):
+    # cppcheck.cfg needs to be next to executable
+    exe = shutil.copy2(__lookup_cppcheck_exe(), tmpdir)
+    if sys.platform == 'win32':
+        shutil.copy2(os.path.join(os.path.dirname(__lookup_cppcheck_exe()), 'cppcheck-core.dll'), tmpdir)
+    shutil.copytree(os.path.join(os.path.dirname(__lookup_cppcheck_exe()), 'cfg'), os.path.join(tmpdir, 'cfg'))
+
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    config_file = os.path.join(tmpdir, 'cppcheck.cfg')
+    with open(config_file, 'wt'):
+        pass
+
+    exitcode, stdout, stderr, exe = cppcheck_ex([test_file], cwd=tmpdir, cppcheck_exe=exe)
+    assert exitcode == 1, stdout if stdout else stderr
+    assert stdout.splitlines() == [
+        'cppcheck: error: could not load cppcheck.cfg - not a valid JSON - syntax error at line 1 near: '
+    ]
+
+
+def test_config_override(tmpdir):
+    # cppcheck.cfg needs to be next to executable
+    exe = shutil.copy2(__lookup_cppcheck_exe(), tmpdir)
+    if sys.platform == 'win32':
+        shutil.copy2(os.path.join(os.path.dirname(__lookup_cppcheck_exe()), 'cppcheck-core.dll'), tmpdir)
+    shutil.copytree(os.path.join(os.path.dirname(__lookup_cppcheck_exe()), 'cfg'), os.path.join(tmpdir, 'cfg'))
+
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt'):
+        pass
+
+    config_file = os.path.join(tmpdir, 'cppcheck.cfg')
+    with open(config_file, 'wt') as f:
+        f.write(json.dumps({
+            'safety': False
+        }))
+
+    exitcode, stdout, stderr, exe = cppcheck_ex(['-q', '--safety', test_file], cwd=tmpdir, cppcheck_exe=exe, remove_checkers_report=False)
+    assert exitcode == 0, stdout if stdout else stderr
+    assert stdout.splitlines() == []
+    assert 'checkersReport' in stderr
+
+
+def test_checkers_report(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write('x=1;')
+    checkers_report = os.path.join(tmpdir, 'r.txt')
+    exitcode, stdout, stderr = cppcheck(['--enable=all', '--checkers-report=' + checkers_report, test_file], remove_checkers_report=False)
+    assert exitcode == 0, stdout if stdout else stderr
+    assert 'Active checkers:' in stderr
+    assert '--checkers-report' not in stderr
+
+
+def test_checkers_report_misra_json(tmpdir):
+    """check that misra checkers are reported properly when --addon=misra.json is used"""
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write('x=1;')
+    misra_json = os.path.join(tmpdir, 'misra.json')
+    with open(misra_json, 'wt') as f:
+        f.write('{"script":"misra.py"}')
+    exitcode, stdout, stderr = cppcheck('--enable=style --addon=misra.json --xml-version=3 test.c'.split(), cwd=tmpdir)
+    assert exitcode == 0, stdout if stdout else stderr
+    assert '<checker id="Misra C 2012: 8.1"/>' in stderr
+
+
+def __test_ignore_file(tmpdir, ign, append=False, inject_path=False):
+    os.mkdir(os.path.join(tmpdir, 'src'))
+    test_file = os.path.join(tmpdir, 'src', 'test.cpp')
+    with open(test_file, 'wt'):
+        pass
+
+    # TODO: this should say that all paths are ignored
+    lines_exp = [
+        'ignored path: {}'.format(test_file),
+        'cppcheck: error: could not find or open any of the paths given.',
+        'cppcheck: Maybe all paths were ignored?'
+    ]
+
+    args = [
+        '--debug-ignore',
+        test_file
+    ]
+
+    if inject_path:
+        ign = ign.replace('$path', str(test_file))
+
+    if append:
+        args += ['-i{}'.format(ign)]
+    else:
+        args = ['-i{}'.format(ign)] + args
+
+    exitcode, stdout, stderr = cppcheck(args, cwd=tmpdir)
+    assert exitcode == 1, stdout if stdout else stderr
+    assert stdout.splitlines() == lines_exp
+
+
+def test_ignore_file(tmpdir):
+    __test_ignore_file(tmpdir, 'test.cpp')
+
+
+def test_ignore_file_append(tmpdir):
+    __test_ignore_file(tmpdir, 'test.cpp', append=True)
+
+
+def test_ignore_file_wildcard_back(tmpdir):
+    __test_ignore_file(tmpdir, 'test.c*')
+
+
+def test_ignore_file_wildcard_front(tmpdir):
+    __test_ignore_file(tmpdir, '*test.cpp')
+
+
+def test_ignore_file_placeholder(tmpdir):
+    __test_ignore_file(tmpdir, 't?st.cpp')
+
+
+def test_ignore_file_relative(tmpdir):
+    __test_ignore_file(tmpdir, 'src/test.cpp')
+
+
+def test_ignore_file_relative_backslash(tmpdir):
+    __test_ignore_file(tmpdir, 'src\\test.cpp')
+
+
+def test_ignore_file_relative_wildcard(tmpdir):
+    __test_ignore_file(tmpdir, 'src/test.c*')
+
+
+def test_ignore_file_relative_wildcard_backslash(tmpdir):
+    __test_ignore_file(tmpdir, 'src\\test.c*')
+
+
+def test_ignore_path_relative(tmpdir):
+    __test_ignore_file(tmpdir, 'src/')
+
+
+def test_ignore_path_relative_backslash(tmpdir):
+    __test_ignore_file(tmpdir, 'src\\')
+
+
+def test_ignore_path_relative_wildcard(tmpdir):
+    __test_ignore_file(tmpdir, 'src*/')
+
+
+def test_ignore_path_relative_wildcard_backslash(tmpdir):
+    __test_ignore_file(tmpdir, 'src*\\')
+
+
+def test_ignore_abspath(tmpdir):
+    __test_ignore_file(tmpdir, '$path', inject_path=True)
+
+
+def __write_gui_project(tmpdir, test_file, ignore):
+    project_file = os.path.join(tmpdir, 'test.cppcheck')
+    with open(project_file, 'wt') as f:
+        f.write(
+        """<?xml version="1.0" encoding="UTF-8"?>
+<project>
+<paths>
+<dir name="{}"/>
+</paths>
+<ignore>
+<path name="{}"/>
+</ignore>
+</project>""".format(test_file, ignore))
+
+    return project_file
+
+
+def __test_ignore_project(tmpdir, ign_proj, ign_cli=None, append_cli=False, inject_path_proj=False):
+    os.mkdir(os.path.join(tmpdir, 'src'))
+    test_file = os.path.join(tmpdir, 'src', 'test.cpp')
+    with open(test_file, 'wt'):
+        pass
+
+    # TODO: this should say that all paths were ignored
+    lines_exp = [
+        'ignored path: {}'.format(test_file),
+        'cppcheck: error: could not find or open any of the paths given.',
+        'cppcheck: Maybe all paths were ignored?'
+    ]
+
+    if inject_path_proj:
+        ign_proj = ign_proj.replace('$path', str(test_file))
+
+    project_file = __write_gui_project(tmpdir, test_file, ign_proj)
+    args = [
+        '--debug-ignore',
+        '--project={}'.format(project_file)
+    ]
+
+    if append_cli:
+        args += ['-i{}'.format(ign_cli)]
+    else:
+        args = ['-i{}'.format(ign_cli)] + args
+
+    exitcode, stdout, _ = cppcheck(args, cwd=tmpdir)
+    assert exitcode == 1, stdout
+    assert stdout.splitlines() == lines_exp
+
+
+def test_ignore_project_file(tmpdir):
+    __test_ignore_project(tmpdir, 'test.cpp')
+
+
+def test_ignore_project_file_cli_prepend(tmpdir):
+    __test_ignore_project(tmpdir, ign_proj='test2.cpp', ign_cli='test.cpp')
+
+
+def test_ignore_project_file_cli_append(tmpdir):
+    __test_ignore_project(tmpdir, ign_proj='test2.cpp', ign_cli='test.cpp', append_cli=True)
+
+
+def test_ignore_project_file_wildcard_back(tmpdir):
+    __test_ignore_project(tmpdir, 'test.c*')
+
+
+def test_ignore_project_file_wildcard_front(tmpdir):
+    __test_ignore_project(tmpdir, '*test.cpp')
+
+
+def test_ignore_project_file_placeholder(tmpdir):
+    __test_ignore_project(tmpdir, 't?st.cpp')
+
+
+def test_ignore_project_file_relative(tmpdir):
+    __test_ignore_project(tmpdir, 'src/test.cpp')
+
+
+def test_ignore_project_file_relative_backslash(tmpdir):
+    __test_ignore_project(tmpdir, 'src\\test.cpp')
+
+
+def test_ignore_project_path_relative(tmpdir):
+    __test_ignore_project(tmpdir, 'src/')
+
+
+def test_ignore_project_path_relative_backslash(tmpdir):
+    __test_ignore_project(tmpdir, 'src\\')
+
+
+def test_ignore_project_abspath(tmpdir):
+    __test_ignore_project(tmpdir, '$path', inject_path_proj=True)
+
+
+def __write_compdb(tmpdir, test_file):
+    compile_commands = os.path.join(tmpdir, 'compile_commands.json')
+    j = [
+        {
+            'directory': os.path.dirname(test_file),
+            'file': test_file,
+            'command': 'gcc -c {}'.format(test_file)
+        }
+    ]
+    with open(compile_commands, 'wt') as f:
+        f.write(json.dumps(j))
+    return compile_commands
+
+
+def __test_ignore_project_2(tmpdir, extra_args, append=False, inject_path=False):
+    os.mkdir(os.path.join(tmpdir, 'src'))
+    test_file = os.path.join(tmpdir, 'src', 'test.cpp')
+    with open(test_file, 'wt'):
+        pass
+
+    lines_exp = [
+        'ignored path: {}'.format(str(test_file).replace('\\', '/')),
+        'cppcheck: error: no C or C++ source files found.',
+        'cppcheck: all paths were ignored'
+    ]
+    project_file = __write_compdb(tmpdir, test_file)
+    args = [
+        '--debug-ignore',
+        '--project={}'.format(project_file)
+    ]
+
+    if inject_path:
+        extra_args = [ extra_args[0].replace('$path', str(test_file)) ]
+    if append:
+        args += extra_args
+    else:
+        args = extra_args + args
+    print(args)
+
+    exitcode, stdout, stderr = cppcheck(args, cwd=tmpdir)
+    assert exitcode == 1, stdout if stdout else stderr
+    assert stdout.splitlines() == lines_exp
+
+
+def test_ignore_project_2_file(tmpdir):
+    __test_ignore_project_2(tmpdir, ['-itest.cpp'])
+
+
+def test_ignore_project_2_file_append(tmpdir):
+    # make sure it also matches when specified after project
+    __test_ignore_project_2(tmpdir, ['-itest.cpp'], append=True)
+
+
+def test_ignore_project_2_file_wildcard_back(tmpdir):
+    __test_ignore_project_2(tmpdir, ['-itest.c*'])
+
+
+def test_ignore_project_2_file_wildcard_front(tmpdir):
+    __test_ignore_project_2(tmpdir, ['-i*test.cpp'])
+
+
+def test_ignore_project_2_file_placeholder(tmpdir):
+    __test_ignore_project_2(tmpdir, ['-it?st.cpp'])
+
+
+def test_ignore_project_2_file_relative(tmpdir):
+    __test_ignore_project_2(tmpdir, ['-isrc/test.cpp'])
+
+
+def test_ignore_project_2_file_relative_backslash(tmpdir):
+    __test_ignore_project_2(tmpdir, ['-isrc\\test.cpp'])
+
+
+def test_ignore_project_2_file_relative_wildcard(tmpdir):
+    __test_ignore_project_2(tmpdir, ['-isrc/test.c*'])
+
+
+def test_ignore_project_2_file_relative_wildcard_backslash(tmpdir):
+    __test_ignore_project_2(tmpdir, ['-isrc\\test.c*'])
+
+
+def test_ignore_project_2_path_relative(tmpdir):
+    __test_ignore_project_2(tmpdir, ['-isrc/'])
+
+
+def test_ignore_project_2_path_relative_backslash(tmpdir):
+    __test_ignore_project_2(tmpdir, ['-isrc\\'])
+
+
+def test_ignore_project_2_path_relative_wildcard(tmpdir):
+    __test_ignore_project_2(tmpdir, ['-isrc*/'])
+
+
+def test_ignore_project_2_path_relative_wildcard_backslash(tmpdir):
+    __test_ignore_project_2(tmpdir, ['-isrc*\\'])
+
+
+def test_ignore_project_2_abspath(tmpdir):
+    __test_ignore_project_2(tmpdir, ['-i$path'], inject_path=True)
+
+
+def test_dumpfile_platform(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write('x=1;\n')
+    cppcheck('--dump --platform=unix64 test.c'.split(), cwd=tmpdir)
+    platform = ''
+    with open(test_file + '.dump', 'rt') as f:
+        for line in f:
+            if line.find('<platform name="') > 0:
+                platform = line.strip()
+                break
+    assert ' wchar_t_bit="' in platform
+    assert ' size_t_bit="' in platform
+
+
+def test_builddir_hash_check_level(tmp_path):  # #13376
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write("""
+void f(bool b)
+{
+    for (int i = 0; i < 2; ++i)
+    {
+        if (i == 0) {}
+        if (b) continue;
+    }
+}
+""")
+
+    build_dir = tmp_path / 'b1'
+    os.mkdir(build_dir)
+
+    args = [ # // #14029
+        '--enable=warning',  # to execute the code which generates the normalCheckLevelMaxBranches message
+        '--cppcheck-build-dir={}'.format(build_dir),
+        '--template=simple',
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stderr == ''
+
+    args = [
+        '--enable=warning',  # to execute the code which generates the normalCheckLevelMaxBranches message
+        '--enable=information',  # to show the normalCheckLevelMaxBranches message
+        '--cppcheck-build-dir={}'.format(build_dir),
+        '--template=simple',
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stderr == '{}:0:0: information: Limiting analysis of branches. Use --check-level=exhaustive to analyze all branches. [normalCheckLevelMaxBranches]\n'.format(test_file)
+
+    cache_file = (build_dir / 'test.a1')
+
+    root = ElementTree.fromstring(cache_file.read_text())
+    hash_1 = root.get('hash')
+
+    args += ['--check-level=exhaustive']
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stderr == ''
+
+    root = ElementTree.fromstring(cache_file.read_text())
+    hash_2 = root.get('hash')
+
+    assert hash_1 != hash_2
+
+
+def test_def_undef(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write("""
+void f()
+{
+#ifndef DEF_1
+    (void)(*((int*)0));
+#endif
+}
+""")
+
+    args = [
+        '--template=simple',
+        '-DDEF_1',
+        '-UDEF_1',
+        str(test_file)
+    ]
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0
+    assert stdout.splitlines() == [
+        'Checking {} ...'.format(test_file),
+        'Checking {}: DEF_1=1...'.format(test_file)  # TODO: should not print DEF_1 - see #13335
+    ]
+    assert stderr.splitlines() == [
+        '{}:5:14: error: Null pointer dereference: (int*)0 [nullPointer]'.format(test_file)
+    ]
+
+
+@pytest.mark.xfail(strict=True)
+def test_def_def(tmp_path):  # #13334
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write("""
+void f()
+{
+#if DEF_1 == 3
+    (void)(*((int*)0));
+#endif
+#if DEF_1 == 7
+    (void)(*((int*)0));
+#endif
+}
+""")
+
+    args = [
+        '--template=simple',
+        '-DDEF_1=3',
+        '-DDEF_1=7',
+        str(test_file)
+    ]
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0
+    assert stdout.splitlines() == [
+        'Checking {} ...'.format(test_file),
+        'Checking {}: DEF_1=3;DEF_1=7...'.format(test_file)  # TODO: should not print DEF_1 twice - see #13335
+    ]
+    assert stderr.splitlines() == [
+        '{}:8:14: error: Null pointer dereference: (int*)0 [nullPointer]'.format(test_file)
+    ]
+
+
+@pytest.mark.xfail(strict=True)
+def test_def_undef_def(tmp_path):  # #13334
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write("""
+void f()
+{
+#ifdef DEF_1
+    (void)(*((int*)0));
+#endif
+}
+""")
+
+    args = [
+        '--template=simple',
+        '-DDEF_1',
+        '-UDEF_1',
+        '-DDEF_1',
+        str(test_file)
+    ]
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0
+    assert stdout.splitlines() == [
+        'Checking {} ...'.format(test_file),
+        'Checking {}: DEF_1=1;DEF_1=1...'.format(test_file)  # TODO: should not print DEF_1 twice - see #13335
+    ]
+    assert stderr.splitlines() == [
+        '{}:5:14: error: Null pointer dereference: (int*)0 [nullPointer]'.format(test_file)
+    ]
+
+
+def test_undef(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write("""
+void f()
+{
+#ifndef DEF_1
+    (void)(*((int*)0));
+#endif
+}
+""")
+
+    args = [
+        '--template=simple',
+        '-UDEF_1',
+        str(test_file)
+    ]
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0
+    assert stdout.splitlines() == [
+        'Checking {} ...'.format(test_file)
+    ]
+    assert stderr.splitlines() == [
+        '{}:5:14: error: Null pointer dereference: (int*)0 [nullPointer]'.format(test_file)
+    ]
+
+
+@pytest.mark.xfail(strict=True)
+def test_undef_src(tmp_path):  # #13340
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write("""
+#define DEF_1
+
+void f()
+{
+#ifdef DEF_1
+    (void)(*((int*)0));
+#endif
+}
+""")
+
+    args = [
+        '--template=simple',
+        '-UDEF_1',
+        str(test_file)
+    ]
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0
+    assert stdout.splitlines() == [
+        'Checking {} ...'.format(test_file)
+    ]
+    assert stderr.splitlines() == [
+        '{}:7:14: error: Null pointer dereference: (int*)0 [nullPointer]'.format(test_file)
+    ]
+
+
+def test_dump_check_config(tmp_path):  # #13432
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write("""
+void f() {}
+""")
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--dump',
+        '--check-config',
+        str(test_file)
+    ]
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout == ''
+    assert stderr == ''
+
+    # no dump file should have been generated
+    assert not os.path.exists(str(test_file) + '.dump')
+
+
+# TODO: remove all overrides when fully fixed
+def __test_inline_suppr(tmp_path, extra_args):  # #13087
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write("""
+void f() {
+  // cppcheck-suppress memleak
+}
+""")
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=information',
+        '--inline-suppr',
+        str(test_file)
+    ]
+
+    args += extra_args
+
+    exitcode, stdout, stderr, = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout == ''
+    assert stderr.splitlines() == [
+        '{}:4:0: information: Unmatched suppression: memleak [unmatchedSuppression]'.format(test_file)
+    ]
+
+
+def test_inline_suppr(tmp_path):
+    __test_inline_suppr(tmp_path, ['-j1'])
+
+
+def test_inline_suppr_j(tmp_path):
+    __test_inline_suppr(tmp_path, ['-j2'])
+
+
+def test_inline_suppr_builddir(tmp_path):
+    build_dir = tmp_path / 'b1'
+    os.mkdir(build_dir)
+    __test_inline_suppr(tmp_path, ['--cppcheck-build-dir={}'.format(build_dir), '-j1'])
+
+
+def test_inline_suppr_builddir_cached(tmp_path):
+    build_dir = tmp_path / 'b1'
+    os.mkdir(build_dir)
+    __test_inline_suppr(tmp_path, ['--cppcheck-build-dir={}'.format(build_dir), '-j1'])
+    __test_inline_suppr(tmp_path, ['--cppcheck-build-dir={}'.format(build_dir), '-j1'])
+
+
+def test_inline_suppr_builddir_j(tmp_path):
+    build_dir = tmp_path / 'b1'
+    os.mkdir(build_dir)
+    __test_inline_suppr(tmp_path, ['--cppcheck-build-dir={}'.format(build_dir), '-j2'])
+
+
+def test_inline_suppr_builddir_j_cached(tmp_path):
+    build_dir = tmp_path / 'b1'
+    os.mkdir(build_dir)
+    __test_inline_suppr(tmp_path, ['--cppcheck-build-dir={}'.format(build_dir), '-j2'])
+    __test_inline_suppr(tmp_path, ['--cppcheck-build-dir={}'.format(build_dir), '-j2'])
+
+
+def test_duplicate_suppression(tmp_path):
+    test_file = tmp_path / 'file.cpp'
+    with open(test_file, 'wt'):
+        pass
+
+    args = [
+        '-q',
+        '--suppress=uninitvar',
+        '--suppress=uninitvar',
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 1, stdout
+    assert stdout.splitlines() == [
+        "cppcheck: error: suppression 'uninitvar' already exists"
+    ]
+    assert stderr == ''
+
+
+def test_duplicate_suppressions_list(tmp_path):
+    suppr_file = tmp_path / 'suppressions'
+    with open(suppr_file, 'wt') as f:
+        f.write('''
+uninitvar
+uninitvar
+''')
+
+    test_file = tmp_path / 'file.cpp'
+    with open(test_file, 'wt'):
+        pass
+
+    args = [
+        '-q',
+        '--suppressions-list={}'.format(suppr_file),
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 1, stdout
+    assert stdout.splitlines() == [
+        "cppcheck: error: suppression 'uninitvar' already exists"
+    ]
+    assert stderr == ''
+
+
+def test_duplicate_suppressions_mixed(tmp_path):
+    suppr_file = tmp_path / 'suppressions'
+    with open(suppr_file, 'wt') as f:
+        f.write('uninitvar')
+
+    test_file = tmp_path / 'file.cpp'
+    with open(test_file, 'wt'):
+        pass
+
+    args = [
+        '-q',
+        '--suppress=uninitvar',
+        '--suppressions-list={}'.format(suppr_file),
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 1, stdout
+    assert stdout.splitlines() == [
+        "cppcheck: error: suppression 'uninitvar' already exists"
+    ]
+    assert stderr == ''
+
+
+def test_xml_output(tmp_path):  # #13391 / #13485
+    test_file = tmp_path / 'test.cpp'
+    with open(test_file, 'wt') as f:
+        f.write("""
+void f(const void* p)
+{
+    if(p) {}
+    (void)*p; // REMARK: boom
+}
+""")
+
+    _, version_str, _ = cppcheck(['--version'])
+    version_str = version_str.replace('Cppcheck ', '').strip()
+
+    args = [
+        '-q',
+        '--enable=style',
+        '--xml',
+        str(test_file)
+    ]
+    exitcode_1, stdout_1, stderr_1 = cppcheck(args)
+    assert exitcode_1 == 0, stdout_1
+    assert stdout_1 == ''
+    test_file_exp = str(test_file).replace('\\', '/')
+    assert (stderr_1 ==
+'''<?xml version="1.0" encoding="UTF-8"?>
+<results version="2">
+    <cppcheck version="{}"/>
+    <errors>
+        <error id="nullPointerRedundantCheck" severity="warning" msg="Either the condition &apos;p&apos; is redundant or there is possible null pointer dereference: p." verbose="Either the condition &apos;p&apos; is redundant or there is possible null pointer dereference: p." cwe="476" file0="{}" remark="boom">
+            <location file="{}" line="5" column="12" info="Null pointer dereference"/>
+            <location file="{}" line="4" column="8" info="Assuming that condition &apos;p&apos; is not redundant"/>
+            <symbol>p</symbol>
+        </error>
+    </errors>
+</results>
+'''.format(version_str, test_file_exp, test_file_exp, test_file_exp))
+
+
+def test_outputfile(tmp_path): # #14051
+    test_file = tmp_path / 'test.cpp'
+    out_file = tmp_path / 'out.txt'
+    with open(test_file, 'wt') as f:
+        f.write(
+"""
+int main()
+{
+    int x = 1 / 0;
+}
+""")
+
+    args = [
+        '-q',
+        '--output-file={}'.format(out_file),
+        str(test_file)
+    ]
+
+    out_exp = [
+        '{}:4:15: error: Division by zero. [zerodiv]'.format(test_file),
+        '    int x = 1 / 0;',
+        '              ^',
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout == ''
+    assert stderr == ''
+
+    with open(out_file, 'rt') as f:
+        out_text = f.read()
+
+    assert out_text.splitlines() == out_exp
+
+
+def test_internal_error_loc_int(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write(
+"""
+void f() {
+    int i = 0x10000000000000000;
+}
+""")
+
+    args = [
+        '-q',
+        '--template=simple',
+        str(test_file)
+    ]
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.splitlines() == []
+    assert stderr.splitlines() == [
+        '{}:3:13: error: Internal Error. MathLib::toBigUNumber: out_of_range: 0x10000000000000000 [internalError]'.format(test_file)
+    ]
+
+
+def __test_addon_suppr(tmp_path, extra_args):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write("""
+// cppcheck-suppress misra-c2012-2.3
+typedef int MISRA_5_6_VIOLATION;
+typedef int MISRA_5_6_VIOLATION_1;
+        """)
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=style',
+        '--addon=misra',
+        str(test_file)
+    ]
+
+    args += extra_args
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout == ''
+    assert stderr.splitlines() == [
+        '{}:4:1: style: misra violation (use --rule-texts=<file> to get proper output) [misra-c2012-2.3]'.format(test_file),
+    ]
+
+
+# TODO: remove override when all issues are fixed
+def test_addon_suppr_inline(tmp_path):
+    __test_addon_suppr(tmp_path, ['--inline-suppr', '-j1'])
+
+# TODO: remove override when all issues are fixed
+def test_addon_suppr_inline_j(tmp_path):
+    __test_addon_suppr(tmp_path, ['--inline-suppr', '-j2'])
+
+
+def test_addon_suppr_cli_line(tmp_path):
+    __test_addon_suppr(tmp_path, ['--suppress=misra-c2012-2.3:*:3'])
+
+
+def test_addon_suppr_cli_file_line(tmp_path):
+    __test_addon_suppr(tmp_path, ['--suppress=misra-c2012-2.3:test.c:3'])
+
+
+def test_addon_suppr_cli_absfile_line(tmp_path):
+    test_file = tmp_path / 'test.c'
+    __test_addon_suppr(tmp_path, ['--suppress=misra-c2012-2.3:{}:3'.format(test_file)])
+
+
+def test_ctu_path_builddir(tmp_path):  # #11883
+    build_dir = tmp_path / 'b1'
+    os.mkdir(build_dir)
+
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write("""
+void f(int *p) { *p = 3; }
+int main() {
+    int *p = 0;
+f(p);
+}
+        """)
+
+    args = [
+        '-q',
+        '--enable=style',
+        '--suppress=nullPointer',  # we only care about the CTU findings
+        '--cppcheck-build-dir={}'.format(build_dir),
+        str(test_file)
+    ]
+
+    # the CTU path was not properly read leading to missing location information
+    stderr_exp = [
+        '{}:2:19: error: Null pointer dereference: p [ctunullpointer]'.format(test_file),
+        'void f(int *p) { *p = 3; }',
+        '                  ^',
+        "{}:4:14: note: Assignment 'p=0', assigned value is 0".format(test_file),
+        '    int *p = 0;',
+        '             ^',
+        '{}:5:2: note: Calling function f, 1st argument is null'.format(test_file),
+        'f(p);',
+        ' ^',
+        '{}:2:19: note: Dereferencing argument p that is null'.format(test_file),
+        'void f(int *p) { *p = 3; }',
+        '                  ^'
+    ]
+
+    exitcode_1, stdout_1, stderr_1 = cppcheck(args)
+    assert exitcode_1 == 0, stdout_1
+    assert stdout_1 == ''
+    assert stderr_1.splitlines() == stderr_exp
+
+    exitcode_2, stdout_2, stderr_2 = cppcheck(args)
+    assert exitcode_2 == 0, stdout_2
+    assert stdout_2 == ''
+    assert stderr_2.splitlines() == stderr_exp
+
+
+@pytest.mark.xfail(strict=True)
+def test_ctu_builddir(tmp_path):  # #11883
+    build_dir = tmp_path / 'b1'
+    os.mkdir(build_dir)
+
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write("""
+void f(int *p) { *p = 3; }
+int main() {
+    int *p = 0;
+f(p);
+}
+        """)
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=style',
+        '--suppress=nullPointer',  # we only care about the CTU findings
+        '--cppcheck-build-dir={}'.format(build_dir),
+        '-j1',
+        '--emit-duplicates',
+        str(test_file)
+    ]
+
+    # the CTU was run and then evaluated again from the builddir leading to duplicated findings
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout == ''
+    assert stderr.splitlines() == [
+        '{}:2:19: error: Null pointer dereference: p [ctunullpointer]'.format(test_file)
+    ]
+
+
+def test_debug(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w") as f:
+        f.write(
+"""void f
+{
+    (void)(*((int*)0));
+}
+""")
+
+    args = [
+        '-q',
+        '--debug',
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.find('##file ') != -1
+    assert stdout.find('##Value flow') != -1
+    assert stdout.find('### Symbol database ###') == -1
+    assert stdout.find('##AST') == -1
+    assert stdout.find('### Template Simplifier pass ') == -1
+    assert stderr.splitlines() == []
+
+
+def test_debug_xml(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w") as f:
+        f.write(
+"""void f
+{
+    (void)(*((int*)0));
+}
+""")
+
+    args = [
+        '-q',
+        '--debug',
+        '--xml',
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+
+    assert stderr
+    assert ElementTree.fromstring(stderr) is not None
+
+    assert stdout.find('##file ') != -1  # also exists in CDATA
+    assert stdout.find('##Value flow') == -1
+    assert stdout.find('### Symbol database ###') == -1
+    assert stdout.find('##AST') == -1
+    assert stdout.find('### Template Simplifier pass ') == -1
+
+    debug_xml = ElementTree.fromstring(stdout)
+    assert debug_xml is not None
+    assert debug_xml.tag == 'debug'
+    file_elem = debug_xml.findall('file')
+    assert len(file_elem) == 1
+    valueflow_elem = debug_xml.findall('valueflow')
+    assert len(valueflow_elem) == 1
+    scopes_elem = debug_xml.findall('scopes')
+    assert len(scopes_elem) == 1
+    ast_elem = debug_xml.findall('ast')
+    assert len(ast_elem) == 0
+
+
+def test_debug_verbose(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w") as f:
+        f.write(
+"""void f
+{
+    (void)(*((int*)0));
+}
+""")
+
+    args = [
+        '-q',
+        '--debug',
+        '--verbose',
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.find('##file ') != -1
+    assert stdout.find('##Value flow') != -1
+    assert stdout.find('### Symbol database ###') != -1
+    assert stdout.find('##AST') != -1
+    assert stdout.find('### Template Simplifier pass ') == -1
+    assert stderr.splitlines() == []
+
+
+def test_debug_verbose_xml(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w") as f:
+        f.write(
+"""void f
+{
+    (void)(*((int*)0));
+}
+""")
+
+    args = [
+        '-q',
+        '--debug',
+        '--verbose',
+        '--xml',
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+
+    assert stderr
+    assert ElementTree.fromstring(stderr) is not None
+
+    assert stdout.find('##file ') != -1  # also exists in CDATA
+    assert stdout.find('##Value flow') == -1
+    assert stdout.find('### Symbol database ###') == -1
+    assert stdout.find('##AST') == -1
+    assert stdout.find('### Template Simplifier pass ') == -1
+
+    debug_xml = ElementTree.fromstring(stdout)
+    assert debug_xml is not None
+    assert debug_xml.tag == 'debug'
+    file_elem = debug_xml.findall('file')
+    assert len(file_elem) == 1
+    valueflow_elem = debug_xml.findall('valueflow')
+    assert len(valueflow_elem) == 1
+    scopes_elem = debug_xml.findall('scopes')
+    assert len(scopes_elem) == 1
+    ast_elem = debug_xml.findall('ast')
+    assert len(ast_elem) == 1
+
+
+# TODO: remove interaction with --debug?
+# TODO: test with --xml
+def __test_debug_template(tmp_path, verbose=False, debug=False):
+    test_file = tmp_path / 'test.cpp'
+    with open(test_file, "w") as f:
+        f.write(
+"""template<class T> class TemplCl;
+void f()
+{
+    (void)(*((int*)nullptr));
+}
+""")
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--debug-template',
+        str(test_file)
+    ]
+
+    if verbose:
+        args += ['--verbose']
+    if debug:
+        args += ['--debug']
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    if debug:
+        assert stdout.find('##file ') != -1
+    else:
+        assert stdout.find('##file ') == -1
+    if debug:
+        assert stdout.find('##Value flow') != -1
+    else:
+        assert stdout.find('##Value flow') == -1
+    if debug and verbose:
+        assert stdout.find('### Symbol database ###') != -1
+    else:
+        assert stdout.find('### Symbol database ###') == -1
+    if debug and verbose:
+        assert stdout.find('##AST') != -1
+    else:
+        assert stdout.find('##AST') == -1
+    if debug:
+        assert stdout.count('### Template Simplifier pass ') == 2
+    else:
+        assert stdout.count('### Template Simplifier pass ') == 1
+    assert stderr.splitlines() == [
+        '{}:4:14: error: Null pointer dereference: (int*)nullptr [nullPointer]'.format(test_file)
+    ]
+    return stdout
+
+
+def test_debug_template(tmp_path):
+    __test_debug_template(tmp_path, verbose=False)
+
+
+def test_debug_template_verbose_nodiff(tmp_path):
+    # make sure --verbose does not change the output
+    assert __test_debug_template(tmp_path, verbose=False) == __test_debug_template(tmp_path, verbose=True)
+
+
+def test_debug_template_debug(tmp_path):
+    __test_debug_template(tmp_path, debug=True)
+
+
+@pytest.mark.xfail(strict=True)  # TODO: remove dependency on --verbose
+def test_debug_template_debug_verbose_nodiff(tmp_path):
+    # make sure --verbose does not change the output
+    assert __test_debug_template(tmp_path, debug=True, verbose=False) == __test_debug_template(tmp_path, debug=True, verbose=True)
+
+
+def test_file_ignore_2(tmp_path):  # #13570
+    tests_path = tmp_path / 'tests'
+    os.mkdir(tests_path)
+
+    lib_path = tmp_path / 'lib'
+    os.mkdir(lib_path)
+
+    test_file_1 = lib_path / 'test_1.c'
+    with open(test_file_1, 'wt'):
+        pass
+
+    args = [
+        '-itests',
+        '-itest_1.c',
+        '.'
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args, cwd=tmp_path)
+    assert exitcode == 1, stdout
+    assert stdout.splitlines() == [
+        'cppcheck: error: could not find or open any of the paths given.',
+        'cppcheck: Maybe all paths were ignored?'
+    ]
+    assert stderr.splitlines() == []
+
+
+def test_debug_valueflow_data(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w") as f:
+        f.write(
+"""int f()
+{
+    double d = 1.0 / 0.5;
+    return d;
+}
+""")
+
+    args = [
+        '-q',
+        '--debug-valueflow',
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+
+    # check sections in output
+    assert stdout.find('##file ') == -1
+    assert stdout.find('##Value flow') != -1
+    assert stdout.find('### Symbol database ###') == -1
+    assert stdout.find('##AST') == -1
+    assert stdout.find('### Template Simplifier pass ') == -1
+    assert stderr.splitlines() == []
+
+    # check precision in output - #13607
+    valueflow = stdout[stdout.find('##Value flow'):]
+    assert valueflow.splitlines() == [
+        '##Value flow',
+        'File {}'.format(str(test_file).replace('\\', '/')),
+        'Line 3',
+        '  = always 2.0',
+        '  1.0 always 1.0',
+        '  / always 2.0',
+        '  0.5 always 0.5',
+        'Line 4',
+        '  d always {symbolic=(1.0/0.5),2.0}'
+    ]
+
+
+def test_debug_valueflow_data_xml(tmp_path):  # #13606
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w") as f:
+        f.write(
+"""double f()
+{
+    double d = 0.0000001;
+    return d;
+}
+""")
+
+    args = [
+        '-q',
+        '--debug-valueflow',
+        '--xml',
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+
+    assert stderr
+    assert ElementTree.fromstring(stderr) is not None
+
+    # check sections in output
+    assert stdout.find('##file ') == -1
+    assert stdout.find('##Value flow') == -1
+    assert stdout.find('### Symbol database ###') == -1
+    assert stdout.find('##AST') == -1
+    assert stdout.find('### Template Simplifier pass ') == -1
+
+    # check XML nodes in output
+    debug_xml = ElementTree.fromstring(stdout)
+    assert debug_xml is not None
+    assert debug_xml.tag == 'debug'
+    valueflow_elem = debug_xml.findall('valueflow')
+    assert len(valueflow_elem) == 1
+    scopes_elem = debug_xml.findall('scopes')
+    assert len(scopes_elem) == 1
+    ast_elem = debug_xml.findall('ast')
+    assert len(ast_elem) == 0
+
+    # check precision in output - #13606
+    value_elem = valueflow_elem[0].findall('values/value')
+    assert len(value_elem) == 3
+    assert 'floatvalue' in value_elem[0].attrib
+    assert value_elem[0].attrib['floatvalue'] == '1e-07'
+    assert 'floatvalue' in value_elem[1].attrib
+    assert value_elem[1].attrib['floatvalue'] == '1e-07'
+    assert 'floatvalue' in value_elem[2].attrib
+    assert value_elem[2].attrib['floatvalue'] == '1e-07'
+
+
+def test_dir_ignore(tmp_path):
+    test_file = tmp_path / 'test.cpp'
+    with open(test_file, 'wt'):
+        pass
+
+    lib_dir = tmp_path / 'lib'
+    os.mkdir(lib_dir)
+    lib_test_file = lib_dir / 'test.cpp'
+    with open(lib_test_file, 'wt'):
+        pass
+
+    args = [
+        '-ilib',
+        '--debug-ignore',
+        str(tmp_path)
+    ]
+    # make sure the whole directory is being ignored instead of each of its contents individually
+    out_lines = [
+        'ignored path: {}'.format(lib_dir),
+        'Checking {} ...'.format(test_file)
+    ]
+
+    assert_cppcheck(args, ec_exp=0, err_exp=[], out_exp=out_lines, cwd=str(tmp_path))
+
+
+def test_check_headers(tmp_path):
+    test_file_h = tmp_path / 'test.h'
+    with open(test_file_h, 'wt') as f:
+        f.write(
+"""
+inline void hdr()
+{
+    (void)(*((int*)0));
+}
+""")
+
+    test_file_c = tmp_path / 'test.c'
+    with open(test_file_c, 'wt') as f:
+        f.write(
+"""
+#include "test.h"
+
+void f() {}
+""")
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--no-check-headers',
+        str(test_file_c)
+    ]
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.splitlines() == []
+    assert stderr.splitlines() == []  # no error since the header is not checked
+
+
+def test_unique_error(tmp_path):  # #6366
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write(
+"""void f()
+{
+    const long m[9] = {};
+    long a=m[9], b=m[9];
+    (void)a;
+    (void)b;
+}
+""")
+
+    args = [
+        '-q',
+        '--template=simple',
+        str(test_file)
+    ]
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.splitlines() == []
+    assert stderr.splitlines() == [
+        "{}:4:13: error: Array 'm[9]' accessed at index 9, which is out of bounds. [arrayIndexOutOfBounds]".format(test_file),
+        "{}:4:21: error: Array 'm[9]' accessed at index 9, which is out of bounds. [arrayIndexOutOfBounds]".format(test_file)
+    ]
+
+
+def test_check_unused_templates_class(tmp_path):
+    test_file_h = tmp_path / 'test.h'
+    with open(test_file_h, 'wt') as f:
+        f.write(
+"""template<class T>
+class HdrCl1
+{
+    HdrCl1()
+    {
+        (void)(*((int*)0));
+    }
+};
+
+template<typename T>
+class HdrCl2
+{
+    HdrCl2()
+    {
+        (void)(*((int*)0));
+    }
+};
+
+template<class T>
+struct HdrSt1
+{
+    HdrSt1()
+    {
+        (void)(*((int*)0));
+    }
+};
+
+template<typename T>
+struct HdrSt2
+{
+    HdrSt2()
+    {
+        (void)(*((int*)0));
+    }
+};
+""")
+
+    test_file = tmp_path / 'test.cpp'
+    with open(test_file, 'wt') as f:
+        f.write(
+"""#include "test.h"
+
+template<class T>
+class Cl1
+{
+    CL1()
+    {
+        (void)(*((int*)0));
+    }
+};
+
+template<typename T>
+class Cl2
+{
+    Cl2()
+    {
+        (void)(*((int*)0));
+    }
+};
+
+template<class T>
+struct St1
+{
+    St1()
+    {
+        (void)(*((int*)0));
+    }
+};
+
+template<typename T>
+struct St2
+{
+    St2()
+    {
+        (void)(*((int*)0));
+    }
+};
+
+void f() {}
+""")
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--no-check-unused-templates',
+        str(test_file)
+    ]
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.splitlines() == []
+    assert stderr.splitlines() == []  # no error since the unused templates are not being checked
+
+
+def test_check_unused_templates_func(tmp_path):  # #13714
+    test_file_h = tmp_path / 'test.h'
+    with open(test_file_h, 'wt') as f:
+        f.write(
+"""template<class T>
+void f_t_hdr_1()
+{
+    (void)(*((int*)0));
+}
+
+template<typename T>
+void f_t_hdr_2()
+{
+    (void)(*((int*)0));
+}
+""")
+
+    test_file = tmp_path / 'test.cpp'
+    with open(test_file, 'wt') as f:
+        f.write(
+"""#include "test.h"
+
+template<class T>
+void f_t_1()
+{
+    (void)(*((int*)0));
+}
+
+template<typename T>
+void f_t_2()
+{
+    (void)(*((int*)0));
+}
+
+void f() {}
+""")
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--no-check-unused-templates',
+        str(test_file)
+    ]
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.splitlines() == []
+    assert stderr.splitlines() == []  # no error since the unused templates are not being checked
+
+try:
+    # TODO: handle exitcode?
+    subprocess.call(['clang-tidy', '--version'])
+    has_clang_tidy = True
+except OSError:
+    has_clang_tidy = False
+
+def __test_clang_tidy(tmpdir, use_compdb):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        f.write(
+"""static void foo() // NOLINT(misc-use-anonymous-namespace)
+{
+    (void)(*((int*)nullptr));
+}""")
+
+    project_file = __write_compdb(tmpdir, test_file) if use_compdb else None
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--clang-tidy'
+    ]
+    if project_file:
+        args += ['--project={}'.format(project_file)]
+    else:
+        args += [str(test_file)]
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.splitlines() == [
+    ]
+    assert stderr.splitlines() == [
+        '{}:3:14: error: Null pointer dereference: (int*)nullptr [nullPointer]'.format(test_file),
+        '{}:3:14: style: C-style casts are discouraged; use static_cast/const_cast/reinterpret_cast [clang-tidy-google-readability-casting]'.format(test_file)
+    ]
+
+
+@pytest.mark.skipif(not has_clang_tidy, reason='clang-tidy is not available')
+@pytest.mark.xfail(strict=True)  # TODO: clang-tidy is only invoked with FileSettings - see #12053
+def test_clang_tidy(tmpdir):  # #12053
+    __test_clang_tidy(tmpdir, False)
+
+
+@pytest.mark.skipif(not has_clang_tidy, reason='clang-tidy is not available')
+def test_clang_tidy_project(tmpdir):
+    __test_clang_tidy(tmpdir, True)
+
+
+@pytest.mark.skipif(not has_clang_tidy, reason='clang-tidy is not available')
+def test_clang_tidy_error_exit(tmp_path):  # #13828 / #13829
+    test_file = tmp_path / 'test.cpp'
+    with open(test_file, 'wt') as f:
+        f.write(
+"""#include <string>
+#include <utility>
+
+// cppcheck-suppress clang-tidy-modernize-use-trailing-return-type
+static bool f() // NOLINT(misc-use-anonymous-namespace)
+{
+    std::string str;
+    const std::string str1 = std::move(str);
+    (void)str1;
+    return str.empty();
+}""")
+
+    # TODO: remove project file usage when --clang-tidy works with non-project files
+    project_file = __write_compdb(tmp_path, str(test_file))
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--inline-suppr',
+        '--std=c++11',
+        '--clang-tidy',
+        '--project={}'.format(project_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert stdout.splitlines() == []
+    assert stderr.splitlines() == [
+        "{}:10:12: warning: 'str' used after it was moved [clang-tidy-bugprone-use-after-move]".format(test_file),
+        "{}:10:12: style: 'str' used after it was moved [clang-tidy-hicpp-invalid-access-moved]".format(test_file)
+    ]
+    assert exitcode == 0, stdout
+
+
+def test_suppress_unmatched_wildcard(tmp_path):  # #13660
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write(
+"""void f()
+{
+    (void)(*((int*)0));
+}
+""")
+
+    # need to run in the temporary folder because the path of the suppression has to match
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=information',
+        '--suppress=nullPointer:test*.c',  # checked and matched
+        '--suppress=id:test*.c',  # checked and unmatched
+        '--suppress=id2:test*.c',  # checked and unmatched
+        '--suppress=id2:tes?.c',  # checked and unmatched
+        '--suppress=*:test*.c',  # checked and unmatched
+        '--suppress=id:test*.cpp',  # unchecked
+        '--suppress=id2:test?.cpp',  # unchecked
+        'test.c'
+    ]
+    exitcode, stdout, stderr = cppcheck(args, cwd=tmp_path)
+    assert exitcode == 0, stdout
+    assert stdout.splitlines() == []
+    assert stderr.splitlines() == [
+        'test*.c:0:0: information: Unmatched suppression: id [unmatchedSuppression]',
+        'test*.c:0:0: information: Unmatched suppression: id2 [unmatchedSuppression]',
+        'tes?.c:0:0: information: Unmatched suppression: id2 [unmatchedSuppression]'
+    ]
+
+
+def test_suppress_unmatched_wildcard_cached(tmp_path):  # #14585
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write(
+"""void f()
+{
+    (void)(*((int*)0));
+}
+""")
+
+    build_dir = tmp_path / 'b1'
+    os.makedirs(build_dir)
+
+    # need to run in the temporary folder because the path of the suppression has to match
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=information',
+        '--cppcheck-build-dir={}'.format(build_dir),
+        '--suppress=nullPointer:test*.c',
+        'test.c'
+    ]
+
+    stderr_exp = []
+
+    exitcode, stdout, stderr = cppcheck(args, cwd=tmp_path)
+    assert exitcode == 0, stdout
+    assert stdout.splitlines() == []
+    assert stderr.splitlines() == stderr_exp
+
+    exitcode, stdout, stderr = cppcheck(args, cwd=tmp_path)
+    assert exitcode == 0, stdout
+    assert stdout.splitlines() == []
+    assert stderr.splitlines() == stderr_exp
+
+
+def test_suppress_unmatched_wildcard_unchecked(tmp_path):
+    # make sure that unmatched wildcards suppressions are reported if files matching the expressions were processesd
+    # but isSuppressed() has never been called (i.e. no findings in file at all)
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write("""void f() {}""")
+
+    # need to run in the temporary folder because the path of the suppression has to match
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=information',
+        '--suppress=id:test*.c',
+        '--suppress=id:tes?.c',
+        '--suppress=id2:*',
+        '--suppress=*:test*.c',
+        'test.c'
+    ]
+    exitcode, stdout, stderr = cppcheck(args, cwd=tmp_path)
+    assert exitcode == 0, stdout
+    assert stdout.splitlines() == []
+    assert stderr.splitlines() == [
+        'test*.c:0:0: information: Unmatched suppression: id [unmatchedSuppression]',
+        'tes?.c:0:0: information: Unmatched suppression: id [unmatchedSuppression]',
+        '*:0:0: information: Unmatched suppression: id2 [unmatchedSuppression]',
+        'test*.c:0:0: information: Unmatched suppression: * [unmatchedSuppression]'
+    ]
+
+
+def test_preprocess_enforced_c(tmp_path):  # #10989
+    test_file = tmp_path / 'test.cpp'
+    with open(test_file, 'wt') as f:
+        f.write(
+"""#ifdef __cplusplus
+#error "err"
+#endif""")
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--language=c',
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout if stdout else stderr
+    assert stdout.splitlines() == []
+    assert stderr.splitlines() == []
+
+
+def test_preprocess_enforced_cpp(tmp_path):  # #10989
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write(
+"""#ifdef __cplusplus
+#error "err"
+#endif""")
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--language=c++',
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout if stdout else stderr
+    assert stdout.splitlines() == []
+    assert stderr.splitlines() == [
+        '{}:2:2: error: #error "err" [preprocessorErrorDirective]'.format(test_file)
+    ]
+
+
+def test_preprocess_system_include(tmp_path): # #13928
+    g = glob.glob('/usr/include/c++/*/string')
+    if len(g) != 1:
+        pytest.skip('<string> header file not found')
+
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'wt') as f:
+        f.write('#include <string>\n'
+                ';\n')
+
+    def has_missing_include_string_warning(e):
+        return '<string>' in e
+
+    args = [
+        '--enable=missingInclude',
+        str(test_file)
+    ]
+
+    # include path not provided => missing include warning about <string>
+    _, _, stderr = cppcheck(args)
+    assert has_missing_include_string_warning(stderr), stderr
+
+    # include path provided => no missing include warning about <string>
+    args.append('-I' + os.path.dirname(str(g[0])))
+    _, _, stderr = cppcheck(args)
+    assert not has_missing_include_string_warning(stderr), stderr
+
+
+# TODO: test with --xml
+def __test_debug_normal(tmp_path, verbose):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w") as f:
+        f.write(
+"""void f()
+{
+    (void)(*((int*)0));
+}
+""")
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--debug-normal',
+        str(test_file)
+    ]
+
+    if verbose:
+        args += ['--verbose']
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.find('##file ') != -1
+    assert stdout.find('##Value flow') != -1
+    if verbose:
+        assert stdout.find('### Symbol database ###') != -1
+    else:
+        assert stdout.find('### Symbol database ###') == -1
+    if verbose:
+        assert stdout.find('##AST') != -1
+    else:
+        assert stdout.find('##AST') == -1
+    assert stdout.find('### Template Simplifier pass ') == -1
+    assert stderr.splitlines() == [
+        '{}:3:14: error: Null pointer dereference: (int*)0 [nullPointer]'.format(test_file)
+    ]
+    return stdout
+
+
+def test_debug_normal(tmp_path):
+    __test_debug_normal(tmp_path, False)
+
+
+@pytest.mark.xfail(strict=True)  # TODO: remove dependency on --verbose
+def test_debug_normal_verbose_nodiff(tmp_path):
+    # make sure --verbose does not change the output
+    assert __test_debug_normal(tmp_path, False) == __test_debug_normal(tmp_path, True)
+
+
+# TODO: test with --xml
+def __test_debug_simplified(tmp_path, verbose):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w") as f:
+        f.write(
+"""void f()
+{
+    (void)(*((int*)0));
+}
+""")
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--debug-simplified',
+        str(test_file)
+    ]
+
+    if verbose:
+        args += ['--verbose']
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.find('##file ') != -1
+    assert stdout.find('##Value flow') == -1
+    assert stdout.find('### Symbol database ###') == -1
+    assert stdout.find('##AST') == -1
+    assert stdout.find('### Template Simplifier pass ') == -1
+    assert stderr.splitlines() == [
+        '{}:3:14: error: Null pointer dereference: (int*)0 [nullPointer]'.format(test_file)
+    ]
+    return stdout
+
+
+def test_debug_simplified(tmp_path):
+    __test_debug_simplified(tmp_path, False)
+
+
+def test_debug_simplified_verbose_nodiff(tmp_path):
+    # make sure --verbose does not change the output
+    assert __test_debug_simplified(tmp_path, False) == __test_debug_simplified(tmp_path, True)
+
+
+# TODO: test with --xml
+def __test_debug_symdb(tmp_path, verbose):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w") as f:
+        f.write(
+"""void f()
+{
+    (void)(*((int*)0));
+}
+""")
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--debug-symdb',
+        str(test_file)
+    ]
+
+    if verbose:
+        args += ['--verbose']
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.find('##file ') == -1
+    assert stdout.find('##Value flow') == -1
+    assert stdout.find('### Symbol database ###') != -1
+    assert stdout.find('##AST') == -1
+    assert stdout.find('### Template Simplifier pass ') == -1
+    assert stderr.splitlines() == [
+        '{}:3:14: error: Null pointer dereference: (int*)0 [nullPointer]'.format(test_file)
+    ]
+    return stdout
+
+
+def test_debug_symdb(tmp_path):
+    __test_debug_symdb(tmp_path, False)
+
+
+@pytest.mark.skip  # TODO: this contains memory addresses the output will always differ - would require stable identifier
+def test_debug_symdb_verbose_nodiff(tmp_path):
+    # make sure --verbose does not change the output
+    assert __test_debug_symdb(tmp_path, False) == __test_debug_symdb(tmp_path, True)
+
+
+# TODO: test with --xml
+def __test_debug_ast(tmp_path, verbose):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w") as f:
+        f.write(
+"""void f()
+{
+    (void)(*((int*)0));
+}
+""")
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--debug-ast',
+        str(test_file)
+    ]
+
+    if verbose:
+        args += ['--verbose']
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.find('##file ') == -1
+    assert stdout.find('##Value flow') == -1
+    assert stdout.find('### Symbol database ###') == -1
+    assert stdout.find('##AST') != -1
+    assert stdout.find('### Template Simplifier pass ') == -1
+    assert stderr.splitlines() == [
+        '{}:3:14: error: Null pointer dereference: (int*)0 [nullPointer]'.format(test_file)
+    ]
+    return stdout
+
+
+def test_debug_ast(tmp_path):
+    __test_debug_ast(tmp_path, False)
+
+
+def test_debug_ast_verbose_nodiff(tmp_path):
+    # make sure --verbose does not change the output
+    assert __test_debug_ast(tmp_path, False) == __test_debug_ast(tmp_path, True)
+
+
+# TODO: test with --xml
+def __test_debug_valueflow(tmp_path, verbose):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w") as f:
+        f.write(
+"""void f()
+{
+    (void)(*((int*)0));
+}
+""")
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--debug-valueflow',
+        str(test_file)
+    ]
+
+    if verbose:
+        args += ['--verbose']
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.find('##file ') == -1
+    assert stdout.find('##Value flow') != -1
+    assert stdout.find('### Symbol database ###') == -1
+    assert stdout.find('##AST') == -1
+    assert stdout.find('### Template Simplifier pass ') == -1
+    assert stderr.splitlines() == [
+        '{}:3:14: error: Null pointer dereference: (int*)0 [nullPointer]'.format(test_file)
+    ]
+    return stdout
+
+
+def test_debug_valueflow(tmp_path):
+    __test_debug_valueflow(tmp_path, False)
+
+
+def test_debug_valueflow_verbose_nodiff(tmp_path):
+    # make sure --verbose does not change the output
+    assert __test_debug_valueflow(tmp_path, False) == __test_debug_valueflow(tmp_path, True)
+
+
+def test_debug_syntaxerror_c(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w") as f:
+        f.write(
+"""
+template<class T> class TemplCl;
+void f()
+{
+    (void)(*((int*)0));
+}
+""")
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--debug-normal',
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.find('##file ') != -1
+    assert stdout.find('##Value flow') != -1
+    assert stdout.find('### Symbol database ###') == -1
+    assert stdout.find('##AST') == -1
+    assert stdout.find('### Template Simplifier pass ') == -1
+    assert stderr.splitlines() == [
+        "{}:2:1: error: Code 'template<...' is invalid C code. [syntaxError]".format(test_file)
+    ]
+
+
+def test_ast_max_depth(tmp_path):
+    test_file = tmp_path / 'test.cpp'
+    with open(test_file, "w") as f:
+        f.write(
+"""
+#define PTR1 (* (* (* (*
+#define PTR2 PTR1 PTR1 PTR1 PTR1
+#define PTR3 PTR2 PTR2 PTR2 PTR2
+#define PTR4 PTR3 PTR3 PTR3 PTR3
+
+#define RBR1 ) ) ) )
+#define RBR2 RBR1 RBR1 RBR1 RBR1
+#define RBR3 RBR2 RBR2 RBR2 RBR2
+#define RBR4 RBR3 RBR3 RBR3 RBR3
+
+int PTR4 q4_var RBR4 = 0;
+""")
+
+    args = [
+        '-q',
+        '--template=simple',
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.splitlines() == []
+    assert stderr.splitlines() == [
+        '{}:12:5: error: maximum AST depth exceeded [internalAstError]'.format(test_file)
+    ]
+
+
+# do not report unmatched misra-* suppressions when misra is not provided
+def test_misra_disabled_unmatched(tmp_path):  #14232
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w"):
+        pass
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=warning,information',
+        '--suppress=misra-c2012-20.5',
+        '--suppress=uninitvar',
+        str(test_file)
+    ]
+
+    ret, stdout, stderr = cppcheck(args)
+    assert stderr.splitlines() == [
+        'nofile:0:0: information: Unmatched suppression: uninitvar [unmatchedSuppression]'
+    ]
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+# do not report unmatched premium-* suppressions when application is not premium
+def test_premium_disabled_unmatched(tmp_path):  #13663
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w"):
+        pass
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=warning,information',
+        '--suppress=premium-misra-cpp-2023-12.2.1',
+        '--suppress=uninitvar',
+        str(test_file)
+    ]
+
+    ret, stdout, stderr = cppcheck(args)
+    assert stderr.splitlines() == [
+        'nofile:0:0: information: Unmatched suppression: uninitvar [unmatchedSuppression]'
+    ]
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+def test_unmatched_file(tmp_path):  # #14248 / #14249
+    lib_path = tmp_path / 'lib'
+    os.makedirs(lib_path)
+
+    test_file = lib_path / 'test.c'
+    with open(test_file, "w"):
+        pass
+
+    suppr_txt = tmp_path / 'suppr.txt'
+    with open(suppr_txt, "w") as f:
+        f.write('''
+error:lib/test.c
+error2:lib\\test.c
+''')
+
+    suppr_xml = tmp_path / 'suppr.xml'
+    with open(suppr_xml, "w") as f:
+        f.write('''
+<suppressions>
+    <suppress>
+        <id>error3</id>
+        <fileName>lib/test.c</fileName>
+    </suppress>
+    <suppress>
+        <id>error4</id>
+        <fileName>lib\\test.c</fileName>
+    </suppress>
+</suppressions>
+''')
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=information',
+        f'--suppressions-list={suppr_txt}',
+        f'--suppress-xml={suppr_xml}',
+        '--suppress=error5:lib/test.c',
+        '--suppress=error6:lib\\test.c',
+        str(test_file)
+    ]
+
+    lib_file = 'lib' + os.path.sep + 'test.c'
+
+    ret, stdout, stderr = cppcheck(args)
+    assert stdout == ''
+    assert stderr.splitlines() == [
+        f'{lib_file}:0:0: information: Unmatched suppression: error [unmatchedSuppression]',
+        f'{lib_file}:0:0: information: Unmatched suppression: error2 [unmatchedSuppression]',
+        f'{lib_file}:0:0: information: Unmatched suppression: error3 [unmatchedSuppression]',
+        f'{lib_file}:0:0: information: Unmatched suppression: error4 [unmatchedSuppression]',
+        f'{lib_file}:0:0: information: Unmatched suppression: error5 [unmatchedSuppression]',
+        f'{lib_file}:0:0: information: Unmatched suppression: error6 [unmatchedSuppression]'
+    ]
+    assert ret == 0, stdout
+
+
+def test_simplecpp_warning(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w") as f:
+        f.write(
+"""
+#define warning "warn msg"
+""")
+
+    args = [
+        '-q',
+        '--template=simple',
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.splitlines() == []
+    assert stderr.splitlines() == []
+
+
+def test_simplecpp_unhandled_char(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w", encoding='utf-8') as f:
+        f.write(
+"""
+int 你=0;
+""")
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--emit-duplicates',
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.splitlines() == []
+    assert stderr.splitlines() == [
+        '{}:2:5: error: The code contains unhandled character(s) (character code=228). Neither unicode nor extended ascii is supported. [unhandledChar]'.format(test_file)
+    ]
+
+
+def test_simplecpp_include_nested_too_deeply(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w") as f:
+        f.write('#include "test.h"')
+
+    test_h = tmp_path / 'test.h'
+    with open(test_h, "w") as f:
+        f.write('#include "test_0.h"')
+
+    for i in range(400):
+        test_h = tmp_path / f'test_{i}.h'
+        with open(test_h, "w") as f:
+            f.write('#include "test_{}.h"'.format(i+1))
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--emit-duplicates',
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.splitlines() == []
+    test_h = tmp_path / 'test_398.h'
+    assert stderr.splitlines() == [
+        # TODO: should only report the error once
+        '{}:1:2: error: #include nested too deeply [includeNestedTooDeeply]'.format(test_h),
+        '{}:1:2: error: #include nested too deeply [includeNestedTooDeeply]'.format(test_h)
+    ]
+
+
+def test_simplecpp_syntax_error(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w") as f:
+        f.write('#include ""')
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--emit-duplicates',
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.splitlines() == []
+    assert stderr.splitlines() == [
+        # TODO: should only report the error once
+        '{}:1:2: error: No header in #include [syntaxError]'.format(test_file),
+        '{}:1:2: error: No header in #include [syntaxError]'.format(test_file)
+    ]
+
+
+@pytest.mark.parametrize('max_configs,number_of_configs,check_config,expected_warn', [
+    # max configs = default, max configs < number of configs => warn
+    (None, 20, False, True),
+    (None, 20, True, True),
+
+    # max configs != default, max configs < number of configs => warn if --check-config
+    (6, 20, False, False),
+    (6, 20, True, True),
+
+    # max configs >= number of configs => no warning
+    (20, 20, False, False),
+    (20, 20, False, False)
+])
+def test_max_configs(tmp_path, max_configs, number_of_configs, check_config, expected_warn):
+    test_file = tmp_path / 'test.cpp'
+    with open(test_file, "w") as f:
+        for i in range(1,number_of_configs):
+            dir = 'if' if i == 1 else 'elif'
+            f.write(f'#{dir} defined(X{i})\nx = {i};\n')
+        f.write('#endif\n')
+
+    args = ['--enable=information', '--template=simple', str(test_file)]
+
+    if max_configs is None:
+        max_configs = 12  # default value
+    else:
+        args = [f'--max-configs={max_configs}'] + args
+
+    if check_config:
+        args = ['--check-config'] + args
+
+    # default max configs is set to 12, warn if code contains more configurations than that
+    _, _, stderr = cppcheck(args)
+    if not expected_warn:
+        assert stderr.splitlines() == []
+    else:
+        assert stderr.splitlines() == [
+            '{}:0:0: information: Too many #ifdef configurations - cppcheck only checks {} of {} configurations. Use --force to check all configurations. [toomanyconfigs]'
+            .format(test_file, max_configs, number_of_configs)
+        ]
+
+
+def test_no_valid_configuration(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w") as f:
+        f.write(
+"""#include ""
+#ifdef DEF_1
+#include ""
+#endif
+""")
+
+    args = [
+        '--template=simple',
+        '--emit-duplicates',
+        '--enable=information',
+        '--suppress=checkersReport',
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.splitlines() == [
+        'Checking {} ...'.format(test_file)
+    ]
+    # TODO: this lacks context about the configuration which encounters these errors
+    # TODO: add message when a configuration is dropped?
+    assert stderr.splitlines() == [
+        # TODO: should only report the error once
+        '{}:1:2: error: No header in #include [syntaxError]'.format(test_file),
+        '{}:1:2: error: No header in #include [syntaxError]'.format(test_file),
+        '{}:1:2: error: No header in #include [syntaxError]'.format(test_file),
+        '{}:0:0: information: This file is not analyzed. No working configuration could be extracted. Use -v for more details. [noValidConfiguration]'.format(test_file)
+    ]
+
+
+def test_no_valid_configuration_check_config(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w") as f:
+        f.write(
+"""#include ""
+#ifdef DEF_1
+#include ""
+#endif
+""")
+
+    args = [
+        '--template=simple',
+        '--emit-duplicates',
+        '--enable=information',
+        '--suppress=checkersReport',
+        '--check-config',
+        str(test_file)
+    ]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert exitcode == 0, stdout
+    assert stdout.splitlines() == [
+        'Checking {} ...'.format(test_file)
+    ]
+    # TODO: this lacks context about the configuration which encounters these errors
+    # TODO: add message when a configuration is dropped
+    assert stderr.splitlines() == [
+        '{}:1:2: error: No header in #include [syntaxError]'.format(test_file),
+        '{}:1:2: error: No header in #include [syntaxError]'.format(test_file)
+    ]
+
+
+def __test_active_checkers(tmp_path, active_cnt, total_cnt, use_misra=False, use_unusedfunction_only=False, checkers_exp=None):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, 'w') as f:
+        f.write('int i;')
+
+    build_dir = None
+    if checkers_exp is not None:
+        build_dir = tmp_path / 'b1'
+        os.makedirs(build_dir)
+
+    args = [
+        '-q',
+        '--enable=information',
+        '-j1',
+        str(test_file)
+    ]
+
+    if use_misra:
+        args += ['--addon=misra']
+    if build_dir:
+        args += ['--cppcheck-build-dir={}'.format(build_dir)]
+    else:
+        args += ['--no-cppcheck-build-dir']
+
+    env = {}
+    if use_unusedfunction_only:
+        env = {'UNUSEDFUNCTION_ONLY': '1'}
+        args += ['--enable=unusedFunction']
+    exitcode, stdout, stderr, _ = cppcheck_ex(args, remove_checkers_report=False, env=env)
+    assert exitcode == 0, stdout
+    assert stdout.splitlines() == []
+    assert stderr.splitlines() == [
+        f'nofile:0:0: information: Active checkers: {active_cnt}/{total_cnt} (use --checkers-report=<filename> to see details) [checkersReport]',
+        ''  # TODO: get rid of extra newline
+    ]
+
+    if build_dir:
+        checkers_file = build_dir / 'checkers.txt'
+        with open(checkers_file, 'r') as f:
+            checkers = f.read().splitlines()
+
+        assert checkers == checkers_exp
+        assert len(checkers) == active_cnt
+
+
+def test_active_unusedfunction_only(tmp_path):
+    __test_active_checkers(tmp_path, 1, 186, use_unusedfunction_only=True)
+
+
+def test_active_unusedfunction_only_builddir(tmp_path):
+    checkers_exp = [
+        'CheckUnusedFunctions::check'
+    ]
+    __test_active_checkers(tmp_path, 1, 186, use_unusedfunction_only=True, checkers_exp=checkers_exp)
+
+
+def test_active_unusedfunction_only_misra(tmp_path):
+    __test_active_checkers(tmp_path, 1, 386, use_unusedfunction_only=True, use_misra=True)
+
+
+def test_active_unusedfunction_only_misra_builddir(tmp_path):
+    checkers_exp = [
+        'CheckUnusedFunctions::check'
+    ]
+    __test_active_checkers(tmp_path, 1, 386, use_unusedfunction_only=True, use_misra=True, checkers_exp=checkers_exp)
+
+
+def test_analyzerinfo(tmp_path):
+    test_file = tmp_path / 'test.c'
+    with open(test_file, "w") as f:
+        f.write(
+"""void f()
+{
+    (void)(*((int*)0));
+}
+""")
+
+    build_dir = tmp_path / 'b1'
+    os.makedirs(build_dir)
+
+    test_a1_file = build_dir / 'test.a1'
+
+    args = [
+        '-q',
+        '--debug-analyzerinfo',
+        '--template=simple',
+        '--cppcheck-build-dir={}'.format(build_dir),
+        '--enable=all',
+        str(test_file)
+    ]
+
+    stderr_exp = [
+        '{}:3:14: error: Null pointer dereference: (int*)0 [nullPointer]'.format(test_file),
+        "{}:1:6: style: The function 'f' is never used. [unusedFunction]".format(test_file)
+    ]
+
+    def run_and_assert_cppcheck(stdout_exp):
+        exitcode, stdout, stderr = cppcheck(args)
+        assert exitcode == 0, stdout
+        assert stdout.splitlines() == stdout_exp
+        assert stderr.splitlines() == stderr_exp
+
+    test_file_s = str(test_file).replace('\\', '/')
+    test_a1_file_s = str(test_a1_file).replace('\\', '/')
+
+    # no cached results
+    run_and_assert_cppcheck([
+        "no cached result '{}' for '{}' found".format(test_a1_file_s, test_file_s)
+    ])
+
+    # cached results
+    run_and_assert_cppcheck([
+        "skipping analysis - loaded 1 cached finding(s) from '{}' for '{}'".format(test_a1_file_s, test_file_s)
+    ])
+
+    # modified file
+    with open(test_file, 'a') as f:
+        f.write('\n#define DEF')
+
+    run_and_assert_cppcheck([
+        "discarding cached result from '{}' for '{}' - hash mismatch".format(test_a1_file_s, test_file_s)
+    ])
+
+    # invalid XML
+    with open(test_a1_file, 'a') as f:
+        f.write('.')
+
+    run_and_assert_cppcheck([
+        "discarding cached result - failed to load '{}' for '{}' (XML_ERROR_PARSING_TEXT)".format(test_a1_file_s, test_file_s)
+    ])
+
+    # missing root node
+    with open(test_a1_file, 'w') as f:
+        f.write('<?xml version="1.0"?>')
+
+    run_and_assert_cppcheck([
+        "discarding cached result from '{}' for '{}' - no root node found".format(test_a1_file_s, test_file_s)
+    ])
+
+    # mismatched root node
+    with open(test_a1_file, 'w') as f:
+        f.write('<?xml version="1.0"?><root/>')
+
+    run_and_assert_cppcheck([
+        "discarding cached result from '{}' for '{}' - unexpected root node".format(test_a1_file_s, test_file_s)
+    ])
+
+    # missing 'hash' attribute
+    with open(test_a1_file, 'w') as f:
+        f.write('<?xml version="1.0"?><analyzerinfo/>')
+
+    run_and_assert_cppcheck([
+        "discarding cached result from '{}' for '{}' - no 'hash' attribute found".format(test_a1_file_s, test_file_s)
+    ])
+
+    # invalid 'hash' attribute
+    with open(test_a1_file, 'w') as f:
+        f.write('<?xml version="1.0"?><analyzerinfo hash="hash"/>')
+
+    run_and_assert_cppcheck([
+        "discarding cached result from '{}' for '{}' - hash mismatch".format(test_a1_file_s, test_file_s)
+    ])
+
+    # TODO:
+    # - invalid error
+    # - internalError
+
+
+def test_ctu_function_call_path_slash(tmp_path):  # #14591
+    test_file = tmp_path / 'test.cpp'
+    with open(test_file, "w") as f:
+        f.write(
+"""void g(T* p)
+{
+    *p = 0;
+}
+
+void f(T* p)
+{
+    p = nullptr;
+    g(p);
+}
+""")
+
+    build_dir = tmp_path / 'b1'
+    os.makedirs(build_dir)
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--cppcheck-build-dir={}'.format(build_dir),
+        str(test_file)
+    ]
+
+    exitcode, _, _ = cppcheck(args)
+    assert exitcode == 0
+
+    test_a1_file = build_dir / 'test.a1'
+    analyzerinfo = ElementTree.fromstring(test_a1_file.read_text())
+    function_call_paths = analyzerinfo.findall('FileInfo/function-call/path')
+    assert len(function_call_paths) == 1
+    file = function_call_paths[0].attrib['file']
+    assert file
+    assert not '\\' in file  # the path was incorrectly converted to native
diff --git a/test/cli/performance_test.py b/test/cli/performance_test.py
new file mode 100644
index 00000000000..55da3b3b04e
--- /dev/null
+++ b/test/cli/performance_test.py
@@ -0,0 +1,415 @@
+
+# python -m pytest performance_test.py
+
+import os
+import sys
+
+import pytest
+
+from testutils import cppcheck
+
+
+
+@pytest.mark.timeout(10)
+def test_slow_array_many_floats(tmpdir):
+    # 11649
+    # cppcheck valueflow takes a long time when an array has many floats
+    filename = os.path.join(tmpdir, 'hang.c')
+    with open(filename, 'wt') as f:
+        f.write("const float f[] = {\n")
+        for _ in range(20000):
+            f.write('    13.6f,\n')
+        f.write("};\n")
+    cppcheck([filename]) # should not take more than ~1 second
+
+
+@pytest.mark.timeout(10)
+def test_slow_array_many_strings(tmpdir):
+    # 11901
+    # cppcheck valueflow takes a long time when analyzing a file with many strings
+    filename = os.path.join(tmpdir, 'hang.c')
+    with open(filename, 'wt') as f:
+        f.write("const char *strings[] = {\n")
+        for _ in range(20000):
+            f.write('    "abc",\n')
+        f.write("};\n")
+    cppcheck([filename]) # should not take more than ~1 second
+
+
+@pytest.mark.timeout(10)
+def test_slow_long_line(tmpdir):
+    # simplecpp #314
+    filename = os.path.join(tmpdir, 'hang.c')
+    with open(filename, 'wt') as f:
+        f.write("#define A() static const int a[] = {\\\n")
+        for _ in range(5000):
+            f.write(" -123, 456, -789,\\\n")
+        f.write("};\n")
+    cppcheck([filename]) # should not take more than ~1 second
+
+
+@pytest.mark.timeout(60)
+def test_slow_large_constant_expression(tmpdir):
+    # 12182
+    filename = os.path.join(tmpdir, 'hang.c')
+    with open(filename, 'wt') as f:
+        f.write("""
+#define FLAG1 0
+#define FLAG2 0
+#define FLAG3 0
+#define FLAG4 0
+#define FLAG5 0
+#define FLAG6 0
+#define FLAG7 0
+#define FLAG8 0
+#define FLAG9 0
+#define FLAG10 0
+#define FLAG11 0
+#define FLAG12 0
+#define FLAG13 0
+#define FLAG14 0
+#define FLAG15 0
+#define FLAG16 0
+#define FLAG17 0
+#define FLAG18 0
+#define FLAG19 0
+#define FLAG20 0
+#define FLAG21 0
+#define FLAG22 0
+#define FLAG23 0
+#define FLAG24 0
+
+#define maxval(x, y) ((x) > (y) ? (x) : (y))
+
+#define E_SAMPLE_SIZE   maxval( FLAG1,                \
+                                  maxval( FLAG2,      \
+                                  maxval( FLAG3,      \
+                                  maxval( FLAG4,      \
+                                  maxval( FLAG5,      \
+                                  maxval( FLAG6,      \
+                                  maxval( FLAG7,      \
+                                  maxval( FLAG8,      \
+                                  maxval( FLAG9,      \
+                                  maxval( FLAG10,     \
+                                  maxval( FLAG11,     \
+                                  maxval( FLAG12,     \
+                                  maxval( FLAG13,     \
+                                  maxval( FLAG14,     \
+                                  FLAG15 ))))))))))))))
+
+#define SAMPLE_SIZE       maxval( E_SAMPLE_SIZE,      \
+                                  maxval( sizeof(st), \
+                                  maxval( FLAG16,     \
+                                  maxval( FLAG17,     \
+                                  maxval( FLAG18,     \
+                                  maxval( FLAG19,     \
+                                  maxval( FLAG20,     \
+                                  maxval( FLAG21,     \
+                                  maxval( FLAG22,     \
+                                  maxval( FLAG23,     \
+                                          FLAG24 ))))))))))
+
+typedef struct {
+    int n;
+} st;
+
+x = SAMPLE_SIZE;
+        """)
+
+    cppcheck([filename])
+
+@pytest.mark.timeout(10)
+def test_slow_exprid(tmpdir):
+    # 11885
+    filename = os.path.join(tmpdir, 'hang.c')
+    with open(filename, 'wt') as f:
+        f.write("""
+int foo(int a, int b)
+{
+#define A0(a, b)  ((a) + (b))
+#define A1(a, b)  ((a) > (b)) ? A0((a) - (b), (b)) : A0((b) - (a), (a))
+#define A2(a, b)  ((a) > (b)) ? A1((a) - (b), (b)) : A1((b) - (a), (a))
+#define A3(a, b)  ((a) > (b)) ? A2((a) - (b), (b)) : A2((b) - (a), (a))
+#define A4(a, b)  ((a) > (b)) ? A3((a) - (b), (b)) : A3((b) - (a), (a))
+#define A5(a, b)  ((a) > (b)) ? A4((a) - (b), (b)) : A4((b) - (a), (a))
+#define A6(a, b)  ((a) > (b)) ? A5((a) - (b), (b)) : A5((b) - (a), (a))
+#define A7(a, b)  ((a) > (b)) ? A6((a) - (b), (b)) : A6((b) - (a), (a))
+#define A8(a, b)  ((a) > (b)) ? A7((a) - (b), (b)) : A7((b) - (a), (a))
+#define A9(a, b)  ((a) > (b)) ? A8((a) - (b), (b)) : A8((b) - (a), (a))
+#define A10(a, b) ((a) > (b)) ? A9((a) - (b), (b)) : A9((b) - (a), (a))
+#define A11(a, b) ((a) > (b)) ? A10((a) - (b), (b)) : A10((b) - (a), (a))
+	return A8(a, b);
+}
+        """)
+
+    my_env = os.environ.copy()
+    my_env["DISABLE_VALUEFLOW"] = "1"
+    cppcheck([filename], env=my_env)
+
+@pytest.mark.timeout(35)
+def test_stack_overflow_AST(tmpdir):
+    # 14435
+    filename = os.path.join(tmpdir, 'hang.cpp')
+    with open(filename, 'wt') as f:
+        f.write("""
+#define ROW 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+#define ROW8 ROW ROW ROW ROW ROW ROW ROW ROW
+#define ROW64 ROW8 ROW8 ROW8 ROW8 ROW8 ROW8 ROW8 ROW8
+#define ROW512 ROW64 ROW64 ROW64 ROW64 ROW64 ROW64 ROW64 ROW64
+#define ROW4096 ROW512 ROW512 ROW512 ROW512 ROW512 ROW512 ROW512 ROW512
+#define ROW32768 ROW4096 ROW4096 ROW4096 ROW4096 ROW4096 ROW4096 ROW4096 ROW4096
+void f(std::vector<int>& v) {
+	v = {
+		ROW32768 0
+	};
+}
+        """)
+
+    my_env = os.environ.copy()
+    my_env["DISABLE_VALUEFLOW"] = "1"
+    cppcheck([filename], env=my_env)
+
+
+@pytest.mark.timeout(10)
+def test_slow_initlist_varchanged(tmpdir):
+    # #12235
+    filename = os.path.join(tmpdir, 'hang.cpp')
+    with open(filename, 'wt') as f:
+        f.write(r"""
+                struct T {
+                    int* q;
+                    int nx, ny;
+                };
+                struct S {
+                    void f();
+                    int n;
+                    T* p;
+                };
+                #define ROW 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 ,
+                #define ROW4 ROW ROW ROW ROW
+                #define ROW16 ROW4 ROW4 ROW4 ROW4
+                #define ROW64 ROW16 ROW16 ROW16 ROW16
+                #define ROW256 ROW64 ROW64 ROW64 ROW64
+                #define ROW1K ROW256 ROW256 ROW256 ROW256
+                #define ROW4K ROW1K ROW1K ROW1K ROW1K
+                const int A[] = {
+                    ROW4K
+                };
+                void S::f() {
+                    for (int i = 0; i < n; ++i) {
+                        T& t = p[i];
+                        for (int y = 0; y < t.ny; y += 4) {
+                            int* row0 = t.q + y * t.nx;
+                            for (int x = 0; x < t.nx; x += 4) {
+                                int s[16] = {};
+                                memcpy(row0, &s[0], 4);
+                                row0 += 4;
+                            }
+                        }
+                    }
+                }""")
+    cppcheck([filename]) # should not take more than ~1 second
+
+
+@pytest.mark.timeout(10)
+def test_slow_many_scopes(tmpdir):
+    # #12038
+    filename = os.path.join(tmpdir, 'hang.cpp')
+    with open(filename, 'wt') as f:
+        f.write(r"""
+                #define BLOCK {\
+                    char buf[sizeof("x") + 5 * 3 + 16];\
+                    int rc;\
+                    memset(buf, cmp[0], sizeof buf);\
+                    rc = sprintf(buf + 5, "x");\
+                    assert(rc == sizeof("x") - 1);\
+                    assert(memcmp(buf, cmp, 5) == 0);\
+                    if ((rc) >= 0) {\
+                        assert(memcmp(buf + 5, ("x"), (rc)) == 0);\
+                        assert(buf[5 + (rc)] == '\0');\
+                    }\
+                    assert(memcmp(buf + 5 + (rc) + 1, cmp, 5) == 0);\
+                }
+                #define BLOCK2 BLOCK BLOCK
+                #define BLOCK4 BLOCK2 BLOCK2
+                #define BLOCK8 BLOCK4 BLOCK4
+                #define BLOCK16 BLOCK8 BLOCK8
+                #define BLOCK32 BLOCK16 BLOCK16
+                #define BLOCK64 BLOCK32 BLOCK32
+                int main() {
+                    char cmp[5];
+                    memset(cmp, '\376', sizeof cmp);
+                    BLOCK64
+                    return EXIT_SUCCESS;
+                }""")
+    cppcheck([filename]) # should not take more than ~1 second
+
+
+@pytest.mark.skipif(sys.platform == 'darwin', reason='GitHub macOS runners are too slow')
+@pytest.mark.timeout(20)
+def test_crash_array_in_namespace(tmpdir):
+    # 12847
+    filename = os.path.join(tmpdir, 'hang.cpp')
+    with open(filename, 'wt') as f:
+        f.write(r"""
+                #define ROW A, A, A, A, A, A, A, A,
+                #define ROW8 ROW ROW ROW ROW ROW ROW ROW ROW
+                #define ROW64 ROW8 ROW8 ROW8 ROW8 ROW8 ROW8 ROW8 ROW8
+                #define ROW512 ROW64 ROW64 ROW64 ROW64 ROW64 ROW64 ROW64 ROW64
+                #define ROW4096 ROW512 ROW512 ROW512 ROW512 ROW512 ROW512 ROW512 ROW512
+                namespace N {
+                    static const char A = 'a';
+                    const char a[] = {
+                        ROW4096 ROW4096 ROW4096 ROW4096
+                    };
+                }""")
+    cppcheck([filename]) # should not take more than ~5 seconds
+
+
+@pytest.mark.skipif(sys.platform == 'darwin', reason='GitHub macOS runners are too slow')
+@pytest.mark.timeout(20)
+def test_crash_array_in_array(tmpdir):
+    # 12861
+    filename = os.path.join(tmpdir, 'hang.cpp')
+    with open(filename, 'wt') as f:
+        f.write(r"""
+                #define ROW A, A, A, A, A, A, A, A,
+                #define ROW8 ROW ROW ROW ROW ROW ROW ROW ROW
+                #define ROW64 ROW8 ROW8 ROW8 ROW8 ROW8 ROW8 ROW8 ROW8
+                #define ROW512 ROW64 ROW64 ROW64 ROW64 ROW64 ROW64 ROW64 ROW64
+                #define ROW4096 ROW512 ROW512 ROW512 ROW512 ROW512 ROW512 ROW512 ROW512
+                void f() {
+                    static const char A = 'a';
+                    const char a[] = {
+                        ROW4096 ROW4096 ROW4096 ROW4096
+                    };
+                }""")
+    cppcheck([filename])
+
+
+@pytest.mark.timeout(5)
+def test_slow_bifurcate(tmpdir):
+    # #14134
+    filename = os.path.join(tmpdir, 'hang.cpp')
+    with open(filename, 'wt') as f:
+        f.write(r"""
+                class C {
+                public:
+	                enum class Status {
+                		Ok,
+                		Waiting,
+                		Error,
+                	};
+                	void setStatus(Status status, const QString& text);
+                	QColor m_statusColor;
+                };
+
+                template < size_t N, typename T >
+                inline QDataStream& deserialize(QDataStream& in, T& value) {
+                	if constexpr (N == 0) {}
+                	else if constexpr (N == 1) {
+                		auto& [f1] = value;
+                		in >> f1;
+                	}
+                	else if constexpr (N == 2) {
+                		auto& [f1, f2] = value;
+                		in >> f1 >> f2;
+                	}
+                	else if constexpr (N == 3) {
+                		auto& [f1, f2, f3] = value;
+                		in >> f1 >> f2 >> f3;
+                	}
+                	else if constexpr (N == 4) {
+                		auto& [f1, f2, f3, f4] = value;
+                		in >> f1 >> f2 >> f3 >> f4;
+                	}
+                	else if constexpr (N == 5) {
+                		auto& [f1, f2, f3, f4, f5] = value;
+                		in >> f1 >> f2 >> f3 >> f4 >> f5;
+                	}
+                	else if constexpr (N == 6) {
+                		auto& [f1, f2, f3, f4, f5, f6] = value;
+                		in >> f1 >> f2 >> f3 >> f4 >> f5 >> f6;
+                	}
+                	else if constexpr (N == 7) {
+                		auto& [f1, f2, f3, f4, f5, f6, f7] = value;
+                		in >> f1 >> f2 >> f3 >> f4 >> f5 >> f6 >> f7;
+                	}
+                	else if constexpr (N == 8) {
+                		auto& [f1, f2, f3, f4, f5, f6, f7, f8] = value;
+                		in >> f1 >> f2 >> f3 >> f4 >> f5 >> f6 >> f7 >> f8;
+                	}
+                	else if constexpr (N == 9) {
+                		auto& [f1, f2, f3, f4, f5, f6, f7, f8, f9] = value;
+                		in >> f1 >> f2 >> f3 >> f4 >> f5 >> f6 >> f7 >> f8 >> f9;
+                	}
+                	else if constexpr (N == 10) {
+                		auto& [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10] = value;
+                		in >> f1 >> f2 >> f3 >> f4 >> f5 >> f6 >> f7 >> f8 >> f9 >> f10;
+                	}
+                	else if constexpr (N == 11) {
+                		auto& [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11] = value;
+                		in >> f1 >> f2 >> f3 >> f4 >> f5 >> f6 >> f7 >> f8 >> f9 >> f10 >> f11;
+	                }
+                	else if constexpr (N == 12) {
+                		auto& [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12] = value;
+                		in >> f1 >> f2 >> f3 >> f4 >> f5 >> f6 >> f7 >> f8 >> f9 >> f10 >> f11 >> f12;
+                	}
+                	else if constexpr (N == 13) {
+                		auto& [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13] = value;
+                		in >> f1 >> f2 >> f3 >> f4 >> f5 >> f6 >> f7 >> f8 >> f9 >> f10 >> f11 >> f12 >> f13;
+                	}
+                	else if constexpr (N == 14) {
+                		auto& [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14] = value;
+                		in >> f1 >> f2 >> f3 >> f4 >> f5 >> f6 >> f7 >> f8 >> f9 >> f10 >> f11 >> f12 >> f13 >> f14;
+                	}
+                	else if constexpr (N == 15) {
+                		auto& [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15] = value;
+                		in >> f1 >> f2 >> f3 >> f4 >> f5 >> f6 >> f7 >> f8 >> f9 >> f10 >> f11 >> f12 >> f13 >> f14 >> f15;
+                	}
+                	else if constexpr (N == 16) {
+                		auto& [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16] = value;
+                		in >> f1 >> f2 >> f3 >> f4 >> f5 >> f6 >> f7 >> f8 >> f9 >> f10 >> f11 >> f12 >> f13 >> f14 >> f15 >> f16;
+                	}
+                	else if constexpr (N == 17) {
+                		auto& [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17] = value;
+                		in >> f1 >> f2 >> f3 >> f4 >> f5 >> f6 >> f7 >> f8 >> f9 >> f10 >> f11 >> f12 >> f13 >> f14 >> f15 >> f16 >> f17;
+                	}
+                	else if constexpr (N == 18) {
+                		auto& [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18] = value;
+                		in >> f1 >> f2 >> f3 >> f4 >> f5 >> f6 >> f7 >> f8 >> f9 >> f10 >> f11 >> f12 >> f13 >> f14 >> f15 >> f16 >> f17 >> f18;
+                	}
+                	else if constexpr (N == 19) {
+                		auto& [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19] = value;
+                		in >> f1 >> f2 >> f3 >> f4 >> f5 >> f6 >> f7 >> f8 >> f9 >> f10 >> f11 >> f12 >> f13 >> f14 >> f15 >> f16 >> f17 >> f18 >> f19;
+                	}
+                	else if constexpr (N == 20) {
+                		auto& [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20] = value;
+                		in >> f1 >> f2 >> f3 >> f4 >> f5 >> f6 >> f7 >> f8 >> f9 >> f10 >> f11 >> f12 >> f13 >> f14 >> f15 >> f16 >> f17 >> f18 >> f19 >> f20;
+                	}
+                	else {
+                		static_assert (!sizeof(T), "missing implementation");
+                	}
+                	return in;
+                }
+
+                void C::setStatus(Status status, const QString& text) {
+                	const auto& colors = Config::get().ui().colors;
+                	QColor color;
+                	switch (status) {
+                	case Status::Ok:
+                		color = colors.green;
+                		break;
+                	case Status::Waiting:
+                		color = Qt::black;
+                		break;
+                	case Status::Error:
+                		color = colors.red;
+                		break;
+	                }
+
+                	if (m_statusColor != color) {
+                		m_statusColor = color;
+                	}
+                }""")
+    cppcheck([filename]) # should not take more than ~1 second
diff --git a/test/cli/premium_test.py b/test/cli/premium_test.py
new file mode 100644
index 00000000000..ddf7b1e2fbe
--- /dev/null
+++ b/test/cli/premium_test.py
@@ -0,0 +1,201 @@
+
+# python -m pytest premium_test.py
+
+import os
+import re
+import shutil
+import sys
+import time
+
+from testutils import cppcheck, __lookup_cppcheck_exe
+
+__PRODUCT_NAME = 'Cppcheck Premium ' + str(time.time())
+
+
+def __copy_cppcheck_premium(tmpdir):
+    exe = shutil.copy2(__lookup_cppcheck_exe(), tmpdir)
+    if sys.platform == 'win32':
+        shutil.copy2(os.path.join(os.path.dirname(__lookup_cppcheck_exe()), 'cppcheck-core.dll'), tmpdir)
+
+    # add minimum cfg/std.cfg
+    test_cfg_folder = tmpdir.mkdir('cfg')
+    with open(test_cfg_folder.join('std.cfg'), 'wt') as f:
+        f.write('<?xml version="1.0"?>\n<def format="2"/>')
+
+    # add simple cppcheck.cfg
+    with open(tmpdir.join('cppcheck.cfg'), 'wt') as f:
+        f.write("""
+                {
+                    "addons": [],
+                    "productName": "NAME",
+                    "about": "NAME",
+                    "manualUrl" : "https://files.cppchecksolutions.com/manual.pdf",
+                    "safety": true
+                }
+                """.replace('NAME', __PRODUCT_NAME))
+
+    return exe
+
+
+def test_misra_c_builtin_style_checks(tmpdir):
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        f.write('void foo() { int x; y = 0; }')
+
+    exe = __copy_cppcheck_premium(tmpdir)
+
+    exitcode, _, stderr = cppcheck(['--premium=autosar', '--xml', test_file], cppcheck_exe=exe)
+    assert exitcode == 0
+    assert 'id="unusedVariable"' in stderr
+    assert 'id="checkersReport"' in stderr
+
+    exitcode, _, stderr = cppcheck(['--premium=autosar', '--premium=safety-off', '--xml', test_file], cppcheck_exe=exe)
+    assert exitcode == 0
+    assert 'id="unusedVariable"' in stderr
+    assert 'id="checkersReport"' not in stderr
+
+    exitcode, _, stderr = cppcheck(['--xml-version=3', test_file], cppcheck_exe=exe)
+    assert exitcode == 0
+    assert '<safety/>' in stderr
+
+    exitcode, _, stderr = cppcheck(['--xml-version=3', '--premium=safety-off', test_file], cppcheck_exe=exe)
+    assert exitcode == 0
+    assert '<safety/>' not in stderr
+
+    exitcode, _, stderr = cppcheck(['--xml-version=3', '--inline-suppr', test_file], cppcheck_exe=exe)
+    assert exitcode == 0
+    assert '<inline-suppr/>' in stderr
+
+    exitcode, _, stderr = cppcheck(['--xml-version=3', '--suppress=foo', test_file], cppcheck_exe=exe)
+    assert exitcode == 0
+    assert '<suppression errorId="foo" inline="false" />' in stderr
+
+
+def test_build_dir_hash_cppcheck_product(tmpdir):
+    # 13644 - cppcheck build dir hashes should depend on the cppcheck version
+    # so that files are rescanned when cppcheck is switched
+
+    test_file = os.path.join(tmpdir, 'test.cpp')
+    with open(test_file, 'wt') as f:
+        f.write(';')
+
+    build_dir = tmpdir.mkdir('b')
+    args = [f'--cppcheck-build-dir={build_dir}', test_file]
+
+    exitcode, stdout, stderr = cppcheck(args)
+    assert 'error' not in stdout
+    assert stderr == ''
+    assert exitcode == 0
+
+    def _get_hash(s:str):
+        i = s.find(' hash="')
+        if i <= -1:
+            return ''
+        i += 7
+        return s[i:s.find('"', i)]
+
+    with open(build_dir.join('test.a1'), 'rt') as f:
+        f1 = f.read()
+        hash1 = _get_hash(f1)
+    assert re.match(r'^[0-9a-f]{6,}$', hash1), f1
+
+    premium_exe = __copy_cppcheck_premium(tmpdir)
+    exitcode, stdout, stderr = cppcheck(args, cppcheck_exe=premium_exe)
+    assert 'error' not in stdout
+    assert stderr == ''
+    assert exitcode == 0
+
+    with open(build_dir.join('test.a1'), 'rt') as f:
+        f2 = f.read()
+        hash2 = _get_hash(f2)
+    assert re.match(r'^[0-9a-f]{6,}$', hash2), f2
+
+    assert hash1 != hash2
+
+
+def test_misra_py(tmpdir):
+    # 13831 - do not execute misra.py when --premium=misra-c-2012 is used
+    test_file = os.path.join(tmpdir, 'test.c')
+    with open(test_file, 'wt') as f:
+        f.write('void foo();\n')
+
+    exe = __copy_cppcheck_premium(tmpdir)
+
+    # ensure that misra.py is not available:
+    _, stdout, _ = cppcheck(['--enable=style', '--addon=misra', test_file], cppcheck_exe=exe)
+    assert 'Did not find addon misra.py' in stdout
+
+    # Execute misra
+    _, stdout, _ = cppcheck(['--enable=style', '--premium=misra-c-2012', test_file], cppcheck_exe=exe)
+    assert 'misra.py' not in stdout # Did not find misra.py
+    assert 'Checking' in stdout
+
+
+def test_invalid_license_retry(tmpdir):
+    # Trac 13832 - cppcheck build dir: do not reuse cached results if there were invalidLicense errors
+    build_dir = os.path.join(tmpdir, 'b')
+    test_file = os.path.join(tmpdir, 'test.c')
+    addon_file = os.path.join(tmpdir, 'premiumaddon.py')
+
+    os.mkdir(build_dir)
+
+    with open(test_file, 'wt') as f:
+        f.write('void foo();\n')
+
+    args = [f"--addon={addon_file}", f"--cppcheck-build-dir={build_dir}", '--xml', '--enable=all', test_file]
+
+    with open(addon_file, 'wt') as f:
+        f.write('print(\'{"addon":"premium","column":0,"errorId":"invalidLicense","extra":"","file":"Cppcheck Premium","linenr":0,"message":"Invalid license: No license file was found, contact sales@cppchecksolutions.com","severity":"error"}\')')
+
+    _, _, stderr = cppcheck(args)
+    assert 'Invalid license' in stderr
+
+    with open(addon_file, 'wt') as f:
+        f.write('')
+
+    _, _, stderr = cppcheck(args)
+    assert 'Invalid license' not in stderr
+
+
+def test_help(tmpdir):
+    exe = __copy_cppcheck_premium(tmpdir)
+
+    exitcode, stdout, _ = cppcheck(['--help'], cppcheck_exe=exe)
+    assert exitcode == 0
+    assert stdout.startswith('Cppcheck ')  # check for product name - TODO: should be "Cppcheck Premium"
+    assert '--premium=' in stdout, stdout  # check for premium option
+    assert 'cppchecksolutions.com' in stdout, stdout  # check for premium help link
+
+
+def test_cwe(tmpdir):
+    # Trac 14323 - addon warnings with cwe
+    test_file = os.path.join(tmpdir, 'test.c')
+    addon_file = os.path.join(tmpdir, 'premiumaddon.py')
+
+    with open(test_file, 'wt') as f:
+        f.write('void foo();\n')
+
+    args = [f"--addon={addon_file}", '--xml', test_file]
+
+    with open(addon_file, 'wt') as f:
+        f.write('print(\'{"addon":"a","column":1,"errorId":"id","extra":"","file":"test.c","cwe":123,"linenr":1,"message":"bug","severity":"error"}\')')
+
+    _, _, stderr = cppcheck(args)
+    assert '<error id="a-id" severity="error" msg="bug" verbose="bug" cwe="123" ' in stderr
+
+
+def test_hash(tmpdir):
+    # Trac 14225 - warnings with hash
+    test_file = os.path.join(tmpdir, 'test.c')
+    addon_file = os.path.join(tmpdir, 'premiumaddon.py')
+
+    with open(test_file, 'wt') as f:
+        f.write('void foo();\n')
+
+    args = [f"--addon={addon_file}", '--xml', test_file]
+
+    with open(addon_file, 'wt') as f:
+        f.write('print(\'{"addon":"a","column":1,"errorId":"id","extra":"","file":"test.c","hash":123,"linenr":1,"message":"bug","severity":"error"}\')')
+
+    _, _, stderr = cppcheck(args)
+    assert '<error id="a-id" severity="error" msg="bug" verbose="bug" hash="123" ' in stderr
diff --git a/test/cli/proj-inline-suppress-unusedFunction/A.cpp b/test/cli/proj-inline-suppress-unusedFunction/A.cpp
new file mode 100644
index 00000000000..69235491d39
--- /dev/null
+++ b/test/cli/proj-inline-suppress-unusedFunction/A.cpp
@@ -0,0 +1,7 @@
+#include "B.hpp"
+
+int main()
+{
+    B b();
+    return 0;
+}
diff --git a/test/cli/proj-inline-suppress-unusedFunction/B.cpp b/test/cli/proj-inline-suppress-unusedFunction/B.cpp
new file mode 100644
index 00000000000..f8e512f3305
--- /dev/null
+++ b/test/cli/proj-inline-suppress-unusedFunction/B.cpp
@@ -0,0 +1,6 @@
+#include "B.hpp"
+
+B::B() {}
+
+// cppcheck-suppress unusedFunction
+void B::unusedFunctionTest() {}
diff --git a/test/cli/proj-inline-suppress-unusedFunction/B.hpp b/test/cli/proj-inline-suppress-unusedFunction/B.hpp
new file mode 100644
index 00000000000..71fad0ab3fd
--- /dev/null
+++ b/test/cli/proj-inline-suppress-unusedFunction/B.hpp
@@ -0,0 +1,6 @@
+class B {
+public:
+    B();
+
+    static void unusedFunctionTest();
+};
diff --git a/test/cli/proj-inline-suppress/3.cpp b/test/cli/proj-inline-suppress/3.cpp
new file mode 100644
index 00000000000..246ffbfe1cd
--- /dev/null
+++ b/test/cli/proj-inline-suppress/3.cpp
@@ -0,0 +1,6 @@
+// From forum: https://sourceforge.net/p/cppcheck/discussion/general/thread/e67653efdb/
+void foo()
+{ // cppcheck-suppress zerodiv
+    int x = 10000 / 0;
+}
+
diff --git a/test/cli/proj-inline-suppress/4.c b/test/cli/proj-inline-suppress/4.c
new file mode 100644
index 00000000000..022c389b22d
--- /dev/null
+++ b/test/cli/proj-inline-suppress/4.c
@@ -0,0 +1,6 @@
+int main() {
+    // cppcheck-suppress unreadVariable
+    int i = 0;
+    return 0;
+}
+
diff --git a/test/cli/proj-inline-suppress/cfg.c b/test/cli/proj-inline-suppress/cfg.c
new file mode 100644
index 00000000000..b597217fa32
--- /dev/null
+++ b/test/cli/proj-inline-suppress/cfg.c
@@ -0,0 +1,10 @@
+void f()
+{
+#if DEF_1
+    // cppcheck-suppress id
+    (void)0;
+#endif
+
+    // cppcheck-suppress id
+    (void)0;
+}
diff --git a/test/cli/proj-inline-suppress/duplicate.cpp b/test/cli/proj-inline-suppress/duplicate.cpp
new file mode 100644
index 00000000000..eae28cf8a46
--- /dev/null
+++ b/test/cli/proj-inline-suppress/duplicate.cpp
@@ -0,0 +1,5 @@
+int main() {
+    // cppcheck-suppress [unreadVariable,unreadVariable]
+    int i = 0;
+    return 0;
+}
diff --git a/test/cli/proj-inline-suppress/misraUnmatched.c b/test/cli/proj-inline-suppress/misraUnmatched.c
new file mode 100644
index 00000000000..93c81febbbc
--- /dev/null
+++ b/test/cli/proj-inline-suppress/misraUnmatched.c
@@ -0,0 +1,5 @@
+void f()
+{
+    // cppcheck-suppress misra-c2012-20.5
+    // cppcheck-suppress uninitvar
+}
\ No newline at end of file
diff --git a/test/cli/proj-inline-suppress/premiumUnmatched.cpp b/test/cli/proj-inline-suppress/premiumUnmatched.cpp
new file mode 100644
index 00000000000..3be3c1369a7
--- /dev/null
+++ b/test/cli/proj-inline-suppress/premiumUnmatched.cpp
@@ -0,0 +1,5 @@
+void f()
+{
+    // cppcheck-suppress premium-misra-cpp-2023-12.2.1
+    // cppcheck-suppress uninitvar
+}
\ No newline at end of file
diff --git a/test/cli/proj-inline-suppress/template.cpp b/test/cli/proj-inline-suppress/template.cpp
new file mode 100644
index 00000000000..62e504e782d
--- /dev/null
+++ b/test/cli/proj-inline-suppress/template.cpp
@@ -0,0 +1,15 @@
+namespace {
+    template<typename T>
+    T f() {
+        return T();
+    }
+}
+
+// cppcheck-suppress unusedFunction
+int g(int i) {
+    if (i == 0)
+        return f<char>();
+    if (i == 1)
+        return f<short>();
+    return f<int>();
+}
\ No newline at end of file
diff --git a/test/cli/proj-inline-suppress/unusedFunctionUnmatched.cpp b/test/cli/proj-inline-suppress/unusedFunctionUnmatched.cpp
new file mode 100644
index 00000000000..8bd895e99bb
--- /dev/null
+++ b/test/cli/proj-inline-suppress/unusedFunctionUnmatched.cpp
@@ -0,0 +1,5 @@
+// cppcheck-suppress unusedFunction
+void f() {
+    // cppcheck-suppress unusedFunction
+    // cppcheck-suppress uninitvar
+}
diff --git a/test/cli/proj-suppress-syntaxError/1.c b/test/cli/proj-suppress-syntaxError/1.c
index ebc333b99c3..c4521b0d6f1 100644
--- a/test/cli/proj-suppress-syntaxError/1.c
+++ b/test/cli/proj-suppress-syntaxError/1.c
@@ -3,8 +3,6 @@
 void validCode(int argInt)
 {
     // if G_UNLIKELY is not defined this results in a syntax error
-    if G_UNLIKELY(argInt == 1) {
-    } else if (G_UNLIKELY(argInt == 2)) {
-    }
+    if G_UNLIKELY(argInt == 1) {} else if (G_UNLIKELY(argInt == 2)) {}
 }
 
diff --git a/test/cli/proj2/a/a.c b/test/cli/proj2/a/a.c
index a87462ab5af..2959aad8c4b 100644
--- a/test/cli/proj2/a/a.c
+++ b/test/cli/proj2/a/a.c
@@ -1,2 +1,5 @@
 x = 3 / 0;
+#ifdef AAA
+void aa;
+#endif
 
diff --git a/test/cli/proj2/proj2.sln b/test/cli/proj2/proj2.sln
index e75bc99c927..9c957ab71d7 100644
--- a/test/cli/proj2/proj2.sln
+++ b/test/cli/proj2/proj2.sln
@@ -1,31 +1,31 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.27130.2027
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "proj2", "proj2.vcxproj", "{B9ED3CF9-9DB9-4876-9923-6FAD501885D5}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|x64 = Debug|x64
-		Debug|x86 = Debug|x86
-		Release|x64 = Release|x64
-		Release|x86 = Release|x86
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{B9ED3CF9-9DB9-4876-9923-6FAD501885D5}.Debug|x64.ActiveCfg = Debug|x64
-		{B9ED3CF9-9DB9-4876-9923-6FAD501885D5}.Debug|x64.Build.0 = Debug|x64
-		{B9ED3CF9-9DB9-4876-9923-6FAD501885D5}.Debug|x86.ActiveCfg = Debug|Win32
-		{B9ED3CF9-9DB9-4876-9923-6FAD501885D5}.Debug|x86.Build.0 = Debug|Win32
-		{B9ED3CF9-9DB9-4876-9923-6FAD501885D5}.Release|x64.ActiveCfg = Release|x64
-		{B9ED3CF9-9DB9-4876-9923-6FAD501885D5}.Release|x64.Build.0 = Release|x64
-		{B9ED3CF9-9DB9-4876-9923-6FAD501885D5}.Release|x86.ActiveCfg = Release|Win32
-		{B9ED3CF9-9DB9-4876-9923-6FAD501885D5}.Release|x86.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {DDBB0F1F-12C9-4A06-B09A-D55E5F0D0A43}
-	EndGlobalSection
-EndGlobal
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 15
+VisualStudioVersion = 15.0.27130.2027
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "proj2", "proj2.vcxproj", "{B9ED3CF9-9DB9-4876-9923-6FAD501885D5}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{B9ED3CF9-9DB9-4876-9923-6FAD501885D5}.Debug|x64.ActiveCfg = Debug|x64
+		{B9ED3CF9-9DB9-4876-9923-6FAD501885D5}.Debug|x64.Build.0 = Debug|x64
+		{B9ED3CF9-9DB9-4876-9923-6FAD501885D5}.Debug|x86.ActiveCfg = Debug|Win32
+		{B9ED3CF9-9DB9-4876-9923-6FAD501885D5}.Debug|x86.Build.0 = Debug|Win32
+		{B9ED3CF9-9DB9-4876-9923-6FAD501885D5}.Release|x64.ActiveCfg = Release|x64
+		{B9ED3CF9-9DB9-4876-9923-6FAD501885D5}.Release|x64.Build.0 = Release|x64
+		{B9ED3CF9-9DB9-4876-9923-6FAD501885D5}.Release|x86.ActiveCfg = Release|Win32
+		{B9ED3CF9-9DB9-4876-9923-6FAD501885D5}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {DDBB0F1F-12C9-4A06-B09A-D55E5F0D0A43}
+	EndGlobalSection
+EndGlobal
diff --git a/test/cli/proj2/proj2.vcxproj b/test/cli/proj2/proj2.vcxproj
index 43d9ceebf32..c65dc35c80e 100644
--- a/test/cli/proj2/proj2.vcxproj
+++ b/test/cli/proj2/proj2.vcxproj
@@ -1,124 +1,124 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <VCProjectVersion>15.0</VCProjectVersion>
-    <ProjectGuid>{B9ED3CF9-9DB9-4876-9923-6FAD501885D5}</ProjectGuid>
-    <RootNamespace>proj2</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0.16299.0</WindowsTargetPlatformVersion>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
-    <CharacterSet>MultiByte</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>MultiByte</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
-    <CharacterSet>MultiByte</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v141</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>MultiByte</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="Shared">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup />
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <SDLCheck>true</SDLCheck>
-      <ConformanceMode>true</ConformanceMode>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <SDLCheck>true</SDLCheck>
-      <ConformanceMode>true</ConformanceMode>
-    </ClCompile>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>true</SDLCheck>
-      <ConformanceMode>true</ConformanceMode>
-    </ClCompile>
-    <Link>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>MaxSpeed</Optimization>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>true</SDLCheck>
-      <ConformanceMode>true</ConformanceMode>
-    </ClCompile>
-    <Link>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClCompile Include="a\a.c" />
-    <ClCompile Include="b\b.c" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{B9ED3CF9-9DB9-4876-9923-6FAD501885D5}</ProjectGuid>
+    <RootNamespace>proj2</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0.16299.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>MaxSpeed</Optimization>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="a\a.c" />
+    <ClCompile Include="b\b.c" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
 </Project>
\ No newline at end of file
diff --git a/test/cli/proj2_test.py b/test/cli/proj2_test.py
new file mode 100644
index 00000000000..c9516d9ddbf
--- /dev/null
+++ b/test/cli/proj2_test.py
@@ -0,0 +1,173 @@
+
+# python -m pytest test-proj2.py
+
+import json
+import os
+import shutil
+from testutils import create_gui_project_file, cppcheck
+
+__script_dir = os.path.dirname(os.path.abspath(__file__))
+__proj_dir = os.path.join(__script_dir, 'proj2')
+
+__COMPILE_COMMANDS_JSON = 'compile_commands.json'
+
+__ERR_A = ('%s:1:7: error: Division by zero. [zerodiv]\n' +
+           'x = 3 / 0;\n' +
+           '      ^\n') % os.path.join('a', 'a.c')
+__ERR_B = ('%s:1:7: error: Division by zero. [zerodiv]\n' +
+           'x = 3 / 0;\n' +
+           '      ^\n') % os.path.join('b', 'b.c')
+
+def __create_compile_commands(proj_dir):
+    proj_dir = str(proj_dir)
+    j = [{'directory': os.path.join(proj_dir, 'a'), 'command': 'gcc -c a.c', 'file': 'a.c'},
+         {'directory': proj_dir, 'command': 'gcc -c b/b.c', 'file': 'b/b.c'}]
+    with open(os.path.join(proj_dir, __COMPILE_COMMANDS_JSON), 'wt') as f:
+        f.write(json.dumps(j))
+
+
+def test_file_filter():
+    ret, stdout, _ = cppcheck(['proj2/','--file-filter=proj2/a/*'], cwd=__script_dir)
+    file1 = os.path.join('proj2', 'a', 'a.c')
+    file2 = os.path.join('proj2', 'b', 'b.c')
+    assert ret == 0, stdout
+    assert stdout.find('Checking %s ...' % file1) >= 0
+    ret, stdout, _ = cppcheck(['proj2/','--file-filter=proj2/b*'], cwd=__script_dir)
+    assert ret == 0, stdout
+    assert stdout.find('Checking %s ...' % file2) >= 0
+
+def test_local_path(tmp_path):
+    proj_dir = tmp_path / 'proj2'
+    shutil.copytree(__proj_dir, proj_dir)
+    __create_compile_commands(proj_dir)
+    ret, stdout, _ = cppcheck(['--project=compile_commands.json'], cwd=proj_dir)
+    file1 = os.path.join('a', 'a.c')
+    file2 = os.path.join('b', 'b.c')
+    assert ret == 0, stdout
+    assert stdout.find('Checking %s ...' % file1) >= 0
+    assert stdout.find('Checking %s ...' % file2) >= 0
+
+def test_local_path_force(tmp_path):
+    proj_dir = tmp_path / 'proj2'
+    shutil.copytree(__proj_dir, proj_dir)
+    __create_compile_commands(proj_dir)
+    ret, stdout, _ = cppcheck(['--project=compile_commands.json', '--force'], cwd=proj_dir)
+    assert ret == 0, stdout
+    assert stdout.find('AAA') >= 0
+
+def test_local_path_maxconfigs(tmp_path):
+    proj_dir = tmp_path / 'proj2'
+    shutil.copytree(__proj_dir, proj_dir)
+    __create_compile_commands(proj_dir)
+    ret, stdout, _ = cppcheck(['--project=compile_commands.json', '--max-configs=2'], cwd=proj_dir)
+    assert ret == 0, stdout
+    assert stdout.find('AAA') >= 0
+
+def test_relative_path(tmp_path):
+    proj_dir = tmp_path / 'proj2'
+    shutil.copytree(__proj_dir, proj_dir)
+    __create_compile_commands(proj_dir)
+    ret, stdout, _ = cppcheck(['--project=proj2/' + __COMPILE_COMMANDS_JSON], cwd=tmp_path)
+    file1 = os.path.join('proj2', 'a', 'a.c')
+    file2 = os.path.join('proj2', 'b', 'b.c')
+    assert ret == 0, stdout
+    assert stdout.find('Checking %s ...' % file1) >= 0
+    assert stdout.find('Checking %s ...' % file2) >= 0
+
+def test_absolute_path(tmp_path):
+    proj_dir = tmp_path / 'proj2'
+    shutil.copytree(__proj_dir, proj_dir)
+    __create_compile_commands(proj_dir)
+    ret, stdout, _ = cppcheck(['--project=' + os.path.join(proj_dir, __COMPILE_COMMANDS_JSON)], cwd=tmp_path)
+    file1 = os.path.join(proj_dir, 'a', 'a.c')
+    file2 = os.path.join(proj_dir, 'b', 'b.c')
+    assert ret == 0, stdout
+    assert stdout.find('Checking %s ...' % file1) >= 0
+    assert stdout.find('Checking %s ...' % file2) >= 0
+
+def test_gui_project_loads_compile_commands_1(tmp_path):
+    proj_dir = tmp_path / 'proj2'
+    shutil.copytree(__proj_dir, proj_dir)
+    __create_compile_commands(proj_dir)
+    ret, stdout, _ = cppcheck(['--project=proj2/proj2.cppcheck'], cwd=tmp_path)
+    file1 = os.path.join('proj2', 'a', 'a.c')
+    file2 = os.path.join('proj2', 'b', 'b.c')
+    assert ret == 0, stdout
+    assert stdout.find('Checking %s ...' % file1) >= 0
+    assert stdout.find('Checking %s ...' % file2) >= 0
+
+def test_gui_project_loads_compile_commands_2(tmp_path):
+    proj_dir = tmp_path / 'proj2'
+    shutil.copytree(__proj_dir, proj_dir)
+    __create_compile_commands(proj_dir)
+    exclude_path_1 = 'proj2/b'
+    create_gui_project_file(os.path.join(proj_dir, 'test.cppcheck'),
+                            import_project='compile_commands.json',
+                            exclude_paths=[exclude_path_1])
+    ret, stdout, _ = cppcheck(['--project=' + os.path.join('proj2','test.cppcheck')], cwd=tmp_path)
+    file1 = os.path.join('proj2', 'a', 'a.c')
+    file2 = os.path.join('proj2', 'b', 'b.c') # Excluded by test.cppcheck
+    assert ret == 0, stdout
+    assert stdout.find('Checking %s ...' % file1) >= 0
+    assert stdout.find('Checking %s ...' % file2) < 0
+
+
+def test_gui_project_loads_relative_vs_solution(tmp_path):
+    proj_dir = tmp_path / 'proj2'
+    shutil.copytree(__proj_dir, proj_dir)
+    create_gui_project_file(os.path.join(tmp_path, 'test.cppcheck'), import_project='proj2/proj2.sln')
+    ret, stdout, _ = cppcheck(['--project=test.cppcheck'], cwd=tmp_path)
+    file1 = os.path.join('proj2', 'a', 'a.c')
+    file2 = os.path.join('proj2', 'b', 'b.c')
+    assert ret == 0, stdout
+    assert stdout.find('Checking %s Debug|Win32...' % file1) >= 0
+    assert stdout.find('Checking %s Debug|x64...' % file1) >= 0
+    assert stdout.find('Checking %s Release|Win32...' % file1) >= 0
+    assert stdout.find('Checking %s Release|x64...' % file1) >= 0
+    assert stdout.find('Checking %s Debug|Win32...' % file2) >= 0
+    assert stdout.find('Checking %s Debug|x64...' % file2) >= 0
+    assert stdout.find('Checking %s Release|Win32...' % file2) >= 0
+    assert stdout.find('Checking %s Release|x64...' % file2) >= 0
+
+def test_gui_project_loads_absolute_vs_solution(tmp_path):
+    proj_dir = tmp_path / 'proj2'
+    shutil.copytree(__proj_dir, proj_dir)
+    create_gui_project_file(os.path.join(tmp_path, 'test.cppcheck'), import_project=os.path.join(proj_dir, 'proj2.sln'))
+    ret, stdout, _ = cppcheck(['--project=test.cppcheck'], cwd=tmp_path)
+    file1 = os.path.join(proj_dir, 'a', 'a.c')
+    file2 = os.path.join(proj_dir, 'b', 'b.c')
+    assert ret == 0, stdout
+    assert stdout.find('Checking %s Debug|Win32...' % file1) >= 0
+    assert stdout.find('Checking %s Debug|x64...' % file1) >= 0
+    assert stdout.find('Checking %s Release|Win32...' % file1) >= 0
+    assert stdout.find('Checking %s Release|x64...' % file1) >= 0
+    assert stdout.find('Checking %s Debug|Win32...' % file2) >= 0
+    assert stdout.find('Checking %s Debug|x64...' % file2) >= 0
+    assert stdout.find('Checking %s Release|Win32...' % file2) >= 0
+    assert stdout.find('Checking %s Release|x64...' % file2) >= 0
+
+def test_gui_project_loads_relative_vs_solution_2(tmp_path):
+    proj_dir = tmp_path / 'proj2'
+    shutil.copytree(__proj_dir, proj_dir)
+    create_gui_project_file(os.path.join(tmp_path, 'test.cppcheck'), root_path='proj2', import_project='proj2/proj2.sln')
+    ret, stdout, stderr = cppcheck(['--project=test.cppcheck'], cwd=tmp_path)
+    assert ret == 0, stdout
+    assert stderr == __ERR_A + __ERR_B
+
+def test_gui_project_loads_relative_vs_solution_with_exclude(tmp_path):
+    proj_dir = tmp_path / 'proj2'
+    shutil.copytree(__proj_dir, proj_dir)
+    create_gui_project_file(os.path.join(tmp_path, 'test.cppcheck'), root_path='proj2', import_project='proj2/proj2.sln', exclude_paths=['b'])
+    ret, stdout, stderr = cppcheck(['--project=test.cppcheck'], cwd=tmp_path)
+    assert ret == 0, stdout
+    assert stderr == __ERR_A
+
+def test_gui_project_loads_absolute_vs_solution_2(tmp_path):
+    proj_dir = tmp_path / 'proj2'
+    shutil.copytree(__proj_dir, proj_dir)
+    create_gui_project_file(os.path.join(tmp_path, 'test.cppcheck'),
+                            root_path=str(proj_dir),
+                            import_project=os.path.join(proj_dir, 'proj2.sln'))
+    ret, stdout, stderr = cppcheck(['--project=test.cppcheck'], cwd=tmp_path)
+    assert ret == 0, stdout
+    assert stderr == __ERR_A + __ERR_B
diff --git a/test/cli/project_test.py b/test/cli/project_test.py
new file mode 100644
index 00000000000..e8c120f2c08
--- /dev/null
+++ b/test/cli/project_test.py
@@ -0,0 +1,162 @@
+# python -m pytest test-projects.py
+
+import pytest
+import os
+import json
+import sys
+from testutils import cppcheck
+
+
+@pytest.mark.parametrize("project_ext", ["json", "sln", "vcxproj", "bpr", "cppcheck"])
+def test_missing_project(project_ext):
+    project_file = "file.{}".format(project_ext)
+
+    ret, stdout, stderr = cppcheck(['--project=' + project_file, '--template=cppcheck1'])
+    assert 1 == ret
+    assert "cppcheck: error: failed to open project '{}'. The file does not exist.\n".format(project_file) == stdout
+    assert "" == stderr
+
+
+def __test_project_error(tmpdir, ext, content, expected):
+    project_file = os.path.join(tmpdir, "file.{}".format(ext))
+
+    with open(project_file, 'w') as f:
+        if content is not None:
+            f.write(content)
+
+    ret, stdout, stderr = cppcheck(['--project=' + str(project_file)])
+    assert 1 == ret
+    assert "cppcheck: error: " + expected + "\ncppcheck: error: failed to load project '{}'. An error occurred.\n".format(project_file) == stdout
+    assert "" == stderr
+
+
+@pytest.mark.parametrize("project_ext, expected", [
+    ("json", "compilation database is not a JSON array"),
+    ("sln", "Visual Studio solution file is empty"),
+    ("vcxproj", "Visual Studio project file is not a valid XML - XML_ERROR_EMPTY_DOCUMENT"),
+    ("bpr", "Borland project file is not a valid XML - XML_ERROR_EMPTY_DOCUMENT"),
+    ("cppcheck", "Cppcheck GUI project file is not a valid XML - XML_ERROR_EMPTY_DOCUMENT")
+])
+def test_empty_project(tmpdir, project_ext, expected):
+    __test_project_error(tmpdir, project_ext, None, expected)
+
+
+def test_json_entry_file_not_found(tmpdir):
+    compilation_db = [
+        {"directory": str(tmpdir),
+         "command": "c++ -o bug1.o -c bug1.cpp",
+         "file": "bug1.cpp",
+         "output": "bug1.o"}
+    ]
+
+    project_file = os.path.join(tmpdir, "file.json")
+    missing_file = os.path.join(tmpdir, "bug1.cpp")
+    missing_file_posix = missing_file
+
+    if sys.platform == "win32":
+        missing_file_posix = missing_file_posix.replace('\\', '/')
+
+    with open(project_file, 'w') as f:
+        f.write(json.dumps(compilation_db))
+
+    ret, _, stderr = cppcheck([
+        '--template=simple',
+        "--project=" + str(project_file)
+    ])
+    assert 0 == ret
+    assert stderr == f"{missing_file}:0:0: error: File is missing: {missing_file_posix} [missingFile]\n"
+
+
+def test_json_no_arguments(tmpdir):
+    compilation_db = [
+        {"directory": str(tmpdir),
+         "file": "bug1.cpp",
+         "output": "bug1.o"}
+    ]
+
+    expected = "no 'arguments' or 'command' field found in compilation database entry"
+
+    __test_project_error(tmpdir, "json", json.dumps(compilation_db), expected)
+
+
+def test_json_invalid_arguments(tmpdir):
+    compilation_db = [
+        {"directory": str(tmpdir),
+         "arguments": "",
+         "file": "bug1.cpp",
+         "output": "bug1.o"}
+    ]
+
+    expected = "'arguments' field in compilation database entry is not a JSON array"
+
+    __test_project_error(tmpdir, "json", json.dumps(compilation_db), expected)
+
+
+def test_sln_invalid_file(tmpdir):
+    content = "some file"
+
+    expected = "Visual Studio solution file header not found"
+
+    __test_project_error(tmpdir, "sln", content, expected)
+
+
+def test_sln_no_header(tmpdir):
+    content = "\xEF\xBB\xBF\r\n" \
+              "some header"
+
+    expected = "Visual Studio solution file header not found"
+
+    __test_project_error(tmpdir, "sln", content, expected)
+
+
+def test_sln_no_projects(tmpdir):
+    content = "\xEF\xBB\xBF\r\n" \
+              "Microsoft Visual Studio Solution File, Format Version 12.00\r\n"
+
+    expected = "no projects found in Visual Studio solution file"
+
+    __test_project_error(tmpdir, "sln", content, expected)
+
+
+def test_sln_project_file_not_found(tmpdir):
+    content = "\xEF\xBB\xBF\r\n" \
+              "Microsoft Visual Studio Solution File, Format Version 12.00\r\n" \
+              "# Visual Studio Version 16\r\n" \
+              "VisualStudioVersion = 16.0.29020.237\r\n" \
+              "MinimumVisualStudioVersion = 10.0.40219.1\r\n" \
+              'Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cli", "cli\\cli.vcxproj", "{35CBDF51-2456-3EC3-99ED-113C30858883}"\r\n' \
+              "ProjectSection(ProjectDependencies) = postProject\r\n" \
+              "{C183DB5B-AD6C-423D-80CA-1F9549555A1A} = {C183DB5B-AD6C-423D-80CA-1F9549555A1A}\r\n" \
+              "EndProjectSection\r\n" \
+              "EndProject\r\n"
+
+    expected = "Visual Studio project file is not a valid XML - XML_ERROR_FILE_NOT_FOUND\n" \
+               "cppcheck: error: failed to load '{}' from Visual Studio solution".format(os.path.join(tmpdir, "cli/cli.vcxproj"))
+    if sys.platform == "win32":
+        expected = expected.replace('\\', '/')
+
+    __test_project_error(tmpdir, "sln", content, expected)
+
+
+def test_vcxproj_no_xml_root(tmpdir):
+    content = '<?xml version="1.0" encoding="utf-8"?>'
+
+    expected = "Visual Studio project file has no XML root node"
+
+    __test_project_error(tmpdir, "vcxproj", content, expected)
+
+
+def test_bpr_no_xml_root(tmpdir):
+    content = '<?xml version="1.0" encoding="utf-8"?>'
+
+    expected = "Borland project file has no XML root node"
+
+    __test_project_error(tmpdir, "bpr", content, expected)
+
+
+def test_cppcheck_no_xml_root(tmpdir):
+    content = '<?xml version="1.0" encoding="utf-8"?>'
+
+    expected = "Cppcheck GUI project file has no XML root node"
+
+    __test_project_error(tmpdir, "cppcheck", content, expected)
diff --git a/test/cli/qml_test.py b/test/cli/qml_test.py
new file mode 100644
index 00000000000..5ce7428b0ae
--- /dev/null
+++ b/test/cli/qml_test.py
@@ -0,0 +1,63 @@
+
+# python3 -m pytest test-qml.py
+
+import os
+from testutils import cppcheck
+
+__script_dir = os.path.dirname(os.path.abspath(__file__))
+
+# there are unused functions. But fillSampleData is not unused because that is referenced from main.qml
+__project_dir = os.path.join(__script_dir, 'QML-Samples-TableView')
+__project_dir_sep = __project_dir + os.path.sep
+
+
+def __test_unused_functions(extra_args):
+    args = [
+        '-q',
+        '--template=simple',
+        '--library=qt',
+        '--enable=unusedFunction',
+        __project_dir
+    ]
+    args += extra_args
+    ret, stdout, stderr = cppcheck(args)
+    assert stdout.splitlines() == []
+    lines = stderr.splitlines()
+    lines.sort()
+    # there are unused functions. But fillSampleData is not unused because that is referenced from main.qml
+    assert lines == [
+        "{}samplemodel.cpp:15:23: style: The function 'data' is never used. [unusedFunction]".format(__project_dir_sep),
+        "{}samplemodel.cpp:38:37: style: The function 'roleNames' is never used. [unusedFunction]".format(__project_dir_sep),
+        "{}samplemodel.cpp:9:18: style: The function 'rowCount' is never used. [unusedFunction]".format(__project_dir_sep)
+    ]
+    assert ret == 0, stdout
+
+
+def test_unused_functions():
+    __test_unused_functions(['-j1', '--no-cppcheck-build-dir'])
+
+
+def test_unused_functions_j():
+    args = [
+        '-q',
+        '--template=simple',
+        '--library=qt',
+        '--enable=unusedFunction',
+        '-j2',
+        '--no-cppcheck-build-dir',
+        __project_dir
+    ]
+    ret, stdout, stderr = cppcheck(args)
+    assert stdout.splitlines() == ["cppcheck: unusedFunction check requires --cppcheck-build-dir to be active with -j."]
+    assert stderr.splitlines() == []
+    assert ret == 0, stdout
+
+
+def test_unused_functions_builddir(tmpdir):
+    build_dir = os.path.join(tmpdir, 'b1')
+    os.mkdir(build_dir)
+    __test_unused_functions(['--cppcheck-build-dir={}'.format(build_dir)])
+
+
+# TODO: test with project file
+# TODO: test with FileSettings
diff --git a/test/cli/reanalysis/a.cpp b/test/cli/reanalysis/a.cpp
new file mode 100644
index 00000000000..aad7e3efa61
--- /dev/null
+++ b/test/cli/reanalysis/a.cpp
@@ -0,0 +1,4 @@
+int main() {
+    int i; // cppcheck-suppress unusedVariable
+}
+
diff --git a/test/cli/reanalysis/b.cpp b/test/cli/reanalysis/b.cpp
new file mode 100644
index 00000000000..cb4df470113
--- /dev/null
+++ b/test/cli/reanalysis/b.cpp
@@ -0,0 +1,2 @@
+int main() {}
+
diff --git a/test/cli/reanalysis/c.cpp b/test/cli/reanalysis/c.cpp
new file mode 100644
index 00000000000..cb4df470113
--- /dev/null
+++ b/test/cli/reanalysis/c.cpp
@@ -0,0 +1,2 @@
+int main() {}
+
diff --git a/test/cli/reanalysis/d.cpp b/test/cli/reanalysis/d.cpp
new file mode 100644
index 00000000000..cb4df470113
--- /dev/null
+++ b/test/cli/reanalysis/d.cpp
@@ -0,0 +1,2 @@
+int main() {}
+
diff --git a/test/cli/rules_test.py b/test/cli/rules_test.py
new file mode 100644
index 00000000000..241cdf34c51
--- /dev/null
+++ b/test/cli/rules_test.py
@@ -0,0 +1,186 @@
+import os
+import sys
+
+from testutils import cppcheck
+
+__script_dir = os.path.dirname(os.path.abspath(__file__))
+__root_dir = os.path.abspath(os.path.join(__script_dir, '..', '..'))
+__rules_dir = os.path.join(__root_dir, 'rules')
+
+
+def test_empty_catch_block(tmp_path):
+    test_file = tmp_path / 'test.cpp'
+    with open(test_file, 'wt') as f:
+        f.write("""
+void f()
+{
+    try
+    {
+    }
+    catch (...)
+    {
+    }
+}
+""")
+
+    rule_file = os.path.join(__rules_dir, 'empty-catch-block.xml')
+    args = [
+        '--template=simple',
+        '--rule-file={}'.format(rule_file),
+        str(test_file)
+    ]
+    ret, stdout, stderr = cppcheck(args)
+    assert ret == 0
+    assert stdout.splitlines() == [
+        'Checking {} ...'.format(test_file),
+        'Processing rule: \\}\\s*catch\\s*\\(.*\\)\\s*\\{\\s*\\}'
+    ]
+    assert stderr.splitlines() == [
+        '{}:6:0: style: Empty catch block found. [rule]'.format(test_file)
+    ]
+
+
+def test_show_all_defines(tmp_path):
+    test_file = tmp_path / 'test.cpp'
+    with open(test_file, 'wt') as f:
+        f.write("""
+#define DEF_1
+
+void f()
+{
+}
+""")
+
+    rule_file = os.path.join(__rules_dir, 'show-all-defines.rule')
+    args = [
+        '--template=simple',
+        '-DDEF_2',
+        '--rule-file={}'.format(rule_file),
+        str(test_file)
+    ]
+    ret, stdout, stderr = cppcheck(args)
+    assert ret == 0
+    assert stdout.splitlines() == [
+        'Checking {} ...'.format(test_file),
+        'Processing rule: .*',
+        'Checking {}: DEF_2=1...'.format(test_file)
+    ]
+    if sys.platform == 'win32':
+        test_file = str(test_file).replace('\\', '/')
+    assert stderr.splitlines() == [
+        # TODO: this message looks strange
+        ":1:0: information: found ' # line 2 \"{}\" # define DEF_1' [showalldefines]".format(test_file)
+    ]
+
+
+def test_stl(tmp_path):
+    test_file = tmp_path / 'test.cpp'
+    with open(test_file, 'wt') as f:
+        f.write("""
+void f()
+{
+    std::string s;
+    if (s.find("t") == 17)
+    {
+    }
+}
+""")
+
+    rule_file = os.path.join(__rules_dir, 'stl.xml')
+    args = [
+        '--template=simple',
+        '--rule-file={}'.format(rule_file),
+        str(test_file)
+    ]
+    ret, stdout, stderr = cppcheck(args)
+    assert ret == 0
+    assert stdout.splitlines() == [
+        'Checking {} ...'.format(test_file),
+        'Processing rule:  \\. find \\( "[^"]+?" \\) == \\d+ '
+    ]
+    assert stderr.splitlines() == [
+        '{}:5:0: performance: When looking for a string at a fixed position compare [UselessSTDStringFind]'.format(test_file)
+    ]
+
+
+def test_strlen_empty_str(tmp_path):
+    test_file = tmp_path / 'test.cpp'
+    with open(test_file, 'wt') as f:
+        f.write("""
+void f(const char* s)
+{
+    if (strlen(s) > 0)
+    {
+    }
+}
+""")
+
+    rule_file = os.path.join(__rules_dir, 'strlen-empty-str.xml')
+    args = [
+        '--template=simple',
+        '--rule-file={}'.format(rule_file),
+        str(test_file)
+    ]
+    ret, stdout, stderr = cppcheck(args)
+    assert ret == 0
+    assert stdout.splitlines() == [
+        'Checking {} ...'.format(test_file),
+        'Processing rule:  if \\( ([!] )*?(strlen) \\( \\w+? \\) ([>] [0] )*?\\) { '
+    ]
+    assert stderr.splitlines() == [
+        '{}:4:0: performance: Using strlen() to check if a string is empty is not efficient. [StrlenEmptyString]'.format(test_file)
+    ]
+
+
+def test_suggest_nullptr(tmp_path):
+    test_file = tmp_path / 'test.cpp'
+    with open(test_file, 'wt') as f:
+        f.write("""
+void f()
+{
+    const char* p = 0;
+}
+""")
+
+    rule_file = os.path.join(__rules_dir, 'suggest_nullptr.xml')
+    args = [
+        '--template=simple',
+        '--rule-file={}'.format(rule_file),
+        str(test_file)
+    ]
+    ret, stdout, stderr = cppcheck(args)
+    assert ret == 0
+    assert stdout.splitlines() == [
+        'Checking {} ...'.format(test_file),
+        'Processing rule: (\\b\\w+\\b) \\* (\\b\\w+\\b) = 0 ;'
+    ]
+    assert stderr.splitlines() == [
+        "{}:4:0: style: Prefer to use a 'nullptr' instead of initializing a pointer with 0. [modernizeUseNullPtr]".format(test_file)
+    ]
+
+
+def test_unused_deref(tmp_path):
+    test_file = tmp_path / 'test.cpp'
+    with open(test_file, 'wt') as f:
+        f.write("""
+void f(const char* p)
+{
+    *p++;
+}
+""")
+
+    rule_file = os.path.join(__rules_dir, 'unused-deref.xml')
+    args = [
+        '--template=simple',
+        '--rule-file={}'.format(rule_file),
+        str(test_file)
+    ]
+    ret, stdout, stderr = cppcheck(args)
+    assert ret == 0
+    assert stdout.splitlines() == [
+        'Checking {} ...'.format(test_file),
+        'Processing rule:  [;{}] [*] \\w+? (\\+\\+|\\-\\-) ; '
+    ]
+    assert stderr.splitlines() == [
+        '{}:3:0: style: Redundant * found, "*p++" is the same as "*(p++)". [UnusedDeref]'.format(test_file)
+    ]
diff --git a/test/cli/samples_test.py b/test/cli/samples_test.py
new file mode 100644
index 00000000000..d8459509d3a
--- /dev/null
+++ b/test/cli/samples_test.py
@@ -0,0 +1,45 @@
+import os
+import sys
+
+from testutils import cppcheck
+
+__script_dir = os.path.dirname(os.path.abspath(__file__))
+__root_dir = os.path.abspath(os.path.join(__script_dir, '..', '..'))
+
+
+def test_samples():
+    failures = {}
+
+    samples_dir = os.path.join(__root_dir, 'samples')
+    for entry in os.listdir(samples_dir):
+        sample_dir = os.path.join(samples_dir, entry)
+        if not os.path.isdir(sample_dir):
+            continue
+
+        with open(os.path.join(sample_dir, 'out.txt')) as out_in:
+            out_txt = out_in.read()
+        if sys.platform != 'win32':
+            out_txt = out_txt.replace('\\', '/')
+
+        if not os.path.exists(os.path.join(sample_dir, 'good.c')):
+            good_src = os.path.join('samples', entry, 'good.cpp')
+            bad_src = os.path.join('samples', entry, 'bad.cpp')
+        else:
+            good_src = os.path.join('samples', entry, 'good.c')
+            bad_src = os.path.join('samples', entry, 'bad.c')
+
+        # check that good input does not produce any warnings
+        ret, _, stderr = cppcheck(['-q', '--enable=all', '--disable=missingInclude', '--inconclusive', '--check-level=exhaustive', '--error-exitcode=1', good_src], cwd=__root_dir)
+        if ret != 0:
+            failures[good_src] = stderr
+
+        # check that the bad inout produces a warning
+        ret, _, stderr = cppcheck(['-q', '--enable=all', '--disable=missingInclude', '--inconclusive', '--check-level=exhaustive', '--error-exitcode=1', bad_src], cwd=__root_dir)
+        if ret != 1:
+            failures[bad_src] = stderr
+
+        # check that the bad input procudes the expected output
+        if not stderr == out_txt:
+            failures[bad_src] = stderr
+
+    assert failures == {}
diff --git a/test/cli/sarif_test.py b/test/cli/sarif_test.py
new file mode 100644
index 00000000000..d2fe9396350
--- /dev/null
+++ b/test/cli/sarif_test.py
@@ -0,0 +1,622 @@
+# python -m pytest sarif_test.py
+
+import os
+import json
+import tempfile
+
+import pytest
+
+from testutils import cppcheck
+
+__script_dir = os.path.dirname(os.path.abspath(__file__))
+
+# Test code with various error types
+TEST_CODE = """
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+#include <vector>
+#include <memory>
+
+class TestClass {
+public:
+    TestClass() : value(0) {}
+    ~TestClass() { delete ptr; }
+    
+    void setValue(int v) { value = v; }
+    int getValue() const { return value; }
+    
+private:
+    int value;
+    int* ptr = nullptr;
+};
+
+void testSecurityViolations() {
+    // Null pointer dereference
+    int* ptr = nullptr;
+    *ptr = 5;
+    
+    // Array bounds violation  
+    int array[5];
+    array[10] = 1;
+    
+    // Memory leak
+    int* mem = (int*)malloc(sizeof(int) * 10);
+    // forgot to free mem
+    
+    // Uninitialized variable
+    int x;
+    printf("%d", x);
+    
+    // Double free
+    int* p = (int*)malloc(sizeof(int));
+    free(p);
+    free(p);
+    
+    // Buffer overflow with strcpy
+    char buffer[10];
+    char source[20] = "This is too long";
+    strcpy(buffer, source);
+    
+    // Use after free
+    int* freed = (int*)malloc(sizeof(int));
+    free(freed);
+    *freed = 42;
+}
+
+void testStyleAndPortabilityIssues() {
+    // Redundant assignment
+    int redundant = 5;
+    redundant = redundant;
+    
+    // Unused variable
+    int unused = 42;
+    
+    // Variable scope reduction
+    int i;
+    for (i = 0; i < 10; i++) {
+        // i could be declared in for loop
+    }
+}
+
+int main() {
+    testSecurityViolations();
+    testStyleAndPortabilityIssues();
+    return 0;
+}
+"""
+
+BASIC_TEST_CODE = """
+int main() {
+    int* p = nullptr;
+    *p = 5; // null pointer dereference
+    return 0;
+}
+"""
+
+
+def create_test_file(tmp_path, filename="test.cpp", content=TEST_CODE):
+    """Create a temporary test file with the given content."""
+    filepath = tmp_path / filename
+    filepath.write_text(content)
+    return str(filepath)
+
+
+def run_sarif_check(code, extra_args=None):
+    """Run cppcheck with SARIF output on the given code."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmp_path = os.path.join(tmpdir, "test.cpp")
+        with open(tmp_path, "w") as f:
+            f.write(code)
+
+        args = ["--output-format=sarif", "--enable=all", tmp_path]
+
+        if extra_args:
+            args.extend(extra_args)
+
+        _, _, stderr = cppcheck(args)
+
+        # SARIF output is in stderr
+        try:
+            sarif_data = json.loads(stderr)
+            return sarif_data
+        except json.JSONDecodeError as e:
+            pytest.fail(f"Failed to parse SARIF JSON: {e}\nOutput: {stderr}")
+            return None
+
+
+def test_sarif_basic_structure():
+    """Test that SARIF output has the correct basic structure."""
+    sarif = run_sarif_check(BASIC_TEST_CODE)
+
+    # Check required SARIF fields
+    assert sarif["version"] == "2.1.0"
+    assert "$schema" in sarif
+    assert "sarif-schema" in sarif["$schema"]
+    assert "runs" in sarif
+    assert len(sarif["runs"]) == 1
+
+    run = sarif["runs"][0]
+    assert "tool" in run
+    assert "results" in run
+
+    tool = run["tool"]
+    assert "driver" in tool
+
+    driver = tool["driver"]
+    assert driver["name"] == "Cppcheck"
+    assert "rules" in driver
+    assert "semanticVersion" in driver
+
+
+def test_sarif_null_pointer():
+    """Test SARIF output for null pointer dereference."""
+    sarif = run_sarif_check(BASIC_TEST_CODE)
+
+    run = sarif["runs"][0]
+    results = run["results"]
+
+    # Should have at least one result
+    assert len(results) > 0
+
+    # Find null pointer result
+    null_pointer_results = [r for r in results if r["ruleId"] == "nullPointer"]
+    assert len(null_pointer_results) > 0
+
+    result = null_pointer_results[0]
+    assert result["level"] == "error"
+    assert "message" in result
+    assert "text" in result["message"]
+    assert (
+        "null" in result["message"]["text"].lower()
+        or "nullptr" in result["message"]["text"].lower()
+    )
+
+    # Check location information
+    assert "locations" in result
+    assert len(result["locations"]) > 0
+    location = result["locations"][0]
+    assert "physicalLocation" in location
+    assert "artifactLocation" in location["physicalLocation"]
+    assert "region" in location["physicalLocation"]
+
+    region = location["physicalLocation"]["region"]
+    assert "startLine" in region
+    assert region["startLine"] > 0
+    assert "startColumn" in region
+    assert region["startColumn"] > 0
+
+
+def test_sarif_security_rules():
+    """Test that security-related rules have proper security properties."""
+    sarif = run_sarif_check(TEST_CODE)
+
+    run = sarif["runs"][0]
+    driver = run["tool"]["driver"]
+    rules = driver["rules"]
+
+    # Check for security-related rules
+    security_rule_ids = [
+        "nullPointer",
+        "arrayIndexOutOfBounds",
+        "memleak",
+        "uninitvar",
+        "doubleFree",
+    ]
+
+    for rule_id in security_rule_ids:
+        matching_rules = [r for r in rules if r["id"] == rule_id]
+        if matching_rules:
+            rule = matching_rules[0]
+            props = rule.get("properties", {})
+
+            # Security rules should have security-severity
+            if "tags" in props and "security" in props["tags"]:
+                assert "security-severity" in props
+                assert float(props["security-severity"]) > 0
+
+            # Should have problem.severity
+            assert "problem.severity" in props
+
+            # Should have precision
+            assert "precision" in props
+
+
+def test_sarif_rule_descriptions():
+    """Test that rule descriptions are properly formatted."""
+    sarif = run_sarif_check(TEST_CODE)
+
+    run = sarif["runs"][0]
+    driver = run["tool"]["driver"]
+    rules = driver["rules"]
+
+    assert len(rules) > 0
+
+    for rule in rules:
+        # Each rule should have required fields
+        assert "id" in rule
+        assert "name" in rule
+        assert "shortDescription" in rule
+        assert "fullDescription" in rule
+
+        # Descriptions should be empty (allowing GitHub to use instance messages)
+        assert rule["name"] == ""
+        assert rule["shortDescription"]["text"] == ""
+        assert rule["fullDescription"]["text"] == ""
+
+        # Should have properties
+        assert "properties" in rule
+
+
+def test_sarif_cwe_tags():
+    """Test that CWE tags are properly formatted."""
+    sarif = run_sarif_check(TEST_CODE)
+
+    run = sarif["runs"][0]
+    driver = run["tool"]["driver"]
+    rules = driver["rules"]
+
+    # Find rules with CWE tags
+    rules_with_cwe = []
+    for rule in rules:
+        props = rule.get("properties", {})
+        tags = props.get("tags", [])
+        cwe_tags = [t for t in tags if t.startswith("external/cwe/cwe-")]
+        if cwe_tags:
+            rules_with_cwe.append((rule["id"], cwe_tags))
+
+    # Should have at least some rules with CWE tags
+    assert len(rules_with_cwe) > 0
+
+    # Validate CWE tag format
+    for _, cwe_tags in rules_with_cwe:
+        for tag in cwe_tags:
+            assert tag.startswith("external/cwe/cwe-")
+            cwe_num = tag[17:]  # After 'external/cwe/cwe-'
+            assert cwe_num.isdigit()
+            assert int(cwe_num) > 0
+
+
+def test_sarif_severity_levels():
+    """Test that different severity levels are properly mapped."""
+    sarif = run_sarif_check(TEST_CODE)
+
+    run = sarif["runs"][0]
+    results = run["results"]
+
+    # Collect severity levels
+    levels = set()
+    for result in results:
+        levels.add(result["level"])
+
+    # Should have at least error level
+    assert "error" in levels
+
+    # Valid SARIF levels
+    valid_levels = {"error", "warning", "note", "none"}
+    for level in levels:
+        assert level in valid_levels
+
+
+def test_sarif_instance_specific_messages():
+    """Test that result messages contain instance-specific information."""
+    sarif = run_sarif_check(TEST_CODE)
+
+    run = sarif["runs"][0]
+    results = run["results"]
+
+    # Check that messages are instance-specific
+    found_specific_messages = False
+
+    for result in results:
+        message_text = result["message"]["text"]
+        rule_id = result["ruleId"]
+
+        # Skip system include warnings
+        if rule_id == "missingIncludeSystem":
+            continue
+
+        # Messages should not be empty
+        assert len(message_text) > 0
+
+        # Check for specific variable names or values from our test code
+        if rule_id == "nullPointer" and "ptr" in message_text:
+            found_specific_messages = True
+        elif rule_id == "arrayIndexOutOfBounds" and (
+            "array" in message_text or "10" in message_text
+        ):
+            found_specific_messages = True
+        elif rule_id == "uninitvar" and "x" in message_text:
+            found_specific_messages = True
+        elif rule_id == "memleak" and "mem" in message_text:
+            found_specific_messages = True
+        elif rule_id == "doubleFree" and "p" in message_text:
+            found_specific_messages = True
+
+    assert (
+        found_specific_messages
+    ), "Should find at least some instance-specific messages"
+
+
+def test_sarif_location_info():
+    """Test that location information is correct."""
+    sarif = run_sarif_check(BASIC_TEST_CODE)
+
+    run = sarif["runs"][0]
+    results = run["results"]
+
+    for result in results:
+        assert "locations" in result
+        locations = result["locations"]
+        assert len(locations) > 0
+
+        for location in locations:
+            assert "physicalLocation" in location
+            phys_loc = location["physicalLocation"]
+
+            assert "artifactLocation" in phys_loc
+            assert "uri" in phys_loc["artifactLocation"]
+
+            assert "region" in phys_loc
+            region = phys_loc["region"]
+
+            # SARIF requires line and column numbers >= 1
+            assert "startLine" in region
+            assert region["startLine"] >= 1
+
+            assert "startColumn" in region
+            assert region["startColumn"] >= 1
+
+
+def test_sarif_with_multiple_files(tmp_path):
+    """Test SARIF output with multiple source files."""
+    # Create two test files
+    file1_content = """
+    void test1() {
+        int* p = nullptr;
+        *p = 1;
+    }
+    """
+
+    file2_content = """
+    void test2() {
+        int arr[5];
+        arr[10] = 2;
+    }
+    """
+
+    file1 = tmp_path / "file1.cpp"
+    file2 = tmp_path / "file2.cpp"
+    file1.write_text(file1_content)
+    file2.write_text(file2_content)
+
+    args = ["--output-format=sarif", "--enable=all", str(tmp_path)]
+
+    _, _, stderr = cppcheck(args)
+    sarif = json.loads(stderr)
+
+    run = sarif["runs"][0]
+    results = run["results"]
+
+    # Should have results from both files
+    files = set()
+    for result in results:
+        if "locations" in result:
+            for location in result["locations"]:
+                uri = location["physicalLocation"]["artifactLocation"]["uri"]
+                files.add(os.path.basename(uri))
+
+    assert "file1.cpp" in files or "file2.cpp" in files
+
+
+def test_sarif_default_configuration():
+    """Test that rules have default configuration with level."""
+    sarif = run_sarif_check(BASIC_TEST_CODE)
+
+    run = sarif["runs"][0]
+    driver = run["tool"]["driver"]
+    rules = driver["rules"]
+
+    for rule in rules:
+        # Check for defaultConfiguration.level (#13885)
+        assert "defaultConfiguration" in rule
+        assert "level" in rule["defaultConfiguration"]
+
+        level = rule["defaultConfiguration"]["level"]
+        assert level in ["error", "warning", "note", "none"]
+
+
+def test_sarif_rule_properties():
+    """Test that rules have required properties."""
+    sarif = run_sarif_check(TEST_CODE)
+
+    run = sarif["runs"][0]
+    driver = run["tool"]["driver"]
+    rules = driver["rules"]
+
+    for rule in rules:
+        assert "properties" in rule
+        props = rule["properties"]
+
+        # Required properties
+        assert "precision" in props
+        assert props["precision"] in ["very-high", "high", "medium", "low"]
+
+        assert "problem.severity" in props
+        assert props["problem.severity"] in [
+            "error",
+            "warning",
+            "style",
+            "performance",
+            "portability",
+            "information",
+            "note",
+        ]
+
+
+def test_sarif_rule_coverage():
+    """Test that a variety of rules are triggered by comprehensive test code."""
+    sarif = run_sarif_check(TEST_CODE)
+
+    run = sarif["runs"][0]
+    driver = run["tool"]["driver"]
+    rules = driver["rules"]
+
+    # Collect all rule IDs
+    rule_ids = set(rule["id"] for rule in rules)
+
+    # Should have at least 5 different rules triggered
+    assert (
+        len(rule_ids) >= 5
+    ), f"Expected at least 5 rules, found {len(rule_ids)}: {rule_ids}"
+
+    # Check for some specific expected rules from different categories
+    expected_rules = [
+        "nullPointer",  # Security
+        "arrayIndexOutOfBounds",  # Security
+        "memleak",  # Security
+        "uninitvar",  # Security
+        "unusedVariable",  # Style
+        "redundantAssignment",  # Style
+        "unusedFunction",  # Style (if enabled)
+        "constParameter",  # Style/Performance
+        "cstyleCast",  # Style
+        "variableScope",  # Style
+    ]
+
+    found_expected_rules = sum(1 for rule in expected_rules if rule in rule_ids)
+
+    # Should find at least 3 of our expected rules
+    assert (
+        found_expected_rules >= 3
+    ), f"Expected at least 3 known rules, found {found_expected_rules}"
+
+
+def test_sarif_generic_descriptions():
+    """Test that ALL rule descriptions are empty for GitHub integration."""
+    sarif = run_sarif_check(TEST_CODE)
+
+    run = sarif["runs"][0]
+    driver = run["tool"]["driver"]
+    rules = driver["rules"]
+
+    assert len(rules) > 0, "Should have at least one rule"
+
+    # Verify that ALL rule descriptions are empty so GitHub uses instance-specific messages
+    for rule in rules:
+        rule_id = rule["id"]
+
+        # All rules must have these fields
+        assert "name" in rule, f"Rule {rule_id} missing 'name'"
+        assert "shortDescription" in rule, f"Rule {rule_id} missing 'shortDescription'"
+        assert "fullDescription" in rule, f"Rule {rule_id} missing 'fullDescription'"
+
+        # The key test: ALL descriptions should be empty
+        assert (
+            rule["name"] == ""
+        ), f"Rule {rule_id} name should be empty, got: {rule['name']}"
+        assert (
+            rule["shortDescription"]["text"] == ""
+        ), f"Rule {rule_id} shortDescription should be empty, got: {rule['shortDescription']['text']}"
+        assert (
+            rule["fullDescription"]["text"] == ""
+        ), f"Rule {rule_id} fullDescription should be empty, got: {rule['fullDescription']['text']}"
+
+
+def test_sarif_security_rules_classification():
+    """Test that security classification is correctly based on CWE IDs."""
+    sarif = run_sarif_check(TEST_CODE)
+
+    run = sarif["runs"][0]
+    driver = run["tool"]["driver"]
+    rules = driver["rules"]
+
+    found_rule_with_cwe = False
+    found_rule_without_cwe = False
+
+    for rule in rules:
+        rule_id = rule["id"]
+        props = rule.get("properties", {})
+        tags = props.get("tags", [])
+
+        # Check if rule has CWE tag
+        cwe_tags = [t for t in tags if t.startswith("external/cwe/")]
+        has_cwe = len(cwe_tags) > 0
+
+        if has_cwe:
+            found_rule_with_cwe = True
+
+            # Rules with CWE should have security-severity and security tag
+            assert (
+                "security-severity" in props
+            ), f"Rule {rule_id} with CWE should have security-severity"
+            assert (
+                float(props["security-severity"]) > 0
+            ), f"Rule {rule_id} security-severity should be positive"
+
+            # Check for security tag
+            assert (
+                "security" in tags
+            ), f"Rule {rule_id} with CWE should have 'security' tag"
+        else:
+            found_rule_without_cwe = True
+
+            # Rules without CWE should NOT have security-severity or security tag
+            assert (
+                "security-severity" not in props
+            ), f"Rule {rule_id} without CWE should not have security-severity"
+            assert (
+                "security" not in tags
+            ), f"Rule {rule_id} without CWE should not have 'security' tag"
+
+        # All rules should still have basic properties
+        assert "precision" in props, f"Rule {rule_id} missing 'precision'"
+        assert "problem.severity" in props, f"Rule {rule_id} missing 'problem.severity'"
+
+    # Should find at least some rules in test data
+    assert (
+        found_rule_with_cwe or found_rule_without_cwe
+    ), "Should find at least some rules with or without CWE"
+
+
+def test_sarif_results_consistency():
+    """Test consistency between rule definitions and results."""
+    sarif = run_sarif_check(TEST_CODE)
+
+    run = sarif["runs"][0]
+    driver = run["tool"]["driver"]
+    rules = driver["rules"]
+    results = run["results"]
+
+    # Collect rule IDs from both rules and results
+    rule_ids_in_rules = set(rule["id"] for rule in rules)
+    rule_ids_in_results = set(result["ruleId"] for result in results)
+
+    # Every rule ID in results should have a corresponding rule definition
+    for result_rule_id in rule_ids_in_results:
+        assert (
+            result_rule_id in rule_ids_in_rules
+        ), f"Result references undefined rule: {result_rule_id}"
+
+    # Verify severity level consistency
+    severity_levels = set()
+    for result in results:
+        level = result["level"]
+        severity_levels.add(level)
+
+        # Valid SARIF levels
+        assert level in [
+            "error",
+            "warning",
+            "note",
+            "none",
+        ], f"Invalid severity level: {level}"
+
+    # Should have at least error level
+    assert "error" in severity_levels, "Should have at least one error"
+
+    # Should have multiple severity levels for comprehensive test
+    assert (
+        len(severity_levels) >= 2
+    ), f"Expected multiple severity levels, found: {severity_levels}"
diff --git a/test/cli/shared-items-project/Main/Main.vcxproj b/test/cli/shared-items-project/Main/Main.vcxproj
new file mode 100644
index 00000000000..17c6fc98aa3
--- /dev/null
+++ b/test/cli/shared-items-project/Main/Main.vcxproj
@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>17.0</VCProjectVersion>
+    <Keyword>Win32Proj</Keyword>
+    <ProjectGuid>{074143a3-6080-409a-a181-24e4e468bfd8}</ProjectGuid>
+    <RootNamespace>Blub</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+    <Import Project="$(SolutionDir)\Shared\Shared.vcxitems" Label="Shared" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="MainFile.cpp" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/test/cli/shared-items-project/Main/MainFile.cpp b/test/cli/shared-items-project/Main/MainFile.cpp
new file mode 100644
index 00000000000..bbfcb9626b7
--- /dev/null
+++ b/test/cli/shared-items-project/Main/MainFile.cpp
@@ -0,0 +1,7 @@
+#include <TestClass.h>
+
+int main(void)
+{
+    Shared::TestClass test{};
+    return 0;
+}
\ No newline at end of file
diff --git a/test/cli/shared-items-project/Shared/Shared.vcxitems b/test/cli/shared-items-project/Shared/Shared.vcxitems
new file mode 100644
index 00000000000..6f904c81453
--- /dev/null
+++ b/test/cli/shared-items-project/Shared/Shared.vcxitems
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup Label="Globals">
+    <MSBuildAllProjects Condition="'$(MSBuildVersion)' == '' Or '$(MSBuildVersion)' &lt; '16.0'">$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
+    <HasSharedItems>true</HasSharedItems>
+    <ItemsProjectGuid>{3633ee6f-e5e8-46fc-87c9-f13a18db966a}</ItemsProjectGuid>
+  </PropertyGroup>
+  <ItemDefinitionGroup>
+    <ClCompile>
+      <AdditionalIncludeDirectories>%(AdditionalIncludeDirectories);$(MSBuildThisFileDirectory)</AdditionalIncludeDirectories>
+    </ClCompile>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ProjectCapability Include="SourceItemsFromImports" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="$(MSBuildThisFileDirectory)TestClass.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="$(MSBuildThisFileDirectory)TestClass.cpp" />
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/test/cli/shared-items-project/Shared/TestClass.cpp b/test/cli/shared-items-project/Shared/TestClass.cpp
new file mode 100644
index 00000000000..4fa992fce1b
--- /dev/null
+++ b/test/cli/shared-items-project/Shared/TestClass.cpp
@@ -0,0 +1,9 @@
+#include "TestClass.h"
+
+using namespace Shared;
+
+TestClass::TestClass()
+{}
+
+TestClass::~TestClass()
+{}
diff --git a/test/cli/shared-items-project/Shared/TestClass.h b/test/cli/shared-items-project/Shared/TestClass.h
new file mode 100644
index 00000000000..7fbdb22dcde
--- /dev/null
+++ b/test/cli/shared-items-project/Shared/TestClass.h
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace Shared
+{
+    class TestClass
+    {
+    public:
+        explicit TestClass();
+        virtual ~TestClass();
+    };
+} // namespace Shared
diff --git a/test/cli/shared-items-project/Solution.sln b/test/cli/shared-items-project/Solution.sln
new file mode 100644
index 00000000000..6a4aac0fd2f
--- /dev/null
+++ b/test/cli/shared-items-project/Solution.sln
@@ -0,0 +1,28 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.9.34607.119
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Shared", "Shared\Shared.vcxitems", "{3633EE6F-E5E8-46FC-87C9-F13A18DB966A}"
+EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Main", "Main\Main.vcxproj", "{074143A3-6080-409A-A181-24E4E468BFD8}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Release|x64 = Release|x64
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{074143A3-6080-409A-A181-24E4E468BFD8}.Release|x64.ActiveCfg = Release|x64
+		{074143A3-6080-409A-A181-24E4E468BFD8}.Release|x64.Build.0 = Release|x64
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {510D1526-E6EE-452F-A697-173A3D4C4E93}
+	EndGlobalSection
+	GlobalSection(SharedMSBuildProjectFiles) = preSolution
+		Shared\Shared.vcxitems*{074143a3-6080-409a-a181-24e4e468bfd8}*SharedItemsImports = 4
+		Shared\Shared.vcxitems*{3633ee6f-e5e8-46fc-87c9-f13a18db966a}*SharedItemsImports = 9
+	EndGlobalSection
+EndGlobal
diff --git a/test/cli/suppress-syntaxError_test.py b/test/cli/suppress-syntaxError_test.py
new file mode 100644
index 00000000000..9b58bf4e7c3
--- /dev/null
+++ b/test/cli/suppress-syntaxError_test.py
@@ -0,0 +1,31 @@
+
+# python -m pytest test-suppress-syntaxError.py
+
+import os
+from testutils import cppcheck
+
+__script_dir = os.path.dirname(os.path.abspath(__file__))
+
+def test_j():
+    ret, stdout, stderr = cppcheck(['-q', '--error-exitcode=1', '-j2', '-q', 'proj-suppress-syntaxError'], cwd=__script_dir)
+    assert ret == 1, stdout
+    assert len(stderr) > 0
+
+def test_suppress_j():
+    ret, stdout, stderr = cppcheck(['-q', '--error-exitcode=1', '--suppress=*:proj-suppress-syntaxError/*', '-j2', '-q', 'proj-suppress-syntaxError'], cwd=__script_dir)
+    assert ret == 0, stdout
+    assert len(stderr) == 0
+
+# TODO: test with -j2
+def test_safety_suppress_syntax_error_implicitly(tmpdir):
+    ret, stdout, stderr = cppcheck(['-q', '--safety', '--suppress=*', 'proj-suppress-syntaxError', '-j1'], remove_checkers_report=False, cwd=__script_dir)
+    assert ret == 1, stdout
+    assert '[syntaxError]' in stderr
+    assert 'Active checkers: There was critical errors' in stderr
+
+# TODO: test with -j2
+def test_safety_suppress_syntax_error_explicitly():
+    ret, stdout, stderr = cppcheck(['-q', '--safety', '--suppress=syntaxError', 'proj-suppress-syntaxError', '-j1'], remove_checkers_report=False, cwd=__script_dir)
+    assert ret == 1, stdout
+    assert '[syntaxError]' not in stderr
+    assert 'Active checkers: There was critical errors' in stderr
diff --git a/test/cli/test-helloworld.py b/test/cli/test-helloworld.py
deleted file mode 100644
index f6a767bc30e..00000000000
--- a/test/cli/test-helloworld.py
+++ /dev/null
@@ -1,187 +0,0 @@
-
-# python -m pytest test-helloworld.py
-
-import os
-import re
-from testutils import create_gui_project_file, cppcheck
-
-# Run Cppcheck from project path
-def cppcheck_local(args):
-    cwd = os.getcwd()
-    os.chdir('helloworld')
-    ret, stdout, stderr = cppcheck(args)
-    os.chdir(cwd)
-    return (ret, stdout, stderr)
-
-def getRelativeProjectPath():
-    return 'helloworld'
-
-def getAbsoluteProjectPath():
-    return os.path.join(os.getcwd(), 'helloworld')
-
-# Get Visual Studio configurations checking a file
-# Checking {file} {config}...
-def getVsConfigs(stdout, filename):
-    ret = []
-    for line in stdout.split('\n'):
-        if not line.startswith('Checking %s ' % (filename)):
-            continue
-        if not line.endswith('...'):
-            continue
-        res = re.match(r'.* ([A-Za-z0-9|]+)...', line)
-        if res:
-            ret.append(res.group(1))
-    ret.sort()
-    return ' '.join(ret)
-
-def test_relative_path():
-    ret, stdout, stderr = cppcheck(['--template=cppcheck1', 'helloworld'])
-    filename = os.path.join('helloworld', 'main.c')
-    assert ret == 0
-    assert stdout == 'Checking %s ...\n' % (filename)
-    assert stderr == '[%s:5]: (error) Division by zero.\n' % (filename)
-
-
-def test_local_path():
-    ret, stdout, stderr = cppcheck_local(['--template=cppcheck1', '.'])
-    assert ret == 0
-    assert stdout == 'Checking main.c ...\n'
-    assert stderr == '[main.c:5]: (error) Division by zero.\n'
-
-def test_absolute_path():
-    prjpath = getAbsoluteProjectPath()
-    ret, stdout, stderr = cppcheck(['--template=cppcheck1', prjpath])
-    filename = os.path.join(prjpath, 'main.c')
-    assert ret == 0
-    assert stdout == 'Checking %s ...\n' % (filename)
-    assert stderr == '[%s:5]: (error) Division by zero.\n' % (filename)
-
-def test_addon_local_path():
-    ret, stdout, stderr = cppcheck_local(['--addon=misra', '--template=cppcheck1', '.'])
-    assert ret == 0
-    assert stdout == 'Checking main.c ...\n'
-    assert stderr == ('[main.c:5]: (error) Division by zero.\n'
-                      '[main.c:1]: (style) misra violation (use --rule-texts=<file> to get proper output)\n')
-
-def test_addon_absolute_path():
-    prjpath = getAbsoluteProjectPath()
-    ret, stdout, stderr = cppcheck(['--addon=misra', '--template=cppcheck1', prjpath])
-    filename = os.path.join(prjpath, 'main.c')
-    assert ret == 0
-    assert stdout == 'Checking %s ...\n' % (filename)
-    assert stderr == ('[%s:5]: (error) Division by zero.\n'
-                      '[%s:1]: (style) misra violation (use --rule-texts=<file> to get proper output)\n' % (filename, filename))
-
-def test_addon_relative_path():
-    prjpath = getRelativeProjectPath()
-    ret, stdout, stderr = cppcheck(['--addon=misra', '--template=cppcheck1', prjpath])
-    filename = os.path.join(prjpath, 'main.c')
-    assert ret == 0
-    assert stdout == 'Checking %s ...\n' % (filename)
-    assert stderr == ('[%s:5]: (error) Division by zero.\n'
-                      '[%s:1]: (style) misra violation (use --rule-texts=<file> to get proper output)\n' % (filename, filename))
-
-def test_addon_relative_path():
-    project_file = 'helloworld/test.cppcheck'
-    create_gui_project_file(project_file, paths=['.'], addon='misra')
-    ret, stdout, stderr = cppcheck(['--template=cppcheck1', '--project=' + project_file])
-    filename = os.path.join('helloworld', 'main.c')
-    assert ret == 0
-    assert stdout == 'Checking %s ...\n' % (filename)
-    assert stderr == ('[%s:5]: (error) Division by zero.\n'
-                      '[%s:1]: (style) misra violation (use --rule-texts=<file> to get proper output)\n' % (filename, filename))
-
-def test_basepath_relative_path():
-    prjpath = getRelativeProjectPath()
-    ret, stdout, stderr = cppcheck([prjpath, '--template=cppcheck1', '-rp=' + prjpath])
-    filename = os.path.join(prjpath, 'main.c')
-    assert ret == 0
-    assert stdout == 'Checking %s ...\n' % (filename)
-    assert stderr == '[main.c:5]: (error) Division by zero.\n'
-
-def test_basepath_absolute_path():
-    prjpath = getAbsoluteProjectPath()
-    ret, stdout, stderr = cppcheck(['--template=cppcheck1', prjpath, '-rp=' + prjpath])
-    filename = os.path.join(prjpath, 'main.c')
-    assert ret == 0
-    assert stdout == 'Checking %s ...\n' % (filename)
-    assert stderr == '[main.c:5]: (error) Division by zero.\n'
-
-def test_vs_project_local_path():
-    ret, stdout, stderr = cppcheck_local(['--template=cppcheck1', '--project=helloworld.vcxproj'])
-    assert ret == 0
-    assert getVsConfigs(stdout, 'main.c') == 'Debug|Win32 Debug|x64 Release|Win32 Release|x64'
-    assert stderr == '[main.c:5]: (error) Division by zero.\n'
-
-def test_vs_project_relative_path():
-    prjpath = getRelativeProjectPath()
-    ret, stdout, stderr = cppcheck(['--template=cppcheck1', '--project=' + os.path.join(prjpath, 'helloworld.vcxproj')])
-    filename = os.path.join(prjpath, 'main.c')
-    assert ret == 0
-    assert getVsConfigs(stdout, filename) == 'Debug|Win32 Debug|x64 Release|Win32 Release|x64'
-    assert stderr == '[%s:5]: (error) Division by zero.\n' % (filename)
-
-def test_vs_project_absolute_path():
-    prjpath = getAbsoluteProjectPath()
-    ret, stdout, stderr = cppcheck(['--template=cppcheck1', '--project=' + os.path.join(prjpath, 'helloworld.vcxproj')])
-    filename = os.path.join(prjpath, 'main.c')
-    assert ret == 0
-    assert getVsConfigs(stdout, filename) == 'Debug|Win32 Debug|x64 Release|Win32 Release|x64'
-    assert stderr == '[%s:5]: (error) Division by zero.\n' % (filename)
-
-def test_cppcheck_project_local_path():
-    ret, stdout, stderr = cppcheck_local(['--template=cppcheck1', '--platform=win64', '--project=helloworld.cppcheck'])
-    assert ret == 0
-    assert getVsConfigs(stdout, 'main.c') == 'Debug|x64'
-    assert stderr == '[main.c:5]: (error) Division by zero.\n'
-
-def test_cppcheck_project_relative_path():
-    prjpath = getRelativeProjectPath()
-    ret, stdout, stderr = cppcheck(['--template=cppcheck1', '--platform=win64', '--project=' + os.path.join(prjpath, 'helloworld.cppcheck')])
-    filename = os.path.join(prjpath, 'main.c')
-    assert ret == 0
-    assert getVsConfigs(stdout, filename) == 'Debug|x64'
-    assert stderr == '[%s:5]: (error) Division by zero.\n' % (filename)
-
-def test_cppcheck_project_absolute_path():
-    prjpath = getAbsoluteProjectPath()
-    ret, stdout, stderr = cppcheck(['--template=cppcheck1', '--platform=win64', '--project=' + os.path.join(prjpath, 'helloworld.cppcheck')])
-    filename = os.path.join(prjpath, 'main.c')
-    assert ret == 0
-    assert getVsConfigs(stdout, filename) == 'Debug|x64'
-    assert stderr == '[%s:5]: (error) Division by zero.\n' % (filename)
-
-def test_suppress_command_line():
-    prjpath = getRelativeProjectPath()
-    ret, stdout, stderr = cppcheck(['--suppress=zerodiv:' + os.path.join(prjpath, 'main.c'), prjpath])
-    assert ret == 0
-    assert stderr == ''
-
-    prjpath = getAbsoluteProjectPath()
-    ret, stdout, stderr = cppcheck(['--suppress=zerodiv:' + os.path.join(prjpath, 'main.c'), prjpath])
-    assert ret == 0
-    assert stderr == ''
-
-def test_suppress_project():
-    project_file = os.path.join('helloworld', 'test.cppcheck')
-    create_gui_project_file(project_file,
-                            paths=['.'],
-                            suppressions=[{'fileName':'main.c', 'id':'zerodiv'}])
-
-    # Relative path
-    ret, stdout, stderr = cppcheck(['--project=' + project_file])
-    assert ret == 0
-    assert stderr == ''
-
-    # Absolute path
-    ret, stdout, stderr = cppcheck(['--project=' + os.path.join(os.getcwd(), 'helloworld', 'test.cppcheck')])
-    assert ret == 0
-    assert stderr == ''
-
-
-def test_exclude():
-    prjpath = getRelativeProjectPath()
-    ret, stdout, stderr = cppcheck(['-i' + prjpath, '--platform=win64', '--project=' + os.path.join(prjpath, 'helloworld.cppcheck')])
-    assert stdout == 'cppcheck: No C or C++ source files found.\n'
-
-
diff --git a/test/cli/test-inline-suppress.py b/test/cli/test-inline-suppress.py
deleted file mode 100644
index c94c493af98..00000000000
--- a/test/cli/test-inline-suppress.py
+++ /dev/null
@@ -1,21 +0,0 @@
-
-# python -m pytest test-inline-suppress.py
-
-import os
-import re
-from testutils import cppcheck
-
-def test1():
-    ret, stdout, stderr = cppcheck(['--inline-suppr', 'proj-inline-suppress'])
-    assert ret == 0
-    # TODO assert len(stderr) == 0
-
-def test2():
-    ret, stdout, stderr = cppcheck(['proj-inline-suppress'])
-    assert ret == 0
-    assert len(stderr) > 0
-
-def test_unmatched_suppression():
-    ret, stdout, stderr = cppcheck(['--inline-suppr', '--enable=information', '--error-exitcode=1', 'proj-inline-suppress/2.c'])
-    assert ret == 1
-    assert 'Unmatched suppression: some_warning_id' in stderr
diff --git a/test/cli/test-proj2.py b/test/cli/test-proj2.py
deleted file mode 100644
index 6235ddd05d0..00000000000
--- a/test/cli/test-proj2.py
+++ /dev/null
@@ -1,135 +0,0 @@
-
-# python -m pytest test-proj2.py
-
-import json
-import os
-from testutils import create_gui_project_file, cppcheck
-
-COMPILE_COMMANDS_JSON = os.path.join('proj2', 'compile_commands.json')
-
-ERR_A = ('a/a.c:1:7: error: Division by zero. [zerodiv]\n' +
-         'x = 3 / 0;\n' +
-         '      ^\n')
-ERR_B = ('b/b.c:1:7: error: Division by zero. [zerodiv]\n' +
-         'x = 3 / 0;\n' +
-         '      ^\n')
-
-def create_compile_commands():
-    prjpath = os.path.join(os.getcwd(), 'proj2')
-    j = [{'directory': os.path.join(prjpath,'a'), 'command': 'gcc -c a.c', 'file': 'a.c'},
-         {'directory': os.path.join(prjpath,'b'), 'command': 'gcc -c b.c', 'file': 'b.c'}]
-    f = open(COMPILE_COMMANDS_JSON, 'wt')
-    f.write(json.dumps(j))
-
-# Run Cppcheck from project path
-def cppcheck_local(args):
-    cwd = os.getcwd()
-    os.chdir('proj2')
-    ret, stdout, stderr = cppcheck(args)
-    os.chdir(cwd)
-    return (ret, stdout, stderr)
-
-
-def test_local_path():
-    create_compile_commands()
-    ret, stdout, stderr = cppcheck_local(['--project=compile_commands.json'])
-    cwd = os.getcwd()
-    file1 = os.path.join(cwd, 'proj2', 'a', 'a.c')
-    file2 = os.path.join(cwd, 'proj2', 'b', 'b.c')
-    assert ret == 0
-    assert stdout.find('Checking %s ...' % (file1)) >= 0
-    assert stdout.find('Checking %s ...' % (file2)) >= 0
-
-def test_relative_path():
-    create_compile_commands()
-    ret, stdout, stderr = cppcheck(['--project=' + COMPILE_COMMANDS_JSON])
-    cwd = os.getcwd()
-    file1 = os.path.join(cwd, 'proj2', 'a', 'a.c')
-    file2 = os.path.join(cwd, 'proj2', 'b', 'b.c')
-    assert ret == 0
-    assert stdout.find('Checking %s ...' % (file1)) >= 0
-    assert stdout.find('Checking %s ...' % (file2)) >= 0
-
-def test_absolute_path():
-    create_compile_commands()
-    cwd = os.getcwd()
-    ret, stdout, stderr = cppcheck(['--project=' + os.path.join(cwd,COMPILE_COMMANDS_JSON)])
-    file1 = os.path.join(cwd, 'proj2', 'a', 'a.c')
-    file2 = os.path.join(cwd, 'proj2', 'b', 'b.c')
-    assert ret == 0
-    assert stdout.find('Checking %s ...' % (file1)) >= 0
-    assert stdout.find('Checking %s ...' % (file2)) >= 0
-
-def test_gui_project_loads_compile_commands_1():
-    create_compile_commands()
-    ret, stdout, stderr = cppcheck(['--project=proj2/proj2.cppcheck'])
-    cwd = os.getcwd()
-    file1 = os.path.join(cwd, 'proj2', 'a', 'a.c')
-    file2 = os.path.join(cwd, 'proj2', 'b', 'b.c')
-    assert ret == 0
-    assert stdout.find('Checking %s ...' % (file1)) >= 0
-    assert stdout.find('Checking %s ...' % (file2)) >= 0
-
-def test_gui_project_loads_compile_commands_2():
-    create_compile_commands()
-    exclude_path_1 = os.path.join(os.getcwd(), 'proj2', 'b').replace('\\', '/')
-    create_gui_project_file('proj2/test.cppcheck',
-                            import_project='compile_commands.json',
-                            exclude_paths=[exclude_path_1])
-    ret, stdout, stderr = cppcheck(['--project=proj2/test.cppcheck'])
-    cwd = os.getcwd()
-    file1 = os.path.join(cwd, 'proj2', 'a', 'a.c')
-    file2 = os.path.join(cwd, 'proj2', 'b', 'b.c') # Excluded by test.cppcheck
-    assert ret == 0
-    assert stdout.find('Checking %s ...' % (file1)) >= 0
-    assert stdout.find('Checking %s ...' % (file2)) < 0
-
-
-def test_gui_project_loads_relative_vs_solution():
-    create_gui_project_file('test.cppcheck', import_project='proj2/proj2.sln')
-    ret, stdout, stderr = cppcheck(['--project=test.cppcheck'])
-    file1 = os.path.join('proj2', 'a', 'a.c')
-    file2 = os.path.join('proj2', 'b', 'b.c')
-    assert ret == 0
-    assert stdout.find('Checking %s Debug|Win32...' % (file1)) >= 0
-    assert stdout.find('Checking %s Debug|x64...' % (file1)) >= 0
-    assert stdout.find('Checking %s Release|Win32...' % (file1)) >= 0
-    assert stdout.find('Checking %s Release|x64...' % (file1)) >= 0
-    assert stdout.find('Checking %s Debug|Win32...' % (file2)) >= 0
-    assert stdout.find('Checking %s Debug|x64...' % (file2)) >= 0
-    assert stdout.find('Checking %s Release|Win32...' % (file2)) >= 0
-    assert stdout.find('Checking %s Release|x64...' % (file2)) >= 0
-
-def test_gui_project_loads_absolute_vs_solution():
-    create_gui_project_file('test.cppcheck', import_project=os.path.join(os.getcwd(),'proj2', 'proj2.sln').replace('\\', '/'))
-    ret, stdout, stderr = cppcheck(['--project=test.cppcheck'])
-    file1 = os.path.join(os.getcwd(), 'proj2', 'a', 'a.c')
-    file2 = os.path.join(os.getcwd(), 'proj2', 'b', 'b.c')
-    print(stdout)
-    assert ret == 0
-    assert stdout.find('Checking %s Debug|Win32...' % (file1)) >= 0
-    assert stdout.find('Checking %s Debug|x64...' % (file1)) >= 0
-    assert stdout.find('Checking %s Release|Win32...' % (file1)) >= 0
-    assert stdout.find('Checking %s Release|x64...' % (file1)) >= 0
-    assert stdout.find('Checking %s Debug|Win32...' % (file2)) >= 0
-    assert stdout.find('Checking %s Debug|x64...' % (file2)) >= 0
-    assert stdout.find('Checking %s Release|Win32...' % (file2)) >= 0
-    assert stdout.find('Checking %s Release|x64...' % (file2)) >= 0
-
-def test_gui_project_loads_relative_vs_solution():
-    create_gui_project_file('test.cppcheck', root_path='proj2', import_project='proj2/proj2.sln')
-    ret, stdout, stderr = cppcheck(['--project=test.cppcheck'])
-    assert stderr == ERR_A + ERR_B
-
-def test_gui_project_loads_relative_vs_solution():
-    create_gui_project_file('test.cppcheck', root_path='proj2', import_project='proj2/proj2.sln', exclude_paths=['b'])
-    ret, stdout, stderr = cppcheck(['--project=test.cppcheck'])
-    assert stderr == ERR_A
-
-def test_gui_project_loads_absolute_vs_solution():
-    create_gui_project_file('test.cppcheck',
-                            root_path=os.path.join(os.getcwd(), 'proj2').replace('\\', '/'),
-                            import_project=os.path.join(os.getcwd(), 'proj2', 'proj2.sln').replace('\\', '/'))
-    ret, stdout, stderr = cppcheck(['--project=test.cppcheck'])
-    assert stderr == ERR_A + ERR_B
-
diff --git a/test/cli/test-suppress-syntaxError.py b/test/cli/test-suppress-syntaxError.py
deleted file mode 100644
index 0276b1eaa7a..00000000000
--- a/test/cli/test-suppress-syntaxError.py
+++ /dev/null
@@ -1,17 +0,0 @@
-
-# python -m pytest test-suppress-syntaxError.py
-
-import os
-import re
-from testutils import cppcheck
-
-def test_j2():
-    ret, stdout, stderr = cppcheck(['--error-exitcode=1', '-j2', '-q', 'proj-suppress-syntaxError'])
-    assert ret == 1
-    assert len(stderr) > 0
-
-def test_j2_suppress():
-    ret, stdout, stderr = cppcheck(['--error-exitcode=1', '--suppress=*:proj-suppress-syntaxError/*', '-j2', '-q', 'proj-suppress-syntaxError'])
-    assert ret == 0
-    assert len(stderr) == 0
-
diff --git a/test/cli/testutils.py b/test/cli/testutils.py
index 140fd5e2b99..f352af49f15 100644
--- a/test/cli/testutils.py
+++ b/test/cli/testutils.py
@@ -1,9 +1,15 @@
-
+import errno
 import logging
 import os
+import select
 import subprocess
+import time
+import tempfile
 
 # Create Cppcheck project file
+import sys
+
+
 def create_gui_project_file(project_file, root_path=None, import_project=None, paths=None, exclude_paths=None, suppressions=None, addon=None):
     cppcheck_xml = ('<?xml version="1.0" encoding="UTF-8"?>\n'
                     '<project version="1">\n')
@@ -31,31 +37,212 @@ def create_gui_project_file(project_file, root_path=None, import_project=None, p
         cppcheck_xml += '  </suppressions>\n'
     if addon:
         cppcheck_xml += '  <addons>\n'
-        cppcheck_xml += '    <addon>%s</addon>\n' % (addon)
+        cppcheck_xml += '    <addon>%s</addon>\n' % addon
         cppcheck_xml += '  </addons>\n'
     cppcheck_xml += '</project>\n'
 
-    f = open(project_file, 'wt')
-    f.write(cppcheck_xml)
-    f.close()
+    with open(project_file, 'wt') as f:
+        f.write(cppcheck_xml)
 
 
-# Run Cppcheck with args
-def cppcheck(args):
-    exe = None
-    if os.path.isfile('../../cppcheck.exe'):
-        exe = '../../cppcheck.exe'
-    elif os.path.isfile('../../../cppcheck.exe'):
-        exe = '../../../cppcheck.exe'
-    elif os.path.isfile('../../cppcheck'):
-        exe = '../../cppcheck'
+def __lookup_cppcheck_exe():
+    # path the script is located in
+    script_path = os.path.dirname(os.path.realpath(__file__))
+
+    exe_name = "cppcheck"
+
+    if sys.platform == "win32":
+        exe_name += ".exe"
+
+    exe_path = None
+
+    if 'TEST_CPPCHECK_EXE_LOOKUP_PATH' in os.environ:
+        lookup_paths = [os.environ['TEST_CPPCHECK_EXE_LOOKUP_PATH']]
     else:
-        exe = '../../../cppcheck'
+        lookup_paths = [os.path.join(script_path, '..', '..'), '.']
+
+    for base in lookup_paths:
+        for path in ('', 'bin', os.path.join('bin', 'debug')):
+            tmp_exe_path = os.path.join(base, path, exe_name)
+            if os.path.isfile(tmp_exe_path):
+                exe_path = tmp_exe_path
+                break
+
+    if exe_path:
+        exe_path = os.path.abspath(exe_path)
+        print("using '{}'".format(exe_path))
+    return exe_path
+
+
+def __run_subprocess_tty(args, env=None, cwd=None, timeout=None):
+    import pty
+    mo, so = pty.openpty()
+    me, se = pty.openpty()
+    p = subprocess.Popen(args, stdout=so, stderr=se, env=env, cwd=cwd)
+    for fd in [so, se]:
+        os.close(fd)
+
+    select_timeout = 0.04  # seconds
+    readable = [mo, me]
+    result = {mo: b'', me: b''}
+    try:
+        start_time = time.monotonic()
+        while readable:
+            ready, _, _ = select.select(readable, [], [], select_timeout)
+            for fd in ready:
+                try:
+                    data = os.read(fd, 512)
+                except OSError as e:
+                    if e.errno != errno.EIO:
+                        raise
+                    # EIO means EOF on some systems
+                    readable.remove(fd)
+                else:
+                    if not data: # EOF
+                        readable.remove(fd)
+                    result[fd] += data
+            if timeout is not None and (time.monotonic() - start_time):
+                break
+    finally:
+        for fd in [mo, me]:
+            os.close(fd)
+        if p.poll() is None:
+            p.kill()
+        return_code = p.wait()
+
+    stdout = result[mo]
+    stderr = result[me]
+    return return_code, stdout, stderr
+
+
+def __run_subprocess(args, env=None, cwd=None, timeout=None):
+    p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env, cwd=cwd)
+
+    try:
+        stdout, stderr = p.communicate(timeout=timeout)
+        return_code = p.returncode
+        p = None
+    except subprocess.TimeoutExpired:
+        import psutil
+        # terminate all the child processes
+        child_procs = psutil.Process(p.pid).children(recursive=True)
+        if len(child_procs) > 0:
+            for child in child_procs:
+                child.terminate()
+            try:
+                # call with timeout since it might be stuck
+                p.communicate(timeout=5)
+                p = None
+            except subprocess.TimeoutExpired:
+                pass
+        raise
+    finally:
+        if p:
+            # sending the signal to the process groups causes the parent Python process to terminate as well
+            #os.killpg(os.getpgid(p.pid), signal.SIGTERM)  # Send the signal to all the process groups
+            p.terminate()
+            stdout, stderr = p.communicate()
+            p = None
+
+    return return_code, stdout, stderr
+
+
+# Run Cppcheck with args
+def cppcheck_ex(args, env=None, remove_checkers_report=True, cwd=None, cppcheck_exe=None, timeout=None, tty=False):
+    exe = cppcheck_exe if cppcheck_exe else __lookup_cppcheck_exe()
+    assert exe is not None, 'no cppcheck binary found'
+
+    # do not inject arguments for calls with exclusive options
+    has_exclusive = bool({'--doc', '--errorlist', '-h', '--help', '--version'} & set(args))
+
+    if not has_exclusive and ('TEST_CPPCHECK_INJECT_J' in os.environ):
+        found_j = False
+        for arg in args:
+            if arg.startswith('-j'):
+                found_j = True
+                break
+        if not found_j:
+            arg_j = '-j' + str(os.environ['TEST_CPPCHECK_INJECT_J'])
+            args.append(arg_j)
+
+    if not has_exclusive and ('TEST_CPPCHECK_INJECT_CLANG' in os.environ):
+        found_clang = False
+        for arg in args:
+            if arg.startswith('--clang'):
+                found_clang = True
+                break
+        if not found_clang:
+            arg_clang = '--clang=' + str(os.environ['TEST_CPPCHECK_INJECT_CLANG'])
+            args.append(arg_clang)
+
+    if not has_exclusive and ('TEST_CPPCHECK_INJECT_EXECUTOR' in os.environ):
+        found_jn = False
+        found_executor = False
+        for arg in args:
+            if arg.startswith('-j') and arg != '-j1':
+                found_jn = True
+                continue
+            if arg.startswith('--executor'):
+                found_executor = True
+                continue
+        # only add '--executor' if we are actually using multiple jobs
+        if found_jn and not found_executor:
+            arg_executor = '--executor=' + str(os.environ['TEST_CPPCHECK_INJECT_EXECUTOR'])
+            args.append(arg_executor)
+
+    builddir_tmp = None
+
+    if not has_exclusive and ('TEST_CPPCHECK_INJECT_BUILDDIR' in os.environ):
+        found_builddir = False
+        for arg in args:
+            if arg.startswith('--cppcheck-build-dir=') or arg == '--no-cppcheck-build-dir':
+                found_builddir = True
+                break
+        if not found_builddir:
+            builddir_tmp = tempfile.TemporaryDirectory(prefix=str(os.environ['TEST_CPPCHECK_INJECT_BUILDDIR']))
+            arg_clang = '--cppcheck-build-dir=' + builddir_tmp.name
+            args.append(arg_clang)
 
     logging.info(exe + ' ' + ' '.join(args))
-    p = subprocess.Popen([exe] + args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    comm = p.communicate()
-    stdout = comm[0].decode(encoding='utf-8', errors='ignore').replace('\r\n', '\n')
-    stderr = comm[1].decode(encoding='utf-8', errors='ignore').replace('\r\n', '\n')
-    return p.returncode, stdout, stderr
 
+    run_subprocess = __run_subprocess_tty if tty else __run_subprocess
+    return_code, stdout, stderr = run_subprocess([exe] + args, env=env, cwd=cwd, timeout=timeout)
+
+    stdout = stdout.decode(encoding='utf-8', errors='ignore').replace('\r\n', '\n')
+    stderr = stderr.decode(encoding='utf-8', errors='ignore').replace('\r\n', '\n')
+
+    if builddir_tmp:
+        builddir_tmp.cleanup()
+
+    if remove_checkers_report:
+        if stderr.find('[checkersReport]\n') > 0:
+            start_id = stderr.find('[checkersReport]\n')
+            start_line = stderr.rfind('\n', 0, start_id)
+            if start_line <= 0:
+                stderr = ''
+            else:
+                stderr = stderr[:start_line + 1]
+        elif stderr.find(': (information) Active checkers: ') >= 0:
+            pos = stderr.find(': (information) Active checkers: ')
+            if pos == 0:
+                stderr = ''
+            elif stderr[pos - 1] == '\n':
+                stderr = stderr[:pos]
+    return return_code, stdout, stderr, exe
+
+
+def cppcheck(*args, **kwargs):
+    return_code, stdout, stderr, _ = cppcheck_ex(*args, **kwargs)
+    return return_code, stdout, stderr
+
+
+def assert_cppcheck(args, ec_exp=None, out_exp=None, err_exp=None, env=None, cwd=None):
+    exitcode, stdout, stderr = cppcheck(args, env=env, cwd=cwd)
+    if ec_exp is not None:
+        assert exitcode == ec_exp, stdout
+    if out_exp is not None:
+        out_lines = stdout.splitlines()
+        assert out_lines == out_exp, out_lines
+    if err_exp is not None:
+        err_lines = stderr.splitlines()
+        assert err_lines == err_exp, err_lines
diff --git a/test/cli/trac5704/trac5704a.c b/test/cli/trac5704/trac5704a.c
new file mode 100644
index 00000000000..e2501041338
--- /dev/null
+++ b/test/cli/trac5704/trac5704a.c
@@ -0,0 +1,11 @@
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+#ifdef INCLUDE_ZERO_DIV
+    // cppcheck-suppress zerodiv
+    int i = 1/0;
+    printf("i = %d\n", i);
+#endif
+    return 0;
+}
diff --git a/test/cli/trac5704/trac5704b.c b/test/cli/trac5704/trac5704b.c
new file mode 100644
index 00000000000..17b28101680
--- /dev/null
+++ b/test/cli/trac5704/trac5704b.c
@@ -0,0 +1,11 @@
+#include <stdio.h>
+
+int main(int argc, char *argv[])
+{
+#ifdef 0
+    // cppcheck-suppress zerodiv
+    int i = 1/0;
+    printf("i = %d\n", i);
+#endif
+    return 0;
+}
diff --git a/test/cli/unusedFunction/1.c b/test/cli/unusedFunction/1.c
new file mode 100644
index 00000000000..6e725814d2b
--- /dev/null
+++ b/test/cli/unusedFunction/1.c
@@ -0,0 +1,7 @@
+#include "3.h"
+
+// cppcheck-suppress unusedFunction
+void f1()
+{
+    f3_1();
+}
\ No newline at end of file
diff --git a/test/cli/unusedFunction/2.c b/test/cli/unusedFunction/2.c
new file mode 100644
index 00000000000..c6bf77cea8b
--- /dev/null
+++ b/test/cli/unusedFunction/2.c
@@ -0,0 +1,7 @@
+#include "3.h"
+
+// cppcheck-suppress unusedFunction
+void f2()
+{
+    f3_2();
+}
\ No newline at end of file
diff --git a/test/cli/unusedFunction/3.c b/test/cli/unusedFunction/3.c
new file mode 100644
index 00000000000..3b517fe3c36
--- /dev/null
+++ b/test/cli/unusedFunction/3.c
@@ -0,0 +1,3 @@
+void f3_1() {}
+void f3_2() {}
+void f3_3() {}
\ No newline at end of file
diff --git a/test/cli/unusedFunction/3.h b/test/cli/unusedFunction/3.h
new file mode 100644
index 00000000000..3b643b42c26
--- /dev/null
+++ b/test/cli/unusedFunction/3.h
@@ -0,0 +1,3 @@
+void f3_1();
+void f3_2();
+void f3_3();
\ No newline at end of file
diff --git a/test/cli/unusedFunction/4.c b/test/cli/unusedFunction/4.c
new file mode 100644
index 00000000000..ae17ea51075
--- /dev/null
+++ b/test/cli/unusedFunction/4.c
@@ -0,0 +1,7 @@
+static void f4_0() {}
+
+// cppcheck-suppress unusedFunction
+void f4_1()
+{
+    f4_0();
+}
\ No newline at end of file
diff --git a/test/cli/unusedFunction/unusedFunction.cppcheck b/test/cli/unusedFunction/unusedFunction.cppcheck
new file mode 100644
index 00000000000..fd28f7074a9
--- /dev/null
+++ b/test/cli/unusedFunction/unusedFunction.cppcheck
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="1">
+    <paths>
+        <dir name="1.c"/>
+        <dir name="2.c"/>
+        <dir name="3.c"/>
+        <dir name="4.c"/>
+    </paths>
+</project>
\ No newline at end of file
diff --git a/test/cli/unused_function_test.py b/test/cli/unused_function_test.py
new file mode 100644
index 00000000000..591986f1dde
--- /dev/null
+++ b/test/cli/unused_function_test.py
@@ -0,0 +1,204 @@
+
+# python3 -m pytest test-unused_function_test.py
+
+import os
+import json
+import sys
+import pytest
+from testutils import cppcheck
+
+__script_dir = os.path.dirname(os.path.abspath(__file__))
+
+__project_dir = os.path.join(__script_dir, 'unusedFunction')
+__project_dir_sep = __project_dir + os.path.sep
+
+
+# TODO: make this a generic helper function
+def __create_compdb(tmpdir, projpath):
+    compile_commands = os.path.join(tmpdir, 'compile_commands.json')
+    files = []
+    for f in os.listdir(projpath):
+        files.append(f)
+    files.sort()
+    j = []
+    for f in files:
+        j.append({
+            'directory': projpath,
+            'file': os.path.join(projpath, f),
+            'command': 'gcc -c {}'.format(f)
+        })
+    with open(compile_commands, 'wt') as f:
+        f.write(json.dumps(j, indent=4))
+    return compile_commands
+
+
+def __test_unused_functions(extra_args):
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=unusedFunction',
+        '--inline-suppr',
+        __project_dir
+    ]
+    args += extra_args
+    ret, stdout, stderr = cppcheck(args)
+    assert stdout.splitlines() == []
+    assert stderr.splitlines() == [
+        "{}3.c:3:6: style: The function 'f3_3' is never used. [unusedFunction]".format(__project_dir_sep)
+    ]
+    assert ret == 0, stdout
+
+
+def test_unused_functions():
+    __test_unused_functions(['-j1', '--no-cppcheck-build-dir'])
+
+
+def test_unused_functions_j():
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=unusedFunction',
+        '--inline-suppr',
+        '-j2',
+        '--no-cppcheck-build-dir',
+        __project_dir
+    ]
+    ret, stdout, stderr = cppcheck(args)
+    assert stdout.splitlines() == [
+        "cppcheck: unusedFunction check requires --cppcheck-build-dir to be active with -j."
+    ]
+    assert stderr.splitlines() == []
+    assert ret == 0, stdout
+
+
+def test_unused_functions_builddir(tmpdir):
+    build_dir = os.path.join(tmpdir, 'b1')
+    os.mkdir(build_dir)
+    __test_unused_functions(['-j1', '--cppcheck-build-dir={}'.format(build_dir)])
+
+
+def test_unused_functions_builddir_j_thread(tmpdir):
+    build_dir = os.path.join(tmpdir, 'b1')
+    os.mkdir(build_dir)
+    __test_unused_functions(['-j2', '--cppcheck-build-dir={}'.format(build_dir), '--executor=thread'])
+
+
+@pytest.mark.skipif(sys.platform == 'win32', reason='ProcessExecutor not available on Windows')
+def test_unused_functions_builddir_j_process(tmpdir):
+    build_dir = os.path.join(tmpdir, 'b1')
+    os.mkdir(build_dir)
+    __test_unused_functions(['-j2', '--cppcheck-build-dir={}'.format(build_dir), '--executor=process'])
+
+
+def __test_unused_functions_project(extra_args):
+    project_file = os.path.join(__project_dir, 'unusedFunction.cppcheck')
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=unusedFunction',
+        '--inline-suppr',
+        '--project={}'.format(project_file),
+    ]
+    args += extra_args
+    ret, stdout, stderr = cppcheck(args)
+    assert stdout.splitlines() == []
+    assert [
+        "{}3.c:3:6: style: The function 'f3_3' is never used. [unusedFunction]".format(__project_dir_sep)
+    ] == stderr.splitlines()
+    assert ret == 0, stdout
+
+
+def test_unused_functions_project():
+    __test_unused_functions_project(['-j1', '--no-cppcheck-build-dir'])
+
+
+def test_unused_functions_project_j():
+    project_file = os.path.join(__project_dir, 'unusedFunction.cppcheck')
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=unusedFunction',
+        '--inline-suppr',
+        '--project={}'.format(project_file),
+        '-j2',
+        '--no-cppcheck-build-dir'
+    ]
+    ret, stdout, stderr = cppcheck(args)
+    assert stdout.splitlines() == [
+        "cppcheck: unusedFunction check requires --cppcheck-build-dir to be active with -j."
+    ]
+    assert [] == stderr.splitlines()
+    assert ret == 0, stdout
+
+
+def test_unused_functions_project_builddir(tmpdir):
+    build_dir = os.path.join(tmpdir, 'b1')
+    os.mkdir(build_dir)
+    __test_unused_functions_project(['-j1', '--cppcheck-build-dir={}'.format(build_dir)])
+
+
+def test_unused_functions_project_builddir_j_thread(tmpdir):
+    build_dir = os.path.join(tmpdir, 'b1')
+    os.mkdir(build_dir)
+    __test_unused_functions_project(['-j2', '--cppcheck-build-dir={}'.format(build_dir), '--executor=thread'])
+
+
+@pytest.mark.skipif(sys.platform == 'win32', reason='ProcessExecutor not available on Windows')
+def test_unused_functions_project_builddir_j_process(tmpdir):
+    build_dir = os.path.join(tmpdir, 'b1')
+    os.mkdir(build_dir)
+    __test_unused_functions_project(['-j2', '--cppcheck-build-dir={}'.format(build_dir), '--executor=process'])
+
+
+def __test_unused_functions_compdb(tmpdir, extra_args):
+    compdb_file = __create_compdb(tmpdir, __project_dir)
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=unusedFunction',
+        '--inline-suppr',
+        '--project={}'.format(compdb_file)
+    ]
+    args += extra_args
+    ret, stdout, stderr = cppcheck(args)
+    assert stdout.splitlines() == []
+    assert stderr.splitlines() == [
+        "{}3.c:3:6: style: The function 'f3_3' is never used. [unusedFunction]".format(__project_dir_sep)
+    ]
+    assert ret == 0, stdout
+
+
+def test_unused_functions_compdb(tmpdir):
+    __test_unused_functions_compdb(tmpdir, ['-j1', '--no-cppcheck-build-dir'])
+
+
+def test_unused_functions_compdb_j(tmpdir):
+    compdb_file = __create_compdb(tmpdir, __project_dir)
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=unusedFunction',
+        '--inline-suppr',
+        '--project={}'.format(compdb_file),
+        '-j2',
+        '--no-cppcheck-build-dir'
+    ]
+    ret, stdout, stderr = cppcheck(args)
+    assert stdout.splitlines() == [
+        "cppcheck: unusedFunction check requires --cppcheck-build-dir to be active with -j."
+    ]
+    assert stderr.splitlines() == []
+    assert ret == 0, stdout
+
+
+def test_unused_functions_compdb_buildir_j_thread(tmpdir):
+    build_dir = os.path.join(tmpdir, 'b1')
+    os.mkdir(build_dir)
+    __test_unused_functions_compdb(tmpdir, ['-j2', '--cppcheck-build-dir={}'.format(build_dir), '--executor=thread'])
+
+
+@pytest.mark.skipif(sys.platform == 'win32', reason='ProcessExecutor not available on Windows')
+def test_unused_functions_compdb_builddir_j_process(tmpdir):
+    build_dir = os.path.join(tmpdir, 'b1')
+    os.mkdir(build_dir)
+    __test_unused_functions_compdb(tmpdir, ['-j2', '--cppcheck-build-dir={}'.format(build_dir), '--executor=process'])
\ No newline at end of file
diff --git a/test/cli/whole-program/nullpointer1.cpp b/test/cli/whole-program/nullpointer1.cpp
new file mode 100644
index 00000000000..d323e3ad1d3
--- /dev/null
+++ b/test/cli/whole-program/nullpointer1.cpp
@@ -0,0 +1 @@
+#include "nullpointer1.h"
diff --git a/test/cli/whole-program/nullpointer1.h b/test/cli/whole-program/nullpointer1.h
new file mode 100644
index 00000000000..56fa6c49d84
--- /dev/null
+++ b/test/cli/whole-program/nullpointer1.h
@@ -0,0 +1,8 @@
+#include "nullpointer1_1.h"
+
+template<typename T>
+void f(T* p) {
+    if (sizeof(T) == 4)
+        p = nullptr;
+    g(p);
+}
diff --git a/test/cli/whole-program/nullpointer1_1.h b/test/cli/whole-program/nullpointer1_1.h
new file mode 100644
index 00000000000..cbbc478cf2c
--- /dev/null
+++ b/test/cli/whole-program/nullpointer1_1.h
@@ -0,0 +1,4 @@
+template<typename T>
+void g(T* p) {
+    *p = 0;
+};
diff --git a/test/cli/whole-program/odr.h b/test/cli/whole-program/odr.h
new file mode 100644
index 00000000000..29965892446
--- /dev/null
+++ b/test/cli/whole-program/odr.h
@@ -0,0 +1,7 @@
+class Base {
+public:
+    virtual void f() = 0;
+};
+
+extern Base *c1_create();
+extern Base *c2_create();
\ No newline at end of file
diff --git a/test/cli/whole-program/odr1.cpp b/test/cli/whole-program/odr1.cpp
new file mode 100644
index 00000000000..11f3f53b8d8
--- /dev/null
+++ b/test/cli/whole-program/odr1.cpp
@@ -0,0 +1,17 @@
+#include "odr.h"
+
+#include <iostream>
+
+// cppcheck-suppress ctuOneDefinitionRuleViolation
+class C : public Base
+{
+public:
+    void f() override {
+        std::cout << "1";
+    }
+};
+
+Base *c1_create()
+{
+    return new C();
+}
diff --git a/test/cli/whole-program/odr2.cpp b/test/cli/whole-program/odr2.cpp
new file mode 100644
index 00000000000..849418af508
--- /dev/null
+++ b/test/cli/whole-program/odr2.cpp
@@ -0,0 +1,16 @@
+#include "odr.h"
+
+#include <iostream>
+
+class C : public Base
+{
+public:
+    void f() override {
+        std::cout << "2";
+    }
+};
+
+Base *c2_create()
+{
+    return new C();
+}
diff --git a/test/cli/whole-program/odr3.cpp b/test/cli/whole-program/odr3.cpp
new file mode 100644
index 00000000000..a4c555e5b7e
--- /dev/null
+++ b/test/cli/whole-program/odr3.cpp
@@ -0,0 +1,6 @@
+// #10431
+#ifdef X
+struct S { S() {} };
+#else
+struct S {};
+#endif
diff --git a/test/cli/whole-program/odr_cfg1.cpp b/test/cli/whole-program/odr_cfg1.cpp
new file mode 100644
index 00000000000..c50bdda949f
--- /dev/null
+++ b/test/cli/whole-program/odr_cfg1.cpp
@@ -0,0 +1,3 @@
+#ifdef X
+struct S {};
+#endif
diff --git a/test/cli/whole-program/odr_cfg2.cpp b/test/cli/whole-program/odr_cfg2.cpp
new file mode 100644
index 00000000000..2b439177aad
--- /dev/null
+++ b/test/cli/whole-program/odr_cfg2.cpp
@@ -0,0 +1,3 @@
+struct S {
+    S() {}
+};
diff --git a/test/cli/whole-program/whole1.c b/test/cli/whole-program/whole1.c
new file mode 100644
index 00000000000..0917e545c06
--- /dev/null
+++ b/test/cli/whole-program/whole1.c
@@ -0,0 +1,3 @@
+// cppcheck-suppress misra-c2012-8.4
+// cppcheck-suppress misra-c2012-5.8
+int misra_5_8_var1;
diff --git a/test/cli/whole-program/whole2.c b/test/cli/whole-program/whole2.c
new file mode 100644
index 00000000000..62546753586
--- /dev/null
+++ b/test/cli/whole-program/whole2.c
@@ -0,0 +1,2 @@
+// cppcheck-suppress misra-c2012-5.8
+static int misra_5_8_var1;
diff --git a/test/cli/whole-program_test.py b/test/cli/whole-program_test.py
new file mode 100644
index 00000000000..dfb4e8112d1
--- /dev/null
+++ b/test/cli/whole-program_test.py
@@ -0,0 +1,432 @@
+import glob
+import os
+import pytest
+import json
+import shutil
+from testutils import cppcheck
+import xml.etree.ElementTree as ET
+
+__script_dir = os.path.dirname(os.path.abspath(__file__))
+
+# TODO: use dedicated addon
+# TODO: test CheckNullPointer
+# TODO: test CheckUninitVar
+# TODO: test CheckBufferOverrun
+
+
+def __create_compile_commands(dir, entries):
+    j = []
+    for e in entries:
+        f = os.path.basename(e)
+        obj = {
+            'directory': os.path.dirname(os.path.abspath(e)),
+            'command': 'gcc -c {}'.format(f),
+            'file': f
+        }
+        j.append(obj)
+    compile_commands = os.path.join(dir, 'compile_commmands.json')
+    with open(compile_commands, 'wt') as f:
+        f.write(json.dumps(j))
+    return compile_commands
+
+
+def test_addon_suppress_inline():
+    args = [
+        '-q',
+        '--addon=misra',
+        '--template=simple',
+        '--enable=information,style',
+        '--inline-suppr',
+        '--error-exitcode=1',
+        'whole-program/whole1.c',
+        'whole-program/whole2.c'
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    assert lines == []
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+def test_addon_suppress_inline_project(tmpdir):
+    compile_db = __create_compile_commands(tmpdir, [
+        os.path.join(__script_dir, 'whole-program', 'whole1.c'),
+        os.path.join(__script_dir, 'whole-program', 'whole2.c')
+    ])
+
+    args = [
+        '-q',
+        '--addon=misra',
+        '--template=simple',
+        '--enable=information,style',
+        '--inline-suppr',
+        '--error-exitcode=1',
+        '--project={}'.format(compile_db)
+    ]
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    assert lines == []
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+# TODO: remove overrides when this is fully working
+def __test_suppress_inline(extra_args):
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=information,style',
+        '--inline-suppr',
+        '--error-exitcode=1',
+        'whole-program/odr1.cpp',
+        'whole-program/odr2.cpp'
+    ]
+
+    args += extra_args
+
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    assert lines == []
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+def test_suppress_inline():
+    __test_suppress_inline(['-j1', '--no-cppcheck-build-dir'])
+
+
+@pytest.mark.xfail(strict=True)
+def test_suppress_inline_j():
+    __test_suppress_inline(['-j2', '--no-cppcheck-build-dir'])
+
+
+def test_suppress_inline_builddir(tmp_path):
+    build_dir = tmp_path / 'b1'
+    os.mkdir(build_dir)
+    __test_suppress_inline(['--cppcheck-build-dir={}'.format(build_dir), '-j1'])
+
+
+def test_suppress_inline_builddir_cached(tmp_path):
+    build_dir = tmp_path / 'b1'
+    os.mkdir(build_dir)
+    __test_suppress_inline(['--cppcheck-build-dir={}'.format(build_dir), '-j1'])
+    __test_suppress_inline(['--cppcheck-build-dir={}'.format(build_dir), '-j1'])
+
+
+def test_suppress_inline_builddir_j(tmp_path):
+    build_dir = tmp_path / 'b1'
+    os.mkdir(build_dir)
+    __test_suppress_inline(['--cppcheck-build-dir={}'.format(build_dir), '-j2'])
+
+
+def test_inline_suppr_builddir_j_cached(tmp_path):
+    build_dir = tmp_path / 'b1'
+    os.mkdir(build_dir)
+    __test_suppress_inline(['--cppcheck-build-dir={}'.format(build_dir), '-j2'])
+    __test_suppress_inline(['--cppcheck-build-dir={}'.format(build_dir), '-j2'])
+
+
+# TODO: remove overrides when it is fully working
+def __test_suppress_inline_project(tmp_path, extra_args):
+    compile_db = __create_compile_commands(str(tmp_path), [
+        os.path.join(__script_dir, 'whole-program', 'odr1.cpp'),
+        os.path.join(__script_dir, 'whole-program', 'odr2.cpp')
+    ])
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=information,style',
+        '--inline-suppr',
+        '--error-exitcode=1',
+        '--project={}'.format(compile_db)
+    ]
+
+    args += extra_args
+
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    assert lines == []
+    assert stdout == ''
+    assert ret == 0, stdout
+
+
+
+def test_suppress_inline_project(tmp_path):
+    __test_suppress_inline_project(tmp_path, ['-j1', '--no-cppcheck-build-dir'])
+
+
+@pytest.mark.xfail(strict=True)
+def test_suppress_inline_project_j(tmp_path):
+    __test_suppress_inline_project(tmp_path, ['-j2', '--no-cppcheck-build-dir'])
+
+
+def test_suppress_inline_project_builddir(tmp_path):
+    build_dir = tmp_path / 'b1'
+    os.mkdir(build_dir)
+    __test_suppress_inline_project(tmp_path, ['--cppcheck-build-dir={}'.format(build_dir), '-j1'])
+
+
+def test_suppress_inline_project_builddir_cached(tmp_path):
+    build_dir = tmp_path / 'b1'
+    os.mkdir(build_dir)
+    __test_suppress_inline_project(tmp_path, ['--cppcheck-build-dir={}'.format(build_dir), '-j1'])
+    __test_suppress_inline_project(tmp_path, ['--cppcheck-build-dir={}'.format(build_dir), '-j1'])
+
+
+def test_suppress_inline_project_builddir_j(tmp_path):
+    build_dir = tmp_path / 'b1'
+    os.mkdir(build_dir)
+    __test_suppress_inline_project(tmp_path, ['--cppcheck-build-dir={}'.format(build_dir), '-j2'])
+
+
+def test_suppress_inline_project_builddir_j_cached(tmp_path):
+    build_dir = tmp_path / 'b1'
+    os.mkdir(build_dir)
+    __test_suppress_inline_project(tmp_path, ['--cppcheck-build-dir={}'.format(build_dir), '-j2'])
+    __test_suppress_inline_project(tmp_path, ['--cppcheck-build-dir={}'.format(build_dir), '-j2'])
+
+
+@pytest.mark.parametrize("builddir", (False,True))
+def test_addon_rerun(tmp_path, builddir):
+    """Rerun analysis and ensure that misra CTU works; with and without build dir"""
+    args = [
+        '--addon=misra',
+        '--enable=style',
+        '--template={id}',
+        'whole-program']
+    # do not use the injection because the directory needs to survive runs
+    if builddir:
+        args.append('--cppcheck-build-dir=' + str(tmp_path))
+    else:
+        args.append('--no-cppcheck-build-dir')
+    _, _, stderr = cppcheck(args, cwd=__script_dir)
+    assert 'misra-c2012-5.8' in stderr
+    _, _, stderr = cppcheck(args, cwd=__script_dir)
+    assert 'misra-c2012-5.8' in stderr
+
+def test_addon_builddir_use_ctuinfo(tmp_path):
+    """Test that ctu-info files are used when builddir is used"""
+    args = [
+        '--cppcheck-build-dir=' + str(tmp_path),
+        '--addon=misra',
+        '--enable=style',
+        '--template={id}',
+        'whole-program']
+    _, _, stderr = cppcheck(args, cwd=__script_dir)
+    assert 'misra-c2012-5.8' in stderr
+    with open(tmp_path / 'whole1.a1.ctu-info', 'wt'):
+        pass
+    with open(tmp_path / 'whole2.a1.ctu-info', 'wt'):
+        pass
+    _, _, stderr = cppcheck(args, cwd=__script_dir)
+    assert 'misra-c2012-5.8' not in stderr
+
+
+@pytest.mark.parametrize("builddir", (False,True))
+def test_addon_no_artifacts(tmp_path, builddir):
+    """Test that there are no artifacts left after analysis"""
+    shutil.copyfile(os.path.join(__script_dir, 'whole-program', 'whole1.c'), tmp_path / 'whole1.c')
+    shutil.copyfile(os.path.join(__script_dir, 'whole-program', 'whole2.c'), tmp_path / 'whole2.c')
+    build_dir = str(tmp_path / 'b1')
+    os.mkdir(build_dir)
+    args = [
+        '--addon=misra',
+        '--enable=style',
+        '--template={id}',
+        str(tmp_path)]
+    if builddir:
+        args.append('--cppcheck-build-dir=' + build_dir)
+    _, _, stderr = cppcheck(args, cwd=__script_dir)
+    assert 'misra-c2012-5.8' in stderr
+    files = []
+    for f in glob.glob(str(tmp_path / '*')):
+        if os.path.isfile(f):
+            files.append(os.path.basename(f))
+    files.sort()
+    assert ' '.join(files) == 'whole1.c whole2.c'
+
+
+def __test_checkclass(extra_args):
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=information,style',
+        '--error-exitcode=1',
+        'whole-program/odr1.cpp',
+        'whole-program/odr2.cpp',
+        'whole-program/odr3.cpp'
+    ]
+
+    args += extra_args
+
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    assert lines == [
+        "whole-program{}odr1.cpp:6:1: error: The one definition rule is violated, different classes/structs have the same name 'C' [ctuOneDefinitionRuleViolation]".format(os.path.sep)
+    ]
+    assert stdout == ''
+    assert ret == 1, stdout
+
+
+def test_checkclass():
+    __test_checkclass(['-j1'])
+
+
+@pytest.mark.xfail(strict=True) # TODO: check error
+def test_checkclass_j():
+    __test_checkclass(['-j2', '--no-cppcheck-build-dir'])
+
+
+def test_checkclass_builddir(tmpdir):
+    build_dir = os.path.join(tmpdir, 'b1')
+    os.mkdir(build_dir)
+    __test_checkclass(['--cppcheck-build-dir={}'.format(build_dir)])
+
+
+def test_checkclass_builddir_j(tmpdir):
+    build_dir = os.path.join(tmpdir, 'b1')
+    os.mkdir(build_dir)
+    __test_checkclass(['-j2', '--cppcheck-build-dir={}'.format(build_dir)])
+
+
+def __test_checkclass_project(tmpdir, extra_args):
+    odr_file_1 = os.path.join(__script_dir, 'whole-program', 'odr1.cpp')
+
+    compile_db = __create_compile_commands(tmpdir, [
+        odr_file_1,
+        os.path.join(__script_dir, 'whole-program', 'odr2.cpp')
+    ])
+
+    args = [
+        '-q',
+        '--template=simple',
+        '--enable=information,style',
+        '--error-exitcode=1',
+        '--project={}'.format(compile_db)
+    ]
+
+    args += extra_args
+
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    assert lines == [
+        "{}:6:1: error: The one definition rule is violated, different classes/structs have the same name 'C' [ctuOneDefinitionRuleViolation]".format(odr_file_1)
+    ]
+    assert stdout == ''
+    assert ret == 1, stdout
+
+
+def test_checkclass_project(tmpdir):
+    __test_checkclass_project(tmpdir, ['-j1'])
+
+
+@pytest.mark.xfail(strict=True) # TODO: check error
+def test_checkclass_project_j(tmpdir):
+    __test_checkclass_project(tmpdir, ['-j2', '--no-cppcheck-build-dir'])
+
+
+def test_checkclass_project_builddir(tmpdir):
+    build_dir = os.path.join(tmpdir, 'b1')
+    os.mkdir(build_dir)
+    __test_checkclass_project(tmpdir, ['-j1', '--cppcheck-build-dir={}'.format(build_dir)])
+
+
+def test_checkclass_project_builddir_j(tmpdir):
+    build_dir = os.path.join(tmpdir, 'b1')
+    os.mkdir(build_dir)
+    __test_checkclass_project(tmpdir, ['-j2', '--cppcheck-build-dir={}'.format(build_dir)])
+
+def test_ctu_odr_config():
+    args = [
+        '-q',
+        '-j1',
+        '--template=simple',
+        '--enable=information,style',
+        '--error-exitcode=1',
+        'whole-program/odr_cfg1.cpp',
+        'whole-program/odr_cfg2.cpp'
+    ]
+
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    lines = stderr.splitlines()
+    assert lines == [
+        "whole-program{}odr_cfg1.cpp:2:1: error: The one definition rule is violated, different classes/structs have the same name 'S' [ctuOneDefinitionRuleViolation]".format(os.path.sep)
+    ]
+    assert stdout == ''
+    assert ret == 1, stdout
+
+
+def __test_nullpointer_file0(extra_args):
+    args = [
+        '-q',
+        '--xml',
+        '--error-exitcode=1',
+        'whole-program/nullpointer1.cpp'
+    ]
+
+    args += extra_args
+
+    ret, stdout, stderr = cppcheck(args, cwd=__script_dir)
+    results = ET.fromstring(stderr)
+    file0 = ''
+    for e in results.findall('errors/error[@id="ctunullpointer"]'):
+        file0 = e.attrib['file0']
+
+    assert ret == 1, stdout if stdout else stderr
+    assert stdout == ''
+    assert file0 == 'whole-program/nullpointer1.cpp', stderr
+
+
+def test_nullpointer_file0():
+    __test_nullpointer_file0(['-j1'])
+
+
+@pytest.mark.xfail(strict=True) # no CTU without builddir
+def test_nullpointer_file0_j():
+    __test_nullpointer_file0(['-j2', '--no-cppcheck-build-dir'])
+
+
+def test_nullpointer_file0_builddir_j(tmpdir):
+    build_dir = os.path.join(tmpdir, 'b1')
+    os.mkdir(build_dir)
+    __test_nullpointer_file0(['-j2', '--cppcheck-build-dir={}'.format(build_dir)])
+
+# TODO: this only succeeded because it depedent on the bugged unqiue message handling
+@pytest.mark.parametrize("single_file", [
+    False,
+    pytest.param(True, marks=pytest.mark.xfail(strict=True)),
+])
+def test_nullpointer_out_of_memory(tmpdir, single_file):
+    """Ensure that there are not duplicate warnings related to memory/resource allocation failures
+       https://trac.cppcheck.net/ticket/13521
+    """
+    code1 = 'void f(int* p) { *p = 0; }\n'
+    code2 = 'int main() { int* p = malloc(10); f(p); return 0; }\n'
+    if single_file:
+        with open(tmpdir / 'test.c', 'wt') as f:
+            f.write(code1 + code2)
+    else:
+        with open(tmpdir / 'header.h', 'wt') as f:
+            f.write('void f(int* p);\n')
+        with open(tmpdir / 'test1.c', 'wt') as f:
+            f.write('#include "header.h"\n' + code1)
+        with open(tmpdir / 'test2.c', 'wt') as f:
+            f.write('#include "header.h"\n' + code2)
+    args = [
+        '--cppcheck-build-dir=.',
+        '--enable=style',
+        '.']
+    _, _, stderr = cppcheck(args, cwd=tmpdir)
+    results = []
+    for line in stderr.splitlines():
+        if line.endswith(']'):
+            results.append(line[line.find('['):])
+
+    if single_file:
+        # the bug is found and reported using normal valueflow analysis
+        # ctu finding is not reported
+        assert results == ['[nullPointerOutOfMemory]']
+    else:
+        # the bug is found using ctu analysis
+        assert results == ['[ctunullpointerOutOfMemory]']
diff --git a/test/fixture.cpp b/test/fixture.cpp
new file mode 100644
index 00000000000..00c844815fa
--- /dev/null
+++ b/test/fixture.cpp
@@ -0,0 +1,532 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "fixture.h"
+
+#include "errortypes.h"
+#include "helpers.h"
+#include "library.h"
+#include "options.h"
+#include "redirect.h"
+
+#include <algorithm>
+#include <cstdio>
+#include <cctype>
+#include <exception>
+#include <iostream>
+#include <set>
+#include <sstream>
+#include <string>
+
+#include "xml.h"
+
+/**
+ * TestRegistry
+ **/
+namespace {
+    struct CompareFixtures {
+        bool operator()(const TestInstance* lhs, const TestInstance* rhs) const {
+            return lhs->classname < rhs->classname;
+        }
+    };
+}
+using TestSet = std::set<TestInstance*, CompareFixtures>;
+namespace {
+    class TestRegistry {
+        TestSet _tests;
+    public:
+
+        static TestRegistry &theInstance() {
+            static TestRegistry testreg;
+            return testreg;
+        }
+
+        void addTest(TestInstance *t) {
+            _tests.insert(t);
+        }
+
+        const TestSet &tests() const {
+            return _tests;
+        }
+    };
+}
+
+TestInstance::TestInstance(const char * _name)
+    : classname(_name)
+{
+    TestRegistry::theInstance().addTest(this);
+}
+
+
+/**
+ * TestFixture
+ **/
+
+std::ostringstream TestFixture::errmsg;
+unsigned int TestFixture::countTests;
+
+std::size_t TestFixture::fails_counter = 0;
+std::size_t TestFixture::todos_counter = 0;
+std::size_t TestFixture::succeeded_todos_counter = 0;
+
+TestFixture::TestFixture(const char * const _name)
+    : classname(_name)
+{}
+
+
+bool TestFixture::prepareTest(const char testname[])
+{
+    mTemplateFormat.clear();
+    mTemplateLocation.clear();
+
+    prepareTestInternal();
+
+    // Check if tests should be executed
+    if (testToRun.empty() || testToRun == testname) {
+        // Tests will be executed - prepare them
+        mTestname = testname;
+        ++countTests;
+        if (quiet_tests) {
+            std::putchar('.'); // Use putchar to write through redirection of std::cout/cerr
+            std::fflush(stdout);
+        } else {
+            std::cout << classname << "::" << mTestname << std::endl;
+        }
+        return !dry_run;
+    }
+    return false;
+}
+
+void TestFixture::teardownTest()
+{
+    teardownTestInternal();
+
+    {
+        const std::string s = errout_str();
+        if (!s.empty())
+            throw std::runtime_error("unconsumed ErrorLogger err: " + s);
+    }
+    {
+        const std::string s = output_str();
+        if (!s.empty())
+            throw std::runtime_error("unconsumed ErrorLogger out: " + s);
+    }
+}
+
+std::string TestFixture::getLocationStr(const char * const filename, const unsigned int linenr) const
+{
+    return std::string(filename) + ':' + std::to_string(linenr) + '(' + classname + "::" + mTestname + ')';
+}
+
+static std::string writestr(const std::string &str, bool gccStyle = false)
+{
+    std::ostringstream ostr;
+    if (gccStyle)
+        ostr << '\"';
+    for (auto i = str.cbegin(); i != str.cend(); ++i) {
+        if (*i == '\n') {
+            ostr << "\\n";
+            if ((i+1) != str.end() && !gccStyle)
+                ostr << std::endl;
+        } else if (*i == '\t')
+            ostr << "\\t";
+        else if (*i == '\"')
+            ostr << "\\\"";
+        else if (std::isprint(static_cast<unsigned char>(*i)))
+            ostr << *i;
+        else
+            ostr << "\\x" << std::hex << short{*i};
+    }
+    if (!str.empty() && !gccStyle)
+        ostr << std::endl;
+    else if (gccStyle)
+        ostr << '\"';
+    return ostr.str();
+}
+
+void TestFixture::assert_(const char * const filename, const unsigned int linenr, const bool condition, const std::string& msg) const
+{
+    if (!condition) {
+        ++fails_counter;
+        errmsg << getLocationStr(filename, linenr) << ": Assertion failed." << std::endl << "_____" << std::endl;
+        if (!msg.empty())
+            errmsg << "Hint:" << std::endl << msg << std::endl;
+        throw AssertFailedError();
+    }
+}
+
+void TestFixture::assertFailure(const char* const filename, const unsigned int linenr, const std::string& expected, const std::string& actual, const std::string& msg) const
+{
+    ++fails_counter;
+    errmsg << getLocationStr(filename, linenr) << ": Assertion failed. " << std::endl
+           << "Expected: " << std::endl
+           << writestr(expected) << std::endl
+           << "Actual: " << std::endl
+           << writestr(actual) << std::endl;
+    if (!msg.empty())
+        errmsg << "Hint:" << std::endl << msg << std::endl;
+    errmsg << "_____" << std::endl;
+    throw AssertFailedError();
+}
+
+void TestFixture::assertEquals(const char * const filename, const unsigned int linenr, const std::string &expected, const std::string &actual, const std::string &msg) const
+{
+    if (expected != actual) {
+        assertFailure(filename, linenr, expected, actual, msg);
+    }
+}
+
+std::string TestFixture::deleteLineNumber(const std::string &message)
+{
+    std::string result(message);
+    // delete line number in "...:NUMBER:..."
+    std::string::size_type pos = 0;
+    while ((pos = result.find(':', pos)) != std::string::npos) {
+        // get number
+        if (pos + 1 == result.find_first_of("0123456789", pos + 1)) {
+            const std::string::size_type after = result.find_first_not_of("0123456789", pos + 1);
+            if (after != std::string::npos
+                && result.at(after) == ':') {
+                // erase NUMBER
+                result.erase(pos + 1, after - pos - 1);
+                pos = after;
+            } else {
+                ++pos;
+            }
+        } else {
+            ++pos;
+        }
+    }
+    return result;
+}
+
+void TestFixture::assertEqualsWithoutLineNumbers(const char * const filename, const unsigned int linenr, const std::string &expected, const std::string &actual, const std::string &msg) const
+{
+    assertEquals(filename, linenr, deleteLineNumber(expected), deleteLineNumber(actual), msg);
+}
+
+void TestFixture::assertEquals(const char * const filename, const unsigned int linenr, const char expected[], const std::string& actual, const std::string &msg) const
+{
+    assertEquals(filename, linenr, std::string(expected), actual, msg);
+}
+
+void TestFixture::assertEquals(const char * const filename, const unsigned int linenr, const char expected[], const char actual[], const std::string &msg) const
+{
+    assertEquals(filename, linenr, std::string(expected), std::string(actual), msg);
+}
+
+void TestFixture::assertEquals(const char * const filename, const unsigned int linenr, const std::string& expected, const char actual[], const std::string &msg) const
+{
+    assertEquals(filename, linenr, expected, std::string(actual), msg);
+}
+
+void TestFixture::assertEquals(const char * const filename, const unsigned int linenr, const long long expected, const long long actual, const std::string &msg) const
+{
+    if (expected != actual) {
+        assertEquals(filename, linenr, std::to_string(expected), std::to_string(actual), msg);
+    }
+}
+
+void TestFixture::assertEqualsDouble(const char * const filename, const unsigned int linenr, const double expected, const double actual, const double tolerance, const std::string &msg) const
+{
+    if (expected < (actual - tolerance) || expected > (actual + tolerance)) {
+        std::ostringstream ostr1;
+        ostr1 << expected;
+        std::ostringstream ostr2;
+        ostr2 << actual;
+        assertEquals(filename, linenr, ostr1.str(), ostr2.str(), msg);
+    }
+}
+
+void TestFixture::todoAssertEquals(const char * const filename, const unsigned int linenr,
+                                   const std::string &wanted,
+                                   const std::string &current,
+                                   const std::string &actual) const
+{
+    if (wanted == actual) {
+        errmsg << getLocationStr(filename, linenr) << ": Assertion succeeded unexpectedly. "
+               << "Result: " << writestr(wanted, true)  << std::endl << "_____" << std::endl;
+
+        ++succeeded_todos_counter;
+    } else {
+        assertEquals(filename, linenr, current, actual);
+        ++todos_counter;
+    }
+}
+
+void TestFixture::todoAssertEquals(const char* const filename, const unsigned int linenr,
+                                   const char wanted[],
+                                   const char current[],
+                                   const std::string& actual) const
+{
+    todoAssertEquals(filename, linenr, std::string(wanted), std::string(current), actual);
+}
+
+
+void TestFixture::todoAssertEquals(const char * const filename, const unsigned int linenr, const long long wanted, const long long current, const long long actual) const
+{
+    todoAssertEquals(filename, linenr, std::to_string(wanted), std::to_string(current), std::to_string(actual));
+}
+
+void TestFixture::assertThrow(const char * const filename, const unsigned int linenr) const
+{
+    ++fails_counter;
+    errmsg << getLocationStr(filename, linenr) << ": Assertion succeeded. "
+           << "The expected exception was thrown" << std::endl << "_____" << std::endl;
+    throw AssertFailedError();
+}
+
+void TestFixture::assertThrowFail(const char * const filename, const unsigned int linenr) const
+{
+    ++fails_counter;
+    errmsg << getLocationStr(filename, linenr) << ": Assertion failed. "
+           << "The expected exception was not thrown"  << std::endl << "_____" << std::endl;
+    throw AssertFailedError();
+}
+
+void TestFixture::assertNoThrowFail(const char * const filename, const unsigned int linenr, bool bailout) const
+{
+    std::string ex_msg;
+
+    try {
+        // cppcheck-suppress rethrowNoCurrentException
+        throw;
+    }
+    catch (const AssertFailedError&) {
+        return;
+    }
+    catch (const InternalError& e) {
+        ex_msg = e.errorMessage;
+    }
+    catch (const std::exception& e) {
+        ex_msg = e.what();
+    }
+    catch (...) {
+        ex_msg = "unknown exception";
+    }
+
+    ++fails_counter;
+    errmsg << getLocationStr(filename, linenr) << ": Assertion failed. "
+           << "Unexpected exception was thrown: " << ex_msg << std::endl << "_____" << std::endl;
+    if (bailout)
+        throw AssertFailedError();
+}
+
+void TestFixture::printHelp()
+{
+    std::cout << "Testrunner - run Cppcheck tests\n"
+        "\n"
+        "Syntax:\n"
+        "    testrunner [OPTIONS] [TestClass::TestCase...]\n"
+        "    run all test cases:\n"
+        "        testrunner\n"
+        "    run all test cases in TestClass:\n"
+        "        testrunner TestClass\n"
+        "    run TestClass::TestCase:\n"
+        "        testrunner TestClass::TestCase\n"
+        "    run all test cases in TestClass1 and TestClass2::TestCase:\n"
+        "        testrunner TestClass1 TestClass2::TestCase\n"
+        "\n"
+        "Options:\n"
+        "    -q                   Do not print the test cases that have run.\n"
+        "    -h, --help           Print this help.\n"
+        "    -n                   Print no summaries.\n"
+        "    -d                   Do not execute any tests (dry run).\n"
+        "    -x                   Exclude the specified tests.\n";
+}
+
+void TestFixture::run(const std::string &str)
+{
+    testToRun = str;
+    try {
+        if (quiet_tests) {
+            std::cout << '\n' << classname << ':';
+            SUPPRESS;
+            run();
+        }
+        else
+            run();
+    }
+    catch (const InternalError& e) {
+        ++fails_counter;
+        errmsg << classname << "::" << mTestname << " - InternalError: " << e.errorMessage << std::endl;
+    }
+    catch (const std::exception& error) {
+        ++fails_counter;
+        errmsg << classname << "::" << mTestname << " - Exception: " << error.what() << std::endl;
+    }
+    catch (...) {
+        ++fails_counter;
+        errmsg << classname << "::" << mTestname << " - Unknown exception" << std::endl;
+    }
+}
+
+void TestFixture::processOptions(const options& args)
+{
+    quiet_tests = args.quiet();
+    dry_run = args.dry_run();
+    exename = args.exe();
+}
+
+std::size_t TestFixture::runTests(const options& args)
+{
+    countTests = 0;
+    errmsg.str("");
+
+    // TODO: bail out when given class/test is not found?
+    for (std::string classname : args.which_test()) {
+        std::string testname;
+        const std::string::size_type pos = classname.find("::");
+        if (pos != std::string::npos) {
+            // TODO: excluding indiviual tests is not supported yet
+            testname = classname.substr(pos + 2);
+            classname.erase(pos);
+        }
+
+        for (TestInstance * test : TestRegistry::theInstance().tests()) {
+            if (!classname.empty()) {
+                const bool match = test->classname == classname;
+                if ((match && args.exclude_tests()) || (!match && !args.exclude_tests()))
+                    continue;
+            }
+
+            TestFixture* fixture = test->create();
+            fixture->processOptions(args);
+            fixture->run(testname);
+        }
+    }
+
+    if (args.summary() && !args.dry_run()) {
+        std::cout << "\n\nTesting Complete\nNumber of tests: " << countTests << std::endl;
+        std::cout << "Number of todos: " << todos_counter;
+        if (succeeded_todos_counter > 0)
+            std::cout << " (" << succeeded_todos_counter << " succeeded)";
+        std::cout << std::endl;
+    }
+    // calling flush here, to do all output before the error messages (in case the output is buffered)
+    std::cout.flush();
+
+    if (args.summary() && !args.dry_run()) {
+        std::cerr << "Tests failed: " << fails_counter << std::endl << std::endl;
+    }
+    std::cerr << errmsg.str();
+
+    std::cerr.flush();
+    return fails_counter + succeeded_todos_counter;
+}
+
+void TestFixture::reportOut(const std::string & outmsg, Color /*c*/)
+{
+    mOutput << outmsg << std::endl;
+}
+
+void TestFixture::reportErr(const ErrorMessage &msg)
+{
+    if (msg.severity == Severity::internal)
+        return;
+    if (msg.severity == Severity::information && msg.id == "normalCheckLevelMaxBranches")
+        return;
+    std::string errormessage;
+    if (!mTemplateFormat.empty()) {
+        errormessage = msg.toString(false, mTemplateFormat, mTemplateLocation);
+    }
+    else {
+        if (!msg.callStack.empty()) {
+            errormessage += ErrorLogger::callStackToString(msg.callStack, mNewTemplate);
+            errormessage += ": ";
+        }
+        if (msg.severity != Severity::none) {
+            errormessage += '(';
+            errormessage += severityToString(msg.severity);
+            if (msg.certainty == Certainty::inconclusive)
+                errormessage += ", inconclusive";
+            errormessage += ") ";
+        }
+        errormessage += msg.shortMessage();
+        if (mNewTemplate) {
+            errormessage += " [";
+            errormessage += msg.id;
+            errormessage += "]";
+        }
+    }
+    mErrout << errormessage << std::endl;
+}
+
+void TestFixture::setTemplateFormat(const std::string &templateFormat)
+{
+    if (templateFormat == "multiline") {
+        mTemplateFormat = "[{file}:{line}:{column}]: {severity}:{inconclusive:inconclusive:} {message} [{id}]";
+        mTemplateLocation = "[{file}:{line}:{column}]: note: {info}";
+    }
+    else if (templateFormat == "simple") { // TODO: use the existing one in CmdLineParser
+        mTemplateFormat = "{file}:{line}:{column}: {severity}:{inconclusive:inconclusive:} {message} [{id}]";
+        mTemplateLocation = "";
+    }
+    else {
+        mTemplateFormat = templateFormat;
+        mTemplateLocation = "";
+    }
+}
+
+TestFixture::SettingsBuilder& TestFixture::SettingsBuilder::checkLevel(Settings::CheckLevel level) {
+    settings.setCheckLevel(level);
+    return *this;
+}
+
+TestFixture::SettingsBuilder& TestFixture::SettingsBuilder::library(const char lib[]) {
+    if (REDUNDANT_CHECK && std::find(settings.libraries.cbegin(), settings.libraries.cend(), lib) != settings.libraries.cend())
+        throw std::runtime_error("redundant setting: libraries (" + std::string(lib) + ")");
+    // TODO: exename is not yet set
+    const Library::ErrorCode lib_error = settings.library.load(fixture.exename.c_str(), lib).errorcode;
+    if (lib_error != Library::ErrorCode::OK)
+        throw std::runtime_error("loading library '" + std::string(lib) + "' failed - " + std::to_string(static_cast<int>(lib_error)));
+    // strip extension
+    std::string lib_s(lib);
+    const std::string ext(".cfg");
+    const auto pos = lib_s.find(ext);
+    if (pos != std::string::npos)
+        lib_s.erase(pos, ext.size());
+    settings.libraries.emplace_back(lib_s);
+    return *this;
+}
+
+TestFixture::SettingsBuilder& TestFixture::SettingsBuilder::platform(Platform::Type type)
+{
+    const std::string platformStr = Platform::toString(type);
+
+    if (REDUNDANT_CHECK && settings.platform.type == type)
+        throw std::runtime_error("redundant setting: platform (" + platformStr + ")");
+
+    std::string errstr;
+    // TODO: exename is not yet set
+    if (!settings.platform.set(platformStr, errstr, {fixture.exename}))
+        throw std::runtime_error("platform '" + platformStr + "' not found");
+    return *this;
+}
+
+TestFixture::SettingsBuilder& TestFixture::SettingsBuilder::libraryxml(const char xmldata[], std::size_t len)
+{
+    tinyxml2::XMLDocument doc;
+    const tinyxml2::XMLError xml_error = doc.Parse(xmldata, len);
+    if (tinyxml2::XML_SUCCESS != xml_error)
+        throw std::runtime_error(std::string("loading library XML data failed - ") + tinyxml2::XMLDocument::ErrorIDToName(xml_error));
+    const Library::ErrorCode lib_error = LibraryHelper::loadxmldoc(settings.library, doc).errorcode;
+    if (lib_error != Library::ErrorCode::OK)
+        throw std::runtime_error("loading library XML failed - " + std::to_string(static_cast<int>(lib_error)));
+    return *this;
+}
diff --git a/test/fixture.h b/test/fixture.h
new file mode 100644
index 00000000000..35fb9ed6277
--- /dev/null
+++ b/test/fixture.h
@@ -0,0 +1,348 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef fixtureH
+#define fixtureH
+
+#include "check.h"
+#include "color.h"
+#include "config.h"
+#include "errorlogger.h"
+#include "errortypes.h"
+#include "platform.h"
+#include "settings.h"
+#include "standards.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <exception>
+#include <list>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+class options;
+class Tokenizer;
+
+class TestFixture : public ErrorLogger {
+private:
+    static std::ostringstream errmsg;
+    static unsigned int countTests;
+    static std::size_t fails_counter;
+    static std::size_t todos_counter;
+    static std::size_t succeeded_todos_counter;
+    std::string mTemplateFormat;
+    std::string mTemplateLocation;
+    std::string mTestname;
+
+protected:
+    std::string exename;
+    std::string testToRun;
+    bool quiet_tests{};
+    bool dry_run{};
+    bool mNewTemplate{};
+
+    virtual void run() = 0;
+
+    bool prepareTest(const char testname[]);
+    virtual void prepareTestInternal() {}
+    void teardownTest();
+    virtual void teardownTestInternal() {}
+    std::string getLocationStr(const char * filename, unsigned int linenr) const;
+
+    class AssertFailedError : public std::exception {};
+
+    void assert_(const char * filename, unsigned int linenr, bool condition, const std::string& msg = "") const;
+
+    template<typename T>
+    void assertEquals(const char* const filename, const unsigned int linenr, const T& expected, const T& actual, const std::string& msg = "") const {
+        if (expected != actual) {
+            std::ostringstream expectedStr;
+            // NOLINTNEXTLINE(bugprone-unintended-char-ostream-output) - chars being treated as integers is acceptable here
+            expectedStr << expected;
+            std::ostringstream actualStr;
+            // NOLINTNEXTLINE(bugprone-unintended-char-ostream-output) - chars being treated as integers is acceptable here
+            actualStr << actual;
+
+            assertFailure(filename, linenr, expectedStr.str(), actualStr.str(), msg);
+        }
+    }
+
+    template<typename T>
+    void assertEqualsEnum(const char* const filename, const unsigned int linenr, const T& expected, const T& actual, const std::string& msg = "") const {
+        if (std::is_unsigned<T>())
+            assertEquals(filename, linenr, static_cast<std::uint64_t>(expected), static_cast<std::uint64_t>(actual), msg);
+        else
+            assertEquals(filename, linenr, static_cast<std::int64_t>(expected), static_cast<std::int64_t>(actual), msg);
+    }
+
+    template<typename T>
+    void todoAssertEqualsEnum(const char* const filename, const unsigned int linenr, const T& wanted, const T& current, const T& actual) const {
+        if (std::is_unsigned<T>())
+            todoAssertEquals(filename, linenr, static_cast<std::uint64_t>(wanted), static_cast<std::uint64_t>(current), static_cast<std::uint64_t>(actual));
+        else
+            todoAssertEquals(filename, linenr, static_cast<std::int64_t>(wanted), static_cast<std::int64_t>(current), static_cast<std::int64_t>(actual));
+    }
+
+    void assertEquals(const char * filename, unsigned int linenr, const std::string &expected, const std::string &actual, const std::string &msg = "") const;
+    void assertEqualsWithoutLineNumbers(const char * filename, unsigned int linenr, const std::string &expected, const std::string &actual, const std::string &msg = "") const;
+    void assertEquals(const char * filename, unsigned int linenr, const char expected[], const std::string& actual, const std::string &msg = "") const;
+    void assertEquals(const char * filename, unsigned int linenr, const char expected[], const char actual[], const std::string &msg = "") const;
+    void assertEquals(const char * filename, unsigned int linenr, const std::string& expected, const char actual[], const std::string &msg = "") const;
+    void assertEquals(const char * filename, unsigned int linenr, long long expected, long long actual, const std::string &msg = "") const;
+    void assertEqualsDouble(const char * filename, unsigned int linenr, double expected, double actual, double tolerance, const std::string &msg = "") const;
+
+    void todoAssertEquals(const char * filename, unsigned int linenr, const std::string &wanted,
+                          const std::string &current, const std::string &actual) const;
+    void todoAssertEquals(const char * filename, unsigned int linenr, const char wanted[],
+                          const char current[], const std::string &actual) const;
+    void todoAssertEquals(const char * filename, unsigned int linenr, long long wanted,
+                          long long current, long long actual) const;
+    NORETURN void assertThrow(const char * filename, unsigned int linenr) const;
+    NORETURN void assertThrowFail(const char * filename, unsigned int linenr) const;
+    void assertNoThrowFail(const char * filename, unsigned int linenr, bool bailout) const;
+    static std::string deleteLineNumber(const std::string &message);
+
+    void setTemplateFormat(const std::string &templateFormat);
+
+    void setMultiline() {
+        setTemplateFormat("multiline");
+    }
+
+    void processOptions(const options& args);
+
+    template<typename T>
+    static T& getCheck()
+    {
+        for (Check *check : Check::instances()) {
+            //cppcheck-suppress useStlAlgorithm
+            if (T* c = dynamic_cast<T*>(check))
+                return *c;
+        }
+        throw std::runtime_error("instance not found");
+    }
+
+    template<typename T>
+    static void runChecks(const Tokenizer &tokenizer, ErrorLogger *errorLogger)
+    {
+        Check& check = getCheck<T>();
+        check.runChecks(tokenizer, errorLogger);
+    }
+
+    class SettingsBuilder
+    {
+    public:
+        explicit SettingsBuilder(const TestFixture &fixture) : fixture(fixture) {}
+        SettingsBuilder(const TestFixture &fixture, Settings settings) : fixture(fixture), settings(std::move(settings)) {}
+
+        SettingsBuilder& severity(Severity sev, bool b = true) {
+            if (REDUNDANT_CHECK && settings.severity.isEnabled(sev) == b)
+                throw std::runtime_error("redundant setting: severity - " + severityToString(sev));
+            settings.severity.setEnabled(sev, b);
+            return *this;
+        }
+
+        SettingsBuilder& certainty(Certainty cert, bool b = true) {
+            if (REDUNDANT_CHECK && settings.certainty.isEnabled(cert) == b)
+                throw std::runtime_error("redundant setting: certainty");
+            settings.certainty.setEnabled(cert, b);
+            return *this;
+        }
+
+        SettingsBuilder& clang() {
+            if (REDUNDANT_CHECK && settings.clang)
+                throw std::runtime_error("redundant setting: clang");
+            settings.clang = true;
+            return *this;
+        }
+
+        SettingsBuilder& checkLibrary() {
+            if (REDUNDANT_CHECK && settings.checkLibrary)
+                throw std::runtime_error("redundant setting: checkLibrary");
+            settings.checkLibrary = true;
+            return *this;
+        }
+
+        SettingsBuilder& checkUnusedTemplates(bool b = true) {
+            if (REDUNDANT_CHECK && settings.checkUnusedTemplates == b)
+                throw std::runtime_error("redundant setting: checkUnusedTemplates");
+            settings.checkUnusedTemplates = b;
+            return *this;
+        }
+
+        SettingsBuilder& debugwarnings(bool b = true) {
+            if (REDUNDANT_CHECK && settings.debugwarnings == b)
+                throw std::runtime_error("redundant setting: debugwarnings");
+            settings.debugwarnings = b;
+            return *this;
+        }
+
+        SettingsBuilder& c(Standards::cstd_t std) {
+            // TODO: CLatest and C23 are the same - handle differently?
+            //if (REDUNDANT_CHECK && settings.standards.c == std)
+            //    throw std::runtime_error("redundant setting: standards.c");
+            settings.standards.c = std;
+            return *this;
+        }
+
+        SettingsBuilder& cpp(Standards::cppstd_t std) {
+            // TODO: CPPLatest and CPP26 are the same - handle differently?
+            //if (REDUNDANT_CHECK && settings.standards.cpp == std)
+            //    throw std::runtime_error("redundant setting: standards.cpp");
+            settings.standards.cpp = std;
+            return *this;
+        }
+
+        SettingsBuilder& checkLevel(Settings::CheckLevel level);
+
+        SettingsBuilder& library(const char lib[]);
+
+        template<size_t size>
+        SettingsBuilder& libraryxml(const char (&xmldata)[size]) {
+            return libraryxml(xmldata, size-1);
+        }
+
+        SettingsBuilder& platform(Platform::Type type);
+
+        SettingsBuilder& checkConfiguration() {
+            if (REDUNDANT_CHECK && settings.checkConfiguration)
+                throw std::runtime_error("redundant setting: checkConfiguration");
+            settings.checkConfiguration = true;
+            return *this;
+        }
+
+        SettingsBuilder& checkHeaders(bool b = true) {
+            if (REDUNDANT_CHECK && settings.checkHeaders == b)
+                throw std::runtime_error("redundant setting: checkHeaders");
+            settings.checkHeaders = b;
+            return *this;
+        }
+
+        Settings build() {
+            return std::move(settings);
+        }
+    private:
+        SettingsBuilder& libraryxml(const char xmldata[], std::size_t len);
+
+        const TestFixture &fixture;
+        Settings settings;
+
+        static constexpr bool REDUNDANT_CHECK = false;
+    };
+
+    SettingsBuilder settingsBuilder() const {
+        return SettingsBuilder(*this);
+    }
+
+    SettingsBuilder settingsBuilder(Settings settings) const {
+        return SettingsBuilder(*this, std::move(settings));
+    }
+
+    std::string output_str() {
+        std::string s = mOutput.str();
+        mOutput.str("");
+        return s;
+    }
+
+    std::string errout_str() {
+        std::string s = mErrout.str();
+        mErrout.str("");
+        return s;
+    }
+
+    void ignore_errout() {
+        if (errout_str().empty())
+            throw std::runtime_error("no errout to ignore");
+    }
+
+    const Settings settingsDefault;
+
+private:
+    //Helper function to be called when an assertEquals assertion fails.
+    //Writes the appropriate failure message to errmsg and increments fails_counter
+    NORETURN void assertFailure(const char* filename, unsigned int linenr, const std::string& expected, const std::string& actual, const std::string& msg) const;
+
+    std::ostringstream mOutput;
+    std::ostringstream mErrout;
+
+    void reportOut(const std::string &outmsg, Color c = Color::Reset) override;
+    void reportErr(const ErrorMessage &msg) override;
+    void reportMetric(const std::string &metric) override
+    {
+        (void) metric;
+    }
+    void run(const std::string &str);
+
+public:
+    static void printHelp();
+    const std::string classname;
+
+    explicit TestFixture(const char * _name);
+
+    static std::size_t runTests(const options& args);
+};
+
+class TestInstance {
+public:
+    explicit TestInstance(const char * _name);
+    virtual ~TestInstance() = default;
+
+    virtual TestFixture* create() = 0;
+
+    const std::string classname;
+protected:
+    std::unique_ptr<TestFixture> impl;
+};
+
+#define TEST_CASE( NAME ) do { if (prepareTest(#NAME)) { try { NAME(); teardownTest(); } catch (const AssertFailedError&) {} catch (...) { assertNoThrowFail(__FILE__, __LINE__, false); } } } while (false)
+
+#define ASSERT( CONDITION ) assert_(__FILE__, __LINE__, (CONDITION))
+#define ASSERT_MSG( CONDITION, MSG ) assert_(__FILE__, __LINE__, (CONDITION), MSG)
+#define ASSERT_LOC( CONDITION, FILE_, LINE_ ) assert_(FILE_, LINE_, (CONDITION))
+#define ASSERT_LOC_MSG( CONDITION, MSG, FILE_, LINE_ ) assert_(FILE_, LINE_, (CONDITION), MSG)
+// *INDENT-OFF*
+#define ASSERT_EQUALS( EXPECTED, ACTUAL ) do { try { assertEquals(__FILE__, __LINE__, (EXPECTED), (ACTUAL)); } catch(const AssertFailedError&) { throw; } catch (...) { assertNoThrowFail(__FILE__, __LINE__, true); } } while (false)
+// *INDENT-ON*
+#define ASSERT_EQUALS_WITHOUT_LINENUMBERS( EXPECTED, ACTUAL ) assertEqualsWithoutLineNumbers(__FILE__, __LINE__, EXPECTED, ACTUAL)
+#define ASSERT_EQUALS_DOUBLE( EXPECTED, ACTUAL, TOLERANCE ) assertEqualsDouble(__FILE__, __LINE__, EXPECTED, ACTUAL, TOLERANCE)
+#define ASSERT_EQUALS_LOC( EXPECTED, ACTUAL, FILE_, LINE_ ) assertEquals(FILE_, LINE_, EXPECTED, ACTUAL)
+#define ASSERT_EQUALS_LOC_MSG( EXPECTED, ACTUAL, MSG, FILE_, LINE_ ) assertEquals(FILE_, LINE_, EXPECTED, ACTUAL, MSG)
+#define ASSERT_EQUALS_MSG( EXPECTED, ACTUAL, MSG ) assertEquals(__FILE__, __LINE__, EXPECTED, ACTUAL, MSG)
+#define ASSERT_EQUALS_ENUM( EXPECTED, ACTUAL ) assertEqualsEnum(__FILE__, __LINE__, (EXPECTED), (ACTUAL))
+#define ASSERT_EQUALS_ENUM_LOC( EXPECTED, ACTUAL, FILE_, LINE_ ) assertEqualsEnum(FILE_, LINE_, (EXPECTED), (ACTUAL))
+#define ASSERT_EQUALS_ENUM_LOC_MSG( EXPECTED, ACTUAL, MSG, FILE_, LINE_ ) assertEqualsEnum(FILE_, LINE_, (EXPECTED), (ACTUAL), MSG)
+#define TODO_ASSERT_EQUALS_ENUM( WANTED, CURRENT, ACTUAL ) todoAssertEqualsEnum(__FILE__, __LINE__, WANTED, CURRENT, ACTUAL)
+#define ASSERT_THROW_EQUALS( CMD, EXCEPTION, EXPECTED ) do { try { (void)(CMD); assertThrowFail(__FILE__, __LINE__); } catch (const AssertFailedError&) { throw; } catch (const EXCEPTION&e) { assertEquals(__FILE__, __LINE__, EXPECTED, e.what()); } catch (...) { assertThrowFail(__FILE__, __LINE__); } } while (false)
+#define ASSERT_THROW_INTERNAL( CMD, TYPE ) do { try { (void)(CMD); assertThrowFail(__FILE__, __LINE__); } catch (const AssertFailedError&) { throw; } catch (const InternalError& e) { assertEqualsEnum(__FILE__, __LINE__, InternalError::TYPE, e.type); } catch (...) { assertThrowFail(__FILE__, __LINE__); } } while (false)
+#define ASSERT_THROW_INTERNAL_EQUALS( CMD, TYPE, EXPECTED ) do { try { (void)(CMD); assertThrowFail(__FILE__, __LINE__); } catch (const AssertFailedError&) { throw; } catch (const InternalError& e) { assertEqualsEnum(__FILE__, __LINE__, InternalError::TYPE, e.type); assertEquals(__FILE__, __LINE__, EXPECTED, e.errorMessage); } catch (...) { assertThrowFail(__FILE__, __LINE__); } } while (false)
+#define ASSERT_NO_THROW( CMD ) do { try { (void)(CMD); } catch (const AssertFailedError&) { throw; } catch (...) { assertNoThrowFail(__FILE__, __LINE__, true); } } while (false)
+#define TODO_ASSERT_THROW( CMD, EXCEPTION ) do { try { (void)(CMD); } catch (const AssertFailedError&) { throw; } catch (const EXCEPTION&) {} catch (...) { assertThrow(__FILE__, __LINE__); } } while (false)
+#define TODO_ASSERT( CONDITION ) do { const bool condition=(CONDITION); todoAssertEquals(__FILE__, __LINE__, true, false, condition); } while (false)
+#define TODO_ASSERT_EQUALS( WANTED, CURRENT, ACTUAL ) todoAssertEquals(__FILE__, __LINE__, WANTED, CURRENT, ACTUAL)
+
+// *INDENT-OFF*
+#define REGISTER_TEST( CLASSNAME ) namespace { class CLASSNAME ## Instance : public TestInstance { public: CLASSNAME ## Instance() : TestInstance(#CLASSNAME) {} TestFixture* create() override { impl.reset(new CLASSNAME); return impl.get(); } }; CLASSNAME ## Instance instance_ ## CLASSNAME; }
+// *INDENT-ON*
+
+#define PLATFORM( P, T ) do { std::string errstr; assertEquals(__FILE__, __LINE__, true, P.set(Platform::toString(T), errstr, {exename}), errstr); } while (false)
+
+#endif // fixtureH
diff --git a/test/helpers.cpp b/test/helpers.cpp
new file mode 100644
index 00000000000..252658cc531
--- /dev/null
+++ b/test/helpers.cpp
@@ -0,0 +1,149 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "helpers.h"
+
+#include "filelister.h"
+#include "filesettings.h"
+#include "library.h"
+#include "path.h"
+#include "pathmatch.h"
+#include "preprocessor.h"
+
+#include <cerrno>
+#include <cstdio>
+#include <iostream>
+#include <fstream>
+#include <list>
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <sys/stat.h>
+#include <unistd.h>
+#endif
+
+#include <simplecpp.h>
+
+#include "xml.h"
+
+const Settings SimpleTokenizer::s_settings;
+
+// TODO: better path-only usage
+ScopedFile::ScopedFile(std::string name, const std::string &content, std::string path)
+    : mName(std::move(name))
+    , mPath(Path::toNativeSeparators(std::move(path)))
+    , mFullPath(Path::join(mPath, mName))
+{
+    if (!mPath.empty() && mPath != Path::getCurrentPath()) {
+        if (Path::isDirectory(mPath))
+            throw std::runtime_error("ScopedFile(" + mFullPath + ") - directory already exists");
+#ifdef _WIN32
+        if (!CreateDirectoryA(mPath.c_str(), nullptr))
+            throw std::runtime_error("ScopedFile(" + mFullPath + ") - could not create directory");
+#else
+        if (mkdir(mPath.c_str(), S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) != 0)
+            throw std::runtime_error("ScopedFile(" + mFullPath + ") - could not create directory");
+#endif
+    }
+
+    if (Path::isFile(mFullPath))
+        throw std::runtime_error("ScopedFile(" + mFullPath + ") - file already exists");
+
+    std::ofstream of(mFullPath);
+    if (!of.is_open())
+        throw std::runtime_error("ScopedFile(" + mFullPath + ") - could not open file");
+    of << content;
+}
+
+ScopedFile::~ScopedFile() {
+    const int remove_res = std::remove(mFullPath.c_str());
+    if (remove_res != 0) {
+        std::cout << "ScopedFile(" << mFullPath + ") - could not delete file (" << remove_res << ")" << std::endl;
+    }
+    if (!mPath.empty() && mPath != Path::getCurrentPath()) {
+        // TODO: remove all files
+        // TODO: simplify the function call
+        // hack to be able to delete *.plist output files
+        std::list<FileWithDetails> files;
+        const std::string res = FileLister::addFiles(files, mPath, {".plist"}, false, PathMatch());
+        if (!res.empty()) {
+            std::cout << "ScopedFile(" << mPath + ") - generating file list failed (" << res << ")" << std::endl;
+        }
+        for (const auto &f : files)
+        {
+            const std::string &file = f.path();
+            const int rm_f_res = std::remove(file.c_str());
+            if (rm_f_res != 0) {
+                std::cout << "ScopedFile(" << mPath + ") - could not delete '" << file << "' (" << rm_f_res << ")" << std::endl;
+            }
+        }
+
+#ifdef _WIN32
+        if (!RemoveDirectoryA(mPath.c_str())) {
+            std::cout << "ScopedFile(" << mFullPath + ") - could not delete folder (" << GetLastError() << ")" << std::endl;
+        }
+#else
+        const int rmdir_res = rmdir(mPath.c_str());
+        if (rmdir_res == -1) {
+            const int err = errno;
+            std::cout << "ScopedFile(" << mFullPath + ") - could not delete folder (" << err << ")" << std::endl;
+        }
+#endif
+    }
+}
+
+void SimpleTokenizer2::preprocess(const char* code, std::size_t size, std::vector<std::string> &files, const std::string& file0, Tokenizer& tokenizer, ErrorLogger& errorlogger)
+{
+    simplecpp::OutputList outputList;
+    simplecpp::TokenList tokens1({code, size}, files, file0, &outputList);
+
+    Preprocessor preprocessor(tokens1, tokenizer.getSettings(), errorlogger, Path::identify(tokens1.getFiles()[0], false));
+    (void)preprocessor.loadFiles(files); // TODO: check result
+    simplecpp::TokenList tokens2 = preprocessor.preprocess("", files, outputList);
+    (void)preprocessor.reportOutput(outputList, true);
+
+    // Tokenizer..
+    tokenizer.list.createTokens(std::move(tokens2));
+
+    std::list<Directive> directives = preprocessor.createDirectives();
+    tokenizer.setDirectives(std::move(directives));
+}
+
+bool LibraryHelper::loadxmldata(Library &lib, const char xmldata[], std::size_t len)
+{
+    tinyxml2::XMLDocument doc;
+    return (tinyxml2::XML_SUCCESS == doc.Parse(xmldata, len)) && (lib.load(doc).errorcode == Library::ErrorCode::OK);
+}
+
+bool LibraryHelper::loadxmldata(Library &lib, Library::Error& liberr, const char xmldata[], std::size_t len)
+{
+    tinyxml2::XMLDocument doc;
+    if (tinyxml2::XML_SUCCESS != doc.Parse(xmldata, len))
+        return false;
+    liberr = lib.load(doc);
+    return true;
+}
+
+Library::Error LibraryHelper::loadxmldoc(Library &lib, const tinyxml2::XMLDocument& doc)
+{
+    return lib.load(doc);
+}
diff --git a/test/helpers.h b/test/helpers.h
new file mode 100644
index 00000000000..5a0bd106812
--- /dev/null
+++ b/test/helpers.h
@@ -0,0 +1,261 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef helpersH
+#define helpersH
+
+#include "library.h"
+#include "path.h"
+#include "settings.h"
+#include "standards.h"
+#include "tokenize.h"
+#include "tokenlist.h"
+
+#include <cstddef>
+#include <stdexcept>
+#include <sstream>
+#include <string>
+#include <vector>
+
+class Token;
+class ErrorLogger;
+namespace tinyxml2 {
+    class XMLDocument;
+}
+
+// TODO: make Tokenizer private
+class SimpleTokenizer : public Tokenizer {
+public:
+    explicit SimpleTokenizer(ErrorLogger& errorlogger, bool cpp = true)
+        : Tokenizer{TokenList{s_settings, cpp ? Standards::Language::CPP : Standards::Language::C}, errorlogger}
+    {}
+
+    SimpleTokenizer(const Settings& settings, ErrorLogger& errorlogger, bool cpp = true)
+        : Tokenizer{TokenList{settings, cpp ? Standards::Language::CPP : Standards::Language::C}, errorlogger}
+    {}
+
+    SimpleTokenizer(const Settings& settings, ErrorLogger& errorlogger, const std::string& filename)
+        : Tokenizer{TokenList{settings, Path::identify(filename, false)}, errorlogger}
+    {
+        list.appendFileIfNew(filename);
+    }
+
+    template<size_t size>
+    bool tokenize(const char (&code)[size])
+    {
+        return tokenize(code, size-1);
+    }
+
+    bool tokenize(const std::string& code)
+    {
+        return tokenize(code.data(), code.size());
+    }
+
+    bool tokenize(const char* code, std::size_t size)
+    {
+        return tokenize(code, size, std::string(list.isCPP() ? "test.cpp" : "test.c"));
+    }
+
+private:
+    /**
+     * Tokenize code
+     * @param code The code
+     * @param filename Indicates if the code is C++
+     * @return false if source code contains syntax errors
+     */
+    template<size_t size>
+    bool tokenize(const char (&code)[size],
+                  const std::string& filename)
+    {
+        return tokenize(code, size-1, filename);
+    }
+
+    bool tokenize(const char* code,
+                  std::size_t size,
+                  const std::string& filename)
+    {
+        if (list.front())
+            throw std::runtime_error("token list is not empty");
+        list.appendFileIfNew(filename);
+        if (!list.createTokensFromBuffer(code, size))
+            return false;
+
+        return simplifyTokens1("");
+    }
+
+    // TODO: find a better solution
+    static const Settings s_settings;
+};
+
+class SimpleTokenList
+{
+public:
+    template<size_t size>
+    explicit SimpleTokenList(const char (&code)[size], Standards::Language lang = Standards::Language::CPP)
+        : list{settings, lang}
+    {
+        if (!list.createTokensFromString(code))
+            throw std::runtime_error("creating tokens failed");
+    }
+
+    template<size_t size>
+    explicit SimpleTokenList(const char (&code)[size], const std::string& file0, Standards::Language lang = Standards::Language::CPP)
+        : list{settings, lang}
+    {
+        list.appendFileIfNew(file0);
+        if (!list.createTokensFromString(code))
+            throw std::runtime_error("creating tokens failed");
+    }
+
+    Token* front() {
+        return list.front();
+    }
+
+    const Token* front() const {
+        return list.front();
+    }
+
+    const TokenList& get() const {
+        return list;
+    }
+
+private:
+    const Settings settings;
+    TokenList list;
+};
+
+
+class ScopedFile {
+public:
+    ScopedFile(std::string name, const std::string &content, std::string path = "");
+    ~ScopedFile();
+
+    const std::string& path() const
+    {
+        return mFullPath;
+    }
+
+    const std::string& name() const {
+        return mName;
+    }
+
+    ScopedFile(const ScopedFile&) = delete;
+    ScopedFile(ScopedFile&&) = delete;
+    ScopedFile& operator=(const ScopedFile&) = delete;
+    ScopedFile& operator=(ScopedFile&&) = delete;
+
+private:
+    const std::string mName;
+    const std::string mPath;
+    const std::string mFullPath;
+};
+
+namespace cppcheck {
+    template<typename T>
+    std::size_t count_all_of(const std::string& str, T sub) {
+        std::size_t n = 0;
+        std::string::size_type pos = 0;
+        while ((pos = str.find(sub, pos)) != std::string::npos) {
+            ++pos;
+            ++n;
+        }
+        return n;
+    }
+}
+
+/* designated initialization helper
+    Usage:
+    struct S
+    {
+        int i;
+    };
+
+    const auto s = dinit(S,
+        $.i = 1
+    );
+ */
+#define dinit(T, ...) \
+    ([&] { T ${}; __VA_ARGS__; return $; }())
+
+// Default construct object to avoid bug in clang
+// error: default member initializer for 'y' needed within definition of enclosing class 'X' outside of member functions
+// see https://stackoverflow.com/questions/53408962
+struct make_default_obj
+{
+    template<class T>
+    operator T() const // NOLINT
+    {
+        return T{};
+    }
+};
+
+inline std::string filter_valueflow(const std::string& s) {
+    bool filtered = false;
+    std::istringstream istr(s);
+    std::string ostr;
+    std::string errline;
+    while (std::getline(istr, errline)) {
+        if (errline.find("valueflow.cpp") != std::string::npos)
+        {
+            filtered = true;
+            continue;
+        }
+        ostr += errline;
+        ostr += '\n'; // TODO: last line might not contain a newline
+    }
+    if (!filtered)
+        throw std::runtime_error("no valueflow.cpp messages were filtered");
+    return ostr;
+}
+
+struct LibraryHelper
+{
+    static bool loadxmldata(Library &lib, const char xmldata[], std::size_t len);
+    static bool loadxmldata(Library &lib, Library::Error& liberr, const char xmldata[], std::size_t len);
+    static Library::Error loadxmldoc(Library &lib, const tinyxml2::XMLDocument& doc);
+};
+
+class SimpleTokenizer2 : public Tokenizer {
+    friend class TestSimplifyTypedef; // TODO: get rid of this
+public:
+    template<size_t size>
+    SimpleTokenizer2(const Settings &settings, ErrorLogger &errorlogger, const char (&code)[size], const std::string& file0)
+        : Tokenizer{TokenList{settings, Path::identify(file0, false)}, errorlogger}
+    {
+        preprocess(code, size-1, mFiles, file0, *this, errorlogger);
+    }
+
+private:
+    static void preprocess(const char* code, std::size_t size, std::vector<std::string> &files, const std::string& file0, Tokenizer& tokenizer, ErrorLogger& errorlogger);
+
+    std::vector<std::string> mFiles;
+};
+
+struct TokenListHelper
+{
+    template<size_t size>
+    static bool createTokensFromString(TokenList& tokenlist, const char (&code)[size], const std::string& file)
+    {
+        if (tokenlist.front())
+            throw std::runtime_error("token list is not empty");
+        tokenlist.appendFileIfNew(file);
+        return tokenlist.createTokensFromString(code);
+    }
+};
+
+#endif // helpersH
diff --git a/test/testrunner.cpp b/test/main.cpp
similarity index 50%
rename from test/testrunner.cpp
rename to test/main.cpp
index 3766f8293bf..571f7742f76 100644
--- a/test/testrunner.cpp
+++ b/test/main.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,41 +16,24 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "color.h"
 #include "options.h"
 #include "preprocessor.h"
-#include "testsuite.h"
+#include "fixture.h"
 
 #include <cstdlib>
-#include <iostream>
 
 int main(int argc, char *argv[])
 {
-    // MS Visual C++ memory leak debug tracing
-#if defined(_MSC_VER) && defined(_DEBUG)
-    _CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | _CRTDBG_LEAK_CHECK_DF);
-#endif
+    Preprocessor::macroChar = '$';     // While macroChar is char(1) per default outside test suite, we require it to be a human-readable character here.
+    gDisableColors = true;
 
-#ifdef NDEBUG
-    try {
-#endif
-        Preprocessor::macroChar = '$'; // While macroChar is char(1) per default outside test suite, we require it to be a human-readable character here.
+    options args(argc, argv);
 
-        options args(argc, argv);
-
-        if (args.help()) {
-            TestFixture::printHelp();
-            return EXIT_SUCCESS;
-        }
-        const std::size_t failedTestsCount = TestFixture::runTests(args);
-        return (failedTestsCount == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
-#ifdef NDEBUG
-    } catch (const InternalError& e) {
-        std::cout << e.errorMessage << std::endl;
-    } catch (const std::exception& error) {
-        std::cout << error.what() << std::endl;
-    } catch (...) {
-        std::cout << "Unknown exception" << std::endl;
+    if (args.help()) {
+        TestFixture::printHelp();
+        return EXIT_SUCCESS;
     }
-    return EXIT_FAILURE;
-#endif
+    const std::size_t failedTestsCount = TestFixture::runTests(args);
+    return (failedTestsCount == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
 }
diff --git a/test/options.cpp b/test/options.cpp
index 74fb30b8bed..17e44eeb6bf 100644
--- a/test/options.cpp
+++ b/test/options.cpp
@@ -1,5 +1,5 @@
 // Cppcheck - A tool for static C/C++ code analysis
-// Copyright (C) 2007-2019 Cppcheck team.
+// Copyright (C) 2007-2025 Cppcheck team.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -16,15 +16,17 @@
 
 #include "options.h"
 
-#include <iterator>
-
 options::options(int argc, const char* const argv[])
-    :mWhichTests(argv + 1, argv + argc)
+    : mWhichTests(argv + 1, argv + argc)
     ,mQuiet(mWhichTests.count("-q") != 0)
     ,mHelp(mWhichTests.count("-h") != 0 || mWhichTests.count("--help"))
+    ,mSummary(mWhichTests.count("-n") == 0)
+    ,mDryRun(mWhichTests.count("-d") != 0)
+    ,mExcludeTests(mWhichTests.count("-x") != 0)
+    ,mExe(argv[0])
 {
-    for (std::set<std::string>::const_iterator it = mWhichTests.begin(); it != mWhichTests.end();) {
-        if (!(*it).empty() && (((*it)[0] == '-') || ((*it).find("::") != std::string::npos && mWhichTests.count((*it).substr(0, (*it).find("::"))))))
+    for (auto it = mWhichTests.cbegin(); it != mWhichTests.cend();) {
+        if (!it->empty() && (((*it)[0] == '-') || (it->find("::") != std::string::npos && mWhichTests.count(it->substr(0, it->find("::"))))))
             it = mWhichTests.erase(it);
         else
             ++it;
@@ -45,7 +47,27 @@ bool options::help() const
     return mHelp;
 }
 
+bool options::summary() const
+{
+    return mSummary;
+}
+
+bool options::dry_run() const
+{
+    return mDryRun;
+}
+
 const std::set<std::string>& options::which_test() const
 {
     return mWhichTests;
 }
+
+const std::string& options::exe() const
+{
+    return mExe;
+}
+
+bool options::exclude_tests() const
+{
+    return mExcludeTests;
+}
diff --git a/test/options.h b/test/options.h
index 28466fe7530..5be6ca34e61 100644
--- a/test/options.h
+++ b/test/options.h
@@ -1,5 +1,5 @@
 // Cppcheck - A tool for static C/C++ code analysis
-// Copyright (C) 2007-2019 Cppcheck team.
+// Copyright (C) 2007-2024 Cppcheck team.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -33,18 +33,29 @@ class options {
     bool quiet() const;
     /** Print help. */
     bool help() const;
+    /** Print summary. */
+    bool summary() const;
+    /** Perform dry run. */
+    bool dry_run() const;
+    /** Exclude provided lists of tests. */
+    bool exclude_tests() const;
     /** Which test should be run. Empty string means 'all tests' */
     const std::set<std::string>& which_test() const;
 
-private:
-    options();
-    options(const options& non_copy);
-    const options& operator =(const options& non_assign);
+    const std::string& exe() const;
+
+    options() = delete;
+    options(const options&) = delete;
+    options& operator =(const options&) = delete;
 
 private:
     std::set<std::string> mWhichTests;
     const bool mQuiet;
     const bool mHelp;
+    const bool mSummary;
+    const bool mDryRun;
+    const bool mExcludeTests;
+    std::string mExe;
 };
 
 #endif
diff --git a/test/precompiled.h b/test/precompiled.h
new file mode 100644
index 00000000000..bb6ba567123
--- /dev/null
+++ b/test/precompiled.h
@@ -0,0 +1,32 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+// IWYU pragma: begin_keep
+#include "check.h"
+#include "config.h"
+#include "importproject.h"
+#include "library.h"
+#include "mathlib.h"
+#include "settings.h"
+#include "timer.h"
+#include "token.h"
+#include "tokenlist.h"
+#include "tokenize.h"
+// IWYU pragma: end_keep
diff --git a/test/redirect.h b/test/redirect.h
index 196c157d139..9177beb6819 100644
--- a/test/redirect.h
+++ b/test/redirect.h
@@ -1,5 +1,5 @@
 // Cppcheck - A tool for static C/C++ code analysis
-// Copyright (C) 2007-2017 Cppcheck team.
+// Copyright (C) 2007-2025 Cppcheck team.
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -19,15 +19,15 @@
 
 #include <iostream>
 #include <sstream>
+#include <stdexcept>
 #include <string>
 
-extern std::ostringstream errout;
-extern std::ostringstream output;
 /**
-  * @brief Utility class for capturing cout and cerr to ostringstream buffers
-  * for later use. Uses RAII to stop redirection when the object goes out of
-  * scope.
-  */
+ * @brief Utility class for capturing cout and cerr to ostringstream buffers
+ * for later use. Uses RAII to stop redirection when the object goes out of
+ * scope.
+ * NOTE: This is *not* thread-safe.
+ */
 class RedirectOutputError {
 public:
     /** Set up redirection, flushing anything in the pipes. */
@@ -43,35 +43,37 @@ class RedirectOutputError {
         std::cerr.rdbuf(_err.rdbuf()); // assign streambuf to cerr
     }
 
+    // TODO: if an assert failed previously this will mask that failure
     /** Revert cout and cerr behaviour */
-    ~RedirectOutputError() {
+    ~RedirectOutputError() noexcept(false) {
         std::cout.rdbuf(_oldCout); // restore cout's original streambuf
         std::cerr.rdbuf(_oldCerr); // restore cerrs's original streambuf
 
-        errout << _err.str();
-        output << _out.str();
-    }
+        {
+            const std::string s = _out.str();
+            if (!s.empty())
+                throw std::runtime_error("unconsumed stdout: " + s);
+        }
 
-    /** Return what would be printed to cout. See also clearOutput() */
-    std::string getOutput() const {
-        return _out.str();
+        {
+            const std::string s = _err.str();
+            if (!s.empty())
+                throw std::runtime_error("consumed stderr: " + s);
+        }
     }
 
-    /** Normally called after getOutput() to prevent same text to be returned
-    twice. */
-    void clearOutput() {
+    /** Return what would be printed to cout. */
+    std::string getOutput() {
+        std::string s = _out.str();
         _out.str("");
+        return s;
     }
 
-    /** Return what would be printed to cerr. See also clearErrout() */
-    std::string getErrout() const {
-        return _err.str();
-    }
-
-    /** Normally called after getErrout() to prevent same text to be returned
-    twice. */
-    void clearErrout() {
+    /** Return what would be printed to cerr. */
+    std::string getErrout() {
+        std::string s = _err.str();
         _err.str("");
+        return s;
     }
 
 private:
@@ -81,10 +83,51 @@ class RedirectOutputError {
     std::streambuf *_oldCerr;
 };
 
-#define REDIRECT RedirectOutputError redir;
+class SuppressOutput {
+public:
+    /** Set up suppression, flushing anything in the pipes. */
+    SuppressOutput() {
+        // flush all old output
+        std::cout.flush();
+        std::cerr.flush();
+
+        _oldCout = std::cout.rdbuf(); // back up cout's streambuf
+        _oldCerr = std::cerr.rdbuf(); // back up cerr's streambuf
+
+        std::cout.rdbuf(nullptr); // disable cout
+        std::cerr.rdbuf(nullptr); // disable cerr
+    }
+
+    /** Revert cout and cerr behaviour */
+    ~SuppressOutput() {
+        std::cout.rdbuf(_oldCout); // restore cout's original streambuf
+        std::cerr.rdbuf(_oldCerr); // restore cerrs's original streambuf
+    }
+
+private:
+    std::streambuf *_oldCout;
+    std::streambuf *_oldCerr;
+};
+
+#define REDIRECT RedirectOutputError redir
 #define GET_REDIRECT_OUTPUT redir.getOutput()
-#define CLEAR_REDIRECT_OUTPUT redir.clearOutput()
 #define GET_REDIRECT_ERROUT redir.getErrout()
-#define CLEAR_REDIRECT_ERROUT redir.clearErrout()
+
+#define SUPPRESS SuppressOutput supprout
+
+
+class RedirectInput {
+public:
+    explicit RedirectInput(const std::string &input) : _in(input) {
+        _oldCin = std::cin.rdbuf(); // back up cin's streambuf
+        std::cin.rdbuf(_in.rdbuf()); // assign streambuf to cin
+    }
+    ~RedirectInput() noexcept {
+        std::cin.rdbuf(_oldCin); // restore cin's original streambuf
+    }
+private:
+    std::istringstream _in;
+    std::streambuf* _oldCin;
+};
 
 #endif
diff --git a/test/scripts/extract_and_run_more_tests.sh b/test/scripts/extract_and_run_more_tests.sh
new file mode 100755
index 00000000000..0ecb64504eb
--- /dev/null
+++ b/test/scripts/extract_and_run_more_tests.sh
@@ -0,0 +1,8 @@
+#!/bin/bash
+
+cd ~/cppcheck || exit 1
+rm -rf test1
+python tools/extracttests.py --code=test1 test/testleakautovar.cpp
+cd ~/cppcheck/test1 || exit 1
+~/cppcheck/test/scripts/run_more_tests.sh
+
diff --git a/tools/extracttests.py b/test/scripts/extracttests.py
similarity index 69%
rename from tools/extracttests.py
rename to test/scripts/extracttests.py
index b6152e7a24d..a45c8261d64 100755
--- a/tools/extracttests.py
+++ b/test/scripts/extracttests.py
@@ -1,7 +1,7 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Cppcheck - A tool for static C/C++ code analysis
-# Copyright (C) 2007-2017 Cppcheck team.
+# Copyright (C) 2007-2021 Cppcheck team.
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -26,6 +26,49 @@
 import re
 
 
+def get_includes(code):
+    includes = (('alloca','alloca.h'),
+                ('NULL','cstddef'),
+                ('size_t','cstddef'),
+                ('free','cstdlib'),
+                ('malloc','cstdlib'),
+                ('realloc','cstdlib'),
+                ('memcpy','cstring'),
+                ('stdin','cstdio'),
+                ('strcat','cstring'),
+                ('strchr','cstring'),
+                ('strcpy','cstring'),
+                ('strlen','cstring'),
+                ('strncat','cstring'),
+                ('strncpy','cstring'),
+                ('std::cout','iostream'),
+                ('std::pair','utility'),
+                ('std::shared_ptr','memory'),
+                ('std::string','string'),
+                ('std::unique_ptr','memory'),
+                ('std::vector','vector'))
+
+    ret = ''
+
+    for i in includes:
+        if i[0] in code:
+            include_header = '#include <%s>' % i[1]
+            if include_header not in ret:
+                ret += include_header + '\n'
+
+    return ret
+
+
+def tweak_expected(expected, start_code):
+    if start_code is None or start_code == '':
+        return expected
+    res = re.match(r'[^(]*\[([^:\]]+):([0-9]+)\](.*)', expected)
+    if res is None:
+        return expected
+    lines = len(start_code[:-1].split('\n'))
+    return '[%s:%i]%s' % (res.group(1), lines + int(res.group(2)), res.group(3))
+
+
 class Extract:
 
     """
@@ -48,9 +91,10 @@ def parseFile(self, filename):
         testclass = None
         functionName = None
         code = None
+        start_code = None
+        disable = False
 
-        fin = open(filename, 'r')
-        for line in fin:
+        for line in open(filename, 'r'):
             # testclass starts
             res = re.match('class (' + name + ')', line)
             if res is not None:
@@ -64,37 +108,62 @@ def parseFile(self, filename):
             res = re.match('\\s+void (' + name + ')\\(\\)', line)
             if res is not None:
                 functionName = res.group(1)
+                start_code = None
 
             elif re.match('\\s+}', line) is not None:
                 functionName = None
 
-            if functionName is None:
+            # extracttests commands..
+            res = re.match(r'\s*//\s*extracttests.start:(.*)', line)
+            if res is not None:
+                start_code = res.group(1).replace('\\n', '\n') + '\n'
+            elif line.find('extracttests.disable') >= 0:
+                disable = True
+            elif line.find('extracttests.enable') >= 0:
+                disable = False
+
+            if functionName is None or disable:
                 continue
 
             # check
-            res = re.match('\s+check.*\(' + string, line)
-            if res is not None:
-                code = res.group(1)
+            for f in check_function:
+                res = re.match('\\s+' + f + '\\(' + string, line)
+                if res is not None:
+                    code = res.group(1)
+                    break
 
             # code..
             if code is not None:
                 res = re.match('\\s+' + string, line)
                 if res is not None:
+                    if line.find('",') > line.find('"'):
+                        code = None
+                        continue
+
                     code = code + res.group(1)
+                    if res.group(1).find('"') > 0:
+                        code = None
 
             # assert
             res = re.match('\\s+ASSERT_EQUALS\\(\\"([^"]*)\\",', line)
             if res is not None and code is not None:
+                if start_code:
+                    includes = get_includes(start_code + code)
+                    code = includes + start_code + code
+                    expected = tweak_expected(res.group(1), includes + start_code)
+                else:
+                    includes = get_includes(code)
+                    code = includes + code
+                    expected = tweak_expected(res.group(1), includes)
+
                 node = {'testclass': testclass,
                         'functionName': functionName,
-                        'code': code,
-                        'expected': res.group(1)}
+                        'code': code.replace("\\\\", "\\"),
+                        'expected': expected}
                 self.nodes.append(node)
                 code = None
-
-        # close test file
-        fin.close()
-
+            elif re.match('\\s+[TOD_]*ASSERT', line) is not None:
+                code = None
 
 def strtoxml(s):
     """Convert string to xml/html format"""
@@ -165,7 +234,7 @@ def writeHtmlFile(nodes, functionName, filename, errorsOnly):
 if len(sys.argv) <= 1 or '--help' in sys.argv:
     print('Extract test cases from test file')
     print(
-        'Syntax: extracttests.py [--html=folder] [--xml] [--code=folder] [--onlyTP] path/testfile.cpp')
+        'Syntax: extracttests.py [--html=folder] [--xml] [--code=folder] [--only-tp] [--check-function=check] path/testfile.cpp')
     sys.exit(0)
 
 # parse command line
@@ -174,10 +243,11 @@ def writeHtmlFile(nodes, functionName, filename, errorsOnly):
 htmldir = None
 codedir = None
 onlyTP = None
+check_function = ['check[A-Za-z0-9_]*']
 for arg in sys.argv[1:]:
     if arg == '--xml':
         xml = True
-    elif arg == '--onlyTP':
+    elif arg == '--only-tp':
         onlyTP = True
     elif arg.startswith('--html='):
         htmldir = arg[7:]
@@ -185,6 +255,8 @@ def writeHtmlFile(nodes, functionName, filename, errorsOnly):
         codedir = arg[7:]
     elif arg.endswith('.cpp'):
         filename = arg
+    elif arg.startswith('--check-function='):
+        check_function.append(arg[17:])
     else:
         print('Invalid option: ' + arg)
         sys.exit(1)
@@ -284,7 +356,7 @@ def writeHtmlFile(nodes, functionName, filename, errorsOnly):
         if not os.path.exists(codedir):
             os.mkdir(codedir)
 
-        errors = open(codedir + 'errors.txt', 'w')
+        testfile = os.path.splitext(os.path.basename(filename))[0]
 
         for node in e.nodes:
             if onlyTP and node['expected'] == '':
@@ -297,24 +369,25 @@ def writeHtmlFile(nodes, functionName, filename, errorsOnly):
             code = code.replace('\\n', '\n')
             code = code.replace('\\"', '"')
             expected = node['expected']
-
-            filename = '0000' + str(testnum) + '-'
-            filename = filename[-4:]
-            filename += functionName + '.cpp'
+            if expected.endswith('\\n'):
+                expected = expected[:-2]
+
+            filename = '%s-%03i-%s.cpp' % (testfile, testnum, functionName)
+
+            # comment error
+            res = re.match(r'[^(]*\[([^:\]]+):([0-9]+)\]: \([a-z, ]+\) (.*)', expected)
+            if res:
+                line_number = int(res.group(2)) - 1
+                lines = code.split('\n')
+                if len(lines) > line_number:
+                    lines[line_number] += ' // ' + res.group(3)
+                    code = '\n'.join(lines)
+                else:
+                    print('filename:%s expected:%s' % (filename, expected))
 
             # source code
-            fout = open(codedir + filename, 'w')
-            fout.write(code)
-            fout.close()
-
-            # write 'expected' to errors.txt
-            if expected != '':
-                expected = expected.replace('\\n', '\n')
-                expected = expected.replace('\\"', '"')
-                expected = re.sub(
-                    '\\[test.cp?p?:', '[' + filename + ':', expected)
-                errors.write(expected)
-        errors.close()
+            with open(codedir + filename, 'w') as fout:
+                fout.write(code + '\n')
     else:
         for node in e.nodes:
             print(node['functionName'])
diff --git a/test/scripts/generate_and_run_more_tests.sh b/test/scripts/generate_and_run_more_tests.sh
new file mode 100755
index 00000000000..3558f425b66
--- /dev/null
+++ b/test/scripts/generate_and_run_more_tests.sh
@@ -0,0 +1,21 @@
+#!/bin/bash
+# Run like:
+# cd ~/cppcheck
+# tools/generate_and_run_more_tests.sh
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+set -e
+
+echo testleakautovar
+$DIR/run_more_tests.sh $DIR/../testleakautovar.cpp
+
+echo testmemleak
+$DIR/run_more_tests.sh $DIR/../testmemleak.cpp
+
+echo testnullpointer
+$DIR/run_more_tests.sh $DIR/../testnullpointer.cpp
+
+echo testuninitvar
+$DIR/run_more_tests.sh $DIR/../testuninitvar.cpp
+
diff --git a/test/scripts/run_more_tests.sh b/test/scripts/run_more_tests.sh
new file mode 100755
index 00000000000..413ff8892f9
--- /dev/null
+++ b/test/scripts/run_more_tests.sh
@@ -0,0 +1,111 @@
+#!/bin/bash
+# Script Used by generate_and_run_more_tests.sh
+
+# "gsed" is a GNU compatible version of "sed" on MacOS
+SED_CMD=$(command -v gsed || command -v sed)
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+set -e
+
+CPPCHECK=$(pwd)/cppcheck
+
+if test -f ./bin/cppcheck; then
+    CPPCHECK=$(pwd)/bin/cppcheck
+fi
+
+python3 $DIR/extracttests.py --code=$(pwd)/test1 $1
+
+cd test1
+
+# ensure there are not critical errors in extracted tests
+$CPPCHECK -q --safety --suppress="*" .
+
+$CPPCHECK -q --template=cppcheck1 . 2> 1.txt
+
+echo "(!x) => (x==0)"
+$SED_CMD -ri 's/([(&][ ]*)\!([a-z]+)([ ]*[&)])/\1\2==0\3/' *.cpp
+$CPPCHECK -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
+
+echo "(x==0) => (0==x)"
+$SED_CMD -ri 's/([(&][ ]*)([a-z]+)[ ]*==[ ]*0([ ]*[&)])/\10==\2\3/' *.cpp
+$CPPCHECK -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
+
+echo "(0==x) => (!x)"
+$SED_CMD -ri 's/([(&][ ]*)0[ ]*==[ ]*([a-z]+)([ ]*[&)])/\1!\2\3/' *.cpp
+$CPPCHECK -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
+
+
+
+
+echo "if (x) => (x!=0)"
+$SED_CMD -ri 's/(if[ ]*\([ ]*[a-z]+)([ ]*[&)])/\1!=0\2/' *.cpp
+$CPPCHECK -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
+
+echo "while (x) => (x!=0)"
+$SED_CMD -ri 's/(while[ ]*\([ ]*[a-z]+)([ ]*[&)])/\1!=0\2/' *.cpp
+$CPPCHECK -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
+
+echo "(x!=0) => (0!=x)"
+$SED_CMD -ri 's/([(&][ ]*)([a-z]+)[ ]*!=[ ]*0([ ]*[&)])/\10!=\2\3/' *.cpp
+$CPPCHECK -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
+
+echo "(0!=x) => (x)"
+$SED_CMD -ri 's/([(&][ ]*)0[ ]*!=[ ]*([a-z]+[ ]*[&)])/\1\2/' *.cpp
+$CPPCHECK -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
+
+
+echo "(x < 0) => (0 > x)"
+$SED_CMD -ri 's/([(&][ ]*)([a-z]+)[ ]*<[ ]*(\-?[0-9]+)([ ]*[&)])/\1\3>\2\4/' *.cpp
+$CPPCHECK -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
+
+echo "(x <= 0) => (0 >= x)"
+$SED_CMD -ri 's/([(&][ ]*)([a-z]+)[ ]*<=[ ]*(\-?[0-9]+)([ ]*[&)])/\1\3>=\2\4/' *.cpp
+$CPPCHECK -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
+
+echo "(x > 0) => (0 < x)"
+$SED_CMD -ri 's/([(&][ ]*)([a-z]+)[ ]*<=[ ]*(\-?[0-9]+)([ ]*[&)])/\1\3>=\2\4/' *.cpp
+$CPPCHECK -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
+
+echo "(x >= 0) => (0 <= x)"
+$SED_CMD -ri 's/([(&][ ]*)([a-z]+)[ ]*<=[ ]*(\-?[0-9]+)([ ]*[&)])/\1\3>=\2\4/' *.cpp
+$CPPCHECK -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
+
+echo "(x == 123) => (123 == x)"
+$SED_CMD -ri 's/([(&][ ]*)([a-z]+)[ ]*==[ ]*(\-?[0-9]+)([ ]*[&)])/\1\3==\2\4/' *.cpp
+$CPPCHECK -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
+
+echo "(x != 123) => (123 != x)"
+$SED_CMD -ri 's/([(&][ ]*)([a-z]+)[ ]*\!=[ ]*(\-?[0-9]+)([ ]*[&)])/\1\3!=\2\4/' *.cpp
+$CPPCHECK -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
+
+
+
+echo "(0 < x) => (x > 0)"
+$SED_CMD -ri 's/([(&][ ]*)(\-?[0-9]+)[ ]*<[ ]*([a-z]+)([ ]*[&)])/\1\3>\2\4/' *.cpp
+$CPPCHECK -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
+
+echo "(0 <= x) => (x >= 0)"
+$SED_CMD -ri 's/([(&][ ]*)(\-?[0-9]+)[ ]*<=[ ]*([a-z]+)([ ]*[&)])/\1\3>=\2\4/' *.cpp
+$CPPCHECK -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
+
+echo "(0 > x) => (x < 0)"
+$SED_CMD -ri 's/([(&][ ]*)(\-?[0-9]+)[ ]*<=[ ]*([a-z]+)([ ]*[&)])/\1\3>=\2\4/' *.cpp
+$CPPCHECK -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
+
+echo "(0 >= x) => (x <= 0)"
+$SED_CMD -ri 's/([(&][ ]*)(\-?[0-9]+)[ ]*<=[ ]*([a-z]+)([ ]*[&)])/\1\3>=\2\4/' *.cpp
+$CPPCHECK -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
+
+echo "(123 == x) => (x == 123)"
+$SED_CMD -ri 's/([(&][ ]*)(\-?[0-9]+)[ ]*==[ ]*([a-z]+)([ ]*[&)])/\1\3==\2\4/' *.cpp
+$CPPCHECK -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
+
+echo "(123 != x) => (x <= 123)"
+$SED_CMD -ri 's/([(&][ ]*)(\-?[0-9]+)[ ]*\!=[ ]*([a-z]+)([ ]*[&)])/\1\3!=\2\4/' *.cpp
+$CPPCHECK -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
+
+
+cd ..
+
+rm -rf test1
diff --git a/test/scripts/testrunner-single.sh b/test/scripts/testrunner-single.sh
new file mode 100755
index 00000000000..3bb63a3c660
--- /dev/null
+++ b/test/scripts/testrunner-single.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+if [ -n "$1" ]; then
+  testrunner_bin=$1
+else
+  make -s -C "$SCRIPT_DIR/../.." -j"$(nproc)" testrunner # CXXOPTS="-g -O2 -w" CPPOPTS="-DHAVE_BOOST"
+  testrunner_bin=$SCRIPT_DIR/../../testrunner
+fi
+
+ec=0
+
+tests=$($testrunner_bin -d | cut -d'(' -f2 | cut -d')' -f1)
+for test in $tests; do
+  $testrunner_bin -n "$test" || ec=1
+done
+
+exit $ec
diff --git a/tools/testrunnerify_code.sh b/test/scripts/testrunnerify_code.sh
similarity index 100%
rename from tools/testrunnerify_code.sh
rename to test/scripts/testrunnerify_code.sh
diff --git a/test/seh/CMakeLists.txt b/test/seh/CMakeLists.txt
new file mode 100644
index 00000000000..aa946a85c4e
--- /dev/null
+++ b/test/seh/CMakeLists.txt
@@ -0,0 +1,4 @@
+add_executable(test-sehwrapper
+    test-sehwrapper.cpp
+    ${PROJECT_SOURCE_DIR}/cli/sehwrapper.cpp)
+target_include_directories(test-sehwrapper PRIVATE ${PROJECT_SOURCE_DIR}/cli ${PROJECT_SOURCE_DIR}/lib)
\ No newline at end of file
diff --git a/test/seh/test-sehwrapper.cpp b/test/seh/test-sehwrapper.cpp
new file mode 100644
index 00000000000..a92753b8423
--- /dev/null
+++ b/test/seh/test-sehwrapper.cpp
@@ -0,0 +1,86 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h" // IWYU pragma: keep
+
+#if defined(USE_WINDOWS_SEH)
+#include "sehwrapper.h"
+
+#include <cassert>
+#include <cfenv>
+#include <cstdlib>
+#include <cstring>
+
+#include <windows.h>
+
+static int my_assert()
+{
+    assert(false);
+    return 0;
+}
+
+static int my_abort()
+{
+    abort();
+}
+
+static int my_segv()
+{
+    // cppcheck-suppress nullPointer
+    ++*(int*)nullptr;
+    return 0;
+}
+
+// TODO: how to catch these?
+static int my_fpe()
+{
+    const int fpe_res = std::feraiseexcept(FE_ALL_EXCEPT);
+    if (fpe_res != 0)
+        return 11;
+    return sqrt(-1.0); // invalid operation
+}
+#endif
+
+int main(int argc, const char * const argv[])
+{
+#if defined(USE_WINDOWS_SEH)
+    if (argc != 2)
+        return 1;
+
+    if (strcmp(argv[1], "assert") == 0) {
+        _set_abort_behavior(0, _WRITE_ABORT_MSG); // suppress the "Debug Error!" MessageBox
+        CALL_WITH_SEH_WRAPPER(my_assert());
+    }
+    if (strcmp(argv[1], "abort") == 0) {
+        _set_abort_behavior(0, _WRITE_ABORT_MSG); // suppress the "Debug Error!" MessageBox
+        CALL_WITH_SEH_WRAPPER(my_abort());
+    }
+    if (strcmp(argv[1], "fpe") == 0) {
+        CALL_WITH_SEH_WRAPPER(my_fpe());
+    }
+    if (strcmp(argv[1], "segv") == 0) {
+        CALL_WITH_SEH_WRAPPER(my_segv());
+    }
+
+    return 0;
+#else
+    (void)argc;
+    (void)argv;
+    return 111;
+#endif
+}
diff --git a/test/seh/test-sehwrapper.py b/test/seh/test-sehwrapper.py
new file mode 100644
index 00000000000..199d96bc0d3
--- /dev/null
+++ b/test/seh/test-sehwrapper.py
@@ -0,0 +1,78 @@
+import subprocess
+import os
+import sys
+import pytest
+
+# TODO: only run on Windows
+
+def _lookup_cppcheck_exe(exe_name):
+    # path the script is located in
+    script_path = os.path.dirname(os.path.realpath(__file__))
+
+    if sys.platform == "win32":
+        exe_name += ".exe"
+
+    for base in (script_path + '/../../', './'):
+        for path in ('', 'bin/', 'bin/debug/'):
+            exe_path = base + path + exe_name
+            if os.path.isfile(exe_path):
+                print("using '{}'".format(exe_path))
+                return exe_path
+
+    return None
+
+def _call_process(arg):
+    exe = _lookup_cppcheck_exe('test-sehwrapper')
+    if exe is None:
+        raise Exception('executable not found')
+    p = subprocess.Popen([exe, arg], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    comm = p.communicate()
+    stdout = comm[0].decode(encoding='utf-8', errors='ignore').replace('\r\n', '\n')
+    stderr = comm[1].decode(encoding='utf-8', errors='ignore').replace('\r\n', '\n')
+    return p.returncode, stdout, stderr
+
+
+def test_assert():
+    exitcode, stdout, stderr = _call_process('assert')
+    assert stdout == ''
+    # Assertion failed: false, file S:\GitHub\cppcheck-fw\test\seh\test-sehwrapper.cpp, line 33
+    assert stderr.startswith("Assertion failed: false, file "), stderr
+    assert stderr.endswith("test-sehwrapper.cpp, line 33\n"), stderr
+    assert exitcode == 3
+
+
+def test_abort():
+    exitcode, stdout, stderr = _call_process('abort')
+    # nothing is written in case of abort()
+    # it will show the "Debug Error!" MessageBox though which we suppress in the test
+    assert stdout == ''
+    assert stderr == ''
+    assert exitcode == 3
+
+
+def test_segv():
+    exitcode, stdout, stderr = _call_process('segv')
+    assert stderr == ''
+    lines = stdout.splitlines()
+    assert lines[0].startswith('Internal error: Access violation (instruction: 0x'), lines[0]
+    assert lines[0].endswith(') reading from 0x0000000000000000'), lines[0]
+    assert lines[1].startswith('0. 0x'), lines[1]
+    assert lines[1].endswith(' in my_segv'), lines[1]
+    assert lines[2].startswith('1. 0x'), lines[2]
+    assert lines[2].endswith(' in main'), lines[2]
+    assert lines[len(lines)-1] == 'Please report this to the cppcheck developers!'
+    assert exitcode == 4294967295  # returns -1
+
+
+# TODO: make this work
+@pytest.mark.skip
+def test_fpe():
+    exitcode, stdout, stderr = _call_process('fpe')
+    assert stderr == ''
+    lines = stdout.splitlines()
+    assert lines[0].startswith('Internal error: cppcheck received signal SIGFPE - FPE_FLTDIV (at 0x7f'), lines[0]
+    assert lines[0].endswith(').'), lines[0]
+    assert lines[1] == 'Callstack:'
+    assert lines[2].endswith('my_fpe()'), lines[2]
+    assert lines[len(lines)-1] == 'Please report this to the cppcheck developers!'
+    assert exitcode == 4294967295  # returns -1
diff --git a/test/signal/CMakeLists.txt b/test/signal/CMakeLists.txt
new file mode 100644
index 00000000000..0bd186fff20
--- /dev/null
+++ b/test/signal/CMakeLists.txt
@@ -0,0 +1,28 @@
+add_executable(test-signalhandler
+        test-signalhandler.cpp
+        ${PROJECT_SOURCE_DIR}/cli/signalhandler.cpp
+        ${PROJECT_SOURCE_DIR}/cli/stacktrace.cpp)
+target_include_directories(test-signalhandler PRIVATE ${PROJECT_SOURCE_DIR}/cli ${PROJECT_SOURCE_DIR}/lib)
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    # names for static functions are omitted from trace
+    target_compile_options_safe(test-signalhandler -Wno-missing-declarations)
+    target_compile_options_safe(test-signalhandler -Wno-missing-prototypes)
+    # required for backtrace() to produce function names
+    if(NOT CMAKE_SYSTEM_NAME MATCHES AIX)
+        target_link_options(test-signalhandler PRIVATE -rdynamic)
+    endif()
+endif()
+
+add_executable(test-stacktrace
+        test-stacktrace.cpp
+        ${PROJECT_SOURCE_DIR}/cli/stacktrace.cpp)
+target_include_directories(test-stacktrace PRIVATE ${PROJECT_SOURCE_DIR}/cli ${PROJECT_SOURCE_DIR}/lib)
+if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    # names for static functions are omitted from trace
+    target_compile_options_safe(test-stacktrace -Wno-missing-declarations)
+    target_compile_options_safe(test-stacktrace -Wno-missing-prototypes)
+    # required for backtrace() to produce function names
+    if(NOT CMAKE_SYSTEM_NAME MATCHES AIX)
+        target_link_options(test-stacktrace PRIVATE -rdynamic)
+    endif()
+endif()
diff --git a/test/signal/test-signalhandler.cpp b/test/signal/test-signalhandler.cpp
new file mode 100644
index 00000000000..153ec95f245
--- /dev/null
+++ b/test/signal/test-signalhandler.cpp
@@ -0,0 +1,94 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#if !defined(__APPLE__)
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE // required to have feenableexcept()
+#endif
+#endif
+
+#include "config.h"
+
+#if defined(USE_UNIX_SIGNAL_HANDLING)
+#include "signalhandler.h"
+
+#include <cassert>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#if !defined(__APPLE__)
+#include <cfenv>
+#endif
+
+// static functions are omitted from trace
+
+/*static*/ NORETURN void my_assert() // NOLINT(misc-use-internal-linkage)
+{
+    assert(false);
+}
+
+/*static*/ NORETURN void my_abort() // NOLINT(misc-use-internal-linkage)
+{
+    abort();
+}
+
+/*static*/ void my_segv() // NOLINT(misc-use-internal-linkage)
+{
+    // cppcheck-suppress nullPointer
+    ++*static_cast<int*>(nullptr); // NOLINT(clang-analyzer-core.NullDereference)
+}
+
+#if !defined(__APPLE__) && !defined(_AIX)
+/*static*/ int my_fpe() // NOLINT(misc-use-internal-linkage)
+{
+    if (feenableexcept(FE_ALL_EXCEPT) == -1)
+        return 2;
+    if (std::feraiseexcept(FE_ALL_EXCEPT) != 0)
+        return 3;
+    return 1 % -1;
+}
+#endif
+#endif
+
+int main(int argc, const char * const argv[])
+{
+#if defined(USE_UNIX_SIGNAL_HANDLING)
+    if (argc != 2)
+        return 1;
+
+    register_signal_handler(stdout);
+
+    if (strcmp(argv[1], "assert") == 0)
+        my_assert();
+    else if (strcmp(argv[1], "abort") == 0)
+        my_abort();
+    else if (strcmp(argv[1], "segv") == 0)
+        my_segv();
+#if !defined(__APPLE__) && !defined(_AIX)
+    else if (strcmp(argv[1], "fpe") == 0)
+        return my_fpe();
+#endif
+
+    return 0;
+#else
+    (void)argc;
+    (void)argv;
+    return 1;
+#endif
+}
diff --git a/test/signal/test-signalhandler.py b/test/signal/test-signalhandler.py
new file mode 100644
index 00000000000..1ed700d7ec8
--- /dev/null
+++ b/test/signal/test-signalhandler.py
@@ -0,0 +1,94 @@
+import subprocess
+import os
+import sys
+import pytest
+import platform
+
+from packaging.version import Version
+
+def __lookup_cppcheck_exe(exe_name):
+    # path the script is located in
+    script_path = os.path.dirname(os.path.realpath(__file__))
+
+    if sys.platform == "win32":
+        exe_name += ".exe"
+
+    for base in (script_path + '/../../', './'):
+        for path in ('', 'bin/', 'bin/debug/'):
+            exe_path = base + path + exe_name
+            if os.path.isfile(exe_path):
+                print("using '{}'".format(exe_path))
+                return exe_path
+
+    return None
+
+def __call_process(arg):
+    exe = __lookup_cppcheck_exe('test-signalhandler')
+    if exe is None:
+        raise Exception('executable not found')
+    with subprocess.Popen([exe, arg], stdout=subprocess.PIPE, stderr=subprocess.PIPE) as p:
+        stdout, stderr = p.communicate()
+        rc = p.returncode
+    stdout = stdout.decode(encoding='utf-8', errors='ignore').replace('\r\n', '\n')
+    stderr = stderr.decode(encoding='utf-8', errors='ignore').replace('\r\n', '\n')
+    return rc, stdout, stderr
+
+
+def test_assert():
+    exitcode, stdout, stderr = __call_process('assert')
+    if sys.platform == "darwin":
+        assert stderr.startswith("Assertion failed: (false), function my_assert, file test-signalhandler.cpp, line "), stderr
+    else:
+        assert stderr.endswith("test-signalhandler.cpp:43: void my_assert(): Assertion `false' failed.\n"), stderr
+    lines = stdout.splitlines()
+    assert lines[0] == 'Internal error: cppcheck received signal SIGABRT - abort or assertion'
+    # no stacktrace of macOS
+    if sys.platform != "darwin":
+        assert lines[1] == 'Callstack:'
+        assert lines[2].endswith('my_abort()'), lines[2]  # TODO: wrong function
+        assert lines[len(lines)-1] == 'Please report this to the cppcheck developers!'
+    assert exitcode == -6
+
+
+def test_abort():
+    exitcode, stdout, _ = __call_process('abort')
+    lines = stdout.splitlines()
+    assert lines[0] == 'Internal error: cppcheck received signal SIGABRT - abort or assertion'
+    # no stacktrace on macOS
+    if sys.platform != "darwin":
+        assert lines[1] == 'Callstack:'
+        assert lines[2].endswith('my_segv()'), lines[2]  # TODO: wrong function
+        assert lines[len(lines)-1] == 'Please report this to the cppcheck developers!'
+    assert exitcode == -6
+
+
+def test_segv():
+    exitcode, stdout, stderr = __call_process('segv')
+    assert stderr == ''
+    lines = stdout.splitlines()
+    if sys.platform == "darwin":
+        if Version(platform.mac_ver()[0]) >= Version('14'):
+            assert lines[0] == 'Internal error: cppcheck received signal SIGSEGV - SEGV_ACCERR (at 0x0).'
+        else:
+            assert lines[0] == 'Internal error: cppcheck received signal SIGSEGV - SEGV_MAPERR (at 0x0).'
+    else:
+        assert lines[0] == 'Internal error: cppcheck received signal SIGSEGV - SEGV_MAPERR (reading at 0x0).'
+    # no stacktrace on macOS
+    if sys.platform != "darwin":
+        assert lines[1] == 'Callstack:'
+        assert lines[2].endswith('my_segv()'), lines[2]  # TODO: wrong function
+        assert lines[len(lines)-1] == 'Please report this to the cppcheck developers!'
+    assert exitcode == -11
+
+
+@pytest.mark.skipif(sys.platform == 'darwin', reason='Cannot raise FPE on macOS')
+def test_fpe():
+    exitcode, stdout, stderr = __call_process('fpe')
+    assert stderr == ''
+    lines = stdout.splitlines()
+    assert lines[0].startswith('Internal error: cppcheck received signal SIGFPE - FPE_FLTINV (at 0x'), lines[0]
+    assert lines[0].endswith(').'), lines[0]
+    assert lines[1] == 'Callstack:'
+    assert lines[3].endswith('my_fpe()'), lines[2]
+    assert lines[len(lines)-1] == 'Please report this to the cppcheck developers!'
+    assert exitcode == -8
diff --git a/test/signal/test-stacktrace.cpp b/test/signal/test-stacktrace.cpp
new file mode 100644
index 00000000000..8b4a2698433
--- /dev/null
+++ b/test/signal/test-stacktrace.cpp
@@ -0,0 +1,48 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#ifdef USE_UNIX_BACKTRACE_SUPPORT
+#include "stacktrace.h"
+
+#include <cstdio>
+
+// static functions are omitted from trace
+
+/*static*/ void my_func_2() // NOLINT(misc-use-internal-linkage)
+{
+    print_stacktrace(stdout, 0, true, -1, true);
+}
+
+/*static*/ void my_func() // NOLINT(misc-use-internal-linkage)
+{
+    my_func_2();
+}
+#endif
+
+int main()
+{
+#ifdef USE_UNIX_BACKTRACE_SUPPORT
+    my_func();
+
+    return 0;
+#else
+    return 1;
+#endif
+}
diff --git a/test/signal/test-stacktrace.py b/test/signal/test-stacktrace.py
new file mode 100644
index 00000000000..47e7b2d72a2
--- /dev/null
+++ b/test/signal/test-stacktrace.py
@@ -0,0 +1,39 @@
+import subprocess
+import os
+import sys
+
+def __lookup_cppcheck_exe(exe_name):
+    # path the script is located in
+    script_path = os.path.dirname(os.path.realpath(__file__))
+
+    if sys.platform == "win32":
+        exe_name += ".exe"
+
+    for base in (script_path + '/../../', './'):
+        for path in ('', 'bin/', 'bin/debug/'):
+            exe_path = base + path + exe_name
+            if os.path.isfile(exe_path):
+                print("using '{}'".format(exe_path))
+                return exe_path
+
+    return None
+
+def __call_process():
+    exe = __lookup_cppcheck_exe('test-stacktrace')
+    if exe is None:
+        raise Exception('executable not found')
+    with subprocess.Popen([exe], stdout=subprocess.PIPE, stderr=subprocess.PIPE) as p:
+        stdout, stderr = p.communicate()
+        rc = p.returncode
+    stdout = stdout.decode(encoding='utf-8', errors='ignore').replace('\r\n', '\n')
+    stderr = stderr.decode(encoding='utf-8', errors='ignore').replace('\r\n', '\n')
+    return rc, stdout, stderr
+
+
+def test_stack():
+    _, stdout, stderr = __call_process()
+    assert stderr == ''
+    lines = stdout.splitlines()
+    assert lines[0] == 'Callstack:'
+    assert lines[1].endswith('my_func_2()')
+    assert lines[2].endswith('my_func()')
diff --git a/test/synthetic/Makefile b/test/synthetic/Makefile
deleted file mode 100644
index 11afb4df579..00000000000
--- a/test/synthetic/Makefile
+++ /dev/null
@@ -1,20 +0,0 @@
-ifndef CC
-    CC=gcc
-endif
-
-all:	controlflow.o	data.o	functions.o	ub.o
-
-controlflow.o:	controlflow.c
-	$(CC) -c controlflow.c
-
-data.o:	data.c
-	$(CC) -c data.c
-
-functions.o:	functions.c
-	$(CC) -c functions.c
-
-ub.o:	ub.c
-	$(CC) -c ub.c
-
-clean:
-	rm -rf controlflow.o data.o functions.o ub.o
diff --git a/test/synthetic/controlflow.c b/test/synthetic/controlflow.c
deleted file mode 100644
index 845a42ab261..00000000000
--- a/test/synthetic/controlflow.c
+++ /dev/null
@@ -1,73 +0,0 @@
-
-//////////////////////////////
-// control flow analysis
-//////////////////////////////
-
-int buf[2];
-
-void in_if(int a) {
-  if (a==100)
-    buf[a] = 0; // BUG
-}
-
-void before_if(int a) {
-  buf[a] = 0; // WARNING
-  if (a==100) {}
-}
-
-void after_if(int a) {
-  if (a==100) {}
-  buf[a] = 0; // WARNING
-}
-
-void in_for(void) {
-  int x;
-  for (x = 0; x<100; x++) {
-    buf[x] = 0; // BUG
-  }
-}
-
-void after_for(void) {
-  int x;
-  for (x = 0; x<100; x++) {}
-  buf[x] = 0; // BUG
-}
-
-void in_switch(int x) {
-  switch (x) {
-  case 100:
-    buf[x] = 0; // BUG
-    break;
-  }
-}
-
-void before_switch(int x) {
-  buf[x] = 0; // WARNING
-  switch (x) {
-  case 100:
-    break;
-  }
-}
-
-void after_switch(int x) {
-  switch (x) {
-  case 100:
-    break;
-  }
-  buf[x] = 0; // WARNING
-}
-
-void in_while(void) {
-  int x = 0;
-  while (x<100) {
-    buf[x] = 0; // BUG
-    x++;
-  }
-}
-
-void after_while(void) {
-  int x = 0;
-  while (x<100)
-    x++;
-  buf[x] = 0; // BUG
-}
diff --git a/test/synthetic/data.c b/test/synthetic/data.c
deleted file mode 100644
index 87d49f1e326..00000000000
--- a/test/synthetic/data.c
+++ /dev/null
@@ -1,68 +0,0 @@
-
-int TestData[10];
-
-int g;
-void global() {
-  g = 1000;
-  TestData[g] = 0; // BUG
-}
-
-int garr[10];
-void global_array() {
-  garr[3] = 1000;
-  TestData[garr[3]] = 0; // BUG
-}
-
-int *gp;
-void global_pointer() {
-  *gp = 1000;
-  TestData[*gp] = 0; // BUG
-}
-
-
-void local() {
-  int x;
-  x = 1000;
-  TestData[x] = 0; // BUG
-}
-
-void local_array() {
-  int arr[10];
-  arr[3] = 1000;
-  TestData[arr[3]] = 0; // BUG
-}
-
-void local_alias_1() {
-  int x;
-  int *p = &x;
-  *p = 1000;
-  TestData[*p] = 0; // BUG
-}
-
-void local_alias_2() {
-  int x;
-  int *p = &x;
-  x = 1000;
-  TestData[*p] = 0; // BUG
-}
-
-struct ABC {
-  int a;
-  int b[10];
-  int c;
-};
-
-void struct_member_init() {
-  struct ABC abc = {1000,{0},3};
-  TestData[abc.a] = 0; // BUG
-}
-
-void struct_member_assign(struct ABC *abc) {
-  abc->a = 1000;
-  TestData[abc->a] = 0; // BUG
-}
-
-void struct_arraymember(struct ABC *abc) {
-  abc->b[3] = 1000;
-  TestData[abc->b[3]] = 0; // BUG
-}
diff --git a/test/synthetic/functions.c b/test/synthetic/functions.c
deleted file mode 100644
index e94082a4636..00000000000
--- a/test/synthetic/functions.c
+++ /dev/null
@@ -1,22 +0,0 @@
-
-int TestData[100];
-
-
-void par_not_dependant(int par) {
-  TestData[par] = 0; // BUG
-}
-void par_dependant(int x, int y) {
-  if (x < 10)
-      TestData[y] = 0; // BUG
-}
-void call(int x) {
-  par_not_dependant(1000);
-  par_dependant(0, 1000);
-}
-
-int getLargeIndex() { return 1000; }
-void return_value() {
-  TestData[getLargeIndex()] = 0; // BUG
-}
-
-
diff --git a/test/synthetic/report.py b/test/synthetic/report.py
deleted file mode 100755
index e4d972102e9..00000000000
--- a/test/synthetic/report.py
+++ /dev/null
@@ -1,57 +0,0 @@
-#!/usr/bin/env python
-import os
-import re
-
-
-def hasresult(filename, result):
-    if not os.path.isfile(filename):
-        return False
-    for line in open(filename, 'rt'):
-        if result in line:
-            return True
-    return False
-
-
-def parsefile(filename):
-    ret = []
-    linenr = 0
-    functionName = None
-    for line in open(filename, 'rt'):
-        linenr = linenr + 1
-        res = re.match('^[a-z]+[ *]+([a-z0-9_]+)[(]', line)
-        if res:
-            functionName = res.group(1)
-        if line.startswith('}'):
-            functionName = ''
-        elif 'BUG' in line or 'WARN' in line or filename == 'ub.c':
-            spaces = ' ' * 100
-            s = filename + spaces
-            s = s[:15] + str(linenr) + spaces
-            s = s[:20] + functionName + spaces
-            s = s[:50]
-            if hasresult('cppcheck.txt', '[' + filename + ':' + str(linenr) + ']'):
-                s = s + '      X'
-            else:
-                s = s + '       '
-            if hasresult('clang.txt', filename + ':' + str(linenr)):
-                s = s + '      X'
-            else:
-                s = s + '       '
-            if hasresult('lint.txt', filename + '  ' + str(linenr)):
-                s = s + '      X'
-            else:
-                s = s + '       '
-            if hasresult('cov.txt', filename + ':' + str(linenr)):
-                s = s + '      X'
-            else:
-                s = s + '       '
-            ret.append(s)
-    return ret
-
-bugs = []
-bugs.extend(parsefile('controlflow.c'))
-bugs.extend(parsefile('data.c'))
-bugs.extend(parsefile('functions.c'))
-bugs.extend(parsefile('ub.c'))
-for bug in bugs:
-    print(bug)
diff --git a/test/synthetic/run-clang.sh b/test/synthetic/run-clang.sh
deleted file mode 100755
index 45fcac06ba9..00000000000
--- a/test/synthetic/run-clang.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-~/llvm/build/bin/clang -cc1 -analyze -analyzer-checker=alpha.security controlflow.c data.c functions.c 2>&1 /dev/null | grep warning
-~/llvm/build/bin/clang -cc1 -analyze -analyzer-checker=alpha.security,core ub.c 2>&1 /dev/null | grep warning
-
diff --git a/test/synthetic/run-lint.bat b/test/synthetic/run-lint.bat
deleted file mode 100755
index e578df1a6b7..00000000000
--- a/test/synthetic/run-lint.bat
+++ /dev/null
@@ -1,4 +0,0 @@
-\lint\lint-nt.exe -e526 -e529 -e550 -e552 -e714 -e744 -e765 -e830 -e831 -e843 -h1 controlflow.c
-\lint\lint-nt.exe -e526 -e529 -e550 -e552 -e714 -e744 -e765 -e830 -e831 -e843 -h1 data.c
-\lint\lint-nt.exe -e526 -e529 -e550 -e552 -e714 -e744 -e765 -e830 -e831 -e843 -h1 functions.c
-\lint\lint-nt.exe -e526 -e529 -e550 -e552 -e714 -e744 -e765 -e830 -e831 -e843 -h1 ub.c
diff --git a/test/synthetic/ub.c b/test/synthetic/ub.c
deleted file mode 100644
index f0ac31ffe47..00000000000
--- a/test/synthetic/ub.c
+++ /dev/null
@@ -1,17 +0,0 @@
-void alias() { int x; int *ip=&x; float *fp = (float *)ip; }
-int buffer_overflow() { int x[10]={0}; return x[100]; }
-int dead_pointer(int a) { int *p=&a; if (a) { int x=0; p = &x; } return *p; }
-int division_by_zero() { return 100 / 0; }
-int float_to_int() { double d=1E100; return (int)d; }
-void negative_size(int sz) { if (sz < 0) { int buf[sz]; } }
-int no_return() {}
-int null_pointer() { int *p = 0; return *p; }
-int *pointer_arithmetic() { static int buf[10]; return buf + 100; }
-unsigned char pointer_to_u8() { static int buf[10]; return (int*)buf; }
-int pointer_subtraction() { char a[10]; char b[10]; return b-a; }
-int pointer_comparison() { char a[10]; char b[10]; return b<a; }
-int shift_overrun(int x) { return x << 123; }
-int shift_negative() { return -1 << 1; }
-int int_overflow() { int intmax = (~0U) >> 1; return intmax * 2; }
-void string_literal() { *((char *)"hello") = 0; }
-int uninit() { int x; return x + 2; }
diff --git a/test/test.cxx b/test/test.cxx
deleted file mode 100644
index 36b1454db8c..00000000000
--- a/test/test.cxx
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
-This is testing data for the GUI.
-Used for testing GUI with various error styles reported by cppcheck.
-Not meant to be compiled.
-*/
-
-#include <vector>
-
-void unused()
-{
-    int a = 15;
-}
-
-void f(char k)
-{
-    delete k;
-}
-
-void possible_style()
-{
-    std::list<int>::iterator it;
-    for (it = ab.begin(); it != ab.end(); it++)
-        ;
-}
-
-int main()
-{
-    char *b = new char[1];
-    char *a = new char[8];
-    if (a);
-    b = gets();
-    f(a);
-    possible_style();
-}
diff --git a/test/test64bit.cpp b/test/test64bit.cpp
index ab97d28f62d..6f9a5fbda2f 100644
--- a/test/test64bit.cpp
+++ b/test/test64bit.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,53 +16,72 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include "check64bit.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
 
+#include <cstddef>
 
 class Test64BitPortability : public TestFixture {
 public:
-    Test64BitPortability() : TestFixture("Test64BitPortability") {
-    }
+    Test64BitPortability() : TestFixture("Test64BitPortability") {}
 
 private:
-    Settings settings;
-
-    void run() OVERRIDE {
-        settings.addEnabled("portability");
+    const Settings settings = settingsBuilder().severity(Severity::portability).library("std.cfg").build();
 
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(novardecl);
         TEST_CASE(functionpar);
         TEST_CASE(structmember);
         TEST_CASE(ptrcompare);
         TEST_CASE(ptrarithmetic);
         TEST_CASE(returnIssues);
+        TEST_CASE(assignment);
     }
 
-    void check(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
-
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], bool cpp = true) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this, cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check char variable usage..
         Check64BitPortability check64BitPortability(&tokenizer, &settings, this);
         check64BitPortability.pointerassignment();
     }
 
+    void assignment() {
+        // #8631
+        check("using CharArray = char[16];\n"
+              "void f() {\n"
+              "    CharArray foo = \"\";\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct T { std::vector<int>*a[2][2]; };\n" // #11560
+              "void f(T& t, int i, int j) {\n"
+              "    t.a[i][j] = new std::vector<int>;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f();\n" // #11522
+              "void g() {\n"
+              "    int (*fp)() = *(int(*)())f;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
     void novardecl() {
         // if the variable declarations can't be seen then skip the warning
         check("void foo()\n"
               "{\n"
               "    a = p;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void functionpar() {
@@ -71,39 +90,85 @@ class Test64BitPortability : public TestFixture {
               "    int a = p;\n"
               "    return a + 4;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (portability) Assigning a pointer to an integer is not portable.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (portability) Assigning a pointer to an integer is not portable. [AssignmentAddressToInteger]\n", errout_str());
 
         check("int foo(int p[])\n"
               "{\n"
               "    int a = p;\n"
               "    return a + 4;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (portability) Assigning a pointer to an integer is not portable.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (portability) Assigning a pointer to an integer is not portable. [AssignmentAddressToInteger]\n", errout_str());
 
         check("int foo(int p[])\n"
               "{\n"
               "    int *a = p;\n"
               "    return a;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (portability) Returning an address value in a function with integer return type is not portable.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (portability) Returning an address value in a function with integer return type is not portable. [CastAddressToIntegerAtReturn]\n", errout_str());
 
         check("void foo(int x)\n"
               "{\n"
               "    int *p = x;\n"
               "    *p = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (portability) Assigning an integer to a pointer is not portable.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (portability) Assigning an integer to a pointer is not portable. [AssignmentIntegerToAddress]\n", errout_str());
 
         check("int f(const char *p) {\n" // #4659
               "    return 6 + p[2] * 256;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int foo(int *p) {\n" // #6096
               "    bool a = p;\n"
               "    return a;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::array<int,2> f();\n"
+              "void g() {\n"
+              "    std::array<int, 2> a = f();\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::array<int,2> f(int x);\n"
+              "void g(int i) {\n"
+              "    std::array<int, 2> a = f(i);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("typedef std::array<int, 2> Array;\n"
+              "Array f(int x);\n"
+              "void g(int i) {\n"
+              "    Array a = f(i);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("typedef std::array<int, 2> Array;\n"
+              "Array f();\n"
+              "void g(int i) {\n"
+              "    Array a = f();\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #9951
+              "    enum E { E0 };\n"
+              "    std::array<double, 1> g(S::E);\n"
+              "};\n"
+              "void f() {\n"
+              "    std::array<double, 1> a = S::g(S::E::E0);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("char* f(char* p) {\n"
+              "    return p ? p : 0;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int* p) {\n"
+              "    int n = (int)(size_t)*p;\n"
+              "    return n;\n"
+              "}\n", false);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void structmember() {
@@ -111,7 +176,17 @@ class Test64BitPortability : public TestFixture {
               "void f(struct Foo *foo) {\n"
               "    int i = foo->p;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (portability) Assigning a pointer to an integer is not portable.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (portability) Assigning a pointer to an integer is not portable. [AssignmentAddressToInteger]\n", errout_str());
+
+        check("struct S {\n" // #10145
+              "    enum class E { e1, e2 };\n"
+              "    E e;\n"
+              "    char* e1;\n"
+              "};\n"
+              "void f(S& s) {\n"
+              "    s.e = S::E::e1;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void ptrcompare() {
@@ -119,7 +194,7 @@ class Test64BitPortability : public TestFixture {
         check("void foo(int *p) {\n"
               "    int a = (p != NULL);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void ptrarithmetic() {
@@ -128,74 +203,74 @@ class Test64BitPortability : public TestFixture {
               "    int x = 10;\n"
               "    int *a = p + x;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int *p) {\n"
               "    int x = 10;\n"
               "    int *a = x + p;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int *p) {\n"
               "    int x = 10;\n"
               "    int *a = x * x;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (portability) Assigning an integer to a pointer is not portable.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (portability) Assigning an integer to a pointer is not portable. [AssignmentIntegerToAddress]\n", errout_str());
 
         check("void foo(int *start, int *end) {\n"
               "    int len;\n"
               "    int len = end + 10 - start;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void returnIssues() {
         check("void* foo(int i) {\n"
               "    return i;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (portability) Returning an integer in a function with pointer return type is not portable.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (portability) Returning an integer in a function with pointer return type is not portable. [CastIntegerToAddressAtReturn]\n", errout_str());
 
         check("void* foo(int* i) {\n"
               "    return i;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void* foo() {\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int foo(int i) {\n"
               "    return i;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Foo {};\n"
               "\n"
               "int* dostuff(Foo foo) {\n"
               "  return foo;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int foo(char* c) {\n"
               "    return c;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (portability) Returning an address value in a function with integer return type is not portable.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (portability) Returning an address value in a function with integer return type is not portable. [CastAddressToIntegerAtReturn]\n", errout_str());
 
         check("int foo(char* c) {\n"
               "    return 1+c;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (portability) Returning an address value in a function with integer return type is not portable.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (portability) Returning an address value in a function with integer return type is not portable. [CastAddressToIntegerAtReturn]\n", errout_str());
 
         check("std::string foo(char* c) {\n"
               "    return c;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int foo(char *a, char *b) {\n" // #4486
               "    return a + 1 - b;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct s {\n" // 4642
               "   int i;\n"
@@ -203,13 +278,13 @@ class Test64BitPortability : public TestFixture {
               "int func(struct s *p) {\n"
               " return 1 + p->i;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("static void __iomem *f(unsigned int port_no) {\n"
               "  void __iomem *mmio = hpriv->mmio;\n"
               "  return mmio + (port_no * 0x80);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #7247: don't check return statements in nested functions..
         check("int foo() {\n"
@@ -217,15 +292,44 @@ class Test64BitPortability : public TestFixture {
               "    const char * name() { return \"abc\"; }\n"
               "  } table;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #7451: Lambdas
         check("const int* test(std::vector<int> outputs, const std::string& text) {\n"
-              "  auto it = std::find_if(outputs.begin(), outputs.end(), \n"
+              "  auto it = std::find_if(outputs.begin(), outputs.end(),\n"
               "     [&](int ele) { return \"test\" == text; });\n"
               "  return nullptr;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #12159
+              "    std::future<int> f() const {\n"
+              "        return {};\n"
+              "    }\n"
+              "};\n"
+              "int g() {\n"
+              "    std::shared_ptr<S> s = std::make_shared<S>();\n"
+              "    auto x = s->f();\n"
+              "    return x.get();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int* p) {\n" // #14294
+              "    return (int)p;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:5]: (portability) Returning an address value in a function with integer return type is not portable. [CastAddressToIntegerAtReturn]\n",
+                      errout_str());
+
+        check("int f(int* p) {\n"
+              "    return reinterpret_cast<int>(p);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:5]: (portability) Returning an address value in a function with integer return type is not portable. [CastAddressToIntegerAtReturn]\n",
+                      errout_str());
+
+        check("bool f(const int* p) {\n"
+              "    return p;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 };
 
diff --git a/test/testanalyzerinformation.cpp b/test/testanalyzerinformation.cpp
new file mode 100644
index 00000000000..0936dbbf3f2
--- /dev/null
+++ b/test/testanalyzerinformation.cpp
@@ -0,0 +1,273 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "analyzerinfo.h"
+#include "errorlogger.h"
+#include "filesettings.h"
+#include "fixture.h"
+#include "standards.h"
+
+#include <list>
+#include <sstream>
+
+#include "xml.h"
+
+class TestAnalyzerInformation : public TestFixture {
+public:
+    TestAnalyzerInformation() : TestFixture("TestAnalyzerInformation") {}
+
+private:
+    class AnalyzerInformationTest final : public AnalyzerInformation
+    {
+        friend class TestAnalyzerInformation;
+    };
+
+    void run() override {
+        TEST_CASE(getAnalyzerInfoFileFromFilesTxt);
+        TEST_CASE(getAnalyzerInfoFile);
+        TEST_CASE(duplicateFile);
+        TEST_CASE(filesTextDuplicateFile);
+        TEST_CASE(parse);
+        TEST_CASE(skipAnalysis);
+    }
+
+    void getAnalyzerInfoFileFromFilesTxt() const {
+        constexpr char filesTxt[] = "file1.a4:::file1.c\n";
+        std::istringstream f(filesTxt);
+        ASSERT_EQUALS("file1.a4", AnalyzerInformationTest::getAnalyzerInfoFileFromFilesTxt(f, "file1.c", "", 0));
+        f.str(filesTxt);
+        ASSERT_EQUALS("file1.a4", AnalyzerInformationTest::getAnalyzerInfoFileFromFilesTxt(f, "./file1.c", "", 0));
+    }
+
+    void getAnalyzerInfoFile() const {
+        ASSERT_EQUALS("builddir/file1.c.analyzerinfo", AnalyzerInformation::getAnalyzerInfoFile("builddir", "file1.c", "", 0));
+        ASSERT_EQUALS("builddir/file1.c.analyzerinfo", AnalyzerInformation::getAnalyzerInfoFile("builddir", "some/path/file1.c", "", 0));
+    }
+
+    void filesTextDuplicateFile() const {
+        std::list<FileSettings> fileSettings;
+        fileSettings.emplace_back("a.c", Standards::Language::C, 10);
+        fileSettings.back().file.setFsFileId(0);
+        fileSettings.emplace_back("a.c", Standards::Language::C, 10);
+        fileSettings.back().file.setFsFileId(1);
+
+        const char expected[] = "a.a1:::a.c\n"
+                                "a.a2::1:a.c\n";
+
+        ASSERT_EQUALS(expected, AnalyzerInformationTest::getFilesTxt({}, fileSettings));
+    }
+
+    void duplicateFile() const {
+        // same file duplicated
+        constexpr char filesTxt[] = "file1.a1::1:file1.c\n"
+                                    "file1.a2::2:file1.c\n";
+        std::istringstream f1(filesTxt);
+        ASSERT_EQUALS("file1.a1", AnalyzerInformationTest::getAnalyzerInfoFileFromFilesTxt(f1, "file1.c", "", 1));
+        std::istringstream f2(filesTxt);
+        ASSERT_EQUALS("file1.a2", AnalyzerInformationTest::getAnalyzerInfoFileFromFilesTxt(f2, "file1.c", "", 2));
+    }
+
+    void parse() const {
+        AnalyzerInformation::Info info;
+
+        ASSERT_EQUALS(false, info.parse("a"));
+        ASSERT_EQUALS(false, info.parse("a:b"));
+        ASSERT_EQUALS(false, info.parse("a:b:c"));
+        ASSERT_EQUALS(false, info.parse("a:b:c:d"));
+
+        ASSERT_EQUALS(true, info.parse("a:b::d"));
+        ASSERT_EQUALS("a", info.afile);
+        ASSERT_EQUALS("b", info.cfg);
+        ASSERT_EQUALS(0, info.fsFileId);
+        ASSERT_EQUALS("d", info.sourceFile);
+
+        ASSERT_EQUALS(true, info.parse("e:f:12:g"));
+        ASSERT_EQUALS("e", info.afile);
+        ASSERT_EQUALS("f", info.cfg);
+        ASSERT_EQUALS(12, info.fsFileId);
+        ASSERT_EQUALS("g", info.sourceFile);
+
+        ASSERT_EQUALS(true, info.parse("odr1.a1:::C:/dm/cppcheck-fix-13333/test/cli/whole-program/odr1.cpp"));
+        ASSERT_EQUALS("odr1.a1", info.afile);
+        ASSERT_EQUALS("", info.cfg);
+        ASSERT_EQUALS(0, info.fsFileId);
+        ASSERT_EQUALS("C:/dm/cppcheck-fix-13333/test/cli/whole-program/odr1.cpp", info.sourceFile);
+    }
+
+    void skipAnalysis() const {
+        // Matching hash with license error (don't skip)
+        {
+            std::list<ErrorMessage> errorList;
+            tinyxml2::XMLDocument doc;
+
+            const tinyxml2::XMLError xmlError = doc.Parse(
+                "<?xml version=\"1.0\"?>"
+                "<analyzerinfo hash=\"100\">"
+                "<error id=\"premium-invalidLicense\" severity=\"error\" msg=\"Invalid license: No license file was found, contact sales@cppchecksolutions.com\" verbose=\"Invalid license: No license file was found, contact sales@cppchecksolutions.com\" file0=\"test.c\">"
+                "<location file=\"Cppcheck Premium\" line=\"0\" column=\"0\"/>"
+                "</error>"
+                "</analyzerinfo>"
+                );
+            ASSERT_EQUALS(tinyxml2::XML_SUCCESS, xmlError);
+
+            ASSERT_EQUALS("'premium-invalidLicense' encountered", AnalyzerInformationTest::skipAnalysis(doc, 100, errorList));
+            ASSERT_EQUALS(0, errorList.size());
+        }
+
+        // Matching hash with premium internal error (don't skip)
+        {
+            std::list<ErrorMessage> errorList;
+            tinyxml2::XMLDocument doc;
+
+            const tinyxml2::XMLError xmlError = doc.Parse(
+                "<?xml version=\"1.0\"?>"
+                "<analyzerinfo hash=\"100\">"
+                "<error id=\"premium-internalError\" severity=\"error\" msg=\"Something went wrong\" verbose=\"Something went wrong\" file0=\"test.c\">"
+                "<location file=\"Cppcheck\" line=\"0\" column=\"0\"/>"
+                "</error>"
+                "</analyzerinfo>"
+                );
+            ASSERT_EQUALS(tinyxml2::XML_SUCCESS, xmlError);
+
+            ASSERT_EQUALS("'premium-internalError' encountered", AnalyzerInformationTest::skipAnalysis(doc, 100, errorList));
+            ASSERT_EQUALS(0, errorList.size());
+        }
+
+        // Matching hash with internal error (don't skip)
+        {
+            std::list<ErrorMessage> errorList;
+            tinyxml2::XMLDocument doc;
+
+            const tinyxml2::XMLError xmlError = doc.Parse(
+                "<?xml version=\"1.0\"?>"
+                "<analyzerinfo hash=\"100\">"
+                "<error id=\"internalError\" severity=\"error\" msg=\"Something went wrong\" verbose=\"Something went wrong\" file0=\"test.c\">"
+                "<location file=\"Cppcheck\" line=\"0\" column=\"0\"/>"
+                "</error>"
+                "</analyzerinfo>"
+                );
+            ASSERT_EQUALS(tinyxml2::XML_SUCCESS, xmlError);
+
+            ASSERT_EQUALS("'internalError' encountered", AnalyzerInformationTest::skipAnalysis(doc, 100, errorList));
+            ASSERT_EQUALS(0, errorList.size());
+        }
+
+        // Matching hash with normal error (skip)
+        {
+            std::list<ErrorMessage> errorList;
+            tinyxml2::XMLDocument doc;
+
+            const tinyxml2::XMLError xmlError = doc.Parse(
+                "<?xml version=\"1.0\"?>"
+                "<analyzerinfo hash=\"100\">"
+                "<error id=\"nullPointer\" severity=\"error\" msg=\"Null pointer dereference: ptr\" verbose=\"Null pointer dereference: ptr\" cwe=\"476\" file0=\"test.c\">"
+                "<location file=\"test.c\" line=\"4\" column=\"3\" info=\"Null pointer dereference\"/>"
+                "<location file=\"test.c\" line=\"3\" column=\"12\" info=\"Assignment &apos;ptr=NULL&apos;, assigned value is 0\"/>"
+                "<symbol>ptr</symbol>"
+                "</error>"
+                "</analyzerinfo>"
+                );
+            ASSERT_EQUALS(tinyxml2::XML_SUCCESS, xmlError);
+
+            ASSERT_EQUALS("", AnalyzerInformationTest::skipAnalysis(doc, 100, errorList));
+            ASSERT_EQUALS(1, errorList.size());
+        }
+
+        // Matching hash with no error (skip)
+        {
+            std::list<ErrorMessage> errorList;
+            tinyxml2::XMLDocument doc;
+
+            const tinyxml2::XMLError xmlError = doc.Parse(
+                "<?xml version=\"1.0\"?>"
+                "<analyzerinfo hash=\"100\">"
+                "</analyzerinfo>"
+                );
+            ASSERT_EQUALS(tinyxml2::XML_SUCCESS, xmlError);
+
+            ASSERT_EQUALS("", AnalyzerInformationTest::skipAnalysis(doc, 100, errorList));
+            ASSERT_EQUALS(0, errorList.size());
+        }
+
+        // Different hash with normal error (don't skip)
+        {
+            std::list<ErrorMessage> errorList;
+            tinyxml2::XMLDocument doc;
+
+            const tinyxml2::XMLError xmlError = doc.Parse(
+                "<?xml version=\"1.0\"?>"
+                "<analyzerinfo hash=\"100\">"
+                "<error id=\"nullPointer\" severity=\"error\" msg=\"Null pointer dereference: ptr\" verbose=\"Null pointer dereference: ptr\" cwe=\"476\" file0=\"test.c\">"
+                "<location file=\"test.c\" line=\"4\" column=\"3\" info=\"Null pointer dereference\"/>"
+                "<location file=\"test.c\" line=\"3\" column=\"12\" info=\"Assignment &apos;ptr=NULL&apos;, assigned value is 0\"/>"
+                "<symbol>ptr</symbol>"
+                "</error>"
+                "</analyzerinfo>"
+                );
+            ASSERT_EQUALS(tinyxml2::XML_SUCCESS, xmlError);
+
+            ASSERT_EQUALS("hash mismatch", AnalyzerInformationTest::skipAnalysis(doc, 99, errorList));
+            ASSERT_EQUALS(0, errorList.size());
+        }
+
+        // Empty document (don't skip)
+        {
+            std::list<ErrorMessage> errorList;
+            tinyxml2::XMLDocument doc;
+
+            const tinyxml2::XMLError xmlError = doc.Parse("");
+            ASSERT_EQUALS(tinyxml2::XML_ERROR_EMPTY_DOCUMENT, xmlError);
+
+            ASSERT_EQUALS("no root node found", AnalyzerInformationTest::skipAnalysis(doc, 100, errorList));
+            ASSERT_EQUALS(0, errorList.size());
+        }
+
+        // Unexpected root node
+        {
+            std::list<ErrorMessage> errorList;
+            tinyxml2::XMLDocument doc;
+
+            const tinyxml2::XMLError xmlError = doc.Parse(
+                "<?xml version=\"1.0\"?>"
+                "<ainfo/>"
+                );
+            ASSERT_EQUALS(tinyxml2::XML_SUCCESS, xmlError);
+
+            ASSERT_EQUALS("unexpected root node", AnalyzerInformationTest::skipAnalysis(doc, 99, errorList));
+            ASSERT_EQUALS(0, errorList.size());
+        }
+
+        // No 'hash' attribute found
+        {
+            std::list<ErrorMessage> errorList;
+            tinyxml2::XMLDocument doc;
+
+            const tinyxml2::XMLError xmlError = doc.Parse(
+                "<?xml version=\"1.0\"?>"
+                "<analyzerinfo/>"
+                );
+            ASSERT_EQUALS(tinyxml2::XML_SUCCESS, xmlError);
+
+            ASSERT_EQUALS("no 'hash' attribute found", AnalyzerInformationTest::skipAnalysis(doc, 99, errorList));
+            ASSERT_EQUALS(0, errorList.size());
+        }
+    }
+};
+
+REGISTER_TEST(TestAnalyzerInformation)
diff --git a/test/testassert.cpp b/test/testassert.cpp
index ef093c87c19..412a7cb750b 100644
--- a/test/testassert.cpp
+++ b/test/testassert.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,39 +18,38 @@
 
 
 #include "checkassert.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
 
+#include <cstddef>
 
 class TestAssert : public TestFixture {
 public:
     TestAssert() : TestFixture("TestAssert") {}
 
 private:
-    Settings settings;
-
-    void check(const char code[], const char *filename = "test.cpp") {
-        // Clear the error buffer..
-        errout.str("");
+    const Settings settings = settingsBuilder().severity(Severity::warning).build();
 
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, filename);
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check..
-        CheckAssert checkAssert;
-        checkAssert.runChecks(&tokenizer, &settings, this);
+        runChecks<CheckAssert>(tokenizer, this);
     }
 
-    void run() OVERRIDE {
-        settings.addEnabled("warning");
-
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(assignmentInAssert);
         TEST_CASE(functionCallInAssert);
         TEST_CASE(memberFunctionCallInAssert);
         TEST_CASE(safeFunctionCallInAssert);
+        TEST_CASE(crash);
     }
 
 
@@ -62,18 +61,16 @@ class TestAssert : public TestFixture {
             "   if (b) { a = 1+2 };\n"
             "   return a;\n"
             "}\n"
-            "assert(foo() == 3); \n"
-        );
-        ASSERT_EQUALS("", errout.str());
+            "assert(foo() == 3);");
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "int foo(int a) {\n"
             "    int b=a+1;\n"
             "    return b;\n"
             "}\n"
-            "assert(foo(1) == 2); \n"
-        );
-        ASSERT_EQUALS("", errout.str());
+            "assert(foo(1) == 2);");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void functionCallInAssert() {
@@ -83,9 +80,8 @@ class TestAssert : public TestFixture {
             "    a = 1+2;\n"
             "    return a;\n"
             "}\n"
-            "assert(foo() == 3); \n"
-        );
-        ASSERT_EQUALS("[test.cpp:6]: (warning) Assert statement calls a function which may have desired side effects: 'foo'.\n", errout.str());
+            "assert(foo() == 3);");
+        ASSERT_EQUALS("[test.cpp:6:8]: (warning) Assert statement calls a function which may have desired side effects: 'foo'. [assertWithSideEffect]\n", errout_str());
 
         //  Ticket #4937 "false positive: Assert calls a function which may have desired side effects"
         check("struct SquarePack {\n"
@@ -96,8 +92,8 @@ class TestAssert : public TestFixture {
               "};\n"
               "void foo() {\n"
               "   assert( !SquarePack::isRank1Or8(push2) );\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct SquarePack {\n"
               "   static bool isRank1Or8( Square &sq ) {\n"
@@ -107,8 +103,8 @@ class TestAssert : public TestFixture {
               "};\n"
               "void foo() {\n"
               "   assert( !SquarePack::isRank1Or8(push2) );\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:8]: (warning) Assert statement calls a function which may have desired side effects: 'isRank1Or8'.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:8:25]: (warning) Assert statement calls a function which may have desired side effects: 'isRank1Or8'. [assertWithSideEffect]\n", errout_str());
 
         check("struct SquarePack {\n"
               "   static bool isRank1Or8( Square *sq ) {\n"
@@ -118,8 +114,8 @@ class TestAssert : public TestFixture {
               "};\n"
               "void foo() {\n"
               "   assert( !SquarePack::isRank1Or8(push2) );\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:8]: (warning) Assert statement calls a function which may have desired side effects: 'isRank1Or8'.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:8:25]: (warning) Assert statement calls a function which may have desired side effects: 'isRank1Or8'. [assertWithSideEffect]\n", errout_str());
 
         check("struct SquarePack {\n"
               "   static bool isRank1Or8( Square *sq ) {\n"
@@ -129,8 +125,28 @@ class TestAssert : public TestFixture {
               "};\n"
               "void foo() {\n"
               "   assert( !SquarePack::isRank1Or8(push2) );\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct Geometry {\n"
+              "    int nbv;\n"
+              "    int empty() { return (nbv == 0); }\n"
+              "    void ReadGeometry();\n"
+              "};\n"
+              "\n"
+              "void Geometry::ReadGeometry() {\n"
+              "    assert(empty());\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #4811
+              "    void f() const;\n"
+              "    bool g(std::ostream& os = std::cerr) const;\n"
+              "};\n"
+              "void S::f() const {\n"
+              "    assert(g());\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void memberFunctionCallInAssert() {
@@ -138,32 +154,32 @@ class TestAssert : public TestFixture {
               "   void Foo();\n"
               "};\n"
               "void foo(SquarePack s) {\n"
-              "   assert( s.Foo(); );\n"
+              "   assert( s.Foo() );\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Assert statement calls a function which may have desired side effects: 'Foo'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:14]: (warning) Assert statement calls a function which may have desired side effects: 'Foo'. [assertWithSideEffect]\n", errout_str());
 
         check("struct SquarePack {\n"
-              "   void Foo() const;\n"
+              "   int Foo() const;\n"
               "};\n"
               "void foo(SquarePack* s) {\n"
-              "   assert( s->Foo(); );\n"
+              "   assert( s->Foo() );\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct SquarePack {\n"
-              "   static void Foo();\n"
+              "   static int Foo();\n"
               "};\n"
               "void foo(SquarePack* s) {\n"
-              "   assert( s->Foo(); );\n"
+              "   assert( s->Foo() );\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct SquarePack {\n"
               "};\n"
               "void foo(SquarePack* s) {\n"
-              "   assert( s->Foo(); );\n"
+              "   assert( s->Foo() );\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void assignmentInAssert() {
@@ -171,54 +187,55 @@ class TestAssert : public TestFixture {
               "    int a; a = 0;\n"
               "    assert(a = 2);\n"
               "    return a;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Assert statement modifies 'a'.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:14]: (warning) Assert statement modifies 'a'. [assignmentInAssert]\n", errout_str());
 
         check("void f(int a) {\n"
               "    assert(a == 2);\n"
               "    return a;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int a, int b) {\n"
-              "    assert(a == 2 && b = 1);\n"
+              "    assert(a == 2 && (b = 1));\n"
               "    return a;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Assert statement modifies 'b'.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:25]: (warning) Assert statement modifies 'b'. [assignmentInAssert]\n", errout_str());
 
         check("void f() {\n"
               "    int a; a = 0;\n"
               "    assert(a += 2);\n"
               "    return a;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Assert statement modifies 'a'.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:14]: (warning) Assert statement modifies 'a'. [assignmentInAssert]\n", errout_str());
 
         check("void f() {\n"
               "    int a; a = 0;\n"
               "    assert(a *= 2);\n"
               "    return a;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Assert statement modifies 'a'.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:14]: (warning) Assert statement modifies 'a'. [assignmentInAssert]\n", errout_str());
 
         check("void f() {\n"
               "    int a; a = 0;\n"
               "    assert(a -= 2);\n"
               "    return a;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Assert statement modifies 'a'.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:14]: (warning) Assert statement modifies 'a'. [assignmentInAssert]\n", errout_str());
 
         check("void f() {\n"
               "    int a = 0;\n"
               "    assert(a--);\n"
               "    return a;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Assert statement modifies 'a'.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:13]: (warning) Assert statement modifies 'a'. [assignmentInAssert]\n", errout_str());
+
+        check("void f() {\n"
+              "    int a = 0;\n"
+              "    assert(--a);\n"
+              "    return a;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:12]: (warning) Assert statement modifies 'a'. [assignmentInAssert]\n", errout_str());
 
         check("void f() {\n"
               "  assert(std::all_of(first, last, []() {\n"
@@ -226,8 +243,20 @@ class TestAssert : public TestFixture {
               "                  auto const expected = someOtherValue;\n"
               "                  return tmp == expected;\n"
               "                }));\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void crash() {
+        check("void foo() {\n"
+              "  assert(sizeof(struct { int a[x++]; })==sizeof(int));\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo() {\n" // #9790
+              "  assert(kad_bucket_hash(&(kad_guid) { .bytes = { 0 } }, & (kad_guid){.bytes = { 0 }}) == -1);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 };
 
diff --git a/test/testastutils.cpp b/test/testastutils.cpp
index 951d2194157..8ca2412a095 100644
--- a/test/testastutils.cpp
+++ b/test/testastutils.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,42 +16,52 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include "astutils.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "settings.h"
-#include "testsuite.h"
+#include "symboldatabase.h"
 #include "token.h"
-#include "tokenize.h"
 #include "tokenlist.h"
 
+#include <cstdint>
+#include <cstring>
 
 class TestAstUtils : public TestFixture {
 public:
-    TestAstUtils() : TestFixture("TestAstUtils") {
-    }
+    TestAstUtils() : TestFixture("TestAstUtils") {}
 
 private:
 
-    void run() OVERRIDE {
-        TEST_CASE(findLambdaEndToken);
-        TEST_CASE(findLambdaStartToken);
-        TEST_CASE(isReturnScope);
-        TEST_CASE(isVariableChanged);
-        TEST_CASE(isVariableChangedByFunctionCall);
-        TEST_CASE(nextAfterAstRightmostLeaf);
+    // TODO: test with C code
+
+    void run() override {
+        TEST_CASE(findLambdaEndTokenTest);
+        TEST_CASE(findLambdaStartTokenTest);
+        TEST_CASE(isNullOperandTest);
+        TEST_CASE(isReturnScopeTest);
+        TEST_CASE(isSameExpressionCpp);
+        TEST_CASE(isSameExpressionC);
+        TEST_CASE(isVariableChangedTest);
+        TEST_CASE(isVariableChangedByFunctionCallTest);
+        TEST_CASE(isExpressionChangedTest);
+        TEST_CASE(nextAfterAstRightmostLeafTest);
+        TEST_CASE(isUsedAsBool);
     }
 
-    bool findLambdaEndToken(const char code[]) {
-        Settings settings;
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        const Token * const tokEnd = ::findLambdaEndToken(tokenizer.tokens());
-        return tokEnd && tokEnd->next() == nullptr;
+#define findLambdaEndToken(...) findLambdaEndToken_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    bool findLambdaEndToken_(const char* file, int line, const char (&code)[size], const char pattern[] = nullptr, bool checkNext = true) {
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+        const Token* const tokStart = pattern ? Token::findsimplematch(tokenizer.tokens(), pattern, strlen(pattern)) : tokenizer.tokens();
+        const Token * const tokEnd = (::findLambdaEndToken)(tokStart);
+        return tokEnd && (!checkNext || tokEnd->next() == nullptr);
     }
 
-    void findLambdaEndToken() {
-        ASSERT(nullptr == ::findLambdaEndToken(nullptr));
+    void findLambdaEndTokenTest() {
+        const Token* nullTok = nullptr;
+        ASSERT(nullptr == (::findLambdaEndToken)(nullTok));
         ASSERT_EQUALS(false, findLambdaEndToken("void f() { }"));
         ASSERT_EQUALS(true, findLambdaEndToken("[]{ }"));
         ASSERT_EQUALS(true, findLambdaEndToken("[]{ return 0; }"));
@@ -71,19 +81,23 @@ class TestAstUtils : public TestFixture {
         ASSERT_EQUALS(true, findLambdaEndToken("[](void) mutable -> const * int { return x; }"));
         ASSERT_EQUALS(true, findLambdaEndToken("[](void) constexpr -> const ** int { return x; }"));
         ASSERT_EQUALS(true, findLambdaEndToken("[](void) constexpr -> const * const* int { return x; }"));
+        ASSERT_EQUALS(false, findLambdaEndToken("int** a[] { new int*[2] { new int, new int} }", "[ ]"));
+        ASSERT_EQUALS(false, findLambdaEndToken("int** a[] { new int*[2] { new int, new int} }", "[ 2"));
+        ASSERT_EQUALS(false, findLambdaEndToken("shared_ptr<Type *[]> sp{ new Type *[2] {new Type, new Type}, Deleter<Type>{ 2 } };", "[ 2"));
+        ASSERT_EQUALS(true, findLambdaEndToken("int i = 5 * []{ return 7; }();", "[", /*checkNext*/ false));
     }
 
-    bool findLambdaStartToken(const char code[]) {
-        Settings settings;
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        const Token * const tokStart = ::findLambdaStartToken(tokenizer.list.back());
+#define findLambdaStartToken(...) findLambdaStartToken_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    bool findLambdaStartToken_(const char* file, int line, const char (&code)[size]) {
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+        const Token * const tokStart = (::findLambdaStartToken)(tokenizer.list.back());
         return tokStart && tokStart == tokenizer.list.front();
     }
 
-    void findLambdaStartToken() {
-        ASSERT(nullptr == ::findLambdaStartToken(nullptr));
+    void findLambdaStartTokenTest() {
+        ASSERT(nullptr == (::findLambdaStartToken)(nullptr));
         ASSERT_EQUALS(false, findLambdaStartToken("void f() { }"));
         ASSERT_EQUALS(true, findLambdaStartToken("[]{ }"));
         ASSERT_EQUALS(true, findLambdaStartToken("[]{ return 0; }"));
@@ -105,18 +119,39 @@ class TestAstUtils : public TestFixture {
         ASSERT_EQUALS(true, findLambdaStartToken("[](void) constexpr -> const * const* int { return x; }"));
     }
 
-    bool isReturnScope(const char code[], int offset) {
-        Settings settings;
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+#define isNullOperand(...) isNullOperand_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    bool isNullOperand_(const char* file, int line, const char (&code)[size]) {
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+        return (::isNullOperand)(tokenizer.tokens());
+    }
+
+    void isNullOperandTest() {
+        ASSERT_EQUALS(true, isNullOperand("(void*)0;"));
+        ASSERT_EQUALS(true, isNullOperand("(void*)0U;"));
+        ASSERT_EQUALS(true, isNullOperand("(void*)0x0LL;"));
+        ASSERT_EQUALS(true, isNullOperand("NULL;"));
+        ASSERT_EQUALS(true, isNullOperand("nullptr;"));
+        ASSERT_EQUALS(true, isNullOperand("(void*)NULL;"));
+        ASSERT_EQUALS(true, isNullOperand("static_cast<int*>(0);"));
+        ASSERT_EQUALS(false, isNullOperand("0;"));
+        ASSERT_EQUALS(false, isNullOperand("(void*)0.0;"));
+        ASSERT_EQUALS(false, isNullOperand("(void*)1;"));
+    }
+
+#define isReturnScope(...) isReturnScope_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    bool isReturnScope_(const char* file, int line, const char (&code)[size], int offset) {
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
         const Token * const tok = (offset < 0)
                                   ? tokenizer.list.back()->tokAt(1+offset)
                                   : tokenizer.tokens()->tokAt(offset);
-        return ::isReturnScope(tok);
+        return (isReturnScope)(tok, settingsDefault.library);
     }
 
-    void isReturnScope() {
+    void isReturnScopeTest() {
         ASSERT_EQUALS(true, isReturnScope("void f() { if (a) { return; } }", -2));
         ASSERT_EQUALS(true, isReturnScope("int f() { if (a) { return {}; } }", -2));                        // #8891
         ASSERT_EQUALS(true, isReturnScope("std::string f() { if (a) { return std::string{}; } }", -2));     // #8891
@@ -129,62 +164,301 @@ class TestAstUtils : public TestFixture {
         ASSERT_EQUALS(true, isReturnScope("auto f() { return [=]() { return data; }; }", -1));
         ASSERT_EQUALS(true, isReturnScope("auto f() { return [=]() { return data; }(); }", -1));
         ASSERT_EQUALS(false, isReturnScope("auto f() { [=]() { return data; }(); }", -1));
+
+        ASSERT_EQUALS(true, isReturnScope("void negativeTokenOffset() { return; }", -1));
+        ASSERT_EQUALS(false, isReturnScope("void zeroTokenOffset() { return; }", 0));
+        ASSERT_EQUALS(true, isReturnScope("void positiveTokenOffset() { return; }", 7));
+    }
+
+#define isSameExpression(...) isSameExpression_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    bool isSameExpression_(const char* file, int line, const char (&code)[size], const char tokStr1[], const char tokStr2[], bool cpp) {
+        SimpleTokenizer tokenizer(settingsDefault, *this, cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+        const Token * const tok1 = Token::findsimplematch(tokenizer.tokens(), tokStr1, strlen(tokStr1));
+        const Token * const tok2 = Token::findsimplematch(tok1->next(), tokStr2, strlen(tokStr2));
+        return (isSameExpression)(false, tok1, tok2, settingsDefault, false, true);
+    }
+
+    void isSameExpressionTestInternal(bool cpp) {
+        ASSERT_EQUALS(true,  isSameExpression("x = 1 + 1;", "1", "1", cpp));
+        ASSERT_EQUALS(false, isSameExpression("x = 1 + 1u;", "1", "1u", cpp));
+        ASSERT_EQUALS(true,  isSameExpression("x = 1.0 + 1.0;", "1.0", "1.0", cpp));
+        ASSERT_EQUALS(false, isSameExpression("x = 1.0f + 1.0;", "1.0f", "1.0", cpp));
+        ASSERT_EQUALS(false, isSameExpression("x = 1L + 1;", "1L", "1", cpp));
+        ASSERT_EQUALS(true,  isSameExpression("x = 0.0f + 0x0p+0f;", "0.0f", "0x0p+0f", cpp));
+        ASSERT_EQUALS(true,  isSameExpression("x < x;", "x", "x", cpp));
+        ASSERT_EQUALS(false, isSameExpression("x < y;", "x", "y", cpp));
+        ASSERT_EQUALS(true,  isSameExpression("(x + 1) < (x + 1);", "+", "+", cpp));
+        ASSERT_EQUALS(false, isSameExpression("(x + 1) < (x + 1L);", "+", "+", cpp));
+        ASSERT_EQUALS(!cpp,  isSameExpression("(1 + x) < (x + 1);", "+", "+", cpp));
+        ASSERT_EQUALS(false, isSameExpression("(1.0l + x) < (1.0 + x);", "+", "+", cpp));
+        ASSERT_EQUALS(!cpp,  isSameExpression("(0.0 + x) < (x + 0x0p+0);", "+", "+", cpp));
+        ASSERT_EQUALS(true,  isSameExpression("void f() {double y = 1e1; (x + y) < (x + 10.0); } ", "+", "+", cpp));
+        ASSERT_EQUALS(!cpp,  isSameExpression("void f() {double y = 1e1; (x + 10.0) < (y + x); } ", "+", "+", cpp));
+        ASSERT_EQUALS(true,  isSameExpression("void f() {double y = 1e1; double z = 10.0; (x + y) < (x + z); } ", "+", "+", cpp));
+        ASSERT_EQUALS(true,  isSameExpression("A + A", "A", "A", cpp));
+
+        // the remaining test cases are not valid C code
+        if (!cpp)
+            return;
+
+        //https://trac.cppcheck.net/ticket/9700
+        ASSERT_EQUALS(true, isSameExpression("A::B + A::B;", "::", "::", cpp));
+        ASSERT_EQUALS(false, isSameExpression("A::B + A::C;", "::", "::", cpp));
+        ASSERT_EQUALS(true, isSameExpression("A::B* get() { if(x) return new A::B(true); else return new A::B(true); }", "new", "new", cpp));
+        ASSERT_EQUALS(false, isSameExpression("A::B* get() { if(x) return new A::B(true); else return new A::C(true); }", "new", "new", cpp));
     }
 
-    bool isVariableChanged(const char code[], const char startPattern[], const char endPattern[]) {
-        Settings settings;
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        const Token * const tok1 = Token::findsimplematch(tokenizer.tokens(), startPattern);
-        const Token * const tok2 = Token::findsimplematch(tokenizer.tokens(), endPattern);
-        return ::isVariableChanged(tok1,tok2,1,false,&settings,true);
+    void isSameExpressionCpp() {
+        isSameExpressionTestInternal(true);
     }
 
-    void isVariableChanged() {
+    void isSameExpressionC() {
+        isSameExpressionTestInternal(false);
+    }
+
+#define isVariableChanged(...) isVariableChanged_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    bool isVariableChanged_(const char* file, int line, const char (&code)[size], const char startPattern[], const char endPattern[]) {
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+        const Token * const tok1 = Token::findsimplematch(tokenizer.tokens(), startPattern, strlen(startPattern));
+        const Token * const tok2 = Token::findsimplematch(tokenizer.tokens(), endPattern, strlen(endPattern));
+        return (isVariableChanged)(tok1, tok2, 1, false, settingsDefault);
+    }
+
+    void isVariableChangedTest() {
         // #8211 - no lhs for >> , do not crash
-        isVariableChanged("void f() {\n"
-                          "  int b;\n"
-                          "  if (b) { (int)((INTOF(8))result >> b); }\n"
-                          "}", "if", "}");
+        (void)isVariableChanged("void f() {\n"
+                                "  int b;\n"
+                                "  if (b) { (int)((INTOF(8))result >> b); }\n"
+                                "}", "if", "}");
         // #9235
-        ASSERT_EQUALS(true, isVariableChanged("void f() {\n"
-                                              "    int &a = a;\n"
-                                              "}\n", "= a", "}"));
+        ASSERT_EQUALS(false,
+                      isVariableChanged("void f() {\n"
+                                        "    int &a = a;\n"
+                                        "}\n",
+                                        "= a",
+                                        "}"));
+
+        ASSERT_EQUALS(false, isVariableChanged("void f(const A& a) { a.f(); }", "{", "}"));
+        ASSERT_EQUALS(true,
+                      isVariableChanged("void g(int*);\n"
+                                        "void f(int x) { g(&x); }\n",
+                                        "{",
+                                        "}"));
+        ASSERT_EQUALS(false, isVariableChanged("const int A[] = { 1, 2, 3 };", "[", "]"));
     }
 
-    bool isVariableChangedByFunctionCall(const char code[], const char pattern[], bool *inconclusive) {
-        Settings settings;
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+#define isVariableChangedByFunctionCall(...) isVariableChangedByFunctionCall_( __FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    bool isVariableChangedByFunctionCall_(const char* file, int line, const char (&code)[size], const char pattern[], bool *inconclusive) {
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
         const Token * const argtok = Token::findmatch(tokenizer.tokens(), pattern);
-        return ::isVariableChangedByFunctionCall(argtok, 0, &settings, inconclusive);
+        ASSERT_LOC(argtok, file, line);
+        int indirect = (argtok->variable() && argtok->variable()->isArray());
+        return (isVariableChangedByFunctionCall)(argtok, indirect, settingsDefault, inconclusive);
+    }
+
+    void isVariableChangedByFunctionCallTest() {
+
+        { // #8271 - template method
+            const char code[] = "void f(int x) {\n"
+                                "  a<int>(x);\n"
+                                "}";
+            bool inconclusive = false;
+            ASSERT_EQUALS(false, isVariableChangedByFunctionCall(code, "x ) ;", &inconclusive));
+            ASSERT_EQUALS(true, inconclusive);
+        }
+
+        {
+            const char code[] = "int f(int x) {\n"
+                                "return int(x);\n"
+                                "}\n";
+            bool inconclusive = false;
+            ASSERT_EQUALS(false, isVariableChangedByFunctionCall(code, "x ) ;", &inconclusive));
+            ASSERT_EQUALS(false, inconclusive);
+        }
+
+        {
+            const char code[] = "void g(int* p);\n"
+                                "void f(int x) {\n"
+                                "    return g(&x);\n"
+                                "}\n";
+            bool inconclusive = false;
+            ASSERT_EQUALS(true, isVariableChangedByFunctionCall(code, "x ) ;", &inconclusive));
+            ASSERT_EQUALS(false, inconclusive);
+        }
+
+        {
+            const char code[] = "void g(const int* p);\n"
+                                "void f(int x) {\n"
+                                "    return g(&x);\n"
+                                "}\n";
+            bool inconclusive = false;
+            ASSERT_EQUALS(false, isVariableChangedByFunctionCall(code, "x ) ;", &inconclusive));
+            ASSERT_EQUALS(false, inconclusive);
+        }
+
+        {
+            const char code[] = "void g(int** pp);\n"
+                                "void f(int* p) {\n"
+                                "    return g(&p);\n"
+                                "}\n";
+            bool inconclusive = false;
+            ASSERT_EQUALS(true, isVariableChangedByFunctionCall(code, "p ) ;", &inconclusive));
+            ASSERT_EQUALS(false, inconclusive);
+        }
+
+        {
+            const char code[] = "void g(int* const* pp);\n"
+                                "void f(int* p) {\n"
+                                "    return g(&p);\n"
+                                "}\n";
+            bool inconclusive = false;
+            ASSERT_EQUALS(false, isVariableChangedByFunctionCall(code, "p ) ;", &inconclusive));
+            ASSERT_EQUALS(false, inconclusive);
+        }
+
+        {
+            const char code[] = "void g(int a[2]);\n"
+                                "void f() {\n"
+                                "    int b[2] = {};\n"
+                                "    return g(b);\n"
+                                "}\n";
+            bool inconclusive = false;
+            ASSERT_EQUALS(true, isVariableChangedByFunctionCall(code, "b ) ;", &inconclusive));
+            ASSERT_EQUALS(false, inconclusive);
+        }
+
+        {
+            const char code[] = "void g(const int a[2]);\n"
+                                "void f() {\n"
+                                "    int b[2] = {};\n"
+                                "    return g(b);\n"
+                                "}\n";
+            bool inconclusive = false;
+            TODO_ASSERT_EQUALS(false, true, isVariableChangedByFunctionCall(code, "b ) ;", &inconclusive));
+            ASSERT_EQUALS(false, inconclusive);
+        }
+
+        {
+            const char code[] = "void g(std::array<int, 2> a);\n"
+                                "void f() {\n"
+                                "    std::array<int, 2> b = {};\n"
+                                "    return g(b);\n"
+                                "}\n";
+            bool inconclusive = false;
+            ASSERT_EQUALS(false, isVariableChangedByFunctionCall(code, "b ) ;", &inconclusive));
+            ASSERT_EQUALS(false, inconclusive);
+        }
+
+        {
+            const char code[] = "void g(std::array<int, 2>& a);\n"
+                                "void f() {\n"
+                                "    std::array<int, 2> b = {};\n"
+                                "    return g(b);\n"
+                                "}\n";
+            bool inconclusive = false;
+            ASSERT_EQUALS(true, isVariableChangedByFunctionCall(code, "b ) ;", &inconclusive));
+            ASSERT_EQUALS(false, inconclusive);
+        }
+
+        {
+            const char code[] = "void g(const std::array<int, 2>& a);\n"
+                                "void f() {\n"
+                                "    std::array<int, 2> b = {};\n"
+                                "    return g(b);\n"
+                                "}\n";
+            bool inconclusive = false;
+            ASSERT_EQUALS(false, isVariableChangedByFunctionCall(code, "b ) ;", &inconclusive));
+            ASSERT_EQUALS(false, inconclusive);
+        }
+
+        {
+            const char code[] = "void g(std::array<int, 2>* p);\n"
+                                "void f() {\n"
+                                "    std::array<int, 2> b = {};\n"
+                                "    return g(&b);\n"
+                                "}\n";
+            bool inconclusive = false;
+            ASSERT_EQUALS(true, isVariableChangedByFunctionCall(code, "b ) ;", &inconclusive));
+            ASSERT_EQUALS(false, inconclusive);
+        }
+
+        {
+            const char code[] = "struct S {};\n"
+                                "void g(S);\n"
+                                "void f(S* s) {\n"
+                                "    g(*s);\n"
+                                "}\n";
+            bool inconclusive = false;
+            ASSERT_EQUALS(false, isVariableChangedByFunctionCall(code, "s ) ;", &inconclusive));
+            ASSERT_EQUALS(false, inconclusive);
+        }
+
+        {
+            const char code[] = "struct S {};\n"
+                                "void g(const S&);\n"
+                                "void f(S* s) {\n"
+                                "    g(*s);\n"
+                                "}\n";
+            bool inconclusive = false;
+            ASSERT_EQUALS(false, isVariableChangedByFunctionCall(code, "s ) ;", &inconclusive));
+            ASSERT_EQUALS(false, inconclusive);
+        }
+    }
+
+#define isExpressionChanged(...) isExpressionChanged_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    bool isExpressionChanged_(const char* file,
+                              int line,
+                              const char (&code)[size],
+                              const char var[],
+                              const char startPattern[],
+                              const char endPattern[])
+    {
+        const Settings settings = settingsBuilder().library("std.cfg").build();
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+        const Token* const start = Token::findsimplematch(tokenizer.tokens(), startPattern, strlen(startPattern));
+        const Token* const end = Token::findsimplematch(start, endPattern, strlen(endPattern));
+        const Token* const expr = Token::findsimplematch(tokenizer.tokens(), var, strlen(var));
+        return (findExpressionChanged)(expr, start, end, settings);
     }
 
-    void isVariableChangedByFunctionCall() {
-        const char *code;
-        bool inconclusive;
+    void isExpressionChangedTest()
+    {
+        ASSERT_EQUALS(true, isExpressionChanged("void f(std::map<int, int>& m) { m[0]; }", "m [", "{", "}"));
+        ASSERT_EQUALS(false, isExpressionChanged("void f(const A& a) { a.f(); }", "a .", "{", "}"));
+
+        ASSERT_EQUALS(true,
+                      isExpressionChanged("void g(int*);\n"
+                                          "void f(int x) { g(&x); }\n",
+                                          "x",
+                                          ") {",
+                                          "}"));
 
-        // #8271 - template method
-        code = "void f(int x) {\n"
-               "  a<int>(x);\n"
-               "}";
-        inconclusive = false;
-        ASSERT_EQUALS(false, isVariableChangedByFunctionCall(code, "x ) ;", &inconclusive));
-        ASSERT_EQUALS(true, inconclusive);
+        ASSERT_EQUALS(true,
+                      isExpressionChanged("struct S { void f(); int i; };\n"
+                                          "void call_f(S& s) { (s.*(&S::f))(); }\n",
+                                          "s .",
+                                          "{ (",
+                                          "}"));
     }
 
-    bool nextAfterAstRightmostLeaf(const char code[], const char parentPattern[], const char rightPattern[]) {
-        Settings settings;
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        const Token * tok = Token::findsimplematch(tokenizer.tokens(), parentPattern);
-        return Token::simpleMatch(::nextAfterAstRightmostLeaf(tok), rightPattern);
+#define nextAfterAstRightmostLeaf(...) nextAfterAstRightmostLeaf_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    bool nextAfterAstRightmostLeaf_(const char* file, int line, const char (&code)[size], const char parentPattern[], const char rightPattern[]) {
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+        const Token * tok = Token::findsimplematch(tokenizer.tokens(), parentPattern, strlen(parentPattern));
+        return Token::simpleMatch((::nextAfterAstRightmostLeaf)(tok), rightPattern, strlen(rightPattern));
     }
 
-    void nextAfterAstRightmostLeaf() {
+    void nextAfterAstRightmostLeafTest() {
         ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("void f(int a, int b) { int x = a + b; }", "=", "; }"));
         ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("int * g(int); void f(int a, int b) { int x = g(a); }", "=", "; }"));
         ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("int * g(int); void f(int a, int b) { int x = g(a)[b]; }", "=", "; }"));
@@ -197,6 +471,53 @@ class TestAstUtils : public TestFixture {
         ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("int * g(int); void f(int a, int b) { int x = g(a)[b + 1]; }", "+", "] ; }"));
         ASSERT_EQUALS(true, nextAfterAstRightmostLeaf("int * g(int); void f(int a, int b) { int x = g(a + 1)[b]; }", "+", ") ["));
     }
+
+    enum class Result : std::uint8_t {False, True, Fail};
+
+    template<size_t size>
+    Result isUsedAsBool(const char (&code)[size], const char pattern[]) {
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        if (!tokenizer.tokenize(code))
+            return Result::Fail;
+        const Token * const argtok = Token::findmatch(tokenizer.tokens(), pattern);
+        if (!argtok)
+            return Result::Fail;
+        return ::isUsedAsBool(argtok, settingsDefault) ? Result::True : Result::False;
+    }
+
+    void isUsedAsBool() {
+        ASSERT(Result::True == isUsedAsBool("void f() { bool b = true; }", "b"));
+        ASSERT(Result::False ==isUsedAsBool("void f() { int i = true; }", "i"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (i) {} }", "i )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; while (i) {} }", "i )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; for (;i;) {} }", "i ; )"));
+        ASSERT(Result::False == isUsedAsBool("void f() { int i; for (;;i) {} }", "i )"));
+        ASSERT(Result::False == isUsedAsBool("void f() { int i; for (i;;) {} }", "i ; ; )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; for (int j=0; i; ++j) {} }", "i ; ++"));
+        ASSERT(Result::False == isUsedAsBool("void f() { int i; if (i == 2) {} }", "i =="));
+        ASSERT(Result::False == isUsedAsBool("void f() { int i; if (i == true) {} }", "i =="));
+        ASSERT(Result::False == isUsedAsBool("void f() { int i,j; if (i == (j&&f())) {} }", "i =="));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (!i == 0) {} }", "i =="));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (!i) {} }", "i )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (!!i) {} }", "i )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (i && f()) {} }", "i &&"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; int j = i && f(); }", "i &&"));
+        ASSERT(Result::False == isUsedAsBool("void f() { int i; if (i & f()) {} }", "i &"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (static_cast<bool>(i)) {} }", "i )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; if ((bool)i) {} }", "i )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (1+static_cast<bool>(i)) {} }", "i )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (1+(bool)i) {} }", "i )"));
+        ASSERT(Result::False == isUsedAsBool("void f() { int i; if (1+static_cast<int>(i)) {} }", "i )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; if (1+!static_cast<int>(i)) {} }", "i )"));
+        ASSERT(Result::False == isUsedAsBool("void f() { int i; if (1+(int)i) {} }", "i )"));
+        ASSERT(Result::False == isUsedAsBool("void f() { int i; if (i + 2) {} }", "i +"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int i; bool b = i; }", "i ; }"));
+        ASSERT(Result::True == isUsedAsBool("void f(bool b); void f() { int i; f(i); }","i )"));
+        ASSERT(Result::False == isUsedAsBool("void f() { int *i; if (*i) {} }", "i )"));
+        ASSERT(Result::True == isUsedAsBool("void f() { int *i; if (*i) {} }", "* i )"));
+        ASSERT(Result::True == isUsedAsBool("int g(); void h(bool); void f() { h(g()); }", "( ) )"));
+        ASSERT(Result::True == isUsedAsBool("int g(int); void h(bool); void f() { h(g(0)); }", "( 0 ) )"));
+    }
 };
 
 REGISTER_TEST(TestAstUtils)
diff --git a/test/testautovariables.cpp b/test/testautovariables.cpp
index e41f7cd44f9..bcdba7ca0dc 100644
--- a/test/testautovariables.cpp
+++ b/test/testautovariables.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,41 +16,42 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include "checkautovariables.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
 
+#include <cstddef>
 
 class TestAutoVariables : public TestFixture {
 public:
-    TestAutoVariables() : TestFixture("TestAutoVariables") {
-    }
+    TestAutoVariables() : TestFixture("TestAutoVariables") {}
 
 private:
-    Settings settings;
+    const Settings settings = settingsBuilder().severity(Severity::warning).severity(Severity::style).library("std.cfg").library("qt.cfg").build();
+    const Settings settings_i = settingsBuilder(settings).certainty(Certainty::inconclusive).build();
 
-    void check(const char code[], bool inconclusive = false, const char* filename = "test.cpp") {
-        // Clear the error buffer..
-        errout.str("");
+    struct CheckOptions
+    {
+        bool inconclusive = true;
+        bool cpp = true;
+    };
 
-        settings.inconclusive = inconclusive;
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
+        const Settings &settings1 = options.inconclusive ? settings_i : settings;
 
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, filename);
+        SimpleTokenizer tokenizer(settings1, *this, options.cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
-        CheckAutoVariables checkAutoVariables;
-        checkAutoVariables.runChecks(&tokenizer, &settings, this);
+        runChecks<CheckAutoVariables>(tokenizer, this);
     }
 
-    void run() OVERRIDE {
-        settings.addEnabled("warning");
-        settings.addEnabled("style");
-        LOAD_LIB_2(settings.library, "std.cfg");
-
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(testautovar1);
         TEST_CASE(testautovar2);
         TEST_CASE(testautovar3); // ticket #2925
@@ -67,16 +68,24 @@ class TestAutoVariables : public TestFixture {
         TEST_CASE(testautovar14); // ticket #4776 - assignment of function parameter, goto
         TEST_CASE(testautovar15); // ticket #6538
         TEST_CASE(testautovar16); // ticket #8114
+        TEST_CASE(testautovar17);
+        TEST_CASE(testautovar18);
         TEST_CASE(testautovar_array1);
         TEST_CASE(testautovar_array2);
+        TEST_CASE(testautovar_array3);
         TEST_CASE(testautovar_normal); // "normal" token list that does not remove casts etc
         TEST_CASE(testautovar_ptrptr); // ticket #6956
         TEST_CASE(testautovar_return1);
         TEST_CASE(testautovar_return2);
         TEST_CASE(testautovar_return3);
         TEST_CASE(testautovar_return4);
+        TEST_CASE(testautovar_return5);
+        TEST_CASE(testautovar_return6);
         TEST_CASE(testautovar_extern);
+        TEST_CASE(testautovar_reassigned);
         TEST_CASE(testinvaliddealloc);
+        TEST_CASE(testinvaliddealloc_input); // Ticket #10600
+        TEST_CASE(testinvaliddealloc_string);
         TEST_CASE(testinvaliddealloc_C);
         TEST_CASE(testassign1);  // Ticket #1819
         TEST_CASE(testassign2);  // Ticket #2765
@@ -100,6 +109,28 @@ class TestAutoVariables : public TestFixture {
         TEST_CASE(returnReference5);
         TEST_CASE(returnReference6);
         TEST_CASE(returnReference7);
+        TEST_CASE(returnReference8);
+        TEST_CASE(returnReference9);
+        TEST_CASE(returnReference10);
+        TEST_CASE(returnReference11);
+        TEST_CASE(returnReference12);
+        TEST_CASE(returnReference13);
+        TEST_CASE(returnReference14);
+        TEST_CASE(returnReference15); // #9432
+        TEST_CASE(returnReference16); // #9433
+        TEST_CASE(returnReference16); // #9433
+        TEST_CASE(returnReference17); // #9461
+        TEST_CASE(returnReference18); // #9482
+        TEST_CASE(returnReference19); // #9597
+        TEST_CASE(returnReference20); // #9536
+        TEST_CASE(returnReference21); // #9530
+        TEST_CASE(returnReference22);
+        TEST_CASE(returnReference23);
+        TEST_CASE(returnReference24); // #10098
+        TEST_CASE(returnReference25); // #10983
+        TEST_CASE(returnReference26);
+        TEST_CASE(returnReference27);
+        TEST_CASE(returnReference28);
         TEST_CASE(returnReferenceFunction);
         TEST_CASE(returnReferenceContainer);
         TEST_CASE(returnReferenceLiteral);
@@ -107,8 +138,10 @@ class TestAutoVariables : public TestFixture {
         TEST_CASE(returnReferenceLambda);
         TEST_CASE(returnReferenceInnerScope);
         TEST_CASE(returnReferenceRecursive);
+        TEST_CASE(extendedLifetime);
 
         TEST_CASE(danglingReference);
+        TEST_CASE(danglingTempReference);
 
         // global namespace
         TEST_CASE(testglobalnamespace);
@@ -121,13 +154,21 @@ class TestAutoVariables : public TestFixture {
 
         TEST_CASE(danglingLifetimeLambda);
         TEST_CASE(danglingLifetimeContainer);
+        TEST_CASE(danglingLifetimeContainerView);
+        TEST_CASE(danglingLifetimeUniquePtr);
         TEST_CASE(danglingLifetime);
         TEST_CASE(danglingLifetimeFunction);
-        TEST_CASE(danglingLifetimeAggegrateConstructor);
+        TEST_CASE(danglingLifetimeUserConstructor);
+        TEST_CASE(danglingLifetimeAggregateConstructor);
         TEST_CASE(danglingLifetimeInitList);
         TEST_CASE(danglingLifetimeImplicitConversion);
+        TEST_CASE(danglingTemporaryLifetime);
+        TEST_CASE(danglingLifetimeBorrowedMembers);
+        TEST_CASE(danglingLifetimeClassMemberFunctions);
         TEST_CASE(invalidLifetime);
         TEST_CASE(deadPointer);
+        TEST_CASE(splitNamespaceAuto); // crash #10473
+        TEST_CASE(incompleteTypeArray);
     }
 
 
@@ -138,21 +179,21 @@ class TestAutoVariables : public TestFixture {
               "    int num = 2;\n"
               "    *res = &num;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Address of local auto-variable assigned to a function parameter.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
 
         check("void func1(int **res)\n"
               "{\n"
               "    int num = 2;\n"
               "    res = &num;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Assignment of function parameter has no effect outside the function. Did you forget dereferencing it?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Assignment of function parameter has no effect outside the function. Did you forget dereferencing it? [uselessAssignmentPtrArg]\n", errout_str());
 
         check("void func1(int **res)\n"
               "{\n"
               "    int num = 2;\n"
               "    foo.res = &num;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testautovar2() {
@@ -164,7 +205,7 @@ class TestAutoVariables : public TestFixture {
               "    int num = 2;\n"
               "    *res = &num;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Address of local auto-variable assigned to a function parameter.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
 
         check("class Fred {\n"
               "    void func1(int **res);\n"
@@ -174,7 +215,7 @@ class TestAutoVariables : public TestFixture {
               "    int num = 2;\n"
               "    res = &num;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (warning) Assignment of function parameter has no effect outside the function. Did you forget dereferencing it?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:5]: (warning) Assignment of function parameter has no effect outside the function. Did you forget dereferencing it? [uselessAssignmentPtrArg]\n", errout_str());
 
         check("class Fred {\n"
               "    void func1(int **res);\n"
@@ -184,7 +225,7 @@ class TestAutoVariables : public TestFixture {
               "    int num = 2;\n"
               "    foo.res = &num;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testautovar3() { // ticket #2925
@@ -193,7 +234,7 @@ class TestAutoVariables : public TestFixture {
               "    int x[100];\n"
               "    *p = x;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Address of local auto-variable assigned to a function parameter.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
     }
 
     void testautovar4() { // ticket #2928
@@ -202,7 +243,7 @@ class TestAutoVariables : public TestFixture {
               "    static int x[100];\n"
               "    *p = x;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testautovar5() { // ticket #2926
@@ -211,7 +252,7 @@ class TestAutoVariables : public TestFixture {
               "    char a;\n"
               "    ab->a = &a;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Address of local auto-variable assigned to a function parameter.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (error, inconclusive) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
     }
 
     void testautovar6() { // ticket #2931
@@ -219,15 +260,15 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    char a[10];\n"
               "    x->str = a;\n"
-              "}", false);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(struct X *x)\n"
               "{\n"
               "    char a[10];\n"
               "    x->str = a;\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:4]: (error, inconclusive) Address of local auto-variable assigned to a function parameter.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:5]: (error, inconclusive) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
     }
 
     void testautovar7() { // ticket #3066
@@ -236,21 +277,21 @@ class TestAutoVariables : public TestFixture {
               "    struct txt_scrollpane_s * scrollpane;\n"
               "    target->parent = &scrollpane->widget;\n"
               "    return scrollpane;\n"
-              "}", false);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testautovar8() {
         check("void foo(int*& p) {\n"
               "    int i = 0;\n"
               "    p = &i;\n"
-              "}", false);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Address of local auto-variable assigned to a function parameter.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
 
         check("void foo(std::string& s) {\n"
               "    s = foo;\n"
-              "}", false);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testautovar9() {
@@ -260,103 +301,119 @@ class TestAutoVariables : public TestFixture {
               "    FN fn;\n"
               "    FP fp;\n"
               "    p = &fn.i;\n"
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:6:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
+
+        check("struct FN {int i;};\n"
+              "struct FP {FN* f};\n"
+              "void foo(int*& p, FN* p_fp) {\n"
+              "    FN fn;\n"
+              "    FP fp;\n"
               "    p = &p_fp->i;\n"
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct FN {int i;};\n"
+              "struct FP {FN* f};\n"
+              "void foo(int*& p, FN* p_fp) {\n"
+              "    FN fn;\n"
+              "    FP fp;\n"
               "    p = &fp.f->i;\n"
-              "}", false);
-        ASSERT_EQUALS("[test.cpp:6]: (error) Address of local auto-variable assigned to a function parameter.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testautovar10() { // #2930 - assignment of function parameter
         check("void foo(char* p) {\n"
               "    p = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Assignment of function parameter has no effect outside the function. Did you forget dereferencing it?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning) Assignment of function parameter has no effect outside the function. Did you forget dereferencing it? [uselessAssignmentPtrArg]\n", errout_str());
 
         check("void foo(int b) {\n"
               "    b = foo(b);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Assignment of function parameter has no effect outside the function.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (style) Assignment of function parameter has no effect outside the function. [uselessAssignmentArg]\n", errout_str());
 
         check("void foo(int b) {\n"
               "    b += 1;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Assignment of function parameter has no effect outside the function.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (style) Assignment of function parameter has no effect outside the function. [uselessAssignmentArg]\n", errout_str());
 
         check("void foo(std::string s) {\n"
               "    s = foo(b);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Assignment of function parameter has no effect outside the function.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (style) Assignment of function parameter has no effect outside the function. [uselessAssignmentArg]\n", errout_str());
 
         check("void foo(char* p) {\n" // don't warn for self assignment, there is another warning for this
               "  p = p;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(char* p) {\n"
               "    if (!p) p = buf;\n"
               "    *p = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(char* p) {\n"
               "    if (!p) p = buf;\n"
               "    do_something(p);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(char* p) {\n"
               "    while (!p) p = buf;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(char* p) {\n"
               "    p = 0;\n"
               "    asm(\"somecmd\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(Foo* p) {\n"
               "    p = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Assignment of function parameter has no effect outside the function. Did you forget dereferencing it?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning) Assignment of function parameter has no effect outside the function. Did you forget dereferencing it? [uselessAssignmentPtrArg]\n", errout_str());
 
         check("class Foo {};\n"
               "void foo(Foo p) {\n"
               "    p = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Assignment of function parameter has no effect outside the function.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (style) Assignment of function parameter has no effect outside the function. [uselessAssignmentArg]\n", errout_str());
 
         check("void foo(Foo p) {\n"
               "    p = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int& p) {\n"
               "    p = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("double foo(double d) {\n" // #5005
               "    int i = d;\n"
               "    d = i;\n"
               "    return d;"
-              "}",false);
-        ASSERT_EQUALS("", errout.str());
+              "}",dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int* ptr) {\n" // #4793
               "    ptr++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Assignment of function parameter has no effect outside the function. Did you forget dereferencing it?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning) Assignment of function parameter has no effect outside the function. Did you forget dereferencing it? [uselessAssignmentPtrArg]\n", errout_str());
 
         check("void foo(int* ptr) {\n" // #3177
               "    --ptr;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Assignment of function parameter has no effect outside the function. Did you forget dereferencing it?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:7]: (warning) Assignment of function parameter has no effect outside the function. Did you forget dereferencing it? [uselessAssignmentPtrArg]\n", errout_str());
 
         check("void foo(struct S* const x) {\n" // #7839
               "    ++x->n;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testautovar11() { // #4641 - fp, assign local struct member address to function parameter
@@ -367,7 +424,7 @@ class TestAutoVariables : public TestFixture {
               "    struct A a = bar();\n"
               "    *p = &(*a.data)[0];\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
               "    char data[10];\n"
@@ -376,30 +433,30 @@ class TestAutoVariables : public TestFixture {
               "    struct A a = bar();\n"
               "    *p = &a.data[0];\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Address of local auto-variable assigned to a function parameter.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
 
         check("void f(char **out) {\n"
               "  struct S *p = glob;\n"
               "  *out = &p->data;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #4998
         check("void f(s8**out) {\n"
               "  s8 *p;\n"  // <- p is pointer => no error
               "  *out = &p[1];\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(s8**out) {\n"
               "  s8 p[10];\n"  // <- p is array => error
               "  *out = &p[1];\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Address of local auto-variable assigned to a function parameter.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:3]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
     }
 
     void testautovar12() { // Ticket #5024, #5050 - Crash on invalid input
-        ASSERT_THROW(check("void f(int* a) { a = }"), InternalError);
+        ASSERT_THROW_INTERNAL(check("void f(int* a) { a = }"), SYNTAX);
         check("struct custom_type { custom_type(int) {} };\n"
               "void func(int) {}\n"
               "int var;\n"
@@ -414,7 +471,7 @@ class TestAutoVariables : public TestFixture {
               "  ~FileManager() {\n"
               "    delete &UniqueRealDirs;\n"
               "   }\n"
-              "};\n");
+              "};");
     }
 
     void testautovar14() { // Ticket #4776
@@ -425,7 +482,7 @@ class TestAutoVariables : public TestFixture {
               "    goto label;\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testautovar15() { // Ticket #6538
@@ -437,8 +494,8 @@ class TestAutoVariables : public TestFixture {
               "    if (lumdiff > 5.0f)\n"
               "        return &darkOutline;\n"
               "    return 0;\n"
-              "}", false);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testautovar16() { // Ticket #8114
@@ -446,7 +503,27 @@ class TestAutoVariables : public TestFixture {
               "  int dummy;\n"
               "  *result = (&dummy < ptr);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void testautovar17() {
+        check("struct S { int* p; };\n" // #14257
+              "int a[10];\n"
+              "void f(int** q) {\n"
+              "    S s;\n"
+              "    s.p = a;\n"
+              "    *q = &s.p[0];\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void testautovar18() {
+        check("struct S { int* p; };\n"
+              "void foo(struct S* s) {\n"
+              "    int x;\n"
+              "    s[2].p = &x;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
     }
 
     void testautovar_array1() {
@@ -455,7 +532,7 @@ class TestAutoVariables : public TestFixture {
               "    int num=2;"
               "    arr[0]=&num;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Address of local auto-variable assigned to a function parameter.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:19]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
     }
 
     void testautovar_array2() {
@@ -467,7 +544,49 @@ class TestAutoVariables : public TestFixture {
               "    int num=2;"
               "    arr[0]=&num;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Address of local auto-variable assigned to a function parameter.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:19]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
+    }
+
+    void testautovar_array3() {
+        check("int main(int argc, char* argv[]) {\n" // #11732
+              "    std::string a = \"abc\";\n"
+              "    argv[0] = &a[0];\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(char* c[]) {\n"
+              "    char a[] = \"abc\";\n"
+              "    c[0] = a;\n"
+              "}\n"
+              "void g(char* c[]) {\n"
+              "    std::string a = \"abc\";\n"
+              "    c[0] = a.data();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n"
+                      "[test.cpp:7:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n",
+                      errout_str());
+
+        check("struct String {\n"
+              "    String& operator=(const char* c) { m = c; return *this; }\n"
+              "    std::string m;\n"
+              "};\n"
+              "struct T { String s; };\n"
+              "void f(T* t) {\n"
+              "    char a[] = \"abc\";\n"
+              "    t->s = &a[0];\n"
+              "}\n"
+              "void g(std::string* s) {\n"
+              "    char a[] = \"abc\";\n"
+              "    *s = &a[0];\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int* p[]) {\n" // #7167
+              "    int a[4] = { 1, 2, 3 };\n"
+              "    p[0] = a;\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n",
+                      errout_str());
     }
 
     void testautovar_normal() {
@@ -476,7 +595,7 @@ class TestAutoVariables : public TestFixture {
               "    XPoint DropPoint;\n"
               "    ds->location_data = (XtPointer *)&DropPoint;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Address of local auto-variable assigned to a function parameter.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (error, inconclusive) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
     }
 
     void testautovar_ptrptr() { // #6596
@@ -484,7 +603,7 @@ class TestAutoVariables : public TestFixture {
               "  char dead_slot;\n"
               "  matches[0] = (char *)&dead_slot;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Address of local auto-variable assigned to a function parameter.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:3]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
     }
 
     void testautovar_return1() {
@@ -493,7 +612,7 @@ class TestAutoVariables : public TestFixture {
               "    int num=2;"
               "    return &num;"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:3] -> [test.cpp:3]: (error) Returning pointer to local variable 'num' that will be invalid when returning.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:26] -> [test.cpp:3:9] -> [test.cpp:3:26]: (error) Returning pointer to local variable 'num' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
     }
 
     void testautovar_return2() {
@@ -505,7 +624,7 @@ class TestAutoVariables : public TestFixture {
               "    int num=2;"
               "    return &num;"
               "}");
-        ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:6] -> [test.cpp:6]: (error) Returning pointer to local variable 'num' that will be invalid when returning.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:26] -> [test.cpp:6:9] -> [test.cpp:6:26]: (error) Returning pointer to local variable 'num' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
     }
 
     void testautovar_return3() {
@@ -515,7 +634,7 @@ class TestAutoVariables : public TestFixture {
               "    void *&value = tls[id];"
               "    return &value;"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testautovar_return4() {
@@ -524,7 +643,35 @@ class TestAutoVariables : public TestFixture {
               "  int cond2;\n"
               "  dostuff([&cond2]() { return &cond2; });\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void testautovar_return5() { // #11465
+        check("struct S {};\n"
+              "const std::type_info* f() {\n"
+              "    return &typeid(S);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void testautovar_return6() { // #14005
+        check("struct S;\n"
+              "struct T { const struct S *s; };\n"
+              "extern struct T factory();\n"
+              "const struct S* f() {\n"
+              "    struct T t = factory();\n"
+              "    return &t.s[0];\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S;\n"
+              "struct T { std::vector<struct S> v; };\n"
+              "extern struct T factory();\n"
+              "const struct S* f() {\n"
+              "    struct T t = factory();\n"
+              "    return &t.v[0];\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:12] -> [test.cpp:5:14] -> [test.cpp:6:12]: (error) Returning pointer to local variable 't' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
     }
 
     void testautovar_extern() {
@@ -533,7 +680,49 @@ class TestAutoVariables : public TestFixture {
               "    extern struct foo f;\n"
               "    return &f;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void testautovar_reassigned() {
+        check("void foo(cb* pcb) {\n"
+              "  int root0;\n"
+              "  pcb->root0 = &root0;\n"
+              "  dostuff(pcb);\n"
+              "  pcb->root0 = 0;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo(cb* pcb) {\n"
+              "  int root0;\n"
+              "  pcb->root0 = &root0;\n"
+              "  dostuff(pcb);\n"
+              "  if (condition) return;\n" // <- not reassigned => error
+              "  pcb->root0 = 0;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:3]: (error, inconclusive) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
+
+        check("void foo(cb* pcb) {\n"
+              "  int root0;\n"
+              "  pcb->root0 = &root0;\n"
+              "  dostuff(pcb);\n"
+              "  if (condition)\n"
+              "    pcb->root0 = 0;\n"  // <- conditional reassign => error
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:3]: (error, inconclusive) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
+
+        check("struct S { int *p; };\n"
+              "void g(struct S* s) {\n"
+              "    int a[10];\n"
+              "    s->p = a;\n"
+              "    a[0] = 0;\n"
+              "}\n"
+              "void f() {\n"
+              "    struct S s;\n"
+              "    g(&s);\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:4:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n",
+            errout_str());
     }
 
     void testinvaliddealloc() {
@@ -549,32 +738,37 @@ class TestAutoVariables : public TestFixture {
               "    char tmp5[256];\n"
               "    delete[] tmp5;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Deallocation of an auto-variable results in undefined behaviour.\n"
-                      "[test.cpp:5]: (error) Deallocation of an auto-variable results in undefined behaviour.\n"
-                      "[test.cpp:7]: (error) Deallocation of an auto-variable results in undefined behaviour.\n"
-                      "[test.cpp:9]: (error) Deallocation of an auto-variable results in undefined behaviour.\n"
-                      "[test.cpp:11]: (error) Deallocation of an auto-variable results in undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (error) Deallocation of an auto-variable results in undefined behaviour. [autovarInvalidDeallocation]\n"
+                      "[test.cpp:5:12]: (error) Deallocation of an auto-variable results in undefined behaviour. [autovarInvalidDeallocation]\n"
+                      "[test.cpp:7:12]: (error) Deallocation of an auto-variable results in undefined behaviour. [autovarInvalidDeallocation]\n"
+                      "[test.cpp:9:15]: (error) Deallocation of an auto-variable results in undefined behaviour. [autovarInvalidDeallocation]\n"
+                      "[test.cpp:11:14]: (error) Deallocation of an auto-variable results in undefined behaviour. [autovarInvalidDeallocation]\n", errout_str());
+
+        check("void func1(char * ptr) {\n"
+              "    free(ptr);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void func1() {\n"
               "    char* tmp1[256];\n"
               "    init(tmp1);\n"
               "    delete tmp1[34];\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void func1() {\n"
               "    static char tmp1[256];\n"
               "    char *p = tmp1;\n"
               "    free(p);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Deallocation of an static variable (tmp1) results in undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:10]: (error) Deallocation of a static variable (tmp1) results in undefined behaviour. [autovarInvalidDeallocation]\n", errout_str());
 
         check("char tmp1[256];\n"
               "void func1() {\n"
               "    char *p; if (x) p = tmp1;\n"
               "    free(p);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Deallocation of an global variable (tmp1) results in undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:10]: (error) Deallocation of a global variable (tmp1) results in undefined behaviour. [autovarInvalidDeallocation]\n", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -585,7 +779,7 @@ class TestAutoVariables : public TestFixture {
               "        free(psz_title);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #2298 new check: passing stack-address to free()
         check("int main() {\n"
@@ -593,44 +787,44 @@ class TestAutoVariables : public TestFixture {
               "   free(&p);\n"
               "   return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Deallocation of an auto-variable results in undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (error) Deallocation of an auto-variable results in undefined behaviour. [autovarInvalidDeallocation]\n", errout_str());
         check("int main() {\n"
               "   int i;\n"
               "   free(&i);\n"
               "   return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Deallocation of an auto-variable results in undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (error) Deallocation of an auto-variable results in undefined behaviour. [autovarInvalidDeallocation]\n", errout_str());
 
         // #5732
         check("int main() {\n"
               "   long (*pKoeff)[256] = new long[9][256];\n"
               "   delete[] pKoeff;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int main() {\n"
               "   long *pKoeff[256];\n"
               "   delete[] pKoeff;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Deallocation of an auto-variable results in undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:13]: (error) Deallocation of an auto-variable results in undefined behaviour. [autovarInvalidDeallocation]\n", errout_str());
 
         check("int main() {\n"
               "   long *pKoeff[256];\n"
               "   free (pKoeff);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Deallocation of an auto-variable results in undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (error) Deallocation of an auto-variable results in undefined behaviour. [autovarInvalidDeallocation]\n", errout_str());
 
         check("void foo() {\n"
               "   const intPtr& intref = Getter();\n"
               "   delete intref;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void test() {\n"
               "   MyObj& obj = *new MyObj;\n"
               "   delete &obj;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6506
         check("struct F {\n"
@@ -642,7 +836,7 @@ class TestAutoVariables : public TestFixture {
               "  char *c2 = 0;\n"
               "  F().free(&c2);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class foo {\n"
               "  void free(void* );\n"
@@ -651,14 +845,14 @@ class TestAutoVariables : public TestFixture {
               "    free(&dst_copy);\n"
               "  }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6551
         check("bool foo( ) {\n"
               "  SwTxtFld * pTxtFld = GetFldTxtAttrAt();\n"
               "  delete static_cast<SwFmtFld*>(&pTxtFld->GetAttr());\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #8910
         check("void f() {\n"
@@ -667,8 +861,113 @@ class TestAutoVariables : public TestFixture {
               "    if (data_size > sizeof (stack)) data = malloc (data_size);\n"
               "    else data = (RGNDATA *)stack;\n"
               "    if ((char *)data != stack) free (data);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #8923
+        check("void f(char **args1, char *args2[]) {\n"
+              "    free((char **)args1);\n"
+              "    free((char **)args2);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10097
+        check("struct Array {\n"
+              "    ~Array() { delete m_Arr; }\n"
+              "    std::array<long, 256>* m_Arr{};\n"
+              "};\n"
+              "Array arr;\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #8174
+        check("struct S {};\n"
+              "void f() {\n"
+              "    S s;\n"
+              "    S* p = &s;\n"
+              "    free(p);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:10]: (error) Deallocation of an auto-variable (s) results in undefined behaviour. [autovarInvalidDeallocation]\n", errout_str());
+
+        check("void f(bool b, int* q) {\n"
+              "    int i;\n"
+              "    int* p = b ? &i : q;\n"
+              "    if (!b)\n"
+              "        free(p);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct E { int* i; };\n" // #11768
+              "struct C { E e; };\n"
+              "int foo(C* cin) {\n"
+              "    E* e = &cin->e;\n"
+              "    e->i = new int[42];\n"
+              "    delete[] e->i;\n"
+              "    return 0;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    S* p = &g();\n"
+              "    delete p;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void testinvaliddealloc_input() {
+        // #10600
+        check("void f(int* a[]) {\n"
+              "    free(a);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int a[]) {\n"
+              "    free(a);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int* a[]) {\n"
+              "    int * p = *a;\n"
+              "    free(p);\n"
+              "    int ** q = a;\n"
+              "    free(q);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int a[]) {\n"
+              "    int * p = a;\n"
+              "    free(p);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void testinvaliddealloc_string() {
+        // #7341
+        check("void f() {\n"
+              "    char *ptr = \"a\";\n"
+              "    free(\"a\");\n"
+              "    delete \"a\";\n"
+              "    free(ptr);\n"
+              "    delete ptr;\n"
+              "    char * p = malloc(1000);\n"
+              "    p = \"abc\";\n"
+              "    free(p);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:10]: (error) Deallocation of a string literal results in undefined behaviour. [autovarInvalidDeallocation]\n"
+                      "[test.cpp:4:12]: (error) Deallocation of a string literal results in undefined behaviour. [autovarInvalidDeallocation]\n"
+                      "[test.cpp:5:10]: (error) Deallocation of a pointer pointing to a string literal (\"a\") results in undefined behaviour. [autovarInvalidDeallocation]\n"
+                      "[test.cpp:6:12]: (error) Deallocation of a pointer pointing to a string literal (\"a\") results in undefined behaviour. [autovarInvalidDeallocation]\n"
+                      "[test.cpp:9:10]: (error) Deallocation of a pointer pointing to a string literal (\"abc\") results in undefined behaviour. [autovarInvalidDeallocation]\n",
+                      errout_str());
+
+        check("void f() {\n"
+              "   char *ptr = malloc(10);\n"
+              "   char *empty_str = \"\";\n"
+              "   if (ptr == NULL)\n"
+              "      ptr = empty_str;\n"
+              "   if (ptr != empty_str)\n"
+              "      free(ptr);\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testinvaliddealloc_C() {
@@ -676,8 +975,8 @@ class TestAutoVariables : public TestFixture {
         check("void svn_repos_dir_delta2() {\n"
               "  struct context c;\n"
               "      SVN_ERR(delete(&c, root_baton, src_entry, pool));\n"
-              "}\n", false, "test.c");
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = false, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testassign1() { // Ticket #1819
@@ -685,7 +984,7 @@ class TestAutoVariables : public TestFixture {
               "    EventPtr event = *eventP;\n"
               "    *actionsP = &event->actions;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testassign2() { // Ticket #2765
@@ -693,7 +992,7 @@ class TestAutoVariables : public TestFixture {
               "    struct my_s *mr = global_structure_pointer;\n"
               "    *datap = &mr->value;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void assignAddressOfLocalArrayToGlobalPointer() {
@@ -702,7 +1001,7 @@ class TestAutoVariables : public TestFixture {
               "  int x[10];\n"
               "  p = x;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:3] -> [test.cpp:4]: (error) Non-local variable 'p' will use pointer to local variable 'x'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7] -> [test.cpp:3:7] -> [test.cpp:4:3]: (error) Non-local variable 'p' will use pointer to local variable 'x'. [danglingLifetime]\n", errout_str());
 
         check("int *p;\n"
               "void f() {\n"
@@ -710,7 +1009,7 @@ class TestAutoVariables : public TestFixture {
               "  p = x;\n"
               "  p = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void assignAddressOfLocalVariableToGlobalPointer() {
@@ -719,7 +1018,7 @@ class TestAutoVariables : public TestFixture {
               "  int x;\n"
               "  p = &x;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:3] -> [test.cpp:4]: (error) Non-local variable 'p' will use pointer to local variable 'x'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7] -> [test.cpp:3:7] -> [test.cpp:4:3]: (error) Non-local variable 'p' will use pointer to local variable 'x'. [danglingLifetime]\n", errout_str());
 
         check("int *p;\n"
               "void f() {\n"
@@ -727,7 +1026,7 @@ class TestAutoVariables : public TestFixture {
               "  p = &x;\n"
               "  p = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void assignAddressOfLocalVariableToMemberVariable() {
@@ -737,8 +1036,8 @@ class TestAutoVariables : public TestFixture {
               "    ptr = &x;\n"
               "  }\n"
               "  int *ptr;\n"
-              "};\n");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:3] -> [test.cpp:4]: (error) Non-local variable 'ptr' will use pointer to local variable 'x'.\n", errout.str());
+              "};");
+        ASSERT_EQUALS("[test.cpp:4:11] -> [test.cpp:3:9] -> [test.cpp:4:5]: (error) Non-local variable 'ptr' will use pointer to local variable 'x'. [danglingLifetime]\n", errout_str());
 
         check("struct A {\n"
               "  void f() {\n"
@@ -747,8 +1046,23 @@ class TestAutoVariables : public TestFixture {
               "    ptr = 0;\n"
               "  }\n"
               "  int *ptr;\n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct R {\n" // #11393
+              "    void pop() { p = nullptr; };\n"
+              "    int* p;\n"
+              "};\n"
+              "struct T {\n"
+              "    void f();\n"
+              "    R* r;\n"
+              "};\n"
+              "void T::f() {\n"
+              "    int i = 0;\n"
+              "    r->p = &i;\n"
+              "    r->pop();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void returnLocalVariable1() {
@@ -758,8 +1072,8 @@ class TestAutoVariables : public TestFixture {
               "    return str;\n"
               "}");
         ASSERT_EQUALS(
-            "[test.cpp:4] -> [test.cpp:3] -> [test.cpp:4]: (error) Returning pointer to local variable 'str' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:4:12] -> [test.cpp:3:10] -> [test.cpp:4:12]: (error) Returning pointer to local variable 'str' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
 
         check("char *foo()\n" // use ValueFlow
               "{\n"
@@ -768,8 +1082,8 @@ class TestAutoVariables : public TestFixture {
               "    return p;\n"
               "}");
         ASSERT_EQUALS(
-            "[test.cpp:4] -> [test.cpp:3] -> [test.cpp:5]: (error) Returning pointer to local variable 'str' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:4:15] -> [test.cpp:3:10] -> [test.cpp:5:12]: (error) Returning pointer to local variable 'str' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
 
         check("class Fred {\n"
               "    char *foo();\n"
@@ -780,8 +1094,8 @@ class TestAutoVariables : public TestFixture {
               "    return str;\n"
               "}");
         ASSERT_EQUALS(
-            "[test.cpp:7] -> [test.cpp:6] -> [test.cpp:7]: (error) Returning pointer to local variable 'str' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:7:12] -> [test.cpp:6:10] -> [test.cpp:7:12]: (error) Returning pointer to local variable 'str' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
 
         check("char * format_reg(char *outbuffer_start) {\n"
               "    return outbuffer_start;\n"
@@ -791,7 +1105,7 @@ class TestAutoVariables : public TestFixture {
               "    char *tp = temp;\n"
               "    tp = format_reg(tp);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void returnLocalVariable2() {
@@ -800,7 +1114,7 @@ class TestAutoVariables : public TestFixture {
               "    char str[100] = {0};\n"
               "    return str;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Fred {\n"
               "    std::string foo();\n"
@@ -810,7 +1124,7 @@ class TestAutoVariables : public TestFixture {
               "    char str[100] = {0};\n"
               "    return str;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -820,14 +1134,14 @@ class TestAutoVariables : public TestFixture {
               "    char q[] = \"AAAAAAAAAAAA\";\n"
               "    return &q[1];\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2] -> [test.cpp:3]: (error) Returning pointer to local variable 'q' that will be invalid when returning.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12] -> [test.cpp:2:10] -> [test.cpp:3:12]: (error) Returning pointer to local variable 'q' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("char *foo()\n"
               "{\n"
               "    static char q[] = \"AAAAAAAAAAAA\";\n"
               "    return &q[1];\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("char *foo()\n"
               "{\n"
@@ -835,8 +1149,8 @@ class TestAutoVariables : public TestFixture {
               "char *p;\n"
               "p = &q[1];\n"
               "return p;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:3] -> [test.cpp:6]: (error) Returning pointer to local variable 'q' that will be invalid when returning.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:5] -> [test.cpp:3:6] -> [test.cpp:6:8]: (error) Returning pointer to local variable 'q' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
     }
 
     void returnLocalVariable4() { // x+y
@@ -845,16 +1159,16 @@ class TestAutoVariables : public TestFixture {
               "    return x+5;\n"
               "}");
         ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:2] -> [test.cpp:3]: (error) Returning pointer to local variable 'x' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:3:12] -> [test.cpp:2:10] -> [test.cpp:3:13]: (error) Returning pointer to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
 
         check("char *foo(int y) {\n"
               "    char x[10] = {0};\n"
               "    return (x+8)-y;\n"
               "}");
         ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:2] -> [test.cpp:3]: (error) Returning pointer to local variable 'x' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:3:13] -> [test.cpp:2:10] -> [test.cpp:3:17]: (error) Returning pointer to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
     }
 
     void returnLocalVariable5() { // cast
@@ -863,8 +1177,8 @@ class TestAutoVariables : public TestFixture {
               "    return (char *)x;\n"
               "}");
         ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:2] -> [test.cpp:3]: (error) Returning pointer to local variable 'x' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:3:20] -> [test.cpp:2:9] -> [test.cpp:3:12]: (error) Returning pointer to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
     }
 
     void returnLocalVariable6() { // valueflow
@@ -873,7 +1187,7 @@ class TestAutoVariables : public TestFixture {
               "    int p = &x;\n"
               "    return p;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2] -> [test.cpp:4]: (error) Returning object that points to local variable 'x' that will be invalid when returning.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:13] -> [test.cpp:2:9] -> [test.cpp:4:12]: (error) Returning object that points to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
     }
 
     void returnReference1() {
@@ -882,36 +1196,36 @@ class TestAutoVariables : public TestFixture {
               "    int s = 0;\n"
               "    int& x = s;\n"
               "    return x;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:5]: (error) Reference to local variable returned.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:12] -> [test.cpp:5:12]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
 
         check("std::string &foo()\n"
               "{\n"
               "    std::string s;\n"
               "    return s;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Reference to local variable returned.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:12]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
 
         check("std::vector<int> &foo()\n"
               "{\n"
               "    std::vector<int> v;\n"
               "    return v;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Reference to local variable returned.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:12]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
 
         check("std::vector<int> &foo()\n"
               "{\n"
               "    static std::vector<int> v;\n"
               "    return v;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("std::vector<int> &foo()\n"
               "{\n"
               "    thread_local std::vector<int> v;\n"
               "    return v;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("std::string hello()\n"
               "{\n"
@@ -922,7 +1236,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    return hello();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Reference to temporary returned.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:17]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         // make sure scope is used in function lookup
         check("class Fred {\n"
@@ -933,7 +1247,7 @@ class TestAutoVariables : public TestFixture {
               "std::string &f() {\n"
               "    return hello();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("std::string hello() {\n"
               "     return std::string();\n"
@@ -942,7 +1256,7 @@ class TestAutoVariables : public TestFixture {
               "std::string &f() {\n"
               "    return hello();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Reference to temporary returned.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:17]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("std::string hello() {\n"
               "     return \"foo\";\n"
@@ -951,7 +1265,7 @@ class TestAutoVariables : public TestFixture {
               "std::string &f() {\n"
               "    return hello().substr(1);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:26]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("class Foo;\n"
               "Foo hello() {\n"
@@ -961,7 +1275,7 @@ class TestAutoVariables : public TestFixture {
               "Foo& f() {\n"
               "    return hello();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Reference to temporary returned.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:17]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         // make sure function overloads are handled properly
         check("class Foo;\n"
@@ -976,7 +1290,7 @@ class TestAutoVariables : public TestFixture {
               "Foo& f() {\n"
               "    return hello(true);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("Foo hello() {\n"
               "     return Foo();\n"
@@ -985,7 +1299,7 @@ class TestAutoVariables : public TestFixture {
               "Foo& f() {\n" // Unknown type - might be a reference
               "    return hello();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void returnReference2() {
@@ -997,7 +1311,7 @@ class TestAutoVariables : public TestFixture {
               "    std::string s;\n"
               "    return s;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Reference to local variable returned.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:12]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
 
         check("class Fred {\n"
               "    std::vector<int> &foo();\n"
@@ -1007,7 +1321,7 @@ class TestAutoVariables : public TestFixture {
               "    std::vector<int> v;\n"
               "    return v;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Reference to local variable returned.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:12]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
 
         check("class Fred {\n"
               "    std::vector<int> &foo();\n"
@@ -1017,7 +1331,7 @@ class TestAutoVariables : public TestFixture {
               "    static std::vector<int> v;\n"
               "    return v;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Fred {\n"
               "    std::string &f();\n"
@@ -1030,7 +1344,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    return hello();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:10]: (error) Reference to temporary returned.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:17]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("class Fred {\n"
               "    std::string hello();\n"
@@ -1044,7 +1358,7 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    return hello();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:11]: (error) Reference to temporary returned.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:11:17]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("class Bar;\n"
               "Bar foo() {\n"
@@ -1053,7 +1367,7 @@ class TestAutoVariables : public TestFixture {
               "Bar& bar() {\n"
               "    return foo();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Reference to temporary returned.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:15]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("std::map<int, string> foo() {\n"
               "     return something;\n"
@@ -1061,7 +1375,7 @@ class TestAutoVariables : public TestFixture {
               "std::map<int, string>& bar() {\n"
               "    return foo();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Reference to temporary returned.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:15]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("Bar foo() {\n"
               "     return something;\n"
@@ -1069,7 +1383,7 @@ class TestAutoVariables : public TestFixture {
               "Bar& bar() {\n" // Unknown type - might be a typedef to a reference type
               "    return foo();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         // Don't crash with function in unknown scope (#4076)
         check("X& a::Bar() {}"
               "X& foo() {"
@@ -1082,8 +1396,8 @@ class TestAutoVariables : public TestFixture {
               "    double ret = getValue();\n"
               "    rd = ret;\n"
               "    return rd;\n"
-              "}", false);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
     }
 
     // Returning reference to global variable
@@ -1092,7 +1406,7 @@ class TestAutoVariables : public TestFixture {
               "double & f() {\n"
               "    return a;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void returnReference5() {
@@ -1112,7 +1426,7 @@ class TestAutoVariables : public TestFixture {
               "        return ra;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void returnReference6() {
@@ -1120,7 +1434,7 @@ class TestAutoVariables : public TestFixture {
               "    Fred &fred(*new Fred);\n"
               "    return fred;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void returnReference7() {  // 3791 - false positive for overloaded function
@@ -1129,14 +1443,318 @@ class TestAutoVariables : public TestFixture {
               "std::string &b() {\n"
               "    return a(12);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("std::string &a(int);\n"
               "std::string a();\n"
               "std::string &b() {\n"
               "    return a(12);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void returnReference8() {
+        check("int& f(std::vector<int> &v) {\n"
+              "    std::vector<int>::iterator it = v.begin();\n"
+              "    int& value = *it;\n"
+              "    return value;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void returnReference9() {
+        check("int& f(bool b, int& x, int& y) {\n"
+              "    return b ? x : y;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void returnReference10() {
+        check("class A { int f() const; };\n"
+              "int& g() {\n"
+              "    A a;\n"
+              "    return a.f();\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:15]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
+
+        check("class A { int& f() const; };\n"
+              "int& g() {\n"
+              "    A a;\n"
+              "    return a.f();\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void returnReference11() {
+        check("class A { static int f(); };\n"
+              "int& g() {\n"
+              "    return A::f();\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:16]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
+
+        check("class A { static int& f(); };\n"
+              "int& g() {\n"
+              "    return A::f();\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("namespace A { int& f(); }\n"
+              "int& g() {\n"
+              "    return A::f();\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void returnReference12() {
+        check("class A { static int& f(); };\n"
+              "auto g() {\n"
+              "    return &A::f;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("class A { static int& f(); };\n"
+              "auto g() {\n"
+              "    auto x = &A::f;\n"
+              "    return x;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void returnReference13() {
+        check("std::vector<int> v;\n"
+              "void* vp = &v;\n"
+              "int& foo(size_t i) {\n"
+              "    return ((std::vector<int>*)vp)->at(i);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::vector<int> v;\n"
+              "void* vp = &v;\n"
+              "int& foo(size_t i) {\n"
+              "    return static_cast<std::vector<int>*>(vp)->at(i);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void returnReference14() {
+        check("struct C { void* m; };\n"
+              "struct A { void* &f(); };\n"
+              "C* g() {\n"
+              "    static C c;\n"
+              "    return &c;\n"
+              "}\n"
+              "void* &A::f() {\n"
+              "    return g()->m;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void returnReference15() {
+        check("template <class T>\n"
+              "const int& f() {\n"
+              "    static int s;\n"
+              "    return s;\n"
+              "}\n"
+              "template <class T>\n"
+              "const int& f(const T&) {\n"
+              "    return f<T>();\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("template <class T>\n"
+              "int g();\n"
+              "template <class T>\n"
+              "const int& f(const T&) {\n"
+              "    return g<T>();\n"
+              "}");
+        TODO_ASSERT_EQUALS("error", "", errout_str());
+    }
+
+    void returnReference16() {
+        check("int& f(std::tuple<int>& x) {\n"
+              "    return std::get<0>(x);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int& f(int x) {\n"
+              "    return std::get<0>(std::make_tuple(x));\n"
+              "}");
+        TODO_ASSERT_EQUALS("error", "", errout_str());
+    }
+
+    void returnReference17() {
+        check("auto g() -> int&;\n"
+              "int& f() {\n"
+              "    return g();\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void returnReference18() {
+        check("template<class T>\n"
+              "auto f(T& x) -> decltype(x);\n"
+              "int& g(int* x) {\n"
+              "    return f(*x);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // #9597
+    void returnReference19() {
+        check("struct C : B {\n"
+              "    const B &f() const { return (const B &)*this; }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // #9536
+    void returnReference20() {
+        check("struct a {\n"
+              "    int& operator()() const;\n"
+              "};\n"
+              "int& b() {\n"
+              "    return a()();\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("auto a() {\n"
+              "    return []() -> int& {\n"
+              "        static int b;\n"
+              "        return b;\n"
+              "    };\n"
+              "}\n"
+              "const int& c() {\n"
+              "    return a()();\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::function<int&()> a();\n"
+              "int& b() {\n"
+              "    return a()();\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9889
+        check("int f(std::vector<std::function<int&()>>& v, int i) {\n"
+              "    auto& j = v[i]();\n"
+              "    return j;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // #9530
+    void returnReference21() {
+        check("int& f(int& x) {\n"
+              "    return {x};\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void returnReference22() {
+        check("int& f() {\n"
+              "    std::unique_ptr<int> p = std::make_unique<int>(1);\n"
+              "    return *p;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
+
+        check("void g(const std::unique_ptr<int>&);\n"
+              "int& f() {\n"
+              "    std::unique_ptr<int> p = std::make_unique<int>(1);\n"
+              "    g(p);\n"
+              "    return *p;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:12]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
+
+        check("void g(std::shared_ptr<int>);\n"
+              "int& f() {\n"
+              "    std::shared_ptr<int> p = std::make_shared<int>(1);\n"
+              "    g(p);\n"
+              "    return *p;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::shared_ptr<int> g();\n"
+              "int& f() {\n"
+              "    return *g();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::unique_ptr<int> g();\n"
+              "int& f() {\n"
+              "    return *g();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
+
+        check("struct A { int x; };\n"
+              "int& f() {\n"
+              "    std::unique_ptr<A> p = std::make_unique<A>();\n"
+              "    return p->x;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:13]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
+    }
+
+    void returnReference23() {
+        check("const std::vector<int> * g();\n"
+              "const std::vector<int>& f() {\n"
+              "    return *g();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void returnReference24()
+    {
+        check("struct A {\n"
+              "    A() {}\n"
+              "};\n"
+              "const A& a() {\n"
+              "    return A();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:13]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
+    }
+
+    void returnReference25()
+    {
+        check("int& f();\n" // #10983
+              "auto g() -> decltype(f()) {\n"
+              "    return f();\n"
+              "}\n"
+              "int& h() {\n"
+              "    return g();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void returnReference26()
+    {
+        check("const int& f() {\n" // #12153
+              "    int x = 234;\n"
+              "    int& s{ x };\n"
+              "    return s;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:4:12]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
+    }
+
+    void returnReference27()
+    {
+        check("struct S {\n" // #12607
+              "    const std::string & f(const std::string& a, const std::string& b) {\n"
+              "        auto status = m.emplace(a, b);\n"
+              "        return status.first->second;\n"
+              "    }\n"
+              "    std::map<std::string, std::string> m;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void returnReference28()
+    {
+        check("struct S {\n" // #13373
+              "    int& r;\n"
+              "};\n"
+              "int& f(S s) {\n"
+              "    return s.r;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void returnReferenceFunction() {
@@ -1146,10 +1764,10 @@ class TestAutoVariables : public TestFixture {
               "int& hello() {\n"
               "    int x = 0;\n"
               "    return f(x);\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:1] -> [test.cpp:2] -> [test.cpp:6] -> [test.cpp:6]: (error) Reference to local variable returned.\n",
-            errout.str());
+            "[test.cpp:1:14] -> [test.cpp:2:12] -> [test.cpp:6:12] -> [test.cpp:6:13]: (error) Reference to local variable returned. [returnReference]\n",
+            errout_str());
 
         check("int& f(int& a) {\n"
               "    return a;\n"
@@ -1157,18 +1775,18 @@ class TestAutoVariables : public TestFixture {
               "int* hello() {\n"
               "    int x = 0;\n"
               "    return &f(x);\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:1] -> [test.cpp:2] -> [test.cpp:6] -> [test.cpp:6] -> [test.cpp:5] -> [test.cpp:6]: (error) Returning pointer to local variable 'x' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:1:14] -> [test.cpp:2:12] -> [test.cpp:6:13] -> [test.cpp:6:12] -> [test.cpp:5:9] -> [test.cpp:6:12]: (error) Returning pointer to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
 
         check("int* f(int * x) {\n"
               "    return x;\n"
               "}\n"
               "int * g(int x) {\n"
               "    return f(&x);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:5] -> [test.cpp:4] -> [test.cpp:5]: (error) Returning pointer to local variable 'x' that will be invalid when returning.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:14] -> [test.cpp:5:14] -> [test.cpp:4:13] -> [test.cpp:5:13]: (error) Returning pointer to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("int* f(int * x) {\n"
               "    x = nullptr;\n"
@@ -1176,8 +1794,8 @@ class TestAutoVariables : public TestFixture {
               "}\n"
               "int * g(int x) {\n"
               "    return f(&x);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("int f(int& a) {\n"
               "    return a;\n"
@@ -1185,8 +1803,8 @@ class TestAutoVariables : public TestFixture {
               "int& hello() {\n"
               "    int x = 0;\n"
               "    return f(x);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:6:13]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("int& f(int a) {\n"
               "    return a;\n"
@@ -1194,8 +1812,8 @@ class TestAutoVariables : public TestFixture {
               "int& hello() {\n"
               "    int x = 0;\n"
               "    return f(x);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Reference to local variable returned.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:12]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
 
         check("int f(int a) {\n"
               "    return a;\n"
@@ -1203,30 +1821,47 @@ class TestAutoVariables : public TestFixture {
               "int& hello() {\n"
               "    int x = 0;\n"
               "    return f(x);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:6:13]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("template<class T>\n"
               "int& f(int& x, T y) {\n"
               "    x += y;\n"
               "    return x;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void returnReferenceContainer() {
         check("auto& f() {\n"
               "    std::vector<int> x;\n"
               "    return x[0];\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Reference to local variable returned.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:13]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
+
+        check("auto& f() {\n"
+              "    std::vector<int> x;\n"
+              "    return x.front();\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:14] -> [test.cpp:3:19]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
+
+        check("std::vector<int> g();\n"
+              "auto& f() {\n"
+              "    return g().front();\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:16] -> [test.cpp:3:21]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
+
+        check("auto& f() {\n"
+              "    return std::vector<int>{1}.front();\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:32] -> [test.cpp:2:37]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("struct A { int foo; };\n"
               "int& f(std::vector<A> v) {\n"
               "    auto it = v.begin();\n"
               "    return it->foo;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (error) Reference to local variable returned.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:22] -> [test.cpp:4:14]: (error) Reference to local variable returned. [returnReference]\n", errout_str());
 
         check("template <class T, class K, class V>\n"
               "const V& get_default(const T& t, const K& k, const V& v) {\n"
@@ -1237,82 +1872,115 @@ class TestAutoVariables : public TestFixture {
               "const int& bar(const std::unordered_map<int, int>& m, int k) {\n"
               "    auto x = 0;\n"
               "    return get_default(m, k, x);\n"
-              "}\n",
-              true);
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:2:56] -> [test.cpp:4:31] -> [test.cpp:9:12] -> [test.cpp:9:23]: (error, inconclusive) Reference to local variable returned. [returnReference]\n",
+            errout_str());
+
+        check("template <class T, class K, class V>\n"
+              "const V& get_default(const T& t, const K& k, const V& v) {\n"
+              "    auto it = t.find(k);\n"
+              "    if (it == t.end()) return v;\n"
+              "    return it->second;\n"
+              "}\n"
+              "const int& bar(const std::unordered_map<int, int>& m, int k) {\n"
+              "    return get_default(m, k, 0);\n"
+              "}\n");
         ASSERT_EQUALS(
-            "[test.cpp:2] -> [test.cpp:4] -> [test.cpp:9] -> [test.cpp:9]: (error, inconclusive) Reference to local variable returned.\n",
-            errout.str());
+            "[test.cpp:2:56] -> [test.cpp:4:31] -> [test.cpp:8:12] -> [test.cpp:8:23]: (error, inconclusive) Reference to temporary returned. [returnTempReference]\n",
+            errout_str());
 
         check("struct A { int foo; };\n"
               "int& f(std::vector<A>& v) {\n"
               "    auto it = v.begin();\n"
               "    return it->foo;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("static std::vector<int> A[2];\n"
+              "static std::vector<int> B;\n"
+              "std::vector<int>& g(int i) {\n"
+              "    return i ? A[i] : B;\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void returnReferenceLiteral() {
         check("const std::string &a() {\n"
               "    return \"foo\";\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Reference to temporary returned.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:12]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("const std::string a() {\n"
               "    return \"foo\";\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("const std::string& f(const std::string& x) { return x; }\n"
+              "const std::string &a() {\n"
+              "    return f(\"foo\");\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:1:42] -> [test.cpp:1:53] -> [test.cpp:3:12] -> [test.cpp:3:13]: (error) Reference to temporary returned. [returnTempReference]\n",
+            errout_str());
+
+        check("const char * f(const char * x) { return x; }\n"
+              "const std::string &a() {\n"
+              "    return f(\"foo\");\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:13]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
     }
 
     void returnReferenceCalculation() {
         check("const std::string &a(const std::string& str) {\n"
               "    return \"foo\" + str;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Reference to temporary returned.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:18]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("int& operator<<(int out, int path) {\n"
               "    return out << path;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Reference to temporary returned.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:16]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("std::ostream& operator<<(std::ostream& out, const std::string& path) {\n"
               "    return out << path;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("std::ostream& operator<<(std::ostream* out, const std::string& path) {\n"
               "    return *out << path;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("Unknown1& operator<<(Unknown1 out, Unknown2 path) {\n"
               "    return out << path;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int& a(int b) {\n"
               "    return 2*(b+1);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Reference to temporary returned.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("const std::string &a(const std::string& str) {\n"
               "    return str;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("const std::string &a(int bar) {\n"
               "    return foo(bar + 1);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("const std::string a(const std::string& str) {\n"
               "    return \"foo\" + str;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int& incValue(int& value) {\n"
               "    return ++value;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void returnReferenceLambda() {
@@ -1323,7 +1991,7 @@ class TestAutoVariables : public TestFixture {
               "        return false;\n"
               "    });\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #5844
         check("map<string,string> const &getVariableTable() {\n"
@@ -1333,13 +2001,13 @@ class TestAutoVariables : public TestFixture {
               "  }();\n"
               "return s_var;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #7583
         check("Command& foo() {\n"
               "  return f([]() -> int { return 1; });\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void returnReferenceInnerScope() {
@@ -1352,16 +2020,62 @@ class TestAutoVariables : public TestFixture {
               "    };\n"
               "    return _make(_Wrapper::call, pmf);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void returnReferenceRecursive() {
         check("int& f() { return f(); }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int& g(int& i) { return i; }\n"
-              "int& f() { return g(f()); }\n");
-        ASSERT_EQUALS("", errout.str());
+              "int& f() { return g(f()); }");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void extendedLifetime() {
+        check("void g(int*);\n"
+              "int h();\n"
+              "auto f() {\n"
+              "    const int& x = h();\n"
+              "    return [&] { return x; };\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:18] -> [test.cpp:5:25] -> [test.cpp:4:16] -> [test.cpp:5:12]: (error) Returning lambda that captures local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
+
+        check("void g(int*);\n"
+              "int h();\n"
+              "int* f() {\n"
+              "    const int& x = h();\n"
+              "    return &x;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:18] -> [test.cpp:5:12] -> [test.cpp:4:16] -> [test.cpp:5:12]: (error) Returning pointer to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
+
+        check("void g(int*);\n"
+              "int h();\n"
+              "void f() {\n"
+              "    int& x = h();\n"
+              "    g(&x);\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:4:12] -> [test.cpp:5:7] -> [test.cpp:4:15] -> [test.cpp:5:7]: (error) Using pointer that is a temporary. [danglingTemporaryLifetime]\n"
+            "[test.cpp:4:12] -> [test.cpp:5:8]: (error) Using reference to dangling temporary. [danglingTempReference]\n",
+            errout_str());
+
+        check("void g(int*);\n"
+              "int h();\n"
+              "void f() {\n"
+              "    const int& x = h();\n"
+              "    g(&x);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct Data {\n"
+              "    std::string path;\n"
+              "};\n"
+              "const char* foo() {\n"
+              "    const Data& data = getData();\n"
+              "    return data.path.c_str();\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void danglingReference() {
@@ -1369,16 +2083,171 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    static int &r = k;\n"
               "    return r;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:3]: (error) Non-local reference variable 'r' to local variable 'k'\n",
-                      errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:19] -> [test.cpp:3:17]: (error) Non-local reference variable 'r' to local variable 'k' [danglingReference]\n",
+                      errout_str());
 
         check("int &f( int & k )\n"
               "{\n"
               "    static int &r = k;\n"
               "    return r;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void danglingTempReference() {
+        check("const std::string& g(const std::string& str_cref) {\n"
+              "    return str_cref;\n"
+              "}\n"
+              "void f() {\n"
+              "    const auto& str_cref2 = g(std::string(\"hello\"));\n"
+              "    std::cout << str_cref2 << std::endl;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:27] -> [test.cpp:1:49] -> [test.cpp:2:12] -> [test.cpp:5:29] -> [test.cpp:6:18]: (error) Using reference to dangling temporary. [danglingTempReference]\n", errout_str());
+
+        // Lifetime extended
+        check("std::string g(const std::string& str_cref) {\n"
+              "    return str_cref;\n"
+              "}\n"
+              "void f() {\n"
+              "    const auto& str_cref2 = g(std::string(\"hello\"));\n"
+              "    std::cout << str_cref2 << std::endl;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("char f() {\n"
+              "    char c = 0;\n"
+              "    char&& cr = std::move(c);\n"
+              "    return cr;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9987
+        check("void g(std::vector<int>);\n"
+              "void f() {\n"
+              "    std::vector<int>&& v = {};\n"
+              "    g(std::move(v));\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void g(std::vector<int>);\n"
+              "std::vector<int> h();\n"
+              "void f() {\n"
+              "    std::vector<int>&& v = h();\n"
+              "    g(std::move(v));\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11087
+        check("struct S1 {\n"
+              "    int& get() { return val; }\n"
+              "    int val{42};\n"
+              "};\n"
+              "void f() {\n"
+              "    int& v = S1().get();\n"
+              "    v += 1;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:6:12] -> [test.cpp:2:25] -> [test.cpp:6:19] -> [test.cpp:7:5]: (error) Using reference to dangling temporary. [danglingTempReference]\n",
+            errout_str());
+
+        check("struct A {\n"
+              "    const int& g() const { return i; }\n"
+              "    int i;\n"
+              "};\n"
+              "A* a();\n"
+              "int f() {\n"
+              "    const int& i = a()->g();\n"
+              "    return i;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "    const int& g() const { return i; }\n"
+              "    int i;\n"
+              "};\n"
+              "std::unique_ptr<A> a();\n"
+              "int f() {\n"
+              "    const int& i = a()->g();\n"
+              "    return i;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:7:18] -> [test.cpp:2:35] -> [test.cpp:7:25] -> [test.cpp:8:12]: (error) Using reference to dangling temporary. [danglingTempReference]\n",
+            errout_str());
+
+        check("struct S1 {\n"
+              "    auto get() -> auto& { return val; }\n"
+              "    int val{42};\n"
+              "};\n"
+              "struct S2 {\n"
+              "    auto get() -> S1 { return s; }\n"
+              "    S1 s;\n"
+              "};\n"
+              "auto main() -> int {\n"
+              "    S2 c{};\n"
+              "    auto& v = c.get().get();\n"
+              "    v += 1;\n"
+              "    return c.s.val;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:11:13] -> [test.cpp:2:34] -> [test.cpp:11:23] -> [test.cpp:12:5]: (error) Using reference to dangling temporary. [danglingTempReference]\n",
+            errout_str());
+
+        check("struct C {\n"
+              "  std::vector<std::vector<int>> v;\n"
+              "};\n"
+              "struct P {\n"
+              "  std::vector<C*>::const_iterator find() const { return pv.begin(); }\n"
+              "  std::vector<C*> pv;\n"
+              "};\n"
+              "struct M {\n"
+              "  const P* get() const { return p; }\n"
+              "  P* p;\n"
+              "};\n"
+              "void f(const M* m) {\n"
+              "  auto it = m->get()->find();\n"
+              "  auto e = (*it)->v.begin();\n"
+              "  const int& x = (*e)[1];\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int* g();\n" // #11188
+              "void f() {\n"
+              "    const auto& p = g();\n"
+              "    if (p != nullptr) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("template<typename S, typename T>\n"
+              "void f(const std::vector<S>& v) {\n"
+              "    T a;\n"
+              "    for (typename std::vector<S>::iterator it = v.begin(); it != v.end(); ++it) {\n"
+              "        const T& b = static_cast<const T&>(it->find(1));\n"
+              "        a = b;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("using namespace std;\n" // #10971
+              "struct S { int i = 3; };\n"
+              "unique_ptr<S> g() {\n"
+              "    auto tp = make_unique<S>();\n"
+              "    return tp;\n"
+              "}\n"
+              "void f() {\n"
+              "    const S& s = *g();\n"
+              "    (void)s.i;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:8:16] -> [test.cpp:9:11]: (error) Using reference to dangling temporary. [danglingTempReference]\n", errout_str());
+
+        check("std::string f() {\n" // #12173
+              "    std::string s;\n"
+              "    for (auto& c : { \"a\", \"b\", \"c\" }) {\n"
+              "        s += c;\n"
+              "    }\n"
+              "    return s;\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testglobalnamespace() {
@@ -1392,7 +2261,7 @@ class TestAutoVariables : public TestFixture {
               "   }\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void returnParameterAddress() {
@@ -1401,28 +2270,28 @@ class TestAutoVariables : public TestFixture {
               "  return &y;\n"
               "}");
 
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:1] -> [test.cpp:3]: (error) Returning pointer to local variable 'y' that will be invalid when returning.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:1:14] -> [test.cpp:3:10]: (error) Returning pointer to local variable 'y' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("int ** foo(int * y)\n"
               "{\n"
               "  return &y;\n"
               "}");
 
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:1] -> [test.cpp:3]: (error) Returning pointer to local variable 'y' that will be invalid when returning.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:1:18] -> [test.cpp:3:10]: (error) Returning pointer to local variable 'y' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("const int * foo(const int & y)\n"
               "{\n"
               "  return &y;\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int * foo(int * y)\n"
               "{\n"
               "  return y;\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct s { void *p; };\n"
               "extern struct s* f(void);\n"
@@ -1430,9 +2299,9 @@ class TestAutoVariables : public TestFixture {
               "{\n"
               "    struct s *r = f();\n"
               "    *q = &r->p;\n"
-              "}\n");
+              "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testconstructor() { // Ticket #5478 - crash while checking a constructor
@@ -1442,6 +2311,7 @@ class TestAutoVariables : public TestFixture {
               "    return const_tree_iterator(foo);\n"
               "  }\n"
               "};");
+        ASSERT_EQUALS("[test.cpp:4:31]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
     }
 
     void variableIsUsedInScope() {
@@ -1459,161 +2329,235 @@ class TestAutoVariables : public TestFixture {
               "    int a = 1;\n"
               "    auto l = [&](){ return a; };\n"
               "    return l;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2] -> [test.cpp:4]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:28] -> [test.cpp:2:9] -> [test.cpp:4:12]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("auto f() {\n"
               "    int a = 1;\n"
               "    return [&](){ return a; };\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2] -> [test.cpp:3]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:26] -> [test.cpp:2:9] -> [test.cpp:3:12]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("auto f(int a) {\n"
               "    return [&](){ return a; };\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:1] -> [test.cpp:2]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:26] -> [test.cpp:1:12] -> [test.cpp:2:12]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("auto f(int a) {\n"
               "    auto p = &a;\n"
               "    return [=](){ return p; };\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3] -> [test.cpp:1] -> [test.cpp:3]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:14] -> [test.cpp:3:26] -> [test.cpp:1:12] -> [test.cpp:3:12]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("auto g(int& a) {\n"
               "    int p = a;\n"
               "    return [&](){ return p; };\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2] -> [test.cpp:3]: (error) Returning lambda that captures local variable 'p' that will be invalid when returning.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:26] -> [test.cpp:2:9] -> [test.cpp:3:12]: (error) Returning lambda that captures local variable 'p' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("auto f() {\n"
               "    return [=](){\n"
               "        int a = 1;\n"
               "        return [&](){ return a; };\n"
               "    };\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:3] -> [test.cpp:4]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:30] -> [test.cpp:3:13] -> [test.cpp:4:16]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("auto f(int b) {\n"
               "    return [=](int a){\n"
               "        a += b;\n"
               "        return [&](){ return a; };\n"
               "    };\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:2] -> [test.cpp:4]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:30] -> [test.cpp:2:20] -> [test.cpp:4:16]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("auto g(int& a) {\n"
               "    return [&](){ return a; };\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("auto g(int a) {\n"
               "    auto p = a;\n"
               "    return [=](){ return p; };\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("auto g(int& a) {\n"
               "    auto p = a;\n"
               "    return [=](){ return p; };\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("auto g(int& a) {\n"
               "    int& p = a;\n"
               "    return [&](){ return p; };\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("template<class F>\n"
               "void g(F);\n"
               "auto f() {\n"
               "    int x;\n"
               "    return g([&]() { return x; });\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("auto f() {\n"
+              "    int i = 0;\n"
+              "    return [&i] {};\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:14] -> [test.cpp:2:9] -> [test.cpp:3:12]: (error) Returning lambda that captures local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
+
+        check("auto f() {\n"
+              "    int i = 0;\n"
+              "    return [i] {};\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("auto f() {\n"
+              "    int i = 0;\n"
+              "    return [=, &i] {};\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:17] -> [test.cpp:2:9] -> [test.cpp:3:12]: (error) Returning lambda that captures local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
+
+        check("auto f() {\n"
+              "    int i = 0;\n"
+              "    int j = 0;\n"
+              "    return [=, &i] { return j; };\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:17] -> [test.cpp:2:9] -> [test.cpp:4:12]: (error) Returning lambda that captures local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
+
+        check("auto f() {\n"
+              "    int i = 0;\n"
+              "    return [&, i] {};\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("auto f() {\n"
+              "    int i = 0;\n"
+              "    int j = 0;\n"
+              "    return [&, i] { return j; };\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:28] -> [test.cpp:3:9] -> [test.cpp:4:12]: (error) Returning lambda that captures local variable 'j' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
+
+        check("auto f(int& i) {\n"
+              "    int j = 0;\n"
+              "    return [=, &i] { return j; };\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int*);\n"
+              "auto g(int y) {\n"
+              "    int x = y;\n"
+              "    return [=] {\n"
+              "        g(&x);\n"
+              "    };\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "    int x;\n"
+              "};\n"
+              "auto f() {\n"
+              "    A a;\n"
+              "    return [=] {\n"
+              "        const A* ap = &a;\n"
+              "        ap->x;\n"
+              "    };\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void danglingLifetimeContainer() {
         check("auto f(const std::vector<int>& x) {\n"
               "    auto it = x.begin();\n"
               "    return it;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("auto f() {\n"
+        check("std::vector<int>::iterator f() {\n"
               "    std::vector<int> x;\n"
               "    auto it = x.begin();\n"
               "    return it;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2] -> [test.cpp:4]: (error) Returning iterator to local container 'x' that will be invalid when returning.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:22] -> [test.cpp:2:22] -> [test.cpp:4:12]: (error) Returning iterator to local container 'x' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("auto f() {\n"
+              "    std::vector<int> x;\n"
+              "    auto it = std::begin(x);\n"
+              "    return it;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:25] -> [test.cpp:2:22] -> [test.cpp:4:12]: (error) Returning iterator to local container 'x' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
+
+        check("int* f() {\n"
               "    std::vector<int> x;\n"
               "    auto p = x.data();\n"
               "    return p;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2] -> [test.cpp:4]: (error) Returning object that points to local variable 'x' that will be invalid when returning.\n", errout.str());
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:3:20] -> [test.cpp:2:22] -> [test.cpp:4:12]: (error) Returning pointer to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
 
         check("auto f() {\n"
               "    std::vector<int> x;\n"
               "    auto p = &x[0];\n"
               "    return p;\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:2] -> [test.cpp:4]: (error) Returning pointer to local variable 'x' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:3:14] -> [test.cpp:2:22] -> [test.cpp:4:12]: (error) Returning pointer to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
 
         check("struct A { int foo; };\n"
               "int* f(std::vector<A> v) {\n"
               "    auto it = v.begin();\n"
               "    return &it->foo;\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:4] -> [test.cpp:2] -> [test.cpp:4]: (error) Returning object that points to local variable 'v' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:3:22] -> [test.cpp:4:12] -> [test.cpp:2:23] -> [test.cpp:4:12]: (error) Returning pointer to local variable 'v' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
 
-        check("auto f(std::vector<int> x) {\n"
+        check("std::vector<int>::iterator f(std::vector<int> x) {\n"
               "    auto it = x.begin();\n"
               "    return it;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:1] -> [test.cpp:3]: (error) Returning iterator to local container 'x' that will be invalid when returning.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:22] -> [test.cpp:1:47] -> [test.cpp:3:12]: (error) Returning iterator to local container 'x' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
         check("auto f() {\n"
               "    std::vector<int> x;\n"
               "    auto it = x.begin();\n"
               "    return std::next(it);\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:4] -> [test.cpp:2] -> [test.cpp:4]: (error) Returning object that points to local variable 'x' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:3:22] -> [test.cpp:2:22] -> [test.cpp:4:21]: (error) Returning iterator to local container 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
 
         check("auto f() {\n"
               "    std::vector<int> x;\n"
               "    auto it = x.begin();\n"
               "    return it + 1;\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:2] -> [test.cpp:4]: (error) Returning iterator to local container 'x' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:3:22] -> [test.cpp:2:22] -> [test.cpp:4:15]: (error) Returning iterator to local container 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
 
         check("auto f() {\n"
               "    std::vector<int> x;\n"
               "    auto it = x.begin();\n"
               "    return std::next(it + 1);\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:4] -> [test.cpp:2] -> [test.cpp:4]: (error) Returning object that points to local variable 'x' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:3:22] -> [test.cpp:4:25] -> [test.cpp:2:22] -> [test.cpp:4:21]: (error) Returning object that points to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
 
         check("std::vector<int*> f() {\n"
               "    int i = 0;\n"
               "    std::vector<int*> v;\n"
               "    v.push_back(&i);\n"
               "    return v;\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:4] -> [test.cpp:4] -> [test.cpp:2] -> [test.cpp:5]: (error) Returning object that points to local variable 'i' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:4:17] -> [test.cpp:4:17] -> [test.cpp:2:9] -> [test.cpp:5:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
 
         check("std::vector<int*> f() {\n"
               "    std::vector<int*> r;\n"
@@ -1622,10 +2566,10 @@ class TestAutoVariables : public TestFixture {
               "    v.push_back(&i);\n"
               "    r.assign(v.begin(), v.end());\n"
               "    return r;\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:5] -> [test.cpp:5] -> [test.cpp:5] -> [test.cpp:3] -> [test.cpp:7]: (error) Returning object that points to local variable 'i' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:5:17] -> [test.cpp:5:17] -> [test.cpp:5:5] -> [test.cpp:3:9] -> [test.cpp:7:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
 
         check("struct A {\n"
               "    std::vector<int*> v;\n"
@@ -1633,10 +2577,10 @@ class TestAutoVariables : public TestFixture {
               "        int i;\n"
               "        v.push_back(&i);\n"
               "    }\n"
-              "};\n");
+              "};");
         ASSERT_EQUALS(
-            "[test.cpp:5] -> [test.cpp:5] -> [test.cpp:4] -> [test.cpp:5]: (error) Non-local variable 'v' will use object that points to local variable 'i'.\n",
-            errout.str());
+            "[test.cpp:5:21] -> [test.cpp:5:21] -> [test.cpp:4:13] -> [test.cpp:5:9]: (error) Non-local variable 'v' will use object that points to local variable 'i'. [danglingLifetime]\n",
+            errout_str());
 
         check("struct A {\n"
               "    std::vector<int*> v;\n"
@@ -1645,10 +2589,10 @@ class TestAutoVariables : public TestFixture {
               "        int * p = &i;\n"
               "        v.push_back(p);\n"
               "    }\n"
-              "};\n");
+              "};");
         ASSERT_EQUALS(
-            "[test.cpp:5] -> [test.cpp:6] -> [test.cpp:4] -> [test.cpp:6]: (error) Non-local variable 'v' will use object that points to local variable 'i'.\n",
-            errout.str());
+            "[test.cpp:5:19] -> [test.cpp:6:21] -> [test.cpp:4:13] -> [test.cpp:6:9]: (error) Non-local variable 'v' will use object that points to local variable 'i'. [danglingLifetime]\n",
+            errout_str());
 
         check("struct A {\n"
               "    std::vector<int*> m;\n"
@@ -1658,28 +2602,29 @@ class TestAutoVariables : public TestFixture {
               "        v.push_back(&x);\n"
               "        m.insert(m.end(), v.begin(), v.end());\n"
               "    }\n"
-              "};\n");
+              "};");
         ASSERT_EQUALS(
-            "[test.cpp:6] -> [test.cpp:6] -> [test.cpp:6] -> [test.cpp:4] -> [test.cpp:7]: (error) Non-local variable 'm' will use object that points to local variable 'x'.\n",
-            errout.str());
+            "[test.cpp:6:21] -> [test.cpp:6:21] -> [test.cpp:6:9] -> [test.cpp:4:13] -> [test.cpp:7:9]: (error) Non-local variable 'm' will use object that points to local variable 'x'. [danglingLifetime]\n"
+            "[test.cpp:6:21] -> [test.cpp:6:21] -> [test.cpp:6:9] -> [test.cpp:4:13] -> [test.cpp:7:18]: (error) Non-local variable 'm' will use object that points to local variable 'x'. [danglingLifetime]\n", // duplicate
+            errout_str());
 
         check("std::vector<int>::iterator f(std::vector<int> v) {\n"
               "    for(auto it = v.begin();it != v.end();it++) {\n"
               "        return it;\n"
               "    }\n"
               "    return {};\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:2] -> [test.cpp:1] -> [test.cpp:3]: (error) Returning iterator to local container 'v' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:2:26] -> [test.cpp:1:47] -> [test.cpp:3:16]: (error) Returning iterator to local container 'v' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
 
         check("const char * f() {\n"
               "   std::string ba(\"hello\");\n"
               "   return ba.c_str();\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:2] -> [test.cpp:3]: (error) Returning pointer to local variable 'ba' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:3:19] -> [test.cpp:2:16] -> [test.cpp:3:19]: (error) Returning pointer to local variable 'ba' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
 
         check("template <class T, class K, class V>\n"
               "const V* get_default(const T& t, const K& k, const V* v) {\n"
@@ -1690,11 +2635,31 @@ class TestAutoVariables : public TestFixture {
               "const int* bar(const std::unordered_map<int, int>& m, int k) {\n"
               "    auto x = 0;\n"
               "    return get_default(m, k, &x);\n"
-              "}\n",
-              true);
+              "}\n");
         ASSERT_EQUALS(
-            "[test.cpp:9] -> [test.cpp:9] -> [test.cpp:8] -> [test.cpp:9]: (error, inconclusive) Returning pointer to local variable 'x' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:9:30] -> [test.cpp:9:30] -> [test.cpp:8:10] -> [test.cpp:9:23]: (error, inconclusive) Returning pointer to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("std::vector<int> g();\n"
+              "auto f() {\n"
+              "    return g().begin();\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:21] -> [test.cpp:3:21]: (error) Returning iterator that will be invalid when returning. [returnDanglingLifetime]\n",
+                      errout_str());
+
+        check("std::vector<int> g();\n"
+              "std::vector<int>::iterator f() {\n"
+              "    auto it = g().begin();\n"
+              "    return it;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:24] -> [test.cpp:3:16] -> [test.cpp:4:5]: (error) Using iterator that is a temporary. [danglingTemporaryLifetime]\n",
+                      errout_str());
+
+        check("std::vector<int> g();\n"
+              "int& f() {\n"
+              "    return *g().begin();\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:22] -> [test.cpp:3:12]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
 
         check("struct A {\n"
               "    std::vector<std::string> v;\n"
@@ -1702,63 +2667,63 @@ class TestAutoVariables : public TestFixture {
               "        char s[3];\n"
               "        v.push_back(s);\n"
               "    }\n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
 
         check("std::vector<std::string> f() {\n"
               "    const char * s = \"hello\";\n"
               "    std::vector<std::string> v;\n"
               "    v.push_back(s);\n"
               "    return v;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("auto f() {\n"
               "  static std::vector<int> x;\n"
               "  return x.begin();\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("std::string g() {\n"
               "    std::vector<char> v;\n"
               "    return v.data();\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("std::vector<int>::iterator f(std::vector<int>* v) {\n"
               "    return v->begin();\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("std::vector<int>::iterator f(std::vector<int>* v) {\n"
               "    std::vector<int>* v = new std::vector<int>();\n"
               "    return v->begin();\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("int f(std::vector<int> v) {\n"
               "    return *v.begin();\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("int f(std::vector<int> v) {\n"
               "    return v.end() - v.begin();\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("auto g() {\n"
               "    std::vector<char> v;\n"
               "    return {v, [v]() { return v.data(); }};\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("template<class F>\n"
               "void g(F);\n"
               "auto f() {\n"
               "    std::vector<char> v;\n"
               "    return g([&]() { return v.data(); });\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("std::vector<int> g();\n"
               "struct A {\n"
@@ -1767,8 +2732,8 @@ class TestAutoVariables : public TestFixture {
               "        std::vector<int> v = g();\n"
               "        m.insert(m.end(), v.begin(), v.end());\n"
               "    }\n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(bool b) {\n"
               "    std::vector<int> v = {1};\n"
@@ -1777,8 +2742,8 @@ class TestAutoVariables : public TestFixture {
               "        v.insert(a, a+1);\n"
               "    }\n"
               "    return v.back() == 0;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("class A {\n"
               "    int f( P p ) {\n"
@@ -1788,8 +2753,8 @@ class TestAutoVariables : public TestFixture {
               "    struct B {};\n"
               "    std::map< S, B > m1;\n"
               "    std::map< S, B > m2;\n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
               "    std::vector<int*> v;\n"
@@ -1797,118 +2762,532 @@ class TestAutoVariables : public TestFixture {
               "    void f() {\n"
               "        v.push_back(&x);\n"
               "    }\n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
 
         check("size_t f(const std::string& x) {\n"
               "    std::string y = \"x\";\n"
               "    return y.find(x);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("std::string* f();\n"
               "const char* g() {\n"
               "    std::string* var = f();\n"
               "    return var->c_str();\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
-    }
-
-    void danglingLifetime() {
-        check("auto f() {\n"
-              "    std::vector<int> a;\n"
-              "    auto it = a.begin();\n"
-              "    return [=](){ return it; };\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4] -> [test.cpp:2] -> [test.cpp:4]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("auto f(std::vector<int> a) {\n"
-              "    auto it = a.begin();\n"
-              "    return [=](){ return it; };\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3] -> [test.cpp:1] -> [test.cpp:3]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning.\n", errout.str());
+        check("std::string f() {\n"
+              "    std::vector<char> data{};\n"
+              "    data.push_back('a');\n"
+              "    return std::string{ data.data(), data.size() };\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("struct e {};\n"
-              "e * j() {\n"
-              "    e c[20];\n"
-              "    return c;\n"
-              "}\n");
-        ASSERT_EQUALS(
-            "[test.cpp:4] -> [test.cpp:3] -> [test.cpp:4]: (error) Returning pointer to local variable 'c' that will be invalid when returning.\n",
-            errout.str());
+        check("std::vector<char*> f() {\n"
+              "    char a = 0;\n"
+              "    return std::vector<char*>{&a};\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:31] -> [test.cpp:3:31] -> [test.cpp:2:10] -> [test.cpp:3:30]: (error) Returning object that points to local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
 
-        check("auto f(std::vector<int>& a) {\n"
-              "    auto it = a.begin();\n"
-              "    return [=](){ return it; };\n"
+        check("std::vector<int>* g();\n"
+              "int& f() {\n"
+              "    auto* p = g();\n"
+              "    return p->front();\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("int * f(int a[]) {\n"
-              "    return a;\n"
+        check("std::vector<std::vector<int>> g();\n"
+              "void f() {\n"
+              "    for(auto& x:g())\n"
+              "        std::sort(x.begin(), x.end());\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f() {\n"
-              "    struct b {\n"
-              "        uint32_t f[6];\n"
-              "    } d;\n"
-              "    uint32_t *a = d.f;\n"
+        check("struct A {\n"
+              "    std::vector<int*> v;\n"
+              "    void add(int* i) {\n"
+              "        v.push_back(i);\n"
+              "    }\n"
+              "    void f() {\n"
+              "        int i = 0;\n"
+              "        add(&i);\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS(
+            "[test.cpp:8:13] -> [test.cpp:8:13] -> [test.cpp:4:21] -> [test.cpp:7:13] -> [test.cpp:4:9]: (error) Non-local variable 'v' will use object that points to local variable 'i'. [danglingLifetime]\n",
+            errout_str());
+
+        check("struct A {\n"
+              "    std::vector<int*> v;\n"
+              "    void add(int* i) {\n"
+              "        v.push_back(i);\n"
+              "    }\n"
+              "};\n"
+              "void f() {\n"
+              "    A a;\n"
+              "    int i = 0;\n"
+              "    a.add(&i);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "    std::vector<int*> v;\n"
+              "    void add(int* i) {\n"
+              "        v.push_back(i);\n"
+              "    }\n"
+              "    void f() {\n"
+              "        A a;\n"
+              "        int i = 0;\n"
+              "        a.add(&i);\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f() {\n"
+              "    int i;\n"
+              "    {\n"
+              "        std::vector<int> vec;\n"
+              "        const auto iter = vec.begin();\n"
+              "        i = (int)(iter - vec.begin());\n"
+              "    }\n"
+              "    return i;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int* get(std::vector<int>& container) {\n"
+              "    Sequence seq(container);\n"
+              "    for (auto& r : seq) {\n"
+              "        return &r;\n"
+              "    }\n"
+              "    return &*seq.begin();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::string f(std::string Str, int first, int last) {\n"
+              "    return { Str.begin() + first, Str.begin() + last + 1 };\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::string f(std::string s) {\n"
+              "    std::string r = { s.begin(), s.end() };\n"
+              "    return r;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "    std::vector<std::unique_ptr<int>> mA;\n"
+              "    void f(std::unique_ptr<int> a) {\n"
+              "        auto x = a.get();\n"
+              "        mA.push_back(std::move(a));\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "    std::map<std::string, int> m;\n"
+              "    int* f(std::string s) {\n"
+              "        auto r = m.emplace(name, name);\n"
+              "        return &(r.first->second);\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "	std::queue<int> q;\n"
+              "	auto& h = q.emplace();\n"
+              "    h = 1;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::string f(std::string s) {\n"
+              "    std::string ss = (\":\" + s).c_str();\n"
+              "    return ss;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n" // #12568
+              "    std::string str;\n"
+              "    {\n"
+              "        std::unique_ptr<char[]> b(new char[1]{});\n"
+              "        str.assign(b.get());\n"
+              "    }\n"
+              "    std::cerr << str;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("auto f() {\n" // #11420
+              "    std::vector<int> x;\n"
+              "    std::vector<int>::iterator it = x.begin();\n"
+              "    return it;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:44] -> [test.cpp:2:22] -> [test.cpp:4:12]: (error) Returning iterator to local container 'x' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
+    }
+
+    void danglingLifetimeContainerView()
+    {
+        check("std::string_view f() {\n"
+              "    std::string s = \"\";\n"
+              "    return s;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:12] -> [test.cpp:2:17] -> [test.cpp:3:12]: (error) Returning object that points to local variable 's' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("std::string_view f() {\n"
+              "    std::string s = \"\";\n"
+              "    std::string_view sv = s;\n"
+              "    return sv;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:27] -> [test.cpp:2:17] -> [test.cpp:4:12]: (error) Returning object that points to local variable 's' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("std::string_view f() {\n"
+              "    std::string s = \"\";\n"
+              "    return std::string_view{s};\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:29] -> [test.cpp:2:17] -> [test.cpp:3:28]: (error) Returning object that points to local variable 's' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("std::string_view f(std::string_view s) {\n"
+              "    return s;\n"
+              "}\n"
+              "std::string_view g() {\n"
+              "    std::string s = \"\";\n"
+              "    return f(s);\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:6:14] -> [test.cpp:6:14] -> [test.cpp:5:17] -> [test.cpp:6:13]: (error) Returning object that points to local variable 's' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("const char * f() {\n"
+              "    std::string s;\n"
+              "    std::string_view sv = s;\n"
+              "    return sv.begin();\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:4:20] -> [test.cpp:2:17] -> [test.cpp:4:20]: (error) Returning iterator to local container 's' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("const char * f() {\n"
+              "    std::string s;\n"
+              "    return std::string_view{s}.begin();\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:37] -> [test.cpp:2:17] -> [test.cpp:3:37]: (error) Returning iterator to local container 's' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("const char * f() {\n"
+              "    std::string s;\n"
+              "    return std::string_view(s).begin();\n"
+              "}\n");
+        TODO_ASSERT_EQUALS(
+            "[test.cpp:3] -> [test.cpp:2] -> [test.cpp:3]: (error) Returning iterator to local container 's' that will be invalid when returning. [returnDanglingLifetime]\n",
+            "",
+            errout_str());
+
+        check("const char * f(std::string_view sv) {\n"
+              "    return sv.begin();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("const char * f(std::string s) {\n"
+              "    std::string_view sv = s;\n"
+              "    return sv.begin();\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:20] -> [test.cpp:1:28] -> [test.cpp:3:20]: (error) Returning iterator to local container 's' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("std::string_view f(std::string s) {\n"
+              "    return s;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:2:12] -> [test.cpp:1:32] -> [test.cpp:2:12]: (error) Returning object that points to local variable 's' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("const char * f(const std::string& s) {\n"
+              "    std::string_view sv = s;\n"
+              "    return sv.begin();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::string_view f(const std::string_view& sv) {\n"
+              "    return sv;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n" // #10993
+              "    std::string_view v = std::string();\n"
+              "    v.data();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:37] -> [test.cpp:2:37] -> [test.cpp:3:5]: (error) Using object that is a temporary. [danglingTemporaryLifetime]\n", errout_str());
+
+        check("std::string convert(std::string_view sv) { return std::string{ sv }; }\n" // #11374
+              "auto f() {\n"
+              "    std::vector<std::string> v;\n"
+              "    v.push_back(convert(\"foo\"));\n"
+              "    return v[0];\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10532
+        check("std::string f(std::string ss) {\n"
+              "  std::string_view sv = true ? \"\" : ss;\n"
+              "  std::string s = sv;\n"
+              "  return s;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:30] -> [test.cpp:2:30] -> [test.cpp:3:17]: (error) Using object that is a temporary. [danglingTemporaryLifetime]\n",
+                      errout_str());
+
+        // #10833
+        check("struct A { std::string s; };\n"
+              "const std::string& f(A* a) {\n"
+              "    return a ? a->s : \"\";\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:14]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
+
+        check("std::span<int> f() {\n"
+              "    std::vector<int> v{};\n"
+              "    return v;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:12] -> [test.cpp:2:22] -> [test.cpp:3:12]: (error) Returning object that points to local variable 'v' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("std::span<int> f() {\n"
+              "    std::vector<int> v;\n"
+              "    std::span sp = v;\n"
+              "    return sp;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:20] -> [test.cpp:2:22] -> [test.cpp:4:12]: (error) Returning object that points to local variable 'v' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("std::span<int> f() {\n"
+              "    std::vector<int> v;\n"
+              "    return std::span{v};\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:22] -> [test.cpp:2:22] -> [test.cpp:3:21]: (error) Returning object that points to local variable 'v' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("int f() {\n"
+              "    std::span<int> s;\n"
+              "    {\n"
+              "        std::vector<int> v(1);"
+              "        s = v;\n"
+              "    }\n"
+              "return s.back()\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:4:43] -> [test.cpp:4:26] -> [test.cpp:6:8]: (error) Using object that points to local variable 'v' that is out of scope. [invalidLifetime]\n",
+            errout_str());
+
+        check("int f() {\n"
+              "    std::span<int> s;\n"
+              "    {\n"
+              "        std::vector<int> v(1);"
+              "        s = v;\n"
+              "    }\n"
+              "return s.back()\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:4:43] -> [test.cpp:4:26] -> [test.cpp:6:8]: (error) Using object that points to local variable 'v' that is out of scope. [invalidLifetime]\n",
+            errout_str());
+
+        check("int f() {\n"
+              "    std::span<int> s;\n"
+              "    {\n"
+              "        std::vector<int> v(1);"
+              "        s = v;\n"
+              "    }\n"
+              "return s.front()\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:4:43] -> [test.cpp:4:26] -> [test.cpp:6:8]: (error) Using object that points to local variable 'v' that is out of scope. [invalidLifetime]\n",
+            errout_str());
+
+        check("int f() {\n"
+              "    std::span<int> s;\n"
+              "    {\n"
+              "        std::vector<int> v(1);"
+              "        s = v;\n"
+              "    }\n"
+              "return s.last(1)\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:4:43] -> [test.cpp:4:26] -> [test.cpp:6:8]: (error) Using object that points to local variable 'v' that is out of scope. [invalidLifetime]\n",
+            errout_str());
+
+        check("int f() {\n"
+              "    std::span<int> s;\n"
+              "    {\n"
+              "        std::vector<int> v(1);"
+              "        s = v;\n"
+              "    }\n"
+              "return s.first(1)\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:4:43] -> [test.cpp:4:26] -> [test.cpp:6:8]: (error) Using object that points to local variable 'v' that is out of scope. [invalidLifetime]\n",
+            errout_str());
+
+        check("std::span<const int> f() {\n" // #12966
+              "    int a[10]{};\n"
+              "    return a;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:12] -> [test.cpp:2:9] -> [test.cpp:3:12]: (error) Returning pointer to local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("std::string_view f() {\n" // #10995
+              "    char a[10]{};\n"
+              "    return a;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:12] -> [test.cpp:2:10] -> [test.cpp:3:12]: (error) Returning pointer to local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("std::string_view f() {\n" // #14465
+              "    std::vector<std::string> v;\n"
+              "    return *v.begin();\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:12] -> [test.cpp:3:12]: (error) Returning object that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+    }
+
+    void danglingLifetimeUniquePtr()
+    {
+        check("int* f(std::unique_ptr<int> p) {\n"
+              "    int * rp = p.get();\n"
+              "    return rp;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:2:21] -> [test.cpp:1:29] -> [test.cpp:3:12]: (error) Returning pointer to local variable 'p' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("int* f();\n" // #11406
+              "bool g() {\n"
+              "    std::unique_ptr<int> ptr(f());\n"
+              "    return ptr.get();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int* f();\n"
+              "int* g() {\n"
+              "    std::unique_ptr<int> ptr(f());\n"
+              "    return ptr.get();\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:4:19] -> [test.cpp:3:26] -> [test.cpp:4:19]: (error) Returning object that points to local variable 'ptr' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        // #12600
+        check("struct S { std::unique_ptr<int> p; };\n"
+              "int* f(const S* s) {\n"
+              "    return s[0].p.get();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+    void danglingLifetime() {
+        check("auto f() {\n"
+              "    std::vector<int> a;\n"
+              "    auto it = a.begin();\n"
+              "    return [=](){ return it; };\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:22] -> [test.cpp:4:26] -> [test.cpp:2:22] -> [test.cpp:4:12]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
+
+        check("auto f(std::vector<int> a) {\n"
+              "    auto it = a.begin();\n"
+              "    return [=](){ return it; };\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:22] -> [test.cpp:3:26] -> [test.cpp:1:25] -> [test.cpp:3:12]: (error) Returning lambda that captures local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n", errout_str());
+
+        check("struct e {};\n"
+              "e * j() {\n"
+              "    e c[20];\n"
+              "    return c;\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:4:12] -> [test.cpp:3:7] -> [test.cpp:4:12]: (error) Returning pointer to local variable 'c' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("auto f(std::vector<int>& a) {\n"
+              "    auto it = a.begin();\n"
+              "    return [=](){ return it; };\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int * f(int a[]) {\n"
+              "    return a;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    struct b {\n"
+              "        uint32_t f[6];\n"
+              "    } d;\n"
+              "    uint32_t *a = d.f;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // Don't decay std::array
         check("std::array<char, 1> f() {\n"
               "    std::array<char, 1> x;\n"
               "    return x;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // Make sure we don't hang
         check("struct A;\n"
               "void f() {\n"
               "    using T = A[3];\n"
               "    A &&a = T{1, 2, 3}[1];\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // Make sure we don't hang
         check("struct A;\n"
               "void f() {\n"
               "    using T = A[3];\n"
               "    A &&a = T{1, 2, 3}[1]();\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // Make sure we don't hang
         check("struct A;\n"
               "void f() {\n"
               "    using T = A[3];\n"
               "    A &&a = T{1, 2, 3}[1];\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // Make sure we don't hang
         check("struct A;\n"
               "void f() {\n"
               "    using T = A[3];\n"
               "    A &&a = T{1, 2, 3}[1]();\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // Crash #8872
         check("struct a {\n"
               "  void operator()(b c) override {\n"
               "    d(c, [&] { c->e });\n"
               "  }\n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct a {\n"
               "  void operator()(b c) override {\n"
               "    d(c, [=] { c->e });\n"
               "  }\n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct a {\n"
               "    a(char* b) {}\n"
@@ -1916,8 +3295,8 @@ class TestAutoVariables : public TestFixture {
               "a f() {\n"
               "    char c[20];\n"
               "    return c;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct a {\n"
               "    a(char* b) {}\n"
@@ -1926,236 +3305,1224 @@ class TestAutoVariables : public TestFixture {
               "    char c[20];\n"
               "    a d = c;\n"
               "    return d;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    struct a {\n"
               "        std::vector<int> v;\n"
               "        auto g() { return v.end(); }\n"
               "    };\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("int * f(std::vector<int>& v) {\n"
               "    for(int & x : v)\n"
               "        return &x;\n"
               "    return nullptr;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9275
+        check("struct S {\n"
+              "   void f();\n"
+              "   std::string m;\n"
+              "}\n"
+              "void S::f() {\n"
+              "    char buf[1024];\n"
+              "    const char* msg = buf;\n"
+              "    m = msg;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9201
+        check("int* f() {\n"
+              "    struct a { int m; };\n"
+              "    static a b{0};\n"
+              "    return &b.m;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9453
+        check("int *ptr;\n"
+              "void foo(int arr[]) {\n"
+              "    ptr = &arr[2];\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9639
+        check("struct Fred {\n"
+              "    std::string s;\n"
+              "};\n"
+              "const Fred &getFred();\n"
+              "const char * f() {\n"
+              "  const Fred &fred = getFred();\n"
+              "  return fred.s.c_str();\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9534
+        check("struct A {\n"
+              "    int* x;\n"
+              "};\n"
+              "int* f(int i, std::vector<A>& v) {\n"
+              "    A& y = v[i];\n"
+              "    return &y.x[i];\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9712
+        check("std::string f(const char *str) {\n"
+              "    char value[256];\n"
+              "    return value;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9770
+        check("class C {\n"
+              "  std::string f(const char*);\n"
+              "};\n"
+              "std::string C::f(const char*) {\n"
+              "  const char data[] = \"x\";\n"
+              "  return data;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9899
+        check("struct A {\n"
+              "    std::vector<int> v;\n"
+              "    void f(std::vector<int> w) {\n"
+              "        v = std::move(w);\n"
+              "    }\n"
+              "    void g(std::vector<int> w) {\n"
+              "        f(std::move(w));\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        //Make sure we can still take the address of a reference without warning
+        check("int* foo() {\n"
+              "  int& x = getX();\n"
+              "  return &x;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+        check("struct C {\n"
+              "  int* m_x;\n"
+              "  void foo() {\n"
+              "    const int& x = getX();\n"
+              "    m_x = &x;\n"
+              "  }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10090
+        check("struct a {\n"
+              "    int b{};\n"
+              "};\n"
+              "struct c {\n"
+              "    int* c{};\n"
+              "    a* d{};\n"
+              "};\n"
+              "a* f();\n"
+              "c g() {\n"
+              "    c e;\n"
+              "    e.d = f();\n"
+              "    if (e.d)\n"
+              "        e.c = &e.d->b;\n"
+              "    return e;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10214
+        check("struct A {\n"
+              "  std::string key;\n"
+              "  const char *value;\n"
+              "};\n"
+              "const char *f(const std::string &key, const std::vector<A> &lookup) {\n"
+              "  const auto &entry =\n"
+              "      std::find_if(lookup.begin(), lookup.end(),\n"
+              "                   [key](const auto &v) { return v.key == key; });\n"
+              "  return (entry == lookup.end()) ? \"\" : entry->value;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9811
+        check("struct Base {\n"
+              "    virtual auto get() -> int & = 0;\n"
+              "};\n"
+              "struct A : public Base {\n"
+              "    int z = 42;\n"
+              "    auto get() -> int & override { return z; }\n"
+              "    auto getMore() -> int & { return get(); }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10575
+        check("struct Data {\n"
+              "    int x=0;\n"
+              "    int y=0;\n"
+              "};\n"
+              "struct MoreData {\n"
+              "    Data *data1;\n"
+              "};\n"
+              "struct Fred {\n"
+              "    Fred() {\n"
+              "        Data data;\n"
+              "        mMoreData.data1 = &data;\n"
+              "    }\n"
+              "    MoreData mMoreData;\n"
+              "};\n");
+        ASSERT_EQUALS(
+            "[test.cpp:11:27] -> [test.cpp:10:14] -> [test.cpp:11:18]: (error) Non-local variable 'mMoreData.data1' will use pointer to local variable 'data'. [danglingLifetime]\n",
+            errout_str());
+
+        // #10784
+        check("template <class... Ts>\n"
+              "auto f(int i, Ts&... xs) {\n"
+              "    return std::tie(xs[i]...);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11362
+        check("int* f() {\n"
+              "    static struct { int x; } a[] = { { 1 } };\n"
+              "    return &a[0].x;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11666
+        check("template <class T, int M, int N>\n"
+              "struct Matrix;\n"
+              "template <class T, int N>\n"
+              "struct Matrix<T, 1, N> {\n"
+              "    std::array<T, N> x;\n"
+              "private:\n"
+              "    static constexpr decltype(&Matrix::x) members[] = {&Matrix::x};\n"
+              "};\n"
+              "template <class T, int N>\n"
+              "struct Matrix<T, 2, N> {\n"
+              "    std::array<T, N> x;\n"
+              "    std::array<T, N> y;\n"
+              "private:\n"
+              "    static constexpr decltype(&Matrix::x) members[] = {&Matrix::x, &Matrix::y};\n"
+              "};\n"
+              "template <class T>\n"
+              "Matrix<T, 2, 2> O() {\n"
+              "    return { {}, {} };\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11729
+        check("struct T {\n"
+              "    void add(int* i) {\n"
+              "        v.push_back(i);\n"
+              "    }\n"
+              "    void f() {\n"
+              "        static int val = 1;\n"
+              "        add(&val);\n"
+              "    }\n"
+              "    std::vector<int*> v;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #13560
+        check("void f() {\n"
+              "    int a[] = { 1 };\n"
+              "    static int* p = nullptr;\n"
+              "    if (!p) {\n"
+              "        p = &a[0];\n"
+              "    }\n"
+              "    *p = 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:13] -> [test.cpp:2:9] -> [test.cpp:7:6]: (error) Static variable 'p' will use pointer to local variable 'a'. [danglingLifetime]\n", errout_str());
+
+        // #10902
+        check("void f() {\n"
+              "    static int* x;\n"
+              "    int y;\n"
+              "    x = &y;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:3:9] -> [test.cpp:4:5]: (error) Static variable 'x' will use pointer to local variable 'y'. [danglingLifetime]\n", errout_str());
+    }
+
+    void danglingLifetimeFunction() {
+        check("auto f() {\n"
+              "    int a;\n"
+              "    return std::ref(a);\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:3:21] -> [test.cpp:2:9] -> [test.cpp:3:20]: (error) Returning object that points to local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("auto f() {\n"
+              "    int a;\n"
+              "    return std::make_tuple(std::ref(a));\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:3:37] -> [test.cpp:3:36] -> [test.cpp:2:9] -> [test.cpp:3:27]: (error) Returning object that points to local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("template<class T>\n"
+              "auto by_value(T x) {\n"
+              "    return [=] { return x; };\n"
+              "}\n"
+              "auto g() {\n"
+              "    std::vector<int> v;\n"
+              "    return by_value(v.begin());\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:7:28] -> [test.cpp:7:28] -> [test.cpp:3:12] -> [test.cpp:3:25] -> [test.cpp:6:22] -> [test.cpp:7:20]: (error) Returning object that points to local variable 'v' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("template<class T>\n"
+              "auto by_value(const T& x) {\n"
+              "    return [=] { return x; };\n"
+              "}\n"
+              "auto g() {\n"
+              "    std::vector<int> v;\n"
+              "    return by_value(v.begin());\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:7:28] -> [test.cpp:7:28] -> [test.cpp:3:12] -> [test.cpp:3:25] -> [test.cpp:6:22] -> [test.cpp:7:20]: (error) Returning object that points to local variable 'v' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("auto by_ref(int& x) {\n"
+              "    return [&] { return x; };\n"
+              "}\n"
+              "auto f() {\n"
+              "    int i = 0;\n"
+              "    return by_ref(i);\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:2:12] -> [test.cpp:1:19] -> [test.cpp:2:25] -> [test.cpp:6:19] -> [test.cpp:5:9] -> [test.cpp:6:18]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("auto by_ref(const int& x) {\n"
+              "    return [=] { return x; };\n"
+              "}\n"
+              "auto f() {\n"
+              "    int i = 0;\n"
+              "    return by_ref(i);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("auto f(int x) {\n"
+              "    int a;\n"
+              "    std::tie(a) = x;\n"
+              "    return a;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::pair<std::string, std::string>\n"
+              "str_pair(std::string const & a, std::string const & b) {\n"
+              "    return std::make_pair(a, b);\n"
+              "}\n"
+              "std::vector<std::pair<std::string, std::string> > create_parameters() {\n"
+              "    std::vector<std::pair<std::string, std::string> > par;\n"
+              "    par.push_back(str_pair(\"param1\", \"prop_a\"));\n"
+              "    par.push_back(str_pair(\"param2\", \"prop_b\"));\n"
+              "    par.push_back(str_pair(\"param3\", \"prop_c\"));\n"
+              "    return par;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { int* (*ptr)(const int*); };\n" // #13057
+              "int* f(S* s) {\n"
+              "    int x = 0;\n"
+              "    return s->ptr(&x);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void danglingLifetimeUserConstructor()
+    {
+        check("struct A {\n"
+              "    int* i;\n"
+              "    A(int& x)\n"
+              "    : i(&x)\n"
+              "    {}\n"
+              "};\n"
+              "A f() {\n"
+              "    int i = 0;\n"
+              "    A a{i};\n"
+              "    return a;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:9:9] -> [test.cpp:8:9] -> [test.cpp:10:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("struct A {\n"
+              "    int* i;\n"
+              "    A(int& x);\n"
+              "};\n"
+              "A f() {\n"
+              "    int i = 0;\n"
+              "    A a{i};\n"
+              "    return a;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:7:9] -> [test.cpp:6:9] -> [test.cpp:8:12]: (error, inconclusive) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("struct A {\n"
+              "    int* i;\n"
+              "    A(const int& x);\n"
+              "};\n"
+              "A f() {\n"
+              "    int i = 0;\n"
+              "    A a{i};\n"
+              "    return a;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "    int& i;\n"
+              "    A(int& x)\n"
+              "    : i(x)\n"
+              "    {}\n"
+              "};\n"
+              "A f() {\n"
+              "    int i = 0;\n"
+              "    A a{i};\n"
+              "    return a;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:9:9] -> [test.cpp:8:9] -> [test.cpp:10:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("struct A {\n"
+              "    int& i;\n"
+              "    A(const std::vector<int>& x)\n"
+              "    : i(x[0])\n"
+              "    {}\n"
+              "};\n"
+              "A f() {\n"
+              "    std::vector<int> v = {0};\n"
+              "    A a{v};\n"
+              "    return a;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:9:9] -> [test.cpp:8:22] -> [test.cpp:10:12]: (error) Returning object that points to local variable 'v' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("struct A {\n"
+              "    int* i;\n"
+              "    A(const std::vector<int>& x)\n"
+              "    : i(x.data())\n"
+              "    {}\n"
+              "};\n"
+              "A f() {\n"
+              "    std::vector<int> v = {0};\n"
+              "    A a{v};\n"
+              "    return a;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:9:9] -> [test.cpp:8:22] -> [test.cpp:10:12]: (error) Returning object that points to local variable 'v' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("struct A {\n"
+              "    const int* i;\n"
+              "    A(const int& x)\n"
+              "    : i(&x)\n"
+              "    {}\n"
+              "};\n"
+              "A f() {\n"
+              "    A a{0};\n"
+              "    return a;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:8:9] -> [test.cpp:9:12]: (error) Returning object that will be invalid when returning. [returnDanglingLifetime]\n",
+                      errout_str());
+
+        check("struct A {\n"
+              "    const int* i;\n"
+              "    A(const int& x)\n"
+              "    : i(&x)\n"
+              "    {}\n"
+              "};\n"
+              "A f() {\n"
+              "    int i = 0;\n"
+              "    return A{i};\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:9:14] -> [test.cpp:8:9] -> [test.cpp:9:13]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("struct A {\n"
+              "    std::string v;\n"
+              "    A(const std::string& s)\n"
+              "    : v(s)\n"
+              "    {}\n"
+              "};\n"
+              "A f() {\n"
+              "    std::string s;\n"
+              "    return A{s};\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "    std::string_view v;\n"
+              "    A(const std::string& s)\n"
+              "    : v(s)\n"
+              "    {}\n"
+              "};\n"
+              "A f() {\n"
+              "    std::string s;\n"
+              "    return A{s};\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:9:14] -> [test.cpp:8:17] -> [test.cpp:9:13]: (error) Returning object that points to local variable 's' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("struct A {\n"
+              "    const int* i;\n"
+              "    A(const int& x)\n"
+              "    : i(&x)\n"
+              "    {}\n"
+              "};\n"
+              "A f() {\n"
+              "    return A{0};\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:8:14] -> [test.cpp:8:13]: (error) Returning object that will be invalid when returning. [returnDanglingLifetime]\n",
+                      errout_str());
+
+        check("struct A {\n"
+              "    int n;\n"
+              "    A(const int &x) : n(x) {}\n"
+              "};\n"
+              "A f() {\n"
+              "    A m(4);\n"
+              "    return m;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct B {};\n"
+              "struct A {\n"
+              "    B n;\n"
+              "    A(const B &x) : n(x) {}\n"
+              "};\n"
+              "A f() {\n"
+              "    A m(B{});\n"
+              "    return m;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "    A(std::vector<std::string> &filenames)\n"
+              "    : files(filenames) {}\n"
+              "    std::vector<std::string> &files;\n"
+              "};\n"
+              "A f() {\n"
+              "    std::vector<std::string> files;\n"
+              "    return A(files);\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:8:14] -> [test.cpp:7:30] -> [test.cpp:8:13]: (error) Returning object that points to local variable 'files' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("struct S {\n"
+              "    explicit S(std::string& s);\n"
+              "}\n"
+              "S f() {\n"
+              "    std::string m(\"abc\");\n"
+              "    return S(m);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n"
+              "    std::string msg;\n"
+              "    explicit S(const char* m) : msg(m) {}\n"
+              "};\n"
+              "S f() {\n"
+              "    std::string s(\"abc\");\n"
+              "    return S(s.c_str());\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n"
+              "    explicit S(const char* p) { m = p; }\n"
+              "    void g();\n"
+              "    std::string m;\n"
+              "    int* t{};\n"
+              "};\n"
+              "void f(const std::stringstream& buffer) {\n"
+              "    S s(buffer.str().c_str());\n"
+              "    s.g();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void danglingLifetimeAggregateConstructor() {
+        check("struct A {\n"
+              "    const int& x;\n"
+              "    int y;\n"
+              "};\n"
+              "A f() {\n"
+              "    int i = 0;\n"
+              "    return A{i, i};\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:7:14] -> [test.cpp:6:9] -> [test.cpp:7:13]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("struct A {\n"
+              "    const int& x;\n"
+              "    int y;\n"
+              "};\n"
+              "A f() {\n"
+              "    int i = 0;\n"
+              "    return {i, i};\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:7:13] -> [test.cpp:6:9] -> [test.cpp:7:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("struct A {\n"
+              "    const int& x;\n"
+              "    int y;\n"
+              "};\n"
+              "A f() {\n"
+              "    int i = 0;\n"
+              "    A r{i, i};\n"
+              "    return r;\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:7:9] -> [test.cpp:6:9] -> [test.cpp:8:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("struct A {\n"
+              "    const int& x;\n"
+              "    int y;\n"
+              "};\n"
+              "A f() {\n"
+              "    int i = 0;\n"
+              "    A r = {i, i};\n"
+              "    return r;\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:7:12] -> [test.cpp:6:9] -> [test.cpp:8:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("struct A {\n"
+              "    const int& x;\n"
+              "    int y;\n"
+              "};\n"
+              "A f(int& x) {\n"
+              "    int i = 0;\n"
+              "    return A{i, x};\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:7:14] -> [test.cpp:6:9] -> [test.cpp:7:13]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("struct A {\n"
+              "    const int& x;\n"
+              "    int y;\n"
+              "};\n"
+              "A f(int& x) {\n"
+              "    int i = 0;\n"
+              "    return A{x, i};\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "    const int& x;\n"
+              "    int y;\n"
+              "};\n"
+              "A f(int& x) {\n"
+              "    return A{x, x};\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A { int i; const int& j; };\n"
+              "A f(int& x) {\n"
+              "    int y = 0;\n"
+              "    return A{y, x};\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct a {\n"
+              "    std::string m;\n"
+              "};\n"
+              "a f() {\n"
+              "    std::array<char, 1024> m {};\n"
+              "    return { m.data() };\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { std::string s; };\n" // #13167
+              "std::vector<S> f() {\n"
+              "    std::vector<S> v;\n"
+              "    {\n"
+              "        std::string a{ \"abc\" };\n"
+              "        v.push_back({ a.c_str() });\n"
+              "    }\n"
+              "    return v;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { std::string_view sv; };\n"
+              "std::vector<S> f() {\n"
+              "    std::vector<S> v;\n"
+              "    {\n"
+              "        std::string a{ \"abc\" };\n"
+              "        v.push_back({ a.c_str() });\n"
+              "    }\n"
+              "    return v;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:6:30] -> [test.cpp:6:30] -> [test.cpp:6:21] -> [test.cpp:5:21] -> [test.cpp:8:12]: (error) Returning object that points to local variable 'a' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("struct S { const std::string& r; };\n" // #14209
+              "S f() {\n"
+              "    std::string s;\n"
+              "    return S{ s };\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:4:15] -> [test.cpp:3:17] -> [test.cpp:4:13]: (error) Returning object that points to local variable 's' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("struct A { int& x; };\n" // #14247
+              "A f() {\n"
+              "    int x = 0;\n"
+              "    A a{.x = x};\n"
+              "    return a;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:4:14] -> [test.cpp:3:9] -> [test.cpp:5:12]: (error) Returning object that points to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("struct A { int x; int& r};\n"
+              "A f(int& r) {\n"
+              "    int x = 0;\n"
+              "    A a{.x = x, .r = r};\n"
+              "    return a;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A { int& x; };\n"
+              "A f() {\n"
+              "    int x = 0;\n"
+              "    A a{ .x{x} };\n"
+              "    return a;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:4:13] -> [test.cpp:3:9] -> [test.cpp:5:12]: (error) Returning object that points to local variable 'x' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
+
+        check("struct A { int x; int& r};\n"
+              "A f(int& r) {\n"
+              "    int x = 0;\n"
+              "    A a{ .x{x}, .r{r} };\n"
+              "    return a;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { int i; bool b; };\n" // #14260
+              "void f() {\n"
+              "    struct S s = { .i = 0, true };\n"
+              "}\n"); // don't crash
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void danglingLifetimeInitList() {
+        check("std::vector<int*> f() {\n"
+              "    int i = 0;\n"
+              "    std::vector<int*> v = {&i, &i};\n"
+              "    return v;\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:3:28] -> [test.cpp:3:28] -> [test.cpp:2:9] -> [test.cpp:4:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n"
+            "[test.cpp:3:32] -> [test.cpp:3:32] -> [test.cpp:2:9] -> [test.cpp:4:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n", // duplicate
+            errout_str());
+
+        check("std::vector<int*> f() {\n"
+              "    int i = 0;\n"
+              "    std::vector<int*> v{&i, &i};\n"
+              "    return v;\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:3:25] -> [test.cpp:3:25] -> [test.cpp:2:9] -> [test.cpp:4:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n"
+            "[test.cpp:3:29] -> [test.cpp:3:29] -> [test.cpp:2:9] -> [test.cpp:4:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n", // duplicate
+            errout_str());
+
+        check("std::vector<int*> f() {\n"
+              "    int i = 0;\n"
+              "    return {&i, &i};\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:3:13] -> [test.cpp:3:13] -> [test.cpp:2:9] -> [test.cpp:3:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n"
+            "[test.cpp:3:17] -> [test.cpp:3:17] -> [test.cpp:2:9] -> [test.cpp:3:12]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n", // duplicate
+            errout_str());
+
+        check("std::vector<int*> f(int& x) {\n"
+              "    return {&x, &x};\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::vector<std::string> f() {\n"
+              "    std::set<std::string> x;\n"
+              "    x.insert(\"1\");\n"
+              "    x.insert(\"2\");\n"
+              "    return { x.begin(), x.end() };\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void danglingLifetimeImplicitConversion() {
+        check("struct A { A(const char *a); };\n"
+              "A f() {\n"
+              "   std::string ba(\"hello\");\n"
+              "   return ba.c_str();\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A { A(const char *a); };\n"
+              "A f() {\n"
+              "   std::string ba(\"hello\");\n"
+              "   A bp = ba.c_str();\n"
+              "   return bp;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A { A(const char *a); };\n"
+              "std::vector<A> f() {\n"
+              "   std::string ba(\"hello\");\n"
+              "   std::vector<A> v;\n"
+              "   v.push_back(ba.c_str());\n"
+              "   return v;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::string f(const std::string& x) {\n"
+              "  const char c[] = \"\";\n"
+              "  if (!x.empty())\n"
+              "    return x + c;\n"
+              "  return \"\";\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::string f(const std::string& x) {\n"
+              "  const char c[] = \"123\";\n"
+              "  if (!x.empty())\n"
+              "    return c + 1;\n"
+              "  return \"\";\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void danglingTemporaryLifetime() {
+        check("struct C {\n" // #11091
+              "    C(C& rhs);\n"
+              "    explicit C(const S& n, const S& p = {});\n"
+              "    bool f() const;\n"
+              "    S m;\n"
+              "};\n"
+              "void f() {\n"
+              "    C c(\"\");\n"
+              "    while (c.f()) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("const int& g(const int& x) {\n"
+              "    return x;\n"
+              "}\n"
+              "void f(int& i) {\n"
+              "    int* x = &g(0);\n"
+              "    i += *x;\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:1:26] -> [test.cpp:2:12] -> [test.cpp:5:15] -> [test.cpp:5:14] -> [test.cpp:5:17] -> [test.cpp:6:11]: (error) Using pointer that is a temporary. [danglingTemporaryLifetime]\n",
+            errout_str());
+
+        check("QString f() {\n"
+              "    QString a(\"dummyValue\");\n"
+              "    const char* b = a.toStdString().c_str();\n"
+              "    QString c = b;\n"
+              "    return c;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:42] -> [test.cpp:3:34] -> [test.cpp:4:15]: (error) Using pointer that is a temporary. [danglingTemporaryLifetime]\n",
+                      errout_str());
+
+        check("auto f(std::string s) {\n"
+              "    const char *x = s.substr(1,2).c_str();\n"
+              "    auto i = s.substr(4,5).begin();\n"
+              "    return *i;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:33] -> [test.cpp:3:22] -> [test.cpp:4:13]: (error) Using iterator that is a temporary. [danglingTemporaryLifetime]\n",
+                      errout_str());
+
+        check("std::string f() {\n"
+              "    std::stringstream tmp;\n"
+              "    const std::string &str = tmp.str();\n"
+              "    return std::string(str.c_str(), 1);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int get_value();\n"
+              "const int &get_reference1() {\n"
+              "  const int &x = get_value();\n"
+              "  return x;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:16] -> [test.cpp:4:10]: (error) Reference to temporary returned. [returnTempReference]\n", errout_str());
+
+        check("int get_value();\n"
+              "const int &get_reference2() {\n"
+              "  const int &x1 = get_value();\n"
+              "  const int &x2 = x1;\n"
+              "  return x2;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:17] -> [test.cpp:3:17] -> [test.cpp:5:10]: (error) Reference to temporary returned. [returnTempReference]\n",
+                      errout_str());
+
+        check("const std::string& getState() {\n"
+              "    static const std::string& state = \"\";\n"
+              "    return state;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct var {\n"
+              "    void fun();\n"
+              "}x;\n"
+              "var* T(const char*) {\n"
+              "    return &x;\n"
+              "}\n"
+              "std::string GetTemp();\n"
+              "void f() {\n"
+              "    auto a = T(GetTemp().c_str());\n"
+              "    a->fun();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "    std::map<int, int> m_;\n"
+              "};\n"
+              "struct B {\n"
+              "    A a_;\n"
+              "};\n"
+              "B func();\n"
+              "void f() {\n"
+              "    const std::map<int, int>::iterator& m = func().a_.m_.begin();\n"
+              "    (void)m->first;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:9:63] -> [test.cpp:9:49] -> [test.cpp:10:11]: (error) Using iterator that is a temporary. [danglingTemporaryLifetime]\n",
+                      errout_str());
+
+        check("struct A {\n" // #14054
+              "    std::map<int, int> m_;\n"
+              "};\n"
+              "struct B {\n"
+              "    A a_;\n"
+              "};\n"
+              "B func();\n"
+              "void f() {\n"
+              "    const std::map<int, int>::iterator m = func().a_.m_.begin();\n"
+              "    (void)m->first;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:9:62] -> [test.cpp:9:48] -> [test.cpp:10:11]: (error) Using iterator that is a temporary. [danglingTemporaryLifetime]\n",
+                      errout_str());
+
+        check("void f(bool b) {\n"
+              "  std::vector<int> ints = g();\n"
+              "  auto *ptr = &ints;\n"
+              "  if (b)\n"
+              "    ptr = &ints;\n"
+              "  for (auto it = ptr->begin(); it != ptr->end(); ++it)\n"
+              "  {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct String {\n" // #10469
+              "    void Append(uint8_t Val);\n"
+              "    String& operator+=(const char s[]);\n"
+              "    String& operator+=(const std::string& Str) {\n"
+              "        return operator+=(Str.c_str());\n"
+              "    }\n"
+              "    void operator+=(uint8_t Val) {\n"
+              "        Append(Val);\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11057
+        check("struct S {\n"
+              "    int& r;\n"
+              "};\n"
+              "void f(int i) {\n"
+              "    const S a[] = { { i } };\n"
+              "    for (const auto& s : a) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::vector<char*> f(const std::vector<std::string>& args) {\n" // #9773
+              "    std::vector<char*> cargs;\n"
+              "    for (const auto& a : args) {\n"
+              "      cargs.push_back(const_cast<char*>(a.data()));\n"
+              "    }\n"
+              "    return cargs;\n"
+              "}\n"
+              "void g() {\n"
+              "    std::vector<char*> cargs = f({ \"0\", \"0\" });\n"
+              "    (void)cargs;\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:6:12] -> [test.cpp:4:47] -> [test.cpp:3:22] -> [test.cpp:1:58] -> [test.cpp:4:40] -> [test.cpp:9:34] -> [test.cpp:9:34] -> [test.cpp:10:11]: (error) Using object that is a temporary. [danglingTemporaryLifetime]\n", errout_str());
+
+        check("struct C {\n" // #9194
+              "    const int& m;\n"
+              "    C(const int& i) : m(i) {}\n"
+              "    int get() { return m; }\n"
+              "};\n"
+              "int f() {\n"
+              "    C c(42);\n"
+              "    return c.get();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:7:9] -> [test.cpp:7:9] -> [test.cpp:8:12]: (error) Using object that is a temporary. [danglingTemporaryLifetime]\n", errout_str());
+
+        // #11298
+        check("struct S {\n"
+              "    std::string g();  \n"
+              "};\n"
+              "struct T {\n"
+              "  void f(); \n"
+              "  S* p = nullptr;\n"
+              "};\n"
+              "struct U {\n"
+              "  explicit U(const char* s);\n"
+              "  bool h();\n"
+              "  int i;\n"
+              "};\n"
+              "void T::f() {\n"
+              "    U u(p->g().c_str());\n"
+              "    if (u.h()) {}\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        // #9275
-        check("struct S {\n"
-              "   void f();\n"
-              "   std::string m;\n"
-              "}\n"
-              "void S::f() {\n"
-              "    char buf[1024];\n"
-              "    const char* msg = buf;\n"
-              "    m = msg;\n"
+        // #11442
+        check("const std::string& f(const P< std::string >& value) {\n"
+              "   static const std::string empty;\n"
+              "   return value.get() == nullptr ? empty : *value;\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
-    }
+        ASSERT_EQUALS("", errout_str());
 
-    void danglingLifetimeFunction() {
-        check("auto f() {\n"
-              "    int a;\n"
-              "    return std::ref(a);\n"
+        // #11472
+        check("namespace N {\n"
+              "    struct T { int m; };\n"
+              "    int i;\n"
+              "    const T& f(const T* p) {\n"
+              "        return p != nullptr ? *p : *reinterpret_cast<const ::N::T*>(&i);\n"
+              "    }\n"
               "}\n");
-        ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:2] -> [test.cpp:3]: (error) Returning object that points to local variable 'a' that will be invalid when returning.\n",
-            errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("auto f() {\n"
-              "    int a;\n"
-              "    return std::make_tuple(std::ref(a));\n"
+        // #11609
+        check("struct S {\n"
+              "    void f(const std::string& s) {\n"
+              "        auto it = m.find(s.substr(1,4));\n"
+              "        if (it == m.end()) {}\n"
+              "    }\n"
+              "    std::map<std::string, int> m;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11628
+        check("std::vector<int>* g();\n"
+              "void f() {\n"
+              "	std::unique_ptr<std::vector<int>> p(g());\n"
+              "	if (!p) {}\n"
               "}\n");
-        ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:3] -> [test.cpp:2] -> [test.cpp:3]: (error) Returning object that points to local variable 'a' that will be invalid when returning.\n",
-            errout.str());
+        ASSERT_EQUALS("", errout_str());
 
+        // #13760
         check("template<class T>\n"
-              "auto by_value(T x) {\n"
-              "    return [=] { return x; };\n"
+              "auto f(T&& x) {\n"
+              "    return [&] {\n"
+              "        return x();\n"
+              "    };\n"
               "}\n"
               "auto g() {\n"
-              "    std::vector<int> v;\n"
-              "    return by_value(v.begin());\n"
+              "    auto y = f([](auto x) { return 1; });\n"
+              "    return y();\n"
               "}\n");
         ASSERT_EQUALS(
-            "[test.cpp:7] -> [test.cpp:7] -> [test.cpp:3] -> [test.cpp:3] -> [test.cpp:6] -> [test.cpp:7]: (error) Returning object that points to local variable 'v' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:3:12] -> [test.cpp:2:13] -> [test.cpp:4:16] -> [test.cpp:8:16] -> [test.cpp:8:16] -> [test.cpp:9:12]: (error) Using object that is a temporary. [danglingTemporaryLifetime]\n",
+            errout_str());
+    }
 
-        check("auto by_ref(int& x) {\n"
-              "    return [&] { return x; };\n"
-              "}\n"
-              "auto f() {\n"
-              "    int i = 0;\n"
-              "    return by_ref(i);\n"
+    void danglingLifetimeBorrowedMembers()
+    {
+        // #10585
+        check("struct Info { int k; };\n"
+              "struct MoreInfo {\n"
+              "    int* k;\n"
+              "    char dat;\n"
+              "};\n"
+              "struct Fields {\n"
+              "    Info info;\n"
+              "};\n"
+              "template <typename T> void func1(T val){}\n"
+              "template <typename T> void func2(T val){}\n"
+              "Fields* get();\n"
+              "void doit() {\n"
+              "    MoreInfo rech;\n"
+              "    rech.k = &get()->info.k;\n"
+              "    func1(&rech.dat);\n"
+              "    func2(rech.k);\n"
               "}\n");
-        ASSERT_EQUALS(
-            "[test.cpp:2] -> [test.cpp:1] -> [test.cpp:2] -> [test.cpp:6] -> [test.cpp:5] -> [test.cpp:6]: (error) Returning object that points to local variable 'i' that will be invalid when returning.\n",
-            errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("auto f(int x) {\n"
-              "    int a;\n"
-              "    std::tie(a) = x;\n"
-              "    return a;\n"
+        check("struct A { int x; };\n"
+              "A* g();\n"
+              "void f() {\n"
+              "    A** ap = &g();\n"
+              "    (*ap)->x;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:14] -> [test.cpp:4:16] -> [test.cpp:5:7]: (error) Using pointer that is a temporary. [danglingTemporaryLifetime]\n",
+                      errout_str());
+
+        check("struct A { int* x; };\n"
+              "A g();\n"
+              "void f() {\n"
+              "    int* x = g().x;\n"
+              "    (void)*x + 1;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A { int x; };\n"
+              "struct B { A* a; }\n"
+              "B g();\n"
+              "void f() {\n"
+              "    int* x = &g()->a.x;\n"
+              "    (void)*x + 1;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A { int x; };\n"
+              "struct B { A* g(); };\n"
+              "A* g();\n"
+              "void f(B b) {\n"
+              "    A** ap = &b.g();\n"
+              "    (*ap)->x;\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:14] -> [test.cpp:5:18] -> [test.cpp:6:7]: (error) Using pointer that is a temporary. [danglingTemporaryLifetime]\n",
+                      errout_str());
     }
 
-    void danglingLifetimeAggegrateConstructor() {
-        check("struct A {\n"
-              "    const int& x;\n"
-              "    int y;\n"
+    void danglingLifetimeClassMemberFunctions()
+    {
+        check("struct S {\n"
+              "    S(int i) : i(i) {}\n"
+              "    int i;\n"
+              "    int* ptr() { return &i; }\n"
               "};\n"
-              "A f() {\n"
-              "    int i = 0;\n"
-              "    return A{i, i};\n"
+              "int* fun(int i) { \n"
+              "    return S(i).ptr();\n"
               "}\n");
         ASSERT_EQUALS(
-            "[test.cpp:7] -> [test.cpp:6] -> [test.cpp:7]: (error) Returning object that points to local variable 'i' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:4:25] -> [test.cpp:4:25] -> [test.cpp:7:13] -> [test.cpp:7:20]: (error) Returning pointer that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
 
-        check("struct A {\n"
-              "    const int& x;\n"
-              "    int y;\n"
+        check("struct Fred\n"
+              "{\n"
+              "    int x[2];\n"
+              "    Fred() {\n"
+              "        x[0] = 0x41;\n"
+              "        x[1] = 0x42;\n"
+              "    }\n"
+              "    const int *get_x() {\n"
+              "        return x;\n"
+              "    }\n"
               "};\n"
-              "A f() {\n"
-              "    int i = 0;\n"
-              "    return {i, i};\n"
+              "static const int *foo() {\n"
+              "    Fred fred;\n"
+              "    return fred.get_x();\n"
               "}\n");
         ASSERT_EQUALS(
-            "[test.cpp:7] -> [test.cpp:6] -> [test.cpp:7]: (error) Returning object that points to local variable 'i' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:9:16] -> [test.cpp:9:16] -> [test.cpp:14:12] -> [test.cpp:13:10] -> [test.cpp:14:22]: (error) Returning pointer to local variable 'fred' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
 
-        // TODO: Ast is missing for this case
         check("struct A {\n"
-              "    const int& x;\n"
-              "    int y;\n"
+              "    int i;\n"
+              "    auto f() const {\n"
+              "        return [=]{ return i; };\n"
+              "    }\n"
               "};\n"
-              "A f() {\n"
-              "    int i = 0;\n"
-              "    A r{i, i};\n"
-              "    return r;\n"
+              "auto g() {\n"
+              "    return A().f();\n"
               "}\n");
-        TODO_ASSERT_EQUALS(
-            "[test.cpp:7] -> [test.cpp:6] -> [test.cpp:7]: (error) Returning object that points to local variable 'i' that will be invalid when returning.\n",
-            "",
-            errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:4:16] -> [test.cpp:4:28] -> [test.cpp:8:13] -> [test.cpp:8:17]: (error) Returning object that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
 
         check("struct A {\n"
-              "    const int& x;\n"
-              "    int y;\n"
+              "    int i;\n"
+              "    auto f() const {\n"
+              "        return [*this]{ return i; };\n"
+              "    }\n"
               "};\n"
-              "A f() {\n"
-              "    int i = 0;\n"
-              "    A r = {i, i};\n"
-              "    return r;\n"
+              "auto g() {\n"
+              "    return A().f();\n"
               "}\n");
-        ASSERT_EQUALS(
-            "[test.cpp:7] -> [test.cpp:6] -> [test.cpp:8]: (error) Returning object that points to local variable 'i' that will be invalid when returning.\n",
-            errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
-              "    const int& x;\n"
-              "    int y;\n"
+              "    int* i;\n"
+              "    auto f() const {\n"
+              "        return [*this]{ return i; };\n"
+              "    }\n"
               "};\n"
-              "A f(int& x) {\n"
+              "auto g() {\n"
               "    int i = 0;\n"
-              "    return A{i, x};\n"
+              "    return A{&i}.f();\n"
               "}\n");
         ASSERT_EQUALS(
-            "[test.cpp:7] -> [test.cpp:6] -> [test.cpp:7]: (error) Returning object that points to local variable 'i' that will be invalid when returning.\n",
-            errout.str());
+            "[test.cpp:9:14] -> [test.cpp:9:14] -> [test.cpp:9:13] -> [test.cpp:4:16] -> [test.cpp:4:18] -> [test.cpp:8:9] -> [test.cpp:9:19]: (error) Returning object that points to local variable 'i' that will be invalid when returning. [returnDanglingLifetime]\n",
+            errout_str());
 
-        check("struct A {\n"
-              "    const int& x;\n"
-              "    int y;\n"
+        check("struct S {\n"
+              "    int i{};\n"
               "};\n"
-              "A f(int& x) {\n"
-              "    int i = 0;\n"
-              "    return A{x, i};\n"
+              "struct T {\n"
+              "    S getS() const { return S{ j }; }\n"
+              "    int j{};\n"
+              "};\n"
+              "void f(S* p) {\n"
+              "    S ret;\n"
+              "    {\n"
+              "        T t;\n"
+              "        ret = t.getS();\n"
+              "    }\n"
+              "    *p = ret;\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
-              "    const int& x;\n"
-              "    int y;\n"
+              "    int val=42;\n"
+              "    const A& Get() const & {\n"
+              "        return *this;\n"
+              "    }\n"
               "};\n"
-              "A f(int& x) {\n"
-              "    return A{x, x};\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
-
-        check("struct A { int i; const int& j; };\n"
-              "A f(int& x) {\n"
-              "    int y = 0;\n"
-              "    return A{y, x};\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
-    }
-
-    void danglingLifetimeInitList() {
-        check("std::vector<int*> f() {\n"
-              "    int i = 0;\n"
-              "    std::vector<int*> v = {&i, &i};\n"
-              "    return v;\n"
+              "const A *ptr;\n"
+              "int main() {\n"
+              "    ptr = &A().Get();\n"
+              "    return ptr->val;\n"
               "}\n");
         ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:3] -> [test.cpp:2] -> [test.cpp:4]: (error) Returning object that points to local variable 'i' that will be invalid when returning.\n",
-            errout.str());
-
-        // TODO: Ast is missing for this case
-        check("std::vector<int*> f() {\n"
-              "    int i = 0;\n"
-              "    std::vector<int*> v{&i, &i};\n"
-              "    return v;\n"
-              "}\n");
-        TODO_ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:3] -> [test.cpp:2] -> [test.cpp:4]: (error) Returning object that points to local variable 'i' that will be invalid when returning.\n",
-            "",
-            errout.str());
+            "[test.cpp:4:16] -> [test.cpp:9:16] -> [test.cpp:9:11] -> [test.cpp:9:13] -> [test.cpp:10:12]: (error) Using pointer that is a temporary. [danglingTemporaryLifetime]\n",
+            errout_str());
 
-        check("std::vector<int*> f() {\n"
-              "    int i = 0;\n"
-              "    return {&i, &i};\n"
+        check("struct A {\n"
+              "    int val = 42;\n"
+              "    const A& Get() const {\n"
+              "        return *this;\n"
+              "    }\n"
+              "};\n"
+              "int main() {\n"
+              "    const A& r = A().Get();\n"
+              "    return r.val;\n"
               "}\n");
         ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:3] -> [test.cpp:2] -> [test.cpp:3]: (error) Returning object that points to local variable 'i' that will be invalid when returning.\n",
-            errout.str());
-
-        check("std::vector<int*> f(int& x) {\n"
-              "    return {&x, &x};\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
-    }
-
-    void danglingLifetimeImplicitConversion() {
-        check("struct A { A(const char *a); };\n"
-              "A f() {\n"
-              "   std::string ba(\"hello\");\n"
-              "   return ba.c_str();\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
-
-        check("struct A { A(const char *a); };\n"
-              "A f() {\n"
-              "   std::string ba(\"hello\");\n"
-              "   A bp = ba.c_str();\n"
-              "   return bp;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
-
-        check("struct A { A(const char *a); };\n"
-              "std::vector<A> f() {\n"
-              "   std::string ba(\"hello\");\n"
-              "   std::vector<A> v;\n"
-              "   v.push_back(ba.c_str());\n"
-              "   return v;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+            "[test.cpp:8:16] -> [test.cpp:4:16] -> [test.cpp:8:22] -> [test.cpp:9:12]: (error) Using reference to dangling temporary. [danglingTempReference]\n",
+            errout_str());
     }
 
     void invalidLifetime() {
@@ -2166,8 +4533,8 @@ class TestAutoVariables : public TestFixture {
               "        f = [&]{ return b; };\n"
               "    }\n"
               "    f();\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:4] -> [test.cpp:7]: (error) Using lambda that captures local variable 'b' that is out of scope.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:25] -> [test.cpp:4:13] -> [test.cpp:7:5]: (error) Using lambda that captures local variable 'b' that is out of scope. [invalidLifetime]\n", errout_str());
 
         check("void f(bool b)  {\n"
               "  int* x;\n"
@@ -2176,10 +4543,10 @@ class TestAutoVariables : public TestFixture {
               "    x = y;\n"
               "  }\n"
               "  x[3];\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:5] -> [test.cpp:4] -> [test.cpp:7]: (error) Using pointer to local variable 'y' that is out of scope.\n",
-            errout.str());
+            "[test.cpp:5:9] -> [test.cpp:4:9] -> [test.cpp:7:3]: (error) Using pointer to local variable 'y' that is out of scope. [invalidLifetime]\n",
+            errout_str());
 
         check("void foo(int a) {\n"
               "    std::function<void()> f;\n"
@@ -2188,8 +4555,8 @@ class TestAutoVariables : public TestFixture {
               "        f = [&]{ return b; };\n"
               "        f();\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct a {\n"
               "  b();\n"
@@ -2197,16 +4564,16 @@ class TestAutoVariables : public TestFixture {
               "};\n"
               "void a::b() {\n"
               "  c.end()\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void b(char f[], char c[]) {\n"
               "  std::string d(c); {\n"
               "    std::string e;\n"
               "    b(f, e.c_str())\n"
               "  }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(bool b) {\n"
               "    std::string s;\n"
@@ -2215,12 +4582,148 @@ class TestAutoVariables : public TestFixture {
               "        s = buf;\n"
               "    }\n"
               "    std::cout << s;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("int &a[];\n"
-              "void b(){int *c = a};\n");
-        ASSERT_EQUALS("", errout.str());
+              "void b(){int *c = a};");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "    int x;\n"
+              "};\n"
+              "struct B {\n"
+              "    std::function<void()> x;\n"
+              "    void f() {\n"
+              "        this->x = [&] {\n"
+              "            B y;\n"
+              "            return y.x;\n"
+              "        };\n"
+              "    }\n"
+              "};");
+        ASSERT_EQUALS("", errout_str());
+
+        check("namespace test {\n"
+              "class Foo {};\n"
+              "struct Bar {\n"
+              "  Foo *_foo;\n"
+              "};\n"
+              "\n"
+              "int f(Bar *bar);\n"
+              "\n"
+              "void g(Bar *bar) {\n"
+              "  {\n"
+              "    Foo foo;\n"
+              "    bar->_foo = &foo;\n"
+              "    bar->_foo = nullptr;\n"
+              "  }\n"
+              "  f(bar);\n"
+              "}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("class Foo {};\n"
+              "struct Bar {\n"
+              "  Foo *_foo;\n"
+              "};\n"
+              "\n"
+              "int f(Bar *bar);\n"
+              "\n"
+              "void g(Bar *bar) {\n"
+              "  {\n"
+              "    Foo foo;\n"
+              "    bar->_foo = &foo;\n"
+              "    bar->_foo = nullptr;\n"
+              "  }\n"
+              "  f(bar);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("namespace test {\n"
+              "class Foo {};\n"
+              "struct Bar {\n"
+              "  Foo *_foo;\n"
+              "};\n"
+              "\n"
+              "int f(Bar *bar);\n"
+              "\n"
+              "void g(Bar *bar) {\n"
+              "  {\n"
+              "    Foo foo;\n"
+              "    bar->_foo = &foo;\n"
+              "  }\n"
+              "  f(bar);\n"
+              "}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:12:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
+
+        check("class Foo {};\n"
+              "struct Bar {\n"
+              "  Foo *_foo;\n"
+              "};\n"
+              "\n"
+              "int f(Bar *bar);\n"
+              "\n"
+              "void g(Bar *bar) {\n"
+              "  {\n"
+              "    Foo foo;\n"
+              "    bar->_foo = &foo;\n"
+              "  }\n"
+              "  f(bar);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:11:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
+
+        check("class Foo {};\n" // #10750
+              "struct Bar {\n"
+              "  Foo *_foo;\n"
+              "};\n"
+              "int f(Bar *bar);\n"
+              "void g(Bar *bar) {\n"
+              "  {\n"
+              "    Foo foo;\n"
+              "    {\n"
+              "      bar->_foo = &foo;\n"
+              "    }\n"
+              "  }\n"
+              "  f(bar);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:10:7]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n", errout_str());
+
+        check("void f(std::string_view text);\n" // #11508
+              "void g() {\n"
+              "  std::string teststr;\n"
+              "  f(teststr);"
+              "}\n"
+              "void f(std::string_view text) {"
+              "  g(text.data());\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::span<int> data);\n" // #11508
+              "void g() {\n"
+              "  std::vector<int> v;\n"
+              "  f(v);"
+              "}\n"
+              "void f(std::span<int> data) {"
+              "  g(data.begin());\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n"
+              "    int* a[1];\n"
+              "    int* b[1][1];\n"
+              "};\n"
+              "void f(S* s) {\n"
+              "    int i = 0;\n"
+              "    s->a[0] = &i;\n"
+              "}\n"
+              "void g(S* s) {\n"
+              "    int i = 0;\n"
+              "    s->b[0][0] = &i;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:7:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n"
+                      "[test.cpp:11:5]: (error) Address of local auto-variable assigned to a function parameter. [autoVariables]\n",
+                      errout_str());
     }
 
     void deadPointer() {
@@ -2232,7 +4735,7 @@ class TestAutoVariables : public TestFixture {
               "  }\n"
               "  *p = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:4] -> [test.cpp:7]: (error) Using pointer to local variable 'x' that is out of scope.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:4:9] -> [test.cpp:7:4]: (error) Using pointer to local variable 'x' that is out of scope. [invalidLifetime]\n", errout_str());
 
         // FP: don't warn in subfunction
         check("void f(struct KEY *key) {\n"
@@ -2249,7 +4752,7 @@ class TestAutoVariables : public TestFixture {
               "  }\n"
               "  f(tmp);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Don't warn about references (#6399)
         check("void f() {\n"
@@ -2261,7 +4764,7 @@ class TestAutoVariables : public TestFixture {
               "    if (former_hover != pitem)\n"
               "        dosth();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    wxAuiToolBarItem* former_hover = NULL;\n"
@@ -2272,7 +4775,9 @@ class TestAutoVariables : public TestFixture {
               "    if (former_hover != pitem)\n"
               "        dosth();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:4] -> [test.cpp:7]: (error) Using pointer to local variable 'item' that is out of scope.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:5:24] -> [test.cpp:3:47] -> [test.cpp:4:26] -> [test.cpp:7:9]: (error) Using pointer to local variable 'item' that is out of scope. [invalidLifetime]\n",
+            errout_str());
 
         // #6575
         check("void trp_deliver_signal()  {\n"
@@ -2283,7 +4788,7 @@ class TestAutoVariables : public TestFixture {
               "    EventReport * rep = &repData;\n"
               "    rep->setEventType(NDB_LE_Connected);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #8785
         check("int f(bool a, bool b) {\n"
@@ -2295,8 +4800,45 @@ class TestAutoVariables : public TestFixture {
               "    if(b && a)\n"
               "        return *iPtr;\n"
               "    return 0;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:16] -> [test.cpp:4:13] -> [test.cpp:8:17]: (error) Using pointer to local variable 'x' that is out of scope. [invalidLifetime]\n", errout_str());
+
+        // #11753
+        check("int main(int argc, const char *argv[]) {\n"
+              "    const char* s = \"\";\n"
+              "    if (argc > 0) {\n"
+              "        char buff[32]{};\n"
+              "        s = std::strncpy(buff, argv[0], 31);\n"
+              "    }\n"
+              "    std::cout << s;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:26] -> [test.cpp:4:14] -> [test.cpp:7:18]: (error) Using pointer to local variable 'buff' that is out of scope. [invalidLifetime]\n", errout_str());
+
+        check("char* f(char* dst) {\n"
+              "    const char* src = \"abc\";\n"
+              "    return strcpy(dst, src);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void splitNamespaceAuto() { // #10473
+        check("namespace ns\n"
+              "{\n"
+              "    auto var{ 0 };\n"
+              "}\n"
+              "namespace ns\n"
+              "{\n"
+              "    int i;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void incompleteTypeArray() { // #13787
+        check("struct S (*a[10]);\n"
+              "void f(int i, struct S* p) {\n"
+              "    a[i] = &p[i];\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:4] -> [test.cpp:8]: (error) Using pointer to local variable 'x' that is out of scope.\n", errout.str());
+        ASSERT_EQUALS("", errout_str()); // don't crash
     }
 
 };
diff --git a/test/testbool.cpp b/test/testbool.cpp
index 385a984c597..70860a8c169 100644
--- a/test/testbool.cpp
+++ b/test/testbool.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,26 +16,23 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include "checkbool.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
 
+#include <cstddef>
 
 class TestBool : public TestFixture {
 public:
-    TestBool() : TestFixture("TestBool") {
-    }
+    TestBool() : TestFixture("TestBool") {}
 
 private:
-    Settings settings;
-
-    void run() OVERRIDE {
-        settings.addEnabled("style");
-        settings.addEnabled("warning");
-        settings.inconclusive = true;
+    const Settings settings = settingsBuilder().severity(Severity::style).severity(Severity::warning).certainty(Certainty::inconclusive).build();
 
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(bitwiseOnBoolean);      // if (bool & bool)
         TEST_CASE(incrementBoolean);
         TEST_CASE(assignBoolToPointer);
@@ -55,6 +52,7 @@ class TestBool : public TestFixture {
         TEST_CASE(comparisonOfBoolWithInt7); // #4846 - (!x == true)
         TEST_CASE(comparisonOfBoolWithInt8); // #9165
         TEST_CASE(comparisonOfBoolWithInt9); // #9304
+        TEST_CASE(comparisonOfBoolWithInt10); // #10935
 
         TEST_CASE(checkComparisonOfFuncReturningBool1);
         TEST_CASE(checkComparisonOfFuncReturningBool2);
@@ -62,6 +60,8 @@ class TestBool : public TestFixture {
         TEST_CASE(checkComparisonOfFuncReturningBool4);
         TEST_CASE(checkComparisonOfFuncReturningBool5);
         TEST_CASE(checkComparisonOfFuncReturningBool6);
+        TEST_CASE(checkComparisonOfFuncReturningBool7); // #7197
+        TEST_CASE(checkComparisonOfFuncReturningBool8); // #4103
         // Integration tests..
         TEST_CASE(checkComparisonOfFuncReturningBoolIntegrationTest1); // #7798 overloaded functions
 
@@ -76,20 +76,20 @@ class TestBool : public TestFixture {
         TEST_CASE(returnNonBoolClass);
     }
 
-    void check(const char code[], bool experimental = false, const char filename[] = "test.cpp") {
-        // Clear the error buffer..
-        errout.str("");
-
-        settings.experimental = experimental;
+    struct CheckOptions
+    {
+        bool cpp = true;
+    };
 
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, filename);
+        SimpleTokenizer tokenizer(settings, *this, options.cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check...
-        CheckBool checkBool(&tokenizer, &settings, this);
-        checkBool.runChecks(&tokenizer, &settings, this);
+        runChecks<CheckBool>(tokenizer, this);
     }
 
 
@@ -97,28 +97,28 @@ class TestBool : public TestFixture {
         check("void foo(bool *p) {\n"
               "    p = false;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Boolean value assigned to pointer.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:7]: (error) Boolean value assigned to pointer. [assignBoolToPointer]\n", errout_str());
 
         check("void foo(bool *p) {\n"
               "    p = (x<y);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Boolean value assigned to pointer.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:7]: (error) Boolean value assigned to pointer. [assignBoolToPointer]\n", errout_str());
 
         check("void foo(bool *p) {\n"
               "    p = (x||y);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Boolean value assigned to pointer.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:7]: (error) Boolean value assigned to pointer. [assignBoolToPointer]\n", errout_str());
 
         check("void foo(bool *p) {\n"
               "    p = (x&&y);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Boolean value assigned to pointer.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:7]: (error) Boolean value assigned to pointer. [assignBoolToPointer]\n", errout_str());
 
         // check against potential false positives
         check("void foo(bool *p) {\n"
               "    *p = false;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ticket #5046 - false positive: Boolean value assigned to pointer
         check("struct S {\n"
@@ -127,8 +127,8 @@ class TestBool : public TestFixture {
               "void f() {\n"
               "    S s = {0};\n"
               "    *s.p = true;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n"
               "    bool *p;\n"
@@ -136,14 +136,14 @@ class TestBool : public TestFixture {
               "void f() {\n"
               "    S s = {0};\n"
               "    s.p = true;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Boolean value assigned to pointer.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:6:9]: (error) Boolean value assigned to pointer. [assignBoolToPointer]\n", errout_str());
 
         // ticket #5627 - false positive: template
         check("void f() {\n"
               "    X *p = new ::std::pair<int,int>[rSize];\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ticket #6588 (c mode)
         check("struct MpegEncContext { int *q_intra_matrix, *q_chroma_intra_matrix; };\n"
@@ -152,8 +152,8 @@ class TestBool : public TestFixture {
               "  const int *rmat = n < 4 ? " /* OK */
               "                       ctx->q_intra_matrix :"
               "                       ctx->q_chroma_intra_matrix;\n"
-              "}", /*experimental=*/false, "test.c");
-        ASSERT_EQUALS("[test.c:3]: (error) Boolean value assigned to pointer.\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:3:19]: (error) Boolean value assigned to pointer. [assignBoolToPointer]\n", errout_str());
 
         // ticket #6588 (c++ mode)
         check("struct MpegEncContext { int *q_intra_matrix, *q_chroma_intra_matrix; };\n"
@@ -163,7 +163,7 @@ class TestBool : public TestFixture {
               "                       ctx->q_intra_matrix :"
               "                       ctx->q_chroma_intra_matrix;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Boolean value assigned to pointer.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:19]: (error) Boolean value assigned to pointer. [assignBoolToPointer]\n", errout_str());
 
         // ticket #6665
         check("void pivot_big(char *first, int compare(const void *, const void *)) {\n"
@@ -171,38 +171,38 @@ class TestBool : public TestFixture {
               "  char* m1 = compare(a, b) < 0\n"
               "      ? (compare(b, c) < 0 ? b : (compare(a, c) < 0 ? c : a))\n"
               "      : (compare(a, c) < 0 ? a : (compare(b, c) < 0 ? c : b));\n"
-              "}", /*experimental=*/false, "test.c");
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
         // #7381
         check("void foo(bool *p, bool b) {\n"
               "    p = b;\n"
               "    p = &b;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Boolean value assigned to pointer.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:7]: (error) Boolean value assigned to pointer. [assignBoolToPointer]\n", errout_str());
     }
 
     void assignBoolToFloat() {
         check("void foo1() {\n"
               "    double d = false;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Boolean value assigned to floating point variable.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (style) Boolean value assigned to floating point variable. [assignBoolToFloat]\n", errout_str());
 
         check("void foo2() {\n"
               "    float d = true;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Boolean value assigned to floating point variable.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (style) Boolean value assigned to floating point variable. [assignBoolToFloat]\n", errout_str());
 
         check("void foo3() {\n"
               "    long double d = (2>1);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Boolean value assigned to floating point variable.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:19]: (style) Boolean value assigned to floating point variable. [assignBoolToFloat]\n", errout_str());
 
         // stability - don't crash:
         check("void foo4() {\n"
               "    unknown = false;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n"
               "    float p;\n"
@@ -210,8 +210,8 @@ class TestBool : public TestFixture {
               "void f() {\n"
               "    S s = {0};\n"
               "    s.p = true;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:6]: (style) Boolean value assigned to floating point variable.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:6:9]: (style) Boolean value assigned to floating point variable. [assignBoolToFloat]\n", errout_str());
 
         check("struct S {\n"
               "    float* p[1];\n"
@@ -219,221 +219,192 @@ class TestBool : public TestFixture {
               "void f() {\n"
               "    S s = {0};\n"
               "    *s.p[0] = true;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:6]: (style) Boolean value assigned to floating point variable.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:6:13]: (style) Boolean value assigned to floating point variable. [assignBoolToFloat]\n", errout_str());
     }
 
     void comparisonOfBoolExpressionWithInt1() {
         check("void f(int x) {\n"
               "    if ((x && 0x0f)==6)\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:20]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x && 0x0f)==0)\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x || 0x0f)==6)\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:20]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x || 0x0f)==0)\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x & 0x0f)==6)\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x | 0x0f)==6)\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
 
         check("void f(int x) {\n"
               "    if ((5 && x)==3)\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:17]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((5 && x)==3 || (8 && x)==9)\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:2:17]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n"
+            "[test.cpp:2:32]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n",   // duplicate
+            errout_str());
 
         check("void f(int x) {\n"
               "    if ((5 && x)!=3)\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:17]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
 
         check("void f(int x) {\n"
               "    if ((5 && x) > 3)\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:18]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((5 && x) > 0)\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if ((5 && x) < 0)\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+              "}"
+              );
+        ASSERT_EQUALS("[test.cpp:2:18]: (warning) Comparison of a boolean expression with an integer. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((5 && x) < 1)\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if ((5 && x) > 1)\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+              "}"
+              );
+        ASSERT_EQUALS("[test.cpp:2:18]: (warning) Comparison of a boolean expression with an integer. [compareBoolExpressionWithInt]\n", errout_str());
 
 
         check("void f(int x) {\n"
               "    if (0 < (5 && x))\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if (0 > (5 && x))\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+              "}"
+              );
+        ASSERT_EQUALS("[test.cpp:2:11]: (warning) Comparison of a boolean expression with an integer. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (1 > (5 && x))\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if (1 < (5 && x))\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+              "}"
+              );
+        ASSERT_EQUALS("[test.cpp:2:11]: (warning) Comparison of a boolean expression with an integer. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(bool x ) {\n"
               "  if ( x > false )\n"
               "      a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=).\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:12]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=). [comparisonOfBoolWithInvalidComparator]\n", errout_str());
 
         check("void f(bool x ) {\n"
               "  if ( false < x )\n"
               "      a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=).\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:16]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=). [comparisonOfBoolWithInvalidComparator]\n", errout_str());
 
         check("void f(bool x ) {\n"
               "  if ( x < false )\n"
               "      a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=).\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:12]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=). [comparisonOfBoolWithInvalidComparator]\n", errout_str());
 
         check("void f(bool x ) {\n"
               "  if ( false > x )\n"
               "      a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=).\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:16]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=). [comparisonOfBoolWithInvalidComparator]\n", errout_str());
 
         check("void f(bool x ) {\n"
               "  if ( x >= false )\n"
               "      a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=).\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:13]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=). [comparisonOfBoolWithInvalidComparator]\n", errout_str());
 
         check("void f(bool x ) {\n"
               "  if ( false >= x )\n"
               "      a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=).\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:17]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=). [comparisonOfBoolWithInvalidComparator]\n", errout_str());
 
         check("void f(bool x ) {\n"
               "  if ( x <= false )\n"
               "      a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=).\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:13]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=). [comparisonOfBoolWithInvalidComparator]\n", errout_str());
 
         check("void f(bool x ) {\n"
               "  if ( false <= x )\n"
               "      a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=).\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:17]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=). [comparisonOfBoolWithInvalidComparator]\n", errout_str());
 
         check("typedef int (*func)(bool invert);\n"
               "void x(int, func f);\n"
               "void foo(int error) {\n"
               "  if (error == ABC) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f() { return !a+b<c; }"); // #5072
-        ASSERT_EQUALS("",errout.str());
+        ASSERT_EQUALS("",errout_str());
 
         check("int f() { return (!a+b<c); }");
-        ASSERT_EQUALS("",errout.str());
-
-        {
-            const char code[] = "void f(int x, bool y) { if ( x != y ) {} }";
-
-            check(code, false, "test.cpp");
-            ASSERT_EQUALS("[test.cpp:1]: (warning) Comparison of a boolean expression with an integer.\n", errout.str());
-
-            check(code, false, "test.c");
-            ASSERT_EQUALS("", errout.str());
-        }
+        ASSERT_EQUALS("",errout_str());
 
         check("int f() { return (a+(b<5)<=c); }");
-        ASSERT_EQUALS("",errout.str());
+        ASSERT_EQUALS("",errout_str());
     }
 
     void comparisonOfBoolExpressionWithInt2() {
@@ -442,85 +413,85 @@ class TestBool : public TestFixture {
               "        printf(\"x not equal to 10\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:12]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (!x != 10) {\n"
               "        printf(\"x not equal to 10\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:12]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x != 10) {\n"
               "        printf(\"x not equal to 10\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if (10 == !x) {\n"
               "        printf(\"x not equal to 10\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:12]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (10 != !x) {\n"
               "        printf(\"x not equal to 10\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:12]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int x, int y) {\n"
               "    if (y != !x) {\n"
               "        printf(\"x not equal to 10\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, bool y) {\n"
               "    if (y != !x) {\n"
               "        printf(\"x not equal to 10\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if (10 != x) {\n"
               "        printf(\"x not equal to 10\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, int y) {\n"
               "    return (!y == !x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f(int a) {\n"
               "  return (x()+1 == !a);\n"
               "}");
-        TODO_ASSERT_EQUALS("error", "", errout.str());
+        TODO_ASSERT_EQUALS("error", "", errout_str());
 
         check("void f() { if (!!a+!!b+!!c>1){} }");
-        ASSERT_EQUALS("",errout.str());
+        ASSERT_EQUALS("",errout_str());
 
         check("void f(int a, int b, int c) { if (a != !b || c) {} }");
-        ASSERT_EQUALS("",errout.str());
+        ASSERT_EQUALS("",errout_str());
 
         check("void f(int a, int b, int c) { if (1 < !!a + !!b + !!c) {} }");
-        ASSERT_EQUALS("",errout.str());
+        ASSERT_EQUALS("",errout_str());
 
         check("void f(int a, int b, int c) { if (1 < !(a+b)) {} }");
-        ASSERT_EQUALS("[test.cpp:1]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n",errout.str());
+        ASSERT_EQUALS("[test.cpp:1:37]: (warning) Comparison of a boolean expression with an integer. [compareBoolExpressionWithInt]\n",errout_str());
     }
 
     void comparisonOfBoolExpressionWithInt3() {
         check("int f(int x) {\n"
               "    return t<0>() && x;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void comparisonOfBoolExpressionWithInt4() {
@@ -528,48 +499,48 @@ class TestBool : public TestFixture {
         check("void f() {\n"
               "  for(int i = 4; i > -1 < 5 ; --i) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:25]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(int a, int b, int c) {\n"
               "  return (a > b) < c;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer.\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int a, int b, int c) {\n"
               "  return x(a > b) < c;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int a, int b, int c) {\n"
               "  return a > b == c;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // templates
         check("struct Tokenizer { TokenList list; };\n"
               "void Tokenizer::f() {\n"
               "  std::list<Token*> locationList;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #5063 - or
         check("void f() {\n"
               "  return a > b or c < d;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "  return (a < b) != 0U;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("int f() {\n"
               "  return (a < b) != 0x0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("int f() {\n"
               "  return (a < b) != 42U;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:18]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
     }
 
     void checkComparisonOfFuncReturningBool1() {
@@ -593,17 +564,24 @@ class TestBool : public TestFixture {
               "     else\n"
               "         return true;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Comparison of two functions returning boolean value using relational (<, >, <= or >=) operator.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:17]: (style) Comparison of two functions returning boolean value using relational (<, >, <= or >=) operator. [comparisonOfTwoFuncsReturningBoolError]\n", errout_str());
     }
 
     void checkComparisonOfFuncReturningBool2() {
-        check("void f(){\n"
+        check("void leftOfComparison(){\n"
               " int temp = 4;\n"
               " bool a = true;\n"
               " if(compare(temp) > a){\n"
               "     printf(\"foo\");\n"
               " }\n"
               "}\n"
+              "void rightOfComparison(){\n"
+              " int temp = 4;\n"
+              " bool a = true;\n"
+              " if(a < compare(temp)){\n"
+              "     printf(\"foo\");\n"
+              " }\n"
+              "}\n"
               "bool compare(int temp){\n"
               "  if(temp==4){\n"
               "     return true;\n"
@@ -611,7 +589,8 @@ class TestBool : public TestFixture {
               "    else\n"
               "     return false;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Comparison of a function returning boolean value using relational (<, >, <= or >=) operator.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:12]: (style) Comparison of a function returning boolean value using relational (<, >, <= or >=) operator. [comparisonOfFuncReturningBoolError]\n"
+                      "[test.cpp:11:7]: (style) Comparison of a function returning boolean value using relational (<, >, <= or >=) operator. [comparisonOfFuncReturningBoolError]\n", errout_str());
     }
 
     void checkComparisonOfFuncReturningBool3() {
@@ -621,15 +600,9 @@ class TestBool : public TestFixture {
               "         printf(\"foo\");\n"
               "   }\n"
               "}\n"
-              "bool compare(int temp){\n"
-              "   if(temp==4){\n"
-              "     return true;\n"
-              "   }\n"
-              " else\n"
-              "     return false;\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Comparison of a boolean expression with an integer.\n"
-                      "[test.cpp:3]: (style) Comparison of a function returning boolean value using relational (<, >, <= or >=) operator.\n", errout.str());
+              "bool compare(int temp);");
+        ASSERT_EQUALS("[test.cpp:3:19]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n"
+                      "[test.cpp:3:12]: (style) Comparison of a function returning boolean value using relational (<, >, <= or >=) operator. [comparisonOfFuncReturningBoolError]\n", errout_str());
     }
 
     void checkComparisonOfFuncReturningBool4() {
@@ -654,7 +627,7 @@ class TestBool : public TestFixture {
               " else\n"
               "     return false;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Comparison of a function returning boolean value using relational (<, >, <= or >=) operator.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (style) Comparison of a function returning boolean value using relational (<, >, <= or >=) operator. [comparisonOfFuncReturningBoolError]\n", errout_str());
     }
 
     void checkComparisonOfFuncReturningBool5() {
@@ -678,7 +651,7 @@ class TestBool : public TestFixture {
               "     else\n"
               "         return true;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Comparison of two functions returning boolean value using relational (<, >, <= or >=) operator.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:17]: (style) Comparison of two functions returning boolean value using relational (<, >, <= or >=) operator. [comparisonOfTwoFuncsReturningBoolError]\n", errout_str());
     }
 
     void checkComparisonOfFuncReturningBool6() {
@@ -692,7 +665,7 @@ class TestBool : public TestFixture {
               "        printf(\"foo\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("namespace Foo {\n"
               "    bool compare1(int temp);\n"
@@ -704,7 +677,7 @@ class TestBool : public TestFixture {
               "        printf(\"foo\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int compare1(int temp);\n"
               "namespace Foo {\n"
@@ -716,7 +689,7 @@ class TestBool : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (style) Comparison of a function returning boolean value using relational (<, >, <= or >=) operator.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:20]: (style) Comparison of a function returning boolean value using relational (<, >, <= or >=) operator. [comparisonOfFuncReturningBoolError]\n", errout_str());
 
         check("int compare1(int temp);\n"
               "namespace Foo {\n"
@@ -728,7 +701,7 @@ class TestBool : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool compare1(int temp);\n"
               "void f(){\n"
@@ -737,7 +710,64 @@ class TestBool : public TestFixture {
               "        printf(\"foo\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void checkComparisonOfFuncReturningBool7() { // #7197
+        check("struct C {\n"
+              "    bool isEmpty();\n"
+              "};\n"
+              "void f() {\n"
+              "    C c1, c2;\n"
+              "    if ((c1.isEmpty()) < (c2.isEmpty())) {}\n"
+              "    if (!c1.isEmpty() < !!c2.isEmpty()) {}\n"
+              "    if ((int)c1.isEmpty() < (int)c2.isEmpty()) {}\n"
+              "    if (static_cast<int>(c1.isEmpty()) < static_cast<int>(c2.isEmpty())) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:20]: (style) Comparison of two functions returning boolean value using relational (<, >, <= or >=) operator. [comparisonOfTwoFuncsReturningBoolError]\n"
+                      "[test.cpp:7:20]: (style) Comparison of two functions returning boolean value using relational (<, >, <= or >=) operator. [comparisonOfTwoFuncsReturningBoolError]\n"
+                      "[test.cpp:8:24]: (style) Comparison of two functions returning boolean value using relational (<, >, <= or >=) operator. [comparisonOfTwoFuncsReturningBoolError]\n"
+                      "[test.cpp:9:36]: (style) Comparison of two functions returning boolean value using relational (<, >, <= or >=) operator. [comparisonOfTwoFuncsReturningBoolError]\n",
+                      errout_str());
+    }
+
+    void checkComparisonOfFuncReturningBool8() { // #4103
+        // op: >
+        check("int main(void){\n"
+              "    bool a = true;\n"
+              "    bool b = false;\n"
+              "    if(b > a){ \n"                             // here warning should be displayed
+              "        ;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:10]: (style) Comparison of a variable having boolean value using relational (<, >, <= or >=) operator. [comparisonOfBoolWithBoolError]\n", errout_str());
+        // op: <
+        check("int main(void){\n"
+              "    bool a = true;\n"
+              "    bool b = false;\n"
+              "    if(b < a){ \n"                             // here warning should be displayed
+              "        ;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:10]: (style) Comparison of a variable having boolean value using relational (<, >, <= or >=) operator. [comparisonOfBoolWithBoolError]\n", errout_str());
+        // op: >=
+        check("int main(void){\n"
+              "    bool a = true;\n"
+              "    bool b = false;\n"
+              "    if(b >= a){ \n"                             // here warning should be displayed
+              "        ;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:10]: (style) Comparison of a variable having boolean value using relational (<, >, <= or >=) operator. [comparisonOfBoolWithBoolError]\n", errout_str());
+        // op: <=
+        check("int main(void){\n"
+              "    bool a = true;\n"
+              "    bool b = false;\n"
+              "    if(b <= a){ \n"                             // here warning should be displayed
+              "        ;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:10]: (style) Comparison of a variable having boolean value using relational (<, >, <= or >=) operator. [comparisonOfBoolWithBoolError]\n", errout_str());
     }
 
     void checkComparisonOfFuncReturningBoolIntegrationTest1() { // #7798
@@ -749,7 +779,7 @@ class TestBool : public TestFixture {
               "    return 1;\n"
               "  return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void checkComparisonOfBoolWithBool() {
@@ -775,102 +805,193 @@ class TestBool : public TestFixture {
                             "    else\n"
                             "        return false;\n"
                             "}\n";
-        check(code, true);
-        ASSERT_EQUALS("[test.cpp:5]: (style) Comparison of a variable having boolean value using relational (<, >, <= or >=) operator.\n", errout.str());
-        check(code, false);
-        ASSERT_EQUALS("", errout.str());
+        check(code);
+        ASSERT_EQUALS("[test.cpp:5:10]: (style) Comparison of a variable having boolean value using relational (<, >, <= or >=) operator. [comparisonOfBoolWithBoolError]\n", errout_str());
     }
 
     void bitwiseOnBoolean() { // 3062
         check("void f(_Bool a, _Bool b) {\n"
               "    if(a & b) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean '&&'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '&&'? [bitwiseOnBoolean]\n", errout_str());
 
         check("void f(_Bool a, _Bool b) {\n"
               "    if(a | b) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean '||'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '||'? [bitwiseOnBoolean]\n", errout_str());
 
         check("void f(bool a, bool b) {\n"
               "    if(a & !b) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean '&&'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '&&'? [bitwiseOnBoolean]\n", errout_str());
 
         check("void f(bool a, bool b) {\n"
               "    if(a | !b) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean '||'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '||'? [bitwiseOnBoolean]\n", errout_str());
 
         check("bool a, b;\n"
               "void f() {\n"
               "    if(a & b) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean '&&'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '&&'? [bitwiseOnBoolean]\n", errout_str());
 
         check("bool a, b;\n"
               "void f() {\n"
               "    if(a & !b) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean '&&'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '&&'? [bitwiseOnBoolean]\n", errout_str());
 
         check("bool a, b;\n"
               "void f() {\n"
               "    if(a | b) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean '||'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '||'? [bitwiseOnBoolean]\n", errout_str());
 
         check("bool a, b;\n"
               "void f() {\n"
               "    if(a | !b) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean '||'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '||'? [bitwiseOnBoolean]\n", errout_str());
 
         check("void f(bool a, int b) {\n"
               "    if(a & b) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style, inconclusive) Boolean variable 'a' is used in bitwise operation. Did you mean '&&'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '&&'? [bitwiseOnBoolean]\n", errout_str());
 
         check("void f(int a, bool b) {\n"
               "    if(a & b) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style, inconclusive) Boolean variable 'b' is used in bitwise operation. Did you mean '&&'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (style, inconclusive) Boolean expression 'b' is used in bitwise operation. Did you mean '&&'? [bitwiseOnBoolean]\n", errout_str());
+
+        check("void f(int a, int b) {\n"
+              "    if((a > 0) & (b < 0)) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:16]: (style, inconclusive) Boolean expression 'a>0' is used in bitwise operation. Did you mean '&&'? [bitwiseOnBoolean]\n", errout_str());
+
+        check("void f(bool a, int b) {\n"
+              "    if(a | b) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:10]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '||'? [bitwiseOnBoolean]\n", errout_str());
+
+        check("void f(int a, bool b) {\n"
+              "    if(a | b) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:10]: (style, inconclusive) Boolean expression 'b' is used in bitwise operation. Did you mean '||'? [bitwiseOnBoolean]\n", errout_str());
+
+        check("int f(bool a, int b) {\n"
+              "    return a | b;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool f(bool a, int b) {\n"
+              "    return a | b;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:14]: (style, inconclusive) Boolean expression 'a' is used in bitwise operation. Did you mean '||'? [bitwiseOnBoolean]\n", errout_str());
 
         check("void f(int a, int b) {\n"
               "    if(a & b) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(bool b) {\n"
               "    foo(bar, &b);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(bool b) {\n" // #9405
+              "    class C { void foo(bool &b) {} };\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool f();\n"
+              "bool g() {\n"
+              "  return f() | f();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("uint8 outcode(float p) {\n"
+              "    float d = 0.;\n"
+              "    return ((p - xm >= d) << 1) | (x - p > d);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int g();\n" // #10655
+              "void f(bool b) {\n"
+              "    if (g() | b) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:13]: (style, inconclusive) Boolean expression 'b' is used in bitwise operation. Did you mean '||'? [bitwiseOnBoolean]\n", errout_str());
+
+        check("int g();\n"
+              "void f(bool b) {\n"
+              "    if (b | g()) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int g();\n"
+              "bool f(bool b, bool c) {\n"
+              "    return b | g() | c;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:20]: (style, inconclusive) Boolean expression 'c' is used in bitwise operation. Did you mean '||'? [bitwiseOnBoolean]\n", errout_str());
+
+        check("void f(int i) {\n" // #4233
+              "    bool b = true, c = false;\n"
+              "    b &= i;\n"
+              "    c |= i;\n"
+              "    if (b || c) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:7]: (style, inconclusive) Boolean expression 'b' is used in bitwise operation. [bitwiseOnBoolean]\n"
+                      "[test.cpp:4:7]: (style, inconclusive) Boolean expression 'c' is used in bitwise operation. [bitwiseOnBoolean]\n",
+                      errout_str());
+
+        check("void f(int i, int j, bool b) {\n"
+              "    i &= b;\n"
+              "    j |= b;\n"
+              "    if (b || c) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool f(bool b, int i) {\n"
+              "    b &= (i == 5);\n"
+              "    return b;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { bool b{}; };\n" // #12455
+              "void f(const std::unordered_map<int, S> m) {\n"
+              "    for (const auto& e : m) {\n"
+              "        S s;\n"
+              "        s.b |= e.second.b;\n"
+              "        (void)s.b;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void incrementBoolean() {
         check("bool bValue = true;\n"
               "void f() { bValue++; }");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Incrementing a variable of type 'bool' with postfix operator++ is deprecated by the C++ Standard. You should assign it the value 'true' instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:12]: (style) Incrementing a variable of type 'bool' with postfix operator++ is deprecated by the C++ Standard. You should assign it the value 'true' instead. [incrementboolean]\n", errout_str());
 
         check("void f(bool test){\n"
               "    test++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Incrementing a variable of type 'bool' with postfix operator++ is deprecated by the C++ Standard. You should assign it the value 'true' instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (style) Incrementing a variable of type 'bool' with postfix operator++ is deprecated by the C++ Standard. You should assign it the value 'true' instead. [incrementboolean]\n", errout_str());
 
         check("void f(bool* test){\n"
               "    (*test)++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Incrementing a variable of type 'bool' with postfix operator++ is deprecated by the C++ Standard. You should assign it the value 'true' instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:6]: (style) Incrementing a variable of type 'bool' with postfix operator++ is deprecated by the C++ Standard. You should assign it the value 'true' instead. [incrementboolean]\n", errout_str());
 
         check("void f(bool* test){\n"
               "    test[0]++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Incrementing a variable of type 'bool' with postfix operator++ is deprecated by the C++ Standard. You should assign it the value 'true' instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Incrementing a variable of type 'bool' with postfix operator++ is deprecated by the C++ Standard. You should assign it the value 'true' instead. [incrementboolean]\n", errout_str());
 
         check("void f(int test){\n"
               "    test++;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void comparisonOfBoolWithInt1() {
@@ -879,51 +1000,51 @@ class TestBool : public TestFixture {
               "        printf(\"foo\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(bool x) {\n"
               "    if (10 >= x) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:12]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(bool x) {\n"
               "    if (x != 0) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(bool x) {\n"  // #3356
               "    if (x == 1) {\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(bool x) {\n"
               "    if (x != 10) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(bool x) {\n"
               "    if (x == 10) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
 
         check("void f(bool x) {\n"
               "    if (x == 0) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("DensePropertyMap<int, true> visited;"); // #4075
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void comparisonOfBoolWithInt2() {
@@ -932,28 +1053,28 @@ class TestBool : public TestFixture {
               "        printf(\"foo\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer.\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, bool y) {\n"
               "    if (x == y) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer.\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(bool x, bool y) {\n"
               "    if (x == y) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(bool x, fooClass y) {\n"
               "    if (x == y) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void comparisonOfBoolWithInt3() {
@@ -962,36 +1083,35 @@ class TestBool : public TestFixture {
               "        printf(\"foo\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer.\n"
-                      "[test.cpp:2]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (warning) Comparison of a boolean value using relational operator (<, >, <= or >=). [comparisonOfBoolWithInvalidComparator]\n", errout_str());
 
         check("void f(int y) {\n"
               "    if (true == y) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer.\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(bool y) {\n"
               "    if (y == true) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(bool y) {\n"
               "    if (false < 5) {\n"
               "        printf(\"foo\");\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of a boolean expression with an integer other than 0 or 1.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Comparison of a boolean expression with an integer other than 0 or 1. [compareBoolExpressionWithInt]\n", errout_str());
     }
 
     void comparisonOfBoolWithInt4() {
         check("void f(int x) {\n"
               "    if (!x == 1) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void comparisonOfBoolWithInt5() {
@@ -999,21 +1119,21 @@ class TestBool : public TestFixture {
               "    bool (SciTEBase::*ischarforsel)(char ch);\n"
               "    if (visible != GetVisible(index)) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void comparisonOfBoolWithInt6() { // #4224 - integer is casted to bool
         check("void SetVisible(bool b, int i) {\n"
               "    if (b == (bool)i) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void comparisonOfBoolWithInt7() { // #4846 - (!x==true)
         check("void f(int x) {\n"
               "    if (!x == true) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void comparisonOfBoolWithInt8() { // #9165
@@ -1023,7 +1143,7 @@ class TestBool : public TestFixture {
               "    if (expectedResult == res)\n"
               "        throw 2;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int Fun();\n"
               "void Test(bool expectedResult) {\n"
@@ -1031,7 +1151,7 @@ class TestBool : public TestFixture {
               "    if (expectedResult == res)\n"
               "        throw 2;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Comparison of a boolean expression with an integer.\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool Fun();\n"
               "void Test(bool expectedResult) {\n"
@@ -1039,7 +1159,7 @@ class TestBool : public TestFixture {
               "    if (5 + expectedResult == res)\n"
               "        throw 2;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Comparison of a boolean expression with an integer.\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int Fun();\n"
               "void Test(bool expectedResult) {\n"
@@ -1047,7 +1167,7 @@ class TestBool : public TestFixture {
               "    if (5 + expectedResult == res)\n"
               "        throw 2;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int Fun();\n"
               "void Test(bool expectedResult) {\n"
@@ -1055,7 +1175,7 @@ class TestBool : public TestFixture {
               "    if (expectedResult == res + 5)\n"
               "        throw 2;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Comparison of a boolean expression with an integer.\n", errout.str());
+        TODO_ASSERT_EQUALS("error", "", errout_str());
     }
 
     void comparisonOfBoolWithInt9() { // #9304
@@ -1066,7 +1186,24 @@ class TestBool : public TestFixture {
               "    }\n"
               "    return b;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void comparisonOfBoolWithInt10() { // #10935
+        check("enum class E { H = 2 };\n"
+              "template <bool H>\n"
+              "void f(bool v) {\n"
+              "    if (v == H) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("namespace N {\n"
+              "    enum class E { H = 2 };\n"
+              "}\n"
+              "void f(bool v) {\n"
+              "    if (v == N::H) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -1074,76 +1211,76 @@ class TestBool : public TestFixture {
         check("void f(char *p) {\n"
               "    if (p+1){}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Converting pointer arithmetic result to bool. The bool is always true unless there is undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (error) Converting pointer arithmetic result to bool. The bool is always true unless there is undefined behaviour. [pointerArithBool]\n", errout_str());
 
         check("void f(char *p) {\n"
               "    do {} while (p+1);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Converting pointer arithmetic result to bool. The bool is always true unless there is undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:19]: (error) Converting pointer arithmetic result to bool. The bool is always true unless there is undefined behaviour. [pointerArithBool]\n", errout_str());
 
         check("void f(char *p) {\n"
               "    while (p-1) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Converting pointer arithmetic result to bool. The bool is always true unless there is undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (error) Converting pointer arithmetic result to bool. The bool is always true unless there is undefined behaviour. [pointerArithBool]\n", errout_str());
 
         check("void f(char *p) {\n"
               "    for (int i = 0; p+1; i++) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Converting pointer arithmetic result to bool. The bool is always true unless there is undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:22]: (error) Converting pointer arithmetic result to bool. The bool is always true unless there is undefined behaviour. [pointerArithBool]\n", errout_str());
 
         check("void f(char *p) {\n"
               "    if (p && p+1){}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Converting pointer arithmetic result to bool. The bool is always true unless there is undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (error) Converting pointer arithmetic result to bool. The bool is always true unless there is undefined behaviour. [pointerArithBool]\n", errout_str());
 
         check("void f(char *p) {\n"
               "    if (p+2 || p) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Converting pointer arithmetic result to bool. The bool is always true unless there is undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (error) Converting pointer arithmetic result to bool. The bool is always true unless there is undefined behaviour. [pointerArithBool]\n", errout_str());
     }
 
     void returnNonBool() {
         check("bool f(void) {\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(void) {\n"
               "    return 1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(void) {\n"
               "    return 2;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Non-boolean value returned from function returning bool\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n", errout_str());
 
         check("bool f(void) {\n"
               "    return -1;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Non-boolean value returned from function returning bool\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n", errout_str());
 
         check("bool f(void) {\n"
               "    return 1 + 1;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Non-boolean value returned from function returning bool\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n", errout_str());
 
         check("bool f(void) {\n"
               "    int x = 0;\n"
               "    return x;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(void) {\n"
               "    int x = 10;\n"
               "    return x;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Non-boolean value returned from function returning bool\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n", errout_str());
 
         check("bool f(void) {\n"
               "    return 2 < 1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(void) {\n"
               "    int ret = 0;\n"
@@ -1151,7 +1288,7 @@ class TestBool : public TestFixture {
               "        ret = 1;\n"
               "    return ret;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(void) {\n"
               "    int ret = 0;\n"
@@ -1159,63 +1296,63 @@ class TestBool : public TestFixture {
               "        ret = 3;\n"
               "    return ret;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (style) Non-boolean value returned from function returning bool\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n", errout_str());
 
         check("bool f(void) {\n"
               "    if (a)\n"
               "        return 3;\n"
               "    return 4;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Non-boolean value returned from function returning bool\n"
-                      "[test.cpp:4]: (style) Non-boolean value returned from function returning bool\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n"
+                      "[test.cpp:4:5]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n", errout_str());
 
         check("bool f(void) {\n"
               "    return;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void returnNonBoolLambda() {
         check("bool f(void) {\n"
               "    auto x = [](void) { return -1; };\n"
               "    return false;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(void) {\n"
               "    auto x = [](void) { return -1; };\n"
               "    return 2;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Non-boolean value returned from function returning bool\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:5]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n", errout_str());
 
         check("bool f(void) {\n"
               "    auto x = [](void) -> int { return -1; };\n"
               "    return false;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(void) {\n"
               "    auto x = [](void) -> int { return -1; };\n"
               "    return 2;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Non-boolean value returned from function returning bool\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:5]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n", errout_str());
     }
 
     void returnNonBoolLogicalOp() {
         check("bool f(int x) {\n"
               "    return x & 0x4;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(int x, int y) {\n"
               "    return x | y;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(int x) {\n"
               "    return (x & 0x2);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void returnNonBoolClass() {
@@ -1223,7 +1360,7 @@ class TestBool : public TestFixture {
               "    public:\n"
               "        bool f() { return -1;}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Non-boolean value returned from function returning bool\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:20]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n", errout_str());
 
         check("bool f() {\n"
               "    struct X {\n"
@@ -1232,7 +1369,7 @@ class TestBool : public TestFixture {
               "    };\n"
               "    return false;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f() {\n"
               "    class X {\n"
@@ -1241,7 +1378,7 @@ class TestBool : public TestFixture {
               "    };\n"
               "    return false;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f() {\n"
               "    class X {\n"
@@ -1250,8 +1387,8 @@ class TestBool : public TestFixture {
               "    };\n"
               "    return -1;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (style) Non-boolean value returned from function returning bool\n"
-                      "[test.cpp:4]: (style) Non-boolean value returned from function returning bool\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:5]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n"
+                      "[test.cpp:4:24]: (style) Non-boolean value returned from function returning bool [returnNonBoolInBooleanFunction]\n", errout_str());
     }
 };
 
diff --git a/test/testboost.cpp b/test/testboost.cpp
deleted file mode 100644
index 7fabaca4ad7..00000000000
--- a/test/testboost.cpp
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#include "checkboost.h"
-#include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
-
-
-class TestBoost : public TestFixture {
-public:
-    TestBoost() : TestFixture("TestBoost") {
-    }
-
-private:
-    Settings settings;
-
-    void run() OVERRIDE {
-        settings.addEnabled("style");
-        settings.addEnabled("performance");
-
-        TEST_CASE(BoostForeachContainerModification)
-    }
-
-    void check(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
-
-        // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-
-        // Check..
-        CheckBoost checkBoost;
-        checkBoost.runChecks(&tokenizer, &settings, this);
-    }
-
-    void BoostForeachContainerModification() {
-        check("void f() {\n"
-              "    vector<int> data;\n"
-              "    BOOST_FOREACH(int i, data) {\n"
-              "        data.push_back(123);\n"
-              "    }\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) BOOST_FOREACH caches the end() iterator. It's undefined behavior if you modify the container inside.\n", errout.str());
-
-        check("void f() {\n"
-              "    set<int> data;\n"
-              "    BOOST_FOREACH(int i, data) {\n"
-              "        data.insert(123);\n"
-              "    }\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) BOOST_FOREACH caches the end() iterator. It's undefined behavior if you modify the container inside.\n", errout.str());
-
-        check("void f() {\n"
-              "    set<int> data;\n"
-              "    BOOST_FOREACH(const int &i, data) {\n"
-              "        data.erase(123);\n"
-              "    }\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) BOOST_FOREACH caches the end() iterator. It's undefined behavior if you modify the container inside.\n", errout.str());
-
-        // Check single line usage
-        check("void f() {\n"
-              "    set<int> data;\n"
-              "    BOOST_FOREACH(const int &i, data)\n"
-              "        data.clear();\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) BOOST_FOREACH caches the end() iterator. It's undefined behavior if you modify the container inside.\n", errout.str());
-
-        // Container returned as result of a function -> Be quiet
-        check("void f() {\n"
-              "    BOOST_FOREACH(const int &i, get_data())\n"
-              "        data.insert(i);\n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
-
-        // Break after modification (#4788)
-        check("void f() {\n"
-              "    vector<int> data;\n"
-              "    BOOST_FOREACH(int i, data) {\n"
-              "        data.push_back(123);\n"
-              "        break;\n"
-              "    }\n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
-    }
-};
-
-REGISTER_TEST(TestBoost)
diff --git a/test/testbufferoverrun.cpp b/test/testbufferoverrun.cpp
index 142d2a443e9..7118a7ae906 100644
--- a/test/testbufferoverrun.cpp
+++ b/test/testbufferoverrun.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,65 +17,74 @@
  */
 
 
+#include "check.h"
 #include "checkbufferoverrun.h"
-#include "library.h"
+#include "ctu.h"
+#include "errortypes.h"
+#include "helpers.h"
+#include "platform.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "token.h"
-#include "tokenize.h"
+#include "fixture.h"
 
-#include <tinyxml2.h>
-#include <climits>
+#include <cstddef>
 #include <list>
-#include <ostream>
 #include <string>
 
-
 class TestBufferOverrun : public TestFixture {
 public:
-    TestBufferOverrun() : TestFixture("TestBufferOverrun") {
-    }
+    TestBufferOverrun() : TestFixture("TestBufferOverrun") {}
 
 private:
-    Settings settings0;
+    /*const*/ Settings settings0 = settingsBuilder().library("std.cfg").severity(Severity::warning).severity(Severity::style).build();
+    const Settings settings0_i = settingsBuilder(settings0).certainty(Certainty::inconclusive).build();
+    const Settings settings0_p = settingsBuilder(settings0).severity(Severity::portability).build();
+    const Settings settings1 = settingsBuilder(settings0).severity(Severity::performance).certainty(Certainty::inconclusive).build();
 
-    void check(const char code[], bool experimental = true, const char filename[] = "test.cpp") {
-        // Clear the error buffer..
-        errout.str("");
+    struct CheckOptions
+    {
+        bool cpp = true;
+    };
 
-        settings0.inconclusive = true;
-        settings0.experimental = experimental;
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
+        check_(file, line, code, settings0_i, options.cpp);
+    }
 
-        // Tokenize..
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, filename);
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const Settings& settings, bool cpp = true) {
+        SimpleTokenizer tokenizer(settings, *this, cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check for buffer overruns..
-        CheckBufferOverrun checkBufferOverrun;
-        checkBufferOverrun.runChecks(&tokenizer, &settings0, this);
+        runChecks<CheckBufferOverrun>(tokenizer, this);
     }
 
-    void check(const char code[], const Settings &settings, const char filename[] = "test.cpp") {
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, filename);
-
-        // Clear the error buffer..
-        errout.str("");
+    // TODO: get rid of this
+    void check_(const char* file, int line, const std::string& code) {
+        // Tokenize..
+        SimpleTokenizer tokenizer(settings0_i, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check for buffer overruns..
-        CheckBufferOverrun checkBufferOverrun(&tokenizer, &settings, this);
-        checkBufferOverrun.runChecks(&tokenizer, &settings, this);
+        runChecks<CheckBufferOverrun>(tokenizer, this);
     }
 
-    void run() OVERRIDE {
-        LOAD_LIB_2(settings0.library, "std.cfg");
+#define checkP(...) checkP_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkP_(const char* file, int line, const char (&code)[size])
+    {
+        SimpleTokenizer2 tokenizer(settings1, *this, code, "test.cpp");
 
-        settings0.addEnabled("warning");
-        settings0.addEnabled("style");
-        settings0.addEnabled("portability");
+        // Tokenizer..
+        ASSERT_LOC(tokenizer.simplifyTokens1(""), file, line);
+
+        // Check for buffer overruns..
+        runChecks<CheckBufferOverrun>(tokenizer, this);
+    }
 
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(noerr1);
         TEST_CASE(noerr2);
         TEST_CASE(noerr3);
@@ -86,7 +95,7 @@ class TestBufferOverrun : public TestFixture {
         TEST_CASE(array_index_1);
         TEST_CASE(array_index_2);
         TEST_CASE(array_index_3);
-        // TODO string TEST_CASE(array_index_4);
+        TEST_CASE(array_index_4);
         TEST_CASE(array_index_6);
         TEST_CASE(array_index_7);
         TEST_CASE(array_index_11);
@@ -126,15 +135,52 @@ class TestBufferOverrun : public TestFixture {
         TEST_CASE(array_index_45); // #4207 - calling function with variable number of parameters (...)
         TEST_CASE(array_index_46); // #4840 - two-statement for loop
         TEST_CASE(array_index_47); // #5849
+        TEST_CASE(array_index_48); // #9478
+        TEST_CASE(array_index_49); // #8653
+        TEST_CASE(array_index_50);
+        TEST_CASE(array_index_51); // #3763
+        TEST_CASE(array_index_52); // #7682
+        TEST_CASE(array_index_53); // #4750
+        TEST_CASE(array_index_54); // #10268
+        TEST_CASE(array_index_55); // #10254
+        TEST_CASE(array_index_56); // #10284
+        TEST_CASE(array_index_57); // #10023
+        TEST_CASE(array_index_58); // #7524
+        TEST_CASE(array_index_59); // #10413
+        TEST_CASE(array_index_60); // #10617, #9824
+        TEST_CASE(array_index_61); // #10621
+        TEST_CASE(array_index_62); // #7684
+        TEST_CASE(array_index_63); // #10979
+        TEST_CASE(array_index_64); // #10878
+        TEST_CASE(array_index_65); // #11066
+        TEST_CASE(array_index_66); // #10740
+        TEST_CASE(array_index_67); // #1596
+        TEST_CASE(array_index_68); // #6655
+        TEST_CASE(array_index_69); // #6370
+        TEST_CASE(array_index_70); // #11355
+        TEST_CASE(array_index_71); // #11461
+        TEST_CASE(array_index_72); // #11784
+        TEST_CASE(array_index_73); // #11530
+        TEST_CASE(array_index_74); // #11088
+        TEST_CASE(array_index_75);
+        TEST_CASE(array_index_76);
         TEST_CASE(array_index_multidim);
         TEST_CASE(array_index_switch_in_for);
         TEST_CASE(array_index_for_in_for);   // FP: #2634
+        TEST_CASE(array_index_bounds);
         TEST_CASE(array_index_calculation);
         TEST_CASE(array_index_negative1);
         TEST_CASE(array_index_negative2);    // ticket #3063
         TEST_CASE(array_index_negative3);
+        TEST_CASE(array_index_negative4);
+        TEST_CASE(array_index_negative5);    // #10526
+        TEST_CASE(array_index_negative6);    // #11349
+        TEST_CASE(array_index_negative7);    // #5685
+        TEST_CASE(array_index_negative8);    // #11651
+        TEST_CASE(array_index_negative9);
+        TEST_CASE(array_index_negative10);
         TEST_CASE(array_index_for_decr);
-        TEST_CASE(array_index_varnames);     // FP: struct member. #1576
+        TEST_CASE(array_index_varnames);     // FP: struct member #1576, FN: #1586
         TEST_CASE(array_index_for_continue); // for,continue
         TEST_CASE(array_index_for);          // FN: for,if
         TEST_CASE(array_index_for_neq);      // #2211: Using != in condition
@@ -144,18 +190,21 @@ class TestBufferOverrun : public TestFixture {
         TEST_CASE(array_index_vla_for);      // #3221: access VLA inside for
         TEST_CASE(array_index_extern);       // FP when using 'extern'. #1684
         TEST_CASE(array_index_cast);         // FP after cast. #2841
-        // TODO string pointer TEST_CASE(array_index_string_literal);
+        TEST_CASE(array_index_string_literal);
         TEST_CASE(array_index_same_struct_and_var_name); // #4751 - not handled well when struct name and var name is same
         TEST_CASE(array_index_valueflow);
         TEST_CASE(array_index_valueflow_pointer);
         TEST_CASE(array_index_function_parameter);
         TEST_CASE(array_index_enum_array); // #8439
+        TEST_CASE(array_index_container); // #9386
+        TEST_CASE(array_index_two_for_loops);
+        TEST_CASE(array_index_new); // #7690
 
         TEST_CASE(buffer_overrun_2_struct);
         TEST_CASE(buffer_overrun_3);
         TEST_CASE(buffer_overrun_4);
         TEST_CASE(buffer_overrun_5);
-        // TODO strcat TEST_CASE(buffer_overrun_6);
+        TEST_CASE(buffer_overrun_6);
         TEST_CASE(buffer_overrun_7);
         TEST_CASE(buffer_overrun_8);
         TEST_CASE(buffer_overrun_9);
@@ -172,11 +221,17 @@ class TestBufferOverrun : public TestFixture {
         TEST_CASE(buffer_overrun_29); // #7083: false positive: typedef and initialization with strings
         TEST_CASE(buffer_overrun_30); // #6367
         TEST_CASE(buffer_overrun_31);
+        TEST_CASE(buffer_overrun_32); //#10244
+        TEST_CASE(buffer_overrun_33); //#2019
+        TEST_CASE(buffer_overrun_34); //#11035
+        TEST_CASE(buffer_overrun_35); //#2304
+        TEST_CASE(buffer_overrun_36);
         TEST_CASE(buffer_overrun_errorpath);
-        // TODO CTU TEST_CASE(buffer_overrun_bailoutIfSwitch);  // ticket #2378 : bailoutIfSwitch
-        // TODO TEST_CASE(buffer_overrun_function_array_argument);
-        // TODO alloca TEST_CASE(possible_buffer_overrun_1); // #3035
+        TEST_CASE(buffer_overrun_bailoutIfSwitch);  // ticket #2378 : bailoutIfSwitch
+        TEST_CASE(buffer_overrun_function_array_argument);
+        TEST_CASE(possible_buffer_overrun_1); // #3035
         TEST_CASE(buffer_overrun_readSizeFromCfg);
+        TEST_CASE(buffer_overrun_handle_addr_of_var); // ticket #7570 - correctly handle &var
 
         TEST_CASE(valueflow_string); // using ValueFlow string values in checking
 
@@ -186,27 +241,23 @@ class TestBufferOverrun : public TestFixture {
         // char *p1 = a + 10;  // OK
         // char *p2 = a + 11   // UB
         TEST_CASE(pointer_out_of_bounds_1);
-        // TODO TEST_CASE(pointer_out_of_bounds_2);
+        TEST_CASE(pointer_out_of_bounds_2);
         TEST_CASE(pointer_out_of_bounds_3);
-        // TODO TEST_CASE(pointer_out_of_bounds_sub);
-
-        // TODO TEST_CASE(strncat1);
-        // TODO TEST_CASE(strncat2);
-        // TODO TEST_CASE(strncat3);
+        TEST_CASE(pointer_out_of_bounds_4);
+        TEST_CASE(pointer_out_of_bounds_5); // #10227
+        TEST_CASE(pointer_out_of_bounds_sub);
 
-        // TODO TEST_CASE(strcat1);
-        // TODO TEST_CASE(strcat2);
-        // TODO TEST_CASE(strcat3);
+        TEST_CASE(strcat1);
 
         TEST_CASE(varid1);
         TEST_CASE(varid2);  // ticket #4764
 
         TEST_CASE(assign1);
 
-        // TODO new TEST_CASE(alloc_new);      // Buffer allocated with new
+        TEST_CASE(alloc_new);      // Buffer allocated with new
         TEST_CASE(alloc_malloc);   // Buffer allocated with malloc
         TEST_CASE(alloc_string);   // statically allocated buffer
-        // TODO TEST_CASE(alloc_alloca);   // Buffer allocated with alloca
+        TEST_CASE(alloc_alloca);   // Buffer allocated with alloca
 
         // TODO TEST_CASE(countSprintfLength);
         TEST_CASE(minsize_argvalue);
@@ -219,6 +270,8 @@ class TestBufferOverrun : public TestFixture {
         TEST_CASE(terminateStrncpy2);
         TEST_CASE(terminateStrncpy3);
         TEST_CASE(terminateStrncpy4);
+        TEST_CASE(terminateStrncpy5); // #9944
+        TEST_CASE(terminateStrncpy_handle_addr_of_var); // #7570
         TEST_CASE(recursive_long_time);
 
         TEST_CASE(crash1);  // Ticket #1587 - crash
@@ -229,8 +282,8 @@ class TestBufferOverrun : public TestFixture {
         TEST_CASE(crash6);  // Ticket #9024 - crash
         TEST_CASE(crash7);  // Ticket #9073 - crash
 
-        // TODO TEST_CASE(insecureCmdLineArgs);
-        // TODO TEST_CASE(checkBufferAllocatedWithStrlen);
+        TEST_CASE(insecureCmdLineArgs);
+        TEST_CASE(checkBufferAllocatedWithStrlen);
 
         TEST_CASE(scope);   // handling different scopes
 
@@ -238,10 +291,11 @@ class TestBufferOverrun : public TestFixture {
 
         // Access array and then check if the used index is within bounds
         TEST_CASE(arrayIndexThenCheck);
+        TEST_CASE(arrayIndexEarlyReturn); // #6884
 
-        // TODO TEST_CASE(bufferNotZeroTerminated);
+        TEST_CASE(bufferNotZeroTerminated);
 
-        // TODO TEST_CASE(negativeMemoryAllocationSizeError) // #389
+        TEST_CASE(negativeMemoryAllocationSizeError); // #389
         TEST_CASE(negativeArraySize);
 
         TEST_CASE(pointerAddition1);
@@ -252,6 +306,8 @@ class TestBufferOverrun : public TestFixture {
         TEST_CASE(ctu_arithmetic);
 
         TEST_CASE(objectIndex);
+
+        TEST_CASE(checkPipeParameterSize); // ticket #3521
     }
 
 
@@ -269,7 +325,7 @@ class TestBufferOverrun : public TestFixture {
               "        char str[50];\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -291,7 +347,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    strcpy(buf, str);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -302,7 +358,7 @@ class TestBufferOverrun : public TestFixture {
               "    char data[1];\n"
               "    return abc.data[1];\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -312,7 +368,7 @@ class TestBufferOverrun : public TestFixture {
               "    char data[100];\n"
               "    const char *p = data + 100;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void sizeof3() {
@@ -324,24 +380,24 @@ class TestBufferOverrun : public TestFixture {
               "    struct group *gr;\n"
               "    snprintf(group, 32, \"%u\", gr->gr_gid);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_1() {
         check("void f()\n"
               "{\n"
-              "    char str[0x10];\n"
+              "    char str[0x10] = {0};\n"
               "    str[15] = 0;\n"
               "    str[16] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'str[16]' accessed at index 16, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:8]: (error) Array 'str[16]' accessed at index 16, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("char f()\n"
               "{\n"
-              "    char str[16];\n"
+              "    char str[16] = {0};\n"
               "    return str[16];\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'str[16]' accessed at index 16, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:15]: (error) Array 'str[16]' accessed at index 16, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // test stack array
         check("int f()\n"
@@ -351,7 +407,7 @@ class TestBufferOverrun : public TestFixture {
               "   y = x[ 4 ];\n"
               "   return y;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'x[3]' accessed at index 4, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9]: (error) Array 'x[3]' accessed at index 4, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("int f()\n"
               "{\n"
@@ -360,15 +416,15 @@ class TestBufferOverrun : public TestFixture {
               "   y = x[ 2 ];\n"
               "   return y;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("int x[5];\n"
-              "int a = x[10];\n");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Array 'x[5]' accessed at index 10, which is out of bounds.\n", errout.str());
+        check("int x[5] = {0};\n"
+              "int a = x[10];");
+        ASSERT_EQUALS("[test.cpp:2:10]: (error) Array 'x[5]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
-        check("int x[5];\n"
-              "int a = (x)[10];\n");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Array 'x[5]' accessed at index 10, which is out of bounds.\n", errout.str());
+        check("int x[5] = {0};\n"
+              "int a = (x)[10];");
+        ASSERT_EQUALS("[test.cpp:2:12]: (error) Array 'x[5]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
 
@@ -379,18 +435,21 @@ class TestBufferOverrun : public TestFixture {
               "    str[i] = 0;\n"
               "}\n"
               "void b() { a(16); }");
-        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Array 'str[16]' accessed at index 16, which is out of bounds.\n", "", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:8]: (error) Array 'str[16]' accessed at index 16, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_4() {
         check("char c = \"abc\"[4];");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Array index out of bounds: \"abc\"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:15]: (error) Array '\"abc\"[4]' accessed at index 4, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("p = &\"abc\"[4];");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("char c = \"\\0abc\"[2];");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("char c = L\"abc\"[4];");
+        ASSERT_EQUALS("[test.cpp:1:16]: (error) Array 'L\"abc\"[4]' accessed at index 4, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_3() {
@@ -401,7 +460,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (i = 0; i < 100; i++)\n"
               "        sum += val[i];\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Array 'val[50]' accessed at index 99, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:19]: (error) Array 'val[50]' accessed at index 99, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -410,7 +469,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (i = 1; i < 100; i++)\n"
               "        sum += val[i];\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Array 'val[50]' accessed at index 99, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:19]: (error) Array 'val[50]' accessed at index 99, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f(int a)\n"
               "{\n"
@@ -419,7 +478,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (i = a; i < 100; i++)\n"
               "        sum += val[i];\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Array 'val[50]' accessed at index 99, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:19]: (error) Array 'val[50]' accessed at index 99, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("typedef struct g g2[3];\n"
               "void foo(char *a)\n"
@@ -429,21 +488,21 @@ class TestBufferOverrun : public TestFixture {
               "    a[i]=0;\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int argc)\n"
               "{\n"
               "  char a[2];\n"
               "  for (int i = 4; i < argc; i++){}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a[10]) {\n"
               "    for (int i=0;i<50;++i) {\n"
               "        a[i] = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Array 'a[10]' accessed at index 49, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (error) Array 'a[10]' accessed at index 49, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_6() {
@@ -457,7 +516,7 @@ class TestBufferOverrun : public TestFixture {
               "    struct ABC abc;\n"
               "    abc.str[10] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:9]: (error) Array 'abc.str[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:12]: (error) Array 'abc.str[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("struct ABC\n"
               "{\n"
@@ -469,7 +528,7 @@ class TestBufferOverrun : public TestFixture {
               "    struct ABC abc;\n"
               "    return abc.str[10];\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:9]: (error) Array 'abc.str[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:19]: (error) Array 'abc.str[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // This is not out of bounds because it is a variable length array
         check("struct ABC\n"
@@ -482,7 +541,7 @@ class TestBufferOverrun : public TestFixture {
               "    struct ABC* x = malloc(sizeof(struct ABC) + 10);\n"
               "    x->str[1] = 0;"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // This is not out of bounds because it is not a variable length array
         check("struct ABC\n"
@@ -496,7 +555,7 @@ class TestBufferOverrun : public TestFixture {
               "    struct ABC* x = malloc(sizeof(struct ABC) + 10);\n"
               "    x->str[1] = 0;"
               "}");
-        TODO_ASSERT_EQUALS("error", "", errout.str());
+        TODO_ASSERT_EQUALS("error", "", errout_str());
 
         // This is not out of bounds because it is a variable length array
         // and the index is within the memory allocated.
@@ -511,7 +570,7 @@ class TestBufferOverrun : public TestFixture {
               "    struct ABC* x = malloc(sizeof(struct ABC) + 10);\n"
               "    x->str[10] = 0;"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // This is out of bounds because it is outside the memory allocated.
         /** @todo this doesn't work because of a bug in sizeof(struct)  */
@@ -525,7 +584,7 @@ class TestBufferOverrun : public TestFixture {
               "    struct ABC* x = malloc(sizeof(struct ABC) + 10);\n"
               "    x->str[11] = 0;"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:9]: (error) Array 'str[1]' accessed at index 11, which is out of bounds.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:9]: (error) Array 'str[1]' accessed at index 11, which is out of bounds.\n", "", errout_str());
 
         // This is out of bounds if 'sizeof(ABC)' is 1 (No padding)
         check("struct ABC\n"
@@ -538,7 +597,7 @@ class TestBufferOverrun : public TestFixture {
               "    struct ABC* x = malloc(sizeof(ABC) + 10);\n"
               "    x->str[11] = 0;"
               "}");
-        TODO_ASSERT_EQUALS("error", "", errout.str());
+        TODO_ASSERT_EQUALS("error", "", errout_str());
 
         // This is out of bounds because it is outside the memory allocated
         /** @todo this doesn't work because of a bug in sizeof(struct) */
@@ -552,7 +611,7 @@ class TestBufferOverrun : public TestFixture {
               "    struct ABC* x = malloc(sizeof(struct ABC));\n"
               "    x->str[1] = 0;"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:9]: (error) Array 'str[1]' accessed at index 1, which is out of bounds.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:9]: (error) Array 'str[1]' accessed at index 1, which is out of bounds.\n", "", errout_str());
 
         // This is out of bounds because it is outside the memory allocated
         // But only if 'sizeof(ABC)' is 1 (No padding)
@@ -566,7 +625,7 @@ class TestBufferOverrun : public TestFixture {
               "    struct ABC* x = malloc(sizeof(ABC));\n"
               "    x->str[1] = 0;"
               "}");
-        TODO_ASSERT_EQUALS("error", "", errout.str());
+        TODO_ASSERT_EQUALS("error", "", errout_str());
 
         // This is out of bounds because it is not a variable array
         check("struct ABC\n"
@@ -579,7 +638,7 @@ class TestBufferOverrun : public TestFixture {
               "    struct ABC x;\n"
               "    x.str[1] = 0;"
               "}");
-        ASSERT_EQUALS("[test.cpp:9]: (error) Array 'x.str[1]' accessed at index 1, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:10]: (error) Array 'x.str[1]' accessed at index 1, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("struct foo\n"
               "{\n"
@@ -592,19 +651,19 @@ class TestBufferOverrun : public TestFixture {
               "    for ( unsigned int i = 0; i < 64; ++i )\n"
               "        f.str[i] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:10]: (error) Array 'f.str[10]' accessed at index 63, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:14]: (error) Array 'f.str[10]' accessed at index 63, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("struct AB { char a[NUM]; char b[NUM]; }\n"
               "void f(struct AB *ab) {\n"
               "    ab->a[0] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("union { char a[1]; int b; } ab;\n"
               "void f() {\n"
               "    ab.a[2] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Array 'ab.a[1]' accessed at index 2, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (error) Array 'ab.a[1]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
 
@@ -618,7 +677,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    abc->str[10] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Array 'abc->str[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:13]: (error) Array 'abc->str[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_11() {
@@ -627,18 +686,17 @@ class TestBufferOverrun : public TestFixture {
               "public:\n"
               "    ABC();\n"
               "    char *str[10];\n"
-              "    struct ABC *next();"
+              "    struct ABC *next();\n"
               "};\n"
               "\n"
-              "static void f()\n"
+              "static void f(ABC *abc1)\n"
               "{\n"
-              "    ABC *abc1;\n"
               "    for ( ABC *abc = abc1; abc; abc = abc->next() )\n"
               "    {\n"
               "        abc->str[10] = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:13]: (error) Array 'abc->str[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:13:17]: (error) Array 'abc->str[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_12() {
@@ -653,7 +711,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    str[10] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:10]: (error) Array 'str[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:8]: (error) Array 'str[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("class Fred\n"
               "{\n"
@@ -666,7 +724,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    return str[10];\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:10]: (error) Array 'str[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:15]: (error) Array 'str[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_13() {
@@ -679,7 +737,7 @@ class TestBufferOverrun : public TestFixture {
               "            int x = buf[i];\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_14() {
@@ -689,7 +747,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i = 0; i < 10; i++)\n"
               "        a[i+10] = i;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'a[10]' accessed at index 19, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10]: (error) Array 'a[10]' accessed at index 19, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_15() {
@@ -699,7 +757,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i = 0; i < 10; i++)\n"
               "        a[10+i] = i;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'a[10]' accessed at index 19, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10]: (error) Array 'a[10]' accessed at index 19, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_16() {
@@ -709,7 +767,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i = 0; i < 10; i++)\n"
               "        a[i+1] = i;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'a[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10]: (error) Array 'a[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_17() {
@@ -719,7 +777,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i = 0; i < 10; i++)\n"
               "        a[i*2] = i;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'a[10]' accessed at index 18, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10]: (error) Array 'a[10]' accessed at index 18, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -727,7 +785,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i = 0; i < 12; i+=6)\n"
               "        a[i+5] = i;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -735,21 +793,21 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i = 0; i < 12; i+=6)\n"
               "        a[i+6] = i;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'a[12]' accessed at index 12, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10]: (error) Array 'a[12]' accessed at index 12, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"  // #4398
               "    int a[2];\n"
               "    for (int i = 0; i < 4; i+=2)\n"
               "        a[i] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'a[2]' accessed at index 2, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:10]: (error) Array 'a[2]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"  // #4398
               "    int a[2];\n"
               "    for (int i = 0; i < 4; i+=2)\n"
               "        do_stuff(a+i);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_18() {
@@ -762,7 +820,7 @@ class TestBufferOverrun : public TestFixture {
               "        i+=1;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -773,7 +831,7 @@ class TestBufferOverrun : public TestFixture {
               "        i++;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -784,7 +842,7 @@ class TestBufferOverrun : public TestFixture {
               "        ++i;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -795,7 +853,7 @@ class TestBufferOverrun : public TestFixture {
               "        i=4;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:10]: (error) Array 'a[5]' accessed at index 5, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -806,7 +864,7 @@ class TestBufferOverrun : public TestFixture {
               "        i+=1;\n"
               "    }\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:6]: (error) Buffer overrun\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:6]: (error) Buffer overrun\n", "", errout_str());
     }
 
     void array_index_19() {
@@ -816,7 +874,7 @@ class TestBufferOverrun : public TestFixture {
               "  char a[2];\n"
               "  char *end = &(a[2]);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Getting more than one past the end is not legal
         check("void f()\n"
@@ -824,7 +882,7 @@ class TestBufferOverrun : public TestFixture {
               "  char a[2];\n"
               "  char *end = &(a[3]);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'a[2]' accessed at index 3, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:18]: (error) Array 'a[2]' accessed at index 3, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_20() {
@@ -835,7 +893,7 @@ class TestBufferOverrun : public TestFixture {
               " for ( int i = 0; i < 9; i++ )\n"
               "  b[i] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_21() {
@@ -849,7 +907,7 @@ class TestBufferOverrun : public TestFixture {
               "  int b = indices[j];\n"
               " }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_22() {
@@ -857,7 +915,7 @@ class TestBufferOverrun : public TestFixture {
               "  size_t indices[2];\n"
               "  int b = indices[2];\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Array 'indices[2]' accessed at index 2, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:18]: (error) Array 'indices[2]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_23() {
@@ -866,77 +924,77 @@ class TestBufferOverrun : public TestFixture {
               "    char c[10];\n"
               "    c[1<<23]='a';\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'c[10]' accessed at index 8388608, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:6]: (error) Array 'c[10]' accessed at index 8388608, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_24() {
         // ticket #1492 and #1539
-        const std::string charMaxPlusOne(settings0.defaultSign == 'u' ? "256" : "128");
-        check(("void f(char n) {\n"
-               "    int a[n];\n"     // n <= CHAR_MAX
-               "    a[-1] = 0;\n"    // negative index
-               "    a[" + charMaxPlusOne + "] = 0;\n"   // 128/256 > CHAR_MAX
-               "}\n").c_str());
-        ASSERT_EQUALS("[test.cpp:3]: (error) Array 'a[" + charMaxPlusOne + "]' accessed at index -1, which is out of bounds.\n"
-                      "[test.cpp:4]: (error) Array 'a[" + charMaxPlusOne + "]' accessed at index " + charMaxPlusOne + ", which is out of bounds.\n", errout.str());
+        const std::string charMaxPlusOne(settings0.platform.defaultSign == 'u' ? "256" : "128");
+        check("void f(char n) {\n"
+              "    int a[n];\n"     // n <= CHAR_MAX
+              "    a[-1] = 0;\n"    // negative index
+              "    a[" + charMaxPlusOne + "] = 0;\n"   // 128/256 > CHAR_MAX
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'a[" + charMaxPlusOne + "]' accessed at index -1, which is out of bounds. [negativeIndex]\n"
+                      "[test.cpp:4:6]: (error) Array 'a[" + charMaxPlusOne + "]' accessed at index " + charMaxPlusOne + ", which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f(signed char n) {\n"
               "    int a[n];\n"     // n <= SCHAR_MAX
               "    a[-1] = 0;\n"    // negative index
               "    a[128] = 0;\n"   // 128 > SCHAR_MAX
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Array 'a[128]' accessed at index -1, which is out of bounds.\n"
-                      "[test.cpp:4]: (error) Array 'a[128]' accessed at index 128, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'a[128]' accessed at index -1, which is out of bounds. [negativeIndex]\n"
+                      "[test.cpp:4:6]: (error) Array 'a[128]' accessed at index 128, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f(unsigned char n) {\n"
               "    int a[n];\n"     // n <= UCHAR_MAX
               "    a[-1] = 0;\n"    // negative index
               "    a[256] = 0;\n"   // 256 > UCHAR_MAX
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Array 'a[256]' accessed at index -1, which is out of bounds.\n"
-                      "[test.cpp:4]: (error) Array 'a[256]' accessed at index 256, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'a[256]' accessed at index -1, which is out of bounds. [negativeIndex]\n"
+                      "[test.cpp:4:6]: (error) Array 'a[256]' accessed at index 256, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f(short n) {\n"
               "    int a[n];\n"     // n <= SHRT_MAX
               "    a[-1] = 0;\n"    // negative index
               "    a[32768] = 0;\n" // 32768 > SHRT_MAX
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Array 'a[32768]' accessed at index -1, which is out of bounds.\n"
-                      "[test.cpp:4]: (error) Array 'a[32768]' accessed at index 32768, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'a[32768]' accessed at index -1, which is out of bounds. [negativeIndex]\n"
+                      "[test.cpp:4:6]: (error) Array 'a[32768]' accessed at index 32768, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f(unsigned short n) {\n"
               "    int a[n];\n"     // n <= USHRT_MAX
               "    a[-1] = 0;\n"    // negative index
               "    a[65536] = 0;\n" // 65536 > USHRT_MAX
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Array 'a[65536]' accessed at index -1, which is out of bounds.\n"
-                      "[test.cpp:4]: (error) Array 'a[65536]' accessed at index 65536, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'a[65536]' accessed at index -1, which is out of bounds. [negativeIndex]\n"
+                      "[test.cpp:4:6]: (error) Array 'a[65536]' accessed at index 65536, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f(signed short n) {\n"
               "    int a[n];\n"     // n <= SHRT_MAX
               "    a[-1] = 0;\n"    // negative index
               "    a[32768] = 0;\n" // 32768 > SHRT_MAX
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Array 'a[32768]' accessed at index -1, which is out of bounds.\n"
-                      "[test.cpp:4]: (error) Array 'a[32768]' accessed at index 32768, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'a[32768]' accessed at index -1, which is out of bounds. [negativeIndex]\n"
+                      "[test.cpp:4:6]: (error) Array 'a[32768]' accessed at index 32768, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f(int n) {\n"
               "    int a[n];\n"     // n <= INT_MAX
               "    a[-1] = 0;\n"    // negative index
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Array 'a[2147483648]' accessed at index -1, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'a[2147483648]' accessed at index -1, which is out of bounds. [negativeIndex]\n", errout_str());
 
         check("void f(unsigned int n) {\n"
               "    int a[n];\n"     // n <= UINT_MAX
               "    a[-1] = 0;\n"    // negative index
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Array 'a[4294967296]' accessed at index -1, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'a[4294967296]' accessed at index -1, which is out of bounds. [negativeIndex]\n", errout_str());
 
         check("void f(signed int n) {\n"
               "    int a[n];\n"     // n <= INT_MAX
               "    a[-1] = 0;\n"    // negative index
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Array 'a[2147483648]' accessed at index -1, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'a[2147483648]' accessed at index -1, which is out of bounds. [negativeIndex]\n", errout_str());
     }
 
     void array_index_25() { // #1536
@@ -944,7 +1002,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "   long l[SOME_SIZE];\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_26() {
@@ -954,7 +1012,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i = 3; 0 <= i; i--)\n"
               "        a[i] = i;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'a[3]' accessed at index 3, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10]: (error) Array 'a[3]' accessed at index 3, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -962,7 +1020,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i = 3; 0 <= i; i--)\n"
               "        a[i] = i;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_27() {
@@ -972,7 +1030,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i = 0; i < 10; i++)\n"
               "        a[i-1] = a[i];\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'a[10]' accessed at index -1, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10]: (error) Array 'a[10]' accessed at index -1, which is out of bounds. [negativeIndex]\n", errout_str());
     }
 
     void array_index_28() {
@@ -983,7 +1041,7 @@ class TestBufferOverrun : public TestFixture {
               "    int *ip = i + 1;\n"
               "    ip[-10] = 1;\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Array ip[-10] out of bounds.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Array ip[-10] out of bounds.\n", "", errout_str());
     }
 
     void array_index_29() {
@@ -995,16 +1053,17 @@ class TestBufferOverrun : public TestFixture {
               "    int *ii = i + -5;"
               "    ii[10] = 0;"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:6]: (error) Array ii[10] out of bounds.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:6]: (error) Array ii[10] out of bounds.\n", "", errout_str());
     }
 
     void array_index_30() {
         // ticket #2086 - unknown type
+        // extracttests.start: typedef unsigned char UINT8;
         check("void f() {\n"
               "    UINT8 x[2];\n"
               "    x[5] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Array 'x[2]' accessed at index 5, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'x[2]' accessed at index 5, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_31() {
@@ -1021,7 +1080,7 @@ class TestBufferOverrun : public TestFixture {
               "    struct s1 obj;\n"
               "    x(obj.delay, 123);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct s1 {\n"
               "    unknown_type_t delay[3];\n"
@@ -1035,7 +1094,9 @@ class TestBufferOverrun : public TestFixture {
               "    struct s1 obj;\n"
               "    x(obj.delay, 123);\n"
               "}");
-        // TODO CTU ASSERT_EQUALS("[test.cpp:11] -> [test.cpp:6]: (error) Array 'obj.delay[3]' accessed at index 4, which is out of bounds.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:11] -> [test.cpp:6]: (error) Array 'obj.delay[3]' accessed at index 4, which is out of bounds.\n",
+                           "",
+                           errout_str());
 
         check("struct s1 {\n"
               "    float a[0];\n"
@@ -1044,7 +1105,7 @@ class TestBufferOverrun : public TestFixture {
               "void f() {\n"
               "    struct s1 *obj;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_32() {
@@ -1058,14 +1119,14 @@ class TestBufferOverrun : public TestFixture {
               "    }\n"
               "    int m_x[1];\n"
               "};");
-        // TODO [1] ASSERT_EQUALS("[test.cpp:7]: (error) Array 'm_x[1]' accessed at index 1, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:11]: (error) Array 'm_x[1]' accessed at index 1, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_33() {
         check("void foo(char bar[][4]) {\n"
               "    baz(bar[5]);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_34() { // ticket #3063
@@ -1074,8 +1135,8 @@ class TestBufferOverrun : public TestFixture {
               "    y[0][2][0] = 0;\n"
               "    y[0][0][2] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Array 'y[2][2][2]' accessed at index y[0][2][0], which is out of bounds.\n"
-                      "[test.cpp:4]: (error) Array 'y[2][2][2]' accessed at index y[0][0][2], which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:6]: (error) Array 'y[2][2][2]' accessed at index y[0][2][0], which is out of bounds. [arrayIndexOutOfBounds]\n"
+                      "[test.cpp:4:6]: (error) Array 'y[2][2][2]' accessed at index y[0][0][2], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("struct TEST\n"
               "{\n"
@@ -1094,12 +1155,12 @@ class TestBufferOverrun : public TestFixture {
               "    ptest->b[10][2] = 4;\n"
               "    ptest->b[0][19] = 4;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:9]: (error) Array 'test.a[10]' accessed at index 10, which is out of bounds.\n"
-                      "[test.cpp:10]: (error) Array 'test.b[10][5]' accessed at index test.b[10][2], which is out of bounds.\n"
-                      "[test.cpp:11]: (error) Array 'test.b[10][5]' accessed at index test.b[0][19], which is out of bounds.\n"
-                      "[test.cpp:14]: (error) Array 'ptest->a[10]' accessed at index 10, which is out of bounds.\n"
-                      "[test.cpp:15]: (error) Array 'ptest->b[10][5]' accessed at index ptest->b[10][2], which is out of bounds.\n"
-                      "[test.cpp:16]: (error) Array 'ptest->b[10][5]' accessed at index ptest->b[0][19], which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:11]: (error) Array 'test.a[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n"
+                      "[test.cpp:10:11]: (error) Array 'test.b[10][5]' accessed at index test.b[10][2], which is out of bounds. [arrayIndexOutOfBounds]\n"
+                      "[test.cpp:11:11]: (error) Array 'test.b[10][5]' accessed at index test.b[0][19], which is out of bounds. [arrayIndexOutOfBounds]\n"
+                      "[test.cpp:14:13]: (error) Array 'ptest->a[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n"
+                      "[test.cpp:15:13]: (error) Array 'ptest->b[10][5]' accessed at index ptest->b[10][2], which is out of bounds. [arrayIndexOutOfBounds]\n"
+                      "[test.cpp:16:13]: (error) Array 'ptest->b[10][5]' accessed at index ptest->b[0][19], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("struct TEST\n"
               "{\n"
@@ -1115,10 +1176,10 @@ class TestBufferOverrun : public TestFixture {
               "    ptest->a[9][5] = 4;\n"
               "    ptest->a[0][50] = 4;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Array 'test.a[10][5]' accessed at index test.a[9][5], which is out of bounds.\n"
-                      "[test.cpp:9]: (error) Array 'test.a[10][5]' accessed at index test.a[0][50], which is out of bounds.\n"
-                      "[test.cpp:12]: (error) Array 'ptest->a[10][5]' accessed at index ptest->a[9][5], which is out of bounds.\n"
-                      "[test.cpp:13]: (error) Array 'ptest->a[10][5]' accessed at index ptest->a[0][50], which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:11]: (error) Array 'test.a[10][5]' accessed at index test.a[9][5], which is out of bounds. [arrayIndexOutOfBounds]\n"
+                      "[test.cpp:9:11]: (error) Array 'test.a[10][5]' accessed at index test.a[0][50], which is out of bounds. [arrayIndexOutOfBounds]\n"
+                      "[test.cpp:12:13]: (error) Array 'ptest->a[10][5]' accessed at index ptest->a[9][5], which is out of bounds. [arrayIndexOutOfBounds]\n"
+                      "[test.cpp:13:13]: (error) Array 'ptest->a[10][5]' accessed at index ptest->a[0][50], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_35() { // ticket #2889
@@ -1126,21 +1187,21 @@ class TestBufferOverrun : public TestFixture {
               "    struct Struct { unsigned m_Var[1]; } s;\n"
               "    s.m_Var[1] = 1;\n"
               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:3]: (error) Array 's.m_Var[1]' accessed at index 1, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Array 's.m_Var[1]' accessed at index 1, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("struct Struct { unsigned m_Var[1]; };\n"
               "void f() {\n"
               "    struct Struct s;\n"
               "    s.m_Var[1] = 1;\n"
               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:4]: (error) Array 's.m_Var[1]' accessed at index 1, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:12]: (error) Array 's.m_Var[1]' accessed at index 1, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("struct Struct { unsigned m_Var[1]; };\n"
               "void f() {\n"
               "    struct Struct * s = calloc(40);\n"
               "    s->m_Var[1] = 1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_36() { // ticket #2960
@@ -1152,8 +1213,8 @@ class TestBufferOverrun : public TestFixture {
               "Fred::Fred(const Fred & rhs) {\n"
               "    m_b[2] = rhs.m_b[2];\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Array 'm_b[2]' accessed at index 2, which is out of bounds.\n"
-                      "[test.cpp:7]: (error) Array 'rhs.m_b[2]' accessed at index 2, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:8]: (error) Array 'm_b[2]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]\n"
+                      "[test.cpp:7:21]: (error) Array 'rhs.m_b[2]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_37() {
@@ -1164,7 +1225,7 @@ class TestBufferOverrun : public TestFixture {
               "            i;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_38() { //ticket #3273
@@ -1183,7 +1244,7 @@ class TestBufferOverrun : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_39() { // ticket 3387
@@ -1192,7 +1253,7 @@ class TestBufferOverrun : public TestFixture {
               "    char a[10];\n"
               "    a[10] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'a[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:6]: (error) Array 'a[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_40() {
@@ -1201,7 +1262,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i = 0; i < 10; ++i)\n"
               "        f2(&a[i + 1]);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_41() {
@@ -1214,7 +1275,7 @@ class TestBufferOverrun : public TestFixture {
               "void b() {\n"
               "    struct Fred { char data[3]; } fred;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void a() {\n"
               "    struct Fred { char data[6]; } fred;\n"
@@ -1225,27 +1286,35 @@ class TestBufferOverrun : public TestFixture {
               "    struct Fred { char data[3]; } fred;\n"
               "    fred.data[4] = 0;\n"  // <- error
               "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Array 'fred.data[3]' accessed at index 4, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:14]: (error) Array 'fred.data[3]' accessed at index 4, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_42() { // ticket #3569
 
         check("void f()\n"
               "{\n"
-              "  char *p; p = malloc(10);\n"
+              "  char *p; p = (char *)malloc(10);\n"
+              "  p[10] = 7;\n"
+              "  free(p);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:4]: (error) Array 'p[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+
+        check("void f()\n"
+              "{\n"
+              "  float *p; p = (float *)malloc(10 * sizeof(float));\n"
               "  p[10] = 7;\n"
               "  free(p);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'p[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:4]: (error) Array 'p[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
-              "  char *p; p = malloc(10);\n"
+              "  char *p; p = (char *)malloc(10);\n"
               "  p[0] = 0;\n"
               "  p[9] = 9;\n"
               "  free(p);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -1254,7 +1323,7 @@ class TestBufferOverrun : public TestFixture {
               "  p[9] = 9;\n"
               "  delete [] p;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -1263,7 +1332,7 @@ class TestBufferOverrun : public TestFixture {
               "  p[9] = 9;\n"
               "  delete [] p;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -1278,7 +1347,7 @@ class TestBufferOverrun : public TestFixture {
               "  p[9] = 9;\n"
               "  delete [] p;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_43() { // #3838
@@ -1295,7 +1364,7 @@ class TestBufferOverrun : public TestFixture {
               "   y = var[ 0 ].arr[ 3 ];\n" // <-- array access out of bounds
               "   return y;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:10]: (error) Array 'var[0].arr[3]' accessed at index 3, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:20]: (error) Array 'var[0].arr[3]' accessed at index 3, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("int f( )\n"
               "{\n"
@@ -1309,10 +1378,10 @@ class TestBufferOverrun : public TestFixture {
               "   y = var[ 0 ].arr[ 2 ];\n"
               "   return y;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
 
-        check("int f( ){ \n"
+        check("int f( ){\n"
               "struct Struct{\n"
               "    int arr[ 3 ];\n"
               "};\n"
@@ -1325,8 +1394,8 @@ class TestBufferOverrun : public TestFixture {
               "y=var.arr[ 3 ];\n"   // <-- array access out of bounds
               "return y;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:10]: (error) Array 'var.arr[3]' accessed at index 3, which is out of bounds.\n"
-                      "[test.cpp:11]: (error) Array 'var.arr[3]' accessed at index 3, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:8]: (error) Array 'var.arr[3]' accessed at index 3, which is out of bounds. [arrayIndexOutOfBounds]\n"
+                      "[test.cpp:11:10]: (error) Array 'var.arr[3]' accessed at index 3, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
 
         check("void f( ) {\n"
@@ -1339,7 +1408,7 @@ class TestBufferOverrun : public TestFixture {
               "var[0].var[ 2 ] = 2;\n"
               "var[0].var[ 4 ] = 4;\n" // <-- array access out of bounds
               "}");
-        ASSERT_EQUALS("[test.cpp:9]: (error) Array 'var[0].var[3]' accessed at index 4, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:11]: (error) Array 'var[0].var[3]' accessed at index 4, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f( ) {\n"
               "struct S{\n"
@@ -1350,32 +1419,32 @@ class TestBufferOverrun : public TestFixture {
               "var[0].var[ 1 ] = 1;\n"
               "var[0].var[ 2 ] = 2;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // avoid FPs (modified examples taken from #3838)
         check("struct AB { int a[10]; int b[10]; };\n"
               "int main() {\n"
               "    struct AB ab;\n"
-              "    int * p = &ab.a[10]; \n"
+              "    int * p = &ab.a[10];\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct AB { int a[10]; int b[10]; };\n"
               "int main() {\n"
               "    struct AB ab[1];\n"
-              "    int * p = &ab[0].a[10]; \n"
+              "    int * p = &ab[0].a[10];\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct AB { int a[10]; int b[10]; };\n"
               "int main() {\n"
               "    struct AB ab[1];\n"
-              "    int * p = &ab[10].a[0]; \n"
+              "    int * p = &ab[10].a[0];\n"
               "    return 0;\n"
               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:4]: (error) Array 'ab[1]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:18]: (error) Array 'ab[1]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_44() { // #3979 (false positive)
@@ -1389,7 +1458,7 @@ class TestBufferOverrun : public TestFixture {
               "        buf[i] = 1;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -1399,7 +1468,7 @@ class TestBufferOverrun : public TestFixture {
               "        buf[i] = 2.;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_45() { // #4207 - handling of function with variable number of parameters / unnamed arguments
@@ -1412,7 +1481,7 @@ class TestBufferOverrun : public TestFixture {
               "    CHAR buffer[1024];\n"
               "    f(\"%s\", buffer);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Unnamed argument
         check("void f(char *) {\n"
@@ -1422,7 +1491,7 @@ class TestBufferOverrun : public TestFixture {
               "    char buffer[1024];\n"
               "    f(buffer);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // Two statement for-loop
@@ -1434,7 +1503,7 @@ class TestBufferOverrun : public TestFixture {
               "        printf(\"files(%i): %s\", 3-i, buffer[3-i]);\n"
               "    }\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Array 'buffer[3]' accessed at index 3, which is out of bounds.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Array 'buffer[3]' accessed at index 3, which is out of bounds.\n", "", errout_str());
 
         check("void f() {\n"
               "    int buffer[9];\n"
@@ -1443,7 +1512,7 @@ class TestBufferOverrun : public TestFixture {
               "        buffer[i] = i;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'buffer[9]' accessed at index 9, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:15]: (error) Array 'buffer[9]' accessed at index 9, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // Correct access limits -> i from 9 to 0
         check("void f() {\n"
@@ -1452,7 +1521,7 @@ class TestBufferOverrun : public TestFixture {
               "        buffer[i] = i;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_47() {
@@ -1460,9 +1529,484 @@ class TestBufferOverrun : public TestFixture {
         check("int s[4];\n"
               "void f() {\n"
               "    for (int i = 2; i < 0; i++)\n"
-              "        s[i] = 5; \n"
+              "        s[i] = 5;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void array_index_48() {
+        // #9478
+        check("void test(void)\n"
+              "{\n"
+              "    int array[4] = { 1,2,3,4 };\n"
+              "    for (int i = 1; i <= 4; i++) {\n"
+              "        printf(\" %i\", i);\n"
+              "        array[i] = 0;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:6:14]: (error) Array 'array[4]' accessed at index 4, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+
+        check("void test(void)\n"
+              "{\n"
+              "    int array[4] = { 1,2,3,4 };\n"
+              "    for (int i = 1; i <= 4; i++) {\n"
+              "        scanf(\"%i\", &i);\n"
+              "        array[i] = 0;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void array_index_49() {
+        // #8653
+        check("void f() {\n"
+              "    int i, k;\n"
+              "    int arr[34] = {};\n"
+              "    i = 1;\n"
+              "    for (k = 0; k < 34 && i < 34; k++) {\n"
+              "        i++;\n"
+              "    }\n"
+              "    arr[k];\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void array_index_50() {
+        check("void f(const char * str) {\n"
+              "    int len = strlen(str);\n"
+              "    (void)str[len - 1];\n"
+              "}\n"
+              "void g() {\n"
+              "    f(\"12345678\");\n"
+              "    f(\"12345\");\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void array_index_51() {
+        check("void f(void){\n"
+              "    int k=0, dd, d[1U] = {1};\n"
+              "    for (dd=d[k]; k<10; dd=d[++k]){;}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:29]: (error) Array 'd[1]' accessed at index 1, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+    }
+
+    void array_index_52() {
+        check("char f(void)\n"
+              "{\n"
+              "    char buf[10];\n"
+              "    for(int i = 0, j= 11; i < j; ++i)\n"
+              "       buf[i] = 0;\n"
+              "    return buf[0];\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:11]: (error) Array 'buf[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+    }
+
+    void array_index_53() {
+        check("double M[3][1];\n"
+              " \n"
+              "void matrix()\n"
+              "{\n"
+              "    for (int i=0; i < 3; i++)\n"
+              "        for (int j = 0; j < 3; j++)\n"
+              "             M[i][j]=0.0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:15]: (error) Array 'M[3][1]' accessed at index M[*][2], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+    }
+
+    void array_index_54() {
+        check("void f() {\n"
+              "    g(0);\n"
+              "}\n"
+              "void g(unsigned int x) {\n"
+              "    int b[4];\n"
+              "    for (unsigned int i = 0; i < 4; i += 2) {\n"
+              "        b[i]   = 0;\n"
+              "        b[i+1] = 0;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void array_index_55() {
+        check("void make(const char* s, size_t len) {\n"
+              "    for (size_t i = 0; i < len; ++i)\n"
+              "        s[i];\n"
+              "}\n"
+              "void make(const char* s) {\n"
+              "    make(s, strlen(s));\n"
+              "}\n"
+              "void f() {\n"
+              "    make(\"my-utf8-payload\");\n"
+              "}\n"
+              "void f2() {\n"
+              "    make(\"false\");\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void array_index_56() {
+        check("struct s {\n"
+              "    int array[1];\n"
+              "    int index;\n"
+              "};\n"
+              "void f(struct s foo) {\n"
+              "    foo.array[foo.index++] = 1;\n"
+              "    if (foo.index == 1) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void array_index_57() {
+        check("void f(std::vector<int>& v) {\n"
+              "    int a[3] = { 1, 2, 3 };\n"
+              "    int i = 0;\n"
+              "    for (auto& x : v) {\n"
+              "        int c = a[i++];\n"
+              "        if (i == 3)\n"
+              "            i = 0;\n"
+              "        x = c;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::vector<int>& v) {\n"
+              "    int a[3] = { 1, 2, 3 };\n"
+              "    int i = 0;\n"
+              "    for (auto& x : v) {\n"
+              "        int c = a[i++];\n"
+              "        if (i == 4)\n"
+              "            i = 0;\n"
+              "        x = c;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:6:15] -> [test.cpp:5:18]: (warning) Either the condition 'i==4' is redundant or the array 'a[3]' is accessed at index 3, which is out of bounds. [arrayIndexOutOfBoundsCond]\n",
+            errout_str());
+    }
+
+    void array_index_58()
+    {
+        check("int f(int x, int y) {\n"
+              "    int a[3]= {0,1,2};\n"
+              "    if(x<2)\n"
+              "        y = a[x] + 1;\n"
+              "    else\n"
+              "        y = a[x];\n"
+              "    return y;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:9] -> [test.cpp:6:14]: (warning) Either the condition 'x<2' is redundant or the array 'a[3]' is accessed at index 3, which is out of bounds. [arrayIndexOutOfBoundsCond]\n",
+            errout_str());
+
+        check("void f() {\n" // #2199
+              "    char a[5];\n"
+              "    for (int i = 0; i < 5; i++) {\n"
+              "        i += 8;\n"
+              "        a[i] = 0;\n"
+              "    }\n"
+              "}\n"
+              "void g() {\n"
+              "    char a[5];\n"
+              "    for (int i = 0; i < 5; i++) {\n"
+              "        a[i + 7] = 0;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:5:10]: (error) Array 'a[5]' accessed at index 8, which is out of bounds. [arrayIndexOutOfBounds]\n"
+            "[test.cpp:11:10]: (error) Array 'a[5]' accessed at index 11, which is out of bounds. [arrayIndexOutOfBounds]\n",
+            errout_str());
+    }
+
+    void array_index_59() // #10413
+    {
+        check("long f(long b) {\n"
+              "  const long a[] = { 0, 1, };\n"
+              "  const long c = std::size(a);\n"
+              "  if (b < 0 || b >= c)\n"
+              "    return 0;\n"
+              "  return a[b];\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int a, int b) {\n"
+              "    const int S[2] = {};\n"
+              "    if (a < 0) {}\n"
+              "    else {\n"
+              "        if (b < 0) {}\n"
+              "        else if (S[b] > S[a]) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int a[2] = {};\n"
+              "void f(int i) {\n"
+              "    g(i < 0 ? 0 : a[i]);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void array_index_60()
+    {
+        checkP("#define CKR(B) if (!(B)) { return -1; }\n"
+               "int f(int i) {\n"
+               "  const int A[3] = {};\n"
+               "  CKR(i < 3);\n"
+               "  if (i > 0)\n"
+               "      i = A[i];\n"
+               "  return i;\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkP("#define ASSERT(expression, action) if (expression) {action;}\n"
+               "int array[5];\n"
+               "void func (int index) {\n"
+               "    ASSERT(index > 5, return);\n"
+               "    array[index]++;\n"
+               "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:4:5] -> [test.cpp:5:10]: (warning) Either the condition 'index>5' is redundant or the array 'array[5]' is accessed at index 5, which is out of bounds. [arrayIndexOutOfBoundsCond]\n",
+            errout_str());
+    }
+
+    void array_index_61()
+    {
+        check("int f(int i) {\n"
+              "  const int M[] = { 0, 1, 2, 3 };\n"
+              "  if (i > 4)\n"
+              "      return -1;\n"
+              "  if (i < 0 || i == std::size(M))\n"
+              "    return 0; \n"
+              "  return M[i];\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { enum E { e0 }; };\n"
+              "const S::E M[4] = { S::E:e0, S::E:e0, S::E:e0, S::E:e0 };\n"
+              "int f(int i) {\n"
+              "  if (i > std::size(M) + 1)\n"
+              "	  return -1;\n"
+              "  if (i < 0 || i >= std::size(M))\n"
+              "	  return 0;\n"
+              "  return M[i]; \n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void array_index_62()
+    {
+        check("struct X {\n"
+              "    static int GetSize() {return 11;}\n"
+              "};\n"
+              "char f() {\n"
+              "    char buf[10]= {0};\n"
+              "    for(int i = 0; i < X::GetSize(); ++i) \n"
+              "       buf[i] = 0;\n"
+              "    return buf[0];\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:7:11]: (error) Array 'buf[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n",
+                      errout_str());
+    }
+
+    void array_index_63()
+    {
+        check("int b[4];\n" // #10979
+              "void f(int i) {\n"
+              "    if (i >= 0 && i < sizeof(b) / sizeof(*(b)))\n"
+              "        b[i] = 0;\n"
+              "    if (i >= 0 && i < sizeof(b) / sizeof((b)[0]))\n"
+              "        b[i] = 0;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void array_index_64() // #10878
+    {
+        check("struct Array {\n"
+              "    int x[10];\n"
+              "    int& accessArrayRef(int a) { return x[a]; }\n"
+              "};\n"
+              "void f() {\n"
+              "    Array array = {};\n"
+              "    array.accessArrayRef(10);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:42]: (error) Array 'x[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+
+        check("int i = 10;\n"
+              "struct Array {\n"
+              "    int x[10];\n"
+              "    int& accessArrayRef(int a) { return x[a]; }\n"
+              "};\n"
+              "void f() {\n"
+              "    Array array = {};\n"
+              "    array.accessArrayRef(i);\n"
+              "}\n");
+        TODO_ASSERT_EQUALS("[test.cpp:3:42]: (error) Array 'x[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", "", errout_str());
+    }
+
+    void array_index_65() // #11066
+    {
+        check("char P[] = { 2, 1 };\n"
+              "char f[2];\n"
+              "void e(char* c) {\n"
+              "    register j;\n"
+              "    for (j = 0; j < 2; j++)\n"
+              "        c[j] = f[P[j] - 1];\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void array_index_66()
+    {
+        check("void foo(int j) {\n"
+              "    int offsets[256];\n"
+              "    while (x) {\n"
+              "        if (j >= 256) break;\n"
+              "        offsets[++j] = -1;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:4:15] -> [test.cpp:5:16]: (warning) Either the condition 'j>=256' is redundant or the array 'offsets[256]' is accessed at index 256, which is out of bounds. [arrayIndexOutOfBoundsCond]\n",
+            errout_str());
+    }
+
+    void array_index_67() {
+        check("void func(int i) {\n" // #1596
+              "    int types[3];\n"
+              "    int type_cnt = 0;\n"
+              "    if (i == 0) {\n"
+              "        types[type_cnt] = 0;\n"
+              "        type_cnt++;\n"
+              "        types[type_cnt] = 0;\n"
+              "        type_cnt++;\n"
+              "        types[type_cnt] = 0;\n"
+              "        type_cnt++;\n"
+              "    } else {\n"
+              "        types[type_cnt] = 1;\n"
+              "        type_cnt++;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void array_index_68() { // #6655
+        check("int ia[10];\n"
+              "void f(int len) {\n"
+              "    for (int i = 0; i < len; i++)\n"
+              "        ia[i] = 0;\n"
+              "}\n"
+              "int g() {\n"
+              "    f(20);\n"
+              "    return 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:11]: (error) Array 'ia[10]' accessed at index 19, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+    }
+
+    // #6370
+    void array_index_69()
+    {
+        check("void f() {\n"
+              "    const int e[] = {0,10,20,30};\n"
+              "    int a[4];\n"
+              "    for(int i = 0; i < 4; ++i)\n"
+              "      a[e[i]] = 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:8]: (error) Array 'a[4]' accessed at index 30, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+    }
+
+    // #11355
+    void array_index_70() {
+        check("void f() {\n"
+              "    static const char a[] = ((\"test\"));\n"
+              "    printf(\"%c\", a[5]);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:19]: (error) Array 'a[5]' accessed at index 5, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+    }
+
+    // #11461
+    void array_index_71()
+    {
+        check("unsigned int f(unsigned int Idx) {\n"
+              "  if (Idx < 64)\n"
+              "    return 0;\n"
+              "  Idx -= 64;\n"
+              "  int arr[64] = { 0 };\n"
+              "  return arr[Idx];\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // #11784
+    void array_index_72()
+    {
+        check("char f(int i) {\n"
+              "  char d[4] = {};\n"
+              "  for (; i < 3; i++) {}\n"
+              "  for (i++; i > 0;) {\n"
+              "    d[--i] = 1;\n"
+              "    break;\n"
+              "  }\n"
+              "  return d[3];\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // #11530
+    void array_index_73()
+    {
+        check("void f() {\n"
+              "  int k = 0;\n"
+              "  std::function<void(int)> a[1] = {};\n"
+              "  a[k++](0);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // #11088
+    void array_index_74()
+    {
+        check("void foo(const char *keys) {\n"
+              "  const char *prefix = \"<Shift+\";\n"
+              "  const size_t prefix_len = strlen(prefix);\n"
+              "  if (strncmp(keys, prefix, prefix_len)) { return; }\n"
+              "  if (keys[prefix_len] == '>') {}\n"
+              "}\n"
+              "void bar() {\n"
+              "  foo(\"q\");\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // #1644
+    void array_index_75()
+    {
+        check("void f() {\n"
+              "    char buf[10];\n"
+              "    int i = 10;\n"
+              "    while (i >= 3)\n"
+              "        buf[i--] = 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:12]: (error) Array 'buf[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+    }
+
+    // #12592
+    void array_index_76()
+    {
+        check("void cb0(void*, int i) {\n"
+              "    const char s[] = \"\";\n"
+              "    (void)s[i];\n"
+              "}\n"
+              "void cb1(int i, void*) {\n"
+              "    const char s[] = \"\";\n"
+              "    (void)s[i];\n"
+              "}\n"
+              "void f() {\n"
+              "    cb0(nullptr, 1);\n"
+              "    cb1(1, nullptr);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Array 's[1]' accessed at index 1, which is out of bounds. [arrayIndexOutOfBounds]\n"
+                      "[test.cpp:7:12]: (error) Array 's[1]' accessed at index 1, which is out of bounds. [arrayIndexOutOfBounds]\n",
+                      errout_str());
     }
 
     void array_index_multidim() {
@@ -1471,87 +2015,87 @@ class TestBufferOverrun : public TestFixture {
               "  char a[2][2];\n"
               "  a[1][1] = 'a';\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
               "  char a[2][2][2];\n"
               "  a[1][1][1] = 'a';\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
               "  char a[2][2];\n"
               "  a[2][1] = 'a';\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'a[2][2]' accessed at index a[2][1], which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:4]: (error) Array 'a[2][2]' accessed at index a[2][1], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "  char a[2][2];\n"
               "  a[1][2] = 'a';\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'a[2][2]' accessed at index a[1][2], which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:4]: (error) Array 'a[2][2]' accessed at index a[1][2], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "  char a[2][2][2];\n"
               "  a[2][1][1] = 'a';\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'a[2][2][2]' accessed at index a[2][1][1], which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:4]: (error) Array 'a[2][2][2]' accessed at index a[2][1][1], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "  char a[2][2][2];\n"
               "  a[1][2][1] = 'a';\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'a[2][2][2]' accessed at index a[1][2][1], which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:4]: (error) Array 'a[2][2][2]' accessed at index a[1][2][1], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "  char a[2][2][2][2];\n"
               "  a[1][2][1][1] = 'a';\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'a[2][2][2][2]' accessed at index a[1][2][1][1], which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:4]: (error) Array 'a[2][2][2][2]' accessed at index a[1][2][1][1], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "  char a[2][2][2];\n"
               "  a[1][1][2] = 'a';\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'a[2][2][2]' accessed at index a[1][1][2], which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:4]: (error) Array 'a[2][2][2]' accessed at index a[1][1][2], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "  char a[10][10][10];\n"
               "  a[2*3][4*3][2] = 'a';\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'a[10][10][10]' accessed at index a[6][12][2], which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:4]: (error) Array 'a[10][10][10]' accessed at index a[6][12][2], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "  char a[10][10][10];\n"
               "  a[6][40][10] = 'a';\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Array 'a[10][10][10]' accessed at index a[6][40][10], which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:4]: (error) Array 'a[10][10][10]' accessed at index a[6][40][10], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "  char a[1][1][1];\n"
               "  a[2][2][2] = 'a';\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Array 'a[1][1][1]' accessed at index a[2][2][2], which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:4]: (error) Array 'a[1][1][1]' accessed at index a[2][2][2], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "  char a[6][6][6];\n"
               "  a[6][6][2] = 'a';\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Array 'a[6][6][6]' accessed at index a[6][6][2], which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:4]: (error) Array 'a[6][6][6]' accessed at index a[6][6][2], which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "  int a[2][2];\n"
               "  p = &a[2][0];\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // unknown dim..
         check("void f()\n"
@@ -1559,7 +2103,7 @@ class TestBufferOverrun : public TestFixture {
               "  int a[2][countof(x)] = {{1,2},{3,4}};\n"
               "  a[0][0] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void draw_quad(float z)  {\n"
               "    int i;\n"
@@ -1580,8 +2124,8 @@ class TestBufferOverrun : public TestFixture {
               "        vertices[i][1][2] = 4.0;\n"
               "        vertices[i][1][3] = 5.0;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         {
             check("int foo() {\n"
@@ -1590,7 +2134,7 @@ class TestBufferOverrun : public TestFixture {
                   "  extern int stuff[A][B];\n"
                   "  return stuff[0][1];\n"
                   "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
 
             // TODO: better handling of VLAs in symboldatabase. should be
             //       possible to use ValueFlow values.
@@ -1600,7 +2144,7 @@ class TestBufferOverrun : public TestFixture {
                   "  extern int stuff[A][B];\n"
                   "  return stuff[0][1];\n"
                   "}");
-            TODO_ASSERT_EQUALS("error", "", errout.str());
+            TODO_ASSERT_EQUALS("error", "", errout_str());
         }
     }
 
@@ -1621,7 +2165,7 @@ class TestBufferOverrun : public TestFixture {
               "  };\n"
               " }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -1639,7 +2183,7 @@ class TestBufferOverrun : public TestFixture {
               "  };\n"
               " }\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:12]: (error) Array index out of bounds.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:12]: (error) Array index out of bounds.\n", "", errout_str());
     }
 
     void array_index_for_in_for() {
@@ -1651,7 +2195,19 @@ class TestBufferOverrun : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void array_index_bounds() {
+        // #10275
+        check("int a[10];\n"
+              "void f(int i) {\n"
+              "  if (i >= 0 && i < 10) {}\n"
+              "  a[i] = 1;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:19] -> [test.cpp:4:4]: (warning) Either the condition 'i<10' is redundant or the array 'a[10]' is accessed at index 10, which is out of bounds. [arrayIndexOutOfBoundsCond]\n"
+                      "[test.cpp:3:9] -> [test.cpp:4:4]: (warning) Either the condition 'i>=0' is redundant or the array 'a[10]' is accessed at index -1, which is out of bounds. [negativeIndex]\n",
+                      errout_str());
     }
 
     void array_index_calculation() {
@@ -1663,7 +2219,7 @@ class TestBufferOverrun : public TestFixture {
               "        data[i/2] = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'data[8]' accessed at index 17, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:13]: (error) Array 'data[8]' accessed at index 17, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // #2199 - false negative: array out of bounds in loop when there is calculation
         check("void f()\n"
@@ -1673,7 +2229,7 @@ class TestBufferOverrun : public TestFixture {
               "        arr[i + 7] = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'arr[5]' accessed at index 11, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:12]: (error) Array 'arr[5]' accessed at index 11, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_negative1() {
@@ -1683,21 +2239,21 @@ class TestBufferOverrun : public TestFixture {
               "    char data[8];\n"
               "    data[-1] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'data[8]' accessed at index -1, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Array 'data[8]' accessed at index -1, which is out of bounds. [negativeIndex]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "    char data[8][4];\n"
               "    data[5][-1] = 0;\n"
               "}");
-        // TODO multidim ASSERT_EQUALS("[test.cpp:4]: (error) Array index -1 is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Array 'data[8][4]' accessed at index data[*][-1], which is out of bounds. [negativeIndex]\n", errout_str());
 
         // #1614 - negative index is ok for pointers
         check("void foo(char *p)\n"
               "{\n"
               "    p[-1] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -1705,14 +2261,14 @@ class TestBufferOverrun : public TestFixture {
               "    char *p = s + strlen(s);\n"
               "    if (p[-1]);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ticket #1850
         check("int f(const std::map<int, std::map<int,int> > &m)\n"
               "{\n"
               "    return m[0][-1];\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_negative2() { // ticket #3063
@@ -1721,7 +2277,7 @@ class TestBufferOverrun : public TestFixture {
               "    TEST test;\n"
               "    test.a[-1] = 3;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'test.a[10]' accessed at index -1, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:11]: (error) Array 'test.a[10]' accessed at index -1, which is out of bounds. [negativeIndex]\n", errout_str());
     }
 
     void array_index_negative3() {
@@ -1737,7 +2293,103 @@ class TestBufferOverrun : public TestFixture {
               "    if( i == 0 )\n"
               "        return f(i);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void array_index_negative4()
+    {
+        check("void f(void) {\n"
+              "    int buf[64]={};\n"
+              "    int i;\n"
+              "    for(i=0; i <16; ++i){}\n"
+              "    for(; i < 24; ++i){ buf[i] = buf[i-16];}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void array_index_negative5() // #10526
+    {
+        check("int i;\n"
+              "std::vector<int> v;\n"
+              "bool f() {\n"
+              "    if (i != 0) {\n"
+              "        if (v.begin() != v.end()) {\n"
+              "            if (i < 0)\n"
+              "                return false;\n"
+              "            const int a[4] = { 0, 1, 2, 3 };\n"
+              "            return a[i - 1] > 0;\n"
+              "        }\n"
+              "    }\n"
+              "    return false;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // #11349
+    void array_index_negative6()
+    {
+        check("void f(int i) {\n"
+              "  int j = i;\n"
+              "  const int a[5] = {};\n"
+              "  const int k = j < 0 ? 0 : j;\n"
+              "  (void)a[k];\n"
+              "  if (i == -3) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // #5685
+    void array_index_negative7()
+    {
+        check("void f() {\n"
+              "    int i = -9;\n"
+              "    int a[5];\n"
+              "    for (; i < 5; i++)\n"
+              "        a[i] = 1;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:10]: (error) Array 'a[5]' accessed at index -9, which is out of bounds. [negativeIndex]\n", errout_str());
+    }
+
+    // #11651
+    void array_index_negative8()
+    {
+        check("unsigned g(char*);\n"
+              "void f() {\n"
+              "    char buf[10];\n"
+              "    unsigned u = g(buf);\n"
+              "    for (int i = u, j = sizeof(i); --i >= 0;)\n"
+              "        char c = buf[i];\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // #8075
+    void array_index_negative9()
+    {
+        check("int g(int i) {\n"
+              "    if (i < 10)\n"
+              "        return -1;\n"
+              "    return 0;\n"
+              "}\n"
+              "void f() {\n"
+              "    int a[] = { 1, 2, 3 };\n"
+              "    printf(\"%d\\n\", a[g(4)]);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:8:21]: (error) Array 'a[3]' accessed at index -1, which is out of bounds. [negativeIndex]\n", errout_str());
+    }
+
+    // #11844
+    void array_index_negative10()
+    {
+        check("struct S { int a[4]; };\n"
+              "void f(S* p, int k) {\n"
+              "  int m = 3;\n"
+              "  if (k)\n"
+              "    m = 2;\n"
+              "  for (int j = m + 1; j <= 4; j++)\n"
+              "    p->a[j-1];\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_for_decr() {
@@ -1748,7 +2400,7 @@ class TestBufferOverrun : public TestFixture {
               "        data[i] = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'data[8]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:13]: (error) Array 'data[8]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -1757,7 +2409,7 @@ class TestBufferOverrun : public TestFixture {
               "        val[i+1] = val[i];\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -1766,8 +2418,8 @@ class TestBufferOverrun : public TestFixture {
               "        val[i+1] = val[i];\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'val[5]' accessed at index -9994, which is out of bounds.\n"
-                      "[test.cpp:5]: (error) Array 'val[5]' accessed at index -9995, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:12]: (error) Array 'val[5]' accessed at index -9994, which is out of bounds. [negativeIndex]\n"
+                      "[test.cpp:5:23]: (error) Array 'val[5]' accessed at index -9995, which is out of bounds. [negativeIndex]\n", errout_str());
     }
 
 
@@ -1782,46 +2434,77 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    A a;\n"
               "    a.data[3] = 0;\n"
+              "    a.b.data[2] = 0;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #1586
+        check("struct A {\n"
+              "    char data[4];\n"
+              "    struct B { char data[3]; };\n"
+              "    B b;\n"
+              "};\n"
+              "\n"
+              "void f()\n"
+              "{\n"
+              "    A a;\n"
+              "    a.data[4] = 0;\n"
+              "    a.b.data[3] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:11]: (error) Array 'a.data[4]' accessed at index 4, which is out of bounds. [arrayIndexOutOfBounds]\n"
+                      "[test.cpp:11:13]: (error) Array 'a.b.data[3]' accessed at index 3, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_for_andand_oror() {  // #3907 - using && or ||
+        // extracttests.start: volatile int y;
+
         check("void f() {\n"
               "    char data[2];\n"
               "    int x;\n"
               "    for (x = 0; x < 10 && y; x++) {\n"
               "        data[x] = 0;\n"
-              "    }"
+              "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'data[2]' accessed at index 9, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:13]: (error) Array 'data[2]' accessed at index 9, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "    char data[2];\n"
               "    int x;\n"
               "    for (x = 0; x < 10 || y; x++) {\n"
               "        data[x] = 0;\n"
-              "    }"
+              "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'data[2]' accessed at index 9, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:13]: (error) Array 'data[2]' accessed at index 9, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "    char data[2];\n"
               "    int x;\n"
               "    for (x = 0; x <= 10 && y; x++) {\n"
               "        data[x] = 0;\n"
-              "    }"
+              "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'data[2]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:13]: (error) Array 'data[2]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "    char data[2];\n"
               "    int x;\n"
               "    for (x = 0; y && x <= 10; x++) {\n"
               "        data[x] = 0;\n"
-              "    }"
+              "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'data[2]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:13]: (error) Array 'data[2]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+
+        check("int f() {\n" // #9126
+              "    int i, c;\n"
+              "    char* words[100] = {0};\n"
+              "    g(words);\n"
+              "    for (i = c = 0; (i < N) && (c < 1); i++) {\n"
+              "        if (words[i][0] == '|')\n"
+              "            c++;\n"
+              "     }\n"
+              "    return c;\n"
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_for_continue() {
@@ -1834,19 +2517,20 @@ class TestBufferOverrun : public TestFixture {
               "        }\n"
               "        a[i - 1] = 0;\n"
               "    }\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
+        // extracttests.start: int maybe();
         check("void f() {\n"
               "    int a[2];\n"
               "    for (int i = 0; i < 2; ++i) {\n"
-              "        if (somecondition) {\n"
+              "        if (maybe()) {\n"
               "            continue;\n"
               "        }\n"
               "        a[i - 1] = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Array 'a[2]' accessed at index -1, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:10]: (error) Array 'a[2]' accessed at index -1, which is out of bounds. [negativeIndex]\n", errout_str());
     }
 
     void array_index_for() {
@@ -1859,7 +2543,7 @@ class TestBufferOverrun : public TestFixture {
               "        a[i] = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Array 'a[10]' accessed at index 19, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:10]: (error) Array 'a[10]' accessed at index 19, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // Ticket #2385 - No false positive
         check("void f() {\n"
@@ -1871,16 +2555,40 @@ class TestBufferOverrun : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #3893 - start value out of bounds
+        // extracttests.start: int maybe(); int dostuff();
         check("void f() {\n"
               "    int a[10];\n"
-              "    for (int i = 10; somecondition; dosomething) {\n"
+              "    for (int i = 10; maybe(); dostuff()) {\n"
               "        a[i] = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'a[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:10]: (error) Array 'a[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+
+        // #7686
+        check("char f() {\n"
+              "    char buf[10];\n"
+              "    const bool a = true, b = true;\n"
+              "    for (int i = 0; i < (a && b ? 11 : 10); ++i)\n"
+              "        buf[i] = 0;\n"
+              "    return buf[0];\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:12]: (error) Array 'buf[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+
+        check("void f() {\n"
+              "    const int a[10] = {};\n"
+              "    for (int n = 0; 1; ++n) {\n"
+              "        if (a[n] < 1) {\n"
+              "            switch (a[n]) {\n"
+              "            case 0:\n"
+              "                break;\n"
+              "            }\n"
+              "        }\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:14]: (error) Array 'a[10]' accessed at index 9998, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_for_neq() {
@@ -1891,8 +2599,8 @@ class TestBufferOverrun : public TestFixture {
               "        a[i] = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'a[5]' accessed at index 9, which is out of bounds.\n",
-                      errout.str());
+        ASSERT_EQUALS("[test.cpp:4:10]: (error) Array 'a[5]' accessed at index 9, which is out of bounds. [arrayIndexOutOfBounds]\n",
+                      errout_str());
     }
 
     void array_index_for_question() {
@@ -1903,7 +2611,7 @@ class TestBufferOverrun : public TestFixture {
               "        i == 0 ? 0 : a[i-1];\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int a[10];\n"
@@ -1911,7 +2619,8 @@ class TestBufferOverrun : public TestFixture {
               "        some_condition ? 0 : a[i-1];\n"
               "    }\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Array index -1 is out of bounds.\n", "", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:31]: (error) Array 'a[10]' accessed at index -1, which is out of bounds. [negativeIndex]\n",
+                      errout_str());
 
         check("void f() {\n"
               "    int a[10];\n"
@@ -1920,7 +2629,7 @@ class TestBufferOverrun : public TestFixture {
               "        a[i-1] = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'a[10]' accessed at index -1, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10]: (error) Array 'a[10]' accessed at index -1, which is out of bounds. [negativeIndex]\n", errout_str());
     }
 
     void array_index_for_varid0() { // #4228: No varid for counter variable
@@ -1928,7 +2637,7 @@ class TestBufferOverrun : public TestFixture {
               "   char a[10];\n"
               "   for (i=0; i<10; i++);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_vla_for() {
@@ -1939,14 +2648,14 @@ class TestBufferOverrun : public TestFixture {
               "        a[0] = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_extern() {
         // Ticket #1684. FP when using 'extern'.
         check("extern char arr[15];\n"
               "char arr[15] = \"abc\";");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_cast() {
@@ -1960,7 +2669,7 @@ class TestBufferOverrun : public TestFixture {
               "    int x[2];\n"
               "    f1(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Same type => error
         check("void f1(const char buf[]) {\n"
@@ -1970,7 +2679,9 @@ class TestBufferOverrun : public TestFixture {
               "    char x[2];\n"
               "    f1(x);\n"
               "}");
-        // TODO CTU ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:2]: (error) Array 'x[2]' accessed at index 4, which is out of bounds.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:2]: (error) Array 'x[2]' accessed at index 4, which is out of bounds.\n",
+                           "",
+                           errout_str());
     }
 
     void array_index_string_literal() {
@@ -1978,41 +2689,50 @@ class TestBufferOverrun : public TestFixture {
               "    const char *str = \"abc\";\n"
               "    bar(str[10]);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Array 'str[4]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Array 'str[4]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "    const char *str = \"abc\";\n"
               "    bar(str[4]);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'str[4]' accessed at index 4, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:12]: (error) Array 'str[4]' accessed at index 4, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "    const char *str = \"abc\";\n"
               "    bar(str[3]);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
               "    const char *str = \"a\tc\";\n"
               "    bar(str[4]);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'str[4]' accessed at index 4, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:12]: (error) Array 'str[4]' accessed at index 4, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n" // #6973
               "    const char *name = \"\";\n"
               "    if ( name[0] == 'U' ? name[1] : 0) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int main(int argc, char **argv) {\n"
               "    char str[6] = \"\\0\";\n"
               "    unsigned short port = 65535;\n"
               "    snprintf(str, sizeof(str), \"%hu\", port);\n"
-              "}", settings0, "test.c");
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int x) {\n" // #11020
+              "    const char* p = (x == 0 ? \"12345\" : \"ABC\");\n"
+              "    int s = 0;\n"
+              "    for (int i = 0; p[i]; i++)\n"
+              "        s += p[i];\n"
+              "    return s;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_same_struct_and_var_name() {
@@ -2025,7 +2745,7 @@ class TestBufferOverrun : public TestFixture {
               "    struct tt *tt=x;\n"
               "    tt->name;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // detect error
         check("struct tt {\n"
@@ -2036,7 +2756,7 @@ class TestBufferOverrun : public TestFixture {
               "    struct tt *tt=x;\n"
               "    tt->name[22] = 123;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Array 'tt->name[21]' accessed at index 22, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:13]: (error) Array 'tt->name[21]' accessed at index 22, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void array_index_valueflow() {
@@ -2045,7 +2765,7 @@ class TestBufferOverrun : public TestFixture {
               "    str[i] = 0;\n"
               "    if (i==10) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:3]: (warning) Either the condition 'i==10' is redundant or the array 'str[3]' is accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:10] -> [test.cpp:3:8]: (warning) Either the condition 'i==10' is redundant or the array 'str[3]' is accessed at index 10, which is out of bounds. [arrayIndexOutOfBoundsCond]\n", errout_str());
 
         check("void f(int i) {\n"
               "    char str[3];\n"
@@ -2054,31 +2774,53 @@ class TestBufferOverrun : public TestFixture {
               "    case 10: break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:3]: (warning) Either the switch case 'case 10' is redundant or the array 'str[3]' is accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5] -> [test.cpp:3:8]: (warning) Either the switch case 'case 10' is redundant or the array 'str[3]' is accessed at index 10, which is out of bounds. [arrayIndexOutOfBoundsCond]\n", errout_str());
 
         check("void f() {\n"
               "    char str[3];\n"
               "    str[((unsigned char)3) - 1] = 0;\n"
-              "}", false, "test.cpp");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"  // #5416 FP
               "    char *str[3];\n"
               "    do_something(&str[0][5]);\n"
-              "}", false, "test.cpp");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("class X { static const int x[100]; };\n" // #6070
               "const int X::x[100] = {0};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("namespace { class X { static const int x[100]; };\n" // #6232
               "const int X::x[100] = {0}; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class ActorSprite { static ImageSet * targetCursorImages[2][10]; };\n"
-              "ImageSet *ActorSprite::targetCursorImages[2][10];\n");
-        ASSERT_EQUALS("", errout.str());
+              "ImageSet *ActorSprite::targetCursorImages[2][10];");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(const std::size_t s) {\n" // #10130
+              "    const char a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };\n"
+              "    return (s > sizeof(a)) ? 11 : (int)a[s];\n"
+              "}\n"
+              "int g() {\n"
+              "    return f(16);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:15] -> [test.cpp:3:41]: (warning) Either the condition 's>sizeof(a)' is redundant or the array 'a[16]' is accessed at index 16, which is out of bounds. [arrayIndexOutOfBoundsCond]\n",
+                      errout_str());
+
+        check("void f(int fd) {\n" // #12318
+              "    char buf[10];\n"
+              "    int size = 0;\n"
+              "    int pos = -1;\n"
+              "    do {\n"
+              "        pos++;\n"
+              "        size = read(fd, &buf[pos], 1);\n"
+              "    } while (size > 0);\n"
+              "    buf[pos] = '\\0';\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
 
     }
 
@@ -2088,7 +2830,7 @@ class TestBufferOverrun : public TestFixture {
               "  int *p = a;\n"
               "  p[20] = 0;\n"
               "}");
-        // TODO pointer ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (error) Array 'a[10]' accessed at index 20, which is out of bounds.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (error) Array 'a[10]' accessed at index 20, which is out of bounds.\n", "", errout_str());
 
         {
             // address of
@@ -2097,14 +2839,14 @@ class TestBufferOverrun : public TestFixture {
                   "  int *p = a;\n"
                   "  p[10] = 0;\n"
                   "}");
-            // TODO pointer ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (error) Array 'a[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+            TODO_ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4:6]: (error) Array 'a[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", "", errout_str());
 
             check("void f() {\n"
                   "  int a[10];\n"
                   "  int *p = a;\n"
                   "  dostuff(&p[10]);\n"
                   "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         check("void f() {\n"
@@ -2112,27 +2854,33 @@ class TestBufferOverrun : public TestFixture {
               "  int *p = a;\n"
               "  p[20] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  int a[2];\n"
               "  char *p = (char *)a;\n" // cast
               "  p[4] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_function_parameter() {
         check("void f(char a[10]) {\n"
               "  a[20] = 0;\n" // <- cppcheck warn here even though it's not a definite access out of bounds
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Array 'a[10]' accessed at index 20, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:4]: (error) Array 'a[10]' accessed at index 20, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f(char a[10]) {\n" // #6353 - reassign 'a'
               "  a += 4;\n"
               "  a[-1] = 0;\n"
               "}");
-        // TODO ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(char a[10]) {\n"
+              "  a[0] = 0;\n"
+              "  a[-1] = 0;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:4]: (error) Array 'a[10]' accessed at index -1, which is out of bounds. [negativeIndex]\n", errout_str());
     }
 
     void array_index_enum_array() { // #8439
@@ -2141,20 +2889,142 @@ class TestBufferOverrun : public TestFixture {
               "    E arrE[] = { e1, e2 };\n"
               "    arrE[sizeof(arrE)] = e1;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'arrE[2]' accessed at index 8, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Array 'arrE[2]' accessed at index 8, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
-    void buffer_overrun_2_struct() {
-        check("struct ABC\n"
+    void array_index_container() { // #9386
+        check("constexpr int blockLen = 10;\n"
+              "void foo(std::array<uint8_t, blockLen * 2>& a) {\n"
+              "    a[2] = 2;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void array_index_two_for_loops() {
+        check("bool b();\n"
+              "void f()\n"
               "{\n"
-              "    char str[5];\n"
-              "};\n"
+              "    int val[50];\n"
+              "    int i, sum=0;\n"
+              "    for (i = 1; b() && i < 50; i++)\n"
+              "        sum += val[i];\n"
+              "    if (i < 50)\n"
+              "        sum -= val[i];\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool b();\n"
+              "void f()\n"
+              "{\n"
+              "    int val[50];\n"
+              "    int i, sum=0;\n"
+              "    for (i = 1; b() && i < 50; i++)\n"
+              "        sum += val[i];\n"
+              "    for (; i < 50;) {\n"
+              "        sum -= val[i];\n"
+              "        break;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool b();\n"
+              "void f()\n"
+              "{\n"
+              "    int val[50];\n"
+              "    int i, sum=0;\n"
+              "    for (i = 1; b() && i < 50; i++)\n"
+              "        sum += val[i];\n"
+              "    for (; i < 50; i++)\n"
+              "        sum -= val[i];\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void array_index_new() { // #7690
+        check("void f() {\n"
+              "    int* z = new int;\n"
+              "    for (int n = 0; n < 8; ++n)\n"
+              "        z[n] = 0;\n"
+              "    delete[] z;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: (error) Array 'z[1]' accessed at index 7, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+
+        check("void f() {\n"
+              "    int* z = new int(1);\n"
+              "    for (int n = 0; n < 8; ++n)\n"
+              "        z[n] = 0;\n"
+              "    delete[] z;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: (error) Array 'z[1]' accessed at index 7, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+
+        check("void f() {\n"
+              "    int* z = new int{};\n"
+              "    for (int n = 0; n < 8; ++n)\n"
+              "        z[n] = 0;\n"
+              "    delete[] z;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: (error) Array 'z[1]' accessed at index 7, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+
+        check("void f() {\n"
+              "    int* z = new int[5];\n"
+              "    for (int n = 0; n < 8; ++n)\n"
+              "        z[n] = 0;\n"
+              "    delete[] z;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: (error) Array 'z[5]' accessed at index 7, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+
+        check("void g() {\n"
+              "    int* z = new int[5]();\n"
+              "    for (int n = 0; n < 8; ++n)\n"
+              "        z[n] = 1;\n"
+              "    delete[] z;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: (error) Array 'z[5]' accessed at index 7, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+
+        check("void h() {\n"
+              "    int** z = new int* [5];\n"
+              "    for (int n = 0; n < 8; ++n)\n"
+              "        z[n] = nullptr;\n"
+              "    delete[] z;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: (error) Array 'z[5]' accessed at index 7, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+
+        check("void h() {\n"
+              "    int** z = new int* [5]();\n"
+              "    for (int n = 0; n < 8; ++n)\n"
+              "        z[n] = nullptr;\n"
+              "    delete[] z;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: (error) Array 'z[5]' accessed at index 7, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+
+        check("void h() {\n"
+              "    int** z = new int* [5]{};\n"
+              "    for (int n = 0; n < 8; ++n)\n"
+              "        z[n] = nullptr;\n"
+              "    delete[] z;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: (error) Array 'z[5]' accessed at index 7, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+
+        check("void h() {\n"
+              "    int** z = new int* [5]{ 0 };\n"
+              "    for (int n = 0; n < 8; ++n)\n"
+              "        z[n] = nullptr;\n"
+              "    delete[] z;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: (error) Array 'z[5]' accessed at index 7, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+    }
+
+    void buffer_overrun_2_struct() {
+        check("struct ABC\n"
+              "{\n"
+              "    char str[5];\n"
+              "};\n"
               "\n"
               "static void f(struct ABC *abc)\n"
               "{\n"
               "    strcpy( abc->str, \"abcdef\" );\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Buffer is accessed out of bounds: abc->str\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:16]: (error) Buffer is accessed out of bounds: abc->str [bufferAccessOutOfBounds]\n", errout_str());
 
         check("struct ABC\n"
               "{\n"
@@ -2166,7 +3036,7 @@ class TestBufferOverrun : public TestFixture {
               "    struct ABC abc;\n"
               "    strcpy( abc.str, \"abcdef\" );\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:9]: (error) Buffer is accessed out of bounds: abc.str\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:16]: (error) Buffer is accessed out of bounds: abc.str [bufferAccessOutOfBounds]\n", errout_str());
 
         check("struct ABC\n"
               "{\n"
@@ -2177,7 +3047,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    strcpy( abc.str, \"abcdef\" );\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Buffer is accessed out of bounds: abc.str\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:16]: (error) Buffer is accessed out of bounds: abc.str [bufferAccessOutOfBounds]\n", errout_str());
 
         check("static void f()\n"
               "{\n"
@@ -2187,7 +3057,7 @@ class TestBufferOverrun : public TestFixture {
               "    } abc;\n"
               "    strcpy( abc.str, \"abcdef\" );\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Buffer is accessed out of bounds: abc.str\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:16]: (error) Buffer is accessed out of bounds: abc.str [bufferAccessOutOfBounds]\n", errout_str());
 
         check("static void f()\n"
               "{\n"
@@ -2199,7 +3069,7 @@ class TestBufferOverrun : public TestFixture {
               "    strcpy( abc->str, \"abcdef\" );\n"
               "    free(abc);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Buffer is accessed out of bounds: abc->str\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:16]: (error) Buffer is accessed out of bounds: abc->str [bufferAccessOutOfBounds]\n", errout_str());
     }
 
 
@@ -2212,7 +3082,11 @@ class TestBufferOverrun : public TestFixture {
               "    for (i = 0; i <= 10; ++i)\n"
               "        a[i] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Array 'a[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:10]: (error) Array 'a[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+
+        check("struct S { int b; } static e[1];\n" // #11052
+              "int f() { return e[1].b; }\n");
+        ASSERT_EQUALS("[test.cpp:2:19]: (error) Array 'e[1]' accessed at index 1, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
 
@@ -2223,7 +3097,7 @@ class TestBufferOverrun : public TestFixture {
               "    for (int i = 0; i < 8; ++i)\n"
               "        p[i] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'p[2]' accessed at index 7, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10]: (error) Array 'p[2]' accessed at index 7, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // No false positive
         check("void foo(int x, int y)\n"
@@ -2232,7 +3106,7 @@ class TestBufferOverrun : public TestFixture {
               "    const char *s = y + p[1];\n"
               "    p[1] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // There is no error here
         check("void f1(char *s,int size)\n"
@@ -2244,7 +3118,7 @@ class TestBufferOverrun : public TestFixture {
               "  char s[3];\n"
               "  f1(s,20);\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:3]: (error) Buffer is accessed out of bounds.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:3]: (error) Buffer is accessed out of bounds.\n", "", errout_str());
 
         check("void f1(char *s,int size)\n"
               "{\n"
@@ -2254,8 +3128,8 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "  char s[3];\n"
               "  f1(s,3);\n"
-              "}\n", false);
-        ASSERT_EQUALS("", errout.str());
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void buffer_overrun_5() {
@@ -2265,7 +3139,7 @@ class TestBufferOverrun : public TestFixture {
               "    sprintf(n, \"d\");\n"
               "    printf(\"hello!\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void buffer_overrun_6() {
@@ -2275,7 +3149,21 @@ class TestBufferOverrun : public TestFixture {
               "   strcat(n, \"abc\");\n"
               "   strcat(n, \"def\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Buffer is accessed out of bounds: n\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Buffer is accessed out of bounds: n\n", "", errout_str());
+
+        check("void f()\n" // #12489
+              "{\n"
+              "   char d[3] = {};\n"
+              "   strcat(d, \"12345678\");\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:11]: (error) Buffer is accessed out of bounds: d [bufferAccessOutOfBounds]\n", errout_str());
+
+        check("void f()\n"
+              "{\n"
+              "   char d[3] = \"ab\"; \n"
+              "   strcat(d, \"c\");\n"
+              "}");
+        TODO_ASSERT_EQUALS("[test.cpp:4:11]: (error) Buffer is accessed out of bounds: d [bufferAccessOutOfBounds]\n", "", errout_str());
     }
 
     void buffer_overrun_7() {
@@ -2285,7 +3173,7 @@ class TestBufferOverrun : public TestFixture {
               "    char a[2];\n"
               "    strcpy(a, \"a\\0\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void buffer_overrun_8() {
@@ -2298,7 +3186,7 @@ class TestBufferOverrun : public TestFixture {
               "        a[i] = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -2308,7 +3196,7 @@ class TestBufferOverrun : public TestFixture {
               "        a[i] = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void buffer_overrun_9() {
@@ -2322,7 +3210,7 @@ class TestBufferOverrun : public TestFixture {
               "        i += 100;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void buffer_overrun_10() {
@@ -2335,7 +3223,7 @@ class TestBufferOverrun : public TestFixture {
               "        char b = a[i];\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void buffer_overrun_11() {
@@ -2346,7 +3234,7 @@ class TestBufferOverrun : public TestFixture {
               "    {\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -2355,7 +3243,7 @@ class TestBufferOverrun : public TestFixture {
               "    {\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void buffer_overrun_15() { // ticket #1787
@@ -2367,7 +3255,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    strcpy(val, \"ab\") ;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Buffer is accessed out of bounds: val\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:12]: (error) Buffer is accessed out of bounds: val [bufferAccessOutOfBounds]\n", errout_str());
     }
 
     void buffer_overrun_16() {
@@ -2376,20 +3264,20 @@ class TestBufferOverrun : public TestFixture {
               "    struct Foo foo[5];\n"
               "    memset(foo, 0, sizeof(foo));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"  // ticket #2093
               "    gchar x[3];\n"
               "    strcpy(x, \"12\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("extern char a[10];\n"
               "void f() {\n"
               "    char b[25] = {0};\n"
               "    std::memcpy(b, a, 10);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void buffer_overrun_18() { // ticket #2576
@@ -2403,7 +3291,7 @@ class TestBufferOverrun : public TestFixture {
               "        b[i] = b[i+1];\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class A {\n"
               "    void foo();\n"
@@ -2415,7 +3303,7 @@ class TestBufferOverrun : public TestFixture {
               "        b[i] = b[i+1];\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Array 'b[7]' accessed at index 7, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:17]: (error) Array 'b[7]' accessed at index 7, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void buffer_overrun_19() { // #2597 - class member with unknown type
@@ -2428,7 +3316,7 @@ class TestBufferOverrun : public TestFixture {
               "A::A() {\n"
               "    memset(buf, 0, 10);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void buffer_overrun_21() {
@@ -2438,8 +3326,8 @@ class TestBufferOverrun : public TestFixture {
               "    const char *src = \"AAAAAAAAAAAAAAAAAAAAA\";\n"
               "    for (size_t i = 0; i <= 4; i++)\n"
               "        dst[i] = src[i];\n"
-              "} } }\n");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Array 'dst[4]' accessed at index 4, which is out of bounds.\n", errout.str());
+              "} } }");
+        ASSERT_EQUALS("[test.cpp:6:12]: (error) Array 'dst[4]' accessed at index 4, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void buffer_overrun_24() { // index variable is changed in for-loop
@@ -2451,7 +3339,7 @@ class TestBufferOverrun : public TestFixture {
               "      x += array[i];\n"
               "       i++;  }\n"
               "}");
-        TODO_ASSERT_EQUALS("error", "", errout.str());
+        TODO_ASSERT_EQUALS("error", "", errout_str());
 
         // ticket #4096
         check("void main() {\n"
@@ -2461,7 +3349,7 @@ class TestBufferOverrun : public TestFixture {
               "      x += array[i++];\n"
               "   }\n"
               "}");
-        TODO_ASSERT_EQUALS("error", "", errout.str());
+        TODO_ASSERT_EQUALS("error", "", errout_str());
     }
 
     void buffer_overrun_26() { // ticket #4432 (segmentation fault)
@@ -2472,7 +3360,7 @@ class TestBufferOverrun : public TestFixture {
               "    split(inbuf, f, 10, \"\t\t\");\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void buffer_overrun_27() { // ticket #4444 (segmentation fault)
@@ -2482,18 +3370,17 @@ class TestBufferOverrun : public TestFixture {
               "abc(x);\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // #7083: false positive: typedef and initialization with strings
     void buffer_overrun_29() {
-        check("typedef char testChar[10]; \n"
-              "int main(){ \n"
-              "  testChar tc1 = \"\"; \n"
-              "  tc1[5]='a'; \n"
-              "} \n"
-             );
-        ASSERT_EQUALS("", errout.str());
+        check("typedef char testChar[10];\n"
+              "int main(){\n"
+              "  testChar tc1 = \"\";\n"
+              "  tc1[5]='a';\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -2502,29 +3389,126 @@ class TestBufferOverrun : public TestFixture {
         check("struct S { int m[9]; };\n"
               "int f(S * s) {\n"
               "    return s->m[sizeof(s->m)];\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:3]: (error) Array 's->m[9]' accessed at index 36, which is out of bounds.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:16]: (error) Array 's->m[9]' accessed at index 36, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void buffer_overrun_31() {
         check("void f(WhereInfo *pWInfo, int *aiCur) {\n"
               "  memcpy(aiCur, pWInfo->aiCurOnePass, sizeof(int)*2);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void buffer_overrun_32() {
+        // destination size is too small
+        check("void f(void) {\n"
+              "    const char src[3] = \"abc\";\n"
+              "    char dest[1] = \"a\";\n"
+              "    (void)strxfrm(dest,src,1);\n"
+              "    (void)strxfrm(dest,src,2);\n"// <<
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:19]: (error) Buffer is accessed out of bounds: dest [bufferAccessOutOfBounds]\n", errout_str());
+        // destination size is too small
+        check("void f(void) {\n"
+              "    const char src[3] = \"abc\";\n"
+              "    char dest[2] = \"ab\";\n"
+              "    (void)strxfrm(dest,src,1);\n"
+              "    (void)strxfrm(dest,src,2);\n"
+              "    (void)strxfrm(dest,src,3);\n" // <<
+              "}");
+        ASSERT_EQUALS("[test.cpp:6:19]: (error) Buffer is accessed out of bounds: dest [bufferAccessOutOfBounds]\n", errout_str());
+        // source size is too small
+        check("void f(void) {\n"
+              "    const char src[2] = \"ab\";\n"
+              "    char dest[3] = \"abc\";\n"
+              "    (void)strxfrm(dest,src,1);\n"
+              "    (void)strxfrm(dest,src,2);\n"
+              "    (void)strxfrm(dest,src,3);\n" // <<
+              "}");
+        ASSERT_EQUALS("[test.cpp:6:24]: (error) Buffer is accessed out of bounds: src [bufferAccessOutOfBounds]\n", errout_str());
+        // source size is too small
+        check("void f(void) {\n"
+              "    const char src[1] = \"a\";\n"
+              "    char dest[3] = \"abc\";\n"
+              "    (void)strxfrm(dest,src,1);\n"
+              "    (void)strxfrm(dest,src,2);\n" // <<
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:24]: (error) Buffer is accessed out of bounds: src [bufferAccessOutOfBounds]\n", errout_str());
+    }
+
+    void buffer_overrun_33() { // #2019
+        check("int f() {\n"
+              "   int z[16];\n"
+              "   for (int i=0; i<20; i++)\n"
+              "      for (int j=0; j<20; j++)\n"
+              "          z[i] = 0;\n"
+              "   return z[0];\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:12]: (error) Array 'z[16]' accessed at index 19, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+    }
+
+    void buffer_overrun_34() { // #11035
+        check("struct S {\n"
+              "    std::vector<int> v;\n"
+              "    int a[15] = {};\n"
+              "    int g() const { return v.size(); }\n"
+              "    int f(int i) const {\n"
+              "        if (i < 0 || i >= g())\n"
+              "            return 0;\n"
+              "        return a[i];\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void buffer_overrun_35() { // #2304
+        check("void f() {\n"
+              "    char* q = \"0123456789\";\n"
+              "    char* p = (char*)malloc(sizeof(q) + 1);\n"
+              "    strcpy(p, q);\n"
+              "    free(p);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:12]: (error) Buffer is accessed out of bounds: p [bufferAccessOutOfBounds]\n", errout_str());
+
+        check("void f() {\n"
+              "    char* q = \"0123456789\";\n"
+              "    char* p = (char*)malloc(1);\n"
+              "    strcpy(p, q);\n"
+              "    free(p);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:12]: (error) Buffer is accessed out of bounds: p [bufferAccessOutOfBounds]\n", errout_str());
+
+        check("typedef struct { char buf[1]; } S;\n"
+              "S* f() {\n"
+              "    S* s = NULL;\n"
+              "    s = (S*)malloc(sizeof(S) + 10);\n"
+              "    sprintf((char*)s->buf, \"abc\");\n"
+              "    return s;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void buffer_overrun_36() { // #11708
+        check("void f(double d) {\n"
+              "    char a[80];\n"
+              "    sprintf(a, \"%2.1f\", d);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void buffer_overrun_errorpath() {
         setMultiline();
-        settings0.templateLocation = "{file}:{line}:note:{info}";
+        Settings s = settings0;
+        s.templateLocation = "{file}:{line}:note:{info}";
 
         check("void f() {\n"
               "    char *p = malloc(10);\n"
               "    memset(p, 0, 20);\n"
-              "}");
-        ASSERT_EQUALS("test.cpp:3:error:Buffer is accessed out of bounds: p\n"
-                      "test.cpp:2:note:Assign p, buffer with size 10\n"
-                      "test.cpp:3:note:Buffer overrun\n", errout.str());
+              "}", s);
+        ASSERT_EQUALS("[test.cpp:3:12]: error: Buffer is accessed out of bounds: p [bufferAccessOutOfBounds]\n"
+                      "[test.cpp:2:13]: note: Assign p, buffer with size 10\n"
+                      "[test.cpp:3:12]: note: Buffer overrun\n", errout_str());
     }
 
     void buffer_overrun_bailoutIfSwitch() {
@@ -2537,7 +3521,7 @@ class TestBufferOverrun : public TestFixture {
               "    char a[10];\n"
               "    f1(a);"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // No false positive
         check("void f1(char *s) {\n"
@@ -2549,7 +3533,7 @@ class TestBufferOverrun : public TestFixture {
               "    char a[10];\n"
               "    f1(a);"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // No false negative
         check("void f1(char *s) {\n"
@@ -2561,37 +3545,44 @@ class TestBufferOverrun : public TestFixture {
               "    char a[10];\n"
               "    f1(a);"
               "}");
-        ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:3]: (error) Array 'a[10]' accessed at index 100, which is out of bounds.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:3]: (error) Array 'a[10]' accessed at index 100, which is out of bounds.\n", "", errout_str());
     }
 
     void buffer_overrun_function_array_argument() {
+        setMultiline();
+
         check("void f(char a[10]);\n"
               "void g() {\n"
               "    char a[2];\n"
               "    f(a);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) The array 'a' is too small, the function 'f' expects a bigger one.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: warning: Buffer 'a' is too small, the function 'f' expects a bigger buffer in 1st argument [argumentSize]\n"
+                      "[test.cpp:4:5]: note: Function 'f' is called\n"
+                      "[test.cpp:1:13]: note: Declaration of 1st function argument.\n"
+                      "[test.cpp:3:10]: note: Passing buffer 'a' to function that is declared here\n"
+                      "[test.cpp:4:5]: note: Buffer 'a' is too small, the function 'f' expects a bigger buffer in 1st argument\n", errout_str());
 
-        check("void f(float a[10][20]);\n"
+        check("void f(float a[10][3]);\n"
               "void g() {\n"
               "    float a[2][3];\n"
               "    f(a);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) The array 'a' is too small, the function 'f' expects a bigger one.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: warning: Buffer 'a' is too small, the function 'f' expects a bigger buffer in 1st argument [argumentSize]\n"
+                      "[test.cpp:4:5]: note: Function 'f' is called\n"
+                      "[test.cpp:1:14]: note: Declaration of 1st function argument.\n"
+                      "[test.cpp:3:11]: note: Passing buffer 'a' to function that is declared here\n"
+                      "[test.cpp:4:5]: note: Buffer 'a' is too small, the function 'f' expects a bigger buffer in 1st argument\n", errout_str());
 
-        check("void f(char a[20]);\n"
+        check("void f(int a[20]);\n"
               "void g() {\n"
               "    int a[2];\n"
               "    f(a);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) The array 'a' is too small, the function 'f' expects a bigger one.\n", errout.str());
-
-        check("void f(char a[20]);\n"
-              "void g() {\n"
-              "    int a[5];\n"
-              "    f(a);\n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: warning: Buffer 'a' is too small, the function 'f' expects a bigger buffer in 1st argument [argumentSize]\n"
+                      "[test.cpp:4:5]: note: Function 'f' is called\n"
+                      "[test.cpp:1:12]: note: Declaration of 1st function argument.\n"
+                      "[test.cpp:3:9]: note: Passing buffer 'a' to function that is declared here\n"
+                      "[test.cpp:4:5]: note: Buffer 'a' is too small, the function 'f' expects a bigger buffer in 1st argument\n", errout_str());
 
         check("void f(int a[]) {\n"
               "  switch (2) {\n"
@@ -2602,121 +3593,186 @@ class TestBufferOverrun : public TestFixture {
               "int a[1];\n"
               "f(a);\n"
               "");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void CreateLeafTex(unsigned char buf[256][2048][4]);\n"
               "void foo() {\n"
               "  unsigned char(* tree)[2048][4] = new unsigned char[256][2048][4];\n"
               "  CreateLeafTex(tree);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
+        check("void f(int a[10]) {\n" // #10069
+              "    int i = 0;\n"
+              "    for (i = 0; i < 10; i++)\n"
+              "        a[i] = i * 2;\n"
+              "}\n"
+              "void g() {\n"
+              "    int b[5];\n"
+              "    f(b);\n"
+              "    return 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:8:5]: warning: Buffer 'b' is too small, the function 'f' expects a bigger buffer in 1st argument [argumentSize]\n"
+                      "[test.cpp:8:5]: note: Function 'f' is called\n"
+                      "[test.cpp:1:12]: note: Declaration of 1st function argument.\n"
+                      "[test.cpp:7:9]: note: Passing buffer 'b' to function that is declared here\n"
+                      "[test.cpp:8:5]: note: Buffer 'b' is too small, the function 'f' expects a bigger buffer in 1st argument\n",
+                      errout_str());
     }
 
     void possible_buffer_overrun_1() { // #3035
         check("void foo() {\n"
-              "    char * data = alloca(50);\n"
+              "    char * data = (char *)alloca(50);\n"
               "    char src[100];\n"
               "    memset(src, 'C', 99);\n"
               "    src[99] = '\\0';\n"
               "    strcat(data, src);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (warning) Possible buffer overflow if strlen(src) is larger than sizeof(data)-strlen(data).\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:6]: (warning) Possible buffer overflow if strlen(src) is larger than sizeof(data)-strlen(data).\n", "", errout_str());
 
         check("void foo() {\n"
-              "    char * data = alloca(100);\n"
+              "    char * data = (char *)alloca(100);\n"
               "    char src[100];\n"
               "    memset(src, 'C', 99);\n"
               "    src[99] = '\\0';\n"
               "    strcat(data, src);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(char src[100]) {\n"
-              "    char * data = alloca(50);\n"
+              "    char * data = (char *)alloca(50);\n"
               "    strcat(data, src);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Possible buffer overflow if strlen(src) is larger than sizeof(data)-strlen(data).\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3]: (warning) Possible buffer overflow if strlen(src) is larger than sizeof(data)-strlen(data).\n", "", errout_str());
 
         check("void foo(char src[100]) {\n"
-              "    char * data = alloca(100);\n"
+              "    char * data = (char *)alloca(100);\n"
               "    strcat(data, src);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
-              "    char * data = alloca(50);\n"
+              "    char * data = (char *)alloca(50);\n"
               "    char src[100];\n"
               "    memset(src, 'C', 99);\n"
               "    src[99] = '\\0';\n"
               "    strcpy(data, src);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (warning) Possible buffer overflow if strlen(src) is larger than or equal to sizeof(data).\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:6]: (warning) Possible buffer overflow if strlen(src) is larger than or equal to sizeof(data).\n", "", errout_str());
 
         check("void foo() {\n"
-              "    char * data = alloca(100);\n"
+              "    char * data = (char *)alloca(100);\n"
               "    char src[100];\n"
               "    memset(src, 'C', 99);\n"
               "    src[99] = '\\0';\n"
               "    strcpy(data, src);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(char src[100]) {\n"
-              "    char * data = alloca(50);\n"
+              "    char * data = (char *)alloca(50);\n"
               "    strcpy(data, src);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Possible buffer overflow if strlen(src) is larger than or equal to sizeof(data).\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3]: (warning) Possible buffer overflow if strlen(src) is larger than or equal to sizeof(data).\n", "", errout_str());
 
         check("void foo(char src[100]) {\n"
-              "    char * data = alloca(100);\n"
+              "    char * data = (char *)alloca(100);\n"
               "    strcpy(data, src);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void buffer_overrun_readSizeFromCfg() {
-        Settings settings;
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <podtype name=\"u8\" sign=\"u\" size=\"1\"/>\n"
-                               "  <function name=\"mystrcpy\">\n"
-                               "    <noreturn>false</noreturn>\n"
-                               "    <arg nr=\"1\">\n"
-                               "      <minsize type=\"strlen\" arg=\"2\"/>\n"
-                               "    </arg>\n"
-                               "    <arg nr=\"2\"/>\n"
-                               "  </function>\n"
-                               "</def>";
-        tinyxml2::XMLDocument doc;
-        doc.Parse(xmldata, sizeof(xmldata));
-        settings.library.load(doc);
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <podtype name=\"u8\" sign=\"u\" size=\"1\"/>\n"
+                                   "  <function name=\"mystrcpy\">\n"
+                                   "    <noreturn>false</noreturn>\n"
+                                   "    <arg nr=\"1\">\n"
+                                   "      <minsize type=\"strlen\" arg=\"2\"/>\n"
+                                   "    </arg>\n"
+                                   "    <arg nr=\"2\"/>\n"
+                                   "  </function>\n"
+                                   "</def>";
+        const Settings settings = settingsBuilder().libraryxml(xmldata).build();
 
         // Attempt to get size from Cfg files, no false positives if size is not specified
         check("void f() {\n"
               "  u8 str[256];\n"
               "  mystrcpy(str, \"abcd\");\n"
               "}", settings);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  u8 str[2];\n"
               "  mystrcpy(str, \"abcd\");\n"
               "}", settings);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds: str\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Buffer is accessed out of bounds: str [bufferAccessOutOfBounds]\n", errout_str());
 
         // The same for structs, where the message comes from a different check
         check("void f() {\n"
               "    struct { u8 str[256]; } ms;\n"
               "    mystrcpy(ms.str, \"abcd\");\n"
               "}", settings);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    struct { u8 str[2]; } ms;\n"
               "    mystrcpy(ms.str, \"abcd\");\n"
               "}", settings);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds: ms.str\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:16]: (error) Buffer is accessed out of bounds: ms.str [bufferAccessOutOfBounds]\n", errout_str());
+    }
+
+    void buffer_overrun_handle_addr_of_var() { // #7570
+        check("void f() {\n"
+              "  int i;\n"
+              "  memset(i, 0, 1000);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "  int i;\n"
+              "  memset(&i, 0, 1000);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:10]: (error) Buffer is accessed out of bounds: &i [bufferAccessOutOfBounds]\n", errout_str());
+
+        check("void f() {\n"
+              "  int i[2];\n"
+              "  memset(&i, 0, 1000);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:10]: (error) Buffer is accessed out of bounds: i [bufferAccessOutOfBounds]\n", errout_str());
+
+        check("void f() {\n"
+              "  int i;\n"
+              "  memset(&i, 0, sizeof(i));\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "  int i[10];\n"
+              "  memset(&i[1], 0, 1000);\n"
+              "}");
+        TODO_ASSERT_EQUALS("[test.cpp:3:10]: (error) Buffer is accessed out of bounds: &i[1] [bufferAccessOutOfBounds]\n", "", errout_str());
+
+        check("struct S { int x; };\n" // #8616
+              "void f() {\n"
+              "    S s;\n"
+              "    memset(&s, 0, sizeof(s) * 2);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:12]: (error) Buffer is accessed out of bounds: &s [bufferAccessOutOfBounds]\n", errout_str());
+
+        check("void f() {\n"
+              "    char x;\n"
+              "    memset(&x, 0, 16);\n"
+              "}\n"
+              "void g(char y) {\n"
+              "    char x;\n"
+              "    memcpy(&x, &y, 16);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Buffer is accessed out of bounds: &x [bufferAccessOutOfBounds]\n"
+                      "[test.cpp:7:12]: (error) Buffer is accessed out of bounds: &x [bufferAccessOutOfBounds]\n"
+                      "[test.cpp:7:16]: (error) Buffer is accessed out of bounds: &y [bufferAccessOutOfBounds]\n",
+                      errout_str());
     }
 
     void valueflow_string() { // using ValueFlow string values in checking
@@ -2725,41 +3781,50 @@ class TestBufferOverrun : public TestFixture {
               "  if (cond) x = \"abcde\";\n"
               "  return x[20];\n" // <- array index out of bounds when x is "abcde"
               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:4]: (error) Array 'x[6]' accessed at index 20, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:11]: (error) Array 'x[6]' accessed at index 20, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void pointer_out_of_bounds_1() {
+        // extracttests.start: void dostuff(char *);
+
         check("void f() {\n"
               "    char a[10];\n"
               "    char *p = a + 100;\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:3]: (portability) Undefined behaviour, pointer arithmetic 'a+100' is out of bounds.\n", errout.str());
+              "}", settings0_p);
+        ASSERT_EQUALS("[test.cpp:3:17]: (portability) Undefined behaviour, pointer arithmetic 'a+100' is out of bounds. [pointerOutOfBounds]\n", errout_str());
 
-        check("void f() {\n"
+        check("char *f() {\n"
               "    char a[10];\n"
               "    return a + 100;\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:3]: (portability) Undefined behaviour, pointer arithmetic 'a+100' is out of bounds.\n", errout.str());
+              "}", settings0_p);
+        ASSERT_EQUALS("[test.cpp:3:14]: (portability) Undefined behaviour, pointer arithmetic 'a+100' is out of bounds. [pointerOutOfBounds]\n", errout_str());
 
         check("void f(int i) {\n"
               "    char x[10];\n"
               "    if (i == 123) {}\n"
               "    dostuff(x+i);\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (portability) Undefined behaviour, when 'i' is 123 the pointer arithmetic 'x+i' is out of bounds.\n", errout.str());
+              "}", settings0_p);
+        ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:4:14]: (portability) Undefined behaviour, when 'i' is 123 the pointer arithmetic 'x+i' is out of bounds. [pointerOutOfBoundsCond]\n", errout_str());
+
+        check("void f(int i) {\n"
+              "    char x[10];\n"
+              "    if (i == -1) {}\n"
+              "    dostuff(x+i);\n"
+              "}", settings0_p);
+        ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:4:14]: (portability) Undefined behaviour, when 'i' is -1 the pointer arithmetic 'x+i' is out of bounds. [pointerOutOfBoundsCond]\n", errout_str());
 
         check("void f() {\n" // #6350 - fp when there is cast of buffer
               "  wchar_t buf[64];\n"
               "  p = (unsigned char *) buf + sizeof (buf);\n"
-              "}", false, "6350.c");
-        ASSERT_EQUALS("", errout.str());
+              "}", settings0_p, false);
+        ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "    const char   d[] = \"0123456789\";\n"
               "    char *cp = d + 3;\n"
               "    return cp - d;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}", settings0_p);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void pointer_out_of_bounds_2() {
@@ -2767,16 +3832,16 @@ class TestBufferOverrun : public TestFixture {
               "    char *p = malloc(10);\n"
               "    p += 100;\n"
               "    free(p);"
-              "}");
-        ASSERT_EQUALS("[test.cpp:3]: (portability) Undefined behaviour, pointer arithmetic 'p+100' is out of bounds.\n", errout.str());
+              "}", settings0_p);
+        TODO_ASSERT_EQUALS("[test.cpp:3]: (portability) Undefined behaviour, pointer arithmetic 'p+100' is out of bounds.\n", "", errout_str());
 
         check("void f() {\n"
               "    char *p = malloc(10);\n"
               "    p += 10;\n"
               "    *p = 0;\n"
               "    free(p);"
-              "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) p is out of bounds.\n", errout.str());
+              "}", settings0_p);
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) p is out of bounds.\n", "", errout_str());
 
         check("void f() {\n"
               "    char *p = malloc(10);\n"
@@ -2784,8 +3849,8 @@ class TestBufferOverrun : public TestFixture {
               "    p -= 10;\n"
               "    *p = 0;\n"
               "    free(p);"
-              "}");
-        ASSERT_EQUALS("", errout.str());
+              "}", settings0_p);
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char *p = malloc(10);\n"
@@ -2793,92 +3858,130 @@ class TestBufferOverrun : public TestFixture {
               "    p = p - 1;\n"
               "    *p = 0;\n"
               "    free(p);"
-              "}");
-        ASSERT_EQUALS("", errout.str());
+              "}", settings0_p);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void pointer_out_of_bounds_3() {
         check("struct S { int a[10]; };\n"
               "void f(struct S *s) {\n"
-              "    char *p = s->a + 100;\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:3]: (portability) Undefined behaviour, pointer arithmetic 's->a+100' is out of bounds.\n", errout.str());
+              "    int *p = s->a + 100;\n"
+              "}", settings0_p);
+        ASSERT_EQUALS("[test.cpp:3:19]: (portability) Undefined behaviour, pointer arithmetic 's->a+100' is out of bounds. [pointerOutOfBounds]\n", errout_str());
+
+        check("template <class T> class Vector\n"
+              "{\n"
+              "public:\n"
+              "    void test() const;\n"
+              "    T* data();\n"
+              "};\n"
+              "template <class T>\n"
+              "void Vector<T>::test() const\n"
+              "{\n"
+              "    const T* PDat = data();\n"
+              "    const T* P2 = PDat + 1;\n"
+              "    const T* P1 = P2 - 1;\n"
+              "}\n"
+              "Vector<std::array<long, 2>> Foo;\n", settings0_p);
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void pointer_out_of_bounds_4() {
+        check("const char* f() {\n"
+              "    g(\"Hello\" + 6);\n"
+              "}", settings0_p);
+        ASSERT_EQUALS("", errout_str());
+
+        check("const char* f() {\n"
+              "    g(\"Hello\" + 7);\n"
+              "}", settings0_p);
+        ASSERT_EQUALS("[test.cpp:2:15]: (portability) Undefined behaviour, pointer arithmetic '\"Hello\"+7' is out of bounds. [pointerOutOfBounds]\n", errout_str());
+
+        check("const char16_t* f() {\n"
+              "    g(u\"Hello\" + 6);\n"
+              "}", settings0_p);
+        ASSERT_EQUALS("", errout_str());
+
+        check("const char16_t* f() {\n"
+              "    g(u\"Hello\" + 7);\n"
+              "}", settings0_p);
+        ASSERT_EQUALS("[test.cpp:2:16]: (portability) Undefined behaviour, pointer arithmetic 'u\"Hello\"+7' is out of bounds. [pointerOutOfBounds]\n", errout_str());
+
+        check("void f() {\n" // #4647
+              "    int val = 5;\n"
+              "    std::string hi = \"hi\" + val;\n"
+              "    std::cout << hi << std::endl;\n"
+              "}\n", settings0_p);
+        ASSERT_EQUALS("[test.cpp:3:27]: (portability) Undefined behaviour, pointer arithmetic '\"hi\"+val' is out of bounds. [pointerOutOfBounds]\n", errout_str());
+
+        check("void f(const char* s, int len) {\n" // #11026
+              "    const char* end = s + len;\n"
+              "    printf(\"%s, %d\\n\", s, *end);\n"
+              "}\n"
+              "void g() {\n"
+              "    f(\"a\", 1);\n"
+              "    f(\"bbb\", 3);\n"
+              "}\n", settings0_p);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int i, const char* a) {\n" // #11140
+              "    (void)a[i];\n"
+              "}\n"
+              "void g() {\n"
+              "    for (int i = 0; \"01234\"[i]; ++i)\n"
+              "        f(i, \"56789\");\n"
+              "}\n"
+              "void h() {\n"
+              "    for (int i = 0; \"012\"[i]; ++i)\n"
+              "        f(i, \"345\");\n"
+              "}\n", settings0_p);
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void pointer_out_of_bounds_5() { // #10227
+        check("int foo(char str[6]) {\n"
+              "    return !((0 && *(\"STRING\" + 14) == 0) || memcmp(str, \"STRING\", 6) == 0);\n"
+              "}\n", settings0_p);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void pointer_out_of_bounds_sub() {
-        check("void f() {\n"
+        // extracttests.start: void dostuff(char *);
+
+        check("char *f() {\n"
               "    char x[10];\n"
               "    return x-1;\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:3]: (portability) Undefined behaviour, pointer arithmetic 'x-1' is out of bounds.\n", errout.str());
+              "}", settings0_p);
+        ASSERT_EQUALS("[test.cpp:3:13]: (portability) Undefined behaviour, pointer arithmetic 'x-1' is out of bounds. [pointerOutOfBounds]\n", errout_str());
 
         check("void f(int i) {\n"
               "    char x[10];\n"
               "    if (i == 123) {}\n"
               "    dostuff(x-i);\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:4]: (portability) Undefined behaviour, when 'i' is 123 the pointer arithmetic 'x-i' is out of bounds.\n", errout.str());
+              "}", settings0_p);
+        ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:4:14]: (portability) Undefined behaviour, when 'i' is 123 the pointer arithmetic 'x-i' is out of bounds. [pointerOutOfBoundsCond]\n", errout_str());
 
         check("void f(int i) {\n"
               "    char x[10];\n"
               "    if (i == -20) {}\n"
               "    dostuff(x-i);\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:4]: (portability) Undefined behaviour, when 'i' is -20 the pointer arithmetic 'x-i' is out of bounds.\n", errout.str());
-    }
+              "}", settings0_p);
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (portability) Undefined behaviour, when 'i' is -20 the pointer arithmetic 'x-i' is out of bounds.\n", "", errout_str());
 
-    void strncat1() {
-        check("void f(char *a, char *b) {\n"
-              "    char str[16];\n"
-              "    strncpy(str, a, 10);\n"
-              "    strncat(str, b, 10);\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Dangerous usage of strncat - 3rd parameter is the maximum number of characters to append.\n", errout.str());
+        check("void f(const char *x[10]) {\n"
+              "    return x-4;\n"
+              "}", settings0_p);
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void strncat2() {
-        check("void f(char *a) {\n"
-              "    char str[5];\n"
-              "    strncat(str, a, 5);\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Dangerous usage of strncat - 3rd parameter is the maximum number of characters to append.\n", errout.str());
-    }
-
-    void strncat3() {
-        check("void f(char *a) {\n"
-              "    char str[5];\n"
-              "    strncat(str, \"foobar\", 5);\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Dangerous usage of strncat - 3rd parameter is the maximum number of characters to append.\n", errout.str());
-    }
-
-
     void strcat1() {
         check("struct Foo { char a[4]; };\n"
               "void f() {\n"
-              "  struct Foo x;\n"
+              "  struct Foo x = {0};\n"
               "  strcat(x.a, \"aa\");\n"
               "  strcat(x.a, \"aa\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Buffer is accessed out of bounds.\n", errout.str());
-    }
-
-    void strcat2() {
-        check("struct Foo { char a[5]; };\n"
-              "void f() {\n"
-              "  struct Foo x;\n"
-              "  strcat(x.a, \"aa\");\n"
-              "  strcat(x.a, \"aa\");\n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
-    }
-
-    void strcat3() {
-        check("void f() {\n"
-              "  INT str[10];\n"
-              "  strcat(str, \"aa\");\n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Buffer is accessed out of bounds.\n", "", errout_str());
     }
 
     void varid1() {
@@ -2891,7 +3994,7 @@ class TestBufferOverrun : public TestFixture {
               "        str[30] = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varid2() { // #4764
@@ -2899,7 +4002,7 @@ class TestBufferOverrun : public TestFixture {
               "  void bar() { return; }\n"
               "  type<> member[1];\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void assign1() {
@@ -2909,7 +4012,7 @@ class TestBufferOverrun : public TestFixture {
               "{\n"
               "    str[3] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'str[3]' accessed at index 3, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:8]: (error) Array 'str[3]' accessed at index 3, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void alloc_new() {
@@ -2918,15 +4021,15 @@ class TestBufferOverrun : public TestFixture {
               "    char *s; s = new char[10];\n"
               "    s[10] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 's[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:6]: (error) Array 's[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // ticket #1670 - false negative when using return
         check("char f()\n"
               "{\n"
-              "    char *s; s = new int[10];\n"
+              "    int *s; s = new int[10];\n"
               "    return s[10];\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 's[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (error) Array 's[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("struct Fred { char c[10]; };\n"
               "char f()\n"
@@ -2934,12 +4037,12 @@ class TestBufferOverrun : public TestFixture {
               "    Fred *f; f = new Fred;\n"
               "    return f->c[10];\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'f->c[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:16]: (error) Array 'f->c[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("static const size_t MAX_SIZE = UNAVAILABLE_TO_CPPCHECK;\n"
               "struct Thing { char data[MAX_SIZE]; };\n"
               "char f4(const Thing& t) { return !t.data[0]; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "  char * buf; buf = new char[8];\n"
@@ -2949,7 +4052,7 @@ class TestBufferOverrun : public TestFixture {
               "  buf[8] = 0;\n"
               "  delete [] buf;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "  char * buf; buf = new char[8];\n"
@@ -2959,7 +4062,7 @@ class TestBufferOverrun : public TestFixture {
               "  buf[9] = 0;\n"
               "  delete [] buf;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Array 'buf[9]' accessed at index 9, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:6]: (error) Array 'buf[9]' accessed at index 9, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -2967,49 +4070,49 @@ class TestBufferOverrun : public TestFixture {
               "    char *s; s = new char[Size];\n"
               "    s[Size] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 's[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:6]: (error) Array 's[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void foo()\n"
               "{\n"
-              "    enum E { };\n"
+              "    enum E { ZERO };\n"
               "    E *e; e = new E[10];\n"
-              "    e[10] = 0;\n"
+              "    e[10] = ZERO;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'e[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:6]: (error) Array 'e[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     // data is allocated with malloc
     void alloc_malloc() {
         check("void foo()\n"
               "{\n"
-              "    char *s; s = malloc(10);\n"
+              "    char *s; s = (char *)malloc(10);\n"
               "    s[10] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 's[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:6]: (error) Array 's[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // ticket #842
         check("void f() {\n"
-              "    int *tab4 = malloc(20 * sizeof(int));\n"
+              "    int *tab4 = (int *)malloc(20 * sizeof(int));\n"
               "    tab4[20] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Array 'tab4[20]' accessed at index 20, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (error) Array 'tab4[20]' accessed at index 20, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // ticket #1478
         check("void foo() {\n"
-              "    char *p = malloc(10);\n"
+              "    char *p = (char *)malloc(10);\n"
               "    free(p);\n"
-              "    p = malloc(10);\n"
+              "    p = (char *)malloc(10);\n"
               "    p[10] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Array 'p[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:6]: (error) Array 'p[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         // ticket #1134
         check("void f() {\n"
               "    int *x, i;\n"
-              "    x = malloc(10 * sizeof(int));\n"
+              "    x = (int *)malloc(10 * sizeof(int));\n"
               "    x[10] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'x[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:6]: (error) Array 'x[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "  int *tab4; tab4 = malloc(20 * sizeof(int));\n"
@@ -3019,7 +4122,7 @@ class TestBufferOverrun : public TestFixture {
               "  tab4[20] = 0;\n"
               "  free(tab4);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  int *tab4 = malloc(20 * sizeof(int));\n"
@@ -3028,35 +4131,58 @@ class TestBufferOverrun : public TestFixture {
               "  tab4[20] = 0;\n"
               "  free(tab4);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    enum E { Size = 20 };\n"
-              "    E *tab4 = malloc(Size * 4);\n"
-              "    tab4[Size] = 0;\n"
+              "    E *tab4 = (E *)malloc(Size * 4);\n"
+              "    tab4[Size] = Size;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'tab4[20]' accessed at index 20, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Array 'tab4[20]' accessed at index 20, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "    enum E { Size = 20 };\n"
-              "    E *tab4 = malloc(4 * Size);\n"
-              "    tab4[Size] = 0;\n"
+              "    E *tab4 = (E *)malloc(4 * Size);\n"
+              "    tab4[Size] = Size;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'tab4[20]' accessed at index 20, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Array 'tab4[20]' accessed at index 20, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
-              "    enum E { };\n"
-              "    E *tab4 = malloc(20 * sizeof(E));\n"
-              "    tab4[20] = 0;\n"
+              "    enum E { ZERO };\n"
+              "    E *tab4 = (E *)malloc(20 * sizeof(E));\n"
+              "    tab4[20] = ZERO;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 'tab4[20]' accessed at index 20, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Array 'tab4[20]' accessed at index 20, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void f() {\n" // #8721
               "  unsigned char **cache = malloc(32);\n"
               "  cache[i] = malloc(65536);\n"
               "  cache[i][0xFFFF] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "  int **a = malloc(2 * sizeof(int*));\n"
+              "  for (int i = 0; i < 3; i++)\n"
+              "    a[i] = NULL;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:6]: (error) Array 'a[2]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+
+        check("void f() {\n"
+              "  int **a = new int*[2];\n"
+              "  for (int i = 0; i < 3; i++)\n"
+              "    a[i] = NULL;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:6]: (error) Array 'a[2]' accessed at index 2, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
+
+        check("void f(const uint8_t* a) {\n" // 10421
+              "    uint8_t* p = (uint8_t*)malloc(20U * sizeof(uint8_t));\n"
+              "    if (!p) return false;\n"
+              "    for (uint8_t i = 1; i < 30; ++i)\n"
+              "        p[i] = a[i];\n"
+              "    free(p);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:10]: (error) Array 'p[20]' accessed at index 29, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     // statically allocated buffer
@@ -3066,21 +4192,21 @@ class TestBufferOverrun : public TestFixture {
               "    const char *s = \"123\";\n"
               "    s[10] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 's[4]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:6]: (error) Array 's[4]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void foo()\n"
               "{\n"
               "    char *s; s = \"\";\n"
               "    s[10] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 's[1]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:6]: (error) Array 's[1]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
 
         check("void foo() {\n"
               "    const char *s = \"\";\n"
               "    s = y();\n"
               "    s[10] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n" // #7718
               "{\n"
@@ -3088,17 +4214,17 @@ class TestBufferOverrun : public TestFixture {
               "    s.resize(100);\n"
               "    s[10] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // data is allocated with alloca
     void alloc_alloca() {
         check("void foo()\n"
               "{\n"
-              "    char *s = alloca(10);\n"
+              "    char *s = (char *)alloca(10);\n"
               "    s[10] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Array 's[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4:6]: (error) Array 's[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", "", errout_str());
     }
     /*
         void countSprintfLength() const {
@@ -3171,36 +4297,37 @@ class TestBufferOverrun : public TestFixture {
             ASSERT_EQUALS(15, CheckBufferOverrun::countSprintfLength("str%s%d%d", multipleParams));
             ASSERT_EQUALS(26, CheckBufferOverrun::countSprintfLength("str%-6s%08ld%08ld", multipleParams));
         }
-    */
+     */
+
+    // extracttests.disable
+
     void minsize_argvalue() {
-        Settings settings;
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <function name=\"mymemset\">\n"
-                               "    <noreturn>false</noreturn>\n"
-                               "    <arg nr=\"1\">\n"
-                               "      <minsize type=\"argvalue\" arg=\"3\"/>\n"
-                               "    </arg>\n"
-                               "    <arg nr=\"2\"/>\n"
-                               "    <arg nr=\"3\"/>\n"
-                               "  </function>\n"
-                               "</def>";
-        tinyxml2::XMLDocument doc;
-        doc.Parse(xmldata, sizeof(xmldata));
-        settings.library.load(doc);
-        settings.addEnabled("warning");
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <function name=\"mymemset\">\n"
+                                   "    <noreturn>false</noreturn>\n"
+                                   "    <arg nr=\"1\">\n"
+                                   "      <minsize type=\"argvalue\" arg=\"3\"/>\n"
+                                   "    </arg>\n"
+                                   "    <arg nr=\"2\"/>\n"
+                                   "    <arg nr=\"3\"/>\n"
+                                   "  </function>\n"
+                                   "</def>";
+        // use a platform which has wchar_t with a sizeof 4
+        const Settings settings = settingsBuilder().libraryxml(xmldata).severity(Severity::warning).platform(Platform::Unix32).build();
+        ASSERT_EQUALS(4, settings.platform.sizeof_wchar_t);
 
         check("void f() {\n"
               "    char c[10];\n"
               "    mymemset(c, 0, 10);\n"
               "}", settings);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char c[10];\n"
               "    mymemset(c, 0, 11);\n"
               "}", settings);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds: c\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:14]: (error) Buffer is accessed out of bounds: c [bufferAccessOutOfBounds]\n", errout_str());
 
         check("struct S {\n"
               "    char a[5];\n"
@@ -3209,54 +4336,79 @@ class TestBufferOverrun : public TestFixture {
               "    S s;\n"
               "    mymemset(s.a, 0, 10);\n"
               "}", settings);
-        ASSERT_EQUALS("[test.cpp:6]: (error) Buffer is accessed out of bounds: s.a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:15]: (error) Buffer is accessed out of bounds: s.a [bufferAccessOutOfBounds]\n", errout_str());
 
         check("void foo() {\n"
               "    char s[10];\n"
               "    mymemset(s, 0, '*');\n"
               "}", settings);
-        // TODO ASSERT_EQUALS("[test.cpp:3]: (warning) The size argument is given as a char constant.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3]: (warning) The size argument is given as a char constant.\n"
+                           "[test.cpp:3:14]: (error) Buffer is accessed out of bounds: s [bufferAccessOutOfBounds]\n", "[test.cpp:3:14]: (error) Buffer is accessed out of bounds: s [bufferAccessOutOfBounds]\n", errout_str());
 
         // ticket #836
         check("void f(void) {\n"
               "  char a[10];\n"
               "  mymemset(a+5, 0, 10);\n"
               "}", settings);
-        TODO_ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds: a\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3:13]: (error) Buffer is accessed out of bounds: a [bufferAccessOutOfBounds]\n", "", errout_str());
 
         // Ticket #909
         check("void f(void) {\n"
               "    char str[] = \"abcd\";\n"
-              "    mymemset(str, 0, 10);\n"
+              "    mymemset(str, 0, 6);\n"
+              "}", settings);
+        ASSERT_EQUALS("[test.cpp:3:14]: (error) Buffer is accessed out of bounds: str [bufferAccessOutOfBounds]\n", errout_str());
+
+        check("void f(void) {\n"
+              "    char str[] = \"abcd\";\n"
+              "    mymemset(str, 0, 5);\n"
+              "}", settings);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(void) {\n"
+              "    wchar_t str[] = L\"abcd\";\n"
+              "    mymemset(str, 0, 21);\n"
+              "}", settings);
+        ASSERT_EQUALS("[test.cpp:3:14]: (error) Buffer is accessed out of bounds: str [bufferAccessOutOfBounds]\n", errout_str());
+
+        check("void f(void) {\n"
+              "    wchar_t str[] = L\"abcd\";\n"
+              "    mymemset(str, 0, 20);\n"
               "}", settings);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds: str\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ticket #1659 - overflowing variable when using memcpy
-        check("void f(void) { \n"
+        check("void f(void) {\n"
               "  char c;\n"
               "  mymemset(&c, 0, 4);\n"
               "}", settings);
-        TODO_ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds: c\n", "", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Buffer is accessed out of bounds: &c [bufferAccessOutOfBounds]\n", errout_str());
 
         // ticket #2121 - buffer access out of bounds when using uint32_t
         check("void f(void) {\n"
               "    unknown_type_t buf[4];\n"
               "    mymemset(buf, 0, 100);\n"
               "}", settings);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        // #3124 - multidimension array
+        // #3124 - multidimensional array
         check("int main() {\n"
               "    char b[5][6];\n"
               "    mymemset(b, 0, 5 * 6);\n"
               "}", settings);
-        // TODO ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int main() {\n"
               "    char b[5][6];\n"
               "    mymemset(b, 0, 6 * 6);\n"
               "}", settings);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds: b\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:14]: (error) Buffer is accessed out of bounds: b [bufferAccessOutOfBounds]\n", errout_str());
+
+        check("int main() {\n"
+              "    char b[5][6];\n"
+              "    mymemset(b, 0, 31);\n"
+              "}", settings);
+        ASSERT_EQUALS("[test.cpp:3:14]: (error) Buffer is accessed out of bounds: b [bufferAccessOutOfBounds]\n", errout_str());
 
         // #4968 - not standard function
         check("void f() {\n"
@@ -3265,113 +4417,116 @@ class TestBufferOverrun : public TestFixture {
               "    foo::mymemset(str, 0, 100);\n"
               "    std::mymemset(str, 0, 100);\n"
               "}", settings);
-        TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Buffer is accessed out of bounds: str\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5:15]: (error) Buffer is accessed out of bounds: str [bufferAccessOutOfBounds]\n", "", errout_str());
 
         // #5257 - check strings
         check("void f() {\n"
               "  mymemset(\"abc\", 0, 20);\n"
               "}", settings);
-        // TODO ASSERT_EQUALS("[test.cpp:2]: (error) Buffer is accessed out of bounds.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:2]: (error) Buffer is accessed out of bounds.\n",
+                           "",
+                           errout_str());
 
         check("void f() {\n"
               "  mymemset(temp, \"abc\", 4);\n"
               "}", settings);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n" // #6816 - fp when array has known string value
               "    char c[10] = \"c\";\n"
               "    mymemset(c, 0, 10);\n"
               "}", settings);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void minsize_sizeof() {
-        Settings settings;
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <function name=\"mystrncpy\">\n"
-                               "    <noreturn>false</noreturn>\n"
-                               "    <arg nr=\"1\">\n"
-                               "      <minsize type=\"strlen\" arg=\"2\"/>\n"
-                               "      <minsize type=\"argvalue\" arg=\"3\"/>\n"
-                               "    </arg>\n"
-                               "    <arg nr=\"2\"/>\n"
-                               "    <arg nr=\"3\"/>\n"
-                               "  </function>\n"
-                               "</def>";
-        tinyxml2::XMLDocument doc;
-        doc.Parse(xmldata, sizeof(xmldata));
-        settings.library.load(doc);
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <function name=\"mystrncpy\">\n"
+                                   "    <noreturn>false</noreturn>\n"
+                                   "    <arg nr=\"1\">\n"
+                                   "      <minsize type=\"strlen\" arg=\"2\"/>\n"
+                                   "      <minsize type=\"argvalue\" arg=\"3\"/>\n"
+                                   "    </arg>\n"
+                                   "    <arg nr=\"2\"/>\n"
+                                   "    <arg nr=\"3\"/>\n"
+                                   "  </function>\n"
+                                   "</def>";
+        const Settings settings = settingsBuilder().libraryxml(xmldata).build();
 
         check("void f() {\n"
               "    char c[7];\n"
               "    mystrncpy(c, \"hello\", 7);\n"
               "}", settings);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               " char c[6];\n"
               " mystrncpy(c,\"hello\",6);\n"
               "}", settings);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               " char c[5];\n"
               " mystrncpy(c,\"hello\",6);\n"
               "}", settings);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds: c\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Buffer is accessed out of bounds: c [bufferAccessOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "    char c[6];\n"
               "    mystrncpy(c,\"hello!\",7);\n"
               "}", settings);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds: c\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:15]: (error) Buffer is accessed out of bounds: c [bufferAccessOutOfBounds]\n", errout_str());
+
+        check("void f(unsigned int addr) {\n"
+              "    memset((void *)addr, 0, 1000);\n"
+              "}", settings0); // TODO: use settings?
+        ASSERT_EQUALS("", errout_str());
 
         check("struct AB { char a[10]; };\n"
               "void foo(AB *ab) {\n"
               "    mystrncpy(x, ab->a, 100);\n"
               "}", settings);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void a(char *p) { mystrncpy(p,\"hello world!\",10); }\n" // #3168
               "void b() {\n"
               "    char buf[5];\n"
               "    a(buf);"
               "}", settings);
-        // TODO CTU ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:1]: (error) Buffer is accessed out of bounds: buf\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:1]: (error) Buffer is accessed out of bounds: buf\n",
+                           "",
+                           errout_str());
     }
 
     void minsize_strlen() {
-        Settings settings;
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <function name=\"mysprintf\">\n"
-                               "    <noreturn>false</noreturn>\n"
-                               "    <formatstr/>\n"
-                               "    <arg nr=\"1\">\n"
-                               "      <minsize type=\"strlen\" arg=\"2\"/>\n"
-                               "    </arg>\n"
-                               "    <arg nr=\"2\">\n"
-                               "      <formatstr/>\n"
-                               "    </arg>\n"
-                               "  </function>\n"
-                               "</def>";
-        tinyxml2::XMLDocument doc;
-        doc.Parse(xmldata, sizeof(xmldata));
-        settings.library.load(doc);
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <function name=\"mysprintf\">\n"
+                                   "    <noreturn>false</noreturn>\n"
+                                   "    <formatstr/>\n"
+                                   "    <arg nr=\"1\">\n"
+                                   "      <minsize type=\"strlen\" arg=\"2\"/>\n"
+                                   "    </arg>\n"
+                                   "    <arg nr=\"2\">\n"
+                                   "      <formatstr/>\n"
+                                   "    </arg>\n"
+                                   "  </function>\n"
+                                   "</def>";
+        const Settings settings = settingsBuilder().libraryxml(xmldata).build();
 
         // formatstr..
         check("void f() {\n"
               "    char str[3];\n"
               "    mysprintf(str, \"test\");\n"
               "}", settings);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds: str\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:15]: (error) Buffer is accessed out of bounds: str [bufferAccessOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "    char str[5];\n"
               "    mysprintf(str, \"%s\", \"abcde\");\n"
               "}", settings);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds: str\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:15]: (error) Buffer is accessed out of bounds: str [bufferAccessOutOfBounds]\n", errout_str());
 
         check("int getnumber();\n"
               "void f()\n"
@@ -3379,66 +4534,73 @@ class TestBufferOverrun : public TestFixture {
               "    char str[5];\n"
               "    mysprintf(str, \"%d: %s\", getnumber(), \"abcde\");\n"
               "}", settings);
-        ASSERT_EQUALS("[test.cpp:5]: (error) Buffer is accessed out of bounds: str\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:15]: (error) Buffer is accessed out of bounds: str [bufferAccessOutOfBounds]\n", errout_str());
 
         check("void f() {\n"
               "    char str[5];\n"
               "    mysprintf(str, \"test%s\", \"\");\n"
               "}", settings);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char *str = new char[5];\n"
               "    mysprintf(str, \"abcde\");\n"
               "}", settings);
-        // TODO ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:15]: (error) Buffer is accessed out of bounds: str [bufferAccessOutOfBounds]\n", errout_str());
 
         check("void f(int condition) {\n"
               "    char str[5];\n"
               "    mysprintf(str, \"test%s\", condition ? \"12\" : \"34\");\n"
               "}", settings);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int condition) {\n"
               "    char str[5];\n"
               "    mysprintf(str, \"test%s\", condition ? \"12\" : \"345\");\n"
               "}", settings);
-        TODO_ASSERT_EQUALS("error", "", errout.str());
+        TODO_ASSERT_EQUALS("error", "", errout_str());
 
         check("struct Foo { char a[1]; };\n"
               "void f() {\n"
               "  struct Foo x;\n"
               "  mysprintf(x.a, \"aa\");\n"
               "}", settings);
-        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer is accessed out of bounds: x.a\n", "", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:14]: (error) Buffer is accessed out of bounds: x.a [bufferAccessOutOfBounds]\n", errout_str());
 
         // ticket #900
         check("void f() {\n"
               "  char *a = new char(30);\n"
               "  mysprintf(a, \"a\");\n"
               "}", settings);
-        // TODO ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:13]: (error) Buffer is accessed out of bounds: a [bufferAccessOutOfBounds]\n", errout_str());
 
         check("void f(char value) {\n"
               "  char *a = new char(value);\n"
               "  mysprintf(a, \"a\");\n"
               "}", settings);
-        // TODO ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:13]: (error) Buffer is accessed out of bounds: a [bufferAccessOutOfBounds]\n", errout_str());
 
         // This is out of bounds if 'sizeof(ABC)' is 1 (No padding)
         check("struct Foo { char a[1]; };\n"
               "void f() {\n"
               "  struct Foo *x = malloc(sizeof(Foo));\n"
-              "  mysprintf(x.a, \"aa\");\n"
+              "  mysprintf(x->a, \"aa\");\n"
               "}", settings);
-        // TODO ASSERT_EQUALS("", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error, inconclusive) Buffer is accessed out of bounds: x.a\n", "", errout_str());
 
         check("struct Foo { char a[1]; };\n"
               "void f() {\n"
               "  struct Foo *x = malloc(sizeof(Foo) + 10);\n"
+              "  mysprintf(x->a, \"aa\");\n"
+              "}", settings);
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct Foo { char a[1]; };\n"
+              "void f() {\n"
+              "  struct Foo x;\n"
               "  mysprintf(x.a, \"aa\");\n"
               "}", settings);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:14]: (error) Buffer is accessed out of bounds: x.a [bufferAccessOutOfBounds]\n", errout_str());
 
         check("struct Foo {\n" // #6668 - unknown size
               "  char a[LEN];\n"
@@ -3447,47 +4609,46 @@ class TestBufferOverrun : public TestFixture {
               "void Foo::f() {\n"
               "  mysprintf(a, \"abcd\");\n"
               "}", settings);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void minsize_mul() {
-        Settings settings;
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <function name=\"myfread\">\n"
-                               "    <arg nr=\"1\">\n"
-                               "      <minsize type=\"mul\" arg=\"2\" arg2=\"3\"/>\n"
-                               "    </arg>\n"
-                               "    <arg nr=\"2\"/>\n"
-                               "    <arg nr=\"3\"/>\n"
-                               "    <arg nr=\"4\"/>\n"
-                               "  </function>\n"
-                               "</def>";
-        tinyxml2::XMLDocument doc;
-        doc.Parse(xmldata, sizeof(xmldata));
-        settings.library.load(doc);
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <function name=\"myfread\">\n"
+                                   "    <arg nr=\"1\">\n"
+                                   "      <minsize type=\"mul\" arg=\"2\" arg2=\"3\"/>\n"
+                                   "    </arg>\n"
+                                   "    <arg nr=\"2\"/>\n"
+                                   "    <arg nr=\"3\"/>\n"
+                                   "    <arg nr=\"4\"/>\n"
+                                   "  </function>\n"
+                                   "</def>";
+        const Settings settings = settingsBuilder().libraryxml(xmldata).build();
 
         check("void f() {\n"
               "    char c[5];\n"
               "    myfread(c, 1, 5, stdin);\n"
               "}", settings);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char c[5];\n"
               "    myfread(c, 1, 6, stdin);\n"
               "}", settings);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds: c\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:13]: (error) Buffer is accessed out of bounds: c [bufferAccessOutOfBounds]\n", errout_str());
     }
 
+    // extracttests.enable
+
     void unknownType() {
         check("void f()\n"
               "{\n"
               " UnknownType *a = malloc(4);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
-
+    // extracttests.disable
     void terminateStrncpy1() {
         check("void foo ( char *bar ) {\n"
               "    char baz[100];\n"
@@ -3497,26 +4658,26 @@ class TestBufferOverrun : public TestFixture {
               "    strncpy(baz, bar, 100);\n"
               "    baz[99] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo ( char *bar ) {\n"
               "    char baz[100];\n"
               "    strncpy(baz, bar, 100);\n"
               "    baz[99] = '\\0';\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo ( char *bar ) {\n"
               "    char baz[100];\n"
               "    strncpy(baz, bar, 100);\n"
               "    baz[x+1] = '\\0';\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Test with invalid code that there is no segfault
         check("char baz[100];\n"
-              "strncpy(baz, \"var\", 100)\n");
-        ASSERT_EQUALS("", errout.str());
+              "strncpy(baz, \"var\", 100)");
+        ASSERT_EQUALS("", errout_str());
 
         // Test that there are no duplicate error messages
         check("void foo ( char *bar ) {\n"
@@ -3525,7 +4686,7 @@ class TestBufferOverrun : public TestFixture {
               "    foo(baz);\n"
               "    foo(baz);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) The buffer 'baz' may not be null-terminated after the call to strncpy().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning, inconclusive) The buffer 'baz' may not be null-terminated after the call to strncpy(). [terminateStrncpy]\n", errout_str());
     }
 
     void terminateStrncpy2() {
@@ -3533,9 +4694,9 @@ class TestBufferOverrun : public TestFixture {
               "    char baz[100];\n"
               "    strncpy(baz, bar, 100);\n"
               "    bar[99] = 0;\n"
-              "    return baz;\n"
+              "    return strdup(baz);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) The buffer 'baz' may not be null-terminated after the call to strncpy().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning, inconclusive) The buffer 'baz' may not be null-terminated after the call to strncpy(). [terminateStrncpy]\n", errout_str());
     }
 
     void terminateStrncpy3() {
@@ -3549,22 +4710,54 @@ class TestBufferOverrun : public TestFixture {
               "\n"
               "void bar(char *p) {\n"
               "    strncpy(p, str, 100);\n"
-              "}\n", false);
-        ASSERT_EQUALS("[test.cpp:4]: (warning, inconclusive) The buffer 'str' may not be null-terminated after the call to strncpy().\n", errout.str());
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning, inconclusive) The buffer 'str' may not be null-terminated after the call to strncpy(). [terminateStrncpy]\n", errout_str());
     }
 
     void terminateStrncpy4() {
         check("void bar() {\n"
               "    char buf[4];\n"
               "    strncpy(buf, \"ab\", 4);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void bar() {\n"
               "    char buf[4];\n"
               "    strncpy(buf, \"abcde\", 4);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning, inconclusive) The buffer 'buf' may not be null-terminated after the call to strncpy(). [terminateStrncpy]\n", errout_str());
+    }
+
+    void terminateStrncpy5() { // #9944
+        check("void f(const std::string& buf) {\n"
+              "    char v[255];\n"
+              "    if (buf.size() >= sizeof(v))\n"
+              "        return;\n"
+              "    strncpy(v, buf.c_str(), sizeof(v));\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) The buffer 'buf' may not be null-terminated after the call to strncpy().\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const std::string& buf) {\n"
+              "    char v[255];\n"
+              "    if (buf.size() >= sizeof(v))\n"
+              "        strncpy(v, buf.c_str(), sizeof(v));\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:9]: (warning, inconclusive) The buffer 'v' may not be null-terminated after the call to strncpy(). [terminateStrncpy]\n", errout_str());
+    }
+    // extracttests.enable
+
+    void terminateStrncpy_handle_addr_of_var() { // #7570
+        check("void foo() {\n"
+              "  char c[6];\n"
+              "  strncpy(&c, \"hello!\", 6);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:3]: (warning, inconclusive) The buffer 'c' may not be null-terminated after the call to strncpy(). [terminateStrncpy]\n", errout_str());
+
+        check("void foo() {\n"
+              "  char c[6];\n"
+              "  strncpy(&c, \"hello\\0\", 6);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void recursive_long_time() {
@@ -3592,7 +4785,7 @@ class TestBufferOverrun : public TestFixture {
               "    char a[10];\n"
               "    f2(a);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -3608,7 +4801,7 @@ class TestBufferOverrun : public TestFixture {
               "    struct A *str;\n"
               "    str = malloc(4);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void crash2() {
@@ -3651,8 +4844,8 @@ class TestBufferOverrun : public TestFixture {
 
     void crash6() {
         check("void start(char* name) {\n"
-              "char snapname[64] = { 0 }; \n"
-              "strncpy(snapname, \"snapshot\", arrayLength(snapname)); \n"
+              "char snapname[64] = { 0 };\n"
+              "strncpy(snapname, \"snapshot\", arrayLength(snapname));\n"
               "}");
     }
 
@@ -3673,7 +4866,7 @@ class TestBufferOverrun : public TestFixture {
               "    }\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Buffer overrun possible for long command line arguments.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:7]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, char *argv[])\n"
               "{\n"
@@ -3686,112 +4879,112 @@ class TestBufferOverrun : public TestFixture {
               "    }\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Buffer overrun possible for long command line arguments.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:7]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(const int argc, char* argv[])\n"
               "{\n"
               "    char prog[10];\n"
               "    strcpy(prog, argv[0]);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, const char* argv[])\n"
               "{\n"
               "    char prog[10];\n"
               "    strcpy(prog, argv[0]);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(const int argc, const char* argv[])\n"
               "{\n"
               "    char prog[10];\n"
               "    strcpy(prog, argv[0]);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, char* argv[])\n"
               "{\n"
               "    char prog[10] = {'\\0'};\n"
               "    strcat(prog, argv[0]);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, char **argv, char **envp)\n"
               "{\n"
               "    char prog[10];\n"
               "    strcpy(prog, argv[0]);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, const char *const *const argv, char **envp)\n"
               "{\n"
               "    char prog[10];\n"
               "    strcpy(prog, argv[0]);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(const int argc, const char *const *const argv, const char *const *const envp)\n"
               "{\n"
               "    char prog[10];\n"
               "    strcpy(prog, argv[0]);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, char **argv, char **envp)\n"
               "{\n"
               "    char prog[10] = {'\\0'};\n"
               "    strcat(prog, argv[0]);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(const int argc, const char **argv, char **envp)\n"
               "{\n"
               "    char prog[10] = {'\\0'};\n"
               "    strcat(prog, argv[0]);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, const char **argv, char **envp)\n"
               "{\n"
               "    char prog[10] = {'\\0'};\n"
               "    strcat(prog, argv[0]);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(const int argc, char **argv, char **envp)\n"
               "{\n"
               "    char prog[10] = {'\\0'};\n"
               "    strcat(prog, argv[0]);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, char **options)\n"
               "{\n"
               "    char prog[10];\n"
               "    strcpy(prog, options[0]);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, char **options)\n"
               "{\n"
               "    char prog[10] = {'\\0'};\n"
               "    strcat(prog, options[0]);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, char **options)\n"
               "{\n"
               "    char prog[10];\n"
               "    strcpy(prog, *options);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, char **options)\n"
               "{\n"
               "    char prog[10];\n"
               "    strcpy(prog+3, *options);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         check("int main(int argc, char **argv, char **envp)\n"
               "{\n"
@@ -3799,7 +4992,7 @@ class TestBufferOverrun : public TestFixture {
               "    if (strlen(argv[0]) < 10)\n"
               "        strcpy(prog, argv[0]);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int main(int argc, char **argv, char **envp)\n"
               "{\n"
@@ -3807,7 +5000,7 @@ class TestBufferOverrun : public TestFixture {
               "    if (10 > strlen(argv[0]))\n"
               "        strcat(prog, argv[0]);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int main(int argc, char **argv, char **envp)\n"
               "{\n"
@@ -3815,7 +5008,7 @@ class TestBufferOverrun : public TestFixture {
               "    argv[0][0] = '\\0';\n"
               "    strcpy(prog, argv[0]);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #5835
         check("int main(int argc, char* argv[]) {\n"
@@ -3823,18 +5016,18 @@ class TestBufferOverrun : public TestFixture {
               "    strcpy(prog, argv[0]);\n"
               "    strcpy(prog, argv[0]);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Buffer overrun possible for long command line arguments.\n"
-                      "[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3]: (error) Buffer overrun possible for long command line arguments.\n"
+                           "[test.cpp:4]: (error) Buffer overrun possible for long command line arguments.\n", "", errout_str());
 
         // #7964
         check("int main(int argc, char *argv[]) {\n"
               "  char *strcpy();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("int main(int argc, char *argv[]) {\n"
               "  char *strcat();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void checkBufferAllocatedWithStrlen() {
@@ -3842,158 +5035,185 @@ class TestBufferOverrun : public TestFixture {
               "  char *b = new char[strlen(a)];\n"
               "  strcpy(b, a);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds.\n", "", errout_str());
 
         check("void f(char *a) {\n"
               "  char *b = new char[strlen(a) + 1];\n"
               "  strcpy(b, a);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(char *a) {\n"
               "  char *b = new char[strlen(a)];\n"
               "  a[0] = '\\0';\n"
               "  strcpy(b, a);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(char *a) {\n"
-              "  char *b = malloc(strlen(a));\n"
+              "  char *b = (char *)malloc(strlen(a));\n"
               "  b = realloc(b, 10000);\n"
               "  strcpy(b, a);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(char *a) {\n"
-              "  char *b = malloc(strlen(a));\n"
+              "  char *b = (char *)malloc(strlen(a));\n"
               "  strcpy(b, a);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds.\n", "", errout_str());
 
         check("void f(char *a) {\n"
-              "  char *b = malloc(strlen(a));\n"
+              "  char *b = (char *)malloc(strlen(a));\n"
               "  {\n"
               "    strcpy(b, a);\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Buffer is accessed out of bounds.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Buffer is accessed out of bounds.\n", "", errout_str());
 
         check("void f(char *a) {\n"
-              "  char *b = malloc(strlen(a) + 1);\n"
+              "  char *b = (char *)malloc(strlen(a) + 1);\n"
               "  strcpy(b, a);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(char *a, char *c) {\n"
-              "  char *b = realloc(c, strlen(a));\n"
+              "  char *b = (char *)realloc(c, strlen(a));\n"
               "  strcpy(b, a);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds.\n", "", errout_str());
 
         check("void f(char *a, char *c) {\n"
-              "  char *b = realloc(c, strlen(a) + 1);\n"
+              "  char *b = (char *)realloc(c, strlen(a) + 1);\n"
               "  strcpy(b, a);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(char *a) {\n"
-              "  char *b = malloc(strlen(a));\n"
+              "  char *b = (char *)malloc(strlen(a));\n"
               "  strcpy(b, a);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3]: (error) Buffer is accessed out of bounds.\n", "", errout_str());
     }
 
     void scope() {
         check("class A {\n"
               "private:\n"
               "    struct X { char buf[10]; };\n"
-              "}\n"
+              "};\n"
               "\n"
               "void f()\n"
               "{\n"
               "    X x;\n"
               "    x.buf[10] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class A {\n"
               "public:\n"
               "    struct X { char buf[10]; };\n"
-              "}\n"
+              "};\n"
               "\n"
               "void f()\n"
               "{\n"
               "    A::X x;\n"
               "    x.buf[10] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:9]: (error) Array 'x.buf[10]' accessed at index 10, which is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:10]: (error) Array 'x.buf[10]' accessed at index 10, which is out of bounds. [arrayIndexOutOfBounds]\n", errout_str());
     }
 
     void getErrorMessages() {
         // Ticket #2292: segmentation fault when using --errorlist
-        CheckBufferOverrun c;
+        const Check& c = getCheck<CheckBufferOverrun>();
         c.getErrorMessages(this, nullptr);
+        // we are not interested in the output - just consume it
+        ignore_errout();
     }
 
     void arrayIndexThenCheck() {
+        // extracttests.start: volatile int y;
+
         check("void f(const char s[]) {\n"
               "    if (s[i] == 'x' && i < y) {\n"
               "    }"
               "}");
-        ASSERT_EQUALS("", errout.str()); // No message because i is unknown and thus gets no varid. Avoid an internalError here.
+        ASSERT_EQUALS("", errout_str()); // No message because i is unknown and thus gets no varid. Avoid an internalError here.
 
         check("void f(const char s[], int i) {\n"
               "    if (s[i] == 'x' && i < y) {\n"
               "    }"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Array index 'i' is used before limits check.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (style) Array index 'i' is used before limits check. [arrayIndexThenCheck]\n", errout_str());
 
         check("void f(const char s[]) {\n"
               "    for (int i = 0; s[i] == 'x' && i < y; ++i) {\n"
               "    }"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Array index 'i' is used before limits check.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:22]: (style) Array index 'i' is used before limits check. [arrayIndexThenCheck]\n", errout_str());
 
         check("void f(const int a[], unsigned i) {\n"
               "    if((a[i] < 2) && (i <= 42)) {\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Array index 'i' is used before limits check.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (style) Array index 'i' is used before limits check. [arrayIndexThenCheck]\n", errout_str());
 
         check("void f(const int a[], unsigned i) {\n"
               "    if((a[i] < 2) && (42 >= i)) {\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Array index 'i' is used before limits check.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (style) Array index 'i' is used before limits check. [arrayIndexThenCheck]\n", errout_str());
 
+        // extracttests.start: int elen;
         check("void f(char* e, int y) {\n"
               "    if (e[y] == '/' && elen > y + 1 && e[y + 1] == '?') {\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
+        // extracttests.start: int foo(int); int func(int);
         check("void f(const int a[], unsigned i) {\n"
               "    if(a[i] < func(i) && i <= 42) {\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Array index 'i' is used before limits check.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Array index 'i' is used before limits check. [arrayIndexThenCheck]\n", errout_str());
 
         check("void f(const int a[], unsigned i) {\n"
               "    if (i <= 42 && a[i] < func(i)) {\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(const int a[], unsigned i) {\n"
               "    if (foo(a[i] + 3) < func(i) && i <= 42) {\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Array index 'i' is used before limits check.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (style) Array index 'i' is used before limits check. [arrayIndexThenCheck]\n", errout_str());
 
         check("void f(int i) {\n" // sizeof
               "  sizeof(a)/sizeof(a[i]) && i < 10;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // extracttests.start: extern int buf[];
+        check("void f(int i) {\n" // ?:
+              "  if ((i < 10 ? buf[i] : 1) && (i < 5 ? buf[i] : 5)){}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void arrayIndexEarlyReturn() { // #6884
+        check("extern const char *Names[2];\n"
+              "const char* getName(int value) {\n"
+              "  if ((value < 0) || (value > 1))\n"
+              "    return \"???\";\n"
+              "  const char* name = Names[value]; \n"
+              "  switch (value) {\n"
+              "  case 2:\n"
+              "    break; \n"
+              "  }\n"
+              "  return name;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void bufferNotZeroTerminated() {
@@ -4001,19 +5221,19 @@ class TestBufferOverrun : public TestFixture {
               "    char c[6];\n"
               "    strncpy(c,\"hello!\",6);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) The buffer 'c' is not null-terminated after the call to strncpy().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning, inconclusive) The buffer 'c' may not be null-terminated after the call to strncpy(). [terminateStrncpy]\n", errout_str());
 
         check("void f() {\n"
               "    char c[6];\n"
               "    memcpy(c,\"hello!\",6);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) The buffer 'c' is not null-terminated after the call to memcpy().\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) The buffer 'c' may not be null-terminated after the call to memcpy().\n", "", errout_str());
 
         check("void f() {\n"
               "    char c[6];\n"
               "    memmove(c,\"hello!\",6);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) The buffer 'c' is not null-terminated after the call to memmove().\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) The buffer 'c' may not be null-terminated after the call to memmove().\n", "", errout_str());
     }
 
     void negativeMemoryAllocationSizeError() { // #389
@@ -4022,32 +5242,40 @@ class TestBufferOverrun : public TestFixture {
               "   int *a;\n"
               "   a = new int[-1];\n"
               "   delete [] a;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Memory allocation size is negative.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:8]: (error) Memory allocation size is negative. [negativeMemoryAllocationSize]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "   int *a;\n"
-              "   a = malloc( -10 );\n"
+              "   a = (int *)malloc( -10 );\n"
               "   free(a);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Memory allocation size is negative.\n", errout.str());
+              "}");
+        TODO_ASSERT_EQUALS("[test.cpp:4:8]: (error) Memory allocation size is negative. [negativeMemoryAllocationSize]\n", "", errout_str());
 
         check("void f()\n"
               "{\n"
               "   int *a;\n"
-              "   a = malloc( -10);\n"
+              "   a = (int *)malloc( -10);\n"
               "   free(a);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Memory allocation size is negative.\n", errout.str());
+              "}");
+        TODO_ASSERT_EQUALS("[test.cpp:4:8]: (error) Memory allocation size is negative. [negativeMemoryAllocationSize]\n", "", errout_str());
 
         check("void f()\n"
               "{\n"
               "   int *a;\n"
-              "   a = alloca( -10 );\n"
-              "   free(a);\n"
+              "   a = (int *)alloca( -10 );\n"
+              "}");
+        TODO_ASSERT_EQUALS("[test.cpp:4:8]: (error) Memory allocation size is negative. [negativeMemoryAllocationSize]\n", "", errout_str());
+
+        check("int* f(int n) {\n" // #11145
+              "    int d = -1;\n"
+              "    for (int i = 0; i < n; ++i)\n"
+              "        d = std::max(i, d);\n"
+              "    int* p = new int[d];\n"
+              "    return p;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Memory allocation size is negative.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:14]: (warning, inconclusive) Memory allocation size is negative. [negativeMemoryAllocationSize]\n", errout_str());
     }
 
     void negativeArraySize() {
@@ -4055,40 +5283,45 @@ class TestBufferOverrun : public TestFixture {
               "   int a[sz];\n"
               "}\n"
               "void x() { f(-100); }");
-        TODO_ASSERT_EQUALS("[test.cpp:2]: (error) Declaration of array 'a' with negative size is undefined behaviour\n", "", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:8]: (error) Declaration of array 'a' with negative size is undefined behaviour [negativeArraySize]\n", errout_str());
 
         // don't warn for constant sizes -> this is a compiler error so this is used for static assertions for instance
         check("int x, y;\n"
               "int a[-1];\n"
               "int b[x?1:-1];\n"
-              "int c[x?y:-1];\n");
-        ASSERT_EQUALS("", errout.str());
+              "int c[x?y:-1];");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void pointerAddition1() {
         check("void f() {\n"
               "    char arr[10];\n"
-              "    p = arr + 20;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (portability) Undefined behaviour, pointer arithmetic 'arr+20' is out of bounds.\n", errout.str());
-    }
+              "    char *p = arr + 20;\n"
+              "}", settings0_p);
+        ASSERT_EQUALS("[test.cpp:3:19]: (portability) Undefined behaviour, pointer arithmetic 'arr+20' is out of bounds. [pointerOutOfBounds]\n", errout_str());
 
-    void ctu(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
+        check("char(*g())[1];\n" // #7950
+              "void f() {\n"
+              "    int a[2];\n"
+              "    int* b = a + sizeof(*g());\n"
+              "}\n", settings0_p);
+        ASSERT_EQUALS("", errout_str());
+    }
 
+#define ctu(...) ctu_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void ctu_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings0, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
-        CTU::FileInfo *ctu = CTU::getFileInfo(&tokenizer);
+        CTU::FileInfo *ctu = CTU::getFileInfo(tokenizer);
 
         // Check code..
         std::list<Check::FileInfo*> fileInfo;
-        CheckBufferOverrun check(&tokenizer, &settings0, this);
-        fileInfo.push_back(check.getFileInfo(&tokenizer, &settings0));
-        check.analyseWholeProgram(ctu, fileInfo, settings0, *this);
+        Check& c = getCheck<CheckBufferOverrun>();
+        fileInfo.push_back(c.getFileInfo(tokenizer, settings0, ""));
+        c.analyseWholeProgram(*ctu, fileInfo, settings0, *this); // TODO: check result
         while (!fileInfo.empty()) {
             delete fileInfo.back();
             fileInfo.pop_back();
@@ -4105,7 +5338,7 @@ class TestBufferOverrun : public TestFixture {
             "  char *s = malloc(4);\n"
             "  dostuff(s);\n"
             "}");
-        ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:7] -> [test.cpp:2]: (error) Array index out of bounds; buffer 'p' is accessed at offset -3.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:11] -> [test.cpp:7:10] -> [test.cpp:2:3]: (error) Array index out of bounds; buffer 'p' is accessed at offset -3. [ctuArrayIndex]\n", errout_str());
 
         ctu("void dostuff(char *p) {\n"
             "  p[4] = 0;\n"
@@ -4115,7 +5348,28 @@ class TestBufferOverrun : public TestFixture {
             "  char *s = malloc(4);\n"
             "  dostuff(s);\n"
             "}");
-        ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:7] -> [test.cpp:2]: (error) Array index out of bounds; 'p' buffer size is 4 and it is accessed at offset 4.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:11] -> [test.cpp:7:10] -> [test.cpp:2:3]: (error) Array index out of bounds; 'p' buffer size is 4 and it is accessed at offset 4. [ctuArrayIndex]\n", errout_str());
+
+        ctu("void f(int* p) {\n" // #10415
+            "    int b[1];\n"
+            "    b[0] = p[5];\n"
+            "    std::cout << b[0];\n"
+            "}\n"
+            "void g() {\n"
+            "    int* a = new int[1];\n"
+            "    a[0] = 5;\n"
+            "    f(a);\n"
+            "}\n");
+        ASSERT_EQUALS("[test.cpp:7:12] -> [test.cpp:9:6] -> [test.cpp:3:12]: (error) Array index out of bounds; 'p' buffer size is 4 and it is accessed at offset 20. [ctuArrayIndex]\n", errout_str());
+
+        ctu("void bar(int *p) { p[4] = 42; }\n" // #13403
+            "void f() {\n"
+            "    int *p = (int*)malloc(4 * sizeof(int));\n"
+            "    if (!p) return;\n"
+            "    bar(p);\n"
+            "    free(p);\n"
+            "}\n");
+        ASSERT_EQUALS("[test.cpp:3:12] -> [test.cpp:4:9] -> [test.cpp:5:8] -> [test.cpp:1:20]: (error) Array index out of bounds; 'p' buffer size is 16 and it is accessed at offset 16. [ctuArrayIndex]\n", errout_str());
     }
 
     void ctu_array() {
@@ -4126,7 +5380,7 @@ class TestBufferOverrun : public TestFixture {
             "  char str[4];\n"
             "  dostuff(str);\n"
             "}");
-        ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:2]: (error) Array index out of bounds; 'p' buffer size is 4 and it is accessed at offset 10.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:10] -> [test.cpp:2:5]: (error) Array index out of bounds; 'p' buffer size is 4 and it is accessed at offset 10. [ctuArrayIndex]\n", errout_str());
 
         ctu("static void memclr( char *data )\n"
             "{\n"
@@ -4138,7 +5392,7 @@ class TestBufferOverrun : public TestFixture {
             "    char str[5];\n"
             "    memclr( str );\n"
             "}");
-        ASSERT_EQUALS("[test.cpp:9] -> [test.cpp:3]: (error) Array index out of bounds; 'data' buffer size is 5 and it is accessed at offset 10.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:11] -> [test.cpp:3:5]: (error) Array index out of bounds; 'data' buffer size is 5 and it is accessed at offset 10. [ctuArrayIndex]\n", errout_str());
 
         ctu("static void memclr( int i, char *data )\n"
             "{\n"
@@ -4150,7 +5404,7 @@ class TestBufferOverrun : public TestFixture {
             "    char str[5];\n"
             "    memclr( 0, str );\n"
             "}");
-        ASSERT_EQUALS("[test.cpp:9] -> [test.cpp:3]: (error) Array index out of bounds; 'data' buffer size is 5 and it is accessed at offset 10.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:11] -> [test.cpp:3:5]: (error) Array index out of bounds; 'data' buffer size is 5 and it is accessed at offset 10. [ctuArrayIndex]\n", errout_str());
 
         ctu("static void memclr( int i, char *data )\n"
             "{\n"
@@ -4163,7 +5417,7 @@ class TestBufferOverrun : public TestFixture {
             "    memclr( 10, str );\n"
             "}");
         TODO_ASSERT_EQUALS("[test.cpp:9] -> [test.cpp:3]: (possible error) Array index out of bounds.\n",
-                           "", errout.str());
+                           "", errout_str());
 
         // This is not an error
         ctu("static void memclr( char *data, int size )\n"
@@ -4177,7 +5431,7 @@ class TestBufferOverrun : public TestFixture {
             "    char str[5];\n"
             "    memclr( str, 5 );\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #2097
         ctu("void foo(int *p)\n"
@@ -4191,7 +5445,7 @@ class TestBufferOverrun : public TestFixture {
             "    int p[3];\n"
             "    foo(p+1);\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #9112
         ctu("static void get_mac_address(const u8 *strbuf)\n"
@@ -4204,7 +5458,53 @@ class TestBufferOverrun : public TestFixture {
             "    u8 macstrbuf[17] = { 0 };\n"
             "    get_mac_address(macstrbuf);\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // #9788
+        ctu("void f1(char *s) { s[2] = 'B'; }\n"
+            "void f2(char s[]) { s[2] = 'B'; }\n"
+            "void g() {\n"
+            "    char str[2];\n"
+            "    f1(str);\n"
+            "    f2(str);\n"
+            "}\n");
+        ASSERT_EQUALS("[test.cpp:5:7] -> [test.cpp:1:20]: (error) Array index out of bounds; 's' buffer size is 2 and it is accessed at offset 2. [ctuArrayIndex]\n"
+                      "[test.cpp:6:7] -> [test.cpp:2:21]: (error) Array index out of bounds; 's' buffer size is 2 and it is accessed at offset 2. [ctuArrayIndex]\n",
+                      errout_str());
+
+        // #5140
+        ctu("void g(const char* argv[]) { std::cout << \"argv: \" << argv[4] << std::endl; }\n"
+            "void f() {\n"
+            "    const char* argv[] = { \"test\" };\n"
+            "    g(argv);\n"
+            "}\n");
+        ASSERT_EQUALS("[test.cpp:4:6] -> [test.cpp:1:55]: (error) Array index out of bounds; 'argv' buffer size is 1 and it is accessed at offset 4. [ctuArrayIndex]\n",
+                      errout_str());
+
+        ctu("void g(const char* argv[]) { std::cout << \"argv: \" << argv[5] << std::endl; }\n"
+            "void f() {\n"
+            "    const char* argv[1] = { \"test\" };\n"
+            "    g(argv);\n"
+            "}\n");
+        ASSERT_EQUALS("[test.cpp:4:6] -> [test.cpp:1:55]: (error) Array index out of bounds; 'argv' buffer size is 1 and it is accessed at offset 5. [ctuArrayIndex]\n",
+                      errout_str());
+
+        ctu("void g(int *b) { b[0] = 0; }\n"
+            "void f() {\n"
+            "    GLint a[1];\n"
+            "    g(a);\n"
+            "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        ctu("const int a[1] = { 1 };\n" // #11042
+            "void g(const int* d) {\n"
+            "    (void)d[2];\n"
+            "}\n"
+            "void f() {\n"
+            "    g(a);\n"
+            "}\n");
+        ASSERT_EQUALS("[test.cpp:6:6] -> [test.cpp:3:11]: (error) Array index out of bounds; 'd' buffer size is 4 and it is accessed at offset 8. [ctuArrayIndex]\n",
+                      errout_str());
     }
 
     void ctu_variable() {
@@ -4215,7 +5515,7 @@ class TestBufferOverrun : public TestFixture {
             "  int x = 4;\n"
             "  dostuff(&x);\n"
             "}");
-        ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:2]: (error) Array index out of bounds; 'p' buffer size is 4 and it is accessed at offset 40.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:10] -> [test.cpp:2:5]: (error) Array index out of bounds; 'p' buffer size is 4 and it is accessed at offset 40. [ctuArrayIndex]\n", errout_str());
     }
 
     void ctu_arithmetic() {
@@ -4224,66 +5524,291 @@ class TestBufferOverrun : public TestFixture {
             "  int x[3];\n"
             "  dostuff(x);\n"
             "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:1]: (error) Pointer arithmetic overflow; 'p' buffer size is 12\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:10] -> [test.cpp:1:28]: (error) Pointer arithmetic overflow; 'p' buffer size is 12 [ctuPointerArith]\n", errout_str());
+
+        ctu("void f(const char *p) {\n" // #11361
+            "    const char* c = p + 1;\n"
+            "}\n"
+            "void g() {\n"
+            "    const char s[N] = \"ab\";\n"
+            "    f(s);\n"
+            "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        setMultiline();
+        ctu("void g(char* p) {\n"
+            "    memset(p + 10, 0, 10);\n"
+            "}\n"
+            "void f() {\n"
+            "    char a[10] = {};\n"
+            "    g(a);\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:2:12]: error: Pointer arithmetic overflow; 'p' buffer size is 10 [ctuPointerArith]\n"
+                      "[test.cpp:6:6]: note: Calling function g, 1st argument is accessed out of bounds\n"
+                      "[test.cpp:2:12]: note: Using argument p\n",
+                      errout_str());
     }
 
     void objectIndex() {
-        check("int f() { \n"
+        check("int f() {\n"
               "    int i;\n"
-              "    return (&i)[1]; \n"
-              "}\n");
+              "    return (&i)[1];\n"
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:3]: (error) The address of local variable 'i' is accessed at non-zero index.\n",
-            errout.str());
+            "[test.cpp:3:13] -> [test.cpp:3:16]: (error) The address of variable 'i' is accessed at non-zero index. [objectIndex]\n",
+            errout_str());
 
-        check("int f(int j) { \n"
+        check("int f(int j) {\n"
               "    int i;\n"
-              "    return (&i)[j]; \n"
-              "}\n");
+              "    return (&i)[j];\n"
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:3]: (warning) The address of local variable 'i' might be accessed at non-zero index.\n",
-            errout.str());
+            "[test.cpp:3:13] -> [test.cpp:3:16]: (warning) The address of variable 'i' might be accessed at non-zero index. [objectIndex]\n",
+            errout_str());
 
-        check("int f() { \n"
+        check("int f() {\n"
               "    int i;\n"
-              "    return (&i)[0]; \n"
+              "    return (&i)[0];\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int * i) {\n"
+              "    return i[1];\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(std::vector<int> i) {\n"
+              "    return i[1];\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(std::vector<int> i) {\n"
+              "    return i.data()[1];\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int* f(std::vector<int>& i) {\n"
+              "    return &(i[1]);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A { int i; int j; };\n"
+              "int f() {\n"
+              "    A x;\n"
+              "    return (&x.i)[0];\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A { int i; int j; };\n"
+              "int f() {\n"
+              "    A x;\n"
+              "    int * i = &x.i;\n"
+              "    return i[0];\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "  int x = 0;\n"
+              "  std::map<int, int*> m;\n"
+              "  m[0] = &x;\n"
+              "  m[1] = &x;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f() {\n"
+              "  int x = 0;\n"
+              "  std::map<int, int*> m;\n"
+              "  m[0] = &x;\n"
+              "  return m[0][1];\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:4:10] -> [test.cpp:5:14]: (error) The address of variable 'x' is accessed at non-zero index. [objectIndex]\n",
+            errout_str());
+
+        check("int x = 0;\n"
+              "int f() {\n"
+              "  std::map<int, int*> m;\n"
+              "  m[0] = &x;\n"
+              "  return m[0][1];\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:4:10] -> [test.cpp:5:14]: (error) The address of variable 'x' is accessed at non-zero index. [objectIndex]\n",
+            errout_str());
+
+        check("int f(int * y) {\n"
+              "  int x = 0;\n"
+              "  std::map<int, int*> m;\n"
+              "  m[0] = &x;\n"
+              "  m[1] = y;\n"
+              "  return m[1][1];\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void print(char** test);\n"
+              "int main(){\n"
+              "    char* test = \"abcdef\";\n"
+              "    print(&test);\n"
+              "    return 0;\n"
+              "}\n"
+              "void print(char** test){\n"
+              "    for(int i=0;i<strlen(*test);i++)\n"
+              "        printf(\"%c\",*test[i]);\n"
+              "}\n");
+        TODO_ASSERT_EQUALS(
+            "[test.cpp:4] -> [test.cpp:4] -> [test.cpp:9]: (warning) The address of local variable 'test' might be accessed at non-zero index.\n",
+            "",
+            errout_str());
+
+        check("void Bar(uint8_t data);\n"
+              "void Foo(const uint8_t * const data, const uint8_t length) {\n"
+              "        for(uint8_t index = 0U; index < length ; ++index)\n"
+              "            Bar(data[index]);\n"
+              "}\n"
+              "void test() {\n"
+              "    const uint8_t data = 0U;\n"
+              "    Foo(&data,1U);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int foo(int n, int* p) {\n"
+              "    int res = 0;\n"
+              "    for(int i = 0; i < n; i++ )\n"
+              "        res += p[i];\n"
+              "    return res;\n"
+              "}\n"
+              "int bar() {\n"
+              "    int single_value = 0;\n"
+              "    return foo(1, &single_value);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const char* app, size_t applen) {\n" // #10137
+              "    char* tmp_de = NULL;\n"
+              "    char** str = &tmp_de;\n"
+              "    char* tmp = (char*)realloc(*str, applen + 1);\n"
+              "    if (tmp) {\n"
+              "        *str = tmp;\n"
+              "        memcpy(*str, app, applen);\n"
+              "        (*str)[applen] = '\\0';\n"
+              "    }\n"
+              "    free(*str);\n"
+              "}\n", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+
+        check("template <typename T, unsigned N>\n"
+              "using vector = Eigen::Matrix<T, N, 1>;\n"
+              "template <typename V>\n"
+              "void scharr(image2d<vector<V, 2>>& out) {\n"
+              "    vector<V, 2>* out_row = &out(r, 0);\n"
+              "    out_row[c] = vector<V, 2>(1,2);\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const uint8_t* d, const uint8_t L) {\n" // #10092
+              "    for (uint8_t i = 0U; i < L; ++i)\n"
+              "        g(d[i]);\n"
+              "}\n"
+              "void h() {\n"
+              "    const uint8_t u = 4;\n"
+              "    f(&u, N);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("int f(int * i) { \n"
-              "    return i[1]; \n"
+        check("uint32_t f(uint32_t u) {\n" // #10154
+              "    return ((uint8_t*)&u)[3];\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("int f(std::vector<int> i) { \n"
-              "    return i[1]; \n"
+        check("uint32_t f(uint32_t u) {\n"
+              "    return ((uint8_t*)&u)[4];\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:23] -> [test.cpp:2:26]: (error) The address of variable 'u' is accessed at non-zero index. [objectIndex]\n", errout_str());
 
-        check("int f(std::vector<int> i) { \n"
-              "    return i.data()[1]; \n"
+        check("uint32_t f(uint32_t u) {\n"
+              "    return reinterpret_cast<unsigned char*>(&u)[3];\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("int* f(std::vector<int>& i) { \n"
-              "    return &(i[1]); \n"
+        check("uint32_t f(uint32_t u) {\n"
+              "    return reinterpret_cast<unsigned char*>(&u)[4];\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:45] -> [test.cpp:2:48]: (error) The address of variable 'u' is accessed at non-zero index. [objectIndex]\n", errout_str());
 
-        check("struct A { int i; int j; };\n"
-              "int f() { \n"
-              "    A x;\n"
-              "    return (&x.i)[0]; \n"
+        check("uint32_t f(uint32_t u) {\n"
+              "    uint8_t* p = (uint8_t*)&u;\n"
+              "    return p[3];\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("struct A { int i; int j; };\n"
-              "int f() { \n"
-              "    A x;\n"
-              "    int * i = &x.i;\n"
-              "    return i[0]; \n"
+        check("uint32_t f(uint32_t u) {\n"
+              "    uint8_t* p = (uint8_t*)&u;\n"
+              "    return p[4];\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:28] -> [test.cpp:3:13]: (error) The address of variable 'u' is accessed at non-zero index. [objectIndex]\n", errout_str());
+
+        check("uint32_t f(uint32_t* pu) {\n"
+              "    uint8_t* p = (uint8_t*)pu;\n"
+              "    return p[4];\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { uint8_t padding[500]; };\n" // #10133
+              "S s = { 0 };\n"
+              "uint8_t f() {\n"
+              "    uint8_t* p = (uint8_t*)&s;\n"
+              "    return p[10];\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct X {\n" // #2654
+              "    int  a;\n"
+              "    char b;\n"
+              "};\n"
+              "void f() {\n"
+              "    const X s;\n"
+              "    const int* y = &s.a;\n"
+              "    (void)y[0];\n"
+              "    (void)y[1];\n"
+              "    (void)y[2];\n"
+              "}\n");
+        TODO_ASSERT_EQUALS("error", "", errout_str());
+    }
+
+    void checkPipeParameterSize() { // #3521
+
+        const Settings settings = settingsBuilder().library("posix.cfg").build();
+
+        check("void f(){\n"
+              "int pipefd[1];\n" // <--  array of two integers is needed
+              "if (pipe(pipefd) == -1) {\n"
+              "    return;\n"
+              "  }\n"
+              "}", settings);
+        ASSERT_EQUALS("[test.cpp:3:10]: (error) Buffer is accessed out of bounds: pipefd [bufferAccessOutOfBounds]\n", errout_str());
+
+        check("void f(){\n"
+              "int pipefd[2];\n"
+              "if (pipe(pipefd) == -1) {\n"
+              "    return;\n"
+              "  }\n"
+              "}", settings);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(){\n"
+              "char pipefd[2];\n"
+              "if (pipe((int*)pipefd) == -1) {\n"
+              "    return;\n"
+              "  }\n"
+              "}", settings);
+        ASSERT_EQUALS("[test.cpp:3:10]: (error) Buffer is accessed out of bounds: (int*)pipefd [bufferAccessOutOfBounds]\n", errout_str());
+
+        check("void f(){\n"
+              "char pipefd[20];\n" // Strange, but large enough
+              "if (pipe((int*)pipefd) == -1) {\n"
+              "    return;\n"
+              "  }\n"
+              "}", settings);
+        ASSERT_EQUALS("", errout_str());
     }
 };
 
diff --git a/test/testcharvar.cpp b/test/testcharvar.cpp
index a414a1c1588..624efcff539 100644
--- a/test/testcharvar.cpp
+++ b/test/testcharvar.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,40 +16,35 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include "checkother.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "platform.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
 
+#include <cstddef>
 
 class TestCharVar : public TestFixture {
 public:
-    TestCharVar() : TestFixture("TestCharVar") {
-    }
+    TestCharVar() : TestFixture("TestCharVar") {}
 
 private:
-    Settings settings;
-
-    void run() OVERRIDE {
-        settings.platform(Settings::Unspecified);
-        settings.addEnabled("warning");
-        settings.addEnabled("portability");
+    const Settings settings = settingsBuilder().severity(Severity::warning).severity(Severity::portability).platform(Platform::Type::Unspecified).build();
 
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(array_index_1);
         TEST_CASE(array_index_2);
         TEST_CASE(bitop);
     }
 
-    void check(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
-
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check char variable usage..
         CheckOther checkOther(&tokenizer, &settings, this);
@@ -63,7 +58,7 @@ class TestCharVar : public TestFixture {
               "    unsigned char ch = 0x80;\n"
               "    buf[ch] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int buf[256];\n"
               "void foo()\n"
@@ -71,7 +66,7 @@ class TestCharVar : public TestFixture {
               "    char ch = 0x80;\n"
               "    buf[ch] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (portability) 'char' type used as array index.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5]: (portability) 'char' type used as array index. [unknownSignCharArrayIndex]\n", errout_str());
 
         check("int buf[256];\n"
               "void foo()\n"
@@ -79,7 +74,7 @@ class TestCharVar : public TestFixture {
               "    char ch = 0;\n"
               "    buf[ch] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int buf[256];\n"
               "void foo()\n"
@@ -87,7 +82,7 @@ class TestCharVar : public TestFixture {
               "    signed char ch = 0;\n"
               "    buf[ch] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int buf[256];\n"
               "void foo()\n"
@@ -95,67 +90,67 @@ class TestCharVar : public TestFixture {
               "    char ch = 0x80;\n"
               "    buf[ch] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (portability) 'char' type used as array index.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5]: (portability) 'char' type used as array index. [unknownSignCharArrayIndex]\n", errout_str());
 
         check("int buf[256];\n"
               "void foo(signed char ch)\n"
               "{\n"
               "    buf[ch] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int buf[256];\n"
               "void foo(char ch)\n"
               "{\n"
               "    buf[ch] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(char* buf)\n"
               "{\n"
               "    char ch = 0x80;"
               "    buf[ch] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (portability) 'char' type used as array index.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:24]: (portability) 'char' type used as array index. [unknownSignCharArrayIndex]\n", errout_str());
 
         check("void foo(char* buf)\n"
               "{\n"
               "    char ch = 0;"
               "    buf[ch] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(char* buf)\n"
               "{\n"
               "    buf['A'] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(char* buf, char ch)\n"
               "{\n"
               "    buf[ch] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int flags[256];\n"
               "void foo(const char* str)\n"
               "{\n"
               "    flags[*str] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int flags[256];\n"
               "void foo(const char* str)\n"
               "{\n"
               "    flags[(unsigned char)*str] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(const char str[])\n"
               "{\n"
               "    map[str] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void array_index_2() {
@@ -165,7 +160,7 @@ class TestCharVar : public TestFixture {
               "    const char *s = \"abcde\";\n"
               "    foo(s[i]);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void bitop() {
@@ -173,32 +168,32 @@ class TestCharVar : public TestFixture {
               "    signed char ch = -1;\n"
               "    *result = a | ch;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) When using 'char' variables in bit operations, sign extension can generate unexpected results.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:17]: (warning) When using 'char' variables in bit operations, sign extension can generate unexpected results. [charBitOp]\n", errout_str());
 
         check("void foo(int *result) {\n"
               "    unsigned char ch = -1;\n"
               "    *result = a | ch;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(char *result) {\n"
               "    signed char ch = -1;\n"
               "    *result = a | ch;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // 0x03 & ..
         check("void foo(int *result) {\n"
               "    signed char ch = -1;\n"
               "    *result = 0x03 | ch;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) When using 'char' variables in bit operations, sign extension can generate unexpected results.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:20]: (warning) When using 'char' variables in bit operations, sign extension can generate unexpected results. [charBitOp]\n", errout_str());
 
         check("void foo(int *result) {\n"
               "    signed char ch = -1;\n"
               "    *result = 0x03 & ch;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 };
 
diff --git a/test/testcheck.cpp b/test/testcheck.cpp
new file mode 100644
index 00000000000..8ea4cef38d8
--- /dev/null
+++ b/test/testcheck.cpp
@@ -0,0 +1,58 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "check.h"
+#include "fixture.h"
+
+#include <list>
+#include <string>
+
+class TestCheck : public TestFixture {
+public:
+    TestCheck() : TestFixture("TestCheck") {}
+
+private:
+    void run() override {
+        TEST_CASE(instancesSorted);
+        TEST_CASE(classInfoFormat);
+    }
+
+    void instancesSorted() const {
+        for (auto i = Check::instances().cbegin(); i != Check::instances().cend(); ++i) {
+            auto j = i;
+            ++j;
+            if (j != Check::instances().cend()) {
+                ASSERT_EQUALS(true, (*i)->name() < (*j)->name());
+            }
+        }
+    }
+
+    void classInfoFormat() const {
+        for (auto i = Check::instances().cbegin(); i != Check::instances().cend(); ++i) {
+            const std::string info = (*i)->classInfo();
+            if (!info.empty()) {
+                ASSERT('\n' != info[0]);         // No \n in the beginning
+                ASSERT('\n' == info.back());     // \n at end
+                if (info.size() > 1)
+                    ASSERT('\n' != info[info.length()-2]); // Only one \n at end
+            }
+        }
+    }
+};
+
+REGISTER_TEST(TestCheck)
diff --git a/test/testcheckersreport.cpp b/test/testcheckersreport.cpp
new file mode 100644
index 00000000000..eafe7b8848f
--- /dev/null
+++ b/test/testcheckersreport.cpp
@@ -0,0 +1,56 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "addoninfo.h"
+#include "checkersreport.h"
+#include "fixture.h"
+#include "settings.h"
+
+class TestCheckersReport : public TestFixture {
+public:
+    TestCheckersReport() : TestFixture("TestCheckersReport") {}
+
+private:
+    void run() final {
+        // AddonInfo::checkers
+        TEST_CASE(addonInfoCheckers);
+    }
+
+    void addonInfoCheckers() const {
+        AddonInfo a;
+        a.name = "test";
+        a.checkers["abcdefghijklmnopqrstuvwxyz::abcdefghijklmnopqrstuvwxyz"] = "123";
+        Settings s;
+        s.addonInfos.emplace_back(a);
+        const std::set<std::string> activeCheckers;
+        CheckersReport r(s, activeCheckers);
+        const std::string report = r.getReport("");
+        const auto pos = report.rfind("\n\n");
+        ASSERT(pos != std::string::npos);
+
+        const char expected[] =
+            "test checkers\n"
+            "-------------\n"
+            "No   abcdefghijklmnopqrstuvwxyz::abcdefghijklmnopqrstuvwxyz    require:123\n";
+
+        ASSERT_EQUALS(expected, report.substr(pos+2));
+    }
+};
+
+REGISTER_TEST(TestCheckersReport)
diff --git a/test/testclangimport.cpp b/test/testclangimport.cpp
new file mode 100644
index 00000000000..6a39b563982
--- /dev/null
+++ b/test/testclangimport.cpp
@@ -0,0 +1,1377 @@
+// Cppcheck - A tool for static C/C++ code analysis
+// Copyright (C) 2007-2026 Cppcheck team.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "clangimport.h"
+#include "fixture.h"
+#include "mathlib.h"
+#include "platform.h"
+#include "settings.h"
+#include "standards.h"
+#include "symboldatabase.h"
+#include "token.h"
+#include "tokenize.h"
+#include "tokenlist.h"
+
+#include <cstdint>
+#include <list>
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+
+
+class TestClangImport : public TestFixture {
+public:
+    TestClangImport()
+        : TestFixture("TestClangImport") {}
+
+
+private:
+    void run() override {
+        TEST_CASE(breakStmt);
+        TEST_CASE(callExpr);
+        TEST_CASE(caseStmt1);
+        TEST_CASE(characterLiteral);
+        TEST_CASE(class1);
+        TEST_CASE(classTemplateDecl1);
+        TEST_CASE(classTemplateDecl2);
+        TEST_CASE(conditionalExpr);
+        TEST_CASE(compoundAssignOperator);
+        TEST_CASE(continueStmt);
+        TEST_CASE(cstyleCastExpr);
+        TEST_CASE(cxxBoolLiteralExpr);
+        TEST_CASE(cxxConstructorDecl1);
+        TEST_CASE(cxxConstructorDecl2);
+        TEST_CASE(cxxConstructExpr1);
+        TEST_CASE(cxxConstructExpr2);
+        TEST_CASE(cxxConstructExpr3);
+        TEST_CASE(cxxDeleteExpr);
+        TEST_CASE(cxxDestructorDecl);
+        TEST_CASE(cxxForRangeStmt1);
+        TEST_CASE(cxxForRangeStmt2);
+        TEST_CASE(cxxFunctionalCastExpr);
+        TEST_CASE(cxxMemberCall);
+        TEST_CASE(cxxMethodDecl1);
+        TEST_CASE(cxxMethodDecl2);
+        TEST_CASE(cxxMethodDecl3);
+        TEST_CASE(cxxMethodDecl4);
+        TEST_CASE(cxxNewExpr1);
+        TEST_CASE(cxxNewExpr2);
+        TEST_CASE(cxxNullPtrLiteralExpr);
+        TEST_CASE(cxxOperatorCallExpr);
+        TEST_CASE(cxxRecordDecl1);
+        TEST_CASE(cxxRecordDecl2);
+        TEST_CASE(cxxRecordDeclDerived);
+        TEST_CASE(cxxStaticCastExpr1);
+        TEST_CASE(cxxStaticCastExpr2);
+        TEST_CASE(cxxStaticCastExpr3);
+        TEST_CASE(cxxStdInitializerListExpr);
+        TEST_CASE(cxxThrowExpr);
+        TEST_CASE(defaultStmt);
+        TEST_CASE(doStmt);
+        TEST_CASE(enumDecl1);
+        TEST_CASE(enumDecl2);
+        TEST_CASE(enumDecl3);
+        TEST_CASE(enumDecl4);
+        TEST_CASE(forStmt);
+        TEST_CASE(funcdecl1);
+        TEST_CASE(funcdecl2);
+        TEST_CASE(funcdecl3);
+        TEST_CASE(funcdecl4);
+        TEST_CASE(funcdecl5);
+        TEST_CASE(funcdecl6);
+        TEST_CASE(functionTemplateDecl1);
+        TEST_CASE(functionTemplateDecl2);
+        TEST_CASE(initListExpr);
+        TEST_CASE(ifelse);
+        TEST_CASE(ifStmt);
+        TEST_CASE(labelStmt);
+        TEST_CASE(memberExpr);
+        TEST_CASE(namespaceDecl1);
+        TEST_CASE(namespaceDecl2);
+        TEST_CASE(recordDecl1);
+        TEST_CASE(recordDecl2);
+        TEST_CASE(switchStmt);
+        TEST_CASE(typedefDeclPrologue);
+        TEST_CASE(unaryExprOrTypeTraitExpr1);
+        TEST_CASE(unaryExprOrTypeTraitExpr2);
+        TEST_CASE(unaryOperator);
+        TEST_CASE(vardecl1);
+        TEST_CASE(vardecl2);
+        TEST_CASE(vardecl3);
+        TEST_CASE(vardecl4);
+        TEST_CASE(vardecl5);
+        TEST_CASE(vardecl6);
+        TEST_CASE(vardecl7);
+        TEST_CASE(whileStmt1);
+        TEST_CASE(whileStmt2);
+
+        TEST_CASE(tokenIndex);
+        TEST_CASE(symbolDatabaseEnum1);
+        TEST_CASE(symbolDatabaseFunction1);
+        TEST_CASE(symbolDatabaseFunction2);
+        TEST_CASE(symbolDatabaseFunction3);
+        TEST_CASE(symbolDatabaseFunctionConst);
+        TEST_CASE(symbolDatabaseVariableRef);
+        TEST_CASE(symbolDatabaseVariableRRef);
+        TEST_CASE(symbolDatabaseVariablePointerRef);
+        TEST_CASE(symbolDatabaseNodeType1);
+        TEST_CASE(symbolDatabaseForVariable);
+        TEST_CASE(stdinLoc);
+
+        TEST_CASE(valueFlow1);
+        TEST_CASE(valueFlow2);
+
+        TEST_CASE(valueType1);
+        TEST_CASE(valueType2);
+
+        TEST_CASE(crash);
+    }
+
+    std::string parse(const char clang[]) {
+        const Settings settings = settingsBuilder().clang().build();
+        TokenList tokenlist{settings, Standards::Language::CPP};
+        Tokenizer tokenizer(std::move(tokenlist), *this);
+        std::istringstream istr(clang);
+        clangimport::parseClangAstDump(tokenizer, istr);
+        if (!tokenizer.tokens()) {
+            return std::string();
+        }
+        return tokenizer.tokens()->stringifyList(true, false, false, false, false);
+    }
+
+    void breakStmt() {
+        const char clang[] = "`-FunctionDecl 0x2c31b18 <1.c:1:1, col:34> col:6 foo 'void ()'\n"
+                             "  `-CompoundStmt 0x2c31c40 <col:12, col:34>\n"
+                             "    `-WhileStmt 0x2c31c20 <col:14, col:24>\n"
+                             "      |-<<<NULL>>>\n"
+                             "      |-IntegerLiteral 0x2c31bf8 <col:21> 'int' 0\n"
+                             "      `-BreakStmt 0x3687c18 <col:24>";
+        ASSERT_EQUALS("void foo ( ) { while ( 0 ) { break ; } }", parse(clang));
+    }
+
+    void callExpr() {
+        const char clang[] = "`-FunctionDecl 0x2444b60 <1.c:1:1, line:8:1> line:1:6 foo 'void (int)'\n"
+                             "  |-ParmVarDecl 0x2444aa0 <col:10, col:14> col:14 used x 'int'\n"
+                             "  `-CompoundStmt 0x2444e00 <col:17, line:8:1>\n"
+                             "    `-CallExpr 0x7f5a6c04b158 <line:1:16, col:60> 'bool'\n"
+                             "      |-ImplicitCastExpr 0x7f5a6c04b140 <col:16, col:23> 'bool (*)(const Token *, const char *, int)' <FunctionToPointerDecay>\n"
+                             "      | `-DeclRefExpr 0x7f5a6c04b0a8 <col:16, col:23> 'bool (const Token *, const char *, int)' lvalue CXXMethod 0x43e5600 'Match' 'bool (const Token *, const char *, int)'\n"
+                             "      |-ImplicitCastExpr 0x7f5a6c04b1c8 <col:29> 'const Token *' <NoOp>\n"
+                             "      | `-ImplicitCastExpr 0x7f5a6c04b1b0 <col:29> 'Token *' <LValueToRValue>\n"
+                             "      |   `-DeclRefExpr 0x7f5a6c04b0e0 <col:29> 'Token *' lvalue Var 0x7f5a6c045968 'tokAfterCondition' 'Token *'\n"
+                             "      |-ImplicitCastExpr 0x7f5a6c04b1e0 <col:48> 'const char *' <ArrayToPointerDecay>\n"
+                             "      | `-StringLiteral 0x7f5a6c04b108 <col:48> 'const char [11]' lvalue \"%name% : {\"\n"
+                             "      `-CXXDefaultArgExpr 0x7f5a6c04b1f8 <<invalid sloc>> 'int'\n";
+        ASSERT_EQUALS("void foo ( int x@1 ) { Match ( tokAfterCondition , \"%name% : {\" ) ; }", parse(clang));
+    }
+
+    void caseStmt1() {
+        const char clang[] = "`-FunctionDecl 0x2444b60 <1.c:1:1, line:8:1> line:1:6 foo 'void (int)'\n"
+                             "  |-ParmVarDecl 0x2444aa0 <col:10, col:14> col:14 used x 'int'\n"
+                             "  `-CompoundStmt 0x2444e00 <col:17, line:8:1>\n"
+                             "    `-SwitchStmt 0x2444c88 <line:2:5, line:7:5>\n"
+                             "      |-<<<NULL>>>\n"
+                             "      |-<<<NULL>>>\n"
+                             "      |-ImplicitCastExpr 0x2444c70 <line:2:13> 'int' <LValueToRValue>\n"
+                             "      | `-DeclRefExpr 0x2444c48 <col:13> 'int' lvalue ParmVar 0x2444aa0 'x' 'int'\n"
+                             "      `-CompoundStmt 0x2444de0 <col:16, line:7:5>\n"
+                             "        |-CaseStmt 0x2444cd8 <line:3:9, line:5:15>\n"
+                             "        | |-IntegerLiteral 0x2444cb8 <line:3:14> 'int' 16\n"
+                             "        | |-<<<NULL>>>\n"
+                             "        | `-CaseStmt 0x2444d30 <line:4:9, line:5:15>\n"
+                             "        |   |-IntegerLiteral 0x2444d10 <line:4:14> 'int' 32\n"
+                             "        |   |-<<<NULL>>>\n"
+                             "        |   `-BinaryOperator 0x2444db0 <line:5:13, col:15> 'int' '='\n"
+                             "        |     |-DeclRefExpr 0x2444d68 <col:13> 'int' lvalue ParmVar 0x2444aa0 'x' 'int'\n"
+                             "        |     `-IntegerLiteral 0x2444d90 <col:15> 'int' 123\n"
+                             "        `-BreakStmt 0x2444dd8 <line:6:13>";
+        ASSERT_EQUALS("void foo ( int x@1 ) { switch ( x@1 ) { case 16 : case 32 : x@1 = 123 ; break ; } }", parse(clang));
+    }
+
+    void characterLiteral() {
+        const char clang[] = "`-VarDecl 0x3df8608 <a.cpp:1:1, col:10> col:6 c 'char' cinit\n"
+                             "  `-CharacterLiteral 0x3df86a8 <col:10> 'char' 120";
+        ASSERT_EQUALS("char c@1 = 'x' ;", parse(clang));
+    }
+
+    void class1() {
+        const char clang[] = "`-CXXRecordDecl 0x274c638 <a.cpp:1:1, col:25> col:7 class C definition\n"
+                             "  |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init\n"
+                             "  | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr\n"
+                             "  | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param\n"
+                             "  | |-MoveConstructor exists simple trivial needs_implicit\n"
+                             "  | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param\n"
+                             "  | |-MoveAssignment exists simple trivial needs_implicit\n"
+                             "  | `-Destructor simple irrelevant trivial needs_implicit\n"
+                             "  |-CXXRecordDecl 0x274c758 <col:1, col:7> col:7 implicit class C\n"
+                             "  `-CXXMethodDecl 0x274c870 <col:11, col:23> col:16 foo 'void ()'\n"
+                             "    `-CompoundStmt 0x274c930 <col:22, col:23>";
+        ASSERT_EQUALS("class C { void foo ( ) { } } ;", parse(clang));
+    }
+
+    void classTemplateDecl1() {
+        const char clang[] = "`-ClassTemplateDecl 0x29d1748 <a.cpp:1:1, col:59> col:25 C\n"
+                             "  |-TemplateTypeParmDecl 0x29d15f8 <col:10, col:16> col:16 referenced class depth 0 index 0 T\n"
+                             "  `-CXXRecordDecl 0x29d16b0 <col:19, col:59> col:25 class C definition\n"
+                             "    |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init\n"
+                             "    | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr\n"
+                             "    | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param\n"
+                             "    | |-MoveConstructor exists simple trivial needs_implicit\n"
+                             "    | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param\n"
+                             "    | |-MoveAssignment exists simple trivial needs_implicit\n"
+                             "    | `-Destructor simple irrelevant trivial needs_implicit\n"
+                             "    |-CXXRecordDecl 0x29d19b0 <col:19, col:25> col:25 implicit class C\n"
+                             "    |-AccessSpecDecl 0x29d1a48 <col:29, col:35> col:29 public\n"
+                             "    `-CXXMethodDecl 0x29d1b20 <col:37, col:57> col:39 foo 'T ()'\n"
+                             "      `-CompoundStmt 0x29d1c18 <col:45, col:57>\n"
+                             "        `-ReturnStmt 0x29d1c00 <col:47, col:54>\n"
+                             "          `-IntegerLiteral 0x29d1be0 <col:54> 'int' 0";
+        ASSERT_EQUALS("", parse(clang));
+    }
+
+    void classTemplateDecl2() {
+        const char clang[] = "|-ClassTemplateDecl 0x244e748 <a.cpp:1:1, col:59> col:25 C\n"
+                             "| |-TemplateTypeParmDecl 0x244e5f8 <col:10, col:16> col:16 referenced class depth 0 index 0 T\n"
+                             "| |-CXXRecordDecl 0x244e6b0 <col:19, col:59> col:25 class C definition\n"
+                             "| | |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init\n"
+                             "| | | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr\n"
+                             "| | | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param\n"
+                             "| | | |-MoveConstructor exists simple trivial needs_implicit\n"
+                             "| | | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param\n"
+                             "| | | |-MoveAssignment exists simple trivial needs_implicit\n"
+                             "| | | `-Destructor simple irrelevant trivial needs_implicit\n"
+                             "| | |-CXXRecordDecl 0x244e9b0 <col:19, col:25> col:25 implicit class C\n"
+                             "| | |-AccessSpecDecl 0x244ea48 <col:29, col:35> col:29 public\n"
+                             "| | `-CXXMethodDecl 0x244eb20 <col:37, col:57> col:39 foo 'T ()'\n"
+                             "| |   `-CompoundStmt 0x244ec18 <col:45, col:57>\n"
+                             "| |     `-ReturnStmt 0x244ec00 <col:47, col:54>\n"
+                             "| |       `-IntegerLiteral 0x244ebe0 <col:54> 'int' 0\n"
+                             "| `-ClassTemplateSpecializationDecl 0x244ed78 <col:1, col:59> col:25 class C definition\n"
+                             "|   |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init\n"
+                             "|   | |-DefaultConstructor exists trivial constexpr defaulted_is_constexpr\n"
+                             "|   | |-CopyConstructor simple trivial has_const_param implicit_has_const_param\n"
+                             "|   | |-MoveConstructor exists simple trivial\n"
+                             "|   | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param\n"
+                             "|   | |-MoveAssignment exists simple trivial needs_implicit\n"
+                             "|   | `-Destructor simple irrelevant trivial needs_implicit\n"
+                             "|   |-TemplateArgument type 'int'\n"
+                             "|   |-CXXRecordDecl 0x244eff0 prev 0x244ed78 <col:19, col:25> col:25 implicit class C\n"
+                             "|   |-AccessSpecDecl 0x244f088 <col:29, col:35> col:29 public\n"
+                             "|   |-CXXMethodDecl 0x244f160 <col:37, col:57> col:39 used foo 'int ()'\n"
+                             "|   | `-CompoundStmt 0x247cb40 <col:45, col:57>\n"
+                             "|   |   `-ReturnStmt 0x247cb28 <col:47, col:54>\n"
+                             "|   |     `-IntegerLiteral 0x244ebe0 <col:54> 'int' 0\n"
+                             "|   |-CXXConstructorDecl 0x247c540 <col:25> col:25 implicit used constexpr C 'void () noexcept' inline default trivial\n"
+                             "|   | `-CompoundStmt 0x247ca00 <col:25>\n"
+                             "|   |-CXXConstructorDecl 0x247c658 <col:25> col:25 implicit constexpr C 'void (const C<int> &)' inline default trivial noexcept-unevaluated 0x247c658\n"
+                             "|   | `-ParmVarDecl 0x247c790 <col:25> col:25 'const C<int> &'\n"
+                             "|   `-CXXConstructorDecl 0x247c828 <col:25> col:25 implicit constexpr C 'void (C<int> &&)' inline default trivial noexcept-unevaluated 0x247c828\n"
+                             "|     `-ParmVarDecl 0x247c960 <col:25> col:25 'C<int> &&'\n";
+        ASSERT_EQUALS("class C { int foo ( ) { return 0 ; } C ( ) { } C ( const C<int> & ) = default ; C ( C<int> && ) = default ; } ;", parse(clang));
+    }
+
+    void conditionalExpr() {
+        const char clang[] = "`-VarDecl 0x257cc88 <a.cpp:4:1, col:13> col:5 x 'int' cinit\n"
+                             "  `-ConditionalOperator 0x257cda8 <col:9, col:13> 'int'\n"
+                             "    |-ImplicitCastExpr 0x257cd60 <col:9> 'int' <LValueToRValue>\n"
+                             "    | `-DeclRefExpr 0x257cce8 <col:9> 'int' lvalue Var 0x257cae0 'a' 'int'\n"
+                             "    |-ImplicitCastExpr 0x257cd78 <col:11> 'int' <LValueToRValue>\n"
+                             "    | `-DeclRefExpr 0x257cd10 <col:11> 'int' lvalue Var 0x257cb98 'b' 'int'\n"
+                             "    `-ImplicitCastExpr 0x257cd90 <col:13> 'int' <LValueToRValue>\n"
+                             "      `-DeclRefExpr 0x257cd38 <col:13> 'int' lvalue Var 0x257cc10 'c' 'int'";
+        ASSERT_EQUALS("int x@1 = a ? b : c ;", parse(clang));
+    }
+
+    void compoundAssignOperator() {
+        const char clang[] = "`-FunctionDecl 0x3570690 <1.cpp:2:1, col:25> col:6 f 'void ()'\n"
+                             "  `-CompoundStmt 0x3570880 <col:10, col:25>\n"
+                             "    `-CompoundAssignOperator 0x3570848 <col:19, col:22> 'int' lvalue '+=' ComputeLHSTy='int' ComputeResultTy='int'\n"
+                             "      |-DeclRefExpr 0x3570800 <col:19> 'int' lvalue Var 0x3570788 'x' 'int'\n"
+                             "      `-IntegerLiteral 0x3570828 <col:22> 'int' 1";
+        ASSERT_EQUALS("void f ( ) { x += 1 ; }", parse(clang));
+    }
+
+    void continueStmt() {
+        const char clang[] = "`-FunctionDecl 0x2c31b18 <1.c:1:1, col:34> col:6 foo 'void ()'\n"
+                             "  `-CompoundStmt 0x2c31c40 <col:12, col:34>\n"
+                             "    `-WhileStmt 0x2c31c20 <col:14, col:24>\n"
+                             "      |-<<<NULL>>>\n"
+                             "      |-IntegerLiteral 0x2c31bf8 <col:21> 'int' 0\n"
+                             "      `-ContinueStmt 0x2c31c18 <col:24>";
+        ASSERT_EQUALS("void foo ( ) { while ( 0 ) { continue ; } }", parse(clang));
+    }
+
+    void cstyleCastExpr() {
+        const char clang[] = "`-VarDecl 0x2336aa0 <1.c:1:1, col:14> col:5 x 'int' cinit\n"
+                             "  `-CStyleCastExpr 0x2336b70 <col:9, col:14> 'int' <NoOp>\n"
+                             "    `-CharacterLiteral 0x2336b40 <col:14> 'int' 97";
+        ASSERT_EQUALS("int x@1 = ( int ) 'a' ;", parse(clang));
+    }
+
+    void cxxBoolLiteralExpr() {
+        const char clang[] = "`-VarDecl 0x3940608 <a.cpp:1:1, col:10> col:6 x 'bool' cinit\n"
+                             "  `-CXXBoolLiteralExpr 0x39406a8 <col:10> 'bool' true";
+        ASSERT_EQUALS("bool x@1 = true ;", parse(clang));
+    }
+
+    void cxxConstructorDecl1() {
+        const char clang[] = "|-CXXConstructorDecl 0x428e890 <a.cpp:11:1, col:24> col:11 C 'void ()'\n"
+                             "| `-CompoundStmt 0x428ea58 <col:15, col:24>\n"
+                             "|   `-BinaryOperator 0x428ea30 <col:17, col:21> 'int' lvalue '='\n"
+                             "|     |-MemberExpr 0x428e9d8 <col:17> 'int' lvalue ->x 0x428e958\n"
+                             "|     | `-CXXThisExpr 0x428e9c0 <col:17> 'C *' this\n"
+                             "|     `-IntegerLiteral 0x428ea10 <col:21> 'int' 0\n"
+                             "`-FieldDecl 0x428e958 <col:26, col:30> col:30 referenced x 'int'";
+        ASSERT_EQUALS("C ( ) { this . x@1 = 0 ; } int x@1", parse(clang));
+    }
+
+    void cxxConstructorDecl2() {
+        const char clang[] = "`-CXXConstructorDecl 0x1c208c0 <a.cpp:1:11> col:11 implicit constexpr basic_string 'void (std::basic_string<char> &&)' inline default trivial noexcept-unevaluated 0x1c208c0\n"
+                             "  `-ParmVarDecl 0x1c209f0 <col:11> col:11 'std::basic_string<char> &&'";
+        ASSERT_EQUALS("basic_string ( std::basic_string<char> && ) = default ;", parse(clang));
+    }
+
+    void cxxConstructExpr1() {
+        const char clang[] = "`-FunctionDecl 0x2dd7940 <a.cpp:2:1, col:30> col:5 f 'Foo (Foo)'\n"
+                             "  |-ParmVarDecl 0x2dd7880 <col:7, col:11> col:11 used foo 'Foo'\n"
+                             "  `-CompoundStmt 0x2dd80c0 <col:16, col:30>\n"
+                             "    `-ReturnStmt 0x2dd80a8 <col:18, col:25>\n"
+                             "      `-CXXConstructExpr 0x2dd8070 <col:25> 'Foo' 'void (Foo &&) noexcept'\n"
+                             "        `-ImplicitCastExpr 0x2dd7f28 <col:25> 'Foo' xvalue <NoOp>\n"
+                             "          `-DeclRefExpr 0x2dd7a28 <col:25> 'Foo' lvalue ParmVar 0x2dd7880 'foo' 'Foo'";
+        ASSERT_EQUALS("Foo f ( Foo foo@1 ) { return foo@1 ; }", parse(clang));
+    }
+
+    void cxxConstructExpr2() {
+        const char clang[] = "`-FunctionDecl 0x3e44180 <1.cpp:2:1, col:30> col:13 f 'std::string ()'\n"
+                             "  `-CompoundStmt 0x3e4cb80 <col:17, col:30>\n"
+                             "    `-ReturnStmt 0x3e4cb68 <col:19, col:27>\n"
+                             "      `-CXXConstructExpr 0x3e4cb38 <col:26, col:27> 'std::string':'std::__cxx11::basic_string<char>' '....' list";
+        ASSERT_EQUALS("std :: string f ( ) { return std :: string ( ) ; }", parse(clang));
+    }
+
+    void cxxConstructExpr3() {
+        const char clang[] = "`-FunctionDecl 0x2c585b8 <1.cpp:4:1, col:39> col:6 f 'void ()'\n"
+                             "  `-CompoundStmt 0x2c589d0 <col:10, col:39>\n"
+                             "    |-DeclStmt 0x2c586d0 <col:12, col:19>\n"
+                             "    | `-VarDecl 0x2c58670 <col:12, col:18> col:18 used p 'char *'\n"
+                             "    `-DeclStmt 0x2c589b8 <col:21, col:37>\n"
+                             "      `-VarDecl 0x2c58798 <col:21, col:36> col:33 s 'std::string':'std::__cxx11::basic_string<char>' callinit\n"
+                             "        `-ExprWithCleanups 0x2c589a0 <col:33, col:36> 'std::string':'std::__cxx11::basic_string<char>'\n"
+                             "          `-CXXConstructExpr 0x2c58960 <col:33, col:36> 'std::string':'std::__cxx11::basic_string<char>' 'void (const char *, const std::allocator<char> &)'\n"
+                             "            |-ImplicitCastExpr 0x2c58870 <col:35> 'const char *' <NoOp>\n"
+                             "            | `-ImplicitCastExpr 0x2c58858 <col:35> 'char *' <LValueToRValue>\n"
+                             "            |   `-DeclRefExpr 0x2c58750 <col:35> 'char *' lvalue Var 0x2c58670 'p' 'char *'\n"
+                             "            `-CXXDefaultArgExpr 0x2c58940 <<invalid sloc>> 'const std::allocator<char>':'const std::allocator<char>' lvalue\n";
+        ASSERT_EQUALS("void f ( ) { char * p@1 ; std :: string s@2 ( p@1 ) ; }", parse(clang));
+    }
+
+    void cxxDeleteExpr() {
+        const char clang[] = "|-FunctionDecl 0x2e0e740 <1.cpp:1:1, col:28> col:6 f 'void (int *)'\n"
+                             "| |-ParmVarDecl 0x2e0e680 <col:8, col:13> col:13 used p 'int *'\n"
+                             "| `-CompoundStmt 0x2e0ee70 <col:16, col:28>\n"
+                             "|   `-CXXDeleteExpr 0x2e0ee48 <col:18, col:25> 'void' Function 0x2e0ebb8 'operator delete' 'void (void *) noexcept'\n"
+                             "|     `-ImplicitCastExpr 0x2e0e850 <col:25> 'int *' <LValueToRValue>\n"
+                             "|       `-DeclRefExpr 0x2e0e828 <col:25> 'int *' lvalue ParmVar 0x2e0e680 'p' 'int *'";
+        ASSERT_EQUALS("void f ( int * p@1 ) { delete p@1 ; }", parse(clang));
+    }
+
+    void cxxDestructorDecl() {
+        const char clang[] = "`-CXXRecordDecl 0x8ecd60 <1.cpp:1:1, line:4:1> line:1:8 struct S definition\n"
+                             "  `-CXXDestructorDecl 0x8ed088 <line:3:3, col:9> col:3 ~S 'void () noexcept'\n"
+                             "    `-CompoundStmt 0x8ed1a8 <col:8, col:9>";
+        ASSERT_EQUALS("struct S { ~S ( ) { } } ;", parse(clang));
+    }
+
+    void cxxForRangeStmt1() {
+        const char clang[] = "`-FunctionDecl 0x4280820 <a.cpp:4:1, line:8:1> line:4:6 foo 'void ()'\n"
+                             "  `-CompoundStmt 0x42810f0 <col:12, line:8:1>\n"
+                             "    `-CXXForRangeStmt 0x4281090 <line:5:3, line:7:3>\n"
+                             "      |-DeclStmt 0x4280c30 <line:5:17>\n"
+                             "      | `-VarDecl 0x42809c8 <col:17> col:17 implicit referenced __range1 'char const (&)[6]' cinit\n"
+                             "      |   `-DeclRefExpr 0x42808c0 <col:17> 'const char [6]' lvalue Var 0x4280678 'hello' 'const char [6]'\n"
+                             "      |-DeclStmt 0x4280ef8 <col:15>\n"
+                             "      | `-VarDecl 0x4280ca8 <col:15> col:15 implicit used __begin1 'const char *':'const char *' cinit\n"
+                             "      |   `-ImplicitCastExpr 0x4280e10 <col:15> 'const char *' <ArrayToPointerDecay>\n"
+                             "      |     `-DeclRefExpr 0x4280c48 <col:15> 'char const[6]' lvalue Var 0x42809c8 '__range1' 'char const (&)[6]'\n"
+                             "      |-DeclStmt 0x4280f10 <col:15>\n"
+                             "      | `-VarDecl 0x4280d18 <col:15, col:17> col:15 implicit used __end1 'const char *':'const char *' cinit\n"
+                             "      |   `-BinaryOperator 0x4280e60 <col:15, col:17> 'const char *' '+'\n"
+                             "      |     |-ImplicitCastExpr 0x4280e48 <col:15> 'const char *' <ArrayToPointerDecay>\n"
+                             "      |     | `-DeclRefExpr 0x4280c70 <col:15> 'char const[6]' lvalue Var 0x42809c8 '__range1' 'char const (&)[6]'\n"
+                             "      |     `-IntegerLiteral 0x4280e28 <col:17> 'long' 6\n"
+                             "      |-BinaryOperator 0x4280fa8 <col:15> 'bool' '!='\n"
+                             "      | |-ImplicitCastExpr 0x4280f78 <col:15> 'const char *':'const char *' <LValueToRValue>\n"
+                             "      | | `-DeclRefExpr 0x4280f28 <col:15> 'const char *':'const char *' lvalue Var 0x4280ca8 '__begin1' 'const char *':'const char *'\n"
+                             "      | `-ImplicitCastExpr 0x4280f90 <col:15> 'const char *':'const char *' <LValueToRValue>\n"
+                             "      |   `-DeclRefExpr 0x4280f50 <col:15> 'const char *':'const char *' lvalue Var 0x4280d18 '__end1' 'const char *':'const char *'\n"
+                             "      |-UnaryOperator 0x4280ff8 <col:15> 'const char *':'const char *' lvalue prefix '++'\n"
+                             "      | `-DeclRefExpr 0x4280fd0 <col:15> 'const char *':'const char *' lvalue Var 0x4280ca8 '__begin1' 'const char *':'const char *'\n"
+                             "      |-DeclStmt 0x4280958 <col:8, col:22>\n"
+                             "      | `-VarDecl 0x42808f8 <col:8, col:15> col:13 c1 'char' cinit\n"
+                             "      |   `-ImplicitCastExpr 0x4281078 <col:15> 'char' <LValueToRValue>\n"
+                             "      |     `-UnaryOperator 0x4281058 <col:15> 'const char' lvalue prefix '*' cannot overflow\n"
+                             "      |       `-ImplicitCastExpr 0x4281040 <col:15> 'const char *':'const char *' <LValueToRValue>\n"
+                             "      |         `-DeclRefExpr 0x4281018 <col:15> 'const char *':'const char *' lvalue Var 0x4280ca8 '__begin1' 'const char *':'const char *'\n"
+                             "      `-CompoundStmt 0x42810e0 <col:24, line:7:3>";
+        ASSERT_EQUALS("void foo ( ) { for ( char c1@1 : hello ) { } }",
+                      parse(clang));
+    }
+
+    void cxxForRangeStmt2() {
+        // clang 9
+        const char clang[] = "`-FunctionDecl 0xc15d98 <a.cpp:3:1, col:36> col:6 foo 'void ()'\n"
+                             "  `-CompoundStmt 0xc16668 <col:12, col:36>\n"
+                             "    `-CXXForRangeStmt 0xc165f8 <col:14, col:34>\n"
+                             "      |-<<<NULL>>>\n"
+                             "      |-DeclStmt 0xc161c0 <col:25>\n"
+                             "      | `-VarDecl 0xc15f48 <col:25> col:25 implicit referenced __range1 'int const (&)[4]' cinit\n"
+                             "      |   `-DeclRefExpr 0xc15e38 <col:25> 'const int [4]' lvalue Var 0xc15ac0 'values' 'const int [4]'\n"
+                             "      |-DeclStmt 0xc16498 <col:24>\n"
+                             "      | `-VarDecl 0xc16228 <col:24> col:24 implicit used __begin1 'const int *':'const int *' cinit\n"
+                             "      |   `-ImplicitCastExpr 0xc163b0 <col:24> 'const int *' <ArrayToPointerDecay>\n"
+                             "      |     `-DeclRefExpr 0xc161d8 <col:24> 'int const[4]' lvalue Var 0xc15f48 '__range1' 'int const (&)[4]' non_odr_use_constant\n"
+                             "      |-DeclStmt 0xc164b0 <col:24>\n"
+                             "      | `-VarDecl 0xc162a0 <col:24, col:25> col:24 implicit used __end1 'const int *':'const int *' cinit\n"
+                             "      |   `-BinaryOperator 0xc16400 <col:24, col:25> 'const int *' '+'\n"
+                             "      |     |-ImplicitCastExpr 0xc163e8 <col:24> 'const int *' <ArrayToPointerDecay>\n"
+                             "      |     | `-DeclRefExpr 0xc161f8 <col:24> 'int const[4]' lvalue Var 0xc15f48 '__range1' 'int const (&)[4]' non_odr_use_constant\n"
+                             "      |     `-IntegerLiteral 0xc163c8 <col:25> 'long' 4\n"
+                             "      |-BinaryOperator 0xc16538 <col:24> 'bool' '!='\n"
+                             "      | |-ImplicitCastExpr 0xc16508 <col:24> 'const int *':'const int *' <LValueToRValue>\n"
+                             "      | | `-DeclRefExpr 0xc164c8 <col:24> 'const int *':'const int *' lvalue Var 0xc16228 '__begin1' 'const int *':'const int *'\n"
+                             "      | `-ImplicitCastExpr 0xc16520 <col:24> 'const int *':'const int *' <LValueToRValue>\n"
+                             "      |   `-DeclRefExpr 0xc164e8 <col:24> 'const int *':'const int *' lvalue Var 0xc162a0 '__end1' 'const int *':'const int *'\n"
+                             "      |-UnaryOperator 0xc16578 <col:24> 'const int *':'const int *' lvalue prefix '++'\n"
+                             "      | `-DeclRefExpr 0xc16558 <col:24> 'const int *':'const int *' lvalue Var 0xc16228 '__begin1' 'const int *':'const int *'\n"
+                             "      |-DeclStmt 0xc15ed8 <col:19, col:31>\n"
+                             "      | `-VarDecl 0xc15e70 <col:19, col:24> col:23 v 'int' cinit\n"
+                             "      |   `-ImplicitCastExpr 0xc165e0 <col:24> 'int' <LValueToRValue>\n"
+                             "      |     `-UnaryOperator 0xc165c8 <col:24> 'const int' lvalue prefix '*' cannot overflow\n"
+                             "      |       `-ImplicitCastExpr 0xc165b0 <col:24> 'const int *':'const int *' <LValueToRValue>\n"
+                             "      |         `-DeclRefExpr 0xc16590 <col:24> 'const int *':'const int *' lvalue Var 0xc16228 '__begin1' 'const int *':'const int *'\n"
+                             "      `-CompoundStmt 0xc16658 <col:33, col:34>";
+        ASSERT_EQUALS("void foo ( ) { for ( int v@1 : values ) { } }",
+                      parse(clang));
+    }
+
+    void cxxFunctionalCastExpr() {
+        const char clang[] = "`-FunctionDecl 0x156fe98 <a.cpp:1:1, line:3:1> line:1:5 main 'int (int, char **)'\n"
+                             "  |-ParmVarDecl 0x156fd00 <col:10, col:14> col:14 argc 'int'\n"
+                             "  |-ParmVarDecl 0x156fdb8 <col:20, col:27> col:27 argv 'char **'\n"
+                             "  `-CompoundStmt 0x1596410 <line:2:1, line:2:1>\n"
+                             "    |-DeclStmt 0x15946a8 <line:2:15, line:2:29>\n"
+                             "    | `-VarDecl 0x1570118 <line:2:15, line:2:28> col:11 used setCode 'MyVar<int>':'MyVar<int>' cinit\n"
+                             "    |   `-ExprWithCleanups 0x1594690 <line:2:15, line:3:28> 'MyVar<int>':'MyVar<int>'\n"
+                             "    |     `-CXXConstructExpr 0x1594660 <line:2:15, line:3:28> 'MyVar<int>':'MyVar<int>' 'void (MyVar<int> &&) noexcept' elidable\n"
+                             "    |       `-MaterializeTemporaryExpr 0x1592b68 <line:2:15, line:3:28> 'MyVar<int>':'MyVar<int>' xvalue\n"
+                             "    |         `-CXXFunctionalCastExpr 0x1592b40 <line:2:15, line:3:28> 'MyVar<int>':'MyVar<int>' functional cast to MyVar<int> <ConstructorConversion>\n"
+                             "    |           `-CXXConstructExpr 0x15929f0 <line:2:15, line:3:28> 'MyVar<int>':'MyVar<int>' 'void (int)'\n"
+                             "    |             `-IntegerLiteral 0x1570248 <col:27> 'int' 5\n";
+        ASSERT_EQUALS("int main ( int argc@1 , char * * argv@2 ) { MyVar<int> setCode@3 = MyVar<int> ( 5 ) ; }",
+                      parse(clang));
+    }
+
+    void cxxMemberCall() {
+        const char clang[] = "`-FunctionDecl 0x320dc80 <a.cpp:2:1, col:33> col:6 bar 'void ()'\n"
+                             "  `-CompoundStmt 0x323bb08 <col:12, col:33>\n"
+                             "    |-DeclStmt 0x323ba40 <col:14, col:22>\n"
+                             "    | `-VarDecl 0x320df28 <col:14, col:21> col:21 used c 'C<int>':'C<int>' callinit\n"
+                             "    |   `-CXXConstructExpr 0x323ba10 <col:21> 'C<int>':'C<int>' 'void () noexcept'\n"
+                             "    `-CXXMemberCallExpr 0x323bab8 <col:24, col:30> 'int':'int'\n"
+                             "      `-MemberExpr 0x323ba80 <col:24, col:26> '<bound member function type>' .foo 0x320e160\n"
+                             "        `-DeclRefExpr 0x323ba58 <col:24> 'C<int>':'C<int>' lvalue Var 0x320df28 'c' 'C<int>':'C<int>'";
+        ASSERT_EQUALS("void bar ( ) { C<int> c@1 ( C<int> ( ) ) ; c@1 . foo ( ) ; }", parse(clang));
+    }
+
+    void cxxMethodDecl1() {
+        const char clang[] = "|-CXXMethodDecl 0x55c786f5ad60 <a.cpp:56:5, col:179> col:10 analyzeFile '_Bool (const std::string &, const std::string &, const std::string &, unsigned long long, std::list<ErrorLogger::ErrorMessage> *)'\n"
+                             "| |-ParmVarDecl 0x55c786f5a4c8 <col:22, col:41> col:41 buildDir 'const std::string &'\n"
+                             "| |-ParmVarDecl 0x55c786f5a580 <col:51, col:70> col:70 sourcefile 'const std::string &'\n"
+                             "| |-ParmVarDecl 0x55c786f5a638 <col:82, col:101> col:101 cfg 'const std::string &'\n"
+                             "| |-ParmVarDecl 0x55c786f5a6a8 <col:106, col:125> col:125 checksum 'unsigned long long'\n"
+                             "| |-ParmVarDecl 0x55c786f5ac00 <col:135, col:173> col:173 errors 'std::list<ErrorLogger::ErrorMessage> *'\n"
+                             "  `-CompoundStmt 0x0 <>";
+        ASSERT_EQUALS("_Bool analyzeFile ( const std :: string & buildDir@1 , const std :: string & sourcefile@2 , const std :: string & cfg@3 , unsigned long long checksum@4 , std::list<ErrorLogger::ErrorMessage> * errors@5 ) { }", parse(clang));
+    }
+
+    void cxxMethodDecl2() { // "unexpanded" template method
+        const char clang[] = "`-CXXMethodDecl 0x220ecb0 parent 0x21e4c28 prev 0x21e5338 <a.cpp:11:1, line:18:1> line:14:1 find 'const typename char_traits<_CharT>::char_type *(const char_traits::char_type *, int, const char_traits::char_type &)'\n"
+                             "  `-CompoundStmt 0x220ede0 <line:15:1, line:18:1>\n"
+                             "    `-ReturnStmt 0x220edd0 <line:17:5, col:12>\n"
+                             "      `-IntegerLiteral 0x220edb0 <col:12> 'int' 0";
+        ASSERT_EQUALS("", parse(clang));
+    }
+
+    void cxxMethodDecl3() {
+        const char clang[] = "|-CXXRecordDecl 0x21cca40 <2.cpp:2:1, line:4:1> line:2:7 class Fred definition\n"
+                             "| |-DefinitionData pass_in_registers empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init\n"
+                             "| | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr\n"
+                             "| | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param\n"
+                             "| | |-MoveConstructor exists simple trivial needs_implicit\n"
+                             "| | |-CopyAssignment trivial has_const_param needs_implicit implicit_has_const_param\n"
+                             "| | |-MoveAssignment exists simple trivial needs_implicit\n"
+                             "| | `-Destructor simple irrelevant trivial needs_implicit\n"
+                             "| |-CXXRecordDecl 0x21ccb58 <col:1, col:7> col:7 implicit class Fred\n"
+                             "| `-CXXMethodDecl 0x21ccc68 <line:3:1, col:10> col:6 foo 'void ()'\n"
+                             "`-CXXMethodDecl 0x21ccd60 parent 0x21cca40 prev 0x21ccc68 <line:6:1, col:19> col:12 foo 'void ()'\n"
+                             "  `-CompoundStmt 0x21cce50 <col:18, col:19>";
+        ASSERT_EQUALS("class Fred { void foo ( ) ; } ; void Fred :: foo ( ) { }", parse(clang));
+    }
+
+    void cxxMethodDecl4() {
+        const char clang[] = "|-ClassTemplateSpecializationDecl 0x15d82f8 <a.cpp:7:3, line:18:3> line:8:12 struct char_traits definition\n"
+                             "| |-TemplateArgument type 'char'\n"
+                             "| | `-BuiltinType 0x15984c0 'char'\n"
+                             "| |-CXXRecordDecl 0x15d8520 <col:5, col:12> col:12 implicit struct char_traits\n"
+                             "| |-CXXMethodDecl 0x15d8738 <line:12:7, line:16:7> line:13:7 move 'char *(char *)' static\n"
+                             "| | |-ParmVarDecl 0x15d8630 <col:12, col:18> col:18 used __s1 'char *'\n"
+                             "| | `-CompoundStmt 0x15d88e8 <line:14:7, line:16:7>\n";
+        ASSERT_EQUALS("struct char_traits<char> { static char * move ( char * __s1@1 ) { } } ;",
+                      parse(clang));
+    }
+
+    void cxxNewExpr1() {
+        const char clang[] = "|-VarDecl 0x3a97680 <1.cpp:2:1, col:14> col:6 i 'int *' cinit\n"
+                             "| `-CXXNewExpr 0x3a97d18 <col:10, col:14> 'int *' Function 0x3a97778 'operator new' 'void *(unsigned long)'\n"
+                             "`-VarDecl 0x3a97d80 <line:3:1, col:21> col:6 j 'int *' cinit\n"
+                             "  `-CXXNewExpr 0x3a97e68 <col:10, col:21> 'int *' array Function 0x3a978c0 'operator new[]' 'void *(unsigned long)'\n"
+                             "    `-ImplicitCastExpr 0x3a97e18 <col:18> 'unsigned long' <IntegralCast>\n"
+                             "      `-IntegerLiteral 0x3a97de0 <col:18> 'int' 100";
+        ASSERT_EQUALS("int * i@1 = new int ; int * j@2 = new int [ 100 ] ;",
+                      parse(clang));
+    }
+
+    void cxxNewExpr2() {
+        const char clang[] = "|-FunctionDecl 0x59a188 <a.cpp:7:1, line:9:1> line:7:11 f 'struct S *()'\n"
+                             "| `-CompoundStmt 0x5c4318 <col:15, line:9:1>\n"
+                             "|   `-ReturnStmt 0x5c4308 <line:8:3, col:14>\n"
+                             "|     `-CXXNewExpr 0x5c42c8 <col:10, col:14> 'S *' Function 0x59a378 'operator new' 'void *(unsigned long)'\n"
+                             "|       `-CXXConstructExpr 0x5c42a0 <col:14> 'S' 'void () noexcept'";
+        ASSERT_EQUALS("struct S * f ( ) { return new S ( ) ; }",
+                      parse(clang));
+    }
+
+    void cxxNullPtrLiteralExpr() {
+        const char clang[] = "`-VarDecl 0x2a7d650 <1.cpp:1:1, col:17> col:13 p 'const char *' cinit\n"
+                             "  `-ImplicitCastExpr 0x2a7d708 <col:17> 'const char *' <NullToPointer>\n"
+                             "    `-CXXNullPtrLiteralExpr 0x2a7d6f0 <col:17> 'nullptr_t'";
+        ASSERT_EQUALS("const char * p@1 = nullptr ;", parse(clang));
+    }
+
+    void cxxOperatorCallExpr() {
+        const char clang[] = "`-FunctionDecl 0x3c099f0 <a.cpp:2:1, col:24> col:6 foo 'void ()'\n"
+                             "  `-CompoundStmt 0x3c37308 <col:12, col:24>\n"
+                             "    |-DeclStmt 0x3c0a060 <col:14, col:17>\n"
+                             "    | `-VarDecl 0x3c09ae0 <col:14, col:16> col:16 used c 'C' callinit\n"
+                             "    |   `-CXXConstructExpr 0x3c0a030 <col:16> 'C' 'void () noexcept'\n"
+                             "    `-CXXOperatorCallExpr 0x3c372c0 <col:19, col:21> 'void'\n"
+                             "      |-ImplicitCastExpr 0x3c372a8 <col:20> 'void (*)(int)' <FunctionToPointerDecay>\n"
+                             "      | `-DeclRefExpr 0x3c37250 <col:20> 'void (int)' lvalue CXXMethod 0x3c098c0 'operator=' 'void (int)'\n"
+                             "      |-DeclRefExpr 0x3c0a078 <col:19> 'C' lvalue Var 0x3c09ae0 'c' 'C'\n"
+                             "      `-IntegerLiteral 0x3c0a0a0 <col:21> 'int' 4";
+        ASSERT_EQUALS("void foo ( ) { C c@1 ( C ( ) ) ; c@1 . operator= ( 4 ) ; }", parse(clang));
+    }
+
+    void cxxRecordDecl1() {
+        const char* clang = "`-CXXRecordDecl 0x34cc5f8 <1.cpp:2:1, col:7> col:7 class Foo";
+        ASSERT_EQUALS("class Foo ;", parse(clang));
+
+        clang = "`-CXXRecordDecl 0x34cc5f8 <C:\\Foo\\Bar Baz\\1.cpp:2:1, col:7> col:7 class Foo";
+        ASSERT_EQUALS("class Foo ;", parse(clang));
+
+        clang = "`-CXXRecordDecl 0x34cc5f8 <C:/Foo/Bar Baz/1.cpp:2:1, col:7> col:7 class Foo";
+        ASSERT_EQUALS("class Foo ;", parse(clang));
+    }
+
+    void cxxRecordDecl2() {
+        const char clang[] = "`-CXXRecordDecl 0x34cc5f8 <1.cpp:2:1, col:7> col:7 struct Foo definition";
+        ASSERT_EQUALS("struct Foo { } ;", parse(clang));
+    }
+
+    void cxxRecordDeclDerived() {
+        const char clang[] = "|-CXXRecordDecl 0x19ccd38 <e.cpp:4:1, line:6:1> line:4:8 referenced struct base definition\n"
+                             "| `-VarDecl 0x19ccf00 <line:5:5, col:35> col:27 value 'const bool' static constexpr cinit\n"
+                             "|   |-value: Int 0\n"
+                             "|   `-CXXBoolLiteralExpr 0x19ccf68 <col:35> 'bool' false\n"
+                             "`-CXXRecordDecl 0x19ccfe8 <line:8:1, col:32> col:8 struct derived definition\n"
+                             "  |-public 'base'\n"
+                             "  `-CXXRecordDecl 0x19cd150 <col:1, col:8> col:8 implicit struct derived";
+
+        ASSERT_EQUALS("struct base { static const bool value@1 = false ; } ; struct derived : public base { } ;", parse(clang));
+    }
+
+    void cxxStaticCastExpr1() {
+        const char clang[] = "`-VarDecl 0x2e0e650 <a.cpp:2:1, col:27> col:5 a 'int' cinit\n"
+                             "  `-CXXStaticCastExpr 0x2e0e728 <col:9, col:27> 'int' static_cast<int> <NoOp>\n"
+                             "    `-IntegerLiteral 0x2e0e6f0 <col:26> 'int' 0";
+        ASSERT_EQUALS("int a@1 = static_cast<int> ( 0 ) ;", parse(clang));
+    }
+
+    void cxxStaticCastExpr2() {
+        const char clang[] = "`-VarDecl 0x2e0e650 <a.cpp:2:1, col:27> col:5 a 'int' cinit\n"
+                             "  `-CXXStaticCastExpr 0x3e453e8 <col:12> 'std::_Rb_tree_iterator<std::pair<const std::__cxx11::basic_string<char>, Library::AllocFunc> >' xvalue static_cast<struct std::_Rb_tree_iterator<struct std::pair<const class std::__cxx11::basic_string<char>, struct Library::AllocFunc> > &&> <NoOp>\n"
+                             "    `-DeclRefExpr 0x3e453b0 <col:12> 'std::_Rb_tree_iterator<std::pair<const std::__cxx11::basic_string<char>, Library::AllocFunc> >' lvalue ParmVar 0x3e45250 '' 'std::_Rb_tree_iterator<std::pair<const std::__cxx11::basic_string<char>, Library::AllocFunc> > &&'";
+        ASSERT_EQUALS("int a@1 = static_cast<structstd::_Rb_tree_iterator<structstd::pair<constclassstd::__cxx11::basic_string<char>,structLibrary::AllocFunc>>&&> ( <NoName> ) ;", parse(clang));
+    }
+
+    void cxxStaticCastExpr3() {
+        const char clang[] = "`-ClassTemplateSpecializationDecl 0xd842d8 <a.cpp:4:3, line:7:3> line:4:21 struct char_traits definition\n"
+                             "  |-TemplateArgument type 'char'\n"
+                             "  | `-BuiltinType 0xd444c0 'char'\n"
+                             "  |-CXXRecordDecl 0xd84500 <col:14, col:21> col:21 implicit struct char_traits\n"
+                             "  |-TypedefDecl 0xd845a0 <line:5:7, col:20> col:20 referenced char_type 'char'\n"
+                             "  | `-BuiltinType 0xd444c0 'char'\n"
+                             "  `-CXXMethodDecl 0xd847b0 <line:6:7, col:80> col:18 assign 'char_traits<char>::char_type *(char_traits<char>::char_type *)'\n"
+                             "    |-ParmVarDecl 0xd84670 <col:25, col:36> col:36 used __s 'char_traits<char>::char_type *'\n"
+                             "    `-CompoundStmt 0xd848f8 <col:41, col:80>\n"
+                             "      `-ReturnStmt 0xd848e8 <col:43, col:77>\n"
+                             "        `-CXXStaticCastExpr 0xd848b8 <col:50, col:77> 'char_traits<char>::char_type *' static_cast<char_traits<char>::char_type *> <NoOp>\n"
+                             "          `-ImplicitCastExpr 0xd848a0 <col:74> 'char_traits<char>::char_type *' <LValueToRValue> part_of_explicit_cast\n"
+                             "            `-DeclRefExpr 0xd84870 <col:74> 'char_traits<char>::char_type *' lvalue ParmVar 0xd84670 '__s' 'char_traits<char>::char_type *'\n";
+
+        ASSERT_EQUALS("struct char_traits<char> { typedef char char_type ; char_traits<char>::char_type * assign ( char_traits<char>::char_type * __s@1 ) { return static_cast<char_traits<char>::char_type*> ( __s@1 ) ; } } ;", parse(clang));
+    }
+
+    void cxxStdInitializerListExpr() {
+        const char clang[] = "`-VarDecl 0x2f92060 <1.cpp:3:1, col:25> col:18 x 'std::vector<int>':'std::vector<int, std::allocator<int> >' listinit\n"
+                             "  `-ExprWithCleanups 0x2fb0b40 <col:18, col:25> 'std::vector<int>':'std::vector<int, std::allocator<int> >'\n"
+                             "    `-CXXConstructExpr 0x2fb0b00 <col:18, col:25> 'std::vector<int>':'std::vector<int, std::allocator<int> >' 'void (initializer_list<std::vector<int, std::allocator<int> >::value_type>, const std::vector<int, std::allocator<int> >::allocator_type &)' list std::initializer_list\n"
+                             "      |-CXXStdInitializerListExpr 0x2fb0928 <col:19, col:25> 'initializer_list<std::vector<int, std::allocator<int> >::value_type>':'std::initializer_list<int>'\n"
+                             "      | `-MaterializeTemporaryExpr 0x2fb0910 <col:19, col:25> 'const int [3]' xvalue\n"
+                             "      |   `-InitListExpr 0x2fb08b8 <col:19, col:25> 'const int [3]'\n"
+                             "      |     |-IntegerLiteral 0x2f920c0 <col:20> 'int' 1\n"
+                             "      |     |-IntegerLiteral 0x2f920e0 <col:22> 'int' 2\n"
+                             "      |     `-IntegerLiteral 0x2f92100 <col:24> 'int' 3\n"
+                             "      `-CXXDefaultArgExpr 0x2fb0ae0 <<invalid sloc>> 'const std::vector<int, std::allocator<int> >::allocator_type':'const std::allocator<int>' lvalue";
+        ASSERT_EQUALS("std :: vector<int> x@1 { 1 , 2 , 3 } ;", parse(clang));
+    }
+
+    void cxxThrowExpr() {
+        const char clang[] = "`-FunctionDecl 0x3701690 <1.cpp:2:1, col:23> col:6 foo 'void ()'\n"
+                             "  `-CompoundStmt 0x37017b0 <col:12, col:23>\n"
+                             "    `-CXXThrowExpr 0x3701790 <col:14, col:20> 'void'\n"
+                             "      `-IntegerLiteral 0x3701770 <col:20> 'int' 1";
+        ASSERT_EQUALS("void foo ( ) { throw 1 ; }", parse(clang));
+    }
+
+    void defaultStmt() {
+        const char clang[] = "`-FunctionDecl 0x18476b8 <1.c:3:1, line:9:1> line:3:5 foo 'int (int)'\n"
+                             "  |-ParmVarDecl 0x18475e0 <col:9, col:13> col:13 used rc 'int'\n"
+                             "  `-CompoundStmt 0x1847868 <line:4:1, line:9:1>\n"
+                             "    `-SwitchStmt 0x18477e0 <line:5:3, line:8:3>\n"
+                             "      |-ImplicitCastExpr 0x18477c8 <line:5:10> 'int' <LValueToRValue>\n"
+                             "      | `-DeclRefExpr 0x18477a8 <col:10> 'int' lvalue ParmVar 0x18475e0 'rc' 'int'\n"
+                             "      `-CompoundStmt 0x1847850 <col:14, line:8:3>\n"
+                             "        `-DefaultStmt 0x1847830 <line:6:3, line:7:12>\n"
+                             "          `-ReturnStmt 0x1847820 <col:5, col:12>\n"
+                             "            `-IntegerLiteral 0x1847800 <col:12> 'int' 1";
+        ASSERT_EQUALS("int foo ( int rc@1 ) { switch ( rc@1 ) { default : return 1 ; } }", parse(clang));
+    }
+
+    void doStmt() {
+        const char clang[] = "`-FunctionDecl 0x27fbbc8 <a.cpp:2:1, col:34> col:6 foo 'void ()'\n"
+                             "  `-CompoundStmt 0x27fbd08 <col:12, col:34>\n"
+                             "    `-DoStmt 0x27fbce8 <col:14, col:31>\n"
+                             "      |-CompoundStmt 0x27fbcb0 <col:17, col:22>\n"
+                             "      | `-UnaryOperator 0x27fbc90 <col:18, col:19> 'int' postfix '++'\n"
+                             "      |   `-DeclRefExpr 0x27fbc68 <col:18> 'int' lvalue Var 0x27fbae0 'x' 'int'\n"
+                             "      `-IntegerLiteral 0x27fbcc8 <col:30> 'int' 1";
+        ASSERT_EQUALS("void foo ( ) { do { ++ x ; } while ( 1 ) ; }", parse(clang));
+    }
+
+    void enumDecl1() {
+        const char clang[] = "`-EnumDecl 0x2660660 <a.cpp:3:1, col:16> col:6 referenced abc\n"
+                             "  |-EnumConstantDecl 0x2660720 <col:11> col:11 referenced a 'abc'\n"
+                             "  |-EnumConstantDecl 0x2660768 <col:13> col:13 b 'abc'\n"
+                             "  `-EnumConstantDecl 0x26607b0 <col:15> col:15 c 'abc'";
+        ASSERT_EQUALS("enum abc { a , b , c }", parse(clang));
+    }
+
+    void enumDecl2() {
+        const char clang[] = "`-EnumDecl 0xb55d50 <2.cpp:4:3, col:44> col:8 syntax_option_type 'unsigned int'";
+        ASSERT_EQUALS("enum syntax_option_type : unsigned int { }", parse(clang));
+    }
+
+    void enumDecl3() {
+        const char clang[] = "|-EnumDecl 0x1586e48 <2.cpp:1:3, line:5:3> line:1:8 __syntax_option\n"
+                             "| |-EnumConstantDecl 0x1586f18 <line:3:5> col:5 referenced _S_polynomial '__syntax_option'\n"
+                             "| `-EnumConstantDecl 0x1586f68 <line:4:5> col:5 _S_syntax_last '__syntax_option'";
+        ASSERT_EQUALS("enum __syntax_option { _S_polynomial , _S_syntax_last }", parse(clang));
+    }
+
+    void enumDecl4() {
+        const char clang[] = "|-EnumDecl 0xace1f8 <e1.cpp:3:1, col:51> col:1\n"
+                             "| |-EnumConstantDecl 0xace2c8 <col:7> col:7 A '(anonymous enum at e1.cpp:3:1)'\n"
+                             "| |-EnumConstantDecl 0xace318 <col:16> col:16 B '(anonymous enum at e1.cpp:3:1)'\n"
+                             "| `-EnumConstantDecl 0xace3b8 <col:46> col:46 referenced C '(anonymous enum at e1.cpp:3:1)'\n"
+                             "`-VarDecl 0xace470 <col:1, col:66> col:53 x 'enum (anonymous enum at e1.cpp:3:1)':'(anonymous enum at e1.cpp:3:1)' cinit\n"
+                             "  `-DeclRefExpr 0xace520 <col:66> '(anonymous enum at e1.cpp:3:1)' EnumConstant 0xace3b8 'C' '(anonymous enum at e1.cpp:3:1)'";
+        ASSERT_EQUALS("enum { A , B , C } x@1 = C ;", parse(clang));
+    }
+
+    void forStmt() {
+        const char clang[] = "`-FunctionDecl 0x2f93ae0 <1.c:1:1, col:56> col:5 main 'int ()'\n"
+                             "  `-CompoundStmt 0x2f93dc0 <col:12, col:56>\n"
+                             "    |-ForStmt 0x2f93d50 <col:14, col:44>\n"
+                             "    | |-DeclStmt 0x2f93c58 <col:19, col:28>\n"
+                             "    | | `-VarDecl 0x2f93bd8 <col:19, col:27> col:23 used i 'int' cinit\n"
+                             "    | |   `-IntegerLiteral 0x2f93c38 <col:27> 'int' 0\n"
+                             "    | |-<<<NULL>>>\n"
+                             "    | |-BinaryOperator 0x2f93cd0 <col:30, col:34> 'int' '<'\n"
+                             "    | | |-ImplicitCastExpr 0x2f93cb8 <col:30> 'int' <LValueToRValue>\n"
+                             "    | | | `-DeclRefExpr 0x2f93c70 <col:30> 'int' lvalue Var 0x2f93bd8 'i' 'int'\n"
+                             "    | | `-IntegerLiteral 0x2f93c98 <col:34> 'int' 10\n"
+                             "    | |-UnaryOperator 0x2f93d20 <col:38, col:39> 'int' postfix '++'\n"
+                             "    | | `-DeclRefExpr 0x2f93cf8 <col:38> 'int' lvalue Var 0x2f93bd8 'i' 'int'\n"
+                             "    | `-CompoundStmt 0x2f93d40 <col:43, col:44>\n"
+                             "    `-ReturnStmt 0x2f93da8 <col:46, col:53>\n"
+                             "      `-IntegerLiteral 0x2f93d88 <col:53> 'int' 0";
+        ASSERT_EQUALS("int main ( ) { for ( int i@1 = 0 ; i@1 < 10 ; ++ i@1 ) { } return 0 ; }", parse(clang));
+    }
+
+    void funcdecl1() {
+        const char clang[] = "`-FunctionDecl 0x3122c30 <1.c:1:1, col:22> col:6 foo 'void (int, int)'\n"
+                             "  |-ParmVarDecl 0x3122ae0 <col:10, col:14> col:14 x 'int'\n"
+                             "  `-ParmVarDecl 0x3122b58 <col:17, col:21> col:21 y 'int'";
+        ASSERT_EQUALS("void foo ( int x@1 , int y@2 ) ;", parse(clang));
+    }
+
+    void funcdecl2() {
+        const char clang[] = "`-FunctionDecl 0x24b2c38 <1.c:1:1, line:4:1> line:1:5 foo 'int (int, int)'\n"
+                             "  |-ParmVarDecl 0x24b2ae0 <col:9, col:13> col:13 used x 'int'\n"
+                             "  |-ParmVarDecl 0x24b2b58 <col:16, col:20> col:20 used y 'int'\n"
+                             "  `-CompoundStmt 0x24b2de8 <line:2:1, line:4:1>\n"
+                             "    `-ReturnStmt 0x24b2dd0 <line:3:5, col:16>\n"
+                             "      `-BinaryOperator 0x24b2da8 <col:12, col:16> 'int' '/'\n"
+                             "        |-ImplicitCastExpr 0x24b2d78 <col:12> 'int' <LValueToRValue>\n"
+                             "        | `-DeclRefExpr 0x24b2d28 <col:12> 'int' lvalue ParmVar 0x24b2ae0 'x' 'int'\n"
+                             "        `-ImplicitCastExpr 0x24b2d90 <col:16> 'int' <LValueToRValue>\n"
+                             "          `-DeclRefExpr 0x24b2d50 <col:16> 'int' lvalue ParmVar 0x24b2b58 'y' 'int'";
+        ASSERT_EQUALS("int foo ( int x@1 , int y@2 ) { return x@1 / y@2 ; }", parse(clang));
+    }
+
+    void funcdecl3() {
+        const char clang[] = "|-FunctionDecl 0x27cb6b8 <a.cpp:865:1, col:35> col:12 __overflow 'int (FILE *, int)' extern\n"
+                             "| |-ParmVarDecl 0x27cb528 <col:24, col:29> col:30 'FILE *'\n"
+                             "| `-ParmVarDecl 0x27cb5a0 <col:32> col:35 'int'";
+        ASSERT_EQUALS("int __overflow ( FILE * , int ) ;", parse(clang));
+    }
+
+    void funcdecl4() {
+        const char clang[] = "|-FunctionDecl 0x272bb60 <a.cpp:658:15> col:15 implicit fwrite 'unsigned long (const void *, unsigned long, unsigned long, FILE *)' extern\n"
+                             "| |-ParmVarDecl 0x272cc40 <<invalid sloc>> <invalid sloc> 'const void *'\n"
+                             "| |-ParmVarDecl 0x272cca0 <<invalid sloc>> <invalid sloc> 'unsigned long'\n"
+                             "| |-ParmVarDecl 0x272cd00 <<invalid sloc>> <invalid sloc> 'unsigned long'\n"
+                             "| `-ParmVarDecl 0x272cd60 <<invalid sloc>> <invalid sloc> 'FILE *'";
+        ASSERT_EQUALS("unsigned long fwrite ( const void * , unsigned long , unsigned long , FILE * ) ;", parse(clang));
+    }
+
+    void funcdecl5() {
+        const char clang[] = "`-FunctionDecl 0x59d670 <1.c:1:1, col:28> col:20 foo 'void (void)' static inline";
+        ASSERT_EQUALS("static inline void foo ( ) ;", parse(clang));
+    }
+
+    void funcdecl6() {
+        const char clang[] = "`-FunctionDecl 0x196eea8 <1.cpp:3:5, col:27> col:12 foo 'void **(int)'\n"
+                             "  `-ParmVarDecl 0x196eda0 <col:17, col:21> col:21 count 'int'";
+        ASSERT_EQUALS("void * * foo ( int count@1 ) ;", parse(clang));
+    }
+
+    void functionTemplateDecl1() {
+        const char clang[] = "`-FunctionTemplateDecl 0x3242860 <a.cpp:1:1, col:46> col:21 foo";
+        ASSERT_EQUALS("", parse(clang));
+    }
+
+    void functionTemplateDecl2() {
+        const char clang[] = "|-FunctionTemplateDecl 0x333a860 <a.cpp:1:1, col:46> col:21 foo\n"
+                             "| |-TemplateTypeParmDecl 0x333a5f8 <col:10, col:16> col:16 referenced class depth 0 index 0 T\n"
+                             "| |-FunctionDecl 0x333a7c0 <col:19, col:46> col:21 foo 'T (T)'\n"
+                             "| | |-ParmVarDecl 0x333a6c0 <col:25, col:27> col:27 referenced t 'T'\n"
+                             "| | `-CompoundStmt 0x333a980 <col:30, col:46>\n"
+                             "| |   `-ReturnStmt 0x333a968 <col:32, col:43>\n"
+                             "| |     `-BinaryOperator 0x333a940 <col:39, col:43> '<dependent type>' '+'\n"
+                             "| |       |-DeclRefExpr 0x333a8f8 <col:39> 'T' lvalue ParmVar 0x333a6c0 't' 'T'\n"
+                             "| |       `-IntegerLiteral 0x333a920 <col:43> 'int' 1\n"
+                             "| `-FunctionDecl 0x333ae00 <col:19, col:46> col:21 used foo 'int (int)'\n"
+                             "|   |-TemplateArgument type 'int'\n"
+                             "|   |-ParmVarDecl 0x333ad00 <col:25, col:27> col:27 used t 'int':'int'\n"
+                             "|   `-CompoundStmt 0x333b0a8 <col:30, col:46>\n"
+                             "|     `-ReturnStmt 0x333b090 <col:32, col:43>\n"
+                             "|       `-BinaryOperator 0x333b068 <col:39, col:43> 'int' '+'\n"
+                             "|         |-ImplicitCastExpr 0x333b050 <col:39> 'int':'int' <LValueToRValue>\n"
+                             "|         | `-DeclRefExpr 0x333b028 <col:39> 'int':'int' lvalue ParmVar 0x333ad00 't' 'int':'int'\n"
+                             "|         `-IntegerLiteral 0x333a920 <col:43> 'int' 1\n"
+                             "`-FunctionDecl 0x333a9f8 <line:2:1, col:22> col:1 invalid bar 'int ()'\n"
+                             "  `-CompoundStmt 0x333b010 <col:7, col:22>\n"
+                             "    `-CallExpr 0x333afe0 <col:9, col:19> 'int':'int'\n"
+                             "      |-ImplicitCastExpr 0x333afc8 <col:9, col:16> 'int (*)(int)' <FunctionToPointerDecay>\n"
+                             "      | `-DeclRefExpr 0x333af00 <col:9, col:16> 'int (int)' lvalue Function 0x333ae00 'foo' 'int (int)' (FunctionTemplate 0x333a860 'foo')\n"
+                             "      `-IntegerLiteral 0x333ab48 <col:18> 'int' 1";
+        ASSERT_EQUALS("int foo<int> ( int t@1 ) { return t@1 + 1 ; } int bar ( ) { foo ( 1 ) ; }", parse(clang));
+    }
+
+    void ifelse() {
+        const char clang[] = "`-FunctionDecl 0x2637ba8 <1.c:1:1, line:4:1> line:1:5 foo 'int (int)'\n"
+                             "  |-ParmVarDecl 0x2637ae0 <col:9, col:13> col:13 used x 'int'\n"
+                             "  `-CompoundStmt 0x2637d70 <col:16, line:4:1>\n"
+                             "    `-IfStmt 0x2637d38 <line:2:5, line:3:11>\n"
+                             "      |-<<<NULL>>>\n"
+                             "      |-<<<NULL>>>\n"
+                             "      |-BinaryOperator 0x2637cf0 <line:2:9, col:13> 'int' '>'\n"
+                             "      | |-ImplicitCastExpr 0x2637cd8 <col:9> 'int' <LValueToRValue>\n"
+                             "      | | `-DeclRefExpr 0x2637c90 <col:9> 'int' lvalue ParmVar 0x2637ae0 'x' 'int'\n"
+                             "      | `-IntegerLiteral 0x2637cb8 <col:13> 'int' 10\n"
+                             "      |-CompoundStmt 0x2637d18 <col:17, col:18>\n"
+                             "      `-CompoundStmt 0x2637d28 <line:3:10, col:11>";
+        ASSERT_EQUALS("int foo ( int x@1 ) { if ( x@1 > 10 ) { } else { } }", parse(clang));
+    }
+
+    void ifStmt() {
+        // Clang 8 in cygwin
+        const char clang[] = "`-FunctionDecl 0x41d0690 <2.cpp:1:1, col:24> col:6 foo 'void ()'\n"
+                             "  `-CompoundStmt 0x41d07f0 <col:12, col:24>\n"
+                             "    `-IfStmt 0x41d07b8 <col:14, col:22>\n"
+                             "      |-ImplicitCastExpr 0x41d0790 <col:18> 'bool' <IntegralToBoolean>\n"
+                             "      | `-IntegerLiteral 0x41d0770 <col:18> 'int' 1\n"
+                             "      |-CompoundStmt 0x41d07a8 <col:21, col:22>\n";
+        ASSERT_EQUALS("void foo ( ) { if ( 1 ) { } }", parse(clang));
+    }
+
+    void initListExpr() {
+        const char clang[] = "|-VarDecl 0x397c680 <1.cpp:2:1, col:26> col:11 used ints 'const int [3]' cinit\n"
+                             "| `-InitListExpr 0x397c7d8 <col:20, col:26> 'const int [3]'\n"
+                             "|   |-IntegerLiteral 0x397c720 <col:21> 'int' 1\n"
+                             "|   |-IntegerLiteral 0x397c740 <col:23> 'int' 2\n"
+                             "|   `-IntegerLiteral 0x397c760 <col:25> 'int' 3";
+        ASSERT_EQUALS("const int [3] ints@1 = { 1 , 2 , 3 } ;", parse(clang));
+    }
+
+    void labelStmt() {
+        const char clang[] = "`-FunctionDecl 0x2ed1ba0 <1.c:1:1, col:36> col:6 foo 'void (int)'\n"
+                             "  `-CompoundStmt 0x2ed1d00 <col:17, col:36>\n"
+                             "    `-LabelStmt 0x2ed1ce8 <col:19, col:30> 'loop'\n"
+                             "      `-GotoStmt 0x2ed1cd0 <col:25, col:30> 'loop' 0x2ed1c88";
+        ASSERT_EQUALS("void foo ( ) { loop : goto loop ; }", parse(clang));
+    }
+
+    void memberExpr() {
+        // C code:
+        // struct S { int x };
+        // int foo(struct S s) { return s.x; }
+        const char clang[] = "|-RecordDecl 0x2441a88 <1.c:1:1, col:18> col:8 struct S definition\n"
+                             "| `-FieldDecl 0x2441b48 <col:12, col:16> col:16 referenced x 'int'\n"
+                             "`-FunctionDecl 0x2441cf8 <line:2:1, col:35> col:5 foo 'int (struct S)'\n"
+                             "  |-ParmVarDecl 0x2441be8 <col:9, col:18> col:18 used s 'struct S':'struct S'\n"
+                             "  `-CompoundStmt 0x2441e70 <col:21, col:35>\n"
+                             "    `-ReturnStmt 0x2441e58 <col:23, col:32>\n"
+                             "      `-ImplicitCastExpr 0x2441e40 <col:30, col:32> 'int' <LValueToRValue>\n"
+                             "        `-MemberExpr 0x2441e08 <col:30, col:32> 'int' lvalue .x 0x2441b48\n"
+                             "          `-DeclRefExpr 0x2441de0 <col:30> 'struct S':'struct S' lvalue ParmVar 0x2441be8 's' 'struct S':'struct S'";
+        ASSERT_EQUALS("struct S { int x@1 ; } ; int foo ( struct S s@2 ) { return s@2 . x@1 ; }",
+                      parse(clang));
+    }
+
+    void namespaceDecl1() {
+        const char clang[] = "`-NamespaceDecl 0x2e5f658 <hello.cpp:1:1, col:24> col:11 x\n"
+                             "  `-VarDecl 0x2e5f6d8 <col:15, col:19> col:19 var 'int'";
+        ASSERT_EQUALS("namespace x { int var@1 ; }",
+                      parse(clang));
+    }
+
+    void namespaceDecl2() {
+        const char clang[] = "`-NamespaceDecl 0x1753e60 <1.cpp:1:1, line:4:1> line:1:11 std\n"
+                             "  |-VisibilityAttr 0x1753ed0 <col:31, col:56> Default\n"
+                             "  `-VarDecl 0x1753f40 <line:3:5, col:9> col:9 x 'int'";
+        ASSERT_EQUALS("namespace std { int x@1 ; }",
+                      parse(clang));
+    }
+
+    void recordDecl1() {
+        const char clang[] = "`-RecordDecl 0x354eac8 <1.c:1:1, line:4:1> line:1:8 struct S definition\n"
+                             "  |-FieldDecl 0x354eb88 <line:2:3, col:7> col:7 x 'int'\n"
+                             "  `-FieldDecl 0x354ebe8 <line:3:3, col:7> col:7 y 'int'";
+        ASSERT_EQUALS("struct S { int x@1 ; int y@2 ; } ;",
+                      parse(clang));
+    }
+
+    void recordDecl2() {
+        const char clang[] = "`-RecordDecl 0x3befac8 <2.c:2:1, col:22> col:1 struct definition\n"
+                             "  `-FieldDecl 0x3befbf0 <col:10, col:19> col:14 val 'int'";
+        ASSERT_EQUALS("struct { int val@1 ; } ;",
+                      parse(clang));
+    }
+
+    void switchStmt() {
+        const char clang[] = "`-FunctionDecl 0x2796ba0 <1.c:1:1, col:35> col:6 foo 'void (int)'\n"
+                             "  |-ParmVarDecl 0x2796ae0 <col:10, col:14> col:14 used x 'int'\n"
+                             "  `-CompoundStmt 0x2796d18 <col:17, col:35>\n"
+                             "    |-SwitchStmt 0x2796cc8 <col:19, col:32>\n"
+                             "    | |-<<<NULL>>>\n"
+                             "    | |-<<<NULL>>>\n"
+                             "    | |-ImplicitCastExpr 0x2796cb0 <col:27> 'int' <LValueToRValue>\n"
+                             "    | | `-DeclRefExpr 0x2796c88 <col:27> 'int' lvalue ParmVar 0x2796ae0 'x' 'int'\n"
+                             "    | `-CompoundStmt 0x2796cf8 <col:30, col:32>\n"
+                             "    `-NullStmt 0x2796d08 <col:33>";
+        ASSERT_EQUALS("void foo ( int x@1 ) { switch ( x@1 ) { } ; }",
+                      parse(clang));
+    }
+
+    void typedefDeclPrologue()
+    {
+        // these TypedefDecl are included in *any* AST dump and we should ignore them as they should not be of interest to us
+        // see https://github.com/llvm/llvm-project/issues/120228#issuecomment-2549212109 for an explanation
+        const char clang[] =
+            "TranslationUnitDecl 0x60efd80ef9f8 <<invalid sloc>> <invalid sloc>\n"
+            "|-TypedefDecl 0x60efd80f0228 <<invalid sloc>> <invalid sloc> implicit __int128_t '__int128'\n"
+            "| `-BuiltinType 0x60efd80effc0 '__int128'\n"
+            "|-TypedefDecl 0x60efd80f0298 <<invalid sloc>> <invalid sloc> implicit __uint128_t 'unsigned __int128'\n"
+            "| `-BuiltinType 0x60efd80effe0 'unsigned __int128'\n"
+            "|-TypedefDecl 0x60efd80f05a0 <<invalid sloc>> <invalid sloc> implicit __NSConstantString 'struct __NSConstantString_tag'\n"
+            "| `-RecordType 0x60efd80f0370 'struct __NSConstantString_tag'\n"
+            "|   `-Record 0x60efd80f02f0 '__NSConstantString_tag'\n"
+            "|-TypedefDecl 0x60efd80f0648 <<invalid sloc>> <invalid sloc> implicit __builtin_ms_va_list 'char *'\n"
+            "| `-PointerType 0x60efd80f0600 'char *'\n"
+            "|   `-BuiltinType 0x60efd80efaa0 'char'\n"
+            "|-TypedefDecl 0x60efd80f0940 <<invalid sloc>> <invalid sloc> implicit __builtin_va_list 'struct __va_list_tag[1]'\n"
+            "| `-ConstantArrayType 0x60efd80f08e0 'struct __va_list_tag[1]' 1\n"
+            "|   `-RecordType 0x60efd80f0720 'struct __va_list_tag'\n"
+            "|     `-Record 0x60efd80f06a0 '__va_list_tag'\n"
+            "`-FunctionDecl 0x60efd8151470 <a.cpp:1:1, line:3:1> line:1:6 f 'void ()'\n"
+            "`-CompoundStmt 0x60efd8151560 <line:2:1, line:3:1>\n";
+
+        ASSERT_EQUALS("void f ( ) ;", parse(clang));
+    }
+
+    void unaryExprOrTypeTraitExpr1() {
+        const char clang[] = "`-VarDecl 0x24cc610 <a.cpp:1:1, col:19> col:5 x 'int' cinit\n"
+                             "  `-ImplicitCastExpr 0x24cc6e8 <col:9, col:19> 'int' <IntegralCast>\n"
+                             "    `-UnaryExprOrTypeTraitExpr 0x24cc6c8 <col:9, col:19> 'unsigned long' sizeof 'int'\n";
+        ASSERT_EQUALS("int x@1 = sizeof ( int ) ;", parse(clang));
+    }
+
+    void unaryExprOrTypeTraitExpr2() {
+        const char clang[] = "`-VarDecl 0x27c6c00 <a.cpp:3:5, col:23> col:9 x 'int' cinit\n"
+                             "  `-ImplicitCastExpr 0x27c6cc8 <col:13, col:23> 'int' <IntegralCast>\n"
+                             "    `-UnaryExprOrTypeTraitExpr 0x27c6ca8 <col:13, col:23> 'unsigned long' sizeof\n"
+                             "      `-ParenExpr 0x27c6c88 <col:19, col:23> 'char [10]' lvalue\n"
+                             "        `-DeclRefExpr 0x27c6c60 <col:20> 'char [10]' lvalue Var 0x27c6b48 'buf' 'char [10]'";
+        ASSERT_EQUALS("int x@1 = sizeof ( buf ) ;", parse(clang));
+    }
+
+    void unaryOperator() {
+        const char clang[] = "`-FunctionDecl 0x2dd9748 <1.cpp:2:1, col:44> col:5 foo 'int (int *)'\n"
+                             "  |-ParmVarDecl 0x2dd9680 <col:14, col:19> col:19 used p 'int *'\n"
+                             "  `-CompoundStmt 0x2dd9908 <col:22, col:44>\n"
+                             "    `-ReturnStmt 0x2dd98f0 <col:24, col:41>\n"
+                             "      `-BinaryOperator 0x2dd98c8 <col:31, col:41> 'int' '/'\n"
+                             "        |-IntegerLiteral 0x2dd9830 <col:31> 'int' 100000\n"
+                             "        `-ImplicitCastExpr 0x2dd98b0 <col:40, col:41> 'int' <LValueToRValue>\n"
+                             "          `-UnaryOperator 0x2dd9890 <col:40, col:41> 'int' lvalue prefix '*' cannot overflow\n"
+                             "            `-ImplicitCastExpr 0x2dd9878 <col:41> 'int *' <LValueToRValue>\n"
+                             "              `-DeclRefExpr 0x2dd9850 <col:41> 'int *' lvalue ParmVar 0x2dd9680 'p' 'int *'";
+        ASSERT_EQUALS("int foo ( int * p@1 ) { return 100000 / * p@1 ; }", parse(clang));
+    }
+
+    void vardecl1() {
+        const char clang[] = "|-VarDecl 0x32b8aa0 <1.c:1:1, col:9> col:5 used a 'int' cinit\n"
+                             "| `-IntegerLiteral 0x32b8b40 <col:9> 'int' 1\n"
+                             "`-VarDecl 0x32b8b78 <line:2:1, col:9> col:5 b 'int' cinit\n"
+                             "  `-ImplicitCastExpr 0x32b8c00 <col:9> 'int' <LValueToRValue>\n"
+                             "    `-DeclRefExpr 0x32b8bd8 <col:9> 'int' lvalue Var 0x32b8aa0 'a' 'int'";
+
+        ASSERT_EQUALS("int a@1 = 1 ; int b@2 = a@1 ;",
+                      parse(clang));
+    }
+
+    void vardecl2() {
+        const char clang[] = "|-VarDecl 0x3873b50 <1.c:1:1, col:9> col:5 used a 'int [10]'\n"
+                             "`-FunctionDecl 0x3873c38 <line:3:1, line:6:1> line:3:6 foo 'void ()'\n"
+                             "  `-CompoundStmt 0x3873dd0 <line:4:1, line:6:1>\n"
+                             "    `-BinaryOperator 0x3873da8 <line:5:3, col:10> 'int' '='\n"
+                             "      |-ArraySubscriptExpr 0x3873d60 <col:3, col:6> 'int' lvalue\n"
+                             "      | |-ImplicitCastExpr 0x3873d48 <col:3> 'int *' <ArrayToPointerDecay>\n"
+                             "      | | `-DeclRefExpr 0x3873cd8 <col:3> 'int [10]' lvalue Var 0x3873b50 'a' 'int [10]'\n"
+                             "      | `-IntegerLiteral 0x3873d00 <col:5> 'int' 0\n"
+                             "      `-IntegerLiteral 0x3873d88 <col:10> 'int' 0\n";
+
+        ASSERT_EQUALS("int [10] a@1 ; void foo ( ) { a@1 [ 0 ] = 0 ; }",
+                      parse(clang));
+    }
+
+    void vardecl3() {
+        const char clang[] = "`-VarDecl 0x25a8aa0 <1.c:1:1, col:12> col:12 p 'const int *'";
+        ASSERT_EQUALS("const int * p@1 ;", parse(clang));
+    }
+
+    void vardecl4() {
+        const char clang[] = "|-VarDecl 0x23d6c78 <a.cpp:137:1, col:14> col:14 stdin 'FILE *' extern";
+        ASSERT_EQUALS("FILE * stdin@1 ;", parse(clang));
+    }
+
+    void vardecl5() {
+        const char clang[] = "|-VarDecl 0x2e31fc0 <a.cpp:27:1, col:38> col:26 sys_errlist 'const char *const []' extern";
+        ASSERT_EQUALS("const char * const [] sys_errlist@1 ;", parse(clang));
+    }
+
+    void vardecl6() {
+        const char clang[] = "`-VarDecl 0x278e170 <1.c:1:1, col:16> col:12 x 'int' static cinit\n"
+                             "  `-IntegerLiteral 0x278e220 <col:16> 'int' 3";
+        ASSERT_EQUALS("static int x@1 = 3 ;", parse(clang));
+    }
+
+    void vardecl7() {
+        const char clang[] = "`-VarDecl 0x2071f20 <1.cpp:2:1, col:23> col:9 start 'void *(*)(void *)'";
+        ASSERT_EQUALS("void * * start@1 ;", parse(clang));
+    }
+
+    void whileStmt1() {
+        const char clang[] = "`-FunctionDecl 0x3d45b18 <1.c:1:1, line:3:1> line:1:6 foo 'void ()'\n"
+                             "  `-CompoundStmt 0x3d45c48 <col:12, line:3:1>\n"
+                             "    `-WhileStmt 0x3d45c28 <line:2:5, col:14>\n"
+                             "      |-<<<NULL>>>\n"
+                             "      |-IntegerLiteral 0x3d45bf8 <col:12> 'int' 0\n"
+                             "      `-NullStmt 0x3d45c18 <col:14>";
+        ASSERT_EQUALS("void foo ( ) { while ( 0 ) { ; } }",
+                      parse(clang));
+    }
+
+    void whileStmt2() {
+        // clang 9
+        const char clang[] = "`-FunctionDecl 0x1c99ac8 <1.cpp:1:1, col:27> col:6 foo 'void ()'\n"
+                             "  `-CompoundStmt 0x1c99c10 <col:12, col:27>\n"
+                             "    `-WhileStmt 0x1c99bf8 <col:14, col:25>\n"
+                             "      |-ImplicitCastExpr 0x1c99bd0 <col:21> 'bool' <IntegralToBoolean>\n"
+                             "      | `-IntegerLiteral 0x1c99bb0 <col:21> 'int' 1\n"
+                             "      `-CompoundStmt 0x1c99be8 <col:24, col:25>";
+        ASSERT_EQUALS("void foo ( ) { while ( 1 ) { } }", parse(clang));
+    }
+
+
+#define GET_SYMBOL_DB(AST) \
+    const Settings settings = settingsBuilder().clang().platform(Platform::Type::Unix64).build(); \
+    TokenList tokenlist{settings, Standards::Language::CPP}; \
+    Tokenizer tokenizer(std::move(tokenlist), *this); \
+    { \
+        std::istringstream istr(AST); \
+        clangimport::parseClangAstDump(tokenizer, istr); \
+    } \
+    const SymbolDatabase *db = tokenizer.getSymbolDatabase(); \
+    ASSERT(db)
+
+    void tokenIndex() {
+        const char clang[] = "`-FunctionDecl 0x1e07dd0 <67.cpp:1:1, col:13> col:6 foo 'void ()'\n"
+                             "  `-CompoundStmt 0x1e07eb8 <col:12, col:13>";
+        ASSERT_EQUALS("void foo ( ) { }", parse(clang));
+
+        GET_SYMBOL_DB(clang);
+        const Token *tok = tokenizer.tokens();
+        ASSERT_EQUALS(tok->index() + 1, tok->next()->index());
+    }
+
+    void symbolDatabaseEnum1() {
+        const char clang[] = "|-NamespaceDecl 0x29ad5f8 <1.cpp:1:1, line:3:1> line:1:11 ns\n"
+                             "| `-EnumDecl 0x29ad660 <line:2:1, col:16> col:6 referenced abc\n"
+                             "|   |-EnumConstantDecl 0x29ad720 <col:11> col:11 a 'ns::abc'\n"
+                             "|   |-EnumConstantDecl 0x29ad768 <col:13> col:13 b 'ns::abc'\n"
+                             "|   `-EnumConstantDecl 0x29ad7b0 <col:15> col:15 referenced c 'ns::abc'\n"
+                             "`-VarDecl 0x29ad898 <line:5:1, col:22> col:9 x 'ns::abc':'ns::abc' cinit\n"
+                             "  `-DeclRefExpr 0x29ad998 <col:13, col:22> 'ns::abc' EnumConstant 0x29ad7b0 'c' 'ns::abc'\n";
+
+        ASSERT_EQUALS("namespace ns { enum abc { a , b , c } } ns :: abc x@1 = c ;", parse(clang));
+
+        GET_SYMBOL_DB(clang);
+
+        // Enum scope and type
+        ASSERT_EQUALS(3, db->scopeList.size());
+        const Scope &enumScope = db->scopeList.back();
+        ASSERT_EQUALS_ENUM(ScopeType::eEnum, enumScope.type);
+        ASSERT_EQUALS("abc", enumScope.className);
+        const Type *enumType = enumScope.definedType;
+        ASSERT_EQUALS("abc", enumType->name());
+
+        // Variable
+        const Token *vartok = Token::findsimplematch(tokenizer.tokens(), "x");
+        ASSERT(vartok);
+        ASSERT(vartok->variable());
+        ASSERT(vartok->variable()->valueType());
+        ASSERT_EQUALS(uintptr_t(&enumScope), uintptr_t(vartok->variable()->valueType()->typeScope));
+    }
+
+    void symbolDatabaseFunction1() {
+        const char clang[] = "|-FunctionDecl 0x3aea7a0 <1.cpp:2:1, col:22> col:6 used foo 'void (int, int)'\n"
+                             "  |-ParmVarDecl 0x3aea650 <col:10, col:14> col:14 x 'int'\n"
+                             "  |-ParmVarDecl 0x3aea6c8 <col:17, col:21> col:21 y 'int'\n"
+                             "  `-CompoundStmt 0x3d45c48 <col:12>\n";
+
+        GET_SYMBOL_DB(clang);
+
+        // There is a function foo that has 2 arguments
+        ASSERT_EQUALS(1, db->functionScopes.size());
+        const Scope *scope = db->functionScopes[0];
+        const Function *func = scope->function;
+        ASSERT_EQUALS(2, func->argCount());
+        ASSERT_EQUALS("x", func->getArgumentVar(0)->name());
+        ASSERT_EQUALS("y", func->getArgumentVar(1)->name());
+        ASSERT_EQUALS(ValueType::Type::INT, func->getArgumentVar(0)->valueType()->type);
+        ASSERT_EQUALS(ValueType::Type::INT, func->getArgumentVar(1)->valueType()->type);
+    }
+
+    void symbolDatabaseFunction2() {
+        const char clang[] = "|-FunctionDecl 0x3aea7a0 <1.cpp:2:1, col:22> col:6 used foo 'void (int, int)'\n"
+                             "| |-ParmVarDecl 0x3aea650 <col:10, col:14> col:14 'int'\n"
+                             "| |-ParmVarDecl 0x3aea6c8 <col:17, col:21> col:21 'int'\n"
+                             "  `-CompoundStmt 0x3d45c48 <col:12>\n";
+
+        GET_SYMBOL_DB(clang);
+
+        // There is a function foo that has 2 arguments
+        ASSERT_EQUALS(1, db->functionScopes.size());
+        const Scope *scope = db->functionScopes[0];
+        const Function *func = scope->function;
+        ASSERT_EQUALS(2, func->argCount());
+        ASSERT(!func->getArgumentVar(0)->nameToken());
+        ASSERT(!func->getArgumentVar(1)->nameToken());
+    }
+
+    void symbolDatabaseFunction3() { // #9640
+        const char clang[] = "`-FunctionDecl 0x238fcd8 <9640.cpp:1:1, col:26> col:6 used bar 'bool (const char, int &)'\n"
+                             "  |-ParmVarDecl 0x238fb10 <col:10, col:16> col:20 'const char'\n"
+                             "  |-ParmVarDecl 0x238fbc0 <col:22, col:25> col:26 'int &'\n"
+                             "  `-CompoundStmt 0x3d45c48 <col:12>\n";
+
+        GET_SYMBOL_DB(clang);
+
+        // There is a function foo that has 2 arguments
+        ASSERT_EQUALS(1, db->functionScopes.size());
+        const Scope *scope = db->functionScopes[0];
+        const Function *func = scope->function;
+        ASSERT_EQUALS(2, func->argCount());
+        ASSERT_EQUALS(false, func->getArgumentVar(0)->isReference());
+        ASSERT_EQUALS(true, func->getArgumentVar(1)->isReference());
+    }
+
+    void symbolDatabaseFunctionConst() {
+        const char clang[] = "`-CXXRecordDecl 0x7e2d98 <1.cpp:2:1, line:5:1> line:2:7 class foo definition\n"
+                             "  `-CXXMethodDecl 0x7e3000 <line:4:3, col:12> col:8 f 'void () const'";
+
+        GET_SYMBOL_DB(clang);
+
+        // There is a function f that is const
+        ASSERT_EQUALS(2, db->scopeList.size());
+        ASSERT_EQUALS(1, db->scopeList.back().functionList.size());
+        const Function &func = db->scopeList.back().functionList.back();
+        ASSERT(func.isConst());
+    }
+
+    void symbolDatabaseVariableRef() {
+        const char clang[] = "`-FunctionDecl 0x1593df0 <3.cpp:1:1, line:4:1> line:1:6 foo 'void ()'\n"
+                             "  `-CompoundStmt 0x15940b0 <col:12, line:4:1>\n"
+                             "    |-DeclStmt 0x1593f58 <line:2:3, col:8>\n"
+                             "    | `-VarDecl 0x1593ef0 <col:3, col:7> col:7 used x 'int'\n"
+                             "    `-DeclStmt 0x1594098 <line:3:3, col:15>\n"
+                             "      `-VarDecl 0x1593fb8 <col:3, col:14> col:8 ref 'int &' cinit\n"
+                             "        `-DeclRefExpr 0x1594020 <col:14> 'int' lvalue Var 0x1593ef0 'x' 'int'";
+        GET_SYMBOL_DB(clang);
+        const Variable *refVar = db->variableList().back();
+        ASSERT(refVar->isReference());
+    }
+
+    void symbolDatabaseVariableRRef() {
+        const char clang[] = "`-FunctionDecl 0x1a40df0 <3.cpp:1:1, line:4:1> line:1:6 foo 'void ()'\n"
+                             "  `-CompoundStmt 0x1a41180 <col:12, line:4:1>\n"
+                             "    |-DeclStmt 0x1a40f58 <line:2:3, col:8>\n"
+                             "    | `-VarDecl 0x1a40ef0 <col:3, col:7> col:7 used x 'int'\n"
+                             "    `-DeclStmt 0x1a41168 <line:3:3, col:18>\n"
+                             "      `-VarDecl 0x1a40fb8 <col:3, col:17> col:9 ref 'int &&' cinit\n"
+                             "        `-ExprWithCleanups 0x1a410f8 <col:15, col:17> 'int' xvalue\n"
+                             "          `-MaterializeTemporaryExpr 0x1a41098 <col:15, col:17> 'int' xvalue extended by Var 0x1a40fb8 'ref' 'int &&'\n"
+                             "            `-BinaryOperator 0x1a41078 <col:15, col:17> 'int' '+'\n"
+                             "              |-ImplicitCastExpr 0x1a41060 <col:15> 'int' <LValueToRValue>\n"
+                             "              | `-DeclRefExpr 0x1a41020 <col:15> 'int' lvalue Var 0x1a40ef0 'x' 'int'\n"
+                             "              `-IntegerLiteral 0x1a41040 <col:17> 'int' 1\n";
+
+        ASSERT_EQUALS("void foo ( ) { int x@1 ; int && ref@2 = x@1 + 1 ; }", parse(clang));
+
+        GET_SYMBOL_DB(clang);
+        const Variable *refVar = db->variableList().back();
+        ASSERT(refVar->isReference());
+        ASSERT(refVar->isRValueReference());
+    }
+
+    void symbolDatabaseVariablePointerRef() {
+        const char clang[] = "`-FunctionDecl 0x9b4f10 <3.cpp:1:1, col:17> col:6 used foo 'void (int *&)'\n"
+                             "  `-ParmVarDecl 0x9b4e40 <col:10, col:16> col:16 p 'int *&'\n";
+
+        ASSERT_EQUALS("void foo ( int * & p@1 ) ;", parse(clang));
+
+        GET_SYMBOL_DB(clang);
+        const Variable *p = db->variableList().back();
+        ASSERT(p->isPointer());
+        ASSERT(p->isReference());
+    }
+
+    void symbolDatabaseNodeType1() {
+        const char clang[] = "`-FunctionDecl 0x32438c0 <a.cpp:5:1, line:7:1> line:5:6 foo 'a::b (a::b)'\n"
+                             "  |-ParmVarDecl 0x32437b0 <col:10, col:15> col:15 used i 'a::b':'long'\n"
+                             "  `-CompoundStmt 0x3243a60 <col:18, line:7:1>\n"
+                             "    `-ReturnStmt 0x3243a48 <line:6:3, col:12>\n"
+                             "      `-BinaryOperator 0x3243a20 <col:10, col:12> 'long' '+'\n"
+                             "        |-ImplicitCastExpr 0x32439f0 <col:10> 'a::b':'long' <LValueToRValue>\n"
+                             "        | `-DeclRefExpr 0x32439a8 <col:10> 'a::b':'long' lvalue ParmVar 0x32437b0 'i' 'a::b':'long'\n"
+                             "        `-ImplicitCastExpr 0x3243a08 <col:12> 'long' <IntegralCast>\n"
+                             "          `-IntegerLiteral 0x32439d0 <col:12> 'int' 1\n";
+
+        GET_SYMBOL_DB(clang);
+
+        const Token *tok = Token::findsimplematch(tokenizer.tokens(), "i + 1");
+        ASSERT(!!tok);
+        ASSERT(!!tok->valueType());
+        ASSERT_EQUALS("signed long", tok->valueType()->str());
+    }
+
+    void symbolDatabaseForVariable() {
+        const char clang[] = "`-FunctionDecl 0x38f8bb0 <10100.c:2:1, line:4:1> line:2:6 f 'void (void)'\n"
+                             "  `-CompoundStmt 0x38f8d88 <col:14, line:4:1>\n"
+                             "    `-ForStmt 0x38f8d50 <line:3:5, col:26>\n"
+                             "      |-DeclStmt 0x38f8d28 <col:10, col:19>\n"
+                             "      | `-VarDecl 0x38f8ca8 <col:10, col:18> col:14 i 'int' cinit\n"
+                             "      |   `-IntegerLiteral 0x38f8d08 <col:18> 'int' 0\n"
+                             "      |-<<<NULL>>>\n"
+                             "      |-<<<NULL>>>\n"
+                             "      |-<<<NULL>>>\n"
+                             "      `-CompoundStmt 0x38f8d40 <col:25, col:26>";
+
+        ASSERT_EQUALS("void f ( ) { for ( int i@1 = 0 ; ; ) { } }", parse(clang));
+
+        GET_SYMBOL_DB(clang);
+
+        const Token *tok = Token::findsimplematch(tokenizer.tokens(), "i");
+        ASSERT(!!tok);
+        ASSERT(!!tok->variable());
+        ASSERT_EQUALS_ENUM(ScopeType::eFor, tok->variable()->scope()->type);
+    }
+
+    void valueFlow1() {
+        // struct S { int x; int buf[10]; } ; int sz = sizeof(struct S);
+        const char clang[] = "|-RecordDecl 0x2fc5a88 <1.c:1:1, line:4:1> line:1:8 struct S definition\n"
+                             "| |-FieldDecl 0x2fc5b48 <line:2:3, col:7> col:7 x 'int'\n"
+                             "| `-FieldDecl 0x2fc5c10 <line:3:3, col:13> col:7 buf 'int [10]'\n"
+                             "`-VarDecl 0x2fc5c70 <line:6:1, col:25> col:5 sz 'int' cinit\n"
+                             "  `-ImplicitCastExpr 0x2fc5d88 <col:10, col:25> 'int' <IntegralCast>\n"
+                             "    `-UnaryExprOrTypeTraitExpr 0x2fc5d68 <col:10, col:25> 'unsigned long' sizeof 'struct S':'struct S'";
+        GET_SYMBOL_DB(clang);
+
+        const Token *tok = Token::findsimplematch(tokenizer.tokens(), "sizeof (");
+        ASSERT(!!tok);
+        tok = tok->next();
+        ASSERT(tok->hasKnownIntValue());
+        ASSERT_EQUALS(MathLib::bigint(44), tok->getKnownIntValue());
+    }
+
+    void valueFlow2() {
+        // int buf[42];
+        // int x = sizeof(buf);
+        const char clang[] = "|-VarDecl 0x10f6de8 <66.cpp:3:1, col:11> col:5 referenced buf 'int [42]'\n"
+                             "`-VarDecl 0x10f6eb0 <line:4:1, col:19> col:5 x 'int' cinit\n"
+                             "  `-ImplicitCastExpr 0x10f6f78 <col:9, col:19> 'int' <IntegralCast>\n"
+                             "    `-UnaryExprOrTypeTraitExpr 0x10f6f58 <col:9, col:19> 'unsigned long' sizeof\n"
+                             "      `-ParenExpr 0x10f6f38 <col:15, col:19> 'int [42]' lvalue\n"
+                             "        `-DeclRefExpr 0x10f6f18 <col:16> 'int [42]' lvalue Var 0x10f6de8 'buf' 'int [42]' non_odr_use_unevaluated";
+
+        GET_SYMBOL_DB(clang);
+
+        const Token *tok = Token::findsimplematch(tokenizer.tokens(), "sizeof (");
+        ASSERT(!!tok);
+        tok = tok->next();
+        TODO_ASSERT_EQUALS(true, false, tok->hasKnownIntValue() && tok->getKnownIntValue() == 10);
+    }
+
+    void valueType1() {
+        const char clang[] = "`-FunctionDecl 0x32438c0 <a.cpp:5:1, line:7:1> line:5:6 foo 'a::b (a::b)'\n"
+                             "  |-ParmVarDecl 0x32437b0 <col:10, col:15> col:15 used i 'a::b':'long'\n"
+                             "  `-CompoundStmt 0x3243a60 <col:18, line:7:1>\n"
+                             "    `-ReturnStmt 0x3243a48 <line:6:3, col:12>\n"
+                             "      `-ImplicitCastExpr 0x2176ca8 <col:9> 'int' <IntegralCast>\n"
+                             "        `-ImplicitCastExpr 0x2176c90 <col:9> 'bool' <LValueToRValue>\n"
+                             "          `-DeclRefExpr 0x2176c60 <col:9> 'bool' lvalue Var 0x2176bd0 'e' 'bool'\n";
+
+        GET_SYMBOL_DB(clang);
+
+        const Token *tok = Token::findsimplematch(tokenizer.tokens(), "e");
+        ASSERT(!!tok);
+        ASSERT(!!tok->valueType());
+        ASSERT_EQUALS("bool", tok->valueType()->str());
+    }
+
+    void valueType2() {
+        const char clang[] = "`-VarDecl 0xc9eda0 <1.cpp:2:1, col:17> col:13 s 'const char *' cinit\n"
+                             "  `-ImplicitCastExpr 0xc9eef0 <col:17> 'const char *' <ArrayToPointerDecay>\n"
+                             "    `-StringLiteral 0xc9eed0 <col:17> 'const char [6]' lvalue \"hello\"\n";
+
+        GET_SYMBOL_DB(clang);
+
+        const Token *tok = Token::findsimplematch(tokenizer.tokens(), "\"hello\"");
+        ASSERT(!!tok);
+        ASSERT(!!tok->valueType());
+        ASSERT_EQUALS("const char *", tok->valueType()->str());
+    }
+
+    void stdinLoc() {
+        // we should never encounter this
+        /*
+           int i;
+         */
+        const char clang[] = "`-VarDecl 0x5776bb240470 <<stdin>:1:1, col:5> col:5 i 'int'\n";
+
+        ASSERT_THROW_INTERNAL_EQUALS(parse(clang), AST, "invalid AST location: <<stdin>");
+    }
+
+    void crash() {
+        const char* clang = "TranslationUnitDecl 0x56037914f998 <<invalid sloc>> <invalid sloc>\n"
+                            "|-ClassTemplateDecl 0x560379196b58 <test1.cpp:1:1, col:50> col:37 A\n"
+                            "| |-TemplateTypeParmDecl 0x560379196950 <col:11> col:19 typename depth 0 index 0\n"
+                            "| |-TemplateTypeParmDecl 0x5603791969f8 <col:21> col:29 typename depth 0 index 1\n"
+                            "| `-CXXRecordDecl 0x560379196ac8 <col:31, col:50> col:37 class A definition\n"
+                            "|   |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init\n"
+                            "|   | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr\n"
+                            "|   | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param\n"
+                            "|   | |-MoveConstructor exists simple trivial needs_implicit\n"
+                            "|   | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param\n"
+                            "|   | |-MoveAssignment exists simple trivial needs_implicit\n"
+                            "|   | `-Destructor simple irrelevant trivial needs_implicit\n"
+                            "|   |-CXXRecordDecl 0x560379196de0 <col:31, col:37> col:37 implicit referenced class A\n"
+                            "|   `-CXXRecordDecl 0x560379196e70 <col:41, col:47> col:47 class b\n"
+                            "|-CXXRecordDecl 0x560379197110 parent 0x560379196ac8 prev 0x560379196e70 <line:2:1, col:63> col:50 class b definition\n"
+                            "| |-DefinitionData empty standard_layout trivially_copyable has_user_declared_ctor can_const_default_init\n"
+                            "| | |-DefaultConstructor defaulted_is_constexpr\n"
+                            "| | |-CopyConstructor simple trivial has_const_param needs_implicit implicit_has_const_param\n"
+                            "| | |-MoveConstructor exists simple trivial needs_implicit\n"
+                            "| | |-CopyAssignment simple trivial has_const_param needs_implicit implicit_has_const_param\n"
+                            "| | |-MoveAssignment exists simple trivial needs_implicit\n"
+                            "| | `-Destructor simple irrelevant trivial needs_implicit\n"
+                            "| |-CXXRecordDecl 0x560379197250 <col:35, col:50> col:50 implicit referenced class b\n"
+                            "| `-CXXConstructorDecl 0x5603791974b8 <col:54, col:60> col:54 b 'void (A<type-parameter-0-0, type-parameter-0-1> &)'\n"
+                            "|   `-ParmVarDecl 0x560379197380 <col:56, col:59> col:59 a 'A<type-parameter-0-0, type-parameter-0-1> &'\n"
+                            "`-CXXConstructorDecl 0x5603791b5600 parent 0x560379197110 prev 0x5603791974b8 <line:3:1, col:55> col:47 b 'void (A<type-parameter-0-0, type-parameter-0-1> &)'\n"
+                            "  |-ParmVarDecl 0x5603791b5570 <col:49, col:51> col:52 'A<type-parameter-0-0, type-parameter-0-1> &'\n"
+                            "  `-CompoundStmt 0x5603791b5700 <col:54, col:55>\n";
+        (void)parse(clang); // don't crash
+    }
+};
+
+REGISTER_TEST(TestClangImport)
diff --git a/test/testclass.cpp b/test/testclass.cpp
index 794f9b2c216..43ada536df2 100644
--- a/test/testclass.cpp
+++ b/test/testclass.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,45 +16,34 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <tinyxml2.h>
-
+#include "check.h"
 #include "checkclass.h"
-#include "library.h"
+#include "ctu.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
 
+#include <cstddef>
+#include <list>
+#include <string>
+#include <vector>
 
 class TestClass : public TestFixture {
 public:
-    TestClass() : TestFixture("TestClass") {
-    }
+    TestClass() : TestFixture("TestClass") {}
 
 private:
-    Settings settings0;
-    Settings settings1;
-
-    void run() OVERRIDE {
-        settings0.addEnabled("style");
-        settings1.addEnabled("warning");
-
-        // Load std.cfg configuration
-        {
-            const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-            "<def>\n"
-            "  <memory>\n"
-            "    <alloc init=\"false\">malloc</alloc>\n"
-            "    <dealloc>free</dealloc>\n"
-            "  </memory>\n"
-            "  <smart-pointer class-name=\"std::shared_ptr\"/>\n"
-            "</def>";
-            tinyxml2::XMLDocument doc;
-            doc.Parse(xmldata, sizeof(xmldata));
-            settings0.library.load(doc);
-            settings1.library.load(doc);
-        }
-
-
+    const Settings settings0 = settingsBuilder().severity(Severity::style).library("std.cfg").build();
+    const Settings settings0_i = settingsBuilder(settings0).certainty(Certainty::inconclusive).build();
+    const Settings settings1 = settingsBuilder().severity(Severity::warning).library("std.cfg").build();
+    const Settings settings2 = settingsBuilder().severity(Severity::style).library("std.cfg").certainty(Certainty::inconclusive).build();
+    const Settings settings3 = settingsBuilder().severity(Severity::style).library("std.cfg").severity(Severity::warning).build();
+    const Settings settings3_i = settingsBuilder(settings3).certainty(Certainty::inconclusive).build();
+    const Settings settings4 = settingsBuilder().severity(Severity::warning).severity(Severity::portability).library("std.cfg").library("posix.cfg").build();
+
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(virtualDestructor1);      // Base class not found => no error
         TEST_CASE(virtualDestructor2);      // Base class doesn't have a destructor
         TEST_CASE(virtualDestructor3);      // Base class has a destructor, but it's not virtual
@@ -71,14 +60,12 @@ class TestClass : public TestFixture {
         TEST_CASE(copyConstructor2); // ticket #4458
         TEST_CASE(copyConstructor3); // defaulted/deleted
         TEST_CASE(copyConstructor4); // base class with private constructor
+        TEST_CASE(copyConstructor5); // multiple inheritance
+        TEST_CASE(copyConstructor6); // array of pointers
+        TEST_CASE(deletedMemberPointer); // deleted member pointer in destructor
         TEST_CASE(noOperatorEq); // class with memory management should have operator eq
         TEST_CASE(noDestructor); // class with memory management should have destructor
 
-        TEST_CASE(operatorEq1);
-        TEST_CASE(operatorEq2);
-        TEST_CASE(operatorEq3); // ticket #3051
-        TEST_CASE(operatorEq4); // ticket #3114
-        TEST_CASE(operatorEq5); // ticket #3296
         TEST_CASE(operatorEqRetRefThis1);
         TEST_CASE(operatorEqRetRefThis2); // ticket #1323
         TEST_CASE(operatorEqRetRefThis3); // ticket #1405
@@ -175,6 +162,40 @@ class TestClass : public TestFixture {
         TEST_CASE(const65); // ticket #8693
         TEST_CASE(const66); // ticket #7714
         TEST_CASE(const67); // ticket #9193
+        TEST_CASE(const68); // ticket #6471
+        TEST_CASE(const69); // ticket #9806
+        TEST_CASE(const70); // variadic template can receive more arguments than in its definition
+        TEST_CASE(const71); // ticket #10146
+        TEST_CASE(const72); // ticket #10520
+        TEST_CASE(const73); // ticket #10735
+        TEST_CASE(const74); // ticket #10671
+        TEST_CASE(const75); // ticket #10065
+        TEST_CASE(const76); // ticket #10825
+        TEST_CASE(const77); // ticket #10307, #10311
+        TEST_CASE(const78); // ticket #10315
+        TEST_CASE(const79); // ticket #9861
+        TEST_CASE(const80); // ticket #11328
+        TEST_CASE(const81); // ticket #11330
+        TEST_CASE(const82); // ticket #11513
+        TEST_CASE(const83);
+        TEST_CASE(const84);
+        TEST_CASE(const85);
+        TEST_CASE(const86);
+        TEST_CASE(const87);
+        TEST_CASE(const88);
+        TEST_CASE(const89);
+        TEST_CASE(const90);
+        TEST_CASE(const91);
+        TEST_CASE(const92);
+        TEST_CASE(const93);
+        TEST_CASE(const94);
+        TEST_CASE(const95); // #13320 - do not warn about r-value ref method
+        TEST_CASE(const96);
+        TEST_CASE(const97);
+        TEST_CASE(const98);
+        TEST_CASE(const99);
+        TEST_CASE(const100);
+
         TEST_CASE(const_handleDefaultParameters);
         TEST_CASE(const_passThisToMemberOfOtherClass);
         TEST_CASE(assigningPointerToPointerIsNotAConstOperation);
@@ -202,8 +223,13 @@ class TestClass : public TestFixture {
         TEST_CASE(constRangeBasedFor); // #5514
         TEST_CASE(const_shared_ptr);
         TEST_CASE(constPtrToConstPtr);
+        TEST_CASE(constTrailingReturnType);
+        TEST_CASE(constRefQualified);
+        TEST_CASE(staticArrayPtrOverload);
+        TEST_CASE(qualifiedNameMember); // #10872
 
         TEST_CASE(initializerListOrder);
+        TEST_CASE(initializerListArgument);
         TEST_CASE(initializerListUsage);
         TEST_CASE(selfInitialization);
 
@@ -217,80 +243,85 @@ class TestClass : public TestFixture {
         TEST_CASE(explicitConstructors);
         TEST_CASE(copyCtorAndEqOperator);
 
-        TEST_CASE(unsafeClassDivZero);
-
         TEST_CASE(override1);
         TEST_CASE(overrideCVRefQualifiers);
 
+        TEST_CASE(uselessOverride);
+
+        TEST_CASE(thisUseAfterFree);
+
         TEST_CASE(unsafeClassRefMember);
+
+        TEST_CASE(ctuOneDefinitionRule);
+
+        TEST_CASE(testGetFileInfo);
+
+        TEST_CASE(returnByReference);
     }
 
-    void checkCopyCtorAndEqOperator(const char code[]) {
-        // Clear the error log
-        errout.str("");
-        Settings settings;
-        settings.addEnabled("warning");
+#define checkCopyCtorAndEqOperator(...) checkCopyCtorAndEqOperator_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkCopyCtorAndEqOperator_(const char* file, int line, const char (&code)[size]) {
+        const Settings settings = settingsBuilder().severity(Severity::warning).build();
 
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        tokenizer.simplifyTokenList2();
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check..
         CheckClass checkClass(&tokenizer, &settings, this);
-        checkClass.checkCopyCtorAndEqOperator();
+        (checkClass.checkCopyCtorAndEqOperator)();
     }
 
     void copyCtorAndEqOperator() {
-        checkCopyCtorAndEqOperator("class A \n"
-                                   "{ \n"
-                                   "    A(const A& other) { } \n"
+        checkCopyCtorAndEqOperator("class A\n"
+                                   "{\n"
+                                   "    A(const A& other) { }\n"
                                    "    A& operator=(const A& other) { return *this; }\n"
                                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
 
-        checkCopyCtorAndEqOperator("class A \n"
-                                   "{ \n"
+        checkCopyCtorAndEqOperator("class A\n"
+                                   "{\n"
                                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        checkCopyCtorAndEqOperator("class A \n"
-                                   "{ \n"
-                                   "    A(const A& other) { } \n"
+        checkCopyCtorAndEqOperator("class A\n"
+                                   "{\n"
+                                   "    A(const A& other) { }\n"
                                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        checkCopyCtorAndEqOperator("class A \n"
-                                   "{ \n"
+        checkCopyCtorAndEqOperator("class A\n"
+                                   "{\n"
                                    "    A& operator=(const A& other) { return *this; }\n"
                                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
 
-        checkCopyCtorAndEqOperator("class A \n"
-                                   "{ \n"
-                                   "    A(const A& other) { } \n"
+        checkCopyCtorAndEqOperator("class A\n"
+                                   "{\n"
+                                   "    A(const A& other) { }\n"
                                    "    int x;\n"
                                    "};");
-        TODO_ASSERT_EQUALS("[test.cpp:1]: (warning) The class 'A' has 'copy constructor' but lack of 'operator='.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:1]: (warning) The class 'A' has 'copy constructor' but lack of 'operator='.\n", "", errout_str());
         // TODO the error message should be clarified. It should say something like 'copy constructor is empty and will not assign i and therefore the behaviour is different to the default assignment operator'
 
-        checkCopyCtorAndEqOperator("class A \n"
-                                   "{ \n"
+        checkCopyCtorAndEqOperator("class A\n"
+                                   "{\n"
                                    "    A& operator=(const A& other) { return *this; }\n"
                                    "    int x;\n"
                                    "};");
-        TODO_ASSERT_EQUALS("[test.cpp:1]: (warning) The class 'A' has 'operator=' but lack of 'copy constructor'.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:1]: (warning) The class 'A' has 'operator=' but lack of 'copy constructor'.\n", "", errout_str());
         // TODO the error message should be clarified. It should say something like 'assignment operator does not assign i and therefore the behaviour is different to the default copy constructor'
 
-        checkCopyCtorAndEqOperator("class A \n"
-                                   "{ \n"
+        checkCopyCtorAndEqOperator("class A\n"
+                                   "{\n"
                                    "    A& operator=(const int &x) { this->x = x; return *this; }\n"
                                    "    int x;\n"
                                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkCopyCtorAndEqOperator("class A {\n"
                                    "public:\n"
@@ -310,7 +341,7 @@ class TestClass : public TestFixture {
                                    "private:\n"
                                    "    static int i;\n"
                                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #7987 - Don't show warning when there is a move constructor
         checkCopyCtorAndEqOperator("struct S {\n"
@@ -320,30 +351,27 @@ class TestClass : public TestFixture {
                                    "    test = std::move(s.test);\n"
                                    "    return *this;\n"
                                    "  }\n"
-                                   "};\n");
-        ASSERT_EQUALS("", errout.str());
+                                   "};");
+        ASSERT_EQUALS("", errout_str());
 
         // #8337 - False positive in copy constructor detection
         checkCopyCtorAndEqOperator("struct StaticListNode {\n"
                                    "  StaticListNode(StaticListNode*& prev) : m_next(0) {}\n"
                                    "  StaticListNode* m_next;\n"
                                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void checkExplicitConstructors(const char code[]) {
-        // Clear the error log
-        errout.str("");
-
+#define checkExplicitConstructors(...) checkExplicitConstructors_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkExplicitConstructors_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        tokenizer.simplifyTokenList2();
+        SimpleTokenizer tokenizer(settings0, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check..
         CheckClass checkClass(&tokenizer, &settings0, this);
-        checkClass.checkExplicitConstructors();
+        (checkClass.checkExplicitConstructors)();
     }
 
     void explicitConstructors() {
@@ -355,7 +383,7 @@ class TestClass : public TestFixture {
                                   "    explicit Class(const std::string&) { }\n"
                                   "    Class(int a, int b) { }\n"
                                   "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkExplicitConstructors("class Class {\n"
                                   "    Class() = delete;\n"
@@ -363,7 +391,7 @@ class TestClass : public TestFixture {
                                   "    explicit Class(Class&& other) { }\n"
                                   "    virtual int i() = 0;\n"
                                   "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkExplicitConstructors("class Class {\n"
                                   "    Class() = delete;\n"
@@ -371,37 +399,37 @@ class TestClass : public TestFixture {
                                   "    Class(Class&& other) = delete;\n"
                                   "    virtual int i() = 0;\n"
                                   "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkExplicitConstructors("class Class {\n"
                                   "    Class(int i) { }\n"
                                   "};");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Class 'Class' has a constructor with 1 argument that is not explicit.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (style) Class 'Class' has a constructor with 1 argument that is not explicit. [noExplicitConstructor]\n", errout_str());
 
         checkExplicitConstructors("class Class {\n"
                                   "    Class(const Class& other) { }\n"
                                   "    virtual int i() = 0;\n"
                                   "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkExplicitConstructors("class Class {\n"
                                   "    Class(Class&& other) { }\n"
                                   "    virtual int i() = 0;\n"
                                   "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6585
         checkExplicitConstructors("class Class {\n"
                                   "    private: Class(const Class&);\n"
                                   "    virtual int i() = 0;\n"
                                   "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkExplicitConstructors("class Class {\n"
                                   "    public: Class(const Class&);\n"
                                   "    virtual int i() = 0;\n"
                                   "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #7465: Error properly reported in templates
         checkExplicitConstructors("template <class T> struct Test {\n"
@@ -412,7 +440,7 @@ class TestClass : public TestFixture {
                                   "  Test <int> test;\n"
                                   "  return 0;\n"
                                   "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Struct 'Test < int >' has a constructor with 1 argument that is not explicit.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:3]: (style) Struct 'Test < int >' has a constructor with 1 argument that is not explicit. [noExplicitConstructor]\n", errout_str());
 
         // #7465: No error for copy or move constructors
         checkExplicitConstructors("template <class T> struct Test {\n"
@@ -425,7 +453,7 @@ class TestClass : public TestFixture {
                                   "  Test <int> test;\n"
                                   "  return 0;\n"
                                   "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #8600
         checkExplicitConstructors("struct A { struct B; };\n"
@@ -433,27 +461,74 @@ class TestClass : public TestFixture {
                                   "    B() = default;\n"
                                   "    B(const B&) {}\n"
                                   "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkExplicitConstructors("struct A{"
                                   "    A(int, int y=2) {}"
                                   "};");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Struct 'A' has a constructor with 1 argument that is not explicit.\n", errout.str());
-    }
-
-    void checkDuplInheritedMembers(const char code[]) {
-        // Clear the error log
-        errout.str("");
+        ASSERT_EQUALS("[test.cpp:1:14]: (style) Struct 'A' has a constructor with 1 argument that is not explicit. [noExplicitConstructor]\n", errout_str());
 
+        checkExplicitConstructors("struct Foo {\n" // #10515
+                                  "    template <typename T>\n"
+                                  "    explicit constexpr Foo(T) {}\n"
+                                  "};\n"
+                                  "struct Bar {\n"
+                                  "    template <typename T>\n"
+                                  "    constexpr explicit Bar(T) {}\n"
+                                  "};\n"
+                                  "struct Baz {\n"
+                                  "    explicit constexpr Baz(int) {}\n"
+                                  "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkExplicitConstructors("class Token;\n" // #11126
+                                  "struct Branch {\n"
+                                  "    Branch(Token* tok = nullptr) : endBlock(tok) {}\n"
+                                  "    Token* endBlock = nullptr;\n"
+                                  "};\n");
+        ASSERT_EQUALS("[test.cpp:3:5]: (style) Struct 'Branch' has a constructor with 1 argument that is not explicit. [noExplicitConstructor]\n", errout_str());
+
+        checkExplicitConstructors("struct S {\n"
+                                  "    S(std::initializer_list<int> il) : v(il) {}\n"
+                                  "    std::vector<int> v;\n"
+                                  "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkExplicitConstructors("template<class T>\n" // #10977
+                                  "struct A {\n"
+                                  "    template<class... Ts>\n"
+                                  "    A(Ts&&... ts) {}\n"
+                                  "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkExplicitConstructors("class Color {\n" // #7176
+                                  "public:\n"
+                                  "    Color(unsigned int rgba);\n"
+                                  "    Color(std::uint8_t r = 0, std::uint8_t g = 0, std::uint8_t b = 0, std::uint8_t a = 255);\n"
+                                  "};\n");
+        ASSERT_EQUALS("[test.cpp:3:5]: (style) Class 'Color' has a constructor with 1 argument that is not explicit. [noExplicitConstructor]\n"
+                      "[test.cpp:4:5]: (style) Class 'Color' has a constructor with 1 argument that is not explicit. [noExplicitConstructor]\n",
+                      errout_str());
+
+        checkExplicitConstructors("template <typename T>\n" // #13878
+                                  "struct S {\n"
+                                  "    S(std::nullptr_t) {}\n"
+                                  "    explicit S(T* p) : m(p) {}\n"
+                                  "    T* m{};\n"
+                                  "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+#define checkDuplInheritedMembers(...) checkDuplInheritedMembers_( __FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkDuplInheritedMembers_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings1, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        tokenizer.simplifyTokenList2();
+        SimpleTokenizer tokenizer(settings1, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check..
         CheckClass checkClass(&tokenizer, &settings1, this);
-        checkClass.checkDuplInheritedMembers();
+        (checkClass.checkDuplInheritedMembers)();
     }
 
     void duplInheritedMembers() {
@@ -463,7 +538,7 @@ class TestClass : public TestFixture {
                                   "struct Derived : Base {\n"
                                   "   int x;\n"
                                   "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkDuplInheritedMembers("class Base {\n"
                                   "   protected:\n"
@@ -472,7 +547,7 @@ class TestClass : public TestFixture {
                                   "struct Derived : Base {\n"
                                   "   int x;\n"
                                   "};");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:6]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:6:8]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base'. [duplInheritedMember]\n", errout_str());
 
         checkDuplInheritedMembers("class Base {\n"
                                   "   protected:\n"
@@ -481,7 +556,7 @@ class TestClass : public TestFixture {
                                   "struct Derived : public Base {\n"
                                   "   int x;\n"
                                   "};");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:6]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:6:8]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base'. [duplInheritedMember]\n", errout_str());
 
         checkDuplInheritedMembers("class Base0 {\n"
                                   "   int x;\n"
@@ -492,7 +567,7 @@ class TestClass : public TestFixture {
                                   "struct Derived : Base0, Base1 {\n"
                                   "   int x;\n"
                                   "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkDuplInheritedMembers("class Base0 {\n"
                                   "   protected:\n"
@@ -504,7 +579,7 @@ class TestClass : public TestFixture {
                                   "struct Derived : Base0, Base1 {\n"
                                   "   int x;\n"
                                   "};");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:9]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base0'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:9:8]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base0'. [duplInheritedMember]\n", errout_str());
 
         checkDuplInheritedMembers("class Base0 {\n"
                                   "   protected:\n"
@@ -517,8 +592,8 @@ class TestClass : public TestFixture {
                                   "struct Derived : Base0, Base1 {\n"
                                   "   int x;\n"
                                   "};");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:10]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base0'.\n"
-                      "[test.cpp:7] -> [test.cpp:10]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base1'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:10:8]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base0'. [duplInheritedMember]\n"
+                      "[test.cpp:7:8] -> [test.cpp:10:8]: (warning) The struct 'Derived' defines member variable with name 'x' also defined in its parent class 'Base1'. [duplInheritedMember]\n", errout_str());
 
         checkDuplInheritedMembers("class Base {\n"
                                   "   int x;\n"
@@ -526,7 +601,7 @@ class TestClass : public TestFixture {
                                   "struct Derived : Base {\n"
                                   "   int y;\n"
                                   "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkDuplInheritedMembers("class A {\n"
                                   "   int x;\n"
@@ -534,20 +609,20 @@ class TestClass : public TestFixture {
                                   "struct B {\n"
                                   "   int x;\n"
                                   "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Unknown 'Base' class
         checkDuplInheritedMembers("class Derived : public UnknownBase {\n"
                                   "  int x;\n"
                                   "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkDuplInheritedMembers("class Base {\n"
                                   "   int x;\n"
                                   "};\n"
                                   "class Derived : public Base {\n"
                                   "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6692
         checkDuplInheritedMembers("namespace test1 {\n"
@@ -559,22 +634,124 @@ class TestClass : public TestFixture {
                                   "   int Value;\n"
                                   "   };\n"
                                   "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-    }
+        // #9957
+        checkDuplInheritedMembers("class Base {\n"
+                                  "    public:\n"
+                                  "        int i;\n"
+                                  "};\n"
+                                  "class Derived1: public Base {\n"
+                                  "    public:\n"
+                                  "        int j;\n"
+                                  "};\n"
+                                  "class Derived2 : public Derived1 {\n"
+                                  "    int i;\n"
+                                  "};");
+        ASSERT_EQUALS("[test.cpp:3:13] -> [test.cpp:10:9]: (warning) The class 'Derived2' defines member variable with name 'i' also defined in its parent class 'Base'. [duplInheritedMember]\n", errout_str());
+
+        // don't crash on recursive template
+        checkDuplInheritedMembers("template<size_t N>\n"
+                                  "struct BitInt : public BitInt<N+1> { };");
+        ASSERT_EQUALS("", errout_str());
+
+        // don't crash on recursive template
+        checkDuplInheritedMembers("namespace _impl {\n"
+                                  "    template <typename AlwaysVoid, typename>\n"
+                                  "    struct fn_traits;\n"
+                                  "}\n"
+                                  "template <typename T>\n"
+                                  "struct function_traits\n"
+                                  "    : public _impl::fn_traits<void, std::remove_reference_t<T>> {};\n"
+                                  "namespace _impl {\n"
+                                  "    template <typename T>\n"
+                                  "    struct fn_traits<decltype(void(&T::operator())), T>\n"
+                                  "        : public fn_traits<void, decltype(&T::operator())> {};\n"
+                                  "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10594
+        checkDuplInheritedMembers("template<int i> struct A { bool a = true; };\n"
+                                  "struct B { bool a; };\n"
+                                  "template<> struct A<1> : B {};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkDuplInheritedMembers("struct B {\n"
+                                  "    int g() const;\n"
+                                  "    virtual int f() const { return g(); }\n"
+                                  "};\n"
+                                  "struct D : B {\n"
+                                  "    int g() const;\n"
+                                  "    int f() const override { return g(); }\n"
+                                  "};\n");
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:6:9]: (warning) The struct 'D' defines member function with name 'g' also defined in its parent struct 'B'. [duplInheritedMember]\n",
+                      errout_str());
+
+        checkDuplInheritedMembers("struct B {\n"
+                                  "    int g() const;\n"
+                                  "};\n"
+                                  "struct D : B {\n"
+                                  "    int g(int) const;\n"
+                                  "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkDuplInheritedMembers("struct S {\n"
+                                  "    struct T {\n"
+                                  "        T() {}\n"
+                                  "    };\n"
+                                  "};\n"
+                                  "struct T : S::T {\n"
+                                  "    T() : S::T() {}\n"
+                                  "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkDuplInheritedMembers("struct S {};\n" // #11827
+                                  "struct SPtr {\n"
+                                  "    virtual S* operator->() const { return p; }\n"
+                                  "    S* p = nullptr;\n"
+                                  "};\n"
+                                  "struct T : public S {};\n"
+                                  "struct TPtr : public SPtr {\n"
+                                  "    T* operator->() const { return (T*)p; }\n"
+                                  "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkDuplInheritedMembers("struct B { virtual int& get() = 0; };\n" // #12311
+                                  "struct D : B {\n"
+                                  "    int i{};\n"
+                                  "    int& get() override { return i; }\n"
+                                  "    const int& get() const { return i; }\n"
+                                  "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkDuplInheritedMembers("class Base {\n" // #12353
+                                  "    public:\n"
+                                  "        void One();\n"
+                                  "        void Two();\n"
+                                  "};\n"
+                                  "class Derived : public Base {\n"
+                                  "public:\n"
+                                  "    void Two() = delete;\n"
+                                  "};\n");
+        ASSERT_EQUALS("", errout_str());
 
-    void checkCopyConstructor(const char code[]) {
-        // Clear the error log
-        errout.str("");
+        checkDuplInheritedMembers("struct B { void f(); };\n" // #14583
+                                  "struct D : B {\n"
+                                  "    template <typename>\n"
+                                  "    void f();\n"
+                                  "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
 
+#define checkCopyConstructor(...) checkCopyConstructor_( __FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkCopyConstructor_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        tokenizer.simplifyTokenList2();
+        SimpleTokenizer tokenizer(settings3, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check..
-        CheckClass checkClass(&tokenizer, &settings0, this);
+        CheckClass checkClass(&tokenizer, &settings3, this);
         checkClass.copyconstructors();
     }
 
@@ -596,7 +773,7 @@ class TestClass : public TestFixture {
                              "   F&operator=(const F&);\n"
                              "   ~F();\n"
                              "};");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Value of pointer 'p', which points to allocated memory, is copied in copy constructor instead of allocating new memory.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5]: (warning) Value of pointer 'p', which points to allocated memory, is copied in copy constructor instead of allocating new memory.\n", "", errout_str());
 
         checkCopyConstructor("class F {\n"
                              "   char *p;\n"
@@ -609,10 +786,10 @@ class TestClass : public TestFixture {
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
                              "};");
-        TODO_ASSERT_EQUALS("[test.cpp:4]: (warning) Value of pointer 'p', which points to allocated memory, is copied in copy constructor instead of allocating new memory.\n"
+        TODO_ASSERT_EQUALS("[test.cpp:4:7]: (warning) Value of pointer 'p', which points to allocated memory, is copied in copy constructor instead of allocating new memory. [copyCtorPointerCopying]\n"
                            "[test.cpp:3] -> [test.cpp:7]: (warning) Copy constructor does not allocate memory for member 'p' although memory has been allocated in other constructors.\n",
-                           "[test.cpp:4]: (warning) Value of pointer 'p', which points to allocated memory, is copied in copy constructor instead of allocating new memory.\n"
-                           , errout.str());
+                           "[test.cpp:4:7]: (warning) Value of pointer 'p', which points to allocated memory, is copied in copy constructor instead of allocating new memory. [copyCtorPointerCopying]\n"
+                           , errout_str());
 
         checkCopyConstructor("class F\n"
                              "{\n"
@@ -631,8 +808,8 @@ class TestClass : public TestFixture {
                              "};");
         TODO_ASSERT_EQUALS("[test.cpp:5]: (warning) Value of pointer 'p', which points to allocated memory, is copied in copy constructor instead of allocating new memory.\n"
                            "[test.cpp:5] -> [test.cpp:10]: (warning) Copy constructor does not allocate memory for member 'p' although memory has been allocated in other constructors.\n",
-                           "[test.cpp:5]: (warning) Value of pointer 'p', which points to allocated memory, is copied in copy constructor instead of allocating new memory.\n"
-                           , errout.str());
+                           ""
+                           , errout_str());
 
         checkCopyConstructor("class kalci\n"
                              "{\n"
@@ -659,7 +836,7 @@ class TestClass : public TestFixture {
                              "   ~kalci();\n"
                              "   kalci& operator=(const kalci&kalci);\n"
                              "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkCopyConstructor("class F\n"
                              "{\n"
@@ -684,7 +861,7 @@ class TestClass : public TestFixture {
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
                              "};");
-        TODO_ASSERT_EQUALS("[test.cpp:14] -> [test.cpp:11]: (warning) Copy constructor does not allocate memory for member 'd' although memory has been allocated in other constructors.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:14] -> [test.cpp:11]: (warning) Copy constructor does not allocate memory for member 'd' although memory has been allocated in other constructors.\n", "", errout_str());
 
         checkCopyConstructor("class F {\n"
                              "   char *c;\n"
@@ -698,7 +875,7 @@ class TestClass : public TestFixture {
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
                              "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkCopyConstructor("class F {\n"
                              "   char *c;\n"
@@ -712,7 +889,7 @@ class TestClass : public TestFixture {
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
                              "};");
-        TODO_ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:4]: (warning) Copy constructor does not allocate memory for member 'd' although memory has been allocated in other constructors.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:4]: (warning) Copy constructor does not allocate memory for member 'd' although memory has been allocated in other constructors.\n", "", errout_str());
 
         checkCopyConstructor("class F\n"
                              "{\n"
@@ -727,7 +904,7 @@ class TestClass : public TestFixture {
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
                              "};");
-        ASSERT_EQUALS("[test.cpp:8]: (warning) Class 'F' does not have a copy constructor which is recommended since it has dynamic memory/resource allocation(s).\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:8]: (warning) Class 'F' does not have a copy constructor which is recommended since it has dynamic memory/resource management.\n", "", errout_str());
 
         checkCopyConstructor("class F\n"
                              "{\n"
@@ -751,7 +928,7 @@ class TestClass : public TestFixture {
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
                              "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkCopyConstructor("class F : E\n"
                              "{\n"
@@ -762,7 +939,7 @@ class TestClass : public TestFixture {
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
                              "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkCopyConstructor("class E { E(E&); };\n" // non-copyable
                              "class F : E\n"
@@ -774,7 +951,7 @@ class TestClass : public TestFixture {
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
                              "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkCopyConstructor("class E {};\n"
                              "class F : E {\n"
@@ -785,7 +962,7 @@ class TestClass : public TestFixture {
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
                              "};");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Class 'F' does not have a copy constructor which is recommended since it has dynamic memory/resource allocation(s).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:7]: (warning) Class 'F' does not have a copy constructor which is recommended since it has dynamic memory/resource management. [noCopyConstructor]\n", errout_str());
 
         checkCopyConstructor("class F {\n"
                              "   char *p;\n"
@@ -796,7 +973,7 @@ class TestClass : public TestFixture {
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
                              "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkCopyConstructor("class F {\n"
                              "   char *p;\n"
@@ -804,7 +981,7 @@ class TestClass : public TestFixture {
                              "   ~F();\n"
                              "   F& operator=(const F&f);\n"
                              "};");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Class 'F' does not have a copy constructor which is recommended since it has dynamic memory/resource allocation(s).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (warning) Class 'F' does not have a copy constructor which is recommended since it has dynamic memory/resource management. [noCopyConstructor]\n", errout_str());
 
         // #7198
         checkCopyConstructor("struct F {\n"
@@ -813,7 +990,7 @@ class TestClass : public TestFixture {
                              "      p = malloc(100);\n"
                              "   }\n"
                              "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void copyConstructor2() { // ticket #4458
@@ -830,7 +1007,7 @@ class TestClass : public TestFixture {
                              "     Vector& operator=(const Vector&v);\n"
                              "    _Tp* _M_finish;\n"
                              "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void copyConstructor3() {
@@ -841,7 +1018,7 @@ class TestClass : public TestFixture {
                              "   F&operator=(const F &f);\n"
                              "   ~F();\n"
                              "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkCopyConstructor("struct F {\n"
                              "   char* c;\n"
@@ -850,7 +1027,7 @@ class TestClass : public TestFixture {
                              "   F&operator=(const F &f);\n"
                              "   ~F();\n"
                              "};");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Struct 'F' has dynamic memory/resource allocation(s). The copy constructor is explicitly defaulted but the default copy constructor does not work well. It is recommended to define or delete the copy constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (warning) Struct 'F' has dynamic memory/resource allocation(s). The copy constructor is explicitly defaulted but the default copy constructor does not work well. It is recommended to define or delete the copy constructor. [noCopyConstructor]\n", errout_str());
     }
 
     void copyConstructor4() {
@@ -873,7 +1050,73 @@ class TestClass : public TestFixture {
                              "private:\n"
                              "    int* m_ptr;\n"
                              "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void copyConstructor5() {
+        checkCopyConstructor("class Copyable {};\n"
+                             "\n"
+                             "class Foo : public Copyable, public UnknownType {\n"
+                             "public:\n"
+                             "    Foo() : m_ptr(new int) {}\n"
+                             "    ~Foo() { delete m_ptr; }\n"
+                             "private:\n"
+                             "    int* m_ptr;\n"
+                             "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkCopyConstructor("class Copyable {};\n"
+                             "\n"
+                             "class Foo : public UnknownType, public Copyable {\n"
+                             "public:\n"
+                             "    Foo() : m_ptr(new int) {}\n"
+                             "    ~Foo() { delete m_ptr; }\n"
+                             "private:\n"
+                             "    int* m_ptr;\n"
+                             "};");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void copyConstructor6() {
+        checkCopyConstructor("struct S {\n"
+                             "    S() {\n"
+                             "        for (int i = 0; i < 5; i++)\n"
+                             "            a[i] = new char[3];\n"
+                             "    }\n"
+                             "    char* a[5];\n"
+                             "};\n");
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (warning) Struct 'S' does not have a copy constructor which is recommended since it has dynamic memory/resource management.\n"
+                           "[test.cpp:4]: (warning) Struct 'S' does not have a operator= which is recommended since it has dynamic memory/resource management.\n"
+                           "[test.cpp:4]: (warning) Struct 'S' does not have a destructor which is recommended since it has dynamic memory/resource management.\n",
+                           "",
+                           errout_str());
+    }
+
+    void deletedMemberPointer() {
+
+        // delete ...
+        checkCopyConstructor("struct P {};\n"
+                             "class C {\n"
+                             "    P *p;\n"
+                             "public:\n"
+                             "    explicit C(P *p) : p(p) {}\n"
+                             "    ~C() { delete p; }\n"
+                             "    void f() {}\n"
+                             "};\n");
+        ASSERT_EQUALS("[test.cpp:6:19]: (warning) Class 'C' does not have a copy constructor which is recommended since it has dynamic memory/resource management. [noCopyConstructor]\n"
+                      "[test.cpp:6:19]: (warning) Class 'C' does not have a operator= which is recommended since it has dynamic memory/resource management. [noOperatorEq]\n", errout_str());
+
+        // free(...)
+        checkCopyConstructor("struct P {};\n"
+                             "class C {\n"
+                             "    P *p;\n"
+                             "public:\n"
+                             "    explicit C(P *p) : p(p) {}\n"
+                             "    ~C() { free(p); }\n"
+                             "    void f() {}\n"
+                             "};\n");
+        ASSERT_EQUALS("[test.cpp:6:17]: (warning) Class 'C' does not have a copy constructor which is recommended since it has dynamic memory/resource management. [noCopyConstructor]\n"
+                      "[test.cpp:6:17]: (warning) Class 'C' does not have a operator= which is recommended since it has dynamic memory/resource management. [noOperatorEq]\n", errout_str());
     }
 
     void noOperatorEq() {
@@ -883,7 +1126,7 @@ class TestClass : public TestFixture {
                              "   F(const F &f);\n"
                              "   ~F();\n"
                              "};");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Struct 'F' does not have a operator= which is recommended since it has dynamic memory/resource allocation(s).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (warning) Struct 'F' does not have a operator= which is recommended since it has dynamic memory/resource management. [noOperatorEq]\n", errout_str());
 
         // defaulted operator=
         checkCopyConstructor("struct F {\n"
@@ -893,7 +1136,7 @@ class TestClass : public TestFixture {
                              "   F &operator=(const F &f) = default;\n"
                              "   ~F();\n"
                              "};");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Struct 'F' has dynamic memory/resource allocation(s). The operator= is explicitly defaulted but the default operator= does not work well. It is recommended to define or delete the operator=.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (warning) Struct 'F' has dynamic memory/resource allocation(s). The operator= is explicitly defaulted but the default operator= does not work well. It is recommended to define or delete the operator=. [noOperatorEq]\n", errout_str());
 
         // deleted operator=
         checkCopyConstructor("struct F {\n"
@@ -903,7 +1146,7 @@ class TestClass : public TestFixture {
                              "   F &operator=(const F &f) = delete;\n"
                              "   ~F();\n"
                              "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // base class deletes operator=
         checkCopyConstructor("struct F : NonCopyable {\n"
@@ -912,7 +1155,7 @@ class TestClass : public TestFixture {
                              "   F(const F &f);\n"
                              "   ~F();\n"
                              "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void noDestructor() {
@@ -922,7 +1165,7 @@ class TestClass : public TestFixture {
                              "   F(const F &f);\n"
                              "   F&operator=(const F&);"
                              "};");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Struct 'F' does not have a destructor which is recommended since it has dynamic memory/resource allocation(s).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (warning) Struct 'F' does not have a destructor which is recommended since it has dynamic memory/resource management. [noDestructor]\n", errout_str());
 
         checkCopyConstructor("struct F {\n"
                              "   C* c;\n"
@@ -930,7 +1173,15 @@ class TestClass : public TestFixture {
                              "   F(const F &f);\n"
                              "   F&operator=(const F&);"
                              "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        checkCopyConstructor("struct F {\n"
+                             "   int* i;\n"
+                             "   F() { i = new int(); }\n"
+                             "   F(const F &f);\n"
+                             "   F& operator=(const F&);"
+                             "};");
+        ASSERT_EQUALS("[test.cpp:3:10]: (warning) Struct 'F' does not have a destructor which is recommended since it has dynamic memory/resource management. [noDestructor]\n", errout_str());
 
         checkCopyConstructor("struct Data { int x; int y; };\n"
                              "struct F {\n"
@@ -939,7 +1190,7 @@ class TestClass : public TestFixture {
                              "   F(const F &f);\n"
                              "   F&operator=(const F&);"
                              "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Struct 'F' does not have a destructor which is recommended since it has dynamic memory/resource allocation(s).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:10]: (warning) Struct 'F' does not have a destructor which is recommended since it has dynamic memory/resource management. [noDestructor]\n", errout_str());
 
         // defaulted destructor
         checkCopyConstructor("struct F {\n"
@@ -949,7 +1200,7 @@ class TestClass : public TestFixture {
                              "   F &operator=(const F &f);\n"
                              "   ~F() = default;\n"
                              "};");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Struct 'F' has dynamic memory/resource allocation(s). The destructor is explicitly defaulted but the default destructor does not work well. It is recommended to define the destructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (warning) Struct 'F' has dynamic memory/resource allocation(s). The destructor is explicitly defaulted but the default destructor does not work well. It is recommended to define the destructor. [noDestructor]\n", errout_str());
 
         // deleted destructor
         checkCopyConstructor("struct F {\n"
@@ -959,186 +1210,16 @@ class TestClass : public TestFixture {
                              "   F &operator=(const F &f);\n"
                              "   ~F() = delete;\n"
                              "};");
-        ASSERT_EQUALS("", errout.str());
-    }
-
-    // Check the operator Equal
-    void checkOpertorEq(const char code[]) {
-        // Clear the error log
-        errout.str("");
-
-        settings0.inconclusive = true;
-
-        // Tokenize..
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        tokenizer.simplifyTokenList2();
-
-        // Check..
-        CheckClass checkClass(&tokenizer, &settings0, this);
-        checkClass.operatorEq();
-    }
-
-    void operatorEq1() {
-        checkOpertorEq("class A\n"
-                       "{\n"
-                       "public:\n"
-                       "    void goo() {}"
-                       "    void operator=(const A&);\n"
-                       "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style) 'A::operator=' should return 'A &'.\n", errout.str());
-
-        checkOpertorEq("class A\n"
-                       "{\n"
-                       "public:\n"
-                       "    void goo() {}"
-                       "    void operator=(const A&)=delete;\n"
-                       "};");
-        ASSERT_EQUALS("", errout.str());
-
-        checkOpertorEq("class A\n"
-                       "{\n"
-                       "public:\n"
-                       "    void goo() {}"
-                       "    void operator=(A&);\n"
-                       "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style) 'A::operator=' should return 'A &'.\n", errout.str());
-
-        checkOpertorEq("class A\n"
-                       "{\n"
-                       "private:\n"
-                       "    void operator=(const A&);\n"
-                       "};");
-        ASSERT_EQUALS("", errout.str());
-
-        checkOpertorEq("class A\n"
-                       "{\n"
-                       "protected:\n"
-                       "    void operator=(const A&);\n"
-                       "};");
-        ASSERT_EQUALS("", errout.str());
-
-        checkOpertorEq("class A\n"
-                       "{\n"
-                       "private:\n"
-                       "    void operator=(const A&)=delete;\n"
-                       "};");
-        ASSERT_EQUALS("", errout.str());
-
-        checkOpertorEq("class A\n"
-                       "{\n"
-                       "    void operator=(const A&);\n"
-                       "};");
-        ASSERT_EQUALS("", errout.str());
-
-        checkOpertorEq("class A\n"
-                       "{\n"
-                       "public:\n"
-                       "    void goo() {}\n"
-                       "private:\n"
-                       "    void operator=(const A&);\n"
-                       "};");
-        ASSERT_EQUALS("", errout.str());
-
-        checkOpertorEq("class A\n"
-                       "{\n"
-                       "public:\n"
-                       "    void operator=(const A&);\n"
-                       "};\n"
-                       "class B\n"
-                       "{\n"
-                       "public:\n"
-                       "    void operator=(const B&);\n"
-                       "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style) 'A::operator=' should return 'A &'.\n"
-                      "[test.cpp:9]: (style) 'B::operator=' should return 'B &'.\n", errout.str());
-
-        checkOpertorEq("struct A\n"
-                       "{\n"
-                       "    void operator=(const A&);\n"
-                       "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style) 'A::operator=' should return 'A &'.\n", errout.str());
-
-        checkOpertorEq("struct A\n"
-                       "{\n"
-                       "    void operator=(const A&)=delete;\n"
-                       "};");
-        ASSERT_EQUALS("", errout.str());
-
-        // Ticket #7017
-        checkOpertorEq("template<class T> struct X {\n"
-                       "  inline X(const X& Rhs);\n"
-                       "  inline X<T>& operator =(const X& Rhs);\n"
-                       "};");
-        ASSERT_EQUALS("", errout.str());
-    }
-
-    void operatorEq2() {
-        checkOpertorEq("class A\n"
-                       "{\n"
-                       "public:\n"
-                       "    void * operator=(const A&);\n"
-                       "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style) 'A::operator=' should return 'A &'.\n", errout.str());
-
-        checkOpertorEq("class A\n"
-                       "{\n"
-                       "public:\n"
-                       "    A * operator=(const A&);\n"
-                       "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style) 'A::operator=' should return 'A &'.\n", errout.str());
-
-        checkOpertorEq("class A\n"
-                       "{\n"
-                       "public:\n"
-                       "    const A & operator=(const A&);\n"
-                       "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style) 'A::operator=' should return 'A &'.\n", errout.str());
-
-        checkOpertorEq("class A\n"
-                       "{\n"
-                       "public:\n"
-                       "    B & operator=(const A&);\n"
-                       "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style) 'A::operator=' should return 'A &'.\n", errout.str());
-    }
-
-    void operatorEq3() { // ticket #3051
-        checkOpertorEq("class A\n"
-                       "{\n"
-                       "public:\n"
-                       "    A * operator=(const A*);\n"
-                       "};");
-        ASSERT_EQUALS("", errout.str());
-    }
-
-    void operatorEq4() { // ticket #3114 (infinite loop)
-        checkOpertorEq("struct A {\n"
-                       "    A& operator=(A const& a) { return operator=(&a); }\n"
-                       "    A& operator=(const A*) { return *this; }\n"
-                       "};");
-        ASSERT_EQUALS("", errout.str());
-    }
-
-    void operatorEq5() { // ticket #3296 (virtual operator)
-        checkOpertorEq(
-            "class A {\n"
-            "    virtual A& operator=(const A &a) {return *this};\n"
-            "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // Check that operator Equal returns reference to this
-    void checkOpertorEqRetRefThis(const char code[]) {
-        // Clear the error log
-        errout.str("");
-
+#define checkOpertorEqRetRefThis(...) checkOpertorEqRetRefThis_( __FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkOpertorEqRetRefThis_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        tokenizer.simplifyTokenList2();
+        SimpleTokenizer tokenizer(settings0, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check..
         CheckClass checkClass(&tokenizer, &settings0, this);
@@ -1152,7 +1233,7 @@ class TestClass : public TestFixture {
             "public:\n"
             "    A & operator=(const A &a) { return *this; }\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A\n"
@@ -1160,7 +1241,7 @@ class TestClass : public TestFixture {
             "public:\n"
             "    A & operator=(const A &a) { return a; }\n"
             "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style) 'operator=' should return reference to 'this' instance.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A\n"
@@ -1169,7 +1250,7 @@ class TestClass : public TestFixture {
             "    A & operator=(const A &);\n"
             "};\n"
             "A & A::operator=(const A &a) { return *this; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A\n"
@@ -1178,7 +1259,7 @@ class TestClass : public TestFixture {
             "    A & operator=(const A &a);\n"
             "};\n"
             "A & A::operator=(const A &a) { return *this; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A\n"
@@ -1187,7 +1268,7 @@ class TestClass : public TestFixture {
             "    A & operator=(const A &);\n"
             "};\n"
             "A & A::operator=(const A &a) { return a; }");
-        ASSERT_EQUALS("[test.cpp:6]: (style) 'operator=' should return reference to 'this' instance.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:8]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A\n"
@@ -1196,7 +1277,7 @@ class TestClass : public TestFixture {
             "    A & operator=(const A &a);\n"
             "};\n"
             "A & A::operator=(const A &a) { return a; }");
-        ASSERT_EQUALS("[test.cpp:6]: (style) 'operator=' should return reference to 'this' instance.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:8]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A\n"
@@ -1208,7 +1289,7 @@ class TestClass : public TestFixture {
             "        B & operator=(const B &b) { return *this; }\n"
             "    };\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A\n"
@@ -1220,7 +1301,7 @@ class TestClass : public TestFixture {
             "        B & operator=(const B &b) { return b; }\n"
             "    };\n"
             "};");
-        ASSERT_EQUALS("[test.cpp:7]: (style) 'operator=' should return reference to 'this' instance.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:13]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A\n"
@@ -1233,7 +1314,7 @@ class TestClass : public TestFixture {
             "    };\n"
             "};\n"
             "A::B & A::B::operator=(const A::B &b) { return *this; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A\n"
@@ -1246,7 +1327,7 @@ class TestClass : public TestFixture {
             "    };\n"
             "};\n"
             "A::B & A::B::operator=(const A::B &b) { return b; }");
-        ASSERT_EQUALS("[test.cpp:10]: (style) 'operator=' should return reference to 'this' instance.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:14]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A {\n"
@@ -1255,8 +1336,8 @@ class TestClass : public TestFixture {
             "class A::B\n"
             "{\n"
             "  B & operator=(const B & b) { return b; }\n"
-            "};\n");
-        ASSERT_EQUALS("[test.cpp:6]: (style) 'operator=' should return reference to 'this' instance.\n", errout.str());
+            "};");
+        ASSERT_EQUALS("[test.cpp:6:7]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A {\n"
@@ -1266,8 +1347,8 @@ class TestClass : public TestFixture {
             "{\n"
             "  B & operator=(const B &);\n"
             "};\n"
-            "A::B & A::B::operator=(const A::B & b) { return b; }\n");
-        ASSERT_EQUALS("[test.cpp:8]: (style) 'operator=' should return reference to 'this' instance.\n", errout.str());
+            "A::B & A::B::operator=(const A::B & b) { return b; }");
+        ASSERT_EQUALS("[test.cpp:8:14]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A {\n"
@@ -1276,8 +1357,8 @@ class TestClass : public TestFixture {
             "class A::B\n"
             "{\n"
             "  A::B & operator=(const A::B & b) { return b; }\n"
-            "};\n");
-        ASSERT_EQUALS("[test.cpp:6]: (style) 'operator=' should return reference to 'this' instance.\n", errout.str());
+            "};");
+        ASSERT_EQUALS("[test.cpp:6:10]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A {\n"
@@ -1287,8 +1368,8 @@ class TestClass : public TestFixture {
             "{\n"
             "  A::B & operator=(const A::B &);\n"
             "};\n"
-            "A::B & A::B::operator=(const A::B & b) { return b; }\n");
-        ASSERT_EQUALS("[test.cpp:8]: (style) 'operator=' should return reference to 'this' instance.\n", errout.str());
+            "A::B & A::B::operator=(const A::B & b) { return b; }");
+        ASSERT_EQUALS("[test.cpp:8:14]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "namespace A {\n"
@@ -1297,8 +1378,8 @@ class TestClass : public TestFixture {
             "class A::B\n"
             "{\n"
             "  B & operator=(const B & b) { return b; }\n"
-            "};\n");
-        ASSERT_EQUALS("[test.cpp:6]: (style) 'operator=' should return reference to 'this' instance.\n", errout.str());
+            "};");
+        ASSERT_EQUALS("[test.cpp:6:7]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "namespace A {\n"
@@ -1308,8 +1389,8 @@ class TestClass : public TestFixture {
             "{\n"
             "  B & operator=(const B &);\n"
             "};\n"
-            "A::B & A::B::operator=(const A::B & b) { return b; }\n");
-        ASSERT_EQUALS("[test.cpp:8]: (style) 'operator=' should return reference to 'this' instance.\n", errout.str());
+            "A::B & A::B::operator=(const A::B & b) { return b; }");
+        ASSERT_EQUALS("[test.cpp:8:14]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "namespace A {\n"
@@ -1318,8 +1399,8 @@ class TestClass : public TestFixture {
             "class A::B\n"
             "{\n"
             "  A::B & operator=(const A::B & b) { return b; }\n"
-            "};\n");
-        ASSERT_EQUALS("[test.cpp:6]: (style) 'operator=' should return reference to 'this' instance.\n", errout.str());
+            "};");
+        ASSERT_EQUALS("[test.cpp:6:10]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "namespace A {\n"
@@ -1329,8 +1410,18 @@ class TestClass : public TestFixture {
             "{\n"
             "  A::B & operator=(const A::B &);\n"
             "};\n"
-            "A::B & A::B::operator=(const A::B & b) { return b; }\n");
-        ASSERT_EQUALS("[test.cpp:8]: (style) 'operator=' should return reference to 'this' instance.\n", errout.str());
+            "A::B & A::B::operator=(const A::B & b) { return b; }");
+        ASSERT_EQUALS("[test.cpp:8:14]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
+
+        checkOpertorEqRetRefThis( // #11380
+            "struct S {\n"
+            "    S& operator=(const S& other) {\n"
+            "        i = []() { return 42; }();\n"
+            "        return *this;\n"
+            "    }\n"
+            "    int i;\n"
+            "};\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void operatorEqRetRefThis2() {
@@ -1340,7 +1431,7 @@ class TestClass : public TestFixture {
             "{\n"
             "  szp &operator =(int *other) {}\n"
             "};");
-        ASSERT_EQUALS("[test.cpp:3]: (error) No 'return' statement in non-void function causes undefined behavior.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "class szp\n"
@@ -1348,7 +1439,7 @@ class TestClass : public TestFixture {
             "  szp &operator =(int *other);\n"
             "};\n"
             "szp &szp::operator =(int *other) {}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) No 'return' statement in non-void function causes undefined behavior.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:11]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "namespace NS {\n"
@@ -1357,8 +1448,8 @@ class TestClass : public TestFixture {
             "class NS::szp\n"
             "{\n"
             "  szp &operator =(int *other) {}\n"
-            "};\n");
-        ASSERT_EQUALS("[test.cpp:6]: (error) No 'return' statement in non-void function causes undefined behavior.\n", errout.str());
+            "};");
+        ASSERT_EQUALS("[test.cpp:6:8]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "namespace NS {\n"
@@ -1369,7 +1460,7 @@ class TestClass : public TestFixture {
             "  szp &operator =(int *other);\n"
             "};\n"
             "NS::szp &NS::szp::operator =(int *other) {}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) No 'return' statement in non-void function causes undefined behavior.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:19]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "namespace NS {\n"
@@ -1378,8 +1469,8 @@ class TestClass : public TestFixture {
             "class NS::szp\n"
             "{\n"
             "  NS::szp &operator =(int *other) {}\n"
-            "};\n");
-        ASSERT_EQUALS("[test.cpp:6]: (error) No 'return' statement in non-void function causes undefined behavior.\n", errout.str());
+            "};");
+        ASSERT_EQUALS("[test.cpp:6:12]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "namespace NS {\n"
@@ -1390,7 +1481,7 @@ class TestClass : public TestFixture {
             "  NS::szp &operator =(int *other);\n"
             "};\n"
             "NS::szp &NS::szp::operator =(int *other) {}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) No 'return' statement in non-void function causes undefined behavior.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:19]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A {\n"
@@ -1399,8 +1490,8 @@ class TestClass : public TestFixture {
             "class A::szp\n"
             "{\n"
             "  szp &operator =(int *other) {}\n"
-            "};\n");
-        ASSERT_EQUALS("[test.cpp:6]: (error) No 'return' statement in non-void function causes undefined behavior.\n", errout.str());
+            "};");
+        ASSERT_EQUALS("[test.cpp:6:8]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A {\n"
@@ -1411,7 +1502,7 @@ class TestClass : public TestFixture {
             "  szp &operator =(int *other);\n"
             "};\n"
             "A::szp &A::szp::operator =(int *other) {}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) No 'return' statement in non-void function causes undefined behavior.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:17]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A {\n"
@@ -1420,8 +1511,8 @@ class TestClass : public TestFixture {
             "class A::szp\n"
             "{\n"
             "  A::szp &operator =(int *other) {}\n"
-            "};\n");
-        ASSERT_EQUALS("[test.cpp:6]: (error) No 'return' statement in non-void function causes undefined behavior.\n", errout.str());
+            "};");
+        ASSERT_EQUALS("[test.cpp:6:11]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A {\n"
@@ -1432,7 +1523,7 @@ class TestClass : public TestFixture {
             "  A::szp &operator =(int *other);\n"
             "};\n"
             "A::szp &A::szp::operator =(int *other) {}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) No 'return' statement in non-void function causes undefined behavior.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:17]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
     }
 
     void operatorEqRetRefThis3() {
@@ -1443,7 +1534,7 @@ class TestClass : public TestFixture {
             "  inline A &operator =(int *other) { return (*this); };\n"
             "  inline A &operator =(long *other) { return (*this = 0); };\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A {\n"
@@ -1453,7 +1544,7 @@ class TestClass : public TestFixture {
             "};\n"
             "A &A::operator =(int *other) { return (*this); };\n"
             "A &A::operator =(long *other) { return (*this = 0); };");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A {\n"
@@ -1461,7 +1552,7 @@ class TestClass : public TestFixture {
             "  inline A &operator =(int *other) { return (*this); };\n"
             "  inline A &operator =(long *other) { return operator = (*(int *)other); };\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A {\n"
@@ -1471,7 +1562,7 @@ class TestClass : public TestFixture {
             "};\n"
             "A &A::operator =(int *other) { return (*this); };\n"
             "A &A::operator =(long *other) { return operator = (*(int *)other); };");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A {\n"
@@ -1481,7 +1572,7 @@ class TestClass : public TestFixture {
             "};\n"
             "A &A::operator =(int *other) { return (*this); };\n"
             "A &A::operator =(long *other) { return this->operator = (*(int *)other); };");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqRetRefThis( // #9045
             "class V {\n"
@@ -1492,8 +1583,8 @@ class TestClass : public TestFixture {
             "        }\n"
             "        return *this;\n"
             "    }\n"
-            "};\n");
-        ASSERT_EQUALS("", errout.str());
+            "};");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void operatorEqRetRefThis4() {
@@ -1503,7 +1594,7 @@ class TestClass : public TestFixture {
             "{\n"
             "  return (P&)(*this += pc);\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void operatorEqRetRefThis5() {
@@ -1513,21 +1604,21 @@ class TestClass : public TestFixture {
             "public:\n"
             "    A & operator=(const A &a) { }\n"
             "};");
-        ASSERT_EQUALS("[test.cpp:3]: (error) No 'return' statement in non-void function causes undefined behavior.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A {\n"
             "protected:\n"
             "    A & operator=(const A &a) {}\n"
             "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style) 'operator=' should return reference to 'this' instance.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A {\n"
             "private:\n"
             "    A & operator=(const A &a) {}\n"
             "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style) 'operator=' should return reference to 'this' instance.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) 'operator=' should return reference to 'this' instance. [operatorEqRetRefThis]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A {\n"
@@ -1537,7 +1628,7 @@ class TestClass : public TestFixture {
             "        throw std::exception();\n"
             "    }\n"
             "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style) 'operator=' should either return reference to 'this' instance or be declared private and left unimplemented.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) 'operator=' should either return reference to 'this' instance or be declared private and left unimplemented. [operatorEqShouldBeLeftUnimplemented]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A {\n"
@@ -1547,7 +1638,7 @@ class TestClass : public TestFixture {
             "        abort();\n"
             "    }\n"
             "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style) 'operator=' should either return reference to 'this' instance or be declared private and left unimplemented.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) 'operator=' should either return reference to 'this' instance or be declared private and left unimplemented. [operatorEqShouldBeLeftUnimplemented]\n", errout_str());
 
         checkOpertorEqRetRefThis(
             "class A {\n"
@@ -1555,7 +1646,7 @@ class TestClass : public TestFixture {
             "    A & operator=(const A &a);\n"
             "};\n"
             "A & A :: operator=(const A &a) { }");
-        ASSERT_EQUALS("[test.cpp:5]: (error) No 'return' statement in non-void function causes undefined behavior.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10]: (error) No 'return' statement in non-void function causes undefined behavior. [operatorEqMissingReturnStatement]\n", errout_str());
     }
 
     void operatorEqRetRefThis6() { // ticket #2478 (segmentation fault)
@@ -1589,20 +1680,17 @@ class TestClass : public TestFixture {
             "  basic_fbstring& replace() {\n"
             "    return replaceImplDiscr();\n"
             "  }\n"
-            "};\n");
-        ASSERT_EQUALS("", errout.str());
+            "};");
+        ASSERT_EQUALS("", errout_str());
     }
 
     // Check that operator Equal checks for assignment to self
-    void checkOpertorEqToSelf(const char code[]) {
-        // Clear the error log
-        errout.str("");
-
+#define checkOpertorEqToSelf(...) checkOpertorEqToSelf_( __FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkOpertorEqToSelf_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings1, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        tokenizer.simplifyTokenList2();
+        SimpleTokenizer tokenizer(settings1, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check..
         CheckClass checkClass(&tokenizer, &settings1, this);
@@ -1617,7 +1705,7 @@ class TestClass : public TestFixture {
             "public:\n"
             "    A & operator=(const A &a) { if (&a != this) { } return *this; }\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // this test doesn't have an assignment test but it is not needed
         checkOpertorEqToSelf(
@@ -1626,7 +1714,7 @@ class TestClass : public TestFixture {
             "public:\n"
             "    A & operator=(const A &a) { return *this; }\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // this test needs an assignment test and has it
         checkOpertorEqToSelf(
@@ -1644,7 +1732,7 @@ class TestClass : public TestFixture {
             "        return *this;\n"
             "    }\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // this class needs an assignment test but doesn't have it
         checkOpertorEqToSelf(
@@ -1659,7 +1747,7 @@ class TestClass : public TestFixture {
             "        return *this;\n"
             "    }\n"
             "};");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
 
         // this test has an assignment test but doesn't need it
         checkOpertorEqToSelf(
@@ -1669,7 +1757,7 @@ class TestClass : public TestFixture {
             "    A & operator=(const A &);\n"
             "};\n"
             "A & A::operator=(const A &a) { if (&a != this) { } return *this; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // this test doesn't have an assignment test but doesn't need it
         checkOpertorEqToSelf(
@@ -1679,7 +1767,7 @@ class TestClass : public TestFixture {
             "    A & operator=(const A &);\n"
             "};\n"
             "A & A::operator=(const A &a) { return *this; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // this test needs an assignment test and has it
         checkOpertorEqToSelf(
@@ -1698,7 +1786,146 @@ class TestClass : public TestFixture {
             "    }\n"
             "    return *this;\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // this test needs an assignment test and has the inverse test
+        checkOpertorEqToSelf(
+            "class A\n"
+            "{\n"
+            "public:\n"
+            "    char *s;\n"
+            "    A & operator=(const A &);\n"
+            "};\n"
+            "A & A::operator=(const A &a)\n"
+            "{\n"
+            "    if (&a == this)\n"
+            "    {\n"
+            "        free(s);\n"
+            "        s = strdup(a.s);\n"
+            "    }\n"
+            "    return *this;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:7:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
+
+        // this test needs an assignment test and has the inverse test
+        checkOpertorEqToSelf(
+            "class A\n"
+            "{\n"
+            "public:\n"
+            "    char *s;\n"
+            "    A & operator=(const A &);\n"
+            "};\n"
+            "A & A::operator=(const A &a)\n"
+            "{\n"
+            "    if ((&a == this) == true)\n"
+            "    {\n"
+            "        free(s);\n"
+            "        s = strdup(a.s);\n"
+            "    }\n"
+            "    return *this;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:7:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
+
+        // this test needs an assignment test and has the inverse test
+        checkOpertorEqToSelf(
+            "class A\n"
+            "{\n"
+            "public:\n"
+            "    char *s;\n"
+            "    A & operator=(const A &);\n"
+            "};\n"
+            "A & A::operator=(const A &a)\n"
+            "{\n"
+            "    if ((&a == this) != false)\n"
+            "    {\n"
+            "        free(s);\n"
+            "        s = strdup(a.s);\n"
+            "    }\n"
+            "    return *this;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:7:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
+
+        // this test needs an assignment test and has the inverse test
+        checkOpertorEqToSelf(
+            "class A\n"
+            "{\n"
+            "public:\n"
+            "    char *s;\n"
+            "    A & operator=(const A &);\n"
+            "};\n"
+            "A & A::operator=(const A &a)\n"
+            "{\n"
+            "    if (!((&a == this) == false))\n"
+            "    {\n"
+            "        free(s);\n"
+            "        s = strdup(a.s);\n"
+            "    }\n"
+            "    return *this;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:7:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
+
+        // this test needs an assignment test and has the inverse test
+        checkOpertorEqToSelf(
+            "class A\n"
+            "{\n"
+            "public:\n"
+            "    char *s;\n"
+            "    A & operator=(const A &);\n"
+            "};\n"
+            "A & A::operator=(const A &a)\n"
+            "{\n"
+            "    if ((&a != this) == false)\n"
+            "    {\n"
+            "        free(s);\n"
+            "        s = strdup(a.s);\n"
+            "    }\n"
+            "    return *this;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:7:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
+
+        // this test needs an assignment test and has the inverse test
+        checkOpertorEqToSelf(
+            "class A\n"
+            "{\n"
+            "public:\n"
+            "    char *s;\n"
+            "    A & operator=(const A &);\n"
+            "};\n"
+            "A & A::operator=(const A &a)\n"
+            "{\n"
+            "    if (&a != this)\n"
+            "    {\n"
+            "    }\n"
+            "    else\n"
+            "    {\n"
+            "        free(s);\n"
+            "        s = strdup(a.s);\n"
+            "    }\n"
+            "    return *this;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:7:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
+
+        // this test needs an assignment test and has the inverse test
+        checkOpertorEqToSelf(
+            "class A\n"
+            "{\n"
+            "public:\n"
+            "    char *s;\n"
+            "    A & operator=(const A &);\n"
+            "};\n"
+            "A & A::operator=(const A &a)\n"
+            "{\n"
+            "    if (&a != this)\n"
+            "        free(s);\n"
+            "    else\n"
+            "    {\n"
+            "        free(s);\n"
+            "        s = strdup(a.s);\n"
+            "    }\n"
+            "    return *this;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:7:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
+
 
         // this test needs an assignment test but doesn’t have it
         checkOpertorEqToSelf(
@@ -1714,7 +1941,7 @@ class TestClass : public TestFixture {
             "    s = strdup(a.s);\n"
             "    return *this;\n"
             "}");
-        ASSERT_EQUALS("[test.cpp:7]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
 
         // ticket #1224
         checkOpertorEqToSelf(
@@ -1732,7 +1959,7 @@ class TestClass : public TestFixture {
             "    delete oldtree;\n"
             "    return *this;\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
     }
 
@@ -1748,7 +1975,7 @@ class TestClass : public TestFixture {
             "        B & operator=(const B &b) { if (&b != this) { } return *this; }\n"
             "    };\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // this test doesn't have an assignment test but doesn't need it
         checkOpertorEqToSelf(
@@ -1761,7 +1988,7 @@ class TestClass : public TestFixture {
             "        B & operator=(const B &b) { return *this; }\n"
             "    };\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // this test needs an assignment test but has it
         checkOpertorEqToSelf(
@@ -1781,7 +2008,7 @@ class TestClass : public TestFixture {
             "        }\n"
             "    };\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // this test needs an assignment test but doesn't have it
         checkOpertorEqToSelf(
@@ -1800,7 +2027,7 @@ class TestClass : public TestFixture {
             "        }\n"
             "    };\n"
             "};");
-        ASSERT_EQUALS("[test.cpp:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:13]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
 
         // this test has an assignment test but doesn't need it
         checkOpertorEqToSelf(
@@ -1814,7 +2041,7 @@ class TestClass : public TestFixture {
             "    };\n"
             "};\n"
             "A::B & A::B::operator=(const A::B &b) { if (&b != this) { } return *this; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // this test doesn't have an assignment test but doesn't need it
         checkOpertorEqToSelf(
@@ -1828,7 +2055,7 @@ class TestClass : public TestFixture {
             "    };\n"
             "};\n"
             "A::B & A::B::operator=(const A::B &b) { return *this; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // this test needs an assignment test and has it
         checkOpertorEqToSelf(
@@ -1851,7 +2078,7 @@ class TestClass : public TestFixture {
             "    }\n"
             "    return *this;\n"
             " }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // this test needs an assignment test but doesn't have it
         checkOpertorEqToSelf(
@@ -1871,7 +2098,7 @@ class TestClass : public TestFixture {
             "    s = strdup(b.s);\n"
             "    return *this;\n"
             " }");
-        ASSERT_EQUALS("[test.cpp:11]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:11:14]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
     }
 
     void operatorEqToSelf3() {
@@ -1882,7 +2109,7 @@ class TestClass : public TestFixture {
             "public:\n"
             "    A & operator=(const A &a) { return *this; }\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // this test has multiple inheritance and needs an assignment test but there is no trivial way to test for it
         checkOpertorEqToSelf(
@@ -1897,7 +2124,7 @@ class TestClass : public TestFixture {
             "        return *this;\n"
             "    }\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // this test has multiple inheritance so there is no trivial way to test for self assignment but doesn't need it
         checkOpertorEqToSelf(
@@ -1907,7 +2134,7 @@ class TestClass : public TestFixture {
             "    A & operator=(const A &);\n"
             "};\n"
             "A & A::operator=(const A &a) { return *this; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // this test has multiple inheritance and needs an assignment test but there is no trivial way to test for it
         checkOpertorEqToSelf(
@@ -1923,7 +2150,7 @@ class TestClass : public TestFixture {
             "    s = strdup(a.s);\n"
             "    return *this;\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void operatorEqToSelf4() {
@@ -1938,7 +2165,7 @@ class TestClass : public TestFixture {
             "        B & operator=(const B &b) { return *this; }\n"
             "    };\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // this test has multiple inheritance and needs an assignment test but there is no trivial way to test for it
         checkOpertorEqToSelf(
@@ -1957,7 +2184,7 @@ class TestClass : public TestFixture {
             "        }\n"
             "    };\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // this test has multiple inheritance so there is no trivial way to test for self assignment but doesn't need it
         checkOpertorEqToSelf(
@@ -1971,7 +2198,7 @@ class TestClass : public TestFixture {
             "    };\n"
             "};\n"
             "A::B & A::B::operator=(const A::B &b) { return *this; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // this test has multiple inheritance and needs an assignment test but there is no trivial way to test for it
         checkOpertorEqToSelf(
@@ -1991,7 +2218,7 @@ class TestClass : public TestFixture {
             "    s = strdup(b.s);\n"
             "    return *this;\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void operatorEqToSelf5() {
@@ -2011,7 +2238,7 @@ class TestClass : public TestFixture {
             "        return *this;\n"
             "    }\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
             "class A\n"
@@ -2028,7 +2255,7 @@ class TestClass : public TestFixture {
             "        return *this;\n"
             "    }\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
             "class A\n"
@@ -2045,7 +2272,7 @@ class TestClass : public TestFixture {
             "        return *this;\n"
             "    }\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
             "class A\n"
@@ -2062,7 +2289,7 @@ class TestClass : public TestFixture {
             "        return *this;\n"
             "    }\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
             "class A\n"
@@ -2079,7 +2306,7 @@ class TestClass : public TestFixture {
             "        return *this;\n"
             "    }\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
             "class A\n"
@@ -2096,7 +2323,7 @@ class TestClass : public TestFixture {
             "        return *this;\n"
             "    }\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
             "class A\n"
@@ -2113,7 +2340,7 @@ class TestClass : public TestFixture {
             "        return *this;\n"
             "    }\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
             "class A\n"
@@ -2130,7 +2357,7 @@ class TestClass : public TestFixture {
             "        return *this;\n"
             "    }\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
             "class A\n"
@@ -2148,7 +2375,7 @@ class TestClass : public TestFixture {
             "    }\n"
             "    return *this;\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
             "class A\n"
@@ -2166,7 +2393,7 @@ class TestClass : public TestFixture {
             "    }\n"
             "    return *this;\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
             "class A\n"
@@ -2184,7 +2411,7 @@ class TestClass : public TestFixture {
             "    }\n"
             "    return *this;\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
             "class A\n"
@@ -2202,7 +2429,7 @@ class TestClass : public TestFixture {
             "    }\n"
             "    return *this;\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
             "class A\n"
@@ -2220,7 +2447,7 @@ class TestClass : public TestFixture {
             "    }\n"
             "    return *this;\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
             "class A\n"
@@ -2238,7 +2465,7 @@ class TestClass : public TestFixture {
             "    }\n"
             "    return *this;\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
             "class A\n"
@@ -2256,7 +2483,7 @@ class TestClass : public TestFixture {
             "    }\n"
             "    return *this;\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
             "class A\n"
@@ -2274,7 +2501,7 @@ class TestClass : public TestFixture {
             "    }\n"
             "    return *this;\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOpertorEqToSelf(
             "struct A {\n"
@@ -2286,7 +2513,7 @@ class TestClass : public TestFixture {
             "    s = strdup(a.s);\n"
             "    return *this;\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void operatorEqToSelf6() {
@@ -2305,7 +2532,7 @@ class TestClass : public TestFixture {
             "private:\n"
             "    char * data;\n"
             "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
 
         checkOpertorEqToSelf(
             "class A\n"
@@ -2322,7 +2549,7 @@ class TestClass : public TestFixture {
             "    strcpy(data, a.data);\n"
             "    return *this;\n"
             "};");
-        ASSERT_EQUALS("[test.cpp:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
 
         checkOpertorEqToSelf(
             "class A\n"
@@ -2338,7 +2565,7 @@ class TestClass : public TestFixture {
             "private:\n"
             "    char * data;\n"
             "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
 
         checkOpertorEqToSelf(
             "class A\n"
@@ -2355,7 +2582,7 @@ class TestClass : public TestFixture {
             "    *data = *a.data;\n"
             "    return *this;\n"
             "};");
-        ASSERT_EQUALS("[test.cpp:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:8]: (warning) 'operator=' should check for assignment to self to avoid problems with dynamic memory. [operatorEqToSelf]\n", errout_str());
     }
 
     void operatorEqToSelf7() {
@@ -2372,7 +2599,7 @@ class TestClass : public TestFixture {
             "        return assign(a);\n"
             "    }\n"
             "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void operatorEqToSelf8() {
@@ -2391,7 +2618,7 @@ class TestClass : public TestFixture {
             "{\n"
             "    return copy(in);\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void operatorEqToSelf9() {
@@ -2410,25 +2637,26 @@ class TestClass : public TestFixture {
             "{\n"
             "    return Foo::operator=(&other);\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
-    // Check that base classes have virtual destructors
-    void checkVirtualDestructor(const char code[], bool inconclusive = false) {
-        // Clear the error log
-        errout.str("");
+    struct CheckVirtualDestructorOptions
+    {
+        bool inconclusive = false;
+    };
 
-        settings0.inconclusive = inconclusive;
-        settings0.addEnabled("warning");
+    // Check that base classes have virtual destructors
+#define checkVirtualDestructor(...) checkVirtualDestructor_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkVirtualDestructor_(const char* file, int line, const char (&code)[size], const CheckVirtualDestructorOptions& options = make_default_obj()) {
+        const Settings& s = options.inconclusive ? settings3_i : settings3;
 
         // Tokenize..
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        tokenizer.simplifyTokenList2();
+        SimpleTokenizer tokenizer(s, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check..
-        CheckClass checkClass(&tokenizer, &settings0, this);
+        CheckClass checkClass(&tokenizer, &s, this);
         checkClass.virtualDestructor();
     }
 
@@ -2438,12 +2666,12 @@ class TestClass : public TestFixture {
         checkVirtualDestructor("class Derived : public Base { };\n"
                                "Base *base = new Derived;\n"
                                "delete base;");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkVirtualDestructor("class Derived : Base { };\n"
                                "Base *base = new Derived;\n"
                                "delete base;");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void virtualDestructor2() {
@@ -2453,25 +2681,67 @@ class TestClass : public TestFixture {
                                "class Derived : public Base { public: ~Derived() { (void)11; } };"
                                "Base *base = new Derived;\n"
                                "delete base;");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:1]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
 
         checkVirtualDestructor("class Base { };\n"
                                "class Derived : protected Base { public: ~Derived() { (void)11; } };"
                                "Base *base = new Derived;\n"
                                "delete base;");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:1]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
 
         checkVirtualDestructor("class Base { };\n"
                                "class Derived : private Base { public: ~Derived() { (void)11; } };"
                                "Base *base = new Derived;\n"
                                "delete base;");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkVirtualDestructor("class Base { };\n"
                                "class Derived : Base { public: ~Derived() { (void)11; } };"
                                "Base *base = new Derived;\n"
                                "delete base;");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // #9104
+        checkVirtualDestructor("struct A\n"
+                               "{\n"
+                               "    A()  { cout << \"A is constructing\\n\"; }\n"
+                               "    ~A() { cout << \"A is destructing\\n\"; }\n"
+                               "};\n"
+                               " \n"
+                               "struct Base {};\n"
+                               " \n"
+                               "struct Derived : Base\n"
+                               "{\n"
+                               "    A a;\n"
+                               "};\n"
+                               " \n"
+                               "int main(void)\n"
+                               "{\n"
+                               "    Base* p = new Derived();\n"
+                               "    delete p;\n"
+                               "}");
+        ASSERT_EQUALS("[test.cpp:7:1]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
+
+        checkVirtualDestructor("using namespace std;\n"
+                               "struct A\n"
+                               "{\n"
+                               "    A()  { cout << \"A is constructing\\n\"; }\n"
+                               "    ~A() { cout << \"A is destructing\\n\"; }\n"
+                               "};\n"
+                               " \n"
+                               "struct Base {};\n"
+                               " \n"
+                               "struct Derived : Base\n"
+                               "{\n"
+                               "    A a;\n"
+                               "};\n"
+                               " \n"
+                               "int main(void)\n"
+                               "{\n"
+                               "    Base* p = new Derived();\n"
+                               "    delete p;\n"
+                               "}");
+        ASSERT_EQUALS("[test.cpp:8:1]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
     }
 
     void virtualDestructor3() {
@@ -2481,19 +2751,19 @@ class TestClass : public TestFixture {
                                "class Derived : public Base { public: ~Derived() { (void)11; } };"
                                "Base *base = new Derived;\n"
                                "delete base;");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:23]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
 
         checkVirtualDestructor("class Base { public: ~Base(); };\n"
                                "class Derived : protected Base { public: ~Derived() { (void)11; } };"
                                "Base *base = new Derived;\n"
                                "delete base;");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:23]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
 
         checkVirtualDestructor("class Base { public: ~Base(); };\n"
                                "class Derived : private Fred, public Base { public: ~Derived() { (void)11; } };"
                                "Base *base = new Derived;\n"
                                "delete base;");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:23]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
     }
 
     void virtualDestructor4() {
@@ -2503,13 +2773,13 @@ class TestClass : public TestFixture {
                                "class Derived : public Base { };"
                                "Base *base = new Derived;\n"
                                "delete base;");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:23]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
 
         checkVirtualDestructor("class Base { public: ~Base(); };\n"
                                "class Derived : private Fred, public Base { };"
                                "Base *base = new Derived;\n"
                                "delete base;");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:23]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
     }
 
     void virtualDestructor5() {
@@ -2519,13 +2789,13 @@ class TestClass : public TestFixture {
                                "class Derived : public Base { public: ~Derived() {} };"
                                "Base *base = new Derived;\n"
                                "delete base;");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:23]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
 
         checkVirtualDestructor("class Base { public: ~Base(); };\n"
                                "class Derived : public Base { public: ~Derived(); }; Derived::~Derived() {}"
                                "Base *base = new Derived;\n"
                                "delete base;");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:23]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
     }
 
     void virtualDestructor6() {
@@ -2534,7 +2804,7 @@ class TestClass : public TestFixture {
 
         checkVirtualDestructor("class Base { public: ~Base(); };\n"
                                "class Derived : public Base { public: ~Derived() { (void)11; } };");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void virtualDestructorProtected() {
@@ -2551,7 +2821,7 @@ class TestClass : public TestFixture {
                                "public:\n"
                                "    ~B() { int a; }\n"
                                "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void virtualDestructorInherited() {
@@ -2572,7 +2842,7 @@ class TestClass : public TestFixture {
                                "public:\n"
                                "    ~B() { int a; }\n"
                                "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // class A inherits virtual destructor from struct Base -> no error
         // also notice that public is not given, but destructor is public, because
@@ -2590,7 +2860,7 @@ class TestClass : public TestFixture {
                                "public:\n"
                                "    ~B() { int a; }\n"
                                "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Unknown Base class -> it could have virtual destructor, so ignore
         checkVirtualDestructor("class A : private Base\n"
@@ -2604,7 +2874,7 @@ class TestClass : public TestFixture {
                                "public:\n"
                                "    ~B() { int a; }\n"
                                "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Virtual destructor is inherited -> no error
         checkVirtualDestructor("class Base2\n"
@@ -2625,7 +2895,7 @@ class TestClass : public TestFixture {
                                "public:\n"
                                "    ~B() { int a; }\n"
                                "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // class A doesn't inherit virtual destructor from class Base -> error
         checkVirtualDestructor("class Base\n"
@@ -2645,7 +2915,7 @@ class TestClass : public TestFixture {
                                "    ~B() { int a; }\n"
                                "};");
         TODO_ASSERT_EQUALS("[test.cpp:7]: (error) Class 'Base' which is inherited by class 'B' does not have a virtual destructor.\n",
-                           "", errout.str());
+                           "", errout_str());
     }
 
     void virtualDestructorTemplate() {
@@ -2666,7 +2936,7 @@ class TestClass : public TestFixture {
                                "};\n"
                                "\n"
                                "AA<double> *p = new B; delete p;");
-        ASSERT_EQUALS("[test.cpp:9]: (error) Class 'AA < double >' which is inherited by class 'B' does not have a virtual destructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:3]: (error) Class 'AA < double >' which is inherited by class 'B' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
     }
 
     void virtualDestructorInconclusive() {
@@ -2674,8 +2944,8 @@ class TestClass : public TestFixture {
                                "public:\n"
                                "    ~Base(){}\n"
                                "    virtual void foo(){}\n"
-                               "};\n", true);
-        ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) Class 'Base' which has virtual members does not have a virtual destructor.\n", errout.str());
+                               "};\n", dinit(CheckVirtualDestructorOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:6]: (warning, inconclusive) Class 'Base' which has virtual members does not have a virtual destructor. [virtualDestructor]\n", errout_str());
 
         checkVirtualDestructor("class Base {\n"
                                "public:\n"
@@ -2689,25 +2959,38 @@ class TestClass : public TestFixture {
                                "void foo() {\n"
                                "    Base * base = new Derived();\n"
                                "    delete base;\n"
-                               "}\n", true);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor.\n", errout.str());
-    }
+                               "}\n", dinit(CheckVirtualDestructorOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:6]: (error) Class 'Base' which is inherited by class 'Derived' does not have a virtual destructor. [virtualDestructor]\n", errout_str());
+
+        // class Base destructor is not virtual but protected -> no error
+        checkVirtualDestructor("class Base {\n"
+                               "public:\n"
+                               "    virtual void foo(){}\n"
+                               "protected:\n"
+                               "    ~Base(){}\n"
+                               "};\n", dinit(CheckVirtualDestructorOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
-    void checkNoMemset(const char code[]) {
-        Settings settings;
-        settings.addEnabled("warning");
-        settings.addEnabled("portability");
-        checkNoMemset(code,settings);
+        checkVirtualDestructor("class C {\n"
+                               "private:\n"
+                               "    C();\n"
+                               "    virtual ~C();\n"
+                               "};\n", dinit(CheckVirtualDestructorOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void checkNoMemset(const char code[], const Settings &settings) {
-        // Clear the error log
-        errout.str("");
 
+#define checkNoMemset(...) checkNoMemset_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkNoMemset_(const char* file, int line, const char (&code)[size]) {
+        checkNoMemset_(file, line, code, settings4);
+    }
+
+    template<size_t size>
+    void checkNoMemset_(const char* file, int line, const char (&code)[size], const Settings &settings) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check..
         CheckClass checkClass(&tokenizer, &settings, this);
@@ -2723,7 +3006,7 @@ class TestClass : public TestFixture {
                       "    Fred fred;\n"
                       "    memset(&fred, 0, sizeof(Fred));\n"
                       "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("class Fred\n"
                       "{\n"
@@ -2734,7 +3017,7 @@ class TestClass : public TestFixture {
                       "    Fred fred;\n"
                       "    memset(&fred, 0, sizeof(Fred));\n"
                       "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("class Fred\n"
                       "{\n"
@@ -2745,7 +3028,7 @@ class TestClass : public TestFixture {
                       "    Fred fred;\n"
                       "    memset(&fred, 0, sizeof(Fred));\n"
                       "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("class Fred\n"
                       "{\n"
@@ -2756,7 +3039,7 @@ class TestClass : public TestFixture {
                       "    Fred fred;\n"
                       "    memset(&fred, 0, sizeof(Fred));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Using 'memset' on class that contains a 'std::string'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:5]: (error) Using 'memset' on class that contains a 'std::string'. [memsetClass]\n", errout_str());
 
         checkNoMemset("class Fred\n"
                       "{\n"
@@ -2767,7 +3050,7 @@ class TestClass : public TestFixture {
                       "    Fred fred;\n"
                       "    memset(&fred, 0, sizeof(Fred));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Using 'memset' on class that contains a 'std::string'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:5]: (error) Using 'memset' on class that contains a 'std::string'. [memsetClass]\n", errout_str());
 
         checkNoMemset("class Fred {\n"
                       "    std::string b;\n"
@@ -2776,7 +3059,7 @@ class TestClass : public TestFixture {
                       "void Fred::f() {\n"
                       "    memset(this, 0, sizeof(*this));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Using 'memset' on class that contains a 'std::string'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:5]: (error) Using 'memset' on class that contains a 'std::string'. [memsetClass]\n", errout_str());
 
         checkNoMemset("class Fred\n"
                       "{\n"
@@ -2786,7 +3069,7 @@ class TestClass : public TestFixture {
                       "    Fred fred;\n"
                       "    memset(&fred, 0, sizeof(fred));\n"
                       "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("class Fred\n"
                       "{\n"
@@ -2797,7 +3080,7 @@ class TestClass : public TestFixture {
                       "    Fred fred;\n"
                       "    memset(&fred, 0, sizeof(fred));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Using 'memset' on class that contains a 'std::string'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:5]: (error) Using 'memset' on class that contains a 'std::string'. [memsetClass]\n", errout_str());
 
         checkNoMemset("class Fred\n"
                       "{\n"
@@ -2809,7 +3092,7 @@ class TestClass : public TestFixture {
                       "    Pebbles pebbles;\n"
                       "    memset(&pebbles, 0, sizeof(pebbles));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:9]: (error) Using 'memset' on class that contains a 'std::string'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:5]: (error) Using 'memset' on class that contains a 'std::string'. [memsetClass]\n", errout_str());
 
         checkNoMemset("class Fred\n"
                       "{\n"
@@ -2820,7 +3103,7 @@ class TestClass : public TestFixture {
                       "    Fred fred;\n"
                       "    memset(&fred, 0, sizeof(fred));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Using 'memset' on class that contains a virtual function.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:5]: (error) Using 'memset' on class that contains a virtual function. [memsetClass]\n", errout_str());
 
         checkNoMemset("class Fred\n"
                       "{\n"
@@ -2831,7 +3114,7 @@ class TestClass : public TestFixture {
                       "    static Fred fred;\n"
                       "    memset(&fred, 0, sizeof(fred));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Using 'memset' on class that contains a virtual function.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:5]: (error) Using 'memset' on class that contains a virtual function. [memsetClass]\n", errout_str());
 
         checkNoMemset("class Fred\n"
                       "{\n"
@@ -2846,7 +3129,7 @@ class TestClass : public TestFixture {
                       "    Pebbles pebbles;\n"
                       "    memset(&pebbles, 0, sizeof(pebbles));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:12]: (error) Using 'memset' on class that contains a virtual function.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:12:5]: (error) Using 'memset' on class that contains a virtual function. [memsetClass]\n", errout_str());
 
         // Fred not defined in scope
         checkNoMemset("namespace n1 {\n"
@@ -2860,7 +3143,7 @@ class TestClass : public TestFixture {
                       "    Fred fred;\n"
                       "    memset(&fred, 0, sizeof(Fred));\n"
                       "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Fred with namespace qualifier
         checkNoMemset("namespace n1 {\n"
@@ -2874,7 +3157,7 @@ class TestClass : public TestFixture {
                       "    n1::Fred fred;\n"
                       "    memset(&fred, 0, sizeof(n1::Fred));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:10]: (error) Using 'memset' on class that contains a 'std::string'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:5]: (error) Using 'memset' on class that contains a 'std::string'. [memsetClass]\n", errout_str());
 
         // Fred with namespace qualifier
         checkNoMemset("namespace n1 {\n"
@@ -2888,7 +3171,7 @@ class TestClass : public TestFixture {
                       "    n1::Fred fred;\n"
                       "    memset(&fred, 0, sizeof(fred));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:10]: (error) Using 'memset' on class that contains a 'std::string'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:5]: (error) Using 'memset' on class that contains a 'std::string'. [memsetClass]\n", errout_str());
 
         checkNoMemset("class A {\n"
                       "  virtual ~A() { }\n"
@@ -2899,7 +3182,7 @@ class TestClass : public TestFixture {
                       "  A** arr = new A*[N];\n"
                       "  memset(arr, 0, N * sizeof(A*));\n"
                       "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("class A {\n" // #5116 - nested class data is mixed in the SymbolDatabase
                       "  std::string s;\n"
@@ -2908,7 +3191,7 @@ class TestClass : public TestFixture {
                       "void f(A::B *b) {\n"
                       "  memset(b,0,4);\n"
                       "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #4461 Warn about memset/memcpy on class with references as members
         checkNoMemset("class A {\n"
@@ -2916,17 +3199,17 @@ class TestClass : public TestFixture {
                       "};\n"
                       "void f() {\n"
                       "  A a;\n"
-                      "  memset(&a, 0, sizeof(a)); \n"
+                      "  memset(&a, 0, sizeof(a));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Using 'memset' on class that contains a reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:3]: (error) Using 'memset' on class that contains a reference. [memsetClassReference]\n", errout_str());
         checkNoMemset("class A {\n"
                       "  const B&b;\n"
                       "};\n"
                       "void f() {\n"
                       "  A a;\n"
-                      "  memset(&a, 0, sizeof(a)); \n"
+                      "  memset(&a, 0, sizeof(a));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Using 'memset' on class that contains a reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:3]: (error) Using 'memset' on class that contains a reference. [memsetClassReference]\n", errout_str());
 
         // #7456
         checkNoMemset("struct A {\n"
@@ -2940,7 +3223,49 @@ class TestClass : public TestFixture {
                       "  B b[4];\n"
                       "  memset(b, 0, sizeof(b));\n"
                       "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // #8619
+        checkNoMemset("struct S { std::vector<int> m; };\n"
+                      "void f() {\n"
+                      "    std::vector<S> v(5);\n"
+                      "    memset(&v[0], 0, sizeof(S) * v.size());\n"
+                      "    memset(&v[0], 0, v.size() * sizeof(S));\n"
+                      "    memset(&v[0], 0, 5 * sizeof(S));\n"
+                      "    memset(&v[0], 0, sizeof(S) * 5);\n"
+                      "}\n");
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Using 'memset' on struct that contains a 'std::vector'. [memsetClass]\n"
+                      "[test.cpp:5:5]: (error) Using 'memset' on struct that contains a 'std::vector'. [memsetClass]\n"
+                      "[test.cpp:6:5]: (error) Using 'memset' on struct that contains a 'std::vector'. [memsetClass]\n"
+                      "[test.cpp:7:5]: (error) Using 'memset' on struct that contains a 'std::vector'. [memsetClass]\n",
+                      errout_str());
+
+        // #1655
+        const Settings s = settingsBuilder().library("std.cfg").build();
+        checkNoMemset("void f() {\n"
+                      "    char c[] = \"abc\";\n"
+                      "    std::string s;\n"
+                      "    memcpy(&s, c, strlen(c) + 1);\n"
+                      "}\n", s);
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Using 'memcpy' on std::string. [memsetClass]\n", errout_str());
+
+        checkNoMemset("template <typename T>\n"
+                      "    void f(T* dst, const T* src, int N) {\n"
+                      "    std::memcpy(dst, src, N * sizeof(T));\n"
+                      "}\n"
+                      "void g() {\n"
+                      "    typedef std::vector<int>* P;\n"
+                      "    P Src[2]{};\n"
+                      "    P Dst[2];\n"
+                      "    f<P>(Dst, Src, 2);\n"
+                      "}\n", s);
+        ASSERT_EQUALS("", errout_str());
+
+        checkNoMemset("void f() {\n"
+                      "    std::array<char, 4> a;\n"
+                      "    std::memset(&a, 0, 4);\n"
+                      "}\n", s);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void memsetOnInvalid() { // Ticket #5425
@@ -2968,7 +3293,7 @@ class TestClass : public TestFixture {
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
                       "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("struct A\n"
                       "{\n"
@@ -2978,7 +3303,7 @@ class TestClass : public TestFixture {
                       "    struct A a;\n"
                       "    memset(&a, 0, sizeof(struct A));\n"
                       "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("struct A\n"
                       "{\n"
@@ -2988,14 +3313,14 @@ class TestClass : public TestFixture {
                       "    struct A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
                       "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("void f()\n"
                       "{\n"
                       "    struct sockaddr_in6 fail;\n"
                       "    memset(&fail, 0, sizeof(struct sockaddr_in6));\n"
                       "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("struct A\n"
                       "{\n"
@@ -3008,7 +3333,7 @@ class TestClass : public TestFixture {
                       " struct A fail;\n"
                       " memset(&fail, 0, sizeof(struct A));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:10]: (error) Using 'memset' on struct that contains a 'std::string'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:2]: (error) Using 'memset' on struct that contains a 'std::string'. [memsetClass]\n", errout_str());
 
         checkNoMemset("struct Fred\n"
                       "{\n"
@@ -3019,7 +3344,7 @@ class TestClass : public TestFixture {
                       "    Fred fred;\n"
                       "    memset(&fred, 0, sizeof(fred));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Using 'memset' on struct that contains a 'std::string'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:5]: (error) Using 'memset' on struct that contains a 'std::string'. [memsetClass]\n", errout_str());
 
         checkNoMemset("struct Stringy {\n"
                       "    std::string inner;\n"
@@ -3032,7 +3357,7 @@ class TestClass : public TestFixture {
                       "    memset(&foo, 0, sizeof(Foo));\n"
                       "}");
 
-        ASSERT_EQUALS("[test.cpp:9]: (error) Using 'memset' on struct that contains a 'std::string'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:5]: (error) Using 'memset' on struct that contains a 'std::string'. [memsetClass]\n", errout_str());
     }
 
     void memsetVector() {
@@ -3044,7 +3369,7 @@ class TestClass : public TestFixture {
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Using 'memset' on class that contains a 'std::vector'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:5]: (error) Using 'memset' on class that contains a 'std::vector'. [memsetClass]\n", errout_str());
 
         checkNoMemset("struct A\n"
                       "{ std::vector<int> ints; };\n"
@@ -3054,7 +3379,7 @@ class TestClass : public TestFixture {
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Using 'memset' on struct that contains a 'std::vector'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:5]: (error) Using 'memset' on struct that contains a 'std::vector'. [memsetClass]\n", errout_str());
 
         checkNoMemset("struct A\n"
                       "{ std::vector<int> ints; };\n"
@@ -3064,7 +3389,7 @@ class TestClass : public TestFixture {
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(struct A));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Using 'memset' on struct that contains a 'std::vector'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:5]: (error) Using 'memset' on struct that contains a 'std::vector'. [memsetClass]\n", errout_str());
 
         checkNoMemset("struct A\n"
                       "{ std::vector<int> ints; };\n"
@@ -3074,7 +3399,7 @@ class TestClass : public TestFixture {
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(a));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Using 'memset' on struct that contains a 'std::vector'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:5]: (error) Using 'memset' on struct that contains a 'std::vector'. [memsetClass]\n", errout_str());
 
         checkNoMemset("class A\n"
                       "{ std::vector< std::vector<int> > ints; };\n"
@@ -3084,7 +3409,7 @@ class TestClass : public TestFixture {
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Using 'memset' on class that contains a 'std::vector'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:5]: (error) Using 'memset' on class that contains a 'std::vector'. [memsetClass]\n", errout_str());
 
         checkNoMemset("struct A\n"
                       "{ std::vector< std::vector<int> > ints; };\n"
@@ -3094,7 +3419,7 @@ class TestClass : public TestFixture {
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Using 'memset' on struct that contains a 'std::vector'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:5]: (error) Using 'memset' on struct that contains a 'std::vector'. [memsetClass]\n", errout_str());
 
         checkNoMemset("struct A\n"
                       "{ std::vector< std::vector<int> > ints; };\n"
@@ -3104,7 +3429,7 @@ class TestClass : public TestFixture {
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(a));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Using 'memset' on struct that contains a 'std::vector'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:5]: (error) Using 'memset' on struct that contains a 'std::vector'. [memsetClass]\n", errout_str());
 
         checkNoMemset("struct A\n"
                       "{ std::vector<int *> ints; };\n"
@@ -3114,7 +3439,7 @@ class TestClass : public TestFixture {
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Using 'memset' on struct that contains a 'std::vector'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:5]: (error) Using 'memset' on struct that contains a 'std::vector'. [memsetClass]\n", errout_str());
 
         checkNoMemset("struct A {\n"
                       "     std::vector<int *> buf;\n"
@@ -3124,7 +3449,7 @@ class TestClass : public TestFixture {
                       "    A a;\n"
                       "    memset(a, 0, 100);\n"
                       "}");
-        ASSERT_EQUALS("", errout.str()); // #4460
+        ASSERT_EQUALS("", errout_str()); // #4460
 
         checkNoMemset("struct C {\n"
                       "    std::string s;\n"
@@ -3142,10 +3467,10 @@ class TestClass : public TestFixture {
                       "    memset(c2, 0, 10);\n"
                       "    memset(c3, 0, 10);\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:9]: (error) Using 'memset' on struct that contains a 'std::string'.\n"
-                      "[test.cpp:11]: (error) Using 'memset' on struct that contains a 'std::string'.\n"
-                      "[test.cpp:12]: (error) Using 'memset' on struct that contains a 'std::string'.\n"
-                      "[test.cpp:13]: (error) Using 'memset' on struct that contains a 'std::string'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:5]: (error) Using 'memset' on struct that contains a 'std::string'. [memsetClass]\n"
+                      "[test.cpp:11:5]: (error) Using 'memset' on struct that contains a 'std::string'. [memsetClass]\n"
+                      "[test.cpp:12:5]: (error) Using 'memset' on struct that contains a 'std::string'. [memsetClass]\n"
+                      "[test.cpp:13:5]: (error) Using 'memset' on struct that contains a 'std::string'. [memsetClass]\n", errout_str());
 
         // Ticket #6953
         checkNoMemset("typedef float realnum;\n"
@@ -3158,19 +3483,16 @@ class TestClass : public TestFixture {
                       "  memset(d, 0, sizeof(multilevel_data));\n"
                       "  return (void*) d;\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:8]: (portability) Using memset() on struct which contains a floating point number.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:3]: (portability) Using memset() on struct which contains a floating point number. [memsetClassFloat]\n", errout_str());
     }
 
     void memsetOnStdPodType() { // Ticket #5901
-        Settings settings;
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <podtype name=\"std::uint8_t\" sign=\"u\" size=\"1\"/>\n"
-                               "  <podtype name=\"std::atomic_bool\"/>\n"
-                               "</def>";
-        tinyxml2::XMLDocument doc;
-        doc.Parse(xmldata, sizeof(xmldata));
-        settings.library.load(doc);
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <podtype name=\"std::uint8_t\" sign=\"u\" size=\"1\"/>\n"
+                                   "  <podtype name=\"std::atomic_bool\"/>\n"
+                                   "</def>";
+        const Settings settings = settingsBuilder().libraryxml(xmldata).build();
 
         checkNoMemset("class A {\n"
                       "    std::array<int, 10> ints;\n"
@@ -3179,7 +3501,7 @@ class TestClass : public TestFixture {
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
                       "}");
-        ASSERT_EQUALS("", errout.str()); // std::array is POD (#5481)
+        ASSERT_EQUALS("", errout_str()); // std::array is POD (#5481)
 
         checkNoMemset("struct st {\n"
                       "  std::uint8_t a;\n"
@@ -3190,7 +3512,7 @@ class TestClass : public TestFixture {
                       "  st s;\n"
                       "  std::memset(&s, 0, sizeof(st));\n"
                       "}", settings);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void memsetOnFloat() {
@@ -3201,7 +3523,7 @@ class TestClass : public TestFixture {
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:6]: (portability) Using memset() on struct which contains a floating point number.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:5]: (portability) Using memset() on struct which contains a floating point number. [memsetClassFloat]\n", errout_str());
 
         checkNoMemset("struct A {\n"
                       "    float f[4];\n"
@@ -3210,7 +3532,7 @@ class TestClass : public TestFixture {
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:6]: (portability) Using memset() on struct which contains a floating point number.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:5]: (portability) Using memset() on struct which contains a floating point number. [memsetClassFloat]\n", errout_str());
 
         checkNoMemset("struct A {\n"
                       "    float f[4];\n"
@@ -3219,7 +3541,7 @@ class TestClass : public TestFixture {
                       "    A a;\n"
                       "    memcpy(&a, &b, sizeof(A));\n"
                       "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("struct A {\n"
                       "    float* f;\n"
@@ -3228,7 +3550,7 @@ class TestClass : public TestFixture {
                       "    A a;\n"
                       "    memset(&a, 0, sizeof(A));\n"
                       "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void memsetOnUnknown() {
@@ -3236,7 +3558,7 @@ class TestClass : public TestFixture {
                       "  *Tokens = (CXToken *)malloc(sizeof(CXToken) * CXTokens.size());\n"
                       "  memmove(*Tokens, CXTokens.data(), sizeof(CXToken) * CXTokens.size());\n"
                       "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void mallocOnClass() {
@@ -3244,61 +3566,77 @@ class TestClass : public TestFixture {
                       "void foo(C*& p) {\n"
                       "    p = malloc(sizeof(C));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:1]: (warning) Memory for class instance allocated with malloc(), but class provides constructors.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5] -> [test.cpp:1:1]: (warning) Memory for class instance allocated with malloc(), but class provides constructors. [mallocOnClassWarning]\n", errout_str());
 
         checkNoMemset("class C { C(int z, Foo bar) { bar(); } };\n"
                       "void foo(C*& p) {\n"
                       "    p = malloc(sizeof(C));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:1]: (warning) Memory for class instance allocated with malloc(), but class provides constructors.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5] -> [test.cpp:1:1]: (warning) Memory for class instance allocated with malloc(), but class provides constructors. [mallocOnClassWarning]\n", errout_str());
 
         checkNoMemset("struct C { C() {} };\n"
                       "void foo(C*& p) {\n"
                       "    p = realloc(p, sizeof(C));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:1]: (warning) Memory for class instance allocated with realloc(), but class provides constructors.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5] -> [test.cpp:1:1]: (warning) Memory for class instance allocated with realloc(), but class provides constructors. [mallocOnClassWarning]\n", errout_str());
 
         checkNoMemset("struct C { virtual void bar(); };\n"
                       "void foo(C*& p) {\n"
                       "    p = malloc(sizeof(C));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:1]: (error) Memory for class instance allocated with malloc(), but class contains a virtual function.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:1:1]: (error) Memory for class instance allocated with malloc(), but class contains a virtual function. [mallocOnClassError]\n", errout_str());
 
         checkNoMemset("struct C { std::string s; };\n"
                       "void foo(C*& p) {\n"
                       "    p = malloc(sizeof(C));\n"
                       "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:1]: (error) Memory for class instance allocated with malloc(), but class contains a 'std::string'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:1:1]: (error) Memory for class instance allocated with malloc(), but class contains a 'std::string'. [mallocOnClassError]\n", errout_str());
 
         checkNoMemset("class C { };\n" // C-Style class/struct
                       "void foo(C*& p) {\n"
                       "    p = malloc(sizeof(C));\n"
                       "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("struct C { C() {} };\n"
                       "void foo(C*& p) {\n"
                       "    p = new C();\n"
                       "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkNoMemset("class C { C() {} };\n"
                       "void foo(D*& p) {\n" // Unknown type
                       "    p = malloc(sizeof(C));\n"
                       "}");
-        ASSERT_EQUALS("", errout.str());
-    }
-
+        ASSERT_EQUALS("", errout_str());
 
-    void checkThisSubtraction(const char code[]) {
-        // Clear the error log
-        errout.str("");
-
-        // Tokenize..
-        Tokenizer tokenizer(&settings1, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        tokenizer.simplifyTokenList2();
+        checkNoMemset("class AutoCloseFD {\n"
+                      "    int fd;\n"
+                      "public:\n"
+                      "    AutoCloseFD(int fd);\n"
+                      "    ~AutoCloseFD();\n"
+                      "};\n"
+                      "void f() {\n"
+                      "    AutoCloseFD fd = open(\"abc\", O_RDONLY | O_CLOEXEC);\n"
+                      "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNoMemset("struct C {\n" // #12313
+                      "    char* p;\n"
+                      "    C(char* ptr) : p(ptr) {}\n"
+                      "};\n"
+                      "void f() {\n"
+                      "    C c = strdup(\"abc\");\n"
+                      "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+#define checkThisSubtraction(...) checkThisSubtraction_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkThisSubtraction_(const char* file, int line, const char (&code)[size]) {
+        // Tokenize..
+        SimpleTokenizer tokenizer(settings1, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check..
         CheckClass checkClass(&tokenizer, &settings1, this);
@@ -3307,39 +3645,42 @@ class TestClass : public TestFixture {
 
     void this_subtraction() {
         checkThisSubtraction("; this-x ;");
-        ASSERT_EQUALS("[test.cpp:1]: (warning) Suspicious pointer subtraction. Did you intend to write '->'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:3]: (warning) Suspicious pointer subtraction. Did you intend to write '->'? [thisSubtraction]\n", errout_str());
 
         checkThisSubtraction("; *this = *this-x ;");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkThisSubtraction("; *this = *this-x ;\n"
                              "this-x ;");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Suspicious pointer subtraction. Did you intend to write '->'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:1]: (warning) Suspicious pointer subtraction. Did you intend to write '->'? [thisSubtraction]\n", errout_str());
 
         checkThisSubtraction("; *this = *this-x ;\n"
                              "this-x ;\n"
-                             "this-x ;\n");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Suspicious pointer subtraction. Did you intend to write '->'?\n"
-                      "[test.cpp:3]: (warning) Suspicious pointer subtraction. Did you intend to write '->'?\n", errout.str());
+                             "this-x ;");
+        ASSERT_EQUALS("[test.cpp:2:1]: (warning) Suspicious pointer subtraction. Did you intend to write '->'? [thisSubtraction]\n"
+                      "[test.cpp:3:1]: (warning) Suspicious pointer subtraction. Did you intend to write '->'? [thisSubtraction]\n", errout_str());
     }
 
-    void checkConst(const char code[], Settings *s = nullptr, bool inconclusive = true) {
-        // Clear the error log
-        errout.str("");
+    struct CheckConstOptions
+    {
+        bool inconclusive = true;
+    };
 
-        // Check..
-        if (!s)
-            s = &settings0;
-        s->inconclusive = inconclusive;
+#define checkConst(...) checkConst_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkConst_(const char* file, int line, const char (&code)[size], const CheckConstOptions& options = make_default_obj()) {
+        const Settings& settings = options.inconclusive ? settings0_i : settings0;
 
-        // Tokenize..
-        Tokenizer tokenizer(s, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        tokenizer.simplifyTokenList2();
+        checkConst_(file, line, code, settings);
+    }
+
+    template<size_t size>
+    void checkConst_(const char* file, int line, const char (&code)[size], const Settings& settings) {
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
-        CheckClass checkClass(&tokenizer, s, this);
-        checkClass.checkConst();
+        CheckClass checkClass(&tokenizer, &settings, this);
+        (checkClass.checkConst)();
     }
 
     void const1() {
@@ -3347,18 +3688,18 @@ class TestClass : public TestFixture {
                    "    int a;\n"
                    "    int getA() { return a; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style, inconclusive) Technically the member function 'Fred::getA' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style, inconclusive) Technically the member function 'Fred::getA' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Fred {\n"
                    "    const std::string foo() { return \"\"; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:2]: (performance, inconclusive) Technically the member function 'Fred::foo' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:23]: (style) The member function 'Fred::foo' can be static. [functionStatic]\n", errout_str());
 
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    const std::string & foo() { return \"\"; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::foo' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:25]: (style) The member function 'Fred::foo' can be static. [functionStatic]\n", errout_str());
 
         // constructors can't be const..
         checkConst("class Fred {\n"
@@ -3366,14 +3707,14 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    Fred() { }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assignment through |=..
         checkConst("class Fred {\n"
                    "    int a;\n"
                    "    int setA() { a |= true; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // functions with a call to a member function can only be const, if that member function is const, too.. (#1305)
         checkConst("class foo {\n"
@@ -3382,7 +3723,7 @@ class TestClass : public TestFixture {
                    "    void a() { x = 1; }\n"
                    "    void b() { a(); }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "public:\n"
@@ -3390,14 +3731,14 @@ class TestClass : public TestFixture {
                    "    int a() const { return x; }\n"
                    "    void b() { a(); }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:5]: (style, inconclusive) Technically the member function 'Fred::b' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10]: (style, inconclusive) Technically the member function 'Fred::b' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Fred {\n"
                    "public:\n"
                    "    int x;\n"
                    "    void b() { a(); }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (performance, inconclusive) Technically the member function 'Fred::b' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:10]: (style) The member function 'Fred::b' can be static. [functionStatic]\n", errout_str());
 
         // static functions can't be const..
         checkConst("class foo\n"
@@ -3406,12 +3747,12 @@ class TestClass : public TestFixture {
                    "    static unsigned get()\n"
                    "    { return 0; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    const std::string foo() const throw() { return \"\"; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:2]: (performance, inconclusive) Technically the member function 'Fred::foo' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:23]: (style) The member function 'Fred::foo' can be static. [functionStatic]\n", errout_str());
     }
 
     void const2() {
@@ -3421,49 +3762,49 @@ class TestClass : public TestFixture {
                    "    std::string s;\n"
                    "    void foo() { s = \"\"; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assignment to function argument reference can be const
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo(std::string & a) { a = s; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style, inconclusive) Technically the member function 'Fred::foo' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Technically the member function 'Fred::foo' can be const. [functionConst]\n", errout_str());
 
         // assignment to variable can't be const
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo(std::string & a) { s = a; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assignment to function argument references can be const
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo(std::string & a, std::string & b) { a = s; b = s; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style, inconclusive) Technically the member function 'Fred::foo' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Technically the member function 'Fred::foo' can be const. [functionConst]\n", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo(std::string & a, std::string & b) { s = a; s = b; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo(std::string & a, std::string & b) { s = a; b = a; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo(std::string & a, std::string & b) { a = s; s = b; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const3() {
@@ -3472,42 +3813,42 @@ class TestClass : public TestFixture {
                    "    int s;\n"
                    "    void foo(int * a) { *a = s; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style, inconclusive) Technically the member function 'Fred::foo' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Technically the member function 'Fred::foo' can be const. [functionConst]\n", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
                    "    int s;\n"
                    "    void foo(int * a) { s = *a; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assignment to function argument pointers can be const
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo(std::string * a, std::string * b) { *a = s; *b = s; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style, inconclusive) Technically the member function 'Fred::foo' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Technically the member function 'Fred::foo' can be const. [functionConst]\n", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo(std::string * a, std::string * b) { s = *a; s = *b; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo(std::string * a, std::string * b) { s = *a; *b = s; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    void foo(std::string * a, std::string * b) { *a = s; s = b; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const4() {
@@ -3516,14 +3857,14 @@ class TestClass : public TestFixture {
                    "    int getA();\n"
                    "};\n"
                    "int Fred::getA() { return a; }");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:3]: (style, inconclusive) Technically the member function 'Fred::getA' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:5:11]: (style, inconclusive) Technically the member function 'Fred::getA' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Fred {\n"
                    "    std::string s;\n"
                    "    const std::string & foo();\n"
                    "};\n"
                    "const std::string & Fred::foo() { return \"\"; }");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::foo' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:25] -> [test.cpp:5:27]: (style) The member function 'Fred::foo' can be static. [functionStatic]\n", errout_str());
 
         // functions with a function call to a non-const member can't be const.. (#1305)
         checkConst("class Fred\n"
@@ -3534,7 +3875,7 @@ class TestClass : public TestFixture {
                    "    void b();\n"
                    "};\n"
                    "void Fred::b() { a(); }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // static functions can't be const..
         checkConst("class Fred\n"
@@ -3543,7 +3884,7 @@ class TestClass : public TestFixture {
                    "    static unsigned get();\n"
                    "};\n"
                    "static unsigned Fred::get() { return 0; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assignment to variable can't be const
         checkConst("class Fred {\n"
@@ -3551,7 +3892,7 @@ class TestClass : public TestFixture {
                    "    void foo();\n"
                    "};\n"
                    "void Fred::foo() { s = \"\"; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assignment to function argument reference can be const
         checkConst("class Fred {\n"
@@ -3559,7 +3900,7 @@ class TestClass : public TestFixture {
                    "    void foo(std::string & a);\n"
                    "};\n"
                    "void Fred::foo(std::string & a) { a = s; }");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:3]: (style, inconclusive) Technically the member function 'Fred::foo' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:5:12]: (style, inconclusive) Technically the member function 'Fred::foo' can be const. [functionConst]\n", errout_str());
 
         // assignment to variable can't be const
         checkConst("class Fred {\n"
@@ -3567,7 +3908,7 @@ class TestClass : public TestFixture {
                    "    void foo(std::string & a);\n"
                    "};\n"
                    "void Fred::foo(std::string & a) { s = a; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assignment to function argument references can be const
         checkConst("class Fred {\n"
@@ -3575,7 +3916,7 @@ class TestClass : public TestFixture {
                    "    void foo(std::string & a, std::string & b);\n"
                    "};\n"
                    "void Fred::foo(std::string & a, std::string & b) { a = s; b = s; }");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:3]: (style, inconclusive) Technically the member function 'Fred::foo' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:5:12]: (style, inconclusive) Technically the member function 'Fred::foo' can be const. [functionConst]\n", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
@@ -3583,7 +3924,7 @@ class TestClass : public TestFixture {
                    "    void foo(std::string & a, std::string & b);\n"
                    "};\n"
                    "void Fred::foo(std::string & a, std::string & b) { s = a; s = b; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
@@ -3591,7 +3932,7 @@ class TestClass : public TestFixture {
                    "    void foo(std::string & a, std::string & b);\n"
                    "};\n"
                    "void Fred::foo(std::string & a, std::string & b) { s = a; b = a; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
@@ -3599,7 +3940,7 @@ class TestClass : public TestFixture {
                    "    void foo(std::string & a, std::string & b);\n"
                    "};\n"
                    "void Fred::foo(std::string & a, std::string & b) { a = s; s = b; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assignment to function argument pointer can be const
         checkConst("class Fred {\n"
@@ -3607,7 +3948,7 @@ class TestClass : public TestFixture {
                    "    void foo(int * a);\n"
                    "};\n"
                    "void Fred::foo(int * a) { *a = s; }");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:3]: (style, inconclusive) Technically the member function 'Fred::foo' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:5:12]: (style, inconclusive) Technically the member function 'Fred::foo' can be const. [functionConst]\n", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
@@ -3615,7 +3956,7 @@ class TestClass : public TestFixture {
                    "    void foo(int * a);\n"
                    "};\n"
                    "void Fred::foo(int * a) { s = *a; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assignment to function argument pointers can be const
         checkConst("class Fred {\n"
@@ -3623,7 +3964,7 @@ class TestClass : public TestFixture {
                    "    void foo(std::string * a, std::string * b);\n"
                    "};\n"
                    "void Fred::foo(std::string * a, std::string * b) { *a = s; *b = s; }");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:3]: (style, inconclusive) Technically the member function 'Fred::foo' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:5:12]: (style, inconclusive) Technically the member function 'Fred::foo' can be const. [functionConst]\n", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
@@ -3631,7 +3972,7 @@ class TestClass : public TestFixture {
                    "    void foo(std::string * a, std::string * b);\n"
                    "};\n"
                    "void Fred::foo(std::string * a, std::string * b) { s = *a; s = *b; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
@@ -3639,7 +3980,7 @@ class TestClass : public TestFixture {
                    "    void foo(std::string * a, std::string * b);\n"
                    "};\n"
                    "void Fred::foo(std::string * a, std::string * b) { s = *a; *b = s; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assignment to variable, can't be const
         checkConst("class Fred {\n"
@@ -3647,7 +3988,7 @@ class TestClass : public TestFixture {
                    "    void foo(std::string * a, std::string * b);\n"
                    "};\n"
                    "void Fred::foo(std::string * a, std::string * b) { *a = s; s = b; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // check functions with same name
         checkConst("class Fred {\n"
@@ -3659,8 +4000,8 @@ class TestClass : public TestFixture {
                    "void Fred::foo() { }"
                    "void Fred::foo(std::string & a) { a = s; }"
                    "void Fred::foo(const std::string & a) { s = a; }");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::foo' can be static (but you may consider moving to unnamed namespace).\n"
-                      "[test.cpp:7] -> [test.cpp:4]: (style, inconclusive) Technically the member function 'Fred::foo' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:7:12]: (style) The member function 'Fred::foo' can be static. [functionStatic]\n"
+                      "[test.cpp:4:10] -> [test.cpp:7:32]: (style, inconclusive) Technically the member function 'Fred::foo' can be const. [functionConst]\n", errout_str());
 
         // check functions with different or missing parameter names
         checkConst("class Fred {\n"
@@ -3676,11 +4017,11 @@ class TestClass : public TestFixture {
                    "void Fred::foo3(int a, int b) { }\n"
                    "void Fred::foo4(int a, int b) { }\n"
                    "void Fred::foo5(int, int) { }");
-        ASSERT_EQUALS("[test.cpp:9] -> [test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::foo1' can be static (but you may consider moving to unnamed namespace).\n"
-                      "[test.cpp:10] -> [test.cpp:4]: (performance, inconclusive) Technically the member function 'Fred::foo2' can be static (but you may consider moving to unnamed namespace).\n"
-                      "[test.cpp:11] -> [test.cpp:5]: (performance, inconclusive) Technically the member function 'Fred::foo3' can be static (but you may consider moving to unnamed namespace).\n"
-                      "[test.cpp:12] -> [test.cpp:6]: (performance, inconclusive) Technically the member function 'Fred::foo4' can be static (but you may consider moving to unnamed namespace).\n"
-                      "[test.cpp:13] -> [test.cpp:7]: (performance, inconclusive) Technically the member function 'Fred::foo5' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:9:12]: (style) The member function 'Fred::foo1' can be static. [functionStatic]\n"
+                      "[test.cpp:4:10] -> [test.cpp:10:12]: (style) The member function 'Fred::foo2' can be static. [functionStatic]\n"
+                      "[test.cpp:5:10] -> [test.cpp:11:12]: (style) The member function 'Fred::foo3' can be static. [functionStatic]\n"
+                      "[test.cpp:6:10] -> [test.cpp:12:12]: (style) The member function 'Fred::foo4' can be static. [functionStatic]\n"
+                      "[test.cpp:7:10] -> [test.cpp:13:12]: (style) The member function 'Fred::foo5' can be static. [functionStatic]\n", errout_str());
 
         // check nested classes
         checkConst("class Fred {\n"
@@ -3689,7 +4030,7 @@ class TestClass : public TestFixture {
                    "        int getA() { return a; }\n"
                    "    };\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'Fred::A::getA' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (style, inconclusive) Technically the member function 'Fred::A::getA' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Fred {\n"
                    "    class A {\n"
@@ -3698,7 +4039,7 @@ class TestClass : public TestFixture {
                    "    };\n"
                    "    int A::getA() { return a; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:4]: (style, inconclusive) Technically the member function 'Fred::A::getA' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13] -> [test.cpp:6:12]: (style, inconclusive) Technically the member function 'Fred::A::getA' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Fred {\n"
                    "    class A {\n"
@@ -3707,7 +4048,7 @@ class TestClass : public TestFixture {
                    "    };\n"
                    "};\n"
                    "int Fred::A::getA() { return a; }");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:4]: (style, inconclusive) Technically the member function 'Fred::A::getA' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13] -> [test.cpp:7:14]: (style, inconclusive) Technically the member function 'Fred::A::getA' can be const. [functionConst]\n", errout_str());
 
         // check deeply nested classes
         checkConst("class Fred {\n"
@@ -3720,9 +4061,9 @@ class TestClass : public TestFixture {
                    "        };\n"
                    "    };\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'Fred::B::getB' can be const.\n"
-                      "[test.cpp:7]: (style, inconclusive) Technically the member function 'Fred::B::A::getA' can be const.\n"
-                      , errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (style, inconclusive) Technically the member function 'Fred::B::getB' can be const. [functionConst]\n"
+                      "[test.cpp:7:17]: (style, inconclusive) Technically the member function 'Fred::B::A::getA' can be const. [functionConst]\n"
+                      , errout_str());
 
         checkConst("class Fred {\n"
                    "    class B {\n"
@@ -3736,8 +4077,8 @@ class TestClass : public TestFixture {
                    "    };\n"
                    "    int B::getB() { return b; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:11] -> [test.cpp:4]: (style, inconclusive) Technically the member function 'Fred::B::getB' can be const.\n"
-                      "[test.cpp:9] -> [test.cpp:7]: (style, inconclusive) Technically the member function 'Fred::B::A::getA' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13] -> [test.cpp:11:12]: (style, inconclusive) Technically the member function 'Fred::B::getB' can be const. [functionConst]\n"
+                      "[test.cpp:7:17] -> [test.cpp:9:16]: (style, inconclusive) Technically the member function 'Fred::B::A::getA' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Fred {\n"
                    "    class B {\n"
@@ -3751,8 +4092,8 @@ class TestClass : public TestFixture {
                    "    int B::A::getA() { return a; }\n"
                    "    int B::getB() { return b; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:11] -> [test.cpp:4]: (style, inconclusive) Technically the member function 'Fred::B::getB' can be const.\n"
-                      "[test.cpp:10] -> [test.cpp:7]: (style, inconclusive) Technically the member function 'Fred::B::A::getA' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13] -> [test.cpp:11:12]: (style, inconclusive) Technically the member function 'Fred::B::getB' can be const. [functionConst]\n"
+                      "[test.cpp:7:17] -> [test.cpp:10:15]: (style, inconclusive) Technically the member function 'Fred::B::A::getA' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Fred {\n"
                    "    class B {\n"
@@ -3766,8 +4107,8 @@ class TestClass : public TestFixture {
                    "};\n"
                    "int Fred::B::A::getA() { return a; }\n"
                    "int Fred::B::getB() { return b; }");
-        ASSERT_EQUALS("[test.cpp:12] -> [test.cpp:4]: (style, inconclusive) Technically the member function 'Fred::B::getB' can be const.\n"
-                      "[test.cpp:11] -> [test.cpp:7]: (style, inconclusive) Technically the member function 'Fred::B::A::getA' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13] -> [test.cpp:12:14]: (style, inconclusive) Technically the member function 'Fred::B::getB' can be const. [functionConst]\n"
+                      "[test.cpp:7:17] -> [test.cpp:11:17]: (style, inconclusive) Technically the member function 'Fred::B::A::getA' can be const. [functionConst]\n", errout_str());
     }
 
     // operator< can often be const
@@ -3776,7 +4117,7 @@ class TestClass : public TestFixture {
                    "    int a;\n"
                    "    bool operator<(const Fred &f) { return a < f.a; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style, inconclusive) Technically the member function 'Fred::operator<' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Technically the member function 'Fred::operator<' can be const. [functionConst]\n", errout_str());
     }
 
     // operator<<
@@ -3791,7 +4132,7 @@ class TestClass : public TestFixture {
                    "        foo << 123;\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("struct Foo {\n"
                    "    void operator<<(int);\n"
@@ -3803,7 +4144,7 @@ class TestClass : public TestFixture {
                    "        std::cout << foo << 123;\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:6]: (style, inconclusive) Technically the member function 'Fred::x' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:10]: (style, inconclusive) Technically the member function 'Fred::x' can be const. [functionConst]\n", errout_str());
     }
 
     void constoperator3() {
@@ -3812,13 +4153,13 @@ class TestClass : public TestFixture {
                    "    int const & operator [] (unsigned int index) const { return array[index]; }\n"
                    "    int & operator [] (unsigned int index) { return array[index]; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("struct Fred {\n"
                    "    int array[10];\n"
                    "    int const & operator [] (unsigned int index) { return array[index]; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style, inconclusive) Technically the member function 'Fred::operator[]' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:17]: (style, inconclusive) Technically the member function 'Fred::operator[]' can be const. [functionConst]\n", errout_str());
     }
 
     void constoperator4() {
@@ -3828,14 +4169,14 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    operator int*() { return &c; };\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class A {\n"
                    "    int c;\n"
                    "public:\n"
                    "    operator const int*() { return &c; };\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::operatorconstint*' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (style, inconclusive) Technically the member function 'A::operatorconstint*' can be const. [functionConst]\n", errout_str());
 
         // #2375
         checkConst("struct Fred {\n"
@@ -3843,14 +4184,14 @@ class TestClass : public TestFixture {
                    "    typedef int* (Fred::*UnspecifiedBoolType);\n"
                    "    operator UnspecifiedBoolType() { };\n"
                    "};");
-        TODO_ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'Fred::operatorint**' can be const.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'Fred::operatorint**' can be const.\n", "", errout_str());
 
         checkConst("struct Fred {\n"
                    "    int array[10];\n"
                    "    typedef int* (Fred::*UnspecifiedBoolType);\n"
                    "    operator UnspecifiedBoolType() { array[0] = 0; };\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void constoperator5() { // ticket #3252
@@ -3859,21 +4200,21 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    operator int& () {return c}\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class A {\n"
                    "    int c;\n"
                    "public:\n"
                    "    operator const int& () {return c}\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::operatorconstint&' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (style, inconclusive) Technically the member function 'A::operatorconstint&' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
                    "    int c;\n"
                    "public:\n"
                    "    operator int () {return c}\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::operatorint' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (style, inconclusive) Technically the member function 'A::operatorint' can be const. [functionConst]\n", errout_str());
     }
 
     void constoperator6() { // ticket #8669
@@ -3881,7 +4222,7 @@ class TestClass : public TestFixture {
                    "    int c;\n"
                    "    void f() { os >> *this; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const5() {
@@ -3895,7 +4236,7 @@ class TestClass : public TestFixture {
                    "        return same;\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style, inconclusive) Technically the member function 'A::foo' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Technically the member function 'A::foo' can be const. [functionConst]\n", errout_str());
     }
 
     void const6() {
@@ -3904,14 +4245,14 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "};\n"
                    "void bar() {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred\n"
                    "{\n"
                    "public:\n"
                    "    void foo() { }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (performance, inconclusive) Technically the member function 'Fred::foo' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:10]: (style) The member function 'Fred::foo' can be static. [functionStatic]\n", errout_str());
 
         checkConst("struct fast_string\n"
                    "{\n"
@@ -3925,7 +4266,7 @@ class TestClass : public TestFixture {
                    "{\n"
                    "    buff[10] = t;\n"
                    "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const7() {
@@ -3936,7 +4277,7 @@ class TestClass : public TestFixture {
                    "    void set(const foo & f) { *this = f; }\n"
                    "};\n"
                    "void bar() {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const8() {
@@ -3948,7 +4289,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    std::string m_strValue;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::strGetString' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:17]: (style, inconclusive) Technically the member function 'A::strGetString' can be const. [functionConst]\n", errout_str());
     }
 
     void const9() {
@@ -3959,7 +4300,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    wxThread::ExitCode m_exitcode;\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const10() {
@@ -3970,7 +4311,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    int x;\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class A {\n"
                    "public:\n"
@@ -3978,7 +4319,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    int x;\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class A {\n"
                    "public:\n"
@@ -3986,7 +4327,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    int x;\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const11() {
@@ -3997,7 +4338,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    struct tm m_time;\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const12() {
@@ -4008,7 +4349,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    mutable int x;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style, inconclusive) Technically the member function 'A::foo' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style, inconclusive) Technically the member function 'A::foo' can be const. [functionConst]\n", errout_str());
     }
 
     void const13() {
@@ -4022,8 +4363,8 @@ class TestClass : public TestFixture {
                    "    std::vector<int> m_vec;\n"
                    "    std::pair<int,double> m_pair;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::GetVec' can be const.\n"
-                      "[test.cpp:5]: (style, inconclusive) Technically the member function 'A::GetPair' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:22]: (style, inconclusive) Technically the member function 'A::GetVec' can be const. [functionConst]\n"
+                      "[test.cpp:5:27]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
                    "public:\n"
@@ -4034,8 +4375,8 @@ class TestClass : public TestFixture {
                    "    std::vector<int> m_vec;\n"
                    "    std::pair<int,double> m_pair;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::GetVec' can be const.\n"
-                      "[test.cpp:5]: (style, inconclusive) Technically the member function 'A::GetPair' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:30]: (style, inconclusive) Technically the member function 'A::GetVec' can be const. [functionConst]\n"
+                      "[test.cpp:5:35]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
     }
 
     void const14() {
@@ -4047,7 +4388,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    std::pair<std::vector<int>,double> m_pair;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::GetPair' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:40]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
                    "public:\n"
@@ -4056,7 +4397,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    std::pair<std::vector<int>,double> m_pair;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::GetPair' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:47]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
                    "public:\n"
@@ -4065,7 +4406,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    std::pair<std::vector<int>,double> m_pair;\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
 
         checkConst("using namespace std;"
@@ -4076,7 +4417,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    pair<int ,double> m_pair;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::GetPair' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:23]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("using namespace std;"
                    "class A {\n"
@@ -4086,7 +4427,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    pair<int ,double> m_pair;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::GetPair' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:31]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("using namespace std;"
                    "class A {\n"
@@ -4096,7 +4437,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    pair<int ,double> m_pair;\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
 
         checkConst("class A {\n"
@@ -4106,7 +4447,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    std::pair< int,std::vector<int> >  m_pair;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::GetPair' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:40]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
                    "public:\n"
@@ -4115,7 +4456,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    std::pair< int,std::vector<int> >  m_pair;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::GetPair' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:47]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
                    "public:\n"
@@ -4124,7 +4465,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    std::pair< int,std::vector<int> >  m_pair;\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
 
         checkConst("using namespace std;"
@@ -4135,7 +4476,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    pair< vector<int>, int >  m_pair;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::GetPair' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:31]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("using namespace std;"
                    "class A {\n"
@@ -4145,7 +4486,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    pair< vector<int>, int >  m_pair;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::GetPair' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:38]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("using namespace std;"
                    "class A {\n"
@@ -4155,7 +4496,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    pair< vector<int>, int >  m_pair;\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class A {\n"
                    "public:\n"
@@ -4164,7 +4505,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    std::pair< std::vector<int>,std::vector<int> >  m_pair;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::GetPair' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:53]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
                    "public:\n"
@@ -4173,7 +4514,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    std::pair< std::vector<int>,std::vector<int> >  m_pair;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::GetPair' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:60]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
                    "public:\n"
@@ -4182,7 +4523,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    std::pair< std::vector<int>,std::vector<int> >  m_pair;\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
 
 
@@ -4193,7 +4534,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    std::pair< std::pair < int, char > , int >  m_pair;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::GetPair' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:49]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
                    "public:\n"
@@ -4202,7 +4543,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    std::pair< std::pair < int, char > , int >  m_pair;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::GetPair' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:56]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
                    "public:\n"
@@ -4211,7 +4552,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    std::pair< std::pair < int, char > , int >  m_pair;\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
 
         checkConst("class A {\n"
@@ -4221,7 +4562,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    std::pair< int , std::pair < int, char > >  m_pair;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::GetPair' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:49]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
                    "public:\n"
@@ -4230,7 +4571,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    std::pair< int , std::pair < int, char > >  m_pair;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::GetPair' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:56]: (style, inconclusive) Technically the member function 'A::GetPair' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
                    "public:\n"
@@ -4239,7 +4580,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    std::pair< int , std::pair < int, char > >  m_pair;\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
 
         checkConst("using namespace std;"
@@ -4250,7 +4591,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    vector<int>  m_Vec;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::GetVec' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:18]: (style, inconclusive) Technically the member function 'A::GetVec' can be const. [functionConst]\n", errout_str());
 
         checkConst("using namespace std;"
                    "class A {\n"
@@ -4260,7 +4601,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    vector<int>  m_Vec;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::GetVec' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:25]: (style, inconclusive) Technically the member function 'A::GetVec' can be const. [functionConst]\n", errout_str());
 
         checkConst("using namespace std;"
                    "class A {\n"
@@ -4270,7 +4611,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    vector<int>  m_Vec;\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
 
         checkConst("class A {\n"
@@ -4279,7 +4620,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    const int * x;\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class A {\n"
                    "public:\n"
@@ -4287,7 +4628,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    const int * x;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style, inconclusive) Technically the member function 'A::foo' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:18]: (style, inconclusive) Technically the member function 'A::foo' can be const. [functionConst]\n", errout_str());
     }
 
     void const15() {
@@ -4295,7 +4636,7 @@ class TestClass : public TestFixture {
                    "    unsigned long long int a;\n"
                    "    unsigned long long int getA() { return a; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style, inconclusive) Technically the member function 'Fred::getA' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:28]: (style, inconclusive) Technically the member function 'Fred::getA' can be const. [functionConst]\n", errout_str());
 
         // constructors can't be const..
         checkConst("class Fred {\n"
@@ -4303,14 +4644,14 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    Fred() { }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assignment through |=..
         checkConst("class Fred {\n"
                    "    unsigned long long int a;\n"
                    "    unsigned long long int setA() { a |= true; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // static functions can't be const..
         checkConst("class foo\n"
@@ -4319,7 +4660,7 @@ class TestClass : public TestFixture {
                    "    static unsigned long long int get()\n"
                    "    { return 0; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const16() {
@@ -4328,7 +4669,7 @@ class TestClass : public TestFixture {
                    "    int a;\n"
                    "    void set(int i) { Fred::a = i; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const17() {
@@ -4339,7 +4680,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    struct { int k; } a[4];\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const18() {
@@ -4348,7 +4689,7 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    void set(int i) { x = i; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (performance, inconclusive) Technically the member function 'Fred::set' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:10]: (style) The member function 'Fred::set' can be static. [functionStatic]\n", errout_str());
     }
 
     void const19() {
@@ -4360,7 +4701,7 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    void set(std::string ss) { s = ss; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const20() {
@@ -4370,35 +4711,35 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    void set(int i) { x = i; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    list<int *> x;\n"
                    "public:\n"
                    "    list<int *> get() { return x; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    list<const int *> x;\n"
                    "public:\n"
                    "    list<const int *> get() { return x; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'Fred::get' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:23]: (style, inconclusive) Technically the member function 'Fred::get' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Fred {\n"
                    "    std::list<std::string &> x;\n"
                    "public:\n"
                    "    std::list<std::string &> get() { return x; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    std::list<const std::string &> x;\n"
                    "public:\n"
                    "    std::list<const std::string &> get() { return x; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'Fred::get' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:36]: (style, inconclusive) Technically the member function 'Fred::get' can be const. [functionConst]\n", errout_str());
     }
 
     void const21() {
@@ -4414,7 +4755,7 @@ class TestClass : public TestFixture {
                    "    }\n"
                    "    void f1() { l1[0] = \"Hello\"; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const22() {
@@ -4425,7 +4766,7 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    void f1() { v1 = 0; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class A\n"
                    "{\n"
@@ -4434,7 +4775,7 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    void f1() { v1[0] = 0; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const23() {
@@ -4446,7 +4787,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    Type2 _m;\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const24() {
@@ -4459,7 +4800,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    std::map<QString, QString> *m_pSettings;\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -4473,9 +4814,8 @@ class TestClass : public TestFixture {
                    "{return m_strVal.c_str();}\n"
                    "private:\n"
                    "std::string m_strVal;\n"
-                   "};\n"
-                  );
-        ASSERT_EQUALS("", errout.str());
+                   "};");
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class A{\n"
                    "public:\n"
@@ -4484,9 +4824,8 @@ class TestClass : public TestFixture {
                    "{return m_strVal.c_str();}\n"
                    "private:\n"
                    "std::string m_strVal;\n"
-                   "};\n"
-                  );
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::strGetString' can be const.\n", errout.str());
+                   "};");
+        ASSERT_EQUALS("[test.cpp:4:13]: (style, inconclusive) Technically the member function 'A::strGetString' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A{\n"
                    "public:\n"
@@ -4495,9 +4834,8 @@ class TestClass : public TestFixture {
                    "{return m_strVal.c_str();}\n"
                    "private:\n"
                    "std::string m_strVal;\n"
-                   "};\n"
-                  );
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::strGetString1' can be const.\n", errout.str());
+                   "};");
+        ASSERT_EQUALS("[test.cpp:4:19]: (style, inconclusive) Technically the member function 'A::strGetString1' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A{\n"
                    "public:\n"
@@ -4506,9 +4844,8 @@ class TestClass : public TestFixture {
                    "{return m_strVec.size();}\n"
                    "private:\n"
                    "std::vector<std::string> m_strVec;\n"
-                   "};\n"
-                  );
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::strGetSize' can be const.\n", errout.str());
+                   "};");
+        ASSERT_EQUALS("[test.cpp:4:8]: (style, inconclusive) Technically the member function 'A::strGetSize' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A{\n"
                    "public:\n"
@@ -4517,9 +4854,8 @@ class TestClass : public TestFixture {
                    "{return m_strVec.empty();}\n"
                    "private:\n"
                    "std::vector<std::string> m_strVec;\n"
-                   "};\n"
-                  );
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'A::strGetEmpty' can be const.\n", errout.str());
+                   "};");
+        ASSERT_EQUALS("[test.cpp:4:6]: (style, inconclusive) Technically the member function 'A::strGetEmpty' can be const. [functionConst]\n", errout_str());
     }
 
     void const26() { // ticket #1847
@@ -4529,9 +4865,8 @@ class TestClass : public TestFixture {
                    "    std::swap<float>(delays_[index1], delays_[index2]);\n"
                    "}\n"
                    "float delays_[4];\n"
-                   "};\n"
-                  );
-        ASSERT_EQUALS("", errout.str());
+                   "};");
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("struct DelayBase {\n"
                    "    float swapSpecificDelays(int index1) {\n"
@@ -4539,7 +4874,7 @@ class TestClass : public TestFixture {
                    "    }\n"
                    "    float delays_[4];\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:2]: (style, inconclusive) Technically the member function 'DelayBase::swapSpecificDelays' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (style, inconclusive) Technically the member function 'DelayBase::swapSpecificDelays' can be const. [functionConst]\n", errout_str());
     }
 
     void const27() { // ticket #1882
@@ -4556,8 +4891,8 @@ class TestClass : public TestFixture {
                    "    if( m_d != 0 )\n"
                    "        return m_iRealVal / m_d;\n"
                    "    return dRet;\n"
-                   "};", nullptr, true);
-        ASSERT_EQUALS("[test.cpp:9] -> [test.cpp:4]: (style, inconclusive) Technically the member function 'A::dGetValue' can be const.\n", errout.str());
+                   "};");
+        ASSERT_EQUALS("[test.cpp:4:12] -> [test.cpp:9:12]: (style, inconclusive) Technically the member function 'A::dGetValue' can be const. [functionConst]\n", errout_str());
     }
 
     void const28() { // ticket #1883
@@ -4573,9 +4908,8 @@ class TestClass : public TestFixture {
                    "        x=xPos;\n"
                    "        y=yPos;\n"
                    "    }\n"
-                   "};\n"
-                  );
-        ASSERT_EQUALS("", errout.str());
+                   "};");
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class AA : public P {\n"
                    "public:\n"
@@ -4585,7 +4919,7 @@ class TestClass : public TestFixture {
                    "        UnknownScope::x = x_;\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class AA {\n"
                    "public:\n"
@@ -4595,7 +4929,7 @@ class TestClass : public TestFixture {
                    "        UnknownScope::x = x_;\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:4]: (performance, inconclusive) Technically the member function 'AA::vSetXPos' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:17]: (style) The member function 'AA::vSetXPos' can be static. [functionStatic]\n", errout_str());
 
     }
 
@@ -4620,7 +4954,7 @@ class TestClass : public TestFixture {
                    "{\n"
                    "  return value_;\n"
                    "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const30() {
@@ -4635,7 +4969,7 @@ class TestClass : public TestFixture {
                    "        return a;\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:7]: (style, inconclusive) Technically the member function 'Derived::get' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:9]: (style, inconclusive) Technically the member function 'Derived::get' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Base1 {\n"
                    "public:\n"
@@ -4654,8 +4988,8 @@ class TestClass : public TestFixture {
                    "        return b;\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:11]: (style, inconclusive) Technically the member function 'Derived::getA' can be const.\n"
-                      "[test.cpp:14]: (style, inconclusive) Technically the member function 'Derived::getB' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:11:9]: (style, inconclusive) Technically the member function 'Derived::getA' can be const. [functionConst]\n"
+                      "[test.cpp:14:9]: (style, inconclusive) Technically the member function 'Derived::getB' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Base {\n"
                    "public:\n"
@@ -4668,7 +5002,7 @@ class TestClass : public TestFixture {
                    "        return a;\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:8]: (style, inconclusive) Technically the member function 'Derived2::get' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:9]: (style, inconclusive) Technically the member function 'Derived2::get' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Base {\n"
                    "public:\n"
@@ -4683,7 +5017,7 @@ class TestClass : public TestFixture {
                    "        return a;\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:10]: (style, inconclusive) Technically the member function 'Derived4::get' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:9]: (style, inconclusive) Technically the member function 'Derived4::get' can be const. [functionConst]\n", errout_str());
 
         // check for false positives
         checkConst("class Base {\n"
@@ -4696,7 +5030,7 @@ class TestClass : public TestFixture {
                    "        return a;\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class Base1 {\n"
                    "public:\n"
@@ -4715,7 +5049,7 @@ class TestClass : public TestFixture {
                    "        return b;\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class Base {\n"
                    "public:\n"
@@ -4728,7 +5062,7 @@ class TestClass : public TestFixture {
                    "        return a;\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class Base {\n"
                    "public:\n"
@@ -4743,7 +5077,7 @@ class TestClass : public TestFixture {
                    "        return a;\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const31() {
@@ -4753,7 +5087,7 @@ class TestClass : public TestFixture {
                    "    int a;\n"
                    "    int get() { return a; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:5]: (style, inconclusive) Technically the member function 'Fred::get' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9]: (style, inconclusive) Technically the member function 'Fred::get' can be const. [functionConst]\n", errout_str());
     }
 
     void const32() {
@@ -4762,7 +5096,7 @@ class TestClass : public TestFixture {
                    "    std::string a[10];\n"
                    "    void seta() { a[0] = \"\"; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const33() {
@@ -4770,7 +5104,7 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    void f(){}\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) Either there is a missing 'override', or the member function 'derived::f' can be static. [functionStatic]\n", errout_str());
     }
 
     void const34() { // ticket #1964
@@ -4779,7 +5113,7 @@ class TestClass : public TestFixture {
                    "        foo.bar = this;\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const35() { // ticket #2001
@@ -4798,7 +5132,7 @@ class TestClass : public TestFixture {
                    "                int var;\n"
                    "        };\n"
                    "}");
-        ASSERT_EQUALS("[test.cpp:12]: (style, inconclusive) Technically the member function 'N::Derived::getResourceName' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:12:21]: (style, inconclusive) Technically the member function 'N::Derived::getResourceName' can be const. [functionConst]\n", errout_str());
 
         checkConst("namespace N\n"
                    "{\n"
@@ -4810,7 +5144,7 @@ class TestClass : public TestFixture {
                    "        };\n"
                    "}\n"
                    "int N::Base::getResourceName() { return var; }");
-        ASSERT_EQUALS("[test.cpp:10] -> [test.cpp:6]: (style, inconclusive) Technically the member function 'N::Base::getResourceName' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:21] -> [test.cpp:10:14]: (style, inconclusive) Technically the member function 'N::Base::getResourceName' can be const. [functionConst]\n", errout_str());
 
         checkConst("namespace N\n"
                    "{\n"
@@ -4825,7 +5159,7 @@ class TestClass : public TestFixture {
                    "{\n"
                    "        int Base::getResourceName() { return var; }\n"
                    "}");
-        ASSERT_EQUALS("[test.cpp:12] -> [test.cpp:6]: (style, inconclusive) Technically the member function 'N::Base::getResourceName' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:21] -> [test.cpp:12:19]: (style, inconclusive) Technically the member function 'N::Base::getResourceName' can be const. [functionConst]\n", errout_str());
 
         checkConst("namespace N\n"
                    "{\n"
@@ -4838,7 +5172,7 @@ class TestClass : public TestFixture {
                    "}\n"
                    "using namespace N;\n"
                    "int Base::getResourceName() { return var; }");
-        ASSERT_EQUALS("[test.cpp:11] -> [test.cpp:6]: (style, inconclusive) Technically the member function 'N::Base::getResourceName' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:21] -> [test.cpp:11:11]: (style, inconclusive) Technically the member function 'N::Base::getResourceName' can be const. [functionConst]\n", errout_str());
     }
 
     void const36() { // ticket #2003
@@ -4850,7 +5184,7 @@ class TestClass : public TestFixture {
                    "        m_MaxQueueSize = a_MaxQueueSize;\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const37() { // ticket #2081 and #2085
@@ -4865,7 +5199,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    std::string m_str;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:5]: (style, inconclusive) Technically the member function 'A::operator+' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:17]: (style, inconclusive) Technically the member function 'A::operator+' can be const. [functionConst]\n", errout_str());
 
         checkConst("class Fred\n"
                    "{\n"
@@ -4879,7 +5213,7 @@ class TestClass : public TestFixture {
                    "        return (x == 0x11224488);\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:9]: (style, inconclusive) Technically the member function 'Fred::isValid' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:10]: (style, inconclusive) Technically the member function 'Fred::isValid' can be const. [functionConst]\n", errout_str());
     }
 
     void const38() { // ticket #2135
@@ -4895,7 +5229,7 @@ class TestClass : public TestFixture {
                    "{\n"
                    "    (*oArq) << \"</table>\";\n"
                    "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const39() {
@@ -4916,7 +5250,7 @@ class TestClass : public TestFixture {
                    "    return p;\n"
                    "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const40() { // ticket #2228
@@ -4933,7 +5267,7 @@ class TestClass : public TestFixture {
                    "   }\n"
                    "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const41() { // ticket #2255
@@ -4947,7 +5281,7 @@ class TestClass : public TestFixture {
                    "   }\n"
                    "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class SharedPtrHolder\n"
                    "{\n"
@@ -4959,7 +5293,7 @@ class TestClass : public TestFixture {
                    "   }\n"
                    "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class SharedPtrHolder2\n"
                    "{\n"
@@ -4974,7 +5308,7 @@ class TestClass : public TestFixture {
                    "   }\n"
                    "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("struct IntPtrTypes\n"
                    "{\n"
@@ -4991,7 +5325,7 @@ class TestClass : public TestFixture {
                    "   }\n"
                    "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("template <typename T>\n"
                    "struct PtrTypes\n"
@@ -5009,7 +5343,7 @@ class TestClass : public TestFixture {
                    "   }\n"
                    "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const42() { // ticket #2282
@@ -5023,7 +5357,7 @@ class TestClass : public TestFixture {
                    "{\n"
                    "}");
 
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:5]: (performance, inconclusive) Technically the member function 'Fred::f' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10] -> [test.cpp:7:12]: (style) The member function 'Fred::f' can be static. [functionStatic]\n", errout_str());
 
         checkConst("class Fred\n"
                    "{\n"
@@ -5037,7 +5371,7 @@ class TestClass : public TestFixture {
                    "{\n"
                    "}");
 
-        ASSERT_EQUALS("[test.cpp:9] -> [test.cpp:7]: (performance, inconclusive) Technically the member function 'Fred::f' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:10] -> [test.cpp:9:12]: (style) The member function 'Fred::f' can be static. [functionStatic]\n", errout_str());
 
         checkConst("namespace NS {\n"
                    "    class Fred\n"
@@ -5053,7 +5387,7 @@ class TestClass : public TestFixture {
                    "    }\n"
                    "}");
 
-        ASSERT_EQUALS("[test.cpp:10] -> [test.cpp:8]: (performance, inconclusive) Technically the member function 'NS::Fred::f' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:14] -> [test.cpp:10:16]: (style) The member function 'NS::Fred::f' can be static. [functionStatic]\n", errout_str());
 
         checkConst("namespace NS {\n"
                    "    class Fred\n"
@@ -5069,7 +5403,7 @@ class TestClass : public TestFixture {
                    "{\n"
                    "}");
 
-        ASSERT_EQUALS("[test.cpp:11] -> [test.cpp:8]: (performance, inconclusive) Technically the member function 'NS::Fred::f' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:14] -> [test.cpp:11:16]: (style) The member function 'NS::Fred::f' can be static. [functionStatic]\n", errout_str());
 
         checkConst("class Foo {\n"
                    "    class Fred\n"
@@ -5085,7 +5419,7 @@ class TestClass : public TestFixture {
                    "{\n"
                    "}");
 
-        ASSERT_EQUALS("[test.cpp:11] -> [test.cpp:8]: (performance, inconclusive) Technically the member function 'Foo::Fred::f' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:14] -> [test.cpp:11:17]: (style) The member function 'Foo::Fred::f' can be static. [functionStatic]\n", errout_str());
     }
 
     void const43() { // ticket 2377
@@ -5100,7 +5434,7 @@ class TestClass : public TestFixture {
                    "    a = b;\n"
                    "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("namespace AA\n"
                    "{\n"
@@ -5124,7 +5458,7 @@ class TestClass : public TestFixture {
                    "    }\n"
                    "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("namespace ZZ\n"
                    "{\n"
@@ -5143,7 +5477,7 @@ class TestClass : public TestFixture {
                    "        a = b;\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const44() { // ticket 2595
@@ -5157,7 +5491,7 @@ class TestClass : public TestFixture {
                    "    }\n"
                    "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const45() { // ticket 2664
@@ -5174,7 +5508,7 @@ class TestClass : public TestFixture {
                    "    };\n"
                    "}");
 
-        ASSERT_EQUALS("[test.cpp:8]: (performance, inconclusive) Technically the member function 'tools::WorkspaceControl::toGrid' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:13]: (style) The member function 'tools::WorkspaceControl::toGrid' can be static. [functionStatic]\n", errout_str());
     }
 
     void const46() { // ticket 2663
@@ -5189,8 +5523,8 @@ class TestClass : public TestFixture {
                    "    }\n"
                    "};");
 
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Altren::fun1' can be static (but you may consider moving to unnamed namespace).\n"
-                      "[test.cpp:7]: (performance, inconclusive) Technically the member function 'Altren::fun2' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) The member function 'Altren::fun1' can be static. [functionStatic]\n"
+                      "[test.cpp:7:9]: (style) The member function 'Altren::fun2' can be static. [functionStatic]\n", errout_str());
     }
 
     void const47() { // ticket 2670
@@ -5201,7 +5535,7 @@ class TestClass : public TestFixture {
                    "  void bar() { foo(); }\n"
                    "};");
 
-        ASSERT_EQUALS("[test.cpp:4]: (performance, inconclusive) Technically the member function 'Altren::foo' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:8]: (style) The member function 'Altren::foo' can be static. [functionStatic]\n", errout_str());
 
         checkConst("class Altren {\n"
                    "public:\n"
@@ -5210,8 +5544,8 @@ class TestClass : public TestFixture {
                    "  void bar() { foo(1); }\n"
                    "};");
 
-        ASSERT_EQUALS("[test.cpp:4]: (performance, inconclusive) Technically the member function 'Altren::foo' can be static (but you may consider moving to unnamed namespace).\n"
-                      "[test.cpp:5]: (style, inconclusive) Technically the member function 'Altren::bar' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:8]: (style) The member function 'Altren::foo' can be static. [functionStatic]\n"
+                      "[test.cpp:5:8]: (style, inconclusive) Technically the member function 'Altren::bar' can be const. [functionConst]\n", errout_str());
     }
 
     void const48() { // ticket 2672
@@ -5233,7 +5567,7 @@ class TestClass : public TestFixture {
                    "    mSave = mCurrent;\n"
                    "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const49() { // ticket 2795
@@ -5247,7 +5581,7 @@ class TestClass : public TestFixture {
                    "             return _hash[key];\n"
                    "         }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const50() { // ticket 2943
@@ -5263,7 +5597,7 @@ class TestClass : public TestFixture {
                    "        if (mEmptyView) return;\n"
                    "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const51() { // ticket 3040
@@ -5276,7 +5610,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    unsigned char *_pesdata;\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class PESPacket {\n"
                    "public:\n"
@@ -5291,7 +5625,7 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    void SetSection(uint num) { pesdata()[6] = num; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const52() { // ticket 3048
@@ -5301,7 +5635,7 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "    int bar;\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:2]: (performance, inconclusive) Technically the member function 'foo::DoSomething' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (style) The member function 'foo::DoSomething' can be static. [functionStatic]\n", errout_str());
     }
 
     void const53() { // ticket 3049
@@ -5317,7 +5651,7 @@ class TestClass : public TestFixture {
                    "    B() {};\n"
                    "    bool One(bool b = false) { return false; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const54() { // ticket 3052
@@ -5325,7 +5659,7 @@ class TestClass : public TestFixture {
                    "  public:\n"
                    "    void Clear(void) { Example tmp; (*this) = tmp; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const55() {
@@ -5335,7 +5669,7 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    void set(std::stringstream &in) { in >> tmp; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const56() { // ticket #3149
@@ -5345,7 +5679,7 @@ class TestClass : public TestFixture {
                    "    switch (x) { }\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'MyObject::foo' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'MyObject::foo' can be static. [functionStatic]\n", errout_str());
 
         checkConst("class A\n"
                    "{\n"
@@ -5385,7 +5719,7 @@ class TestClass : public TestFixture {
                    "\n"
                    "    return RET_NOK;\n"
                    "}");
-        ASSERT_EQUALS("[test.cpp:9] -> [test.cpp:4]: (performance, inconclusive) Technically the member function 'A::f' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:24] -> [test.cpp:9:19]: (style) The member function 'A::f' can be static. [functionStatic]\n", errout_str());
 
         checkConst("class MyObject {\n"
                    "public:\n"
@@ -5393,7 +5727,7 @@ class TestClass : public TestFixture {
                    "    for (int i = 0; i < 5; i++) { }\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'MyObject::foo' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'MyObject::foo' can be static. [functionStatic]\n", errout_str());
     }
 
     void const57() { // tickets #2669 and #2477
@@ -5418,9 +5752,9 @@ class TestClass : public TestFixture {
                    "private:\n"
                    "  MyGUI::IntCoord mCoordValue;\n"
                    "};");
-        TODO_ASSERT_EQUALS("[test.cpp:7]: (performance, inconclusive) Technically the member function 'MyGUI::types::TCoord::size' can be static (but you may consider moving to unnamed namespace).\n"
+        TODO_ASSERT_EQUALS("[test.cpp:7:13]: (style) The member function 'MyGUI::types::TCoord::size' can be static. [functionStatic]\n"
                            "[test.cpp:15]: (style, inconclusive) Technically the member function 'SelectorControl::getSize' can be const.\n",
-                           "[test.cpp:7]: (performance, inconclusive) Technically the member function 'MyGUI::types::TCoord::size' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+                           "[test.cpp:7:13]: (style) The member function 'MyGUI::types::TCoord::size' can be static. [functionStatic]\n", errout_str());
 
         checkConst("struct Foo {\n"
                    "    Bar b;\n"
@@ -5428,7 +5762,7 @@ class TestClass : public TestFixture {
                    "        b.run();\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("struct Bar {\n"
                    "    int i = 0;\n"
@@ -5440,7 +5774,7 @@ class TestClass : public TestFixture {
                    "        b.run();\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("struct Bar {\n"
                    "    void run() const { }\n"
@@ -5451,8 +5785,8 @@ class TestClass : public TestFixture {
                    "        b.run();\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:2]: (performance, inconclusive) Technically the member function 'Bar::run' can be static (but you may consider moving to unnamed namespace).\n"
-                      "[test.cpp:6]: (style, inconclusive) Technically the member function 'Foo::foo' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (style) The member function 'Bar::run' can be static. [functionStatic]\n"
+                      "[test.cpp:6:10]: (style, inconclusive) Technically the member function 'Foo::foo' can be const. [functionConst]\n", errout_str());
     }
 
     void const58() {
@@ -5461,14 +5795,14 @@ class TestClass : public TestFixture {
                    "        f.clear();\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:2]: (performance, inconclusive) Technically the member function 'MyObject::foo' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (style) The member function 'MyObject::foo' can be static. [functionStatic]\n", errout_str());
 
         checkConst("struct MyObject {\n"
                    "    int foo(Foo f) {\n"
                    "        return f.length();\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:2]: (performance, inconclusive) Technically the member function 'MyObject::foo' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) The member function 'MyObject::foo' can be static. [functionStatic]\n", errout_str());
 
         checkConst("struct MyObject {\n"
                    "    Foo f;\n"
@@ -5476,7 +5810,7 @@ class TestClass : public TestFixture {
                    "        return f.length();\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("struct MyObject {\n"
                    "    std::string f;\n"
@@ -5484,7 +5818,7 @@ class TestClass : public TestFixture {
                    "        return f.length();\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style, inconclusive) Technically the member function 'MyObject::foo' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style, inconclusive) Technically the member function 'MyObject::foo' can be const. [functionConst]\n", errout_str());
     }
 
     void const59() { // ticket #4646
@@ -5496,7 +5830,7 @@ class TestClass : public TestFixture {
                    "    int   re;\n"
                    "    int   im;\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const60() { // ticket #3322
@@ -5508,36 +5842,36 @@ class TestClass : public TestFixture {
                    "            m_ptr = new char[42];\n"
                    "    }\n"
                    "    MyString append( const MyString& str )\n"
-                   "    {       return operator+=( str ); } \n"
+                   "    {       return operator+=( str ); }\n"
                    "    char *m_ptr;\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         checkConst("class MyString {\n"
                    "public:\n"
                    "    MyString() : m_ptr(0){}\n"
                    "    MyString& operator+=( const MyString& rhs );\n"
                    "    MyString append( const MyString& str )\n"
-                   "    {       return operator+=( str ); } \n"
+                   "    {       return operator+=( str ); }\n"
                    "    char *m_ptr;\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const61() { // ticket #5606 - don't crash
+        // this code is invalid so a false negative is OK
         checkConst("class MixerParticipant : public MixerParticipant {\n"
                    "    int GetAudioFrame();\n"
                    "};\n"
                    "int MixerParticipant::GetAudioFrame() {\n"
                    "    return 0;\n"
                    "}");
-        ASSERT_EQUALS("", errout.str());
 
+        // this code is invalid so a false negative is OK
         checkConst("class MixerParticipant : public MixerParticipant {\n"
                    "    bool InitializeFileReader() {\n"
                    "       printf(\"music\");\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
 
         // Based on an example from SVN source code causing an endless recursion within CheckClass::isConstMemberFunc()
         // A more complete example including a template declaration like
@@ -5555,8 +5889,9 @@ class TestClass : public TestFixture {
                    "  void set(const Key& key) {\n"
                    "      inherited::set(inherited::Key(key));\n"
                    "  }\n"
-                   "};\n", nullptr, false);
-        ASSERT_EQUALS("", errout.str());
+                   "};\n", dinit(CheckConstOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:4:23]: (style) Either there is a missing 'override', or the member function 'MixerParticipant::GetAudioFrame' can be static. [functionStatic]\n",
+                      errout_str());
     }
 
     void const62() {
@@ -5570,7 +5905,7 @@ class TestClass : public TestFixture {
                    "             return _hash[key];\n"
                    "         }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const63() {
@@ -5581,7 +5916,7 @@ class TestClass : public TestFixture {
                    "         p->clear();\n"
                    "     }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("struct A {\n"
                    "    std::string s;\n"
@@ -5590,7 +5925,7 @@ class TestClass : public TestFixture {
                    "         r.clear();\n"
                    "     }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("struct A {\n"
                    "    std::string s;\n"
@@ -5599,7 +5934,7 @@ class TestClass : public TestFixture {
                    "         r.clear();\n"
                    "     }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style, inconclusive) Technically the member function 'A::clear' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Technically the member function 'A::clear' can be const. [functionConst]\n", errout_str());
 
         checkConst("struct A {\n"
                    "    std::string s;\n"
@@ -5608,7 +5943,7 @@ class TestClass : public TestFixture {
                    "         p->somefunction();\n"
                    "     }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style, inconclusive) Technically the member function 'A::clear' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Technically the member function 'A::clear' can be const. [functionConst]\n", errout_str());
 
         checkConst("struct A {\n"
                    "    std::string s;\n"
@@ -5617,7 +5952,7 @@ class TestClass : public TestFixture {
                    "         r.somefunction();\n"
                    "     }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style, inconclusive) Technically the member function 'A::clear' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Technically the member function 'A::clear' can be const. [functionConst]\n", errout_str());
     }
 
     void const64() {
@@ -5632,7 +5967,7 @@ class TestClass : public TestFixture {
                    "        ::B::D::DKIPtr membervariable;\n"
                    "    };\n"
                    "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const65() {
@@ -5650,8 +5985,8 @@ class TestClass : public TestFixture {
                    "    TemplateClass<int> a;\n"
                    "    TemplateClass<float> b;\n"
                    "    return 0;\n"
-                   "}\n");
-        ASSERT_EQUALS("", errout.str());
+                   "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const66() {
@@ -5660,8 +5995,8 @@ class TestClass : public TestFixture {
                    "    void f(int v) { g((char *) &v); }\n"
                    "    void g(char *) { n++; }\n"
                    "    int n;\n"
-                   "};\n");
-        ASSERT_EQUALS("", errout.str());
+                   "};");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const67() { // #9193
@@ -5674,301 +6009,1266 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    const std::list<std::shared_ptr<int>>& get() { return m_test.m_list; }\n"
                    "    TestList<std::shared_ptr<int>> m_test;\n"
-                   "};\n");
-        ASSERT_EQUALS("[test.cpp:8]: (style, inconclusive) Technically the member function 'Test::get' can be const.\n", errout.str());
+                   "};");
+        ASSERT_EQUALS("[test.cpp:8:44]: (style, inconclusive) Technically the member function 'Test::get' can be const. [functionConst]\n", errout_str());
     }
 
-    void const_handleDefaultParameters() {
-        checkConst("struct Foo {\n"
-                   "    void foo1(int i, int j = 0) {\n"
-                   "        return func(this);\n"
-                   "    }\n"
-                   "    int bar1() {\n"
-                   "        return foo1(1);\n"
-                   "    }\n"
-                   "    int bar2() {\n"
-                   "        return foo1(1, 2);\n"
-                   "    }\n"
-                   "    int bar3() {\n"
-                   "        return foo1(1, 2, 3);\n"
-                   "    }\n"
-                   "    int bar4() {\n"
-                   "        return foo1();\n"
-                   "    }\n"
-                   "    void foo2(int i = 0) {\n"
-                   "        return func(this);\n"
-                   "    }\n"
-                   "    int bar5() {\n"
-                   "        return foo2();\n"
+    void const68() { // #6471
+        checkConst("class MyClass {\n"
+                   "    void clear() {\n"
+                   "        SVecPtr v = (SVecPtr) m_data;\n"
+                   "        v->clear();\n"
                    "    }\n"
-                   "    void foo3() {\n"
-                   "        return func(this);\n"
+                   "    void* m_data;\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void const69() { // #9806
+        checkConst("struct A {\n"
+                   "    int a = 0;\n"
+                   "    template <typename... Args> void call(const Args &... args) { a = 1; }\n"
+                   "    template <typename T, typename... Args> auto call(const Args &... args) -> T {\n"
+                   "        a = 2;\n"
+                   "        return T{};\n"
                    "    }\n"
-                   "    int bar6() {\n"
-                   "        return foo3();\n"
+                   "};\n"
+                   "\n"
+                   "struct B : public A {\n"
+                   "    void test() {\n"
+                   "        call();\n"
+                   "        call<int>(1, 2, 3);\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:11]: (performance, inconclusive) Technically the member function 'Foo::bar3' can be static (but you may consider moving to unnamed namespace).\n"
-                      "[test.cpp:14]: (performance, inconclusive) Technically the member function 'Foo::bar4' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void const_passThisToMemberOfOtherClass() {
-        checkConst("struct Foo {\n"
-                   "    void foo() {\n"
-                   "        Bar b;\n"
-                   "        b.takeFoo(this);\n"
+    void const70() {
+        checkConst("struct A {\n"
+                   "    template <typename... Args> void call(Args ... args) {\n"
+                   "        func(this);\n"
                    "    }\n"
-                   "};");
-        ASSERT_EQUALS("", errout.str());
-
-        checkConst("struct Foo {\n"
-                   "    void foo() {\n"
-                   "        Foo f;\n"
-                   "        f.foo();\n"
+                   "\n"
+                   "    void test() {\n"
+                   "        call(1, 2);\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:2]: (performance, inconclusive) Technically the member function 'Foo::foo' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        checkConst("struct A;\n" // #5839 - operator()
-                   "struct B {\n"
-                   "    void operator()(A *a);\n"
+    void const71() { // #10146
+        checkConst("struct Bar {\n"
+                   "    int j = 5;\n"
+                   "    void f(int& i) const { i += j; }\n"
                    "};\n"
-                   "struct A {\n"
-                   "    void dostuff() {\n"
-                   "        B()(this);\n"
+                   "struct Foo {\n"
+                   "    Bar bar;\n"
+                   "    int k{};\n"
+                   "    void g() { bar.f(k); }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("struct S {\n"
+                   "    A a;\n"
+                   "    void f(int j, int*& p) {\n"
+                   "        p = &(((a[j])));\n"
                    "    }\n"
-                   "};");
-        ASSERT_EQUALS("", errout.str());
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void assigningPointerToPointerIsNotAConstOperation() {
-        checkConst("struct s\n"
-                   "{\n"
-                   "    int** v;\n"
-                   "    void f()\n"
-                   "    {\n"
-                   "        v = 0;\n"
-                   "    }\n"
+    void const72() { // #10520
+        checkConst("struct S {\n"
+                   "    explicit S(int* p) : mp(p) {}\n"
+                   "    int* mp{};\n"
                    "};\n"
-                  );
-        ASSERT_EQUALS("", errout.str());
-    }
+                   "struct C {\n"
+                   "    int i{};\n"
+                   "    S f() { return S{ &i }; }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
 
-    void assigningArrayElementIsNotAConstOperation() {
-        checkConst("struct s\n"
-                   "{\n"
-                   "    ::std::string v[3];\n"
-                   "    void f()\n"
-                   "    {\n"
-                   "        v[0] = \"Happy new year!\";\n"
-                   "    }\n"
+        checkConst("struct S {\n"
+                   "    explicit S(int* p) : mp(p) {}\n"
+                   "    int* mp{};\n"
                    "};\n"
-                  );
-        ASSERT_EQUALS("", errout.str());
-    }
+                   "struct C {\n"
+                   "    int i{};\n"
+                   "    S f() { return S(&i); }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
 
-    // increment/decrement => not const
-    void constincdec() {
-        checkConst("class Fred {\n"
-                   "    int a;\n"
-                   "    void nextA() { return ++a; }\n"
-                   "};");
-        ASSERT_EQUALS("", errout.str());
+        checkConst("struct S {\n"
+                   "    int* mp{};\n"
+                   "};\n"
+                   "struct C {\n"
+                   "    int i{};\n"
+                   "    S f() { return S{ &i }; }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
 
-        checkConst("class Fred {\n"
-                   "    int a;\n"
-                   "    void nextA() { return --a; }\n"
-                   "};");
-        ASSERT_EQUALS("", errout.str());
+        checkConst("struct S {\n"
+                   "    int* mp{};\n"
+                   "};\n"
+                   "struct C {\n"
+                   "    int i{};\n"
+                   "    S f() { return { &i }; }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
 
-        checkConst("class Fred {\n"
-                   "    int a;\n"
-                   "    void nextA() { return a++; }\n"
-                   "};");
-        ASSERT_EQUALS("", errout.str());
+        checkConst("struct S {\n"
+                   "    explicit S(const int* p) : mp(p) {}\n"
+                   "    const int* mp{};\n"
+                   "};\n"
+                   "struct C {\n"
+                   "    int i{};\n"
+                   "    S f() { return S{ &i }; }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:7:7]: (style, inconclusive) Technically the member function 'C::f' can be const. [functionConst]\n", errout_str());
 
-        checkConst("class Fred {\n"
-                   "    int a;\n"
-                   "    void nextA() { return a--; }\n"
-                   "};");
-        ASSERT_EQUALS("", errout.str());
+        checkConst("struct S {\n"
+                   "    explicit S(const int* p) : mp(p) {}\n"
+                   "    const int* mp{};\n"
+                   "};\n"
+                   "struct C {\n"
+                   "    int i{};\n"
+                   "    S f() { return S(&i); }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:7:7]: (style, inconclusive) Technically the member function 'C::f' can be const. [functionConst]\n", errout_str());
 
-        checkConst("int a;\n"
-                   "class Fred {\n"
-                   "    void nextA() { return ++a; }\n"
-                   "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        checkConst("struct S {\n"
+                   "    const int* mp{};\n"
+                   "};\n"
+                   "struct C {\n"
+                   "    int i{};\n"
+                   "    S f() { return S{ &i }; }\n"
+                   "};\n");
+        TODO_ASSERT_EQUALS("[test.cpp:7:7]: (style, inconclusive) Technically the member function 'C::f' can be const. [functionConst]\n", "", errout_str());
 
-        checkConst("int a;\n"
-                   "class Fred {\n"
-                   "    void nextA() { return --a; }\n"
-                   "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        checkConst("struct S {\n"
+                   "    const int* mp{};\n"
+                   "};\n"
+                   "struct C {\n"
+                   "    int i{};\n"
+                   "    S f() { return { &i }; }\n"
+                   "};\n");
+        TODO_ASSERT_EQUALS("[test.cpp:7:7]: (style, inconclusive) Technically the member function 'C::f' can be const. [functionConst]\n", "", errout_str());
+    }
 
-        checkConst("int a;\n"
-                   "class Fred {\n"
-                   "    void nextA() { return a++; }\n"
-                   "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+    void const73() {
+        checkConst("struct A {\n"
+                   "    int* operator[](int i);\n"
+                   "    const int* operator[](int i) const;\n"
+                   "};\n"
+                   "struct S {\n"
+                   "    A a;\n"
+                   "    void f(int j) {\n"
+                   "        int* p = a[j];\n"
+                   "        *p = 0;\n"
+                   "    }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
 
-        checkConst("int a;\n"
-                   "class Fred {\n"
-                   "    void nextA() { return a--; }\n"
-                   "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        checkConst("struct S {\n" // #10758
+                   "    T* h;\n"
+                   "    void f(); \n"
+                   "};\n"
+                   "void S::f() {\n"
+                   "    char* c = h->x[y];\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:5:9]: (style, inconclusive) Technically the member function 'S::f' can be const. [functionConst]\n", errout_str());
     }
 
-    void constassign1() {
-        checkConst("class Fred {\n"
-                   "    int a;\n"
-                   "    void nextA() { return a=1; }\n"
+    void const74() { // #10671
+        checkConst("class A {\n"
+                   "    std::vector<std::string> m_str;\n"
+                   "public:\n"
+                   "    A() {}\n"
+                   "    void bar(void) {\n"
+                   "        for(std::vector<std::string>::const_iterator it = m_str.begin(); it != m_str.end(); ++it) {;}\n"
+                   "    }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10]: (style, inconclusive) Technically the member function 'A::bar' can be const. [functionConst]\n", errout_str());
 
-        checkConst("class Fred {\n"
-                   "    int a;\n"
-                   "    void nextA() { return a-=1; }\n"
-                   "};");
-        ASSERT_EQUALS("", errout.str());
+        // Don't crash
+        checkConst("struct S {\n"
+                   "    std::vector<T*> v;\n"
+                   "    void f() const;\n"
+                   "};\n"
+                   "void S::f() const {\n"
+                   "    for (std::vector<T*>::const_iterator it = v.begin(), end = v.end(); it != end; ++it) {}\n"
+                   "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        checkConst("class Fred {\n"
-                   "    int a;\n"
-                   "    void nextA() { return a+=1; }\n"
-                   "};");
-        ASSERT_EQUALS("", errout.str());
+    void const75() { // #10065
+        checkConst("namespace N { int i = 0; }\n"
+                   "struct S {\n"
+                   "    int i;\n"
+                   "    void f() {\n"
+                   "        if (N::i) {}\n"
+                   "    }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: (style) The member function 'S::f' can be static. [functionStatic]\n", errout_str());
 
-        checkConst("class Fred {\n"
-                   "    int a;\n"
-                   "    void nextA() { return a*=-1; }\n"
-                   "};");
-        ASSERT_EQUALS("", errout.str());
+        checkConst("int i = 0;\n"
+                   "struct S {\n"
+                   "    int i;\n"
+                   "    void f() {\n"
+                   "        if (::i) {}\n"
+                   "    }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: (style) The member function 'S::f' can be static. [functionStatic]\n", errout_str());
 
-        checkConst("class Fred {\n"
-                   "    int a;\n"
-                   "    void nextA() { return a/=-2; }\n"
-                   "};");
-        ASSERT_EQUALS("", errout.str());
+        checkConst("namespace N {\n"
+                   "    struct S {\n"
+                   "        int i;\n"
+                   "        void f() {\n"
+                   "            if (N::S::i) {}\n"
+                   "        }\n"
+                   "    };\n"
+                   "}\n");
+        ASSERT_EQUALS("[test.cpp:4:14]: (style, inconclusive) Technically the member function 'N::S::f' can be const. [functionConst]\n", errout_str());
+    }
 
-        checkConst("int a;\n"
-                   "class Fred {\n"
-                   "    void nextA() { return a=1; }\n"
-                   "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+    void const76() { // #10825
+        checkConst("struct S {\n"
+                   "    enum E {};\n"
+                   "    void f(const T* t);\n"
+                   "    E e;\n"
+                   "};\n"
+                   "struct T { void e(); };\n"
+                   "void S::f(const T* t) {\n"
+                   "    const_cast<T*>(t)->e();\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:7:9]: (style) The member function 'S::f' can be static. [functionStatic]\n",
+                      errout_str());
+    }
 
-        checkConst("int a;\n"
-                   "class Fred {\n"
-                   "    void nextA() { return a-=1; }\n"
-                   "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+    void const77() {
+        checkConst("template <typename T>\n" // #10307
+                   "struct S {\n"
+                   "    std::vector<T> const* f() const { return p; }\n"
+                   "    std::vector<T> const* p;\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
 
-        checkConst("int a;\n"
-                   "class Fred {\n"
-                   "    void nextA() { return a+=1; }\n"
-                   "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        checkConst("struct S {\n" // #10311
+                   "    std::vector<const int*> v;\n"
+                   "    std::vector<const int*>& f() { return v; }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        checkConst("int a;\n"
-                   "class Fred {\n"
-                   "    void nextA() { return a*=-1; }\n"
-                   "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+    void const78() { // #10315
+        checkConst("struct S {\n"
+                   "    typedef void(S::* F)();\n"
+                   "    void g(F f);\n"
+                   "};\n"
+                   "void S::g(F f) {\n"
+                   "    (this->*f)();\n"
+                   "}\n");
+        ASSERT_EQUALS("", errout_str());
 
-        checkConst("int a;\n"
-                   "class Fred {\n"
-                   "    void nextA() { return a/=-2; }\n"
-                   "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        checkConst("struct S {\n"
+                   "    using F = void(S::*)();\n"
+                   "    void g(F f);\n"
+                   "};\n"
+                   "void S::g(F f) {\n"
+                   "    (this->*f)();\n"
+                   "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void constassign2() {
-        checkConst("class Fred {\n"
-                   "    struct A { int a; } s;\n"
-                   "    void nextA() { return s.a=1; }\n"
-                   "};");
-        ASSERT_EQUALS("", errout.str());
-
-        checkConst("class Fred {\n"
-                   "    struct A { int a; } s;\n"
-                   "    void nextA() { return s.a-=1; }\n"
-                   "};");
-        ASSERT_EQUALS("", errout.str());
+    void const79() { // #9861
+        checkConst("class A {\n"
+                   "public:\n"
+                   "    char* f() {\n"
+                   "        return nullptr;\n"
+                   "    }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) The member function 'A::f' can be static. [functionStatic]\n",
+                      errout_str());
+    }
+
+    void const80() { // #11328
+        checkConst("struct B { static void b(); };\n"
+                   "struct S : B {\n"
+                   "    static void f() {}\n"
+                   "    void g() const;\n"
+                   "    void h();\n"
+                   "    void k();\n"
+                   "    void m();\n"
+                   "    void n();\n"
+                   "    int i;\n"
+                   "};\n"
+                   "void S::g() const {\n"
+                   "    this->f();\n"
+                   "}\n"
+                   "void S::h() {\n"
+                   "    this->f();\n"
+                   "}\n"
+                   "void S::k() {\n"
+                   "    if (i)\n"
+                   "        this->f();\n"
+                   "}\n"
+                   "void S::m() {\n"
+                   "        this->B::b();\n"
+                   "}\n"
+                   "void S::n() {\n"
+                   "        this->h();\n"
+                   "}\n");
+        ASSERT_EQUALS("[test.cpp:4:10] -> [test.cpp:11:9]: (style) The member function 'S::g' can be static. [functionStatic]\n"
+                      "[test.cpp:5:10] -> [test.cpp:14:9]: (style) The member function 'S::h' can be static. [functionStatic]\n"
+                      "[test.cpp:6:10] -> [test.cpp:17:9]: (style, inconclusive) Technically the member function 'S::k' can be const. [functionConst]\n"
+                      "[test.cpp:7:10] -> [test.cpp:21:9]: (style) The member function 'S::m' can be static. [functionStatic]\n",
+                      errout_str());
+    }
+
+    void const81() {
+        checkConst("struct A {\n" // #11330
+                   "    bool f() const;\n"
+                   "};\n"
+                   "struct S {\n"
+                   "    std::shared_ptr<A> a;\n"
+                   "    void g() {\n"
+                   "        if (a->f()) {}\n"
+                   "    }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:6:10]: (style, inconclusive) Technically the member function 'S::g' can be const. [functionConst]\n",
+                      errout_str());
+
+        checkConst("struct A {\n" // #11499
+                   "    void f() const;\n"
+                   "};\n"
+                   "template<class T>\n"
+                   "struct P {\n"
+                   "    T* operator->();\n"
+                   "    const T* operator->() const;\n"
+                   "};\n"
+                   "struct S {\n"
+                   "    P<A> p;\n"
+                   "    void g() { p->f(); }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:11:10]: (style, inconclusive) Technically the member function 'S::g' can be const. [functionConst]\n",
+                      errout_str());
+
+        checkConst("struct A {\n"
+                   "    void f(int) const;\n"
+                   "};\n"
+                   "template<class T>\n"
+                   "struct P {\n"
+                   "  T* operator->();\n"
+                   "  const T* operator->() const;\n"
+                   "};\n"
+                   "struct S {\n"
+                   "  P<A> p;\n"
+                   "  void g() { p->f(1); }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:11:8]: (style, inconclusive) Technically the member function 'S::g' can be const. [functionConst]\n", errout_str());
+
+        checkConst("struct A {\n"
+                   "    void f(void*) const;\n"
+                   "};\n"
+                   "template<class T>\n"
+                   "struct P {\n"
+                   "    T* operator->();\n"
+                   "    const T* operator->() const;\n"
+                   "    P<T>& operator=(P) {\n"
+                   "        return *this;\n"
+                   "    }\n"
+                   "};\n"
+                   "struct S {\n"
+                   "    P<A> p;\n"
+                   "    std::vector<S> g() { p->f(nullptr); return {}; }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:14:20]: (style, inconclusive) Technically the member function 'S::g' can be const. [functionConst]\n", errout_str());
+
+        checkConst("struct A {\n"
+                   "    void f();\n"
+                   "};\n"
+                   "template<class T>\n"
+                   "struct P {\n"
+                   "    T* operator->();\n"
+                   "    const T* operator->() const;\n"
+                   "};\n"
+                   "struct S {\n"
+                   "    P<A> p;\n"
+                   "    void g() { p->f(); }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("struct A {\n"
+                   "    void f() const;\n"
+                   "};\n"
+                   "template<class T>\n"
+                   "struct P {\n"
+                   "    T* operator->();\n"
+                   "};\n"
+                   "struct S {\n"
+                   "    P<A> p;\n"
+                   "    void g() { p->f(); }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("struct A {\n"
+                   "    void f(int&) const;\n"
+                   "};\n"
+                   "template<class T>\n"
+                   "struct P {\n"
+                   "    T* operator->();\n"
+                   "    const T* operator->() const;\n"
+                   "};\n"
+                   "struct S {\n"
+                   "    P<A> p;\n"
+                   "    int i;\n"
+                   "    void g() { p->f(i); }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("struct A {\n" // #11501
+                   "    enum E { E1 };\n"
+                   "    virtual void f(E) const = 0;\n"
+                   "};\n"
+                   "struct F {\n"
+                   "    A* a;\n"
+                   "    void g() { a->f(A::E1); }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:7:10]: (style, inconclusive) Technically the member function 'F::g' can be const. [functionConst]\n", errout_str());
+    }
+
+    void const82() { // #11513
+        checkConst("struct S {\n"
+                   "    int i;\n"
+                   "    void h(bool) const;\n"
+                   "    void g() { h(i == 1); }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: (style, inconclusive) Technically the member function 'S::g' can be const. [functionConst]\n",
+                      errout_str());
+
+        checkConst("struct S {\n"
+                   "    int i;\n"
+                   "    void h(int, int*) const;\n"
+                   "    void g() { int a; h(i, &a); }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: (style, inconclusive) Technically the member function 'S::g' can be const. [functionConst]\n",
+                      errout_str());
+    }
+
+    void const83() {
+        checkConst("struct S {\n"
+                   "    int i1, i2;\n"
+                   "    void f(bool b);\n"
+                   "    void g(bool b, int j);\n"
+                   "};\n"
+                   "void S::f(bool b) {\n"
+                   "    int& r = b ? i1 : i2;\n"
+                   "    r = 5;\n"
+                   "}\n"
+                   "void S::g(bool b, int j) {\n"
+                   "    int& r = b ? j : i2;\n"
+                   "    r = 5;\n"
+                   "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void const84() {
+        checkConst("class S {};\n" // #11616
+                   "struct T {\n"
+                   "    T(const S*);\n"
+                   "    T(const S&);\n"
+                   "};\n"
+                   "struct C {\n"
+                   "    const S s;\n"
+                   "    void f1() {\n"
+                   "        T t(&s);\n"
+                   "    }\n"
+                   "    void f2() {\n"
+                   "        T t(s);\n"
+                   "    }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:8:10]: (style, inconclusive) Technically the member function 'C::f1' can be const. [functionConst]\n"
+                      "[test.cpp:11:10]: (style, inconclusive) Technically the member function 'C::f2' can be const. [functionConst]\n",
+                      errout_str());
+    }
+
+    void const85() { // #11618
+        checkConst("struct S {\n"
+                   "    int a[2], b[2];\n"
+                   "    void f() { f(a, b); }\n"
+                   "    static void f(const int p[2], int q[2]);\n"
+                   "};\n"
+                   "void S::f(const int p[2], int q[2]) {\n"
+                   "    q[0] = p[0];\n"
+                   "    q[1] = p[1];\n"
+                   "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void const86() { // #11621
+        checkConst("struct S { int* p; };\n"
+                   "struct T { int m; int* p; };\n"
+                   "struct U {\n"
+                   "    int i;\n"
+                   "    void f() { S s = { &i }; }\n"
+                   "    void g() { int* a[] = { &i }; }\n"
+                   "    void h() { T t = { 1, &i }; }\n"
+                   "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void const87() {
+        checkConst("struct Tokenizer {\n" // #11720
+                   "        bool isCPP() const {\n"
+                   "        return cpp;\n"
+                   "    }\n"
+                   "    bool cpp;\n"
+                   "};\n"
+                   "struct Check {\n"
+                   "    const Tokenizer* const mTokenizer;\n"
+                   "    const int* const mSettings;\n"
+                   "};\n"
+                   "struct CheckA : Check {\n"
+                   "    static bool test(const std::string& funcname, const int* settings, bool cpp);\n"
+                   "};\n"
+                   "struct CheckB : Check {\n"
+                   "    bool f(const std::string& s);\n"
+                   "};\n"
+                   "bool CheckA::test(const std::string& funcname, const int* settings, bool cpp) {\n"
+                   "    return !funcname.empty() && settings && cpp;\n"
+                   "}\n"
+                   "bool CheckB::f(const std::string& s) {\n"
+                   "    return CheckA::test(s, mSettings, mTokenizer->isCPP());\n"
+                   "}\n");
+        ASSERT_EQUALS("[test.cpp:15:10] -> [test.cpp:20:14]: (style, inconclusive) Technically the member function 'CheckB::f' can be const. [functionConst]\n", errout_str());
+
+        checkConst("void g(int&);\n"
+                   "struct S {\n"
+                   "    struct { int i; } a[1];\n"
+                   "    void f() { g(a[0].i); }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("struct S {\n"
+                   "    const int& g() const { return i; }\n"
+                   "    int i;\n"
+                   "};\n"
+                   "void h(int, const int&);\n"
+                   "struct T {\n"
+                   "    S s;\n"
+                   "    int j;\n"
+                   "    void f() { h(j, s.g()); }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:9:10]: (style, inconclusive) Technically the member function 'T::f' can be const. [functionConst]\n", errout_str());
+
+        checkConst("struct S {\n"
+                   "    int& g() { return i; }\n"
+                   "    int i;\n"
+                   "};\n"
+                   "void h(int, int&);\n"
+                   "struct T {\n"
+                   "    S s;\n"
+                   "    int j;\n"
+                   "    void f() { h(j, s.g()); }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("struct S {\n"
+                   "    const int& g() const { return i; }\n"
+                   "    int i;\n"
+                   "};\n"
+                   "void h(int, const int*);\n"
+                   "struct T {\n"
+                   "    S s;\n"
+                   "    int j;\n"
+                   "    void f() { h(j, &s.g()); }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:9:10]: (style, inconclusive) Technically the member function 'T::f' can be const. [functionConst]\n", errout_str());
+
+        checkConst("struct S {\n"
+                   "    int& g() { return i; }\n"
+                   "    int i;\n"
+                   "};\n"
+                   "void h(int, int*);\n"
+                   "struct T {\n"
+                   "    S s;\n"
+                   "    int j;\n"
+                   "    void f() { h(j, &s.g()); }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("void j(int** x);\n"
+                   "void k(int* const* y);\n"
+                   "struct S {\n"
+                   "    int* p;\n"
+                   "    int** q;\n"
+                   "    int* const* r;\n"
+                   "    void f1() { j(&p); }\n"
+                   "    void f2() { j(q); }\n"
+                   "    void g1() { k(&p); }\n"
+                   "    void g2() { k(q); }\n"
+                   "    void g3() { k(r); }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("void m(int*& r);\n"
+                   "void n(int* const& s);\n"
+                   "struct T {\n"
+                   "    int i;\n"
+                   "    int* p;\n"
+                   "    void f1() { m(p); }\n"
+                   "    void f2() { n(&i); }\n"
+                   "    void f3() { n(p); }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void const88() { // #11626
+        checkConst("struct S {\n"
+                   "    bool f() { return static_cast<bool>(p); }\n"
+                   "    const int* g() { return const_cast<const int*>(p); }\n"
+                   "    const int* h() { return (const int*)p; }\n"
+                   "    char* j() { return reinterpret_cast<char*>(p); }\n"
+                   "    char* k() { return (char*)p; }\n"
+                   "    int* p;\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:2:10]: (style, inconclusive) Technically the member function 'S::f' can be const. [functionConst]\n"
+                      "[test.cpp:3:16]: (style, inconclusive) Technically the member function 'S::g' can be const. [functionConst]\n"
+                      "[test.cpp:4:16]: (style, inconclusive) Technically the member function 'S::h' can be const. [functionConst]\n",
+                      errout_str());
+
+        checkConst("struct S {\n"
+                   "    bool f() { return p != nullptr; }\n"
+                   "    std::shared_ptr<int> p;\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:2:10]: (style, inconclusive) Technically the member function 'S::f' can be const. [functionConst]\n",
+                      errout_str());
+    }
+
+    void const89() {
+        checkConst("struct S {\n" // #11654
+                   "    void f(bool b);\n"
+                   "    int i;\n"
+                   "};\n"
+                   "void S::f(bool b) {\n"
+                   "    if (i && b)\n"
+                   "        f(false);\n"
+                   "}\n");
+        ASSERT_EQUALS("[test.cpp:2:10] -> [test.cpp:5:9]: (style, inconclusive) Technically the member function 'S::f' can be const. [functionConst]\n", errout_str());
+
+        checkConst("struct S {\n"
+                   "    void f(int& r);\n"
+                   "    int i;\n"
+                   "};\n"
+                   "void S::f(int& r) {\n"
+                   "    r = 0;\n"
+                   "    if (i)\n"
+                   "        f(i);\n"
+                   "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("struct S {\n" // #11744
+                   "    S* p;\n"
+                   "    int f() {\n"
+                   "        if (p)\n"
+                   "            return 1 + p->f();\n"
+                   "        return 1;\n"
+                   "    }\n"
+                   "    int g(int i) {\n"
+                   "        if (i > 0)\n"
+                   "            return i + g(i - 1);\n"
+                   "        return 0;\n"
+                   "    }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:3:9]: (style, inconclusive) Technically the member function 'S::f' can be const. [functionConst]\n"
+                      "[test.cpp:8:9]: (style) The member function 'S::g' can be static. [functionStatic]\n",
+                      errout_str());
+
+        checkConst("class C {\n" // #11653
+                   "public:\n"
+                   "    void f(bool b) const;\n"
+                   "};\n"
+                   "void C::f(bool b) const {\n"
+                   "    if (b)\n"
+                   "        f(false);\n"
+                   "}\n");
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:5:9]: (style) The member function 'C::f' can be static. [functionStatic]\n",
+                      errout_str());
+    }
+
+    void const90() { // #11637
+        checkConst("class S {};\n"
+                   "struct C {\n"
+                   "    C(const S*);\n"
+                   "    C(const S&);\n"
+                   "};\n"
+                   "class T {\n"
+                   "    S s;\n"
+                   "    void f1() { C c = C{ &s }; }\n"
+                   "    void f2() { C c = C{ s }; }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:8:10]: (style, inconclusive) Technically the member function 'T::f1' can be const. [functionConst]\n"
+                      "[test.cpp:9:10]: (style, inconclusive) Technically the member function 'T::f2' can be const. [functionConst]\n",
+                      errout_str());
+    }
+
+    void const91() { // #11790
+        checkConst("struct S {\n"
+                   "    char* p;\n"
+                   "    template <typename T>\n"
+                   "    T* get() {\n"
+                   "        return reinterpret_cast<T*>(p);\n"
+                   "    }\n"
+                   "};\n"
+                   "const int* f(S& s) {\n"
+                   "    return s.get<const int>();\n"
+                   "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void const92() { // #11886
+        checkConst("void g(int);\n"
+                   "template<int n>\n"
+                   "struct S : public S<n - 1> {\n"
+                   "    void f() {\n"
+                   "        g(n - 1);\n"
+                   "    }\n"
+                   "};\n"
+                   "template<>\n"
+                   "struct S<0> {};\n"
+                   "struct D : S<150> {};\n");
+        // don't hang
+        ignore_errout();
+    }
+
+    void const93() { // #12162
+        checkConst("struct S {\n"
+                   "    bool f() {\n"
+                   "        return m.cbegin()->first == 0;\n"
+                   "    }\n"
+                   "    bool g() {\n"
+                   "        return m.count(0);\n"
+                   "    }\n"
+                   "    std::map<int, int> m;\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:2:10]: (style, inconclusive) Technically the member function 'S::f' can be const. [functionConst]\n"
+                      "[test.cpp:5:10]: (style, inconclusive) Technically the member function 'S::g' can be const. [functionConst]\n",
+                      errout_str());
+    }
+
+    void const94() { // #7459
+        checkConst("class A {\n"
+                   "public:\n"
+                   "    A() : tickFunction(&A::nop) {}\n"
+                   "    void tick() { (this->*tickFunction)(); }\n"
+                   "private:\n"
+                   "    typedef void (A::* Fn)();\n"
+                   "    Fn tickFunction;\n"
+                   "    void nop() {}\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void const95() { // #13320
+        checkConst("class C {\n"
+                   "    std::string x;\n"
+                   "    std::string get() && { return x; }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void const96() {
+        checkConst("struct S : B {\n" // #13282
+                   "    bool f() { return b; }\n"
+                   "    bool g() override { return b; }\n"
+                   "    bool b;\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:2:10]: (style, inconclusive) Either there is a missing 'override', or the member function 'S::f' can be const. [functionConst]\n", errout_str());
+
+        checkConst("struct B;\n" // #13382
+                   "struct S : B {\n"
+                   "    void f();\n"
+                   "};\n"
+                   "void S::f() {\n"
+                   "    B::g(0);\n"
+                   "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("struct S {\n" // #14366
+                   "    void f();\n"
+                   "};\n"
+                   "struct T : U {\n"
+                   "    void g(S* s) {\n"
+                   "        s->f();\n"
+                   "    }\n"
+                   "    void h() {\n"
+                   "        S s;\n"
+                   "        s.f();\n"
+                   "    }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:5:10]: (style) Either there is a missing 'override', or the member function 'T::g' can be static. [functionStatic]\n"
+                      "[test.cpp:8:10]: (style) Either there is a missing 'override', or the member function 'T::h' can be static. [functionStatic]\n",
+                      errout_str());
+
+        checkConst("enum E { E0 };\n"
+                   "int f();\n"
+                   "struct S : U {\n"
+                   "    E g() {\n"
+                   "        return E0;\n"
+                   "    }\n"
+                   "    int h() {\n"
+                   "        return f();\n"
+                   "    }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:4:7]: (style) Either there is a missing 'override', or the member function 'S::g' can be static. [functionStatic]\n"
+                      "[test.cpp:7:9]: (style) Either there is a missing 'override', or the member function 'S::h' can be static. [functionStatic]\n",
+                      errout_str());
+
+        checkConst("namespace N {\n" // #14391
+                   "    void f();\n"
+                   "}\n"
+                   "struct S : U {\n"
+                   "    void g() { N::f(); }\n"
+                   "    void h() { ::N::f(); }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:5:10]: (style) Either there is a missing 'override', or the member function 'S::g' can be static. [functionStatic]\n"
+                      "[test.cpp:6:10]: (style) Either there is a missing 'override', or the member function 'S::h' can be static. [functionStatic]\n",
+                      errout_str());
+
+        checkConst("struct S : U {\n" // #14425
+                   "    void f() { this->g(); }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void const97() { // #13301
+        checkConst("struct S {\n"
+                   "    std::vector<int> v;\n"
+                   "    int f() {\n"
+                   "        const int& r = v.front();\n"
+                   "        return r;\n"
+                   "    }\n"
+                   "    int g() {\n"
+                   "        const int& r = v.at(0);\n"
+                   "        return r;\n"
+                   "    }\n"
+                   "    void h() {\n"
+                   "        if (v.front() == 0) {}\n"
+                   "        if (1 == v.front()) {}\n"
+                   "    }\n"
+                   "    void i() {\n"
+                   "        v.at(0) = 0;\n"
+                   "    }\n"
+                   "    void j() {\n"
+                   "        dostuff(1, v.at(0));\n"
+                   "    }\n"
+                   "    void k() {\n"
+                   "        int& r = v.front();\n"
+                   "        r = 0;\n"
+                   "    }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:3:9]: (style, inconclusive) Technically the member function 'S::f' can be const. [functionConst]\n"
+                      "[test.cpp:7:9]: (style, inconclusive) Technically the member function 'S::g' can be const. [functionConst]\n"
+                      "[test.cpp:11:10]: (style, inconclusive) Technically the member function 'S::h' can be const. [functionConst]\n",
+                      errout_str());
+
+        checkConst("struct B { std::string s; };\n"
+                   "struct D : B {\n"
+                   "    bool f(std::string::iterator it) { return it == B::s.begin(); }\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Technically the member function 'D::f' can be const. [functionConst]\n",
+                      errout_str());
+
+        checkConst("int g(int);\n" // #12162
+                   "struct S {\n"
+                   "    bool has(int i) { return m.find(i) != m.end(); }\n"
+                   "    bool isZero(int i) { return m.at(i) == 0; }\n"
+                   "    bool isZero() { return v.front() == 0; }\n"
+                   "    void f() { g(v.front() + 1); }\n"
+                   "    void set(int i) { m.at(i) = 0; }\n"
+                   "    std::map<int, int> m;\n"
+                   "    std::vector<int> v;\n"
+                   "};\n");
+        ASSERT_EQUALS("[test.cpp:3:10]: (style, inconclusive) Technically the member function 'S::has' can be const. [functionConst]\n"
+                      "[test.cpp:4:10]: (style, inconclusive) Technically the member function 'S::isZero' can be const. [functionConst]\n"
+                      "[test.cpp:5:10]: (style, inconclusive) Technically the member function 'S::isZero' can be const. [functionConst]\n"
+                      "[test.cpp:6:10]: (style, inconclusive) Technically the member function 'S::f' can be const. [functionConst]\n",
+                      errout_str());
+    }
+
+    void const98() { // #13642
+        checkConst("enum E {\n"
+                   "    E0,\n"
+                   "    E1\n"
+                   "};\n"
+                   "void set(int* p) {\n"
+                   "    *p = 1;\n"
+                   "}\n"
+                   "struct S {\n"
+                   "    E e;\n"
+                   "    void f() {\n"
+                   "        set(reinterpret_cast<int*>(&e));\n"
+                   "    }\n"
+                   "    void g() {\n"
+                   "        set(reinterpret_cast<int*>(reinterpret_cast<void*>(&e)));\n"
+                   "    }\n"
+                   "    void h() {\n"
+                   "        set((int*)(&e));\n"
+                   "    }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("enum E {\n"
+                   "    E0,\n"
+                   "    E1\n"
+                   "};\n"
+                   "void set1(int i, int* p) {\n"
+                   "    *p = i;\n"
+                   "}\n"
+                   "void set2(int* p, int i) {\n"
+                   "    *p = i;\n"
+                   "}\n"
+                   "struct S {\n"
+                   "    E e;\n"
+                   "    void f1() {\n"
+                   "        set1(1, reinterpret_cast<int*>(&e));\n"
+                   "    }\n"
+                   "    void f2() {\n"
+                   "        set2(reinterpret_cast<int*>(&e), 1);\n"
+                   "    }\n"
+                   "    void g1() {\n"
+                   "        set1(1, reinterpret_cast<int*>(reinterpret_cast<void*>(&e)));\n"
+                   "    }\n"
+                   "    void g2() {\n"
+                   "        set2(reinterpret_cast<int*>(reinterpret_cast<void*>(&e)), 1);\n"
+                   "    }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void const99() {
+        checkConst("typedef void (*InitFunc)(void**);\n" // #13953
+                   "struct S {\n"
+                   "    int *m;\n"
+                   "    void f(InitFunc func) {\n"
+                   "        func(reinterpret_cast<void**>(&m));\n"
+                   "    }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void const100() {
+        checkConst("struct S {\n" // #14023
+                   "    void f() { ++i; }\n"
+                   "    void f() const {}\n"
+                   "    int i;\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("struct S {\n" // #14033
+                   "    void f();\n"
+                   "    void f() const {}\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str()); // don't crash
+    }
+
+    void const_handleDefaultParameters() {
+        checkConst("struct Foo {\n"
+                   "    void foo1(int i, int j = 0) {\n"
+                   "        return func(this);\n"
+                   "    }\n"
+                   "    int bar1() {\n"
+                   "        return foo1(1);\n"
+                   "    }\n"
+                   "    int bar2() {\n"
+                   "        return foo1(1, 2);\n"
+                   "    }\n"
+                   "    int bar3() {\n"
+                   "        return foo1(1, 2, 3);\n"
+                   "    }\n"
+                   "    int bar4() {\n"
+                   "        return foo1();\n"
+                   "    }\n"
+                   "    void foo2(int i = 0) {\n"
+                   "        return func(this);\n"
+                   "    }\n"
+                   "    int bar5() {\n"
+                   "        return foo2();\n"
+                   "    }\n"
+                   "    void foo3() {\n"
+                   "        return func(this);\n"
+                   "    }\n"
+                   "    int bar6() {\n"
+                   "        return foo3();\n"
+                   "    }\n"
+                   "};");
+        ASSERT_EQUALS("[test.cpp:11:9]: (style) The member function 'Foo::bar3' can be static. [functionStatic]\n"
+                      "[test.cpp:14:9]: (style) The member function 'Foo::bar4' can be static. [functionStatic]\n", errout_str());
+    }
+
+    void const_passThisToMemberOfOtherClass() {
+        checkConst("struct Foo {\n"
+                   "    void foo() {\n"
+                   "        Bar b;\n"
+                   "        b.takeFoo(this);\n"
+                   "    }\n"
+                   "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("struct Foo {\n"
+                   "    void foo() {\n"
+                   "        Foo f;\n"
+                   "        f.foo();\n"
+                   "    }\n"
+                   "};");
+        ASSERT_EQUALS("[test.cpp:2:10]: (style) The member function 'Foo::foo' can be static. [functionStatic]\n", errout_str());
+
+        checkConst("struct A;\n" // #5839 - operator()
+                   "struct B {\n"
+                   "    void operator()(A *a);\n"
+                   "};\n"
+                   "struct A {\n"
+                   "    void dostuff() {\n"
+                   "        B()(this);\n"
+                   "    }\n"
+                   "};");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void assigningPointerToPointerIsNotAConstOperation() {
+        checkConst("struct s\n"
+                   "{\n"
+                   "    int** v;\n"
+                   "    void f()\n"
+                   "    {\n"
+                   "        v = 0;\n"
+                   "    }\n"
+                   "};");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void assigningArrayElementIsNotAConstOperation() {
+        checkConst("struct s\n"
+                   "{\n"
+                   "    ::std::string v[3];\n"
+                   "    void f()\n"
+                   "    {\n"
+                   "        v[0] = \"Happy new year!\";\n"
+                   "    }\n"
+                   "};");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // increment/decrement => not const
+    void constincdec() {
+        checkConst("class Fred {\n"
+                   "    int a;\n"
+                   "    void nextA() { return ++a; }\n"
+                   "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("class Fred {\n"
+                   "    int a;\n"
+                   "    void nextA() { return --a; }\n"
+                   "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("class Fred {\n"
+                   "    int a;\n"
+                   "    void nextA() { return a++; }\n"
+                   "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("class Fred {\n"
+                   "    int a;\n"
+                   "    void nextA() { return a--; }\n"
+                   "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("int a;\n"
+                   "class Fred {\n"
+                   "    void nextA() { return ++a; }\n"
+                   "};");
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
+
+        checkConst("int a;\n"
+                   "class Fred {\n"
+                   "    void nextA() { return --a; }\n"
+                   "};");
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
+
+        checkConst("int a;\n"
+                   "class Fred {\n"
+                   "    void nextA() { return a++; }\n"
+                   "};");
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
+
+        checkConst("int a;\n"
+                   "class Fred {\n"
+                   "    void nextA() { return a--; }\n"
+                   "};");
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
+
+        checkConst("struct S {\n" // #10077
+                   "    int i{};\n"
+                   "    S& operator ++() { ++i; return *this; }\n"
+                   "    S operator ++(int) { S s = *this; ++(*this); return s; }\n"
+                   "    void f() { (*this)--; }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void constassign1() {
+        checkConst("class Fred {\n"
+                   "    int a;\n"
+                   "    void nextA() { return a=1; }\n"
+                   "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("class Fred {\n"
+                   "    int a;\n"
+                   "    void nextA() { return a-=1; }\n"
+                   "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("class Fred {\n"
+                   "    int a;\n"
+                   "    void nextA() { return a+=1; }\n"
+                   "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("class Fred {\n"
+                   "    int a;\n"
+                   "    void nextA() { return a*=-1; }\n"
+                   "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("class Fred {\n"
+                   "    int a;\n"
+                   "    void nextA() { return a/=-2; }\n"
+                   "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("int a;\n"
+                   "class Fred {\n"
+                   "    void nextA() { return a=1; }\n"
+                   "};");
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
+
+        checkConst("int a;\n"
+                   "class Fred {\n"
+                   "    void nextA() { return a-=1; }\n"
+                   "};");
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
+
+        checkConst("int a;\n"
+                   "class Fred {\n"
+                   "    void nextA() { return a+=1; }\n"
+                   "};");
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
+
+        checkConst("int a;\n"
+                   "class Fred {\n"
+                   "    void nextA() { return a*=-1; }\n"
+                   "};");
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
+
+        checkConst("int a;\n"
+                   "class Fred {\n"
+                   "    void nextA() { return a/=-2; }\n"
+                   "};");
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
+    }
+
+    void constassign2() {
+        checkConst("class Fred {\n"
+                   "    struct A { int a; } s;\n"
+                   "    void nextA() { return s.a=1; }\n"
+                   "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkConst("class Fred {\n"
+                   "    struct A { int a; } s;\n"
+                   "    void nextA() { return s.a-=1; }\n"
+                   "};");
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    struct A { int a; } s;\n"
                    "    void nextA() { return s.a+=1; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    struct A { int a; } s;\n"
                    "    void nextA() { return s.a*=-1; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("struct A { int a; } s;\n"
                    "class Fred {\n"
                    "    void nextA() { return s.a=1; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("struct A { int a; } s;\n"
                    "class Fred {\n"
                    "    void nextA() { return s.a-=1; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("struct A { int a; } s;\n"
                    "class Fred {\n"
                    "    void nextA() { return s.a+=1; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("struct A { int a; } s;\n"
                    "class Fred {\n"
                    "    void nextA() { return s.a*=-1; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("struct A { int a; } s;\n"
                    "class Fred {\n"
                    "    void nextA() { return s.a/=-2; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("struct A { int a; };\n"
                    "class Fred {\n"
                    "    A s;\n"
                    "    void nextA() { return s.a=1; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("struct A { int a; };\n"
                    "class Fred {\n"
                    "    A s;\n"
                    "    void nextA() { return s.a-=1; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("struct A { int a; };\n"
                    "class Fred {\n"
                    "    A s;\n"
                    "    void nextA() { return s.a+=1; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("struct A { int a; };\n"
                    "class Fred {\n"
                    "    A s;\n"
                    "    void nextA() { return s.a*=-1; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("struct A { int a; };\n"
                    "class Fred {\n"
                    "    A s;\n"
                    "    void nextA() { return s.a/=-2; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // increment/decrement array element => not const
@@ -5977,49 +7277,49 @@ class TestClass : public TestFixture {
                    "    int a[2];\n"
                    "    void nextA() { return ++a[0]; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a[2];\n"
                    "    void nextA() { return --a[0]; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a[2];\n"
                    "    void nextA() { return a[0]++; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a[2];\n"
                    "    void nextA() { return a[0]--; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("int a[2];\n"
                    "class Fred {\n"
                    "    void nextA() { return ++a[0]; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a[2];\n"
                    "class Fred {\n"
                    "    void nextA() { return --a[0]; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a[2];\n"
                    "class Fred {\n"
                    "    void nextA() { return a[0]++; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a[2];\n"
                    "class Fred {\n"
                    "    void nextA() { return a[0]--; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
     }
 
     void constassignarray() {
@@ -6027,61 +7327,61 @@ class TestClass : public TestFixture {
                    "    int a[2];\n"
                    "    void nextA() { return a[0]=1; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a[2];\n"
                    "    void nextA() { return a[0]-=1; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a[2];\n"
                    "    void nextA() { return a[0]+=1; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a[2];\n"
                    "    void nextA() { return a[0]*=-1; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class Fred {\n"
                    "    int a[2];\n"
                    "    void nextA() { return a[0]/=-2; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("int a[2];\n"
                    "class Fred {\n"
                    "    void nextA() { return a[0]=1; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a[2];\n"
                    "class Fred {\n"
                    "    void nextA() { return a[0]-=1; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a[2];\n"
                    "class Fred {\n"
                    "    void nextA() { return a[0]+=1; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a[2];\n"
                    "class Fred {\n"
                    "    void nextA() { return a[0]*=-1; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
 
         checkConst("int a[2];\n"
                    "class Fred {\n"
                    "    void nextA() { return a[0]/=-2; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'Fred::nextA' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'Fred::nextA' can be static. [functionStatic]\n", errout_str());
     }
 
     // return pointer/reference => not const
@@ -6091,7 +7391,7 @@ class TestClass : public TestFixture {
                    "    int &getR() { return a; }\n"
                    "    int *getP() { return &a; }"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // delete member variable => not const (but technically it can, it compiles without errors)
@@ -6100,7 +7400,7 @@ class TestClass : public TestFixture {
                    "    int *a;\n"
                    "    void clean() { delete a; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // A function that returns unknown types can't be const (#1579)
@@ -6108,14 +7408,14 @@ class TestClass : public TestFixture {
         checkConst("class Fred {\n"
                    "    UNKNOWN a() { return 0; };\n"
                    "};");
-        TODO_ASSERT_EQUALS("[test.cpp:2]: (performance, inconclusive) Technically the member function 'Fred::a' can be static.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:2]: (style) The member function 'Fred::a' can be static.\n", "", errout_str());
 
         // #1579 - HDC
         checkConst("class Fred {\n"
                    "    foo bar;\n"
                    "    UNKNOWN a() { return b; };\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // a function that calls const functions can be const
@@ -6124,8 +7424,8 @@ class TestClass : public TestFixture {
                    "    void f() const { };\n"
                    "    void a() { f(); };\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:2]: (performance, inconclusive) Technically the member function 'Fred::f' can be static (but you may consider moving to unnamed namespace).\n"
-                      "[test.cpp:3]: (style, inconclusive) Technically the member function 'Fred::a' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (style) The member function 'Fred::f' can be static. [functionStatic]\n"
+                      "[test.cpp:3:10]: (style, inconclusive) Technically the member function 'Fred::a' can be const. [functionConst]\n", errout_str());
 
         // ticket #1593
         checkConst("class A\n"
@@ -6135,7 +7435,7 @@ class TestClass : public TestFixture {
                    "   A(){}\n"
                    "   unsigned int GetVecSize()  {return m_v.size();}\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:6]: (style, inconclusive) Technically the member function 'A::GetVecSize' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:17]: (style, inconclusive) Technically the member function 'A::GetVecSize' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A\n"
                    "{\n"
@@ -6144,7 +7444,7 @@ class TestClass : public TestFixture {
                    "   A(){}\n"
                    "   bool GetVecEmpty()  {return m_v.empty();}\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:6]: (style, inconclusive) Technically the member function 'A::GetVecEmpty' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:9]: (style, inconclusive) Technically the member function 'A::GetVecEmpty' can be const. [functionConst]\n", errout_str());
     }
 
     void constVirtualFunc() {
@@ -6156,7 +7456,7 @@ class TestClass : public TestFixture {
                    "   B() : b(0) { }\n"
                    "   int func() { return b; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:6]: (style, inconclusive) Technically the member function 'B::func' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:8]: (style, inconclusive) Technically the member function 'B::func' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A { };\n"
                    "class B : public A {\n"
@@ -6166,7 +7466,7 @@ class TestClass : public TestFixture {
                    "   int func();\n"
                    "};\n"
                    "int B::func() { return b; }");
-        ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:6]: (style, inconclusive) Technically the member function 'B::func' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:8] -> [test.cpp:8:8]: (style, inconclusive) Technically the member function 'B::func' can be const. [functionConst]\n", errout_str());
 
         // base class has no virtual function
         checkConst("class A {\n"
@@ -6179,7 +7479,7 @@ class TestClass : public TestFixture {
                    "    B() : b(0) { }\n"
                    "    int func() { return b; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:9]: (style, inconclusive) Technically the member function 'B::func' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:9]: (style, inconclusive) Technically the member function 'B::func' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
                    "public:\n"
@@ -6192,7 +7492,7 @@ class TestClass : public TestFixture {
                    "    int func();\n"
                    "};\n"
                    "int B::func() { return b; }");
-        ASSERT_EQUALS("[test.cpp:11] -> [test.cpp:9]: (style, inconclusive) Technically the member function 'B::func' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:9] -> [test.cpp:11:8]: (style, inconclusive) Technically the member function 'B::func' can be const. [functionConst]\n", errout_str());
 
         // base class has virtual function
         checkConst("class A {\n"
@@ -6205,7 +7505,7 @@ class TestClass : public TestFixture {
                    "    B() : b(0) { }\n"
                    "    int func() { return b; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class A {\n"
                    "public:\n"
@@ -6218,7 +7518,7 @@ class TestClass : public TestFixture {
                    "    int func();\n"
                    "};\n"
                    "int B::func() { return b; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class A {\n"
                    "public:\n"
@@ -6231,7 +7531,7 @@ class TestClass : public TestFixture {
                    "    int func();\n"
                    "};\n"
                    "int B::func() { return b; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // base class has no virtual function
         checkConst("class A {\n"
@@ -6252,9 +7552,9 @@ class TestClass : public TestFixture {
                    "    C() : c(0) { }\n"
                    "    int func() { return c; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:5]: (style, inconclusive) Technically the member function 'A::func' can be const.\n"
-                      "[test.cpp:11]: (style, inconclusive) Technically the member function 'B::func' can be const.\n"
-                      "[test.cpp:17]: (style, inconclusive) Technically the member function 'C::func' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9]: (style, inconclusive) Technically the member function 'A::func' can be const. [functionConst]\n"
+                      "[test.cpp:11:9]: (style, inconclusive) Technically the member function 'B::func' can be const. [functionConst]\n"
+                      "[test.cpp:17:9]: (style, inconclusive) Technically the member function 'C::func' can be const. [functionConst]\n", errout_str());
 
         checkConst("class A {\n"
                    "    int a;\n"
@@ -6277,9 +7577,9 @@ class TestClass : public TestFixture {
                    "    int func();\n"
                    "};\n"
                    "int C::func() { return c; }");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:5]: (style, inconclusive) Technically the member function 'A::func' can be const.\n"
-                      "[test.cpp:14] -> [test.cpp:12]: (style, inconclusive) Technically the member function 'B::func' can be const.\n"
-                      "[test.cpp:21] -> [test.cpp:19]: (style, inconclusive) Technically the member function 'C::func' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:7:8]: (style, inconclusive) Technically the member function 'A::func' can be const. [functionConst]\n"
+                      "[test.cpp:12:9] -> [test.cpp:14:8]: (style, inconclusive) Technically the member function 'B::func' can be const. [functionConst]\n"
+                      "[test.cpp:19:9] -> [test.cpp:21:8]: (style, inconclusive) Technically the member function 'C::func' can be const. [functionConst]\n", errout_str());
 
         // base class has virtual function
         checkConst("class A {\n"
@@ -6300,7 +7600,7 @@ class TestClass : public TestFixture {
                    "    C() : c(0) { }\n"
                    "    int func() { return c; }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkConst("class A {\n"
                    "    int a;\n"
@@ -6323,7 +7623,7 @@ class TestClass : public TestFixture {
                    "    int func();\n"
                    "};\n"
                    "int C::func() { return c; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ticket #1311
         checkConst("class X {\n"
@@ -6344,9 +7644,9 @@ class TestClass : public TestFixture {
                    "    Z(int x, int y, int z) : Y(x, y), z(z) { }\n"
                    "    int getZ() { return z; }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:5]: (style, inconclusive) Technically the member function 'X::getX' can be const.\n"
-                      "[test.cpp:11]: (style, inconclusive) Technically the member function 'Y::getY' can be const.\n"
-                      "[test.cpp:17]: (style, inconclusive) Technically the member function 'Z::getZ' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9]: (style, inconclusive) Technically the member function 'X::getX' can be const. [functionConst]\n"
+                      "[test.cpp:11:9]: (style, inconclusive) Technically the member function 'Y::getY' can be const. [functionConst]\n"
+                      "[test.cpp:17:9]: (style, inconclusive) Technically the member function 'Z::getZ' can be const. [functionConst]\n", errout_str());
 
         checkConst("class X {\n"
                    "    int x;\n"
@@ -6369,9 +7669,9 @@ class TestClass : public TestFixture {
                    "    int getZ();\n"
                    "};\n"
                    "int Z::getZ() { return z; }");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:5]: (style, inconclusive) Technically the member function 'X::getX' can be const.\n"
-                      "[test.cpp:14] -> [test.cpp:12]: (style, inconclusive) Technically the member function 'Y::getY' can be const.\n"
-                      "[test.cpp:21] -> [test.cpp:19]: (style, inconclusive) Technically the member function 'Z::getZ' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:7:8]: (style, inconclusive) Technically the member function 'X::getX' can be const. [functionConst]\n"
+                      "[test.cpp:12:9] -> [test.cpp:14:8]: (style, inconclusive) Technically the member function 'Y::getY' can be const. [functionConst]\n"
+                      "[test.cpp:19:9] -> [test.cpp:21:8]: (style, inconclusive) Technically the member function 'Z::getZ' can be const. [functionConst]\n", errout_str());
     }
 
     void constIfCfg() {
@@ -6384,11 +7684,11 @@ class TestClass : public TestFixture {
                             "    }\n"
                             "};";
 
-        checkConst(code, &settings0, true);
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Technically the member function 'foo::f' can be static (but you may consider moving to unnamed namespace).\n", errout.str());
+        checkConst(code);
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'foo::f' can be static. [functionStatic]\n", errout_str());
 
-        checkConst(code, &settings0, false); // TODO: Set inconclusive to true (preprocess it)
-        ASSERT_EQUALS("", errout.str());
+        checkConst(code, dinit(CheckConstOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The member function 'foo::f' can be static. [functionStatic]\n", errout_str());
     }
 
     void constFriend() { // ticket #1921
@@ -6396,7 +7696,7 @@ class TestClass : public TestFixture {
                             "    friend void f() { }\n"
                             "};";
         checkConst(code);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void constUnion() { // ticket #2111
@@ -6410,7 +7710,7 @@ class TestClass : public TestFixture {
                    "        d.f = x;\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void constArrayOperator() {
@@ -6427,7 +7727,7 @@ class TestClass : public TestFixture {
                    "        return y[1][6];\n"
                    "    }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:10]: (style, inconclusive) Technically the member function 'foo::c' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:7]: (style, inconclusive) Technically the member function 'foo::c' can be const. [functionConst]\n", errout_str());
     }
 
     void constRangeBasedFor() { // #5514
@@ -6442,8 +7742,25 @@ class TestClass : public TestFixture {
                    "        for (const auto & e : array)\n"
                    "            foo(e);\n"
                    "    }\n"
+                   "    void f3() {\n"
+                   "        for (decltype(auto) e : array)\n"
+                   "            foo(e);\n"
+                   "    }\n"
                    "};");
-        ASSERT_EQUALS("[test.cpp:8]: (style, inconclusive) Technically the member function 'Fred::f2' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:10]: (style, inconclusive) Technically the member function 'Fred::f2' can be const. [functionConst]\n", errout_str());
+
+        checkConst("struct T {\n" // #14390
+                   "    std::vector<int*> v;\n"
+                   "    void f() {\n"
+                   "        for (const auto& p : v)\n"
+                   "            *p = 0;\n"
+                   "    }\n"
+                   "    void g() {\n"
+                   "        for (auto* p : v)\n"
+                   "            *p = 0;\n"
+                   "    }\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void const_shared_ptr() { // #8674
@@ -6455,7 +7772,7 @@ class TestClass : public TestFixture {
                    "};\n"
                    "\n"
                    "std::shared_ptr<Data> Fred::getData() { return data; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void constPtrToConstPtr() {
@@ -6463,23 +7780,64 @@ class TestClass : public TestFixture {
                    "public:\n"
                    "    const char *const *data;\n"
                    "    const char *const *getData() { return data; }\n}");
-        ASSERT_EQUALS("[test.cpp:4]: (style, inconclusive) Technically the member function 'Fred::getData' can be const.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:24]: (style, inconclusive) Technically the member function 'Fred::getData' can be const. [functionConst]\n", errout_str());
     }
 
-    void checkInitializerListOrder(const char code[]) {
-        // Clear the error log
-        errout.str("");
+    void constTrailingReturnType() { // #9814
+        checkConst("struct A {\n"
+                   "    int x = 1;\n"
+                   "    auto get() -> int & { return x; }\n"
+                   "};");
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        // Check..
-        settings0.inconclusive = true;
+    void constRefQualified() { // #12920
+        checkConst("class Fred {\n"
+                   "public:\n"
+                   "    const Data& get() & { return data; }\n"
+                   "private:\n"
+                   "    Data data;\n"
+                   "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void staticArrayPtrOverload() {
+        checkConst("struct S {\n"
+                   "    template<size_t N>\n"
+                   "    void f(const std::array<std::string_view, N>& sv);\n"
+                   "    template<long N>\n"
+                   "    void f(const char* const (&StrArr)[N]);\n"
+                   "};\n"
+                   "template<size_t N>\n"
+                   "void S::f(const std::array<std::string_view, N>& sv) {\n"
+                   "    const char* ptrs[N]{};\n"
+                   "    return f(ptrs);\n"
+                   "}\n"
+                   "template void S::f(const std::array<std::string_view, 3>& sv);\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void qualifiedNameMember() { // #10872
+        const Settings s = settingsBuilder().severity(Severity::style).debugwarnings().library("std.cfg").certainty(Certainty::inconclusive).build();
+        checkConst("struct data {};\n"
+                   "    struct S {\n"
+                   "    std::vector<data> std;\n"
+                   "    void f();\n"
+                   "};\n"
+                   "void S::f() {\n"
+                   "    std::vector<data>::const_iterator end = std.end();\n"
+                   "}\n", s);
+        ASSERT_EQUALS("[test.cpp:4:10] -> [test.cpp:6:9]: (style, inconclusive) Technically the member function 'S::f' can be const. [functionConst]\n", errout_str());
+    }
 
+#define checkInitializerListOrder(...) checkInitializerListOrder_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkInitializerListOrder_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        tokenizer.simplifyTokenList2();
+        SimpleTokenizer tokenizer(settings2, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
-        CheckClass checkClass(&tokenizer, &settings0, this);
+        CheckClass checkClass(&tokenizer, &settings2, this);
         checkClass.initializerListOrder();
     }
 
@@ -6489,31 +7847,149 @@ class TestClass : public TestFixture {
                                   "public:\n"
                                   "    Fred() : c(0), b(0), a(0) { }\n"
                                   "};");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:2]: (style, inconclusive) Member variable 'Fred::b' is in the wrong place in the initializer list.\n"
-                      "[test.cpp:4] -> [test.cpp:2]: (style, inconclusive) Member variable 'Fred::a' is in the wrong place in the initializer list.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:20] -> [test.cpp:2:12]: (style, inconclusive) Member variable 'Fred::b' is in the wrong place in the initializer list. [initializerList]\n"
+                      "[test.cpp:4:26] -> [test.cpp:2:9]: (style, inconclusive) Member variable 'Fred::a' is in the wrong place in the initializer list. [initializerList]\n", errout_str());
 
         checkInitializerListOrder("class Fred {\n"
                                   "    int a, b, c;\n"
                                   "public:\n"
                                   "    Fred() : c{0}, b{0}, a{0} { }\n"
                                   "};");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:2]: (style, inconclusive) Member variable 'Fred::b' is in the wrong place in the initializer list.\n"
-                      "[test.cpp:4] -> [test.cpp:2]: (style, inconclusive) Member variable 'Fred::a' is in the wrong place in the initializer list.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:20] -> [test.cpp:2:12]: (style, inconclusive) Member variable 'Fred::b' is in the wrong place in the initializer list. [initializerList]\n"
+                      "[test.cpp:4:26] -> [test.cpp:2:9]: (style, inconclusive) Member variable 'Fred::a' is in the wrong place in the initializer list. [initializerList]\n", errout_str());
+
+        checkInitializerListOrder("struct S {\n"
+                                  "    S() : b(a = 1) {}\n"
+                                  "    int a, b;\n"
+                                  "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkInitializerListOrder("struct S {\n"
+                                  "    int nCols() const;\n"
+                                  "    int nRows() const;\n"
+                                  "};\n"
+                                  "struct B {\n"
+                                  "    const char* m_name;\n"
+                                  "    int nCols;\n"
+                                  "    int nRows;\n"
+                                  "    B(const char* p_name, int nR, int nC)\n"
+                                  "        : m_name(p_name)\n"
+                                  "        , nCols(nC)\n"
+                                  "        , nRows(nR)\n"
+                                  "    {}\n"
+                                  "};\n"
+                                  "struct D : public B {\n"
+                                  "    const int  m_i;\n"
+                                  "    D(const S& s, int _i)\n"
+                                  "        : B(\"abc\", s.nRows(), s.nCols())\n"
+                                  "        , m_i(_i)\n"
+                                  "    {}\n"
+                                  "};");
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void checkInitializationListUsage(const char code[]) {
-        // Clear the error log
-        errout.str("");
+    void initializerListArgument() {
+        checkInitializerListOrder("struct A { A(); };\n" // #12322
+                                  "struct B { explicit B(const A* a); };\n"
+                                  "struct C {\n"
+                                  "    C() : b(&a) {}\n"
+                                  "    B b;\n"
+                                  "    const A a;\n"
+                                  "};");
+        ASSERT_EQUALS("[test.cpp:4:11] -> [test.cpp:5:7]: (style, inconclusive) Member variable 'C::b' uses an uninitialized argument 'a' due to the order of declarations. [initializerList]\n",
+                      errout_str());
+
+        checkInitializerListOrder("struct S {\n"
+                                  "    S(const std::string& f, std::string i, int b, int c) : a(0), b(b), c(c) {}\n"
+                                  "    int a, b, c;\n"
+                                  "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkInitializerListOrder("struct S {\n"
+                                  "    S() : p(a) {}\n"
+                                  "    int* p;\n"
+                                  "    int a[1];\n"
+                                  "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkInitializerListOrder("struct S {\n"
+                                  "    S() : p(&i) {}\n"
+                                  "    int* p;\n"
+                                  "    int i;\n"
+                                  "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkInitializerListOrder("struct S {\n"
+                                  "    S() : a(b = 1) {}\n"
+                                  "    int a, b;\n"
+                                  "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkInitializerListOrder("struct S {\n"
+                                  "    S() : r(i) {}\n"
+                                  "    int& r;\n"
+                                  "    int i{};\n"
+                                  "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkInitializerListOrder("struct B {\n"
+                                  "    int a{}, b{};\n"
+                                  "};\n"
+                                  "struct D : B {\n"
+                                  "    D() : B(), j(b) {}\n"
+                                  "    int j;\n"
+                                  "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkInitializerListOrder("struct S {\n"
+                                  "    S() : a(i) {}\n"
+                                  "    int a;\n"
+                                  "    static int i;\n"
+                                  "};\n"
+                                  "int S::i = 0;");
+        ASSERT_EQUALS("", errout_str());
+
+        checkInitializerListOrder("struct S {\n"
+                                  "    S(int b) : a(b) {}\n"
+                                  "    int a, b{};\n"
+                                  "};");
+        ASSERT_EQUALS("", errout_str());
 
+        checkInitializerListOrder("class Foo {\n" // #3524
+                                  "public:\n"
+                                  "    Foo(int arg) : a(b), b(arg) {}\n"
+                                  "    int a;\n"
+                                  "    int b;\n"
+                                  "};\n");
+        ASSERT_EQUALS("[test.cpp:3:20] -> [test.cpp:4:9]: (style, inconclusive) Member variable 'Foo::a' uses an uninitialized argument 'b' due to the order of declarations. [initializerList]\n",
+                      errout_str());
+
+        checkInitializerListOrder("struct S { double d = 0; };\n" // #12730
+                                  "struct T {\n"
+                                  "    T() : s(), a(s.d), d(0) {}\n"
+                                  "    S s;\n"
+                                  "    double a, d;\n"
+                                  "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkInitializerListOrder("struct S { static const int d = 1; };\n"
+                                  "struct T {\n"
+                                  "    T() : s(), a(S::d), d(0) {}\n"
+                                  "    S s;\n"
+                                  "    int a, d;\n"
+                                  "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+#define checkInitializationListUsage(...) checkInitializationListUsage_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkInitializationListUsage_(const char* file, int line, const char (&code)[size]) {
         // Check..
-        Settings settings;
-        settings.addEnabled("performance");
+        const Settings settings = settingsBuilder().severity(Severity::performance).build();
 
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        tokenizer.simplifyTokenList2();
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         CheckClass checkClass(&tokenizer, &settings, this);
         checkClass.initializationListUsage();
@@ -6527,113 +8003,113 @@ class TestClass : public TestFixture {
                                      "    Enum c;\n" // No message for enums: No performance gain
                                      "    Fred() { a = 0; b = 0; c = C; }\n"
                                      "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class Fred {\n"
                                      "    std::string s;\n"
                                      "    Fred() { a = 0; s = \"foo\"; }\n"
                                      "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Variable 's' is assigned in constructor body. Consider performing initialization in initialization list.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:21]: (performance) Variable 's' is assigned in constructor body. Consider performing initialization in initialization list. [useInitializationList]\n", errout_str());
 
         checkInitializationListUsage("class Fred {\n"
                                      "    std::string& s;\n" // Message is invalid for references, since their initialization in initializer list is required anyway and behaves different from assignment (#5004)
                                      "    Fred(const std::string& s_) : s(s_) { s = \"foo\"; }\n"
                                      "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class Fred {\n"
                                      "    std::vector<int> v;\n"
                                      "    Fred() { v = unknown; }\n"
                                      "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Variable 'v' is assigned in constructor body. Consider performing initialization in initialization list.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:14]: (performance) Variable 'v' is assigned in constructor body. Consider performing initialization in initialization list. [useInitializationList]\n", errout_str());
 
         checkInitializationListUsage("class C { std::string s; };\n"
                                      "class Fred {\n"
                                      "    C c;\n"
                                      "    Fred() { c = unknown; }\n"
                                      "};");
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Variable 'c' is assigned in constructor body. Consider performing initialization in initialization list.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:14]: (performance) Variable 'c' is assigned in constructor body. Consider performing initialization in initialization list. [useInitializationList]\n", errout_str());
 
         checkInitializationListUsage("class C;\n"
                                      "class Fred {\n"
                                      "    C c;\n"
                                      "    Fred() { c = unknown; }\n"
                                      "};");
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Variable 'c' is assigned in constructor body. Consider performing initialization in initialization list.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:14]: (performance) Variable 'c' is assigned in constructor body. Consider performing initialization in initialization list. [useInitializationList]\n", errout_str());
 
         checkInitializationListUsage("class C;\n"
                                      "class Fred {\n"
                                      "    C c;\n"
                                      "    Fred(Fred const & other) { c = other.c; }\n"
                                      "};");
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Variable 'c' is assigned in constructor body. Consider performing initialization in initialization list.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:32]: (performance) Variable 'c' is assigned in constructor body. Consider performing initialization in initialization list. [useInitializationList]\n", errout_str());
 
         checkInitializationListUsage("class C;\n"
                                      "class Fred {\n"
                                      "    C c;\n"
                                      "    Fred(Fred && other) { c = other.c; }\n"
                                      "};");
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Variable 'c' is assigned in constructor body. Consider performing initialization in initialization list.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:27]: (performance) Variable 'c' is assigned in constructor body. Consider performing initialization in initialization list. [useInitializationList]\n", errout_str());
 
         checkInitializationListUsage("class C;\n"
                                      "class Fred {\n"
                                      "    C a;\n"
                                      "    Fred() { initB(); a = b; }\n"
                                      "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class C;\n"
                                      "class Fred {\n"
                                      "    C a;\n"
                                      "    Fred() : a(0) { if(b) a = 0; }\n"
                                      "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class C;\n"
                                      "class Fred {\n"
                                      "    C a[5];\n"
                                      "    Fred() { for(int i = 0; i < 5; i++) a[i] = 0; }\n"
                                      "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class C;\n"
                                      "class Fred {\n"
                                      "    C a; int b;\n"
                                      "    Fred() : b(5) { a = b; }\n" // Don't issue a message here: You actually could move it to the initialization list, but it would cause problems if you change the order of the variable declarations.
                                      "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class C;\n"
                                      "class Fred {\n"
                                      "    C a;\n"
                                      "    Fred() { try { a = new int; } catch(...) {} }\n"
                                      "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class Fred {\n"
                                      "    std::string s;\n"
                                      "    Fred() { s = toString((size_t)this); }\n"
                                      "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class Fred {\n"
                                      "    std::string a;\n"
                                      "    std::string foo();\n"
                                      "    Fred() { a = foo(); }\n"
                                      "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class Fred {\n"
                                      "    std::string a;\n"
                                      "    Fred() { a = foo(); }\n"
                                      "};");
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Variable 'a' is assigned in constructor body. Consider performing initialization in initialization list.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:14]: (performance) Variable 'a' is assigned in constructor body. Consider performing initialization in initialization list. [useInitializationList]\n", errout_str());
 
         checkInitializationListUsage("class Fred {\n" // #4332
                                      "    static std::string s;\n"
                                      "    Fred() { s = \"foo\"; }\n"
                                      "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class Fred {\n" // #5640
                                      "    std::string s;\n"
@@ -6644,7 +8120,7 @@ class TestClass : public TestFixture {
                                      "        s = str;\n"
                                      "    }\n"
                                      "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class B {\n" // #5640
                                      "    std::shared_ptr<A> _d;\n"
@@ -6652,7 +8128,7 @@ class TestClass : public TestFixture {
                                      "        *_d = *other._d;\n"
                                      "    }\n"
                                      "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class Bar {\n" // #8466
                                      "public:\n"
@@ -6661,7 +8137,7 @@ class TestClass : public TestFixture {
                                      "private:\n"
                                      "    char s;\n"
                                      "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("unsigned bar(std::string);\n" // #8291
                                      "class Foo {\n"
@@ -6670,7 +8146,7 @@ class TestClass : public TestFixture {
                                      "    Foo(int a, int b) : a_(a), b_(b) {}\n"
                                      "    Foo(int a, const std::string& b) : Foo(a, bar(b)) {}\n"
                                      "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkInitializationListUsage("class Fred {\n" // #8111
                                      "    std::string a;\n"
@@ -6680,7 +8156,7 @@ class TestClass : public TestFixture {
                                      "        a = ostr.str();\n"
                                      "    }\n"
                                      "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // bailout: multi line lambda in rhs => do not warn
         checkInitializationListUsage("class Fred {\n"
@@ -6691,7 +8167,7 @@ class TestClass : public TestFixture {
                                      "        };\n"
                                      "    }\n"
                                      "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // don't warn if some other instance's members are assigned to
         checkInitializationListUsage("class C {\n"
@@ -6700,22 +8176,47 @@ class TestClass : public TestFixture {
                                      "private:\n"
                                      "    Foo m_i;\n"
                                      "};");
-        ASSERT_EQUALS("", errout.str());
-    }
+        ASSERT_EQUALS("", errout_str());
 
+        checkInitializationListUsage("class A {\n" // #9821 - delegate constructor
+                                     "public:\n"
+                                     "    A() : st{} {}\n"
+                                     "\n"
+                                     "    explicit A(const std::string &input): A() {\n"
+                                     "        st = input;\n"
+                                     "    }\n"
+                                     "\n"
+                                     "private:\n"
+                                     "    std::string st;\n"
+                                     "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkInitializationListUsage("struct S {\n" // #14189
+                                     "    S() {}\n"
+                                     "    int i{};\n"
+                                     "};\n"
+                                     "struct T { explicit T(const S&); };\n"
+                                     "class C {\n"
+                                     "    C() {\n"
+                                     "        S s;\n"
+                                     "        s.i = 1;\n"
+                                     "        p = std::make_unique<T>(s);\n"
+                                     "    }\n"
+                                     "    std::unique_ptr<T> p;\n"
+                                     "};");
+        ASSERT_EQUALS("", errout_str());
+    }
 
-    void checkSelfInitialization(const char code []) {
-        // Clear the error log
-        errout.str("");
 
+#define checkSelfInitialization(...) checkSelfInitialization_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkSelfInitialization_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        tokenizer.simplifyTokenList2();
+        SimpleTokenizer tokenizer(settings0, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         CheckClass checkClass(&tokenizer, &settings0, this);
-        checkClass.checkSelfInitialization();
+        (checkClass.checkSelfInitialization)();
     }
 
     void selfInitialization() {
@@ -6724,14 +8225,14 @@ class TestClass : public TestFixture {
                                 "    Fred() : i(i) {\n"
                                 "    }\n"
                                 "};");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Member variable 'i' is initialized by itself.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Member variable 'i' is initialized by itself. [selfInitialization]\n", errout_str());
 
         checkSelfInitialization("class Fred {\n"
                                 "    int i;\n"
                                 "    Fred() : i{i} {\n"
                                 "    }\n"
                                 "};");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Member variable 'i' is initialized by itself.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Member variable 'i' is initialized by itself. [selfInitialization]\n", errout_str());
 
         checkSelfInitialization("class Fred {\n"
                                 "    int i;\n"
@@ -6739,86 +8240,92 @@ class TestClass : public TestFixture {
                                 "};\n"
                                 "Fred::Fred() : i(i) {\n"
                                 "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Member variable 'i' is initialized by itself.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:14]: (error) Member variable 'i' is initialized by itself. [selfInitialization]\n", errout_str());
+
+        checkSelfInitialization("class A {\n" // #10427
+                                "public:\n"
+                                "    explicit A(int x) : _x(static_cast<int>(_x)) {}\n"
+                                "private:\n"
+                                "    int _x;\n"
+                                "};\n");
+        ASSERT_EQUALS("[test.cpp:3:23]: (error) Member variable '_x' is initialized by itself. [selfInitialization]\n", errout_str());
+
+        checkSelfInitialization("class A {\n"
+                                "public:\n"
+                                "    explicit A(int x) : _x((int)(_x)) {}\n"
+                                "private:\n"
+                                "    int _x;\n"
+                                "};\n");
+        ASSERT_EQUALS("[test.cpp:3:23]: (error) Member variable '_x' is initialized by itself. [selfInitialization]\n", errout_str());
 
         checkSelfInitialization("class Fred {\n"
                                 "    std::string s;\n"
                                 "    Fred() : s(s) {\n"
                                 "    }\n"
                                 "};");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Member variable 's' is initialized by itself.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Member variable 's' is initialized by itself. [selfInitialization]\n", errout_str());
 
         checkSelfInitialization("class Fred {\n"
                                 "    int x;\n"
                                 "    Fred(int x);\n"
                                 "};\n"
-                                "Fred::Fred(int x) : x(x) { }\n"
-                               );
-        ASSERT_EQUALS("", errout.str());
+                                "Fred::Fred(int x) : x(x) { }");
+        ASSERT_EQUALS("", errout_str());
 
         checkSelfInitialization("class Fred {\n"
                                 "    int x;\n"
                                 "    Fred(int x);\n"
                                 "};\n"
-                                "Fred::Fred(int x) : x{x} { }\n"
-                               );
-        ASSERT_EQUALS("", errout.str());
+                                "Fred::Fred(int x) : x{x} { }");
+        ASSERT_EQUALS("", errout_str());
 
         checkSelfInitialization("class Fred {\n"
                                 "    std::string s;\n"
                                 "    Fred(const std::string& s) : s(s) {\n"
                                 "    }\n"
                                 "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkSelfInitialization("class Fred {\n"
                                 "    std::string s;\n"
                                 "    Fred(const std::string& s) : s{s} {\n"
                                 "    }\n"
                                 "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkSelfInitialization("struct Foo : Bar {\n"
                                 "    int i;\n"
                                 "    Foo(int i)\n"
-                                "        : Bar(""), i(i) {}\n"
+                                "        : Bar(\"\"), i(i) {}\n"
                                 "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkSelfInitialization("struct Foo : std::Bar {\n" // #6073
                                 "    int i;\n"
                                 "    Foo(int i)\n"
-                                "        : std::Bar(""), i(i) {}\n"
+                                "        : std::Bar(\"\"), i(i) {}\n"
                                 "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkSelfInitialization("struct Foo : std::Bar {\n" // #6073
                                 "    int i;\n"
                                 "    Foo(int i)\n"
-                                "        : std::Bar(""), i{i} {}\n"
+                                "        : std::Bar(\"\"), i{i} {}\n"
                                 "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void checkVirtualFunctionCall(const char code[], Settings *s = nullptr, bool inconclusive = true) {
-        // Clear the error log
-        errout.str("");
-
+#define checkVirtualFunctionCall(...) checkVirtualFunctionCall_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkVirtualFunctionCall_(const char* file, int line, const char (&code)[size]) {
         // Check..
-        if (!s) {
-            static Settings settings_;
-            s = &settings_;
-            s->addEnabled("warning");
-        }
-        s->inconclusive = inconclusive;
+        const Settings settings = settingsBuilder().severity(Severity::warning).severity(Severity::style).certainty(Certainty::inconclusive).build();
 
         // Tokenize..
-        Tokenizer tokenizer(s, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        tokenizer.simplifyTokenList2();
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
-        CheckClass checkClass(&tokenizer, s, this);
+        CheckClass checkClass(&tokenizer, &settings, this);
         checkClass.checkVirtualFunctionCallInConstructor();
     }
 
@@ -6829,39 +8336,114 @@ class TestClass : public TestFixture {
                                  "    A();\n"
                                  "};\n"
                                  "A::A()\n"
-                                 "{f();}\n");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:3]: (warning) Virtual function 'f' is called from constructor 'A()' at line 7. Dynamic binding is not used.\n", errout.str());
+                                 "{f();}");
+        ASSERT_EQUALS("[test.cpp:7:2] -> [test.cpp:3:17]: (style) Virtual function 'f' is called from constructor 'A()' at line 7. Dynamic binding is not used. [virtualCallInConstructor]\n", errout_str());
 
         checkVirtualFunctionCall("class A {\n"
                                  "    virtual int f();\n"
                                  "    A() {f();}\n"
                                  "};\n"
-                                 "int A::f() { return 1; }\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (warning) Virtual function 'f' is called from constructor 'A()' at line 3. Dynamic binding is not used.\n", errout.str());
+                                 "int A::f() { return 1; }");
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:2:17]: (style) Virtual function 'f' is called from constructor 'A()' at line 3. Dynamic binding is not used. [virtualCallInConstructor]\n", errout_str());
 
         checkVirtualFunctionCall("class A : B {\n"
                                  "    int f() override;\n"
                                  "    A() {f();}\n"
                                  "};\n"
-                                 "int A::f() { return 1; }\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (warning) Virtual function 'f' is called from constructor 'A()' at line 3. Dynamic binding is not used.\n", errout.str());
+                                 "int A::f() { return 1; }");
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:2:9]: (style) Virtual function 'f' is called from constructor 'A()' at line 3. Dynamic binding is not used. [virtualCallInConstructor]\n", errout_str());
 
         checkVirtualFunctionCall("class B {\n"
                                  "    virtual int f() = 0;\n"
                                  "};\n"
                                  "class A : B {\n"
-                                 "    int f();\n"
+                                 "    int f();\n" // <- not explicitly virtual
                                  "    A() {f();}\n"
                                  "};\n"
-                                 "int A::f() { return 1; }\n");
-        ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:5]: (warning) Virtual function 'f' is called from constructor 'A()' at line 6. Dynamic binding is not used.\n", errout.str());
+                                 "int A::f() { return 1; }");
+        ASSERT_EQUALS("", errout_str());
 
         checkVirtualFunctionCall("class A\n"
                                  "{\n"
                                  "    A() { A::f(); }\n"
                                  "    virtual void f() {}\n"
+                                 "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkVirtualFunctionCall("class A : B {\n"
+                                 "    int f() final { return 1; }\n"
+                                 "    A() { f(); }\n"
+                                 "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkVirtualFunctionCall("class B {\n"
+                                 "public:"
+                                 "    virtual void f() {}\n"
+                                 "};\n"
+                                 "class A : B {\n"
+                                 "public:"
+                                 "    void f() override final {}\n"
+                                 "    A() { f(); }\n"
+                                 "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkVirtualFunctionCall("class Base {\n"
+                                 "public:\n"
+                                 "    virtual void Copy(const Base& Src) = 0;\n"
+                                 "};\n"
+                                 "class Derived : public Base {\n"
+                                 "public:\n"
+                                 "    Derived() : i(0) {}\n"
+                                 "    Derived(const Derived& Src);\n"
+                                 "    void Copy(const Base& Src) override;\n"
+                                 "    int i;\n"
+                                 "};\n"
+                                 "Derived::Derived(const Derived& Src) {\n"
+                                 "    Copy(Src);\n"
+                                 "}\n"
+                                 "void Derived::Copy(const Base& Src) {\n"
+                                 "    auto d = dynamic_cast<const Derived&>(Src);\n"
+                                 "    i = d.i;\n"
+                                 "}\n");
+        ASSERT_EQUALS("[test.cpp:13:5] -> [test.cpp:9:10]: (style) Virtual function 'Copy' is called from copy constructor 'Derived(const Derived&Src)' at line 13. Dynamic binding is not used. [virtualCallInConstructor]\n",
+                      errout_str());
+
+        checkVirtualFunctionCall("struct B {\n"
+                                 "    B() { auto pf = &f; }\n"
+                                 "    virtual void f() {}\n"
+                                 "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkVirtualFunctionCall("struct B {\n"
+                                 "    B() { auto pf = &B::f; }\n"
+                                 "    virtual void f() {}\n"
+                                 "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkVirtualFunctionCall("struct B {\n"
+                                 "    B() { (f)(); }\n"
+                                 "    virtual void f() {}\n"
+                                 "};\n");
+        ASSERT_EQUALS("[test.cpp:2:12] -> [test.cpp:3:18]: (style) Virtual function 'f' is called from constructor 'B()' at line 2. Dynamic binding is not used. [virtualCallInConstructor]\n", errout_str());
+
+        checkVirtualFunctionCall("class S {\n" // don't crash
+                                 "    ~S();\n"
+                                 "public:\n"
+                                 "    S();\n"
+                                 "};\n"
+                                 "S::S() {\n"
+                                 "    typeid(S);\n"
+                                 "}\n"
+                                 "S::~S() = default;\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkVirtualFunctionCall("struct Base: { virtual void wibble() = 0; virtual ~Base() {} };\n" // #11167
+                                 "struct D final : public Base {\n"
+                                 "    void wibble() override;\n"
+                                 "    D() {}\n"
+                                 "    virtual ~D() { wibble(); }\n"
                                  "};\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void pureVirtualFunctionCall() {
@@ -6871,8 +8453,8 @@ class TestClass : public TestFixture {
                                  "    A();\n"
                                  "};\n"
                                  "A::A()\n"
-                                 "{pure();}\n");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:3]: (warning) Call of pure virtual function 'pure' in constructor.\n", errout.str());
+                                 "{pure();}");
+        ASSERT_EQUALS("[test.cpp:7:2] -> [test.cpp:3:18]: (warning) Call of pure virtual function 'pure' in constructor. [pureVirtualCall]\n", errout_str());
 
         checkVirtualFunctionCall("class A\n"
                                  "{\n"
@@ -6881,53 +8463,64 @@ class TestClass : public TestFixture {
                                  "    int m;\n"
                                  "};\n"
                                  "A::A():m(A::pure())\n"
-                                 "{}\n");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:3]: (warning) Call of pure virtual function 'pure' in constructor.\n", errout.str());
+                                 "{}");
+        ASSERT_EQUALS("[test.cpp:7:13] -> [test.cpp:3:17]: (warning) Call of pure virtual function 'pure' in constructor. [pureVirtualCall]\n", errout_str());
+
+        checkVirtualFunctionCall("namespace N {\n"
+                                 "  class A\n"
+                                 "  {\n"
+                                 "      virtual int pure() = 0;\n"
+                                 "      A();\n"
+                                 "      int m;\n"
+                                 "  };\n"
+                                 "}\n"
+                                 "N::A::A() : m(N::A::pure()) {}\n");
+        ASSERT_EQUALS("[test.cpp:9:21] -> [test.cpp:4:19]: (warning) Call of pure virtual function 'pure' in constructor. [pureVirtualCall]\n", errout_str());
 
         checkVirtualFunctionCall("class A\n"
                                  " {\n"
-                                 "    virtual void pure()=0; \n"
-                                 "    virtual ~A(); \n"
-                                 "    int m; \n"
+                                 "    virtual void pure()=0;\n"
+                                 "    virtual ~A();\n"
+                                 "    int m;\n"
                                  "};\n"
                                  "A::~A()\n"
-                                 "{pure();}\n");
-        ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:3]: (warning) Call of pure virtual function 'pure' in destructor.\n", errout.str());
+                                 "{pure();}");
+        ASSERT_EQUALS("[test.cpp:8:2] -> [test.cpp:3:18]: (warning) Call of pure virtual function 'pure' in destructor. [pureVirtualCall]\n", errout_str());
 
         checkVirtualFunctionCall("class A\n"
                                  " {\n"
                                  "    virtual void pure()=0;\n"
                                  "    void nonpure()\n"
                                  "    {pure();}\n"
-                                 "    A(); \n"
+                                 "    A();\n"
                                  "};\n"
                                  "A::A()\n"
-                                 "{nonpure();}\n");
-        ASSERT_EQUALS("[test.cpp:9] -> [test.cpp:5] -> [test.cpp:3]: (warning) Call of pure virtual function 'pure' in constructor.\n", errout.str());
+                                 "{nonpure();}");
+        ASSERT_EQUALS("[test.cpp:9:2] -> [test.cpp:5:6] -> [test.cpp:3:18]: (warning) Call of pure virtual function 'pure' in constructor. [pureVirtualCall]\n", errout_str());
 
         checkVirtualFunctionCall("class A\n"
                                  " {\n"
                                  "    virtual int pure()=0;\n"
                                  "    int nonpure()\n"
                                  "    {return pure();}\n"
-                                 "    A(); \n"
+                                 "    A();\n"
                                  "    int m;\n"
                                  "};\n"
                                  "A::A():m(nonpure())\n"
-                                 "{}\n");
-        TODO_ASSERT_EQUALS("[test.cpp:9] -> [test.cpp:5] -> [test.cpp:3]: (warning) Call of pure virtual function 'pure' in constructor.\n", "", errout.str());
+                                 "{}");
+        TODO_ASSERT_EQUALS("[test.cpp:9:2] -> [test.cpp:5:6] -> [test.cpp:3:18]: (warning) Call of pure virtual function 'pure' in constructor. [pureVirtualCall]\n", "", errout_str());
 
         checkVirtualFunctionCall("class A\n"
                                  " {\n"
-                                 "    virtual void pure()=0; \n"
+                                 "    virtual void pure()=0;\n"
                                  "    void nonpure()\n"
                                  "    {pure();}\n"
                                  "    virtual ~A();\n"
                                  "    int m;\n"
                                  "};\n"
                                  "A::~A()\n"
-                                 "{nonpure();}\n");
-        ASSERT_EQUALS("[test.cpp:10] -> [test.cpp:5] -> [test.cpp:3]: (warning) Call of pure virtual function 'pure' in destructor.\n", errout.str());
+                                 "{nonpure();}");
+        ASSERT_EQUALS("[test.cpp:10:2] -> [test.cpp:5:6] -> [test.cpp:3:18]: (warning) Call of pure virtual function 'pure' in destructor. [pureVirtualCall]\n", errout_str());
 
         checkVirtualFunctionCall("class A\n"
                                  "{\n"
@@ -6935,8 +8528,8 @@ class TestClass : public TestFixture {
                                  "    A(bool b);\n"
                                  "};\n"
                                  "A::A(bool b)\n"
-                                 "{if (b) pure();}\n");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:3]: (warning) Call of pure virtual function 'pure' in constructor.\n", errout.str());
+                                 "{if (b) pure();}");
+        ASSERT_EQUALS("[test.cpp:7:9] -> [test.cpp:3:18]: (warning) Call of pure virtual function 'pure' in constructor. [pureVirtualCall]\n", errout_str());
 
         checkVirtualFunctionCall("class A\n"
                                  "{\n"
@@ -6946,7 +8539,7 @@ class TestClass : public TestFixture {
                                  "};\n"
                                  "A::~A()\n"
                                  "{if (b) pure();}");
-        ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:3]: (warning) Call of pure virtual function 'pure' in destructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:9] -> [test.cpp:3:18]: (warning) Call of pure virtual function 'pure' in destructor. [pureVirtualCall]\n", errout_str());
 
         // #5831
         checkVirtualFunctionCall("class abc {\n"
@@ -6954,7 +8547,7 @@ class TestClass : public TestFixture {
                                  "  virtual ~abc() throw() {}\n"
                                  "  virtual void def(void* g) throw () = 0;\n"
                                  "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #4992
         checkVirtualFunctionCall("class CMyClass {\n"
@@ -6965,7 +8558,15 @@ class TestClass : public TestFixture {
                                  "    }\n"
                                  "    virtual void VirtualMethod() = 0;\n"
                                  "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // #10559
+        checkVirtualFunctionCall("struct S {\n"
+                                 "    S(const int x) : m(std::bind(&S::f, this, x, 42)) {}\n"
+                                 "    virtual int f(const int x, const int y) = 0;\n"
+                                 "    std::function<int()> m;\n"
+                                 "};\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void pureVirtualFunctionCallOtherClass() {
@@ -6975,8 +8576,8 @@ class TestClass : public TestFixture {
                                  "    A(const A & a);\n"
                                  "};\n"
                                  "A::A(const A & a)\n"
-                                 "{a.pure();}\n");
-        ASSERT_EQUALS("", errout.str());
+                                 "{a.pure();}");
+        ASSERT_EQUALS("", errout_str());
 
         checkVirtualFunctionCall("class A\n"
                                  "{\n"
@@ -6988,8 +8589,8 @@ class TestClass : public TestFixture {
                                  "    virtual void pure()=0;\n"
                                  "};\n"
                                  "A::A()\n"
-                                 "{B b; b.pure();}\n");
-        ASSERT_EQUALS("", errout.str());
+                                 "{B b; b.pure();}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void pureVirtualFunctionCallWithBody() {
@@ -7001,21 +8602,21 @@ class TestClass : public TestFixture {
                                  "A::A()\n"
                                  "{pureWithBody();}\n"
                                  "void A::pureWithBody()\n"
-                                 "{}\n");
-        ASSERT_EQUALS("", errout.str());
+                                 "{}");
+        ASSERT_EQUALS("", errout_str());
 
         checkVirtualFunctionCall("class A\n"
                                  " {\n"
                                  "    virtual void pureWithBody()=0;\n"
                                  "    void nonpure()\n"
                                  "    {pureWithBody();}\n"
-                                 "    A(); \n"
+                                 "    A();\n"
                                  "};\n"
                                  "A::A()\n"
                                  "{nonpure();}\n"
                                  "void A::pureWithBody()\n"
-                                 "{}\n");
-        ASSERT_EQUALS("", errout.str());
+                                 "{}");
+        ASSERT_EQUALS("", errout_str());
 
     }
 
@@ -7025,22 +8626,22 @@ class TestClass : public TestFixture {
                                  "    virtual void pure()=0;\n"
                                  "    void nonpure(bool bCallPure)\n"
                                  "    { if (bCallPure) pure();}\n"
-                                 "    A(); \n"
+                                 "    A();\n"
                                  "};\n"
                                  "A::A()\n"
-                                 "{nonpure(false);}\n");
-        ASSERT_EQUALS("", errout.str());
+                                 "{nonpure(false);}");
+        ASSERT_EQUALS("", errout_str());
 
         checkVirtualFunctionCall("class A\n"
                                  " {\n"
                                  "    virtual void pure()=0;\n"
                                  "    void nonpure(bool bCallPure)\n"
                                  "    { if (!bCallPure) ; else pure();}\n"
-                                 "    A(); \n"
+                                 "    A();\n"
                                  "};\n"
                                  "A::A()\n"
-                                 "{nonpure(false);}\n");
-        ASSERT_EQUALS("", errout.str());
+                                 "{nonpure(false);}");
+        ASSERT_EQUALS("", errout_str());
 
         checkVirtualFunctionCall("class A\n"
                                  " {\n"
@@ -7051,82 +8652,40 @@ class TestClass : public TestFixture {
                                  "        case true: pure(); break;\n"
                                  "        }\n"
                                  "    }\n"
-                                 "    A(); \n"
+                                 "    A();\n"
                                  "};\n"
                                  "A::A()\n"
-                                 "{nonpure(false);}\n");
-        ASSERT_EQUALS("", errout.str());
-    }
-
-    void checkUnsafeClassDivZero(const char code[]) {
-        // Clear the error log
-        errout.str("");
-        Settings settings;
-        settings.addEnabled("style");
-
-        // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-
-        // Check..
-        CheckClass checkClass(&tokenizer, &settings, this);
-        checkClass.checkUnsafeClassDivZero(true);
+                                 "{nonpure(false);}");
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void unsafeClassDivZero() {
-        checkUnsafeClassDivZero("class A {\n"
-                                "public:\n"
-                                "  void dostuff(int x);\n"
-                                "}\n"
-                                "void A::dostuff(int x) { int a = 1000 / x; }");
-        ASSERT_EQUALS("[test.cpp:5]: (style) Public interface of A is not safe. When calling A::dostuff(), if parameter x is 0 that leads to division by zero.\n", errout.str());
-
-        checkUnsafeClassDivZero("class A {\n"
-                                "public:\n"
-                                "  void f1();\n"
-                                "  void f2(int x);\n"
-                                "}\n"
-                                "void A::f1() {}\n"
-                                "void A::f2(int x) { int a = 1000 / x; }");
-        ASSERT_EQUALS("[test.cpp:7]: (style) Public interface of A is not safe. When calling A::f2(), if parameter x is 0 that leads to division by zero.\n", errout.str());
-
-        checkUnsafeClassDivZero("class A {\n"
-                                "public:\n"
-                                "  void operator/(int x);\n"
-                                "}\n"
-                                "void A::operator/(int x) { int a = 1000 / x; }");
-        ASSERT_EQUALS("", errout.str());
-    }
 
-    void checkOverride(const char code[]) {
-        // Clear the error log
-        errout.str("");
-        Settings settings;
-        settings.addEnabled("style");
+#define checkOverride(...) checkOverride_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkOverride_(const char* file, int line, const char (&code)[size]) {
+        const Settings settings = settingsBuilder().severity(Severity::style).build();
 
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check..
         CheckClass checkClass(&tokenizer, &settings, this);
-        checkClass.checkOverride();
+        (checkClass.checkOverride)();
     }
 
     void override1() {
         checkOverride("class Base { virtual void f(); };\n"
                       "class Derived : Base { virtual void f(); };");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:2]: (style) The function 'f' overrides a function in a base class but is not marked with a 'override' specifier.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:27] -> [test.cpp:2:37]: (style) The function 'f' overrides a function in a base class but is not marked with a 'override' specifier. [missingOverride]\n", errout_str());
 
         checkOverride("class Base { virtual void f(); };\n"
                       "class Derived : Base { virtual void f() override; };");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOverride("class Base { virtual void f(); };\n"
                       "class Derived : Base { virtual void f() final; };");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOverride("class Base {\n"
                       "public:\n"
@@ -7138,7 +8697,7 @@ class TestClass : public TestFixture {
                       "    auto foo( ) const -> size_t { return 0; }\n"
                       "    auto bar( ) const -> size_t override { return 0; }\n"
                       "};");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:8]: (style) The function 'foo' overrides a function in a base class but is not marked with a 'override' specifier.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:18] -> [test.cpp:8:10]: (style) The function 'foo' overrides a function in a base class but is not marked with a 'override' specifier. [missingOverride]\n", errout_str());
 
         checkOverride("namespace Test {\n"
                       "    class C {\n"
@@ -7150,48 +8709,722 @@ class TestClass : public TestFixture {
                       "public:\n"
                       "    ~C();\n"
                       "};");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:9]: (style) The destructor '~C' overrides a destructor in a base class but is not marked with a 'override' specifier.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:18] -> [test.cpp:9:6]: (style) The destructor '~C' overrides a destructor in a base class but is not marked with a 'override' specifier. [missingOverride]\n", errout_str());
+
+        checkOverride("struct Base {\n"
+                      "    virtual void foo();\n"
+                      "};\n"
+                      "\n"
+                      "struct Derived: public Base {\n"
+                      "   void foo() override;\n"
+                      "   void foo(int);\n"
+                      "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkOverride("struct B {\n" // #9092
+                      "    virtual int f(int i) const = 0;\n"
+                      "};\n"
+                      "namespace N {\n"
+                      "    struct D : B {\n"
+                      "        virtual int f(int i) const;\n"
+                      "    };\n"
+                      "}\n");
+        ASSERT_EQUALS("[test.cpp:2:17] -> [test.cpp:6:21]: (style) The function 'f' overrides a function in a base class but is not marked with a 'override' specifier. [missingOverride]\n", errout_str());
+
+        checkOverride("struct A {\n"
+                      "    virtual void f(int);\n"
+                      "};\n"
+                      "struct D : A {\n"
+                      "  void f(double);\n"
+                      "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkOverride("struct A {\n"
+                      "    virtual void f(int);\n"
+                      "};\n"
+                      "struct D : A {\n"
+                      "  void f(int);\n"
+                      "};\n");
+        ASSERT_EQUALS("[test.cpp:2:18] -> [test.cpp:5:8]: (style) The function 'f' overrides a function in a base class but is not marked with a 'override' specifier. [missingOverride]\n", errout_str());
+
+        checkOverride("struct A {\n"
+                      "    virtual void f(char, int);\n"
+                      "};\n"
+                      "struct D : A {\n"
+                      "  void f(char, int);\n"
+                      "};\n");
+        ASSERT_EQUALS("[test.cpp:2:18] -> [test.cpp:5:8]: (style) The function 'f' overrides a function in a base class but is not marked with a 'override' specifier. [missingOverride]\n", errout_str());
+
+        checkOverride("struct A {\n"
+                      "    virtual void f(char, int);\n"
+                      "};\n"
+                      "struct D : A {\n"
+                      "  void f(char, double);\n"
+                      "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkOverride("struct A {\n"
+                      "    virtual void f(char, int);\n"
+                      "};\n"
+                      "struct D : A {\n"
+                      "  void f(char c = '\\0', double);\n"
+                      "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkOverride("struct A {\n"
+                      "    virtual void f(char, int);\n"
+                      "};\n"
+                      "struct D : A {\n"
+                      "  void f(char c = '\\0', int);\n"
+                      "};\n");
+        ASSERT_EQUALS("[test.cpp:2:18] -> [test.cpp:5:8]: (style) The function 'f' overrides a function in a base class but is not marked with a 'override' specifier. [missingOverride]\n", errout_str());
+
+        checkOverride("struct A {\n"
+                      "    virtual void f(char c, std::vector<int>);\n"
+                      "};\n"
+                      "struct D : A {\n"
+                      "  void f(char c, std::vector<double>);\n"
+                      "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkOverride("struct A {\n"
+                      "    virtual void f(char c, std::vector<int>);\n"
+                      "};\n"
+                      "struct D : A {\n"
+                      "  void f(char c, std::set<int>);\n"
+                      "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkOverride("struct A {\n"
+                      "    virtual void f(char c, std::vector<int> v);\n"
+                      "};\n"
+                      "struct D : A {\n"
+                      "  void f(char c, std::vector<int> w = {});\n"
+                      "};\n");
+        TODO_ASSERT_EQUALS("[test.cpp:2:18] -> [test.cpp:5:8]: (style) The function 'f' overrides a function in a base class but is not marked with a 'override' specifier. [missingOverride]\n", "", errout_str());
 
+        checkOverride("struct T {};\n" // #10920
+                      "struct B {\n"
+                      "    virtual T f() = 0;\n"
+                      "};\n"
+                      "struct D : B {\n"
+                      "    friend T f();\n"
+                      "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkOverride("struct S {};\n" // #11827
+                      "struct SPtr {\n"
+                      "    virtual S* operator->() const { return p; }\n"
+                      "    S* p = nullptr;\n"
+                      "};\n"
+                      "struct T : public S {};\n"
+                      "struct TPtr : public SPtr {\n"
+                      "    T* operator->() const { return (T*)p; }\n"
+                      "};\n");
+        ASSERT_EQUALS("[test.cpp:3:16] -> [test.cpp:8:8]: (style) The function 'operator->' overrides a function in a base class but is not marked with a 'override' specifier. [missingOverride]\n",
+                      errout_str());
+
+        checkOverride("class Base {\n" // #12131
+                      "    virtual int Calculate(int arg) = 0;\n"
+                      "};\n"
+                      "class Derived : public Base {\n"
+                      "    int Calculate(int arg = 0) {\n"
+                      "        return arg * 2;\n"
+                      "    }\n"
+                      "};\n");
+        ASSERT_EQUALS("[test.cpp:2:17] -> [test.cpp:5:9]: (style) The function 'Calculate' overrides a function in a base class but is not marked with a 'override' specifier. [missingOverride]\n", errout_str());
+
+        checkOverride("struct S {\n" // #12439
+                      "    virtual ~S() = default;\n"
+                      "};\n"
+                      "struct D : S {\n"
+                      "    ~D() {}\n"
+                      "};\n");
+        ASSERT_EQUALS("[test.cpp:2:14] -> [test.cpp:5:6]: (style) The destructor '~D' overrides a destructor in a base class but is not marked with a 'override' specifier. [missingOverride]\n",
+                      errout_str());
+
+        checkOverride("struct B {\n" // #14581
+                      "    virtual void f();\n"
+                      "};\n"
+                      "struct D : B {\n"
+                      "    void f() override;\n"
+                      "    template <typename T>\n"
+                      "    void f();\n"
+                      "};\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void overrideCVRefQualifiers() {
         checkOverride("class Base { virtual void f(); };\n"
                       "class Derived : Base { void f() const; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOverride("class Base { virtual void f(); };\n"
                       "class Derived : Base { void f() volatile; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOverride("class Base { virtual void f(); };\n"
                       "class Derived : Base { void f() &; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkOverride("class Base { virtual void f(); };\n"
                       "class Derived : Base { void f() &&; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    #define checkUselessOverride(...) checkUselessOverride_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkUselessOverride_(const char* file, int line, const char (&code)[size]) {
+        const Settings settings = settingsBuilder().severity(Severity::style).build();
+
+        SimpleTokenizer2 tokenizer(settings, *this, code, "test.cpp");
+
+        ASSERT_LOC(tokenizer.simplifyTokens1(""), file, line);
+
+        // Check..
+        CheckClass checkClass(&tokenizer, &settings, this);
+        (checkClass.checkUselessOverride)();
+    }
+
+    void uselessOverride() {
+        checkUselessOverride("struct B { virtual int f() { return 5; } };\n" // #11757
+                             "struct D : B {\n"
+                             "    int f() override { return B::f(); }\n"
+                             "};");
+        ASSERT_EQUALS("[test.cpp:1:24] -> [test.cpp:3:9]: (style) The function 'f' overrides a function in a base class but just delegates back to the base class. [uselessOverride]\n", errout_str());
+
+        checkUselessOverride("struct B { virtual void f(); };\n"
+                             "struct D : B {\n"
+                             "    void f() override { B::f(); }\n"
+                             "};");
+        ASSERT_EQUALS("[test.cpp:1:25] -> [test.cpp:3:10]: (style) The function 'f' overrides a function in a base class but just delegates back to the base class. [uselessOverride]\n", errout_str());
+
+        checkUselessOverride("struct B { virtual int f() = 0; };\n"
+                             "int B::f() { return 5; }\n"
+                             "struct D : B {\n"
+                             "    int f() override { return B::f(); }\n"
+                             "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUselessOverride("struct B { virtual int f(int i); };\n"
+                             "struct D : B {\n"
+                             "    int f(int i) override { return B::f(i); }\n"
+                             "};");
+        ASSERT_EQUALS("[test.cpp:1:24] -> [test.cpp:3:9]: (style) The function 'f' overrides a function in a base class but just delegates back to the base class. [uselessOverride]\n", errout_str());
+
+        checkUselessOverride("struct B { virtual int f(int i); };\n"
+                             "struct D : B {\n"
+                             "    int f(int i) override { return B::f(i + 1); }\n"
+                             "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUselessOverride("struct B { virtual int f(int i, int j); };\n"
+                             "struct D : B {\n"
+                             "    int f(int i, int j) override { return B::f(j, i); }\n"
+                             "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUselessOverride("struct B { virtual int f(); };\n"
+                             "struct I { virtual int f() = 0; };\n"
+                             "struct D : B, I {\n"
+                             "    int f() override { return B::f(); }\n"
+                             "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUselessOverride("struct S { virtual void f(); };\n"
+                             "struct D : S {\n"
+                             "    void f() final { S::f(); }\n"
+                             "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUselessOverride("struct S {\n"
+                             "protected:\n"
+                             "    virtual void f();\n"
+                             "};\n"
+                             "struct D : S {\n"
+                             "public:\n"
+                             "    void f() override { S::f(); }\n"
+                             "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUselessOverride("struct B { virtual void f(int, int, int) const; };\n" // #11799
+                             "struct D : B {\n"
+                             "    int m = 42;\n"
+                             "    void f(int a, int b, int c) const override;\n"
+                             "};\n"
+                             "void D::f(int a, int b, int c) const {\n"
+                             "    B::f(a, b, m);\n"
+                             "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUselessOverride("struct B {\n" // #11803
+                             "    virtual void f();\n"
+                             "    virtual void f(int i);\n"
+                             "};\n"
+                             "struct D : B {\n"
+                             "    void f() override { B::f(); }\n"
+                             "    void f(int i) override;\n"
+                             "    void g() { f(); }\n"
+                             "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUselessOverride("struct B { virtual void f(); };\n" // #11808
+                             "struct D : B { void f() override {} };\n"
+                             "struct D2 : D {\n"
+                             "    void f() override {\n"
+                             "        B::f();\n"
+                             "    }\n"
+                             "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUselessOverride("struct B {\n"
+                             "    virtual int f() { return 1; }\n"
+                             "    virtual int g() { return 7; }\n"
+                             "    virtual int h(int i, int j) { return i + j; }\n"
+                             "    virtual int j(int i, int j) { return i + j; }\n"
+                             "};\n"
+                             "struct D : B {\n"
+                             "    int f() override { return 2; }\n"
+                             "    int g() override { return 7; }\n"
+                             "    int h(int j, int i) override { return i + j; }\n"
+                             "    int j(int i, int j) override { return i + j; }\n"
+                             "};");
+        ASSERT_EQUALS("[test.cpp:3:17] -> [test.cpp:9:9]: (style) The function 'g' overrides a function in a base class but is identical to the overridden function [uselessOverride]\n"
+                      "[test.cpp:5:17] -> [test.cpp:11:9]: (style) The function 'j' overrides a function in a base class but is identical to the overridden function [uselessOverride]\n",
+                      errout_str());
+
+        checkUselessOverride("struct B : std::exception {\n"
+                             "    virtual void f() { throw *this; }\n"
+                             "};\n"
+                             "struct D : B {\n"
+                             "    void f() override { throw *this; }\n"
+                             "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUselessOverride("#define MACRO virtual void f() {}\n"
+                             "struct B {\n"
+                             "    MACRO\n"
+                             "};\n"
+                             "struct D : B {\n"
+                             "    MACRO\n"
+                             "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUselessOverride("struct B {\n"
+                             "    B() = default;\n"
+                             "    explicit B(int i) : m(i) {}\n"
+                             "    int m{};\n"
+                             "    virtual int f() const { return m; }\n"
+                             "};\n"
+                             "struct D : B {\n"
+                             "    explicit D(int i) : m(i) {}\n"
+                             "    int m{};\n"
+                             "    int f() const override { return m; }\n"
+                             "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUselessOverride("struct B {\n"
+                             "    int g() const;\n"
+                             "    virtual int f() const { return g(); }\n"
+                             "};\n"
+                             "struct D : B {\n"
+                             "    int g() const;\n"
+                             "    int f() const override { return g(); }\n"
+                             "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUselessOverride("#define MACRO 1\n"
+                             "struct B { virtual int f() { return 1; } };\n"
+                             "struct D : B {\n"
+                             "    int f() override { return MACRO; }\n"
+                             "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUselessOverride("struct B {\n" // #12706
+                             "    virtual void f() { g(); }\n"
+                             "    void g() { std::cout << \"Base\\n\"; }\n"
+                             "};\n"
+                             "struct D : B {\n"
+                             "    void f() override { g(); }\n"
+                             "    virtual void g() { std::cout << \"Derived\\n\"; }\n"
+                             "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUselessOverride("struct B {\n" // #12946
+                             "    virtual int f() { return i; }\n"
+                             "    int i;\n"
+                             "};\n"
+                             "struct D : B {\n"
+                             "    int f() override { return b.f(); }\n"
+                             "    B b;\n"
+                             "};\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void checkUnsafeClassRefMember(const char code[]) {
-        // Clear the error log
-        errout.str("");
-        Settings settings;
+#define checkUnsafeClassRefMember(...) checkUnsafeClassRefMember_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkUnsafeClassRefMember_(const char* file, int line, const char (&code)[size]) {
+        /*const*/ Settings settings = settingsBuilder().severity(Severity::warning).build();
         settings.safeChecks.classes = true;
-        settings.addEnabled("warning");
 
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check..
         CheckClass checkClass(&tokenizer, &settings, this);
-        checkClass.checkUnsafeClassRefMember();
+        (checkClass.checkUnsafeClassRefMember)();
     }
 
     void unsafeClassRefMember() {
         checkUnsafeClassRefMember("class C { C(const std::string &s) : s(s) {} const std::string &s; };");
-        ASSERT_EQUALS("[test.cpp:1]: (warning) Unsafe class: The const reference member 'C::s' is initialized by a const reference constructor argument. You need to be careful about lifetime issues.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:37]: (warning) Unsafe class: The const reference member 'C::s' is initialized by a const reference constructor argument. You need to be careful about lifetime issues. [unsafeClassRefMember]\n", errout_str());
+    }
+
+
+#define checkThisUseAfterFree(...) checkThisUseAfterFree_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkThisUseAfterFree_(const char* file, int line, const char (&code)[size]) {
+        // Tokenize..
+        SimpleTokenizer tokenizer(settings1, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+
+        // Check..
+        CheckClass checkClass(&tokenizer, &settings1, this);
+        (checkClass.checkThisUseAfterFree)();
+    }
+
+    void thisUseAfterFree() {
+        setMultiline();
+
+        // Calling method..
+        checkThisUseAfterFree("class C {\n"
+                              "public:\n"
+                              "  void dostuff() { delete mInstance; hello(); }\n"
+                              "private:\n"
+                              "  static C *mInstance;\n"
+                              "  void hello() {}\n"
+                              "};");
+        ASSERT_EQUALS("[test.cpp:3:38]: warning: Calling method 'hello()' when 'this' might be invalid [thisUseAfterFree]\n"
+                      "[test.cpp:5:13]: note: Assuming 'mInstance' is used as 'this'\n"
+                      "[test.cpp:3:20]: note: Delete 'mInstance', invalidating 'this'\n"
+                      "[test.cpp:3:38]: note: Call method when 'this' is invalid\n",
+                      errout_str());
+
+        checkThisUseAfterFree("class C {\n"
+                              "public:\n"
+                              "  void dostuff() { mInstance.reset(); hello(); }\n"
+                              "private:\n"
+                              "  static std::shared_ptr<C> mInstance;\n"
+                              "  void hello() {}\n"
+                              "};");
+        ASSERT_EQUALS("[test.cpp:3:39]: warning: Calling method 'hello()' when 'this' might be invalid [thisUseAfterFree]\n"
+                      "[test.cpp:5:29]: note: Assuming 'mInstance' is used as 'this'\n"
+                      "[test.cpp:3:20]: note: Delete 'mInstance', invalidating 'this'\n"
+                      "[test.cpp:3:39]: note: Call method when 'this' is invalid\n",
+                      errout_str());
+
+        checkThisUseAfterFree("class C {\n"
+                              "public:\n"
+                              "  void dostuff() { reset(); hello(); }\n"
+                              "private:\n"
+                              "  static std::shared_ptr<C> mInstance;\n"
+                              "  void hello();\n"
+                              "  void reset() { mInstance.reset(); }\n"
+                              "};");
+        ASSERT_EQUALS("[test.cpp:3:29]: warning: Calling method 'hello()' when 'this' might be invalid [thisUseAfterFree]\n"
+                      "[test.cpp:5:29]: note: Assuming 'mInstance' is used as 'this'\n"
+                      "[test.cpp:7:18]: note: Delete 'mInstance', invalidating 'this'\n"
+                      "[test.cpp:3:29]: note: Call method when 'this' is invalid\n",
+                      errout_str());
+
+        // Use member..
+        checkThisUseAfterFree("class C {\n"
+                              "public:\n"
+                              "  void dostuff() { delete self; x = 123; }\n"
+                              "private:\n"
+                              "  static C *self;\n"
+                              "  int x;\n"
+                              "};");
+        ASSERT_EQUALS("[test.cpp:3:33]: warning: Using member 'x' when 'this' might be invalid [thisUseAfterFree]\n"
+                      "[test.cpp:5:13]: note: Assuming 'self' is used as 'this'\n"
+                      "[test.cpp:3:20]: note: Delete 'self', invalidating 'this'\n"
+                      "[test.cpp:3:33]: note: Call method when 'this' is invalid\n",
+                      errout_str());
+
+        checkThisUseAfterFree("class C {\n"
+                              "public:\n"
+                              "  void dostuff() { delete self; x[1] = 123; }\n"
+                              "private:\n"
+                              "  static C *self;\n"
+                              "  std::map<int,int> x;\n"
+                              "};");
+        ASSERT_EQUALS("[test.cpp:3:33]: warning: Using member 'x' when 'this' might be invalid [thisUseAfterFree]\n"
+                      "[test.cpp:5:13]: note: Assuming 'self' is used as 'this'\n"
+                      "[test.cpp:3:20]: note: Delete 'self', invalidating 'this'\n"
+                      "[test.cpp:3:33]: note: Call method when 'this' is invalid\n",
+                      errout_str());
+
+        // Assign 'shared_from_this()' to non-static smart pointer
+        checkThisUseAfterFree("class C {\n"
+                              "public:\n"
+                              "  void hold() { mInstance = shared_from_this(); }\n"
+                              "  void dostuff() { mInstance.reset(); hello(); }\n"
+                              "private:\n"
+                              "  std::shared_ptr<C> mInstance;\n"
+                              "  void hello() {}\n"
+                              "};");
+        ASSERT_EQUALS("[test.cpp:4:39]: warning: Calling method 'hello()' when 'this' might be invalid [thisUseAfterFree]\n"
+                      "[test.cpp:6:22]: note: Assuming 'mInstance' is used as 'this'\n"
+                      "[test.cpp:4:20]: note: Delete 'mInstance', invalidating 'this'\n"
+                      "[test.cpp:4:39]: note: Call method when 'this' is invalid\n",
+                      errout_str());
+
+        // Avoid FP..
+        checkThisUseAfterFree("class C {\n"
+                              "public:\n"
+                              "  void dostuff() { delete self; x = 123; }\n"
+                              "private:\n"
+                              "  C *self;\n"
+                              "  int x;\n"
+                              "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkThisUseAfterFree("class C {\n"
+                              "public:\n"
+                              "  void hold() { mInstance = shared_from_this(); }\n"
+                              "  void dostuff() { if (x) { mInstance.reset(); return; } hello(); }\n"
+                              "private:\n"
+                              "  std::shared_ptr<C> mInstance;\n"
+                              "  void hello() {}\n"
+                              "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkThisUseAfterFree("class C\n"
+                              "{\n"
+                              "public:\n"
+                              "    explicit C(const QString& path) : mPath( path ) {}\n"
+                              "\n"
+                              "    static void initialize(const QString& path) {\n" // <- avoid fp in static method
+                              "        if (instanceSingleton)\n"
+                              "            delete instanceSingleton;\n"
+                              "        instanceSingleton = new C(path);\n"
+                              "    }\n"
+                              "private:\n"
+                              "    static C* instanceSingleton;\n"
+                              "};\n"
+                              "\n"
+                              "C* C::instanceSingleton;");
+        ASSERT_EQUALS("", errout_str());
+
+        // Avoid false positive when pointer is deleted in lambda
+        checkThisUseAfterFree("class C {\n"
+                              "public:\n"
+                              "    void foo();\n"
+                              "    void set() { p = this; }\n"
+                              "    void dostuff() {}\n"
+                              "    C* p;\n"
+                              "};\n"
+                              "\n"
+                              "void C::foo() {\n"
+                              "    auto done = [this] () { delete p; };\n"
+                              "    dostuff();\n"
+                              "    done();\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkThisUseAfterFree("class C {\n" // #13311
+                              "public:\n"
+                              "    static void init();\n"
+                              "private:\n"
+                              "    C();\n"
+                              "    static C* self;\n"
+                              "    bool use;\n"
+                              "};\n"
+                              "C::C() { use = true; }\n"
+                              "void C::init() {\n"
+                              "    if (self)\n"
+                              "        delete self;\n"
+                              "    self = new C();\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+
+    void ctu(const std::vector<std::string> &code) {
+        Check &check = getCheck<CheckClass>();
+
+        // getFileInfo
+        std::list<Check::FileInfo*> fileInfo;
+        for (const std::string& c: code) {
+            const std::string filename = std::to_string(fileInfo.size()) + ".cpp";
+            SimpleTokenizer tokenizer{settingsDefault, *this, filename};
+            ASSERT(tokenizer.tokenize(c));
+            fileInfo.push_back(check.getFileInfo(tokenizer, settingsDefault, ""));
+        }
+
+        // Check code..
+        const CTU::FileInfo ctu;
+        check.analyseWholeProgram(ctu, fileInfo, settingsDefault, *this); // TODO: check result
+
+        while (!fileInfo.empty()) {
+            delete fileInfo.back();
+            fileInfo.pop_back();
+        }
+    }
+
+    void ctuOneDefinitionRule() {
+        ctu({"class C { C() { std::cout << 0; } };", "class C { C() { std::cout << 1; } };"});
+        ASSERT_EQUALS("[1.cpp:1:1] -> [0.cpp:1:1]: (error) The one definition rule is violated, different classes/structs have the same name 'C' [ctuOneDefinitionRuleViolation]\n", errout_str());
+
+        ctu({"class C { C(); }; C::C() { std::cout << 0; }", "class C { C(); }; C::C() { std::cout << 1; }"});
+        ASSERT_EQUALS("[1.cpp:1:1] -> [0.cpp:1:1]: (error) The one definition rule is violated, different classes/structs have the same name 'C' [ctuOneDefinitionRuleViolation]\n", errout_str());
+
+        ctu({"class C { C() {} };\n", "class C { C() {} };\n"});
+        ASSERT_EQUALS("", errout_str());
+
+        ctu({"class C { C(); }; C::C(){}", "class C { C(); }; C::C(){}"});
+        ASSERT_EQUALS("", errout_str());
+
+        ctu({"class A::C { C() { std::cout << 0; } };", "class B::C { C() { std::cout << 1; } };"});
+        ASSERT_EQUALS("", errout_str());
+
+        // 11435 - template specialisations
+        const std::string header = "template<typename T1, typename T2> struct Test {};\n";
+        ctu({header + "template<typename T1> struct Test<T1, int> {};\n",
+             header + "template<typename T1> struct Test<T1, double> {};\n"});
+        ASSERT_EQUALS("", errout_str());
+    }
+
+
+#define getFileInfo(...) getFileInfo_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void getFileInfo_(const char* file, int line, const char (&code)[size]) {
+        // Tokenize..
+        SimpleTokenizer tokenizer(settings1, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+
+        // Check..
+        const Check& c = getCheck<CheckClass>();
+        Check::FileInfo * fileInfo = (c.getFileInfo)(tokenizer, settings1, "");
+
+        delete fileInfo;
+    }
+
+    void testGetFileInfo() {
+        getFileInfo("void foo() { union { struct { }; }; }"); // don't crash
+        getFileInfo("struct sometype { sometype(); }; sometype::sometype() = delete;"); // don't crash
+    }
+
+#define checkReturnByReference(...) checkReturnByReference_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkReturnByReference_(const char* file, int line, const char (&code)[size]) {
+        const Settings settings = settingsBuilder().severity(Severity::performance).library("std.cfg").build();
+
+        SimpleTokenizer2 tokenizer(settings, *this, code, "test.cpp");
+
+        ASSERT_LOC(tokenizer.simplifyTokens1(""), file, line);
+
+        // Check..
+        CheckClass checkClass(&tokenizer, &settings, this);
+        (checkClass.checkReturnByReference)();
+    }
+
+    void returnByReference() {
+        checkReturnByReference("struct T { int a[10]; };\n" // #12546
+                               "struct S {\n"
+                               "    T t;\n"
+                               "    int i;\n"
+                               "    std::string s;\n"
+                               "    T getT() const { return t; }\n"
+                               "    int getI() const { return i; }\n"
+                               "    std::string getS() const { return s; }\n"
+                               "    unknown_t f() { return; }\n"
+                               "};\n");
+        ASSERT_EQUALS("[test.cpp:6:7]: (performance) Function 'getT()' should return member 't' by const reference. [returnByReference]\n"
+                      "[test.cpp:8:17]: (performance) Function 'getS()' should return member 's' by const reference. [returnByReference]\n",
+                      errout_str());
+
+        checkReturnByReference("struct B {\n" // #12608
+                               "    virtual std::string f() { return \"abc\"; }\n"
+                               "};\n"
+                               "struct D : B {\n"
+                               "    std::string f() override { return s; }\n"
+                               "    std::string s;\n"
+                               "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkReturnByReference("struct S {\n"
+                               "    std::string f(std::string s) { return s; }\n"
+                               "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkReturnByReference("struct S { S(); };\n" // #12620
+                               "S::S() = delete;\n");
+        ASSERT_EQUALS("", errout_str()); // don't crash
+
+        checkReturnByReference("struct S {\n" // #12626
+                               "    std::string s;\n"
+                               "    operator std::string_view() const { return s; }\n"
+                               "    std::string_view get() const { return s; }\n"
+                               "};\n"
+                               "template<typename T>\n"
+                               "struct U {\n"
+                               "    T t;\n"
+                               "    operator const T& () const { return t; }\n"
+                               "};\n"
+                               "U<std::string> u;\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkReturnByReference("struct S {\n" // #13011
+                               "    std::string s;\n"
+                               "    const std::string& foo() const & { return s; }\n"
+                               "    std::string foo() && { return s; }\n" // <- used for temporary objects
+                               "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkReturnByReference("struct S1 {\n" // #13056
+                               "    std::string str;\n"
+                               "    struct T { std::string strT; } mT;\n"
+                               "};\n"
+                               "struct S2 {\n"
+                               "    std::string get1() const {\n"
+                               "        return mS1->str;\n"
+                               "    }\n"
+                               "    std::string get2() const {\n"
+                               "        return mS1->mT.strT;\n"
+                               "    }\n"
+                               "    S1* mS1;\n"
+                               "};\n");
+        ASSERT_EQUALS("[test.cpp:6:17]: (performance) Function 'get1()' should return member 'str' by const reference. [returnByReference]\n"
+                      "[test.cpp:9:17]: (performance) Function 'get2()' should return member 'strT' by const reference. [returnByReference]\n",
+                      errout_str());
+
+        checkReturnByReference("struct S { std::string str; };\n" // #13059
+                               "struct T {\n"
+                               "    S temp() const;\n"
+                               "    S s[1];\n"
+                               "};\n"
+                               "struct U {\n"
+                               "    std::string get1() const {\n"
+                               "        return t.temp().str;\n"
+                               "    }\n"
+                               "    std::string get2() const {\n"
+                               "        return t.s[0].str;\n"
+                               "    }\n"
+                               "    T t;\n"
+                               "};\n");
+        ASSERT_EQUALS("[test.cpp:10:17]: (performance) Function 'get2()' should return member 'str' by const reference. [returnByReference]\n",
+                      errout_str());
+
+        checkReturnByReference("struct S {\n" // #13845
+                               "    std::string m;\n"
+                               "    std::string get() { return m; }\n"
+                               "};\n"
+                               "std::string f(std::optional<S> o) {\n"
+                               "    return o.transform(&S::get).value_or(\"\");\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 };
 
diff --git a/test/testcmdlineparser.cpp b/test/testcmdlineparser.cpp
index 6963aa381a5..ef8afc1eb0a 100644
--- a/test/testcmdlineparser.cpp
+++ b/test/testcmdlineparser.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,37 +16,136 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "checkers.h"
+#include "cmdlinelogger.h"
 #include "cmdlineparser.h"
+#include "config.h"
+#include "errorlogger.h"
+#include "errortypes.h"
+#include "filesettings.h"
+#include "fixture.h"
+#include "helpers.h"
+#include "path.h"
 #include "platform.h"
 #include "redirect.h"
 #include "settings.h"
 #include "standards.h"
 #include "suppressions.h"
-#include "testsuite.h"
 #include "timer.h"
+#include "utils.h"
 
+#include <cstdio>
 #include <list>
+#include <memory>
 #include <set>
-#include <sstream>
+#include <stdexcept>
 #include <string>
+#include <unordered_set>
 #include <vector>
 
 class TestCmdlineParser : public TestFixture {
 public:
-    TestCmdlineParser()
-        : TestFixture("TestCmdlineParser")
-        , defParser(&settings) {
-    }
+    TestCmdlineParser() : TestFixture("TestCmdlineParser")
+    {}
 
 private:
-    Settings settings;
-    CmdLineParser defParser;
+    class CmdLineLoggerTest final : public CmdLineLogger
+    {
+    public:
+        CmdLineLoggerTest() = default;
+
+        void printMessage(const std::string &message) override
+        {
+            printInternal("cppcheck: " + message + '\n');
+        }
+
+        void printError(const std::string &message) override
+        {
+            printMessage("error: " + message);
+        }
+
+        void printRaw(const std::string &message) override
+        {
+            printInternal(message + '\n'); // TODO: should not append newline
+        }
+
+        std::string str()
+        {
+            std::string s;
+            std::swap(buf, s);
+            return s;
+        }
+
+        void destroy()
+        {
+            if (!buf.empty())
+                throw std::runtime_error("unconsumed messages: " + buf);
+        }
+
+    private:
+        void printInternal(const std::string &message)
+        {
+            buf += message;
+        }
+
+        std::string buf;
+    };
+
+    class CmdLineParserTest final : public CmdLineParser
+    {
+        friend class TestCmdlineParser;
+    public:
+        CmdLineParserTest(CmdLineLogger &logger, Settings &settings, Suppressions &suppressions)
+            : CmdLineParser(logger, settings, suppressions)
+        {}
+    };
+
+    std::unique_ptr<CmdLineLoggerTest> logger;
+    std::unique_ptr<Settings> settings;
+    std::unique_ptr<Suppressions> supprs;
+    std::unique_ptr<CmdLineParserTest> parser;
+
+    void prepareTestInternal() override {
+        logger.reset(new CmdLineLoggerTest());
+        settings.reset(new Settings());
+        supprs.reset(new Suppressions());
+        parser.reset(new CmdLineParserTest(*logger, *settings, *supprs));
+    }
+
+    void teardownTestInternal() override {
+        logger->destroy();
+    }
+
+    void asPremium() {
+        // set this so we think it is the premium
+        settings->cppcheckCfgProductName = "Cppcheck Premium 0.0.0";
+    }
+
+    template<size_t size>
+    CmdLineParser::Result parseFromArgs(const char* const (&argv)[size]) {
+        return parser->parseFromArgs(size, argv);
+    }
+
+    template<size_t size>
+    bool fillSettingsFromArgs(const char* const (&argv)[size]) {
+        return parser->fillSettingsFromArgs(size, argv);
+    }
 
-    void run() OVERRIDE {
+    void run() override {
         TEST_CASE(nooptions);
+        TEST_CASE(nooptionsWithCfg);
+        TEST_CASE(nooptionsWithInvalidCfg);
         TEST_CASE(helpshort);
+        TEST_CASE(helpshortExclusive);
+        TEST_CASE(helpshortWithCfg);
         TEST_CASE(helplong);
-        TEST_CASE(showversion);
+        TEST_CASE(helplongExclusive);
+        TEST_CASE(helplongWithCfg);
+        TEST_CASE(version);
+        TEST_CASE(versionWithCfg);
+        TEST_CASE(versionExclusive);
+        TEST_CASE(checkVersionCorrect);
+        TEST_CASE(checkVersionIncorrect);
         TEST_CASE(onefile);
         TEST_CASE(onepath);
         TEST_CASE(optionwithoutfile);
@@ -56,7 +155,10 @@ class TestCmdlineParser : public TestFixture {
         TEST_CASE(debugwarnings);
         TEST_CASE(forceshort);
         TEST_CASE(forcelong);
-        TEST_CASE(relativePaths);
+        TEST_CASE(relativePaths1);
+        TEST_CASE(relativePaths2);
+        TEST_CASE(relativePaths3);
+        TEST_CASE(relativePaths4);
         TEST_CASE(quietshort);
         TEST_CASE(quietlong);
         TEST_CASE(defines_noarg);
@@ -66,7 +168,13 @@ class TestCmdlineParser : public TestFixture {
         TEST_CASE(defines2);
         TEST_CASE(defines3);
         TEST_CASE(defines4);
-        TEST_CASE(enforceLanguage);
+        TEST_CASE(enforceLanguage1);
+        TEST_CASE(enforceLanguage2);
+        TEST_CASE(enforceLanguage3);
+        TEST_CASE(enforceLanguage4);
+        TEST_CASE(enforceLanguage5);
+        TEST_CASE(enforceLanguage6);
+        TEST_CASE(enforceLanguage7);
         TEST_CASE(includesnopath);
         TEST_CASE(includes);
         TEST_CASE(includesslash);
@@ -74,41 +182,124 @@ class TestCmdlineParser : public TestFixture {
         TEST_CASE(includesnospace);
         TEST_CASE(includes2);
         TEST_CASE(includesFile);
+        TEST_CASE(includesFileNoFile);
         TEST_CASE(configExcludesFile);
+        TEST_CASE(configExcludesFileNoFile);
         TEST_CASE(enabledAll);
         TEST_CASE(enabledStyle);
         TEST_CASE(enabledPerformance);
         TEST_CASE(enabledPortability);
+        TEST_CASE(enabledInformation);
         TEST_CASE(enabledUnusedFunction);
         TEST_CASE(enabledMissingInclude);
+        TEST_CASE(disabledMissingIncludeWithInformation);
+        TEST_CASE(enabledMissingIncludeWithInformation);
+        TEST_CASE(enabledMissingIncludeWithInformationReverseOrder);
 #ifdef CHECK_INTERNAL
         TEST_CASE(enabledInternal);
 #endif
         TEST_CASE(enabledMultiple);
+        TEST_CASE(enabledInvalid);
+        TEST_CASE(enabledError);
+        TEST_CASE(enabledEmpty);
+        TEST_CASE(disableAll);
+        TEST_CASE(disableMultiple);
+        TEST_CASE(disableStylePartial);
+        TEST_CASE(disableInformationPartial);
+        TEST_CASE(disableInformationPartial2);
+        TEST_CASE(disableInvalid);
+        TEST_CASE(disableError);
+        TEST_CASE(disableEmpty);
         TEST_CASE(inconclusive);
         TEST_CASE(errorExitcode);
         TEST_CASE(errorExitcodeMissing);
         TEST_CASE(errorExitcodeStr);
-        TEST_CASE(exitcodeSuppressionsOld); // TODO: Create and test real suppression file
+        TEST_CASE(exitcodeSuppressionsOld);
         TEST_CASE(exitcodeSuppressions);
         TEST_CASE(exitcodeSuppressionsNoFile);
-        TEST_CASE(fileList); // TODO: Create and test real file listing file
-        // TEST_CASE(fileListStdin);  // Disabled since hangs the test run
+        TEST_CASE(fileFilterFileWithDetailsSimplifiedPath);
+        TEST_CASE(fileFilterFileWithDetailsCase);
+        TEST_CASE(fileFilterStdin);
+        TEST_CASE(fileFilterPlus);
+        TEST_CASE(fileFilterNoMatch);
+        TEST_CASE(fileList);
+        TEST_CASE(fileListNoFile);
+        TEST_CASE(fileListStdin);
+        TEST_CASE(fileListInvalid);
         TEST_CASE(inlineSuppr);
         TEST_CASE(jobs);
+        TEST_CASE(jobs2);
         TEST_CASE(jobsMissingCount);
         TEST_CASE(jobsInvalid);
+        TEST_CASE(jobsNoJobs);
+        TEST_CASE(jobsTooBig);
         TEST_CASE(maxConfigs);
         TEST_CASE(maxConfigsMissingCount);
         TEST_CASE(maxConfigsInvalid);
         TEST_CASE(maxConfigsTooSmall);
-        TEST_CASE(reportProgressTest); // "Test" suffix to avoid hiding the parent's reportProgress
+        TEST_CASE(outputFormatText);
+        TEST_CASE(outputFormatSarif);
+        TEST_CASE(outputFormatXml);
+        TEST_CASE(outputFormatXmlv2);
+        TEST_CASE(outputFormatXmlv3);
+        TEST_CASE(outputFormatOther);
+        TEST_CASE(outputFormatImplicitPlist);
+        TEST_CASE(outputFormatImplicitXml);
+        TEST_CASE(outputFormatOverridePlist);
+        TEST_CASE(outputFormatMixed1);
+        TEST_CASE(outputFormatMixed2);
+        TEST_CASE(outputFormatMixed3);
+        TEST_CASE(premiumOptions1);
+        TEST_CASE(premiumOptions2);
+        TEST_CASE(premiumOptions3);
+        TEST_CASE(premiumOptions4);
+        TEST_CASE(premiumOptions5);
+        TEST_CASE(premiumOptionsAll);
+        TEST_CASE(premiumOptionsMetrics);
+        TEST_CASE(premiumOptionsCertCIntPrecision);
+        TEST_CASE(premiumOptionsLicenseFile);
+        TEST_CASE(premiumOptionsInvalid1);
+        TEST_CASE(premiumOptionsInvalid2);
+        TEST_CASE(premiumSafety);
+        TEST_CASE(premiumDebugProgress);
+        TEST_CASE(reportProgress1);
+        TEST_CASE(reportProgress2);
+        TEST_CASE(reportProgress3);
+        TEST_CASE(reportProgress4);
+        TEST_CASE(reportProgress5);
         TEST_CASE(stdc99);
+        TEST_CASE(stdgnu17);
+        TEST_CASE(stdiso9899_1999);
         TEST_CASE(stdcpp11);
-        TEST_CASE(platform);
-        TEST_CASE(suppressionsOld); // TODO: Create and test real suppression file
+        TEST_CASE(stdgnupp23);
+        TEST_CASE(stdunknown1);
+        TEST_CASE(stdunknown2);
+        TEST_CASE(stdunknown3);
+        TEST_CASE(stdoverwrite1);
+        TEST_CASE(stdoverwrite2);
+        TEST_CASE(stdoverwrite3);
+        TEST_CASE(stdoverwrite4);
+        TEST_CASE(stdmulti1);
+        TEST_CASE(stdmulti2);
+        TEST_CASE(platformWin64);
+        TEST_CASE(platformWin32A);
+        TEST_CASE(platformWin32W);
+        TEST_CASE(platformUnix32);
+        TEST_CASE(platformUnix32Unsigned);
+        TEST_CASE(platformUnix64);
+        TEST_CASE(platformUnix64Unsigned);
+        TEST_CASE(platformNative);
+        TEST_CASE(platformUnspecified);
+        TEST_CASE(platformPlatformFile);
+        TEST_CASE(platformUnknown);
+        TEST_CASE(platformEmpty);
+        TEST_CASE(plistEmpty);
+        TEST_CASE(plistDoesNotExist);
+        TEST_CASE(suppressionsOld);
         TEST_CASE(suppressions);
-        TEST_CASE(suppressionsNoFile);
+        TEST_CASE(suppressionsNoFile1);
+        TEST_CASE(suppressionsNoFile2);
+        TEST_CASE(suppressionsNoFile3);
         TEST_CASE(suppressionSingle);
         TEST_CASE(suppressionSingleFile);
         TEST_CASE(suppressionTwo);
@@ -117,6 +308,15 @@ class TestCmdlineParser : public TestFixture {
         TEST_CASE(templatesGcc);
         TEST_CASE(templatesVs);
         TEST_CASE(templatesEdit);
+        TEST_CASE(templatesCppcheck1);
+        TEST_CASE(templatesDaca2);
+        TEST_CASE(templatesSelfcheck);
+        TEST_CASE(templatesSimple);
+        TEST_CASE(templatesNoPlaceholder);
+        TEST_CASE(templateFormatInvalid);
+        TEST_CASE(templateFormatEmpty);
+        TEST_CASE(templateLocationInvalid);
+        TEST_CASE(templateLocationEmpty);
         TEST_CASE(xml);
         TEST_CASE(xmlver2);
         TEST_CASE(xmlver2both);
@@ -124,20 +324,192 @@ class TestCmdlineParser : public TestFixture {
         TEST_CASE(xmlverunknown);
         TEST_CASE(xmlverinvalid);
         TEST_CASE(doc);
-        TEST_CASE(showtime);
-        TEST_CASE(errorlist1);
-        TEST_CASE(errorlistverbose1);
-        TEST_CASE(errorlistverbose2);
+        TEST_CASE(docExclusive);
+        TEST_CASE(showtimeSummary);
+        TEST_CASE(showtimeFile);
+        TEST_CASE(showtimeFileTotal);
+        TEST_CASE(showtimeTop5);
+        TEST_CASE(showtimeTop5File);
+        TEST_CASE(showtimeTop5Summary);
+        TEST_CASE(showtimeNone);
+        TEST_CASE(showtimeEmpty);
+        TEST_CASE(showtimeInvalid);
+        TEST_CASE(errorlist);
+        TEST_CASE(errorlistWithCfg);
+        TEST_CASE(errorlistExclusive);
         TEST_CASE(ignorepathsnopath);
-
-        // Disabling these tests since they use relative paths to the
-        // testrunner executable.
-        //TEST_CASE(ignorepaths1);
-        //TEST_CASE(ignorepaths2);
-        //TEST_CASE(ignorepaths3);
-        //TEST_CASE(ignorepaths4);
-        //TEST_CASE(ignorefilepaths1);
-        //TEST_CASE(ignorefilepaths2);
+#if defined(USE_WINDOWS_SEH) || defined(USE_UNIX_SIGNAL_HANDLING)
+        TEST_CASE(exceptionhandling);
+        TEST_CASE(exceptionhandling2);
+        TEST_CASE(exceptionhandling3);
+        TEST_CASE(exceptionhandlingInvalid);
+        TEST_CASE(exceptionhandlingInvalid2);
+#else
+        TEST_CASE(exceptionhandlingNotSupported);
+        TEST_CASE(exceptionhandlingNotSupported2);
+#endif
+        TEST_CASE(clang);
+        TEST_CASE(clangCustom);
+        TEST_CASE(clangInvalid);
+        TEST_CASE(valueFlowMaxIterations);
+        TEST_CASE(valueFlowMaxIterations2);
+        TEST_CASE(valueFlowMaxIterationsInvalid);
+        TEST_CASE(valueFlowMaxIterationsInvalid2);
+        TEST_CASE(valueFlowMaxIterationsInvalid3);
+        TEST_CASE(checksMaxTime);
+        TEST_CASE(checksMaxTime2);
+        TEST_CASE(checksMaxTimeInvalid);
+#ifdef HAS_THREADING_MODEL_FORK
+        TEST_CASE(loadAverage);
+        TEST_CASE(loadAverage2);
+        TEST_CASE(loadAverageInvalid);
+#else
+        TEST_CASE(loadAverageNotSupported);
+#endif
+        TEST_CASE(maxCtuDepth);
+        TEST_CASE(maxCtuDepth2);
+        TEST_CASE(maxCtuDepthLimit);
+        TEST_CASE(maxCtuDepthInvalid);
+        TEST_CASE(performanceValueflowMaxTime);
+        TEST_CASE(performanceValueflowMaxTimeInvalid);
+        TEST_CASE(performanceValueFlowMaxIfCount);
+        TEST_CASE(performanceValueFlowMaxIfCountInvalid);
+        TEST_CASE(templateMaxTime);
+        TEST_CASE(templateMaxTimeInvalid);
+        TEST_CASE(templateMaxTimeInvalid2);
+        TEST_CASE(typedefMaxTime);
+        TEST_CASE(typedefMaxTimeInvalid);
+        TEST_CASE(typedefMaxTimeInvalid2);
+        TEST_CASE(templateMaxTime);
+        TEST_CASE(templateMaxTime);
+        TEST_CASE(project);
+        TEST_CASE(projectMultiple);
+        TEST_CASE(projectAndSource);
+        TEST_CASE(projectEmpty);
+        TEST_CASE(projectMissing);
+        TEST_CASE(projectNoPaths);
+        TEST_CASE(addon);
+        TEST_CASE(addonMissing);
+#ifdef HAVE_RULES
+        TEST_CASE(rule);
+        TEST_CASE(ruleMissingPattern);
+        TEST_CASE(ruleInvalidPattern);
+#else
+        TEST_CASE(ruleNotSupported);
+#endif
+#ifdef HAVE_RULES
+        TEST_CASE(ruleFileMulti);
+        TEST_CASE(ruleFileSingle);
+        TEST_CASE(ruleFileEmpty);
+        TEST_CASE(ruleFileMissing);
+        TEST_CASE(ruleFileInvalid);
+        TEST_CASE(ruleFileNoRoot);
+        TEST_CASE(ruleFileEmptyElements1);
+        TEST_CASE(ruleFileEmptyElements2);
+        TEST_CASE(ruleFileUnknownElement1);
+        TEST_CASE(ruleFileUnknownElement2);
+        TEST_CASE(ruleFileMissingTokenList);
+        TEST_CASE(ruleFileUnknownTokenList);
+        TEST_CASE(ruleFileMissingId);
+        TEST_CASE(ruleFileInvalidSeverity1);
+        TEST_CASE(ruleFileInvalidSeverity2);
+        TEST_CASE(ruleFileInvalidPattern);
+#else
+        TEST_CASE(ruleFileNotSupported);
+#endif
+        TEST_CASE(signedChar);
+        TEST_CASE(signedChar2);
+        TEST_CASE(unsignedChar);
+        TEST_CASE(unsignedChar2);
+        TEST_CASE(signedCharUnsignedChar);
+        TEST_CASE(library);
+        TEST_CASE(libraryMissing);
+        TEST_CASE(libraryMultiple);
+        TEST_CASE(libraryMultipleEmpty);
+        TEST_CASE(libraryMultipleEmpty2);
+        TEST_CASE(suppressXml);
+        TEST_CASE(suppressXmlEmpty);
+        TEST_CASE(suppressXmlMissing);
+        TEST_CASE(suppressXmlInvalid);
+        TEST_CASE(suppressXmlNoRoot);
+        TEST_CASE(executorDefault);
+        TEST_CASE(executorAuto);
+        TEST_CASE(executorAutoNoJobs);
+#if defined(HAS_THREADING_MODEL_THREAD)
+        TEST_CASE(executorThread);
+        TEST_CASE(executorThreadNoJobs);
+#else
+        TEST_CASE(executorThreadNotSupported);
+#endif
+#if defined(HAS_THREADING_MODEL_FORK)
+        TEST_CASE(executorProcess);
+        TEST_CASE(executorProcessNoJobs);
+#else
+        TEST_CASE(executorProcessNotSupported);
+#endif
+        TEST_CASE(checkLevelDefault);
+        TEST_CASE(checkLevelNormal);
+        TEST_CASE(checkLevelExhaustive);
+        TEST_CASE(checkLevelUnknown);
+        TEST_CASE(cppHeaderProbe);
+        TEST_CASE(cppHeaderProbe2);
+        TEST_CASE(noCppHeaderProbe);
+        TEST_CASE(noCppHeaderProbe2);
+        TEST_CASE(debugLookup);
+        TEST_CASE(debugLookupAll);
+        TEST_CASE(debugLookupAddon);
+        TEST_CASE(debugLookupConfig);
+        TEST_CASE(debugLookupLibrary);
+        TEST_CASE(debugLookupPlatform);
+        TEST_CASE(maxTemplateRecursion);
+        TEST_CASE(maxTemplateRecursionMissingCount);
+        TEST_CASE(emitDuplicates);
+        TEST_CASE(debugClangOutput);
+        TEST_CASE(debugXmlMultiple);
+        TEST_CASE(debugNormalXmlMultiple);
+        TEST_CASE(debugIgnore);
+        TEST_CASE(checkHeaders);
+        TEST_CASE(noCheckHeaders);
+        TEST_CASE(noCheckHeaders2);
+        TEST_CASE(filesdir);
+        TEST_CASE(checkUnusedTemplates);
+        TEST_CASE(noCheckUnusedTemplates);
+        TEST_CASE(noCheckUnusedTemplates);
+        TEST_CASE(clangTidy);
+        TEST_CASE(clangTidyCustom);
+        TEST_CASE(projectConfigurationNoProject);
+        TEST_CASE(projectConfigurationEmpty);
+        TEST_CASE(analyzeAllVsConfigs);
+        TEST_CASE(noAnalyzeAllVsConfigs);
+        TEST_CASE(noAnalyzeAllVsConfigs2);
+        TEST_CASE(debugSymdb);
+        TEST_CASE(debugAst);
+        TEST_CASE(debugValueflow);
+        TEST_CASE(debugNormal);
+        TEST_CASE(debugNormalVerbose);
+        TEST_CASE(debug);
+        TEST_CASE(debugVerbose);
+        TEST_CASE(safety);
+        TEST_CASE(safetyOverride);
+        TEST_CASE(noSafety);
+        TEST_CASE(noSafetyOverride);
+        TEST_CASE(debugAnalyzerinfo);
+
+        TEST_CASE(ignorepaths1);
+        TEST_CASE(ignorepaths2);
+        TEST_CASE(ignorepaths3);
+        TEST_CASE(ignorepaths4);
+        TEST_CASE(ignorefilepaths1);
+        TEST_CASE(ignorefilepaths2);
+        TEST_CASE(ignorefilepaths3);
+        TEST_CASE(ignorefilepaths4);
+        TEST_CASE(ignorefilepaths5);
+        TEST_CASE(ignorefilepaths6);
+        TEST_CASE(ignorefilepaths7);
+        TEST_CASE(ignorefilepaths8);
+        TEST_CASE(ignorefilepaths9);
+
+        TEST_CASE(nonexistentpath);
 
         TEST_CASE(checkconfig);
         TEST_CASE(unknownParam);
@@ -147,898 +519,3240 @@ class TestCmdlineParser : public TestFixture {
         TEST_CASE(undefs_noarg3);
         TEST_CASE(undefs);
         TEST_CASE(undefs2);
-    }
 
+        TEST_CASE(cppcheckBuildDirExistent);
+        TEST_CASE(cppcheckBuildDirNonExistent);
+        TEST_CASE(cppcheckBuildDirEmpty);
+        TEST_CASE(cppcheckBuildDirMultiple);
+        TEST_CASE(noCppcheckBuildDir);
+        TEST_CASE(noCppcheckBuildDir2);
+
+        TEST_CASE(invalidCppcheckCfg);
+
+        TEST_CASE(reportTypeAutosar);
+        TEST_CASE(reportTypeCertCpp);
+        TEST_CASE(reportTypeCertC);
+        TEST_CASE(reportTypeMisraC2012);
+        TEST_CASE(reportTypeMisraC2023);
+        TEST_CASE(reportTypeMisraC2025);
+        TEST_CASE(reportTypeMisraCpp2008);
+        TEST_CASE(reportTypeMisraCpp2023);
+        TEST_CASE(invalidReportType);
+        TEST_CASE(defaultReportType);
+    }
 
     void nooptions() {
         REDIRECT;
         const char * const argv[] = {"cppcheck"};
-        CmdLineParser parser(&settings);
-        ASSERT(parser.parseFromArgs(1, argv));
-        ASSERT_EQUALS(true, parser.getShowHelp());
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
+        ASSERT(startsWith(logger->str(), "Cppcheck - A tool for static C/C++ code analysis"));
+    }
+
+    void nooptionsWithCfg() {
+        REDIRECT;
+        ScopedFile file(Path::join(Path::getPathFromFilename(Path::getCurrentExecutablePath("")), "cppcheck.cfg"),
+                        "{\n"
+                        "\"productName\": \"Cppcheck Premium\","
+                        "\"manualUrl\": \"https://docs.notcppcheck.com/manual.pdf\""
+                        "}\n");
+        const char * const argv[] = {"cppcheck"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
+        ASSERT_EQUALS(1, settings->settingsFiles.size());
+        ASSERT_EQUALS(file.path(), *settings->settingsFiles.cbegin());
+        const std::string log_str = logger->str();
+        ASSERT_MSG(startsWith(log_str, "Cppcheck - A tool for static C/C++ code analysis"), "header");
+        ASSERT_MSG(log_str.find("https://docs.notcppcheck.com/manual.pdf") != std::string::npos, "help url");
+    }
+
+    void nooptionsWithInvalidCfg() {
+        REDIRECT;
+        ScopedFile file(Path::join(Path::getPathFromFilename(Path::getCurrentExecutablePath("")), "cppcheck.cfg"),
+                        "{\n");
+        const char * const argv[] = {"cppcheck"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: could not load cppcheck.cfg - not a valid JSON - syntax error at line 2 near: \n", logger->str());
     }
 
     void helpshort() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-h"};
-        CmdLineParser parser(&settings);
-        ASSERT(parser.parseFromArgs(2, argv));
-        ASSERT_EQUALS(true, parser.getShowHelp());
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
+        ASSERT(startsWith(logger->str(), "Cppcheck - A tool for static C/C++ code analysis"));
+    }
+
+    void helpshortExclusive() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--library=missing", "-h"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
+        ASSERT(startsWith(logger->str(), "Cppcheck - A tool for static C/C++ code analysis"));
+    }
+
+    void helpshortWithCfg() {
+        REDIRECT;
+        ScopedFile file(Path::join(Path::getPathFromFilename(Path::getCurrentExecutablePath("")), "cppcheck.cfg"),
+                        "{\n"
+                        "\"productName\": \"Cppcheck Premium\","
+                        "\"manualUrl\": \"https://docs.notcppcheck.com/manual.pdf\""
+                        "}\n");
+        const char * const argv[] = {"cppcheck", "-h"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
+        ASSERT_EQUALS(1, settings->settingsFiles.size());
+        ASSERT_EQUALS(file.path(), *settings->settingsFiles.cbegin());
+        const std::string log_str = logger->str();
+        ASSERT_MSG(startsWith(log_str, "Cppcheck - A tool for static C/C++ code analysis"), "header");
+        ASSERT_MSG(log_str.find("https://docs.notcppcheck.com/manual.pdf") != std::string::npos, "help url");
     }
 
     void helplong() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--help"};
-        CmdLineParser parser(&settings);
-        ASSERT(parser.parseFromArgs(2, argv));
-        ASSERT_EQUALS(true, parser.getShowHelp());
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
+        ASSERT(startsWith(logger->str(), "Cppcheck - A tool for static C/C++ code analysis"));
+    }
+
+    void helplongExclusive() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--library=missing", "--help"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
+        ASSERT(startsWith(logger->str(), "Cppcheck - A tool for static C/C++ code analysis"));
+    }
+
+    void helplongWithCfg() {
+        REDIRECT;
+        ScopedFile file(Path::join(Path::getPathFromFilename(Path::getCurrentExecutablePath("")), "cppcheck.cfg"),
+                        "{\n"
+                        "\"productName\": \"Cppcheck Premium\","
+                        "\"manualUrl\": \"https://docs.notcppcheck.com/manual.pdf\""
+                        "}\n");
+        const char * const argv[] = {"cppcheck", "--help"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
+        ASSERT_EQUALS(1, settings->settingsFiles.size());
+        ASSERT_EQUALS(file.path(), *settings->settingsFiles.cbegin());
+        const std::string log_str = logger->str();
+        ASSERT_MSG(startsWith(log_str, "Cppcheck - A tool for static C/C++ code analysis"), "header");
+        ASSERT_MSG(log_str.find("https://docs.notcppcheck.com/manual.pdf") != std::string::npos, "help url");
+    }
+
+    void version() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--version"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
+        ASSERT(logger->str().compare(0, 11, "Cppcheck 2.") == 0);
     }
 
-    void showversion() {
+    void versionWithCfg() {
         REDIRECT;
+        ScopedFile file(Path::join(Path::getPathFromFilename(Path::getCurrentExecutablePath("")), "cppcheck.cfg"),
+                        "{\n"
+                        "\"productName\": \"The Product\""
+                        "}\n");
         const char * const argv[] = {"cppcheck", "--version"};
-        CmdLineParser parser(&settings);
-        ASSERT(parser.parseFromArgs(2, argv));
-        ASSERT_EQUALS(true, parser.getShowVersion());
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
+        ASSERT_EQUALS(1, settings->settingsFiles.size());
+        ASSERT_EQUALS(file.path(), *settings->settingsFiles.cbegin());
+        ASSERT_EQUALS("The Product\n", logger->str()); // TODO: include version?
+    }
+
+    // TODO: test --version with extraVersion
+
+    void versionExclusive() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--library=missing", "--version"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
+        ASSERT(logger->str().compare(0, 11, "Cppcheck 2.") == 0);
+    }
+
+    void checkVersionCorrect() {
+        REDIRECT;
+        const std::string currentVersion = parser->getVersion();
+        const std::string checkVersion = "--check-version=" + currentVersion;
+        const char * const argv[] = {"cppcheck", checkVersion.c_str(), "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+    }
+
+    void checkVersionIncorrect() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--check-version=Cppcheck 2.0", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: --check-version check failed. Aborting.\n", logger->str());
     }
 
     void onefile() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "file.cpp"};
-        CmdLineParser parser(&settings);
-        ASSERT(parser.parseFromArgs(2, argv));
-        ASSERT_EQUALS(1, (int)parser.getPathNames().size());
-        ASSERT_EQUALS("file.cpp", parser.getPathNames().at(0));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(1, parser->mPathNames.size());
+        ASSERT_EQUALS("file.cpp", parser->mPathNames[0]);
     }
 
     void onepath() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "src"};
-        CmdLineParser parser(&settings);
-        ASSERT(parser.parseFromArgs(2, argv));
-        ASSERT_EQUALS(1, (int)parser.getPathNames().size());
-        ASSERT_EQUALS("src", parser.getPathNames().at(0));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(1, parser->mPathNames.size());
+        ASSERT_EQUALS("src", parser->mPathNames[0]);
     }
 
     void optionwithoutfile() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-v"};
-        CmdLineParser parser(&settings);
-        ASSERT_EQUALS(false, parser.parseFromArgs(2, argv));
-        ASSERT_EQUALS(0, (int)parser.getPathNames().size());
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS(0, parser->mPathNames.size());
+        ASSERT_EQUALS("cppcheck: error: no C or C++ source files found.\n", logger->str());
     }
 
     void verboseshort() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-v", "file.cpp"};
-        settings.verbose = false;
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT_EQUALS(true, settings.verbose);
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->verbose);
     }
 
     void verboselong() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--verbose", "file.cpp"};
-        settings.verbose = false;
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT_EQUALS(true, settings.verbose);
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->verbose);
     }
 
     void debugSimplified() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--debug-simplified", "file.cpp"};
-        settings.debugSimplified = false;
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT_EQUALS(true, settings.debugSimplified);
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->debugSimplified);
     }
 
     void debugwarnings() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--debug-warnings", "file.cpp"};
-        settings.debugwarnings = false;
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT_EQUALS(true, settings.debugwarnings);
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->debugwarnings);
     }
 
     void forceshort() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-f", "file.cpp"};
-        settings.force = false;
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT_EQUALS(true, settings.force);
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->force);
     }
 
     void forcelong() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--force", "file.cpp"};
-        settings.force = false;
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT_EQUALS(true, settings.force);
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->force);
     }
 
-    void relativePaths() {
+    void relativePaths1() {
         REDIRECT;
-        settings.relativePaths = false;
-
-        const char * const argvs[] = {"cppcheck", "-rp", "file.cpp"};
-        ASSERT(defParser.parseFromArgs(3, argvs));
-        ASSERT_EQUALS(true, settings.relativePaths);
-
-        settings.relativePaths = false;
-
-        const char * const argvl[] = {"cppcheck", "--relative-paths", "file.cpp"};
-        ASSERT(defParser.parseFromArgs(3, argvl));
-        ASSERT_EQUALS(true, settings.relativePaths);
-
-        settings.relativePaths = false;
-        settings.basePaths.clear();
+        const char * const argv[] = {"cppcheck", "-rp", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->relativePaths);
+    }
 
-        const char * const argvsp[] = {"cppcheck", "-rp=C:/foo;C:\\bar", "file.cpp"};
-        ASSERT(defParser.parseFromArgs(3, argvsp));
-        ASSERT_EQUALS(true, settings.relativePaths);
-        ASSERT_EQUALS(2, settings.basePaths.size());
-        ASSERT_EQUALS("C:/foo", settings.basePaths[0]);
-        ASSERT_EQUALS("C:/bar", settings.basePaths[1]);
+    void relativePaths2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--relative-paths", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->relativePaths);
+    }
 
-        settings.relativePaths = false;
-        settings.basePaths.clear();
+    void relativePaths3() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-rp=C:/foo;C:\\bar", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->relativePaths);
+        ASSERT_EQUALS(2, settings->basePaths.size());
+        ASSERT_EQUALS("C:/foo", settings->basePaths[0]);
+        ASSERT_EQUALS("C:/bar", settings->basePaths[1]);
+    }
 
-        const char * const argvlp[] = {"cppcheck", "--relative-paths=C:/foo;C:\\bar", "file.cpp"};
-        ASSERT(defParser.parseFromArgs(3, argvlp));
-        ASSERT_EQUALS(true, settings.relativePaths);
-        ASSERT_EQUALS(2, settings.basePaths.size());
-        ASSERT_EQUALS("C:/foo", settings.basePaths[0]);
-        ASSERT_EQUALS("C:/bar", settings.basePaths[1]);
+    void relativePaths4() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--relative-paths=C:/foo;C:\\bar", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->relativePaths);
+        ASSERT_EQUALS(2, settings->basePaths.size());
+        ASSERT_EQUALS("C:/foo", settings->basePaths[0]);
+        ASSERT_EQUALS("C:/bar", settings->basePaths[1]);
     }
 
     void quietshort() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-q", "file.cpp"};
-        settings.quiet = false;
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT_EQUALS(true, settings.quiet);
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->quiet);
     }
 
     void quietlong() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--quiet", "file.cpp"};
-        settings.quiet = false;
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT_EQUALS(true, settings.quiet);
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->quiet);
     }
 
     void defines_noarg() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-D"};
         // Fails since -D has no param
-        ASSERT_EQUALS(false, defParser.parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '-D' is missing.\n", logger->str());
     }
 
     void defines_noarg2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-D", "-v", "file.cpp"};
         // Fails since -D has no param
-        ASSERT_EQUALS(false, defParser.parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '-D' is missing.\n", logger->str());
     }
 
     void defines_noarg3() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-D", "--quiet", "file.cpp"};
         // Fails since -D has no param
-        ASSERT_EQUALS(false, defParser.parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '-D' is missing.\n", logger->str());
     }
 
     void defines() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-D_WIN32", "file.cpp"};
-        settings.userDefines.clear();
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT_EQUALS("_WIN32=1", settings.userDefines);
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("_WIN32=1", settings->userDefines);
     }
 
     void defines2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-D_WIN32", "-DNODEBUG", "file.cpp"};
-        settings.userDefines.clear();;
-        ASSERT(defParser.parseFromArgs(4, argv));
-        ASSERT_EQUALS("_WIN32=1;NODEBUG=1", settings.userDefines);
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("_WIN32=1;NODEBUG=1", settings->userDefines);
     }
 
     void defines3() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-D", "DEBUG", "file.cpp"};
-        settings.userDefines.clear();
-        ASSERT(defParser.parseFromArgs(4, argv));
-        ASSERT_EQUALS("DEBUG=1", settings.userDefines);
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("DEBUG=1", settings->userDefines);
     }
 
     void defines4() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-DDEBUG=", "file.cpp"}; // #5137 - defining empty macro
-        settings.userDefines.clear();
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT_EQUALS("DEBUG=", settings.userDefines);
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("DEBUG=", settings->userDefines);
     }
 
-    void enforceLanguage() {
+    void enforceLanguage1() {
         REDIRECT;
-        {
-            const char * const argv[] = {"cppcheck", "file.cpp"};
-            settings.enforcedLang = Settings::None;
-            ASSERT(defParser.parseFromArgs(2, argv));
-            ASSERT_EQUALS(Settings::None, settings.enforcedLang);
-        }
-        {
-            const char * const argv[] = {"cppcheck", "-x", "c++", "file.cpp"};
-            settings.enforcedLang = Settings::None;
-            ASSERT(defParser.parseFromArgs(4, argv));
-            ASSERT_EQUALS(Settings::CPP, settings.enforcedLang);
-        }
-        {
-            const char * const argv[] = {"cppcheck", "-x"};
-            ASSERT(!defParser.parseFromArgs(2, argv));
-        }
-        {
-            const char * const argv[] = {"cppcheck", "-x", "--inconclusive", "file.cpp"};
-            ASSERT(!defParser.parseFromArgs(4, argv));
-        }
-        {
-            const char * const argv[] = {"cppcheck", "--language=c++", "file.cpp"};
-            settings.enforcedLang = Settings::None;
-            ASSERT(defParser.parseFromArgs(3, argv));
-            ASSERT_EQUALS(Settings::CPP, settings.enforcedLang);
-        }
-        {
-            const char * const argv[] = {"cppcheck", "--language=c", "file.cpp"};
-            settings.enforcedLang = Settings::None;
-            ASSERT(defParser.parseFromArgs(3, argv));
-            ASSERT_EQUALS(Settings::C, settings.enforcedLang);
-        }
-        {
-            const char * const argv[] = {"cppcheck", "--language=unknownLanguage", "file.cpp"};
-            ASSERT(!defParser.parseFromArgs(3, argv));
-        }
+        const char * const argv[] = {"cppcheck", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(Standards::Language::None, parser->mEnforcedLang);
+    }
+
+    void enforceLanguage2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-x", "c++", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(Standards::Language::CPP, parser->mEnforcedLang);
+    }
+
+    void enforceLanguage3() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-x"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: no language given to '-x' option.\n", logger->str());
+    }
+
+    void enforceLanguage4() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-x", "--inconclusive", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: no language given to '-x' option.\n", logger->str());
+    }
+
+    void enforceLanguage5() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--language=c++", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(Standards::Language::CPP, parser->mEnforcedLang);
+    }
+
+    void enforceLanguage6() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--language=c", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(Standards::Language::C, parser->mEnforcedLang);
+    }
+
+    void enforceLanguage7() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--language=unknownLanguage", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unknown language 'unknownLanguage' enforced.\n", logger->str());
     }
 
     void includesnopath() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-I"};
         // Fails since -I has no param
-        ASSERT_EQUALS(false, defParser.parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '-I' is missing.\n", logger->str());
     }
 
     void includes() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-I", "include", "file.cpp"};
-        settings.includePaths.clear();
-        ASSERT(defParser.parseFromArgs(4, argv));
-        ASSERT_EQUALS("include/", settings.includePaths.front());
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("include/", settings->includePaths.front());
     }
 
     void includesslash() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-I", "include/", "file.cpp"};
-        settings.includePaths.clear();
-        ASSERT(defParser.parseFromArgs(4, argv));
-        ASSERT_EQUALS("include/", settings.includePaths.front());
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("include/", settings->includePaths.front());
     }
 
     void includesbackslash() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-I", "include\\", "file.cpp"};
-        settings.includePaths.clear();
-        ASSERT(defParser.parseFromArgs(4, argv));
-        ASSERT_EQUALS("include/", settings.includePaths.front());
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("include/", settings->includePaths.front());
     }
 
     void includesnospace() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-Iinclude", "file.cpp"};
-        settings.includePaths.clear();
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT_EQUALS("include/", settings.includePaths.front());
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("include/", settings->includePaths.front());
     }
 
     void includes2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-I", "include/", "-I", "framework/", "file.cpp"};
-        settings.includePaths.clear();
-        ASSERT(defParser.parseFromArgs(6, argv));
-        ASSERT_EQUALS("include/", settings.includePaths.front());
-        settings.includePaths.pop_front();
-        ASSERT_EQUALS("framework/", settings.includePaths.front());
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("include/", settings->includePaths.front());
+        settings->includePaths.pop_front();
+        ASSERT_EQUALS("framework/", settings->includePaths.front());
     }
 
     void includesFile() {
+        REDIRECT;
+        ScopedFile file("includes.txt",
+                        "path/sub\n"
+                        "path2/sub1\n");
+        const char * const argv[] = {"cppcheck", "--includes-file=includes.txt", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(2, settings->includePaths.size());
+        auto it = settings->includePaths.cbegin();
+        ASSERT_EQUALS("path/sub/", *it++);
+        ASSERT_EQUALS("path2/sub1/", *it);
+    }
+
+    void includesFileNoFile() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--includes-file=fileThatDoesNotExist.txt", "file.cpp"};
-        settings.includePaths.clear();
-        ASSERT_EQUALS(false, defParser.parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unable to open includes file at 'fileThatDoesNotExist.txt'\n", logger->str());
     }
 
     void configExcludesFile() {
+        REDIRECT;
+        ScopedFile file("excludes.txt",
+                        "path/sub\n"
+                        "path2/sub1\n");
+        const char * const argv[] = {"cppcheck", "--config-excludes-file=excludes.txt", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(2, settings->configExcludePaths.size());
+        auto it = settings->configExcludePaths.cbegin();
+        ASSERT_EQUALS("path/sub/", *it++);
+        ASSERT_EQUALS("path2/sub1/", *it);
+    }
+
+    void configExcludesFileNoFile() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--config-excludes-file=fileThatDoesNotExist.txt", "file.cpp"};
-        settings.includePaths.clear();
-        ASSERT_EQUALS(false, defParser.parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unable to open config excludes file at 'fileThatDoesNotExist.txt'\n", logger->str());
     }
 
     void enabledAll() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--enable=all", "file.cpp"};
-        settings = Settings();
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT(settings.isEnabled(Settings::STYLE));
-        ASSERT(settings.isEnabled(Settings::WARNING));
-        ASSERT(settings.isEnabled(Settings::UNUSED_FUNCTION));
-        ASSERT(settings.isEnabled(Settings::MISSING_INCLUDE));
-        ASSERT(!settings.isEnabled(Settings::INTERNAL));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->severity.isEnabled(Severity::error));
+        ASSERT(settings->severity.isEnabled(Severity::style));
+        ASSERT(settings->severity.isEnabled(Severity::warning));
+        ASSERT(settings->checks.isEnabled(Checks::unusedFunction));
+        ASSERT(settings->checks.isEnabled(Checks::missingInclude));
+        ASSERT(!settings->checks.isEnabled(Checks::internalCheck));
     }
 
     void enabledStyle() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--enable=style", "file.cpp"};
-        settings = Settings();
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT(settings.isEnabled(Settings::STYLE));
-        ASSERT(settings.isEnabled(Settings::WARNING));
-        ASSERT(settings.isEnabled(Settings::PERFORMANCE));
-        ASSERT(settings.isEnabled(Settings::PORTABILITY));
-        ASSERT(!settings.isEnabled(Settings::UNUSED_FUNCTION));
-        ASSERT(!settings.isEnabled(Settings::MISSING_INCLUDE));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->severity.isEnabled(Severity::error));
+        ASSERT(settings->severity.isEnabled(Severity::style));
+        ASSERT(settings->severity.isEnabled(Severity::warning));
+        ASSERT(settings->severity.isEnabled(Severity::performance));
+        ASSERT(settings->severity.isEnabled(Severity::portability));
+        ASSERT(!settings->checks.isEnabled(Checks::unusedFunction));
+        ASSERT(!settings->checks.isEnabled(Checks::internalCheck));
     }
 
     void enabledPerformance() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--enable=performance", "file.cpp"};
-        settings = Settings();
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT(!settings.isEnabled(Settings::STYLE));
-        ASSERT(!settings.isEnabled(Settings::WARNING));
-        ASSERT(settings.isEnabled(Settings::PERFORMANCE));
-        ASSERT(!settings.isEnabled(Settings::PORTABILITY));
-        ASSERT(!settings.isEnabled(Settings::UNUSED_FUNCTION));
-        ASSERT(!settings.isEnabled(Settings::MISSING_INCLUDE));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->severity.isEnabled(Severity::error));
+        ASSERT(!settings->severity.isEnabled(Severity::style));
+        ASSERT(!settings->severity.isEnabled(Severity::warning));
+        ASSERT(settings->severity.isEnabled(Severity::performance));
+        ASSERT(!settings->severity.isEnabled(Severity::portability));
+        ASSERT(!settings->checks.isEnabled(Checks::unusedFunction));
+        ASSERT(!settings->checks.isEnabled(Checks::missingInclude));
     }
 
     void enabledPortability() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--enable=portability", "file.cpp"};
-        settings = Settings();
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT(!settings.isEnabled(Settings::STYLE));
-        ASSERT(!settings.isEnabled(Settings::WARNING));
-        ASSERT(!settings.isEnabled(Settings::PERFORMANCE));
-        ASSERT(settings.isEnabled(Settings::PORTABILITY));
-        ASSERT(!settings.isEnabled(Settings::UNUSED_FUNCTION));
-        ASSERT(!settings.isEnabled(Settings::MISSING_INCLUDE));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->severity.isEnabled(Severity::error));
+        ASSERT(!settings->severity.isEnabled(Severity::style));
+        ASSERT(!settings->severity.isEnabled(Severity::warning));
+        ASSERT(!settings->severity.isEnabled(Severity::performance));
+        ASSERT(settings->severity.isEnabled(Severity::portability));
+        ASSERT(!settings->checks.isEnabled(Checks::unusedFunction));
+        ASSERT(!settings->checks.isEnabled(Checks::missingInclude));
+    }
+
+    void enabledInformation() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--enable=information", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->severity.isEnabled(Severity::error));
+        ASSERT(settings->severity.isEnabled(Severity::information));
+        ASSERT(!settings->checks.isEnabled(Checks::missingInclude));
     }
 
     void enabledUnusedFunction() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--enable=unusedFunction", "file.cpp"};
-        settings = Settings();
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT(settings.isEnabled(Settings::UNUSED_FUNCTION));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->severity.isEnabled(Severity::error));
+        ASSERT(settings->checks.isEnabled(Checks::unusedFunction));
     }
 
     void enabledMissingInclude() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--enable=missingInclude", "file.cpp"};
-        settings = Settings();
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT(settings.isEnabled(Settings::MISSING_INCLUDE));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->severity.isEnabled(Severity::error));
+        ASSERT(settings->checks.isEnabled(Checks::missingInclude));
+    }
+
+    void disabledMissingIncludeWithInformation() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--disable=missingInclude", "--enable=information", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->severity.isEnabled(Severity::error));
+        ASSERT(settings->severity.isEnabled(Severity::information));
+        ASSERT(!settings->checks.isEnabled(Checks::missingInclude));
+        ASSERT_EQUALS("", logger->str());
+    }
+
+    void enabledMissingIncludeWithInformation() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--enable=information", "--enable=missingInclude", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->severity.isEnabled(Severity::error));
+        ASSERT(settings->severity.isEnabled(Severity::information));
+        ASSERT(settings->checks.isEnabled(Checks::missingInclude));
+        ASSERT_EQUALS("", logger->str());
+    }
+
+    void enabledMissingIncludeWithInformationReverseOrder() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--enable=missingInclude", "--enable=information", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->severity.isEnabled(Severity::error));
+        ASSERT(settings->severity.isEnabled(Severity::information));
+        ASSERT(settings->checks.isEnabled(Checks::missingInclude));
+        ASSERT_EQUALS("", logger->str());
     }
 
 #ifdef CHECK_INTERNAL
     void enabledInternal() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--enable=internal", "file.cpp"};
-        settings = Settings();
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT(settings.isEnabled(Settings::INTERNAL));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->severity.isEnabled(Severity::error));
+        ASSERT(settings->checks.isEnabled(Checks::internalCheck));
     }
 #endif
 
     void enabledMultiple() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--enable=missingInclude,portability,warning", "file.cpp"};
-        settings = Settings();
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT(!settings.isEnabled(Settings::STYLE));
-        ASSERT(settings.isEnabled(Settings::WARNING));
-        ASSERT(!settings.isEnabled(Settings::PERFORMANCE));
-        ASSERT(settings.isEnabled(Settings::PORTABILITY));
-        ASSERT(!settings.isEnabled(Settings::UNUSED_FUNCTION));
-        ASSERT(settings.isEnabled(Settings::MISSING_INCLUDE));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->severity.isEnabled(Severity::error));
+        ASSERT(!settings->severity.isEnabled(Severity::style));
+        ASSERT(settings->severity.isEnabled(Severity::warning));
+        ASSERT(!settings->severity.isEnabled(Severity::performance));
+        ASSERT(settings->severity.isEnabled(Severity::portability));
+        ASSERT(!settings->checks.isEnabled(Checks::unusedFunction));
+        ASSERT(settings->checks.isEnabled(Checks::missingInclude));
+    }
+
+    void enabledInvalid() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--enable=warning,missingIncludeSystem,style", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: --enable parameter with the unknown name 'missingIncludeSystem'\n", logger->str());
+    }
+
+    void enabledError() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--enable=error", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: --enable parameter with the unknown name 'error'\n", logger->str());
+    }
+
+    void enabledEmpty() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--enable=", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: --enable parameter is empty\n", logger->str());
+    }
+
+
+    void disableAll() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--enable=all", "--disable=all", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::error));
+        ASSERT_EQUALS(false, settings->severity.isEnabled(Severity::warning));
+        ASSERT_EQUALS(false, settings->severity.isEnabled(Severity::style));
+        ASSERT_EQUALS(false, settings->severity.isEnabled(Severity::performance));
+        ASSERT_EQUALS(false, settings->severity.isEnabled(Severity::portability));
+        ASSERT_EQUALS(false, settings->severity.isEnabled(Severity::debug));
+        ASSERT_EQUALS(false, settings->checks.isEnabled(Checks::unusedFunction));
+        ASSERT_EQUALS(false, settings->checks.isEnabled(Checks::missingInclude));
+        ASSERT_EQUALS(false, settings->checks.isEnabled(Checks::internalCheck));
+    }
+
+    void disableMultiple() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--enable=all", "--disable=style", "--disable=unusedFunction", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::error));
+        ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::warning));
+        ASSERT_EQUALS(false, settings->severity.isEnabled(Severity::style));
+        ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::performance));
+        ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::portability));
+        ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::debug));
+        ASSERT_EQUALS(false, settings->checks.isEnabled(Checks::unusedFunction));
+        ASSERT_EQUALS(true, settings->checks.isEnabled(Checks::missingInclude));
+        ASSERT_EQUALS(false, settings->checks.isEnabled(Checks::internalCheck));
+    }
+
+    // make sure the implied "style" checks are not added when "--enable=style" is specified
+    void disableStylePartial() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--enable=style", "--disable=performance", "--enable=unusedFunction", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::error));
+        ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::warning));
+        ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::style));
+        ASSERT_EQUALS(false, settings->severity.isEnabled(Severity::performance));
+        ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::portability));
+        ASSERT_EQUALS(false, settings->severity.isEnabled(Severity::debug));
+        ASSERT_EQUALS(true, settings->checks.isEnabled(Checks::unusedFunction));
+        ASSERT_EQUALS(false, settings->checks.isEnabled(Checks::missingInclude));
+        ASSERT_EQUALS(false, settings->checks.isEnabled(Checks::internalCheck));
+    }
+
+    void disableInformationPartial() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--enable=information", "--disable=missingInclude", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->severity.isEnabled(Severity::information));
+        ASSERT(!settings->checks.isEnabled(Checks::missingInclude));
+        ASSERT_EQUALS("", logger->str());
+    }
+
+    void disableInformationPartial2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--enable=missingInclude", "--disable=information", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(!settings->severity.isEnabled(Severity::information));
+        ASSERT(settings->checks.isEnabled(Checks::missingInclude));
+    }
+
+    void disableInvalid() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--disable=leaks", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: --disable parameter with the unknown name 'leaks'\n", logger->str());
+    }
+
+    void disableError() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--disable=error", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: --disable parameter with the unknown name 'error'\n", logger->str());
+    }
+
+    void disableEmpty() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--disable=", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: --disable parameter is empty\n", logger->str());
     }
 
     void inconclusive() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--inconclusive"};
-        settings.inconclusive = false;
-        ASSERT(defParser.parseFromArgs(2, argv));
-        ASSERT_EQUALS(true, settings.inconclusive);
+        const char * const argv[] = {"cppcheck", "--inconclusive", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->certainty.isEnabled(Certainty::inconclusive));
     }
 
     void errorExitcode() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--error-exitcode=5", "file.cpp"};
-        settings.exitCode = 0;
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT_EQUALS(5, settings.exitCode);
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(5, settings->exitCode);
     }
 
     void errorExitcodeMissing() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--error-exitcode=", "file.cpp"};
-        settings.exitCode = 0;
         // Fails since exit code not given
-        ASSERT_EQUALS(false, defParser.parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--error-exitcode=' is not valid - not an integer.\n", logger->str());
     }
 
     void errorExitcodeStr() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--error-exitcode=foo", "file.cpp"};
-        settings.exitCode = 0;
         // Fails since invalid exit code
-        ASSERT_EQUALS(false, defParser.parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--error-exitcode=' is not valid - not an integer.\n", logger->str());
     }
 
     void exitcodeSuppressionsOld() {
-        // TODO: Fails since cannot open the file
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--exitcode-suppressions", "suppr.txt", "file.cpp"};
-        settings.exitCode = 0;
-        TODO_ASSERT_EQUALS(true, false, defParser.parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--exitcode-suppressions\".\n", logger->str());
     }
 
     void exitcodeSuppressions() {
-        // TODO: Fails since cannot open the file
         REDIRECT;
+        ScopedFile file("suppr.txt",
+                        "uninitvar\n"
+                        "unusedFunction\n");
         const char * const argv[] = {"cppcheck", "--exitcode-suppressions=suppr.txt", "file.cpp"};
-        settings.exitCode = 0;
-        TODO_ASSERT_EQUALS(true, false, defParser.parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        const auto supprsNofail = supprs->nofail.getSuppressions();
+        ASSERT_EQUALS(2, supprsNofail.size());
+        auto it = supprsNofail.cbegin();
+        ASSERT_EQUALS("uninitvar", (it++)->errorId);
+        ASSERT_EQUALS("unusedFunction", it->errorId);
     }
 
     void exitcodeSuppressionsNoFile() {
-        // TODO: Fails since cannot open the file
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--exitcode-suppressions", "file.cpp"};
-        settings.exitCode = 0;
-        TODO_ASSERT_EQUALS(true, false, defParser.parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--exitcode-suppressions\".\n", logger->str());
+    }
+
+    void fileFilterFileWithDetailsSimplifiedPath() const {
+        // match against simplified path
+        const std::vector<std::string> fileFilters{"m1.c"};
+        const std::list<FileWithDetails> filesResolved{ FileWithDetails("./m1.c", Standards::Language::C, 123) };
+        const std::list<FileWithDetails> files = CmdLineParser::filterFiles(fileFilters, filesResolved);
+        ASSERT_EQUALS(1U, files.size());
+    }
+
+    void fileFilterFileWithDetailsCase() {
+        // in windows, paths are case insensitive
+        const std::vector<std::string> fileFilters{"m1.c"};
+        const std::list<FileWithDetails> filesResolved{ FileWithDetails("M1.C", Standards::Language::C, 123) };
+        const std::list<FileWithDetails> files = CmdLineParser::filterFiles(fileFilters, filesResolved);
+#ifdef _WIN32
+        ASSERT_EQUALS(1U, files.size());
+#else
+        ASSERT_EQUALS(0U, files.size());
+#endif
+    }
+
+    void fileFilterStdin() {
+        REDIRECT;
+        RedirectInput input("file1.c\nfile2.cpp\n");
+        const char * const argv[] = {"cppcheck", "--file-filter=-"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: no C or C++ source files found.\n", logger->str());
+        ASSERT_EQUALS(2U, settings->fileFilters.size());
+        ASSERT_EQUALS("file1.c", settings->fileFilters[0]);
+        ASSERT_EQUALS("file2.cpp", settings->fileFilters[1]);
+    }
+
+    void fileFilterPlus() {
+        REDIRECT;
+        ScopedFile file("project.cppcheck",
+                        "<project>\n"
+                        "<paths>\n"
+                        "<dir name=\"src\"/>\n"
+                        "</paths>\n"
+                        "</project>");
+        const char * const argv[] = {"cppcheck", "--project=project.cppcheck", "--file-filter=+", "src/file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("src/file.cpp", settings->fileFilters.front());
+    }
+
+    void fileFilterNoMatch() {
+        REDIRECT;
+        RedirectInput input("notexist1.c\nnotexist2.cpp\n");
+        const char * const argv[] = {"cppcheck", "--file-filter=-", "."};
+        ASSERT(!fillSettingsFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: could not find any files matching the filter:notexist1.c\n"
+                      "cppcheck: error: could not find any files matching the filter:notexist2.cpp\n",
+                      logger->str());
     }
 
     void fileList() {
-        // TODO: Fails since cannot open the file
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--file-list", "files.txt", "file.cpp"};
-        TODO_ASSERT_EQUALS(true, false, defParser.parseFromArgs(4, argv));
+        ScopedFile file("files.txt",
+                        "file1.c\n"
+                        "file2.cpp\n");
+        const char * const argv[] = {"cppcheck", "--file-list=files.txt", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(3, parser->mPathNames.size());
+        auto it = parser->mPathNames.cbegin();
+        ASSERT_EQUALS("file1.c", *it++);
+        ASSERT_EQUALS("file2.cpp", *it++);
+        ASSERT_EQUALS("file.cpp", *it);
+    }
+
+    void fileListNoFile() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--file-list=files.txt", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: couldn't open the file: \"files.txt\".\n", logger->str());
     }
 
-    /*    void fileListStdin() {
-            // TODO: Give it some stdin to read from, fails because the list of
-            // files in stdin (_pathnames) is empty
-            REDIRECT;
-            const char * const argv[] = {"cppcheck", "--file-list=-", "file.cpp"};
-            TODO_ASSERT_EQUALS(true, false, defParser.parseFromArgs(3, argv));
-        } */
+    void fileListStdin() {
+        REDIRECT;
+        RedirectInput input("file1.c\nfile2.cpp\n");
+        const char * const argv[] = {"cppcheck", "--file-list=-", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(3, parser->mPathNames.size());
+        auto it = parser->mPathNames.cbegin();
+        ASSERT_EQUALS("file1.c", *it++);
+        ASSERT_EQUALS("file2.cpp", *it++);
+        ASSERT_EQUALS("file.cpp", *it);
+    }
+
+    void fileListInvalid() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--file-list", "files.txt", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--file-list\".\n", logger->str());
+    }
 
     void inlineSuppr() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--inline-suppr", "file.cpp"};
-        ASSERT(defParser.parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->inlineSuppressions);
     }
 
     void jobs() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-j", "3", "file.cpp"};
-        settings.jobs = 0;
-        ASSERT(defParser.parseFromArgs(4, argv));
-        ASSERT_EQUALS(3, settings.jobs);
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(3, settings->jobs);
+    }
+
+    void jobs2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-j3", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(3, settings->jobs);
     }
 
     void jobsMissingCount() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-j", "file.cpp"};
-        settings.jobs = 0;
         // Fails since -j is missing thread count
-        ASSERT_EQUALS(false, defParser.parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '-j' is not valid - not an integer.\n", logger->str());
     }
 
     void jobsInvalid() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-j", "e", "file.cpp"};
-        settings.jobs = 0;
         // Fails since invalid count given for -j
-        ASSERT_EQUALS(false, defParser.parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '-j' is not valid - not an integer.\n", logger->str());
+    }
+
+    void jobsNoJobs() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-j0", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument for '-j' must be greater than 0.\n", logger->str());
+    }
+
+    void jobsTooBig() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-j1025", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument for '-j' is allowed to be 1024 at max.\n", logger->str());
     }
 
     void maxConfigs() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-f", "--max-configs=12", "file.cpp"};
-        settings.force = false;
-        settings.maxConfigs = 12;
-        ASSERT(defParser.parseFromArgs(4, argv));
-        ASSERT_EQUALS(12, settings.maxConfigs);
-        ASSERT_EQUALS(false, settings.force);
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(12, settings->maxConfigsOption);
+        ASSERT_EQUALS(false, settings->force);
     }
 
     void maxConfigsMissingCount() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--max-configs=", "file.cpp"};
         // Fails since --max-configs= is missing limit
-        ASSERT_EQUALS(false, defParser.parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--max-configs=' is not valid - not an integer.\n", logger->str());
     }
 
     void maxConfigsInvalid() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--max-configs=e", "file.cpp"};
         // Fails since invalid count given for --max-configs=
-        ASSERT_EQUALS(false, defParser.parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--max-configs=' is not valid - not an integer.\n", logger->str());
     }
 
     void maxConfigsTooSmall() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--max-configs=0", "file.cpp"};
         // Fails since limit must be greater than 0
-        ASSERT_EQUALS(false, defParser.parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--max-configs=' must be greater than 0.\n", logger->str());
     }
 
-    void reportProgressTest() {
+    void outputFormatText() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--report-progress", "file.cpp"};
-        settings.reportProgress = false;
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT(settings.reportProgress);
+        const char * const argv[] = {"cppcheck", "--output-format=text", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Settings::OutputFormat::text, settings->outputFormat);
     }
 
-    void stdc99() {
+    void outputFormatSarif() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--std=c99", "file.cpp"};
-        settings.standards.c = Standards::C89;
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT(settings.standards.c == Standards::C99);
+        const char * const argv[] = {"cppcheck", "--output-format=sarif", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Settings::OutputFormat::sarif, settings->outputFormat);
     }
 
-    void stdcpp11() {
+    void outputFormatXml() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--std=c++11", "file.cpp"};
-        settings.standards.cpp = Standards::CPP03;
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT(settings.standards.cpp == Standards::CPP11);
+        const char * const argv[] = {"cppcheck", "--output-format=xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Settings::OutputFormat::xml, settings->outputFormat);
     }
 
-    void platform() {
+    void outputFormatXmlv2() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--platform=win64", "file.cpp"};
-        settings.platform(Settings::Unspecified);
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT(settings.platformType == Settings::Win64);
+        const char * const argv[] = {"cppcheck", "--output-format=xmlv2", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Settings::OutputFormat::xml, settings->outputFormat);
+        ASSERT_EQUALS(2, settings->xml_version);
     }
 
-    void suppressionsOld() {
-        // TODO: Fails because there is no suppr.txt file!
+    void outputFormatXmlv3() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--suppressions", "suppr.txt", "file.cpp"};
-        ASSERT(!defParser.parseFromArgs(4, argv));
+        const char * const argv[] = {"cppcheck", "--output-format=xmlv3", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Settings::OutputFormat::xml, settings->outputFormat);
+        ASSERT_EQUALS(3, settings->xml_version);
     }
 
-    void suppressions() {
-        // TODO: Fails because there is no suppr.txt file!
+    void outputFormatOther() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--suppressions-list=suppr.txt", "file.cpp"};
-        TODO_ASSERT_EQUALS(true, false, defParser.parseFromArgs(3, argv));
+        const char * const argv[] = {"cppcheck", "--output-format=plist", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--output-format=' must be 'text', 'sarif', 'xml' (deprecated), 'xmlv2' or 'xmlv3'.\n", logger->str());
     }
 
-    void suppressionsNoFile() {
+    void outputFormatImplicitPlist() {
         REDIRECT;
-        {
-            CLEAR_REDIRECT_OUTPUT;
-            const char * const argv[] = {"cppcheck", "--suppressions-list=", "file.cpp"};
-            ASSERT_EQUALS(false, defParser.parseFromArgs(3, argv));
-            ASSERT_EQUALS(false, GET_REDIRECT_OUTPUT.find("If you want to pass two files") != std::string::npos);
-        }
-
-        {
-            CLEAR_REDIRECT_OUTPUT;
-            const char * const argv[] = {"cppcheck", "--suppressions-list=a.suppr,b.suppr", "file.cpp"};
-            ASSERT_EQUALS(false, defParser.parseFromArgs(3, argv));
-            ASSERT_EQUALS(true, GET_REDIRECT_OUTPUT.find("If you want to pass two files") != std::string::npos);
-        }
-
-        {
-            CLEAR_REDIRECT_OUTPUT;
-            const char * const argv[] = {"cppcheck", "--suppressions-list=a.suppr b.suppr", "file.cpp"};
-            ASSERT_EQUALS(false, defParser.parseFromArgs(3, argv));
-            ASSERT_EQUALS(true, GET_REDIRECT_OUTPUT.find("If you want to pass two files") != std::string::npos);
-        }
+        const char * const argv[] = {"cppcheck", "--plist-output=.", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Settings::OutputFormat::plist, settings->outputFormat);
+        ASSERT_EQUALS("./", settings->plistOutput);
     }
 
-    static Suppressions::ErrorMessage errorMessage(const std::string &errorId, const std::string &fileName, int lineNumber) {
-        Suppressions::ErrorMessage e;
-        e.errorId = errorId;
-        e.setFileName(fileName);
-        e.lineNumber = lineNumber;
-        return e;
+    void outputFormatImplicitXml() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Settings::OutputFormat::xml, settings->outputFormat);
     }
 
-    void suppressionSingle() {
+    void outputFormatOverridePlist() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--suppress=uninitvar", "file.cpp"};
-        settings = Settings();
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT_EQUALS(true, settings.nomsg.isSuppressed(errorMessage("uninitvar", "file.cpp", 1)));
+        const char * const argv[] = {"cppcheck", "--plist-output=.", "--output-format=text", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Settings::OutputFormat::text, settings->outputFormat);
+        ASSERT_EQUALS("", settings->plistOutput);
     }
 
-    void suppressionSingleFile() {
+    void outputFormatMixed1() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--suppress=uninitvar:file.cpp", "file.cpp"};
-        settings = Settings();
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT_EQUALS(true, settings.nomsg.isSuppressed(errorMessage("uninitvar", "file.cpp", 1U)));
+        const char * const argv[] = {"cppcheck", "--xml", "--output-format=xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: '--output-format' and '--xml...' may not be used in conjunction.\n", logger->str());
     }
 
-    void suppressionTwo() {
+    void outputFormatMixed2() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--suppress=uninitvar,noConstructor", "file.cpp"};
-        settings = Settings();
-        TODO_ASSERT_EQUALS(true, false, defParser.parseFromArgs(3, argv));
-        TODO_ASSERT_EQUALS(true, false, settings.nomsg.isSuppressed(errorMessage("uninitvar", "file.cpp", 1U)));
-        TODO_ASSERT_EQUALS(true, false, settings.nomsg.isSuppressed(errorMessage("noConstructor", "file.cpp", 1U)));
+        const char * const argv[] = {"cppcheck", "--output-format=xml", "--xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: '--output-format' and '--xml...' may not be used in conjunction.\n", logger->str());
     }
 
-    void suppressionTwoSeparate() {
+    void outputFormatMixed3() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--suppress=uninitvar", "--suppress=noConstructor", "file.cpp"};
-        settings = Settings();
-        ASSERT(defParser.parseFromArgs(4, argv));
-        ASSERT_EQUALS(true, settings.nomsg.isSuppressed(errorMessage("uninitvar", "file.cpp", 1U)));
-        ASSERT_EQUALS(true, settings.nomsg.isSuppressed(errorMessage("noConstructor", "file.cpp", 1U)));
+        const char * const argv[] = {"cppcheck", "--xml-version=2", "--output-format=xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: '--output-format' and '--xml...' may not be used in conjunction.\n", logger->str());
     }
 
-    void templates() {
+    void premiumOptions1() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--template", "{file}:{line},{severity},{id},{message}", "file.cpp"};
-        settings.templateFormat.clear();
-        ASSERT(defParser.parseFromArgs(4, argv));
-        ASSERT_EQUALS("{file}:{line},{severity},{id},{message}", settings.templateFormat);
+        asPremium();
+        const char * const argv[] = {"cppcheck", "--premium=autosar", "file.c"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->severity.isEnabled(Severity::error));
+        ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::warning));
     }
 
-    void templatesGcc() {
+    void premiumOptions2() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--template", "gcc", "file.cpp"};
-        settings.templateFormat.clear();
-        ASSERT(defParser.parseFromArgs(4, argv));
-        ASSERT_EQUALS("{file}:{line}:{column}: warning: {message} [{id}]\\n{code}", settings.templateFormat);
+        asPremium();
+        const char * const argv[] = {"cppcheck", "--premium=misra-c-2012", "file.c"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->severity.isEnabled(Severity::error));
+        ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::warning));
     }
 
-    void templatesVs() {
+    void premiumOptions3() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--template", "vs", "file.cpp"};
-        settings.templateFormat.clear();
-        ASSERT(defParser.parseFromArgs(4, argv));
-        ASSERT_EQUALS("{file}({line}): {severity}: {message}", settings.templateFormat);
+        asPremium();
+        const char * const argv[] = {"cppcheck", "--premium=misra-c++-2023", "file.c"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->severity.isEnabled(Severity::error));
+        ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::warning));
     }
 
-    void templatesEdit() {
+    void premiumOptions4() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--template", "edit", "file.cpp"};
-        settings.templateFormat.clear();
-        ASSERT(defParser.parseFromArgs(4, argv));
-        ASSERT_EQUALS("{file} +{line}: {severity}: {message}", settings.templateFormat);
+        asPremium();
+        const char * const argv[] = {"cppcheck", "--premium=cert-c++-2016", "file.c"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->severity.isEnabled(Severity::error));
+        ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::warning));
     }
 
-    void xml() {
+    void premiumOptions5() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--xml", "file.cpp"};
-        settings.xml_version = 1;
-        settings.xml = false;
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT(settings.xml);
-        ASSERT_EQUALS(1, settings.xml_version);
+        asPremium();
+        const char * const argv[] = {"cppcheck", "--premium=safety", "file.c"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->severity.isEnabled(Severity::error));
+        ASSERT_EQUALS(false, settings->severity.isEnabled(Severity::warning));
     }
 
-    void xmlver2() {
+    void premiumOptionsAll() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--xml-version=2", "file.cpp"};
-        settings.xml_version = 1;
-        settings.xml = false;
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT(settings.xml);
-        ASSERT_EQUALS(2, settings.xml_version);
+        asPremium();
+        const char * const argv[] = {
+            "cppcheck",
+            "--premium=autosar:all",
+            "--premium=cert-c:all",
+            "--premium=cert-c++:all",
+            "--premium=misra-c-2023:all",
+            "--premium=misra-c++-2023:all",
+            "file.c"
+        };
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("--autosar:all --cert-c:all --cert-c++:all --misra-c-2023:all --misra-c++-2023:all",
+                      settings->premiumArgs);
     }
 
-    void xmlver2both() {
+    void premiumOptionsMetrics() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--xml", "--xml-version=2", "file.cpp"};
-        settings.xml_version = 1;
-        settings.xml = false;
-        ASSERT(defParser.parseFromArgs(4, argv));
-        ASSERT(settings.xml);
-        ASSERT_EQUALS(2, settings.xml_version);
+        asPremium();
+        const char * const argv[] = {"cppcheck", "--premium=metrics", "file.c"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("--metrics", settings->premiumArgs);
+        ASSERT(settings->severity.isEnabled(Severity::error));
+        ASSERT_EQUALS(false, settings->severity.isEnabled(Severity::warning));
+        ASSERT_EQUALS(false, settings->severity.isEnabled(Severity::portability));
     }
 
-    void xmlver2both2() {
+    void premiumOptionsCertCIntPrecision() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--xml-version=2", "--xml", "file.cpp"};
-        settings.xml_version = 1;
-        settings.xml = false;
-        ASSERT(defParser.parseFromArgs(4, argv));
-        ASSERT(settings.xml);
-        ASSERT_EQUALS(2, settings.xml_version);
+        asPremium();
+        const char * const argv[] = {"cppcheck", "--premium-cert-c-int-precision=12", "file.c"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("--cert-c-int-precision=12", settings->premiumArgs);
     }
 
-    void xmlverunknown() {
+    void premiumOptionsLicenseFile() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--xml", "--xml-version=3", "file.cpp"};
-        // FAils since unknown XML format version
-        ASSERT_EQUALS(false, defParser.parseFromArgs(4, argv));
+        asPremium();
+        const char * const argv[] = {"cppcheck", "--premium-license-file=file.lic", "file.c"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("--license-file=file.lic", settings->premiumArgs);
     }
 
-    void xmlverinvalid() {
+    void premiumOptionsInvalid1() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--xml", "--xml-version=a", "file.cpp"};
-        // FAils since unknown XML format version
-        ASSERT_EQUALS(false, defParser.parseFromArgs(4, argv));
+        asPremium();
+        const char * const argv[] = {"cppcheck", "--premium=misra", "file.c"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: invalid --premium option 'misra'.\n", logger->str());
     }
 
-    void doc() {
+    void premiumOptionsInvalid2() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--doc"};
-        ASSERT(defParser.parseFromArgs(2, argv));
-        ASSERT(defParser.exitAfterPrinting());
+        asPremium();
+        const char * const argv[] = {"cppcheck", "--premium=cert", "file.c"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: invalid --premium option 'cert'.\n", logger->str());
     }
 
-    void showtime() {
+    void premiumSafety() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--showtime=summary"};
-        settings.showtime = SHOWTIME_MODES::SHOWTIME_NONE;
-        ASSERT(defParser.parseFromArgs(2, argv));
-        ASSERT(settings.showtime == SHOWTIME_MODES::SHOWTIME_SUMMARY);
+        asPremium();
+        const char * const argv[] = {"cppcheck", "--premium=safety", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->safety);
     }
 
-    void errorlist1() {
+    void premiumDebugProgress() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--errorlist"};
-        ASSERT(defParser.parseFromArgs(2, argv));
-        ASSERT(defParser.getShowErrorMessages());
+        asPremium();
+        const char * const argv[] = {"cppcheck", "--premium=debug-progress", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("--debug-progress", settings->premiumArgs);
     }
 
-    void errorlistverbose1() {
+    void reportProgress1() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--verbose", "--errorlist"};
-        settings.verbose = false;
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT(settings.verbose);
+        const char * const argv[] = {"cppcheck", "--report-progress", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(10, settings->reportProgress);
     }
 
-    void errorlistverbose2() {
+    void reportProgress2() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "--errorlist", "--verbose"};
-        settings.verbose = false;
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT(settings.verbose);
+        const char * const argv[] = {"cppcheck", "--report-progress=", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--report-progress=' is not valid - not an integer.\n", logger->str());
+    }
+
+    void reportProgress3() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--report-progress=-1", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--report-progress=' needs to be a positive integer.\n", logger->str());
+    }
+
+    void reportProgress4() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--report-progress=0", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(0, settings->reportProgress);
+    }
+
+    void reportProgress5() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--report-progress=1", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(1, settings->reportProgress);
+    }
+
+    void stdc99() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--std=c99", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->standards.c == Standards::C99);
+    }
+
+    void stdgnu17() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--std=gnu17", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->standards.c == Standards::C17);
+    }
+
+    void stdiso9899_1999() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--std=iso9899:1999", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->standards.c == Standards::C99);
+    }
+
+    void stdcpp11() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--std=c++11", "file.cpp"};
+        settings->standards.cpp = Standards::CPP03;
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->standards.cpp == Standards::CPP11);
+    }
+
+    void stdgnupp23() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--std=gnu++23", "file.cpp"};
+        settings->standards.cpp = Standards::CPP03;
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->standards.cpp == Standards::CPP23);
+    }
+
+    void stdunknown1() {
+        REDIRECT;
+        const char *const argv[] = {"cppcheck", "--std=d++11", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unknown --std value 'd++11'\n", logger->str());
+    }
+
+    void stdunknown2() {
+        REDIRECT;
+        const char *const argv[] = {"cppcheck", "--std=cplusplus11", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unknown --std value 'cplusplus11'\n", logger->str());
+    }
+
+    void stdunknown3() {
+        REDIRECT;
+        const char *const argv[] = {"cppcheck", "--std=C++11", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unknown --std value 'C++11'\n", logger->str());
+    }
+
+    void stdoverwrite1() {
+        REDIRECT;
+        const char *const argv[] = {"cppcheck", "--std=c++11", "--std=c++23", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Standards::CPP23, settings->standards.cpp);
+        ASSERT_EQUALS_ENUM(Standards::CLatest, settings->standards.c);
+    }
+
+    void stdoverwrite2() {
+        REDIRECT;
+        const char *const argv[] = {"cppcheck", "--std=c99", "--std=c11", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Standards::C11, settings->standards.c);
+        ASSERT_EQUALS_ENUM(Standards::CPPLatest, settings->standards.cpp);
+    }
+
+    void stdoverwrite3() {
+        REDIRECT;
+        const char *const argv[] = {"cppcheck", "--std=c99", "--std=c++11", "--std=c11", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Standards::C11, settings->standards.c);
+        ASSERT_EQUALS_ENUM(Standards::CPP11, settings->standards.cpp);
+    }
+
+    void stdoverwrite4() {
+        REDIRECT;
+        const char *const argv[] = {"cppcheck", "--std=c++11", "--std=c99", "--std=c++23", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Standards::CPP23, settings->standards.cpp);
+        ASSERT_EQUALS_ENUM(Standards::C99, settings->standards.c);
+    }
+
+    void stdmulti1() {
+        REDIRECT;
+        const char *const argv[] = {"cppcheck", "--std=c99", "--std=c++11", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Standards::C99, settings->standards.c);
+        ASSERT_EQUALS_ENUM(Standards::CPP11, settings->standards.cpp);
+    }
+
+    void stdmulti2() {
+        REDIRECT;
+        const char *const argv[] = {"cppcheck", "--std=c++20", "--std=c11", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Standards::C11, settings->standards.c);
+        ASSERT_EQUALS_ENUM(Standards::CPP20, settings->standards.cpp);
+    }
+
+    void platformWin64() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--platform=win64", "file.cpp"};
+        ASSERT(settings->platform.set(Platform::Type::Unspecified));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(Platform::Type::Win64, settings->platform.type);
+    }
+
+    void platformWin32A() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--platform=win32A", "file.cpp"};
+        ASSERT(settings->platform.set(Platform::Type::Unspecified));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(Platform::Type::Win32A, settings->platform.type);
+    }
+
+    void platformWin32W() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--platform=win32W", "file.cpp"};
+        ASSERT(settings->platform.set(Platform::Type::Unspecified));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(Platform::Type::Win32W, settings->platform.type);
+    }
+
+    void platformUnix32() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--platform=unix32", "file.cpp"};
+        ASSERT(settings->platform.set(Platform::Type::Unspecified));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(Platform::Type::Unix32, settings->platform.type);
+    }
+
+    void platformUnix32Unsigned() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--platform=unix32-unsigned", "file.cpp"};
+        ASSERT(settings->platform.set(Platform::Type::Unspecified));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unrecognized platform: 'unix32-unsigned'.\n", logger->str());
+    }
+
+    void platformUnix64() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--platform=unix64", "file.cpp"};
+        ASSERT(settings->platform.set(Platform::Type::Unspecified));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(Platform::Type::Unix64, settings->platform.type);
+    }
+
+    void platformUnix64Unsigned() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--platform=unix64-unsigned", "file.cpp"};
+        ASSERT(settings->platform.set(Platform::Type::Unspecified));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unrecognized platform: 'unix64-unsigned'.\n", logger->str());
+    }
+
+    void platformNative() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--platform=native", "file.cpp"};
+        ASSERT(settings->platform.set(Platform::Type::Unspecified));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(Platform::Type::Native, settings->platform.type);
+    }
+
+    void platformUnspecified() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--platform=unspecified", "file.cpp"};
+        ASSERT(settings->platform.set(Platform::Type::Native));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(Platform::Type::Unspecified, settings->platform.type);
+    }
+
+    void platformPlatformFile() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--platform=avr8", "file.cpp"};
+        ASSERT(settings->platform.set(Platform::Type::Unspecified));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(Platform::Type::File, settings->platform.type);
+    }
+
+    void platformUnknown() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--platform=win128", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unrecognized platform: 'win128'.\n", logger->str());
+    }
+
+    void platformEmpty() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--platform=", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: empty platform specified.\n", logger->str());
+    }
+
+    void plistEmpty() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--plist-output=", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->plistOutput == "./");
+    }
+
+    void plistDoesNotExist() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--plist-output=./cppcheck_reports", "file.cpp"};
+        // Fails since folder pointed by --plist-output= does not exist
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: plist folder does not exist: 'cppcheck_reports'.\n", logger->str());
+    }
+
+    void suppressionsOld() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--suppressions", "suppr.txt", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--suppressions\".\n", logger->str());
+    }
+
+    void suppressions() {
+        REDIRECT;
+        ScopedFile file("suppr.txt",
+                        "uninitvar\n"
+                        "unusedFunction\n");
+        const char * const argv[] = {"cppcheck", "--suppressions-list=suppr.txt", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        const auto supprsNomsg = supprs->nomsg.getSuppressions();
+        ASSERT_EQUALS(2, supprsNomsg.size());
+        auto it = supprsNomsg.cbegin();
+        ASSERT_EQUALS("uninitvar", (it++)->errorId);
+        ASSERT_EQUALS("unusedFunction", it->errorId);
+    }
+
+    void suppressionsNoFile1() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--suppressions-list=", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS(false, logger->str().find("If you want to pass two files") != std::string::npos);
+    }
+
+    void suppressionsNoFile2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--suppressions-list=a.suppr,b.suppr", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS(true, logger->str().find("If you want to pass two files") != std::string::npos);
+    }
+
+    void suppressionsNoFile3() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--suppressions-list=a.suppr b.suppr", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS(true, logger->str().find("If you want to pass two files") != std::string::npos);
+    }
+
+    static SuppressionList::ErrorMessage errorMessage(const std::string &errorId, const std::string &fileName, int lineNumber) {
+        SuppressionList::ErrorMessage e;
+        e.errorId = errorId;
+        e.setFileName(fileName);
+        e.lineNumber = lineNumber;
+        return e;
+    }
+
+    void suppressionSingle() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--suppress=uninitvar", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, supprs->nomsg.isSuppressed(errorMessage("uninitvar", "file.cpp", 1)));
+    }
+
+    void suppressionSingleFile() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--suppress=uninitvar:file.cpp", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, supprs->nomsg.isSuppressed(errorMessage("uninitvar", "file.cpp", 1U)));
+    }
+
+    void suppressionTwo() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--suppress=uninitvar,noConstructor", "file.cpp"};
+        TODO_ASSERT_EQUALS(static_cast<int>(CmdLineParser::Result::Success), static_cast<int>(CmdLineParser::Result::Fail), static_cast<int>(parseFromArgs(argv)));
+        TODO_ASSERT_EQUALS(true, false, supprs->nomsg.isSuppressed(errorMessage("uninitvar", "file.cpp", 1U)));
+        TODO_ASSERT_EQUALS(true, false, supprs->nomsg.isSuppressed(errorMessage("noConstructor", "file.cpp", 1U)));
+        TODO_ASSERT_EQUALS("", "cppcheck: error: Failed to add suppression. Invalid id \"uninitvar,noConstructor\"\n", logger->str());
+    }
+
+    void suppressionTwoSeparate() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--suppress=uninitvar", "--suppress=noConstructor", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, supprs->nomsg.isSuppressed(errorMessage("uninitvar", "file.cpp", 1U)));
+        ASSERT_EQUALS(true, supprs->nomsg.isSuppressed(errorMessage("noConstructor", "file.cpp", 1U)));
+    }
+
+    void templates() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--template={file}:{line},{severity},{id},{message}", "--template-location={file}:{line}:{column} {info}", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("{file}:{line},{severity},{id},{message}", settings->templateFormat);
+        ASSERT_EQUALS("{file}:{line}:{column} {info}", settings->templateLocation);
+    }
+
+    void templatesGcc() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--template=gcc", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("{file}:{line}:{column}: warning: {message} [{id}]\n{code}", settings->templateFormat);
+        ASSERT_EQUALS("{file}:{line}:{column}: note: {info}\n{code}", settings->templateLocation);
+    }
+
+    void templatesVs() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--template=vs", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("{file}({line}): {severity}: {message}", settings->templateFormat);
+        ASSERT_EQUALS("", settings->templateLocation);
+    }
+
+    void templatesEdit() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--template=edit", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("{file} +{line}: {severity}: {message}", settings->templateFormat);
+        ASSERT_EQUALS("", settings->templateLocation);
+    }
+
+    void templatesCppcheck1() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--template=cppcheck1", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("{callstack}: ({severity}{inconclusive:, inconclusive}) {message}", settings->templateFormat);
+        ASSERT_EQUALS("", settings->templateLocation);
+    }
+
+    void templatesDaca2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--template=daca2", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("{file}:{line}:{column}: {severity}:{inconclusive:inconclusive:} {message} [{id}]", settings->templateFormat);
+        ASSERT_EQUALS("{file}:{line}:{column}: note: {info}", settings->templateLocation);
+        ASSERT_EQUALS(true, settings->daca);
+    }
+
+    void templatesSelfcheck() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--template=selfcheck", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("{file}:{line}:{column}: {severity}:{inconclusive:inconclusive:} {message} [{id}]\n{code}", settings->templateFormat);
+        ASSERT_EQUALS("{file}:{line}:{column}: note: {info}\n{code}", settings->templateLocation);
+    }
+
+    void templatesSimple() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--template=simple", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("{file}:{line}:{column}: {severity}:{inconclusive:inconclusive:} {message} [{id}]", settings->templateFormat);
+        ASSERT_EQUALS("", settings->templateLocation);
+    }
+
+    // TODO: we should bail out on this
+    void templatesNoPlaceholder() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--template=selfchek", "file.cpp"};
+        TODO_ASSERT_EQUALS(static_cast<int>(CmdLineParser::Result::Fail), static_cast<int>(CmdLineParser::Result::Success), static_cast<int>(parseFromArgs(argv)));
+        ASSERT_EQUALS("selfchek", settings->templateFormat);
+        ASSERT_EQUALS("", settings->templateLocation);
+    }
+
+    void templateFormatInvalid() {
+        REDIRECT;
+        const char* const argv[] = { "cppcheck", "--template", "file.cpp" };
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--template\".\n", logger->str());
+    }
+
+    // will use the default
+    // TODO: bail out on empty?
+    void templateFormatEmpty() {
+        REDIRECT;
+        const char* const argv[] = { "cppcheck", "--template=", "file.cpp" };
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("{file}:{line}:{column}: {inconclusive:}{severity}:{inconclusive: inconclusive:} {message} [{id}]\n{code}", settings->templateFormat);
+        ASSERT_EQUALS("{file}:{line}:{column}: note: {info}\n{code}", settings->templateLocation);
+    }
+
+    void templateLocationInvalid() {
+        REDIRECT;
+        const char* const argv[] = { "cppcheck", "--template-location", "--template={file}", "file.cpp" };
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--template-location\".\n", logger->str());
+    }
+
+    // will use the default
+    // TODO: bail out on empty?
+    void templateLocationEmpty() {
+        REDIRECT;
+        const char* const argv[] = { "cppcheck", "--template-location=", "file.cpp" };
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS("{file}:{line}:{column}: {inconclusive:}{severity}:{inconclusive: inconclusive:} {message} [{id}]\n{code}", settings->templateFormat);
+        ASSERT_EQUALS("{file}:{line}:{column}: note: {info}\n{code}", settings->templateLocation);
+    }
+
+    void xml() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Settings::OutputFormat::xml, settings->outputFormat);
+        ASSERT_EQUALS(2, settings->xml_version);
+    }
+
+    void xmlver2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--xml-version=2", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Settings::OutputFormat::xml, settings->outputFormat);
+        ASSERT_EQUALS(2, settings->xml_version);
+    }
+
+    void xmlver2both() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--xml", "--xml-version=2", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Settings::OutputFormat::xml, settings->outputFormat);
+        ASSERT_EQUALS(2, settings->xml_version);
+    }
+
+    void xmlver2both2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--xml-version=2", "--xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Settings::OutputFormat::xml, settings->outputFormat);
+        ASSERT_EQUALS(2, settings->xml_version);
+    }
+
+    void xmlverunknown() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--xml", "--xml-version=4", "file.cpp"};
+        // FAils since unknown XML format version
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: '--xml-version' can only be 2 or 3.\n", logger->str());
+    }
+
+    void xmlverinvalid() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--xml", "--xml-version=a", "file.cpp"};
+        // FAils since unknown XML format version
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--xml-version=' is not valid - not an integer.\n", logger->str());
+    }
+
+    void doc() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--doc"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
+        ASSERT(startsWith(logger->str(), "## "));
+    }
+
+    void docExclusive() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--library=missing", "--doc"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
+        ASSERT(startsWith(logger->str(), "## "));
+    }
+
+    void showtimeSummary() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--showtime=summary", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->showtime == ShowTime::SUMMARY);
+    }
+
+    void showtimeFile() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--showtime=file", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->showtime == ShowTime::FILE);
+    }
+
+    void showtimeFileTotal() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--showtime=file-total", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->showtime == ShowTime::FILE_TOTAL);
+    }
+
+    void showtimeTop5() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--showtime=top5", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unrecognized --showtime mode: 'top5'. Supported modes: file, file-total, summary, top5_file, top5_summary.\n", logger->str());
+    }
+
+    void showtimeTop5File() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--showtime=top5_file", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->showtime == ShowTime::TOP5_FILE);
+    }
+
+    void showtimeTop5Summary() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--showtime=top5_summary", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->showtime == ShowTime::TOP5_SUMMARY);
+    }
+
+    void showtimeNone() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--showtime=none", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->showtime == ShowTime::NONE);
+    }
+
+    void showtimeEmpty() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--showtime=", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: no mode provided for --showtime\n", logger->str());
+    }
+
+    void showtimeInvalid() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--showtime=top10", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unrecognized --showtime mode: 'top10'. Supported modes: file, file-total, summary, top5_file, top5_summary.\n", logger->str());
+    }
+
+    void errorlist() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--errorlist"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
+        const std::string errout_s = GET_REDIRECT_OUTPUT;
+        ASSERT_EQUALS("", logger->str()); // empty since it is logged via ErrorLogger
+        ASSERT(startsWith(errout_s, ErrorMessage::getXMLHeader("")));
+        ASSERT(endsWith(errout_s, "</results>\n"));
+    }
+
+    void errorlistWithCfg() {
+        REDIRECT;
+        ScopedFile file(Path::join(Path::getPathFromFilename(Path::getCurrentExecutablePath("")), "cppcheck.cfg"),
+                        R"({"productName": "The Product"}\n)");
+        const char * const argv[] = {"cppcheck", "--errorlist"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
+        const std::string errout_s = GET_REDIRECT_OUTPUT;
+        ASSERT_EQUALS(1, settings->settingsFiles.size());
+        ASSERT_EQUALS(file.path(), *settings->settingsFiles.cbegin());
+        ASSERT_EQUALS("", logger->str()); // empty since it is logged via ErrorLogger
+        ASSERT(startsWith(errout_s, ErrorMessage::getXMLHeader("The Product")));
+    }
+
+    void errorlistExclusive() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--library=missing", "--errorlist"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
+        const std::string errout_s = GET_REDIRECT_OUTPUT;
+        ASSERT_EQUALS("", logger->str()); // empty since it is logged via ErrorLogger
+        ASSERT(startsWith(errout_s, ErrorMessage::getXMLHeader("")));
+        ASSERT(endsWith(errout_s, "</results>\n"));
     }
 
     void ignorepathsnopath() {
         REDIRECT;
-        const char * const argv[] = {"cppcheck", "-i"};
-        CmdLineParser parser(&settings);
-        // Fails since no ignored path given
-        ASSERT_EQUALS(false, parser.parseFromArgs(2, argv));
-        ASSERT_EQUALS(0, parser.getIgnoredPaths().size());
-    }
-
-    /*
-        void ignorepaths1() {
-            REDIRECT;
-            const char * const argv[] = {"cppcheck", "-isrc", "file.cpp"};
-            CmdLineParser parser(&settings);
-            ASSERT(parser.parseFromArgs(3, argv));
-            ASSERT_EQUALS(1, parser.getIgnoredPaths().size());
-            ASSERT_EQUALS("src/", parser.getIgnoredPaths()[0]);
-        }
+        const char * const argv[] = {"cppcheck", "-i"};
+        // Fails since no ignored path given
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '-i' is missing.\n", logger->str());
+    }
+
+#if defined(USE_WINDOWS_SEH) || defined(USE_UNIX_SIGNAL_HANDLING)
+    void exceptionhandling() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--exception-handling", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->exceptionHandling);
+        ASSERT_EQUALS(stdout, settings->exceptionOutput);
+    }
+
+    void exceptionhandling2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--exception-handling=stderr", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->exceptionHandling);
+        ASSERT_EQUALS(stderr, settings->exceptionOutput);
+    }
+
+    void exceptionhandling3() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--exception-handling=stdout", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->exceptionHandling);
+        ASSERT_EQUALS(stdout, settings->exceptionOutput);
+    }
+
+    void exceptionhandlingInvalid() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--exception-handling=exfile"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: invalid '--exception-handling' argument\n", logger->str());
+    }
+
+    void exceptionhandlingInvalid2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--exception-handling-foo"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--exception-handling-foo\".\n", logger->str());
+    }
+#else
+    void exceptionhandlingNotSupported() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--exception-handling", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: Option --exception-handling is not supported since Cppcheck has not been built with any exception handling enabled.\n", logger->str());
+    }
+
+    void exceptionhandlingNotSupported2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--exception-handling=stderr", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: Option --exception-handling is not supported since Cppcheck has not been built with any exception handling enabled.\n", logger->str());
+    }
+#endif
+
+    void clang() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--clang", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->clang);
+        ASSERT_EQUALS("clang", settings->clangExecutable);
+    }
+
+    void clangCustom() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--clang=clang-14", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->clang);
+        ASSERT_EQUALS("clang-14", settings->clangExecutable);
+    }
+
+    void clangInvalid() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--clang-foo"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--clang-foo\".\n", logger->str());
+    }
+
+    void valueFlowMaxIterations() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--valueflow-max-iterations=0", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(0, settings->vfOptions.maxIterations);
+    }
+
+    void valueFlowMaxIterations2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--valueflow-max-iterations=11", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(11, settings->vfOptions.maxIterations);
+    }
+
+    void valueFlowMaxIterationsInvalid() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--valueflow-max-iterations"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--valueflow-max-iterations\".\n", logger->str());
+    }
+
+    void valueFlowMaxIterationsInvalid2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--valueflow-max-iterations=seven"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--valueflow-max-iterations=' is not valid - not an integer.\n", logger->str());
+    }
+
+    void valueFlowMaxIterationsInvalid3() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--valueflow-max-iterations=-1"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--valueflow-max-iterations=' is not valid - needs to be positive.\n", logger->str());
+    }
+
+    void checksMaxTime() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--checks-max-time=12", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(12, settings->checksMaxTime);
+    }
+
+    void checksMaxTime2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--checks-max-time=-1", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--checks-max-time=' needs to be a positive integer.\n", logger->str());
+    }
+
+    void checksMaxTimeInvalid() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--checks-max-time=one", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--checks-max-time=' is not valid - not an integer.\n", logger->str());
+    }
+
+#ifdef HAS_THREADING_MODEL_FORK
+    void loadAverage() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-l", "12", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(12, settings->loadAverage);
+    }
+
+    void loadAverage2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-l12", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(12, settings->loadAverage);
+    }
+
+    void loadAverageInvalid() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-l", "one", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '-l' is not valid - not an integer.\n", logger->str());
+    }
+#else
+    void loadAverageNotSupported() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-l", "12", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: Option -l cannot be used as Cppcheck has not been built with fork threading model.\n", logger->str());
+    }
+#endif
+
+    void maxCtuDepth() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--max-ctu-depth=5", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(5, settings->maxCtuDepth);
+    }
+
+    void maxCtuDepth2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--max-ctu-depth=10", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(10, settings->maxCtuDepth);
+    }
+
+    void maxCtuDepthLimit() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--max-ctu-depth=12", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(10, settings->maxCtuDepth);
+        ASSERT_EQUALS("cppcheck: --max-ctu-depth is being capped at 10. This limitation will be removed in a future Cppcheck version.\n", logger->str());
+    }
+
+    void maxCtuDepthInvalid() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--max-ctu-depth=one", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--max-ctu-depth=' is not valid - not an integer.\n", logger->str());
+    }
+
+    void performanceValueflowMaxTime() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--performance-valueflow-max-time=12", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(12, settings->vfOptions.maxTime);
+    }
+
+    void performanceValueflowMaxTimeInvalid() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--performance-valueflow-max-time=one", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--performance-valueflow-max-time=' is not valid - not an integer.\n", logger->str());
+    }
+
+    void performanceValueFlowMaxIfCount() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--performance-valueflow-max-if-count=12", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(12, settings->vfOptions.maxIfCount);
+    }
+
+    void performanceValueFlowMaxIfCountInvalid() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--performance-valueflow-max-if-count=one", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--performance-valueflow-max-if-count=' is not valid - not an integer.\n", logger->str());
+    }
+
+    void templateMaxTime() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--template-max-time=12", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(12, settings->templateMaxTime);
+    }
+
+    void templateMaxTimeInvalid() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--template-max-time=one", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--template-max-time=' is not valid - not an integer.\n", logger->str());
+    }
+
+    void templateMaxTimeInvalid2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--template-max-time=-1", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--template-max-time=' is not valid - needs to be positive.\n", logger->str());
+    }
+
+    void typedefMaxTime() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--typedef-max-time=12", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(12, settings->typedefMaxTime);
+    }
+
+    void typedefMaxTimeInvalid() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--typedef-max-time=one", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--typedef-max-time=' is not valid - not an integer.\n", logger->str());
+    }
+
+    void typedefMaxTimeInvalid2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--typedef-max-time=-1", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--typedef-max-time=' is not valid - needs to be positive.\n", logger->str());
+    }
+
+    void project() {
+        REDIRECT;
+        ScopedFile file("project.cppcheck",
+                        "<project>\n"
+                        "<paths>\n"
+                        "<dir name=\"dir\"/>\n"
+                        "</paths>\n"
+                        "</project>");
+        const char * const argv[] = {"cppcheck", "--project=project.cppcheck"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(1, parser->mPathNames.size());
+        auto it = parser->mPathNames.cbegin();
+        ASSERT_EQUALS("dir", *it);
+    }
+
+    void projectMultiple() {
+        REDIRECT;
+        ScopedFile file("project.cppcheck", "<project></project>");
+        const char * const argv[] = {"cppcheck", "--project=project.cppcheck", "--project=project.cppcheck", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: multiple --project options are not supported.\n", logger->str());
+    }
+
+    void projectAndSource() {
+        REDIRECT;
+        ScopedFile file("project.cppcheck", "<project></project>");
+        const char * const argv[] = {"cppcheck", "--project=project.cppcheck", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: --project cannot be used in conjunction with source files.\n", logger->str());
+    }
+
+    void projectEmpty() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--project=", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: failed to open project ''. The file does not exist.\n", logger->str());
+    }
+
+    void projectMissing() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--project=project.cppcheck", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: failed to open project 'project.cppcheck'. The file does not exist.\n", logger->str());
+    }
+
+    void projectNoPaths() {
+        ScopedFile file("project.cppcheck", "<project></project>");
+        const char * const argv[] = {"cppcheck", "--project=project.cppcheck"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: no C or C++ source files found.\n", logger->str());
+    }
+
+    void addon() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--addon=misra", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(1, settings->addons.size());
+        ASSERT_EQUALS("misra", *settings->addons.cbegin());
+    }
+
+    void addonMissing() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--addon=misra2", "file.cpp"};
+        ASSERT(!fillSettingsFromArgs(argv));
+        ASSERT_EQUALS(1, settings->addons.size());
+        ASSERT_EQUALS("misra2", *settings->addons.cbegin());
+        ASSERT_EQUALS("Did not find addon misra2.py\n", logger->str());
+    }
+
+    void signedChar() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--fsigned-char", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS('s', settings->platform.defaultSign);
+    }
+
+    void signedChar2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--platform=avr8", "--fsigned-char", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS('s', settings->platform.defaultSign);
+    }
+
+    void unsignedChar() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--funsigned-char", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS('u', settings->platform.defaultSign);
+    }
+
+    void unsignedChar2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--platform=mips32", "--funsigned-char", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS('u', settings->platform.defaultSign);
+    }
+
+    void signedCharUnsignedChar() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--fsigned-char", "--funsigned-char", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS('u', settings->platform.defaultSign);
+    }
+
+#ifdef HAVE_RULES
+    void rule() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--rule=.+", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(1, settings->rules.size());
+        auto it = settings->rules.cbegin();
+        ASSERT_EQUALS(".+", it->pattern);
+    }
+
+    void ruleMissingPattern() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--rule=", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: no rule pattern provided.\n", logger->str());
+    }
+
+    void ruleInvalidPattern() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--rule=.*\\", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS("cppcheck: error: failed to compile rule pattern '.*\\' (pcre_compile failed: \\ at end of pattern).\n", logger->str());
+    }
+#else
+    void ruleNotSupported() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--rule=.+", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: Option --rule cannot be used as Cppcheck has not been built with rules support.\n", logger->str());
+    }
+#endif
+
+#ifdef HAVE_RULES
+    void ruleFileMulti() {
+        REDIRECT;
+        ScopedFile file("rule.xml",
+                        "<rules>\n"
+                        "<rule>\n"
+                        "<tokenlist>raw</tokenlist>\n"
+                        "<pattern>.+</pattern>\n"
+                        "<message>\n"
+                        "<severity>error</severity>\n"
+                        "<id>ruleId1</id>\n"
+                        "<summary>ruleSummary1</summary>\n"
+                        "</message>\n"
+                        "</rule>\n"
+                        "<rule>\n"
+                        "<tokenlist>define</tokenlist>\n"
+                        "<pattern>.*</pattern>\n"
+                        "<message>\n"
+                        "<severity>warning</severity>\n"
+                        "<id>ruleId2</id>\n"
+                        "<summary>ruleSummary2</summary>\n"
+                        "</message>\n"
+                        "</rule>\n"
+                        "</rules>");
+        const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(2, settings->rules.size());
+        auto it = settings->rules.cbegin();
+        ASSERT_EQUALS("raw", it->tokenlist);
+        ASSERT_EQUALS(".+", it->pattern);
+        ASSERT_EQUALS_ENUM(Severity::error, it->severity);
+        ASSERT_EQUALS("ruleId1", it->id);
+        ASSERT_EQUALS("ruleSummary1", it->summary);
+        ++it;
+        ASSERT_EQUALS("define", it->tokenlist);
+        ASSERT_EQUALS(".*", it->pattern);
+        ASSERT_EQUALS_ENUM(Severity::warning, it->severity);
+        ASSERT_EQUALS("ruleId2", it->id);
+        ASSERT_EQUALS("ruleSummary2", it->summary);
+    }
+
+    void ruleFileSingle() {
+        REDIRECT;
+        ScopedFile file("rule.xml",
+                        "<rule>\n"
+                        "<tokenlist>define</tokenlist>\n"
+                        "<pattern>.+</pattern>\n"
+                        "<message>\n"
+                        "<severity>error</severity>\n"
+                        "<id>ruleId</id>\n"
+                        "<summary>ruleSummary</summary>\n"
+                        "</message>\n"
+                        "</rule>\n");
+        const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(1, settings->rules.size());
+        auto it = settings->rules.cbegin();
+        ASSERT_EQUALS("define", it->tokenlist);
+        ASSERT_EQUALS(".+", it->pattern);
+        ASSERT_EQUALS_ENUM(Severity::error, it->severity);
+        ASSERT_EQUALS("ruleId", it->id);
+        ASSERT_EQUALS("ruleSummary", it->summary);
+    }
+
+    void ruleFileEmpty() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--rule-file=", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unable to load rule-file '' (XML_ERROR_FILE_NOT_FOUND).\n", logger->str());
+    }
+
+    void ruleFileMissing() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' (XML_ERROR_FILE_NOT_FOUND).\n", logger->str());
+    }
+
+    void ruleFileInvalid() {
+        REDIRECT;
+        ScopedFile file("rule.xml", "");
+        const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' (XML_ERROR_EMPTY_DOCUMENT).\n", logger->str());
+    }
+
+    void ruleFileNoRoot() {
+        REDIRECT;
+        ScopedFile file("rule.xml", "<?xml version=\"1.0\"?>");
+        const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(0, settings->rules.size());
+    }
+
+    void ruleFileEmptyElements1() {
+        REDIRECT;
+        ScopedFile file("rule.xml",
+                        "<rule>"
+                        "<tokenlist/>"
+                        "<pattern/>"
+                        "<message/>"
+                        "</rule>"
+                        );
+        const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv)); // do not crash
+        ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' - a rule is lacking a pattern.\n", logger->str());
+    }
+
+    void ruleFileEmptyElements2() {
+        REDIRECT;
+        ScopedFile file("rule.xml",
+                        "<rule>"
+                        "<message>"
+                        "<severity/>"
+                        "<id/>"
+                        "<summary/>"
+                        "</message>"
+                        "</rule>"
+                        );
+        const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv)); // do not crash
+        ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' - a rule is lacking a pattern.\n", logger->str());
+    }
+
+    void ruleFileUnknownElement1() {
+        REDIRECT;
+        ScopedFile file("rule.xml",
+                        "<rule>"
+                        "<messages/>"
+                        "</rule>"
+                        );
+        const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' - unknown element 'messages' encountered in 'rule'.\n", logger->str());
+    }
+
+    void ruleFileUnknownElement2() {
+        REDIRECT;
+        ScopedFile file("rule.xml",
+                        "<rule>"
+                        "<message>"
+                        "<pattern/>"
+                        "</message>"
+                        "</rule>"
+                        );
+        const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' - unknown element 'pattern' encountered in 'message'.\n", logger->str());
+    }
+
+    void ruleFileMissingTokenList() {
+        REDIRECT;
+        ScopedFile file("rule.xml",
+                        "<rule>\n"
+                        "<tokenlist/>\n"
+                        "<pattern>.+</pattern>\n"
+                        "</rule>\n");
+        const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' - a rule is lacking a tokenlist.\n", logger->str());
+    }
+
+    void ruleFileUnknownTokenList() {
+        REDIRECT;
+        ScopedFile file("rule.xml",
+                        "<rule>\n"
+                        "<tokenlist>simple</tokenlist>\n"
+                        "<pattern>.+</pattern>\n"
+                        "</rule>\n");
+        const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' - a rule is using the unsupported tokenlist 'simple'.\n", logger->str());
+    }
+
+    void ruleFileMissingId() {
+        REDIRECT;
+        ScopedFile file("rule.xml",
+                        "<rule>\n"
+                        "<pattern>.+</pattern>\n"
+                        "<message>\n"
+                        "<id/>"
+                        "</message>\n"
+                        "</rule>\n");
+        const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' - a rule is lacking an id.\n", logger->str());
+    }
+
+    void ruleFileInvalidSeverity1() {
+        REDIRECT;
+        ScopedFile file("rule.xml",
+                        "<rule>\n"
+                        "<pattern>.+</pattern>\n"
+                        "<message>\n"
+                        "<severity/>"
+                        "</message>\n"
+                        "</rule>\n");
+        const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' - a rule has an invalid severity.\n", logger->str());
+    }
+
+    void ruleFileInvalidSeverity2() {
+        REDIRECT;
+        ScopedFile file("rule.xml",
+                        "<rule>\n"
+                        "<pattern>.+</pattern>\n"
+                        "<message>\n"
+                        "<severity>none</severity>"
+                        "</message>\n"
+                        "</rule>\n");
+        const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' - a rule has an invalid severity.\n", logger->str());
+    }
+
+    void ruleFileInvalidPattern() {
+        REDIRECT;
+        ScopedFile file("rule.xml",
+                        "<rule>\n"
+                        "<pattern>.+\\</pattern>\n"
+                        "</rule>\n");
+        const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' - pattern '.+\\' failed to compile (pcre_compile failed: \\ at end of pattern).\n", logger->str());
+    }
+#else
+    void ruleFileNotSupported() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: Option --rule-file cannot be used as Cppcheck has not been built with rules support.\n", logger->str());
+    }
+#endif
+
+    void library() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--library=posix", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(1, settings->libraries.size());
+        ASSERT_EQUALS("posix", *settings->libraries.cbegin());
+    }
+
+    void libraryMissing() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--library=posix2", "file.cpp"};
+        ASSERT_EQUALS(false, fillSettingsFromArgs(argv));
+        ASSERT_EQUALS(1, settings->libraries.size());
+        ASSERT_EQUALS("posix2", *settings->libraries.cbegin());
+        ASSERT_EQUALS("cppcheck: Failed to load library configuration file 'posix2'. File not found\n", logger->str());
+    }
+
+    void libraryMultiple() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--library=posix,gnu", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(2, settings->libraries.size());
+        auto it = settings->libraries.cbegin();
+        ASSERT_EQUALS("posix", *it++);
+        ASSERT_EQUALS("gnu", *it);
+    }
+
+    void libraryMultipleEmpty() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--library=posix,,gnu", "file.cpp"};
+        ASSERT_EQUALS(false, fillSettingsFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: empty library specified.\n", logger->str());
+    }
+
+    void libraryMultipleEmpty2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--library=posix,gnu,", "file.cpp"};
+        ASSERT_EQUALS(false, fillSettingsFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: empty library specified.\n", logger->str());
+    }
+
+    void suppressXml() {
+        REDIRECT;
+        ScopedFile file("suppress.xml",
+                        "<suppressions>\n"
+                        "<suppress>\n"
+                        "<id>uninitvar</id>\n"
+                        "</suppress>\n"
+                        "</suppressions>");
+        const char * const argv[] = {"cppcheck", "--suppress-xml=suppress.xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        const auto supprsNomsg = supprs->nomsg.getSuppressions();
+        ASSERT_EQUALS(1, supprsNomsg.size());
+        const auto it = supprsNomsg.cbegin();
+        ASSERT_EQUALS("uninitvar", it->errorId);
+    }
+
+    void suppressXmlEmpty() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--suppress-xml=", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: failed to load suppressions XML '' (XML_ERROR_FILE_NOT_FOUND).\n", logger->str());
+    }
+
+    void suppressXmlMissing() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--suppress-xml=suppress.xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: failed to load suppressions XML 'suppress.xml' (XML_ERROR_FILE_NOT_FOUND).\n", logger->str());
+    }
+
+    void suppressXmlInvalid() {
+        REDIRECT;
+        ScopedFile file("suppress.xml", "");
+        const char * const argv[] = {"cppcheck", "--suppress-xml=suppress.xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: failed to load suppressions XML 'suppress.xml' (XML_ERROR_EMPTY_DOCUMENT).\n", logger->str());
+    }
+
+    void suppressXmlNoRoot() {
+        REDIRECT;
+        ScopedFile file("suppress.xml", "<?xml version=\"1.0\"?>");
+        const char * const argv[] = {"cppcheck", "--suppress-xml=suppress.xml", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: failed to load suppressions XML 'suppress.xml' (no root node found).\n", logger->str());
+    }
+
+    void executorDefault() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+#if defined(HAS_THREADING_MODEL_FORK)
+        ASSERT_EQUALS_ENUM(Settings::ExecutorType::Process, settings->executor);
+#elif defined(HAS_THREADING_MODEL_THREAD)
+        ASSERT_EQUALS_ENUM(Settings::ExecutorType::Thread, settings->executor);
+#endif
+    }
+
+    void executorAuto() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-j2", "--executor=auto", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+#if defined(HAS_THREADING_MODEL_FORK)
+        ASSERT_EQUALS_ENUM(Settings::ExecutorType::Process, settings->executor);
+#elif defined(HAS_THREADING_MODEL_THREAD)
+        ASSERT_EQUALS_ENUM(Settings::ExecutorType::Thread, settings->executor);
+#endif
+    }
+
+    void executorAutoNoJobs() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--executor=auto", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+#if defined(HAS_THREADING_MODEL_FORK)
+        ASSERT_EQUALS_ENUM(Settings::ExecutorType::Process, settings->executor);
+#elif defined(HAS_THREADING_MODEL_THREAD)
+        ASSERT_EQUALS_ENUM(Settings::ExecutorType::Thread, settings->executor);
+#endif
+    }
+
+#if defined(HAS_THREADING_MODEL_THREAD)
+    void executorThread() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-j2", "--executor=thread", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Settings::ExecutorType::Thread, settings->executor);
+    }
 
-        void ignorepaths2() {
-            REDIRECT;
-            const char * const argv[] = {"cppcheck", "-i", "src", "file.cpp"};
-            CmdLineParser parser(&settings);
-            ASSERT(parser.parseFromArgs(4, argv));
-            ASSERT_EQUALS(1, parser.getIgnoredPaths().size());
-            ASSERT_EQUALS("src/", parser.getIgnoredPaths()[0]);
-        }
+    void executorThreadNoJobs() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--executor=thread", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Settings::ExecutorType::Thread, settings->executor);
+        ASSERT_EQUALS("cppcheck: '--executor' has no effect as only a single job will be used.\n", logger->str());
+    }
+#else
+    void executorThreadNotSupported() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-j2", "--executor=thread", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: executor type 'thread' cannot be used as Cppcheck has not been built with a respective threading model.\n", logger->str());
+    }
+#endif
+
+#if defined(HAS_THREADING_MODEL_FORK)
+    void executorProcess() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-j2", "--executor=process", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Settings::ExecutorType::Process, settings->executor);
+    }
+
+    void executorProcessNoJobs() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--executor=process", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Settings::ExecutorType::Process, settings->executor);
+        ASSERT_EQUALS("cppcheck: '--executor' has no effect as only a single job will be used.\n", logger->str());
+    }
+#else
+    void executorProcessNotSupported() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-j2", "--executor=process", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: executor type 'process' cannot be used as Cppcheck has not been built with a respective threading model.\n", logger->str());
+    }
+#endif
+
+    // the CLI default to --check-level=normal
+    void checkLevelDefault() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Settings::CheckLevel::normal, settings->checkLevel);
+        ASSERT_EQUALS(100, settings->vfOptions.maxIfCount);
+        ASSERT_EQUALS(8, settings->vfOptions.maxSubFunctionArgs);
+        ASSERT_EQUALS(false, settings->vfOptions.doConditionExpressionAnalysis);
+        ASSERT_EQUALS(4, settings->vfOptions.maxForwardBranches);
+    }
+
+    void checkLevelNormal() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--check-level=normal", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Settings::CheckLevel::normal, settings->checkLevel);
+        ASSERT_EQUALS(100, settings->vfOptions.maxIfCount);
+        ASSERT_EQUALS(8, settings->vfOptions.maxSubFunctionArgs);
+        ASSERT_EQUALS(false, settings->vfOptions.doConditionExpressionAnalysis);
+        ASSERT_EQUALS(4, settings->vfOptions.maxForwardBranches);
+    }
+
+    void checkLevelExhaustive() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--check-level=exhaustive", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(Settings::CheckLevel::exhaustive, settings->checkLevel);
+        ASSERT_EQUALS(-1, settings->vfOptions.maxIfCount);
+        ASSERT_EQUALS(256, settings->vfOptions.maxSubFunctionArgs);
+        ASSERT_EQUALS(true, settings->vfOptions.doConditionExpressionAnalysis);
+        ASSERT_EQUALS(-1, settings->vfOptions.maxForwardBranches);
+    }
+
+    void checkLevelUnknown() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--check-level=default", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unknown '--check-level' value 'default'.\n", logger->str());
+    }
+
+    void cppHeaderProbe() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--cpp-header-probe", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->cppHeaderProbe);
+    }
+
+    void cppHeaderProbe2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--no-cpp-header-probe", "--cpp-header-probe", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->cppHeaderProbe);
+    }
+
+    void noCppHeaderProbe() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--no-cpp-header-probe", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(false, settings->cppHeaderProbe);
+    }
+
+    void noCppHeaderProbe2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--cpp-header-probe", "--no-cpp-header-probe", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(false, settings->cppHeaderProbe);
+    }
+
+    void debugLookup() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--debug-lookup", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        GET_REDIRECT_OUTPUT; // ignore config lookup output
+        ASSERT_EQUALS(true, settings->debuglookup);
+    }
+
+    void debugLookupAll() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--debug-lookup=all", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        GET_REDIRECT_OUTPUT; // ignore config lookup output
+        ASSERT_EQUALS(true, settings->debuglookup);
+    }
+
+    void debugLookupAddon() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--debug-lookup=addon", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->debuglookupAddon);
+    }
+
+    void debugLookupConfig() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--debug-lookup=config", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        GET_REDIRECT_OUTPUT; // ignore config lookup output
+        ASSERT_EQUALS(true, settings->debuglookupConfig);
+    }
+
+    void debugLookupLibrary() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--debug-lookup=library", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->debuglookupLibrary);
+    }
+
+    void debugLookupPlatform() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--debug-lookup=platform", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->debuglookupPlatform);
+    }
+
+    void maxTemplateRecursion() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--max-template-recursion=12", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(12, settings->maxTemplateRecursion);
+    }
+
+    void maxTemplateRecursionMissingCount() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--max-template-recursion=", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '--max-template-recursion=' is not valid - not an integer.\n", logger->str());
+    }
+
+    void emitDuplicates() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--emit-duplicates", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->emitDuplicates);
+    }
+
+    void debugClangOutput() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--debug-clang-output", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->debugClangOutput);
+    }
+
+    void debugXmlMultiple() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--debug", "--xml", "1.cpp", "2.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: printing debug output in XML format does not support multiple input files.\n", logger->str());
+    }
+
+    void debugNormalXmlMultiple() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--debug-normal", "--xml", "1.cpp", "2.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: printing debug output in XML format does not support multiple input files.\n", logger->str());
+    }
+
+    void debugIgnore() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--debug-ignore", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->debugignore);
+    }
+
+    void checkHeaders() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--check-headers", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->checkHeaders);
+    }
+
+    void noCheckHeaders() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--no-check-headers", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(false, settings->checkHeaders);
+    }
+
+    void noCheckHeaders2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--check-headers", "--no-check-headers", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(false, settings->checkHeaders);
+    }
+
+    void filesdir() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--filesdir"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
+#ifdef FILESDIR
+        ASSERT_EQUALS(std::string(FILESDIR) + '\n', logger->str());
+#else
+        ASSERT_EQUALS("", logger->str());
+#endif
+    }
+
+    void checkUnusedTemplates() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--check-unused-templates", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->checkUnusedTemplates);
+    }
+
+    void noCheckUnusedTemplates() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--no-check-unused-templates", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs( argv));
+        ASSERT_EQUALS(false, settings->checkUnusedTemplates);
+    }
+
+    void noCheckUnusedTemplates2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--check-unused-templates", "--no-check-unused-templates", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(false, settings->checkUnusedTemplates);
+    }
+
+    void clangTidy() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--clang-tidy", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->clangTidy);
+        ASSERT_EQUALS("clang-tidy", settings->clangTidyExecutable);
+    }
+
+    void clangTidyCustom() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--clang-tidy=clang-tidy-14", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->clangTidy);
+        ASSERT_EQUALS("clang-tidy-14", settings->clangTidyExecutable);
+    }
+
+    void projectConfigurationNoProject() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--project-configuration=Debug|Win32", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: --project-configuration has no effect - no Visual Studio project provided.\n", logger->str());
+    }
+
+    void projectConfigurationEmpty() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--project-configuration=", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: --project-configuration parameter is empty.\n", logger->str());
+    }
+
+    void analyzeAllVsConfigs() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--analyze-all-vs-configs", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->analyzeAllVsConfigs);
+        ASSERT(parser->mAnalyzeAllVsConfigsSetOnCmdLine);
+    }
+
+    void noAnalyzeAllVsConfigs() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--no-analyze-all-vs-configs", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: --no-analyze-all-vs-configs has no effect - no Visual Studio project provided.\n", logger->str());
+        ASSERT(parser->mAnalyzeAllVsConfigsSetOnCmdLine);
+    }
+
+    void noAnalyzeAllVsConfigs2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--analyze-all-vs-configs", "--no-analyze-all-vs-configs", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: --no-analyze-all-vs-configs has no effect - no Visual Studio project provided.\n", logger->str());
+        ASSERT(parser->mAnalyzeAllVsConfigsSetOnCmdLine);
+    }
+
+    void debugSymdb() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--debug-symdb", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->debugsymdb);
+    }
+
+    void debugAst() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--debug-ast", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->debugast);
+    }
+
+    void debugValueflow() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--debug-valueflow", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->debugvalueflow);
+    }
+
+    void debugNormal() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--debug-normal", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->debugnormal);
+        ASSERT_EQUALS(false, settings->debugSimplified);
+        ASSERT_EQUALS(true, settings->debugvalueflow);
+        ASSERT_EQUALS(false, settings->debugast);
+        ASSERT_EQUALS(false, settings->debugsymdb);
+    }
+
+    void debugNormalVerbose() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--debug-normal", "--verbose", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->debugnormal);
+        ASSERT_EQUALS(false, settings->debugSimplified);
+        ASSERT_EQUALS(true, settings->debugvalueflow);
+        ASSERT_EQUALS(true, settings->debugast);
+        ASSERT_EQUALS(true, settings->debugsymdb);
+    }
+
+    void debug() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--debug", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->debugnormal);
+        ASSERT_EQUALS(false, settings->debugSimplified);
+        ASSERT_EQUALS(true, settings->debugvalueflow);
+        ASSERT_EQUALS(false, settings->debugast);
+        ASSERT_EQUALS(false, settings->debugsymdb);
+    }
+
+    void debugVerbose() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--debug", "--verbose", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->debugnormal);
+        ASSERT_EQUALS(false, settings->debugSimplified);
+        ASSERT_EQUALS(true, settings->debugvalueflow);
+        ASSERT_EQUALS(true, settings->debugast);
+        ASSERT_EQUALS(true, settings->debugsymdb);
+    }
+
+    void safety() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--safety", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->safety);
+    }
+
+    void safetyOverride() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--no-safety", "--safety", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->safety);
+    }
+
+    void noSafety() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--no-safety", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(false, settings->safety);
+    }
+
+    void noSafetyOverride() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--safety", "--no-safety", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(false, settings->safety);
+    }
+
+    void debugAnalyzerinfo() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--debug-analyzerinfo", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->debugainfo);
+    }
+
+    void ignorepaths1() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-isrc", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(1, parser->mIgnoredPaths.size());
+        ASSERT_EQUALS("src", parser->mIgnoredPaths[0]);
+        ASSERT_EQUALS(1, parser->mPathNames.size());
+        ASSERT_EQUALS("file.cpp", parser->mPathNames[0]);
+    }
+
+    void ignorepaths2() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-i", "src", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(1, parser->mIgnoredPaths.size());
+        ASSERT_EQUALS("src", parser->mIgnoredPaths[0]);
+        ASSERT_EQUALS(1, parser->mPathNames.size());
+        ASSERT_EQUALS("file.cpp", parser->mPathNames[0]);
+    }
+
+    void ignorepaths3() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-isrc", "-imodule", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(2, parser->mIgnoredPaths.size());
+        ASSERT_EQUALS("src", parser->mIgnoredPaths[0]);
+        ASSERT_EQUALS("module", parser->mIgnoredPaths[1]);
+        ASSERT_EQUALS(1, parser->mPathNames.size());
+        ASSERT_EQUALS("file.cpp", parser->mPathNames[0]);
+    }
 
-        void ignorepaths3() {
-            REDIRECT;
-            const char * const argv[] = {"cppcheck", "-isrc", "-imodule", "file.cpp"};
-            CmdLineParser parser(&settings);
-            ASSERT(parser.parseFromArgs(4, argv));
-            ASSERT_EQUALS(2, parser.getIgnoredPaths().size());
-            ASSERT_EQUALS("src/", parser.getIgnoredPaths()[0]);
-            ASSERT_EQUALS("module/", parser.getIgnoredPaths()[1]);
-        }
-    */
     void ignorepaths4() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-i", "src", "-i", "module", "file.cpp"};
-        CmdLineParser parser(&settings);
-        ASSERT(parser.parseFromArgs(6, argv));
-        ASSERT_EQUALS(2, parser.getIgnoredPaths().size());
-        ASSERT_EQUALS("src/", parser.getIgnoredPaths()[0]);
-        ASSERT_EQUALS("module/", parser.getIgnoredPaths()[1]);
-    }
-    /*
-        void ignorefilepaths1() {
-            REDIRECT;
-            const char * const argv[] = {"cppcheck", "-ifoo.cpp", "file.cpp"};
-            CmdLineParser parser(&settings);
-            ASSERT(parser.parseFromArgs(3, argv));
-            ASSERT_EQUALS(1, parser.getIgnoredPaths().size());
-            ASSERT_EQUALS("foo.cpp", parser.getIgnoredPaths()[0]);
-        }
-    */
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(2, parser->mIgnoredPaths.size());
+        ASSERT_EQUALS("src", parser->mIgnoredPaths[0]);
+        ASSERT_EQUALS("module", parser->mIgnoredPaths[1]);
+        ASSERT_EQUALS(1, parser->mPathNames.size());
+        ASSERT_EQUALS("file.cpp", parser->mPathNames[0]);
+    }
+
+    void ignorefilepaths1() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-ifoo.cpp", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(1, parser->mIgnoredPaths.size());
+        ASSERT_EQUALS("foo.cpp", parser->mIgnoredPaths[0]);
+        ASSERT_EQUALS(1, parser->mPathNames.size());
+        ASSERT_EQUALS("file.cpp", parser->mPathNames[0]);
+    }
+
     void ignorefilepaths2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-isrc/foo.cpp", "file.cpp"};
-        CmdLineParser parser(&settings);
-        ASSERT(parser.parseFromArgs(3, argv));
-        ASSERT_EQUALS(1, parser.getIgnoredPaths().size());
-        ASSERT_EQUALS("src/foo.cpp", parser.getIgnoredPaths()[0]);
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(1, parser->mIgnoredPaths.size());
+        ASSERT_EQUALS("src/foo.cpp", parser->mIgnoredPaths[0]);
+        ASSERT_EQUALS(1, parser->mPathNames.size());
+        ASSERT_EQUALS("file.cpp", parser->mPathNames[0]);
+    }
+
+    void ignorefilepaths3() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-i", "foo.cpp", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(1, parser->mIgnoredPaths.size());
+        ASSERT_EQUALS("foo.cpp", parser->mIgnoredPaths[0]);
+        ASSERT_EQUALS(1, parser->mPathNames.size());
+        ASSERT_EQUALS("file.cpp", parser->mPathNames[0]);
+    }
+
+    void ignorefilepaths4() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-ifoo.cpp", "file.cpp"};
+        ASSERT(!fillSettingsFromArgs(argv));
+        ASSERT_EQUALS(1, parser->mIgnoredPaths.size());
+        ASSERT_EQUALS("foo.cpp", parser->mIgnoredPaths[0]);
+        ASSERT_EQUALS(1, parser->mPathNames.size());
+        ASSERT_EQUALS("file.cpp", parser->mPathNames[0]);
+        TODO_ASSERT_EQUALS("cppcheck: error: could not find or open any of the paths given.\n", "cppcheck: error: could not find or open any of the paths given.\ncppcheck: Maybe all paths were ignored?\n", logger->str());
+    }
+
+    void ignorefilepaths5() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-ifile.cpp", "file.cpp"};
+        ASSERT(!fillSettingsFromArgs(argv));
+        ASSERT_EQUALS(1, parser->mIgnoredPaths.size());
+        ASSERT_EQUALS("file.cpp", parser->mIgnoredPaths[0]);
+        ASSERT_EQUALS(1, parser->mPathNames.size());
+        ASSERT_EQUALS("file.cpp", parser->mPathNames[0]);
+        ASSERT_EQUALS("cppcheck: error: could not find or open any of the paths given.\ncppcheck: Maybe all paths were ignored?\n", logger->str());
+    }
+
+    void ignorefilepaths6() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-isrc/file.cpp", "src/file.cpp"};
+        ASSERT(!fillSettingsFromArgs(argv));
+        ASSERT_EQUALS(1, parser->mIgnoredPaths.size());
+        ASSERT_EQUALS("src/file.cpp", parser->mIgnoredPaths[0]);
+        ASSERT_EQUALS(1, parser->mPathNames.size());
+        ASSERT_EQUALS("src/file.cpp", parser->mPathNames[0]);
+        ASSERT_EQUALS("cppcheck: error: could not find or open any of the paths given.\ncppcheck: Maybe all paths were ignored?\n", logger->str());
+    }
+
+    void ignorefilepaths7() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-isrc\\file.cpp", "src/file.cpp"};
+        ASSERT(!fillSettingsFromArgs(argv));
+        ASSERT_EQUALS(1, parser->mIgnoredPaths.size());
+        ASSERT_EQUALS("src/file.cpp", parser->mIgnoredPaths[0]);
+        ASSERT_EQUALS(1, parser->mPathNames.size());
+        ASSERT_EQUALS("src/file.cpp", parser->mPathNames[0]);
+        ASSERT_EQUALS("cppcheck: error: could not find or open any of the paths given.\ncppcheck: Maybe all paths were ignored?\n", logger->str());
+    }
+
+    void ignorefilepaths8() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-isrc/file.cpp", "src\\file.cpp"};
+        ASSERT(!fillSettingsFromArgs(argv));
+        ASSERT_EQUALS(1, parser->mIgnoredPaths.size());
+        ASSERT_EQUALS("src/file.cpp", parser->mIgnoredPaths[0]);
+        ASSERT_EQUALS(1, parser->mPathNames.size());
+        ASSERT_EQUALS("src/file.cpp", parser->mPathNames[0]);
+        ASSERT_EQUALS("cppcheck: error: could not find or open any of the paths given.\ncppcheck: Maybe all paths were ignored?\n", logger->str());
+    }
+
+    void ignorefilepaths9() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "-isrc\\", "src\\file.cpp"};
+        ASSERT(!fillSettingsFromArgs(argv));
+        ASSERT_EQUALS(1, parser->mIgnoredPaths.size());
+        ASSERT_EQUALS("src/", parser->mIgnoredPaths[0]);
+        ASSERT_EQUALS(1, parser->mPathNames.size());
+        ASSERT_EQUALS("src/file.cpp", parser->mPathNames[0]);
+        ASSERT_EQUALS("cppcheck: error: could not find or open any of the paths given.\ncppcheck: Maybe all paths were ignored?\n", logger->str());
+    }
+
+    void nonexistentpath() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "file.cpp"};
+        ASSERT(!fillSettingsFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: could not find or open any of the paths given.\n", logger->str());
     }
 
     void checkconfig() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--check-config", "file.cpp"};
-        settings.checkConfiguration = false;
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT_EQUALS(true, settings.checkConfiguration);
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->checkConfiguration);
     }
 
     void unknownParam() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--foo", "file.cpp"};
-        ASSERT(!defParser.parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--foo\".\n", logger->str());
     }
 
     void undefs() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-U_WIN32", "file.cpp"};
-        settings = Settings();
-        ASSERT(defParser.parseFromArgs(3, argv));
-        ASSERT_EQUALS(1, settings.userUndefs.size());
-        ASSERT(settings.userUndefs.find("_WIN32") != settings.userUndefs.end());
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(1, settings->userUndefs.size());
+        ASSERT(settings->userUndefs.find("_WIN32") != settings->userUndefs.end());
     }
 
     void undefs2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-U_WIN32", "-UNODEBUG", "file.cpp"};
-        settings = Settings();
-        ASSERT(defParser.parseFromArgs(4, argv));
-        ASSERT_EQUALS(2, settings.userUndefs.size());
-        ASSERT(settings.userUndefs.find("_WIN32") != settings.userUndefs.end());
-        ASSERT(settings.userUndefs.find("NODEBUG") != settings.userUndefs.end());
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(2, settings->userUndefs.size());
+        ASSERT(settings->userUndefs.find("_WIN32") != settings->userUndefs.end());
+        ASSERT(settings->userUndefs.find("NODEBUG") != settings->userUndefs.end());
     }
 
     void undefs_noarg() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-U"};
         // Fails since -U has no param
-        ASSERT_EQUALS(false, defParser.parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '-U' is missing.\n", logger->str());
     }
 
     void undefs_noarg2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-U", "-v", "file.cpp"};
         // Fails since -U has no param
-        ASSERT_EQUALS(false, defParser.parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '-U' is missing.\n", logger->str());
     }
 
     void undefs_noarg3() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-U", "--quiet", "file.cpp"};
         // Fails since -U has no param
-        ASSERT_EQUALS(false, defParser.parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: argument to '-U' is missing.\n", logger->str());
+    }
+
+    void cppcheckBuildDirExistent() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--cppcheck-build-dir=.", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(".", settings->buildDir);
+    }
+
+    void cppcheckBuildDirNonExistent() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--cppcheck-build-dir=non-existent-path", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: Directory 'non-existent-path' specified by --cppcheck-build-dir argument has to be existent.\n", logger->str());
+    }
+
+    void cppcheckBuildDirEmpty() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--cppcheck-build-dir=", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: no path has been specified for --cppcheck-build-dir\n", logger->str());
+    }
+
+    void cppcheckBuildDirMultiple() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--cppcheck-build-dir=non-existent-path", "--cppcheck-build-dir=.", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(".", settings->buildDir);
+    }
+
+    void noCppcheckBuildDir()
+    {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--no-cppcheck-build-dir", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->buildDir.empty());
+    }
+
+    void noCppcheckBuildDir2()
+    {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--cppcheck-build-dir=b1", "--no-cppcheck-build-dir", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT(settings->buildDir.empty());
+    }
+
+    void invalidCppcheckCfg() {
+        REDIRECT;
+        ScopedFile file(Path::join(Path::getPathFromFilename(Path::getCurrentExecutablePath("")), "cppcheck.cfg"),
+                        "{\n");
+        const char * const argv[] = {"cppcheck", "test.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: could not load cppcheck.cfg - not a valid JSON - syntax error at line 2 near: \n", logger->str());
+    }
+
+    void reportTypeAutosar() {
+        REDIRECT;
+        const char *const argv[] = { "cppcheck", "--report-type=autosar", "file.cpp" };
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(ReportType::autosar, settings->reportType);
+    }
+
+    void reportTypeCertCpp() {
+        REDIRECT;
+        const char *const argv[] = { "cppcheck", "--report-type=cert-cpp-2016", "file.cpp" };
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(ReportType::certCpp, settings->reportType);
+    }
+
+    void reportTypeCertC() {
+        REDIRECT;
+        const char *const argv[] = { "cppcheck", "--report-type=cert-c-2016", "file.cpp" };
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(ReportType::certC, settings->reportType);
+    }
+
+    void reportTypeMisraC2012() {
+        REDIRECT;
+        const char *const argv[] = { "cppcheck", "--report-type=misra-c-2012", "file.cpp" };
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(ReportType::misraC2012, settings->reportType);
+    }
+
+    void reportTypeMisraC2023() {
+        REDIRECT;
+        const char *const argv[] = { "cppcheck", "--report-type=misra-c-2023", "file.cpp" };
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(ReportType::misraC2023, settings->reportType);
+    }
+
+    void reportTypeMisraC2025() {
+        REDIRECT;
+        const char *const argv[] = { "cppcheck", "--report-type=misra-c-2025", "file.cpp" };
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(ReportType::misraC2025, settings->reportType);
+    }
+
+    void reportTypeMisraCpp2008() {
+        REDIRECT;
+        const char *const argv[] = { "cppcheck", "--report-type=misra-cpp-2008", "file.cpp" };
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(ReportType::misraCpp2008, settings->reportType);
+    }
+
+    void reportTypeMisraCpp2023() {
+        REDIRECT;
+        const char *const argv[] = { "cppcheck", "--report-type=misra-cpp-2023", "file.cpp" };
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(ReportType::misraCpp2023, settings->reportType);
+    }
+
+    void invalidReportType() {
+        REDIRECT;
+        const char *const argv[] = { "cppcheck", "--report-type=invalid", "file.cpp" };
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
+        ASSERT_EQUALS("cppcheck: error: Unknown report type 'invalid'\n", logger->str());
+    }
+
+    void defaultReportType() {
+        REDIRECT;
+        const char *const argv[] = { "cppcheck", "file.cpp" };
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS_ENUM(ReportType::normal, settings->reportType);
     }
 };
 
diff --git a/test/testcolor.cpp b/test/testcolor.cpp
new file mode 100644
index 00000000000..7351cb2df9e
--- /dev/null
+++ b/test/testcolor.cpp
@@ -0,0 +1,38 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2023 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "color.h"
+#include "fixture.h"
+
+class TestColor : public TestFixture {
+public:
+    TestColor() : TestFixture("TestColor") {}
+
+private:
+
+    void run() override {
+        TEST_CASE(toString);
+    }
+
+    void toString() const {
+        // TODO: color conversion is dependent on stdout/stderr being a TTY
+        ASSERT_EQUALS("", ::toString(Color::FgRed));
+    }
+};
+
+REGISTER_TEST(TestColor)
diff --git a/test/testcondition.cpp b/test/testcondition.cpp
index beaa5a6ff78..241d0400099 100644
--- a/test/testcondition.cpp
+++ b/test/testcondition.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,42 +17,32 @@
  */
 
 #include "checkcondition.h"
-#include "library.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
+#include "platform.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
 
-#include <simplecpp.h>
-#include <tinyxml2.h>
-#include <map>
-#include <vector>
+#include <cstddef>
+#include <string>
 
 class TestCondition : public TestFixture {
 public:
-    TestCondition() : TestFixture("TestCondition") {
-    }
+    TestCondition() : TestFixture("TestCondition") {}
 
 private:
-    Settings settings0;
-    Settings settings1;
-
-    void run() OVERRIDE {
-        LOAD_LIB_2(settings0.library, "qt.cfg");
-        LOAD_LIB_2(settings0.library, "std.cfg");
-
-        settings0.addEnabled("style");
-        settings0.addEnabled("warning");
+    const Settings settings0 = settingsBuilder().library("qt.cfg").library("std.cfg").severity(Severity::style).severity(Severity::warning).build();
+    /*const*/ Settings settings1 = settingsBuilder().severity(Severity::style).severity(Severity::warning).build();
+    const Settings settings2 = settingsBuilder(settings0).severity(Severity::performance).certainty(Certainty::inconclusive).build();
 
+    void run() override {
         const char cfg[] = "<?xml version=\"1.0\"?>\n"
-        "<def>\n"
-        "  <function name=\"bar\"> <pure/> </function>\n"
-        "</def>";
-        tinyxml2::XMLDocument xmldoc;
-        xmldoc.Parse(cfg, sizeof(cfg));
-        settings1.addEnabled("style");
-        settings1.addEnabled("warning");
-        settings1.library.load(xmldoc);
+                           "<def>\n"
+                           "  <function name=\"bar\"> <pure/> </function>\n"
+                           "</def>";
+        settings1 = settingsBuilder(settings1).libraryxml(cfg).build();
 
+        mNewTemplate = true;
         TEST_CASE(assignAndCompare);   // assignment and comparison don't match
         TEST_CASE(mismatchingBitAnd);  // overlapping bitmasks
         TEST_CASE(comparison);         // CheckCondition::comparison test cases
@@ -76,6 +66,9 @@ class TestCondition : public TestFixture {
         TEST_CASE(incorrectLogicOperator12);
         TEST_CASE(incorrectLogicOperator13);
         TEST_CASE(incorrectLogicOperator14);
+        TEST_CASE(incorrectLogicOperator15);
+        TEST_CASE(incorrectLogicOperator16); // #10070
+        TEST_CASE(incorrectLogicOperator17);
         TEST_CASE(secondAlwaysTrueFalseWhenFirstTrueError);
         TEST_CASE(incorrectLogicOp_condSwapping);
         TEST_CASE(testBug5895);
@@ -91,8 +84,10 @@ class TestCondition : public TestFixture {
         TEST_CASE(oppositeInnerCondition2);
         TEST_CASE(oppositeInnerCondition3);
         TEST_CASE(oppositeInnerConditionAnd);
+        TEST_CASE(oppositeInnerConditionOr);
         TEST_CASE(oppositeInnerConditionEmpty);
         TEST_CASE(oppositeInnerConditionFollowVar);
+        TEST_CASE(oppositeInnerConditionLambda);
 
         TEST_CASE(identicalInnerCondition);
 
@@ -109,6 +104,13 @@ class TestCondition : public TestFixture {
         TEST_CASE(clarifyCondition8);
 
         TEST_CASE(alwaysTrue);
+        TEST_CASE(alwaysTrueSymbolic);
+        TEST_CASE(alwaysTrueInfer);
+        TEST_CASE(alwaysTrueContainer);
+        TEST_CASE(alwaysTrueLoop);
+        TEST_CASE(alwaysTrueTryCatch);
+        TEST_CASE(alwaysTrueSideEffect);
+        TEST_CASE(alwaysTruePremiumMisra);
         TEST_CASE(multiConditionAlwaysTrue);
         TEST_CASE(duplicateCondition);
 
@@ -117,32 +119,49 @@ class TestCondition : public TestFixture {
         TEST_CASE(alwaysTrueFalseInLogicalOperators);
         TEST_CASE(pointerAdditionResultNotNull);
         TEST_CASE(duplicateConditionalAssign);
+
+        TEST_CASE(checkAssignmentInCondition);
+        TEST_CASE(compareOutOfTypeRange);
+        TEST_CASE(knownConditionCast); // #9976
+        TEST_CASE(knownConditionIncrementLoop); // #9808
+        TEST_CASE(knownConditionAfterBailout); // #12526
+        TEST_CASE(knownConditionIncDecOperator);
+        TEST_CASE(knownConditionFloating);
     }
 
-    void check(const char code[], const char* filename = "test.cpp", bool inconclusive = false) {
-        // Clear the error buffer..
-        errout.str("");
+    struct CheckOptions
+    {
+        bool cpp = true;
+    };
 
-        settings0.inconclusive = inconclusive;
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
+        check_(file, line, code, settings0, options.cpp);
+    }
+
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const Settings& settings, bool cpp = true) {
+        SimpleTokenizer2 tokenizer(settings, *this, code, cpp ? "test.cpp" : "test.c");
+
+        // Tokenizer..
+        ASSERT_LOC(tokenizer.simplifyTokens1(""), file, line);
 
-        // Raw tokens..
-        std::vector<std::string> files(1, filename);
-        std::istringstream istr(code);
-        const simplecpp::TokenList tokens1(istr, files, files[0]);
+        // Run checks..
+        runChecks<CheckCondition>(tokenizer, this);
+    }
 
-        // Preprocess..
-        simplecpp::TokenList tokens2(files);
-        std::map<std::string, simplecpp::TokenList*> filedata;
-        simplecpp::preprocess(tokens2, tokens1, files, filedata, simplecpp::DUI());
+#define checkP(...) checkP_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkP_(const char* file, int line, const char (&code)[size])
+    {
+        SimpleTokenizer2 tokenizer(settings2, *this, code, "test.cpp");
 
         // Tokenizer..
-        Tokenizer tokenizer(&settings0, this);
-        tokenizer.createTokens(&tokens2);
-        tokenizer.simplifyTokens1("");
+        ASSERT_LOC(tokenizer.simplifyTokens1(""), file, line);
 
         // Run checks..
-        CheckCondition checkCondition;
-        checkCondition.runChecks(&tokenizer, &settings0, this);
+        runChecks<CheckCondition>(tokenizer, this);
     }
 
     void assignAndCompare() {
@@ -152,59 +171,59 @@ class TestCondition : public TestFixture {
               "    int y = x & 4;\n"
               "    if (y == 3);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (style) Mismatching assignment and comparison, comparison 'y==3' is always false.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:4:8]: (style) Mismatching assignment and comparison, comparison 'y==3' is always false. [assignIfError]\n", errout_str());
 
         check("void foo(int x)\n"
               "{\n"
               "    int y = x & 4;\n"
               "    if (y != 3);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (style) Mismatching assignment and comparison, comparison 'y!=3' is always true.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:4:8]: (style) Mismatching assignment and comparison, comparison 'y!=3' is always true. [assignIfError]\n", errout_str());
 
         // |
         check("void foo(int x) {\n"
               "    int y = x | 0x14;\n"
               "    if (y == 0x710);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Mismatching assignment and comparison, comparison 'y==1808' is always false.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:8]: (style) Mismatching assignment and comparison, comparison 'y==0x710' is always false. [assignIfError]\n", errout_str());
 
         check("void foo(int x) {\n"
               "    int y = x | 0x14;\n"
               "    if (y == 0x71f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // various simple assignments
         check("void foo(int x) {\n"
               "    int y = (x+1) | 1;\n"
               "    if (y == 2);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Mismatching assignment and comparison, comparison 'y==2' is always false.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:8]: (style) Mismatching assignment and comparison, comparison 'y==2' is always false. [assignIfError]\n", errout_str());
 
         check("void foo() {\n"
               "    int y = 1 | x();\n"
               "    if (y == 2);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Mismatching assignment and comparison, comparison 'y==2' is always false.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:8]: (style) Mismatching assignment and comparison, comparison 'y==2' is always false. [assignIfError]\n", errout_str());
 
         // multiple conditions
         check("void foo(int x) {\n"
               "    int y = x & 4;\n"
               "    if ((y == 3) && (z == 1));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Mismatching assignment and comparison, comparison 'y==3' is always false.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:9]: (style) Mismatching assignment and comparison, comparison 'y==3' is always false. [assignIfError]\n", errout_str());
 
         check("void foo(int x) {\n"
               "    int y = x & 4;\n"
               "    if ((x==123) || ((y == 3) && (z == 1)));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Mismatching assignment and comparison, comparison 'y==3' is always false.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:22]: (style) Mismatching assignment and comparison, comparison 'y==3' is always false. [assignIfError]\n", errout_str());
 
         check("void f(int x) {\n"
               "    int y = x & 7;\n"
               "    if (setvalue(&y) && y != 8);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // recursive checking into scopes
         check("void f(int x) {\n"
@@ -212,20 +231,20 @@ class TestCondition : public TestFixture {
               "    if (z) y=0;\n"
               "    else { if (y==8); }\n" // always false
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (style) Mismatching assignment and comparison, comparison 'y==8' is always false.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:4:15]: (style) Mismatching assignment and comparison, comparison 'y==8' is always false. [assignIfError]\n", errout_str());
 
         // while
         check("void f(int x) {\n"
               "    int y = x & 7;\n"
               "    while (y==8);\n" // local variable => always false
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Mismatching assignment and comparison, comparison 'y==8' is always false.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:11]: (style) Mismatching assignment and comparison, comparison 'y==8' is always false. [assignIfError]\n", errout_str());
 
         check("void f(int x) {\n"
               "    extern int y; y = x & 7;\n"
               "    while (y==8);\n" // non-local variable => no error
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    int a = 100;\n"
@@ -234,7 +253,7 @@ class TestCondition : public TestFixture {
               "        while (y != 0) y--;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void g(int x);\n"
               "void f(int x) {\n"
@@ -245,8 +264,8 @@ class TestCondition : public TestFixture {
               "    }\n"
               "}");
         ASSERT_EQUALS(
-            "[test.cpp:5] -> [test.cpp:6]: (style) Mismatching assignment and comparison, comparison 'y!=0' is always true.\n",
-            errout.str());
+            "[test.cpp:5:15] -> [test.cpp:6:15]: (style) Mismatching assignment and comparison, comparison 'y!=0' is always true. [assignIfError]\n",
+            errout_str());
 
         check("void g(int &x);\n"
               "void f(int x) {\n"
@@ -256,7 +275,7 @@ class TestCondition : public TestFixture {
               "        while (y != 0) g(y);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // calling function
         check("void f(int x) {\n"
@@ -264,14 +283,14 @@ class TestCondition : public TestFixture {
               "    do_something();\n"
               "    if (y==8);\n" // local variable => always false
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (style) Mismatching assignment and comparison, comparison 'y==8' is always false.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:4:8]: (style) Mismatching assignment and comparison, comparison 'y==8' is always false. [assignIfError]\n", errout_str());
 
         check("void f(int x) {\n"
               "    int y = x & 7;\n"
               "    do_something(&y);\n" // passing variable => no error
               "    if (y==8);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void do_something(int);\n"
               "void f(int x) {\n"
@@ -279,14 +298,14 @@ class TestCondition : public TestFixture {
               "    do_something(y);\n"
               "    if (y==8);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (style) Mismatching assignment and comparison, comparison 'y==8' is always false.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:5:8]: (style) Mismatching assignment and comparison, comparison 'y==8' is always false. [assignIfError]\n", errout_str());
 
         check("void f(int x) {\n"
               "    extern int y; y = x & 7;\n"
               "    do_something();\n"
               "    if (y==8);\n" // non-local variable => no error
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #4434 : false positive: ?:
         check("void f(int x) {\n"
@@ -294,28 +313,28 @@ class TestCondition : public TestFixture {
               "    x = x & 1 ? 1 : -1;\n"
               "    if(x != -1) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #4735
         check("void f() {\n"
               "    int x = *(char*)&0x12345678;\n"
               "    if (x==18) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // bailout: no variable info
         check("void foo(int x) {\n"
               "    y = 2 | x;\n"  // y not declared => no error
               "    if(y == 1) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // bailout: negative number
         check("void foo(int x) {\n"
               "    int y = -2 | x;\n" // negative number => no error
               "    if (y==1) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // bailout: pass variable to function
         check("void foo(int x) {\n"
@@ -323,14 +342,17 @@ class TestCondition : public TestFixture {
               "    bar(&y);\n"  // pass variable to function => no error
               "    if (y==1) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // no crash on unary operator& (#5643)
+        // #11610
         check("SdrObject* ApplyGraphicToObject() {\n"
               "    if (&rHitObject) {}\n"
               "    else if (rHitObject.IsClosedObj() && !&rHitObject) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Condition '&rHitObject' is always true [knownConditionTrueFalse]\n"
+                      "[test.cpp:3:42]: (style) Condition '!&rHitObject' is always false [knownConditionTrueFalse]\n",
+                      errout_str());
 
         // #5695: increment
         check("void f(int a0, int n) {\n"
@@ -340,24 +362,24 @@ class TestCondition : public TestFixture {
               "    if (c == 4)\n"
               "      c  = 0;\n"
               "  }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int a) {\n" // #6662
               "  int x = a & 1;\n"
               "  while (x <= 4) {\n"
               "    if (x != 5) {}\n"
               "  }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (style) Mismatching assignment and comparison, comparison 'x!=5' is always true.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:4:8]: (style) Mismatching assignment and comparison, comparison 'x!=5' is always true. [assignIfError]\n", errout_str());
 
         check("void f(int a) {\n" // #6662
               "  int x = a & 1;\n"
               "  while ((x += 4) < 10) {\n"
               "    if (x != 5) {}\n"
               "  }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int x = 100;\n"
@@ -365,7 +387,7 @@ class TestCondition : public TestFixture {
               "        g(x);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void g(int x);\n"
               "void f() {\n"
@@ -374,7 +396,7 @@ class TestCondition : public TestFixture {
               "        g(x);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Condition 'x' is always true\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:12]: (style) Condition 'x' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void g(int & x);\n"
               "void f() {\n"
@@ -383,7 +405,7 @@ class TestCondition : public TestFixture {
               "        g(x);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
     }
 
@@ -392,13 +414,13 @@ class TestCondition : public TestFixture {
               "    int b = a & 0xf0;\n"
               "    b &= 1;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Mismatching bitmasks. Result is always 0 (X = Y & 0xf0; Z = X & 0x1; => Z=0).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:5]: (style) Mismatching bitmasks. Result is always 0 (X = Y & 0xf0; Z = X & 0x1; => Z=0). [mismatchingBitAnd]\n", errout_str());
 
         check("void f(int a) {\n"
               "    int b = a & 0xf0;\n"
               "    int c = b & 1;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Mismatching bitmasks. Result is always 0 (X = Y & 0xf0; Z = X & 0x1; => Z=0).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:9]: (style) Mismatching bitmasks. Result is always 0 (X = Y & 0xf0; Z = X & 0x1; => Z=0). [mismatchingBitAnd]\n", errout_str());
 
         check("void f(int a) {\n"
               "    int b = a;"
@@ -407,67 +429,103 @@ class TestCondition : public TestFixture {
               "    case 2: b &= 2; break;\n"
               "    };\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void comparison() {
         // CheckCondition::comparison test cases
         // '=='
         check("void f(int a) {\n assert( (a & 0x07) == 8U );\n}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X & 0x7) == 0x8' is always false.\n",errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X & 0x7) == 0x8' is always false. [comparisonError]\n",errout_str());
         check("void f(int a) {\n assert( (a & b & 4 & c ) == 3 );\n}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X & 0x4) == 0x3' is always false.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:21]: (style) Expression '(X & 0x4) == 0x3' is always false. [comparisonError]\n", errout_str());
         check("void f(int a) {\n assert( (a | 0x07) == 8U );\n}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X | 0x7) == 0x8' is always false.\n",errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X | 0x7) == 0x8' is always false. [comparisonError]\n",errout_str());
         check("void f(int a) {\n assert( (a & 0x07) == 7U );\n}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void f(int a) {\n assert( (a | 0x01) == -15 );\n}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         // '!='
         check("void f(int a) {\n assert( (a & 0x07) != 8U );\n}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X & 0x7) != 0x8' is always true.\n",errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X & 0x7) != 0x8' is always true. [comparisonError]\n",errout_str());
         check("void f(int a) {\n assert( (a | 0x07) != 8U );\n}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X | 0x7) != 0x8' is always true.\n",errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X | 0x7) != 0x8' is always true. [comparisonError]\n",errout_str());
         check("void f(int a) {\n assert( (a & 0x07) != 7U );\n}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void f(int a) {\n assert( (a | 0x07) != 7U );\n}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         // '>='
         check("void f(int a) {\n assert( (a & 0x07) >= 8U );\n}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X & 0x7) >= 0x8' is always false.\n",errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X & 0x7) >= 0x8' is always false. [comparisonError]\n",errout_str());
         check("void f(unsigned int a) {\n assert( (a | 0x7) >= 7U );\n}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X | 0x7) >= 0x7' is always true.\n",errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X | 0x7) >= 0x7' is always true. [comparisonError]\n",errout_str());
         check("void f(int a) {\n assert( (a & 0x07) >= 7U );\n}");
-        ASSERT_EQUALS("",errout.str());
+        ASSERT_EQUALS("",errout_str());
         check("void f(int a) {\n assert( (a | 0x07) >= 8U );\n}");
-        ASSERT_EQUALS("",errout.str()); //correct for negative 'a'
+        ASSERT_EQUALS("",errout_str()); //correct for negative 'a'
         // '>'
         check("void f(int a) {\n assert( (a & 0x07) > 7U );\n}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X & 0x7) > 0x7' is always false.\n",errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X & 0x7) > 0x7' is always false. [comparisonError]\n",errout_str());
         check("void f(unsigned int a) {\n assert( (a | 0x7) > 6U );\n}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X | 0x7) > 0x6' is always true.\n",errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X | 0x7) > 0x6' is always true. [comparisonError]\n",errout_str());
         check("void f(int a) {\n assert( (a & 0x07) > 6U );\n}");
-        ASSERT_EQUALS("",errout.str());
+        ASSERT_EQUALS("",errout_str());
         check("void f(int a) {\n assert( (a | 0x07) > 7U );\n}");
-        ASSERT_EQUALS("",errout.str()); //correct for negative 'a'
+        ASSERT_EQUALS("",errout_str()); //correct for negative 'a'
         // '<='
         check("void f(int a) {\n assert( (a & 0x07) <= 7U );\n}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X & 0x7) <= 0x7' is always true.\n",errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X & 0x7) <= 0x7' is always true. [comparisonError]\n",errout_str());
         check("void f(unsigned int a) {\n assert( (a | 0x08) <= 7U );\n}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X | 0x8) <= 0x7' is always false.\n",errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X | 0x8) <= 0x7' is always false. [comparisonError]\n",errout_str());
         check("void f(int a) {\n assert( (a & 0x07) <= 6U );\n}");
-        ASSERT_EQUALS("",errout.str());
+        ASSERT_EQUALS("",errout_str());
         check("void f(int a) {\n assert( (a | 0x08) <= 7U );\n}");
-        ASSERT_EQUALS("",errout.str()); //correct for negative 'a'
+        ASSERT_EQUALS("",errout_str()); //correct for negative 'a'
         // '<'
         check("void f(int a) {\n assert( (a & 0x07) < 8U );\n}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X & 0x7) < 0x8' is always true.\n",errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X & 0x7) < 0x8' is always true. [comparisonError]\n",errout_str());
         check("void f(unsigned int a) {\n assert( (a | 0x07) < 7U );\n}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Expression '(X | 0x7) < 0x7' is always false.\n",errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (style) Expression '(X | 0x7) < 0x7' is always false. [comparisonError]\n",errout_str());
         check("void f(int a) {\n assert( (a & 0x07) < 3U );\n}");
-        ASSERT_EQUALS("",errout.str());
+        ASSERT_EQUALS("",errout_str());
         check("void f(int a) {\n assert( (a | 0x07) < 7U );\n}");
-        ASSERT_EQUALS("",errout.str()); //correct for negative 'a'
+        ASSERT_EQUALS("",errout_str()); //correct for negative 'a'
+
+        check("void f(int i) {\n" // #11998
+              "    if ((i & 0x100) == 0x200) {}\n"
+              "    if (0x200 == (i & 0x100)) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:21] -> [test.cpp:3:15]: (style) The if condition is the same as the previous if condition [duplicateCondition]\n"
+                      "[test.cpp:2:12]: (style) Expression '(X & 0x100) == 0x200' is always false. [comparisonError]\n"
+                      "[test.cpp:3:21]: (style) Expression '(X & 0x100) == 0x200' is always false. [comparisonError]\n",
+                      errout_str());
+
+        checkP("#define MACRO1 (0x0010)\n" // #13222
+               "#define MACRO2 (0x0020)\n"
+               "#define MACRO_ALL (MACRO1 | MACRO2)\n"
+               "void f() {\n"
+               "    if (MACRO_ALL == 0) {}\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkP("void f(int i, int j) {\n" // #13360
+               "    int X = 0x10;\n"
+               "    if ((i & 0xff00) == X) {}\n"
+               "    if (X == (j & 0xff00)) {}\n"
+               "}\n");
+        ASSERT_EQUALS("[test.cpp:3:12]: (style) Expression '(X & 0xff00) == 0x10' is always false. [comparisonError]\n"
+                      "[test.cpp:4:17]: (style) Expression '(X & 0xff00) == 0x10' is always false. [comparisonError]\n",
+                      errout_str());
+    }
+
+#define checkPureFunction(...) checkPureFunction_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkPureFunction_(const char* file, int line, const char (&code)[size]) {
+        // Tokenize..
+        SimpleTokenizer tokenizer(settings1, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+
+        runChecks<CheckCondition>(tokenizer, this);
     }
 
     void multicompare() {
@@ -476,14 +534,14 @@ class TestCondition : public TestFixture {
               "    if (x & 7);\n"
               "    else { if (x == 1); }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Expression is always false because 'else if' condition matches previous condition at line 3.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:18]: (style) Expression is always false because 'else if' condition matches previous condition at line 3. [multiCondition]\n", errout_str());
 
         check("void foo(int x)\n"
               "{\n"
               "    if (x & 7);\n"
               "    else { if (x & 1); }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Expression is always false because 'else if' condition matches previous condition at line 3.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:18]: (style) Expression is always false because 'else if' condition matches previous condition at line 3. [multiCondition]\n", errout_str());
 
         check("extern int bar() __attribute__((pure));\n"
               "void foo(int x)\n"
@@ -491,7 +549,7 @@ class TestCondition : public TestFixture {
               "    if ( bar() >1 && b) {}\n"
               "    else if (bar() >1 && b) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (style) Expression is always false because 'else if' condition matches previous condition at line 4.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:23]: (style) Expression is always false because 'else if' condition matches previous condition at line 4. [multiCondition]\n", errout_str());
 
         checkPureFunction("extern int bar();\n"
                           "void foo(int x)\n"
@@ -499,27 +557,33 @@ class TestCondition : public TestFixture {
                           "    if ( bar() >1 && b) {}\n"
                           "    else if (bar() >1 && b) {}\n"
                           "}");
-        ASSERT_EQUALS("[test.cpp:5]: (style) Expression is always false because 'else if' condition matches previous condition at line 4.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:23]: (style) Expression is always false because 'else if' condition matches previous condition at line 4. [multiCondition]\n", errout_str());
 
         // 7284
         check("void foo() {\n"
               "    if (a) {}\n"
               "    else if (!!a) {}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());
-    }
-
-    void checkPureFunction(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
-
-        // Tokenize..
-        Tokenizer tokenizer(&settings1, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:14]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
-        CheckCondition checkCondition;
-        checkCondition.runChecks(&tokenizer, &settings1, this);
+        // #11059
+        check("int f();\n"
+              "void g() {\n"
+              "    int i = f();\n"
+              "    if (i == 3) {}\n"
+              "    else if ((i = f()) == 5) {}\n"
+              "    else if (i == 3) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f();\n"
+              "void g() {\n"
+              "    int i = f();\n"
+              "    if (i == 3) {}\n"
+              "    else if ((i = f()) == 5) {}\n"
+              "    else if (i != 3) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void overlappingElseIfCondition() {
@@ -527,53 +591,53 @@ class TestCondition : public TestFixture {
               "    if (a) { b = 1; }\n"
               "    else { if (a) { b = 2; } }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Condition 'a' is always false\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:16]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         check("void f(int a, int &b) {\n"
               "    if (a) { b = 1; }\n"
               "    else { if (a) { b = 2; } }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Condition 'a' is always false\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:16]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         check("void f(int a, int &b) {\n"
               "    if (a == 1) { b = 1; }\n"
               "    else { if (a == 2) { b = 2; }\n"
               "    else { if (a == 1) { b = 3; } } }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (style) Condition 'a==1' is always false\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:18]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         check("void f(int a, int &b) {\n"
               "    if (a == 1) { b = 1; }\n"
               "    else { if (a == 2) { b = 2; }\n"
               "    else { if (a == 2) { b = 3; } } }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (style) Condition 'a==2' is always false\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:18]: (style) Expression is always false because 'else if' condition matches previous condition at line 3. [multiCondition]\n", errout_str());
 
         check("void f(int a, int &b) {\n"
               "    if (a++) { b = 1; }\n"
               "    else { if (a++) { b = 2; }\n"
               "    else { if (a++) { b = 3; } } }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int a, int &b) {\n"
               "    if (!strtok(NULL, \" \")) { b = 1; }\n"
               "    else { if (!strtok(NULL, \" \")) { b = 2; } }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         {
             check("void f(Class &c) {\n"
                   "    if (c.dostuff() == 3) {}\n"
                   "    else { if (c.dostuff() == 3) {} }\n"
                   "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
 
             check("void f(const Class &c) {\n"
                   "    if (c.dostuff() == 3) {}\n"
                   "    else { if (c.dostuff() == 3) {} }\n"
                   "}");
-            ASSERT_EQUALS("[test.cpp:3]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());
+            ASSERT_EQUALS("[test.cpp:3:28]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
         }
 
         check("void f(int a, int &b) {\n"
@@ -581,13 +645,13 @@ class TestCondition : public TestFixture {
               "   if (x < 100) { b = 1; }\n"
               "   else { x = x / 2; if (x < 100) { b = 2; } }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f(int i) {\n"
+        check("void f(int64_t i) {\n"
               "   if(i == 0x02e2000000 || i == 0xa0c6000000)\n"
               "       foo(i);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ticket 3689 ( avoid false positive )
         check("int fitInt(long long int nValue){\n"
@@ -609,79 +673,90 @@ class TestCondition : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(WIDGET *widget) {\n"
               "  if (dynamic_cast<BUTTON*>(widget)){}\n"
               "  else if (dynamic_cast<LABEL*>(widget)){}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("class B { virtual void v() {} };\n" // #11037
+              "class D1 : public B {};\n"
+              "class D2 : public B {};\n"
+              "void f(const std::shared_ptr<B>&p) {\n"
+              "    const auto d1 = dynamic_cast<D1*>(p.get());\n"
+              "    const auto d2 = dynamic_cast<D2*>(p.get());\n"
+              "    if (d1) {}\n"
+              "    else if (d2) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n" // #6482
               "  if (x & 1) {}\n"
               "  else if (x == 0) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "  if (x & 15) {}\n"
               "  else if (x == 40) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:14]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         check("void f(int x) {\n"
               "  if (x == sizeof(double)) {}\n"
               "  else { if (x == sizeof(long double)) {} }"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "  if (x & 0x08) {}\n"
               "  else if (x & 0xF8) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "  if (x & 0xF8) {}\n"
               "  else if (x & 0x08) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:14]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         check("void f(bool a, bool b) {\n"
               "   if(a && b){}\n"
               "   else if( !!b && !!a){}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:17]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         check("void f(bool a, bool b) {\n"
               "   if(a && b){}\n"
               "   else if( !!b && a){}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:17]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         check("void f(bool a, bool b) {\n"
               "   if(a && b){}\n"
               "   else if( b && !!a){}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:15]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         check("void f(bool a, bool b) {\n"
               "   if(a && b){}\n"
               "   else if( b && !(!a)){}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:15]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         check("void f(bool a, bool b) {\n"
               "   if(a && b){}\n"
               "   else if( !!b && !(!a)){}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Expression is always false because 'else if' condition matches previous condition at line 2.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:17]: (style) Expression is always false because 'else if' condition matches previous condition at line 2. [multiCondition]\n", errout_str());
 
         check("void f(bool a, bool b) {\n"
               "   if(a && b){}\n"
               "   else if( !!(b) && !!(a+b)){}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // #8168
         check("enum MaskValues\n"
@@ -692,8 +767,20 @@ class TestCondition : public TestFixture {
               "void TestFunction(int value) {\n"
               "    if ( value & (int)Value1 ) {}\n"
               "    else if ( value & (int)Value2 ) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(size_t x) {\n"
+              "    if (x == sizeof(int)) {}\n"
+              "    else { if (x == sizeof(long)) {} }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(size_t x) {\n"
+              "    if (x == sizeof(long)) {}\n"
+              "    else { if (x == sizeof(long long)) {} }\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void oppositeElseIfCondition() {
@@ -703,19 +790,19 @@ class TestCondition : public TestFixture {
               "    if (x) {}\n"
               "    else if (!x) {}\n"
               "}");
-        ASSERT_EQUALS("test.cpp:3:style:Condition '!x' is always true\n"
-                      "test.cpp:2:note:condition 'x'\n"
-                      "test.cpp:3:note:Condition '!x' is always true\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:14]: style: Expression is always true because 'else if' condition is opposite to previous condition at line 2. [multiCondition]\n"
+                      "[test.cpp:2:9]: note: first condition\n"
+                      "[test.cpp:3:14]: note: else if condition is opposite to first condition\n", errout_str());
 
         check("void f(int x) {\n"
               "    int y = x;\n"
               "    if (x) {}\n"
               "    else if (!y) {}\n"
               "}");
-        ASSERT_EQUALS("test.cpp:4:style:Expression is always true because 'else if' condition is opposite to previous condition at line 3.\n"
-                      "test.cpp:2:note:'y' is assigned value 'x' here.\n"
-                      "test.cpp:3:note:first condition\n"
-                      "test.cpp:4:note:else if condition is opposite to first condition\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:14]: style: Expression is always true because 'else if' condition is opposite to previous condition at line 3. [multiCondition]\n"
+                      "[test.cpp:2:13]: note: 'y' is assigned value 'x' here.\n"
+                      "[test.cpp:3:9]: note: first condition\n"
+                      "[test.cpp:4:14]: note: else if condition is opposite to first condition\n", errout_str());
     }
 
     void checkBadBitmaskCheck() {
@@ -723,31 +810,31 @@ class TestCondition : public TestFixture {
               "    bool b = x | 0x02;\n"
               "    return b;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:16]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\n", errout_str());
 
         check("bool f(int x) {\n"
               "    bool b = 0x02 | x;\n"
               "    return b;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:19]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\n", errout_str());
 
         check("int f(int x) {\n"
               "    int b = x | 0x02;\n"
               "    return b;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(int x) {\n"
               "    bool b = x & 0x02;\n"
               "    return b;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(int x) {\n"
               "    if(x | 0x02)\n"
               "        return b;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\n", errout_str());
 
         check("bool f(int x) {\n"
               "    int y = 0x1;\n"
@@ -755,27 +842,27 @@ class TestCondition : public TestFixture {
               "    if(x | y)\n"
               "        return b;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(int x) {\n"
               "    foo(a && (x | 0x02));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\n", errout_str());
 
         check("int f(int x) {\n"
               "    return (x | 0x02) ? 0 : 5;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\n", errout_str());
 
         check("int f(int x) {\n"
               "    return x ? (x | 0x02) : 5;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(int x) {\n"
               "    return x | 0x02;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\n", errout_str());
 
         check("bool f(int x) {\n"
               "  if (x) {\n"
@@ -783,19 +870,19 @@ class TestCondition : public TestFixture {
               "  }\n"
               "  return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:14]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\n", errout_str());
 
         check("const bool f(int x) {\n"
               "    return x | 0x02;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\n", errout_str());
 
         check("struct F {\n"
               "  static const bool f(int x) {\n"
               "      return x | 0x02;\n"
               "  }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:16]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\n", errout_str());
 
         check("struct F {\n"
               "  typedef bool b_t;\n"
@@ -803,12 +890,12 @@ class TestCondition : public TestFixture {
               "F::b_t f(int x) {\n"
               "  return x | 0x02;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:12]: (warning) Result of operator '|' is always true if one operand is non-zero. Did you intend to use '&'? [badBitmaskCheck]\n", errout_str());
 
         check("int f(int x) {\n"
               "    return x | 0x02;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void create_rop_masks_4( rop_mask_bits *bits) {\n"
               "DWORD mask_offset;\n"
@@ -816,7 +903,7 @@ class TestCondition : public TestFixture {
               "rop_mask *rop_mask;\n"
               "and_bits[mask_offset] |= (rop_mask->and & 0x0f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(unsigned a, unsigned b) {\n"
               "  unsigned cmd1 = b & 0x0F;\n"
@@ -824,7 +911,45 @@ class TestCondition : public TestFixture {
               "    if (b == 0x0C) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int i) {\n" // #11082
+              "    int j = 0;\n"
+              "    if (i | j) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Operator '|' with one operand equal to zero is redundant. [badBitmaskCheck]\n", errout_str());
+
+        check("#define EIGHTTOIS(x) (((x) << 8) | (x))\n"
+              "int f() {\n"
+              "    return EIGHTTOIS(0);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("#define O_RDONLY 0\n"
+              "void f(const char* s, int* pFd) {\n"
+              "    *pFd = open(s, O_RDONLY | O_BINARY, 0);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("const int FEATURE_BITS = x |\n"
+              "#if FOO_ENABLED\n"
+              "    FEATURE_FOO |\n"
+              "#endif\n"
+              "#if BAR_ENABLED\n"
+              "    FEATURE_BAR |\n"
+              "#endif\n"
+              "    0;");
+        ASSERT_EQUALS("", errout_str());
+
+        check("enum precedence { PC0, UNARY };\n"
+              "int x = PC0   | UNARY;\n"
+              "int y = UNARY | PC0;\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("#define MASK 0\n"
+              "#define SHIFT 1\n"
+              "int x = 1 | (MASK << SHIFT);\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -832,95 +957,85 @@ class TestCondition : public TestFixture {
         check("void f(int x) {\n"
               "    if ((x != 1) || (x != 3))\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical disjunction always evaluates to true: x != 1 || x != 3.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:18]: (warning) Logical disjunction always evaluates to true: x != 1 || x != 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (1 != x || 3 != x)\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical disjunction always evaluates to true: x != 1 || x != 3.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:16]: (warning) Logical disjunction always evaluates to true: x != 1 || x != 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "  if (x<0 && !x) {}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 0 && !x.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:11]: (warning) Logical conjunction always evaluates to false: x < 0 && !x. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "  if (x==0 && x) {}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x == 0 && x.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:12]: (warning) Logical conjunction always evaluates to false: x == 0 && x. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n" // ast..
               "    if (y == 1 && x == 1 && x == 7) { }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x == 1 && x == 7.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:26]: (warning) Logical conjunction always evaluates to false: x == 1 && x == 7. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x, int y) {\n"
               "    if (x != 1 || y != 1)\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, int y) {\n"
               "    if ((y == 1) && (x != 1) || (x != 3))\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, int y) {\n"
               "    if ((x != 1) || (x != 3) && (y == 1))\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}"
+              );
+        ASSERT_EQUALS("[test.cpp:2:12] -> [test.cpp:2:24]: (style) Condition 'x!=3' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x != 1) && (x != 3))\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x == 1) || (x == 3))\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, int y) {\n"
               "    if ((x != 1) || (y != 3))\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, int y) {\n"
               "    if ((x != hotdog) || (y != hotdog))\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, int y) {\n"
               "    if ((x != 5) || (y != 5))\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
 
         check("void f(int x) {\n"
               "    if ((x != 5) || (x != 6))\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical disjunction always evaluates to true: x != 5 || x != 6.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:18]: (warning) Logical disjunction always evaluates to true: x != 5 || x != 6. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(unsigned int a, unsigned int b, unsigned int c) {\n"
               "    if((a != b) || (c != b) || (c != a))\n"
@@ -928,9 +1043,8 @@ class TestCondition : public TestFixture {
               "        return true;\n"
               "    }\n"
               "    return false;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:23] -> [test.cpp:2:35]: (style) Condition 'c!=a' is always false [knownConditionTrueFalse]\n", errout_str());
     }
 
     void incorrectLogicOperator2() {
@@ -938,218 +1052,224 @@ class TestCondition : public TestFixture {
               "    if ((x == 1) && (x == 1.0))\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x == 1) && (x == 0x00000001))\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:12] -> [test.cpp:2:24]: (style) Condition 'x==0x00000001' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x == 1 && x == 3)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x == 1 && x == 3.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:16]: (warning) Logical conjunction always evaluates to false: x == 1 && x == 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x == 1.0 && x == 3.0)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("", errout.str()); // float comparisons with == and != are not checked right now - such comparison is a bad idea
+        ASSERT_EQUALS("", errout_str()); // float comparisons with == and != are not checked right now - such comparison is a bad idea
 
         check("void f(float x) {\n"
               "    if (x == 1 && x == 1.0)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void bar(float f) {\n" // #5246
               "    if ((f > 0) && (f < 1)) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if (x < 1 && x > 1)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 1.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 1. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x < 1.0 && x > 1.0)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1.0 && x > 1.0.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (warning) Logical conjunction always evaluates to false: x < 1.0 && x > 1.0. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x < 1 && x > 1.0)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 1.0.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 1.0. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x >= 1.0 && x <= 1.001)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if (x < 1 && x > 3)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(float x) {\n"
               "    if (x < 1.0 && x > 3.0)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1.0 && x > 3.0.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (warning) Logical conjunction always evaluates to false: x < 1.0 && x > 3.0. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (1 > x && 3 < x)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x < 3 && x > 1)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 3 || x < 10)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical disjunction always evaluates to true: x > 3 || x < 10.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical disjunction always evaluates to true: x > 3 || x < 10. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x >= 3 || x <= 10)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical disjunction always evaluates to true: x >= 3 || x <= 10.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:16]: (warning) Logical disjunction always evaluates to true: x >= 3 || x <= 10. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x >= 3 || x < 10)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical disjunction always evaluates to true: x >= 3 || x < 10.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:16]: (warning) Logical disjunction always evaluates to true: x >= 3 || x < 10. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 3 || x <= 10)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical disjunction always evaluates to true: x > 3 || x <= 10.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical disjunction always evaluates to true: x > 3 || x <= 10. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 3 || x < 3)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if (x >= 3 || x <= 3)\n"
               "        a++;\n"
               "}"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical disjunction always evaluates to true: x >= 3 || x <= 3.\n", errout.str());
+              );
+        ASSERT_EQUALS("[test.cpp:2:16]: (warning) Logical disjunction always evaluates to true: x >= 3 || x <= 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x >= 3 || x < 3)\n"
               "        a++;\n"
               "}"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical disjunction always evaluates to true: x >= 3 || x < 3.\n", errout.str());
+              );
+        ASSERT_EQUALS("[test.cpp:2:16]: (warning) Logical disjunction always evaluates to true: x >= 3 || x < 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 3 || x <= 3)\n"
               "        a++;\n"
               "}"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical disjunction always evaluates to true: x > 3 || x <= 3.\n", errout.str());
+              );
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical disjunction always evaluates to true: x > 3 || x <= 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "   if((x==3) && (x!=4))\n"
               "        a++;\n"
               "}");
+        ASSERT_EQUALS("[test.cpp:2:14]: (style) Redundant condition: The condition 'x != 4' is redundant since 'x == 3' is sufficient. [redundantCondition]\n", errout_str());
 
-        ASSERT_EQUALS("[test.cpp:2]: (style) Redundant condition: If 'x == 3', the comparison 'x != 4' is always true.\n", errout.str());
+        check("void f(const std::string &s) {\n" // #8860
+              "    const std::size_t p = s.find(\"42\");\n"
+              "    const std::size_t * const ptr = &p;\n"
+              "    if(p != std::string::npos && p == 0 && *ptr != 1){;}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:36] -> [test.cpp:4:49]: (style) Condition '*ptr!=1' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x!=4) && (x==3))\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Redundant condition: If 'x == 3', the comparison 'x != 4' is always true.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:16]: (style) Redundant condition: The condition 'x != 4' is redundant since 'x == 3' is sufficient. [redundantCondition]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x==3) || (x!=4))\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Redundant condition: If 'x == 3', the comparison 'x != 4' is always true.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:16]: (style) Redundant condition: The condition 'x == 3' is redundant since 'x != 4' is sufficient. [redundantCondition]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x!=4) || (x==3))\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Redundant condition: If 'x == 3', the comparison 'x != 4' is always true.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:16]: (style) Redundant condition: The condition 'x == 3' is redundant since 'x != 4' is sufficient. [redundantCondition]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x==3) && (x!=3))\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x == 3 && x != 3.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:16]: (warning) Logical conjunction always evaluates to false: x == 3 && x != 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x==6) || (x!=6))\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical disjunction always evaluates to true: x == 6 || x != 6.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:16]: (warning) Logical disjunction always evaluates to true: x == 6 || x != 6. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 10 || x < 3)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 5 && x == 1)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x > 5 && x == 1.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x > 5 && x == 1. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 5 && x == 6)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Redundant condition: If 'x == 6', the comparison 'x > 5' is always true.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (style) Redundant condition: The condition 'x > 5' is redundant since 'x == 6' is sufficient. [redundantCondition]\n", errout_str());
 
         // #3419
         check("void f() {\n"
               "    if ( &q != &a && &q != &b ) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #3676
         check("void f(int m_x2, int w, int x) {\n"
               "    if (x + w - 1 > m_x2 || m_x2 < 0 )\n"
               "        m_x2 = x + w - 1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(float x) {\n" // x+1 => x
               "  if (x <= 1.0e20 && x >= -1.0e20) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(float x) {\n" // x+1 => x
               "  if (x >= 1.0e20 && x <= 1.0e21) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(float x) {\n" // x+1 => x
               "  if (x <= -1.0e20 && x >= -1.0e21) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void incorrectLogicOperator3() {
@@ -1159,10 +1279,10 @@ class TestCondition : public TestFixture {
               "    d = x >= 5 && x == 1;\n"
               "    e = x <= 1 && x == 3;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x > 5 && x == 1.\n"
-                      "[test.cpp:3]: (warning) Logical conjunction always evaluates to false: x < 1 && x == 3.\n"
-                      "[test.cpp:4]: (warning) Logical conjunction always evaluates to false: x >= 5 && x == 1.\n"
-                      "[test.cpp:5]: (warning) Logical conjunction always evaluates to false: x <= 1 && x == 3.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x > 5 && x == 1. [incorrectLogicOperator]\n"
+                      "[test.cpp:3:15]: (warning) Logical conjunction always evaluates to false: x < 1 && x == 3. [incorrectLogicOperator]\n"
+                      "[test.cpp:4:16]: (warning) Logical conjunction always evaluates to false: x >= 5 && x == 1. [incorrectLogicOperator]\n"
+                      "[test.cpp:5:16]: (warning) Logical conjunction always evaluates to false: x <= 1 && x == 3. [incorrectLogicOperator]\n", errout_str());
     }
 
     void incorrectLogicOperator4() {
@@ -1170,65 +1290,74 @@ class TestCondition : public TestFixture {
               "void f(int x) {\n"
               "  if (x && x != ZERO) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int N) {\n" // #9789
+              "    T a[20] = { 0 };\n"
+              "    for (int i = 0; i < N; ++i) {\n"
+              "        if (0 < a[i] && a[i] < 1) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void incorrectLogicOperator5() { // complex expressions
         check("void f(int x) {\n"
               "  if (x+3 > 2 || x+3 < 10) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical disjunction always evaluates to true: EXPR > 2 || EXPR < 10.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical disjunction always evaluates to true: x+3 > 2 || x+3 < 10. [incorrectLogicOperator]\n", errout_str());
     }
 
     void incorrectLogicOperator6() { // char literals
+        const Settings s = settingsBuilder(settings0).certainty(Certainty::inconclusive).build();
         check("void f(char x) {\n"
               "  if (x == '1' || x == '2') {}\n"
-              "}", "test.cpp", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", s);
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(char x) {\n"
               "  if (x == '1' && x == '2') {}\n"
-              "}", "test.cpp", true);
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x == '1' && x == '2'.\n", errout.str());
+              "}", s);
+        ASSERT_EQUALS("[test.cpp:2:16]: (warning) Logical conjunction always evaluates to false: x == '1' && x == '2'. [incorrectLogicOperator]\n", errout_str());
 
         check("int f(char c) {\n"
               "  return (c >= 'a' && c <= 'z');\n"
-              "}", "test.cpp", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", s);
+        ASSERT_EQUALS("", errout_str());
 
         check("int f(char c) {\n"
               "  return (c <= 'a' && c >= 'z');\n"
-              "}", "test.cpp", true);
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Logical conjunction always evaluates to false: c <= 'a' && c >= 'z'.\n", errout.str());
+              "}", s);
+        ASSERT_EQUALS("[test.cpp:2:20]: (warning, inconclusive) Logical conjunction always evaluates to false: c <= 'a' && c >= 'z'. [incorrectLogicOperator]\n", errout_str());
 
         check("int f(char c) {\n"
               "  return (c <= 'a' && c >= 'z');\n"
-              "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+              "}"); // TODO: use s?
+        ASSERT_EQUALS("[test.cpp:2:13] -> [test.cpp:2:25]: (style) Return value 'c>='z'' is always false [knownConditionTrueFalse]\n", errout_str());
     }
 
     void incorrectLogicOperator7() { // opposite expressions
         check("void f(int i) {\n"
               "  if (i || !i) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical disjunction always evaluates to true: i || !(i).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (warning) Logical disjunction always evaluates to true: i || !(i). [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int a, int b) {\n"
               "  if (a>b || a<=b) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical disjunction always evaluates to true: a > b || a <= b.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (warning) Logical disjunction always evaluates to true: a > b || a <= b. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int a, int b) {\n"
               "  if (a>b || a<b) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6064 False positive incorrectLogicOperator - invalid assumption about template type?
         check("template<typename T> T icdf( const T uniform ) {\n"
               "   if ((0<uniform) && (uniform<1))\n"
               "     {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6081 False positive: incorrectLogicOperator, with close negative comparisons
         check("double neg = -1.0 - 1.0e-13;\n"
@@ -1238,23 +1367,23 @@ class TestCondition : public TestFixture {
               "    else\n"
               "        return;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void incorrectLogicOperator8() { // opposite expressions
         check("void f(int i) {\n"
               "  if (!(i!=10) && !(i!=20)) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: !(i != 10) && !(i != 20).\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:16]: (warning) Logical conjunction always evaluates to false: !(i != 10) && !(i != 20). [incorrectLogicOperator]\n", errout_str());
     }
 
     void incorrectLogicOperator9() { //  #6069 "False positive incorrectLogicOperator due to dynamic_cast"
         check("class MyType;\n"
               "class OtherType;\n"
-              "void foo (OtherType* obj) { \n"
+              "void foo (OtherType* obj) {\n"
               "    assert((!obj) || dynamic_cast<MyType*>(obj));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void incorrectLogicOperator10() { //  #7794 - enum
@@ -1263,24 +1392,70 @@ class TestCondition : public TestFixture {
               "    if ((t == A) && (t == B))\n"
               "    {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Logical conjunction always evaluates to false: t == 0 && t == 1.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:18]: (warning) Logical conjunction always evaluates to false: t == 0 && t == 1. [incorrectLogicOperator]\n", errout_str());
     }
 
     void incorrectLogicOperator11() {
         check("void foo(int i, const int n) { if ( i < n && i == n ) {} }");
-        ASSERT_EQUALS("[test.cpp:1]: (warning) Logical conjunction always evaluates to false: i < n && i == n.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:43]: (warning) Logical conjunction always evaluates to false: i < n && i == n. [incorrectLogicOperator]\n", errout_str());
 
         check("void foo(int i, const int n) { if ( i > n && i == n ) {} }");
-        ASSERT_EQUALS("[test.cpp:1]: (warning) Logical conjunction always evaluates to false: i > n && i == n.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:43]: (warning) Logical conjunction always evaluates to false: i > n && i == n. [incorrectLogicOperator]\n", errout_str());
 
         check("void foo(int i, const int n) { if ( i == n && i > n ) {} }");
-        ASSERT_EQUALS("[test.cpp:1]: (warning) Logical conjunction always evaluates to false: i == n && i > n.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:44]: (warning) Logical conjunction always evaluates to false: i == n && i > n. [incorrectLogicOperator]\n", errout_str());
 
         check("void foo(int i, const int n) { if ( i == n && i < n ) {} }");
-        ASSERT_EQUALS("[test.cpp:1]: (warning) Logical conjunction always evaluates to false: i == n && i < n.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:44]: (warning) Logical conjunction always evaluates to false: i == n && i < n. [incorrectLogicOperator]\n", errout_str());
     }
 
     void incorrectLogicOperator12() { // #8696
+        check("struct A {\n"
+              "    void f() const;\n"
+              "};\n"
+              "void foo(A a, A b) {\n"
+              "  A x = b;\n"
+              "  A y = b;\n"
+              "  y.f();\n"
+              "  if (a > x && a < y)\n"
+              "    return;\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:5:9] -> [test.cpp:6:9] -> [test.cpp:8:13]: (warning) Logical conjunction always evaluates to false: a > x && a < y. [incorrectLogicOperator]\n",
+            errout_str());
+
+        check("struct A {\n"
+              "    void f();\n"
+              "};\n"
+              "void foo(A a, A b) {\n"
+              "  A x = b;\n"
+              "  A y = b;\n"
+              "  y.f();\n"
+              "  if (a > x && a < y)\n"
+              "    return;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo(A a, A b) {\n"
+              "  A x = b;\n"
+              "  A y = b;\n"
+              "  y.f();\n"
+              "  if (a > x && a < y)\n"
+              "    return;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo(A a, A b) {\n"
+              "  const A x = b;\n"
+              "  const A y = b;\n"
+              "  y.f();\n"
+              "  if (a > x && a < y)\n"
+              "    return;\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:2:15] -> [test.cpp:3:15] -> [test.cpp:5:13]: (warning) Logical conjunction always evaluates to false: a > x && a < y. [incorrectLogicOperator]\n",
+            errout_str());
+
         check("struct A {\n"
               "    void f() const;\n"
               "};\n"
@@ -1290,8 +1465,10 @@ class TestCondition : public TestFixture {
               "  y.f();\n"
               "  if (a > x && a < y)\n"
               "    return;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:6] -> [test.cpp:8]: (warning) Logical conjunction always evaluates to false: a > x && a < y.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:8:9]: (style) Condition 'a>x' is always false [knownConditionTrueFalse]\n"
+                      "[test.cpp:8:18]: (style) Condition 'a<y' is always false [knownConditionTrueFalse]\n",
+                      errout_str());
 
         check("struct A {\n"
               "    void f();\n"
@@ -1302,8 +1479,8 @@ class TestCondition : public TestFixture {
               "  y.f();\n"
               "  if (a > x && a < y)\n"
               "    return;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:8:9]: (style) Condition 'a>x' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void foo(A a) {\n"
               "  A x = a;\n"
@@ -1311,8 +1488,8 @@ class TestCondition : public TestFixture {
               "  y.f();\n"
               "  if (a > x && a < y)\n"
               "    return;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:9]: (style) Condition 'a>x' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void foo(A a) {\n"
               "  const A x = a;\n"
@@ -1320,8 +1497,10 @@ class TestCondition : public TestFixture {
               "  y.f();\n"
               "  if (a > x && a < y)\n"
               "    return;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3] -> [test.cpp:5]: (warning) Logical conjunction always evaluates to false: a > x && a < y.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:9]: (style) Condition 'a>x' is always false [knownConditionTrueFalse]\n"
+                      "[test.cpp:5:18]: (style) Condition 'a<y' is always false [knownConditionTrueFalse]\n",
+                      errout_str());
     }
 
     void incorrectLogicOperator13() {
@@ -1329,14 +1508,14 @@ class TestCondition : public TestFixture {
         check("void f(const int &v) {\n"
               "    const int x=v;\n"
               "    if ((v == 1) && (x == 2)) {;}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Logical conjunction always evaluates to false: v == 1 && x == 2.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:17] -> [test.cpp:3:18]: (warning) Logical conjunction always evaluates to false: v == 1 && x == 2. [incorrectLogicOperator]\n", errout_str());
 
         check("void f2(const int *v) {\n"
               "    const int *x=v;\n"
               "    if ((*v == 1) && (*x == 2)) {;}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Logical conjunction always evaluates to false: *(v) == 1 && *(x) == 2.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:18] -> [test.cpp:3:19]: (warning) Logical conjunction always evaluates to false: *(v) == 1 && *(x) == 2. [incorrectLogicOperator]\n", errout_str());
     }
 
     void incorrectLogicOperator14() {
@@ -1542,38 +1721,88 @@ class TestCondition : public TestFixture {
               "      if (f && g)\n"
               "        ;\n"
               "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:200:11] -> [test.cpp:200:16]: (style) Condition 'g' is always true [knownConditionTrueFalse]\n", errout_str());
+    }
+
+    void incorrectLogicOperator15() {
+        // 10022
+        check("struct PipeRoute {\n"
+              "    std::deque<int> points;\n"
+              "    std::deque<int> estimates;\n"
+              "};\n"
+              "void CleanPipeRoutes(std::map<int, PipeRoute*>& pipeRoutes) {\n"
+              "    for (auto it = pipeRoutes.begin(); it != pipeRoutes.end(); ) {\n"
+              "        PipeRoute* curRoute = it->second;\n"
+              "        if (curRoute->points.empty() && curRoute->estimates.size() != 2)\n"
+              "        {\n"
+              "            delete curRoute;\n"
+              "            it = pipeRoutes.erase(it);\n"
+              "        }\n"
+              "        else\n"
+              "        {\n"
+              "            ++it;\n"
+              "        }\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void incorrectLogicOperator16() { // #10070
+        check("void foo(void* p) {\n"
+              "    if (!p || p == -1) { }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void incorrectLogicOperator17() { // #12471
+        check("struct R {\n"
+              "    void set() { i = 1; }\n"
+              "    int get() const { return i; }\n"
+              "    int i;\n"
+              "};\n"
+              "struct P {\n"
+              "    void f();\n"
+              "    R* r;\n"
+              "};\n"
+              "void P::f() {\n"
+              "    int a = r->get();\n"
+              "    r->set();\n"
+              "    if (a == 0 && r->get()) {}\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void secondAlwaysTrueFalseWhenFirstTrueError() {
+        check("void f(void) {\n" // #8892
+              "    const char c[1] = { \'x\' }; \n"
+              "    if(c[0] == \'x\'){;}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:13]: (style) Condition 'c[0]=='x'' is always true [knownConditionTrueFalse]\n", errout_str());
+
         check("void f(int x) {\n"
               "    if (x > 5 && x != 1)\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (style) Redundant condition: If 'x > 5', the comparison 'x != 1' is always true.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:15]: (style) Redundant condition: The condition 'x != 1' is redundant since 'x > 5' is sufficient. [redundantCondition]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 5 && x != 6)\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x > 5) && (x != 1))\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (style) Redundant condition: If 'x > 5', the comparison 'x != 1' is always true.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) Redundant condition: The condition 'x != 1' is redundant since 'x > 5' is sufficient. [redundantCondition]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x > 5) && (x != 6))\n"
               "        a++;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, bool& b) {\n"
               "    b = x > 3 || x == 4;\n"
@@ -1581,10 +1810,11 @@ class TestCondition : public TestFixture {
               "    d = x >= 3 || x == 4;\n"
               "    e = x <= 5 || x == 4;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Redundant condition: If 'x == 4', the comparison 'x > 3' is always true.\n"
-                      "[test.cpp:3]: (style) Redundant condition: If 'x == 4', the comparison 'x < 5' is always true.\n"
-                      "[test.cpp:4]: (style) Redundant condition: If 'x == 4', the comparison 'x >= 3' is always true.\n"
-                      "[test.cpp:5]: (style) Redundant condition: If 'x == 4', the comparison 'x <= 5' is always true.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (style) Redundant condition: The condition 'x == 4' is redundant since 'x > 3' is sufficient. [redundantCondition]\n"
+                      "[test.cpp:3:15]: (style) Redundant condition: The condition 'x == 4' is redundant since 'x < 5' is sufficient. [redundantCondition]\n"
+                      "[test.cpp:4:16]: (style) Redundant condition: The condition 'x == 4' is redundant since 'x >= 3' is sufficient. [redundantCondition]\n"
+                      "[test.cpp:5:16]: (style) Redundant condition: The condition 'x == 4' is redundant since 'x <= 5' is sufficient. [redundantCondition]\n",
+                      errout_str());
 
         check("void f(int x, bool& b) {\n"
               "    b = x > 5 || x != 1;\n"
@@ -1592,10 +1822,11 @@ class TestCondition : public TestFixture {
               "    d = x >= 5 || x != 1;\n"
               "    e = x <= 1 || x != 3;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Redundant condition: If 'x > 5', the comparison 'x != 1' is always true.\n"
-                      "[test.cpp:3]: (style) Redundant condition: If 'x < 1', the comparison 'x != 3' is always true.\n"
-                      "[test.cpp:4]: (style) Redundant condition: If 'x >= 5', the comparison 'x != 1' is always true.\n"
-                      "[test.cpp:5]: (style) Redundant condition: If 'x <= 1', the comparison 'x != 3' is always true.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (style) Redundant condition: The condition 'x > 5' is redundant since 'x != 1' is sufficient. [redundantCondition]\n"
+                      "[test.cpp:3:15]: (style) Redundant condition: The condition 'x < 1' is redundant since 'x != 3' is sufficient. [redundantCondition]\n"
+                      "[test.cpp:4:16]: (style) Redundant condition: The condition 'x >= 5' is redundant since 'x != 1' is sufficient. [redundantCondition]\n"
+                      "[test.cpp:5:16]: (style) Redundant condition: The condition 'x <= 1' is redundant since 'x != 3' is sufficient. [redundantCondition]\n",
+                      errout_str());
 
         check("void f(int x, bool& b) {\n"
               "    b = x > 6 && x > 5;\n"
@@ -1603,10 +1834,29 @@ class TestCondition : public TestFixture {
               "    d = x < 6 && x < 5;\n"
               "    e = x < 5 || x < 6;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Redundant condition: If 'x > 6', the comparison 'x > 5' is always true.\n"
-                      "[test.cpp:3]: (style) Redundant condition: If 'x > 6', the comparison 'x > 5' is always true.\n"
-                      "[test.cpp:4]: (style) Redundant condition: If 'x < 5', the comparison 'x < 6' is always true.\n"
-                      "[test.cpp:5]: (style) Redundant condition: If 'x < 5', the comparison 'x < 6' is always true.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (style) Redundant condition: The condition 'x > 5' is redundant since 'x > 6' is sufficient. [redundantCondition]\n"
+                      "[test.cpp:3:15]: (style) Redundant condition: The condition 'x > 6' is redundant since 'x > 5' is sufficient. [redundantCondition]\n"
+                      "[test.cpp:4:15]: (style) Redundant condition: The condition 'x < 6' is redundant since 'x < 5' is sufficient. [redundantCondition]\n"
+                      "[test.cpp:5:15]: (style) Redundant condition: The condition 'x < 5' is redundant since 'x < 6' is sufficient. [redundantCondition]\n",
+                      errout_str());
+
+        check("void f(double x, bool& b) {\n"
+              "    b = x > 6.5 && x > 5.5;\n"
+              "    c = x > 5.5 || x > 6.5;\n"
+              "    d = x < 6.5 && x < 5.5;\n"
+              "    e = x < 5.5 || x < 6.5;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) Redundant condition: The condition 'x > 5.5' is redundant since 'x > 6.5' is sufficient. [redundantCondition]\n"
+                      "[test.cpp:3:17]: (style) Redundant condition: The condition 'x > 6.5' is redundant since 'x > 5.5' is sufficient. [redundantCondition]\n"
+                      "[test.cpp:4:17]: (style) Redundant condition: The condition 'x < 6.5' is redundant since 'x < 5.5' is sufficient. [redundantCondition]\n"
+                      "[test.cpp:5:17]: (style) Redundant condition: The condition 'x < 5.5' is redundant since 'x < 6.5' is sufficient. [redundantCondition]\n",
+                      errout_str());
+
+        check("void f(const char *p) {\n" // #10320
+              "    if (!p || !*p || *p != 'x') {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:19]: (style) Redundant condition: The condition '!*p' is redundant since '*p != 'x'' is sufficient. [redundantCondition]\n",
+                      errout_str());
     }
 
     void incorrectLogicOp_condSwapping() {
@@ -1614,49 +1864,49 @@ class TestCondition : public TestFixture {
               "    if (x < 1 && x > 3)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (1 > x && x > 3)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x < 1 && 3 < x)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (1 > x && 3 < x)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x < 1 && x > 3. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 3 && x < 1)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x > 3 && x < 1.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x > 3 && x < 1. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (3 < x && x < 1)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x > 3 && x < 1.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x > 3 && x < 1. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (x > 3 && 1 > x)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x > 3 && x < 1.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x > 3 && x < 1. [incorrectLogicOperator]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if (3 < x && 1 > x)\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Logical conjunction always evaluates to false: x > 3 && x < 1.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Logical conjunction always evaluates to false: x > 3 && x < 1. [incorrectLogicOperator]\n", errout_str());
     }
 
     void modulo() {
@@ -1666,7 +1916,7 @@ class TestCondition : public TestFixture {
               "    b3 = a % 5 == c;\n"
               "    return a % 5 == 5-p;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(bool& b1, bool& b2, bool& b3, bool& b4, bool& b5) {\n"
               "    b1 = a % 5 < 5;\n"
@@ -1676,27 +1926,31 @@ class TestCondition : public TestFixture {
               "    b5 = a % 5 >= 5;\n"
               "    return a % 5 > 5;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
-                      "[test.cpp:3]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
-                      "[test.cpp:4]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
-                      "[test.cpp:5]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
-                      "[test.cpp:6]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
-                      "[test.cpp:7]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:16]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. [moduloAlwaysTrueFalse]\n"
+            "[test.cpp:3:16]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. [moduloAlwaysTrueFalse]\n"
+            "[test.cpp:4:16]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. [moduloAlwaysTrueFalse]\n"
+            "[test.cpp:5:16]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. [moduloAlwaysTrueFalse]\n"
+            "[test.cpp:6:16]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. [moduloAlwaysTrueFalse]\n"
+            "[test.cpp:7:18]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. [moduloAlwaysTrueFalse]\n",
+            errout_str());
 
         check("void f(bool& b1, bool& b2) {\n"
               "    b1 = bar() % 5 < 889;\n"
               "    if(x[593] % 5 <= 5)\n"
               "        b2 = x.a % 5 == 5;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
-                      "[test.cpp:3]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
-                      "[test.cpp:4]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:20]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. [moduloAlwaysTrueFalse]\n"
+            "[test.cpp:3:19]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. [moduloAlwaysTrueFalse]\n"
+            "[test.cpp:4:22]: (warning) Comparison of modulo result is predetermined, because it is always less than 5. [moduloAlwaysTrueFalse]\n",
+            errout_str());
 
         check("void f() {\n"
               "    if (a % 2 + b % 2 == 2)\n"
               "        foo();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void oppositeInnerCondition() {
@@ -1705,21 +1959,21 @@ class TestCondition : public TestFixture {
               "        if(a!=b)\n"
               "            cout << a;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:13]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("bool foo(int a, int b) {\n"
               "    if(a==b)\n"
               "        return a!=b;\n"
               "    return false;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Opposite inner 'return' condition leads to a dead code block.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:17]: (warning) Opposite inner 'return' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("void foo(int a, int b) {\n"
               "    if(a==b)\n"
               "        if(b!=a)\n"
               "            cout << a;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:13]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("void foo(int a) {\n"
               "    if(a >= 50) {\n"
@@ -1729,7 +1983,7 @@ class TestCondition : public TestFixture {
               "            cout << 100;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10] -> [test.cpp:3:14]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         // #4186
         check("void foo(int a) {\n"
@@ -1740,7 +1994,7 @@ class TestCondition : public TestFixture {
               "            cout << 100;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // 4170
         check("class foo {\n"
@@ -1759,7 +2013,7 @@ class TestCondition : public TestFixture {
               "    void next();\n"
               "    const char *tok;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int i)\n"
               "{\n"
@@ -1770,7 +2024,7 @@ class TestCondition : public TestFixture {
               "       }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int& i) {\n"
               "    i=6;\n"
@@ -1782,7 +2036,7 @@ class TestCondition : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int& i);\n"
               "void bar() {\n"
@@ -1793,7 +2047,7 @@ class TestCondition : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int i);\n"
               "void bar(int i) {\n"
@@ -1803,7 +2057,7 @@ class TestCondition : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:5:13]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("void foo(const int &i);\n"
               "void bar(int i) {\n"
@@ -1813,7 +2067,7 @@ class TestCondition : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:5:13]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("void foo(int i);\n"
               "void bar() {\n"
@@ -1824,7 +2078,7 @@ class TestCondition : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:6]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:6:13]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("class C { void f(int &i) const; };\n" // #7028 - variable is changed by const method
               "void foo(C c, int i) {\n"
@@ -1833,7 +2087,7 @@ class TestCondition : public TestFixture {
               "    if (i != 5) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // see linux revision 1f80c0cc
         check("int generic_write_sync(int,int,int);\n"
@@ -1847,7 +2101,7 @@ class TestCondition : public TestFixture {
               "       }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:7]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:11] -> [test.cpp:7:14]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
 
         // #5874 - array
@@ -1858,7 +2112,7 @@ class TestCondition : public TestFixture {
               "    if (array[0] > 2) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6227 - FP caused by simplifications of casts and known variables
         check("void foo(A *a) {\n"
@@ -1867,7 +2121,7 @@ class TestCondition : public TestFixture {
               "       if(!b) {}\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a) {\n"
               "   if(a) {\n"
@@ -1875,7 +2129,7 @@ class TestCondition : public TestFixture {
               "       if(!b) {}\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2] -> [test.cpp:4]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:16] -> [test.cpp:2:7] -> [test.cpp:4:11]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("void foo(unsigned u) {\n"
               "  if (u != 0) {\n"
@@ -1885,7 +2139,7 @@ class TestCondition : public TestFixture {
               "    }\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #8186
         check("void f() {\n"
@@ -1893,7 +2147,38 @@ class TestCondition : public TestFixture {
               "    if (i==5) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17] -> [test.cpp:3:10]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
+
+        // #8938
+        check("void Delete(SS_CELLCOORD upperleft) {\n"
+              "    if ((upperleft.Col == -1) && (upperleft.Row == -1)) {\n"
+              "        GetActiveCell(&(upperleft.Col), &(upperleft.Row));\n"
+              "        if (upperleft.Row == -1) {}\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9702
+        check("struct A {\n"
+              "    void DoTest() {\n"
+              "        if (!IsSet()) {\n"
+              "            m_value = true;\n"
+              "            if (IsSet());\n"
+              "        }\n"
+              "    }\n"
+              "    bool IsSet() const { return m_value; }\n"
+              "    bool m_value = false;\n"
+              "};");
+        ASSERT_EQUALS("", errout_str());
+
+        // #12725
+        check("bool f(bool b) {\n"
+              "    if (b)\n"
+              "        return !b;\n"
+              "    b = g();\n"
+              "    return b;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:16]: (style) Return value '!b' is always false [knownConditionTrueFalse]\n", errout_str());
     }
 
     void oppositeInnerConditionPointers() {
@@ -1906,7 +2191,7 @@ class TestCondition : public TestFixture {
               "       }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void Fred::f() {\n" // daca: ace
               "  if (this->next_ == map_man_->table_) {\n"
@@ -1914,7 +2199,7 @@ class TestCondition : public TestFixture {
               "    if (this->next_ != map_man_->table_) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void test(float *f) {\n" // #7405
               "  if(*f>10) {\n"
@@ -1922,13 +2207,13 @@ class TestCondition : public TestFixture {
               "    if(*f<10) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int * f(int * x, int * y) {\n"
               "    if(!x) return x;\n"
               "    return y;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void oppositeInnerConditionClass() {
@@ -1940,7 +2225,7 @@ class TestCondition : public TestFixture {
               "    if (!fred.isValid()) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:19] -> [test.cpp:5:9]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("class Fred { public: bool isValid() const; void dostuff() const; };\n"
               "void f() {\n"
@@ -1950,7 +2235,7 @@ class TestCondition : public TestFixture {
               "    if (!fred.isValid()) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:6]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:19] -> [test.cpp:6:9]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("void f() {\n"
               "  Fred fred;\n"
@@ -1959,7 +2244,7 @@ class TestCondition : public TestFixture {
               "    if (!fred.isValid()) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6385 "crash in Variable::getFlag()"
         check("class TranslationHandler {\n"
@@ -1970,14 +2255,14 @@ class TestCondition : public TestFixture {
               "        }\n"
               "   }\n"
               "};");
-        ASSERT_EQUALS("", errout.str()); // just don't crash...
+        ASSERT_EQUALS("", errout_str()); // just don't crash...
 
         check("bool f(std::ofstream &CFileStream) {\n" // #8198
               "  if(!CFileStream.good()) { return; }\n"
               "  CFileStream << \"abc\";\n"
               "  if (!CFileStream.good()) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void oppositeInnerConditionUndeclaredVariable() {
@@ -1988,7 +2273,7 @@ class TestCondition : public TestFixture {
               "       if (x != -1) {}\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #5750 - another fp when undeclared variable is used
         check("void f() {\n"
@@ -1997,7 +2282,7 @@ class TestCondition : public TestFixture {
               "       if (r > w) {}\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6574 - another fp when undeclared variable is used
         check("void foo() {\n"
@@ -2006,7 +2291,7 @@ class TestCondition : public TestFixture {
               "       if(!i) {}\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // undeclared array
         check("void f(int x) {\n"
@@ -2015,7 +2300,7 @@ class TestCondition : public TestFixture {
               "    if (a[x] < 0) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6313 - false positive: opposite conditions in nested if blocks when condition changed
         check("void Foo::Bar() {\n"
@@ -2024,8 +2309,8 @@ class TestCondition : public TestFixture {
               "      if(!var){}\n"
               "      else {}\n"
               "   }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // daca hyphy
         check("bool f() {\n"
@@ -2034,7 +2319,7 @@ class TestCondition : public TestFixture {
               "    if (rec.lLength!=0) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void oppositeInnerConditionAlias() {
@@ -2048,7 +2333,7 @@ class TestCondition : public TestFixture {
               "    if (hasFailed) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:7]: (style) Condition '!hasFailed' is always true [knownConditionTrueFalse]\n", errout_str());
     }
 
     void oppositeInnerCondition2() {
@@ -2059,45 +2344,45 @@ class TestCondition : public TestFixture {
               "    if (x==5) {}\n" // <- Warning
               "  }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (warning) Opposite inner 'if' condition leads to a dead code block.\n",
-                      errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n",
+                      errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x<4) {\n"
               "    if (x!=5) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (style) Condition 'x!=5' is always true\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (style) Condition 'x!=5' is always true [knownConditionTrueFalse]\n", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x<4) {\n"
               "    if (x>5) {}\n" // <- Warning
               "  }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (warning) Opposite inner 'if' condition leads to a dead code block.\n",
-                      errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n",
+                      errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x<4) {\n"
               "    if (x>=5) {}\n" // <- Warning
               "  }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (warning) Opposite inner 'if' condition leads to a dead code block.\n",
-                      errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n",
+                      errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x<4) {\n"
               "    if (x<5) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (style) Condition 'x<5' is always true [knownConditionTrueFalse]\n", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x<4) {\n"
               "    if (x<=5) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (style) Condition 'x<=5' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int x) {\n"
               "\n"
@@ -2105,42 +2390,49 @@ class TestCondition : public TestFixture {
               "    if (x==4) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x<5) {\n"
               "    if (x!=4) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+        check("void f(int x) {\n"
+              "\n"
+              "  if (x<5) {\n"
+              "    if (x!=6) {}\n"
+              "  }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (style) Condition 'x!=6' is always true [knownConditionTrueFalse]\n", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x<5) {\n"
-              "    if (x>4) {}\n" // <- TODO
+              "    if (x>4) {}\n" // <- Warning
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (style) Condition 'x>4' is always false [knownConditionTrueFalse]\n", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x<5) {\n"
               "    if (x>=4) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x<5) {\n"
               "    if (x<4) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x<5) {\n"
               "    if (x<=4) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (style) Condition 'x<=4' is always true [knownConditionTrueFalse]\n", errout_str());
 
         // first comparison: >
         check("void f(int x) {\n"
@@ -2149,35 +2441,35 @@ class TestCondition : public TestFixture {
               "    if (x==5) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x>4) {\n"
               "    if (x>5) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x>4) {\n"
-              "    if (x>=5) {}\n" // <- TODO
+              "    if (x>=5) {}\n" // <- Warning
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (style) Condition 'x>=5' is always true [knownConditionTrueFalse]\n", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x>4) {\n"
-              "    if (x<5) {}\n" // <- TODO
+              "    if (x<5) {}\n" // <- Warning
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (style) Condition 'x<5' is always false [knownConditionTrueFalse]\n", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x>4) {\n"
               "    if (x<=5) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "\n"
@@ -2185,100 +2477,100 @@ class TestCondition : public TestFixture {
               "    if (x==4) {}\n" // <- Warning
               "  }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (warning) Opposite inner 'if' condition leads to a dead code block.\n",
-                      errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n",
+                      errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x>5) {\n"
-              "    if (x>4) {}\n" // <- TODO
+              "    if (x>4) {}\n" // <- Warning
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (style) Condition 'x>4' is always true [knownConditionTrueFalse]\n", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x>5) {\n"
-              "    if (x>=4) {}\n" // <- TODO
+              "    if (x>=4) {}\n" // <- Warning
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (style) Condition 'x>=4' is always true [knownConditionTrueFalse]\n", errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x>5) {\n"
               "    if (x<4) {}\n" // <- Warning
               "  }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (warning) Opposite inner 'if' condition leads to a dead code block.\n",
-                      errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n",
+                      errout_str());
         check("void f(int x) {\n"
               "\n"
               "  if (x>5) {\n"
               "    if (x<=4) {}\n" // <- Warning
               "  }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (warning) Opposite inner 'if' condition leads to a dead code block.\n",
-                      errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:4:10]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n",
+                      errout_str());
 
         check("void f(int x) {\n"
               "  if (x < 4) {\n"
               "    if (10 < x) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:12]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
     }
 
     void oppositeInnerCondition3() {
-        check("void f3(char c) { if(c=='x') if(c=='y') {}} ");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        check("void f3(char c) { if(c=='x') if(c=='y') {}}");
+        ASSERT_EQUALS("[test.cpp:1:23] -> [test.cpp:1:34]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f4(char *p) { if(*p=='x') if(*p=='y') {}} ");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        check("void f4(char *p) { if(*p=='x') if(*p=='y') {}}");
+        ASSERT_EQUALS("[test.cpp:1:25] -> [test.cpp:1:37]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f5(const char * const p) { if(*p=='x') if(*p=='y') {}} ");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        check("void f5(const char * const p) { if(*p=='x') if(*p=='y') {}}");
+        ASSERT_EQUALS("[test.cpp:1:38] -> [test.cpp:1:50]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f5(const char * const p) { if('x'==*p) if('y'==*p) {}} ");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        check("void f5(const char * const p) { if('x'==*p) if('y'==*p) {}}");
+        ASSERT_EQUALS("[test.cpp:1:39] -> [test.cpp:1:51]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f6(char * const p) { if(*p=='x') if(*p=='y') {}} ");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        check("void f6(char * const p) { if(*p=='x') if(*p=='y') {}}");
+        ASSERT_EQUALS("[test.cpp:1:32] -> [test.cpp:1:44]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f7(const char * p) { if(*p=='x') if(*p=='y') {}} ");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        check("void f7(const char * p) { if(*p=='x') if(*p=='y') {}}");
+        ASSERT_EQUALS("[test.cpp:1:32] -> [test.cpp:1:44]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f8(int i) { if(i==4) if(i==2) {}} ");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        check("void f8(int i) { if(i==4) if(i==2) {}}");
+        ASSERT_EQUALS("[test.cpp:1:22] -> [test.cpp:1:31]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f9(int *p) { if (*p==4) if(*p==2) {}} ");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        check("void f9(int *p) { if (*p==4) if(*p==2) {}}");
+        ASSERT_EQUALS("[test.cpp:1:25] -> [test.cpp:1:35]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f10(int * const p) { if (*p==4) if(*p==2) {}} ");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        check("void f10(int * const p) { if (*p==4) if(*p==2) {}}");
+        ASSERT_EQUALS("[test.cpp:1:33] -> [test.cpp:1:43]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f11(const int *p) { if (*p==4) if(*p==2) {}} ");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        check("void f11(const int *p) { if (*p==4) if(*p==2) {}}");
+        ASSERT_EQUALS("[test.cpp:1:32] -> [test.cpp:1:42]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("void f12(const int * const p) { if (*p==4) if(*p==2) {}}");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:39] -> [test.cpp:1:49]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
         check("struct foo {\n"
               "    int a;\n"
               "    int b;\n"
               "};\n"
-              "void f(foo x) { if(x.a==4) if(x.b==2) {}} ");
-        ASSERT_EQUALS("", errout.str());
+              "void f(foo x) { if(x.a==4) if(x.b==2) {}}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct foo {\n"
               "    int a;\n"
               "    int b;\n"
               "};\n"
-              "void f(foo x) { if(x.a==4) if(x.b==4) {}} ");
-        ASSERT_EQUALS("", errout.str());
+              "void f(foo x) { if(x.a==4) if(x.b==4) {}}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f3(char a, char b) { if(a==b) if(a==0) {}} ");
-        ASSERT_EQUALS("", errout.str());
+        check("void f3(char a, char b) { if(a==b) if(a==0) {}}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) { if (x == 1) if (x != 1) {} }");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:23] -> [test.cpp:1:35]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
     }
 
     void oppositeInnerConditionAnd() {
@@ -2287,62 +2579,108 @@ class TestCondition : public TestFixture {
               "    if (x < 10) {}\n"
               "  }"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:16] -> [test.cpp:3:11]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
+
+        check("void f(bool x, const int a, const int b) {\n"
+              "        if(x && a < b)\n"
+              "            if( x && a > b){}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:14] -> [test.cpp:3:19]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
+    }
+
+    void oppositeInnerConditionOr()
+    {
+        check("void f(int x) {\n"
+              "    if (x == 1 || x == 2) {\n"
+              "        if (x == 3) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:16] -> [test.cpp:3:15]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n",
+                      errout_str());
+
+        check("void f(int x) {\n"
+              "    if (x == 1 || x == 2) {\n"
+              "        if (x == 1) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int x) {\n"
+              "    if (x == 1 || x == 2) {\n"
+              "        if (x == 2) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::string x) {\n"
+              "    if (x == \"1\" || x == \"2\") {\n"
+              "        if (x == \"1\") {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int x) {\n"
+              "    if (x < 1 || x > 3) {\n"
+              "        if (x == 3) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:15] -> [test.cpp:3:15]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n",
+                      errout_str());
     }
 
     void oppositeInnerConditionEmpty() {
-        check("void f1(const std::string &s) { if(s.size() > 42) if(s.empty()) {}} ");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        check("void f1(const std::string &s) { if(s.size() > 42) if(s.empty()) {}}");
+        ASSERT_EQUALS("[test.cpp:1:45] -> [test.cpp:1:61]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f1(const std::string &s) { if(s.size() > 0) if(s.empty()) {}} ");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        check("void f1(const std::string &s) { if(s.size() > 0) if(s.empty()) {}}");
+        ASSERT_EQUALS("[test.cpp:1:45] -> [test.cpp:1:60]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f1(const std::string &s) { if(s.size() < 0) if(s.empty()) {}} ");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        check("void f1(const std::string &s) { if(s.size() < 0) if(s.empty()) {}} "); // <- CheckOther reports: checking if unsigned expression is less than zero
+        ASSERT_EQUALS("[test.cpp:1:45] -> [test.cpp:1:60]: (style) Condition 's.empty()' is always false [knownConditionTrueFalse]\n", errout_str());
 
-        check("void f1(const std::string &s) { if(s.empty()) if(s.size() > 42) {}} ");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        check("void f1(const std::string &s) { if(s.empty()) if(s.size() > 42) {}}");
+        ASSERT_EQUALS("[test.cpp:1:43] -> [test.cpp:1:59]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("template<class T> void f1(const T &s) { if(s.size() > 42) if(s.empty()) {}} ");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        check("template<class T> void f1(const T &s) { if(s.size() > 42) if(s.empty()) {}}");
+        ASSERT_EQUALS("", errout_str()); //We don't know the type of T so we don't know the relationship between size() and empty(). e.g. s might be a 50 tonne truck with nothing in it.
 
-        check("void f2(const std::wstring &s) { if(s.empty()) if(s.size() > 42) {}} ");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        check("void f2(const std::wstring &s) { if(s.empty()) if(s.size() > 42) {}}");
+        ASSERT_EQUALS("[test.cpp:1:44] -> [test.cpp:1:60]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f1(QString s) { if(s.isEmpty()) if(s.length() > 42) {}} ");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Opposite inner 'if' condition leads to a dead code block.\n", errout.str());
+        check("void f1(QString s) { if(s.isEmpty()) if(s.length() > 42) {}}");
+        ASSERT_EQUALS("[test.cpp:1:34] -> [test.cpp:1:52]: (warning) Opposite inner 'if' condition leads to a dead code block. [oppositeInnerCondition]\n", errout_str());
 
-        check("void f1(const std::string &s, bool b) { if(s.empty() || ((s.size() == 1) && b)) {}} ");
-        ASSERT_EQUALS("", errout.str());
+        check("void f1(const std::string &s, bool b) { if(s.empty() || ((s.size() == 1) && b)) {}}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f1(const std::string &x, const std::string &y) { if(x.size() > 42) if(y.empty()) {}} ");
-        ASSERT_EQUALS("", errout.str());
+        check("void f1(const std::string &x, const std::string &y) { if(x.size() > 42) if(y.empty()) {}}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f1(const std::string &x, const std::string &y) { if(y.empty()) if(x.size() > 42) {}} ");
-        ASSERT_EQUALS("", errout.str());
+        check("void f1(const std::string &x, const std::string &y) { if(y.empty()) if(x.size() > 42) {}}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f1(const std::string v[10]) { if(v[0].size() > 42) if(v[1].empty()) {}} ");
-        ASSERT_EQUALS("", errout.str());
+        check("void f1(const std::string v[10]) { if(v[0].size() > 42) if(v[1].empty()) {}}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f1(const std::string &s) { if(s.size() <= 1) if(s.empty()) {}} ");
-        ASSERT_EQUALS("", errout.str());
+        check("void f1(const std::string &s) { if(s.size() <= 1) if(s.empty()) {}}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f1(const std::string &s) { if(s.size() <= 2) if(s.empty()) {}} ");
-        ASSERT_EQUALS("", errout.str());
+        check("void f1(const std::string &s) { if(s.size() <= 2) if(s.empty()) {}}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f1(const std::string &s) { if(s.size() < 2) if(s.empty()) {}} ");
-        ASSERT_EQUALS("", errout.str());
+        check("void f1(const std::string &s) { if(s.size() < 2) if(s.empty()) {}}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f1(const std::string &s) { if(s.size() >= 0) if(s.empty()) {}} ");
-        ASSERT_EQUALS("", errout.str());
+        check("void f1(const std::string &s) { if(s.size() >= 0) if(s.empty()) {}} "); // CheckOther says: Unsigned expression 's.size()' can't be negative so it is unnecessary to test it. [unsignedPositive]
+        ASSERT_EQUALS("", errout_str());
 
         // TODO: These are identical condition since size cannot be negative
-        check("void f1(const std::string &s) { if(s.size() <= 0) if(s.empty()) {}} ");
-        ASSERT_EQUALS("", errout.str());
+        check("void f1(const std::string &s) { if(s.size() <= 0) if(s.empty()) {}}");
+        ASSERT_EQUALS("", errout_str());
 
         // TODO: These are identical condition since size cannot be negative
-        check("void f1(const std::string &s) { if(s.size() < 1) if(s.empty()) {}} ");
-        ASSERT_EQUALS("", errout.str());
+        check("void f1(const std::string &s) { if(s.size() < 1) if(s.empty()) {}}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void oppositeInnerConditionFollowVar() {
@@ -2357,7 +2695,21 @@ class TestCondition : public TestFixture {
               "    void bar();\n"
               "    int get() const;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct CD {\n"
+              "    bool state;\n"
+              "    void foo()  {\n"
+              "        const bool flag = this->get();\n"
+              "        if (flag) {\n"
+              "            this->bar();\n"
+              "            if (!this->get()) return;\n"
+              "        }\n"
+              "    }\n"
+              "    bool get() const;\n"
+              "    void bar();\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
 
         check("class C {\n"
               "public:\n"
@@ -2371,15 +2723,39 @@ class TestCondition : public TestFixture {
               "  x += 1;\n"
               "  if (!b && f()) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(double d) {\n"
+              "    if (d != 0) {\n"
+              "        int i = d;\n"
+              "        if (i == 0) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void oppositeInnerConditionLambda() {
+        check("void f() {\n" // #13728
+              "    for (int i = 0; i < 2;) {\n"
+              "        auto inc = [&]() {\n"
+              "            if (i >= 2)\n"
+              "                throw 0;\n"
+              "            return i++;\n"
+              "        };\n"
+              "        inc();\n"
+              "        inc();\n"
+              "        inc();\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void identicalInnerCondition() {
         check("void f1(int a, int b) { if(a==b) if(a==b) {}}");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Identical inner 'if' condition is always true.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:29] -> [test.cpp:1:38]: (warning) Identical inner 'if' condition is always true. [identicalInnerCondition]\n", errout_str());
 
         check("void f2(int a, int b) { if(a!=b) if(a!=b) {}}");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (warning) Identical inner 'if' condition is always true.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:29] -> [test.cpp:1:38]: (warning) Identical inner 'if' condition is always true. [identicalInnerCondition]\n", errout_str());
 
         // #6645 false negative: condition is always false
         check("void f(bool a, bool b) {\n"
@@ -2387,39 +2763,39 @@ class TestCondition : public TestFixture {
               "     if(a) {}\n"
               "     else  {}\n"
               "  }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Identical inner 'if' condition is always true.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:6] -> [test.cpp:3:9]: (warning) Identical inner 'if' condition is always true. [identicalInnerCondition]\n", errout_str());
 
         check("bool f(int a, int b) {\n"
               "    if(a == b) { return a == b; }\n"
               "    return false;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:2]: (warning) Identical inner 'return' condition is always true.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:10] -> [test.cpp:2:27]: (warning) Identical inner 'return' condition is always true. [identicalInnerCondition]\n", errout_str());
 
         check("bool f(bool a) {\n"
               "    if(a) { return a; }\n"
               "    return false;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("int* f(int* a, int * b) {\n"
               "    if(a) { return a; }\n"
               "    return b;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("int* f(std::shared_ptr<int> a, std::shared_ptr<int> b) {\n"
               "    if(a.get()) { return a.get(); }\n"
               "    return b.get();\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A { int * x; };\n"
               "int* f(A a, int * b) {\n"
               "    if(a.x) { return a.x; }\n"
               "    return b;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    uint32_t value;\n"
@@ -2430,71 +2806,90 @@ class TestCondition : public TestFixture {
               "        get_value (&value);\n"
               "        if ((value >> 28) & 1) {}\n"
               "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkP("#define TYPE_1 \"a\"\n" // #13202
+               "#define TYPE_2 \"b\"\n"
+               "#define TYPE_3 \"c\"\n"
+               "void f(const std::string& s) {\n"
+               "    if (s == TYPE_1) {}\n"
+               "    else if (s == TYPE_2 || s == TYPE_3) {\n"
+               "        if (s == TYPE_2) {}\n"
+               "        else if (s == TYPE_3) {}\n"
+               "    }\n"
+               "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const int* p, const int* e) {\n" // #14595
+              "    for (; p;) {\n"
+              "        if (p == e) {}\n"
+              "        if (p) {}\n"
+              "    }\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:12] -> [test.cpp:4:13]: (warning) Identical inner 'if' condition is always true. [identicalInnerCondition]\n", errout_str());
     }
 
     void identicalConditionAfterEarlyExit() {
-        check("void f(int x) {\n"
+        check("void f(int x) {\n" // #8137
               "  if (x > 100) { return; }\n"
               "  if (x > 100) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Identical condition 'x>100', second condition is always false\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:9]: (warning) Identical condition 'x>100', second condition is always false [identicalConditionAfterEarlyExit]\n", errout_str());
 
         check("bool f(int x) {\n"
               "  if (x > 100) { return false; }\n"
               "  return x > 100;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Identical condition 'x>100', second condition is always false\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:12]: (warning) Identical condition and return expression 'x>100', return value is always false [identicalConditionAfterEarlyExit]\n", errout_str());
 
         check("void f(int x) {\n"
               "  if (x > 100) { return; }\n"
               "  if (x > 100 || y > 100) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Identical condition 'x>100', second condition is always false\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:9]: (warning) Identical condition 'x>100', second condition is always false [identicalConditionAfterEarlyExit]\n", errout_str());
 
         check("void f(int x) {\n"
               "  if (x > 100) { return; }\n"
               "  if (x > 100 && y > 100) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Identical condition 'x>100', second condition is always false\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:9]: (warning) Identical condition 'x>100', second condition is always false [identicalConditionAfterEarlyExit]\n", errout_str());
 
         check("void f(int x) {\n"
               "  if (x > 100) { return; }\n"
               "  if (abc) {}\n"
               "  if (x > 100) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (warning) Identical condition 'x>100', second condition is always false\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:4:9]: (warning) Identical condition 'x>100', second condition is always false [identicalConditionAfterEarlyExit]\n", errout_str());
 
         check("void f(int x) {\n"
               "  if (x > 100) { return; }\n"
               "  while (abc) { y = x; }\n"
               "  if (x > 100) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (warning) Identical condition 'x>100', second condition is always false\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:4:9]: (warning) Identical condition 'x>100', second condition is always false [identicalConditionAfterEarlyExit]\n", errout_str());
 
-        check("void f(int x) {\n"  // #8217 - crash for incomplete code
-              "  if (x > 100) { return; }\n"
-              "  X(do);\n"
-              "  if (x > 100) {}\n"
-              "}");
-        // TODO: we should probably throw unknownMacro InternalError. Complain that the macro X must be defined. We can't check the code well without the definition.
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (style) Condition 'x>100' is always false\n", errout.str());
+        ASSERT_THROW_INTERNAL(check("void f(int x) {\n"  // #8217 - crash for incomplete code
+                                    "  if (x > 100) { return; }\n"
+                                    "  X(do);\n"
+                                    "  if (x > 100) {}\n"
+                                    "}"),
+                              SYNTAX);
 
         check("void f(const int *i) {\n"
               "  if (!i) return;\n"
               "  if (!num1tok) { *num1 = *num2; }\n"
               "  if (!i) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (warning) Identical condition '!i', second condition is always false\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:7] -> [test.cpp:4:7]: (warning) Identical condition '!i', second condition is always false [identicalConditionAfterEarlyExit]\n", errout_str());
 
         check("void C::f(Tree &coreTree) {\n" // daca
               "  if(!coreTree.build())\n"
               "    return;\n"
               "  coreTree.dostuff();\n"
               "  if(!coreTree.build()) {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C { void f(const Tree &coreTree); };\n"
               "void C::f(const Tree &coreTree) {\n"
@@ -2502,8 +2897,8 @@ class TestCondition : public TestFixture {
               "    return;\n"
               "  coreTree.dostuff();\n"
               "  if(!coreTree.build()) {}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:6]: (warning) Identical condition '!coreTree.build()', second condition is always false\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:6] -> [test.cpp:6:6]: (warning) Identical condition '!coreTree.build()', second condition is always false [identicalConditionAfterEarlyExit]\n", errout_str());
 
         check("void f(int x) {\n" // daca: labplot
               "  switch(type) {\n"
@@ -2516,7 +2911,7 @@ class TestCondition : public TestFixture {
               "  }\n"
               "  return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("static int failed = 0;\n"
               "void f() {\n"
@@ -2524,14 +2919,14 @@ class TestCondition : public TestFixture {
               "  checkBuffer();\n"
               "  if (failed) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // daca icu
         check("void f(const uint32_t *section, int32_t  start) {\n"
               "  if(10<=section[start]) { return; }\n"
               "  if(++start<100 && 10<=section[start]) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // daca iqtree
         check("void readNCBITree(std::istream &in) {\n"
@@ -2540,8 +2935,8 @@ class TestCondition : public TestFixture {
               "  if (ch != '|') return;\n"
               "  in >> ch;\n"
               "  if (ch != '|') {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // #8924
         check("struct A {\n"
@@ -2550,9 +2945,49 @@ class TestCondition : public TestFixture {
               "        this->FileIndex = 1 ;\n"
               "        if (this->FileIndex < 0) return;\n"
               "    }\n"
-              "    int FileIndex;  \n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "    int FileIndex;\n"
+              "};");
+        ASSERT_EQUALS("[test.cpp:5:29]: (style) Condition 'this->FileIndex<0' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        // #8858 - #if
+        check("short Do() {\n"
+              "    short ret = bar1();\n"
+              "    if ( ret )\n"
+              "        return ret;\n"
+              "#ifdef FEATURE\n"
+              "    ret = bar2();\n"
+              "#endif\n"
+              "    return ret;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10456
+        check("int f() {\n"
+              "    int i = 0;\n"
+              "    auto f = [&](bool b) { if (b) ++i; };\n"
+              "    if (i) return i;\n"
+              "    f(true);\n"
+              "    if (i) return i;\n"
+              "    return 0;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11478
+        check("struct S {\n"
+              "    void run();\n"
+              "    bool b = false;\n"
+              "    const std::function<void(S&)> f;\n"
+              "};\n"
+              "void S::run() {\n"
+              "    while (true) {\n"
+              "        if (b)\n"
+              "            return;\n"
+              "        f(*this);\n"
+              "        if (b)\n"
+              "            return;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void innerConditionModified() {
@@ -2562,7 +2997,7 @@ class TestCondition : public TestFixture {
               "    if (x == 0) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "  if (x == 0) {\n"
@@ -2570,7 +3005,7 @@ class TestCondition : public TestFixture {
               "    if (x == 1) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int * x, int * y) {\n"
               "  if (x[*y] == 0) {\n"
@@ -2578,7 +3013,7 @@ class TestCondition : public TestFixture {
               "    if (x[*y] == 0) {}\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // clarify conditions with = and comparison
@@ -2586,92 +3021,102 @@ class TestCondition : public TestFixture {
         check("void f() {\n"
               "    if (x = b() < 0) {}\n" // don't simplify and verify this code
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Suspicious condition (assignment + comparison); Clarify expression with parentheses.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:8]: (style) Suspicious condition (assignment + comparison); Clarify expression with parentheses. [clarifyCondition]\n", errout_str());
 
         check("void f(int i) {\n"
               "    for (i = 0; i < 10; i++) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    x = a<int>(); if (x) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    if (x = b < 0 ? 1 : 2) {}\n" // don't simplify and verify this code
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int y = rand(), z = rand();\n"
               "    if (y || (!y && z));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Redundant condition: !y. 'y || (!y && z)' is equivalent to 'y || z'\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Redundant condition: !y. 'y || (!y && z)' is equivalent to 'y || z' [redundantCondition]\n", errout_str());
 
         check("void f() {\n"
               "    int y = rand(), z = rand();\n"
               "    if (y || !y && z);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Redundant condition: !y. 'y || (!y && z)' is equivalent to 'y || z'\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Redundant condition: !y. 'y || (!y && z)' is equivalent to 'y || z' [redundantCondition]\n", errout_str());
 
         check("void f() {\n"
               "    if (!a || a && b) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Redundant condition: a. '!a || (a && b)' is equivalent to '!a || b'\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:12]: (style) Redundant condition: a. '!a || (a && b)' is equivalent to '!a || b' [redundantCondition]\n", errout_str());
 
 
         check("void f(const Token *tok) {\n"
-              "    if (!tok->next()->function() || \n"
+              "    if (!tok->next()->function() ||\n"
               "        (tok->next()->function() && tok->next()->function()->isConstructor()));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Redundant condition: tok->next()->function(). '!A || (A && B)' is equivalent to '!A || B'\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:34]: (style) Redundant condition: tok->next()->function(). '!A || (A && B)' is equivalent to '!A || B' [redundantCondition]\n", errout_str());
 
         check("void f() {\n"
-              "    if (!tok->next()->function() || \n"
+              "    if (!tok->next()->function() ||\n"
               "        (!tok->next()->function() && tok->next()->function()->isConstructor()));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
-              "    if (!tok->next()->function() || \n"
+              "    if (!tok->next()->function() ||\n"
               "        (!tok2->next()->function() && tok->next()->function()->isConstructor()));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(const Token *tok) {\n"
-              "    if (!tok->next(1)->function(1) || \n"
+              "    if (!tok->next(1)->function(1) ||\n"
               "        (tok->next(1)->function(1) && tok->next(1)->function(1)->isConstructor()));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Redundant condition: tok->next(1)->function(1). '!A || (A && B)' is equivalent to '!A || B'\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:36]: (style) Redundant condition: tok->next(1)->function(1). '!A || (A && B)' is equivalent to '!A || B' [redundantCondition]\n", errout_str());
 
         check("void f() {\n"
-              "    if (!tok->next()->function(1) || \n"
+              "    if (!tok->next()->function(1) ||\n"
               "        (tok->next()->function(2) && tok->next()->function()->isConstructor()));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "   int y = rand(), z = rand();\n"
               "   if (y==0 || y!=0 && z);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Redundant condition: y!=0. 'y==0 || (y!=0 && z)' is equivalent to 'y==0 || z'\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:13]: (style) Redundant condition: y!=0. 'y==0 || (y!=0 && z)' is equivalent to 'y==0 || z' [redundantCondition]\n", errout_str());
 
         check("void f() {\n"
               "  if (x>0 || (x<0 && y)) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Test Token::expressionString, TODO move this test
         check("void f() {\n"
               "  if (!dead || (dead && (*it).ticks > 0)) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Redundant condition: dead. '!dead || (dead && (*it).ticks>0)' is equivalent to '!dead || (*it).ticks>0'\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (style) Redundant condition: dead. '!dead || (dead && (*it).ticks>0)' is equivalent to '!dead || (*it).ticks>0' [redundantCondition]\n", errout_str());
 
         check("void f() {\n"
               "  if (!x || (x && (2>(y-1)))) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Redundant condition: x. '!x || (x && 2>(y-1))' is equivalent to '!x || 2>(y-1)'\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (style) Redundant condition: x. '!x || (x && 2>(y-1))' is equivalent to '!x || 2>(y-1)' [redundantCondition]\n", errout_str());
+
+        check("void f(bool a, bool b) {\n"
+              "    if (a || (a && b)) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Redundant condition: a. 'a || (a && b)' is equivalent to 'a' [redundantCondition]\n", errout_str());
+
+        check("void f(bool a, bool b) {\n"
+              "    if (a && (a || b)) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Redundant condition: a. 'a && (a || b)' is equivalent to 'a' [redundantCondition]\n", errout_str());
     }
 
     // clarify conditions with bitwise operator and comparison
@@ -2679,17 +3124,16 @@ class TestCondition : public TestFixture {
         check("void f() {\n"
               "    if (x & 3 == 2) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Suspicious condition (bitwise operator + comparison); Clarify expression with parentheses.\n"
-                      "[test.cpp:2]: (style) Boolean result is used in bitwise operation. Clarify expression with parentheses.\n"
-                      "[test.cpp:2]: (style) Condition 'x&3==2' is always false\n"
-                      "[test.cpp:2]: (style) Condition '3==2' is always false\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:8]: (style) Suspicious condition (bitwise operator + comparison); Clarify expression with parentheses. [clarifyCondition]\n"
+                      "[test.cpp:2:11]: (style) Boolean result is used in bitwise operation. Clarify expression with parentheses. [clarifyCondition]\n"
+                      "[test.cpp:2:11]: (style) Condition 'x&3==2' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "    if (a & fred1.x == fred2.y) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Suspicious condition (bitwise operator + comparison); Clarify expression with parentheses.\n"
-                      "[test.cpp:2]: (style) Boolean result is used in bitwise operation. Clarify expression with parentheses.\n"
-                      , errout.str());
+        ASSERT_EQUALS("[test.cpp:2:8]: (style) Suspicious condition (bitwise operator + comparison); Clarify expression with parentheses. [clarifyCondition]\n"
+                      "[test.cpp:2:11]: (style) Boolean result is used in bitwise operation. Clarify expression with parentheses. [clarifyCondition]\n"
+                      , errout_str());
     }
 
     // clarify condition that uses ! operator and then bitwise operator
@@ -2697,50 +3141,50 @@ class TestCondition : public TestFixture {
         check("void f(int w) {\n"
               "    if(!w & 0x8000) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Boolean result is used in bitwise operation. Clarify expression with parentheses.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Boolean result is used in bitwise operation. Clarify expression with parentheses. [clarifyCondition]\n", errout_str());
 
         check("void f(int w) {\n"
               "    if((!w) & 0x8000) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    if (x == foo() & 2) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Boolean result is used in bitwise operation. Clarify expression with parentheses.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:20]: (style) Boolean result is used in bitwise operation. Clarify expression with parentheses. [clarifyCondition]\n", errout_str());
 
         check("void f() {\n"
               "    if (2 & x == foo()) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Boolean result is used in bitwise operation. Clarify expression with parentheses.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Boolean result is used in bitwise operation. Clarify expression with parentheses. [clarifyCondition]\n", errout_str());
 
         check("void f() {\n"
               "    if (2 & (x == foo())) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(std::list<int> &ints) { }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() { A<x &> a; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f() { a(x<y|z,0); }", "test.c");  // filename is c => there are never templates
-        ASSERT_EQUALS("[test.c:1]: (style) Boolean result is used in bitwise operation. Clarify expression with parentheses.\n", errout.str());
+        check("void f() { a(x<y|z,0); }", dinit(CheckOptions, $.cpp = false));  // language is c => there are never templates
+        ASSERT_EQUALS("[test.c:1:17]: (style) Boolean result is used in bitwise operation. Clarify expression with parentheses. [clarifyCondition]\n", errout_str());
 
-        check("class A<B&,C>;", "test.cpp");
-        ASSERT_EQUALS("", errout.str());
+        check("class A<B&,C>;");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    if (result != (char *)&inline_result) { }\n" // don't simplify and verify cast
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #8495
         check("void f(bool a, bool b) {\n"
               "    C & a & b;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void clarifyCondition4() { // ticket #3110
@@ -2755,13 +3199,13 @@ class TestCondition : public TestFixture {
               "         return left.first < right.first;\n"
               "     }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void clarifyCondition5() { // ticket #3609 (using | in template instantiation)
         check("template<bool B> struct CWinTraits;\n"
               "CWinTraits<WS_CHILD|WS_VISIBLE>::GetWndStyle(0);");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void clarifyCondition6() {
@@ -2770,7 +3214,7 @@ class TestCondition : public TestFixture {
               "    px = r.px;\n"
               "    return *this;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void clarifyCondition7() {
@@ -2779,7 +3223,7 @@ class TestCondition : public TestFixture {
               "    bool & withoutSideEffects=found.first->second;\n" // Declaring a reference to a boolean; & is no operator at all
               "    execute(secondExpression, &programMemory, &result, &error);\n" // Unary &
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void clarifyCondition8() {
@@ -2789,24 +3233,24 @@ class TestCondition : public TestFixture {
               "bool f(bool b) {\n"
               "    return (a() & b);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(bool *a, bool b) {\n"
               "    return (a[10] & b);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A { bool a; };\n"
               "bool f(struct A a, bool b) {\n"
               "    return (a.a & b);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A { bool a; };\n"
               "bool f(struct A a, bool b) {\n"
               "    return (A::a & b);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testBug5895() {
@@ -2814,7 +3258,7 @@ class TestCondition : public TestFixture {
               "    if (init == 0x89504e470d0a1a0a || init == 0x8a4d4e470d0a1a0a)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testBug5309() {
@@ -2823,92 +3267,126 @@ class TestCondition : public TestFixture {
               "    if( ( value >= 0x7ff0000000000001ULL )\n"
               "            && ( value <= 0x7fffffffffffffffULL ) );\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void alwaysTrue() {
+
+        check("void f(const struct S *s) {\n" //#8196
+              "  int x1 = s->x;\n"
+              "  int x2 = s->x;\n"
+              "  if (x1 == 10 && x2 == 10) {}\n" // <<
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:10] -> [test.cpp:4:22]: (style) Condition 'x2==10' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f ()\n"// #8220
+              "{\n"
+              "    int a;\n"
+              "    int b = 0;\n"
+              "    int ret;\n"
+              " \n"
+              "    a = rand();\n"
+              "    while (((0 < a) && (a < 2)) && ((8 < a) && (a < 10))) \n"
+              "    {\n"
+              "        b += a;\n"
+              "        a ++;\n"
+              "    }\n"
+              "    ret = b;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:8:27] -> [test.cpp:8:40]: (style) Condition '8<a' is always false [knownConditionTrueFalse]\n", errout_str());
+
         check("void f() {\n" // #4842
               "  int x = 0;\n"
               "  if (a) { return; }\n" // <- this is just here to fool simplifyKnownVariabels
               "  if (!x) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Condition '!x' is always true\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: (style) Condition '!x' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("bool f(int x) {\n"
-              "  if(x == 0) { x++; return x == 0; } \n"
+              "  if(x == 0) { x++; return x == 0; }\n"
               "  return false;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:2]: (style) Condition 'x==0' is always false\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:8] -> [test.cpp:2:30]: (style) Return value 'x==0' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n" // #6898 (Token::expressionString)
               "  int x = 0;\n"
               "  A(x++ == 1);\n"
               "  A(x++ == 2);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Condition 'x++==1' is always false\n"
-                      "[test.cpp:4]: (style) Condition 'x++==2' is always false\n",
-                      errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Condition 'x++==1' is always false [knownConditionTrueFalse]\n"
+                      "[test.cpp:4:9]: (style) Condition 'x++==2' is always false [knownConditionTrueFalse]\n",
+                      errout_str());
+
+        check("bool foo(int bar) {\n"
+              "  bool ret = false;\n"
+              "  if (bar == 1)\n"
+              "    return ret;\n" // <- #9326 - FP condition is always false
+              "  if (bar == 2)\n"
+              "    ret = true;\n"
+              "  return ret;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f1(const std::string &s) { if(s.empty()) if(s.size() == 0) {}} ");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (style) Condition 's.size()==0' is always true\n", errout.str());
+        check("void f1(const std::string &s) { if(s.empty()) if(s.size() == 0) {}}");
+        ASSERT_EQUALS("[test.cpp:1:43] -> [test.cpp:1:59]: (style) Condition 's.size()==0' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "   int buf[42];\n"
               "   if( buf != 0) {}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Condition 'buf!=0' is always true\n", errout.str()); // #8924
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:12]: (style) Condition 'buf!=0' is always true [knownConditionTrueFalse]\n", errout_str()); // #8924
 
         check("void f() {\n"
               "   int buf[42];\n"
               "   if( !buf ) {}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Condition '!buf' is always false\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:8]: (style) Condition '!buf' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "   int buf[42];\n"
               "   bool b = buf;\n"
               "   if( b ) {}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Condition 'b' is always true\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:8]: (style) Condition 'b' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "   int buf[42];\n"
               "   bool b = buf;\n"
               "   if( !b ) {}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Condition '!b' is always false\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:8]: (style) Condition '!b' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "   int buf[42];\n"
               "   int * p = nullptr;\n"
               "   if( buf == p ) {}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Condition 'buf==p' is always false\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:12]: (style) Condition 'buf==p' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(bool x) {\n"
               "   int buf[42];\n"
               "   if( buf || x ) {}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Condition 'buf' is always true\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:8]: (style) Condition 'buf' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int * p) {\n"
               "   int buf[42];\n"
               "   if( buf == p ) {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "   int buf[42];\n"
               "   int p[42];\n"
               "   if( buf == p ) {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "   int buf[42];\n"
               "   if( buf == 1) {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // Avoid FP when condition comes from macro
         check("#define NOT !\n"
@@ -2917,7 +3395,7 @@ class TestCondition : public TestFixture {
               "  if (a) { return; }\n" // <- this is just here to fool simplifyKnownVariabels
               "  if (NOT x) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("#define M  x != 0\n"
               "void f() {\n"
@@ -2925,25 +3403,28 @@ class TestCondition : public TestFixture {
               "  if (a) { return; }\n" // <- this is just here to fool simplifyKnownVariabels
               "  if (M) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("#define IF(X)  if (X && x())\n"
               "void f() {\n"
               "  IF(1) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Avoid FP for sizeof condition
         check("void f() {\n"
               "  if (sizeof(char) != 123) {}\n"
+              "  if (123 != sizeof(char)) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  int x = 123;\n"
               "  if (sizeof(char) != x) {}\n"
+              "  if (x != sizeof(char)) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Condition 'sizeof(char)!=x' is always true\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3]: (style) Condition 'sizeof(char)!=x' is always true\n"
+                           "[test.cpp:4]: (style) Condition 'x!=sizeof(char)' is always true\n", "", errout_str());
 
         // Don't warn in assertions. Condition is often 'always true' by intention.
         // If platform,defines,etc cause an 'always false' assertion then that is not very dangerous neither
@@ -2951,7 +3432,16 @@ class TestCondition : public TestFixture {
               "  int x = 0;\n"
               "  assert(x == 0);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // #9363 - do not warn about value passed to function
+        check("void f(bool b) {\n"
+              "    if (b) {\n"
+              "        if (bar(!b)) {}\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
 
         // #7783  FP knownConditionTrueFalse on assert(0 && "message")
         check("void foo(int x) {\n"
@@ -2964,8 +3454,8 @@ class TestCondition : public TestFixture {
               "        assert((int)(0==0));\n"
               "        assert((int)(0==0) && \"bla\");\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // #7750 char literals in boolean expressions
         check("void f() {\n"
@@ -2974,26 +3464,34 @@ class TestCondition : public TestFixture {
               "  if(1 && 'c'){}\n"
               "  int x = 'd' ? 1 : 2;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // #8206 - knownCondition always false
+        check("void f(int i)\n"
+              "{\n"
+              "        if(i > 4)\n"
+              "          for( int x = 0; i < 3; ++x){}\n" // <<
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:14] -> [test.cpp:4:29]: (style) Condition 'i<3' is always false [knownConditionTrueFalse]\n", errout_str());
 
         // Skip literals
         check("void f() { if(true) {} }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() { if(false) {} }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() { if(!true) {} }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() { if(!false) {} }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() { if(0) {} }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() { if(1) {} }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int i) {\n"
               "    bool b = false;\n"
@@ -3001,37 +3499,37 @@ class TestCondition : public TestFixture {
               "    else if (!b && i == 1) {}\n"
               "    if (b)\n"
               "    {}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Condition '!b' is always true\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:14]: (style) Condition '!b' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("bool f() { return nullptr; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("enum E { A };\n"
-              "bool f() { return A; }\n");
-        ASSERT_EQUALS("", errout.str());
+              "bool f() { return A; }");
+        ASSERT_EQUALS("", errout_str());
 
-        check("bool f() { \n"
+        check("bool f() {\n"
               "    const int x = 0;\n"
-              "    return x; \n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "    return x;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("int f(void){return 1/abs(10);}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("bool f() { \n"
+        check("bool f() {\n"
               "    int x = 0;\n"
-              "    return x; \n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "    return x;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f() {\n"
               "    const int a = 50;\n"
               "    const int b = 52;\n"
               "    return a+b;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:13]: (style) Return value 'a+b' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("int f() {\n"
               "    int a = 50;\n"
@@ -3039,16 +3537,16 @@ class TestCondition : public TestFixture {
               "    a++;\n"
               "    b++;\n"
               "    return a+b;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("bool& g();\n"
               "bool f() {\n"
               "    bool & b = g();\n"
               "    b = false;\n"
               "    return b;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
               "    bool b;\n"
@@ -3056,14 +3554,14 @@ class TestCondition : public TestFixture {
               "        b = false;\n"
               "        return b;\n"
               "    }\n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(long maxtime) {\n"
               "  if (std::time(0) > maxtime)\n"
               "    return std::time(0) > maxtime;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(double param) {\n"
               "  while(bar()) {\n"
@@ -3072,8 +3570,8 @@ class TestCondition : public TestFixture {
               "  }\n"
               "  if (param<0.)\n"
               "    return;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int i) {\n"
               "  if (i==42)\n"
@@ -3082,8 +3580,8 @@ class TestCondition : public TestFixture {
               "  }\n"
               "  if (cond && (42==i))\n"
               "    return;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // 8842 crash
         check("class a {\n"
@@ -3092,16 +3590,16 @@ class TestCondition : public TestFixture {
               "  void f() {\n"
               "    if (b) return;\n"
               "  }\n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(const char* x, const char* t) {\n"
               "    if (!(strcmp(x, y) == 0)) { return; }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(const int a[]){ if (a == 0){} }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n"
               "  bool operator<(const S&);\n"
@@ -3111,8 +3609,8 @@ class TestCondition : public TestFixture {
               "  bool c = s<s;\n"
               "  if (c) return 0;\n"
               "  else return 42;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("long X::g(bool unknown, int& result) {\n"
               "    long ret = 0;\n"
@@ -3120,37 +3618,62 @@ class TestCondition : public TestFixture {
               "    f = f || unknown;\n"
               "    f ? result = 42 : ret = -1;\n"
               "    return ret;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("int f(void *handle) {\n"
               "    if (!handle) return 0;\n"
               "    if (handle) return 1;\n"
               "    else return 0;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Condition 'handle' is always true\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:9]: (style) Condition 'handle' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("int f(void *handle) {\n"
               "    if (handle == 0) return 0;\n"
               "    if (handle) return 1;\n"
               "    else return 0;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Condition 'handle' is always true\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Condition 'handle' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("int f(void *handle) {\n"
               "    if (handle != 0) return 0;\n"
               "    if (handle) return 1;\n"
               "    else return 0;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Condition 'handle' is always false\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:16] -> [test.cpp:3:9]: (warning) Identical condition 'handle!=0', second condition is always false [identicalConditionAfterEarlyExit]\n", errout_str());
+
+        check("int f(void *handle) {\n"
+              "    if (handle != nullptr) return 0;\n"
+              "    if (handle) return 1;\n"
+              "    else return 0;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:16] -> [test.cpp:3:9]: (warning) Identical condition 'handle!=nullptr', second condition is always false [identicalConditionAfterEarlyExit]\n", errout_str());
+
+        check("void f(const char* p) {\n" // #13716
+              "    if (!p) {}\n"
+              "    if (p == NULL) {}\n"
+              "    if (p == nullptr) {}\n"
+              "    if (p == 0) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:11]: (style) The if condition is the same as the previous if condition [duplicateCondition]\n",
+                      errout_str());
+
+        check("int f(const char* p) {\n" // #13717
+              "    if (p) {}\n"
+              "    else if (!p) {}\n"
+              "    else if (p == NULL) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:14]: (style) Expression is always true because 'else if' condition is opposite to previous condition at line 2. [multiCondition]\n"
+                      "[test.cpp:4:16]: (style) Expression is always false because 'else if' condition matches previous condition at line 3. [multiCondition]\n",
+                      errout_str());
 
         check("void f(void* x, void* y) {\n"
               "    if (x == nullptr && y == nullptr)\n"
               "        return;\n"
               "    if (x == nullptr || y == nullptr)\n"
               "        return;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void* g();\n"
               "void f(void* a, void* b) {\n"
@@ -3160,8 +3683,8 @@ class TestCondition : public TestFixture {
               "            break;\n"
               "    }\n"
               "    if (a) {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void* g();\n"
               "void f(void* a, void* b) {\n"
@@ -3169,27 +3692,27 @@ class TestCondition : public TestFixture {
               "        a = g();\n"
               "    }\n"
               "    if (a) {}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:6]: (style) Condition 'a' is always false\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:12] -> [test.cpp:6:9]: (style) Condition 'a' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int * x, bool b) {\n"
               "    if (!x && b) {}\n"
               "    else if (x) {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    const std::string x=\"xyz\";\n"
               "    if(!x.empty()){}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Condition '!x.empty()' is always true\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:8]: (style) Condition '!x.empty()' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("std::string g();\n"
               "void f() {\n"
               "    const std::string msg = g();\n"
               "    if(!msg.empty()){}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int *array, int size ) {\n"
               "    for(int i = 0; i < size; ++i) {\n"
@@ -3197,8 +3720,8 @@ class TestCondition : public TestFixture {
               "            continue;\n"
               "        if(array){}\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (style) Condition 'array' is always true\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:12]: (style) Condition 'array' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int *array, int size ) {\n"
               "    for(int i = 0; i < size; ++i) {\n"
@@ -3206,8 +3729,8 @@ class TestCondition : public TestFixture {
               "            continue;\n"
               "        else if(array){}\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (style) Condition 'array' is always true\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:17]: (style) Condition 'array' is always true [knownConditionTrueFalse]\n", errout_str());
 
         // #9277
         check("int f() {\n"
@@ -3216,8 +3739,17 @@ class TestCondition : public TestFixture {
               "        return 0;\n"
               "    else\n"
               "        return 1;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9954
+        check("void f() {\n"
+              "    const size_t a(8 * sizeof(short));\n"
+              "    const size_t b(8 * sizeof(int));\n"
+              "    if constexpr (a == 16 && b == 16) {}\n"
+              "    else if constexpr (a == 16 && b == 32) {}\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #9319
         check("struct S {\n"
@@ -3229,8 +3761,8 @@ class TestCondition : public TestFixture {
               "  bool x = false;\n"
               "  g({0, 1}, x);\n"
               "  if (x) {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // #9318
         check("class A {};\n"
@@ -3240,15 +3772,26 @@ class TestCondition : public TestFixture {
               "    return;\n"
               "  auto b = dynamic_cast<B*>(x);\n"
               "  if (b) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int foo() {\n"
+              "    auto x = getX();\n"
+              "    if (x == nullptr)\n"
+              "        return 1;\n"
+              "    auto y = dynamic_cast<Y*>(x)\n"
+              "    if (y == nullptr)\n"
+              "        return 2;\n"
+              "    return 3;\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // handleKnownValuesInLoop
         check("bool g();\n"
               "void f(bool x) {\n"
               "    if (x) while(x) x = g();\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // isLikelyStream
         check("void f(std::istringstream& iss) {\n"
@@ -3257,24 +3800,8 @@ class TestCondition : public TestFixture {
               "       iss >> x;\n"
               "       if (!iss) break;\n"
               "   }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
-
-        check("void f(int x) {\n"
-              "    if (x > 5) {\n"
-              "        x++;\n"
-              "        if (x == 1) {}\n"
-              "    }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (style) Condition 'x==1' is always false\n", errout.str());
-
-        check("void f(int x) {\n"
-              "    if (x > 5) {\n"
-              "        x++;\n"
-              "        if (x != 1) {}\n"
-              "    }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (style) Condition 'x!=1' is always true\n", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // #9332
         check("struct A { void* g(); };\n"
@@ -3285,23 +3812,23 @@ class TestCondition : public TestFixture {
               "    void* c = a.g();\n"
               "    if (!c) return;\n"
               "    bool compare = c == b;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // #9361
         check("void f(char c) {\n"
               "    if (c == '.') {}\n"
               "    else if (isdigit(c) != 0) {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // #9351
         check("int f(int x) {\n"
               "    const bool b = x < 42;\n"
               "    if(b) return b?0:-1;\n"
               "    return 42;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:3]: (style) Condition 'b' is always true\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:3:18]: (style) Condition 'b' is always true [knownConditionTrueFalse]\n", errout_str());
 
         // #9362
         check("uint8_t g();\n"
@@ -3310,8 +3837,8 @@ class TestCondition : public TestFixture {
               "    if((v != 0x00)) {\n"
               "        if( (v & 0x01) == 0x00) {}\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // #9367
         check("void f(long x) {\n"
@@ -3319,120 +3846,1923 @@ class TestCondition : public TestFixture {
               "        return;\n"
               "    if (x % 360L == 0)\n"
               "        return;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int a, int b) {\n"
+              "    static const int x = 10;\n"
+              "    return x == 1 ? a : b;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("const bool x = false;\n"
+              "void f() {\n"
+              "    if (x) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("const bool x = false;\n"
+              "void f() {\n"
+              "    if (!x) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9709
+        check("void f(int a) {\n"
+              "    bool ok = false;\n"
+              "    const char * r = nullptr;\n"
+              "    do_something(&r);\n"
+              "    if (r != nullptr)\n"
+              "        ok = a != 0;\n"
+              "    if (ok) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9816
+        check("bool g();\n"
+              "void f() {\n"
+              "    bool b = false;\n"
+              "    do {\n"
+              "        do {\n"
+              "            if (g())\n"
+              "                break;\n"
+              "            b = true;\n"
+              "        } while(false);\n"
+              "    } while(!b);\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
-    }
+        ASSERT_EQUALS("", errout_str());
+
+        // #9865
+        check("void f(const std::string &s) {\n"
+              "    for (std::string::const_iterator it = s.begin(); it != s.end(); ++it) {\n"
+              "        const unsigned char c = static_cast<unsigned char>(*it);\n"
+              "        if (c == '0') {}\n"
+              "        else if ((c == 'a' || c == 'A')\n"
+              "                 || (c == 'b' || c == 'B')) {}\n"
+              "        else {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
 
-    void alwaysTrueContainer() {
-        // #9329
-        check("void c1(std::vector<double>&);\n"
-              "void c2(std::vector<double>&);\n"
-              "void foo(int flag) {\n"
-              "    std::vector<double> g;\n"
-              "    if (flag)\n"
-              "        c1(g );\n"
-              "    else\n"
-              "        c2(g );\n"
-              "    if ( !g.empty() )\n"
-              "        return;\n"
+        // #9711
+        check("int main(int argc, char* argv[]) {\n"
+              "  int foo = 0;\n"
+              "  struct option options[] = {\n"
+              "    {\"foo\", no_argument, &foo, \'f\'},\n"
+              "    {NULL, 0, NULL, 0},\n"
+              "  };\n"
+              "  getopt_long(argc, argv, \"f\", options, NULL);\n"
+              "  if (foo) {}\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void foo(int flag) {\n"
-              "    std::vector<double> g;\n"
-              "    if (flag)\n"
-              "        c1(g );\n"
-              "    else\n"
-              "        c2(g );\n"
-              "    if ( !g.empty() )\n"
-              "        return;\n"
+        // TODO: if (!v) is a known condition as well
+        check("struct a {\n"
+              "  int *b();\n"
+              "};\n"
+              "bool g(a c, a* d) {\n"
+              "  a *v, *e = v = &c;\n"
+              "  if (!v)\n"
+              "    return true;\n"
+              "  int *f = v->b();\n"
+              "  if (f)\n"
+              "    v = nullptr;\n"
+              "  if (v == nullptr && e) {}\n"
+              "  return d;\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
-    }
+        ASSERT_EQUALS("[test.cpp:11:23]: (style) Condition 'e' is always true [knownConditionTrueFalse]\n", errout_str());
 
-    void multiConditionAlwaysTrue() {
-        check("void f() {\n"
-              "  int val = 0;\n"
-              "  if (val < 0) continue;\n"
-              "  if (val > 0) {}\n"
+        // #10037
+        check("struct a {\n"
+              "    int* p;\n"
+              "};\n"
+              "void g(a*);\n"
+              "void f() {\n"
+              "    struct a b;\n"
+              "    uint32_t p = (uint32_t) -1;\n"
+              "    b.p = (void *) &p;\n"
+              "    int r = g(&b);\n"
+              "    if (r == 0)\n"
+              "        if (p != (uint32_t) -1) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9890
+        check("int g(int);\n"
+              "bool h(int*);\n"
+              "int f(int *x) {\n"
+              "    int y = g(0);\n"
+              "    if (!y) {\n"
+              "        if (h(x)) {\n"
+              "            y = g(1);\n"
+              "            if (y) {}\n"
+              "            return 0;\n"
+              "        }\n"
+              "        if (!y) {}\n"
+              "    }\n"
+              "    return 0;\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:11:13]: (style) Condition '!y' is always true [knownConditionTrueFalse]\n", errout_str());
 
-        check("void f() {\n"
-              "  int val = 0;\n"
-              "  if (val < 0) {\n"
-              "    if (val > 0) {}\n"
-              "  }\n"
+        // #10134
+        check("bool foo(bool b);\n"
+              "bool thud(const std::vector<std::wstring>& Arr, const std::wstring& Str) {\n"
+              "  if (Arr.empty() && Str.empty())\n"
+              "    return false;\n"
+              "  bool OldFormat = Arr.empty() && !Str.empty();\n"
+              "  if (OldFormat)\n"
+              "    return foo(OldFormat);\n"
+              "  return false;\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f() {\n"
-              "  int val = 0;\n"
-              "  if (val < 0) {\n"
-              "    if (val < 0) {}\n"
-              "  }\n"
+        // #10208
+        check("bool GetFirst(std::string &first);\n"
+              "bool GetNext(std::string &next);\n"
+              "void g(const std::string& name);\n"
+              "void f() {\n"
+              "  for (std::string name; name.empty() ? GetFirst(name) : GetNext(name);)\n"
+              "    g(name);\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f() {\n"
-              "  int activate = 0;\n"
-              "  int foo = 0;\n"
-              "  if (activate) {}\n"
-              "  else if (foo) {}\n"
+        check("bool GetFirst(std::string &first);\n"
+              "bool GetNext(std::string &next);\n"
+              "void g(const std::string& name);\n"
+              "void f() {\n"
+              "  for (std::string name{}; name.empty() ? GetFirst(name) : GetNext(name);)\n"
+              "    g(name);\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Condition 'activate' is always false\n"
-                      "[test.cpp:5]: (style) Condition 'foo' is always false\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        // #6904
-        check("void f() {\n"
-              "  const int b[2] = { 1,0 };\n"
-              "  if(b[1] == 2) {}\n"
+        check("bool GetFirst(std::string &first);\n"
+              "bool GetNext(std::string &next);\n"
+              "void g(const std::string& name);\n"
+              "void f() {\n"
+              "  for (std::string name{'a', 'b'}; name.empty() ? GetFirst(name) : GetNext(name);)\n"
+              "    g(name);\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Condition 'b[1]==2' is always false\n", errout.str());
-    }
+        ASSERT_EQUALS("", errout_str());
 
-    void duplicateCondition() {
-        check("void f(bool x) {\n"
-              "    if(x) {}\n"
-              "    if(x) {}\n"
+        check("bool GetFirst(const std::string &first);\n"
+              "bool GetNext(const std::string &next);\n"
+              "void g(const std::string& name);\n"
+              "void f() {\n"
+              "  for (std::string name; name.empty() ? GetFirst(name) : GetNext(name);)\n"
+              "    g(name);\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) The if condition is the same as the previous if condition\n",
-                      errout.str());
+        ASSERT_EQUALS("[test.cpp:5:36]: (style) Condition 'name.empty()' is always true [knownConditionTrueFalse]\n", errout_str());
 
-        check("void f(int x) {\n"
-              "    if(x == 1) {}\n"
-              "    if(x == 1) {}\n"
+        // #10278
+        check("void foo(unsigned int x) {\n"
+              "    if ((100 - x) > 0) {}\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) The if condition is the same as the previous if condition\n",
-                      errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f(int x) {\n"
-              "    if(x == 1) {}\n"
-              "    if(x == 2) {}\n"
+        // #10298
+        check("void foo(unsigned int x) {\n"
+              "    if (x == -1) {}\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f(int x) {\n"
-              "    if(x == 1) {}\n"
-              "    if(x != 1) {}\n"
+        // #10121
+        check("struct AB {\n"
+              "    int a;\n"
+              "};\n"
+              "struct ABC {\n"
+              "    AB* ab;\n"
+              "};\n"
+              "void g(ABC*);\n"
+              "int f(struct ABC *abc) {\n"
+              "    int err = 0;\n"
+              "    AB *ab = abc->ab;\n"
+              "    if (ab->a == 123){\n"
+              "        g(abc);\n"
+              "        if (ab->a != 123) {\n"
+              "            err = 1;\n"
+              "        }\n"
+              "    }\n"
+              "    return err;\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f(bool x) {\n"
-              "    if(x) {}\n"
-              "    g();\n"
+        // #10323
+        check("void foo(int x) {\n"
+              "    if(x)\n"
+              "        if(x == 1) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo(int x) {\n"
               "    if(x) {}\n"
+              "    else\n"
+              "        if(x == 1) {}\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:8] -> [test.cpp:4:14]: (style) Condition 'x==1' is always false [knownConditionTrueFalse]\n", errout_str());
 
-        check("void f(int x) {\n"
-              "    if(x == 1) { x++; }\n"
-              "    if(x == 1) {}\n"
+        // do not report both unsignedLessThanZero and knownConditionTrueFalse
+        check("void foo(unsigned int max) {\n"
+              "    unsigned int num = max - 1;\n"
+              "    if (num < 0) {}\n" // <- do not report knownConditionTrueFalse
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10297
+        check("void foo(size_t len, int start) {\n"
+              "    if (start < 0) {\n"
+              "        start = len+start;\n"
+              "        if (start < 0) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10362
+        check("int tok;\n"
+              "void next();\n"
+              "void parse_attribute() {\n"
+              "    if (tok == '(') {\n"
+              "        int parenthesis = 0;\n"
+              "        do {\n"
+              "            if (tok == '(')\n"
+              "                parenthesis++;\n"
+              "            else if (tok == ')')\n"
+              "                parenthesis--;\n"
+              "            next();\n"
+              "        } while (parenthesis && tok != -1);\n"
+              "    }\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        // #8996
-        check("void g(int** v);\n"
+        // #7843
+        check("void f(int i) {\n"
+              "    if(abs(i) == -1) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:15]: (style) Condition 'abs(i)==-1' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        // #7844
+        check("void f(int i) {\n"
+              "    if(i > 0 && abs(i) == i) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:24]: (style) Condition 'abs(i)==i' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(int i) {\n"
+              "    if(i < 0 && abs(i) == i) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:10] -> [test.cpp:2:24]: (style) Condition 'abs(i)==i' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(int i) {\n"
+              "    if(i > -3 && abs(i) == i) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9948
+        check("bool f(bool a, bool b) {\n"
+              "    return a || ! b || ! a;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:12] -> [test.cpp:2:24]: (style) Return value '!a' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        // #10148
+        check("void f(int i) {\n"
+              "    if (i >= 64) {}\n"
+              "    else if (i >= 32) {\n"
+              "        i &= 31;\n"
+              "        if (i == 0) {}\n"
+              "        else {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10548
+        check("void f() {\n"
+              "    int i = 0;\n"
+              "    do {} while (i++ == 0);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10582
+        check("static void fun(message_t *message) {\n"
+              "    if (message->length >= 1) {\n"
+              "        switch (data[0]) {}\n"
+              "    }\n"
+              "    uint8_t d0 = message->length > 0 ? data[0] : 0xff;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #8266
+        check("void f(bool b) {\n"
+              "    if (b)\n"
+              "        return;\n"
+              "    if (g(&b) || b)\n"
+              "        return;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9720
+        check("bool bar(int &);\n"
+              "void f(int a, int b) {\n"
+              "    if (a + b == 3)\n"
+              "        return;\n"
+              "    if (bar(a) && (a + b == 3)) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10437
+        check("void f() {\n"
+              "  Obj* PObj = nullptr;\n"
+              "  bool b = false;\n"
+              "  if (GetObj(PObj) && PObj != nullptr)\n"
+              "    b = true;\n"
+              "  if (b) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10223
+        check("static volatile sig_atomic_t is_running;\n"
+              "static void handler(int signum) {\n"
+              "    is_running = 0;\n"
+              "}\n"
+              "void f() {\n"
+              "    signal(SIGINT, &handler);\n"
+              "    is_running = 1;\n"
+              "    while (is_running) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10659
+        check("auto func(const std::tuple<int, int>& t) {\n"
+              "  auto& [foo, bar] = t;\n"
+              "  std::cout << foo << bar << std::endl;\n"
+              "  return foo < bar;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10484
+        check("void f() {\n"
+              "    static bool init = true;\n"
+              "    if (init)\n"
+              "        init = false;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:14] -> [test.cpp:3:9]: (style) The statement 'if (init) init=false' is logically equivalent to 'init=false'. [duplicateConditionalAssign]\n", errout_str());
+
+        check("void f() {\n"
+              "    static bool init(true);\n"
+              "    if (init)\n"
+              "        init = false;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:14] -> [test.cpp:3:9]: (style) The statement 'if (init) init=false' is logically equivalent to 'init=false'. [duplicateConditionalAssign]\n", errout_str());
+
+        check("void f() {\n"
+              "    static bool init{ true };\n"
+              "    if (init)\n"
+              "        init = false;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:14] -> [test.cpp:3:9]: (style) The statement 'if (init) init=false' is logically equivalent to 'init=false'. [duplicateConditionalAssign]\n", errout_str());
+
+        // #10248
+        check("void f() {\n"
+              "    static int var(1);\n"
+              "    if (var == 1) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    static int var{ 1 };\n"
+              "    if (var == 1) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void Fun();\n"
+              "using Fn = void (*)();\n"
+              "void f() {\n"
+              "    static Fn logger = nullptr;\n"
+              "    if (logger == nullptr)\n"
+              "        logger = Fun;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void Fun();\n"
+              "using Fn = void (*)();\n"
+              "void f() {\n"
+              "    static Fn logger(nullptr);\n"
+              "    if (logger == nullptr)\n"
+              "        logger = Fun;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void Fun();\n"
+              "using Fn = void (*)();\n"
+              "void f() {\n"
+              "    static Fn logger{ nullptr };\n"
+              "    if (logger == nullptr)\n"
+              "        logger = Fun;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void Fun();\n"
+              "typedef void (*Fn)();\n"
+              "void f() {\n"
+              "    static Fn logger = nullptr;\n"
+              "    if (logger == nullptr)\n"
+              "        logger = Fun;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void Fun();\n"
+              "typedef void (*Fn)();\n"
+              "void f() {\n"
+              "    static Fn logger(nullptr);\n"
+              "    if (logger == nullptr)\n"
+              "        logger = Fun;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void Fun();\n"
+              "typedef void (*Fn)();\n"
+              "void f() {\n"
+              "    static Fn logger{ nullptr };\n"
+              "    if (logger == nullptr)\n"
+              "        logger = Fun;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9256
+        check("bool f() {\n"
+              "    bool b = false;\n"
+              "    b = true;\n"
+              "    return b;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10702
+        check("struct Object {\n"
+              "  int _count=0;\n"
+              "   void increment() { ++_count;}\n"
+              "   auto get() const { return _count; }\n"
+              "};\n"
+              "struct Modifier {\n"
+              "Object & _object;\n"
+              "  explicit Modifier(Object & object) : _object(object) {}\n"
+              "  void do_something() { _object.increment(); }\n"
+              "};\n"
+              "struct Foo {\n"
+              "  Object _object;\n"
+              "  void foo() {\n"
+              "    Modifier mod(_object);\n"
+              "    if (_object.get()>0)\n"
+              "      return;\n"
+              "    mod.do_something();\n"
+              "    if (_object.get()>0)\n"
+              "      return;\n"
+              "  }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct Object {\n"
+              "  int _count=0;\n"
+              "   auto get() const;\n"
+              "};\n"
+              "struct Modifier {\n"
+              "Object & _object;\n"
+              "  explicit Modifier(Object & object);\n"
+              "  void do_something();\n"
+              "};\n"
+              "struct Foo {\n"
+              "  Object _object;\n"
+              "  void foo() {\n"
+              "    Modifier mod(_object);\n"
+              "    if (_object.get()>0)\n"
+              "      return;\n"
+              "    mod.do_something();\n"
+              "    if (_object.get()>0)\n"
+              "      return;\n"
+              "  }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const uint32_t u) {\n"
+              "	const uint32_t v = u < 4;\n"
+              "	if (v) {\n"
+              "		const uint32_t w = v < 2;\n"
+              "		if (w) {}\n"
+              "	}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:24]: (style) Condition 'v<2' is always true [knownConditionTrueFalse]\n"
+                      "[test.cpp:5:7]: (style) Condition 'w' is always true [knownConditionTrueFalse]\n",
+                      errout_str());
+
+        check("void f(double d) {\n" // #10792
+              "    if (d != 0) {\n"
+              "        int i = (int)d;\n"
+              "        if (i == 0) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(double d) {\n"
+              "    if (0 != d) {\n"
+              "        int i = (int)d;\n"
+              "        if (i == 0) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A { double d; }\n"
+              "void f(A a) {\n"
+              "    if (a.d != 0) {\n"
+              "        int i = a.d;\n"
+              "        if (i == 0) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    if(strlen(\"abc\") == 3) {;}\n"
+              "    if(strlen(\"abc\") == 1) {;}\n"
+              "    if(wcslen(L\"abc\") == 3) {;}\n"
+              "    if(wcslen(L\"abc\") == 1) {;}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:22]: (style) Condition 'strlen(\"abc\")==3' is always true [knownConditionTrueFalse]\n"
+                      "[test.cpp:3:22]: (style) Condition 'strlen(\"abc\")==1' is always false [knownConditionTrueFalse]\n"
+                      "[test.cpp:4:23]: (style) Condition 'wcslen(L\"abc\")==3' is always true [knownConditionTrueFalse]\n"
+                      "[test.cpp:5:23]: (style) Condition 'wcslen(L\"abc\")==1' is always false [knownConditionTrueFalse]\n",
+                      errout_str());
+
+        check("int foo(bool a, bool b) {\n"
+              "  if(!a && b && (!a == !b))\n"
+              "   return 1;\n"
+              "  return 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:6] -> [test.cpp:2:21]: (style) Condition '!a==!b' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        // #10454
+        check("struct S {\n"
+              "    int f() const { return g() ? 0 : 1; }\n"
+              "    bool g() const { return u == 18446744073709551615ULL; }\n"
+              "    unsigned long long u{};\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #8358
+        check("void f(double d) { if ((d * 0) != 0) {} }");
+        ASSERT_EQUALS("", errout_str());
+
+        // #6870
+        check("struct S {\n"
+              "    int* p;\n"
+              "    void f() const;\n"
+              "    int g();\n"
+              "};\n"
+              "void S::f() {\n"
+              "    if ((p == NULL) || ((p) && (g() >= *p))) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:7:26]: (style) Condition 'p' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        // #10749
+        check("struct Interface {\n"
+              "    virtual int method() = 0;\n"
+              "};\n"
+              "struct Child : Interface {\n"
+              "   int method() override { return 0; }\n"
+              "   auto foo() {\n"
+              "       if (method() == 0)\n"
+              "           return true;\n"
+              "       else\n"
+              "           return false;\n"
+              "   }\n"
+              "};\n"
+              "struct GrandChild : Child {\n"
+              "   int method() override  { return 1; }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #6855
+        check("struct S { int i; };\n"
+              "void f(S& s) {\n"
+              "    if (!(s.i > 0) && (s.i != 0))\n"
+              "        s.i = 0;\n"
+              "    else if (s.i < 0)\n"
+              "        s.s = 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:15] -> [test.cpp:5:18]: (style) Condition 's.i<0' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        // #6857
+        check("int bar(int i) { return i; }\n"
+              "void foo() {\n"
+              "    if (bar(1) == 0 && bar(1) > 0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:16]: (style) Condition 'bar(1)==0' is always false [knownConditionTrueFalse]\n"
+                      "[test.cpp:3:31]: (style) Condition 'bar(1)>0' is always true [knownConditionTrueFalse]\n",
+                      errout_str());
+
+        check("struct S { int bar(int i) const; };\n"
+              "void foo(const S& s) {\n"
+              "    if (s.bar(1) == 0 && s.bar(1) > 0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:23]: (warning) Logical conjunction always evaluates to false: s.bar(1) == 0 && s.bar(1) > 0. [incorrectLogicOperator]\n",
+                      errout_str());
+
+        check("struct B {\n" // #10618
+              "    void Modify();\n"
+              "    static void Static();\n"
+              "    virtual void CalledByModify();\n"
+              "};\n"
+              "struct D : B {\n"
+              "    int i{};\n"
+              "    void testV();\n"
+              "    void testS();\n"
+              "    void CalledByModify() override { i = 0; }\n"
+              "};\n"
+              "void D::testV() {\n"
+              "    i = 1;\n"
+              "    B::Modify();\n"
+              "    if (i == 1) {}\n"
+              "}\n"
+              "void D::testS() {\n"
+              "    i = 1;\n"
+              "    B::Static();\n"
+              "    if (i == 1) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:20:11]: (style) Condition 'i==1' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        check("typedef struct { bool x; } s_t;\n" // #8446
+              "unsigned f(bool a, bool b) {\n"
+              "    s_t s;\n"
+              "    const unsigned col = a ? (s.x = false) : (b = true);\n"
+              "    if (!s.x) {}\n"
+              "    return col;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #11233
+              "    static std::string m;\n"
+              "    static void f() { m = \"abc\"; }\n"
+              "    static void g() {\n"
+              "        m.clear();\n"
+              "        f();\n"
+              "        if (m.empty()) {}\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11203
+        check("void f() {\n"
+              "    int i = 10;\n"
+              "    if(i > 9.9){}\n"
+              "    float f = 9.9f;\n"
+              "    if(f < 10) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:10]: (style) Condition 'i>9.9' is always true [knownConditionTrueFalse]\n"
+            "[test.cpp:5:10]: (style) Condition 'f<10' is always true [knownConditionTrueFalse]\n",
+            errout_str());
+        check("constexpr int f() {\n" // #11238
+              "    return 1;\n"
+              "}\n"
+              "constexpr bool g() {\n"
+              "    return f() == 1;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int g() { return -1; }\n"
+              "void f() {\n"
+              "    if (g() == 1 && g() == -1) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:13]: (style) Condition 'g()==1' is always false [knownConditionTrueFalse]\n"
+                      "[test.cpp:3:25]: (style) Condition 'g()==-1' is always true [knownConditionTrueFalse]\n",
+                      errout_str());
+
+        // #9817
+        check("void f(float x) {\n"
+              "    if (x <= 0) {}\n"
+              "    else if (x < 1) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10426
+        check("int f() {\n"
+              "    std::string s;\n"
+              "    for (; !s.empty();) {}\n"
+              "    for (; s.empty();) {}\n"
+              "    if (s.empty()) {}\n"
+              "    if ((bool)0) {}\n"
+              "    return s.empty();"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:12]: (style) Condition '!s.empty()' is always false [knownConditionTrueFalse]\n"
+                      "[test.cpp:4:19]: (style) Condition 's.empty()' is always true [knownConditionTrueFalse]\n"
+                      "[test.cpp:5:16]: (style) Condition 's.empty()' is always true [knownConditionTrueFalse]\n"
+                      "[test.cpp:6:9]: (style) Condition '(bool)0' is always false [knownConditionTrueFalse]\n"
+                      "[test.cpp:7:19]: (style) Return value 's.empty()' is always true [knownConditionTrueFalse]\n",
+                      errout_str());
+
+        check("int f(bool b) {\n"
+              "    if (b) return static_cast<int>(1);\n"
+              "    return (int)0;\n"
+              "}\n"
+              "bool g(bool b) {\n"
+              "    if (b) return static_cast<int>(1);\n"
+              "    return (int)0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:35]: (style) Return value 'static_cast<int>(1)' is always true [knownConditionTrueFalse]\n"
+                      "[test.cpp:7:12]: (style) Return value '(int)0' is always false [knownConditionTrueFalse]\n",
+                      errout_str());
+
+        check("int f() { return 3; }\n"
+              "int g() { return f(); }\n"
+              "int h() { if (f()) {} }\n"
+              "int i() { return f() == 3; }\n");
+        ASSERT_EQUALS("[test.cpp:3:16]: (style) Condition 'f()' is always true [knownConditionTrueFalse]\n"
+                      "[test.cpp:4:22]: (style) Return value 'f()==3' is always true [knownConditionTrueFalse]\n",
+                      errout_str());
+
+        check("int f() {\n"
+              "    const char *n;\n"
+              "    return((n=42) &&\n"
+              "           *n == 'A');\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::istringstream& i) {\n" // #9327
+              "    std::string s;\n"
+              "    if (!(i >> s))\n"
+              "        return;\n"
+              "    if (!(i >> s))\n"
+              "        return;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11227
+        check("struct S {\n"
+              "	int get();\n"
+              "};\n"
+              "void f(const S* s) {\n"
+              "    if (!s)\n"
+              "        return;\n"
+              "    g(s ? s->get() : 0);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:7:7]: (style) Condition 's' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(const char* o) {\n" // #11558
+              "    if (!o || !o[0])\n"
+              "        return;\n"
+              "    if (o[0] == '-' && o[1]) {\n"
+              "        if (o[1] == '-') {}\n"
+              "        if (o[1] == '\\0') {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:18]: (style) Condition 'o[1]=='\\0'' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(int x) {\n" // #11449
+              "    int i = x;\n"
+              "    i = (std::min)(i, 1);\n"
+              "    if (i == 1) {}\n"
+              "    int j = x;\n"
+              "    j = (::std::min)(j, 1);\n"
+              "    if (j == 1) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void h(int);\n" // #11679
+              "bool g(int a) { h(a); return false; }\n"
+              "bool f(int i) {\n"
+              "    return g(i);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::string a) {\n" // #11051
+              "    a = \"x\";\n"
+              "    if (a == \"x\") {}\n"
+              "    return a;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Condition 'a==\"x\"' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        check("void g(bool);\n"
+              "void f() {\n"
+              "    int i = 5;\n"
+              "    int* p = &i;\n"
+              "    g(i == 7);\n"
+              "    g(p == nullptr);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:9]: (style) Condition 'i==7' is always false [knownConditionTrueFalse]\n"
+                      "[test.cpp:6:9]: (style) Condition 'p==nullptr' is always false [knownConditionTrueFalse]\n",
+                      errout_str());
+
+        check("enum E { E0, E1 };\n"
+              "void f() {\n"
+              "	static_assert(static_cast<int>(E::E1) == 1);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct a {\n"
+              "  bool g();\n"
+              "  int h();\n"
+              "};\n"
+              "void f(a c, int d, int e) {\n"
+              "  if (c.g() && c.h()) {}\n"
+              "  else {\n"
+              "    bool u = false;\n"
+              "    if (d && e)\n"
+              "      u = true;\n"
+              "    if (u) {}\n"
+              "  }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int i) {\n" // #11741
+              "    i = -i - 1;\n"
+              "    if (i < 0 || i >= 20)\n"
+              "        return 0;\n"
+              "    return 1;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("namespace S { int s{}; };\n" // #11046
+              "void f(bool b) {\n"
+              "    if (S::s) {\n"
+              "        if (b) {\n"
+              "            if (S::s) {}\n"
+              "        }\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:5:18]: (warning) Identical inner 'if' condition is always true. [identicalInnerCondition]\n", errout_str());
+
+        check("void f() {\n" // #10811
+              "    int i = 0;\n"
+              "    if ((i = g(), 1) != 0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:22]: (style) Condition '(i=g(),1)!=0' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(unsigned i) {\n"
+              "    const int a[2] = {};\n"
+              "    const int* q = a + i;\n"
+              "    if (q) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:9]: (style) Condition 'q' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f() {\n" // #12786
+              "    const int b[2] = {};\n"
+              "    if (b) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Condition 'b' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(int i) {\n"
+              "    int j = 0;\n"
+              "    switch (i) {\n"
+              "    case 1:\n"
+              "        j = 0;\n"
+              "        break;\n"
+              "    default:\n"
+              "        j = 1;\n"
+              "    }\n"
+              "    if (j != 0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    const char *s1 = foo();\n"
+              "    const char *s2 = bar();\n"
+              "    if (s2 == NULL)\n"
+              "        return;\n"
+              "    size_t len = s2 - s1;\n"
+              "    if (len == 0)\n"
+              "        return;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int h();\n" // #12858
+              "bool g() {\n"
+              "    bool b{};\n"
+              "    try {\n"
+              "        int x = h();\n"
+              "        switch (x) {\n"
+              "        default:\n"
+              "            b = true;\n"
+              "        }\n"
+              "    }\n"
+              "    catch (...) {\n"
+              "        b = false;\n"
+              "    }\n"
+              "    return b;\n"
+              "}\n"
+              "void f() {\n"
+              "    if (g()) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int x, int y) {\n" // #11822
+              "    if (x) {\n"
+              "        switch (y) {\n"
+              "        case 1:\n"
+              "            return 7;\n"
+              "        }\n"
+              "    }\n"
+              " \n"
+              "    if (y)\n"
+              "        return 8;\n"
+              " \n"
+              "    if (x)\n"
+              "        return 9;\n"
+              " \n"
+              "    return 0;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int g();\n" // #10561
+              "bool h();\n"
+              "int f() {\n"
+              "    bool b = false;\n"
+              "    try {\n"
+              "        switch (g()) {\n"
+              "        default:\n"
+              "            b = h();\n"
+              "        }\n"
+              "    }\n"
+              "    catch (...) {}\n"
+              "    return b ? 1 : 0;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n"
+              "    const S* get2() const {\n"
+              "        if (mS)\n"
+              "            return mS;\n"
+              "        return this;\n"
+              "    }\n"
+              "    S* mS = nullptr;\n"
+              "};\n"
+              "void f2() {\n"
+              "    const S s;\n"
+              "    const S* sp2 = s.get2();\n"
+              "    if (sp2) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:12:9]: (style) Condition 'sp2' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        check("struct S {\n"
+              "    void f(int i);\n"
+              "    bool g() const { return !m.empty(); }\n"
+              "    std::set<int> m;\n"
+              "};\n"
+              "void S::f(int i) {\n"
+              "    bool b = g();\n"
+              "    auto it = m.find(i);\n"
+              "    if (it != m.end()) {\n"
+              "        m.erase(it);\n"
+              "        if (g() != b) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #14392
+              "    bool g() const { return m; }\n"
+              "    bool m{};\n"
+              "};\n"
+              "bool f(S s) {\n"
+              "    if (s.g()) {\n"
+              "        bool b = s.g();\n"
+              "        return b;\n"
+              "    }\n"
+              "    return false;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:12] -> [test.cpp:7:21]: (style) Assigned value 's.g()' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(const void* p) {\n" // #11519
+              "    bool b = false;\n"
+              "    if (!p && !b) {}\n"
+              "    if (!b) {}\n"
+              "    (void)b;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:15]: (style) Condition '!b' is always true [knownConditionTrueFalse]\n"
+                      "[test.cpp:4:9]: (style) Condition '!b' is always true [knownConditionTrueFalse]\n",
+                      errout_str());
+
+        check("struct C {\n" // #12532
+              "    void f() const;\n"
+              "    int a, b;\n"
+              "};\n"
+              "void C::f() const {\n"
+              "    if (a)\n"
+              "        return;\n"
+              "    if (!b) {}\n"
+              "    if (a) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:9] -> [test.cpp:9:9]: (warning) Identical condition 'a', second condition is always false [identicalConditionAfterEarlyExit]\n",
+                      errout_str());
+    }
+
+    void alwaysTrueSymbolic()
+    {
+        check("void f(const uint32_t x) {\n"
+              "    uint32_t y[1];\n"
+              "    y[0]=x;\n"
+              "    if(x > 0 || y[0] < 42){}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:10] -> [test.cpp:4:22]: (style) Condition 'y[0]<42' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(int x, int y) {\n"
+              "    if(x < y && x < 42) {\n"
+              "        --x;\n"
+              "        if(x == y) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:10] -> [test.cpp:4:14]: (style) Condition 'x==y' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(bool a, bool b) {  if (a == b && a && !b){} }");
+        ASSERT_EQUALS("[test.cpp:1:41] -> [test.cpp:1:46]: (style) Condition '!b' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("bool f(bool a, bool b) { if(a && b && (!a)){} }");
+        ASSERT_EQUALS("[test.cpp:1:29] -> [test.cpp:1:40]: (style) Condition '!a' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(int x, int y) {\n"
+              "  if (x < y) {\n"
+              "    auto z = y - x;\n"
+              "    if (z < 1) {}\n"
+              "  }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:4:11]: (style) Condition 'z<1' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("bool f(int &index, const int s, const double * const array, double & x) {\n"
+              "    if (index >= s)\n"
+              "        return false;\n"
+              "    else {\n"
+              "        x = array[index];\n"
+              "        return (index++) >= s;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:15] -> [test.cpp:6:26]: (style) Return value '(index++)>=s' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("struct a {\n"
+              "  a *b() const;\n"
+              "} c;\n"
+              "void d() {\n"
+              "  a *e = nullptr;\n"
+              "  e = c.b();\n"
+              "  if (e) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int g(int i) {\n"
+              "  if (i < 256)\n"
+              "    return 1;\n"
+              "  const int N = 2 * i;\n"
+              "  i -= 256;\n"
+              "  if (i == 0)\n"
+              "    return 0;\n"
+              "  return N;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int i, int j) {\n"
+              "    if (i < j) {\n"
+              "        i++;\n"
+              "        if (i >= j)\n"
+              "            return;\n"
+              "        i++;\n"
+              "        if (i >= j) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int get_delta() {\n"
+              "    clock_t now_ms = (clock() / (CLOCKS_PER_SEC / 1000));\n"
+              "    static clock_t last_clock_ms = now_ms;\n"
+              "    clock_t delta = now_ms - last_clock_ms;\n"
+              "    last_clock_ms = now_ms;\n"
+              "    if (delta > 50)\n"
+              "        delta = 50;\n"
+              "    return delta;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10555
+        check("struct C {\n"
+              "  int GetI() const { return i; }\n"
+              "  int i{};\n"
+              "};\n"
+              "struct B {\n"
+              "    C *m_PC{};\n"
+              "    Modify();\n"
+              "};\n"
+              "struct D : B {\n"
+              "  void test();  \n"
+              "};\n"
+              "void D::test() {\n"
+              "    const int I = m_PC->GetI();\n"
+              "    Modify();\n"
+              "    if (m_PC->GetI() != I) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10624
+        check("struct Data {\n"
+              "  Base* PBase{};\n"
+              "};\n"
+              "void f(Data* BaseData) {\n"
+              "  Base* PObj = BaseData->PBase;\n"
+              "  if (PObj == nullptr)\n"
+              "    return;\n"
+              "  Derived* pD = dynamic_cast<Derived*>(PObj);\n"
+              "  if (pD) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9549
+        check("void f(const uint32_t v) {\n"
+              "    const uint32_t v16 = v >> 16;\n"
+              "    if (v16) {\n"
+              "        const uint32_t v8 = v16 >> 8;\n"
+              "        if (v8) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10649
+        check("void foo(struct diag_msg *msg) {\n"
+              "    msg = msg->next;\n"
+              "    if (msg == NULL)\n"
+              "        return CMD_OK;\n"
+              "    msg = msg->next;\n"
+              "    if (msg == NULL)\n"
+              "        return CMD_OK;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int foo(bool a, bool b) {\n"
+              "  if((!a == !b) && !a && b)\n"
+              "   return 1;\n"
+              "  return 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:20] -> [test.cpp:2:26]: (style) Condition 'b' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        // #11124
+        check("struct Basket {\n"
+              "	std::vector<int> getApples() const;\n"
+              "	std::vector<int> getBananas() const;	\n"
+              "};\n"
+              "int getFruit(const Basket & b, bool preferApples)\n"
+              "{\n"
+              "    std::vector<int> apples = b.getApples();\n"
+              "    int apple = apples.empty() ? -1 : apples.front();\n"
+              "    std::vector<int> bananas = b.getBananas();\n"
+              "    int banana = bananas.empty() ? -1 : bananas.front();\n"
+              "    int fruit = std::max(apple, banana);\n"
+              "    if (fruit == -1)\n"
+              "        return fruit;\n"
+              "    if (std::min(apple, banana) != -1)\n"
+              "        fruit = preferApples ? apple : banana;\n"
+              "    return fruit;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const std::string & s, int i) {\n"
+              "    const char c = s[i];\n"
+              "    if (!std::isalnum(c)) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #11404
+              "    int f() const;\n"
+              "    void g();\n"
+              "};\n"
+              "void h(std::vector<S*>::iterator it) {\n"
+              "    auto i = (*it)->f();\n"
+              "    (*it)->g();\n"
+              "    auto j = (*it)->f();\n"
+              "    if (i == j) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11384
+        check("bool f(const int* it, const int* end) {\n"
+              "	return (it != end) && *it++ &&\n"
+              "           (it != end) && *it;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #12116
+        check("void f(int n) {\n"
+              "    for (int i = 0; i < N; ++i) {\n"
+              "        if (i < n) {}\n"
+              "        else if (i > n) {}\n"
+              "        else {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #12681
+        check("void f(unsigned u) {\n"
+              "      if (u > 0) {\n"
+              "             u--;\n"
+              "             if (u == 0) {}\n"
+              "      }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(unsigned u) {\n"
+              "      if (u < 0xFFFFFFFF) {\n"
+              "             u++;\n"
+              "             if (u == 0xFFFFFFFF) {}\n"
+              "      }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(bool a, bool b) {\n" // #12937
+              "    bool c = !a && b;\n"
+              "    if (a) {}\n"
+              "    else {\n"
+              "        if (c) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(unsigned x) {\n" // #13522
+              "    unsigned u = x;\n"
+              "    int i = u - 0;\n"
+              "    if (i < 0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void alwaysTrueInfer() {
+        check("void f(int x) {\n"
+              "    if (x > 5) {\n"
+              "        x++;\n"
+              "        if (x == 1) {}\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:4:15]: (style) Condition 'x==1' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(int x) {\n"
+              "    if (x > 5) {\n"
+              "        x++;\n"
+              "        if (x != 1) {}\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:4:15]: (style) Condition 'x!=1' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        // #6890
+        check("void f(int i) {\n"
+              "    int x = i;\n"
+              "    if (x >= 1) {}\n"
+              "    else {\n"
+              "        x = 8 - x;\n"
+              "        if (x == -1) {}\n"
+              "        else {}\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:6:15]: (style) Condition 'x==-1' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(int i) {\n"
+              "    int x = i;\n"
+              "    if (x >= 1) {}\n"
+              "    else {\n"
+              "        x = 8 - x;\n"
+              "        if (x != -1) {}\n"
+              "        else {}\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:6:15]: (style) Condition 'x!=-1' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(int i) {\n"
+              "    int x = i;\n"
+              "    if (x >= 1) {}\n"
+              "    else {\n"
+              "        x = 8 - x;\n"
+              "        if (x >= -1) {}\n"
+              "        else {}\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:6:15]: (style) Condition 'x>=-1' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(int i) {\n"
+              "    int x = i;\n"
+              "    if (x >= 1) {}\n"
+              "    else {\n"
+              "        x = 8 - x;\n"
+              "        if (x > -1) {}\n"
+              "        else {}\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:6:15]: (style) Condition 'x>-1' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(int i) {\n"
+              "    int x = i;\n"
+              "    if (x >= 1) {}\n"
+              "    else {\n"
+              "        x = 8 - x;\n"
+              "        if (x < -1) {}\n"
+              "        else {}\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:6:15]: (style) Condition 'x<-1' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(int i) {\n"
+              "    int x = i;\n"
+              "    if (x >= 1) {}\n"
+              "    else {\n"
+              "        x = 8 - x;\n"
+              "        if (x <= -1) {}\n"
+              "        else {}\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:6:15]: (style) Condition 'x<=-1' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(int i) {\n"
+              "    int x = i;\n"
+              "    if (x >= 1) {}\n"
+              "    else {\n"
+              "        x = 8 - x;\n"
+              "        if (x > 7) {}\n"
+              "        else {}\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:6:15]: (style) Condition 'x>7' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(int i) {\n"
+              "    int x = i;\n"
+              "    if (x >= 1) {}\n"
+              "    else {\n"
+              "        x = 8 - x;\n"
+              "        if (x > 9) {}\n"
+              "        else {}\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int i) {\n"
+              "    int x = i;\n"
+              "    if (x >= 1) {}\n"
+              "    else {\n"
+              "        x = 8 - x;\n"
+              "        if (x > 10) {}\n"
+              "        else {}\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11100
+        check("struct T {\n"
+              "  bool m{};\n"
+              "  void f(bool b);\n"
+              "  bool get() const { return m; }\n"
+              "  void set(bool v) { m = v; }\n"
+              "};\n"
+              "void T::f(bool b) {\n"
+              "	bool tmp = get();\n"
+              "	set(b);\n"
+              "	if (tmp != get()) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9541
+        check("int f(int pos, int a) {\n"
+              "    if (pos <= 0)\n"
+              "        pos = 0;\n"
+              "    else if (pos < a)\n"
+              "        if(pos > 0)\n"
+              "            --pos;\n"
+              "    return pos;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:13] -> [test.cpp:5:16]: (style) Condition 'pos>0' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        // #9721
+        check("void f(int x) {\n"
+              "    if (x > 127) {\n"
+              "        if ( (x>255) || (-128>x) )\n"
+              "            return;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:30]: (style) Condition '-128>x' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        // #8778
+        check("void f() {\n"
+              "    for(int i = 0; i < 19; ++i)\n"
+              "        if(i<=18) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:13]: (style) Condition 'i<=18' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        // #8209
+        check("void f() {\n"
+              "    for(int x = 0; x < 3; ++x)\n"
+              "        if(x == -5) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:14]: (style) Condition 'x==-5' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        // #8407
+        check("int f(void) {\n"
+              "    for(int i = 0; i <1; ++i)\n"
+              "        if(i == 0) return 1; \n" // <<
+              "        else return 0;\n"
+              "    return -1;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:14]: (style) Condition 'i==0' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(unsigned int u1, unsigned int u2) {\n"
+              "    if (u1 <= 10 && u2 >= 20) {\n"
+              "        if (u1 != u2) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:12] -> [test.cpp:3:16]: (style) Condition 'u1!=u2' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        // #10544
+        check("void f(int N) {\n"
+              "    if (N > 0) {\n"
+              "        while (N)\n"
+              "            N = test();\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11098
+        check("void f(unsigned int x) { if (x == -1u) {} }\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool f(const int *p, const int *q) {\n"
+              "    return p != NULL && q != NULL && p == NULL;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:40]: (style) Return value 'p==NULL' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("struct S {\n" // #11789
+              "    std::vector<int> v;\n"
+              "    void f(int i) const;\n"
+              "};\n"
+              "void S::f(int i) const {\n"
+              "    int j = i - v.size();\n"
+              "    if (j >= 0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int i) {\n" // #12039
+              "    if ((128 + i < 255 ? 128 + i : 255) > 0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #12727
+              "    bool f() const {\n"
+              "        return g() > 0;\n"
+              "    }\n"
+              "    std::size_t g() const {\n"
+              "        return 5 - h();\n"
+              "    }\n"
+              "    std::size_t h() const {\n"
+              "        if (x > 7)\n"
+              "            return 5;\n"
+              "        return (5 + x) % 5;\n"
+              "    }\n"
+              "    std::size_t x;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void alwaysTrueContainer() {
+        // #9329
+        check("void c1(std::vector<double>&);\n"
+              "void c2(std::vector<double>&);\n"
+              "void foo(int flag) {\n"
+              "    std::vector<double> g;\n"
+              "    if (flag)\n"
+              "        c1(g );\n"
+              "    else\n"
+              "        c2(g );\n"
+              "    if ( !g.empty() )\n"
+              "        return;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo(int flag) {\n"
+              "    std::vector<double> g;\n"
+              "    if (flag)\n"
+              "        c1(g );\n"
+              "    else\n"
+              "        c2(g );\n"
+              "    if ( !g.empty() )\n"
+              "        return;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "    std::vector<int> v;\n"
+              "    void g();\n"
+              "    void f(bool b) {\n"
+              "        v.clear();\n"
+              "        g();\n"
+              "        return !v.empty();\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10409
+        check("void foo(const std::string& s) {\n"
+              "    if( s.size() < 2 ) return;\n"
+              "    if( s == \"ab\" ) return;\n"
+              "    if( s.size() < 3 ) return;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo(const std::string& s) {\n"
+              "    if( s.size() < 2 ) return;\n"
+              "    if( s != \"ab\" )\n"
+              "        if( s.size() < 3 ) return;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10226
+        check("int f(std::vector<int>::iterator it, const std::vector<int>& vector) {\n"
+              "    if (!(it != vector.end() && it != vector.begin()))\n"
+              "        throw 0;\n"
+              "    if (it != vector.end() && *it == 0)\n"
+              "        return -1;\n"
+              "    return *it;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:12]: (style) Condition 'it!=vector.end()' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        // #11303
+        check("void f(int n) {\n"
+              "    std::vector<char> buffer(n);\n"
+              "    if(buffer.back() == 0 ||\n"
+              "       buffer.back() == '\\n' ||\n"
+              "       buffer.back() == '\\0') {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:22]: (style) Condition 'buffer.back()=='\\0'' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        // #9353
+        check("struct X { std::string s; };\n"
+              "void f(const std::vector<X>&v) {\n"
+              "    for (std::vector<X>::const_iterator it = v.begin(); it != v.end(); ++it)\n"
+              "        if (!it->s.empty()) {\n"
+              "            if (!it->s.empty()) {}\n"
+              "        }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:13] -> [test.cpp:5:17]: (style) Condition '!it->s.empty()' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        check("struct X { std::string s; };\n"
+              "void f(const std::vector<struct X>&v) {\n"
+              "    for (std::vector<struct X>::const_iterator it = v.begin(); it != v.end(); ++it)\n"
+              "        if (!it->s.empty()) {\n"
+              "            if (!it->s.empty()) {}\n"
+              "        }\n"
+              "}\n");
+        TODO_ASSERT_EQUALS("[test.cpp:4:13] -> [test.cpp:5:17]: (style) Condition '!it->s.empty()' is always true [knownConditionTrueFalse]\n", "", errout_str());
+
+        // #10508
+        check("bool f(const std::string& a, const std::string& b) {\n"
+              "    return a.empty() || (b.empty() && a.empty());\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:19] -> [test.cpp:2:46]: (style) Return value 'a.empty()' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("struct A {\n"
+              "    struct iterator;\n"
+              "    iterator begin() const;\n"
+              "    iterator end() const;\n"
+              "};\n"
+              "A g();\n"
+              "void f(bool b) {\n"
+              "    std::set<int> s;\n"
+              "    auto v = g();\n"
+              "    s.insert(v.begin(), v.end());\n"
+              "    if(!b && s.size() != 1)\n"
+              "        return;\n"
+              "    if(!s.empty()) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(std::string s) {\n"
+              "    if (s.empty())\n"
+              "        return -1;\n"
+              "    s += '\\n';\n"
+              "    if (s.empty())\n"
+              "        return -1;\n"
+              "    return -1;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:16]: (style) Condition 's.empty()' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(std::string& p) {\n"
+              "    const std::string d{ \"abc\" };\n"
+              "    p += d;\n"
+              "    if(p.empty()) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:15]: (style) Condition 'p.empty()' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("bool f(int i, FILE* fp) {\n"
+              "  std::string s = \"abc\";\n"
+              "  s += std::to_string(i);\n"
+              "  s += \"\\n\";\n"
+              "  return fwrite(s.c_str(), 1, s.length(), fp) == s.length();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const std::string& s) {\n" // #9148
+              "    if (s.empty() || s.size() < 1) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:16] -> [test.cpp:2:31]: (style) Condition 's.size()<1' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("void bar(std::vector<int>& vv) {\n" // #11464
+              "    class F {\n"
+              "    public:\n"
+              "        F(int, std::vector<int>& lv) : mV(lv) {\n"
+              "            mV.push_back(0);\n"
+              "        }\n"
+              "    private:\n"
+              "        std::vector<int>& mV;\n"
+              "    } fi(1, vv);\n"
+              "}\n"
+              "void g() {\n"
+              "    std::vector<int> v;\n"
+              "    bar(v);\n"
+              "    if (v.empty()) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct F {\n"
+              "    F(int, std::vector<int>&lv) : mV(lv) {\n"
+              "        mV.push_back(0);\n"
+              "    }\n"
+              "    std::vector<int>& mV;\n"
+              "};\n"
+              "void g(std::vector<int>& vv) {\n"
+              "    F(1, vv);\n"
+              "}\n"
+              "void f() {\n"
+              "    std::vector<int> v;\n"
+              "    g(v);\n"
+              "    if (v.empty()) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void alwaysTrueLoop()
+    {
+        check("long foo() {\n"
+              "  bool bUpdated = false;\n"
+              "  long Ret{};\n"
+              "  do {\n"
+              "    Ret = bar();\n"
+              "    if (Ret == 0) {\n"
+              "      if (bUpdated)\n"
+              "        return 1;\n"
+              "      bUpdated = true;\n"
+              "    }\n"
+              "    else\n"
+              "      bUpdated = false;\n"
+              "  }\n"
+              "  while (bUpdated);\n"
+              "  return Ret;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool foo() {\n"
+              "  bool bFirst = true;\n"
+              "  do {\n"
+              "    if (bFirst)\n"
+              "      bar();\n"
+              "    if (baz())\n"
+              "      break;       \n"
+              "    bFirst = false;\n"
+              "  } while (true);\n"
+              "  return bFirst;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "   void * pool = NULL;\n"
+              "   do {\n"
+              "      pool = malloc(40);\n"
+              "      if (dostuff())\n"
+              "         break;\n"
+              "      pool = NULL;\n"
+              "   }\n"
+              "   while (0);\n"
+              "   if (pool) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #8499
+        check("void f(void)\n"
+              "{\n"
+              "    for (int i = 0; i < 2; ++i)\n"
+              "    {\n"
+              "        for (int j = 0; j < 8; ++j)\n"
+              "        {\n"
+              "            if ( (i==0|| i==1)\n" // << always true
+              "              && (j==0) )\n"
+              "            {;}\n"
+              "        }\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:7:20] -> [test.cpp:7:27]: (style) Condition 'i==1' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        // #10863
+        check("void f(const int A[], int Len) {\n"
+              "  if (Len <= 0)\n"
+              "    return;\n"
+              "  int I = 0;\n"
+              "  while (I < Len) {\n"
+              "    int K = I + 1;\n"
+              "    for (; K < Len; K++) {\n"
+              "      if (A[I] != A[K])\n"
+              "        break;\n"
+              "    } \n"
+              "    I = K;   \n"
+              "  }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n" // #11434
+              "    const int N = 5;\n"
+              "    bool a[N];\n"
+              "    for (int i = 0; i < N; a[i++] = false);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n" // #8192
+              "    for (int i = 0; i > 10; ++i) {}\n"
+              "}\n");
+        TODO_ASSERT_EQUALS("[test.cpp:2]: (style) Condition 'i>10' is always false\n", "", errout_str());
+
+        check("void f() {\n"
+              "    for (int i = 1000; i < 20; ++i) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:26]: (style) Condition 'i<20' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("int foo(int foo, int bar, bool baz, bool flag) {\n"
+              "    if (baz && flag) {\n"
+              "        do {\n"
+              "            if (bar==42)\n"
+              "                return 0;\n"
+              "        } while (flag);\n"
+              "    }\n"
+              "    return foo;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:16] -> [test.cpp:6:18]: (style) Condition 'flag' is always true [knownConditionTrueFalse]\n", errout_str());
+    }
+
+    void alwaysTrueTryCatch()
+    {
+        check("void g();\n"
+              "void f(int x)\n"
+              "{\n"
+              "    if( x ) {\n"
+              "        try {\n"
+              "            g();\n"
+              "        }\n"
+              "        catch(...) {\n"
+              "            return;\n"
+              "        }\n"
+              "    }\n"
+              "    g();\n"
+              "    if( x ) {\n"
+              "        g();\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void g();\n"
+              "void h();\n"
+              "void f(int x) {\n"
+              "    if( x ) {\n"
+              "        try {\n"
+              "            g();\n"
+              "            return;\n"
+              "        }\n"
+              "        catch( ... ) {}\n"
+              "    }\n"
+              "    h();\n"
+              "    if( x ) {\n"
+              "        g();\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n" // #10701
+              "    std::string s;\n"
+              "    try {\n"
+              "        try {\n"
+              "            s = g();\n"
+              "        }\n"
+              "        catch (const Err& err) {}\n"
+              "    }\n"
+              "    catch (const std::exception& e) {}\n"
+              "    if (s != \"abc\") {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void alwaysTrueSideEffect() {
+        check("bool check(const char* const);\n" // #14416
+              "void create(const char*);\n"
+              "void f(const char* n) {\n"
+              "    if (!check(n)) {\n"
+              "        create(n);\n"
+              "        if (check(n)) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void alwaysTruePremiumMisra() {
+        const char code[] = "void f() {\n"
+                            "  if (3 > 2) {}\n"
+                            "}";
+
+        check(code);
+        ASSERT_EQUALS("", errout_str());
+
+        Settings misraSettings;
+        misraSettings.premiumArgs = "--misra-c-2012";
+        check(code, misraSettings);
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Condition '3>2' is always true [knownConditionTrueFalse]\n", errout_str());
+    }
+
+    void multiConditionAlwaysTrue() {
+        check("void f() {\n"
+              "  int val = 0;\n"
+              "  if (val < 0) continue;\n"
+              "  if (val > 0) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "  int val = 0;\n"
+              "  if (val < 0) {\n"
+              "    if (val > 0) {}\n"
+              "  }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "  int val = 0;\n"
+              "  if (val < 0) {\n"
+              "    if (val < 0) {}\n"
+              "  }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "  int activate = 0;\n"
+              "  int foo = 0;\n"
+              "  if (activate) {}\n"
+              "  else if (foo) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:7]: (style) Condition 'activate' is always false [knownConditionTrueFalse]\n"
+                      "[test.cpp:5:12]: (style) Condition 'foo' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        // #6904
+        check("void f() {\n"
+              "  const int b[2] = { 1,0 };\n"
+              "  if(b[1] == 2) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Condition 'b[1]==2' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        // #9878
+        check("void f(bool a, bool b) {\n"
+              "    if (a && b){;}\n"
+              "    else if (!a && b){;}\n"
+              "    else if (!a && !b){;}\n"
+              "    else {;}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void duplicateCondition() {
+        check("void f(bool x) {\n"
+              "    if(x) {}\n"
+              "    if(x) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:8] -> [test.cpp:3:8]: (style) The if condition is the same as the previous if condition [duplicateCondition]\n",
+                      errout_str());
+
+        check("void f(int x) {\n"
+              "    if(x == 1) {}\n"
+              "    if(x == 1) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:10] -> [test.cpp:3:10]: (style) The if condition is the same as the previous if condition [duplicateCondition]\n",
+                      errout_str());
+
+        check("void f(int x) {\n"
+              "    if(x == 1) {}\n"
+              "    if(x == 2) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int x) {\n"
+              "    if(x == 1) {}\n"
+              "    if(x != 1) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(bool x) {\n"
+              "    if(x) {}\n"
+              "    g();\n"
+              "    if(x) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int x) {\n"
+              "    if(x == 1) { x++; }\n"
+              "    if(x == 1) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #8996
+        check("void g(int** v);\n"
               "void f() {\n"
               "  int a = 0;\n"
               "  int b = 0;\n"
@@ -3440,8 +5770,8 @@ class TestCondition : public TestFixture {
               "  g(d);\n"
               "  if (a) {}\n"
               "  if (b) {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // #9311
         check("struct c {\n"
@@ -3455,48 +5785,273 @@ class TestCondition : public TestFixture {
               "  g(d);\n"
               "  if (a) {}\n"
               "  if (b) {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // #8993
         check("void f(const std::string& x) {\n"
               "  auto y = x;\n"
               "  if (x.empty()) y = \"1\";\n"
               "  if (y.empty()) return;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9106
+        check("struct A {int b;};\n"
+              "void f(A a, int c) {\n"
+              "    if (a.b) a.b = c;\n"
+              "    if (a.b) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "    int a;\n"
+              "    void b() const {\n"
+              "        return a == 1;\n"
+              "    }\n"
+              "    void c();\n"
+              "    void d() {\n"
+              "        if(b()) {\n"
+              "            c();\n"
+              "        }\n"
+              "        if (b()) {\n"
+              "            a = 3;\n"
+              "        }\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "    int a;\n"
+              "    void b() const {\n"
+              "        return a == 1;\n"
+              "    }\n"
+              "    void d() {\n"
+              "        if(b()) {\n"
+              "            a = 2;\n"
+              "        }\n"
+              "        if (b()) {\n"
+              "            a = 3;\n"
+              "        }\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "    int a;\n"
+              "    void b() const {\n"
+              "        return a == 1;\n"
+              "    }\n"
+              "    void d() {\n"
+              "        if(b()) {\n"
+              "        }\n"
+              "        if (b()) {\n"
+              "            a = 3;\n"
+              "        }\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:7:13] -> [test.cpp:9:14]: (style) The if condition is the same as the previous if condition [duplicateCondition]\n",
+                      errout_str());
+
+        check("void f(bool a, bool b) {\n"
+              "    auto g = [&] { b = !a; };\n"
+              "    if (b)\n"
+              "        g();\n"
+              "    if (b) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void g(bool& a);\n"
+              "void f(bool b) {\n"
+              "    auto h = std::bind(&g, std::ref(b));\n"
+              "    if (b)\n"
+              "        h();\n"
+              "    if (b) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int *i) {\n"
+              "  if (*i == 0) {\n"
+              "    *i = 1;\n"
+              "  }\n"
+              "  if (*i == 0) {\n"
+              "  }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void g(std::function<void()>);\n"
+              "void f(std::vector<int> v) {\n"
+              "    auto x = [&v] { v.push_back(1); };\n"
+              "    if(v.empty()) {\n"
+              "        g(x);\n"
+              "    }\n"
+              "    if(v.empty())\n"
+              "        return;\n"
+              "    return;\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { int i; };\n"
+              "int f(const S& s) {\n"
+              "    int a = 0, b = 0;\n"
+              "    if (s.i == 0)\n"
+              "        a = 1;\n"
+              "    if (s.i == 0)\n"
+              "        b = 1;\n"
+              "    return a + b;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:13] -> [test.cpp:6:13]: (style) The if condition is the same as the previous if condition [duplicateCondition]\n", errout_str());
+
+        check("void f(double d) {\n" // #12712
+              "    if (std::isfinite(d)) {}\n"
+              "    if (std::isfinite(d)) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:22] -> [test.cpp:3:22]: (style) The if condition is the same as the previous if condition [duplicateCondition]\n", errout_str());
+
+        check("struct S { int x; };\n" // #12391
+              "int f(const struct S* a, const struct S* b) {\n"
+              "    const struct S* p = b;\n"
+              "    if (a->x < p->x) p++;\n"
+              "    if (a->x < p->x) p++;\n"
+              "    return p->x;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // do not crash
+        check("void assign(const MMA& other) {\n"
+              "    if (mPA.cols != other.mPA.cols || mPA.rows != other.mPA.rows)\n"
+              "        ;\n"
+              "    if (other.mPA.cols > 0 && other.mPA.rows > 0)\n"
+              "        ;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo() {\n" // #11202
+              "    float f = 0x1.4p+3;\n"
+              "    if (f > 10.0) {}\n"
+              "    if (f < 10.0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(char* s, const char* p) {\n" // #14070
+              "    strcpy(s, p);\n"
+              "}\n"
+              "void g() {\n"
+              "    char s1[10] = \"\";\n"
+              "    char s2[10] = \"\";\n"
+              "    f(s1, \"123\");\n"
+              "    f(s2, \"1234\");\n"
+              "    if (strlen(s1) > 0) {}\n"
+              "    if (strlen(s2) > 0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void g(int*);\n" // #14428
+              "int f(int* const p) {\n"
+              "    int i = 0;\n"
+              "    if (*p == 0)\n"
+              "        g(p);\n"
+              "    if (*p == 0)\n"
+              "        i = 1;\n"
+              "    return i;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void g(const int*);\n"
+              "int f(const int* const p) {\n"
+              "    int i = 0;\n"
+              "    if (*p == 0)\n"
+              "        g(p);\n"
+              "    if (*p == 0)\n"
+              "        i = 1;\n"
+              "    return i;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:12] -> [test.cpp:6:12]: (style) The if condition is the same as the previous if condition [duplicateCondition]\n", errout_str());
     }
 
     void checkInvalidTestForOverflow() {
         check("void f(char *p, unsigned int x) {\n"
               "    assert((p + x) < p);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Invalid test for overflow '(p+x)<p'. Condition is always false unless there is overflow, and overflow is undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:20]: (warning) Invalid test for overflow '(p+x)<p'; pointer overflow is undefined behavior. Some mainstream compilers remove such overflow tests when optimising the code and assume it's always false. [invalidTestForOverflow]\n", errout_str());
 
         check("void f(char *p, unsigned int x) {\n"
               "    assert((p + x) >= p);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Invalid test for overflow '(p+x)>=p'. Condition is always true unless there is overflow, and overflow is undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:20]: (warning) Invalid test for overflow '(p+x)>=p'; pointer overflow is undefined behavior. Some mainstream compilers remove such overflow tests when optimising the code and assume it's always true. [invalidTestForOverflow]\n", errout_str());
 
         check("void f(char *p, unsigned int x) {\n"
               "    assert(p > (p + x));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Invalid test for overflow 'p>(p+x)'. Condition is always false unless there is overflow, and overflow is undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (warning) Invalid test for overflow 'p>(p+x)'; pointer overflow is undefined behavior. Some mainstream compilers remove such overflow tests when optimising the code and assume it's always false. [invalidTestForOverflow]\n", errout_str());
 
         check("void f(char *p, unsigned int x) {\n"
               "    assert(p <= (p + x));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Invalid test for overflow 'p<=(p+x)'. Condition is always true unless there is overflow, and overflow is undefined behaviour.\n", errout.str());
-
-        check("void f(signed int x) {\n"
-              "    assert(x + 100 < x);\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Invalid test for overflow 'x+100<x'. Condition is always false unless there is overflow, and overflow is undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (warning) Invalid test for overflow 'p<=(p+x)'; pointer overflow is undefined behavior. Some mainstream compilers remove such overflow tests when optimising the code and assume it's always true. [invalidTestForOverflow]\n", errout_str());
 
         check("void f(signed int x) {\n" // unsigned overflow => don't warn
               "    assert(x + 100U < x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+
+        // x + c < x
+
+#define MSG(EXPR, RESULT)   "[test.cpp:1:30]: (warning) Invalid test for overflow '" EXPR "'; signed integer overflow is undefined behavior. Some mainstream compilers remove such overflow tests when optimising the code and assume it's always " RESULT ". [invalidTestForOverflow]\n"
+
+        check("int f(int x) { return x + 10 > x; }");
+        ASSERT_EQUALS(MSG("x+10>x", "true"), errout_str());
+
+        check("int f(int x) { return x + 10 >= x; }");
+        ASSERT_EQUALS(MSG("x+10>=x", "true"), errout_str());
+
+        check("int f(int x) { return x + 10 < x; }");
+        ASSERT_EQUALS(MSG("x+10<x", "false"), errout_str());
+
+        check("int f(int x) { return x + 10 <= x; }");
+        ASSERT_EQUALS(MSG("x+10<=x", "false"), errout_str());
+
+        check("int f(int x) { return x - 10 > x; }");
+        ASSERT_EQUALS(MSG("x-10>x", "false"), errout_str());
+
+        check("int f(int x) { return x - 10 >= x; }");
+        ASSERT_EQUALS(MSG("x-10>=x", "false"), errout_str());
+
+        check("int f(int x) { return x - 10 < x; }");
+        ASSERT_EQUALS(MSG("x-10<x", "true"), errout_str());
+
+        check("int f(int x) { return x - 10 <= x; }");
+        ASSERT_EQUALS(MSG("x-10<=x", "true"), errout_str());
+
+        // x + y < x
+#undef MSG
+#define MSG(EXPR, RESULT)   "[test.cpp:1:36]: (warning) Invalid test for overflow '" EXPR "'; signed integer overflow is undefined behavior. Some mainstream compilers removes handling of overflows when optimising the code and change the code to '" RESULT "'. [invalidTestForOverflow]\n"
+
+        check("int f(int x, int y) { return x + y < x; }");
+        ASSERT_EQUALS(MSG("x+y<x", "y<0"), errout_str());
+
+        check("int f(int x, int y) { return x + y <= x; }");
+        ASSERT_EQUALS(MSG("x+y<=x", "y<=0"), errout_str());
+
+        check("int f(int x, int y) { return x + y > x; }");
+        ASSERT_EQUALS(MSG("x+y>x", "y>0"), errout_str());
+
+        check("int f(int x, int y) { return x + y >= x; }");
+        ASSERT_EQUALS(MSG("x+y>=x", "y>=0"), errout_str());
+
+        // x - y < x
+        check("int f(int x, int y) { return x - y < x; }");
+        ASSERT_EQUALS(MSG("x-y<x", "y>0"), errout_str());
+
+        check("int f(int x, int y) { return x - y <= x; }");
+        ASSERT_EQUALS(MSG("x-y<=x", "y>=0"), errout_str());
+
+        check("int f(int x, int y) { return x - y > x; }");
+        ASSERT_EQUALS(MSG("x-y>x", "y<0"), errout_str());
+
+        check("int f(int x, int y) { return x - y >= x; }");
+        ASSERT_EQUALS(MSG("x-y>=x", "y<=0"), errout_str());
     }
 
     void checkConditionIsAlwaysTrueOrFalseInsideIfWhile() {
@@ -3505,62 +6060,75 @@ class TestCondition : public TestFixture {
               "    const unsigned g_flags = B|C;\n"
               "    if(g_flags & A) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Condition 'g_flags&A' is always false\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:16]: (style) Condition 'g_flags&A' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "    int a = 5;"
               "    if(a) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Condition 'a' is always true\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:22]: (style) Condition 'a' is always true [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "    int a = 5;"
               "    while(a + 1) { a--; }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int a = 5;"
               "    while(a + 1) { return; }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Condition 'a+1' is always true\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:27]: (style) Condition 'a+1' is always true [knownConditionTrueFalse]\n", errout_str());
     }
 
     void alwaysTrueFalseInLogicalOperators() {
         check("bool f();\n"
-              "void foo() { bool x = true; if(x||f()) {}}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Condition 'x' is always true\n", errout.str());
+              "void foo() { bool x = true; if(x||f()) {}}");
+        ASSERT_EQUALS("[test.cpp:2:32]: (style) Condition 'x' is always true [knownConditionTrueFalse]\n", errout_str());
 
-        check("void foo(bool b) { bool x = true; if(x||b) {}}\n");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Condition 'x' is always true\n", errout.str());
+        check("void foo(bool b) { bool x = true; if(x||b) {}}");
+        ASSERT_EQUALS("[test.cpp:1:38]: (style) Condition 'x' is always true [knownConditionTrueFalse]\n", errout_str());
 
-        check("void foo(bool b) { if(true||b) {}}\n");
-        ASSERT_EQUALS("", errout.str());
+        check("void foo(bool b) { if(true||b) {}}");
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f();\n"
-              "void foo() { bool x = false; if(x||f()) {}}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Condition 'x' is always false\n", errout.str());
+              "void foo() { bool x = false; if(x||f()) {}}");
+        ASSERT_EQUALS("[test.cpp:2:33]: (style) Condition 'x' is always false [knownConditionTrueFalse]\n", errout_str());
 
         check("bool f();\n"
-              "void foo() { bool x = false; if(x&&f()) {}}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Condition 'x' is always false\n", errout.str());
+              "void foo() { bool x = false; if(x&&f()) {}}");
+        ASSERT_EQUALS("[test.cpp:2:33]: (style) Condition 'x' is always false [knownConditionTrueFalse]\n", errout_str());
 
-        check("void foo(bool b) { bool x = false; if(x&&b) {}}\n");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Condition 'x' is always false\n", errout.str());
+        check("void foo(bool b) { bool x = false; if(x&&b) {}}");
+        ASSERT_EQUALS("[test.cpp:1:39]: (style) Condition 'x' is always false [knownConditionTrueFalse]\n", errout_str());
 
-        check("void foo(bool b) { if(false&&b) {}}\n");
-        ASSERT_EQUALS("", errout.str());
+        check("void foo(bool b) { if(false&&b) {}}");
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f();\n"
-              "void foo() { bool x = true; if(x&&f()) {}}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Condition 'x' is always true\n", errout.str());
+              "void foo() { bool x = true; if(x&&f()) {}}");
+        ASSERT_EQUALS("[test.cpp:2:32]: (style) Condition 'x' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        // #9578
+        check("bool f(const std::string &s) {\n"
+              "        return s.size()>2U && s[0]=='4' && s[0]=='2';\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:35] -> [test.cpp:2:48]: (style) Return value 's[0]=='2'' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(int i) { if (i == 1 || 2) {} }\n"); // #12487
+        ASSERT_EQUALS("[test.cpp:1:28]: (style) Condition 'i==1||2' is always true [knownConditionTrueFalse]\n", errout_str());
+
+        check("enum E { E1 = 1, E2 = 2 };\n"
+              "void f(int i) { if (i == E1 || E2) {} }\n");
+        ASSERT_EQUALS("[test.cpp:2:29]: (style) Condition 'i==E1||E2' is always true [knownConditionTrueFalse]\n", errout_str());
     }
 
     void pointerAdditionResultNotNull() {
         check("void f(char *ptr) {\n"
               "  if (ptr + 1 != 0);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison is wrong. Result of 'ptr+1' can't be 0 unless there is pointer overflow, and pointer overflow is undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Comparison is wrong. Result of 'ptr+1' can't be 0 unless there is pointer overflow, and pointer overflow is undefined behaviour. [pointerAdditionResultNotNull]\n", errout_str());
     }
 
     void duplicateConditionalAssign() {
@@ -3569,42 +6137,42 @@ class TestCondition : public TestFixture {
         check("void f(int& x, int y) {\n"
               "    if (x == y)\n"
               "        x = y;\n"
-              "}\n");
-        ASSERT_EQUALS("test.cpp:3:style:Assignment 'x=y' is redundant with condition 'x==y'.\n"
-                      "test.cpp:2:note:Condition 'x==y'\n"
-                      "test.cpp:3:note:Assignment 'x=y' is redundant\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:11]: style: Assignment 'x=y' is redundant with condition 'x==y'. [duplicateConditionalAssign]\n"
+                      "[test.cpp:2:11]: note: Condition 'x==y'\n"
+                      "[test.cpp:3:11]: note: Assignment 'x=y' is redundant\n", errout_str());
 
         check("void f(int& x, int y) {\n"
               "    if (x != y)\n"
               "        x = y;\n"
-              "}\n");
-        ASSERT_EQUALS("test.cpp:2:style:The statement 'if (x!=y) x=y' is logically equivalent to 'x=y'.\n"
-                      "test.cpp:3:note:Assignment 'x=y'\n"
-                      "test.cpp:2:note:Condition 'x!=y' is redundant\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:11]: style: The statement 'if (x!=y) x=y' is logically equivalent to 'x=y'. [duplicateConditionalAssign]\n"
+                      "[test.cpp:3:11]: note: Assignment 'x=y'\n"
+                      "[test.cpp:2:11]: note: Condition 'x!=y' is redundant\n", errout_str());
 
         check("void f(int& x, int y) {\n"
               "    if (x == y)\n"
               "        x = y;\n"
               "    else\n"
               "        x = 1;\n"
-              "}\n");
-        ASSERT_EQUALS("test.cpp:3:style:Assignment 'x=y' is redundant with condition 'x==y'.\n"
-                      "test.cpp:2:note:Condition 'x==y'\n"
-                      "test.cpp:3:note:Assignment 'x=y' is redundant\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:11]: style: Assignment 'x=y' is redundant with condition 'x==y'. [duplicateConditionalAssign]\n"
+                      "[test.cpp:2:11]: note: Condition 'x==y'\n"
+                      "[test.cpp:3:11]: note: Assignment 'x=y' is redundant\n", errout_str());
 
         check("void f(int& x, int y) {\n"
               "    if (x != y)\n"
               "        x = y;\n"
               "    else\n"
               "        x = 1;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int& x, int y) {\n"
               "    if (x == y)\n"
               "        x = y + 1;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void g();\n"
               "void f(int& x, int y) {\n"
@@ -3612,8 +6180,432 @@ class TestCondition : public TestFixture {
               "        x = y;\n"
               "        g();\n"
               "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool f(bool b) {\n"
+              "    if (b)\n"
+              "        b = false;\n"
+              "    else\n"
+              "        g();\n"
+              "    return b;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int& i) {\n"
+              "    if (!i)\n"
+              "        i = 1; \n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #9406
+              "    S() : b(false) {}\n"
+              "    void f() {\n"
+              "        if (b) b = true;\n"
+              "        if (b) b = false;\n"
+              "        if (!b) b = true;\n"
+              "        if (!b) b = false;\n"
+              "    }\n"
+              "    bool b;\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:4:13]: style: The statement 'if (b) b=true' is redundant. [duplicateConditionalAssign]\n"
+                      "[test.cpp:4:18]: note: Assignment 'b=true'\n"
+                      "[test.cpp:4:13]: note: Condition 'b' is redundant\n"
+                      "[test.cpp:5:13]: style: The statement 'if (b) b=false' is logically equivalent to 'b=false'. [duplicateConditionalAssign]\n"
+                      "[test.cpp:5:18]: note: Assignment 'b=false'\n"
+                      "[test.cpp:5:13]: note: Condition 'b' is redundant\n"
+                      "[test.cpp:6:13]: style: The statement 'if (!b) b=true' is logically equivalent to 'b=true'. [duplicateConditionalAssign]\n"
+                      "[test.cpp:6:19]: note: Assignment 'b=true'\n"
+                      "[test.cpp:6:13]: note: Condition '!b' is redundant\n"
+                      "[test.cpp:7:13]: style: The statement 'if (!b) b=false' is redundant. [duplicateConditionalAssign]\n"
+                      "[test.cpp:7:19]: note: Assignment 'b=false'\n"
+                      "[test.cpp:7:13]: note: Condition '!b' is redundant\n",
+                      errout_str());
+    }
+
+    void checkAssignmentInCondition() {
+        check("void f(std::string s) {\n"
+              "    if (s=\"123\"){}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:10]: (style) Suspicious assignment in condition. Condition 's=\"123\"' is always true. [assignmentInCondition]\n", errout_str());
+
+        check("void f(std::string *p) {\n"
+              "    if (p=foo()){}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(uint32_t u) {\n" // #2490
+              "    if ((u = 0x00000000) || (u = 0xffffffff)) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:12]: (style) Condition 'u=0x00000000' is always false [knownConditionTrueFalse]\n"
+                      "[test.cpp:2:32]: (style) Condition 'u=0xffffffff' is always true [knownConditionTrueFalse]\n",
+                      errout_str());
+    }
+
+    void compareOutOfTypeRange() {
+        const Settings settingsUnix64 = settingsBuilder().severity(Severity::style).platform(Platform::Type::Unix64).build();
+
+        check("void f(unsigned char c) {\n"
+              "  if (c == 256) {}\n"
+              "}", settingsUnix64);
+        ASSERT_EQUALS("[test.cpp:2:12]: (style) Comparing expression of type 'unsigned char' against value 256. Condition is always false. [compareValueOutOfTypeRangeError]\n", errout_str());
+
+        check("void f(unsigned char* b, int i) {\n" // #6372
+              "  if (b[i] == 256) {}\n"
+              "}", settingsUnix64);
+        ASSERT_EQUALS("[test.cpp:2:15]: (style) Comparing expression of type 'unsigned char' against value 256. Condition is always false. [compareValueOutOfTypeRangeError]\n", errout_str());
+
+        check("void f(unsigned char c) {\n"
+              "  if (c == 255) {}\n"
+              "}", settingsUnix64);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(bool b) {\n"
+              "  if (b == true) {}\n"
+              "}", settingsUnix64);
+        ASSERT_EQUALS("", errout_str());
+
+        // #10372
+        check("void f(signed char x) {\n"
+              "  if (x == 0xff) {}\n"
+              "}", settingsUnix64);
+        ASSERT_EQUALS("[test.cpp:2:12]: (style) Comparing expression of type 'signed char' against value 255. Condition is always false. [compareValueOutOfTypeRangeError]\n", errout_str());
+
+        check("void f(short x) {\n"
+              "  if (x == 0xffff) {}\n"
+              "}", settingsUnix64);
+        ASSERT_EQUALS("[test.cpp:2:12]: (style) Comparing expression of type 'signed short' against value 65535. Condition is always false. [compareValueOutOfTypeRangeError]\n", errout_str());
+
+        check("void f(int x) {\n"
+              "  if (x == 0xffffffff) {}\n"
+              "}", settingsUnix64);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(long x) {\n"
+              "  if (x == ~0L) {}\n"
+              "}", settingsUnix64);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(long long x) {\n"
+              "  if (x == ~0LL) {}\n"
+              "}", settingsUnix64);
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int x) {\n"
+              "    const int i = 0xFFFFFFFF;\n"
+              "    if (x == i) {}\n"
+              "}", settingsUnix64);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "  char c;\n"
+              "  if ((c = foo()) != -1) {}\n"
+              "}", settingsUnix64);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int x) {\n"
+              "  if (x < 3000000000) {}\n"
+              "}", settingsUnix64);
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Comparing expression of type 'signed int' against value 3000000000. Condition is always true. [compareValueOutOfTypeRangeError]\n", errout_str());
+
+        check("void f(const signed char i) {\n" // #8545
+              "    if (i >  -129) {}\n" // warn
+              "    if (i >= -128) {}\n" // warn
+              "    if (i >= -127) {}\n"
+              "    if (i <  +128) {}\n" // warn
+              "    if (i <= +127) {}\n" // warn
+              "    if (i <= +126) {}\n"
+              "}\n", settingsUnix64);
+        ASSERT_EQUALS("[test.cpp:2:15]: (style) Comparing expression of type 'const signed char' against value -129. Condition is always true. [compareValueOutOfTypeRangeError]\n"
+                      "[test.cpp:3:15]: (style) Comparing expression of type 'const signed char' against value -128. Condition is always true. [compareValueOutOfTypeRangeError]\n"
+                      "[test.cpp:5:15]: (style) Comparing expression of type 'const signed char' against value 128. Condition is always true. [compareValueOutOfTypeRangeError]\n"
+                      "[test.cpp:6:15]: (style) Comparing expression of type 'const signed char' against value 127. Condition is always true. [compareValueOutOfTypeRangeError]\n",
+                      errout_str());
+
+        check("void f(const unsigned char u) {\n"
+              "    if (u >  0) {}\n"
+              "    if (u <  0) {}\n" // warn
+              "    if (u >= 0) {}\n" // warn
+              "    if (u <= 0) {}\n"
+              "    if (u >  255) {}\n" // warn
+              "    if (u <  255) {}\n"
+              "    if (u >= 255) {}\n"
+              "    if (u <= 255) {}\n" // warn
+              "    if (0   <  u) {}\n"
+              "    if (0   >  u) {}\n" // warn
+              "    if (0   <= u) {}\n" // warn
+              "    if (0   >= u) {}\n"
+              "    if (255 <  u) {}\n" // warn
+              "    if (255 >  u) {}\n"
+              "    if (255 <= u) {}\n"
+              "    if (255 >= u) {}\n" // warn
+              "}\n", settingsUnix64);
+        ASSERT_EQUALS("[test.cpp:3:14]: (style) Comparing expression of type 'const unsigned char' against value 0. Condition is always false. [compareValueOutOfTypeRangeError]\n"
+                      "[test.cpp:4:14]: (style) Comparing expression of type 'const unsigned char' against value 0. Condition is always true. [compareValueOutOfTypeRangeError]\n"
+                      "[test.cpp:6:14]: (style) Comparing expression of type 'const unsigned char' against value 255. Condition is always false. [compareValueOutOfTypeRangeError]\n"
+                      "[test.cpp:9:14]: (style) Comparing expression of type 'const unsigned char' against value 255. Condition is always true. [compareValueOutOfTypeRangeError]\n"
+                      "[test.cpp:11:9]: (style) Comparing expression of type 'const unsigned char' against value 0. Condition is always false. [compareValueOutOfTypeRangeError]\n"
+                      "[test.cpp:12:9]: (style) Comparing expression of type 'const unsigned char' against value 0. Condition is always true. [compareValueOutOfTypeRangeError]\n"
+                      "[test.cpp:14:9]: (style) Comparing expression of type 'const unsigned char' against value 255. Condition is always false. [compareValueOutOfTypeRangeError]\n"
+                      "[test.cpp:17:9]: (style) Comparing expression of type 'const unsigned char' against value 255. Condition is always true. [compareValueOutOfTypeRangeError]\n",
+                      errout_str());
+
+        check("void f(bool b) {\n" // #14037
+              "    if (b != 2) {}\n"
+              "}\n", settingsUnix64);
+        ASSERT_EQUALS("[test.cpp:2:14]: (style) Comparing expression of type 'bool' against value 2. Condition is always true. [compareValueOutOfTypeRangeError]\n",
+                      errout_str());
+    }
+
+    void knownConditionCast() {
+        check("void f(int i) {\n" // #9976
+              "    if (i < 0 || (unsigned)i > 5) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct B {\n" // #12941
+              "    virtual void f();\n"
+              "};\n"
+              "struct One : public B {};\n"
+              "struct Two : public B {};\n"
+              "void g(const B& b) {\n"
+              "    const Two* two = nullptr;\n"
+              "    const One* one = dynamic_cast<const One*>(&b);\n"
+              "    if (one == nullptr)\n"
+              "        two = dynamic_cast<const Two*>(&b);\n"
+              "    if (two) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void knownConditionIncrementLoop() { // #9808
+        check("void f() {\n"
+              "    int a = 0;\n"
+              "    while (++a < 5) {}\n"
+              "    if (a == 1) {}\n"
+              "    std::cout << a;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void knownConditionAfterBailout() { // #12526
+        check(
+            "#include <list>\n"
+            "int func()\n"
+            "{\n"
+            "  return VALUE_1;"
+            "}\n"
+            "\n"
+            "struct S1 {\n"
+            "  bool b{};\n"
+            "};\n"
+            "\n"
+            "struct S {\n"
+            "  void f(const std::list<int>& l) const\n"
+            "  {\n"
+            "    if (mS.b)\n"
+            "      return;\n"
+            "    for (int i : l)\n"
+            "    {\n"
+            "      (void)i;\n"
+            "      if (mS.b)\n"
+            "        continue;\n"
+            "    }\n"
+            "  }\n"
+            "\n"
+            "  S1 mS;\n"
+            "};"
+            );
+        ASSERT_EQUALS("[test.cpp:13:11] -> [test.cpp:18:13]: (style) Condition 'mS.b' is always false [knownConditionTrueFalse]\n", errout_str());
+    }
+
+    void knownConditionIncDecOperator() {
+        check(
+            "void f() {\n"
+            "    unsigned int d = 0;\n"
+            "    for (int i = 0; i < 4; ++i) {\n"
+            "        if (i < 3)\n"
+            "            ++d;\n"
+            "        else if (--d == 0)\n"
+            "            ;\n"
+            "    }\n"
+            "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void knownConditionFloating() {
+        check("void foo() {\n"   // #11199
+              "    float f = 1.0;\n"
+              "    if (f > 1.0f) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Condition 'f>1.0f' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("void foo() {\n"     // #11199
+              "    float f = 1.0;\n"
+              "    if (f > 1.0L) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Condition 'f>1.0L' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("void foo() {\n"   // #11199
+              "    float f = 1.0f;\n"
+              "    if (f > 1.0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Condition 'f>1.0' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("void foo() {\n"     // #11199
+              "    float f = 1.0f;\n"
+              "    if (f > 1.0L) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Condition 'f>1.0L' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("void foo() {\n"     // #11199
+              "    float f = 1.0L;\n"
+              "    if (f > 1.0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Condition 'f>1.0' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("void foo() {\n"     // #11199
+              "    float f = 1.0L;\n"
+              "    if (f > 1.0f) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Condition 'f>1.0f' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("void foo() {\n"   // #11201
+              "    float f = 0x1.4p+3;\n" // hex fraction 1.4 (decimal 1.25) scaled by 2^3, that is 10.0
+              "    if (f > 9.9) {}\n"
+              "    if (f < 9.9) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:11]: (style) Condition 'f>9.9' is always true [knownConditionTrueFalse]\n"
+            "[test.cpp:4:11]: (style) Condition 'f<9.9' is always false [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("void foo() {\n" // #12330
+              "    double d = 1.0;\n"
+              "    if (d < 0.0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Condition 'd<0.0' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("void foo() {\n"     // #12330
+              "    long double ld = 1.0;\n"
+              "    if (ld < 0.0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:12]: (style) Condition 'ld<0.0' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("void foo() {\n"     // #12330
+              "    float f = 1.0;\n"
+              "    if (f < 0.0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Condition 'f<0.0' is always false [knownConditionTrueFalse]\n", errout_str());
+
+        check("void foo() {\n"     // #12774
+              "    float f = 1.0f;\n"
+              "    if (f > 1.01f) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:11]: (style) Condition 'f>1.01f' is always false [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("void foo() {\n"     // #12774
+              "    float f = 1.0;\n"
+              "    if (f > 1.01) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:11]: (style) Condition 'f>1.01' is always false [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("void foo() {\n"
+              "    float f = 1.0f;\n"
+              "    if (f > 1) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:11]: (style) Condition 'f>1' is always false [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("void foo() {\n" // #13508
+              "    float f = 1.0f;\n"
+              "    if (f > 1.00f) {}\n"
+              "}\n");
+        TODO_ASSERT_EQUALS(
+            "[test.cpp:3]: (style) Condition 'f>1.00f' is always false\n",
+            "",
+            errout_str());
+
+        check("void foo() {\n"
+              "    float f = 1.0;\n"
+              "    if (f > 1) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:11]: (style) Condition 'f>1' is always false [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("void foo() {\n"// #13508
+              "    float f = 1.0;\n"
+              "    if (f > 1.00) {}\n"
+              "}\n");
+        TODO_ASSERT_EQUALS(
+            "[test.cpp:3]: (style) Condition 'f>1.00' is always false\n",
+            "",
+            errout_str());
+
+        check("void foo() {\n" // #13506
+              "    float nf = -1.0;\n"
+              "    if (nf > +1.0) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:12]: (style) Condition 'nf>+1.0' is always false [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("void foo() {\n" // #11200
+              "    float f = 1.0;\n"
+              "    if (f > -1.0) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:11]: (style) Condition 'f>-1.0' is always true [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("void foo() {\n" // #13508
+              "    float f = 1.0;\n"
+              "    if (f > 1.0) {}\n"
+              "}\n");
+        TODO_ASSERT_EQUALS(
+            "[test.cpp:3]: (style) Condition 'f>1.0' is always true\n",
+            "",
+            errout_str());
+
+        check("void foo() {\n" // #11200
+              "    float pf = +1.0;\n"
+              "    if (pf > -1.0) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:12]: (style) Condition 'pf>-1.0' is always true [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("void foo() {\n" // #13508
+              "    float pf = +1.0;\n"
+              "    if (pf > 1.0) {}\n"
+              "}\n");
+        TODO_ASSERT_EQUALS(
+            "[test.cpp:3]: (style) Condition 'pf>1.0' is always true\n",
+            "",
+            errout_str());
+
+        check("void foo() {\n" // #11200
+              "    float nf = -1.0;\n"
+              "    if (nf > 1.0) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:12]: (style) Condition 'nf>1.0' is always false [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("void foo() {\n" // / #13508
+              "    float nf = -1.0;\n"
+              "    if (nf > -1.0) {}\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        TODO_ASSERT_EQUALS(
+            "[test.cpp:3]: (style) Condition 'nf>-1.0' is always false\n",
+            "",
+            errout_str());
     }
 };
 
diff --git a/test/testconstructors.cpp b/test/testconstructors.cpp
index aded0c8c277..54af2d0a1c3 100644
--- a/test/testconstructors.cpp
+++ b/test/testconstructors.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,41 +16,48 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include "checkclass.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
+#include "standards.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
 
+#include <cstddef>
 
 class TestConstructors : public TestFixture {
 public:
-    TestConstructors() : TestFixture("TestConstructors") {
-    }
+    TestConstructors() : TestFixture("TestConstructors") {}
 
 private:
-    Settings settings;
+    const Settings settings = settingsBuilder().severity(Severity::style).severity(Severity::warning).build();
+    const Settings settings_i = settingsBuilder(settings).certainty(Certainty::inconclusive).build();
+
+    struct CheckOptions
+    {
+        bool inconclusive = false;
+    };
 
-    void check(const char code[], bool showAll = false) {
-        // Clear the error buffer..
-        errout.str("");
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
+        const Settings settings1 = options.inconclusive ? settings_i : settings;
 
-        settings.inconclusive = showAll;
+        check_(file, line, code, settings1);
+    }
 
-        // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const Settings& settings1) {
+        SimpleTokenizer tokenizer(settings1, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check class constructors..
-        CheckClass checkClass(&tokenizer, &settings, this);
+        CheckClass checkClass(&tokenizer, &settings1, this);
         checkClass.constructors();
     }
 
-    void run() OVERRIDE {
-        settings.addEnabled("style");
-        settings.addEnabled("warning");
-
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(simple1);
         TEST_CASE(simple2);
         TEST_CASE(simple3);
@@ -65,6 +72,10 @@ class TestConstructors : public TestFixture {
         TEST_CASE(simple12); // ticket #4620
         TEST_CASE(simple13); // #5498 - no constructor, c++11 assignments
         TEST_CASE(simple14); // #6253 template base
+        TEST_CASE(simple15); // #8942 multiple arguments, decltype
+        TEST_CASE(simple16); // copy members with c++11 init
+        TEST_CASE(simple17); // #10360
+        TEST_CASE(simple18);
 
         TEST_CASE(noConstructor1);
         TEST_CASE(noConstructor2);
@@ -75,8 +86,12 @@ class TestConstructors : public TestFixture {
         TEST_CASE(noConstructor7); // ticket #4391
         TEST_CASE(noConstructor8); // ticket #4404
         TEST_CASE(noConstructor9); // ticket #4419
+        TEST_CASE(noConstructor10); // ticket #6614
         TEST_CASE(noConstructor11); // ticket #3552
         TEST_CASE(noConstructor12); // #8951 - member initialization
+        TEST_CASE(noConstructor13); // #9998
+        TEST_CASE(noConstructor14); // #10770
+        TEST_CASE(noConstructor15); // #5499
 
         TEST_CASE(forwardDeclaration); // ticket #4290/#3190
 
@@ -88,21 +103,32 @@ class TestConstructors : public TestFixture {
         TEST_CASE(initvar_operator_eq4);     // ticket #2204
         TEST_CASE(initvar_operator_eq5);     // ticket #4119
         TEST_CASE(initvar_operator_eq6);
+        TEST_CASE(initvar_operator_eq7);
+        TEST_CASE(initvar_operator_eq8);
+        TEST_CASE(initvar_operator_eq9);
+        TEST_CASE(initvar_operator_eq10);
+        TEST_CASE(initvar_operator_eq11);
         TEST_CASE(initvar_same_classname);      // BUG 2208157
         TEST_CASE(initvar_chained_assign);      // BUG 2270433
         TEST_CASE(initvar_2constructors);       // BUG 2270353
         TEST_CASE(initvar_constvar);
+        TEST_CASE(initvar_mutablevar);
         TEST_CASE(initvar_staticvar);
+        TEST_CASE(initvar_brace_init);
         TEST_CASE(initvar_union);
         TEST_CASE(initvar_delegate);       // ticket #4302
         TEST_CASE(initvar_delegate2);
+        TEST_CASE(initvar_derived_class);
+        TEST_CASE(initvar_derived_pod_struct_with_union); // #11101
 
         TEST_CASE(initvar_private_constructor);     // BUG 2354171 - private constructor
+        TEST_CASE(initvar_derived_private_constructor);
         TEST_CASE(initvar_copy_constructor); // ticket #1611
         TEST_CASE(initvar_nested_constructor); // ticket #1375
         TEST_CASE(initvar_nocopy1);            // ticket #2474
         TEST_CASE(initvar_nocopy2);            // ticket #2484
         TEST_CASE(initvar_nocopy3);            // ticket #3611
+        TEST_CASE(initvar_nocopy4);            // ticket #9247
         TEST_CASE(initvar_with_member_function_this); // ticket #4824
 
         TEST_CASE(initvar_destructor);      // No variables need to be initialized in a destructor
@@ -111,6 +137,7 @@ class TestConstructors : public TestFixture {
         TEST_CASE(initvar_alias); // #6921
 
         TEST_CASE(initvar_templateMember); // #7205
+        TEST_CASE(initvar_smartptr); // #10237
 
         TEST_CASE(operatorEqSTL);
 
@@ -146,6 +173,11 @@ class TestConstructors : public TestFixture {
         TEST_CASE(uninitVar30); // ticket #6417
         TEST_CASE(uninitVar31); // ticket #8271
         TEST_CASE(uninitVar32); // ticket #8835
+        TEST_CASE(uninitVar33); // ticket #10295
+        TEST_CASE(uninitVar34); // ticket #10841
+        TEST_CASE(uninitVar35);
+        TEST_CASE(uninitVar36);
+        TEST_CASE(uninitVar37);
         TEST_CASE(uninitVarEnum1);
         TEST_CASE(uninitVarEnum2); // ticket #8146
         TEST_CASE(uninitVarStream);
@@ -160,6 +192,8 @@ class TestConstructors : public TestFixture {
         TEST_CASE(uninitVarArray7);
         TEST_CASE(uninitVarArray8);
         TEST_CASE(uninitVarArray9); // ticket #6957, #6959
+        TEST_CASE(uninitVarArray10);
+        TEST_CASE(uninitVarArray11);
         TEST_CASE(uninitVarArray2D);
         TEST_CASE(uninitVarArray3D);
         TEST_CASE(uninitVarCpp11Init1);
@@ -173,6 +207,7 @@ class TestConstructors : public TestFixture {
         TEST_CASE(privateCtor2);           // If constructor is private..
         TEST_CASE(function);               // Function is not variable
         TEST_CASE(uninitVarPublished);     // Borland C++: Variables in the published section are auto-initialized
+        TEST_CASE(uninitVarInheritClassInit); // Borland C++: if class inherits from TObject, all variables are initialized
         TEST_CASE(uninitOperator);         // No FP about uninitialized 'operator[]'
         TEST_CASE(uninitFunction1);        // No FP when initialized in function
         TEST_CASE(uninitFunction2);        // No FP when initialized in function
@@ -194,6 +229,8 @@ class TestConstructors : public TestFixture {
         TEST_CASE(uninitComparisonAssignment);    // ticket #7429
 
         TEST_CASE(uninitTemplate1); // ticket #7372
+
+        TEST_CASE(unknownTemplateType);
     }
 
 
@@ -203,21 +240,21 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    int i;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
               "{\n"
               "private:\n"
               "    int i;\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:1]: (style) The class 'Fred' does not have a constructor although it has private member variables.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:1]: (style) The class 'Fred' does not declare a constructor although it has private member variables which likely require initialization. [noConstructor]\n", errout_str());
 
         check("struct Fred\n"
               "{\n"
               "private:\n"
               "    int i;\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:1]: (style) The struct 'Fred' does not have a constructor although it has private member variables.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:1]: (style) The struct 'Fred' does not declare a constructor although it has private member variables which likely require initialization. [noConstructor]\n", errout_str());
     }
 
 
@@ -230,7 +267,7 @@ class TestConstructors : public TestFixture {
               "    Fred(Fred && other) : i(other.i) {}\n"
               "    int i;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
               "{\n"
@@ -240,7 +277,7 @@ class TestConstructors : public TestFixture {
               "    Fred(Fred && other) {i=other.i}\n"
               "    int i;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
               "{\n"
@@ -250,9 +287,9 @@ class TestConstructors : public TestFixture {
               "    Fred(Fred && other) {}\n"
               "    int i;\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n"
-                      "[test.cpp:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n"
-                      "[test.cpp:6]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:5:5]: (warning) Member variable 'Fred::i' is not initialized in the copy constructor. [uninitMemberVar]\n"
+                      "[test.cpp:6:5]: (warning) Member variable 'Fred::i' is not initialized in the move constructor. [uninitMemberVar]\n", errout_str());
 
         check("struct Fred\n"
               "{\n"
@@ -261,9 +298,9 @@ class TestConstructors : public TestFixture {
               "    Fred(Fred && other) {}\n"
               "    int i;\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n"
-                      "[test.cpp:4]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n"
-                      "[test.cpp:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:4:5]: (warning) Member variable 'Fred::i' is not initialized in the copy constructor. [uninitMemberVar]\n"
+                      "[test.cpp:5:5]: (warning) Member variable 'Fred::i' is not initialized in the move constructor. [uninitMemberVar]\n", errout_str());
     }
 
 
@@ -275,7 +312,7 @@ class TestConstructors : public TestFixture {
               "};\n"
               "Fred::Fred() :i(0)\n"
               "{ }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Fred\n"
               "{\n"
@@ -284,7 +321,7 @@ class TestConstructors : public TestFixture {
               "};\n"
               "Fred::Fred()\n"
               "{ i = 0; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Fred\n"
               "{\n"
@@ -293,7 +330,7 @@ class TestConstructors : public TestFixture {
               "};\n"
               "Fred::Fred()\n"
               "{ }");
-        ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:7]: (warning) Member variable 'Fred::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
 
@@ -310,8 +347,8 @@ class TestConstructors : public TestFixture {
               "Fred::Fred(int _i)\n"
               "{\n"
               "    i = _i;\n"
-              "}\n", true);
-        ASSERT_EQUALS("[test.cpp:8]: (warning, inconclusive) Member variable 'Fred::i' is not initialized in the constructor.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:8:7]: (warning, inconclusive) Member variable 'Fred::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void simple5() { // ticket #2560
@@ -328,7 +365,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    int mValue;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simple6() { // ticket #4085 - uninstantiated template class
@@ -338,7 +375,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    int x;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("template <class T> struct A {\n"
               "    A<T>() : x(0) { }\n"
@@ -346,7 +383,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    int x;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("template <class T> struct A {\n"
               "    A<T>() : x(0) { }\n"
@@ -355,8 +392,8 @@ class TestConstructors : public TestFixture {
               "    int x;\n"
               "    int y;\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Member variable 'A::y' is not initialized in the constructor.\n"
-                      "[test.cpp:3]: (warning) Member variable 'A::y' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning) Member variable 'A::y' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:3:5]: (warning) Member variable 'A::y' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void simple7() { // ticket #4531
@@ -364,15 +401,15 @@ class TestConstructors : public TestFixture {
               "struct Fred {\n"
               "    int x;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simple8() {
         check("struct Fred { int x; };\n"
               "class Barney { Fred fred; };\n"
               "class Wilma { struct Betty { int x; } betty; };");
-        ASSERT_EQUALS("[test.cpp:2]: (style) The class 'Barney' does not have a constructor although it has private member variables.\n"
-                      "[test.cpp:3]: (style) The class 'Wilma' does not have a constructor although it has private member variables.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:1]: (style) The class 'Barney' does not declare a constructor although it has private member variables which likely require initialization. [noConstructor]\n"
+                      "[test.cpp:3:1]: (style) The class 'Wilma' does not declare a constructor although it has private member variables which likely require initialization. [noConstructor]\n", errout_str());
     }
 
     void simple9() { // ticket #4574
@@ -382,17 +419,28 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    int x;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void simple10() { // ticket #4388
-        check("class Fred {\n"
+    void simple10() {
+        check("class Fred {\n" // ticket #4388
               "public:\n"
               "    Fred() = default;\n"
               "private:\n"
               "    int x;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Member variable 'Fred::x' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
+
+        check("struct S {\n" // #9391
+              "    S() = default;\n"
+              "    ~S() = default;\n"
+              "    S(const S&) = default;\n"
+              "    S(S&&) = default;\n"
+              "    S& operator=(const S&) = default;\n"
+              "    S& operator=(S&&) = default;\n"
+              "    int i;\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning) Member variable 'S::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void simple11() { // ticket #4536, #6214
@@ -409,8 +457,8 @@ class TestConstructors : public TestFixture {
               "    int d, e{3};\n"
               "    int f{4}, g;\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Member variable 'Fred::d' is not initialized in the constructor.\n"
-                      "[test.cpp:3]: (warning) Member variable 'Fred::g' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Member variable 'Fred::d' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:3:5]: (warning) Member variable 'Fred::g' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void simple12() { // ticket #4620
@@ -421,7 +469,7 @@ class TestConstructors : public TestFixture {
               "    void Init(int i = 0);\n"
               "};\n"
               "void Fred::Init(int i) { x = i; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Fred {\n"
               "    int x;\n"
@@ -431,15 +479,15 @@ class TestConstructors : public TestFixture {
               "    void Init(int i, int j = 0);\n"
               "};\n"
               "void Fred::Init(int i, int j) { x = i; y = j; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simple13() { // #5498
         check("class Fred {\n"
               "    int x=1;\n"
               "    int *y=0;\n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simple14() { // #6253 template base
@@ -451,8 +499,8 @@ class TestConstructors : public TestFixture {
               "    {}\n"
               "private:\n"
               "    int x;\n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
 
         check("class Fred : public Base<A, B> {"
               "public:"
@@ -462,8 +510,78 @@ class TestConstructors : public TestFixture {
               "    {}\n"
               "private:\n"
               "    int x;\n"
+              "};");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void simple15() { // #8942
+        check("class A\n"
+              "{\n"
+              "public:\n"
+              "  int member;\n"
+              "};\n"
+              "class B\n"
+              "{\n"
+              "public:\n"
+              "  B(const decltype(A::member)& x, const decltype(A::member)& y) : x(x), y(y) {}\n"
+              "private:\n"
+              "  const decltype(A::member)& x;\n"
+              "  const decltype(A::member)& y;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void simple16() {
+        check("struct S {\n"
+              "    int i{};\n"
+              "    S() = default;\n"
+              "    S(const S& s) {}\n"
+              "    S& operator=(const S& s) { return *this; }\n"
+              "};\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning, inconclusive) Member variable 'S::i' is not assigned in the copy constructor. Should it be copied? [missingMemberCopy]\n"
+                      "[test.cpp:5:8]: (warning) Member variable 'S::i' is not assigned a value in 'S::operator='. [operatorEqVarError]\n",
+                      errout_str());
+
+        check("struct S {\n"
+              "    int i;\n"
+              "    S() : i(0) {}\n"
+              "    S(const S& s) {}\n"
+              "    S& operator=(const S& s) { return *this; }\n"
               "};\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'S::i' is not initialized in the copy constructor. [uninitMemberVar]\n"
+                      "[test.cpp:5:8]: (warning) Member variable 'S::i' is not assigned a value in 'S::operator='. [operatorEqVarError]\n",
+                      errout_str());
+    }
+
+    void simple17() { // #10360
+        check("class Base {\n"
+              "public:\n"
+              "    virtual void Copy(const Base& Src) = 0;\n"
+              "};\n"
+              "class Derived : public Base {\n"
+              "public:\n"
+              "    Derived() : i(0) {}\n"
+              "    Derived(const Derived& Src);\n"
+              "    void Copy(const Base& Src) override;\n"
+              "    int i;\n"
+              "};\n"
+              "Derived::Derived(const Derived& Src) {\n"
+              "    Copy(Src);\n"
+              "}\n"
+              "void Derived::Copy(const Base& Src) {\n"
+              "    auto d = dynamic_cast<const Derived&>(Src);\n"
+              "    i = d.i;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void simple18() { // #13302
+        check("struct S {};\n"
+              "class C1 { S& r; };\n"
+              "class C2 { S* p; };\n");
+        ASSERT_EQUALS("[test.cpp:2:1]: (style) The class 'C1' does not declare a constructor although it has private member variables which likely require initialization. [noConstructor]\n"
+                      "[test.cpp:3:1]: (style) The class 'C2' does not declare a constructor although it has private member variables which likely require initialization. [noConstructor]\n",
+                      errout_str());
     }
 
     void noConstructor1() {
@@ -472,7 +590,7 @@ class TestConstructors : public TestFixture {
               "{\n"
               "    int i;\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:1]: (style) The class 'Fred' does not have a constructor although it has private member variables.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:1]: (style) The class 'Fred' does not declare a constructor although it has private member variables which likely require initialization. [noConstructor]\n", errout_str());
     }
 
     void noConstructor2() {
@@ -484,7 +602,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "void Fred::foobar()\n"
               "{ }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void noConstructor3() {
@@ -493,7 +611,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    static int foobar;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void noConstructor4() {
@@ -502,7 +620,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    int foobar;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void noConstructor5() {
@@ -510,7 +628,7 @@ class TestConstructors : public TestFixture {
               "{\n"
               "    int i;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void noConstructor6() {
@@ -524,22 +642,22 @@ class TestConstructors : public TestFixture {
               "    cpucyclesT m_v;\n"
               "    bool m_b;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void noConstructor7() {
         // ticket #4391
         check("short bar;\n"
-              "class foo;\n");
-        ASSERT_EQUALS("", errout.str());
+              "class foo;");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void noConstructor8() {
         // ticket #4404
         check("class LineSegment;\n"
               "class PointArray  { };\n"
-              "void* tech_ = NULL;\n");
-        ASSERT_EQUALS("", errout.str());
+              "void* tech_ = NULL;");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void noConstructor9() {
@@ -550,43 +668,110 @@ class TestConstructors : public TestFixture {
               "private:\n"
               " bool MessageSet;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
+    void noConstructor10() {
+        // ticket #6614
+        check("class A : public wxDialog\n"
+              "{\n"
+              "private:\n"
+              "    DECLARE_EVENT_TABLE()\n"
+              "public:\n"
+              "    A(wxWindow *parent,\n"
+              "      wxWindowID id = 1,\n"
+              "      const wxString &title = wxT(" "),\n"
+              "      const wxPoint& pos = wxDefaultPosition,\n"
+              "      const wxSize& size = wxDefaultSize,\n"
+              "      long style = wxDIALOG_NO_PARENT | wxMINIMIZE_BOX | wxMAXIMIZE_BOX | wxCLOSE_BOX);\n"
+              "    virtual ~A();\n"
+              "private:\n"
+              "    wxTimer *WxTimer1;\n"
+              "};");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+
     void noConstructor11() { // #3552
         check("class Fred { int x; };\n"
               "union U { int y; Fred fred; };");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void noConstructor12() { // #8951
         check("class Fred { int x{0}; };");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Fred { int x=0; };");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Fred { int x[1]={0}; };"); // #8850
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Fred { int x[1]{0}; };");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void noConstructor13() { // #9998
+        check("struct C { int v; };\n"
+              "struct B { C c[5] = {}; };\n"
+              "struct A {\n"
+              "    A() {}\n"
+              "    B b;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void noConstructor14() { // #10770
+        check("typedef void (*Func)();\n"
+              "class C {\n"
+              "public:\n"
+              "    void f();\n"
+              "private:\n"
+              "    Func fp = nullptr;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void noConstructor15() { // #5499
+        check("class C {\n"
+              "private:\n"
+              "    int i1 = 0;\n"
+              "    int i2;\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'C::i2' is not initialized. [uninitMemberVarPrivate]\n", errout_str());
+
+        check("class C {\n"
+              "private:\n"
+              "    int i1;\n"
+              "    int i2;\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:1:1]: (style) The class 'C' does not declare a constructor although it has private member variables which likely require initialization. [noConstructor]\n", errout_str());
+
+        check("class C {\n"
+              "public:\n"
+              "    C(int i) : i1(i) {}\n"
+              "private:\n"
+              "    int i1;\n"
+              "    int i2;\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Member variable 'C::i2' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     // ticket #4290 "False Positive: style (noConstructor): The class 'foo' does not have a constructor."
     // ticket #3190 "SymbolDatabase: Parse of sub class constructor fails"
     void forwardDeclaration() {
         check("class foo;\n"
-              "int bar;\n");
-        ASSERT_EQUALS("", errout.str());
+              "int bar;");
+        ASSERT_EQUALS("", errout_str());
 
         check("class foo;\n"
-              "class foo;\n");
-        ASSERT_EQUALS("", errout.str());
+              "class foo;");
+        ASSERT_EQUALS("", errout_str());
 
         check("class foo{};\n"
-              "class foo;\n");
-        ASSERT_EQUALS("", errout.str());
+              "class foo;");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void initvar_with_this() {
@@ -596,7 +781,7 @@ class TestConstructors : public TestFixture {
               "    { this->i = 0; }\n"
               "    int i;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void initvar_if() {
@@ -611,7 +796,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int i;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void initvar_operator_eq1() {
@@ -630,7 +815,7 @@ class TestConstructors : public TestFixture {
               "    const Fred & operator=(const Fred &fred)\n"
               "    { i = fred.i; return *this; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Fred {\n"
               "    int i;\n"
@@ -641,7 +826,7 @@ class TestConstructors : public TestFixture {
               "    const Fred & operator=(const Fred &fred)\n"
               "    { i = fred.i; return *this; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A\n"
               "{\n"
@@ -656,7 +841,7 @@ class TestConstructors : public TestFixture {
               "  int i;\n"
               "  int j;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -667,7 +852,7 @@ class TestConstructors : public TestFixture {
               "    void operator=(const Fred &fred) { }\n"
               "    int i;\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:10]: (warning) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='. [operatorEqVarError]\n", errout_str());
     }
 
     void initvar_operator_eq3() {
@@ -679,7 +864,7 @@ class TestConstructors : public TestFixture {
               "    void Init() { i = 0; }\n"
               "    int i;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void initvar_operator_eq4() {
@@ -696,7 +881,7 @@ class TestConstructors : public TestFixture {
               "        return *this\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:12]: (warning) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='. [operatorEqVarError]\n", errout_str());
 
         check("class Fred\n"
               "{\n"
@@ -711,7 +896,7 @@ class TestConstructors : public TestFixture {
               "        return *this\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:12]: (warning) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='. [operatorEqVarError]\n", errout_str());
 
         check("class Fred\n"
               "{\n"
@@ -726,7 +911,7 @@ class TestConstructors : public TestFixture {
               "        return *this\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:12]: (warning) Member variable 'Fred::i' is not assigned a value in 'Fred::operator='. [operatorEqVarError]\n", errout_str());
 
         check("class Fred\n"
               "{\n"
@@ -741,7 +926,7 @@ class TestConstructors : public TestFixture {
               "        return *this\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void initvar_operator_eq5() { // #4119 - false positive when using swap to assign variables
@@ -756,7 +941,7 @@ class TestConstructors : public TestFixture {
               "        return *this;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void initvar_operator_eq6() { // std::vector
@@ -765,26 +950,109 @@ class TestConstructors : public TestFixture {
               "    Fred & operator=(const Fred &rhs) {\n"
               "        return *this;\n"
               "    }\n"
-              "};",true);
-        ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) Member variable 'Fred::data' is not assigned a value in 'Fred::operator='.\n", errout.str());
+              "};",dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:12]: (warning, inconclusive) Member variable 'Fred::data' is not assigned a value in 'Fred::operator='. [operatorEqVarError]\n", errout_str());
 
         check("struct Fred {\n"
               "    std::vector<int> ints;\n"
               "    Fred & operator=(const Fred &rhs) {\n"
               "        return *this;\n"
               "    }\n"
-              "};",true);
-        ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) Member variable 'Fred::ints' is not assigned a value in 'Fred::operator='.\n", errout.str());
+              "};",dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:12]: (warning, inconclusive) Member variable 'Fred::ints' is not assigned a value in 'Fred::operator='. [operatorEqVarError]\n", errout_str());
 
         check("struct Fred {\n"
               "    Data data;\n"
               "    Fred & operator=(const Fred &rhs) {\n"
               "        return *this;\n"
               "    }\n"
-              "};",true);
-        ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) Member variable 'Fred::data' is not assigned a value in 'Fred::operator='.\n", errout.str());
+              "};",dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:12]: (warning, inconclusive) Member variable 'Fred::data' is not assigned a value in 'Fred::operator='. [operatorEqVarError]\n", errout_str());
     }
 
+    void initvar_operator_eq7() {
+        check("struct B {\n"
+              "    virtual void CopyImpl(const B& Src) = 0;\n"
+              "    void Copy(const B& Src);\n"
+              "};\n"
+              "struct D : B {};\n"
+              "struct DD : D {\n"
+              "    void CopyImpl(const B& Src) override;\n"
+              "    DD& operator=(const DD& Src);\n"
+              "    int i{};\n"
+              "};\n"
+              "DD& DD::operator=(const DD& Src) {\n"
+              "    if (this != &Src)\n"
+              "        Copy(Src);\n"
+              "    return *this;\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void initvar_operator_eq8() {
+        check("struct B {\n"
+              "    int b;\n"
+              "};\n"
+              "struct D1 : B {\n"
+              "    D1& operator=(const D1& src);\n"
+              "    int d1;\n"
+              "};\n"
+              "struct D2 : D1 {\n"
+              "    D2& operator=(const D2& src);\n"
+              "    int d2;\n"
+              "};\n"
+              "struct D3 : D2 {\n"
+              "    D3& operator=(const D3& src) {\n"
+              "        D1::operator=(src);\n"
+              "        d3_1 = src.d3_1;\n"
+              "    }\n"
+              "    int d3_1;\n"
+              "    int d3_2;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:13:9]: (warning) Member variable 'D3::d3_2' is not assigned a value in 'D3::operator='. [operatorEqVarError]\n"
+                      "[test.cpp:13:9]: (warning) Member variable 'D3::d2' is not assigned a value in 'D3::operator='. [operatorEqVarError]\n", errout_str());
+    }
+
+    void initvar_operator_eq9() {  // ticket #13203
+        check("struct S {\n"
+              "    int* m_data;\n"
+              "    S() : m_data(new int()) {}\n"
+              "    S& operator=(const S& s) {\n"
+              "        if (&s != this) {\n"
+              "            *(m_data) = *(s.m_data);\n"
+              "        }\n"
+              "        return *this;\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void initvar_operator_eq10() {
+        check("struct S {\n"
+              "    int* m_data;\n"
+              "    S() : m_data(new int()) {}\n"
+              "    S& operator=(const S& s) {\n"
+              "        if (&s != this) {\n"
+              "            (*m_data) = *(s.m_data);\n"
+              "        }\n"
+              "        return *this;\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void initvar_operator_eq11() {
+        check("struct S {\n"
+              "    int* m_data;\n"
+              "    S() : m_data(new int()) {}\n"
+              "    S& operator=(const S& s) {\n"
+              "        return *this;\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:4:8]: (warning) Member variable 'S::m_data' is not assigned a value in 'S::operator='. [operatorEqVarError]\n", errout_str());
+    }
+
+
     void initvar_same_classname() {
         // Bug 2208157 - False positive: Uninitialized variable, same class name
 
@@ -806,7 +1074,7 @@ class TestConstructors : public TestFixture {
               "    };\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void func1()\n"
               "{\n"
@@ -826,7 +1094,7 @@ class TestConstructors : public TestFixture {
               "    };\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void func1()\n"
               "{\n"
@@ -846,7 +1114,7 @@ class TestConstructors : public TestFixture {
               "    };\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Foo {\n"
               "    void func1()\n"
@@ -868,7 +1136,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Foo {\n"
               "    void func1()\n"
@@ -890,8 +1158,8 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "};");
 
-        ASSERT_EQUALS("[test.cpp:7]: (warning) Member variable 'Fred::a' is not initialized in the constructor.\n"
-                      "[test.cpp:16]: (warning) Member variable 'Fred::b' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:13]: (warning) Member variable 'Fred::a' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:16:13]: (warning) Member variable 'Fred::b' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void initvar_chained_assign() {
@@ -910,7 +1178,7 @@ class TestConstructors : public TestFixture {
               "    m_iMyInt1 = m_iMyInt2 = 0;\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -943,7 +1211,7 @@ class TestConstructors : public TestFixture {
               "    m_iMyInt = 0;\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -955,7 +1223,7 @@ class TestConstructors : public TestFixture {
               "};\n"
               "Fred::Fred() : s(NULL)\n"
               "{ }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Fred\n"
               "{\n"
@@ -964,7 +1232,7 @@ class TestConstructors : public TestFixture {
               "};\n"
               "Fred::Fred()\n"
               "{ s = NULL; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Fred\n"
               "{\n"
@@ -973,7 +1241,19 @@ class TestConstructors : public TestFixture {
               "};\n"
               "Fred::Fred()\n"
               "{ }");
-        ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'Fred::s' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:7]: (warning) Member variable 'Fred::s' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
+    }
+
+
+    void initvar_mutablevar() {
+        check("class Foo {\n"
+              "public:\n"
+              "    Foo() { update(); }\n"
+              "private:\n"
+              "    void update() const;\n"
+              "    mutable int x;\n"
+              "};");
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -984,7 +1264,20 @@ class TestConstructors : public TestFixture {
               "    Fred() { }\n"
               "    static void *p;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+
+    void initvar_brace_init() { // #10142
+        check("class C\n"
+              "{\n"
+              "public:\n"
+              "  C() {}\n"
+              "\n"
+              "private:\n"
+              "  std::map<int, double> * values_{};\n"
+              "};");
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -1002,7 +1295,7 @@ class TestConstructors : public TestFixture {
               "        U.a = 0;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
               "{\n"
@@ -1016,7 +1309,7 @@ class TestConstructors : public TestFixture {
               "    {\n"
               "    }\n"
               "};");
-        TODO_ASSERT_EQUALS("[test.cpp:9]: (warning) Member variable 'Fred::U' is not initialized in the constructor.\n", "", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:5]: (warning) Member variable 'Fred::U' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
 
@@ -1027,8 +1320,8 @@ class TestConstructors : public TestFixture {
               "    A(int n) { }\n"
               "    A() : A(42) {}\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'A::number' is not initialized in the constructor.\n"
-                      "[test.cpp:5]: (warning) Member variable 'A::number' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'A::number' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:5:5]: (warning) Member variable 'A::number' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("class A {\n"
               "    int number;\n"
@@ -1036,16 +1329,16 @@ class TestConstructors : public TestFixture {
               "    A(int n) { number = n; }\n"
               "    A() : A(42) {}\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class A {\n"
               "    int number;\n"
               "public:\n"
               "    A(int n) : A() { }\n"
               "    A() {}\n"
-              "};", true);
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'A::number' is not initialized in the constructor.\n"
-                      "[test.cpp:5]: (warning, inconclusive) Member variable 'A::number' is not initialized in the constructor.\n", errout.str());
+              "};", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'A::number' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:5:5]: (warning, inconclusive) Member variable 'A::number' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("class A {\n"
               "    int number;\n"
@@ -1053,7 +1346,7 @@ class TestConstructors : public TestFixture {
               "    A(int n) : A() { }\n"
               "    A() { number = 42; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class A {\n"
               "    int number;\n"
@@ -1061,8 +1354,8 @@ class TestConstructors : public TestFixture {
               "    A(int n) { }\n"
               "    A() : A{42} {}\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'A::number' is not initialized in the constructor.\n"
-                      "[test.cpp:5]: (warning) Member variable 'A::number' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'A::number' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:5:5]: (warning) Member variable 'A::number' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("class A {\n"
               "    int number;\n"
@@ -1070,16 +1363,16 @@ class TestConstructors : public TestFixture {
               "    A(int n) { number = n; }\n"
               "    A() : A{42} {}\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class A {\n"
               "    int number;\n"
               "public:\n"
               "    A(int n) : A{} { }\n"
               "    A() {}\n"
-              "};", true);
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'A::number' is not initialized in the constructor.\n"
-                      "[test.cpp:5]: (warning, inconclusive) Member variable 'A::number' is not initialized in the constructor.\n", errout.str());
+              "};", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'A::number' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:5:5]: (warning, inconclusive) Member variable 'A::number' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("class A {\n"
               "    int number;\n"
@@ -1087,7 +1380,7 @@ class TestConstructors : public TestFixture {
               "    A(int n) : A{} { }\n"
               "    A() { number = 42; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #6675
         check("struct Foo {\n"
@@ -1096,8 +1389,8 @@ class TestConstructors : public TestFixture {
               "  int foo_;\n"
               "};\n"
               "Foo::Foo() : Foo(0) {}\n"
-              "Foo::Foo(int foo) : foo_(foo) {}\n");
-        ASSERT_EQUALS("", errout.str());
+              "Foo::Foo(int foo) : foo_(foo) {}");
+        ASSERT_EQUALS("", errout_str());
 
         // Noexcept ctors
         check("class A {\n"
@@ -1109,7 +1402,7 @@ class TestConstructors : public TestFixture {
               "};\n"
               "\n"
               "A::A() noexcept: A(0) {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #8581
         check("class A {\n"
@@ -1119,7 +1412,7 @@ class TestConstructors : public TestFixture {
               "    A(int a) : _a(a) {}\n"
               "    A(float a) : A(int(a)) {}\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #8258
         check("struct F{};\n"
@@ -1131,7 +1424,7 @@ class TestConstructors : public TestFixture {
               "    int _b;\n"
               "    F _f;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void initvar_delegate2() {
@@ -1155,31 +1448,180 @@ class TestConstructors : public TestFixture {
               "    , b(0)\n"
               "{\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void initvar_private_constructor() {
-        settings.standards.cpp = Standards::CPP11;
-        check("class Fred\n"
-              "{\n"
-              "private:\n"
-              "    int var;\n"
-              "    Fred();\n"
+    void initvar_derived_class() {
+        check("class Base {\n" // #10161
+              "public:\n"
+              "  virtual void foo() = 0;\n"
+              "  int x;\n" // <- uninitialized
               "};\n"
-              "Fred::Fred()\n"
-              "{ }");
-        ASSERT_EQUALS("[test.cpp:7]: (warning) Member variable 'Fred::var' is not initialized in the constructor.\n", errout.str());
+              "\n"
+              "class Derived: public Base {\n"
+              "public:\n"
+              "  Derived() {}\n"
+              "  void foo() override;\n"
+              "};");
+        ASSERT_EQUALS("[test.cpp:9:3]: (warning) Member variable 'Base::x' is not initialized in the constructor. Maybe it should be initialized directly in the class Base? [uninitDerivedMemberVar]\n", errout_str());
 
-        settings.standards.cpp = Standards::CPP03;
-        check("class Fred\n"
-              "{\n"
-              "private:\n"
-              "    int var;\n"
-              "    Fred();\n"
+        check("struct A {\n" // #3462
+              "    char ca;\n"
+              "    A& operator=(const A& a) {\n"
+              "        ca = a.ca;\n"
+              "        return *this;\n"
+              "    }\n"
               "};\n"
-              "Fred::Fred()\n"
-              "{ }");
-        ASSERT_EQUALS("", errout.str());
+              "struct B : public A {\n"
+              "    char cb;\n"
+              "    B& operator=(const B& b) {\n"
+              "        A::operator=(b);\n"
+              "        return *this;\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:10:8]: (warning) Member variable 'B::cb' is not assigned a value in 'B::operator='. [operatorEqVarError]\n", errout_str());
+
+        check("struct A {\n"
+              "    char ca;\n"
+              "    A& operator=(const A& a) {\n"
+              "        return *this;\n"
+              "    }\n"
+              "};\n"
+              "struct B : public A {\n"
+              "    char cb;\n"
+              "    B& operator=(const B& b) {\n"
+              "        A::operator=(b);\n"
+              "        return *this;\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:3:8]: (warning) Member variable 'A::ca' is not assigned a value in 'A::operator='. [operatorEqVarError]\n"
+                      "[test.cpp:9:8]: (warning) Member variable 'B::cb' is not assigned a value in 'B::operator='. [operatorEqVarError]\n"
+                      "[test.cpp:9:8]: (warning) Member variable 'B::ca' is not assigned a value in 'B::operator='. [operatorEqVarError]\n",
+                      errout_str());
+
+        check("class C : B {\n" // don't crash
+              "    virtual C& operator=(C& c);\n"
+              "};\n"
+              "class D : public C {\n"
+              "    virtual C& operator=(C& c) { return C::operator=(c); };\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct B;\n" // don't crash
+              "struct D : B { D& operator=(const D&); };\n"
+              "struct E : D { E& operator=(const E& rhs); };\n"
+              "E& E::operator=(const E& rhs) {\n"
+              "    if (this != &rhs)\n"
+              "        D::operator=(rhs);\n"
+              "    return *this;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("template <class T>\n" // #12128
+              "struct B {\n"
+              "    T x;\n"
+              "};\n"
+              "struct D : B<double> {\n"
+              "    D(double x) : B{ x } {}\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct B {\n"
+              "    int x;\n"
+              "};\n"
+              "struct D : B {\n"
+              "    D(int i) : B{ i } {}\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void initvar_derived_pod_struct_with_union() {
+        check("struct S {\n"
+              "    union {\n"
+              "        unsigned short       all;\n"
+              "        struct {\n"
+              "            unsigned char    flag1;\n"
+              "            unsigned char    flag2;\n"
+              "        };\n"
+              "    };\n"
+              "};\n"
+              "\n"
+              "class C : public S {\n"
+              "public:\n"
+              "    C() { all = 0; tick = 0; }\n"
+              "};");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n"
+              "    union {\n"
+              "        unsigned short       all;\n"
+              "        struct {\n"
+              "            unsigned char    flag1;\n"
+              "            unsigned char    flag2;\n"
+              "        };\n"
+              "    };\n"
+              "};\n"
+              "\n"
+              "class C : public S {\n"
+              "public:\n"
+              "    C() { flag1 = flag2 = 0; tick = 0; }\n"
+              "};");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n"
+              "    union {\n"
+              "        unsigned short       all;\n"
+              "        struct {\n"
+              "            unsigned char    flag1;\n"
+              "            unsigned char    flag2;\n"
+              "        };\n"
+              "    };\n"
+              "};\n"
+              "\n"
+              "class C : public S {\n"
+              "public:\n"
+              "    C() {}\n"
+              "};");
+        ASSERT_EQUALS("[test.cpp:13:5]: (warning) Member variable 'S::all' is not initialized in the constructor. Maybe it should be initialized directly in the class S? [uninitDerivedMemberVar]\n"
+                      "[test.cpp:13:5]: (warning) Member variable 'S::flag1' is not initialized in the constructor. Maybe it should be initialized directly in the class S? [uninitDerivedMemberVar]\n"
+                      "[test.cpp:13:5]: (warning) Member variable 'S::flag2' is not initialized in the constructor. Maybe it should be initialized directly in the class S? [uninitDerivedMemberVar]\n", errout_str());
+    }
+
+    void initvar_private_constructor() {
+        {
+            const Settings s = settingsBuilder(settings).cpp( Standards::CPP11).build();
+            check("class Fred\n"
+                  "{\n"
+                  "private:\n"
+                  "    int var;\n"
+                  "    Fred();\n"
+                  "};\n"
+                  "Fred::Fred()\n"
+                  "{ }", s);
+            ASSERT_EQUALS("[test.cpp:7:7]: (warning) Member variable 'Fred::var' is not initialized in the constructor. [uninitMemberVarPrivate]\n", errout_str());
+        }
+
+        {
+            const Settings s = settingsBuilder(settings).cpp(Standards::CPP03).build();
+            check("class Fred\n"
+                  "{\n"
+                  "private:\n"
+                  "    int var;\n"
+                  "    Fred();\n"
+                  "};\n"
+                  "Fred::Fred()\n"
+                  "{ }", s);
+            ASSERT_EQUALS("", errout_str());
+        }
+    }
+    void initvar_derived_private_constructor() {
+        check("class B { int i; };\n"
+              "class D : B {\n"
+              "    explicit D(int) {}\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:1:1]: (style) The class 'B' does not declare a constructor although it has private member variables which likely require initialization. [noConstructor]\n"
+                      "[test.cpp:3:14]: (warning) Member variable 'B::i' is not initialized in the constructor. Maybe it should be initialized directly in the class B? [uninitDerivedMemberVarPrivate]\n",
+                      errout_str());
     }
 
     void initvar_copy_constructor() { // ticket #1611
@@ -1191,7 +1633,7 @@ class TestConstructors : public TestFixture {
               "    Fred() { };\n"
               "    Fred(const Fred &) { };\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
               "{\n"
@@ -1200,8 +1642,8 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Fred() { };\n"
               "    Fred(const Fred &) { };\n"
-              "};", true);
-        ASSERT_EQUALS("[test.cpp:7]: (warning, inconclusive) Member variable 'Fred::var' is not initialized in the constructor.\n", errout.str());
+              "};", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:7:5]: (warning, inconclusive) Member variable 'Fred::var' is not assigned in the copy constructor. Should it be copied? [missingMemberCopy]\n", errout_str());
 
         check("class Fred\n"
               "{\n"
@@ -1212,8 +1654,17 @@ class TestConstructors : public TestFixture {
               "    Fred(const Fred &);\n"
               "};\n"
               "Fred::Fred() { };\n"
-              "Fred::Fred(const Fred &) { };\n", true);
-        ASSERT_EQUALS("[test.cpp:10]: (warning, inconclusive) Member variable 'Fred::var' is not initialized in the constructor.\n", errout.str());
+              "Fred::Fred(const Fred &) { };\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:10:7]: (warning, inconclusive) Member variable 'Fred::var' is not assigned in the copy constructor. Should it be copied? [missingMemberCopy]\n", errout_str());
+
+        check("class Baz {};\n" // #8496
+              "class Bar {\n"
+              "public:\n"
+              "    explicit Bar(Baz* pBaz = NULL) : i(0) {}\n"
+              "    Bar(const Bar& bar) {}\n"
+              "    int i;\n"
+              "};\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) Member variable 'Bar::i' is not initialized in the copy constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void initvar_nested_constructor() { // ticket #1375
@@ -1242,10 +1693,10 @@ class TestConstructors : public TestFixture {
               "A::B::C::D::D(int z){}");
         // Note that the example code is not compilable. The A constructor must
         // explicitly initialize A::b. A warning for A::b is not necessary.
-        ASSERT_EQUALS("[test.cpp:20]: (warning) Member variable 'A::a' is not initialized in the constructor.\n"
-                      "[test.cpp:21]: (warning) Member variable 'B::b' is not initialized in the constructor.\n"
-                      "[test.cpp:22]: (warning) Member variable 'C::c' is not initialized in the constructor.\n"
-                      "[test.cpp:23]: (warning) Member variable 'D::d' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:20:4]: (warning) Member variable 'A::a' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:21:7]: (warning) Member variable 'B::b' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:22:10]: (warning) Member variable 'C::c' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:23:13]: (warning) Member variable 'D::d' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("class A {\n"
               "public:\n"
@@ -1272,10 +1723,10 @@ class TestConstructors : public TestFixture {
               "A::B::C::D::D(const A::B::C::D & d){}");
         // Note that the example code is not compilable. The A constructor must
         // explicitly initialize A::b. A warning for A::b is not necessary.
-        ASSERT_EQUALS("[test.cpp:20]: (warning) Member variable 'A::a' is not initialized in the constructor.\n"
-                      "[test.cpp:21]: (warning) Member variable 'B::b' is not initialized in the constructor.\n"
-                      "[test.cpp:22]: (warning) Member variable 'C::c' is not initialized in the constructor.\n"
-                      "[test.cpp:23]: (warning) Member variable 'D::d' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:20:4]: (warning) Member variable 'A::a' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:21:7]: (warning) Member variable 'B::b' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:22:10]: (warning) Member variable 'C::c' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:23:13]: (warning) Member variable 'D::d' is not initialized in the copy constructor. [uninitMemberVar]\n", errout_str());
 
         check("class A {\n"
               "public:\n"
@@ -1303,10 +1754,10 @@ class TestConstructors : public TestFixture {
               "A::B::C::D::D(const A::B::C::D::E & e){}");
         // Note that the example code is not compilable. The A constructor must
         // explicitly initialize A::b. A warning for A::b is not necessary.
-        ASSERT_EQUALS("[test.cpp:21]: (warning) Member variable 'A::a' is not initialized in the constructor.\n"
-                      "[test.cpp:22]: (warning) Member variable 'B::b' is not initialized in the constructor.\n"
-                      "[test.cpp:23]: (warning) Member variable 'C::c' is not initialized in the constructor.\n"
-                      "[test.cpp:24]: (warning) Member variable 'D::d' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:21:4]: (warning) Member variable 'A::a' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:22:7]: (warning) Member variable 'B::b' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:23:10]: (warning) Member variable 'C::c' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:24:13]: (warning) Member variable 'D::d' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void initvar_nocopy1() { // ticket #2474
@@ -1323,7 +1774,7 @@ class TestConstructors : public TestFixture {
               "    A(A &&){}\n"
               "    const A& operator=(const A&){return *this;}\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class B\n"
               "{\n"
@@ -1338,7 +1789,7 @@ class TestConstructors : public TestFixture {
               "    A(A &&){}\n"
               "    const A& operator=(const A&){return *this;}\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class B\n"
               "{\n"
@@ -1355,7 +1806,7 @@ class TestConstructors : public TestFixture {
               "    A(A &&){}\n"
               "    const A& operator=(const A&){return *this;}\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class B\n"
               "{\n"
@@ -1371,7 +1822,7 @@ class TestConstructors : public TestFixture {
               "    A(A &&){}\n"
               "    const A& operator=(const A&){return *this;}\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class A : public std::vector<int>\n"
               "{\n"
@@ -1386,11 +1837,11 @@ class TestConstructors : public TestFixture {
               "    B(const B&){}\n"
               "    B(B &&){}\n"
               "    const B& operator=(const B&){return *this;}\n"
-              "};", true);
-        ASSERT_EQUALS("[test.cpp:11]: (warning, inconclusive) Member variable 'B::a' is not initialized in the constructor.\n"
-                      "[test.cpp:12]: (warning, inconclusive) Member variable 'B::a' is not initialized in the constructor.\n"
-                      "[test.cpp:13]: (warning, inconclusive) Member variable 'B::a' is not assigned a value in 'B::operator='.\n",
-                      errout.str());
+              "};", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:11:5]: (warning, inconclusive) Member variable 'B::a' is not assigned in the copy constructor. Should it be copied? [missingMemberCopy]\n"
+                      "[test.cpp:12:5]: (warning, inconclusive) Member variable 'B::a' is not assigned in the move constructor. Should it be moved? [missingMemberCopy]\n"
+                      "[test.cpp:13:14]: (warning, inconclusive) Member variable 'B::a' is not assigned a value in 'B::operator='. [operatorEqVarError]\n",
+                      errout_str());
 
         check("class B\n"
               "{\n"
@@ -1407,7 +1858,7 @@ class TestConstructors : public TestFixture {
               "    A(A &&){}\n"
               "    const A& operator=(const A&){return *this;}\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:13]: (warning) Member variable 'A::m_SemVar' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:13:5]: (warning) Member variable 'A::m_SemVar' is not initialized in the move constructor. [uninitMemberVar]\n", errout_str());
 
         check("class B\n"
               "{\n"
@@ -1425,7 +1876,7 @@ class TestConstructors : public TestFixture {
               "    A(A &&){}\n"
               "    const A& operator=(const A&){return *this;}\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class A\n"
               "{\n"
@@ -1435,7 +1886,7 @@ class TestConstructors : public TestFixture {
               "    A(const A&){}\n"
               "    const A& operator=(const A&){return *this;}\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void initvar_nocopy2() { // ticket #2484
@@ -1452,8 +1903,8 @@ class TestConstructors : public TestFixture {
               "    A(){}\n"
               "    A(const A&){}\n"
               "    const A& operator=(const A&){return *this;}\n"
-              "};", true);
-        ASSERT_EQUALS("", errout.str());
+              "};", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("class B\n"
               "{\n"
@@ -1469,10 +1920,10 @@ class TestConstructors : public TestFixture {
               "    A(){}\n"
               "    A(const A&){}\n"
               "    const A& operator=(const A&){return *this;}\n"
-              "};", true);
-        ASSERT_EQUALS("[test.cpp:12]: (warning) Member variable 'A::m_SemVar' is not initialized in the constructor.\n"
-                      "[test.cpp:13]: (warning) Member variable 'A::m_SemVar' is not initialized in the constructor.\n"
-                      "[test.cpp:14]: (warning) Member variable 'A::m_SemVar' is not assigned a value in 'A::operator='.\n", errout.str());
+              "};", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:12:5]: (warning) Member variable 'A::m_SemVar' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:13:5]: (warning) Member variable 'A::m_SemVar' is not initialized in the copy constructor. [uninitMemberVar]\n"
+                      "[test.cpp:14:14]: (warning) Member variable 'A::m_SemVar' is not assigned a value in 'A::operator='. [operatorEqVarError]\n", errout_str());
     }
 
     void initvar_nocopy3() { // #3611 - unknown type is non-copyable
@@ -1481,14 +1932,30 @@ class TestConstructors : public TestFixture {
               "    A() {}\n"
               "    A(const A& rhs) {}\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
               "    B b;\n"
               "    A() {}\n"
               "    A(const A& rhs) {}\n"
-              "};", true);
-        ASSERT_EQUALS("[test.cpp:4]: (warning, inconclusive) Member variable 'A::b' is not initialized in the constructor.\n", errout.str());
+              "};", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning, inconclusive) Member variable 'A::b' is not assigned in the copy constructor. Should it be copied? [missingMemberCopy]\n", errout_str());
+    }
+
+    void initvar_nocopy4() { // #9247
+        check("struct S {\n"
+              "    S(const S & s);\n"
+              "    void S::Set(const T& val);\n"
+              "    void S::Set(const U& val);\n"
+              "    T t;\n"
+              "};\n"
+              "S::S(const S& s) {\n"
+              "    Set(s.t);\n"
+              "}\n"
+              "void S::Set(const T& val) {\n"
+              "    t = val;\n"
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void initvar_with_member_function_this() {
@@ -1497,7 +1964,7 @@ class TestConstructors : public TestFixture {
               "  void setMember(int m) { member = m; }\n"
               "  int member;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void initvar_destructor() {
@@ -1509,7 +1976,7 @@ class TestConstructors : public TestFixture {
               "    Fred() : var(0) {}\n"
               "    ~Fred() {}\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void initvar_func_ret_func_ptr() { // ticket #4449 (segmentation fault)
@@ -1517,7 +1984,7 @@ class TestConstructors : public TestFixture {
               "    int * ( something :: * process()) () { return 0; }\n"
               "    something() { process(); }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void initvar_alias() { // #6921
@@ -1528,7 +1995,7 @@ class TestConstructors : public TestFixture {
               "        pa = 4;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n"
               "    int a;\n"
@@ -1537,7 +2004,7 @@ class TestConstructors : public TestFixture {
               "        *pa = 4;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n"
               "    int a[2];\n"
@@ -1547,7 +2014,7 @@ class TestConstructors : public TestFixture {
               "            *pa++ = i;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n"
               "    int* a[2];\n"
@@ -1556,7 +2023,7 @@ class TestConstructors : public TestFixture {
               "        *pa = 0;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Member variable 'S::a' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Member variable 'S::a' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("struct S {\n"
               "    int a;\n"
@@ -1565,7 +2032,7 @@ class TestConstructors : public TestFixture {
               "        pa = 4;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Member variable 'S::a' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Member variable 'S::a' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void initvar_templateMember() {
@@ -1584,7 +2051,34 @@ class TestConstructors : public TestFixture {
               "        Wrapper<dim>::foo(x);\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void initvar_smartptr() { // #10237
+        // TODO: test should probably not pass without library
+        const Settings s = settingsBuilder() /*.library("std.cfg")*/.build();
+        check("struct S {\n"
+              "    explicit S(const std::shared_ptr<S>& sp) {\n"
+              "        set(*sp);\n"
+              "    }\n"
+              "    double get() const {\n"
+              "        return d;\n"
+              "    }\n"
+              "    void set(const S& rhs) {\n"
+              "        d = rhs.get();\n"
+              "    }\n"
+              "    double d;\n"
+              "};", s);
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #8485
+              "    explicit S(const T& rhs) { set(*rhs); }\n"
+              "    void set(const S& v) {\n"
+              "        d = v.d;\n"
+              "    }\n"
+              "    double d; \n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void operatorEqSTL() {
@@ -1601,8 +2095,15 @@ class TestConstructors : public TestFixture {
               "{ }\n"
               "\n"
               "void Fred::operator=(const Fred &f)\n"
-              "{ }", true);
-        ASSERT_EQUALS("[test.cpp:13]: (warning, inconclusive) Member variable 'Fred::ints' is not assigned a value in 'Fred::operator='.\n", errout.str());
+              "{ }", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:13:12]: (warning, inconclusive) Member variable 'Fred::ints' is not assigned a value in 'Fred::operator='. [operatorEqVarError]\n", errout_str());
+
+        const Settings s = settingsBuilder().certainty(Certainty::inconclusive).severity(Severity::style).severity(Severity::warning).library("std.cfg").build();
+        check("struct S {\n"
+              "    S& operator=(const S& s) { return *this; }\n"
+              "    std::mutex m;\n"
+              "};\n", s);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVar1() {
@@ -1621,7 +2122,7 @@ class TestConstructors : public TestFixture {
               "    ECODES _code;\n"
               "};");
 
-        ASSERT_EQUALS("[test.cpp:10]: (warning) Member variable 'Fred::_code' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:5]: (warning) Member variable 'Fred::_code' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
 
         check("class A{};\n"
@@ -1633,7 +2134,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "  float f;\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'B::f' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:3]: (warning) Member variable 'B::f' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("class C\n"
               "{\n"
@@ -1646,7 +2147,7 @@ class TestConstructors : public TestFixture {
               "C::C(FILE *fp) {\n"
               "    C::fp = fp;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVar2() {
@@ -1657,7 +2158,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    int i;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVar3() {
@@ -1672,7 +2173,7 @@ class TestConstructors : public TestFixture {
               "    };\n"
               "    Bar bars[2];\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Using struct that doesn't have constructor
         check("class Foo\n"
@@ -1685,7 +2186,7 @@ class TestConstructors : public TestFixture {
               "    };\n"
               "    Bar bars[2];\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Foo::bars' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Foo::bars' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void uninitVar4() {
@@ -1699,7 +2200,7 @@ class TestConstructors : public TestFixture {
               "    };\n"
               "    struct Bar bar;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVar5() {
@@ -1711,7 +2212,7 @@ class TestConstructors : public TestFixture {
               "    { return *this; }\n"
               "    static int i;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVar6() {
@@ -1722,7 +2223,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    int mi;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Foo : public Bar\n"
               "{\n"
@@ -1731,7 +2232,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    int mi;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVar7() {
@@ -1752,7 +2253,7 @@ class TestConstructors : public TestFixture {
               "    copy.Swap(*this);\n"
               "    return *this;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVar8() {
@@ -1769,7 +2270,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    return *this;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8]: (warning) Member variable 'Foo::a' is not assigned a value in 'Foo::operator='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:11]: (warning) Member variable 'Foo::a' is not assigned a value in 'Foo::operator='. [operatorEqVarError]\n", errout_str());
     }
 
     void uninitVar9() { // ticket #1730
@@ -1783,7 +2284,7 @@ class TestConstructors : public TestFixture {
               "{\n"
               "    SetMinSize( wxSize( 48,48 ) );\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (warning) Member variable 'Prefs::xasd' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:8]: (warning) Member variable 'Prefs::xasd' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void uninitVar10() { // ticket #1993
@@ -1795,7 +2296,7 @@ class TestConstructors : public TestFixture {
               "        int var2;\n"
               "};\n"
               "A::A() : var1(0) { }");
-        ASSERT_EQUALS("[test.cpp:8]: (warning) Member variable 'A::var2' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:4]: (warning) Member variable 'A::var2' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void uninitVar11() {
@@ -1806,7 +2307,7 @@ class TestConstructors : public TestFixture {
               "        int var;\n"
               "};\n"
               "A::A(int a) { }");
-        ASSERT_EQUALS("[test.cpp:7]: (warning) Member variable 'A::var' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:4]: (warning) Member variable 'A::var' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void uninitVar12() { // ticket #2078
@@ -1822,8 +2323,8 @@ class TestConstructors : public TestFixture {
               "    {}\n"
               "    int x, y;\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Point::x' is not initialized in the constructor.\n"
-                      "[test.cpp:4]: (warning) Member variable 'Point::y' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Point::x' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:4:5]: (warning) Member variable 'Point::y' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void uninitVar13() { // ticket #1195
@@ -1834,7 +2335,7 @@ class TestConstructors : public TestFixture {
               "    A()\n"
               "    {}\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Member variable 'A::ints' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) Member variable 'A::ints' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void uninitVar14() { // ticket #2149
@@ -1849,7 +2350,7 @@ class TestConstructors : public TestFixture {
               "Foo::Foo()\n"
               "{\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:6]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         // single namespace
         check("namespace Output\n"
@@ -1865,7 +2366,7 @@ class TestConstructors : public TestFixture {
               "    {\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:10]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:10]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         // constructor outside namespace
         check("namespace Output\n"
@@ -1881,7 +2382,7 @@ class TestConstructors : public TestFixture {
               "Foo::Foo()\n"
               "{\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // constructor outside namespace
         check("namespace Output\n"
@@ -1897,7 +2398,24 @@ class TestConstructors : public TestFixture {
               "Output::Foo::Foo()\n"
               "{\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:11]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:11:14]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
+
+        // constructor outside namespace with using, #4792
+        check("namespace Output\n"
+              "{\n"
+              "    class Foo\n"
+              "    {\n"
+              "    public:\n"
+              "        Foo();\n"
+              "    private:\n"
+              "        bool mMember;\n"
+              "    };\n"
+              "}\n"
+              "using namespace Output;"
+              "Foo::Foo()\n"
+              "{\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:11:29]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         // constructor in separate namespace
         check("namespace Output\n"
@@ -1916,7 +2434,7 @@ class TestConstructors : public TestFixture {
               "    {\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:13]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:13:10]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         // constructor in different separate namespace
         check("namespace Output\n"
@@ -1935,7 +2453,7 @@ class TestConstructors : public TestFixture {
               "    {\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // constructor in different separate namespace (won't compile)
         check("namespace Output\n"
@@ -1954,7 +2472,7 @@ class TestConstructors : public TestFixture {
               "    {\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // constructor in nested separate namespace
         check("namespace A\n"
@@ -1976,7 +2494,7 @@ class TestConstructors : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:15]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:15:14]: (warning) Member variable 'Foo::mMember' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         // constructor in nested different separate namespace
         check("namespace A\n"
@@ -1998,7 +2516,7 @@ class TestConstructors : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // constructor in nested different separate namespace
         check("namespace A\n"
@@ -2020,7 +2538,7 @@ class TestConstructors : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVar15() {
@@ -2034,7 +2552,7 @@ class TestConstructors : public TestFixture {
               "Fred::~Fred()\n"
               "{\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVar16() {
@@ -2052,7 +2570,7 @@ class TestConstructors : public TestFixture {
               "        foo.set(0);\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Foo\n"
               "{\n"
@@ -2067,7 +2585,7 @@ class TestConstructors : public TestFixture {
               "    {\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:10]: (warning) Member variable 'Bar::foo' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:5]: (warning) Member variable 'Bar::foo' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void uninitVar17() {
@@ -2084,7 +2602,7 @@ class TestConstructors : public TestFixture {
               "        foo[0].a = 0;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Foo\n"
               "{\n"
@@ -2098,7 +2616,7 @@ class TestConstructors : public TestFixture {
               "    {\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:9]: (warning) Member variable 'Bar::foo' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:5]: (warning) Member variable 'Bar::foo' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void uninitVar18() { // ticket #2465
@@ -2114,7 +2632,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    Altren value;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVar19() { // ticket #2792
@@ -2138,7 +2656,7 @@ class TestConstructors : public TestFixture {
               "        free(m_str);\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVar20() { // ticket #2867
@@ -2150,7 +2668,7 @@ class TestConstructors : public TestFixture {
               "        double bitsInData_;\n"
               "    } obj;\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'LocalClass::bitsInData_' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9]: (warning) Member variable 'LocalClass::bitsInData_' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("struct copy_protected;\n"
               "Object::MemFunc() {\n"
@@ -2162,8 +2680,8 @@ class TestConstructors : public TestFixture {
               "    } obj;\n"
               "};");
         ASSERT_EQUALS(
-            "[test.cpp:5]: (warning) Member variable 'LocalClass::bitsInData_' is not initialized in the constructor.\n",
-            errout.str());
+            "[test.cpp:5:9]: (warning) Member variable 'LocalClass::bitsInData_' is not initialized in the constructor. [uninitMemberVar]\n",
+            errout_str());
 
         check("struct copy_protected;\n"
               "Object::MemFunc() {\n"
@@ -2175,8 +2693,8 @@ class TestConstructors : public TestFixture {
               "    } obj;\n"
               "};");
         ASSERT_EQUALS(
-            "[test.cpp:5]: (warning) Member variable 'LocalClass::bitsInData_' is not initialized in the constructor.\n",
-            errout.str());
+            "[test.cpp:5:9]: (warning) Member variable 'LocalClass::bitsInData_' is not initialized in the constructor. [uninitMemberVar]\n",
+            errout_str());
     }
 
     void uninitVar21() { // ticket #2947
@@ -2189,7 +2707,7 @@ class TestConstructors : public TestFixture {
               "Fred::Fred() {\n"
               "    a[x::y] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVar22() { // ticket #3043
@@ -2206,7 +2724,7 @@ class TestConstructors : public TestFixture {
               "    x = 0;\n"
               "    return *this;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Fred {\n"
               "  public:\n"
@@ -2220,7 +2738,7 @@ class TestConstructors : public TestFixture {
               "Fred & Fred::clone(const Fred & other) {\n"
               "    return *this;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (warning) Member variable 'Fred::x' is not assigned a value in 'Fred::operator='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:14]: (warning) Member variable 'Fred::x' is not assigned a value in 'Fred::operator='. [operatorEqVarError]\n", errout_str());
     }
 
     void uninitVar23() { // ticket #3702
@@ -2237,13 +2755,12 @@ class TestConstructors : public TestFixture {
               "Fred::Fred(struct C c, D d) { }\n"
               "Fred::Fred(E e, struct F f) { }\n"
               "Fred::Fred(G g, H h) { }\n"
-              "Fred::Fred(struct I i, struct J j) { }\n"
-             );
-        ASSERT_EQUALS("[test.cpp:10]: (warning) Member variable 'Fred::x' is not initialized in the constructor.\n"
-                      "[test.cpp:11]: (warning) Member variable 'Fred::x' is not initialized in the constructor.\n"
-                      "[test.cpp:12]: (warning) Member variable 'Fred::x' is not initialized in the constructor.\n"
-                      "[test.cpp:13]: (warning) Member variable 'Fred::x' is not initialized in the constructor.\n"
-                      "[test.cpp:14]: (warning) Member variable 'Fred::x' is not initialized in the constructor.\n", errout.str());
+              "Fred::Fred(struct I i, struct J j) { }");
+        ASSERT_EQUALS("[test.cpp:10:7]: (warning) Member variable 'Fred::x' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:11:7]: (warning) Member variable 'Fred::x' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:12:7]: (warning) Member variable 'Fred::x' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:13:7]: (warning) Member variable 'Fred::x' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:14:7]: (warning) Member variable 'Fred::x' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void uninitVar24() { // ticket #3190
@@ -2269,11 +2786,11 @@ class TestConstructors : public TestFixture {
               "::Foo::Sub::Sub() { }\n"
               "class Foo;\n"
               "class Bar;\n"
-              "class Sub;\n", true);
+              "class Sub;\n", dinit(CheckOptions, $.inconclusive = true));
 
-        ASSERT_EQUALS("[test.cpp:9]: (warning, inconclusive) Member variable 'Sub::b' is not initialized in the constructor.\n"
-                      "[test.cpp:12]: (warning) Member variable 'Sub::b' is not initialized in the constructor.\n"
-                      "[test.cpp:20]: (warning) Member variable 'Sub::f' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:5]: (warning, inconclusive) Member variable 'Sub::b' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:12:11]: (warning) Member variable 'Sub::b' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:20:13]: (warning) Member variable 'Sub::f' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void uninitVar25() { // ticket #4789
@@ -2283,60 +2800,60 @@ class TestConstructors : public TestFixture {
               "    int c;\n"
               "    A(int x = 0, int y = 0, int z = 0);\n"
               "};\n"
-              "A::A(int x = 0, int y = 0, int z = 0) { } \n"
+              "A::A(int x = 0, int y = 0, int z = 0) { }\n"
               "struct B {\n"
               "    int a;\n"
               "    int b;\n"
               "    int c;\n"
               "    B(int x = 0, int y = 0, int z = 0);\n"
               "};\n"
-              "B::B(int x, int y, int z) { } \n"
+              "B::B(int x, int y, int z) { }\n"
               "struct C {\n"
               "    int a;\n"
               "    int b;\n"
               "    int c;\n"
               "    C(int, int, int);\n"
               "};\n"
-              "C::C(int x = 0, int y = 0, int z = 0) { } \n"
+              "C::C(int x = 0, int y = 0, int z = 0) { }\n"
               "struct D {\n"
               "    int a;\n"
               "    int b;\n"
               "    int c;\n"
               "    D(int, int, int);\n"
               "};\n"
-              "D::D(int x, int y, int z) { } \n"
+              "D::D(int x, int y, int z) { }\n"
               "struct E {\n"
               "    int a;\n"
               "    int b;\n"
               "    int c;\n"
               "    E(int x, int y, int z);\n"
               "};\n"
-              "E::E(int, int, int) { } \n"
+              "E::E(int, int, int) { }\n"
               "struct F {\n"
               "    int a;\n"
               "    int b;\n"
               "    int c;\n"
               "    F(int x = 0, int y = 0, int z = 0);\n"
               "};\n"
-              "F::F(int, int, int) { }\n", true);
-        ASSERT_EQUALS("[test.cpp:7]: (warning) Member variable 'A::a' is not initialized in the constructor.\n"
-                      "[test.cpp:7]: (warning) Member variable 'A::b' is not initialized in the constructor.\n"
-                      "[test.cpp:7]: (warning) Member variable 'A::c' is not initialized in the constructor.\n"
-                      "[test.cpp:14]: (warning) Member variable 'B::a' is not initialized in the constructor.\n"
-                      "[test.cpp:14]: (warning) Member variable 'B::b' is not initialized in the constructor.\n"
-                      "[test.cpp:14]: (warning) Member variable 'B::c' is not initialized in the constructor.\n"
-                      "[test.cpp:21]: (warning) Member variable 'C::a' is not initialized in the constructor.\n"
-                      "[test.cpp:21]: (warning) Member variable 'C::b' is not initialized in the constructor.\n"
-                      "[test.cpp:21]: (warning) Member variable 'C::c' is not initialized in the constructor.\n"
-                      "[test.cpp:28]: (warning) Member variable 'D::a' is not initialized in the constructor.\n"
-                      "[test.cpp:28]: (warning) Member variable 'D::b' is not initialized in the constructor.\n"
-                      "[test.cpp:28]: (warning) Member variable 'D::c' is not initialized in the constructor.\n"
-                      "[test.cpp:35]: (warning) Member variable 'E::a' is not initialized in the constructor.\n"
-                      "[test.cpp:35]: (warning) Member variable 'E::b' is not initialized in the constructor.\n"
-                      "[test.cpp:35]: (warning) Member variable 'E::c' is not initialized in the constructor.\n"
-                      "[test.cpp:42]: (warning) Member variable 'F::a' is not initialized in the constructor.\n"
-                      "[test.cpp:42]: (warning) Member variable 'F::b' is not initialized in the constructor.\n"
-                      "[test.cpp:42]: (warning) Member variable 'F::c' is not initialized in the constructor.\n", errout.str());
+              "F::F(int, int, int) { }\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:7:4]: (warning) Member variable 'A::a' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:7:4]: (warning) Member variable 'A::b' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:7:4]: (warning) Member variable 'A::c' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:14:4]: (warning) Member variable 'B::a' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:14:4]: (warning) Member variable 'B::b' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:14:4]: (warning) Member variable 'B::c' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:21:4]: (warning) Member variable 'C::a' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:21:4]: (warning) Member variable 'C::b' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:21:4]: (warning) Member variable 'C::c' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:28:4]: (warning) Member variable 'D::a' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:28:4]: (warning) Member variable 'D::b' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:28:4]: (warning) Member variable 'D::c' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:35:4]: (warning) Member variable 'E::a' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:35:4]: (warning) Member variable 'E::b' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:35:4]: (warning) Member variable 'E::c' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:42:4]: (warning) Member variable 'F::a' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:42:4]: (warning) Member variable 'F::b' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:42:4]: (warning) Member variable 'F::c' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void uninitVar26() {
@@ -2348,7 +2865,7 @@ class TestConstructors : public TestFixture {
               "        v = new int [sz = s];\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVar27() {
@@ -2359,7 +2876,7 @@ class TestConstructors : public TestFixture {
               "        rtl::math::setNan(&d);\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("class A {\n"
               "    double d;\n"
               "public:\n"
@@ -2367,7 +2884,7 @@ class TestConstructors : public TestFixture {
               "        ::rtl::math::setNan(&d);\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVar28() {
@@ -2382,7 +2899,7 @@ class TestConstructors : public TestFixture {
               "    void foo(int a) { i = a; }\n"
               "    void foo(float a) { f = a; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVar29() {
@@ -2414,8 +2931,8 @@ class TestConstructors : public TestFixture {
               "	void foo() { }\n"
               "	void foo() const { i = 0; }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:18]: (warning) Member variable 'C::i' is not initialized in the constructor.\n"
-                      "[test.cpp:25]: (warning) Member variable 'D::i' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:18:5]: (warning) Member variable 'C::i' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:25:5]: (warning) Member variable 'D::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void uninitVar30() { // ticket #6417
@@ -2430,8 +2947,8 @@ class TestConstructors : public TestFixture {
               "}\n"
               "using namespace NS;\n"
               "MyClass::~MyClass() { }\n"
-              "MyClass::MyClass() : SomeVar(false) { }\n");
-        ASSERT_EQUALS("", errout.str());
+              "MyClass::MyClass() : SomeVar(false) { }");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVar31() { // ticket #8271
@@ -2448,8 +2965,8 @@ class TestConstructors : public TestFixture {
               "}\n"
               "void MyClass::Restart() {\n"
               "    m_retCode = 0;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVar32() { // ticket #8835
@@ -2461,8 +2978,8 @@ class TestConstructors : public TestFixture {
               "   {\n"
               "      if (1) {}\n"
               "   }\n"
-              "};\n");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Member variable 'Foo::member' is not initialized in the constructor.\n", errout.str());
+              "};");
+        ASSERT_EQUALS("[test.cpp:5:4]: (warning) Member variable 'Foo::member' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
         check("class Foo {\n"
               "   friend class Bar;\n"
               "   int member;\n"
@@ -2471,8 +2988,8 @@ class TestConstructors : public TestFixture {
               "   {\n"
               "      while (1) {}\n"
               "   }\n"
-              "};\n");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Member variable 'Foo::member' is not initialized in the constructor.\n", errout.str());
+              "};");
+        ASSERT_EQUALS("[test.cpp:5:4]: (warning) Member variable 'Foo::member' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
         check("class Foo {\n"
               "   friend class Bar;\n"
               "   int member;\n"
@@ -2481,8 +2998,60 @@ class TestConstructors : public TestFixture {
               "   {\n"
               "      for (;;) {}\n"
               "   }\n"
+              "};");
+        ASSERT_EQUALS("[test.cpp:5:4]: (warning) Member variable 'Foo::member' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
+    }
+
+    void uninitVar33() { // ticket #10295
+        check("namespace app {\n"
+              "    class B {\n"
+              "    public:\n"
+              "        B(void);\n"
+              "        int x;\n"
+              "    };\n"
+              "};\n"
+              "app::B::B(void){}");
+        ASSERT_EQUALS("[test.cpp:8:9]: (warning) Member variable 'B::x' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
+    }
+
+    void uninitVar34() { // ticket #10841
+        check("struct A { void f() {} };\n"
+              "struct B {\n"
+              "    B() { a->f(); }\n"
+              "    A* a;\n"
               "};\n");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Member variable 'Foo::member' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Member variable 'B::a' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
+    }
+
+    void uninitVar35() {
+        check("struct S {\n" // #12908
+              "    int a, b;\n"
+              "    explicit S(int h = 0);\n"
+              "    S(S&& s) : a(s.a), b(a.b) {\n"
+              "        s.a = 0;\n"
+              "    }\n"
+              "};\n"
+              "S::S(int h) : a(h), b(0) {}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void uninitVar36() {
+        check("struct S {\n"
+              "    unsigned int a : 16;\n"
+              "    unsigned int   : 8;\n"
+              "    unsigned int b : 8;\n"
+              "    S() : a(0) {}\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) Member variable 'S::b' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
+    }
+
+    void uninitVar37() {
+        const Settings s = settingsBuilder(settings).library("std.cfg").build();
+        check("struct C {\n" // #13989
+              "    C() = default;\n"
+              "    std::list<int>::const_iterator it;\n"
+              "};\n", s);
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning) Member variable 'C::it' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void uninitVarArray1() {
@@ -2494,7 +3063,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    char name[255];\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'John::name' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'John::name' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("class John\n"
               "{\n"
@@ -2504,7 +3073,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    char name[255];\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class John\n"
               "{\n"
@@ -2514,7 +3083,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    char name[255];\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class John\n"
               "{\n"
@@ -2523,7 +3092,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "    double  operator[](const unsigned long i);\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class A;\n"
               "class John\n"
@@ -2532,7 +3101,7 @@ class TestConstructors : public TestFixture {
               "    John() { }\n"
               "    A a[5];\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class A;\n"
               "class John\n"
@@ -2541,7 +3110,7 @@ class TestConstructors : public TestFixture {
               "    John() { }\n"
               "    A (*a)[5];\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Member variable 'John::a' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) Member variable 'John::a' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void uninitVarArray2() {
@@ -2553,7 +3122,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    char name[255];\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #5754
         check("class John\n"
@@ -2564,7 +3133,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    char name[255];\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVarArray3() {
@@ -2581,7 +3150,7 @@ class TestConstructors : public TestFixture {
               "        memset(b,0,sizeof(b));\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVarArray4() {
@@ -2598,7 +3167,7 @@ class TestConstructors : public TestFixture {
               "        if (snprintf(b,10,\"b\")) { }\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVarArray5() {
@@ -2610,7 +3179,7 @@ class TestConstructors : public TestFixture {
               "    Foo()\n"
               "    { }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVarArray6() {
@@ -2622,7 +3191,7 @@ class TestConstructors : public TestFixture {
               "};\n"
               "const char Foo::STR[] = \"abc\";\n"
               "Foo::Foo() { }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVarArray7() {
@@ -2632,7 +3201,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Foo() { }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Member variable 'Foo::array' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) Member variable 'Foo::array' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("class Foo\n"
               "{\n"
@@ -2640,7 +3209,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Foo() { memset(array, 0, sizeof(array)); }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Foo\n"
               "{\n"
@@ -2648,7 +3217,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Foo() { ::memset(array, 0, sizeof(array)); }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVarArray8() {
@@ -2657,7 +3226,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Foo() { ::ZeroMemory(a); }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVarArray9() { // #6957
@@ -2668,7 +3237,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    IxExprListT() {}\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'IxExprListT::eArr' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:5]: (warning) Member variable 'IxExprListT::eArr' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
         check("struct sRAIUnitDefBL {\n"
               "  sRAIUnitDefBL();\n"
               "  ~sRAIUnitDefBL();\n"
@@ -2677,7 +3246,42 @@ class TestConstructors : public TestFixture {
               "  sRAIUnitDef() {}\n"
               "  sRAIUnitDefBL *List[35];\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'sRAIUnitDef::List' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:3]: (warning) Member variable 'sRAIUnitDef::List' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
+    }
+
+    void uninitVarArray10() { // #11650
+        const Settings s = settingsBuilder(settings).library("std.cfg").build();
+        check("struct T { int j; };\n"
+              "struct U { int k{}; };\n"
+              "struct S {\n"
+              "    std::array<int, 2> a;\n"
+              "    std::array<T, 2> b;\n"
+              "    std::array<std::size_t, 2> c;\n"
+              "    std::array<clock_t, 2> d;\n"
+              "    std::array<std::string, 2> e;\n"
+              "    std::array<U, 2> f;\n"
+              "S() {}\n"
+              "};\n", s);
+
+        ASSERT_EQUALS("[test.cpp:10:1]: (warning) Member variable 'S::a' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:10:1]: (warning) Member variable 'S::b' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:10:1]: (warning) Member variable 'S::c' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:10:1]: (warning) Member variable 'S::d' is not initialized in the constructor. [uninitMemberVar]\n",
+                      errout_str());
+    }
+
+    void uninitVarArray11() {
+        check("class C {\n" // #12150
+              "private:\n"
+              "    int buf[10];\n"
+              "public:\n"
+              "    C() {\n"
+              "        for (int& i : buf)\n"
+              "            i = 0;\n"
+              "    }\n"
+              "};\n");
+
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVarArray2D() {
@@ -2689,7 +3293,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    char a[2][2];\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVarArray3D() {
@@ -2700,7 +3304,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    John() { a[0][0][0] = 0; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVarCpp11Init1() {
@@ -2711,7 +3315,7 @@ class TestConstructors : public TestFixture {
               "        : bar({\"a\", \"b\"})\n"
               "    {}\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVarCpp11Init2() {
@@ -2727,7 +3331,7 @@ class TestConstructors : public TestFixture {
               "    float get() const;\n"
               "};\n"
               "float Fred::get() const { return g; }");
-        ASSERT_EQUALS("[test.cpp:9]: (warning) Member variable 'Fred::g' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:5]: (warning) Member variable 'Fred::g' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void uninitVarStruct1() { // ticket #2172
@@ -2743,7 +3347,7 @@ class TestConstructors : public TestFixture {
               "    A() {\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class A\n"
               "{\n"
@@ -2757,7 +3361,7 @@ class TestConstructors : public TestFixture {
               "    A() {\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:10]: (warning) Member variable 'A::b' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:5]: (warning) Member variable 'A::b' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("class A\n"
               "{\n"
@@ -2772,7 +3376,7 @@ class TestConstructors : public TestFixture {
               "    A() {\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVarStruct2() { // ticket #838
@@ -2789,7 +3393,7 @@ class TestConstructors : public TestFixture {
               "    Fred()\n"
               "    { }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:11]: (warning) Member variable 'Fred::p' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:11:5]: (warning) Member variable 'Fred::p' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("struct POINT\n"
               "{\n"
@@ -2805,7 +3409,7 @@ class TestConstructors : public TestFixture {
               "    Fred()\n"
               "    { }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct POINT\n"
               "{\n"
@@ -2821,7 +3425,7 @@ class TestConstructors : public TestFixture {
               "    Fred()\n"
               "    { }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // non static data-member initialization
         check("struct POINT\n"
@@ -2837,11 +3441,11 @@ class TestConstructors : public TestFixture {
               "    Fred()\n"
               "    { }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void uninitVarUnion1() { // ticket #3196
-        check("class Fred\n"
+    void uninitVarUnion1() {
+        check("class Fred\n" // ticket #3196
               "{\n"
               "private:\n"
               "    union { int a; int b; };\n"
@@ -2849,13 +3453,16 @@ class TestConstructors : public TestFixture {
               "    Fred()\n"
               "    { a = 0; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("class Fred {\n"
+              "private:\n"
+              "    union { int a{}; int b; };\n"
+              "};");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVarUnion2() {
-        // If the "data_type" is 0 it means union member "data" is invalid.
-        // So it's ok to not initialize "data".
-        // related forum: http://sourceforge.net/apps/phpbb/cppcheck/viewtopic.php?f=3&p=1806
         check("union Data { int id; int *ptr; };\n"
               "\n"
               "class Fred {\n"
@@ -2866,7 +3473,7 @@ class TestConstructors : public TestFixture {
               "    Fred() : data_type(0)\n"
               "    { }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:5]: (warning) Member variable 'Fred::data' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void uninitMissingFuncDef() {
@@ -2879,7 +3486,7 @@ class TestConstructors : public TestFixture {
               "    void Init();"
               "    int i;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Unknown non-member function (friend class)
         check("class Fred\n"
@@ -2890,7 +3497,7 @@ class TestConstructors : public TestFixture {
               "    friend ABC;\n"
               "    int i;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Unknown non-member function (is Init a virtual function?)
         check("class Fred : private ABC\n"
@@ -2900,7 +3507,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    int i;\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         // Unknown non-member function
         check("class Fred\n"
@@ -2910,7 +3517,7 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    int i;\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         // Unknown non-member function
         check("class ABC { };\n"
@@ -2921,8 +3528,40 @@ class TestConstructors : public TestFixture {
               "private:\n"
               "    int i;\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
+        // Unknown member functions and unknown static functions
+        check("class ABC {\n"
+              "  static void static_base_func();\n"
+              "  void const_base_func() const;\n"
+              "};\n"
+              "class Fred : private ABC {\n"
+              "public:\n"
+              "    Fred() {\n"
+              "        const_func();\n"
+              "        static_func();\n"
+              "        const_base_func();\n"
+              "        ABC::static_base_func();\n"
+              "    }\n"
+              "    void const_func() const;\n"
+              "    static void static_f();\n"
+              "private:\n"
+              "    int i;\n"
+              "};");
+        ASSERT_EQUALS("[test.cpp:7:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
+
+        // Unknown overloaded member functions
+        check("class Fred : private ABC {\n"
+              "public:\n"
+              "    Fred() {\n"
+              "        func();\n"
+              "    }\n"
+              "    void func() const;\n"
+              "    void func();\n"
+              "private:\n"
+              "    int i;\n"
+              "};");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVarEnum1() {
@@ -2935,7 +3574,7 @@ class TestConstructors : public TestFixture {
               "    unsigned int i;\n"
               "};");
 
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) Member variable 'Fred::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void uninitVarEnum2() { // ticket #8146
@@ -2946,7 +3585,7 @@ class TestConstructors : public TestFixture {
               "    X x;\n"
               "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVarStream() {
@@ -2962,7 +3601,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVarTypedef() {
@@ -2974,7 +3613,7 @@ class TestConstructors : public TestFixture {
               "    pointer a;\n"
               "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVarMemset() {
@@ -2985,7 +3624,7 @@ class TestConstructors : public TestFixture {
               "    Foo() { memset(this, 0, sizeof(*this)); }\n"
               "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Foo\n"
               "{\n"
@@ -2994,7 +3633,7 @@ class TestConstructors : public TestFixture {
               "    Foo() { ::memset(this, 0, sizeof(*this)); }\n"
               "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #7068
         check("struct Foo {\n"
@@ -3002,13 +3641,13 @@ class TestConstructors : public TestFixture {
               "    char c;\n"
               "    Foo() { memset(p, 0, sizeof(int)); }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Foo::c' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Foo::c' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
         check("struct Foo {\n"
               "    int i;\n"
               "    char c;\n"
               "    Foo() { memset(&i, 0, sizeof(int)); }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Foo::c' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Foo::c' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
         check("struct Foo { int f; };\n"
               "struct Bar { int b; };\n"
               "struct FooBar {\n"
@@ -3022,7 +3661,7 @@ class TestConstructors : public TestFixture {
               "  FooBar foobar;\n"
               "  return foobar.foo.f + foobar.bar.b;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'FooBar::bar' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:3]: (warning) Member variable 'FooBar::bar' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
         check("struct Foo { int f; };\n"
               "struct Bar { int b; };\n"
               "struct FooBar {\n"
@@ -3036,7 +3675,7 @@ class TestConstructors : public TestFixture {
               "  FooBar foobar;\n"
               "  return foobar.foo.f + foobar.bar.b;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'FooBar::bar' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:3]: (warning) Member variable 'FooBar::bar' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         // #7755
         check("struct A {\n"
@@ -3045,23 +3684,27 @@ class TestConstructors : public TestFixture {
               "  }\n"
               "  char data[42];\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void privateCtor1() {
-        settings.standards.cpp = Standards::CPP03;
-        check("class Foo {\n"
-              "    int foo;\n"
-              "    Foo() { }\n"
-              "};");
-        ASSERT_EQUALS("", errout.str());
-
-        settings.standards.cpp = Standards::CPP11;
-        check("class Foo {\n"
-              "    int foo;\n"
-              "    Foo() { }\n"
-              "};");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Member variable 'Foo::foo' is not initialized in the constructor.\n", errout.str());
+        {
+            const Settings s = settingsBuilder(settings).cpp(Standards::CPP03).build();
+            check("class Foo {\n"
+                  "    int foo;\n"
+                  "    Foo() { }\n"
+                  "};", s);
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        {
+            const Settings s = settingsBuilder(settings).cpp(Standards::CPP11).build();
+            check("class Foo {\n"
+                  "    int foo;\n"
+                  "    Foo() { }\n"
+                  "};", s);
+            ASSERT_EQUALS("[test.cpp:3:5]: (warning) Member variable 'Foo::foo' is not initialized in the constructor. [uninitMemberVarPrivate]\n", errout_str());
+        }
     }
 
     void privateCtor2() {
@@ -3074,7 +3717,7 @@ class TestConstructors : public TestFixture {
               "    explicit Foo(int _i) { }\n"
               "};");
 
-        ASSERT_EQUALS("[test.cpp:7]: (warning) Member variable 'Foo::foo' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:14]: (warning) Member variable 'Foo::foo' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
 
@@ -3095,7 +3738,7 @@ class TestConstructors : public TestFixture {
               "    return p;\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -3108,7 +3751,21 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "    Fred() { }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void uninitVarInheritClassInit() {
+        // TODO: test should probably not pass without library
+        const Settings s = settingsBuilder() /*.library("vcl.cfg")*/.build();
+
+        check("class Fred: public TObject\n"
+              "{\n"
+              "public:\n"
+              "    Fred() { }\n"
+              "private:\n"
+              "    int x;\n"
+              "};", s);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitOperator() {
@@ -3118,7 +3775,7 @@ class TestConstructors : public TestFixture {
               "    Fred() { }\n"
               "    int *operator [] (int index) { return 0; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitFunction1() {
@@ -3132,7 +3789,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "    double d;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
               "{\n"
@@ -3144,7 +3801,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "    double d;\n"
               "};");
-        TODO_ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Fred::d' is not initialized in the constructor.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Fred::d' is not initialized in the constructor. [uninitMemberVar]\n", "", errout_str());
     }
 
     void uninitFunction2() {
@@ -3158,7 +3815,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "    double d;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
               "{\n"
@@ -3170,7 +3827,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "    double d;\n"
               "};");
-        TODO_ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Fred::d' is not initialized in the constructor.\n", "",  errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Fred::d' is not initialized in the constructor. [uninitMemberVar]\n", "",  errout_str());
     }
 
     void uninitFunction3() {
@@ -3184,7 +3841,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "    double d;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
               "{\n"
@@ -3196,7 +3853,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "    double d;\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Fred::d' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Fred::d' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void uninitFunction4() {
@@ -3210,7 +3867,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "    double d;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
               "{\n"
@@ -3222,7 +3879,7 @@ class TestConstructors : public TestFixture {
               "\n"
               "    double d;\n"
               "};");
-        TODO_ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'Fred::d' is not initialized in the constructor.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'Fred::d' is not initialized in the constructor. [uninitMemberVar]\n", "", errout_str());
     }
 
     void uninitFunction5() { // #4072 - FP about struct that is initialized in function
@@ -3236,7 +3893,19 @@ class TestConstructors : public TestFixture {
               "    A() { Init( B ); };\n"
               "    void Init( Structure& S ) { S.C = 0; };\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct Structure {\n"
+              "    int C;\n"
+              "};\n"
+              "\n"
+              "class A {\n"
+              "    Structure B;\n"
+              "public:\n"
+              "    A() { Init( B ); };\n"
+              "    void Init(const Structure& S) { }\n"
+              "};");
+        ASSERT_EQUALS("[test.cpp:8:5]: (warning) Member variable 'A::B' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
     }
 
     void uninitSameClassName() {
@@ -3261,7 +3930,7 @@ class TestConstructors : public TestFixture {
               "{\n"
               "    i = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class B\n"
               "{\n"
@@ -3287,8 +3956,8 @@ class TestConstructors : public TestFixture {
               "A::B::B()\n"
               "{\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:18]: (warning) Member variable 'B::j' is not initialized in the constructor.\n"
-                      "[test.cpp:22]: (warning) Member variable 'B::i' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:18:4]: (warning) Member variable 'B::j' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:22:7]: (warning) Member variable 'B::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         // Ticket #1700
         check("namespace n1\n"
@@ -3308,7 +3977,7 @@ class TestConstructors : public TestFixture {
               "    Foo() { }\n"
               "};\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("namespace n1\n"
               "{\n"
@@ -3330,7 +3999,7 @@ class TestConstructors : public TestFixture {
               "    Foo() { }\n"
               "};\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:11]: (warning) Member variable 'Foo::i' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:11:10]: (warning) Member variable 'Foo::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("namespace n1\n"
               "{\n"
@@ -3352,7 +4021,7 @@ class TestConstructors : public TestFixture {
               "    Foo() { }\n"
               "};\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitFunctionOverload() {
@@ -3373,7 +4042,7 @@ class TestConstructors : public TestFixture {
               "    void init(int value)\n"
               "    { i = value; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class A\n"
               "{\n"
@@ -3391,7 +4060,19 @@ class TestConstructors : public TestFixture {
               "    void init(int value)\n"
               "    { }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:7]: (warning) Member variable 'A::i' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:5]: (warning) Member variable 'A::i' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
+
+        check("class bar {\n" // #9887
+              "    int length;\n"
+              "    bar() { length = 0; }\n"
+              "};\n"
+              "class foo {\n"
+              "    int x;\n"
+              "    foo() { Set(bar()); }\n"
+              "    void Set(int num) { x = 1; }\n"
+              "    void Set(bar num) { x = num.length; }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitVarOperatorEqual() { // ticket #2415
@@ -3400,7 +4081,7 @@ class TestConstructors : public TestFixture {
               "    A() { a=0; }\n"
               "    A(A const &a) { operator=(a); }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
               "    int a;\n"
@@ -3411,7 +4092,7 @@ class TestConstructors : public TestFixture {
               "        return *this;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
               "    int a;\n"
@@ -3421,8 +4102,8 @@ class TestConstructors : public TestFixture {
               "        return *this;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'A::a' is not initialized in the constructor.\n"
-                      "[test.cpp:5]: (warning) Member variable 'A::a' is not assigned a value in 'A::operator='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'A::a' is not initialized in the copy constructor. [uninitMemberVar]\n"
+                      "[test.cpp:5:9]: (warning) Member variable 'A::a' is not assigned a value in 'A::operator='. [operatorEqVarError]\n", errout_str());
     }
 
     void uninitVarPointer() { // #3801
@@ -3433,28 +4114,69 @@ class TestConstructors : public TestFixture {
               "    A* a;\n"
               "    B() { }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:6]: (warning) Member variable 'B::a' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:5]: (warning) Member variable 'B::a' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("struct A;\n"
               "struct B {\n"
               "    A* a;\n"
               "    B() { }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'B::a' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'B::a' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("struct A;\n"
               "struct B {\n"
               "    const A* a;\n"
               "    B() { }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'B::a' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'B::a' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("struct A;\n"
               "struct B {\n"
               "    A* const a;\n"
               "    B() { }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'B::a' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'B::a' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
+
+        check("class Test {\n" // #8498
+              "public:\n"
+              "    Test() {}\n"
+              "    std::map<int, int>* pMap = nullptr;\n"
+              "    std::string* pStr = nullptr;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("template <typename U>\n"
+              "class C1 {}; \n"
+              "template <typename U, typename V>\n"
+              "class C2 {};\n"
+              "namespace A {\n"
+              "    template <typename U>\n"
+              "    class D1 {};\n"
+              "    template <typename U, typename V>\n"
+              "    class D2 {};\n"
+              "}\n"
+              "class Test {\n"
+              "public:\n"
+              "    Test() {}\n"
+              "    C1<int>* c1 = nullptr;\n"
+              "    C2<int, int >* c2 = nullptr;\n"
+              "    A::D1<int>* d1 = nullptr;\n"
+              "    A::D2<int, int >* d2 = nullptr;\n"
+              "    std::map<int, int>* pMap = nullptr;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #6294
+              "    S() : r(new int) {\n"
+              "        *p = 0;\n"
+              "        *(q) = 1;\n"
+              "        *r = 2;\n"
+              "    }\n"
+              "    int *p, *q, *r;\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning) Member variable 'S::p' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:2:5]: (warning) Member variable 'S::q' is not initialized in the constructor. [uninitMemberVar]\n",
+                      errout_str());
     }
 
     void uninitConstVar() {
@@ -3464,29 +4186,29 @@ class TestConstructors : public TestFixture {
               "    B() { }\n"
               "    B(B& b) { }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Member variable 'B::a' is not initialized in the constructor.\n"
-                      "[test.cpp:5]: (warning) Member variable 'B::a' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Member variable 'B::a' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:5:5]: (warning) Member variable 'B::a' is not initialized in the copy constructor. [uninitMemberVar]\n", errout_str());
 
         check("struct A;\n"
               "struct B {\n"
               "    A* const a;\n"
               "    B& operator=(const B& r) { }\n"
               "};");
-        ASSERT_EQUALS("", errout.str()); // #3804
+        ASSERT_EQUALS("", errout_str()); // #3804
 
         check("struct B {\n"
               "    const int a;\n"
               "    B() { }\n"
               "    B(B& b) { }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Member variable 'B::a' is not initialized in the constructor.\n"
-                      "[test.cpp:4]: (warning) Member variable 'B::a' is not initialized in the constructor.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Member variable 'B::a' is not initialized in the constructor. [uninitMemberVar]\n"
+                      "[test.cpp:4:5]: (warning) Member variable 'B::a' is not initialized in the copy constructor. [uninitMemberVar]\n", errout_str());
 
         check("struct B {\n"
               "    const int a;\n"
               "    B& operator=(const B& r) { }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // Ticket #5641 "Regression. Crash for 'C() _STLP_NOTHROW {}'"
@@ -3495,8 +4217,8 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "  C() _STLP_NOTHROW {}\n"
               "  C(const C&) _STLP_NOTHROW {}\n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void classWithOperatorInName() { // ticket #2827
@@ -3505,7 +4227,7 @@ class TestConstructors : public TestFixture {
               "public:\n"
               "  operatorX() : mValue(0) {}\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void templateConstructor() { // ticket #7942
@@ -3515,7 +4237,7 @@ class TestConstructors : public TestFixture {
               "};\n"
               "template <class T> Container<T>::Container() : mElements(nullptr) {}\n"
               "Container<int> intContainer;");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void typedefArray() { // ticket #5766
@@ -3525,7 +4247,7 @@ class TestConstructors : public TestFixture {
               "    SelectionPosition() {}\n"
               "    const rvec &x() const;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitAssignmentWithOperator() {
@@ -3539,9 +4261,9 @@ class TestConstructors : public TestFixture {
               "        x = 1;\n"
               "        return true;\n"
               "    }\n"
-              "};", true);
+              "};", dinit(CheckOptions, $.inconclusive = true));
         TODO_ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) Member variable 'C::x' is not initialized in the constructor.\n",
-                           "[test.cpp:3]: (warning) Member variable 'C::x' is not initialized in the constructor.\n", errout.str());
+                           "[test.cpp:3:5]: (warning) Member variable 'C::x' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3553,9 +4275,9 @@ class TestConstructors : public TestFixture {
               "        x = 1;\n"
               "        return true;\n"
               "    }\n"
-              "};", true);
+              "};", dinit(CheckOptions, $.inconclusive = true));
         TODO_ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) Member variable 'C::x' is not initialized in the constructor.\n",
-                           "[test.cpp:3]: (warning) Member variable 'C::x' is not initialized in the constructor.\n", errout.str());
+                           "[test.cpp:3:5]: (warning) Member variable 'C::x' is not initialized in the constructor. [uninitMemberVar]\n", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3568,7 +4290,7 @@ class TestConstructors : public TestFixture {
               "        return true;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3581,7 +4303,7 @@ class TestConstructors : public TestFixture {
               "        return true;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3591,7 +4313,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3601,7 +4323,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3611,7 +4333,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3621,7 +4343,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3631,7 +4353,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3641,7 +4363,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3651,7 +4373,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3661,7 +4383,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitCompoundAssignment() {
@@ -3676,7 +4398,7 @@ class TestConstructors : public TestFixture {
               "        return true;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3689,7 +4411,7 @@ class TestConstructors : public TestFixture {
               "        return true;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3699,7 +4421,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3709,7 +4431,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3719,7 +4441,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3729,7 +4451,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3739,7 +4461,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3749,7 +4471,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3759,7 +4481,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3769,7 +4491,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitComparisonAssignment() {
@@ -3784,7 +4506,7 @@ class TestConstructors : public TestFixture {
               "        return true;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3797,7 +4519,7 @@ class TestConstructors : public TestFixture {
               "        return true;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3806,7 +4528,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3815,7 +4537,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3824,7 +4546,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct C {\n"
               "    int x;\n"
@@ -3833,7 +4555,7 @@ class TestConstructors : public TestFixture {
               "    }\n"
               "    int SetValue() { return x = 1; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitTemplate1() {
@@ -3850,8 +4572,8 @@ class TestConstructors : public TestFixture {
               "class C {\n"
               "  private:\n"
               "    A* b;\n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
 
         check("template<class T> class A{};\n"
               "template<class T1, class T2> class B{};\n"
@@ -3862,9 +4584,29 @@ class TestConstructors : public TestFixture {
               "    bool m_value;\n"
               "};\n"
               "template<class T1, class T2>\n"
-              "A<B<T1, T2>>::A() : m_value(false) {}\n");
-        ASSERT_EQUALS("", errout.str());
+              "A<B<T1, T2>>::A() : m_value(false) {}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("template <typename T> struct S;\n" // #11177
+              "template <> struct S<void> final {\n"
+              "    explicit S(int& i);\n"
+              "    int& m;\n"
+              "};\n"
+              "S<void>::S(int& i) : m(i) {}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void unknownTemplateType() {
+        check("template <typename T> class A {\n"
+              "private:\n"
+              "    T m;\n"
+              "public:\n"
+              "    A& operator=() { return *this; }\n"
+              "};\n"
+              "A<decltype(SOMETHING)> a;");
+        ASSERT_EQUALS("", errout_str());
     }
+
 };
 
 REGISTER_TEST(TestConstructors)
diff --git a/test/testcppcheck.cpp b/test/testcppcheck.cpp
index 64de5a67731..84db6db6c28 100644
--- a/test/testcppcheck.cpp
+++ b/test/testcppcheck.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,75 +16,87 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "check.h"
+#include "addoninfo.h"
+#include "color.h"
 #include "cppcheck.h"
 #include "errorlogger.h"
-#include "testsuite.h"
+#include "errortypes.h"
+#include "filesettings.h"
+#include "fixture.h"
+#include "helpers.h"
+#include "path.h"
+#include "preprocessor.h"
+#include "redirect.h"
+#include "settings.h"
+#include "standards.h"
+#include "suppressions.h"
 
 #include <algorithm>
+#include <cstdio>
+#include <cstdlib>
 #include <list>
 #include <string>
+#include <unordered_set>
+#include <utility>
+#include <vector>
 
+#include <simplecpp.h>
 
 class TestCppcheck : public TestFixture {
 public:
-    TestCppcheck() : TestFixture("TestCppcheck") {
-    }
+    TestCppcheck() : TestFixture("TestCppcheck") {}
 
 private:
+    const std::string templateFormat{"{file}:{line}:{column}: {severity}:{inconclusive:inconclusive:} {message} [{id}]"};
 
     class ErrorLogger2 : public ErrorLogger {
     public:
-        std::list<std::string> id;
+        std::list<std::string> ids;
+        std::list<ErrorMessage> errmsgs;
+
+    private:
+        void reportOut(const std::string & /*outmsg*/, Color /*c*/ = Color::Reset) override {}
 
-        void reportOut(const std::string & /*outmsg*/) OVERRIDE {
+        void reportErr(const ErrorMessage &msg) override {
+            ids.push_back(msg.id);
+            errmsgs.push_back(msg);
         }
 
-        void reportErr(const ErrorLogger::ErrorMessage &msg) OVERRIDE {
-            id.push_back(msg.id);
+        void reportMetric(const std::string &metric) override {
+            (void) metric;
         }
     };
 
-    void run() OVERRIDE {
-        TEST_CASE(instancesSorted);
-        TEST_CASE(classInfoFormat);
+    void run() override {
         TEST_CASE(getErrorMessages);
-    }
-
-    void instancesSorted() const {
-        for (std::list<Check *>::const_iterator i = Check::instances().begin(); i != Check::instances().end(); ++i) {
-            std::list<Check *>::const_iterator j = i;
-            ++j;
-            if (j != Check::instances().end()) {
-                ASSERT_EQUALS(true, (*i)->name() < (*j)->name());
-            }
-        }
-    }
-
-    void classInfoFormat() const {
-        for (std::list<Check *>::const_iterator i = Check::instances().begin(); i != Check::instances().end(); ++i) {
-            const std::string info = (*i)->classInfo();
-            if (!info.empty()) {
-                ASSERT('\n' != info[0]);         // No \n in the beginning
-                ASSERT('\n' == info.back());     // \n at end
-                if (info.size() > 1)
-                    ASSERT('\n' != info[info.length()-2]); // Only one \n at end
-            }
-        }
+        TEST_CASE(checkWithFile);
+        TEST_CASE(checkWithFileWithTools);
+        TEST_CASE(checkWithFileWithToolsNoCommand);
+        TEST_CASE(checkWithFS);
+        TEST_CASE(checkWithFSWithTools);
+        TEST_CASE(checkWithFSWithToolsNoCommand);
+        TEST_CASE(suppress_error_library);
+        TEST_CASE(unique_errors);
+        TEST_CASE(unique_errors_2);
+        TEST_CASE(isPremiumCodingStandardId);
+        TEST_CASE(getDumpFileContentsRawTokens);
+        TEST_CASE(getDumpFileContentsLibrary);
+        TEST_CASE(checkPlistOutput);
+        TEST_CASE(premiumResultsCache);
+        TEST_CASE(purgedConfiguration);
     }
 
     void getErrorMessages() const {
         ErrorLogger2 errorLogger;
-        CppCheck cppCheck(errorLogger, true);
-        cppCheck.getErrorMessages();
-        ASSERT(!errorLogger.id.empty());
+        CppCheck::getErrorMessages(errorLogger);
+        ASSERT(!errorLogger.ids.empty());
 
         // Check if there are duplicate error ids in errorLogger.id
         std::string duplicate;
-        for (std::list<std::string>::iterator it = errorLogger.id.begin();
-             it != errorLogger.id.end();
+        for (auto it = errorLogger.ids.cbegin();
+             it != errorLogger.ids.cend();
              ++it) {
-            if (std::find(errorLogger.id.begin(), it, *it) != it) {
+            if (std::find(errorLogger.ids.cbegin(), it, *it) != it) {
                 duplicate = "Duplicate ID: " + *it;
                 break;
             }
@@ -94,15 +106,524 @@ class TestCppcheck : public TestFixture {
         // Check for error ids from this class.
         bool foundPurgedConfiguration = false;
         bool foundTooManyConfigs = false;
-        for (const std::string & it : errorLogger.id) {
+        bool foundMissingInclude = false; // #11984
+        bool foundMissingIncludeSystem = false; // #11984
+        for (const std::string & it : errorLogger.ids) {
             if (it == "purgedConfiguration")
                 foundPurgedConfiguration = true;
             else if (it == "toomanyconfigs")
                 foundTooManyConfigs = true;
+            else if (it == "missingInclude")
+                foundMissingInclude = true;
+            else if (it == "missingIncludeSystem")
+                foundMissingIncludeSystem = true;
         }
         ASSERT(foundPurgedConfiguration);
         ASSERT(foundTooManyConfigs);
+        ASSERT(foundMissingInclude);
+        ASSERT(foundMissingIncludeSystem);
+    }
+
+    static std::string exename_(const std::string& exe)
+    {
+#ifdef _WIN32
+        return exe + ".exe";
+#else
+        return exe;
+#endif
+    }
+
+    CppCheck::ExecuteCmdFn getExecuteCommand(const std::string& fname, int& called) const
+    {
+        // cppcheck-suppress passedByValue - used as callback so we need to preserve the signature
+        // NOLINTNEXTLINE(performance-unnecessary-value-param) - used as callback so we need to preserve the signature
+        return [&](std::string exe, std::vector<std::string> args, std::string redirect, std::string& /*output*/) -> int {
+            ++called;
+            if (exe == exename_("clang-tidy"))
+            {
+                ASSERT_EQUALS(4, args.size());
+                ASSERT_EQUALS("-quiet", args[0]);
+                ASSERT_EQUALS("-checks=*,-clang-analyzer-*,-llvm*", args[1]);
+                ASSERT_EQUALS(fname, args[2]);
+                ASSERT_EQUALS("--", args[3]);
+                ASSERT_EQUALS("2>&1", redirect);
+                return EXIT_SUCCESS;
+            }
+            if (exe == exename_("python3"))
+            {
+                ASSERT_EQUALS(1, args.size());
+                ASSERT_EQUALS("--version", args[0]);
+                ASSERT_EQUALS("2>&1", redirect);
+                return EXIT_SUCCESS;
+            }
+            if (exe == exename_("python"))
+            {
+                ASSERT_EQUALS(1, args.size());
+                ASSERT_EQUALS("--version", args[0]);
+                ASSERT_EQUALS("2>&1", redirect);
+                return EXIT_SUCCESS;
+            }
+            ASSERT_MSG(false, "unhandled exe: " + exe);
+            return EXIT_FAILURE;
+        };
+    }
+
+    void checkWithFileInternal(const std::string& fname, bool tools, bool nocmd = false) const
+    {
+        REDIRECT;
+        ScopedFile file(fname,
+                        "void f()\n"
+                        "{\n"
+                        "  (void)(*((int*)0));\n"
+                        "}");
+
+        int called = 0;
+        std::unordered_set<std::string> addons;
+        std::vector<AddonInfo> addonInfo;
+        if (tools)
+        {
+            addons.emplace("testcppcheck");
+            addonInfo.emplace_back(/*AddonInfo()*/);
+        }
+        const auto s = dinit(Settings,
+                             $.templateFormat = templateFormat,
+                                 $.clangTidy = tools,
+                                 $.addons = std::move (addons),
+                                 $.addonInfos = std::move (addonInfo));
+        Suppressions supprs;
+        ErrorLogger2 errorLogger;
+        CppCheck::ExecuteCmdFn f;
+        if (tools && !nocmd) {
+            f = getExecuteCommand(fname, called);
+        }
+        CppCheck cppcheck(s, supprs, errorLogger, nullptr, false, f);
+        ASSERT_EQUALS(1, cppcheck.check(FileWithDetails(file.path(), Path::identify(file.path(), false), 0)));
+        // TODO: how to properly disable these warnings?
+        errorLogger.ids.erase(std::remove_if(errorLogger.ids.begin(), errorLogger.ids.end(), [](const std::string& id) {
+            return id == "logChecker";
+        }), errorLogger.ids.end());
+        errorLogger.errmsgs.erase(std::remove_if(errorLogger.errmsgs.begin(), errorLogger.errmsgs.end(), [](const ErrorMessage& msg) {
+            return msg.id == "logChecker";
+        }), errorLogger.errmsgs.end());
+        if (tools)
+        {
+            ASSERT_EQUALS(2, errorLogger.ids.size());
+            auto it = errorLogger.errmsgs.cbegin();
+            ASSERT_EQUALS("nullPointer", it->id);
+            ++it;
+
+            if (nocmd)
+            {
+                ASSERT_EQUALS("internalError", it->id);
+                ASSERT_EQUALS("Bailing out from analysis: Checking file failed: Failed to execute addon - no command callback provided", it->shortMessage()); // TODO: add addon name
+
+                // TODO: clang-tidy is currently not invoked for file inputs - see #12053
+                // TODO: needs to become a proper error
+                TODO_ASSERT_EQUALS("Failed to execute '" + exename_("clang-tidy") + "' (no command callback provided)\n", "", GET_REDIRECT_ERROUT);
+
+                ASSERT_EQUALS(0, called); // not called because we check if the callback exists
+            }
+            else
+            {
+                ASSERT_EQUALS("internalError", it->id);
+                ASSERT_EQUALS("Bailing out from analysis: Checking file failed: Failed to auto detect python", it->shortMessage()); // TODO: clarify what python is used for
+
+                // TODO: we cannot check this because the python detection is cached globally so this result will different dependent on how the test is called
+                //ASSERT_EQUALS(2, called);
+            }
+        }
+        else
+        {
+            ASSERT_EQUALS(0, called);
+            ASSERT_EQUALS(1, errorLogger.ids.size());
+            ASSERT_EQUALS("nullPointer", *errorLogger.ids.cbegin());
+        }
+    }
+
+    void checkWithFile() const {
+        checkWithFileInternal("file.c", false);
+    }
+
+    void checkWithFileWithTools() const {
+        checkWithFileInternal("file_tools.c", true);
+    }
+
+    void checkWithFileWithToolsNoCommand() const {
+        checkWithFileInternal("file_tools_nocmd.c", true, true);
+    }
+
+    void checkWithFSInternal(const std::string& fname, bool tools, bool nocmd = false) const
+    {
+        REDIRECT;
+        ScopedFile file(fname,
+                        "void f()\n"
+                        "{\n"
+                        "  (void)(*((int*)0));\n"
+                        "}");
+
+        int called = 0;
+        std::unordered_set<std::string> addons;
+        std::vector<AddonInfo> addonInfo;
+        if (tools)
+        {
+            addons.emplace("testcppcheck");
+            addonInfo.emplace_back(/*AddonInfo()*/);
+        }
+        const auto s = dinit(Settings,
+                             $.templateFormat = templateFormat,
+                                 $.clangTidy = tools,
+                                 $.addons = std::move (addons),
+                                 $.addonInfos = std::move (addonInfo));
+        Suppressions supprs;
+        ErrorLogger2 errorLogger;
+        CppCheck::ExecuteCmdFn f;
+        if (tools && !nocmd) {
+            f = getExecuteCommand(fname, called);
+        }
+        CppCheck cppcheck(s, supprs, errorLogger, nullptr, false, f);
+        FileSettings fs{file.path(), Path::identify(file.path(), false), 0};
+        ASSERT_EQUALS(1, cppcheck.check(fs));
+        // TODO: how to properly disable these warnings?
+        errorLogger.ids.erase(std::remove_if(errorLogger.ids.begin(), errorLogger.ids.end(), [](const std::string& id) {
+            return id == "logChecker";
+        }), errorLogger.ids.end());
+        errorLogger.errmsgs.erase(std::remove_if(errorLogger.errmsgs.begin(), errorLogger.errmsgs.end(), [](const ErrorMessage& msg) {
+            return msg.id == "logChecker";
+        }), errorLogger.errmsgs.end());
+        if (tools)
+        {
+            ASSERT_EQUALS(2, errorLogger.ids.size());
+            auto it = errorLogger.errmsgs.cbegin();
+            ASSERT_EQUALS("nullPointer", it->id);
+            ++it;
+
+            if (nocmd)
+            {
+                ASSERT_EQUALS("internalError", it->id);
+                ASSERT_EQUALS("Bailing out from analysis: Checking file failed: Failed to execute addon - no command callback provided", it->shortMessage()); // TODO: add addon name
+
+                // TODO: needs to become a proper error
+                ASSERT_EQUALS("Failed to execute '" + exename_("clang-tidy") + "' (no command callback provided)\n", GET_REDIRECT_ERROUT);
+
+                ASSERT_EQUALS(0, called); // not called because we check if the callback exists
+            }
+            else
+            {
+                ASSERT_EQUALS("internalError", it->id);
+                ASSERT_EQUALS("Bailing out from analysis: Checking file failed: Failed to auto detect python", it->shortMessage()); // TODO: clarify what python is used for
+
+                // TODO: we cannot check this because the python detection is cached globally so this result will different dependent on how the test is called
+                //ASSERT_EQUALS(3, called);
+            }
+        }
+        else
+        {
+            ASSERT_EQUALS(0, called);
+            ASSERT_EQUALS(1, errorLogger.ids.size());
+            ASSERT_EQUALS("nullPointer", *errorLogger.ids.cbegin());
+        }
+    }
+
+    void checkWithFS() const {
+        checkWithFSInternal("fs.c", false);
+    }
+
+    void checkWithFSWithTools() const {
+        checkWithFSInternal("fs_tools.c", true);
+    }
+
+    void checkWithFSWithToolsNoCommand() const {
+        checkWithFSInternal("fs_tools_nocmd.c", true, true);
+    }
+
+    void suppress_error_library() const
+    {
+        ScopedFile file("suppr_err_lib.c",
+                        "void f()\n"
+                        "{\n"
+                        "  (void)(*((int*)0));\n"
+                        "}");
+
+        const char xmldata[] = R"(<def format="2"><markup ext=".c" reporterrors="false"/></def>)";
+        const Settings s = settingsBuilder().libraryxml(xmldata).build();
+        Suppressions supprs;
+        ErrorLogger2 errorLogger;
+        CppCheck cppcheck(s, supprs, errorLogger, nullptr, false, {});
+        ASSERT_EQUALS(0, cppcheck.check(FileWithDetails(file.path(), Path::identify(file.path(), false), 0)));
+        // TODO: how to properly disable these warnings?
+        errorLogger.ids.erase(std::remove_if(errorLogger.ids.begin(), errorLogger.ids.end(), [](const std::string& id) {
+            return id == "logChecker";
+        }), errorLogger.ids.end());
+        ASSERT_EQUALS(0, errorLogger.ids.size());
     }
+
+    // TODO: how to actually get duplicated findings
+    void unique_errors() const
+    {
+        ScopedFile file("inc.h",
+                        "inline void f()\n"
+                        "{\n"
+                        "  (void)(*((int*)0));\n"
+                        "}");
+        ScopedFile test_file_a("a.c",
+                               "#include \"inc.h\"");
+        ScopedFile test_file_b("b.c",
+                               "#include \"inc.h\"");
+
+        // this is the "simple" format
+        const auto s = dinit(Settings, $.templateFormat = templateFormat); // TODO: remove when we only longer rely on toString() in unique message handling
+        Suppressions supprs;
+        ErrorLogger2 errorLogger;
+        CppCheck cppcheck(s, supprs, errorLogger, nullptr, false, {});
+        ASSERT_EQUALS(1, cppcheck.check(FileWithDetails(test_file_a.path(), Path::identify(test_file_a.path(), false), 0)));
+        ASSERT_EQUALS(1, cppcheck.check(FileWithDetails(test_file_b.path(), Path::identify(test_file_b.path(), false), 0)));
+        // TODO: how to properly disable these warnings?
+        errorLogger.errmsgs.erase(std::remove_if(errorLogger.errmsgs.begin(), errorLogger.errmsgs.end(), [](const ErrorMessage& msg) {
+            return msg.id == "logChecker";
+        }), errorLogger.errmsgs.end());
+        // the internal errorlist is cleared after each check() call
+        ASSERT_EQUALS(2, errorLogger.errmsgs.size());
+        auto it = errorLogger.errmsgs.cbegin();
+        ASSERT_EQUALS("a.c", it->file0);
+        ASSERT_EQUALS("nullPointer", it->id);
+        ++it;
+        ASSERT_EQUALS("b.c", it->file0);
+        ASSERT_EQUALS("nullPointer", it->id);
+    }
+
+    void unique_errors_2() const
+    {
+        ScopedFile test_file("c.c",
+                             "void f()\n"
+                             "{\n"
+                             "const long m[9] = {};\n"
+                             "long a=m[9], b=m[9];\n"
+                             "(void)a;\n"
+                             "(void)b;\n"
+                             "}");
+
+        // this is the "simple" format
+        const auto s = dinit(Settings, $.templateFormat = templateFormat); // TODO: remove when we only longer rely on toString() in unique message handling?
+        Suppressions supprs;
+        ErrorLogger2 errorLogger;
+        CppCheck cppcheck(s, supprs, errorLogger, nullptr, false, {});
+        ASSERT_EQUALS(1, cppcheck.check(FileWithDetails(test_file.path(), Path::identify(test_file.path(), false), 0)));
+        // TODO: how to properly disable these warnings?
+        errorLogger.errmsgs.erase(std::remove_if(errorLogger.errmsgs.begin(), errorLogger.errmsgs.end(), [](const ErrorMessage& msg) {
+            return msg.id == "logChecker";
+        }), errorLogger.errmsgs.end());
+        // the internal errorlist is cleared after each check() call
+        ASSERT_EQUALS(2, errorLogger.errmsgs.size());
+        auto it = errorLogger.errmsgs.cbegin();
+        ASSERT_EQUALS("c.c", it->file0);
+        ASSERT_EQUALS(1, it->callStack.size());
+        {
+            auto stack = it->callStack.cbegin();
+            ASSERT_EQUALS(4, stack->line);
+            ASSERT_EQUALS(9, stack->column);
+        }
+        ASSERT_EQUALS("arrayIndexOutOfBounds", it->id);
+        ++it;
+        ASSERT_EQUALS("c.c", it->file0);
+        ASSERT_EQUALS(1, it->callStack.size());
+        {
+            auto stack = it->callStack.cbegin();
+            ASSERT_EQUALS(4, stack->line);
+            ASSERT_EQUALS(17, stack->column);
+        }
+        ASSERT_EQUALS("arrayIndexOutOfBounds", it->id);
+    }
+
+    void isPremiumCodingStandardId() const {
+        Suppressions supprs;
+        ErrorLogger2 errorLogger;
+
+        {
+            const auto s = dinit(Settings, $.premiumArgs = "");
+            CppCheck cppcheck(s, supprs, errorLogger, nullptr, false, {});
+
+            ASSERT_EQUALS(false, cppcheck.isPremiumCodingStandardId("misra-c2012-0.0"));
+            ASSERT_EQUALS(false, cppcheck.isPremiumCodingStandardId("misra-c2023-0.0"));
+            ASSERT_EQUALS(false, cppcheck.isPremiumCodingStandardId("premium-misra-c-2012-0.0"));
+            ASSERT_EQUALS(false, cppcheck.isPremiumCodingStandardId("premium-misra-c-2023-0.0"));
+            ASSERT_EQUALS(false, cppcheck.isPremiumCodingStandardId("premium-misra-c-2025-0.0"));
+            ASSERT_EQUALS(false, cppcheck.isPremiumCodingStandardId("premium-misra-c-2025-dir-0.0"));
+            ASSERT_EQUALS(false, cppcheck.isPremiumCodingStandardId("premium-misra-c++-2008-0-0-0"));
+            ASSERT_EQUALS(false, cppcheck.isPremiumCodingStandardId("premium-misra-c++-2023-0.0.0"));
+            ASSERT_EQUALS(false, cppcheck.isPremiumCodingStandardId("premium-cert-int50-cpp"));
+            ASSERT_EQUALS(false, cppcheck.isPremiumCodingStandardId("premium-autosar-0-0-0"));
+        }
+
+        {
+            const auto s = dinit(Settings, $.premiumArgs = "--misra-c-2012 --cert-c++-2016 --autosar");
+
+            CppCheck cppcheck(s, supprs, errorLogger, nullptr, false, {});
+
+            ASSERT_EQUALS(false, cppcheck.isPremiumCodingStandardId("misra-c2012-0.0"));
+            ASSERT_EQUALS(true, cppcheck.isPremiumCodingStandardId("premium-misra-c-2012-0.0"));
+            ASSERT_EQUALS(true, cppcheck.isPremiumCodingStandardId("premium-misra-c-2023-0.0"));
+            ASSERT_EQUALS(true, cppcheck.isPremiumCodingStandardId("premium-misra-c-2025-0.0"));
+            ASSERT_EQUALS(true, cppcheck.isPremiumCodingStandardId("premium-misra-c-2025-dir-0.0"));
+            ASSERT_EQUALS(true, cppcheck.isPremiumCodingStandardId("premium-misra-c++-2008-0-0-0"));
+            ASSERT_EQUALS(true, cppcheck.isPremiumCodingStandardId("premium-misra-c++-2023-0.0.0"));
+            ASSERT_EQUALS(true, cppcheck.isPremiumCodingStandardId("premium-cert-int50-cpp"));
+            ASSERT_EQUALS(true, cppcheck.isPremiumCodingStandardId("premium-autosar-0-0-0"));
+        }
+    }
+
+    void getDumpFileContentsRawTokens() const {
+        Settings s;
+        s.relativePaths = true;
+        s.basePaths.emplace_back("/some/path");
+        Suppressions supprs;
+        ErrorLogger2 errorLogger;
+        CppCheck cppcheck(s, supprs, errorLogger, nullptr, false, {});
+        std::vector<std::string> files{"/some/path/test.c"};
+        simplecpp::TokenList tokens1(files);
+        const std::string expected = "  <rawtokens>\n"
+                                     "    <file index=\"0\" name=\"test.c\"/>\n"
+                                     "  </rawtokens>\n";
+        ASSERT_EQUALS(expected, cppcheck.getDumpFileContentsRawTokens(files, tokens1));
+
+        const char code[] = "//x \\ \n"
+                            "y\n"
+                            ";\n";
+
+        simplecpp::OutputList outputList;
+        const simplecpp::TokenList tokens2(code, files, "", &outputList);
+        const std::string expected2 = "  <rawtokens>\n"
+                                      "    <file index=\"0\" name=\"test.c\"/>\n"
+                                      "    <file index=\"1\" name=\"\"/>\n"
+                                      "    <tok fileIndex=\"1\" linenr=\"1\" column=\"1\" str=\"//x &#10;y\"/>\n"
+                                      "    <tok fileIndex=\"1\" linenr=\"3\" column=\"1\" str=\";\"/>\n"
+                                      "  </rawtokens>\n";
+        ASSERT_EQUALS(expected2, cppcheck.getDumpFileContentsRawTokens(files, tokens2));
+
+    }
+
+    void getDumpFileContentsLibrary() const {
+        Suppressions supprs;
+        ErrorLogger2 errorLogger;
+
+        {
+            Settings s;
+            s.libraries.emplace_back("std.cfg");
+            CppCheck cppcheck(s, supprs, errorLogger, nullptr, false, {});
+            //std::vector<std::string> files{ "/some/path/test.c" };
+            const std::string expected = "  <library lib=\"std.cfg\"/>\n";
+            ASSERT_EQUALS(expected, cppcheck.getLibraryDumpData());
+        }
+
+        {
+            Settings s;
+            s.libraries.emplace_back("std.cfg");
+            s.libraries.emplace_back("posix.cfg");
+            CppCheck cppcheck(s, supprs, errorLogger, nullptr, false, {});
+            const std::string expected = "  <library lib=\"std.cfg\"/>\n  <library lib=\"posix.cfg\"/>\n";
+            ASSERT_EQUALS(expected, cppcheck.getLibraryDumpData());
+        }
+    }
+
+    void checkPlistOutput() const {
+        Suppressions supprs;
+        ErrorLogger2 errorLogger;
+        std::vector<std::string> files = {"textfile.txt"};
+
+        {
+            const auto s = dinit(Settings, $.templateFormat = templateFormat, $.plistOutput = "output");
+            const ScopedFile file("file", "");
+            CppCheck cppcheck(s, supprs, errorLogger, nullptr, false, {});
+            const FileWithDetails fileWithDetails {file.path(), Path::identify(file.path(), false), 0};
+
+            cppcheck.checkPlistOutput(fileWithDetails, files);
+            const std::string outputFile {"outputfile_" + std::to_string(std::hash<std::string> {}(fileWithDetails.spath())) + ".plist"};
+            ASSERT(Path::exists(outputFile));
+            std::remove(outputFile.c_str());
+        }
+
+        {
+            const auto s = dinit(Settings, $.plistOutput = "output");
+            const ScopedFile file("file.c", "");
+            CppCheck cppcheck(s, supprs, errorLogger, nullptr, false, {});
+            const FileWithDetails fileWithDetails {file.path(), Path::identify(file.path(), false), 0};
+
+            cppcheck.checkPlistOutput(fileWithDetails, files);
+            const std::string outputFile {"outputfile_" + std::to_string(std::hash<std::string> {}(fileWithDetails.spath())) + ".plist"};
+            ASSERT(Path::exists(outputFile));
+            std::remove(outputFile.c_str());
+        }
+
+        {
+            Settings s;
+            const ScopedFile file("file.c", "");
+            CppCheck cppcheck(s, supprs, errorLogger, nullptr, false, {});
+            cppcheck.checkPlistOutput(FileWithDetails(file.path(), Path::identify(file.path(), false), 0), files);
+        }
+    }
+
+    void premiumResultsCache() const {
+        // Trac #13889 - cached misra results are shown after removing --premium=misra-c-2012 option
+
+        Settings settings;
+        Suppressions supprs;
+        ErrorLogger2 errorLogger;
+
+        std::vector<std::string> files;
+
+        const char code[] = "void f();\nint x;\n";
+        simplecpp::TokenList tokens(code, files, "m1.c");
+
+        Preprocessor preprocessor(tokens, settings, errorLogger, Standards::Language::C);
+        ASSERT(preprocessor.loadFiles(files));
+
+        AddonInfo premiumaddon;
+        premiumaddon.name = "premiumaddon.json";
+        premiumaddon.executable = "premiumaddon";
+
+        settings.cppcheckCfgProductName = "Cppcheck Premium 0.0.0";
+        settings.addons.insert(premiumaddon.name);
+        settings.addonInfos.push_back(premiumaddon);
+
+        settings.premiumArgs = "misra-c-2012";
+        CppCheck check(settings, supprs, errorLogger, nullptr, false, {});
+        const size_t hash1 = check.calculateHash(preprocessor);
+
+        settings.premiumArgs = "";
+        const size_t hash2 = check.calculateHash(preprocessor);
+
+        // cppcheck-suppress knownConditionTrueFalse
+        ASSERT(hash1 != hash2);
+    }
+
+    void purgedConfiguration() const
+    {
+        ScopedFile test_file("test.cpp",
+                             "#ifdef X\n"
+                             "#endif\n"
+                             "int main() {}\n");
+
+        // this is the "simple" format
+        const auto s = dinit(Settings,
+                             $.templateFormat = templateFormat, // TODO: remove when we only longer rely on toString() in unique message handling
+                                 $.severity.enable (Severity::information);
+                             $.debugwarnings = true);
+        Suppressions supprs;
+        ErrorLogger2 errorLogger;
+        CppCheck cppcheck(s, supprs, errorLogger, nullptr, false, {});
+        ASSERT_EQUALS(1, cppcheck.check(FileWithDetails(test_file.path(), Path::identify(test_file.path(), false), 0)));
+        // TODO: how to properly disable these warnings?
+        errorLogger.errmsgs.erase(std::remove_if(errorLogger.errmsgs.begin(), errorLogger.errmsgs.end(), [](const ErrorMessage& msg) {
+            return msg.id == "logChecker";
+        }), errorLogger.errmsgs.end());
+        // the internal errorlist is cleared after each check() call
+        ASSERT_EQUALS(1, errorLogger.errmsgs.size());
+        auto it = errorLogger.errmsgs.cbegin();
+        ASSERT_EQUALS("test.cpp:0:0: information: The configuration 'X=X' was not checked because its code equals another one. [purgedConfiguration]",
+                      it->toString(false, templateFormat, ""));
+    }
+
+    // TODO: test suppressions
+    // TODO: test all with FS
 };
 
 REGISTER_TEST(TestCppcheck)
diff --git a/test/testerrorlogger.cpp b/test/testerrorlogger.cpp
index d83d4bfe0f4..42537ca36fb 100644
--- a/test/testerrorlogger.cpp
+++ b/test/testerrorlogger.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,39 +16,51 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "config.h"
+#include "checkers.h"
 #include "cppcheck.h"
 #include "errorlogger.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "suppressions.h"
-#include "testsuite.h"
 
 #include <list>
 #include <string>
+#include <utility>
 
+#include "xml.h"
 
 class TestErrorLogger : public TestFixture {
 public:
-    TestErrorLogger() : TestFixture("TestErrorLogger"), fooCpp5("foo.cpp", 5, 1), barCpp8("bar.cpp", 8, 1) {
-    }
+    TestErrorLogger() : TestFixture("TestErrorLogger") {}
 
 private:
-    const ErrorLogger::ErrorMessage::FileLocation fooCpp5;
-    const ErrorLogger::ErrorMessage::FileLocation barCpp8;
+    const std::string templateFormat{"{callstack}: ({severity}) {inconclusive:inconclusive: }{message}"};
+
+    const ErrorMessage::FileLocation fooCpp5{"foo.cpp", 5, 1};
+    const ErrorMessage::FileLocation barCpp8{"bar.cpp", 8, 1};
+    const ErrorMessage::FileLocation barCpp8_i{"bar.cpp", "ä", 8, 1};
 
-    void run() OVERRIDE {
+    void run() override {
         TEST_CASE(PatternSearchReplace);
-        TEST_CASE(FileLocationDefaults);
+        TEST_CASE(FileLocationConstruct);
+        TEST_CASE(FileLocationConstructFile);
         TEST_CASE(FileLocationSetFile);
+        TEST_CASE(FileLocationSetFile2);
         TEST_CASE(ErrorMessageConstruct);
         TEST_CASE(ErrorMessageConstructLocations);
         TEST_CASE(ErrorMessageVerbose);
         TEST_CASE(ErrorMessageVerboseLocations);
+        TEST_CASE(ErrorMessageFromInternalError);
         TEST_CASE(CustomFormat);
         TEST_CASE(CustomFormat2);
         TEST_CASE(CustomFormatLocations);
         TEST_CASE(ToXmlV2);
-        TEST_CASE(ToXmlV2Locations);
+        TEST_CASE(ToXmlV2RemarkComment);
+        TEST_CASE(ToXmlLocations);
         TEST_CASE(ToXmlV2Encoding);
+        TEST_CASE(FromXmlV2);
+        TEST_CASE(ToXmlV3);
 
         // Inconclusive results in xml reports..
         TEST_CASE(InconclusiveXml);
@@ -58,23 +70,29 @@ class TestErrorLogger : public TestFixture {
         TEST_CASE(DeserializeInvalidInput);
         TEST_CASE(SerializeSanitize);
         TEST_CASE(SerializeFileLocation);
+        TEST_CASE(SerializeAndDeserialize);
+
+        TEST_CASE(substituteTemplateFormatStatic);
+        TEST_CASE(substituteTemplateLocationStatic);
+
+        TEST_CASE(isCriticalErrorId);
 
-        TEST_CASE(suppressUnmatchedSuppressions);
+        TEST_CASE(TestReportType);
     }
 
     void TestPatternSearchReplace(const std::string& idPlaceholder, const std::string& id) const {
         const std::string plainText = "text";
 
-        ErrorLogger::ErrorMessage message;
+        ErrorMessage message;
         message.id = id;
 
-        std::string serialized = message.toString(true, idPlaceholder + plainText + idPlaceholder);
+        std::string serialized = message.toString(true, idPlaceholder + plainText + idPlaceholder, "");
         ASSERT_EQUALS(id + plainText + id, serialized);
 
-        serialized = message.toString(true, idPlaceholder + idPlaceholder);
+        serialized = message.toString(true, idPlaceholder + idPlaceholder, "");
         ASSERT_EQUALS(id + id, serialized);
 
-        serialized = message.toString(true, plainText + idPlaceholder + plainText);
+        serialized = message.toString(true, plainText + idPlaceholder + plainText, "");
         ASSERT_EQUALS(plainText + id + plainText, serialized);
     }
 
@@ -97,146 +115,374 @@ class TestErrorLogger : public TestFixture {
         TestPatternSearchReplace(idPlaceholder, longIdValue);
     }
 
-    void FileLocationDefaults() const {
-        ErrorLogger::ErrorMessage::FileLocation loc;
-        ASSERT_EQUALS("", loc.getfile());
-        ASSERT_EQUALS(0, loc.line);
+    void FileLocationConstruct() const {
+        {
+            const ErrorMessage::FileLocation loc("foo.cpp", 1, 2);
+            ASSERT_EQUALS("foo.cpp", loc.getOrigFile(false));
+            ASSERT_EQUALS("foo.cpp", loc.getfile(false));
+            ASSERT_EQUALS(1, loc.line);
+            ASSERT_EQUALS(2, loc.column);
+            ASSERT_EQUALS("[foo.cpp:1]", loc.stringify(false));
+            ASSERT_EQUALS("[foo.cpp:1:2]", loc.stringify(true));
+            ASSERT_EQUALS("", loc.getinfo());
+        }
+        {
+            const ErrorMessage::FileLocation loc("foo.cpp", "info", 1, 2);
+            ASSERT_EQUALS("foo.cpp", loc.getOrigFile(false));
+            ASSERT_EQUALS("foo.cpp", loc.getfile(false));
+            ASSERT_EQUALS(1, loc.line);
+            ASSERT_EQUALS(2, loc.column);
+            ASSERT_EQUALS("[foo.cpp:1]", loc.stringify(false));
+            ASSERT_EQUALS("[foo.cpp:1:2]", loc.stringify(true));
+            ASSERT_EQUALS("info", loc.getinfo());
+        }
+        {
+            const SimpleTokenList tokenlist("a", "dir/a.cpp");
+            {
+                const ErrorMessage::FileLocation loc(tokenlist.front(), &tokenlist.get());
+                ASSERT_EQUALS("dir/a.cpp", loc.getOrigFile(false));
+                ASSERT_EQUALS("dir/a.cpp", loc.getfile(false));
+                ASSERT_EQUALS(1, loc.line);
+                ASSERT_EQUALS(1, loc.column);
+#if defined(_WIN32)
+                ASSERT_EQUALS("[dir\\a.cpp:1]", loc.stringify(false));
+                ASSERT_EQUALS("[dir\\a.cpp:1:1]", loc.stringify(true));
+#else
+                ASSERT_EQUALS("[dir/a.cpp:1]", loc.stringify(false));
+                ASSERT_EQUALS("[dir/a.cpp:1:1]", loc.stringify(true));
+#endif
+                ASSERT_EQUALS("", loc.getinfo());
+            }
+            {
+                const ErrorMessage::FileLocation loc(tokenlist.front(), "info", &tokenlist.get());
+                ASSERT_EQUALS("dir/a.cpp", loc.getOrigFile(false));
+                ASSERT_EQUALS("dir/a.cpp", loc.getfile(false));
+                ASSERT_EQUALS(1, loc.line);
+                ASSERT_EQUALS(1, loc.column);
+#if defined(_WIN32)
+                ASSERT_EQUALS("[dir\\a.cpp:1]", loc.stringify(false));
+                ASSERT_EQUALS("[dir\\a.cpp:1:1]", loc.stringify(true));
+#else
+                ASSERT_EQUALS("[dir/a.cpp:1]", loc.stringify(false));
+                ASSERT_EQUALS("[dir/a.cpp:1:1]", loc.stringify(true));
+#endif
+                ASSERT_EQUALS("info", loc.getinfo());
+            }
+        }
+        {
+            const SimpleTokenList tokenlist("a", "dir\\a.cpp");
+            {
+                const ErrorMessage::FileLocation loc(tokenlist.front(), &tokenlist.get());
+                ASSERT_EQUALS("dir\\a.cpp", loc.getOrigFile(false));
+                ASSERT_EQUALS("dir/a.cpp", loc.getfile(false));
+                ASSERT_EQUALS(1, loc.line);
+                ASSERT_EQUALS(1, loc.column);
+#if defined(_WIN32)
+                ASSERT_EQUALS("[dir\\a.cpp:1]", loc.stringify(false));
+                ASSERT_EQUALS("[dir\\a.cpp:1:1]", loc.stringify(true));
+#else
+                ASSERT_EQUALS("[dir/a.cpp:1]", loc.stringify(false));
+                ASSERT_EQUALS("[dir/a.cpp:1:1]", loc.stringify(true));
+#endif
+                ASSERT_EQUALS("", loc.getinfo());
+            }
+            {
+                const ErrorMessage::FileLocation loc(tokenlist.front(), "info", &tokenlist.get());
+                ASSERT_EQUALS("dir\\a.cpp", loc.getOrigFile(false));
+                ASSERT_EQUALS("dir/a.cpp", loc.getfile(false));
+                ASSERT_EQUALS(1, loc.line);
+                ASSERT_EQUALS(1, loc.column);
+#if defined(_WIN32)
+                ASSERT_EQUALS("[dir\\a.cpp:1]", loc.stringify(false));
+                ASSERT_EQUALS("[dir\\a.cpp:1:1]", loc.stringify(true));
+#else
+                ASSERT_EQUALS("[dir/a.cpp:1]", loc.stringify(false));
+                ASSERT_EQUALS("[dir/a.cpp:1:1]", loc.stringify(true));
+#endif
+                ASSERT_EQUALS("info", loc.getinfo());
+            }
+        }
+    }
+
+    void FileLocationConstructFile() const {
+        ASSERT_EQUALS("dir/a.cpp", ErrorMessage::FileLocation("dir/a.cpp", 1, 1).getfile(false));
+        ASSERT_EQUALS("dir/a.cpp", ErrorMessage::FileLocation("dir\\a.cpp", 1, 1).getfile(false));
+        ASSERT_EQUALS("dir/a.cpp", ErrorMessage::FileLocation("dir/a.cpp", "info", 1, 1).getfile(false));
+        ASSERT_EQUALS("dir/a.cpp", ErrorMessage::FileLocation("dir\\a.cpp", "info", 1, 1).getfile(false));
+        {
+            const SimpleTokenList tokenlist("a", "dir/a.cpp");
+            ASSERT_EQUALS("dir/a.cpp", ErrorMessage::FileLocation(tokenlist.front(), &tokenlist.get()).getfile(false));
+            ASSERT_EQUALS("dir/a.cpp", ErrorMessage::FileLocation(tokenlist.front(), "info", &tokenlist.get()).getfile(false));
+        }
+        {
+            const SimpleTokenList tokenlist("a", "dir\\a.cpp");
+            ASSERT_EQUALS("dir/a.cpp", ErrorMessage::FileLocation(tokenlist.front(), &tokenlist.get()).getfile(false));
+            ASSERT_EQUALS("dir/a.cpp", ErrorMessage::FileLocation(tokenlist.front(), "info", &tokenlist.get()).getfile(false));
+        }
     }
 
     void FileLocationSetFile() const {
-        ErrorLogger::ErrorMessage::FileLocation loc;
+        ErrorMessage::FileLocation loc("foo1.cpp", 0, 0);
         loc.setfile("foo.cpp");
-        ASSERT_EQUALS("foo.cpp", loc.getfile());
+        ASSERT_EQUALS("foo1.cpp", loc.getOrigFile(false));
+        ASSERT_EQUALS("foo.cpp", loc.getfile(false));
         ASSERT_EQUALS(0, loc.line);
+        ASSERT_EQUALS(0, loc.column);
+        // TODO: the following looks wrong - there is no line or column 0
+        ASSERT_EQUALS("[foo.cpp:0]", loc.stringify(false));
+        ASSERT_EQUALS("[foo.cpp:0:0]", loc.stringify(true));
+    }
+
+    void FileLocationSetFile2() const {
+        ErrorMessage::FileLocation loc("foo1.cpp", SuppressionList::Suppression::NO_LINE, 0); // TODO: should not depend on Suppression
+        loc.setfile("foo.cpp");
+        ASSERT_EQUALS("foo1.cpp", loc.getOrigFile(false));
+        ASSERT_EQUALS("foo.cpp", loc.getfile(false));
+        ASSERT_EQUALS(SuppressionList::Suppression::NO_LINE, loc.line);
+        ASSERT_EQUALS(0, loc.column);
+        ASSERT_EQUALS("[foo.cpp]", loc.stringify(false));
+        ASSERT_EQUALS("[foo.cpp]", loc.stringify(true));
     }
 
     void ErrorMessageConstruct() const {
-        std::list<ErrorLogger::ErrorMessage::FileLocation> locs(1, fooCpp5);
-        ErrorMessage msg(locs, emptyString, Severity::error, "Programming error.", "errorId", false);
+        std::list<ErrorMessage::FileLocation> locs(1, fooCpp5);
+        ErrorMessage msg(std::move(locs), "", Severity::error, "Programming error.", "errorId", Certainty::normal);
         ASSERT_EQUALS(1, msg.callStack.size());
         ASSERT_EQUALS("Programming error.", msg.shortMessage());
         ASSERT_EQUALS("Programming error.", msg.verboseMessage());
-        ASSERT_EQUALS("[foo.cpp:5]: (error) Programming error.", msg.toString(false));
-        ASSERT_EQUALS("[foo.cpp:5]: (error) Programming error.", msg.toString(true));
+        ASSERT_EQUALS("[foo.cpp:5]: (error) Programming error.", msg.toString(false, templateFormat, ""));
+        ASSERT_EQUALS("[foo.cpp:5]: (error) Programming error.", msg.toString(true, templateFormat, ""));
     }
 
     void ErrorMessageConstructLocations() const {
-        std::list<ErrorLogger::ErrorMessage::FileLocation> locs = { fooCpp5, barCpp8 };
-        ErrorMessage msg(locs, emptyString, Severity::error, "Programming error.", "errorId", false);
+        std::list<ErrorMessage::FileLocation> locs = { fooCpp5, barCpp8 };
+        ErrorMessage msg(std::move(locs), "", Severity::error, "Programming error.", "errorId", Certainty::normal);
         ASSERT_EQUALS(2, msg.callStack.size());
         ASSERT_EQUALS("Programming error.", msg.shortMessage());
         ASSERT_EQUALS("Programming error.", msg.verboseMessage());
-        ASSERT_EQUALS("[foo.cpp:5] -> [bar.cpp:8]: (error) Programming error.", msg.toString(false));
-        ASSERT_EQUALS("[foo.cpp:5] -> [bar.cpp:8]: (error) Programming error.", msg.toString(true));
+        ASSERT_EQUALS("[foo.cpp:5] -> [bar.cpp:8]: (error) Programming error.", msg.toString(false, templateFormat, ""));
+        ASSERT_EQUALS("[foo.cpp:5] -> [bar.cpp:8]: (error) Programming error.", msg.toString(true, templateFormat, ""));
     }
 
     void ErrorMessageVerbose() const {
-        std::list<ErrorLogger::ErrorMessage::FileLocation> locs(1, fooCpp5);
-        ErrorMessage msg(locs, emptyString, Severity::error, "Programming error.\nVerbose error", "errorId", false);
+        std::list<ErrorMessage::FileLocation> locs(1, fooCpp5);
+        ErrorMessage msg(std::move(locs), "", Severity::error, "Programming error.\nVerbose error", "errorId", Certainty::normal);
         ASSERT_EQUALS(1, msg.callStack.size());
         ASSERT_EQUALS("Programming error.", msg.shortMessage());
         ASSERT_EQUALS("Verbose error", msg.verboseMessage());
-        ASSERT_EQUALS("[foo.cpp:5]: (error) Programming error.", msg.toString(false));
-        ASSERT_EQUALS("[foo.cpp:5]: (error) Verbose error", msg.toString(true));
+        ASSERT_EQUALS("[foo.cpp:5]: (error) Programming error.", msg.toString(false, templateFormat, ""));
+        ASSERT_EQUALS("[foo.cpp:5]: (error) Verbose error", msg.toString(true, templateFormat, ""));
     }
 
     void ErrorMessageVerboseLocations() const {
-        std::list<ErrorLogger::ErrorMessage::FileLocation> locs = { fooCpp5, barCpp8 };
-        ErrorMessage msg(locs, emptyString, Severity::error, "Programming error.\nVerbose error", "errorId", false);
+        std::list<ErrorMessage::FileLocation> locs = { fooCpp5, barCpp8 };
+        ErrorMessage msg(std::move(locs), "", Severity::error, "Programming error.\nVerbose error", "errorId", Certainty::normal);
         ASSERT_EQUALS(2, msg.callStack.size());
         ASSERT_EQUALS("Programming error.", msg.shortMessage());
         ASSERT_EQUALS("Verbose error", msg.verboseMessage());
-        ASSERT_EQUALS("[foo.cpp:5] -> [bar.cpp:8]: (error) Programming error.", msg.toString(false));
-        ASSERT_EQUALS("[foo.cpp:5] -> [bar.cpp:8]: (error) Verbose error", msg.toString(true));
+        ASSERT_EQUALS("[foo.cpp:5] -> [bar.cpp:8]: (error) Programming error.", msg.toString(false, templateFormat, ""));
+        ASSERT_EQUALS("[foo.cpp:5] -> [bar.cpp:8]: (error) Verbose error", msg.toString(true, templateFormat, ""));
+    }
+
+    void ErrorMessageFromInternalError() const {
+        // TODO: test with token
+        {
+            InternalError internalError(nullptr, "message", InternalError::INTERNAL);
+            const auto msg = ErrorMessage::fromInternalError(internalError, nullptr, "file.c");
+            ASSERT_EQUALS(1, msg.callStack.size());
+            const auto &loc = *msg.callStack.cbegin();
+            ASSERT_EQUALS(0, loc.fileIndex);
+            ASSERT_EQUALS(0, loc.line);
+            ASSERT_EQUALS(0, loc.column);
+            ASSERT_EQUALS("message", msg.shortMessage());
+            ASSERT_EQUALS("message", msg.verboseMessage());
+            ASSERT_EQUALS("[file.c:0]: (error) message", msg.toString(false, templateFormat, ""));
+            ASSERT_EQUALS("[file.c:0]: (error) message", msg.toString(true, templateFormat, ""));
+        }
+        {
+            InternalError internalError(nullptr, "message", "details", InternalError::INTERNAL);
+            const auto msg = ErrorMessage::fromInternalError(internalError, nullptr, "file.cpp", "msg");
+            ASSERT_EQUALS(1, msg.callStack.size());
+            const auto &loc = *msg.callStack.cbegin();
+            ASSERT_EQUALS(0, loc.fileIndex);
+            ASSERT_EQUALS(0, loc.line);
+            ASSERT_EQUALS(0, loc.column);
+            ASSERT_EQUALS("msg: message", msg.shortMessage());
+            ASSERT_EQUALS("msg: message: details", msg.verboseMessage());
+            ASSERT_EQUALS("[file.cpp:0]: (error) msg: message", msg.toString(false, templateFormat, ""));
+            ASSERT_EQUALS("[file.cpp:0]: (error) msg: message: details", msg.toString(true, templateFormat, ""));
+        }
+    }
+
+    #define testReportType(...) testReportType_(__FILE__, __LINE__, __VA_ARGS__)
+    void testReportType_(const char *file, int line, ReportType reportType, Severity severity, const std::string &errorId,
+                         const std::string &expectedClassification, const std::string &expectedGuideline) const
+    {
+        std::list<ErrorMessage::FileLocation> locs = { fooCpp5 };
+        const auto mapping = createGuidelineMapping(reportType);
+
+        ErrorMessage msg(std::move(locs), "", severity, "", errorId, Certainty::normal);
+        msg.guideline = getGuideline(msg.id, reportType, mapping, msg.severity);
+        msg.classification = getClassification(msg.guideline, reportType);
+
+        ASSERT_EQUALS_LOC(expectedClassification, msg.classification, file, line);
+        ASSERT_EQUALS_LOC(expectedGuideline, msg.guideline, file, line);
+    }
+
+    void TestReportType() const {
+        testReportType(ReportType::misraC2012, Severity::error, "unusedVariable", "Advisory", "2.8");
+        testReportType(ReportType::misraCpp2023, Severity::warning, "premium-misra-cpp-2023-6.8.4", "Advisory", "6.8.4");
+        testReportType(ReportType::misraCpp2023, Severity::style, "premium-misra-cpp-2023-19.6.1", "Advisory", "19.6.1");
+        testReportType(ReportType::misraCpp2023, Severity::style, "premium-misra-cpp-2023-dir-0.3.1", "Advisory", "Dir 0.3.1");
+        testReportType(ReportType::misraCpp2023, Severity::style, "premium-misra-cpp-2023-dir-0.3.2", "Required", "Dir 0.3.2");
+        testReportType(ReportType::misraCpp2008, Severity::style, "premium-misra-cpp-2008-3-4-1", "Required", "3-4-1");
+        testReportType(ReportType::misraC2012, Severity::style, "premium-misra-c-2012-dir-4.6", "Advisory", "Dir 4.6");
+        testReportType(ReportType::misraC2012, Severity::style, "misra-c2012-dir-4.6", "Advisory", "Dir 4.6");
+        testReportType(ReportType::certC, Severity::error, "resourceLeak", "L3", "FIO42-C");
     }
 
     void CustomFormat() const {
-        std::list<ErrorLogger::ErrorMessage::FileLocation> locs(1, fooCpp5);
-        ErrorMessage msg(locs, emptyString, Severity::error, "Programming error.\nVerbose error", "errorId", false);
+        std::list<ErrorMessage::FileLocation> locs(1, fooCpp5);
+        ErrorMessage msg(std::move(locs), "", Severity::error, "Programming error.\nVerbose error", "errorId", Certainty::normal);
         ASSERT_EQUALS(1, msg.callStack.size());
         ASSERT_EQUALS("Programming error.", msg.shortMessage());
         ASSERT_EQUALS("Verbose error", msg.verboseMessage());
-        ASSERT_EQUALS("foo.cpp:5,error,errorId,Programming error.", msg.toString(false, "{file}:{line},{severity},{id},{message}"));
-        ASSERT_EQUALS("foo.cpp:5,error,errorId,Verbose error", msg.toString(true, "{file}:{line},{severity},{id},{message}"));
+        ASSERT_EQUALS("foo.cpp:5,error,errorId,Programming error.", msg.toString(false, "{file}:{line},{severity},{id},{message}", ""));
+        ASSERT_EQUALS("foo.cpp:5,error,errorId,Verbose error", msg.toString(true, "{file}:{line},{severity},{id},{message}", ""));
     }
 
     void CustomFormat2() const {
-        std::list<ErrorLogger::ErrorMessage::FileLocation> locs(1, fooCpp5);
-        ErrorMessage msg(locs, emptyString, Severity::error, "Programming error.\nVerbose error", "errorId", false);
+        std::list<ErrorMessage::FileLocation> locs(1, fooCpp5);
+        ErrorMessage msg(std::move(locs), "", Severity::error, "Programming error.\nVerbose error", "errorId", Certainty::normal);
         ASSERT_EQUALS(1, msg.callStack.size());
         ASSERT_EQUALS("Programming error.", msg.shortMessage());
         ASSERT_EQUALS("Verbose error", msg.verboseMessage());
-        ASSERT_EQUALS("Programming error. - foo.cpp(5):(error,errorId)", msg.toString(false, "{message} - {file}({line}):({severity},{id})"));
-        ASSERT_EQUALS("Verbose error - foo.cpp(5):(error,errorId)", msg.toString(true, "{message} - {file}({line}):({severity},{id})"));
+        ASSERT_EQUALS("Programming error. - foo.cpp(5):(error,errorId)", msg.toString(false, "{message} - {file}({line}):({severity},{id})", ""));
+        ASSERT_EQUALS("Verbose error - foo.cpp(5):(error,errorId)", msg.toString(true, "{message} - {file}({line}):({severity},{id})", ""));
     }
 
     void CustomFormatLocations() const {
         // Check that first location from location stack is used in template
-        std::list<ErrorLogger::ErrorMessage::FileLocation> locs = { fooCpp5, barCpp8 };
-        ErrorMessage msg(locs, emptyString, Severity::error, "Programming error.\nVerbose error", "errorId", false);
+        std::list<ErrorMessage::FileLocation> locs = { fooCpp5, barCpp8 };
+        ErrorMessage msg(std::move(locs), "", Severity::error, "Programming error.\nVerbose error", "errorId", Certainty::normal);
         ASSERT_EQUALS(2, msg.callStack.size());
         ASSERT_EQUALS("Programming error.", msg.shortMessage());
         ASSERT_EQUALS("Verbose error", msg.verboseMessage());
-        ASSERT_EQUALS("Programming error. - bar.cpp(8):(error,errorId)", msg.toString(false, "{message} - {file}({line}):({severity},{id})"));
-        ASSERT_EQUALS("Verbose error - bar.cpp(8):(error,errorId)", msg.toString(true, "{message} - {file}({line}):({severity},{id})"));
+        ASSERT_EQUALS("Programming error. - bar.cpp(8):(error,errorId)", msg.toString(false, "{message} - {file}({line}):({severity},{id})", ""));
+        ASSERT_EQUALS("Verbose error - bar.cpp(8):(error,errorId)", msg.toString(true, "{message} - {file}({line}):({severity},{id})", ""));
     }
 
     void ToXmlV2() const {
-        std::list<ErrorLogger::ErrorMessage::FileLocation> locs(1, fooCpp5);
-        ErrorMessage msg(locs, emptyString, Severity::error, "Programming error.\nVerbose error", "errorId", false);
+        std::list<ErrorMessage::FileLocation> locs(1, fooCpp5);
+        ErrorMessage msg(std::move(locs), "", Severity::error, "Programming error.\nVerbose error", "errorId", Certainty::normal);
         std::string header("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<results version=\"2\">\n");
         header += "    <cppcheck version=\"";
         header += CppCheck::version();
         header += "\"/>\n    <errors>";
-        ASSERT_EQUALS(header, ErrorLogger::ErrorMessage::getXMLHeader());
-        ASSERT_EQUALS("    </errors>\n</results>", ErrorLogger::ErrorMessage::getXMLFooter());
+        ASSERT_EQUALS(header, ErrorMessage::getXMLHeader(""));
+        ASSERT_EQUALS("    </errors>\n</results>", ErrorMessage::getXMLFooter(2));
         std::string message("        <error id=\"errorId\" severity=\"error\"");
         message += " msg=\"Programming error.\" verbose=\"Verbose error\">\n";
         message += "            <location file=\"foo.cpp\" line=\"5\" column=\"1\"/>\n        </error>";
         ASSERT_EQUALS(message, msg.toXML());
     }
 
-    void ToXmlV2Locations() const {
-        std::list<ErrorLogger::ErrorMessage::FileLocation> locs = { fooCpp5, barCpp8 };
-        locs.back().setinfo("ä");
-        ErrorMessage msg(locs, emptyString, Severity::error, "Programming error.\nVerbose error", "errorId", false);
-        std::string header("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<results version=\"2\">\n");
-        header += "    <cppcheck version=\"";
-        header += CppCheck::version();
-        header += "\"/>\n    <errors>";
-        ASSERT_EQUALS(header, ErrorLogger::ErrorMessage::getXMLHeader());
-        ASSERT_EQUALS("    </errors>\n</results>", ErrorLogger::ErrorMessage::getXMLFooter());
-        std::string message("        <error id=\"errorId\" severity=\"error\"");
-        message += " msg=\"Programming error.\" verbose=\"Verbose error\">\n";
+    void ToXmlV2RemarkComment() const {
+        ErrorMessage msg({}, "", Severity::warning, "", "id", Certainty::normal);
+        msg.remark = "remark";
+        ASSERT_EQUALS("        <error id=\"id\" severity=\"warning\" msg=\"\" verbose=\"\" remark=\"remark\"/>", msg.toXML());
+    }
+
+    void ToXmlLocations() const {
+        const ErrorMessage::FileLocation dir1loc{"dir1/a.cpp", 1, 1};
+        const ErrorMessage::FileLocation dir2loc{"dir2\\a.cpp", 1, 1};
+        ErrorMessage::FileLocation dir3loc{"dir/a.cpp", 1, 1};
+        dir3loc.setfile("dir3/a.cpp");
+        ErrorMessage::FileLocation dir4loc{"dir/a.cpp", 1, 1};
+        dir4loc.setfile("dir4\\a.cpp");
+        std::list<ErrorMessage::FileLocation> locs = { dir4loc, dir3loc, dir2loc, dir1loc, fooCpp5, barCpp8_i };
+
+        ErrorMessage msg(std::move(locs), "", Severity::error, "Programming error.\nVerbose error", "errorId", Certainty::normal);
+        std::string message;
+        message += "        <error id=\"errorId\" severity=\"error\" msg=\"Programming error.\" verbose=\"Verbose error\">\n";
         message += "            <location file=\"bar.cpp\" line=\"8\" column=\"1\" info=\"\\303\\244\"/>\n";
-        message += "            <location file=\"foo.cpp\" line=\"5\" column=\"1\"/>\n        </error>";
+        message += "            <location file=\"foo.cpp\" line=\"5\" column=\"1\"/>\n";
+        message += "            <location file=\"dir1/a.cpp\" line=\"1\" column=\"1\"/>\n";
+        message += "            <location origfile=\"dir2\\a.cpp\" file=\"dir2/a.cpp\" line=\"1\" column=\"1\"/>\n";
+        message += "            <location origfile=\"dir/a.cpp\" file=\"dir3/a.cpp\" line=\"1\" column=\"1\"/>\n";
+        message += "            <location origfile=\"dir/a.cpp\" file=\"dir4/a.cpp\" line=\"1\" column=\"1\"/>\n";
+        message += "        </error>";
         ASSERT_EQUALS(message, msg.toXML());
     }
 
     void ToXmlV2Encoding() const {
         {
-            std::list<ErrorLogger::ErrorMessage::FileLocation> locs;
-            ErrorMessage msg(locs, emptyString, Severity::error, "Programming error.\nComparing \"\203\" with \"\003\"", "errorId", false);
+            ErrorMessage msg({}, "", Severity::error, "Programming error.\nComparing \"\203\" with \"\003\"", "errorId", Certainty::normal);
             const std::string expected("        <error id=\"errorId\" severity=\"error\" msg=\"Programming error.\" verbose=\"Comparing &quot;\\203&quot; with &quot;\\003&quot;\"/>");
             ASSERT_EQUALS(expected, msg.toXML());
         }
         {
             const char code1[]="äöü";
             const char code2[]="\x12\x00\x00\x01";
-            std::list<ErrorLogger::ErrorMessage::FileLocation> locs;
-            ErrorMessage msg1(locs, emptyString, Severity::error, std::string("Programming error.\nReading \"")+code1+"\"", "errorId", false);
+            ErrorMessage msg1({}, "", Severity::error, std::string("Programming error.\nReading \"")+code1+"\"", "errorId", Certainty::normal);
             ASSERT_EQUALS("        <error id=\"errorId\" severity=\"error\" msg=\"Programming error.\" verbose=\"Reading &quot;\\303\\244\\303\\266\\303\\274&quot;\"/>", msg1.toXML());
-            ErrorMessage msg2(locs, emptyString, Severity::error, std::string("Programming error.\nReading \"")+code2+"\"", "errorId", false);
+            ErrorMessage msg2({}, "", Severity::error, std::string("Programming error.\nReading \"")+code2+"\"", "errorId", Certainty::normal);
             ASSERT_EQUALS("        <error id=\"errorId\" severity=\"error\" msg=\"Programming error.\" verbose=\"Reading &quot;\\022&quot;\"/>", msg2.toXML());
         }
     }
 
+    void FromXmlV2() const {
+        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                               "<error id=\"errorId\""
+                               " severity=\"error\""
+                               " cwe=\"123\""
+                               " inconclusive=\"true\""
+                               " msg=\"Programming error.\""
+                               " verbose=\"Verbose error\""
+                               " hash=\"456\""
+                               ">\n"
+                               "  <location file=\"bar.cpp\" line=\"8\" column=\"1\"/>\n"
+                               "  <location origfile=\"proj/foo.cpp\" file=\"foo.cpp\" line=\"5\" column=\"2\"/>\n"
+                               "</error>";
+        tinyxml2::XMLDocument doc;
+        ASSERT(doc.Parse(xmldata, sizeof(xmldata)) == tinyxml2::XML_SUCCESS);
+        const auto * const rootnode = doc.FirstChildElement();
+        ASSERT(rootnode);
+        ErrorMessage msg(doc.FirstChildElement());
+        ASSERT_EQUALS("errorId", msg.id);
+        ASSERT_EQUALS_ENUM(Severity::error, msg.severity);
+        ASSERT_EQUALS(123u, msg.cwe.id);
+        ASSERT_EQUALS_ENUM(Certainty::inconclusive, msg.certainty);
+        ASSERT_EQUALS("Programming error.", msg.shortMessage());
+        ASSERT_EQUALS("Verbose error", msg.verboseMessage());
+        ASSERT_EQUALS(456u, msg.hash);
+        ASSERT_EQUALS(2u, msg.callStack.size());
+        ASSERT_EQUALS("proj/foo.cpp", msg.callStack.front().getOrigFile(false));
+        ASSERT_EQUALS("foo.cpp", msg.callStack.front().getfile(false));
+        ASSERT_EQUALS(5, msg.callStack.front().line);
+        ASSERT_EQUALS(2u, msg.callStack.front().column);
+        ASSERT_EQUALS("bar.cpp", msg.callStack.back().getOrigFile(false));
+        ASSERT_EQUALS("bar.cpp", msg.callStack.back().getfile(false));
+        ASSERT_EQUALS(8, msg.callStack.back().line);
+        ASSERT_EQUALS(1u, msg.callStack.back().column);
+    }
+
+    void ToXmlV3() const {
+        std::string header("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<results version=\"3\">\n");
+        header += "    <cppcheck version=\"";
+        header += CppCheck::version();
+        header += "\"/>\n    <errors>";
+        ASSERT_EQUALS(header, ErrorMessage::getXMLHeader("", 3));
+
+        ASSERT_EQUALS("</results>", ErrorMessage::getXMLFooter(3));
+    }
+
     void InconclusiveXml() const {
         // Location
-        std::list<ErrorLogger::ErrorMessage::FileLocation> locs(1, fooCpp5);
+        std::list<ErrorMessage::FileLocation> locs(1, fooCpp5);
 
         // Inconclusive error message
-        ErrorMessage msg(locs, emptyString, Severity::error, "Programming error", "errorId", true);
+        ErrorMessage msg(std::move(locs), "", Severity::error, "Programming error", "errorId", Certainty::inconclusive);
 
         // xml version 2 error message
         ASSERT_EQUALS("        <error id=\"errorId\" severity=\"error\" msg=\"Programming error\" verbose=\"Programming error\" inconclusive=\"true\">\n"
@@ -247,60 +493,151 @@ class TestErrorLogger : public TestFixture {
 
     void SerializeInconclusiveMessage() const {
         // Inconclusive error message
-        std::list<ErrorLogger::ErrorMessage::FileLocation> locs;
-        ErrorMessage msg(locs, emptyString, Severity::error, "Programming error", "errorId", true);
+        ErrorMessage msg({}, "", Severity::error, "Programming error", "errorId", Certainty::inconclusive);
+        msg.file0 = "test.cpp";
+
+        const std::string msg_str = msg.serialize();
         ASSERT_EQUALS("7 errorId"
                       "5 error"
                       "1 0"
-                      "12 inconclusive"
+                      "1 0"
+                      "0 "
+                      "8 test.cpp"
+                      "1 1"
                       "17 Programming error"
                       "17 Programming error"
-                      "0 ", msg.serialize());
+                      "0 "
+                      "0 ", msg_str);
 
         ErrorMessage msg2;
-        msg2.deserialize(msg.serialize());
+        ASSERT_NO_THROW(msg2.deserialize(msg_str));
         ASSERT_EQUALS("errorId", msg2.id);
-        ASSERT_EQUALS(Severity::error, msg2.severity);
-        ASSERT_EQUALS(true, msg2.inconclusive);
+        ASSERT_EQUALS_ENUM(Severity::error, msg2.severity);
+        ASSERT_EQUALS("test.cpp", msg2.file0);
+        ASSERT_EQUALS_ENUM(Certainty::inconclusive, msg2.certainty);
         ASSERT_EQUALS("Programming error", msg2.shortMessage());
         ASSERT_EQUALS("Programming error", msg2.verboseMessage());
     }
 
     void DeserializeInvalidInput() const {
-        ErrorMessage msg;
-        ASSERT_THROW(msg.deserialize("500foobar"), InternalError);
+        {
+            // missing/invalid length
+            // missing separator
+            ErrorMessage msg;
+            ASSERT_THROW_INTERNAL_EQUALS(msg.deserialize("500foobar"), INTERNAL, "Internal Error: Deserialization of error message failed - invalid separator");
+        }
+        {
+            // invalid length
+            ErrorMessage msg;
+            ASSERT_THROW_INTERNAL_EQUALS(msg.deserialize("foo foobar"), INTERNAL, "Internal Error: Deserialization of error message failed - invalid length");
+        }
+        {
+            // mismatching length
+            ErrorMessage msg;
+            ASSERT_THROW_INTERNAL_EQUALS(msg.deserialize("8 errorId"), INTERNAL, "Internal Error: Deserialization of error message failed - premature end of data");
+        }
+        {
+            // incomplete message
+            ErrorMessage msg;
+            ASSERT_THROW_INTERNAL_EQUALS(msg.deserialize("7 errorId"), INTERNAL, "Internal Error: Deserialization of error message failed - invalid length");
+        }
+        {
+            // invalid CWE ID
+            const char str[] = "7 errorId"
+                               "5 error"
+                               "7 invalid" // cwe
+                               "1 0"
+                               "0 "
+                               "8 test.cpp"
+                               "17 Programming error"
+                               "17 Programming error"
+                               "0 "
+                               "0 ";
+            ErrorMessage msg;
+            ASSERT_THROW_INTERNAL_EQUALS(msg.deserialize(str), INTERNAL, "Internal Error: Deserialization of error message failed - invalid CWE ID - not an integer");
+        }
+        {
+            // invalid hash
+            const char str[] = "7 errorId"
+                               "5 error"
+                               "1 0"
+                               "7 invalid" // hash
+                               "1 0"
+                               "0 "
+                               "8 test.cpp"
+                               "17 Programming error"
+                               "17 Programming error"
+                               "0 "
+                               "0 ";
+            ErrorMessage msg;
+            ASSERT_THROW_INTERNAL_EQUALS(msg.deserialize(str), INTERNAL, "Internal Error: Deserialization of error message failed - invalid hash - not an integer");
+        }
+        {
+            // out-of-range CWE ID
+            const char str[] = "7 errorId"
+                               "5 error"
+                               "5 65536" // max +1
+                               "1 0"
+                               "1 0"
+                               "0 "
+                               "8 test.cpp"
+                               "17 Programming error"
+                               "17 Programming error"
+                               "0 "
+                               "0 ";
+            ErrorMessage msg;
+            ASSERT_THROW_INTERNAL_EQUALS(msg.deserialize(str), INTERNAL, "Internal Error: Deserialization of error message failed - invalid CWE ID - out of range (limits)");
+        }
     }
 
     void SerializeSanitize() const {
-        std::list<ErrorLogger::ErrorMessage::FileLocation> locs;
-        ErrorMessage msg(locs, emptyString, Severity::error, std::string("Illegal character in \"foo\001bar\""), "errorId", false);
+        ErrorMessage msg({}, "", Severity::error, std::string("Illegal character in \"foo\001bar\""), "errorId", Certainty::normal);
+        msg.file0 = "1.c";
 
+        const std::string msg_str = msg.serialize();
         ASSERT_EQUALS("7 errorId"
                       "5 error"
                       "1 0"
+                      "1 0"
+                      "0 "
+                      "3 1.c"
+                      "1 0"
                       "33 Illegal character in \"foo\\001bar\""
                       "33 Illegal character in \"foo\\001bar\""
-                      "0 ", msg.serialize());
+                      "0 "
+                      "0 ", msg_str);
 
         ErrorMessage msg2;
-        msg2.deserialize(msg.serialize());
+        ASSERT_NO_THROW(msg2.deserialize(msg_str));
         ASSERT_EQUALS("errorId", msg2.id);
-        ASSERT_EQUALS(Severity::error, msg2.severity);
+        ASSERT_EQUALS_ENUM(Severity::error, msg2.severity);
+        ASSERT_EQUALS("1.c", msg2.file0);
         ASSERT_EQUALS("Illegal character in \"foo\\001bar\"", msg2.shortMessage());
         ASSERT_EQUALS("Illegal character in \"foo\\001bar\"", msg2.verboseMessage());
     }
 
     void SerializeFileLocation() const {
-        ErrorLogger::ErrorMessage::FileLocation loc1(":/,;", 654, 33);
+        ErrorMessage::FileLocation loc1(":/,;", "abcd:/,", 654, 33);
         loc1.setfile("[]:;,()");
-        loc1.setinfo("abcd:/,");
 
-        std::list<ErrorLogger::ErrorMessage::FileLocation> locs{loc1};
+        ErrorMessage msg({std::move(loc1)}, "", Severity::error, "Programming error", "errorId", Certainty::inconclusive);
 
-        ErrorMessage msg(locs, emptyString, Severity::error, "Programming error", "errorId", true);
+        const std::string msg_str = msg.serialize();
+        ASSERT_EQUALS("7 errorId"
+                      "5 error"
+                      "1 0"
+                      "1 0"
+                      "0 "
+                      "0 "
+                      "1 1"
+                      "17 Programming error"
+                      "17 Programming error"
+                      "0 "
+                      "1 "
+                      "27 654\t33\t[]:;,()\t:/,;\tabcd:/,", msg_str);
 
         ErrorMessage msg2;
-        msg2.deserialize(msg.serialize());
+        ASSERT_NO_THROW(msg2.deserialize(msg_str));
         ASSERT_EQUALS("[]:;,()", msg2.callStack.front().getfile(false));
         ASSERT_EQUALS(":/,;", msg2.callStack.front().getOrigFile(false));
         ASSERT_EQUALS(654, msg2.callStack.front().line);
@@ -308,54 +645,92 @@ class TestErrorLogger : public TestFixture {
         ASSERT_EQUALS("abcd:/,", msg2.callStack.front().getinfo());
     }
 
-    void suppressUnmatchedSuppressions() {
-        std::list<Suppressions::Suppression> suppressions;
-
-        // No unmatched suppression
-        errout.str("");
-        suppressions.clear();
-        reportUnmatchedSuppressions(suppressions);
-        ASSERT_EQUALS("", errout.str());
-
-        // suppress all unmatchedSuppression
-        errout.str("");
-        suppressions.clear();
-        suppressions.emplace_back("abc", "a.c", 10U);
-        suppressions.emplace_back("unmatchedSuppression", "*", Suppressions::Suppression::NO_LINE);
-        reportUnmatchedSuppressions(suppressions);
-        ASSERT_EQUALS("", errout.str());
-
-        // suppress all unmatchedSuppression in a.c
-        errout.str("");
-        suppressions.clear();
-        suppressions.emplace_back("abc", "a.c", 10U);
-        suppressions.emplace_back("unmatchedSuppression", "a.c", Suppressions::Suppression::NO_LINE);
-        reportUnmatchedSuppressions(suppressions);
-        ASSERT_EQUALS("", errout.str());
-
-        // suppress unmatchedSuppression in a.c at line 10
-        errout.str("");
-        suppressions.clear();
-        suppressions.emplace_back("abc", "a.c", 10U);
-        suppressions.emplace_back("unmatchedSuppression", "a.c", 10U);
-        reportUnmatchedSuppressions(suppressions);
-        ASSERT_EQUALS("", errout.str());
-
-        // don't suppress unmatchedSuppression when file is mismatching
-        errout.str("");
-        suppressions.clear();
-        suppressions.emplace_back("abc", "a.c", 10U);
-        suppressions.emplace_back("unmatchedSuppression", "b.c", Suppressions::Suppression::NO_LINE);
-        reportUnmatchedSuppressions(suppressions);
-        ASSERT_EQUALS("[a.c:10]: (information) Unmatched suppression: abc\n", errout.str());
-
-        // don't suppress unmatchedSuppression when line is mismatching
-        errout.str("");
-        suppressions.clear();
-        suppressions.emplace_back("abc", "a.c", 10U);
-        suppressions.emplace_back("unmatchedSuppression", "a.c", 1U);
-        reportUnmatchedSuppressions(suppressions);
-        ASSERT_EQUALS("[a.c:10]: (information) Unmatched suppression: abc\n", errout.str());
+    void SerializeAndDeserialize() const {
+        ErrorMessage msg({}, "", Severity::warning, "$symbol:var\nmessage $symbol", "id", Certainty::normal);
+        msg.remark = "some remark";
+
+        ErrorMessage msg2;
+        ASSERT_NO_THROW(msg2.deserialize(msg.serialize()));
+
+        ASSERT_EQUALS(msg.callStack.size(), msg2.callStack.size());
+        ASSERT_EQUALS(msg.file0, msg2.file0);
+        ASSERT_EQUALS_ENUM(msg.severity, msg2.severity);
+        ASSERT_EQUALS(msg.shortMessage(), msg2.shortMessage());
+        ASSERT_EQUALS(msg.verboseMessage(), msg2.verboseMessage());
+        ASSERT_EQUALS(msg.id, msg2.id);
+        ASSERT_EQUALS_ENUM(msg.certainty, msg2.certainty);
+        ASSERT_EQUALS(msg.cwe.id, msg2.cwe.id);
+        ASSERT_EQUALS(msg.hash, msg2.hash);
+        ASSERT_EQUALS(msg.remark, msg2.remark);
+        ASSERT_EQUALS(msg.symbolNames(), msg2.symbolNames());
+    }
+
+    void substituteTemplateFormatStatic() const
+    {
+        {
+            std::string s;
+            ::substituteTemplateFormatStatic(s);
+            ASSERT_EQUALS("", s);
+        }
+        {
+            std::string s = "template{black}\\z";
+            ::substituteTemplateFormatStatic(s);
+            ASSERT_EQUALS("template{black}\\z", s);
+        }
+        {
+            std::string s = "{reset}{bold}{dim}{red}{blue}{magenta}{default}\\b\\n\\r\\t";
+            ::substituteTemplateFormatStatic(s);
+            ASSERT_EQUALS("\b\n\r\t", s);
+        }
+        {
+            std::string s = "\\\\n";
+            ::substituteTemplateFormatStatic(s);
+            ASSERT_EQUALS("\\\n", s);
+        }
+        {
+            std::string s = "{{red}";
+            ::substituteTemplateFormatStatic(s);
+            ASSERT_EQUALS("{", s);
+        }
+    }
+
+    void substituteTemplateLocationStatic() const
+    {
+        {
+            std::string s;
+            ::substituteTemplateLocationStatic(s);
+            ASSERT_EQUALS("", s);
+        }
+        {
+            std::string s = "template";
+            ::substituteTemplateLocationStatic(s);
+            ASSERT_EQUALS("template", s);
+        }
+        {
+            std::string s = "template{black}\\z";
+            ::substituteTemplateFormatStatic(s);
+            ASSERT_EQUALS("template{black}\\z", s);
+        }
+        {
+            std::string s = "{reset}{bold}{dim}{red}{blue}{magenta}{default}\\b\\n\\r\\t";
+            ::substituteTemplateFormatStatic(s);
+            ASSERT_EQUALS("\b\n\r\t", s);
+        }
+        {
+            std::string s = "\\\\n";
+            ::substituteTemplateFormatStatic(s);
+            ASSERT_EQUALS("\\\n", s);
+        }
+        {
+            std::string s = "{{red}";
+            ::substituteTemplateFormatStatic(s);
+            ASSERT_EQUALS("{", s);
+        }
+    }
+
+    void isCriticalErrorId() const {
+        // It does not abort all the analysis of the file. Like "missingInclude" there can be false negatives.
+        ASSERT_EQUALS(false, ErrorLogger::isCriticalErrorId("misra-config"));
     }
 };
 
diff --git a/test/testexceptionsafety.cpp b/test/testexceptionsafety.cpp
index 9e5519bf7f9..58b26ecbc27 100644
--- a/test/testexceptionsafety.cpp
+++ b/test/testexceptionsafety.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,24 +16,25 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include "checkexceptionsafety.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
 
+#include <cstddef>
 
 class TestExceptionSafety : public TestFixture {
 public:
-    TestExceptionSafety() : TestFixture("TestExceptionSafety") {
-    }
+    TestExceptionSafety() : TestFixture("TestExceptionSafety") {}
 
 private:
-    Settings settings;
+    /*const*/ Settings settings;
 
-    void run() OVERRIDE {
-        settings.addEnabled("all");
+    void run() override {
+        settings.severity.fill();
 
+        mNewTemplate = true;
         TEST_CASE(destructors);
         TEST_CASE(deallocThrow1);
         TEST_CASE(deallocThrow2);
@@ -48,25 +49,34 @@ class TestExceptionSafety : public TestFixture {
         TEST_CASE(nothrowThrow);
         TEST_CASE(unhandledExceptionSpecification1); // #4800
         TEST_CASE(unhandledExceptionSpecification2);
+        TEST_CASE(unhandledExceptionSpecification3);
         TEST_CASE(nothrowAttributeThrow);
         TEST_CASE(nothrowAttributeThrow2); // #5703
         TEST_CASE(nothrowDeclspecThrow);
+        TEST_CASE(rethrowNoCurrentException1);
+        TEST_CASE(rethrowNoCurrentException2);
+        TEST_CASE(rethrowNoCurrentException3);
+        TEST_CASE(noFunctionCall);
+        TEST_CASE(entryPoint);
     }
 
-    void check(const char code[], bool inconclusive = false) {
-        // Clear the error buffer..
-        errout.str("");
+    struct CheckOptions
+    {
+        bool inconclusive = false;
+        const Settings *s = nullptr;
+    };
 
-        settings.inconclusive = inconclusive;
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size],  const CheckOptions& options = make_default_obj()) {
+        const Settings settings1 = settingsBuilder(options.s ? *options.s : settings).certainty(Certainty::inconclusive, options.inconclusive).build();
 
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings1, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check char variable usage..
-        CheckExceptionSafety checkExceptionSafety(&tokenizer, &settings, this);
-        checkExceptionSafety.runChecks(&tokenizer, &settings, this);
+        runChecks<CheckExceptionSafety>(tokenizer, this);
     }
 
     void destructors() {
@@ -75,7 +85,8 @@ class TestExceptionSafety : public TestFixture {
               "        throw e;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Class x is not safe, destructor throws exception\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (warning) Class x is not safe, destructor throws exception [exceptThrowInDestructor]\n"
+                      "[test.cpp:3:9]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n", errout_str());
 
         check("class x {\n"
               "    ~x();\n"
@@ -83,7 +94,8 @@ class TestExceptionSafety : public TestFixture {
               "x::~x() {\n"
               "    throw e;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Class x is not safe, destructor throws exception\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) Class x is not safe, destructor throws exception [exceptThrowInDestructor]\n"
+                      "[test.cpp:5:5]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n", errout_str());
 
         // #3858 - throwing exception in try block in destructor.
         check("class x {\n"
@@ -94,7 +106,7 @@ class TestExceptionSafety : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class x {\n"
               "    ~x() {\n"
@@ -103,7 +115,16 @@ class TestExceptionSafety : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n", errout_str());
+
+        // #11031 should not warn when noexcept false
+        check("class A {\n"
+              "public:\n"
+              "    ~A() noexcept(false) {\n"
+              "        throw 30;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void deallocThrow1() {
@@ -114,7 +135,7 @@ class TestExceptionSafety : public TestFixture {
               "        throw 123;\n"
               "    p = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Exception thrown in invalid state, 'p' points at deallocated memory.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9]: (warning) Exception thrown in invalid state, 'p' points at deallocated memory. [exceptDeallocThrow]\n", errout_str());
 
         check("void f() {\n"
               "    static int* p = foo;\n"
@@ -123,7 +144,7 @@ class TestExceptionSafety : public TestFixture {
               "        throw 1;\n"
               "    p = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Exception thrown in invalid state, 'p' points at deallocated memory.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9]: (warning) Exception thrown in invalid state, 'p' points at deallocated memory. [exceptDeallocThrow]\n", errout_str());
     }
 
     void deallocThrow2() {
@@ -133,16 +154,16 @@ class TestExceptionSafety : public TestFixture {
               "    if (foo)\n"
               "        throw 1;\n"
               "    p = new int;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    static int* p = 0;\n"
               "    delete p;\n"
               "    reset(p);\n"
               "    throw 1;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void deallocThrow3() {
@@ -151,14 +172,14 @@ class TestExceptionSafety : public TestFixture {
               "    delete p;\n"
               "    throw 1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    static int* p = 0;\n"
               "    delete p;\n"
               "    throw 1;\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Exception thrown in invalid state, 'p' points at deallocated memory.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Exception thrown in invalid state, 'p' points at deallocated memory. [exceptDeallocThrow]\n", errout_str());
     }
 
     void rethrowCopy1() {
@@ -172,7 +193,7 @@ class TestExceptionSafety : public TestFixture {
               "        throw err;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8]: (style) Throwing a copy of the caught exception instead of rethrowing the original exception.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:9]: (style) Throwing a copy of the caught exception instead of rethrowing the original exception. [exceptRethrowCopy]\n", errout_str());
     }
 
     void rethrowCopy2() {
@@ -186,7 +207,7 @@ class TestExceptionSafety : public TestFixture {
               "        throw err;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8]: (style) Throwing a copy of the caught exception instead of rethrowing the original exception.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:9]: (style) Throwing a copy of the caught exception instead of rethrowing the original exception. [exceptRethrowCopy]\n", errout_str());
     }
 
     void rethrowCopy3() {
@@ -198,7 +219,7 @@ class TestExceptionSafety : public TestFixture {
               "        throw err;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (style) Throwing a copy of the caught exception instead of rethrowing the original exception.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:9]: (style) Throwing a copy of the caught exception instead of rethrowing the original exception. [exceptRethrowCopy]\n", errout_str());
     }
 
     void rethrowCopy4() {
@@ -213,7 +234,7 @@ class TestExceptionSafety : public TestFixture {
               "        throw err2;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void rethrowCopy5() {
@@ -230,7 +251,7 @@ class TestExceptionSafety : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:10]: (style) Throwing a copy of the caught exception instead of rethrowing the original exception.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:13]: (style) Throwing a copy of the caught exception instead of rethrowing the original exception. [exceptRethrowCopy]\n", errout_str());
 
         check("void f() {\n"
               "    try {\n"
@@ -245,7 +266,7 @@ class TestExceptionSafety : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void catchExceptionByValue() {
@@ -257,7 +278,7 @@ class TestExceptionSafety : public TestFixture {
               "        foo(err);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (style) Exception should be caught by reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5]: (style) Exception should be caught by reference. [catchExceptionByValue]\n", errout_str());
 
         check("void f() {\n"
               "    try {\n"
@@ -267,7 +288,7 @@ class TestExceptionSafety : public TestFixture {
               "        foo(err);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (style) Exception should be caught by reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5]: (style) Exception should be caught by reference. [catchExceptionByValue]\n", errout_str());
 
         check("void f() {\n"
               "    try {\n"
@@ -277,7 +298,7 @@ class TestExceptionSafety : public TestFixture {
               "        foo(err);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    try {\n"
@@ -287,7 +308,7 @@ class TestExceptionSafety : public TestFixture {
               "        foo(err);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    try {\n"
@@ -297,7 +318,7 @@ class TestExceptionSafety : public TestFixture {
               "        foo(err);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    try {\n"
@@ -307,7 +328,7 @@ class TestExceptionSafety : public TestFixture {
               "        foo(err);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    try {\n"
@@ -317,37 +338,64 @@ class TestExceptionSafety : public TestFixture {
               "        foo(err);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void noexceptThrow() {
-        check("void func1() noexcept(false) { throw 1; }\n"
+        check("void func1() noexcept(false) { try {} catch(...) {;} throw 1; }\n"
               "void func2() noexcept { throw 1; }\n"
               "void func3() noexcept(true) { throw 1; }\n"
               "void func4() noexcept(false) { throw 1; }\n"
               "void func5() noexcept(true) { func1(); }\n"
-              "void func6() noexcept(false) { func1(); }\n");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Exception thrown in function declared not to throw exceptions.\n"
-                      "[test.cpp:3]: (error) Exception thrown in function declared not to throw exceptions.\n"
-                      "[test.cpp:5]: (error) Exception thrown in function declared not to throw exceptions.\n", errout.str());
+              "void func6() noexcept(false) { func1(); }");
+        ASSERT_EQUALS("[test.cpp:2:25]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n"
+                      "[test.cpp:3:31]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n"
+                      "[test.cpp:5:31]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n", errout_str());
 
         // avoid false positives
-        check("const char *func() noexcept { return 0; }\n");
-        ASSERT_EQUALS("", errout.str());
+        check("const char *func() noexcept { return 0; }\n"
+              "const char *func1() noexcept { try { throw 1; } catch(...) {} return 0; }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n" // #14526
+              "    void f(int = 0, int = 1) { throw 0; }\n"
+              "};\n"
+              "void g() noexcept {\n"
+              "    A a;\n"
+              "    a.f();\n"
+              "}\n"
+              "void h() noexcept {\n"
+              "    A a;\n"
+              "    a.f(1, 3);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:7]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n"
+                      "[test.cpp:10:7]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n",
+                      errout_str());
     }
 
     void nothrowThrow() {
-        check("void func1() throw(int) { throw 1; }\n"
+        check("void func1() throw(int) { try {;} catch(...) { throw 1; } ; }\n"
               "void func2() throw() { throw 1; }\n"
               "void func3() throw(int) { throw 1; }\n"
               "void func4() throw() { func1(); }\n"
-              "void func5() throw(int) { func1(); }\n");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Exception thrown in function declared not to throw exceptions.\n"
-                      "[test.cpp:4]: (error) Exception thrown in function declared not to throw exceptions.\n", errout.str());
+              "void func5() throw(int) { func1(); }");
+        ASSERT_EQUALS("[test.cpp:2:24]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n"
+                      "[test.cpp:4:24]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n", errout_str());
 
         // avoid false positives
-        check("const char *func() throw() { return 0; }\n");
-        ASSERT_EQUALS("", errout.str());
+        check("const char *func() throw() { return 0; }");
+        ASSERT_EQUALS("", errout_str());
+
+
+        // #11691: FP throwInNoexceptFunction with if constexpr in template
+        check("template<bool IsNoThrow>\n"
+              "static void foo(size_t Size) noexcept(IsNoThrow) {\n"
+              "    if constexpr (!IsNoThrow) {\n"
+              "        throw std::bad_alloc();\n"
+              "    }\n"
+              "}\n"
+              "foo<true>(123);\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void unhandledExceptionSpecification1() { // #4800
@@ -361,8 +409,8 @@ class TestExceptionSafety : public TestFixture {
               "  try {\n"
               "    myThrowingFoo();\n"
               "  } catch(MyException &) {}\n"
-              "}\n", true);
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:1]: (style, inconclusive) Unhandled exception specification when calling function myThrowingFoo().\n", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:5:3] -> [test.cpp:1:6]: (style, inconclusive) Unhandled exception specification when calling function myThrowingFoo(). [unhandledExceptionSpecification]\n", errout_str());
     }
 
     void unhandledExceptionSpecification2() {
@@ -370,20 +418,46 @@ class TestExceptionSafety : public TestFixture {
               "int main()\n"
               "{\n"
               "    f();\n"
-              "}\n", true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Unhandled exception thrown in function that is an entry point. [throwInEntryPoint]\n", errout_str());
+    }
+
+    void unhandledExceptionSpecification3() {
+        const char code[] = "void f() const throw (std::runtime_error);\n"
+                            "int _init() {\n"
+                            "    f();\n"
+                            "}\n"
+                            "int _fini() {\n"
+                            "    f();\n"
+                            "}\n"
+                            "int main()\n"
+                            "{\n"
+                            "    f();\n"
+                            "}\n";
+
+        check(code, dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:10:5]: (error) Unhandled exception thrown in function that is an entry point. [throwInEntryPoint]\n"
+                      "[test.cpp:3:5] -> [test.cpp:1:6]: (style, inconclusive) Unhandled exception specification when calling function f(). [unhandledExceptionSpecification]\n"
+                      "[test.cpp:6:5] -> [test.cpp:1:6]: (style, inconclusive) Unhandled exception specification when calling function f(). [unhandledExceptionSpecification]\n", errout_str());
+
+        const Settings s = settingsBuilder().library("gnu.cfg").build();
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.s = &s));
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Unhandled exception thrown in function that is an entry point. [throwInEntryPoint]\n"
+                      "[test.cpp:6:5]: (error) Unhandled exception thrown in function that is an entry point. [throwInEntryPoint]\n"
+                      "[test.cpp:10:5]: (error) Unhandled exception thrown in function that is an entry point. [throwInEntryPoint]\n",
+                      errout_str());
     }
 
     void nothrowAttributeThrow() {
         check("void func1() throw(int) { throw 1; }\n"
               "void func2() __attribute((nothrow)); void func2() { throw 1; }\n"
-              "void func3() __attribute((nothrow)); void func3() { func1(); }\n");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Exception thrown in function declared not to throw exceptions.\n"
-                      "[test.cpp:3]: (error) Exception thrown in function declared not to throw exceptions.\n", errout.str());
+              "void func3() __attribute((nothrow)); void func3() { func1(); }");
+        ASSERT_EQUALS("[test.cpp:2:53]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n"
+                      "[test.cpp:3:53]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n", errout_str());
 
         // avoid false positives
-        check("const char *func() __attribute((nothrow)); void func1() { return 0; }\n");
-        ASSERT_EQUALS("", errout.str());
+        check("const char *func() __attribute((nothrow)); void func1() { return 0; }");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nothrowAttributeThrow2() {
@@ -391,20 +465,83 @@ class TestExceptionSafety : public TestFixture {
               "  void copyMemberValues() throw () {\n"
               "      copyMemberValues();\n"
               "   }\n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nothrowDeclspecThrow() {
         check("void func1() throw(int) { throw 1; }\n"
               "void __declspec(nothrow) func2() { throw 1; }\n"
-              "void __declspec(nothrow) func3() { func1(); }\n");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Exception thrown in function declared not to throw exceptions.\n"
-                      "[test.cpp:3]: (error) Exception thrown in function declared not to throw exceptions.\n", errout.str());
+              "void __declspec(nothrow) func3() { func1(); }");
+        ASSERT_EQUALS("[test.cpp:2:36]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n"
+                      "[test.cpp:3:36]: (error) Unhandled exception thrown in function declared not to throw exceptions. [throwInNoexceptFunction]\n", errout_str());
 
         // avoid false positives
-        check("const char *func() __attribute((nothrow)); void func1() { return 0; }\n");
-        ASSERT_EQUALS("", errout.str());
+        check("const char *func() __attribute((nothrow)); void func1() { return 0; }");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void rethrowNoCurrentException1() {
+        check("void func1(const bool flag) { try{ if(!flag) throw; } catch (int&) { ; } }");
+        ASSERT_EQUALS("[test.cpp:1:46]: (error) Rethrowing current exception with 'throw;', it seems there is no current exception to rethrow."
+                      " If there is no current exception this calls std::terminate(). More: https://isocpp.org/wiki/faq/exceptions#throw-without-an-object [rethrowNoCurrentException]\n", errout_str());
+    }
+
+    void rethrowNoCurrentException2() {
+        check("void func1() { try{ ; } catch (...) { ; } throw; }");
+        ASSERT_EQUALS("[test.cpp:1:43]: (error) Rethrowing current exception with 'throw;', it seems there is no current exception to rethrow."
+                      " If there is no current exception this calls std::terminate(). More: https://isocpp.org/wiki/faq/exceptions#throw-without-an-object [rethrowNoCurrentException]\n", errout_str());
+    }
+
+    void rethrowNoCurrentException3() {
+        check("void on_error() { try { throw; } catch (const int &) { ; } catch (...) { ; } }\n"      // exception dispatcher idiom
+              "void func2() { try{ ; } catch (const int&) { throw; } ; }\n"
+              "void func3() { throw 0; }");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void noFunctionCall() {
+        check("void f() {\n" // #13803
+              "    throw \"error\";\n"
+              "}\n"
+              "void g() noexcept {\n"
+              "    auto pF = &f;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void entryPoint() {
+        check("void f(int i) {\n" // #14195
+              "    if (i < 2)\n"
+              "        throw 0;\n"
+              "}\n"
+              "int main(int argc, char* argv[]) {\n"
+              "    f(argc);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:5]: (error) Unhandled exception thrown in function that is an entry point. [throwInEntryPoint]\n",
+                      errout_str());
+
+        check("void f(int i) {\n"
+              "    if (i < 2)\n"
+              "        throw 0;\n"
+              "}\n"
+              "int main(int argc, char* argv[]) {\n"
+              "    try {\n"
+              "        f(argc);\n"
+              "    } catch (...) {\n"
+              "        return 1;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int i) {\n" // #9380
+              "    throw i;\n"
+              "}\n"
+              "int main() {\n"
+              "    f(123);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:5]: (error) Unhandled exception thrown in function that is an entry point. [throwInEntryPoint]\n",
+                      errout_str());
     }
 };
 
diff --git a/test/testexecutor.cpp b/test/testexecutor.cpp
new file mode 100644
index 00000000000..30b2b834834
--- /dev/null
+++ b/test/testexecutor.cpp
@@ -0,0 +1,88 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+#include "errorlogger.h"
+#include "errortypes.h"
+#include "executor.h"
+#include "filesettings.h"
+#include "fixture.h"
+#include "helpers.h"
+#include "settings.h"
+#include "standards.h"
+#include "suppressions.h"
+
+#include <list>
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+class DummyExecutor : public Executor
+{
+public:
+    DummyExecutor(const std::list<FileWithDetails> &files, const std::list<FileSettings>& fileSettings, const Settings &settings, Suppressions &suppressions, ErrorLogger &errorLogger)
+        : Executor(files, fileSettings, settings, suppressions, errorLogger, nullptr)
+    {}
+
+    NORETURN unsigned int check() override
+    {
+        throw std::runtime_error("not implemented");
+    }
+
+    bool hasToLog_(const ErrorMessage &msg)
+    {
+        return hasToLog(msg);
+    }
+};
+
+class TestExecutor : public TestFixture {
+public:
+    TestExecutor() : TestFixture("TestExecutor") {}
+
+private:
+    void run() override {
+        TEST_CASE(hasToLogSimple);
+    }
+
+    void hasToLogSimple() {
+        const std::list<FileWithDetails> files{FileWithDetails{"test.c", Standards::Language::C, 0}};
+        const std::list<FileSettings> fileSettings;
+        // this is the "simple" format
+        const auto settings = dinit(Settings,
+                                    $.templateFormat = "{file}:{line}:{column}: {severity}:{inconclusive:inconclusive:} {message} [{id}]");
+        Suppressions supprs;
+        DummyExecutor executor(files, fileSettings, settings, supprs, *this);
+
+        ErrorMessage::FileLocation loc1("test.c", 1, 2);
+        ErrorMessage msg({std::move(loc1)}, "test.c", Severity::error, "error", "id", Certainty::normal);
+
+        ASSERT(executor.hasToLog_(msg));
+        ASSERT(!executor.hasToLog_(msg));
+
+        ErrorMessage::FileLocation loc2("test.c", 1, 12);
+        msg.callStack = {std::move(loc2)};
+
+        ASSERT(executor.hasToLog_(msg));
+
+        msg.id = "id2";
+
+        ASSERT(executor.hasToLog_(msg));
+    }
+};
+
+REGISTER_TEST(TestExecutor)
diff --git a/test/testexprengine.cpp b/test/testexprengine.cpp
deleted file mode 100644
index 15da29fb6fc..00000000000
--- a/test/testexprengine.cpp
+++ /dev/null
@@ -1,312 +0,0 @@
-/*
- * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "exprengine.h"
-#include "settings.h"
-#include "symboldatabase.h"
-#include "tokenize.h"
-#include "testsuite.h"
-
-#include <limits>
-#include <string>
-
-class TestExprEngine : public TestFixture {
-public:
-    TestExprEngine() : TestFixture("TestExprEngine") {
-    }
-
-private:
-    void run() OVERRIDE {
-#ifdef USE_Z3
-        TEST_CASE(expr1);
-        TEST_CASE(expr2);
-        TEST_CASE(expr3);
-        TEST_CASE(expr4);
-        TEST_CASE(expr5);
-        TEST_CASE(exprAssign1);
-        TEST_CASE(exprAssign2); // Truncation
-
-        TEST_CASE(if1);
-        TEST_CASE(ifelse1);
-
-        TEST_CASE(array1);
-        TEST_CASE(array2);
-        TEST_CASE(array3);
-        TEST_CASE(array4);
-        TEST_CASE(arrayInit1);
-        TEST_CASE(arrayInit2);
-        TEST_CASE(arrayUninit);
-
-        TEST_CASE(floatValue1);
-        TEST_CASE(floatValue2);
-
-        TEST_CASE(functionCall1);
-        TEST_CASE(functionCall2);
-        TEST_CASE(functionCall3);
-
-        TEST_CASE(int1);
-
-        TEST_CASE(pointer1);
-        TEST_CASE(pointerAlias1);
-        TEST_CASE(pointerAlias2);
-        TEST_CASE(pointerAlias3);
-        TEST_CASE(pointerAlias4);
-        TEST_CASE(pointerNull1);
-
-        TEST_CASE(structMember);
-#endif
-    }
-
-    std::string expr(const char code[], const std::string &binop) {
-        Settings settings;
-        settings.platform(cppcheck::Platform::Unix64);
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        std::string ret;
-        std::function<void(const Token *, const ExprEngine::Value &, ExprEngine::DataBase *)> f = [&](const Token *tok, const ExprEngine::Value &value, ExprEngine::DataBase *dataBase) {
-            if (tok->str() != binop)
-                return;
-            auto b = dynamic_cast<const ExprEngine::BinOpResult *>(&value);
-            if (!b)
-                return;
-            ret = b->getExpr(dataBase);
-        };
-        std::vector<ExprEngine::Callback> callbacks;
-        callbacks.push_back(f);
-        std::ostringstream dummy;
-        ExprEngine::executeAllFunctions(&tokenizer, &settings, callbacks, dummy);
-        return ret;
-    }
-
-    std::string getRange(const char code[], const std::string &str, int linenr = 0) {
-        Settings settings;
-        settings.platform(cppcheck::Platform::Unix64);
-        settings.library.smartPointers.insert("std::shared_ptr");
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        std::string ret;
-        std::function<void(const Token *, const ExprEngine::Value &, ExprEngine::DataBase *)> f = [&](const Token *tok, const ExprEngine::Value &value, ExprEngine::DataBase *dataBase) {
-            (void)dataBase;
-            if ((linenr == 0 || linenr == tok->linenr()) && tok->expressionString() == str) {
-                if (!ret.empty())
-                    ret += ",";
-                ret += value.getRange();
-            }
-        };
-        std::vector<ExprEngine::Callback> callbacks;
-        callbacks.push_back(f);
-        std::ostringstream dummy;
-        ExprEngine::executeAllFunctions(&tokenizer, &settings, callbacks, dummy);
-        return ret;
-    }
-
-    std::string trackExecution(const char code[]) {
-        Settings settings;
-        settings.debugVerification = true;
-        settings.platform(cppcheck::Platform::Unix64);
-        settings.library.smartPointers.insert("std::shared_ptr");
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        std::vector<ExprEngine::Callback> dummy;
-        std::ostringstream ret;
-        ExprEngine::executeAllFunctions(&tokenizer, &settings, dummy, ret);
-        return ret.str();
-    }
-
-    void expr1() {
-        ASSERT_EQUALS("-32768:32767", getRange("void f(short x) { a = x; }", "x"));
-    }
-
-    void expr2() {
-        ASSERT_EQUALS("($1)+($1)", getRange("void f(short x) { a = x + x; }", "x+x"));
-    }
-
-    void expr3() {
-        ASSERT_EQUALS("($1)+($1)", getRange("int f(short x) { int a = x + x; return a; }", "return a"));
-    }
-
-    void expr4() {
-        ASSERT_EQUALS("($1)-($1)", getRange("int f(short x) { int a = x - x; return a; }", "return a"));
-    }
-
-    void expr5() {
-        ASSERT_EQUALS("($1)+($2)", getRange("void f(short a, short b, short c, short d) { if (a+b<c+d) {} }", "a+b"));
-    }
-
-    void exprAssign1() {
-        ASSERT_EQUALS("($1)+(1)", getRange("void f(unsigned char a) { a += 1; }", "a+=1"));
-    }
-
-    void exprAssign2() {
-        ASSERT_EQUALS("2", getRange("void f(unsigned char x) { x = 258; int a = x }", "a=x"));
-    }
-
-    void if1() {
-        ASSERT_EQUALS("(declare-fun v0 () Int)\n"
-                      "(declare-fun v1 () Int)\n"
-                      "(assert (<= v0 2147483647))\n"
-                      "(assert (>= v0 (- 2147483648)))\n"
-                      "(assert (<= v1 2147483647))\n"
-                      "(assert (>= v1 (- 2147483648)))\n"
-                      "(assert (< v0 v1))\n"
-                      "(assert (= v0 v1))\n",
-                      expr("void f(int x, int y) { if (x < y) return x == y; }", "=="));
-    }
-
-    void ifelse1() {
-        ASSERT_EQUALS("(declare-fun v0 () Int)\n"
-                      "(assert (<= v0 32767))\n"
-                      "(assert (>= v0 (- 32768)))\n"
-                      "(assert (<= v0 5))\n"
-                      "(assert (= (+ v0 2) 40))\n",
-                      expr("void f(short x) { if (x > 5) ; else if (x+2==40); }", "=="));
-    }
-
-
-    void array1() {
-        ASSERT_EQUALS("(assert (= 5 0))\n",
-                      expr("int f() { int arr[10]; arr[4] = 5; return arr[4]==0; }", "=="));
-    }
-
-    void array2() {
-        ASSERT_EQUALS("(declare-fun v0 () Int)\n"
-                      "(assert (<= v0 255))\n"
-                      "(assert (>= v0 0))\n"
-                      "(assert (= v0 365))\n",
-                      expr("void dostuff(unsigned char *); int f() { unsigned char arr[10] = \"\"; dostuff(arr); return arr[4] == 365; }", "=="));
-    }
-
-    void array3() {
-        const char code[] = "void f(unsigned char x) { int arr[10]; arr[4] = 43; return arr[x] == 12; }";
-        ASSERT_EQUALS("?,43", getRange(code, "arr[x]"));
-        // TODO: ASSERT_EQUALS("", expr(code, "=="));
-    }
-
-    void array4() {
-        const char code[] = "int buf[10];\n"
-                            "void f() { int x = buf[0]; }";
-        ASSERT_EQUALS("2:16: $2:0=-2147483648:2147483647\n"
-                      "2:20: $2=-2147483648:2147483647\n"
-                      "2:26: { buf=($1,size=10,[:]=$2) x=$2:0}\n",
-                      trackExecution(code));
-    }
-
-    void arrayInit1() {
-        ASSERT_EQUALS("0", getRange("inf f() { char arr[10] = \"\"; return arr[4]; }", "arr[4]"));
-    }
-
-    void arrayInit2() {
-        ASSERT_EQUALS("66", getRange("void f() { char str[] = \"hello\"; str[0] = \'B\'; }", "str[0]=\'B\'"));
-    }
-
-    void arrayUninit() {
-        ASSERT_EQUALS("?", getRange("int f() { int arr[10]; return arr[4]; }", "arr[4]"));
-    }
-
-
-    void floatValue1() {
-        ASSERT_EQUALS(std::to_string(std::numeric_limits<float>::min()) + ":" + std::to_string(std::numeric_limits<float>::max()), getRange("float f; void func() { f=f; }", "f=f"));
-    }
-
-    void floatValue2() {
-        ASSERT_EQUALS("(29.0)/(2.0)", getRange("void func() { float f = 29.0; f = f / 2.0; }", "f/2.0"));
-    }
-
-
-    void functionCall1() {
-        ASSERT_EQUALS("-2147483648:2147483647", getRange("int atoi(const char *p); void f() { int x = atoi(a); x = x; }", "x=x"));
-    }
-
-    void functionCall2() {
-        const char code[] = "namespace NS {\n"
-                            "    short getValue();\n"
-                            "}"
-                            "void f() {\n"
-                            "    short value = NS::getValue();\n"
-                            "    value = value;\n"
-                            "}";
-        ASSERT_EQUALS("-32768:32767", getRange(code, "value=value"));
-    }
-
-    void functionCall3() {
-        ASSERT_EQUALS("-2147483648:2147483647", getRange("int fgets(int, const char *, void *); void f() { int x = -1; fgets(stdin, \"%d\", &x); x=x; }", "x=x"));
-    }
-
-
-    void int1() {
-        ASSERT_EQUALS("(declare-fun v0 () Int)\n"
-                      "(assert (<= v0 2147483647))\n"
-                      "(assert (>= v0 (- 2147483648)))\n"
-                      "(assert (= (+ 2 v0) 3))\n",
-                      expr("void f(int x) { return 2+x==3; }", "=="));
-    }
-
-
-    void pointer1() {
-        const char code[] = "void f(unsigned char *p) { a = *p; }";
-        ASSERT_EQUALS("->$1,null,->?", getRange(code, "p"));
-        // TODO expr
-    }
-
-    void pointerAlias1() {
-        ASSERT_EQUALS("3", getRange("int f() { int x; int *p = &x; x = 3; return *p; }", "return*p"));
-    }
-
-    void pointerAlias2() {
-        ASSERT_EQUALS("1", getRange("int f() { int x; int *p = &x; *p = 1; return *p; }", "return*p"));
-    }
-
-    void pointerAlias3() {
-        ASSERT_EQUALS("7", getRange("int f() {\n"
-                                    "  int x = 18;\n"
-                                    "  int *p = &x;\n"
-                                    "  *p = 7;\n"
-                                    "  return x;\n"
-                                    "}", "x", 5));
-    }
-
-    void pointerAlias4() {
-        ASSERT_EQUALS("71", getRange("int f() { int x[10]; int *p = x+3; *p = 71; return x[3]; }", "x[3]"));
-    }
-
-    void pointerNull1() {
-        ASSERT_EQUALS("1", getRange("void f(void *p) { p = NULL; p += 1; }", "p+=1"));
-    }
-
-
-    void structMember() {
-        ASSERT_EQUALS("(declare-fun v0 () Int)\n"
-                      "(declare-fun v1 () Int)\n"
-                      "(assert (<= v0 255))\n"
-                      "(assert (>= v0 0))\n"
-                      "(assert (<= v1 255))\n"
-                      "(assert (>= v1 0))\n"
-                      "(assert (= (+ v0 v1) 0))\n",
-                      expr("struct S {\n"
-                           "    unsigned char a;\n"
-                           "    unsigned char b;\n"
-                           "};\n"
-                           "void f(struct S s) { return s.a + s.b == 0; }", "=="));
-    }
-
-};
-
-REGISTER_TEST(TestExprEngine)
diff --git a/test/testfilelister.cpp b/test/testfilelister.cpp
index afe69bdd79d..13057735513 100644
--- a/test/testfilelister.cpp
+++ b/test/testfilelister.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,68 +17,187 @@
  */
 
 #include "filelister.h"
+#include "filesettings.h"
+#include "fixture.h"
+#include "path.h"
 #include "pathmatch.h"
-#include "testsuite.h"
+#include "standards.h"
 
-#include <cstddef>
-#include <fstream>
-#include <map>
+#include <algorithm>
+#include <list>
+#include <stdexcept>
 #include <string>
-#include <utility>
 
-#ifndef _WIN32
-#include <vector>
-#endif
-
-class TestFileLister: public TestFixture {
+class TestFileLister : public TestFixture {
 public:
-    TestFileLister()
-        :TestFixture("TestFileLister") {
-    }
+    TestFileLister() : TestFixture("TestFileLister") {}
 
 private:
-    void run() OVERRIDE {
-        // bail out if the tests are not executed from the base folder
-        {
-            std::ifstream fin("test/testfilelister.cpp");
-            if (!fin.is_open())
-                return;
-        }
-
-        TEST_CASE(isDirectory);
+    void run() override {
         TEST_CASE(recursiveAddFiles);
+        TEST_CASE(recursiveAddFilesEmptyPath);
+        TEST_CASE(excludeFile1);
+        TEST_CASE(excludeFile2);
+        TEST_CASE(excludeDir);
+        TEST_CASE(addFiles);
     }
 
-    void isDirectory() const {
-        ASSERT_EQUALS(false, FileLister::isDirectory("readme.txt"));
-        ASSERT_EQUALS(true, FileLister::isDirectory("lib"));
+    // TODO: generate file list instead
+    static std::string findBaseDir() {
+        std::string basedir;
+        while (!Path::isDirectory(Path::join(basedir, ".github"))) {
+            const std::string abspath = Path::getAbsoluteFilePath(basedir);
+            basedir += "../";
+            // no more going up
+            if (Path::getAbsoluteFilePath(basedir) == abspath)
+                throw std::runtime_error("could not find repository root directory");
+        }
+        return basedir;
     }
 
     void recursiveAddFiles() const {
+        const std::string adddir = findBaseDir() + ".";
+
         // Recursively add add files..
-        std::map<std::string, std::size_t> files;
-        std::vector<std::string> masks;
-        PathMatch matcher(masks);
-        FileLister::recursiveAddFiles(files, ".", matcher);
-
-        // In case there are leading "./"..
-        for (std::map<std::string, std::size_t>::iterator i = files.begin(); i != files.end();) {
-            if (i->first.compare(0,2,"./") == 0) {
-                files[i->first.substr(2)] = i->second;
-                files.erase(i++);
-            } else
-                ++i;
-        }
+        std::list<FileWithDetails> files;
+        std::string err = FileLister::recursiveAddFiles(files, adddir, {}, PathMatch());
+        ASSERT_EQUALS("", err);
+
+        ASSERT(!files.empty());
+
+#ifdef _WIN32
+        std::string dirprefix;
+        if (adddir != ".")
+            dirprefix = adddir + "/";
+#else
+        const std::string dirprefix = adddir + "/";
+#endif
+
+        const auto find_file = [&](const std::string& name) {
+            return std::find_if(files.cbegin(), files.cend(), [&name](const FileWithDetails& entry) {
+                return entry.path() == name;
+            });
+        };
 
         // Make sure source files are added..
-        ASSERT(files.find("cli/main.cpp") != files.end());
-        ASSERT(files.find("lib/token.cpp") != files.end());
-        ASSERT(files.find("lib/tokenize.cpp") != files.end());
-        ASSERT(files.find("test/testfilelister.cpp") != files.end());
+        auto it = find_file(dirprefix + "cli/main.cpp");
+        ASSERT(it != files.end());
+        ASSERT_EQUALS_ENUM(Standards::Language::CPP, it->lang());
+
+        it = find_file(dirprefix + "lib/token.cpp");
+        ASSERT(it != files.end());
+        ASSERT_EQUALS_ENUM(Standards::Language::CPP, it->lang());
+
+        it = find_file(dirprefix + "lib/tokenize.cpp");
+        ASSERT(it != files.end());
+        ASSERT_EQUALS_ENUM(Standards::Language::CPP, it->lang());
+
+        it = find_file(dirprefix + "gui/main.cpp");
+        ASSERT(it != files.end());
+        ASSERT_EQUALS_ENUM(Standards::Language::CPP, it->lang());
+
+        it = find_file(dirprefix + "test/testfilelister.cpp");
+        ASSERT(it != files.end());
+        ASSERT_EQUALS_ENUM(Standards::Language::CPP, it->lang());
 
         // Make sure headers are not added..
-        ASSERT(files.find("lib/tokenize.h") == files.end());
+        ASSERT(find_file(dirprefix + "lib/tokenize.h") == files.end());
+    }
+
+    void recursiveAddFilesEmptyPath() const {
+        std::list<FileWithDetails> files;
+        const std::string err = FileLister::recursiveAddFiles(files, "", {}, PathMatch());
+        ASSERT_EQUALS("no path specified", err);
+    }
+
+    void excludeFile1() const {
+        const std::string basedir = findBaseDir();
+
+        std::list<FileWithDetails> files;
+        PathMatch matcher({"lib/token.cpp"});
+        std::string err = FileLister::recursiveAddFiles(files, basedir + "lib/token.cpp", {}, matcher);
+        ASSERT_EQUALS("", err);
+        ASSERT(files.empty());
+    }
+
+    void excludeFile2() const {
+        const std::string basedir = findBaseDir();
+
+        std::list<FileWithDetails> files;
+        std::string err = FileLister::recursiveAddFiles(files, basedir + "lib/token.cpp", {}, PathMatch());
+        ASSERT_EQUALS("", err);
+        ASSERT_EQUALS(1, files.size());
+        ASSERT_EQUALS(basedir + "lib/token.cpp", files.begin()->path());
+    }
+
+    void excludeDir() const {
+        const std::string basedir = findBaseDir() + ".";
+
+        std::list<FileWithDetails> files;
+        PathMatch matcher({"lib/"});
+        std::string err = FileLister::recursiveAddFiles(files, basedir, {}, matcher);
+        ASSERT_EQUALS("", err);
+        ASSERT(!files.empty());
+        const auto it = std::find_if(files.cbegin(), files.cend(), [](const FileWithDetails& f){
+            return f.spath().find("/lib/") != std::string::npos;
+        });
+        ASSERT(it == files.cend());
     }
+
+    void addFiles() const {
+        const std::string adddir = findBaseDir() + ".";
+
+        // TODO: on Windows the prefix is different from when a recursive a folder (see recursiveAddFiles test)
+        const std::string dirprefix = adddir + "/";
+#ifdef _WIN32
+        const std::string dirprefix_nat = Path::toNativeSeparators(dirprefix);
+#endif
+
+        std::list<FileWithDetails> files;
+
+        {
+            const std::string addfile = Path::join(Path::join(adddir, "cli"), "main.cpp");
+            const std::string err = FileLister::addFiles(files, addfile, {}, true,PathMatch());
+            ASSERT_EQUALS("", err);
+        }
+        {
+            const std::string addfile = Path::join(Path::join(adddir, "lib"), "token.cpp");
+            const std::string err = FileLister::addFiles(files, addfile, {}, true,PathMatch());
+            ASSERT_EQUALS("", err);
+        }
+        {
+            const std::string addfile = Path::join(Path::join(adddir, "cli"), "token.cpp"); // does not exist
+            const std::string err = FileLister::addFiles(files, addfile, {}, true,PathMatch());
+            ASSERT_EQUALS("", err);
+        }
+        {
+            const std::string addfile = Path::join(Path::join(adddir, "lib2"), "token.cpp"); // does not exist
+            const std::string err = FileLister::addFiles(files, addfile, {}, true,PathMatch());
+            ASSERT_EQUALS("", err);
+        }
+        {
+            const std::string addfile = Path::join(Path::join(adddir, "lib"), "matchcompiler.h");
+            const std::string err = FileLister::addFiles(files, addfile, {}, true,PathMatch());
+            ASSERT_EQUALS("", err);
+        }
+
+        ASSERT_EQUALS(3, files.size());
+        auto it = files.cbegin();
+        ASSERT_EQUALS(dirprefix + "cli/main.cpp", it->path());
+        ASSERT_EQUALS(Path::simplifyPath(dirprefix + "cli/main.cpp"), it->spath());
+        ASSERT_EQUALS_ENUM(Standards::Language::None, it->lang());
+        it++;
+        ASSERT_EQUALS(dirprefix + "lib/token.cpp", it->path());
+        ASSERT_EQUALS(Path::simplifyPath(dirprefix + "lib/token.cpp"), it->spath());
+        ASSERT_EQUALS_ENUM(Standards::Language::None, it->lang());
+        it++;
+        ASSERT_EQUALS(dirprefix + "lib/matchcompiler.h", it->path());
+        ASSERT_EQUALS(Path::simplifyPath(dirprefix + "lib/matchcompiler.h"), it->spath());
+        ASSERT_EQUALS_ENUM(Standards::Language::None, it->lang());
+    }
+
+    // TODO: test errors
+    // TODO: test wildcards
 };
 
 REGISTER_TEST(TestFileLister)
diff --git a/test/testfilesettings.cpp b/test/testfilesettings.cpp
new file mode 100644
index 00000000000..c815cb8aa01
--- /dev/null
+++ b/test/testfilesettings.cpp
@@ -0,0 +1,78 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "filesettings.h"
+#include "fixture.h"
+#include "standards.h"
+
+class TestFileSettings : public TestFixture {
+public:
+    TestFileSettings() : TestFixture("TestFileSettings") {}
+
+private:
+    void run() override {
+        TEST_CASE(test);
+    }
+
+    void test() const {
+        {
+            const FileWithDetails p{"file.c", Standards::Language::C, 456};
+            ASSERT_EQUALS("file.c", p.path());
+            ASSERT_EQUALS("file.c", p.spath());
+            ASSERT_EQUALS_ENUM(Standards::Language::C, p.lang());
+            ASSERT_EQUALS(456, p.size());
+        }
+        {
+            const FileWithDetails p{"file.cpp", Standards::Language::CPP, 123};
+            ASSERT_EQUALS("file.cpp", p.path());
+            ASSERT_EQUALS("file.cpp", p.spath());
+            ASSERT_EQUALS_ENUM(Standards::Language::CPP, p.lang());
+            ASSERT_EQUALS(123, p.size());
+        }
+        {
+            const FileWithDetails p{"in/file.cpp", Standards::Language::CPP, 123};
+            ASSERT_EQUALS("in/file.cpp", p.path());
+            ASSERT_EQUALS("in/file.cpp", p.spath());
+            ASSERT_EQUALS_ENUM(Standards::Language::CPP, p.lang());
+            ASSERT_EQUALS(123, p.size());
+        }
+        {
+            const FileWithDetails p{"in\\file.cpp", Standards::Language::CPP, 123};
+            ASSERT_EQUALS("in\\file.cpp", p.path());
+            ASSERT_EQUALS("in/file.cpp", p.spath());
+            ASSERT_EQUALS_ENUM(Standards::Language::CPP, p.lang());
+            ASSERT_EQUALS(123, p.size());
+        }
+        {
+            const FileWithDetails p{"in/../file.cpp", Standards::Language::CPP, 123};
+            ASSERT_EQUALS("in/../file.cpp", p.path());
+            ASSERT_EQUALS("file.cpp", p.spath());
+            ASSERT_EQUALS_ENUM(Standards::Language::CPP, p.lang());
+            ASSERT_EQUALS(123, p.size());
+        }
+        {
+            const FileWithDetails p{"in\\..\\file.cpp", Standards::Language::CPP, 123};
+            ASSERT_EQUALS("in\\..\\file.cpp", p.path());
+            ASSERT_EQUALS("file.cpp", p.spath());
+            ASSERT_EQUALS_ENUM(Standards::Language::CPP, p.lang());
+            ASSERT_EQUALS(123, p.size());
+        }
+    }
+};
+
+REGISTER_TEST(TestFileSettings)
diff --git a/test/testfrontend.cpp b/test/testfrontend.cpp
new file mode 100644
index 00000000000..ef6b774181a
--- /dev/null
+++ b/test/testfrontend.cpp
@@ -0,0 +1,147 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <filesettings.h>
+
+#include "fixture.h"
+#include "frontend.h"
+#include "settings.h"
+#include "standards.h"
+
+#include <list>
+#include <string>
+
+class TestFrontend : public TestFixture {
+public:
+    TestFrontend() : TestFixture("TestFrontend") {}
+
+private:
+    void run() override {
+        TEST_CASE(applyLangFS);
+        TEST_CASE(applyLangFiles);
+    }
+
+    void applyLangFS() const {
+        const char xmldata[] = R"(<def format="2"><markup ext=".ml" reporterrors="false"/></def>)";
+        const Settings s = settingsBuilder().libraryxml(xmldata).build();
+
+        const std::list<FileSettings> fs = {
+            {"nolang", Standards::Language::None, 0 },
+            {"c", Standards::Language::None, 0 }, // TODO: should be C - FileSettings are currently expected to not be pre-identified
+            {"cpp", Standards::Language::None, 0 }, // TODO: should be CPP - FileSettings arecurrently expected to not be pre-identified
+            {"nolang.c", Standards::Language::None, 0 },
+            {"nolang.cpp", Standards::Language::None, 0 },
+            {"nolang.ml", Standards::Language::None, 0 }
+        };
+
+        // no language to enforce - identify only
+        {
+            std::list<FileSettings> fs1 = fs;
+            frontend::applyLang(fs1, s, Standards::Language::None);
+            auto it = fs1.cbegin();
+            ASSERT_EQUALS_ENUM((it++)->file.lang(), Standards::Language::CPP); // unknown defaults to C++
+            ASSERT_EQUALS_ENUM((it++)->file.lang(), Standards::Language::CPP); // unknown defaults to C++
+            ASSERT_EQUALS_ENUM((it++)->file.lang(), Standards::Language::CPP); // unknown defaults to C++
+            ASSERT_EQUALS_ENUM((it++)->file.lang(), Standards::Language::C);
+            ASSERT_EQUALS_ENUM((it++)->file.lang(), Standards::Language::CPP);
+            ASSERT_EQUALS_ENUM((it++)->file.lang(), Standards::Language::C); // markup files are always C
+        }
+
+        // language to enforce (C)
+        {
+            std::list<FileSettings> fs1 = fs;
+            frontend::applyLang(fs1, s, Standards::Language::C);
+            auto it = fs1.cbegin();
+            ASSERT_EQUALS_ENUM((it++)->file.lang(), Standards::Language::C);
+            ASSERT_EQUALS_ENUM((it++)->file.lang(), Standards::Language::C);
+            ASSERT_EQUALS_ENUM((it++)->file.lang(), Standards::Language::C);
+            ASSERT_EQUALS_ENUM((it++)->file.lang(), Standards::Language::C);
+            ASSERT_EQUALS_ENUM((it++)->file.lang(), Standards::Language::C);
+            ASSERT_EQUALS_ENUM((it++)->file.lang(), Standards::Language::C); // markup files are always C
+        }
+
+        // language to enforce (C++)
+        {
+            std::list<FileSettings> fs1 = fs;
+            frontend::applyLang(fs1, s, Standards::Language::CPP);
+            auto it = fs1.cbegin();
+            ASSERT_EQUALS_ENUM((it++)->file.lang(), Standards::Language::CPP);
+            ASSERT_EQUALS_ENUM((it++)->file.lang(), Standards::Language::CPP);
+            ASSERT_EQUALS_ENUM((it++)->file.lang(), Standards::Language::CPP);
+            ASSERT_EQUALS_ENUM((it++)->file.lang(), Standards::Language::CPP);
+            ASSERT_EQUALS_ENUM((it++)->file.lang(), Standards::Language::CPP);
+            ASSERT_EQUALS_ENUM((it++)->file.lang(), Standards::Language::C); // markup files are always C
+        }
+    }
+
+    void applyLangFiles() const
+    {
+        const char xmldata[] = R"(<def format="2"><markup ext=".ml" reporterrors="false"/></def>)";
+        const Settings s = settingsBuilder().libraryxml(xmldata).build();
+
+        const std::list<FileWithDetails> fs = {
+            {"nolang", Standards::Language::None, 0 },
+            {"c", Standards::Language::C, 0 },
+            {"cpp", Standards::Language::CPP, 0 },
+            {"nolang.c", Standards::Language::None, 0 },
+            {"nolang.cpp", Standards::Language::None, 0 },
+            {"nolang.ml", Standards::Language::None, 0 }
+        };
+
+        // no language to enforce - identify only
+        {
+            std::list<FileWithDetails> fs1 = fs;
+            frontend::applyLang(fs1, s, Standards::Language::None);
+            auto it = fs1.cbegin();
+            ASSERT_EQUALS_ENUM((it++)->lang(), Standards::Language::CPP); // unknown defaults to C++
+            ASSERT_EQUALS_ENUM((it++)->lang(), Standards::Language::C);
+            ASSERT_EQUALS_ENUM((it++)->lang(), Standards::Language::CPP);
+            ASSERT_EQUALS_ENUM((it++)->lang(), Standards::Language::C);
+            ASSERT_EQUALS_ENUM((it++)->lang(), Standards::Language::CPP);
+            ASSERT_EQUALS_ENUM((it++)->lang(), Standards::Language::C); // markup files are always C
+        }
+
+        // language to enforce (C)
+        {
+            std::list<FileWithDetails> fs1 = fs;
+            frontend::applyLang(fs1, s, Standards::Language::C);
+            auto it = fs1.cbegin();
+            ASSERT_EQUALS_ENUM((it++)->lang(), Standards::Language::C);
+            ASSERT_EQUALS_ENUM((it++)->lang(), Standards::Language::C);
+            ASSERT_EQUALS_ENUM((it++)->lang(), Standards::Language::C);
+            ASSERT_EQUALS_ENUM((it++)->lang(), Standards::Language::C);
+            ASSERT_EQUALS_ENUM((it++)->lang(), Standards::Language::C);
+            ASSERT_EQUALS_ENUM((it++)->lang(), Standards::Language::C); // markup files are always C
+        }
+
+        // language to enforce (C++)
+        {
+            std::list<FileWithDetails> fs1 = fs;
+            frontend::applyLang(fs1, s, Standards::Language::CPP);
+            auto it = fs1.cbegin();
+            ASSERT_EQUALS_ENUM((it++)->lang(), Standards::Language::CPP);
+            ASSERT_EQUALS_ENUM((it++)->lang(), Standards::Language::CPP);
+            ASSERT_EQUALS_ENUM((it++)->lang(), Standards::Language::CPP);
+            ASSERT_EQUALS_ENUM((it++)->lang(), Standards::Language::CPP);
+            ASSERT_EQUALS_ENUM((it++)->lang(), Standards::Language::CPP);
+            ASSERT_EQUALS_ENUM((it++)->lang(), Standards::Language::C); // markup files are always C
+        }
+    }
+};
+
+REGISTER_TEST(TestFrontend)
diff --git a/test/testfunctions.cpp b/test/testfunctions.cpp
index 70c2f762192..feb7f2a666f 100644
--- a/test/testfunctions.cpp
+++ b/test/testfunctions.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,34 +16,27 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <tinyxml2.h>
-
 #include "checkfunctions.h"
-#include "library.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
+#include "platform.h"
 #include "settings.h"
 #include "standards.h"
-#include "testsuite.h"
-#include "tokenize.h"
 
+#include <cstddef>
+#include <string>
 
 class TestFunctions : public TestFixture {
 public:
-    TestFunctions() : TestFixture("TestFunctions") {
-    }
+    TestFunctions() : TestFixture("TestFunctions") {}
 
 private:
-    Settings settings;
-
-    void run() OVERRIDE {
-        settings.addEnabled("style");
-        settings.addEnabled("warning");
-        settings.addEnabled("portability");
-        settings.libraries.emplace_back("posix");
-        settings.standards.c = Standards::C11;
-        settings.standards.cpp = Standards::CPP11;
-        LOAD_LIB_2(settings.library, "std.cfg");
-        LOAD_LIB_2(settings.library, "posix.cfg");
+    const Settings settings = settingsBuilder().severity(Severity::style).severity(Severity::warning).severity(Severity::performance).severity(Severity::portability).
+                              certainty(Certainty::inconclusive).c(Standards::C11).cpp(Standards::CPP11).library("std.cfg").library("posix.cfg").build();
 
+    void run() override {
+        mNewTemplate = true;
         // Prohibited functions
         TEST_CASE(prohibitedFunctions_posix);
         TEST_CASE(prohibitedFunctions_index);
@@ -62,7 +55,10 @@ class TestFunctions : public TestFixture {
 
         // Invalid function usage
         TEST_CASE(invalidFunctionUsage1);
-        // TODO TEST_CASE(invalidFunctionUsageStrings);
+        TEST_CASE(invalidFunctionUsageStrings);
+
+        // Invalid function argument
+        TEST_CASE(invalidFunctionArg1);
 
         // Math function usage
         TEST_CASE(mathfunctionCall_fmod);
@@ -76,26 +72,67 @@ class TestFunctions : public TestFixture {
 
         // Ignored return value
         TEST_CASE(checkIgnoredReturnValue);
+        TEST_CASE(checkIgnoredErrorCode);
 
         // memset..
         TEST_CASE(memsetZeroBytes);
         TEST_CASE(memsetInvalid2ndParam);
+
+        // missing "return"
+        TEST_CASE(checkMissingReturn1);
+        TEST_CASE(checkMissingReturn2); // #11798
+        TEST_CASE(checkMissingReturn3);
+        TEST_CASE(checkMissingReturn4);
+        TEST_CASE(checkMissingReturn5);
+        TEST_CASE(checkMissingReturn6); // #13180
+        TEST_CASE(checkMissingReturn7); // #14370 - FN try/catch
+        TEST_CASE(checkMissingReturnStdInt); // #14482 - FN std::int32_t
+
+        // std::move for locar variable
+        TEST_CASE(returnLocalStdMove1);
+        TEST_CASE(returnLocalStdMove2);
+        TEST_CASE(returnLocalStdMove3);
+        TEST_CASE(returnLocalStdMove4);
+
+        TEST_CASE(returnLocalStdMove5);
+
+        TEST_CASE(negativeMemoryAllocationSizeError); // #389
+
+        TEST_CASE(checkLibraryMatchFunctions);
+
+        TEST_CASE(checkUseStandardLibrary1);
+        TEST_CASE(checkUseStandardLibrary2);
+        TEST_CASE(checkUseStandardLibrary3);
+        TEST_CASE(checkUseStandardLibrary4);
+        TEST_CASE(checkUseStandardLibrary5);
+        TEST_CASE(checkUseStandardLibrary6);
+        TEST_CASE(checkUseStandardLibrary7);
+        TEST_CASE(checkUseStandardLibrary8);
+        TEST_CASE(checkUseStandardLibrary9);
+        TEST_CASE(checkUseStandardLibrary10);
+        TEST_CASE(checkUseStandardLibrary11);
+        TEST_CASE(checkUseStandardLibrary12);
+        TEST_CASE(checkUseStandardLibrary13);
+        TEST_CASE(checkUseStandardLibrary14);
     }
 
-    void check(const char code[], const char filename[]="test.cpp", const Settings* settings_=nullptr) {
-        // Clear the error buffer..
-        errout.str("");
+    struct CheckOptions
+    {
+        bool cpp = true;
+    };
 
-        if (!settings_)
-            settings_ = &settings;
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
+        check_(file, line, code, settings, options.cpp);
+    }
 
-        // Tokenize..
-        Tokenizer tokenizer(settings_, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, filename);
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const Settings& s, bool cpp = true) {
+        SimpleTokenizer tokenizer(s, *this, cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
-        CheckFunctions checkFunctions(&tokenizer, settings_, this);
-        checkFunctions.runChecks(&tokenizer, settings_, this);
+        runChecks<CheckFunctions>(tokenizer, this);
     }
 
     void prohibitedFunctions_posix() {
@@ -103,14 +140,14 @@ class TestFunctions : public TestFixture {
               "{\n"
               "    bsd_signal(SIGABRT, SIG_IGN);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Obsolescent function 'bsd_signal' called. It is recommended to use 'sigaction' instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (style) Obsolescent function 'bsd_signal' called. It is recommended to use 'sigaction' instead. [bsd_signalCalled]\n", errout_str());
 
         check("int f()\n"
               "{\n"
               "    int bsd_signal(0);\n"
               "    return bsd_signal;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -119,7 +156,7 @@ class TestFunctions : public TestFixture {
               "        exit(1);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Obsolescent function 'gethostbyname' called. It is recommended to use 'getaddrinfo' instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:14]: (style) Obsolescent function 'gethostbyname' called. It is recommended to use 'getaddrinfo' instead. [gethostbynameCalled]\n", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -129,24 +166,25 @@ class TestFunctions : public TestFixture {
               "        exit(1);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (style) Obsolescent function 'gethostbyaddr' called. It is recommended to use 'getnameinfo' instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:14]: (style) Obsolescent function 'gethostbyaddr' called. It is recommended to use 'getnameinfo' instead. [gethostbyaddrCalled]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "    usleep( 1000 );\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Obsolescent function 'usleep' called. It is recommended to use 'nanosleep' or 'setitimer' instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (style) Obsolescent function 'usleep' called. It is recommended to use 'nanosleep' or 'setitimer' instead. [usleepCalled]\n", errout_str());
     }
 
     void prohibitedFunctions_index() {
         check("namespace n1 {\n"
-              "    int index(){};\n"
+              "    int index(){ return 1; };\n"
               "}\n"
               "int main()\n"
               "{\n"
               "    n1::index();\n"
+              "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("std::size_t f()\n"
               "{\n"
@@ -154,19 +192,19 @@ class TestFunctions : public TestFixture {
               "    index++;\n"
               "    return index;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f()\n"
               "{\n"
               "    return this->index();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
               "    int index( 0 );\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("const char f()\n"
               "{\n"
@@ -174,15 +212,18 @@ class TestFunctions : public TestFixture {
               "    const char i = index(var, 0);\n"
               "    return i;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Obsolescent function 'index' called. It is recommended to use 'strchr' instead.\n",
-                      errout.str());
+        ASSERT_EQUALS("[test.cpp:4:20]: (style) Obsolescent function 'index' called. It is recommended to use 'strchr' instead. [indexCalled]\n",
+                      errout_str());
     }
 
     void prohibitedFunctions_qt_index() {
         check("void TDataModel::forceRowRefresh(int row) {\n"
               "    emit dataChanged(index(row, 0), index(row, columnCount() - 1));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Obsolescent function 'index' called. It is recommended to use 'strchr' instead.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:22]: (style) Obsolescent function 'index' called. It is recommended to use 'strchr' instead. [indexCalled]\n"
+            "[test.cpp:2:37]: (style) Obsolescent function 'index' called. It is recommended to use 'strchr' instead. [indexCalled]\n",   // duplicate
+            errout_str());
     }
 
     void prohibitedFunctions_rindex() {
@@ -190,14 +231,14 @@ class TestFunctions : public TestFixture {
               "{\n"
               "    int rindex( 0 );\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
               "    const char var[7] = \"rindex\";\n"
               "    print(rindex(var, 0));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Obsolescent function 'rindex' called. It is recommended to use 'strrchr' instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Obsolescent function 'rindex' called. It is recommended to use 'strrchr' instead. [rindexCalled]\n", errout_str());
     }
 
 
@@ -207,7 +248,7 @@ class TestFunctions : public TestFixture {
               "    Fred() : index(0) { }\n"
               "    int index;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void prohibitedFunctions_gets() {
@@ -215,49 +256,46 @@ class TestFunctions : public TestFixture {
               "{\n"
               "    char *x = gets(a);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Obsolete function 'gets' called. It is recommended to use 'fgets' or 'gets_s' instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:15]: (warning) Obsolete function 'gets' called. It is recommended to use 'fgets' or 'gets_s' instead. [getsCalled]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "    foo(x, gets(a));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Obsolete function 'gets' called. It is recommended to use 'fgets' or 'gets_s' instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (warning) Obsolete function 'gets' called. It is recommended to use 'fgets' or 'gets_s' instead. [getsCalled]\n", errout_str());
     }
 
     void prohibitedFunctions_alloca() {
         check("void f()\n"
               "{\n"
               "    char *x = alloca(10);\n"
-              "}", "test.cpp");  // #4382 - there are no VLAs in C++
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Obsolete function 'alloca' called.\n", errout.str());
+              "}");  // #4382 - there are no VLAs in C++
+        ASSERT_EQUALS("[test.cpp:3:15]: (warning) Obsolete function 'alloca' called. [allocaCalled]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "    char *x = alloca(10);\n"
-              "}", "test.c");
-        ASSERT_EQUALS("[test.c:3]: (warning) Obsolete function 'alloca' called. In C99 and later it is recommended to use a variable length array instead.\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:3:15]: (warning) Obsolete function 'alloca' called. In C99 and later it is recommended to use a variable length array instead. [allocaCalled]\n", errout_str());
 
-        settings.standards.c = Standards::C89;
-        settings.standards.cpp = Standards::CPP03;
+        const Settings s = settingsBuilder(settings).c(Standards::C89).cpp(Standards::CPP03).build();
         check("void f()\n"
               "{\n"
               "    char *x = alloca(10);\n"
-              "}", "test.cpp");  // #4382 - there are no VLAs in C++
-        ASSERT_EQUALS("", errout.str());
+              "}", s);  // #4382 - there are no VLAs in C++
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
               "    char *x = alloca(10);\n"
-              "}", "test.c"); // #7558 - no alternative to alloca in C89
-        ASSERT_EQUALS("", errout.str());
+              "}", s, false); // #7558 - no alternative to alloca in C89
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
               "    char *x = alloca(10);\n"
-              "}", "test.c");
-        ASSERT_EQUALS("", errout.str());
-        settings.standards.c = Standards::C11;
-        settings.standards.cpp = Standards::CPP11;
+              "}", s, false);
+        ASSERT_EQUALS("", errout_str());
     }
 
     // ticket #3121
@@ -271,7 +309,7 @@ class TestFunctions : public TestFixture {
               "    int b ; b = ftime ( 1 ) ;\n"
               "    return 0 ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // test std::gets
@@ -281,8 +319,8 @@ class TestFunctions : public TestFixture {
               "    char *x = std::gets(str);\n"
               "    char *y = gets(str);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Obsolete function 'gets' called. It is recommended to use 'fgets' or 'gets_s' instead.\n"
-                      "[test.cpp:4]: (warning) Obsolete function 'gets' called. It is recommended to use 'fgets' or 'gets_s' instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:20]: (warning) Obsolete function 'gets' called. It is recommended to use 'fgets' or 'gets_s' instead. [getsCalled]\n"
+                      "[test.cpp:4:15]: (warning) Obsolete function 'gets' called. It is recommended to use 'fgets' or 'gets_s' instead. [getsCalled]\n", errout_str());
     }
 
     // multiple use
@@ -292,8 +330,8 @@ class TestFunctions : public TestFixture {
               "    char *x = std::gets(str);\n"
               "    usleep( 1000 );\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Obsolete function 'gets' called. It is recommended to use 'fgets' or 'gets_s' instead.\n"
-                      "[test.cpp:4]: (style) Obsolescent function 'usleep' called. It is recommended to use 'nanosleep' or 'setitimer' instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:20]: (warning) Obsolete function 'gets' called. It is recommended to use 'fgets' or 'gets_s' instead. [getsCalled]\n"
+                      "[test.cpp:4:5]: (style) Obsolescent function 'usleep' called. It is recommended to use 'nanosleep' or 'setitimer' instead. [usleepCalled]\n", errout_str());
     }
 
     void prohibitedFunctions_c_declaration() {
@@ -302,15 +340,16 @@ class TestFunctions : public TestFixture {
               "{\n"
               "    char s [ 10 ] ;\n"
               "    gets ( s ) ;\n"
+              "    return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Obsolete function 'gets' called. It is recommended to use 'fgets' or 'gets_s' instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) Obsolete function 'gets' called. It is recommended to use 'fgets' or 'gets_s' instead. [getsCalled]\n", errout_str());
 
         check("int getcontext(ucontext_t *ucp);\n"
-              "int f (ucontext_t *ucp)\n"
+              "void f (ucontext_t *ucp)\n"
               "{\n"
               "    getcontext ( ucp ) ;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (portability) Obsolescent function 'getcontext' called. Applications are recommended to be rewritten to use POSIX threads.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (portability) Obsolescent function 'getcontext' called. Applications are recommended to be rewritten to use POSIX threads. [getcontextCalled]\n", errout_str());
     }
 
     void prohibitedFunctions_functionWithBody() {
@@ -319,8 +358,9 @@ class TestFunctions : public TestFixture {
               "{\n"
               "    char s [ 10 ] ;\n"
               "    gets ( s ) ;\n"
+              "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void prohibitedFunctions_crypt() {
@@ -329,8 +369,8 @@ class TestFunctions : public TestFixture {
               "    char *cpwd;"
               "    crypt(pwd, cpwd);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Return value of function crypt() is not used.\n"
-                      "[test.cpp:3]: (portability) Non reentrant function 'crypt' called. For threadsafe applications it is recommended to use the reentrant replacement function 'crypt_r'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:20]: (warning) Return value of function crypt() is not used. [ignoredReturnValue]\n"
+                      "[test.cpp:3:20]: (portability) Non reentrant function 'crypt' called. For threadsafe applications it is recommended to use the reentrant replacement function 'crypt_r'. [cryptCalled]\n", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -338,122 +378,167 @@ class TestFunctions : public TestFixture {
               "    char *cpwd;"
               "    crypt(pwd, cpwd);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Return value of function crypt() is not used.\n"
-                      "[test.cpp:3]: (portability) Non reentrant function 'crypt' called. For threadsafe applications it is recommended to use the reentrant replacement function 'crypt_r'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:57]: (warning) Return value of function crypt() is not used. [ignoredReturnValue]\n"
+                      "[test.cpp:3:57]: (portability) Non reentrant function 'crypt' called. For threadsafe applications it is recommended to use the reentrant replacement function 'crypt_r'. [cryptCalled]\n", errout_str());
 
         check("int f()\n"
               "{\n"
               "    int crypt = 0;"
               "    return crypt;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void prohibitedFunctions_namespaceHandling() {
-        check("int f()\n"
+        check("void f()\n"
               "{\n"
               "    time_t t = 0;"
-              "    std::localtime(&t);\n"
+              "    auto lt = std::localtime(&t);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (portability) Non reentrant function 'localtime' called. For threadsafe applications it is recommended to use the reentrant replacement function 'localtime_r'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:37]: (portability) Non reentrant function 'localtime' called. For threadsafe applications it is recommended to use the reentrant replacement function 'localtime_r'. [localtimeCalled]\n", errout_str());
 
         // Passed as function argument
-        check("int f()\n"
+        check("void f()\n"
               "{\n"
               "    printf(\"Magic guess: %d\", getpwent());\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (portability) Non reentrant function 'getpwent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getpwent_r'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:31]: (portability) Non reentrant function 'getpwent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getpwent_r'. [getpwentCalled]\n", errout_str());
 
         // Pass return value
-        check("int f()\n"
+        check("void f()\n"
               "{\n"
               "    time_t t = 0;"
               "    struct tm *foo = localtime(&t);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (portability) Non reentrant function 'localtime' called. For threadsafe applications it is recommended to use the reentrant replacement function 'localtime_r'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:39]: (portability) Non reentrant function 'localtime' called. For threadsafe applications it is recommended to use the reentrant replacement function 'localtime_r'. [localtimeCalled]\n", errout_str());
 
         // Access via global namespace
-        check("int f()\n"
+        check("void f()\n"
               "{\n"
               "    ::getpwent();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Return value of function getpwent() is not used.\n"
-                      "[test.cpp:3]: (portability) Non reentrant function 'getpwent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getpwent_r'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:7]: (warning) Return value of function ::getpwent() is not used. [ignoredReturnValue]\n"
+                      "[test.cpp:3:7]: (portability) Non reentrant function 'getpwent' called. For threadsafe applications it is recommended to use the reentrant replacement function 'getpwent_r'. [getpwentCalled]\n", errout_str());
 
         // Be quiet on function definitions
         check("int getpwent()\n"
               "{\n"
               "    return 123;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Be quiet on other namespaces
-        check("int f()\n"
+        check("void f()\n"
               "{\n"
               "    foobar::getpwent();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Be quiet on class member functions
-        check("int f()\n"
+        check("void f()\n"
               "{\n"
               "    foobar.getpwent();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void invalidFunctionUsage1() {
-        check("int f() { memset(a,b,sizeof(a)!=12); }");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Invalid memset() argument nr 3. A non-boolean value is required.\n", errout.str());
+        check("void f() { memset(a,b,sizeof(a)!=12); }");
+        ASSERT_EQUALS("[test.cpp:1:32]: (error) Invalid memset() argument nr 3. A non-boolean value is required. [invalidFunctionArgBool]\n", errout_str());
 
-        check("int f() { memset(a,b,sizeof(a)!=0); }");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Invalid memset() argument nr 3. A non-boolean value is required.\n", errout.str());
+        check("void f() { memset(a,b,sizeof(a)!=0); }");
+        ASSERT_EQUALS("[test.cpp:1:32]: (error) Invalid memset() argument nr 3. A non-boolean value is required. [invalidFunctionArgBool]\n", errout_str());
 
-        check("int f() { memset(a,b,!c); }");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Invalid memset() argument nr 3. A non-boolean value is required.\n", errout.str());
+        check("void f() { memset(a,b,!c); }");
+        ASSERT_EQUALS("[test.cpp:1:23]: (error) Invalid memset() argument nr 3. A non-boolean value is required. [invalidFunctionArgBool]\n", errout_str());
 
         // Ticket #6990
-        check("int f(bool c) { memset(a,b,c); }");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Invalid memset() argument nr 3. A non-boolean value is required.\n", errout.str());
-        check("int f() { memset(a,b,true); }");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Invalid memset() argument nr 3. A non-boolean value is required.\n", errout.str());
+        check("void f(bool c) { memset(a,b,c); }");
+        ASSERT_EQUALS("[test.cpp:1:29]: (error) Invalid memset() argument nr 3. A non-boolean value is required. [invalidFunctionArgBool]\n", errout_str());
+        check("void f() { memset(a,b,true); }");
+        ASSERT_EQUALS("[test.cpp:1:23]: (error) Invalid memset() argument nr 3. A non-boolean value is required. [invalidFunctionArgBool]\n", errout_str());
 
         // Ticket #6588 (c mode)
         check("void record(char* buf, int n) {\n"
               "  memset(buf, 0, n < 255);\n"           /* KO */
               "  memset(buf, 0, n < 255 ? n : 255);\n" /* OK */
-              "}", "test.c");
-        ASSERT_EQUALS("[test.c:2]: (error) Invalid memset() argument nr 3. A non-boolean value is required.\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:2:20]: (error) Invalid memset() argument nr 3. A non-boolean value is required. [invalidFunctionArgBool]\n", errout_str());
 
         // Ticket #6588 (c++ mode)
         check("void record(char* buf, int n) {\n"
               "  memset(buf, 0, n < 255);\n"           /* KO */
               "  memset(buf, 0, n < 255 ? n : 255);\n" /* OK */
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Invalid memset() argument nr 3. A non-boolean value is required.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:20]: (error) Invalid memset() argument nr 3. A non-boolean value is required. [invalidFunctionArgBool]\n", errout_str());
+
+        check("int boolArgZeroIsInvalidButOneIsValid(int a, int param) {\n"
+              "  return div(a, param > 0);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:23]: (error) Invalid div() argument nr 2. The value is 0 or 1 (boolean) but the valid values are ':-1,1:'. [invalidFunctionArg]\n", errout_str());
+
+        check("void boolArgZeroIsValidButOneIsInvalid(int param) {\n"
+              "  strtol(a, b, param > 0);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:22]: (error) Invalid strtol() argument nr 3. The value is 0 or 1 (boolean) but the valid values are '0,2:36'. [invalidFunctionArg]\n", errout_str());
 
-        check("int f() { strtol(a,b,sizeof(a)!=12); }");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Invalid strtol() argument nr 3. The value is 0 or 1 (boolean) but the valid values are '0,2:36'.\n", errout.str());
+        check("void f() { strtol(a,b,1); }");
+        ASSERT_EQUALS("[test.cpp:1:23]: (error) Invalid strtol() argument nr 3. The value is 1 but the valid values are '0,2:36'. [invalidFunctionArg]\n", errout_str());
 
-        check("int f() { strtol(a,b,1); }");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Invalid strtol() argument nr 3. The value is 1 but the valid values are '0,2:36'.\n", errout.str());
+        check("void f() { strtol(a,b,10); }");
+        ASSERT_EQUALS("", errout_str());
 
-        check("int f() { strtol(a,b,10); }");
-        ASSERT_EQUALS("", errout.str());
+        check("void f(std::vector<int>& v) {\n" //  #10754
+              "    int N = -1;\n"
+              "    for (long i = 0; i < g(); i++)\n"
+              "        N = h(N);\n"
+              "    v.resize(N);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:14]: (warning) Invalid v.resize() argument nr 1. The value is -1 but the valid values are '0:'. [invalidFunctionArg]\n", errout_str());
+
+        check("void f(std::vector<int>& v, int N) {\n"
+              "    if (N < -1)\n"
+              "        return;\n"
+              "    v.resize(N);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:4:14]: (warning) Either the condition 'N<-1' is redundant or v.resize() argument nr 1 can have invalid value. The value is -1 but the valid values are '0:'. [invalidFunctionArg]\n",
+                      errout_str());
+
+        check("void f(std::vector<int>& v, int N) {\n"
+              "    if (N == -1) {}\n"
+              "    v.resize(N);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:14]: (warning) Either the condition 'N==-1' is redundant or v.resize() argument nr 1 can have invalid value. The value is -1 but the valid values are '0:'. [invalidFunctionArg]\n",
+                      errout_str());
+
+        check("void f(std::vector<int>& v, int N, bool b) {\n"
+              "    if (b)\n"
+              "        N = -1;\n"
+              "    v.resize(N);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:14]: (warning) Invalid v.resize() argument nr 1. The value is -1 but the valid values are '0:'. [invalidFunctionArg]\n",
+                      errout_str());
+
+        check("void f(std::vector<int>& v) {\n"
+              "    int N = -1;\n"
+              "    v.resize(N);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:14]: (error) Invalid v.resize() argument nr 1. The value is -1 but the valid values are '0:'. [invalidFunctionArg]\n",
+                      errout_str());
     }
 
     void invalidFunctionUsageStrings() {
         check("size_t f() { char x = 'x'; return strlen(&x); }");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:42]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
         check("size_t f() { return strlen(&x); }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("size_t f(char x) { return strlen(&x); }");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:34]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
         check("size_t f() { char x = '\\0'; return strlen(&x); }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("size_t f() {\n"
               "  char x;\n"
@@ -463,41 +548,41 @@ class TestFunctions : public TestFixture {
               "    x = 'a';\n"
               "  return strlen(&x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:17]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
         check("int f() { char x = '\\0'; return strcmp(\"Hello world\", &x); }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f() { char x = 'x'; return strcmp(\"Hello world\", &x); }");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Invalid strcmp() argument nr 2. A nul-terminated string is required.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:54]: (error) Invalid strcmp() argument nr 2. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
-        check("size_t f(char x) { char * y = &x; return strlen(y) }");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required.\n", errout.str());
+        check("size_t f(char x) { char * y = &x; return strlen(y); }");
+        TODO_ASSERT_EQUALS("[test.cpp:1:42]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", "", errout_str());
 
-        check("size_t f(char x) { char * y = &x; char *z = y; return strlen(z) }");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required.\n", errout.str());
+        check("size_t f(char x) { char * y = &x; char *z = y; return strlen(z); }");
+        TODO_ASSERT_EQUALS("[test.cpp:1:42]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", "", errout_str());
 
-        check("size_t f() { char x = 'x'; char * y = &x; char *z = y; return strlen(z) }");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required.\n", errout.str());
+        check("size_t f() { char x = 'x'; char * y = &x; char *z = y; return strlen(z); }");
+        TODO_ASSERT_EQUALS("[test.cpp:1:42]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", "", errout_str());
 
-        check("size_t f() { char x = '\\0'; char * y = &x; char *z = y; return strlen(z) }");
-        ASSERT_EQUALS("", errout.str());
+        check("size_t f() { char x = '\\0'; char * y = &x; char *z = y; return strlen(z); }");
+        ASSERT_EQUALS("", errout_str());
 
-        check("size_t f() { char x[] = \"Hello world\"; return strlen(x) }");
-        ASSERT_EQUALS("", errout.str());
+        check("size_t f() { char x[] = \"Hello world\"; return strlen(x); }");
+        ASSERT_EQUALS("", errout_str());
 
-        check("size_t f(char x[]) { return strlen(x) }");
-        ASSERT_EQUALS("", errout.str());
+        check("size_t f(char x[]) { return strlen(x); }");
+        ASSERT_EQUALS("", errout_str());
 
         check("int f(char x, char y) { return strcmp(&x, &y); }");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Invalid strcmp() argument nr 1. A nul-terminated string is required.\n"
-                      "[test.cpp:1]: (error) Invalid strcmp() argument nr 2. A nul-terminated string is required.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:39]: (error) Invalid strcmp() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n"
+                      "[test.cpp:1:43]: (error) Invalid strcmp() argument nr 2. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
-        check("size_t f() { char x[] = \"Hello world\"; return strlen(&x[0]) }");
-        ASSERT_EQUALS("", errout.str());
+        check("size_t f() { char x[] = \"Hello world\"; return strlen(&x[0]); }");
+        ASSERT_EQUALS("", errout_str());
 
-        check("size_t f() { char* x = \"Hello world\"; return strlen(&x[0]) }");
-        ASSERT_EQUALS("", errout.str());
+        check("size_t f() { char* x = \"Hello world\"; return strlen(&x[0]); }");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n"
               "  char x;\n"
@@ -509,33 +594,58 @@ class TestFunctions : public TestFixture {
               "  size_t l1 = strlen(&s1.x);\n"
               "  size_t l2 = strlen(&s2.x);\n"
               "  return l1 + l2;\n"
-              "}\n");
-        TODO_ASSERT_EQUALS("[test.cpp:9]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required.\n", "", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:8:22]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n"
+                      "[test.cpp:9:22]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
         check("const char x = 'x'; size_t f() { return strlen(&x); }");
-        TODO_ASSERT_EQUALS("[test.cpp:1]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required.\n", "", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:48]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
+
+        check("struct someStruct {\n"
+              "    union {\n"
+              "        struct {\n"
+              "            uint16_t nr;\n"
+              "            uint8_t d[40];\n"
+              "        } data;\n"
+              "        char buf[42];\n"
+              "    } x;\n"
+              "};\n"
+              "int f(struct someStruct * const tp, const int k)\n"
+              "{\n"
+              "    return strcmp(&tp->x.buf[k], \"needle\");\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct someStruct {\n"
+              "    char buf[42];\n"
+              "};\n"
+              "int f(struct someStruct * const tp, const int k)\n"
+              "{\n"
+              "    return strcmp(&tp->buf[k], \"needle\");\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("const char x = 'x'; size_t f() { char y = x; return strlen(&y); }");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:60]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
 
         check("const char x = '\\0'; size_t f() { return strlen(&x); }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("const char x = '\\0'; size_t f() { char y = x; return strlen(&y); }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("size_t f() {\n"
               "  char * a = \"Hello world\";\n"
               "  char ** b = &a;\n"
               "  return strlen(&b[0][0]);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("size_t f() {\n"
               "  char ca[] = \"asdf\";\n"
               "  return strlen((char*) &ca);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // #5225
         check("int main(void)\n"
@@ -545,8 +655,132 @@ class TestFunctions : public TestFixture {
               "  strcat(str, &d);\n"
               "  puts(str);\n"
               "  return 0;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:15]: (error) Invalid strcat() argument nr 2. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
+
+        check("FILE* f(void) {\n"
+              "  const char fileName[1] = { \'x\' };\n"
+              "  return fopen(fileName, \"r\"); \n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:16]: (error) Invalid fopen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
+
+        check("FILE* f(void) {\n"
+              "  const char fileName[2] = { \'x\', \'y\' };\n"
+              "  return fopen(fileName, \"r\"); \n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:16]: (error) Invalid fopen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
+
+        check("FILE* f(void) {\n"
+              "  const char fileName[3] = { \'x\', \'y\' ,\'\\0\' };\n"
+              "  return fopen(fileName, \"r\"); \n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("FILE* f(void) {\n"
+              "  const char fileName[3] = { \'x\', \'\\0\' ,\'y\' };\n"
+              "  return fopen(fileName, \"r\"); \n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("FILE* f(void) {\n"
+              "  const char fileName[3] = { \'x\', \'y\' };\n" // implicit '\0' added at the end
+              "  return fopen(fileName, \"r\"); \n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("FILE* f(void) {\n"
+              "  const char fileName[] = { \'\\0\' };\n"
+              "  return fopen(fileName, \"r\"); \n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("FILE* f(void) {\n"
+              "  const char fileName[] = { \'0\' + 42 };\n" // no size is explicitly defined, no implicit '\0' is added
+              "  return fopen(fileName, \"r\"); \n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:16]: (error) Invalid fopen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
+
+        check("FILE* f(void) {\n"
+              "  const char fileName[] = { \'0\' + 42, \'x\' };\n" // no size is explicitly defined, no implicit '\0' is added
+              "  return fopen(fileName, \"r\"); \n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:16]: (error) Invalid fopen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
+
+        check("FILE* f(void) {\n"
+              "  const char fileName[2] = { \'0\' + 42 };\n" // implicitly '\0' added at the end because size is set to 2
+              "  return fopen(fileName, \"r\"); \n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("FILE* f(void) {\n"
+              "  const char fileName[] = { };\n"
+              "  return fopen(fileName, \"r\"); \n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void scanMetaTypes()\n" // don't crash
+              "{\n"
+              "    QVector<int> metaTypes;\n"
+              "    for (int mtId = 0; mtId <= QMetaType::User; ++mtId) {\n"
+              "        const auto name = QMetaType::typeName(mtId);\n"
+              "        if (strstr(name, \"GammaRay::\") != name)\n"
+              "            metaTypes.push_back(mtId);\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f() {\n"
+              "    const char c[3] = \"abc\";\n"
+              "    return strlen(c);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:19]: (error) Invalid strlen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
+
+        check("int f() {\n"
+              "    const wchar_t c[3] = L\"abc\";\n"
+              "    return wcslen(c);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:19]: (error) Invalid wcslen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
+
+        check("void f(char* dest) {\n"
+              "    char if_name[(IF_NAMESIZE > 21 ? IF_NAMESIZE : 21) + 1] = \"%\";\n"
+              "    strcat(dest, if_name);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f() {\n"
+              "    const char c[3] = \"ab\\0\";\n"
+              "    return strlen(c);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int n) {\n" // #11179
+              "    char s[8] = \"        \";\n"
+              "    n = (n + 1) % 100;\n"
+              "    sprintf(s, \"lwip%02d\", n);\n"
+              "    s[strlen(s)] = ' ';\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Invalid strcat() argument nr 2. A nul-terminated string is required.\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("size_t f() { wchar_t x = L'x'; return wcslen(&x); }");
+        ASSERT_EQUALS("[test.cpp:1:46]: (error) Invalid wcslen() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
+
+        check("void f() { char a[10] = \"1234567890\"; puts(a); }", dinit(CheckOptions, $.cpp = false)); // #1770
+        ASSERT_EQUALS("[test.c:1:44]: (error) Invalid puts() argument nr 1. A nul-terminated string is required. [invalidFunctionArgStr]\n", errout_str());
+    }
+
+    void invalidFunctionArg1() {
+        const Settings settingsUnix32 = settingsBuilder(settings).platform(Platform::Unix32).build();
+        check("int main() {\n"
+              "    char tgt[7];\n"
+              "    char src[7+1] = \"7777777\";\n"
+              "    if (sizeof tgt <= sizeof src) {\n"
+              "        memmove(&tgt, &src, sizeof tgt);\n"
+              "    } else {\n"
+              "        memmove(&tgt, &src, sizeof src);\n"
+              "        memset(&tgt + sizeof src, ' ', sizeof tgt - sizeof src);\n"
+              "    }\n"
+              "}\n", settingsUnix32, false);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void mathfunctionCall_sqrt() {
@@ -557,9 +791,9 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  sqrtf(-1) << std::endl;\n"
               "    std::cout <<  sqrtl(-1) << std::endl;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Invalid sqrt() argument nr 1. The value is -1 but the valid values are '0.0:'.\n"
-                      "[test.cpp:4]: (error) Invalid sqrtf() argument nr 1. The value is -1 but the valid values are '0.0:'.\n"
-                      "[test.cpp:5]: (error) Invalid sqrtl() argument nr 1. The value is -1 but the valid values are '0.0:'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:25]: (error) Invalid sqrt() argument nr 1. The value is -1 but the valid values are '0.0:'. [invalidFunctionArg]\n"
+                      "[test.cpp:4:26]: (error) Invalid sqrtf() argument nr 1. The value is -1 but the valid values are '0.0:'. [invalidFunctionArg]\n"
+                      "[test.cpp:5:26]: (error) Invalid sqrtl() argument nr 1. The value is -1 but the valid values are '0.0:'. [invalidFunctionArg]\n", errout_str());
 
         // implementation-defined behaviour for "finite values of x<0" only:
         check("void foo()\n"
@@ -568,7 +802,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  sqrtf(-0.) << std::endl;\n"
               "    std::cout <<  sqrtl(-0.) << std::endl;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -576,7 +810,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  sqrtf(1) << std::endl;\n"
               "    std::cout <<  sqrtl(1) << std::endl;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void mathfunctionCall_log() {
@@ -596,18 +830,27 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  log1pf(-3) << std::endl;\n"
               "    std::cout <<  log1pl(-3) << std::endl;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Passing value -2 to log() leads to implementation-defined result.\n"
-                      "[test.cpp:4]: (warning) Passing value -2 to logf() leads to implementation-defined result.\n"
-                      "[test.cpp:5]: (warning) Passing value -2 to logl() leads to implementation-defined result.\n"
-                      "[test.cpp:6]: (warning) Passing value -2 to log10() leads to implementation-defined result.\n"
-                      "[test.cpp:7]: (warning) Passing value -2 to log10f() leads to implementation-defined result.\n"
-                      "[test.cpp:8]: (warning) Passing value -2 to log10l() leads to implementation-defined result.\n"
-                      "[test.cpp:9]: (warning) Passing value -2 to log2() leads to implementation-defined result.\n"
-                      "[test.cpp:10]: (warning) Passing value -2 to log2f() leads to implementation-defined result.\n"
-                      "[test.cpp:11]: (warning) Passing value -2 to log2l() leads to implementation-defined result.\n"
-                      "[test.cpp:12]: (warning) Passing value -3 to log1p() leads to implementation-defined result.\n"
-                      "[test.cpp:13]: (warning) Passing value -3 to log1pf() leads to implementation-defined result.\n"
-                      "[test.cpp:14]: (warning) Passing value -3 to log1pl() leads to implementation-defined result.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:24]: (error) Invalid log() argument nr 1. The value is -2 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:4:25]: (error) Invalid logf() argument nr 1. The value is -2 but the valid values are '1.4013e-45:'. [invalidFunctionArg]\n"
+                      "[test.cpp:5:25]: (error) Invalid logl() argument nr 1. The value is -2 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:6:26]: (error) Invalid log10() argument nr 1. The value is -2 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:7:27]: (error) Invalid log10f() argument nr 1. The value is -2 but the valid values are '1.4013e-45:'. [invalidFunctionArg]\n"
+                      "[test.cpp:8:27]: (error) Invalid log10l() argument nr 1. The value is -2 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:9:25]: (error) Invalid log2() argument nr 1. The value is -2 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:10:26]: (error) Invalid log2f() argument nr 1. The value is -2 but the valid values are '1.4013e-45:'. [invalidFunctionArg]\n"
+                      "[test.cpp:11:26]: (error) Invalid log2l() argument nr 1. The value is -2 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:3:19]: (warning) Passing value -2 to log() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:4:19]: (warning) Passing value -2 to logf() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:5:19]: (warning) Passing value -2 to logl() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:6:19]: (warning) Passing value -2 to log10() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:7:19]: (warning) Passing value -2 to log10f() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:8:19]: (warning) Passing value -2 to log10l() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:9:19]: (warning) Passing value -2 to log2() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:10:19]: (warning) Passing value -2 to log2f() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:11:19]: (warning) Passing value -2 to log2l() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:12:19]: (warning) Passing value -3 to log1p() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:13:19]: (warning) Passing value -3 to log1pf() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:14:19]: (warning) Passing value -3 to log1pl() leads to implementation-defined result. [wrongmathcall]\n", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -624,18 +867,27 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  log1pf(-2) << std::endl;\n"
               "    std::cout <<  log1pl(-2) << std::endl;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Passing value -1 to log() leads to implementation-defined result.\n"
-                      "[test.cpp:4]: (warning) Passing value -1 to logf() leads to implementation-defined result.\n"
-                      "[test.cpp:5]: (warning) Passing value -1 to logl() leads to implementation-defined result.\n"
-                      "[test.cpp:6]: (warning) Passing value -1 to log10() leads to implementation-defined result.\n"
-                      "[test.cpp:7]: (warning) Passing value -1 to log10f() leads to implementation-defined result.\n"
-                      "[test.cpp:8]: (warning) Passing value -1 to log10l() leads to implementation-defined result.\n"
-                      "[test.cpp:9]: (warning) Passing value -1 to log2() leads to implementation-defined result.\n"
-                      "[test.cpp:10]: (warning) Passing value -1 to log2f() leads to implementation-defined result.\n"
-                      "[test.cpp:11]: (warning) Passing value -1 to log2l() leads to implementation-defined result.\n"
-                      "[test.cpp:12]: (warning) Passing value -2 to log1p() leads to implementation-defined result.\n"
-                      "[test.cpp:13]: (warning) Passing value -2 to log1pf() leads to implementation-defined result.\n"
-                      "[test.cpp:14]: (warning) Passing value -2 to log1pl() leads to implementation-defined result.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:24]: (error) Invalid log() argument nr 1. The value is -1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:4:25]: (error) Invalid logf() argument nr 1. The value is -1 but the valid values are '1.4013e-45:'. [invalidFunctionArg]\n"
+                      "[test.cpp:5:25]: (error) Invalid logl() argument nr 1. The value is -1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:6:26]: (error) Invalid log10() argument nr 1. The value is -1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:7:27]: (error) Invalid log10f() argument nr 1. The value is -1 but the valid values are '1.4013e-45:'. [invalidFunctionArg]\n"
+                      "[test.cpp:8:27]: (error) Invalid log10l() argument nr 1. The value is -1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:9:25]: (error) Invalid log2() argument nr 1. The value is -1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:10:26]: (error) Invalid log2f() argument nr 1. The value is -1 but the valid values are '1.4013e-45:'. [invalidFunctionArg]\n"
+                      "[test.cpp:11:26]: (error) Invalid log2l() argument nr 1. The value is -1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:3:19]: (warning) Passing value -1 to log() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:4:19]: (warning) Passing value -1 to logf() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:5:19]: (warning) Passing value -1 to logl() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:6:19]: (warning) Passing value -1 to log10() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:7:19]: (warning) Passing value -1 to log10f() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:8:19]: (warning) Passing value -1 to log10l() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:9:19]: (warning) Passing value -1 to log2() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:10:19]: (warning) Passing value -1 to log2f() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:11:19]: (warning) Passing value -1 to log2l() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:12:19]: (warning) Passing value -2 to log1p() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:13:19]: (warning) Passing value -2 to log1pf() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:14:19]: (warning) Passing value -2 to log1pl() leads to implementation-defined result. [wrongmathcall]\n", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -652,18 +904,27 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  log1pf(-2.0) << std::endl;\n"
               "    std::cout <<  log1pl(-2.0) << std::endl;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Passing value -1.0 to log() leads to implementation-defined result.\n"
-                      "[test.cpp:4]: (warning) Passing value -1.0 to logf() leads to implementation-defined result.\n"
-                      "[test.cpp:5]: (warning) Passing value -1.0 to logl() leads to implementation-defined result.\n"
-                      "[test.cpp:6]: (warning) Passing value -1.0 to log10() leads to implementation-defined result.\n"
-                      "[test.cpp:7]: (warning) Passing value -1.0 to log10f() leads to implementation-defined result.\n"
-                      "[test.cpp:8]: (warning) Passing value -1.0 to log10l() leads to implementation-defined result.\n"
-                      "[test.cpp:9]: (warning) Passing value -1.0 to log2() leads to implementation-defined result.\n"
-                      "[test.cpp:10]: (warning) Passing value -1.0 to log2f() leads to implementation-defined result.\n"
-                      "[test.cpp:11]: (warning) Passing value -1.0 to log2l() leads to implementation-defined result.\n"
-                      "[test.cpp:12]: (warning) Passing value -2.0 to log1p() leads to implementation-defined result.\n"
-                      "[test.cpp:13]: (warning) Passing value -2.0 to log1pf() leads to implementation-defined result.\n"
-                      "[test.cpp:14]: (warning) Passing value -2.0 to log1pl() leads to implementation-defined result.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:25]: (error) Invalid log() argument nr 1. The value is -1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:4:26]: (error) Invalid logf() argument nr 1. The value is -1 but the valid values are '1.4013e-45:'. [invalidFunctionArg]\n"
+                      "[test.cpp:5:26]: (error) Invalid logl() argument nr 1. The value is -1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:6:27]: (error) Invalid log10() argument nr 1. The value is -1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:7:28]: (error) Invalid log10f() argument nr 1. The value is -1 but the valid values are '1.4013e-45:'. [invalidFunctionArg]\n"
+                      "[test.cpp:8:28]: (error) Invalid log10l() argument nr 1. The value is -1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:9:26]: (error) Invalid log2() argument nr 1. The value is -1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:10:27]: (error) Invalid log2f() argument nr 1. The value is -1 but the valid values are '1.4013e-45:'. [invalidFunctionArg]\n"
+                      "[test.cpp:11:27]: (error) Invalid log2l() argument nr 1. The value is -1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:3:19]: (warning) Passing value -1.0 to log() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:4:19]: (warning) Passing value -1.0 to logf() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:5:19]: (warning) Passing value -1.0 to logl() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:6:19]: (warning) Passing value -1.0 to log10() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:7:19]: (warning) Passing value -1.0 to log10f() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:8:19]: (warning) Passing value -1.0 to log10l() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:9:19]: (warning) Passing value -1.0 to log2() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:10:19]: (warning) Passing value -1.0 to log2f() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:11:19]: (warning) Passing value -1.0 to log2l() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:12:19]: (warning) Passing value -2.0 to log1p() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:13:19]: (warning) Passing value -2.0 to log1pf() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:14:19]: (warning) Passing value -2.0 to log1pl() leads to implementation-defined result. [wrongmathcall]\n", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -680,18 +941,27 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  log1pf(-1.1) << std::endl;\n"
               "    std::cout <<  log1pl(-1.1) << std::endl;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Passing value -0.1 to log() leads to implementation-defined result.\n"
-                      "[test.cpp:4]: (warning) Passing value -0.1 to logf() leads to implementation-defined result.\n"
-                      "[test.cpp:5]: (warning) Passing value -0.1 to logl() leads to implementation-defined result.\n"
-                      "[test.cpp:6]: (warning) Passing value -0.1 to log10() leads to implementation-defined result.\n"
-                      "[test.cpp:7]: (warning) Passing value -0.1 to log10f() leads to implementation-defined result.\n"
-                      "[test.cpp:8]: (warning) Passing value -0.1 to log10l() leads to implementation-defined result.\n"
-                      "[test.cpp:9]: (warning) Passing value -0.1 to log2() leads to implementation-defined result.\n"
-                      "[test.cpp:10]: (warning) Passing value -0.1 to log2f() leads to implementation-defined result.\n"
-                      "[test.cpp:11]: (warning) Passing value -0.1 to log2l() leads to implementation-defined result.\n"
-                      "[test.cpp:12]: (warning) Passing value -1.1 to log1p() leads to implementation-defined result.\n"
-                      "[test.cpp:13]: (warning) Passing value -1.1 to log1pf() leads to implementation-defined result.\n"
-                      "[test.cpp:14]: (warning) Passing value -1.1 to log1pl() leads to implementation-defined result.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:25]: (error) Invalid log() argument nr 1. The value is -0.1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:4:26]: (error) Invalid logf() argument nr 1. The value is -0.1 but the valid values are '1.4013e-45:'. [invalidFunctionArg]\n"
+                      "[test.cpp:5:26]: (error) Invalid logl() argument nr 1. The value is -0.1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:6:27]: (error) Invalid log10() argument nr 1. The value is -0.1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:7:28]: (error) Invalid log10f() argument nr 1. The value is -0.1 but the valid values are '1.4013e-45:'. [invalidFunctionArg]\n"
+                      "[test.cpp:8:28]: (error) Invalid log10l() argument nr 1. The value is -0.1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:9:26]: (error) Invalid log2() argument nr 1. The value is -0.1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:10:27]: (error) Invalid log2f() argument nr 1. The value is -0.1 but the valid values are '1.4013e-45:'. [invalidFunctionArg]\n"
+                      "[test.cpp:11:27]: (error) Invalid log2l() argument nr 1. The value is -0.1 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:3:19]: (warning) Passing value -0.1 to log() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:4:19]: (warning) Passing value -0.1 to logf() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:5:19]: (warning) Passing value -0.1 to logl() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:6:19]: (warning) Passing value -0.1 to log10() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:7:19]: (warning) Passing value -0.1 to log10f() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:8:19]: (warning) Passing value -0.1 to log10l() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:9:19]: (warning) Passing value -0.1 to log2() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:10:19]: (warning) Passing value -0.1 to log2f() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:11:19]: (warning) Passing value -0.1 to log2l() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:12:19]: (warning) Passing value -1.1 to log1p() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:13:19]: (warning) Passing value -1.1 to log1pf() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:14:19]: (warning) Passing value -1.1 to log1pl() leads to implementation-defined result. [wrongmathcall]\n", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -708,18 +978,27 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  log1pf(-1.0) << std::endl;\n"
               "    std::cout <<  log1pl(-1) << std::endl;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Passing value 0 to log() leads to implementation-defined result.\n"
-                      "[test.cpp:4]: (warning) Passing value 0. to logf() leads to implementation-defined result.\n"
-                      "[test.cpp:5]: (warning) Passing value 0.0 to logl() leads to implementation-defined result.\n"
-                      "[test.cpp:6]: (warning) Passing value 0.0 to log10() leads to implementation-defined result.\n"
-                      "[test.cpp:7]: (warning) Passing value 0 to log10f() leads to implementation-defined result.\n"
-                      "[test.cpp:8]: (warning) Passing value 0. to log10l() leads to implementation-defined result.\n"
-                      "[test.cpp:9]: (warning) Passing value 0. to log2() leads to implementation-defined result.\n"
-                      "[test.cpp:10]: (warning) Passing value 0.0 to log2f() leads to implementation-defined result.\n"
-                      "[test.cpp:11]: (warning) Passing value 0 to log2l() leads to implementation-defined result.\n"
-                      "[test.cpp:12]: (warning) Passing value -1. to log1p() leads to implementation-defined result.\n"
-                      "[test.cpp:13]: (warning) Passing value -1.0 to log1pf() leads to implementation-defined result.\n"
-                      "[test.cpp:14]: (warning) Passing value -1 to log1pl() leads to implementation-defined result.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:23]: (error) Invalid log() argument nr 1. The value is 0 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:4:25]: (error) Invalid logf() argument nr 1. The value is 0 but the valid values are '1.4013e-45:'. [invalidFunctionArg]\n"
+                      "[test.cpp:5:25]: (error) Invalid logl() argument nr 1. The value is 0 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:6:26]: (error) Invalid log10() argument nr 1. The value is 0 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:7:26]: (error) Invalid log10f() argument nr 1. The value is 0 but the valid values are '1.4013e-45:'. [invalidFunctionArg]\n"
+                      "[test.cpp:8:27]: (error) Invalid log10l() argument nr 1. The value is 0 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:9:25]: (error) Invalid log2() argument nr 1. The value is 0 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:10:26]: (error) Invalid log2f() argument nr 1. The value is 0 but the valid values are '1.4013e-45:'. [invalidFunctionArg]\n"
+                      "[test.cpp:11:25]: (error) Invalid log2l() argument nr 1. The value is 0 but the valid values are '4.94066e-324:'. [invalidFunctionArg]\n"
+                      "[test.cpp:3:19]: (warning) Passing value 0 to log() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:4:19]: (warning) Passing value 0. to logf() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:5:19]: (warning) Passing value 0.0 to logl() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:6:19]: (warning) Passing value 0.0 to log10() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:7:19]: (warning) Passing value 0 to log10f() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:8:19]: (warning) Passing value 0. to log10l() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:9:19]: (warning) Passing value 0. to log2() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:10:19]: (warning) Passing value 0.0 to log2f() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:11:19]: (warning) Passing value 0 to log2l() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:12:19]: (warning) Passing value -1. to log1p() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:13:19]: (warning) Passing value -1.0 to log1pf() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:14:19]: (warning) Passing value -1 to log1pl() leads to implementation-defined result. [wrongmathcall]\n", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -772,59 +1051,59 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  log1pf(2.0)       << std::endl;\n"
               "    std::cout <<  log1pf(2.0f)      << std::endl;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
               "{\n"
               "    std::string *log(0);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #3473 - no warning if "log" is a variable
         check("Fred::Fred() : log(0) { }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #5748
         check("void f() { foo.log(0); }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void mathfunctionCall_acos() {
         // acos, acosf, acosl
         check("void foo()\n"
               "{\n"
-              " return acos(-1)      \n"
-              "    + acos(0.1)       \n"
-              "    + acos(0.0001)    \n"
-              "    + acos(0.01)      \n"
-              "    + acos(1.0E-1)    \n"
-              "    + acos(-1.0E-1)   \n"
-              "    + acos(+1.0E-1)   \n"
-              "    + acos(0.1E-1)    \n"
-              "    + acos(+0.1E-1)   \n"
-              "    + acos(-0.1E-1)   \n"
-              "    + acosf(-1)       \n"
-              "    + acosf(0.1)      \n"
-              "    + acosf(0.0001)   \n"
-              "    + acosf(0.01)     \n"
-              "    + acosf(1.0E-1)   \n"
-              "    + acosf(-1.0E-1)  \n"
-              "    + acosf(+1.0E-1)  \n"
-              "    + acosf(0.1E-1)   \n"
-              "    + acosf(+0.1E-1)  \n"
-              "    + acosf(-0.1E-1)  \n"
-              "    + acosl(-1)       \n"
-              "    + acosl(0.1)      \n"
-              "    + acosl(0.0001)   \n"
-              "    + acosl(0.01)     \n"
-              "    + acosl(1.0E-1)   \n"
-              "    + acosl(-1.0E-1)  \n"
-              "    + acosl(+1.0E-1)  \n"
-              "    + acosl(0.1E-1)   \n"
-              "    + acosl(+0.1E-1)  \n"
-              "    + acosl(-0.1E-1); \n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
+              " return acos(-1)     \n"
+              "    + acos(0.1)      \n"
+              "    + acos(0.0001)   \n"
+              "    + acos(0.01)     \n"
+              "    + acos(1.0E-1)   \n"
+              "    + acos(-1.0E-1)  \n"
+              "    + acos(+1.0E-1)  \n"
+              "    + acos(0.1E-1)   \n"
+              "    + acos(+0.1E-1)  \n"
+              "    + acos(-0.1E-1)  \n"
+              "    + acosf(-1)      \n"
+              "    + acosf(0.1)     \n"
+              "    + acosf(0.0001)  \n"
+              "    + acosf(0.01)    \n"
+              "    + acosf(1.0E-1)  \n"
+              "    + acosf(-1.0E-1) \n"
+              "    + acosf(+1.0E-1) \n"
+              "    + acosf(0.1E-1)  \n"
+              "    + acosf(+0.1E-1) \n"
+              "    + acosf(-0.1E-1) \n"
+              "    + acosl(-1)      \n"
+              "    + acosl(0.1)     \n"
+              "    + acosl(0.0001)  \n"
+              "    + acosl(0.01)    \n"
+              "    + acosl(1.0E-1)  \n"
+              "    + acosl(-1.0E-1) \n"
+              "    + acosl(+1.0E-1) \n"
+              "    + acosl(0.1E-1)  \n"
+              "    + acosl(+0.1E-1) \n"
+              "    + acosl(-0.1E-1);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -832,9 +1111,9 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  acosf(1.1) << std::endl;\n"
               "    std::cout <<  acosl(1.1) << std::endl;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Invalid acos() argument nr 1. The value is 1.1 but the valid values are '-1.0:1.0'.\n"
-                      "[test.cpp:4]: (error) Invalid acosf() argument nr 1. The value is 1.1 but the valid values are '-1.0:1.0'.\n"
-                      "[test.cpp:5]: (error) Invalid acosl() argument nr 1. The value is 1.1 but the valid values are '-1.0:1.0'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:25]: (error) Invalid acos() argument nr 1. The value is 1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n"
+                      "[test.cpp:4:26]: (error) Invalid acosf() argument nr 1. The value is 1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n"
+                      "[test.cpp:5:26]: (error) Invalid acosl() argument nr 1. The value is 1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -842,50 +1121,50 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  acosf(-1.1) << std::endl;\n"
               "    std::cout <<  acosl(-1.1) << std::endl;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Invalid acos() argument nr 1. The value is -1.1 but the valid values are '-1.0:1.0'.\n"
-                      "[test.cpp:4]: (error) Invalid acosf() argument nr 1. The value is -1.1 but the valid values are '-1.0:1.0'.\n"
-                      "[test.cpp:5]: (error) Invalid acosl() argument nr 1. The value is -1.1 but the valid values are '-1.0:1.0'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:26]: (error) Invalid acos() argument nr 1. The value is -1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n"
+                      "[test.cpp:4:27]: (error) Invalid acosf() argument nr 1. The value is -1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n"
+                      "[test.cpp:5:27]: (error) Invalid acosl() argument nr 1. The value is -1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n", errout_str());
     }
 
     void mathfunctionCall_asin() {
         // asin, asinf, asinl
         check("void foo()\n"
               "{\n"
-              " return asin(1)       \n"
-              "    + asin(-1)        \n"
-              "    + asin(0.1)       \n"
-              "    + asin(0.0001)    \n"
-              "    + asin(0.01)      \n"
-              "    + asin(1.0E-1)    \n"
-              "    + asin(-1.0E-1)   \n"
-              "    + asin(+1.0E-1)   \n"
-              "    + asin(0.1E-1)    \n"
-              "    + asin(+0.1E-1)   \n"
-              "    + asin(-0.1E-1)   \n"
-              "    + asinf(1)        \n"
-              "    + asinf(-1)       \n"
-              "    + asinf(0.1)      \n"
-              "    + asinf(0.0001)   \n"
-              "    + asinf(0.01)     \n"
-              "    + asinf(1.0E-1)   \n"
-              "    + asinf(-1.0E-1)  \n"
-              "    + asinf(+1.0E-1)  \n"
-              "    + asinf(0.1E-1)   \n"
-              "    + asinf(+0.1E-1)  \n"
-              "    + asinf(-0.1E-1)  \n"
-              "    + asinl(1)        \n"
-              "    + asinl(-1)       \n"
-              "    + asinl(0.1)      \n"
-              "    + asinl(0.0001)   \n"
-              "    + asinl(0.01)     \n"
-              "    + asinl(1.0E-1)   \n"
-              "    + asinl(-1.0E-1)  \n"
-              "    + asinl(+1.0E-1)  \n"
-              "    + asinl(0.1E-1)   \n"
-              "    + asinl(+0.1E-1)  \n"
-              "    + asinl(-0.1E-1); \n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
+              " return asin(1)      \n"
+              "    + asin(-1)       \n"
+              "    + asin(0.1)      \n"
+              "    + asin(0.0001)   \n"
+              "    + asin(0.01)     \n"
+              "    + asin(1.0E-1)   \n"
+              "    + asin(-1.0E-1)  \n"
+              "    + asin(+1.0E-1)  \n"
+              "    + asin(0.1E-1)   \n"
+              "    + asin(+0.1E-1)  \n"
+              "    + asin(-0.1E-1)  \n"
+              "    + asinf(1)       \n"
+              "    + asinf(-1)      \n"
+              "    + asinf(0.1)     \n"
+              "    + asinf(0.0001)  \n"
+              "    + asinf(0.01)    \n"
+              "    + asinf(1.0E-1)  \n"
+              "    + asinf(-1.0E-1) \n"
+              "    + asinf(+1.0E-1) \n"
+              "    + asinf(0.1E-1)  \n"
+              "    + asinf(+0.1E-1) \n"
+              "    + asinf(-0.1E-1) \n"
+              "    + asinl(1)       \n"
+              "    + asinl(-1)      \n"
+              "    + asinl(0.1)     \n"
+              "    + asinl(0.0001)  \n"
+              "    + asinl(0.01)    \n"
+              "    + asinl(1.0E-1)  \n"
+              "    + asinl(-1.0E-1) \n"
+              "    + asinl(+1.0E-1) \n"
+              "    + asinl(0.1E-1)  \n"
+              "    + asinl(+0.1E-1) \n"
+              "    + asinl(-0.1E-1);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -893,9 +1172,9 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  asinf(1.1) << std::endl;\n"
               "    std::cout <<  asinl(1.1) << std::endl;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Invalid asin() argument nr 1. The value is 1.1 but the valid values are '-1.0:1.0'.\n"
-                      "[test.cpp:4]: (error) Invalid asinf() argument nr 1. The value is 1.1 but the valid values are '-1.0:1.0'.\n"
-                      "[test.cpp:5]: (error) Invalid asinl() argument nr 1. The value is 1.1 but the valid values are '-1.0:1.0'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:25]: (error) Invalid asin() argument nr 1. The value is 1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n"
+                      "[test.cpp:4:26]: (error) Invalid asinf() argument nr 1. The value is 1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n"
+                      "[test.cpp:5:26]: (error) Invalid asinl() argument nr 1. The value is 1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -903,9 +1182,9 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  asinf(-1.1) << std::endl;\n"
               "    std::cout <<  asinl(-1.1) << std::endl;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Invalid asin() argument nr 1. The value is -1.1 but the valid values are '-1.0:1.0'.\n"
-                      "[test.cpp:4]: (error) Invalid asinf() argument nr 1. The value is -1.1 but the valid values are '-1.0:1.0'.\n"
-                      "[test.cpp:5]: (error) Invalid asinl() argument nr 1. The value is -1.1 but the valid values are '-1.0:1.0'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:26]: (error) Invalid asin() argument nr 1. The value is -1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n"
+                      "[test.cpp:4:27]: (error) Invalid asinf() argument nr 1. The value is -1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n"
+                      "[test.cpp:5:27]: (error) Invalid asinl() argument nr 1. The value is -1.1 but the valid values are '-1.0:1.0'. [invalidFunctionArg]\n", errout_str());
     }
 
     void mathfunctionCall_pow() {
@@ -916,9 +1195,9 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  powf(0,-10) << std::endl;\n"
               "    std::cout <<  powl(0,-10) << std::endl;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Passing values 0 and -10 to pow() leads to implementation-defined result.\n"
-                      "[test.cpp:4]: (warning) Passing values 0 and -10 to powf() leads to implementation-defined result.\n"
-                      "[test.cpp:5]: (warning) Passing values 0 and -10 to powl() leads to implementation-defined result.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:19]: (warning) Passing values 0 and -10 to pow() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:4:19]: (warning) Passing values 0 and -10 to powf() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:5:19]: (warning) Passing values 0 and -10 to powl() leads to implementation-defined result. [wrongmathcall]\n", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -926,7 +1205,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  powf(0,10) << std::endl;\n"
               "    std::cout <<  powl(0,10) << std::endl;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void mathfunctionCall_atan2() {
@@ -967,7 +1246,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  atan2l(+0.1E-1,1)  ;\n"
               "    std::cout <<  atan2l(-0.1E-1,8)  ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -975,9 +1254,9 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  atan2f(0,0) << std::endl;\n"
               "    std::cout <<  atan2l(0,0) << std::endl;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Passing values 0 and 0 to atan2() leads to implementation-defined result.\n"
-                      "[test.cpp:4]: (warning) Passing values 0 and 0 to atan2f() leads to implementation-defined result.\n"
-                      "[test.cpp:5]: (warning) Passing values 0 and 0 to atan2l() leads to implementation-defined result.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:19]: (warning) Passing values 0 and 0 to atan2() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:4:19]: (warning) Passing values 0 and 0 to atan2f() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:5:19]: (warning) Passing values 0 and 0 to atan2l() leads to implementation-defined result. [wrongmathcall]\n", errout_str());
     }
 
     void mathfunctionCall_fmod() {
@@ -988,9 +1267,12 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  fmodf(1.0,0) << std::endl;\n"
               "    std::cout <<  fmodl(1.0,0) << std::endl;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Passing values 1.0 and 0 to fmod() leads to implementation-defined result.\n"
-                      "[test.cpp:4]: (warning) Passing values 1.0 and 0 to fmodf() leads to implementation-defined result.\n"
-                      "[test.cpp:5]: (warning) Passing values 1.0 and 0 to fmodl() leads to implementation-defined result.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:28]: (error) Invalid fmod() argument nr 2. The value is 0 but the valid values are '!0.0'. [invalidFunctionArg]\n"
+                      "[test.cpp:4:29]: (error) Invalid fmodf() argument nr 2. The value is 0 but the valid values are '!0.0'. [invalidFunctionArg]\n"
+                      "[test.cpp:5:29]: (error) Invalid fmodl() argument nr 2. The value is 0 but the valid values are '!0.0'. [invalidFunctionArg]\n"
+                      "[test.cpp:3:19]: (warning) Passing values 1.0 and 0 to fmod() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:4:19]: (warning) Passing values 1.0 and 0 to fmodf() leads to implementation-defined result. [wrongmathcall]\n"
+                      "[test.cpp:5:19]: (warning) Passing values 1.0 and 0 to fmodl() leads to implementation-defined result. [wrongmathcall]\n", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -998,7 +1280,7 @@ class TestFunctions : public TestFixture {
               "    std::cout <<  fmodf(1.0,1) << std::endl;\n"
               "    std::cout <<  fmodl(1.0,1) << std::endl;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void mathfunctionCall_precision() {
@@ -1007,114 +1289,110 @@ class TestFunctions : public TestFixture {
               "    print(log(1 + x));\n"
               "    print(1 - erf(x));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Expression 'exp(x) - 1' can be replaced by 'expm1(x)' to avoid loss of precision.\n"
-                      "[test.cpp:3]: (style) Expression 'log(1 + x)' can be replaced by 'log1p(x)' to avoid loss of precision.\n"
-                      "[test.cpp:4]: (style) Expression '1 - erf(x)' can be replaced by 'erfc(x)' to avoid loss of precision.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Expression 'exp(x) - 1' can be replaced by 'expm1(x)' to avoid loss of precision. [unpreciseMathCall]\n"
+                      "[test.cpp:3:11]: (style) Expression 'log(1 + x)' can be replaced by 'log1p(x)' to avoid loss of precision. [unpreciseMathCall]\n"
+                      "[test.cpp:4:11]: (style) Expression '1 - erf(x)' can be replaced by 'erfc(x)' to avoid loss of precision. [unpreciseMathCall]\n", errout_str());
 
         check("void foo() {\n"
               "    print(exp(x) - 1.0);\n"
               "    print(log(1.0 + x));\n"
               "    print(1.0 - erf(x));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Expression 'exp(x) - 1' can be replaced by 'expm1(x)' to avoid loss of precision.\n"
-                      "[test.cpp:3]: (style) Expression 'log(1 + x)' can be replaced by 'log1p(x)' to avoid loss of precision.\n"
-                      "[test.cpp:4]: (style) Expression '1 - erf(x)' can be replaced by 'erfc(x)' to avoid loss of precision.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Expression 'exp(x) - 1' can be replaced by 'expm1(x)' to avoid loss of precision. [unpreciseMathCall]\n"
+                      "[test.cpp:3:11]: (style) Expression 'log(1 + x)' can be replaced by 'log1p(x)' to avoid loss of precision. [unpreciseMathCall]\n"
+                      "[test.cpp:4:12]: (style) Expression '1 - erf(x)' can be replaced by 'erfc(x)' to avoid loss of precision. [unpreciseMathCall]\n", errout_str());
 
         check("void foo() {\n"
               "    print(exp(3 + x*f(a)) - 1);\n"
               "    print(log(x*4 + 1));\n"
               "    print(1 - erf(34*x + f(x) - c));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Expression 'exp(x) - 1' can be replaced by 'expm1(x)' to avoid loss of precision.\n"
-                      "[test.cpp:3]: (style) Expression 'log(1 + x)' can be replaced by 'log1p(x)' to avoid loss of precision.\n"
-                      "[test.cpp:4]: (style) Expression '1 - erf(x)' can be replaced by 'erfc(x)' to avoid loss of precision.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Expression 'exp(x) - 1' can be replaced by 'expm1(x)' to avoid loss of precision. [unpreciseMathCall]\n"
+                      "[test.cpp:3:11]: (style) Expression 'log(1 + x)' can be replaced by 'log1p(x)' to avoid loss of precision. [unpreciseMathCall]\n"
+                      "[test.cpp:4:11]: (style) Expression '1 - erf(x)' can be replaced by 'erfc(x)' to avoid loss of precision. [unpreciseMathCall]\n", errout_str());
 
         check("void foo() {\n"
               "    print(2*exp(x) - 1);\n"
               "    print(1 - erf(x)/2.0);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void checkIgnoredReturnValue() {
-        Settings settings2;
-        settings2.addEnabled("warning");
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def version=\"2\">\n"
-                               "  <function name=\"mystrcmp,foo::mystrcmp\">\n"
-                               "    <use-retval/>\n"
-                               "    <arg nr=\"1\"/>\n"
-                               "    <arg nr=\"2\"/>\n"
-                               "  </function>\n"
-                               "</def>";
-        tinyxml2::XMLDocument doc;
-        doc.Parse(xmldata, sizeof(xmldata));
-        settings2.library.load(doc);
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def version=\"2\">\n"
+                                   "  <function name=\"mystrcmp,foo::mystrcmp\">\n"
+                                   "    <use-retval/>\n"
+                                   "    <arg nr=\"1\"/>\n"
+                                   "    <arg nr=\"2\"/>\n"
+                                   "  </function>\n"
+                                   "</def>";
+        const Settings settings2 = settingsBuilder().severity(Severity::warning).libraryxml(xmldata).build();
 
         check("void foo() {\n"
               "  mystrcmp(a, b);\n"
-              "}", "test.cpp", &settings2);
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Return value of function mystrcmp() is not used.\n", errout.str());
+              "}", settings2);
+        ASSERT_EQUALS("[test.cpp:2:3]: (warning) Return value of function mystrcmp() is not used. [ignoredReturnValue]\n", errout_str());
 
         check("void foo() {\n"
               "  foo::mystrcmp(a, b);\n"
-              "}", "test.cpp", &settings2);
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Return value of function foo::mystrcmp() is not used.\n", errout.str());
+              "}", settings2);
+        ASSERT_EQUALS("[test.cpp:2:8]: (warning) Return value of function foo::mystrcmp() is not used. [ignoredReturnValue]\n", errout_str());
 
         check("void f() {\n"
               "  foo x;\n"
               "  x.mystrcmp(a, b);\n"
-              "}", "test.cpp", &settings2);
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Return value of function x.mystrcmp() is not used.\n", errout.str());
+              "}", settings2);
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Return value of function x.mystrcmp() is not used. [ignoredReturnValue]\n", errout_str());
 
         check("bool mystrcmp(char* a, char* b);\n" // cppcheck sees a custom strcmp definition, but it returns a value. Assume it is the one specified in the library.
               "void foo() {\n"
               "    mystrcmp(a, b);\n"
-              "}", "test.cpp", &settings2);
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Return value of function mystrcmp() is not used.\n", errout.str());
+              "}", settings2);
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Return value of function mystrcmp() is not used. [ignoredReturnValue]\n", errout_str());
 
         check("void mystrcmp(char* a, char* b);\n" // cppcheck sees a custom strcmp definition which returns void!
               "void foo() {\n"
               "    mystrcmp(a, b);\n"
-              "}", "test.cpp", &settings2);
-        ASSERT_EQUALS("", errout.str());
+              "}", settings2);
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    class mystrcmp { mystrcmp() {} };\n" // strcmp is a constructor definition here
-              "}", "test.cpp", &settings2);
-        ASSERT_EQUALS("", errout.str());
+              "}", settings2);
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    return mystrcmp(a, b);\n"
-              "}", "test.cpp", &settings2);
-        ASSERT_EQUALS("", errout.str());
+              "}", settings2);
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    return foo::mystrcmp(a, b);\n"
-              "}", "test.cpp", &settings2);
-        ASSERT_EQUALS("", errout.str());
+              "}", settings2);
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    if(mystrcmp(a, b));\n"
-              "}", "test.cpp", &settings2);
-        ASSERT_EQUALS("", errout.str());
+              "}", settings2);
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    bool b = mystrcmp(a, b);\n"
-              "}", "test.cpp", &settings2);
-        ASSERT_EQUALS("", errout.str());
+              "}", settings2);
+        ASSERT_EQUALS("", errout_str());
 
         // #6194
         check("void foo() {\n"
               "    MyStrCmp mystrcmp(x, y);\n"
-              "}", "test.cpp", &settings2);
-        ASSERT_EQUALS("", errout.str());
+              "}", settings2);
+        ASSERT_EQUALS("", errout_str());
 
         // #6197
         check("void foo() {\n"
               "    abc::def.mystrcmp(a,b);\n"
-              "}", "test.cpp", &settings2);
-        ASSERT_EQUALS("", errout.str());
+              "}", settings2);
+        ASSERT_EQUALS("", errout_str());
 
         // #6233
         check("int main() {\n"
@@ -1125,35 +1403,29 @@ class TestFunctions : public TestFixture {
               "    lambda(13.3);\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str()); // TODO: use settings2?
 
         // #6669
         check("void foo(size_t size) {\n"
               "   void * res{malloc(size)};\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str()); // TODO: use settings2?
 
         // #7447
         check("void foo() {\n"
               "   int x{mystrcmp(a,b)};\n"
-              "}", "test.cpp", &settings2);
-        ASSERT_EQUALS("", errout.str());
+              "}", settings2);
+        ASSERT_EQUALS("", errout_str());
 
         // #7905
         check("void foo() {\n"
               "   int x({mystrcmp(a,b)});\n"
-              "}", "test.cpp", &settings2);
-        ASSERT_EQUALS("", errout.str());
-
-        // #7979 - code is not well configured
-        check("void foo() {\n"
-              "  DEBUG(x(); mystrcmp(a,b););\n"
-              "}", "test.cpp", &settings2);
-        ASSERT_EQUALS("", errout.str());
+              "}", settings2);
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n" // don't crash
               "  DEBUG(123)(mystrcmp(a,b))(fd);\n"
-              "}", "test.c", &settings2);
+              "}", settings2);
         check("struct teststruct {\n"
               "    int testfunc1() __attribute__ ((warn_unused_result)) { return 1; }\n"
               "    [[nodiscard]] int testfunc2() { return 1; }\n"
@@ -1163,43 +1435,82 @@ class TestFunctions : public TestFixture {
               "    teststruct TestStruct1;\n"
               "    TestStruct1.testfunc1();\n"
               "    TestStruct1.testfunc2();\n"
-              "}", "test.cpp", &settings2);
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Return value of function testfunc1() is not used.\n"
-                      "[test.cpp:4]: (warning) Return value of function testfunc2() is not used.\n"
-                      "[test.cpp:8]: (warning) Return value of function TestStruct1.testfunc1() is not used.\n"
-                      "[test.cpp:9]: (warning) Return value of function TestStruct1.testfunc2() is not used.\n", errout.str());
+              "    return 0;\n"
+              "}", settings2);
+        ASSERT_EQUALS("[test.cpp:4:18]: (warning) Return value of function testfunc1() is not used. [ignoredReturnValue]\n"
+                      "[test.cpp:4:31]: (warning) Return value of function testfunc2() is not used. [ignoredReturnValue]\n"
+                      "[test.cpp:8:17]: (warning) Return value of function TestStruct1.testfunc1() is not used. [ignoredReturnValue]\n"
+                      "[test.cpp:9:17]: (warning) Return value of function TestStruct1.testfunc2() is not used. [ignoredReturnValue]\n", errout_str());
 
         // #9006
         check("template <typename... a> uint8_t b(std::tuple<uint8_t> d) {\n"
               "  std::tuple<a...> c{std::move(d)};\n"
               "  return std::get<0>(c);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str()); // TODO: use settings2?
 
         check("struct A { int x; };\n"
               "template <class... Ts>\n"
               "A f(int x, Ts... xs) {\n"
               "    return {std::move(x), static_cast<int>(xs)...};\n"
               "}\n"
-              "A g() { return f(1); }\n");
-        ASSERT_EQUALS("", errout.str());
+              "A g() { return f(1); }");
+        ASSERT_EQUALS("", errout_str()); // TODO: use settings2?
+
+        // #8412 - unused operator result
+        check("void foo() {\n"
+              "  !mystrcmp(a, b);\n"
+              "}", settings2);
+        ASSERT_EQUALS("[test.cpp:2:4]: (warning) Return value of function mystrcmp() is not used. [ignoredReturnValue]\n", errout_str());
+
+        check("void f(std::vector<int*> v) {\n"
+              "    delete *v.begin();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str()); // TODO: use settings2?
+
+        check("int __attribute__((pure)) p_foo(int);\n" // #12697
+              "int __attribute__((const)) c_foo(int);\n"
+              "void f() {\n"
+              "    p_foo(0);\n"
+              "    c_foo(0);\n"
+              "}\n"); // TODO: use settings2?
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Return value of function p_foo() is not used. [ignoredReturnValue]\n"
+                      "[test.cpp:5:5]: (warning) Return value of function c_foo() is not used. [ignoredReturnValue]\n",
+                      errout_str());
+    }
+
+    void checkIgnoredErrorCode() {
+        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                               "<def version=\"2\">\n"
+                               "  <function name=\"mystrcmp\">\n"
+                               "    <use-retval type=\"error-code\"/>\n"
+                               "    <arg nr=\"1\"/>\n"
+                               "    <arg nr=\"2\"/>\n"
+                               "  </function>\n"
+                               "</def>";
+        const Settings settings2 = settingsBuilder().severity(Severity::style).libraryxml(xmldata).build();
+
+        check("void foo() {\n"
+              "  mystrcmp(a, b);\n"
+              "}", settings2);
+        ASSERT_EQUALS("[test.cpp:2:3]: (style) Error code from the return value of function mystrcmp() is not used. [ignoredReturnErrorCode]\n", errout_str());
     }
 
     void memsetZeroBytes() {
         check("void f() {\n"
               "    memset(p, 10, 0x0);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) memset() called to fill 0 bytes.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning) memset() called to fill 0 bytes. [memsetZeroBytes]\n", errout_str());
 
         check("void f() {\n"
               "    memset(p, sizeof(p), 0);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) memset() called to fill 0 bytes.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning) memset() called to fill 0 bytes. [memsetZeroBytes]\n", errout_str());
 
         check("void f() {\n"
               "    memset(p, sizeof(p), i);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // #6269 false positives in case of overloaded standard library functions
         check("class c {\n"
@@ -1208,13 +1519,13 @@ class TestFunctions : public TestFixture {
               "     memset( 0 );\n"
               "  }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #7285
         check("void f() {\n"
               "    memset(&tm, sizeof(tm), 0);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) memset() called to fill 0 bytes.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning) memset() called to fill 0 bytes. [memsetZeroBytes]\n", errout_str());
 
     }
 
@@ -1224,37 +1535,37 @@ class TestFunctions : public TestFixture {
               "    memset(is, 1.0f, 40);\n"
               "    int* is2 = new int[10];\n"
               "    memset(is2, 0.1f, 40);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (portability) The 2nd memset() argument '1.0f' is a float, its representation is implementation defined.\n"
-                      "[test.cpp:5]: (portability) The 2nd memset() argument '0.1f' is a float, its representation is implementation defined.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:17]: (portability) The 2nd memset() argument '1.0f' is a float, its representation is implementation defined. [memsetFloat]\n"
+                      "[test.cpp:5:18]: (portability) The 2nd memset() argument '0.1f' is a float, its representation is implementation defined. [memsetFloat]\n", errout_str());
 
         check("void f() {\n"
               "    int* is = new int[10];\n"
               "    float g = computeG();\n"
               "    memset(is, g, 40);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (portability) The 2nd memset() argument 'g' is a float, its representation is implementation defined.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:16]: (portability) The 2nd memset() argument 'g' is a float, its representation is implementation defined. [memsetFloat]\n", errout_str());
 
         check("void f() {\n"
               "    int* is = new int[10];\n"
               "    memset(is, 0.0f, 40);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n" // FP
               "    float x = 2.3f;\n"
               "    memset(a, (x?64:0), 40);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    short ss[] = {1, 2};\n"
               "    memset(ss, 256, 4);\n"
               "    short ss2[2];\n"
               "    memset(ss2, -129, 4);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) The 2nd memset() argument '256' doesn't fit into an 'unsigned char'.\n"
-                      "[test.cpp:5]: (warning) The 2nd memset() argument '-129' doesn't fit into an 'unsigned char'.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:16]: (warning) The 2nd memset() argument '256' doesn't fit into an 'unsigned char'. [memsetValueOutOfRange]\n"
+                      "[test.cpp:5:18]: (warning) The 2nd memset() argument '-129' doesn't fit into an 'unsigned char'. [memsetValueOutOfRange]\n", errout_str());
 
         check("void f() {\n"
               "    int is[10];\n"
@@ -1267,15 +1578,775 @@ class TestFunctions : public TestFixture {
               "    memset(cs2, 255, 30);\n"
               "    char cs3[30];\n"
               "    memset(cs3, 0, 30);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int is[10];\n"
               "    const int i = g();\n"
               "    memset(is, 1.0f + i, 40);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:21]: (portability) The 2nd memset() argument '1.0f+i' is a float, its representation is implementation defined. [memsetFloat]\n", errout_str());
+    }
+
+    void checkMissingReturn1() {
+        check("int f() {}");
+        ASSERT_EQUALS("[test.cpp:1:10]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
+
+        {
+            const char code[] = "int main(void) {}";
+            {
+                const Settings s = settingsBuilder().c(Standards::C89).build();
+
+                check(code, s, false); // c code (c89)
+                ASSERT_EQUALS("[test.c:1:17]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
+            }
+
+            {
+                const Settings s = settingsBuilder().c(Standards::C99).build();
+                check(code, s, false); // c code (c99)
+                ASSERT_EQUALS("", errout_str());
+
+                check(code, s); // c++ code
+                ASSERT_EQUALS("", errout_str());
+            }
+        }
+
+        check("F(A,B) { x=1; }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("auto foo4() -> void {}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void STDCALL foo() {}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void operator=(int y) { x=y; }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f() {\n"
+              "back:\n"
+              "    return 0;\n"
+              "ng:\n"
+              "    x=y;\n"
+              "    goto back;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (portability) The 2nd memset() argument '1.0f+i' is a float, its representation is implementation defined.\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // unreachable code..
+        check("int foo(int x) {\n"
+              "  return 1;\n"
+              "  (void)x;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int foo(int x) {\n"
+              "  if (x) goto out;\n"
+              "  return 1;\n"
+              "out:\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:11]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
+
+        // switch
+        check("int f() {\n"
+              "    switch (x) {\n"
+              "        case 1: break;\n" // <- error
+              "        case 2: return 1;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:17]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
+
+        check("int f() {\n"
+              "    switch (x) {\n"
+              "        case 1: return 2; break;\n"
+              "        default: return 1;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool test(unsigned char v1, int v2) {\n"
+              "    switch (v1) {\n"
+              "        case 0:\n"
+              "            switch (v2) {\n"
+              "            case 48000:\n"
+              "                break;\n"
+              "            }\n"
+              "            return false;\n"
+              "        default:\n"
+              "            return true;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // if/else
+        check("int f(int x) {\n"
+              "    if (x) {\n"
+              "        return 1;\n"
+              "    }\n" // <- error (missing else)
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
+
+        check("int f(int x) {\n"
+              "    if (x) {\n"
+              "        ;\n" // <- error
+              "    } else {\n"
+              "        return 1;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:9]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
+
+        check("int f() {\n"
+              "    if (!0) {\n"
+              "        return 1;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f() {\n"
+              "    if (!0) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:14]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
+
+        // loop
+        check("int f(int x) {\n"
+              "    while (1) {\n"
+              "        dostuff();\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // return {..}
+        check("std::pair<int, int> typeDecl(int tok) {\n"
+              "    if (!tok)\n"
+              "        return {};\n"
+              "    else\n"
+              "        return {1, 2};\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // noreturn function
+        check("int f(int x) { exit(0); }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int x) { assert(0); }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int x) { if (x) return 1; else return bar({1}, {}); }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("auto f() -> void {}"); // #10342
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S1 {\n" // #7433
+              "    S1& operator=(const S1& r) { if (this != &r) { i = r.i; } }\n"
+              "    int i;\n"
+              "};\n"
+              "struct S2 {\n"
+              "    S2& operator=(const S2& s) { if (this != &s) { j = s.j; } return *this; }\n"
+              "    int j;\n"
+              "};\n"
+              "struct S3 {\n"
+              "    S3& operator=(const S3& t) { if (this != &t) { k = t.k; return *this; } }\n"
+              "    int k;\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:2:61]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n"
+                      "[test.cpp:10:75]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n",
+                      errout_str());
+
+        // #11171
+        check("std::enable_if_t<sizeof(uint64_t) == 8> f() {}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::enable_if_t<sizeof(uint64_t) == 8, int> f() {}");
+        ASSERT_EQUALS(
+            "[test.cpp:1:51]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n",
+            errout_str());
+
+        check("template<class T> std::enable_if_t<std::is_same<T, int>{}, int> f(T) {}");
+        ASSERT_EQUALS(
+            "[test.cpp:1:71]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n",
+            errout_str());
+
+        check("template<class T> std::enable_if_t<std::is_same<T, int>{}> f(T) {}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("typename std::enable_if<sizeof(uint64_t) == 8>::type f() {}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("typename std::enable_if<sizeof(uint64_t) == 8, int>::type f() {}");
+        ASSERT_EQUALS(
+            "[test.cpp:1:64]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n",
+            errout_str());
+
+        check("template<class T> typename std::enable_if<std::is_same<T, int>{}, int>::type f(T) {}");
+        ASSERT_EQUALS(
+            "[test.cpp:1:84]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n",
+            errout_str());
+
+        check("template<class T> typename std::enable_if<std::is_same<T, int>{}>::type f(T) {}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n"
+              "     [[noreturn]] void f();\n"
+              "     int g() { this->f(); }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { [[noreturn]] void f(); };\n"
+              "int g(S& s) { s.f(); }\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void checkMissingReturn2() { // #11798
+        check("int f(bool const a) {\n"
+              "      switch (a) {\n"
+              "      case true:\n"
+              "            return 1;\n"
+              "      case false:\n"
+              "            return 2;\n"
+              "      }\n"
+              "}\n"
+              "int main(int argc, char* argv[])\n"
+              "{\n"
+              "      auto const b= f(true);\n"
+              "      auto const c= f(false);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void checkMissingReturn3() {
+        check("enum Enum {\n"
+              "    A,\n"
+              "    B,\n"
+              "    C,\n"
+              "};\n"
+              "int f(Enum e) {\n"
+              "    switch (e) {\n"
+              "    case A:\n"
+              "          return 1;\n"
+              "    case B:\n"
+              "          return 2;\n"
+              "    case C:\n"
+              "          return 2;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void checkMissingReturn4() {
+        check("enum Enum {\n"
+              "    A,\n"
+              "    B,\n"
+              "    C,\n"
+              "};\n"
+              "int f(Enum e) {\n"
+              "    switch (e) {\n"
+              "    case A:\n"
+              "          return 1;\n"
+              "    case B:\n"
+              "          return 2;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:7:16]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
+    }
+
+    void checkMissingReturn5() {
+        check("enum Enum {\n"
+              "    A,\n"
+              "    B,\n"
+              "    C,\n"
+              "};\n"
+              "int f(Enum e, bool b) {\n"
+              "    switch (e) {\n"
+              "    case A:\n"
+              "          return 1;\n"
+              "    case B:\n"
+              "          return 2;\n"
+              "    case C:\n"
+              "          switch (b) {\n"
+              "          case true:\n"
+              "              return 3;\n"
+              "          case false:\n"
+              "              return 4;\n"
+              "          }\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void checkMissingReturn6() {// #13180
+        check("int foo(void)\n"
+              "{\n"
+              "    i = readData();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
+    }
+
+    void checkMissingReturn7() {// #14370 FN try/catch
+        check("int foo(void) {\n"
+              "    try { return readData(); }\n"
+              "    catch (...) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:18]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
+
+        check("int foo(void) {\n"
+              "    try { return readData(); }\n"
+              "    catch (const E& e) {}\n"
+              "    catch (...) { return 2; }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:25]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
+
+        check("int foo(void) {\n"
+              "    try { x=1; }\n"
+              "    catch (...) { return 2; }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:11]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
+
+        check("int foo(void) {\n"
+              "    try { return readData(); }\n"
+              "    catch (...) { return 0; }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int foo(void)\n"
+              "    try { x=1; }\n"
+              "    catch (...) { return 2; }\n");
+        ASSERT_EQUALS("[test.cpp:2:11]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
+
+        check("int foo(void)\n"
+              "    try { return readData(); }\n"
+              "    catch (...) { }\n");
+        ASSERT_EQUALS("[test.cpp:3:19]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
+    }
+
+    void checkMissingReturnStdInt() {// #14482 - FN
+        check("std::int32_t f() {}\n");
+        ASSERT_EQUALS("[test.cpp:1:19]: (error) Found an exit path from function with non-void return type that has missing return statement [missingReturn]\n", errout_str());
+    }
+
+    // NRVO check
+    void returnLocalStdMove1() {
+        check("struct A{}; A f() { A var; return std::move(var); }");
+        ASSERT_EQUALS("[test.cpp:1:45]: (performance) Using std::move for returning object by-value from function will affect copy elision optimization."
+                      " More: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rf-return-move-local [returnStdMoveLocal]\n", errout_str());
+    }
+
+    // RVO, C++03 ctor style
+    void returnLocalStdMove2() {
+        check("struct A{}; A f() { return std::move( A() ); }");
+        ASSERT_EQUALS("[test.cpp:1:40]: (performance) Using std::move for returning object by-value from function will affect copy elision optimization."
+                      " More: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rf-return-move-local [returnStdMoveLocal]\n", errout_str());
+    }
+
+    // RVO, new ctor style
+    void returnLocalStdMove3() {
+        check("struct A{}; A f() { return std::move(A{}); }");
+        ASSERT_EQUALS("[test.cpp:1:39]: (performance) Using std::move for returning object by-value from function will affect copy elision optimization."
+                      " More: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rf-return-move-local [returnStdMoveLocal]\n", errout_str());
+    }
+
+    // Function argument
+    void returnLocalStdMove4() {
+        check("struct A{}; A f(A a) { return std::move(A{}); }");
+        ASSERT_EQUALS("[test.cpp:1:42]: (performance) Using std::move for returning object by-value from function will affect copy elision optimization."
+                      " More: https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rf-return-move-local [returnStdMoveLocal]\n", errout_str());
+    }
+
+    void returnLocalStdMove5() {
+        check("struct A{} a; A f1() { return std::move(a); }\n"
+              "A f2() { volatile A var; return std::move(var); }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { std::string msg{ \"abc\" }; };\n"
+              "std::unique_ptr<S> get(std::vector<std::unique_ptr<S>>& v) {\n"
+              "    return std::move(v.front());\n"
+              "}\n"
+              "int main() {\n"
+              "    std::vector<std::unique_ptr<S>> v;\n"
+              "    v.emplace_back(std::make_unique<S>());\n"
+              "    auto p = get(v);\n"
+              "    std::cout << p->msg;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::string&& f() {\n" // #11881
+              "    std::string s;\n"
+              "    return std::move(s);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void negativeMemoryAllocationSizeError() { // #389
+        check("void f() {\n"
+              "   int *a;\n"
+              "   a = malloc( -10 );\n"
+              "   free(a);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:17]: (error) Invalid malloc() argument nr 1. The value is -10 but the valid values are '0:'. [invalidFunctionArg]\n", errout_str());
+
+        check("void f() {\n"
+              "   int *a;\n"
+              "   a = alloca( -10 );\n"
+              "   free(a);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:8]: (warning) Obsolete function 'alloca' called. [allocaCalled]\n"
+                      "[test.cpp:3:17]: (error) Invalid alloca() argument nr 1. The value is -10 but the valid values are '0:'. [invalidFunctionArg]\n", errout_str());
+    }
+
+    void checkLibraryMatchFunctions() {
+        /*const*/ Settings s = settingsBuilder(settings).checkLibrary().debugwarnings().build();
+        s.daca = true;
+
+        check("void f() {\n"
+              "    lib_func();"
+              "}", s);
+        ASSERT_EQUALS("[test.cpp:2:5]: (information) --check-library: There is no matching configuration for function lib_func() [checkLibraryFunction]\n", errout_str());
+
+        check("void f(void* v) {\n"
+              "    lib_func(v);"
+              "}", s);
+        ASSERT_EQUALS("[test.cpp:2:5]: (information) --check-library: There is no matching configuration for function lib_func() [checkLibraryFunction]\n", errout_str());
+
+        // #10105
+        check("class TestFixture {\n"
+              "protected:\n"
+              "        bool prepareTest(const char testname[]);\n"
+              "};\n"
+              "\n"
+              "class TestMemleak : private TestFixture {\n"
+              "        void run() {\n"
+              "                do { prepareTest(\"testFunctionReturnType\"); } while (false);\n"
+              "        }\n"
+              "\n"
+              "        void testFunctionReturnType() {\n"
+              "        }\n"
+              "};", s);
+        ASSERT_EQUALS("", errout_str());
+
+        // #11183
+        check("#include <string>\n"
+              "\n"
+              "extern void cb(const std::string&);\n"
+              "\n"
+              "void f() {\n"
+              "    cb(std::string(\"\"));\n"
+              "}", s);
+        TODO_ASSERT_EQUALS("", "[test.cpp:6:5]: (information) --check-library: There is no matching configuration for function cb() [checkLibraryFunction]\n", errout_str());
+
+        // #7375
+        check("void f() {\n"
+              "    struct S { int i; char c; };\n"
+              "    size_t s = sizeof(S);\n"
+              "    static_assert(s == 9);\n"
+              "}\n", s);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(char) {}\n"
+              "void g() {\n"
+              "    f(int8_t(1));\n"
+              "}\n", s);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::uint64_t& u) {\n"
+              "    u = std::uint32_t(u) * std::uint64_t(100);\n"
+              "}\n", s);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() { throw(1); }\n", s); // #8958
+        ASSERT_EQUALS("", errout_str());
+
+        check("using namespace std;\n"
+              "void f() { throw range_error(\"abc\"); }\n", s);
+        ASSERT_EQUALS("", errout_str());
+
+        check("class C {\n" // #9002
+              "public:\n"
+              "    static int f() { return 1; }\n"
+              "};\n"
+              "void g() { C::f(); }\n", s);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const std::vector<std::string>& v) {\n" // #11223
+              "    for (const auto& s : v)\n"
+              "        s.find(\"\");\n"
+              "}\n", s);
+        ASSERT_EQUALS("[test.cpp:3:11]: (warning) Return value of function s.find() is not used. [ignoredReturnValue]\n", errout_str());
+
+        check("void f() {\n"
+              "    auto* p = new std::vector<int>(5);\n"
+              "    p->push_back(1);\n"
+              "    auto* q = new std::vector<int>{ 5, 7 };\n"
+              "    q->push_back(1);\n"
+              "    auto* r = new std::vector<int>;\n"
+              "    r->push_back(1);\n"
+              "}\n", s);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    auto p = std::make_shared<std::vector<int>>();\n"
+              "    p->push_back(1);\n"
+              "}\n", s);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::vector<std::vector<int>>& v) {\n"
+              "    auto it = v.begin();\n"
+              "    it->push_back(1);\n"
+              "}\n", s);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    auto v = std::vector<int>{};\n"
+              "    v.push_back(1);\n"
+              "    auto w = std::vector<int>{ 1, 2, 3 };\n"
+              "    w.push_back(1);\n"
+              "    auto x = std::vector<int>(1);\n"
+              "    x.push_back(1);\n"
+              "}\n", s);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    auto p(std::make_shared<std::vector<int>>());\n"
+              "    p->push_back(1);\n"
+              "    auto q{ std::make_shared<std::vector<int>>{} };\n"
+              "    q->push_back(1);\n"
+              "}\n", s);
+        TODO_ASSERT_EQUALS("",
+                           "[test.cpp:2:5]: (debug) auto token with no type. [autoNoType]\n"
+                           "[test.cpp:4:5]: (debug) auto token with no type. [autoNoType]\n"
+                           "[test.cpp:3:8]: (information) --check-library: There is no matching configuration for function auto::push_back() [checkLibraryFunction]\n"
+                           "[test.cpp:5:8]: (information) --check-library: There is no matching configuration for function auto::push_back() [checkLibraryFunction]\n",
+                           errout_str());
+
+        check("struct F { void g(int); };\n"
+              "void f(std::list<F>& l) {\n"
+              "    std::list<F>::iterator it;\n"
+              "    for (it = l.begin(); it != l.end(); ++it)\n"
+              "        it->g(0);\n"
+              "}\n", s);
+        ASSERT_EQUALS("", filter_valueflow(errout_str()));
+
+        check("auto f() {\n"
+              "    return std::runtime_error(\"abc\");\n"
+              "}\n", s);
+        TODO_ASSERT_EQUALS("",
+                           "[test.cpp:1:1]: (debug) auto token with no type. [autoNoType]\n",
+                           errout_str());
+
+        check("struct S {\n" // #11543
+              "    S() {}\n"
+              "    std::vector<std::shared_ptr<S>> v;\n"
+              "    void f(int i) const;\n"
+              "};\n"
+              "void S::f(int i) const {\n"
+              "    for (const std::shared_ptr<S>& c : v)\n"
+              "        c->f(i);\n"
+              "}\n", s);
+        ASSERT_EQUALS("", errout_str());
+
+        check("namespace N {\n"
+              "    struct S { static const std::set<std::string> s; };\n"
+              "}\n"
+              "void f() {\n"
+              "    const auto& t = N::S::s;\n"
+              "    if (t.find(\"abc\") != t.end()) {}\n"
+              "}\n", s);
+        ASSERT_EQUALS("", filter_valueflow(errout_str()));
+
+        check("void f(std::vector<std::unordered_map<int, std::unordered_set<int>>>& v, int i, int j) {\n"
+              "    auto& s = v[i][j];\n"
+              "    s.insert(0);\n"
+              "}\n", s);
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(const std::vector<std::string>& v, int i, char c) {\n"
+              "    const auto& s = v[i];\n"
+              "    return s.find(c);\n"
+              "}\n", s);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n" // #11604
+              "    int (*g)() = nullptr;\n"
+              "}\n", s);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    INT (*g)() = nullptr;\n"
+              "}\n", s);
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct T;\n"
+              "std::shared_ptr<T> get();\n"
+              "void f(int i) {\n"
+              "    auto p = get();\n"
+              "    p->h(i);\n"
+              "    p.reset(nullptr);\n"
+              "}\n", s);
+        ASSERT_EQUALS("[test.cpp:5:8]: (information) --check-library: There is no matching configuration for function T::h() [checkLibraryFunction]\n",
+                      errout_str());
+
+        check("struct S : std::vector<int> {\n"
+              "    void f(int i) { push_back(i); }\n"
+              "};\n", s);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    auto g = []() -> std::string { return \"abc\"; };\n"
+              "    auto s = g();\n"
+              "    if (s.at(0)) {}\n"
+              "    auto h{ []() -> std::string { return \"xyz\"; } };\n"
+              "    auto t = h();\n"
+              "    if (t.at(0)) {}\n"
+              "};\n", s);
+        ASSERT_EQUALS("", filter_valueflow(errout_str()));
+
+        check("::std::string f(const char* c) {\n" // #12365
+              "    return ::std::string(c);\n"
+              "}\n", s);
+        ASSERT_EQUALS("", errout_str());
+
+        check("template <typename T>\n"
+              "struct S : public std::vector<T> {\n"
+              "    void resize(size_t n) { std::vector<T>::resize(n); }\n"
+              "};\n", s);
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct P {\n" // #13105
+              "    bool g(int i) const;\n"
+              "    std::shared_ptr<std::map<int, int>> m;\n"
+              "};\n"
+              "bool P::g(int i) const {\n"
+              "    auto it = m->find(i);\n"
+              "    const bool b = it != m->end();\n"
+              "    return b;\n"
+              "}\n", s);
+        TODO_ASSERT_EQUALS("", "[test.cpp:6:5]: (debug) auto token with no type. [autoNoType]\n", errout_str());
+
+        check("template <typename T>\n" // #13509
+              "void f(const T& t) {\n"
+              "    t.g();\n"
+              "}\n", s);
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void checkUseStandardLibrary1() {
+        check("void f(void* dest, void const* src, const size_t count) {\n"
+              "    size_t i;\n"
+              "    for (i = 0; count > i; ++i)\n"
+              "        (reinterpret_cast<uint8_t*>(dest))[i] = (reinterpret_cast<const uint8_t*>(src))[i];\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:9]: (style) Consider using std::memcpy instead of loop. [useStandardLibrary]\n", errout_str());
+    }
+
+    void checkUseStandardLibrary2() {
+        check("void f(void* dest, void const* src, const size_t count) {\n"
+              "    for (size_t i = 0; i < count; i++) {\n"
+              "        (reinterpret_cast<uint8_t*>(dest))[i] = (reinterpret_cast<const uint8_t*>(src))[i];\n"
+              "}}\n");
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Consider using std::memcpy instead of loop. [useStandardLibrary]\n", errout_str());
+    }
+
+    void checkUseStandardLibrary3() {
+        check("void f(void* dst, const void* src, const size_t count) {\n"
+              "    size_t i;\n"
+              "    for (i = 0; count > i; i++)\n"
+              "        ((char*)dst)[i] = ((const char*)src)[i];\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:9]: (style) Consider using std::memcpy instead of loop. [useStandardLibrary]\n", errout_str());
+    }
+
+    void checkUseStandardLibrary4() {
+        check("void f(void* dst, void* src, const size_t size) {\n"
+              "    for (size_t i = 0; i < size; i += 1) {\n"
+              "        ((int8_t*)dst)[i] = ((int8_t*)src)[i];\n"
+              "}}\n");
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Consider using std::memcpy instead of loop. [useStandardLibrary]\n", errout_str());
+    }
+
+    // different indexes
+    void checkUseStandardLibrary5() {
+        check("void f(void* dst, void* src, const size_t size, const size_t from_idx) {\n"
+              "    for (size_t i = 0; i < size; ++i) {\n"
+              "        ((int8_t*)dst)[i] = ((int8_t*)src)[from_idx];\n"
+              "}}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // unknown count
+    void checkUseStandardLibrary6() {
+        check("void f(void* dst, void* src, const size_t size) {\n"
+              "    for (size_t i = 0; ((int8_t*)src)[i] != 0; ++i) {\n"
+              "        ((int8_t*)dst)[i] = ((int8_t*)src)[i];\n"
+              "}}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // increment with 2
+    void checkUseStandardLibrary7() {
+        check("void f(void* dst, void* src, const size_t size) {\n"
+              "    for (size_t i = 0; i < size; i += 2) {\n"
+              "        ((int8_t*)dst)[i] = ((int8_t*)src)[i];\n"
+              "}}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // right argument of assignment could be static_cast, functional cast, c-style and implicit cast
+    // functional cast case not covered
+    void checkUseStandardLibrary8() {
+        check("void f(void* dest, const size_t count) {\n"
+              "    size_t i;\n"
+              "    for (i = 0; i < count; ++i)\n"
+              "        (reinterpret_cast<int8_t*>(dest))[i] = static_cast<const int8_t>(0);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:9]: (style) Consider using std::memset instead of loop. [useStandardLibrary]\n", errout_str());
+    }
+
+    void checkUseStandardLibrary9() {
+        check("void f(void* dest, const size_t count) {\n"
+              "    for (size_t i = 0; i < count; i++) {\n"
+              "        (reinterpret_cast<uint8_t*>(dest))[i] = (static_cast<const uint8_t>(0));\n"
+              "}}\n");
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Consider using std::memset instead of loop. [useStandardLibrary]\n", errout_str());
+    }
+
+    void checkUseStandardLibrary10() {
+        check("void f(void* dst, const size_t size) {\n"
+              "    size_t i;\n"
+              "    for (i = 0; i < size; i++)\n"
+              "        ((char*)dst)[i] = (const char)0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:9]: (style) Consider using std::memset instead of loop. [useStandardLibrary]\n", errout_str());
+    }
+
+    void checkUseStandardLibrary11() {
+        check("void f(void* dst, const size_t size) {\n"
+              "    for (size_t i = 0; i < size; i += 1) {\n"
+              "        ((int8_t*)dst)[i] = ((int8_t)0);\n"
+              "}}\n");
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Consider using std::memset instead of loop. [useStandardLibrary]\n", errout_str());
+    }
+
+    void checkUseStandardLibrary12() {
+        check("void f(void* dst, const size_t size) {\n"
+              "    for (size_t i = 0; i < size; i += 1) {\n"
+              "        ((int8_t*)dst)[i] = 42;\n"
+              "}}\n");
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Consider using std::memset instead of loop. [useStandardLibrary]\n", errout_str());
+    }
+
+    void checkUseStandardLibrary13() {
+        check("void f(void* dest, const size_t count) {\n"
+              "    for (size_t i = 0; i < count; i++) {\n"
+              "        reinterpret_cast<unsigned char*>(dest)[i] = '0';\n"
+              "}}\n");
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Consider using std::memset instead of loop. [useStandardLibrary]\n", errout_str());
+    }
+
+    void checkUseStandardLibrary14() {
+        check("void f(void* dest) {\n"
+              "    for (size_t i = 0; i < sizeof(int)*(15 + 42/2 - 7); i++) {\n"
+              "        reinterpret_cast<unsigned char*>(dest)[i] = '0';\n"
+              "}}\n");
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Consider using std::memset instead of loop. [useStandardLibrary]\n", errout_str());
     }
 };
 
diff --git a/test/testgarbage.cpp b/test/testgarbage.cpp
index f13d1560827..5f6b67867f7 100644
--- a/test/testgarbage.cpp
+++ b/test/testgarbage.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,32 +17,28 @@
  */
 
 #include "check.h"
-#include "errorlogger.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "settings.h"
-#include "testsuite.h"
 #include "token.h"
-#include "tokenize.h"
 
+#include <cstddef>
 #include <list>
-
+#include <string>
 
 class TestGarbage : public TestFixture {
 public:
-    TestGarbage() : TestFixture("TestGarbage") {
-    }
+    TestGarbage() : TestFixture("TestGarbage") {}
 
 private:
-    Settings settings;
-
-    void run() OVERRIDE {
-        settings.debugwarnings = true;
-        settings.addEnabled("style");
-        settings.addEnabled("warning");
-        settings.addEnabled("portability");
-        settings.addEnabled("performance");
-        settings.addEnabled("information");
-        settings.inconclusive = true;
-        settings.experimental = true;
+    /*const*/ Settings settings = settingsBuilder().debugwarnings().build();
+
+    void run() override {
+        settings.severity.fill();
+        settings.certainty.fill();
+
+        mNewTemplate = true;
 
         // don't freak out when the syntax is wrong
 
@@ -53,6 +49,7 @@ class TestGarbage : public TestFixture {
         TEST_CASE(wrong_syntax4); // #3618
         TEST_CASE(wrong_syntax_if_macro);  // #2518 - if MACRO()
         TEST_CASE(wrong_syntax_class_x_y); // #3585 - class x y { };
+        TEST_CASE(wrong_syntax_anonymous_struct);
         TEST_CASE(syntax_case_default);
         TEST_CASE(garbageCode1);
         TEST_CASE(garbageCode2); // #4300
@@ -66,7 +63,6 @@ class TestGarbage : public TestFixture {
         TEST_CASE(garbageCode10); // #6127
         TEST_CASE(garbageCode12);
         TEST_CASE(garbageCode13); // #2607
-        TEST_CASE(garbageCode14); // #5595
         TEST_CASE(garbageCode15); // #5203
         TEST_CASE(garbageCode16);
         TEST_CASE(garbageCode17);
@@ -238,6 +234,32 @@ class TestGarbage : public TestFixture {
         TEST_CASE(garbageCode203); // #8972
         TEST_CASE(garbageCode204);
         TEST_CASE(garbageCode205);
+        TEST_CASE(garbageCode206);
+        TEST_CASE(garbageCode207); // #8750
+        TEST_CASE(garbageCode208); // #8753
+        TEST_CASE(garbageCode209); // #8756
+        TEST_CASE(garbageCode210); // #8762
+        TEST_CASE(garbageCode211); // #8764
+        TEST_CASE(garbageCode212); // #8765
+        TEST_CASE(garbageCode213); // #8758
+        TEST_CASE(garbageCode214);
+        TEST_CASE(garbageCode215); // daca@home script with extension .c
+        TEST_CASE(garbageCode216); // #7884
+        TEST_CASE(garbageCode217); // #10011
+        TEST_CASE(garbageCode218); // #8763
+        TEST_CASE(garbageCode219); // #10101
+        TEST_CASE(garbageCode220); // #6832
+        TEST_CASE(garbageCode221);
+        TEST_CASE(garbageCode222); // #10763
+        TEST_CASE(garbageCode223); // #11639
+        TEST_CASE(garbageCode224);
+        TEST_CASE(garbageCode225);
+        TEST_CASE(garbageCode226);
+        TEST_CASE(garbageCode227);
+        TEST_CASE(garbageCode228);
+        TEST_CASE(garbageCode229);
+        TEST_CASE(garbageCode230);
+        TEST_CASE(garbageCode231);
 
         TEST_CASE(garbageCodeFuzzerClientMode1); // test cases created with the fuzzer client, mode 1
 
@@ -255,47 +277,43 @@ class TestGarbage : public TestFixture {
         TEST_CASE(nonGarbageCode1); // #8346
     }
 
-    std::string checkCode(const std::string &code, bool cpp = true) {
-        // double the tests - run each example as C as well as C++
-        const char* const filename = cpp ? "test.cpp" : "test.c";
-        const char* const alternatefilename = cpp ? "test.c" : "test.cpp";
+#define checkCodeInternal(...) checkCodeInternal_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    std::string checkCodeInternal_(const char* file, int line, const char (&code)[size], bool cpp) {
+        // tokenize..
+        SimpleTokenizer tokenizer(settings, *this, cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
-        // run alternate check first. It should only ensure stability - so we catch exceptions here.
-        try {
-            checkCodeInternal(code, alternatefilename);
-        } catch (const InternalError&) {
+        // call all "runChecks" in all registered Check classes
+        for (auto it = Check::instances().cbegin(); it != Check::instances().cend(); ++it) {
+            (*it)->runChecks(tokenizer, this);
         }
 
-        return checkCodeInternal(code, filename);
+        return tokenizer.tokens()->stringifyList(false, false, false, true, false, nullptr, nullptr);
     }
 
-    std::string checkCodeInternal(const std::string &code, const char* filename) {
-        errout.str("");
-
-        // tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, filename);
-
-        // call all "runChecks" in all registered Check classes
-        for (std::list<Check *>::const_iterator it = Check::instances().begin(); it != Check::instances().end(); ++it) {
-            (*it)->runChecks(&tokenizer, &settings, this);
-        }
+    template<size_t size>
+    std::string checkCode(const char (&code)[size], bool cpp = true) {
+        // double the tests - run each example as C as well as C++
 
-        tokenizer.simplifyTokenList2();
+        // run alternate check first. It should only ensure stability - so we catch exceptions here.
+        try {
+            (void)checkCodeInternal(code, !cpp);
+        } catch (const InternalError&) {}
 
-        return tokenizer.tokens()->stringifyList(false, false, false, true, false, nullptr, nullptr);
+        return checkCodeInternal(code, cpp);
     }
 
-    std::string getSyntaxError(const char code[]) {
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
+#define getSyntaxError(...) getSyntaxError_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    std::string getSyntaxError_(const char* file, int line, const char (&code)[size]) {
+        SimpleTokenizer tokenizer(settings, *this);
         try {
-            tokenizer.tokenize(istr, "test.cpp");
+            ASSERT_LOC(tokenizer.tokenize(code), file, line);
         } catch (InternalError& e) {
             if (e.id != "syntaxError")
                 return "";
-            return "[test.cpp:" + MathLib::toString(e.token->linenr()) + "] " + e.errorMessage;
+            return "[test.cpp:" + std::to_string(e.token->linenr()) + "] " + e.errorMessage;
         }
         return "";
     }
@@ -304,31 +322,26 @@ class TestGarbage : public TestFixture {
     void final_class_x() {
 
         const char code[] = "class __declspec(dllexport) x final { };";
-        {
-            errout.str("");
-            Tokenizer tokenizer(&settings, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
-            tokenizer.simplifyTokenList2();
-            ASSERT_EQUALS("", errout.str());
-        }
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT(tokenizer.tokenize(code));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void wrong_syntax1() {
         {
             const char code[] ="TR(kvmpio, PROTO(int rw), ARGS(rw), TP_(aa->rw;))";
-            ASSERT_EQUALS("TR ( kvmpio , PROTO ( int rw ) , ARGS ( rw ) , TP_ ( aa . rw ; ) )", checkCode(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_THROW_INTERNAL(checkCode(code), UNKNOWN_MACRO);
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] ="struct A { template<int> struct { }; };";
-            ASSERT_THROW(checkCode(code), InternalError);
+            ASSERT_THROW_INTERNAL(checkCode(code), SYNTAX);
         }
 
         {
             const char code[] ="enum ABC { A,B, typedef enum { C } };";
-            ASSERT_THROW(checkCode(code), InternalError);
+            ASSERT_THROW_INTERNAL(checkCode(code), SYNTAX);
         }
     }
 
@@ -341,7 +354,8 @@ class TestGarbage : public TestFixture {
                             "void G( template <typename T> class (j) ) {}";
 
         // don't segfault..
-        ASSERT_THROW(checkCode(code), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode(code), SYNTAX);
+        ignore_errout(); // we are not interested in the output
     }
 
 
@@ -354,10 +368,9 @@ class TestGarbage : public TestFixture {
                             " )\n"
                             "}";
 
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
+        SimpleTokenizer tokenizer(settings, *this);
         try {
-            tokenizer.tokenize(istr, "test.cpp");
+            ASSERT(tokenizer.tokenize(code));
             assertThrowFail(__FILE__, __LINE__);
         } catch (InternalError& e) {
             ASSERT_EQUALS("syntax error", e.errorMessage);
@@ -369,18 +382,18 @@ class TestGarbage : public TestFixture {
     void wrong_syntax4() {   // #3618
         const char code[] = "typedef void (x) (int);    return x&";
 
-        ASSERT_THROW(checkCode(code), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode(code), SYNTAX);
     }
 
     void wrong_syntax_if_macro() {
         // #2518 #4171
-        ASSERT_THROW(checkCode("void f() { if MACRO(); }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { if MACRO(); }"), SYNTAX);
 
         // #4668 - note there is no semicolon after MACRO()
-        ASSERT_THROW(checkCode("void f() { if (x) MACRO() {} }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { if (x) MACRO() {} }"), SYNTAX);
 
         // #4810 - note there is no semicolon after MACRO()
-        ASSERT_THROW(checkCode("void f() { if (x) MACRO() else ; }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { if (x) MACRO() else ; }"), SYNTAX);
     }
 
     void wrong_syntax_class_x_y() {
@@ -388,48 +401,47 @@ class TestGarbage : public TestFixture {
         const char code[] = "class x y { };";
 
         {
-            errout.str("");
-            Tokenizer tokenizer(&settings, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.c");
-            tokenizer.simplifyTokenList2();
-            ASSERT_EQUALS("", errout.str());
+            SimpleTokenizer tokenizer(settings, *this, false);
+            ASSERT(tokenizer.tokenize(code));
+            ASSERT_EQUALS("", errout_str());
         }
         {
-            errout.str("");
-            Tokenizer tokenizer(&settings, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
-            tokenizer.simplifyTokenList2();
-            ASSERT_EQUALS("[test.cpp:1]: (information) The code 'class x y {' is not handled. You can use -I or --include to add handling of this code.\n", errout.str());
+            SimpleTokenizer tokenizer(settings, *this);
+            ASSERT(tokenizer.tokenize(code));
+            ASSERT_EQUALS("[test.cpp:1:1]: (information) The code 'class x y {' is not handled. You can use -I or --include to add handling of this code. [class_X_Y]\n", errout_str());
         }
     }
 
+    void wrong_syntax_anonymous_struct() {
+        ASSERT_THROW_INTERNAL(checkCode("struct { int x; } = {0};"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("struct { int x; } * = {0};"), SYNTAX);
+    }
+
     void syntax_case_default() {
-        ASSERT_THROW(checkCode("void f() {switch (n) { case: z(); break;}}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {switch (n) { case: z(); break;}}"), SYNTAX);
 
-        ASSERT_THROW(checkCode("void f() {switch (n) { case;: z(); break;}}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {switch (n) { case;: z(); break;}}"), SYNTAX);
 
-        ASSERT_THROW(checkCode("void f() {switch (n) { case {}: z(); break;}}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {switch (n) { case {}: z(); break;}}"), SYNTAX);
 
-        ASSERT_THROW(checkCode("void f() {switch (n) { case 0?{1}:{2} : z(); break;}}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {switch (n) { case 0?{1}:{2} : z(); break;}}"), SYNTAX);
 
-        ASSERT_THROW(checkCode("void f() {switch (n) { case 0?1;:{2} : z(); break;}}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {switch (n) { case 0?1;:{2} : z(); break;}}"), SYNTAX);
 
-        ASSERT_THROW(checkCode("void f() {switch (n) { case 0?(1?{3:4}):2 : z(); break;}}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {switch (n) { case 0?(1?{3:4}):2 : z(); break;}}"), AST);
 
         //ticket #4234
-        ASSERT_THROW(checkCode("( ) { switch break ; { switch ( x ) { case } y break ; : } }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("( ) { switch break ; { switch ( x ) { case } y break ; : } }"), SYNTAX);
 
         //ticket #4267
-        ASSERT_THROW(checkCode("f ( ) { switch break; { switch ( x ) { case } case break; -6: ( ) ; } }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("f ( ) { switch break; { switch ( x ) { case } case break; -6: ( ) ; } }"), SYNTAX);
 
         // Missing semicolon
-        ASSERT_THROW(checkCode("void foo () { switch(0) case 0 : default : }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void foo () { switch(0) case 0 : default : }"), SYNTAX);
     }
 
     void garbageCode1() {
-        checkCode("struct x foo_t; foo_t typedef y;");
+        (void)checkCode("struct x foo_t; foo_t typedef y;");
     }
 
     void garbageCode2() { //#4300 (segmentation fault)
@@ -441,21 +453,21 @@ class TestGarbage : public TestFixture {
     }
 
     void garbageCode4() { // #4887
-        ASSERT_THROW(checkCode("void f ( ) { = a ; if ( 1 ) if = ( 0 ) ; }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f ( ) { = a ; if ( 1 ) if = ( 0 ) ; }"), SYNTAX);
     }
 
-    void garbageCode5() { // #5168
-        checkCode("( asm : ; void : );");
+    void garbageCode5() { // #5168 (segmentation fault)
+        ASSERT_THROW_INTERNAL(checkCode("( asm : ; void : );"), SYNTAX);
     }
 
     void garbageCode6() { // #5214
-        ASSERT_THROW(checkCode("int b = ( 0 ? ? ) 1 : 0 ;"), InternalError);
-        ASSERT_THROW(checkCode("int a = int b = ( 0 ? ? ) 1 : 0 ;"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("int b = ( 0 ? ? ) 1 : 0 ;"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("int a = int b = ( 0 ? ? ) 1 : 0 ;"), SYNTAX);
     }
 
     void garbageCode7() {
-        ASSERT_THROW(checkCode("1 (int j) { return return (c) * sizeof } y[1];"), InternalError);
-        ASSERT_THROW(checkCode("foo(Args&&...) fn void = { } auto template<typename... bar(Args&&...)"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("1 (int j) { return return (c) * sizeof } y[1];"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("foo(Args&&...) fn void = { } auto template<typename... bar(Args&&...)"), SYNTAX);
     }
 
     void garbageCode8() { // #5604
@@ -463,7 +475,7 @@ class TestGarbage : public TestFixture {
         TODO_ASSERT_THROW(checkCode("int ScopedEnum{ template<typename T> { { e = T::error }; };\n"
                                     "ScopedEnum1<int> se1; { enum class E : T { e = 0 = e ScopedEnum2<void*> struct UnscopedEnum3 { T{ e = 4 }; };\n"
                                     "arr[(int) E::e]; }; UnscopedEnum3<int> e2 = f()\n"
-                                    "{ { e = e1; T::error } int test1 ue2; g() { enum class E { e = T::error }; return E::e; } int test2 = } \n"
+                                    "{ { e = e1; T::error } int test1 ue2; g() { enum class E { e = T::error }; return E::e; } int test2 = }\n"
                                     "namespace UnscopedEnum { template<typename T> struct UnscopedEnum1 { E{ e = T::error }; }; UnscopedEnum1<int> { enum E : { e = 0 }; };\n"
                                     "UnscopedEnum2<void*> ue3; template<typename T> struct UnscopedEnum3 { enum { }; }; int arr[E::e]; };\n"
                                     "UnscopedEnum3<int> namespace template<typename T> int f() { enum E { e }; T::error }; return (int) E(); } int test1 int g() { enum E { e = E };\n"
@@ -475,37 +487,35 @@ class TestGarbage : public TestFixture {
     }
 
     void garbageCode10() { // #6127
-        checkCode("for( rl=reslist; rl!=NULL; rl=rl->next )");
+        ASSERT_THROW_INTERNAL(checkCode("for( rl=reslist; rl!=NULL; rl=rl->next )"), SYNTAX);
     }
 
     void garbageCode12() { // do not crash
-        checkCode("{ g; S (void) { struct } { } int &g; }");
-    }
-
-    void garbageCode13() {
-        checkCode("struct C {} {} x");
+        (void)checkCode("{ g; S (void) { struct } { } int &g; }");
+        ignore_errout(); // we do not care about the output
     }
 
-    void garbageCode14() {
-        checkCode("static f() { int i; int source[1] = { 1 }; for (i = 0; i < 4; i++) (u, if (y u.x e)) }"); // Garbage code
+    void garbageCode13() { // Ticket #2607 - crash
+        (void)checkCode("struct C {} {} x");
     }
 
     void garbageCode15() { // Ticket #5203
-        ASSERT_THROW(checkCode("int f ( int* r ) { {  int s[2] ; f ( s ) ; if ( ) } }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("int f ( int* r ) { {  int s[2] ; f ( s ) ; if ( ) } }"), SYNTAX);
     }
 
-    void garbageCode16() {
-        checkCode("{ } A() { delete }"); // #6080
+    void garbageCode16() { // #6080 (segmentation fault)
+        (void)checkCode("{ } A() { delete }"); // #6080
+        ignore_errout(); // we do not care about the output
     }
 
     void garbageCode17() {
-        ASSERT_THROW(checkCode("void h(int l) {\n"
-                               "    while\n" // Don't crash (#3870)
-                               "}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void h(int l) {\n"
+                                        "    while\n" // Don't crash (#3870)
+                                        "}"), SYNTAX);
     }
 
     void garbageCode18() {
-        ASSERT_THROW(checkCode("switch(){case}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("switch(){case}"), SYNTAX);
     }
 
     void garbageCode20() {
@@ -515,90 +525,95 @@ class TestGarbage : public TestFixture {
 
     void garbageCode21() {
         // Ticket #3486 - Don't crash garbage code
-        ASSERT_THROW(checkCode("void f()\n"
-                               "{\n"
-                               "  (\n"
-                               "    x;\n"
-                               "    int a, a2, a2*x; if () ;\n"
-                               "  )\n"
-                               "}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f()\n"
+                                        "{\n"
+                                        "  (\n"
+                                        "    x;\n"
+                                        "    int a, a2, a2*x; if () ;\n"
+                                        "  )\n"
+                                        "}"), SYNTAX);
     }
 
     void garbageCode22() {
         // Ticket #3480 - Don't crash garbage code
-        ASSERT_THROW(checkCode("int f()\n"
-                               "{\n"
-                               "    return if\n"
-                               "}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("int f()\n"
+                                        "{\n"
+                                        "    return if\n"
+                                        "}"), SYNTAX);
     }
 
     void garbageCode23() {
         //garbage code : don't crash (#3481)
-        checkCode("{\n"
-                  "    if (1) = x\n"
-                  "    else abort s[2]\n"
-                  "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_THROW_INTERNAL_EQUALS(checkCode("{\n"
+                                               "    if (1) = x\n"
+                                               "    else abort s[2]\n"
+                                               "}"),
+                                     SYNTAX,
+                                     "syntax error");
     }
 
     void garbageCode24() {
         // don't crash (example from #6361)
-        ASSERT_THROW(checkCode("float buffer[64];\n"
-                               "main (void)\n"
-                               "{\n"
-                               "  char *cptr;\n"
-                               "  cptr = (char *)buffer;\n"
-                               "  cptr += (-(long int) buffer & (16 * sizeof (float) - 1));\n"
-                               "}\n"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("float buffer[64];\n"
+                                        "main (void)\n"
+                                        "{\n"
+                                        "  char *cptr;\n"
+                                        "  cptr = (char *)buffer;\n"
+                                        "  cptr += (-(long int) buffer & (16 * sizeof (float) - 1));\n"
+                                        "}\n"), SYNTAX);
+        ignore_errout(); // we do not care about the output
     }
 
     void garbageCode25() {
         // Ticket #2386 - Segmentation fault upon strange syntax
-        ASSERT_THROW(checkCode("void f() {\n"
-                               "    switch ( x ) {\n"
-                               "        case struct Tree : break;\n"
-                               "    }\n"
-                               "}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {\n"
+                                        "    switch ( x ) {\n"
+                                        "        case struct Tree : break;\n"
+                                        "    }\n"
+                                        "}"), SYNTAX);
+        ignore_errout(); // we do not care about the output
     }
 
     void garbageCode26() {
         // See tickets #2518 #2555 #4171
-        ASSERT_THROW(checkCode("void f() {\n"
-                               "    switch MAKEWORD(1)\n"
-                               "    {\n"
-                               "    case 0:\n"
-                               "        return;\n"
-                               "    }\n"
-                               "}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {\n"
+                                        "    switch MAKEWORD(1)\n"
+                                        "    {\n"
+                                        "    case 0:\n"
+                                        "        return;\n"
+                                        "    }\n"
+                                        "}"), SYNTAX);
     }
 
     void garbageCode27() {
-        ASSERT_THROW(checkCode("int f() {\n"
-                               "    return if\n"
-                               "}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("int f() {\n"
+                                        "    return if\n"
+                                        "}"), SYNTAX);
     }
 
-    void garbageCode28() {
+    void garbageCode28() { // #5702 (segmentation fault)
         // 5702
-        checkCode("struct R1 {\n"
-                  "  int a;\n"
-                  "  R1 () : a { }\n"
-                  "};\n");
+        (void)checkCode("struct R1 {\n"
+                        "  int a;\n"
+                        "  R1 () : a { }\n"
+                        "};");
+        ignore_errout(); // we do not care about the output
     }
 
     void garbageCode30() {
         // simply survive - a syntax error would be even better (#5867)
-        checkCode("void f(int x) {\n"
-                  " x = 42\n"
-                  "}");
+        (void)checkCode("void f(int x) {\n"
+                        " x = 42\n"
+                        "}");
+        ignore_errout(); // we do not care about the output
     }
 
     void garbageCode31() {
-        ASSERT_THROW(checkCode("typedef struct{}x[([],)]typedef e y;(y,x 0){}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("typedef struct{}x[([],)]typedef e y;(y,x 0){}"), SYNTAX);
     }
 
-    void garbageCode33() { // #6613
-        checkCode("main(()B{});");
+    void garbageCode33() { // #6613 (segmentation fault)
+        (void)checkCode("main(()B{});");
     }
 
     // Bug #6626 crash: Token::astOperand2() const ( do while )
@@ -607,281 +622,286 @@ class TestGarbage : public TestFixture {
                             " do\n"
                             " while (0);\n"
                             "}";
-        ASSERT_THROW(checkCode(code), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode(code), SYNTAX);
     }
 
     void garbageCode35() {
         // ticket #2604 segmentation fault
-        ASSERT_THROW(checkCode("sizeof <= A"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("sizeof <= A"), AST);
     }
 
     void garbageCode36() { // #6334
-        ASSERT_THROW(checkCode("{ } < class template < > , { = } ; class... >\n"
-                               "struct Y { }\n"
-                               "class Types { }\n"
-                               "( X < int > \"uses template\" ) ( < ( ) \"uses ;"
-                               "( int int ::primary \"uses template\" ) int double \"uses )"
-                               "::primary , \"uses template\" ;\n"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ } < class template < > , { = } ; class... >\n"
+                                        "struct Y { }\n"
+                                        "class Types { }\n"
+                                        "( X < int > \"uses template\" ) ( < ( ) \"uses ;"
+                                        "( int int ::primary \"uses template\" ) int double \"uses )"
+                                        "::primary , \"uses template\" ;\n"), SYNTAX);
     }
 
     void garbageCode37() {
         // #5166 segmentation fault (invalid code) in lib/checkother.cpp:329 ( void * f { } void b ( ) { * f } )
-        checkCode("void * f { } void b ( ) { * f }");
+        (void)checkCode("void * f { } void b ( ) { * f }");
+        ignore_errout(); // we do not care about the output
     }
 
-    void garbageCode38() { // Ticket #6666
-        checkCode("{ f2 { } } void f3 () { delete[] } { }");
+    void garbageCode38() { // Ticket #6666 (segmentation fault)
+        (void)checkCode("{ f2 { } } void f3 () { delete[] } { }");
+        ignore_errout(); // we do not care about the output
     }
 
-    void garbageCode40() { // #6620
-        checkCode("{ ( ) () { virtual } ; { } E } A { : { } ( ) } * const ( ) const { }");
+    void garbageCode40() { // #6620 (segmentation fault)
+        (void)checkCode("{ ( ) () { virtual } ; { } E } A { : { } ( ) } * const ( ) const { }");
         // test doesn't seem to work on any platform: ASSERT_THROW(checkCode("{ ( ) () { virtual } ; { } E } A { : { } ( ) } * const ( ) const { }", "test.c"), InternalError);
     }
 
-    void garbageCode41() { // #6685
-        checkCode(" { } { return } *malloc(__SIZE_TYPE__ size); *memcpy(void n); static * const () { memcpy (*slot, 3); } { (); } { }");
+    void garbageCode41() { // #6685 (segmentation fault)
+        (void)checkCode(" { } { return } *malloc(__SIZE_TYPE__ size); *memcpy(void n); static * const () { memcpy (*slot, 3); } { (); } { }");
     }
 
-    void garbageCode42() { // #5760
-        checkCode("{  } * const ( ) { }");
+    void garbageCode42() { // #5760 (segmentation fault)
+        (void)checkCode("{  } * const ( ) { }");
     }
 
-    void garbageCode43() { // #6703
-        ASSERT_THROW(checkCode("int { }; struct A<void> a = { }"), InternalError);
+    void garbageCode43() { // #6703 (segmentation fault)
+        (void)checkCode("int { }; struct A<void> a = { }");
     }
 
     void garbageCode44() { // #6704
-        ASSERT_THROW(checkCode("{ { }; }; { class A : }; public typedef b;"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ { }; }; { class A : }; public typedef b;"), SYNTAX);
     }
 
     void garbageCode45() { // #6608
-        ASSERT_THROW(checkCode("struct true template < > { = } > struct Types \"s\" ; static_assert < int > ;"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("struct true template < > { = } > struct Types \"s\" ; static_assert < int > ;"), SYNTAX);
     }
 
-    void garbageCode46() { // #6705
-        checkCode(" { bar(char *x); void foo (int ...) { struct } va_list ap; va_start(ap, size); va_arg(ap, (d)); }");
+    void garbageCode46() { // #6705 (segmentation fault)
+        (void)checkCode(" { bar(char *x); void foo (int ...) { struct } va_list ap; va_start(ap, size); va_arg(ap, (d)); }");
+        ignore_errout(); // we do not care about the output
     }
 
-    void garbageCode47() { // #6706
-        checkCode(" { { }; }; * new private: B: B;");
+    void garbageCode47() { // #6706 (segmentation fault)
+        (void)checkCode(" { { }; }; * new private: B: B;");
     }
 
-    void garbageCode48() { // #6712
-        checkCode(" { d\" ) d ...\" } int main ( ) { ( ) catch ( A a ) { { } catch ( ) \"\" } }");
+    void garbageCode48() { // #6712 (segmentation fault)
+        ASSERT_THROW_INTERNAL(checkCode(" { d\" ) d ...\" } int main ( ) { ( ) catch ( A a ) { { } catch ( ) \"\" } }"), SYNTAX);
     }
 
     void garbageCode49() { // #6715
-        ASSERT_THROW(checkCode(" ( ( ) ) { } ( { ( __builtin_va_arg_pack ( ) ) ; } ) { ( int { ( ) ( ( ) ) } ( ) { } ( ) ) += ( ) }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode(" ( ( ) ) { } ( { ( __builtin_va_arg_pack ( ) ) ; } ) { ( int { ( ) ( ( ) ) } ( ) { } ( ) ) += ( ) }"), AST);
     }
 
     void garbageCode51() { // #6719
-        ASSERT_THROW(checkCode(" (const \"C\" ...); struct base { int f2; base (int arg1, int arg2); }; global_base(0x55, 0xff); { ((global_base.f1 0x55) (global_base.f2 0xff)) { } } base::base(int arg1, int arg2) { f2 = }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode(" (const \"C\" ...); struct base { int f2; base (int arg1, int arg2); }; global_base(0x55, 0xff); { ((global_base.f1 0x55) (global_base.f2 0xff)) { } } base::base(int arg1, int arg2) { f2 = }"), SYNTAX);
     }
 
     void garbageCode53() { // #6721
-        ASSERT_THROW(checkCode("{ { } }; void foo (struct int i) { x->b[i] = = }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ { } }; void foo (struct int i) { x->b[i] = = }"), SYNTAX);
     }
 
     void garbageCode54() { // #6722
-        ASSERT_THROW(checkCode("{ typedef long ((pf) p) (); }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ typedef long ((pf) p) (); }"), SYNTAX);
     }
 
     void garbageCode55() { // #6724
-        checkCode("() __attribute__((constructor)); { } { }");
+        ASSERT_THROW_INTERNAL(checkCode("() __attribute__((constructor)); { } { }"), SYNTAX);
     }
 
     void garbageCode56() { // #6713
-        ASSERT_THROW(checkCode("void foo() { int a = 0; int b = ???; }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void foo() { int a = 0; int b = ???; }"), AST);
     }
 
     void garbageCode57() { // #6731
-        ASSERT_THROW(checkCode("{ } if () try { } catch (...) B::~B { }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ } if () try { } catch (...) B::~B { }"), SYNTAX);
     }
 
     void garbageCode58() { // #6732, #6762
-        ASSERT_THROW(checkCode("{ }> {= ~A()^{} }P { }"), InternalError);
-        ASSERT_THROW(checkCode("{= ~A()^{} }P { } { }> is"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ }> {= ~A()^{} }P { }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("{= ~A()^{} }P { } { }> is"), SYNTAX);
     }
 
     void garbageCode59() { // #6735
-        ASSERT_THROW(checkCode("{ { } }; char font8x8[256][8]"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ { } }; char font8x8[256][8]"), SYNTAX);
     }
 
     void garbageCode60() { // #6736
-        ASSERT_THROW(checkCode("{ } { } typedef int int_array[]; int_array &right ="), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ } { } typedef int int_array[]; int_array &right ="), SYNTAX);
     }
 
     void garbageCode61() { // #6737
-        ASSERT_THROW(checkCode("{ (const U&) }; { }; { }; struct U : virtual public"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ (const U&) }; { }; { }; struct U : virtual public"), SYNTAX);
     }
 
     void garbageCode63() { // #6739
-        ASSERT_THROW(checkCode("{ } { } typedef int u_array[]; typedef u_array &u_array_ref; (u_array_ref arg) { } u_array_ref u_array_ref_gbl_obj0"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ } { } typedef int u_array[]; typedef u_array &u_array_ref; (u_array_ref arg) { } u_array_ref u_array_ref_gbl_obj0"), SYNTAX);
     }
 
     void garbageCode64() { // #6740
-        ASSERT_THROW(checkCode("{ } foo(void (*bar)(void))"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ } foo(void (*bar)(void))"), SYNTAX);
     }
 
-    void garbageCode65() { // #6741
-        ASSERT_THROW(checkCode("{ } { } typedef int u_array[]; typedef u_array &u_array_ref; (u_array_ref arg) { } u_array_ref"), InternalError);
+    void garbageCode65() { // #6741 (segmentation fault)
+        // TODO write some syntax error
+        (void)checkCode("{ } { } typedef int u_array[]; typedef u_array &u_array_ref; (u_array_ref arg) { } u_array_ref");
     }
 
     void garbageCode66() { // #6742
-        ASSERT_THROW(checkCode("{ { } }; { { } }; { }; class bar : public virtual"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ { } }; { { } }; { }; class bar : public virtual"), SYNTAX);
     }
 
-    void garbageCode68() { // #6745
-        checkCode("(int a[3]); typedef void (*fp) (void); fp");
+    void garbageCode68() { // #6745 (segmentation fault)
+        (void)checkCode("(int a[3]); typedef void (*fp) (void); fp");
     }
 
     void garbageCode69() { // #6746
-        ASSERT_THROW(checkCode("{ (make_mess, aux); } typedef void F(void); aux(void (*x)()) { } (void (*y)()) { } F*"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ (make_mess, aux); } typedef void F(void); aux(void (*x)()) { } (void (*y)()) { } F*"), SYNTAX);
     }
 
     void garbageCode70() { // #6747
-        ASSERT_THROW(checkCode("{ } __attribute__((constructor)) void"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ } __attribute__((constructor)) void"), SYNTAX);
     }
 
     void garbageCode71() { // #6748
-        ASSERT_THROW(checkCode("( ) { } typedef void noattr_t ( ) ; noattr_t __attribute__ ( )"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("( ) { } typedef void noattr_t ( ) ; noattr_t __attribute__ ( )"), SYNTAX);
     }
 
     void garbageCode72() { // #6749
-        ASSERT_THROW(checkCode("{ } { } typedef void voidfn(void); <voidfn&"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ } { } typedef void voidfn(void); <voidfn&"), SYNTAX);
     }
 
     void garbageCode73() { // #6750
-        ASSERT_THROW(checkCode("typedef int IRT[2]; IRT&"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("typedef int IRT[2]; IRT&"), SYNTAX);
     }
 
     void garbageCode74() { // #6751
-        ASSERT_THROW(checkCode("_lenraw(const char* digits) { } typedef decltype(sizeof(0)) { } operator"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("_lenraw(const char* digits) { } typedef decltype(sizeof(0)) { } operator"), SYNTAX);
     }
 
     void garbageCode76() { // #6754
-        ASSERT_THROW(checkCode(" ( ) ( ) { ( ) [ ] } TEST ( ) { ( _broadcast_f32x4 ) ( ) ( ) ( ) ( ) if ( ) ( ) ; } E mask = ( ) [ ] ( ) res1.x ="), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode(" ( ) ( ) { ( ) [ ] } TEST ( ) { ( _broadcast_f32x4 ) ( ) ( ) ( ) ( ) if ( ) ( ) ; } E mask = ( ) [ ] ( ) res1.x ="), SYNTAX);
     }
 
     void garbageCode77() { // #6755
-        ASSERT_THROW(checkCode("void foo (int **p) { { { };>= } } unsigned *d = (b b--) --*d"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void foo (int **p) { { { };>= } } unsigned *d = (b b--) --*d"), SYNTAX);
     }
 
     void garbageCode78() { // #6756
-        ASSERT_THROW(checkCode("( ) { [ ] } ( ) { } const_array_of_int ( ) { } typedef int A [ ] [ ] ; A a = { { } { } }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("( ) { [ ] } ( ) { } const_array_of_int ( ) { } typedef int A [ ] [ ] ; A a = { { } { } }"), SYNTAX);
+        ignore_errout(); // we do not care about the output
     }
 
     void garbageCode79() { // #6757
-        ASSERT_THROW(checkCode("{ } { } typedef void ( func_type ) ( ) ; func_type & ( )"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ } { } typedef void ( func_type ) ( ) ; func_type & ( )"), SYNTAX);
     }
 
     void garbageCode80() { // #6759
-        ASSERT_THROW(checkCode("( ) { ; ( ) ; ( * ) [ ] ; [ ] = ( ( ) ( ) h ) ! ( ( ) ) } { ; } { } head heads [ ] = ; = & heads [ 2 ]"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("( ) { ; ( ) ; ( * ) [ ] ; [ ] = ( ( ) ( ) h ) ! ( ( ) ) } { ; } { } head heads [ ] = ; = & heads [ 2 ]"), SYNTAX);
     }
 
     void garbageCode81() { // #6760
-        ASSERT_THROW(checkCode("{ } [ ] { ( ) } { } typedef void ( *fptr1 ) ( ) const"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ } [ ] { ( ) } { } typedef void ( *fptr1 ) ( ) const"), SYNTAX);
     }
 
     void garbageCode82() { // #6761
-        ASSERT_THROW(checkCode("p(\"Hello \" 14) _yn(const size_t) typedef bool pfunk (*pfunk)(const size_t)"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("p(\"Hello \" 14) _yn(const size_t) typedef bool pfunk (*pfunk)(const size_t)"), SYNTAX);
     }
 
     void garbageCode83() { // #6771
-        ASSERT_THROW(checkCode("namespace A { class } class A { friend C ; } { } ;"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("namespace A { class } class A { friend C ; } { } ;"), SYNTAX);
     }
 
     void garbageCode84() { // #6780
-        ASSERT_THROW(checkCode("int main ( [ ] ) { " " [ ] ; int i = 0 ; do { } ; } ( [ ] ) { }"), InternalError); // do not crash
+        ASSERT_THROW_INTERNAL(checkCode("int main ( [ ] ) { " " [ ] ; int i = 0 ; do { } ; } ( [ ] ) { }"), SYNTAX); // do not crash
     }
 
-    void garbageCode85() { // #6784
-        ASSERT_THROW(checkCode("{ } { } typedef void ( *VoidFunc() ) ( ) ; VoidFunc"), InternalError); // do not crash
+    void garbageCode85() { // #6784 (segmentation fault)
+        (void)checkCode("{ } { } typedef void ( *VoidFunc() ) ( ) ; VoidFunc"); // do not crash
     }
 
     void garbageCode86() { // #6785
-        ASSERT_THROW(checkCode("{ } typedef char ( *( X ) ( void) , char ) ;"), InternalError); // do not crash
+        ASSERT_THROW_INTERNAL(checkCode("{ } typedef char ( *( X ) ( void) , char ) ;"), SYNTAX); // do not crash
     }
 
     void garbageCode87() { // #6788
-        ASSERT_THROW(checkCode("((X (128))) (int a) { v[ = {} (x 42) a] += }"), InternalError); // do not crash
+        ASSERT_THROW_INTERNAL(checkCode("((X (128))) (int a) { v[ = {} (x 42) a] += }"), SYNTAX); // do not crash
     }
 
     void garbageCode88() { // #6786
-        ASSERT_THROW(checkCode("( ) { ( 0 ) { ( ) } } g ( ) { i( ( false ?) ( ) : 1 ) ; } ;"), InternalError); // do not crash
+        ASSERT_THROW_INTERNAL(checkCode("( ) { ( 0 ) { ( ) } } g ( ) { i( ( false ?) ( ) : 1 ) ; } ;"), SYNTAX); // do not crash
     }
 
     void garbageCode90() { // #6790
-        ASSERT_THROW(checkCode("{ } { } typedef int u_array [[ ] ; typedef u_array & u_array_ref] ( ) { } u_array_ref_gbl_obj0"), InternalError); // do not crash
+        ASSERT_THROW_INTERNAL(checkCode("{ } { } typedef int u_array [[ ] ; typedef u_array & u_array_ref] ( ) { } u_array_ref_gbl_obj0"), SYNTAX); // do not crash
     }
 
     void garbageCode91() { // #6791
-        ASSERT_THROW(checkCode("typedef __attribute__((vector_size (16))) { return[ (v2df){ } ;] }"), InternalError); // throw syntax error
+        ASSERT_THROW_INTERNAL(checkCode("typedef __attribute__((vector_size (16))) { return[ (v2df){ } ;] }"), SYNTAX); // throw syntax error
     }
 
     void garbageCode92() { // #6792
-        ASSERT_THROW(checkCode("template < typename _Tp ( ( ) ; _Tp ) , decltype > { } { ( ) ( ) }"), InternalError); // do not crash
+        ASSERT_THROW_INTERNAL(checkCode("template < typename _Tp ( ( ) ; _Tp ) , decltype > { } { ( ) ( ) }"), SYNTAX); // do not crash
     }
 
     void garbageCode94() { // #6803
         //checkCode("typedef long __m256i __attribute__ ( ( ( ) ) )[ ; ( ) { } typedef __m256i __attribute__ ( ( ( ) ) ) < ] ( ) { ; }");
-        ASSERT_THROW(checkCode("typedef long __m256i __attribute__ ( ( ( ) ) )[ ; ( ) { } typedef __m256i __attribute__ ( ( ( ) ) ) < ] ( ) { ; }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("typedef long __m256i __attribute__ ( ( ( ) ) )[ ; ( ) { } typedef __m256i __attribute__ ( ( ( ) ) ) < ] ( ) { ; }"), SYNTAX);
     }
 
     void garbageCode95() { // #6804
-        ASSERT_THROW(checkCode("{ } x x ; { } h h [ ] ( ) ( ) { struct x ( x ) ; int __attribute__ ( ) f ( ) { h - > first = & x ; struct x * n = h - > first ; ( ) n > } }"), InternalError); // do not crash
+        ASSERT_THROW_INTERNAL(checkCode("{ } x x ; { } h h [ ] ( ) ( ) { struct x ( x ) ; int __attribute__ ( ) f ( ) { h - > first = & x ; struct x * n = h - > first ; ( ) n > } }"), SYNTAX); // do not crash
     }
 
     void garbageCode96() { // #6807
-        ASSERT_THROW(checkCode("typedef J J[ ; typedef ( ) ( ) { ; } typedef J J ;] ( ) ( J cx ) { n } ;"), InternalError); // throw syntax error
+        ASSERT_THROW_INTERNAL(checkCode("typedef J J[ ; typedef ( ) ( ) { ; } typedef J J ;] ( ) ( J cx ) { n } ;"), SYNTAX); // throw syntax error
     }
 
     void garbageCode97() { // #6808
-        ASSERT_THROW(checkCode("namespace A {> } class A{ { }} class A : T< ;"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("namespace A {> } class A{ { }} class A : T< ;"), SYNTAX);
     }
 
     void garbageCode98() { // #6838
-        ASSERT_THROW(checkCode("for (cocon To::ta@Taaaaaforconst oken aaaaaaaaaaaa5Dl()\n"
-                               "const unsigned in;\n"
-                               "fon *tok = f);.s(Token i = d-)L;"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("for (cocon To::ta@Taaaaaforconst oken aaaaaaaaaaaa5Dl()\n"
+                                        "const unsigned in;\n"
+                                        "fon *tok = f);.s(Token i = d-)L;"), SYNTAX);
     }
 
     void garbageCode99() { // #6726
-        ASSERT_THROW(checkCode("{ xs :: i(:) ! ! x/5 ! !\n"
-                               "i, :: a :: b integer, } foo2(x) :: j(:) \n"
-                               "b type(*), d(:), a x :: end d(..), foo end\n"
-                               "foo4 b d(..), a a x type(*), b foo2 b"), InternalError);
+        ASSERT_THROW_INTERNAL_EQUALS(checkCode("{ xs :: i(:) ! ! x/5 ! !\n"
+                                               "i, :: a :: b integer, } foo2(x) :: j(:)\n"
+                                               "b type(*), d(:), a x :: end d(..), foo end\n"
+                                               "foo4 b d(..), a a x type(*), b foo2 b"), SYNTAX, "syntax error");
     }
 
     void garbageCode100() { // #6840
-        ASSERT_THROW(checkCode("( ) { ( i< ) } int foo ( ) { int i ; ( for ( i => 1 ) ; ) }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("( ) { ( i< ) } int foo ( ) { int i ; ( for ( i => 1 ) ; ) }"), SYNTAX);
     }
 
     void garbageCode101() { // #6835
         // Reported case
-        ASSERT_THROW(checkCode("template < class , =( , int) X = 1 > struct A { } ( ) { = } [ { } ] ( ) { A < void > 0 }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("template < class , =( , int) X = 1 > struct A { } ( ) { = } [ { } ] ( ) { A < void > 0 }"), SYNTAX);
         // Reduced case
-        ASSERT_THROW(checkCode("template < class =( , ) X = 1> struct A {}; A<void> a;"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("template < class =( , ) X = 1> struct A {}; A<void> a;"), SYNTAX);
     }
 
-    void garbageCode102() { // #6846
-        checkCode("struct Object { ( ) ; Object & operator= ( Object ) { ( ) { } if ( this != & b ) } }");
+    void garbageCode102() { // #6846 (segmentation fault)
+        ASSERT_THROW_INTERNAL(checkCode("struct Object { ( ) ; Object & operator= ( Object ) { ( ) { } if ( this != & b ) } }"), SYNTAX);
     }
 
     void garbageCode103() { // #6824
-        ASSERT_THROW(checkCode("a f(r) int * r; { { int s[2]; [f(s); if () ]  } }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("a f(r) int * r; { { int s[2]; [f(s); if () ]  } }"), SYNTAX);
     }
 
     void garbageCode104() { // #6847
-        ASSERT_THROW(checkCode("template < Types > struct S {> ( S < ) S >} { ( ) { } } ( ) { return S < void > ( ) } { ( )> >} { ( ) { } } ( ) { ( ) }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("template < Types > struct S {> ( S < ) S >} { ( ) { } } ( ) { return S < void > ( ) } { ( )> >} { ( ) { } } ( ) { ( ) }"), SYNTAX);
     }
 
     void garbageCode105() { // #6859
-        ASSERT_THROW(checkCode("void foo (int i) { int a , for (a 1; a( < 4; a++) if (a) (b b++) (b);) n++; }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void foo (int i) { int a , for (a 1; a( < 4; a++) if (a) (b b++) (b);) n++; }"), SYNTAX);
     }
 
     void garbageCode106() { // #6880
-        ASSERT_THROW(checkCode("[ ] typedef typedef b_array b_array_ref [ ; ] ( ) b_array_ref b_array_ref_gbl_obj0 { ; { b_array_ref b_array_ref_gbl_obj0 } }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("[ ] typedef typedef b_array b_array_ref [ ; ] ( ) b_array_ref b_array_ref_gbl_obj0 { ; { b_array_ref b_array_ref_gbl_obj0 } }"), SYNTAX);
     }
 
     void garbageCode107() { // #6881
@@ -889,15 +909,15 @@ class TestGarbage : public TestFixture {
     }
 
     void garbageCode108() { //  #6895 "segmentation fault (invalid code) in CheckCondition::isOppositeCond"
-        ASSERT_THROW(checkCode("A( ) { } bool f( ) { ( ) F; ( ) { ( == ) if ( !=< || ( !A( ) && r[2] ) ) ( !A( ) ) ( ) } }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("A( ) { } bool f( ) { ( ) F; ( ) { ( == ) if ( !=< || ( !A( ) && r[2] ) ) ( !A( ) ) ( ) } }"), SYNTAX);
     }
 
     void garbageCode109() { //  #6900 "segmentation fault (invalid code) in CheckStl::runSimplifiedChecks"
-        checkCode("( *const<> (( ) ) { } ( *const ( ) ( ) ) { } ( * const<> ( size_t )) ) { } ( * const ( ) ( ) ) { }");
+        (void)checkCode("( *const<> (( ) ) { } ( *const ( ) ( ) ) { } ( * const<> ( size_t )) ) { } ( * const ( ) ( ) ) { }");
     }
 
     void garbageCode110() { //  #6902 "segmentation fault (invalid code) in CheckStl::string_c_str"
-        ASSERT_THROW(checkCode("( *const<> ( size_t ) ; foo ) { } * ( *const ( size_t ) ( ) ;> foo )< { }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("( *const<> ( size_t ) ; foo ) { } * ( *const ( size_t ) ( ) ;> foo )< { }"), SYNTAX);
     }
 
     void garbageCode111() { //  #6907
@@ -909,18 +929,18 @@ class TestGarbage : public TestFixture {
     }
 
     void garbageCode114() { // #2118
-        checkCode("Q_GLOBAL_STATIC_WITH_INITIALIZER(Qt4NodeStaticData, qt4NodeStaticData, {\n"
-                  "    for (unsigned i = 0 ; i < count; i++) {\n"
-                  "    }\n"
-                  "});");
+        ASSERT_NO_THROW(checkCode("Q_GLOBAL_STATIC_WITH_INITIALIZER(Qt4NodeStaticData, qt4NodeStaticData, {\n"
+                                  "    for (unsigned i = 0 ; i < count; i++) {\n"
+                                  "    }\n"
+                                  "});"));
     }
 
     void garbageCode115() { // #5506
-        ASSERT_THROW(checkCode("A template < int { int = -1 ; } template < int N > struct B { int [ A < N > :: zero ] ;  } ; B < 0 > b ;"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("A template < int { int = -1 ; } template < int N > struct B { int [ A < N > :: zero ] ;  } ; B < 0 > b ;"), UNKNOWN_MACRO);
     }
 
     void garbageCode116() { // #5356
-        ASSERT_THROW(checkCode("struct template<int { = }; > struct B { }; B < 0 > b;"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("struct template<int { = }; > struct B { }; B < 0 > b;"), SYNTAX);
     }
 
     void garbageCode117() { // #6121
@@ -929,68 +949,72 @@ class TestGarbage : public TestFixture {
     }
 
     void garbageCode118() { // #5600 - missing include causes invalid enum
-        ASSERT_THROW(checkCode("enum {\n"
-                               "    NUM_OPCODES = \n"
-                               // #include "definition"
-                               "};\n"
-                               "struct bytecode {};\n"
-                               "jv jq_next() { opcode = ((opcode) +NUM_OPCODES);\n"
-                               "}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("enum {\n"
+                                        "    NUM_OPCODES =\n"
+                                        // #include "definition"
+                                        "};\n"
+                                        "struct bytecode {};\n"
+                                        "jv jq_next() { opcode = ((opcode) +NUM_OPCODES);\n"
+                                        "}"), SYNTAX);
     }
 
-    void garbageCode119() { // #5598
-        checkCode("{ { void foo() { struct }; template <typename> struct S { Used x; void bar() } auto f = [this] { }; } };");
+    void garbageCode119() { // #5598 (segmentation fault)
+        (void)checkCode("{ { void foo() { struct }; template <typename> struct S { Used x; void bar() } auto f = [this] { }; } };");
+        ignore_errout(); // we do not care about the output
     }
 
-    void garbageCode120() { // #4927
-        checkCode("int main() {\n"
-                  "   return 0\n"
-                  "}");
-        ASSERT_EQUALS("", errout.str());
+    void garbageCode120() { // #4927 (segmentation fault)
+        (void)checkCode("int main() {\n"
+                        "   return 0\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void garbageCode121() { // #2585
-        ASSERT_THROW(checkCode("abcdef?""?<"
-                               "123456?""?>"
-                               "+?""?="), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("abcdef?" "?<"
+                                        "123456?" "?>"
+                                        "+?" "?="), SYNTAX);
     }
 
-    void garbageCode122() { // #6303
-        checkCode("void foo() {\n"
-                  "char *a = malloc(10);\n"
-                  "a[0]\n"
-                  "}");
+    void garbageCode122() { // #6303 (segmentation fault)
+        (void)checkCode("void foo() {\n"
+                        "char *a = malloc(10);\n"
+                        "a[0]\n"
+                        "}");
+        ignore_errout(); // we do not care about the output
     }
 
     void garbageCode123() {
-        ASSERT_THROW(checkCode("namespace pr16989 {\n"
-                               "    class C {\n"
-                               "        C tpl_mem(T *) { return }\n"
-                               "    };\n"
-                               "}"), InternalError);
+        (void)checkCode("namespace pr16989 {\n"
+                        "    class C {\n"
+                        "        C tpl_mem(T *) { return }\n"
+                        "    };\n"
+                        "}");
+        ignore_errout(); // we do not care about the output
     }
 
     void garbageCode125() {
-        ASSERT_THROW(checkCode("{ T struct B : T valueA_AA ; } T : [ T > ( ) { B } template < T > struct A < > : ] { ( ) { return valueA_AC struct { : } } b A < int > AC ( ) a_aa.M ; ( ) ( ) }"), InternalError);
-        ASSERT_THROW(checkCode("template < Types > struct S :{ ( S < ) S >} { ( ) { } } ( ) { return S < void > ( ) }"),
-                     InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ T struct B : T valueA_AA ; } T : [ T > ( ) { B } template < T > struct A < > : ] { ( ) { return valueA_AC struct { : } } b A < int > AC ( ) a_aa.M ; ( ) ( ) }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("template < Types > struct S :{ ( S < ) S >} { ( ) { } } ( ) { return S < void > ( ) }"),
+                              SYNTAX);
     }
 
     void garbageCode126() {
-        ASSERT_THROW(checkCode("{ } float __ieee754_sinhf ( float x ) { float t , , do { gf_u ( jx ) { } ( 0 ) return ; ( ) { } t } ( 0x42b17180 ) { } }"),
-                     InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ } float __ieee754_sinhf ( float x ) { float t , , do { gf_u ( jx ) { } ( 0 ) return ; ( ) { } t } ( 0x42b17180 ) { } }"),
+                              SYNTAX);
     }
 
-    void garbageCode127() { // #6667
-        checkCode("extern \"C\" int printf(const char* fmt, ...);\n"
-                  "class A {\n"
-                  "public:\n"
-                  "  int Var;\n"
-                  "  A(int arg) { Var = arg; }\n"
-                  "  ~A() { printf(\"A d'tor\\n\"); }\n"
-                  "};\n"
-                  " const A& foo(const A& arg) { return arg; }\n"
-                  " foo(A(12)).Var\n");
+    void garbageCode127() { // #6667 (segmentation fault)
+        (void)checkCode("extern \"C\" int printf(const char* fmt, ...);\n"
+                        "class A {\n"
+                        "public:\n"
+                        "  int Var;\n"
+                        "  A(int arg) { Var = arg; }\n"
+                        "  ~A() { printf(\"A d'tor\\n\"); }\n"
+                        "};\n"
+                        " const A& foo(const A& arg) { return arg; }\n"
+                        " foo(A(12)).Var");
+        ignore_errout(); // we do not care about the output
     }
 
     void garbageCode128() {
@@ -999,8 +1023,8 @@ class TestGarbage : public TestFixture {
     }
 
     void garbageCode129() {
-        ASSERT_THROW(checkCode("operator - ( { } typedef typename x ; ( ) ) { ( { { ( ( ) ) } ( { } ) } ) }"),
-                     InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("operator - ( { } typedef typename x ; ( ) ) { ( { { ( ( ) ) } ( { } ) } ) }"),
+                              SYNTAX);
     }
 
     void garbageCode130() {
@@ -1009,33 +1033,33 @@ class TestGarbage : public TestFixture {
     }
 
     void garbageCode131() {
-        ASSERT_THROW(checkCode("( void ) { ( ) } ( ) / { ( ) }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("( void ) { ( ) } ( ) / { ( ) }"), SYNTAX);
         // actually the invalid code should trigger an syntax error...
     }
 
     void garbageCode132() { // #7022
-        checkCode("() () { } { () () ({}) i() } void i(void(*ptr) ()) { ptr(!) () }");
+        ASSERT_THROW_INTERNAL(checkCode("() () { } { () () ({}) i() } void i(void(*ptr) ()) { ptr(!) () }"), SYNTAX);
     }
 
     void garbageCode133() {
-        ASSERT_THROW(checkCode("void f() {{}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {{}"), SYNTAX);
 
-        ASSERT_THROW(checkCode("void f()) {}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f()) {}"), SYNTAX);
 
-        ASSERT_THROW(checkCode("void f()\n"
-                               "{\n"
-                               " foo(;\n"
-                               "}\n"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f()\n"
+                                        "{\n"
+                                        " foo(;\n"
+                                        "}\n"), SYNTAX);
 
-        ASSERT_THROW(checkCode("void f()\n"
-                               "{\n"
-                               " for(;;){ foo();\n"
-                               "}\n"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f()\n"
+                                        "{\n"
+                                        " for(;;){ foo();\n"
+                                        "}\n"), SYNTAX);
 
-        ASSERT_THROW(checkCode("void f()\n"
-                               "{\n"
-                               " a[10;\n"
-                               "}\n"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f()\n"
+                                        "{\n"
+                                        " a[10;\n"
+                                        "}\n"), SYNTAX);
 
         {
             const char code[] = "{\n"
@@ -1071,72 +1095,76 @@ class TestGarbage : public TestFixture {
 
     void garbageCode134() {
         // Ticket #5605, #5759, #5762, #5774, #5823, #6059
-        ASSERT_THROW(checkCode("foo() template<typename T1 = T2 = typename = unused, T5 = = unused> struct tuple Args> tuple<Args...> { } main() { foo<int,int,int,int,int,int>(); }"), InternalError);
-        ASSERT_THROW(checkCode("( ) template < T1 = typename = unused> struct Args { } main ( ) { foo < int > ( ) ; }"), InternalError);
-        ASSERT_THROW(checkCode("() template < T = typename = x > struct a {} { f <int> () }"), InternalError);
-        ASSERT_THROW(checkCode("template < T = typename = > struct a { f <int> }"), InternalError);
-        checkCode("struct S { int i, j; }; "
-                  "template<int S::*p, typename U> struct X {}; "
-                  "X<&S::i, int> x = X<&S::i, int>(); "
-                  "X<&S::j, int> y = X<&S::j, int>(); ");
-        checkCode("template <typename T> struct A {}; "
-                  "template <> struct A<void> {}; "
-                  "void foo(const void* f = 0) {}");
-        checkCode("template<typename... T> struct A { "
-                  "  static const int s = 0; "
-                  "}; "
-                  "A<int> a;");
-        checkCode("template<class T, class U> class A {}; "
-                  "template<class T = A<int, int> > class B {}; "
-                  "template<class T = B<int> > class C { "
-                  "    C() : _a(0), _b(0) {} "
-                  "    int _a, _b; "
-                  "};");
-        checkCode("template<class... T> struct A { "
-                  "  static int i; "
-                  "}; "
-                  "void f() { A<int>::i = 0; }");
-    }
-
-    void garbageCode135() { // #4994
-        checkCode("long f () {\n"
-                  "  return a >> extern\n"
-                  "}\n"
-                  "long a = 1 ;\n"
-                  "long b = 2 ;");
+        ASSERT_THROW_INTERNAL(checkCode("foo() template<typename T1 = T2 = typename = unused, T5 = = unused> struct tuple Args> tuple<Args...> { } main() { foo<int,int,int,int,int,int>(); }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("( ) template < T1 = typename = unused> struct Args { } main ( ) { foo < int > ( ) ; }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("() template < T = typename = x > struct a {} { f <int> () }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("template < T = typename = > struct a { f <int> }"), SYNTAX);
+        (void)checkCode("struct S { int i, j; }; "
+                        "template<int S::*p, typename U> struct X {}; "
+                        "X<&S::i, int> x = X<&S::i, int>(); "
+                        "X<&S::j, int> y = X<&S::j, int>();");
+        ignore_errout(); // we are not interested in the output
+        (void)checkCode("template <typename T> struct A {}; "
+                        "template <> struct A<void> {}; "
+                        "void foo(const void* f = 0) {}");
+        (void)checkCode("template<typename... T> struct A { "
+                        "  static const int s = 0; "
+                        "}; "
+                        "A<int> a;");
+        (void)checkCode("template<class T, class U> class A {}; "
+                        "template<class T = A<int, int> > class B {}; "
+                        "template<class T = B<int> > class C { "
+                        "    C() : _a(0), _b(0) {} "
+                        "    int _a, _b; "
+                        "};");
+        (void)checkCode("template<class... T> struct A { "
+                        "  static int i; "
+                        "}; "
+                        "void f() { A<int>::i = 0; }");
+        ignore_errout(); // we are not interested in the output
+    }
+
+    void garbageCode135() { // #4994 (segmentation fault)
+        (void)checkCode("long f () {\n"
+                        "  return a >> extern\n"
+                        "}\n"
+                        "long a = 1 ;\n"
+                        "long b = 2 ;");
+        ignore_errout(); // we are not interested in the output
     }
 
     void garbageCode136() { // #7033
-        ASSERT_THROW(checkCode("{ } () { void f() { node_t * n; for (; -n) {} } } { }"),
-                     InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ } () { void f() { node_t * n; for (; -n) {} } } { }"),
+                              SYNTAX);
     }
 
     void garbageCode137() { // #7034
-        ASSERT_THROW(checkCode("\" \" typedef signed char f; \" \"; void a() { f * s = () &[]; (; ) (; ) }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("\" \" typedef signed char f; \" \"; void a() { f * s = () &[]; (; ) (; ) }"), SYNTAX);
     }
 
-    void garbageCode138() { // #6660
-        checkCode("CS_PLUGIN_NAMESPACE_BEGIN(csparser)\n"
-                  "{\n"
-                  "    struct foo\n"
-                  "    {\n"
-                  "      union\n"
-                  "      {};\n"
-                  "    } halo;\n"
-                  "}\n"
-                  "CS_PLUGIN_NAMESPACE_END(csparser)");
+    void garbageCode138() { // #6660 (segmentation fault)
+        (void)checkCode("CS_PLUGIN_NAMESPACE_BEGIN(csparser)\n"
+                        "{\n"
+                        "    struct foo\n"
+                        "    {\n"
+                        "      union\n"
+                        "      {};\n"
+                        "    } halo;\n"
+                        "}\n"
+                        "CS_PLUGIN_NAMESPACE_END(csparser)");
+        ignore_errout(); // we are not interested in the output
     }
 
     void garbageCode139() { // #6659 heap user after free: kernel: sm750_accel.c
-        ASSERT_THROW(checkCode("void hw_copyarea() {\n"
-                               "   de_ctrl = (nDirection == RIGHT_TO_LEFT) ?\n"
-                               "    ( (0 & ~(((1 << (1 - (0 ? DE_CONTROL_DIRECTION))) - 1) << (0 ? DE_CONTROL_DIRECTION))) )\n"
-                               "    : 42;\n"
-                               "}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void hw_copyarea() {\n"
+                                        "   de_ctrl = (nDirection == RIGHT_TO_LEFT) ?\n"
+                                        "    ( (0 & ~(((1 << (1 - (0 ? DE_CONTROL_DIRECTION))) - 1) << (0 ? DE_CONTROL_DIRECTION))) )\n"
+                                        "    : 42;\n"
+                                        "}"), SYNTAX);
     }
 
     void garbageCode140() { // #7035
-        ASSERT_THROW(checkCode("int foo(int align) { int off(= 0 % align;  return off) ? \\ align - off  :  0;  \\ }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("int foo(int align) { int off(= 0 % align;  return off) ? \\ align - off  :  0;  \\ }"), SYNTAX);
     }
 
     void garbageCode141() { // #7043
@@ -1144,186 +1172,189 @@ class TestGarbage : public TestFixture {
     }
 
     void garbageCode142() { // #7050
-        checkCode("{ } (  ) { void mapGraphs ( ) { node_t * n ; for (!oid n ) { } } } { }");
+        ASSERT_THROW_INTERNAL(checkCode("{ } (  ) { void mapGraphs ( ) { node_t * n ; for (!oid n ) { } } } { }"), SYNTAX);
     }
 
     void garbageCode143() { // #6922
-        ASSERT_THROW(checkCode("void neoProgramShadowRegs() {\n"
-                               "    int i;\n"
-                               "    Bool noProgramShadowRegs;\n"
-                               "    if (noProgramShadowRegs) {\n"
-                               "    } else {\n"
-                               "        switch (nPtr->NeoPanelWidth) {\n"
-                               "        case 1280:\n"
-                               "            VGAwCR(0x64,0x?? );\n"
-                               "        }\n"
-                               "    }\n"
-                               "}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void neoProgramShadowRegs() {\n"
+                                        "    int i;\n"
+                                        "    Bool noProgramShadowRegs;\n"
+                                        "    if (noProgramShadowRegs) {\n"
+                                        "    } else {\n"
+                                        "        switch (nPtr->NeoPanelWidth) {\n"
+                                        "        case 1280:\n"
+                                        "            VGAwCR(0x64,0x?? );\n"
+                                        "        }\n"
+                                        "    }\n"
+                                        "}"), AST);
     }
 
     void garbageCode144() { // #6865
-        ASSERT_THROW(checkCode("template < typename > struct A { } ; template < typename > struct A < INVALID > : A < int[ > { }] ;"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("template < typename > struct A { } ; template < typename > struct A < INVALID > : A < int[ > { }] ;"), SYNTAX);
     }
 
     void garbageCode146() { // #7081
-        ASSERT_THROW(checkCode("void foo() {\n"
-                               "    ? std::cout << pow((, 1) << std::endl;\n"
-                               "    double <ip = NUO ip) << std::end;\n"
-                               "}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void foo() {\n"
+                                        "    ? std::cout << pow((, 1) << std::endl;\n"
+                                        "    double <ip = NUO ip) << std::end;\n"
+                                        "}"), SYNTAX);
     }
 
     void garbageCode147() { // #7082
-        ASSERT_THROW(checkCode("free(3();\n"
-                               "$  vWrongAllocp1) test1<int, -!>() ^ {\n"
-                               "    int *p<ynew int[n];\n"
-                               "    delete[]p;\n"
-                               "    int *p1 = (int*)malloc(n*sizeof(int));\n"
-                               "    free(p1);\n"
-                               "}\n"
-                               "void est2() {\n"
-                               "    for (int ui = 0; ui < 1z; ui++)\n"
-                               "        ;\n"
-                               "}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("free(3();\n"
+                                        "$  vWrongAllocp1) test1<int, -!>() ^ {\n"
+                                        "    int *p<ynew int[n];\n"
+                                        "    delete[]p;\n"
+                                        "    int *p1 = (int*)malloc(n*sizeof(int));\n"
+                                        "    free(p1);\n"
+                                        "}\n"
+                                        "void est2() {\n"
+                                        "    for (int ui = 0; ui < 1z; ui++)\n"
+                                        "        ;\n"
+                                        "}"), SYNTAX);
 
-        ASSERT_THROW(checkCode("; void f ^ { return } int main ( ) { }"), InternalError); // #4941
+        ASSERT_THROW_INTERNAL(checkCode("; void f ^ { return } int main ( ) { }"), SYNTAX); // #4941
     }
 
     void garbageCode148() { // #7090
-        ASSERT_THROW(checkCode("void f_1() {\n"
-                               "    typedef S0 b[][1][1] != 0\n"
-                               "};\n"
-                               "b[K][0] S0 b[][1][1] != 4{ 0 };\n"
-                               "b[0][0]"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f_1() {\n"
+                                        "    typedef S0 b[][1][1] != 0\n"
+                                        "};\n"
+                                        "b[K][0] S0 b[][1][1] != 4{ 0 };\n"
+                                        "b[0][0]"), UNKNOWN_MACRO);
     }
 
-    void garbageCode149() { // #7085
-        checkCode("int main() {\n"
-                  "    for (j = 0; j < 1; j)\n"
-                  "        j6;\n"
-                  "}");
+    void garbageCode149() { // #7085 (segmentation fault)
+        (void)checkCode("int main() {\n"
+                        "    for (j = 0; j < 1; j)\n"
+                        "        j6;\n"
+                        "}");
+        ignore_errout(); // we do not care about the output
     }
 
     void garbageCode150() { // #7089
-        ASSERT_THROW(checkCode("class A {\n"
-                               "    pl vFoo() {\n"
-                               "        A::\n"
-                               "    };\n"
-                               "    A::\n"
-                               "}\n"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("class A {\n"
+                                        "    pl vFoo() {\n"
+                                        "        A::\n"
+                                        "    };\n"
+                                        "    A::\n"
+                                        "}\n"), SYNTAX);
     }
 
     void garbageCode151() { // #4911 - bad simplification => don't crash
-        checkCode("void f() {\n"
-                  "    int a;\n"
-                  "    do { a=do_something() } while (a);\n"
-                  "}");
+        (void)checkCode("void f() {\n"
+                        "    int a;\n"
+                        "    do { a=do_something() } while (a);\n"
+                        "}");
     }
 
-    void garbageCode152() { // happened in travis, originally from llvm clang code
-        const char* code = "template <bool foo = std::value &&>\n"
-                           "static std::string foo(char *Bla) {\n"
-                           "    while (Bla[1] && Bla[1] != ',') }\n";
-        checkCode(code);
+    void garbageCode152() { // happened in travis, originally from llvm clang code (segmentation fault)
+        const char code[] = "template <bool foo = std::value &&>\n"
+                            "static std::string foo(char *Bla) {\n"
+                            "    while (Bla[1] && Bla[1] != ',') }\n";
+        ASSERT_THROW_INTERNAL(checkCode(code), SYNTAX);
     }
 
     void garbageCode153() {
         TODO_ASSERT_THROW(checkCode("enum { X = << { X } } { X X } enum { X = << { ( X ) } } { } X */"), InternalError);
     }
 
-    void garbageCode154() {
-        checkCode("\"abc\"[];");
+    void garbageCode154() { // #7112 (segmentation fault)
+        (void)checkCode("\"abc\"[];");
     }
 
     void garbageCode156() { // #7120
-        checkCode("struct {}a; d f() { c ? : } {}a.p");
+        ASSERT_THROW_INTERNAL(checkCode("struct {}a; d f() { c ? : } {}a.p"), AST);
     }
 
     void garbageCode157() { // #7131
-        ASSERT_THROW(checkCode("namespace std {\n"
-                               "  template < typename >\n"
-                               "  void swap(); \n"
-                               "}"
-                               "template std::swap\n"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("namespace std {\n"
+                                        "  template < typename >\n"
+                                        "  void swap();\n"
+                                        "}"
+                                        "template std::swap\n"), SYNTAX);
     }
 
-    void garbageCode158() { // #3238
-        checkCode("__FBSDID(\"...\");\n");
+    void garbageCode158() { // #3238 (segmentation fault)
+        (void)checkCode("__FBSDID(\"...\");");
     }
 
     void garbageCode159() { // #7119
-        checkCode("({}typedef typename x;typename x!){({{}()})}"); // don't hang
+        ASSERT_THROW_INTERNAL(checkCode("({}typedef typename x;typename x!){({{}()})}"), SYNTAX);
     }
 
     void garbageCode160() { // #7190
-        ASSERT_THROW(checkCode("f(a,b,c,d)float [  a[],d;int ]  b[],c;{} "), InternalError); // don't hang
+        ASSERT_THROW_INTERNAL(checkCode("f(a,b,c,d)float [  a[],d;int ]  b[],c;{} "), SYNTAX); // don't hang
     }
 
 
     void garbageCodeFuzzerClientMode1() {
-        ASSERT_THROW(checkCode("void f() { x= name2 & name3 name2 = | 0.1 , | 0.1 , | 0.1 name4 <= >( ); }"), InternalError);
-        ASSERT_THROW(checkCode("void f() { x = , * [ | + 0xff | > 0xff]; }"), InternalError);
-        ASSERT_THROW(checkCode("void f() {  x = , | 0xff , 0.1 < ; }"), InternalError);
-        ASSERT_THROW(checkCode("void f() { x = [ 1 || ] ; }"), InternalError);
-        ASSERT_THROW(checkCode("void f1() { x = name6 1 || ? name3 [  ( 1 || +) ] ; }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { x= name2 & name3 name2 = | 0.1 , | 0.1 , | 0.1 name4 <= >( ); }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { x = , * [ | + 0xff | > 0xff]; }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {  x = , | 0xff , 0.1 < ; }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { x = [ 1 || ] ; }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f1() { x = name6 1 || ? name3 [  ( 1 || +) ] ; }"), SYNTAX);
     }
 
     void garbageValueFlow() {
-        // #6089
-        const char* code = "{} int foo(struct, x1, struct x2, x3, int, x5, x6, x7)\n"
-                           "{\n"
-                           "    (foo(s, , 2, , , 5, , 7)) abort()\n"
-                           "}\n";
-        ASSERT_THROW(checkCode(code), InternalError);
-
-        // #6106
-        code = " f { int i ; b2 , [ ] ( for ( i = 0 ; ; ) ) }";
-        checkCode(code);
+        { // #6089
+            const char code[] = "{} int foo(struct, x1, struct x2, x3, int, x5, x6, x7)\n"
+                                "{\n"
+                                "    (foo(s, , 2, , , 5, , 7)) abort()\n"
+                                "}\n";
+            ASSERT_THROW_INTERNAL(checkCode(code), SYNTAX);
+        }
 
-        // 6122 survive garbage code
-        code = "; { int i ; for ( i = 0 ; = 123 ; ) - ; }";
-        ASSERT_THROW(checkCode(code), InternalError);
+        { // 6122 survive garbage code
+            const char code[] = "; { int i ; for ( i = 0 ; = 123 ; ) - ; }";
+            ASSERT_THROW_INTERNAL(checkCode(code), SYNTAX);
+        }
 
-        code = "void f1() { for (int n = 0 n < 10 n++); }";
-        checkCode(code);
+        {
+            const char code[] = "void f1() { for (int n = 0 n < 10 n++); }";
+            ASSERT_THROW_INTERNAL(checkCode(code), SYNTAX);
+        }
     }
 
     void garbageSymbolDatabase() {
-        checkCode("void f( { u = 1 ; } ) { }");
+        (void)checkCode("void f( { u = 1 ; } ) { }");
 
-        ASSERT_THROW(checkCode("{ }; void namespace A::f; { g() { int } }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ }; void namespace A::f; { g() { int } }"), SYNTAX);
 
-        ASSERT_THROW(checkCode("class Foo {}; class Bar : public Foo"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("class Foo {}; class Bar : public Foo"), SYNTAX);
 
-        checkCode("YY_DECL { switch (yy_act) {\n"
-                  "    case 65: YY_BREAK\n"
-                  "    case YY_STATE_EOF(block):\n"
-                  "        yyterminate(); \n"
-                  "} }"); // #5663
+        // #5663 (segmentation fault)
+        (void)checkCode("YY_DECL { switch (yy_act) {\n"
+                        "    case 65: YY_BREAK\n"
+                        "    case YY_STATE_EOF(block):\n"
+                        "        yyterminate();\n"
+                        "} }");
+        ignore_errout(); // we are not interested in the output
     }
 
     void garbageAST() {
-        ASSERT_THROW(checkCode("N 1024 float a[N], b[N + 3], c[N]; void N; (void) i;\n"
-                               "int #define for (i = avx_test i < c[i]; i++)\n"
-                               "b[i + 3] = a[i] * {}"), InternalError); // Don't hang (#5787)
+        ASSERT_THROW_INTERNAL(checkCode("N 1024 float a[N], b[N + 3], c[N]; void N; (void) i;\n"
+                                        "int #define for (i = avx_test i < c[i]; i++)\n"
+                                        "b[i + 3] = a[i] * {}"), SYNTAX); // Don't hang (#5787)
 
-        checkCode("START_SECTION([EXTRA](bool isValid(const String &filename)))"); // Don't crash (#5991)
+        (void)checkCode("START_SECTION([EXTRA](bool isValid(const String &filename)))"); // Don't crash (#5991)
 
         // #8352
-        ASSERT_THROW(checkCode("else return % name5 name2 - =name1 return enum | { - name3 1 enum != >= 1 >= ++ { { || "
-                               "{ return return { | { - name3 1 enum != >= 1 >= ++ { name6 | ; ++}}}}}}}"), InternalError);
-        ASSERT_THROW(checkCode("else return % name5 name2 - =name1 return enum | { - name3 1 enum != >= 1 >= ++ { { || "
-                               "{ return return { | { - name3 1 enum != >= 1 >= ++ { { || ; ++}}}}}}}}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("else return % name5 name2 - =name1 return enum | { - name3 1 enum != >= 1 >= ++ { { || "
+                                        "{ return return { | { - name3 1 enum != >= 1 >= ++ { name6 | ; ++}}}}}}}"), UNKNOWN_MACRO);
+        ASSERT_THROW_INTERNAL(checkCode("else return % name5 name2 - =name1 return enum | { - name3 1 enum != >= 1 >= ++ { { || "
+                                        "{ return return { | { - name3 1 enum != >= 1 >= ++ { { || ; ++}}}}}}}}"), UNKNOWN_MACRO);
     }
 
     void templateSimplifierCrashes() {
-        checkCode( // #5950
-            "struct A { \n"
+        (void)checkCode( // #5950 (segmentation fault)
+            "struct A {\n"
             "  template <class T> operator T*();\n"
-            "}; \n"
+            "};\n"
             "\n"
             "template <> A::operator char*(){ return 0; } // specialization\n"
             "\n"
-            "int main() { \n"
+            "int main() {\n"
             "  A a;\n"
             "  int *ip = a.operator int*();\n"
             "}\n"
@@ -1336,24 +1367,23 @@ class TestGarbage : public TestFixture {
             "  void f() {\n"
             "    s.operator A<A<int> >();\n"
             "  }\n"
-            "}\n");
+            "}");
 
-        checkCode( // #6034
-            "template<template<typename...> class T, typename... Args>\n"
-            "struct foo<T<Args...> > {\n"
-            "    const bool value = true;\n"
-            "};\n"
-            "\n"
-            "template<int I>\n"
-            "struct int_\n"
-            "{};\n"
-            "\n"
-            "int main() {\n"
-            "  foo<int_<0> >::value;\n"
-            "}\n"
-        );
+        ASSERT_NO_THROW(checkCode( // #6034
+                            "template<template<typename...> class T, typename... Args>\n"
+                            "struct foo<T<Args...> > {\n"
+                            "    const bool value = true;\n"
+                            "};\n"
+                            "\n"
+                            "template<int I>\n"
+                            "struct int_\n"
+                            "{};\n"
+                            "\n"
+                            "int main() {\n"
+                            "  foo<int_<0> >::value;\n"
+                            "}"));
 
-        checkCode( // #6117
+        (void)checkCode( // #6117 (segmentation fault)
             "template <typename ...> struct something_like_tuple\n"
             "{};\n"
             "template <typename, typename> struct is_last {\n"
@@ -1369,19 +1399,18 @@ class TestGarbage : public TestFixture {
             "\n"
             "typedef something_like_tuple<char, int, float> something_like_tuple_t;\n"
             "SA ((is_last<float, something_like_tuple_t>::value == false));\n"
-            "SA ((is_last<int, something_like_tuple_t>::value == false));\n"
-        );
+            "SA ((is_last<int, something_like_tuple_t>::value == false));");
+        ignore_errout(); // we are not interested in the output
 
-        checkCode( // #6225
+        (void)checkCode( // #6225 (use-after-free)
             "template <typename...>\n"
             "void templ_fun_with_ty_pack() {}\n"
-            " \n"
+            "\n"
             "namespace PR20047 {\n"
             "        template <typename T>\n"
             "        struct A {};\n"
             "        using AliasA = A<T>;\n"
-            "}\n"
-        );
+            "}");
 
         // #3449
         ASSERT_EQUALS("template < typename T > struct A ;\n"
@@ -1393,104 +1422,106 @@ class TestGarbage : public TestFixture {
     }
     void garbageCode161() {
         //7200
-        ASSERT_THROW(checkCode("{ }{ if () try { } catch (...)} B : : ~B { }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{ }{ if () try { } catch (...)} B : : ~B { }"), SYNTAX);
     }
 
     void garbageCode162() {
         //7208
-        ASSERT_THROW(checkCode("return <<  >>  x return <<  >>  x ", false), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("return <<  >>  x return <<  >>  x ", false), UNKNOWN_MACRO);
     }
 
     void garbageCode163() {
         //7228
-        ASSERT_THROW(checkCode("typedef s f[](){typedef d h(;f)}", false), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("typedef s f[](){typedef d h(;f)}", false), SYNTAX);
     }
 
     void garbageCode164() {
         //7234
-        checkCode("class d{k p;}(){d::d():B<()}");
+        ASSERT_THROW_INTERNAL(checkCode("class d{k p;}(){d::d():B<()}"), SYNTAX);
     }
 
     void garbageCode165() {
         //7235
-        ASSERT_THROW(checkCode("for(;..)", false),InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("for(;..)", false),SYNTAX);
     }
 
     void garbageCode167() {
         //7237
-        ASSERT_THROW(checkCode("class D00i000{:D00i000::}i"),InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("class D00i000{:D00i000::}i"),SYNTAX);
     }
 
     void garbageCode168() {
-        // 7246
-        checkCode("long foo(void) { return *bar; }", false);
+        // #7246 (segmentation fault)
+        (void)checkCode("long foo(void) { return *bar; }", false);
+        ignore_errout(); // we do not care about the output
     }
 
     void garbageCode169() {
         // 6713
-        ASSERT_THROW(checkCode("( ) { ( ) ; { return } switch ( ) i\n"
-                               "set case break ; default: ( ) }", false), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("( ) { ( ) ; { return } switch ( ) i\n"
+                                        "set case break ; default: ( ) }", false), SYNTAX);
     }
 
     void garbageCode170() {
         // 7255
-        ASSERT_THROW(checkCode("d i(){{f*s=typeid(()0,)}}", false), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("d i(){{f*s=typeid(()0,)}}", false), SYNTAX);
     }
 
     void garbageCode171() {
         // 7270
-        ASSERT_THROW(checkCode("(){case()?():}:", false), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("(){case()?():}:", false), SYNTAX);
     }
 
     void garbageCode172() {
         // #7357
-        ASSERT_THROW(checkCode("p<e T=l[<]<>>,"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("p<e T=l[<]<>>,"), SYNTAX);
     }
 
     void garbageCode173() {
         // #6781  heap corruption ;  TemplateSimplifier::simplifyTemplateInstantiations
-        ASSERT_THROW(checkCode(" template < Types > struct S : >( S < ...Types... > S <) > { ( ) { } } ( ) { return S < void > ( ) }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode(" template < Types > struct S : >( S < ...Types... > S <) > { ( ) { } } ( ) { return S < void > ( ) }"), SYNTAX);
     }
 
     void garbageCode174() { // #7356
-        ASSERT_THROW(checkCode("{r e() { w*constD = (())D = cast< }}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{r e() { w*constD = (())D = cast< }}"), SYNTAX);
     }
 
     void garbageCode175() { // #7027
-        ASSERT_THROW(checkCode("int f() {\n"
-                               "  int i , j;\n"
-                               "  for ( i = t3 , i < t1 ; i++ )\n"
-                               "    for ( j = 0 ; j < = j++ )\n"
-                               "        return t1 ,\n"
-                               "}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("int f() {\n"
+                                        "  int i , j;\n"
+                                        "  for ( i = t3 , i < t1 ; i++ )\n"
+                                        "    for ( j = 0 ; j < = j++ )\n"
+                                        "        return t1 ,\n"
+                                        "}"), SYNTAX);
     }
 
-    void garbageCode176() { // #7527
-        checkCode("class t { { struct } enum class f : unsigned { q } b ; operator= ( T ) { switch ( b ) { case f::q: } } { assert ( b ) ; } } { ; & ( t ) ( f::t ) ; } ;");
+    void garbageCode176() { // #7257 (segmentation fault)
+        (void)checkCode("class t { { struct } enum class f : unsigned { q } b ; operator= ( T ) { switch ( b ) { case f::q: } } { assert ( b ) ; } } { ; & ( t ) ( f::t ) ; } ;");
+        ignore_errout(); // we are not interested in the output
     }
 
     void garbageCode181() {
-        ASSERT_THROW(checkCode("int test() { int +; }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("int test() { int +; }"), SYNTAX);
     }
 
     // #4195 - segfault for "enum { int f ( ) { return = } r = f ( ) ; }"
     void garbageCode182() {
-        ASSERT_THROW(checkCode("enum { int f ( ) { return = } r = f ( ) ; }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("enum { int f ( ) { return = } r = f ( ) ; }"), SYNTAX);
     }
     // #7505 - segfault
     void garbageCode183() {
-        ASSERT_THROW(checkCode("= { int } enum return { r = f() f(); }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("= { int } enum return { r = f() f(); }"), SYNTAX);
     }
 
     void garbageCode184() { // #7699
-        checkCode("unsigned int AquaSalSystem::GetDisplayScreenCount() {\n"
-                  "    NSArray* pScreens = [NSScreen screens];\n"
-                  "    return pScreens ? [pScreens count] : 1;\n"
-                  "}");
+        ASSERT_THROW_INTERNAL(checkCode("unsigned int AquaSalSystem::GetDisplayScreenCount() {\n"
+                                        "    NSArray* pScreens = [NSScreen screens];\n"
+                                        "    return pScreens ? [pScreens count] : 1;\n"
+                                        "}"), SYNTAX);
     }
 
     void garbageCode185() { // #6011 crash in libreoffice failure to create proper AST
-        checkCode(
+        (void)checkCode(
             "namespace binfilter\n"
             "{\n"
             "       BOOL EnhWMFReader::ReadEnhWMF()\n"
@@ -1498,252 +1529,374 @@ class TestGarbage : public TestFixture {
             "               pOut->CreateObject( nIndex, GDI_BRUSH, new WinMtfFillStyle( ReadColor(), ( nStyle == BS_HOLLOW ) ? TRUE : FALSE ) );\n"
             "               return bStatus;\n"
             "       };\n"
-            "}\n");
+            "}");
+        ignore_errout(); // we are not interested in the output
     }
 
     // #8151 - segfault due to incorrect template syntax
     void garbageCode186() {
-        ASSERT_THROW(checkCode("A<B<><>C"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("A<B<><>C"), SYNTAX);
     }
 
     void garbageCode187() { // # 8152 - segfault in handling
-        const std::string inp("0|\0|0>;\n", 8);
-        ASSERT_THROW(checkCode(inp), InternalError);
+        const char inp[] = "0|\0|0>;\n";
+        ASSERT_THROW_INTERNAL(checkCode(inp), SYNTAX);
 
-        checkCode("template<class T> struct S : A< B<T> || C<T> > {};"); // No syntax error: #8390
-        checkCode("static_assert(A<x> || B<x>, ab);");
+        (void)checkCode("template<class T> struct S : A< B<T> || C<T> > {};"); // No syntax error: #8390
+        (void)checkCode("static_assert(A<x> || B<x>, ab);");
     }
 
     void garbageCode188() { // #8255
-        ASSERT_THROW(checkCode("{z r(){(){for(;<(x);){if(0==0)}}}}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{z r(){(){for(;<(x);){if(0==0)}}}}"), SYNTAX);
     }
 
-    void garbageCode189() { // #8317
-        checkCode("t&n(){()()[](){()}}$");
+    void garbageCode189() { // #8317 (segmentation fault)
+        (void)checkCode("t&n(){()()[](){()}}$");
     }
 
     void garbageCode190() { // #8307
-        ASSERT_THROW(checkCode("void foo() {\n"
-                               "    int i;\n"
-                               "    i *= 0;\n"
-                               "    !i <;\n"
-                               "}"),
-                     InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void foo() {\n"
+                                        "    int i;\n"
+                                        "    i *= 0;\n"
+                                        "    !i <;\n"
+                                        "}"),
+                              AST);
     }
 
     void garbageCode191() { // #8333
-        ASSERT_THROW(checkCode("struct A { int f(const); };"), InternalError);
-        ASSERT_THROW(checkCode("struct A { int f(int, const, char); };"), InternalError);
-        ASSERT_THROW(checkCode("struct A { int f(struct); };"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("struct A { int f(const); };"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("struct A { int f(int, const, char); };"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("struct A { int f(struct); };"), SYNTAX);
 
         // The following code is valid and should not trigger any error
-        checkCode("struct A { int f ( char ) ; } ;");
+        ASSERT_NO_THROW(checkCode("struct A { int f ( char ) ; } ;"));
     }
 
     void garbageCode192() { // #8386 (segmentation fault)
-        ASSERT_THROW(checkCode("{(()[((0||0xf||))]0[])}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{(()[((0||0xf||))]0[])}"), SYNTAX);
     }
 
     // #8740
     void garbageCode193() {
-        ASSERT_THROW(checkCode("d f(){!=[]&&0()!=0}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("d f(){!=[]&&0()!=0}"), SYNTAX);
     }
 
     // #8384
     void garbageCode194() {
-        ASSERT_THROW(checkCode("{((()))(return 1||);}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("{((()))(return 1||);}"), SYNTAX);
     }
 
-    // #8709 - no garbage but to avoid stability regression
+    // #8709 - no garbage but to avoid stability regression (segmentation fault)
     void garbageCode195() {
-        checkCode("a b;\n"
-                  "void c() {\n"
-                  "  switch (d) { case b:; }\n"
-                  "  double e(b);\n"
-                  "  if(e <= 0) {}\n"
-                  "}");
+        (void)checkCode("a b;\n"
+                        "void c() {\n"
+                        "  switch (d) { case b:; }\n"
+                        "  double e(b);\n"
+                        "  if(e <= 0) {}\n"
+                        "}");
+        ignore_errout(); // we do not care about the output
     }
 
     // #8265
     void garbageCode196() {
-        ASSERT_THROW(checkCode("0|,0<<V"), InternalError);
-        ASSERT_THROW(checkCode(";|4|<0;"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("0|,0<<V"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode(";|4|<0;"), SYNTAX);
     }
 
     // #8385
     void garbageCode197() {
-        ASSERT_THROW(checkCode("(){e break,{(case)|{e:[()]}}}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("(){e break,{(case)|{e:[()]}}}"), SYNTAX);
     }
 
     // #8383
     void garbageCode198() {
-        ASSERT_THROW(checkCode("void f(){\n"
-                               "x= ={(continue continue { ( struct continue { ( ++ name5 name5 ) ( name5 name5 n\n"
-                               "ame5 ( name5 struct ( name5 name5 < ) ) ( default ) { name4 != name5 name5 name5\n"
-                               " ( name5 name5 name5 ( { 1 >= void { ( ()) } 1 name3 return >= >= ( ) >= name5 (\n"
-                               " name5 name6 :nam00 [ ()])}))})})})};\n"
-                               "}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f(){\n"
+                                        "x= ={(continue continue { ( struct continue { ( ++ name5 name5 ) ( name5 name5 n\n"
+                                        "ame5 ( name5 struct ( name5 name5 < ) ) ( default ) { name4 != name5 name5 name5\n"
+                                        " ( name5 name5 name5 ( { 1 >= void { ( ()) } 1 name3 return >= >= ( ) >= name5 (\n"
+                                        " name5 name6 :nam00 [ ()])}))})})})};\n"
+                                        "}"), SYNTAX);
     }
 
-    // #8752
+    // #8752 (segmentation fault)
     void garbageCode199() {
-        checkCode("d f(){e n00e0[]n00e0&""0+f=0}");
+        ASSERT_THROW_INTERNAL(checkCode("d f(){e n00e0[]n00e0&" "0+f=0}"), SYNTAX);
     }
 
     // #8757
     void garbageCode200() {
-        ASSERT_THROW(checkCode("(){e break,{(case)!{e:[]}}}"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("(){e break,{(case)!{e:[]}}}"), SYNTAX);
     }
 
     // #8873
     void garbageCode201() {
-        ASSERT_THROW(checkCode("void f() { std::string s=\"abc\"; return s + }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { std::string s=\"abc\"; return s + }"), SYNTAX);
     }
 
     // #8907
     void garbageCode202() {
-        ASSERT_THROW(checkCode("void f() { UNKNOWN_MACRO(return); }"), InternalError);
-        ASSERT_THROW(checkCode("void f() { UNKNOWN_MACRO(throw); }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { UNKNOWN_MACRO(return); }"), UNKNOWN_MACRO);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { UNKNOWN_MACRO(throw); }"), UNKNOWN_MACRO);
+        ignore_errout();
     }
 
-    void garbageCode203() { // #8972
-        checkCode("{ > () {} }");
-        checkCode("template <> a > ::b();");
+    void garbageCode203() { // #8972 (segmentation fault)
+        ASSERT_THROW_INTERNAL(checkCode("{ > () {} }"), SYNTAX);
+        (void)checkCode("template <> a > ::b();");
     }
 
     void garbageCode204() {
-        ASSERT_THROW(checkCode("template <a, = b<>()> c; template <a> a as() {} as<c<>>();"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("template <a, = b<>()> c; template <a> a as() {} as<c<>>();"), SYNTAX);
     }
 
     void garbageCode205() {
-        checkCode("class CodeSnippetsEvent : public wxCommandEvent {\n"
-                  "public :\n"
-                  "    CodeSnippetsEvent ( wxEventType commandType =  wxEventType , int id = 0 ) ;\n"
-                  "    CodeSnippetsEvent ( const CodeSnippetsEvent & event ) ;\n"
-                  "virtual wxEvent * Clone ( ) const { return new CodeSnippetsEvent ( * this ) ; }\n"
-                  "private :\n"
-                  "    int m_SnippetID ;\n"
-                  "} ;\n"
-                  "const  wxEventType wxEVT_CODESNIPPETS_GETFILELINKS  =  wxNewEventType  (  )\n"
-                  "CodeSnippetsEvent :: CodeSnippetsEvent ( wxEventType commandType , int id )\n"
-                  ": wxCommandEvent ( commandType , id ) {\n"
-                  "}\n"
-                  "CodeSnippetsEvent :: CodeSnippetsEvent ( const CodeSnippetsEvent & Event )\n"
-                  ": wxCommandEvent ( Event )\n"
-                  ", m_SnippetID ( 0 ) {\n"
-                  "}"); // don't crash
+        ASSERT_THROW_INTERNAL(checkCode("class CodeSnippetsEvent : public wxCommandEvent {\n"
+                                        "public :\n"
+                                        "    CodeSnippetsEvent ( wxEventType commandType =  wxEventType , int id = 0 ) ;\n"
+                                        "    CodeSnippetsEvent ( const CodeSnippetsEvent & event ) ;\n"
+                                        "virtual wxEvent * Clone ( ) const { return new CodeSnippetsEvent ( * this ) ; }\n"
+                                        "private :\n"
+                                        "    int m_SnippetID ;\n"
+                                        "} ;\n"
+                                        "const  wxEventType wxEVT_CODESNIPPETS_GETFILELINKS  =  wxNewEventType  (  )\n"
+                                        "CodeSnippetsEvent :: CodeSnippetsEvent ( wxEventType commandType , int id )\n"
+                                        ": wxCommandEvent ( commandType , id ) {\n"
+                                        "}\n"
+                                        "CodeSnippetsEvent :: CodeSnippetsEvent ( const CodeSnippetsEvent & Event )\n"
+                                        ": wxCommandEvent ( Event )\n"
+                                        ", m_SnippetID ( 0 ) {\n"
+                                        "}"),
+                              INTERNAL);
+    }
+
+    void garbageCode206() {
+        ASSERT_EQUALS("[test.cpp:1] syntax error: operator", getSyntaxError("void foo() { for (auto operator new : int); }"));
+        ASSERT_EQUALS("[test.cpp:1] syntax error", getSyntaxError("void foo() { for (a operator== :) }"));
+    }
+
+    void garbageCode207() { // #8750
+        ASSERT_THROW_INTERNAL(checkCode("d f(){(.n00e0(return%n00e0''('')));}"), SYNTAX);
+    }
+
+    void garbageCode208() { // #8753
+        ASSERT_THROW_INTERNAL(checkCode("d f(){(for(((((0{t b;((((((((()))))))))}))))))}"), SYNTAX);
+    }
+
+    void garbageCode209() { // #8756
+        ASSERT_THROW_INTERNAL(checkCode("{(- -##0xf/-1 0)[]}"), SYNTAX);
+    }
+
+    void garbageCode210() { // #8762
+        ASSERT_THROW_INTERNAL(checkCode("{typedef typedef c n00e0[]c000(;n00e0&c000)}"), SYNTAX);
     }
 
+    void garbageCode211() { // #8764
+        ASSERT_THROW_INTERNAL(checkCode("{typedef f typedef[]({typedef e e,>;typedef(((typedef<typedef|)))})}"), SYNTAX);
+    }
+
+    void garbageCode212() { // #8765
+        ASSERT_THROW_INTERNAL(checkCode("{(){}[]typedef r n00e0[](((n00e0 0((;()))))){(0 typedef n00e0 bre00 n00e0())}[]();typedef n n00e0()[],(bre00)}"), SYNTAX);
+    }
+
+    void garbageCode213() { // #8758
+        ASSERT_THROW_INTERNAL(checkCode("{\"\"[(1||)];}"), SYNTAX);
+    }
+
+    void garbageCode214() { // segmentation fault
+        (void)checkCode("THIS FILE CONTAINS VARIOUS TEXT");
+    }
+
+    void garbageCode215() { // daca@home script with extension .c
+        ASSERT_THROW_INTERNAL(checkCode("a = [1,2,3];"), SYNTAX);
+    }
+
+    void garbageCode216() { // #7884 (out-of-memory)
+        (void)checkCode("template<typename> struct A {};\n"
+                        "template<typename...T> struct A<T::T...> {}; \n"
+                        "A<int> a;");
+    }
+
+    void garbageCode217() { // #10011
+        ASSERT_THROW_INTERNAL(checkCode("void f() {\n"
+                                        "    auto p;\n"
+                                        "    if (g(p)) {}\n"
+                                        "    assert();\n"
+                                        "}"), AST);
+    }
+
+    void garbageCode218() { // #8763
+        ASSERT_THROW_INTERNAL(checkCode("d f(){t n0000 const[]n0000+0!=n0000,(0)}"), SYNTAX);
+    }
+    void garbageCode219() { // #10101
+        (void)checkCode("typedef void (*func) (addr) ;\n"
+                        "void bar(void) {\n"
+                        "    func f;\n"
+                        "    f & = (func)42;\n"
+                        "}\n"); // don't crash
+        ignore_errout(); // we are not interested in the output
+    }
+    void garbageCode220() { // #6832
+        ASSERT_THROW_INTERNAL(checkCode("(){(){{()}}return;{switch()0 case(){}break;l:()}}\n"), SYNTAX);  // don't crash
+    }
+    void garbageCode221() {
+        ASSERT_THROW_INTERNAL(checkCode("struct A<0<;\n"), SYNTAX);  // don't crash
+    }
+    void garbageCode222() { // #10763
+        ASSERT_THROW_INTERNAL(checkCode("template<template<class>\n"), SYNTAX);  // don't crash
+    }
+    void garbageCode223() { // #11639
+        ASSERT_THROW_INTERNAL(checkCode("struct{}*"), SYNTAX);  // don't crash
+    }
+    void garbageCode224() {
+        ASSERT_THROW_INTERNAL(checkCode("void f(){ auto* b = dynamic_cast<const }"), SYNTAX);  // don't crash
+        ASSERT_EQUALS("", errout_str());
+        ASSERT_THROW_INTERNAL(checkCode("void f(){ auto* b = dynamic_cast x; }"), SYNTAX);
+        ignore_errout();
+    }
+    void garbageCode225() {
+        ASSERT_THROW_INTERNAL(checkCode("int n() { c * s0, 0 s0 = c(sizeof = ) }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("int n() { c * s0, 0 s0 = c(sizeof |= ) }"), SYNTAX);
+    }
+    void garbageCode226() {
+        ASSERT_THROW_INTERNAL(checkCode("int a() { (b((c)`)) } {}"), SYNTAX); // #11638
+        ASSERT_THROW_INTERNAL(checkCode("int a() { (b((c)\\)) } {}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("int a() { (b((c)@)) } {}"), SYNTAX);
+    }
+    void garbageCode227() { // #12615
+        ASSERT_NO_THROW(checkCode("f(&S::operator=);"));
+    }
+    void garbageCode228() {
+        ASSERT_NO_THROW(checkCode("void f() { enum { A = [=]() mutable { return 0; }() }; }"));
+        ASSERT_NO_THROW(checkCode("enum { A = [=](void) mutable -> int { return 0; }() };"));
+    }
+    void garbageCode229() { // #14126
+        ASSERT_THROW_INTERNAL(checkCode("void f() {} [[maybe_unused]]"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() {} [[unused]]"), SYNTAX);
+    }
+    void garbageCode230() { // #14432
+        ASSERT_THROW_INTERNAL(checkCode("e U U,i"), SYNTAX);
+    }
+    void garbageCode231() {
+        ASSERT_THROW_INTERNAL(checkCode("char char* [] = {\"a\" \"b\"}"), SYNTAX);
+    }
+
+
     void syntaxErrorFirstToken() {
-        ASSERT_THROW(checkCode("&operator(){[]};"), InternalError); // #7818
-        ASSERT_THROW(checkCode("*(*const<> (size_t); foo) { } *(*const (size_t)() ; foo) { }"), InternalError); // #6858
-        ASSERT_THROW(checkCode(">{ x while (y) z int = }"), InternalError); // #4175
-        ASSERT_THROW(checkCode("&p(!{}e x){({(0?:?){({})}()})}"), InternalError); // #7118
-        ASSERT_THROW(checkCode("<class T> { struct { typename D4:typename Base<T*> }; };"), InternalError); // #3533
-        ASSERT_THROW(checkCode(" > template < . > struct Y < T > { = } ;\n"), InternalError); // #6108
+        ASSERT_THROW_INTERNAL(checkCode("&operator(){[]};"), SYNTAX); // #7818
+        ASSERT_THROW_INTERNAL(checkCode("*(*const<> (size_t); foo) { } *(*const (size_t)() ; foo) { }"), SYNTAX); // #6858
+        ASSERT_THROW_INTERNAL(checkCode(">{ x while (y) z int = }"), SYNTAX); // #4175
+        ASSERT_THROW_INTERNAL(checkCode("&p(!{}e x){({(0?:?){({})}()})}"), SYNTAX); // #7118
+        ASSERT_THROW_INTERNAL(checkCode("<class T> { struct { typename D4:typename Base<T*> }; };"), SYNTAX); // #3533
+        ASSERT_THROW_INTERNAL(checkCode(" > template < . > struct Y < T > { = } ;\n"), SYNTAX); // #6108
     }
 
     void syntaxErrorLastToken() {
-        ASSERT_THROW(checkCode("int *"), InternalError); // #7821
-        ASSERT_THROW(checkCode("x[y]"), InternalError); // #2986
-        ASSERT_THROW(checkCode("( ) &"), InternalError);
-        ASSERT_THROW(checkCode("|| #if #define <="), InternalError); // #2601
-        ASSERT_THROW(checkCode("f::y:y : <x::"), InternalError); // #6613
-        ASSERT_THROW(checkCode("a \"b\" not_eq \"c\""), InternalError); // #6720
-        ASSERT_THROW(checkCode("(int arg2) { } { } typedef void (func_type) (int, int); typedef func_type&"), InternalError); // #6738
-        ASSERT_THROW(checkCode("&g[0]; { (g[0] 0) } =", false), InternalError); // #6744
-        ASSERT_THROW(checkCode("{ { void foo() { struct }; { }; } }; struct S { } f =", false), InternalError); // #6753
-        ASSERT_THROW(checkCode("{ { ( ) } P ( ) ^ { } { } { } ( ) } 0"), InternalError); // #6772
-        ASSERT_THROW(checkCode("+---+"), InternalError); // #6948
-        ASSERT_THROW(checkCode("template<>\n"), InternalError);
-        ASSERT_THROW(checkCode("++4++ +  + E++++++++++ + ch " "tp.oed5[.]"), InternalError); // #7074
-        ASSERT_THROW(checkCode("d a(){f s=0()8[]s?():0}*()?:0", false), InternalError); // #7236
-        ASSERT_THROW(checkCode("!2 : #h2 ?:", false), InternalError); // #7769
-        ASSERT_THROW(checkCode("--"), InternalError);
-        ASSERT_THROW(checkCode("volatile true , test < test < #ifdef __ppc__ true ,"), InternalError); // #4169
-        ASSERT_THROW(checkCode("a,b--\n"), InternalError); // #2847
-        ASSERT_THROW(checkCode("x a[0] ="), InternalError); // #2682
-        ASSERT_THROW(checkCode("auto_ptr<x>\n"), InternalError); // #2967
-        ASSERT_THROW(checkCode("char a[1]\n"), InternalError); // #2865
-        ASSERT_THROW(checkCode("<><<"), InternalError); // #2612
-        ASSERT_THROW(checkCode("z<y<x>"), InternalError); // #2831
-        ASSERT_THROW(checkCode("><,f<i,"), InternalError); // #2835
-        ASSERT_THROW(checkCode("0; (a) < (a)"), InternalError); // #2875
-        ASSERT_THROW(checkCode(" ( * const ( size_t ) ; foo )"), InternalError); // #6135
-        ASSERT_THROW(checkCode("({ (); strcat(strcat(() ()) ()) })"), InternalError); // #6686
-        ASSERT_THROW(checkCode("%: return ; ()"), InternalError); // #3441
-        ASSERT_THROW(checkCode("__attribute__((destructor)) void"), InternalError); // #7816
-        ASSERT_THROW(checkCode("1 *p = const"), InternalError); // #3512
-        ASSERT_THROW(checkCode("sizeof"), InternalError); // #2599
-        ASSERT_THROW(checkCode(" enum struct"), InternalError); // #6718
-        ASSERT_THROW(checkCode("{(){(())}}r&const"), InternalError); // #7321
-        ASSERT_THROW(checkCode("int"), InternalError);
-        ASSERT_THROW(checkCode("struct A :\n"), InternalError); // #2591
-        ASSERT_THROW(checkCode("{} const const\n"), InternalError); // #2637
-        ASSERT_THROW(checkCode("re2c: error: line 14, column 4: can only difference char sets"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("int *"), SYNTAX); // #7821
+        ASSERT_THROW_INTERNAL(checkCode("x[y]"), SYNTAX); // #2986
+        ASSERT_THROW_INTERNAL(checkCode("( ) &"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("|| #if #define <="), SYNTAX); // #2601
+        ASSERT_THROW_INTERNAL(checkCode("f::y:y : <x::"), SYNTAX); // #6613
+        ASSERT_THROW_INTERNAL(checkCode("a \"b\" not_eq \"c\""), SYNTAX); // #6720
+        ASSERT_THROW_INTERNAL(checkCode("(int arg2) { } { } typedef void (func_type) (int, int); typedef func_type&"), SYNTAX); // #6738
+        ASSERT_THROW_INTERNAL(checkCode("&g[0]; { (g[0] 0) } =", false), SYNTAX); // #6744
+        ASSERT_THROW_INTERNAL(checkCode("{ { void foo() { struct }; { }; } }; struct S { } f =", false), SYNTAX); // #6753
+        ASSERT_THROW_INTERNAL(checkCode("{ { ( ) } P ( ) ^ { } { } { } ( ) } 0"), SYNTAX); // #6772
+        ASSERT_THROW_INTERNAL(checkCode("+---+"), SYNTAX); // #6948
+        ASSERT_THROW_INTERNAL(checkCode("template<>\n"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("++4++ +  + E++++++++++ + ch " "tp.oed5[.]"), SYNTAX); // #7074
+        ASSERT_THROW_INTERNAL(checkCode("d a(){f s=0()8[]s?():0}*()?:0", false), SYNTAX); // #7236
+        ASSERT_THROW_INTERNAL(checkCode("!2 : #h2 ?:", false), SYNTAX); // #7769
+        ASSERT_THROW_INTERNAL(checkCode("--"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("volatile true , test < test < #ifdef __ppc__ true ,"), SYNTAX); // #4169
+        ASSERT_THROW_INTERNAL(checkCode("a,b--\n"), SYNTAX); // #2847
+        ASSERT_THROW_INTERNAL(checkCode("x a[0] ="), SYNTAX); // #2682
+        ASSERT_THROW_INTERNAL(checkCode("auto_ptr<x>\n"), SYNTAX); // #2967
+        ASSERT_THROW_INTERNAL(checkCode("char a[1]\n"), SYNTAX); // #2865
+        ASSERT_THROW_INTERNAL(checkCode("<><<"), SYNTAX); // #2612
+        ASSERT_THROW_INTERNAL(checkCode("z<y<x>"), SYNTAX); // #2831
+        ASSERT_THROW_INTERNAL(checkCode("><,f<i,"), SYNTAX); // #2835
+        ASSERT_THROW_INTERNAL(checkCode("0; (a) < (a)"), SYNTAX); // #2875
+        ASSERT_THROW_INTERNAL(checkCode(" ( * const ( size_t ) ; foo )"), SYNTAX); // #6135
+        ASSERT_THROW_INTERNAL(checkCode("({ (); strcat(strcat(() ()) ()) })"), SYNTAX); // #6686
+        ASSERT_THROW_INTERNAL(checkCode("%: return ; ()"), SYNTAX); // #3441
+        ASSERT_THROW_INTERNAL(checkCode("__attribute__((destructor)) void"), SYNTAX); // #7816
+        ASSERT_THROW_INTERNAL(checkCode("1 *p = const"), SYNTAX); // #3512
+        ASSERT_THROW_INTERNAL(checkCode("sizeof"), SYNTAX); // #2599
+        ASSERT_THROW_INTERNAL(checkCode(" enum struct"), SYNTAX); // #6718
+        ASSERT_THROW_INTERNAL(checkCode("{(){(())}}r&const"), SYNTAX); // #7321
+        ASSERT_THROW_INTERNAL(checkCode("int"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("struct A :\n"), SYNTAX); // #2591
+        ASSERT_THROW_INTERNAL(checkCode("{} const const\n"), SYNTAX); // #2637
+        ASSERT_THROW_INTERNAL(checkCode("re2c: error: line 14, column 4: can only difference char sets"), SYNTAX);
 
         // ASSERT_THROW(  , InternalError)
     }
 
     void syntaxErrorCase() {
         // case must be inside switch block
-        ASSERT_THROW(checkCode("void f() { switch (a) {}; case 1: }"), InternalError); // #8184
-        ASSERT_THROW(checkCode("struct V : { public case {} ; struct U : U  void { V *f (int x) (x) } }"), InternalError); // #5120
-        ASSERT_THROW(checkCode("void f() { 0 0; }"), InternalError);
-        ASSERT_THROW(checkCode("void f() { true 0; }"), InternalError);
-        ASSERT_THROW(checkCode("void f() { 'a' 0; }"), InternalError);
-        ASSERT_THROW(checkCode("void f() { 1 \"\"; }"), InternalError);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { switch (a) {}; case 1: }"), SYNTAX); // #8184
+        ASSERT_THROW_INTERNAL(checkCode("struct V : { public case {} ; struct U : U  void { V *f (int x) (x) } }"), SYNTAX); // #5120
+        ASSERT_THROW_INTERNAL(checkCode("void f() { 0 0; }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { true 0; }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { 'a' 0; }"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f() { 1 \"\"; }"), SYNTAX);
     }
 
     void syntaxErrorFuzzerCliType1() {
-        ASSERT_THROW(checkCode("void f(){x=0,return return''[]()}"), InternalError);
-        ASSERT_THROW(checkCode("void f(){x='0'++'0'(return)[];}"), InternalError); // #9063
-        checkCode("void f(){*(int *)42=0;}"); // no syntax error
-        ASSERT_THROW(checkCode("void f() { x= 'x' > typedef name5 | ( , ;){ } (); }"), InternalError); // #9067
-        ASSERT_THROW(checkCode("void f() { x= {}( ) ( 'x')[ ] (); }"), InternalError); // #9068
-        ASSERT_THROW(checkCode("void f() { x= y{ } name5 y[ ] + y ^ name5 ^ name5 for ( ( y y y && y y y && name5 ++ int )); }"), InternalError); // #9069
+        ASSERT_THROW_INTERNAL(checkCode("void f(){x=0,return return''[]()}"), SYNTAX);
+        ASSERT_THROW_INTERNAL(checkCode("void f(){x='0'++'0'(return)[];}"), SYNTAX); // #9063
+        (void)checkCode("void f(){*(int *)42=0;}"); // no syntax error
+        ignore_errout(); // we are not interested in the output
+        ASSERT_THROW_INTERNAL(checkCode("void f() { x= 'x' > typedef name5 | ( , ;){ } (); }"), SYNTAX); // #9067
+        ASSERT_THROW_INTERNAL(checkCode("void f() { x= {}( ) ( 'x')[ ] (); }"), SYNTAX); // #9068
+        ASSERT_THROW_INTERNAL(checkCode("void f() { x= y{ } name5 y[ ] + y ^ name5 ^ name5 for ( ( y y y && y y y && name5 ++ int )); }"), SYNTAX); // #9069
     }
 
     void cliCode() {
         // #8913
-        /*
-        ASSERT_THROW(checkCode("public ref class LibCecSharp : public CecCallbackMethods {\n"
-                               "array<CecAdapter ^> ^ FindAdapters(String ^ path) {} \n"
-                               "bool GetDeviceInformation(String ^ port, LibCECConfiguration ^configuration, uint32_t timeoutMs) {\n"
-                               "bool bReturn(false);\n"
-                               "}\n"
-                               "};\n"), InternalError);
-                               */
+        ASSERT_NO_THROW(checkCode(
+                            "public ref class LibCecSharp : public CecCallbackMethods {\n"
+                            "array<CecAdapter ^> ^ FindAdapters(String ^ path) {}\n"
+                            "bool GetDeviceInformation(String ^ port, LibCECConfiguration ^configuration, uint32_t timeoutMs) {\n"
+                            "bool bReturn(false);\n"
+                            "}\n"
+                            "};"));
+        ignore_errout(); // we are not interested in the output
     }
 
     void enumTrailingComma() {
-        ASSERT_THROW(checkCode("enum ssl_shutdown_t {ssl_shutdown_none = 0,ssl_shutdown_close_notify = , } ;"), InternalError); // #8079
+        ASSERT_THROW_INTERNAL(checkCode("enum ssl_shutdown_t {ssl_shutdown_none = 0,ssl_shutdown_close_notify = , } ;"), SYNTAX); // #8079
     }
 
     void nonGarbageCode1() {
-        checkCode("template <class T> class List {\n"
-                  "public:\n"
-                  "   List();\n"
-                  "   virtual ~List();\n"
-                  "   template< class Predicate > u_int DeleteIf( const Predicate &pred );\n"
-                  "};\n"
-                  "template< class T >\n"
-                  "template< class Predicate > int\n"
-                  "List<T>::DeleteIf( const Predicate &pred )\n"
-                  "{}\n");
+        ASSERT_NO_THROW(checkCode("template <class T> class List {\n"
+                                  "public:\n"
+                                  "   List();\n"
+                                  "   virtual ~List();\n"
+                                  "   template< class Predicate > u_int DeleteIf( const Predicate &pred );\n"
+                                  "};\n"
+                                  "template< class T >\n"
+                                  "template< class Predicate > int\n"
+                                  "List<T>::DeleteIf( const Predicate &pred )\n"
+                                  "{}"));
+        ignore_errout(); // we are not interested in the output
 
         // #8749
-        checkCode(
-            "struct A {\n"
-            "    void operator+=(A&) && = delete;\n"
-            "};\n");
+        ASSERT_NO_THROW(checkCode(
+                            "struct A {\n"
+                            "    void operator+=(A&) && = delete;\n"
+                            "};"));
 
         // #8788
-        checkCode(
-            "struct foo;\n"
-            "void f() {\n"
-            "    auto fn = []() -> foo* { return new foo(); };\n"
-            "}\n");
+        ASSERT_NO_THROW(checkCode(
+                            "struct foo;\n"
+                            "void f() {\n"
+                            "    auto fn = []() -> foo* { return new foo(); };\n"
+                            "}"));
+        ignore_errout(); // we do not care about the output
+
+        // #13892
+        ASSERT_NO_THROW(checkCode("void foovm(int x[const *]);"));
     }
 };
 
diff --git a/test/testimportproject.cpp b/test/testimportproject.cpp
index 2d1e4eab76f..a0daea25bb2 100644
--- a/test/testimportproject.cpp
+++ b/test/testimportproject.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,175 +16,694 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "filesettings.h"
+#include "fixture.h"
 #include "importproject.h"
+#include "redirect.h"
 #include "settings.h"
-#include "testsuite.h"
+#include "standards.h"
+#include "suppressions.h"
+#include "xml.h"
 
 #include <list>
 #include <map>
+#include <sstream>
 #include <string>
+#include <utility>
+#include <vector>
 
-class TestImporter : public ImportProject {
+class TestImporter final : public ImportProject {
 public:
     using ImportProject::importCompileCommands;
     using ImportProject::importCppcheckGuiProject;
+    using ImportProject::importVcxproj;
+    using ImportProject::SharedItemsProject;
+    using ImportProject::collectArgs;
+    using ImportProject::fsSetDefines;
+    using ImportProject::fsSetIncludePaths;
 };
 
 
 class TestImportProject : public TestFixture {
 public:
-    TestImportProject() : TestFixture("TestImportProject") {
-    }
+    TestImportProject() : TestFixture("TestImportProject") {}
 
 private:
 
-    void run() OVERRIDE {
+    void run() override {
         TEST_CASE(setDefines);
         TEST_CASE(setIncludePaths1);
         TEST_CASE(setIncludePaths2);
         TEST_CASE(setIncludePaths3); // macro names are case insensitive
         TEST_CASE(importCompileCommands1);
-        TEST_CASE(importCompileCommands2); // #8563
+        TEST_CASE(importCompileCommands2); // #8563, #9567
         TEST_CASE(importCompileCommands3); // check with existing trailing / in directory
         TEST_CASE(importCompileCommands4); // only accept certain file types
+        TEST_CASE(importCompileCommands5); // Windows/CMake/Ninja generated compile_commands.json
+        TEST_CASE(importCompileCommands6); // Windows/CMake/Ninja generated compile_commands.json with spaces
+        TEST_CASE(importCompileCommands7); // linux: "/home/danielm/cppcheck 2"
+        TEST_CASE(importCompileCommands8); // Windows: "C:\Users\danielm\cppcheck"
+        TEST_CASE(importCompileCommands9);
+        TEST_CASE(importCompileCommands10); // #10887: include path with space
+        TEST_CASE(importCompileCommands11); // include path order
+        TEST_CASE(importCompileCommands12); // #13040: "directory" is parent directory, relative include paths
+        TEST_CASE(importCompileCommands13); // #13333: duplicate file entries
+        TEST_CASE(importCompileCommands14); // #14156
+        TEST_CASE(importCompileCommands15); // #14306
         TEST_CASE(importCompileCommandsArgumentsSection); // Handle arguments section
         TEST_CASE(importCompileCommandsNoCommandSection); // gracefully handles malformed json
+        TEST_CASE(importCompileCommandsDirectoryMissing); // 'directory' field missing
+        TEST_CASE(importCompileCommandsDirectoryInvalid); // 'directory' field not a string
         TEST_CASE(importCppcheckGuiProject);
+        TEST_CASE(importCppcheckGuiProjectPremiumMisra);
+        TEST_CASE(ignorePaths);
+        TEST_CASE(testVcxprojUnicode);
+        TEST_CASE(testCollectArgs1);
+        TEST_CASE(testCollectArgs2);
+        TEST_CASE(testCollectArgs3);
+        TEST_CASE(testCollectArgs4);
+        TEST_CASE(testCollectArgs5);
+        TEST_CASE(testCollectArgs6);
+        TEST_CASE(testCollectArgs7);
     }
 
     void setDefines() const {
-        ImportProject::FileSettings fs;
+        FileSettings fs{"test.cpp", Standards::Language::CPP, 0};
 
-        fs.setDefines("A");
+        TestImporter::fsSetDefines(fs, "A");
         ASSERT_EQUALS("A=1", fs.defines);
 
-        fs.setDefines("A;B;");
+        TestImporter::fsSetDefines(fs, "A;B;");
         ASSERT_EQUALS("A=1;B=1", fs.defines);
 
-        fs.setDefines("A;;B;");
+        TestImporter::fsSetDefines(fs, "A;;B;");
         ASSERT_EQUALS("A=1;B=1", fs.defines);
 
-        fs.setDefines("A;;B");
+        TestImporter::fsSetDefines(fs, "A;;B");
         ASSERT_EQUALS("A=1;B=1", fs.defines);
     }
 
     void setIncludePaths1() const {
-        ImportProject::FileSettings fs;
+        FileSettings fs{"test.cpp", Standards::Language::CPP, 0};
         std::list<std::string> in(1, "../include");
         std::map<std::string, std::string, cppcheck::stricmp> variables;
-        fs.setIncludePaths("abc/def/", in, variables);
+        TestImporter::fsSetIncludePaths(fs, "abc/def/", in, variables);
         ASSERT_EQUALS(1U, fs.includePaths.size());
         ASSERT_EQUALS("abc/include/", fs.includePaths.front());
     }
 
     void setIncludePaths2() const {
-        ImportProject::FileSettings fs;
+        FileSettings fs{"test.cpp", Standards::Language::CPP, 0};
         std::list<std::string> in(1, "$(SolutionDir)other");
         std::map<std::string, std::string, cppcheck::stricmp> variables;
         variables["SolutionDir"] = "c:/abc/";
-        fs.setIncludePaths("/home/fred", in, variables);
+        TestImporter::fsSetIncludePaths(fs, "/home/fred", in, variables);
         ASSERT_EQUALS(1U, fs.includePaths.size());
         ASSERT_EQUALS("c:/abc/other/", fs.includePaths.front());
     }
 
     void setIncludePaths3() const { // macro names are case insensitive
-        ImportProject::FileSettings fs;
+        FileSettings fs{"test.cpp", Standards::Language::CPP, 0};
         std::list<std::string> in(1, "$(SOLUTIONDIR)other");
         std::map<std::string, std::string, cppcheck::stricmp> variables;
         variables["SolutionDir"] = "c:/abc/";
-        fs.setIncludePaths("/home/fred", in, variables);
+        TestImporter::fsSetIncludePaths(fs, "/home/fred", in, variables);
         ASSERT_EQUALS(1U, fs.includePaths.size());
         ASSERT_EQUALS("c:/abc/other/", fs.includePaths.front());
     }
 
     void importCompileCommands1() const {
-        const char json[] = "[ { \"directory\": \"/tmp\","
-                            "\"command\": \"gcc -I/tmp -DFILESDIR=\\\\\\\"/usr/local/share/Cppcheck\\\\\\\" -DTEST1 -DTEST2=2 -o /tmp/src.o -c /tmp/src.c\","
-                            "\"file\": \"/tmp/src.c\" } ]";
+        REDIRECT;
+        constexpr char json[] = R"([{
+                                   "directory": "/tmp",
+                                   "command": "gcc -DTEST1 -DTEST2=2 -o /tmp/src.o -c /tmp/src.c",
+                                   "file": "/tmp/src.c"
+                                   }])";
         std::istringstream istr(json);
         TestImporter importer;
-        importer.importCompileCommands(istr);
+        ASSERT_EQUALS(true, importer.importCompileCommands(istr));
         ASSERT_EQUALS(1, importer.fileSettings.size());
-        ASSERT_EQUALS("FILESDIR=\"/usr/local/share/Cppcheck\";TEST1=1;TEST2=2", importer.fileSettings.begin()->defines);
+        ASSERT_EQUALS("TEST1=1;TEST2=2", importer.fileSettings.cbegin()->defines);
     }
 
     void importCompileCommands2() const {
-        const char json[] = "[ { \"directory\": \"/tmp\","
-                            "\"command\": \"gcc -c src.c\","
-                            "\"file\": \"src.c\" } ]";
+        REDIRECT;
+        // Absolute file path
+#ifdef _WIN32
+        const char json[] = R"([{
+                                   "directory": "C:/foo",
+                                   "command": "gcc -c /bar.c",
+                                   "file": "/bar.c"
+                               }])";
+        std::istringstream istr(json);
+        TestImporter importer;
+        ASSERT_EQUALS(true, importer.importCompileCommands(istr));
+        ASSERT_EQUALS(1, importer.fileSettings.size());
+        ASSERT_EQUALS("C:/bar.c", importer.fileSettings.cbegin()->filename());
+#else
+        constexpr char json[] = R"([{
+                                   "directory": "/foo",
+                                   "command": "gcc -c bar.c",
+                                   "file": "/bar.c"
+                                   }])";
         std::istringstream istr(json);
         TestImporter importer;
-        importer.importCompileCommands(istr);
+        ASSERT_EQUALS(true, importer.importCompileCommands(istr));
         ASSERT_EQUALS(1, importer.fileSettings.size());
-        ASSERT_EQUALS("/tmp/src.c", importer.fileSettings.begin()->filename);
+        ASSERT_EQUALS("/bar.c", importer.fileSettings.cbegin()->filename());
+#endif
     }
 
     void importCompileCommands3() const {
-        const char json[] = "[ { \"directory\": \"/tmp/\","
-                            "\"command\": \"gcc -c src.c\","
-                            "\"file\": \"src.c\" } ]";
+        REDIRECT;
+        const char json[] = R"([{
+                                    "directory": "/tmp/",
+                                    "command": "gcc -c src.c",
+                                    "file": "src.c"
+                               }])";
         std::istringstream istr(json);
         TestImporter importer;
-        importer.importCompileCommands(istr);
+        ASSERT_EQUALS(true, importer.importCompileCommands(istr));
         ASSERT_EQUALS(1, importer.fileSettings.size());
-        ASSERT_EQUALS("/tmp/src.c", importer.fileSettings.begin()->filename);
+        ASSERT_EQUALS("/tmp/src.c", importer.fileSettings.cbegin()->filename());
     }
 
     void importCompileCommands4() const {
-        const char json[] = "[ { \"directory\": \"/tmp/\","
-                            "\"command\": \"gcc -c src.mm\","
-                            "\"file\": \"src.mm\" } ]";
+        REDIRECT;
+        constexpr char json[] = R"([{
+                                    "directory": "/tmp/",
+                                    "command": "gcc -c src.mm",
+                                    "file": "src.mm"
+                                   }])";
         std::istringstream istr(json);
         TestImporter importer;
-        importer.importCompileCommands(istr);
+        ASSERT_EQUALS(true, importer.importCompileCommands(istr));
         ASSERT_EQUALS(0, importer.fileSettings.size());
     }
 
+    void importCompileCommands5() const {
+        REDIRECT;
+        constexpr char json[] =
+            R"([{
+                "directory": "C:/Users/dan/git/build-test-cppcheck-Desktop_Qt_5_15_0_MSVC2019_64bit-Debug",
+                "command": "C:\\PROGRA~2\\MICROS~1\\2019\\COMMUN~1\\VC\\Tools\\MSVC\\1427~1.291\\bin\\HostX64\\x64\\cl.exe /nologo /TP -IC:\\Users\\dan\\git\\test-cppcheck\\mylib\\src /DWIN32 /D_WINDOWS /GR /EHsc /Zi /Ob0 /Od /RTC1 -MDd -std:c++17 /Fomylib\\CMakeFiles\\mylib.dir\\src\\foobar\\mylib.cpp.obj /FdTARGET_COMPILE_PDB /FS -c C:\\Users\\dan\\git\\test-cppcheck\\mylib\\src\\foobar\\mylib.cpp",
+                "file": "C:\\Users\\dan\\git\\test-cppcheck\\mylib\\src\\foobar\\mylib.cpp"
+             },
+             {
+                "directory": "C:/Users/dan/git/build-test-cppcheck-Desktop_Qt_5_15_0_MSVC2019_64bit-Debug",
+                "command": "C:\\PROGRA~2\\MICROS~1\\2019\\COMMUN~1\\VC\\Tools\\MSVC\\1427~1.291\\bin\\HostX64\\x64\\cl.exe /nologo /TP -IC:\\Users\\dan\\git\\test-cppcheck\\myapp\\src -Imyapp -IC:\\Users\\dan\\git\\test-cppcheck\\mylib\\src /DWIN32 /D_WINDOWS /GR /EHsc /Zi /Ob0 /Od /RTC1 -MDd -std:c++17 /Fomyapp\\CMakeFiles\\myapp.dir\\src\\main.cpp.obj /FdTARGET_COMPILE_PDB /FS -c C:\\Users\\dan\\git\\test-cppcheck\\myapp\\src\\main.cpp",
+                "file": "C:\\Users\\dan\\git\\test-cppcheck\\myapp\\src\\main.cpp"
+             }])";
+        std::istringstream istr(json);
+        TestImporter importer;
+        ASSERT_EQUALS(true, importer.importCompileCommands(istr));
+        ASSERT_EQUALS(2, importer.fileSettings.size());
+        ASSERT_EQUALS("C:/Users/dan/git/test-cppcheck/mylib/src/", importer.fileSettings.cbegin()->includePaths.front());
+    }
+
+    void importCompileCommands6() const {
+        REDIRECT;
+        constexpr char json[] =
+            R"([{
+                "directory": "C:/Users/dan/git/build-test-cppcheck-Desktop_Qt_5_15_0_MSVC2019_64bit-Debug",
+                "command": "C:\\PROGRA~2\\MICROS~1\\2019\\COMMUN~1\\VC\\Tools\\MSVC\\1427~1.291\\bin\\HostX64\\x64\\cl.exe /nologo /TP -IC:\\Users\\dan\\git\\test-cppcheck\\mylib\\src -I\"C:\\Users\\dan\\git\\test-cppcheck\\mylib\\second src\" /DWIN32 /D_WINDOWS /GR /EHsc /Zi /Ob0 /Od /RTC1 -MDd -std:c++17 /Fomylib\\CMakeFiles\\mylib.dir\\src\\foobar\\mylib.cpp.obj /FdTARGET_COMPILE_PDB /FS -c C:\\Users\\dan\\git\\test-cppcheck\\mylib\\src\\foobar\\mylib.cpp",
+                "file": "C:\\Users\\dan\\git\\test-cppcheck\\mylib\\src\\foobar\\mylib.cpp"
+            },
+            {
+                "directory": "C:/Users/dan/git/build-test-cppcheck-Desktop_Qt_5_15_0_MSVC2019_64bit-Debug",
+                "command": "C:\\PROGRA~2\\MICROS~1\\2019\\COMMUN~1\\VC\\Tools\\MSVC\\1427~1.291\\bin\\HostX64\\x64\\cl.exe /nologo /TP -IC:\\Users\\dan\\git\\test-cppcheck\\myapp\\src -Imyapp -IC:\\Users\\dan\\git\\test-cppcheck\\mylib\\src /DWIN32 /D_WINDOWS /GR /EHsc /Zi /Ob0 /Od /RTC1 -MDd -std:c++17 /Fomyapp\\CMakeFiles\\myapp.dir\\src\\main.cpp.obj /FdTARGET_COMPILE_PDB /FS -c C:\\Users\\dan\\git\\test-cppcheck\\myapp\\src\\main.cpp",
+                "file": "C:\\Users\\dan\\git\\test-cppcheck\\myapp\\src\\main.cpp"
+             }])";
+        std::istringstream istr(json);
+        TestImporter importer;
+        ASSERT_EQUALS(true, importer.importCompileCommands(istr));
+        ASSERT_EQUALS(2, importer.fileSettings.size());
+        ASSERT_EQUALS("C:/Users/dan/git/test-cppcheck/mylib/src/", importer.fileSettings.cbegin()->includePaths.front());
+        ASSERT_EQUALS("C:/Users/dan/git/test-cppcheck/mylib/second src/", importer.fileSettings.cbegin()->includePaths.back());
+    }
+
+
+    void importCompileCommands7() const {
+        REDIRECT;
+        // cmake -DFILESDIR="/some/path" ..
+        constexpr char json[] =
+            R"([{
+                "directory": "/home/danielm/cppcheck 2/b/lib",
+                "command": "/usr/bin/c++  -DFILESDIR=\\\"/some/path\\\" -I\"/home/danielm/cppcheck 2/b/lib\" -isystem \"/home/danielm/cppcheck 2/externals\" \"/home/danielm/cppcheck 2/lib/astutils.cpp\"",
+                "file": "/home/danielm/cppcheck 2/lib/astutils.cpp"
+            }])";
+        std::istringstream istr(json);
+        TestImporter importer;
+        ASSERT_EQUALS(true, importer.importCompileCommands(istr));
+        ASSERT_EQUALS(1, importer.fileSettings.size());
+        ASSERT_EQUALS("FILESDIR=\"/some/path\"", importer.fileSettings.cbegin()->defines);
+        ASSERT_EQUALS(1, importer.fileSettings.cbegin()->includePaths.size());
+        ASSERT_EQUALS("/home/danielm/cppcheck 2/b/lib/", importer.fileSettings.cbegin()->includePaths.front());
+        TODO_ASSERT_EQUALS("/home/danielm/cppcheck 2/externals/",
+                           "/home/danielm/cppcheck 2/b/lib/",
+                           importer.fileSettings.cbegin()->includePaths.back());
+    }
+
+    void importCompileCommands8() const {
+        REDIRECT;
+        // cmake -DFILESDIR="C:\Program Files\Cppcheck" -G"NMake Makefiles" ..
+        constexpr char json[] =
+            R"([{
+              "directory": "C:/Users/danielm/cppcheck/build/lib",
+              "command": "C:\\PROGRA~2\\MICROS~2\\2017\\COMMUN~1\\VC\\Tools\\MSVC\\1412~1.258\\bin\\Hostx64\\x64\\cl.exe  /nologo /TP -DFILESDIR=\"\\\"C:\\Program Files\\Cppcheck\\\"\" -IC:\\Users\\danielm\\cppcheck\\build\\lib -IC:\\Users\\danielm\\cppcheck\\lib -c C:\\Users\\danielm\\cppcheck\\lib\\astutils.cpp",
+              "file": "C:/Users/danielm/cppcheck/lib/astutils.cpp"
+            }])";
+        std::istringstream istr(json);
+        TestImporter importer;
+        ASSERT_EQUALS(true, importer.importCompileCommands(istr)); // Do not crash
+    }
+
+    void importCompileCommands9() const {
+        REDIRECT;
+        // IAR output (https://sourceforge.net/p/cppcheck/discussion/general/thread/608af51e0a/)
+        constexpr char json[] =
+            R"([{
+              "arguments" : [
+                 "powershell.exe -WindowStyle Hidden -NoProfile -ExecutionPolicy Bypass -File d:\\Projekte\\xyz\\firmware\\app\\xyz-lib\\build.ps1 -IAR -COMPILER_PATH \"c:\\Program Files (x86)\\IAR Systems\\Embedded Workbench 9.0\" -CONTROLLER CC1310F128 -LIB LIB_PERMANENT -COMPILER_DEFINES \"CC1310_HFXO_FREQ=24000000 DEBUG\""
+              ],
+              "directory" : "d:\\Projekte\\xyz\\firmware\\app",
+              "type" : "PRE",
+              "file": "1.c"
+            }])";
+        std::istringstream istr(json);
+        TestImporter importer;
+        ASSERT_EQUALS(true, importer.importCompileCommands(istr));
+    }
+
+    void importCompileCommands10() const { // #10887
+        REDIRECT;
+        constexpr char json[] =
+            R"([{
+               "file": "/home/danielm/cppcheck/1/test folder/1.c" ,
+               "directory": "",
+               "arguments": [
+                   "iccavr.exe",
+                   "-I",
+                   "/home/danielm/cppcheck/test folder"
+               ]
+            }])";
+        std::istringstream istr(json);
+        TestImporter importer;
+        ASSERT_EQUALS(true, importer.importCompileCommands(istr));
+        ASSERT_EQUALS(1, importer.fileSettings.size());
+        const FileSettings &fs = importer.fileSettings.front();
+        ASSERT_EQUALS("/home/danielm/cppcheck/test folder/", fs.includePaths.front());
+    }
+
+    void importCompileCommands11() const { // include path order
+        REDIRECT;
+        constexpr char json[] =
+            R"([{
+               "file": "1.c" ,
+               "directory": "/x",
+               "arguments": [
+                   "cc",
+                   "-I",
+                   "def",
+                   "-I",
+                   "abc"
+               ]
+            }])";
+        std::istringstream istr(json);
+        TestImporter importer;
+        ASSERT_EQUALS(true, importer.importCompileCommands(istr));
+        ASSERT_EQUALS(1, importer.fileSettings.size());
+        const FileSettings &fs = importer.fileSettings.front();
+        ASSERT_EQUALS("/x/def/", fs.includePaths.front());
+        ASSERT_EQUALS("/x/abc/", fs.includePaths.back());
+    }
+
+    void importCompileCommands12() const { // #13040
+        REDIRECT;
+        constexpr char json[] =
+            R"([{
+               "file": "/x/src/1.c" ,
+               "directory": "/x",
+               "command": "cc -c -I. src/1.c"
+            }])";
+        std::istringstream istr(json);
+        TestImporter importer;
+        ASSERT_EQUALS(true, importer.importCompileCommands(istr));
+        ASSERT_EQUALS(1, importer.fileSettings.size());
+        const FileSettings &fs = importer.fileSettings.front();
+        ASSERT_EQUALS(1, fs.includePaths.size());
+        ASSERT_EQUALS("/x/", fs.includePaths.front());
+    }
+
+    void importCompileCommands13() const { // #13333
+        REDIRECT;
+        constexpr char json[] =
+            R"([{
+               "file": "/x/src/1.c" ,
+               "directory": "/x",
+               "command": "cc -c -I. src/1.c"
+            },{
+               "file": "/x/src/1.c" ,
+               "directory": "/x",
+               "command": "cc -c -I. src/1.c"
+            }])";
+        std::istringstream istr(json);
+        TestImporter importer;
+        ASSERT_EQUALS(true, importer.importCompileCommands(istr));
+        ASSERT_EQUALS(2, importer.fileSettings.size());
+        const FileSettings &fs1 = importer.fileSettings.front();
+        const FileSettings &fs2 = importer.fileSettings.back();
+        ASSERT_EQUALS(0, fs1.file.fsFileId());
+        ASSERT_EQUALS(1, fs2.file.fsFileId());
+    }
+
+    void importCompileCommands14() const { // #14156
+        REDIRECT;
+        constexpr char json[] =
+            R"([{
+                "arguments": [
+                  "/usr/bin/g++",
+                  "-DTFS_LINUX_MODULE_NAME=\"tfs_linux\"",
+                  "-g",
+                  "-c",
+                  "cli/main.cpp"
+                ],
+                "directory": "/home/daniel/cppcheck",
+                "file": "/home/daniel/cppcheck/cli/main.cpp",
+                "output": "/home/daniel/cppcheck/cli/main.o"
+            }])";
+        std::istringstream istr(json);
+        TestImporter importer;
+        ASSERT_EQUALS(true, importer.importCompileCommands(istr));
+        ASSERT_EQUALS(1, importer.fileSettings.size());
+        const FileSettings &fs = importer.fileSettings.front();
+        ASSERT_EQUALS("TFS_LINUX_MODULE_NAME=\"tfs_linux\"", fs.defines);
+    }
+
+    void importCompileCommands15() const { // #14306
+        REDIRECT;
+        constexpr char json[] =
+            R"([
+                 {
+                   "directory": "C:\\Users\\abcd\\efg\\hijk",
+                   "command": "gcc \"-Ipath\\123\" \"-c\" test.c",
+                   "file": "test.c",
+                   "output": "test.obj"
+                 }
+               ])";
+        std::istringstream istr(json);
+        TestImporter importer;
+        ASSERT_EQUALS(true, importer.importCompileCommands(istr));
+        ASSERT_EQUALS(1, importer.fileSettings.size());
+        const FileSettings &fs = importer.fileSettings.front();
+        ASSERT_EQUALS(1, fs.includePaths.size());
+        ASSERT_EQUALS("C:/Users/abcd/efg/hijk/path/123/", fs.includePaths.front());
+    }
+
     void importCompileCommandsArgumentsSection() const {
-        const char json[] = "[ { \"directory\": \"/tmp/\","
-                            "\"arguments\": [\"gcc\", \"-c\", \"src.c\"],"
-                            "\"file\": \"src.c\" } ]";
+        REDIRECT;
+        constexpr char json[] = "[ { \"directory\": \"/tmp/\","
+                                "\"arguments\": [\"gcc\", \"-c\", \"src.c\"],"
+                                "\"file\": \"src.c\" } ]";
         std::istringstream istr(json);
         TestImporter importer;
-        importer.importCompileCommands(istr);
+        ASSERT_EQUALS(true, importer.importCompileCommands(istr));
         ASSERT_EQUALS(1, importer.fileSettings.size());
-        ASSERT_EQUALS("/tmp/src.c", importer.fileSettings.begin()->filename);
+        ASSERT_EQUALS("/tmp/src.c", importer.fileSettings.cbegin()->filename());
     }
 
     void importCompileCommandsNoCommandSection() const {
-        const char json[] = "[ { \"directory\": \"/tmp/\","
-                            "\"file\": \"src.mm\" } ]";
+        REDIRECT;
+        constexpr char json[] = "[ { \"directory\": \"/tmp/\","
+                                "\"file\": \"src.mm\" } ]";
+        std::istringstream istr(json);
+        TestImporter importer;
+        ASSERT_EQUALS(false, importer.importCompileCommands(istr));
+        ASSERT_EQUALS(0, importer.fileSettings.size());
+        ASSERT_EQUALS(1, importer.errors.size());
+        ASSERT_EQUALS("no 'arguments' or 'command' field found in compilation database entry", importer.errors[0]);
+    }
+
+    void importCompileCommandsDirectoryMissing() const {
+        REDIRECT;
+        constexpr char json[] = "[ { \"file\": \"src.mm\" } ]";
+        std::istringstream istr(json);
+        TestImporter importer;
+        ASSERT_EQUALS(false, importer.importCompileCommands(istr));
+        ASSERT_EQUALS(0, importer.fileSettings.size());
+        ASSERT_EQUALS(1, importer.errors.size());
+        ASSERT_EQUALS("'directory' field in compilation database entry missing", importer.errors[0]);
+    }
+
+    void importCompileCommandsDirectoryInvalid() const {
+        REDIRECT;
+        constexpr char json[] = "[ { \"directory\": 123,"
+                                "\"file\": \"src.mm\" } ]";
         std::istringstream istr(json);
         TestImporter importer;
-        importer.importCompileCommands(istr);
+        ASSERT_EQUALS(false, importer.importCompileCommands(istr));
         ASSERT_EQUALS(0, importer.fileSettings.size());
+        ASSERT_EQUALS(1, importer.errors.size());
+        ASSERT_EQUALS("'directory' field in compilation database entry is not a string", importer.errors[0]);
     }
 
     void importCppcheckGuiProject() const {
-        const char xml[] = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
-                           "<project version=\"1\">\n"
-                           "    <root name=\".\"/>\n"
-                           "    <builddir>out1</builddir>\n"
-                           "    <analyze-all-vs-configs>true</analyze-all-vs-configs>\n"
-                           "    <includedir>\n"
-                           "        <dir name=\"lib/\"/>\n"
-                           "    </includedir>\n"
-                           "    <paths>\n"
-                           "        <dir name=\"cli/\"/>\n"
-                           "    </paths>\n"
-                           "    <exclude>\n"
-                           "        <path name=\"gui/temp/\"/>\n"
-                           "    </exclude>\n"
-                           "</project>\n";
+        REDIRECT;
+        constexpr char xml[] = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+                               "<project version=\"1\">\n"
+                               "    <root name=\".\"/>\n"
+                               "    <builddir>out1</builddir>\n"
+                               "    <analyze-all-vs-configs>true</analyze-all-vs-configs>\n"
+                               "    <includedir>\n"
+                               "        <dir name=\"lib/\"/>\n"
+                               "    </includedir>\n"
+                               "    <paths>\n"
+                               "        <dir name=\"cli/\"/>\n"
+                               "    </paths>\n"
+                               "    <exclude>\n"
+                               "        <path name=\"gui/temp/\"/>\n"
+                               "    </exclude>\n"
+                               "    <inline-suppression>true</inline-suppression>\n"
+                               "    <project-name>test test</project-name>\n"
+                               "</project>\n";
         std::istringstream istr(xml);
         Settings s;
+        Suppressions supprs;
         TestImporter project;
-        ASSERT_EQUALS(true, project.importCppcheckGuiProject(istr, &s));
+        ASSERT_EQUALS(true, project.importCppcheckGuiProject(istr, s, supprs));
         ASSERT_EQUALS(1, project.guiProject.pathNames.size());
         ASSERT_EQUALS("cli/", project.guiProject.pathNames[0]);
         ASSERT_EQUALS(1, s.includePaths.size());
         ASSERT_EQUALS("lib/", s.includePaths.front());
+        ASSERT_EQUALS(true, s.inlineSuppressions);
     }
+
+    void importCppcheckGuiProjectPremiumMisra() const {
+        REDIRECT;
+        constexpr char xml[] = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+                               "<project>\n"
+                               "    <paths>\n"
+                               "        <dir name=\"m1.c\"/>\n"
+                               "    </paths>\n"
+                               "    <addons>\n"
+                               "        <addon>misra</addon>\n"  // <- Premium: add premium argument misra-c-2012
+                               "    </addons>\n"
+                               "</project>";
+        std::istringstream istr(xml);
+        Settings s;
+        s.premium = true;
+        Suppressions supprs;
+        TestImporter project;
+        ASSERT_EQUALS(true, project.importCppcheckGuiProject(istr, s, supprs));
+        ASSERT_EQUALS("--misra-c-2012", s.premiumArgs);
+        ASSERT(s.addons.empty());
+    }
+
+    void ignorePaths() const {
+        FileSettings fs1{"foo/bar", Standards::Language::CPP, 0};
+        FileSettings fs2{"qwe/rty", Standards::Language::CPP, 0};
+        TestImporter project;
+        project.fileSettings = {std::move(fs1), std::move(fs2)};
+
+        project.ignorePaths({"*foo", "bar*"});
+        ASSERT_EQUALS(1, project.fileSettings.size());
+
+        project.ignorePaths({"foo/*"});
+        ASSERT_EQUALS(1, project.fileSettings.size());
+        ASSERT_EQUALS("qwe/rty", project.fileSettings.front().filename());
+
+        project.ignorePaths({ "*e/r*" });
+        ASSERT_EQUALS(0, project.fileSettings.size());
+    }
+
+    void testVcxprojUnicode() const
+    {
+        const char vcxproj[] = R"-(
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Configuration">
+    <!-- Only to test that the last configuration entry overwrites this -->
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>NotSet</CharacterSet>
+    <UseOfMfc>Static</UseOfMfc>
+  </PropertyGroup>
+  <ItemGroup>
+    <ClCompile Include="main.cpp" />
+  </ItemGroup>
+</Project>
+)-";
+        tinyxml2::XMLDocument doc;
+        ASSERT_EQUALS(tinyxml2::XML_SUCCESS, doc.Parse(vcxproj, sizeof(vcxproj)));
+        TestImporter project;
+        std::map<std::string, std::string, cppcheck::stricmp> variables;
+        std::vector<TestImporter::SharedItemsProject> cache;
+        ASSERT_EQUALS(project.importVcxproj("test.vcxproj", doc, variables, {}, {}, cache), true);
+        ASSERT_EQUALS(project.fileSettings.size(), 2);
+        ASSERT(project.fileSettings.front().defines.find(";UNICODE=1;") != std::string::npos);
+        ASSERT(project.fileSettings.front().defines.find(";_UNICODE=1") != std::string::npos);
+        ASSERT(project.fileSettings.front().defines.find(";_UNICODE=1;") == std::string::npos); // No duplicates
+        ASSERT_EQUALS(project.fileSettings.front().useMfc, false);
+        ASSERT(project.fileSettings.back().defines.find(";UNICODE=1;") == std::string::npos);
+        ASSERT(project.fileSettings.back().defines.find(";_UNICODE=1") == std::string::npos);
+        ASSERT_EQUALS(project.fileSettings.back().useMfc, true);
+    }
+
+    void testCollectArgs1() const
+    {
+        std::vector<std::string> args;
+        const std::string cmd = "  gcc -o main main.c  ";
+        const std::string error = TestImporter::collectArgs(cmd, args);
+
+        ASSERT_EQUALS("", error);
+        ASSERT_EQUALS(4, args.size());
+        ASSERT_EQUALS("gcc", args[0]);
+        ASSERT_EQUALS("-o", args[1]);
+        ASSERT_EQUALS("main", args[2]);
+        ASSERT_EQUALS("main.c", args[3]);
+    }
+
+    void testCollectArgs2() const
+    {
+        std::vector<std::string> args;
+        const std::string cmd = "gcc -o main \"directory with space\"/main.c";
+        const std::string error = TestImporter::collectArgs(cmd, args);
+
+        ASSERT_EQUALS("", error);
+        ASSERT_EQUALS(4, args.size());
+        ASSERT_EQUALS("gcc", args[0]);
+        ASSERT_EQUALS("-o", args[1]);
+        ASSERT_EQUALS("main", args[2]);
+        ASSERT_EQUALS("directory with space/main.c", args[3]);
+    }
+
+    void testCollectArgs3() const
+    {
+        std::vector<std::string> args;
+        const std::string cmd = "gcc -o main directory\\ with\\ space/main.c";
+        const std::string error = TestImporter::collectArgs(cmd, args);
+
+        ASSERT_EQUALS("", error);
+        ASSERT_EQUALS(4, args.size());
+        ASSERT_EQUALS("gcc", args[0]);
+        ASSERT_EQUALS("-o", args[1]);
+        ASSERT_EQUALS("main", args[2]);
+        ASSERT_EQUALS("directory with space/main.c", args[3]);
+    }
+
+    void testCollectArgs4() const
+    {
+        std::vector<std::string> args;
+        const std::string cmd = "gcc -o main \'directory with space\'/main.c";
+        const std::string error = TestImporter::collectArgs(cmd, args);
+
+        ASSERT_EQUALS("", error);
+        ASSERT_EQUALS(4, args.size());
+        ASSERT_EQUALS("gcc", args[0]);
+        ASSERT_EQUALS("-o", args[1]);
+        ASSERT_EQUALS("main", args[2]);
+        ASSERT_EQUALS("directory with space/main.c", args[3]);
+    }
+
+    void testCollectArgs5() const
+    {
+        std::vector<std::string> args;
+        const std::string cmd = "gcc -o main directory_with_quote\\\"/main.c";
+        const std::string error = TestImporter::collectArgs(cmd, args);
+
+        ASSERT_EQUALS("", error);
+        ASSERT_EQUALS(4, args.size());
+        ASSERT_EQUALS("gcc", args[0]);
+        ASSERT_EQUALS("-o", args[1]);
+        ASSERT_EQUALS("main", args[2]);
+        ASSERT_EQUALS("directory_with_quote\"/main.c", args[3]);
+    }
+
+    void testCollectArgs6() const
+    {
+        std::vector<std::string> args;
+        const std::string cmd = "gcc -o main windows\\\\path\\\\main.c";
+        const std::string error = TestImporter::collectArgs(cmd, args);
+
+        ASSERT_EQUALS("", error);
+        ASSERT_EQUALS(4, args.size());
+        ASSERT_EQUALS("gcc", args[0]);
+        ASSERT_EQUALS("-o", args[1]);
+        ASSERT_EQUALS("main", args[2]);
+        ASSERT_EQUALS("windows\\path\\main.c", args[3]);
+    }
+
+    void testCollectArgs7() const
+    {
+        std::vector<std::string> args;
+        const std::string cmd = "gcc -o main \"non-terminated-quote/main.c";
+        const std::string error = TestImporter::collectArgs(cmd, args);
+
+        ASSERT_EQUALS("Missing closing quote in command string", error);
+    }
+
+    // TODO: test fsParseCommand()
+
+    // TODO: test vcxproj conditions
+    /*
+        <?xml version="1.0" encoding="utf-8"?>
+        <Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+        <ItemGroup Label="ProjectConfigurations">
+        <ProjectConfiguration Include="Debug|x64">
+        <Configuration>Debug</Configuration>
+        <Platform>x64</Platform>
+        </ProjectConfiguration>
+        </ItemGroup>
+        <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+        <ClCompile>
+        <PreprocessorDefinitions>CPPCHECKLIB_IMPORT</PreprocessorDefinitions>
+        </ClCompile>
+        </ItemDefinitionGroup>
+        <ItemGroup>
+        <ClCompile Include="main.c" />
+        </ItemGroup>
+        </Project>
+     */
 };
 
 REGISTER_TEST(TestImportProject)
diff --git a/test/testincompletestatement.cpp b/test/testincompletestatement.cpp
index f0dc7f87c75..7a1fbdb2dab 100644
--- a/test/testincompletestatement.cpp
+++ b/test/testincompletestatement.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,57 +17,52 @@
  */
 
 #include "checkother.h"
+#include "errortypes.h"
+#include "helpers.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
+#include "fixture.h"
 
-#include <simplecpp.h>
-#include <map>
-#include <vector>
+#include <cstddef>
+#include <string>
 
 class TestIncompleteStatement : public TestFixture {
 public:
-    TestIncompleteStatement() : TestFixture("TestIncompleteStatement") {
-    }
+    TestIncompleteStatement() : TestFixture("TestIncompleteStatement") {}
 
 private:
-    Settings settings;
-
-    void check(const char code[], bool inconclusive = false) {
-        // Clear the error buffer..
-        errout.str("");
+    const Settings settings = settingsBuilder().severity(Severity::warning).library("std.cfg").build();
+    const Settings settings_i = settingsBuilder(settings).certainty(Certainty::inconclusive).build();
 
-        settings.inconclusive = inconclusive;
+    struct CheckOptions
+    {
+        bool inconclusive = false;
+        bool cpp = true;
+    };
 
-        // Raw tokens..
-        std::vector<std::string> files(1, "test.cpp");
-        std::istringstream istr(code);
-        const simplecpp::TokenList tokens1(istr, files, files[0]);
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
+        const Settings &settings1 = options.inconclusive ? settings_i : settings;
 
-        // Preprocess..
-        simplecpp::TokenList tokens2(files);
-        std::map<std::string, simplecpp::TokenList*> filedata;
-        simplecpp::preprocess(tokens2, tokens1, files, filedata, simplecpp::DUI());
+        SimpleTokenizer2 tokenizer(settings1, *this, code, options.cpp ? "test.cpp" : "test.c");
 
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        tokenizer.createTokens(&tokens2);
-        tokenizer.simplifyTokens1("");
+        ASSERT_LOC(tokenizer.simplifyTokens1(""), file, line);
 
         // Check for incomplete statements..
-        CheckOther checkOther(&tokenizer, &settings, this);
+        CheckOther checkOther(&tokenizer, &settings1, this);
         checkOther.checkIncompleteStatement();
     }
 
-    void run() OVERRIDE {
-        settings.addEnabled("warning");
-
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(test1);
         TEST_CASE(test2);
         TEST_CASE(test3);
         TEST_CASE(test4);
         TEST_CASE(test5);
         TEST_CASE(test6);
+        TEST_CASE(test7);
         TEST_CASE(test_numeric);
         TEST_CASE(void0); // #6327: No fp for statement "(void)0;"
         TEST_CASE(intarray);
@@ -83,11 +78,14 @@ class TestIncompleteStatement : public TestFixture {
         TEST_CASE(cpp11init3);          // #8995
         TEST_CASE(block);               // ({ do_something(); 0; })
         TEST_CASE(mapindex);
-        TEST_CASE(commaoperator);
+        TEST_CASE(commaoperator1);
+        TEST_CASE(commaoperator2);
         TEST_CASE(redundantstmts);
         TEST_CASE(vardecl);
         TEST_CASE(archive);             // ar & x
         TEST_CASE(ast);
+        TEST_CASE(oror);                // dostuff() || x=32;
+        TEST_CASE(functioncall);
     }
 
     void test1() {
@@ -97,7 +95,7 @@ class TestIncompleteStatement : public TestFixture {
               "    \"abc\";\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void test2() {
@@ -106,7 +104,7 @@ class TestIncompleteStatement : public TestFixture {
               "    \"abc\";\n"
               "}");
 
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Redundant code: Found a statement that begins with string constant.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Redundant code: Found a statement that begins with string constant. [constStatement]\n", errout_str());
     }
 
     void test3() {
@@ -115,7 +113,7 @@ class TestIncompleteStatement : public TestFixture {
               "    const char *str[] = { \"abc\" };\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void test4() {
@@ -129,7 +127,7 @@ class TestIncompleteStatement : public TestFixture {
               "};\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void test5() {
@@ -138,7 +136,7 @@ class TestIncompleteStatement : public TestFixture {
               "    50;\n"
               "}");
 
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Redundant code: Found a statement that begins with numeric constant.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Redundant code: Found a statement that begins with numeric constant. [constStatement]\n", errout_str());
     }
 
     void test6() {
@@ -150,35 +148,49 @@ class TestIncompleteStatement : public TestFixture {
               "}");
     }
 
-    void test_numeric() {
-        check("struct P\n"
-              "{\n"
-              "double a;\n"
-              "double b;\n"
+    void test7() { // #9335
+        check("namespace { std::string S = \"\"; }\n"
+              "\n"
+              "class C {\n"
+              "public:\n"
+              "  explicit C(const std::string& s);\n"
               "};\n"
-              "void f()\n"
-              "{\n"
-              "const P values[2] =\n"
-              "{\n"
-              "{ 346.1,114.1 }, { 347.1,111.1 }\n"
+              "\n"
+              "void f() {\n"
+              "  for (C c(S); ; ) {\n"
+              "    (void)c;\n"
+              "  }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void test_numeric() {
+        check("struct P {\n"
+              "    double a;\n"
+              "    double b;\n"
               "};\n"
+              "void f() {\n"
+              "    const P values[2] =\n"
+              "    {\n"
+              "        { 346.1,114.1 }, { 347.1,111.1 }\n"
+              "    };\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void void0() { // #6327
         check("void f() { (void*)0; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("#define X  0\n"
               "void f() { X; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void intarray() {
         check("int arr[] = { 100/2, 1*100 };");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void structarraynull() {
@@ -186,7 +198,7 @@ class TestIncompleteStatement : public TestFixture {
               "    { 100/2, 1*100 }\n"
               "    { 90, 70 }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void structarray() {
@@ -194,14 +206,14 @@ class TestIncompleteStatement : public TestFixture {
               "    { 100/2, 1*100 }\n"
               "    { 90, 70 }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void conditionalcall() {
         check("void f() {\n"
               "    0==x ? X() : Y();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void structinit() {
@@ -209,7 +221,7 @@ class TestIncompleteStatement : public TestFixture {
         check("void f() {\n"
               "    ABC abc{1,2,3};\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6260 - C++11 array initialization
         check("void foo() {\n"
@@ -217,30 +229,30 @@ class TestIncompleteStatement : public TestFixture {
               "        {\"b\", \"\"},\n"
               "    };\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #2482 - false positive for empty struct
         check("struct A {};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #4387 - C++11 initializer list
         check("A::A() : abc{0} {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #5042 - C++11 initializer list
         check("A::A() : abc::def<int>{0} {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #4503 - vector init
         check("void f() { vector<int> v{1}; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void returnstruct() {
         check("struct s foo() {\n"
               "    return (struct s){0,0};\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #4754
         check("unordered_map<string, string>  foo() {\n"
@@ -249,19 +261,30 @@ class TestIncompleteStatement : public TestFixture {
               "        {\"happy\", \"sad\"}\n"
               "    };\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct s foo() {\n"
               "  return (struct s){0};\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void cast() {
         check("void f() {\n"
               "    ((struct foo *)(0x1234))->xy = 1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool f(const std::exception& e) {\n" // #10918
+              "    try {\n"
+              "        dynamic_cast<const InvalidTypeException&>(e);\n"
+              "        return true;\n"
+              "    }\n"
+              "    catch (...) {\n"
+              "        return false;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void increment() {
@@ -269,64 +292,130 @@ class TestIncompleteStatement : public TestFixture {
               "    int x = 1;\n"
               "    x++, x++;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void cpp11init() {
         check("void f() {\n"
               "    int x{1};\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::vector<int> f(int* p) {\n"
+              "    return std::vector<int>({ p[0] });\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void cpp11init2() {
         check("x<string> handlers{\n"
               "  { \"mode2\", []() { return 2; } },\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void cpp11init3() {
         check("struct A { void operator()(int); };\n"
               "void f() {\n"
               "A{}(0);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("template<class> struct A { void operator()(int); };\n"
               "void f() {\n"
               "A<int>{}(0);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void block() {
         check("void f() {\n"
               "    ({ do_something(); 0; });\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "out:\n"
               "    ({ do_something(); 0; });\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void mapindex() {
         check("void f() {\n"
               "  map[{\"1\",\"2\"}]=0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
-    // #8827
-    void commaoperator() {
-        check("void foo(int,const char*,int);\n"
+    void commaoperator1() {
+        check("void foo(int,const char*,int);\n" // #8827
               "void f(int value) {\n"
               "    foo(42,\"test\",42),(value&42);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:22]: (warning) Found suspicious operator ',', result is not used. [constStatement]\n", errout_str());
+
+        check("int f() {\n" // #11257
+              "    int y;\n"
+              "    y = (3, 4);\n"
+              "    return y;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:11]: (warning) Found suspicious operator ',', result is not used. [constStatement]\n", errout_str());
+    }
+
+    void commaoperator2() {
+        check("void f() {\n"
+              "    for(unsigned int a=0, b; a<10; a++ ) {}\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Found suspicious operator ','\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void g();\n" // #10952
+              "bool f() {\n"
+              "    return (void)g(), false;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int a, int b, int c, int d) {\n"
+              "    Eigen::Vector4d V;\n"
+              "    V << a, b, c, d;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { Eigen::Vector4d V; };\n"
+              "struct T { int a, int b, int c, int d; };\n"
+              "void f(S& s, const T& t) {\n"
+              "    s.V << t.a, t.b, t.c, t.d;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { Eigen::Vector4d V[2]; };\n"
+              "void f(int a, int b, int c, int d) {\n"
+              "    S s[1];\n"
+              "    s[0].V[1] << a, b, c, d;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    a.b[4][3].c()->d << x , y, z;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct V {\n"
+              "    Eigen::Vector3d& operator[](int i) { return v[i]; }\n"
+              "    void f(int a, int b, int c);\n"
+              "    Eigen::Vector3d v[1];\n"
+              "};\n"
+              "void V::f(int a, int b, int c) {\n"
+              "    (*this)[0] << a, b, c;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n" // #11359
+              "    struct S {\n"
+              "        S(int x, int y) {}\n"
+              "    } s(1, 2);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     // #8451
@@ -340,65 +429,403 @@ class TestIncompleteStatement : public TestFixture {
               "    (!x);\n"
               "    (unsigned int)!x;\n"
               "    ~x;\n"
-              "}\n", true);
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Redundant code: Found a statement that begins with numeric constant.\n"
-                      "[test.cpp:3]: (warning) Redundant code: Found a statement that begins with numeric constant.\n"
-                      "[test.cpp:4]: (warning) Redundant code: Found a statement that begins with string constant.\n"
-                      "[test.cpp:5]: (warning) Redundant code: Found a statement that begins with string constant.\n"
-                      "[test.cpp:6]: (warning, inconclusive) Found suspicious operator '!'\n"
-                      "[test.cpp:7]: (warning, inconclusive) Found suspicious operator '!'\n"
-                      "[test.cpp:9]: (warning, inconclusive) Found suspicious operator '~'\n", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning) Redundant code: Found a statement that begins with numeric constant. [constStatement]\n"
+                      "[test.cpp:3:6]: (warning) Redundant code: Found a statement that begins with numeric constant. [constStatement]\n"
+                      "[test.cpp:4:5]: (warning) Redundant code: Found a statement that begins with numeric constant. [constStatement]\n"
+                      "[test.cpp:5:6]: (warning) Redundant code: Found a statement that begins with numeric constant. [constStatement]\n"
+                      "[test.cpp:6:5]: (warning, inconclusive) Found suspicious operator '!', result is not used. [constStatement]\n"
+                      "[test.cpp:7:6]: (warning, inconclusive) Found suspicious operator '!', result is not used. [constStatement]\n"
+                      "[test.cpp:8:5]: (warning) Redundant code: Found unused cast of expression '!x'. [constStatement]\n"
+                      "[test.cpp:9:5]: (warning, inconclusive) Found suspicious operator '~', result is not used. [constStatement]\n",
+                      errout_str());
+
+        check("void f1(int x) { x; }", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:1:18]: (warning) Unused variable value 'x' [constStatement]\n", errout_str());
+
+        check("void f() { if (Type t; g(t)) {} }"); // #9776
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int x) { static_cast<unsigned>(x); }");
+        ASSERT_EQUALS("[test.cpp:1:38]: (warning) Redundant code: Found unused cast of expression 'x'. [constStatement]\n", errout_str());
+
+        check("void f(int x, int* p) {\n"
+              "    static_cast<void>(x);\n"
+              "    (void)x;\n"
+              "    static_cast<void*>(p);\n"
+              "    (void*)p;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() { false; }"); // #10856
+        ASSERT_EQUALS("[test.cpp:1:12]: (warning) Redundant code: Found a statement that begins with bool constant. [constStatement]\n", errout_str());
+
+        check("void f(int i) {\n"
+              "    (float)(char)i;\n"
+              "    static_cast<float>((char)i);\n"
+              "    (char)static_cast<float>(i);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning) Redundant code: Found unused cast of expression 'i'. [constStatement]\n"
+                      "[test.cpp:3:23]: (warning) Redundant code: Found unused cast of expression 'i'. [constStatement]\n"
+                      "[test.cpp:4:5]: (warning) Redundant code: Found unused cast of expression 'i'. [constStatement]\n",
+                      errout_str());
+
+        check("namespace M {\n"
+              "    namespace N { typedef char T; }\n"
+              "}\n"
+              "void f(int i) {\n"
+              "    (M::N::T)i;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) Redundant code: Found unused cast of expression 'i'. [constStatement]\n", errout_str());
+
+        check("void f(int (g)(int a, int b)) {\n" // #10873
+              "    int p = 0, q = 1;\n"
+              "    (g)(p, q);\n"
+              "}\n"
+              "void f() {\n"
+              "  char buf[10];\n"
+              "  (sprintf)(buf, \"%d\", 42);\n"
+              "  (printf)(\"abc\");\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S; struct T; struct U;\n"
+              "void f() {\n"
+              "    T t;\n"
+              "    (S)(U)t;\n"
+              "    (S)static_cast<U>(t);\n"
+              "    static_cast<S>((U)t);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f1(int x) { x; }", true);
-        ASSERT_EQUALS("[test.cpp:1]: (warning) Unused variable value 'x'\n", errout.str());
+        check("void f(bool b) { b ? true : false; }\n"); // #10865
+        ASSERT_EQUALS("[test.cpp:1:20]: (warning) Redundant code: Found unused result of ternary operator. [constStatement]\n", errout_str());
 
+        check("struct S { void (*f)() = nullptr; };\n" // #10877
+              "void g(S* s) {\n"
+              "    (s->f == nullptr) ? nullptr : (s->f(), nullptr);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(bool b) {\n"
+              "    g() ? true : false;\n"
+              "    true ? g() : false;\n"
+              "    false ? true : g();\n"
+              "    g(b ? true : false, 1);\n"
+              "    C c{ b ? true : false, 1 };\n"
+              "    b = (b ? true : false);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int i) {\n"
+              "    for (i; ;) {}\n"
+              "    for ((long)i; ;) {}\n"
+              "    for (1; ;) {}\n"
+              "    for (true; ;) {}\n"
+              "    for ('a'; ;) {}\n"
+              "    for (L'b'; ;) {}\n"
+              "    for (\"x\"; ;) {}\n"
+              "    for (L\"y\"; ;) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:10]: (warning) Unused variable value 'i' [constStatement]\n"
+                      "[test.cpp:3:10]: (warning) Redundant code: Found unused cast of expression 'i'. [constStatement]\n"
+                      "[test.cpp:4:10]: (warning) Redundant code: Found a statement that begins with numeric constant. [constStatement]\n"
+                      "[test.cpp:5:10]: (warning) Redundant code: Found a statement that begins with bool constant. [constStatement]\n"
+                      "[test.cpp:6:10]: (warning) Redundant code: Found a statement that begins with character constant. [constStatement]\n"
+                      "[test.cpp:7:10]: (warning) Redundant code: Found a statement that begins with character constant. [constStatement]\n"
+                      "[test.cpp:8:10]: (warning) Redundant code: Found a statement that begins with string constant. [constStatement]\n"
+                      "[test.cpp:9:10]: (warning) Redundant code: Found a statement that begins with string constant. [constStatement]\n",
+                      errout_str());
+
+        check("struct S { bool b{}; };\n"
+              "struct T {\n"
+              "    S s[2];\n"
+              "    void g();\n"
+              "};\n"
+              "void f(const S& r, const S* p) {\n"
+              "    r.b;\n"
+              "    p->b;\n"
+              "    S s;\n"
+              "    (s.b);\n"
+              "    T t, u[2];\n"
+              "    t.s[1].b;\n"
+              "    t.g();\n"
+              "    u[0].g();\n"
+              "    u[1].s[0].b;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:7:6]: (warning) Redundant code: Found unused member access. [constStatement]\n"
+                      "[test.cpp:8:6]: (warning) Redundant code: Found unused member access. [constStatement]\n"
+                      "[test.cpp:10:7]: (warning) Redundant code: Found unused member access. [constStatement]\n"
+                      "[test.cpp:12:11]: (warning) Redundant code: Found unused member access. [constStatement]\n"
+                      "[test.cpp:15:14]: (warning) Redundant code: Found unused member access. [constStatement]\n",
+                      errout_str());
+
+        check("struct S { int a[2]{}; };\n"
+              "struct T { S s; };\n"
+              "void f() {\n"
+              "    int i[2];\n"
+              "    i[0] = 0;\n"
+              "    i[0];\n" // <--
+              "    S s[1];\n"
+              "    s[0].a[1];\n" // <--
+              "    T t;\n"
+              "    t.s.a[1];\n" // <--
+              "    int j[2][2][1] = {};\n"
+              "    j[0][0][0];\n" // <--
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:6]: (warning) Redundant code: Found unused array access. [constStatement]\n"
+                      "[test.cpp:8:11]: (warning) Redundant code: Found unused array access. [constStatement]\n"
+                      "[test.cpp:10:10]: (warning) Redundant code: Found unused array access. [constStatement]\n"
+                      "[test.cpp:12:6]: (warning) Redundant code: Found unused array access. [constStatement]\n",
+                      errout_str());
+
+        check("void g(std::map<std::string, std::string>& map) {\n"
+              "    int j[2]{};\n"
+              "    int k[2] = {};\n"
+              "    int l[]{ 1, 2 };\n"
+              "    int m[] = { 1, 2 };\n"
+              "    h(0, j[0], 1);\n"
+              "    C c{ 0, j[0], 1 };\n"
+              "    c[0];\n"
+              "    int j[2][2][2] = {};\n"
+              "    j[h()][0][0];\n"
+              "    j[0][h()][0];\n"
+              "    j[0][0][h()];\n"
+              "    std::map<std::string, int> M;\n"
+              "    M[\"abc\"];\n"
+              "    map[\"abc\"];\n" // #10928
+              "    std::auto_ptr<Int> app[4];" // #10919
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { void* p; };\n" // #10875
+              "void f(S s) {\n"
+              "    delete (int*)s.p;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct T {\n" // #10874
+              "    T* p;\n"
+              "};\n"
+              "void f(T* t) {\n"
+              "    for (decltype(t->p) (c) = t->p; ;) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int i, std::vector<int*> v);\n" // #10880
+              "void g() {\n"
+              "    f(1, { static_cast<int*>(nullptr) });\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { int i; };\n" // #10882
+              "enum E {};\n"
+              "void f(const S* s) {\n"
+              "    E e = (E)!s->i;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int* p) {\n" // #10932
+              "    int& r(*p[0]);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { int i; };\n" // #10917
+              "bool f(S s) {\n"
+              "    return [](int i) { return i > 0; }(s.i);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("extern int (*p);\n" // #10936
+              "void f() {\n"
+              "    for (int i = 0; ;) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("class T {};\n" // #10849
+              "void f() {\n"
+              "    auto g = [](const T* t) -> int {\n"
+              "        const T* u{}, * v{};\n"
+              "        return 0;\n"
+              "    };\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("namespace N {\n" // #10876
+              "    template <class R, class S, void(*T)(R&, float, S)>\n"
+              "    inline void f() {}\n"
+              "    template<class T>\n"
+              "    void g(T& c) {\n"
+              "        for (typename T::iterator v = c.begin(); v != c.end(); ++v) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::string a, std::string b) {\n" // #7529
+              "    const std::string s = \" x \" + a;\n"
+              "    +\" y = \" + b;\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:14]: (warning, inconclusive) Found suspicious operator '+', result is not used. [constStatement]\n", errout_str());
+
+        check("void f() {\n"
+              "    *new int;\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning, inconclusive) Found suspicious operator '*', result is not used. [constStatement]\n", errout_str());
+
+        check("void f(int x, int y) {\n" // #12525
+              "    x * y;\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:2:7]: (warning, inconclusive) Found suspicious operator '*', result is not used. [constStatement]\n", errout_str());
+
+        check("void f() {\n" // #5475
+              "    std::string(\"a\") + \"a\";\n"
+              "}\n"
+              "void f(std::string& a) {\n"
+              "    a.erase(3) + \"suf\";\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:2:22]: (warning, inconclusive) Found suspicious operator '+', result is not used. [constStatement]\n"
+                      "[test.cpp:5:16]: (warning, inconclusive) Found suspicious operator '+', result is not used. [constStatement]\n",
+                      errout_str());
+
+        check("void f(XMLElement& parent) {\n" // #11234
+              "    auto** elem = &parent.firstChild;\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n" // #11301
+              "    NULL;\n"
+              "    nullptr;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning) Redundant code: Found a statement that begins with NULL constant. [constStatement]\n"
+                      "[test.cpp:3:5]: (warning) Redundant code: Found a statement that begins with NULL constant. [constStatement]\n",
+                      errout_str());
+
+        check("struct S { int i; };\n" // #6504
+              "void f(S* s) {\n"
+              "    (*s).i;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:9]: (warning) Redundant code: Found unused member access. [constStatement]\n", errout_str());
+
+        check("int a[2];\n" // #11370
+              "void f() {\n"
+              "    auto g = [](decltype(a[0]) i) {};\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("enum E { E0 };\n"
+              "void f() {\n"
+              "    E0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Redundant code: Found a statement that begins with enumerator constant. [constStatement]\n",
+                      errout_str());
+
+        check("void f(int* a) {\n" // #12534
+              "    a[a[3]];\n"
+              "    a[a[g()]];\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:6]: (warning) Redundant code: Found unused array access. [constStatement]\n",
+                      errout_str());
+
+        check("void f() {\n" // #13153
+              "    []() {} ();\n"
+              "    []() {};\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Redundant code: Found unused lambda. [constStatement]\n",
+                      errout_str());
+
+        check("int main() {\n" // #13177
+              "    sizeof(int);\n"
+              "    alignof(long double*);\n"
+              "    noexcept(int());\n"
+              "    typeid(int);\n"
+              "    return(0);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:11]: (warning) Redundant code: Found unused 'sizeof' expression. [constStatement]\n"
+                      "[test.cpp:3:12]: (warning) Redundant code: Found unused 'alignof' expression. [constStatement]\n"
+                      "[test.cpp:4:13]: (warning) Redundant code: Found unused 'noexcept' expression. [constStatement]\n"
+                      "[test.cpp:5:11]: (warning) Redundant code: Found unused 'typeid' expression. [constStatement]\n",
+                      errout_str());
+
+        check("void f() {\n" // #14044
+              "    g<sizeof(wchar_t)>();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void vardecl() {
         // #8984
-        check("void f() { a::b *c = d(); }", true);
-        ASSERT_EQUALS("", errout.str());
+        check("void f() { a::b *c = d(); }", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f() { std::vector<b> *c; }", true);
-        ASSERT_EQUALS("", errout.str());
+        check("void f() { std::vector<b> *c; }", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f() { a::b &c = d(); }", true);
-        ASSERT_EQUALS("", errout.str());
+        check("void f() { a::b &c = d(); }", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f() { std::vector<b> &c; }", true);
-        ASSERT_EQUALS("", errout.str());
+        check("void f() { std::vector<b> &c; }", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f() { a::b &&c = d(); }", true);
-        ASSERT_EQUALS("", errout.str());
+        check("void f() { a::b &&c = d(); }", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f() { std::vector<b> &&c; }", true);
-        ASSERT_EQUALS("", errout.str());
+        check("void f() { std::vector<b> &&c; }", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f() { char * const * a, * const * b; }", true);
-        ASSERT_EQUALS("", errout.str());
+        check("void f() { char * const * a, * const * b; }", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f() { char * const * a = 0, * volatile restrict * b; }", true);
-        ASSERT_EQUALS("", errout.str());
+        check("void f() { char * const * a = 0, * volatile restrict * b; }", dinit(CheckOptions, $.inconclusive = true, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f() { char * const * a = 0, * volatile const * b; }", true);
-        ASSERT_EQUALS("", errout.str());
+        check("void f() { char * const * a = 0, * volatile const * b; }", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void archive() {
         check("void f(Archive &ar) {\n"
               "  ar & x;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int ar) {\n"
               "  ar & x;\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Found suspicious operator '&'\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:2:6]: (warning, inconclusive) Found suspicious operator '&', result is not used. [constStatement]\n", errout_str());
     }
 
     void ast() {
-        check("struct c { void a() const { for (int x=0; x;); } };", true);
-        ASSERT_EQUALS("", errout.str());
+        check("struct c { void a() const { for (int x=0; x;); } };", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void oror() {
+        check("void foo() {\n"
+              "    params_given (params, \"overrides\") || (overrides = \"1\");\n"
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::ifstream& file) {\n" // #10930
+              "    int a{}, b{};\n"
+              "    (file >> a) || (file >> b);\n"
+              "    (file >> a) && (file >> b);\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void functioncall() {
+        check("void g();\n" // #13794
+              "void f() {\n"
+              "    g;\n"
+              "    exit;\n"
+              "    std::free;\n"
+              "    ::std::terminate;\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Redundant code: Found unused function. [constStatement]\n"
+                      "[test.cpp:4:5]: (warning) Redundant code: Found unused function. [constStatement]\n"
+                      "[test.cpp:5:8]: (warning) Redundant code: Found unused function. [constStatement]\n"
+                      "[test.cpp:6:10]: (warning) Redundant code: Found unused function. [constStatement]\n",
+                      errout_str());
     }
 };
 
diff --git a/test/testinternal.cpp b/test/testinternal.cpp
index a46516cefb5..009129c5dc1 100644
--- a/test/testinternal.cpp
+++ b/test/testinternal.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,47 +18,46 @@
 
 #ifdef CHECK_INTERNAL
 
-#include "tokenize.h"
 #include "checkinternal.h"
-#include "testsuite.h"
+#include "fixture.h"
+#include "helpers.h"
+#include "settings.h"
 
+#include <cstddef>
 
 class TestInternal : public TestFixture {
 public:
-    TestInternal() : TestFixture("TestInternal") {
-    }
+    TestInternal() : TestFixture("TestInternal") {}
 
 private:
-    Settings settings;
-
-    void run() OVERRIDE {
-        settings.addEnabled("internal");
-
-        TEST_CASE(simplePatternInTokenMatch)
-        TEST_CASE(complexPatternInTokenSimpleMatch)
-        TEST_CASE(simplePatternSquareBrackets)
-        TEST_CASE(simplePatternAlternatives)
-        TEST_CASE(missingPercentCharacter)
-        TEST_CASE(unknownPattern)
-        TEST_CASE(redundantNextPrevious)
+    /*const*/ Settings settings;
+
+    void run() override {
+        ASSERT_EQUALS("", settings.addEnabled("internal"));
+
+        mNewTemplate = true;
+        TEST_CASE(simplePatternInTokenMatch);
+        TEST_CASE(complexPatternInTokenSimpleMatch);
+        TEST_CASE(simplePatternSquareBrackets);
+        TEST_CASE(simplePatternAlternatives);
+        TEST_CASE(missingPercentCharacter);
+        TEST_CASE(unknownPattern);
+        TEST_CASE(redundantNextPrevious);
         TEST_CASE(internalError);
         TEST_CASE(orInComplexPattern);
         TEST_CASE(extraWhitespace);
         TEST_CASE(checkRedundantTokCheck);
     }
 
-    void check(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
-
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check..
-        CheckInternal checkInternal;
-        checkInternal.runChecks(&tokenizer, &settings, this);
+        runChecks<CheckInternal>(tokenizer, this);
     }
 
     void simplePatternInTokenMatch() {
@@ -66,25 +65,25 @@ class TestInternal : public TestFixture {
               "    const Token *tok;\n"
               "    Token::Match(tok, \";\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Found simple pattern inside Token::Match() call: \";\"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Found simple pattern inside Token::Match() call: \";\" [simplePatternError]\n", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::Match(tok, \"%type%\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::Match(tok, \"%or%\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Found simple pattern inside Token::Match() call: \"%or%\"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Found simple pattern inside Token::Match() call: \"%or%\" [simplePatternError]\n", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::findmatch(tok, \";\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Found simple pattern inside Token::findmatch() call: \";\"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Found simple pattern inside Token::findmatch() call: \";\" [simplePatternError]\n", errout_str());
     }
 
     void complexPatternInTokenSimpleMatch() {
@@ -92,31 +91,31 @@ class TestInternal : public TestFixture {
               "    const Token *tok;\n"
               "    Token::simpleMatch(tok, \"%type%\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Found complex pattern inside Token::simpleMatch() call: \"%type%\"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Found complex pattern inside Token::simpleMatch() call: \"%type%\" [complexPatternError]\n", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::findsimplematch(tok, \"%type%\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Found complex pattern inside Token::findsimplematch() call: \"%type%\"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Found complex pattern inside Token::findsimplematch() call: \"%type%\" [complexPatternError]\n", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::findsimplematch(tok, \"} !!else\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Found complex pattern inside Token::findsimplematch() call: \"} !!else\"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Found complex pattern inside Token::findsimplematch() call: \"} !!else\" [complexPatternError]\n", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::findsimplematch(tok, \"foobar\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::findsimplematch(tok, \"%\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplePatternSquareBrackets() {
@@ -124,37 +123,37 @@ class TestInternal : public TestFixture {
               "    const Token *tok;\n"
               "    Token::simpleMatch(tok, \"[\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::simpleMatch(tok, \"[ ]\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::simpleMatch(tok, \"[]\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Found complex pattern inside Token::simpleMatch() call: \"[]\"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Found complex pattern inside Token::simpleMatch() call: \"[]\" [complexPatternError]\n", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::simpleMatch(tok, \"] [\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::simpleMatch(tok, \"] [ [abc]\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Found complex pattern inside Token::simpleMatch() call: \"] [ [abc]\"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Found complex pattern inside Token::simpleMatch() call: \"] [ [abc]\" [complexPatternError]\n", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::simpleMatch(tok, \"[.,;]\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Found complex pattern inside Token::simpleMatch() call: \"[.,;]\"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Found complex pattern inside Token::simpleMatch() call: \"[.,;]\" [complexPatternError]\n", errout_str());
     }
 
     void simplePatternAlternatives() {
@@ -162,31 +161,31 @@ class TestInternal : public TestFixture {
               "    const Token *tok;\n"
               "    Token::simpleMatch(tok, \"||\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::simpleMatch(tok, \"|\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::simpleMatch(tok, \"a|b\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Found complex pattern inside Token::simpleMatch() call: \"a|b\"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Found complex pattern inside Token::simpleMatch() call: \"a|b\" [complexPatternError]\n", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::simpleMatch(tok, \"|= 0\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::simpleMatch(tok, \"| 0 )\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void missingPercentCharacter() {
@@ -194,126 +193,130 @@ class TestInternal : public TestFixture {
               "    const Token *tok;\n"
               "    Token::Match(tok, \"%type%\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::Match(tok, \"foo %type% bar\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Missing % at the end of string
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::Match(tok, \"%type\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Missing percent end character in Token::Match() pattern: \"%type\"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Missing percent end character in Token::Match() pattern: \"%type\" [missingPercentCharacter]\n", errout_str());
 
         // Missing % in the middle of a pattern
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::Match(tok, \"foo %type bar\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Missing percent end character in Token::Match() pattern: \"foo %type bar\"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Missing percent end character in Token::Match() pattern: \"foo %type bar\" [missingPercentCharacter]\n", errout_str());
 
         // Bei quiet on single %
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::Match(tok, \"foo % %type% bar\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::Match(tok, \"foo % %type % bar\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Missing percent end character in Token::Match() pattern: \"foo % %type % bar\"\n"
-                      "[test.cpp:3]: (error) Unknown pattern used: \"%type %\"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Missing percent end character in Token::Match() pattern: \"foo % %type % bar\" [missingPercentCharacter]\n"
+                      "[test.cpp:3:5]: (error) Unknown pattern used: \"%type %\" [unknownPattern]\n", errout_str());
 
         // Find missing % also in 'alternatives' pattern
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::Match(tok, \"foo|%type|bar\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Missing percent end character in Token::Match() pattern: \"foo|%type|bar\"\n"
-                      , errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Missing percent end character in Token::Match() pattern: \"foo|%type|bar\" [missingPercentCharacter]\n"
+                      , errout_str());
 
         // Make sure we don't take %or% for a broken %oror%
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::Match(tok, \"foo|%oror%|bar\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void unknownPattern() {
         check("void f() {\n"
               "    Token::Match(tok, \"%typ%\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Unknown pattern used: \"%typ%\"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (error) Unknown pattern used: \"%typ%\" [unknownPattern]\n", errout_str());
 
         // Make sure we don't take %or% for a broken %oror%
         check("void f() {\n"
               "    Token::Match(tok, \"%type%\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void redundantNextPrevious() {
         check("void f() {\n"
               "    return tok->next()->previous();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Call to 'Token::next()' followed by 'Token::previous()' can be simplified.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) Call to 'Token::next()' followed by 'Token::previous()' can be simplified. [redundantNextPrevious]\n", errout_str());
 
         check("void f() {\n"
               "    return tok->tokAt(5)->previous();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Call to 'Token::tokAt()' followed by 'Token::previous()' can be simplified.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) Call to 'Token::tokAt()' followed by 'Token::previous()' can be simplified. [redundantNextPrevious]\n", errout_str());
 
         check("void f() {\n"
               "    return tok->previous()->linkAt(5);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Call to 'Token::previous()' followed by 'Token::linkAt()' can be simplified.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) Call to 'Token::previous()' followed by 'Token::linkAt()' can be simplified. [redundantNextPrevious]\n", errout_str());
 
         check("void f() {\n"
               "    tok->next()->previous(foo);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
-              "    return tok->next()->next();\n" // Simplification won't make code much shorter/readable
+              "    return tok->next()->next();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) Call to 'Token::next()' followed by 'Token::next()' can be simplified. [redundantNextPrevious]\n", errout_str());
 
         check("void f() {\n"
-              "    return tok->previous()->previous();\n" // Simplification won't make code much shorter/readable
+              "    return tok->previous()->previous();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) Call to 'Token::previous()' followed by 'Token::previous()' can be simplified. [redundantNextPrevious]\n", errout_str());
 
         check("void f() {\n"
               "    return tok->tokAt(foo+bar)->tokAt();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Call to 'Token::tokAt()' followed by 'Token::tokAt()' can be simplified.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) Call to 'Token::tokAt()' followed by 'Token::tokAt()' can be simplified. [redundantNextPrevious]\n", errout_str());
 
         check("void f() {\n"
               "    return tok->tokAt(foo+bar)->link();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Call to 'Token::tokAt()' followed by 'Token::link()' can be simplified.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) Call to 'Token::tokAt()' followed by 'Token::link()' can be simplified. [redundantNextPrevious]\n", errout_str());
 
         check("void f() {\n"
               "    tok->tokAt(foo+bar)->link(foo);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    return tok->next()->next()->str();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Call to 'Token::next()' followed by 'Token::str()' can be simplified.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) Call to 'Token::next()' followed by 'Token::next()' can be simplified. [redundantNextPrevious]\n"
+                      "[test.cpp:2:25]: (style) Call to 'Token::next()' followed by 'Token::str()' can be simplified. [redundantNextPrevious]\n",
+                      errout_str());
 
         check("void f() {\n"
               "    return tok->previous()->next()->str();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Call to 'Token::previous()' followed by 'Token::next()' can be simplified.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) Call to 'Token::previous()' followed by 'Token::next()' can be simplified. [redundantNextPrevious]\n"
+                      "[test.cpp:2:29]: (style) Call to 'Token::next()' followed by 'Token::str()' can be simplified. [redundantNextPrevious]\n",
+                      errout_str());
 
     }
 
@@ -330,39 +333,39 @@ class TestInternal : public TestFixture {
               "      z[0] = 0;\n"
               "   }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void orInComplexPattern() {
         check("void f() {\n"
               "    Token::Match(tok, \"||\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Token::Match() pattern \"||\" contains \"||\" or \"|\". Replace it by \"%oror%\" or \"%or%\".\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (error) Token::Match() pattern \"||\" contains \"||\" or \"|\". Replace it by \"%oror%\" or \"%or%\". [orInComplexPattern]\n", errout_str());
 
         check("void f() {\n"
               "    Token::Match(tok, \"|\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Token::Match() pattern \"|\" contains \"||\" or \"|\". Replace it by \"%oror%\" or \"%or%\".\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (error) Token::Match() pattern \"|\" contains \"||\" or \"|\". Replace it by \"%oror%\" or \"%or%\". [orInComplexPattern]\n", errout_str());
 
         check("void f() {\n"
               "    Token::Match(tok, \"[|+-]\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    Token::Match(tok, \"foo | bar\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Token::Match() pattern \"foo | bar\" contains \"||\" or \"|\". Replace it by \"%oror%\" or \"%or%\".\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (error) Token::Match() pattern \"foo | bar\" contains \"||\" or \"|\". Replace it by \"%oror%\" or \"%or%\". [orInComplexPattern]\n", errout_str());
 
         check("void f() {\n"
               "    Token::Match(tok, \"foo |\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Token::Match() pattern \"foo |\" contains \"||\" or \"|\". Replace it by \"%oror%\" or \"%or%\".\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (error) Token::Match() pattern \"foo |\" contains \"||\" or \"|\". Replace it by \"%oror%\" or \"%or%\". [orInComplexPattern]\n", errout_str());
 
         check("void f() {\n"
               "    Token::Match(tok, \"bar foo|\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void extraWhitespace() {
@@ -371,42 +374,42 @@ class TestInternal : public TestFixture {
               "    const Token *tok;\n"
               "    Token::Match(tok, \"%str% \");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Found extra whitespace inside Token::Match() call: \"%str% \"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Found extra whitespace inside Token::Match() call: \"%str% \" [extraWhitespaceError]\n", errout_str());
 
         // whitespace at the begin
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::Match(tok, \" %str%\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Found extra whitespace inside Token::Match() call: \" %str%\"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Found extra whitespace inside Token::Match() call: \" %str%\" [extraWhitespaceError]\n", errout_str());
 
         // two whitespaces or more
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::Match(tok, \"%str%  bar\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Found extra whitespace inside Token::Match() call: \"%str%  bar\"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Found extra whitespace inside Token::Match() call: \"%str%  bar\" [extraWhitespaceError]\n", errout_str());
 
         // test simpleMatch
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::simpleMatch(tok, \"foobar \");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Found extra whitespace inside Token::simpleMatch() call: \"foobar \"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Found extra whitespace inside Token::simpleMatch() call: \"foobar \" [extraWhitespaceError]\n", errout_str());
 
         // test findmatch
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::findmatch(tok, \"%str% \");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Found extra whitespace inside Token::findmatch() call: \"%str% \"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Found extra whitespace inside Token::findmatch() call: \"%str% \" [extraWhitespaceError]\n", errout_str());
 
         // test findsimplematch
         check("void f() {\n"
               "    const Token *tok;\n"
               "    Token::findsimplematch(tok, \"foobar \");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Found extra whitespace inside Token::findsimplematch() call: \"foobar \"\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Found extra whitespace inside Token::findsimplematch() call: \"foobar \" [extraWhitespaceError]\n", errout_str());
     }
 
     void checkRedundantTokCheck() {
@@ -415,59 +418,59 @@ class TestInternal : public TestFixture {
               "    const Token *tok;\n"
               "    if(tok && Token::findsimplematch(tok, \"foobar\")) {};\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unnecessary check of \"tok\", match-function already checks if it is null.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:38]: (style) Unnecessary check of \"tok\", match-function already checks if it is null. [redundantTokCheck]\n", errout_str());
 
         // findmatch
         check("void f() {\n"
               "    const Token *tok;\n"
               "    if(tok && Token::findmatch(tok, \"%str% foobar\")) {};\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unnecessary check of \"tok\", match-function already checks if it is null.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:32]: (style) Unnecessary check of \"tok\", match-function already checks if it is null. [redundantTokCheck]\n", errout_str());
 
         // Match
         check("void f() {\n"
               "    const Token *tok;\n"
               "    if(tok && Token::Match(tok, \"5str% foobar\")) {};\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unnecessary check of \"tok\", match-function already checks if it is null.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:28]: (style) Unnecessary check of \"tok\", match-function already checks if it is null. [redundantTokCheck]\n", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    if(a && tok && Token::Match(tok, \"5str% foobar\")) {};\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unnecessary check of \"tok\", match-function already checks if it is null.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:33]: (style) Unnecessary check of \"tok\", match-function already checks if it is null. [redundantTokCheck]\n", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    if(a && b && tok && Token::Match(tok, \"5str% foobar\")) {};\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unnecessary check of \"tok\", match-function already checks if it is null.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:38]: (style) Unnecessary check of \"tok\", match-function already checks if it is null. [redundantTokCheck]\n", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
-              "    if(a && b && && c && tok && Token::Match(tok, \"5str% foobar\")) {};\n"
+              "    if(a && b && c && tok && Token::Match(tok, \"5str% foobar\")) {};\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unnecessary check of \"tok\", match-function already checks if it is null.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:43]: (style) Unnecessary check of \"tok\", match-function already checks if it is null. [redundantTokCheck]\n", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
-              "    if(a && b && && c && tok && d && Token::Match(tok, \"5str% foobar\")) {};\n"
+              "    if(a && b && c && tok && d && Token::Match(tok, \"5str% foobar\")) {};\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // simpleMatch
         check("void f() {\n"
               "    const Token *tok;\n"
               "    if(tok && Token::simpleMatch(tok, \"foobar\")) {};\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unnecessary check of \"tok\", match-function already checks if it is null.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:34]: (style) Unnecessary check of \"tok\", match-function already checks if it is null. [redundantTokCheck]\n", errout_str());
 
         // Match
         check("void f() {\n"
               "    const Token *tok;\n"
               "    if(tok->previous() && Token::Match(tok->previous(), \"5str% foobar\")) {};\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unnecessary check of \"tok->previous()\", match-function already checks if it is null.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:53]: (style) Unnecessary check of \"tok->previous()\", match-function already checks if it is null. [redundantTokCheck]\n", errout_str());
 
         // don't report:
         // tok->previous() vs tok
@@ -475,55 +478,57 @@ class TestInternal : public TestFixture {
               "    const Token *tok;\n"
               "    if(tok->previous() && Token::Match(tok, \"5str% foobar\")) {};\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // tok vs tok->previous())
         check("void f() {\n"
               "    const Token *tok;\n"
               "    if(tok && Token::Match(tok->previous(), \"5str% foobar\")) {};\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // tok->previous() vs tok->previous()->previous())
         check("void f() {\n"
               "    const Token *tok;\n"
               "    if(tok->previous() && Token::Match(tok->previous()->previous(), \"5str% foobar\")) {};\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:45]: (style) Call to 'Token::previous()' followed by 'Token::previous()' can be simplified. [redundantNextPrevious]\n", errout_str());
 
         // if a && fn(a) triggers, make sure !a || !fn(a) triggers as well!
         check("void f() {\n"
               "    const Token *tok;\n"
               "    if(!tok || !Token::simpleMatch(tok, \"foobar\")) {};\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unnecessary check of \"tok\", match-function already checks if it is null.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:36]: (style) Unnecessary check of \"tok\", match-function already checks if it is null. [redundantTokCheck]\n", errout_str());
 
         check("void f() {\n"
               "    const Token *tok;\n"
               "    if(a || !tok || !Token::simpleMatch(tok, \"foobar\")) {};\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unnecessary check of \"tok\", match-function already checks if it is null.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:41]: (style) Unnecessary check of \"tok\", match-function already checks if it is null. [redundantTokCheck]\n", errout_str());
 
         // if tok || !Token::simpleMatch...
         check("void f() {\n"
               "    const Token *tok;\n"
               "    if(tok || !Token::simpleMatch(tok, \"foobar\")) {};\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // if !tok || Token::simpleMatch...
         check("void f() {\n"
               "    const Token *tok;\n"
               "    if(!tok || Token::simpleMatch(tok, \"foobar\")) {};\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // something more complex
         check("void f() {\n"
               "    const Token *tok;\n"
               "    if(!tok->previous()->previous() || !Token::simpleMatch(tok->previous()->previous(), \"foobar\")) {};\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unnecessary check of \"tok->previous()->previous()\", match-function already checks if it is null.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:14]: (style) Call to 'Token::previous()' followed by 'Token::previous()' can be simplified. [redundantNextPrevious]\n"
+                      "[test.cpp:3:65]: (style) Call to 'Token::previous()' followed by 'Token::previous()' can be simplified. [redundantNextPrevious]\n"
+                      "[test.cpp:3:85]: (style) Unnecessary check of \"tok->previous()->previous()\", match-function already checks if it is null. [redundantTokCheck]\n", errout_str());
     }
 };
 
diff --git a/test/testio.cpp b/test/testio.cpp
index 989e77759c0..b402f5c0aa1 100644
--- a/test/testio.cpp
+++ b/test/testio.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,27 +16,26 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include "checkio.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "platform.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
 
+#include <cstddef>
+#include <string>
 
 class TestIO : public TestFixture {
 public:
-    TestIO() : TestFixture("TestIO") {
-    }
+    TestIO() : TestFixture("TestIO") {}
 
 private:
-    Settings settings;
-
-    void run() OVERRIDE {
-        LOAD_LIB_2(settings.library, "std.cfg");
-        LOAD_LIB_2(settings.library, "windows.cfg");
-        LOAD_LIB_2(settings.library, "qt.cfg");
+    const Settings settings = settingsBuilder().library("std.cfg").library("windows.cfg").library("qt.cfg").build();
+    /*const*/ Settings settings1 = settingsBuilder().library("std.cfg").library("windows.cfg").library("qt.cfg").severity(Severity::warning).severity(Severity::style).build();
 
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(coutCerrMisusage);
 
         TEST_CASE(wrongMode_simple);
@@ -45,15 +44,19 @@ class TestIO : public TestFixture {
         TEST_CASE(fileIOwithoutPositioning);
         TEST_CASE(seekOnAppendedFile);
         TEST_CASE(fflushOnInputStream);
+        TEST_CASE(incompatibleFileOpen);
 
         TEST_CASE(testScanf1); // Scanf without field limiters
         TEST_CASE(testScanf2);
         TEST_CASE(testScanf3); // #3494
         TEST_CASE(testScanf4); // #ticket 2553
+        TEST_CASE(testScanf5); // #10632
 
+        mNewTemplate = false;
         TEST_CASE(testScanfArgument);
         TEST_CASE(testPrintfArgument);
         TEST_CASE(testPrintfArgumentVariables);
+        mNewTemplate = true;
         TEST_CASE(testPosixPrintfScanfParameterPosition);  // #4900
 
         TEST_CASE(testMicrosoftPrintfArgument); // ticket #4902
@@ -73,34 +76,44 @@ class TestIO : public TestFixture {
 
         TEST_CASE(testPrintfTypeAlias1);
         TEST_CASE(testPrintfAuto); // #8992
-    }
+        TEST_CASE(testPrintfParenthesis); // #8489
+        TEST_CASE(testStdDistance); // #10304
+        TEST_CASE(testParameterPack); // #11289
 
-    void check(const char* code, bool inconclusive = false, bool portability = false, Settings::PlatformType platform = Settings::Unspecified) {
-        // Clear the error buffer..
-        errout.str("");
+        TEST_CASE(testDefaultSignInt); // #13363
+        TEST_CASE(testPrintfWithGeneric); // #13592
+    }
 
-        settings.clearEnabled();
-        settings.addEnabled("warning");
-        settings.addEnabled("style");
-        if (portability)
-            settings.addEnabled("portability");
-        settings.inconclusive = inconclusive;
-        settings.platform(platform);
+    struct CheckOptions
+    {
+        bool inconclusive = false;
+        bool portability = false;
+        Platform::Type platform = Platform::Type::Unspecified;
+        char defaultSign = '\0';
+        bool onlyFormatStr = false;
+        bool cpp = true;
+    };
+
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
+        // TODO: using dedicated Settings (i.e. copying it) object causes major slowdown
+        settings1.severity.setEnabled(Severity::portability, options.portability);
+        settings1.certainty.setEnabled(Certainty::inconclusive, options.inconclusive);
+        PLATFORM(settings1.platform, options.platform);
+        settings1.platform.defaultSign = options.defaultSign;
 
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings1, *this, options.cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check..
-        CheckIO checkIO(&tokenizer, &settings, this);
-        checkIO.checkWrongPrintfScanfArguments();
-
-        // Simplify token list..
-        tokenizer.simplifyTokenList2();
-        checkIO.checkCoutCerrMisusage();
-        checkIO.checkFileUsage();
-        checkIO.invalidScanf();
+        if (options.onlyFormatStr) {
+            CheckIO checkIO(&tokenizer, &settings1, this);
+            checkIO.checkWrongPrintfScanfArguments();
+            return;
+        }
+        runChecks<CheckIO>(tokenizer, this);
     }
 
     void coutCerrMisusage() {
@@ -108,50 +121,50 @@ class TestIO : public TestFixture {
             "void foo() {\n"
             "  std::cout << std::cout;\n"
             "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Invalid usage of output stream: '<< std::cout'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:3]: (error) Invalid usage of output stream: '<< std::cout'. [coutCerrMisusage]\n", errout_str());
 
         check(
             "void foo() {\n"
             "  std::cout << (std::cout);\n"
             "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Invalid usage of output stream: '<< std::cout'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:3]: (error) Invalid usage of output stream: '<< std::cout'. [coutCerrMisusage]\n", errout_str());
 
         check(
             "void foo() {\n"
             "  std::cout << \"xyz\" << std::cout;\n"
             "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Invalid usage of output stream: '<< std::cout'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:3]: (error) Invalid usage of output stream: '<< std::cout'. [coutCerrMisusage]\n", errout_str());
 
         check(
             "void foo(int i) {\n"
             "  std::cout << i << std::cerr;\n"
             "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Invalid usage of output stream: '<< std::cerr'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:3]: (error) Invalid usage of output stream: '<< std::cerr'. [coutCerrMisusage]\n", errout_str());
 
         check(
             "void foo() {\n"
             "  std::cout << \"xyz\";\n"
             "  std::cout << \"xyz\";\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo() {\n"
             "  std::cout << std::cout.good();\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo() {\n"
             "    unknownObject << std::cout;\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo() {\n"
             "  MACRO(std::cout <<, << std::cout)\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -164,103 +177,103 @@ class TestIO : public TestFixture {
               "    rewind(f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Write operation on a file that was opened only for reading.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _wfopen(name, L\"r\");\n"
               "    fread(buffer, 5, 6, f);\n"
               "    rewind(f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:5]: (error) Write operation on a file that was opened only for reading.\n", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _tfopen(name, _T(\"r\"));\n"
               "    fread(buffer, 5, 6, f);\n"
               "    rewind(f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:5]: (error) Write operation on a file that was opened only for reading.\n", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _tfopen(name, _T(\"r\"));\n"
               "    fread(buffer, 5, 6, f);\n"
               "    rewind(f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:5]: (error) Write operation on a file that was opened only for reading.\n", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    _wfopen_s(&f, name, L\"r\");\n"
               "    fread(buffer, 5, 6, f);\n"
               "    rewind(f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:5]: (error) Write operation on a file that was opened only for reading.\n", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    _tfopen_s(&f, name, _T(\"r\"));\n"
               "    fread(buffer, 5, 6, f);\n"
               "    rewind(f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:5]: (error) Write operation on a file that was opened only for reading.\n", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    _tfopen_s(&f, name, _T(\"r\"));\n"
               "    fread(buffer, 5, 6, f);\n"
               "    rewind(f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:5]: (error) Write operation on a file that was opened only for reading.\n", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:5:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = fopen(name, \"r+\");\n"
               "    fwrite(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _wfopen(name, L\"r+\");\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", false, false, Settings::Win32W);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _tfopen(name, _T(\"r+\"));\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", false, false, Settings::Win32A);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _tfopen(name, _T(\"r+\"));\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", false, false, Settings::Win32W);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    _wfopen_s(&f, name, L\"r+\");\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", false, false, Settings::Win32W);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    _tfopen_s(&f, name, _T(\"r+\"));\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", false, false, Settings::Win32A);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    _tfopen_s(&f, name, _T(\"r+\"));\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", false, false, Settings::Win32W);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = tmpfile();\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", false, false, Settings::Win32W);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("", errout_str());
 
         // Write mode
         check("void foo(FILE*& f) {\n"
@@ -269,19 +282,19 @@ class TestIO : public TestFixture {
               "    rewind(f);\n"
               "    fread(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Read operation on a file that was opened only for writing.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5]: (error) Read operation on a file that was opened only for writing. [readWriteOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = fopen(name, \"w+\");\n"
               "    fread(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = tmpfile();\n"
               "    fread(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Append mode
         check("void foo(FILE*& f) {\n"
@@ -290,14 +303,14 @@ class TestIO : public TestFixture {
               "    rewind(f);\n"
               "    fread(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Repositioning operation performed on a file opened in append mode has no effect.\n"
-                      "[test.cpp:5]: (error) Read operation on a file that was opened only for writing.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) Repositioning operation performed on a file opened in append mode has no effect. [seekOnAppendedFile]\n"
+                      "[test.cpp:5:5]: (error) Read operation on a file that was opened only for writing. [readWriteOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = fopen(name, \"a+\");\n"
               "    fread(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Variable declared locally
         check("void foo() {\n"
@@ -305,7 +318,7 @@ class TestIO : public TestFixture {
               "    fwrite(buffer, 5, 6, f);\n"
               "    fclose(f);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Write operation on a file that was opened only for reading.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         // Call unknown function
         check("void foo(FILE*& f) {\n"
@@ -314,57 +327,57 @@ class TestIO : public TestFixture {
               "    bar(f);\n"
               "    fread(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // freopen and tmpfile
         check("void foo(FILE*& f) {\n"
               "    f = freopen(name, \"r\", f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Write operation on a file that was opened only for reading.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _wfreopen(name, L\"r\", f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Write operation on a file that was opened only for reading.\n", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _tfreopen(name, _T(\"r\"), f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Write operation on a file that was opened only for reading.\n", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _tfreopen(name, _T(\"r\"), f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Write operation on a file that was opened only for reading.\n", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _wfreopen_s(&f, name, L\"r\", f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Write operation on a file that was opened only for reading.\n", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _tfreopen_s(&f, name, _T(\"r\"), f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Write operation on a file that was opened only for reading.\n", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = _tfreopen_s(&f, name, _T(\"r\"), f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
-              "}", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Write operation on a file that was opened only for reading.\n", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Write operation on a file that was opened only for reading. [writeReadOnlyFile]\n", errout_str());
 
         // Crash tests
         check("void foo(FILE*& f) {\n"
               "    f = fopen(name, mode);\n" // No assertion failure (#3830)
               "    fwrite(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void fopen(std::string const &filepath, std::string const &mode);"); // #3832
     }
@@ -376,7 +389,7 @@ class TestIO : public TestFixture {
               "    if(a) fwrite(buffer, 5, 6, f);\n"
               "    else  fread(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    FILE* f;\n"
@@ -385,14 +398,14 @@ class TestIO : public TestFixture {
               "    if(a) fwrite(buffer, 5, 6, f);\n"
               "    else  fread(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    FILE* f = fopen(name, \"w\");\n"
               "    if(a) fwrite(buffer, 5, 6, f);\n"
               "    else  fread(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Read operation on a file that was opened only for writing.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:11]: (error) Read operation on a file that was opened only for writing. [readWriteOnlyFile]\n", errout_str());
     }
 
     void useClosedFile() {
@@ -405,12 +418,12 @@ class TestIO : public TestFixture {
               "    ungetwc(L'a', f);\n"
               "    rewind(f);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Used file that is not opened.\n"
-                      "[test.cpp:4]: (error) Used file that is not opened.\n"
-                      "[test.cpp:5]: (error) Used file that is not opened.\n"
-                      "[test.cpp:6]: (error) Used file that is not opened.\n"
-                      "[test.cpp:7]: (error) Used file that is not opened.\n"
-                      "[test.cpp:8]: (error) Used file that is not opened.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Used file that is not opened. [useClosedFile]\n"
+                      "[test.cpp:4:5]: (error) Used file that is not opened. [useClosedFile]\n"
+                      "[test.cpp:5:5]: (error) Used file that is not opened. [useClosedFile]\n"
+                      "[test.cpp:6:5]: (error) Used file that is not opened. [useClosedFile]\n"
+                      "[test.cpp:7:5]: (error) Used file that is not opened. [useClosedFile]\n"
+                      "[test.cpp:8:5]: (error) Used file that is not opened. [useClosedFile]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    if(!ferror(f)) {\n"
@@ -419,40 +432,40 @@ class TestIO : public TestFixture {
               "    }\n"
               "    fwrite(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    fclose(f);\n"
               "    f = fopen(name, \"r\");\n"
               "    fread(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = fopen(name, \"r\");\n"
               "    f = g;\n"
               "    fwrite(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    FILE* f;\n"
               "    fwrite(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Used file that is not opened.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Used file that is not opened. [useClosedFile]\n", errout_str());
 
         check("void foo() {\n"
               "    FILE* f(stdout);\n"
               "    fwrite(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n" // #3965
               "    FILE* f[3];\n"
               "    f[0] = fopen(name, mode);\n"
               "    fclose(f[0]);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #4368: multiple functions
         check("static FILE *fp = NULL;\n"
@@ -475,7 +488,7 @@ class TestIO : public TestFixture {
               "  close();\n"
               "  return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("static FILE *fp = NULL;\n"
               "\n"
@@ -489,7 +502,7 @@ class TestIO : public TestFixture {
               "  fclose(fp);\n"
               "  fprintf(fp, \"Here's the output.\\n\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:11]: (error) Used file that is not opened.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:11:3]: (error) Used file that is not opened. [useClosedFile]\n", errout_str());
 
         // #4466
         check("void chdcd_parse_nero(FILE *infile) {\n"
@@ -502,7 +515,7 @@ class TestIO : public TestFixture {
               "            return;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void chdcd_parse_nero(FILE *infile) {\n"
               "    switch (mode) {\n"
@@ -514,7 +527,7 @@ class TestIO : public TestFixture {
               "            return;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #4649
         check("void foo() {\n"
@@ -524,14 +537,14 @@ class TestIO : public TestFixture {
               "    fclose(a.f1);\n"
               "    fclose(a.f2);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #1473
         check("void foo() {\n"
               "    FILE *a = fopen(\"aa\", \"r\");\n"
               "    while (fclose(a)) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Used file that is not opened.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3:5]: (error) Used file that is not opened. [useClosedFile]\n", "", errout_str());
 
         // #6823
         check("void foo() {\n"
@@ -541,7 +554,15 @@ class TestIO : public TestFixture {
               "    fclose(f[0]);\n"
               "    fclose(f[1]);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // #12236
+        check("void f() {\n"
+              "    FILE* f = fopen(\"abc\", \"r\");\n"
+              "    decltype(fclose(f)) y;\n"
+              "    y = fclose(f);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void fileIOwithoutPositioning() {
@@ -549,13 +570,13 @@ class TestIO : public TestFixture {
               "    fwrite(buffer, 5, 6, f);\n"
               "    fread(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour. [IOWithoutPositioning]\n", errout_str());
 
         check("void foo(FILE* f) {\n"
               "    fread(buffer, 5, 6, f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour. [IOWithoutPositioning]\n", errout_str());
 
         check("void foo(FILE* f, bool read) {\n"
               "    if(read)\n"
@@ -563,42 +584,42 @@ class TestIO : public TestFixture {
               "    else\n"
               "        fwrite(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE* f) {\n"
               "    fread(buffer, 5, 6, f);\n"
               "    fflush(f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE* f) {\n"
               "    fread(buffer, 5, 6, f);\n"
               "    rewind(f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE* f) {\n"
               "    fread(buffer, 5, 6, f);\n"
               "    fsetpos(f, pos);\n"
               "    fwrite(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE* f) {\n"
               "    fread(buffer, 5, 6, f);\n"
               "    fseek(f, 0, SEEK_SET);\n"
               "    fwrite(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE* f) {\n"
               "    fread(buffer, 5, 6, f);\n"
               "    long pos = ftell(f);\n"
               "    fwrite(buffer, 5, 6, f);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour. [IOWithoutPositioning]\n", errout_str());
 
         // #6452 - member functions
         check("class FileStream {\n"
@@ -611,7 +632,7 @@ class TestIO : public TestFixture {
               "    seek(writePosition);\n"
               "    fwrite(buffer.data(), sizeof(char), buffer.size(), d->file);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class FileStream {\n"
               "    void insert(const ByteVector &data, ulong start);\n"
@@ -622,7 +643,7 @@ class TestIO : public TestFixture {
               "    unknown(writePosition);\n"
               "    fwrite(buffer.data(), sizeof(char), buffer.size(), d->file);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class FileStream {\n"
               "    void insert(const ByteVector &data, ulong start);\n"
@@ -634,7 +655,7 @@ class TestIO : public TestFixture {
               "    known(writePosition);\n"
               "    fwrite(buffer.data(), sizeof(char), buffer.size(), d->file);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:9]: (error) Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:5]: (error) Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour. [IOWithoutPositioning]\n", errout_str());
 
         check("class FileStream {\n"
               "    void insert(const ByteVector &data, ulong start);\n"
@@ -646,7 +667,7 @@ class TestIO : public TestFixture {
               "    known(writePosition);\n"
               "    fwrite(X::data(), sizeof(char), buffer.size(), d->file);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:9]: (error) Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:5]: (error) Read and write operations without a call to a positioning function (fseek, fsetpos or rewind) or fflush in between result in undefined behaviour. [IOWithoutPositioning]\n", errout_str());
     }
 
     void seekOnAppendedFile() {
@@ -654,25 +675,25 @@ class TestIO : public TestFixture {
               "    FILE* f = fopen(\"\", \"a+\");\n"
               "    fseek(f, 0, SEEK_SET);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    FILE* f = fopen(\"\", \"w\");\n"
               "    fseek(f, 0, SEEK_SET);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    FILE* f = fopen(\"\", \"a\");\n"
               "    fseek(f, 0, SEEK_SET);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Repositioning operation performed on a file opened in append mode has no effect.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Repositioning operation performed on a file opened in append mode has no effect. [seekOnAppendedFile]\n", errout_str());
 
         check("void foo() {\n"
               "    FILE* f = fopen(\"\", \"a\");\n"
               "    fflush(f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str()); // #5578
+        ASSERT_EQUALS("", errout_str()); // #5578
 
         check("void foo() {\n"
               "    FILE* f = fopen(\"\", \"a\");\n"
@@ -680,41 +701,47 @@ class TestIO : public TestFixture {
               "    f = fopen(\"\", \"r\");\n"
               "    fseek(f, 0, SEEK_SET);\n"
               "}");
-        ASSERT_EQUALS("", errout.str()); // #6566
+        ASSERT_EQUALS("", errout_str()); // #6566
     }
 
     void fflushOnInputStream() {
         check("void foo()\n"
               "{\n"
               "    fflush(stdin);\n"
-              "}", false, true);
-        ASSERT_EQUALS("[test.cpp:3]: (portability) fflush() called on input stream 'stdin' may result in undefined behaviour on non-linux systems.\n", errout.str());
+              "}", dinit(CheckOptions, $.portability = true));
+        ASSERT_EQUALS("[test.cpp:3:5]: (portability) fflush() called on input stream 'stdin' may result in undefined behaviour on non-linux systems. [fflushOnInputStream]\n", errout_str());
 
         check("void foo()\n"
               "{\n"
               "    fflush(stdout);\n"
-              "}", false, true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.portability = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = fopen(path, \"r\");\n"
               "    fflush(f);\n"
-              "}", false, true);
-        ASSERT_EQUALS("[test.cpp:3]: (portability) fflush() called on input stream 'f' may result in undefined behaviour on non-linux systems.\n", errout.str());
+              "}", dinit(CheckOptions, $.portability = true));
+        ASSERT_EQUALS("[test.cpp:3:5]: (portability) fflush() called on input stream 'f' may result in undefined behaviour on non-linux systems. [fflushOnInputStream]\n", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    f = fopen(path, \"w\");\n"
               "    fflush(f);\n"
-              "}", false, true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.portability = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(FILE*& f) {\n"
               "    fflush(f);\n"
-              "}", false, true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.portability = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
-
+    void incompatibleFileOpen() {
+        check("void foo() {\n"
+              "    FILE *f1 = fopen(\"tmp\", \"wt\");\n"
+              "    FILE *f2 = fopen(\"tmp\", \"rt\");\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:16]: (warning) The file '\"tmp\"' is opened for read and write access at the same time on different streams [incompatibleFileOpen]\n", errout_str());
+    }
 
 
     void testScanf1() {
@@ -728,11 +755,11 @@ class TestIO : public TestFixture {
               "    scanf(\"%dx%s\", &b, bar);\n"
               "    fclose(file);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) fscanf() without field width limits can crash with huge input data.\n"
-                      "[test.cpp:5]: (warning) scanf() without field width limits can crash with huge input data.\n"
-                      "[test.cpp:6]: (warning) scanf() without field width limits can crash with huge input data.\n"
-                      "[test.cpp:7]: (warning) sscanf() without field width limits can crash with huge input data.\n"
-                      "[test.cpp:8]: (warning) scanf() without field width limits can crash with huge input data.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9]: (warning) fscanf() without field width limits can crash with huge input data. [invalidscanf]\n"
+                      "[test.cpp:5:9]: (warning) scanf() without field width limits can crash with huge input data. [invalidscanf]\n"
+                      "[test.cpp:6:9]: (warning) scanf() without field width limits can crash with huge input data. [invalidscanf]\n"
+                      "[test.cpp:7:5]: (warning) sscanf() without field width limits can crash with huge input data. [invalidscanf]\n"
+                      "[test.cpp:8:5]: (warning) scanf() without field width limits can crash with huge input data. [invalidscanf]\n", errout_str());
     }
 
     void testScanf2() {
@@ -744,7 +771,7 @@ class TestIO : public TestFixture {
               "    scanf(\"aa%ld\", &a);\n" // No %s
               "    scanf(\"%*[^~]\");\n" // Ignore input
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) scanf format string requires 0 parameters but 1 is given.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) scanf format string requires 0 parameters but 1 is given. [wrongPrintfScanfArgNum]\n", errout_str());
     }
 
     void testScanf3() { // ticket #3494
@@ -754,7 +781,7 @@ class TestIO : public TestFixture {
               "  scanf(\"%8c\", str);\n"
               "  scanf(\"%9c\", str);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Width 9 given in format string (no. 1) is larger than destination buffer 'str[8]', use %8c to prevent overflowing it.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:3]: (error) Width 9 given in format string (no. 1) is larger than destination buffer 'str[8]', use %8c to prevent overflowing it. [invalidScanfFormatWidth]\n", errout_str());
     }
 
     void testScanf4() { // ticket #2553
@@ -763,110 +790,165 @@ class TestIO : public TestFixture {
               "  char str [8];\n"
               "  scanf (\"%70s\",str);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Width 70 given in format string (no. 1) is larger than destination buffer 'str[8]', use %7s to prevent overflowing it.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:3]: (error) Width 70 given in format string (no. 1) is larger than destination buffer 'str[8]', use %7s to prevent overflowing it. [invalidScanfFormatWidth]\n", errout_str());
+    }
+
+    void testScanf5() { // #10632
+        check("char s1[42], s2[42];\n"
+              "void test() {\n"
+              "    scanf(\"%42s%42[a-z]\", s1, s2);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Width 42 given in format string (no. 1) is larger than destination buffer 's1[42]', use %41s to prevent overflowing it. [invalidScanfFormatWidth]\n"
+                      "[test.cpp:3:5]: (error) Width 42 given in format string (no. 2) is larger than destination buffer 's2[42]', use %41[a-z] to prevent overflowing it. [invalidScanfFormatWidth]\n", errout_str());
     }
 
 
-#define TEST_SCANF_CODE(format, type)\
+#define TEST_SCANF_CODE(format, type) \
     "void f(){" type " x; scanf(\"" format "\", &x);}"
 
-#define TEST_SCANF_ERR(format, formatStr, type)\
-    "[test.cpp:1]: (warning) " format " in format string (no. 1) requires '" formatStr " *' but the argument type is '" type " *'.\n"
+#define TEST_SCANF_ERR(format, formatStr, type) \
+    "[test.c:1]: (warning) " format " in format string (no. 1) requires '" formatStr " *' but the argument type is '" type " *'.\n"
+
+#define TEST_SCANF_ERR_AKA_(file, format, formatStr, type, akaType) \
+    "[" file ":1]: (portability) " format " in format string (no. 1) requires '" formatStr " *' but the argument type is '" type " * {aka " akaType " *}'.\n"
+
+#define TEST_SCANF_ERR_AKA(format, formatStr, type, akaType) \
+    TEST_SCANF_ERR_AKA_("test.c", format, formatStr, type, akaType)
 
-#define TEST_SCANF_ERR_AKA(format, formatStr, type, akaType)\
-    "[test.cpp:1]: (portability) " format " in format string (no. 1) requires '" formatStr " *' but the argument type is '" type " * {aka " akaType " *}'.\n"
+#define TEST_SCANF_ERR_AKA_CPP(format, formatStr, type, akaType) \
+    TEST_SCANF_ERR_AKA_("test.cpp", format, formatStr, type, akaType)
 
-#define TEST_PRINTF_CODE(format, type)\
+#define TEST_PRINTF_CODE(format, type) \
     "void f(" type " x){printf(\"" format "\", x);}"
 
-#define TEST_PRINTF_ERR(format, requiredType, actualType)\
-    "[test.cpp:1]: (warning) " format " in format string (no. 1) requires '" requiredType "' but the argument type is '" actualType "'.\n"
-
-#define TEST_PRINTF_ERR_AKA(format, requiredType, actualType, akaType)\
-    "[test.cpp:1]: (portability) " format " in format string (no. 1) requires '" requiredType "' but the argument type is '" actualType " {aka " akaType "}'.\n"
-
-    void testScanfNoWarn(const char *filename, unsigned int linenr, const char* code) {
-        check(code, true, false, Settings::Unix32);
-        assertEquals(filename, linenr, "", errout.str());
-        check(code, true, false, Settings::Unix64);
-        assertEquals(filename, linenr, "", errout.str());
-        check(code, true, false, Settings::Win32A);
-        assertEquals(filename, linenr, "", errout.str());
-        check(code, true, false, Settings::Win64);
-        assertEquals(filename, linenr, "", errout.str());
+#define TEST_PRINTF_ERR(format, requiredType, actualType) \
+    "[test.c:1]: (warning) " format " in format string (no. 1) requires '" requiredType "' but the argument type is '" actualType "'.\n"
+
+#define TEST_PRINTF_ERR_AKA_(file, format, requiredType, actualType, akaType) \
+    "[" file ":1]: (portability) " format " in format string (no. 1) requires '" requiredType "' but the argument type is '" actualType " {aka " akaType "}'.\n"
+
+#define TEST_PRINTF_ERR_AKA(format, requiredType, actualType, akaType) \
+    TEST_PRINTF_ERR_AKA_("test.c", format, requiredType, actualType, akaType)
+
+#define TEST_PRINTF_ERR_AKA_CPP(format, requiredType, actualType, akaType) \
+    TEST_PRINTF_ERR_AKA_("test.cpp", format, requiredType, actualType, akaType)
+
+    template<size_t size>
+    void testFormatStrNoWarn(const char *filename, unsigned int linenr, const char (&code)[size],
+                             bool cpp = false) {
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Unix32, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, "", errout_str());
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Unix64, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, "", errout_str());
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Win32A, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, "", errout_str());
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Win32W, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, "", errout_str());
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Win64, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, "", errout_str());
     }
 
-    void testScanfWarn(const char *filename, unsigned int linenr,
-                       const char* code, const char* testScanfErrString) {
-        check(code, true, false, Settings::Unix32);
-        assertEquals(filename, linenr, testScanfErrString, errout.str());
-        check(code, true, false, Settings::Unix64);
-        assertEquals(filename, linenr, testScanfErrString, errout.str());
-        check(code, true, false, Settings::Win32A);
-        assertEquals(filename, linenr, testScanfErrString, errout.str());
-        check(code, true, false, Settings::Win64);
-        assertEquals(filename, linenr, testScanfErrString, errout.str());
+    template<size_t size>
+    void testFormatStrWarn(const char *filename, unsigned int linenr,
+                           const char (&code)[size], const char* testScanfErrString,
+                           bool cpp = false) {
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Unix32, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, testScanfErrString, errout_str());
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Unix64, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, testScanfErrString, errout_str());
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Win32A, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, testScanfErrString, errout_str());
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Win32W, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, testScanfErrString, errout_str());
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Win64, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, testScanfErrString, errout_str());
     }
 
-    void testScanfWarnAka(const char *filename, unsigned int linenr,
-                          const char* code, const char* testScanfErrAkaString, const char* testScanfErrAkaWin64String) {
-        check(code, true, true, Settings::Unix32);
-        assertEquals(filename, linenr, testScanfErrAkaString, errout.str());
-        check(code, true, true, Settings::Unix64);
-        assertEquals(filename, linenr, testScanfErrAkaString, errout.str());
-        check(code, true, true, Settings::Win32A);
-        assertEquals(filename, linenr, testScanfErrAkaString, errout.str());
-        check(code, true, true, Settings::Win64);
-        assertEquals(filename, linenr, testScanfErrAkaWin64String, errout.str());
+    template<size_t size>
+    void testFormatStrWarnAka(const char *filename, unsigned int linenr,
+                              const char (&code)[size], const char* testScanfErrAkaString, const char* testScanfErrAkaWin64String,
+                              bool cpp = false) {
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Unix32, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, testScanfErrAkaString, errout_str());
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Unix64, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, testScanfErrAkaString, errout_str());
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Win32A, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, testScanfErrAkaString, errout_str());
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Win32W, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, testScanfErrAkaString, errout_str());
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Win64, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, testScanfErrAkaWin64String, errout_str());
     }
 
-    void testScanfWarnAkaWin64(const char *filename, unsigned int linenr,
-                               const char* code, const char* testScanfErrAkaWin64String) {
-        check(code, true, true, Settings::Unix32);
-        assertEquals(filename, linenr, "", errout.str());
-        check(code, true, true, Settings::Unix64);
-        assertEquals(filename, linenr, "", errout.str());
-        check(code, true, true, Settings::Win32A);
-        assertEquals(filename, linenr, "", errout.str());
-        check(code, true, true, Settings::Win64);
-        assertEquals(filename, linenr, testScanfErrAkaWin64String, errout.str());
+    template<size_t size>
+    void testFormatStrWarnAkaWin64(const char *filename, unsigned int linenr,
+                                   const char (&code)[size], const char* testScanfErrAkaWin64String,
+                                   bool cpp = false) {
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Unix32, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, "", errout_str());
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Unix64, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, "", errout_str());
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Win32A, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, "", errout_str());
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Win32W, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, "", errout_str());
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Win64, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, testScanfErrAkaWin64String, errout_str());
     }
 
-    void testScanfWarnAkaWin32(const char *filename, unsigned int linenr,
-                               const char* code, const char* testScanfErrAkaString) {
-        check(code, true, true, Settings::Unix32);
-        assertEquals(filename, linenr, testScanfErrAkaString, errout.str());
-        check(code, true, true, Settings::Unix64);
-        assertEquals(filename, linenr, testScanfErrAkaString, errout.str());
-        check(code, true, true, Settings::Win32A);
-        assertEquals(filename, linenr, testScanfErrAkaString, errout.str());
-        check(code, true, true, Settings::Win64);
-        assertEquals(filename, linenr, "", errout.str());
+    template<size_t size>
+    void testFormatStrWarnAkaWin32(const char *filename, unsigned int linenr,
+                                   const char (&code)[size], const char* testScanfErrAkaString,
+                                   bool cpp = false) {
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Unix32, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, testScanfErrAkaString, errout_str());
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Unix64, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, testScanfErrAkaString, errout_str());
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Win32A, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, testScanfErrAkaString, errout_str());
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Win32W, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, testScanfErrAkaString, errout_str());
+        check(code, dinit(CheckOptions, $.inconclusive = true, $.portability = true, $.platform = Platform::Type::Win64, $.onlyFormatStr = true, $.cpp = cpp));
+        assertEquals(filename, linenr, "", errout_str());
     }
 
 #define TEST_SCANF_NOWARN(FORMAT, FORMATSTR, TYPE) \
-    testScanfNoWarn(__FILE__, __LINE__, TEST_SCANF_CODE(FORMAT, TYPE))
+    testFormatStrNoWarn(__FILE__, __LINE__, TEST_SCANF_CODE(FORMAT, TYPE))
+#define TEST_SCANF_NOWARN_CPP(FORMAT, FORMATSTR, TYPE) \
+    testFormatStrNoWarn(__FILE__, __LINE__, TEST_SCANF_CODE(FORMAT, TYPE), true)
 #define TEST_SCANF_WARN(FORMAT, FORMATSTR, TYPE) \
-    testScanfWarn(__FILE__, __LINE__, TEST_SCANF_CODE(FORMAT, TYPE), TEST_SCANF_ERR(FORMAT, FORMATSTR, TYPE))
+    testFormatStrWarn(__FILE__, __LINE__, TEST_SCANF_CODE(FORMAT, TYPE), TEST_SCANF_ERR(FORMAT, FORMATSTR, TYPE))
 #define TEST_SCANF_WARN_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE, AKATYPE_WIN64) \
-    testScanfWarnAka(__FILE__, __LINE__, TEST_SCANF_CODE(FORMAT, TYPE), TEST_SCANF_ERR_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE), TEST_SCANF_ERR_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64))
+    testFormatStrWarnAka(__FILE__, __LINE__, TEST_SCANF_CODE(FORMAT, TYPE), TEST_SCANF_ERR_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE), TEST_SCANF_ERR_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64))
+#define TEST_SCANF_WARN_AKA_CPP(FORMAT, FORMATSTR, TYPE, AKATYPE, AKATYPE_WIN64) \
+    testFormatStrWarnAka(__FILE__, __LINE__, TEST_SCANF_CODE(FORMAT, TYPE), TEST_SCANF_ERR_AKA_CPP(FORMAT, FORMATSTR, TYPE, AKATYPE), TEST_SCANF_ERR_AKA_CPP(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64), true)
 #define TEST_SCANF_WARN_AKA_WIN64(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64) \
-    testScanfWarnAkaWin64(__FILE__, __LINE__, TEST_SCANF_CODE(FORMAT, TYPE), TEST_SCANF_ERR_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64))
+    testFormatStrWarnAkaWin64(__FILE__, __LINE__, TEST_SCANF_CODE(FORMAT, TYPE), TEST_SCANF_ERR_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64))
+#define TEST_SCANF_WARN_AKA_CPP_WIN64(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64) \
+    testFormatStrWarnAkaWin64(__FILE__, __LINE__, TEST_SCANF_CODE(FORMAT, TYPE), TEST_SCANF_ERR_AKA_CPP(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64), true)
 #define TEST_SCANF_WARN_AKA_WIN32(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN32) \
-    testScanfWarnAkaWin32(__FILE__, __LINE__, TEST_SCANF_CODE(FORMAT, TYPE), TEST_SCANF_ERR_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN32))
+    testFormatStrWarnAkaWin32(__FILE__, __LINE__, TEST_SCANF_CODE(FORMAT, TYPE), TEST_SCANF_ERR_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN32))
+#define TEST_SCANF_WARN_AKA_CPP_WIN32(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN32) \
+    testFormatStrWarnAkaWin32(__FILE__, __LINE__, TEST_SCANF_CODE(FORMAT, TYPE), TEST_SCANF_ERR_AKA_CPP(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN32), true)
 
-// Macros for printf work just fine with scanf test functions.
-// TODO - invent better function names
 #define TEST_PRINTF_NOWARN(FORMAT, FORMATSTR, TYPE) \
-    testScanfNoWarn(__FILE__, __LINE__, TEST_PRINTF_CODE(FORMAT, TYPE))
+    testFormatStrNoWarn(__FILE__, __LINE__, TEST_PRINTF_CODE(FORMAT, TYPE))
+#define TEST_PRINTF_NOWARN_CPP(FORMAT, FORMATSTR, TYPE) \
+    testFormatStrNoWarn(__FILE__, __LINE__, TEST_PRINTF_CODE(FORMAT, TYPE), true)
 #define TEST_PRINTF_WARN(FORMAT, FORMATSTR, TYPE) \
-    testScanfWarn(__FILE__, __LINE__, TEST_PRINTF_CODE(FORMAT, TYPE), TEST_PRINTF_ERR(FORMAT, FORMATSTR, TYPE))
+    testFormatStrWarn(__FILE__, __LINE__, TEST_PRINTF_CODE(FORMAT, TYPE), TEST_PRINTF_ERR(FORMAT, FORMATSTR, TYPE))
 #define TEST_PRINTF_WARN_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE, AKATYPE_WIN64) \
-    testScanfWarnAka(__FILE__, __LINE__, TEST_PRINTF_CODE(FORMAT, TYPE), TEST_PRINTF_ERR_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE), TEST_PRINTF_ERR_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64))
+    testFormatStrWarnAka(__FILE__, __LINE__, TEST_PRINTF_CODE(FORMAT, TYPE), TEST_PRINTF_ERR_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE), TEST_PRINTF_ERR_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64))
+#define TEST_PRINTF_WARN_AKA_CPP(FORMAT, FORMATSTR, TYPE, AKATYPE, AKATYPE_WIN64) \
+    testFormatStrWarnAka(__FILE__, __LINE__, TEST_PRINTF_CODE(FORMAT, TYPE), TEST_PRINTF_ERR_AKA_CPP(FORMAT, FORMATSTR, TYPE, AKATYPE), TEST_PRINTF_ERR_AKA_CPP(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64), true)
 #define TEST_PRINTF_WARN_AKA_WIN64(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64) \
-    testScanfWarnAkaWin64(__FILE__, __LINE__, TEST_PRINTF_CODE(FORMAT, TYPE), TEST_PRINTF_ERR_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64))
+    testFormatStrWarnAkaWin64(__FILE__, __LINE__, TEST_PRINTF_CODE(FORMAT, TYPE), TEST_PRINTF_ERR_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64))
+#define TEST_PRINTF_WARN_AKA_CPP_WIN64(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64) \
+    testFormatStrWarnAkaWin64(__FILE__, __LINE__, TEST_PRINTF_CODE(FORMAT, TYPE), TEST_PRINTF_ERR_AKA_CPP(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN64), true)
 #define TEST_PRINTF_WARN_AKA_WIN32(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN32) \
-    testScanfWarnAkaWin32(__FILE__, __LINE__, TEST_PRINTF_CODE(FORMAT, TYPE), TEST_PRINTF_ERR_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN32))
+    testFormatStrWarnAkaWin32(__FILE__, __LINE__, TEST_PRINTF_CODE(FORMAT, TYPE), TEST_PRINTF_ERR_AKA(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN32))
+#define TEST_PRINTF_WARN_AKA_CPP_WIN32(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN32) \
+    testFormatStrWarnAkaWin32(__FILE__, __LINE__, TEST_PRINTF_CODE(FORMAT, TYPE), TEST_PRINTF_ERR_AKA_CPP(FORMAT, FORMATSTR, TYPE, AKATYPE_WIN32), true)
 
     void testScanfArgument() {
         check("void foo() {\n"
@@ -877,7 +959,7 @@ class TestIO : public TestFixture {
               "    fscanf(f, \"%7ms\", &ref);\n" // #3461
               "    sscanf(ip_port, \"%*[^:]:%4d\", &port);\n" // #3468
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    scanf(\"\", &foo);\n"
@@ -888,7 +970,7 @@ class TestIO : public TestFixture {
         ASSERT_EQUALS("[test.cpp:2]: (warning) scanf format string requires 0 parameters but 1 is given.\n"
                       "[test.cpp:3]: (warning) scanf format string requires 1 parameter but 2 are given.\n"
                       "[test.cpp:4]: (warning) fscanf format string requires 1 parameter but 2 are given.\n"
-                      "[test.cpp:5]: (warning) scanf format string requires 2 parameters but 3 are given.\n", errout.str());
+                      "[test.cpp:5]: (warning) scanf format string requires 2 parameters but 3 are given.\n", errout_str());
 
         check("void foo() {\n"
               "    scanf(\"%1d\");\n"
@@ -899,7 +981,7 @@ class TestIO : public TestFixture {
         ASSERT_EQUALS("[test.cpp:2]: (error) scanf format string requires 1 parameter but only 0 are given.\n"
                       "[test.cpp:3]: (error) scanf format string requires 2 parameters but only 1 is given.\n"
                       "[test.cpp:4]: (error) sscanf format string requires 2 parameters but only 1 is given.\n"
-                      "[test.cpp:5]: (error) scanf format string requires 2 parameters but only 1 is given.\n", errout.str());
+                      "[test.cpp:5]: (error) scanf format string requires 2 parameters but only 1 is given.\n", errout_str());
 
         check("void foo() {\n"
               "    char input[10];\n"
@@ -907,8 +989,8 @@ class TestIO : public TestFixture {
               "    sscanf(input, \"%3s\", output);\n"
               "    sscanf(input, \"%4s\", output);\n"
               "    sscanf(input, \"%5s\", output);\n"
-              "}", false);
-        ASSERT_EQUALS("[test.cpp:6]: (error) Width 5 given in format string (no. 1) is larger than destination buffer 'output[5]', use %4s to prevent overflowing it.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:6]: (error) Width 5 given in format string (no. 1) is larger than destination buffer 'output[5]', use %4s to prevent overflowing it.\n", errout_str());
 
         check("void foo() {\n"
               "    char input[10];\n"
@@ -917,10 +999,10 @@ class TestIO : public TestFixture {
               "    sscanf(input, \"%3s\", output);\n"
               "    sscanf(input, \"%4s\", output);\n"
               "    sscanf(input, \"%5s\", output);\n"
-              "}", true);
+              "}", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:5]: (warning, inconclusive) Width 3 given in format string (no. 1) is smaller than destination buffer 'output[5]'.\n"
                       "[test.cpp:7]: (error) Width 5 given in format string (no. 1) is larger than destination buffer 'output[5]', use %4s to prevent overflowing it.\n"
-                      "[test.cpp:4]: (warning) sscanf() without field width limits can crash with huge input data.\n", errout.str());
+                      "[test.cpp:4]: (warning) sscanf() without field width limits can crash with huge input data.\n", errout_str());
 
         check("void foo() {\n"
               "    const size_t BUFLENGTH(2048);\n"
@@ -929,8 +1011,8 @@ class TestIO : public TestFixture {
               "    bufT projectId= {0};\n"
               "    const int scanrc=sscanf(line, \"Project(\\\"{%36s}\\\")\", projectId);\n"
               "    sscanf(input, \"%5s\", output);\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:6]: (warning, inconclusive) Width 36 given in format string (no. 1) is smaller than destination buffer 'projectId[2048]'.\n", errout_str());
 
         check("void foo(unsigned int i) {\n"
               "  scanf(\"%h\", &i);\n"
@@ -951,7 +1033,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:7]: (warning) 'z' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
                       "[test.cpp:8]: (warning) 't' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
                       "[test.cpp:9]: (warning) 'L' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:10]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n", errout.str());
+                      "[test.cpp:10]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n", errout_str());
 
         // Unrecognized (and non-existent in standard library) specifiers.
         // Perhaps should emit warnings
@@ -960,8 +1042,8 @@ class TestIO : public TestFixture {
         TEST_SCANF_NOWARN("%zr", "size_t", "size_t");
         TEST_SCANF_NOWARN("%tm", "ptrdiff_t", "ptrdiff_t");
         TEST_SCANF_NOWARN("%La", "long double", "long double");
-        TEST_SCANF_NOWARN("%zv", "std::size_t", "std::size_t");
-        TEST_SCANF_NOWARN("%tp", "std::ptrdiff_t", "std::ptrdiff_t");
+        TEST_SCANF_NOWARN_CPP("%zv", "std::size_t", "std::size_t");
+        TEST_SCANF_NOWARN_CPP("%tp", "std::ptrdiff_t", "std::ptrdiff_t");
 
         TEST_SCANF_WARN("%u", "unsigned int", "bool");
         TEST_SCANF_WARN("%u", "unsigned int", "char");
@@ -987,25 +1069,25 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%u", "unsigned int", "uintmax_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%u", "unsigned int", "intptr_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%u", "unsigned int", "uintptr_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%u", "unsigned int", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%u", "unsigned int", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%u", "unsigned int", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%u", "unsigned int", "std::intmax_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%u", "unsigned int", "std::uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%u", "unsigned int", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%u", "unsigned int", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%u", "unsigned int", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%u", "unsigned int", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%u", "unsigned int", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%u", "unsigned int", "std::intmax_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%u", "unsigned int", "std::uintmax_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%u", "unsigned int", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%u", "unsigned int", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         check("void foo() {\n"
               "    scanf(\"%u\", \"s3\");\n"
               "    scanf(\"%u\", L\"s5W\");\n"
-              "}", true);
+              "}", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2]: (warning) %u in format string (no. 1) requires 'unsigned int *' but the argument type is 'const char *'.\n"
-                      "[test.cpp:3]: (warning) %u in format string (no. 1) requires 'unsigned int *' but the argument type is 'const wchar_t *'.\n", errout.str());
+                      "[test.cpp:3]: (warning) %u in format string (no. 1) requires 'unsigned int *' but the argument type is 'const wchar_t *'.\n", errout_str());
 
         check("void foo(long l) {\n"
               "    scanf(\"%u\", l);\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:2]: (warning) %u in format string (no. 1) requires 'unsigned int *' but the argument type is 'signed long'.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:2]: (warning) %u in format string (no. 1) requires 'unsigned int *' but the argument type is 'signed long'.\n", errout_str());
 
         TEST_SCANF_WARN("%lu","unsigned long","bool");
         TEST_SCANF_WARN("%lu","unsigned long","char");
@@ -1031,13 +1113,13 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%lu","unsigned long","uintmax_t","unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%lu","unsigned long","intptr_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA_WIN64("%lu","unsigned long","uintptr_t", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%lu","unsigned long","std::size_t","unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%lu","unsigned long","std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%lu","unsigned long","std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%lu","unsigned long","std::intmax_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%lu","unsigned long","std::uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%lu","unsigned long","std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA_WIN64("%lu","unsigned long","std::uintptr_t", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%lu","unsigned long","std::size_t","unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%lu","unsigned long","std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%lu","unsigned long","std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%lu","unsigned long","std::intmax_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%lu","unsigned long","std::uintmax_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%lu","unsigned long","std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP_WIN64("%lu","unsigned long","std::uintptr_t", "unsigned long long");
 
         TEST_SCANF_WARN("%lx","unsigned long","bool");
         TEST_SCANF_WARN("%lx","unsigned long","char");
@@ -1063,13 +1145,13 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%lx","unsigned long","uintmax_t","unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%lx","unsigned long","intptr_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA_WIN64("%lx","unsigned long","uintptr_t", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%lx","unsigned long","std::size_t","unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%lx","unsigned long","std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%lx","unsigned long","std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%lx","unsigned long","std::intmax_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%lx","unsigned long","std::uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%lx","unsigned long","std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA_WIN64("%lx","unsigned long","std::uintptr_t", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%lx","unsigned long","std::size_t","unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%lx","unsigned long","std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%lx","unsigned long","std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%lx","unsigned long","std::intmax_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%lx","unsigned long","std::uintmax_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%lx","unsigned long","std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP_WIN64("%lx","unsigned long","std::uintptr_t", "unsigned long long");
 
         TEST_SCANF_WARN("%ld","long","bool");
         TEST_SCANF_WARN("%ld","long","char");
@@ -1078,10 +1160,10 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN("%ld","long","void *");
         TEST_SCANF_WARN_AKA("%ld","long","size_t","unsigned long","unsigned long long");
         TEST_SCANF_WARN_AKA("%ld","long","intmax_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%ld","long","std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%ld","long","std::intmax_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA_WIN64("%ld","long","std::intptr_t", "signed long long");
-        TEST_SCANF_WARN_AKA("%ld","long","std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%ld","long","std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%ld","long","std::intmax_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP_WIN64("%ld","long","std::intptr_t", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%ld","long","std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_SCANF_WARN("%llu","unsigned long long","bool");
         TEST_SCANF_WARN("%llu","unsigned long long","char");
@@ -1107,13 +1189,13 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%llu","unsigned long long","uintmax_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%llu","unsigned long long","intptr_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA_WIN32("%llu","unsigned long long","uintptr_t", "unsigned long");
-        TEST_SCANF_WARN_AKA("%llu","unsigned long long","std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%llu","unsigned long long","std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%llu","unsigned long long","std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%llu","unsigned long long","std::intmax_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%llu","unsigned long long","std::uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%llu","unsigned long long","std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA_WIN32("%llu","unsigned long long","std::uintptr_t", "unsigned long");
+        TEST_SCANF_WARN_AKA_CPP("%llu","unsigned long long","std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%llu","unsigned long long","std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%llu","unsigned long long","std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%llu","unsigned long long","std::intmax_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%llu","unsigned long long","std::uintmax_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%llu","unsigned long long","std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP_WIN32("%llu","unsigned long long","std::uintptr_t", "unsigned long");
 
         TEST_SCANF_WARN("%llx","unsigned long long","bool");
         TEST_SCANF_WARN("%llx","unsigned long long","char");
@@ -1139,13 +1221,13 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%llx","unsigned long long","uintmax_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%llx","unsigned long long","intptr_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA_WIN32("%llx","unsigned long long","uintptr_t", "unsigned long");
-        TEST_SCANF_WARN_AKA("%llx","unsigned long long","std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%llx","unsigned long long","std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%llx","unsigned long long","std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%llx","unsigned long long","std::intmax_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%llx","unsigned long long","std::uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%llx","unsigned long long","std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA_WIN32("%llx","unsigned long long","std::uintptr_t", "unsigned long");
+        TEST_SCANF_WARN_AKA_CPP("%llx","unsigned long long","std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%llx","unsigned long long","std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%llx","unsigned long long","std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%llx","unsigned long long","std::intmax_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%llx","unsigned long long","std::uintmax_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%llx","unsigned long long","std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP_WIN32("%llx","unsigned long long","std::uintptr_t", "unsigned long");
 
         TEST_SCANF_WARN("%lld","long long","bool");
         TEST_SCANF_WARN("%lld","long long","char");
@@ -1154,9 +1236,9 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN("%lld","long long","void *");
         TEST_SCANF_WARN_AKA("%lld","long long","size_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%lld","long long","intmax_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%lld","long long","std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%lld","long long","std::intmax_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA_WIN32("%lld","long long","std::intptr_t", "signed long");
+        TEST_SCANF_WARN_AKA_CPP("%lld","long long","std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%lld","long long","std::intmax_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP_WIN32("%lld","long long","std::intptr_t", "signed long");
 
         TEST_SCANF_WARN("%hu", "unsigned short", "bool");
         TEST_SCANF_WARN("%hu", "unsigned short", "char");
@@ -1180,11 +1262,11 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%hu", "unsigned short", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%hu", "unsigned short", "intmax_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%hu", "unsigned short", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%hu", "unsigned short", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%hu", "unsigned short", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%hu", "unsigned short", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%hu", "unsigned short", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%hu", "unsigned short", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%hu", "unsigned short", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%hu", "unsigned short", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%hu", "unsigned short", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%hu", "unsigned short", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%hu", "unsigned short", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_SCANF_WARN("%hx", "unsigned short", "bool");
         TEST_SCANF_WARN("%hx", "unsigned short", "char");
@@ -1208,11 +1290,11 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%hx", "unsigned short", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%hx", "unsigned short", "intmax_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%hx", "unsigned short", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%hx", "unsigned short", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%hx", "unsigned short", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%hx", "unsigned short", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%hx", "unsigned short", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%hx", "unsigned short", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%hx", "unsigned short", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%hx", "unsigned short", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%hx", "unsigned short", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%hx", "unsigned short", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%hx", "unsigned short", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_SCANF_WARN("%hd", "short", "bool");
         TEST_SCANF_WARN("%hd", "short", "char");
@@ -1249,11 +1331,11 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%hhu", "unsigned char", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%hhu", "unsigned char", "intmax_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%hhu", "unsigned char", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%hhu", "unsigned char", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%hhu", "unsigned char", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%hhu", "unsigned char", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%hhu", "unsigned char", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%hhu", "unsigned char", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%hhu", "unsigned char", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%hhu", "unsigned char", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%hhu", "unsigned char", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%hhu", "unsigned char", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%hhu", "unsigned char", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_SCANF_WARN("%hhx", "unsigned char", "bool");
         TEST_SCANF_WARN("%hhx", "unsigned char", "char");
@@ -1277,11 +1359,11 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%hhx", "unsigned char", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%hhx", "unsigned char", "intmax_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%hhx", "unsigned char", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%hhx", "unsigned char", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%hhx", "unsigned char", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%hhx", "unsigned char", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%hhx", "unsigned char", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%hhx", "unsigned char", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%hhx", "unsigned char", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%hhx", "unsigned char", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%hhx", "unsigned char", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%hhx", "unsigned char", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%hhx", "unsigned char", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_SCANF_WARN("%hhd", "char", "bool");
         TEST_SCANF_NOWARN("%hhd", "char", "char");
@@ -1315,13 +1397,13 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%Lu", "unsigned long long", "uintmax_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%Lu", "unsigned long long", "intptr_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA_WIN32("%Lu", "unsigned long long", "uintptr_t", "unsigned long");
-        TEST_SCANF_WARN_AKA("%Lu", "unsigned long long", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%Lu", "unsigned long long", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%Lu", "unsigned long long", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%Lu", "unsigned long long", "std::intmax_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%Lu", "unsigned long long", "std::uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%Lu", "unsigned long long", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA_WIN32("%Lu", "unsigned long long", "std::uintptr_t", "unsigned long");
+        TEST_SCANF_WARN_AKA_CPP("%Lu", "unsigned long long", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%Lu", "unsigned long long", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%Lu", "unsigned long long", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%Lu", "unsigned long long", "std::intmax_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%Lu", "unsigned long long", "std::uintmax_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%Lu", "unsigned long long", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP_WIN32("%Lu", "unsigned long long", "std::uintptr_t", "unsigned long");
 
         TEST_SCANF_WARN("%Lx", "unsigned long long", "bool");
         TEST_SCANF_WARN("%Lx", "unsigned long long", "char");
@@ -1347,13 +1429,13 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%Lx", "unsigned long long", "uintmax_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%Lx", "unsigned long long", "intptr_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA_WIN32("%Lx", "unsigned long long", "uintptr_t", "unsigned long");
-        TEST_SCANF_WARN_AKA("%Lx", "unsigned long long", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%Lx", "unsigned long long", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%Lx", "unsigned long long", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%Lx", "unsigned long long", "std::intmax_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%Lx", "unsigned long long", "std::uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%Lx", "unsigned long long", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA_WIN32("%Lx", "unsigned long long", "std::uintptr_t", "unsigned long");
+        TEST_SCANF_WARN_AKA_CPP("%Lx", "unsigned long long", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%Lx", "unsigned long long", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%Lx", "unsigned long long", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%Lx", "unsigned long long", "std::intmax_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%Lx", "unsigned long long", "std::uintmax_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%Lx", "unsigned long long", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP_WIN32("%Lx", "unsigned long long", "std::uintptr_t", "unsigned long");
 
         TEST_SCANF_WARN("%Ld", "long long", "bool");
         TEST_SCANF_WARN("%Ld", "long long", "char");
@@ -1377,23 +1459,23 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%Ld", "long long", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA_WIN32("%Ld", "long long", "intmax_t", "signed long");
         TEST_SCANF_WARN_AKA("%Ld", "long long", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%Ld", "long long", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA_WIN32("%Ld", "long long", "std::ssize_t", "signed long");
-        TEST_SCANF_WARN_AKA_WIN32("%Ld", "long long", "std::ptrdiff_t", "signed long");
-        TEST_SCANF_WARN_AKA_WIN32("%Ld", "long long", "std::intptr_t", "signed long");
-        TEST_SCANF_WARN_AKA("%Ld", "long long", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%Ld", "long long", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP_WIN32("%Ld", "long long", "std::ssize_t", "signed long");
+        TEST_SCANF_WARN_AKA_CPP_WIN32("%Ld", "long long", "std::ptrdiff_t", "signed long");
+        TEST_SCANF_WARN_AKA_CPP_WIN32("%Ld", "long long", "std::intptr_t", "signed long");
+        TEST_SCANF_WARN_AKA_CPP("%Ld", "long long", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         check("void foo() {\n"
               "    scanf(\"%Ld\", \"s3\");\n"
               "    scanf(\"%Ld\", L\"s5W\");\n"
-              "}", true);
+              "}", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2]: (warning) %Ld in format string (no. 1) requires 'long long *' but the argument type is 'const char *'.\n"
-                      "[test.cpp:3]: (warning) %Ld in format string (no. 1) requires 'long long *' but the argument type is 'const wchar_t *'.\n", errout.str());
+                      "[test.cpp:3]: (warning) %Ld in format string (no. 1) requires 'long long *' but the argument type is 'const wchar_t *'.\n", errout_str());
 
         check("void foo(int i) {\n"
               "    scanf(\"%Ld\", i);\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:2]: (warning) %Ld in format string (no. 1) requires 'long long *' but the argument type is 'signed int'.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:2]: (warning) %Ld in format string (no. 1) requires 'long long *' but the argument type is 'signed int'.\n", errout_str());
 
         TEST_SCANF_WARN("%ju", "uintmax_t", "bool");
         TEST_SCANF_WARN("%ju", "uintmax_t", "char");
@@ -1417,13 +1499,13 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%ju", "uintmax_t", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%ju", "uintmax_t", "intmax_t", "signed long", "signed long long");
         TEST_SCANF_NOWARN("%ju", "uintmax_t", "uintmax_t");
-        TEST_SCANF_WARN_AKA("%ju", "uintmax_t", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%ju", "uintmax_t", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%ju", "uintmax_t", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%ju", "uintmax_t", "std::intmax_t", "signed long", "signed long long");
-        TEST_SCANF_NOWARN("%ju", "uintmax_t", "std::uintmax_t");
-        TEST_SCANF_WARN_AKA("%ju", "uintmax_t", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%ju", "uintmax_t", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%ju", "uintmax_t", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%ju", "uintmax_t", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%ju", "uintmax_t", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%ju", "uintmax_t", "std::intmax_t", "signed long", "signed long long");
+        TEST_SCANF_NOWARN_CPP("%ju", "uintmax_t", "std::uintmax_t");
+        TEST_SCANF_WARN_AKA_CPP("%ju", "uintmax_t", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%ju", "uintmax_t", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_SCANF_WARN("%jx", "uintmax_t", "bool");
         TEST_SCANF_WARN("%jx", "uintmax_t", "char");
@@ -1447,23 +1529,23 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%jx", "uintmax_t", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%jx", "uintmax_t", "intmax_t", "signed long", "signed long long");
         TEST_SCANF_NOWARN("%jx", "uintmax_t", "uintmax_t");
-        TEST_SCANF_WARN_AKA("%jx", "uintmax_t", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%jx", "uintmax_t", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%jx", "uintmax_t", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%jx", "uintmax_t", "std::intmax_t", "signed long", "signed long long");
-        TEST_SCANF_NOWARN("%jx", "uintmax_t", "std::uintmax_t");
-        TEST_SCANF_WARN_AKA("%jx", "uintmax_t", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%jx", "uintmax_t", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%jx", "uintmax_t", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%jx", "uintmax_t", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%jx", "uintmax_t", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%jx", "uintmax_t", "std::intmax_t", "signed long", "signed long long");
+        TEST_SCANF_NOWARN_CPP("%jx", "uintmax_t", "std::uintmax_t");
+        TEST_SCANF_WARN_AKA_CPP("%jx", "uintmax_t", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%jx", "uintmax_t", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_SCANF_WARN("%jd", "intmax_t", "long double");
         TEST_SCANF_WARN("%jd", "intmax_t", "void *");
-        // TODO TEST_SCANF_WARN("%jd", "intmax_t", "size_t");
-        // TODO TEST_SCANF_WARN("%jd", "intmax_t", "unsigned ptrdiff_t");
-        TEST_SCANF_WARN_AKA("%jd", "intmax_t", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%jd", "intmax_t", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA("%jd", "intmax_t", "size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA("%jd", "intmax_t", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%jd", "intmax_t", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%jd", "intmax_t", "std::ptrdiff_t", "signed long", "signed long long");
         TEST_SCANF_NOWARN("%jd", "intmax_t", "intmax_t");
         TEST_SCANF_WARN_AKA("%jd", "intmax_t", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_NOWARN("%jd", "intmax_t", "std::intmax_t");
+        TEST_SCANF_NOWARN_CPP("%jd", "intmax_t", "std::intmax_t");
 
         TEST_SCANF_WARN("%zu", "size_t", "bool");
         TEST_SCANF_WARN("%zu", "size_t", "char");
@@ -1487,11 +1569,11 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%zu", "size_t", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%zu", "size_t", "intmax_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%zu", "size_t", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_NOWARN("%zu", "size_t", "std::size_t");
-        TEST_SCANF_WARN_AKA("%zu", "size_t", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%zu", "size_t", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%zu", "size_t", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%zu", "size_t", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_NOWARN_CPP("%zu", "size_t", "std::size_t");
+        TEST_SCANF_WARN_AKA_CPP("%zu", "size_t", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%zu", "size_t", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%zu", "size_t", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%zu", "size_t", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_SCANF_WARN("%zx", "size_t", "bool");
         TEST_SCANF_WARN("%zx", "size_t", "char");
@@ -1515,11 +1597,11 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%zx", "size_t", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%zx", "size_t", "intmax_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%zx", "size_t", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_NOWARN("%zx", "size_t", "std::size_t");
-        TEST_SCANF_WARN_AKA("%zx", "size_t", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%zx", "size_t", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%zx", "size_t", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%zx", "size_t", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_NOWARN_CPP("%zx", "size_t", "std::size_t");
+        TEST_SCANF_WARN_AKA_CPP("%zx", "size_t", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%zx", "size_t", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%zx", "size_t", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%zx", "size_t", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_SCANF_WARN("%zd", "ssize_t", "bool");
         TEST_SCANF_WARN("%zd", "ssize_t", "signed short");
@@ -1528,6 +1610,8 @@ class TestIO : public TestFixture {
         TEST_SCANF_NOWARN("%zd", "ssize_t", "ssize_t");
         TEST_SCANF_WARN_AKA("%zd", "ssize_t", "ptrdiff_t", "signed long", "signed long long");
 
+        TEST_SCANF_WARN_AKA("%zi", "ssize_t", "size_t", "unsigned long", "unsigned long long");
+
         TEST_SCANF_WARN("%tu", "unsigned ptrdiff_t", "bool");
         TEST_SCANF_WARN("%tu", "unsigned ptrdiff_t", "char");
         TEST_SCANF_WARN("%tu", "unsigned ptrdiff_t", "signed char");
@@ -1550,11 +1634,11 @@ class TestIO : public TestFixture {
         TEST_SCANF_NOWARN("%tu", "unsigned ptrdiff_t", "unsigned ptrdiff_t");
         TEST_SCANF_WARN_AKA("%tu", "unsigned ptrdiff_t", "intmax_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%tu", "unsigned ptrdiff_t", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%tu", "unsigned ptrdiff_t", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%tu", "unsigned ptrdiff_t", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%tu", "unsigned ptrdiff_t", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%tu", "unsigned ptrdiff_t", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%tu", "unsigned ptrdiff_t", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%tu", "unsigned ptrdiff_t", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%tu", "unsigned ptrdiff_t", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%tu", "unsigned ptrdiff_t", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%tu", "unsigned ptrdiff_t", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%tu", "unsigned ptrdiff_t", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_SCANF_WARN("%tx", "unsigned ptrdiff_t", "bool");
         TEST_SCANF_WARN("%tx", "unsigned ptrdiff_t", "char");
@@ -1578,11 +1662,11 @@ class TestIO : public TestFixture {
         TEST_SCANF_NOWARN("%tx", "unsigned ptrdiff_t", "unsigned ptrdiff_t");
         TEST_SCANF_WARN_AKA("%tx", "unsigned ptrdiff_t", "intmax_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%tx", "unsigned ptrdiff_t", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%tx", "unsigned ptrdiff_t", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%tx", "unsigned ptrdiff_t", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%tx", "unsigned ptrdiff_t", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%tx", "unsigned ptrdiff_t", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%tx", "unsigned ptrdiff_t", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%tx", "unsigned ptrdiff_t", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%tx", "unsigned ptrdiff_t", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%tx", "unsigned ptrdiff_t", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%tx", "unsigned ptrdiff_t", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%tx", "unsigned ptrdiff_t", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_SCANF_WARN("%td", "ptrdiff_t", "long double");
         TEST_SCANF_WARN("%td", "ptrdiff_t", "void *");
@@ -1615,13 +1699,13 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%Iu", "size_t", "uintmax_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%Iu", "size_t", "intptr_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%Iu", "size_t", "uintptr_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_NOWARN("%Iu", "size_t", "std::size_t");
-        TEST_SCANF_WARN_AKA("%Iu", "size_t", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%Iu", "size_t", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%Iu", "size_t", "std::intmax_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%Iu", "size_t", "std::uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%Iu", "size_t", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%Iu", "size_t", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_NOWARN_CPP("%Iu", "size_t", "std::size_t");
+        TEST_SCANF_WARN_AKA_CPP("%Iu", "size_t", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%Iu", "size_t", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%Iu", "size_t", "std::intmax_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%Iu", "size_t", "std::uintmax_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%Iu", "size_t", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%Iu", "size_t", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_SCANF_WARN("%Ix", "size_t", "bool");
         TEST_SCANF_WARN("%Ix", "size_t", "char");
@@ -1647,13 +1731,13 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%Ix", "size_t", "uintmax_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%Ix", "size_t", "intptr_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%Ix", "size_t", "uintptr_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_NOWARN("%Ix", "size_t", "std::size_t");
-        TEST_SCANF_WARN_AKA("%Ix", "size_t", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%Ix", "size_t", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%Ix", "size_t", "std::intmax_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%Ix", "size_t", "std::uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%Ix", "size_t", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%Ix", "size_t", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_NOWARN_CPP("%Ix", "size_t", "std::size_t");
+        TEST_SCANF_WARN_AKA_CPP("%Ix", "size_t", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%Ix", "size_t", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%Ix", "size_t", "std::intmax_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%Ix", "size_t", "std::uintmax_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%Ix", "size_t", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%Ix", "size_t", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_SCANF_WARN("%Id", "ptrdiff_t", "bool");
         TEST_SCANF_WARN("%Id", "ptrdiff_t", "char");
@@ -1677,11 +1761,11 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%Id", "ptrdiff_t", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%Id", "ptrdiff_t", "intmax_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%Id", "ptrdiff_t", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%Id", "ptrdiff_t", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%Id", "ptrdiff_t", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_NOWARN("%Id", "ptrdiff_t", "std::ptrdiff_t");
-        TEST_SCANF_WARN_AKA("%Id", "ptrdiff_t", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%Id", "ptrdiff_t", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%Id", "ptrdiff_t", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%Id", "ptrdiff_t", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_NOWARN_CPP("%Id", "ptrdiff_t", "std::ptrdiff_t");
+        TEST_SCANF_WARN_AKA_CPP("%Id", "ptrdiff_t", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%Id", "ptrdiff_t", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_SCANF_WARN("%I64u", "unsigned __int64", "bool");
         TEST_SCANF_WARN("%I64u", "unsigned __int64", "char");
@@ -1707,13 +1791,13 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA_WIN32("%I64u", "unsigned __int64", "uintmax_t", "unsigned long");
         TEST_SCANF_WARN_AKA("%I64u", "unsigned __int64", "intptr_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA_WIN32("%I64u", "unsigned __int64", "uintptr_t", "unsigned long");
-        TEST_SCANF_WARN_AKA_WIN32("%I64u", "unsigned __int64", "std::size_t", "unsigned long");
-        TEST_SCANF_WARN_AKA("%I64u", "unsigned __int64", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%I64u", "unsigned __int64", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%I64u", "unsigned __int64", "std::intmax_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA_WIN32("%I64u", "unsigned __int64", "std::uintmax_t", "unsigned long");
-        TEST_SCANF_WARN_AKA("%I64u", "unsigned __int64", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA_WIN32("%I64u", "unsigned __int64", "std::uintptr_t", "unsigned long");
+        TEST_SCANF_WARN_AKA_CPP_WIN32("%I64u", "unsigned __int64", "std::size_t", "unsigned long");
+        TEST_SCANF_WARN_AKA_CPP("%I64u", "unsigned __int64", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%I64u", "unsigned __int64", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%I64u", "unsigned __int64", "std::intmax_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP_WIN32("%I64u", "unsigned __int64", "std::uintmax_t", "unsigned long");
+        TEST_SCANF_WARN_AKA_CPP("%I64u", "unsigned __int64", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP_WIN32("%I64u", "unsigned __int64", "std::uintptr_t", "unsigned long");
 
         TEST_SCANF_WARN("%I64x", "unsigned __int64", "bool");
         TEST_SCANF_WARN("%I64x", "unsigned __int64", "char");
@@ -1741,13 +1825,13 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA_WIN32("%I64x", "unsigned __int64", "uintmax_t", "unsigned long");
         TEST_SCANF_WARN_AKA("%I64x", "unsigned __int64", "intptr_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA_WIN32("%I64x", "unsigned __int64", "uintptr_t", "unsigned long");
-        TEST_SCANF_WARN_AKA_WIN32("%I64x", "unsigned __int64", "std::size_t", "unsigned long");
-        TEST_SCANF_WARN_AKA("%I64x", "unsigned __int64", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%I64x", "unsigned __int64", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%I64x", "unsigned __int64", "std::intmax_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA_WIN32("%I64x", "unsigned __int64", "std::uintmax_t", "unsigned long");
-        TEST_SCANF_WARN_AKA("%I64x", "unsigned __int64", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA_WIN32("%I64x", "unsigned __int64", "std::uintptr_t", "unsigned long");
+        TEST_SCANF_WARN_AKA_CPP_WIN32("%I64x", "unsigned __int64", "std::size_t", "unsigned long");
+        TEST_SCANF_WARN_AKA_CPP("%I64x", "unsigned __int64", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%I64x", "unsigned __int64", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%I64x", "unsigned __int64", "std::intmax_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP_WIN32("%I64x", "unsigned __int64", "std::uintmax_t", "unsigned long");
+        TEST_SCANF_WARN_AKA_CPP("%I64x", "unsigned __int64", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP_WIN32("%I64x", "unsigned __int64", "std::uintptr_t", "unsigned long");
 
         TEST_SCANF_WARN("%I64d", "__int64", "bool");
         TEST_SCANF_WARN("%I64d", "__int64", "signed char");
@@ -1783,13 +1867,13 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%I32u", "unsigned __int32", "uintmax_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%I32u", "unsigned __int32", "intptr_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%I32u", "unsigned __int32", "uintptr_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%I32u", "unsigned __int32", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%I32u", "unsigned __int32", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%I32u", "unsigned __int32", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%I32u", "unsigned __int32", "std::intmax_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%I32u", "unsigned __int32", "std::uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%I32u", "unsigned __int32", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%I32u", "unsigned __int32", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%I32u", "unsigned __int32", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%I32u", "unsigned __int32", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%I32u", "unsigned __int32", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%I32u", "unsigned __int32", "std::intmax_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%I32u", "unsigned __int32", "std::uintmax_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%I32u", "unsigned __int32", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%I32u", "unsigned __int32", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_SCANF_WARN("%I32x", "unsigned __int32", "bool");
         TEST_SCANF_WARN("%I32x", "unsigned __int32", "char");
@@ -1815,17 +1899,17 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%I32x", "unsigned __int32", "uintmax_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%I32x", "unsigned __int32", "intptr_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%I32x", "unsigned __int32", "uintptr_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%I32x", "unsigned __int32", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%I32x", "unsigned __int32", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%I32x", "unsigned __int32", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%I32x", "unsigned __int32", "std::intmax_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%I32x", "unsigned __int32", "std::uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%I32x", "unsigned __int32", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%I32x", "unsigned __int32", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%I32x", "unsigned __int32", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%I32x", "unsigned __int32", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%I32x", "unsigned __int32", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%I32x", "unsigned __int32", "std::intmax_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%I32x", "unsigned __int32", "std::uintmax_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%I32x", "unsigned __int32", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%I32x", "unsigned __int32", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_SCANF_WARN("%I32d", "__int32", "bool");
         TEST_SCANF_WARN("%I32d", "__int32", "void *");
-        //TODO TEST_SCANF_WARN_AKA("%I32d", "__int32", "size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA("%I32d", "__int32", "size_t", "unsigned long", "unsigned long long");
         //TODO TEST_SCANF_WARN_AKA_WIN32("%I32d", "__int32", "ssize_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%I32d", "__int32", "ptrdiff_t", "signed long", "signed long long");
         TEST_SCANF_NOWARN("%I32d", "__int32", "__int32");
@@ -1852,23 +1936,23 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%d", "int", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%d", "int", "intmax_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%d", "int", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%d", "int", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%d", "int", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%d", "int", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%d", "int", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%d", "int", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%d", "int", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%d", "int", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%d", "int", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%d", "int", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%d", "int", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         check("void foo() {\n"
               "    scanf(\"%d\", \"s3\");\n"
               "    scanf(\"%d\", L\"s5W\");\n"
-              "}", true);
+              "}", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2]: (warning) %d in format string (no. 1) requires 'int *' but the argument type is 'const char *'.\n"
-                      "[test.cpp:3]: (warning) %d in format string (no. 1) requires 'int *' but the argument type is 'const wchar_t *'.\n", errout.str());
+                      "[test.cpp:3]: (warning) %d in format string (no. 1) requires 'int *' but the argument type is 'const wchar_t *'.\n", errout_str());
 
         check("void foo(long l) {\n"
               "    scanf(\"%d\", l);\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:2]: (warning) %d in format string (no. 1) requires 'int *' but the argument type is 'signed long'.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:2]: (warning) %d in format string (no. 1) requires 'int *' but the argument type is 'signed long'.\n", errout_str());
 
         TEST_SCANF_WARN("%x", "unsigned int", "bool");
         TEST_SCANF_WARN("%x", "unsigned int", "char");
@@ -1894,25 +1978,25 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%x", "unsigned int", "uintmax_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%x", "unsigned int", "intptr_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%x", "unsigned int", "uintptr_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%x", "unsigned int", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%x", "unsigned int", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%x", "unsigned int", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%x", "unsigned int", "std::intmax_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%x", "unsigned int", "std::uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%x", "unsigned int", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%x", "unsigned int", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%x", "unsigned int", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%x", "unsigned int", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%x", "unsigned int", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%x", "unsigned int", "std::intmax_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%x", "unsigned int", "std::uintmax_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%x", "unsigned int", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%x", "unsigned int", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         check("void foo() {\n"
               "    scanf(\"%x\", \"s3\");\n"
               "    scanf(\"%x\", L\"s5W\");\n"
-              "}", true);
+              "}", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2]: (warning) %x in format string (no. 1) requires 'unsigned int *' but the argument type is 'const char *'.\n"
-                      "[test.cpp:3]: (warning) %x in format string (no. 1) requires 'unsigned int *' but the argument type is 'const wchar_t *'.\n", errout.str());
+                      "[test.cpp:3]: (warning) %x in format string (no. 1) requires 'unsigned int *' but the argument type is 'const wchar_t *'.\n", errout_str());
 
         check("void foo(long l) {\n"
               "    scanf(\"%x\", l);\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:2]: (warning) %x in format string (no. 1) requires 'unsigned int *' but the argument type is 'signed long'.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:2]: (warning) %x in format string (no. 1) requires 'unsigned int *' but the argument type is 'signed long'.\n", errout_str());
 
         TEST_SCANF_WARN("%f", "float", "bool");
         TEST_SCANF_WARN("%f", "float", "char");
@@ -1936,23 +2020,23 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%f", "float", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%f", "float", "intmax_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%f", "float", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%f", "float", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%f", "float", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%f", "float", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%f", "float", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%f", "float", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%f", "float", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%f", "float", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%f", "float", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%f", "float", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%f", "float", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         check("void foo() {\n"
               "    scanf(\"%f\", \"s3\");\n"
               "    scanf(\"%f\", L\"s5W\");\n"
-              "}", true);
+              "}", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2]: (warning) %f in format string (no. 1) requires 'float *' but the argument type is 'const char *'.\n"
-                      "[test.cpp:3]: (warning) %f in format string (no. 1) requires 'float *' but the argument type is 'const wchar_t *'.\n", errout.str());
+                      "[test.cpp:3]: (warning) %f in format string (no. 1) requires 'float *' but the argument type is 'const wchar_t *'.\n", errout_str());
 
         check("void foo(float f) {\n"
               "    scanf(\"%f\", f);\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:2]: (warning) %f in format string (no. 1) requires 'float *' but the argument type is 'float'.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:2]: (warning) %f in format string (no. 1) requires 'float *' but the argument type is 'float'.\n", errout_str());
 
         TEST_SCANF_WARN("%lf", "double", "bool");
         TEST_SCANF_WARN("%lf", "double", "char");
@@ -1976,11 +2060,11 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%lf", "double", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%lf", "double", "intmax_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%lf", "double", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%lf", "double", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%lf", "double", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%lf", "double", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%lf", "double", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%lf", "double", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%lf", "double", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%lf", "double", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%lf", "double", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%lf", "double", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%lf", "double", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_SCANF_WARN("%Lf", "long double", "bool");
         TEST_SCANF_WARN("%Lf", "long double", "char");
@@ -2004,11 +2088,11 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%Lf", "long double", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%Lf", "long double", "intmax_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%Lf", "long double", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%Lf", "long double", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%Lf", "long double", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%Lf", "long double", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%Lf", "long double", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%Lf", "long double", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%Lf", "long double", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%Lf", "long double", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%Lf", "long double", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%Lf", "long double", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%Lf", "long double", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_SCANF_WARN("%n", "int", "bool");
         TEST_SCANF_WARN("%n", "int", "char");
@@ -2032,23 +2116,23 @@ class TestIO : public TestFixture {
         TEST_SCANF_WARN_AKA("%n", "int", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_SCANF_WARN_AKA("%n", "int", "intmax_t", "signed long", "signed long long");
         TEST_SCANF_WARN_AKA("%n", "int", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%n", "int", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_SCANF_WARN_AKA("%n", "int", "std::ssize_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%n", "int", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%n", "int", "std::intptr_t", "signed long", "signed long long");
-        TEST_SCANF_WARN_AKA("%n", "int", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%n", "int", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_SCANF_WARN_AKA_CPP("%n", "int", "std::ssize_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%n", "int", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%n", "int", "std::intptr_t", "signed long", "signed long long");
+        TEST_SCANF_WARN_AKA_CPP("%n", "int", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         check("void foo() {\n"
               "    scanf(\"%n\", \"s3\");\n"
               "    scanf(\"%n\", L\"s5W\");\n"
-              "}", true);
+              "}", dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS("[test.cpp:2]: (warning) %n in format string (no. 1) requires 'int *' but the argument type is 'const char *'.\n"
-                      "[test.cpp:3]: (warning) %n in format string (no. 1) requires 'int *' but the argument type is 'const wchar_t *'.\n", errout.str());
+                      "[test.cpp:3]: (warning) %n in format string (no. 1) requires 'int *' but the argument type is 'const wchar_t *'.\n", errout_str());
 
         check("void foo(long l) {\n"
               "    scanf(\"%n\", l);\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:2]: (warning) %n in format string (no. 1) requires 'int *' but the argument type is 'signed long'.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:2]: (warning) %n in format string (no. 1) requires 'int *' but the argument type is 'signed long'.\n", errout_str());
 
         check("void g() {\n" // #5104
               "    myvector<int> v1(1);\n"
@@ -2061,11 +2145,11 @@ class TestIO : public TestFixture {
               "    scanf(\"%lf\",&v4[0]);\n"
               "    myvector<char *> v5(1);\n"
               "    scanf(\"%10s\",v5[0]);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         {
-            const char * code = "void g() {\n" // #5348
+            const char code[] = "void g() {\n" // #5348
                                 "    size_t s1;\n"
                                 "    ptrdiff_t s2;\n"
                                 "    ssize_t s3;\n"
@@ -2078,23 +2162,36 @@ class TestIO : public TestFixture {
             const char* result_win64("[test.cpp:5]: (portability) %zd in format string (no. 1) requires 'ssize_t *' but the argument type is 'size_t * {aka unsigned long long *}'.\n"
                                      "[test.cpp:6]: (portability) %zd in format string (no. 1) requires 'ssize_t *' but the argument type is 'ptrdiff_t * {aka signed long long *}'.\n");
 
-            check(code, false, true, Settings::Unix32);
-            ASSERT_EQUALS(result, errout.str());
-            check(code, false, true, Settings::Unix64);
-            ASSERT_EQUALS(result, errout.str());
-            check(code, false, true, Settings::Win32A);
-            ASSERT_EQUALS(result, errout.str());
-            check(code, false, true, Settings::Win64);
-            ASSERT_EQUALS(result_win64, errout.str());
+            check(code, dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix32));
+            ASSERT_EQUALS(result, errout_str());
+            check(code, dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
+            ASSERT_EQUALS(result, errout_str());
+            check(code, dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
+            ASSERT_EQUALS(result, errout_str());
+            check(code, dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32W));
+            ASSERT_EQUALS(result, errout_str());
+            check(code, dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
+            ASSERT_EQUALS(result_win64, errout_str());
         }
         {
             check("void g() {\n"
                   "    const char c[]=\"42\";\n"
                   "    scanf(\"%s\", c);\n"
-                  "}\n");
+                  "}");
             ASSERT_EQUALS("[test.cpp:3]: (warning) %s in format string (no. 1) requires a 'char *' but the argument type is 'const char *'.\n"
-                          "[test.cpp:3]: (warning) scanf() without field width limits can crash with huge input data.\n", errout.str());
+                          "[test.cpp:3]: (warning) scanf() without field width limits can crash with huge input data.\n", errout_str());
         }
+
+        check("void f() {\n" // #7038
+              "    scanf(\"%i\", \"abc\" + 1);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2]: (warning) %i in format string (no. 1) requires 'int *' but the argument type is 'const char *'.\n", errout_str());
+
+        check("struct S { unsigned char a[1]; };" // #14302
+              "void f(S s) {\n"
+              "    scanf(\"%hhu\", s.a);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testPrintfArgument() {
@@ -2117,7 +2214,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:7]: (error) fprintf format string requires 2 parameters but only 0 are given.\n"
                       "[test.cpp:8]: (error) snprintf format string requires 2 parameters but only 0 are given.\n"
                       "[test.cpp:9]: (error) sprintf format string requires 3 parameters but only 2 are given.\n"
-                      "[test.cpp:10]: (error) snprintf format string requires 2 parameters but only 1 is given.\n", errout.str());
+                      "[test.cpp:10]: (error) snprintf format string requires 2 parameters but only 1 is given.\n", errout_str());
 
         check("void foo(char *str) {\n"
               "    printf(\"\", 0);\n"
@@ -2126,7 +2223,7 @@ class TestIO : public TestFixture {
               "}");
         ASSERT_EQUALS("[test.cpp:2]: (warning) printf format string requires 0 parameters but 1 is given.\n"
                       "[test.cpp:3]: (warning) printf format string requires 1 parameter but 2 are given.\n"
-                      "[test.cpp:4]: (warning) printf format string requires 2 parameters but 3 are given.\n", errout.str());
+                      "[test.cpp:4]: (warning) printf format string requires 2 parameters but 3 are given.\n", errout_str());
 
         check("void foo() {\n" // swprintf exists as MSVC extension and as standard function: #4790
               "    swprintf(string1, L\"%i\", 32, string2);\n" // MSVC implementation
@@ -2135,7 +2232,7 @@ class TestIO : public TestFixture {
               "    swprintf(string1, 6, L\"%i%s\", 32, string2);\n" // Standard implementation
               "}");
         ASSERT_EQUALS("[test.cpp:2]: (warning) swprintf format string requires 1 parameter but 2 are given.\n"
-                      "[test.cpp:4]: (warning) swprintf format string requires 1 parameter but 2 are given.\n", errout.str());
+                      "[test.cpp:4]: (warning) swprintf format string requires 1 parameter but 2 are given.\n", errout_str());
 
         check("void foo(char *str) {\n"
               "    printf(\"%i\", 0);\n"
@@ -2151,7 +2248,7 @@ class TestIO : public TestFixture {
               "    fprintf(stderr, \"%*cText.\", indent, ' ');\n" // #3313
               "    sprintf(string1, \"%*\", 32);\n" // #3364
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(char* s, const char* s2, std::string s3, int i) {\n"
               "    printf(\"%s%s\", s, s2);\n"
@@ -2164,7 +2261,7 @@ class TestIO : public TestFixture {
         ASSERT_EQUALS("[test.cpp:3]: (warning) %s in format string (no. 1) requires 'char *' but the argument type is 'signed int'.\n"
                       "[test.cpp:4]: (warning) %s in format string (no. 2) requires 'char *' but the argument type is 'signed int'.\n"
                       "[test.cpp:5]: (warning) %s in format string (no. 1) requires 'char *' but the argument type is 'std::string'.\n"
-                      "[test.cpp:7]: (warning) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'char *'.\n", errout.str());
+                      "[test.cpp:7]: (warning) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'char *'.\n", errout_str());
 
         check("void foo(char* s, const char* s2, std::string s3, int i) {\n"
               "    printf(\"%jd\", s);\n"
@@ -2179,7 +2276,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:4]: (warning) %ju in format string (no. 1) requires 'uintmax_t' but the argument type is 'const char *'.\n"
                       "[test.cpp:5]: (warning) %jo in format string (no. 1) requires 'uintmax_t' but the argument type is 'std::string'.\n"
                       "[test.cpp:6]: (warning) %jx in format string (no. 1) requires 'uintmax_t' but the argument type is 'signed int'.\n"
-                      "[test.cpp:7]: (warning) %jX in format string (no. 1) requires 'uintmax_t' but the argument type is 'signed int'.\n", errout.str());
+                      "[test.cpp:7]: (warning) %jX in format string (no. 1) requires 'uintmax_t' but the argument type is 'signed int'.\n", errout_str());
 
         check("void foo(uintmax_t uim, std::string s3, unsigned int ui, int i) {\n"
               "    printf(\"%ju\", uim);\n"
@@ -2191,7 +2288,7 @@ class TestIO : public TestFixture {
         ASSERT_EQUALS("[test.cpp:3]: (warning) %ju in format string (no. 1) requires 'uintmax_t' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:4]: (warning) %jd in format string (no. 1) requires 'intmax_t' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:5]: (warning) %jd in format string (no. 1) requires 'intmax_t' but the argument type is 'std::string'.\n"
-                      "[test.cpp:6]: (warning) %jd in format string (no. 1) requires 'intmax_t' but the argument type is 'signed int'.\n", errout.str());
+                      "[test.cpp:6]: (warning) %jd in format string (no. 1) requires 'intmax_t' but the argument type is 'signed int'.\n", errout_str());
 
         check("void foo(const int* cpi, const int ci, int i, int* pi, std::string s) {\n"
               "    printf(\"%n\", cpi);\n"
@@ -2204,12 +2301,12 @@ class TestIO : public TestFixture {
         ASSERT_EQUALS("[test.cpp:3]: (warning) %n in format string (no. 1) requires 'int *' but the argument type is 'signed int'.\n"
                       "[test.cpp:4]: (warning) %n in format string (no. 1) requires 'int *' but the argument type is 'signed int'.\n"
                       "[test.cpp:6]: (warning) %n in format string (no. 1) requires 'int *' but the argument type is 'std::string'.\n"
-                      "[test.cpp:7]: (warning) %n in format string (no. 1) requires 'int *' but the argument type is 'const char *'.\n", errout.str());
+                      "[test.cpp:7]: (warning) %n in format string (no. 1) requires 'int *' but the argument type is 'const char *'.\n", errout_str());
 
         check("void foo() {\n"
               "    printf(\"%n\", L\"s5W\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) %n in format string (no. 1) requires 'int *' but the argument type is 'const wchar_t *'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2]: (warning) %n in format string (no. 1) requires 'int *' but the argument type is 'const wchar_t *'.\n", errout_str());
 
         check("class foo {};\n"
               "void foo(const int* cpi, foo f, bar b, bar* bp, double d, int i, unsigned int u) {\n"
@@ -2226,7 +2323,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:4]: (warning) %c in format string (no. 1) requires 'unsigned int' but the argument type is 'const char *'.\n"
                       "[test.cpp:5]: (warning) %o in format string (no. 1) requires 'unsigned int' but the argument type is 'double'.\n"
                       "[test.cpp:6]: (warning) %x in format string (no. 1) requires 'unsigned int' but the argument type is 'const signed int *'.\n"
-                      "[test.cpp:8]: (warning) %X in format string (no. 1) requires 'unsigned int' but the argument type is 'bar *'.\n", errout.str());
+                      "[test.cpp:8]: (warning) %X in format string (no. 1) requires 'unsigned int' but the argument type is 'bar *'.\n", errout_str());
 
         check("class foo {};\n"
               "void foo(const char* cpc, char* pc) {\n"
@@ -2234,7 +2331,7 @@ class TestIO : public TestFixture {
               "    printf(\"%x\", pc);\n"
               "}");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %x in format string (no. 1) requires 'unsigned int' but the argument type is 'const char *'.\n"
-                      "[test.cpp:4]: (warning) %x in format string (no. 1) requires 'unsigned int' but the argument type is 'char *'.\n", errout.str());
+                      "[test.cpp:4]: (warning) %x in format string (no. 1) requires 'unsigned int' but the argument type is 'char *'.\n", errout_str());
 
         check("class foo {};\n"
               "void foo() {\n"
@@ -2246,7 +2343,7 @@ class TestIO : public TestFixture {
         ASSERT_EQUALS("[test.cpp:3]: (warning) %x in format string (no. 1) requires 'unsigned int' but the argument type is 'const wchar_t *'.\n"
                       "[test.cpp:4]: (warning) %X in format string (no. 1) requires 'unsigned int' but the argument type is 'const wchar_t *'.\n"
                       "[test.cpp:5]: (warning) %c in format string (no. 1) requires 'unsigned int' but the argument type is 'const wchar_t *'.\n"
-                      "[test.cpp:6]: (warning) %o in format string (no. 1) requires 'unsigned int' but the argument type is 'const wchar_t *'.\n", errout.str());
+                      "[test.cpp:6]: (warning) %o in format string (no. 1) requires 'unsigned int' but the argument type is 'const wchar_t *'.\n", errout_str());
 
         check("class foo {};\n"
               "void foo(const int* cpi, foo f, bar b, bar* bp, double d, unsigned int u, unsigned char uc) {\n"
@@ -2264,7 +2361,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'double'.\n"
                       "[test.cpp:6]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:7]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'const signed int *'.\n"
-                      "[test.cpp:9]: (warning) %i in format string (no. 1) requires 'int' but the argument type is 'bar *'.\n", errout.str());
+                      "[test.cpp:9]: (warning) %i in format string (no. 1) requires 'int' but the argument type is 'bar *'.\n", errout_str());
 
         check("class foo {};\n"
               "void foo() {\n"
@@ -2272,7 +2369,7 @@ class TestIO : public TestFixture {
               "    printf(\"%d\", L\"s5W\");\n"
               "}");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %i in format string (no. 1) requires 'int' but the argument type is 'const wchar_t *'.\n"
-                      "[test.cpp:4]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'const wchar_t *'.\n", errout.str());
+                      "[test.cpp:4]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'const wchar_t *'.\n", errout_str());
 
         check("class foo {};\n"
               "void foo(const int* cpi, foo f, bar b, bar* bp, double d, int i, bool bo) {\n"
@@ -2290,13 +2387,13 @@ class TestIO : public TestFixture {
                       "[test.cpp:5]: (warning) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'double'.\n"
                       "[test.cpp:6]: (warning) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'signed int'.\n"
                       "[test.cpp:7]: (warning) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'const signed int *'.\n"
-                      "[test.cpp:9]: (warning) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'bar *'.\n", errout.str());
+                      "[test.cpp:9]: (warning) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'bar *'.\n", errout_str());
 
         check("class foo {};\n"
               "void foo(const int* cpi, foo f, bar b, bar* bp, double d, int i, bool bo) {\n"
               "    printf(\"%u\", L\"s5W\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'const wchar_t *'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3]: (warning) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'const wchar_t *'.\n", errout_str());
 
         check("class foo {};\n"
               "void foo(const int* cpi, foo f, bar b, bar* bp, char c) {\n"
@@ -2307,7 +2404,7 @@ class TestIO : public TestFixture {
               "    printf(\"%p\", b);\n"
               "}");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %p in format string (no. 1) requires an address but the argument type is 'foo'.\n"
-                      "[test.cpp:4]: (warning) %p in format string (no. 1) requires an address but the argument type is 'char'.\n", errout.str());
+                      "[test.cpp:4]: (warning) %p in format string (no. 1) requires an address but the argument type is 'char'.\n", errout_str());
 
         check("class foo {};\n"
               "void foo(char* pc, const char* cpc, wchar_t* pwc, const wchar_t* cpwc) {\n"
@@ -2318,7 +2415,7 @@ class TestIO : public TestFixture {
               "    printf(\"%p\", \"s4\");\n"
               "    printf(\"%p\", L\"s5W\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class foo {};\n"
               "void foo(const int* cpi, foo f, bar b, bar* bp, double d) {\n"
@@ -2333,7 +2430,7 @@ class TestIO : public TestFixture {
         ASSERT_EQUALS("[test.cpp:3]: (warning) %e in format string (no. 1) requires 'double' but the argument type is 'foo'.\n"
                       "[test.cpp:4]: (warning) %E in format string (no. 1) requires 'double' but the argument type is 'const char *'.\n"
                       "[test.cpp:5]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'const signed int *'.\n"
-                      "[test.cpp:6]: (warning) %G in format string (no. 1) requires 'double' but the argument type is 'bar *'.\n", errout.str());
+                      "[test.cpp:6]: (warning) %G in format string (no. 1) requires 'double' but the argument type is 'bar *'.\n", errout_str());
 
         check("class foo {};\n"
               "void foo(const char* cpc, char* pc) {\n"
@@ -2347,7 +2444,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:4]: (warning) %E in format string (no. 1) requires 'double' but the argument type is 'char *'.\n"
                       "[test.cpp:5]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'const char *'.\n"
                       "[test.cpp:6]: (warning) %G in format string (no. 1) requires 'double' but the argument type is 'char *'.\n"
-                      "[test.cpp:7]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'char *'.\n", errout.str());
+                      "[test.cpp:7]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'char *'.\n", errout_str());
 
         check("class foo {};\n"
               "void foo() {\n"
@@ -2359,7 +2456,7 @@ class TestIO : public TestFixture {
         ASSERT_EQUALS("[test.cpp:3]: (warning) %e in format string (no. 1) requires 'double' but the argument type is 'const wchar_t *'.\n"
                       "[test.cpp:4]: (warning) %E in format string (no. 1) requires 'double' but the argument type is 'const wchar_t *'.\n"
                       "[test.cpp:5]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'const wchar_t *'.\n"
-                      "[test.cpp:6]: (warning) %G in format string (no. 1) requires 'double' but the argument type is 'const wchar_t *'.\n", errout.str());
+                      "[test.cpp:6]: (warning) %G in format string (no. 1) requires 'double' but the argument type is 'const wchar_t *'.\n", errout_str());
 
         check("class foo;\n"
               "void foo(foo f) {\n"
@@ -2369,7 +2466,7 @@ class TestIO : public TestFixture {
               "}");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'foo'.\n"
                       "[test.cpp:4]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'foo'.\n"
-                      "[test.cpp:5]: (warning) %p in format string (no. 1) requires an address but the argument type is 'foo'.\n", errout.str());
+                      "[test.cpp:5]: (warning) %p in format string (no. 1) requires an address but the argument type is 'foo'.\n", errout_str());
 
         // Ticket #4189 (Improve check (printf("%l") not detected)) tests (according to C99 7.19.6.1.7)
         // False positive tests
@@ -2378,13 +2475,13 @@ class TestIO : public TestFixture {
               "  printf(\"%hd %hu\", si, usi);\n"
               "}");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %hhx in format string (no. 1) requires 'unsigned char' but the argument type is 'signed char'.\n"
-                      "[test.cpp:2]: (warning) %hhd in format string (no. 2) requires 'char' but the argument type is 'unsigned char'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %hhd in format string (no. 2) requires 'char' but the argument type is 'unsigned char'.\n", errout_str());
 
         check("void foo(long long int lli, unsigned long long int ulli, long int li, unsigned long int uli) {\n"
               "  printf(\"%llo %llx\", lli, ulli);\n"
               "  printf(\"%ld %lu\", li, uli);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(intmax_t im, uintmax_t uim, size_t s, ptrdiff_t p, long double ld, std::size_t ss, std::ptrdiff_t sp) {\n"
               "  printf(\"%jd %jo\", im, uim);\n"
@@ -2394,7 +2491,7 @@ class TestIO : public TestFixture {
               "  printf(\"%zx\", ss);\n"
               "  printf(\"%ti\", sp);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Unrecognized (and non-existent in standard library) specifiers.
         // Perhaps should emit warnings
@@ -2406,32 +2503,32 @@ class TestIO : public TestFixture {
               "  printf(\"%zv\", ss);\n"
               "  printf(\"%tp\", sp);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(long long l, ptrdiff_t p, std::ptrdiff_t sp) {\n"
               "  printf(\"%td\", p);\n"
               "  printf(\"%td\", sp);\n"
               "  printf(\"%td\", l);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) %td in format string (no. 1) requires 'ptrdiff_t' but the argument type is 'signed long long'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4]: (warning) %td in format string (no. 1) requires 'ptrdiff_t' but the argument type is 'signed long long'.\n", errout_str());
 
         check("void foo(int i, long double ld) {\n"
               "  printf(\"%zx %zu\", i, ld);\n"
               "}");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %zx in format string (no. 1) requires 'size_t' but the argument type is 'signed int'.\n"
-                      "[test.cpp:2]: (warning) %zu in format string (no. 2) requires 'size_t' but the argument type is 'long double'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %zu in format string (no. 2) requires 'size_t' but the argument type is 'long double'.\n", errout_str());
 
         check("void foo(unsigned int ui, long double ld) {\n"
               "  printf(\"%zu %zx\", ui, ld);\n"
               "}");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %zu in format string (no. 1) requires 'size_t' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:2]: (warning) %zx in format string (no. 2) requires 'size_t' but the argument type is 'long double'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %zx in format string (no. 2) requires 'size_t' but the argument type is 'long double'.\n", errout_str());
 
         check("void foo(int i, long double ld) {\n"
               "  printf(\"%tx %tu\", i, ld);\n"
               "}");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %tx in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'signed int'.\n"
-                      "[test.cpp:2]: (warning) %tu in format string (no. 2) requires 'unsigned ptrdiff_t' but the argument type is 'long double'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %tu in format string (no. 2) requires 'unsigned ptrdiff_t' but the argument type is 'long double'.\n", errout_str());
 
         // False negative test
         check("void foo(unsigned int i) {\n"
@@ -2453,7 +2550,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:7]: (warning) 'z' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
                       "[test.cpp:8]: (warning) 't' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
                       "[test.cpp:9]: (warning) 'L' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:10]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n", errout.str());
+                      "[test.cpp:10]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n", errout_str());
 
         check("void foo(unsigned int i) {\n"
               "  printf(\"%hd\", i);\n"
@@ -2464,74 +2561,74 @@ class TestIO : public TestFixture {
         ASSERT_EQUALS("[test.cpp:2]: (warning) %hd in format string (no. 1) requires 'short' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:3]: (warning) %hhd in format string (no. 1) requires 'char' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:4]: (warning) %ld in format string (no. 1) requires 'long' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:5]: (warning) %lld in format string (no. 1) requires 'long long' but the argument type is 'unsigned int'.\n", errout.str());
+                      "[test.cpp:5]: (warning) %lld in format string (no. 1) requires 'long long' but the argument type is 'unsigned int'.\n", errout_str());
 
         check("void foo(size_t s, ptrdiff_t p) {\n"
               "  printf(\"%zd\", s);\n"
               "  printf(\"%tu\", p);\n"
-              "}", false, true, Settings::Unix32);
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix32));
         ASSERT_EQUALS("[test.cpp:2]: (portability) %zd in format string (no. 1) requires 'ssize_t' but the argument type is 'size_t {aka unsigned long}'.\n"
-                      "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'ptrdiff_t {aka signed long}'.\n", errout.str());
+                      "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'ptrdiff_t {aka signed long}'.\n", errout_str());
 
         check("void foo(std::size_t s, std::ptrdiff_t p) {\n"
               "  printf(\"%zd\", s);\n"
               "  printf(\"%tu\", p);\n"
-              "}", false, true, Settings::Unix32);
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix32));
         ASSERT_EQUALS("[test.cpp:2]: (portability) %zd in format string (no. 1) requires 'ssize_t' but the argument type is 'std::size_t {aka unsigned long}'.\n"
-                      "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'std::ptrdiff_t {aka signed long}'.\n", errout.str());
+                      "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'std::ptrdiff_t {aka signed long}'.\n", errout_str());
 
         check("void foo(size_t s, ptrdiff_t p) {\n"
               "  printf(\"%zd\", s);\n"
               "  printf(\"%tu\", p);\n"
-              "}", false, true, Settings::Unix64);
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
         ASSERT_EQUALS("[test.cpp:2]: (portability) %zd in format string (no. 1) requires 'ssize_t' but the argument type is 'size_t {aka unsigned long}'.\n"
-                      "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'ptrdiff_t {aka signed long}'.\n", errout.str());
+                      "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'ptrdiff_t {aka signed long}'.\n", errout_str());
 
         check("void foo(std::size_t s, std::ptrdiff_t p) {\n"
               "  printf(\"%zd\", s);\n"
               "  printf(\"%tu\", p);\n"
-              "}", false, true, Settings::Unix64);
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
         ASSERT_EQUALS("[test.cpp:2]: (portability) %zd in format string (no. 1) requires 'ssize_t' but the argument type is 'std::size_t {aka unsigned long}'.\n"
-                      "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'std::ptrdiff_t {aka signed long}'.\n", errout.str());
+                      "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'std::ptrdiff_t {aka signed long}'.\n", errout_str());
 
         check("void foo(size_t s, ptrdiff_t p) {\n"
               "  printf(\"%zd\", s);\n"
               "  printf(\"%tu\", p);\n"
-              "}", false, true, Settings::Win32A);
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("[test.cpp:2]: (portability) %zd in format string (no. 1) requires 'ssize_t' but the argument type is 'size_t {aka unsigned long}'.\n"
-                      "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'ptrdiff_t {aka signed long}'.\n", errout.str());
+                      "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'ptrdiff_t {aka signed long}'.\n", errout_str());
 
         check("void foo(std::size_t s, std::ptrdiff_t p) {\n"
               "  printf(\"%zd\", s);\n"
               "  printf(\"%tu\", p);\n"
-              "}", false, true, Settings::Win32A);
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("[test.cpp:2]: (portability) %zd in format string (no. 1) requires 'ssize_t' but the argument type is 'std::size_t {aka unsigned long}'.\n"
-                      "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'std::ptrdiff_t {aka signed long}'.\n", errout.str());
+                      "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'std::ptrdiff_t {aka signed long}'.\n", errout_str());
 
         check("void foo(size_t s, ptrdiff_t p) {\n"
               "  printf(\"%zd\", s);\n"
               "  printf(\"%tu\", p);\n"
-              "}", false, true, Settings::Win64);
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
         ASSERT_EQUALS("[test.cpp:2]: (portability) %zd in format string (no. 1) requires 'ssize_t' but the argument type is 'size_t {aka unsigned long long}'.\n"
-                      "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'ptrdiff_t {aka signed long long}'.\n", errout.str());
+                      "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'ptrdiff_t {aka signed long long}'.\n", errout_str());
 
         check("void foo(std::size_t s, std::ptrdiff_t p) {\n"
               "  printf(\"%zd\", s);\n"
               "  printf(\"%tu\", p);\n"
-              "}", false, true, Settings::Win64);
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
         ASSERT_EQUALS("[test.cpp:2]: (portability) %zd in format string (no. 1) requires 'ssize_t' but the argument type is 'std::size_t {aka unsigned long long}'.\n"
-                      "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'std::ptrdiff_t {aka signed long long}'.\n", errout.str());
+                      "[test.cpp:3]: (portability) %tu in format string (no. 1) requires 'unsigned ptrdiff_t' but the argument type is 'std::ptrdiff_t {aka signed long long}'.\n", errout_str());
 
         check("void foo(size_t s, uintmax_t um) {\n"
               "  printf(\"%lu\", s);\n"
               "  printf(\"%lu\", um);\n"
               "  printf(\"%llu\", s);\n"
               "  printf(\"%llu\", um);\n"
-              "}", false, true, Settings::Win64);
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
         ASSERT_EQUALS("[test.cpp:2]: (portability) %lu in format string (no. 1) requires 'unsigned long' but the argument type is 'size_t {aka unsigned long long}'.\n"
                       "[test.cpp:3]: (portability) %lu in format string (no. 1) requires 'unsigned long' but the argument type is 'uintmax_t {aka unsigned long long}'.\n"
                       "[test.cpp:4]: (portability) %llu in format string (no. 1) requires 'unsigned long long' but the argument type is 'size_t {aka unsigned long long}'.\n"
-                      "[test.cpp:5]: (portability) %llu in format string (no. 1) requires 'unsigned long long' but the argument type is 'uintmax_t {aka unsigned long long}'.\n", errout.str());
+                      "[test.cpp:5]: (portability) %llu in format string (no. 1) requires 'unsigned long long' but the argument type is 'uintmax_t {aka unsigned long long}'.\n", errout_str());
 
         check("void foo(unsigned int i) {\n"
               "  printf(\"%ld\", i);\n"
@@ -2546,21 +2643,21 @@ class TestIO : public TestFixture {
                       "[test.cpp:4]: (warning) %lu in format string (no. 1) requires 'unsigned long' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:5]: (warning) %llu in format string (no. 1) requires 'unsigned long long' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:6]: (warning) %lx in format string (no. 1) requires 'unsigned long' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:7]: (warning) %llx in format string (no. 1) requires 'unsigned long long' but the argument type is 'unsigned int'.\n", errout.str());
+                      "[test.cpp:7]: (warning) %llx in format string (no. 1) requires 'unsigned long long' but the argument type is 'unsigned int'.\n", errout_str());
 
         check("void foo(int i, intmax_t im, ptrdiff_t p) {\n"
               "  printf(\"%lld\", i);\n"
               "  printf(\"%lld\", im);\n"
               "  printf(\"%lld\", p);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) %lld in format string (no. 1) requires 'long long' but the argument type is 'signed int'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2]: (warning) %lld in format string (no. 1) requires 'long long' but the argument type is 'signed int'.\n", errout_str());
 
         check("void foo(intmax_t im, ptrdiff_t p) {\n"
               "  printf(\"%lld\", im);\n"
               "  printf(\"%lld\", p);\n"
-              "}", false, true, Settings::Win64);
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
         ASSERT_EQUALS("[test.cpp:2]: (portability) %lld in format string (no. 1) requires 'long long' but the argument type is 'intmax_t {aka signed long long}'.\n"
-                      "[test.cpp:3]: (portability) %lld in format string (no. 1) requires 'long long' but the argument type is 'ptrdiff_t {aka signed long long}'.\n", errout.str());
+                      "[test.cpp:3]: (portability) %lld in format string (no. 1) requires 'long long' but the argument type is 'ptrdiff_t {aka signed long long}'.\n", errout_str());
 
         check("class Foo {\n"
               "    double d;\n"
@@ -2583,7 +2680,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:13]: (warning) %f in format string (no. 3) requires 'double' but the argument type is 'int'.\n"
                       "[test.cpp:13]: (warning) %d in format string (no. 4) requires 'int' but the argument type is 'double'.\n"
                       "[test.cpp:13]: (warning) %f in format string (no. 5) requires 'double' but the argument type is 'int'.\n"
-                      "[test.cpp:13]: (warning) %f in format string (no. 6) requires 'double' but the argument type is 'int'.\n", errout.str());
+                      "[test.cpp:13]: (warning) %f in format string (no. 6) requires 'double' but the argument type is 'int'.\n", errout_str());
 
         check("short f() { return 0; }\n"
               "void foo() { printf(\"%d %u %lu %I64u %I64d %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }");
@@ -2593,7 +2690,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %I64d in format string (no. 5) requires '__int64' but the argument type is 'signed short'.\n"
                       "[test.cpp:2]: (warning) %f in format string (no. 6) requires 'double' but the argument type is 'signed short'.\n"
                       "[test.cpp:2]: (warning) %Lf in format string (no. 7) requires 'long double' but the argument type is 'signed short'.\n"
-                      "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'signed short'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'signed short'.\n", errout_str());
 
         check("unsigned short f() { return 0; }\n"
               "void foo() { printf(\"%u %d %ld %I64d %I64u %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }");
@@ -2602,7 +2699,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %I64u in format string (no. 5) requires 'unsigned __int64' but the argument type is 'unsigned short'.\n"
                       "[test.cpp:2]: (warning) %f in format string (no. 6) requires 'double' but the argument type is 'unsigned short'.\n"
                       "[test.cpp:2]: (warning) %Lf in format string (no. 7) requires 'long double' but the argument type is 'unsigned short'.\n"
-                      "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'unsigned short'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'unsigned short'.\n", errout_str());
 
         check("int f() { return 0; }\n"
               "void foo() { printf(\"%d %u %lu %I64u %I64d %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }");
@@ -2612,7 +2709,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %I64d in format string (no. 5) requires '__int64' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %f in format string (no. 6) requires 'double' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %Lf in format string (no. 7) requires 'long double' but the argument type is 'signed int'.\n"
-                      "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'signed int'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'signed int'.\n", errout_str());
 
         check("unsigned int f() { return 0; }\n"
               "void foo() { printf(\"%u %d %ld %I64d %I64u %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }");
@@ -2622,7 +2719,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %I64u in format string (no. 5) requires 'unsigned __int64' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:2]: (warning) %f in format string (no. 6) requires 'double' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:2]: (warning) %Lf in format string (no. 7) requires 'long double' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'unsigned int'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'unsigned int'.\n", errout_str());
 
         check("long f() { return 0; }\n"
               "void foo() { printf(\"%ld %u %lu %I64u %I64d %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }");
@@ -2632,7 +2729,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %I64d in format string (no. 5) requires '__int64' but the argument type is 'signed long'.\n"
                       "[test.cpp:2]: (warning) %f in format string (no. 6) requires 'double' but the argument type is 'signed long'.\n"
                       "[test.cpp:2]: (warning) %Lf in format string (no. 7) requires 'long double' but the argument type is 'signed long'.\n"
-                      "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'signed long'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'signed long'.\n", errout_str());
 
         check("unsigned long f() { return 0; }\n"
               "void foo() { printf(\"%lu %d %ld %I64d %I64u %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }");
@@ -2642,7 +2739,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %I64u in format string (no. 5) requires 'unsigned __int64' but the argument type is 'unsigned long'.\n"
                       "[test.cpp:2]: (warning) %f in format string (no. 6) requires 'double' but the argument type is 'unsigned long'.\n"
                       "[test.cpp:2]: (warning) %Lf in format string (no. 7) requires 'long double' but the argument type is 'unsigned long'.\n"
-                      "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'unsigned long'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'unsigned long'.\n", errout_str());
 
         check("long long f() { return 0; }\n"
               "void foo() { printf(\"%lld %u %lu %I64u %I64d %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }");
@@ -2651,7 +2748,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %I64u in format string (no. 4) requires 'unsigned __int64' but the argument type is 'signed long long'.\n"
                       "[test.cpp:2]: (warning) %f in format string (no. 6) requires 'double' but the argument type is 'signed long long'.\n"
                       "[test.cpp:2]: (warning) %Lf in format string (no. 7) requires 'long double' but the argument type is 'signed long long'.\n"
-                      "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'signed long long'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'signed long long'.\n", errout_str());
 
         check("unsigned long long f() { return 0; }\n"
               "void foo() { printf(\"%llu %d %ld %I64d %I64u %f %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f()); }");
@@ -2660,7 +2757,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %I64d in format string (no. 4) requires '__int64' but the argument type is 'unsigned long long'.\n"
                       "[test.cpp:2]: (warning) %f in format string (no. 6) requires 'double' but the argument type is 'unsigned long long'.\n"
                       "[test.cpp:2]: (warning) %Lf in format string (no. 7) requires 'long double' but the argument type is 'unsigned long long'.\n"
-                      "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'unsigned long long'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %p in format string (no. 8) requires an address but the argument type is 'unsigned long long'.\n", errout_str());
 
         check("float f() { return 0; }\n"
               "void foo() { printf(\"%f %d %ld %u %lu %I64d %I64u %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f(), f()); }");
@@ -2671,7 +2768,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %I64d in format string (no. 6) requires '__int64' but the argument type is 'float'.\n"
                       "[test.cpp:2]: (warning) %I64u in format string (no. 7) requires 'unsigned __int64' but the argument type is 'float'.\n"
                       "[test.cpp:2]: (warning) %Lf in format string (no. 8) requires 'long double' but the argument type is 'float'.\n"
-                      "[test.cpp:2]: (warning) %p in format string (no. 9) requires an address but the argument type is 'float'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %p in format string (no. 9) requires an address but the argument type is 'float'.\n", errout_str());
 
         check("double f() { return 0; }\n"
               "void foo() { printf(\"%f %d %ld %u %lu %I64d %I64u %Lf %p\", f(), f(), f(), f(), f(), f(), f(), f(), f()); }");
@@ -2682,7 +2779,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %I64d in format string (no. 6) requires '__int64' but the argument type is 'double'.\n"
                       "[test.cpp:2]: (warning) %I64u in format string (no. 7) requires 'unsigned __int64' but the argument type is 'double'.\n"
                       "[test.cpp:2]: (warning) %Lf in format string (no. 8) requires 'long double' but the argument type is 'double'.\n"
-                      "[test.cpp:2]: (warning) %p in format string (no. 9) requires an address but the argument type is 'double'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %p in format string (no. 9) requires an address but the argument type is 'double'.\n", errout_str());
 
         check("long double f() { return 0; }\n"
               "void foo() { printf(\"%Lf %d %ld %u %lu %I64d %I64u %f %p\", f(), f(), f(), f(), f(), f(), f(), f(), f()); }");
@@ -2693,37 +2790,37 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %I64d in format string (no. 6) requires '__int64' but the argument type is 'long double'.\n"
                       "[test.cpp:2]: (warning) %I64u in format string (no. 7) requires 'unsigned __int64' but the argument type is 'long double'.\n"
                       "[test.cpp:2]: (warning) %f in format string (no. 8) requires 'double' but the argument type is 'long double'.\n"
-                      "[test.cpp:2]: (warning) %p in format string (no. 9) requires an address but the argument type is 'long double'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %p in format string (no. 9) requires an address but the argument type is 'long double'.\n", errout_str());
 
         check("int f() { return 0; }\n"
               "void foo() { printf(\"%I64d %I64u %I64x %d\", f(), f(), f(), f()); }");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %I64d in format string (no. 1) requires '__int64' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %I64u in format string (no. 2) requires 'unsigned __int64' but the argument type is 'signed int'.\n"
-                      "[test.cpp:2]: (warning) %I64x in format string (no. 3) requires 'unsigned __int64' but the argument type is 'signed int'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %I64x in format string (no. 3) requires 'unsigned __int64' but the argument type is 'signed int'.\n", errout_str());
 
         check("long long f() { return 0; }\n"
               "void foo() { printf(\"%I32d %I32u %I32x %lld\", f(), f(), f(), f()); }");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %I32d in format string (no. 1) requires '__int32' but the argument type is 'signed long long'.\n"
                       "[test.cpp:2]: (warning) %I32u in format string (no. 2) requires 'unsigned __int32' but the argument type is 'signed long long'.\n"
-                      "[test.cpp:2]: (warning) %I32x in format string (no. 3) requires 'unsigned __int32' but the argument type is 'signed long long'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %I32x in format string (no. 3) requires 'unsigned __int32' but the argument type is 'signed long long'.\n", errout_str());
 
         check("unsigned long long f() { return 0; }\n"
               "void foo() { printf(\"%I32d %I32u %I32x %llx\", f(), f(), f(), f()); }");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %I32d in format string (no. 1) requires '__int32' but the argument type is 'unsigned long long'.\n"
                       "[test.cpp:2]: (warning) %I32u in format string (no. 2) requires 'unsigned __int32' but the argument type is 'unsigned long long'.\n"
-                      "[test.cpp:2]: (warning) %I32x in format string (no. 3) requires 'unsigned __int32' but the argument type is 'unsigned long long'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %I32x in format string (no. 3) requires 'unsigned __int32' but the argument type is 'unsigned long long'.\n", errout_str());
 
         check("signed char f() { return 0; }\n"
               "void foo() { printf(\"%Id %Iu %Ix %hhi\", f(), f(), f(), f()); }");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %Id in format string (no. 1) requires 'ptrdiff_t' but the argument type is 'signed char'.\n"
                       "[test.cpp:2]: (warning) %Iu in format string (no. 2) requires 'size_t' but the argument type is 'signed char'.\n"
-                      "[test.cpp:2]: (warning) %Ix in format string (no. 3) requires 'size_t' but the argument type is 'signed char'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %Ix in format string (no. 3) requires 'size_t' but the argument type is 'signed char'.\n", errout_str());
 
         check("unsigned char f() { return 0; }\n"
               "void foo() { printf(\"%Id %Iu %Ix %hho\", f(), f(), f(), f()); }");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %Id in format string (no. 1) requires 'ptrdiff_t' but the argument type is 'unsigned char'.\n"
                       "[test.cpp:2]: (warning) %Iu in format string (no. 2) requires 'size_t' but the argument type is 'unsigned char'.\n"
-                      "[test.cpp:2]: (warning) %Ix in format string (no. 3) requires 'size_t' but the argument type is 'unsigned char'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %Ix in format string (no. 3) requires 'size_t' but the argument type is 'unsigned char'.\n", errout_str());
 
         check("namespace bar { int f() { return 0; } }\n"
               "void foo() { printf(\"%d %u %lu %f %Lf %p\", bar::f(), bar::f(), bar::f(), bar::f(), bar::f(), bar::f()); }");
@@ -2731,7 +2828,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %lu in format string (no. 3) requires 'unsigned long' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %Lf in format string (no. 5) requires 'long double' but the argument type is 'signed int'.\n"
-                      "[test.cpp:2]: (warning) %p in format string (no. 6) requires an address but the argument type is 'signed int'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %p in format string (no. 6) requires an address but the argument type is 'signed int'.\n", errout_str());
 
         check("struct Fred { int i; } f;\n"
               "void foo() { printf(\"%d %u %lu %f %Lf %p\", f.i, f.i, f.i, f.i, f.i, f.i); }");
@@ -2739,7 +2836,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %lu in format string (no. 3) requires 'unsigned long' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %Lf in format string (no. 5) requires 'long double' but the argument type is 'signed int'.\n"
-                      "[test.cpp:2]: (warning) %p in format string (no. 6) requires an address but the argument type is 'signed int'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %p in format string (no. 6) requires an address but the argument type is 'signed int'.\n", errout_str());
 
         check("struct Fred { unsigned int u; } f;\n"
               "void foo() { printf(\"%u %d %ld %f %Lf %p\", f.u, f.u, f.u, f.u, f.u, f.u); }");
@@ -2747,7 +2844,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %ld in format string (no. 3) requires 'long' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:2]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:2]: (warning) %Lf in format string (no. 5) requires 'long double' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:2]: (warning) %p in format string (no. 6) requires an address but the argument type is 'unsigned int'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %p in format string (no. 6) requires an address but the argument type is 'unsigned int'.\n", errout_str());
 
         check("struct Fred { unsigned int ui() { return 0; } } f;\n"
               "void foo() { printf(\"%u %d %ld %f %Lf %p\", f.ui(), f.ui(), f.ui(), f.ui(), f.ui(), f.ui()); }");
@@ -2755,14 +2852,14 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %ld in format string (no. 3) requires 'long' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:2]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:2]: (warning) %Lf in format string (no. 5) requires 'long double' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:2]: (warning) %p in format string (no. 6) requires an address but the argument type is 'unsigned int'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %p in format string (no. 6) requires an address but the argument type is 'unsigned int'.\n", errout_str());
 
         // #4975
         check("void f(int len, int newline) {\n"
               "    printf(\"%s\", newline ? a : str + len);\n"
               "    printf(\"%s\", newline + newline);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) %s in format string (no. 1) requires 'char *' but the argument type is 'signed int'.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3]: (warning) %s in format string (no. 1) requires 'char *' but the argument type is 'signed int'.\n", errout_str());
 
         check("struct Fred { int i; } f;\n"
               "struct Fred & bar() { };\n"
@@ -2771,7 +2868,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:3]: (warning) %lu in format string (no. 3) requires 'unsigned long' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %Lf in format string (no. 5) requires 'long double' but the argument type is 'signed int'.\n"
-                      "[test.cpp:3]: (warning) %p in format string (no. 6) requires an address but the argument type is 'signed int'.\n", errout.str());
+                      "[test.cpp:3]: (warning) %p in format string (no. 6) requires an address but the argument type is 'signed int'.\n", errout_str());
 
         check("struct Fred { int i; } f;\n"
               "const struct Fred & bar() { };\n"
@@ -2780,7 +2877,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:3]: (warning) %lu in format string (no. 3) requires 'unsigned long' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %Lf in format string (no. 5) requires 'long double' but the argument type is 'signed int'.\n"
-                      "[test.cpp:3]: (warning) %p in format string (no. 6) requires an address but the argument type is 'signed int'.\n", errout.str());
+                      "[test.cpp:3]: (warning) %p in format string (no. 6) requires an address but the argument type is 'signed int'.\n", errout_str());
 
         check("struct Fred { int i; } f;\n"
               "static const struct Fred & bar() { };\n"
@@ -2789,7 +2886,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:3]: (warning) %lu in format string (no. 3) requires 'unsigned long' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %Lf in format string (no. 5) requires 'long double' but the argument type is 'signed int'.\n"
-                      "[test.cpp:3]: (warning) %p in format string (no. 6) requires an address but the argument type is 'signed int'.\n", errout.str());
+                      "[test.cpp:3]: (warning) %p in format string (no. 6) requires an address but the argument type is 'signed int'.\n", errout_str());
 
         check("struct Fred { int i; } f[2];\n"
               "struct Fred * bar() { return f; };\n"
@@ -2798,7 +2895,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:3]: (warning) %lu in format string (no. 3) requires 'unsigned long' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %Lf in format string (no. 5) requires 'long double' but the argument type is 'signed int'.\n"
-                      "[test.cpp:3]: (warning) %p in format string (no. 6) requires an address but the argument type is 'signed int'.\n", errout.str());
+                      "[test.cpp:3]: (warning) %p in format string (no. 6) requires an address but the argument type is 'signed int'.\n", errout_str());
 
         check("struct Fred { int i; } f[2];\n"
               "const struct Fred * bar() { return f; };\n"
@@ -2807,7 +2904,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:3]: (warning) %lu in format string (no. 3) requires 'unsigned long' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %Lf in format string (no. 5) requires 'long double' but the argument type is 'signed int'.\n"
-                      "[test.cpp:3]: (warning) %p in format string (no. 6) requires an address but the argument type is 'signed int'.\n", errout.str());
+                      "[test.cpp:3]: (warning) %p in format string (no. 6) requires an address but the argument type is 'signed int'.\n", errout_str());
 
         check("struct Fred { int i; } f[2];\n"
               "static const struct Fred * bar() { return f; };\n"
@@ -2816,7 +2913,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:3]: (warning) %lu in format string (no. 3) requires 'unsigned long' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %Lf in format string (no. 5) requires 'long double' but the argument type is 'signed int'.\n"
-                      "[test.cpp:3]: (warning) %p in format string (no. 6) requires an address but the argument type is 'signed int'.\n", errout.str());
+                      "[test.cpp:3]: (warning) %p in format string (no. 6) requires an address but the argument type is 'signed int'.\n", errout_str());
 
         check("struct Fred { int32_t i; } f;\n"
               "struct Fred & bar() { };\n"
@@ -2826,111 +2923,111 @@ class TestIO : public TestFixture {
                       "[test.cpp:3]: (warning) %lu in format string (no. 4) requires 'unsigned long' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %f in format string (no. 5) requires 'double' but the argument type is 'signed int'.\n"
                       "[test.cpp:3]: (warning) %Lf in format string (no. 6) requires 'long double' but the argument type is 'signed int'.\n",
-                      errout.str());
+                      errout_str());
 
         // #4984
         check("void f(double *x) {\n"
               "    printf(\"%f\", x[0]);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("int array[10];\n"
               "int * foo() { return array; }\n"
               "void f() {\n"
               "    printf(\"%f\", foo()[0]);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'signed int'.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'signed int'.\n", errout_str());
 
         check("struct Base { int length() { } };\n"
               "struct Derived : public Base { };\n"
               "void foo(Derived * d) {\n"
               "    printf(\"%f\", d.length());\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'signed int'.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'signed int'.\n", errout_str());
 
         check("std::vector<int> v;\n"
               "void foo() {\n"
               "    printf(\"%d %u %f\", v[0], v[0], v[0]);\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
-                      "[test.cpp:3]: (warning) %f in format string (no. 3) requires 'double' but the argument type is 'signed int'.\n", errout.str());
+                      "[test.cpp:3]: (warning) %f in format string (no. 3) requires 'double' but the argument type is 'signed int'.\n", errout_str());
 
         // #4999 (crash)
         check("int bar(int a);\n"
               "void foo() {\n"
               "    printf(\"%d\", bar(0));\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("std::vector<int> v;\n"
               "std::string s;\n"
               "void foo() {\n"
               "    printf(\"%zu %Iu %d %f\", v.size(), v.size(), v.size(), v.size());\n"
               "    printf(\"%zu %Iu %d %f\", s.size(), s.size(), s.size(), s.size());\n"
-              "}\n", false, true, Settings::Win32A);
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("[test.cpp:4]: (portability) %d in format string (no. 3) requires 'int' but the argument type is 'std::size_t {aka unsigned long}'.\n"
                       "[test.cpp:4]: (portability) %f in format string (no. 4) requires 'double' but the argument type is 'std::size_t {aka unsigned long}'.\n"
                       "[test.cpp:5]: (portability) %d in format string (no. 3) requires 'int' but the argument type is 'std::size_t {aka unsigned long}'.\n"
-                      "[test.cpp:5]: (portability) %f in format string (no. 4) requires 'double' but the argument type is 'std::size_t {aka unsigned long}'.\n", errout.str());
+                      "[test.cpp:5]: (portability) %f in format string (no. 4) requires 'double' but the argument type is 'std::size_t {aka unsigned long}'.\n", errout_str());
 
         check("std::vector<int> v;\n"
               "std::string s;\n"
               "void foo() {\n"
               "    printf(\"%zu %Iu %d %f\", v.size(), v.size(), v.size(), v.size());\n"
               "    printf(\"%zu %Iu %d %f\", s.size(), s.size(), s.size(), s.size());\n"
-              "}\n", false, true, Settings::Win64);
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
         ASSERT_EQUALS("[test.cpp:4]: (portability) %d in format string (no. 3) requires 'int' but the argument type is 'std::size_t {aka unsigned long long}'.\n"
                       "[test.cpp:4]: (portability) %f in format string (no. 4) requires 'double' but the argument type is 'std::size_t {aka unsigned long long}'.\n"
                       "[test.cpp:5]: (portability) %d in format string (no. 3) requires 'int' but the argument type is 'std::size_t {aka unsigned long long}'.\n"
-                      "[test.cpp:5]: (portability) %f in format string (no. 4) requires 'double' but the argument type is 'std::size_t {aka unsigned long long}'.\n", errout.str());
+                      "[test.cpp:5]: (portability) %f in format string (no. 4) requires 'double' but the argument type is 'std::size_t {aka unsigned long long}'.\n", errout_str());
 
         check("std::vector<int> v;\n"
               "std::string s;\n"
               "void foo() {\n"
               "    printf(\"%zu %Iu %d %f\", v.size(), v.size(), v.size(), v.size());\n"
               "    printf(\"%zu %Iu %d %f\", s.size(), s.size(), s.size(), s.size());\n"
-              "}\n", false, true, Settings::Unix32);
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix32));
         ASSERT_EQUALS("[test.cpp:4]: (portability) %d in format string (no. 3) requires 'int' but the argument type is 'std::size_t {aka unsigned long}'.\n"
                       "[test.cpp:4]: (portability) %f in format string (no. 4) requires 'double' but the argument type is 'std::size_t {aka unsigned long}'.\n"
                       "[test.cpp:5]: (portability) %d in format string (no. 3) requires 'int' but the argument type is 'std::size_t {aka unsigned long}'.\n"
-                      "[test.cpp:5]: (portability) %f in format string (no. 4) requires 'double' but the argument type is 'std::size_t {aka unsigned long}'.\n", errout.str());
+                      "[test.cpp:5]: (portability) %f in format string (no. 4) requires 'double' but the argument type is 'std::size_t {aka unsigned long}'.\n", errout_str());
 
         check("std::vector<int> v;\n"
               "std::string s;\n"
               "void foo() {\n"
               "    printf(\"%zu %Iu %d %f\", v.size(), v.size(), v.size(), v.size());\n"
               "    printf(\"%zu %Iu %d %f\", s.size(), s.size(), s.size(), s.size());\n"
-              "}\n", false, true, Settings::Unix64);
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
         ASSERT_EQUALS("[test.cpp:4]: (portability) %d in format string (no. 3) requires 'int' but the argument type is 'std::size_t {aka unsigned long}'.\n"
                       "[test.cpp:4]: (portability) %f in format string (no. 4) requires 'double' but the argument type is 'std::size_t {aka unsigned long}'.\n"
                       "[test.cpp:5]: (portability) %d in format string (no. 3) requires 'int' but the argument type is 'std::size_t {aka unsigned long}'.\n"
-                      "[test.cpp:5]: (portability) %f in format string (no. 4) requires 'double' but the argument type is 'std::size_t {aka unsigned long}'.\n", errout.str());
+                      "[test.cpp:5]: (portability) %f in format string (no. 4) requires 'double' but the argument type is 'std::size_t {aka unsigned long}'.\n", errout_str());
 
         check("class Fred : public std::vector<int> {} v;\n"
               "std::string s;\n"
               "void foo() {\n"
               "    printf(\"%zu %Iu %d %f\", v.size(), v.size(), v.size(), v.size());\n"
               "    printf(\"%zu %Iu %d %f\", s.size(), s.size(), s.size(), s.size());\n"
-              "}\n", false, true, Settings::Unix64);
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
         ASSERT_EQUALS("[test.cpp:4]: (portability) %d in format string (no. 3) requires 'int' but the argument type is 'size_t {aka unsigned long}'.\n"
                       "[test.cpp:4]: (portability) %f in format string (no. 4) requires 'double' but the argument type is 'size_t {aka unsigned long}'.\n"
                       "[test.cpp:5]: (portability) %d in format string (no. 3) requires 'int' but the argument type is 'std::size_t {aka unsigned long}'.\n"
-                      "[test.cpp:5]: (portability) %f in format string (no. 4) requires 'double' but the argument type is 'std::size_t {aka unsigned long}'.\n", errout.str());
+                      "[test.cpp:5]: (portability) %f in format string (no. 4) requires 'double' but the argument type is 'std::size_t {aka unsigned long}'.\n", errout_str());
 
         check("class Fred : public std::vector<int> {} v;\n"
               "void foo() {\n"
               "    printf(\"%d %u %f\", v[0], v[0], v[0]);\n"
-              "}\n", false, true, Settings::Unix64);
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
         ASSERT_EQUALS("[test.cpp:3]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'int'.\n"
-                      "[test.cpp:3]: (warning) %f in format string (no. 3) requires 'double' but the argument type is 'int'.\n", errout.str());
+                      "[test.cpp:3]: (warning) %f in format string (no. 3) requires 'double' but the argument type is 'int'.\n", errout_str());
 
         check("std::string s;\n"
               "void foo() {\n"
               "    printf(\"%s %p %u %d %f\", s.c_str(), s.c_str(), s.c_str(), s.c_str(), s.c_str());\n"
-              "}\n", false, true, Settings::Unix64);
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
         ASSERT_EQUALS("[test.cpp:3]: (warning) %u in format string (no. 3) requires 'unsigned int' but the argument type is 'const char *'.\n"
                       "[test.cpp:3]: (warning) %d in format string (no. 4) requires 'int' but the argument type is 'const char *'.\n"
-                      "[test.cpp:3]: (warning) %f in format string (no. 5) requires 'double' but the argument type is 'const char *'.\n", errout.str());
+                      "[test.cpp:3]: (warning) %f in format string (no. 5) requires 'double' but the argument type is 'const char *'.\n", errout_str());
 
         check("std::vector<int> array;\n"
               "char * p = 0;\n"
@@ -2943,7 +3040,7 @@ class TestIO : public TestFixture {
               "    printf(\"%u %u\", array.size(), s);\n"
               "    printf(\"%lu %lu\", array.size(), s);\n"
               "    printf(\"%llu %llu\", array.size(), s);\n"
-              "}\n", false, true, Settings::Unix64);
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
         ASSERT_EQUALS("[test.cpp:8]: (warning) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'char *'.\n"
                       "[test.cpp:8]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'char *'.\n"
                       "[test.cpp:8]: (warning) %u in format string (no. 3) requires 'unsigned int' but the argument type is 'char *'.\n"
@@ -2952,7 +3049,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:10]: (portability) %lu in format string (no. 1) requires 'unsigned long' but the argument type is 'std::size_t {aka unsigned long}'.\n"
                       "[test.cpp:10]: (portability) %lu in format string (no. 2) requires 'unsigned long' but the argument type is 'size_t {aka unsigned long}'.\n"
                       "[test.cpp:11]: (portability) %llu in format string (no. 1) requires 'unsigned long long' but the argument type is 'std::size_t {aka unsigned long}'.\n"
-                      "[test.cpp:11]: (portability) %llu in format string (no. 2) requires 'unsigned long long' but the argument type is 'size_t {aka unsigned long}'.\n", errout.str());
+                      "[test.cpp:11]: (portability) %llu in format string (no. 2) requires 'unsigned long long' but the argument type is 'size_t {aka unsigned long}'.\n", errout_str());
 
         check("bool b; bool bf();\n"
               "char c; char cf();\n"
@@ -2967,13 +3064,13 @@ class TestIO : public TestFixture {
               "char ca[3];\n"
               "void foo() {\n"
               "    printf(\"%td %zd %d %d %d %d %d %d %d %d %d %d %d\", pt, pt, b, c, sc, uc, s, us, st, pt, pc, cl, ca);\n"
-              "}\n", false, true, Settings::Unix64);
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
         ASSERT_EQUALS("[test.cpp:13]: (portability) %zd in format string (no. 2) requires 'ssize_t' but the argument type is 'ptrdiff_t {aka signed long}'.\n"
                       "[test.cpp:13]: (portability) %d in format string (no. 9) requires 'int' but the argument type is 'size_t {aka unsigned long}'.\n"
                       "[test.cpp:13]: (portability) %d in format string (no. 10) requires 'int' but the argument type is 'ptrdiff_t {aka signed long}'.\n"
                       "[test.cpp:13]: (warning) %d in format string (no. 11) requires 'int' but the argument type is 'char *'.\n"
                       "[test.cpp:13]: (warning) %d in format string (no. 12) requires 'int' but the argument type is 'char *'.\n"
-                      "[test.cpp:13]: (warning) %d in format string (no. 13) requires 'int' but the argument type is 'char *'.\n", errout.str());
+                      "[test.cpp:13]: (warning) %d in format string (no. 13) requires 'int' but the argument type is 'char *'.\n", errout_str());
 
         check("bool b; bool bf();\n"
               "char c; char cf();\n"
@@ -2988,7 +3085,7 @@ class TestIO : public TestFixture {
               "char ca[3];\n"
               "void foo() {\n"
               "    printf(\"%ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld\", b, c, sc, uc, s, us, st, pt, pc, cl, ca);\n"
-              "}\n", false, true, Settings::Unix64);
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
         ASSERT_EQUALS("[test.cpp:13]: (warning) %ld in format string (no. 1) requires 'long' but the argument type is 'bool'.\n"
                       "[test.cpp:13]: (warning) %ld in format string (no. 2) requires 'long' but the argument type is 'char'.\n"
                       "[test.cpp:13]: (warning) %ld in format string (no. 3) requires 'long' but the argument type is 'signed char'.\n"
@@ -2999,7 +3096,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:13]: (portability) %ld in format string (no. 8) requires 'long' but the argument type is 'ptrdiff_t {aka signed long}'.\n"
                       "[test.cpp:13]: (warning) %ld in format string (no. 9) requires 'long' but the argument type is 'char *'.\n"
                       "[test.cpp:13]: (warning) %ld in format string (no. 10) requires 'long' but the argument type is 'char *'.\n"
-                      "[test.cpp:13]: (warning) %ld in format string (no. 11) requires 'long' but the argument type is 'char *'.\n", errout.str());
+                      "[test.cpp:13]: (warning) %ld in format string (no. 11) requires 'long' but the argument type is 'char *'.\n", errout_str());
 
 
         check("bool b; bool bf();\n"
@@ -3015,11 +3112,11 @@ class TestIO : public TestFixture {
               "char ca[3];\n"
               "void foo() {\n"
               "    printf(\"%td %zd %d %d %d %d %d %d %d %d %d\", ptf(), ptf(), bf(), cf(), scf(), ucf(), sf(), usf(), stf(), ptf(), pcf());\n"
-              "}\n", false, true, Settings::Unix64);
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
         ASSERT_EQUALS("[test.cpp:13]: (portability) %zd in format string (no. 2) requires 'ssize_t' but the argument type is 'ptrdiff_t {aka signed long}'.\n"
                       "[test.cpp:13]: (portability) %d in format string (no. 9) requires 'int' but the argument type is 'size_t {aka unsigned long}'.\n"
                       "[test.cpp:13]: (portability) %d in format string (no. 10) requires 'int' but the argument type is 'ptrdiff_t {aka signed long}'.\n"
-                      "[test.cpp:13]: (warning) %d in format string (no. 11) requires 'int' but the argument type is 'char *'.\n", errout.str());
+                      "[test.cpp:13]: (warning) %d in format string (no. 11) requires 'int' but the argument type is 'char *'.\n", errout_str());
 
         check("bool b; bool bf();\n"
               "char c; char cf();\n"
@@ -3034,7 +3131,7 @@ class TestIO : public TestFixture {
               "char ca[3];\n"
               "void foo() {\n"
               "    printf(\"%ld %ld %ld %ld %ld %ld %ld %ld %ld\", bf(), cf(), scf(), ucf(), sf(), usf(), stf(), ptf(), pcf());\n"
-              "}\n", false, true, Settings::Unix64);
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
         ASSERT_EQUALS("[test.cpp:13]: (warning) %ld in format string (no. 1) requires 'long' but the argument type is 'bool'.\n"
                       "[test.cpp:13]: (warning) %ld in format string (no. 2) requires 'long' but the argument type is 'char'.\n"
                       "[test.cpp:13]: (warning) %ld in format string (no. 3) requires 'long' but the argument type is 'signed char'.\n"
@@ -3043,7 +3140,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:13]: (warning) %ld in format string (no. 6) requires 'long' but the argument type is 'unsigned short'.\n"
                       "[test.cpp:13]: (portability) %ld in format string (no. 7) requires 'long' but the argument type is 'size_t {aka unsigned long}'.\n"
                       "[test.cpp:13]: (portability) %ld in format string (no. 8) requires 'long' but the argument type is 'ptrdiff_t {aka signed long}'.\n"
-                      "[test.cpp:13]: (warning) %ld in format string (no. 9) requires 'long' but the argument type is 'char *'.\n", errout.str());
+                      "[test.cpp:13]: (warning) %ld in format string (no. 9) requires 'long' but the argument type is 'char *'.\n", errout_str());
 
         check("struct A {};\n"
               "class B : public std::vector<const int *> {} b;\n"
@@ -3054,11 +3151,11 @@ class TestIO : public TestFixture {
               "    printf(\"%p %d\", b[0], b[0]);\n"
               "    printf(\"%p %d\", c[0], c[0]);\n"
               "    printf(\"%p %d\", s.c_str(), s.c_str());\n"
-              "}\n", false, true, Settings::Unix64);
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
         ASSERT_EQUALS("[test.cpp:6]: (portability) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'size_t {aka unsigned long}'.\n"
                       "[test.cpp:7]: (warning) %d in format string (no. 2) requires 'int' but the argument type is 'const int *'.\n"
                       "[test.cpp:8]: (warning) %d in format string (no. 2) requires 'int' but the argument type is 'const struct A *'.\n"
-                      "[test.cpp:9]: (warning) %d in format string (no. 2) requires 'int' but the argument type is 'const char *'.\n", errout.str());
+                      "[test.cpp:9]: (warning) %d in format string (no. 2) requires 'int' but the argument type is 'const char *'.\n", errout_str());
 
         check("class A : public std::vector<std::string> {} a;\n"
               "class B : public std::string {} b;\n"
@@ -3067,10 +3164,10 @@ class TestIO : public TestFixture {
               "    printf(\"%p %d\", a[0].c_str(), a[0].c_str());\n"
               "    printf(\"%c %p\", b[0], b[0]);\n"
               "    printf(\"%c %p\", s[0], s[0]);\n"
-              "}\n", false, false, Settings::Unix64);
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Unix64));
         ASSERT_EQUALS("[test.cpp:5]: (warning) %d in format string (no. 2) requires 'int' but the argument type is 'const char *'.\n"
                       "[test.cpp:6]: (warning) %p in format string (no. 2) requires an address but the argument type is 'char'.\n"
-                      "[test.cpp:7]: (warning) %p in format string (no. 2) requires an address but the argument type is 'char'.\n", errout.str());
+                      "[test.cpp:7]: (warning) %p in format string (no. 2) requires an address but the argument type is 'char'.\n", errout_str());
 
         check("template <class T>\n"
               "struct buffer {\n"
@@ -3079,50 +3176,50 @@ class TestIO : public TestFixture {
               "buffer<int> b;\n"
               "void foo() {\n"
               "    printf(\"%u\", b.size());\n"
-              "}\n", false, true, Settings::Unix64);
-        ASSERT_EQUALS("[test.cpp:7]: (portability) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'size_t {aka unsigned long}'.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
+        ASSERT_EQUALS("[test.cpp:7]: (portability) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'size_t {aka unsigned long}'.\n", errout_str());
 
         check("DWORD a;\n"
               "DWORD_PTR b;\n"
               "void foo() {\n"
               "    printf(\"%u %u\", a, b);\n"
-              "}\n", false, true, Settings::Win32A);
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("[test.cpp:4]: (portability) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'DWORD {aka unsigned long}'.\n"
-                      "[test.cpp:4]: (portability) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'DWORD_PTR {aka unsigned long}'.\n", errout.str());
+                      "[test.cpp:4]: (portability) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'DWORD_PTR {aka unsigned long}'.\n", errout_str());
 
         check("unsigned long a[] = { 1, 2 };\n"
               "void foo() {\n"
               "    printf(\"%d %d %x \", a[0], a[0], a[0]);\n"
-              "}\n", false, false, Settings::Win32A);
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
         ASSERT_EQUALS("[test.cpp:3]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned long'.\n"
                       "[test.cpp:3]: (warning) %d in format string (no. 2) requires 'int' but the argument type is 'unsigned long'.\n"
-                      "[test.cpp:3]: (warning) %x in format string (no. 3) requires 'unsigned int' but the argument type is 'unsigned long'.\n", errout.str());
+                      "[test.cpp:3]: (warning) %x in format string (no. 3) requires 'unsigned int' but the argument type is 'unsigned long'.\n", errout_str());
 
         check("void foo (wchar_t c) {\n" // ticket #5051 false positive
               "    printf(\"%c\", c);\n"
-              "}\n", false, false, Settings::Win64);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win64));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    printf(\"%f %d\", static_cast<int>(1.0f), reinterpret_cast<const void *>(0));\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'signed int'.\n"
-                      "[test.cpp:2]: (warning) %d in format string (no. 2) requires 'int' but the argument type is 'const void *'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %d in format string (no. 2) requires 'int' but the argument type is 'const void *'.\n", errout_str());
 
         check("void foo() {\n"
               "    UNKNOWN * u;\n"
               "    printf(\"%d %x %u %f\", u[i], u[i], u[i], u[i]);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    long * l;\n"
               "    printf(\"%d %x %u %f\", l[i], l[i], l[i], l[i]);\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'signed long'.\n"
                       "[test.cpp:3]: (warning) %x in format string (no. 2) requires 'unsigned int' but the argument type is 'signed long'.\n"
                       "[test.cpp:3]: (warning) %u in format string (no. 3) requires 'unsigned int' but the argument type is 'signed long'.\n"
-                      "[test.cpp:3]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'signed long'.\n", errout.str());
+                      "[test.cpp:3]: (warning) %f in format string (no. 4) requires 'double' but the argument type is 'signed long'.\n", errout_str());
 
         check("void f() {\n" // #5104
               "    myvector<unsigned short> v1(1,0);\n"
@@ -3139,37 +3236,37 @@ class TestIO : public TestFixture {
               "    printf(\"%u\",v6[0]);\n"
               "    myvector<char *> v7(1,0);\n"
               "    printf(\"%s\",v7[0]);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("std::vector<char> v;\n" // #5151
               "void foo() {\n"
               "   printf(\"%c %u %f\", v.at(32), v.at(32), v.at(32));\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS("[test.cpp:3]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'char'.\n"
-                      "[test.cpp:3]: (warning) %f in format string (no. 3) requires 'double' but the argument type is 'char'.\n", errout.str());
+                      "[test.cpp:3]: (warning) %f in format string (no. 3) requires 'double' but the argument type is 'char'.\n", errout_str());
 
         // #5195 (segmentation fault)
         check("void T::a(const std::vector<double>& vx) {\n"
               "    printf(\"%f\", vx.at(0));\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // #5486
         check("void foo() {\n"
               "    ssize_t test = 0;\n"
               "    printf(\"%zd\", test);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // #6009
         check("extern std::string StringByReturnValue();\n"
               "extern int         IntByReturnValue();\n"
               "void MyFunction() {\n"
               "    printf( \"%s - %s\", StringByReturnValue(), IntByReturnValue() );\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS("[test.cpp:4]: (warning) %s in format string (no. 1) requires 'char *' but the argument type is 'std::string'.\n"
-                      "[test.cpp:4]: (warning) %s in format string (no. 2) requires 'char *' but the argument type is 'signed int'.\n", errout.str());
+                      "[test.cpp:4]: (warning) %s in format string (no. 2) requires 'char *' but the argument type is 'signed int'.\n", errout_str());
 
         check("template <class T, size_t S>\n"
               "struct Array {\n"
@@ -3180,23 +3277,23 @@ class TestIO : public TestFixture {
               "    Array<int, 10> array1;\n"
               "    Array<float, 10> array2;\n"
               "    printf(\"%u %u\", array1[0], array2[0]);\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS("[test.cpp:9]: (warning) %u in format string (no. 1) requires 'unsigned int' but the argument type is 'int'.\n"
-                      "[test.cpp:9]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'float'.\n", errout.str());
+                      "[test.cpp:9]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'float'.\n", errout_str());
 
         // Ticket #7445
         check("struct S { unsigned short x; } s = {0};\n"
               "void foo() {\n"
               "    printf(\"%d\", s.x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #7601
         check("void foo(int i, unsigned int ui, long long ll, unsigned long long ull) {\n"
               "    printf(\"%Ld %Lu %Ld %Lu\", i, ui, ll, ull);\n"
               "}");
         ASSERT_EQUALS("[test.cpp:2]: (warning) %Ld in format string (no. 1) requires 'long long' but the argument type is 'signed int'.\n"
-                      "[test.cpp:2]: (warning) %Lu in format string (no. 2) requires 'unsigned long long' but the argument type is 'unsigned int'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %Lu in format string (no. 2) requires 'unsigned long long' but the argument type is 'unsigned int'.\n", errout_str());
 
         check("void foo(char c, unsigned char uc, short s, unsigned short us, int i, unsigned int ui, long l, unsigned long ul) {\n"
               "    printf(\"%hhd %hhd %hhd %hhd %hhd %hhd %hhd %hhd\", c, uc, s, us, i, ui, l, ul);\n"
@@ -3207,7 +3304,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %hhd in format string (no. 5) requires 'char' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %hhd in format string (no. 6) requires 'char' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:2]: (warning) %hhd in format string (no. 7) requires 'char' but the argument type is 'signed long'.\n"
-                      "[test.cpp:2]: (warning) %hhd in format string (no. 8) requires 'char' but the argument type is 'unsigned long'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %hhd in format string (no. 8) requires 'char' but the argument type is 'unsigned long'.\n", errout_str());
 
         check("void foo(char c, unsigned char uc, short s, unsigned short us, int i, unsigned int ui, long l, unsigned long ul) {\n"
               "    printf(\"%hhu %hhu %hhu %hhu %hhu %hhu %hhu %hhu\", c, uc, s, us, i, ui, l, ul);\n"
@@ -3218,7 +3315,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %hhu in format string (no. 5) requires 'unsigned char' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %hhu in format string (no. 6) requires 'unsigned char' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:2]: (warning) %hhu in format string (no. 7) requires 'unsigned char' but the argument type is 'signed long'.\n"
-                      "[test.cpp:2]: (warning) %hhu in format string (no. 8) requires 'unsigned char' but the argument type is 'unsigned long'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %hhu in format string (no. 8) requires 'unsigned char' but the argument type is 'unsigned long'.\n", errout_str());
 
         check("void foo(char c, unsigned char uc, short s, unsigned short us, int i, unsigned int ui, long l, unsigned long ul) {\n"
               "    printf(\"%hhx %hhx %hhx %hhx %hhx %hhx %hhx %hhx\", c, uc, s, us, i, ui, l, ul);\n"
@@ -3229,7 +3326,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %hhx in format string (no. 5) requires 'unsigned char' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %hhx in format string (no. 6) requires 'unsigned char' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:2]: (warning) %hhx in format string (no. 7) requires 'unsigned char' but the argument type is 'signed long'.\n"
-                      "[test.cpp:2]: (warning) %hhx in format string (no. 8) requires 'unsigned char' but the argument type is 'unsigned long'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %hhx in format string (no. 8) requires 'unsigned char' but the argument type is 'unsigned long'.\n", errout_str());
 
         check("void foo(char c, unsigned char uc, short s, unsigned short us, int i, unsigned int ui, long l, unsigned long ul) {\n"
               "    printf(\"%hd %hd %hd %hd %hd %hd %hd %hd\", c, uc, s, us, i, ui, l, ul);\n"
@@ -3240,7 +3337,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %hd in format string (no. 5) requires 'short' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %hd in format string (no. 6) requires 'short' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:2]: (warning) %hd in format string (no. 7) requires 'short' but the argument type is 'signed long'.\n"
-                      "[test.cpp:2]: (warning) %hd in format string (no. 8) requires 'short' but the argument type is 'unsigned long'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %hd in format string (no. 8) requires 'short' but the argument type is 'unsigned long'.\n", errout_str());
 
         check("void foo(char c, unsigned char uc, short s, unsigned short us, int i, unsigned int ui, long l, unsigned long ul) {\n"
               "    printf(\"%hu %hu %hu %hu %hu %hu %hu %hu\", c, uc, s, us, i, ui, l, ul);\n"
@@ -3251,7 +3348,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %hu in format string (no. 5) requires 'unsigned short' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %hu in format string (no. 6) requires 'unsigned short' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:2]: (warning) %hu in format string (no. 7) requires 'unsigned short' but the argument type is 'signed long'.\n"
-                      "[test.cpp:2]: (warning) %hu in format string (no. 8) requires 'unsigned short' but the argument type is 'unsigned long'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %hu in format string (no. 8) requires 'unsigned short' but the argument type is 'unsigned long'.\n", errout_str());
 
         check("void foo(char c, unsigned char uc, short s, unsigned short us, int i, unsigned int ui, long l, unsigned long ul) {\n"
               "    printf(\"%hx %hx %hx %hx %hx %hx %hx %hx\", c, uc, s, us, i, ui, l, ul);\n"
@@ -3262,7 +3359,7 @@ class TestIO : public TestFixture {
                       "[test.cpp:2]: (warning) %hx in format string (no. 5) requires 'unsigned short' but the argument type is 'signed int'.\n"
                       "[test.cpp:2]: (warning) %hx in format string (no. 6) requires 'unsigned short' but the argument type is 'unsigned int'.\n"
                       "[test.cpp:2]: (warning) %hx in format string (no. 7) requires 'unsigned short' but the argument type is 'signed long'.\n"
-                      "[test.cpp:2]: (warning) %hx in format string (no. 8) requires 'unsigned short' but the argument type is 'unsigned long'.\n", errout.str());
+                      "[test.cpp:2]: (warning) %hx in format string (no. 8) requires 'unsigned short' but the argument type is 'unsigned long'.\n", errout_str());
 
         // #7837 - Use ValueType for function call
         check("struct S {\n"
@@ -3272,7 +3369,13 @@ class TestIO : public TestFixture {
               "void foo(struct S x) {\n"
               "  printf(\"%f\", x.f(4.0));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    printf(\"%lu\", sizeof(char));\n"
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
+        ASSERT_EQUALS("[test.cpp:2]: (portability) %lu in format string (no. 1) requires 'unsigned long' but the argument type is 'size_t {aka unsigned long long}'.\n",
+                      errout_str());
     }
 
     void testPrintfArgumentVariables() {
@@ -3300,13 +3403,13 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA("%u", "unsigned int", "uintmax_t", "unsigned long", "unsigned long long");
         TEST_PRINTF_WARN_AKA("%u", "unsigned int", "intptr_t", "signed long", "signed long long");
         TEST_PRINTF_WARN_AKA("%u", "unsigned int", "uintptr_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%u", "unsigned int", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%u", "unsigned int", "std::ssize_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%u", "unsigned int", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%u", "unsigned int", "std::intmax_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%u", "unsigned int", "std::uintmax_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%u", "unsigned int", "std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%u", "unsigned int", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%u", "unsigned int", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%u", "unsigned int", "std::ssize_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%u", "unsigned int", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%u", "unsigned int", "std::intmax_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%u", "unsigned int", "std::uintmax_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%u", "unsigned int", "std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%u", "unsigned int", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_PRINTF_NOWARN("%x", "unsigned int", "bool");
         //TODO TEST_PRINTF_WARN("%x", "unsigned int", "char");
@@ -3332,13 +3435,13 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA("%x", "unsigned int", "uintmax_t", "unsigned long", "unsigned long long");
         TEST_PRINTF_WARN_AKA("%x", "unsigned int", "intptr_t", "signed long", "signed long long");
         TEST_PRINTF_WARN_AKA("%x", "unsigned int", "uintptr_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%x", "unsigned int", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%x", "unsigned int", "std::ssize_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%x", "unsigned int", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%x", "unsigned int", "std::intmax_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%x", "unsigned int", "std::uintmax_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%x", "unsigned int", "std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%x", "unsigned int", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%x", "unsigned int", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%x", "unsigned int", "std::ssize_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%x", "unsigned int", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%x", "unsigned int", "std::intmax_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%x", "unsigned int", "std::uintmax_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%x", "unsigned int", "std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%x", "unsigned int", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_PRINTF_WARN("%lu","unsigned long","bool");
         TEST_PRINTF_WARN("%lu","unsigned long","char");
@@ -3364,13 +3467,13 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA("%lu","unsigned long","uintmax_t","unsigned long", "unsigned long long");
         TEST_PRINTF_WARN_AKA("%lu","unsigned long","intptr_t", "signed long", "signed long long");
         TEST_PRINTF_WARN_AKA_WIN64("%lu","unsigned long","uintptr_t", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%lu","unsigned long","std::size_t","unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%lu","unsigned long","std::ssize_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%lu","unsigned long","std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%lu","unsigned long","std::intmax_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA_WIN64("%lu","unsigned long","std::uintmax_t", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%lu","unsigned long","std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA_WIN64("%lu","unsigned long","std::uintptr_t", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%lu","unsigned long","std::size_t","unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%lu","unsigned long","std::ssize_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%lu","unsigned long","std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%lu","unsigned long","std::intmax_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN64("%lu","unsigned long","std::uintmax_t", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%lu","unsigned long","std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN64("%lu","unsigned long","std::uintptr_t", "unsigned long long");
 
         TEST_PRINTF_WARN("%lx","unsigned long","bool");
         TEST_PRINTF_WARN("%lx","unsigned long","char");
@@ -3396,13 +3499,13 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA("%lx","unsigned long","uintmax_t", "unsigned long", "unsigned long long");
         TEST_PRINTF_WARN_AKA_WIN64("%lx","unsigned long","intptr_t", "signed long long");
         TEST_PRINTF_WARN_AKA_WIN64("%lx","unsigned long","uintptr_t", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%lx","unsigned long","std::size_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA_WIN64("%lx","unsigned long","std::ssize_t", "signed long long");
-        TEST_PRINTF_WARN_AKA_WIN64("%lx","unsigned long","std::ptrdiff_t", "signed long long");
-        TEST_PRINTF_WARN_AKA_WIN64("%lx","unsigned long","std::intmax_t", "signed long long");
-        TEST_PRINTF_WARN_AKA_WIN64("%lx","unsigned long","std::uintmax_t", "unsigned long long");
-        TEST_PRINTF_WARN_AKA_WIN64("%lx","unsigned long","std::intptr_t", "signed long long");
-        TEST_PRINTF_WARN_AKA_WIN64("%lx","unsigned long","std::uintptr_t", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%lx","unsigned long","std::size_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN64("%lx","unsigned long","std::ssize_t", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN64("%lx","unsigned long","std::ptrdiff_t", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN64("%lx","unsigned long","std::intmax_t", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN64("%lx","unsigned long","std::uintmax_t", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN64("%lx","unsigned long","std::intptr_t", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN64("%lx","unsigned long","std::uintptr_t", "unsigned long long");
 
         TEST_PRINTF_WARN("%llu","unsigned long long","bool");
         TEST_PRINTF_WARN("%llu","unsigned long long","char");
@@ -3428,13 +3531,13 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA("%llu","unsigned long long","uintmax_t", "unsigned long", "unsigned long long");
         TEST_PRINTF_WARN_AKA("%llu","unsigned long long","intptr_t", "signed long", "signed long long");
         TEST_PRINTF_WARN_AKA_WIN32("%llu","unsigned long long","uintptr_t", "unsigned long");
-        TEST_PRINTF_WARN_AKA("%llu","unsigned long long","std::size_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%llu","unsigned long long","std::ssize_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%llu","unsigned long long","std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%llu","unsigned long long","std::intmax_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA_WIN32("%llu","unsigned long long","std::uintmax_t", "unsigned long");
-        TEST_PRINTF_WARN_AKA("%llu","unsigned long long","std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA_WIN32("%llu","unsigned long long","std::uintptr_t", "unsigned long");
+        TEST_PRINTF_WARN_AKA_CPP("%llu","unsigned long long","std::size_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%llu","unsigned long long","std::ssize_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%llu","unsigned long long","std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%llu","unsigned long long","std::intmax_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%llu","unsigned long long","std::uintmax_t", "unsigned long");
+        TEST_PRINTF_WARN_AKA_CPP("%llu","unsigned long long","std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%llu","unsigned long long","std::uintptr_t", "unsigned long");
 
         TEST_PRINTF_WARN("%llx","unsigned long long","bool");
         TEST_PRINTF_WARN("%llx","unsigned long long","char");
@@ -3460,13 +3563,13 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA("%llx","unsigned long long","uintmax_t", "unsigned long", "unsigned long long");
         TEST_PRINTF_WARN_AKA_WIN32("%llx","unsigned long long","intptr_t", "signed long");
         TEST_PRINTF_WARN_AKA_WIN32("%llx","unsigned long long","uintptr_t", "unsigned long");
-        TEST_PRINTF_WARN_AKA("%llx","unsigned long long","std::size_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA_WIN32("%llx","unsigned long long","std::ssize_t", "signed long");
-        TEST_PRINTF_WARN_AKA_WIN32("%llx","unsigned long long","std::ptrdiff_t", "signed long");
-        TEST_PRINTF_WARN_AKA_WIN32("%llx","unsigned long long","std::intmax_t", "signed long");
-        TEST_PRINTF_WARN_AKA_WIN32("%llx","unsigned long long","std::uintmax_t", "unsigned long");
-        TEST_PRINTF_WARN_AKA_WIN32("%llx","unsigned long long","std::intptr_t", "signed long");
-        TEST_PRINTF_WARN_AKA_WIN32("%llx","unsigned long long","std::uintptr_t", "unsigned long");
+        TEST_PRINTF_WARN_AKA_CPP("%llx","unsigned long long","std::size_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%llx","unsigned long long","std::ssize_t", "signed long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%llx","unsigned long long","std::ptrdiff_t", "signed long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%llx","unsigned long long","std::intmax_t", "signed long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%llx","unsigned long long","std::uintmax_t", "unsigned long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%llx","unsigned long long","std::intptr_t", "signed long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%llx","unsigned long long","std::uintptr_t", "unsigned long");
 
         TEST_PRINTF_WARN("%hu", "unsigned short", "bool");
         TEST_PRINTF_WARN("%hu", "unsigned short", "char");
@@ -3490,11 +3593,11 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA("%hu", "unsigned short", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_PRINTF_WARN_AKA("%hu", "unsigned short", "intmax_t", "signed long", "signed long long");
         TEST_PRINTF_WARN_AKA("%hu", "unsigned short", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%hu", "unsigned short", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%hu", "unsigned short", "std::ssize_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%hu", "unsigned short", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%hu", "unsigned short", "std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%hu", "unsigned short", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%hu", "unsigned short", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%hu", "unsigned short", "std::ssize_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%hu", "unsigned short", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%hu", "unsigned short", "std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%hu", "unsigned short", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_PRINTF_WARN("%hx", "unsigned short", "bool");
         TEST_PRINTF_WARN("%hx", "unsigned short", "char");
@@ -3518,11 +3621,11 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA("%hx", "unsigned short", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_PRINTF_WARN_AKA("%hx", "unsigned short", "intmax_t", "signed long", "signed long long");
         TEST_PRINTF_WARN_AKA("%hx", "unsigned short", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%hx", "unsigned short", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%hx", "unsigned short", "std::ssize_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%hx", "unsigned short", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%hx", "unsigned short", "std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%hx", "unsigned short", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%hx", "unsigned short", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%hx", "unsigned short", "std::ssize_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%hx", "unsigned short", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%hx", "unsigned short", "std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%hx", "unsigned short", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_PRINTF_WARN("%hhu", "unsigned char", "bool");
         TEST_PRINTF_WARN("%hhu", "unsigned char", "char");
@@ -3546,11 +3649,11 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA("%hhu", "unsigned char", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_PRINTF_WARN_AKA("%hhu", "unsigned char", "intmax_t", "signed long", "signed long long");
         TEST_PRINTF_WARN_AKA("%hhu", "unsigned char", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%hhu", "unsigned char", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%hhu", "unsigned char", "std::ssize_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%hhu", "unsigned char", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%hhu", "unsigned char", "std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%hhu", "unsigned char", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%hhu", "unsigned char", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%hhu", "unsigned char", "std::ssize_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%hhu", "unsigned char", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%hhu", "unsigned char", "std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%hhu", "unsigned char", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_PRINTF_WARN("%hhx", "unsigned char", "bool");
         TEST_PRINTF_WARN("%hhx", "unsigned char", "char");
@@ -3574,11 +3677,11 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA("%hhx", "unsigned char", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_PRINTF_WARN_AKA("%hhx", "unsigned char", "intmax_t", "signed long", "signed long long");
         TEST_PRINTF_WARN_AKA("%hhx", "unsigned char", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%hhx", "unsigned char", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%hhx", "unsigned char", "std::ssize_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%hhx", "unsigned char", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%hhx", "unsigned char", "std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%hhx", "unsigned char", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%hhx", "unsigned char", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%hhx", "unsigned char", "std::ssize_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%hhx", "unsigned char", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%hhx", "unsigned char", "std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%hhx", "unsigned char", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_PRINTF_WARN("%Lu", "unsigned long long", "bool");
         TEST_PRINTF_WARN("%Lu", "unsigned long long", "char");
@@ -3604,13 +3707,13 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA_WIN32("%Lu", "unsigned long long", "uintmax_t", "unsigned long");
         TEST_PRINTF_WARN_AKA("%Lu", "unsigned long long", "intptr_t", "signed long", "signed long long");
         TEST_PRINTF_WARN_AKA_WIN32("%Lu", "unsigned long long", "uintptr_t", "unsigned long");
-        TEST_PRINTF_WARN_AKA_WIN32("%Lu", "unsigned long long", "std::size_t", "unsigned long");
-        TEST_PRINTF_WARN_AKA("%Lu", "unsigned long long", "std::ssize_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%Lu", "unsigned long long", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%Lu", "unsigned long long", "std::intmax_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA_WIN32("%Lu", "unsigned long long", "std::uintmax_t", "unsigned long");
-        TEST_PRINTF_WARN_AKA("%Lu", "unsigned long long", "std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA_WIN32("%Lu", "unsigned long long", "std::uintptr_t", "unsigned long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%Lu", "unsigned long long", "std::size_t", "unsigned long");
+        TEST_PRINTF_WARN_AKA_CPP("%Lu", "unsigned long long", "std::ssize_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%Lu", "unsigned long long", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%Lu", "unsigned long long", "std::intmax_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%Lu", "unsigned long long", "std::uintmax_t", "unsigned long");
+        TEST_PRINTF_WARN_AKA_CPP("%Lu", "unsigned long long", "std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%Lu", "unsigned long long", "std::uintptr_t", "unsigned long");
 
         //TODO TEST_PRINTF_WARN("%Lx", "unsigned long long", "bool");
         //TODO TEST_PRINTF_WARN("%Lx", "unsigned long long", "char");
@@ -3636,13 +3739,13 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA("%Lx", "unsigned long long", "uintmax_t", "unsigned long", "unsigned long long");
         TEST_PRINTF_WARN_AKA("%Lx", "unsigned long long", "intptr_t", "signed long", "signed long long");
         TEST_PRINTF_WARN_AKA("%Lx", "unsigned long long", "uintptr_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%Lx", "unsigned long long", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%Lx", "unsigned long long", "std::ssize_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%Lx", "unsigned long long", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%Lx", "unsigned long long", "std::intmax_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%Lx", "unsigned long long", "std::uintmax_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%Lx", "unsigned long long", "std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%Lx", "unsigned long long", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%Lx", "unsigned long long", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%Lx", "unsigned long long", "std::ssize_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%Lx", "unsigned long long", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%Lx", "unsigned long long", "std::intmax_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%Lx", "unsigned long long", "std::uintmax_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%Lx", "unsigned long long", "std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%Lx", "unsigned long long", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_PRINTF_WARN("%ju", "uintmax_t", "bool");
         TEST_PRINTF_WARN("%ju", "uintmax_t", "char");
@@ -3666,11 +3769,11 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA("%ju", "uintmax_t", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_PRINTF_WARN_AKA("%ju", "uintmax_t", "intmax_t", "signed long", "signed long long");
         TEST_PRINTF_NOWARN("%ju", "uintmax_t", "uintmax_t");
-        TEST_PRINTF_WARN_AKA("%ju", "uintmax_t", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%ju", "uintmax_t", "std::ssize_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%ju", "uintmax_t", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%ju", "uintmax_t", "std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%ju", "uintmax_t", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%ju", "uintmax_t", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%ju", "uintmax_t", "std::ssize_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%ju", "uintmax_t", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%ju", "uintmax_t", "std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%ju", "uintmax_t", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_PRINTF_WARN("%jx", "uintmax_t", "bool");
         TEST_PRINTF_WARN("%jx", "uintmax_t", "char");
@@ -3694,11 +3797,14 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA("%jx", "uintmax_t", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_PRINTF_WARN_AKA("%jx", "uintmax_t", "intmax_t", "signed long", "signed long long");
         TEST_PRINTF_NOWARN("%jx", "uintmax_t", "uintmax_t");
-        TEST_PRINTF_WARN_AKA("%jx", "uintmax_t", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%jx", "uintmax_t", "std::ssize_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%jx", "uintmax_t", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%jx", "uintmax_t", "std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%jx", "uintmax_t", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%jx", "uintmax_t", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%jx", "uintmax_t", "std::ssize_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%jx", "uintmax_t", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%jx", "uintmax_t", "std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%jx", "uintmax_t", "std::uintptr_t", "unsigned long", "unsigned long long");
+
+        TEST_PRINTF_WARN_AKA("%zd", "ssize_t", "size_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA("%zi", "ssize_t", "size_t", "unsigned long", "unsigned long long");
 
         TEST_PRINTF_WARN("%zu", "size_t", "bool");
         TEST_PRINTF_WARN("%zu", "size_t", "char");
@@ -3722,11 +3828,11 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA("%zu", "size_t", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_PRINTF_WARN_AKA("%zu", "size_t", "intmax_t", "signed long", "signed long long");
         TEST_PRINTF_WARN_AKA("%zu", "size_t", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_NOWARN("%zu", "size_t", "std::size_t");
-        TEST_PRINTF_WARN_AKA("%zu", "size_t", "std::ssize_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%zu", "size_t", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%zu", "size_t", "std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%zu", "size_t", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_NOWARN_CPP("%zu", "size_t", "std::size_t");
+        TEST_PRINTF_WARN_AKA_CPP("%zu", "size_t", "std::ssize_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%zu", "size_t", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%zu", "size_t", "std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%zu", "size_t", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_PRINTF_WARN("%zx", "size_t", "bool");
         TEST_PRINTF_WARN("%zx", "size_t", "char");
@@ -3750,11 +3856,11 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA("%zx", "size_t", "unsigned ptrdiff_t", "unsigned long", "unsigned long long");
         TEST_PRINTF_WARN_AKA("%zx", "size_t", "intmax_t", "signed long", "signed long long");
         TEST_PRINTF_WARN_AKA("%zx", "size_t", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_NOWARN("%zx", "size_t", "std::size_t");
-        TEST_PRINTF_WARN_AKA("%zx", "size_t", "std::ssize_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%zx", "size_t", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%zx", "size_t", "std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%zx", "size_t", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_NOWARN_CPP("%zx", "size_t", "std::size_t");
+        TEST_PRINTF_WARN_AKA_CPP("%zx", "size_t", "std::ssize_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%zx", "size_t", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%zx", "size_t", "std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%zx", "size_t", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_PRINTF_WARN("%tu", "unsigned ptrdiff_t", "bool");
         TEST_PRINTF_WARN("%tu", "unsigned ptrdiff_t", "char");
@@ -3778,11 +3884,11 @@ class TestIO : public TestFixture {
         TEST_PRINTF_NOWARN("%tu", "unsigned ptrdiff_t", "unsigned ptrdiff_t");
         TEST_PRINTF_WARN_AKA("%tu", "unsigned ptrdiff_t", "intmax_t", "signed long", "signed long long");
         TEST_PRINTF_WARN_AKA("%tu", "unsigned ptrdiff_t", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%tu", "unsigned ptrdiff_t", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%tu", "unsigned ptrdiff_t", "std::ssize_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%tu", "unsigned ptrdiff_t", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%tu", "unsigned ptrdiff_t", "std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%tu", "unsigned ptrdiff_t", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%tu", "unsigned ptrdiff_t", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%tu", "unsigned ptrdiff_t", "std::ssize_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%tu", "unsigned ptrdiff_t", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%tu", "unsigned ptrdiff_t", "std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%tu", "unsigned ptrdiff_t", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_PRINTF_WARN("%tx", "unsigned ptrdiff_t", "bool");
         TEST_PRINTF_WARN("%tx", "unsigned ptrdiff_t", "char");
@@ -3806,11 +3912,11 @@ class TestIO : public TestFixture {
         TEST_PRINTF_NOWARN("%tx", "unsigned ptrdiff_t", "unsigned ptrdiff_t");
         TEST_PRINTF_WARN_AKA("%tx", "unsigned ptrdiff_t", "intmax_t", "signed long", "signed long long");
         TEST_PRINTF_WARN_AKA("%tx", "unsigned ptrdiff_t", "uintmax_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%tx", "unsigned ptrdiff_t", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%tx", "unsigned ptrdiff_t", "std::ssize_t", "signed long", "signed long long");
-        //TODO TEST_PRINTF_WARN_AKA("%tx", "unsigned ptrdiff_t", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%tx", "unsigned ptrdiff_t", "std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%tx", "unsigned ptrdiff_t", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%tx", "unsigned ptrdiff_t", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%tx", "unsigned ptrdiff_t", "std::ssize_t", "signed long", "signed long long");
+        //TODO TEST_PRINTF_WARN_AKA_CPP("%tx", "unsigned ptrdiff_t", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%tx", "unsigned ptrdiff_t", "std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%tx", "unsigned ptrdiff_t", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_PRINTF_WARN("%Iu", "size_t", "bool");
         TEST_PRINTF_WARN("%Iu", "size_t", "char");
@@ -3836,13 +3942,13 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA("%Iu", "size_t", "uintmax_t", "unsigned long", "unsigned long long");
         TEST_PRINTF_WARN_AKA("%Iu", "size_t", "intptr_t", "signed long", "signed long long");
         TEST_PRINTF_WARN_AKA("%Iu", "size_t", "uintptr_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_NOWARN("%Iu", "size_t", "std::size_t");
-        TEST_PRINTF_WARN_AKA("%Iu", "size_t", "std::ssize_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%Iu", "size_t", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%Iu", "size_t", "std::intmax_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%Iu", "size_t", "std::uintmax_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%Iu", "size_t", "std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%Iu", "size_t", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_NOWARN_CPP("%Iu", "size_t", "std::size_t");
+        TEST_PRINTF_WARN_AKA_CPP("%Iu", "size_t", "std::ssize_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%Iu", "size_t", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%Iu", "size_t", "std::intmax_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%Iu", "size_t", "std::uintmax_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%Iu", "size_t", "std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%Iu", "size_t", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_PRINTF_WARN("%Ix", "size_t", "bool");
         TEST_PRINTF_WARN("%Ix", "size_t", "char");
@@ -3868,13 +3974,13 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA("%Ix", "size_t", "uintmax_t", "unsigned long", "unsigned long long");
         TEST_PRINTF_WARN_AKA("%Ix", "size_t", "intptr_t", "signed long", "signed long long");
         TEST_PRINTF_WARN_AKA("%Ix", "size_t", "uintptr_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_NOWARN("%Ix", "size_t", "std::size_t");
-        TEST_PRINTF_WARN_AKA("%Ix", "size_t", "std::ssize_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%Ix", "size_t", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%Ix", "size_t", "std::intmax_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%Ix", "size_t", "std::uintmax_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%Ix", "size_t", "std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%Ix", "size_t", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_NOWARN_CPP("%Ix", "size_t", "std::size_t");
+        TEST_PRINTF_WARN_AKA_CPP("%Ix", "size_t", "std::ssize_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%Ix", "size_t", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%Ix", "size_t", "std::intmax_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%Ix", "size_t", "std::uintmax_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%Ix", "size_t", "std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%Ix", "size_t", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_PRINTF_WARN("%I64u", "unsigned __int64", "bool");
         TEST_PRINTF_WARN("%I64u", "unsigned __int64", "char");
@@ -3900,13 +4006,13 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA_WIN32("%I64u", "unsigned __int64", "uintmax_t", "unsigned long");
         TEST_PRINTF_WARN_AKA("%I64u", "unsigned __int64", "intptr_t", "signed long", "signed long long");
         TEST_PRINTF_WARN_AKA_WIN32("%I64u", "unsigned __int64", "uintptr_t", "unsigned long");
-        TEST_PRINTF_WARN_AKA_WIN32("%I64u", "unsigned __int64", "std::size_t", "unsigned long");
-        TEST_PRINTF_WARN_AKA("%I64u", "unsigned __int64", "std::ssize_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%I64u", "unsigned __int64", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%I64u", "unsigned __int64", "std::intmax_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA_WIN32("%I64u", "unsigned __int64", "std::uintmax_t", "unsigned long");
-        TEST_PRINTF_WARN_AKA("%I64u", "unsigned __int64", "std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA_WIN32("%I64u", "unsigned __int64", "std::uintptr_t", "unsigned long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%I64u", "unsigned __int64", "std::size_t", "unsigned long");
+        TEST_PRINTF_WARN_AKA_CPP("%I64u", "unsigned __int64", "std::ssize_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%I64u", "unsigned __int64", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%I64u", "unsigned __int64", "std::intmax_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%I64u", "unsigned __int64", "std::uintmax_t", "unsigned long");
+        TEST_PRINTF_WARN_AKA_CPP("%I64u", "unsigned __int64", "std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%I64u", "unsigned __int64", "std::uintptr_t", "unsigned long");
 
         TEST_PRINTF_WARN("%I64x", "unsigned __int64", "bool");
         TEST_PRINTF_WARN("%I64x", "unsigned __int64", "char");
@@ -3934,13 +4040,13 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA_WIN32("%I64x", "unsigned __int64", "uintmax_t", "unsigned long");
         TEST_PRINTF_WARN_AKA_WIN32("%I64x", "unsigned __int64", "intptr_t", "signed long");
         TEST_PRINTF_WARN_AKA_WIN32("%I64x", "unsigned __int64", "uintptr_t", "unsigned long");
-        TEST_PRINTF_WARN_AKA_WIN32("%I64x", "unsigned __int64", "std::size_t", "unsigned long");
-        TEST_PRINTF_WARN_AKA_WIN32("%I64x", "unsigned __int64", "std::ssize_t", "signed long");
-        TEST_PRINTF_WARN_AKA_WIN32("%I64x", "unsigned __int64", "std::ptrdiff_t", "signed long");
-        TEST_PRINTF_WARN_AKA_WIN32("%I64x", "unsigned __int64", "std::intmax_t", "signed long");
-        TEST_PRINTF_WARN_AKA_WIN32("%I64x", "unsigned __int64", "std::uintmax_t", "unsigned long");
-        TEST_PRINTF_WARN_AKA_WIN32("%I64x", "unsigned __int64", "std::intptr_t", "signed long");
-        TEST_PRINTF_WARN_AKA_WIN32("%I64x", "unsigned __int64", "std::uintptr_t", "unsigned long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%I64x", "unsigned __int64", "std::size_t", "unsigned long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%I64x", "unsigned __int64", "std::ssize_t", "signed long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%I64x", "unsigned __int64", "std::ptrdiff_t", "signed long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%I64x", "unsigned __int64", "std::intmax_t", "signed long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%I64x", "unsigned __int64", "std::uintmax_t", "unsigned long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%I64x", "unsigned __int64", "std::intptr_t", "signed long");
+        TEST_PRINTF_WARN_AKA_CPP_WIN32("%I64x", "unsigned __int64", "std::uintptr_t", "unsigned long");
 
         TEST_PRINTF_WARN("%I64d", "__int64", "bool");
         TEST_PRINTF_WARN("%I64d", "__int64", "signed char");
@@ -3976,13 +4082,13 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA("%I32u", "unsigned __int32", "uintmax_t", "unsigned long", "unsigned long long");
         TEST_PRINTF_WARN_AKA("%I32u", "unsigned __int32", "intptr_t", "signed long", "signed long long");
         TEST_PRINTF_WARN_AKA("%I32u", "unsigned __int32", "uintptr_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%I32u", "unsigned __int32", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%I32u", "unsigned __int32", "std::ssize_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%I32u", "unsigned __int32", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%I32u", "unsigned __int32", "std::intmax_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%I32u", "unsigned __int32", "std::uintmax_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%I32u", "unsigned __int32", "std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%I32u", "unsigned __int32", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%I32u", "unsigned __int32", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%I32u", "unsigned __int32", "std::ssize_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%I32u", "unsigned __int32", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%I32u", "unsigned __int32", "std::intmax_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%I32u", "unsigned __int32", "std::uintmax_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%I32u", "unsigned __int32", "std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%I32u", "unsigned __int32", "std::uintptr_t", "unsigned long", "unsigned long long");
 
         TEST_PRINTF_WARN("%I32x", "unsigned __int32", "bool");
         TEST_PRINTF_WARN("%I32x", "unsigned __int32", "char");
@@ -4008,13 +4114,13 @@ class TestIO : public TestFixture {
         TEST_PRINTF_WARN_AKA("%I32x", "unsigned __int32", "uintmax_t", "unsigned long", "unsigned long long");
         TEST_PRINTF_WARN_AKA("%I32x", "unsigned __int32", "intptr_t", "signed long", "signed long long");
         TEST_PRINTF_WARN_AKA("%I32x", "unsigned __int32", "uintptr_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%I32x", "unsigned __int32", "std::size_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%I32x", "unsigned __int32", "std::ssize_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%I32x", "unsigned __int32", "std::ptrdiff_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%I32x", "unsigned __int32", "std::intmax_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%I32x", "unsigned __int32", "std::uintmax_t", "unsigned long", "unsigned long long");
-        TEST_PRINTF_WARN_AKA("%I32x", "unsigned __int32", "std::intptr_t", "signed long", "signed long long");
-        TEST_PRINTF_WARN_AKA("%I32x", "unsigned __int32", "std::uintptr_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%I32x", "unsigned __int32", "std::size_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%I32x", "unsigned __int32", "std::ssize_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%I32x", "unsigned __int32", "std::ptrdiff_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%I32x", "unsigned __int32", "std::intmax_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%I32x", "unsigned __int32", "std::uintmax_t", "unsigned long", "unsigned long long");
+        TEST_PRINTF_WARN_AKA_CPP("%I32x", "unsigned __int32", "std::intptr_t", "signed long", "signed long long");
+        TEST_PRINTF_WARN_AKA_CPP("%I32x", "unsigned __int32", "std::uintptr_t", "unsigned long", "unsigned long long");
     }
 
     void testPosixPrintfScanfParameterPosition() { // #4900  - No support for parameters in format strings
@@ -4024,7 +4130,7 @@ class TestIO : public TestFixture {
               "  printf(\"%1$d, %d, %1$d\", 1, 2);"
               "  scanf(\"%1$d\", &bar);"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "  int bar;\n"
@@ -4033,11 +4139,11 @@ class TestIO : public TestFixture {
               "  scanf(\"%2$d\", &bar);\n"
               "  printf(\"%0$f\", 0.0);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) printf format string requires 1 parameter but only 0 are given.\n"
-                      "[test.cpp:4]: (warning) printf: referencing parameter 4 while 3 arguments given\n"
-                      "[test.cpp:5]: (warning) scanf: referencing parameter 2 while 1 arguments given\n"
-                      "[test.cpp:6]: (warning) printf: parameter positions start at 1, not 0\n"
-                      "", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:3]: (error) printf format string requires 1 parameter but only 0 are given. [wrongPrintfScanfArgNum]\n"
+                      "[test.cpp:4:3]: (warning) printf: referencing parameter 4 while 3 arguments given [wrongPrintfScanfParameterPositionError]\n"
+                      "[test.cpp:5:3]: (warning) scanf: referencing parameter 2 while 1 arguments given [wrongPrintfScanfParameterPositionError]\n"
+                      "[test.cpp:6:3]: (warning) printf: parameter positions start at 1, not 0 [wrongPrintfScanfParameterPositionError]\n"
+                      "", errout_str());
     }
 
 
@@ -4055,14 +4161,14 @@ class TestIO : public TestFixture {
               "    printf(\"%I32d %I32u %I32x\", u32, u32, u32);\n"
               "    printf(\"%I64d %I64u %I64x\", i64, i64, i64);\n"
               "    printf(\"%I64d %I64u %I64x\", u64, u64, u64);\n"
-              "}", false, true, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:8]: (portability) %Id in format string (no. 1) requires 'ptrdiff_t' but the argument type is 'size_t {aka unsigned long}'.\n"
-                      "[test.cpp:9]: (portability) %Iu in format string (no. 2) requires 'size_t' but the argument type is 'ptrdiff_t {aka signed long}'.\n"
-                      "[test.cpp:9]: (portability) %Ix in format string (no. 3) requires 'size_t' but the argument type is 'ptrdiff_t {aka signed long}'.\n"
-                      "[test.cpp:10]: (portability) %I32u in format string (no. 2) requires 'unsigned __int32' but the argument type is '__int32 {aka signed int}'.\n"
-                      "[test.cpp:11]: (portability) %I32d in format string (no. 1) requires '__int32' but the argument type is 'unsigned __int32 {aka unsigned int}'.\n"
-                      "[test.cpp:12]: (portability) %I64u in format string (no. 2) requires 'unsigned __int64' but the argument type is '__int64 {aka signed long long}'.\n"
-                      "[test.cpp:13]: (portability) %I64d in format string (no. 1) requires '__int64' but the argument type is 'unsigned __int64 {aka unsigned long long}'.\n", errout.str());
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:8:5]: (portability) %Id in format string (no. 1) requires 'ptrdiff_t' but the argument type is 'size_t {aka unsigned long}'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:9:5]: (portability) %Iu in format string (no. 2) requires 'size_t' but the argument type is 'ptrdiff_t {aka signed long}'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:9:5]: (portability) %Ix in format string (no. 3) requires 'size_t' but the argument type is 'ptrdiff_t {aka signed long}'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:10:5]: (portability) %I32u in format string (no. 2) requires 'unsigned __int32' but the argument type is '__int32 {aka signed int}'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:11:5]: (portability) %I32d in format string (no. 1) requires '__int32' but the argument type is 'unsigned __int32 {aka unsigned int}'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:12:5]: (portability) %I64u in format string (no. 2) requires 'unsigned __int64' but the argument type is '__int64 {aka signed long long}'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:13:5]: (portability) %I64d in format string (no. 1) requires '__int64' but the argument type is 'unsigned __int64 {aka unsigned long long}'. [invalidPrintfArgType_sint]\n", errout_str());
 
         check("void foo() {\n"
               "    size_t s;\n"
@@ -4077,14 +4183,14 @@ class TestIO : public TestFixture {
               "    printf(\"%I32d %I32u %I32x\", u32, u32, u32);\n"
               "    printf(\"%I64d %I64u %I64x\", i64, i64, i64);\n"
               "    printf(\"%I64d %I64u %I64x\", u64, u64, u64);\n"
-              "}", false, true, Settings::Win64);
-        ASSERT_EQUALS("[test.cpp:8]: (portability) %Id in format string (no. 1) requires 'ptrdiff_t' but the argument type is 'size_t {aka unsigned long long}'.\n"
-                      "[test.cpp:9]: (portability) %Iu in format string (no. 2) requires 'size_t' but the argument type is 'ptrdiff_t {aka signed long long}'.\n"
-                      "[test.cpp:9]: (portability) %Ix in format string (no. 3) requires 'size_t' but the argument type is 'ptrdiff_t {aka signed long long}'.\n"
-                      "[test.cpp:10]: (portability) %I32u in format string (no. 2) requires 'unsigned __int32' but the argument type is '__int32 {aka signed int}'.\n"
-                      "[test.cpp:11]: (portability) %I32d in format string (no. 1) requires '__int32' but the argument type is 'unsigned __int32 {aka unsigned int}'.\n"
-                      "[test.cpp:12]: (portability) %I64u in format string (no. 2) requires 'unsigned __int64' but the argument type is '__int64 {aka signed long long}'.\n"
-                      "[test.cpp:13]: (portability) %I64d in format string (no. 1) requires '__int64' but the argument type is 'unsigned __int64 {aka unsigned long long}'.\n", errout.str());
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
+        ASSERT_EQUALS("[test.cpp:8:5]: (portability) %Id in format string (no. 1) requires 'ptrdiff_t' but the argument type is 'size_t {aka unsigned long long}'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:9:5]: (portability) %Iu in format string (no. 2) requires 'size_t' but the argument type is 'ptrdiff_t {aka signed long long}'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:9:5]: (portability) %Ix in format string (no. 3) requires 'size_t' but the argument type is 'ptrdiff_t {aka signed long long}'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:10:5]: (portability) %I32u in format string (no. 2) requires 'unsigned __int32' but the argument type is '__int32 {aka signed int}'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:11:5]: (portability) %I32d in format string (no. 1) requires '__int32' but the argument type is 'unsigned __int32 {aka unsigned int}'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:12:5]: (portability) %I64u in format string (no. 2) requires 'unsigned __int64' but the argument type is '__int64 {aka signed long long}'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:13:5]: (portability) %I64d in format string (no. 1) requires '__int64' but the argument type is 'unsigned __int64 {aka unsigned long long}'. [invalidPrintfArgType_sint]\n", errout_str());
 
         check("void foo() {\n"
               "    size_t s;\n"
@@ -4104,43 +4210,80 @@ class TestIO : public TestFixture {
               "    printf(\"%I32%i\", s, i);\n"
               "    printf(\"%I64%i\", s, i);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:6]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:7]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:8]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:9]: (warning) 'I32' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:10]: (warning) 'I64' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:11]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:12]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:13]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:14]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:15]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:16]: (warning) 'I32' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:17]: (warning) 'I64' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:5:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:6:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:7:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:8:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:9:5]: (warning) 'I32' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:10:5]: (warning) 'I64' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:11:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:12:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:13:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:14:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:15:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:16:5]: (warning) 'I32' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:17:5]: (warning) 'I64' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n", errout_str());
 
         // ticket #5264
         check("void foo(LPARAM lp, WPARAM wp, LRESULT lr) {\n"
               "    printf(\"%Ix %Ix %Ix\", lp, wp, lr);\n"
-              "}\n", false, true, Settings::Win64);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(LPARAM lp, WPARAM wp, LRESULT lr) {\n"
               "    printf(\"%Ix %Ix %Ix\", lp, wp, lr);\n"
-              "}\n", false, true, Settings::Win32A);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(UINT32 a, ::UINT32 b, Fred::UINT32 c) {\n"
               "    printf(\"%d %d %d\", a, b, c);\n"
-              "};\n", false, true, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:2]: (portability) %d in format string (no. 1) requires 'int' but the argument type is 'UINT32 {aka unsigned int}'.\n"
-                      "[test.cpp:2]: (portability) %d in format string (no. 2) requires 'int' but the argument type is 'UINT32 {aka unsigned int}'.\n", errout.str());
+              "};\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:2:5]: (portability) %d in format string (no. 1) requires 'int' but the argument type is 'UINT32 {aka unsigned int}'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:2:5]: (portability) %d in format string (no. 2) requires 'int' but the argument type is 'UINT32 {aka unsigned int}'. [invalidPrintfArgType_sint]\n", errout_str());
 
         check("void foo(LPCVOID a, ::LPCVOID b, Fred::LPCVOID c) {\n"
               "    printf(\"%d %d %d\", a, b, c);\n"
-              "};\n", false, true, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:2]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'const void *'.\n"
-                      "[test.cpp:2]: (warning) %d in format string (no. 2) requires 'int' but the argument type is 'const void *'.\n", errout.str());
+              "};\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'const void *'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:2:5]: (warning) %d in format string (no. 2) requires 'int' but the argument type is 'const void *'. [invalidPrintfArgType_sint]\n", errout_str());
+
+        check("void foo() {\n"
+              "    SSIZE_T s = -2;\n" // In MSVC, SSIZE_T is available in capital letters using #include <BaseTsd.h>
+              "    int i;\n"
+              "    printf(\"%zd\", s);\n"
+              "    printf(\"%zd%i\", s, i);\n"
+              "    printf(\"%zu\", s);\n"
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:6:5]: (portability) %zu in format string (no. 1) requires 'size_t' but the argument type is 'SSIZE_T {aka signed long}'. [invalidPrintfArgType_uint]\n", errout_str());
+
+        check("void foo() {\n"
+              "    SSIZE_T s = -2;\n" // In MSVC, SSIZE_T is available in capital letters using #include <BaseTsd.h>
+              "    int i;\n"
+              "    printf(\"%zd\", s);\n"
+              "    printf(\"%zd%i\", s, i);\n"
+              "    printf(\"%zu\", s);\n"
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
+        ASSERT_EQUALS("[test.cpp:6:5]: (portability) %zu in format string (no. 1) requires 'size_t' but the argument type is 'SSIZE_T {aka signed long long}'. [invalidPrintfArgType_uint]\n", errout_str());
+
+        check("void foo() {\n"
+              "    SSIZE_T s = -2;\n" // Under Unix, ssize_t has to be written in small letters. Not Cppcheck, but the compiler will report this.
+              "    int i;\n"
+              "    printf(\"%zd\", s);\n"
+              "    printf(\"%zd%i\", s, i);\n"
+              "    printf(\"%zu\", s);\n"
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo() {\n"
+              "    typedef SSIZE_T ssize_t;\n" // Test using typedef
+              "    ssize_t s = -2;\n"
+              "    int i;\n"
+              "    printf(\"%zd\", s);\n"
+              "    printf(\"%zd%i\", s, i);\n"
+              "    printf(\"%zu\", s);\n"
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
+        ASSERT_EQUALS("[test.cpp:7:5]: (portability) %zu in format string (no. 1) requires 'size_t' but the argument type is 'SSIZE_T {aka signed long long}'. [invalidPrintfArgType_uint]\n", errout_str());
 
     }
 
@@ -4158,16 +4301,16 @@ class TestIO : public TestFixture {
               "    scanf(\"%I32d %I32u %I32x\", &u32, &u32, &u32);\n"
               "    scanf(\"%I64d %I64u %I64x\", &i64, &i64, &i64);\n"
               "    scanf(\"%I64d %I64u %I64x\", &u64, &u64, &u64);\n"
-              "}", false, true, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:8]: (portability) %Id in format string (no. 1) requires 'ptrdiff_t *' but the argument type is 'size_t * {aka unsigned long *}'.\n"
-                      "[test.cpp:9]: (portability) %Iu in format string (no. 2) requires 'size_t *' but the argument type is 'ptrdiff_t * {aka signed long *}'.\n"
-                      "[test.cpp:9]: (portability) %Ix in format string (no. 3) requires 'size_t *' but the argument type is 'ptrdiff_t * {aka signed long *}'.\n"
-                      "[test.cpp:10]: (portability) %I32u in format string (no. 2) requires 'unsigned __int32 *' but the argument type is '__int32 * {aka signed int *}'.\n"
-                      "[test.cpp:10]: (portability) %I32x in format string (no. 3) requires 'unsigned __int32 *' but the argument type is '__int32 * {aka signed int *}'.\n"
-                      "[test.cpp:11]: (portability) %I32d in format string (no. 1) requires '__int32 *' but the argument type is 'unsigned __int32 * {aka unsigned int *}'.\n"
-                      "[test.cpp:12]: (portability) %I64u in format string (no. 2) requires 'unsigned __int64 *' but the argument type is '__int64 * {aka signed long long *}'.\n"
-                      "[test.cpp:12]: (portability) %I64x in format string (no. 3) requires 'unsigned __int64 *' but the argument type is '__int64 * {aka signed long long *}'.\n"
-                      "[test.cpp:13]: (portability) %I64d in format string (no. 1) requires '__int64 *' but the argument type is 'unsigned __int64 * {aka unsigned long long *}'.\n", errout.str());
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:8:5]: (portability) %Id in format string (no. 1) requires 'ptrdiff_t *' but the argument type is 'size_t * {aka unsigned long *}'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:9:5]: (portability) %Iu in format string (no. 2) requires 'size_t *' but the argument type is 'ptrdiff_t * {aka signed long *}'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:9:5]: (portability) %Ix in format string (no. 3) requires 'size_t *' but the argument type is 'ptrdiff_t * {aka signed long *}'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:10:5]: (portability) %I32u in format string (no. 2) requires 'unsigned __int32 *' but the argument type is '__int32 * {aka signed int *}'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:10:5]: (portability) %I32x in format string (no. 3) requires 'unsigned __int32 *' but the argument type is '__int32 * {aka signed int *}'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:11:5]: (portability) %I32d in format string (no. 1) requires '__int32 *' but the argument type is 'unsigned __int32 * {aka unsigned int *}'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:12:5]: (portability) %I64u in format string (no. 2) requires 'unsigned __int64 *' but the argument type is '__int64 * {aka signed long long *}'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:12:5]: (portability) %I64x in format string (no. 3) requires 'unsigned __int64 *' but the argument type is '__int64 * {aka signed long long *}'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:13:5]: (portability) %I64d in format string (no. 1) requires '__int64 *' but the argument type is 'unsigned __int64 * {aka unsigned long long *}'. [invalidScanfArgType_int]\n", errout_str());
 
         check("void foo() {\n"
               "    size_t s;\n"
@@ -4182,16 +4325,16 @@ class TestIO : public TestFixture {
               "    scanf(\"%I32d %I32u %I32x\", &u32, &u32, &u32);\n"
               "    scanf(\"%I64d %I64u %I64x\", &i64, &i64, &i64);\n"
               "    scanf(\"%I64d %I64u %I64x\", &u64, &u64, &u64);\n"
-              "}", false, true, Settings::Win64);
-        ASSERT_EQUALS("[test.cpp:8]: (portability) %Id in format string (no. 1) requires 'ptrdiff_t *' but the argument type is 'size_t * {aka unsigned long long *}'.\n"
-                      "[test.cpp:9]: (portability) %Iu in format string (no. 2) requires 'size_t *' but the argument type is 'ptrdiff_t * {aka signed long long *}'.\n"
-                      "[test.cpp:9]: (portability) %Ix in format string (no. 3) requires 'size_t *' but the argument type is 'ptrdiff_t * {aka signed long long *}'.\n"
-                      "[test.cpp:10]: (portability) %I32u in format string (no. 2) requires 'unsigned __int32 *' but the argument type is '__int32 * {aka signed int *}'.\n"
-                      "[test.cpp:10]: (portability) %I32x in format string (no. 3) requires 'unsigned __int32 *' but the argument type is '__int32 * {aka signed int *}'.\n"
-                      "[test.cpp:11]: (portability) %I32d in format string (no. 1) requires '__int32 *' but the argument type is 'unsigned __int32 * {aka unsigned int *}'.\n"
-                      "[test.cpp:12]: (portability) %I64u in format string (no. 2) requires 'unsigned __int64 *' but the argument type is '__int64 * {aka signed long long *}'.\n"
-                      "[test.cpp:12]: (portability) %I64x in format string (no. 3) requires 'unsigned __int64 *' but the argument type is '__int64 * {aka signed long long *}'.\n"
-                      "[test.cpp:13]: (portability) %I64d in format string (no. 1) requires '__int64 *' but the argument type is 'unsigned __int64 * {aka unsigned long long *}'.\n", errout.str());
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
+        ASSERT_EQUALS("[test.cpp:8:5]: (portability) %Id in format string (no. 1) requires 'ptrdiff_t *' but the argument type is 'size_t * {aka unsigned long long *}'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:9:5]: (portability) %Iu in format string (no. 2) requires 'size_t *' but the argument type is 'ptrdiff_t * {aka signed long long *}'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:9:5]: (portability) %Ix in format string (no. 3) requires 'size_t *' but the argument type is 'ptrdiff_t * {aka signed long long *}'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:10:5]: (portability) %I32u in format string (no. 2) requires 'unsigned __int32 *' but the argument type is '__int32 * {aka signed int *}'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:10:5]: (portability) %I32x in format string (no. 3) requires 'unsigned __int32 *' but the argument type is '__int32 * {aka signed int *}'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:11:5]: (portability) %I32d in format string (no. 1) requires '__int32 *' but the argument type is 'unsigned __int32 * {aka unsigned int *}'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:12:5]: (portability) %I64u in format string (no. 2) requires 'unsigned __int64 *' but the argument type is '__int64 * {aka signed long long *}'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:12:5]: (portability) %I64x in format string (no. 3) requires 'unsigned __int64 *' but the argument type is '__int64 * {aka signed long long *}'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:13:5]: (portability) %I64d in format string (no. 1) requires '__int64 *' but the argument type is 'unsigned __int64 * {aka unsigned long long *}'. [invalidScanfArgType_int]\n", errout_str());
 
         check("void foo() {\n"
               "    size_t s;\n"
@@ -4211,20 +4354,58 @@ class TestIO : public TestFixture {
               "    scanf(\"%I32%i\", &s, &i);\n"
               "    scanf(\"%I64%i\", &s, &i);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:6]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:7]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:8]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:9]: (warning) 'I32' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:10]: (warning) 'I64' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:11]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:12]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:13]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:14]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:15]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:16]: (warning) 'I32' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n"
-                      "[test.cpp:17]: (warning) 'I64' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:5:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:6:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:7:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:8:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:9:5]: (warning) 'I32' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:10:5]: (warning) 'I64' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:11:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:12:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:13:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:14:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:15:5]: (warning) 'I' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:16:5]: (warning) 'I32' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n"
+                      "[test.cpp:17:5]: (warning) 'I64' in format string (no. 1) is a length modifier and cannot be used without a conversion specifier. [invalidLengthModifierError]\n", errout_str());
+
+        check("void foo() {\n"
+              "    SSIZE_T s;\n" // In MSVC, SSIZE_T is available in capital letters using #include <BaseTsd.h>
+              "    int i;\n"
+              "    scanf(\"%zd\", &s);\n"
+              "    scanf(\"%zd%i\", &s, &i);\n"
+              "    scanf(\"%zu\", &s);\n"
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:6:5]: (portability) %zu in format string (no. 1) requires 'size_t *' but the argument type is 'SSIZE_T * {aka signed long *}'. [invalidScanfArgType_int]\n", errout_str());
+
+        check("void foo() {\n"
+              "    SSIZE_T s;\n" // In MSVC, SSIZE_T is available in capital letters using #include <BaseTsd.h>
+              "    int i;\n"
+              "    scanf(\"%zd\", &s);\n"
+              "    scanf(\"%zd%i\", &s, &i);\n"
+              "    scanf(\"%zu\", &s);\n"
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
+        ASSERT_EQUALS("[test.cpp:6:5]: (portability) %zu in format string (no. 1) requires 'size_t *' but the argument type is 'SSIZE_T * {aka signed long long *}'. [invalidScanfArgType_int]\n", errout_str());
+
+        check("void foo() {\n"
+              "    SSIZE_T s;\n" // Under Unix, ssize_t has to be written in small letters. Not Cppcheck, but the compiler will report this.
+              "    int i;\n"
+              "    scanf(\"%zd\", &s);\n"
+              "    scanf(\"%zd%i\", &s, &i);\n"
+              "    scanf(\"%zu\", &s);\n"
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo() {\n"
+              "    typedef SSIZE_T ssize_t;\n" // Test using typedef
+              "    ssize_t s;\n"
+              "    int i;\n"
+              "    scanf(\"%zd\", &s);\n"
+              "    scanf(\"%zd%i\", &s, &i);\n"
+              "    scanf(\"%zu\", &s);\n"
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win64));
+        ASSERT_EQUALS("[test.cpp:7:5]: (portability) %zu in format string (no. 1) requires 'size_t *' but the argument type is 'SSIZE_T * {aka signed long long *}'. [invalidScanfArgType_int]\n", errout_str());
+
     }
 
     void testMicrosoftCStringFormatArguments() { // ticket #4920
@@ -4233,16 +4414,16 @@ class TestIO : public TestFixture {
               "    String string;\n"
               "    string.Format(\"%I32d\", u32);\n"
               "    string.AppendFormat(\"%I32d\", u32);\n"
-              "}", false, true, Settings::Win32A);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    unsigned __int32 u32;\n"
               "    CString string;\n"
               "    string.Format(\"%I32d\", u32);\n"
               "    string.AppendFormat(\"%I32d\", u32);\n"
-              "}", false, true, Settings::Unix32);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix32));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    unsigned __int32 u32;\n"
@@ -4250,10 +4431,10 @@ class TestIO : public TestFixture {
               "    string.Format(\"%I32d\", u32);\n"
               "    string.AppendFormat(\"%I32d\", u32);\n"
               "    CString::Format(\"%I32d\", u32);\n"
-              "}", false, true, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:4]: (portability) %I32d in format string (no. 1) requires '__int32' but the argument type is 'unsigned __int32 {aka unsigned int}'.\n"
-                      "[test.cpp:5]: (portability) %I32d in format string (no. 1) requires '__int32' but the argument type is 'unsigned __int32 {aka unsigned int}'.\n"
-                      "[test.cpp:6]: (portability) %I32d in format string (no. 1) requires '__int32' but the argument type is 'unsigned __int32 {aka unsigned int}'.\n", errout.str());
+              "}", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:4:12]: (portability) %I32d in format string (no. 1) requires '__int32' but the argument type is 'unsigned __int32 {aka unsigned int}'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:5:12]: (portability) %I32d in format string (no. 1) requires '__int32' but the argument type is 'unsigned __int32 {aka unsigned int}'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:6:14]: (portability) %I32d in format string (no. 1) requires '__int32' but the argument type is 'unsigned __int32 {aka unsigned int}'. [invalidPrintfArgType_sint]\n", errout_str());
     }
 
     void testMicrosoftSecurePrintfArgument() {
@@ -4261,181 +4442,181 @@ class TestIO : public TestFixture {
               "    int i;\n"
               "    unsigned int u;\n"
               "    _tprintf_s(_T(\"%d %u\"), u, i, 0);\n"
-              "}\n", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:4]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:4]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
-                      "[test.cpp:4]: (warning) _tprintf_s format string requires 2 parameters but 3 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:4:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:4:5]: (warning) _tprintf_s format string requires 2 parameters but 3 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    _tprintf_s(_T(\"%d %u\"), u, i, 0);\n"
-              "}\n", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:4]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:4]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
-                      "[test.cpp:4]: (warning) _tprintf_s format string requires 2 parameters but 3 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:4:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:4:5]: (warning) _tprintf_s format string requires 2 parameters but 3 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    printf_s(\"%d %u\", u, i, 0);\n"
-              "}\n", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:4]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:4]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
-                      "[test.cpp:4]: (warning) printf_s format string requires 2 parameters but 3 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:4:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:4:5]: (warning) printf_s format string requires 2 parameters but 3 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    wprintf_s(L\"%d %u\", u, i, 0);\n"
-              "}\n", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:4]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:4]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
-                      "[test.cpp:4]: (warning) wprintf_s format string requires 2 parameters but 3 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:4:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:4:5]: (warning) wprintf_s format string requires 2 parameters but 3 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    TCHAR str[10];\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    _stprintf_s(str, sizeof(str) / sizeof(TCHAR), _T(\"%d %u\"), u, i, 0);\n"
-              "}\n", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
-                      "[test.cpp:5]: (warning) _stprintf_s format string requires 2 parameters but 3 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:5:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:5:5]: (warning) _stprintf_s format string requires 2 parameters but 3 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    TCHAR str[10];\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    _stprintf_s(str, sizeof(str) / sizeof(TCHAR), _T(\"%d %u\"), u, i, 0);\n"
-              "}\n", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
-                      "[test.cpp:5]: (warning) _stprintf_s format string requires 2 parameters but 3 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:5:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:5:5]: (warning) _stprintf_s format string requires 2 parameters but 3 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    char str[10];\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    sprintf_s(str, sizeof(str), \"%d %u\", u, i, 0);\n"
-              "}\n", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
-                      "[test.cpp:5]: (warning) sprintf_s format string requires 2 parameters but 3 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:5:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:5:5]: (warning) sprintf_s format string requires 2 parameters but 3 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    char str[10];\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    sprintf_s(str, \"%d %u\", u, i, 0);\n"
-              "}\n", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
-                      "[test.cpp:5]: (warning) sprintf_s format string requires 2 parameters but 3 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:5:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:5:5]: (warning) sprintf_s format string requires 2 parameters but 3 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    wchar_t str[10];\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    swprintf_s(str, sizeof(str) / sizeof(wchar_t), L\"%d %u\", u, i, 0);\n"
-              "}\n", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
-                      "[test.cpp:5]: (warning) swprintf_s format string requires 2 parameters but 3 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:5:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:5:5]: (warning) swprintf_s format string requires 2 parameters but 3 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    wchar_t str[10];\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    swprintf_s(str, L\"%d %u\", u, i, 0);\n"
-              "}\n", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
-                      "[test.cpp:5]: (warning) swprintf_s format string requires 2 parameters but 3 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:5:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:5:5]: (warning) swprintf_s format string requires 2 parameters but 3 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    TCHAR str[10];\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    _sntprintf_s(str, sizeof(str) / sizeof(TCHAR), _TRUNCATE, _T(\"%d %u\"), u, i, 0);\n"
-              "}\n", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
-                      "[test.cpp:5]: (warning) _sntprintf_s format string requires 2 parameters but 3 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:5:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:5:5]: (warning) _sntprintf_s format string requires 2 parameters but 3 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    TCHAR str[10];\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    _sntprintf_s(str, sizeof(str) / sizeof(TCHAR), _TRUNCATE, _T(\"%d %u\"), u, i, 0);\n"
-              "}\n", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
-                      "[test.cpp:5]: (warning) _sntprintf_s format string requires 2 parameters but 3 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:5:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:5:5]: (warning) _sntprintf_s format string requires 2 parameters but 3 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    char str[10];\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    _snprintf_s(str, sizeof(str), _TRUNCATE, \"%d %u\", u, i, 0);\n"
-              "}\n", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
-                      "[test.cpp:5]: (warning) _snprintf_s format string requires 2 parameters but 3 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:5:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:5:5]: (warning) _snprintf_s format string requires 2 parameters but 3 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    wchar_t str[10];\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    _snwprintf_s(str, sizeof(str) / sizeof(wchar_t), _TRUNCATE, L\"%d %u\", u, i, 0);\n"
-              "}\n", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
-                      "[test.cpp:5]: (warning) _snwprintf_s format string requires 2 parameters but 3 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:5:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:5:5]: (warning) _snwprintf_s format string requires 2 parameters but 3 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo(FILE * fp) {\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    _ftprintf_s(fp, _T(\"%d %u\"), u, i, 0);\n"
-              "}\n", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:4]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:4]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
-                      "[test.cpp:4]: (warning) _ftprintf_s format string requires 2 parameters but 3 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:4:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:4:5]: (warning) _ftprintf_s format string requires 2 parameters but 3 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo(FILE * fp) {\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    _ftprintf_s(fp, _T(\"%d %u\"), u, i, 0);\n"
-              "}\n", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:4]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:4]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
-                      "[test.cpp:4]: (warning) _ftprintf_s format string requires 2 parameters but 3 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:4:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:4:5]: (warning) _ftprintf_s format string requires 2 parameters but 3 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo(FILE * fp) {\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    fprintf_s(fp, \"%d %u\", u, i, 0);\n"
-              "}\n", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:4]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:4]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
-                      "[test.cpp:4]: (warning) fprintf_s format string requires 2 parameters but 3 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:4:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:4:5]: (warning) fprintf_s format string requires 2 parameters but 3 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo(FILE * fp) {\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    fwprintf_s(fp, L\"%d %u\", u, i, 0);\n"
-              "}\n", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:4]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'.\n"
-                      "[test.cpp:4]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'.\n"
-                      "[test.cpp:4]: (warning) fwprintf_s format string requires 2 parameters but 3 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'unsigned int'. [invalidPrintfArgType_sint]\n"
+                      "[test.cpp:4:5]: (warning) %u in format string (no. 2) requires 'unsigned int' but the argument type is 'signed int'. [invalidPrintfArgType_uint]\n"
+                      "[test.cpp:4:5]: (warning) fwprintf_s format string requires 2 parameters but 3 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    char lineBuffer [600];\n"
               "    const char * const format = \"%15s%17s%17s%17s%17s\";\n"
               "    sprintf_s(lineBuffer, 600, format, \"type\", \"sum\", \"avg\", \"min\", \"max\");\n"
               "    sprintf_s(lineBuffer, format, \"type\", \"sum\", \"avg\", \"min\", \"max\");\n"
-              "}\n", false, false, Settings::Win32A);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    const char * const format1 = \"%15s%17s%17s%17s%17s\";\n"
@@ -4454,31 +4635,31 @@ class TestIO : public TestFixture {
               "    sprintf_s(lineBuffer, 100, format1, \"type\", \"sum\", \"avg\", \"min\", i, 0);\n"
               "    sprintf_s(lineBuffer, 100, format2, \"type\", \"sum\", \"avg\", \"min\", i, 0);\n"
               "    sprintf_s(lineBuffer, 100, format3, \"type\", \"sum\", \"avg\", \"min\", i, 0);\n"
-              "}\n", true, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:6]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'.\n"
-                      "[test.cpp:6]: (warning) sprintf_s format string requires 5 parameters but 6 are given.\n"
-                      "[test.cpp:7]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'.\n"
-                      "[test.cpp:7]: (warning) sprintf_s format string requires 5 parameters but 6 are given.\n"
-                      "[test.cpp:8]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'.\n"
-                      "[test.cpp:8]: (warning) sprintf_s format string requires 5 parameters but 6 are given.\n"
-                      "[test.cpp:9]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'.\n"
-                      "[test.cpp:9]: (warning) sprintf format string requires 5 parameters but 6 are given.\n"
-                      "[test.cpp:10]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'.\n"
-                      "[test.cpp:10]: (warning) sprintf format string requires 5 parameters but 6 are given.\n"
-                      "[test.cpp:11]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'.\n"
-                      "[test.cpp:11]: (warning) sprintf format string requires 5 parameters but 6 are given.\n"
-                      "[test.cpp:12]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'.\n"
-                      "[test.cpp:12]: (warning) printf format string requires 5 parameters but 6 are given.\n"
-                      "[test.cpp:13]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'.\n"
-                      "[test.cpp:13]: (warning) printf format string requires 5 parameters but 6 are given.\n"
-                      "[test.cpp:14]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'.\n"
-                      "[test.cpp:14]: (warning) printf format string requires 5 parameters but 6 are given.\n"
-                      "[test.cpp:15]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'.\n"
-                      "[test.cpp:15]: (warning) sprintf_s format string requires 5 parameters but 6 are given.\n"
-                      "[test.cpp:16]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'.\n"
-                      "[test.cpp:16]: (warning) sprintf_s format string requires 5 parameters but 6 are given.\n"
-                      "[test.cpp:17]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'.\n"
-                      "[test.cpp:17]: (warning) sprintf_s format string requires 5 parameters but 6 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = true, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:6:5]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'. [invalidPrintfArgType_s]\n"
+                      "[test.cpp:6:5]: (warning) sprintf_s format string requires 5 parameters but 6 are given. [wrongPrintfScanfArgNum]\n"
+                      "[test.cpp:7:5]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'. [invalidPrintfArgType_s]\n"
+                      "[test.cpp:7:5]: (warning) sprintf_s format string requires 5 parameters but 6 are given. [wrongPrintfScanfArgNum]\n"
+                      "[test.cpp:8:5]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'. [invalidPrintfArgType_s]\n"
+                      "[test.cpp:8:5]: (warning) sprintf_s format string requires 5 parameters but 6 are given. [wrongPrintfScanfArgNum]\n"
+                      "[test.cpp:9:5]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'. [invalidPrintfArgType_s]\n"
+                      "[test.cpp:9:5]: (warning) sprintf format string requires 5 parameters but 6 are given. [wrongPrintfScanfArgNum]\n"
+                      "[test.cpp:10:5]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'. [invalidPrintfArgType_s]\n"
+                      "[test.cpp:10:5]: (warning) sprintf format string requires 5 parameters but 6 are given. [wrongPrintfScanfArgNum]\n"
+                      "[test.cpp:11:5]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'. [invalidPrintfArgType_s]\n"
+                      "[test.cpp:11:5]: (warning) sprintf format string requires 5 parameters but 6 are given. [wrongPrintfScanfArgNum]\n"
+                      "[test.cpp:12:5]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'. [invalidPrintfArgType_s]\n"
+                      "[test.cpp:12:5]: (warning) printf format string requires 5 parameters but 6 are given. [wrongPrintfScanfArgNum]\n"
+                      "[test.cpp:13:5]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'. [invalidPrintfArgType_s]\n"
+                      "[test.cpp:13:5]: (warning) printf format string requires 5 parameters but 6 are given. [wrongPrintfScanfArgNum]\n"
+                      "[test.cpp:14:5]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'. [invalidPrintfArgType_s]\n"
+                      "[test.cpp:14:5]: (warning) printf format string requires 5 parameters but 6 are given. [wrongPrintfScanfArgNum]\n"
+                      "[test.cpp:15:5]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'. [invalidPrintfArgType_s]\n"
+                      "[test.cpp:15:5]: (warning) sprintf_s format string requires 5 parameters but 6 are given. [wrongPrintfScanfArgNum]\n"
+                      "[test.cpp:16:5]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'. [invalidPrintfArgType_s]\n"
+                      "[test.cpp:16:5]: (warning) sprintf_s format string requires 5 parameters but 6 are given. [wrongPrintfScanfArgNum]\n"
+                      "[test.cpp:17:5]: (warning) %s in format string (no. 5) requires 'char *' but the argument type is 'signed int'. [invalidPrintfArgType_s]\n"
+                      "[test.cpp:17:5]: (warning) sprintf_s format string requires 5 parameters but 6 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
     }
 
@@ -4488,47 +4669,47 @@ class TestIO : public TestFixture {
               "    unsigned int u;\n"
               "    TCHAR str[10];\n"
               "    _tscanf_s(_T(\"%s %d %u %[a-z]\"), str, 10, &u, &i, str, 10, 0)\n"
-              "}\n", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:5]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'.\n"
-                      "[test.cpp:5]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'.\n"
-                      "[test.cpp:5]: (warning) _tscanf_s format string requires 6 parameters but 7 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:5:5]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:5:5]: (warning) _tscanf_s format string requires 6 parameters but 7 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    TCHAR str[10];\n"
               "    _tscanf_s(_T(\"%s %d %u %[a-z]\"), str, 10, &u, &i, str, 10, 0)\n"
-              "}\n", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:5]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'.\n"
-                      "[test.cpp:5]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'.\n"
-                      "[test.cpp:5]: (warning) _tscanf_s format string requires 6 parameters but 7 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:5:5]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:5:5]: (warning) _tscanf_s format string requires 6 parameters but 7 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    char str[10];\n"
               "    scanf_s(\"%s %d %u %[a-z]\", str, 10, &u, &i, str, 10, 0)\n"
-              "}\n", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:5]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'.\n"
-                      "[test.cpp:5]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'.\n"
-                      "[test.cpp:5]: (warning) scanf_s format string requires 6 parameters but 7 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:5:5]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:5:5]: (warning) scanf_s format string requires 6 parameters but 7 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    wchar_t str[10];\n"
               "    wscanf_s(L\"%s %d %u %[a-z]\", str, 10, &u, &i, str, 10, 0)\n"
-              "}\n", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:5]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'.\n"
-                      "[test.cpp:5]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'.\n"
-                      "[test.cpp:5]: (warning) wscanf_s format string requires 6 parameters but 7 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:5:5]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:5:5]: (warning) wscanf_s format string requires 6 parameters but 7 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void f() {\n"
               "  char str[8];\n"
-              "  scanf_s(\"%8c\", str, sizeof(str))\n"
-              "  scanf_s(\"%9c\", str, sizeof(str))\n"
-              "}\n", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:4]: (error) Width 9 given in format string (no. 1) is larger than destination buffer 'str[8]', use %8c to prevent overflowing it.\n", errout.str());
+              "  scanf_s(\"%8c\", str, sizeof(str));\n"
+              "  scanf_s(\"%9c\", str, sizeof(str));\n"
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:4:3]: (error) Width 9 given in format string (no. 1) is larger than destination buffer 'str[8]', use %8c to prevent overflowing it. [invalidScanfFormatWidth]\n", errout_str());
 
         check("void foo() {\n"
               "    TCHAR txt[100];\n"
@@ -4536,10 +4717,10 @@ class TestIO : public TestFixture {
               "    unsigned int u;\n"
               "    TCHAR str[10];\n"
               "    _stscanf_s(txt, _T(\"%s %d %u %[a-z]\"), str, 10, &u, &i, str, 10, 0)\n"
-              "}\n", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:6]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'.\n"
-                      "[test.cpp:6]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'.\n"
-                      "[test.cpp:6]: (warning) _stscanf_s format string requires 6 parameters but 7 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:6:5]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:6:5]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:6:5]: (warning) _stscanf_s format string requires 6 parameters but 7 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    TCHAR txt[100];\n"
@@ -4547,10 +4728,10 @@ class TestIO : public TestFixture {
               "    unsigned int u;\n"
               "    TCHAR str[10];\n"
               "    _stscanf_s(txt, _T(\"%s %d %u %[a-z]\"), str, 10, &u, &i, str, 10, 0)\n"
-              "}\n", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:6]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'.\n"
-                      "[test.cpp:6]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'.\n"
-                      "[test.cpp:6]: (warning) _stscanf_s format string requires 6 parameters but 7 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:6:5]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:6:5]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:6:5]: (warning) _stscanf_s format string requires 6 parameters but 7 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    char txt[100];\n"
@@ -4558,10 +4739,10 @@ class TestIO : public TestFixture {
               "    unsigned int u;\n"
               "    char str[10];\n"
               "    sscanf_s(txt, \"%s %d %u %[a-z]\", str, 10, &u, &i, str, 10, 0)\n"
-              "}\n", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:6]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'.\n"
-                      "[test.cpp:6]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'.\n"
-                      "[test.cpp:6]: (warning) sscanf_s format string requires 6 parameters but 7 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:6:5]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:6:5]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:6:5]: (warning) sscanf_s format string requires 6 parameters but 7 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    wchar_t txt[100];\n"
@@ -4569,116 +4750,116 @@ class TestIO : public TestFixture {
               "    unsigned int u;\n"
               "    wchar_t str[10];\n"
               "    swscanf_s(txt, L\"%s %d %u %[a-z]\", str, 10, &u, &i, str, 10, 0)\n"
-              "}\n", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:6]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'.\n"
-                      "[test.cpp:6]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'.\n"
-                      "[test.cpp:6]: (warning) swscanf_s format string requires 6 parameters but 7 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:6:5]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:6:5]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:6:5]: (warning) swscanf_s format string requires 6 parameters but 7 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo(FILE * fp) {\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    TCHAR str[10];\n"
               "    _ftscanf_s(fp, _T(\"%s %d %u %[a-z]\"), str, 10, &u, &i, str, 10, 0)\n"
-              "}\n", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:5]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'.\n"
-                      "[test.cpp:5]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'.\n"
-                      "[test.cpp:5]: (warning) _ftscanf_s format string requires 6 parameters but 7 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:5:5]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:5:5]: (warning) _ftscanf_s format string requires 6 parameters but 7 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo(FILE * fp) {\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    TCHAR str[10];\n"
               "    _ftscanf_s(fp, _T(\"%s %d %u %[a-z]\"), str, 10, &u, &i, str, 10, 0)\n"
-              "}\n", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:5]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'.\n"
-                      "[test.cpp:5]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'.\n"
-                      "[test.cpp:5]: (warning) _ftscanf_s format string requires 6 parameters but 7 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:5:5]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:5:5]: (warning) _ftscanf_s format string requires 6 parameters but 7 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo(FILE * fp) {\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    char str[10];\n"
               "    fscanf_s(fp, \"%s %d %u %[a-z]\", str, 10, &u, &i, str, 10, 0)\n"
-              "}\n", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:5]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'.\n"
-                      "[test.cpp:5]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'.\n"
-                      "[test.cpp:5]: (warning) fscanf_s format string requires 6 parameters but 7 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:5:5]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:5:5]: (warning) fscanf_s format string requires 6 parameters but 7 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo(FILE * fp) {\n"
               "    int i;\n"
               "    unsigned int u;\n"
               "    wchar_t str[10];\n"
               "    fwscanf_s(fp, L\"%s %d %u %[a-z]\", str, 10, &u, &i, str, 10, 0)\n"
-              "}\n", false, false, Settings::Win32W);
-        ASSERT_EQUALS("[test.cpp:5]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'.\n"
-                      "[test.cpp:5]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'.\n"
-                      "[test.cpp:5]: (warning) fwscanf_s format string requires 6 parameters but 7 are given.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) %d in format string (no. 2) requires 'int *' but the argument type is 'unsigned int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:5:5]: (warning) %u in format string (no. 3) requires 'unsigned int *' but the argument type is 'signed int *'. [invalidScanfArgType_int]\n"
+                      "[test.cpp:5:5]: (warning) fwscanf_s format string requires 6 parameters but 7 are given. [wrongPrintfScanfArgNum]\n", errout_str());
 
         check("void foo() {\n"
               "    WCHAR msStr1[5] = {0};\n"
               "    wscanf_s(L\"%4[^-]\", msStr1, _countof(msStr1));\n"
-              "}\n", false, false, Settings::Win32W);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.platform = Platform::Type::Win32W));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testQStringFormatArguments() {
         check("void foo(float f) {\n"
               "    QString string;\n"
               "    string.sprintf(\"%d\", f);\n"
-              "}", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:3]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'float'.\n", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:3:12]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'float'. [invalidPrintfArgType_sint]\n", errout_str());
 
         check("void foo(float f) {\n"
               "    QString string;\n"
               "    string = QString::asprintf(\"%d\", f);\n"
-              "}", false, false, Settings::Win32A);
-        ASSERT_EQUALS("[test.cpp:3]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'float'.\n", errout.str());
+              "}", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("[test.cpp:3:23]: (warning) %d in format string (no. 1) requires 'int' but the argument type is 'float'. [invalidPrintfArgType_sint]\n", errout_str());
     }
 
     void testTernary() {  // ticket #6182
         check("void test(const std::string &val) {\n"
               "    printf(\"%s\", val.empty() ? \"I like to eat bananas\" : val.c_str());\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testUnsignedConst() {  // ticket #6321
         check("void test() {\n"
               "    unsigned const x = 5;\n"
               "    printf(\"%u\", x);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testAstType() { // ticket #7014
         check("void test() {\n"
               "    printf(\"%c\", \"hello\"[0]);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void test() {\n"
               "    printf(\"%lld\", (long long)1);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void test() {\n"
               "    printf(\"%i\", (short *)x);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) %i in format string (no. 1) requires 'int' but the argument type is 'signed short *'.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning) %i in format string (no. 1) requires 'int' but the argument type is 'signed short *'. [invalidPrintfArgType_sint]\n", errout_str());
 
         check("int (*fp)();\n" // #7178 - function pointer call
               "void test() {\n"
               "    printf(\"%i\", fp());\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testPrintf0WithSuffix() { // ticket #7069
         check("void foo() {\n"
               "    printf(\"%u %lu %llu\", 0U, 0UL, 0ULL);\n"
               "    printf(\"%u %lu %llu\", 0u, 0ul, 0ull);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testReturnValueTypeStdLib() {
@@ -4686,13 +4867,13 @@ class TestIO : public TestFixture {
               "   const char *s = \"0\";\n"
               "   printf(\"%ld%lld\", atol(s), atoll(s));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // 8141
         check("void f(int i) {\n"
               "   printf(\"%f\", imaxabs(i));\n"
-              "}\n", false, true, Settings::Unix64);
-        ASSERT_EQUALS("[test.cpp:2]: (portability) %f in format string (no. 1) requires 'double' but the argument type is 'intmax_t {aka signed long}'.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.portability = true, $.platform = Platform::Type::Unix64));
+        ASSERT_EQUALS("[test.cpp:2:4]: (portability) %f in format string (no. 1) requires 'double' but the argument type is 'intmax_t {aka signed long}'. [invalidPrintfArgType_float]\n", errout_str());
     }
 
     void testPrintfTypeAlias1() {
@@ -4705,7 +4886,7 @@ class TestIO : public TestFixture {
               "void foo() {\n"
               "    printf(\"%d %p %p\", i, pi, pci);\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("using INT = int;\n\n"
               "using PINT = INT *;\n"
@@ -4716,9 +4897,9 @@ class TestIO : public TestFixture {
               "void foo() {\n"
               "    printf(\"%f %f %f\", i, pi, pci);\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:8]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'signed int'.\n"
-                      "[test.cpp:8]: (warning) %f in format string (no. 2) requires 'double' but the argument type is 'signed int *'.\n"
-                      "[test.cpp:8]: (warning) %f in format string (no. 3) requires 'double' but the argument type is 'const signed int *'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:5]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'signed int'. [invalidPrintfArgType_float]\n"
+                      "[test.cpp:8:5]: (warning) %f in format string (no. 2) requires 'double' but the argument type is 'signed int *'. [invalidPrintfArgType_float]\n"
+                      "[test.cpp:8:5]: (warning) %f in format string (no. 3) requires 'double' but the argument type is 'const signed int *'. [invalidPrintfArgType_float]\n", errout_str());
     }
 
     void testPrintfAuto() { // #8992
@@ -4726,8 +4907,69 @@ class TestIO : public TestFixture {
               "    auto s = sizeof(int);\n"
               "    printf(\"%zu\", s);\n"
               "    printf(\"%f\", s);\n"
-              "}\n", false, true);
-        ASSERT_EQUALS("[test.cpp:4]: (portability) %f in format string (no. 1) requires 'double' but the argument type is 'size_t {aka unsigned long}'.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.portability = true));
+        ASSERT_EQUALS("[test.cpp:4:5]: (portability) %f in format string (no. 1) requires 'double' but the argument type is 'size_t {aka unsigned long}'. [invalidPrintfArgType_float]\n", errout_str());
+    }
+
+    void testPrintfParenthesis() { // #8489
+        check("void f(int a) {\n"
+              "    printf(\"%f\", (a >> 24) & 0xff);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'signed int'. [invalidPrintfArgType_float]\n", errout_str());
+
+        check("void f(int a) {\n"
+              "    printf(\"%f\", 0xff & (a >> 24));\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'signed int'. [invalidPrintfArgType_float]\n", errout_str());
+
+        check("void f(int a) {\n"
+              "    printf(\"%f\", ((a >> 24) + 1) & 0xff);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning) %f in format string (no. 1) requires 'double' but the argument type is 'signed int'. [invalidPrintfArgType_float]\n", errout_str());
+    }
+
+    void testStdDistance() { // #10304
+        check("void foo(const std::vector<int>& IO, const int* pio) {\n"
+              "const auto Idx = std::distance(&IO.front(), pio);\n"
+              "printf(\"Idx = %td\", Idx);\n"
+              "}", dinit(CheckOptions, $.portability = true));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void testParameterPack() { // #11289
+        check("template <typename... Args> auto f(const char* format, const Args&... args) {\n"
+              "    return snprintf(nullptr, 0, format, args...);\n"
+              "}\n"
+              "void g() {\n"
+              "    f(\"%d%d\", 1, 2);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // TODO: we need to run big tests with a platform that has unsigned chars
+    void testDefaultSignInt() { // #13363
+        // Platform::defaultSign should only affect char
+        const char code[] =
+            "void f() {\n"
+            "    double d = 1\n;"
+            "    printf(\"%i\", int(d));\n"
+            "}\n";
+        check(code);
+        ASSERT_EQUALS("", errout_str());
+        check(code, dinit(CheckOptions, $.defaultSign = 's'));
+        ASSERT_EQUALS("", errout_str());
+        check(code, dinit(CheckOptions, $.defaultSign = 'u'));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void testPrintfWithGeneric() { // #13592
+        const char code[] =
+            "void f(void) {\n"
+            "    float x = 27.0f;\n"
+            "    printf(\"%s\\n\", _Generic(x, double: cbrt, float: cbrtf)(x));\n"
+            "}\n";
+        check(code);
+        ASSERT_EQUALS("", errout_str());
     }
 };
 
diff --git a/test/testleakautovar.cpp b/test/testleakautovar.cpp
index 2dc5f1d0c6f..300db8d9855 100644
--- a/test/testleakautovar.cpp
+++ b/test/testleakautovar.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,46 +16,23 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include "checkleakautovar.h"
-#include "library.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
 
-#include <simplecpp.h>
-#include <tinyxml2.h>
-#include <vector>
+#include <cstddef>
+#include <string>
 
 class TestLeakAutoVar : public TestFixture {
 public:
-    TestLeakAutoVar() : TestFixture("TestLeakAutoVar") {
-    }
+    TestLeakAutoVar() : TestFixture("TestLeakAutoVar") {}
 
 private:
-    Settings settings;
-
-    void run() OVERRIDE {
-        int id = 0;
-        while (!Library::ismemory(++id));
-        settings.library.setalloc("malloc", id, -1);
-        settings.library.setrealloc("realloc", id, -1);
-        settings.library.setdealloc("free", id, 1);
-        while (!Library::isresource(++id));
-        settings.library.setalloc("fopen", id, -1);
-        settings.library.setrealloc("freopen", id, -1, 3);
-        settings.library.setdealloc("fclose", id, 1);
-        settings.library.smartPointers.insert("std::shared_ptr");
-        settings.library.smartPointers.insert("std::unique_ptr");
-
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-        "<def>\n"
-        "  <podtype name=\"uint8_t\" sign=\"u\" size=\"1\"/>\n"
-        "</def>";
-        tinyxml2::XMLDocument doc;
-        doc.Parse(xmldata, sizeof(xmldata));
-        settings.library.load(doc);
+    const Settings settings = settingsBuilder().library("std.cfg").checkLibrary().build();
 
+    void run() override {
+        mNewTemplate = true;
         // Assign
         TEST_CASE(assign1);
         TEST_CASE(assign2);
@@ -69,30 +46,49 @@ class TestLeakAutoVar : public TestFixture {
         TEST_CASE(assign10);
         TEST_CASE(assign11); // #3942: x = a(b(p));
         TEST_CASE(assign12); // #4236: FP. bar(&x);
-        // TODO TEST_CASE(assign13); // #4237: FP. char*&ref=p; p=malloc(10); free(ref);
+        TEST_CASE(assign13); // #4237: FP. char*&ref=p; p=malloc(10); free(ref);
         TEST_CASE(assign14);
         TEST_CASE(assign15);
         TEST_CASE(assign16);
         TEST_CASE(assign17); // #9047
         TEST_CASE(assign18);
         TEST_CASE(assign19);
+        TEST_CASE(assign20); // #9187
+        TEST_CASE(assign21); // #10186
+        TEST_CASE(assign22); // #9139
+        TEST_CASE(assign23);
+        TEST_CASE(assign24); // #7440
+        TEST_CASE(assign25);
+        TEST_CASE(assign26);
+
+        TEST_CASE(memcpy1); // #11542
+        TEST_CASE(memcpy2);
 
         TEST_CASE(isAutoDealloc);
 
         TEST_CASE(realloc1);
         TEST_CASE(realloc2);
         TEST_CASE(realloc3);
+        TEST_CASE(realloc4);
+        TEST_CASE(realloc5); // #9292, #9990
         TEST_CASE(freopen1);
         TEST_CASE(freopen2);
 
         TEST_CASE(deallocuse1);
-        TEST_CASE(deallocuse2);
         TEST_CASE(deallocuse3);
         TEST_CASE(deallocuse4);
-        // TODO TEST_CASE(deallocuse5); // #4018: FP. free(p), p = 0;
+        TEST_CASE(deallocuse5); // #4018: FP. free(p), p = 0;
         TEST_CASE(deallocuse6); // #4034: FP. x = p = f();
         TEST_CASE(deallocuse7); // #6467, #6469, #6473
         TEST_CASE(deallocuse8); // #1765
+        TEST_CASE(deallocuse9); // #9781
+        TEST_CASE(deallocuse10);
+        TEST_CASE(deallocuse11); // #8302
+        TEST_CASE(deallocuse12);
+        TEST_CASE(deallocuse13);
+        TEST_CASE(deallocuse14);
+        TEST_CASE(deallocuse15);
+        TEST_CASE(deallocuse16); // #8109: delete with comma operator
 
         TEST_CASE(doublefree1);
         TEST_CASE(doublefree2);
@@ -104,11 +100,21 @@ class TestLeakAutoVar : public TestFixture {
         TEST_CASE(doublefree8);
         TEST_CASE(doublefree9);
         TEST_CASE(doublefree10); // #8706
+        TEST_CASE(doublefree11);
+        TEST_CASE(doublefree12); // #10502
+        TEST_CASE(doublefree13); // #11008
+        TEST_CASE(doublefree14); // #9708
+        TEST_CASE(doublefree15);
+        TEST_CASE(doublefree16);
+        TEST_CASE(doublefree17); // #8109: delete with comma operator
+        TEST_CASE(doublefree18);
+        TEST_CASE(doublefree19); // #13960
 
         // exit
         TEST_CASE(exit1);
         TEST_CASE(exit2);
         TEST_CASE(exit3);
+        TEST_CASE(exit4);
 
         // handling function calls
         TEST_CASE(functioncall1);
@@ -116,6 +122,7 @@ class TestLeakAutoVar : public TestFixture {
         // goto
         TEST_CASE(goto1);
         TEST_CASE(goto2);
+        TEST_CASE(goto3); // #11431
 
         // if/else
         TEST_CASE(ifelse1);
@@ -133,12 +140,27 @@ class TestLeakAutoVar : public TestFixture {
         TEST_CASE(ifelse13); // #8392
         TEST_CASE(ifelse14); // #9130 - if (x == (char*)NULL)
         TEST_CASE(ifelse15); // #9206 - if (global_ptr = malloc(1))
+        TEST_CASE(ifelse16); // #9635 - if (p = malloc(4), p == NULL)
+        TEST_CASE(ifelse17); //  if (!!(!p))
+        TEST_CASE(ifelse18);
+        TEST_CASE(ifelse19);
+        TEST_CASE(ifelse20); // #10182
+        TEST_CASE(ifelse21);
+        TEST_CASE(ifelse22); // #10187
+        TEST_CASE(ifelse23); // #5473
+        TEST_CASE(ifelse24); // #1733
+        TEST_CASE(ifelse25); // #9966
+        TEST_CASE(ifelse26);
+        TEST_CASE(ifelse27);
+        TEST_CASE(ifelse28); // #11038
+        TEST_CASE(ifelse29);
 
         // switch
         TEST_CASE(switch1);
 
         // loops
         TEST_CASE(loop1);
+        TEST_CASE(loop2);
 
         // mismatching allocation/deallocation
         TEST_CASE(mismatchAllocDealloc);
@@ -155,6 +177,11 @@ class TestLeakAutoVar : public TestFixture {
         TEST_CASE(return6); // #8282 return {p, p}
         TEST_CASE(return7); // #9343 return (uint8_t*)x
         TEST_CASE(return8);
+        TEST_CASE(return9);
+        TEST_CASE(return10);
+        TEST_CASE(return11); // #13098
+        TEST_CASE(return12); // #12238
+        TEST_CASE(return13);
 
         // General tests: variable type, allocation type, etc
         TEST_CASE(test1);
@@ -172,6 +199,8 @@ class TestLeakAutoVar : public TestFixture {
         TEST_CASE(configuration2);
         TEST_CASE(configuration3);
         TEST_CASE(configuration4);
+        TEST_CASE(configuration5);
+        TEST_CASE(configuration6);
 
         TEST_CASE(ptrptr);
 
@@ -182,49 +211,37 @@ class TestLeakAutoVar : public TestFixture {
 
         TEST_CASE(smartPtrInContainer); // #8262
 
-        TEST_CASE(recursiveCountLimit); // #5872 #6157 #9097
+        TEST_CASE(functionCallCastConfig); // #9652
+        TEST_CASE(functionCallLeakIgnoreConfig); // #7923
     }
 
-    void check(const char code[], bool cpp = false) {
-        // Clear the error buffer..
-        errout.str("");
+    struct CheckOptions
+    {
+        bool cpp = false;
+        const Settings *s = nullptr;
+    };
+
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
+        const Settings& settings1 = options.s ? *options.s : settings;
 
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, cpp?"test.cpp":"test.c");
+        SimpleTokenizer tokenizer(settings1, *this, options.cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check for leaks..
-        CheckLeakAutoVar c;
-        settings.checkLibrary = true;
-        settings.addEnabled("information");
-        c.runChecks(&tokenizer, &settings, this);
+        runChecks<CheckLeakAutoVar>(tokenizer, this);
     }
 
-    void checkP(const char code[], bool cpp = false) {
-        // Clear the error buffer..
-        errout.str("");
-
-        // Raw tokens..
-        std::vector<std::string> files(1, cpp?"test.cpp":"test.c");
-        std::istringstream istr(code);
-        const simplecpp::TokenList tokens1(istr, files, files[0]);
-
-        // Preprocess..
-        simplecpp::TokenList tokens2(files);
-        std::map<std::string, simplecpp::TokenList*> filedata;
-        simplecpp::preprocess(tokens2, tokens1, files, filedata, simplecpp::DUI());
-
-        // Tokenizer..
-        Tokenizer tokenizer(&settings, this);
-        tokenizer.createTokens(&tokens2);
-        tokenizer.simplifyTokens1("");
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const Settings & s) {
+        // Tokenize..
+        SimpleTokenizer tokenizer(s, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check for leaks..
-        CheckLeakAutoVar c;
-        settings.checkLibrary = true;
-        settings.addEnabled("information");
-        c.runChecks(&tokenizer, &settings, this);
+        runChecks<CheckLeakAutoVar>(tokenizer, this);
     }
 
     void assign1() {
@@ -233,7 +250,7 @@ class TestLeakAutoVar : public TestFixture {
               "    p = NULL;\n"
               "    free(p);\n"
               "}");
-        ASSERT_EQUALS("[test.c:3]: (error) Memory leak: p\n", errout.str());
+        ASSERT_EQUALS("[test.c:3:5]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
     void assign2() {
@@ -242,7 +259,7 @@ class TestLeakAutoVar : public TestFixture {
               "    char *q = p;\n"
               "    free(q);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void assign3() {
@@ -251,7 +268,7 @@ class TestLeakAutoVar : public TestFixture {
               "    char *q = p + 1;\n"
               "    free(q - 1);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void assign4() {
@@ -260,7 +277,7 @@ class TestLeakAutoVar : public TestFixture {
               "    a += 10;\n"
               "    free(a - 10);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void assign5() {
@@ -269,7 +286,7 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p = new char[100];\n"
               "    list += p;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void assign6() { // #2806 - FP when there is redundant assignment
@@ -278,7 +295,7 @@ class TestLeakAutoVar : public TestFixture {
               "    p = strcpy(p,q);\n"
               "    free(p);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void assign7() {
@@ -286,7 +303,7 @@ class TestLeakAutoVar : public TestFixture {
               "    struct str *p = malloc(10);\n"
               "    d->p = p;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void assign8() {  // linux list
@@ -294,7 +311,7 @@ class TestLeakAutoVar : public TestFixture {
               "    struct str *p = malloc(10);\n"
               "    d->p = &p->x;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void assign9() {
@@ -303,7 +320,7 @@ class TestLeakAutoVar : public TestFixture {
               "    free(p);\n"
               "    p = NULL;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void assign10() {
@@ -313,7 +330,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (!x) { p = NULL; }\n"
               "    free(p);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void assign11() { // #3942 - FP for x = a(b(p));
@@ -321,7 +338,7 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p = malloc(10);\n"
               "    x = a(b(p));\n"
               "}");
-        ASSERT_EQUALS("[test.c:4]: (information) --check-library: Function b() should have <use>/<leak-ignore> configuration\n", errout.str());
+        ASSERT_EQUALS("[test.c:4:1]: (information) --check-library: Function b() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n", errout_str());
     }
 
     void assign12() { // #4236: FP. bar(&x)
@@ -331,7 +348,7 @@ class TestLeakAutoVar : public TestFixture {
               "    bar(&p);\n"
               "    free(p);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void assign13() { // #4237: FP. char *&ref=p; p=malloc(10); free(ref);
@@ -340,8 +357,8 @@ class TestLeakAutoVar : public TestFixture {
               "    char * &ref = p;\n"
               "    p = malloc(10);\n"
               "    free(ref);\n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        TODO_ASSERT_EQUALS("", "[test.cpp:6:1]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
     void assign14() {
@@ -349,13 +366,13 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p;\n"
               "    if (x && (p = malloc(10))) { }"
               "}");
-        ASSERT_EQUALS("[test.c:3]: (error) Memory leak: p\n", errout.str());
+        ASSERT_EQUALS("[test.c:3:35]: (error) Memory leak: p [memleak]\n", errout_str());
 
         check("void f(int x) {\n"
               "    char *p;\n"
               "    if (x && (p = new char[10])) { }"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Memory leak: p\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:3:37]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
     void assign15() {
@@ -367,7 +384,7 @@ class TestLeakAutoVar : public TestFixture {
               "   p = malloc(sizeof *p);\n"
               "   free(p);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void assign16() {
@@ -376,19 +393,19 @@ class TestLeakAutoVar : public TestFixture {
               "   free(p);\n"
               "   if (p=dostuff()) *p = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void assign17() { // #9047
         check("void f() {\n"
               "    char *p = (char*)malloc(10);\n"
               "}");
-        ASSERT_EQUALS("[test.c:3]: (error) Memory leak: p\n", errout.str());
+        ASSERT_EQUALS("[test.c:3:1]: (error) Memory leak: p [memleak]\n", errout_str());
 
         check("void f() {\n"
               "    char *p = (char*)(int*)malloc(10);\n"
               "}");
-        ASSERT_EQUALS("[test.c:3]: (error) Memory leak: p\n", errout.str());
+        ASSERT_EQUALS("[test.c:3:1]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
     void assign18() {
@@ -396,13 +413,13 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p;\n"
               "    if (x && (p = (char*)malloc(10))) { }"
               "}");
-        ASSERT_EQUALS("[test.c:3]: (error) Memory leak: p\n", errout.str());
+        ASSERT_EQUALS("[test.c:3:42]: (error) Memory leak: p [memleak]\n", errout_str());
 
         check("void f(int x) {\n"
               "    char *p;\n"
               "    if (x && (p = (char*)(int*)malloc(10))) { }"
               "}");
-        ASSERT_EQUALS("[test.c:3]: (error) Memory leak: p\n", errout.str());
+        ASSERT_EQUALS("[test.c:3:48]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
     void assign19() {
@@ -410,24 +427,295 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p = malloc(10);\n"
               "    free((void*)p);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void assign20() { // #9187
+        check("void f() {\n"
+              "    char *p = static_cast<int>(malloc(10));\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:3:1]: (error) Memory leak: p [memleak]\n", errout_str());
+    }
+
+    void assign21() {
+        check("void f(int **x) {\n" // #10186
+              "    void *p = malloc(10);\n"
+              "    *x = (int*)p;\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { int i; };\n" // #10996
+              "void f() {\n"
+              "    S* s = new S();\n"
+              "    (void)s;\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:5:1]: (error) Memory leak: s [memleak]\n", errout_str());
+    }
+
+    void assign22() { // #9139
+        const Settings s = settingsBuilder().library("posix.cfg").checkLibrary().build();
+        check("void f(char tempFileName[256]) {\n"
+              "    const int fd = socket(AF_INET, SOCK_PACKET, 0 );\n"
+              "}", dinit(CheckOptions, $.cpp = true, $.s = &s));
+        ASSERT_EQUALS("[test.cpp:3:1]: (error) Resource leak: fd [resourceLeak]\n", errout_str());
+
+        check("void f() {\n"
+              "    const void * const p = malloc(10);\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:3:1]: (error) Memory leak: p [memleak]\n", errout_str());
+    }
+
+    void assign23() {
+        const Settings s = settingsBuilder().library("posix.cfg").checkLibrary().build();
+        check("void f() {\n"
+              "    int n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12, n13, n14;\n"
+              "    *&n1 = open(\"xx.log\", O_RDONLY);\n"
+              "    *&(n2) = open(\"xx.log\", O_RDONLY);\n"
+              "    *(&n3) = open(\"xx.log\", O_RDONLY);\n"
+              "    *&*&n4 = open(\"xx.log\", O_RDONLY);\n"
+              "    *&*&*&(n5) = open(\"xx.log\", O_RDONLY);\n"
+              "    *&*&(*&n6) = open(\"xx.log\", O_RDONLY);\n"
+              "    *&*(&*&n7) = open(\"xx.log\", O_RDONLY);\n"
+              "    *(&*&n8) = open(\"xx.log\", O_RDONLY);\n"
+              "    *&(*&*&(*&n9)) = open(\"xx.log\", O_RDONLY);\n"
+              "    (n10) = open(\"xx.log\", O_RDONLY);\n"
+              "    ((n11)) = open(\"xx.log\", O_RDONLY);\n"
+              "    ((*&n12)) = open(\"xx.log\", O_RDONLY);\n"
+              "    *(&(*&n13)) = open(\"xx.log\", O_RDONLY);\n"
+              "    ((*&(*&n14))) = open(\"xx.log\", O_RDONLY);\n"
+              "}\n", dinit(CheckOptions, $.cpp = true, $.s = &s));
+        ASSERT_EQUALS("[test.cpp:17:1]: (error) Resource leak: n1 [resourceLeak]\n"
+                      "[test.cpp:17:1]: (error) Resource leak: n2 [resourceLeak]\n"
+                      "[test.cpp:17:1]: (error) Resource leak: n3 [resourceLeak]\n"
+                      "[test.cpp:17:1]: (error) Resource leak: n4 [resourceLeak]\n"
+                      "[test.cpp:17:1]: (error) Resource leak: n5 [resourceLeak]\n"
+                      "[test.cpp:17:1]: (error) Resource leak: n6 [resourceLeak]\n"
+                      "[test.cpp:17:1]: (error) Resource leak: n7 [resourceLeak]\n"
+                      "[test.cpp:17:1]: (error) Resource leak: n8 [resourceLeak]\n"
+                      "[test.cpp:17:1]: (error) Resource leak: n9 [resourceLeak]\n"
+                      "[test.cpp:17:1]: (error) Resource leak: n10 [resourceLeak]\n"
+                      "[test.cpp:17:1]: (error) Resource leak: n11 [resourceLeak]\n"
+                      "[test.cpp:17:1]: (error) Resource leak: n12 [resourceLeak]\n"
+                      "[test.cpp:17:1]: (error) Resource leak: n13 [resourceLeak]\n"
+                      "[test.cpp:17:1]: (error) Resource leak: n14 [resourceLeak]\n",
+                      errout_str());
+    }
+
+    void assign24() {
+        check("void f() {\n" // #7440
+              "    char* data = new char[100];\n"
+              "    char** dataPtr = &data;\n"
+              "    delete[] *dataPtr;\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    char* data = new char[100];\n"
+              "    char** dataPtr = &data;\n"
+              "    printf(\"test\");\n"
+              "    delete[] *dataPtr;\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n" // #9279
+              "    int* p = new int;\n"
+              "    *p = 42;\n"
+              "    g();\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:4:8]: (information) --check-library: Function g() should have <noreturn> configuration [checkLibraryNoReturn]\n",
+                      errout_str());
+
+        check("void g();\n"
+              "void f() {\n"
+              "    int* p = new int;\n"
+              "    *p = 42;\n"
+              "    g();\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:6:1]: (error) Memory leak: p [memleak]\n", errout_str());
+
+        check("void g() {}\n"
+              "void f() {\n"
+              "    int* p = new int;\n"
+              "    *p = 42;\n"
+              "    g();\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:6:1]: (error) Memory leak: p [memleak]\n", errout_str());
+
+        check("[[noreturn]] void g();\n"
+              "void f() {\n"
+              "    int* p = new int;\n"
+              "    *p = 42;\n"
+              "    g();\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void g() { exit(1); }\n"
+              "void f() {\n"
+              "    int* p = new int;\n"
+              "    *p = 42;\n"
+              "    g();\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void g() {}\n" // #10517
+              "void f() {\n"
+              "    char* p = malloc(10);\n"
+              "    g();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.c:5:1]: (error) Memory leak: p [memleak]\n", errout_str());
+    }
+
+    void assign25() {
+        check("void f() {\n" // #11796
+              "    int* p{ new int };\n"
+              "    int* q(new int);\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:4:1]: (error) Memory leak: p [memleak]\n"
+                      "[test.cpp:4:1]: (error) Memory leak: q [memleak]\n",
+                      errout_str());
+
+        check("struct S : B {\n" // #12239
+              "    void f();\n"
+              "    void g();\n"
+              "};\n"
+              "void S::f() {\n"
+              "    FD* fd(new FD(this));\n"
+              "    fd->exec();\n"
+              "}\n"
+              "void S::g() {\n"
+              "    FD* fd{ new FD(this) };\n"
+              "    fd->exec();\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct C {\n" // #12327
+              "    char* m_p;\n"
+              "    C(char* p) : m_p(p) {}\n"
+              "};\n"
+              "std::list<C> gli;\n"
+              "void f() {\n"
+              "    std::list<C> li;\n"
+              "    char* p = new char[1];\n"
+              "    C c(p);\n"
+              "    li.push_back(c);\n"
+              "    C c2(li.front());\n"
+              "    delete[] c2.m_p;\n"
+              "}\n"
+              "void g() {\n"
+              "    char* p = new char[1];\n"
+              "    C c(p);\n"
+              "    gli.push_back(c);\n"
+              "}\n"
+              "void h() {\n"
+              "    std::list<C> li;\n"
+              "    char* p = new char[1];\n"
+              "    C c(p);\n"
+              "    li.push_back(c);\n"
+              "    delete[] li.front().m_p;\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #12890
+              "    int** p;\n"
+              "    S() {\n"
+              "        p = std::malloc(sizeof(int*));\n"
+              "        p[0] = new int;\n"
+              "    }\n"
+              "    ~S() {\n"
+              "        delete p[0];\n"
+              "        std::free(p);\n"
+              "    }\n"
+              "};\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void assign26() {
+        check("void f(int*& x) {\n" // #8235
+              "    int* p = (int*)malloc(10);\n"
+              "    x = p ? p : nullptr;\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int*& x) {\n"
+              "    int* p = (int*)malloc(10);\n"
+              "    x = p != nullptr ? p : nullptr;\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const char* n) {\n" // #12724
+              "    FILE* fp = fopen(n, \"r\");\n"
+              "    bool b = (fp == NULL);\n"
+              "    if (b)\n"
+              "        return;\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:6:1]: (error) Resource leak: fp [resourceLeak]\n", errout_str());
+    }
+
+    void memcpy1() { // #11542
+        check("void f(char** old, char* value) {\n"
+              "    char *str = strdup(value);\n"
+              "    memcpy(old, &str, sizeof(char*));\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void memcpy2() {
+        check("void f(char* old, char* value, size_t len) {\n"
+              "    char *str = strdup(value);\n"
+              "    memcpy(old, str, len);\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:4:1]: (error) Memory leak: str [memleak]\n", errout_str());
     }
 
     void isAutoDealloc() {
         check("void f() {\n"
               "    char *p = new char[100];"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:2]: (error) Memory leak: p\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:2:29]: (error) Memory leak: p [memleak]\n", errout_str());
 
         check("void f() {\n"
               "    Fred *fred = new Fred;"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    std::string *str = new std::string;"
-              "}", true);
-        TODO_ASSERT_EQUALS("[test.cpp:2]: (error) Memory leak: str\n", "", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:2:40]: (error) Memory leak: str [memleak]\n", errout_str());
+
+        check("class TestType {\n" // #9028
+              "public:\n"
+              "    char ca[12];\n"
+              "};\n"
+              "void f() {\n"
+              "    TestType *tt = new TestType();\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:7:1]: (error) Memory leak: tt [memleak]\n", errout_str());
+
+        check("void f(Bar& b) {\n" // #7622
+              "    char* data = new char[10];\n"
+              "    b = Bar(*new Foo(data));\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:4:1]: (information) --check-library: Function Foo() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n", errout_str());
+
+        check("class B {};\n"
+              "    class D : public B {};\n"
+              "    void g() {\n"
+              "        auto d = new D();\n"
+              "        if (d) {}\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:6:1]: (error) Memory leak: d [memleak]\n", errout_str());
+
+        check("struct S {\n" // #12354
+              "    int i{};\n"
+              "    void f();\n"
+              "};\n"
+              "void f(S* p, bool b) {\n"
+              "    if (b)\n"
+              "        p = new S();\n"
+              "    p->f();\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:9:1]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
     void realloc1() {
@@ -436,7 +724,7 @@ class TestLeakAutoVar : public TestFixture {
               "    void *q = realloc(p, 20);\n"
               "    free(q)\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void realloc2() {
@@ -444,7 +732,7 @@ class TestLeakAutoVar : public TestFixture {
               "    void *p = malloc(10);\n"
               "    void *q = realloc(p, 20);\n"
               "}");
-        ASSERT_EQUALS("[test.c:4]: (error) Memory leak: q\n", errout.str());
+        ASSERT_EQUALS("[test.c:4:1]: (error) Memory leak: q [memleak]\n", errout_str());
     }
 
     void realloc3() {
@@ -452,7 +740,41 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p = malloc(10);\n"
               "    char *q = (char*) realloc(p, 20);\n"
               "}");
-        ASSERT_EQUALS("[test.c:4]: (error) Memory leak: q\n", errout.str());
+        ASSERT_EQUALS("[test.c:4:1]: (error) Memory leak: q [memleak]\n", errout_str());
+    }
+
+    void realloc4() {
+        check("void f(void *p) {\n"
+              "    void * q = realloc(p, 10);\n"
+              "    if (q == NULL)\n"
+              "        return;\n"
+              "}");
+        ASSERT_EQUALS("[test.c:5:1]: (error) Memory leak: q [memleak]\n", errout_str());
+    }
+
+    void realloc5() {
+        // #9292
+        check("void * f(void * ptr, size_t size) {\n"
+              "    void *datap = realloc(ptr, size);\n"
+              "    if (size && !datap)\n"
+              "        free(ptr);\n"
+              "    return datap;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9990
+        check("void f() {\n"
+              "    void * p1 = malloc(10);\n"
+              "    if (!p1)\n"
+              "        return;\n"
+              "    void * p2 = realloc(p1, 42);\n"
+              "    if (!p2) {\n"
+              "        free(p1);\n"
+              "        return;\n"
+              "    }\n"
+              "    free(p2);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void freopen1() {
@@ -461,7 +783,7 @@ class TestLeakAutoVar : public TestFixture {
               "    void *q = freopen(name, b, p);\n"
               "    fclose(q)\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void freopen2() {
@@ -469,7 +791,7 @@ class TestLeakAutoVar : public TestFixture {
               "    void *p = fopen(name,a);\n"
               "    void *q = freopen(name, b, p);\n"
               "}");
-        ASSERT_EQUALS("[test.c:4]: (error) Resource leak: q\n", errout.str());
+        ASSERT_EQUALS("[test.c:4:1]: (error) Resource leak: q [resourceLeak]\n", errout_str());
     }
 
     void deallocuse1() {
@@ -477,27 +799,13 @@ class TestLeakAutoVar : public TestFixture {
               "    free(p);\n"
               "    *p = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.c:3]: (error) Dereferencing 'p' after it is deallocated / released\n", errout.str());
+        ASSERT_EQUALS("[test.c:3:6]: (error) Dereferencing 'p' after it is deallocated / released [deallocuse]\n", errout_str());
 
         check("void f(char *p) {\n"
               "    free(p);\n"
               "    char c = *p;\n"
               "}");
-        ASSERT_EQUALS("[test.c:3]: (error) Dereferencing 'p' after it is deallocated / released\n", errout.str());
-    }
-
-    void deallocuse2() {
-        check("void f(char *p) {\n"
-              "    free(p);\n"
-              "    strcpy(a, p);\n"
-              "}");
-        TODO_ASSERT_EQUALS("error (free,use)", "[test.c:3]: (information) --check-library: Function strcpy() should have <noreturn> configuration\n", errout.str());
-
-        check("void f(char *p) {\n"   // #3041 - assigning pointer when it's used
-              "    free(p);\n"
-              "    strcpy(a, p=b());\n"
-              "}");
-        TODO_ASSERT_EQUALS("", "[test.c:3]: (information) --check-library: Function strcpy() should have <noreturn> configuration\n", errout.str());
+        ASSERT_EQUALS("[test.c:3:15]: (error) Dereferencing 'p' after it is deallocated / released [deallocuse]\n", errout_str());
     }
 
     void deallocuse3() {
@@ -505,7 +813,7 @@ class TestLeakAutoVar : public TestFixture {
               "    free(p);\n"
               "    p = p->next;\n"
               "}");
-        ASSERT_EQUALS("[test.c:3]: (error) Dereferencing 'p' after it is deallocated / released\n", errout.str());
+        ASSERT_EQUALS("[test.c:3:9]: (error) Dereferencing 'p' after it is deallocated / released [deallocuse]\n", errout_str());
     }
 
     void deallocuse4() {
@@ -513,25 +821,25 @@ class TestLeakAutoVar : public TestFixture {
               "    free(p);\n"
               "    return p;\n"
               "}");
-        ASSERT_EQUALS("[test.c:2] -> [test.c:3]: (error) Returning/dereferencing 'p' after it is deallocated / released\n", errout.str());
+        ASSERT_EQUALS("[test.c:2:5] -> [test.c:3:5]: (error) Returning/dereferencing 'p' after it is deallocated / released [deallocret]\n", errout_str());
 
         check("void f(char *p) {\n"
               "  if (!p) free(p);\n"
               "  return p;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(char *p) {\n"
               "  if (!p) delete p;\n"
               "  return p;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(char *p) {\n"
               "  if (!p) delete [] p;\n"
               "  return p;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(void* p) {\n"
               "   if (a) {\n"
@@ -541,7 +849,7 @@ class TestLeakAutoVar : public TestFixture {
               "   g(p);\n"
               "   return;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void deallocuse5() {  // #4018
@@ -549,7 +857,7 @@ class TestLeakAutoVar : public TestFixture {
               "    free(p), p = 0;\n"
               "    *p = 0;\n"  // <- Make sure pointer info is reset. It is NOT a freed pointer dereference
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void deallocuse6() {  // #4034
@@ -557,23 +865,23 @@ class TestLeakAutoVar : public TestFixture {
               "    free(p);\n"
               "    x = p = foo();\n"  // <- p is not dereferenced
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void deallocuse7() {  // #6467, #6469, #6473, #6648
         check("struct Foo { int* ptr; };\n"
               "void f(Foo* foo) {\n"
               "    delete foo->ptr;\n"
-              "    foo->ptr = new Foo; \n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "    foo->ptr = new Foo;\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Foo { int* ptr; };\n"
               "void f(Foo* foo) {\n"
               "    delete foo->ptr;\n"
-              "    x = *foo->ptr; \n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:4]: (error) Dereferencing 'ptr' after it is deallocated / released\n", errout.str());
+              "    x = *foo->ptr;\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        TODO_ASSERT_EQUALS("[test.cpp:4:6]: (error) Dereferencing 'ptr' after it is deallocated / released [deallocuse]\n", "", errout_str());
 
         check("void parse() {\n"
               "    struct Buf {\n"
@@ -581,8 +889,8 @@ class TestLeakAutoVar : public TestFixture {
               "        ~Buf() { delete[]m_buf; }\n"
               "        uint8_t *m_buf;\n"
               "    };\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Foo {\n"
               "    Foo();\n"
@@ -593,15 +901,15 @@ class TestLeakAutoVar : public TestFixture {
               "    delete foo->ptr;\n"
               "    foo->ptr = new Foo;\n"
               "    foo->ptr->func();\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(void (*conv)(char**)) {\n"
               "  char * ptr=(char*)malloc(42);\n"
               "  free(ptr);\n"
               "  (*conv)(&ptr);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void deallocuse8() {  // #1765
@@ -609,8 +917,204 @@ class TestLeakAutoVar : public TestFixture {
               "    int *ptr = new int;\n"
               "    delete(ptr);\n"
               "    *ptr = 0;\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:4]: (error) Dereferencing 'ptr' after it is deallocated / released\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:4:6]: (error) Dereferencing 'ptr' after it is deallocated / released [deallocuse]\n", errout_str());
+    }
+
+    void deallocuse9() {
+        check("void f(Type* p) {\n" // #9781
+              "  std::shared_ptr<Type> sp(p);\n"
+              "  bool b = p->foo();\n"
+              "  return b;\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n" // #8635
+              "    std::vector<std::unique_ptr<A>> array_;\n"
+              "    A* foo() {\n"
+              "        A* a = new A();\n"
+              "        array_.push_back(std::unique_ptr<A>(a));\n"
+              "        return a;\n"
+              "    }\n"
+              "};\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("int g(int *p) {\n" // #9838
+              "    std::unique_ptr<int> temp(p);\n"
+              "    return DoSomething(p);\n"
+              "}\n"
+              "int f() {\n"
+              "    return g(new int(3));\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void deallocuse10() {
+        check("void f(char* p) {\n"
+              "    free(p);\n"
+              "    p[0] = 10;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.c:3:5]: (error) Dereferencing 'p' after it is deallocated / released [deallocuse]\n", errout_str());
+
+        check("int f(int* p) {\n"
+              "    free(p);\n"
+              "    return p[1];\n"
+              "}\n");
+        ASSERT_EQUALS("[test.c:2:5] -> [test.c:3:5]: (error) Returning/dereferencing 'p' after it is deallocated / released [deallocret]\n", errout_str());
+    }
+
+    void deallocuse11() { // #8302
+        check("int f() {\n"
+              "  int *array = new int[42];\n"
+              "  delete [] array;\n"
+              "  return array[1];" // <<
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:3:3] -> [test.cpp:4:3]: (error) Returning/dereferencing 'array' after it is deallocated / released [deallocret]\n", errout_str());
+
+        check("int f() {\n"
+              "  int *array = (int*)malloc(40);\n"
+              "  free(array);\n"
+              "  return array[1];" // <<
+              "}");
+        ASSERT_EQUALS("[test.c:3:3] -> [test.c:4:3]: (error) Returning/dereferencing 'array' after it is deallocated / released [deallocret]\n", errout_str());
+    }
+
+    void deallocuse12() {
+        check("struct foo { int x; }\n"
+              "void f1(struct foo *f) {\n"
+              "  free(f);\n"
+              "}\n"
+              "void f2(struct foo *f, int *out) {\n"
+              "  *out = f->x;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void deallocuse13() {
+        check("void f() {\n" // #9695
+              "    auto* a = new int[2];\n"
+              "    delete[] a;\n"
+              "    a[1] = 0;\n"
+              "    auto* b = static_cast<int*>(malloc(8));\n"
+              "    free(b);\n"
+              "    b[1] = 0;\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Dereferencing 'a' after it is deallocated / released [deallocuse]\n"
+                      "[test.cpp:7:5]: (error) Dereferencing 'b' after it is deallocated / released [deallocuse]\n",
+                      errout_str());
+    }
+
+    void deallocuse14() {
+        check("struct S { void f(); };\n" // #10905
+              "void g() {\n"
+              "    S* s = new S;\n"
+              "    delete s;\n"
+              "    s->f();\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:5:5]: (error) Dereferencing 's' after it is deallocated / released [deallocuse]\n",
+                      errout_str());
+
+        check("void f() {\n"
+              "    int *p = (int*)malloc(4);\n"
+              "    free(p);\n"
+              "    if (*p == 5) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.c:4:10]: (error) Dereferencing 'p' after it is deallocated / released [deallocuse]\n",
+                      errout_str());
+
+        check("int g(int);\n"
+              "void f(int* p) {\n"
+              "    free(p);\n"
+              "    g(*p);\n"
+              "}\n"
+              "int h(int* p) {\n"
+              "    free(p);\n"
+              "    return g(*p);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.c:4:8]: (error) Dereferencing 'p' after it is deallocated / released [deallocuse]\n"
+                      "[test.c:7:5] -> [test.c:8:5]: (error) Returning/dereferencing 'p' after it is deallocated / released [deallocret]\n",
+                      errout_str());
+
+        check("int g(int);\n"
+              "void f(int* p) {\n"
+              "    free(p);\n"
+              "    g(1 + *p);\n"
+              "}\n"
+              "int h(int* p) {\n"
+              "    free(p);\n"
+              "    return g(1 + *p);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.c:4:12]: (error) Dereferencing 'p' after it is deallocated / released [deallocuse]\n"
+                      "[test.c:7:5] -> [test.c:8:5]: (error) Returning/dereferencing 'p' after it is deallocated / released [deallocret]\n",
+                      errout_str());
+
+        check("int g(int, int);\n"
+              "void f(int* p) {\n"
+              "    free(p);\n"
+              "    g(0, 1 + *p);\n"
+              "}\n"
+              "int h(int* p) {\n"
+              "    free(p);\n"
+              "    return g(0, 1 + *p);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.c:4:15]: (error) Dereferencing 'p' after it is deallocated / released [deallocuse]\n"
+                      "[test.c:7:5] -> [test.c:8:5]: (error) Returning/dereferencing 'p' after it is deallocated / released [deallocret]\n",
+                      errout_str());
+
+        check("void f() {\n"
+              "    FOREACH(callables, ());\n"
+              "}\n");
+        ASSERT_EQUALS("[test.c:2:27]: (information) --check-library: Function FOREACH() should have <noreturn> configuration [checkLibraryNoReturn]\n", errout_str()); // don't crash
+
+        check("int f() {\n" // #12321
+              "    std::invoke([](int i) {\n"
+              "        int* p = (int*)malloc(4);\n"
+              "        *p = 0;\n"
+              "        if (i) {\n"
+              "            free(p);\n"
+              "            return;\n"
+              "        }\n"
+              "        free(p);\n"
+              "    }, 1);\n"
+              "    return 0;\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void deallocuse15() {
+        check("bool FileExists(const char* filename) {\n" // #12490
+              "    FILE* f = fopen(filename, \"rb\");\n"
+              "    if (f) fclose(f);\n"
+              "    return f;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool f() {\n" // #12590
+              "    FILE* fd = fopen(\"/foo/bar\", \"w\");\n"
+              "    if (fd == nullptr)\n"
+              "        return false;\n"
+              "    return fclose(fd) == 0;\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(const char* fileName) {\n" // #13136
+              "    FILE* h = fopen(fileName, \"rb\");\n"
+              "    if (fseek(h, 0L, SEEK_END) == -1)\n"
+              "        fclose(h);\n"
+              "    int i = ftell(h);\n"
+              "    return i;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.c:5:19]: (error) Dereferencing 'h' after it is deallocated / released [deallocuse]\n", errout_str());
+    }
+
+    void deallocuse16() {
+        check("void f() {\n"
+              "    int *a = nullptr;\n"
+              "    int *c = new int;\n"
+              "    delete (a, c);\n"
+              "    *c = 10;\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:5:6]: (error) Dereferencing 'c' after it is deallocated / released [deallocuse]\n", errout_str());
     }
 
     void doublefree1() {  // #3895
@@ -621,35 +1125,35 @@ class TestLeakAutoVar : public TestFixture {
               "        p = 0;\n"
               "    free(p);\n"
               "}");
-        ASSERT_EQUALS("[test.c:3] -> [test.c:6]: (error) Memory pointed to by 'p' is freed twice.\n", errout.str());
+        ASSERT_EQUALS("[test.c:3:9] -> [test.c:6:5]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
 
         check(
             "void foo(char *p) {\n"
             "  free(p);\n"
             "  free(p);\n"
             "}");
-        ASSERT_EQUALS("[test.c:2] -> [test.c:3]: (error) Memory pointed to by 'p' is freed twice.\n", errout.str());
+        ASSERT_EQUALS("[test.c:2:3] -> [test.c:3:3]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
 
         check(
             "void foo(char *p, char *r) {\n"
             "  free(p);\n"
             "  free(r);\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo() {\n"
             "  free(p);\n"
             "  free(r);\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo(char *p) {\n"
             "  if (x < 3) free(p);\n"
             "  else { if (x > 9) free(p); }\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo(char *p) {\n"
@@ -657,7 +1161,7 @@ class TestLeakAutoVar : public TestFixture {
             "  getNext(&p);\n"
             "  free(p);\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo(char *p) {\n"
@@ -665,7 +1169,7 @@ class TestLeakAutoVar : public TestFixture {
             "  bar();\n"
             "  free(p);\n"
             "}");
-        ASSERT_EQUALS("[test.c:2] -> [test.c:4]: (error) Memory pointed to by 'p' is freed twice.\n", errout.str());
+        ASSERT_EQUALS("[test.c:2:3] -> [test.c:4:3]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
 
         check(
             "void foo(char *p) {\n"
@@ -673,28 +1177,30 @@ class TestLeakAutoVar : public TestFixture {
             "  printf(\"Freed memory at location %x\", p);\n"
             "  free(p);\n"
             "}");
-        ASSERT_EQUALS("[test.c:2] -> [test.c:4]: (error) Memory pointed to by 'p' is freed twice.\n", errout.str());
+        ASSERT_EQUALS("[test.c:3:41]: (error) Dereferencing 'p' after it is deallocated / released [deallocuse]\n"
+                      "[test.c:2:3] -> [test.c:4:3]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n",
+                      errout_str());
 
         check(
             "void foo(FILE *p) {\n"
             "  fclose(p);\n"
             "  fclose(p);\n"
             "}");
-        ASSERT_EQUALS("[test.c:2] -> [test.c:3]: (error) Resource handle 'p' freed twice.\n", errout.str());
+        ASSERT_EQUALS("[test.c:2:3] -> [test.c:3:3]: (error) Resource handle 'p' freed twice. [doubleFree]\n", errout_str());
 
         check(
             "void foo(FILE *p, FILE *r) {\n"
             "  fclose(p);\n"
             "  fclose(r);\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo(FILE *p) {\n"
             "  if (x < 3) fclose(p);\n"
             "  else { if (x > 9) fclose(p); }\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo(FILE *p) {\n"
@@ -702,7 +1208,7 @@ class TestLeakAutoVar : public TestFixture {
             "  gethandle(&p);\n"
             "  fclose(p);\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo(FILE *p) {\n"
@@ -710,14 +1216,14 @@ class TestLeakAutoVar : public TestFixture {
             "  gethandle();\n"
             "  fclose(p);\n"
             "}");
-        ASSERT_EQUALS("[test.c:2] -> [test.c:4]: (error) Resource handle 'p' freed twice.\n", errout.str());
+        ASSERT_EQUALS("[test.c:2:3] -> [test.c:4:3]: (error) Resource handle 'p' freed twice. [doubleFree]\n", errout_str());
 
         check(
             "void foo(Data* p) {\n"
             "  free(p->a);\n"
             "  free(p->b);\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void f() {\n"
@@ -728,7 +1234,7 @@ class TestLeakAutoVar : public TestFixture {
             "    }\n"
             "    free(p);\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void f() {\n"
@@ -739,7 +1245,7 @@ class TestLeakAutoVar : public TestFixture {
             "    }\n"
             "    free(p);\n"
             "}");
-        ASSERT_EQUALS("[test.c:4] -> [test.c:7]: (error) Memory pointed to by 'p' is freed twice.\n", errout.str());
+        ASSERT_EQUALS("[test.c:4:9] -> [test.c:7:5]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
 
         check(
             "void f() {\n"
@@ -748,81 +1254,81 @@ class TestLeakAutoVar : public TestFixture {
             "    p = do_something();\n"
             "    free(p);\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo(char *p) {\n"
             "  delete p;\n"
             "  delete p;\n"
-            "}", true);
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (error) Memory pointed to by 'p' is freed twice.\n", errout.str());
+            "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:2:10] -> [test.cpp:3:10]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
 
         check(
             "void foo(char *p, char *r) {\n"
             "  delete p;\n"
             "  delete r;\n"
-            "}", true);
-        ASSERT_EQUALS("", errout.str());
+            "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo(P p) {\n"
             "  delete p.x;\n"
             "  delete p;\n"
-            "}", true);
-        ASSERT_EQUALS("", errout.str());
+            "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo(char **p) {\n"
             "  delete p[0];\n"
             "  delete p[1];\n"
-            "}", true);
-        ASSERT_EQUALS("", errout.str());
+            "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo(char *p) {\n"
             "  delete p;\n"
             "  getNext(&p);\n"
             "  delete p;\n"
-            "}", true);
-        ASSERT_EQUALS("", errout.str());
+            "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo(char *p) {\n"
             "  delete p;\n"
             "  bar();\n"
             "  delete p;\n"
-            "}", true);
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (error) Memory pointed to by 'p' is freed twice.\n", errout.str());
+            "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:2:10] -> [test.cpp:4:10]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
 
         check(
             "void foo(char *p) {\n"
             "  delete[] p;\n"
             "  delete[] p;\n"
-            "}", true);
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (error) Memory pointed to by 'p' is freed twice.\n", errout.str());
+            "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:2:12] -> [test.cpp:3:12]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
 
         check(
             "void foo(char *p, char *r) {\n"
             "  delete[] p;\n"
             "  delete[] r;\n"
-            "}", true);
-        ASSERT_EQUALS("", errout.str());
+            "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo(char *p) {\n"
             "  delete[] p;\n"
             "  getNext(&p);\n"
             "  delete[] p;\n"
-            "}", true);
-        ASSERT_EQUALS("", errout.str());
+            "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo(char *p) {\n"
             "  delete[] p;\n"
             "  bar();\n"
             "  delete[] p;\n"
-            "}", true);
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (error) Memory pointed to by 'p' is freed twice.\n", errout.str());
+            "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:2:12] -> [test.cpp:4:12]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
 
         check(
             "LineMarker::~LineMarker() {\n"
@@ -832,8 +1338,8 @@ class TestLeakAutoVar : public TestFixture {
             "  delete pxpm;\n"
             "  pxpm = NULL;\n"
             "  return *this;\n"
-            "}", true);
-        ASSERT_EQUALS("", errout.str());
+            "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo()\n"
@@ -849,8 +1355,8 @@ class TestLeakAutoVar : public TestFixture {
             "      throw;\n"
             "    }\n"
             "  delete ptr;\n"
-            "}", true);
-        ASSERT_EQUALS("", errout.str());
+            "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "int foo()\n"
@@ -865,8 +1371,8 @@ class TestLeakAutoVar : public TestFixture {
             "   if(doDelete)\n"
             "       delete a;\n"
             "   return 0;\n"
-            "}", true);
-        TODO_ASSERT_EQUALS("", "[test.cpp:8] -> [test.cpp:11]: (error) Memory pointed to by 'a' is freed twice.\n", errout.str());
+            "}", dinit(CheckOptions, $.cpp = true));
+        TODO_ASSERT_EQUALS("", "[test.cpp:8:8] -> [test.cpp:11:15]: (error) Memory pointed to by 'a' is freed twice. [doubleFree]\n", errout_str());
 
         check(
             "void foo(int y)\n"
@@ -879,8 +1385,8 @@ class TestLeakAutoVar : public TestFixture {
             "        delete[] x;\n"
             "    }\n"
             "    delete[] x;\n"
-            "}", true);
-        ASSERT_EQUALS("", errout.str());
+            "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo(int y)\n"
@@ -891,8 +1397,8 @@ class TestLeakAutoVar : public TestFixture {
             "        delete[] x;\n"
             "    }\n"
             "    delete[] x;\n"
-            "}", true);
-        TODO_ASSERT_EQUALS("[test.cpp:8]: (error) Memory pointed to by 'x' is freed twice.\n", "", errout.str());
+            "}", dinit(CheckOptions, $.cpp = true));
+        TODO_ASSERT_EQUALS("[test.cpp:8]: (error) Memory pointed to by 'x' is freed twice.\n", "", errout_str());
 
         check(
             "void foo(int y)\n"
@@ -903,8 +1409,8 @@ class TestLeakAutoVar : public TestFixture {
             "        delete[] x;\n"
             "    }\n"
             "    delete[] x;\n"
-            "}", true);
-        TODO_ASSERT_EQUALS("[test.cpp:8]: (error) Memory pointed to by 'x' is freed twice.\n", "", errout.str());
+            "}", dinit(CheckOptions, $.cpp = true));
+        TODO_ASSERT_EQUALS("[test.cpp:8]: (error) Memory pointed to by 'x' is freed twice.\n", "", errout_str());
 
         check(
             "void foo(int y)\n"
@@ -916,7 +1422,7 @@ class TestLeakAutoVar : public TestFixture {
             "    }\n"
             "    free(x);\n"
             "}");
-        TODO_ASSERT_EQUALS("[test.c:8]: (error) Memory pointed to by 'x' is freed twice.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.c:8]: (error) Memory pointed to by 'x' is freed twice.\n", "", errout_str());
 
         check(
             "void foo(int y)\n"
@@ -929,8 +1435,8 @@ class TestLeakAutoVar : public TestFixture {
             "        delete[] x;\n"
             "    }\n"
             "    delete[] x;\n"
-            "}", true);
-        ASSERT_EQUALS("", errout.str());
+            "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void foo(int y)\n"
@@ -943,8 +1449,8 @@ class TestLeakAutoVar : public TestFixture {
             "        delete[] x;\n"
             "    } while (true);\n"
             "    delete[] x;\n"
-            "}", true);
-        ASSERT_EQUALS("", errout.str());
+            "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void f()\n"
@@ -956,7 +1462,7 @@ class TestLeakAutoVar : public TestFixture {
             "    }\n"
             "    free(p);\n"
             "}");
-        ASSERT_EQUALS("[test.c:6] -> [test.c:8]: (error) Memory pointed to by 'p' is freed twice.\n", errout.str());
+        ASSERT_EQUALS("[test.c:6:9] -> [test.c:8:5]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
 
         check(
             "void MyFunction()\n"
@@ -976,8 +1482,8 @@ class TestLeakAutoVar : public TestFixture {
             "void MyThrow(err)\n"
             "{\n"
             "    throw(err);\n"
-            "}", true);
-        ASSERT_EQUALS("", errout.str());
+            "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "void MyFunction()\n"
@@ -997,8 +1503,8 @@ class TestLeakAutoVar : public TestFixture {
             "void MyExit(err)\n"
             "{\n"
             "    exit(err);\n"
-            "}", true);
-        ASSERT_EQUALS("", errout.str());
+            "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check( // #6252
             "struct Wrapper {\n"
@@ -1012,15 +1518,15 @@ class TestLeakAutoVar : public TestFixture {
             "        delete m_thing;\n"
             "        m_thing = new Thing;\n"
             "    }\n"
-            "};", true);
-        ASSERT_EQUALS("", errout.str());
+            "};", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         // #7401
         check("void pCodeLabelDestruct(pCode *pc) {\n"
               "    free(PCL(pc)->label);\n"
               "    free(pc);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void doublefree2() {  // #3891
@@ -1030,7 +1536,7 @@ class TestLeakAutoVar : public TestFixture {
               "    free(p);\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void doublefree3() {  // #4914
@@ -1047,19 +1553,30 @@ class TestLeakAutoVar : public TestFixture {
               "   } while(!done);\n"
               "   return;"
               "}"
-             );
-        ASSERT_EQUALS("", errout.str());
+              );
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void doublefree4() {  // #5451 - exit
-        check("void f(char *p) {\n"
+    void doublefree4() {
+        check("void f(char *p) {\n" // #5451 - exit
               "  if (x) {\n"
               "    free(p);\n"
               "    exit(1);\n"
               "  }\n"
               "  free(p);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(void* p, int i) {\n" // #11391
+              "    if (i)\n"
+              "        goto cleanup;\n"
+              "    free(p);\n"
+              "    exit(0);\n"
+              "cleanup:\n"
+              "    free(p);\n"
+              "    exit(1);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void doublefree5() {  // #5522
@@ -1068,15 +1585,15 @@ class TestLeakAutoVar : public TestFixture {
               "  x = (q == p);\n"
               "  free(p);\n"
               "}");
-        ASSERT_EQUALS("[test.c:2] -> [test.c:4]: (error) Memory pointed to by 'p' is freed twice.\n", errout.str());
+        ASSERT_EQUALS("[test.c:2:3] -> [test.c:4:3]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
     }
 
     void doublefree6() { // #7685
         check("void do_wordexp(FILE *f) {\n"
               "  free(getword(f));\n"
               "  fclose(f);\n"
-              "}", /*cpp=*/false);
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void doublefree7() {
@@ -1085,14 +1602,14 @@ class TestLeakAutoVar : public TestFixture {
               "    if (x && (p = malloc(10)))\n"
               "        free(p);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(char *p, int x) {\n"
               "    delete[] p;\n"
               "    if (x && (p = new char[10]))\n"
               "        delete[] p;\n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void doublefree8() {
@@ -1100,51 +1617,59 @@ class TestLeakAutoVar : public TestFixture {
               "    int * i = new int;\n"
               "    std::unique_ptr<int> x(i);\n"
               "    delete i;\n"
-              "}\n", true);
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (error) Memory pointed to by 'i' is freed twice.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:4:12]: (error) Memory pointed to by 'i' is freed twice. [doubleFree]\n", errout_str());
 
         check("void f() {\n"
               "    int * i = new int;\n"
               "    delete i;\n"
               "    std::unique_ptr<int> x(i);\n"
-              "}\n", true);
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (error) Memory pointed to by 'i' is freed twice.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:3:5] -> [test.cpp:4:28]: (error) Memory pointed to by 'i' is freed twice. [doubleFree]\n", errout_str());
 
         check("void f() {\n"
               "    int * i = new int;\n"
               "    std::unique_ptr<int> x{i};\n"
               "    delete i;\n"
-              "}\n", true);
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (error) Memory pointed to by 'i' is freed twice.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:4:12]: (error) Memory pointed to by 'i' is freed twice. [doubleFree]\n", errout_str());
 
         check("void f() {\n"
               "    int * i = new int;\n"
               "    std::shared_ptr<int> x(i);\n"
               "    delete i;\n"
-              "}\n", true);
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (error) Memory pointed to by 'i' is freed twice.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:4:12]: (error) Memory pointed to by 'i' is freed twice. [doubleFree]\n", errout_str());
 
         check("void f() {\n"
               "    int * i = new int;\n"
               "    std::shared_ptr<int> x{i};\n"
               "    delete i;\n"
-              "}\n", true);
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (error) Memory pointed to by 'i' is freed twice.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:4:12]: (error) Memory pointed to by 'i' is freed twice. [doubleFree]\n", errout_str());
 
         // Check for use-after-free FP
         check("void f() {\n"
               "    int * i = new int;\n"
               "    std::shared_ptr<int> x{i};\n"
               "    *i = 123;\n"
-              "}\n", true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int * i = new int[1];\n"
               "    std::unique_ptr<int[]> x(i);\n"
               "    delete i;\n"
-              "}\n", true);
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (error) Memory pointed to by 'i' is freed twice.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:4:12]: (error) Memory pointed to by 'i' is freed twice. [doubleFree]\n", errout_str());
+
+        check("using namespace std;\n" // #9708
+              "void f() {\n"
+              "    int* i = new int;\n"
+              "    unique_ptr<int> x(i);\n"
+              "    delete i;\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:4:5] -> [test.cpp:5:12]: (error) Memory pointed to by 'i' is freed twice. [doubleFree]\n", errout_str());
     }
 
     void doublefree9() {
@@ -1154,8 +1679,8 @@ class TestLeakAutoVar : public TestFixture {
               "void f(foo* b) {\n"
               "    std::unique_ptr<int> x(b->get(0));\n"
               "    std::unique_ptr<int> y(b->get(1));\n"
-              "}\n", true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void doublefree10() {
@@ -1168,8 +1693,8 @@ class TestLeakAutoVar : public TestFixture {
               "    }\n"
               "    if (p != NULL)\n"
               "        free(p);\n"
-              "}\n", true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(char* s) {\n"
               "    char *p = malloc(strlen(s));\n"
@@ -1180,8 +1705,130 @@ class TestLeakAutoVar : public TestFixture {
               "    }\n"
               "    if (p != NULL)\n"
               "        free(p);\n"
-              "}\n", true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void doublefree11() {
+        check("void f() {\n"
+              "    void * p = malloc(5);\n"
+              "    void * q = realloc(p, 10);\n"
+              "    if (q == NULL) {\n"
+              "        free(p);\n"
+              "        return;\n"
+              "    }\n"
+              "    free(p);\n"
+              "    if (q == NULL)\n"
+              "        return;\n"
+              "    free(q);\n"
+              "}");
+        ASSERT_EQUALS("[test.c:3:16] -> [test.c:8:5]: (error) Memory pointed to by 'p' is freed twice. [doubleFree]\n", errout_str());
+    }
+
+    void doublefree12() { // #10502
+        check("int f(FILE *fp, const bool b) {\n"
+              "    if (b)\n"
+              "        return fclose(fp);\n"
+              "    fclose(fp);\n"
+              "    return 0;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void doublefree13() { // #11008
+        check("struct buf_t { void* ptr; };\n"
+              "void f() {\n"
+              "    struct buf_t buf;\n"
+              "    if ((buf.ptr = malloc(10)) == NULL)\n"
+              "        return;\n"
+              "    free(buf.ptr);\n"
+              "    if ((buf.ptr = malloc(10)) == NULL)\n"
+              "        return;\n"
+              "    free(buf.ptr);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void doublefree14() { // #9708
+        check("using namespace std;\n"
+              " \n"
+              "int main()\n"
+              "{\n"
+              "    int *i = new int;\n"
+              "    unique_ptr<int> x(i);\n"
+              "    delete i;\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:6:5] -> [test.cpp:7:12]: (error) Memory pointed to by 'i' is freed twice. [doubleFree]\n", errout_str());
+
+        check("using namespace std;\n"
+              " \n"
+              "int main()\n"
+              "{\n"
+              "    int *i = new int;\n"
+              "    unique_ptr<int> x(i);\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void doublefree15() { // #11966
+        check("void f(FILE* fp) {\n"
+              "    static_cast<void>(fclose(fp));\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void doublefree16() { // #12236
+        check("void f() {\n"
+              "    FILE* f = fopen(\"abc\", \"r\");\n"
+              "    decltype(fclose(f)) y;\n"
+              "    y = fclose(f);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    FILE *fp = fopen(\"abc\", \"r\");\n"
+              "    if (({\n"
+              "        __typeof__(fclose(fp)) r;\n"
+              "        r = (fclose(fp));\n"
+              "        r;\n"
+              "    })) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void doublefree17() {
+        check("void f() {\n"
+              "    int *a = nullptr;\n"
+              "    int *b = nullptr;\n"
+              "    int *c = new int;\n"
+              "    delete (a, c);\n"
+              "    delete (b, c);\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:5:5] -> [test.cpp:6:16]: (error) Memory pointed to by 'c' is freed twice. [doubleFree]\n", errout_str());
+    }
+
+    void doublefree18() {
+        check("typedef struct {\n" // #13918
+              "    FILE * fp;\n"
+              "} S;\n"
+              "void f(S* s, FILE* x) {\n"
+              "    if (fclose(s->fp)) {}\n"
+              "    s->fp = x;\n"
+              "    if (fclose(s->fp)) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void doublefree19() {
+        check("struct S {\n"
+              "  void *x;\n"
+              "};\n"
+              "void f(struct S *p)\n"
+              "{\n"
+              "  free(p->x);\n"
+              "  free(p->x);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.c:6:3] -> [test.c:7:3]: (error) Memory pointed to by 'x' is freed twice. [doubleFree]\n", errout_str());
     }
 
     void exit1() {
@@ -1189,7 +1836,7 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p = malloc(10);\n"
               "    exit(0);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void exit2() {
@@ -1197,9 +1844,8 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p = malloc(10);\n"
               "    fatal_error();\n"
               "}");
-        ASSERT_EQUALS("[test.c:3]: (information) --check-library: Function fatal_error() should have <noreturn> configuration\n"
-                      "[test.c:4]: (information) --check-library: Function fatal_error() should have <use>/<leak-ignore> configuration\n",
-                      errout.str());
+        ASSERT_EQUALS("[test.c:3:18]: (information) --check-library: Function fatal_error() should have <noreturn> configuration [checkLibraryNoReturn]\n",
+                      errout_str());
     }
 
     void exit3() {
@@ -1210,8 +1856,8 @@ class TestLeakAutoVar : public TestFixture {
               "    ::exit(0);\n"
               "  }"
               "  free(p);\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  char *p = malloc(100);\n"
@@ -1220,8 +1866,21 @@ class TestLeakAutoVar : public TestFixture {
               "    std::exit(0);\n"
               "  }"
               "  free(p);\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void exit4() {
+        check("void __attribute__((__noreturn__)) (*func_notret)(void);\n"
+              "int main(int argc) {\n"
+              "    void* ptr = malloc(1000);\n"
+              "    if (argc == 1) {\n"
+              "        free(ptr);\n"
+              "        func_notret();\n"
+              "    }\n"
+              "    free(ptr);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void functioncall1() {
@@ -1230,7 +1889,29 @@ class TestLeakAutoVar : public TestFixture {
               "  free(p->x);\n"
               "  p->x = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(s_t s) {\n" // #11061
+              "    s->p = (char*)malloc(10);\n"
+              "    free((void*)s->p);\n"
+              "    s->p = NULL;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {};\n"
+              "void f(int i, std::vector<std::unique_ptr<S>> &v) {\n"
+              "    if (i < 1) {\n"
+              "        auto s = new S;\n"
+              "        v.push_back(std::unique_ptr<S>(s));\n"
+              "    }\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str()); // don't crash
+
+        check("void g(size_t len) {\n" // #12365
+              "    char* b = new char[len + 1]{};\n"
+              "    std::string str = std::string(b);\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:4:1]: (error) Memory leak: b [memleak]\n", errout_str());
     }
 
     void goto1() {
@@ -1241,7 +1922,7 @@ class TestLeakAutoVar : public TestFixture {
               "        free(reg);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void goto2() { // #4231
@@ -1254,7 +1935,22 @@ class TestLeakAutoVar : public TestFixture {
               "    }\n"
               "    return p;\n"  // no error since there is a goto
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void goto3() { // #11431
+        check("void f() {\n"
+              "    int* p = (int*)malloc(2);\n"
+              "    if (!p) {\n"
+              "        p = (int*)malloc(1);\n"
+              "        if (!p)\n"
+              "            goto err;\n"
+              "    }\n"
+              "    free(p);\n"
+              "err:\n"
+              "    (void)0;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void ifelse1() {
@@ -1264,7 +1960,7 @@ class TestLeakAutoVar : public TestFixture {
               "    else { return 0; }\n"
               "    free(p);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void ifelse2() {
@@ -1273,7 +1969,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (x) { p = malloc(10); }\n"
               "    else { return 0; }\n"
               "}");
-        ASSERT_EQUALS("[test.c:5]: (error) Memory leak: p\n", errout.str());
+        ASSERT_EQUALS("[test.c:5:1]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
     void ifelse3() {
@@ -1282,7 +1978,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (!p) { return; }\n"
               "    free(p);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("char * f(size_t size) {"
               "    void *p = malloc(1);"
@@ -1290,14 +1986,14 @@ class TestLeakAutoVar : public TestFixture {
               "        return NULL;"
               "    return p;"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char *p = malloc(10);\n"
               "    if (p) { } else { return; }\n"
               "    free(p);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #3866 - UNLIKELY
         check("void f() {\n"
@@ -1305,7 +2001,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (UNLIKELY(!p)) { return; }\n"
               "    free(p);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void ifelse4() {
@@ -1314,7 +2010,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (x) { p = malloc(10); }\n"
               "    if (x) { free(p); }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    char *p;\n"
@@ -1322,7 +2018,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (!x) { return; }\n"
               "    free(p);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void ifelse5() {
@@ -1331,7 +2027,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if (!p && x) { p = malloc(10); }\n"
               "    free(p);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void ifelse6() { // #3370
@@ -1342,7 +2038,7 @@ class TestLeakAutoVar : public TestFixture {
               "    else\n"
               "        a = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.c:6]: (error) Memory leak: a\n", errout.str());
+        ASSERT_EQUALS("[test.c:6:9]: (error) Memory leak: a [memleak]\n", errout_str());
     }
 
     void ifelse7() { // #5576
@@ -1352,16 +2048,25 @@ class TestLeakAutoVar : public TestFixture {
               "        return;\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void ifelse8() { // #5747
-        check("void f() {\n"
+        check("int f() {\n"
               "    int fd = socket(AF_INET, SOCK_PACKET, 0 );\n"
               "    if (fd == -1)\n"
-              "        return;\n"
+              "        return -1;\n"
+              "    return fd;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f() {\n"
+              "    int fd = socket(AF_INET, SOCK_PACKET, 0 );\n"
+              "    if (fd != -1)\n"
+              "        return fd;\n"
+              "    return -1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void ifelse9() { // #5273
@@ -1371,7 +2076,7 @@ class TestLeakAutoVar : public TestFixture {
               "        return;\n"
               "    free(p);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void ifelse10() { // #8794
@@ -1381,7 +2086,7 @@ class TestLeakAutoVar : public TestFixture {
               "        return;\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void ifelse11() { // #8365
@@ -1391,7 +2096,7 @@ class TestLeakAutoVar : public TestFixture {
               "        return;\n"
               "    free(p);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void ifelse12() { // #8340
@@ -1399,7 +2104,7 @@ class TestLeakAutoVar : public TestFixture {
               "    if ((*p = malloc(4)) == NULL)\n"
               "        return;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void ifelse13() { // #8392
@@ -1410,7 +2115,7 @@ class TestLeakAutoVar : public TestFixture {
               "    free(path);\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f(int fd, const char *mode) {\n"
               "    char *path;\n"
@@ -1419,7 +2124,7 @@ class TestLeakAutoVar : public TestFixture {
               "    free(path);\n"
               "    return 0;\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:4] memory leak", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4] memory leak", "", errout_str());
     }
 
     void ifelse14() { // #9130
@@ -1429,7 +2134,7 @@ class TestLeakAutoVar : public TestFixture {
               "        return NULL;\n"
               "    return buf;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void ifelse15() { // #9206
@@ -1438,15 +2143,251 @@ class TestLeakAutoVar : public TestFixture {
               "void test_alloc() {\n"
               "   if ( global_ptr = new SSS()) {}\n"
               "   return;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("FILE* hFile;\n"
               "int openFile( void ) {\n"
               "   if ((hFile = fopen(\"1.txt\", \"wb\" )) == NULL) return 0;\n"
               "   return 1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void ifelse16() { // #9635
+        check("void f(void) {\n"
+              "    char *p;\n"
+              "    if(p = malloc(4), p == NULL)\n"
+              "        return;\n"
+              "    free(p);\n"
+              "    return;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(void) {\n"
+              "    char *p, q;\n"
+              "    if(p = malloc(4), q = 1, p == NULL)\n"
+              "        return;\n"
+              "    free(p);\n"
+              "    return;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void ifelse17() {
+        check("int *f() {\n"
+              "    int *p = realloc(nullptr, 10);\n"
+              "    if (!p)\n"
+              "        return NULL;\n"
+              "    return p;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int *f() {\n"
+              "    int *p = realloc(nullptr, 10);\n"
+              "    if (!!(!p))\n"
+              "        return NULL;\n"
+              "    return p;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void ifelse18() {
+        check("void f() {\n"
+              "    void * p = malloc(10);\n"
+              "    void * q = realloc(p, 20);\n"
+              "    if (q == 0)\n"
+              "        return;\n"
+              "    free(q);\n"
+              "}");
+        ASSERT_EQUALS("[test.c:5:9]: (error) Memory leak: p [memleak]\n", errout_str());
+
+        check("void f() {\n"
+              "    void * p = malloc(10);\n"
+              "    void * q = realloc(p, 20);\n"
+              "    if (q != 0) {\n"
+              "        free(q);\n"
+              "        return;\n"
+              "    } else\n"
+              "        return;\n"
+              "}");
+        ASSERT_EQUALS("[test.c:8:9]: (error) Memory leak: p [memleak]\n", errout_str());
+    }
+
+    void ifelse19() {
+        check("void f() {\n"
+              "    static char * a;\n"
+              "    char * b = realloc(a, 10);\n"
+              "    if (!b)\n"
+              "        return;\n"
+              "    a = b;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void ifelse20() {
+        check("void f() {\n"
+              "    if (x > 0)\n"
+              "        void * p1 = malloc(5);\n"
+              "    else\n"
+              "        void * p2 = malloc(2);\n"
+              "    return;\n"
+              "}");
+        ASSERT_EQUALS("[test.c:3:30]: (error) Memory leak: p1 [memleak]\n"
+                      "[test.c:5:30]: (error) Memory leak: p2 [memleak]\n", errout_str());
+
+        check("void f() {\n"
+              "    if (x > 0)\n"
+              "        void * p1 = malloc(5);\n"
+              "    else\n"
+              "        void * p2 = malloc(2);\n"
+              "}");
+        ASSERT_EQUALS("[test.c:3:30]: (error) Memory leak: p1 [memleak]\n"
+                      "[test.c:5:30]: (error) Memory leak: p2 [memleak]\n", errout_str());
+    }
+
+    void ifelse21() {
+        check("void f() {\n"
+              "    if (y) {\n"
+              "        void * p;\n"
+              "        if (x > 0)\n"
+              "            p = malloc(5);\n"
+              "    }\n"
+              "    return;\n"
+              "}");
+        ASSERT_EQUALS("[test.c:6:5]: (error) Memory leak: p [memleak]\n",  errout_str());
+    }
+
+    void ifelse22() { // #10187
+        check("int f(const char * pathname, int flags) {\n"
+              "    int fd = socket(pathname, flags);\n"
+              "    if (fd >= 0)\n"
+              "        return fd;\n"
+              "    return -1;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(const char * pathname, int flags) {\n"
+              "    int fd = socket(pathname, flags);\n"
+              "    if (fd <= -1)\n"
+              "        return -1;\n"
+              "    return fd;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void ifelse23() { // #5473
+        check("void f() {\n"
+              "    if (FILE* fp = fopen(\"x\", \"r\")) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.c:2:38]: (error) Resource leak: fp [resourceLeak]\n", errout_str());
+    }
+
+    void ifelse24() { // #1733
+        const Settings s = settingsBuilder().library("std.cfg").library("posix.cfg").checkLibrary().build();
+
+        check("void f() {\n"
+              "    char* temp = strdup(\"temp.txt\");\n"
+              "    FILE* fp;\n"
+              "    if (NULL == x || NULL == (fp = fopen(temp, \"rt\")))\n"
+              "        return;\n"
+              "}\n", s);
+        ASSERT_EQUALS("[test.cpp:5:9]: (error) Memory leak: temp [memleak]\n"
+                      "[test.cpp:6:1]: (error) Memory leak: temp [memleak]\n"
+                      "[test.cpp:6:1]: (error) Resource leak: fp [resourceLeak]\n",
+                      errout_str());
+
+        check("FILE* f() {\n"
+              "    char* temp = strdup(\"temp.txt\");\n"
+              "    FILE* fp = fopen(temp, \"rt\");\n"
+              "    return fp;\n"
+              "}\n", s);
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Memory leak: temp [memleak]\n", errout_str());
+
+        check("FILE* f() {\n"
+              "    char* temp = strdup(\"temp.txt\");\n"
+              "    FILE* fp = NULL;\n"
+              "    fopen_s(&fp, temp, \"rt\");\n"
+              "    return fp;\n"
+              "}\n", s);
+        ASSERT_EQUALS("[test.cpp:5:5]: (error) Memory leak: temp [memleak]\n", errout_str());
+
+        check("void f() {\n"
+              "    char* temp = strdup(\"temp.txt\");\n"
+              "    FILE* fp = fopen(\"a.txt\", \"rb\");\n"
+              "    if (fp)\n"
+              "        freopen(temp, \"rt\", fp);\n"
+              "}\n", s);
+        ASSERT_EQUALS("[test.cpp:6:1]: (error) Memory leak: temp [memleak]\n"
+                      "[test.cpp:6:1]: (error) Resource leak: fp [resourceLeak]\n",
+                      errout_str());
+
+        check("FILE* f() {\n"
+              "    char* temp = strdup(\"temp.txt\");\n"
+              "    return fopen(temp, \"rt\");\n"
+              "}\n", s);
+        TODO_ASSERT_EQUALS("[test.cpp:3]: (error) Memory leak: temp\n", "", errout_str());
+    }
+
+    void ifelse25() { // #9966
+        check("void f() {\n"
+              "    void *p, *p2;\n"
+              "    if((p2 = p = malloc(10)) == NULL)\n"
+              "        return;\n"
+              "    (void)p;\n"
+              "    free(p2);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void ifelse26() { // don't crash
+        check("union tidi {\n"
+              "    long long ti;\n"
+              "    unsigned int di[2];\n"
+              "};\n"
+              "void f(long long val) {\n"
+              "    if (val == ({ union tidi d = {.di = {0x0, 0x80000000}}; d.ti; })) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void ifelse27() {
+        check("struct key { void* p; };\n"
+              "int f(struct key** handle) {\n"
+              "    struct key* key;\n"
+              "    if (!(key = calloc(1, sizeof(*key))))\n"
+              "        return 0;\n"
+              "    if (!(key->p = malloc(4))) {\n"
+              "        free(key);\n"
+              "        return 0;\n"
+              "    }\n"
+              "    *handle = key;\n"
+              "    return 1;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void ifelse28() { // #11038
+        check("char * f(void) {\n"
+              "   char *buf = (char*)malloc(42*sizeof(char));\n"
+              "   char *temp;\n"
+              "   if ((temp = (char*)realloc(buf, 16)) != NULL)\n"
+              "   {  buf = temp;  }\n"
+              "   return buf;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void ifelse29() { // #13296
+        check("struct S {\n"
+              "    typedef int (S::* func_t)(int) const;\n"
+              "    void f(func_t pfn);\n"
+              "    int g(int) const;\n"
+              "};\n"
+              "void S::f(func_t pfn) {\n"
+              "    if (pfn == (func_t)&S::g) {}\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str()); // don't crash
     }
 
     void switch1() {
@@ -1458,7 +2399,7 @@ class TestLeakAutoVar : public TestFixture {
               "    }\n"
               "    free(p);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void loop1() {
@@ -1469,7 +2410,34 @@ class TestLeakAutoVar : public TestFixture {
               "    if (x) { free(p) }\n"
               "    else { a = p; }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void loop2() {
+        check("void f() {\n" // #11786
+              "    int* p = (int*)malloc(sizeof(int));\n"
+              "    if (1) {\n"
+              "        while (0) {}\n"
+              "        free(p);\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(node **p) {\n"
+              "    node* n = *p;\n"
+              "    if (n->left == NULL) {\n"
+              "        *p = n->right;\n"
+              "        free(n);\n"
+              "    }\n"
+              "    else if (n->right == NULL) {\n"
+              "        *p = n->left;\n"
+              "        free(n);\n"
+              "    }\n"
+              "    else {\n"
+              "        for (int i = 0; i < 4; ++i) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void mismatchAllocDealloc() {
@@ -1477,13 +2445,13 @@ class TestLeakAutoVar : public TestFixture {
               "    FILE*f=fopen(fname,a);\n"
               "    free(f);\n"
               "}");
-        ASSERT_EQUALS("[test.c:2] -> [test.c:3]: (error) Mismatching allocation and deallocation: f\n", errout.str());
+        ASSERT_EQUALS("[test.c:2:12] -> [test.c:3:5]: (error) Mismatching allocation and deallocation: f [mismatchAllocDealloc]\n", errout_str());
 
         check("void f() {\n"
               "    FILE*f=fopen(fname,a);\n"
               "    free((void*)f);\n"
               "}");
-        ASSERT_EQUALS("[test.c:2] -> [test.c:3]: (error) Mismatching allocation and deallocation: f\n", errout.str());
+        ASSERT_EQUALS("[test.c:2:12] -> [test.c:3:5]: (error) Mismatching allocation and deallocation: f [mismatchAllocDealloc]\n", errout_str());
 
         check("void f() {\n"
               "    char *cPtr = new char[100];\n"
@@ -1492,135 +2460,164 @@ class TestLeakAutoVar : public TestFixture {
               "    delete[] cPtr;\n"
               "    cPtr = new char[100];\n"
               "    delete cPtr;\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:7]: (error) Mismatching allocation and deallocation: cPtr\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:6:12] -> [test.cpp:7:12]: (error) Mismatching allocation and deallocation: cPtr [mismatchAllocDealloc]\n", errout_str());
 
         check("void f() {\n"
               "    char *cPtr = new char[100];\n"
               "    free(cPtr);\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (error) Mismatching allocation and deallocation: cPtr\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:2:18] -> [test.cpp:3:5]: (error) Mismatching allocation and deallocation: cPtr [mismatchAllocDealloc]\n", errout_str());
 
         check("void f() {\n"
               "    char *cPtr = new (buf) char[100];\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int * i = new int[1];\n"
               "    std::unique_ptr<int> x(i);\n"
-              "}\n", true);
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (error) Mismatching allocation and deallocation: i\n", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:2:15] -> [test.cpp:3:28]: (error) Mismatching allocation and deallocation: i [mismatchAllocDealloc]\n", errout_str());
 
         check("void f() {\n"
               "    int * i = new int;\n"
               "    std::unique_ptr<int[]> x(i);\n"
-              "}\n", true);
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (error) Mismatching allocation and deallocation: i\n", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:2:15] -> [test.cpp:3:30]: (error) Mismatching allocation and deallocation: i [mismatchAllocDealloc]\n", errout_str());
 
         check("void f() {\n"
               "   void* a = malloc(1);\n"
               "   void* b = freopen(f, p, a);\n"
               "   free(b);\n"
               "}");
-        ASSERT_EQUALS("[test.c:2] -> [test.c:3]: (error) Mismatching allocation and deallocation: a\n"
-                      "[test.c:3] -> [test.c:4]: (error) Mismatching allocation and deallocation: b\n", errout.str());
+        ASSERT_EQUALS("[test.c:2:14] -> [test.c:3:14]: (error) Mismatching allocation and deallocation: a [mismatchAllocDealloc]\n"
+                      "[test.c:3:14] -> [test.c:4:4]: (error) Mismatching allocation and deallocation: b [mismatchAllocDealloc]\n", errout_str());
 
         check("void f() {\n"
               "   void* a;\n"
               "   void* b = realloc(a, 10);\n"
               "   free(b);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "   int * i = new int;\n"
               "   int * j = realloc(i, 2 * sizeof(int));\n"
               "   delete[] j;\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (error) Mismatching allocation and deallocation: i\n"
-                      "[test.cpp:3] -> [test.cpp:4]: (error) Mismatching allocation and deallocation: j\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:2:14] -> [test.cpp:3:14]: (error) Mismatching allocation and deallocation: i [mismatchAllocDealloc]\n"
+                      "[test.cpp:3:14] -> [test.cpp:4:13]: (error) Mismatching allocation and deallocation: j [mismatchAllocDealloc]\n", errout_str());
+
+        check("static void deleter(int* p) { free(p); }\n" // #11392
+              "void f() {\n"
+              "    if (int* p = static_cast<int*>(malloc(4))) {\n"
+              "        std::unique_ptr<int, decltype(&deleter)> guard(p, &deleter);\n"
+              "    }\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    if (int* p = static_cast<int*>(malloc(4))) {\n"
+              "        std::unique_ptr<int, decltype(&deleter)> guard(p, &deleter);\n"
+              "    }\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int i) {\n"
+              "    int* a = new int[i] {};\n"
+              "    delete[] a;\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void smartPointerDeleter() {
         check("void f() {\n"
               "    FILE*f=fopen(fname,a);\n"
               "    std::unique_ptr<FILE> fp{f};\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (error) Mismatching allocation and deallocation: f\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:2:12] -> [test.cpp:3:30]: (error) Mismatching allocation and deallocation: f [mismatchAllocDealloc]\n", errout_str());
 
         check("void f() {\n"
               "    FILE*f=fopen(fname,a);\n"
               "    std::unique_ptr<FILE, decltype(&fclose)> fp{f, &fclose};\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    FILE*f=fopen(fname,a);\n"
               "    std::shared_ptr<FILE> fp{f, &fclose};\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("struct deleter { void operator()(FILE* f) { fclose(f); }};\n"
               "void f() {\n"
               "    FILE*f=fopen(fname,a);\n"
               "    std::unique_ptr<FILE, deleter> fp{f};\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("int * create();\n"
               "void destroy(int * x);\n"
               "void f() {\n"
               "    int x * = create()\n"
               "    std::unique_ptr<int, decltype(&destroy)> xp{x, &destroy()};\n"
-              "}\n", true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("int * create();\n"
               "void destroy(int * x);\n"
               "void f() {\n"
               "    int x * = create()\n"
               "    std::unique_ptr<int, decltype(&destroy)> xp(x, &destroy());\n"
-              "}\n", true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    FILE*f=fopen(fname,a);\n"
               "    std::shared_ptr<FILE> fp{f, [](FILE* x) { fclose(x); }};\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    FILE*f=fopen(fname,a);\n"
               "    std::shared_ptr<FILE> fp{f, +[](FILE* x) { fclose(x); }};\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    FILE*f=fopen(fname,a);\n"
               "    std::shared_ptr<FILE> fp{f, [](FILE* x) { free(f); }};\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (error) Mismatching allocation and deallocation: f\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:2:12] -> [test.cpp:3:30]: (error) Mismatching allocation and deallocation: f [mismatchAllocDealloc]\n", errout_str());
 
         check("void f() {\n"
               "    FILE*f=fopen(fname,a);\n"
               "    std::shared_ptr<FILE> fp{f, [](FILE* x) {}};\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (error) Mismatching allocation and deallocation: f\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:2:12] -> [test.cpp:3:30]: (error) Mismatching allocation and deallocation: f [mismatchAllocDealloc]\n", errout_str());
 
         check("class C;\n"
               "void f() {\n"
               "  C* c = new C{};\n"
               "  std::shared_ptr<C> a{c, [](C*) {}};\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("class C;\n"
               "void f() {\n"
               "  C* c = new C{};\n"
               "  std::shared_ptr<C> a{c, [](C* x) { delete x; }};\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct DirDeleter {\n" // #12544
+              "    void operator()(DIR* d) { ::closedir(d); }\n"
+              "};\n"
+              "void openDir(DIR* dir) {\n"
+              "    std::shared_ptr<DIR> dp(dir, DirDeleter());\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:2:44]: (information) --check-library: Function closedir() should have <noreturn> configuration [checkLibraryNoReturn]\n", errout_str()); // don't crash
     }
     void smartPointerRelease() {
         check("void f() {\n"
@@ -1628,15 +2625,15 @@ class TestLeakAutoVar : public TestFixture {
               "    std::unique_ptr<int> x(i);\n"
               "    x.release();\n"
               "    delete i;\n"
-              "}\n", true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int * i = new int;\n"
               "    std::unique_ptr<int> x(i);\n"
               "    x.release();\n"
-              "}\n", true);
-        ASSERT_EQUALS("[test.cpp:5]: (error) Memory leak: i\n", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:5:1]: (error) Memory leak: i [memleak]\n", errout_str());
     }
 
     void return1() {
@@ -1644,7 +2641,7 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p = malloc(100);\n"
               "    return 123;\n"
               "}");
-        ASSERT_EQUALS("[test.c:3]: (error) Memory leak: p\n", errout.str());
+        ASSERT_EQUALS("[test.c:3:5]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
     void return2() {
@@ -1652,7 +2649,7 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p = malloc(100);\n"
               "    return p;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void return3() {
@@ -1660,7 +2657,7 @@ class TestLeakAutoVar : public TestFixture {
               "    struct ABC *abc = malloc(100);\n"
               "    return &abc->dev;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void return4() { // ticket #3862
@@ -1671,8 +2668,8 @@ class TestLeakAutoVar : public TestFixture {
               "        throw 1;\n"
               "    }\n"
               "    free(p);\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(char *p, int x) {\n"
               "    if (x==12) {\n"
@@ -1680,8 +2677,8 @@ class TestLeakAutoVar : public TestFixture {
               "        throw 1;\n"
               "    }\n"
               "    delete p;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(char *p, int x) {\n"
               "    if (x==12) {\n"
@@ -1689,8 +2686,8 @@ class TestLeakAutoVar : public TestFixture {
               "        throw 1;\n"
               "    }\n"
               "    delete [] p;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void return5() { // ticket #6397 - conditional allocation/deallocation and conditional return
@@ -1703,93 +2700,195 @@ class TestLeakAutoVar : public TestFixture {
               "        return;\n"
               "    }\n"
               "    *p = 0;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void return6() { // #8282
         check("std::pair<char*, char*> f(size_t n) {\n"
               "   char* p = (char* )malloc(n);\n"
               "   return {p, p};\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void return7() { // #9343
         check("uint8_t *f() {\n"
               "    void *x = malloc(1);\n"
               "    return (uint8_t *)x;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("uint8_t f() {\n"
               "    void *x = malloc(1);\n"
               "    return (uint8_t)x;\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Memory leak: x\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Memory leak: x [memleak]\n", errout_str());
 
         check("void** f() {\n"
               "    void *x = malloc(1);\n"
               "    return (void**)x;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void* f() {\n"
               "    void *x = malloc(1);\n"
               "    return (long long)x;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void* f() {\n"
               "    void *x = malloc(1);\n"
               "    return (void*)(short)x;\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Memory leak: x\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Memory leak: x [memleak]\n", errout_str());
 
         check("void* f() {\n"
               "    void *x = malloc(1);\n"
               "    return (mytype)x;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void* f() {\n" // Do not crash
               "    void *x = malloc(1);\n"
               "    return (mytype)y;\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Memory leak: x\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Memory leak: x [memleak]\n", errout_str());
     }
 
     void return8() {
         check("void* f() {\n"
               "    void *x = malloc(1);\n"
               "    return (x);\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void* f() {\n"
               "    void *x = malloc(1);\n"
               "    return ((x));\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void* f() {\n"
               "    void *x = malloc(1);\n"
               "    return ((((x))));\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("char* f() {\n"
               "    void *x = malloc(1);\n"
               "    return (char*)(x);\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void test1() { // 3809
-        check("void f(double*&p) {\n"
-              "    p = malloc(0x100);\n"
+    void return9() {
+        check("void* f() {\n"
+              "    void *x = malloc (sizeof (struct alloc));\n"
+              "    return x + sizeof (struct alloc);\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void return10() {
+        check("char f() {\n" // #11758
+              "    char* p = (char*)malloc(1);\n"
+              "    p[0] = 'x';\n"
+              "    return p[0];\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.c:4:5]: (error) Memory leak: p [memleak]\n", errout_str());
+
+        check("struct S { int f(); };\n" // #11746
+              "int g() {\n"
+              "    S* s = new S;\n"
+              "    delete s;\n"
+              "    return s->f();\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:4:5] -> [test.cpp:5:5]: (error) Returning/dereferencing 's' after it is deallocated / released [deallocret]\n", errout_str());
+
+        check("int f() {\n"
+              "    int* p = new int(3);\n"
+              "    delete p;\n"
+              "    return *p;\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:3:5] -> [test.cpp:4:5]: (error) Returning/dereferencing 'p' after it is deallocated / released [deallocret]\n", errout_str());
+    }
+
+    void return11() { // #13098
+        check("char malloc_memleak(void) {\n"
+              "    bool flag = false;\n"
+              "    char *ptr = malloc(10);\n"
+              "    if (flag) {\n"
+              "        free(ptr);\n"
+              "    }\n"
+              "    return 'a';\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:7:5]: (error) Memory leak: ptr [memleak]\n", errout_str());
+
+        check("char malloc_memleak(void) {\n"
+              "    bool flag = false;\n"
+              "    char *ptr = malloc(10);\n"
+              "    if (flag) {\n"
+              "        free(ptr);\n"
+              "    }\n"
+              "    return 'a';\n"
+              "}\n");
+        ASSERT_EQUALS("[test.c:7:5]: (error) Memory leak: ptr [memleak]\n", errout_str());
+    }
+
+    void return12() { // #12238
+        CheckOptions options;
+        options.cpp = true;
+        check("void f(size_t size) {\n"
+              "    void* buffer = malloc(size);\n"
+              "    std::vector<void*> v{ buffer };\n"
+              "    x->g(v);\n"
+              "}\n", options);
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void return13() { // #4638
+        CheckOptions options;
+        options.cpp = true;
+        check("bool f() {\n"
+              "    int* p = new int;\n"
+              "    return p;\n"
+              "}\n"
+              "bool g() {\n"
+              "    void* p = malloc(4);\n"
+              "    return p;\n"
+              "}\n", options);
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Memory leak: p [memleak]\n"
+                      "[test.cpp:7:5]: (error) Memory leak: p [memleak]\n",
+                      errout_str());
+    }
+
+    void test1() {
+        check("void f(double*&p) {\n" // 3809
+              "    p = malloc(0x100);\n"
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int*& p) {\n" // #4400
+              "    p = (int*)malloc(4);\n"
+              "    p = (int*)malloc(4);\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Memory leak: p [memleak]\n", errout_str());
+
+        check("void f() {\n"
+              "    int* p = (int*)malloc(4);\n"
+              "    int*& r = p;\n"
+              "    r = (int*)malloc(4);\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Memory leak: p\n", "", errout_str());
+
+        check("void f() {\n"
+              "    int* p = (int*)malloc(4);\n"
+              "    int*& r = p;\n"
+              "    free(r);\n"
+              "    p = (int*)malloc(4);\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        TODO_ASSERT_EQUALS("", "[test.cpp:6:1]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
     void test2() { // 3899
@@ -1797,15 +2896,15 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p;\n"
               "    void f1() { free(p); }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void test3() { // 3954 - reference pointer
         check("void f() {\n"
               "    char *&p = x();\n"
               "    p = malloc(10);\n"
-              "};");
-        ASSERT_EQUALS("", errout.str());
+              "};", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void test4() { // 5923 - static pointer
@@ -1814,29 +2913,29 @@ class TestLeakAutoVar : public TestFixture {
               "    if (!p) p = malloc(10);\n"
               "    if (x) { free(p); p = 0; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void test5() { // unknown type
-        check("void f() { Fred *p = malloc(10); }", true);
-        ASSERT_EQUALS("[test.cpp:1]: (error) Memory leak: p\n", errout.str());
+        check("void f() { Fred *p = malloc(10); }", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:1:34]: (error) Memory leak: p [memleak]\n", errout_str());
 
-        check("void f() { Fred *p = malloc(10); }", false);
-        ASSERT_EQUALS("[test.c:1]: (error) Memory leak: p\n", errout.str());
+        check("void f() { Fred *p = malloc(10); }");
+        ASSERT_EQUALS("[test.c:1:34]: (error) Memory leak: p [memleak]\n", errout_str());
 
-        check("void f() { Fred *p = new Fred; }", true);
-        ASSERT_EQUALS("", errout.str());
+        check("void f() { Fred *p = new Fred; }", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f() { Fred fred = malloc(10); }", true);
-        ASSERT_EQUALS("", errout.str());
+        check("void f() { Fred fred = malloc(10); }", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void throw1() { // 3987 - Execution reach a 'throw'
         check("void f() {\n"
               "    char *p = malloc(10);\n"
               "    throw 123;\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Memory leak: p\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Memory leak: p [memleak]\n", errout_str());
 
         check("void f() {\n"
               "    char *p;\n"
@@ -1845,8 +2944,8 @@ class TestLeakAutoVar : public TestFixture {
               "        throw 123;\n"
               "    } catch (...) { }\n"
               "    free(p);\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void throw2() { // do not miss ::NS::Except()
@@ -1862,8 +2961,8 @@ class TestLeakAutoVar : public TestFixture {
               "        throw ::NS::Except();\n"
               "    }\n"
               "    delete pi;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void configuration1() {
@@ -1876,9 +2975,15 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p = malloc(10);\n"
               "    x(p);\n"
               "}");
-        ASSERT_EQUALS("[test.c:3]: (information) --check-library: Function x() should have <noreturn> configuration\n"
-                      "[test.c:4]: (information) --check-library: Function x() should have <use>/<leak-ignore> configuration\n",
-                      errout.str());
+        ASSERT_EQUALS("[test.c:3:9]: (information) --check-library: Function x() should have <noreturn> configuration [checkLibraryNoReturn]\n"
+                      "[test.c:4:1]: (information) --check-library: Function x() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n",
+                      errout_str());
+
+        check("void cb();\n" // #11190, #11523
+              "void f() {\n"
+              "    cb();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void configuration2() {
@@ -1888,33 +2993,37 @@ class TestLeakAutoVar : public TestFixture {
               "    char *p = malloc(10);\n"
               "    x(&p);\n"
               "}");
-        ASSERT_EQUALS("[test.c:3]: (information) --check-library: Function x() should have <noreturn> configuration\n"
-                      "[test.c:4]: (information) --check-library: Function x() should have <use>/<leak-ignore> configuration\n",
-                      errout.str());
+        ASSERT_EQUALS("[test.c:3:10]: (information) --check-library: Function x() should have <noreturn> configuration [checkLibraryNoReturn]\n"
+                      "[test.c:4:1]: (information) --check-library: Function x() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n",
+                      errout_str());
     }
 
     void configuration3() {
-        const char * code = "void f() {\n"
-                            "    char *p = malloc(10);\n"
-                            "    if (set_data(p)) { }\n"
-                            "}";
-        check(code);
-        ASSERT_EQUALS("[test.c:4]: (information) --check-library: Function set_data() should have <use>/<leak-ignore> configuration\n", errout.str());
-        check(code, true);
-        ASSERT_EQUALS("[test.cpp:4]: (information) --check-library: Function set_data() should have <use>/<leak-ignore> configuration\n", errout.str());
-
-        code = "void f() {\n"
-               "    char *p = malloc(10);\n"
-               "    if (set_data(p)) { return; }\n"
-               "}";
-        check(code);
-        ASSERT_EQUALS("[test.c:3]: (information) --check-library: Function set_data() should have <use>/<leak-ignore> configuration\n"
-                      "[test.c:4]: (information) --check-library: Function set_data() should have <use>/<leak-ignore> configuration\n"
-                      , errout.str());
-        check(code, true);
-        ASSERT_EQUALS("[test.cpp:3]: (information) --check-library: Function set_data() should have <use>/<leak-ignore> configuration\n"
-                      "[test.cpp:4]: (information) --check-library: Function set_data() should have <use>/<leak-ignore> configuration\n"
-                      , errout.str());
+        {
+            const char code[] = "void f() {\n"
+                                "    char *p = malloc(10);\n"
+                                "    if (set_data(p)) { }\n"
+                                "}";
+            check(code);
+            ASSERT_EQUALS("[test.c:4:1]: (information) --check-library: Function set_data() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n", errout_str());
+            check(code, dinit(CheckOptions, $.cpp = true));
+            ASSERT_EQUALS("[test.cpp:4:1]: (information) --check-library: Function set_data() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n", errout_str());
+        }
+
+        {
+            const char code[] = "void f() {\n"
+                                "    char *p = malloc(10);\n"
+                                "    if (set_data(p)) { return; }\n"
+                                "}";
+            check(code);
+            ASSERT_EQUALS("[test.c:3:24]: (information) --check-library: Function set_data() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n"
+                          "[test.c:4:1]: (information) --check-library: Function set_data() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n"
+                          , errout_str());
+            check(code, dinit(CheckOptions, $.cpp = true));
+            ASSERT_EQUALS("[test.cpp:3:24]: (information) --check-library: Function set_data() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n"
+                          "[test.cpp:4:1]: (information) --check-library: Function set_data() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n"
+                          , errout_str());
+        }
     }
 
     void configuration4() {
@@ -1923,34 +3032,105 @@ class TestLeakAutoVar : public TestFixture {
               "    int ret = set_data(p);\n"
               "    return ret;\n"
               "}");
-        ASSERT_EQUALS("[test.c:4]: (information) --check-library: Function set_data() should have <use>/<leak-ignore> configuration\n", errout.str());
+        ASSERT_EQUALS("[test.c:4:5]: (information) --check-library: Function set_data() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n", errout_str());
+    }
+
+    void configuration5() {
+        check("void f() {\n"
+              "    int(i);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    static_assert(1 == sizeof(char), \"test\");\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("namespace pal {\n" // #11237
+              "    struct AutoTimer {};\n"
+              "}\n"
+              "int main() {\n"
+              "    pal::AutoTimer();\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct AutoTimer {};\n"
+              "int main() {\n"
+              "    AutoTimer();\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n" // #8666
+              "    asm(\"assembler code\");\n"
+              "    asm volatile(\"assembler code\");\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n" // #11239
+              "    asm goto(\"assembler code\");\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    FILE* p = fopen(\"abc.txt\", \"r\");\n"
+              "    if (fclose(p) != 0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S;\n"
+              "void f(int a, int b, S*& p) {\n"
+              "    if (a == -1) {\n"
+              "        FILE* file = fopen(\"abc.txt\", \"r\");\n"
+              "    }\n"
+              "    if (b) {\n"
+              "        void* buf = malloc(10);\n"
+              "        p = reinterpret_cast<S*>(buf);\n"
+              "    }\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:5:5]: (error) Resource leak: file [resourceLeak]\n", errout_str());
+    }
+
+    void configuration6() {
+        check("void f() {}\n" // #11198
+              "void g() {\n"
+              "    f();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::function<void()> cb) {\n" // #11189
+              "    cb();\n"
+              "}\n"
+              "void g(void (*cb)()) {\n"
+              "    cb();\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void ptrptr() {
         check("void f() {\n"
               "    char **p = malloc(10);\n"
               "}");
-        ASSERT_EQUALS("[test.c:3]: (error) Memory leak: p\n", errout.str());
+        ASSERT_EQUALS("[test.c:3:1]: (error) Memory leak: p [memleak]\n", errout_str());
     }
 
     void nestedAllocation() {
         check("void QueueDSMCCPacket(unsigned char *data, int length) {\n"
               "    unsigned char *dataCopy = malloc(length * sizeof(unsigned char));\n"
               "    m_dsmccQueue.enqueue(new DSMCCPacket(dataCopy));\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:4]: (information) --check-library: Function DSMCCPacket() should have <use>/<leak-ignore> configuration\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:4:1]: (information) --check-library: Function DSMCCPacket() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n", errout_str());
 
         check("void QueueDSMCCPacket(unsigned char *data, int length) {\n"
               "    unsigned char *dataCopy = malloc(length * sizeof(unsigned char));\n"
               "    m_dsmccQueue.enqueue(new DSMCCPacket(somethingunrelated));\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:4]: (error) Memory leak: dataCopy\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:4:1]: (error) Memory leak: dataCopy [memleak]\n", errout_str());
 
         check("void f() {\n"
               "  char *buf = new char[1000];\n"
               "  clist.push_back(new (std::nothrow) C(buf));\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:4]: (information) --check-library: Function C() should have <use>/<leak-ignore> configuration\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:4:1]: (information) --check-library: Function C() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n", errout_str());
     }
 
     void testKeywords() {
@@ -1958,8 +3138,8 @@ class TestLeakAutoVar : public TestFixture {
               "  double *new = malloc(1*sizeof(double));\n"
               "  free(new);\n"
               "  return 0;\n"
-              "}", false);
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void inlineFunction() {
@@ -1972,7 +3152,7 @@ class TestLeakAutoVar : public TestFixture {
               "    c = malloc(128);\n"
               "    return ret();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // #8262
@@ -1982,20 +3162,117 @@ class TestLeakAutoVar : public TestFixture {
               "  int *pt = new int(1);\n"
               "  mList.push_back(std::shared_ptr<int>(pt));\n"
               "}\n",
-              true
-             );
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.cpp = true)
+              );
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void functionCallCastConfig() { // #9652
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def format=\"2\">\n"
+                                   "  <function name=\"free_func\">\n"
+                                   "    <noreturn>false</noreturn>\n"
+                                   "    <arg nr=\"1\">\n"
+                                   "      <not-uninit/>\n"
+                                   "    </arg>\n"
+                                   "    <arg nr=\"2\">\n"
+                                   "      <not-uninit/>\n"
+                                   "    </arg>\n"
+                                   "  </function>\n"
+                                   "</def>";
+        const Settings settingsFunctionCall = settingsBuilder(settings).libraryxml(xmldata).build();
+
+        check("void test_func()\n"
+              "{\n"
+              "    char * buf = malloc(4);\n"
+              "    free_func((void *)(1), buf);\n"
+              "}", settingsFunctionCall);
+        ASSERT_EQUALS("[test.cpp:5:1]: (information) --check-library: Function free_func() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n", errout_str());
+
+        check("void g(void*);\n"
+              "void h(int, void*);\n"
+              "void f1() {\n"
+              "    int* p = new int;\n"
+              "    g(static_cast<void*>(p));\n"
+              "}\n"
+              "void f2() {\n"
+              "    int* p = new int;\n"
+              "    h(1, static_cast<void*>(p));\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:6:1]: (information) --check-library: Function g() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n"
+                      "[test.cpp:10:1]: (information) --check-library: Function h() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n",
+                      errout_str());
+    }
+
+    void functionCallLeakIgnoreConfig() { // #7923
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def format=\"2\">\n"
+                                   "  <function name=\"SomeClass::someMethod\">\n"
+                                   "    <leak-ignore/>\n"
+                                   "    <noreturn>false</noreturn>\n"
+                                   "    <arg nr=\"1\" direction=\"in\"/>\n"
+                                   "  </function>\n"
+                                   "</def>\n";
+        const Settings settingsLeakIgnore = settingsBuilder().libraryxml(xmldata).checkLibrary().build();
+        check("void f() {\n"
+              "    double* a = new double[1024];\n"
+              "    SomeClass::someMethod(a);\n"
+              "}\n", settingsLeakIgnore);
+        ASSERT_EQUALS("[test.cpp:4:1]: (error) Memory leak: a [memleak]\n", errout_str());
+
+        check("void bar(int* p) {\n"
+              "    if (p)\n"
+              "        free(p);\n"
+              "}\n"
+              "void f() {\n"
+              "    int* p = malloc(4);\n"
+              "    bar(p);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int n) {\n"
+              "    char* p = new char[n];\n"
+              "    v.push_back(p);\n"
+              "}\n", dinit(CheckOptions, $.cpp = true));
+        ASSERT_EQUALS("[test.cpp:4:1]: (information) --check-library: Function unknown::push_back() should have <use>/<leak-ignore> configuration [checkLibraryUseIgnore]\n", errout_str());
+    }
+};
+
+REGISTER_TEST(TestLeakAutoVar)
+
+class TestLeakAutoVarRecursiveCountLimit : public TestFixture {
+public:
+    TestLeakAutoVarRecursiveCountLimit() : TestFixture("TestLeakAutoVarRecursiveCountLimit") {}
+
+private:
+    const Settings settings = settingsBuilder().library("std.cfg").checkLibrary().build();
+
+#define checkP(...) checkP_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkP_(const char* file, int line, const char (&code)[size]) {
+        SimpleTokenizer2 tokenizer(settings, *this, code, "test.c");
+
+        // Tokenizer..
+        ASSERT_LOC(tokenizer.simplifyTokens1(""), file, line);
+
+        // Check for leaks..
+        runChecks<CheckLeakAutoVar>(tokenizer, this);
+    }
+
+    void run() override {
+        mNewTemplate = true;
+        TEST_CASE(recursiveCountLimit); // #5872 #6157 #9097
     }
 
     void recursiveCountLimit() { // #5872 #6157 #9097
-        ASSERT_THROW(checkP("#define ONE     else if (0) { }\n"
-                            "#define TEN     ONE ONE ONE ONE ONE ONE ONE ONE ONE ONE\n"
-                            "#define HUN     TEN TEN TEN TEN TEN TEN TEN TEN TEN TEN\n"
-                            "#define THOU    HUN HUN HUN HUN HUN HUN HUN HUN HUN HUN\n"
-                            "void foo() {\n"
-                            "  if (0) { }\n"
-                            "  THOU THOU\n"
-                            "}"), InternalError);
+        ASSERT_THROW_INTERNAL_EQUALS(checkP("#define ONE     else if (0) { }\n"
+                                            "#define TEN     ONE ONE ONE ONE ONE ONE ONE ONE ONE ONE\n"
+                                            "#define HUN     TEN TEN TEN TEN TEN TEN TEN TEN TEN TEN\n"
+                                            "#define THOU    HUN HUN HUN HUN HUN HUN HUN HUN HUN HUN\n"
+                                            "void foo() {\n"
+                                            "  if (0) { }\n"
+                                            "  THOU THOU\n"
+                                            "}"), LIMIT, "Internal limit: CheckLeakAutoVar::checkScope() Maximum recursive count of 1000 reached.");
         ASSERT_NO_THROW(checkP("#define ONE     if (0) { }\n"
                                "#define TEN     ONE ONE ONE ONE ONE ONE ONE ONE ONE ONE\n"
                                "#define HUN     TEN TEN TEN TEN TEN TEN TEN TEN TEN TEN\n"
@@ -2005,91 +3282,266 @@ class TestLeakAutoVar : public TestFixture {
                                "  THOU THOU\n"
                                "}"));
     }
-
 };
 
-REGISTER_TEST(TestLeakAutoVar)
+#if !defined(__MINGW32__) && !defined(__CYGWIN__)
+// TODO: this crashes with a stack overflow for MinGW and error 2816 for Cygwinin the CI
+REGISTER_TEST(TestLeakAutoVarRecursiveCountLimit)
+#endif
 
+class TestLeakAutoVarStrcpy : public TestFixture {
+public:
+    TestLeakAutoVarStrcpy() : TestFixture("TestLeakAutoVarStrcpy") {}
 
+private:
+    const Settings settings = settingsBuilder().library("std.cfg").checkLibrary().build();
 
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size]) {
+        // Tokenize..
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+
+        // Check for leaks..
+        runChecks<CheckLeakAutoVar>(tokenizer, this);
+    }
+
+    void run() override {
+        mNewTemplate = true;
+        TEST_CASE(returnedValue); // #9298
+        TEST_CASE(deallocuse2);
+        TEST_CASE(fclose_false_positive); // #9575
+        TEST_CASE(strcpy_false_negative);
+        TEST_CASE(doubleFree);
+        TEST_CASE(memleak_std_string);
+    }
+
+    void returnedValue() { // #9298
+        check("char *m;\n"
+              "void strcpy_returnedvalue(const char* str)\n"
+              "{\n"
+              "    char* ptr = new char[strlen(str)+1];\n"
+              "    m = strcpy(ptr, str);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void deallocuse2() {
+        check("void f(char *p) {\n"
+              "    free(p);\n"
+              "    strcpy(a, p);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:15]: (error) Dereferencing 'p' after it is deallocated / released [deallocuse]\n", errout_str());
+
+        check("void f(char *p, const char *q) {\n" // #11665
+              "    free(p);\n"
+              "    strcpy(p, q);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Dereferencing 'p' after it is deallocated / released [deallocuse]\n",
+                      errout_str());
+
+        check("void f(char *p) {\n"   // #3041 - assigning pointer when it's used
+              "    free(p);\n"
+              "    strcpy(a, p=b());\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void fclose_false_positive() { // #9575
+        check("int  f(FILE *fp) { return fclose(fp); }");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void strcpy_false_negative() { // #12289
+        check("void f() {\n"
+              "    char* buf = new char[12];\n"
+              "    strcpy(buf, \"123\");\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:1]: (error) Memory leak: buf [memleak]\n", errout_str());
+    }
+
+    void doubleFree() {
+        check("void f(char* p) {\n"
+              "    free(p);\n"
+              "    printf(\"%s\", p = strdup(\"abc\"));\n"
+              "    free(p);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void memleak_std_string() {
+        check("struct S {\n" // #12354
+              "    std::string s;\n"
+              "    void f();\n"
+              "};\n"
+              "void f(S* p, bool b) {\n"
+              "    if (b)\n"
+              "        p = new S();\n"
+              "    p->f();\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:9:1]: (error) Memory leak: p [memleak]\n", errout_str());
+
+        check("class B { std::string s; };\n" // #12062
+              "class D : public B {};\n"
+              "void g() {\n"
+              "    auto d = new D();\n"
+              "    if (d) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:1]: (error) Memory leak: d [memleak]\n", errout_str());
+    }
+};
+
+REGISTER_TEST(TestLeakAutoVarStrcpy)
 
 
 class TestLeakAutoVarWindows : public TestFixture {
 public:
-    TestLeakAutoVarWindows() : TestFixture("TestLeakAutoVarWindows") {
-    }
+    TestLeakAutoVarWindows() : TestFixture("TestLeakAutoVarWindows") {}
 
 private:
-    Settings settings;
-
-    void check(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
+    const Settings settings = settingsBuilder().library("windows.cfg").build();
 
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.c");
+        SimpleTokenizer tokenizer(settings, *this, false);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check for leaks..
-        CheckLeakAutoVar checkLeak;
-        checkLeak.runChecks(&tokenizer, &settings, this);
+        runChecks<CheckLeakAutoVar>(tokenizer, this);
     }
 
-    void run() OVERRIDE {
-        LOAD_LIB_2(settings.library, "windows.cfg");
-
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(heapDoubleFree);
     }
 
     void heapDoubleFree() {
-        check("void f() {"
-              "  HANDLE MyHeap = HeapCreate(0, 0, 0);"
-              "  int *a = HeapAlloc(MyHeap, 0, sizeof(int));"
-              "  int *b = HeapAlloc(MyHeap, 0, sizeof(int));"
-              "  HeapFree(MyHeap, 0, a);"
-              "  HeapFree(MyHeap, 0, b);"
-              "  HeapDestroy(MyHeap);"
-              "}");
-        ASSERT_EQUALS("", errout.str());
-
-        check("void f() {"
-              "  int *a = HeapAlloc(GetProcessHeap(), 0, sizeof(int));"
-              "  int *b = HeapAlloc(GetProcessHeap(), 0, sizeof(int));"
-              "  HeapFree(GetProcessHeap(), 0, a);"
-              "  HeapFree(GetProcessHeap(), 0, b);"
-              "}");
-        ASSERT_EQUALS("", errout.str());
-
-        check("void f() {"
-              "  HANDLE MyHeap = HeapCreate(0, 0, 0);"
-              "  int *a = HeapAlloc(MyHeap, 0, sizeof(int));"
-              "  int *b = HeapAlloc(MyHeap, 0, sizeof(int));"
-              "  HeapFree(MyHeap, 0, a);"
-              "  HeapDestroy(MyHeap);"
-              "}");
-        ASSERT_EQUALS("[test.c:1]: (error) Memory leak: b\n", errout.str());
-
-        check("void f() {"
-              "  HANDLE MyHeap = HeapCreate(0, 0, 0);"
-              "  int *a = HeapAlloc(MyHeap, 0, sizeof(int));"
-              "  int *b = HeapAlloc(MyHeap, 0, sizeof(int));"
-              "  HeapFree(MyHeap, 0, a);"
-              "  HeapFree(MyHeap, 0, b);"
-              "}");
-        TODO_ASSERT_EQUALS("[test.c:1] (error) Resource leak: MyHeap",
-                           "", errout.str());
-
-        check("void f() {"
-              "  HANDLE MyHeap = HeapCreate(0, 0, 0);"
-              "  int *a = HeapAlloc(MyHeap, 0, sizeof(int));"
-              "  int *b = HeapAlloc(MyHeap, 0, sizeof(int));"
-              "  HeapFree(MyHeap, 0, a);"
-              "}");
-        TODO_ASSERT_EQUALS("[test.c:1] (error) Memory leak: MyHeap\n"
-                           "[test.c:1] (error) Memory leak: b",
-                           "[test.c:1]: (error) Memory leak: b\n", errout.str());
+        check("void f() {\n"
+              "  HANDLE MyHeap = HeapCreate(0, 0, 0);\n"
+              "  int *a = HeapAlloc(MyHeap, 0, sizeof(int));\n"
+              "  int *b = HeapAlloc(MyHeap, 0, sizeof(int));\n"
+              "  HeapFree(MyHeap, 0, a);\n"
+              "  HeapFree(MyHeap, 0, b);\n"
+              "  HeapDestroy(MyHeap);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "  int *a = HeapAlloc(GetProcessHeap(), 0, sizeof(int))\n"
+              "  int *b = HeapAlloc(GetProcessHeap(), 0, sizeof(int));\n"
+              "  HeapFree(GetProcessHeap(), 0, a);\n"
+              "  HeapFree(GetProcessHeap(), 0, b);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "  HANDLE MyHeap = HeapCreate(0, 0, 0);\n"
+              "  int *a = HeapAlloc(MyHeap, 0, sizeof(int));\n"
+              "  int *b = HeapAlloc(MyHeap, 0, sizeof(int));\n"
+              "  HeapFree(MyHeap, 0, a);\n"
+              "  HeapDestroy(MyHeap);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.c:7:1]: (error) Memory leak: b [memleak]\n", errout_str());
+
+        check("void f() {\n"
+              "  HANDLE MyHeap = HeapCreate(0, 0, 0);\n"
+              "  int *a = HeapAlloc(MyHeap, 0, sizeof(int));\n"
+              "  int *b = HeapAlloc(MyHeap, 0, sizeof(int));\n"
+              "  HeapFree(MyHeap, 0, a);\n"
+              "  HeapFree(MyHeap, 0, b);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.c:7:1]: (error) Resource leak: MyHeap [resourceLeak]\n", errout_str());
+
+        check("void f() {\n"
+              "  HANDLE MyHeap = HeapCreate(0, 0, 0);\n"
+              "  int *a = HeapAlloc(MyHeap, 0, sizeof(int));\n"
+              "  int *b = HeapAlloc(MyHeap, 0, sizeof(int));\n"
+              "  HeapFree(MyHeap, 0, a);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.c:6:1]: (error) Resource leak: MyHeap [resourceLeak]\n"
+                      "[test.c:6:1]: (error) Memory leak: b [memleak]\n",
+                      errout_str());
     }
 };
 
 REGISTER_TEST(TestLeakAutoVarWindows)
+
+class TestLeakAutoVarPosix : public TestFixture {
+public:
+    TestLeakAutoVarPosix() : TestFixture("TestLeakAutoVarPosix") {}
+
+private:
+    const Settings settings = settingsBuilder().library("std.cfg").library("posix.cfg").build();
+
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size]) {
+        // Tokenize..
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+
+        // Check for leaks..
+        runChecks<CheckLeakAutoVar>(tokenizer, this);
+    }
+
+    void run() override {
+        mNewTemplate = true;
+        TEST_CASE(memleak_getline);
+        TEST_CASE(deallocuse_fdopen);
+        TEST_CASE(doublefree_fdopen); // #12781
+        TEST_CASE(memleak_open); // #13356
+    }
+
+    void memleak_getline() {
+        check("void f(std::ifstream &is) {\n" // #12297
+              "    std::string str;\n"
+              "    if (getline(is, str, 'x').good()) {};\n"
+              "    if (!getline(is, str, 'x').good()) {};\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void deallocuse_fdopen() {
+        check("struct FileCloser {\n" // #13126
+              "    void operator()(std::FILE * ptr) const {\n"
+              "        std::fclose(ptr);\n"
+              "    }\n"
+              "};\n"
+              "void f(char* fileName) {\n"
+              "    std::unique_ptr<std::FILE, FileCloser> out;\n"
+              "    int fd = mkstemps(fileName, 4);\n"
+              "    if (fd != -1)\n"
+              "        out.reset(fdopen(fd, \"w\"));\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void doublefree_fdopen() { // #12781
+        check("void foo(void) {\n"
+              "    int fd;\n"
+              "    FILE *stream;\n"
+              "    fd = open(\"/foo\", O_RDONLY);\n"
+              "    if (fd == -1) return;\n"
+              "    stream = fdopen(fd, \"r\");\n"
+              "    if (!stream) {\n"
+              "        close(fd);\n"
+              "        return;\n"
+              "    }\n"
+              "    fclose(stream);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void memleak_open() { // #13356
+        check("int f() {\n"
+              "    int fd = open(\"abc \", O_RDONLY);\n"
+              "    if (fd > -1) {\n"
+              "        return fd;\n"
+              "    }\n"
+              "    return -1;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+};
+
+REGISTER_TEST(TestLeakAutoVarPosix)
diff --git a/test/testlibrary.cpp b/test/testlibrary.cpp
index 89ef7064606..a531ac4cba9 100644
--- a/test/testlibrary.cpp
+++ b/test/testlibrary.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,31 +16,31 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "errorlogger.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "library.h"
 #include "settings.h"
 #include "standards.h"
-#include "testsuite.h"
 #include "token.h"
-#include "tokenize.h"
 #include "tokenlist.h"
 
-#include <tinyxml2.h>
+#include <cstddef>
+#include <cstdint>
 #include <map>
-#include <set>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 #define ASSERT_EQ(expected, actual)   ASSERT(expected == actual)
 
 class TestLibrary : public TestFixture {
 public:
-    TestLibrary() : TestFixture("TestLibrary") { }
+    TestLibrary() : TestFixture("TestLibrary") {}
 
 private:
-    Settings settings;
-
-    void run() OVERRIDE {
+    void run() override {
+        TEST_CASE(isCompliantValidationExpression);
         TEST_CASE(empty);
         TEST_CASE(function);
         TEST_CASE(function_match_scope);
@@ -63,132 +63,153 @@ class TestLibrary : public TestFixture {
         TEST_CASE(resource);
         TEST_CASE(podtype);
         TEST_CASE(container);
+        TEST_CASE(containerActionToFromString);
+        TEST_CASE(containerYieldToFromString);
         TEST_CASE(version);
         TEST_CASE(loadLibErrors);
+        TEST_CASE(loadLibCombinations);
+        TEST_CASE(smartpointer);
     }
 
-    static Library::Error readLibrary(Library& library, const char* xmldata) {
-        tinyxml2::XMLDocument doc;
-        doc.Parse(xmldata);
-        return library.load(doc);
+    void isCompliantValidationExpression() const {
+        ASSERT_EQUALS(true, Library::isCompliantValidationExpression("-1"));
+        ASSERT_EQUALS(true, Library::isCompliantValidationExpression("1"));
+        ASSERT_EQUALS(true, Library::isCompliantValidationExpression("1:"));
+        ASSERT_EQUALS(true, Library::isCompliantValidationExpression(":1"));
+        ASSERT_EQUALS(true, Library::isCompliantValidationExpression("-1,42"));
+        ASSERT_EQUALS(true, Library::isCompliantValidationExpression("-1,-42"));
+        ASSERT_EQUALS(true, Library::isCompliantValidationExpression("-1.0:42.0"));
+        ASSERT_EQUALS(true, Library::isCompliantValidationExpression("1.175494e-38:3.402823e+38"));
+        ASSERT_EQUALS(true, Library::isCompliantValidationExpression("1.175494e-38,3.402823e+38"));
+        ASSERT_EQUALS(true, Library::isCompliantValidationExpression("1.175494e-38:"));
+        ASSERT_EQUALS(true, Library::isCompliantValidationExpression(":1.175494e-38"));
+        ASSERT_EQUALS(true, Library::isCompliantValidationExpression(":42.0"));
+        ASSERT_EQUALS(true, Library::isCompliantValidationExpression("!42.0"));
+
+        // Robustness tests
+        ASSERT_EQUALS(false, Library::isCompliantValidationExpression(nullptr));
+        ASSERT_EQUALS(false, Library::isCompliantValidationExpression("x"));
+        ASSERT_EQUALS(false, Library::isCompliantValidationExpression("!"));
+        ASSERT_EQUALS(false, Library::isCompliantValidationExpression(""));
     }
 
     void empty() const {
         // Reading an empty library file is considered to be OK
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n<def/>";
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n<def/>";
         Library library;
-        ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
-        ASSERT(library.functions.empty());
+        ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
+        ASSERT(library.functions().empty());
     }
 
     void function() const {
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <function name=\"foo\">\n"
-                               "    <noreturn>false</noreturn>\n"
-                               "  </function>\n"
-                               "</def>";
-
-        TokenList tokenList(nullptr);
-        std::istringstream istr("foo();");
-        tokenList.createTokens(istr);
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <function name=\"foo\">\n"
+                                   "    <noreturn>false</noreturn>\n"
+                                   "  </function>\n"
+                                   "</def>";
+
+        const char code[] = "foo();";
+        SimpleTokenList tokenList(code);
         tokenList.front()->next()->astOperand1(tokenList.front());
 
         Library library;
-        ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
-        ASSERT_EQUALS(library.functions.size(), 1U);
-        ASSERT(library.functions.at("foo").argumentChecks.empty());
+        ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
+        ASSERT_EQUALS(library.functions().size(), 1U);
+        ASSERT(library.functions().at("foo").argumentChecks.empty());
         ASSERT(library.isnotnoreturn(tokenList.front()));
     }
 
     void function_match_scope() const {
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <function name=\"foo\">\n"
-                               "    <arg nr=\"1\"/>"
-                               "  </function>\n"
-                               "</def>";
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <function name=\"foo\">\n"
+                                   "    <arg nr=\"1\"/>"
+                                   "  </function>\n"
+                                   "</def>";
 
         Library library;
-        ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
+        ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
         {
-            TokenList tokenList(nullptr);
-            std::istringstream istr("fred.foo(123);"); // <- wrong scope, not library function
-            tokenList.createTokens(istr);
+            const char code[] = "fred.foo(123);"; // <- wrong scope, not library function
+            const SimpleTokenList tokenList(code);
 
             ASSERT(library.isNotLibraryFunction(tokenList.front()->tokAt(2)));
         }
         {
-            TokenList tokenList(nullptr);
-            std::istringstream istr("Fred::foo(123);"); // <- wrong scope, not library function
-            tokenList.createTokens(istr);
+            const char code[] = "Fred::foo(123);"; // <- wrong scope, not library function
+            const SimpleTokenList tokenList(code);
 
             ASSERT(library.isNotLibraryFunction(tokenList.front()->tokAt(2)));
         }
     }
 
     void function_match_args() const {
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <function name=\"foo\">\n"
-                               "    <arg nr=\"1\"/>"
-                               "  </function>\n"
-                               "</def>";
-
-        TokenList tokenList(nullptr);
-        std::istringstream istr("foo();"); // <- too few arguments, not library function
-        tokenList.createTokens(istr);
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <function name=\"foo\">\n"
+                                   "    <arg nr=\"1\"/>"
+                                   "  </function>\n"
+                                   "</def>";
+
+        TokenList tokenList(settingsDefault, Standards::Language::CPP);
+        const char code[] = "foo();"; // <- too few arguments, not library function
+        ASSERT(tokenList.createTokensFromString(code));
         Token::createMutualLinks(tokenList.front()->next(), tokenList.back()->previous());
         tokenList.createAst();
 
         Library library;
-        ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
+        ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
         ASSERT(library.isNotLibraryFunction(tokenList.front()));
     }
 
     void function_match_args_default() const {
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <function name=\"foo\">\n"
-                               "    <arg nr=\"1\"/>"
-                               "    <arg nr=\"2\" default=\"0\"/>"
-                               "  </function>\n"
-                               "</def>";
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <function name=\"foo\">\n"
+                                   "    <arg nr=\"1\"/>"
+                                   "    <arg nr=\"2\" default=\"0\"/>"
+                                   "  </function>\n"
+                                   "</def>";
 
         Library library;
-        ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
+        ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
 
         {
-            TokenList tokenList(nullptr);
-            std::istringstream istr("foo();"); // <- too few arguments, not library function
-            tokenList.createTokens(istr);
+            TokenList tokenList(settingsDefault, Standards::Language::CPP);
+            const char code[] = "foo();"; // <- too few arguments, not library function
+            ASSERT(tokenList.createTokensFromString(code));
             Token::createMutualLinks(tokenList.front()->next(), tokenList.back()->previous());
             tokenList.createAst();
 
             ASSERT(library.isNotLibraryFunction(tokenList.front()));
         }
         {
-            TokenList tokenList(nullptr);
-            std::istringstream istr("foo(a);"); // <- library function
-            tokenList.createTokens(istr);
+            TokenList tokenList(settingsDefault, Standards::Language::CPP);
+            const char code[] = "foo(a);"; // <- library function
+            ASSERT(tokenList.createTokensFromString(code));
             Token::createMutualLinks(tokenList.front()->next(), tokenList.back()->previous());
             tokenList.createAst();
 
-            ASSERT(!library.isNotLibraryFunction(tokenList.front()));
+            const Library::Function* func = nullptr;
+            ASSERT(!library.isNotLibraryFunction(tokenList.front(), &func));
+            ASSERT(func);
         }
         {
-            TokenList tokenList(nullptr);
-            std::istringstream istr("foo(a, b);"); // <- library function
-            tokenList.createTokens(istr);
+            TokenList tokenList(settingsDefault, Standards::Language::CPP);
+            const char code[] = "foo(a, b);"; // <- library function
+            ASSERT(tokenList.createTokensFromString(code));
             Token::createMutualLinks(tokenList.front()->next(), tokenList.back()->previous());
             tokenList.createAst();
 
-            ASSERT(!library.isNotLibraryFunction(tokenList.front()));
+            const Library::Function* func = nullptr;
+            ASSERT(!library.isNotLibraryFunction(tokenList.front(), &func));
+            ASSERT(func);
         }
         {
-            TokenList tokenList(nullptr);
-            std::istringstream istr("foo(a, b, c);"); // <- too much arguments, not library function
-            tokenList.createTokens(istr);
+            TokenList tokenList(settingsDefault, Standards::Language::CPP);
+            const char code[] = "foo(a, b, c);"; // <- too much arguments, not library function
+            ASSERT(tokenList.createTokensFromString(code));
             Token::createMutualLinks(tokenList.front()->next(), tokenList.back()->previous());
             tokenList.createAst();
 
@@ -197,76 +218,75 @@ class TestLibrary : public TestFixture {
     }
 
     void function_match_var() const {
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <function name=\"foo\">\n"
-                               "    <arg nr=\"1\"/>"
-                               "  </function>\n"
-                               "</def>";
-
-        TokenList tokenList(nullptr);
-        std::istringstream istr("Fred foo(123);"); // <- Variable declaration, not library function
-        tokenList.createTokens(istr);
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <function name=\"foo\">\n"
+                                   "    <arg nr=\"1\"/>"
+                                   "  </function>\n"
+                                   "</def>";
+
+        const char code[] = "Fred foo(123);"; // <- Variable declaration, not library function
+        SimpleTokenList tokenList(code);
         tokenList.front()->next()->astOperand1(tokenList.front());
         tokenList.front()->next()->varId(1);
 
         Library library;
-        ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
+        ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
         ASSERT(library.isNotLibraryFunction(tokenList.front()->next()));
     }
 
     void function_arg() const {
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <function name=\"foo\">\n"
-                               "    <arg nr=\"1\"><not-uninit/></arg>\n"
-                               "    <arg nr=\"2\"><not-null/></arg>\n"
-                               "    <arg nr=\"3\"><formatstr/></arg>\n"
-                               "    <arg nr=\"4\"><strz/></arg>\n"
-                               "    <arg nr=\"5\" default=\"0\"><not-bool/></arg>\n"
-                               "  </function>\n"
-                               "</def>";
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <function name=\"foo\">\n"
+                                   "    <arg nr=\"1\"><not-uninit/></arg>\n"
+                                   "    <arg nr=\"2\"><not-null/></arg>\n"
+                                   "    <arg nr=\"3\"><formatstr/></arg>\n"
+                                   "    <arg nr=\"4\"><strz/></arg>\n"
+                                   "    <arg nr=\"5\" default=\"0\"><not-bool/></arg>\n"
+                                   "  </function>\n"
+                                   "</def>";
 
         Library library;
-        ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
-        ASSERT_EQUALS(true, library.functions["foo"].argumentChecks[1].notuninit);
-        ASSERT_EQUALS(true, library.functions["foo"].argumentChecks[2].notnull);
-        ASSERT_EQUALS(true, library.functions["foo"].argumentChecks[3].formatstr);
-        ASSERT_EQUALS(true, library.functions["foo"].argumentChecks[4].strz);
-        ASSERT_EQUALS(false, library.functions["foo"].argumentChecks[4].optional);
-        ASSERT_EQUALS(true, library.functions["foo"].argumentChecks[5].notbool);
-        ASSERT_EQUALS(true, library.functions["foo"].argumentChecks[5].optional);
+        ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
+        const auto& foo_fn_args = library.functions().at("foo").argumentChecks;
+        ASSERT_EQUALS(0, foo_fn_args.at(1).notuninit);
+        ASSERT_EQUALS(true, foo_fn_args.at(2).notnull);
+        ASSERT_EQUALS(true, foo_fn_args.at(3).formatstr);
+        ASSERT_EQUALS(true, foo_fn_args.at(4).strz);
+        ASSERT_EQUALS(false, foo_fn_args.at(4).optional);
+        ASSERT_EQUALS(true, foo_fn_args.at(5).notbool);
+        ASSERT_EQUALS(true, foo_fn_args.at(5).optional);
     }
 
     void function_arg_any() const {
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "<function name=\"foo\">\n"
-                               "   <arg nr=\"any\"><not-uninit/></arg>\n"
-                               "</function>\n"
-                               "</def>";
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "<function name=\"foo\">\n"
+                                   "   <arg nr=\"any\"><not-uninit/></arg>\n"
+                                   "</function>\n"
+                                   "</def>";
 
         Library library;
-        ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
-        ASSERT_EQUALS(true, library.functions["foo"].argumentChecks[-1].notuninit);
+        ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
+        ASSERT_EQUALS(0, library.functions().at("foo").argumentChecks.at(-1).notuninit);
     }
 
     void function_arg_variadic() const {
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "<function name=\"foo\">\n"
-                               "   <arg nr=\"1\"></arg>\n"
-                               "   <arg nr=\"variadic\"><not-uninit/></arg>\n"
-                               "</function>\n"
-                               "</def>";
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "<function name=\"foo\">\n"
+                                   "   <arg nr=\"1\"></arg>\n"
+                                   "   <arg nr=\"variadic\"><not-uninit/></arg>\n"
+                                   "</function>\n"
+                                   "</def>";
 
         Library library;
-        ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
-        ASSERT_EQUALS(true, library.functions["foo"].argumentChecks[-1].notuninit);
+        ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
+        ASSERT_EQUALS(0, library.functions().at("foo").argumentChecks.at(-1).notuninit);
 
-        TokenList tokenList(nullptr);
-        std::istringstream istr("foo(a,b,c,d,e);");
-        tokenList.createTokens(istr);
+        const char code[] = "foo(a,b,c,d,e);";
+        SimpleTokenList tokenList(code);
         tokenList.front()->next()->astOperand1(tokenList.front());
 
         ASSERT_EQUALS(false, library.isuninitargbad(tokenList.front(), 1));
@@ -276,22 +296,21 @@ class TestLibrary : public TestFixture {
     }
 
     void function_arg_direction() const {
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "<function name=\"foo\">\n"
-                               "   <arg nr=\"1\" direction=\"in\"></arg>\n"
-                               "   <arg nr=\"2\" direction=\"out\"></arg>\n"
-                               "   <arg nr=\"3\" direction=\"inout\"></arg>\n"
-                               "   <arg nr=\"4\"></arg>\n"
-                               "</function>\n"
-                               "</def>";
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "<function name=\"foo\">\n"
+                                   "   <arg nr=\"1\" direction=\"in\"></arg>\n"
+                                   "   <arg nr=\"2\" direction=\"out\"></arg>\n"
+                                   "   <arg nr=\"3\" direction=\"inout\"></arg>\n"
+                                   "   <arg nr=\"4\"></arg>\n"
+                                   "</function>\n"
+                                   "</def>";
 
         Library library;
-        ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
+        ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
 
-        TokenList tokenList(nullptr);
-        std::istringstream istr("foo(a,b,c,d);");
-        tokenList.createTokens(istr);
+        const char code[] = "foo(a,b,c,d);";
+        SimpleTokenList tokenList(code);
         tokenList.front()->next()->astOperand1(tokenList.front());
 
         ASSERT(Library::ArgumentChecks::Direction::DIR_IN == library.getArgDirection(tokenList.front(), 1));
@@ -301,164 +320,169 @@ class TestLibrary : public TestFixture {
     }
 
     void function_arg_valid() const {
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <function name=\"foo\">\n"
-                               "    <arg nr=\"1\"><valid>1:</valid></arg>\n"
-                               "    <arg nr=\"2\"><valid>-7:0</valid></arg>\n"
-                               "    <arg nr=\"3\"><valid>1:5,8</valid></arg>\n"
-                               "    <arg nr=\"4\"><valid>-1,5</valid></arg>\n"
-                               "    <arg nr=\"5\"><valid>:1,5</valid></arg>\n"
-                               "    <arg nr=\"6\"><valid>1.5:</valid></arg>\n"
-                               "    <arg nr=\"7\"><valid>-6.7:-5.5,-3.3:-2.7</valid></arg>\n"
-                               "    <arg nr=\"8\"><valid>0.0:</valid></arg>\n"
-                               "    <arg nr=\"9\"><valid>:2.0</valid></arg>\n"
-                               "    <arg nr=\"10\"><valid>0.0</valid></arg>\n"
-                               "  </function>\n"
-                               "</def>";
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <function name=\"foo\">\n"
+                                   "    <arg nr=\"1\"><valid>1:</valid></arg>\n"
+                                   "    <arg nr=\"2\"><valid>-7:0</valid></arg>\n"
+                                   "    <arg nr=\"3\"><valid>1:5,8</valid></arg>\n"
+                                   "    <arg nr=\"4\"><valid>-1,5</valid></arg>\n"
+                                   "    <arg nr=\"5\"><valid>:1,5</valid></arg>\n"
+                                   "    <arg nr=\"6\"><valid>1.5:</valid></arg>\n"
+                                   "    <arg nr=\"7\"><valid>-6.7:-5.5,-3.3:-2.7</valid></arg>\n"
+                                   "    <arg nr=\"8\"><valid>0.0:</valid></arg>\n"
+                                   "    <arg nr=\"9\"><valid>:2.0</valid></arg>\n"
+                                   "    <arg nr=\"10\"><valid>0.0</valid></arg>\n"
+                                   "    <arg nr=\"11\"><valid>!0.0</valid></arg>\n"
+                                   "  </function>\n"
+                                   "</def>";
 
         Library library;
-        ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
+        ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
 
-        TokenList tokenList(nullptr);
-        std::istringstream istr("foo(a,b,c,d,e,f,g,h,i,j);");
-        tokenList.createTokens(istr);
+        const char code[] = "foo(a,b,c,d,e,f,g,h,i,j,k);";
+        SimpleTokenList tokenList(code);
         tokenList.front()->next()->astOperand1(tokenList.front());
 
         // 1-
-        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 1, -10));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 1, -10.0));
-        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 1, 0));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 1, 0.0));
-        ASSERT_EQUALS(true, library.isIntArgValid(tokenList.front(), 1, 1));
-        ASSERT_EQUALS(true, library.isFloatArgValid(tokenList.front(), 1, 1.0));
-        ASSERT_EQUALS(true, library.isIntArgValid(tokenList.front(), 1, 10));
-        ASSERT_EQUALS(true, library.isFloatArgValid(tokenList.front(), 1, 10.0));
+        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 1, -10, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 1, -10.0, settingsDefault));
+        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 1, 0, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 1, 0.0, settingsDefault));
+        ASSERT_EQUALS(true, library.isIntArgValid(tokenList.front(), 1, 1, settingsDefault));
+        ASSERT_EQUALS(true, library.isFloatArgValid(tokenList.front(), 1, 1.0, settingsDefault));
+        ASSERT_EQUALS(true, library.isIntArgValid(tokenList.front(), 1, 10, settingsDefault));
+        ASSERT_EQUALS(true, library.isFloatArgValid(tokenList.front(), 1, 10.0, settingsDefault));
 
         // -7-0
-        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 2, -10));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 2, -10.0));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 2, -7.5));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 2, -7.1));
-        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 2, -7));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 2, -7.0));
-        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 2, -3));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 2, -3.0));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 2, -3.5));
-        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 2, 0));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 2, 0.0));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 2, 0.5));
-        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 2, 1));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 2, 1.0));
+        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 2, -10, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 2, -10.0, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 2, -7.5, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 2, -7.1, settingsDefault));
+        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 2, -7, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 2, -7.0, settingsDefault));
+        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 2, -3, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 2, -3.0, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 2, -3.5, settingsDefault));
+        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 2, 0, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 2, 0.0, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 2, 0.5, settingsDefault));
+        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 2, 1, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 2, 1.0, settingsDefault));
 
         // 1-5,8
-        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 3, 0));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 3, 0.0));
-        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 3, 1));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 3, 1.0));
-        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 3, 3));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 3, 3.0));
-        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 3, 5));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 3, 5.0));
-        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 3, 6));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 3, 6.0));
-        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 3, 7));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 3, 7.0));
-        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 3, 8));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 3, 8.0));
-        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 3, 9));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 3, 9.0));
+        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 3, 0, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 3, 0.0, settingsDefault));
+        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 3, 1, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 3, 1.0, settingsDefault));
+        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 3, 3, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 3, 3.0, settingsDefault));
+        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 3, 5, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 3, 5.0, settingsDefault));
+        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 3, 6, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 3, 6.0, settingsDefault));
+        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 3, 7, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 3, 7.0, settingsDefault));
+        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 3, 8, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 3, 8.0, settingsDefault));
+        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 3, 9, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 3, 9.0, settingsDefault));
 
         // -1,5
-        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 4, -10));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 4, -10.0));
-        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 4, -1));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 4, -1.0));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 4, 5.000001));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 4, 5.5));
+        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 4, -10, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 4, -10.0, settingsDefault));
+        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 4, -1, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 4, -1.0, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 4, 5.000001, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 4, 5.5, settingsDefault));
 
         // :1,5
-        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 5, -10));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 5, -10.0));
-        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 5, 1));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 5, 1.0));
-        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 5, 2));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 5, 2.0));
+        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 5, -10, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 5, -10.0, settingsDefault));
+        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 5, 1, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 5, 1.0, settingsDefault));
+        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 5, 2, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 5, 2.0, settingsDefault));
 
         // 1.5:
-        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 6, 0));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 6, 0.0));
-        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 6, 1));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 6, 1.499999));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 6, 1.5));
-        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 6, 2));
-        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 6, 10));
+        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 6, 0, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 6, 0.0, settingsDefault));
+        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 6, 1, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 6, 1.499999, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 6, 1.5, settingsDefault));
+        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 6, 2, settingsDefault));
+        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 6, 10, settingsDefault));
 
         // -6.7:-5.5,-3.3:-2.7
-        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 7, -7));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 7, -7.0));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 7, -6.7000001));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 7, -6.7));
-        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 7, -6));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 7, -6.0));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 7, -5.5));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 7, -5.4999999));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 7, -3.3000001));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 7, -3.3));
-        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 7, -3));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 7, -3.0));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 7, -2.7));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 7, -2.6999999));
-        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 7, -2));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 7, -2.0));
-        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 7, 0));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 7, 0.0));
-        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 7, 3));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 7, 3.0));
-        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 7, 6));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 7, 6.0));
+        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 7, -7, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 7, -7.0, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 7, -6.7000001, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 7, -6.7, settingsDefault));
+        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 7, -6, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 7, -6.0, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 7, -5.5, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 7, -5.4999999, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 7, -3.3000001, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 7, -3.3, settingsDefault));
+        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 7, -3, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 7, -3.0, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 7, -2.7, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 7, -2.6999999, settingsDefault));
+        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 7, -2, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 7, -2.0, settingsDefault));
+        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 7, 0, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 7, 0.0, settingsDefault));
+        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 7, 3, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 7, 3.0, settingsDefault));
+        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 7, 6, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 7, 6.0, settingsDefault));
 
         // 0.0:
-        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 8, -1));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 8, -1.0));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 8, -0.00000001));
-        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 8, 0));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 8, 0.0));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 8, 0.000000001));
-        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 8, 1));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 8, 1.0));
+        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 8, -1, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 8, -1.0, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 8, -0.00000001, settingsDefault));
+        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 8, 0, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 8, 0.0, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 8, 0.000000001, settingsDefault));
+        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 8, 1, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 8, 1.0, settingsDefault));
 
         // :2.0
-        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 9, -1));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 9, -1.0));
-        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 9, 2));
-        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 9, 2.0));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 9, 2.00000001));
-        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 9, 200));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 9, 200.0));
+        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 9, -1, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 9, -1.0, settingsDefault));
+        ASSERT_EQUALS(true,  library.isIntArgValid(tokenList.front(), 9, 2, settingsDefault));
+        ASSERT_EQUALS(true,  library.isFloatArgValid(tokenList.front(), 9, 2.0, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 9, 2.00000001, settingsDefault));
+        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 9, 200, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 9, 200.0, settingsDefault));
 
         // 0.0
-        ASSERT_EQUALS(false, library.isIntArgValid(tokenList.front(), 10, 0));
-        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 10, 0.0));
+        ASSERT_EQUALS(true, library.isIntArgValid(tokenList.front(), 10, 0, settingsDefault));
+        ASSERT_EQUALS(true, library.isFloatArgValid(tokenList.front(), 10, 0.0, settingsDefault));
+
+        // ! 0.0
+        ASSERT_EQUALS(true, library.isFloatArgValid(tokenList.front(), 11, -0.42, settingsDefault));
+        ASSERT_EQUALS(false, library.isFloatArgValid(tokenList.front(), 11, 0.0, settingsDefault));
+        ASSERT_EQUALS(true, library.isFloatArgValid(tokenList.front(), 11, 0.42, settingsDefault));
     }
 
     void function_arg_minsize() const {
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <function name=\"foo\">\n"
-                               "    <arg nr=\"1\"><minsize type=\"strlen\" arg=\"2\"/></arg>\n"
-                               "    <arg nr=\"2\"><minsize type=\"argvalue\" arg=\"3\"/></arg>\n"
-                               "    <arg nr=\"3\"/>\n"
-                               "    <arg nr=\"4\"><minsize type=\"value\" value=\"500\"/></arg>\n"
-                               "  </function>\n"
-                               "</def>";
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <function name=\"foo\">\n"
+                                   "    <arg nr=\"1\"><minsize type=\"strlen\" arg=\"2\"/></arg>\n"
+                                   "    <arg nr=\"2\"><minsize type=\"argvalue\" arg=\"3\"/></arg>\n"
+                                   "    <arg nr=\"3\"/>\n"
+                                   "    <arg nr=\"4\"><minsize type=\"value\" value=\"500\"/></arg>\n"
+                                   "    <arg nr=\"5\"><minsize type=\"value\" value=\"4\" baseType=\"int\"/></arg>\n"
+                                   "  </function>\n"
+                                   "</def>";
 
         Library library;
-        ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
+        ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
 
-        TokenList tokenList(nullptr);
-        std::istringstream istr("foo(a,b,c,d);");
-        tokenList.createTokens(istr);
+        const char code[] = "foo(a,b,c,d,e);";
+        SimpleTokenList tokenList(code);
         tokenList.front()->next()->astOperand1(tokenList.front());
 
         // arg1: type=strlen arg2
@@ -467,7 +491,7 @@ class TestLibrary : public TestFixture {
         ASSERT_EQUALS(1U, minsizes ? minsizes->size() : 1U);
         if (minsizes && minsizes->size() == 1U) {
             const Library::ArgumentChecks::MinSize &m = minsizes->front();
-            ASSERT_EQUALS(Library::ArgumentChecks::MinSize::STRLEN, m.type);
+            ASSERT_EQUALS(true, Library::ArgumentChecks::MinSize::Type::STRLEN == m.type);
             ASSERT_EQUALS(2, m.arg);
         }
 
@@ -477,7 +501,7 @@ class TestLibrary : public TestFixture {
         ASSERT_EQUALS(1U, minsizes ? minsizes->size() : 1U);
         if (minsizes && minsizes->size() == 1U) {
             const Library::ArgumentChecks::MinSize &m = minsizes->front();
-            ASSERT_EQUALS(Library::ArgumentChecks::MinSize::ARGVALUE, m.type);
+            ASSERT_EQUALS(true, Library::ArgumentChecks::MinSize::Type::ARGVALUE == m.type);
             ASSERT_EQUALS(3, m.arg);
         }
 
@@ -487,205 +511,212 @@ class TestLibrary : public TestFixture {
         ASSERT_EQUALS(1U, minsizes ? minsizes->size() : 1U);
         if (minsizes && minsizes->size() == 1U) {
             const Library::ArgumentChecks::MinSize &m = minsizes->front();
-            ASSERT_EQUALS(Library::ArgumentChecks::MinSize::VALUE, m.type);
+            ASSERT(Library::ArgumentChecks::MinSize::Type::VALUE == m.type);
             ASSERT_EQUALS(500, m.value);
+            ASSERT_EQUALS("", m.baseType);
+        }
+
+        // arg5: type=value
+        minsizes = library.argminsizes(tokenList.front(), 5);
+        ASSERT_EQUALS(true, minsizes != nullptr);
+        ASSERT_EQUALS(1U, minsizes ? minsizes->size() : 1U);
+        if (minsizes && minsizes->size() == 1U) {
+            const Library::ArgumentChecks::MinSize& m = minsizes->front();
+            ASSERT(Library::ArgumentChecks::MinSize::Type::VALUE == m.type);
+            ASSERT_EQUALS(4, m.value);
+            ASSERT_EQUALS("int", m.baseType);
         }
     }
 
     void function_namespace() const {
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <function name=\"Foo::foo,bar\">\n"
-                               "    <noreturn>false</noreturn>\n"
-                               "  </function>\n"
-                               "</def>";
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <function name=\"Foo::foo,bar\">\n"
+                                   "    <noreturn>false</noreturn>\n"
+                                   "  </function>\n"
+                                   "</def>";
 
         Library library;
-        ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
-        ASSERT_EQUALS(library.functions.size(), 2U);
-        ASSERT(library.functions.at("Foo::foo").argumentChecks.empty());
-        ASSERT(library.functions.at("bar").argumentChecks.empty());
+        ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
+        ASSERT_EQUALS(library.functions().size(), 2U);
+        ASSERT(library.functions().at("Foo::foo").argumentChecks.empty());
+        ASSERT(library.functions().at("bar").argumentChecks.empty());
 
         {
-            TokenList tokenList(nullptr);
-            std::istringstream istr("Foo::foo();");
-            tokenList.createTokens(istr);
+            const char code[] = "Foo::foo();";
+            const SimpleTokenList tokenList(code);
             ASSERT(library.isnotnoreturn(tokenList.front()->tokAt(2)));
         }
 
         {
-            TokenList tokenList(nullptr);
-            std::istringstream istr("bar();");
-            tokenList.createTokens(istr);
+            const char code[] = "bar();";
+            const SimpleTokenList tokenList(code);
             ASSERT(library.isnotnoreturn(tokenList.front()));
         }
     }
 
-    void function_method() const {
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <function name=\"CString::Format\">\n"
-                               "    <noreturn>false</noreturn>\n"
-                               "  </function>\n"
-                               "</def>";
+    void function_method() {
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <function name=\"CString::Format\">\n"
+                                   "    <noreturn>false</noreturn>\n"
+                                   "  </function>\n"
+                                   "</def>";
 
         Library library;
-        ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
-        ASSERT_EQUALS(library.functions.size(), 1U);
+        ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
+        ASSERT_EQUALS(library.functions().size(), 1U);
 
         {
-            Tokenizer tokenizer(&settings, nullptr);
-            std::istringstream istr("CString str; str.Format();");
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            const char code[] = "CString str; str.Format();";
+            ASSERT(tokenizer.tokenize(code));
             ASSERT(library.isnotnoreturn(Token::findsimplematch(tokenizer.tokens(), "Format")));
         }
 
         {
-            Tokenizer tokenizer(&settings, nullptr);
-            std::istringstream istr("HardDrive hd; hd.Format();");
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            const char code[] = "HardDrive hd; hd.Format();";
+            ASSERT(tokenizer.tokenize(code));
             ASSERT(!library.isnotnoreturn(Token::findsimplematch(tokenizer.tokens(), "Format")));
         }
     }
 
-    void function_baseClassMethod() const {
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <function name=\"Base::f\">\n"
-                               "    <arg nr=\"1\"><not-null/></arg>\n"
-                               "  </function>\n"
-                               "</def>";
+    void function_baseClassMethod() {
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <function name=\"Base::f\">\n"
+                                   "    <arg nr=\"1\"><not-null/></arg>\n"
+                                   "  </function>\n"
+                                   "</def>";
 
         Library library;
-        ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
+        ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
 
         {
-            Tokenizer tokenizer(&settings, nullptr);
-            std::istringstream istr("struct X : public Base { void dostuff() { f(0); } };");
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            const char code[] = "struct X : public Base { void dostuff() { f(0); } };";
+            ASSERT(tokenizer.tokenize(code));
             ASSERT(library.isnullargbad(Token::findsimplematch(tokenizer.tokens(), "f"),1));
         }
 
         {
-            Tokenizer tokenizer(&settings, nullptr);
-            std::istringstream istr("struct X : public Base { void dostuff() { f(1,2); } };");
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            const char code[] = "struct X : public Base { void dostuff() { f(1,2); } };";
+            ASSERT(tokenizer.tokenize(code));
             ASSERT(!library.isnullargbad(Token::findsimplematch(tokenizer.tokens(), "f"),1));
         }
     }
 
     void function_warn() const {
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <function name=\"a\">\n"
-                               "    <warn severity=\"style\" cstd=\"c99\">Message</warn>\n"
-                               "  </function>\n"
-                               "  <function name=\"b\">\n"
-                               "    <warn severity=\"performance\" cppstd=\"c++11\" reason=\"Obsolescent\" alternatives=\"c,d,e\"/>\n"
-                               "  </function>\n"
-                               "</def>";
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <function name=\"a\">\n"
+                                   "    <warn severity=\"style\" cstd=\"c99\">Message</warn>\n"
+                                   "  </function>\n"
+                                   "  <function name=\"b\">\n"
+                                   "    <warn severity=\"performance\" cppstd=\"c++11\" reason=\"Obsolescent\" alternatives=\"c,d,e\"/>\n"
+                                   "  </function>\n"
+                                   "</def>";
 
         Library library;
-        ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
+        ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
 
-        TokenList tokenList(nullptr);
-        std::istringstream istr("a(); b();");
-        tokenList.createTokens(istr);
+        const char code[] = "a(); b();";
+        const SimpleTokenList tokenList(code);
 
         const Library::WarnInfo* a = library.getWarnInfo(tokenList.front());
         const Library::WarnInfo* b = library.getWarnInfo(tokenList.front()->tokAt(4));
 
-        ASSERT_EQUALS(2, library.functionwarn.size());
+        ASSERT_EQUALS(2, library.functionwarn().size());
         ASSERT(a && b);
         if (a && b) {
             ASSERT_EQUALS("Message", a->message);
-            ASSERT_EQUALS(Severity::style, a->severity);
+            ASSERT_EQUALS_ENUM(Severity::style, a->severity);
             ASSERT_EQUALS(Standards::C99, a->standards.c);
             ASSERT_EQUALS(Standards::CPP03, a->standards.cpp);
 
             ASSERT_EQUALS("Obsolescent function 'b' called. It is recommended to use 'c', 'd' or 'e' instead.", b->message);
-            ASSERT_EQUALS(Severity::performance, b->severity);
+            ASSERT_EQUALS_ENUM(Severity::performance, b->severity);
             ASSERT_EQUALS(Standards::C89, b->standards.c);
             ASSERT_EQUALS(Standards::CPP11, b->standards.cpp);
         }
     }
 
     void memory() const {
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <memory>\n"
-                               "    <alloc>CreateX</alloc>\n"
-                               "    <dealloc>DeleteX</dealloc>\n"
-                               "  </memory>\n"
-                               "</def>";
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <memory>\n"
+                                   "    <alloc>CreateX</alloc>\n"
+                                   "    <dealloc>DeleteX</dealloc>\n"
+                                   "  </memory>\n"
+                                   "</def>";
 
         Library library;
-        ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
-        ASSERT(library.functions.empty());
+        ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
+        ASSERT(library.functions().empty());
 
-        ASSERT(Library::ismemory(library.getAllocFuncInfo("CreateX")));
-        ASSERT_EQUALS(library.allocId("CreateX"), library.deallocId("DeleteX"));
         const Library::AllocFunc* af = library.getAllocFuncInfo("CreateX");
         ASSERT(af && af->arg == -1);
+        ASSERT(Library::ismemory(af));
+        ASSERT_EQUALS(library.allocId("CreateX"), library.deallocId("DeleteX"));
         const Library::AllocFunc* df = library.getDeallocFuncInfo("DeleteX");
         ASSERT(df && df->arg == 1);
     }
     void memory2() const {
-        const char xmldata1[] = "<?xml version=\"1.0\"?>\n"
-                                "<def>\n"
-                                "  <memory>\n"
-                                "    <alloc>malloc</alloc>\n"
-                                "    <dealloc>free</dealloc>\n"
-                                "  </memory>\n"
-                                "</def>";
-        const char xmldata2[] = "<?xml version=\"1.0\"?>\n"
-                                "<def>\n"
-                                "  <memory>\n"
-                                "    <alloc>foo</alloc>\n"
-                                "    <dealloc>free</dealloc>\n"
-                                "  </memory>\n"
-                                "</def>";
+        constexpr char xmldata1[] = "<?xml version=\"1.0\"?>\n"
+                                    "<def>\n"
+                                    "  <memory>\n"
+                                    "    <alloc>malloc</alloc>\n"
+                                    "    <dealloc>free</dealloc>\n"
+                                    "  </memory>\n"
+                                    "</def>";
+        constexpr char xmldata2[] = "<?xml version=\"1.0\"?>\n"
+                                    "<def>\n"
+                                    "  <memory>\n"
+                                    "    <alloc>foo</alloc>\n"
+                                    "    <dealloc>free</dealloc>\n"
+                                    "  </memory>\n"
+                                    "</def>";
 
         Library library;
-        library.loadxmldata(xmldata1, sizeof(xmldata1));
-        library.loadxmldata(xmldata2, sizeof(xmldata2));
+        ASSERT_EQUALS(true, LibraryHelper::loadxmldata(library, xmldata1, sizeof(xmldata1)));
+        ASSERT_EQUALS(true, LibraryHelper::loadxmldata(library, xmldata2, sizeof(xmldata2)));
 
         ASSERT_EQUALS(library.deallocId("free"), library.allocId("malloc"));
         ASSERT_EQUALS(library.deallocId("free"), library.allocId("foo"));
     }
     void memory3() const {
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <memory>\n"
-                               "    <alloc arg=\"5\" init=\"false\">CreateX</alloc>\n"
-                               "    <dealloc arg=\"2\">DeleteX</dealloc>\n"
-                               "  </memory>\n"
-                               "</def>";
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <memory>\n"
+                                   "    <alloc arg=\"5\" init=\"false\">CreateX</alloc>\n"
+                                   "    <dealloc arg=\"2\">DeleteX</dealloc>\n"
+                                   "  </memory>\n"
+                                   "</def>";
 
         Library library;
-        ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
-        ASSERT(library.functions.empty());
+        ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
+        ASSERT(library.functions().empty());
 
         const Library::AllocFunc* af = library.getAllocFuncInfo("CreateX");
-        ASSERT(af && af->arg == 5);
+        ASSERT(af && af->arg == 5 && !af->initData);
         const Library::AllocFunc* df = library.getDeallocFuncInfo("DeleteX");
         ASSERT(df && df->arg == 2);
-
-        ASSERT(library.returnuninitdata.find("CreateX") != library.returnuninitdata.cend());
     }
 
     void resource() const {
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <resource>\n"
-                               "    <alloc>CreateX</alloc>\n"
-                               "    <dealloc>DeleteX</dealloc>\n"
-                               "  </resource>\n"
-                               "</def>";
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <resource>\n"
+                                   "    <alloc>CreateX</alloc>\n"
+                                   "    <dealloc>DeleteX</dealloc>\n"
+                                   "  </resource>\n"
+                                   "</def>";
 
         Library library;
-        ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
-        ASSERT(library.functions.empty());
+        ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
+        ASSERT(library.functions().empty());
 
         ASSERT(Library::isresource(library.allocId("CreateX")));
         ASSERT_EQUALS(library.allocId("CreateX"), library.deallocId("DeleteX"));
@@ -693,18 +724,18 @@ class TestLibrary : public TestFixture {
 
     void podtype() const {
         {
-            const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                                   "<def>\n"
-                                   "  <podtype name=\"s8\" sign=\"s\" size=\"1\"/>\n"
-                                   "  <podtype name=\"u8\" sign=\"u\" size=\"1\"/>\n"
-                                   "  <podtype name=\"u16\" sign=\"u\" size=\"2\"/>\n"
-                                   "  <podtype name=\"s16\" sign=\"s\" size=\"2\"/>\n"
-                                   "</def>";
+            constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                       "<def>\n"
+                                       "  <podtype name=\"s8\" sign=\"s\" size=\"1\"/>\n"
+                                       "  <podtype name=\"u8\" sign=\"u\" size=\"1\"/>\n"
+                                       "  <podtype name=\"u16\" sign=\"u\" size=\"2\"/>\n"
+                                       "  <podtype name=\"s16\" sign=\"s\" size=\"2\"/>\n"
+                                       "</def>";
             Library library;
-            ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
+            ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
             // s8
             {
-                const struct Library::PodType * const type = library.podtype("s8");
+                const Library::PodType * const type = library.podtype("s8");
                 ASSERT_EQUALS(true, type != nullptr);
                 if (type) {
                     ASSERT_EQUALS(1U, type->size);
@@ -713,7 +744,7 @@ class TestLibrary : public TestFixture {
             }
             // u8
             {
-                const struct Library::PodType * const type = library.podtype("u8");
+                const Library::PodType * const type = library.podtype("u8");
                 ASSERT_EQUALS(true, type != nullptr);
                 if (type) {
                     ASSERT_EQUALS(1U, type->size);
@@ -722,7 +753,7 @@ class TestLibrary : public TestFixture {
             }
             // u16
             {
-                const struct Library::PodType * const type = library.podtype("u16");
+                const Library::PodType * const type = library.podtype("u16");
                 ASSERT_EQUALS(true, type != nullptr);
                 if (type) {
                     ASSERT_EQUALS(2U, type->size);
@@ -731,7 +762,7 @@ class TestLibrary : public TestFixture {
             }
             // s16
             {
-                const struct Library::PodType * const type = library.podtype("s16");
+                const Library::PodType * const type = library.podtype("s16");
                 ASSERT_EQUALS(true, type != nullptr);
                 if (type) {
                     ASSERT_EQUALS(2U, type->size);
@@ -740,50 +771,55 @@ class TestLibrary : public TestFixture {
             }
             // robustness test: provide cfg without PodType
             {
-                const struct Library::PodType * const type = library.podtype("nonExistingPodType");
+                const Library::PodType * const type = library.podtype("nonExistingPodType");
                 ASSERT_EQUALS(true, type == nullptr);
             }
         }
     }
 
-    void container() const {
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <container id=\"A\" startPattern=\"std :: A &lt;\" endPattern=\"&gt; !!::\" itEndPattern=\"&gt; :: iterator\">\n"
-                               "    <type templateParameter=\"1\"/>\n"
-                               "    <size templateParameter=\"4\">\n"
-                               "      <function name=\"resize\" action=\"resize\"/>\n"
-                               "      <function name=\"clear\" action=\"clear\"/>\n"
-                               "      <function name=\"size\" yields=\"size\"/>\n"
-                               "      <function name=\"empty\" yields=\"empty\"/>\n"
-                               "      <function name=\"push_back\" action=\"push\"/>\n"
-                               "      <function name=\"pop_back\" action=\"pop\"/>\n"
-                               "    </size>\n"
-                               "    <access>\n"
-                               "      <function name=\"at\" yields=\"at_index\"/>\n"
-                               "      <function name=\"begin\" yields=\"start-iterator\"/>\n"
-                               "      <function name=\"end\" yields=\"end-iterator\"/>\n"
-                               "      <function name=\"data\" yields=\"buffer\"/>\n"
-                               "      <function name=\"c_str\" yields=\"buffer-nt\"/>\n"
-                               "      <function name=\"front\" yields=\"item\"/>\n"
-                               "      <function name=\"find\" action=\"find\"/>\n"
-                               "    </access>\n"
-                               "  </container>\n"
-                               "  <container id=\"B\" startPattern=\"std :: B &lt;\" inherits=\"A\" opLessAllowed=\"false\">\n"
-                               "    <size templateParameter=\"3\"/>\n" // Inherits all but templateParameter
-                               "  </container>\n"
-                               "  <container id=\"C\">\n"
-                               "    <type string=\"std-like\"/>\n"
-                               "    <access indexOperator=\"array-like\"/>\n"
-                               "  </container>\n"
-                               "</def>";
+    void container() {
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <container id=\"A\" startPattern=\"std :: A &lt;\" endPattern=\"&gt; !!::\" itEndPattern=\"&gt; :: iterator\">\n"
+                                   "    <type templateParameter=\"1\"/>\n"
+                                   "    <size templateParameter=\"4\">\n"
+                                   "      <function name=\"resize\" action=\"resize\"/>\n"
+                                   "      <function name=\"clear\" action=\"clear\"/>\n"
+                                   "      <function name=\"size\" yields=\"size\"/>\n"
+                                   "      <function name=\"empty\" yields=\"empty\"/>\n"
+                                   "      <function name=\"push_back\" action=\"push\"/>\n"
+                                   "      <function name=\"pop_back\" action=\"pop\"/>\n"
+                                   "    </size>\n"
+                                   "    <access>\n"
+                                   "      <function name=\"at\" yields=\"at_index\"/>\n"
+                                   "      <function name=\"begin\" yields=\"start-iterator\"/>\n"
+                                   "      <function name=\"end\" yields=\"end-iterator\"/>\n"
+                                   "      <function name=\"data\" yields=\"buffer\"/>\n"
+                                   "      <function name=\"c_str\" yields=\"buffer-nt\"/>\n"
+                                   "      <function name=\"front\" yields=\"item\"/>\n"
+                                   "      <function name=\"find\" action=\"find\"/>\n"
+                                   "      <function name=\"cfind\" action=\"find-const\"/>\n"
+                                   "    </access>\n"
+                                   "  </container>\n"
+                                   "  <container id=\"B\" startPattern=\"std :: B &lt;\" inherits=\"A\" opLessAllowed=\"false\">\n"
+                                   "    <size templateParameter=\"3\"/>\n" // Inherits all but templateParameter
+                                   "  </container>\n"
+                                   "  <container id=\"C\">\n"
+                                   "    <type string=\"std-like\"/>\n"
+                                   "    <access indexOperator=\"array-like\"/>\n"
+                                   "  </container>\n"
+                                   "  <container id=\"E\" startPattern=\"std :: E\"/>\n"
+                                   "  <container id=\"F\" startPattern=\"std :: F\" itEndPattern=\":: iterator\"/>\n"
+                                   "</def>";
 
         Library library;
-        ASSERT_EQUALS(true, Library::OK == (readLibrary(library, xmldata)).errorcode);
+        ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
 
-        Library::Container& A = library.containers["A"];
-        Library::Container& B = library.containers["B"];
-        Library::Container& C = library.containers["C"];
+        const Library::Container& A = library.containers().at("A");
+        const Library::Container& B = library.containers().at("B");
+        const Library::Container& C = library.containers().at("C");
+        const Library::Container& E = library.containers().at("E");
+        const Library::Container& F = library.containers().at("F");
 
         ASSERT_EQUALS(A.type_templateArgNo, 1);
         ASSERT_EQUALS(A.size_templateArgNo, 4);
@@ -807,6 +843,7 @@ class TestLibrary : public TestFixture {
         ASSERT_EQ(Library::Container::Action::PUSH, A.getAction("push_back"));
         ASSERT_EQ(Library::Container::Action::POP, A.getAction("pop_back"));
         ASSERT_EQ(Library::Container::Action::FIND, A.getAction("find"));
+        ASSERT_EQ(Library::Container::Action::FIND_CONST, A.getAction("cfind"));
         ASSERT_EQ(Library::Container::Action::NO_ACTION, A.getAction("foo"));
 
         ASSERT_EQUALS(B.type_templateArgNo, 1);
@@ -822,41 +859,207 @@ class TestLibrary : public TestFixture {
         ASSERT_EQUALS(C.size_templateArgNo, -1);
         ASSERT_EQUALS(C.stdStringLike, true);
         ASSERT_EQUALS(C.arrayLike_indexOp, true);
+
+        ASSERT_EQUALS(E.startPattern, "std :: E");
+        ASSERT_EQUALS(E.endPattern, "");
+        ASSERT_EQUALS(E.itEndPattern, "");
+
+        ASSERT_EQUALS(F.startPattern, "std :: F");
+        ASSERT_EQUALS(F.endPattern, "");
+        ASSERT_EQUALS(F.itEndPattern, ":: iterator");
+
+        ASSERT(!library.detectContainerOrIterator(nullptr));
+
+        {
+            SimpleTokenizer var(*this);
+            ASSERT(var.tokenize("std::A<int> a;"));
+            ASSERT_EQUALS(&A, library.detectContainer(var.tokens()));
+            ASSERT(!library.detectIterator(var.tokens()));
+            bool isIterator;
+            ASSERT_EQUALS(&A, library.detectContainerOrIterator(var.tokens(), &isIterator));
+            ASSERT(!isIterator);
+        }
+
+        {
+            SimpleTokenizer var(*this);
+            ASSERT(var.tokenize("std::A<int>::size_type a_s;"));
+            ASSERT(!library.detectContainer(var.tokens()));
+            ASSERT(!library.detectIterator(var.tokens()));
+            ASSERT(!library.detectContainerOrIterator(var.tokens()));
+        }
+
+        {
+            SimpleTokenizer var(*this);
+            ASSERT(var.tokenize("std::A<int>::iterator a_it;"));
+            ASSERT(!library.detectContainer(var.tokens()));
+            ASSERT_EQUALS(&A, library.detectIterator(var.tokens()));
+            bool isIterator;
+            ASSERT_EQUALS(&A, library.detectContainerOrIterator(var.tokens(), &isIterator));
+            ASSERT(isIterator);
+        }
+
+        {
+            SimpleTokenizer var(*this);
+            ASSERT(var.tokenize("std::B<int> b;"));
+            ASSERT_EQUALS(&B, library.detectContainer(var.tokens()));
+            ASSERT(!library.detectIterator(var.tokens()));
+            bool isIterator;
+            ASSERT_EQUALS(&B, library.detectContainerOrIterator(var.tokens(), &isIterator));
+            ASSERT(!isIterator);
+        }
+
+        {
+            SimpleTokenizer var(*this);
+            ASSERT(var.tokenize("std::B<int>::size_type b_s;"));
+            ASSERT(!library.detectContainer(var.tokens()));
+            ASSERT(!library.detectIterator(var.tokens()));
+            ASSERT(!library.detectContainerOrIterator(var.tokens()));
+        }
+
+        {
+            SimpleTokenizer var(*this);
+            ASSERT(var.tokenize("std::B<int>::iterator b_it;"));
+            ASSERT(!library.detectContainer(var.tokens()));
+            ASSERT_EQUALS(&B, library.detectIterator(var.tokens()));
+            bool isIterator;
+            ASSERT_EQUALS(&B, library.detectContainerOrIterator(var.tokens(), &isIterator));
+            ASSERT(isIterator);
+        }
+
+        {
+            SimpleTokenizer var(*this);
+            ASSERT(var.tokenize("C c;"));
+            ASSERT(!library.detectContainer(var.tokens()));
+            ASSERT(!library.detectIterator(var.tokens()));
+            ASSERT(!library.detectContainerOrIterator(var.tokens()));
+        }
+
+        {
+            SimpleTokenizer var(*this);
+            ASSERT(var.tokenize("D d;"));
+            ASSERT(!library.detectContainer(var.tokens()));
+            ASSERT(!library.detectIterator(var.tokens()));
+            ASSERT(!library.detectContainerOrIterator(var.tokens()));
+        }
+
+        {
+            SimpleTokenizer var(*this);
+            ASSERT(var.tokenize("std::E e;"));
+            ASSERT(library.detectContainer(var.tokens()));
+            ASSERT(!library.detectIterator(var.tokens()));
+            bool isIterator;
+            ASSERT_EQUALS(&E, library.detectContainerOrIterator(var.tokens(), &isIterator));
+            ASSERT(!isIterator);
+            ASSERT(!library.detectContainerOrIterator(var.tokens(), nullptr, true));
+        }
+
+        {
+            SimpleTokenizer var(*this);
+            ASSERT(var.tokenize("E e;"));
+            ASSERT(!library.detectContainer(var.tokens()));
+            ASSERT(!library.detectIterator(var.tokens()));
+            ASSERT(!library.detectContainerOrIterator(var.tokens()));
+            ASSERT_EQUALS(&E, library.detectContainerOrIterator(var.tokens(), nullptr, true));
+        }
+
+        {
+            SimpleTokenizer var(*this);
+            ASSERT(var.tokenize("std::E::iterator I;"));
+            ASSERT(!library.detectContainer(var.tokens()));
+            ASSERT(!library.detectIterator(var.tokens()));
+            ASSERT(!library.detectContainerOrIterator(var.tokens()));
+            ASSERT(!library.detectContainerOrIterator(var.tokens(), nullptr, true));
+        }
+
+        {
+            SimpleTokenizer var(*this);
+            ASSERT(var.tokenize("std::E::size_type p;"));
+            ASSERT(!library.detectContainer(var.tokens()));
+            ASSERT(!library.detectIterator(var.tokens()));
+            ASSERT(!library.detectContainerOrIterator(var.tokens()));
+            ASSERT(!library.detectContainerOrIterator(var.tokens(), nullptr, true));
+        }
+
+        {
+            SimpleTokenizer var(*this);
+            ASSERT(var.tokenize("std::F f;"));
+            ASSERT(library.detectContainer(var.tokens()));
+            ASSERT(!library.detectIterator(var.tokens()));
+            bool isIterator;
+            ASSERT_EQUALS(&F, library.detectContainerOrIterator(var.tokens(), &isIterator));
+            ASSERT(!isIterator);
+        }
+
+        {
+            SimpleTokenizer var(*this);
+            ASSERT(var.tokenize("std::F::iterator I;"));
+            ASSERT(!library.detectContainer(var.tokens()));
+            TODO_ASSERT(library.detectIterator(var.tokens()));
+            bool isIterator = false;
+            TODO_ASSERT_EQUALS(reinterpret_cast<intptr_t>(&F), 0, reinterpret_cast<intptr_t>(library.detectContainerOrIterator(var.tokens(), &isIterator)));
+            TODO_ASSERT(isIterator);
+        }
+
+        {
+            SimpleTokenizer var(*this);
+            ASSERT(var.tokenize("F::iterator I;"));
+            ASSERT(!library.detectContainer(var.tokens()));
+            ASSERT(!library.detectIterator(var.tokens()));
+            ASSERT(!library.detectContainerOrIterator(var.tokens()));
+            bool isIterator = false;
+            TODO_ASSERT_EQUALS(reinterpret_cast<intptr_t>(&F), 0, reinterpret_cast<intptr_t>(library.detectContainerOrIterator(var.tokens(), &isIterator, true)));
+            TODO_ASSERT(isIterator);
+        }
+    }
+
+#define LOADLIBERROR(...) loadLibError(__FILE__, __LINE__, __VA_ARGS__)
+    template<std::size_t size>
+    void loadLibError(const char* file, unsigned line, const char (&xmldata)[size], Library::ErrorCode errorcode) const {
+        Library library;
+        Library::Error liberr;
+        assertEquals(file, line, true, LibraryHelper::loadxmldata(library, liberr, xmldata, size-1));
+        assertEquals(file, line, true, errorcode == liberr.errorcode);
     }
 
     void version() const {
         {
-            const char xmldata [] = "<?xml version=\"1.0\"?>\n"
-                                    "<def>\n"
-                                    "</def>";
+            constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                       "<def>\n"
+                                       "</def>";
             Library library;
-            const Library::Error err = readLibrary(library, xmldata);
-            ASSERT_EQUALS(err.errorcode, Library::OK);
+            ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
         }
         {
-            const char xmldata [] = "<?xml version=\"1.0\"?>\n"
-                                    "<def format=\"1\">\n"
-                                    "</def>";
+            constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                       "<def format=\"1\">\n"
+                                       "</def>";
             Library library;
-            const Library::Error err = readLibrary(library, xmldata);
-            ASSERT_EQUALS(err.errorcode, Library::OK);
+            ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
         }
         {
-            const char xmldata [] = "<?xml version=\"1.0\"?>\n"
-                                    "<def format=\"42\">\n"
-                                    "</def>";
-            Library library;
-            const Library::Error err = readLibrary(library, xmldata);
-            ASSERT_EQUALS(err.errorcode, Library::UNSUPPORTED_FORMAT);
+            constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                       "<def format=\"42\">\n"
+                                       "</def>";
+            LOADLIBERROR(xmldata, Library::ErrorCode::UNSUPPORTED_FORMAT);
         }
     }
 
-    void loadLibError(const char xmldata [], Library::ErrorCode errorcode, const char* file, unsigned line) const {
-        Library library;
-        assertEquals(file, line, errorcode, readLibrary(library, xmldata).errorcode);
+    void containerActionToFromString() const {
+        for (uint16_t i = 0; i < static_cast<uint16_t>(Library::Container::Action::NO_ACTION); ++i) {
+            const auto a = static_cast<Library::Container::Action>(i);
+            const std::string& s = Library::Container::toString(a);
+            ASSERT_EQUALS(i, static_cast<uint16_t>(Library::Container::actionFrom(s)));
+        }
+    }
+
+    void containerYieldToFromString() const {
+        for (uint16_t i = 0; i < static_cast<uint16_t>(Library::Container::Yield::NO_YIELD); ++i) {
+            const auto y = static_cast<Library::Container::Yield>(i);
+            const std::string& s = Library::Container::toString(y);
+            ASSERT_EQUALS(i, static_cast<uint16_t>(Library::Container::yieldFrom(s)));
+        }
     }
 
-#define LOADLIBERROR(xmldata, errorcode) loadLibError(xmldata, errorcode, __FILE__, __LINE__)
 #define LOADLIB_ERROR_INVALID_RANGE(valid) LOADLIBERROR("<?xml version=\"1.0\"?>\n" \
                                                         "<def>\n" \
                                                         "<function name=\"f\">\n" \
@@ -865,40 +1068,43 @@ class TestLibrary : public TestFixture {
                                                         "</arg>\n" \
                                                         "</function>\n" \
                                                         "</def>", \
-                                                        Library::BAD_ATTRIBUTE_VALUE)
+                                                        Library::ErrorCode::BAD_ATTRIBUTE_VALUE)
 
     void loadLibErrors() const {
 
+        LOADLIBERROR("<?xml version=\"1.0\"?>",
+                     Library::ErrorCode::BAD_XML);
+
         LOADLIBERROR("<?xml version=\"1.0\"?>\n"
                      "<def>\n"
                      "   <X name=\"uint8_t,std::uint8_t\" size=\"1\"/>\n"
                      "</def>",
-                     Library::UNKNOWN_ELEMENT);
+                     Library::ErrorCode::UNKNOWN_ELEMENT);
 
         // #define without attributes
         LOADLIBERROR("<?xml version=\"1.0\"?>\n"
                      "<def>\n"
                      "  <define />\n" // no attributes provided at all
                      "</def>",
-                     Library::MISSING_ATTRIBUTE);
+                     Library::ErrorCode::MISSING_ATTRIBUTE);
 
         // #define with name but without value
         LOADLIBERROR("<?xml version=\"1.0\"?>\n"
                      "<def>\n"
                      "  <define name=\"foo\" />\n" // no value provided
                      "</def>",
-                     Library::MISSING_ATTRIBUTE);
+                     Library::ErrorCode::MISSING_ATTRIBUTE);
 
         LOADLIBERROR("<?xml version=\"1.0\"?>\n"
                      "<def>\n"
                      "  <define value=\"1\" />\n" // no name provided
                      "</def>",
-                     Library::MISSING_ATTRIBUTE);
+                     Library::ErrorCode::MISSING_ATTRIBUTE);
 
         LOADLIBERROR("<?xml version=\"1.0\"?>\n"
                      "<X>\n"
                      "</X>",
-                     Library::UNSUPPORTED_FORMAT);
+                     Library::ErrorCode::UNSUPPORTED_FORMAT);
 
         // empty range
         LOADLIB_ERROR_INVALID_RANGE("");
@@ -951,6 +1157,30 @@ class TestLibrary : public TestFixture {
         // comma followed by dot
         LOADLIB_ERROR_INVALID_RANGE("-10:0,.5:");
     }
+
+    void loadLibCombinations() const {
+        {
+            const Settings s = settingsBuilder().library("std.cfg").library("gnu.cfg").library("bsd.cfg").build();
+            ASSERT_EQUALS(s.library.defines().empty(), false);
+        }
+        {
+            const Settings s = settingsBuilder().library("std.cfg").library("microsoft_sal.cfg").build();
+            ASSERT_EQUALS(s.library.defines().empty(), false);
+        }
+        {
+            const Settings s = settingsBuilder().library("std.cfg").library("windows.cfg").library("mfc.cfg").build();
+            ASSERT_EQUALS(s.library.defines().empty(), false);
+        }
+    }
+
+    void smartpointer() const {
+        const Settings s = settingsBuilder().library("std.cfg").build();
+        const Library& library = s.library;
+
+        ASSERT(!library.detectSmartPointer(nullptr));
+
+        // TODO: add more tests
+    }
 };
 
 REGISTER_TEST(TestLibrary)
diff --git a/test/testmathlib.cpp b/test/testmathlib.cpp
index 0acc2449f12..8cbe5b50019 100644
--- a/test/testmathlib.cpp
+++ b/test/testmathlib.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,21 +16,24 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
+#include "fixture.h"
 #include "mathlib.h"
-#include "testsuite.h"
-
-struct InternalError;
+#include "standards.h"
+#include "token.h"
+#include "tokenlist.h"
 
+#include <limits>
+#include <memory>
+#include <string>
+#include <utility>
 
 class TestMathLib : public TestFixture {
 public:
-    TestMathLib() : TestFixture("TestMathLib") {
-    }
+    TestMathLib() : TestFixture("TestMathLib") {}
 
 private:
 
-    void run() OVERRIDE {
+    void run() override {
         TEST_CASE(isint);
         TEST_CASE(isbin);
         TEST_CASE(isdec);
@@ -42,27 +45,25 @@ class TestMathLib : public TestFixture {
         TEST_CASE(ispositive);
         TEST_CASE(isFloat);
         TEST_CASE(isDecimalFloat);
-        TEST_CASE(isGreater)
-        TEST_CASE(isGreaterEqual)
-        TEST_CASE(isEqual)
-        TEST_CASE(isNotEqual)
-        TEST_CASE(isLess)
-        TEST_CASE(isLessEqual)
+        TEST_CASE(isGreater);
+        TEST_CASE(isGreaterEqual);
+        TEST_CASE(isEqual);
+        TEST_CASE(isNotEqual);
+        TEST_CASE(isLess);
+        TEST_CASE(isLessEqual);
         TEST_CASE(calculate);
         TEST_CASE(calculate1);
         TEST_CASE(typesuffix);
-        TEST_CASE(toLongNumber);
+        TEST_CASE(toBigNumber);
+        TEST_CASE(toBigUNumber);
         TEST_CASE(toDoubleNumber);
         TEST_CASE(naninf);
         TEST_CASE(isNullValue);
-        TEST_CASE(incdec);
         TEST_CASE(sin);
         TEST_CASE(cos);
         TEST_CASE(tan);
         TEST_CASE(abs);
         TEST_CASE(toString);
-        TEST_CASE(characterLiteralsNormalization);
-        TEST_CASE(CPP14DigitSeparators);
     }
 
     void isGreater() const {
@@ -145,18 +146,28 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS("5.0",  MathLib::divide("25.5", "5.1"));
         ASSERT_EQUALS("7.0",  MathLib::divide("21.", "3"));
         ASSERT_EQUALS("1",    MathLib::divide("3", "2"));
-        ASSERT_THROW(MathLib::divide("123", "0"), InternalError);  // decimal zero: throw
-        ASSERT_THROW(MathLib::divide("123", "00"), InternalError); // octal zero: throw
-        ASSERT_THROW(MathLib::divide("123", "0x0"), InternalError); // hex zero: throw
-        MathLib::divide("123", "0.0f"); // float zero: don't throw
-        MathLib::divide("123", "0.0"); // double zero: don't throw
-        MathLib::divide("123", "0.0L"); // long double zero: don't throw
-        ASSERT_THROW(MathLib::divide("-9223372036854775808", "-1"), InternalError); // #4520 - out of range => throw
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::divide("123", "0"), INTERNAL, "Internal Error: Division by zero");  // decimal zero: throw
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::divide("123", "00"), INTERNAL, "Internal Error: Division by zero"); // octal zero: throw
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::divide("123", "0x0"), INTERNAL, "Internal Error: Division by zero"); // hex zero: throw
+        ASSERT_NO_THROW(MathLib::divide("123", "0.0f")); // float zero
+        ASSERT_NO_THROW(MathLib::divide("123", "0.0")); // double zero
+        ASSERT_NO_THROW(MathLib::divide("123", "0.0L")); // long double zero
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::divide("-9223372036854775808", "-1"), INTERNAL, "Internal Error: Division overflow"); // #4520 - out of range => throw
         ASSERT_EQUALS("4611686018427387904",  MathLib::divide("-9223372036854775808", "-2")); // #6679
 
 
+        // invoke for each supported action
+        ASSERT_EQUALS("3", MathLib::calculate("2", "1", '+'));
+        ASSERT_EQUALS("1", MathLib::calculate("2", "1", '-'));
+        ASSERT_EQUALS("2", MathLib::calculate("2", "1", '*'));
+        ASSERT_EQUALS("2", MathLib::calculate("2", "1", '/'));
+        ASSERT_EQUALS("0", MathLib::calculate("2", "1", '%'));
+        ASSERT_EQUALS("0", MathLib::calculate("1", "2", '&'));
+        ASSERT_EQUALS("1", MathLib::calculate("1", "1", '|'));
+        ASSERT_EQUALS("1", MathLib::calculate("0", "1", '^'));
+
         // Unknown action should throw exception
-        ASSERT_THROW(MathLib::calculate("1","2",'j'),InternalError);
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::calculate("1","2",'j'),INTERNAL, "Unexpected action 'j' in MathLib::calculate().");
     }
 
     void calculate1() const {
@@ -170,10 +181,10 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS("12.0", MathLib::calculate("12.0", "13.0", '%'));
         ASSERT_EQUALS("1.3",  MathLib::calculate("5.3",  "2.0",  '%'));
         ASSERT_EQUALS("1.7",  MathLib::calculate("18.5", "4.2",  '%'));
-        MathLib::calculate("123", "0.0", '%'); // don't throw
+        ASSERT_NO_THROW(MathLib::calculate("123", "0.0", '%'));
 #endif
 
-        ASSERT_THROW(MathLib::calculate("123", "0", '%'), InternalError); // throw
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::calculate("123", "0", '%'), INTERNAL, "Internal Error: Division by zero"); // throw
 
         ASSERT_EQUALS("0", MathLib::calculate("1", "1", '^'));
         ASSERT_EQUALS("3", MathLib::calculate("2", "1", '^'));
@@ -239,119 +250,371 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS("2ULL",  MathLib::add("1ULL", "1LLU"));
     }
 
-    void toLongNumber() const {
+    void toBigNumber() const {
+        // zero input
+        ASSERT_EQUALS(0, MathLib::toBigNumber("0"));
+        ASSERT_EQUALS(0, MathLib::toBigNumber("-0"));
+        ASSERT_EQUALS(0, MathLib::toBigNumber("+0"));
+        ASSERT_EQUALS(0, MathLib::toBigNumber("0L"));
+        ASSERT_EQUALS(0, MathLib::toBigNumber("0l"));
+        ASSERT_EQUALS(0, MathLib::toBigNumber("0LL"));
+        ASSERT_EQUALS(0, MathLib::toBigNumber("0ll"));
+        ASSERT_EQUALS(0, MathLib::toBigNumber("0U"));
+        ASSERT_EQUALS(0, MathLib::toBigNumber("0u"));
+        ASSERT_EQUALS(0, MathLib::toBigNumber("0UL"));
+        ASSERT_EQUALS(0, MathLib::toBigNumber("0ul"));
+        ASSERT_EQUALS(0, MathLib::toBigNumber("0ULL"));
+        ASSERT_EQUALS(0, MathLib::toBigNumber("0ull"));
+        ASSERT_EQUALS(0, MathLib::toBigNumber("0i64")); // Visual Studio-specific
+        ASSERT_EQUALS(0, MathLib::toBigNumber("0ui64")); // Visual Studio-specific
+
+        // TODO: needs to fail
+        //ASSERT_EQUALS(0, MathLib::toBigNumber("0lll"));
+        //ASSERT_EQUALS(0, MathLib::toBigNumber("0uu"));
+
+        ASSERT_EQUALS(1U, MathLib::toBigNumber("1U"));
+        ASSERT_EQUALS(10000U, MathLib::toBigNumber("1e4"));
+        ASSERT_EQUALS(10000U, MathLib::toBigNumber("1e4"));
+        ASSERT_EQUALS(0xFF00000000000000UL, MathLib::toBigNumber("0xFF00000000000000UL"));
+        ASSERT_EQUALS(0x0A00000000000000UL, MathLib::toBigNumber("0x0A00000000000000UL"));
+
         // from hex
-        ASSERT_EQUALS(0,      MathLib::toLongNumber("0x0"));
-        ASSERT_EQUALS(0,      MathLib::toLongNumber("-0x0"));
-        ASSERT_EQUALS(0,      MathLib::toLongNumber("+0x0"));
-        ASSERT_EQUALS(10,     MathLib::toLongNumber("0xa"));
-        ASSERT_EQUALS(10995,  MathLib::toLongNumber("0x2AF3"));
-        ASSERT_EQUALS(-10,    MathLib::toLongNumber("-0xa"));
-        ASSERT_EQUALS(-10995, MathLib::toLongNumber("-0x2AF3"));
-        ASSERT_EQUALS(10,     MathLib::toLongNumber("+0xa"));
-        ASSERT_EQUALS(10995,  MathLib::toLongNumber("+0x2AF3"));
+        ASSERT_EQUALS(0, MathLib::toBigNumber("0x0"));
+        ASSERT_EQUALS(0, MathLib::toBigNumber("-0x0"));
+        ASSERT_EQUALS(0, MathLib::toBigNumber("+0x0"));
+        ASSERT_EQUALS(10, MathLib::toBigNumber("0xa"));
+        ASSERT_EQUALS(10995, MathLib::toBigNumber("0x2AF3"));
+        ASSERT_EQUALS(-10, MathLib::toBigNumber("-0xa"));
+        ASSERT_EQUALS(-10995, MathLib::toBigNumber("-0x2AF3"));
+        ASSERT_EQUALS(10, MathLib::toBigNumber("+0xa"));
+        ASSERT_EQUALS(10995, MathLib::toBigNumber("+0x2AF3"));
 
         // from octal
-        ASSERT_EQUALS(8,    MathLib::toLongNumber("010"));
-        ASSERT_EQUALS(8,    MathLib::toLongNumber("+010"));
-        ASSERT_EQUALS(-8,   MathLib::toLongNumber("-010"));
-        ASSERT_EQUALS(125,  MathLib::toLongNumber("0175"));
-        ASSERT_EQUALS(125,  MathLib::toLongNumber("+0175"));
-        ASSERT_EQUALS(-125, MathLib::toLongNumber("-0175"));
+        ASSERT_EQUALS(8, MathLib::toBigNumber("010"));
+        ASSERT_EQUALS(8, MathLib::toBigNumber("+010"));
+        ASSERT_EQUALS(-8, MathLib::toBigNumber("-010"));
+        ASSERT_EQUALS(125, MathLib::toBigNumber("0175"));
+        ASSERT_EQUALS(125, MathLib::toBigNumber("+0175"));
+        ASSERT_EQUALS(-125, MathLib::toBigNumber("-0175"));
 
         // from binary
-        ASSERT_EQUALS(0,    MathLib::toLongNumber("0b0"));
-        ASSERT_EQUALS(1,    MathLib::toLongNumber("0b1"));
-        ASSERT_EQUALS(1,    MathLib::toLongNumber("+0b1"));
-        ASSERT_EQUALS(-1,   MathLib::toLongNumber("-0b1"));
-        ASSERT_EQUALS(215,  MathLib::toLongNumber("0b11010111"));
-        ASSERT_EQUALS(-215, MathLib::toLongNumber("-0b11010111"));
-        ASSERT_EQUALS(215,  MathLib::toLongNumber("0B11010111"));
+        ASSERT_EQUALS(0, MathLib::toBigNumber("0b0"));
+        ASSERT_EQUALS(1, MathLib::toBigNumber("0b1"));
+        ASSERT_EQUALS(1, MathLib::toBigNumber("0b1U"));
+        ASSERT_EQUALS(1, MathLib::toBigNumber("0b1L"));
+        ASSERT_EQUALS(1, MathLib::toBigNumber("0b1LU"));
+        ASSERT_EQUALS(1, MathLib::toBigNumber("0b1LL"));
+        ASSERT_EQUALS(1, MathLib::toBigNumber("0b1LLU"));
+        ASSERT_EQUALS(1, MathLib::toBigNumber("+0b1"));
+        ASSERT_EQUALS(-1, MathLib::toBigNumber("-0b1"));
+        ASSERT_EQUALS(9U, MathLib::toBigNumber("011"));
+        ASSERT_EQUALS(5U, MathLib::toBigNumber("0b101"));
+        ASSERT_EQUALS(215, MathLib::toBigNumber("0b11010111"));
+        ASSERT_EQUALS(-215, MathLib::toBigNumber("-0b11010111"));
+        ASSERT_EQUALS(215, MathLib::toBigNumber("0B11010111"));
 
         // from base 10
-        ASSERT_EQUALS(10,  MathLib::toLongNumber("10"));
-        ASSERT_EQUALS(10,  MathLib::toLongNumber("10."));
-        ASSERT_EQUALS(10,  MathLib::toLongNumber("10.0"));
-        ASSERT_EQUALS(100, MathLib::toLongNumber("10E+1"));
-        ASSERT_EQUALS(1,   MathLib::toLongNumber("10E-1"));
-        ASSERT_EQUALS(100, MathLib::toLongNumber("+10E+1"));
-        ASSERT_EQUALS(-1,  MathLib::toLongNumber("-10E-1"));
-        ASSERT_EQUALS(100, MathLib::toLongNumber("+10.E+1"));
-        ASSERT_EQUALS(-1,  MathLib::toLongNumber("-10.E-1"));
-        ASSERT_EQUALS(100, MathLib::toLongNumber("+10.0E+1"));
-        ASSERT_EQUALS(-1,  MathLib::toLongNumber("-10.0E-1"));
+        ASSERT_EQUALS(10, MathLib::toBigNumber("10"));
+        ASSERT_EQUALS(10, MathLib::toBigNumber("10."));
+        ASSERT_EQUALS(10, MathLib::toBigNumber("10.0"));
+        ASSERT_EQUALS(100, MathLib::toBigNumber("10E+1"));
+        ASSERT_EQUALS(1, MathLib::toBigNumber("10E-1"));
+        ASSERT_EQUALS(100, MathLib::toBigNumber("+10E+1"));
+        ASSERT_EQUALS(-1, MathLib::toBigNumber("-10E-1"));
+        ASSERT_EQUALS(100, MathLib::toBigNumber("+10.E+1"));
+        ASSERT_EQUALS(-1, MathLib::toBigNumber("-10.E-1"));
+        ASSERT_EQUALS(100, MathLib::toBigNumber("+10.0E+1"));
+        ASSERT_EQUALS(-1, MathLib::toBigNumber("-10.0E-1"));
 
         // from char
-        ASSERT_EQUALS((int)('A'),    MathLib::toLongNumber("'A'"));
-        ASSERT_EQUALS((int)('\x10'), MathLib::toLongNumber("'\\x10'"));
-        ASSERT_EQUALS((int)('\100'), MathLib::toLongNumber("'\\100'"));
-        ASSERT_EQUALS((int)('\200'), MathLib::toLongNumber("'\\200'"));
-#ifdef __GNUC__
-        // BEGIN Implementation-specific results
-        ASSERT_EQUALS((int)('AB'),    MathLib::toLongNumber("'AB'"));
-        ASSERT_EQUALS((int)('ABC'),    MathLib::toLongNumber("'ABC'"));
-        ASSERT_EQUALS((int)('ABCD'),    MathLib::toLongNumber("'ABCD'"));
-        ASSERT_EQUALS((int)('ABCDE'),    MathLib::toLongNumber("'ABCDE'"));
-        // END Implementation-specific results
-#endif
-        ASSERT_EQUALS((int)('\0'),   MathLib::toLongNumber("'\\0'"));
-        ASSERT_EQUALS(0x1B,   MathLib::toLongNumber("'\\e'"));
-        ASSERT_EQUALS((int)('\r'),   MathLib::toLongNumber("'\\r'"));
-        ASSERT_EQUALS((int)('\x12'), MathLib::toLongNumber("'\\x12'"));
-        // may cause some compile problems: ASSERT_EQUALS((int)('\x123'), MathLib::toLongNumber("'\\x123'"));
-        // may cause some compile problems: ASSERT_EQUALS((int)('\x1234'), MathLib::toLongNumber("'\\x1234'"));
-        ASSERT_EQUALS((int)('\3'),  MathLib::toLongNumber("'\\3'"));
-        ASSERT_EQUALS((int)('\34'),  MathLib::toLongNumber("'\\34'"));
-        ASSERT_EQUALS((int)('\034'), MathLib::toLongNumber("'\\034'"));
-        ASSERT_EQUALS((int)('\x34'), MathLib::toLongNumber("'\\x34'"));
-        ASSERT_EQUALS((int)('\134'), MathLib::toLongNumber("'\\134'"));
-        ASSERT_EQUALS((int)('\134t'), MathLib::toLongNumber("'\\134t'")); // Ticket #7452
-        ASSERT_THROW(MathLib::toLongNumber("'\\9'"), InternalError);
-        ASSERT_THROW(MathLib::toLongNumber("'\\934'"), InternalError);
-        // that is not gcc/clang encoding
-        ASSERT_EQUALS(959657011, MathLib::toLongNumber("'\\u9343'"));
-        ASSERT_EQUALS(1714631779, MathLib::toLongNumber("'\\U0001f34c'"));
+        ASSERT_EQUALS(static_cast<int>('A'), MathLib::toBigNumber("'A'"));
+        ASSERT_EQUALS(static_cast<int>('\x10'), MathLib::toBigNumber("'\\x10'"));
+        ASSERT_EQUALS(static_cast<int>('\100'), MathLib::toBigNumber("'\\100'"));
+        ASSERT_EQUALS(static_cast<int>('\200'), MathLib::toBigNumber("'\\200'"));
+        ASSERT_EQUALS(static_cast<int>(L'A'), MathLib::toBigNumber("L'A'"));
+
+        ASSERT_EQUALS(-8552249625308161526, MathLib::toBigNumber("0x89504e470d0a1a0a"));
+        ASSERT_EQUALS(-8481036456200365558, MathLib::toBigNumber("0x8a4d4e470d0a1a0a"));
+
+        // from long long
+        /*
+         * ASSERT_EQUALS(0xFF00000000000000LL, MathLib::toBigNumber("0xFF00000000000000LL"));
+         * This does not work in a portable way!
+         * While it succeeds on 32bit Visual Studio it fails on Linux 64bit because it is greater than 0x7FFFFFFFFFFFFFFF (=LLONG_MAX)
+         */
+
+        ASSERT_EQUALS(0x0A00000000000000LL, MathLib::toBigNumber("0x0A00000000000000LL"));
+
+        // min/max numeric limits
+        ASSERT_EQUALS(std::numeric_limits<long long>::min(),
+                      MathLib::toBigNumber(std::to_string(std::numeric_limits<long long>::min())));
+        ASSERT_EQUALS(std::numeric_limits<long long>::max(),
+                      MathLib::toBigNumber(std::to_string(std::numeric_limits<long long>::max())));
+        ASSERT_EQUALS(std::numeric_limits<unsigned long long>::min(),
+                      MathLib::toBigNumber(std::to_string(std::numeric_limits<unsigned long long>::min())));
+        ASSERT_EQUALS(std::numeric_limits<unsigned long long>::max(),
+                      MathLib::toBigNumber(std::to_string(std::numeric_limits<unsigned long long>::max())));
+
+        // min/max and out-of-bounds - hex
         {
-            // some unit-testing for a utility function
-            ASSERT_EQUALS(0, MathLib::characterLiteralToLongNumber(std::string()));
-            ASSERT_EQUALS(32, MathLib::characterLiteralToLongNumber(std::string(" ")));
-            ASSERT_EQUALS(538976288, MathLib::characterLiteralToLongNumber(std::string("          ")));
-            ASSERT_THROW(MathLib::characterLiteralToLongNumber(std::string("\\u")), InternalError);
+            constexpr MathLib::bigint i = 0xFFFFFFFFFFFFFFFF;
+            ASSERT_EQUALS(i, MathLib::toBigNumber(std::to_string(i)));
+            ASSERT_EQUALS(i, MathLib::toBigNumber("0xFFFFFFFFFFFFFFFF"));
+        }
+        {
+            constexpr MathLib::bigint i = -0xFFFFFFFFFFFFFFFF;
+            ASSERT_EQUALS(i, MathLib::toBigNumber(std::to_string(i)));
+            ASSERT_EQUALS(i, MathLib::toBigNumber("-0xFFFFFFFFFFFFFFFF"));
         }
 
-        ASSERT_EQUALS(-8552249625308161526, MathLib::toLongNumber("0x89504e470d0a1a0a"));
-        ASSERT_EQUALS(-8481036456200365558, MathLib::toLongNumber("0x8a4d4e470d0a1a0a"));
-        ASSERT_EQUALS(9894494448401390090ULL, MathLib::toULongNumber("0x89504e470d0a1a0a"));
-        ASSERT_EQUALS(9965707617509186058ULL, MathLib::toULongNumber("0x8a4d4e470d0a1a0a"));
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigNumber("0x10000000000000000"), INTERNAL, "Internal Error. MathLib::toBigNumber: out_of_range: 0x10000000000000000");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigNumber("-0x10000000000000000"), INTERNAL, "Internal Error. MathLib::toBigNumber: out_of_range: -0x10000000000000000");
 
+        // min/max and out-of-bounds - octal
+        {
+            constexpr MathLib::bigint i = 01777777777777777777777;
+            ASSERT_EQUALS(i, MathLib::toBigNumber(std::to_string(i)));
+            ASSERT_EQUALS(i, MathLib::toBigNumber("01777777777777777777777"));
+        }
+        {
+            constexpr MathLib::bigint i = -01777777777777777777777;
+            ASSERT_EQUALS(i, MathLib::toBigNumber(std::to_string(i)));
+            ASSERT_EQUALS(i, MathLib::toBigNumber("-01777777777777777777777"));
+        }
+
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigNumber("02000000000000000000000"), INTERNAL, "Internal Error. MathLib::toBigNumber: out_of_range: 02000000000000000000000");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigNumber("-02000000000000000000000"), INTERNAL, "Internal Error. MathLib::toBigNumber: out_of_range: -02000000000000000000000");
+
+        // min/max and out-of-range - decimal
+        {
+            constexpr MathLib::bigint i = 18446744073709551615ULL;
+            ASSERT_EQUALS(i, MathLib::toBigNumber(std::to_string(i)));
+            ASSERT_EQUALS(i, MathLib::toBigNumber("18446744073709551615"));
+        }
+        {
+            constexpr MathLib::bigint i = -18446744073709551615ULL;
+            ASSERT_EQUALS(i, MathLib::toBigNumber(std::to_string(i)));
+            ASSERT_EQUALS(i, MathLib::toBigNumber("-18446744073709551615"));
+        }
+
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigNumber("18446744073709551616"), INTERNAL, "Internal Error. MathLib::toBigNumber: out_of_range: 18446744073709551616");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigNumber("-18446744073709551616"), INTERNAL, "Internal Error. MathLib::toBigNumber: out_of_range: -18446744073709551616");
+
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigNumber("invalid"), INTERNAL, "Internal Error. MathLib::toBigNumber: invalid_argument: invalid");
+
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigNumber("1invalid"), INTERNAL, "Internal Error. MathLib::toBigNumber: input was not completely consumed: 1invalid");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigNumber("1 invalid"), INTERNAL, "Internal Error. MathLib::toBigNumber: input was not completely consumed: 1 invalid");
+
+        {
+            TokenList list{settingsDefault, Standards::Language::C};
+            list.appendFileIfNew("test.c");
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            auto *tok = new Token(list, std::move(tokensFrontBack));
+            tok->str("invalid");
+            ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigNumber(tok), INTERNAL, "Internal Error. MathLib::toBigNumber: invalid_argument: invalid");
+            ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigNumber("invalid", tok), INTERNAL, "Internal Error. MathLib::toBigNumber: invalid_argument: invalid");
+            TokenList::deleteTokens(tok);
+        }
+
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigNumber("''"), INTERNAL, "Internal Error. MathLib::toBigNumber: characterLiteralToLL('') => empty character literal");
+
+        // TODO: test binary
+        // TODO: test floating point
+
+        // TODO: test with 128-bit values
+    }
+
+    void toBigUNumber() const {
         // zero input
-        ASSERT_EQUALS(0,  MathLib::toULongNumber("0"));
-        ASSERT_EQUALS(0,  MathLib::toULongNumber("-0"));
-        ASSERT_EQUALS(0,  MathLib::toULongNumber("+0"));
-        ASSERT_EQUALS(0U, MathLib::toULongNumber("0U"));
-        ASSERT_EQUALS(0,  MathLib::toULongNumber("-0x0"));
-
-        ASSERT_EQUALS(1U,     MathLib::toULongNumber("1U"));
-        ASSERT_EQUALS(10000U, MathLib::toULongNumber("1e4"));
-        ASSERT_EQUALS(10000U, MathLib::toULongNumber("1e4"));
-        ASSERT_EQUALS(0xFF00000000000000UL, MathLib::toULongNumber("0xFF00000000000000UL"));
-        ASSERT_EQUALS(0x0A00000000000000UL, MathLib::toULongNumber("0x0A00000000000000UL"));
-        ASSERT_EQUALS(9U, MathLib::toULongNumber("011"));
-        ASSERT_EQUALS(5U, MathLib::toULongNumber("0b101"));
+        ASSERT_EQUALS(0, MathLib::toBigUNumber("0"));
+        ASSERT_EQUALS(0, MathLib::toBigUNumber("-0"));
+        ASSERT_EQUALS(0, MathLib::toBigUNumber("+0"));
+        ASSERT_EQUALS(0, MathLib::toBigUNumber("0L"));
+        ASSERT_EQUALS(0, MathLib::toBigUNumber("0l"));
+        ASSERT_EQUALS(0, MathLib::toBigUNumber("0LL"));
+        ASSERT_EQUALS(0, MathLib::toBigUNumber("0ll"));
+        ASSERT_EQUALS(0, MathLib::toBigUNumber("0U"));
+        ASSERT_EQUALS(0, MathLib::toBigUNumber("0u"));
+        ASSERT_EQUALS(0, MathLib::toBigUNumber("0UL"));
+        ASSERT_EQUALS(0, MathLib::toBigUNumber("0ul"));
+        ASSERT_EQUALS(0, MathLib::toBigUNumber("0ULL"));
+        ASSERT_EQUALS(0, MathLib::toBigUNumber("0ull"));
+        ASSERT_EQUALS(0, MathLib::toBigUNumber("0i64")); // Visual Studio-specific
+        ASSERT_EQUALS(0, MathLib::toBigUNumber("0ui64")); // Visual Studio-specific
+
+        // TODO: needs to fail
+        //ASSERT_EQUALS(0, MathLib::toBigUNumber("0lll"));
+        //ASSERT_EQUALS(0, MathLib::toBigUNumber("0uu"));
+
+        ASSERT_EQUALS(1U, MathLib::toBigUNumber("1U"));
+        ASSERT_EQUALS(10000U, MathLib::toBigUNumber("1e4"));
+        ASSERT_EQUALS(10000U, MathLib::toBigUNumber("1e4"));
+        ASSERT_EQUALS(0xFF00000000000000UL, MathLib::toBigUNumber("0xFF00000000000000UL"));
+        ASSERT_EQUALS(0x0A00000000000000UL, MathLib::toBigUNumber("0x0A00000000000000UL"));
+
+        // from hex
+        ASSERT_EQUALS(0, MathLib::toBigUNumber("0x0"));
+        ASSERT_EQUALS(0, MathLib::toBigUNumber("-0x0"));
+        ASSERT_EQUALS(0, MathLib::toBigUNumber("+0x0"));
+        ASSERT_EQUALS(10, MathLib::toBigUNumber("0xa"));
+        ASSERT_EQUALS(10995, MathLib::toBigUNumber("0x2AF3"));
+        ASSERT_EQUALS(-10, MathLib::toBigUNumber("-0xa"));
+        ASSERT_EQUALS(-10995, MathLib::toBigUNumber("-0x2AF3"));
+        ASSERT_EQUALS(10, MathLib::toBigUNumber("+0xa"));
+        ASSERT_EQUALS(10995, MathLib::toBigUNumber("+0x2AF3"));
+
+        // from octal
+        ASSERT_EQUALS(8, MathLib::toBigUNumber("010"));
+        ASSERT_EQUALS(8, MathLib::toBigUNumber("+010"));
+        ASSERT_EQUALS(-8, MathLib::toBigUNumber("-010"));
+        ASSERT_EQUALS(125, MathLib::toBigUNumber("0175"));
+        ASSERT_EQUALS(125, MathLib::toBigUNumber("+0175"));
+        ASSERT_EQUALS(-125, MathLib::toBigUNumber("-0175"));
+
+        // from binary
+        ASSERT_EQUALS(0, MathLib::toBigUNumber("0b0"));
+        ASSERT_EQUALS(1, MathLib::toBigUNumber("0b1"));
+        ASSERT_EQUALS(1, MathLib::toBigUNumber("0b1U"));
+        ASSERT_EQUALS(1, MathLib::toBigUNumber("0b1L"));
+        ASSERT_EQUALS(1, MathLib::toBigUNumber("0b1LU"));
+        ASSERT_EQUALS(1, MathLib::toBigUNumber("0b1LL"));
+        ASSERT_EQUALS(1, MathLib::toBigUNumber("0b1LLU"));
+        ASSERT_EQUALS(1, MathLib::toBigUNumber("+0b1"));
+        ASSERT_EQUALS(-1, MathLib::toBigUNumber("-0b1"));
+        ASSERT_EQUALS(9U, MathLib::toBigUNumber("011"));
+        ASSERT_EQUALS(5U, MathLib::toBigUNumber("0b101"));
+        ASSERT_EQUALS(215, MathLib::toBigUNumber("0b11010111"));
+        ASSERT_EQUALS(-215, MathLib::toBigUNumber("-0b11010111"));
+        ASSERT_EQUALS(215, MathLib::toBigUNumber("0B11010111"));
+
+        // from base 10
+        ASSERT_EQUALS(10, MathLib::toBigUNumber("10"));
+        ASSERT_EQUALS(10, MathLib::toBigUNumber("10."));
+        ASSERT_EQUALS(10, MathLib::toBigUNumber("10.0"));
+        ASSERT_EQUALS(100, MathLib::toBigUNumber("10E+1"));
+        ASSERT_EQUALS(1, MathLib::toBigUNumber("10E-1"));
+        ASSERT_EQUALS(100, MathLib::toBigUNumber("+10E+1"));
+        ASSERT_EQUALS(-1, MathLib::toBigUNumber("-10E-1"));
+        ASSERT_EQUALS(100, MathLib::toBigUNumber("+10.E+1"));
+        ASSERT_EQUALS(-1, MathLib::toBigUNumber("-10.E-1"));
+        ASSERT_EQUALS(100, MathLib::toBigUNumber("+10.0E+1"));
+        ASSERT_EQUALS(-1, MathLib::toBigUNumber("-10.0E-1"));
+
+        // from char
+        ASSERT_EQUALS(static_cast<int>('A'), MathLib::toBigUNumber("'A'"));
+        ASSERT_EQUALS(static_cast<int>('\x10'), MathLib::toBigUNumber("'\\x10'"));
+        ASSERT_EQUALS(static_cast<int>('\100'), MathLib::toBigUNumber("'\\100'"));
+        ASSERT_EQUALS(static_cast<int>('\200'), MathLib::toBigUNumber("'\\200'"));
+        ASSERT_EQUALS(static_cast<int>(L'A'), MathLib::toBigUNumber("L'A'"));
+
+        ASSERT_EQUALS(9894494448401390090ULL, MathLib::toBigUNumber("0x89504e470d0a1a0a"));
+        ASSERT_EQUALS(9965707617509186058ULL, MathLib::toBigUNumber("0x8a4d4e470d0a1a0a"));
 
         // from long long
         /*
-         * ASSERT_EQUALS(0xFF00000000000000LL, MathLib::toLongNumber("0xFF00000000000000LL"));
+         * ASSERT_EQUALS(0xFF00000000000000LL, MathLib::toBigUNumber("0xFF00000000000000LL"));
          * This does not work in a portable way!
          * While it succeeds on 32bit Visual Studio it fails on Linux 64bit because it is greater than 0x7FFFFFFFFFFFFFFF (=LLONG_MAX)
          */
 
-        ASSERT_EQUALS(0x0A00000000000000LL, MathLib::toLongNumber("0x0A00000000000000LL"));
+        ASSERT_EQUALS(0x0A00000000000000LL, MathLib::toBigUNumber("0x0A00000000000000LL"));
+
+        // min/max numeric limits
+        ASSERT_EQUALS(std::numeric_limits<long long>::min(),
+                      MathLib::toBigUNumber(std::to_string(std::numeric_limits<long long>::min())));
+        ASSERT_EQUALS(std::numeric_limits<long long>::max(),
+                      MathLib::toBigUNumber(std::to_string(std::numeric_limits<long long>::max())));
+        ASSERT_EQUALS(std::numeric_limits<unsigned long long>::min(),
+                      MathLib::toBigUNumber(std::to_string(std::numeric_limits<unsigned long long>::min())));
+        ASSERT_EQUALS(std::numeric_limits<unsigned long long>::max(),
+                      MathLib::toBigUNumber(std::to_string(std::numeric_limits<unsigned long long>::max())));
+
+        // min/max and out-of-bounds - hex
+        {
+            constexpr MathLib::biguint u = 0xFFFFFFFFFFFFFFFF;
+            ASSERT_EQUALS(u, MathLib::toBigUNumber(std::to_string(u)));
+            ASSERT_EQUALS(u, MathLib::toBigUNumber("0xFFFFFFFFFFFFFFFF"));
+        }
+        {
+            constexpr MathLib::biguint u = -0xFFFFFFFFFFFFFFFF;
+            ASSERT_EQUALS(u, MathLib::toBigUNumber(std::to_string(u)));
+            ASSERT_EQUALS(u, MathLib::toBigUNumber("-0xFFFFFFFFFFFFFFFF"));
+        }
+
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigUNumber("0x10000000000000000"), INTERNAL, "Internal Error. MathLib::toBigUNumber: out_of_range: 0x10000000000000000");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigUNumber("-0x10000000000000000"), INTERNAL, "Internal Error. MathLib::toBigUNumber: out_of_range: -0x10000000000000000");
+
+        // min/max and out-of-bounds - octal
+        {
+            constexpr MathLib::biguint u = 01777777777777777777777;
+            ASSERT_EQUALS(u, MathLib::toBigUNumber(std::to_string(u)));
+            ASSERT_EQUALS(u, MathLib::toBigUNumber("01777777777777777777777"));
+        }
+        {
+            constexpr MathLib::biguint u = -01777777777777777777777;
+            ASSERT_EQUALS(u, MathLib::toBigUNumber(std::to_string(u)));
+            ASSERT_EQUALS(u, MathLib::toBigUNumber("-01777777777777777777777"));
+        }
+
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigUNumber("02000000000000000000000"), INTERNAL, "Internal Error. MathLib::toBigUNumber: out_of_range: 02000000000000000000000");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigUNumber("-02000000000000000000000"), INTERNAL, "Internal Error. MathLib::toBigUNumber: out_of_range: -02000000000000000000000");
+
+        // min/max and out-of-range - decimal
+        {
+            constexpr MathLib::biguint u = 18446744073709551615ULL;
+            ASSERT_EQUALS(u, MathLib::toBigUNumber(std::to_string(u)));
+            ASSERT_EQUALS(u, MathLib::toBigUNumber("18446744073709551615"));
+        }
+        {
+            constexpr MathLib::biguint u = -18446744073709551615ULL;
+            ASSERT_EQUALS(u, MathLib::toBigUNumber(std::to_string(u)));
+            ASSERT_EQUALS(u, MathLib::toBigUNumber("-18446744073709551615"));
+        }
+
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigUNumber("18446744073709551616"), INTERNAL, "Internal Error. MathLib::toBigUNumber: out_of_range: 18446744073709551616");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigUNumber("-18446744073709551616"), INTERNAL, "Internal Error. MathLib::toBigUNumber: out_of_range: -18446744073709551616");
+
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigUNumber("invalid"), INTERNAL, "Internal Error. MathLib::toBigUNumber: invalid_argument: invalid");
+
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigUNumber("1invalid"), INTERNAL, "Internal Error. MathLib::toBigUNumber: input was not completely consumed: 1invalid");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigUNumber("1 invalid"), INTERNAL, "Internal Error. MathLib::toBigUNumber: input was not completely consumed: 1 invalid");
+
+        {
+            TokenList list{settingsDefault, Standards::Language::C};
+            list.appendFileIfNew("test.c");
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            auto *tok = new Token(list, std::move(tokensFrontBack));
+            tok->str("invalid");
+            ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigUNumber(tok), INTERNAL, "Internal Error. MathLib::toBigUNumber: invalid_argument: invalid");
+            ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigUNumber("invalid", tok), INTERNAL, "Internal Error. MathLib::toBigUNumber: invalid_argument: invalid");
+            TokenList::deleteTokens(tok);
+        }
+
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toBigUNumber("''"), INTERNAL, "Internal Error. MathLib::toBigUNumber: characterLiteralToLL('') => empty character literal");
+
+        // TODO: test binary
+        // TODO: test floating point
+
+        // TODO: test with 128-bit values
     }
 
     void toDoubleNumber() const {
+        // float values
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1."),       0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1.f"),      0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1.F"),      0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1.l"),      0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1.L"),      0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1.0"),      0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1.0f"),     0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1.0F"),     0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1.0l"),     0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1.0L"),     0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("0x1"),      0.001);
         ASSERT_EQUALS_DOUBLE(10.0,   MathLib::toDoubleNumber("10"),       0.001);
         ASSERT_EQUALS_DOUBLE(1000.0, MathLib::toDoubleNumber("10E+2"),    0.001);
+        ASSERT_EQUALS_DOUBLE(1000.0, MathLib::toDoubleNumber("10E+2l"),   0.001);
+        ASSERT_EQUALS_DOUBLE(1000.0, MathLib::toDoubleNumber("10E+2L"),   0.001);
         ASSERT_EQUALS_DOUBLE(100.0,  MathLib::toDoubleNumber("1.0E+2"),   0.001);
         ASSERT_EQUALS_DOUBLE(-100.0, MathLib::toDoubleNumber("-1.0E+2"),  0.001);
         ASSERT_EQUALS_DOUBLE(-1e+10, MathLib::toDoubleNumber("-1.0E+10"), 1);
@@ -359,6 +622,27 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS_DOUBLE(1e+10,  MathLib::toDoubleNumber("+1.0E+10"), 1);
         ASSERT_EQUALS_DOUBLE(100.0,  MathLib::toDoubleNumber("1.0E+2"),   0.001);
         ASSERT_EQUALS_DOUBLE(1e+10,  MathLib::toDoubleNumber("1.0E+10"),  1);
+
+        // valid non-float values
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1"),        0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1l"),       0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1L"),       0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1ll"),      0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1LL"),      0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1u"),       0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1U"),       0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1ul"),      0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1UL"),      0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1ULL"),     0.001);
+        // TODO: make these work with libc++
+#ifndef _LIBCPP_VERSION
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1i64"),     0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1I64"),     0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1ui64"),    0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1UI64"),    0.001);
+        ASSERT_EQUALS_DOUBLE(1.0,    MathLib::toDoubleNumber("1I64"),     0.001);
+#endif
+
         ASSERT_EQUALS_DOUBLE(0.0,    MathLib::toDoubleNumber("0E+0"),     0.000001);
         ASSERT_EQUALS_DOUBLE(0.0,    MathLib::toDoubleNumber("0E-0"),     0.000001);
         ASSERT_EQUALS_DOUBLE(0.0,    MathLib::toDoubleNumber("0E+00"),    0.000001);
@@ -375,6 +659,7 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS_DOUBLE(0.0,    MathLib::toDoubleNumber("-0.0"),     0.000001);
         ASSERT_EQUALS_DOUBLE(0.0,    MathLib::toDoubleNumber("+0.0"),     0.000001);
         ASSERT_EQUALS_DOUBLE('0',    MathLib::toDoubleNumber("'0'"),      0.000001);
+        ASSERT_EQUALS_DOUBLE(L'0',   MathLib::toDoubleNumber("L'0'"),     0.000001);
 
         ASSERT_EQUALS_DOUBLE(192, MathLib::toDoubleNumber("0x0.3p10"), 0.000001);
         ASSERT_EQUALS_DOUBLE(5.42101e-20, MathLib::toDoubleNumber("0x1p-64"), 1e-20);
@@ -385,7 +670,61 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS_DOUBLE(9.0, MathLib::toDoubleNumber("0x1.2P3"), 0.000001);
         ASSERT_EQUALS_DOUBLE(0.0625, MathLib::toDoubleNumber("0x.1P0"), 0.000001);
 
+        // from char
+        ASSERT_EQUALS_DOUBLE(static_cast<double>('A'),    MathLib::toDoubleNumber("'A'"), 0.000001);
+        ASSERT_EQUALS_DOUBLE(static_cast<double>('\x10'), MathLib::toDoubleNumber("'\\x10'"), 0.000001);
+        ASSERT_EQUALS_DOUBLE(static_cast<double>('\100'), MathLib::toDoubleNumber("'\\100'"), 0.000001);
+        ASSERT_EQUALS_DOUBLE(static_cast<double>('\200'), MathLib::toDoubleNumber("'\\200'"), 0.000001);
+        ASSERT_EQUALS_DOUBLE(static_cast<double>(L'A'),   MathLib::toDoubleNumber("L'A'"), 0.000001);
+
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("invalid"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: conversion failed: invalid");
+
+        // AppleClang before 18 reports a different error
+#if (defined(__APPLE__) && defined(__MACH__)) && (defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION < 180000))
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1invalid"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: conversion failed: 1invalid");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1.1invalid"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: conversion failed: 1.1invalid");
+#else
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1invalid"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1invalid");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1.1invalid"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1.1invalid");
+#endif
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1 invalid"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1 invalid");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("-1e-08.0"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: -1e-08.0");
+
+        // invalid suffices
+#ifdef _LIBCPP_VERSION
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1f"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: conversion failed: 1f");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1F"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: conversion failed: 1F");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1.ff"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: conversion failed: 1.ff");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1.FF"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: conversion failed: 1.FF");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1.0ff"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: conversion failed: 1.0ff");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1.0FF"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: conversion failed: 1.0FF");
+#else
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1f"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1f");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1F"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1F");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1.ff"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1.ff");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1.FF"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1.FF");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1.0ff"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1.0ff");
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1.0FF"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1.0FF");
+#endif
+        // TODO: needs to fail
+        //ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1.ll"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1.ll");
+        //ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1.0LL"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1.0LL");
+        //ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1.0ll"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1.0ll");
+        //ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("1.0LL"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: input was not completely consumed: 1.0LL");
+
+        {
+            TokenList list{settingsDefault, Standards::Language::C};
+            list.appendFileIfNew("test.c");
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            auto *tok = new Token(list, std::move(tokensFrontBack));
+            tok->str("invalid");
+            ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber(tok), INTERNAL, "Internal Error. MathLib::toDoubleNumber: conversion failed: invalid");
+            ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("invalid", tok), INTERNAL, "Internal Error. MathLib::toDoubleNumber: conversion failed: invalid");
+            TokenList::deleteTokens(tok);
+        }
+
         // verify: string --> double --> string conversion
+        // TODO: add L, min/max
         ASSERT_EQUALS("1.0",  MathLib::toString(MathLib::toDoubleNumber("1.0f")));
         ASSERT_EQUALS("1.0",  MathLib::toString(MathLib::toDoubleNumber("1.0")));
         ASSERT_EQUALS("0.0",  MathLib::toString(MathLib::toDoubleNumber("0.0f")));
@@ -401,6 +740,8 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS("0.0",  MathLib::toString(MathLib::toDoubleNumber("-0")));
         ASSERT_EQUALS("0.0",  MathLib::toString(MathLib::toDoubleNumber("-0.")));
         ASSERT_EQUALS("0.0",  MathLib::toString(MathLib::toDoubleNumber("-0.0")));
+
+        ASSERT_THROW_INTERNAL_EQUALS(MathLib::toDoubleNumber("''"), INTERNAL, "Internal Error. MathLib::toDoubleNumber: characterLiteralToLL('') => empty character literal");
     }
 
     void isint() const {
@@ -668,6 +1009,14 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS(true, MathLib::isIntHex("-0x0ULL"));
         ASSERT_EQUALS(true, MathLib::isIntHex("+0x0LLU"));
         ASSERT_EQUALS(true, MathLib::isIntHex("-0x0LLU"));
+        ASSERT_EQUALS(true, MathLib::isIntHex("+0x0Z"));
+        ASSERT_EQUALS(true, MathLib::isIntHex("-0x0Z"));
+        ASSERT_EQUALS(true, MathLib::isIntHex("+0x0ZU"));
+        ASSERT_EQUALS(true, MathLib::isIntHex("-0x0ZU"));
+        ASSERT_EQUALS(true, MathLib::isIntHex("+0x0UZ"));
+        ASSERT_EQUALS(true, MathLib::isIntHex("-0x0UZ"));
+        ASSERT_EQUALS(true, MathLib::isIntHex("+0x0Uz"));
+        ASSERT_EQUALS(true, MathLib::isIntHex("-0x0Uz"));
 
         // negative testing
         ASSERT_EQUALS(false, MathLib::isIntHex("+0x"));
@@ -680,10 +1029,6 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS(false, MathLib::isIntHex("  "));
         ASSERT_EQUALS(false, MathLib::isIntHex(" "));
         ASSERT_EQUALS(false, MathLib::isIntHex("0"));
-        ASSERT_EQUALS(false, MathLib::isIntHex("+0x0Z"));
-        ASSERT_EQUALS(false, MathLib::isIntHex("-0x0Z"));
-        ASSERT_EQUALS(false, MathLib::isIntHex("+0x0Uz"));
-        ASSERT_EQUALS(false, MathLib::isIntHex("-0x0Uz"));
         ASSERT_EQUALS(false, MathLib::isIntHex("+0x0Lz"));
         ASSERT_EQUALS(false, MathLib::isIntHex("-0x0Lz"));
         ASSERT_EQUALS(false, MathLib::isIntHex("+0x0LUz"));
@@ -709,6 +1054,7 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix(""));
         ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("ux"));
         ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("ulx"));
+        ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("uu"));
         ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("lx"));
         ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("lux"));
         ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("lll"));
@@ -725,12 +1071,19 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("u"));
         ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("ul"));
         ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("ull"));
+        ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("uz"));
         ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("l"));
         ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("lu"));
         ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("ll"));
         ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("llu"));
         ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("llU"));
         ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("LLU"));
+        ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("z"));
+        ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("Z"));
+        ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("zu"));
+        ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("UZ"));
+        ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("ZU"));
+
         // Microsoft extensions:
         ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("i64"));
         ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("I64"));
@@ -740,6 +1093,10 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("I64", false));
         ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("ui64", false));
         ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("UI64", false));
+
+        // User defined suffix literals
+        ASSERT_EQUALS(false, MathLib::isValidIntegerSuffix("_"));
+        ASSERT_EQUALS(true, MathLib::isValidIntegerSuffix("_MyUserDefinedLiteral"));
     }
 
     void ispositive() const {
@@ -764,6 +1121,13 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS(true,  MathLib::isFloat("0.f"));
         ASSERT_EQUALS(true,  MathLib::isFloat("0.f"));
         ASSERT_EQUALS(true,  MathLib::isFloat("0xA.Fp-10"));
+
+        // User defined suffix literals
+        ASSERT_EQUALS(false, MathLib::isFloat("0_"));
+        ASSERT_EQUALS(false, MathLib::isFloat("0._"));
+        ASSERT_EQUALS(false, MathLib::isFloat("0.1_"));
+        ASSERT_EQUALS(true, MathLib::isFloat("0.0_MyUserDefinedLiteral"));
+        ASSERT_EQUALS(true, MathLib::isFloat("0._MyUserDefinedLiteral"));
     }
 
     void isDecimalFloat() const {
@@ -871,6 +1235,13 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS(true, MathLib::isDecimalFloat("1.0E+1"));
         ASSERT_EQUALS(true, MathLib::isDecimalFloat("1.0E-1"));
         ASSERT_EQUALS(true, MathLib::isDecimalFloat("-1.0E+1"));
+
+        // User defined suffix literals
+        ASSERT_EQUALS(false, MathLib::isDecimalFloat("0_"));
+        ASSERT_EQUALS(false, MathLib::isDecimalFloat(".1_"));
+        ASSERT_EQUALS(false, MathLib::isDecimalFloat("0.1_"));
+        ASSERT_EQUALS(true, MathLib::isDecimalFloat("0.0_MyUserDefinedLiteral"));
+        ASSERT_EQUALS(true, MathLib::isDecimalFloat(".1_MyUserDefinedLiteral"));
     }
 
     void naninf() const {
@@ -886,7 +1257,7 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS("inf.0", MathLib::divide("3.0", "0.f")); // inf (#5875)
         ASSERT_EQUALS("-inf.0", MathLib::divide("-3.0", "0.0")); // -inf (#5142)
         ASSERT_EQUALS("-inf.0", MathLib::divide("-3.0", "0.0f")); // -inf (#5142)
-        ASSERT_EQUALS("-inf.0", MathLib::divide("-3.0", "-0.0f")); // inf (#5142)
+        ASSERT_EQUALS("inf.0", MathLib::divide("-3.0", "-0.0f")); // inf (#5142)
     }
 
     void isdec() const {
@@ -905,6 +1276,14 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS(false, MathLib::isDec("+x"));
         ASSERT_EQUALS(false, MathLib::isDec("x"));
         ASSERT_EQUALS(false, MathLib::isDec(""));
+
+        // User defined suffix literals
+        ASSERT_EQUALS(false, MathLib::isDec("0_"));
+        ASSERT_EQUALS(false, MathLib::isDec("+0_"));
+        ASSERT_EQUALS(false, MathLib::isDec("-1_"));
+        ASSERT_EQUALS(true, MathLib::isDec("0_MyUserDefinedLiteral"));
+        ASSERT_EQUALS(true, MathLib::isDec("+1_MyUserDefinedLiteral"));
+        ASSERT_EQUALS(true, MathLib::isDec("-1_MyUserDefinedLiteral"));
     }
 
     void isNullValue() const {
@@ -920,6 +1299,8 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS(true, MathLib::isNullValue("0x0"));
         ASSERT_EQUALS(true, MathLib::isNullValue("+0x0"));
         ASSERT_EQUALS(true, MathLib::isNullValue("-0x0"));
+        ASSERT_EQUALS(true, MathLib::isNullValue("+0X0"));
+        ASSERT_EQUALS(true, MathLib::isNullValue("-0X0"));
         // unsigned integer zero value
         ASSERT_EQUALS(true, MathLib::isNullValue("0U"));
         ASSERT_EQUALS(true, MathLib::isNullValue("+0U"));
@@ -978,6 +1359,8 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS(true, MathLib::isNullValue("0E0"));
         ASSERT_EQUALS(true, MathLib::isNullValue("+0E0"));
         ASSERT_EQUALS(true, MathLib::isNullValue("-0E0"));
+        ASSERT_EQUALS(true, MathLib::isNullValue("+0e0"));
+        ASSERT_EQUALS(true, MathLib::isNullValue("-0e0"));
         // integer scientific notation
         ASSERT_EQUALS(true, MathLib::isNullValue("0E1"));
         ASSERT_EQUALS(true, MathLib::isNullValue("+0E1"));
@@ -1040,6 +1423,7 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS(true, MathLib::isNullValue("-0.f"));
         // floating point scientific notation (suffix f)
         ASSERT_EQUALS(true, MathLib::isNullValue("0.0f"));
+        ASSERT_EQUALS(true, MathLib::isNullValue("0.0F"));
         ASSERT_EQUALS(true, MathLib::isNullValue("+0.0f"));
         ASSERT_EQUALS(true, MathLib::isNullValue("-0.0f"));
         // floating point scientific notation (suffix f)
@@ -1054,6 +1438,12 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS(true, MathLib::isNullValue("00.00E+1f"));
         ASSERT_EQUALS(true, MathLib::isNullValue("+00.00E+1f"));
         ASSERT_EQUALS(true, MathLib::isNullValue("-00.00E+1f"));
+        // hex float
+        ASSERT_EQUALS(true, MathLib::isNullValue("0x0p3"));
+        ASSERT_EQUALS(true, MathLib::isNullValue("0X0P3"));
+        ASSERT_EQUALS(true, MathLib::isNullValue("0X0p-3"));
+        ASSERT_EQUALS(true, MathLib::isNullValue("-0x0p3"));
+        ASSERT_EQUALS(true, MathLib::isNullValue("+0x0p3"));
 
         // binary numbers
         ASSERT_EQUALS(true, MathLib::isNullValue("0b00"));
@@ -1067,6 +1457,18 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS(false, MathLib::isNullValue("0.1"));
         ASSERT_EQUALS(false, MathLib::isNullValue("1.0"));
         ASSERT_EQUALS(false, MathLib::isNullValue("0.01"));
+        ASSERT_EQUALS(false, MathLib::isNullValue("0xF"));
+        ASSERT_EQUALS(false, MathLib::isNullValue("0XFF"));
+        ASSERT_EQUALS(false, MathLib::isNullValue("0b01"));
+        ASSERT_EQUALS(false, MathLib::isNullValue("0B01"));
+        ASSERT_EQUALS(false, MathLib::isNullValue("0x1p0"));
+        ASSERT_EQUALS(false, MathLib::isNullValue("0x1P0"));
+        ASSERT_EQUALS(false, MathLib::isNullValue("0xap0"));
+        ASSERT_EQUALS(false, MathLib::isNullValue("0xbp0"));
+        ASSERT_EQUALS(false, MathLib::isNullValue("0xcp0"));
+        ASSERT_EQUALS(false, MathLib::isNullValue("0xdp0"));
+        ASSERT_EQUALS(false, MathLib::isNullValue("0xep0"));
+        ASSERT_EQUALS(false, MathLib::isNullValue("0xfp0"));
         ASSERT_EQUALS(false, MathLib::isNullValue("-00.01e-12"));
         ASSERT_EQUALS(false, MathLib::isNullValue("-00.01e+12"));
         ASSERT_EQUALS(false, MathLib::isNullValue(""));
@@ -1074,27 +1476,7 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS(false, MathLib::isNullValue("x"));
         ASSERT_EQUALS(false, MathLib::isNullValue("garbage"));
         ASSERT_EQUALS(false, MathLib::isNullValue("UL"));
-    }
-
-    void incdec() const {
-        // increment
-        {
-            const MathLib::biguint num = ~10U;
-            const std::string op = "++";
-            const std::string strNum = MathLib::incdec(MathLib::toString(num), op);
-            const MathLib::biguint incrementedNum = MathLib::toULongNumber(strNum);
-            ASSERT_EQUALS(num + 1U, incrementedNum);
-        }
-        // decrement
-        {
-            const MathLib::biguint num = ~10U;
-            const std::string op = "--";
-            const std::string strNum = MathLib::incdec(MathLib::toString(num), op);
-            const MathLib::biguint decrementedNum = MathLib::toULongNumber(strNum);
-            ASSERT_EQUALS(num - 1U, decrementedNum);
-        }
-        // invalid operation
-        ASSERT_THROW(MathLib::incdec("1", "x"), InternalError); // throw
+        ASSERT_EQUALS(false, MathLib::isNullValue("-ENOMEM"));
     }
 
     void sin() const {
@@ -1107,64 +1489,27 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS("0.0", MathLib::tan("0"));
     }
     void abs() const {
-        ASSERT_EQUALS("0.0", MathLib::abs("0"));
-        ASSERT_EQUALS("0.0", MathLib::abs("+0"));
-        ASSERT_EQUALS("0.0", MathLib::abs("-0"));
-        ASSERT_EQUALS("1.0", MathLib::abs("+1"));
-        ASSERT_EQUALS("1.0", MathLib::abs("+1.0"));
-        ASSERT_EQUALS("1.0", MathLib::abs("-1"));
+        ASSERT_EQUALS("", MathLib::abs(""));
+        ASSERT_EQUALS("0", MathLib::abs("0"));
+        ASSERT_EQUALS("+0", MathLib::abs("+0"));
+        ASSERT_EQUALS("0", MathLib::abs("-0"));
+        ASSERT_EQUALS("+1", MathLib::abs("+1"));
+        ASSERT_EQUALS("+1.0", MathLib::abs("+1.0"));
+        ASSERT_EQUALS("1", MathLib::abs("-1"));
         ASSERT_EQUALS("1.0", MathLib::abs("-1.0"));
+        ASSERT_EQUALS("9007199254740991", MathLib::abs("9007199254740991"));
     }
 
     void toString() const {
         ASSERT_EQUALS("0.0", MathLib::toString(0.0));
         ASSERT_EQUALS("0.0", MathLib::toString(+0.0));
         ASSERT_EQUALS("0.0", MathLib::toString(-0.0));
-        // float (trailing f or F)
-        ASSERT_EQUALS("0",  MathLib::toString(+0.0f));
-        ASSERT_EQUALS("-0", MathLib::toString(-0.0F));
-        // double (tailing l or L)
-        ASSERT_EQUALS("0",  MathLib::toString(+0.0l));
-        ASSERT_EQUALS("-0", MathLib::toString(-0.0L));
-    }
 
-    void characterLiteralsNormalization() const {
-        // `A` is 0x41 and 0101
-        ASSERT_EQUALS("A", MathLib::normalizeCharacterLiteral("\\x41"));
-        ASSERT_EQUALS("A", MathLib::normalizeCharacterLiteral("\\101"));
-        // Hexa and octal numbers should not only be interpreted in byte 1
-        ASSERT_EQUALS("TESTATEST", MathLib::normalizeCharacterLiteral("TEST\\x41TEST"));
-        ASSERT_EQUALS("TESTATEST", MathLib::normalizeCharacterLiteral("TEST\\101TEST"));
-        ASSERT_EQUALS("TESTTESTA", MathLib::normalizeCharacterLiteral("TESTTEST\\x41"));
-        ASSERT_EQUALS("TESTTESTA", MathLib::normalizeCharacterLiteral("TESTTEST\\101"));
-        // Single escape sequences
-        ASSERT_EQUALS("\?", MathLib::normalizeCharacterLiteral("\\?"));
-        ASSERT_EQUALS("\'", MathLib::normalizeCharacterLiteral("\\'"));
-        // Incomplete hexa and octal sequences
-        ASSERT_THROW(MathLib::normalizeCharacterLiteral("\\"), InternalError);
-        ASSERT_THROW(MathLib::normalizeCharacterLiteral("\\x"), InternalError);
-        // No octal digit in an octal sequence
-        ASSERT_THROW(MathLib::normalizeCharacterLiteral("\\9"), InternalError);
-        // Unsupported single escape sequence
-        ASSERT_THROW(MathLib::normalizeCharacterLiteral("\\c"), InternalError);
-    }
+        ASSERT_EQUALS("1e-08", MathLib::toString(0.00000001));
+        ASSERT_EQUALS("-1e-08", MathLib::toString(-0.00000001));
 
-    void CPP14DigitSeparators() const { // Ticket #7137, #7565
-        ASSERT(MathLib::isDigitSeparator("'", 0) == false);
-        ASSERT(MathLib::isDigitSeparator("123'0;", 3));
-        ASSERT(MathLib::isDigitSeparator("foo(1'2);", 5));
-        ASSERT(MathLib::isDigitSeparator("foo(1,1'2);", 7));
-        ASSERT(MathLib::isDigitSeparator("int a=1'234-1'2-'0';", 7));
-        ASSERT(MathLib::isDigitSeparator("int a=1'234-1'2-'0';", 13));
-        ASSERT(MathLib::isDigitSeparator("int a=1'234-1'2-'0';", 16) == false);
-        ASSERT(MathLib::isDigitSeparator("int b=1+9'8;", 9));
-        ASSERT(MathLib::isDigitSeparator("if (1'2) { char c = 'c'; }", 5));
-        ASSERT(MathLib::isDigitSeparator("if (120%1'2) { char c = 'c'; }", 9));
-        ASSERT(MathLib::isDigitSeparator("if (120&1'2) { char c = 'c'; }", 9));
-        ASSERT(MathLib::isDigitSeparator("if (120|1'2) { char c = 'c'; }", 9));
-        ASSERT(MathLib::isDigitSeparator("if (120%1'2) { char c = 'c'; }", 24) == false);
-        ASSERT(MathLib::isDigitSeparator("if (120%1'2) { char c = 'c'; }", 26) == false);
-        ASSERT(MathLib::isDigitSeparator("0b0000001'0010'01110", 14));
+        ASSERT_EQUALS("2.22507385851e-308", MathLib::toString(std::numeric_limits<double>::min()));
+        ASSERT_EQUALS("1.79769313486e+308", MathLib::toString(std::numeric_limits<double>::max()));
     }
 };
 
diff --git a/test/testmemleak.cpp b/test/testmemleak.cpp
index 4467691f7f1..39f298fa923 100644
--- a/test/testmemleak.cpp
+++ b/test/testmemleak.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -15,50 +15,38 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
+
 #include "checkmemoryleak.h"
-#include "preprocessor.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "settings.h"
-#include "simplecpp.h"
-#include "standards.h"
 #include "symboldatabase.h"
-#include "testsuite.h"
 #include "token.h"
-#include "tokenize.h"
-#include "tokenlist.h"
 
+#include <cstddef>
 #include <list>
-#include <ostream>
-#include <string>
-#include <vector>
-
-struct InternalError;
-
 
-class TestMemleak : private TestFixture {
+class TestMemleak : public TestFixture {
 public:
-    TestMemleak() : TestFixture("TestMemleak") {
-    }
+    TestMemleak() : TestFixture("TestMemleak") {}
 
 private:
-    Settings settings;
-
-    void run() OVERRIDE {
+    void run() override {
         TEST_CASE(testFunctionReturnType);
         TEST_CASE(open);
     }
 
-    CheckMemoryLeak::AllocType functionReturnType(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
-
+#define functionReturnType(...) functionReturnType_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    CheckMemoryLeak::AllocType functionReturnType_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
-        const CheckMemoryLeak c(&tokenizer, this, &settings);
+        const CheckMemoryLeak c(&tokenizer, this, &settingsDefault);
 
-        return c.functionReturnType(&tokenizer.getSymbolDatabase()->scopeList.front().functionList.front());
+        return (c.functionReturnType)(&tokenizer.getSymbolDatabase()->scopeList.front().functionList.front());
     }
 
     void testFunctionReturnType() {
@@ -101,16 +89,12 @@ class TestMemleak : private TestFixture {
                             "  }\n"
                             "};\n";
 
-        // Clear the error buffer..
-        errout.str("");
-
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT(tokenizer.tokenize(code));
 
         // there is no allocation
         const Token *tok = Token::findsimplematch(tokenizer.tokens(), "ret =");
-        const CheckMemoryLeak check(&tokenizer, nullptr, &settings);
+        const CheckMemoryLeak check(&tokenizer, nullptr, &settingsDefault);
         ASSERT_EQUALS(CheckMemoryLeak::No, check.getAllocationType(tok->tokAt(2), 1));
     }
 };
@@ -123,36 +107,26 @@ REGISTER_TEST(TestMemleak)
 
 class TestMemleakInFunction : public TestFixture {
 public:
-    TestMemleakInFunction() : TestFixture("TestMemleakInFunction") {
-    }
+    TestMemleakInFunction() : TestFixture("TestMemleakInFunction") {}
 
 private:
-    Settings settings0;
-    Settings settings1;
-    Settings settings2;
-
-    void check(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
-
-        Settings *settings = &settings1;
+    const Settings settings = settingsBuilder().library("std.cfg").library("posix.cfg").build();
 
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check for memory leaks..
-        CheckMemoryLeakInFunction checkMemoryLeak(&tokenizer, settings, this);
+        CheckMemoryLeakInFunction checkMemoryLeak(&tokenizer, &settings, this);
         checkMemoryLeak.checkReallocUsage();
     }
 
 
-    void run() OVERRIDE {
-        LOAD_LIB_2(settings1.library, "std.cfg");
-        LOAD_LIB_2(settings1.library, "posix.cfg");
-        LOAD_LIB_2(settings2.library, "std.cfg");
-
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(realloc1);
         TEST_CASE(realloc2);
         TEST_CASE(realloc3);
@@ -172,7 +146,10 @@ class TestMemleakInFunction : public TestFixture {
         TEST_CASE(realloc18);
         TEST_CASE(realloc19);
         TEST_CASE(realloc20);
-        TEST_CASE(reallocarray1);
+        TEST_CASE(realloc21);
+        TEST_CASE(realloc22);
+        TEST_CASE(realloc23);
+        TEST_CASE(realloc24); // #9228
     }
 
     void realloc1() {
@@ -181,7 +158,7 @@ class TestMemleakInFunction : public TestFixture {
               "    char *a = (char *)malloc(10);\n"
               "    a = realloc(a, 100);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());
     }
 
     void realloc2() {
@@ -192,7 +169,7 @@ class TestMemleakInFunction : public TestFixture {
               "    free(a);\n"
               "}");
 
-        ASSERT_EQUALS("[test.cpp:4]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());
     }
 
     void realloc3() {
@@ -204,7 +181,7 @@ class TestMemleakInFunction : public TestFixture {
               "    free(a);\n"
               "}");
 
-        TODO_ASSERT_EQUALS("", "[test.cpp:4]: (error) Common realloc mistake: 'a' nulled but not freed upon failure\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void realloc4() {
@@ -217,8 +194,8 @@ class TestMemleakInFunction : public TestFixture {
               "}");
 
         TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Memory leak: a\n",
-                           "[test.cpp:4]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure\n",
-                           errout.str());
+                           "[test.cpp:4:10]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n",
+                           errout_str());
     }
 
     void realloc5() {
@@ -232,8 +209,8 @@ class TestMemleakInFunction : public TestFixture {
               "        free(buf);\n"
               "    else\n"
               "        free(new_buf);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void realloc7() {
@@ -246,8 +223,8 @@ class TestMemleakInFunction : public TestFixture {
               "    }\n"
               "    free(pData);\n"
               "    return true;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void realloc8() {
@@ -258,16 +235,16 @@ class TestMemleakInFunction : public TestFixture {
               "    if (!m_buf) {\n"
               "        m_buf = origBuf;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void realloc9() {
         check("void foo()\n"
               "{\n"
               "    x = realloc(x,100);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void realloc10() {
@@ -276,8 +253,8 @@ class TestMemleakInFunction : public TestFixture {
               "    pa = pb = malloc(10);\n"
               "    pa = realloc(pa, 20);"
               "    exit();\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void realloc11() {
@@ -287,8 +264,8 @@ class TestMemleakInFunction : public TestFixture {
               "    if (!p)\n"
               "        error();\n"
               "    usep(p);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void realloc12() {
@@ -299,7 +276,7 @@ class TestMemleakInFunction : public TestFixture {
               "        return;\n"
               "    free(a);\n"
               "}");
-        TODO_ASSERT_EQUALS("", "[test.cpp:4]: (error) Common realloc mistake: 'a' nulled but not freed upon failure\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void realloc13() {
@@ -309,7 +286,7 @@ class TestMemleakInFunction : public TestFixture {
               "    *str = realloc(*str,100);\n"
               "    free (*str);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Common realloc mistake: \'str\' nulled but not freed upon failure\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:6]: (error) Common realloc mistake: \'str\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());
     }
 
     void realloc14() {
@@ -319,8 +296,8 @@ class TestMemleakInFunction : public TestFixture {
               "    if (!p)\n"
               "        error();\n"
               "    usep(p);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void realloc15() {
@@ -330,8 +307,8 @@ class TestMemleakInFunction : public TestFixture {
               "    if( m_options == NULL )\n"
               "        return false;\n"
               "    return true;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Common realloc mistake: \'m_options\' nulled but not freed upon failure\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Common realloc mistake: \'m_options\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());
     }
 
     void realloc16() {
@@ -340,8 +317,8 @@ class TestMemleakInFunction : public TestFixture {
               "  if (zLine) {\n"
               "    free(zLine);\n"
               "  }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void realloc17() {
@@ -350,7 +327,7 @@ class TestMemleakInFunction : public TestFixture {
               "    void ***a = malloc(sizeof(a));\n"
               "    ***a = realloc(***(a), sizeof(a) * 2);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:8]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());
     }
 
     void realloc18() {
@@ -359,7 +336,7 @@ class TestMemleakInFunction : public TestFixture {
               "    void *a = malloc(sizeof(a));\n"
               "    a = realloc((void*)a, sizeof(a) * 2);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());
     }
 
     void realloc19() {
@@ -368,7 +345,7 @@ class TestMemleakInFunction : public TestFixture {
               "    void *a = malloc(sizeof(a));\n"
               "    a = (realloc((void*)((a)), sizeof(a) * 2));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());
     }
 
     void realloc20() {
@@ -377,16 +354,69 @@ class TestMemleakInFunction : public TestFixture {
               "    void *a = malloc(sizeof(a));\n"
               "    a = realloc((a) + 1, sizeof(a) * 2);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void reallocarray1() {
-        check("void foo()\n"
+    void realloc21() {
+        check("char *foo(char *bs0)\n"
               "{\n"
-              "    char *a = (char *)malloc(10);\n"
-              "    a = reallocarray(a, 100, 2);\n"
+              "    char *bs = bs0;\n"
+              "    bs = realloc(bs, 100);\n"
+              "    if (bs == NULL) return bs0;\n"
+              "    return bs;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void realloc22() {
+        check("void foo(char **bsp)\n"
+              "{\n"
+              "    char *bs = *bsp;\n"
+              "    bs = realloc(bs, 100);\n"
+              "    if (bs == NULL) return;\n"
+              "    *bsp = bs;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void realloc23() {
+        check("void foo(struct ABC *s)\n"
+              "{\n"
+              "    uint32_t *cigar = s->cigar;\n"
+              "    if (!(cigar = realloc(cigar, 100 * sizeof(*cigar))))\n"
+              "        return;\n"
+              "    s->cigar = cigar;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Common reallocarray mistake: \'a\' nulled but not freed upon failure\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void realloc24() { // #9228
+        check("void f() {\n"
+              "void *a = NULL;\n"
+              "a = realloc(a, 20);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "void *a = NULL;\n"
+              "a = malloc(10);\n"
+              "a = realloc(a, 20);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:1]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());
+
+        check("void f() {\n"
+              "void *a = nullptr;\n"
+              "a = malloc(10);\n"
+              "a = realloc(a, 20);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:1]: (error) Common realloc mistake: \'a\' nulled but not freed upon failure [memleakOnRealloc]\n", errout_str());
+
+        check("void f(char *b) {\n"
+              "void *a = NULL;\n"
+              "a = b;\n"
+              "a = realloc(a, 20);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 };
 
@@ -401,37 +431,28 @@ REGISTER_TEST(TestMemleakInFunction)
 
 class TestMemleakInClass : public TestFixture {
 public:
-    TestMemleakInClass() : TestFixture("TestMemleakInClass") {
-    }
+    TestMemleakInClass() : TestFixture("TestMemleakInClass") {}
 
 private:
-    Settings settings;
+    const Settings settings = settingsBuilder().severity(Severity::warning).severity(Severity::style).library("std.cfg").build();
 
     /**
      * Tokenize and execute leak check for given code
      * @param code Source code
      */
-    void check(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
-
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        tokenizer.simplifyTokenList2();
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check for memory leaks..
         CheckMemoryLeakInClass checkMemoryLeak(&tokenizer, &settings, this);
-        checkMemoryLeak.check();
+        (checkMemoryLeak.check)();
     }
 
-    void run() OVERRIDE {
-        settings.addEnabled("warning");
-        settings.addEnabled("style");
-
-        LOAD_LIB_2(settings.library, "std.cfg");
-
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(class1);
         TEST_CASE(class2);
         TEST_CASE(class3);
@@ -456,6 +477,8 @@ class TestMemleakInClass : public TestFixture {
         TEST_CASE(class23); // ticket #3303
         TEST_CASE(class24); // ticket #3806 - false positive in copy constructor
         TEST_CASE(class25); // ticket #4367 - false positive implementation for destructor is not seen
+        TEST_CASE(class26); // ticket #10789
+        TEST_CASE(class27); // ticket #8126
 
         TEST_CASE(staticvar);
 
@@ -491,7 +514,7 @@ class TestMemleakInClass : public TestFixture {
               "{\n"
               "    delete [] str2;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
         check("class Fred\n"
               "{\n"
@@ -509,7 +532,7 @@ class TestMemleakInClass : public TestFixture {
               "        delete [] str2;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
     }
 
     void class2() {
@@ -531,7 +554,7 @@ class TestMemleakInClass : public TestFixture {
               "{\n"
               "    free(str1);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:17]: (error) Mismatching allocation and deallocation: Fred::str1\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:17:5]: (error) Mismatching allocation and deallocation: Fred::str1 [mismatchAllocDealloc]\n", errout_str());
 
         check("class Fred\n"
               "{\n"
@@ -547,7 +570,7 @@ class TestMemleakInClass : public TestFixture {
               "        free(str1);\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:12]: (error) Mismatching allocation and deallocation: Fred::str1\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:12:9]: (error) Mismatching allocation and deallocation: Fred::str1 [mismatchAllocDealloc]\n", errout_str());
     }
 
     void class3() {
@@ -584,7 +607,7 @@ class TestMemleakInClass : public TestFixture {
               "    }\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Token;\n"
               "\n"
@@ -613,7 +636,7 @@ class TestMemleakInClass : public TestFixture {
               "    }\n"
               "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void class4() {
@@ -636,7 +659,7 @@ class TestMemleakInClass : public TestFixture {
               "    ABC *p = new ABC;\n"
               "    addAbc( p );\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct ABC;\n"
               "class Fred\n"
@@ -653,7 +676,7 @@ class TestMemleakInClass : public TestFixture {
               "        addAbc( p );\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void class6() {
@@ -669,7 +692,7 @@ class TestMemleakInClass : public TestFixture {
               "    delete [] str;\n"
               "    hello();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
               "{\n"
@@ -681,7 +704,7 @@ class TestMemleakInClass : public TestFixture {
               "        hello();\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void class7() {
@@ -701,7 +724,7 @@ class TestMemleakInClass : public TestFixture {
               "{\n"
               "    delete this->i;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
               "{\n"
@@ -716,7 +739,7 @@ class TestMemleakInClass : public TestFixture {
               "        delete this->i;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void class8() {
@@ -733,7 +756,7 @@ class TestMemleakInClass : public TestFixture {
               "    delete c;\n"
               "    doNothing(c);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class A\n"
               "{\n"
@@ -746,7 +769,7 @@ class TestMemleakInClass : public TestFixture {
               "    }\n"
               "    void doNothing() { }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void class9() {
@@ -763,7 +786,7 @@ class TestMemleakInClass : public TestFixture {
               "\n"
               "A::~A()\n"
               "{ delete (p); }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class A\n"
               "{\n"
@@ -774,7 +797,7 @@ class TestMemleakInClass : public TestFixture {
               "    ~A()\n"
               "    { delete (p); }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void class10() {
@@ -786,7 +809,7 @@ class TestMemleakInClass : public TestFixture {
               "};\n"
               "A::A()\n"
               "{ p = new int; }");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
         check("class A\n"
               "{\n"
@@ -794,7 +817,7 @@ class TestMemleakInClass : public TestFixture {
               "    int * p;\n"
               "    A() { p = new int; }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
     }
 
     void class11() {
@@ -805,7 +828,7 @@ class TestMemleakInClass : public TestFixture {
               "    A() : p(new int[10])\n"
               "    { }"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
         check("class A\n"
               "{\n"
@@ -815,7 +838,7 @@ class TestMemleakInClass : public TestFixture {
               "};\n"
               "A::A() : p(new int[10])\n"
               "{ }");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
     }
 
     void class12() {
@@ -837,7 +860,7 @@ class TestMemleakInClass : public TestFixture {
               "\n"
               "void A::cleanup()\n"
               "{ delete [] p; }");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
         check("class A\n"
               "{\n"
@@ -851,7 +874,7 @@ class TestMemleakInClass : public TestFixture {
               "    void cleanup()\n"
               "    { delete [] p; }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
     }
 
     void class13() {
@@ -873,7 +896,7 @@ class TestMemleakInClass : public TestFixture {
               "\n"
               "void A::foo()\n"
               "{ p = new int[10]; delete [] p; }");
-        ASSERT_EQUALS("[test.cpp:17]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:17:3]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n", errout_str());
 
         check("class A\n"
               "{\n"
@@ -887,7 +910,7 @@ class TestMemleakInClass : public TestFixture {
               "    void foo()\n"
               "    { p = new int[10]; delete [] p; }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:11]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:11:7]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n", errout_str());
     }
 
     void class14() {
@@ -900,8 +923,8 @@ class TestMemleakInClass : public TestFixture {
               "\n"
               "void A::init()\n"
               "{ p = new int[10]; }");
-        ASSERT_EQUALS("[test.cpp:9]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated.\n"
-                      "[test.cpp:3]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:3]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n"
+                      "[test.cpp:3:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
         check("class A\n"
               "{\n"
@@ -910,8 +933,8 @@ class TestMemleakInClass : public TestFixture {
               "    void init()\n"
               "    { p = new int[10]; }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:6]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated.\n"
-                      "[test.cpp:3]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:7]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n"
+                      "[test.cpp:3:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
 
         check("class A\n"
@@ -923,8 +946,8 @@ class TestMemleakInClass : public TestFixture {
               "\n"
               "void A::init()\n"
               "{ p = new int; }");
-        ASSERT_EQUALS("[test.cpp:9]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated.\n"
-                      "[test.cpp:3]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:3]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n"
+                      "[test.cpp:3:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
         check("class A\n"
               "{\n"
@@ -933,8 +956,8 @@ class TestMemleakInClass : public TestFixture {
               "    void init()\n"
               "    { p = new int; }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:6]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated.\n"
-                      "[test.cpp:3]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:7]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n"
+                      "[test.cpp:3:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
 
         check("class A\n"
@@ -946,8 +969,8 @@ class TestMemleakInClass : public TestFixture {
               "\n"
               "void A::init()\n"
               "{ p = malloc(sizeof(int)*10); }");
-        ASSERT_EQUALS("[test.cpp:9]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated.\n"
-                      "[test.cpp:3]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:3]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n"
+                      "[test.cpp:3:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
         check("class A\n"
               "{\n"
@@ -956,8 +979,8 @@ class TestMemleakInClass : public TestFixture {
               "    void init()\n"
               "    { p = malloc(sizeof(int)*10); }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:6]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated.\n"
-                      "[test.cpp:3]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:7]: (warning) Possible leak in public function. The pointer 'p' is not deallocated before it is allocated. [publicAllocationError]\n"
+                      "[test.cpp:3:10]: (style) Class 'A' is unsafe, 'A::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
     }
 
     void class15() {
@@ -970,7 +993,7 @@ class TestMemleakInClass : public TestFixture {
               "};\n"
               "A::A()\n"
               "{ p = new int[10]; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class A\n"
               "{\n"
@@ -980,7 +1003,7 @@ class TestMemleakInClass : public TestFixture {
               "    { p = new int[10]; }\n"
               "    ~A() { delete [] p; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
 
         check("class A\n"
@@ -992,7 +1015,7 @@ class TestMemleakInClass : public TestFixture {
               "};\n"
               "A::A()\n"
               "{ p = new int; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class A\n"
               "{\n"
@@ -1002,7 +1025,7 @@ class TestMemleakInClass : public TestFixture {
               "    { p = new int; }\n"
               "    ~A() { delete p; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
 
         check("class A\n"
@@ -1014,7 +1037,7 @@ class TestMemleakInClass : public TestFixture {
               "};\n"
               "A::A()\n"
               "{ p = malloc(sizeof(int)*10); }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class A\n"
               "{\n"
@@ -1024,7 +1047,7 @@ class TestMemleakInClass : public TestFixture {
               "    { p = malloc(sizeof(int)*10); }\n"
               "    ~A() { free(p); }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void class16() {
@@ -1037,7 +1060,7 @@ class TestMemleakInClass : public TestFixture {
               "    A() { a = b = new int[10]; }\n"
               "    ~A() { delete [] a; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void class17() {
@@ -1054,7 +1077,7 @@ class TestMemleakInClass : public TestFixture {
               "    A::pd = new char[12];\n"
               "    delete [] A::pd;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:10]: (warning) Possible leak in public function. The pointer 'pd' is not deallocated before it is allocated.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:5]: (warning) Possible leak in public function. The pointer 'pd' is not deallocated before it is allocated. [publicAllocationError]\n", errout_str());
 
         check("class A {\n"
               "private:\n"
@@ -1066,7 +1089,7 @@ class TestMemleakInClass : public TestFixture {
               "        delete [] pd;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:7]: (warning) Possible leak in public function. The pointer 'pd' is not deallocated before it is allocated.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:9]: (warning) Possible leak in public function. The pointer 'pd' is not deallocated before it is allocated. [publicAllocationError]\n", errout_str());
 
         check("class A {\n"
               "private:\n"
@@ -1080,7 +1103,7 @@ class TestMemleakInClass : public TestFixture {
               "    pd = new char[12];\n"
               "    delete [] pd;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:10]: (warning) Possible leak in public function. The pointer 'pd' is not deallocated before it is allocated.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:5]: (warning) Possible leak in public function. The pointer 'pd' is not deallocated before it is allocated. [publicAllocationError]\n", errout_str());
     }
 
     void class18() {
@@ -1096,7 +1119,7 @@ class TestMemleakInClass : public TestFixture {
               "private:\n"
               "  char *a;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class  A : public x\n"
               "{\n"
@@ -1110,7 +1133,7 @@ class TestMemleakInClass : public TestFixture {
               "  a = new char[10];\n"
               "  foo(a);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void class19() {
@@ -1128,7 +1151,7 @@ class TestMemleakInClass : public TestFixture {
               "    rp1 = new TRadioButton(this);\n"
               "    rp2 = new TRadioButton(this);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class TRadioButton { };\n"
               "class Foo\n"
@@ -1144,8 +1167,8 @@ class TestMemleakInClass : public TestFixture {
               "    rp1 = new TRadioButton;\n"
               "    rp2 = new TRadioButton;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (style) Class 'Foo' is unsafe, 'Foo::rp1' can leak by wrong usage.\n"
-                      "[test.cpp:6]: (style) Class 'Foo' is unsafe, 'Foo::rp2' can leak by wrong usage.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:19]: (style) Class 'Foo' is unsafe, 'Foo::rp1' can leak by wrong usage. [unsafeClassCanLeak]\n"
+                      "[test.cpp:6:19]: (style) Class 'Foo' is unsafe, 'Foo::rp2' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
         check("class TRadioButton { };\n"
               "class Foo\n"
@@ -1167,7 +1190,7 @@ class TestMemleakInClass : public TestFixture {
               "    delete rp1;\n"
               "    delete rp2;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void class20() {
@@ -1189,7 +1212,7 @@ class TestMemleakInClass : public TestFixture {
               "        }\n"
               "    };\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:15]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
         check("namespace ns1 {\n"
               "    class Fred\n"
@@ -1213,7 +1236,7 @@ class TestMemleakInClass : public TestFixture {
               "        delete [] str2;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:15]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
         check("namespace ns1 {\n"
               "    class Fred\n"
@@ -1236,7 +1259,7 @@ class TestMemleakInClass : public TestFixture {
               "{\n"
               "    delete [] str2;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:15]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
         check("namespace ns1 {\n"
               "    namespace ns2 {\n"
@@ -1261,7 +1284,7 @@ class TestMemleakInClass : public TestFixture {
               "{\n"
               "    delete [] str2;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:19]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
 
         check("namespace ns1 {\n"
               "    namespace ns2 {\n"
@@ -1288,7 +1311,7 @@ class TestMemleakInClass : public TestFixture {
               "{\n"
               "    delete [] str2;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:23]: (style) Class 'Fred' is unsafe, 'Fred::str1' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
     }
 
     void class21() { // ticket #2517
@@ -1305,8 +1328,10 @@ class TestMemleakInClass : public TestFixture {
               "public:\n"
               "    A() : b(new B()), c(new C(b)) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:9]: (style) Class 'A' is unsafe, 'A::b' can leak by wrong usage.\n"
-                      "[test.cpp:10]: (style) Class 'A' is unsafe, 'A::c' can leak by wrong usage.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:9:8]: (style) Class 'A' is unsafe, 'A::b' can leak by wrong usage. [unsafeClassCanLeak]\n"
+                           "[test.cpp:10]: (style) Class 'A' is unsafe, 'A::c' can leak by wrong usage.\n",
+                           "[test.cpp:9:8]: (style) Class 'A' is unsafe, 'A::b' can leak by wrong usage. [unsafeClassCanLeak]\n",
+                           errout_str());
 
         check("struct B { };\n"
               "struct C\n"
@@ -1325,8 +1350,10 @@ class TestMemleakInClass : public TestFixture {
               "       c = new C(b);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:9]: (style) Class 'A' is unsafe, 'A::b' can leak by wrong usage.\n"
-                      "[test.cpp:10]: (style) Class 'A' is unsafe, 'A::c' can leak by wrong usage.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:9:8]: (style) Class 'A' is unsafe, 'A::b' can leak by wrong usage. [unsafeClassCanLeak]\n"
+                           "[test.cpp:10]: (style) Class 'A' is unsafe, 'A::c' can leak by wrong usage.\n",
+                           "[test.cpp:9:8]: (style) Class 'A' is unsafe, 'A::b' can leak by wrong usage. [unsafeClassCanLeak]\n",
+                           errout_str());
     }
 
     void class22() { // ticket #3012 - false positive
@@ -1337,7 +1364,7 @@ class TestMemleakInClass : public TestFixture {
               "    Fred() { a = new int; }\n"
               "    ~Fred() { (delete(a), (a)=NULL); }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void class23() { // ticket #3303 - false positive
@@ -1356,7 +1383,7 @@ class TestMemleakInClass : public TestFixture {
               "private:\n"
               "    CDataImpl *m_impl;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void class24() { // ticket #3806 - false positive in copy constructor
@@ -1367,7 +1394,7 @@ class TestMemleakInClass : public TestFixture {
               "    Fred(const Fred &fred) { a = new int; }\n"
               "    ~Fred() { delete a; }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void class25() { // ticket #4367 - false positive when implementation for destructor is not seen
@@ -1378,7 +1405,29 @@ class TestMemleakInClass : public TestFixture {
               "    Fred() { a = new int; }\n"
               "    ~Fred();\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void class26() { // ticket #10789 - crash
+        check("class C;\n"
+              "struct S {\n"
+              "    S() { p = new C; }\n"
+              "    ~S();\n"
+              "    C* p;\n"
+              "};\n"
+              "S::~S() = default;\n");
+        ASSERT_EQUALS("[test.cpp:5:8]: (style) Class 'S' is unsafe, 'S::p' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
+    }
+
+    void class27() { // ticket #8126 - array of pointers
+        check("struct S {\n"
+              "    S() {\n"
+              "        for (int i = 0; i < 5; i++)\n"
+              "            a[i] = new char[3];\n"
+              "    }\n"
+              "    char* a[5];\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:6:11]: (style) Class 'S' is unsafe, 'S::a' can leak by wrong usage. [unsafeClassCanLeak]\n", errout_str());
     }
 
     void staticvar() {
@@ -1393,7 +1442,7 @@ class TestMemleakInClass : public TestFixture {
               "            p = new int[100];\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -1425,7 +1474,7 @@ class TestMemleakInClass : public TestFixture {
               "{\n"
               "    delete tok;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Global function
         check("void deleteTokens(int *tok)\n"
@@ -1452,7 +1501,7 @@ class TestMemleakInClass : public TestFixture {
               "    deleteTokens(_tokens);\n"
               "    _tokens = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void mismatch1() {
@@ -1477,7 +1526,19 @@ class TestMemleakInClass : public TestFixture {
               "A::~A() {\n"
               "    delete [] pkt_buffer;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:14]: (error) Mismatching allocation and deallocation: A::pkt_buffer\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:14:9]: (error) Mismatching allocation and deallocation: A::pkt_buffer [mismatchAllocDealloc]\n", errout_str());
+
+        check("struct S {\n" // 5678
+              "    ~S();\n"
+              "    void f();\n"
+              "    int* p;\n"
+              "};\n"
+              "void S::f() {\n"
+              "    p = new char[1];\n"
+              "    delete p;\n"
+              "    p = 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:8:5]: (error) Mismatching allocation and deallocation: S::p [mismatchAllocDealloc]\n", errout_str());
     }
 
     void mismatch2() { // #5659
@@ -1500,9 +1561,9 @@ class TestMemleakInClass : public TestFixture {
               "  data_ = new char[42];\n"
               "  delete data_;\n"
               "  data_ = 0;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:17]: (warning) Possible leak in public function. The pointer 'data_' is not deallocated before it is allocated.\n"
-                      "[test.cpp:18]: (error) Mismatching allocation and deallocation: Foo::data_\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:17:3]: (warning) Possible leak in public function. The pointer 'data_' is not deallocated before it is allocated. [publicAllocationError]\n"
+                      "[test.cpp:18:3]: (error) Mismatching allocation and deallocation: Foo::data_ [mismatchAllocDealloc]\n", errout_str());
 
         check("namespace NS\n"
               "{\n"
@@ -1523,9 +1584,9 @@ class TestMemleakInClass : public TestFixture {
               "  data_ = new char[42];\n"
               "  delete data_;\n"
               "  data_ = 0;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:17]: (warning) Possible leak in public function. The pointer 'data_' is not deallocated before it is allocated.\n"
-                      "[test.cpp:18]: (error) Mismatching allocation and deallocation: Foo::data_\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:17:3]: (warning) Possible leak in public function. The pointer 'data_' is not deallocated before it is allocated. [publicAllocationError]\n"
+                      "[test.cpp:18:3]: (error) Mismatching allocation and deallocation: Foo::data_ [mismatchAllocDealloc]\n", errout_str());
     }
 
     void func1() {
@@ -1539,7 +1600,7 @@ class TestMemleakInClass : public TestFixture {
               "    void xy()\n"
               "    { s = malloc(100); }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:9]: (warning) Possible leak in public function. The pointer 's' is not deallocated before it is allocated.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:7]: (warning) Possible leak in public function. The pointer 's' is not deallocated before it is allocated. [publicAllocationError]\n", errout_str());
 
         check("class Fred\n"
               "{\n"
@@ -1551,7 +1612,7 @@ class TestMemleakInClass : public TestFixture {
               "private:\n"
               "    char *s;\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:7]: (warning) Possible leak in public function. The pointer 's' is not deallocated before it is allocated.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:7]: (warning) Possible leak in public function. The pointer 's' is not deallocated before it is allocated. [publicAllocationError]\n", errout_str());
     }
 
     void func2() {
@@ -1565,7 +1626,7 @@ class TestMemleakInClass : public TestFixture {
               "    const Fred & operator = (const Fred &f)\n"
               "    { s = malloc(100); }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:9]: (warning) Possible leak in public function. The pointer 's' is not deallocated before it is allocated.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:7]: (warning) Possible leak in public function. The pointer 's' is not deallocated before it is allocated. [publicAllocationError]\n", errout_str());
     }
 };
 
@@ -1579,31 +1640,24 @@ REGISTER_TEST(TestMemleakInClass)
 
 class TestMemleakStructMember : public TestFixture {
 public:
-    TestMemleakStructMember() : TestFixture("TestMemleakStructMember") {
-    }
+    TestMemleakStructMember() : TestFixture("TestMemleakStructMember") {}
 
 private:
-    Settings settings;
-
-    void check(const char code[], bool isCPP = true) {
-        // Clear the error buffer..
-        errout.str("");
+    const Settings settings = settingsBuilder().library("std.cfg").library("posix.cfg").build();
 
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], bool cpp = true) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, isCPP ? "test.cpp" : "test.c");
-        tokenizer.simplifyTokenList2();
+        SimpleTokenizer tokenizer(settings, *this, cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check for memory leaks..
         CheckMemoryLeakStructMember checkMemoryLeakStructMember(&tokenizer, &settings, this);
-        checkMemoryLeakStructMember.check();
+        (checkMemoryLeakStructMember.check)();
     }
 
-    void run() OVERRIDE {
-        LOAD_LIB_2(settings.library, "std.cfg");
-        LOAD_LIB_2(settings.library, "posix.cfg");
-
+    void run() override {
+        mNewTemplate = true;
         // testing that errors are detected
         TEST_CASE(err);
 
@@ -1618,6 +1672,9 @@ class TestMemleakStructMember : public TestFixture {
         TEST_CASE(assign1);
         TEST_CASE(assign2);
         TEST_CASE(assign3);
+        TEST_CASE(assign4); // #11019
+        TEST_CASE(assign5);
+        TEST_CASE(assign6);
 
         // Failed allocation
         TEST_CASE(failedAllocation);
@@ -1626,6 +1683,7 @@ class TestMemleakStructMember : public TestFixture {
         TEST_CASE(function2);   // #2848: Taking address in function
         TEST_CASE(function3);   // #3024: kernel list
         TEST_CASE(function4);   // #3038: Deallocating in function
+        TEST_CASE(function5);   // #10381, #10382, #10158
 
         // Handle if-else
         TEST_CASE(ifelse);
@@ -1649,6 +1707,8 @@ class TestMemleakStructMember : public TestFixture {
         TEST_CASE(varid_2); // #5315: Analysis confused by ((variable).attribute) notation
 
         TEST_CASE(customAllocation);
+
+        TEST_CASE(lambdaInScope); // #9793
     }
 
     void err() {
@@ -1658,14 +1718,14 @@ class TestMemleakStructMember : public TestFixture {
               "    abc->a = malloc(10);\n"
               "    free(abc);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Memory leak: abc.a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5]: (error) Memory leak: abc.a [memleak]\n", errout_str());
 
         check("static void foo()\n"
               "{\n"
               "    struct ABC *abc = malloc(sizeof(struct ABC));\n"
               "    abc->a = malloc(10);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Memory leak: abc.a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:1]: (error) Memory leak: abc.a [memleak]\n", errout_str());
 
         check("static ABC * foo()\n"
               "{\n"
@@ -1678,7 +1738,7 @@ class TestMemleakStructMember : public TestFixture {
               "    }\n"
               "    return abc;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Memory leak: abc.a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:9]: (error) Memory leak: abc.a [memleak]\n", errout_str());
 
         check("static void foo(int a)\n"
               "{\n"
@@ -1690,7 +1750,7 @@ class TestMemleakStructMember : public TestFixture {
               "        return;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:10]: (error) Memory leak: abc.a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:1]: (error) Memory leak: abc.a [memleak]\n", errout_str());
     }
 
     void goto_() {
@@ -1706,7 +1766,7 @@ class TestMemleakStructMember : public TestFixture {
               "    free(abc->a);\n"
               "    free(abc);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void ret1() {
@@ -1716,13 +1776,13 @@ class TestMemleakStructMember : public TestFixture {
               "    abc->a = malloc(10);\n"
               "    return abc;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("static void foo(struct ABC *abc)\n"
               "{\n"
               "    abc->a = malloc(10);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #7302
         check("void* foo() {\n"
@@ -1730,14 +1790,14 @@ class TestMemleakStructMember : public TestFixture {
               "    abc.a = malloc(10);\n"
               "    return abc.a;\n"
               "}", false);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void* foo() {\n"
               "    struct ABC abc;\n"
               "    abc.a = malloc(10);\n"
               "    return abc.b;\n"
               "}", false);
-        ASSERT_EQUALS("[test.c:4]: (error) Memory leak: abc.a\n", errout.str());
+        ASSERT_EQUALS("[test.c:4:5]: (error) Memory leak: abc.a [memleak]\n", errout_str());
     }
 
     void ret2() {
@@ -1747,7 +1807,7 @@ class TestMemleakStructMember : public TestFixture {
               "    abc->a = malloc(10);\n"
               "    return &abc->self;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void assign1() {
@@ -1756,7 +1816,7 @@ class TestMemleakStructMember : public TestFixture {
               "    struct ABC *abc = abc1;\n"
               "    abc->a = malloc(10);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("static void foo()\n"
               "{\n"
@@ -1764,7 +1824,7 @@ class TestMemleakStructMember : public TestFixture {
               "    abc1 = abc = malloc(sizeof(ABC));\n"
               "    abc->a = malloc(10);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("static void foo()\n"
               "{\n"
@@ -1773,7 +1833,7 @@ class TestMemleakStructMember : public TestFixture {
               " ptr->msn = malloc(100);\n"
               " back = ptr;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
     }
 
@@ -1782,7 +1842,7 @@ class TestMemleakStructMember : public TestFixture {
               "    struct ABC *abc = malloc(123);\n"
               "    abc->a = abc->b = malloc(10);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void assign3() {
@@ -1791,7 +1851,118 @@ class TestMemleakStructMember : public TestFixture {
               "    f2.a = malloc(100);\n"
               "    *f1 = f2;\n"
               "}", false);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void assign4() {
+        check("struct S { int a, b, c; };\n" // #11019
+              "void f() {\n"
+              "    struct S s;\n"
+              "    *&s.a = open(\"xx.log\", O_RDONLY);\n"
+              "    ((s).b) = open(\"xx.log\", O_RDONLY);\n"
+              "    (&s)->c = open(\"xx.log\", O_RDONLY);\n"
+              "}\n", false);
+        ASSERT_EQUALS("[test.c:7:1]: (error) Resource leak: s.a [resourceLeak]\n"
+                      "[test.c:7:1]: (error) Resource leak: s.b [resourceLeak]\n"
+                      "[test.c:7:1]: (error) Resource leak: s.c [resourceLeak]\n",
+                      errout_str());
+
+        check("struct S { int *p, *q; };\n" // #7705
+              "void f(S s) {\n"
+              "    s.p = new int[10];\n"
+              "    s.q = malloc(40);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:1]: (error) Memory leak: s.p [memleak]\n"
+                      "[test.cpp:5:1]: (error) Memory leak: s.q [memleak]\n",
+                      errout_str());
+
+        check("struct S** f(struct S** s) {\n" // don't throw
+              "    struct S** ret = malloc(sizeof(*ret));\n"
+              "    ret[0] = malloc(sizeof(**s));\n"
+              "    ret[0]->g = strdup(s[0]->g);\n"
+              "    return ret;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void run_rcmd(enum rcommand rcmd, rsh_session *sess, char *cmd) {\n"
+              "    sess->fp = popen(cmd, rcmd == RSH_PIPE_READ ? \"r\" : \"w\");\n"
+              "}\n", false);
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { char* a[2]; };\n"
+              "enum E { E0, E1 };\n"
+              "void f(struct S* s, enum E e, const char* n) {\n"
+              "    free(s->a[e]);\n"
+              "    s->a[e] = strdup(n);\n"
+              "}\n", false);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(struct S** s, const char* c) {\n"
+              "    *s = malloc(sizeof(struct S));\n"
+              "    (*s)->value = strdup(c);\n"
+              "}\n", false);
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n"
+              "    size_t mpsz;\n"
+              "    void* hdr;\n"
+              "};\n"
+              "void f(struct S s[static 1U], int fd, size_t size) {\n"
+              "    s->mpsz = size;\n"
+              "    s->hdr = mmap(NULL, s->mpsz, PROT_READ, MAP_SHARED, fd, 0);\n"
+              "}\n", false);
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(type_t t) {\n"
+              "    t->p = malloc(10);\n"
+              "    t->x.p = malloc(10);\n"
+              "    t->y[2].p = malloc(10);\n"
+              "}\n", false);
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void assign5() {
+        check("struct S { int fd; };\n"
+              "void f() {\n"
+              "    struct S* s = (struct S*)malloc(sizeof(struct S));\n"
+              "    s->fd = open(\"abc\", O_RDWR | O_NOCTTY);\n"
+              "    free(s);\n"
+              "}\n"
+              "void g() {\n"
+              "    struct S* s = static_cast<struct S*>(malloc(sizeof(struct S)));\n"
+              "    s->fd = open(\"abc\", O_RDWR | O_NOCTTY);\n"
+              "    free(s);\n"
+              "}\n"
+              "void h() {\n"
+              "    S* s = new S;\n"
+              "    s->fd = open(\"abc\", O_RDWR | O_NOCTTY);\n"
+              "    delete s;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:5]: (error) Resource leak: s.fd [resourceLeak]\n"
+                      "[test.cpp:10:5]: (error) Resource leak: s.fd [resourceLeak]\n"
+                      "[test.cpp:16:1]: (error) Resource leak: s.fd [resourceLeak]\n",
+                      errout_str());
+
+        check("struct S { int fd; };\n" // #13031
+              "void f() {\n"
+              "    struct S* s = malloc(sizeof(struct S));\n"
+              "    s->fd = open(\"abc\", O_RDWR | O_NOCTTY);\n"
+              "    if (s->fd < 0) {\n"
+              "        free(s);\n"
+              "        return NULL;\n"
+              "    }\n"
+              "    return s;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void assign6() {
+        check("struct S { S* p; };\n" // #14524
+              "void f() {\n"
+              "    S s;\n"
+              "    s.p = static_cast<S*>(malloc(sizeof(S)));\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:1]: (error) Memory leak: s.p [memleak]\n", errout_str());
     }
 
     void failedAllocation() {
@@ -1806,7 +1977,7 @@ class TestMemleakStructMember : public TestFixture {
               "    }\n"
               "    return abc;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void function1() {
@@ -1817,7 +1988,7 @@ class TestMemleakStructMember : public TestFixture {
               "    abc->a = malloc(10);\n"
               "    func(abc);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("static void foo()\n"
               "{\n"
@@ -1825,7 +1996,7 @@ class TestMemleakStructMember : public TestFixture {
               "    abclist.push_back(abc);\n"
               "    abc->a = malloc(10);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // #2848: Taking address in function 'assign'
@@ -1835,7 +2006,7 @@ class TestMemleakStructMember : public TestFixture {
               "  a.foo = (char *) malloc(10);\n"
               "  assign(&a);\n"
               "}", false);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // #3024: kernel list
@@ -1845,7 +2016,7 @@ class TestMemleakStructMember : public TestFixture {
               "  abc.a = (char *) malloc(10);\n"
               "  list_add_tail(&abc->list, head);\n"
               "}", false);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // #3038: deallocating in function
@@ -1856,7 +2027,44 @@ class TestMemleakStructMember : public TestFixture {
               "  abc.a = (char *) malloc(10);\n"
               "  a(abc.a);\n"
               "}", false);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void function5() {
+        check("struct s f() {\n" // #10381
+              "    struct s s1;\n"
+              "    s1->x = malloc(1);\n"
+              "    return (s1);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct nc_rpc nc_rpc_getconfig() {\n" // #10382
+              "    struct nc_rpc rpc;\n"
+              "    rpc->filter = malloc(1);\n"
+              "    return (nc_rpc)rpc;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("T* f(const char *str) {\n" // #10158
+              "    S* s = malloc(sizeof(S));\n"
+              "    s->str = strdup(str);\n"
+              "    return NewT(s);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("typedef struct s { char* str; } attr_t;\n" // #10152
+              "attr_t* f(int type) {\n"
+              "    attr_t a;\n"
+              "    switch (type) {\n"
+              "    case 1:\n"
+              "        a.str = strdup(\"?\");\n"
+              "        break;\n"
+              "    default:\n"
+              "        return NULL;\n"
+              "    }\n"
+              "    return g(&a);\n"
+              "}\n");
+        TODO_ASSERT_EQUALS("", "[test.cpp:9:9]: (error) Memory leak: a.str [memleak]\n", errout_str());
     }
 
     void ifelse() {
@@ -1875,7 +2083,7 @@ class TestMemleakStructMember : public TestFixture {
               "    free(abc->a);\n"
               "    free(abc);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void linkedlist() {
@@ -1891,7 +2099,7 @@ class TestMemleakStructMember : public TestFixture {
               "        abc = next;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void globalvar() {
@@ -1903,7 +2111,7 @@ class TestMemleakStructMember : public TestFixture {
               "    abc->a = malloc(10);\n"
               "    return;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // Ticket #933 Leaks with struct members not detected
@@ -1923,12 +2131,12 @@ class TestMemleakStructMember : public TestFixture {
                              "}";
 
         check(code1, true);
-        ASSERT_EQUALS("[test.cpp:12]: (error) Memory leak: a.f\n"
-                      "[test.cpp:12]: (error) Memory leak: a.c\n"
-                      "[test.cpp:12]: (error) Memory leak: a.m\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:12:1]: (error) Resource leak: a.f [resourceLeak]\n"
+                      "[test.cpp:12:1]: (error) Memory leak: a.c [memleak]\n"
+                      "[test.cpp:12:1]: (error) Memory leak: a.m [memleak]\n", errout_str());
         check(code1, false);
-        ASSERT_EQUALS("[test.c:12]: (error) Memory leak: a.f\n"
-                      "[test.c:12]: (error) Memory leak: a.m\n", errout.str());
+        ASSERT_EQUALS("[test.c:12:1]: (error) Resource leak: a.f [resourceLeak]\n"
+                      "[test.c:12:1]: (error) Memory leak: a.m [memleak]\n", errout_str());
 
         // Test OK case
         const char code2[] = "struct A {\n"
@@ -1948,9 +2156,7 @@ class TestMemleakStructMember : public TestFixture {
                              "}";
 
         check(code2, true);
-        ASSERT_EQUALS("", errout.str());
-        check(code2, false);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Test unknown struct. In C++, it might have a destructor
         const char code3[] = "void func() {\n"
@@ -1959,9 +2165,9 @@ class TestMemleakStructMember : public TestFixture {
                              "}";
 
         check(code3, true);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check(code3, false);
-        ASSERT_EQUALS("[test.c:4]: (error) Memory leak: a.f\n", errout.str());
+        ASSERT_EQUALS("[test.c:4:1]: (error) Resource leak: a.f [resourceLeak]\n", errout_str());
 
         // Test struct with destructor
         const char code4[] = "struct A {\n"
@@ -1974,7 +2180,7 @@ class TestMemleakStructMember : public TestFixture {
                              "}";
 
         check(code4, true);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void refvar() { // #8116
@@ -1988,7 +2194,7 @@ class TestMemleakStructMember : public TestFixture {
               "  Test& y = *x;\n"
               "  y.data = malloc(10);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // don't crash
@@ -1998,7 +2204,7 @@ class TestMemleakStructMember : public TestFixture {
               "char *const oldbuffer = otherbuffer.get();\n"
               "int const oldbufsize = otherbufsize;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varid() { // #5201
@@ -2011,7 +2217,7 @@ class TestMemleakStructMember : public TestFixture {
               "  if (s.state_check_buff == 0)\n"
               "    return;\n"
               "}", false);
-        ASSERT_EQUALS("[test.c:9]: (error) Memory leak: s.state_check_buff\n", errout.str());
+        ASSERT_EQUALS("[test.c:9:1]: (error) Memory leak: s.state_check_buff [memleak]\n", errout_str());
     }
 
     void varid_2() { // #5315
@@ -2021,7 +2227,7 @@ class TestMemleakStructMember : public TestFixture {
               "  ((f)->realm) = strdup(realm);\n"
               "  if(f->realm == NULL) {}\n"
               "}", false);
-        ASSERT_EQUALS("[test.c:6]: (error) Memory leak: f.realm\n", errout.str());
+        ASSERT_EQUALS("[test.c:6:1]: (error) Memory leak: f.realm [memleak]\n", errout_str());
     }
 
     void customAllocation() { // #4770
@@ -2032,7 +2238,52 @@ class TestMemleakStructMember : public TestFixture {
               "    struct ABC abc;\n"
               "    abc.a = myalloc();\n"
               "}", false);
-        ASSERT_EQUALS("[test.c:7]: (error) Memory leak: abc.a\n", errout.str());
+        ASSERT_EQUALS("[test.c:7:1]: (error) Memory leak: abc.a [memleak]\n", errout_str());
+    }
+
+    void lambdaInScope() {
+        check( // #9793
+            "struct S { int * p{nullptr}; };\n"
+            "int main()\n"
+            "{\n"
+            "    S s;\n"
+            "    s.p = new int[10];\n"
+            "    for (int i = 0; i < 10; ++i) {\n"
+            "        s.p[i] = []() { return 1; }();\n"
+            "    }\n"
+            "    delete[] s.p;\n"
+            "    return 0;\n"
+            "}", true);
+        ASSERT_EQUALS("", errout_str());
+
+        check(
+            "struct S { int* p; };\n"
+            "void f() {\n"
+            "    auto g = []() {\n"
+            "      S s;\n"
+            "      s.p = new int;\n"
+            "    };\n"
+            "}\n", true);
+        ASSERT_EQUALS("[test.cpp:6:5]: (error) Memory leak: s.p [memleak]\n", errout_str());
+
+        check(
+            "struct S { int* p; };\n"
+            "void f() {\n"
+            "    S s;\n"
+            "    s.p = new int;\n"
+            "    auto g = [&]() {\n"
+            "        delete s.p;\n"
+            "    };\n"
+            "    g();\n"
+            "}\n"
+            "void h() {\n"
+            "    S s;\n"
+            "    s.p = new int;\n"
+            "    [&]() {\n"
+            "        delete s.p;\n"
+            "    }();\n"
+            "}\n", true);
+        ASSERT_EQUALS("", errout_str());
     }
 };
 
@@ -2044,34 +2295,24 @@ REGISTER_TEST(TestMemleakStructMember)
 
 class TestMemleakNoVar : public TestFixture {
 public:
-    TestMemleakNoVar() : TestFixture("TestMemleakNoVar") {
-    }
+    TestMemleakNoVar() : TestFixture("TestMemleakNoVar") {}
 
 private:
-    Settings settings;
-
-    void check(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
+    const Settings settings = settingsBuilder().certainty(Certainty::inconclusive).severity(Severity::warning).library("std.cfg").library("posix.cfg").build();
 
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check for memory leaks..
         CheckMemoryLeakNoVar checkMemoryLeakNoVar(&tokenizer, &settings, this);
-        checkMemoryLeakNoVar.check();
+        (checkMemoryLeakNoVar.check)();
     }
 
-    void run() OVERRIDE {
-        settings.inconclusive = true;
-        settings.libraries.emplace_back("posix");
-        settings.addEnabled("warning");
-
-        LOAD_LIB_2(settings.library, "std.cfg");
-        LOAD_LIB_2(settings.library, "posix.cfg");
-
+    void run() override {
+        mNewTemplate = true;
         // pass allocated memory to function..
         TEST_CASE(functionParameter);
 
@@ -2084,6 +2325,9 @@ class TestMemleakNoVar : public TestFixture {
 
         // Test getAllocationType for subfunction
         TEST_CASE(getAllocationType);
+
+        TEST_CASE(crash1); // #10729
+        TEST_CASE(openDevNull); // #9653
     }
 
     void functionParameter() {
@@ -2091,18 +2335,23 @@ class TestMemleakNoVar : public TestFixture {
         check("void x() {\n"
               "    strcpy(a, strdup(p));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Allocation with strdup, strcpy doesn't release it.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (error) Allocation with strdup, strcpy doesn't release it. [leakNoVarFunctionCall]\n", errout_str());
 
         check("char *x() {\n"
               "    char *ret = strcpy(malloc(10), \"abc\");\n"
               "    return ret;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("char *x() {\n"
+              "    return strcpy(malloc(10), \"abc\");\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void x() {\n"
               "    free(malloc(10));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // user function..
         check("void set_error(const char *msg) {\n"
@@ -2111,7 +2360,7 @@ class TestMemleakNoVar : public TestFixture {
               "void x() {\n"
               "    set_error(strdup(p));\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Allocation with strdup, set_error doesn't release it.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5:15]: (error) Allocation with strdup, set_error doesn't release it. [leakNoVarFunctionCall]\n", "", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -2119,58 +2368,159 @@ class TestMemleakNoVar : public TestFixture {
               "    fd = mkstemp(strdup(\"/tmp/file.XXXXXXXX\"));\n"
               "    close(fd);\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Allocation with strdup, mkstemp doesn't release it.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Allocation with strdup, mkstemp doesn't release it.\n", "", errout_str());
 
         check("void f()\n"
               "{\n"
               "    if(TRUE || strcmp(strdup(a), b));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Allocation with strdup, strcmp doesn't release it.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:23]: (error) Allocation with strdup, strcmp doesn't release it. [leakNoVarFunctionCall]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "    if(!strcmp(strdup(a), b) == 0);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Allocation with strdup, strcmp doesn't release it.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:16]: (error) Allocation with strdup, strcmp doesn't release it. [leakNoVarFunctionCall]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "    42, strcmp(strdup(a), b);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Allocation with strdup, strcmp doesn't release it.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:16]: (error) Allocation with strdup, strcmp doesn't release it. [leakNoVarFunctionCall]\n", errout_str());
 
         check("void f() {\n"
               "   assert(freopen(\"/dev/null\", \"r\", stdin));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void x() {\n"
               "    strcpy(a, (void*)strdup(p));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Allocation with strdup, strcpy doesn't release it.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:22]: (error) Allocation with strdup, strcpy doesn't release it. [leakNoVarFunctionCall]\n", errout_str());
 
         check("void* malloc1() {\n"
               "    return (malloc(1));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("char *x() {\n"
               "    char *ret = (char*)strcpy(malloc(10), \"abc\");\n"
               "    return ret;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    free(malloc(1));\n"
               "    strcpy(a, strdup(p));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Allocation with strdup, strcpy doesn't release it.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:15]: (error) Allocation with strdup, strcpy doesn't release it. [leakNoVarFunctionCall]\n", errout_str());
 
         check("void f() {\n"
               "    memcmp(calloc(10, 10), strdup(q), 100);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Allocation with calloc, memcmp doesn't release it.\n"
-                      "[test.cpp:2]: (error) Allocation with strdup, memcmp doesn't release it.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:12]: (error) Allocation with calloc, memcmp doesn't release it. [leakNoVarFunctionCall]\n"
+                      "[test.cpp:2:28]: (error) Allocation with strdup, memcmp doesn't release it. [leakNoVarFunctionCall]\n", errout_str());
+
+        check("void* f(int size) {\n"
+              "    return (void*) malloc(size);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int* f(int size) {\n"
+              "    return static_cast<int*>(malloc(size));\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() { if (new int[42]) {} }\n" // #10857
+              "void g() { if (malloc(42)) {} }\n");
+        ASSERT_EQUALS("[test.cpp:1:16]: (error) Allocation with new, if doesn't release it. [leakNoVarFunctionCall]\n"
+                      "[test.cpp:2:16]: (error) Allocation with malloc, if doesn't release it. [leakNoVarFunctionCall]\n",
+                      errout_str());
+
+        check("const char* string(const char* s) {\n"
+              "    StringSet::iterator it = strings_.find(s);\n"
+              "    if (it != strings_.end())\n"
+              "        return *it;\n"
+              "    return *strings_.insert(it, std::strcpy(new char[std::strlen(s) + 1], s));\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n"
+              "    static void load(const QString& projPath) {\n"
+              "        if (proj_)\n"
+              "            return;\n"
+              "        proj_ = new ProjectT(projPath);\n"
+              "        proj_->open(new OpenCallback());\n"
+              "    }\n"
+              "private:\n"
+              "    static Core::ProjectBase* proj_;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const std::string& s, int n) {\n"
+              "    std::unique_ptr<char[]> u;\n"
+              "    u.reset(strcpy(new char[n], s.c_str()));\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { char* p; };\n"
+              "void f(S* s, int N) {\n"
+              "    s->p = s->p ? strcpy(new char[N], s->p) : nullptr;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {};\n" // #11866
+              "void f(bool b);\n"
+              "void g() {\n"
+              "    f(new int());\n"
+              "    f(new std::vector<int>());\n"
+              "    f(new S());\n"
+              "    f(new tm());\n"
+              "    f(malloc(sizeof(S)));\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:7]: (error) Allocation with new, f doesn't release it. [leakNoVarFunctionCall]\n"
+                      "[test.cpp:5:7]: (error) Allocation with new, f doesn't release it. [leakNoVarFunctionCall]\n"
+                      "[test.cpp:6:7]: (error) Allocation with new, f doesn't release it. [leakNoVarFunctionCall]\n"
+                      "[test.cpp:7:7]: (error) Allocation with new, f doesn't release it. [leakNoVarFunctionCall]\n"
+                      "[test.cpp:8:7]: (error) Allocation with malloc, f doesn't release it. [leakNoVarFunctionCall]\n",
+                      errout_str());
+
+        check("void f(uintptr_t u);\n"
+              "void g() {\n"
+              "    f((uintptr_t)new int());\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(uint8_t u);\n"
+              "void g() {\n"
+              "    f((uint8_t)new int());\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:16]: (error) Allocation with new, f doesn't release it. [leakNoVarFunctionCall]\n",
+                      errout_str());
+
+        check("void f(int i, T t);\n"
+              "void g(int i, U* u);\n"
+              "void h() {\n"
+              "    f(1, new int());\n"
+              "    g(1, new int());\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(T t);\n"
+              "struct U {};\n"
+              "void g() {\n"
+              "    f(new U());\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n" // #14339
+              "    void g(int* p) { p_ = p; }\n"
+              "    int *p_;\n"
+              "};\n"
+              "void f(A& a) {\n"
+              "    a.g(new int);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void missingAssignment() {
@@ -2178,31 +2528,25 @@ class TestMemleakNoVar : public TestFixture {
               "{\n"
               "    malloc(10);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Return value of allocation function 'malloc' is not stored.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Return value of allocation function 'malloc' is not stored. [leakReturnValNotUsed]\n", errout_str());
 
         check("void x()\n"
               "{\n"
               "    calloc(10, 1);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Return value of allocation function 'calloc' is not stored.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Return value of allocation function 'calloc' is not stored. [leakReturnValNotUsed]\n", errout_str());
 
         check("void x()\n"
               "{\n"
               "    strdup(\"Test\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Return value of allocation function 'strdup' is not stored.\n", errout.str());
-
-        check("void x()\n"
-              "{\n"
-              "    reallocarray(NULL, 10, 10);\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Return value of allocation function 'reallocarray' is not stored.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Return value of allocation function 'strdup' is not stored. [leakReturnValNotUsed]\n", errout_str());
 
         check("void x()\n"
               "{\n"
               "    (char*) malloc(10);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Return value of allocation function 'malloc' is not stored.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:13]: (error) Return value of allocation function 'malloc' is not stored. [leakReturnValNotUsed]\n", errout_str());
 
         check("void x()\n"
               "{\n"
@@ -2210,19 +2554,28 @@ class TestMemleakNoVar : public TestFixture {
               "    foo(ptr);\n"
               "    free(ptr);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f( void ) {\n" // FP: #11246
+              "  void* address = malloc( 1 );\n"
+              "  int ok = address != 0;\n"
+              "  if ( ok )\n"
+              "    free( address ), address = 0;\n"
+              "  return 0;\n"
+              "} ");
+        ASSERT_EQUALS("", errout_str());
 
         check("char** x(const char* str) {\n"
               "    char* ptr[] = { malloc(10), malloc(5), strdup(str) };\n"
               "    return ptr;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void x()\n"
               "{\n"
               "    42,malloc(42);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Return value of allocation function 'malloc' is not stored.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8]: (error) Return value of allocation function 'malloc' is not stored. [leakReturnValNotUsed]\n", errout_str());
 
         check("void *f()\n"
               "{\n"
@@ -2232,7 +2585,7 @@ class TestMemleakNoVar : public TestFixture {
               "{\n"
               "    f();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Return value of allocation function 'f' is not stored.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:5]: (error) Return value of allocation function 'f' is not stored. [leakReturnValNotUsed]\n", errout_str());
 
         check("void f()\n" // #8100
               "{\n"
@@ -2242,7 +2595,7 @@ class TestMemleakNoVar : public TestFixture {
               "{\n"
               "    f();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void *f() {\n" // #8848
               "    struct S { void *alloc() { return malloc(10); } };\n"
@@ -2251,26 +2604,26 @@ class TestMemleakNoVar : public TestFixture {
               "{\n"
               "    f();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void x()\n"
               "{\n"
               "    if(!malloc(5)) fail();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Return value of allocation function 'malloc' is not stored.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (error) Return value of allocation function 'malloc' is not stored. [leakReturnValNotUsed]\n", errout_str());
 
         check("FOO* factory() {\n"
               "    FOO* foo = new (std::nothrow) FOO;\n"
               "    return foo;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #6536
         check("struct S { S(int) {} };\n"
               "void foo(int i) {\n"
               "  S socket(i);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #6693
         check("struct CTest {\n"
@@ -2280,12 +2633,12 @@ class TestMemleakNoVar : public TestFixture {
               "void CTest::Initialise() {\n"
               "    malloc();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n" // #7348 - cast
               "    p = (::X*)malloc(42);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #7182 "crash: CheckMemoryLeak::functionReturnType()"
         check("template<typename... Ts> auto unary_right_comma (Ts... ts) { return (ts , ...); }\n"
@@ -2293,78 +2646,215 @@ class TestMemleakNoVar : public TestFixture {
               "int main() {\n"
               "  unary_right_comma (a);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    new int[10];\n"
+              "    new int[10][5];\n"
+              "    new int[10]();\n"
+              "    new int[10]{};\n"
+              "    new int[] { 1, 2, 3 };\n"
+              "    new std::string;\n"
+              "    new int;\n"
+              "    new int();\n"
+              "    new int(1);\n"
+              "    new int{};\n"
+              "    new int{ 1 };\n"
+              "    new uint8_t[4];\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:5]: (error) Return value of allocation function 'new' is not stored. [leakReturnValNotUsed]\n"
+                      "[test.cpp:3:5]: (error) Return value of allocation function 'new' is not stored. [leakReturnValNotUsed]\n"
+                      "[test.cpp:4:5]: (error) Return value of allocation function 'new' is not stored. [leakReturnValNotUsed]\n"
+                      "[test.cpp:5:5]: (error) Return value of allocation function 'new' is not stored. [leakReturnValNotUsed]\n"
+                      "[test.cpp:6:5]: (error) Return value of allocation function 'new' is not stored. [leakReturnValNotUsed]\n"
+                      "[test.cpp:7:5]: (error) Return value of allocation function 'new' is not stored. [leakReturnValNotUsed]\n"
+                      "[test.cpp:8:5]: (error) Return value of allocation function 'new' is not stored. [leakReturnValNotUsed]\n"
+                      "[test.cpp:9:5]: (error) Return value of allocation function 'new' is not stored. [leakReturnValNotUsed]\n"
+                      "[test.cpp:10:5]: (error) Return value of allocation function 'new' is not stored. [leakReturnValNotUsed]\n"
+                      "[test.cpp:11:5]: (error) Return value of allocation function 'new' is not stored. [leakReturnValNotUsed]\n"
+                      "[test.cpp:12:5]: (error) Return value of allocation function 'new' is not stored. [leakReturnValNotUsed]\n"
+                      "[test.cpp:13:5]: (error) Return value of allocation function 'new' is not stored. [leakReturnValNotUsed]\n",
+                      errout_str());
+
+        check("void f(int* p) {\n"
+              "    new auto('c');\n"
+              "    new(p) int;\n"
+              "}");
+        TODO_ASSERT_EQUALS("[test.cpp:1:29]: (error) Return value of allocation function 'new' is not stored. [leakReturnValNotUsed]\n"
+                           "[test.cpp:3]: (error) Return value of allocation function 'new' is not stored.\n",
+                           "",
+                           errout_str());
+
+        check("void g(int* p) {\n"
+              "    new QWidget;\n"
+              "    new QWidget();\n"
+              "    new QWidget{ this };\n"
+              "    h(new int[10], 1);\n"
+              "    h(new int[10][5], 1);\n"
+              "    h(new int[10](), 1);\n"
+              "    h(new int[10]{}, 1);\n"
+              "    h(new int[] { 1, 2, 3 }, 1);\n"
+              "    h(new auto('c'), 1);\n"
+              "    h(new std::string, 1);\n"
+              "    h(new int, 1);\n"
+              "    h(new int{}, 1);\n"
+              "    h(new int(), 1);\n"
+              "    h(new int{ 1 }, 1);\n"
+              "    h(new int(1), 1);\n"
+              "    h(new(p) int, 1);\n"
+              "    h(new QWidget, 1);\n"
+              "    C{ new int[10], 1 };\n"
+              "    C{ new int[10](), 1 };\n"
+              "    C{ new int[10]{}, 1 };\n"
+              "    C{ new int[] { 1, 2, 3 }, 1 };\n"
+              "    C{ new auto('c'), 1 };\n"
+              "    C{ new std::string, 1 };\n"
+              "    C{ new int, 1 };\n"
+              "    C{ new int{}, 1 };\n"
+              "    C{ new int(), 1 };\n"
+              "    C{ new int{ 1 }, 1 };\n"
+              "    C{ new int(1), 1 };\n"
+              "    C{ new(p) int, 1 };\n"
+              "    C{ new QWidget, 1 };\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(bool b) { if (b && malloc(42)) {} }\n" //  // #10858
+              "void g(bool b) { if (b || malloc(42)) {} }\n");
+        ASSERT_EQUALS("[test.cpp:1:27]: (error) Return value of allocation function 'malloc' is not stored. [leakReturnValNotUsed]\n"
+                      "[test.cpp:2:27]: (error) Return value of allocation function 'malloc' is not stored. [leakReturnValNotUsed]\n",
+                      errout_str());
+
+        check("void f0(const bool b) { b ? new int : nullptr; }\n" // #11155
+              "void f1(const bool b) { b ? nullptr : new int; }\n"
+              "int* g0(const bool b) { return b ? new int : nullptr; }\n"
+              "void g1(const bool b) { h(b, b ? nullptr : new int); }\n");
+        ASSERT_EQUALS("[test.cpp:1:29]: (error) Return value of allocation function 'new' is not stored. [leakReturnValNotUsed]\n"
+                      "[test.cpp:2:39]: (error) Return value of allocation function 'new' is not stored. [leakReturnValNotUsed]\n",
+                      errout_str());
+
+        check("void f() {\n" // #11157
+              "    switch (*new int) { case 42: break; }\n"
+              "    switch (*malloc(42)) { case 42: break; }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:14]: (error) Allocation with new, switch doesn't release it. [leakNoVarFunctionCall]\n"
+                      "[test.cpp:3:14]: (error) Allocation with malloc, switch doesn't release it. [leakNoVarFunctionCall]\n",
+                      errout_str());
+
+        check("void f() {\n"
+              "    Ref<StringBuffer> remove(new StringBuffer());\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n" // #11039
+              "    delete new int;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n" // #11327
+              "    int* p = (new int[3]) + 1;\n"
+              "    delete[] &p[-1];\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(FILE* fp1, FILE* fp2) {\n" // #14171
+              "    if (freopen(NULL, \"w+b\", fp1) == NULL) {}\n"
+              "    if (std::freopen(NULL, \"w+b\", fp2) == NULL) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n" // #14172
+              "    if (malloc(4) == nullptr) {}\n"
+              "    if (::malloc(4) == nullptr) {}\n"
+              "    if (std::malloc(4) == nullptr) {}\n"
+              "    if (::std::malloc(4) == nullptr) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:9]: (error) Return value of allocation function 'malloc' is not stored. [leakReturnValNotUsed]\n"
+                      "[test.cpp:3:11]: (error) Return value of allocation function 'malloc' is not stored. [leakReturnValNotUsed]\n"
+                      "[test.cpp:4:14]: (error) Return value of allocation function 'malloc' is not stored. [leakReturnValNotUsed]\n"
+                      "[test.cpp:5:16]: (error) Return value of allocation function 'malloc' is not stored. [leakReturnValNotUsed]\n",
+                      errout_str());
     }
 
     void smartPointerFunctionParam() {
         check("void x() {\n"
               "    f(shared_ptr<int>(new int(42)), g());\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Unsafe allocation. If g() throws, memory could be leaked. Use make_shared<int>() instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning, inconclusive) Unsafe allocation. If g() throws, memory could be leaked. Use make_shared<int>() instead. [leakUnsafeArgAlloc]\n", errout_str());
 
         check("void x() {\n"
               "    h(12, f(shared_ptr<int>(new int(42)), g()));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Unsafe allocation. If g() throws, memory could be leaked. Use make_shared<int>() instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (warning, inconclusive) Unsafe allocation. If g() throws, memory could be leaked. Use make_shared<int>() instead. [leakUnsafeArgAlloc]\n", errout_str());
 
         check("void x() {\n"
               "    f(unique_ptr<int>(new int(42)), g());\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Unsafe allocation. If g() throws, memory could be leaked. Use make_unique<int>() instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning, inconclusive) Unsafe allocation. If g() throws, memory could be leaked. Use make_unique<int>() instead. [leakUnsafeArgAlloc]\n", errout_str());
 
         check("void x() {\n"
               "    f(g(), shared_ptr<int>(new int(42)));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Unsafe allocation. If g() throws, memory could be leaked. Use make_shared<int>() instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning, inconclusive) Unsafe allocation. If g() throws, memory could be leaked. Use make_shared<int>() instead. [leakUnsafeArgAlloc]\n", errout_str());
 
         check("void x() {\n"
               "    f(g(), unique_ptr<int>(new int(42)));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Unsafe allocation. If g() throws, memory could be leaked. Use make_unique<int>() instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning, inconclusive) Unsafe allocation. If g() throws, memory could be leaked. Use make_unique<int>() instead. [leakUnsafeArgAlloc]\n", errout_str());
 
         check("void x() {\n"
               "    f(shared_ptr<char>(new char), make_unique<int>(32));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Unsafe allocation. If make_unique<int>() throws, memory could be leaked. Use make_shared<char>() instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning, inconclusive) Unsafe allocation. If make_unique<int>() throws, memory could be leaked. Use make_shared<char>() instead. [leakUnsafeArgAlloc]\n", errout_str());
 
         check("void x() {\n"
               "    f(g(124), h(\"test\", 234), shared_ptr<char>(new char));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Unsafe allocation. If h() throws, memory could be leaked. Use make_shared<char>() instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning, inconclusive) Unsafe allocation. If h() throws, memory could be leaked. Use make_shared<char>() instead. [leakUnsafeArgAlloc]\n", errout_str());
 
         check("void x() {\n"
               "    f(shared_ptr<std::string>(new std::string(\"\")), g<std::string>());\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Unsafe allocation. If g<std::string>() throws, memory could be leaked. Use make_shared<std::string>() instead.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning, inconclusive) Unsafe allocation. If g<std::string>() throws, memory could be leaked. Use make_shared<std::string>() instead. [leakUnsafeArgAlloc]\n", errout_str());
 
         check("void g(int x) throw() { }\n"
               "void x() {\n"
               "    f(g(124), shared_ptr<char>(new char));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void __declspec(nothrow) g(int x) { }\n"
               "void x() {\n"
               "    f(g(124), shared_ptr<char>(new char));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
     void resourceLeak() {
+        check("bool f(const char* name)\n" // FP: #12253
+              "{\n"
+              "    FILE* fp = fopen(name, \"r\");\n"
+              "    bool result = (fp == nullptr);\n"
+              "    if (result) return !result;\n"
+              "    fclose(fp);\n"
+              "    return result;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
         check("void foo() {\n"
               "  fopen(\"file.txt\", \"r\");\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Return value of allocation function 'fopen' is not stored.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:3]: (error) Return value of allocation function 'fopen' is not stored. [leakReturnValNotUsed]\n", errout_str());
 
         check("void foo() {\n"
-              "  FILE f* = fopen(\"file.txt\", \"r\");\n"
+              "  FILE *f = fopen(\"file.txt\", \"r\");\n"
               "  freopen(\"file.txt\", \"r\", f);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Return value of allocation function 'freopen' is not stored.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:3]: (error) Return value of allocation function 'freopen' is not stored. [leakReturnValNotUsed]\n", errout_str());
 
         check("void foo() {\n"
               "  freopen(\"file.txt\", \"r\", stdin);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Holder {\n"
               "  Holder(FILE* f) : file(f) {}\n"
@@ -2373,8 +2863,8 @@ class TestMemleakNoVar : public TestFixture {
               "};\n"
               "void foo() {\n"
               "  Holder h ( fopen(\"file.txt\", \"r\"));\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Holder {\n"
               "  Holder(FILE* f) : file(f) {}\n"
@@ -2383,8 +2873,8 @@ class TestMemleakNoVar : public TestFixture {
               "};\n"
               "void foo() {\n"
               "  Holder ( fopen(\"file.txt\", \"r\"));\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Holder {\n"
               "  Holder(FILE* f) : file(f) {}\n"
@@ -2393,8 +2883,8 @@ class TestMemleakNoVar : public TestFixture {
               "};\n"
               "void foo() {\n"
               "  Holder h { fopen(\"file.txt\", \"r\")};\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Holder {\n"
               "  Holder(FILE* f) : file(f) {}\n"
@@ -2403,8 +2893,8 @@ class TestMemleakNoVar : public TestFixture {
               "};\n"
               "void foo() {\n"
               "  Holder h = fopen(\"file.txt\", \"r\");\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Holder {\n"
               "  Holder(FILE* f) : file(f) {}\n"
@@ -2413,8 +2903,8 @@ class TestMemleakNoVar : public TestFixture {
               "};\n"
               "void foo() {\n"
               "  Holder { fopen(\"file.txt\", \"r\")};\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Holder {\n"
               "  Holder(int i, FILE* f) : file(f) {}\n"
@@ -2423,8 +2913,8 @@ class TestMemleakNoVar : public TestFixture {
               "};\n"
               "void foo() {\n"
               "  Holder { 0, fopen(\"file.txt\", \"r\")};\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void getAllocationType() {
@@ -2435,7 +2925,47 @@ class TestMemleakNoVar : public TestFixture {
               "void f() {\n"
               "  makeThing();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // #10631
+        check("struct Thing {\n"
+              "    Thing();\n"
+              "};\n"
+              "std::vector<Thing*> g_things;\n"
+              "Thing* makeThing() {\n"
+              "    Thing* n = new Thing();\n"
+              "    return n;\n"
+              "}\n"
+              "Thing::Thing() {\n"
+              "    g_things.push_back(this);\n"
+              "}\n"
+              "void f() {\n"
+              "    makeThing();\n"
+              "    for(Thing* t : g_things) {\n"
+              "        delete t;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void crash1() { // #10729
+        check("void foo() {\n"
+              "    extern void *realloc (void *ptr, size_t size);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo() {\n"
+              "    extern void *malloc (size_t size);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void openDevNull() {
+        check("void f() {\n" // #9653
+              "    (void)open(\"/dev/null\", O_RDONLY);\n"
+              "    open(\"/dev/null\", O_WRONLY);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 };
 REGISTER_TEST(TestMemleakNoVar)
diff --git a/test/testnullpointer.cpp b/test/testnullpointer.cpp
index 3fbfc30eba9..eb61c781b13 100644
--- a/test/testnullpointer.cpp
+++ b/test/testnullpointer.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,33 +16,30 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "check.h"
 #include "checknullpointer.h"
-#include "checkuninitvar.h"
+#include "ctu.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "library.h"
 #include "settings.h"
-#include "testsuite.h"
+#include "standards.h"
 #include "token.h"
-#include "tokenize.h"
 
-#include <simplecpp.h>
-#include <tinyxml2.h>
+#include <cstddef>
 #include <list>
-#include <map>
 #include <string>
-#include <vector>
 
 class TestNullPointer : public TestFixture {
 public:
-    TestNullPointer() : TestFixture("TestNullPointer") {
-    }
+    TestNullPointer() : TestFixture("TestNullPointer") {}
 
 private:
-    Settings settings;
-
-    void run() OVERRIDE {
-        LOAD_LIB_2(settings.library, "std.cfg");
-        settings.addEnabled("warning");
+    const Settings settings = settingsBuilder().library("std.cfg").severity(Severity::warning).build();
 
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(nullpointerAfterLoop);
         TEST_CASE(nullpointer1);
         TEST_CASE(nullpointer2);
@@ -82,6 +79,69 @@ class TestNullPointer : public TestFixture {
         TEST_CASE(nullpointer40);
         TEST_CASE(nullpointer41);
         TEST_CASE(nullpointer42);
+        TEST_CASE(nullpointer43); // #9404
+        TEST_CASE(nullpointer44); // #9395, #9423
+        TEST_CASE(nullpointer45);
+        TEST_CASE(nullpointer46); // #9441
+        TEST_CASE(nullpointer47); // #6850
+        TEST_CASE(nullpointer48); // #9196
+        TEST_CASE(nullpointer49); // #7804
+        TEST_CASE(nullpointer50); // #6462
+        TEST_CASE(nullpointer51);
+        TEST_CASE(nullpointer52);
+        TEST_CASE(nullpointer53); // #8005
+        TEST_CASE(nullpointer54); // #9573
+        TEST_CASE(nullpointer55); // #8144
+        TEST_CASE(nullpointer56); // #9701
+        TEST_CASE(nullpointer57); // #9751
+        TEST_CASE(nullpointer58); // #9807
+        TEST_CASE(nullpointer59); // #9897
+        TEST_CASE(nullpointer60); // #9842
+        TEST_CASE(nullpointer61);
+        TEST_CASE(nullpointer62);
+        TEST_CASE(nullpointer63);
+        TEST_CASE(nullpointer64);
+        TEST_CASE(nullpointer65); // #9980
+        TEST_CASE(nullpointer66); // #10024
+        TEST_CASE(nullpointer67); // #10062
+        TEST_CASE(nullpointer68);
+        TEST_CASE(nullpointer69); // #8143
+        TEST_CASE(nullpointer70);
+        TEST_CASE(nullpointer71); // #10178
+        TEST_CASE(nullpointer72); // #10215
+        TEST_CASE(nullpointer73); // #10321
+        TEST_CASE(nullpointer74);
+        TEST_CASE(nullpointer75);
+        TEST_CASE(nullpointer76); // #10408
+        TEST_CASE(nullpointer77);
+        TEST_CASE(nullpointer78); // #7802
+        TEST_CASE(nullpointer79); // #10400
+        TEST_CASE(nullpointer80); // #10410
+        TEST_CASE(nullpointer81); // #8724
+        TEST_CASE(nullpointer82); // #10331
+        TEST_CASE(nullpointer83); // #9870
+        TEST_CASE(nullpointer84); // #9873
+        TEST_CASE(nullpointer85); // #10210
+        TEST_CASE(nullpointer86);
+        TEST_CASE(nullpointer87); // #9291
+        TEST_CASE(nullpointer88); // #9949
+        TEST_CASE(nullpointer89); // #10640
+        TEST_CASE(nullpointer90); // #6098
+        TEST_CASE(nullpointer91); // #10678
+        TEST_CASE(nullpointer92);
+        TEST_CASE(nullpointer93); // #3929
+        TEST_CASE(nullpointer94); // #11040
+        TEST_CASE(nullpointer95); // #11142
+        TEST_CASE(nullpointer96); // #11416
+        TEST_CASE(nullpointer97); // #11229
+        TEST_CASE(nullpointer98); // #11458
+        TEST_CASE(nullpointer99); // #10602
+        TEST_CASE(nullpointer100);        // #11636
+        TEST_CASE(nullpointer101);        // #11382
+        TEST_CASE(nullpointer102);
+        TEST_CASE(nullpointer103);
+        TEST_CASE(nullpointer104); // #13881
+        TEST_CASE(nullpointer105); // #13861
         TEST_CASE(nullpointer_addressOf); // address of
         TEST_CASE(nullpointerSwitch); // #2626
         TEST_CASE(nullpointer_cast); // #4692
@@ -96,13 +156,17 @@ class TestNullPointer : public TestFixture {
         TEST_CASE(scanf_with_invalid_va_argument);
         TEST_CASE(nullpointer_in_return);
         TEST_CASE(nullpointer_in_typeid);
+        TEST_CASE(nullpointer_in_alignof); // #11401
         TEST_CASE(nullpointer_in_for_loop);
+        TEST_CASE(nullpointerDeadCode); // #11311
         TEST_CASE(nullpointerDelete);
         TEST_CASE(nullpointerSubFunction);
         TEST_CASE(nullpointerExit);
         TEST_CASE(nullpointerStdString);
         TEST_CASE(nullpointerStdStream);
         TEST_CASE(nullpointerSmartPointer);
+        TEST_CASE(nullpointerOutOfMemory);
+        TEST_CASE(nullpointerOutOfResources);
         TEST_CASE(functioncall);
         TEST_CASE(functioncalllibrary); // use Library to parse function call
         TEST_CASE(functioncallDefaultArguments);
@@ -110,62 +174,53 @@ class TestNullPointer : public TestFixture {
         TEST_CASE(ticket6505);
         TEST_CASE(subtract);
         TEST_CASE(addNull);
+        TEST_CASE(isPointerDeRefFunctionDecl);
 
-        TEST_CASE(ctu);
+        TEST_CASE(ctuTest);
     }
 
-    void check(const char code[], bool inconclusive = false, const char filename[] = "test.cpp") {
-        // Clear the error buffer..
-        errout.str("");
+    struct CheckOptions
+    {
+        bool inconclusive = false;
+        bool cpp = true;
+        Standards::cstd_t cstd = Standards::CLatest;
+    };
 
-        settings.inconclusive = inconclusive;
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
+        const Settings settings1 = settingsBuilder(settings).certainty(Certainty::inconclusive, options.inconclusive).c(options.cstd).build();
 
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        if (!tokenizer.tokenize(istr, filename))
-            return;
+        SimpleTokenizer tokenizer(settings1, *this, options.cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check for null pointer dereferences..
-        CheckNullPointer checkNullPointer;
-        checkNullPointer.runChecks(&tokenizer, &settings, this);
+        runChecks<CheckNullPointer>(tokenizer, this);
     }
 
-    void checkP(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
-
-        settings.inconclusive = false;
-
-        // Raw tokens..
-        std::vector<std::string> files(1, "test.cpp");
-        std::istringstream istr(code);
-        const simplecpp::TokenList tokens1(istr, files, files[0]);
-
-        // Preprocess..
-        simplecpp::TokenList tokens2(files);
-        std::map<std::string, simplecpp::TokenList*> filedata;
-        simplecpp::preprocess(tokens2, tokens1, files, filedata, simplecpp::DUI());
+#define checkP(...) checkP_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkP_(const char* file, int line, const char (&code)[size]) {
+        SimpleTokenizer2 tokenizer(settings, *this, code, "test.cpp");
 
         // Tokenizer..
-        Tokenizer tokenizer(&settings, this);
-        tokenizer.createTokens(&tokens2);
-        tokenizer.simplifyTokens1("");
+        ASSERT_LOC(tokenizer.simplifyTokens1(""), file, line);
 
         // Check for null pointer dereferences..
-        CheckNullPointer checkNullPointer;
-        checkNullPointer.runChecks(&tokenizer, &settings, this);
+        runChecks<CheckNullPointer>(tokenizer, this);
     }
 
 
 
     void nullpointerAfterLoop() {
-        check("int foo(const Token *tok)\n"
+        // extracttests.start: struct Token { const Token *next() const; std::string str() const; };
+        check("void foo(const Token *tok)\n"
               "{\n"
               "    while (tok);\n"
               "    tok = tok->next();\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (warning, inconclusive) Either the condition 'tok' is redundant or there is possible null pointer dereference: tok.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:12] -> [test.cpp:4:11]: (warning) Either the condition 'tok' is redundant or there is possible null pointer dereference: tok. [nullPointerRedundantCheck]\n", errout_str());
 
         // #2681
         {
@@ -178,11 +233,8 @@ class TestNullPointer : public TestFixture {
                                 "        ;\n"
                                 "}\n";
 
-            check(code, false);   // inconclusive=false => no error
-            ASSERT_EQUALS("", errout.str());
-
-            check(code, true);    // inconclusive=true => error
-            ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:6]: (warning, inconclusive) Either the condition 'tok' is redundant or there is possible null pointer dereference: tok.\n", errout.str());
+            check(code);
+            ASSERT_EQUALS("[test.cpp:3:12] -> [test.cpp:6:9]: (warning) Either the condition 'tok' is redundant or there is possible null pointer dereference: tok. [nullPointerRedundantCheck]\n", errout_str());
         }
 
         check("void foo()\n"
@@ -193,7 +245,7 @@ class TestNullPointer : public TestFixture {
               "            tok = tok->next();\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:3]: (warning) Either the condition 'while' is redundant or there is possible null pointer dereference: tok.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:3]: (warning) Either the condition 'while' is redundant or there is possible null pointer dereference: tok.\n", "", errout_str());
 
         check("void foo(Token &tok)\n"
               "{\n"
@@ -203,7 +255,7 @@ class TestNullPointer : public TestFixture {
               "            char c = tok.read();\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -214,7 +266,7 @@ class TestNullPointer : public TestFixture {
               "        if( !tok ) break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -224,7 +276,7 @@ class TestNullPointer : public TestFixture {
               "            tok = tok->next();\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(A*a)\n"
               "{\n"
@@ -239,7 +291,7 @@ class TestNullPointer : public TestFixture {
               "      break;\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // dereference in outer scope..
         check("void foo(int x, const Token *tok) {\n"
@@ -247,21 +299,44 @@ class TestNullPointer : public TestFixture {
               "        while (tok) tok = tok->next();\n"
               "    }\n"
               "    tok->str();\n"
-              "}\n");
-        TODO_ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:3]: (warning, inconclusive) Possible null pointer dereference: tok - otherwise it is redundant to check it against null.\n", "", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:16] -> [test.cpp:5:5]: (warning) Either the condition 'tok' is redundant or there is possible null pointer dereference: tok. [nullPointerRedundantCheck]\n", errout_str());
 
         check("int foo(const Token *tok)\n"
               "{\n"
               "    while (tok){;}\n"
-              "}\n", true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("int foo(const Token *tok)\n"
               "{\n"
               "    while (tok){;}\n"
               "    char a[2] = {0,0};\n"
-              "}\n", true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct b {\n"
+              "    b * c;\n"
+              "    int i;\n"
+              "}\n"
+              "void a(b * e) {\n"
+              "  for (b *d = e;d; d = d->c)\n"
+              "    while (d && d->i == 0)\n"
+              "      d = d->c;\n"
+              "  if (!d) throw;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct b {\n"
+              "    b * c;\n"
+              "    int i;\n"
+              "};\n"
+              "void f(b* e1, b* e2) {\n"
+              "    for (const b* d = e1; d != e2; d = d->c) {\n"
+              "        if (d && d->i != 0) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:7:13] -> [test.cpp:6:40]: (warning) Either the condition 'd' is redundant or there is possible null pointer dereference: d. [nullPointerRedundantCheck]\n", errout_str());
     }
 
     void nullpointer1() {
@@ -275,7 +350,7 @@ class TestNullPointer : public TestFixture {
               "    else if (a->x == 2) { }\n"
               "    if (a) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ticket #2134 - sizeof doesn't dereference
         check("void f() {\n"
@@ -284,16 +359,16 @@ class TestNullPointer : public TestFixture {
               "    sizeof(*list);\n"
               "    if (!list)\n"
               "        ;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         // ticket #2245 - sizeof doesn't dereference
         check("void f(Bar *p) {\n"
               "    if (!p) {\n"
               "        int sz = sizeof(p->x);\n"
               "    }\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
     }
 
@@ -304,14 +379,16 @@ class TestNullPointer : public TestFixture {
               "    Fred fred;\n"
               "    while (fred);\n"
               "    fred.hello();\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     // Dereferencing a struct and then checking if it is null
     // This is checked by this function:
-    //        CheckOther::nullPointerStructByDeRefAndChec
+    //        CheckOther::nullPointerStructByDeRefAndCheck
     void structDerefAndCheck() {
+        // extracttests.start: struct ABC { int a; int b; int x; };
+
         // errors..
         check("void foo(struct ABC *abc)\n"
               "{\n"
@@ -319,7 +396,7 @@ class TestNullPointer : public TestFixture {
               "    if (!abc)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:3]: (warning) Either the condition '!abc' is redundant or there is possible null pointer dereference: abc.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:3:13]: (warning) Either the condition '!abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n", errout_str());
 
         check("void foo(struct ABC *abc) {\n"
               "    bar(abc->a);\n"
@@ -328,9 +405,9 @@ class TestNullPointer : public TestFixture {
               "    if (!abc)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:2]: (warning) Either the condition '!abc' is redundant or there is possible null pointer dereference: abc.\n"
-                      "[test.cpp:5] -> [test.cpp:3]: (warning) Either the condition '!abc' is redundant or there is possible null pointer dereference: abc.\n"
-                      "[test.cpp:5] -> [test.cpp:4]: (warning) Either the condition '!abc' is redundant or there is possible null pointer dereference: abc.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:2:9]: (warning) Either the condition '!abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n"
+                      "[test.cpp:5:9] -> [test.cpp:3:12]: (warning) Either the condition '!abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n"
+                      "[test.cpp:5:9] -> [test.cpp:4:15]: (warning) Either the condition '!abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n", errout_str());
 
         check("void foo(ABC *abc) {\n"
               "    if (abc->a == 3) {\n"
@@ -338,7 +415,9 @@ class TestNullPointer : public TestFixture {
               "    }\n"
               "    if (abc) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:2]: (warning) Either the condition 'if(abc)' is redundant or there is possible null pointer dereference: abc.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:5:9] -> [test.cpp:2:9]: (warning) Either the condition 'abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n",
+            errout_str());
 
         check("void f(ABC *abc) {\n"
               "    if (abc->x == 0) {\n"
@@ -346,7 +425,7 @@ class TestNullPointer : public TestFixture {
               "    }\n"
               "    if (!abc);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:2]: (warning) Either the condition '!abc' is redundant or there is possible null pointer dereference: abc.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:2:9]: (warning) Either the condition '!abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n", errout_str());
 
         // TODO: False negative if member of member is dereferenced
         check("void foo(ABC *abc) {\n"
@@ -354,14 +433,16 @@ class TestNullPointer : public TestFixture {
               "    if (abc->next)\n"
               "        ;\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (warning) Possible null pointer dereference: abc - otherwise it is redundant to check it against null.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (warning) Possible null pointer dereference: abc - otherwise it is redundant to check it against null.\n", "", errout_str());
 
         check("void foo(ABC *abc) {\n"
               "    abc->a = 0;\n"
               "    if (abc && abc->b == 0)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (warning) Either the condition 'if(abc&&abc->b==0)' is redundant or there is possible null pointer dereference: abc.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:9] -> [test.cpp:2:5]: (warning) Either the condition 'abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n",
+            errout_str());
 
         // ok dereferencing in a condition
         check("void foo(struct ABC *abc)\n"
@@ -370,13 +451,13 @@ class TestNullPointer : public TestFixture {
               "    if (!abc)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(struct ABC *abc) {\n"
               "    int x = abc && a(abc->x);\n"
               "    if (abc) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ok to use a linked list..
         check("void foo(struct ABC *abc)\n"
@@ -384,14 +465,14 @@ class TestNullPointer : public TestFixture {
               "    abc = abc->next;\n"
               "    if (!abc)\n"
               "        ;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(struct ABC *abc) {\n"
               "    abc = (ABC *)(abc->_next);\n"
               "    if (abc) { }"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         // reassign struct..
         check("void foo(struct ABC *abc)\n"
@@ -400,8 +481,8 @@ class TestNullPointer : public TestFixture {
               "    abc = abc->next;\n"
               "    if (!abc)\n"
               "        ;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(struct ABC *abc)\n"
               "{\n"
@@ -409,8 +490,8 @@ class TestNullPointer : public TestFixture {
               "    f(&abc);\n"
               "    if (!abc)\n"
               "        ;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         // goto..
         check("void foo(struct ABC *abc)\n"
@@ -424,7 +505,7 @@ class TestNullPointer : public TestFixture {
               "    if (!abc)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // loops..
         check("void foo(struct ABC *abc)\n"
@@ -438,7 +519,7 @@ class TestNullPointer : public TestFixture {
               "    }\n"
               "    while (a > 0);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -450,7 +531,7 @@ class TestNullPointer : public TestFixture {
               "            return;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // dynamic_cast..
         check("void foo(ABC *abc)\n"
@@ -459,7 +540,7 @@ class TestNullPointer : public TestFixture {
               "    if (!dynamic_cast<DEF *>(abc))\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #2641 - global pointer, function call
         check("ABC *abc;\n"
@@ -468,14 +549,14 @@ class TestNullPointer : public TestFixture {
               "    do_stuff();\n"
               "    if (abc) { }\n"
               "}");
-        ASSERT_EQUALS("",errout.str());
+        ASSERT_EQUALS("",errout_str());
 
         check("Fred *fred;\n"
               "void f() {\n"
               "    fred->foo();\n"
               "    if (fred) { }\n"
               "}");
-        ASSERT_EQUALS("",errout.str());
+        ASSERT_EQUALS("",errout_str());
 
         // #2641 - local pointer, function call
         check("void f() {\n"
@@ -484,7 +565,9 @@ class TestNullPointer : public TestFixture {
               "    do_stuff();\n"
               "    if (abc) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:3]: (warning) Either the condition 'if(abc)' is redundant or there is possible null pointer dereference: abc.\n",errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:5:9] -> [test.cpp:3:5]: (warning) Either the condition 'abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n",
+            errout_str());
 
         // #2641 - local pointer, function call
         check("void f(ABC *abc) {\n"
@@ -492,7 +575,9 @@ class TestNullPointer : public TestFixture {
               "    do_stuff();\n"
               "    if (abc) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:2]: (warning) Either the condition 'if(abc)' is redundant or there is possible null pointer dereference: abc.\n",errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:4:9] -> [test.cpp:2:5]: (warning) Either the condition 'abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n",
+            errout_str());
 
         // #2691 - switch/break
         check("void f(ABC *abc) {\n"
@@ -505,32 +590,32 @@ class TestNullPointer : public TestFixture {
               "            break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #3128
         check("void f(ABC *abc) {\n"
               "    x(!abc || y(abc->a));\n"
               "    if (abc) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(ABC *abc) {\n"
               "  x(def || !abc || y(def, abc->a));\n"
               "  if (abc) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(ABC *abc) {\n"
               "  x(abc && y(def, abc->a));\n"
               "  if (abc) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(ABC *abc) {\n"
               "    x(def && abc && y(def, abc->a));\n"
               "    if (abc) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #3228 - calling function with null object
         {
@@ -539,9 +624,9 @@ class TestNullPointer : public TestFixture {
                                 "    if (fred) { }\n"
                                 "}";
             check(code);
-            ASSERT_EQUALS("", errout.str());
-            check(code, true);
-            ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (warning, inconclusive) Either the condition 'if(fred)' is redundant or there is possible null pointer dereference: fred.\n", errout.str());
+            ASSERT_EQUALS(
+                "[test.cpp:3:9] -> [test.cpp:2:5]: (warning) Either the condition 'fred' is redundant or there is possible null pointer dereference: fred. [nullPointerRedundantCheck]\n",
+                errout_str());
         }
 
         // #3425 - false positives when there are macros
@@ -550,11 +635,21 @@ class TestNullPointer : public TestFixture {
                "    fred->x = 0;\n"
                "    IF(!fred){}\n"
                "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo() {\n"
+              "  BUFFER *buffer = get_buffer();\n"
+              "  if (!buffer)\n"
+              "    uv_fatal_error();\n"
+              "  buffer->x = 11;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     // Dereferencing a pointer and then checking if it is null
     void pointerDerefAndCheck() {
+        // extracttests.start: void bar(int);
+
         // errors..
         check("void foo(int *p)\n"
               "{\n"
@@ -562,21 +657,25 @@ class TestNullPointer : public TestFixture {
               "    if (!p)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:3]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:3:6]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         check("void foo(int *p)\n"
               "{\n"
               "    *p = 0;\n"
               "    if (p) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:3]: (warning) Either the condition 'if(p)' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:4:9] -> [test.cpp:3:6]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
+            errout_str());
 
         check("void foo(int *p)\n"
               "{\n"
               "    *p = 0;\n"
               "    if (p || q) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:3]: (warning) Either the condition 'if(p||q)' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:4:9] -> [test.cpp:3:6]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
+            errout_str());
 
         check("void foo(int *p)\n"
               "{\n"
@@ -584,7 +683,7 @@ class TestNullPointer : public TestFixture {
               "    if (!p)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:3]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:3:10]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         check("void foo(char *p)\n"
               "{\n"
@@ -592,14 +691,14 @@ class TestNullPointer : public TestFixture {
               "    if (!p)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:3]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:3:12]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         check("void foo(char *p)\n"
               "{\n"
               "    if (*p == 0) { }\n"
               "    if (!p) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:3]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:3:10]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         // no error
         check("void foo()\n"
@@ -609,15 +708,15 @@ class TestNullPointer : public TestFixture {
               "    if (!p)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
               "{\n"
               "    int **p = f();\n"
               "    if (!p)\n"
               "        ;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int *p)\n"
               "{\n"
@@ -628,15 +727,15 @@ class TestNullPointer : public TestFixture {
               "    if (!p)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int x)\n"
               "{\n"
               "    int a = 2 * x;"
               "    if (x == 0)\n"
               "        ;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int *p)\n"
               "{\n"
@@ -644,28 +743,32 @@ class TestNullPointer : public TestFixture {
               "    if (!p)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void foo(int *p)\n"
+        check("void foo(int *p, bool x)\n"
               "{\n"
               "    int var1 = x ? *p : 5;\n"
               "    if (!p)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:3]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:4:9] -> [test.cpp:3:21]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
+            errout_str());
 
         // while
         check("void f(int *p) {\n"
               "    *p = 0;\n"
               "    while (p) { p = 0; }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p) {\n"
               "    *p = 0;\n"
               "    while (p) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (warning) Either the condition 'while(p)' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:12] -> [test.cpp:2:6]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
+            errout_str());
 
         // Ticket #3125
         check("void foo(ABC *p)\n"
@@ -674,7 +777,7 @@ class TestNullPointer : public TestFixture {
               "    if (!p)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(ABC *p)\n"
               "{\n"
@@ -682,29 +785,29 @@ class TestNullPointer : public TestFixture {
               "    if (!p)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int * a=0;\n"
               "    if (!a) {};\n"
               "    int c = a ? 0 : 1;\n"
-              "}\n",true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n",dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         // #3686
         check("void f() {\n"
               "    int * a=0;\n"
               "    if (!a) {};\n"
               "    int c = a ? b : b+1;\n"
-              "}\n",true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n",dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int * a=0;\n"
               "    if (!a) {};\n"
               "    int c = (a) ? b : b+1;\n"
-              "}\n",true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n",dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(P *p)\n"
               "{\n"
@@ -714,7 +817,7 @@ class TestNullPointer : public TestFixture {
               "    else\n"
               "      p = p->next();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(Document *doc) {\n"
               "    int x = doc && doc->x;\n"
@@ -722,27 +825,29 @@ class TestNullPointer : public TestFixture {
               "        return;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #3128 - false positive
         check("void f(int *p) {\n"
               "    assert(!p || (*p<=6));\n"
               "    if (p) { *p = 0; }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p) {\n"
               "    assert(p && (*p<=6));\n"
               "    if (p) { *p = 0; }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p) {\n"
               "    *p = 12;\n"
               "    assert(p && (*p<=6));\n"
               "    if (p) { *p = 0; }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:2]: (warning) Either the condition 'if(p)' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:12] -> [test.cpp:2:6]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
+            errout_str());
 
         check("void foo(x *p)\n"
               "{\n"
@@ -750,7 +855,7 @@ class TestNullPointer : public TestFixture {
               "    if (!p)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(x *p)\n"
               "{\n"
@@ -758,7 +863,7 @@ class TestNullPointer : public TestFixture {
               "    if (!p)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(x *p)\n"
               "{\n"
@@ -766,7 +871,7 @@ class TestNullPointer : public TestFixture {
               "    if (!p)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(x *p)\n"
               "{\n"
@@ -774,7 +879,7 @@ class TestNullPointer : public TestFixture {
               "    if (!p)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(struct ABC *abc)\n"
               "{\n"
@@ -782,32 +887,34 @@ class TestNullPointer : public TestFixture {
               "    if (!abc)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(struct ABC *abc) {\n" // #4523
               "    abc = (*abc).next;\n"
               "    if (abc) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(struct ABC *abc) {\n" // #4523
               "    abc = (*abc->ptr);\n"
               "    if (abc) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f(Item *item) {\n"
               "    x = item ? ab(item->x) : 0;\n"
               "    if (item) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f(Item *item) {\n"
               "    item->x = 0;\n"
               "    a = b ? c : d;\n"
               "    if (item) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:2]: (warning) Either the condition 'if(item)' is redundant or there is possible null pointer dereference: item.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:4:9] -> [test.cpp:2:5]: (warning) Either the condition 'item' is redundant or there is possible null pointer dereference: item. [nullPointerRedundantCheck]\n",
+            errout_str());
 
         check("BOOL GotoFlyAnchor()\n"  // #2243
               "{\n"
@@ -819,7 +926,7 @@ class TestNullPointer : public TestFixture {
               "    if( !pFrm )\n"
               "        return FALSE;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #2463
         check("struct A\n"
@@ -839,7 +946,7 @@ class TestNullPointer : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #2525 - sizeof
         check("void f() {\n"
@@ -847,27 +954,27 @@ class TestNullPointer : public TestFixture {
               "    int c = sizeof(test[0]);\n"
               "    if (!test)\n"
               "        ;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(type* p) {\n" // #4983
               "    x(sizeof p[0]);\n"
               "    if (!p)\n"
               "        ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #3023 - checked deref
         check("void f(struct ABC *abc) {\n"
               "  WARN_ON(!abc || abc->x == 0);\n"
               "  if (!abc) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void f(struct ABC *abc) {\n"
               "  WARN_ON(!abc || abc->x == 7);\n"
               "  if (!abc) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #3425 - false positives when there are macros
         checkP("#define IF if\n"
@@ -875,14 +982,27 @@ class TestNullPointer : public TestFixture {
                "    *p = 0;\n"
                "    IF(!p){}\n"
                "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n" // #3914 - false positive
               "    int *p;\n"
               "    ((p=ret()) && (x=*p));\n"
               "    if (p);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { struct T { char c; } *p; };\n" // #6541
+              "char f(S* s) { return s->p ? 'a' : s->p->c; }\n");
+        ASSERT_EQUALS("[test.cpp:2:24] -> [test.cpp:2:37]: (warning) Either the condition 's->p' is redundant or there is possible null pointer dereference: s->p. [nullPointerRedundantCheck]\n",
+                      errout_str());
+
+        check("int f(const int a[]) {\n" // #14544
+              "    int i = 0;\n"
+              "    if (!a)\n"
+              "        a = &i;\n"
+              "    return *a;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointer5() {
@@ -893,7 +1013,7 @@ class TestNullPointer : public TestFixture {
               " if (!a)\n"
               "   return;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // Execution paths..
@@ -909,17 +1029,17 @@ class TestNullPointer : public TestFixture {
               "    p->abcd();\n"
               "}");
         TODO_ASSERT_EQUALS("[test.cpp:8]: (error) Possible null pointer dereference: p\n",
-                           "", errout.str());
+                           "", errout_str());
 
         check("static void foo() {\n"
-              "    int &r = *0;\n"
+              "    int &r = *(int*)0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Null pointer dereference\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (error) Null pointer dereference: (int*)0 [nullPointer]\n", errout_str());
 
         check("static void foo(int x) {\n"
-              "    int y = 5 + *0;\n"
+              "    int y = 5 + *(int*)0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Null pointer dereference\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:18]: (error) Null pointer dereference: (int*)0 [nullPointer]\n", errout_str());
 
         {
             const char code[] = "static void foo() {\n"
@@ -927,19 +1047,14 @@ class TestNullPointer : public TestFixture {
                                 "    abc->a();\n"
                                 "}\n";
 
-            // inconclusive=false => no error
-            check(code,false);
-            ASSERT_EQUALS("", errout.str());
-
-            // inconclusive=true => error
-            check(code, true);
-            ASSERT_EQUALS("[test.cpp:3]: (error, inconclusive) Null pointer dereference: abc\n", errout.str());
+            check(code);
+            ASSERT_EQUALS("[test.cpp:3:5]: (error) Null pointer dereference: abc [nullPointer]\n", errout_str());
         }
 
         check("static void foo() {\n"
-              "    std::cout << *0;"
+              "    std::cout << *(int*)0;"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Null pointer dereference\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:19]: (error) Null pointer dereference: (int*)0 [nullPointer]\n", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -949,12 +1064,12 @@ class TestNullPointer : public TestFixture {
               "    }\n"
               "    c[0] = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Null pointer dereference: c\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:5]: (error) Null pointer dereference: c [nullPointer]\n", errout_str());
 
         check("static void foo() {\n"
-              "    if (3 > *0);\n"
+              "    if (3 > *(int*)0);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Null pointer dereference\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (error) Null pointer dereference: (int*)0 [nullPointer]\n", errout_str());
 
         // no false positive..
         check("static void foo()\n"
@@ -963,20 +1078,20 @@ class TestNullPointer : public TestFixture {
               "    p = new Foo;\n"
               "    p->abcd();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
               "{\n"
               "    int sz = sizeof((*(struct dummy *)0).x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void get_offset(long &offset)\n"
               "{\n"
               "    mystruct * temp; temp = 0;\n"
               "    offset = (long)(&(temp->z));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #1893 - try/catch inside else
         check("int *test(int *Z)\n"
@@ -995,7 +1110,7 @@ class TestNullPointer : public TestFixture {
               "    *Q=1;\n"
               "    return Q;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int *test(int *Z)\n"
               "{\n"
@@ -1011,7 +1126,7 @@ class TestNullPointer : public TestFixture {
               "    *Q=1;\n"
               "    return Q;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:12]: (warning) Possible null pointer dereference: Q\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:12:6]: (warning) Possible null pointer dereference: Q [nullPointer]\n", errout_str());
 
         // Ticket #2052 (false positive for 'else continue;')
         check("void f() {\n"
@@ -1022,7 +1137,7 @@ class TestNullPointer : public TestFixture {
               "        *p = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // function pointer..
         check("void foo()\n"
@@ -1031,7 +1146,16 @@ class TestNullPointer : public TestFixture {
               "    f = 0;\n"
               "    f();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Null pointer dereference: f\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5]: (error) Null pointer dereference: f [nullPointer]\n", errout_str());
+
+        check("int* g();\n" // #11007
+              "int* f() {\n"
+              "    static int* (*fun)() = 0;\n"
+              "    if (!fun)\n"
+              "        fun = g;\n"
+              "    return fun();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
 
         // loops..
         check("void f() {\n"
@@ -1040,7 +1164,7 @@ class TestNullPointer : public TestFixture {
               "        int x = *p + 1;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Null pointer dereference: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:18]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
 
         check("void f(int a) {\n"
               "    const char *p = 0;\n"
@@ -1050,22 +1174,22 @@ class TestNullPointer : public TestFixture {
               "    for (int i = 0; i < 3; i++) {\n"
               "        if (a && (p[i] == '1'));\n"
               "    }\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         // ticket #2251: taking the address of member
         check("void f() {\n"
               "    Fred *fred = 0;\n"
               "    int x = &fred->x;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
-        // ticket #3220: calling member function
+        // ticket #3220: dereferencing a null pointer is UB
         check("void f() {\n"
               "    Fred *fred = NULL;\n"
               "    fred->do_something();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Null pointer dereference: fred [nullPointer]\n", errout_str());
 
         // ticket #3570 - parsing of conditions
         {
@@ -1074,22 +1198,22 @@ class TestNullPointer : public TestFixture {
                   "    if (x)\n"
                   "        p = q;\n"
                   "    if (p && *p) { }\n"
-                  "}", true);
-            ASSERT_EQUALS("", errout.str());
+                  "}", dinit(CheckOptions, $.inconclusive = true));
+            ASSERT_EQUALS("", errout_str());
             check("void f() {\n"
                   "    int *p = NULL;\n"
                   "    if (x)\n"
                   "        p = q;\n"
                   "    if (!p || *p) { }\n"
-                  "}", true);
-            ASSERT_EQUALS("", errout.str());
+                  "}", dinit(CheckOptions, $.inconclusive = true));
+            ASSERT_EQUALS("", errout_str());
             check("void f() {\n"
                   "    int *p = NULL;\n"
                   "    if (x)\n"
                   "        p = q;\n"
                   "    if (p || *p) { }\n"
                   "}");
-            ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:5]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+            ASSERT_EQUALS("[test.cpp:5:15]: (warning) Possible null pointer dereference: p [nullPointer]\n", errout_str());
         }
 
         // ticket #8831 - FP triggered by if/return/else sequence
@@ -1104,9 +1228,15 @@ class TestNullPointer : public TestFixture {
                   "\n"
                   "void g() {\n"
                   "    f(NULL, NULL);\n"
-                  "}", true);
-            ASSERT_EQUALS("", errout.str());
+                  "}", dinit(CheckOptions, $.inconclusive = true));
+            ASSERT_EQUALS("", errout_str());
         }
+
+        check("void f() {\n" // #5979
+              "    int* const crash = 0;\n"
+              "    *crash = 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:6]: (error) Null pointer dereference: crash [nullPointer]\n", errout_str());
     }
 
     // Ticket #2350
@@ -1124,7 +1254,7 @@ class TestNullPointer : public TestFixture {
               "        argv32[i] = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // No false negative:
         check("void foo() {\n"
@@ -1139,23 +1269,23 @@ class TestNullPointer : public TestFixture {
               "        argv32[i] = 0;\n"
               "    }\n"
               "}");
-        TODO_ASSERT_EQUALS("error",
-                           "", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:9]: (warning) Possible null pointer dereference: argv32 [nullPointer]\n", errout_str());
 
         // #2231 - error if assignment in loop is not used
+        // extracttests.start: int y[20];
         check("void f() {\n"
               "    char *p = 0;\n"
               "\n"
               "    for (int x = 0; x < 3; ++x) {\n"
               "        if (y[x] == 0) {\n"
-              "            p = malloc(10);\n"
+              "            p = (char *)malloc(10);\n"
               "            break;\n"
               "        }\n"
               "    }\n"
               "\n"
               "    *p = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:11]: (warning) Possible null pointer dereference: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:11:6]: (warning) Possible null pointer dereference: p [nullPointer]\n", errout_str());
     }
 
     void nullpointer7() {
@@ -1163,8 +1293,8 @@ class TestNullPointer : public TestFixture {
               "{\n"
               "  wxLongLong x = 0;\n"
               "  int y = x.GetValue();\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointer9() { //#ticket 1778
@@ -1173,26 +1303,29 @@ class TestNullPointer : public TestFixture {
               "  std::string * x = 0;\n"
               "  *x = \"test\";\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Null pointer dereference: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:4]: (error) Null pointer dereference: x [nullPointer]\n", errout_str());
     }
 
     void nullpointer10() {
+        // extracttests.start: struct my_type { int x; };
         check("void foo()\n"
               "{\n"
               "  struct my_type* p = 0;\n"
               "  p->x = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Null pointer dereference: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:3]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
     }
 
     void nullpointer11() { // ticket #2812
+        // extracttests.start: struct my_type { int x; };
+
         check("int foo()\n"
               "{\n"
               "  struct my_type* p;\n"
               "  p = 0;\n"
               "  return p->x;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Null pointer dereference: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
     }
 
     void nullpointer12() { // ticket #2470, #4035
@@ -1202,11 +1335,14 @@ class TestNullPointer : public TestFixture {
                             "  return *i;\n"
                             "}\n";
 
-        check(code, false, "test.cpp"); // C++ file => nullptr means NULL
-        ASSERT_EQUALS("[test.cpp:4]: (error) Null pointer dereference: i\n", errout.str());
+        check(code); // C++ file => nullptr means NULL
+        ASSERT_EQUALS("[test.cpp:4:11]: (error) Null pointer dereference: i [nullPointer]\n", errout_str());
+
+        check(code, dinit(CheckOptions, $.cpp = false, $.cstd = Standards::C17)); // C17 file => nullptr does not mean NULL
+        ASSERT_EQUALS("", errout_str());
 
-        check(code, false, "test.c"); // C file => nullptr does not mean NULL
-        ASSERT_EQUALS("", errout.str());
+        check(code, dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:4:11]: (error) Null pointer dereference: i [nullPointer]\n", errout_str());
     }
 
     void nullpointer15() {  // #3560
@@ -1215,7 +1351,7 @@ class TestNullPointer : public TestFixture {
               "    if (x) p = \"abcd\";\n"
               "    return p ? f(*p) : f(0);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointer16() {  // #3591
@@ -1223,8 +1359,8 @@ class TestNullPointer : public TestFixture {
               "    int *p = 0;\n"
               "    bar(&p);\n"
               "    *p = 0;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointer17() {  // #3567
@@ -1232,15 +1368,15 @@ class TestNullPointer : public TestFixture {
               "    int *p = 0;\n"
               "    if (x) { return 0; }\n"
               "    return !p || *p;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("int foo() {\n"
               "    int *p = 0;\n"
               "    if (x) { return 0; }\n"
               "    return p && *p;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointer18() {  // #1927
@@ -1253,14 +1389,14 @@ class TestNullPointer : public TestFixture {
               "    i++;\n"
               "  };\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Null pointer dereference: str\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10]: (error) Null pointer dereference: str [nullPointer]\n", errout_str());
     }
 
     void nullpointer19() { // #3811
         check("int foo() {\n"
               "    perror(0);\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointer20() {  // #3807
@@ -1269,14 +1405,16 @@ class TestNullPointer : public TestFixture {
               "    if (x) p = q;\n"
               "    if (p ? p->x || p->y : 0) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"   // false negative
               "    struct xy *p = 0;\n"
               "    if (x) p = q;\n"
               "    if (y ? p->x : p->y) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Possible null pointer dereference: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (warning) Possible null pointer dereference: p [nullPointer]\n"
+                      "[test.cpp:4:20]: (warning) Possible null pointer dereference: p [nullPointer]\n",
+                      errout_str());
     }
 
     void nullpointer21() {  // #4038 - fp: if (x) p=q; else return;
@@ -1286,7 +1424,7 @@ class TestNullPointer : public TestFixture {
               "    else return;\n"
               "    *p = 0;\n" // <- p is not NULL
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointer23() {  // #4665
@@ -1295,7 +1433,7 @@ class TestNullPointer : public TestFixture {
               "    char cBuf[10];\n"
               "    sprintf(cBuf, \"%s\", c ? c : \"0\" );\n"
               "}");
-        ASSERT_EQUALS("",errout.str());
+        ASSERT_EQUALS("",errout_str());
     }
 
     void nullpointer24() {  // #5083 - fp: chained assignment
@@ -1304,7 +1442,7 @@ class TestNullPointer : public TestFixture {
               "    x = c = new char[10];\n"
               "    *c = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointer25() { // #5061
@@ -1314,7 +1452,7 @@ class TestNullPointer : public TestFixture {
               "    if (data == 1 && array[i] == 0)\n"
               "        std::cout << \"test\";\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Null pointer dereference: array\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:22]: (error) Null pointer dereference: array [nullPointer]\n", errout_str());
     }
 
     void nullpointer26() { // #3589
@@ -1331,7 +1469,7 @@ class TestNullPointer : public TestFixture {
               "        return 0.0;\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointer27() { // #6568
@@ -1345,32 +1483,36 @@ class TestNullPointer : public TestFixture {
               "    *pointer_=0;\n"
               "    return *this;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Null pointer dereference: pointer_\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:6]: (error) Null pointer dereference: pointer_ [nullPointer]\n", errout_str());
     }
 
     void nullpointer28() { // #6491
         check("typedef struct { int value; } S;\n"
-              "int f(const S *s) { \n"
-              "  int i = s ? s->value + 1 \n"
-              "            : s->value - 1; // <-- null ptr dereference \n"
+              "int f(const S *s) {\n"
+              "  int i = s ? s->value + 1\n"
+              "            : s->value - 1; // <-- null ptr dereference\n"
               "  return i;\n"
-              "}\n");
-        TODO_ASSERT_EQUALS("[test.cpp:4]: (warning) Possible null pointer dereference: s\n", "", errout.str());
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:3:11] -> [test.cpp:4:15]: (warning) Either the condition 's' is redundant or there is possible null pointer dereference: s. [nullPointerRedundantCheck]\n",
+            errout_str());
     }
 
     void nullpointer30() { // #6392
         check("void f(std::vector<std::string> *values)\n"
               "{\n"
               "  values->clear();\n"
-              "  if (values) \n"
+              "  if (values)\n"
               "  {\n"
               "    for (int i = 0; i < values->size(); ++i)\n"
               "    {\n"
               "      values->push_back(\"test\");\n"
               "    }\n"
               "  }\n"
-              "}\n", true);
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:3]: (warning, inconclusive) Either the condition 'if(values)' is redundant or there is possible null pointer dereference: values.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS(
+            "[test.cpp:4:7] -> [test.cpp:3:3]: (warning) Either the condition 'values' is redundant or there is possible null pointer dereference: values. [nullPointerRedundantCheck]\n",
+            errout_str());
     }
 
     void nullpointer31() { // #8482
@@ -1378,14 +1520,31 @@ class TestNullPointer : public TestFixture {
               "{\n"
               "    int x;\n"
               "};\n"
-              " \n"
+              "\n"
               "static void foo(F* f)\n"
               "{\n"
               "    if( f ) {}\n"
               "    else { return; }\n"
               "    (void)f->x;\n"
-              "}\n", true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("typedef struct\n"
+              "{\n"
+              "    int x;\n"
+              "} F;\n"
+              "\n"
+              "static void foo(F* f)\n"
+              "{\n"
+              "    if( !f || f->x == 0 )\n"
+              "    {\n"
+              "        if( !f )\n"
+              "            return;\n"
+              "    }\n"
+              "\n"
+              "    (void)f->x;\n"
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointer32() { // #8460
@@ -1396,8 +1555,8 @@ class TestNullPointer : public TestFixture {
               "    int *p1 = ptr;\n"
               "    return *p1;\n"
               "  }\n"
-              "}\n", true);
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:6]: (warning) Either the condition 'ptr' is redundant or there is possible null pointer dereference: p1.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:2:6] -> [test.cpp:6:13]: (warning) Either the condition 'ptr' is redundant or there is possible null pointer dereference: p1. [nullPointerRedundantCheck]\n", errout_str());
     }
 
     void nullpointer33() {
@@ -1406,20 +1565,20 @@ class TestNullPointer : public TestFixture {
               "        *x = 2;\n"
               "    else\n"
               "        *x = 3;\n"
-              "}\n", true);
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:5]: (warning) Either the condition 'x!=nullptr' is redundant or there is possible null pointer dereference: x.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:5:10]: (warning) Either the condition 'x!=nullptr' is redundant or there is possible null pointer dereference: x. [nullPointerRedundantCheck]\n", errout_str());
     }
 
     void nullpointer34() {
         check("void g() {\n"
-              "    throw "";\n"
+              "    throw " ";\n"
               "}\n"
               "bool f(int * x) {\n"
               "    if (x) *x += 1;\n"
               "    if (!x) g();\n"
               "    return *x;\n"
-              "}\n", true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointer35() {
@@ -1431,8 +1590,21 @@ class TestNullPointer : public TestFixture {
               "}\n"
               "void h() {\n"
               "    g(0);\n"
-              "}\n", true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool f(int*);\n"
+              "void g(int* x) {\n"
+              "    bool b = f(x);\n"
+              "    if (b) {\n"
+              "        *x = 1;\n"
+              "    }\n"
+              "}\n"
+              "void h() {\n"
+              "    g(0);\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointer36() {
@@ -1443,8 +1615,8 @@ class TestNullPointer : public TestFixture {
               "    while (isspace(*start))\n"
               "        start++;\n"
               "    return (start);\n"
-              "}\n", true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointer37() {
@@ -1462,8 +1634,8 @@ class TestNullPointer : public TestFixture {
               "        ptr1++;\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointer38() {
@@ -1474,8 +1646,8 @@ class TestNullPointer : public TestFixture {
               "        *x;\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointer39() {
@@ -1483,10 +1655,10 @@ class TestNullPointer : public TestFixture {
               "void f(struct A *a) {\n"
               "    if (a->x == NULL) {}\n"
               "    *(a->x);\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:4]: (warning) Either the condition 'a->x==NULL' is redundant or there is possible null pointer dereference: a->x.\n",
-            errout.str());
+            "[test.cpp:3:14] -> [test.cpp:4:8]: (warning) Either the condition 'a->x==NULL' is redundant or there is possible null pointer dereference: a->x. [nullPointerRedundantCheck]\n",
+            errout_str());
     }
 
     void nullpointer40() {
@@ -1494,10 +1666,10 @@ class TestNullPointer : public TestFixture {
               "void f(struct A *a) {\n"
               "    if (a->x == nullptr) {}\n"
               "    *(a->x);\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:4]: (warning) Either the condition 'a->x==nullptr' is redundant or there is possible null pointer dereference: a->x.\n",
-            errout.str());
+            "[test.cpp:3:14] -> [test.cpp:4:8]: (warning) Either the condition 'a->x==nullptr' is redundant or there is possible null pointer dereference: a->x. [nullPointerRedundantCheck]\n",
+            errout_str());
     }
 
     void nullpointer41() {
@@ -1505,17 +1677,17 @@ class TestNullPointer : public TestFixture {
               "void f(struct A *a) {\n"
               "    if (a->g() == nullptr) {}\n"
               "    *(a->g());\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:4]: (warning) Either the condition 'a->g()==nullptr' is redundant or there is possible null pointer dereference: a->g().\n",
-            errout.str());
+            "[test.cpp:3:16] -> [test.cpp:4:11]: (warning) Either the condition 'a->g()==nullptr' is redundant or there is possible null pointer dereference: a->g(). [nullPointerRedundantCheck]\n",
+            errout_str());
 
         check("struct A { int * g(); };\n"
               "void f(struct A *a) {\n"
               "    if (a->g() == nullptr) {}\n"
               "    *(a->g());\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointer42() {
@@ -1523,222 +1695,1500 @@ class TestNullPointer : public TestFixture {
               "void f(struct A *a) {\n"
               "    if (a->g() == nullptr) {}\n"
               "    *(a->g());\n"
-              "}\n");
-        ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:4]: (warning) Either the condition 'a->g()==nullptr' is redundant or there is possible null pointer dereference: a->g().\n",
-            errout.str());
-    }
-
-    void nullpointer_addressOf() { // address of
-        check("void f() {\n"
-              "  struct X *x = 0;\n"
-              "  if (addr == &x->y) {}\n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
-
-        check("void f() {\n"
-              "  struct X *x = 0;\n"
-              "  if (addr == &x->y.z[0]) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:16] -> [test.cpp:4:11]: (warning) Either the condition 'a->g()==nullptr' is redundant or there is possible null pointer dereference: a->g(). [nullPointerRedundantCheck]\n",
+            errout_str());
     }
 
-    void nullpointerSwitch() { // #2626
-        check("char *f(int x) {\n"
-              "    char *p = do_something();\n"
-              "    switch (x) {\n"
-              "      case 1:\n"
-              "        p = 0;\n"
-              "      case 2:\n"
-              "        *p = 0;\n"
-              "        break;\n"
+    void nullpointer43() {
+        check("struct A { int* x; };\n"
+              "void f(A* a) {\n"
+              "    int * x = a->x;\n"
+              "    if (x) {\n"
+              "        (void)*a->x;\n"
               "    }\n"
-              "    return p;\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:7]: (warning) Possible null pointer dereference: p\n", errout.str());
-    }
-
-    void nullpointer_cast() { // #4692
-        check("char *nasm_skip_spaces(const char *p) {\n"
-              "    if (p)\n"
-              "        while (*p && nasm_isspace(*p))\n"
-              "            p++;\n"
-              "    return p;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void nullpointer_castToVoid() {  // #3771
-        check("void f () {\n"
-              "    int *buf; buf = NULL;\n"
-              "    buf;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+    void nullpointer44() {
+        // #9395
+        check("int foo( ) {\n"
+              "    const B* b = getB();\n"
+              "    const double w = ( nullptr != b) ? 42. : 0.0;\n"
+              "    if ( w == 0.0 )\n"
+              "        return 0;\n"
+              "    return b->get();\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+        // #9423
+        check("extern F* GetF();\n"
+              "extern L* GetL();\n"
+              "void Foo() {\n"
+              "    const F* const fPtr = GetF();\n"
+              "    const bool fPtrOk = fPtr != NULL;\n"
+              "    assert(fPtrOk);\n"
+              "    if (!fPtrOk)\n"
+              "        return;\n"
+              "    L* const lPtr = fPtr->l;\n"
+              "    const bool lPtrOk = lPtr != NULL;\n"
+              "    assert(lPtrOk);\n"
+              "    if (!lPtrOk)\n"
+              "        return;\n"
+              "    lPtr->Clear();\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void nullpointer_subfunction() {
-        check("int f(int* x, int* y) {\n"
-              "    if (!x)\n"
-              "        return;\n"
-              "    return *x + *y;\n"
-              "}\n"
-              "void g() {\n"
-              "    f(nullptr, nullptr);\n"
-              "}\n", true);
-        ASSERT_EQUALS("", errout.str());
+    void nullpointer45() {
+        check("struct a {\n"
+              "  a *b() const;\n"
+              "};\n"
+              "void g() { throw 0; }\n"
+              "a h(a * c) {\n"
+              "  if (c && c->b()) {}\n"
+              "  if (!c)\n"
+              "    g();\n"
+              "  if (!c->b())\n"
+              "    g();\n"
+              "  a d = *c->b();\n"
+              "  return d;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct a {\n"
+              "  a *b() const;\n"
+              "};\n"
+              "void e() { throw 0; }\n"
+              "a f() {\n"
+              "  a *c = 0;\n"
+              "  if (0 && c->b()) {}\n"
+              "  if (!c)\n"
+              "    e();\n"
+              "  if (!c->b())\n"
+              "    e();\n"
+              "  a d = *c->b();\n"
+              "  return d;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
-    // Check if pointer is null and the dereference it
-    void pointerCheckAndDeRef() {
-        check("void foo(char *p) {\n"
-              "    if (!p) {\n"
-              "    }\n"
-              "    *p = 0;\n"
+    void nullpointer46() {
+        check("void f() {\n"
+              "    char* p = new(std::nothrow) char[1];\n"
+              "    if( p ) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        check("void foo(char *p) {\n"
-              "    if (p && *p == 0) {\n"
-              "    }\n"
-              "    printf(\"%c\", *p);\n"
+    void nullpointer47() {
+        check("void f(int *p) {\n"
+              "   if(!p[0]) {}\n"
+              "   const int *const a = p;\n"
+              "   if(!a){}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7] -> [test.cpp:2:8]: (warning) Either the condition '!a' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
+    }
 
-        check("void foo(char *p) {\n"
-              "    if (p && *p == 0) {\n"
-              "    } else { *p = 0; }\n"
+    void nullpointer48() {
+        check("template<class T>\n"
+              "auto f(T& x) -> decltype(x);\n"
+              "int& g(int* x) {\n"
+              "    return f(*x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        check("void foo(char *p) {\n"
-              "    if (p) {\n"
-              "    }\n"
-              "    strcpy(p, \"abc\");\n"
+    void nullpointer49() {
+        check("void f(int *p, int n) {\n"
+              "    int *q = 0;\n"
+              "    if(n > 10) q = p;\n"
+              "    *p +=2;\n"
+              "    if(n < 120) *q+=12;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:18]: (warning) Possible null pointer dereference: q [nullPointer]\n", errout_str());
 
-        check("void foo(char *p) {\n"
-              "    if (p) {\n"
-              "    }\n"
-              "    bar();\n"
-              "    strcpy(p, \"abc\");\n"
+        check("void f(int *p, int n) {\n"
+              "    int *q = 0;\n"
+              "    if(n > 10) q = p;\n"
+              "    *p +=2;\n"
+              "    if(n > 10) *q+=12;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:5]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        check("void foo(abc *p) {\n"
-              "    if (!p) {\n"
+    void nullpointer50() {
+        check("void f(int *p, int a) {\n"
+              "    if(!p) {\n"
+              "        if(a > 0) {\n"
+              "            if(a > 10){}\n"
+              "            else {\n"
+              "                *p = 0;\n"
+              "            }\n"
+              "        }\n"
               "    }\n"
-              "    else { if (!p->x) {\n"
-              "    } }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:8] -> [test.cpp:6:18]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
+            errout_str());
+    }
 
-        {
-            static const char code[] =
-                "void foo(char *p) {\n"
-                "    if (!p) {\n"
-                "        abort();\n"
-                "    }\n"
-                "    *p = 0;\n"
-                "}";
-            check(code, false);
-            ASSERT_EQUALS("", errout.str());
+    void nullpointer51() {
+        check("struct a {\n"
+              "  a *b();\n"
+              "};\n"
+              "bool c(a *, const char *);\n"
+              "a *d(a *e) {\n"
+              "  if (e) {}\n"
+              "  if (c(e, \"\"))\n"
+              "    return nullptr;\n"
+              "  return e->b();\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
 
-            check(code, true);
-            ASSERT_EQUALS("", errout.str());
-        }
+    void nullpointer52() {
+        check("int f(int a, int* b) {\n"
+              "    int* c = nullptr;\n"
+              "    if(b) c = b;\n"
+              "    if (!c) c = &a;\n"
+              "    return *c;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int a, int* b) {\n"
+              "    int* c = nullptr;\n"
+              "    if(b) c = b;\n"
+              "    bool d = !c;\n"
+              "    if (d) c = &a;\n"
+              "    return *c;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A { int* x; };\n"
+              "int f(int a, int* b) {\n"
+              "    A c;\n"
+              "    c.x = nullptr;\n"
+              "    if(b) c.x = b;\n"
+              "    if (!c.x) c.x = &a;\n"
+              "    return *c.x;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A { int* x; };\n"
+              "int f(int a, int* b) {\n"
+              "    A c;\n"
+              "    c.x = nullptr;\n"
+              "    if(b) c.x = b;\n"
+              "    bool d = !c.x;\n"
+              "    if (d) c.x = &a;\n"
+              "    return *c.x;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A { int* x; };\n"
+              "int f(int a, int* b) {\n"
+              "    A c;\n"
+              "    c.x = nullptr;\n"
+              "    if(b) c.x = b;\n"
+              "    bool d = !c.x;\n"
+              "    if (!d) c.x = &a;\n"
+              "    return *c.x;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:8:14]: (warning) Possible null pointer dereference: c.x [nullPointer]\n", errout_str());
+    }
 
-        check("void foo(char *p) {\n"
-              "    if (!p) {\n"
-              "        (*bail)();\n"
-              "    }\n"
-              "    *p = 0;\n"
+    void nullpointer53() {
+        check("void f(int nParams, int* params) {\n"
+              "  for (int n=1; n<nParams+10; ++n) {\n"
+              "    params[n]=42;\n"
+              "  }\n"
+              "}\n"
+              "void bar() {\n"
+              "  f(0, 0);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Possible null pointer dereference: params [nullPointer]\n", errout_str());
+    }
 
-        check("void foo(char *p) {\n"
-              "    if (!p) {\n"
-              "        throw x;\n"
+    void nullpointer54() {
+        check("int foo (int **array, size_t n_array) {\n"
+              "    size_t i;\n"
+              "    for (i = 0; i < n_array; ++i) {\n"
+              "        if (*array[i] == 1)\n"
+              "            return 1;\n"
               "    }\n"
-              "    *p = 0;\n"
+              "    return 0;\n"
+              "}\n"
+              "int bar() {\n"
+              "    int **array = NULL;\n"
+              "    foo (array, 0);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        check("void foo(char *p) {\n"
-              "    if (!p) {\n"
-              "        ab.abort();\n"
-              "    }\n"
-              "    *p = 0;\n"
+    void nullpointer55() {
+        check("void f(const Token* tok) {\n"
+              "    const Token* tok3 = tok;\n"
+              "    while (tok3->astParent() && tok3->str() == \",\")\n"
+              "        tok3 = tok3->astParent();\n"
+              "    if (tok3 && tok3->str() == \"(\") {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
-
-        check("void foo(char *p) {\n"
-              "    if (!p) {\n"
-              "        switch (x) { }\n"
+        ASSERT_EQUALS(
+            "[test.cpp:5:9] -> [test.cpp:3:12]: (warning) Either the condition 'tok3' is redundant or there is possible null pointer dereference: tok3. [nullPointerRedundantCheck]\n",
+            errout_str());
+
+        check("void f(int* t1, int* t2) {\n"
+              "    while (t1 && t2 &&\n"
+              "       *t1 == *t2) {\n"
+              "        t1 = nullptr;\n"
+              "        t2 = nullptr;\n"
               "    }\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "    if (!t1 || !t2)\n"
+              "        return;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("void foo(char *p) {\n"
-              "    if (!p) {\n"
-              "    }\n"
-              "    return *x;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+        check("bool f(int* i);\n"
+              "void g(int* i) {\n"
+              "    while(f(i) && *i == 0)\n"
+              "        i++;\n"
+              "    if (!i) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        check("int foo(int *p) {\n"
-              "    if (!p) {\n"
-              "        x = *p;\n"
-              "        return 5+*p;\n"
-              "    }\n"
+    void nullpointer56() {
+        check("struct ListEntry {\n"
+              "    struct ListEntry *next;\n"
+              "};\n"
+              "static void dostuff(ListEntry * listHead) {\n"
+              "    ListEntry *prev = NULL;\n"
+              "    for (ListEntry *cursor = listHead; cursor != NULL; prev = cursor, cursor = cursor->next) {}\n"
+              "    if (prev) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p.\n"
-                      "[test.cpp:2] -> [test.cpp:4]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        // operator!
+    void nullpointer57() {
         check("void f() {\n"
-              "    A a;\n"
-              "    if (!a) {\n"
-              "        a.x();\n"
+              "    FILE* fptr = fopen(\"test\", \"r\");\n"
+              "    if (fptr != nullptr) {\n"
+              "        std::function<void()> fn([&] {\n"
+              "            fclose(fptr);\n"
+              "            fptr = NULL;\n"
+              "        });\n"
+              "        fgetc(fptr);\n"
+              "        fn();\n"
               "    }\n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        // This is why this check can't be used on the simplified token list
-        check("void f(Foo *foo) {\n"
-              "    if (!dynamic_cast<bar *>(foo)) {\n"
-              "        *foo = 0;\n"
-              "    }\n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
+    void nullpointer58() {
+        check("struct myStruct { char entry[0]; };\n"
+              "void f() {\n"
+              "    struct myStruct* sPtr = NULL;\n"
+              "    int sz = (!*(&sPtr) || ((*(&sPtr))->entry[0] > 15)) ?\n"
+              "        sizeof((*(&sPtr))->entry[0]) : 123456789;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        // ticket: #2300 - calling unknown function that may initialize the pointer
-        check("Fred *fred;\n"
-              "void a() {\n"
-              "    if (!fred) {\n"
-              "        initfred();\n"
-              "        fred->x = 0;\n"
-              "    }\n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
+    void nullpointer59() {
+        check("struct Box {\n"
+              "    struct Box* prev;\n"
+              "    struct Box* next;\n"
+              "};\n"
+              "void foo(Box** pfreeboxes) {\n"
+              "    Box *b = *pfreeboxes;\n"
+              "    *pfreeboxes = b->next;\n"
+              "    if( *pfreeboxes )\n"
+              "        (*pfreeboxes)->prev = nullptr;\n"
+              "    b->next = nullptr;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        // ticket #1219
-        check("void foo(char *p) {\n"
-              "    if (p) {\n"
+    void nullpointer60() {
+        check("void f(){\n"
+              "    char uuid[128];\n"
+              "    char *s1;\n"
+              "    memset(uuid, 0, sizeof(uuid));\n"
+              "    s1 = strchr(uuid, '=');\n"
+              "    s1 = s1 ? s1 + 1 : &uuid[5];\n"
+              "    if (!strcmp(\"00000000000000000000000000000000\", s1) )\n"
               "        return;\n"
-              "    }\n"
-              "    *p = 0;\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:5]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        // #2467 - unknown macro may terminate the application
-        check("void f(Fred *fred) {\n"
-              "    if (fred == NULL) {\n"
-              "        MACRO;\n"
-              "    }\n"
+    void nullpointer61() {
+        check("struct a {\n"
+              "  int *e;\n"
+              "};\n"
+              "struct f {\n"
+              "  a *g() const;\n"
+              "};\n"
+              "void h() {\n"
+              "  for (f b;;) {\n"
+              "    a *c = b.g();\n"
+              "    int *d = c->e;\n"
+              "    if (d)\n"
+              "      ;\n"
+              "  }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "  A* g() const;\n"
+              "  A* h() const;\n"
+              "};\n"
+              "void f(A* a) {\n"
+              "  if (!a->h())\n"
+              "    return;\n"
+              "  const A *b = a;\n"
+              "  while (b && !b->h())\n"
+              "      b = b->g();\n"
+              "  if (!b || b == b->g()->h())\n"
+              "      return;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer62() {
+        check("struct A {\n"
+              "  bool f()() const;\n"
+              "};\n"
+              "void a(A *x) {\n"
+              "  std::string b = x && x->f() ? \"\" : \"\";\n"
+              "  if (x) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "  bool f()() const;\n"
+              "};\n"
+              "void a(A *x) {\n"
+              "  std::string b = (!x || x->f()) ? \"\" : \"\";\n"
+              "  if (x) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "  A * aa;\n"
+              "};\n"
+              "void b(A*);\n"
+              "void a(A *x) {\n"
+              "  b(x ? x->aa : nullptr);\n"
+              "  if (!x) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer63() {
+        check("struct A {\n"
+              "    A* a() const;\n"
+              "    A* b() const;\n"
+              "};\n"
+              "A* f(A*);\n"
+              "void g(const A* x) {\n"
+              "    A *d = x->a();\n"
+              "    d = f(d->b()) ? d->a() : nullptr;\n"
+              "    if (d && f(d->b())) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer64() {
+        check("struct A {\n"
+              "  A* f() const;\n"
+              "  int g() const;\n"
+              "};\n"
+              "bool a;\n"
+              "bool b(A* c) {\n"
+              "    if (c->g() == 0)\n"
+              "      ;\n"
+              "    A *aq = c;\n"
+              "    if (c->g() == 0)\n"
+              "      c = c->f();\n"
+              "    if (c)\n"
+              "      for (A *d = c; d != aq; d = d->f()) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "  A* g() const;\n"
+              "  A* h() const;\n"
+              "};\n"
+              "bool i(A*);\n"
+              "void f(A* x) {\n"
+              "  if (i(x->g())) {\n"
+              "    A *y = x->g();\n"
+              "    x = x->g()->h();\n"
+              "    if (x && x->g()) {\n"
+              "        y = x->g()->h();\n"
+              "    }\n"
+              "    if (!y) {}\n"
+              "  }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer65() {
+        check("struct A {\n"
+              "    double get();\n"
+              "};\n"
+              "double x;\n"
+              "double run(A** begin, A** end) {\n"
+              "    A* a = nullptr;\n"
+              "    while (begin != end) {\n"
+              "        a = *begin;\n"
+              "        x = a->get();\n"
+              "        ++begin;\n"
+              "    }\n"
+              "    x = 0;\n"
+              "    if (a)\n"
+              "        return a->get();\n"
+              "    return 0;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer66() {
+        check("int f() {\n"
+              "    int ret = 0;\n"
+              "    int *v = nullptr;\n"
+              "    if (!MyAlloc(&v)) {\n"
+              "        ret = -1;\n"
+              "        goto done;\n"
+              "    }\n"
+              "    DoSomething(*v);\n"
+              "done:\n"
+              "    if (v)\n"
+              "      MyFree(&v);\n"
+              "    return ret;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer67() {
+        check("int result;\n"
+              "\n"
+              "int test_b(void) {\n"
+              "    char **string = NULL;\n"
+              "\n"
+              "    /* The bug disappears if \"result =\" is omitted. */\n"
+              "    result = some_other_call(&string);\n"
+              "    if (string && string[0])\n"
+              "        return 0;\n"
+              "    return -1;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int result;\n"
+              "\n"
+              "int test_b(void) {\n"
+              "    char **string = NULL;\n"
+              "\n"
+              "    some_other_call(&string);\n"
+              "    if (string && string[0])\n"
+              "        return 0;\n"
+              "    return -1;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer68() {
+        check("struct A {\n"
+              "    A* b;\n"
+              "};\n"
+              "void f(A* c) {\n"
+              "    c = c->b;\n"
+              "    if (c->b) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "    A* b;\n"
+              "};\n"
+              "void f(A* c) {\n"
+              "    A* d = c->b;\n"
+              "    A *e = c;\n"
+              "    while (nullptr != (e = e->b)) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer69() {
+        check("void f(const Scope *scope) {\n"
+              "    if (scope->definedType) {}\n"
+              "    while (scope) {\n"
+              "        scope = scope->nestedIn;\n"
+              "        enumerator = scope->findEnumerator();\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:12] -> [test.cpp:5:22]: (warning) Either the condition 'scope' is redundant or there is possible null pointer dereference: scope. [nullPointerRedundantCheck]\n",
+            errout_str());
+
+        check("void f(const Scope *scope) {\n"
+              "    if (scope->definedType) {}\n"
+              "    while (scope && scope->nestedIn) {\n"
+              "        if (scope->type == Scope::eFunction && scope->functionOf)\n"
+              "            scope = scope->functionOf;\n"
+              "        else\n"
+              "            scope = scope->nestedIn;\n"
+              "        enumerator = scope->findEnumerator();\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:12] -> [test.cpp:8:22]: (warning) Either the condition 'scope' is redundant or there is possible null pointer dereference: scope. [nullPointerRedundantCheck]\n",
+            errout_str());
+
+        check("struct a {\n"
+              "  a *b() const;\n"
+              "  void c();\n"
+              "};\n"
+              "void d() {\n"
+              "  for (a *e;;) {\n"
+              "    e->b()->c();\n"
+              "    while (e)\n"
+              "      e = e->b();\n"
+              "  }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer70() {
+        check("struct Token {\n"
+              "    const Token* nextArgument() const;\n"
+              "    const Token* next() const;\n"
+              "    int varId() const;\n"
+              "};\n"
+              "int f(const Token *first, const Token* second) {\n"
+              "    first = first->nextArgument();\n"
+              "    if (first)\n"
+              "        first = first->next();\n"
+              "    if (second->next()->varId() == 0) {\n"
+              "        second = second->nextArgument();\n"
+              "        if (!first || !second)\n"
+              "            return 0;\n"
+              "    } else if (!first) {\n"
+              "        return 0;\n"
+              "    }\n"
+              "    return first->varId();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct Token {\n"
+              "    const Token* nextArgument() const;\n"
+              "    const Token* next() const;\n"
+              "    int varId() const;\n"
+              "    void str() const;"
+              "};\n"
+              "void f(const Token *first) {\n"
+              "    first = first->nextArgument();\n"
+              "    if (first)\n"
+              "        first = first->next();\n"
+              "    first->str();\n"
+              "}\n");
+        TODO_ASSERT_EQUALS(
+            "[test.cpp:8] -> [test.cpp:10]: (warning) Either the condition 'first' is redundant or there is possible null pointer dereference: first.\n",
+            "",
+            errout_str());
+    }
+
+    void nullpointer71() {
+        check("void f() {\n"
+              "  Device* dev = Get();\n"
+              "  SetCount(dev == nullptr ? 0 : dev->size());\n"
+              "  if (dev)\n"
+              "    DoSomething(dev);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "  Device* dev = Get();\n"
+              "  SetCount(dev != nullptr ? dev->size() : 0);\n"
+              "  if (dev)\n"
+              "    DoSomething(dev);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer72() { // #10215
+        check("int test() {\n"
+              "  int* p0 = nullptr, *p1 = nullptr;\n"
+              "  getFoo(p0);\n"
+              "  getBar(p1);\n"
+              "  if (!(p0 != nullptr && p1 != nullptr))\n"
+              "    return {};\n"
+              "  return *p0 + *p1;\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("int test2() {\n"
+              "  int* p0 = nullptr;\n"
+              "  if (!(getBaz(p0) && p0 != nullptr))\n"
+              "    return 0;\n"
+              "  return *p0;\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("int test3() {\n"
+              "  Obj* PObj = nullptr;\n"
+              "  if (!(GetObj(PObj) && PObj != nullptr))\n"
+              "    return 1;\n"
+              "  if (!PObj->foo())\n"
+              "    test();\n"
+              "  PObj->bar();\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer73() {
+        check("void f(bool flag2, int* ptr) {\n"
+              "    bool flag1 = true;\n"
+              "    if (flag2) {\n"
+              "        if (ptr != nullptr)\n"
+              "            (*ptr)++;\n"
+              "        else\n"
+              "            flag1 = false;\n"
+              "    }\n"
+              "    if (flag1 && flag2)\n"
+              "        (*ptr)++;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(bool flag2, int* ptr) {\n"
+              "    bool flag1 = true;\n"
+              "    if (flag2) {\n"
+              "        if (ptr != nullptr)\n"
+              "            (*ptr)++;\n"
+              "        else\n"
+              "            flag1 = false;\n"
+              "    }\n"
+              "    if (!flag1 && flag2)\n"
+              "        (*ptr)++;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:17] -> [test.cpp:10:11]: (warning) Either the condition 'ptr!=nullptr' is redundant or there is possible null pointer dereference: ptr. [nullPointerRedundantCheck]\n", errout_str());
+    }
+
+    void nullpointer74() {
+        check("struct d {\n"
+              "  d* e();\n"
+              "};\n"
+              "void g(d* f) {\n"
+              "  do {\n"
+              "    f = f->e();\n"
+              "    if (f) {}\n"
+              "  } while (0);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct d {\n"
+              "  d* e();\n"
+              "};\n"
+              "void g(d* f, int i) {\n"
+              "  do {\n"
+              "    i--;\n"
+              "    f = f->e();\n"
+              "    if (f) {}\n"
+              "  } while (i > 0);\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:8:9] -> [test.cpp:7:9]: (warning) Either the condition 'f' is redundant or there is possible null pointer dereference: f. [nullPointerRedundantCheck]\n",
+            errout_str());
+
+        check("struct d {\n"
+              "  d* e();\n"
+              "};\n"
+              "void g(d* f, int i) {\n"
+              "  do {\n"
+              "    i--;\n"
+              "    f = f->e();\n"
+              "    if (f) {}\n"
+              "  } while (f && i > 0);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer75() {
+        check("struct a {\n"
+              "  a *b() const;\n"
+              "  void c();\n"
+              "  int d() const;\n"
+              "};\n"
+              "void e(a *x) {\n"
+              "  while (x->b()->d() == 0)\n"
+              "    x->c();\n"
+              "  x->c();\n"
+              "  if (x->b()) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer76()
+    {
+        check("int* foo(int y) {\n"
+              "    std::unique_ptr<int> x = std::make_unique<int>(0);\n"
+              "    if( y == 0 )\n"
+              "        return x.release();\n"
+              "    (*x) ++;\n"
+              "    return x.release();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer77()
+    {
+        check("bool h(int*);\n"
+              "void f(int* i) {\n"
+              "    int* i = nullptr;\n"
+              "    if (h(i) && *i == 1) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool h(int*);\n"
+              "void f(int* i) {\n"
+              "    int* i = nullptr;\n"
+              "    if (h(i))\n"
+              "        if (*i == 1) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool h(int*);\n"
+              "void f(int* x) {\n"
+              "    int* i = x;\n"
+              "    if (h(i))\n"
+              "        i = nullptr;\n"
+              "    if (h(i) && *i == 1) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int i) {\n" // #13797
+              "    int* p = nullptr;\n"
+              "    if (!i) {\n"
+              "        *p = 0;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
+    }
+
+    void nullpointer78() // #7802
+    {
+        check("void f()\n"
+              "{\n"
+              "    int **pp;\n"
+              "    int *p = 0;\n"
+              "    pp = &p;\n"
+              "    **pp = 1;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:6:6]: (error) Null pointer dereference: *pp [nullPointer]\n", errout_str());
+    }
+
+    void nullpointer79() // #10400
+    {
+        check("void resize(size_t nF, size_t nT) {\n"
+              "    double* pValues = nullptr;\n"
+              "    if (nF > 0 && nT > 0)\n"
+              "        pValues = new double[nF * nT];\n"
+              "    for (size_t cc = 0; cc < nF * nT; ++cc)\n"
+              "        pValues[cc] = 42;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer80() // #10410
+    {
+        check("int f(int* a, int* b) {\n"
+              "    if( a || b ) {\n"
+              "        int n = a ? *a : *b;\n"
+              "        if( b )\n"
+              "            n++;\n"
+              "        return n;\n"
+              "    }\n"
+              "    return 0;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer81() // #8724
+    {
+        check("void f(A **list) {\n"
+              "  A *tmp_List = NULL;\n"
+              "  *list = NULL;\n"
+              "  while (1) {\n"
+              "    if (*list == NULL) {\n"
+              "      tmp_List = malloc (sizeof (ArchiveList_struct));\n"
+              "      *list = tmp_List;\n"
+              "    } else {\n"
+              "      tmp_List->next = malloc (sizeof (ArchiveList_struct));\n"
+              "    }\n"
+              "  }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer82() // #10331
+    {
+        check("bool g();\n"
+              "int* h();\n"
+              "void f(int* ptr) {\n"
+              "    if (!ptr) {\n"
+              "        if (g())\n"
+              "            goto done;\n"
+              "        ptr = h();\n"
+              "        if (!ptr)\n"
+              "            return;\n"
+              "    }\n"
+              "    if (*ptr == 1)\n"
+              "        return;\n"
+              "\n"
+              "done:\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer83() // #9870
+    {
+        check("int* qux();\n"
+              "int* f7c2(int *x) {\n"
+              "  int* p = 0;\n"
+              "  if (nullptr == x)\n"
+              "    p = qux();\n"
+              "  if (nullptr == x)\n"
+              "    return x;\n"
+              "  *p = 1;\n"
+              "  return x;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:8:4]: (warning) Possible null pointer dereference: p [nullPointer]\n", errout_str());
+    }
+
+    void nullpointer84() // #9873
+    {
+        check("void f(std::unique_ptr<A> P) {\n"
+              "  A *RP = P.get();\n"
+              "  if (!RP) {\n"
+              "    P->foo();\n"
+              "  }\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:7] -> [test.cpp:4:5]: (warning) Either the condition '!RP' is redundant or there is possible null pointer dereference: P. [nullPointerRedundantCheck]\n",
+            errout_str());
+    }
+
+    void nullpointer85() // #10210
+    {
+        check("struct MyStruct {\n"
+              "  int GetId() const {\n"
+              "      int id = 0;\n"
+              "      int page = m_notebook->GetSelection();\n"
+              "      if (m_notebook && (m_notebook->GetPageCount() > 0))\n"
+              "        id = page;\n"
+              "      return id;\n"
+              "  }\n"
+              "  wxNoteBook *m_notebook = nullptr;\n"
+              "};\n"
+              "int f() {\n"
+              "  const MyStruct &s = Get();\n"
+              "  return s.GetId();\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:5:11] -> [test.cpp:4:18]: (warning) Either the condition 'm_notebook' is redundant or there is possible null pointer dereference: m_notebook. [nullPointerRedundantCheck]\n",
+            errout_str());
+    }
+
+    void nullpointer86()
+    {
+        check("struct A {\n"
+              "    A* a() const;\n"
+              "    int b() const;\n"
+              "};\n"
+              "A* f(A* t) {\n"
+              "    if (t->b() == 0) {\n"
+              "        return t;\n"
+              "    }\n"
+              "    return t->a();\n"
+              "}\n"
+              "void g(A* t) {\n"
+              "    t = f(t->a());\n"
+              "    if (!t->a()) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer87() // #9291
+    {
+        check("int f(bool b, int* x) {\n"
+              "    if (b && x == nullptr)\n"
+              "        return 0;\n"
+              "    else if (!b && x == nullptr)\n"
+              "        return 1;\n"
+              "    else if (!b && x != nullptr)\n"
+              "        return *x;\n"
+              "    else\n"
+              "        return *x + 1;\n"
+              "}\n");
+        TODO_ASSERT_EQUALS("", "[test.cpp:6:22] -> [test.cpp:9:17]: (warning) Either the condition 'x!=nullptr' is redundant or there is possible null pointer dereference: x. [nullPointerRedundantCheck]\n", errout_str());
+
+        check("void f(int n, int* p) {\n"
+              "    int* r = nullptr;\n"
+              "    if (n < 0)\n"
+              "        return;\n"
+              "    if (n == 0)\n"
+              "        r = p;\n"
+              "    else if (n > 0)\n"
+              "        r = p + 1;\n"
+              "    *r;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer88() // #9949
+    {
+        check("struct S { char **ppc; };\n"
+              "int alloc(struct S* s) {\n"
+              "    char** ppc = malloc(4096);\n"
+              "    if (ppc != NULL) {\n"
+              "        s->ppc = ppc;\n"
+              "        return 1;\n"
+              "    }\n"
+              "    return 0;\n"
+              "}\n"
+              "void f() {\n"
+              "    struct S* s = malloc(sizeof(struct S));\n"
+              "    if (!s) return;\n"
+              "    s->ppc = NULL;\n"
+              "    if (alloc(s))\n"
+              "        s->ppc[0] = \"\";\n"
+              "}\n", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer89() // #10640
+    {
+        check("typedef struct {\n"
+              "    int x;\n"
+              "} foo_t;\n"
+              "typedef struct {\n"
+              "    foo_t *y;\n"
+              "} bar_t;\n"
+              "void f(bar_t *ptr) {\n"
+              "    if(ptr->y->x)\n"
+              "        if(ptr->y != nullptr) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:9:19] -> [test.cpp:8:11]: (warning) Either the condition 'ptr->y!=nullptr' is redundant or there is possible null pointer dereference: ptr->y. [nullPointerRedundantCheck]\n",
+            errout_str());
+
+        check("bool argsMatch(const Token *first, const Token *second) {\n" // #6145
+              "    if (first->str() == \")\")\n"
+              "        return true;\n"
+              "    else if (first->next()->str() == \"=\")\n"
+              "        first = first->nextArgument();\n"
+              "    else if (second->next()->str() == \"=\") {\n"
+              "        second = second->nextArgument();\n"
+              "        if (second)\n"
+              "            second = second->tokAt(-2);\n"
+              "        if (!first || !second) {\n"
+              "            return !first && !second;\n"
+              "        }\n"
+              "    }\n"
+              "    return false;\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:10:13] -> [test.cpp:2:9]: (warning) Either the condition '!first' is redundant or there is possible null pointer dereference: first. [nullPointerRedundantCheck]\n"
+            "[test.cpp:10:13] -> [test.cpp:4:14]: (warning) Either the condition '!first' is redundant or there is possible null pointer dereference: first. [nullPointerRedundantCheck]\n",
+            errout_str());
+    }
+
+    void nullpointer90() // #6098
+    {
+        check("std::string definitionToName(Definition *ctx)\n"
+              "{\n"
+              "  if (ctx->definitionType()==Definition::TypeMember)\n"                           // possible null pointer dereference
+              "  {\n"
+              "     return \"y\";\n"
+              "  }\n"
+              "  else if (ctx)\n"                           // ctx is checked against null
+              "  {\n"
+              "    if(ctx->definitionType()!=Definition::TypeMember)\n"
+              "    {\n"
+              "       return \"x\";\n"
+              "    }\n"
+              "  }\n"
+              "  return \"unknown\";\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:7:12] -> [test.cpp:3:7]: (warning) Either the condition 'ctx' is redundant or there is possible null pointer dereference: ctx. [nullPointerRedundantCheck]\n",
+            errout_str());
+    }
+
+    void nullpointer91() // #10678
+    {
+        check("void f(const char* PBeg, const char* PEnd) {\n"
+              "  while (PEnd != nullptr) {\n"
+              "    const int N = h(PEnd);\n"
+              "    PEnd = g();\n"
+              "    const int Length = PEnd == nullptr ? 0 : PEnd - PBeg;\n"
+              "  };\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer92()
+    {
+        check("bool g(bool);\n"
+              "int f(int* i) {\n"
+              "    if (!g(!!i)) return 0;\n"
+              "    return *i;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool g(bool);\n"
+              "int f(int* i) {\n"
+              "    if (!g(!i)) return 0;\n"
+              "    return *i;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer93() // #3929
+    {
+        check("int* GetThing( ) { return 0; }\n"
+              "int main() {\n"
+              "        int* myNull = GetThing();\n"
+              "        *myNull=42;\n"
+              "        return 0;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:10]: (error) Null pointer dereference: myNull [nullPointer]\n", errout_str());
+
+        check("struct foo {\n"
+              "    int* GetThing(void) { return 0; }\n"
+              "};\n"
+              "int main(void) {\n"
+              "        foo myFoo;\n"
+              "        int* myNull = myFoo.GetThing();\n"
+              "        *myNull=42;\n"
+              "        return 0;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:7:10]: (error) Null pointer dereference: myNull [nullPointer]\n", errout_str());
+
+        check("struct T { bool g() const; };\n"
+              "void f(T* p) {\n"
+              "    if (!p)\n"
+              "        return;\n"
+              "    while (p->g())\n"
+              "        p = nullptr;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:12]: (warning) Possible null pointer dereference: p [nullPointer]\n", errout_str());
+    }
+
+    void nullpointer94() // #11040
+    {
+        check("struct entry { struct entry* next; size_t len; };\n"
+              "void f(struct entry **kep, size_t slen) {\n"
+              "    while (*kep)\n"
+              "        kep = &(*kep)->next;\n"
+              "    *kep = (struct entry*)malloc(sizeof(**kep));\n"
+              "    (*kep)->next = 0;\n"
+              "    (*kep)->len = slen;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:6]: (warning) If memory allocation fails, then there is a possible null pointer dereference: *kep [nullPointerOutOfMemory]\n", errout_str());
+    }
+
+    void nullpointer95() // #11142
+    {
+        check("void f(std::vector<int*>& v) {\n"
+              "    for (auto& p : v)\n"
+              "        if (*p < 2)\n"
+              "            p = nullptr;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer96()
+    {
+        check("struct S {\n"
+              "  int x;\n"
+              "};\n"
+              "S *create_s();\n"
+              "void test() {\n"
+              "  S *s = create_s();\n"
+              "  for (int i = 0; i < s->x; i++) {\n"
+              "    if (s->x == 17) {\n"
+              "      s = nullptr;\n"
+              "      break;\n"
+              "    }\n"
+              "  }\n"
+              "  if (s) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer97() // #11229
+    {
+        check("struct B { virtual int f() = 0; };\n"
+              "struct D : public B { int f() override; };\n"
+              "int g(B* p) {\n"
+              "    if (p) {\n"
+              "        auto d = dynamic_cast<D*>(p);\n"
+              "        return d ? d->f() : 0;\n"
+              "    }\n"
+              "    return 0;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer98() // #11458
+    {
+        check("struct S { double* d() const; };\n"
+              "struct T {\n"
+              "    virtual void g(double* b, double* d) const = 0;\n"
+              "    void g(S* b) const { g(b->d(), nullptr); }\n"
+              "    void g(S* b, S* d) const { g(b->d(), d->d()); }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer99() // #10602
+    {
+        check("class A\n"
+              "{\n"
+              "    int *foo(const bool b)\n"
+              "    {\n"
+              "        if(b)\n"
+              "            return nullptr;\n"
+              "        else\n"
+              "            return new int [10];\n"
+              "    }\n"
+              "public:\n"
+              "    void bar(void)\n"
+              "    {\n"
+              "        int * buf = foo(true);\n"
+              "        buf[2] = 0;" // <<
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:14:9]: (error) Null pointer dereference: buf [nullPointer]\n", errout_str());
+    }
+
+    void nullpointer100() // #11636
+    {
+        check("const char* type_of(double) { return \"unknown\"; }\n"
+              "void f() {\n"
+              "    double tmp = 0.0;\n"
+              "    const char* t = type_of(tmp);\n"
+              "    std::cout << t;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer101() // #11382
+    {
+        check("struct Base { virtual ~Base(); };\n"
+              "struct Derived : Base {};\n"
+              "bool is_valid(const Derived&);\n"
+              "void f(const Base* base) {\n"
+              "    const Derived* derived = dynamic_cast<const Derived*>(base);\n"
+              "    if (derived && !is_valid(*derived) || base == nullptr) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer102()
+    {
+        check("struct S { std::string str; };\n" // #11534
+              "struct T { S s; };\n"
+              "struct U { T t[1]; };\n"
+              "void f(const T& t, const U& u, std::string& str) {\n"
+              "    if (str.empty())\n"
+              "        str = t.s.str;\n"
+              "    else\n"
+              "        str = u.t[0].s.str;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer103()
+    {
+        check("struct S {\n" // #10572
+              "    int f();\n"
+              "    int* m_P{};\n"
+              "};\n"
+              "int S::f() {\n"
+              "    if (!m_P) {\n"
+              "        try {\n"
+              "            m_P = new int(1);\n"
+              "        }\n"
+              "        catch (...) {\n"
+              "            return 0;\n"
+              "        }\n"
+              "    }\n"
+              "    return *m_P;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int* p, const int* q) {\n" // #11873
+              "    if (*q == -1)\n"
+              "        *p = 0;\n"
+              "}\n"
+              "void g() {\n"
+              "    int x = -2;\n"
+              "    f(nullptr, &x);\n"
+              "}\n");
+        TODO_ASSERT_EQUALS("", "[test.cpp:3:10]: (warning) Possible null pointer dereference: p [nullPointer]\n", errout_str());
+    }
+
+    void nullpointer104() // #13881
+    {
+        check("using std::max;\n"
+              "void f(int i) {\n"
+              "    const size_t maxlen = i == 1 ? 8 : (std::numeric_limits<std::size_t>::max());\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer105() // #13861
+    {
+        check("struct AB { int a; int b; };\n"
+              "namespace ns { typedef AB S[10]; }\n"
+              "void foo(void) {\n"
+              "    ns::S x = {0};\n"
+              "    x[1].a = 2;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer_addressOf() { // address of
+        check("void f() {\n"
+              "  struct X *x = 0;\n"
+              "  if (addr == &x->y) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "  struct X *x = 0;\n"
+              "  if (addr == &x->y.z[0]) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkP("typedef int Count;\n" // #10018
+               "#define offsetof(TYPE, MEMBER) ((Count) & ((TYPE*)0)->MEMBER)\n"
+               "struct S {\n"
+               "    int a[20];\n"
+               "};\n"
+               "int g(int i) {\n"
+               "    return offsetof(S, a[i]);\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointerSwitch() { // #2626
+        // extracttests.start: char *do_something();
+        check("char *f(int x) {\n"
+              "    char *p = do_something();\n"
+              "    switch (x) {\n"
+              "      case 1:\n"
+              "        p = 0;\n"
+              "      case 2:\n"
+              "        *p = 0;\n"
+              "        break;\n"
+              "    }\n"
+              "    return p;\n"
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:7:10]: (warning) Possible null pointer dereference: p [nullPointer]\n", errout_str());
+    }
+
+    void nullpointer_cast() {
+        check("char *nasm_skip_spaces(const char *p) {\n" // #4692
+              "    if (p)\n"
+              "        while (*p && nasm_isspace(*p))\n"
+              "            p++;\n"
+              "    return p;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(char* origin) {\n" // #11449
+              "    char* cp = (strchr)(origin, '\\0');\n"
+              "    if (cp[-1] != '/')\n"
+              "        *cp++ = '/';\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer_castToVoid() {  // #3771
+        check("void f () {\n"
+              "    int *buf; buf = NULL;\n"
+              "    buf;\n"
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer_subfunction() {
+        check("int f(int* x, int* y) {\n"
+              "    if (!x)\n"
+              "        return;\n"
+              "    return *x + *y;\n"
+              "}\n"
+              "void g() {\n"
+              "    f(nullptr, nullptr);\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // Check if pointer is null and the dereference it
+    void pointerCheckAndDeRef() {
+        check("void foo(char *p) {\n"
+              "    if (!p) {\n"
+              "    }\n"
+              "    *p = 0;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:4:6]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
+
+        check("void foo(char *p) {\n"
+              "    if (p && *p == 0) {\n"
+              "    }\n"
+              "    printf(\"%c\", *p);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:4:19]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
+
+        check("void foo(char *p) {\n"
+              "    if (p && *p == 0) {\n"
+              "    } else { *p = 0; }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:15]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
+
+        check("void foo(char *p) {\n"
+              "    if (p) {\n"
+              "    }\n"
+              "    strcpy(p, \"abc\");\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:4:12]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
+
+        check("void foo(char *p) {\n"
+              "    if (p) {\n"
+              "    }\n"
+              "    bar();\n"
+              "    strcpy(p, \"abc\");\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:5:12]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
+
+        check("void foo(abc *p) {\n"
+              "    if (!p) {\n"
+              "    }\n"
+              "    else { if (!p->x) {\n"
+              "    } }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        {
+            static const char code[] =
+                "void foo(char *p) {\n"
+                "    if (!p) {\n"
+                "        abort();\n"
+                "    }\n"
+                "    *p = 0;\n"
+                "}";
+            check(code);
+            ASSERT_EQUALS("", errout_str());
+
+            check(code, dinit(CheckOptions, $.inconclusive = true));
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        check("void foo(char *p) {\n"
+              "    if (!p) {\n"
+              "        (*bail)();\n"
+              "    }\n"
+              "    *p = 0;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo(char *p) {\n"
+              "    if (!p) {\n"
+              "        throw x;\n"
+              "    }\n"
+              "    *p = 0;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo(char *p) {\n"
+              "    if (!p) {\n"
+              "        ab.abort();\n"
+              "    }\n"
+              "    *p = 0;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo(char *p) {\n"
+              "    if (!p) {\n"
+              "        switch (x) { }\n"
+              "    }\n"
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo(char *p) {\n"
+              "    if (!p) {\n"
+              "    }\n"
+              "    return *x;\n"
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("int foo(int *p) {\n"
+              "    if (!p) {\n"
+              "        x = *p;\n"
+              "        return 5+*p;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:14]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n"
+                      "[test.cpp:2:9] -> [test.cpp:4:19]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
+
+        // operator!
+        check("void f() {\n"
+              "    A a;\n"
+              "    if (!a) {\n"
+              "        a.x();\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // This is why this check can't be used on the simplified token list
+        check("void f(Foo *foo) {\n"
+              "    if (!dynamic_cast<bar *>(foo)) {\n"
+              "        *foo = 0;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // ticket: #2300 - calling unknown function that may initialize the pointer
+        check("Fred *fred;\n"
+              "void a() {\n"
+              "    if (!fred) {\n"
+              "        initfred();\n"
+              "        fred->x = 0;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // ticket #1219
+        check("void foo(char *p) {\n"
+              "    if (p) {\n"
+              "        return;\n"
+              "    }\n"
+              "    *p = 0;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:5:6]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
+
+        // #2467 - unknown macro may terminate the application
+        check("void f(Fred *fred) {\n"
+              "    if (fred == NULL) {\n"
+              "        MACRO;\n"
+              "    }\n"
               "    fred->a();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #2493 - switch
         check("void f(Fred *fred) {\n"
@@ -1751,7 +3201,7 @@ class TestNullPointer : public TestFixture {
               "            break;\n"
               "    };\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #4118 - second if
         check("void f(char *p) {\n"
@@ -1759,7 +3209,7 @@ class TestNullPointer : public TestFixture {
               "    if (!p) x = 0;\n"
               "    if (x) *p = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #2674 - different functions
         check("class Fred {\n"
@@ -1775,16 +3225,16 @@ class TestNullPointer : public TestFixture {
               "\n"
               "void Fred::b() {\n"
               "    wilma->Reload();\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void test(int *i) {\n"
               "  if(i == NULL) { }\n"
               "  else {\n"
               "    int b = *i;\n"
               "  }\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         // #2696 - false positives nr 1
         check("void f()\n"
@@ -1796,8 +3246,8 @@ class TestNullPointer : public TestFixture {
               "\n"
               "   if (pFoo)\n"
               "      bar();\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         // #2696 - false positives nr 2
         check("void f()\n"
@@ -1809,8 +3259,8 @@ class TestNullPointer : public TestFixture {
               "      pFoo = pFoo->next;\n"
               "\n"
               "   len = sizeof(pFoo->data);\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         // #2696 - false positives nr 3
         check("void f()\n"
@@ -1822,14 +3272,14 @@ class TestNullPointer : public TestFixture {
               "      pFoo = pFoo->next;\n"
               "\n"
               "   len = decltype(*pFoo);\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("int foo(struct Fred *fred) {\n"
               "    if (fred) { }\n"
               "    return fred->a;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Either the condition 'fred' is redundant or there is possible null pointer dereference: fred.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:12]: (warning) Either the condition 'fred' is redundant or there is possible null pointer dereference: fred. [nullPointerRedundantCheck]\n", errout_str());
 
         // #2789 - assign and check pointer
         check("void f() {\n"
@@ -1837,7 +3287,7 @@ class TestNullPointer : public TestFixture {
               "    if (!p) { }\n"
               "    *p = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:4:6]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         // check, assign and use
         check("void f() {\n"
@@ -1846,7 +3296,7 @@ class TestNullPointer : public TestFixture {
               "        *p = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // check, assign and use
         check("void f() {\n"
@@ -1855,7 +3305,7 @@ class TestNullPointer : public TestFixture {
               "        *p = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // check, and use
         check("void f() {\n"
@@ -1864,7 +3314,7 @@ class TestNullPointer : public TestFixture {
               "        return;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:3]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:3:21]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         // check, and use
         check("void f() {\n"
@@ -1873,7 +3323,7 @@ class TestNullPointer : public TestFixture {
               "        return;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:3]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:3:19]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         // check, and use
         check("void f() {\n"
@@ -1882,7 +3332,7 @@ class TestNullPointer : public TestFixture {
               "        return;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // check, and use
         check("void f() {\n"
@@ -1891,7 +3341,7 @@ class TestNullPointer : public TestFixture {
               "        return;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:3]: (warning) Either the condition 'p==NULL' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:3:24]: (warning) Either the condition 'p==NULL' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         // check, and use
         check("void f(struct X *p, int x) {\n"
@@ -1899,7 +3349,7 @@ class TestNullPointer : public TestFixture {
               "        return;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         {
             const char code[] = "void f(Fred *fred) {\n"
@@ -1907,77 +3357,96 @@ class TestNullPointer : public TestFixture {
                                 "    fred->x();\n"
                                 "}";
 
-            check(code, false);    // non-inconclusive
-            ASSERT_EQUALS("", errout.str());
-
-            check(code, true);     // inconclusive
-            ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning, inconclusive) Either the condition 'fred==NULL' is redundant or there is possible null pointer dereference: fred.\n", errout.str());
+            check(code);     // inconclusive
+            ASSERT_EQUALS("[test.cpp:2:14] -> [test.cpp:3:5]: (warning) Either the condition 'fred==NULL' is redundant or there is possible null pointer dereference: fred. [nullPointerRedundantCheck]\n", errout_str());
         }
 
         check("void f(char *s) {\n"   // #3358
               "    if (s==0);\n"
               "    strcpy(a, s?b:c);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // sizeof
         check("void f(struct fred_t *fred) {\n"
               "    if (!fred)\n"
               "        int sz = sizeof(fred->x);\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         // check in macro
         check("void f(int *x) {\n"
               "    $if (!x) {}\n"
               "    *x = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // return ?:
         check("int f(ABC *p) {\n" // FP : return ?:
               "    if (!p) {}\n"
               "    return p ? p->x : 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("int f(ABC *p) {\n" // no fn
               "    if (!p) {}\n"
               "    return q ? p->x : 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:16]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         check("int f(ABC *p) {\n" // FP : return &&
               "    if (!p) {}\n"
               "    return p && p->x;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, int *p) {\n"
               "    if (x || !p) {}\n"
               "    *p = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14] -> [test.cpp:3:6]: (warning) Either the condition '!p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         // sizeof
         check("void f() {\n"
               "  int *pointer = NULL;\n"
               "  pointer = func(sizeof pointer[0]);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct T {\n" // #14164
+              "    T* next;\n"
+              "    char op;\n"
+              "};\n"
+              "void h(int, char);\n"
+              "void g(const T* tok, bool b) {\n"
+              "    if (tok->op == '<') {\n"
+              "        while ((tok = tok->next) && tok->op != '>') {}\n"
+              "    }\n"
+              "    h(b ? 1 : 0, tok->op);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:8:21] -> [test.cpp:10:18]: (warning) Either the condition 'tok=tok->next' is redundant or there is possible null pointer dereference: tok. [nullPointerRedundantCheck]\n",
+                      errout_str());
     }
 
     // Test CheckNullPointer::nullConstantDereference
     void nullConstantDereference() {
-        check("void f() {\n"
+        check("int f() {\n"
               "    int* p = 0;\n"
               "    return p[4];\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Null pointer dereference: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
 
         check("void f() {\n"
               "    typeof(*NULL) y;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("int * f() {\n"
+              "    return NULL;\n"
+              "}\n"
+              "int main() {\n"
+              "  return *f();\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:12]: (error) Null pointer dereference: f() [nullPointer]\n", errout_str());
     }
 
     void gcc_statement_expression() {
@@ -1985,15 +3454,15 @@ class TestNullPointer : public TestFixture {
         check("void f(struct ABC *abc) {\n"
               "    ({ if (abc) dbg(); })\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void snprintf_with_zero_size() {
         // Ticket #2840
         check("void f() {\n"
               "    int bytes = snprintf(0, 0, \"%u\", 1);\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void snprintf_with_non_zero_size() {
@@ -2001,145 +3470,165 @@ class TestNullPointer : public TestFixture {
         check("void f() {\n"
               "    int bytes = snprintf(0, 10, \"%u\", 1);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Null pointer dereference\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:26]: (error) Null pointer dereference [nullPointer]\n", errout_str());
     }
 
     void printf_with_invalid_va_argument() {
         check("void f() {\n"
               "    printf(\"%s\", 0);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Null pointer dereference\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:18]: (error) Null pointer dereference [nullPointer]\n", errout_str());
 
         check("void f(char* s) {\n"
               "    printf(\"%s\", s);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char* s = 0;\n"
               "    printf(\"%s\", s);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Null pointer dereference: s\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:18]: (error) Null pointer dereference: s [nullPointer]\n"
+            "[test.cpp:3:18]: (error) Null pointer dereference [nullPointer]\n",
+            errout_str());
 
         check("void f() {\n"
               "    char *s = 0;\n"
               "    printf(\"%s\", s == 0 ? a : s);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    printf(\"%u%s\", 0, 0);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Null pointer dereference\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:23]: (error) Null pointer dereference [nullPointer]\n", errout_str());
 
         check("void f(char* s) {\n"
               "    printf(\"%u%s\", 0, s);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char* s = 0;\n"
               "    printf(\"%u%s\", 123, s);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Null pointer dereference: s\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:25]: (error) Null pointer dereference: s [nullPointer]\n"
+            "[test.cpp:3:25]: (error) Null pointer dereference [nullPointer]\n",
+            errout_str());
 
 
         check("void f() {\n"
               "    printf(\"%%%s%%\", 0);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Null pointer dereference\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:22]: (error) Null pointer dereference [nullPointer]\n", errout_str());
 
         check("void f(char* s) {\n"
               "    printf(\"text: %s, %s\", s, 0);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Null pointer dereference\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:31]: (error) Null pointer dereference [nullPointer]\n", errout_str());
 
 
         check("void f() {\n"
               "    char* s = \"blabla\";\n"
               "    printf(\"%s\", s);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
 
         check("void f(char* s) {\n"
               "    printf(\"text: %m%s, %s\", s, 0);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Null pointer dereference\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:33]: (error) Null pointer dereference [nullPointer]\n", errout_str());
 
         check("void f(char* s) {\n"
               "    printf(\"text: %*s, %s\", s, 0);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Null pointer dereference\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:32]: (error) Null pointer dereference [nullPointer]\n", errout_str());
 
         // Ticket #3364
         check("void f() {\n"
               "    printf(\"%-*.*s\", s, 0);\n"
               "    sprintf(\"%*\", s);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void scanf_with_invalid_va_argument() {
         check("void f(char* s) {\n"
               "    sscanf(s, \"%s\", 0);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Null pointer dereference\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:21]: (error) Null pointer dereference [nullPointer]\n"
+            "[test.cpp:2:21]: (error) Null pointer dereference [nullPointer]\n",   // duplicate
+            errout_str());
 
         check("void f() {\n"
               "    scanf(\"%d\", 0);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Null pointer dereference\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:17]: (error) Null pointer dereference [nullPointer]\n"
+            "[test.cpp:2:17]: (error) Null pointer dereference [nullPointer]\n",   // duplicate
+            errout_str());
 
         check("void f(char* foo) {\n"
               "    char location[200];\n"
               "    int width, height;\n"
               "    sscanf(imgInfo, \"%s %d %d\", location, &width, &height);\n"
               "}");
-        ASSERT_EQUALS("", errout.str()); // ticket #3207
+        ASSERT_EQUALS("", errout_str()); // ticket #3207
 
         check("void f(char *dummy) {\n"
               "    int iVal;\n"
               "    sscanf(dummy, \"%d%c\", &iVal);\n"
               "}");
-        ASSERT_EQUALS("", errout.str()); // ticket #3211
+        ASSERT_EQUALS("", errout_str()); // ticket #3211
 
         check("void f(char *dummy) {\n"
               "    int* iVal = 0;\n"
               "    sscanf(dummy, \"%d\", iVal);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Null pointer dereference: iVal\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:25]: (error) Null pointer dereference: iVal [nullPointer]\n"
+            "[test.cpp:3:25]: (error) Null pointer dereference [nullPointer]\n"
+            "[test.cpp:3:25]: (error) Null pointer dereference [nullPointer]\n",   // duplicate
+            errout_str());
 
         check("void f(char *dummy) {\n"
               "    int* iVal;\n"
               "    sscanf(dummy, \"%d\", foo(iVal));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(char *dummy) {\n"
               "    int* iVal = 0;\n"
               "    sscanf(dummy, \"%d%d\", foo(iVal), iVal);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(char* dummy) {\n"
               "    sscanf(dummy, \"%*d%u\", 0);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Null pointer dereference\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:28]: (error) Null pointer dereference [nullPointer]\n"
+            "[test.cpp:2:28]: (error) Null pointer dereference [nullPointer]\n",   // duplicate
+            errout_str());
     }
 
     void nullpointer_in_return() {
+        // extracttests.start: int maybe(); int *g();
         check("int foo() {\n"
               "    int* iVal = 0;\n"
-              "    if(g()) iVal = g();\n"
+              "    if(maybe()) iVal = g();\n"
               "    return iVal[0];\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Possible null pointer dereference: iVal\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:12]: (warning) Possible null pointer dereference: iVal [nullPointer]\n", errout_str());
 
         check("int foo(int* iVal) {\n"
               "    return iVal[0];\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointer_in_typeid() {
@@ -2148,22 +3637,63 @@ class TestNullPointer : public TestFixture {
               "bool foo() {\n"
               "     PolymorphicA* a = 0;\n"
               "     return typeid(*a) == typeid(*a);\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("struct NonPolymorphicA { ~A() {} };\n"
               "bool foo() {\n"
               "     NonPolymorphicA* a = 0;\n"
               "     return typeid(*a) == typeid(*a);\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("bool foo() {\n"
               "     char* c = 0;\n"
               "     return typeid(*c) == typeid(*c);\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointer_in_alignof() // #11401
+    {
+        check("size_t foo() {\n"
+              "    char* c = 0;\n"
+              "    return alignof(*c);\n"
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("size_t foo() {\n"
+              "    return alignof(*0);\n"
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo(int *p) {\n"
+              "    f(alignof(*p));\n"
+              "    if (p) {}\n"
+              "    return;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("size_t foo() {\n"
+              "    char* c = 0;\n"
+              "    return _Alignof(*c);\n"
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("size_t foo() {\n"
+              "    return _alignof(*0);\n"
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("size_t foo() {\n"
+              "    return __alignof(*0);\n"
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
+        check("size_t foo() {\n"
+              "    return __alignof__(*0);\n"
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointer_in_for_loop() {
@@ -2174,7 +3704,69 @@ class TestNullPointer : public TestFixture {
               " for (int i = 0; i < cnt; ++i)\n"
               "  *ptr++ = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // #11635
+        check("void f(char *cons, int rlen, int pos) {\n"
+              "    int i;\n"
+              "    char* cp1;\n"
+              "    for (cp1 = &cons[pos], i = 1; i < rlen; cp1--)\n"
+              "        if (*cp1 == '*')\n"
+              "            continue;\n"
+              "        else\n"
+              "            i++;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void nullpointerDeadCode() {
+        // Ticket #11311
+        check ("void f() {\n"
+               "    if (0)\n"
+               "        *(int *)0 = 1;\n"
+               "    else\n"
+               "         ;\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check ("void f() {\n"
+               "    if (0)\n"
+               "        *(int *)0 = 1;\n"
+               "    else {\n"
+               "        if (0)\n"
+               "            *(int *)0 = 2;\n"
+               "        else\n"
+               "            ;\n"
+               "    }\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check ("void f() {\n"
+               "    while(0)\n"
+               "        *(int*)0 = 1;\n"
+               "    do {\n"
+               "    } while(0);\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check ("int f() {\n"
+               "    return 0 ? *(int*)0 = 1 : 1;\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check ("int f() {\n"
+               "    return 1 ? 1 : *(int*)0 = 1;\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check ("struct S {\n" // #13220
+               "    explicit S(int* p) : i(*p) {\n"
+               "        if (p) {}\n"
+               "    }\n"
+               "    int i;\n"
+               "};\n");
+        ASSERT_EQUALS("[test.cpp:3:13] -> [test.cpp:2:29]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
+                      errout_str());
     }
 
     void nullpointerDelete() {
@@ -2183,8 +3775,8 @@ class TestNullPointer : public TestFixture {
               "  if (k)\n"
               "     k->doStuff();\n"
               "  delete k;\n"
-              "}\n", true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  K *k = getK();\n"
@@ -2192,8 +3784,8 @@ class TestNullPointer : public TestFixture {
               "     k[0] = ptr;\n"
               "  delete [] k;\n"
               "  k = new K[10];\n"
-              "}\n", true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointerSubFunction() {
@@ -2201,8 +3793,23 @@ class TestNullPointer : public TestFixture {
               "void f(int* x) {\n"
               "    if (x)\n"
               "        g(x);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct T {\n" // #14308
+              "    bool b{};\n"
+              "    T* next{};\n"
+              "};\n"
+              "bool g(const T*& r) {\n"
+              "    const T* t = r;\n"
+              "    r = t->next;\n"
+              "    return t->b;\n"
+              "}\n"
+              "void f(const T* tok) {\n"
+              "    if (g(tok)) {}\n"
+              "    if (tok) {}\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointerExit() {
@@ -2211,8 +3818,8 @@ class TestNullPointer : public TestFixture {
               "  if (!k)\n"
               "     exit(1);\n"
               "  k->f();\n"
-              "}\n", true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nullpointerStdString() {
@@ -2228,40 +3835,40 @@ class TestNullPointer : public TestFixture {
               "    std::string s4 = p;\n"
               "    std::string s5(p);\n"
               "    foo(std::string(p));\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:9]: (error) Null pointer dereference: p\n"
-                      "[test.cpp:10]: (error) Null pointer dereference: p\n"
-                      "[test.cpp:11]: (error) Null pointer dereference: p\n"
-                      "[test.cpp:12]: (warning, inconclusive) Possible null pointer dereference: p\n"
-                      "[test.cpp:3]: (error) Null pointer dereference\n"
-                      "[test.cpp:5]: (error) Null pointer dereference\n"
-                      "[test.cpp:7]: (error) Null pointer dereference\n"
-                      "[test.cpp:8]: (error) Null pointer dereference\n"
-                      , errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:9:10]: (error) Null pointer dereference: p [nullPointer]\n"
+                      "[test.cpp:10:22]: (error) Null pointer dereference: p [nullPointer]\n"
+                      "[test.cpp:11:20]: (error) Null pointer dereference: p [nullPointer]\n"
+                      "[test.cpp:12:21]: (error) Null pointer dereference: p [nullPointer]\n"
+                      "[test.cpp:3:10]: (error) Null pointer dereference [nullPointer]\n"
+                      "[test.cpp:5:22]: (error) Null pointer dereference [nullPointer]\n"
+                      "[test.cpp:7:17]: (error) Null pointer dereference [nullPointer]\n"
+                      "[test.cpp:8:9]: (error) Null pointer dereference [nullPointer]\n"
+                      , errout_str());
 
         check("void f(std::string s1) {\n"
               "    s1 = nullptr;\n"
               "    std::string s2 = nullptr;\n"
               "    std::string s3(nullptr);\n"
               "    foo(std::string(nullptr));\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:2]: (error) Null pointer dereference\n"
-                      "[test.cpp:3]: (error) Null pointer dereference\n"
-                      "[test.cpp:4]: (error) Null pointer dereference\n"
-                      "[test.cpp:5]: (error) Null pointer dereference\n"
-                      , errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:2:10]: (error) Null pointer dereference [nullPointer]\n"
+                      "[test.cpp:3:22]: (error) Null pointer dereference [nullPointer]\n"
+                      "[test.cpp:4:17]: (error) Null pointer dereference [nullPointer]\n"
+                      "[test.cpp:5:9]: (error) Null pointer dereference [nullPointer]\n"
+                      , errout_str());
 
         check("void f(std::string s1) {\n"
               "    s1 = NULL;\n"
               "    std::string s2 = NULL;\n"
               "    std::string s3(NULL);\n"
               "    foo(std::string(NULL));\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:2]: (error) Null pointer dereference\n"
-                      "[test.cpp:3]: (error) Null pointer dereference\n"
-                      "[test.cpp:4]: (error) Null pointer dereference\n"
-                      "[test.cpp:5]: (error) Null pointer dereference\n"
-                      , errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:2:10]: (error) Null pointer dereference [nullPointer]\n"
+                      "[test.cpp:3:22]: (error) Null pointer dereference [nullPointer]\n"
+                      "[test.cpp:4:17]: (error) Null pointer dereference [nullPointer]\n"
+                      "[test.cpp:5:9]: (error) Null pointer dereference [nullPointer]\n"
+                      , errout_str());
 
         check("void f(std::string s1, const std::string& s2, const std::string* s3) {\n"
               "    void* p = 0;\n"
@@ -2272,11 +3879,11 @@ class TestNullPointer : public TestFixture {
               "    foo(p == s1);\n"
               "    foo(p == s2);\n"
               "    foo(p == s3);\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:4]: (error) Null pointer dereference: p\n"
-                      "[test.cpp:5]: (error) Null pointer dereference: p\n"
-                      "[test.cpp:7]: (error) Null pointer dereference: p\n"
-                      "[test.cpp:8]: (error) Null pointer dereference: p\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:15]: (error) Null pointer dereference: p [nullPointer]\n"
+                      "[test.cpp:5:15]: (error) Null pointer dereference: p [nullPointer]\n"
+                      "[test.cpp:7:9]: (error) Null pointer dereference: p [nullPointer]\n"
+                      "[test.cpp:8:9]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
 
         check("void f(std::string s1, const std::string& s2, const std::string* s3) {\n"
               "    void* p = 0;\n"
@@ -2287,8 +3894,8 @@ class TestNullPointer : public TestFixture {
               "    foo(s1.size() == 0);\n"
               "    foo(s2.size() == 0);\n"
               "    foo(s3->size() == 0);\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(std::string s1, const std::string& s2) {\n"
               "    if (x) { return; }\n"
@@ -2296,8 +3903,8 @@ class TestNullPointer : public TestFixture {
               "    foo(0 == s2[0]);\n"
               "    foo(s1[0] == 0);\n"
               "    foo(s2[0] == 0);\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(std::string s1, const std::string& s2) {\n"
               "    if (x) { return; }\n"
@@ -2305,8 +3912,8 @@ class TestNullPointer : public TestFixture {
               "    foo(s2 == '\\0');\n"
               "    foo('\\0' == s1);\n"
               "    foo('\\0' == s2);\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("class Bar {\n"
               "    std::string s;\n"
@@ -2317,19 +3924,19 @@ class TestNullPointer : public TestFixture {
               "    Foo();\n"
               "};\n"
               "Foo::Foo() : s(0) {}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Null pointer dereference\n"
-                      "[test.cpp:9]: (error) Null pointer dereference\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:13]: (error) Null pointer dereference [nullPointer]\n"
+                      "[test.cpp:9:14]: (error) Null pointer dereference [nullPointer]\n", errout_str());
 
         check("void f() {\n"
               "    std::string s = 0 == x ? \"a\" : \"b\";\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  const std::string s = g();\n"
               "  ASSERT_MESSAGE(\"Error on s\", 0 == s.compare(\"Some text\"));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int i, std::string s);\n"
               "void bar() {\n"
@@ -2340,10 +3947,44 @@ class TestNullPointer : public TestFixture {
               "  foo(var, nullptr);\n"
               "  foo(0, var);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Null pointer dereference\n"
-                      "[test.cpp:5]: (error) Null pointer dereference\n"
-                      "[test.cpp:6]: (error) Null pointer dereference\n"
-                      "[test.cpp:7]: (error) Null pointer dereference\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:10]: (error) Null pointer dereference [nullPointer]\n"
+                      "[test.cpp:5:12]: (error) Null pointer dereference [nullPointer]\n"
+                      "[test.cpp:6:12]: (error) Null pointer dereference [nullPointer]\n"
+                      "[test.cpp:7:12]: (error) Null pointer dereference [nullPointer]\n", errout_str());
+
+        check("std::string f() {\n" // #9827
+              "  char* p = NULL;\n"
+              "  int r = g(p);\n"
+              "  if (!r)\n"
+              "    return \"\";\n"
+              "  std::string s(p);\n"
+              "  return s;\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:6:17]: (warning, inconclusive) Possible null pointer dereference: p [nullPointer]\n",
+                      errout_str());
+
+        check("void f() {\n" // #11078
+              "    const char* p = nullptr;\n"
+              "    std::string s1{ p };\n"
+              "    std::string s2{ nullptr };\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:21]: (error) Null pointer dereference: p [nullPointer]\n"
+                      "[test.cpp:4:17]: (error) Null pointer dereference [nullPointer]\n",
+                      errout_str());
+
+        check("const char* g(long) { return nullptr; }\n" // #11561
+              "void f() { std::string s = g(0L); }\n");
+        ASSERT_EQUALS("[test.cpp:2:29]: (error) Null pointer dereference: g(0L) [nullPointer]\n",
+                      errout_str());
+
+        check("const char* g() { return nullptr; }\n" // #14098
+              "std::string f() {\n"
+              "    std::string s{ g() };\n"
+              "    return s + std::string(g());\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:21]: (error) Null pointer dereference: g() [nullPointer]\n"
+                      "[test.cpp:4:29]: (error) Null pointer dereference: g() [nullPointer]\n",
+                      errout_str());
     }
 
     void nullpointerStdStream() {
@@ -2351,7 +3992,7 @@ class TestNullPointer : public TestFixture {
               "    char* p = 0;\n"
               "    is >> p;\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:3]: (error) Possible null pointer dereference: p\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3]: (error) Possible null pointer dereference: p\n", "", errout_str());
 
         check("void f(const std::ostringstream& oss, char* q) {\n"
               "    char const* p = 0;\n" // Simplification makes detection of bug difficult
@@ -2359,10 +4000,10 @@ class TestNullPointer : public TestFixture {
               "    oss << foo << p;\n"
               "    if(q == 0)\n"
               "        oss << foo << q;\n"
-              "}", false);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Null pointer dereference: p\n"
-                      "[test.cpp:4]: (error) Null pointer dereference: p\n"
-                      "[test.cpp:5] -> [test.cpp:6]: (warning) Either the condition 'q==0' is redundant or there is possible null pointer dereference: q.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Null pointer dereference: p [nullPointer]\n"
+                      "[test.cpp:4:19]: (error) Null pointer dereference: p [nullPointer]\n"
+                      "[test.cpp:5:10] -> [test.cpp:6:23]: (warning) Either the condition 'q==0' is redundant or there is possible null pointer dereference: q. [nullPointerRedundantCheck]\n", errout_str());
 
         check("void f(const char* p) {\n"
               "    if(p == 0) {\n"
@@ -2371,14 +4012,14 @@ class TestNullPointer : public TestFixture {
               "        std::cin >> p;\n"
               "        std::cout << abc << p;\n"
               "    }\n"
-              "}", false);
-        TODO_ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p.\n"
-                           "[test.cpp:2] -> [test.cpp:4]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p.\n"
-                           "[test.cpp:2] -> [test.cpp:5]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p.\n"
-                           "[test.cpp:2] -> [test.cpp:6]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p.\n",
-                           "[test.cpp:2] -> [test.cpp:3]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p.\n"
-                           "[test.cpp:2] -> [test.cpp:4]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p.\n",
-                           errout.str());
+              "}");
+        TODO_ASSERT_EQUALS("[test.cpp:2:10] -> [test.cpp:3:22]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n"
+                           "[test.cpp:2:10] -> [test.cpp:4:22]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n"
+                           "[test.cpp:2:10] -> [test.cpp:5]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n"
+                           "[test.cpp:2:10] -> [test.cpp:6]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
+                           "[test.cpp:2:10] -> [test.cpp:3:22]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n"
+                           "[test.cpp:2:10] -> [test.cpp:4:22]: (warning) Either the condition 'p==0' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
+                           errout_str());
 
         check("void f() {\n"
               "    void* p1 = 0;\n"
@@ -2386,22 +4027,22 @@ class TestNullPointer : public TestFixture {
               "    char* p2 = 0;\n"
               "    std::cin >> (int)p;\n" // result casted
               "    std::cout << (int)p;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(const std::string& str) {\n"
               "    long long ret = 0;\n"
               "    std::istringstream istr(str);\n"
               "    istr >> std::hex >> ret;\n" // Read integer
               "    return ret;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int* i) {\n"
               "    if(i) return;\n"
               "    std::cout << i;\n" // Its no char* (#4240)
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         // #5811 false positive: (error) Null pointer dereference
         check("using namespace std;\n"
@@ -2409,98 +4050,100 @@ class TestNullPointer : public TestFixture {
               "    stringstream out;\n"
               "    out << ((ip >> 0) & 0xFF);\n"
               "    return out.str();\n"
-              "}n", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
         // avoid regression from first fix attempt for #5811...
         check("void deserialize(const std::string &data) {\n"
               "std::istringstream iss(data);\n"
               "unsigned int len = 0;\n"
               "if (!(iss >> len))\n"
               "    return;\n"
-              "}\n", true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
     }
 
     void nullpointerSmartPointer() {
+        // extracttests.start: void dostuff(int);
+
         check("struct Fred { int x; };\n"
               "void f(std::shared_ptr<Fred> p) {\n"
               "  if (p) {}\n"
               "  dostuff(p->x);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:7] -> [test.cpp:4:11]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         check("struct Fred { int x; };\n"
               "void f(std::shared_ptr<Fred> p) {\n"
               "  p = nullptr;\n"
               "  dostuff(p->x);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Null pointer dereference: p\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:11]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
 
         check("struct Fred { int x; };\n"
               "void f(std::unique_ptr<Fred> p) {\n"
               "  if (p) {}\n"
               "  dostuff(p->x);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:7] -> [test.cpp:4:11]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n", errout_str());
 
         check("struct Fred { int x; };\n"
               "void f(std::unique_ptr<Fred> p) {\n"
               "  p = nullptr;\n"
               "  dostuff(p->x);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Null pointer dereference: p\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:11]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
 
         check("struct Fred { int x; };\n"
               "void f() {\n"
               "  std::shared_ptr<Fred> p;\n"
               "  dostuff(p->x);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Null pointer dereference: p\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:11]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
 
         check("struct Fred { int x; };\n"
               "void f(std::shared_ptr<Fred> p) {\n"
               "  p.reset();\n"
               "  dostuff(p->x);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Null pointer dereference: p\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:11]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
 
         check("struct Fred { int x; };\n"
               "void f(std::shared_ptr<Fred> p) {\n"
               "  Fred * pp = nullptr;\n"
               "  p.reset(pp);\n"
               "  dostuff(p->x);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Null pointer dereference: p\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:11]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
 
         check("struct Fred { int x; };\n"
               "void f(Fred& f) {\n"
               "  std::shared_ptr<Fred> p;\n"
               "  p.reset(&f);\n"
               "  dostuff(p->x);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Fred { int x; };\n"
               "void f(std::shared_ptr<Fred> p) {\n"
-              "  p.release();\n"
+              "  p.reset();\n"
               "  dostuff(p->x);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Null pointer dereference: p\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:11]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
 
         check("struct Fred { int x; };\n"
               "void f() {\n"
               "  std::shared_ptr<Fred> p(nullptr);\n"
               "  dostuff(p->x);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Null pointer dereference: p\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:11]: (error) Null pointer dereference: p [nullPointer]\n", errout_str());
 
         check("struct A {};\n"
               "void f(int n) {\n"
               "    std::unique_ptr<const A*[]> p;\n"
               "    p.reset(new const A*[n]);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // #9216
         check("struct A {\n"
@@ -2510,8 +4153,50 @@ class TestNullPointer : public TestFixture {
               "void g(std::unique_ptr<A> var) {\n"
               "    var->reset();\n"
               "    var->f();\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9439
+        check("char* g();\n"
+              "char* f() {\n"
+              "    std::unique_ptr<char> x(g());\n"
+              "    if( x ) {}\n"
+              "    return x.release();\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        // #9496
+        check("std::shared_ptr<int> f() {\n"
+              "    return std::shared_ptr<int>(nullptr);\n"
+              "}\n"
+              "void g() {\n"
+              "    int a = *f();\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:5:15]: (error) Null pointer dereference: f() [nullPointer]\n", errout_str());
+    }
+
+    void nullpointerOutOfMemory() {
+        check("void f() {\n"
+              "    int *p = malloc(10);\n"
+              "    *p = 0;\n"
+              "    free(p);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:6]: (warning) If memory allocation fails, then there is a possible null pointer dereference: p [nullPointerOutOfMemory]\n", errout_str());
+
+        check("void f() {\n"
+              "    int *p = malloc(10);\n"
+              "    *(p+2) = 0;\n"
+              "    free(p);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:8]: (error) If memory allocation fails: pointer addition with NULL pointer. [nullPointerArithmeticOutOfMemory]\n", errout_str());
+
+        check("void f() {\n" // #13676
+              "    int* q = static_cast<int*>(std::malloc(4));\n"
+              "    *q = 0;\n"
+              "    std::free(q);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:6]: (warning) If memory allocation fails, then there is a possible null pointer dereference: q [nullPointerOutOfMemory]\n", errout_str());
     }
 
     void functioncall() {    // #3443 - function calls
@@ -2523,7 +4208,7 @@ class TestNullPointer : public TestFixture {
                   "    foo(p);\n"
                   "    if (p) { }\n"
                   "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
 
             // function seen (taking pointer parameter)
             check("void foo(int *p) { }\n"
@@ -2533,7 +4218,9 @@ class TestNullPointer : public TestFixture {
                   "    foo(p);\n"
                   "    if (p) { }\n"
                   "}");
-            ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:4]: (warning) Either the condition 'if(p)' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+            ASSERT_EQUALS(
+                "[test.cpp:6:9] -> [test.cpp:4:6]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
+                errout_str());
 
             // function seen (taking reference parameter)
             check("void foo(int *&p) { }\n"
@@ -2542,8 +4229,8 @@ class TestNullPointer : public TestFixture {
                   "    *p = 0;\n"
                   "    foo(p);\n"
                   "    if (p) { }\n"
-                  "}", true);
-            ASSERT_EQUALS("", errout.str());
+                  "}", dinit(CheckOptions, $.inconclusive = true));
+            ASSERT_EQUALS("", errout_str());
 
             // function implementation not seen
             check("void foo(int *p);\n"
@@ -2553,15 +4240,19 @@ class TestNullPointer : public TestFixture {
                   "    foo(p);\n"
                   "    if (p) { }\n"
                   "}");
-            ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:4]: (warning) Either the condition 'if(p)' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+            ASSERT_EQUALS(
+                "[test.cpp:6:9] -> [test.cpp:4:6]: (warning) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
+                errout_str());
 
             // inconclusive
             check("void f(int *p) {\n"
                   "    *p = 0;\n"
                   "    foo(p);\n"
                   "    if (p) { }\n"
-                  "}", true);
-            ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:2]: (warning, inconclusive) Either the condition 'if(p)' is redundant or there is possible null pointer dereference: p.\n", errout.str());
+                  "}", dinit(CheckOptions, $.inconclusive = true));
+            ASSERT_EQUALS(
+                "[test.cpp:4:9] -> [test.cpp:2:6]: (warning, inconclusive) Either the condition 'p' is redundant or there is possible null pointer dereference: p. [nullPointerRedundantCheck]\n",
+                errout_str());
         }
 
         // dereference struct pointer and then check if it's null
@@ -2572,7 +4263,7 @@ class TestNullPointer : public TestFixture {
                   "    foo(abc);\n"
                   "    if (abc) { }\n"
                   "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
 
             // function seen (taking pointer parameter)
             check("void foo(struct ABC *abc) { }\n"
@@ -2582,7 +4273,9 @@ class TestNullPointer : public TestFixture {
                   "    foo(abc);\n"
                   "    if (abc) { }\n"
                   "}");
-            ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:4]: (warning) Either the condition 'if(abc)' is redundant or there is possible null pointer dereference: abc.\n", errout.str());
+            ASSERT_EQUALS(
+                "[test.cpp:6:9] -> [test.cpp:4:5]: (warning) Either the condition 'abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n",
+                errout_str());
 
             // function implementation not seen
             check("void foo(struct ABC *abc);\n"
@@ -2592,49 +4285,75 @@ class TestNullPointer : public TestFixture {
                   "    foo(abc);\n"
                   "    if (abc) { }\n"
                   "}");
-            ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:4]: (warning) Either the condition 'if(abc)' is redundant or there is possible null pointer dereference: abc.\n", errout.str());
+            ASSERT_EQUALS(
+                "[test.cpp:6:9] -> [test.cpp:4:5]: (warning) Either the condition 'abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n",
+                errout_str());
 
             // inconclusive
             check("void f(struct ABC *abc) {\n"
                   "    abc->a = 0;\n"
                   "    foo(abc);\n"
                   "    if (abc) { }\n"
-                  "}", true);
-            ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:2]: (warning, inconclusive) Either the condition 'if(abc)' is redundant or there is possible null pointer dereference: abc.\n", errout.str());
+                  "}", dinit(CheckOptions, $.inconclusive = true));
+            ASSERT_EQUALS(
+                "[test.cpp:4:9] -> [test.cpp:2:5]: (warning, inconclusive) Either the condition 'abc' is redundant or there is possible null pointer dereference: abc. [nullPointerRedundantCheck]\n",
+                errout_str());
         }
     }
 
+    void nullpointerOutOfResources() {
+        check("void f() {\n"
+              "    FILE* fid = fopen(\"x.txt\", \"w\");\n"
+              "    fprintf(fid, \"abcdef\");\n"
+              "    fclose(fid);\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:13]: (warning) If resource allocation fails, then there is a possible null pointer dereference: fid [nullPointerOutOfResources]\n"
+            "[test.cpp:4:12]: (warning) If resource allocation fails, then there is a possible null pointer dereference: fid [nullPointerOutOfResources]\n",
+            errout_str());
+    }
+
     void functioncalllibrary() {
-        Settings settings1;
-        Tokenizer tokenizer(&settings1,this);
-        std::istringstream code("void f() { int a,b,c; x(a,b,c); }");
-        tokenizer.tokenize(code,"test.c");
+        SimpleTokenizer tokenizer(settingsDefault,*this,false);
+        const char code[] = "void f() { int a,b,c; x(a,b,c); }";
+        ASSERT_EQUALS(true, tokenizer.tokenize(code));
         const Token *xtok = Token::findsimplematch(tokenizer.tokens(), "x");
 
         // nothing bad..
         {
+            constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                       "<def>\n"
+                                       "  <function name=\"x\">\n"
+                                       "    <arg nr=\"1\"></arg>\n"
+                                       "    <arg nr=\"2\"></arg>\n"
+                                       "    <arg nr=\"3\"></arg>\n"
+                                       "  </function>\n"
+                                       "</def>";
+
             Library library;
-            Library::ArgumentChecks arg;
-            library.functions["x"].argumentChecks[1] = arg;
-            library.functions["x"].argumentChecks[2] = arg;
-            library.functions["x"].argumentChecks[3] = arg;
+            ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
 
             std::list<const Token *> null;
-            CheckNullPointer::parseFunctionCall(*xtok, null, &library);
+            CheckNullPointer::parseFunctionCall(*xtok, null, library);
             ASSERT_EQUALS(0U, null.size());
         }
 
         // for 1st parameter null pointer is not ok..
         {
+            constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                       "<def>\n"
+                                       "  <function name=\"x\">\n"
+                                       "    <arg nr=\"1\"><not-null/></arg>\n"
+                                       "    <arg nr=\"2\"></arg>\n"
+                                       "    <arg nr=\"3\"></arg>\n"
+                                       "  </function>\n"
+                                       "</def>";
+
             Library library;
-            Library::ArgumentChecks arg;
-            library.functions["x"].argumentChecks[1] = arg;
-            library.functions["x"].argumentChecks[2] = arg;
-            library.functions["x"].argumentChecks[3] = arg;
-            library.functions["x"].argumentChecks[1].notnull = true;
+            ASSERT(LibraryHelper::loadxmldata(library, xmldata, sizeof(xmldata)));
 
             std::list<const Token *> null;
-            CheckNullPointer::parseFunctionCall(*xtok, null, &library);
+            CheckNullPointer::parseFunctionCall(*xtok, null, library);
             ASSERT_EQUALS(1U, null.size());
             ASSERT_EQUALS("a", null.front()->str());
         }
@@ -2645,51 +4364,51 @@ class TestNullPointer : public TestFixture {
         check("void f(int *p = 0) {\n"
               "    *p = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Possible null pointer dereference if the default parameter value is used: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:6]: (warning) Possible null pointer dereference if the default parameter value is used: p [nullPointerDefaultArg]\n", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    if (!p)\n"
               "        return;\n"
               "    *p = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(char a, int *p = 0) {\n"
               "    *p = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Possible null pointer dereference if the default parameter value is used: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:6]: (warning) Possible null pointer dereference if the default parameter value is used: p [nullPointerDefaultArg]\n", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    printf(\"p = %d\", *p);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Possible null pointer dereference if the default parameter value is used: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:23]: (warning) Possible null pointer dereference if the default parameter value is used: p [nullPointerDefaultArg]\n", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    printf(\"p[1] = %d\", p[1]);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Possible null pointer dereference if the default parameter value is used: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:25]: (warning) Possible null pointer dereference if the default parameter value is used: p [nullPointerDefaultArg]\n", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    buf[p] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    if (p != 0 && bar())\n"
               "      *p = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p) {\n"
               "    *p = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    if (p != 0)\n"
               "      *p = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    int y;\n"
@@ -2697,25 +4416,27 @@ class TestNullPointer : public TestFixture {
               "      p = &y;\n"
               "    *p = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int a, int *p = 0) {\n"
               "    if (a != 0)\n"
               "      *p = 0;\n"
-              "}", true);
-        TODO_ASSERT_EQUALS("[test.cpp:3]: (warning) Possible null pointer dereference if the default parameter value is used: p\n", "", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS(
+            "[test.cpp:3:8]: (warning) Possible null pointer dereference if the default parameter value is used: p [nullPointerDefaultArg]\n",
+            errout_str());
 
         check("void f(int *p = 0) {\n"
               "    p = a;\n"
               "    *p = 0;\n" // <- don't simplify and verify
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    p += a;\n"
               "    *p = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f(int *p = 0) {\n"
               "    if (p == 0) {\n"
@@ -2723,42 +4444,45 @@ class TestNullPointer : public TestFixture {
               "    }\n"
               "    return *p;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    std::cout << p ? *p : 0;\n" // Due to operator precedence, this is equivalent to: (std::cout << p) ? *p : 0;
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Possible null pointer dereference if the default parameter value is used: p\n", errout.str()); // Check the first branch of ternary
+        ASSERT_EQUALS("[test.cpp:2:23]: (warning) Possible null pointer dereference if the default parameter value is used: p [nullPointerDefaultArg]\n", errout_str()); // Check the first branch of ternary
 
         check("void f(char *p = 0) {\n"
               "    std::cout << p ? *p : 0;\n" // Due to operator precedence, this is equivalent to: (std::cout << p) ? *p : 0;
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Possible null pointer dereference if the default parameter value is used: p\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:18]: (warning) Possible null pointer dereference if the default parameter value is used: p [nullPointerDefaultArg]\n"
+            "[test.cpp:2:23]: (warning) Possible null pointer dereference if the default parameter value is used: p [nullPointerDefaultArg]\n",   // duplicate
+            errout_str());
 
         check("void f(int *p = 0) {\n"
               "    std::cout << (p ? *p : 0);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    std::cout << p;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    std::cout << (p && p[0] ? *p : 42);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void isEmpty(int *p = 0) {\n"
               "    return p && *p;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void g(int *p = 0) {\n"
               "    return !p || *p;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
 
         // bar may initialize p but be can't know for sure without knowing
@@ -2767,13 +4491,13 @@ class TestNullPointer : public TestFixture {
               "    bar(p);\n"
               "    *p = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    printf(\"%p\", p);\n"
               "    *p = 0;\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) Possible null pointer dereference if the default parameter value is used: p\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:6]: (warning) Possible null pointer dereference if the default parameter value is used: p [nullPointerDefaultArg]\n", errout_str());
 
         // The init() function may or may not initialize p, but since the address
         // of p is passed in, it's a good bet that p may be modified and
@@ -2782,14 +4506,14 @@ class TestNullPointer : public TestFixture {
               "    init(&p);\n"
               "    *p = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void init(int* &g);\n"
               "void f(int *p = 0) {\n"
               "    init(p);\n"
               "    *p = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    if (p == 0) {\n"
@@ -2797,7 +4521,7 @@ class TestNullPointer : public TestFixture {
               "    }\n"
               "    *p = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p = 0) {\n"
               "    if (p == 0) {\n"
@@ -2805,12 +4529,16 @@ class TestNullPointer : public TestFixture {
               "    }\n"
               "    *p = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void foo(int *p = 0) {\n"
+        check("void foo(int x, int *p = 0) {\n"
               "    int var1 = x ? *p : 5;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Possible null pointer dereference if the default parameter value is used: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:21]: (warning) Possible null pointer dereference if the default parameter value is used: p [nullPointerDefaultArg]\n", errout_str());
+
+        check("void f(int* i = nullptr) { *i = 0; }\n" // #11567
+              "void g() { f(); }\n");
+        ASSERT_EQUALS("[test.cpp:1:29]: (warning) Possible null pointer dereference if the default parameter value is used: i [nullPointerDefaultArg]\n", errout_str());
     }
 
     void nullpointer_internal_error() { // ticket #5080
@@ -2820,8 +4548,8 @@ class TestNullPointer : public TestFixture {
               "    unsigned int j;\n"
               "    for (j = 0; j < b[0].a->size; ++j) {\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void ticket6505() {
@@ -2836,109 +4564,123 @@ class TestNullPointer : public TestFixture {
               "}\n"
               "void bar() {\n"
               "  foo(0);\n"
-              "}\n", true, "test.c");
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = true, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void subtract() {
         check("void foo(char *s) {\n"
-              "  p = s - 20;\n"
+              "  char *p = s - 20;\n"
               "}\n"
-              "void bar() { foo(0); }\n");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Overflow in pointer arithmetic, NULL pointer is subtracted.\n",
-                      errout.str());
+              "void bar() { foo(0); }");
+        ASSERT_EQUALS("[test.cpp:2:15]: (error) Overflow in pointer arithmetic, NULL pointer is subtracted. [nullPointerArithmetic]\n",
+                      errout_str());
 
         check("void foo(char *s) {\n"
               "  if (!s) {}\n"
-              "  p = s - 20;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Either the condition '!s' is redundant or there is overflow in pointer subtraction.\n", errout.str());
+              "  char *p = s - 20;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:7] -> [test.cpp:3:15]: (warning) Either the condition '!s' is redundant or there is overflow in pointer subtraction. [nullPointerArithmeticRedundantCheck]\n", errout_str());
 
         check("void foo(char *s) {\n"
               "  s -= 20;\n"
               "}\n"
-              "void bar() { foo(0); }\n");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Overflow in pointer arithmetic, NULL pointer is subtracted.\n",
-                      errout.str());
+              "void bar() { foo(0); }");
+        ASSERT_EQUALS("[test.cpp:2:5]: (error) Overflow in pointer arithmetic, NULL pointer is subtracted. [nullPointerArithmetic]\n",
+                      errout_str());
 
         check("void foo(char *s) {\n"
               "  if (!s) {}\n"
               "  s -= 20;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Either the condition '!s' is redundant or there is overflow in pointer subtraction.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:7] -> [test.cpp:3:5]: (warning) Either the condition '!s' is redundant or there is overflow in pointer subtraction. [nullPointerArithmeticRedundantCheck]\n", errout_str());
 
         check("int* f8() { int *x = NULL; return --x; }");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Overflow in pointer arithmetic, NULL pointer is subtracted.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:35]: (error) Overflow in pointer arithmetic, NULL pointer is subtracted. [nullPointerArithmetic]\n", errout_str());
 
         check("int* f9() { int *x = NULL; return x--; }");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Overflow in pointer arithmetic, NULL pointer is subtracted.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:36]: (error) Overflow in pointer arithmetic, NULL pointer is subtracted. [nullPointerArithmetic]\n", errout_str());
     }
 
     void addNull() {
         check("void foo(char *s) {\n"
               "  char * p = s + 20;\n"
               "}\n"
-              "void bar() { foo(0); }\n");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Pointer addition with NULL pointer.\n", errout.str());
+              "void bar() { foo(0); }");
+        ASSERT_EQUALS("[test.cpp:2:16]: (error) Pointer addition with NULL pointer. [nullPointerArithmetic]\n", errout_str());
 
         check("void foo(char *s) {\n"
               "  if (!s) {}\n"
               "  char * p = s + 20;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Either the condition '!s' is redundant or there is pointer arithmetic with NULL pointer.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:7] -> [test.cpp:3:16]: (warning) Either the condition '!s' is redundant or there is pointer arithmetic with NULL pointer. [nullPointerArithmeticRedundantCheck]\n", errout_str());
 
         check("void foo(char *s) {\n"
               "  char * p = 20 + s;\n"
               "}\n"
-              "void bar() { foo(0); }\n");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Pointer addition with NULL pointer.\n", errout.str());
+              "void bar() { foo(0); }");
+        ASSERT_EQUALS("[test.cpp:2:17]: (error) Pointer addition with NULL pointer. [nullPointerArithmetic]\n", errout_str());
 
         check("void foo(char *s) {\n"
               "  if (!s) {}\n"
               "  char * p = 20 + s;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Either the condition '!s' is redundant or there is pointer arithmetic with NULL pointer.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:7] -> [test.cpp:3:17]: (warning) Either the condition '!s' is redundant or there is pointer arithmetic with NULL pointer. [nullPointerArithmeticRedundantCheck]\n", errout_str());
 
         check("void foo(char *s) {\n"
               "  s += 20;\n"
               "}\n"
-              "void bar() { foo(0); }\n");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Pointer addition with NULL pointer.\n", errout.str());
+              "void bar() { foo(0); }");
+        ASSERT_EQUALS("[test.cpp:2:5]: (error) Pointer addition with NULL pointer. [nullPointerArithmetic]\n", errout_str());
 
         check("void foo(char *s) {\n"
               "  if (!s) {}\n"
               "  s += 20;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Either the condition '!s' is redundant or there is pointer arithmetic with NULL pointer.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:7] -> [test.cpp:3:5]: (warning) Either the condition '!s' is redundant or there is pointer arithmetic with NULL pointer. [nullPointerArithmeticRedundantCheck]\n", errout_str());
 
         check("int* f7() { int *x = NULL; return ++x; }");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Pointer addition with NULL pointer.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:35]: (error) Pointer addition with NULL pointer. [nullPointerArithmetic]\n", errout_str());
 
-        check("int* f10() { int *x = NULL; return x++; } ");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Pointer addition with NULL pointer.\n", errout.str());
+        check("int* f10() { int *x = NULL; return x++; }");
+        ASSERT_EQUALS("[test.cpp:1:37]: (error) Pointer addition with NULL pointer. [nullPointerArithmetic]\n", errout_str());
 
         check("class foo {};\n"
               "const char* get() const { return 0; }\n"
-              "void f(foo x) { if (get()) x += get(); }\n");
-        ASSERT_EQUALS("", errout.str());
+              "void f(foo x) { if (get()) x += get(); }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("typedef struct { uint8_t* buf, *buf_end; } S;\n" // #11117
+              "void f(S* s, uint8_t* buffer, int buffer_size) {\n"
+              "    if (buffer_size < 0) {\n"
+              "        buffer_size = 0;\n"
+              "        buffer = NULL;\n"
+              "    }\n"
+              "    s->buf = buffer;\n"
+              "    s->buf_end = s->buf + buffer_size;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void ctu(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
+    void isPointerDeRefFunctionDecl() {
+        check("const char** get() { return 0; }");
+        ASSERT_EQUALS("", errout_str());
+    }
 
+#define ctu(...) ctu_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void ctu_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
-        CTU::FileInfo *ctu = CTU::getFileInfo(&tokenizer);
+        CTU::FileInfo *ctu = CTU::getFileInfo(tokenizer);
 
         // Check code..
         std::list<Check::FileInfo*> fileInfo;
-        CheckNullPointer check(&tokenizer, &settings, this);
-        fileInfo.push_back(check.getFileInfo(&tokenizer, &settings));
-        check.analyseWholeProgram(ctu, fileInfo, settings, *this);
+        Check& c = getCheck<CheckNullPointer>();
+        fileInfo.push_back(c.getFileInfo(tokenizer, settings, ""));
+        c.analyseWholeProgram(*ctu, fileInfo, settings, *this); // TODO: check result
         while (!fileInfo.empty()) {
             delete fileInfo.back();
             fileInfo.pop_back();
@@ -2946,7 +4688,7 @@ class TestNullPointer : public TestFixture {
         delete ctu;
     }
 
-    void ctu() {
+    void ctuTest() {
         setMultiline();
 
         ctu("void f(int *fp) {\n"
@@ -2956,20 +4698,20 @@ class TestNullPointer : public TestFixture {
             "  int *p = 0;\n"
             "  f(p);\n"
             "}");
-        ASSERT_EQUALS("test.cpp:2:error:Null pointer dereference: fp\n"
-                      "test.cpp:5:note:Assignment 'p=0', assigned value is 0\n"
-                      "test.cpp:6:note:Calling function f, 1st argument is null\n"
-                      "test.cpp:2:note:Dereferencing argument fp that is null\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: error: Null pointer dereference: fp [ctunullpointer]\n"
+                      "[test.cpp:5:12]: note: Assignment 'p=0', assigned value is 0\n"
+                      "[test.cpp:6:4]: note: Calling function f, 1st argument is null\n"
+                      "[test.cpp:2:10]: note: Dereferencing argument fp that is null\n", errout_str());
 
         ctu("void use(int *p) { a = *p + 3; }\n"
             "void call(int x, int *p) { x++; use(p); }\n"
             "int main() {\n"
             "  call(4,0);\n"
             "}");
-        ASSERT_EQUALS("test.cpp:1:error:Null pointer dereference: p\n"
-                      "test.cpp:4:note:Calling function call, 2nd argument is null\n"
-                      "test.cpp:2:note:Calling function use, 1st argument is null\n"
-                      "test.cpp:1:note:Dereferencing argument p that is null\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:25]: error: Null pointer dereference: p [ctunullpointer]\n"
+                      "[test.cpp:4:7]: note: Calling function call, 2nd argument is null\n"
+                      "[test.cpp:2:33]: note: Calling function use, 1st argument is null\n"
+                      "[test.cpp:1:25]: note: Dereferencing argument p that is null\n", errout_str());
 
         ctu("void dostuff(int *x, int *y) {\n"
             "  if (!var)\n"
@@ -2980,7 +4722,7 @@ class TestNullPointer : public TestFixture {
             "void f() {\n"
             "  dostuff(a, 0);\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         ctu("void dostuff(int *x, int *y) {\n"
             "  if (cond)\n"
@@ -2991,7 +4733,7 @@ class TestNullPointer : public TestFixture {
             "void f() {\n"
             "  dostuff(a, 0);\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // else
         ctu("void dostuff(int mask, int *p) {\n"
@@ -3002,7 +4744,7 @@ class TestNullPointer : public TestFixture {
             "void f() {\n"
             "  dostuff(0, 0);\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ?, &&, ||
         ctu("void dostuff(int mask, int *p) {\n"
@@ -3012,14 +4754,60 @@ class TestNullPointer : public TestFixture {
             "void f() {\n"
             "  dostuff(0, 0);\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         ctu("void g(int* x) { *x; }\n"
             "void f(int* x) {\n"
             "    if (x)\n"
             "        g(x);\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        ctu("size_t f(int* p) {\n"
+            "    size_t len = sizeof(*p);\n"
+            "    return len;\n"
+            "}\n"
+            "void g() {\n"
+            "    f(NULL);\n"
+            "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        ctu("size_t f(int* p) {\n"
+            "    size_t len = alignof(*p);\n"
+            "    return len;\n"
+            "}\n"
+            "void g() {\n"
+            "    f(NULL);\n"
+            "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // ctu: memory allocation fails
+        ctu("void f(int* p) {\n"
+            "    *p = 0;\n"
+            "}\n"
+            "void g() {\n"
+            "    int* q = (int*)malloc(4);\n"
+            "    f(q);\n"
+            "}\n");
+        ASSERT_EQUALS("[test.cpp:2:6]: warning: If memory allocation fails, then there is a possible null pointer dereference: p [ctunullpointerOutOfMemory]\n"
+                      "[test.cpp:5:26]: note: Assuming allocation function fails\n"
+                      "[test.cpp:5:14]: note: Assignment 'q=(int*)malloc(4)', assigned value is 0\n"
+                      "[test.cpp:6:6]: note: Calling function f, 1st argument is null\n"
+                      "[test.cpp:2:6]: note: Dereferencing argument p that is null\n", errout_str());
+
+        // ctu: resource allocation fails
+        ctu("void foo(FILE* f) {\n"
+            "    fprintf(f, a);\n"
+            "}\n"
+            "void bar() {\n"
+            "    FILE* f = fopen(notexist,t);\n"
+            "    foo(f);\n"
             "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: warning: If resource allocation fails, then there is a possible null pointer dereference: f [ctunullpointerOutOfResources]\n"
+                      "[test.cpp:5:20]: note: Assuming allocation function fails\n"
+                      "[test.cpp:5:20]: note: Assignment 'f=fopen(notexist,t)', assigned value is 0\n"
+                      "[test.cpp:6:8]: note: Calling function foo, 1st argument is null\n"
+                      "[test.cpp:2:13]: note: Dereferencing argument f that is null\n", errout_str());
     }
 };
 
diff --git a/test/testoptions.cpp b/test/testoptions.cpp
index 0e6001b4cd9..7c72b2de336 100644
--- a/test/testoptions.cpp
+++ b/test/testoptions.cpp
@@ -1,32 +1,37 @@
-// Cppcheck - A tool for static C/C++ code analysis
-// Copyright (C) 2007-2019 Cppcheck team.
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "fixture.h"
 #include "options.h"
-#include "testsuite.h"
+#include "utils.h"
+
+#include <set>
+#include <string>
 
 
-class TestOptions: public TestFixture {
+class TestOptions : public TestFixture {
 public:
     TestOptions()
-        :TestFixture("TestOptions") {
-    }
+        : TestFixture("TestOptions") {}
 
 
 private:
-    void run() OVERRIDE {
+    void run() override {
         TEST_CASE(which_test);
         TEST_CASE(which_test_method);
         TEST_CASE(no_test_method);
@@ -38,84 +43,98 @@ class TestOptions: public TestFixture {
         TEST_CASE(multiple_testcases);
         TEST_CASE(multiple_testcases_ignore_duplicates);
         TEST_CASE(invalid_switches);
+        TEST_CASE(summary);
+        TEST_CASE(dry_run);
     }
 
 
     void which_test() const {
         const char* argv[] = {"./test_runner", "TestClass"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         ASSERT(std::set<std::string> {"TestClass"} == args.which_test());
     }
 
 
     void which_test_method() const {
         const char* argv[] = {"./test_runner", "TestClass::TestMethod"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         ASSERT(std::set<std::string> {"TestClass::TestMethod"} == args.which_test());
     }
 
 
     void no_test_method() const {
         const char* argv[] = {"./test_runner"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         ASSERT(std::set<std::string> {""} == args.which_test());
     }
 
 
     void not_quiet() const {
         const char* argv[] = {"./test_runner", "TestClass::TestMethod", "-v"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         ASSERT_EQUALS(false, args.quiet());
     }
 
 
     void quiet() const {
         const char* argv[] = {"./test_runner", "TestClass::TestMethod", "-q"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         ASSERT_EQUALS(true, args.quiet());
     }
 
     void not_help() const {
         const char* argv[] = {"./test_runner", "TestClass::TestMethod", "-v"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         ASSERT_EQUALS(false, args.help());
     }
 
 
     void help() const {
         const char* argv[] = {"./test_runner", "TestClass::TestMethod", "-h"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         ASSERT_EQUALS(true, args.help());
     }
 
 
     void help_long() const {
         const char* argv[] = {"./test_runner", "TestClass::TestMethod", "--help"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         ASSERT_EQUALS(true, args.help());
     }
 
     void multiple_testcases() const {
         const char* argv[] = {"./test_runner", "TestClass::TestMethod", "TestClass::AnotherTestMethod"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         std::set<std::string> expected {"TestClass::TestMethod", "TestClass::AnotherTestMethod"};
         ASSERT(expected == args.which_test());
     }
 
     void multiple_testcases_ignore_duplicates() const {
         const char* argv[] = {"./test_runner", "TestClass::TestMethod", "TestClass"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         std::set<std::string> expected {"TestClass"};
         ASSERT(expected == args.which_test());
     }
 
     void invalid_switches() const {
         const char* argv[] = {"./test_runner", "TestClass::TestMethod", "-a", "-v", "-q"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         std::set<std::string> expected {"TestClass::TestMethod"};
         ASSERT(expected == args.which_test());
         ASSERT_EQUALS(true, args.quiet());
     }
+
+    void summary() const {
+        const char* argv[] = {"./test_runner", "TestClass::TestMethod", "-n"};
+        options args(getArrayLength(argv), argv);
+        ASSERT_EQUALS(false, args.summary());
+    }
+
+    void dry_run() const {
+        const char* argv[] = {"./test_runner", "TestClass::TestMethod", "-d"};
+        options args(getArrayLength(argv), argv);
+        ASSERT_EQUALS(true, args.dry_run());
+    }
 };
 
 REGISTER_TEST(TestOptions)
diff --git a/test/testother.cpp b/test/testother.cpp
index 79851ee67b7..d2f57bbb2a4 100644
--- a/test/testother.cpp
+++ b/test/testother.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,31 +17,39 @@
  */
 
 #include "checkother.h"
-#include "library.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "platform.h"
 #include "settings.h"
 #include "standards.h"
-#include "testsuite.h"
-#include "tokenize.h"
 
-#include <simplecpp.h>
-#include <tinyxml2.h>
-#include <map>
+#include <cstddef>
+#include <sstream>
 #include <string>
-#include <vector>
+
+static std::string unionZeroInitMessage(int lno, int cno, const std::string &varName, const std::string &largestMemberName)
+{
+    std::stringstream ss;
+    ss << "[test.cpp:" << lno << ":" << cno << "]: (portability) ";
+    ss << "Zero initializing union '" << varName << "' ";
+    ss << "does not guarantee its complete storage to be zero initialized as its largest member is not declared as the first member. ";
+    ss << "Consider making " << largestMemberName << " the first member or favor memset(). [UnionZeroInit]";
+    ss << std::endl;
+    return ss.str();
+}
 
 class TestOther : public TestFixture {
 public:
-    TestOther() : TestFixture("TestOther") {
-    }
+    TestOther() : TestFixture("TestOther") {}
 
 private:
-    Settings _settings;
-
-    void run() OVERRIDE {
-        LOAD_LIB_2(_settings.library, "std.cfg");
-
+    const Settings settings0 = settingsBuilder().library("std.cfg").build();
+    /*const*/ Settings settings1 = settingsBuilder().library("std.cfg").severity(Severity::style).severity(Severity::warning).severity(Severity::portability).severity(Severity::performance).build();
+    const Settings settings2 = settingsBuilder(settings1).certainty(Certainty::inconclusive).build();
 
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(emptyBrackets);
 
         TEST_CASE(zeroDiv1);
@@ -56,6 +64,16 @@ class TestOther : public TestFixture {
         TEST_CASE(zeroDiv10);
         TEST_CASE(zeroDiv11);
         TEST_CASE(zeroDiv12);
+        TEST_CASE(zeroDiv13);
+        TEST_CASE(zeroDiv14); // #1169
+        TEST_CASE(zeroDiv15); // #8319
+        TEST_CASE(zeroDiv16); // #11158
+        TEST_CASE(zeroDiv17); // #9931
+        TEST_CASE(zeroDiv18);
+        TEST_CASE(zeroDiv19);
+        TEST_CASE(zeroDiv20); // #11175
+        TEST_CASE(zeroDiv21);
+        TEST_CASE(zeroDiv22);
 
         TEST_CASE(zeroDivCond); // division by zero / useless condition
 
@@ -86,22 +104,50 @@ class TestOther : public TestFixture {
         TEST_CASE(varScope24);      // pointer / reference
         TEST_CASE(varScope25);      // time_t
         TEST_CASE(varScope26);      // range for loop, map
+        TEST_CASE(varScope27);      // #7733 - #if
+        TEST_CASE(varScope28);      // #10527
+        TEST_CASE(varScope29);      // #10888
+        TEST_CASE(varScope30);      // #8541
+        TEST_CASE(varScope31);      // #11099
+        TEST_CASE(varScope32);      // #11441
+        TEST_CASE(varScope33);
+        TEST_CASE(varScope34);
+        TEST_CASE(varScope35);
+        TEST_CASE(varScope36);      // #12158
+        TEST_CASE(varScope37);      // #12158
+        TEST_CASE(varScope38);
+        TEST_CASE(varScope39);
+        TEST_CASE(varScope40);
+        TEST_CASE(varScope41);      // #11845
+        TEST_CASE(varScope42);
+        TEST_CASE(varScope43);
+        TEST_CASE(varScope44);
+        TEST_CASE(varScope45);
+        TEST_CASE(varScope46);
 
         TEST_CASE(oldStylePointerCast);
+        TEST_CASE(intToPointerCast);
         TEST_CASE(invalidPointerCast);
 
         TEST_CASE(passedByValue);
         TEST_CASE(passedByValue_nonConst);
+        TEST_CASE(passedByValue_externC);
 
         TEST_CASE(constVariable);
+        TEST_CASE(constParameterCallback);
+        TEST_CASE(constPointer);
+        TEST_CASE(constArray);
 
         TEST_CASE(switchRedundantAssignmentTest);
         TEST_CASE(switchRedundantOperationTest);
         TEST_CASE(switchRedundantBitwiseOperationTest);
         TEST_CASE(unreachableCode);
+        TEST_CASE(redundantContinue);
 
         TEST_CASE(suspiciousCase);
         TEST_CASE(suspiciousEqualityComparison);
+        TEST_CASE(suspiciousUnaryPlusMinus); // #8004
+        TEST_CASE(suspiciousFloatingPointCast);
 
         TEST_CASE(selfAssignment);
         TEST_CASE(trac1132);
@@ -117,7 +163,9 @@ class TestOther : public TestFixture {
         TEST_CASE(testMisusedScopeObjectDoesNotPickPureC);
         TEST_CASE(testMisusedScopeObjectDoesNotPickNestedClass);
         TEST_CASE(testMisusedScopeObjectInConstructor);
-        TEST_CASE(testMisusedScopeObjectNoCodeAfter);
+        TEST_CASE(testMisusedScopeObjectStandardType);
+        TEST_CASE(testMisusedScopeObjectNamespace);
+        TEST_CASE(testMisusedScopeObjectAssignment); // #11371
         TEST_CASE(trac2071);
         TEST_CASE(trac2084);
         TEST_CASE(trac3693);
@@ -129,6 +177,9 @@ class TestOther : public TestFixture {
         TEST_CASE(duplicateBranch1); // tests extracted by http://www.viva64.com/en/b/0149/ ( Comparison between PVS-Studio and cppcheck ): Errors detected in Quake 3: Arena by PVS-Studio: Fragment 2
         TEST_CASE(duplicateBranch2); // empty macro
         TEST_CASE(duplicateBranch3);
+        TEST_CASE(duplicateBranch4);
+        TEST_CASE(duplicateBranch5); // make sure the Token attributes are compared
+        TEST_CASE(duplicateBranch6);
         TEST_CASE(duplicateExpression1);
         TEST_CASE(duplicateExpression2); // ticket #2730
         TEST_CASE(duplicateExpression3); // ticket #3317
@@ -138,10 +189,23 @@ class TestOther : public TestFixture {
         TEST_CASE(duplicateExpression7);
         TEST_CASE(duplicateExpression8);
         TEST_CASE(duplicateExpression9); // #9320
+        TEST_CASE(duplicateExpression10); // #9485
+        TEST_CASE(duplicateExpression11); // #8916 (function call)
+        TEST_CASE(duplicateExpression12); // #10026
+        TEST_CASE(duplicateExpression13); // #7899
+        TEST_CASE(duplicateExpression14); // #9871
+        TEST_CASE(duplicateExpression15); // #10650
+        TEST_CASE(duplicateExpression16); // #10569
+        TEST_CASE(duplicateExpression17); // #12036
+        TEST_CASE(duplicateExpression18);
+        TEST_CASE(duplicateExpression19);
+        TEST_CASE(duplicateExpression20);
         TEST_CASE(duplicateExpressionLoop);
         TEST_CASE(duplicateValueTernary);
+        TEST_CASE(duplicateValueTernarySizeof); // #13773
         TEST_CASE(duplicateExpressionTernary); // #6391
         TEST_CASE(duplicateExpressionTemplate); // #6930
+        TEST_CASE(duplicateExpressionCompareWithZero);
         TEST_CASE(oppositeExpression);
         TEST_CASE(duplicateVarExpression);
         TEST_CASE(duplicateVarExpressionUnique);
@@ -152,8 +216,10 @@ class TestOther : public TestFixture {
         TEST_CASE(checkSignOfUnsignedVariable);
         TEST_CASE(checkSignOfPointer);
 
-        TEST_CASE(checkForSuspiciousSemicolon1);
-        TEST_CASE(checkForSuspiciousSemicolon2);
+        TEST_CASE(checkSuspiciousSemicolon1);
+        TEST_CASE(checkSuspiciousSemicolon2);
+        TEST_CASE(checkSuspiciousSemicolon3);
+        TEST_CASE(checkSuspiciousComparison);
 
         TEST_CASE(checkInvalidFree);
 
@@ -164,21 +230,24 @@ class TestOther : public TestFixture {
         TEST_CASE(incompleteArrayFill);
 
         TEST_CASE(redundantVarAssignment);
+        TEST_CASE(redundantVarAssignment_trivial);
         TEST_CASE(redundantVarAssignment_struct);
+        TEST_CASE(redundantVarAssignment_union);
         TEST_CASE(redundantVarAssignment_7133);
         TEST_CASE(redundantVarAssignment_stackoverflow);
         TEST_CASE(redundantVarAssignment_lambda);
-        TEST_CASE(redundantVarAssignment_for);
+        TEST_CASE(redundantVarAssignment_loop);
         TEST_CASE(redundantVarAssignment_after_switch);
         TEST_CASE(redundantVarAssignment_pointer);
         TEST_CASE(redundantVarAssignment_pointer_parameter);
+        TEST_CASE(redundantVarAssignment_array);
+        TEST_CASE(redundantVarAssignment_switch_break);
         TEST_CASE(redundantInitialization);
-        TEST_CASE(redundantMemWrite);
+        //TEST_CASE(redundantMemWrite); // FIXME: temporary hack
+        TEST_CASE(redundantAssignmentSameValue);
 
         TEST_CASE(varFuncNullUB);
 
-        TEST_CASE(checkPipeParameterSize); // ticket #3521
-
         TEST_CASE(checkCastIntToCharAndBack); // ticket #160
 
         TEST_CASE(checkCommaSeparatedReturn);
@@ -193,6 +262,9 @@ class TestOther : public TestFixture {
         TEST_CASE(raceAfterInterlockedDecrement);
 
         TEST_CASE(testUnusedLabel);
+        TEST_CASE(testUnusedLabelConfiguration);
+        TEST_CASE(testUnusedLabelSwitchConfiguration);
+        TEST_CASE(testUnusedLabelPremiumMisra);
 
         TEST_CASE(testEvaluationOrder);
         TEST_CASE(testEvaluationOrderSelfAssignment);
@@ -206,6 +278,8 @@ class TestOther : public TestFixture {
         TEST_CASE(doubleMove1);
         TEST_CASE(doubleMoveMemberInitialization1);
         TEST_CASE(doubleMoveMemberInitialization2);
+        TEST_CASE(doubleMoveMemberInitialization3); // #9974
+        TEST_CASE(doubleMoveMemberInitialization4);
         TEST_CASE(moveAndAssign1);
         TEST_CASE(moveAndAssign2);
         TEST_CASE(moveAssignMoveAssign);
@@ -222,111 +296,106 @@ class TestOther : public TestFixture {
         TEST_CASE(moveAndAddressOf);
         TEST_CASE(partiallyMoved);
         TEST_CASE(moveAndLambda);
+        TEST_CASE(moveInLoop);
+        TEST_CASE(moveCallback);
+        TEST_CASE(moveClassVariable);
         TEST_CASE(forwardAndUsed);
+        TEST_CASE(moveAndReference);
+        TEST_CASE(moveForRange);
+        TEST_CASE(moveTernary);
+        TEST_CASE(movePointerAlias);
 
         TEST_CASE(funcArgNamesDifferent);
         TEST_CASE(funcArgOrderDifferent);
         TEST_CASE(cpp11FunctionArgInit); // #7846 - "void foo(int declaration = {}) {"
 
         TEST_CASE(shadowVariables);
-        TEST_CASE(constArgument);
+        TEST_CASE(knownArgument);
+        TEST_CASE(knownArgumentHiddenVariableExpression);
+        TEST_CASE(knownArgumentTernaryOperator);
         TEST_CASE(checkComparePointers);
 
         TEST_CASE(unusedVariableValueTemplate); // #8994
-    }
 
-    void check(const char code[], const char *filename = nullptr, bool experimental = false, bool inconclusive = true, bool runSimpleChecks=true, bool verbose=false, Settings* settings = nullptr) {
-        // Clear the error buffer..
-        errout.str("");
-
-        if (!settings) {
-            settings = &_settings;
-        }
-        settings->addEnabled("style");
-        settings->addEnabled("warning");
-        settings->addEnabled("portability");
-        settings->addEnabled("performance");
-        settings->standards.c = Standards::CLatest;
-        settings->standards.cpp = Standards::CPPLatest;
-        settings->inconclusive = inconclusive;
-        settings->experimental = experimental;
-        settings->verbose = verbose;
+        TEST_CASE(moduloOfOne);
 
-        // Tokenize..
-        Tokenizer tokenizer(settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, filename ? filename : "test.cpp");
+        TEST_CASE(sameExpressionPointers);
 
-        // Check..
-        CheckOther checkOther(&tokenizer, settings, this);
-        checkOther.runChecks(&tokenizer, settings, this);
+        TEST_CASE(checkOverlappingWrite);
 
-        (void)runSimpleChecks; // TODO Remove this
-    }
+        TEST_CASE(constVariableArrayMember); // #10371
 
-    void check(const char code[], Settings *s) {
-        check(code,"test.cpp",false,true,true,false,s);
-    }
+        TEST_CASE(knownPointerToBool);
+        TEST_CASE(iterateByValue);
 
-    void checkP(const char code[], const char *filename = "test.cpp") {
-        // Clear the error buffer..
-        errout.str("");
+        TEST_CASE(knownConditionFloating);
+        TEST_CASE(knownConditionPrefixed);
 
-        Settings* settings = &_settings;
-        settings->addEnabled("style");
-        settings->addEnabled("warning");
-        settings->addEnabled("portability");
-        settings->addEnabled("performance");
-        settings->standards.c = Standards::CLatest;
-        settings->standards.cpp = Standards::CPPLatest;
-        settings->inconclusive = true;
-        settings->experimental = false;
+        TEST_CASE(unionZeroInitBasic);
+        TEST_CASE(unionZeroInitArrayMember);
+        TEST_CASE(unionZeroInitStructMember);
+        TEST_CASE(unionZeroInitUnknownType);
+        TEST_CASE(unionZeroInitBitfields);
+    }
 
-        // Raw tokens..
-        std::vector<std::string> files(1, filename);
-        std::istringstream istr(code);
-        const simplecpp::TokenList tokens1(istr, files, files[0]);
+    struct CheckOptions
+    {
+        bool cpp = true;
+        bool inconclusive = true;
+        bool verbose = false;
+        Settings* settings = nullptr; // TODO: split from this
+    };
 
-        // Preprocess..
-        simplecpp::TokenList tokens2(files);
-        std::map<std::string, simplecpp::TokenList*> filedata;
-        simplecpp::preprocess(tokens2, tokens1, files, filedata, simplecpp::DUI());
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const CheckOptions& opt = make_default_obj{}) {
+        // TODO: do not modify object passed into
+        Settings* settings;
+        if (!opt.settings) {
+            settings = &settings1;
+        }
+        else {
+            settings = opt.settings;
+        }
+        settings->certainty.setEnabled(Certainty::inconclusive, opt.inconclusive);
+        settings->verbose = opt.verbose;
 
-        // Tokenizer..
-        Tokenizer tokenizer(settings, this);
-        tokenizer.createTokens(&tokens2);
-        tokenizer.simplifyTokens1("");
+        // Tokenize..
+        SimpleTokenizer tokenizer(*settings, *this, opt.cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check..
-        CheckOther checkOther(&tokenizer, settings, this);
-        checkOther.runChecks(&tokenizer, settings, this);
+        runChecks<CheckOther>(tokenizer, this);
     }
 
-    void checkposix(const char code[]) {
-        static Settings settings;
-        settings.addEnabled("warning");
-        settings.libraries.emplace_back("posix");
+    struct CheckPOptions
+    {
+        bool cpp = true;
+    };
+
+#define checkP(...) checkP_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkP_(const char* file, int line, const char (&code)[size], const CheckPOptions& options = make_default_obj()) {
+        SimpleTokenizer2 tokenizer(settings2, *this, code, options.cpp ? "test.cpp" : "test.c");
+
+        // Tokenizer..
+        ASSERT_LOC(tokenizer.simplifyTokens1(""), file, line);
 
-        check(code,
-              nullptr, // filename
-              false,   // experimental
-              false,   // inconclusive
-              true,    // runSimpleChecks
-              false,   // verbose
-              &settings);
+        // Check..
+        runChecks<CheckOther>(tokenizer, this);
     }
 
-    void checkInterlockedDecrement(const char code[]) {
-        static Settings settings;
-        settings.platformType = Settings::Win32A;
+    template<size_t size>
+    void checkInterlockedDecrement(const char (&code)[size]) {
+        /*const*/ Settings settings = settingsBuilder().platform(Platform::Type::Win32A).build();
 
-        check(code, nullptr, false, false, true, false, &settings);
+        check(code, dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
     }
 
     void emptyBrackets() {
         check("{\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -334,22 +403,22 @@ class TestOther : public TestFixture {
         check("void foo() {\n"
               "    cout << 1. / 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    cout << 42 / (double)0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    cout << 42 / (float)0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    cout << 42 / (int)0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Division by zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:16]: (error) Division by zero. [zerodiv]\n", errout_str());
     }
 
     void zeroDiv2() {
@@ -362,34 +431,34 @@ class TestOther : public TestFixture {
               "    }\n"
               "    cout<<b/sum;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void zeroDiv3() {
         check("int foo(int i) {\n"
               "    return i / 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Division by zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (error) Division by zero. [zerodiv]\n", errout_str());
 
         check("int foo(int i) {\n"
               "    return i % 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Division by zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (error) Division by zero. [zerodiv]\n", errout_str());
 
         check("void foo(int& i) {\n"
               "    i /= 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Division by zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:7]: (error) Division by zero. [zerodiv]\n", errout_str());
 
         check("void foo(int& i) {\n"
               "    i %= 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Division by zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:7]: (error) Division by zero. [zerodiv]\n", errout_str());
 
         check("uint8_t foo(uint8_t i) {\n"
               "    return i / 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Division by zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (error) Division by zero. [zerodiv]\n", errout_str());
     }
 
     void zeroDiv4() {
@@ -397,40 +466,40 @@ class TestOther : public TestFixture {
               "{\n"
               "   long a = b / 0x6;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
               "   long a = b / 0x0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void f(long b)\n"
               "{\n"
               "   long a = b / 0x0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Division by zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:15]: (error) Division by zero. [zerodiv]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "   long a = b / 0L;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void f(long b)\n"
               "{\n"
               "   long a = b / 0L;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Division by zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:15]: (error) Division by zero. [zerodiv]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "   long a = b / 0ul;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void f(long b)\n"
               "{\n"
               "   long a = b / 0ul;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Division by zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:15]: (error) Division by zero. [zerodiv]\n", errout_str());
 
         // Don't warn about floating points (gcc doesn't warn either)
         // and floating points are handled differently than integers.
@@ -438,13 +507,13 @@ class TestOther : public TestFixture {
               "{\n"
               "   long a = b / 0.0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
               "   long a = b / 0.5;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void zeroDiv5() {
@@ -452,12 +521,12 @@ class TestOther : public TestFixture {
               "{ { {\n"
               "   long a = b / 0;\n"
               "} } }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void f(long b)\n"
               "{ { {\n"
               "   long a = b / 0;\n"
               "} } }");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Division by zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:15]: (error) Division by zero. [zerodiv]\n", errout_str());
     }
 
     void zeroDiv6() {
@@ -465,12 +534,12 @@ class TestOther : public TestFixture {
               "{ { {\n"
               "   int a = b % 0;\n"
               "} } }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void f(int b)\n"
               "{ { {\n"
               "   int a = b % 0;\n"
               "} } }");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Division by zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:14]: (error) Division by zero. [zerodiv]\n", errout_str());
     }
 
     void zeroDiv7() {
@@ -479,13 +548,13 @@ class TestOther : public TestFixture {
               "  int a = x/2*3/0;\n"
               "  int b = y/2*3%0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void f(int x, int y) {\n"
               "  int a = x/2*3/0;\n"
               "  int b = y/2*3%0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Division by zero.\n"
-                      "[test.cpp:3]: (error) Division by zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:16]: (error) Division by zero. [zerodiv]\n"
+                      "[test.cpp:3:16]: (error) Division by zero. [zerodiv]\n", errout_str());
     }
 
     void zeroDiv8() {
@@ -495,7 +564,7 @@ class TestOther : public TestFixture {
               "  do_something(a);\n"
               "  return 4 / a;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error, inconclusive) Division by zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:12]: (error, inconclusive) Division by zero. [zerodiv]\n", errout_str());
     }
 
     void zeroDiv9() {
@@ -509,7 +578,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void zeroDiv10() {
@@ -520,7 +589,7 @@ class TestOther : public TestFixture {
               "    << std::endl;\n"
               "  return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void zeroDiv11() {
@@ -528,21 +597,135 @@ class TestOther : public TestFixture {
               "  int res = (a+2)/0;\n"
               "  int res = (a*2)/0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Division by zero.\n"
-                      "[test.cpp:3]: (error) Division by zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:18]: (error) Division by zero. [zerodiv]\n"
+                      "[test.cpp:3:18]: (error) Division by zero. [zerodiv]\n", errout_str());
         check("void f() {\n"
               "  int res = (a+2)/0;\n"
               "  int res = (a*2)/0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void zeroDiv12() {
         // #8141
         check("intmax_t f() {\n"
               "  return 1 / imaxabs(0);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:12]: (error) Division by zero. [zerodiv]\n", errout_str());
+    }
+    void zeroDiv13() {
+        // #7324
+        check("int f () {\n"
+              "    int dividend = 10;\n"
+              "        int divisor = 1;\n"
+              "    dividend = dividend / (--divisor);\n"
+              "    return dividend;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:25]: (error) Division by zero. [zerodiv]\n", errout_str());
+    }
+
+    void zeroDiv14() {
+        check("void f() {\n" // #1169
+              "    double dx = 1.;\n"
+              "    int ix = 1;\n"
+              "    int i = 1;\n"
+              "    std::cout << ix / (i >> 1) << std::endl;\n"
+              "    std::cout << dx / (i >> 1) << std::endl;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:21]: (error) Division by zero. [zerodiv]\n", errout_str());
+    }
+
+    void zeroDiv15() { // #8319
+        check("int f(int i) { return i - 1; }\n"
+              "int f() {\n"
+              "    const int d = 1;\n"
+              "    const int r = 1 / f(d);\n"
+              "    return r;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:21]: (error) Division by zero. [zerodiv]\n", errout_str());
+    }
+
+    // #11158
+    void zeroDiv16()
+    {
+        check("int f(int i) {\n"
+              "    int number = 10, a = 0;\n"
+              "    for (int count = 0; count < 2; count++) {\n"
+              "        a += (i / number) % 10;\n"
+              "        number = number / 10;\n"
+              "    }\n"
+              "    return a;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int i) {\n"
+              "    int number = 10, a = 0;\n"
+              "    for (int count = 0; count < 2; count++) {\n"
+              "        int x = number / 10;\n"
+              "        a += (i / number) % 10;\n"
+              "        number = x;\n"
+              "    }\n"
+              "    return a;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void zeroDiv17() { // #9931
+        check("int f(int len) {\n"
+              "    int sz = sizeof(void*[255]) / 255;\n"
+              "    int x = len % sz;\n"
+              "    return x;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void zeroDiv18()
+    {
+        check("int f(int x, int y) {\n"
+              "    if (x == y) {}\n"
+              "    return 1 / (x-y);\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:2:11] -> [test.cpp:3:14]: (warning) Either the condition 'x==y' is redundant or there is division by zero at line 3. [zerodivcond]\n",
+            errout_str());
+    }
+
+    void zeroDiv19()
+    {
+        check("void f() {\n" // #2456
+              "    for (int i = 0;;)\n"
+              "        int j = 10 / i;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:20]: (error) Division by zero. [zerodiv]\n", errout_str());
+    }
+
+    void zeroDiv20()
+    {
+        check("uint16_t f(void)\n" // #11175
+              "{\n"
+              "    uint16_t x = 0xFFFFU;\n" // UINT16_MAX=0xFFFF
+              "    return 42/(++x);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:14]: (error) Division by zero. [zerodiv]\n", errout_str());
+    }
+
+    void zeroDiv21()
+    {
+        check("int f(int n) {\n"
+              "    return 1 / ((1 / n) - 1);\n"
+              "}\n"
+              "int g() {\n"
+              "    return f(1);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:14]: (error) Division by zero. [zerodiv]\n", errout_str());
+    }
+
+    void zeroDiv22()
+    {
+        check("int main() {\n"
+              "    return _Generic((0), int: (42) / (0), default: 0);\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Division by zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:36]: (error) Division by zero. [zerodiv]\n", errout_str());
     }
 
     void zeroDivCond() {
@@ -550,25 +733,25 @@ class TestOther : public TestFixture {
               "  int y = 17 / x;\n"
               "  if (x > 0) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (warning) Either the condition 'x>0' is redundant or there is division by zero at line 2.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:2:14]: (warning) Either the condition 'x>0' is redundant or there is division by zero at line 2. [zerodivcond]\n", errout_str());
 
         check("void f(unsigned int x) {\n"
               "  int y = 17 / x;\n"
               "  if (x >= 1) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (warning) Either the condition 'x>=1' is redundant or there is division by zero at line 2.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:2:14]: (warning) Either the condition 'x>=1' is redundant or there is division by zero at line 2. [zerodivcond]\n", errout_str());
 
         check("void f(int x) {\n"
               "  int y = 17 / x;\n"
               "  if (x == 0) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (warning) Either the condition 'x==0' is redundant or there is division by zero at line 2.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:2:14]: (warning) Either the condition 'x==0' is redundant or there is division by zero at line 2. [zerodivcond]\n", errout_str());
 
         check("void f(unsigned int x) {\n"
               "  int y = 17 / x;\n"
               "  if (x != 0) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (warning) Either the condition 'x!=0' is redundant or there is division by zero at line 2.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:2:14]: (warning) Either the condition 'x!=0' is redundant or there is division by zero at line 2. [zerodivcond]\n", errout_str());
 
         // function call
         check("void f1(int x, int y) { c=x/y; }\n"
@@ -576,10 +759,9 @@ class TestOther : public TestFixture {
               "    f1(123,y);\n"
               "    if (y>0){}\n"
               "}");
-        TODO_ASSERT_EQUALS(
-            "[test.cpp:4] -> [test.cpp:1]: (warning) Either the condition 'y>0' is redundant or there is division by zero at line 1.\n",
-            "",
-            errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:4:10] -> [test.cpp:1:28]: (warning) Either the condition 'y>0' is redundant or there is division by zero at line 1. [zerodivcond]\n",
+            errout_str());
 
         // avoid false positives when variable is changed after division
         check("void f() {\n"
@@ -588,7 +770,7 @@ class TestOther : public TestFixture {
               "  x = some+calculation;\n"
               "  if (x != 0) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         {
             // function is called that might modify global variable
@@ -599,7 +781,7 @@ class TestOther : public TestFixture {
                   "  do_something();\n"
                   "  if (x != 0) {}\n"
                   "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
 
             // function is called. but don't care, variable is local
             check("void do_something();\n"
@@ -609,7 +791,7 @@ class TestOther : public TestFixture {
                   "  do_something();\n"
                   "  if (x != 0) {}\n"
                   "}");
-            ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:4]: (warning) Either the condition 'x!=0' is redundant or there is division by zero at line 4.\n", errout.str());
+            ASSERT_EQUALS("[test.cpp:6:9] -> [test.cpp:4:14]: (warning) Either the condition 'x!=0' is redundant or there is division by zero at line 4. [zerodivcond]\n", errout_str());
         }
 
         check("void do_something(int value);\n"
@@ -617,14 +799,14 @@ class TestOther : public TestFixture {
               "  int y = 17 / x;\n"
               "  do_something(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int x;\n"
               "void f() {\n"
               "  int y = 17 / x;\n"
               "  while (y || x == 0) { x--; }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ticket 5033 segmentation fault (valid code) in CheckOther::checkZeroDivisionOrUselessCondition
         check("void f() {\n"
@@ -633,33 +815,33 @@ class TestOther : public TestFixture {
               "double* p3= new double[1];\n"
               "double* pp[3] = {p1,p2,p3};\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #5105 - FP
         check("int f(int a, int b) {\n"
               "  int r = a / b;\n"
               "  if (func(b)) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Unknown types for b and c --> do not warn
         check("int f(int d) {\n"
               "  int r = (a?b:c) / d;\n"
               "  if (d == 0) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f(int a) {\n"
               "  int r = a ? 1 / a : 0;\n"
               "  if (a == 0) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f(int a) {\n"
               "  int r = (a == 0) ? 0 : 1 / a;\n"
               "  if (a == 0) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int g();\n"
               "void f(int b) {\n"
@@ -668,8 +850,46 @@ class TestOther : public TestFixture {
               "  else if (x > 0) {}\n"
               "  else\n"
               "    a = b / -x;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "    int x;\n"
+              "};\n"
+              "int f(A* a) {\n"
+              "    if (a->x == 0) \n"
+              "        a->x = 1;\n"
+              "    return 1/a->x;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10049
+        check("int f(int argc) {\n"
+              "    int quotient, remainder;\n"
+              "    remainder = argc % 2;\n"
+              "    argc = 2;\n"
+              "    quotient = argc;\n"
+              "    if (quotient != 0) \n"
+              "        return quotient;\n"
+              "    return remainder;\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // #11315
+        checkP("#define STATIC_ASSERT(c) \\\n"
+               "do { enum { sa = 1/(int)(!!(c)) }; } while (0)\n"
+               "void f() {\n"
+               "    STATIC_ASSERT(sizeof(int) == sizeof(FOO));\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11505
+        check("void f(uint16_t num, uint8_t radix) {\n"
+              "    int c = num % radix;\n"
+              "    num /= radix;\n"
+              "    if (!num) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void nanInArithmeticExpression() {
@@ -678,35 +898,35 @@ class TestOther : public TestFixture {
               "   double x = 3.0 / 0.0 + 1.0;\n"
               "   printf(\"%f\", x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Using NaN/Inf in a computation.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:19]: (style) Using NaN/Inf in a computation. [nanInArithmeticExpression]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "   double x = 3.0 / 0.0 - 1.0;\n"
               "   printf(\"%f\", x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Using NaN/Inf in a computation.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:19]: (style) Using NaN/Inf in a computation. [nanInArithmeticExpression]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "   double x = 1.0 + 3.0 / 0.0;\n"
               "   printf(\"%f\", x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Using NaN/Inf in a computation.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:25]: (style) Using NaN/Inf in a computation. [nanInArithmeticExpression]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "   double x = 1.0 - 3.0 / 0.0;\n"
               "   printf(\"%f\", x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Using NaN/Inf in a computation.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:25]: (style) Using NaN/Inf in a computation. [nanInArithmeticExpression]\n", errout_str());
 
         check("void f()\n"
               "{\n"
               "   double x = 3.0 / 0.0;\n"
               "   printf(\"%f\", x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
     }
 
@@ -737,7 +957,7 @@ class TestOther : public TestFixture {
               "\n"
               "    return 1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varScope2() {
@@ -747,7 +967,7 @@ class TestOther : public TestFixture {
               "    e.SetValue(12);\n"
               "    throw e;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varScope3() {
@@ -761,7 +981,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    *p = 1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varScope4() {
@@ -769,7 +989,7 @@ class TestOther : public TestFixture {
               "{\n"
               "    int i;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varScope5() {
@@ -780,7 +1000,7 @@ class TestOther : public TestFixture {
               "        for ( ; i < 10; ++i) ;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) The scope of the variable 'i' can be reduced.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) The scope of the variable 'i' can be reduced. [variableScope]\n", errout_str());
 
         check("void f(int x) {\n"
               "    const unsigned char i = 0;\n"
@@ -788,7 +1008,7 @@ class TestOther : public TestFixture {
               "        for ( ; i < 10; ++i) ;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x)\n"
               "{\n"
@@ -798,7 +1018,7 @@ class TestOther : public TestFixture {
               "        for ( ; i < 10; ++i) ;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) The scope of the variable 'i' can be reduced.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) The scope of the variable 'i' can be reduced. [variableScope]\n", errout_str());
     }
 
     void varScope6() {
@@ -812,7 +1032,7 @@ class TestOther : public TestFixture {
               "        c(i);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n" // #5398
               "    bool success = false;\n"
@@ -821,14 +1041,14 @@ class TestOther : public TestFixture {
               "        foo(notReducable);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(Test &test) {\n"
               "  int& x = test.getData();\n"
               "  if (test.process())\n"
               "    x = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -843,7 +1063,7 @@ class TestOther : public TestFixture {
               " }\n"
               "}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int &x)\n"
               "{\n"
@@ -854,7 +1074,7 @@ class TestOther : public TestFixture {
               "    ++x;\n"
               "  } while (x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varScope7() {
@@ -866,7 +1086,7 @@ class TestOther : public TestFixture {
               "        y++;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varScope8() {
@@ -877,12 +1097,25 @@ class TestOther : public TestFixture {
               "        edgeResistance = (edge+1) / 2.0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) The scope of the variable 'edgeResistance' can be reduced.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) The scope of the variable 'edgeResistance' can be reduced. [variableScope]\n", errout_str());
     }
 
     void varScope9() {
         // classes may have extra side effects
         check("class fred {\n"
+              "public:\n"
+              "    fred();\n"
+              "    void x();\n"
+              "};\n"
+              "void test(int a) {\n"
+              "    fred f;\n"
+              "    if (a == 2) {\n"
+              "        f.x();\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("class fred {\n" // #2062
               "public:\n"
               "    void x();\n"
               "};\n"
@@ -892,7 +1125,17 @@ class TestOther : public TestFixture {
               "        f.x();\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:10]: (style) The scope of the variable 'f' can be reduced. [variableScope]\n", errout_str());
+
+        check("struct S { int a, b; };\n"
+              "bool f() {\n"
+              "    S s{};\n"
+              "    {\n"
+              "        bool b = s.a && a.b;\n"
+              "        return b;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:7]: (style) The scope of the variable 's' can be reduced. [variableScope]\n", errout_str());
     }
 
     void varScope10() {
@@ -903,7 +1146,7 @@ class TestOther : public TestFixture {
               "        foo(x++);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varScope11() {
@@ -911,21 +1154,21 @@ class TestOther : public TestFixture {
               "    int x = 0;\n"
               "    AB ab = { x, 0 };\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "    int x = 0;\n"
               "    if (a == 0) { ++x; }\n"
               "    AB ab = { x, 0 };\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "    int x = 0;\n"
               "    if (a == 0) { ++x; }\n"
               "    if (a == 1) { AB ab = { x, 0 }; }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varScope12() {
@@ -936,7 +1179,7 @@ class TestOther : public TestFixture {
               "        foo(i);\n"
               "    foo(j);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) The scope of the variable 'i' can be reduced.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) The scope of the variable 'i' can be reduced. [variableScope]\n", errout_str());
 
         check("void f(int x) {\n"
               "    int i[5];\n"
@@ -945,7 +1188,7 @@ class TestOther : public TestFixture {
               "        j = i;\n"
               "    foo(j);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    const bool b = true;\n"
@@ -953,7 +1196,7 @@ class TestOther : public TestFixture {
               "    if (x == 5)\n"
               "        foo(b);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    const bool b = x;\n"
@@ -961,7 +1204,7 @@ class TestOther : public TestFixture {
               "    if (x == 5)\n"
               "        foo(b);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varScope13() {
@@ -972,7 +1215,7 @@ class TestOther : public TestFixture {
               "        if (i++ == 42) { break; }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varScope14() {
@@ -983,7 +1226,7 @@ class TestOther : public TestFixture {
               "        for ( ; i < 10; ++i) ;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varScope15() {
@@ -994,8 +1237,8 @@ class TestOther : public TestFixture {
               "    else if(b);\n"
               "    else if(c);\n"
               "    else;\n"
-              "}", nullptr, false, false);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varScope16() {
@@ -1005,7 +1248,7 @@ class TestOther : public TestFixture {
               "        foo();\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int a = 0;\n"
@@ -1013,7 +1256,7 @@ class TestOther : public TestFixture {
               "        foo();\n"
               "    } while((++a) < 56);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int a = 0;\n"
@@ -1022,7 +1265,7 @@ class TestOther : public TestFixture {
               "        foo(a);\n"
               "    } while((++a) < 56);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int a = 0;\n"
@@ -1031,7 +1274,7 @@ class TestOther : public TestFixture {
               "        foo(a);\n"
               "    } while(z());\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) The scope of the variable 'a' can be reduced.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) The scope of the variable 'a' can be reduced. [variableScope]\n", errout_str());
     }
 
     void varScope17() {
@@ -1042,7 +1285,7 @@ class TestOther : public TestFixture {
               "        morestuff(x);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) The scope of the variable 'x' can be reduced.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) The scope of the variable 'x' can be reduced. [variableScope]\n", errout_str());
 
         check("void f() {\n"
               "    int x;\n"
@@ -1052,7 +1295,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    if (b) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) The scope of the variable 'x' can be reduced.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) The scope of the variable 'x' can be reduced. [variableScope]\n", errout_str());
     }
 
     void varScope18() {
@@ -1072,7 +1315,7 @@ class TestOther : public TestFixture {
               "        do_something(x);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) The scope of the variable 'x' can be reduced.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) The scope of the variable 'x' can be reduced. [variableScope]\n", errout_str());
 
         check("void f() {\n"
               "    short x;\n"
@@ -1091,7 +1334,7 @@ class TestOther : public TestFixture {
               "        do_something(x);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    short x;\n"
@@ -1106,7 +1349,7 @@ class TestOther : public TestFixture {
               "            break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) The scope of the variable 'x' can be reduced.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) The scope of the variable 'x' can be reduced. [variableScope]\n", errout_str());
 
         check("void f() {\n"
               "    short x;\n"
@@ -1123,7 +1366,7 @@ class TestOther : public TestFixture {
               "            break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varScope20() { // Ticket #5103 - constant variable only used in inner scope
@@ -1133,7 +1376,7 @@ class TestOther : public TestFixture {
               "  if (b > 32) b = x;\n"
               "  return b;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varScope21() { // Ticket #5382 - initializing two-dimensional array
@@ -1142,7 +1385,7 @@ class TestOther : public TestFixture {
               "    int test_array[1][1] = { { test_value } };\n"
               "    return sizeof(test_array);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varScope22() { // Ticket #5684 - "The scope of the variable 'p' can be reduced" - But it can not.
@@ -1155,7 +1398,7 @@ class TestOther : public TestFixture {
               "      ++i;\n"
               "   }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         // try to avoid an obvious false negative after applying the fix for the example above:
         check("void foo() {\n"
               "   int* p( 42 );\n"
@@ -1168,7 +1411,7 @@ class TestOther : public TestFixture {
               "      ++i;\n"
               "   }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) The scope of the variable 'p' can be reduced.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) The scope of the variable 'p' can be reduced. [variableScope]\n", errout_str());
     }
 
     void varScope23() { // #6154: Don't suggest to reduce scope if inner scope is a lambda
@@ -1178,7 +1421,7 @@ class TestOther : public TestFixture {
               "       std::cout << myCounter += aX << std::endl;\n"
               "   });\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varScope24() {
@@ -1188,7 +1431,7 @@ class TestOther : public TestFixture {
               "       r.dostuff();\n"
               "   }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) The scope of the variable 'r' can be reduced.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) The scope of the variable 'r' can be reduced. [variableScope]\n", errout_str());
 
         check("void f(Foo x) {\n"
               "   Foo foo = x;\n"
@@ -1196,7 +1439,7 @@ class TestOther : public TestFixture {
               "       foo.dostuff();\n"
               "   }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varScope25() {
@@ -1206,8 +1449,8 @@ class TestOther : public TestFixture {
               "        currtime = time(&dummy);\n"
               "        if (currtime > t) {}\n"
               "    }\n"
-              "}", "test.c");
-        ASSERT_EQUALS("[test.c:2]: (style) The scope of the variable 'currtime' can be reduced.\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:2:12]: (style) The scope of the variable 'currtime' can be reduced. [variableScope]\n", errout_str());
     }
 
     void varScope26() {
@@ -1218,140 +1461,753 @@ class TestOther : public TestFixture {
               "       if (cond2) { dostuff(key); }\n"
               "     }\n"
               "  }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void checkOldStylePointerCast(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
-
-        static Settings settings;
-        settings.addEnabled("style");
-        settings.standards.cpp = Standards::CPP03; // #5560
+    void varScope27() {
+        checkP("void f() {\n"
+               "  int x = 0;\n"
+               "#ifdef X\n"
+               "#endif\n"
+               "  if (id == ABC) { return x; }\n"
+               "}");
+        ASSERT_EQUALS("", errout_str());
 
-        // Tokenize..
-        Tokenizer tokenizerCpp(&settings, this);
-        std::istringstream istr(code);
-        tokenizerCpp.tokenize(istr, "test.cpp");
+        checkP("void f() {\n"
+               "#ifdef X\n"
+               "#endif\n"
+               "  int x = 0;\n"
+               "  if (id == ABC) { return x; }\n"
+               "}");
+        ASSERT_EQUALS("[test.cpp:4:7]: (style) The scope of the variable 'x' can be reduced. [variableScope]\n", errout_str());
+    }
 
-        CheckOther checkOtherCpp(&tokenizerCpp, &settings, this);
-        checkOtherCpp.warningOldStylePointerCast();
+    void varScope28() {
+        check("void f() {\n" // #10527
+              "    int i{};\n"
+              "    if (double d = g(i); d == 1.0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void oldStylePointerCast() {
-        checkOldStylePointerCast("class Base;\n"
-                                 "void foo()\n"
-                                 "{\n"
-                                 "    Base * b = (Base *) derived;\n"
-                                 "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) C-style pointer casting\n", errout.str());
+    void varScope29() { // #10888
+        check("enum E { E0 };\n"
+              "struct S { int i; };\n"
+              "void f(int b) {\n"
+              "    enum E e;\n"
+              "    struct S s;\n"
+              "    if (b) {\n"
+              "        e = E0;\n"
+              "        s.i = 0;\n"
+              "        g(e, s);\n"
+              "    }\n"
+              "}\n", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:4:12]: (style) The scope of the variable 'e' can be reduced. [variableScope]\n"
+                      "[test.c:5:14]: (style) The scope of the variable 's' can be reduced. [variableScope]\n",
+                      errout_str());
 
-        checkOldStylePointerCast("class Base;\n"
-                                 "void foo()\n"
-                                 "{\n"
-                                 "    Base * b = (const Base *) derived;\n"
-                                 "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) C-style pointer casting\n", errout.str());
+        check("void f(bool b) {\n"
+              "    std::string s;\n"
+              "    if (b) {\n"
+              "        s = \"abc\";\n"
+              "        g(s);\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) The scope of the variable 's' can be reduced. [variableScope]\n", errout_str());
 
-        checkOldStylePointerCast("class Base;\n"
-                                 "void foo()\n"
-                                 "{\n"
-                                 "    Base * b = (const Base * const) derived;\n"
-                                 "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) C-style pointer casting\n", errout.str());
+        check("auto foo(std::vector<int>& vec, bool flag) {\n"
+              "    std::vector<int> dummy;\n"
+              "    std::vector<int>::iterator iter;\n"
+              "    if (flag)\n"
+              "        iter = vec.begin();\n"
+              "    else {\n"
+              "        dummy.push_back(42);\n"
+              "        iter = dummy.begin();\n"
+              "    }\n"
+              "    return *iter;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:1:28]: (style) Parameter 'vec' can be declared as reference to const [constParameterReference]\n", errout_str());
 
-        checkOldStylePointerCast("class Base;\n"
-                                 "void foo()\n"
-                                 "{\n"
-                                 "    Base * b = (volatile Base *) derived;\n"
-                                 "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) C-style pointer casting\n", errout.str());
+        check("auto& foo(std::vector<int>& vec, bool flag) {\n"
+              "    std::vector<int> dummy;\n"
+              "    std::vector<int>::iterator iter;\n"
+              "    if (flag)\n"
+              "        iter = vec.begin();\n"
+              "    else {\n"
+              "        dummy.push_back(42);\n"
+              "        iter = dummy.begin();\n"
+              "    }\n"
+              "    return *iter;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        checkOldStylePointerCast("class Base;\n"
-                                 "void foo()\n"
-                                 "{\n"
-                                 "    Base * b = (volatile Base * const) derived;\n"
-                                 "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) C-style pointer casting\n", errout.str());
+    void varScope30() { // #8541
+        check("bool f(std::vector<int>& v, int i) {\n"
+              "    int n = 0;\n"
+              "    bool b = false;\n"
+              "    std::for_each(v.begin(), v.end(), [&](int j) {\n"
+              "        if (j == i) {\n"
+              "            ++n;\n"
+              "            if (n > 5)\n"
+              "                b = true;\n"
+              "        }\n"
+              "    });\n"
+              "    return b;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        checkOldStylePointerCast("class Base;\n"
-                                 "void foo()\n"
-                                 "{\n"
-                                 "    Base * b = (const volatile Base *) derived;\n"
-                                 "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) C-style pointer casting\n", errout.str());
+    void varScope31() { // #11099
+        check("bool g(std::vector<int>&);\n"
+              "void h(std::vector<int>);\n"
+              "void f0(std::vector<int> v) {\n"
+              "    std::vector<int> w{ v };\n"
+              "    bool b = g(v);\n"
+              "    if (b)\n"
+              "        h(w);\n"
+              "    h(v);\n"
+              "}\n"
+              "void f1(std::vector<int> v) {\n"
+              "    std::vector<int> w{ v.begin(), v.end() };\n"
+              "    bool b = g(v);\n"
+              "    if (b)\n"
+              "        h(w);\n"
+              "    h(v);\n"
+              "}\n"
+              "void f2(std::vector<int> v) {\n"
+              "    std::vector<int> w{ 10, 0, std::allocator<int>() };\n" // FN
+              "    bool b = g(v);\n"
+              "    if (b)\n"
+              "        h(w);\n"
+              "    h(v);\n"
+              "}\n"
+              "void f3(std::vector<int> v) {\n"
+              "    std::vector<int> w{ 10, 0 };\n" // warn
+              "    bool b = g(v);\n"
+              "    if (b)\n"
+              "        h(w);\n"
+              "    h(v);\n"
+              "}\n"
+              "void f4(std::vector<int> v) {\n"
+              "    std::vector<int> w{ 10 };\n" // warn
+              "    bool b = g(v);\n"
+              "    if (b)\n"
+              "        h(w);\n"
+              "    h(v);\n"
+              "}\n"
+              "void f5(std::vector<int> v) {\n"
+              "    std::vector<int> w(v);\n"
+              "    bool b = g(v);\n"
+              "    if (b)\n"
+              "        h(w);\n"
+              "    h(v);\n"
+              "}\n"
+              "void f6(std::vector<int> v) {\n"
+              "    std::vector<int> w(v.begin(), v.end());\n"
+              "    bool b = g(v);\n"
+              "    if (b)\n"
+              "        h(w);\n"
+              "    h(v);\n"
+              "}\n"
+              "void f7(std::vector<int> v) {\n"
+              "    std::vector<int> w(10, 0, std::allocator<int>);\n" // FN
+              "    bool b = g(v);\n"
+              "    if (b)\n"
+              "        h(w);\n"
+              "    h(v);\n"
+              "}\n"
+              "void f8(std::vector<int> v) {\n"
+              "    std::vector<int> w(10, 0);\n" // warn
+              "    bool b = g(v);\n"
+              "    if (b)\n"
+              "        h(w);\n"
+              "    h(v);\n"
+              "}\n"
+              "void f9(std::vector<int> v) {\n"
+              "    std::vector<int> w(10);\n" // warn
+              "    bool b = g(v);\n"
+              "    if (b)\n"
+              "        h(w);\n"
+              "    h(v);\n"
+              "}\n"
+              "void f10(std::vector<int> v) {\n"
+              "    std::vector<int> w{};\n" // warn
+              "    bool b = g(v);\n"
+              "    if (b)\n"
+              "        h(w);\n"
+              "    h(v);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:25:22]: (style) The scope of the variable 'w' can be reduced. [variableScope]\n"
+                      "[test.cpp:32:22]: (style) The scope of the variable 'w' can be reduced. [variableScope]\n"
+                      "[test.cpp:60:22]: (style) The scope of the variable 'w' can be reduced. [variableScope]\n"
+                      "[test.cpp:67:22]: (style) The scope of the variable 'w' can be reduced. [variableScope]\n"
+                      "[test.cpp:74:22]: (style) The scope of the variable 'w' can be reduced. [variableScope]\n",
+                      errout_str());
+    }
+
+    void varScope32() { // #11441
+        check("template <class F>\n"
+              "std::vector<int> g(F, const std::vector<int>&);\n"
+              "void f(const std::vector<int>&v) {\n"
+              "    std::vector<int> w;\n"
+              "    for (auto x : v)\n"
+              "        w = g([&]() { x; }, w);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:23]: (warning) Unused variable value 'x' [constStatement]\n", errout_str());
+    }
 
-        checkOldStylePointerCast("class Base;\n"
-                                 "void foo()\n"
-                                 "{\n"
-                                 "    Base * b = (const volatile Base * const) derived;\n"
-                                 "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) C-style pointer casting\n", errout.str());
+    void varScope33() { // #11131
+        check("struct S {\n"
+              "    const std::string& getStr() const;\n"
+              "    void mutate();\n"
+              "    bool getB() const;\n"
+              "};\n"
+              "void g(S& s) {\n"
+              "    std::string str = s.getStr();\n"
+              "    s.mutate();\n"
+              "    if (s.getB()) {\n"
+              "        if (str == \"abc\") {}\n"
+              "    }\n"
+              "}\n"
+              "void g(char* s, bool b) {\n"
+              "    int i = strlen(s);\n"
+              "    s[0] = '\\0';\n"
+              "    if (b) {\n"
+              "        if (i == 5) {}\n"
+              "    }\n"
+              "}\n"
+              "void f(const S& s) {\n"
+              "    std::string str = s.getStr();\n"
+              "    std::string str2{ s.getStr() };\n"
+              "    std::string str3(s.getStr());\n"
+              "    if (s.getB()) {\n"
+              "        if (str == \"abc\") {}\n"
+              "        if (str2 == \"abc\") {}\n"
+              "        if (str3 == \"abc\") {}\n"
+              "    }\n"
+              "}\n"
+              "void f(const char* s, bool b) {\n"
+              "    int i = strlen(s);\n"
+              "    if (b) {\n"
+              "        if (i == 5) {}\n"
+              "    }\n"
+              "}\n"
+              "void f(int j, bool b) {\n"
+              "    int k = j;\n"
+              "    if (b) {\n"
+              "        if (k == 5) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:21:17]: (style) The scope of the variable 'str' can be reduced. [variableScope]\n"
+                      "[test.cpp:22:17]: (style) The scope of the variable 'str2' can be reduced. [variableScope]\n"
+                      "[test.cpp:23:17]: (style) The scope of the variable 'str3' can be reduced. [variableScope]\n"
+                      "[test.cpp:31:9]: (style) The scope of the variable 'i' can be reduced. [variableScope]\n"
+                      "[test.cpp:37:9]: (style) The scope of the variable 'k' can be reduced. [variableScope]\n",
+                      errout_str());
+    }
 
-        checkOldStylePointerCast("class Base;\n"
-                                 "void foo()\n"
-                                 "{\n"
-                                 "    Base * b = (const Base *) ( new Derived() );\n"
-                                 "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) C-style pointer casting\n", errout.str());
+    void varScope34() { // #11742
+        check("void f() {\n"
+              "    bool b = false;\n"
+              "    int i = 1;\n"
+              "    for (int k = 0; k < 20; ++k) {\n"
+              "        b = !b;\n"
+              "        if (b)\n"
+              "            i++;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        checkOldStylePointerCast("class Base;\n"
-                                 "void foo()\n"
-                                 "{\n"
-                                 "    Base * b = (const Base *) new Derived();\n"
-                                 "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) C-style pointer casting\n", errout.str());
+    void varScope35() { // #11845
+        check("void f(int err, const char* src) {\n"
+              "    const char* msg = \"Success\";\n"
+              "    char buf[42];\n"
+              "    if (err != 0)\n"
+              "        msg = strcpy(buf, src);\n"
+              "    printf(\"%d: %s\\n\", err, msg);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("char* g(char* dst, const char* src);\n"
+              "void f(int err, const char* src) {\n"
+              "    const char* msg = \"Success\";\n"
+              "    char buf[42];\n"
+              "    if (err != 0)\n"
+              "        msg = g(buf, src);\n"
+              "    printf(\"%d: %s\\n\", err, msg);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("char* g(char* dst, const char* src);\n"
+              "void f(int err, const char* src) {\n"
+              "    const char* msg = \"Success\";\n"
+              "    char buf[42];\n"
+              "    if (err != 0)\n"
+              "        g(buf, src);\n"
+              "    printf(\"%d: %s\\n\", err, msg);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: (style) The scope of the variable 'buf' can be reduced. [variableScope]\n", errout_str());
+    }
 
-        checkOldStylePointerCast("class Base;\n"
-                                 "void foo()\n"
-                                 "{\n"
-                                 "    Base * b = (const Base *) new short[10];\n"
-                                 "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) C-style pointer casting\n", errout.str());
+    void varScope36() {
+        // #12158
+        check("void f( uint32_t value ) {\n"
+              "    uint32_t i = 0U;\n"
+              "    if ( value > 100U ) { }\n"
+              "    else if( value > 50U ) { }\n"
+              "    else{\n"
+              "         for( i = 0U; i < 5U; i++ ) {}\n"
+              "    }\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:2:14]: (style) The scope of the variable 'i' can be reduced. [variableScope]\n", errout_str());
+    }
 
-        checkOldStylePointerCast("class B;\n"
-                                 "class A\n"
-                                 "{\n"
-                                 "  virtual void abc(B *) const = 0;\n"
-                                 "}");
-        ASSERT_EQUALS("", errout.str());
+    void varScope37() {
+        // #12158
+        check("void f( uint32_t value ) {\n"
+              "    uint32_t i = 0U;\n"
+              "    if ( value > 100U ) { }\n"
+              "    else {\n"
+              "        if( value > 50U ) { }\n"
+              "        else{\n"
+              "            for( i = 0U; i < 5U; i++ ) {}\n"
+              "        }\n"
+              "    }\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:2:14]: (style) The scope of the variable 'i' can be reduced. [variableScope]\n", errout_str());
+    }
 
-        checkOldStylePointerCast("class B;\n"
-                                 "class A\n"
-                                 "{\n"
-                                 "  virtual void abc(const B *) const = 0;\n"
-                                 "}");
-        ASSERT_EQUALS("", errout.str());
+    void varScope38() {
+        checkP("bool dostuff();\n" // #12519
+               "#define DOSTUFF(c) if (c < 5) { if (c) b = dostuff(); }\n"
+               "#define DOSTUFFEX(c) { bool b = false; DOSTUFF(c); }\n"
+               "void f(int a) {\n"
+               "    DOSTUFFEX(a);\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        // #3630
-        checkOldStylePointerCast("class SomeType;\n"
-                                 "class X : public Base {\n"
-                                 "    X() : Base((SomeType*)7) {}\n"
-                                 "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style) C-style pointer casting\n", errout.str());
+    void varScope39() {
+        check("struct S {\n" // #12405
+              "    void f(const std::string&) const;\n"
+              "    const int* g(std::string&) const;\n"
+              "};\n"
+              "void h(int);\n"
+              "void S::f(const std::string& s) const {\n"
+              "    std::string n = s;\n"
+              "    const int* a = g(n);\n"
+              "    if (n == \"abc\") {\n"
+              "        h(a[0]);\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void varScope40() {
+        checkP("#define NUM (-999.9)\n" // #8862
+               "double f(int i) {\n"
+               "    double a = NUM;\n"
+               "    double b = -NUM;\n"
+               "    double c = -1.0 * NUM;\n"
+               "    if (i == 1) {\n"
+               "        return a;\n"
+               "    }\n"
+               "    if (i == 2) {\n"
+               "        return b;\n"
+               "    }\n"
+               "    if (i == 3) {\n"
+               "        return c;\n"
+               "    }\n"
+               "    return 0.0;\n"
+               "}\n");
+        ASSERT_EQUALS("[test.cpp:3:12]: (style) The scope of the variable 'a' can be reduced. [variableScope]\n"
+                      "[test.cpp:4:12]: (style) The scope of the variable 'b' can be reduced. [variableScope]\n"
+                      "[test.cpp:5:12]: (style) The scope of the variable 'c' can be reduced. [variableScope]\n",
+                      errout_str());
+
+        check("struct S { int a; };\n" // #12618
+              "int f(const S* s, int i) {\n"
+              "    int x = s->a;\n"
+              "    const int b[] = { 1, 2, 3 };\n"
+              "    int y = b[1];\n"
+              "    if (i)\n"
+              "        return x + y;\n"
+              "    return 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) The scope of the variable 'x' can be reduced. [variableScope]\n"
+                      "[test.cpp:5:9]: (style) The scope of the variable 'y' can be reduced. [variableScope]\n",
+                      errout_str());
+    }
 
-        checkOldStylePointerCast("class SomeType;\n"
-                                 "class X : public Base {\n"
-                                 "    X() : Base((SomeType*)var) {}\n"
-                                 "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style) C-style pointer casting\n", errout.str());
+    void varScope41() {    // #11845
+        check("void get_errmsg(const char **msg, char *buf, size_t bufsiz, int err);\n"
+              "void test(int err)\n"
+              "{\n"
+              "    const char *msg = \"Success\";\n"
+              "    char buf[42];\n"
+              "    if (err != 0)\n"
+              "        get_errmsg(&msg, buf, sizeof(buf), err);\n"
+              "    printf(\"%d: %s\\n\", err, msg);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
 
-        checkOldStylePointerCast("class SomeType;\n"
-                                 "class X : public Base {\n"
-                                 "    X() : Base((SomeType*)0) {}\n"
-                                 "};");
-        ASSERT_EQUALS("", errout.str());
+        check("void get_errmsg(char *buf, size_t bufsiz, int err);\n"
+              "void test(int err)\n"
+              "{\n"
+              "    const char *msg = \"Success\";\n"
+              "    char buf[42];\n"
+              "    if (err != 0)\n"
+              "        get_errmsg(buf, sizeof(buf), err);\n"
+              "    printf(\"%d: %s\\n\", err, msg);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:10]: (style) The scope of the variable 'buf' can be reduced. [variableScope]\n", errout_str());
+    }
 
-        // #5560
-        checkOldStylePointerCast("class C;\n"
+    void varScope42() {
+        check("void f(const char **, char *);\n"
+              "void g(int e) {\n"
+              "    const char *msg = \"Something\";\n"
+              "    char buf[42];\n"
+              "    if (e != 0)\n"
+              "        f(&msg, buf);\n"
+              "    printf(\"result: %s\\n\", msg);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(char *, char *);\n"
+              "void g(int e) {\n"
+              "    char msg [42] = \"Something\";\n"
+              "    char buf[42];\n"
+              "    if (e != 0)\n"
+              "        f(msg, buf);\n"
+              "    printf(\"result: %s\\n\", msg);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const char *, char *);\n"
+              "void g(int e) {\n"
+              "    const char *msg = \"Something\";\n"
+              "    char buf[42];\n"
+              "    if (e != 0)\n"
+              "        f(msg, buf);\n"
+              "    printf(\"result: %s\\n\", msg);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: (style) The scope of the variable 'buf' can be reduced. [variableScope]\n", errout_str());
+
+        check("void f(int **, char *);\n"
+              "void g(int e) {\n"
+              "    int *msg = calloc(0, sizeof(*msg));\n"
+              "    char buf[42];\n"
+              "    if (e != 0)\n"
+              "        f(&msg, buf);\n"
+              "    printf(\"result: %d\\n\", *msg);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: (style) The scope of the variable 'buf' can be reduced. [variableScope]\n", errout_str());
+
+        check("void f(const char *&, const char *&);\n"
+              "void g(int e) {\n"
+              "    const char *msg = \"Something\";\n"
+              "    char *buf = malloc(42);\n"
+              "    if (e != 0)\n"
+              "        f(msg, buf);\n"
+              "    printf(\"result: %d\\n\", msg);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void g(const char* format, ...);\n"
+              "void f(bool b) {\n"
+              "    const char* s = \"abc\";\n"
+              "    if (b)\n"
+              "       g(\"%d %s\", 1, s);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:17]: (style) The scope of the variable 's' can be reduced. [variableScope]\n", errout_str());
+    }
+
+    void varScope43() {
+        check("struct S { int a, b; };\n" // #13838
+              "int f(S s) {\n"
+              "    auto& [x, y] = s;\n"
+              "    if (x < 5) {\n"
+              "        return y;\n"
+              "    }\n"
+              "    return 0;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { int a; };\n"
+              "int f(S s) {\n"
+              "    auto& [x] = s;\n"
+              "    if (y) {\n"
+              "        return x;\n"
+              "    }\n"
+              "    return 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:12]: (style) The scope of the variable 'x' can be reduced. [variableScope]\n", errout_str());
+    }
+
+    void varScope44() { // #14496
+        check("char* f() {\n"
+              "    char* p = nullptr;\n"
+              "    {\n"
+              "        p = strdup(\"abc\");\n"
+              "        if (p) {\n"
+              "            return p;\n"
+              "        }\n"
+              "    }\n"
+              "    return nullptr;\n"
+              "}\n"
+              "char* g() {\n"
+              "    char* q = NULL;\n"
+              "    {\n"
+              "        q = strdup(\"abc\");\n"
+              "        if (q) {\n"
+              "            return q;\n"
+              "        }\n"
+              "    }\n"
+              "    return nullptr;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) The scope of the variable 'p' can be reduced. [variableScope]\n"
+                      "[test.cpp:12:11]: (style) The scope of the variable 'q' can be reduced. [variableScope]\n",
+                      errout_str());
+    }
+
+    void varScope45() {
+        check("void g(int x, int y) {\n" // #14497
+              "    int a = x, b = y;\n"
+              "    if (a) {}\n"
+              "    else {\n"
+              "        if (b) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:16]: (style) The scope of the variable 'b' can be reduced. [variableScope]\n", errout_str());
+    }
+
+    void varScope46() {
+        check("void f() {\n" // #7091
+              "    int y1;\n"
+              "    for (int i = 0; i < 3; ++i) {\n"
+              "        for(int j = 0; j < 3; ++j) {\n"
+              "                y1 = 2 * 1;\n"
+              "                y1 += 1;\n"
+              "        }\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) The scope of the variable 'y1' can be reduced. [variableScope]\n",
+                      errout_str());
+
+        check("bool f() {\n"
+              "bool b = false;\n"
+              "do {\n"
+              "    switch (g()) {\n"
+              "        case 0:\n"
+              "            b = true;\n"
+              "            break;\n"
+              "        case 1:\n"
+              "            return b;\n"
+              "            break;\n"
+              "        default:\n"
+              "            break;\n"
+              "    }\n"
+              "}\n"
+              "while (true);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    int y1 = 0;\n"
+              "    for (int i = 0; i < 3; ++i) {\n"
+              "        for(int j = 0; j < 3; ++j) {\n"
+              "                y1 = y1 + 1;\n"
+              "                dostuff(y1);\n"
+              "        }\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int& r) {\n" // #14566
+              "    int i = 0;\n"
+              "    while (g()) {\n"
+              "        {\n"
+              "            if (g()) {\n"
+              "                i = 0;"
+              "                std::swap(i, r);\n"
+              "            }\n"
+              "        }\n"
+              "    }\n"
+              "    use(i);"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+#define checkOldStylePointerCast(...) checkOldStylePointerCast_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkOldStylePointerCast_(const char* file, int line, const char (&code)[size], Standards::cppstd_t std = Standards::CPPLatest) {
+
+        const Settings settings = settingsBuilder().severity(Severity::warning).severity(Severity::style).cpp(std).build();
+
+        // Tokenize..
+        SimpleTokenizer tokenizerCpp(settings, *this);
+        ASSERT_LOC(tokenizerCpp.tokenize(code), file, line);
+
+        CheckOther checkOtherCpp(&tokenizerCpp, &settings, this);
+        checkOtherCpp.warningOldStylePointerCast();
+        checkOtherCpp.warningDangerousTypeCast();
+    }
+
+    void oldStylePointerCast() {
+        checkOldStylePointerCast("class Base{};\n"
+                                 "class Derived: public Base {};\n"
+                                 "void foo(Base* base)\n"
+                                 "{\n"
+                                 "    Derived * d = (Derived *) base;\n"
+                                 "}");
+        ASSERT_EQUALS("[test.cpp:5:19]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
+
+        checkOldStylePointerCast("class Base{};\n"
+                                 "class Derived: public Base {};\n"
+                                 "void foo(Derived* derived)\n"
+                                 "{\n"
+                                 "    Base * b = (Base *) derived;\n" // <- cast from derived to base is safe => cstyleCast
+                                 "}");
+        ASSERT_EQUALS("[test.cpp:5:16]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
+
+        checkOldStylePointerCast("void foo(Base* base)\n"
+                                 "{\n"
+                                 "    Derived * d = (Derived *) base;\n"
+                                 "}");
+        ASSERT_EQUALS("[test.cpp:3:19]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
+
+        checkOldStylePointerCast("class Base{};\n"
+                                 "class Derived: public Base {};\n"
+                                 "void foo(Base* base)\n"
+                                 "{\n"
+                                 "    Derived * d = (const Derived *) base;\n"
+                                 "}");
+        ASSERT_EQUALS("[test.cpp:5:19]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
+
+        checkOldStylePointerCast("class Base{};\n"
+                                 "class Derived: public Base {};\n"
+                                 "void foo()\n"
+                                 "{\n"
+                                 "    Derived * d = (const Derived *) ( new Base() );\n"
+                                 "}");
+        ASSERT_EQUALS("[test.cpp:5:19]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
+
+        checkOldStylePointerCast("class Base{};\n"
+                                 "class Derived: public Base {};\n"
+                                 "void foo()\n"
+                                 "{\n"
+                                 "    Derived * d = (const Derived *) new Base();\n"
+                                 "}");
+        ASSERT_EQUALS("[test.cpp:5:19]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
+
+        checkOldStylePointerCast("class Base{};\n"
+                                 "void foo()\n"
+                                 "{\n"
+                                 "    Base * b = (Base *) new short[10];\n"
+                                 "}");
+        ASSERT_EQUALS("[test.cpp:4:16]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
+
+        checkOldStylePointerCast("class Base;\n"
+                                 "void foo()\n"
+                                 "{\n"
+                                 "    Base * b = (volatile Base *) derived;\n"
+                                 "}");
+        ASSERT_EQUALS("[test.cpp:4:16]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
+
+        checkOldStylePointerCast("class Base;\n"
+                                 "void foo()\n"
+                                 "{\n"
+                                 "    Base * b = (volatile Base * const) derived;\n"
+                                 "}");
+        ASSERT_EQUALS("[test.cpp:4:16]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
+
+        checkOldStylePointerCast("class Base;\n"
+                                 "void foo()\n"
+                                 "{\n"
+                                 "    Base * b = (const volatile Base *) derived;\n"
+                                 "}");
+        ASSERT_EQUALS("[test.cpp:4:16]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
+
+        checkOldStylePointerCast("class Base;\n"
+                                 "void foo()\n"
+                                 "{\n"
+                                 "    Base * b = (const volatile Base * const) derived;\n"
+                                 "}");
+        ASSERT_EQUALS("[test.cpp:4:16]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
+
+        checkOldStylePointerCast("class Base;\n"
+                                 "void foo()\n"
+                                 "{\n"
+                                 "    Base * b = (const Base *) ( new Derived() );\n"
+                                 "}");
+        ASSERT_EQUALS("[test.cpp:4:16]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
+
+        checkOldStylePointerCast("class Base;\n"
+                                 "void foo()\n"
+                                 "{\n"
+                                 "    Base * b = (const Base *) new Derived();\n"
+                                 "}");
+        ASSERT_EQUALS("[test.cpp:4:16]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
+
+        checkOldStylePointerCast("class Base;\n"
+                                 "void foo()\n"
+                                 "{\n"
+                                 "    Base * b = (const Base *) new short[10];\n"
+                                 "}");
+        ASSERT_EQUALS("[test.cpp:4:16]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
+
+        checkOldStylePointerCast("class B;\n"
+                                 "class A\n"
+                                 "{\n"
+                                 "  virtual void abc(B *) const = 0;\n"
+                                 "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkOldStylePointerCast("class B;\n"
+                                 "class A\n"
+                                 "{\n"
+                                 "  virtual void abc(const B *) const = 0;\n"
+                                 "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #3630
+        checkOldStylePointerCast("class SomeType{};\n"
+                                 "class X : public Base {\n"
+                                 "    X() : Base((SomeType*)7) {}\n" // <- intToPointerCast
+                                 "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkOldStylePointerCast("class SomeType{};\n"
+                                 "class X : public Base {\n"
+                                 "    X() : Base((SomeType*)0x7000) {}\n" // <- it's common in embedded code to cast address
+                                 "};");
+        ASSERT_EQUALS("", errout_str());
+
+        checkOldStylePointerCast("class SomeType;\n"
+                                 "class X : public Base {\n"
+                                 "    X() : Base((SomeType*)var) {}\n"
+                                 "};");
+        ASSERT_EQUALS("[test.cpp:3:16]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
+
+        checkOldStylePointerCast("class SomeType;\n"
+                                 "class X : public Base {\n"
+                                 "    X() : Base((SomeType*)0) {}\n"
+                                 "};");
+        ASSERT_EQUALS("", errout_str());
+
+        // #5560
+        checkOldStylePointerCast("class C;\n"
                                  "\n"
                                  "class B\n"
                                  "{ virtual G* createGui(S*, C*) const = 0; };\n"
                                  "\n"
                                  "class MS : public M\n"
-                                 "{ virtual void addController(C*) override {} };");
-        ASSERT_EQUALS("", errout.str());
+                                 "{ virtual void addController(C*) override {} };", Standards::CPP03);
+        ASSERT_EQUALS("", errout_str());
 
         // #6164
         checkOldStylePointerCast("class Base {};\n"
@@ -1360,23 +2216,166 @@ class TestOther : public TestFixture {
                                  "  std::vector<Base*> v;\n"
                                  "  v.push_back((Base*)new Derived);\n"
                                  "}");
-        ASSERT_EQUALS("[test.cpp:5]: (style) C-style pointer casting\n", errout.str());
+        // FIXME write a dangerousTypeCast warning instead
+        ASSERT_EQUALS("[test.cpp:5:15]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
+
+        // #7709
+        checkOldStylePointerCast("typedef struct S S;\n"
+                                 "typedef struct S SS;\n"
+                                 "typedef class C C;\n"
+                                 "typedef long LONG;\n"
+                                 "typedef long* LONGP;\n"
+                                 "struct T {};\n"
+                                 "typedef struct T TT;\n"
+                                 "typedef struct T2 {} TT2;\n"
+                                 "void f(int* i) {\n"
+                                 "    S* s = (S*)i;\n"
+                                 "    SS* ss = (SS*)i;\n"
+                                 "    struct S2* s2 = (struct S2*)i;\n"
+                                 "    C* c = (C*)i;\n"
+                                 "    class C2* c2 = (class C2*)i;\n"
+                                 "    long* l = (long*)i;\n"
+                                 "    LONG* l2 = (LONG*)i;\n"
+                                 "    LONGP l3 = (LONGP)i;\n"
+                                 "    TT* tt = (TT*)i;\n"
+                                 "    TT2* tt2 = (TT2*)i;\n"
+                                 "}\n");
+        ASSERT_EQUALS("[test.cpp:10:12]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n"
+                      "[test.cpp:11:14]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n"
+                      "[test.cpp:12:21]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n"
+                      "[test.cpp:13:12]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n"
+                      "[test.cpp:14:20]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n"
+                      "[test.cpp:15:15]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n"
+                      "[test.cpp:16:16]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n"
+                      "[test.cpp:17:16]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n"
+                      "[test.cpp:18:14]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n"
+                      "[test.cpp:19:16]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n",
+                      errout_str());
+
+        // #8649
+        checkOldStylePointerCast("struct S {};\n"
+                                 "void g(S*& s);\n"
+                                 "void f(uintptr_t i) {\n"
+                                 "    g((S*&)i);\n"
+                                 "    S*& r = (S*&)i;\n"
+                                 "}\n");
+        ASSERT_EQUALS("[test.cpp:4:7]: (style) C-style pointer casting [cstyleCast]\n"
+                      "[test.cpp:5:13]: (style) C-style pointer casting [cstyleCast]\n",
+                      errout_str());
+
+        checkOldStylePointerCast("struct S {};\n"
+                                 "void g(S*& s);\n"
+                                 "void f(uint8_t i) {\n"
+                                 "    g((S*&)i);\n"
+                                 "    S*& r = (S*&)i;\n"
+                                 "}\n");
+        // TODO: these conversions are dangerous, but it's a different issue not covered by cstyleCast. A separate checker can be added which is executed for both C and C++ code.
+        // clang says: 1.cpp:5:18: warning: cast to 'unsigned char *' from smaller integer type 'uint8_t' (aka 'unsigned char') [-Wint-to-pointer-cast]
+        ASSERT_EQUALS("[test.cpp:4:7]: (style) C-style pointer casting [cstyleCast]\n"
+                      "[test.cpp:5:13]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
+
+        // #10823
+        checkOldStylePointerCast("void f(void* p) {\n"
+                                 "    auto h = reinterpret_cast<void (STDAPICALLTYPE*)(int)>(p);\n"
+                                 "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #5210
+        checkOldStylePointerCast("class Base {};\n"
+                                 "class Derived: public Base {};\n"
+                                 "void f(Base** b1, Base*** b2) {\n"
+                                 "    Derived** p1 = (Derived**)b1;\n"
+                                 "    Derived*** p2 = (Derived***)b2;\n"
+                                 "}\n");
+        ASSERT_EQUALS("[test.cpp:4:20]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n"
+                      "[test.cpp:5:21]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n",
+                      errout_str());
+
+        // #12446
+        checkOldStylePointerCast("namespace N { struct S {}; }\n"
+                                 "union U {\n"
+                                 "    int i;\n"
+                                 "    char c[4];\n"
+                                 "};\n"
+                                 "void f(void* p) {\n"
+                                 "    auto ps = (N::S*)p;\n"
+                                 "    auto pu = (union U*)p;\n"
+                                 "    auto pv = (std::vector<int>*)(p);\n"
+                                 "}\n");
+        ASSERT_EQUALS("[test.cpp:7:15]: (style) C-style pointer casting [cstyleCast]\n"
+                      "[test.cpp:8:15]: (style) C-style pointer casting [cstyleCast]\n"
+                      "[test.cpp:9:15]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
+
+        // #12447
+        checkOldStylePointerCast("class Base {};\n"
+                                 "class Derived: public Base {};\n"
+                                 "void f(const Base& base) {\n"
+                                 "  d = (const Derived&)base;\n"
+                                 "}\n");
+        ASSERT_EQUALS("[test.cpp:4:7]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
+
+        // #11430
+        checkOldStylePointerCast("struct B {\n"
+                                 "    float* data() const;\n"
+                                 "};\n"
+                                 "namespace N {\n"
+                                 "    bool f(float* v);\n"
+                                 "}\n"
+                                 "bool g(B& b) {\n"
+                                 "    using float_ptr = float*;\n"
+                                 "    return N::f(float_ptr(b.data()));\n" // <- the cast is safe
+                                 "}\n");
+        ASSERT_EQUALS("[test.cpp:9:17]: (style) C-style pointer casting [cstyleCast]\n", errout_str());
+    }
+
+#define checkIntToPointerCast(...) checkIntToPointerCast_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkIntToPointerCast_(const char* file, int line, const char (&code)[size]) {
+
+        const Settings settings = settingsBuilder().severity(Severity::portability).build();
+
+        // Tokenize..
+        SimpleTokenizer tokenizerCpp(settings, *this);
+        ASSERT_LOC(tokenizerCpp.tokenize(code), file, line);
+
+        CheckOther checkOtherCpp(&tokenizerCpp, &settings, this);
+        checkOtherCpp.warningIntToPointerCast();
+    }
+
+    void intToPointerCast() {
+        // #3630
+        checkIntToPointerCast("uint8_t* ptr = (uint8_t*)7;");
+        ASSERT_EQUALS("[test.cpp:1:16]: (portability) Casting non-zero decimal integer literal to pointer. [intToPointerCast]\n", errout_str());
+
+        checkIntToPointerCast("void* ptr = (void*)7;");
+        ASSERT_EQUALS("[test.cpp:1:13]: (portability) Casting non-zero decimal integer literal to pointer. [intToPointerCast]\n", errout_str());
+
+        checkIntToPointerCast("uint8_t* ptr = (uint8_t*)0;");
+        ASSERT_EQUALS("", errout_str());
+
+        checkIntToPointerCast("uint8_t* ptr = (uint8_t*)0x7000;"); // <- it's common in embedded code to cast address
+        ASSERT_EQUALS("", errout_str());
+
+        checkIntToPointerCast("struct S { int i; };\n" // #13886, don't crash
+                              "int f() { return sizeof(((struct S*)0)->i); }");
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void checkInvalidPointerCast(const char code[], bool portability = true, bool inconclusive = false) {
-        // Clear the error buffer..
-        errout.str("");
+    struct CheckInvalidPointerCastOptions
+    {
+        bool portability = true;
+        bool inconclusive = false;
+    };
 
-        Settings settings;
-        settings.addEnabled("warning");
-        if (portability)
-            settings.addEnabled("portability");
-        settings.inconclusive = inconclusive;
+#define checkInvalidPointerCast(...) checkInvalidPointerCast_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkInvalidPointerCast_(const char* file, int line, const char (&code)[size], const CheckInvalidPointerCastOptions& opt = make_default_obj{}) {
+        /*const*/ Settings settings = settingsBuilder().severity(Severity::warning).severity(Severity::portability, opt.portability).certainty(Certainty::inconclusive, opt.inconclusive).build();
+        settings.platform.defaultSign = 's';
 
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         CheckOther checkOtherCpp(&tokenizer, &settings, this);
         checkOtherCpp.invalidPointerCast();
@@ -1389,66 +2388,66 @@ class TestOther : public TestFixture {
                                 "    delete [] (double*)f;\n"
                                 "    delete [] (long double const*)(new float[10]);\n"
                                 "}");
-        ASSERT_EQUALS("[test.cpp:3]: (portability) Casting between float* and double* which have an incompatible binary data representation.\n"
-                      "[test.cpp:4]: (portability) Casting between float* and const long double* which have an incompatible binary data representation.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:15]: (portability) Casting between float * and double * which have an incompatible binary data representation. [invalidPointerCast]\n"
+                      "[test.cpp:4:15]: (portability) Casting between float * and const long double * which have an incompatible binary data representation. [invalidPointerCast]\n", errout_str());
 
         checkInvalidPointerCast("void test(const float* f) {\n"
                                 "    double *d = (double*)f;\n"
                                 "}");
-        ASSERT_EQUALS("[test.cpp:2]: (portability) Casting between const float* and double* which have an incompatible binary data representation.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (portability) Casting between const float * and double * which have an incompatible binary data representation. [invalidPointerCast]\n", errout_str());
 
         checkInvalidPointerCast("void test(double* d1) {\n"
                                 "    long double *ld = (long double*)d1;\n"
                                 "    double *d2 = (double*)ld;\n"
                                 "}");
-        ASSERT_EQUALS("[test.cpp:2]: (portability) Casting between double* and long double* which have an incompatible binary data representation.\n"
-                      "[test.cpp:3]: (portability) Casting between long double* and double* which have an incompatible binary data representation.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:23]: (portability) Casting between double * and long double * which have an incompatible binary data representation. [invalidPointerCast]\n"
+                      "[test.cpp:3:18]: (portability) Casting between long double * and double * which have an incompatible binary data representation. [invalidPointerCast]\n", errout_str());
 
         checkInvalidPointerCast("char* test(int* i) {\n"
                                 "    long double *d = (long double*)(i);\n"
                                 "    double *d = (double*)(i);\n"
                                 "    float *f = reinterpret_cast<float*>(i);\n"
                                 "}");
-        ASSERT_EQUALS("[test.cpp:2]: (portability) Casting between integer* and long double* which have an incompatible binary data representation.\n"
-                      "[test.cpp:3]: (portability) Casting between integer* and double* which have an incompatible binary data representation.\n"
-                      "[test.cpp:4]: (portability) Casting between integer* and float* which have an incompatible binary data representation.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:22]: (portability) Casting between signed int * and long double * which have an incompatible binary data representation. [invalidPointerCast]\n"
+                      "[test.cpp:3:17]: (portability) Casting between signed int * and double * which have an incompatible binary data representation. [invalidPointerCast]\n"
+                      "[test.cpp:4:16]: (portability) Casting between signed int * and float * which have an incompatible binary data representation. [invalidPointerCast]\n", errout_str());
 
         checkInvalidPointerCast("float* test(unsigned int* i) {\n"
                                 "    return (float*)i;\n"
                                 "}");
-        ASSERT_EQUALS("[test.cpp:2]: (portability) Casting between integer* and float* which have an incompatible binary data representation.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:12]: (portability) Casting between unsigned int * and float * which have an incompatible binary data representation. [invalidPointerCast]\n", errout_str());
 
         checkInvalidPointerCast("float* test(unsigned int* i) {\n"
                                 "    return (float*)i[0];\n"
                                 "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkInvalidPointerCast("float* test(double& d) {\n"
                                 "    return (float*)&d;\n"
                                 "}");
-        ASSERT_EQUALS("[test.cpp:2]: (portability) Casting between double* and float* which have an incompatible binary data representation.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:12]: (portability) Casting between double * and float * which have an incompatible binary data representation. [invalidPointerCast]\n", errout_str());
 
         checkInvalidPointerCast("void test(float* data) {\n"
                                 "    f.write((char*)data,sizeof(float));\n"
-                                "}", true, false);
-        ASSERT_EQUALS("", errout.str());
+                                "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkInvalidPointerCast("void test(float* data) {\n"
                                 "    f.write((char*)data,sizeof(float));\n"
-                                "}", true, true); // #3639
-        ASSERT_EQUALS("[test.cpp:2]: (portability, inconclusive) Casting from float* to char* is not portable due to different binary data representations on different platforms.\n", errout.str());
+                                "}", dinit(CheckInvalidPointerCastOptions, $.inconclusive = true)); // #3639
+        ASSERT_EQUALS("[test.cpp:2:13]: (portability, inconclusive) Casting from float * to char * is not portable due to different binary data representations on different platforms. [invalidPointerCast]\n", errout_str());
 
 
         checkInvalidPointerCast("long long* test(float* f) {\n"
                                 "    return (long long*)f;\n"
-                                "}", false);
-        ASSERT_EQUALS("", errout.str());
+                                "}", dinit(CheckInvalidPointerCastOptions, $.portability = false));
+        ASSERT_EQUALS("", errout_str());
 
         checkInvalidPointerCast("long long* test(float* f, char* c) {\n"
                                 "    foo((long long*)f);\n"
                                 "    return reinterpret_cast<long long*>(c);\n"
-                                "}", true);
-        ASSERT_EQUALS("[test.cpp:2]: (portability) Casting from float* to integer* is not portable due to different binary data representations on different platforms.\n", errout.str());
+                                "}");
+        ASSERT_EQUALS("[test.cpp:2:9]: (portability) Casting from float * to signed long long * is not portable due to different binary data representations on different platforms. [invalidPointerCast]\n", errout_str());
 
         checkInvalidPointerCast("Q_DECLARE_METATYPE(int*)"); // #4135 - don't crash
     }
@@ -1456,91 +2455,101 @@ class TestOther : public TestFixture {
 
     void passedByValue() {
         check("void f(const std::string str) {}");
-        ASSERT_EQUALS("[test.cpp:1]: (performance) Function parameter 'str' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:26]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("void f(std::unique_ptr<std::string> ptr) {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(const std::shared_ptr<std::string> ptr) {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(const std::function<F> ptr) {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         {
             check("void f(const std::pair<int,int> x) {}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
 
             check("void f(const std::pair<std::string,std::string> x) {}");
-            TODO_ASSERT_EQUALS("error", "", errout.str());
+            TODO_ASSERT_EQUALS("error", "", errout_str());
         }
 
         check("void f(const std::string::size_type x) {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Foo;\nvoid f(const Foo foo) {}"); // Unknown class
-        ASSERT_EQUALS("[test.cpp:2]: (performance, inconclusive) Function parameter 'foo' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:18]: (performance, inconclusive) Function parameter 'foo' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("class Foo { std::vector<int> v; };\nvoid f(const Foo foo) {}"); // Large class (STL member)
-        ASSERT_EQUALS("[test.cpp:2]: (performance) Function parameter 'foo' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:18]: (performance) Function parameter 'foo' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("class Foo { int i; };\nvoid f(const Foo foo) {}"); // Small class
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Foo { int i[6]; };\nvoid f(const Foo foo) {}"); // Large class (array)
-        ASSERT_EQUALS("[test.cpp:2]: (performance) Function parameter 'foo' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:18]: (performance) Function parameter 'foo' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("class Foo { std::string* s; };\nvoid f(const Foo foo) {}"); // Small class (pointer)
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Foo { static std::string s; };\nvoid f(const Foo foo) {}"); // Small class (static member)
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class X { std::string s; }; class Foo : X { };\nvoid f(const Foo foo) {}"); // Large class (inherited)
-        ASSERT_EQUALS("[test.cpp:2]: (performance) Function parameter 'foo' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:18]: (performance) Function parameter 'foo' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("class X { std::string s; }; class Foo { X x; };\nvoid f(const Foo foo) {}"); // Large class (inherited)
-        ASSERT_EQUALS("[test.cpp:2]: (performance) Function parameter 'foo' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:18]: (performance) Function parameter 'foo' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("void f(const std::string &str) {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // The idiomatic way of passing a std::string_view is by value
+        check("void f(const std::string_view str) {}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::string_view str) {}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const std::string_view &str) {}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(const std::vector<int> v) {}");
-        ASSERT_EQUALS("[test.cpp:1]: (performance) Function parameter 'v' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:31]: (performance) Function parameter 'v' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("void f(const std::vector<std::string> v) {}");
-        ASSERT_EQUALS("[test.cpp:1]: (performance) Function parameter 'v' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:39]: (performance) Function parameter 'v' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("void f(const std::vector<std::string>::size_type s) {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(const std::vector<int> &v) {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(const std::map<int,int> &v) {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(const std::map<int,int> v) {}");
-        ASSERT_EQUALS("[test.cpp:1]: (performance) Function parameter 'v' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:32]: (performance) Function parameter 'v' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("void f(const std::map<std::string,std::string> v) {}");
-        ASSERT_EQUALS("[test.cpp:1]: (performance) Function parameter 'v' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:48]: (performance) Function parameter 'v' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("void f(const std::map<int,std::string> v) {}");
-        ASSERT_EQUALS("[test.cpp:1]: (performance) Function parameter 'v' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:40]: (performance) Function parameter 'v' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("void f(const std::map<std::string,int> v) {}");
-        ASSERT_EQUALS("[test.cpp:1]: (performance) Function parameter 'v' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:40]: (performance) Function parameter 'v' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("void f(const std::streamoff pos) {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(std::initializer_list<int> i) {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #5824
         check("void log(const std::string& file, int line, const std::string& function, const std::string str, ...) {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #5534
         check("struct float3 { };\n"
@@ -1548,94 +2557,270 @@ class TestOther : public TestFixture {
               "class Plane {\n"
               "    vec Refract(vec &vec) const;\n"
               "    bool IntersectLinePlane(const vec &planeNormal);\n"
-              "}; ");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
 
         check("class X {\n"
               "    virtual void func(const std::string str) {}\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:2]: (performance) Function parameter 'str' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:41]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n", errout_str());
+
+        check("enum X;\n"
+              "void foo(X x1){}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("enum X { a, b, c };\n"
+              "void foo(X x2){}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("enum X { a, b, c };\n"
+              "enum X;"
+              "void foo(X x3){}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("enum X;\n"
+              "enum X { a, b, c };"
+              "void foo(X x4){}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("union U {\n"
+              "    char* pc;\n"
+              "    short* ps;\n"
+              "    int* pi;\n"
+              "};\n"
+              "void f(U u) {}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { char A[8][8]; };\n"
+              "void f(S s) {}\n");
+        ASSERT_EQUALS("[test.cpp:2:10]: (performance) Function parameter 's' should be passed by const reference. [passedByValue]\n", errout_str());
+
+        check("union U {\n" // don't crash
+              "    int a;\n"
+              "    decltype(nullptr) b;\n"
+              "};\n"
+              "int* f(U u) { return u.b; }\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct B { virtual int f(std::string s) = 0; };\n" // #11432
+              "struct D1 : B {\n"
+              "  int f(std::string s) override { s += 'a'; return s.size(); }\n"
+              "}\n"
+              "struct D2 : B {\n"
+              "  int f(std::string s) override { return s.size(); }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int x(int);\n"
+              "void f(std::vector<int> v, int& j) {\n"
+              "    for (int i : v)\n"
+              "        j = i;\n"
+              "}\n"
+              "void fn(std::vector<int> v) {\n"
+              "    for (int& i : v)\n"
+              "        i = x(i);\n"
+              "}\n"
+              "void g(std::vector<int> v, int& j) {\n"
+              "    for (int i = 0; i < v.size(); ++i)\n"
+              "        j = v[i];\n"
+              "}\n"
+              "void gn(std::vector<int> v) {\n"
+              "    for (int i = 0; i < v.size(); ++i)\n"
+              "        v[i] = x(i);\n"
+              "}\n"
+              "void h(std::vector<std::vector<int>> v, int& j) {\n"
+              "    for (int i = 0; i < v.size(); ++i)\n"
+              "        j = v[i][0];\n"
+              "}\n"
+              "void hn(std::vector<std::vector<int>> v) {\n"
+              "    for (int i = 0; i < v.size(); ++i)\n"
+              "        v[i][0] = x(i);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:25]: (performance) Function parameter 'v' should be passed by const reference. [passedByValue]\n"
+                      "[test.cpp:10:25]: (performance) Function parameter 'v' should be passed by const reference. [passedByValue]\n"
+                      "[test.cpp:18:38]: (performance) Function parameter 'v' should be passed by const reference. [passedByValue]\n",
+                      errout_str());
+
+        check("struct S {\n" // #11995
+              "    explicit S(std::string s) noexcept;\n"
+              "    std::string m;\n"
+              "};\n"
+              "S::S(std::string s) noexcept : m(std::move(s)) {}\n"
+              "struct T {\n"
+              "    explicit S(std::string s) noexcept(true);\n"
+              "    std::string m;\n"
+              "};\n"
+              "T::T(std::string s) noexcept(true) : m(std::move(s)) {}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("namespace N {\n" // #12086
+              "    void g(int);\n"
+              "}\n"
+              "void f(std::vector<int> v) {\n"
+              "    N::g(v[0]);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:25]: (performance) Function parameter 'v' should be passed by const reference. [passedByValue]\n", errout_str());
+
+        check("void f(const std::string& s, std::string t) {\n" // #12083
+              "    const std::string& v = !s.empty() ? s : t;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:42]: (performance) Function parameter 't' should be passed by const reference. [passedByValue]\n", errout_str());
+
+        /*const*/ Settings settingsUnix64 = settingsBuilder(settings0).platform(Platform::Type::Unix64).build();
+        check("struct S {\n" // #12138
+              "    union {\n"
+              "        int a = 0;\n"
+              "        int x;\n"
+              "    };\n"
+              "    union {\n"
+              "        int b = 0;\n"
+              "        int y;\n"
+              "    };\n"
+              "    union {\n"
+              "        int c = 0;\n"
+              "        int z;\n"
+              "    };\n"
+              "};\n"
+              "void f(S s) {\n"
+              "    if (s.x > s.y) {}\n"
+              "}\n", dinit(CheckOptions, $.settings = &settingsUnix64));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { std::list<int> l; };\n" // #12147
+              "class C { public: std::list<int> l; };\n"
+              "bool f(S s) {\n"
+              "    return s.l.empty();\n"
+              "}\n"
+              "bool f(C c) {\n"
+              "    return c.l.empty();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:10]: (performance) Function parameter 's' should be passed by const reference. [passedByValue]\n"
+                      "[test.cpp:6:10]: (performance) Function parameter 'c' should be passed by const reference. [passedByValue]\n",
+                      errout_str());
+
+        check("struct S { std::list<int> a[1][1]; };\n"
+              "bool f(S s) {\n"
+              "    return s.a[0][0].empty();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:10]: (performance) Function parameter 's' should be passed by const reference. [passedByValue]\n",
+                      errout_str());
+
+        check("struct S {\n"
+              "    enum class E : std::uint8_t { E0 };\n"
+              "    static void f(S::E e) {\n"
+              "        if (e == S::E::E0) {}\n"
+              "    }\n"
+              "    char a[20];\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const std::vector<int> v[2]);\n" // #13052
+              "void g(const std::vector<int> v[2]);\n"
+              "void g(const std::vector<int> v[2]) {}\n"
+              "int h(const std::array<std::vector<int>, 2> a) { return a[0][0]; }\n");
+        ASSERT_EQUALS("[test.cpp:4:45]: (performance) Function parameter 'a' should be passed by const reference. [passedByValue]\n", errout_str());
+
+        check("void f(const std::array<int, 10> a[]) {}\n"); // #13524
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #10733
+              "    std::vector<int> v;\n"
+              "    using F = void (*)();\n"
+              "    void func(F f);\n"
+              "};\n"
+              "void S::func(S::F f) {}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        /*const*/ Settings settingsWin64 = settingsBuilder().platform(Platform::Type::Win64).build();
+        check("using ui64 = unsigned __int64;\n"
+              "ui64 Test(ui64 one, ui64 two) { return one + two; }\n",
+              dinit(CheckOptions, $.settings = &settingsWin64));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void passedByValue_nonConst() {
         check("void f(std::string str) {}");
-        ASSERT_EQUALS("[test.cpp:1]: (performance) Function parameter 'str' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:20]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("void f(std::string str) {\n"
               "    return str + x;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:1]: (performance) Function parameter 'str' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:20]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("void f(std::string str) {\n"
               "    std::cout << str;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:1]: (performance) Function parameter 'str' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:20]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("void f(std::string str) {\n"
               "    std::cin >> str;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(std::string str) {\n"
               "    std::string s2 = str;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:1]: (performance) Function parameter 'str' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (performance, inconclusive) Use const reference for 's2' to avoid unnecessary data copying. [redundantCopyLocalConst]\n"
+                      "[test.cpp:1:20]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n",
+                      errout_str());
 
         check("void f(std::string str) {\n"
               "    std::string& s2 = str;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Variable 's2' can be declared with const\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:20]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n"
+                      "[test.cpp:2:18]: (style) Variable 's2' can be declared as reference to const [constVariableReference]\n",
+                      errout_str());
 
         check("void f(std::string str) {\n"
               "    const std::string& s2 = str;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:1]: (performance) Function parameter 'str' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:20]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("void f(std::string str) {\n"
               "    str = \"\";\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(std::string str) {\n"
               "    foo(str);\n" // It could be that foo takes str as non-const-reference
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(const std::string& str);\n"
               "void f(std::string str) {\n"
               "    foo(str);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (performance) Function parameter 'str' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:20]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("void foo(std::string str);\n"
               "void f(std::string str) {\n"
               "    foo(str);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (performance) Function parameter 'str' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:20]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("void foo(std::string& str);\n"
               "void f(std::string str) {\n"
               "    foo(str);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(std::string* str);\n"
               "void f(std::string str) {\n"
               "    foo(&str);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int& i1, const std::string& str, int& i2);\n"
               "void f(std::string str) {\n"
               "    foo((a+b)*c, str, x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (performance) Function parameter 'str' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:20]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("std::string f(std::string str) {\n"
               "    str += x;\n"
               "    return str;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class X {\n"
               "    std::string s;\n"
@@ -1644,7 +2829,7 @@ class TestOther : public TestFixture {
               "Y f(X x) {\n"
               "    x.func();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (performance) Function parameter 'x' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:7]: (performance) Function parameter 'x' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("class X {\n"
               "    void func();\n"
@@ -1652,17 +2837,17 @@ class TestOther : public TestFixture {
               "Y f(X x) {\n"
               "    x.func();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class X {\n"
               "    void func(std::string str) {}\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:2]: (performance) Function parameter 'str' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:27]: (performance) Function parameter 'str' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("class X {\n"
               "    virtual void func(std::string str) {}\n" // Do not warn about virtual functions, if 'str' is not declared as const
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class X {\n"
               "    char a[1024];\n"
@@ -1672,7 +2857,7 @@ class TestOther : public TestFixture {
               "};\n"
               "void f(Y y) {\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (performance) Function parameter 'y' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:10]: (performance) Function parameter 'y' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("class X {\n"
               "    void* a;\n"
@@ -1685,7 +2870,7 @@ class TestOther : public TestFixture {
               "};\n"
               "void f(X x, Y y) {\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:10]: (performance) Function parameter 'y' should be passed by const reference.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:15]: (performance) Function parameter 'y' should be passed by const reference. [passedByValue]\n", errout_str());
 
         {
             // 8-byte data should be passed by const reference on 32-bit platform but not on 64-bit platform
@@ -1695,159 +2880,190 @@ class TestOther : public TestFixture {
                                 "};\n"
                                 "void f(X x) {}";
 
-            Settings s32(_settings);
-            s32.platform(cppcheck::Platform::Unix32);
-            check(code, &s32);
-            ASSERT_EQUALS("[test.cpp:5]: (performance) Function parameter 'x' should be passed by const reference.\n", errout.str());
+            /*const*/ Settings s32 = settingsBuilder(settings1).platform(Platform::Type::Unix32).build();
+            check(code, dinit(CheckOptions, $.settings = &s32));
+            ASSERT_EQUALS("[test.cpp:5:10]: (performance) Function parameter 'x' should be passed by const reference. [passedByValue]\n", errout_str());
 
-            Settings s64(_settings);
-            s64.platform(cppcheck::Platform::Unix64);
-            check(code, &s64);
-            ASSERT_EQUALS("", errout.str());
+            /*const*/ Settings s64 = settingsBuilder(settings1).platform(Platform::Type::Unix64).build();
+            check(code, dinit(CheckOptions, $.settings = &s64));
+            ASSERT_EQUALS("", errout_str());
         }
+
+        check("Writer* getWriter();\n"
+              "\n"
+              "void foo(Buffer& buffer) {\n"
+              "    getWriter()->operator<<(buffer);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void passedByValue_externC() {
+        check("struct X { int a[5]; }; void f(X v) { }");
+        ASSERT_EQUALS("[test.cpp:1:34]: (performance) Function parameter 'v' should be passed by const reference. [passedByValue]\n", errout_str());
+
+        check("extern \"C\" { struct X { int a[5]; }; void f(X v) { } }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct X { int a[5]; }; extern \"C\" void f(X v) { }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct X { int a[5]; }; void f(const X v);");
+        ASSERT_EQUALS("[test.cpp:1:40]: (performance) Function parameter 'v' should be passed by const reference. [passedByValue]\n", errout_str());
+
+        check("extern \"C\" { struct X { int a[5]; }; void f(const X v); }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct X { int a[5]; }; extern \"C\" void f(const X v) { }");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void constVariable() {
         check("int f(std::vector<int> x) {\n"
               "    int& i = x[0];\n"
               "    return i;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Variable 'i' can be declared with const\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:1:24]: (performance) Function parameter 'x' should be passed by const reference. [passedByValue]\n"
+                      "[test.cpp:2:10]: (style) Variable 'i' can be declared as reference to const [constVariableReference]\n",
+                      errout_str());
 
         check("int f(std::vector<int>& x) {\n"
               "    return x[0];\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Parameter 'x' can be declared with const\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:1:25]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
 
         check("int f(std::vector<int> x) {\n"
               "    const int& i = x[0];\n"
               "    return i;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:1:24]: (performance) Function parameter 'x' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("int f(std::vector<int> x) {\n"
               "    static int& i = x[0];\n"
               "    return i;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:1:24]: (performance) Function parameter 'x' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("int f(std::vector<int> x) {\n"
               "    int& i = x[0];\n"
               "    i++;\n"
               "    return i;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("int& f(std::vector<int>& x) {\n"
               "    x.push_back(1);\n"
               "    int& i = x[0];\n"
               "    return i;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("int f(const std::vector<int>& x) {\n"
               "    return x[0];\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("int& f(std::vector<int>& x) {\n"
               "    return x[0];\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("const int& f(std::vector<int>& x) {\n"
+              "    return x[0];\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:1:32]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
 
         check("int f(std::vector<int>& x) {\n"
               "    x[0]++;\n"
               "    return x[0];\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A { int a; };\n"
               "A f(std::vector<A>& x) {\n"
               "    x[0].a = 1;\n"
               "    return x[0];\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A { int a(); };\n"
               "A f(std::vector<A>& x) {\n"
               "    x[0].a();\n"
               "    return x[0];\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("int g(int& x);\n"
               "int f(std::vector<int>& x) {\n"
               "    g(x[0]);\n"
               "    return x[0];\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("template<class T>\n"
               "T f(T& x) {\n"
               "    return x[0];\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("template<class T>\n"
               "T f(T&& x) {\n"
               "    return x[0];\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("template<class T>\n"
               "T f(T& x) {\n"
               "    return x[0];\n"
               "}\n"
-              "void h() { std::vector<int> v; h(v); }\n");
-        ASSERT_EQUALS("", errout.str());
+              "void h() { std::vector<int> v; h(v); }");
+        ASSERT_EQUALS("", errout_str());
 
         check("int f(int& x) {\n"
               "    return std::move(x);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(std::ostream& os) {\n"
               "    os << \"Hello\";\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void g(int*);\n"
               "void f(int& x) {\n"
               "    g(&x);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A { A(int*); };\n"
               "A f(int& x) {\n"
               "    return A(&x);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A { A(int*); };\n"
               "A f(int& x) {\n"
               "    return A{&x};\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
-        // Perhaps unused variable should be checked as well.
         check("void f(int& x, int& y) {\n"
               "    y++;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:1:13]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
 
         check("struct A {\n"
               "    explicit A(int& y) : x(&y) {}\n"
               "    int * x = nullptr;\n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
               "    std::vector<int> v;\n"
               "    void swap(A& a) {\n"
               "        v.swap(a.v);\n"
               "    }\n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
               "    template<class T>\n"
@@ -1857,55 +3073,71 @@ class TestOther : public TestFixture {
               "};\n"
               "void g(A& a) {\n"
               "    a.f<int>();\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(std::vector<int>& v) {\n"
               "    for(auto&& x:v)\n"
               "        x = 1;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(std::vector<int>& v) {\n"
               "    for(auto x:v)\n"
               "        x = 1;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Parameter 'v' can be declared with const\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:1:26]: (style) Parameter 'v' can be declared as reference to const [constParameterReference]\n", errout_str());
 
         check("void f(std::vector<int>& v) {\n"
               "    for(auto& x:v) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:15]: (style) Variable 'x' can be declared as reference to const [constVariableReference]\n",
+                      errout_str());
+
+        check("void f(std::vector<int>& v) {\n" // #10980
+              "    for (int& i : v)\n"
+              "        if (i == 0) {}\n"
+              "    for (const int& i : v)\n"
+              "        if (i == 0) {}\n"
+              "    for (auto& i : v)\n"
+              "        if (i == 0) {}\n"
+              "    for (const auto& i : v)\n"
+              "        if (i == 0) {}\n"
+              "    v.clear();\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Parameter 'v' can be declared with const\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (style) Variable 'i' can be declared as reference to const [constVariableReference]\n"
+                      "[test.cpp:6:16]: (style) Variable 'i' can be declared as reference to const [constVariableReference]\n",
+                      errout_str());
 
         check("void f(std::vector<int>& v) {\n"
               "    for(const auto& x:v) {}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Parameter 'v' can be declared with const\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:1:26]: (style) Parameter 'v' can be declared as reference to const [constParameterReference]\n", errout_str());
 
         check("void f(int& i) {\n"
               "    int& j = i;\n"
               "    j++;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(std::vector<int>& v) {\n"
               "    int& i = v[0];\n"
               "    i++;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(std::map<unsigned int, std::map<std::string, unsigned int> >& m, unsigned int i) {\n"
               "    std::map<std::string, unsigned int>& members = m[i];\n"
               "    members.clear();\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
               "    int& x;\n"
               "    A(int& y) : x(y)\n"
               "    {}\n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
               "    A(int& x);\n"
@@ -1913,15 +3145,316 @@ class TestOther : public TestFixture {
               "struct B : A {\n"
               "    B(int& x) : A(x)\n"
               "    {}\n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(bool b, int& x, int& y) {\n"
               "  auto& z = x;\n"
               "  auto& w = b ? y : z;\n"
               "  w = 1;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n"
+              "  int i;\n"
+              "};\n"
+              "int& f(S& s) {\n"
+              "  return s.i;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int* f(std::list<int>& x, unsigned int y) {\n"
+              "    for (int& m : x) {\n"
+              "        if (m == y)\n"
+              "            return &m;\n"
+              "    }\n"
+              "    return nullptr;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int& f(std::list<int>& x, int& y) {\n"
+              "    for (int& m : x) {\n"
+              "        if (m == y)\n"
+              "            return m;\n"
+              "    }\n"
+              "    return y;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool from_string(int& t, const std::string& s) {\n"
+              "    std::istringstream iss(s);\n"
+              "    return !(iss >> t).fail();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9710
+        check("class a {\n"
+              "    void operator()(int& i) const {\n"
+              "        i++;\n"
+              "    }\n"
+              "};\n"
+              "void f(int& i) {\n"
+              "    a()(i);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("class a {\n"
+              "    void operator()(int& i) const {\n"
+              "        i++;\n"
+              "    }\n"
+              "};\n"
+              "void f(int& i) {\n"
+              "    a x;\n"
+              "    x(i);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("class a {\n"
+              "    void operator()(const int& i) const;\n"
+              "};\n"
+              "void f(int& i) {\n"
+              "    a x;\n"
+              "    x(i);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:13]: (style) Parameter 'i' can be declared as reference to const [constParameterReference]\n", errout_str());
+
+        //cast or assignment to a non-const reference should prevent the warning
+        check("struct T { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
+        check("struct T : public U  { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    const T& z = x;\n" // Make sure we find all assignments
+              "    T& y = x;\n"
+              "    y.mutate();\n" // to avoid warnings that y can be const
+              "}");
+        ASSERT_EQUALS("", errout_str());
+        check("struct T : public U  { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    const U& y = x\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
+        check("struct T : public U  { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    U& y = x;\n"
+              "    y.mutate();\n" // to avoid warnings that y can be const
+              "}");
+        ASSERT_EQUALS("", errout_str());
+        check("struct T : public U  { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    my<fancy>::type& y = x;\n" // we don't know if y is const or not
+              "    y.mutate();\n"             // to avoid warnings that y can be const
+              "}");
+        ASSERT_EQUALS("", errout_str());
+        check("struct T : public U  { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    const U& y = static_cast<const U&>(x);\n"
+              "    y.mutate();\n" // to avoid warnings that y can be const
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
+        check("struct T : public U  { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    U& y = static_cast<U&>(x);\n"
+              "    y.mutate();\n" // to avoid warnings that y can be const
+              "}");
+        ASSERT_EQUALS("", errout_str());
+        check("struct T : public U { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    const U& y = dynamic_cast<const U&>(x)\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
+        check("struct T : public U { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    const U& y = dynamic_cast<U const &>(x);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
+        check("struct T : public U { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    const U& y = dynamic_cast<U & const>(x);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
+        check("struct T : public U { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    U& y = dynamic_cast<U&>(x);\n"
+              "    y.mutate();\n" // to avoid warnings that y can be const
+              "}");
+        ASSERT_EQUALS("", errout_str());
+        check("struct T : public U { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    const U& y = dynamic_cast<typename const U&>(x);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
+        check("struct T : public U { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    U& y = dynamic_cast<typename U&>(x);\n"
+              "    y.mutate();\n" // to avoid warnings that y can be const
+              "}");
+        ASSERT_EQUALS("", errout_str());
+        check("struct T : public U { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    U* y = dynamic_cast<U*>(&x);\n"
+              "    y->mutate();\n" // to avoid warnings that y can be const
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct T : public U { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    const U * y = dynamic_cast<const U *>(&x);\n"
+              "    y->mutate();\n" // to avoid warnings that y can be const
+              "}");
+        TODO_ASSERT_EQUALS("can be const", errout_str(), ""); //Currently taking the address is treated as a non-const operation when it should depend on what we do with it
+        check("struct T : public U { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    U const * y = dynamic_cast<U const *>(&x);\n"
+              "    y->mutate();\n" // to avoid warnings that y can be const
+              "}");
+        TODO_ASSERT_EQUALS("can be const", errout_str(), ""); //Currently taking the address is treated as a non-const operation when it should depend on what we do with it
+        check("struct T : public U { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    const U const * const * const * const y = dynamic_cast<const U const * const * const * const>(&x);\n"
+              "    y->mutate();\n" // to avoid warnings that y can be const
+              "}");
+        ASSERT_EQUALS("", errout_str());
+        check("struct T : public U { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    const U const * const * const * const y = dynamic_cast<const U const * const * const * const>(&x);\n"
+              "    y->mutate();\n" // to avoid warnings that y can be const
+              "}");
+        TODO_ASSERT_EQUALS("can be const", errout_str(), ""); //Currently taking the address is treated as a non-const operation when it should depend on what we do with it
+        check("struct T : public U { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    const U const * const *  * const y = dynamic_cast<const U const * const *  * const>(&x);\n"
+              "    y->mutate();\n" // to avoid warnings that y can be const
+              "}");
+        ASSERT_EQUALS("", errout_str());
+        check("struct T : public U { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    my::fancy<typename type const *> const * const  * const y = dynamic_cast<my::fancy<typename type const *> const * const  * const>(&x);\n"
+              "    y->mutate();\n" // to avoid warnings that y can be const
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct T : public U { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    const U& y = (const U&)(x);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:18]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n"
+                      "[test.cpp:2:11]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n",
+                      errout_str());
+        check("struct T : public U { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    U& y = (U&)(x);\n"
+              "    y.mutate();\n" // to avoid warnings that y can be const
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:12]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
+        check("struct T : public U { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    const U& y = (typename const U&)(x);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:18]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n"
+                      "[test.cpp:2:11]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n",
+                      errout_str());
+        check("struct T : public U { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    U& y = (typename U&)(x);\n"
+              "    y.mutate();\n" // to avoid warnings that y can be const
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:12]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
+        check("struct T : public U { void dostuff() const {}};\n"
+              "void a(T& x) {\n"
+              "    x.dostuff();\n"
+              "    U* y = (U*)(&x);\n"
+              "    y->mutate();\n" // to avoid warnings that y can be const
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:12]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
+
+        check("struct C { void f() const; };\n" // #9875 - crash
+              "\n"
+              "void foo(C& x) {\n"
+              "   x.f();\n"
+              "   foo( static_cast<U2>(0) );\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:13]: (style) Parameter 'x' can be declared as reference to const [constParameterReference]\n", errout_str());
+
+        check("class a {\n"
+              "    void foo(const int& i) const;\n"
+              "    void operator()(int& i) const;\n"
+              "};\n"
+              "void f(int& i) {\n"
+              "    a()(i);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("class a {\n"
+              "    void operator()(const int& i) const;\n"
+              "};\n"
+              "void f(int& i) {\n"
+              "    a()(i);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:13]: (style) Parameter 'i' can be declared as reference to const [constParameterReference]\n", errout_str());
+
+        // #9767
+        check("void fct1(MyClass& object) {\n"
+              "   fct2([&](void){}, object);\n"
+              "}\n"
+              "bool fct2(std::function<void()> lambdaExpression, MyClass& object) {\n"
+              "   object.modify();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9778
+        check("struct A {};\n"
+              "struct B : A {};\n"
+              "B& f(A& x) {\n"
+              "    return static_cast<B&>(x);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10002
+        check("using A = int*;\n"
+              "void f(const A& x) {\n"
+              "    ++(*x);\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // #10086
+        check("struct V {\n"
+              "    V& get(typename std::vector<V>::size_type i) {\n"
+              "        std::vector<V>& arr = v;\n"
+              "        return arr[i];\n"
+              "    }\n"
+              "    std::vector<V> v;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #14136
+        check("void f(int& x) { (void)x; }\n");
+        ASSERT_EQUALS("", errout_str());
 
         check("void e();\n"
               "void g(void);\n"
@@ -2059,7 +3592,7 @@ class TestOther : public TestFixture {
               "}\n"
               "void bc(size_t ae) {\n"
               "wchar_t *ad = 0, *af = 0;\n"
-              "struct tm *ag = 0;                  \n"
+              "struct tm *ag = 0;\n"
               "(void)std::wcsftime(ad, ae, af, ag);\n"
               "(void)std::wcsftime(0, ae, 0, 0);\n"
               "}\n"
@@ -2073,146 +3606,1370 @@ class TestOther : public TestFixture {
               "void bh(const std::list<int> &ak, const std::list<int> &al);\n"
               "void ah();\n"
               "void an();\n"
-              "void h();\n");
-        ASSERT_EQUALS("", errout.str());
-    }
+              "void h();");
+        ASSERT_EQUALS("[test.cpp:131:12]: (style) Variable 'tm' can be declared as pointer to const [constVariablePointer]\n"
+                      "[test.cpp:136:19]: (style) Variable 'af' can be declared as pointer to const [constVariablePointer]\n"
+                      "[test.cpp:137:12]: (style) Variable 'ag' can be declared as pointer to const [constVariablePointer]\n",
+                      errout_str());
 
-    void switchRedundantAssignmentTest() {
-        check("void foo()\n"
+        check("class C\n"
               "{\n"
-              "    int y = 1;\n"
-              "    switch (a)\n"
-              "    {\n"
-              "    case 2:\n"
-              "        y = 2;\n"
-              "    case 3:\n"
-              "        y = 3;\n"
-              "    }\n"
-              "    bar(y);\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:9]: (warning) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing?\n", errout.str());
-
-        check("void foo()\n"
+              "public:\n"
+              "  explicit C(int&);\n"
+              "};\n"
+              "\n"
+              "class D\n"
               "{\n"
-              "    int y = 1;\n"
-              "    switch (a)\n"
-              "    {\n"
-              "    case 2:\n"
-              "      {\n"
-              "        y = 2;\n"
-              "      }\n"
-              "    case 3:\n"
-              "        y = 3;\n"
-              "    }\n"
-              "    bar(y);\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:11]: (warning) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing?\n", errout.str());
-
-        check("void foo()\n"
+              "public:\n"
+              "  explicit D(int&);\n"
+              "\n"
+              "private:\n"
+              "  C c;\n"
+              "};\n"
+              "\n"
+              "D::D(int& i)\n"
+              "  : c(i)\n"
               "{\n"
-              "    int y = 1;\n"
-              "    switch (a)\n"
-              "    {\n"
-              "    case 2:\n"
-              "        y = 2;\n"
-              "    case 3:\n"
-              "        if (x)\n"
-              "        {\n"
-              "            y = 3;\n"
-              "        }\n"
-              "    }\n"
-              "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void foo()\n"
+        check("class C\n"
               "{\n"
-              "    int y = 1;\n"
-              "    switch (a)\n"
-              "    {\n"
-              "    case 2:\n"
-              "      {\n"
-              "        y = 2;\n"
-              "        if (z)\n"
-              "            printf(\"%d\", y);\n"
-              "      }\n"
-              "    case 3:\n"
-              "        y = 3;\n"
-              "    }\n"
-              "    bar(y);\n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
+              "public:\n"
+              "  explicit C(int&);\n"
+              "};\n"
+              "\n"
+              "class D\n"
+              "{\n"
+              "public:\n"
+              "  explicit D(int&) noexcept;\n"
+              "\n"
+              "private:\n"
+              "  C c;\n"
+              "};\n"
+              "\n"
+              "D::D(int& i) noexcept\n"
+              "  : c(i)\n"
+              "{}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("void foo()\n"
+        check("class C\n"
+              "{\n"
+              "public:\n"
+              "  explicit C(const int&);\n"
+              "};\n"
+              "\n"
+              "class D\n"
+              "{\n"
+              "public:\n"
+              "  explicit D(int&);\n"
+              "\n"
+              "private:\n"
+              "  C c;\n"
+              "};\n"
+              "\n"
+              "D::D(int& i)\n"
+              "  : c(i)\n"
               "{\n"
-              "    int x = a;\n"
-              "    int y = 1;\n"
-              "    switch (x)\n"
-              "    {\n"
-              "    case 2:\n"
-              "        x = 2;\n"
-              "    case 3:\n"
-              "        y = 3;\n"
-              "    }\n"
-              "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:16]: (style) Parameter 'i' can be declared as reference to const\n", "", errout_str());
 
-        check("void foo()\n"
+        check("class C\n"
+              "{\n"
+              "public:\n"
+              "  explicit C(int);\n"
+              "};\n"
+              "\n"
+              "class D\n"
+              "{\n"
+              "public:\n"
+              "  explicit D(int&);\n"
+              "\n"
+              "private:\n"
+              "  C c;\n"
+              "};\n"
+              "\n"
+              "D::D(int& i)\n"
+              "  : c(i)\n"
               "{\n"
-              "    int y = 1;\n"
-              "    switch (x)\n"
-              "    {\n"
-              "    case 2:\n"
-              "        y = 2;\n"
-              "        break;\n"
-              "    case 3:\n"
-              "        y = 3;\n"
-              "    }\n"
-              "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:16]: (style) Parameter 'i' can be declared as reference to const\n", "", errout_str());
 
-        check("void foo()\n"
+        check("class C\n"
+              "{\n"
+              "public:\n"
+              "  explicit C(int, int);\n"
+              "};\n"
+              "\n"
+              "class D\n"
+              "{\n"
+              "public:\n"
+              "  explicit D(int&);\n"
+              "\n"
+              "private:\n"
+              "  C c;\n"
+              "};\n"
+              "\n"
+              "D::D(int& i)\n"
+              "  : c(0, i)\n"
               "{\n"
-              "    int y = 1;\n"
-              "    while(xyz()) {\n"
-              "        switch (x)\n"
-              "        {\n"
-              "        case 2:\n"
-              "            y = 2;\n"
-              "            continue;\n"
-              "        case 3:\n"
-              "            y = 3;\n"
-              "        }\n"
-              "        bar(y);\n"
-              "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:16]: (style) Parameter 'i' can be declared as reference to const\n", "", errout_str());
 
-        check("void foo()\n"
-              "{\n"
-              "    int y = 1;\n"
-              "    while(xyz()) {\n"
-              "        switch (x)\n"
-              "        {\n"
-              "        case 2:\n"
-              "            y = 2;\n"
-              "            throw e;\n"
-              "        case 3:\n"
-              "            y = 3;\n"
-              "        }\n"
-              "        bar(y);\n"
-              "    }\n"
+        check("void f(std::map<int, std::vector<int>> &map) {\n" // #10266
+              "  for (auto &[slave, panels] : map)\n"
+              "    panels.erase(it);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void foo()\n"
-              "{\n"
-              "    int y = 1;\n"
-              "    switch (x)\n"
-              "    {\n"
-              "    case 2:\n"
+        check("struct S { void f(); int i; };\n"
+              "void call_f(S& s) { (s.*(&S::f))(); }\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { int a[1]; };\n"
+              "void f(S& s) { int* p = s.a; *p = 0; }\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct Foo {\n" // #9910
+              "    int* p{};\n"
+              "    int* get() { return p; }\n"
+              "    const int* get() const { return p; }\n"
+              "};\n"
+              "struct Bar {\n"
+              "    int j{};\n"
+              "    void f(Foo& foo) const { int* q = foo.get(); *q = j; }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #10679
+              "    void g(long L, const C*& PC) const;\n"
+              "    void g(long L, C*& PC);\n"
+              "};\n"
+              "void f(S& s) {\n"
+              "    C* PC{};\n"
+              "    s.g(0, PC);\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10785
+        check("template <class T, class C>\n"
+              "struct d {\n"
+              "    T& g(C& c, T C::*f) { return c.*f; }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::map<int, int>& m) {\n"
+              "    std::cout << m[0] << std::endl;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::vector<std::map<int, int>>& v) {\n" // #11607
+              "    for (auto& m : v)\n"
+              "        std::cout << m[0];\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { int i; };\n" // #11473
+              "void f(std::vector<std::vector<S>>&m, int*& p) {\n"
+              "    auto& a = m[0];\n"
+              "    for (auto& s : a) {\n"
+              "        p = &s.i;\n"
+              "        return;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int& g(int* p, int& r) {\n" // #11625
+              "    if (p)\n"
+              "        return *p;\n"
+              "    return r;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("template <typename T> void f(std::vector<T*>& d, const std::vector<T*>& s) {\n" // #11632
+              "    for (const auto& e : s) {\n"
+              "        T* newE = new T(*e);\n"
+              "        d.push_back(newE);\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11682
+        check("struct b {\n"
+              "    void mutate();\n"
+              "};\n"
+              "struct c {\n"
+              "    const b& get() const;\n"
+              "    b get();\n"
+              "};\n"
+              "struct d {\n"
+              "    void f(c& e) const {\n"
+              "        e.get().mutate();\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct B { virtual void f() const {} };\n" // #11528
+              "struct D : B {};\n"
+              "void g(B* b) {\n"
+              "    D* d = dynamic_cast<D*>(b);\n"
+              "    if (d)\n"
+              "        d->f();\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:4:8]: (style) Variable 'd' can be declared as pointer to const [constVariablePointer]\n",
+            errout_str());
+
+        check("void g(const int*);\n"
+              "void f(const std::vector<int*>&v) {\n"
+              "    for (int* i : v)\n"
+              "        g(i);\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:15]: (style) Variable 'i' can be declared as pointer to const [constVariablePointer]\n",
+            errout_str());
+
+        check("struct A {\n" // #11225
+              "    A();\n"
+              "    virtual ~A();\n"
+              "};\n"
+              "struct B : A {};\n"
+              "void f(A* a) {\n"
+              "    const B* b = dynamic_cast<const B*>(a);\n"
+              "}\n"
+              "void g(A* a) {\n"
+              "    const B* b = (const B*)a;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:10:18]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n"
+                      "[test.cpp:6:11]: (style) Parameter 'a' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:9:11]: (style) Parameter 'a' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
+        check("void g(int*);\n"
+              "void f(std::vector<int>& v) {\n"
+              "    g(v.data());\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void g(const int*);\n"
+              "void f(std::vector<int>& v) {\n"
+              "    g(v.data());\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:26]: (style) Parameter 'v' can be declared as reference to const [constParameterReference]\n", errout_str());
+
+        check("struct a {\n"
+              "    template <class T>\n"
+              "    void mutate();\n"
+              "};\n"
+              "struct b {};\n"
+              "template <class T>\n"
+              "void f(a& x) {\n"
+              "    x.mutate<T>();\n"
+              "}\n"
+              "template <class T>\n"
+              "void f(const b&)\n"
+              "{}\n"
+              "void g(a& c) { f<int>(c); }\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n"
+              "    template <typename T>\n"
+              "    T* g() {\n"
+              "        return reinterpret_cast<T*>(m);\n"
+              "    }\n"
+              "    template <typename T>\n"
+              "    const T* g() const {\n"
+              "        return reinterpret_cast<const T*>(m);\n"
+              "    }\n"
+              "    char* m;\n"
+              "};\n"
+              "void f(S& s) {\n"
+              "    const int* p = s.g<int>();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { int x; };\n" // #11818
+              "std::istream& f(std::istream& is, S& s) {\n"
+              "    return is >> s.x;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool f(std::string& s1, std::string& s2) {\n" // #12203
+              "    return &s1 == &s2;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:21]: (style) Parameter 's1' can be declared as reference to const [constParameterReference]\n"
+                      "[test.cpp:1:38]: (style) Parameter 's2' can be declared as reference to const [constParameterReference]\n",
+                      errout_str());
+
+        check("void f(int& r) {\n" // #12214
+              "    (void)(true);\n"
+              "    if (r) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:13]: (style) Parameter 'r' can be declared as reference to const [constParameterReference]\n", errout_str());
+
+        check("struct S { void f(int&); };\n" // #12216
+              "void g(S& s, int& r, void (S::* p2m)(int&)) {\n"
+              "    (s.*p2m)(r);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n"
+              "    void f(int& r) { p = &r; }\n"
+              "    int* p;\n"
+              "};\n"
+              "void g(std::vector<int>& v1, std::vector<int*>& v2) {\n"
+              "    std::transform(v1.begin(), v1.end(), v2.begin(), [](auto& x) { return &x; });\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("class T;\n" // #11869
+              "class E {\n"
+              "public:\n"
+              "    class F {\n"
+              "    public:\n"
+              "        explicit F(const T* t);\n"
+              "    };\n"
+              "};\n"
+              "void f(T& t) {\n"
+              "    std::list<E::F> c(1, E::F(&t));\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:9:11]: (style) Parameter 't' can be declared as reference to const [constParameterReference]\n", errout_str());
+
+        check("struct T;\n"
+              "struct U {\n"
+              "    struct V { explicit V(const T* p); };\n"
+              "};\n"
+              "void g(U::V v);\n"
+              "void f(T& t) {\n"
+              "    g(U::V(&t));\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:11]: (style) Parameter 't' can be declared as reference to const [constParameterReference]\n", errout_str());
+
+        check("void f1(std::vector<int>& v) {\n" // #11207
+              "    auto it = v.cbegin();\n"
+              "    while (it != v.cend()) {\n"
+              "        if (*it > 12) {}\n"
+              "        ++it;\n"
+              "    }\n"
+              "}\n"
+              "void f2(std::vector<int>& v) {\n"
+              "    auto it = v.begin();\n"
+              "    while (it != v.end()) {\n"
+              "        if (*it > 12) {}\n"
+              "        ++it;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:27]: (style) Parameter 'v' can be declared as reference to const [constParameterReference]\n"
+                      "[test.cpp:8:27]: (style) Parameter 'v' can be declared as reference to const [constParameterReference]\n",
+                      errout_str());
+
+        check("void cb(const std::string&);\n" // #12349, #12350, #12351
+              "void f(std::string& s) {\n"
+              "    const std::string& str(s);\n"
+              "    cb(str);\n"
+              "}\n"
+              "void g(std::string& s) {\n"
+              "    const std::string& str{ s };\n"
+              "    cb(str);\n"
+              "}\n"
+              "void h(std::string* s) {\n"
+              "    const std::string& str(*s);\n"
+              "    cb(str);\n"
+              "}\n"
+              "void k(std::string* s) {\n"
+              "    const std::string& str = *s;\n"
+              "    cb(str);\n"
+              "}\n"
+              "void m(std::string& s) {\n"
+              "    const std::string str(s);\n"
+              "    cb(str);\n"
+              "}\n"
+              "void n(std::string* s) {\n"
+              "    const std::string& str(*s);\n"
+              "    cb(str);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:21]: (style) Parameter 's' can be declared as reference to const [constParameterReference]\n"
+                      "[test.cpp:6:21]: (style) Parameter 's' can be declared as reference to const [constParameterReference]\n"
+                      "[test.cpp:18:21]: (style) Parameter 's' can be declared as reference to const [constParameterReference]\n"
+                      "[test.cpp:10:21]: (style) Parameter 's' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:14:21]: (style) Parameter 's' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:22:21]: (style) Parameter 's' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
+        check("struct S {\n"
+              "    S(std::string& r);\n"
+              "};\n"
+              "void f(std::string& str) {\n"
+              "    const S& s(str);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct C {\n" // #10052
+              "    int& operator()(int);\n"
+              "};\n"
+              "void f(std::vector<C>& c) {\n"
+              "    c[0](5) = 12;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int& t) {\n" // #11713
+              "    return 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:12]: (style) Parameter 't' can be declared as reference to const [constParameterReference]\n", errout_str());
+
+        check("void f(std::list<std::string>& v) {\n" // #12202
+              "    v.remove_if([](std::string& s) {\n"
+              "        return true;\n"
+              "    });\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:33]: (style) Parameter 's' can be declared as reference to const [constParameterReference]\n", errout_str());
+
+        check("struct S {\n" // #12762
+              "    std::vector<int> m;\n"
+              "    void f();\n"
+              "};\n"
+              "void S::f() {\n"
+              "    std::vector<int>& r = m;\n"
+              "    g(r[0] * 2);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:23]: (style) Variable 'r' can be declared as reference to const [constVariableReference]\n", errout_str());
+
+        check("std::iostream& get();\n" // #12940
+              "std::iostream& Fun() {\n"
+              "    auto lam = []() -> std::iostream& {\n"
+              "        std::iostream& ios = get();\n"
+              "        return ios;\n"
+              "    };\n"
+              "    return lam();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { int x[3]; };\n" // #13226
+              "void g(int a, int* b);\n"
+              "void f(int a, S& s) {\n"
+              "    return g(a, s.x);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { std::vector<int> v; };\n" // #13317
+              "struct T { S s; };\n"
+              "int f(S& s) {\n"
+              "    for (std::vector<int>::const_iterator it = s.v.cbegin(); it != s.v.cend(); ++it) {}\n"
+              "    return *s.v.cbegin();\n"
+              "}\n"
+              "int f(T& t) {\n"
+              "    return *t.s.v.cbegin();\n"
+              "}\n"
+              "int f(std::vector<int>& v) {\n"
+              "    return *v.cbegin();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) Parameter 's' can be declared as reference to const [constParameterReference]\n"
+                      "[test.cpp:7:10]: (style) Parameter 't' can be declared as reference to const [constParameterReference]\n"
+                      "[test.cpp:10:25]: (style) Parameter 'v' can be declared as reference to const [constParameterReference]\n",
+                      errout_str());
+
+        check("void push(V& v) { v.push_back({ .x = 1 }); }"); // #14010
+        ASSERT_EQUALS("", errout_str());
+
+        check("size_t* f(std::array<uint8_t, 128>& a) { return reinterpret_cast<size_t*>(a.data()); }\n"); // #14074
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { int i; };\n" // #14231
+              "void* f(S& s, int& v) {\n"
+              "    v = s.i;\n"
+              "    return (void*)&s;\n"
+              "}\n"); // don't crash
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { int i; };\n" // #14251
+              "struct T { std::optional<S> s; };\n"
+              "void f(T& t) {\n"
+              "    t.s->i = 0;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct B {};\n" // #13877
+              "struct D : B { int i; };\n"
+              "void f(B& b) {\n"
+              "    static_cast<D&>(b).i = 0;\n"
+              "}\n"
+              "void g(B& b) {\n"
+              "    std::cin >> static_cast<D&>(b).i;\n"
+              "}\n"
+              "int h(B& b) {\n"
+              "    return static_cast<const D&>(b).i;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:9:10]: (style) Parameter 'b' can be declared as reference to const [constParameterReference]\n", errout_str());
+
+        check("void f(int *p) {\n" // #14409
+              "    int*& pp{ p };\n"
+              "    if (*pp) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void constParameterCallback() {
+        check("int callback(std::vector<int>& x) { return x[0]; }\n"
+              "void f() { dostuff(callback); }");
+        ASSERT_EQUALS("[test.cpp:2:20] -> [test.cpp:1:32]: (style) Parameter 'x' can be declared as reference to const. However it seems that 'callback' is a callback function, if 'x' is declared with const you might also need to cast function pointer(s). [constParameterCallback]\n", errout_str());
+
+        // #9906
+        check("class EventEngine : public IEventEngine {\n"
+              "public:\n"
+              "    EventEngine();\n"
+              "\n"
+              "private:\n"
+              "    void signalEvent(ev::sig& signal, int revents);\n"
+              "};\n"
+              "\n"
+              "EventEngine::EventEngine() {\n"
+              "    mSigWatcher.set<EventEngine, &EventEngine::signalEvent>(this);\n"
+              "}\n"
+              "\n"
+              "void EventEngine::signalEvent(ev::sig& signal, int revents) {\n"
+              "    switch (signal.signum) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:10:48] -> [test.cpp:13:40]: (style) Parameter 'signal' can be declared as reference to const. However it seems that 'signalEvent' is a callback function, if 'signal' is declared with const you might also need to cast function pointer(s). [constParameterCallback]\n", errout_str());
+
+        check("void f(int* p) {}\n" // 12843
+              "void g(std::map<void(*)(int*), int>&m) {\n"
+              "    m[&f] = 0;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:1:13]: (style) Parameter 'p' can be declared as pointer to const. "
+                      "However it seems that 'f' is a callback function, if 'p' is declared with const you might also need to cast function pointer(s). [constParameterCallback]\n",
+                      errout_str());
+
+        check("struct S { explicit S(std::function<void(std::string)>); };\n" // #13338
+              "void cb(std::string s) {\n"
+              "    (void)s.empty();\n"
+              "}\n"
+              "void f() {\n"
+              "    S s2{ cb };\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:11] -> [test.cpp:2:21]: (performance) Function parameter 's' should be passed by const reference. However it seems that 'cb' is a callback function. [passedByValueCallback]\n", errout_str());
+    }
+
+    void constPointer() {
+        check("void foo(int *p) { return *p; }");
+        ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
+
+        check("void foo(int *p) { x = *p; }");
+        ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
+
+        check("void foo(int *p) { int &ref = *p; ref = 12; }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo(int *p) { x = *p + 10; }");
+        ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
+
+        check("void foo(int *p) { return p[10]; }");
+        ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
+
+        check("void foo(int *p) { int &ref = p[0]; ref = 12; }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo(int *p) { x[*p] = 12; }");
+        ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
+
+        check("void foo(int *p) { if (p) {} }");
+        ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
+
+        check("void foo(int *p) { if (p || x) {} }");
+        ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
+
+        check("void foo(int *p) { if (p == 0) {} }");
+        ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
+
+        check("void foo(int *p) { if (!p) {} }");
+        ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
+
+        check("void foo(int *p) { if (*p > 123) {} }");
+        ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
+
+        check("void foo(int *p) { return *p + 1; }");
+        ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
+
+        check("void foo(int *p) { return *p > 1; }");
+        ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
+
+        check("void foo(const int* c) { if (c == 0) {}; }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct a { void b(); };\n"
+              "struct c {\n"
+              "    a* d;\n"
+              "    a& g() { return *d; }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct a { void b(); };\n"
+              "struct c { a* d; };\n"
+              "void e(c);\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct V {\n"
+              "    V& get(typename std::vector<V>::size_type i, std::vector<V>* arr) {\n"
+              "        return arr->at(i);\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {};\n"
+              "struct B : A {};\n"
+              "B* f(A* x) {\n"
+              "    return static_cast<B*>(x);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(std::vector<int>* x) {\n"
+              "    int& i = (*x)[0];\n"
+              "    i++;\n"
+              "    return i;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A { int a; };\n"
+              "A f(std::vector<A>* x) {\n"
+              "    x->front().a = 1;\n"
+              "    return x->front();\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::vector<int>* v) {\n"
+              "    for(auto&& x:*v)\n"
+              "        x = 1;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "    int* x;\n"
+              "    A(int* y) : x(y)\n"
+              "    {}\n"
+              "};");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(bool b, int* x, int* y) {\n"
+              "  int* z = x;\n"
+              "  int* w = b ? y : z;\n"
+              "  *w = 1;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(bool b, int* x, int* y) {\n"
+              "  int& z = *x;\n"
+              "  int& w = b ? *y : z;\n"
+              "  w = 1;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("class Base { virtual void dostuff(int *p) = 0; };\n" // #10397
+              "class Derived: public Base { int x; void dostuff(int *p) override { x = *p; } };");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct Data { char buf[128]; };\n" // #10483
+              "void encrypt(Data& data) {\n"
+              "    const char a[] = \"asfasd\";\n"
+              "    memcpy(data.buf, &a, sizeof(a));\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10547
+        check("void foo(std::istream &istr) {\n"
+              "  unsigned char x[2];\n"
+              "  istr >> x[0];\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10744
+        check("S& f() {\n"
+              "    static S* p = new S();\n"
+              "    return *p;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10471
+        check("void f(std::array<int, 1> const& i) {\n"
+              "    if (i[0] == 0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10466
+        check("typedef void* HWND;\n"
+              "void f(const std::vector<HWND>&v) {\n"
+              "    for (const auto* h : v)\n"
+              "        if (h) {}\n"
+              "    for (const auto& h : v)\n"
+              "        if (h) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:5:22]: (style) Variable 'h' can be declared as pointer to const [constVariableReference]\n",
+            errout_str());
+
+        check("void f(const std::vector<int*>& v) {\n"
+              "    for (const auto& p : v)\n"
+              "        if (p == nullptr) {}\n"
+              "    for (const auto* p : v)\n"
+              "        if (p == nullptr) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:2:22]: (style) Variable 'p' can be declared as pointer to const [constVariableReference]\n",
+            errout_str());
+
+        check("void f(std::vector<int*>& v) {\n"
+              "    for (const auto& p : v)\n"
+              "        if (p == nullptr) {}\n"
+              "    for (const auto* p : v)\n"
+              "        if (p == nullptr) {}\n"
+              "    for (const int* const& p : v)\n"
+              "        if (p == nullptr) {}\n"
+              "    for (const int* p : v)\n"
+              "        if (p == nullptr) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:27]: (style) Parameter 'v' can be declared as reference to const [constParameterReference]\n"
+                      "[test.cpp:2:22]: (style) Variable 'p' can be declared as pointer to const [constVariableReference]\n",
+                      errout_str());
+
+        check("void f(std::vector<const int*>& v) {\n"
+              "    for (const auto& p : v)\n"
+              "        if (p == nullptr) {}\n"
+              "    for (const auto* p : v)\n"
+              "        if (p == nullptr) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:33]: (style) Parameter 'v' can be declared as reference to const [constParameterReference]\n", errout_str());
+
+        check("void f(const std::vector<const int*>& v) {\n"
+              "    for (const auto& p : v)\n"
+              "        if (p == nullptr) {}\n"
+              "    for (const auto* p : v)\n"
+              "        if (p == nullptr) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const int* const p) {\n"
+              "    if (p == nullptr) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void g(int*);\n"
+              "void f(int* const* pp) {\n"
+              "    int* p = pp[0];\n"
+              "    g(p);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("template <typename T>\n"
+              "struct S {\n"
+              "    static bool f(const T& t) { return t != nullptr; }\n"
+              "};\n"
+              "S<int*> s;\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("typedef void* HWND;\n" // #11084
+              "void f(const HWND h) {\n"
+              "    if (h == nullptr) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("using HWND = void*;\n"
+              "void f(const HWND h) {\n"
+              "    if (h == nullptr) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("typedef int A;\n"
+              "void f(A* x) {\n"
+              "    if (x == nullptr) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Parameter 'x' can be declared as pointer to const [constParameterPointer]\n", errout_str());
+
+        check("using A = int;\n"
+              "void f(A* x) {\n"
+              "    if (x == nullptr) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Parameter 'x' can be declared as pointer to const [constParameterPointer]\n", errout_str());
+
+        check("struct S { void v(); };\n" // #11095
+              "void f(S* s) {\n"
+              "    (s - 1)->v();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::vector<int*>& v) {\n" // #11085
+              "    for (int* p : v) {\n"
+              "        if (p) {}\n"
+              "    }\n"
+              "    for (auto* p : v) {\n"
+              "        if (p) {}\n"
+              "    }\n"
+              "    v.clear();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:15]: (style) Variable 'p' can be declared as pointer to const [constVariablePointer]\n"
+                      "[test.cpp:5:16]: (style) Variable 'p' can be declared as pointer to const [constVariablePointer]\n",
+                      errout_str());
+
+        check("void f() {\n"
+              "    char a[1][1];\n"
+              "    char* b[1];\n"
+              "    b[0] = a[0];\n"
+              "    **b = 0;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("ptrdiff_t f(int *p0, int *p1) {\n" // #11148
+              "    return p0 - p1;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:18]: (style) Parameter 'p0' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:1:27]: (style) Parameter 'p1' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
+        check("void f() {\n"
+              "    std::array<int, 1> a{}, b{};\n"
+              "    const std::array<int, 1>& r = a;\n"
+              "    if (r == b) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {};\n" // #11599
+              "void g(S);\n"
+              "void h(const S&);\n"
+              "void h(int, int, const S&);\n"
+              "void i(S&);\n"
+              "void j(const S*);\n"
+              "void j(int, int, const S*);\n"
+              "void f1(S* s) {\n"
+              "    g(*s);\n"
+              "}\n"
+              "void f2(S* s) {\n"
+              "    h(*s);\n"
+              "}\n"
+              "void f3(S* s) {\n"
+              "    h(1, 2, *s);\n"
+              "}\n"
+              "void f4(S* s) {\n"
+              "    i(*s);\n"
+              "}\n"
+              "void f5(S& s) {\n"
+              "    j(&s);\n"
+              "}\n"
+              "void f6(S& s) {\n"
+              "    j(1, 2, &s);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:20:12]: (style) Parameter 's' can be declared as reference to const [constParameterReference]\n"
+                      "[test.cpp:23:12]: (style) Parameter 's' can be declared as reference to const [constParameterReference]\n"
+                      "[test.cpp:8:12]: (style) Parameter 's' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:11:12]: (style) Parameter 's' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:14:12]: (style) Parameter 's' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
+        check("void g(int, const int*);\n"
+              "void h(const int*);\n"
+              "void f(int* p) {\n"
+              "    g(1, p);\n"
+              "    h(p);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:13]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
+        check("void f(int, const int*);\n"
+              "void f(int i, int* p) {\n"
+              "    f(i, const_cast<const int*>(p));\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { int a; };\n"
+              "void f(std::vector<S>& v, int b) {\n"
+              "    size_t n = v.size();\n"
+              "    for (size_t i = 0; i < n; i++) {\n"
+              "        S& s = v[i];\n"
+              "        if (!(b & s.a))\n"
+              "            continue;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:12]: (style) Variable 's' can be declared as reference to const [constVariableReference]\n", errout_str()); // don't crash
+
+        check("void f(int& i) {\n"
+              "    new (&i) int();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str()); // don't crash
+
+        check("void f(int& i) {\n"
+              "    int& r = i;\n"
+              "    if (!&r) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:10]: (style) Variable 'r' can be declared as reference to const [constVariableReference]\n", errout_str()); // don't crash
+
+        check("class C;\n" // #11646
+              "void g(const C* const p);\n"
+              "void f(C* c) {\n"
+              "    g(c);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Parameter 'c' can be declared as pointer to const [constParameterPointer]\n", errout_str());
+
+        check("typedef void (*cb_t)(int*);\n" // #11674
+              "void cb(int* p) {\n"
+              "    if (*p) {}\n"
+              "}\n"
+              "void g(cb_t);\n"
+              "void f() {\n"
+              "    g(cb);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:7:7] -> [test.cpp:2:14]: (style) Parameter 'p' can be declared as pointer to const. "
+                      "However it seems that 'cb' is a callback function, if 'p' is declared with const you might also need to cast function pointer(s). [constParameterCallback]\n",
+                      errout_str());
+
+        check("typedef void (*cb_t)(int*);\n"
+              "void cb(int* p) {\n"
+              "    if (*p) {}\n"
+              "}\n"
+              "void g(cb_t);\n"
+              "void f() {\n"
+              "    g(::cb);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:7:9] -> [test.cpp:2:14]: (style) Parameter 'p' can be declared as pointer to const. "
+                      "However it seems that 'cb' is a callback function, if 'p' is declared with const you might also need to cast function pointer(s). [constParameterCallback]\n",
+                      errout_str());
+
+        check("void f1(std::vector<int>* p) {\n" // #11681
+              "    if (p->empty()) {}\n" // warn
+              "}\n"
+              "void f2(std::vector<int>* p) {\n"
+              "    p->resize(0);\n"
+              "}\n"
+              "struct S {\n"
+              "    void h1() const;\n"
+              "    void h2();\n"
+              "    int i;\n"
+              "};\n"
+              "void k(int&);\n"
+              "void g1(S* s) {\n"
+              "    s->h1();\n" // warn
+              "}\n"
+              "void g1(S* s) {\n"
+              "    s->h2();\n"
+              "}\n"
+              "void g1(S* s) {\n"
+              "    if (s->i) {}\n" // warn
+              "}\n"
+              "void g2(S* s) {\n"
+              "    s->i = 0;\n"
+              "}\n"
+              "void g3(S* s) {\n"
+              "    k(s->i);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:27]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:13:12]: (style) Parameter 's' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:19:12]: (style) Parameter 's' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
+        check("struct S {\n" // #11573
+              "    const char* g() const {\n"
+              "        return m;\n"
+              "    }\n"
+              "    const char* m;\n"
+              "};\n"
+              "struct T { std::vector<S*> v; };\n"
+              "void f(T* t, const char* n) {\n"
+              "    for (const auto* p : t->v)\n"
+              "        if (strcmp(p->g(), n) == 0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:8:11]: (style) Parameter 't' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
+        check("void f(int*& p, int* q) {\n"
+              "    p = q;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { int a[1]; };\n"
+              "void f(S* s) {\n"
+              "    if (s->a[0]) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Parameter 's' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
+        check("size_t f(char* p) {\n" // #11842
+              "    return strlen(p);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:16]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
+
+        check("void f(int* p) {\n" // #11862
+              "    long long j = *(p++);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:13]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
+        check("void f(void *p, size_t nmemb, size_t size, int (*cmp)(const void *, const void *)) {\n"
+              "    qsort(p, nmemb, size, cmp);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void g(bool *r, std::size_t *b) {\n" // #12129
+              "    if (*r && *b >= 5) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:14]: (style) Parameter 'r' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:1:30]: (style) Parameter 'b' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
+        check("void f(int i) {\n" // #12185
+              "    void* p = &i;\n"
+              "    std::cout << p << '\\n';\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Variable 'p' can be declared as pointer to const [constVariablePointer]\n",
+                      errout_str());
+
+        check("struct S { const T* t; };\n" // #12206
+              "void f(S* s) {\n"
+              "    if (s->t.i) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Parameter 's' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
+        check("void f(char *a1, char *a2) {\n" // #12252
+              "    char* b = new char[strlen(a1) + strlen(a2) + 2];\n"
+              "    sprintf(b, \"%s_%s\", a1, a2);\n"
+              "    delete[] b;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:14]: (style) Parameter 'a1' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:1:24]: (style) Parameter 'a2' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
+        check("int f(int* p) {\n" // #11713
+              "    return 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:12]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
+        check("void f(int *src, int* dst) {\n" // #12518
+              "    *dst++ = (int)*src++;\n"
+              "    *dst++ = static_cast<int>(*src++);\n"
+              "    *dst = (int)*src;\n"
+              "}\n"
+              "void g(int* dst) {\n"
+              "    (int&)*dst = 5;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:13]: (style) Parameter 'src' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
+        check("struct S {};\n"
+              "void f(T* t) {\n"
+              "    S* s = (S*)t->p;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:12]: (style) C-style pointer casting [cstyleCast]\n"
+                      "[test.cpp:3:8]: (style) Variable 's' can be declared as pointer to const [constVariablePointer]\n",
+                      errout_str()); // don't crash
+
+        check("struct S { int i; };\n" // #12205
+              "void f(S* s) {\n"
+              "    (void)s->i;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Parameter 's' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
+        check("void f(int* a, int* b, int i) {\n" // #13072
+              "    a[b[i]] = 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:21]: (style) Parameter 'b' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
+        check("int f(int* a, int* b, int i) {\n" // #13085
+              "    a[*(b + i)] = 0;\n"
+              "    return *(b + i);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:20]: (style) Parameter 'b' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
+        check("struct S { int a; };\n" // #13286
+              "void f(struct S* s) {\n"
+              "    if ((--s)->a >= 0) {}\n"
+              "}\n"
+              "void g(struct S* s) {\n"
+              "    --s;\n"
+              "    if (s->a >= 0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:18]: (style) Parameter 's' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:5:18]: (style) Parameter 's' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
+        check("struct T;\n"
+              "void use(const T*);\n"
+              "void f(T* tok0) {\n"
+              "    T *tok1 = tok0;\n"
+              "    const T *tok2 = tok1;\n"
+              "    use(tok2);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:8]: (style) Variable 'tok1' can be declared as pointer to const [constVariablePointer]\n",
+                      errout_str());
+
+        check("struct S { S* next; };\n" // #14119
+              "void f(S* s) {\n"
+              "    for (S* p = s->next; p != nullptr; p = p->next) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:13]: (style) Variable 'p' can be declared as pointer to const [constVariablePointer]\n",
+                      errout_str());
+
+        check("void f(int* p) {\n"
+              "    for (int* q = p; q;)\n"
+              "        break;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:15]: (style) Variable 'q' can be declared as pointer to const [constVariablePointer]\n",
+                      errout_str());
+
+        check("void g(const int*);\n" // #14148
+              "void f() {\n"
+              "    int a[] = {1, 2, 3};\n"
+              "    for (int* p = a; *p != 3; p++) {\n"
+              "        g(p);\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:15]: (style) Variable 'p' can be declared as pointer to const [constVariablePointer]\n",
+                      errout_str());
+
+        check("uintptr_t f(int* p) {\n"
+              "    return (uintptr_t)p;\n"
+              "}\n"
+              "uintptr_t g(int* p) {\n"
+              "    return static_cast<uintptr_t>(p);\n"
+              "}\n"
+              "U h(int* p) {\n"
+              "    return (U)p;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:18]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:4:18]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
+        check("using fp_t = int (*)(int*);\n" // #14510
+              "fp_t g_fp;\n"
+              "struct S { fp_t m_fp; };\n"
+              "void g(fp_t);\n"
+              "S f(S* s) {\n"
+              "    g_fp = [](int* p) { return *p; };\n"
+              "    s->m_fp = [](int* p) { return *p; };\n"
+              "    g([](int* p) { return *p; });\n"
+              "    auto x = [](int* p) { return *p; };\n"
+              "    g(x);\n"
+              "    return { [](int* p) { return *p; } };\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    int i = 0;\n"
+              "    auto x = [&]() { int* p = &i; if (*p) {} };\n"
+              "    x();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:27]: (style) Variable 'p' can be declared as pointer to const [constVariablePointer]\n", errout_str());
+
+        check("int f() {\n"
+              "    int i = 0;\n"
+              "    return [](int* p) { return *p; }(&i);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:20]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
+
+        check("struct S {\n" // #14571
+              "    char* c;\n"
+              "};\n"
+              "struct T {\n"
+              "    S s;\n"
+              "};\n"
+              "void f(std::string* p, T& t) {\n"
+              "    S& r = t.s;\n"
+              "    strcpy(r.c, p->c_str());\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:7:21]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n", errout_str());
+    }
+
+    void constArray() {
+        check("void f(std::array<int, 2>& a) {\n"
+              "    if (a[0]) {}\n"
+              "}\n"
+              "void g(std::array<int, 2>& a) {\n"
+              "    a.fill(0);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:28]: (style) Parameter 'a' can be declared as const array [constParameterReference]\n", errout_str());
+
+        check("int f() {\n"
+              "    static int i[1] = {};\n"
+              "    return i[0];\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:16]: (style) Variable 'i' can be declared as const array [constVariable]\n", errout_str());
+
+        check("int f() {\n"
+              "    static int i[] = { 0 };\n"
+              "    int j = i[0] + 1;\n"
+              "    return j;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:16]: (style) Variable 'i' can be declared as const array [constVariable]\n", errout_str());
+
+        check("void f(int i) {\n"
+              "    const char *tmp;\n"
+              "    char* a[] = { \"a\", \"aa\" };\n"
+              "    static char* b[] = { \"b\", \"bb\" };\n"
+              "    tmp = a[i];\n"
+              "    printf(\"%s\", tmp);\n"
+              "    tmp = b[i];\n"
+              "    printf(\"%s\", tmp);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Variable 'a' can be declared as const array [constVariable]\n"
+                      "[test.cpp:4:18]: (style) Variable 'b' can be declared as const array [constVariable]\n",
+                      errout_str());
+
+        check("int f(int i, int j) {\n" // #13069
+              "    int a[3][4] = {\n"
+              "        { 2,  2, -1, -1 },\n"
+              "        { 2, -1,  2, -1 },\n"
+              "        { 2, -1, -1,  2 },\n"
+              "    };\n"
+              "    return a[j][i];\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Variable 'a' can be declared as const array [constVariable]\n",
+                      errout_str());
+
+        check("void f(int n, int v[42]) {\n" // #12796
+              "    int j = 0;\n"
+              "    for (int i = 0; i < n; ++i) {\n"
+              "        j += 1;\n"
+              "        if (j == 1) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:19]: (style) Parameter 'v' can be declared as const array [constParameter]\n",
+                      errout_str());
+    }
+
+    void switchRedundantAssignmentTest() {
+        check("void foo()\n"
+              "{\n"
+              "    int y = 1;\n"
+              "    switch (a)\n"
+              "    {\n"
+              "    case 2:\n"
+              "        y = 2;\n"
+              "    case 3:\n"
+              "        y = 3;\n"
+              "    }\n"
+              "    bar(y);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:7:11] -> [test.cpp:9:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
+
+        check("void foo()\n"
+              "{\n"
+              "    int y = 1;\n"
+              "    switch (a)\n"
+              "    {\n"
+              "    case 2:\n"
+              "      {\n"
+              "        y = 2;\n"
+              "      }\n"
+              "    case 3:\n"
+              "        y = 3;\n"
+              "    }\n"
+              "    bar(y);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:8:11] -> [test.cpp:11:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
+
+        check("void foo()\n"
+              "{\n"
+              "    int y = 1;\n"
+              "    switch (a)\n"
+              "    {\n"
+              "    case 2:\n"
+              "        y = 2;\n"
+              "    case 3:\n"
+              "        if (x)\n"
+              "        {\n"
+              "            y = 3;\n"
+              "        }\n"
+              "    }\n"
+              "    bar(y);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo()\n"
+              "{\n"
+              "    int y = 1;\n"
+              "    switch (a)\n"
+              "    {\n"
+              "    case 2:\n"
+              "      {\n"
+              "        y = 2;\n"
+              "        if (z)\n"
+              "            printf(\"%d\", y);\n"
+              "      }\n"
+              "    case 3:\n"
+              "        y = 3;\n"
+              "    }\n"
+              "    bar(y);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo()\n"
+              "{\n"
+              "    int x = a;\n"
+              "    int y = 1;\n"
+              "    switch (x)\n"
+              "    {\n"
+              "    case 2:\n"
+              "        x = 2;\n"
+              "    case 3:\n"
+              "        y = 3;\n"
+              "    }\n"
+              "    bar(y);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo()\n"
+              "{\n"
+              "    int y = 1;\n"
+              "    switch (x)\n"
+              "    {\n"
+              "    case 2:\n"
+              "        y = 2;\n"
+              "        break;\n"
+              "    case 3:\n"
+              "        y = 3;\n"
+              "    }\n"
+              "    bar(y);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo()\n"
+              "{\n"
+              "    int y = 1;\n"
+              "    while(xyz()) {\n"
+              "        switch (x)\n"
+              "        {\n"
+              "        case 2:\n"
+              "            y = 2;\n"
+              "            continue;\n"
+              "        case 3:\n"
+              "            y = 3;\n"
+              "        }\n"
+              "        bar(y);\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo()\n"
+              "{\n"
+              "    int y = 1;\n"
+              "    while(xyz()) {\n"
+              "        switch (x)\n"
+              "        {\n"
+              "        case 2:\n"
+              "            y = 2;\n"
+              "            throw e;\n"
+              "        case 3:\n"
+              "            y = 3;\n"
+              "        }\n"
+              "        bar(y);\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo()\n"
+              "{\n"
+              "    int y = 1;\n"
+              "    switch (x)\n"
+              "    {\n"
+              "    case 2:\n"
               "        y = 2;\n"
               "        printf(\"%d\", y);\n"
               "    case 3:\n"
@@ -2220,7 +4977,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -2235,7 +4992,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:10]: (warning) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:11] -> [test.cpp:10:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
 
         check("void bar() {}\n" // bar isn't noreturn
               "void foo()\n"
@@ -2251,7 +5008,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:11]: (warning) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:11] -> [test.cpp:11:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
 
         check("void foo(int a) {\n"
               "    char str[10];\n"
@@ -2262,8 +5019,10 @@ class TestOther : public TestFixture {
               "    case 3:\n"
               "      strcpy(str, \"b'\");\n"
               "    }\n"
-              "}", nullptr, false, false, false);
-        // TODO ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:8]: (warning) Buffer 'str' is being written before its old content has been used. 'break;' missing?\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        TODO_ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:8]: (style) Buffer 'str' is being written before its old content has been used. 'break;' missing?\n",
+                           "",
+                           errout_str());
 
         check("void foo(int a) {\n"
               "    char str[10];\n"
@@ -2275,7 +5034,9 @@ class TestOther : public TestFixture {
               "      strncpy(str, \"b'\");\n"
               "    }\n"
               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:8]: (warning) Buffer 'str' is being written before its old content has been used. 'break;' missing?\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:8]: (style) Buffer 'str' is being written before its old content has been used. 'break;' missing?\n",
+                           "",
+                           errout_str());
 
         check("void foo(int a) {\n"
               "    char str[10];\n"
@@ -2289,8 +5050,10 @@ class TestOther : public TestFixture {
               "      strcpy(str, \"b'\");\n"
               "      z++;\n"
               "    }\n"
-              "}", nullptr, false, false, false);
-        // TODO ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:10]: (warning) Buffer 'str' is being written before its old content has been used. 'break;' missing?\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        TODO_ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:10]: (style) Buffer 'str' is being written before its old content has been used. 'break;' missing?\n",
+                           "",
+                           errout_str());
 
         check("void foo(int a) {\n"
               "    char str[10];\n"
@@ -2304,7 +5067,7 @@ class TestOther : public TestFixture {
               "      break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a) {\n"
               "    char str[10];\n"
@@ -2316,8 +5079,8 @@ class TestOther : public TestFixture {
               "    case 3:\n"
               "      strcpy(str, \"b'\");\n"
               "    }\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #5158 "segmentation fault (valid code)"
         check("typedef struct ct_data_s {\n"
@@ -2330,18 +5093,18 @@ class TestOther : public TestFixture {
               "} deflate_state;\n"
               "void f(deflate_state *s) {\n"
               "    s->dyn_ltree[0].fc.freq++;\n"
-              "}\n", nullptr, false, false, false);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #6132 "crash: daca: kvirc CheckOther::checkRedundantAssignment()"
-        check("void HttpFileTransfer :: transferTerminated ( bool bSuccess@1 ) {\n"
+        check("void HttpFileTransfer :: transferTerminated ( bool bSuccess ) {\n"
               "if ( m_szCompletionCallback . isNull ( ) ) {\n"
               "KVS_TRIGGER_EVENT ( KviEvent_OnHTTPGetTerminated , out ? out : ( g_pApp . activeConsole ( ) ) , & vParams )\n"
               "} else {\n"
               "KviKvsScript :: run ( m_szCompletionCallback , out ? out : ( g_pApp . activeConsole ( ) ) , & vParams ) ;\n"
               "}\n"
-              "}\n", nullptr, false, false, true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  int x;\n"
@@ -2350,7 +5113,7 @@ class TestOther : public TestFixture {
               "  case 1: x = 6; goto a;\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void switchRedundantOperationTest() {
@@ -2366,7 +5129,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:9]: (warning) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:9] -> [test.cpp:9:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2381,7 +5144,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:11]: (warning) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:9] -> [test.cpp:11:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2394,7 +5157,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2407,7 +5170,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2420,7 +5183,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:9]: (warning) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:9] -> [test.cpp:9:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2435,7 +5198,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:11]: (warning) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:9] -> [test.cpp:11:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2448,7 +5211,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2461,7 +5224,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2474,7 +5237,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:9]: (warning) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:10] -> [test.cpp:9:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2489,7 +5252,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:11]: (warning) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:10] -> [test.cpp:11:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2501,8 +5264,8 @@ class TestOther : public TestFixture {
               "        y++;\n"
               "    }\n"
               "    bar(y);\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2515,7 +5278,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2528,7 +5291,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:9]: (warning) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:10] -> [test.cpp:9:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2543,7 +5306,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:11]: (warning) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:10] -> [test.cpp:11:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2555,8 +5318,8 @@ class TestOther : public TestFixture {
               "        y--;\n"
               "    }\n"
               "    bar(y);\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2569,7 +5332,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2585,7 +5348,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2602,7 +5365,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
               "    int x = a;\n"
@@ -2616,7 +5379,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2630,7 +5393,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2646,7 +5409,7 @@ class TestOther : public TestFixture {
               "        bar(y);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2662,7 +5425,7 @@ class TestOther : public TestFixture {
               "        bar(y);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2676,7 +5439,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
               "    int y = 1;\n"
@@ -2690,7 +5453,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    bar(y);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:10]: (warning) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:10] -> [test.cpp:10:11]: (style) Variable 'y' is reassigned a value before the old one has been used. 'break;' missing? [redundantAssignInSwitch]\n", errout_str());
 
         check("bool f() {\n"
               "    bool ret = false;\n"
@@ -2708,10 +5471,10 @@ class TestOther : public TestFixture {
               "    ret = true;\n"
               "    return ret;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:14]: (style) Variable 'ret' is reassigned a value before the old one has been used.\n"
-                      "[test.cpp:8] -> [test.cpp:14]: (style) Variable 'ret' is reassigned a value before the old one has been used.\n"
-                      "[test.cpp:11] -> [test.cpp:14]: (style) Variable 'ret' is reassigned a value before the old one has been used.\n",
-                      errout.str());
+        ASSERT_EQUALS("[test.cpp:5:13] -> [test.cpp:14:9]: (style) Variable 'ret' is reassigned a value before the old one has been used. [redundantAssignment]\n"
+                      "[test.cpp:8:13] -> [test.cpp:14:9]: (style) Variable 'ret' is reassigned a value before the old one has been used. [redundantAssignment]\n"
+                      "[test.cpp:11:13] -> [test.cpp:14:9]: (style) Variable 'ret' is reassigned a value before the old one has been used. [redundantAssignment]\n",
+                      errout_str());
     }
 
     void switchRedundantBitwiseOperationTest() {
@@ -2727,7 +5490,21 @@ class TestOther : public TestFixture {
               "        break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (warning) Redundant bitwise operation on 'y' in 'switch' statement. 'break;' missing?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:9]: (style) Redundant bitwise operation on 'y' in 'switch' statement. 'break;' missing? [redundantBitwiseOperationInSwitch]\n", errout_str());
+
+        check("void foo(int a)\n"
+              "{\n"
+              "    int y = 1;\n"
+              "    switch (a)\n"
+              "    {\n"
+              "    case 2:\n"
+              "        y = y | 3;\n"
+              "    case 3:\n"
+              "        y = y | 3;\n"
+              "        break;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:7:9]: (style) Redundant bitwise operation on 'y' in 'switch' statement. 'break;' missing? [redundantBitwiseOperationInSwitch]\n", errout_str());
 
         check("void foo(int a)\n"
               "{\n"
@@ -2741,7 +5518,7 @@ class TestOther : public TestFixture {
               "        break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (warning) Redundant bitwise operation on 'y' in 'switch' statement. 'break;' missing?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:9]: (style) Redundant bitwise operation on 'y' in 'switch' statement. 'break;' missing? [redundantBitwiseOperationInSwitch]\n", errout_str());
 
         check("void foo(int a)\n"
               "{\n"
@@ -2756,7 +5533,7 @@ class TestOther : public TestFixture {
               "        break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a)\n"
               "{\n"
@@ -2765,13 +5542,13 @@ class TestOther : public TestFixture {
               "    {\n"
               "    case 2:\n"
               "        y |= z;\n"
-              "        z++\n"
+              "        z++;\n"
               "    default:\n"
               "        y |= z;\n"
               "        break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a)\n"
               "{\n"
@@ -2786,7 +5563,7 @@ class TestOther : public TestFixture {
               "        break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a)\n"
               "{\n"
@@ -2801,7 +5578,7 @@ class TestOther : public TestFixture {
               "        break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:8]: (style) Variable 'y' is reassigned a value before the old one has been used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:11] -> [test.cpp:8:11]: (style) Variable 'y' is reassigned a value before the old one has been used. [redundantAssignment]\n", errout_str());
 
         check("void foo(int a)\n"
               "{\n"
@@ -2815,7 +5592,7 @@ class TestOther : public TestFixture {
               "        break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (warning) Redundant bitwise operation on 'y' in 'switch' statement. 'break;' missing?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:9]: (style) Redundant bitwise operation on 'y' in 'switch' statement. 'break;' missing? [redundantBitwiseOperationInSwitch]\n", errout_str());
 
         check("void foo(int a)\n"
               "{\n"
@@ -2830,7 +5607,7 @@ class TestOther : public TestFixture {
               "        break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a)\n"
               "{\n"
@@ -2844,7 +5621,7 @@ class TestOther : public TestFixture {
               "        break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a)\n"
               "{\n"
@@ -2858,7 +5635,7 @@ class TestOther : public TestFixture {
               "        break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a)\n"
               "{\n"
@@ -2872,7 +5649,7 @@ class TestOther : public TestFixture {
               "        break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a)\n"
               "{\n"
@@ -2886,7 +5663,7 @@ class TestOther : public TestFixture {
               "        break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void unreachableCode() {
@@ -2897,30 +5674,36 @@ class TestOther : public TestFixture {
               "            continue;\n"
               "        }\n"
               "    }\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("[test.cpp:5]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:5:13]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         check("int foo(int a) {\n"
               "    return 0;\n"
               "    return(a-1);\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("[test.cpp:3]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:3:5]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         check("int foo(int a) {\n"
               "  A:"
               "    return(0);\n"
               "    goto A;\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("[test.cpp:3]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:3:5]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
+
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <function name=\"exit\">\n"
+                                   "    <noreturn>true</noreturn>\n"
+                                   "    <arg nr=\"1\"/>\n"
+                                   "  </function>\n"
+                                   "</def>";
+        /*const*/ Settings settings = settingsBuilder().libraryxml(xmldata).severity(Severity::style).build();
 
-        Settings settings;
-        settings.library.setnoreturn("exit", true);
-        settings.library.functions["exit"].argumentChecks[1] = Library::ArgumentChecks();
         check("void foo() {\n"
               "    exit(0);\n"
               "    break;\n"
-              "}", nullptr, false, false, false, false, &settings);
-        ASSERT_EQUALS("[test.cpp:3]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
+        ASSERT_EQUALS("[test.cpp:3:5]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         check("class NeonSession {\n"
               "    void exit();\n"
@@ -2928,17 +5711,17 @@ class TestOther : public TestFixture {
               "void NeonSession::exit()\n"
               "{\n"
               "    SAL_INFO(\"ucb.ucp.webdav\", \"neon commands cannot be aborted\");\n"
-              "}", nullptr, false, false, false, false, &settings);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
+        ASSERT_EQUALS("", errout_str());
 
         check("void NeonSession::exit()\n"
               "{\n"
               "    SAL_INFO(\"ucb.ucp.webdav\", \"neon commands cannot be aborted\");\n"
-              "}", nullptr, false, false, false, false, &settings);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
+        ASSERT_EQUALS("", errout_str());
 
-        check("void foo() { xResAccess->exit(); }", nullptr, false, false, false, false, &settings);
-        ASSERT_EQUALS("", errout.str());
+        check("void foo() { xResAccess->exit(); }", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a)\n"
               "{\n"
@@ -2951,8 +5734,8 @@ class TestOther : public TestFixture {
               "            c++;\n"
               "            break;\n"
               "         }\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("[test.cpp:7]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:7:13]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         check("void foo(int a)\n"
               "{\n"
@@ -2965,7 +5748,7 @@ class TestOther : public TestFixture {
               "            break;\n"
               "         }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a)\n"
               "{\n"
@@ -2975,8 +5758,8 @@ class TestOther : public TestFixture {
               "            break;\n"
               "          }\n"
               "       }\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("[test.cpp:6]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:6:13]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         check("void foo(int a)\n"
               "{\n"
@@ -2987,8 +5770,8 @@ class TestOther : public TestFixture {
               "          }\n"
               "          a+=2;\n"
               "       }\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("[test.cpp:6]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:6:13]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         check("void foo(int a)\n"
               "{\n"
@@ -2999,59 +5782,65 @@ class TestOther : public TestFixture {
               "          a+=2;\n"
               "       }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int foo() {\n"
               "    throw 0;\n"
               "    return 1;\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:3:5]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         check("void foo() {\n"
               "    throw 0;\n"
               "    return;\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("[test.cpp:3]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:3:5]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
+
+        check("int foo() {\n"
+              "    throw = 0;\n"
+              "    return 1;\n"
+              "}", dinit(CheckOptions, $.cpp = false, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("int foo() {\n"
               "    return 0;\n"
               "    return 1;\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("[test.cpp:3]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:3:5]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         check("int foo() {\n"
               "    return 0;\n"
               "    foo();\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("[test.cpp:3]: (style) Statements following return, break, continue, goto or throw will never be executed.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:3:5]: (style) Statements following 'return' will never be executed. [unreachableCode]\n", errout_str());
 
         check("int foo(int unused) {\n"
               "    return 0;\n"
               "    (void)unused;\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("int foo(int unused1, int unused2) {\n"
               "    return 0;\n"
               "    (void)unused1;\n"
               "    (void)unused2;\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("int foo(int unused1, int unused2) {\n"
               "    return 0;\n"
               "    (void)unused1;\n"
               "    (void)unused2;\n"
               "    foo();\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("[test.cpp:5]: (style) Statements following return, break, continue, goto or throw will never be executed.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:5:5]: (style) Statements following 'return' will never be executed. [unreachableCode]\n", errout_str());
 
         check("int foo() {\n"
               "    if(bar)\n"
               "        return 0;\n"
               "    return 124;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int foo() {\n"
               "    while(bar) {\n"
@@ -3061,16 +5850,16 @@ class TestOther : public TestFixture {
               "        return 0;\n"
               "    }\n"
               "    return 124;\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:4:9]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         check("void foo() {\n"
               "    while(bar) {\n"
               "        return;\n"
               "        break;\n"
               "    }\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:4:9]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         // #5707
         check("extern int i,j;\n"
@@ -3080,21 +5869,21 @@ class TestOther : public TestFixture {
               "    }\n"
               "    return 0;\n"
               "    j=2;\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("[test.cpp:7]: (style) Statements following return, break, continue, goto or throw will never be executed.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:7:5]: (style) Statements following 'return' will never be executed. [unreachableCode]\n", errout_str());
 
         check("int foo() {\n"
               "    return 0;\n"
               "  label:\n"
               "    throw 0;\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("[test.cpp:3]: (style) Label 'label' is not used.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:3:3]: (style) Label 'label' is not used. [unusedLabel]\n", errout_str());
 
         check("struct A {\n"
               "    virtual void foo  (P & Val) throw ();\n"
               "    virtual void foo1 (P & Val) throw ();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int foo() {\n"
               "    goto label;\n"
@@ -3103,7 +5892,7 @@ class TestOther : public TestFixture {
               "     label:\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str()); // #3457
+        ASSERT_EQUALS("", errout_str()); // #3457
 
         check("int foo() {\n"
               "    goto label;\n"
@@ -3112,7 +5901,7 @@ class TestOther : public TestFixture {
               "     label:\n"
               "    } while (true);\n"
               "}");
-        ASSERT_EQUALS("", errout.str()); // #3457
+        ASSERT_EQUALS("", errout_str()); // #3457
 
         check("int foo() {\n"
               "    goto label;\n"
@@ -3121,7 +5910,7 @@ class TestOther : public TestFixture {
               "     label:\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str()); // #3457
+        ASSERT_EQUALS("", errout_str()); // #3457
 
         // #3383. TODO: Use preprocessor
         check("int foo() {\n"
@@ -3129,25 +5918,22 @@ class TestOther : public TestFixture {
               "    return 0;\n"
               "\n" // #endif
               "    return 1;\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
         check("int foo() {\n"
               "\n" // #ifdef A
               "    return 0;\n"
               "\n" // #endif
               "    return 1;\n"
-              "}", nullptr, false, true, false);
-        ASSERT_EQUALS("[test.cpp:5]: (style, inconclusive) Consecutive return, break, continue, goto or throw statements are unnecessary.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:5]: (style, inconclusive) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n", errout_str());
 
         // #4711 lambda functions
         check("int f() {\n"
               "    return g([](int x){(void)x+1; return x;});\n"
               "}",
-              nullptr,
-              false,
-              false,
-              false);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         // #4756
         check("template <>\n"
@@ -3160,8 +5946,8 @@ class TestOther : public TestFixture {
               "             __asm__ (\"rorw $8, %w0\" : \"=r\" (__v) : \"0\" (__x) : \"cc\");\n"
               "         (void)__v;\n"
               "     }));\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         // #6008
         check("static std::function< int ( int, int ) > GetFunctor() {\n"
@@ -3169,36 +5955,271 @@ class TestOther : public TestFixture {
               "        int sum = a_ + b_;\n"
               "        return sum;\n"
               "    };\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         // #5789
         check("struct per_state_info {\n"
               "    uint64_t enter, exit;\n"
               "    uint64_t events;\n"
               "    per_state_info() : enter(0), exit(0), events(0) {}\n"
-              "};", nullptr, false, false, false);
-        ASSERT_EQUALS("", errout.str());
+              "};", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         // #6664
         check("void foo() {\n"
               "    (beat < 100) ? (void)0 : exit(0);\n"
               "    bar();\n"
-              "}", nullptr, false, false, false, false, &settings);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    (beat < 100) ? exit(0) : (void)0;\n"
               "    bar();\n"
-              "}", nullptr, false, false, false, false, &settings);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
+        ASSERT_EQUALS("", errout_str());
 
         // #8261
-        check("void foo() {\n"
-              "    (beat < 100) ? (void)0 : throw(0);\n"
-              "    bar();\n"
-              "}", nullptr, false, false, false, false, &settings);
-        ASSERT_EQUALS("", errout.str());
+        // TODO Do not throw AST validation exception
+        TODO_ASSERT_THROW(check("void foo() {\n"
+                                "    (beat < 100) ? (void)0 : throw(0);\n"
+                                "    bar();\n"
+                                "}", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings)), InternalError);
+        //ASSERT_EQUALS("", errout_str());
+
+        check("int foo() {\n"
+              "    exit(0);\n"
+              "    return 1;\n" // <- clarify for tools that function does not continue..
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    enum : uint8_t { A, B } var = A;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkP("#define INB(x) __extension__ ({ u_int tmp = (x); inb(tmp); })\n" // #4739
+               "static unsigned char cmos_hal_read(unsigned index) {\n"
+               "    unsigned short port_0, port_1;\n"
+               "    assert(!verify_cmos_byte_index(index));\n"
+               "    if (index < 128) {\n"
+               "      port_0 = 0x70;\n"
+               "      port_1 = 0x71;\n"
+               "    }\n"
+               "    else {\n"
+               "      port_0 = 0x72;\n"
+               "      port_1 = 0x73;\n"
+               "    }\n"
+               "    OUTB(index, port_0);\n"
+               "    return INB(port_1);\n"
+               "}\n", dinit(CheckPOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+
+        check("[[noreturn]] void n();\n"
+              "void f() {\n"
+              "    n();\n"
+              "    g();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:5]: (style) Statements following noreturn function 'n()' will never be executed. [unreachableCode]\n", errout_str());
+
+        check("void f() {\n"
+              "    exit(1);\n"
+              "    g();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:5]: (style) Statements following noreturn function 'exit()' will never be executed. [unreachableCode]\n", errout_str());
+
+        check("void f() {\n"
+              "    do {\n"
+              "        break;\n"
+              "        g();\n"
+              "    } while (0);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:9]: (style) Statements following 'break' will never be executed. [unreachableCode]\n", errout_str());
+
+        check("void f() {\n" // #12244
+              "    {\n"
+              "        std::cout << \"x\";\n"
+              "        return;\n"
+              "    }\n"
+              "    std::cout << \"y\";\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:5]: (style) Statements following 'return' will never be executed. [unreachableCode]\n", errout_str());
+
+        check("void f() {\n"
+              "    {\n"
+              "        std::cout << \"x\";\n"
+              "        exit(1);\n"
+              "    }\n"
+              "    std::cout << \"y\";\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:5]: (style) Statements following noreturn function 'exit()' will never be executed. [unreachableCode]\n", errout_str());
+
+        check("int f() {\n" // #13475
+              "    { return 0; };\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int i) {\n" // #13478
+              "    int x = 0;\n"
+              "    switch (i) {\n"
+              "        { case 0: x = 5; break; }\n"
+              "        { case 1: x = 7; break; }\n"
+              "    }\n"
+              "    return x;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int c) {\n"
+              "    switch (c) {\n"
+              "    case '\\n':\n"
+              "    { return 1; };\n"
+              "    default:\n"
+              "    { return c; };\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int main(int argc, char *argv[]) {\n" // #11
+              "    switch (argc) {\n"
+              "        case 0: {\n"
+              "            return 1;\n"
+              "        }\n"
+              "        break;\n"
+              "    }\n"
+              "    return 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:9]: (style) Consecutive return, break, continue, goto or throw statements are unnecessary. [duplicateBreak]\n"
+                      "[test.cpp:1:26]: (style) Parameter 'argv' can be declared as const array [constParameter]\n",
+                      errout_str());
+
+        check("int f(int i) {\n" // #13491
+              "    switch (i) {\n"
+              "    case 0:\n"
+              "        return 0;\n"
+              "        int j;\n"
+              "    case 1:\n"
+              "    case 2:\n"
+              "        j = 5;\n"
+              "        return j + i;\n"
+              "    }\n"
+              "    return 3;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int i) {\n"
+              "    switch (i) {\n"
+              "    {\n"
+              "    case 0:\n"
+              "        return 0;\n"
+              "    }\n"
+              "    {\n"
+              "        int j;\n"
+              "    case 1:\n"
+              "    case 2:\n"
+              "        j = 5;\n"
+              "        return j + i;\n"
+              "    }\n"
+              "    }\n"
+              "    return 3;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int i) {\n"
+              "    switch (i) {\n"
+              "    case 0:\n"
+              "        return 0;\n"
+              "        int a[1];\n"
+              "    case 1:\n"
+              "    case 2:\n"
+              "        a[0] = 5;\n"
+              "        return a[0] + i;\n"
+              "    }\n"
+              "    return 3;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int i) {\n"
+              "    switch (i) {\n"
+              "    case 0:\n"
+              "        return 0;\n"
+              "        int j;\n"
+              "        dostuff();\n"
+              "    case 1:\n"
+              "    case 2:\n"
+              "        j = 5;\n"
+              "        return j + i;\n"
+              "    }\n"
+              "    return 3;\n"
+              "}\n");
+        TODO_ASSERT_EQUALS("[test.cpp:6:5]: (style) Statements following 'return' will never be executed. [unreachableCode]\n", "", errout_str());
+
+        check("int f() {\n" // #13472
+              "    int var;\n"
+              "    auto int ret();\n"
+              "    int ret() {\n"
+              "        return var;\n"
+              "    }\n"
+              "    var = 42;\n"
+              "    return ret();\n"
+              "}\n", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n" // #13516
+              "    io_uring_for_each_cqe(&ring, head, cqe) {\n"
+              "        if (cqe->res == -EOPNOTSUPP)\n"
+              "            printf(\"error\");\n"
+              "        goto ok;\n"
+              "    }\n"
+              "    usleep(10000);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void redundantContinue() {
+        check("void f() {\n" // #11195
+              "    for (int i = 0; i < 10; ++i) {\n"
+              "        printf(\"i = %d\\n\", i);\n"
+              "        continue;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:9]: (style) 'continue' is redundant since it is the last statement in a loop. [redundantContinue]\n", errout_str());
+
+        check("void f() {\n"
+              "    int i = 0;"
+              "    do {\n"
+              "        ++i;\n"
+              "        printf(\"i = %d\\n\", i);\n"
+              "        continue;\n"
+              "    } while (i < 10);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:9]: (style) 'continue' is redundant since it is the last statement in a loop. [redundantContinue]\n", errout_str());
+
+        check("int f() {\n" // #13475
+              "    { return 0; };\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int i) {\n" // #13478
+              "    int x = 0;\n"
+              "    switch (i) {\n"
+              "        { case 0: x = 5; break; }\n"
+              "        { case 1: x = 7; break; }\n"
+              "    }\n"
+              "    return x;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool f(int x, int y) {\n" // #13544
+              "    switch (x) {\n"
+              "    case 1: {\n"
+              "        return y != 0;\n"
+              "        int z = y + 5;\n"
+              "        return z != 7;\n"
+              "    }\n"
+              "    }\n"
+              "    return false;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:9]: (style) Statements following 'return' will never be executed. [unreachableCode]\n", errout_str());
     }
 
 
@@ -3213,9 +6234,9 @@ class TestOther : public TestFixture {
               "            foo();\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) Found suspicious case label in switch(). Operator '&&' probably doesn't work as intended.\n"
-                      "[test.cpp:5]: (warning, inconclusive) Found suspicious case label in switch(). Operator '||' probably doesn't work as intended.\n"
-                      "[test.cpp:7]: (warning, inconclusive) Found suspicious case label in switch(). Operator '||' probably doesn't work as intended.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:15]: (warning, inconclusive) Found suspicious case label in switch(). Operator '&&' probably doesn't work as intended. [suspiciousCase]\n"
+                      "[test.cpp:5:16]: (warning, inconclusive) Found suspicious case label in switch(). Operator '||' probably doesn't work as intended. [suspiciousCase]\n"
+                      "[test.cpp:7:15]: (warning, inconclusive) Found suspicious case label in switch(). Operator '||' probably doesn't work as intended. [suspiciousCase]\n", errout_str());
 
         check("void foo() {\n"
               "    switch(a) {\n"
@@ -3223,27 +6244,28 @@ class TestOther : public TestFixture {
               "            a=A&&B;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void foo() {\n"
-              "    switch(a) {\n"
-              "        case A&&B?B:A:\n"
-              "            foo();\n"
-              "    }\n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
+        // TODO Do not throw AST validation exception
+        TODO_ASSERT_THROW(check("void foo() {\n"
+                                "    switch(a) {\n"
+                                "        case A&&B?B:A:\n"
+                                "            foo();\n"
+                                "    }\n"
+                                "}"), InternalError);
+        //ASSERT_EQUALS("", errout_str());
     }
 
     void suspiciousEqualityComparison() {
         check("void foo(int c) {\n"
               "    if (x) c == 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead? [constStatement]\n", errout_str());
 
-        check("void foo(int* c) {\n"
+        check("void foo(const int* c) {\n"
               "    if (x) *c == 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead? [constStatement]\n", errout_str());
 
 
         check("void foo(int c) {\n"
@@ -3251,90 +6273,136 @@ class TestOther : public TestFixture {
               "        c = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int c) {\n"
               "    c == 1;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:7]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead? [constStatement]\n", errout_str());
 
         check("void foo(int c) {\n"
               "    for (int i = 0; i == 10; i ++) {\n"
               "        a ++;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int c) {\n"
               "    for (i == 0; i < 10; i ++) {\n"
               "        c ++;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:12]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead? [constStatement]\n", errout_str());
 
         check("void foo(int c) {\n"
               "    for (i == 1; i < 10; i ++) {\n"
               "        c ++;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:12]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead? [constStatement]\n", errout_str());
 
         check("void foo(int c) {\n"
               "    for (i == 2; i < 10; i ++) {\n"
               "        c ++;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:12]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead? [constStatement]\n", errout_str());
 
         check("void foo(int c) {\n"
               "    for (int i = 0; i < 10; i == c) {\n"
               "        c ++;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:31]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead? [constStatement]\n", errout_str());
 
         check("void foo(int c) {\n"
               "    for (; running == 1;) {\n"
               "        c ++;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int c) {\n"
               "    printf(\"%i\", ({x==0;}));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int arg) {\n"
               "    printf(\"%i\", ({int x = do_something(); x == 0;}));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int x) {\n"
               "    printf(\"%i\", ({x == 0; x > 0 ? 10 : 20}));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:22]: (warning, inconclusive) Found suspicious equality comparison. Did you intend to assign a value instead? [constStatement]\n", errout_str());
 
         check("void foo(int x) {\n"
               "    for (const Token* end = tok->link(); tok != end; tok = (tok == end) ? end : tok->next()) {\n"
               "        x++;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int x) {\n"
               "    for (int i = (x == 0) ? 0 : 5; i < 10; i ++) {\n"
               "        x++;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int x) {\n"
               "    for (int i = 0; i < 10; i += (x == 5) ? 1 : 2) {\n"
               "        x++;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void suspiciousUnaryPlusMinus() { // #8004
+        check("int g() { return 1; }\n"
+              "void f() {\n"
+              "    +g();\n"
+              "    -g();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning, inconclusive) Found suspicious operator '+', result is not used. [constStatement]\n"
+                      "[test.cpp:4:5]: (warning, inconclusive) Found suspicious operator '-', result is not used. [constStatement]\n",
+                      errout_str());
+
+        check("void f(int i) {\n"
+              "    +i;\n"
+              "    -i;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning, inconclusive) Found suspicious operator '+', result is not used. [constStatement]\n"
+                      "[test.cpp:3:5]: (warning, inconclusive) Found suspicious operator '-', result is not used. [constStatement]\n",
+                      errout_str());
+    }
+
+    void suspiciousFloatingPointCast() {
+        check("double f(double a, double b, float c) {\n"
+              "    return a + (float)b + c;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:16]: (style) Floating-point cast causes loss of precision. [suspiciousFloatingPointCast]\n", errout_str());
+
+        check("double f(double a, double b, float c) {\n"
+              "    return a + static_cast<float>(b) + c;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:34]: (style) Floating-point cast causes loss of precision. [suspiciousFloatingPointCast]\n", errout_str());
+
+        check("long double f(long double a, long double b, float c) {\n"
+              "    return a + (double)b + c;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:16]: (style) Floating-point cast causes loss of precision. [suspiciousFloatingPointCast]\n", errout_str());
+
+        check("void g(int, double);\n"
+              "void h(double);\n"
+              "void f(double d) {\n"
+              "    g(1, (float)d);\n"
+              "    h((float)d);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: (style) Floating-point cast causes loss of precision. [suspiciousFloatingPointCast]\n"
+                      "[test.cpp:5:7]: (style) Floating-point cast causes loss of precision. [suspiciousFloatingPointCast]\n",
+                      errout_str());
     }
 
     void selfAssignment() {
@@ -3344,26 +6412,26 @@ class TestOther : public TestFixture {
               "    x = x;\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Redundant assignment of 'x' to itself.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: (style) Redundant assignment of 'x' to itself. [selfAssignment]\n", errout_str());
 
         check("void foo()\n"
               "{\n"
               "    int x = x;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Redundant assignment of 'x' to itself.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Redundant assignment of 'x' to itself. [selfAssignment]\n", errout_str());
 
         check("struct A { int b; };\n"
               "void foo(A* a1, A* a2) {\n"
               "    a1->b = a1->b;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Redundant assignment of 'a1->b' to itself.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Redundant assignment of 'a1->b' to itself. [selfAssignment]\n", errout_str());
 
         check("int x;\n"
               "void f()\n"
               "{\n"
               "    x = x = 3;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Redundant assignment of 'x' to itself.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: (style) Redundant assignment of 'x' to itself. [selfAssignment]\n", errout_str());
 
         // #4073 (segmentation fault)
         check("void Foo::myFunc( int a )\n"
@@ -3378,52 +6446,52 @@ class TestOther : public TestFixture {
               "    x = x + 1;\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
               "{\n"
               "        int *x = getx();\n"
               "        *x = x;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    BAR *x = getx();\n"
               "    x = x;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Redundant assignment of 'x' to itself.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:7]: (style) Redundant assignment of 'x' to itself. [selfAssignment]\n", errout_str());
 
         // #2502 - non-primitive type -> there might be some side effects
         check("void foo()\n"
               "{\n"
               "    Fred fred; fred = fred;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    x = (x == 0);"
               "    func(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) {\n"
               "    x = (x != 0);"
               "    func(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ticket #3001 - false positive
         check("void foo(int x) {\n"
               "    x = x ? x : 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #3800 - false negative when variable is extern
         check("extern int i;\n"
               "void f() {\n"
               "    i = i;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Redundant assignment of 'i' to itself.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:7]: (style) Redundant assignment of 'i' to itself. [selfAssignment]\n", errout_str());
 
         // #4291 - id for variables accessed through 'this'
         check("class Foo {\n"
@@ -3433,7 +6501,7 @@ class TestOther : public TestFixture {
               "void Foo::func() {\n"
               "    this->var = var;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (warning) Redundant assignment of 'this->var' to itself.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:15]: (style) Redundant assignment of 'this->var' to itself. [selfAssignment]\n", errout_str());
 
         check("class Foo {\n"
               "    int var;\n"
@@ -3442,7 +6510,7 @@ class TestOther : public TestFixture {
               "void Foo::func(int var) {\n"
               "    this->var = var;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6406 - designated initializer doing bogus self assignment
         check("struct callbacks {\n"
@@ -3451,8 +6519,8 @@ class TestOther : public TestFixture {
               "void something(void) {}\n"
               "void f() {\n"
               "    struct callbacks ops = { .s = ops.s };\n"
-              "}\n");
-        TODO_ASSERT_EQUALS("[test.cpp:6]: (warning) Redundant assignment of 'something' to itself.\n", "", errout.str());
+              "}");
+        TODO_ASSERT_EQUALS("[test.cpp:6]: (style) Redundant assignment of 'something' to itself.\n", "", errout_str());
 
         check("class V\n"
               "{\n"
@@ -3461,19 +6529,66 @@ class TestOther : public TestFixture {
               "    {\n"
               "        x = y = z = 0.0;\n"
               "    }\n"
-              "    V( double x, const double y, const double &z )\n"
+              "    V( double x, const double y_, const double &z_)\n"
               "    {\n"
               "        x = x; y = y; z = z;\n"
               "    }\n"
               "    double x, y, z;\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:10]: (warning) Redundant assignment of 'x' to itself.\n"
-                      "[test.cpp:10]: (warning) Redundant assignment of 'y' to itself.\n"
-                      "[test.cpp:10]: (warning) Redundant assignment of 'z' to itself.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:11]: (style) Redundant assignment of 'x' to itself. [selfAssignment]\n"
+                      "[test.cpp:10:18]: (style) Redundant assignment of 'y' to itself. [selfAssignment]\n"
+                      "[test.cpp:10:25]: (style) Redundant assignment of 'z' to itself. [selfAssignment]\n", errout_str());
 
         check("void f(int i) { i = !!i; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo() {\n"
+              "    int x = 1;\n"
+              "    int &ref = x;\n"
+              "    ref = x;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:9]: (style) Redundant assignment of 'ref' to itself. [selfAssignment]\n", errout_str());
+
+        check("class Foo {\n" // #9850
+              "    int i{};\n"
+              "    void modify();\n"
+              "    void method() {\n"
+              "        Foo copy = *this;\n"
+              "        modify();\n"
+              "        *this = copy;\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
 
+        check("struct S {\n" // #11383
+              "    void f() {\n"
+              "        int x = 42;"
+              "        auto l2 = [i = i, x, y = 0]() { return i + x + y; };\n"
+              "    }\n"
+              "    int i;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n" // #10337
+              "    int b[2] = { 1, 2 };\n"
+              "    int idx = 0;\n"
+              "    int& i = b[idx];\n"
+              "    idx++;\n"
+              "    i = b[idx];\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void g(int*);\n" // #12390
+              "void f() {\n"
+              "    int o = s.i;\n"
+              "    g(&s.i);\n"
+              "    s.i = o;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int N;\n" // #14234
+              "void f() { ::N = N; }\n");
+        ASSERT_EQUALS("[test.cpp:2:16]: (style) Redundant assignment of '::N' to itself. [selfAssignment]\n", errout_str());
     }
 
     void trac1132() {
@@ -3494,9 +6609,8 @@ class TestOther : public TestFixture {
               "    Lock(123);\n"
               "    std::cout << \"hello\" << std::endl;\n"
               "    return 0;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:15]: (style) Instance of 'Lock' object is destroyed immediately.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:15:5]: (style) Instance of 'Lock' object is destroyed immediately. [unusedScopedObject]\n", errout_str());
     }
 
     void trac3693() {
@@ -3505,8 +6619,8 @@ class TestOther : public TestFixture {
               "    b = 300\n"
               "  };\n"
               "};\n"
-              "const int DFLT_TIMEOUT = A::b % 1000000 ;\n", nullptr, false, false, false);
-        ASSERT_EQUALS("", errout.str());
+              "const int DFLT_TIMEOUT = A::b % 1000000 ;\n", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testMisusedScopeObjectDoesNotPickFunction1() {
@@ -3514,9 +6628,8 @@ class TestOther : public TestFixture {
               "{\n"
               "    CouldBeFunction ( 123 ) ;\n"
               "    return 0 ;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testMisusedScopeObjectDoesNotPickFunction2() {
@@ -3532,9 +6645,8 @@ class TestOther : public TestFixture {
               "        error();\n"
               "        do_something();\n"
               "    }\n"
-              "};\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testMisusedScopeObjectPicksClass() {
@@ -3543,9 +6655,8 @@ class TestOther : public TestFixture {
               "{\n"
               "    NotAFunction ( 123 );\n"
               "    return 0 ;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:4]: (style) Instance of 'NotAFunction' object is destroyed immediately.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:5]: (style) Instance of 'NotAFunction' object is destroyed immediately. [unusedScopedObject]\n", errout_str());
     }
 
     void testMisusedScopeObjectPicksStruct() {
@@ -3554,9 +6665,8 @@ class TestOther : public TestFixture {
               "{\n"
               "    NotAClass ( 123 ) ;\n"
               "    return true ;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:4]: (style) Instance of 'NotAClass' object is destroyed immediately.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:5]: (style) Instance of 'NotAClass' object is destroyed immediately. [unusedScopedObject]\n", errout_str());
     }
 
     void testMisusedScopeObjectDoesNotPickIf() {
@@ -3564,9 +6674,8 @@ class TestOther : public TestFixture {
               "{\n"
               "    if ( a > b ) return c == a ;\n"
               "    return b == a ;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testMisusedScopeObjectDoesNotPickConstructorDeclaration() {
@@ -3575,9 +6684,8 @@ class TestOther : public TestFixture {
               "public:\n"
               "~Something ( ) ;\n"
               "Something ( ) ;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testMisusedScopeObjectDoesNotPickFunctor() {
@@ -3595,9 +6703,8 @@ class TestOther : public TestFixture {
               "    int a = 1;\n"
               "    IncrementFunctor()(a);\n"
               "    return a;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testMisusedScopeObjectDoesNotPickLocalClassConstructors() {
@@ -3609,9 +6716,8 @@ class TestOther : public TestFixture {
               "    };\n"
               "    Foo();\n"
               "    do_something();\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:7]: (style) Instance of 'Foo' object is destroyed immediately.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:7:5]: (style) Instance of 'Foo' object is destroyed immediately. [unusedScopedObject]\n", errout_str());
     }
 
     void testMisusedScopeObjectDoesNotPickUsedObject() {
@@ -3622,9 +6728,8 @@ class TestOther : public TestFixture {
               "\n"
               "void fn() {\n"
               "    Foo().bar();\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testMisusedScopeObjectDoesNotPickPureC() {
@@ -3639,11 +6744,11 @@ class TestOther : public TestFixture {
                             "    do_something();\n"
                             "}\n";
 
-        check(code, "test.cpp");
-        ASSERT_EQUALS("[test.cpp:7]: (style) Instance of 'cb_watch_bool' object is destroyed immediately.\n", errout.str());
+        check(code);
+        ASSERT_EQUALS("[test.cpp:7:5]: (style) Instance of 'cb_watch_bool' object is destroyed immediately. [unusedScopedObject]\n", errout_str());
 
-        check(code, "test.c");
-        ASSERT_EQUALS("", errout.str());
+        check(code, dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #2639
         check("struct stat { int a; int b; };\n"
@@ -3653,7 +6758,18 @@ class TestOther : public TestFixture {
               "    stat(\"file.txt\", &st);\n"
               "    do_something();\n"
               "}");
-        ASSERT_EQUALS("",errout.str());
+        ASSERT_EQUALS("",errout_str());
+
+        check("struct AMethodObject {\n" // #4336
+              "    AMethodObject(double, double, double);\n"
+              "};\n"
+              "struct S {\n"
+              "    static void A(double, double, double);\n"
+              "};\n"
+              "void S::A(double const a1, double const a2, double const a3) {\n"
+              "    AMethodObject(a1, a2, a3);\n"
+              "}\n");
+        ASSERT_EQUALS("",errout_str());
     }
 
     void testMisusedScopeObjectDoesNotPickNestedClass() {
@@ -3673,29 +6789,118 @@ class TestOther : public TestFixture {
                             "  do_something();\n"
                             "}\n";
 
-        check(code, "test.cpp");
-        ASSERT_EQUALS("", errout.str());
-    }
+        check(code);
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void testMisusedScopeObjectInConstructor() {
+        const char code[] = "class Foo {\n"
+                            "public:\n"
+                            "  Foo(char x) {\n"
+                            "    Foo(x, 0);\n"
+                            "    do_something();\n"
+                            "  }\n"
+                            "  Foo(char x, int y) { }\n"
+                            "};\n";
+        check(code);
+        ASSERT_EQUALS("[test.cpp:4:5]: (style) Instance of 'Foo' object is destroyed immediately. [unusedScopedObject]\n", errout_str());
+    }
+
+    void testMisusedScopeObjectStandardType() {
+        check("int g();\n"
+              "void f(int i) {\n"
+              "    int();\n"
+              "    int(0);\n"
+              "    int( g() );\n" // don't warn
+              "    int{};\n"
+              "    int{ 0 };\n"
+              "    int{ i };\n"
+              "    int{ g() };\n" // don't warn
+              "    g();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:5]: (style) Instance of 'int' object is destroyed immediately. [unusedScopedObject]\n"
+                      "[test.cpp:4:5]: (style) Instance of 'int' object is destroyed immediately. [unusedScopedObject]\n"
+                      "[test.cpp:6:5]: (style) Instance of 'int' object is destroyed immediately. [unusedScopedObject]\n"
+                      "[test.cpp:7:5]: (style) Instance of 'int' object is destroyed immediately. [unusedScopedObject]\n"
+                      "[test.cpp:8:5]: (style) Instance of 'int' object is destroyed immediately. [unusedScopedObject]\n",
+                      errout_str());
+
+        check("void f(int j) {\n"
+              "    for (; bool(j); ) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void g() {\n"
+              "    float (f);\n"
+              "    float (*p);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int i) {\n"
+              "    void();\n"
+              "    return i;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void testMisusedScopeObjectNamespace() {
+        check("namespace M {\n" // #4779
+              "    namespace N {\n"
+              "        struct S {};\n"
+              "    }\n"
+              "}\n"
+              "int f() {\n"
+              "    M::N::S();\n"
+              "    return 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:7:11]: (style) Instance of 'M::N::S' object is destroyed immediately. [unusedScopedObject]\n", errout_str());
+
+        check("void f() {\n" // #10057
+              "    std::string(\"abc\");\n"
+              "    std::string{ \"abc\" };\n"
+              "    std::pair<int, int>(1, 2);\n"
+              "    (void)0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:10]: (style) Instance of 'std::string' object is destroyed immediately. [unusedScopedObject]\n"
+                      "[test.cpp:3:10]: (style) Instance of 'std::string' object is destroyed immediately. [unusedScopedObject]\n"
+                      "[test.cpp:4:10]: (style) Instance of 'std::pair' object is destroyed immediately. [unusedScopedObject]\n",
+                      errout_str());
 
-    void testMisusedScopeObjectInConstructor() {
-        const char code[] = "class Foo {\n"
-                            "public:\n"
-                            "  Foo(char x) {\n"
-                            "    Foo(x, 0);\n"
-                            "    do_something();\n"
-                            "  }\n"
-                            "  Foo(char x, int y) { }\n"
-                            "};\n";
-        check(code, "test.cpp");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Instance of 'Foo' object is destroyed immediately.\n", errout.str());
+        check("struct S {\n" // #10083
+              "    void f() {\n"
+              "        std::lock_guard<std::mutex>(m);\n"
+              "    }\n"
+              "    void g() {\n"
+              "        std::scoped_lock<std::mutex>(m);\n"
+              "    }\n"
+              "    void h() {\n"
+              "        std::scoped_lock(m);\n"
+              "    }\n"
+              "    std::mutex m;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:14]: (style) Instance of 'std::lock_guard' object is destroyed immediately. [unusedScopedObject]\n"
+                      "[test.cpp:6:14]: (style) Instance of 'std::scoped_lock' object is destroyed immediately. [unusedScopedObject]\n"
+                      "[test.cpp:9:14]: (style) Instance of 'std::scoped_lock' object is destroyed immediately. [unusedScopedObject]\n",
+                      errout_str());
+
+        check("struct S { int i; };\n"
+              "namespace {\n"
+              "    S s() { return ::S{42}; }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void testMisusedScopeObjectNoCodeAfter() {
-        check("class Foo {};\n"
-              "void f() {\n"
-              "  Foo();\n" // No code after class => don't warn
-              "}", "test.cpp");
-        ASSERT_EQUALS("", errout.str());
+    void testMisusedScopeObjectAssignment() { // #11371
+        check("struct S;\n"
+              "S f();\n"
+              "S& g();\n"
+              "S&& h();\n"
+              "S* i();\n"
+              "void t0() { f() = {}; }\n"
+              "void t1() { g() = {}; }\n"
+              "void t2() { h() = {}; }\n"
+              "void t3() { *i() = {}; }\n");
+        ASSERT_EQUALS("[test.cpp:6:19]: (style) Instance of 'S' object is destroyed immediately, assignment has no effect. [unusedScopedObject]\n", errout_str());
     }
 
     void trac2084() {
@@ -3705,9 +6910,8 @@ class TestOther : public TestFixture {
               "\n"
               "    { sigaction(SIGHUP, &sa, 0); };\n"
               "    { sigaction(SIGINT, &sa, 0); };\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void trac2071() {
@@ -3717,60 +6921,77 @@ class TestOther : public TestFixture {
               "    };\n"
               "\n"
               "    const AB ab[3] = { AB(0), AB(1), AB(2) };\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void clarifyCalculation() {
         check("int f(char c) {\n"
               "    return 10 * (c == 0) ? 1 : 2;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Clarify calculation precedence for '*' and '?'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:26]: (style) Clarify calculation precedence for '*' and '?'. [clarifyCalculation]\n", errout_str());
 
         check("void f(char c) {\n"
               "    printf(\"%i\", 10 * (c == 0) ? 1 : 2);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Clarify calculation precedence for '*' and '?'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:32]: (style) Clarify calculation precedence for '*' and '?'. [clarifyCalculation]\n", errout_str());
 
         check("void f() {\n"
               "    return (2*a)?b:c;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(char c) {\n"
-              "    printf(\"%i\", 1 + 1 ? 1 : 2);\n" // "1+1" is simplified away
-              "}",nullptr,false,false,false);
-        ASSERT_EQUALS("[test.cpp:2]: (style) Clarify calculation precedence for '+' and '?'.\n", errout.str());
+              "    printf(\"%i\", a + b ? 1 : 2);\n"
+              "}",dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:2:24]: (style) Clarify calculation precedence for '+' and '?'. [clarifyCalculation]\n", errout_str());
 
         check("void f() {\n"
-              "    std::cout << x << 1 ? 2 : 3;\n"
+              "    std::cout << x << y ? 2 : 3;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Clarify calculation precedence for '<<' and '?'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:25]: (style) Clarify calculation precedence for '<<' and '?'. [clarifyCalculation]\n", errout_str());
 
         check("void f() {\n"
               "    int ab = a - b ? 2 : 3;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Clarify calculation precedence for '-' and '?'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:20]: (style) Clarify calculation precedence for '-' and '?'. [clarifyCalculation]\n", errout_str());
 
         check("void f() {\n"
               "    int ab = a | b ? 2 : 3;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Clarify calculation precedence for '|' and '?'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:20]: (style) Clarify calculation precedence for '|' and '?'. [clarifyCalculation]\n", errout_str());
 
         // ticket #195
         check("int f(int x, int y) {\n"
               "    return x >> ! y ? 8 : 2;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Clarify calculation precedence for '>>' and '?'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:21]: (style) Clarify calculation precedence for '>>' and '?'. [clarifyCalculation]\n", errout_str());
 
         check("int f() {\n"
               "   return shift < sizeof(int64_t)*8 ? 1 : 2;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() { a = *p ? 1 : 2; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int x) { const char *p = x & 1 ? \"1\" : \"0\"; }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo() { x = a % b ? \"1\" : \"0\"; }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int x) { return x & 1 ? '1' : '0'; }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int x) { return x & 16 ? 1 : 0; }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int x) { return x % 16 ? 1 : 0; }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("enum {X,Y}; void f(int x) { return x & Y ? 1 : 0; }");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void clarifyStatement() {
@@ -3778,67 +6999,103 @@ class TestOther : public TestFixture {
               "    *c++;\n"
               "    return c;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'?\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:5]: (warning, inconclusive) Found suspicious operator '*', result is not used. [constStatement]\n"
+            "[test.cpp:2:7]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'? [clarifyStatement]\n",
+            errout_str());
 
         check("char* f(char** c) {\n"
               "    *c[5]--;\n"
               "    return *c;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'?\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:5]: (warning, inconclusive) Found suspicious operator '*', result is not used. [constStatement]\n"
+            "[test.cpp:2:10]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'? [clarifyStatement]\n",
+            errout_str());
 
         check("void f(Foo f) {\n"
               "    *f.a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'?\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:5]: (warning, inconclusive) Found suspicious operator '*', result is not used. [constStatement]\n"
+            "[test.cpp:2:9]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'? [clarifyStatement]\n",
+            errout_str());
 
         check("void f(Foo f) {\n"
               "    *f.a[5].v[3]++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'?\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:5]: (warning, inconclusive) Found suspicious operator '*', result is not used. [constStatement]\n"
+            "[test.cpp:2:17]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'? [clarifyStatement]\n",
+            errout_str());
 
         check("void f(Foo f) {\n"
               "    *f.a(1, 5).v[x + y]++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'?\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:5]: (warning, inconclusive) Found suspicious operator '*', result is not used. [constStatement]\n"
+            "[test.cpp:2:24]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'? [clarifyStatement]\n",
+            errout_str());
 
         check("char* f(char* c) {\n"
               "    (*c)++;\n"
               "    return c;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(char* c) {\n"
               "    bar(*c++);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("char*** f(char*** c) {\n"
               "    ***c++;\n"
               "    return c;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'?\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:5]: (warning, inconclusive) Found suspicious operator '*', result is not used. [constStatement]\n"
+            "[test.cpp:2:9]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'? [clarifyStatement]\n",
+            errout_str());
 
         check("char** f(char*** c) {\n"
               "    **c[5]--;\n"
               "    return **c;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'?\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:5]: (warning, inconclusive) Found suspicious operator '*', result is not used. [constStatement]\n"
+            "[test.cpp:2:11]: (warning) In expression like '*A++' the result of '*' is unused. Did you intend to write '(*A)++;'? [clarifyStatement]\n",
+            errout_str());
 
         check("char*** f(char*** c) {\n"
               "    (***c)++;\n"
               "    return c;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const int*** p) {\n" // #10923
+              "    delete[] **p;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
 
         check("void *f(char** c) {\n"
               "    bar(**c++);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void *f(char* p) {\n"
               "    for (p = path; *p++;) ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    std::array<std::array<double,3>,3> array;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const std::vector<int*>& v) {\n" // #12088
+              "    for (auto it = v.begin(); it != v.end(); delete *it++);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void duplicateBranch() {
@@ -3848,7 +7105,7 @@ class TestOther : public TestFixture {
               "    else\n"
               "        b = 1;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:2]: (style, inconclusive) Found duplicate branches for 'if' and 'else'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5] -> [test.cpp:2:5]: (style, inconclusive) Found duplicate branches for 'if' and 'else'. [duplicateBranch]\n", errout_str());
 
         check("void f(int a, int &b) {\n"
               "    if (a) {\n"
@@ -3859,7 +7116,7 @@ class TestOther : public TestFixture {
               "    } else\n"
               "        b = 1;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:3]: (style, inconclusive) Found duplicate branches for 'if' and 'else'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:3:9]: (style, inconclusive) Found duplicate branches for 'if' and 'else'. [duplicateBranch]\n", errout_str());
 
         check("void f(int a, int &b) {\n"
               "    if (a == 1)\n"
@@ -3871,7 +7128,7 @@ class TestOther : public TestFixture {
               "            b = 2;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:5]: (style, inconclusive) Found duplicate branches for 'if' and 'else'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:9] -> [test.cpp:5:9]: (style, inconclusive) Found duplicate branches for 'if' and 'else'. [duplicateBranch]\n", errout_str());
 
         check("int f(int signed, unsigned char value) {\n"
               "    int ret;\n"
@@ -3880,8 +7137,8 @@ class TestOther : public TestFixture {
               "    else\n"
               "        ret = (unsigned char)value;\n"
               "    return ret;\n"
-              "}", nullptr, false, false, false);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    if (b)\n"
@@ -3889,7 +7146,7 @@ class TestOther : public TestFixture {
               "    else\n"
               "        __asm__(\"mov bx, bx\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str()); // #3407
+        ASSERT_EQUALS("", errout_str()); // #3407
 
         check("void f() {\n"
               "    if (b)\n"
@@ -3897,7 +7154,7 @@ class TestOther : public TestFixture {
               "    else\n"
               "        __asm__(\"mov ax, bx\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:2]: (style, inconclusive) Found duplicate branches for 'if' and 'else'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5] -> [test.cpp:2:5]: (style, inconclusive) Found duplicate branches for 'if' and 'else'. [duplicateBranch]\n", errout_str());
     }
 
     void duplicateBranch1() {
@@ -3911,7 +7168,7 @@ class TestOther : public TestFixture {
               "  else\n"
               "    frac = front/(front-back);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:3]: (style, inconclusive) Found duplicate branches for 'if' and 'else'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:3] -> [test.cpp:3:3]: (style, inconclusive) Found duplicate branches for 'if' and 'else'. [duplicateBranch]\n", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -3920,7 +7177,7 @@ class TestOther : public TestFixture {
               "  else\n"
               "    frac = front/((front-back));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:3]: (style, inconclusive) Found duplicate branches for 'if' and 'else'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:3] -> [test.cpp:3:3]: (style, inconclusive) Found duplicate branches for 'if' and 'else'. [duplicateBranch]\n", errout_str());
 
         // No message about empty branches (#5354)
         check("void f()\n"
@@ -3930,7 +7187,7 @@ class TestOther : public TestFixture {
               "  else\n"
               "  {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void duplicateBranch2() {
@@ -3942,7 +7199,7 @@ class TestOther : public TestFixture {
                "  else\n"
                "    DOSTUFF2\n"
                "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void duplicateBranch3() {
@@ -3953,8 +7210,10 @@ class TestOther : public TestFixture {
               "    } else {\n"
               "        x = j;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:5] -> [test.cpp:3]: (style, inconclusive) Found duplicate branches for 'if' and 'else'.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:13] -> [test.cpp:5:7] -> [test.cpp:3:5]: (style, inconclusive) Found duplicate branches for 'if' and 'else'. [duplicateBranch]\n"
+                      "[test.cpp:2:9]: (style) The scope of the variable 'j' can be reduced. [variableScope]\n",
+                      errout_str());
 
         check("void f(bool b, int i) {\n"
               "    int j = i;\n"
@@ -3964,15 +7223,92 @@ class TestOther : public TestFixture {
               "    } else {\n"
               "        x = j;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void duplicateBranch4() {
+        check("void* f(bool b) {\n"
+              "    if (b) {\n"
+              "        return new A::Y(true);\n"
+              "    } else {\n"
+              "        return new A::Z(true);\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void duplicateBranch5() {
+        check("void f(bool b) {\n"
+              "    int j;\n"
+              "    if (b) {\n"
+              "        unsigned int i = 0;\n"
+              "        j = i;\n"
+              "    } else {\n"
+              "        unsigned int i = 0;\n"
+              "        j = i;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:6:7] -> [test.cpp:3:5]: (style, inconclusive) Found duplicate branches for 'if' and 'else'. [duplicateBranch]\n", errout_str());
+
+        check("void f(bool b) {\n"
+              "    int j;\n"
+              "    if (b) {\n"
+              "        unsigned int i = 0;\n"
+              "        j = i;\n"
+              "    } else {\n"
+              "        unsigned int i = 0;\n"
+              "        j = 1;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(bool b) {\n"
+              "    int j;\n"
+              "    if (b) {\n"
+              "        unsigned int i = 0;\n"
+              "    } else {\n"
+              "        int i = 0;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(bool b) {\n"
+              "    int j;\n"
+              "    if (b) {\n"
+              "        unsigned int i = 0;\n"
+              "        j = i;\n"
+              "    } else {\n"
+              "        int i = 0;\n"
+              "        j = i;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void duplicateBranch6() {
+        check("void f(bool b) {\n"
+              "    if (b) {\n"
+              "    } else {\n"
+              "        int i = 0;\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(bool b) {\n"
+              "    if (b) {\n"
+              "        int i = 0;\n"
+              "    } else {\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void duplicateExpression1() {
         check("void foo(int a) {\n"
               "    if (a == a) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '=='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Same expression on both sides of '=='. [duplicateExpression]\n", errout_str());
 
         check("void fun(int b) {\n"
               "    return  a && a ||\n"
@@ -3981,90 +7317,90 @@ class TestOther : public TestFixture {
               "            e < e &&\n"
               "            f ;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '&&'.\n"
-                      "[test.cpp:3]: (style) Same expression on both sides of '=='.\n"
-                      "[test.cpp:4]: (style) Same expression on both sides of '>'.\n"
-                      "[test.cpp:5]: (style) Same expression on both sides of '<'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:15]: (style) Same expression on both sides of '&&'. [duplicateExpression]\n"
+                      "[test.cpp:3:15]: (style) Same expression on both sides of '=='. [duplicateExpression]\n"
+                      "[test.cpp:4:15]: (style) Same expression on both sides of '>'. [duplicateExpression]\n"
+                      "[test.cpp:5:15]: (style) Same expression on both sides of '<'. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    return a && a;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '&&'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (style) Same expression on both sides of '&&'. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    a = b && b;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '&&'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Same expression on both sides of '&&'. [duplicateExpression]\n", errout_str());
 
         check("void foo(int b) {\n"
               "    f(a,b == b);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '=='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Same expression on both sides of '=='. [duplicateExpression]\n", errout_str());
 
         check("void foo(int b) {\n"
               "    f(b == b, a);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '=='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Same expression on both sides of '=='. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if (x!=2 || x!=2) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '||'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (style) Same expression on both sides of '||'. [duplicateExpression]\n", errout_str());
 
         check("void foo(int a, int b) {\n"
               "    if ((a < b) && (b > a)) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '&&' because 'a<b' and 'b>a' represent the same value.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) Same expression on both sides of '&&' because 'a<b' and 'b>a' represent the same value. [knownConditionTrueFalse]\n", errout_str());
 
         check("void foo(int a, int b) {\n"
               "    if ((a <= b) && (b >= a)) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '&&' because 'a<=b' and 'b>=a' represent the same value.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:18]: (style) Same expression on both sides of '&&' because 'a<=b' and 'b>=a' represent the same value. [knownConditionTrueFalse]\n", errout_str());
 
         check("void foo() {\n"
               "    if (x!=2 || y!=3 || x!=2) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '||'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:22]: (style) Same expression 'x!=2' found multiple times in chain of '||' operators. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if (x!=2 && (x=y) && x!=2) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    if (a && b || a && b) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '||'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:16]: (style) Same expression on both sides of '||'. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if (a && b || b && c) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    if (a && b | b && c) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '|'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:16]: (style) Same expression on both sides of '|'. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if ((a + b) | (a + b)) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '|'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) Same expression on both sides of '|'. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if ((a | b) & (a | b)) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '&'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) Same expression on both sides of '&'. [duplicateExpression]\n", errout_str());
 
         check("void foo(int a, int b) {\n"
               "    if ((a | b) == (a | b)) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '=='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) Same expression on both sides of '=='. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if (a1[a2[c & 0xff] & 0xff]) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void d(const char f, int o, int v)\n"
               "{\n"
@@ -4072,138 +7408,141 @@ class TestOther : public TestFixture {
               "         ((f=='R') && (o == 2) && ((v < 2) || (v > 99))) ||\n"
               "         ((f=='T') && (o == 2) && ((v < 200) || (v > 9999)))) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f(int x) { return x+x; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) { while (x+=x) ; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    if (a && b && b) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '&&'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:16]: (style) Same expression on both sides of '&&'. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if (a || b || b) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '||'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:16]: (style) Same expression on both sides of '||'. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if (a / 1000 / 1000) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int foo(int i) {\n"
               "    return i/i;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '/'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (style) Same expression on both sides of '/'. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if (a << 1 << 1) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f() { return !!y; }"); // No FP
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // make sure there are not "same expression" fp when there are different casts
         check("void f(long x) { if ((int32_t)x == (int64_t)x) {} }",
-              nullptr,  // filename
-              false, // experimental
-              false, // inconclusive
-              false, // runSimpleChecks
-              false, // verbose
-              nullptr   // settings
-             );
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = false)
+              );
+        ASSERT_EQUALS("", errout_str());
 
         // make sure there are not "same expression" fp when there are different ({}) expressions
         check("void f(long x) { if (({ 1+2; }) == ({3+4;})) {} }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #5535: Reference named like its type
         check("void foo() { UMSConfig& UMSConfig = GetUMSConfiguration(); }");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Variable 'UMSConfig' can be declared with const\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:25]: (style) Variable 'UMSConfig' can be declared as reference to const [constVariableReference]\n", errout_str());
 
         // #3868 - false positive (same expression on both sides of |)
         check("void f(int x) {\n"
               "    a = x ? A | B | C\n"
               "          : A | B;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(const Bar &bar) {\n"
               "    bool a = bar.isSet() && bar->isSet();\n"
               "    bool b = bar.isSet() && bar.isSet();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Same expression on both sides of '&&'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:26]: (style) Same expression on both sides of '&&'. [duplicateExpression]\n", errout_str());
 
 
         check("void foo(int a, int b) {\n"
               "    if ((b + a) | (a + b)) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '|' because 'b+a' and 'a+b' represent the same value.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) Same expression on both sides of '|' because 'b+a' and 'a+b' represent the same value. [duplicateExpression]\n", errout_str());
 
         check("void foo(const std::string& a, const std::string& b) {\n"
               "  return a.find(b+\"&\") || a.find(\"&\"+b);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a, int b) {\n"
               "    if ((b > a) | (a > b)) {}\n" // > is not commutative
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(double a, double b) {\n"
               "    if ((b + a) > (a + b)) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) The expression 'b+a > a+b' is always false because 'b+a' and 'a+b' represent the same value.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) The comparison 'b+a > a+b' is always false because 'b+a' and 'a+b' represent the same value. [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int x) {\n"
               "    if ((x == 1) && (x == 0x00000001))\n"
               "        a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '&&'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:18]: (style) Same expression on both sides of '&&' because 'x==1' and 'x==0x00000001' represent the same value. [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "    enum { Four = 4 };\n"
               "    if (Four == 4) {}"
-              "}", nullptr, false, true, false);
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:14]: (style) The comparison 'Four == 4' is always true. [knownConditionTrueFalse]\n",
+                      errout_str());
 
         check("void f() {\n"
               "    enum { Four = 4 };\n"
               "    static_assert(Four == 4, \"\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    enum { Four = 4 };\n"
+              "    _Static_assert(Four == 4, \"\");\n"
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    enum { Four = 4 };\n"
               "    static_assert(4 == Four, \"\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    enum { FourInEnumOne = 4 };\n"
               "    enum { FourInEnumTwo = 4 };\n"
               "    if (FourInEnumOne == FourInEnumTwo) {}\n"
-              "}", nullptr, false, true, false);
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:23]: (style) The comparison 'FourInEnumOne == FourInEnumTwo' is always true because 'FourInEnumOne' and 'FourInEnumTwo' represent the same value. [knownConditionTrueFalse]\n",
+                      errout_str());
 
         check("void f() {\n"
               "    enum { FourInEnumOne = 4 };\n"
               "    enum { FourInEnumTwo = 4 };\n"
               "    static_assert(FourInEnumOne == FourInEnumTwo, \"\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(int a, int b) {\n"
               "    if (sizeof(a) == sizeof(a)) { }\n"
               "    if (sizeof(a) == sizeof(b)) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '=='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:19]: (style) Same expression on both sides of '=='. [duplicateExpression]\n", errout_str());
 
         check("float bar(int) __attribute__((pure));\n"
               "char foo(int) __attribute__((pure));\n"
@@ -4212,7 +7551,7 @@ class TestOther : public TestFixture {
               "    if (unknown(a) == unknown(a)) { }\n"
               "    if (foo(a) == foo(a)) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (style) Same expression on both sides of '=='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:16]: (style) Same expression on both sides of '=='. [duplicateExpression]\n", errout_str());
     }
 
     void duplicateExpression2() { // check if float is NaN or Inf
@@ -4222,45 +7561,42 @@ class TestOther : public TestFixture {
               "    if (flt != flt) have_nan = 1;\n"
               "    return have_nan;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("float f(float x) { return x-x; }"); // ticket #4485 (Inf)
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("float f(float x) { return (X double)x == (X double)x; }", nullptr, false, false, false);
-        ASSERT_EQUALS("", errout.str());
+        check("float f(float x) { return (X double)x == (X double)x; }", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("struct X { float f; };\n"
               "float f(struct X x) { return x.f == x.f; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct X { int i; };\n"
               "int f(struct X x) { return x.i == x.i; }");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '=='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:32]: (style) Same expression on both sides of '=='. [duplicateExpression]\n", errout_str());
 
         // #5284 - when type is unknown, assume it's float
         check("int f() { return x==x; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void duplicateExpression3() {
-        Settings settings;
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def>\n"
-                               "  <function name=\"mystrcmp\">\n"
-                               "    <pure/>\n"
-                               "    <arg nr=\"1\"/>\n"
-                               "    <arg nr=\"2\"/>\n"
-                               "  </function>\n"
-                               "</def>";
-        tinyxml2::XMLDocument doc;
-        doc.Parse(xmldata, sizeof(xmldata));
-        settings.library.load(doc);
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<def>\n"
+                                   "  <function name=\"mystrcmp\">\n"
+                                   "    <pure/>\n"
+                                   "    <arg nr=\"1\"/>\n"
+                                   "    <arg nr=\"2\"/>\n"
+                                   "  </function>\n"
+                                   "</def>";
+        /*const*/ Settings settings = settingsBuilder().libraryxml(xmldata).severity(Severity::style).build();
 
         check("void foo() {\n"
               "    if (x() || x()) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A {\n"
               "  void foo() const;\n"
@@ -4269,7 +7605,7 @@ class TestOther : public TestFixture {
               "void A::foo() const {\n"
               "    if (bar() && bar()) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (style) Same expression on both sides of '&&'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:15]: (style) Same expression on both sides of '&&'. [duplicateExpression]\n", errout_str());
 
         check("struct A {\n"
               "  void foo();\n"
@@ -4279,7 +7615,7 @@ class TestOther : public TestFixture {
               "void A::foo() {\n"
               "    if (bar() && bar()) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class B {\n"
               "    void bar(int i);\n"
@@ -4293,71 +7629,74 @@ class TestOther : public TestFixture {
               "    if (b.bar(1) && b.bar(1)) {}\n"
               "    if (a.bar(1) && a.bar(1)) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:11]: (style) Same expression on both sides of '&&'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:11:18]: (style) Same expression on both sides of '&&'. [duplicateExpression]\n", errout_str());
 
         check("class D { void strcmp(); };\n"
               "void foo() {\n"
               "    D d;\n"
               "    if (d.strcmp() && d.strcmp()) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    if ((mystrcmp(a, b) == 0) || (mystrcmp(a, b) == 0)) {}\n"
-              "}", "test.cpp", false, false, true, false, &settings);
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '||'.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false, $.settings = &settings));
+        ASSERT_EQUALS("[test.cpp:2:31]: (style) Same expression on both sides of '||'. [duplicateExpression]\n", errout_str());
 
         check("void GetValue() { return rand(); }\n"
               "void foo() {\n"
               "    if ((GetValue() == 0) || (GetValue() == 0)) { dostuff(); }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void __attribute__((const)) GetValue() { return X; }\n"
               "void foo() {\n"
               "    if ((GetValue() == 0) || (GetValue() == 0)) { dostuff(); }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Same expression on both sides of '||'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:27]: (style) Same expression on both sides of '||'. [duplicateExpression]\n", errout_str());
 
         check("void GetValue() __attribute__((const));\n"
               "void GetValue() { return X; }\n"
               "void foo() {\n"
               "    if ((GetValue() == 0) || (GetValue() == 0)) { dostuff(); }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Same expression on both sides of '||'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:27]: (style) Same expression on both sides of '||'. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if (str == \"(\" || str == \"(\") {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '||'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:20]: (style) Same expression on both sides of '||'. [duplicateExpression]\n", errout_str());
 
         check("void foo() {\n"
               "    if (bar(a) && !strcmp(a, b) && bar(a) && !strcmp(a, b)) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #5334
         check("void f(C *src) {\n"
               "    if (x<A*>(src) || x<B*>(src))\n"
               "        a++;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(A *src) {\n"
               "    if (dynamic_cast<B*>(src) || dynamic_cast<B*>(src)) {}\n"
-              "}\n", "test.cpp", false, false, false); // don't run simplifications
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '||'.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:2:31]: (style) Same expression on both sides of '||'. [duplicateExpression]\n", errout_str());
 
         // #5819
         check("Vector func(Vector vec1) {\n"
               "    return fabs(vec1 & vec1 & vec1);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("Vector func(int vec1) {\n"
               "    return fabs(vec1 & vec1 & vec1);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '&'.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:22]: (style) Same expression on both sides of '&'. [duplicateExpression]\n"
+            "[test.cpp:2:29]: (style) Same expression on both sides of '&'. [duplicateExpression]\n",   // duplicate
+            errout_str());
 
     }
 
@@ -4365,127 +7704,142 @@ class TestOther : public TestFixture {
         check("void foo() {\n"
               "    if (*a++ != b || *a++ != b) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    if (*a-- != b || *a-- != b) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assignment
         check("void f() {\n"
               "  while (*(a+=2)==*(b+=2) && *(a+=2)==*(b+=2)) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void duplicateExpression5() {  // #3749 - macros with same values
         check("void f() {\n"
               "    if ($a == $a) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        checkP("#define X 1\n"
+               "#define Y 1\n"
+               "void f() {\n"
+               "    if (X == X) {}\n"
+               "    if (X == Y) {}\n"
+               "}\n");
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Same expression on both sides of '=='. [duplicateExpression]\n", errout_str());
+
+        checkP("#define X 1\n"
+               "#define Y X\n"
+               "void f() {\n"
+               "    if (X == Y) {}\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void duplicateExpression6() {  // #4639
         check("float IsNan(float value) { return !(value == value); }\n"
               "double IsNan(double value) { return !(value == value); }\n"
               "long double IsNan(long double value) { return !(value == value); }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void duplicateExpression7() {
         check("void f() {\n"
               "    const int i = sizeof(int);\n"
               "    if ( i != sizeof (int)){}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) The expression 'i != sizeof(int)' is always false because 'i' and 'sizeof(int)' represent the same value.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:25] -> [test.cpp:3:12]: (style) The comparison 'i != sizeof(int)' is always false because 'i' and 'sizeof(int)' represent the same value. [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "    const int i = sizeof(int);\n"
               "    if ( sizeof (int) != i){}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) The expression 'sizeof(int) != i' is always false because 'sizeof(int)' and 'i' represent the same value.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:25] -> [test.cpp:3:23]: (style) The comparison 'sizeof(int) != i' is always false because 'sizeof(int)' and 'i' represent the same value. [knownConditionTrueFalse]\n", errout_str());
 
-        check("void f(int a = 1) { if ( a != 1){}}\n");
-        ASSERT_EQUALS("", errout.str());
+        check("void f(int a = 1) { if ( a != 1){}}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int a = 1;\n"
-              "    if ( a != 1){} \n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) The expression 'a != 1' is always false.\n", errout.str());
+              "    if ( a != 1){}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:13] -> [test.cpp:3:12]: (style) The comparison 'a != 1' is always false. [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "    int a = 1;\n"
               "    int b = 1;\n"
-              "    if ( a != b){} \n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3] -> [test.cpp:4]: (style) The expression 'a != b' is always false because 'a' and 'b' represent the same value.\n", errout.str());
+              "    if ( a != b){}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:13] -> [test.cpp:3:13] -> [test.cpp:4:12]: (style) The comparison 'a != b' is always false because 'a' and 'b' represent the same value. [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "    int a = 1;\n"
               "    int b = a;\n"
-              "    if ( a != b){} \n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (style) The expression 'a != b' is always false because 'a' and 'b' represent the same value.\n", errout.str());
+              "    if ( a != b){}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:13] -> [test.cpp:4:12]: (style) The comparison 'a != b' is always false because 'a' and 'b' represent the same value. [knownConditionTrueFalse]\n", errout_str());
 
         check("void use(int);\n"
               "void f() {\n"
               "    int a = 1;\n"
               "    int b = 1;\n"
               "    use(b);\n"
-              "    if ( a != 1){} \n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:6]: (style) The expression 'a != 1' is always false.\n", errout.str());
+              "    if ( a != 1){}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:13] -> [test.cpp:6:12]: (style) The comparison 'a != 1' is always false. [knownConditionTrueFalse]\n", errout_str());
 
         check("void use(int);\n"
               "void f() {\n"
               "    int a = 1;\n"
               "    use(a);\n"
               "    a = 2;\n"
-              "    if ( a != 1){} \n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "    if ( a != 1){}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void use(int);\n"
               "void f() {\n"
               "    int a = 2;\n"
               "    use(a);\n"
               "    a = 1;\n"
-              "    if ( a != 1){} \n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "    if ( a != 1){}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("const int a = 1;\n"
-              "    void f() {\n"
-              "    if ( a != 1){} \n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:3]: (style) The expression 'a != 1' is always false.\n", errout.str());
+              "void f() {\n"
+              "    if ( a != 1){}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:1:15] -> [test.cpp:3:12]: (style) The comparison 'a != 1' is always false. [knownConditionTrueFalse]\n", errout_str());
 
         check("int a = 1;\n"
               "    void f() {\n"
-              "    if ( a != 1){} \n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "    if ( a != 1){}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    static const int a = 1;\n"
-              "    if ( a != 1){} \n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) The expression 'a != 1' is always false.\n", errout.str());
+              "    if ( a != 1){}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:26] -> [test.cpp:3:12]: (style) The comparison 'a != 1' is always false. [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "    static int a = 1;\n"
-              "    if ( a != 1){} \n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "    if ( a != 1){}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int a = 1;\n"
               "    if ( a != 1){\n"
               "        a++;\n"
-              "    }}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) The expression 'a != 1' is always false.\n", errout.str());
+              "    }}");
+        ASSERT_EQUALS("[test.cpp:2:13] -> [test.cpp:3:12]: (style) The comparison 'a != 1' is always false. [knownConditionTrueFalse]\n", errout_str());
 
         check("void f(int b) {\n"
               "    int a = 1;\n"
@@ -4493,27 +7847,28 @@ class TestOther : public TestFixture {
               "        if ( a != 1){}\n"
               "        a++;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(bool a, bool b) {\n"
               "    const bool c = a;\n"
               "    return a && b && c;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Same expression on both sides of '&&' because 'a' and 'c' represent the same value.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:20] -> [test.cpp:3:19]: (style) Same expression 'a' found multiple times in chain of '&&' operators because 'a' and 'c' represent the same value. [knownConditionTrueFalse]\n",
+                      errout_str());
 
         // 6906
         check("void f(const bool b) {\n"
               "   const bool b1 = !b;\n"
               "   if(!b && b1){}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Same expression on both sides of '&&' because '!b' and 'b1' represent the same value.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:20] -> [test.cpp:3:10]: (style) Same expression on both sides of '&&' because '!b' and 'b1' represent the same value. [knownConditionTrueFalse]\n", errout_str());
 
         // 7284
         check("void f(void) {\n"
               "   if (a || !!a) {}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression on both sides of '||' because 'a' and '!!a' represent the same value.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:10]: (style) Same expression on both sides of '||' because 'a' and '!!a' represent the same value. [knownConditionTrueFalse]\n", errout_str());
 
         // 8205
         check("void f(int x) {\n"
@@ -4523,8 +7878,26 @@ class TestOther : public TestFixture {
               "       if (Diag==0) {}\n"
               "       break;\n"
               "   }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:15] -> [test.cpp:5:16]: (style) The comparison 'Diag == 0' is always true. [knownConditionTrueFalse]\n", errout_str());
+
+        // #9744
+        check("void f(const std::vector<int>& ints) {\n"
+              "    int i = 0;\n"
+              "    for (int p = 0; i < ints.size(); ++i) {\n"
+              "        if (p == 0) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:18] -> [test.cpp:4:15]: (style) The comparison 'p == 0' is always true. [knownConditionTrueFalse]\n", errout_str());
+
+        // #11820
+        check("unsigned f(unsigned x) {\n"
+              "    return x - !!x;\n"
+              "}\n"
+              "unsigned g(unsigned x) {\n"
+              "    return !!x - x;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:5]: (style) The expression 'Diag == 0' is always true.\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void duplicateExpression8() {
@@ -4533,25 +7906,25 @@ class TestOther : public TestFixture {
               "    int b = a;\n"
               "    a = 2;\n"
               "    if ( b != a){}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f(int * a, int i) { int b = a[i]; a[i] = 2; if ( b != a[i]){}}\n");
-        ASSERT_EQUALS("", errout.str());
+        check("void f(int * a, int i) { int b = a[i]; a[i] = 2; if ( b != a[i]){}}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f(int * a, int i) { int b = *a; *a = 2; if ( b != *a){}}\n");
-        ASSERT_EQUALS("", errout.str());
+        check("void f(int * a, int i) { int b = *a; *a = 2; if ( b != *a){}}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A { int f() const; };\n"
               "A g();\n"
               "void foo() {\n"
-              "    for (const A x = A();;) {\n"
+              "    for (A x = A();;) {\n"
               "        const int a = x.f();\n"
               "        x = g();\n"
               "        if (x.f() == a) break;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("int f(int i);\n"
               "struct A {\n"
@@ -4563,34 +7936,34 @@ class TestOther : public TestFixture {
               "    const bool x = a.f(A::B);\n"
               "    const bool y = a.f(A::C);\n"
               "    if(!x && !y) return;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("void foo() { \n"
+        check("void foo() {\n"
               "    const bool x = a.f(A::B);\n"
               "    const bool y = a.f(A::C);\n"
               "    if (!x && !y) return;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(bool * const b);\n"
-              "void foo() { \n"
+              "void foo() {\n"
               "    bool x = true;\n"
               "    bool y = true;\n"
               "    f(&x);\n"
               "    if (!x && !y) return;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    const int a = {};\n"
               "    if(a == 1) {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("volatile const int var = 42;\n"
-              "void f() { if(var == 42) {} }\n");
-        ASSERT_EQUALS("", errout.str());
+              "void f() { if(var == 42) {} }");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int a = 0;\n"
@@ -4598,8 +7971,8 @@ class TestOther : public TestFixture {
               "    c.a = &a;\n"
               "    g(&c);\n"
               "    if (a == 0) {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void duplicateExpression9() {
@@ -4608,55 +7981,236 @@ class TestOther : public TestFixture {
               "  uint16_t x = 1000;\n"
               "  uint8_t y = x;\n"
               "  if (x != y) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void duplicateExpression10() {
+        // #9485
+        check("int f() {\n"
+              "   const int a = 1;\n"
+              "   const int b = a-1;\n"
+              "   const int c = a+1;\n"
+              "   return c;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void duplicateExpression11() {
+        check("class Fred {\n"
+              "public:\n"
+              "    double getScale() const { return m_range * m_zoom; }\n"
+              "    void setZoom(double z) { m_zoom = z; }\n"
+              "    void dostuff(int);\n"
+              "private:\n"
+              "    double m_zoom;\n"
+              "    double m_range;\n"
+              "};\n"
+              "\n"
+              "void Fred::dostuff(int x) {\n"
+              "    if (x == 43) {\n"
+              "        double old_scale = getScale();\n"
+              "        setZoom(m_zoom + 1);\n"
+              "        double scale_ratio = getScale() / old_scale;\n" // <- FP
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void duplicateExpression12() { //#10026
+        check("int f(const std::vector<int> &buffer, const uint8_t index)\n"
+              "{\n"
+              "        int var = buffer[index - 1];\n"
+              "        return buffer[index - 1] - var;\n"  // <<
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:25] -> [test.cpp:4:34]: (style) Same expression on both sides of '-' because 'buffer[index-1]' and 'var' represent the same value. [duplicateExpression]\n", errout_str());
+    }
+
+    void duplicateExpression13() { //#7899
+        check("void f() {\n"
+              "    if (sizeof(long) == sizeof(long long)) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void duplicateExpression14() { //#9871
+        check("int f() {\n"
+              "    int k = 7;\n"
+              "    int* f = &k;\n"
+              "    int* g = &k;\n"
+              "    return (f + 4 != g + 4);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:14] -> [test.cpp:4:14] -> [test.cpp:5:19]: (style) The comparison 'f+4 != g+4' is always false because 'f+4' and 'g+4' represent the same value. [knownConditionTrueFalse]\n", errout_str());
+    }
+
+    void duplicateExpression15() { //#10650
+        check("bool f() {\n"
+              "    const int i = int(0);\n"
+              "    return i == 0;\n"
+              "}\n"
+              "bool g() {\n"
+              "    const int i = int{ 0 };\n"
+              "    return i == 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:22] -> [test.cpp:3:14]: (style) The comparison 'i == 0' is always true. [knownConditionTrueFalse]\n"
+                      "[test.cpp:6:22] -> [test.cpp:7:14]: (style) The comparison 'i == 0' is always true. [knownConditionTrueFalse]\n",
+                      errout_str());
+    }
+
+    void duplicateExpression16() {
+        check("void f(const std::string& a) {\n" //#10569
+              "    if ((a == \"x\") ||\n"
+              "        (a == \"42\") ||\n"
+              "        (a == \"y\") ||\n"
+              "        (a == \"42\")) {}\n"
+              "}\n"
+              "void g(const std::string& a) {\n"
+              "    if ((a == \"42\") ||\n"
+              "        (a == \"x\") ||\n"
+              "        (a == \"42\") ||\n"
+              "        (a == \"y\")) {}\n"
+              "}\n"
+              "void h(const std::string& a) {\n"
+              "    if ((a == \"42\") ||\n"
+              "        (a == \"x\") ||\n"
+              "        (a == \"y\") ||\n"
+              "        (a == \"42\")) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:28] -> [test.cpp:4:20]: (style) Same expression 'a==\"42\"' found multiple times in chain of '||' operators. [duplicateExpression]\n"
+                      "[test.cpp:7:28] -> [test.cpp:9:20]: (style) Same expression 'a==\"42\"' found multiple times in chain of '||' operators. [duplicateExpression]\n"
+                      "[test.cpp:13:28] -> [test.cpp:16:20]: (style) Same expression 'a==\"42\"' found multiple times in chain of '||' operators. [duplicateExpression]\n",
+                      errout_str());
+
+        check("void f(const char* s) {\n" // #6371
+              "    if (*s == '\x0F') {\n"
+              "        if (!s[1] || !s[2] || !s[1])\n"
+              "            break;\n"
+              "    }\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:28]: (style) Same expression '!s[1]' found multiple times in chain of '||' operators. [duplicateExpression]\n", errout_str());
+    }
+
+    void duplicateExpression17() {
+        check("enum { E0 };\n" // #12036
+              "void f() {\n"
+              "    if (0 > E0) {}\n"
+              "    if (E0 > 0) {}\n"
+              "    if (E0 == 0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) The comparison '0 > E0' is always false. [knownConditionTrueFalse]\n"
+                      "[test.cpp:4:12]: (style) The comparison 'E0 > 0' is always false. [knownConditionTrueFalse]\n"
+                      "[test.cpp:5:12]: (style) The comparison 'E0 == 0' is always true. [knownConditionTrueFalse]\n",
+                      errout_str());
+
+        check("struct S {\n" // #12040, #12044
+              "    static const int I = 0;\n"
+              "    enum { E0 };\n"
+              "    enum F { F0 };\n"
+              "    void f() {\n"
+              "        if (0 > I) {}\n"
+              "        if (0 > S::I) {}\n"
+              "        if (0 > E0) {}\n"
+              "        if (0 > S::E0) {}\n"
+              "    }\n"
+              "};\n"
+              "void g() {\n"
+              "    if (0 > S::I) {}\n"
+              "    if (0 > S::E0) {}\n"
+              "    if (0 > S::F::F0) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:26] -> [test.cpp:6:15]: (style) The comparison '0 > I' is always false. [knownConditionTrueFalse]\n"
+                      "[test.cpp:2:26] -> [test.cpp:7:15]: (style) The comparison '0 > S::I' is always false. [knownConditionTrueFalse]\n"
+                      "[test.cpp:8:15]: (style) The comparison '0 > E0' is always false. [knownConditionTrueFalse]\n"
+                      "[test.cpp:9:15]: (style) The comparison '0 > S::E0' is always false. [knownConditionTrueFalse]\n"
+                      "[test.cpp:2:26] -> [test.cpp:13:11]: (style) The comparison '0 > S::I' is always false. [knownConditionTrueFalse]\n"
+                      "[test.cpp:14:11]: (style) The comparison '0 > S::E0' is always false. [knownConditionTrueFalse]\n"
+                      "[test.cpp:15:11]: (style) The comparison '0 > S::F::F0' is always false. [knownConditionTrueFalse]\n",
+                      errout_str());
+
+        check("template<typename T, typename U>\n" // #12122
+              "void f() {\n"
+              "    static_assert(std::is_same<T, U>::value || std::is_integral<T>::value);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void duplicateExpression18() {
+        checkP("#if defined(ABC)\n" // #13218
+               "#define MACRO1 (0x1)\n"
+               "#else\n"
+               "#define MACRO1 (0)\n"
+               "#endif\n"
+               "#if defined(XYZ)\n"
+               "#define MACRO2 (0x2)\n"
+               "#else\n"
+               "#define MACRO2 (0)\n"
+               "#endif\n"
+               "#define MACRO_ALL (MACRO1 | MACRO2)\n"
+               "void f() {\n"
+               "    if (MACRO_ALL == 0) {}\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void duplicateExpression19() {
+        checkP("const int i = 0;\n"
+               "void f() {\n"
+               "    assert(i == 0);\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void duplicateExpression20() {
+        check("enum { N = 1 };\n" // #14202
+              "int f() { return N - 1; }");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void duplicateExpressionLoop() {
         check("void f() {\n"
               "    int a = 1;\n"
               "    while ( a != 1){}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) The expression 'a != 1' is always false.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:13] -> [test.cpp:3:15]: (style) The comparison 'a != 1' is always false. [knownConditionTrueFalse]\n", errout_str());
 
-        check("void f() { int a = 1; while ( a != 1){ a++; }}\n");
-        ASSERT_EQUALS("", errout.str());
+        check("void f() { int a = 1; while ( a != 1){ a++; }}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f() { int a = 1; for ( int i=0; i < 3 && a != 1; i++){ a++; }}\n");
-        ASSERT_EQUALS("", errout.str());
+        check("void f() { int a = 1; for ( int i=0; i < 3 && a != 1; i++){ a++; }}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f(int b) { int a = 1; while (b) { if ( a != 1){} b++; } a++; } \n");
-        ASSERT_EQUALS("", errout.str());
+        check("void f(int b) { int a = 1; while (b) { if ( a != 1){} b++; } a++; }");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    for(int i = 0; i < 10;) {\n"
               "        if( i != 0 ) {}\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) The expression 'i != 0' is always false.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:17] -> [test.cpp:3:15]: (style) The comparison 'i != 0' is always false. [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "    for(int i = 0; i < 10;) {\n"
               "        if( i != 0 ) {}\n"
               "        i++;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    for(int i = 0; i < 10;) {\n"
               "        if( i != 0 ) { i++; }\n"
               "        i++;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    for(int i = 0; i < 10;) {\n"
               "        if( i != 0 ) { i++; }\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int i = 0;\n"
@@ -4664,8 +8218,8 @@ class TestOther : public TestFixture {
               "        if( i != 0 ) {}\n"
               "        i++;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int b) {\n"
               "    while (b) {\n"
@@ -4673,170 +8227,391 @@ class TestOther : public TestFixture {
               "        if ( a != 1){}\n"
               "        b++;\n"
               "    }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:17] -> [test.cpp:4:16]: (style) The comparison 'a != 1' is always false. [knownConditionTrueFalse]\n", errout_str());
+
+        check("struct T {\n" // #11083
+              "    std::string m;\n"
+              "    const std::string & str() const { return m; }\n"
+              "    T* next();\n"
+              "};\n"
+              "void f(T* t) {\n"
+              "    const std::string& s = t->str();\n"
+              "    while (t && t->str() == s)\n"
+              "        t = t->next();\n"
+              "    do {\n"
+              "        t = t->next();\n"
+              "    } while (t && t->str() == s);\n"
+              "    for (; t && t->str() == s; t = t->next());\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::string &out, const std::vector<std::string> &list) {\n" // #13669
+              "    for (int i = 0, size = list.size(); i < size; i++) {\n"
+              "        out += list[i];\n"
+              "        if (size > 0 && i < (size - 2))\n"
+              "            out += \",\";\n"
+              "        else if (i == (size - 1))\n"
+              "            out += \".\";\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const std::vector<int>& v) {\n" // #14193
+              "    for (const int& r1 : v) {\n"
+              "        for (const int& r2 : v) {\n"
+              "            if (&r1 == &r2) {}\n"
+              "        }\n"
+              "    }\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (style) The expression 'a != 1' is always false.\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void duplicateExpressionTernary() { // #6391
         check("void f() {\n"
               "    return A ? x : x;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same expression in both branches of ternary operator.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:18]: (style) Same expression in both branches of ternary operator. [duplicateExpressionTernary]\n", errout_str());
 
         check("int f(bool b, int a) {\n"
               "    const int c = a;\n"
               "    return b ? a : c;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Same expression in both branches of ternary operator.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:19] -> [test.cpp:3:18]: (style) Same expression in both branches of ternary operator. [duplicateExpressionTernary]\n", errout_str());
 
         check("void f() {\n"
               "    return A ? x : z;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(unsigned char c) {\n"
               "  x = y ? (signed char)c : (unsigned char)c;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("std::string stringMerge(std::string const& x, std::string const& y) {\n" // #7938
               "    return ((x > y) ? (y + x) : (x + y));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6426
-        check("void foo(bool flag) {\n"
-              "  bar( (flag) ? ~0u : ~0ul);\n"
-              "}");
-        ASSERT_EQUALS((_settings.sizeof_int==_settings.sizeof_long)?"[test.cpp:2]: (style) Same value in both branches of ternary operator.\n":"",  errout.str());
+        {
+            const char code[] = "void foo(bool flag) {\n"
+                                "  bar( (flag) ? ~0u : ~0ul);\n"
+                                "}";
+            /*const*/ Settings settings = settings1;
+            settings.platform.sizeof_int = 4;
+            settings.platform.int_bit = 32;
+
+            settings.platform.sizeof_long = 4;
+            settings.platform.long_bit = 32;
+            check(code, dinit(CheckOptions, $.settings = &settings));
+            ASSERT_EQUALS("[test.cpp:2:21]: (style) Same value in both branches of ternary operator. [duplicateValueTernary]\n", errout_str());
+
+            settings.platform.sizeof_long = 8;
+            settings.platform.long_bit = 64;
+            check(code, dinit(CheckOptions, $.settings = &settings));
+            ASSERT_EQUALS("", errout_str());
+        }
     }
 
     void duplicateValueTernary() {
         check("void f() {\n"
               "    if( a ? (b ? false:false): false ) ;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same value in both branches of ternary operator.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:23]: (style) Same expression in both branches of ternary operator. [duplicateExpressionTernary]\n", errout_str());
 
         check("int f1(int a) {return (a == 1) ? (int)1 : 1; }");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Same value in both branches of ternary operator.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:41]: (style) Same value in both branches of ternary operator. [duplicateValueTernary]\n", errout_str());
 
         check("int f2(int a) {return (a == 1) ? (int)1 : (int)1; }");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Same value in both branches of ternary operator.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:41]: (style) Same expression in both branches of ternary operator. [duplicateExpressionTernary]\n", errout_str());
 
         check("int f3(int a) {return (a == 1) ? 1 : (int)1; }");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Same value in both branches of ternary operator.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:36]: (style) Same value in both branches of ternary operator. [duplicateValueTernary]\n", errout_str());
 
         check("int f4(int a) {return (a == 1) ? 1 : 1; }");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Same value in both branches of ternary operator.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:36]: (style) Same expression in both branches of ternary operator. [duplicateExpressionTernary]\n", errout_str());
+
+        check("int f5(int a) {return (a == (int)1) ? (int)1 : 1; }");
+        ASSERT_EQUALS("[test.cpp:1:46]: (style) Same value in both branches of ternary operator. [duplicateValueTernary]\n", errout_str());
+
+        check("int f6(int a) {return (a == (int)1) ? (int)1 : (int)1; }");
+        ASSERT_EQUALS("[test.cpp:1:46]: (style) Same expression in both branches of ternary operator. [duplicateExpressionTernary]\n", errout_str());
+
+        check("int f7(int a) {return (a == (int)1) ? 1 : (int)1; }");
+        ASSERT_EQUALS("[test.cpp:1:41]: (style) Same value in both branches of ternary operator. [duplicateValueTernary]\n", errout_str());
+
+        check("int f8(int a) {return (a == (int)1) ? 1 : 1; }");
+        ASSERT_EQUALS("[test.cpp:1:41]: (style) Same expression in both branches of ternary operator. [duplicateExpressionTernary]\n", errout_str());
+
+        check("struct Foo {\n"
+              "  std::vector<int> bar{1,2,3};\n"
+              "  std::vector<int> baz{4,5,6};\n"
+              "};\n"
+              "void f() {\n"
+              "  Foo foo;\n"
+              "  it = true ? foo.bar.begin() : foo.baz.begin();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(bool b) {\n"
+              "  std::vector<int> bar{1,2,3};\n"
+              "  std::vector<int> baz{4,5,6};\n"
+              "  std::vector<int> v = b ? bar : baz;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(bool q) {\n" // #9570
+              "    static int a = 0;\n"
+              "    static int b = 0;\n"
+              "    int& x = q ? a : b;\n"
+              "    ++x;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
 
-        check("int f5(int a) {return (a == (int)1) ? (int)1 : 1; }");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Same value in both branches of ternary operator.\n", errout.str());
+        check("struct S { int a, b; };\n" // #10107
+              "S f(bool x, S s) {\n"
+              "    (x) ? f.a = 42 : f.b = 42;\n"
+              "    return f;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
 
-        check("int f6(int a) {return (a == (int)1) ? (int)1 : (int)1; }");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Same value in both branches of ternary operator.\n", errout.str());
+        check("float f(float x) {\n" // # 11368
+              "    return (x >= 0.0) ? 0.0 : -0.0;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {};\n" // # 14300
+              "struct B {};\n"
+              "void f(bool x) {\n"
+              "    A* a = new A();\n"
+              "    B* b = new B();\n"
+              "    auto p = x ? static_cast<void*>(a) : static_cast<void*>(b);\n"
+              "    (void)p;\n"
+              "    delete a;\n"
+              "    delete b;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        check("int f7(int a) {return (a == (int)1) ? 1 : (int)1; }");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Same value in both branches of ternary operator.\n", errout.str());
+    void duplicateValueTernarySizeof() { // #13773
+        check("int f() { return x ? sizeof(uint32_t) : sizeof(unsigned int); }");
+        ASSERT_EQUALS("", errout_str());
 
-        check("int f8(int a) {return (a == (int)1) ? 1 : 1; }");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Same value in both branches of ternary operator.\n", errout.str());
+        check("int f() { return x ? sizeof(uint32_t) : sizeof(uint32_t); }");
+        ASSERT_EQUALS("[test.cpp:1:39]: (style) Same expression in both branches of ternary operator. [duplicateExpressionTernary]\n", errout_str());
     }
 
-    void duplicateExpressionTemplate() { // #6930
-        check("template <int I> void f() {\n"
+    void duplicateExpressionTemplate() {
+        check("template <int I> void f() {\n" // #6930
               "    if (I >= 0 && I < 3) {}\n"
               "}\n"
               "\n"
               "static auto a = f<0>();");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("template<typename T>\n" // #7754
+              "void f() {\n"
+              "    if (std::is_same_v<T, char> || std::is_same_v<T, unsigned char>) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("typedef long long int64_t;"
+              "template<typename T>\n"
+              "void f() {\n"
+              "    if (std::is_same_v<T, long> || std::is_same_v<T, int64_t>) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkP("#define int32_t int"
+               "template<typename T>\n"
+               "void f() {\n"
+               "    if (std::is_same_v<T, int> || std::is_same_v<T, int32_t>) {}\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkP("#define F(v) (v) != 0\n" // #12392
+               "template<class T>\n"
+               "void f() {\n"
+               "    if (F(0)) {}\n"
+               "}\n"
+               "void g() {\n"
+               "    f<int>();\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void duplicateExpressionCompareWithZero() {
+        check("void f(const int* x, bool b) {\n"
+              "    if ((x && b) || (x != 0 && b)) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:18]: (style) Same expression on both sides of '||' because 'x&&b' and 'x!=0&&b' represent the same value. [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(const int* x, bool b) {\n"
+              "    if ((x != 0 && b) || (x && b)) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:23]: (style) Same expression on both sides of '||' because 'x!=0&&b' and 'x&&b' represent the same value. [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(const int* x, bool b) {\n"
+              "    if ((x && b) || (b && x != 0)) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:18]: (style) Same expression on both sides of '||' because 'x&&b' and 'b&&x!=0' represent the same value. [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(const int* x, bool b) {\n"
+              "    if ((!x && b) || (x == 0 && b)) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:19]: (style) Same expression on both sides of '||' because '!x&&b' and 'x==0&&b' represent the same value. [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(const int* x, bool b) {\n"
+              "    if ((x == 0 && b) || (!x && b)) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:23]: (style) Same expression on both sides of '||' because 'x==0&&b' and '!x&&b' represent the same value. [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(const int* x, bool b) {\n"
+              "    if ((!x && b) || (b && x == 0)) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:19]: (style) Same expression on both sides of '||' because '!x&&b' and 'b&&x==0' represent the same value. [knownConditionTrueFalse]\n", errout_str());
+
+        check("struct A {\n"
+              "    int* getX() const;\n"
+              "    bool getB() const;\n"
+              "    void f() {\n"
+              "        if ((getX() && getB()) || (getX() != 0 && getB())) {}\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:5:32]: (style) Same expression on both sides of '||' because 'getX()&&getB()' and 'getX()!=0&&getB()' represent the same value. [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f(const int* x, bool b) {\n"
+              "    if ((x && b) || (x == 0 && b)) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const int* x, bool b) {\n"
+              "    if ((!x && b) || (x != 0 && b)) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void oppositeExpression() {
         check("void f(bool a) { if(a && !a) {} }");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Opposite expression on both sides of '&&'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:23]: (style) Opposite expression on both sides of '&&'. [oppositeExpression]\n", errout_str());
 
         check("void f(bool a) { if(a != !a) {} }");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Opposite expression on both sides of '!='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:23]: (style) Opposite expression on both sides of '!='. [oppositeExpression]\n", errout_str());
 
         check("void f(bool a) { if( a == !(a) ) {}}");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Opposite expression on both sides of '=='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:24]: (style) Opposite expression on both sides of '=='. [oppositeExpression]\n", errout_str());
 
         check("void f(bool a) { if( a != !(a) ) {}}");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Opposite expression on both sides of '!='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:24]: (style) Opposite expression on both sides of '!='. [oppositeExpression]\n", errout_str());
 
         check("void f(bool a) { if( !(a) == a ) {}}");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Opposite expression on both sides of '=='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:27]: (style) Opposite expression on both sides of '=='. [oppositeExpression]\n", errout_str());
 
         check("void f(bool a) { if( !(a) != a ) {}}");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Opposite expression on both sides of '!='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:27]: (style) Opposite expression on both sides of '!='. [oppositeExpression]\n", errout_str());
 
         check("void f(bool a) { if( !(!a) == !(a) ) {}}");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Opposite expression on both sides of '=='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:28]: (style) Opposite expression on both sides of '=='. [oppositeExpression]\n", errout_str());
 
         check("void f(bool a) { if( !(!a) != !(a) ) {}}");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Opposite expression on both sides of '!='.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:28]: (style) Opposite expression on both sides of '!='. [oppositeExpression]\n", errout_str());
 
         check("void f1(bool a) {\n"
               "    const bool b = a;\n"
               "    if( a == !(b) ) {}\n"
               "    if( b == !(a) ) {}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Opposite expression on both sides of '=='.\n"
-                      "[test.cpp:2] -> [test.cpp:4]: (style) Opposite expression on both sides of '=='.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:20] -> [test.cpp:3:11]: (style) Opposite expression on both sides of '=='. [oppositeExpression]\n"
+                      "[test.cpp:2:20] -> [test.cpp:4:11]: (style) Opposite expression on both sides of '=='. [oppositeExpression]\n", errout_str());
 
-        check("void f2(bool *a) {\n"
+        check("void f2(const bool *a) {\n"
               "    const bool b = *a;\n"
               "    if( *a == !(b) ) {}\n"
               "    if( b == !(*a) ) {}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Opposite expression on both sides of '=='.\n"
-                      "[test.cpp:2] -> [test.cpp:4]: (style) Opposite expression on both sides of '=='.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:20] -> [test.cpp:3:12]: (style) Opposite expression on both sides of '=='. [oppositeExpression]\n"
+                      "[test.cpp:2:20] -> [test.cpp:4:11]: (style) Opposite expression on both sides of '=='. [oppositeExpression]\n", errout_str());
 
         check("void f(bool a) { a = !a; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int a) { if( a < -a ) {}}");
-        ASSERT_EQUALS("[test.cpp:1]: (style) Opposite expression on both sides of '<'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:23]: (style) Opposite expression on both sides of '<'. [oppositeExpression]\n", errout_str());
 
         check("void f(int a) { a -= -a; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int a) { a = a / (-a); }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(int i){ return !((i - 1) & i); }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(unsigned i){ return (x > 0) && (x & (x-1)) == 0; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void A::f(bool a, bool c)\n"
               "{\n"
               "    const bool b = a;\n"
-              "    if(c) { a = false; } \n"
+              "    if(c) { a = false; }\n"
               "    if(b && !a) { }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(bool c) {\n"
               "    const bool b = a;\n"
-              "    if(c) { a = false; } \n"
+              "    if(c) { a = false; }\n"
               "    if(b && !a) { }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    bool x = a;\n"
               "    dostuff();\n"
               "    if (x && a) {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  const bool b = g();\n"
               "  if (!b && g()) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const bool *a) {\n"
+              "    const bool b = a[42];\n"
+              "    if( b == !(a[42]) ) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:21] -> [test.cpp:3:11]: (style) Opposite expression on both sides of '=='. [oppositeExpression]\n", errout_str());
+
+        check("void f(const bool *a) {\n"
+              "    const bool b = a[42];\n"
+              "    if( a[42] == !(b) ) {}\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:21] -> [test.cpp:3:15]: (style) Opposite expression on both sides of '=='. [oppositeExpression]\n", errout_str());
+
+        check("void f(const bool *a) {\n"
+              "    const bool b = *a;\n"
+              "    if( b == !(*a) ) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:20] -> [test.cpp:3:11]: (style) Opposite expression on both sides of '=='. [oppositeExpression]\n", errout_str());
+
+        check("void f(const bool *a) {\n"
+              "    const bool b = *a;\n"
+              "    if( *a == !(b) ) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:20] -> [test.cpp:3:12]: (style) Opposite expression on both sides of '=='. [oppositeExpression]\n", errout_str());
+
+        check("void f(uint16_t u) {\n" // #9342
+              "    if (u != (u & -u))\n"
+              "        return false;\n"
+              "    if (u != (-u & u))\n"
+              "        return false;\n"
+              "    return true;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void duplicateVarExpression() {
@@ -4846,7 +8621,7 @@ class TestOther : public TestFixture {
               "    int i = f();\n"
               "    int j = f();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:4]: (style) Same expression used in consecutive assignments of 'i' and 'j'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:4:9]: (style) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("struct Foo { int f() const; int g() const; };\n"
               "void test() {\n"
@@ -4854,7 +8629,7 @@ class TestOther : public TestFixture {
               "    int i = f.f();\n"
               "    int j = f.f();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:4]: (style) Same expression used in consecutive assignments of 'i' and 'j'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:4:9]: (style) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("struct Foo { int f() const; int g() const; };\n"
               "void test() {\n"
@@ -4863,7 +8638,7 @@ class TestOther : public TestFixture {
               "    int i = f.f();\n"
               "    int j = f.f();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:5]: (style) Same expression used in consecutive assignments of 'i' and 'j'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:9] -> [test.cpp:5:9]: (style) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("int f() __attribute__((pure));\n"
               "int g() __attribute__((pure));\n"
@@ -4871,7 +8646,7 @@ class TestOther : public TestFixture {
               "    int i = 1 + f();\n"
               "    int j = 1 + f();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:4]: (style) Same expression used in consecutive assignments of 'i' and 'j'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:4:9]: (style) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("int f() __attribute__((pure));\n"
               "int g() __attribute__((pure));\n"
@@ -4879,7 +8654,7 @@ class TestOther : public TestFixture {
               "    int i = f() + 1;\n"
               "    int j = 1 + f();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f() __attribute__((pure));\n"
               "int g() __attribute__((pure));\n"
@@ -4888,7 +8663,7 @@ class TestOther : public TestFixture {
               "    int i = x + 1;\n"
               "    int j = f() + 1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f() __attribute__((pure));\n"
               "int g() __attribute__((pure));\n"
@@ -4896,7 +8671,7 @@ class TestOther : public TestFixture {
               "    int i = f() + f();\n"
               "    int j = f() + f();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:4]: (style) Same expression used in consecutive assignments of 'i' and 'j'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:4:9]: (style) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("int f(int) __attribute__((pure));\n"
               "int g(int) __attribute__((pure));\n"
@@ -4904,7 +8679,7 @@ class TestOther : public TestFixture {
               "    int i = f(0);\n"
               "    int j = f(0);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:4]: (style) Same expression used in consecutive assignments of 'i' and 'j'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:4:9]: (style) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("int f(int) __attribute__((pure));\n"
               "int g(int) __attribute__((pure));\n"
@@ -4913,39 +8688,39 @@ class TestOther : public TestFixture {
               "    int i = f(0);\n"
               "    int j = f(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void test(int * p, int * q) {\n"
+        check("void test(const int * p, const int * q) {\n"
               "    int i = *p;\n"
               "    int j = *p;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (style) Same expression used in consecutive assignments of 'i' and 'j'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:2:9]: (style) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("struct A { int x; int y; };"
               "void test(A a) {\n"
               "    int i = a.x;\n"
               "    int j = a.x;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (style) Same expression used in consecutive assignments of 'i' and 'j'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:2:9]: (style) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("void test() {\n"
               "    int i = 0;\n"
               "    int j = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void test() {\n"
               "    int i = -1;\n"
               "    int j = -1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f(int);\n"
               "void test() {\n"
               "    int i = f(0);\n"
               "    int j = f(1);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f();\n"
               "int g();\n"
@@ -4953,21 +8728,21 @@ class TestOther : public TestFixture {
               "    int i = f() || f();\n"
               "    int j = f() && f();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Foo {};\n"
               "void test() {\n"
               "    Foo i = Foo();\n"
               "    Foo j = Foo();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Foo {};\n"
               "void test() {\n"
               "    Foo i = Foo{};\n"
               "    Foo j = Foo{};\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Foo { int f() const; float g() const; };\n"
               "void test() {\n"
@@ -4975,7 +8750,7 @@ class TestOther : public TestFixture {
               "    int i = f.f();\n"
               "    int j = f.f();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:4]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:4:9]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("struct Foo { int f(); int g(); };\n"
               "void test() {\n"
@@ -4983,43 +8758,43 @@ class TestOther : public TestFixture {
               "    int i = f.f();\n"
               "    int j = f.f();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void test() {\n"
               "    int i = f();\n"
               "    int j = f();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void test(int x) {\n"
               "    int i = ++x;\n"
               "    int j = ++x;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void test(int x) {\n"
               "    int i = x++;\n"
               "    int j = x++;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void test(int x) {\n"
               "    int i = --x;\n"
               "    int j = --x;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void test(int x) {\n"
               "    int i = x--;\n"
               "    int j = x--;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void test(int x) {\n"
               "    int i = x + 1;\n"
               "    int j = 1 + x;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void duplicateVarExpressionUnique() {
@@ -5028,26 +8803,32 @@ class TestOther : public TestFixture {
               "    int start = x->first;\n"
               "    int end   = x->first;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:3]: (style, inconclusive) Same expression used in consecutive assignments of 'start' and 'end'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:3:9]: (style, inconclusive) Same expression used in consecutive assignments of 'start' and 'end'. [duplicateAssignExpression]\n"
+                      "[test.cpp:2:14]: (style) Parameter 'x' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
         check("struct SW { int first; };\n"
               "void foo(SW* x, int i, int j) {\n"
               "    int start = x->first;\n"
               "    int end   = x->first;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:3]: (style, inconclusive) Same expression used in consecutive assignments of 'start' and 'end'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:3:9]: (style, inconclusive) Same expression used in consecutive assignments of 'start' and 'end'. [duplicateAssignExpression]\n"
+                      "[test.cpp:2:14]: (style) Parameter 'x' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
+
         check("struct Foo { int f() const; };\n"
               "void test() {\n"
               "    Foo f = Foo{};\n"
               "    int i = f.f();\n"
               "    int j = f.f();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:4]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:4:9]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
-        check("void test(int * p) {\n"
+        check("void test(const int * p) {\n"
               "    int i = *p;\n"
               "    int j = *p;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:2:9]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("struct Foo { int f() const; int g(int) const; };\n"
               "void test() {\n"
@@ -5055,7 +8836,7 @@ class TestOther : public TestFixture {
               "    int i = f.f();\n"
               "    int j = f.f();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:4]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:4:9]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("struct Foo { int f() const; };\n"
               "void test() {\n"
@@ -5063,7 +8844,7 @@ class TestOther : public TestFixture {
               "    int i = f.f();\n"
               "    int j = f.f();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:4]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:4:9]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
     }
 
     void duplicateVarExpressionAssign() {
@@ -5075,7 +8856,7 @@ class TestOther : public TestFixture {
               "    use(i);\n"
               "    i = j;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:3]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:3:9]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
 
         check("struct A { int x; int y; };"
               "void use(int);\n"
@@ -5085,7 +8866,46 @@ class TestOther : public TestFixture {
               "    use(j);\n"
               "    j = i;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:3]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9] -> [test.cpp:3:9]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n", errout_str());
+
+        check("struct A { int x; int y; };"
+              "void use(int);\n"
+              "void test(A a) {\n"
+              "    int i = a.x;\n"
+              "    int j = a.x;\n"
+              "    use(j);\n"
+              "    if (i == j) {}\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:4:9] -> [test.cpp:3:9]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n"
+            "[test.cpp:3:14] -> [test.cpp:4:14] -> [test.cpp:6:11]: (style) The comparison 'i == j' is always true because 'i' and 'j' represent the same value. [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("struct A { int x; int y; };"
+              "void use(int);\n"
+              "void test(A a) {\n"
+              "    int i = a.x;\n"
+              "    int j = a.x;\n"
+              "    use(j);\n"
+              "    if (i == a.x) {}\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:4:9] -> [test.cpp:3:9]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n"
+            "[test.cpp:3:14] -> [test.cpp:6:11]: (style) The comparison 'i == a.x' is always true because 'i' and 'a.x' represent the same value. [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("struct A { int x; int y; };"
+              "void use(int);\n"
+              "void test(A a) {\n"
+              "    int i = a.x;\n"
+              "    int j = a.x;\n"
+              "    use(i);\n"
+              "    if (j == a.x) {}\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:4:9] -> [test.cpp:3:9]: (style, inconclusive) Same expression used in consecutive assignments of 'i' and 'j'. [duplicateAssignExpression]\n"
+            "[test.cpp:4:14] -> [test.cpp:6:11]: (style) The comparison 'j == a.x' is always true because 'j' and 'a.x' represent the same value. [knownConditionTrueFalse]\n",
+            errout_str());
 
         // Issue #8612
         check("struct P\n"
@@ -5113,8 +8933,8 @@ class TestOther : public TestFixture {
               "        }\n"
               "        previous = current;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:16] -> [test.cpp:15]: (style, inconclusive) Same expression used in consecutive assignments of 'current' and 'previous'.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:16:7] -> [test.cpp:15:7]: (style, inconclusive) Same expression used in consecutive assignments of 'current' and 'previous'. [duplicateAssignExpression]\n", errout_str());
     }
 
     void duplicateVarExpressionCrash() {
@@ -5129,22 +8949,22 @@ class TestOther : public TestFixture {
               "        int b = x.f();\n"
               "        (void)a;\n"
               "        (void)b;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:7]: (style, inconclusive) Same expression used in consecutive assignments of 'a' and 'b'.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:8:13] -> [test.cpp:7:13]: (style, inconclusive) Same expression used in consecutive assignments of 'a' and 'b'. [duplicateAssignExpression]\n", errout_str());
 
         // Issue #8712
         check("void f() {\n"
               "  unsigned char d;\n"
               "  d = d % 5;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("template <typename T>\n"
               "T f() {\n"
               "  T x = T();\n"
               "}\n"
-              "int &a = f<int&>();\n");
-        ASSERT_EQUALS("", errout.str());
+              "int &a = f<int&>();");
+        ASSERT_EQUALS("", errout_str());
 
         // Issue #8713
         check("class A {\n"
@@ -5155,8 +8975,8 @@ class TestOther : public TestFixture {
               "  uint32_t a = 42;\n"
               "  uint32_t b = uint32_t(A ::B / 1024);\n"
               "  int32_t c = int32_t(a / b);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // Issue #8709
         check("a b;\n"
@@ -5164,9 +8984,20 @@ class TestOther : public TestFixture {
               "  switch (d) { case b:; }\n"
               "  double e(b);\n"
               "  if(e <= 0) {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
+        // #10718
+        // Should probably not be inconclusive
+        check("struct a {\n"
+              "  int b() const;\n"
+              "  auto c() -> decltype(0) {\n"
+              "    a d;\n"
+              "    int e = d.b(), f = d.b();\n"
+              "    return e + f;\n"
+              "  }\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:5:20] -> [test.cpp:5:9]: (style, inconclusive) Same expression used in consecutive assignments of 'e' and 'f'. [duplicateAssignExpression]\n", errout_str());
     }
 
     void multiConditionSameExpression() {
@@ -5174,77 +9005,99 @@ class TestOther : public TestFixture {
               "  int val = 0;\n"
               "  if (val < 0) continue;\n"
               "  if ((val > 0)) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:13] -> [test.cpp:3:11]: (style) The comparison 'val < 0' is always false. [knownConditionTrueFalse]\n"
+                      "[test.cpp:2:13] -> [test.cpp:4:12]: (style) The comparison 'val > 0' is always false. [knownConditionTrueFalse]\n", errout_str());
+
+        check("void f() {\n"
+              "  int val = 0;\n"
+              "  int *p = &val;n"
+              "  val = 1;\n"
+              "  if (*p < 0) continue;\n"
+              "  if ((*p > 0)) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:8]: (style) Variable 'p' can be declared as pointer to const [constVariablePointer]\n",
+            errout_str());
+
+        check("void f() {\n"
+              "  int val = 0;\n"
+              "  int *p = &val;\n"
+              "  if (*p < 0) continue;\n"
+              "  if ((*p > 0)) {}\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) The expression 'val < 0' is always false.\n"
-                      "[test.cpp:2] -> [test.cpp:4]: (style) The expression 'val > 0' is always false.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) The comparison '*p < 0' is always false.\n"
+                           "[test.cpp:2] -> [test.cpp:4]: (style) The comparison '*p > 0' is always false.\n",
+                           "[test.cpp:3:8]: (style) Variable 'p' can be declared as pointer to const [constVariablePointer]\n",
+                           errout_str());
 
         check("void f() {\n"
               "  int val = 0;\n"
               "  if (val < 0) {\n"
               "    if ((val > 0)) {}\n"
               "  }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) The expression 'val < 0' is always false.\n"
-                      "[test.cpp:2] -> [test.cpp:4]: (style) The expression 'val > 0' is always false.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:13] -> [test.cpp:3:11]: (style) The comparison 'val < 0' is always false. [knownConditionTrueFalse]\n"
+                      "[test.cpp:2:13] -> [test.cpp:4:14]: (style) The comparison 'val > 0' is always false. [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "  int val = 0;\n"
               "  if (val < 0) {\n"
               "    if ((val < 0)) {}\n"
               "  }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) The expression 'val < 0' is always false.\n"
-                      "[test.cpp:2] -> [test.cpp:4]: (style) The expression 'val < 0' is always false.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:13] -> [test.cpp:3:11]: (style) The comparison 'val < 0' is always false. [knownConditionTrueFalse]\n"
+                      "[test.cpp:2:13] -> [test.cpp:4:14]: (style) The comparison 'val < 0' is always false. [knownConditionTrueFalse]\n", errout_str());
 
         check("void f() {\n"
               "  int activate = 0;\n"
               "  int foo = 0;\n"
               "  if (activate) {}\n"
               "  else if (foo) {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void checkSignOfUnsignedVariable() {
         check("void foo() {\n"
               "  for(unsigned char i = 10; i >= 0; i--) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Unsigned expression 'i' can't be negative so it is unnecessary to test it.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:31]: (style) Unsigned expression 'i' can't be negative so it is unnecessary to test it. [unsignedPositive]\n", errout_str());
 
         check("void foo(bool b) {\n"
               "  for(unsigned int i = 10; b || i >= 0; i--) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Unsigned expression 'i' can't be negative so it is unnecessary to test it.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:35]: (style) Unsigned expression 'i' can't be negative so it is unnecessary to test it. [unsignedPositive]\n", errout_str());
 
         {
             const char code[] = "void foo(unsigned int x) {\n"
                                 "  if (x < 0) {}\n"
                                 "}";
-            check(code, nullptr, false, false, true, false);
-            ASSERT_EQUALS("[test.cpp:2]: (style) Checking if unsigned expression 'x' is less than zero.\n", errout.str());
-            check(code, nullptr, false, false, true, true);
-            ASSERT_EQUALS("[test.cpp:2]: (style) Checking if unsigned expression 'x' is less than zero.\n", errout.str());
+            check(code, dinit(CheckOptions, $.inconclusive = false));
+            ASSERT_EQUALS("[test.cpp:2:9]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
+            check(code, dinit(CheckOptions, $.inconclusive = false, $.verbose = true));
+            ASSERT_EQUALS("[test.cpp:2:9]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
         }
 
         check("void foo(unsigned int x) {\n"
               "  if (x < 0u) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Checking if unsigned expression 'x' is less than zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         check("void foo(int x) {\n"
               "  if (x < 0) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         {
             const char code[] = "void foo(unsigned x) {\n"
                                 "  int y = 0;\n"
                                 "  if (x < y) {}\n"
                                 "}";
-            check(code, nullptr, false, false, true, false);
-            ASSERT_EQUALS("[test.cpp:3]: (style) Checking if unsigned expression 'x' is less than zero.\n", errout.str());
-            check(code, nullptr, false, false, true, true);
-            ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) Checking if unsigned expression 'x' is less than zero.\n", errout.str());
+            check(code, dinit(CheckOptions, $.inconclusive = false));
+            ASSERT_EQUALS("[test.cpp:3:9]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
+            check(code, dinit(CheckOptions, $.inconclusive = false, $.verbose = true));
+            ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:9]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
         }
         check("void foo(unsigned x) {\n"
               "  int y = 0;\n"
@@ -5252,149 +9105,149 @@ class TestOther : public TestFixture {
               "    y = 1;\n"
               "  if (x < y) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(unsigned int x) {\n"
               "  if (0 > x) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Checking if unsigned expression 'x' is less than zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         check("void foo(unsigned int x) {\n"
               "  if (0UL > x) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Checking if unsigned expression 'x' is less than zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         check("void foo(int x) {\n"
               "  if (0 > x) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(unsigned int x) {\n"
               "  if (x >= 0) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it. [unsignedPositive]\n", errout_str());
 
         check("void foo(unsigned int x, unsigned y) {\n"
               "  if (x - y >= 0) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Unsigned expression 'x-y' can't be negative so it is unnecessary to test it.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (style) Unsigned expression 'x-y' can't be negative so it is unnecessary to test it. [unsignedPositive]\n", errout_str());
 
         check("void foo(unsigned int x) {\n"
               "  if (x >= 0ull) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it. [unsignedPositive]\n", errout_str());
 
         check("void foo(int x) {\n"
               "  if (x >= 0) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(unsigned int x) {\n"
               "  if (0 <= x) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it. [unsignedPositive]\n", errout_str());
 
         check("void foo(unsigned int x) {\n"
               "  if (0ll <= x) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it. [unsignedPositive]\n", errout_str());
 
         check("void foo(int x) {\n"
               "  if (0 <= x) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(unsigned int x, bool y) {\n"
               "  if (x < 0 && y) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Checking if unsigned expression 'x' is less than zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         check("void foo(int x, bool y) {\n"
               "  if (x < 0 && y) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(unsigned int x, bool y) {\n"
               "  if (0 > x && y) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Checking if unsigned expression 'x' is less than zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         check("void foo(int x, bool y) {\n"
               "  if (0 > x && y) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(unsigned int x, bool y) {\n"
               "  if (x >= 0 && y) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it. [unsignedPositive]\n", errout_str());
 
         check("void foo(int x, bool y) {\n"
               "  if (x >= 0 && y) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
 
         check("void foo(unsigned int x, bool y) {\n"
               "  if (y && x < 0) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Checking if unsigned expression 'x' is less than zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         check("void foo(int x, bool y) {\n"
               "  if (y && x < 0) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(unsigned int x, bool y) {\n"
               "  if (y && 0 > x) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Checking if unsigned expression 'x' is less than zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         check("void foo(int x, bool y) {\n"
               "  if (y && 0 > x) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(unsigned int x, bool y) {\n"
               "  if (y && x >= 0) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it. [unsignedPositive]\n", errout_str());
 
         check("void foo(int x, bool y) {\n"
               "  if (y && x >= 0) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
 
         check("void foo(unsigned int x, bool y) {\n"
               "  if (x < 0 || y) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Checking if unsigned expression 'x' is less than zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         check("void foo(int x, bool y) {\n"
               "  if (x < 0 || y) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(unsigned int x, bool y) {\n"
               "  if (0 > x || y) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Checking if unsigned expression 'x' is less than zero.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         check("void foo(int x, bool y) {\n"
               "  if (0 > x || y) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(unsigned int x, bool y) {\n"
               "  if (x >= 0 || y) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Unsigned expression 'x' can't be negative so it is unnecessary to test it. [unsignedPositive]\n", errout_str());
 
         check("void foo(int x, bool y) {\n"
               "  if (x >= 0 || y) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #3233 - FP when template is used (template parameter is numeric constant)
         {
@@ -5402,16 +9255,18 @@ class TestOther : public TestFixture {
                                 "  if (x <= n);\n"
                                 "}\n"
                                 "foo<0>();";
-            check(code, nullptr, false, false);
-            ASSERT_EQUALS("", errout.str());
-            check(code, nullptr, false, true);
-            ASSERT_EQUALS("", errout.str());
+            check(code, dinit(CheckOptions, $.inconclusive = false));
+            ASSERT_EQUALS("", errout_str());
+            check(code);
+            ASSERT_EQUALS("", errout_str());
         }
 
-        check("template<int n> void foo(unsigned int x) {\n"
-              "if (x <= 0);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Checking if unsigned expression 'x' is less than zero.\n", errout.str());
+        {
+            check("template<int n> void foo(unsigned int x) {\n"
+                  "if (x <= 0);\n"
+                  "}");
+            ASSERT_EQUALS("[test.cpp:2:7]: (style) Checking if unsigned expression 'x' is less than zero. [unsignedLessThanZero]\n", errout_str());
+        }
 
         // #8836
         check("uint32_t value = 0xFUL;\n"
@@ -5420,273 +9275,323 @@ class TestOther : public TestFixture {
               "  {\n"
               "    value = 0u;\n"
               "  }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Checking if unsigned expression 'value' is less than zero.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:13]: (style) Checking if unsigned expression 'value' is less than zero. [unsignedLessThanZero]\n", errout_str());
 
         // #9040
-        Settings settings1;
-        settings1.platform(Settings::Win64);
+        /*const*/ Settings settingsWin64 = settingsBuilder().platform(Platform::Type::Win64).build();
         check("using BOOL = unsigned;\n"
               "int i;\n"
               "bool f() {\n"
               "    return i >= 0;\n"
-              "}\n", &settings1);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.settings = &settingsWin64));
+        ASSERT_EQUALS("", errout_str());
+
+        // #10612
+        check("void f(void) {\n"
+              "   const uint32_t x = 0;\n"
+              "   constexpr const auto y = 0xFFFFU;\n"
+              "   if (y < x) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:10]: (style) Checking if unsigned expression 'y' is less than zero. [unsignedLessThanZero]\n", errout_str());
+
+        // #12387
+        check("template<typename T>\n"
+              "void f(T t) {\n"
+              "    if constexpr (std::numeric_limits<T>::is_signed) {\n"
+              "        if (t < 0) {}\n"
+              "    }\n"
+              "}\n"
+              "void g() {\n"
+              "    f<uint32_t>(0);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #13734
+        check("void f() {\n"
+              "    uint8_t a[N + 1];\n"
+              "    for (unsigned p = 0; p < (sizeof(a) / sizeof((a)[0])); ++p) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void checkSignOfPointer() {
-        check("void foo(int* x) {\n"
+        check("void foo(const int* x) {\n"
               "  if (x >= 0) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) A pointer can not be negative so it is either pointless or an error to check if it is not.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) A pointer can not be negative so it is either pointless or an error to check if it is not. [pointerPositive]\n", errout_str());
 
         {
-            const char code[] = "void foo(int* x) {\n"
+            const char code[] = "void foo(const int* x) {\n"
                                 "  int y = 0;\n"
                                 "  if (x >= y) {}\n"
                                 "}";
-            check(code, nullptr, false, false, true, false);
-            ASSERT_EQUALS("[test.cpp:3]: (style) A pointer can not be negative so it is either pointless or an error to check if it is not.\n", errout.str());
-            check(code, nullptr, false, false, true, true);
-            ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) A pointer can not be negative so it is either pointless or an error to check if it is not.\n", errout.str());
+            check(code, dinit(CheckOptions, $.inconclusive = false));
+            ASSERT_EQUALS("[test.cpp:3:9]: (style) A pointer can not be negative so it is either pointless or an error to check if it is not. [pointerPositive]\n", errout_str());
+            check(code, dinit(CheckOptions, $.inconclusive = false, $.verbose = true));
+            ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:9]: (style) A pointer can not be negative so it is either pointless or an error to check if it is not. [pointerPositive]\n", errout_str());
         }
-        check("void foo(int* x) {\n"
+        check("void foo(const int* x) {\n"
               "  if (*x >= 0) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void foo(int* x) {\n"
+        check("void foo(const int* x) {\n"
               "  if (x < 0) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) A pointer can not be negative so it is either pointless or an error to check if it is.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) A pointer can not be negative so it is either pointless or an error to check if it is. [pointerLessThanZero]\n", errout_str());
 
         {
-            const char code[] = "void foo(int* x) {\n"
+            const char code[] = "void foo(const int* x) {\n"
                                 "  unsigned y = 0u;\n"
                                 "  if (x < y) {}\n"
                                 "}";
 
-            check(code, nullptr, false, false, true, false);
-            ASSERT_EQUALS("[test.cpp:3]: (style) A pointer can not be negative so it is either pointless or an error to check if it is.\n", errout.str());
-            check(code, nullptr, false, false, true, true);
-            ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (style) A pointer can not be negative so it is either pointless or an error to check if it is.\n", errout.str());
+            check(code, dinit(CheckOptions, $.inconclusive = false));
+            ASSERT_EQUALS("[test.cpp:3:9]: (style) A pointer can not be negative so it is either pointless or an error to check if it is. [pointerLessThanZero]\n", errout_str());
+            check(code, dinit(CheckOptions, $.inconclusive = false, $.verbose = true));
+            ASSERT_EQUALS("[test.cpp:2:16] -> [test.cpp:3:9]: (style) A pointer can not be negative so it is either pointless or an error to check if it is. [pointerLessThanZero]\n", errout_str());
         }
 
-        check("void foo(int* x) {\n"
+        check("void foo(const int* x) {\n"
               "  if (*x < 0) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void foo(int* x, int* y) {\n"
+        check("void foo(const int* x, const int* y) {\n"
               "  if (x - y < 0) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void foo(int* x, int* y) {\n"
+        check("void foo(const int* x, const int* y) {\n"
               "  if (x - y <= 0) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void foo(int* x, int* y) {\n"
+        check("void foo(const int* x, const int* y) {\n"
               "  if (x - y > 0) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void foo(int* x, int* y) {\n"
+        check("void foo(const int* x, const int* y) {\n"
               "  if (x - y >= 0) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void foo(Bar* x) {\n"
+        check("void foo(const Bar* x) {\n"
               "  if (0 <= x) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) A pointer can not be negative so it is either pointless or an error to check if it is not.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) A pointer can not be negative so it is either pointless or an error to check if it is not. [pointerPositive]\n", errout_str());
 
         check("struct S {\n"
               "  int* ptr;\n"
               "};\n"
               "void foo(S* first) {\n"
-              "  if (first.ptr >= 0) {} \n"
+              "  if (first.ptr >= 0) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (style) A pointer can not be negative so it is either pointless or an error to check if it is not.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:17]: (style) A pointer can not be negative so it is either pointless or an error to check if it is not. [pointerPositive]\n"
+                      "[test.cpp:4:13]: (style) Parameter 'first' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
 
         check("struct S {\n"
               "  int* ptr;\n"
               "};\n"
               "void foo(S* first, S* second) {\n"
-              "  if((first.ptr - second.ptr) >= 0) {} \n"
+              "  if((first.ptr - second.ptr) >= 0) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (style) Parameter 'first' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:4:23]: (style) Parameter 'second' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
 
         check("struct S {\n"
               "  int* ptr;\n"
               "};\n"
               "void foo(S* first) {\n"
-              "  if((first.ptr) >= 0) {} \n"
+              "  if((first.ptr) >= 0) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (style) A pointer can not be negative so it is either pointless or an error to check if it is not.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:18]: (style) A pointer can not be negative so it is either pointless or an error to check if it is not. [pointerPositive]\n"
+                      "[test.cpp:4:13]: (style) Parameter 'first' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
 
         check("struct S {\n"
               "  int* ptr;\n"
               "};\n"
               "void foo(S* first, S* second) {\n"
-              "  if(0 <= first.ptr - second.ptr) {} \n"
+              "  if(0 <= first.ptr - second.ptr) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (style) Parameter 'first' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:4:23]: (style) Parameter 'second' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
 
         check("struct S {\n"
               "  int* ptr;\n"
               "};\n"
               "void foo(S* first, S* second) {\n"
-              "  if(0 <= (first.ptr - second.ptr)) {} \n"
+              "  if(0 <= (first.ptr - second.ptr)) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (style) Parameter 'first' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:4:23]: (style) Parameter 'second' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
 
         check("struct S {\n"
               "  int* ptr;\n"
               "};\n"
               "void foo(S* first, S* second) {\n"
-              "  if(first.ptr - second.ptr < 0) {} \n"
+              "  if(first.ptr - second.ptr < 0) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (style) Parameter 'first' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:4:23]: (style) Parameter 'second' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
 
         check("struct S {\n"
               "  int* ptr;\n"
               "};\n"
               "void foo(S* first, S* second) {\n"
-              "  if((first.ptr - second.ptr) < 0) {} \n"
+              "  if((first.ptr - second.ptr) < 0) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (style) Parameter 'first' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:4:23]: (style) Parameter 'second' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
 
         check("struct S {\n"
               "  int* ptr;\n"
               "};\n"
               "void foo(S* first, S* second) {\n"
-              "  if(0 > first.ptr - second.ptr) {} \n"
+              "  if(0 > first.ptr - second.ptr) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (style) Parameter 'first' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:4:23]: (style) Parameter 'second' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
 
         check("struct S {\n"
               "  int* ptr;\n"
               "};\n"
               "void foo(S* first, S* second) {\n"
-              "  if(0 > (first.ptr - second.ptr)) {} \n"
+              "  if(0 > (first.ptr - second.ptr)) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (style) Parameter 'first' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:4:23]: (style) Parameter 'second' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
 
-        check("void foo(int* x) {\n"
+        check("void foo(const int* x) {\n"
               "  if (0 <= x[0]) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(Bar* x) {\n"
               "  if (0 <= x.y) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'x' can be declared as pointer to const [constParameterPointer]\n", errout_str());
 
         check("void foo(Bar* x) {\n"
               "  if (0 <= x->y) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'x' can be declared as pointer to const [constParameterPointer]\n", errout_str());
 
         check("void foo(Bar* x, Bar* y) {\n"
               "  if (0 <= x->y - y->y ) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'x' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:1:23]: (style) Parameter 'y' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
 
-        check("void foo(Bar* x) {\n"
+        check("void foo(const Bar* x) {\n"
               "  if (0 > x) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) A pointer can not be negative so it is either pointless or an error to check if it is.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) A pointer can not be negative so it is either pointless or an error to check if it is. [pointerLessThanZero]\n", errout_str());
 
-        check("void foo(int* x) {\n"
+        check("void foo(const int* x) {\n"
               "  if (0 > x[0]) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(Bar* x) {\n"
               "  if (0 > x.y) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'x' can be declared as pointer to const [constParameterPointer]\n", errout_str());
 
         check("void foo(Bar* x) {\n"
               "  if (0 > x->y) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:15]: (style) Parameter 'x' can be declared as pointer to const [constParameterPointer]\n", errout_str());
 
         check("void foo() {\n"
               "  int (*t)(void *a, void *b);\n"
               "  if (t(a, b) < 0) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "  int (*t)(void *a, void *b);\n"
               "  if (0 > t(a, b)) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct object_info { int *typep; };\n"
               "void packed_object_info(struct object_info *oi) {\n"
               "  if (oi->typep < 0);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) A pointer can not be negative so it is either pointless or an error to check if it is.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:17]: (style) A pointer can not be negative so it is either pointless or an error to check if it is. [pointerLessThanZero]\n"
+                      "[test.cpp:2:45]: (style) Parameter 'oi' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
 
         check("struct object_info { int typep[10]; };\n"
               "void packed_object_info(struct object_info *oi) {\n"
               "  if (oi->typep < 0);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) A pointer can not be negative so it is either pointless or an error to check if it is.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:17]: (style) A pointer can not be negative so it is either pointless or an error to check if it is. [pointerLessThanZero]\n"
+                      "[test.cpp:2:45]: (style) Parameter 'oi' can be declared as pointer to const [constParameterPointer]\n",
+                      errout_str());
 
         check("struct object_info { int *typep; };\n"
               "void packed_object_info(struct object_info *oi) {\n"
               "  if (*oi->typep < 0);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:45]: (style) Parameter 'oi' can be declared as pointer to const [constParameterPointer]\n", errout_str());
     }
 
-    void checkForSuspiciousSemicolon1() {
+    void checkSuspiciousSemicolon1() {
         check("void foo() {\n"
               "  for(int i = 0; i < 10; ++i);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Empty block
         check("void foo() {\n"
               "  for(int i = 0; i < 10; ++i); {\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Suspicious use of ; at the end of 'for' statement.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:3]: (warning) Suspicious use of ; at the end of 'for' statement. [suspiciousSemicolon]\n", errout_str());
 
         check("void foo() {\n"
               "  while (!quit); {\n"
               "    do_something();\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Suspicious use of ; at the end of 'while' statement.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:3]: (warning) Suspicious use of ; at the end of 'while' statement. [suspiciousSemicolon]\n", errout_str());
     }
 
-    void checkForSuspiciousSemicolon2() {
+    void checkSuspiciousSemicolon2() {
         check("void foo() {\n"
               "  if (i == 1); {\n"
               "    do_something();\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Suspicious use of ; at the end of 'if' statement.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:3]: (warning) Suspicious use of ; at the end of 'if' statement. [suspiciousSemicolon]\n", errout_str());
 
         // Seen this in the wild
         check("void foo() {\n"
               "  if (Match());\n"
               "  do_something();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "  if (Match());\n"
               "  else\n"
               "    do_something();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "  if (i == 1)\n"
@@ -5695,7 +9600,7 @@ class TestOther : public TestFixture {
               "    do_something();\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "  if (i == 1);\n"
@@ -5704,47 +9609,72 @@ class TestOther : public TestFixture {
               "    do_something();\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void checkSuspiciousSemicolon3() {
+        checkP("#define REQUIRE(code) {code}\n"
+               "void foo() {\n"
+               "  if (x == 123);\n"
+               "  REQUIRE(y=z);\n"
+               "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
+    void checkSuspiciousComparison() {
+        checkP("void f(int a, int b) {\n"
+               "  a > b;\n"
+               "}");
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning, inconclusive) Found suspicious operator '>', result is not used. [constStatement]\n", errout_str());
+
+        checkP("void f() {\n" // #10607
+               "  for (auto p : m)\n"
+               "    std::vector<std::pair<std::string, std::string>> k;\n"
+               "}");
+        ASSERT_EQUALS("", errout_str());
+    }
 
     void checkInvalidFree() {
         check("void foo(char *p) {\n"
               "  char *a; a = malloc(1024);\n"
               "  free(a + 10);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Mismatching address is freed. The address you get from malloc() must be freed without offset.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:3]: (error) Mismatching address is freed. The address you get from malloc() must be freed without offset. [invalidFree]\n", errout_str());
 
         check("void foo(char *p) {\n"
               "  char *a; a = malloc(1024);\n"
               "  free(a - 10);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Mismatching address is freed. The address you get from malloc() must be freed without offset.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:3]: (error) Mismatching address is freed. The address you get from malloc() must be freed without offset. [invalidFree]\n", errout_str());
 
         check("void foo(char *p) {\n"
               "  char *a; a = malloc(1024);\n"
               "  free(10 + a);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Mismatching address is freed. The address you get from malloc() must be freed without offset.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:3]: (error) Mismatching address is freed. The address you get from malloc() must be freed without offset. [invalidFree]\n", errout_str());
 
         check("void foo(char *p) {\n"
               "  char *a; a = new char[1024];\n"
               "  delete[] (a + 10);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Mismatching address is deleted. The address you get from new must be deleted without offset.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:16]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:3:3]: (error) Mismatching address is deleted. The address you get from new must be deleted without offset. [invalidFree]\n",
+                      errout_str());
 
         check("void foo(char *p) {\n"
               "  char *a; a = new char;\n"
               "  delete a + 10;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Mismatching address is deleted. The address you get from new must be deleted without offset.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:16]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:3:3]: (error) Mismatching address is deleted. The address you get from new must be deleted without offset. [invalidFree]\n",
+                      errout_str());
 
         check("void foo(char *p) {\n"
               "  char *a; a = new char;\n"
               "  bar(a);\n"
               "  delete a + 10;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(char *p) {\n"
               "  char *a; a = new char;\n"
@@ -5753,7 +9683,7 @@ class TestOther : public TestFixture {
               "  delete a + 10;\n"
               "  delete b + 10;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Mismatching address is deleted. The address you get from new must be deleted without offset.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:3]: (error) Mismatching address is deleted. The address you get from new must be deleted without offset. [invalidFree]\n", errout_str());
 
         check("void foo(char *p) {\n"
               "  char *a; a = new char;\n"
@@ -5762,21 +9692,23 @@ class TestOther : public TestFixture {
               "  delete a + 10;\n"
               "  delete b + 10;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(char *p) {\n"
               "  char *a; a = new char;\n"
               "  bar()\n"
               "  delete a + 10;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Mismatching address is deleted. The address you get from new must be deleted without offset.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:16]: (style) Parameter 'p' can be declared as pointer to const [constParameterPointer]\n"
+                      "[test.cpp:4:3]: (error) Mismatching address is deleted. The address you get from new must be deleted without offset. [invalidFree]\n",
+                      errout_str());
 
         check("void foo(size_t xx) {\n"
               "  char *ptr; ptr = malloc(42);\n"
               "  ptr += xx;\n"
               "  free(ptr + 1 - xx);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Mismatching address is freed. The address you get from malloc() must be freed without offset.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:3]: (error) Mismatching address is freed. The address you get from malloc() must be freed without offset. [invalidFree]\n", errout_str());
 
         check("void foo(size_t xx) {\n"
               "  char *ptr; ptr = malloc(42);\n"
@@ -5784,7 +9716,9 @@ class TestOther : public TestFixture {
               "  ptr = otherPtr;\n"
               "  free(otherPtr - xx - 1);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:9]: (style) Variable 'ptr' can be declared as pointer to const [constVariablePointer]\n",
+            errout_str());
     }
 
     void checkRedundantCopy() {
@@ -5792,16 +9726,16 @@ class TestOther : public TestFixture {
               "void foo() {\n"
               "    const std::string a = getA();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (performance, inconclusive) Use const reference for 'a' to avoid unnecessary data copying.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:23]: (performance, inconclusive) Use const reference for 'a' to avoid unnecessary data copying. [redundantCopyLocalConst]\n", errout_str());
 
-        check("class A{public:A(){}};\n"
+        check("class A { public: A() {} char x[100]; };\n"
               "const A& getA(){static A a;return a;}\n"
               "int main()\n"
               "{\n"
               "    const A a = getA();\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (performance, inconclusive) Use const reference for 'a' to avoid unnecessary data copying.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:13]: (performance, inconclusive) Use const reference for 'a' to avoid unnecessary data copying. [redundantCopyLocalConst]\n", errout_str());
 
         check("const int& getA(){static int a;return a;}\n"
               "int main()\n"
@@ -5809,7 +9743,7 @@ class TestOther : public TestFixture {
               "    const int a = getA();\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("const int& getA(){static int a;return a;}\n"
               "int main()\n"
@@ -5818,16 +9752,16 @@ class TestOther : public TestFixture {
               "    const int a = getA + 3;\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:4]: (style) Local variable \'getA\' shadows outer function\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:12] -> [test.cpp:4:9]: (style) Local variable 'getA' shadows outer function [shadowFunction]\n", errout_str());
 
-        check("class A{public:A(){}};\n"
+        check("class A { public: A() {} char x[100]; };\n"
               "const A& getA(){static A a;return a;}\n"
               "int main()\n"
               "{\n"
               "    const A a(getA());\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (performance, inconclusive) Use const reference for 'a' to avoid unnecessary data copying.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:13]: (performance, inconclusive) Use const reference for 'a' to avoid unnecessary data copying. [redundantCopyLocalConst]\n", errout_str());
 
         check("const int& getA(){static int a;return a;}\n"
               "int main()\n"
@@ -5835,7 +9769,7 @@ class TestOther : public TestFixture {
               "    const int a(getA());\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class A{\n"
               "public:A(int a=0){_a = a;}\n"
@@ -5847,7 +9781,7 @@ class TestOther : public TestFixture {
               "    const A a = getA() + 1;\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class A{\n"
               "public:A(int a=0){_a = a;}\n"
@@ -5859,7 +9793,7 @@ class TestOther : public TestFixture {
               "    const A a(getA()+1);\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #5190 - FP when creating object with constructor that takes a reference
         check("class A {};\n"
@@ -5868,23 +9802,31 @@ class TestOther : public TestFixture {
               "void f() {\n"
               "    const B b(getA());\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("class A {};\n"
+              "class B { B(const A& a); };\n"
+              "const A& getA();\n"
+              "void f() {\n"
+              "    const B b{ getA() };\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // #5618
-        const char* code5618 = "class Token {\n"
-                               "public:\n"
-                               "    const std::string& str();\n"
-                               "};\n"
-                               "void simplifyArrayAccessSyntax() {\n"
-                               "    for (Token *tok = list.front(); tok; tok = tok->next()) {\n"
-                               "        const std::string temp = tok->str();\n"
-                               "        tok->str(tok->strAt(2));\n"
-                               "    }\n"
-                               "}";
-        check(code5618, nullptr, false, true);
-        TODO_ASSERT_EQUALS("", "[test.cpp:7]: (performance, inconclusive) Use const reference for 'temp' to avoid unnecessary data copying.\n", errout.str());
-        check(code5618, nullptr, false, false);
-        ASSERT_EQUALS("", errout.str());
+        const char code5618[] = "class Token {\n"
+                                "public:\n"
+                                "    const std::string& str();\n"
+                                "};\n"
+                                "void simplifyArrayAccessSyntax() {\n"
+                                "    for (Token *tok = list.front(); tok; tok = tok->next()) {\n"
+                                "        const std::string temp = tok->str();\n"
+                                "        tok->str(tok->strAt(2));\n"
+                                "    }\n"
+                                "}";
+        check(code5618);
+        ASSERT_EQUALS("", errout_str());
+        check(code5618, dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         // #5890 - crash: wesnoth desktop_util.cpp / unicode.hpp
         check("typedef std::vector<char> X;\n"
@@ -5892,7 +9834,207 @@ class TestOther : public TestFixture {
               "    const X s = f<X>(in);\n"
               "    return f<X>(s);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // #7981 - False positive redundantCopyLocalConst - const ref argument to ctor
+        check("class CD {\n"
+              "        public:\n"
+              "        CD(const CD&);\n"
+              "        static const CD& getOne();\n"
+              "};\n"
+              " \n"
+              "void foo() {\n"
+              "  const CD cd(CD::getOne());\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #10545
+              "    int modify();\n"
+              "    const std::string& get() const;\n"
+              "};\n"
+              "std::string f(S& s) {\n"
+              "    const std::string old = s.get();\n"
+              "    int i = s.modify();\n"
+              "    if (i != 0)\n"
+              "        return old;\n"
+              "    return {};\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct X { int x; };\n" // #10191
+              "struct S {\n"
+              "    X _x;\n"
+              "    X& get() { return _x; }\n"
+              "    void modify() { _x.x += 42; }\n"
+              "    int copy() {\n"
+              "        const X x = get();\n"
+              "        modify();\n"
+              "        return x.x;\n"
+              "    }\n"
+              "    int constref() {\n"
+              "        const X& x = get();\n"
+              "        modify();\n"
+              "        return x.x;\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10704
+        check("struct C {\n"
+              "    std::string str;\n"
+              "    const std::string& get() const { return str; }\n"
+              "};\n"
+              "struct D {\n"
+              "    C c;\n"
+              "    bool f() const {\n"
+              "        std::string s = c.get();\n"
+              "        return s.empty();\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:8:21]: (performance, inconclusive) Use const reference for 's' to avoid unnecessary data copying. [redundantCopyLocalConst]\n", errout_str());
+
+        check("struct C {\n"
+              "    const std::string & get() const { return m; }\n"
+              "    std::string m;\n"
+              "};\n"
+              "C getC();\n"
+              "void f() {\n"
+              "    const std::string s = getC().get();\n"
+              "}\n"
+              "void g() {\n"
+              "    std::string s = getC().get();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #12139
+              "    int x, y;\n"
+              "};\n"
+              "struct T {\n"
+              "    S s;\n"
+              "    const S& get() const { return s; }\n"
+              "};\n"
+              "void f(const T& t) {\n"
+              "    const S a = t.get();\n"
+              "    if (a.x > a.y) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #12740
+              "    const std::string & get() const { return m; }\n"
+              "    void set(const std::string& v) { m = v; }\n"
+              "    std::string m;\n"
+              "};\n"
+              "struct T {\n"
+              "    void f();\n"
+              "    S* s;\n"
+              "};\n"
+              "void T::f() {\n"
+              "    const std::string o = s->get();\n"
+              "    s->set(\"abc\");\n"
+              "    s->set(o);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #12196
+              "    std::string s;\n"
+              "    const std::string& get() const { return s; }\n"
+              "};\n"
+              "struct T {\n"
+              "    S* m;\n"
+              "    void f();\n"
+              "};\n"
+              "struct U {\n"
+              "    explicit U(S* p);\n"
+              "    void g();\n"
+              "    S* n;\n"
+              "};\n"
+              "void T::f() {\n"
+              "    U u(m);\n"
+              "    const std::string c = m->get();\n"
+              "    u.g();\n"
+              "    if (c == m->get()) {}\n"
+              "}\n");
+        TODO_ASSERT_EQUALS("",
+                           "[test.cpp:16:33] -> [test.cpp:18:11]: (style) The comparison 'c == m->get()' is always true because 'c' and 'm->get()' represent the same value. [knownConditionTrueFalse]\n",
+                           errout_str());
+
+        check("struct S {\n" // #12925
+              "    const std::string & f() const { return str; }\n"
+              "    std::string str;\n"
+              "};\n"
+              "void f(const S* s) {\n"
+              "    const std::string v{ s->f() };\n"
+              "    if (v.empty()) {}\n"
+              "}\n"
+              "void g(const S* s) {\n"
+              "    const std::string w(s->f());\n"
+              "    if (w.empty()) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:23]: (performance, inconclusive) Use const reference for 'v' to avoid unnecessary data copying. [redundantCopyLocalConst]\n"
+                      "[test.cpp:10:23]: (performance, inconclusive) Use const reference for 'w' to avoid unnecessary data copying. [redundantCopyLocalConst]\n",
+                      errout_str());
+
+        check("struct T {\n"
+              "    std::string s;\n"
+              "    const std::string& get() const { return s; }\n"
+              "};\n"
+              "void f(const T& t) {\n"
+              "    const auto s = t.get();\n"
+              "    if (s.empty()) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:16]: (performance, inconclusive) Use const reference for 's' to avoid unnecessary data copying. [redundantCopyLocalConst]\n", errout_str());
+
+        check("void f1(const std::string& s) {\n"
+              "    std::string s1 = s;\n"
+              "    (void)s1;\n"
+              "}\n"
+              "void f2() {\n"
+              "    const std::string s;\n"
+              "    std::string s1 = s;\n"
+              "    (void)s1;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:17]: (performance, inconclusive) Use const reference for 's1' to avoid unnecessary data copying. [redundantCopyLocalConst]\n"
+                      "[test.cpp:7:17]: (performance, inconclusive) Use const reference for 's1' to avoid unnecessary data copying. [redundantCopyLocalConst]\n",
+                      errout_str());
+
+        check("struct S {\n"
+              "    std::string m;\n"
+              "    int f(const std::string& s);\n"
+              "};\n"
+              "int S::f(const std::string& s) {\n"
+              "    std::string c = s;\n"
+              "    m.clear();\n"
+              "    return c.size();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n"
+              "    std::string m;\n"
+              "    int f(std::string s);\n"
+              "};\n"
+              "int S::f(std::string s) {\n"
+              "    s += m;\n"
+              "    std::string c = s;\n"
+              "    m.clear();\n"
+              "    return c.size();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:7:17]: (performance, inconclusive) Use const reference for 'c' to avoid unnecessary data copying. [redundantCopyLocalConst]\n",
+                      errout_str());
+
+        check("int f(const char* c) {\n" // #14530
+              "    std::string s = c;\n"
+              "    return s.rfind('.');\n"
+              "}\n"
+              "struct M {\n"
+              "    M(const std::array<double, 9>& a);\n"
+              "    double m[3][3];\n"
+              "    double trace() const;\n"
+              "};\n"
+              "double g(const std::array<double, 9>& a) {\n"
+              "    M m = a;\n"
+              "    return m.trace();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void checkNegativeShift() {
@@ -5901,65 +10043,101 @@ class TestOther : public TestFixture {
               "   int a; a = 123;\n"
               "   (void)(a << -1);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Shifting by a negative value is undefined behaviour\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (error) Shifting by a negative value is undefined behaviour [shiftNegative]\n", errout_str());
         check("void foo()\n"
               "{\n"
               "   int a; a = 123;\n"
               "   (void)(a >> -1);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Shifting by a negative value is undefined behaviour\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (error) Shifting by a negative value is undefined behaviour [shiftNegative]\n", errout_str());
         check("void foo()\n"
               "{\n"
               "   int a; a = 123;\n"
               "   a <<= -1;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Shifting by a negative value is undefined behaviour\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:6]: (error) Shifting by a negative value is undefined behaviour [shiftNegative]\n", errout_str());
         check("void foo()\n"
               "{\n"
               "   int a; a = 123;\n"
               "   a >>= -1;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Shifting by a negative value is undefined behaviour\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:6]: (error) Shifting by a negative value is undefined behaviour [shiftNegative]\n", errout_str());
         check("void foo()\n"
               "{\n"
               "   std::cout << -1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
               "   std::cout << a << -1 ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void foo()\n"
               "{\n"
               "   std::cout << 3 << -1 ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void foo() {\n"
               "   x = (-10+2) << 3;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (portability) Shifting a negative value is technically undefined behaviour\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:16]: (portability) Shifting a negative value is technically undefined behaviour [shiftNegativeLHS]\n", errout_str());
 
-        check("x = y ? z << $-1 : 0;\n");
-        ASSERT_EQUALS("", errout.str());
+        check("x = y ? z << $-1 : 0;");
+        ASSERT_EQUALS("", errout_str());
 
         // Negative LHS
         check("const int x = -1 >> 2;");
-        ASSERT_EQUALS("[test.cpp:1]: (portability) Shifting a negative value is technically undefined behaviour\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:18]: (portability) Shifting a negative value is technically undefined behaviour [shiftNegativeLHS]\n", errout_str());
 
         // #6383 - unsigned type
         check("const int x = (unsigned int)(-1) >> 2;");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #7814 - UB happening in valueflowcode when it tried to compute shifts.
         check("int shift1() { return 1 >> -1 ;}\n"
               "int shift2() { return 1 << -1 ;}\n"
               "int shift3() { return -1 >> 1 ;}\n"
-              "int shift4() { return -1 << 1 ;}\n");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Shifting by a negative value is undefined behaviour\n"
-                      "[test.cpp:2]: (error) Shifting by a negative value is undefined behaviour\n"
-                      "[test.cpp:3]: (portability) Shifting a negative value is technically undefined behaviour\n"
-                      "[test.cpp:4]: (portability) Shifting a negative value is technically undefined behaviour\n", errout.str());
+              "int shift4() { return -1 << 1 ;}");
+        ASSERT_EQUALS("[test.cpp:1:25]: (error) Shifting by a negative value is undefined behaviour [shiftNegative]\n"
+                      "[test.cpp:2:25]: (error) Shifting by a negative value is undefined behaviour [shiftNegative]\n"
+                      "[test.cpp:3:26]: (portability) Shifting a negative value is technically undefined behaviour [shiftNegativeLHS]\n"
+                      "[test.cpp:4:26]: (portability) Shifting a negative value is technically undefined behaviour [shiftNegativeLHS]\n", errout_str());
+
+        check("void f(int i) {\n" // #12916
+              "    if (i < 0) {\n"
+              "        g(\"abc\" << i);\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #13326
+        check("template<int b>\n"
+              "int f(int a)\n"
+              "{\n"
+              "    if constexpr (b >= 0) {\n"
+              "        return a << b;\n"
+              "    } else {\n"
+              "        return a << -b;\n"
+              "    }\n"
+              "}\n"
+              "int g() {\n"
+              "    return f<1>(2)\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("template<int b>\n"
+              "int f(int a)\n"
+              "{\n"
+              "    if constexpr (b >= 0) {\n"
+              "        return a << b;\n"
+              "    } else {\n"
+              "        return a << -b;\n"
+              "    }\n"
+              "}\n"
+              "int g() {\n"
+              "    return f<-1>(2)\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void incompleteArrayFill() {
@@ -5970,46 +10148,63 @@ class TestOther : public TestFixture {
               "    memmove(a, b, 5);\n"
               "}");
         ASSERT_EQUALS(// TODO "[test.cpp:4] -> [test.cpp:5]: (performance) Buffer 'a' is being written before its old content has been used.\n"
-            "[test.cpp:3]: (warning, inconclusive) Array 'a' is filled incompletely. Did you forget to multiply the size given to 'memset()' with 'sizeof(*a)'?\n"
-            "[test.cpp:4]: (warning, inconclusive) Array 'a' is filled incompletely. Did you forget to multiply the size given to 'memcpy()' with 'sizeof(*a)'?\n"
-            "[test.cpp:5]: (warning, inconclusive) Array 'a' is filled incompletely. Did you forget to multiply the size given to 'memmove()' with 'sizeof(*a)'?\n", errout.str());
+            "[test.cpp:3:5]: (warning, inconclusive) Array 'a' is filled incompletely. Did you forget to multiply the size given to 'memset()' with 'sizeof(*a)'? [incompleteArrayFill]\n"
+            "[test.cpp:4:5]: (warning, inconclusive) Array 'a' is filled incompletely. Did you forget to multiply the size given to 'memcpy()' with 'sizeof(*a)'? [incompleteArrayFill]\n"
+            "[test.cpp:5:5]: (warning, inconclusive) Array 'a' is filled incompletely. Did you forget to multiply the size given to 'memmove()' with 'sizeof(*a)'? [incompleteArrayFill]\n", errout_str());
+
+        check("int a[5];\n"
+              "namespace Z { struct B { int a[5]; } b; }\n"
+              "void f() {\n"
+              "    memset(::a, 123, 5);\n"
+              "    memset(Z::b.a, 123, 5);\n"
+              "}");
+        TODO_ASSERT_EQUALS("[test.cpp:4:5]: (warning, inconclusive) Array '::a' is filled incompletely. Did you forget to multiply the size given to 'memset()' with 'sizeof(*::a)'? [incompleteArrayFill]\n"
+                           "[test.cpp:5]: (warning, inconclusive) Array 'Z::b.a' is filled incompletely. Did you forget to multiply the size given to 'memset()' with 'sizeof(*Z::b.a)'?\n",
+                           "[test.cpp:4:5]: (warning, inconclusive) Array '::a' is filled incompletely. Did you forget to multiply the size given to 'memset()' with 'sizeof(*::a)'? [incompleteArrayFill]\n", errout_str());
 
         check("void f() {\n"
               "    Foo* a[5];\n"
               "    memset(a, 'a', 5);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning, inconclusive) Array 'a' is filled incompletely. Did you forget to multiply the size given to 'memset()' with 'sizeof(*a)'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning, inconclusive) Array 'a' is filled incompletely. Did you forget to multiply the size given to 'memset()' with 'sizeof(*a)'? [incompleteArrayFill]\n", errout_str());
 
         check("class Foo {int a; int b;};\n"
               "void f() {\n"
               "    Foo a[5];\n"
               "    memset(a, 'a', 5);\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:4]: (warning, inconclusive) Array 'a' is filled incompletely. Did you forget to multiply the size given to 'memset()' with 'sizeof(*a)'?\n", "", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning, inconclusive) Array 'a' is filled incompletely. Did you forget to multiply the size given to 'memset()' with 'sizeof(*a)'? [incompleteArrayFill]\n", errout_str());
 
         check("void f() {\n"
               "    Foo a[5];\n" // Size of foo is unknown
               "    memset(a, 'a', 5);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char a[5];\n"
               "    memset(a, 'a', 5);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int a[5];\n"
               "    memset(a+15, 'a', 5);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    bool a[5];\n"
               "    memset(a, false, 5);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (portability, inconclusive) Array 'a' might be filled incompletely. Did you forget to multiply the size given to 'memset()' with 'sizeof(*a)'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (portability, inconclusive) Array 'a' might be filled incompletely. Did you forget to multiply the size given to 'memset()' with 'sizeof(*a)'? [incompleteArrayFill]\n", errout_str());
+
+        check("void f() {\n"
+              "    const int n = 5;"
+              "    int a[n];\n"
+              "    memset(a, 0, n);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning, inconclusive) Array 'a' is filled incompletely. Did you forget to multiply the size given to 'memset()' with 'sizeof(*a)'? [incompleteArrayFill]\n", errout_str());
     }
 
     void redundantVarAssignment() {
@@ -6020,9 +10215,9 @@ class TestOther : public TestFixture {
               "    i = 1;\n"
               "    i = 1;\n"
               "}");
-        ASSERT_EQUALS("test.cpp:3:style:Variable 'i' is reassigned a value before the old one has been used.\n"
-                      "test.cpp:2:note:i is assigned\n"
-                      "test.cpp:3:note:i is overwritten\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:7]: style: Variable 'i' is reassigned a value before the old one has been used. [redundantAssignment]\n"
+                      "[test.cpp:2:7]: note: i is assigned\n"
+                      "[test.cpp:3:7]: note: i is overwritten\n", errout_str());
 
         // non-local variable => only show warning when inconclusive is used
         check("int i;\n"
@@ -6030,34 +10225,34 @@ class TestOther : public TestFixture {
               "    i = 1;\n"
               "    i = 1;\n"
               "}");
-        ASSERT_EQUALS("test.cpp:4:style:Variable 'i' is reassigned a value before the old one has been used.\n"
-                      "test.cpp:3:note:i is assigned\n"
-                      "test.cpp:4:note:i is overwritten\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: style: Variable 'i' is reassigned a value before the old one has been used. [redundantAssignment]\n"
+                      "[test.cpp:3:7]: note: i is assigned\n"
+                      "[test.cpp:4:7]: note: i is overwritten\n", errout_str());
 
         check("void f() {\n"
               "    int i;\n"
               "    i = 1;\n"
               "    i = 1;\n"
               "}");
-        ASSERT_EQUALS("test.cpp:4:style:Variable 'i' is reassigned a value before the old one has been used.\n"
-                      "test.cpp:3:note:i is assigned\n"
-                      "test.cpp:4:note:i is overwritten\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: style: Variable 'i' is reassigned a value before the old one has been used. [redundantAssignment]\n"
+                      "[test.cpp:3:7]: note: i is assigned\n"
+                      "[test.cpp:4:7]: note: i is overwritten\n", errout_str());
 
         check("void f() {\n"
               "    static int i;\n"
               "    i = 1;\n"
               "    i = 1;\n"
               "}");
-        TODO_ASSERT_EQUALS("error", "", errout.str());
+        TODO_ASSERT_EQUALS("error", "", errout_str());
 
         check("void f() {\n"
               "    int i[10];\n"
               "    i[2] = 1;\n"
               "    i[2] = 1;\n"
               "}");
-        ASSERT_EQUALS("test.cpp:4:style:Variable 'i[2]' is reassigned a value before the old one has been used.\n"
-                      "test.cpp:3:note:i[2] is assigned\n"
-                      "test.cpp:4:note:i[2] is overwritten\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:10]: style: Variable 'i[2]' is reassigned a value before the old one has been used. [redundantAssignment]\n"
+                      "[test.cpp:3:10]: note: i[2] is assigned\n"
+                      "[test.cpp:4:10]: note: i[2] is overwritten\n", errout_str());
 
         check("void f(int x) {\n"
               "    int i[10];\n"
@@ -6065,30 +10260,30 @@ class TestOther : public TestFixture {
               "    x=1;\n"
               "    i[x] = 1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(const int x) {\n"
               "    int i[10];\n"
               "    i[x] = 1;\n"
               "    i[x] = 1;\n"
               "}");
-        ASSERT_EQUALS("test.cpp:4:style:Variable 'i[x]' is reassigned a value before the old one has been used.\n"
-                      "test.cpp:3:note:i[x] is assigned\n"
-                      "test.cpp:4:note:i[x] is overwritten\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:10]: style: Variable 'i[x]' is reassigned a value before the old one has been used. [redundantAssignment]\n"
+                      "[test.cpp:3:10]: note: i[x] is assigned\n"
+                      "[test.cpp:4:10]: note: i[x] is overwritten\n", errout_str());
 
         // Testing different types
         check("void f() {\n"
               "    Foo& bar = foo();\n"
               "    bar = x;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    Foo& bar = foo();\n"
               "    bar = x;\n"
               "    bar = y;\n"
               "}");
-        TODO_ASSERT_EQUALS("error", "", errout.str());
+        TODO_ASSERT_EQUALS("error", "", errout_str());
 
         check("void f() {\n"
               "    Foo& bar = foo();\n" // #4425. bar might refer to something global, etc.
@@ -6096,7 +10291,7 @@ class TestOther : public TestFixture {
               "    foo();\n"
               "    bar = y();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Tests with function call between assignment
         check("void f(int i) {\n"
@@ -6104,9 +10299,9 @@ class TestOther : public TestFixture {
               "    bar();\n"
               "    i = 1;\n"
               "}");
-        ASSERT_EQUALS("test.cpp:4:style:Variable 'i' is reassigned a value before the old one has been used.\n"
-                      "test.cpp:2:note:i is assigned\n"
-                      "test.cpp:4:note:i is overwritten\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: style: Variable 'i' is reassigned a value before the old one has been used. [redundantAssignment]\n"
+                      "[test.cpp:2:7]: note: i is assigned\n"
+                      "[test.cpp:4:7]: note: i is overwritten\n", errout_str());
 
         check("int i;\n"
               "void f() {\n"
@@ -6114,7 +10309,7 @@ class TestOther : public TestFixture {
               "    bar();\n" // Global variable might be accessed in bar()
               "    i = 1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    static int i;\n"
@@ -6122,7 +10317,7 @@ class TestOther : public TestFixture {
               "    bar();\n" // bar() might call f() recursively. This could be a false positive in more complex examples (when value of i is used somewhere. See #4229)
               "    i = 2;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int i;\n"
@@ -6130,9 +10325,9 @@ class TestOther : public TestFixture {
               "    bar();\n"
               "    i = 1;\n"
               "}");
-        ASSERT_EQUALS("test.cpp:5:style:Variable 'i' is reassigned a value before the old one has been used.\n"
-                      "test.cpp:3:note:i is assigned\n"
-                      "test.cpp:5:note:i is overwritten\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:7]: style: Variable 'i' is reassigned a value before the old one has been used. [redundantAssignment]\n"
+                      "[test.cpp:3:7]: note: i is assigned\n"
+                      "[test.cpp:5:7]: note: i is overwritten\n", errout_str());
 
         check("void bar(int i) {}\n"
               "void f(int i) {\n"
@@ -6140,14 +10335,14 @@ class TestOther : public TestFixture {
               "    bar(i);\n" // Passed as argument
               "    i = 1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    Foo bar = foo();\n"
               "    bar();\n" // #5568. operator() called
               "    bar = y();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Branch tests
         check("void f(int i) {\n"
@@ -6155,7 +10350,7 @@ class TestOther : public TestFixture {
               "    if(x)\n"
               "        i = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int i) {\n"
               "    if(x)\n"
@@ -6163,9 +10358,9 @@ class TestOther : public TestFixture {
               "    i = 1;\n"
               "    i = 2;\n"
               "}");
-        ASSERT_EQUALS("test.cpp:5:style:Variable 'i' is reassigned a value before the old one has been used.\n"
-                      "test.cpp:4:note:i is assigned\n"
-                      "test.cpp:5:note:i is overwritten\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:7]: style: Variable 'i' is reassigned a value before the old one has been used. [redundantAssignment]\n"
+                      "[test.cpp:4:7]: note: i is assigned\n"
+                      "[test.cpp:5:7]: note: i is overwritten\n", errout_str());
 
         // #4513
         check("int x;\n"
@@ -6176,7 +10371,7 @@ class TestOther : public TestFixture {
               "    x = 2;\n"
               "    x = g();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int g() {\n"
               "    return x*x;\n"
@@ -6185,16 +10380,16 @@ class TestOther : public TestFixture {
               "    x = 2;\n"
               "    x = g();\n"
               "}");
-        ASSERT_EQUALS("test.cpp:6:style:Variable 'x' is reassigned a value before the old one has been used.\n"
-                      "test.cpp:5:note:x is assigned\n"
-                      "test.cpp:6:note:x is overwritten\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:7]: style: Variable 'x' is reassigned a value before the old one has been used. [redundantAssignment]\n"
+                      "[test.cpp:5:7]: note: x is assigned\n"
+                      "[test.cpp:6:7]: note: x is overwritten\n", errout_str());
 
         check("void f() {\n"
               "    Foo& bar = foo();\n"
               "    bar = x;\n"
               "    bar = y();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class C {\n"
               "    int x;\n"
@@ -6206,7 +10401,7 @@ class TestOther : public TestFixture {
               "    x = 2;\n"
               "    x = g();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class C {\n"
               "    int x;\n"
@@ -6218,7 +10413,7 @@ class TestOther : public TestFixture {
               "    x = 2;\n"
               "    x = z.g();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ({ })
         check("void f() {\n"
@@ -6226,7 +10421,7 @@ class TestOther : public TestFixture {
               "  x = 321;\n"
               "  x = ({ asm(123); })\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // from #3103 (avoid a false negative)
         check("int foo(){\n"
@@ -6235,9 +10430,9 @@ class TestOther : public TestFixture {
               "    x = 1;\n"
               "    return x + 1;\n"
               "}");
-        ASSERT_EQUALS("test.cpp:4:style:Variable 'x' is reassigned a value before the old one has been used.\n"
-                      "test.cpp:3:note:x is assigned\n"
-                      "test.cpp:4:note:x is overwritten\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: style: Variable 'x' is reassigned a value before the old one has been used. [redundantAssignment]\n"
+                      "[test.cpp:3:7]: note: x is assigned\n"
+                      "[test.cpp:4:7]: note: x is overwritten\n", errout_str());
 
         // from #3103 (avoid a false positive)
         check("int foo(){\n"
@@ -6247,27 +10442,31 @@ class TestOther : public TestFixture {
               "        x = 2;\n"
               "    return x + 1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // initialization, assignment with 0
         check("void f() {\n"  // Ticket #4356
               "    int x = 0;\n"  // <- ignore initialization with 0
               "    x = 3;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  state_t *x = NULL;\n"
               "  x = dostuff();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:12]: style: Variable 'x' can be declared as pointer to const [constVariablePointer]\n",
+            errout_str());
 
         check("void f() {\n"
               "  state_t *x;\n"
               "  x = NULL;\n"
               "  x = dostuff();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:12]: style: Variable 'x' can be declared as pointer to const [constVariablePointer]\n",
+            errout_str());
 
         check("int foo() {\n" // #4420
               "    int x;\n"
@@ -6275,7 +10474,7 @@ class TestOther : public TestFixture {
               "    x = 5;\n"
               "    return bar(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // struct member..
         check("struct AB { int a; int b; };\n"
@@ -6286,9 +10485,9 @@ class TestOther : public TestFixture {
               "    ab.a = 2;\n"
               "    return ab.a;\n"
               "}");
-        ASSERT_EQUALS("test.cpp:6:style:Variable 'ab.a' is reassigned a value before the old one has been used.\n"
-                      "test.cpp:5:note:ab.a is assigned\n"
-                      "test.cpp:6:note:ab.a is overwritten\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:10]: style: Variable 'ab.a' is reassigned a value before the old one has been used. [redundantAssignment]\n"
+                      "[test.cpp:5:10]: note: ab.a is assigned\n"
+                      "[test.cpp:6:10]: note: ab.a is overwritten\n", errout_str());
 
         check("struct AB { int a; int b; };\n"
               "\n"
@@ -6298,7 +10497,7 @@ class TestOther : public TestFixture {
               "    ab = do_something();\n"
               "    return ab.a;\n"
               "}");
-        TODO_ASSERT_EQUALS("error", "", errout.str());
+        TODO_ASSERT_EQUALS("error", "", errout_str());
 
         check("struct AB { int a; int b; };\n"
               "\n"
@@ -6309,7 +10508,7 @@ class TestOther : public TestFixture {
               "    ab.a = 2;\n"
               "    return ab.a;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct AB { int a; int b; };\n"
               "\n"
@@ -6320,7 +10519,7 @@ class TestOther : public TestFixture {
               "    ab.a = 2;\n"
               "    return ab.a;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct AB { int a; int b; };\n"
               "\n"
@@ -6331,7 +10530,7 @@ class TestOther : public TestFixture {
               "    ab->a = 1;\n"
               "    ab->b = 2;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct AB { int a; int b; };\n"
               "\n"
@@ -6342,20 +10541,20 @@ class TestOther : public TestFixture {
               "    ab->a = 1;\n"
               "    ab->b = 2;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(struct AB *ab) {\n" // #
               "    ab->data->x = 1;\n"
               "    ab = &ab1;\n"
               "    ab->data->x = 2;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #5964
         check("void func(char *buffer, const char *format, int precision, unsigned value) {\n"
               "    (precision < 0) ? sprintf(buffer, format, value) : sprintf(buffer, format, precision, value);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // don't crash
         check("struct data {\n"
@@ -6375,7 +10574,7 @@ class TestOther : public TestFixture {
               "    asm(\"foo\");\n"
               "    i = 1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6555
         check("void foo() {\n"
@@ -6388,7 +10587,7 @@ class TestOther : public TestFixture {
               "        barney(p);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    char *p = 0;\n"
@@ -6400,8 +10599,9 @@ class TestOther : public TestFixture {
               "        barney(x);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("test.cpp:2:style:The scope of the variable 'p' can be reduced.\n",
-                      errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: style: The scope of the variable 'p' can be reduced. [variableScope]\n"
+                      "[test.cpp:2:11]: style: Variable 'p' can be declared as pointer to const [constVariablePointer]\n",
+                      errout_str());
 
         check("void foo() {\n"
               "    char *p = 0;\n"
@@ -6415,19 +10615,19 @@ class TestOther : public TestFixture {
               "        barney(p);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Member variable pointers
         check("void podMemPtrs() {\n"
-              "    int POD::*memptr;\n"
+              "    const int POD::*memptr;\n"
               "    memptr = &POD::a;\n"
               "    memptr = &POD::b;\n"
               "    if (memptr)\n"
               "        memptr = 0;\n"
               "}");
-        ASSERT_EQUALS("test.cpp:4:style:Variable 'memptr' is reassigned a value before the old one has been used.\n"
-                      "test.cpp:3:note:memptr is assigned\n"
-                      "test.cpp:4:note:memptr is overwritten\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:12]: style: Variable 'memptr' is reassigned a value before the old one has been used. [redundantAssignment]\n"
+                      "[test.cpp:3:12]: note: memptr is assigned\n"
+                      "[test.cpp:4:12]: note: memptr is overwritten\n", errout_str());
 
         // Pointer function argument (#3857)
         check("void f(float * var)\n"
@@ -6435,18 +10635,90 @@ class TestOther : public TestFixture {
               "  var[0] = 0.2f;\n"
               "  var[0] = 0.2f;\n" // <-- is initialized twice
               "}");
-        ASSERT_EQUALS("test.cpp:4:style:Variable 'var[0]' is reassigned a value before the old one has been used.\n"
-                      "test.cpp:3:note:var[0] is assigned\n"
-                      "test.cpp:4:note:var[0] is overwritten\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:10]: style: Variable 'var[0]' is reassigned a value before the old one has been used. [redundantAssignment]\n"
+                      "[test.cpp:3:10]: note: var[0] is assigned\n"
+                      "[test.cpp:4:10]: note: var[0] is overwritten\n", errout_str());
+
+        check("void f(float * var)\n"
+              "{\n"
+              "  *var = 0.2f;\n"
+              "  *var = 0.2f;\n" // <-- is initialized twice
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:8]: style: Variable '*var' is reassigned a value before the old one has been used. [redundantAssignment]\n"
+                      "[test.cpp:3:8]: note: *var is assigned\n"
+                      "[test.cpp:4:8]: note: *var is overwritten\n", errout_str());
+
+        // Volatile variables
+        check("void f() {\n"
+              "  volatile char *reg = (volatile char *)0x12345;\n"
+              "  *reg = 12;\n"
+              "  *reg = 34;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::map<int, int>& m, int key, int value) {\n" // #6379
+              "    m[key] = value;\n"
+              "    m[key] = value;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:12]: style: Variable 'm[key]' is reassigned a value before the old one has been used. [redundantAssignment]\n"
+                      "[test.cpp:2:12]: note: m[key] is assigned\n"
+                      "[test.cpp:3:12]: note: m[key] is overwritten\n",
+                      errout_str());
+    }
+
+    void redundantVarAssignment_trivial() {
+        check("void f() {\n"
+              "   int a = 0;\n"
+              "   a = 4;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "   int a;\n"
+              "   a = 0;\n"
+              "   a = 4;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "   unsigned a;\n"
+              "   a = 0u;\n"
+              "   a = 2u;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "   void* a;\n"
+              "   a = (void*)0;\n"
+              "   a = p;\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:2:10]: (style) Variable 'a' can be declared as pointer to const [constVariablePointer]\n",
+            errout_str());
 
-        check("void f(float * var)\n"
-              "{\n"
-              "  *var = 0.2f;\n"
-              "  *var = 0.2f;\n" // <-- is initialized twice
+        check("void f() {\n"
+              "   void* a;\n"
+              "   a = (void*)0U;\n"
+              "   a = p;\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:2:10]: (style) Variable 'a' can be declared as pointer to const [constVariablePointer]\n",
+            errout_str());
+
+        check("std::string f() {\n" // #14534
+              "    std::string s = \"abc\";\n"
+              "    s = \"def\";\n"
+              "    return s;\n"
+              "}\n"
+              "const char* g() {\n"
+              "    const char* p = \"abc\";\n"
+              "    p = \"def\";\n"
+              "    return p;\n"
               "}");
-        ASSERT_EQUALS("test.cpp:4:style:Variable '*var' is reassigned a value before the old one has been used.\n"
-                      "test.cpp:3:note:*var is assigned\n"
-                      "test.cpp:4:note:*var is overwritten\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:19] -> [test.cpp:3:7]: (style) Redundant initialization for 's'. The initialized value is overwritten before it is read. [redundantInitialization]\n"
+            "[test.cpp:7:19] -> [test.cpp:8:7]: (style) Redundant initialization for 'p'. The initialized value is overwritten before it is read. [redundantInitialization]\n",
+            errout_str());
     }
 
     void redundantVarAssignment_struct() {
@@ -6459,7 +10731,7 @@ class TestOther : public TestFixture {
               "  x.a = _mm_set1_ps(1.0);\n"
               "  x.a = _mm_set1_ps(2.0);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:8]: (style) Variable 'x.a' is reassigned a value before the old one has been used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:7] -> [test.cpp:8:7]: (style) Variable 'x.a' is reassigned a value before the old one has been used. [redundantAssignment]\n", errout_str());
 
         check("void f() {\n"
               "  struct AB ab;\n"
@@ -6467,13 +10739,117 @@ class TestOther : public TestFixture {
               "  ab.y = 41;\n"
               "  ab.x = 1;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (style) Variable 'ab.x' is reassigned a value before the old one has been used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:8] -> [test.cpp:5:8]: (style) Variable 'ab.x' is reassigned a value before the old one has been used. [redundantAssignment]\n", errout_str());
 
         check("void f() {\n"
               "  struct AB ab = {0};\n"
               "  ab = foo();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void redundantVarAssignment_union() {
+        // Ticket #5115 "redundantAssignment when using a union"
+        check("void main(void)\n"
+              "{\n"
+              "    short lTotal = 0;\n"
+              "    union\n"
+              "    {\n"
+              "        short l1;\n"
+              "        struct\n"
+              "        {\n"
+              "            unsigned char b1;\n"
+              "            unsigned char b2;\n"
+              "        } b;\n"
+              "    } u;\n"
+              "    u.l1 = 1;\n"
+              "    lTotal += u.b.b1;\n"
+              "    u.l1 = 2;\n" //Should not show RedundantAssignment
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
+
+        // Ticket #5115 "redundantAssignment when using a union"
+        check("void main(void)\n"
+              "{\n"
+              "    short lTotal = 0;\n"
+              "    union\n"
+              "    {\n"
+              "        short l1;\n"
+              "        struct\n"
+              "        {\n"
+              "            unsigned char b1;\n"
+              "            unsigned char b2;\n"
+              "        } b;\n"
+              "    } u;\n"
+              "    u.l1 = 1;\n"
+              "    u.l1 = 2;\n"
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:13:10] -> [test.cpp:14:10]: (style) Variable 'u.l1' is reassigned a value before the old one has been used. [redundantAssignment]\n", errout_str());
+
+        // Ticket #10093 "redundantAssignment when using a union"
+        check("typedef union fixed32_union {\n"
+              "    struct {\n"
+              "        unsigned32 abcd;\n"
+              "    } u32;\n"
+              "    struct {\n"
+              "        unsigned16 ab;\n"
+              "        unsigned16 cd;\n"
+              "    } u16;"
+              "    struct {\n"
+              "        unsigned8 a;\n"
+              "        unsigned8 b;\n"
+              "        unsigned8 c;\n"
+              "        unsigned8 d;\n"
+              "        } b;\n"
+              "} fixed32;\n"
+              "void func1(void) {\n"
+              "    fixed32 m;\n"
+              "    m.u16.ab = 47;\n"
+              "    m.u16.cd = 0;\n"
+              "    m.u16.ab = m.u32.abcd / 53;\n"
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
+
+        // Ticket #10093 "redundantAssignment when using a union"
+        check("typedef union{\n"
+              "    char as_char[4];\n"
+              "    int as_int;\n"
+              "} union_t;\n"
+              "void fn(char *data, int len) {\n"
+              "    int i;\n"
+              "    for (i = 0; i < len; i++)\n"
+              "        data[i] = 'a';\n"
+              "}\n"
+              "int main(int argc, char *argv[]) {\n"
+              "    union_t u;\n"
+              "    u.as_int = 42;\n"
+              "    fn(&u.as_char[0], 4);\n"
+              "    u.as_int = 0;\n"
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
+
+        // Ticket #5115 "redundantAssignment when using a union"
+        check("void foo(char *ptr) {\n"
+              "    union {\n"
+              "        char * s8;\n"
+              "        unsigned long long u64;\n"
+              "    } addr;\n"
+              "    addr.s8 = ptr;\n"
+              "    addr.u64 += 8;\n"
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #12895
+              "    int x, y;\n"
+              "};\n"
+              "union U {\n"
+              "    S* s;\n"
+              "};\n"
+              "void f(const U& Src, const U& Dst) {\n"
+              "    Dst.s->x = Src.s->x;\n"
+              "    Dst.s->y = Src.s->y;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void redundantVarAssignment_7133() {
@@ -6495,8 +10871,8 @@ class TestOther : public TestFixture {
               "   }\n"
               "   catch (const uno::Exception&)  {\n"
               "   }\n"
-              "}", "test.cpp", false, true);
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void ConvertBitmapData(sal_uInt16 nDestBits) {\n"
               "    BitmapBuffer aSrcBuf;\n"
@@ -6504,8 +10880,8 @@ class TestOther : public TestFixture {
               "    BitmapBuffer aDstBuf;\n"
               "    aSrcBuf.mnBitCount = nDestBits;\n"
               "    bConverted = ::ImplFastBitmapConversion( aDstBuf, aSrcBuf, aTwoRects );\n"
-              "}", "test.c");
-        ASSERT_EQUALS("[test.c:3] -> [test.c:5]: (style) Variable 'aSrcBuf.mnBitCount' is reassigned a value before the old one has been used.\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:3:24] -> [test.c:5:24]: (style) Variable 'aSrcBuf.mnBitCount' is reassigned a value before the old one has been used. [redundantAssignment]\n", errout_str());
         check("void ConvertBitmapData(sal_uInt16 nDestBits) {\n"
               "    BitmapBuffer aSrcBuf;\n"
               "    aSrcBuf.mnBitCount = nSrcBits;\n"
@@ -6513,8 +10889,8 @@ class TestOther : public TestFixture {
               "    aSrcBuf.mnBitCount = nDestBits;\n"
               "    bConverted = ::ImplFastBitmapConversion( aDstBuf, aSrcBuf, aTwoRects );\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (style) Variable 'aSrcBuf.mnBitCount' is reassigned a value before the old one has been used.\n",
-                      errout.str());
+        ASSERT_EQUALS("[test.cpp:3:24] -> [test.cpp:5:24]: (style) Variable 'aSrcBuf.mnBitCount' is reassigned a value before the old one has been used. [redundantAssignment]\n",
+                      errout_str());
 
         check("class C { void operator=(int x); };\n" // #8368 - assignment operator might have side effects => inconclusive
               "void f() {\n"
@@ -6522,7 +10898,7 @@ class TestOther : public TestFixture {
               "    c = x;\n"
               "    c = x;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:5]: (style, inconclusive) Variable 'c' is reassigned a value before the old one has been used if variable is no semaphore variable.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7] -> [test.cpp:5:7]: (style, inconclusive) Variable 'c' is reassigned a value before the old one has been used if variable is no semaphore variable. [redundantAssignment]\n", errout_str());
     }
 
     void redundantVarAssignment_stackoverflow() {
@@ -6536,7 +10912,7 @@ class TestOther : public TestFixture {
               "    m->next->prev = m->prev;\n"
               "    return m->next;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void redundantVarAssignment_lambda() {
@@ -6550,10 +10926,19 @@ class TestOther : public TestFixture {
               "    f();\n"
               "    return y;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // #10228
+        check("std::tuple<int, int> g();\n"
+              "void h(int);\n"
+              "void f() {\n"
+              "    auto [a, b] = g();\n"
+              "    auto l = [a = a]() { h(i); };\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void redundantVarAssignment_for() {
+    void redundantVarAssignment_loop() {
         check("void f() {\n"
               "    char buf[10];\n"
               "    int i;\n"
@@ -6561,7 +10946,30 @@ class TestOther : public TestFixture {
               "        buf[i] = 131;\n"
               "    buf[i] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void bar() {\n" // #9262 do-while with break
+              "    int x = 0;\n"
+              "    x = 432;\n"
+              "    do {\n"
+              "        if (foo()) break;\n"
+              "        x = 1;\n"
+              "     } while (false);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo(int num) {\n" // #9420 FP
+              "  int a = num;\n"
+              "  for (int b = 0; b < num; a = b++)\n"
+              "    dostuff(a);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo(int num) {\n" // #9420 FN
+              "  int a = num;\n"
+              "  for (int b = 0; b < num; a = b++);\n"
+              "}");
+        TODO_ASSERT_EQUALS("error", "", errout_str());
     }
 
     void redundantVarAssignment_after_switch() {
@@ -6574,7 +10982,7 @@ class TestOther : public TestFixture {
               "    }\n"
               "    ret = 3;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:8]: (style) Variable 'ret' is reassigned a value before the old one has been used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:13] -> [test.cpp:8:9]: (style) Variable 'ret' is reassigned a value before the old one has been used. [redundantAssignment]\n", errout_str());
     }
 
     void redundantVarAssignment_pointer() {
@@ -6584,7 +10992,7 @@ class TestOther : public TestFixture {
               "    foo(ptr);\n"
               "    *x = 32;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #8997
         check("void f() {\n"
@@ -6594,7 +11002,7 @@ class TestOther : public TestFixture {
               "  p += 1;\n"
               "  *p = 1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void redundantVarAssignment_pointer_parameter() {
@@ -6603,7 +11011,47 @@ class TestOther : public TestFixture {
               "    if (condition) return;\n"
               "    *p = 2;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void redundantVarAssignment_array() {
+        check("void f() {\n"
+              "    int arr[10];\n"
+              "    int i = 0;\n"
+              "    arr[i] = 1;\n"
+              "    i += 2;\n"
+              "    arr[i] = 3;\n"
+              "    dostuff(arr);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void redundantVarAssignment_switch_break() {
+        // #10058
+        check("void f(int a, int b) {\n"
+              "    int ret = 0;\n"
+              "    switch (a) {\n"
+              "    case 1:\n"
+              "        ret = 543;\n"
+              "        if (b) break;\n"
+              "        ret = 1;\n"
+              "        break;\n"
+              "    }"
+              "    return ret;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int a, int b) {\n"
+              "    int ret = 0;\n"
+              "    switch (a) {\n"
+              "    case 1:\n"
+              "        ret = 543;\n"
+              "        if (b) break;\n"
+              "        ret = 1;\n"
+              "        break;\n"
+              "    }"
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:13] -> [test.cpp:7:13]: (style) Variable 'ret' is reassigned a value before the old one has been used. [redundantAssignment]\n", errout_str());
     }
 
     void redundantInitialization() {
@@ -6613,57 +11061,80 @@ class TestOther : public TestFixture {
               "    int err = -ENOMEM;\n"
               "    err = dostuff();\n"
               "}");
-        ASSERT_EQUALS("test.cpp:3:style:Redundant initialization for 'err'. The initialized value is overwritten before it is read.\n"
-                      "test.cpp:2:note:err is initialized\n"
-                      "test.cpp:3:note:err is overwritten\n",
-                      errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: style: Redundant initialization for 'err'. The initialized value is overwritten before it is read. [redundantInitialization]\n"
+                      "[test.cpp:2:13]: note: err is initialized\n"
+                      "[test.cpp:3:9]: note: err is overwritten\n",
+                      errout_str());
 
         check("void f() {\n"
               "    struct S s = {1,2,3};\n"
               "    s = dostuff();\n"
               "}");
-        ASSERT_EQUALS("test.cpp:3:style:Redundant initialization for 's'. The initialized value is overwritten before it is read.\n"
-                      "test.cpp:2:note:s is initialized\n"
-                      "test.cpp:3:note:s is overwritten\n",
-                      errout.str());
+        ASSERT_EQUALS("[test.cpp:3:7]: style: Redundant initialization for 's'. The initialized value is overwritten before it is read. [redundantInitialization]\n"
+                      "[test.cpp:2:16]: note: s is initialized\n"
+                      "[test.cpp:3:7]: note: s is overwritten\n",
+                      errout_str());
 
         check("void f() {\n"
               "    int *p = NULL;\n"
               "    p = dostuff();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:10]: style: Variable 'p' can be declared as pointer to const [constVariablePointer]\n",
+            errout_str());
 
+        // "trivial" initialization => do not warn
         check("void f() {\n"
               "    struct S s = {0};\n"
               "    s = dostuff();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("namespace N { enum E {e0,e1}; }\n"
+              "void f() {\n"
+              "    N::E e = N::e0;\n" // #9261
+              "    e = dostuff();\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n" // #10143
+              "    std::shared_ptr<int> i = g();\n"
+              "    h();\n"
+              "    i = nullptr;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(const std::vector<int>& v) {\n" // #9815
+              "    int i = g();\n"
+              "    i = std::distance(v.begin(), std::find_if(v.begin(), v.end(), [=](int j) { return i == j; }));\n"
+              "    return i;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
+    // cppcheck-suppress unusedPrivateFunction
     void redundantMemWrite() {
-        return; // FIXME: temporary hack
-
         // Simple tests
         check("void f() {\n"
               "    char a[10];\n"
               "    memcpy(a, foo, bar);\n"
               "    memset(a, 0, bar);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (performance) Buffer 'a' is being written before its old content has been used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (performance) Buffer 'a' is being written before its old content has been used.\n", errout_str());
 
         check("void f() {\n"
               "    char a[10];\n"
               "    strcpy(a, foo);\n"
               "    strncpy(a, 0, bar);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (performance) Buffer 'a' is being written before its old content has been used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (performance) Buffer 'a' is being written before its old content has been used.\n", errout_str());
 
         check("void f() {\n"
               "    char a[10];\n"
               "    sprintf(a, \"foo\");\n"
               "    memmove(a, 0, bar);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (performance) Buffer 'a' is being written before its old content has been used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (performance) Buffer 'a' is being written before its old content has been used.\n", errout_str());
 
         check("void f(char *filename) {\n"
               "    char *p = strrchr(filename,'.');\n"
@@ -6671,14 +11142,14 @@ class TestOther : public TestFixture {
               "    dostuff(filename);\n"
               "    strcpy(p, \"foo\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Writing to different parts of a buffer
         check("void f(void* a) {\n"
               "    memcpy(a, foo, bar);\n"
               "    memset(a+5, 0, bar);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Use variable as second argument
         check("void f(void* a, void* b) {\n"
@@ -6686,7 +11157,7 @@ class TestOther : public TestFixture {
               "    memcpy(b, a, 5);\n"
               "    memset(a, 1, 5);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // strcat is special
         check("void f() {\n"
@@ -6695,7 +11166,7 @@ class TestOther : public TestFixture {
               "    strcat(a, bar);\n" // Not redundant
               "    strcpy(a, x);\n" // Redundant
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (performance) Buffer 'a' is being written before its old content has been used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (performance) Buffer 'a' is being written before its old content has been used.\n", errout_str());
 
         // Tests with function call between copy
         check("void f() {\n"
@@ -6704,7 +11175,7 @@ class TestOther : public TestFixture {
               "    bar();\n"
               "    memset(a, 0, size);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (performance) Buffer 'a' is being written before its old content has been used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (performance) Buffer 'a' is being written before its old content has been used.\n", errout_str());
 
         check("void* a;\n"
               "void f() {\n"
@@ -6712,7 +11183,7 @@ class TestOther : public TestFixture {
               "    bar();\n" // Global variable might be accessed in bar()
               "    memset(a, 0, size);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char a[10];\n"
@@ -6720,7 +11191,7 @@ class TestOther : public TestFixture {
               "    bar();\n"
               "    memset(a, 0, size);\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (performance) Buffer 'a' is being written before its old content has been used.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (performance) Buffer 'a' is being written before its old content has been used.\n", "", errout_str());
 
         check("void bar(void* a) {}\n"
               "void f(void* a) {\n"
@@ -6728,7 +11199,7 @@ class TestOther : public TestFixture {
               "    bar(a);\n" // Passed as argument
               "    memset(a, 0, size);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Branch tests
         check("void f(void* a) {\n"
@@ -6736,7 +11207,7 @@ class TestOther : public TestFixture {
               "    if(x)\n"
               "        memset(a, 0, size);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #4455 - initialization of local buffer
         check("void f(void) {"
@@ -6744,14 +11215,14 @@ class TestOther : public TestFixture {
               "    memset(buf, 0, 10);\n"
               "    strcpy(buf, string);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(void) {\n"
               "    char buf[10] = {0};\n"
               "    memset(buf, 0, 10);\n"
               "    strcpy(buf, string);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (performance) Buffer 'buf' is being written before its old content has been used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (performance) Buffer 'buf' is being written before its old content has been used.\n", errout_str());
 
         // #5689 - use return value of strcpy
         check("int f(void* a) {\n"
@@ -6759,7 +11230,7 @@ class TestOther : public TestFixture {
               "    strncpy(a, 0, bar);\n"
               "    return i;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #7175 - read+write
         check("void f() {\n"
@@ -6768,7 +11239,7 @@ class TestOther : public TestFixture {
               "    strcpy(buf, dostuff(buf));\n" // <- read + write
               "    strcpy(buf, x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char buf[100];\n"
@@ -6776,110 +11247,86 @@ class TestOther : public TestFixture {
               "    strcpy(buf, dostuff(buf));\n"
               "    strcpy(buf, x);\n"
               "}");
-        TODO_ASSERT_EQUALS("error", "", errout.str());
+        TODO_ASSERT_EQUALS("error", "", errout_str());
+    }
+
+    void redundantAssignmentSameValue() {
+        check("int main() {\n" // #11642
+              "    int a = 0;\n"
+              "    int b = a;\n"
+              "    int c = 1;\n"
+              "    a = b;\n"
+              "    return a * b * c;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:5:5]: (style) Variable 'a' is assigned an expression that holds the same value. [redundantAssignment]\n", errout_str());
+
+        check("int main() {\n"
+              "    int a = 0;\n"
+              "    int b = a;\n"
+              "    int c = 1;\n"
+              "    a = b + 1;\n"
+              "    return a * b * c;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int main() {\n"
+              "    int a = 0;\n"
+              "    int b = a;\n"
+              "    int c = 1;\n"
+              "    a = b = 5;\n"
+              "    return a * b * c;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:11] -> [test.cpp:5:11]: (style) Redundant initialization for 'b'. The initialized value is overwritten before it is read. [redundantInitialization]\n", errout_str());
+
+        check("int f(int i) {\n" // #12874
+              "    int j = i + 1;\n"
+              "    if (i > 5)\n"
+              "        j = i;\n"
+              "    return j;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #12894
+              "    std::string a;\n"
+              "    void f(const S& s);\n"
+              "    void g(const S& s);\n"
+              "};\n"
+              "void S::f(const S& s) {\n"
+              "    std::string x = a;\n"
+              "    this->operator=(s);\n"
+              "    a = x;\n"
+              "}\n"
+              "void S::g(const S& s) {\n"
+              "    std::string x = a;\n"
+              "    operator=(s);\n"
+              "    a = x;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int a, int b, int c) {\n" // #4491
+              "    int x = a + b;\n"
+              "    if (c)\n"
+              "        x = a + b;\n"
+              "    return x;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:4:9]: (style) Variable 'x' is assigned an expression that holds the same value. [redundantAssignment]\n",
+                      errout_str());
     }
 
     void varFuncNullUB() { // #4482
         check("void a(...);\n"
               "void b() { a(NULL); }");
-        ASSERT_EQUALS("[test.cpp:2]: (portability) Passing NULL after the last typed argument to a variadic function leads to undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (portability) Passing NULL after the last typed argument to a variadic function leads to undefined behaviour. [varFuncNullUB]\n", errout_str());
 
         check("void a(char *p, ...);\n"
               "void b() { a(NULL, 2); }");
-        ASSERT_EQUALS("", errout.str());
-    }
-
-    void checkPipeParameterSize() { // #3521
-
-        checkposix("void f(){\n"
-                   "int pipefd[1];\n" // <--  array of two integers is needed
-                   "if (pipe(pipefd) == -1) {\n"
-                   "    return;\n"
-                   "  }\n"
-                   "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Buffer 'pipefd' must have size of 2 integers if used as parameter of pipe().\n", errout.str());
-
-        checkposix("void f(){\n"
-                   "int pipefd[2];\n"
-                   "if (pipe(pipefd) == -1) {\n"
-                   "    return;\n"
-                   "  }\n"
-                   "}");
-        ASSERT_EQUALS("", errout.str());
-
-        checkposix("void f(){\n"
-                   "int pipefd[20];\n"
-                   "if (pipe(pipefd) == -1) {\n"
-                   "    return;\n"
-                   "  }\n"
-                   "}");
-        ASSERT_EQUALS("", errout.str());
-
-        checkposix("void f(){\n"
-                   "int pipefd[1];\n" // <--  array of two integers is needed
-                   "if (pipe2(pipefd,0) == -1) {\n"
-                   "    return;\n"
-                   "  }\n"
-                   "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Buffer 'pipefd' must have size of 2 integers if used as parameter of pipe().\n", errout.str());
-
-        checkposix("void f(){\n"
-                   "int pipefd[2];\n"
-                   "if (pipe2(pipefd,0) == -1) {\n"
-                   "    return;\n"
-                   "  }\n"
-                   "}");
-        ASSERT_EQUALS("", errout.str());
-
-        checkposix("void f(){\n"
-                   "int pipefd[20];\n"
-                   "if (pipe2(pipefd,0) == -1) {\n"
-                   "    return;\n"
-                   "  }\n"
-                   "}");
-        ASSERT_EQUALS("", errout.str());
-
-        // avoid crash with pointer variable
-        check("void foo (int* arrayPtr)\n"
-              "{\n"
-              "  if (pipe (arrayPtr) < 0)\n"
-              "  {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
-
-        // avoid crash with pointer variable - for local variable on stack as well - see #4801
-        check("void foo() {\n"
-              "  int *cp;\n"
-              "  if ( pipe (cp) == -1 ) {\n"
-              "     return;\n"
-              "  }\n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
-
-        // test with unknown variable
-        check("void foo() {\n"
-              "  if ( pipe (cp) == -1 ) {\n"
-              "     return;\n"
-              "  }\n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
-
-        // avoid crash with pointer variable - for local variable on stack as well - see #4801
-        check("void foo() {\n"
-              "  int *cp;\n"
-              "  if ( pipe (cp) == -1 ) {\n"
-              "     return;\n"
-              "  }\n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        // test with unknown variable
-        check("void foo() {\n"
-              "  if ( pipe (cp) == -1 ) {\n"
-              "     return;\n"
-              "  }\n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
+        checkP("extern const int sentinel;\n"
+               "void a(int, ...);\n"
+               "#define b(x, ...) a((x), __VA_ARGS__, &sentinel)\n"
+               "void c() { b(1, NULL); }");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void checkCastIntToCharAndBack() { // #160
@@ -6893,7 +11340,7 @@ class TestOther : public TestFixture {
               "    c = getchar();\n"
               "  } ;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Storing getchar() return value in char variable and then comparing with EOF.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (warning) Storing getchar() return value in char variable and then comparing with EOF. [checkCastIntToCharAndBack]\n", errout_str());
 
         check("void f() {\n"
               "unsigned char c = getchar();\n"
@@ -6902,7 +11349,7 @@ class TestOther : public TestFixture {
               "    bar(c);\n"
               "  } ;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Storing getchar() return value in char variable and then comparing with EOF.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:17]: (warning) Storing getchar() return value in char variable and then comparing with EOF. [checkCastIntToCharAndBack]\n", errout_str());
 
         check("void f() {\n"
               "  unsigned char c; c = getchar();\n"
@@ -6912,7 +11359,15 @@ class TestOther : public TestFixture {
               "    c = getchar();\n"
               "  } ;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Storing getchar() return value in char variable and then comparing with EOF.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:17]: (warning) Storing getchar() return value in char variable and then comparing with EOF. [checkCastIntToCharAndBack]\n", errout_str());
+
+        check("void f() {\n"
+              "  unsigned char c;\n"
+              "  while( EOF != ( c = getchar() ) )\n"
+              "  {\n"
+              "  }\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:19]: (warning) Storing getchar() return value in char variable and then comparing with EOF. [checkCastIntToCharAndBack]\n", errout_str());
 
         check("void f() {\n"
               "  int i; i = getchar();\n"
@@ -6922,7 +11377,7 @@ class TestOther : public TestFixture {
               "    i = getchar();\n"
               "  } ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  int i; i = getchar();\n"
@@ -6932,7 +11387,7 @@ class TestOther : public TestFixture {
               "    i = getchar();\n"
               "  } ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
 
         // check getc
@@ -6940,33 +11395,33 @@ class TestOther : public TestFixture {
               "unsigned char c;\n"
               "do {\n"
               "  c = getc (pFile);\n"
-              "} while (c != EOF)"
+              "} while (c != EOF);"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Storing getc() return value in char variable and then comparing with EOF.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10]: (warning) Storing getc() return value in char variable and then comparing with EOF. [checkCastIntToCharAndBack]\n", errout_str());
 
         check("void f (FILE * pFile){\n"
               "unsigned char c;\n"
               "do {\n"
               "  c = getc (pFile);\n"
-              "} while (EOF != c)"
+              "} while (EOF != c);"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Storing getc() return value in char variable and then comparing with EOF.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:17]: (warning) Storing getc() return value in char variable and then comparing with EOF. [checkCastIntToCharAndBack]\n", errout_str());
 
         check("void f (FILE * pFile){\n"
               "int i;\n"
               "do {\n"
               "  i = getc (pFile);\n"
-              "} while (i != EOF)"
+              "} while (i != EOF);"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f (FILE * pFile){\n"
               "int i;\n"
               "do {\n"
               "  i = getc (pFile);\n"
-              "} while (EOF != i)"
+              "} while (EOF != i);"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
 
         // check fgetc
@@ -6974,41 +11429,41 @@ class TestOther : public TestFixture {
               "unsigned char c;\n"
               "do {\n"
               "  c = fgetc (pFile);\n"
-              "} while (c != EOF)"
+              "} while (c != EOF);"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Storing fgetc() return value in char variable and then comparing with EOF.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10]: (warning) Storing fgetc() return value in char variable and then comparing with EOF. [checkCastIntToCharAndBack]\n", errout_str());
 
         check("void f (FILE * pFile){\n"
               "char c;\n"
               "do {\n"
               "  c = fgetc (pFile);\n"
-              "} while (EOF != c)"
+              "} while (EOF != c);"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Storing fgetc() return value in char variable and then comparing with EOF.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:17]: (warning) Storing fgetc() return value in char variable and then comparing with EOF. [checkCastIntToCharAndBack]\n", errout_str());
 
         check("void f (FILE * pFile){\n"
               "signed char c;\n"
               "do {\n"
               "  c = fgetc (pFile);\n"
-              "} while (EOF != c)"
+              "} while (EOF != c);"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f (FILE * pFile){\n"
               "int i;\n"
               "do {\n"
               "  i = fgetc (pFile);\n"
-              "} while (i != EOF)"
+              "} while (i != EOF);"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f (FILE * pFile){\n"
               "int i;\n"
               "do {\n"
               "  i = fgetc (pFile);\n"
-              "} while (EOF != i)"
+              "} while (EOF != i);"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // cin.get()
         check("void f(){\n"
@@ -7018,7 +11473,7 @@ class TestOther : public TestFixture {
               "        ch = std::cin.get();\n"
               "   }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Storing cin.get() return value in char variable and then comparing with EOF.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:18]: (warning) Storing cin.get() return value in char variable and then comparing with EOF. [checkCastIntToCharAndBack]\n", errout_str());
 
         check("void f(){\n"
               "   char ch; ch = std::cin.get();\n"
@@ -7027,7 +11482,7 @@ class TestOther : public TestFixture {
               "        ch = std::cin.get();\n"
               "   }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Storing cin.get() return value in char variable and then comparing with EOF.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (warning) Storing cin.get() return value in char variable and then comparing with EOF. [checkCastIntToCharAndBack]\n", errout_str());
 
         check("void f(){\n"
               "   int i; i = std::cin.get();\n"
@@ -7036,7 +11491,7 @@ class TestOther : public TestFixture {
               "        i = std::cin.get();\n"
               "   }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(){\n"
               "   int i; i = std::cin.get();\n"
@@ -7045,7 +11500,7 @@ class TestOther : public TestFixture {
               "        i = std::cin.get();\n"
               "   }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void checkCommaSeparatedReturn() {
@@ -7053,33 +11508,33 @@ class TestOther : public TestFixture {
               "  if (a < 0)\n"
               "    return a++,\n"
               "  do_something();\n"
-              "}", nullptr, true, false, false);
-        ASSERT_EQUALS("[test.cpp:3]: (style) Comma is used in return statement. The comma can easily be misread as a ';'.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        TODO_ASSERT_EQUALS("[test.cpp:3]: (style) Comma is used in return statement. The comma can easily be misread as a ';'.\n", "", errout_str());
 
         check("int fun(int a) {\n"
               "  if (a < 0)\n"
               "    return a++, do_something();\n"
-              "}", nullptr, true, false, false);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("int fun(int a) {\n"
               "  if (a < 0)\n"
               "    return a+5,\n"
               "  do_something();\n"
-              "}", nullptr, true, false, false);
-        ASSERT_EQUALS("[test.cpp:3]: (style) Comma is used in return statement. The comma can easily be misread as a ';'.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        TODO_ASSERT_EQUALS("[test.cpp:3]: (style) Comma is used in return statement. The comma can easily be misread as a ';'.\n", "", errout_str());
 
         check("int fun(int a) {\n"
               "  if (a < 0)\n"
               "    return a+5, do_something();\n"
-              "}", nullptr, true, false, false);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("int fun(int a) {\n"
               "  if (a < 0)\n"
               "    return c<int,\nint>::b;\n"
-              "}", nullptr, true, false, false);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         // #4943 take care of C++11 initializer lists
         check("std::vector<Foo> Bar() {\n"
@@ -7089,8 +11544,8 @@ class TestOther : public TestFixture {
               "        { \"2\" },\n"
               "        { \"3\" }\n"
               "    };\n"
-              "}", nullptr, true, false, false);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void checkPassByReference() {
@@ -7105,8 +11560,8 @@ class TestOther : public TestFixture {
               "    explicit B(A a) : a(std::move(a)) {}\n"
               "    void Init(A _a) { a = std::move(_a); }\n"
               "    A a;"
-              "};", nullptr, false, false, true);
-        ASSERT_EQUALS("", errout.str());
+              "};", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A\n"
               "{\n"
@@ -7118,8 +11573,8 @@ class TestOther : public TestFixture {
               "    explicit B(A a) : a{std::move(a)} {}\n"
               "    void Init(A _a) { a = std::move(_a); }\n"
               "    A a;"
-              "};", nullptr, false, false, true);
-        ASSERT_EQUALS("", errout.str());
+              "};", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A\n"
               "{\n"
@@ -7132,8 +11587,8 @@ class TestOther : public TestFixture {
               "    void Init(A _a) { a = std::move(_a); }\n"
               "    A a;"
               "    A a2;"
-              "};", nullptr, false, false, true);
-        ASSERT_EQUALS("", errout.str());
+              "};", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A\n"
               "{\n"
@@ -7146,8 +11601,8 @@ class TestOther : public TestFixture {
               "    void Init(A _a) { a = std::move(_a); }\n"
               "    A a;"
               "    A a2;"
-              "};", nullptr, false, false, true);
-        ASSERT_EQUALS("[test.cpp:8]: (performance) Function parameter 'a2' should be passed by const reference.\n", errout.str());
+              "};", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:8:14]: (performance) Function parameter 'a2' should be passed by const reference. [passedByValue]\n", errout_str());
 
         check("struct A\n"
               "{\n"
@@ -7160,8 +11615,51 @@ class TestOther : public TestFixture {
               "    void Init(A _a) { a = std::move(_a); }\n"
               "    A a;"
               "    A a2;"
-              "};", nullptr, false, false, true);
-        ASSERT_EQUALS("[test.cpp:8]: (performance) Function parameter 'a2' should be passed by const reference.\n", errout.str());
+              "};", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:8:14]: (performance) Function parameter 'a2' should be passed by const reference. [passedByValue]\n", errout_str());
+
+        check("std::map<int, int> m;\n" // #10817
+              "void f(const decltype(m)::const_iterator i) {}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int (*pf) (std::vector<int>) = nullptr;\n" // #12118
+              "int f(std::vector<int> v) {\n"
+              "    return v.size();\n"
+              "}\n"
+              "void g() {\n"
+              "    pf = f;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:10] -> [test.cpp:2:24]: (performance) Function parameter 'v' should be passed by const reference. However it seems that 'f' is a callback function. [passedByValueCallback]\n",
+                      errout_str());
+
+        check("template<typename T> struct A;\n" // #12621
+              "template<typename T>\n"
+              "struct B { A<T> a; };\n"
+              "template<typename T>\n"
+              "struct A { B<T> b; };\n"
+              "template<typename T>\n"
+              "struct C : public virtual A<T>, public virtual B<T> {\n"
+              "    A<T> x;\n"
+              "    B<T> y;\n"
+              "    C(A<T> x_, B<T> y_) : x(x_), y(y_) {}\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str()); // don't crash
+
+        check("template <typename T, int N>\n" // #13537
+              "    struct S {\n"
+              "    T a[N];\n"
+              "};\n"
+              "void f(S<char, 3> s) {}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        Settings settingsUnix32 = settingsBuilder().platform(Platform::Type::Unix32).build();
+        check("struct S {\n" // #13850
+              "    int i0 : 32;\n"
+              "    int i1 : 16;\n"
+              "    unsigned short u16;\n"
+              "};\n"
+              "void f(S s) {}\n", dinit(CheckOptions, $.settings = &settingsUnix32));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void checkComparisonFunctionIsAlwaysTrueOrFalse() {
@@ -7169,105 +11667,136 @@ class TestOther : public TestFixture {
         check("bool f(int x){\n"
               "   return isless(x,x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of two identical variables with isless(x,x) always evaluates to false.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (warning) Comparison of two identical variables with isless(x,x) always evaluates to false. [comparisonFunctionIsAlwaysTrueOrFalse]\n", errout_str());
 
         check("bool f(int x){\n"
               "   return isgreater(x,x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of two identical variables with isgreater(x,x) always evaluates to false.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (warning) Comparison of two identical variables with isgreater(x,x) always evaluates to false. [comparisonFunctionIsAlwaysTrueOrFalse]\n", errout_str());
 
         check("bool f(int x){\n"
               "   return islessgreater(x,x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of two identical variables with islessgreater(x,x) always evaluates to false.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (warning) Comparison of two identical variables with islessgreater(x,x) always evaluates to false. [comparisonFunctionIsAlwaysTrueOrFalse]\n", errout_str());
 
         check("bool f(int x){\n"
               "   return islessequal(x,x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of two identical variables with islessequal(x,x) always evaluates to true.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (warning) Comparison of two identical variables with islessequal(x,x) always evaluates to true. [comparisonFunctionIsAlwaysTrueOrFalse]\n", errout_str());
 
         check("bool f(int x){\n"
               "   return isgreaterequal(x,x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Comparison of two identical variables with isgreaterequal(x,x) always evaluates to true.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (warning) Comparison of two identical variables with isgreaterequal(x,x) always evaluates to true. [comparisonFunctionIsAlwaysTrueOrFalse]\n", errout_str());
 
         // no warning should be reported for
         check("bool f(int x, int y){\n"
               "   return isgreaterequal(x,y) && islessequal(x,y) && islessgreater(x,y) && isgreater(x,y) && isless(x,y);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void integerOverflow() { // 5895
         // no signed integer overflow should happen
         check("void f(unsigned long long ull) {\n"
               "    if (ull == 0x89504e470d0a1a0a || ull == 0x8a4d4e470d0a1a0a) ;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void redundantPointerOp() {
         check("int *f(int *x) {\n"
               "    return &*x;\n"
-              "}\n", nullptr, false, true);
-        ASSERT_EQUALS("[test.cpp:2]: (style) Redundant pointer operation on 'x' - it's already a pointer.\n", errout.str());
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:12]: (style) Redundant pointer operation on 'x' - it's already a pointer. [redundantPointerOp]\n", errout_str());
 
         check("int *f(int *y) {\n"
               "    return &(*y);\n"
-              "}\n", nullptr, false, true);
-        ASSERT_EQUALS("[test.cpp:2]: (style) Redundant pointer operation on 'y' - it's already a pointer.\n", errout.str());
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:12]: (style) Redundant pointer operation on 'y' - it's already a pointer. [redundantPointerOp]\n", errout_str());
+
+        check("int f() {\n" // #10991
+              "    int value = 4;\n"
+              "    int result1 = *(&value);\n"
+              "    int result2 = *&value;\n"
+              "    return result1 + result2;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:19]: (style) Redundant pointer operation on 'value' - it's already a variable. [redundantPointerOp]\n"
+                      "[test.cpp:4:19]: (style) Redundant pointer operation on 'value' - it's already a variable. [redundantPointerOp]\n",
+                      errout_str());
+
+        check("void f(int& a, int b) {\n"
+              "    *(&a) = b;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:5]: (style) Redundant pointer operation on 'a' - it's already a variable. [redundantPointerOp]\n",
+                      errout_str());
+
+        check("void f(int**& p) {}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkP("#define	RESTORE(ORIG, COPY) { *ORIG = *COPY; }\n"
+               "void f(int* p, int i) {\n"
+               "    RESTORE(p, &i);\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
 
         // no warning for bitwise AND
-        check("void f(int *b) {\n"
+        check("void f(const int *b) {\n"
               "    int x = 0x20 & *b;\n"
-              "}\n", nullptr, false, true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
 
         // No message for double pointers to structs
         check("void f(struct foo **my_struct) {\n"
               "    char **pass_to_func = &(*my_struct)->buf;\n"
-              "}\n", nullptr, false, true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
 
         // another double pointer to struct - with an array
         check("void f(struct foo **my_struct) {\n"
               "    char **pass_to_func = &(*my_struct)->buf[10];\n"
-              "}\n", nullptr, false, true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
 
         // double pointer to array
         check("void f(char **ptr) {\n"
               "    int *x = &(*ptr)[10];\n"
-              "}\n", nullptr, false, true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:10]: (style) Variable 'x' can be declared as pointer to const [constVariablePointer]\n", errout_str());
 
         // function calls
         check("void f(Mutex *mut) {\n"
               "    pthread_mutex_lock(&*mut);\n"
-              "}\n", nullptr, false, false);
-        ASSERT_EQUALS("[test.cpp:2]: (style) Redundant pointer operation on 'mut' - it's already a pointer.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:2:24]: (style) Redundant pointer operation on 'mut' - it's already a pointer. [redundantPointerOp]\n", errout_str());
 
         // make sure we got the AST match for "(" right
         check("void f(char *ptr) {\n"
               "    if (&*ptr == NULL)\n"
               "        return;\n"
-              "}\n", nullptr, false, true);
-        ASSERT_EQUALS("[test.cpp:2]: (style) Redundant pointer operation on 'ptr' - it's already a pointer.\n", errout.str());
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Redundant pointer operation on 'ptr' - it's already a pointer. [redundantPointerOp]\n", errout_str());
 
         // no warning for macros
-        check("#define MUTEX_LOCK(m) pthread_mutex_lock(&(m))\n"
-              "void f(struct mutex *mut) {\n"
-              "    MUTEX_LOCK(*mut);\n"
-              "}\n", nullptr, false, true);
-        ASSERT_EQUALS("", errout.str());
+        checkP("#define MUTEX_LOCK(m) pthread_mutex_lock(&(m))\n"
+               "void f(struct mutex *mut) {\n"
+               "    MUTEX_LOCK(*mut);\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
 
+        checkP("#define B(op)        bar(op)\n"
+               "#define C(orf)       B(&orf)\n"
+               "void foo(const int * pkey) {\n"
+               "    C(*pkey);\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void test_isSameExpression() { // see #5738
         check("bool isInUnoIncludeFile(StringRef name) {"
               "   return  name.startswith(SRCDIR \"/com/\") || name.startswith(SRCDIR \"/uno/\");\n"
-              "};", "test.cpp", false, false);
-        ASSERT_EQUALS("", errout.str());
+              "};", dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void raceAfterInterlockedDecrement() {
@@ -7275,8 +11804,8 @@ class TestOther : public TestFixture {
                                   "    int counter = 0;\n"
                                   "    InterlockedDecrement(&counter);\n"
                                   "    whatever();\n"
-                                  "}\n");
-        ASSERT_EQUALS("", errout.str());
+                                  "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
                                   "    int counter = 0;\n"
@@ -7284,16 +11813,16 @@ class TestOther : public TestFixture {
                                   "    if (counter)\n"
                                   "        return;\n"
                                   "    destroy();\n"
-                                  "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead.\n", errout.str());
+                                  "}");
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
                                   "    int counter = 0;\n"
                                   "    InterlockedDecrement(&counter);\n"
                                   "    if (!counter)\n"
                                   "        destroy();\n"
-                                  "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead.\n", errout.str());
+                                  "}");
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
                                   "    int counter = 0;\n"
@@ -7301,8 +11830,8 @@ class TestOther : public TestFixture {
                                   "    if (counter > 0)\n"
                                   "        return;\n"
                                   "    destroy();\n"
-                                  "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead.\n", errout.str());
+                                  "}");
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
                                   "    int counter = 0;\n"
@@ -7310,24 +11839,24 @@ class TestOther : public TestFixture {
                                   "    if (0 < counter)\n"
                                   "        return;\n"
                                   "    destroy();\n"
-                                  "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead.\n", errout.str());
+                                  "}");
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
                                   "    int counter = 0;\n"
                                   "    InterlockedDecrement(&counter);\n"
                                   "    if (counter == 0)\n"
                                   "        destroy();\n"
-                                  "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead.\n", errout.str());
+                                  "}");
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
                                   "    int counter = 0;\n"
                                   "    InterlockedDecrement(&counter);\n"
                                   "    if (0 == counter)\n"
                                   "        destroy();\n"
-                                  "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead.\n", errout.str());
+                                  "}");
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
                                   "    int counter = 0;\n"
@@ -7335,8 +11864,8 @@ class TestOther : public TestFixture {
                                   "    if (0 != counter)\n"
                                   "        return;\n"
                                   "    destroy()\n"
-                                  "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead.\n", errout.str());
+                                  "}");
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
                                   "    int counter = 0;\n"
@@ -7344,24 +11873,24 @@ class TestOther : public TestFixture {
                                   "    if (counter != 0)\n"
                                   "        return;\n"
                                   "    destroy()\n"
-                                  "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead.\n", errout.str());
+                                  "}");
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
                                   "    int counter = 0;\n"
                                   "    InterlockedDecrement(&counter);\n"
                                   "    if (counter <= 0)\n"
                                   "        destroy();\n"
-                                  "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead.\n", errout.str());
+                                  "}");
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
                                   "    int counter = 0;\n"
                                   "    InterlockedDecrement(&counter);\n"
                                   "    if (0 >= counter)\n"
                                   "        destroy();\n"
-                                  "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead.\n", errout.str());
+                                  "}");
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
                                   "    int counter = 0;\n"
@@ -7369,16 +11898,16 @@ class TestOther : public TestFixture {
                                   "    if (newCount)\n"
                                   "        return;\n"
                                   "    destroy();\n"
-                                  "}\n");
-        ASSERT_EQUALS("", errout.str());
+                                  "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
                                   "    int counter = 0;\n"
                                   "    int newCount = InterlockedDecrement(&counter);\n"
                                   "    if (!newCount)\n"
                                   "        destroy();\n"
-                                  "}\n");
-        ASSERT_EQUALS("", errout.str());
+                                  "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
                                   "    int counter = 0;\n"
@@ -7386,8 +11915,8 @@ class TestOther : public TestFixture {
                                   "    if (newCount > 0)\n"
                                   "        return;\n"
                                   "    destroy();\n"
-                                  "}\n");
-        ASSERT_EQUALS("", errout.str());
+                                  "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
                                   "    int counter = 0;\n"
@@ -7395,24 +11924,24 @@ class TestOther : public TestFixture {
                                   "    if (0 < newCount)\n"
                                   "        return;\n"
                                   "    destroy();\n"
-                                  "}\n");
-        ASSERT_EQUALS("", errout.str());
+                                  "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
                                   "    int counter = 0;\n"
                                   "    int newCount = InterlockedDecrement(&counter);\n"
                                   "    if (newCount == 0)\n"
                                   "        destroy();\n"
-                                  "}\n");
-        ASSERT_EQUALS("", errout.str());
+                                  "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
                                   "    int counter = 0;\n"
                                   "    int newCount = InterlockedDecrement(&counter);\n"
                                   "    if (0 == newCount)\n"
                                   "        destroy();\n"
-                                  "}\n");
-        ASSERT_EQUALS("", errout.str());
+                                  "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
                                   "    int counter = 0;\n"
@@ -7420,8 +11949,8 @@ class TestOther : public TestFixture {
                                   "    if (0 != newCount)\n"
                                   "        return;\n"
                                   "    destroy()\n"
-                                  "}\n");
-        ASSERT_EQUALS("", errout.str());
+                                  "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
                                   "    int counter = 0;\n"
@@ -7429,24 +11958,24 @@ class TestOther : public TestFixture {
                                   "    if (newCount != 0)\n"
                                   "        return;\n"
                                   "    destroy()\n"
-                                  "}\n");
-        ASSERT_EQUALS("", errout.str());
+                                  "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
                                   "    int counter = 0;\n"
                                   "    int newCount = InterlockedDecrement(&counter);\n"
                                   "    if (newCount <= 0)\n"
                                   "        destroy();\n"
-                                  "}\n");
-        ASSERT_EQUALS("", errout.str());
+                                  "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("void f() {\n"
                                   "    int counter = 0;\n"
                                   "    int newCount = InterlockedDecrement(&counter);\n"
                                   "    if (0 >= newCount)\n"
                                   "        destroy;\n"
-                                  "}\n");
-        ASSERT_EQUALS("", errout.str());
+                                  "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkInterlockedDecrement("int f() {\n"
                                   "    int counter = 0;\n"
@@ -7456,8 +11985,8 @@ class TestOther : public TestFixture {
                                   "    } else {\n"
                                   "        return counter;\n"
                                   "    }\n"
-                                  "}\n");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead.\n", errout.str());
+                                  "}");
+        ASSERT_EQUALS("[test.cpp:7:16]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("int f() {\n"
                                   "    int counter = 0;\n"
@@ -7467,8 +11996,8 @@ class TestOther : public TestFixture {
                                   "    } else {\n"
                                   "        return counter;\n"
                                   "    }\n"
-                                  "}\n");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead.\n", errout.str());
+                                  "}");
+        ASSERT_EQUALS("[test.cpp:7:16]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
 
         checkInterlockedDecrement("int f() {\n"
@@ -7478,8 +12007,8 @@ class TestOther : public TestFixture {
                                   "        return 0;\n"
                                   "    }\n"
                                   "    return counter;\n"
-                                  "}\n");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead.\n", errout.str());
+                                  "}");
+        ASSERT_EQUALS("[test.cpp:7:12]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("int f() {\n"
                                   "    int counter = 0;\n"
@@ -7488,8 +12017,8 @@ class TestOther : public TestFixture {
                                   "        return 0;\n"
                                   "    }\n"
                                   "    return counter;\n"
-                                  "}\n");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead.\n", errout.str());
+                                  "}");
+        ASSERT_EQUALS("[test.cpp:7:12]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("int f() {\n"
                                   "    int counter = 0;\n"
@@ -7498,9 +12027,9 @@ class TestOther : public TestFixture {
                                   "        return 0;\n"
                                   "    } else\n"
                                   "        return counter;\n"
-                                  "    \n"
-                                  "}\n");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead.\n", errout.str());
+                                  "   \n"
+                                  "}");
+        ASSERT_EQUALS("[test.cpp:7:16]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
 
         checkInterlockedDecrement("int f() {\n"
                                   "    int counter = 0;\n"
@@ -7509,23 +12038,23 @@ class TestOther : public TestFixture {
                                   "        return 0;\n"
                                   "    } else\n"
                                   "        return counter;\n"
-                                  "    \n"
-                                  "}\n");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead.\n", errout.str());
+                                  "   \n"
+                                  "}");
+        ASSERT_EQUALS("[test.cpp:7:16]: (error) Race condition: non-interlocked access after InterlockedDecrement(). Use InterlockedDecrement() return value instead. [raceAfterInterlockedDecrement]\n", errout_str());
     }
 
     void testUnusedLabel() {
         check("void f() {\n"
               "    label:\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Label 'label' is not used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (style) Label 'label' is not used. [unusedLabel]\n", errout_str());
 
         check("void f() {\n"
               "    label:\n"
               "    foo();\n"
               "    goto label;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    label:\n"
@@ -7535,28 +12064,28 @@ class TestOther : public TestFixture {
               "void g() {\n"
               "    label:\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (style) Label 'label' is not used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:5]: (style) Label 'label' is not used. [unusedLabel]\n", errout_str());
 
         check("void f() {\n"
               "    switch(a) {\n"
               "        default:\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    class X {\n"
               "        protected:\n"
               "    };\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    class X {\n"
               "        my_protected:\n"
               "    };\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int test(char art) {\n"
               "    switch (art) {\n"
@@ -7568,8 +12097,8 @@ class TestOther : public TestFixture {
               "        return 2;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Label 'caseZERO' is not used. Should this be a 'case' of the enclosing switch()?\n"
-                      "[test.cpp:5]: (warning) Label 'case1' is not used. Should this be a 'case' of the enclosing switch()?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) Label 'caseZERO' is not used. Should this be a 'case' of the enclosing switch()? [unusedLabelSwitch]\n"
+                      "[test.cpp:5:5]: (warning) Label 'case1' is not used. Should this be a 'case' of the enclosing switch()? [unusedLabelSwitch]\n", errout_str());
 
         check("int test(char art) {\n"
               "    switch (art) {\n"
@@ -7578,60 +12107,147 @@ class TestOther : public TestFixture {
               "    }\n"
               "    label:\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (style) Label 'label' is not used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:5]: (style) Label 'label' is not used. [unusedLabel]\n", errout_str());
+    }
+
+
+    void testUnusedLabelConfiguration() {
+        checkP("void f() {\n"
+               "#ifdef X\n"
+               "    goto END;\n"
+               "#endif\n"
+               "END:\n"
+               "}");
+        ASSERT_EQUALS("[test.cpp:5:1]: (style) Label 'END' is not used. There is #if in function body so the label might be used in code that is removed by the preprocessor. [unusedLabelConfiguration]\n",
+                      errout_str());
+    }
+
+    void testUnusedLabelSwitchConfiguration() {
+        checkP("void f(int i) {\n"
+               "    switch (i) {\n"
+               "    default:\n"
+               "        break;\n"
+               "#ifdef X\n"
+               "    case 1:\n"
+               "        goto END;\n"
+               "#endif\n"
+               "    case 2:\n"
+               "    END:\n"
+               "        return;\n"
+               "    }\n"
+               "}");
+        ASSERT_EQUALS("[test.cpp:10:5]: (warning) Label 'END' is not used. There is #if in function body so the label might be used in code that is removed by the preprocessor. Should this be a 'case' of the enclosing switch()? [unusedLabelSwitchConfiguration]\n",
+                      errout_str());
+    }
+
+    void testUnusedLabelPremiumMisra() { // #14467 - enable unusedLabel with --premium=misra-c-20xx flag
+        Settings s;
+        check("void f() {\n"
+              "    label:\n"
+              "}", dinit(CheckOptions, $.settings = &s));
+        ASSERT_EQUALS("", errout_str());
+        s.premiumArgs = "--premium=misra-c-2012"; // <- activates unusedLabel checking
+        check("void f() {\n"
+              "    label:\n"
+              "}", dinit(CheckOptions, $.settings = &s));
+        ASSERT_EQUALS("[test.cpp:2:5]: (style) Label 'label' is not used. [unusedLabel]\n", errout_str());
+    }
+
+    // TODO: only used in a single place
+#define checkCustomSettings(...) checkCustomSettings_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkCustomSettings_(const char* file, int line, const char (&code)[size], const Settings& settings, bool cpp = true) {
+        // Tokenize..
+        SimpleTokenizer tokenizer(settings, *this, cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+
+        // Check..
+        runChecks<CheckOther>(tokenizer, this);
     }
 
     void testEvaluationOrder() {
         check("void f() {\n"
               "  int x = dostuff();\n"
               "  return x + x++;\n"
-              "}", "test.c");
-        ASSERT_EQUALS("[test.c:3]: (error) Expression 'x+x++' depends on order of evaluation of side effects\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:3:12]: (error) Expression 'x+x++' depends on order of evaluation of side effects [unknownEvaluationOrder]\n", errout_str());
 
         // #7226
         check("long int f1(const char *exp) {\n"
               "  return strtol(++exp, (char **)&exp, 10);\n"
-              "}", "test.c");
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("long int f1(const char *exp) {\n"
               "  return dostuff(++exp, exp, 10);\n"
-              "}", "test.c");
-        ASSERT_EQUALS("[test.c:2]: (error) Expression '++exp,exp' depends on order of evaluation of side effects\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:2:23]: (error) Expression '++exp,exp' depends on order of evaluation of side effects [unknownEvaluationOrder]\n", errout_str());
 
         check("void f() {\n"
               "  int a;\n"
               "  while (a=x(), a==123) {}\n"
-              "}", "test.c");
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
         // # 8717
         check("void f(int argc, char *const argv[]) {\n"
               "    char **local_argv = safe_malloc(sizeof (*local_argv));\n"
               "    int local_argc = 0;\n"
               "    local_argv[local_argc++] = argv[0];\n"
-              "}\n", "test.c");
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  int x = 0;\n"
               "  return 0 + x++;\n"
-              "}\n", "test.c");
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x, int y) {\n"
               "  int a[10];\n"
               "  a[x+y] = a[y+x]++;;\n"
-              "}\n", "test.c");
-        ASSERT_EQUALS("[test.c:3]: (error) Expression 'a[x+y]=a[y+x]++' depends on order of evaluation of side effects\n", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:3:10]: (error) Expression 'a[x+y]=a[y+x]++' depends on order of evaluation of side effects [unknownEvaluationOrder]\n", errout_str());
+
+        check("void f(int i) {\n"
+              "  int n = ++i + i;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:15]: (error) Expression '++i+i' depends on order of evaluation of side effects [unknownEvaluationOrder]\n", errout_str());
+
+        check("long int f1(const char *exp) {\n"
+              "  return dostuff(++exp, ++exp, 10);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:23]: (portability) Expression '++exp,++exp' depends on order of evaluation of side effects. Behavior is Unspecified according to c++17 [unknownEvaluationOrder]\n"
+                      "[test.cpp:2:23]: (portability) Expression '++exp,++exp' depends on order of evaluation of side effects. Behavior is Unspecified according to c++17 [unknownEvaluationOrder]\n", errout_str());
+
+        check("void f(int i) {\n"
+              "  int n = (~(-(++i)) + i);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:22]: (error) Expression '~(-(++i))+i' depends on order of evaluation of side effects [unknownEvaluationOrder]\n", errout_str());
+
+        const Settings settings11 = settingsBuilder(settings0).cpp(Standards::CPP11).certainty(Certainty::inconclusive).build();
+
+        checkCustomSettings("void f(int i) {\n"
+                            "  i = i++ + 2;\n"
+                            "}", settings11);
+        ASSERT_EQUALS("[test.cpp:2:11]: (error) Expression 'i+++2' depends on order of evaluation of side effects [unknownEvaluationOrder]\n", errout_str());
+
+        // #14431
+        checkCustomSettings("int f(void) {\n"
+                            "  struct baz baz = {.bar = {.foo = {.foo = 1}}};\n"
+                            "}\n", settings0, false);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testEvaluationOrderSelfAssignment() {
         // self assignment
         check("void f() {\n"
               "  int x = x = y + 1;\n"
-              "}", "test.c");
-        ASSERT_EQUALS("[test.c:2]: (warning) Redundant assignment of 'x' to itself.\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS(
+            "[test.c:2:9]: (style) Redundant assignment of 'x' to itself. [selfAssignment]\n"
+            "[test.c:2:9]: (style) Redundant assignment of 'x' to itself. [selfAssignment]\n",   // duplicate
+            errout_str());
     }
 
     void testEvaluationOrderMacro() {
@@ -7639,71 +12255,71 @@ class TestOther : public TestFixture {
         checkP("#define X x\n"
                "void f(int x) {\n"
                "  return x + X++;\n"
-               "}", "test.c");
-        ASSERT_EQUALS("[test.c:3]: (error) Expression 'x+x++' depends on order of evaluation of side effects\n", errout.str());
+               "}", dinit(CheckPOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:3:12]: (error) Expression 'x+x++' depends on order of evaluation of side effects [unknownEvaluationOrder]\n", errout_str());
     }
 
     void testEvaluationOrderSequencePointsFunctionCall() {
         // FP
         check("void f(int id) {\n"
               "  id = dostuff(id += 42);\n"
-              "}", "test.c");
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
         // FN
         check("void f(int id) {\n"
               "  id = id + dostuff(id += 42);\n"
-              "}", "test.c");
-        TODO_ASSERT_EQUALS("error", "", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        TODO_ASSERT_EQUALS("error", "", errout_str());
     }
 
     void testEvaluationOrderSequencePointsComma() {
         check("int f(void) {\n"
               "  int t;\n"
               "  return (unsigned char)(t=1,t^c);\n"
-              "}", "test.c");
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(void) {\n"
               "  int t;\n"
               "  dostuff(t=1,t^c);\n"
-              "}", "test.c");
-        ASSERT_EQUALS("[test.c:3]: (error) Expression 't=1,t^c' depends on order of evaluation of side effects\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:3:14]: (error) Expression 't=1,t^c' depends on order of evaluation of side effects [unknownEvaluationOrder]\n", errout_str());
 
         check("void f(void) {\n"
               "  int t;\n"
               "  dostuff((t=1,t),2);\n"
-              "}", "test.c");
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
         // #8230
         check("void hprf(const char* fp) {\n"
               "    do\n"
               "        ;\n"
               "    while (++fp, (*fp) <= 0177);\n"
-              "}\n", "test.c");
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("void hprf(const char* fp) {\n"
               "    do\n"
               "        ;\n"
               "    while (i++, ++fp, (*fp) <= 0177);\n"
-              "}\n", "test.c");
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(const char* fp) {\n"
               "    do\n"
               "        ;\n"
               "    while (f(++fp, (*fp) <= 7));\n"
-              "}\n", "test.c");
-        ASSERT_EQUALS("[test.c:4]: (error) Expression '++fp,(*fp)<=7' depends on order of evaluation of side effects\n", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:4:18]: (error) Expression '++fp,(*fp)<=7' depends on order of evaluation of side effects [unknownEvaluationOrder]\n", errout_str());
     }
 
     void testEvaluationOrderSizeof() {
         check("void f(char *buf) {\n"
               "  dostuff(buf++, sizeof(*buf));"
-              "}", "test.c");
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testUnsignedLessThanZero() {
@@ -7721,10 +12337,10 @@ class TestOther : public TestFixture {
               "  if (0 > d.n) {\n"
               "    return;\n"
               "  }\n"
-              "}", "test.c");
-        ASSERT_EQUALS("[test.c:8]: (style) Checking if unsigned expression 'd.n' is less than zero.\n"
-                      "[test.c:12]: (style) Checking if unsigned expression 'd.n' is less than zero.\n",
-                      errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:8:11]: (style) Checking if unsigned expression 'd.n' is less than zero. [unsignedLessThanZero]\n"
+                      "[test.c:12:9]: (style) Checking if unsigned expression 'd.n' is less than zero. [unsignedLessThanZero]\n",
+                      errout_str());
     }
 
     void doubleMove1() {
@@ -7734,7 +12350,7 @@ class TestOther : public TestFixture {
               "    g(std::move(a));\n"
               "    g(std::move(a));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Access of moved variable 'a'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:17]: (warning) Access of moved variable 'a'. [accessMoved]\n", errout_str());
     }
 
     void doubleMoveMemberInitialization1() {
@@ -7748,7 +12364,7 @@ class TestOther : public TestFixture {
               "    B b1;\n"
               "    B b2;\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:6]: (warning) Access of moved variable 'b'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:24]: (warning) Access of moved variable 'b'. [accessMoved]\n", errout_str());
     }
 
     void doubleMoveMemberInitialization2() {
@@ -7761,7 +12377,28 @@ class TestOther : public TestFixture {
               "    B b1;\n"
               "    B b2;\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Access of moved variable 'b'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:19]: (warning) Access of moved variable 'b'. [accessMoved]\n", errout_str());
+    }
+
+    void doubleMoveMemberInitialization3() { // #9974
+        check("struct A { int i; };\n"
+              "struct B { A a1; A a2; };\n"
+              "B f() {\n"
+              "    A a1 = { 1 };\n"
+              "    A a2 = { 2 };\n"
+              "    return { .a1 = std::move(a1), .a2 = std::move(a2) };\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void doubleMoveMemberInitialization4() { // #11440
+        check("struct S { void f(int); };\n"
+              "struct T {\n"
+              "    T(int c, S&& d) : c{ c }, d{ std::move(d) } { d.f(c); }\n"
+              "    int c;\n"
+              "    S d;\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:3:51]: (warning, inconclusive) Access of moved variable 'd'. [accessMoved]\n", errout_str());
     }
 
     void moveAndAssign1() {
@@ -7771,7 +12408,7 @@ class TestOther : public TestFixture {
               "    a = g(std::move(a));\n"
               "    a = g(std::move(a));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void moveAndAssign2() {
@@ -7781,7 +12418,7 @@ class TestOther : public TestFixture {
               "    B b = g(std::move(a));\n"
               "    C c = g(std::move(a));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Access of moved variable 'a'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:23]: (warning) Access of moved variable 'a'. [accessMoved]\n", errout_str());
     }
 
     void moveAssignMoveAssign() {
@@ -7797,8 +12434,8 @@ class TestOther : public TestFixture {
               "    a = b;\n"
               "    h(a);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Access of moved variable 'a'.\n"
-                      "[test.cpp:8]: (warning) Access of moved variable 'a'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: (warning) Access of moved variable 'a'. [accessMoved]\n"
+                      "[test.cpp:8:7]: (warning) Access of moved variable 'a'. [accessMoved]\n", errout_str());
     }
 
     void moveAndReset1() {
@@ -7808,7 +12445,7 @@ class TestOther : public TestFixture {
               "    a.reset(g(std::move(a)));\n"
               "    a.reset(g(std::move(a)));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void moveAndReset2() {
@@ -7820,7 +12457,7 @@ class TestOther : public TestFixture {
               "    b.reset(g(std::move(a)));\n"
               "    c.reset(g(std::move(a)));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (warning) Access of moved variable 'a'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:25]: (warning) Access of moved variable 'a'. [accessMoved]\n", errout_str());
     }
 
     void moveResetMoveReset() {
@@ -7836,8 +12473,8 @@ class TestOther : public TestFixture {
               "    a.reset(b);\n"
               "    h(a);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Access of moved variable 'a'.\n"
-                      "[test.cpp:8]: (warning) Access of moved variable 'a'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: (warning) Access of moved variable 'a'. [accessMoved]\n"
+                      "[test.cpp:8:7]: (warning) Access of moved variable 'a'. [accessMoved]\n", errout_str());
     }
 
     void moveAndFunctionParameter() {
@@ -7848,8 +12485,8 @@ class TestOther : public TestFixture {
               "    g(a);\n"
               "    A c = a;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Access of moved variable 'a'.\n"
-                      "[test.cpp:6]: (warning) Access of moved variable 'a'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:7]: (warning) Access of moved variable 'a'. [accessMoved]\n"
+                      "[test.cpp:6:11]: (warning) Access of moved variable 'a'. [accessMoved]\n", errout_str());
     }
 
     void moveAndFunctionParameterReference() {
@@ -7860,7 +12497,7 @@ class TestOther : public TestFixture {
               "    g(a);\n"
               "    A c = a;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void moveAndFunctionParameterConstReference() {
@@ -7871,8 +12508,8 @@ class TestOther : public TestFixture {
               "    g(a);\n"
               "    A c = a;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Access of moved variable 'a'.\n"
-                      "[test.cpp:6]: (warning) Access of moved variable 'a'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:7]: (warning) Access of moved variable 'a'. [accessMoved]\n"
+                      "[test.cpp:6:11]: (warning) Access of moved variable 'a'. [accessMoved]\n", errout_str());
     }
 
     void moveAndFunctionParameterUnknown() {
@@ -7882,8 +12519,8 @@ class TestOther : public TestFixture {
               "    g(a);\n"
               "    A c = a;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning, inconclusive) Access of moved variable 'a'.\n"
-                      "[test.cpp:5]: (warning, inconclusive) Access of moved variable 'a'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: (warning, inconclusive) Access of moved variable 'a'. [accessMoved]\n"
+                      "[test.cpp:5:11]: (warning, inconclusive) Access of moved variable 'a'. [accessMoved]\n", errout_str());
     }
 
     void moveAndReturn() {
@@ -7895,7 +12532,7 @@ class TestOther : public TestFixture {
               "        return g(std::move(b));\n"
               "    return h(std::move(a),std::move(b));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (warning) Access of moved variable 'a'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:24]: (warning) Access of moved variable 'a'. [accessMoved]\n", errout_str());
     }
 
     void moveAndClear() {
@@ -7905,7 +12542,7 @@ class TestOther : public TestFixture {
               "    v.clear();\n"
               "    if (v.empty()) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void movedPointer() {
@@ -7915,8 +12552,8 @@ class TestOther : public TestFixture {
               "    x = p->x;\n"
               "    y = p->y;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Access of moved variable 'p'.\n"
-                      "[test.cpp:5]: (warning) Access of moved variable 'p'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9]: (warning) Access of moved variable 'p'. [accessMoved]\n"
+                      "[test.cpp:5:9]: (warning) Access of moved variable 'p'. [accessMoved]\n", errout_str());
     }
 
     void moveAndAddressOf() {
@@ -7925,7 +12562,7 @@ class TestOther : public TestFixture {
               "    std::string s2 = std::move(s1);\n"
               "    p = &s1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void partiallyMoved() {
@@ -7934,7 +12571,7 @@ class TestOther : public TestFixture {
               "    gx(std::move(a).x());\n"
               "    gy(std::move(a).y());\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void moveAndLambda() {
@@ -7943,7 +12580,51 @@ class TestOther : public TestFixture {
               "    auto h = [a=std::move(a)](){return g(std::move(a));};"
               "    b = a;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void moveInLoop()
+    {
+        check("void g(std::string&& s);\n"
+              "void f() {\n"
+              "    std::string p;\n"
+              "    while(true)\n"
+              "        g(std::move(p));\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:21]: (warning) Access of moved variable 'p'. [accessMoved]\n", errout_str());
+
+        check("std::list<int> g(std::list<int>&&);\n"
+              "void f(std::list<int>l) {\n"
+              "    for(int i = 0; i < 10; ++i) {\n"
+              "        for (auto &j : g(std::move(l))) { (void)j; }\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:36]: (warning) Access of moved variable 'l'. [accessMoved]\n", errout_str());
+    }
+
+    void moveCallback()
+    {
+        check("bool f(std::function<void()>&& callback);\n"
+              "void func(std::function<void()> callback) {\n"
+              "    if(!f(std::move(callback)))\n"
+              "        callback();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:9]: (warning) Access of moved variable 'callback'. [accessMoved]\n", errout_str());
+    }
+
+    void moveClassVariable()
+    {
+        check("struct B {\n"
+              "    virtual void f();\n"
+              "};\n"
+              "struct D : B {\n"
+              "    void f() override {\n"
+              "        auto p = std::unique_ptr<D>(new D(std::move(m)));\n"
+              "    }\n"
+              "    D(std::unique_ptr<int> c) : m(std::move(c)) {}\n"
+              "    std::unique_ptr<int> m;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void forwardAndUsed() {
@@ -7952,16 +12633,80 @@ class TestOther : public TestFixture {
               "    g(std::forward<T>(t));\n"
               "    T s = t;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Access of forwarded variable 't'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:11]: (warning) Access of forwarded variable 't'. [accessForwarded]\n", errout_str());
+    }
+
+    void moveAndReference() { // #9791
+        check("void g(std::string&&);\n"
+              "void h(const std::string&);\n"
+              "void f() {\n"
+              "    std::string s;\n"
+              "    const std::string& r = s;\n"
+              "    g(std::move(s));\n"
+              "    h(r);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:7:7]: (warning) Access of moved variable 'r'. [accessMoved]\n", errout_str());
+    }
+
+    void moveForRange()
+    {
+        check("struct C {\n"
+              "    void f() {\n"
+              "        for (auto r : mCategory.find(std::move(mWhere))) {}\n"
+              "    }\n"
+              "    cif::category mCategory;\n"
+              "    cif::condition mWhere;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void moveTernary()
+    {
+        check("void gA(std::string);\n" // #12174
+              "void gB(std::string);\n"
+              "void f(bool b) {\n"
+              "    std::string s = \"abc\";\n"
+              "    b ? gA(std::move(s)) : gB(std::move(s));\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int gA(std::string);\n"
+              "int gB(std::string);\n"
+              "void h(int);\n"
+              "void f(bool b) {\n"
+              "    std::string s = \"abc\";\n"
+              "    h(b ? gA(std::move(s)) : gB(std::move(s)));\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int gA(int, std::string);\n"
+              "int gB(int, std::string);\n"
+              "int h(int);\n"
+              "void f(bool b) {\n"
+              "    std::string s = \"abc\";\n"
+              "    h(b ? h(gA(5, std::move(s))) : h(gB(7, std::move(s))));\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void movePointerAlias()
+    {
+        check("void f() {\n"
+              "    std::string s;\n"
+              "    std::string s1 = std::move(s);\n"
+              "    const std::string* s_p = &s;\n"
+              "    s_p->size();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:8]: (warning) Access of moved variable '.'. [accessMoved]\n", errout_str());
     }
 
     void funcArgNamesDifferent() {
-        check("void func1(int a, int b, int c); \n"
+        check("void func1(int a, int b, int c);\n"
               "void func1(int a, int b, int c) { }\n"
               "void func2(int a, int b, int c);\n"
               "void func2(int A, int B, int C) { }\n"
               "class Fred {\n"
-              "    void func1(int a, int b, int c); \n"
+              "    void func1(int a, int b, int c);\n"
               "    void func2(int a, int b, int c);\n"
               "    void func3(int a = 0, int b = 0, int c = 0);\n"
               "    void func4(int a = 0, int b = 0, int c = 0);\n"
@@ -7969,16 +12714,16 @@ class TestOther : public TestFixture {
               "void Fred::func1(int a, int b, int c) { }\n"
               "void Fred::func2(int A, int B, int C) { }\n"
               "void Fred::func3(int a, int b, int c) { }\n"
-              "void Fred::func4(int A, int B, int C) { }\n");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (style, inconclusive) Function 'func2' argument 1 names different: declaration 'a' definition 'A'.\n"
-                      "[test.cpp:3] -> [test.cpp:4]: (style, inconclusive) Function 'func2' argument 2 names different: declaration 'b' definition 'B'.\n"
-                      "[test.cpp:3] -> [test.cpp:4]: (style, inconclusive) Function 'func2' argument 3 names different: declaration 'c' definition 'C'.\n"
-                      "[test.cpp:7] -> [test.cpp:12]: (style, inconclusive) Function 'func2' argument 1 names different: declaration 'a' definition 'A'.\n"
-                      "[test.cpp:7] -> [test.cpp:12]: (style, inconclusive) Function 'func2' argument 2 names different: declaration 'b' definition 'B'.\n"
-                      "[test.cpp:7] -> [test.cpp:12]: (style, inconclusive) Function 'func2' argument 3 names different: declaration 'c' definition 'C'.\n"
-                      "[test.cpp:9] -> [test.cpp:14]: (style, inconclusive) Function 'func4' argument 1 names different: declaration 'a' definition 'A'.\n"
-                      "[test.cpp:9] -> [test.cpp:14]: (style, inconclusive) Function 'func4' argument 2 names different: declaration 'b' definition 'B'.\n"
-                      "[test.cpp:9] -> [test.cpp:14]: (style, inconclusive) Function 'func4' argument 3 names different: declaration 'c' definition 'C'.\n", errout.str());
+              "void Fred::func4(int A, int B, int C) { }");
+        ASSERT_EQUALS("[test.cpp:3:16] -> [test.cpp:4:16]: (style, inconclusive) Function 'func2' argument 1 names different: declaration 'a' definition 'A'. [funcArgNamesDifferent]\n"
+                      "[test.cpp:3:23] -> [test.cpp:4:23]: (style, inconclusive) Function 'func2' argument 2 names different: declaration 'b' definition 'B'. [funcArgNamesDifferent]\n"
+                      "[test.cpp:3:30] -> [test.cpp:4:30]: (style, inconclusive) Function 'func2' argument 3 names different: declaration 'c' definition 'C'. [funcArgNamesDifferent]\n"
+                      "[test.cpp:7:20] -> [test.cpp:12:22]: (style, inconclusive) Function 'func2' argument 1 names different: declaration 'a' definition 'A'. [funcArgNamesDifferent]\n"
+                      "[test.cpp:7:27] -> [test.cpp:12:29]: (style, inconclusive) Function 'func2' argument 2 names different: declaration 'b' definition 'B'. [funcArgNamesDifferent]\n"
+                      "[test.cpp:7:34] -> [test.cpp:12:36]: (style, inconclusive) Function 'func2' argument 3 names different: declaration 'c' definition 'C'. [funcArgNamesDifferent]\n"
+                      "[test.cpp:9:20] -> [test.cpp:14:22]: (style, inconclusive) Function 'func4' argument 1 names different: declaration 'a' definition 'A'. [funcArgNamesDifferent]\n"
+                      "[test.cpp:9:31] -> [test.cpp:14:29]: (style, inconclusive) Function 'func4' argument 2 names different: declaration 'b' definition 'B'. [funcArgNamesDifferent]\n"
+                      "[test.cpp:9:42] -> [test.cpp:14:36]: (style, inconclusive) Function 'func4' argument 3 names different: declaration 'c' definition 'C'. [funcArgNamesDifferent]\n", errout_str());
     }
 
     void funcArgOrderDifferent() {
@@ -7998,12 +12743,12 @@ class TestOther : public TestFixture {
               "void Fred::func2(int c, int b, int a) { }\n"
               "void Fred::func3(int c, int b, int a) { }\n"
               "void Fred::func4(int c, int b, int a) { }\n",
-              nullptr, false, false);
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4]: (warning) Function 'func2' argument order different: declaration 'a, b, c' definition 'c, b, a'\n"
-                      "[test.cpp:5] -> [test.cpp:6]: (warning) Function 'func3' argument order different: declaration ', b, c' definition 'c, b, a'\n"
-                      "[test.cpp:9] -> [test.cpp:14]: (warning) Function 'func2' argument order different: declaration 'a, b, c' definition 'c, b, a'\n"
-                      "[test.cpp:10] -> [test.cpp:15]: (warning) Function 'func3' argument order different: declaration 'a, b, c' definition 'c, b, a'\n"
-                      "[test.cpp:11] -> [test.cpp:16]: (warning) Function 'func4' argument order different: declaration ', b, c' definition 'c, b, a'\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = false));
+        ASSERT_EQUALS("[test.cpp:3:16] -> [test.cpp:4:16]: (warning) Function 'func2' argument order different: declaration 'a, b, c' definition 'c, b, a' [funcArgOrderDifferent]\n"
+                      "[test.cpp:5:12] -> [test.cpp:6:16]: (warning) Function 'func3' argument order different: declaration ', b, c' definition 'c, b, a' [funcArgOrderDifferent]\n"
+                      "[test.cpp:9:20] -> [test.cpp:14:22]: (warning) Function 'func2' argument order different: declaration 'a, b, c' definition 'c, b, a' [funcArgOrderDifferent]\n"
+                      "[test.cpp:10:20] -> [test.cpp:15:22]: (warning) Function 'func3' argument order different: declaration 'a, b, c' definition 'c, b, a' [funcArgOrderDifferent]\n"
+                      "[test.cpp:11:16] -> [test.cpp:16:22]: (warning) Function 'func4' argument order different: declaration ', b, c' definition 'c, b, a' [funcArgOrderDifferent]\n", errout_str());
     }
 
     // #7846 - Syntax error when using C++11 braced-initializer in default argument
@@ -8013,124 +12758,211 @@ class TestOther : public TestFixture {
                               "\n   for (int i = 0; i < 10; i++) {}\n"
                               "\n }"
                               "\n  "));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void shadowVariables() {
         check("int x;\n"
-              "void f() { int x; }\n");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:2]: (style) Local variable \'x\' shadows outer variable\n", errout.str());
+              "void f() { int x; }");
+        ASSERT_EQUALS("[test.cpp:1:5] -> [test.cpp:2:16]: (style) Local variable 'x' shadows outer variable [shadowVariable]\n", errout_str());
 
         check("int x();\n"
-              "void f() { int x; }\n");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:2]: (style) Local variable \'x\' shadows outer function\n", errout.str());
+              "void f() { int x; }");
+        ASSERT_EQUALS("[test.cpp:1:5] -> [test.cpp:2:16]: (style) Local variable 'x' shadows outer function [shadowFunction]\n", errout_str());
 
         check("struct C {\n"
               "    C(int x) : x(x) {}\n" // <- we do not want a FP here
               "    int x;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  if (cond) {int x;}\n" // <- not a shadow variable
               "  int x;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("int size() {\n"
               "  int size;\n" // <- not a shadow variable
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n" // #8954 - lambda
               "  int x;\n"
               "  auto f = [](){ int x; }"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x) { int x; }");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:1]: (style) Local variable 'x' shadows outer argument\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:12] -> [test.cpp:1:21]: (style) Local variable 'x' shadows outer argument [shadowArgument]\n", errout_str());
+
+        check("class C { C(); void foo() { static int C = 0; } }"); // #9195 - shadow constructor
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct C {\n" // #10091 - shadow destructor
+              "    ~C();\n"
+              "    void f() {\n"
+              "        bool C{};\n"
+              "    }\n"
+              "};\n"
+              "C::~C() = default;");
+        ASSERT_EQUALS("", errout_str());
+
+        // 10752 - no
+        check("struct S {\n"
+              "    int i;\n"
+              "\n"
+              "    static int foo() {\n"
+              "        int i = 0;\n"
+              "        return i;\n"
+              "    }\n"
+              "};");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n"
+              "    int i{};\n"
+              "    void f() { int i; }\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:20]: (style) Local variable 'i' shadows outer variable [shadowVariable]\n", errout_str());
+
+        check("struct S {\n"
+              "    int i{};\n"
+              "    std::vector<int> v;\n"
+              "    void f() const { for (const int& i : v) {} }\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:4:38]: (style) Local variable 'i' shadows outer variable [shadowVariable]\n", errout_str());
+
+        check("struct S {\n" // #10405
+              "    F* f{};\n"
+              "    std::list<F> fl;\n"
+              "    void S::f() const;\n"
+              "};\n"
+              "void S::f() const {\n"
+              "    for (const F& f : fl) {}\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:2:8] -> [test.cpp:7:19]: (style) Local variable 'f' shadows outer variable [shadowVariable]\n", errout_str());
+
+        check("extern int a;\n"
+              "int a;\n"
+              "static int f(void) {\n"
+              "    int a;\n"
+              "    return 0;\n"
+              "}\n", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:1:12] -> [test.c:4:9]: (style) Local variable 'a' shadows outer variable [shadowVariable]\n", errout_str());
+
+        check("int f() {\n" // #12591
+              "    int g = 0;\n"
+              "    return g;\n"
+              "}\n"
+              "int g() { return 1; }\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #13888
+              "    int i;\n"
+              "    friend int f() { int i = 5; return i; }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void constArgument() {
+    void knownArgument() {
         check("void g(int);\n"
               "void f(int x) {\n"
               "   g((x & 0x01) >> 7);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Argument '(x&1)>>7' to function g is always 0\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:17]: (style) Argument '(x&0x01)>>7' to function g is always 0. It does not matter what value 'x' has. [knownArgument]\n", errout_str());
 
         check("void g(int);\n"
               "void f(int x) {\n"
               "   g((int)((x & 0x01) >> 7));\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Argument '(int)((x&1)>>7)' to function g is always 0\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:6]: (style) Argument '(int)((x&0x01)>>7)' to function g is always 0. It does not matter what value 'x' has. [knownArgument]\n", errout_str());
+
+        check("void g(int, int);\n"
+              "void f(int x) {\n"
+              "   g(x, (x & 0x01) >> 7);\n"
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:3:20]: (style) Argument '(x&0x01)>>7' to function g is always 0. It does not matter what value 'x' has. [knownArgument]\n",
+            errout_str());
 
         check("void g(int);\n"
               "void f(int x) {\n"
               "    g(0);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void g(int);\n"
               "void h() { return 1; }\n"
               "void f(int x) {\n"
               "    g(h());\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void g(int);\n"
               "void f(int x) {\n"
               "    g(std::strlen(\"a\"));\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void g(int);\n"
               "void f(int x) {\n"
               "    g((int)0);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void g(Foo *);\n"
               "void f() {\n"
               "    g(reinterpret_cast<Foo*>(0));\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void g(int);\n"
               "void f(int x) {\n"
               "    x = 0;\n"
               "    g(x);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void g(int);\n"
               "void f() {\n"
               "    const int x = 0;\n"
               "    g(x + 1);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void g(int);\n"
               "void f() {\n"
               "    char i = 1;\n"
               "    g(static_cast<int>(i));\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("char *yytext;\n"
+              "void re_init_scanner() {\n"
+              "  int size = 256;\n"
+              "  yytext = xmalloc(size * sizeof *yytext);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo(const char *c) {\n"
+              "    if (*c == '+' && (operand || !isalnum(*c))) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // #8986
         check("void f(int);\n"
               "void g() {\n"
               "    const int x[] = { 10, 10 };\n"
               "    f(x[0]);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int);\n"
               "void g() {\n"
               "    int x[] = { 10, 10 };\n"
               "    f(x[0]);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Variable 'x' can be declared as const array [constVariable]\n", errout_str());
 
         check("struct A { int x; };"
               "void g(int);\n"
@@ -8138,23 +12970,143 @@ class TestOther : public TestFixture {
               "    A y;\n"
               "    y.x = 1;\n"
               "    g(y.x);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // allow known argument value in assert call
+        check("void g(int);\n"
+              "void f(int x) {\n"
+              "   ASSERT((int)((x & 0x01) >> 7));\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9905 - expression that does not use integer calculation at all
+        check("void foo() {\n"
+              "    const std::string heading = \"Interval\";\n"
+              "    std::cout << std::setw(heading.length());\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #9909 - struct member with known value
+        check("struct LongStack {\n"
+              "    int maxsize;\n"
+              "};\n"
+              "\n"
+              "void growLongStack(LongStack* self) {\n"
+              "    self->maxsize = 32;\n"
+              "    dostuff(self->maxsize * sizeof(intptr_t));\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11894
+        check("struct S {\n"
+              "    int *p, n;\n"
+              "};\n"
+              "S* g() {\n"
+              "    S* s = static_cast<S*>(calloc(1, sizeof(S)));\n"
+              "    s->n = 100;\n"
+              "    s->p = static_cast<int*>(malloc(s->n * sizeof(int)));\n"
+              "    return s;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11679
+        check("bool g(int);\n"
+              "void h(int);\n"
+              "int k(int a) { h(a); return 0; }\n"
+              "void f(int i) {\n"
+              "    if (g(k(i))) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11889
+        check("struct S {\n"
+              "    int a[5];\n"
+              "    void f(int i);\n"
+              "}\n"
+              "void g(int);\n"
+              "void S::f(int i) {\n"
+              "    if (a[i] == 1) {\n"
+              "        a[i] = 0;\n"
+              "        g(a[i]);\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11927
+        check("void f(func_t func, int i) {\n"
+              "    (func)(i, 0);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { void operator()(int, int); };\n"
+              "void f(int i) {\n"
+              "    S()(i, 1);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int& r) {\n"
+              "    g(static_cast<char>(r = 42));\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { int i; };\n"
+              "void f(int i) {\n"
+              "    const int a[] = { i - 1 * i, 0 };\n"
+              "    auto s = S{ i - 1 * i };\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:25]: (style) Argument 'i-1*i' to init list { is always 0. It does not matter what value 'i' has. [knownArgument]\n"
+                      "[test.cpp:4:19]: (style) Argument 'i-1*i' to constructor S is always 0. It does not matter what value 'i' has. [knownArgument]\n",
+                      errout_str());
+
+        checkP("#define MACRO(X) std::abs(X ? 0 : a)\n"
+               "int f(int a) {\n"
+               "    return MACRO(true);\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void knownArgumentHiddenVariableExpression() {
+        // #9914 - variable expression is explicitly hidden
+        check("void f(int x) {\n"
+              "    dostuff(x && false);\n"
+              "    dostuff(false && x);\n"
+              "    dostuff(x || true);\n"
+              "    dostuff(true || x);\n"
+              "    dostuff(x * 0);\n"
+              "    dostuff(0 * x);\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:19]: (style) Argument 'false&&x' to function dostuff is always 0. Constant literal calculation disable/hide variable expression 'x'. [knownArgumentHiddenVariableExpression]\n"
+                      "[test.cpp:5:18]: (style) Argument 'true||x' to function dostuff is always 1. Constant literal calculation disable/hide variable expression 'x'. [knownArgumentHiddenVariableExpression]\n"
+                      "[test.cpp:6:15]: (style) Argument 'x*0' to function dostuff is always 0. Constant literal calculation disable/hide variable expression 'x'. [knownArgumentHiddenVariableExpression]\n"
+                      "[test.cpp:7:15]: (style) Argument '0*x' to function dostuff is always 0. Constant literal calculation disable/hide variable expression 'x'. [knownArgumentHiddenVariableExpression]\n", errout_str());
+    }
+
+    void knownArgumentTernaryOperator() { // #10374
+        check("void f(bool a, bool b) {\n"
+              "    const T* P = nullptr; \n"
+              "    long N = 0; \n"
+              "    const bool c = foo(); \n"
+              "    bar(P, N); \n"
+              "    if (c ? a : b)\n"
+              "      baz(P, N); \n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void checkComparePointers() {
         check("int f() {\n"
-              "    int foo[1] = {0};\n"
-              "    int bar[1] = {0};\n"
+              "    const int foo[1] = {0};\n"
+              "    const int bar[1] = {0};\n"
               "    int diff = 0;\n"
               "    if(foo > bar) {\n"
               "       diff = 1;\n"
               "    }\n"
               "    return diff;\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:2] -> [test.cpp:5] -> [test.cpp:3] -> [test.cpp:5] -> [test.cpp:5]: (error) Comparing pointers that point to different objects\n",
-            errout.str());
+            "[test.cpp:2:15] -> [test.cpp:5:8] -> [test.cpp:3:15] -> [test.cpp:5:14] -> [test.cpp:5:12]: (error) Comparing pointers that point to different objects [comparePointers]\n",
+            errout_str());
 
         check("bool f() {\n"
               "    int x = 0;\n"
@@ -8162,19 +13114,21 @@ class TestOther : public TestFixture {
               "    int* xp = &x;\n"
               "    int* yp = &y;\n"
               "    return xp > yp;\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:2] -> [test.cpp:4] -> [test.cpp:3] -> [test.cpp:5] -> [test.cpp:6]: (error) Comparing pointers that point to different objects\n",
-            errout.str());
+            "[test.cpp:2:9] -> [test.cpp:4:15] -> [test.cpp:3:9] -> [test.cpp:5:15] -> [test.cpp:6:15]: (error) Comparing pointers that point to different objects [comparePointers]\n"
+            "[test.cpp:4:10]: (style) Variable 'xp' can be declared as pointer to const [constVariablePointer]\n"
+            "[test.cpp:5:10]: (style) Variable 'yp' can be declared as pointer to const [constVariablePointer]\n",
+            errout_str());
 
         check("bool f() {\n"
               "    int x = 0;\n"
               "    int y = 1;\n"
               "    return &x > &y;\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:2] -> [test.cpp:4] -> [test.cpp:3] -> [test.cpp:4] -> [test.cpp:4]: (error) Comparing pointers that point to different objects\n",
-            errout.str());
+            "[test.cpp:2:9] -> [test.cpp:4:12] -> [test.cpp:3:9] -> [test.cpp:4:17] -> [test.cpp:4:15]: (error) Comparing pointers that point to different objects [comparePointers]\n",
+            errout_str());
 
         check("struct A {int data;};\n"
               "bool f() {\n"
@@ -8183,10 +13137,12 @@ class TestOther : public TestFixture {
               "    int* xp = &x.data;\n"
               "    int* yp = &y.data;\n"
               "    return xp > yp;\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:1] -> [test.cpp:5] -> [test.cpp:1] -> [test.cpp:6] -> [test.cpp:7]: (error) Comparing pointers that point to different objects\n",
-            errout.str());
+            "[test.cpp:3:7] -> [test.cpp:5:15] -> [test.cpp:4:7] -> [test.cpp:6:15] -> [test.cpp:7:15]: (error) Comparing pointers that point to different objects [comparePointers]\n"
+            "[test.cpp:5:10]: (style) Variable 'xp' can be declared as pointer to const [constVariablePointer]\n"
+            "[test.cpp:6:10]: (style) Variable 'yp' can be declared as pointer to const [constVariablePointer]\n",
+            errout_str());
 
         check("struct A {int data;};\n"
               "bool f(A ix, A iy) {\n"
@@ -8195,44 +13151,48 @@ class TestOther : public TestFixture {
               "    int* xp = &x->data;\n"
               "    int* yp = &y->data;\n"
               "    return xp > yp;\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:2] -> [test.cpp:3] -> [test.cpp:5] -> [test.cpp:2] -> [test.cpp:4] -> [test.cpp:6] -> [test.cpp:7]: (error) Comparing pointers that point to different objects\n",
-            errout.str());
+            "[test.cpp:2:10] -> [test.cpp:3:12] -> [test.cpp:5:15] -> [test.cpp:2:16] -> [test.cpp:4:12] -> [test.cpp:6:15] -> [test.cpp:7:15]: (error) Comparing pointers that point to different objects [comparePointers]\n"
+            "[test.cpp:5:10]: (style) Variable 'xp' can be declared as pointer to const [constVariablePointer]\n"
+            "[test.cpp:6:10]: (style) Variable 'yp' can be declared as pointer to const [constVariablePointer]\n",
+            errout_str());
 
         check("bool f(int * xp, int* yp) {\n"
               "    return &xp > &yp;\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:1] -> [test.cpp:2] -> [test.cpp:1] -> [test.cpp:2] -> [test.cpp:2]: (error) Comparing pointers that point to different objects\n",
-            errout.str());
+            "[test.cpp:1:14] -> [test.cpp:2:12] -> [test.cpp:1:23] -> [test.cpp:2:18] -> [test.cpp:2:16]: (error) Comparing pointers that point to different objects [comparePointers]\n",
+            errout_str());
 
         check("int f() {\n"
               "    int x = 0;\n"
               "    int y = 1;\n"
               "    return &x - &y;\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
-            "[test.cpp:2] -> [test.cpp:4] -> [test.cpp:3] -> [test.cpp:4] -> [test.cpp:4]: (error) Subtracting pointers that point to different objects\n",
-            errout.str());
+            "[test.cpp:2:9] -> [test.cpp:4:12] -> [test.cpp:3:9] -> [test.cpp:4:17] -> [test.cpp:4:15]: (error) Subtracting pointers that point to different objects [subtractPointers]\n",
+            errout_str());
 
         check("bool f() {\n"
               "    int x[2] = {1, 2}m;\n"
               "    int* xp = &x[0];\n"
               "    int* yp = &x[1];\n"
               "    return xp > yp;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) Variable 'xp' can be declared as pointer to const [constVariablePointer]\n"
+                      "[test.cpp:4:10]: (style) Variable 'yp' can be declared as pointer to const [constVariablePointer]\n",
+                      errout_str());
 
-        check("bool f(int * xp, int* yp) {\n"
+        check("bool f(const int * xp, const int* yp) {\n"
               "    return xp > yp;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(const int & x, const int& y) {\n"
               "    return &x > &y;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("int& g();\n"
               "bool f() {\n"
@@ -8241,8 +13201,8 @@ class TestOther : public TestFixture {
               "    const int* xp = &x;\n"
               "    const int* yp = &y;\n"
               "    return xp > yp;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct A {int data;};\n"
               "bool f(A ix) {\n"
@@ -8251,8 +13211,30 @@ class TestOther : public TestFixture {
               "    int* xp = &x->data;\n"
               "    int* yp = &y->data;\n"
               "    return xp > yp;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:10]: (style) Variable 'xp' can be declared as pointer to const [constVariablePointer]\n"
+                      "[test.cpp:6:10]: (style) Variable 'yp' can be declared as pointer to const [constVariablePointer]\n",
+                      errout_str());
+
+        check("struct S { int i; };\n" // #11576
+              "int f(S s) {\n"
+              "    return &s.i - (int*)&s;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:19]: (warning) Potentially invalid type conversion in old-style C cast, clarify/fix with C++ cast [dangerousTypeCast]\n", errout_str());
+
+        check("struct S { int i; };\n"
+              "int f(S s1, S s2) {\n"
+              "    return &s1.i - reinterpret_cast<int*>(&s2);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:12] -> [test.cpp:2:15] -> [test.cpp:3:43] -> [test.cpp:3:18]: (error) Subtracting pointers that point to different objects [subtractPointers]\n",
+                      errout_str());
+
+        check("struct S { int a; int b; };\n" // #12422
+              "int f() {\n"
+              "    S s;\n"
+              "    return &s.b - &s.a;\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void unusedVariableValueTemplate() {
@@ -8281,9 +13263,498 @@ class TestOther : public TestFixture {
               "        }\n"
               "    };\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void moduloOfOne() {
+        check("void f(unsigned int x) {\n"
+              "  int y = x % 1;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:13]: (style) Modulo of one is always equal to zero [moduloofone]\n", errout_str());
+
+        check("void f() {\n"
+              "  for (int x = 1; x < 10; x++) {\n"
+              "    int y = 100 % x;\n"
+              "  }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int i, int j) {\n" // #11191
+              "    const int c = pow(2, i);\n"
+              "    if (j % c) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    int i = 0;\n"
+              "    i %= 1;\n"
+              "    (void)i;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:7]: (style) Modulo of one is always equal to zero [moduloofone]\n", errout_str());
+    }
+
+    void sameExpressionPointers() {
+        check("int f(int *i);\n"
+              "void g(int *a, const int *b) {\n"
+              "    int c = *a;\n"
+              "    f(a);\n"
+              "    if (b && c != *a) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void checkOverlappingWrite() {
+        // union
+        check("void foo() {\n"
+              "    union { int i; float f; } u;\n"
+              "    u.i = 0;\n"
+              "    u.i = u.f;\n" // <- error
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Overlapping read/write of union is undefined behavior [overlappingWriteUnion]\n", errout_str());
+
+        check("void foo() {\n" // #11013
+              "    union { struct { uint8_t a; uint8_t b; }; uint16_t c; } u;\n"
+              "    u.a = u.b = 0;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // memcpy
+        check("void foo() {\n"
+              "    char a[10];\n"
+              "    memcpy(&a[5], &a[4], 2u);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Overlapping read/write in memcpy() is undefined behavior [overlappingWriteFunction]\n", errout_str());
+
+        check("void foo() {\n"
+              "    char a[10];\n"
+              "    memcpy(a+5, a+4, 2u);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Overlapping read/write in memcpy() is undefined behavior [overlappingWriteFunction]\n", errout_str());
+
+        check("void foo() {\n"
+              "    char a[10];\n"
+              "    memcpy(a, a+1, 2u);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Overlapping read/write in memcpy() is undefined behavior [overlappingWriteFunction]\n", errout_str());
+
+        check("void foo() {\n"
+              "    char a[8];\n"
+              "    memcpy(&a[0], &a[4], 4u);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("_Bool a[10];\n" // #10350
+              "void foo() {\n"
+              "    memcpy(&a[5], &a[4], 2u * sizeof(a[0]));\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Overlapping read/write in memcpy() is undefined behavior [overlappingWriteFunction]\n", errout_str());
+
+        check("int K[2];\n" // #12638
+              "void f(int* p) {\n"
+              "    memcpy(&K[0], &K[1], sizeof(K[0]));\n"
+              "    memcpy(&K[1], &K[0], sizeof(K[0]));\n"
+              "    memcpy(p, p + 1, sizeof(*p));\n"
+              "    memcpy(p + 1, p, sizeof(*p));\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int K[2];\n"
+              "void f(int* p) {\n"
+              "    memcpy(&K[0], &K[1], 2 * sizeof(K[0]));\n"
+              "    memcpy(&K[1], &K[0], 2 *sizeof(K[0]));\n"
+              "    memcpy(p, p + 1, 2 * sizeof(*p));\n"
+              "    memcpy(p + 1, p, 2 * sizeof(*p));\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Overlapping read/write in memcpy() is undefined behavior [overlappingWriteFunction]\n"
+                      "[test.cpp:4:5]: (error) Overlapping read/write in memcpy() is undefined behavior [overlappingWriteFunction]\n"
+                      "[test.cpp:5:5]: (error) Overlapping read/write in memcpy() is undefined behavior [overlappingWriteFunction]\n"
+                      "[test.cpp:6:5]: (error) Overlapping read/write in memcpy() is undefined behavior [overlappingWriteFunction]\n",
+                      errout_str());
+
+        // wmemcpy
+        check("void foo() {\n"
+              "    wchar_t a[10];\n"
+              "    wmemcpy(&a[5], &a[4], 2u);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Overlapping read/write in wmemcpy() is undefined behavior [overlappingWriteFunction]\n", errout_str());
+
+        check("void foo() {\n"
+              "    wchar_t a[10];\n"
+              "    wmemcpy(a+5, a+4, 2u);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Overlapping read/write in wmemcpy() is undefined behavior [overlappingWriteFunction]\n", errout_str());
+
+        check("void foo() {\n"
+              "    wchar_t a[10];\n"
+              "    wmemcpy(a, a+1, 2u);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Overlapping read/write in wmemcpy() is undefined behavior [overlappingWriteFunction]\n", errout_str());
+
+        // strcpy
+        check("void foo(char *ptr) {\n"
+              "    strcpy(ptr, ptr);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:5]: (error) Overlapping read/write in strcpy() is undefined behavior [overlappingWriteFunction]\n", errout_str());
+    }
+
+    void constVariableArrayMember() { // #10371
+        check("class Foo {\n"
+              "public:\n"
+              "    Foo();\n"
+              "    int GetVal() const { return m_Arr[0]; }\n"
+              "    int m_Arr[1];\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void knownPointerToBool()
+    {
+        check("void g(bool);\n"
+              "void f() {\n"
+              "    int i = 5;\n"
+              "    int* p = &i;\n"
+              "    g(p);\n"
+              "    g(&i);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:7]: (style) Pointer expression 'p' converted to bool is always true. [knownPointerToBool]\n"
+                      "[test.cpp:6:7]: (style) Pointer expression '&i' converted to bool is always true. [knownPointerToBool]\n",
+                      errout_str());
+
+        check("void f() {\n"
+              "    const int* x = nullptr;\n"
+              "    std::empty(x);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    const int* x = nullptr;\n"
+              "    std::empty(const_cast<int*>(x));\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A { bool x; };\n" // #14481
+              "bool f(A* a) {\n"
+              "    if (a) {\n"
+              "        return a->x;\n"
+              "    }\n"
+              "    return false;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Parameter 'a' can be declared as pointer to const [constParameterPointer]\n", errout_str());
+
+        check("struct A { int* x; };\n"
+              "bool f(A a) {\n"
+              "    if (a.x) {\n"
+              "        return a.x;\n"
+              "    }\n"
+              "    return false;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:17]: (style) Pointer expression 'a.x' converted to bool is always true. [knownPointerToBool]\n", errout_str());
+
+        check("void f(bool* b) { if (b) *b = true; }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool f() {\n"
+              "    int* x = nullptr;\n"
+              "    return bool(x);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:17]: (style) Pointer expression 'x' converted to bool is always false. [knownPointerToBool]\n", errout_str());
+
+        check("bool f() {\n"
+              "    int* x = nullptr;\n"
+              "    return bool{x};\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:17]: (style) Pointer expression 'x' converted to bool is always false. [knownPointerToBool]\n", errout_str());
+
+        check("struct A { A(bool); };\n"
+              "A f() {\n"
+              "    int* x = nullptr;\n"
+              "    return A(x);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:14]: (style) Pointer expression 'x' converted to bool is always false. [knownPointerToBool]\n", errout_str());
+
+        check("struct A { A(bool); };\n"
+              "A f() {\n"
+              "    int* x = nullptr;\n"
+              "    return A{x};\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:14]: (style) Pointer expression 'x' converted to bool is always false. [knownPointerToBool]\n", errout_str());
+
+        check("struct B { virtual void f() {} };\n" // #11929
+              "struct D : B {};\n"
+              "void g(B* b) {\n"
+              "    if (!b)\n"
+              "        return;\n"
+              "    if (dynamic_cast<D*>(b)) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool (*ptr)();\n" // #12170
+              "void f() {\n"
+              "    if (!ptr || !ptr()) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void g(bool b[2]);\n" // #12822
+              "void f() {\n"
+              "    bool b[2] = {};\n"
+              "    g(b);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void iterateByValue() {
+        check("void f() {\n" // #9684
+              "    const std::set<std::string> ss = { \"a\", \"b\", \"c\" };\n"
+              "    for (auto s : ss)\n"
+              "        (void)s.size();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:15]: (performance) Range variable 's' should be declared as const reference. [iterateByValue]\n",
+                      errout_str());
+        check("void f() {\n" // #13696
+              "    struct T {\n"
+              "        std::string name;\n"
+              "        UnknownClass member;\n"
+              "    };\n"
+              "\n"
+              "    const std::set<T> ss;\n"
+              "    for (auto s : ss)\n"
+              "        (void)s.name;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:8:15]: (performance) Range variable 's' should be declared as const reference. [iterateByValue]\n",
+                      errout_str());
+    }
+
+    void knownConditionFloating()
+    {
+        check("void foo() {\n" // #11200
+              "    float f = 1.0;\n"
+              "    if (f > 1.0) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:2:16] -> [test.cpp:3:11]: (style) The comparison 'f > 1.0' is always false. [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("void foo() {\n" // #13508
+              "    float f = 1.0;\n"
+              "    if (f > -1.0) {}\n"
+              "}\n");
+        TODO_ASSERT_EQUALS(
+            "[test.cpp:2] -> [test.cpp:3]: (style) The comparison 'f > -1.0' is always false.\n",
+            "",
+            errout_str());
+
+        check("void foo() {\n" // #13506
+              "    float f = 1.0;\n"
+              "    if (f > +1.0) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:2:16] -> [test.cpp:3:11]: (style) The comparison 'f > +1.0' is always false. [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("void foo() {\n"
+              "    float f = 1.0;\n"
+              "    if (f < +1.0) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:2:16] -> [test.cpp:3:11]: (style) The comparison 'f < 1.0' is always false. [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("void foo() {\n" // #11200
+              "    float pf = +1.0;\n"
+              "    if (pf > 1.0) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:2:18] -> [test.cpp:3:12]: (style) The comparison 'pf > 1.0' is always false. [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("void foo() {\n" // #13508
+              "    float pf = +1.0;\n"
+              "    if (pf > -1.0) {}\n"
+              "}\n");
+        TODO_ASSERT_EQUALS(
+            "[test.cpp:2] -> [test.cpp:3]: (style) The comparison 'pf > -1.0' is always false.\n",
+            "",
+            errout_str());
+
+        check("void foo() {\n" // #13506
+              "    float pf = +1.0;\n"
+              "    if (pf > +1.0) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:2:18] -> [test.cpp:3:12]: (style) The comparison 'pf > +1.0' is always false. [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("void foo() {\n"
+              "    float pf = +1.0;\n"
+              "    if (pf < +1.0) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:2:18] -> [test.cpp:3:12]: (style) The comparison 'pf < 1.0' is always false. [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("void foo() {\n" // #11200
+              "    float nf = -1.0;\n"
+              "    if (nf > -1.0) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:2:18] -> [test.cpp:3:12]: (style) The comparison 'nf > -1.0' is always false. [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("void foo() {\n" // #13508
+              "    float nf = -1.0;\n"
+              "    if (nf > 1.0) {}\n"
+              "}\n");
+        TODO_ASSERT_EQUALS(
+            "[test.cpp:2] -> [test.cpp:3]: (style) The comparison 'nf > 1.0' is always false.\n",
+            "",
+            errout_str());
+
+        check("void foo() {\n" // #13508
+              "    float nf = -1.0;\n"
+              "    if (nf > +1.0) {}\n"
+              "}\n");
+        TODO_ASSERT_EQUALS(
+            "[test.cpp:2] -> [test.cpp:3]: (style) The comparison 'nf > +1.0' is always false.\n",
+            "",
+            errout_str());
+
+        check("void foo() {\n"
+              "    float f = 1.0f;\n"
+              "    if (f > 1.00f) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:2:16] -> [test.cpp:3:11]: (style) The comparison 'f > 1.00f' is always false. [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("void foo() {\n" // #13508
+              "    float f = 1.0f;\n"
+              "    if (f > 1) {}\n"
+              "}\n");
+        TODO_ASSERT_EQUALS(
+            "[test.cpp:2] -> [test.cpp:3]: (style) The comparison 'f > 1' is always false.\n",
+            "",
+            errout_str());
+
+        check("void foo() {\n"
+              "    float f = 1.0;\n"
+              "    if (f > 1.00) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:2:16] -> [test.cpp:3:11]: (style) The comparison 'f > 1.00' is always false. [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("void foo() {\n" // #13508
+              "    float f = 1.0;\n"
+              "    if (f > 1) {}\n"
+              "}\n");
+        TODO_ASSERT_EQUALS(
+            "[test.cpp:2] -> [test.cpp:3]: (style) The comparison 'f > 1' is always false.\n",
+            "",
+            errout_str());
     }
 
+    void knownConditionPrefixed()
+    {
+        check("void foo() {\n"
+              "    int i = 1;\n"
+              "    if (i < +1) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:2:13] -> [test.cpp:3:11]: (style) The comparison 'i < 1' is always false. [knownConditionTrueFalse]\n",
+            errout_str());
+
+        check("void foo() {\n" // #13506
+              "    int i = 1;\n"
+              "    if (i > +1) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:2:13] -> [test.cpp:3:11]: (style) The comparison 'i > +1' is always false. [knownConditionTrueFalse]\n",
+            errout_str());
+    }
+
+    void unionZeroInitBasic() {
+        check(
+            "union bad_union_0 {\n"
+            "  char c;\n"
+            "  long long i64;\n"
+            "  void *p;\n"
+            "};\n"
+            "\n"
+            "typedef union {\n"
+            "  char c;\n"
+            "  int i;\n"
+            "} bad_union_1;\n"
+            "\n"
+            "extern void e(union bad_union_0 *);\n"
+            "\n"
+            "void\n"
+            "foo(void)\n"
+            "{\n"
+            "  union { int i; char c; } good0 = {0};\n"
+            "  union { int i; char c; } good1 = {};\n"
+            "\n"
+            "  union { char c; int i; } bad0 = {0};\n"
+            "  union bad_union_0 bad1 = {0};\n"
+            "  e(&bad1);\n"
+            "  bad_union_1 bad2 = {0};\n"
+            "}");
+        const std::string exp = unionZeroInitMessage(20, 28, "bad0", "i") +
+                                unionZeroInitMessage(21, 21, "bad1", "i64") +
+                                unionZeroInitMessage(23, 15, "bad2", "i");
+        ASSERT_EQUALS(exp, errout_str());
+    }
+
+    void unionZeroInitArrayMember() {
+        check(
+            "void foo(void) {\n"
+            " union { int c; char s8[2]; } u = {0};\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void unionZeroInitStructMember() {
+        check(
+            "void foo(void) {\n"
+            "  union {\n"
+            "    int c;\n"
+            "     struct {\n"
+            "       char x;\n"
+            "       struct {\n"
+            "         char y;\n"
+            "       } s1;\n"
+            "    } s0;\n"
+            "  } u = {0};\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void unionZeroInitUnknownType() {
+        check(
+            "union u {\n"
+            "  Unknown x;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void unionZeroInitBitfields() {
+        check(
+            "typedef union Evex {\n"
+            "  int u32;\n"
+            "  struct {\n"
+            "    char mmm:3,\n"
+            "         b4:1,\n"
+            "         r4:1,\n"
+            "         b3:1,\n"
+            "         x3:1,\n"
+            "         r3:1;\n"
+            "  } extended;\n"
+            "} Evex;\n"
+            "\n"
+            "void foo(void) {\n"
+            "  Evex evex = {0};\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+    }
 };
 
 REGISTER_TEST(TestOther)
diff --git a/test/testpath.cpp b/test/testpath.cpp
index ddebb2963c5..2d937950646 100644
--- a/test/testpath.cpp
+++ b/test/testpath.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,27 +17,46 @@
  */
 
 #include "path.h"
-#include "testsuite.h"
+#include "fixture.h"
+#include "helpers.h"
+#include "standards.h"
 
+#include <initializer_list>
+#include <list>
+#include <set>
 #include <string>
 #include <vector>
 
+#ifndef _WIN32
+#include <stdexcept>
+#endif
+
 class TestPath : public TestFixture {
 public:
-    TestPath() : TestFixture("TestPath") {
-    }
+    TestPath() : TestFixture("TestPath") {}
 
 private:
 
-    void run() OVERRIDE {
+    void run() override {
         TEST_CASE(removeQuotationMarks);
         TEST_CASE(acceptFile);
         TEST_CASE(getCurrentPath);
+        TEST_CASE(getCurrentExecutablePath);
         TEST_CASE(isAbsolute);
         TEST_CASE(getRelative);
-        TEST_CASE(is_c);
-        TEST_CASE(is_cpp);
         TEST_CASE(get_path_from_filename);
+        TEST_CASE(join);
+        TEST_CASE(isDirectory);
+        TEST_CASE(isFile);
+        TEST_CASE(sameFileName);
+        TEST_CASE(getFilenameExtension);
+        TEST_CASE(identify);
+        TEST_CASE(identifyWithCppProbe);
+        TEST_CASE(is_header);
+        TEST_CASE(simplifyPath);
+        TEST_CASE(getAbsolutePath);
+        TEST_CASE(exists);
+        TEST_CASE(fromNativeSeparators);
     }
 
     void removeQuotationMarks() const {
@@ -53,6 +72,7 @@ class TestPath : public TestFixture {
     }
 
     void acceptFile() const {
+        ASSERT(Path::acceptFile("index.c"));
         ASSERT(Path::acceptFile("index.cpp"));
         ASSERT(Path::acceptFile("index.invalid.cpp"));
         ASSERT(Path::acceptFile("index.invalid.Cpp"));
@@ -62,16 +82,53 @@ class TestPath : public TestFixture {
         ASSERT(Path::acceptFile("index")==false);
         ASSERT(Path::acceptFile("")==false);
         ASSERT(Path::acceptFile("C")==false);
+        {
+            Standards::Language lang;
+            ASSERT(Path::acceptFile("index.c", &lang));
+            ASSERT_EQUALS_ENUM(Standards::Language::C, lang);
+        }
+        {
+            Standards::Language lang;
+            ASSERT(Path::acceptFile("index.cpp", &lang));
+            ASSERT_EQUALS_ENUM(Standards::Language::CPP, lang);
+        }
 
         // don't accept any headers
         ASSERT_EQUALS(false, Path::acceptFile("index.h"));
         ASSERT_EQUALS(false, Path::acceptFile("index.hpp"));
+
+        const std::set<std::string> extra = { ".extra", ".header" };
+        ASSERT(Path::acceptFile("index.c", extra));
+        ASSERT(Path::acceptFile("index.cpp", extra));
+        ASSERT(Path::acceptFile("index.extra", extra));
+        ASSERT(Path::acceptFile("index.header", extra));
+        ASSERT(Path::acceptFile("index.h", extra)==false);
+        ASSERT(Path::acceptFile("index.hpp", extra)==false);
+        {
+            Standards::Language lang;
+            ASSERT(Path::acceptFile("index.c", extra, &lang));
+            ASSERT_EQUALS_ENUM(Standards::Language::C, lang);
+        }
+        {
+            Standards::Language lang;
+            ASSERT(Path::acceptFile("index.cpp", extra, &lang));
+            ASSERT_EQUALS_ENUM(Standards::Language::CPP, lang);
+        }
+        {
+            Standards::Language lang;
+            ASSERT(Path::acceptFile("index.extra", extra, &lang));
+            ASSERT_EQUALS_ENUM(Standards::Language::None, lang);
+        }
     }
 
     void getCurrentPath() const {
         ASSERT_EQUALS(true, Path::isAbsolute(Path::getCurrentPath()));
     }
 
+    void getCurrentExecutablePath() const {
+        ASSERT_EQUALS(false, Path::getCurrentExecutablePath("").empty());
+    }
+
     void isAbsolute() const {
 #ifdef _WIN32
         ASSERT_EQUALS(true, Path::isAbsolute("C:\\foo\\bar"));
@@ -107,40 +164,459 @@ class TestPath : public TestFixture {
         ASSERT_EQUALS("C:/foobar/test.cpp", Path::getRelativePath("C:/foobar/test.cpp", basePaths));
     }
 
-    void is_c() const {
-        ASSERT(Path::isC("index.cpp")==false);
-        ASSERT(Path::isC("")==false);
-        ASSERT(Path::isC("c")==false);
-        ASSERT(Path::isC("index.c"));
-        ASSERT(Path::isC("C:\\foo\\index.c"));
+    void get_path_from_filename() const {
+        ASSERT_EQUALS("", Path::getPathFromFilename("index.h"));
+        ASSERT_EQUALS("/tmp/", Path::getPathFromFilename("/tmp/index.h"));
+        ASSERT_EQUALS("a/b/c/", Path::getPathFromFilename("a/b/c/index.h"));
+        ASSERT_EQUALS("a/b/c/", Path::getPathFromFilename("a/b/c/"));
+    }
 
-        // In unix .C is considered C++
-#ifdef _WIN32
-        ASSERT_EQUALS(true, Path::isC("C:\\foo\\index.C"));
+    void join() const {
+        ASSERT_EQUALS("", Path::join("", ""));
+        ASSERT_EQUALS("b", Path::join("", "b"));
+        ASSERT_EQUALS("/b", Path::join("", "/b"));
+        ASSERT_EQUALS("/b", Path::join("", "\\b"));
+
+        ASSERT_EQUALS("a", Path::join("a", ""));
+        ASSERT_EQUALS("a/b", Path::join("a", "b"));
+        ASSERT_EQUALS("/b", Path::join("a", "/b"));
+        ASSERT_EQUALS("/b", Path::join("a", "\\b"));
+
+        ASSERT_EQUALS("a/", Path::join("a/", ""));
+        ASSERT_EQUALS("a/b", Path::join("a/", "b"));
+        ASSERT_EQUALS("/b", Path::join("a/", "/b"));
+        ASSERT_EQUALS("/b", Path::join("a/", "\\b"));
+
+        ASSERT_EQUALS("a/", Path::join("a\\", ""));
+        ASSERT_EQUALS("a/b", Path::join("a\\", "b"));
+        ASSERT_EQUALS("/b", Path::join("a\\", "/b"));
+        ASSERT_EQUALS("/b", Path::join("a\\", "\\b"));
+
+        // TODO: how to absolute Windows path in path2?
+        //ASSERT_EQUALS("", Path::join("a", "s:/b"));
+
+        //ASSERT_EQUALS("", Path::join("S:\\a", "S:/b"));
+        //ASSERT_EQUALS("", Path::join("S:\\a", "S:\\b"));
+        //ASSERT_EQUALS("", Path::join("S:\\a", "/b"));
+
+        //ASSERT_EQUALS("", Path::join("S:/a", "S:/b"));
+        //ASSERT_EQUALS("", Path::join("S:/a", "S:\\b"));
+        //ASSERT_EQUALS("", Path::join("S:/a", "/b"));
+    }
+
+    void isDirectory() const {
+        ScopedFile file("testpath.txt", "", "testpath");
+        ScopedFile file2("testpath2.txt", "");
+        ASSERT_EQUALS(false, Path::isDirectory("testpath.txt"));
+        ASSERT_EQUALS(true, Path::isDirectory("testpath"));
+        ASSERT_EQUALS(false, Path::isDirectory("testpath/testpath.txt"));
+        ASSERT_EQUALS(false, Path::isDirectory("testpath2.txt"));
+    }
+
+    void isFile() const {
+        ScopedFile file("testpath.txt", "", "testpath");
+        ScopedFile file2("testpath2.txt", "");
+        ASSERT_EQUALS(false, Path::isFile("testpath"));
+        ASSERT_EQUALS(false, Path::isFile("testpath.txt"));
+        ASSERT_EQUALS(true, Path::isFile("testpath/testpath.txt"));
+        ASSERT_EQUALS(true, Path::isFile("testpath2.txt"));
+    }
+
+    void sameFileName() const {
+        ASSERT(Path::sameFileName("test", "test"));
+
+        // case sensitivity cases
+#if defined(_WIN32) || (defined(__APPLE__) && defined(__MACH__))
+        ASSERT(Path::sameFileName("test", "Test"));
+        ASSERT(Path::sameFileName("test", "TesT"));
+        ASSERT(Path::sameFileName("test.h", "test.H"));
+        ASSERT(Path::sameFileName("test.hh", "test.Hh"));
+        ASSERT(Path::sameFileName("test.hh", "test.hH"));
 #else
-        ASSERT_EQUALS(false, Path::isC("C:\\foo\\index.C"));
+        ASSERT(!Path::sameFileName("test", "Test"));
+        ASSERT(!Path::sameFileName("test", "TesT"));
+        ASSERT(!Path::sameFileName("test.h", "test.H"));
+        ASSERT(!Path::sameFileName("test.hh", "test.Hh"));
+        ASSERT(!Path::sameFileName("test.hh", "test.hH"));
 #endif
     }
 
-    void is_cpp() const {
-        ASSERT(Path::isCPP("index.c")==false);
+    void getFilenameExtension() const {
+        ASSERT_EQUALS("", Path::getFilenameExtension("test"));
+        ASSERT_EQUALS("", Path::getFilenameExtension("Test"));
+        ASSERT_EQUALS(".h", Path::getFilenameExtension("test.h"));
+        ASSERT_EQUALS(".h", Path::getFilenameExtension("Test.h"));
+        ASSERT_EQUALS("", Path::getFilenameExtension("test", true));
+        ASSERT_EQUALS("", Path::getFilenameExtension("Test", true));
+        ASSERT_EQUALS(".h", Path::getFilenameExtension("test.h", true));
+        ASSERT_EQUALS(".h", Path::getFilenameExtension("Test.h", true));
+
+        // case sensitivity cases
+#if defined(_WIN32) || (defined(__APPLE__) && defined(__MACH__))
+        ASSERT_EQUALS(".h", Path::getFilenameExtension("test.H"));
+        ASSERT_EQUALS(".hh", Path::getFilenameExtension("test.Hh"));
+        ASSERT_EQUALS(".hh", Path::getFilenameExtension("test.hH"));
+        ASSERT_EQUALS(".h", Path::getFilenameExtension("test.H", true));
+        ASSERT_EQUALS(".hh", Path::getFilenameExtension("test.Hh", true));
+        ASSERT_EQUALS(".hh", Path::getFilenameExtension("test.hH", true));
+#else
+        ASSERT_EQUALS(".H", Path::getFilenameExtension("test.H"));
+        ASSERT_EQUALS(".Hh", Path::getFilenameExtension("test.Hh"));
+        ASSERT_EQUALS(".hH", Path::getFilenameExtension("test.hH"));
+        ASSERT_EQUALS(".h", Path::getFilenameExtension("test.H", true));
+        ASSERT_EQUALS(".hh", Path::getFilenameExtension("test.Hh", true));
+        ASSERT_EQUALS(".hh", Path::getFilenameExtension("test.hH", true));
+#endif
+    }
+
+
+    void identify() const {
+        Standards::Language lang;
+        bool header;
+
+        ASSERT_EQUALS(Standards::Language::None, Path::identify("", false));
+        ASSERT_EQUALS(Standards::Language::None, Path::identify("c", false));
+        ASSERT_EQUALS(Standards::Language::None, Path::identify("cpp", false));
+        ASSERT_EQUALS(Standards::Language::None, Path::identify("h", false));
+        ASSERT_EQUALS(Standards::Language::None, Path::identify("hpp", false));
+
+        // TODO: what about files starting with a "."?
+        //ASSERT_EQUALS(Standards::Language::None, Path::identify(".c", false));
+        //ASSERT_EQUALS(Standards::Language::None, Path::identify(".cpp", false));
+        //ASSERT_EQUALS(Standards::Language::None, Path::identify(".h", false));
+        //ASSERT_EQUALS(Standards::Language::None, Path::identify(".hpp", false));
+
+        // C
+        ASSERT_EQUALS(Standards::Language::C, Path::identify("index.c", false));
+        ASSERT_EQUALS(Standards::Language::C, Path::identify("index.cl", false));
+        ASSERT_EQUALS(Standards::Language::C, Path::identify("C:\\foo\\index.c", false));
+        ASSERT_EQUALS(Standards::Language::C, Path::identify("/mnt/c/foo/index.c", false));
 
         // In unix .C is considered C++
 #ifdef _WIN32
-        ASSERT_EQUALS(false, Path::isCPP("index.C"));
+        ASSERT_EQUALS(Standards::Language::C, Path::identify("C:\\foo\\index.C", false));
+#endif
+
+        lang = Path::identify("index.c", false, &header);
+        ASSERT_EQUALS(Standards::Language::C, lang);
+        ASSERT_EQUALS(false, header);
+
+        // C++
+        ASSERT_EQUALS(Standards::Language::CPP, Path::identify("index.cpp", false));
+        ASSERT_EQUALS(Standards::Language::CPP, Path::identify("index.cxx", false));
+        ASSERT_EQUALS(Standards::Language::CPP, Path::identify("index.cc", false));
+        ASSERT_EQUALS(Standards::Language::CPP, Path::identify("index.c++", false));
+        ASSERT_EQUALS(Standards::Language::CPP, Path::identify("index.tpp", false));
+        ASSERT_EQUALS(Standards::Language::CPP, Path::identify("index.txx", false));
+        ASSERT_EQUALS(Standards::Language::CPP, Path::identify("index.ipp", false));
+        ASSERT_EQUALS(Standards::Language::CPP, Path::identify("index.ixx", false));
+        ASSERT_EQUALS(Standards::Language::CPP, Path::identify("C:\\foo\\index.cpp", false));
+        ASSERT_EQUALS(Standards::Language::CPP, Path::identify("C:\\foo\\index.Cpp", false));
+        ASSERT_EQUALS(Standards::Language::CPP, Path::identify("/mnt/c/foo/index.cpp", false));
+        ASSERT_EQUALS(Standards::Language::CPP, Path::identify("/mnt/c/foo/index.Cpp", false));
+
+        // TODO: check for case-insenstive filesystem instead
+        // In unix .C is considered C++
+#if !defined(_WIN32) && !(defined(__APPLE__) && defined(__MACH__))
+        ASSERT_EQUALS(Standards::Language::CPP, Path::identify("index.C", false));
 #else
-        ASSERT_EQUALS(true, Path::isCPP("index.C"));
+        ASSERT_EQUALS(Standards::Language::C, Path::identify("index.C", false));
 #endif
-        ASSERT(Path::isCPP("index.cpp"));
-        ASSERT(Path::isCPP("C:\\foo\\index.cpp"));
-        ASSERT(Path::isCPP("C:\\foo\\index.Cpp"));
+
+        lang = Path::identify("index.cpp", false, &header);
+        ASSERT_EQUALS(Standards::Language::CPP, lang);
+        ASSERT_EQUALS(false, header);
+
+        // headers
+        lang = Path::identify("index.h", false, &header);
+        ASSERT_EQUALS(Standards::Language::C, lang);
+        ASSERT_EQUALS(true, header);
+
+        lang = Path::identify("index.hpp", false, &header);
+        ASSERT_EQUALS(Standards::Language::CPP, lang);
+        ASSERT_EQUALS(true, header);
+        lang = Path::identify("index.hxx", false, &header);
+        ASSERT_EQUALS(Standards::Language::CPP, lang);
+        ASSERT_EQUALS(true, header);
+        lang = Path::identify("index.h++", false, &header);
+        ASSERT_EQUALS(Standards::Language::CPP, lang);
+        ASSERT_EQUALS(true, header);
+        lang = Path::identify("index.hh", false, &header);
+        ASSERT_EQUALS(Standards::Language::CPP, lang);
+        ASSERT_EQUALS(true, header);
+
+        ASSERT_EQUALS(Standards::Language::None, Path::identify("index.header", false));
+        ASSERT_EQUALS(Standards::Language::None, Path::identify("index.htm", false));
+        ASSERT_EQUALS(Standards::Language::None, Path::identify("index.html", false));
     }
 
-    void get_path_from_filename() const {
-        ASSERT_EQUALS("", Path::getPathFromFilename("index.h"));
-        ASSERT_EQUALS("/tmp/", Path::getPathFromFilename("/tmp/index.h"));
-        ASSERT_EQUALS("a/b/c/", Path::getPathFromFilename("a/b/c/index.h"));
-        ASSERT_EQUALS("a/b/c/", Path::getPathFromFilename("a/b/c/"));
+#define identifyWithCppProbeInternal(...) identifyWithCppProbeInternal_(__FILE__, __LINE__, __VA_ARGS__)
+    void identifyWithCppProbeInternal_(const char* file, int line, const std::string& filename, const std::string& marker, Standards::Language std) const
+    {
+        const ScopedFile f(filename, marker);
+        ASSERT_EQUALS_LOC_MSG(std, Path::identify(f.path(), true), filename + "\n" + marker, file, line);
+    }
+
+    void identifyWithCppProbe() const
+    {
+        const std::list<std::string> markers_cpp = {
+            "// -*- C++ -*-",
+            "// -*-C++-*-",
+            "// -*- Mode: C++; -*-",
+            "// -*-Mode: C++;-*-",
+            "// -*- Mode:C++; -*-",
+            "// -*-Mode:C++;-*-",
+            "// -*- Mode: C++ -*-",
+            "// -*-Mode: C++-*-",
+            "// -*- Mode:C++ -*-",
+            "// -*-Mode:C++-*-",
+            "// -*- Mode: C++; c-basic-offset: 8 -*-",
+            "// -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*-",
+
+            "// -*- c++ -*-",
+            "// -*- mode: c++; -*-",
+
+            "/* -*- C++ -*- */",
+            "/* -*- C++ -*-",
+
+            "//-*- C++ -*-",
+            " //-*- C++ -*-",
+            "\t//-*- C++ -*-",
+            "\t //-*- C++ -*-",
+            " \t//-*- C++ -*-",
+            "//-*- C++ -*- ",
+            "//-*- C++ -*- \n",
+            "// -----*- C++ -*-----",
+            "// comment-*- C++ -*-comment",
+            "// -*- C++ -*-\n",
+            "//-*- C++ -*-\r// comment",
+            "//-*- C++ -*-\n// comment",
+            "//-*- C++ -*-\r\n// comment",
+
+            "/* -*-C++-*- */",
+            "/*-*-C++-*-*/",
+            " /*-*-C++-*-*/",
+        };
+
+        for (const auto& f : { "cppprobe.h", "cppprobe" }) {
+            for (const auto& m : markers_cpp) {
+                identifyWithCppProbeInternal(f, m, Standards::Language::CPP);
+            }
+        }
+
+        const std::list<std::string> markers_c = {
+            "-*- C++ -*-", // needs to be in comment
+            "// -*- C++", // no end marker
+            "// -*- C++ --*-", // incorrect end marker
+            "// -*- C++/-*-", // unexpected character
+            "// comment\n// -*- C++ -*-", // not on the first line
+            "// comment\r// -*- C++ -*-", // not on the first line
+            "// comment\r\n// -*- C++ -*-", // not on the first line
+            "// -*- C -*-",
+            "// -*- Mode: C; -*-",
+            "// -*- f90 -*-",
+            "// -*- fortran -*-",
+            "// -*- c-basic-offset: 2 -*-",
+            "// -*- c-basic-offset:4; indent-tabs-mode:nil -*-",
+            "// ", // no marker
+            "// -*-", // incomplete marker
+            "/*", // no marker
+            "/**/", // no marker
+            "/*\n*/", // no marker
+            "/* */", // no marker
+            "/* \n*/", // no marker
+            "/* -*-", // incomplete marker
+            "/* \n-*-", // incomplete marker
+            "/* \n-*- C++ -*-", // not on the first line
+            "/* \n-*- C++ -*- */" // not on the first line
+        };
+
+        for (const auto& m : markers_c) {
+            identifyWithCppProbeInternal("cppprobe.h", m, Standards::Language::C);
+        }
+        for (const auto& m : markers_c) {
+            identifyWithCppProbeInternal("cppprobe", m, Standards::Language::None);
+        }
+    }
+
+    void is_header() const {
+        ASSERT(Path::isHeader("index.h"));
+        ASSERT(Path::isHeader("index.hpp"));
+        ASSERT(Path::isHeader("index.hxx"));
+        ASSERT(Path::isHeader("index.h++"));
+        ASSERT(Path::isHeader("index.hh"));
+
+        ASSERT(Path::isHeader("index.c")==false);
+        ASSERT(Path::isHeader("index.cpp")==false);
+        ASSERT(Path::isHeader("index.header")==false);
+        ASSERT(Path::isHeader("index.htm")==false);
+        ASSERT(Path::isHeader("index.html")==false);
+    }
+
+    void simplifyPath() const {
+        ASSERT_EQUALS("file.cpp", Path::simplifyPath("file.cpp"));
+        ASSERT_EQUALS("../file.cpp", Path::simplifyPath("../file.cpp"));
+        ASSERT_EQUALS("file.cpp", Path::simplifyPath("test/../file.cpp"));
+        ASSERT_EQUALS("../file.cpp", Path::simplifyPath("../test/../file.cpp"));
+
+        ASSERT_EQUALS("file.cpp", Path::simplifyPath("./file.cpp"));
+        ASSERT_EQUALS("../file.cpp", Path::simplifyPath("./../file.cpp"));
+        ASSERT_EQUALS("file.cpp", Path::simplifyPath("./test/../file.cpp"));
+        ASSERT_EQUALS("../file.cpp", Path::simplifyPath("./../test/../file.cpp"));
+
+        ASSERT_EQUALS("test/", Path::simplifyPath("test/"));
+        ASSERT_EQUALS("../test/", Path::simplifyPath("../test/"));
+        ASSERT_EQUALS("../", Path::simplifyPath("../test/.."));
+        ASSERT_EQUALS("../", Path::simplifyPath("../test/../"));
+
+        ASSERT_EQUALS("/home/file.cpp", Path::simplifyPath("/home/test/../file.cpp"));
+        ASSERT_EQUALS("/file.cpp", Path::simplifyPath("/home/../test/../file.cpp"));
+
+        ASSERT_EQUALS("C:/home/file.cpp", Path::simplifyPath("C:/home/test/../file.cpp"));
+        ASSERT_EQUALS("C:/file.cpp", Path::simplifyPath("C:/home/../test/../file.cpp"));
+
+        ASSERT_EQUALS("../file.cpp", Path::simplifyPath("..\\file.cpp"));
+        ASSERT_EQUALS("file.cpp", Path::simplifyPath("test\\..\\file.cpp"));
+        ASSERT_EQUALS("../file.cpp", Path::simplifyPath("..\\test\\..\\file.cpp"));
+
+        ASSERT_EQUALS("file.cpp", Path::simplifyPath(".\\file.cpp"));
+        ASSERT_EQUALS("../file.cpp", Path::simplifyPath(".\\..\\file.cpp"));
+        ASSERT_EQUALS("file.cpp", Path::simplifyPath(".\\test\\..\\file.cpp"));
+        ASSERT_EQUALS("../file.cpp", Path::simplifyPath(".\\..\\test\\..\\file.cpp"));
+
+        ASSERT_EQUALS("test/", Path::simplifyPath("test\\"));
+        ASSERT_EQUALS("../test/", Path::simplifyPath("..\\test\\"));
+        ASSERT_EQUALS("../", Path::simplifyPath("..\\test\\.."));
+        ASSERT_EQUALS("../", Path::simplifyPath("..\\test\\..\\"));
+
+        ASSERT_EQUALS("C:/home/file.cpp", Path::simplifyPath("C:\\home\\test\\..\\file.cpp"));
+        ASSERT_EQUALS("C:/file.cpp", Path::simplifyPath("C:\\home\\..\\test\\..\\file.cpp"));
+
+        ASSERT_EQUALS("//home/file.cpp", Path::simplifyPath("\\\\home\\test\\..\\file.cpp"));
+        ASSERT_EQUALS("//file.cpp", Path::simplifyPath("\\\\home\\..\\test\\..\\file.cpp"));
+    }
+
+    void getAbsolutePath() const {
+        const std::string cwd = Path::getCurrentPath();
+
+        ScopedFile file("testabspath.txt", "");
+        std::string expected = Path::toNativeSeparators(Path::join(cwd, "testabspath.txt"));
+
+        ASSERT_EQUALS(expected, Path::getAbsoluteFilePath("testabspath.txt"));
+        ASSERT_EQUALS(expected, Path::getAbsoluteFilePath("./testabspath.txt"));
+        ASSERT_EQUALS(expected, Path::getAbsoluteFilePath(".\\testabspath.txt"));
+        ASSERT_EQUALS(expected, Path::getAbsoluteFilePath("test/../testabspath.txt"));
+        ASSERT_EQUALS(expected, Path::getAbsoluteFilePath("test\\..\\testabspath.txt"));
+        ASSERT_EQUALS(expected, Path::getAbsoluteFilePath("./test/../testabspath.txt"));
+        ASSERT_EQUALS(expected, Path::getAbsoluteFilePath(".\\test\\../testabspath.txt"));
+
+        ASSERT_EQUALS(expected, Path::getAbsoluteFilePath(Path::join(cwd, "testabspath.txt")));
+
+        std::string cwd_up = Path::getPathFromFilename(cwd);
+        cwd_up.pop_back(); // remove trailing slash
+        ASSERT_EQUALS(cwd_up, Path::getAbsoluteFilePath(Path::join(cwd, "..")));
+        ASSERT_EQUALS(cwd_up, Path::getAbsoluteFilePath(Path::join(cwd, "../")));
+        ASSERT_EQUALS(cwd_up, Path::getAbsoluteFilePath(Path::join(cwd, "..\\")));
+        ASSERT_EQUALS(cwd_up, Path::getAbsoluteFilePath(Path::join(cwd, "./../")));
+        ASSERT_EQUALS(cwd_up, Path::getAbsoluteFilePath(Path::join(cwd, ".\\..\\")));
+
+        ASSERT_EQUALS(cwd, Path::getAbsoluteFilePath("."));
+#ifndef _WIN32
+        TODO_ASSERT_EQUALS(cwd, "", Path::getAbsoluteFilePath("./"));
+        TODO_ASSERT_EQUALS(cwd, "", Path::getAbsoluteFilePath(".\\"));
+#else
+        ASSERT_EQUALS(cwd, Path::getAbsoluteFilePath("./"));
+        ASSERT_EQUALS(cwd, Path::getAbsoluteFilePath(".\\"));
+#endif
+
+        ASSERT_EQUALS("", Path::getAbsoluteFilePath(""));
+
+#ifndef _WIN32
+        // the underlying realpath() call only returns something if the path actually exists
+        ASSERT_THROW_EQUALS(Path::getAbsoluteFilePath("testabspath2.txt"), std::runtime_error, "path 'testabspath2.txt' does not exist");
+#else
+        ASSERT_EQUALS(Path::toNativeSeparators(Path::join(cwd, "testabspath2.txt")), Path::getAbsoluteFilePath("testabspath2.txt"));
+#endif
+
+#ifdef _WIN32
+        // determine an existing drive letter
+        std::string drive = Path::getCurrentPath().substr(0, 2);
+        ASSERT_EQUALS(drive + "", Path::getAbsoluteFilePath(drive + "\\"));
+        ASSERT_EQUALS(drive + "\\path", Path::getAbsoluteFilePath(drive + "\\path"));
+        ASSERT_EQUALS(drive + "\\path", Path::getAbsoluteFilePath(drive + "\\path\\"));
+        ASSERT_EQUALS(drive + "\\path\\files.txt", Path::getAbsoluteFilePath(drive + "\\path\\files.txt"));
+        ASSERT_EQUALS(drive + "", Path::getAbsoluteFilePath(drive + "//"));
+        ASSERT_EQUALS(drive + "\\path", Path::getAbsoluteFilePath(drive + "//path"));
+        ASSERT_EQUALS(drive + "\\path", Path::getAbsoluteFilePath(drive + "//path/"));
+        ASSERT_EQUALS(drive + "\\path\\files.txt", Path::getAbsoluteFilePath(drive + "//path/files.txt"));
+        ASSERT_EQUALS(drive + "\\path", Path::getAbsoluteFilePath(drive + "\\\\path"));
+        ASSERT_EQUALS(drive + "", Path::getAbsoluteFilePath(drive + "/"));
+        ASSERT_EQUALS(drive + "\\path", Path::getAbsoluteFilePath(drive + "/path"));
+
+        drive[0] = static_cast<char>(toupper(drive[0]));
+        ASSERT_EQUALS(drive + "\\path", Path::getAbsoluteFilePath(drive + "\\path"));
+        ASSERT_EQUALS(drive + "\\path", Path::getAbsoluteFilePath(drive + "/path"));
+
+        drive[0] = static_cast<char>(tolower(drive[0]));
+        ASSERT_EQUALS(drive + "\\path", Path::getAbsoluteFilePath(drive + "\\path"));
+        ASSERT_EQUALS(drive + "\\path", Path::getAbsoluteFilePath(drive + "/path"));
+
+        ASSERT_EQUALS("1:\\path\\files.txt", Path::getAbsoluteFilePath("1:\\path\\files.txt")); // treated as valid drive
+        ASSERT_EQUALS(
+            Path::toNativeSeparators(Path::join(Path::getCurrentPath(), "CC:\\path\\files.txt")),
+            Path::getAbsoluteFilePath("CC:\\path\\files.txt")); // treated as filename
+        ASSERT_EQUALS("1:\\path\\files.txt", Path::getAbsoluteFilePath("1:/path/files.txt")); // treated as valid drive
+        ASSERT_EQUALS(
+            Path::toNativeSeparators(Path::join(Path::getCurrentPath(), "CC:\\path\\files.txt")),
+            Path::getAbsoluteFilePath("CC:/path/files.txt")); // treated as filename
+#endif
+
+#ifndef _WIN32
+        ASSERT_THROW_EQUALS(Path::getAbsoluteFilePath("C:\\path\\files.txt"), std::runtime_error, "path 'C:\\path\\files.txt' does not exist");
+#endif
+
+        // TODO: test UNC paths
+        // TODO: test with symlinks
+    }
+
+    void exists() const {
+        ScopedFile file("testpath.txt", "", "testpath");
+        ScopedFile file2("testpath2.txt", "");
+
+        ASSERT_EQUALS(true, Path::exists("testpath"));
+        ASSERT_EQUALS(true, Path::exists("testpath2.txt"));
+
+        ASSERT_EQUALS(false, Path::exists("testpath2"));
+
+        bool b = false;
+
+        ASSERT_EQUALS(true, Path::exists("testpath", &b));
+        ASSERT_EQUALS(true, b);
+        ASSERT_EQUALS(true, Path::exists("testpath/testpath.txt", &b));
+        ASSERT_EQUALS(false, b);
+        ASSERT_EQUALS(true, Path::exists("testpath2.txt", &b));
+        ASSERT_EQUALS(false, b);
+
+        ASSERT_EQUALS(false, Path::exists("testpath2", &b));
+        ASSERT_EQUALS(false, b);
+        ASSERT_EQUALS(false, Path::exists("testpath/testpath2.txt", &b));
+        ASSERT_EQUALS(false, b);
+        ASSERT_EQUALS(false, Path::exists("testpath.txt", &b));
+        ASSERT_EQUALS(false, b);
+    }
+
+    void fromNativeSeparators() const {
+        ASSERT_EQUALS("lib/file.c", Path::fromNativeSeparators("lib/file.c"));
+        ASSERT_EQUALS("lib//file.c", Path::fromNativeSeparators("lib//file.c"));
+        ASSERT_EQUALS("/lib/file.c", Path::fromNativeSeparators("/lib/file.c"));
+        ASSERT_EQUALS("//lib/file.c", Path::fromNativeSeparators("//lib/file.c"));
+        ASSERT_EQUALS("./lib/file.c", Path::fromNativeSeparators("./lib/file.c"));
+
+        ASSERT_EQUALS("lib/file.c", Path::fromNativeSeparators("lib\\file.c"));
+        ASSERT_EQUALS("lib//file.c", Path::fromNativeSeparators("lib\\\\file.c"));
+        ASSERT_EQUALS("/lib/file.c", Path::fromNativeSeparators("\\lib\\file.c"));
+        ASSERT_EQUALS("//lib/file.c", Path::fromNativeSeparators("\\\\lib\\file.c"));
+        ASSERT_EQUALS("./lib/file.c", Path::fromNativeSeparators(".\\lib\\file.c"));
     }
 };
 
diff --git a/test/testpathmatch.cpp b/test/testpathmatch.cpp
index 12a76507570..31cc5e687b6 100644
--- a/test/testpathmatch.cpp
+++ b/test/testpathmatch.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,7 +17,7 @@
  */
 
 #include "pathmatch.h"
-#include "testsuite.h"
+#include "fixture.h"
 
 #include <string>
 #include <vector>
@@ -25,29 +25,39 @@
 
 class TestPathMatch : public TestFixture {
 public:
-    TestPathMatch()
-        : TestFixture("TestPathMatch")
-        , emptyMatcher(std::vector<std::string>())
-        , srcMatcher(std::vector<std::string>(1, "src/"))
-        , fooCppMatcher(std::vector<std::string>(1, "foo.cpp"))
-        , srcFooCppMatcher(std::vector<std::string>(1, "src/foo.cpp")) {
-    }
+    TestPathMatch() : TestFixture("TestPathMatch") {}
 
 private:
-    const PathMatch emptyMatcher;
-    const PathMatch srcMatcher;
-    const PathMatch fooCppMatcher;
-    const PathMatch srcFooCppMatcher;
-
-    void run() OVERRIDE {
+    class PathMatchTest final : public PathMatch
+    {
+        friend class TestPathMatch;
+    };
+
+    static constexpr auto unix = PathMatch::Syntax::unix;
+    static constexpr auto windows = PathMatch::Syntax::windows;
+    static constexpr auto ifreg = PathMatch::Filemode::regular;
+    static constexpr auto ifdir = PathMatch::Filemode::directory;
+#ifdef _WIN32
+    const std::string basepath{"C:\\test"};
+#else
+    const std::string basepath{"/test"};
+#endif
+    const PathMatch emptyMatcher{{}, basepath};
+    const PathMatch srcMatcher{{"src/"}, basepath};
+    const PathMatch fooCppMatcher{{"foo.cpp"}, basepath};
+    const PathMatch srcFooCppMatcher{{"src/foo.cpp"}, basepath};
+
+    void run() override {
         TEST_CASE(emptymaskemptyfile);
         TEST_CASE(emptymaskpath1);
         TEST_CASE(emptymaskpath2);
         TEST_CASE(emptymaskpath3);
         TEST_CASE(onemaskemptypath);
         TEST_CASE(onemasksamepath);
+        TEST_CASE(onemasksamepathdifferentslash);
         TEST_CASE(onemasksamepathdifferentcase);
         TEST_CASE(onemasksamepathwithfile);
+        TEST_CASE(onemaskshorterpath);
         TEST_CASE(onemaskdifferentdir1);
         TEST_CASE(onemaskdifferentdir2);
         TEST_CASE(onemaskdifferentdir3);
@@ -55,6 +65,7 @@ class TestPathMatch : public TestFixture {
         TEST_CASE(onemasklongerpath1);
         TEST_CASE(onemasklongerpath2);
         TEST_CASE(onemasklongerpath3);
+        TEST_CASE(onemaskcwd);
         TEST_CASE(twomasklongerpath1);
         TEST_CASE(twomasklongerpath2);
         TEST_CASE(twomasklongerpath3);
@@ -63,10 +74,17 @@ class TestPathMatch : public TestFixture {
         TEST_CASE(filemaskdifferentcase);
         TEST_CASE(filemask2);
         TEST_CASE(filemask3);
+        TEST_CASE(filemaskcwd);
         TEST_CASE(filemaskpath1);
         TEST_CASE(filemaskpath2);
         TEST_CASE(filemaskpath3);
         TEST_CASE(filemaskpath4);
+        TEST_CASE(mixedallmatch);
+        TEST_CASE(glob1);
+        TEST_CASE(glob2);
+        TEST_CASE(globstar1);
+        TEST_CASE(globstar2);
+        TEST_CASE(pathiterator);
     }
 
     // Test empty PathMatch
@@ -75,15 +93,16 @@ class TestPathMatch : public TestFixture {
     }
 
     void emptymaskpath1() const {
-        ASSERT(!emptyMatcher.match("src/"));
+        ASSERT(!emptyMatcher.match("src/", ifdir));
     }
 
     void emptymaskpath2() const {
-        ASSERT(!emptyMatcher.match("../src/"));
+        ASSERT(!emptyMatcher.match("../src/", ifdir));
     }
 
     void emptymaskpath3() const {
-        ASSERT(!emptyMatcher.match("/home/user/code/src/"));
+        ASSERT(!emptyMatcher.match("/home/user/code/src/", ifdir));
+        ASSERT(!emptyMatcher.match("d:/home/user/code/src/", ifdir));
     }
 
     // Test PathMatch containing "src/"
@@ -92,19 +111,35 @@ class TestPathMatch : public TestFixture {
     }
 
     void onemasksamepath() const {
-        ASSERT(srcMatcher.match("src/"));
+        ASSERT(srcMatcher.match("src/", ifdir));
+        ASSERT(!srcMatcher.match("src/", ifreg));
+    }
+
+    void onemasksamepathdifferentslash() const {
+        PathMatch srcMatcher2({"src\\"}, basepath, windows);
+        ASSERT(srcMatcher2.match("src/", ifdir));
+        ASSERT(!srcMatcher2.match("src/", ifreg));
     }
 
     void onemasksamepathdifferentcase() const {
-        std::vector<std::string> masks(1, "sRc/");
-        PathMatch match(masks, false);
-        ASSERT(match.match("srC/"));
+        PathMatch match({"sRc/"}, basepath, windows);
+        ASSERT(match.match("srC/", ifdir));
+        ASSERT(!match.match("srC/", ifreg));
     }
 
     void onemasksamepathwithfile() const {
         ASSERT(srcMatcher.match("src/file.txt"));
     }
 
+    void onemaskshorterpath() const {
+        const std::string longerExclude("longersrc/");
+        const std::string shorterToMatch("src/");
+        ASSERT(shorterToMatch.length() < longerExclude.length());
+        PathMatch match({longerExclude});
+        ASSERT(match.match(longerExclude, ifdir));
+        ASSERT(!match.match(shorterToMatch, ifdir));
+    }
+
     void onemaskdifferentdir1() const {
         ASSERT(!srcMatcher.match("srcfiles/file.txt"));
     }
@@ -122,39 +157,43 @@ class TestPathMatch : public TestFixture {
     }
 
     void onemasklongerpath1() const {
-        ASSERT(srcMatcher.match("/tmp/src/"));
+        ASSERT(srcMatcher.match("/tmp/src/", ifdir));
+        ASSERT(srcMatcher.match("d:/tmp/src/", ifdir));
     }
 
     void onemasklongerpath2() const {
-        ASSERT(srcMatcher.match("src/module/"));
+        ASSERT(srcMatcher.match("src/module/", ifdir));
     }
 
     void onemasklongerpath3() const {
-        ASSERT(srcMatcher.match("project/src/module/"));
+        ASSERT(srcMatcher.match("project/src/module/", ifdir));
+    }
+
+    void onemaskcwd() const {
+        ASSERT(srcMatcher.match("./src", ifdir));
     }
 
     void twomasklongerpath1() const {
-        std::vector<std::string> masks = { "src/", "module/" };
-        PathMatch match(masks);
-        ASSERT(!match.match("project/"));
+        PathMatch match({ "src/", "module/" });
+        ASSERT(!match.match("project/", ifdir));
     }
 
     void twomasklongerpath2() const {
-        std::vector<std::string> masks = { "src/", "module/" };
-        PathMatch match(masks);
-        ASSERT(match.match("project/src/"));
+        PathMatch match({ "src/", "module/" });
+        ASSERT(match.match("project/src/", ifdir));
+        ASSERT(!match.match("project/src/", ifreg));
     }
 
     void twomasklongerpath3() const {
-        std::vector<std::string> masks = { "src/", "module/" };
-        PathMatch match(masks);
-        ASSERT(match.match("project/module/"));
+        PathMatch match({ "src/", "module/" });
+        ASSERT(match.match("project/module/", ifdir));
+        ASSERT(!match.match("project/module/", ifreg));
     }
 
     void twomasklongerpath4() const {
-        std::vector<std::string> masks = { "src/", "module/" };
-        PathMatch match(masks);
-        ASSERT(match.match("project/src/module/"));
+        PathMatch match({ "src/", "module/" });
+        ASSERT(match.match("project/src/module/", ifdir));
+        ASSERT(match.match("project/src/module/", ifreg));
     }
 
     // Test PathMatch containing "foo.cpp"
@@ -163,8 +202,7 @@ class TestPathMatch : public TestFixture {
     }
 
     void filemaskdifferentcase() const {
-        std::vector<std::string> masks(1, "foo.cPp");
-        PathMatch match(masks, false);
+        PathMatch match({"foo.cPp"}, basepath, windows);
         ASSERT(match.match("fOo.cpp"));
     }
 
@@ -176,6 +214,10 @@ class TestPathMatch : public TestFixture {
         ASSERT(fooCppMatcher.match("src/foo.cpp"));
     }
 
+    void filemaskcwd() const {
+        ASSERT(fooCppMatcher.match("./lib/foo.cpp"));
+    }
+
     // Test PathMatch containing "src/foo.cpp"
     void filemaskpath1() const {
         ASSERT(srcFooCppMatcher.match("src/foo.cpp"));
@@ -192,6 +234,80 @@ class TestPathMatch : public TestFixture {
     void filemaskpath4() const {
         ASSERT(!srcFooCppMatcher.match("bar/foo.cpp"));
     }
+
+    void mixedallmatch() const { // #13570
+        // when trying to match a directory against a directory entry it erroneously modified a local variable also used for file matching
+        PathMatch match({ "tests/", "file.c" });
+        ASSERT(match.match("tests/", ifdir));
+        ASSERT(!match.match("tests/", ifreg));
+        ASSERT(match.match("lib/file.c"));
+    }
+
+    void glob1() const {
+        PathMatch match({"test?.cpp"});
+        ASSERT(match.match("test1.cpp"));
+        ASSERT(match.match("src/test1.cpp"));
+        ASSERT(match.match("test1.cpp/src"));
+        ASSERT(!match.match("test1.c"));
+        ASSERT(!match.match("test.cpp"));
+    }
+
+    void glob2() const {
+        PathMatch match({"test*.cpp"});
+        ASSERT(match.match("test1.cpp"));
+        ASSERT(match.match("src/test1.cpp"));
+        ASSERT(match.match("test1.cpp/src"));
+        ASSERT(!match.match("test1.c"));
+        ASSERT(match.match("test.cpp"));
+    }
+
+    void globstar1() const {
+        PathMatch match({"src/**/foo.c"});
+        ASSERT(match.match("src/lib/foo/foo.c"));
+        ASSERT(match.match("src/lib/foo/bar/foo.c"));
+        ASSERT(!match.match("src/lib/foo/foo.cpp"));
+        ASSERT(!match.match("src/lib/foo/bar/foo.cpp"));
+        ASSERT(!match.match("src/foo.c"));
+    }
+
+    void globstar2() const {
+        PathMatch match({"./src/**/foo.c"});
+        ASSERT(match.match("src/lib/foo/foo.c"));
+        ASSERT(match.match("src/lib/foo/bar/foo.c"));
+        ASSERT(!match.match("src/lib/foo/foo.cpp"));
+        ASSERT(!match.match("src/lib/foo/bar/foo.cpp"));
+        ASSERT(!match.match("src/foo.c"));
+    }
+
+    void pathiterator() const {
+        /* See https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats
+         * for information on Windows path syntax. */
+        using PathIterator = PathMatchTest::PathIterator;
+        ASSERT_EQUALS("/", PathIterator("/", nullptr, unix).read());
+        ASSERT_EQUALS("/", PathIterator("//", nullptr, unix).read());
+        ASSERT_EQUALS("/", PathIterator("/", "/", unix).read());
+        ASSERT_EQUALS("/hello/world", PathIterator("/hello/universe/.", "../world//", unix).read());
+        ASSERT_EQUALS("/", PathIterator("//./..//.///.", "../../..///", unix).read());
+        ASSERT_EQUALS("/foo/bar", PathIterator(nullptr, "/foo/bar/.", unix).read());
+        ASSERT_EQUALS("/foo/bar", PathIterator("/foo/bar/.", nullptr, unix).read());
+        ASSERT_EQUALS("/foo/bar", PathIterator("/foo", "bar", unix).read());
+        ASSERT_EQUALS("", PathIterator("", "", unix).read());
+        ASSERT_EQUALS("", PathIterator("", nullptr, unix).read());
+        ASSERT_EQUALS("", PathIterator(nullptr, "", unix).read());
+        ASSERT_EQUALS("", PathIterator(nullptr, nullptr, unix).read());
+        ASSERT_EQUALS("c:", PathIterator("C:", nullptr, windows).read());
+        /* C: without slash is a bit ambigous. It should probably not be considered a root because it's
+         * not fully qualified (it designates the current directory on the C drive),
+         * so this test could be considered to be unspecified behavior. */
+        ASSERT_EQUALS("c:", PathIterator("C:", "../..", windows).read());
+        ASSERT_EQUALS("c:/windows/system32", PathIterator("C:", "Windows\\System32\\Drivers\\..\\.", windows).read());
+        ASSERT_EQUALS("c:/", PathIterator("C:\\Program Files\\", "..", windows).read());
+        ASSERT_EQUALS("//./", PathIterator("\\\\.\\C:\\", "../..", windows).read());
+        ASSERT_EQUALS("//./", PathIterator("\\\\.\\", "..\\..", windows).read());
+        ASSERT_EQUALS("//?/", PathIterator("\\\\?\\", "..\\..", windows).read());
+        /* The server and share should actually be considered part of the root and not be removed */
+        ASSERT_EQUALS("//", PathIterator("\\\\Server\\Share\\Directory", "../..\\../..", windows).read());
+    }
 };
 
 REGISTER_TEST(TestPathMatch)
diff --git a/test/testplatform.cpp b/test/testplatform.cpp
index 27ca7bb6292..ccb7d9b41a8 100644
--- a/test/testplatform.cpp
+++ b/test/testplatform.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,111 +16,222 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "errorlogger.h"
 #include "platform.h"
-#include "testsuite.h"
+#include "fixture.h"
+#include "standards.h"
 
-#include <tinyxml2.h>
+#include <string>
+
+#include "xml.h"
 
 
 class TestPlatform : public TestFixture {
 public:
-    TestPlatform() : TestFixture("TestPlatform") { }
+    TestPlatform() : TestFixture("TestPlatform") {}
 
 private:
-    void run() OVERRIDE {
+    void run() override {
         TEST_CASE(empty);
-        TEST_CASE(valid_config_native_1);
-        TEST_CASE(valid_config_native_2);
+        TEST_CASE(valid_config_win32a);
+        TEST_CASE(valid_config_unix64);
+        TEST_CASE(valid_config_win32w);
+        TEST_CASE(valid_config_unix32);
+        TEST_CASE(valid_config_win64);
+        // TODO: test native and unspecified
         TEST_CASE(valid_config_file_1);
         TEST_CASE(valid_config_file_2);
-        TEST_CASE(valid_config_file_3);
         TEST_CASE(valid_config_file_4);
         TEST_CASE(invalid_config_file_1);
-        // TEST_CASE(empty_elements); // TODO: Trac issue #8409
+        TEST_CASE(invalid_config_file_2);
+        TEST_CASE(empty_elements);
+        TEST_CASE(default_platform);
+        TEST_CASE(limitsDefines);
+        TEST_CASE(charMinMax);
+        TEST_CASE(no_root_node);
+        TEST_CASE(wrong_root_node);
     }
 
-    static bool readPlatform(cppcheck::Platform& platform, const char* xmldata) {
+    class PlatformTest final : public Platform
+    {
+        friend class TestPlatform;
+    };
+
+    static bool readPlatform(PlatformTest& platform, const char* xmldata) {
         tinyxml2::XMLDocument doc;
-        doc.Parse(xmldata);
-        return platform.loadFromXmlDocument(&doc);
+        return (doc.Parse(xmldata) == tinyxml2::XML_SUCCESS) && platform.loadFromXmlDocument(&doc);
     }
 
     void empty() const {
         // An empty platform file does not change values, only the type.
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n<platform/>";
-        cppcheck::Platform platform;
-        ASSERT(platform.platform(cppcheck::Platform::Win64));
-        ASSERT(readPlatform(platform, xmldata));
-        ASSERT_EQUALS(cppcheck::Platform::PlatformFile, platform.platformType);
-        ASSERT(!platform.isWindowsPlatform());
-        ASSERT_EQUALS(8, platform.char_bit);
-        ASSERT_EQUALS('\0', platform.defaultSign);
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n<platform/>";
+        PlatformTest platform;
+        // TODO: this should fail - platform files need to be complete
+        TODO_ASSERT(!readPlatform(platform, xmldata));
+    }
+
+    void valid_config_win32a() const {
+        // Verify if native Win32A platform is loaded correctly
+        Platform platform;
+        PLATFORM(platform, Platform::Type::Win32A);
+        ASSERT_EQUALS(Platform::Type::Win32A, platform.type);
+        ASSERT(platform.isWindows());
         ASSERT_EQUALS(1, platform.sizeof_bool);
         ASSERT_EQUALS(2, platform.sizeof_short);
         ASSERT_EQUALS(4, platform.sizeof_int);
         ASSERT_EQUALS(4, platform.sizeof_long);
         ASSERT_EQUALS(8, platform.sizeof_long_long);
+        ASSERT_EQUALS(4, platform.sizeof_float);
+        ASSERT_EQUALS(8, platform.sizeof_double);
+        ASSERT_EQUALS(8, platform.sizeof_long_double);
+        ASSERT_EQUALS(2, platform.sizeof_wchar_t);
+        ASSERT_EQUALS(4, platform.sizeof_size_t);
+        ASSERT_EQUALS(4, platform.sizeof_pointer);
+        ASSERT_EQUALS('s', platform.defaultSign);
+        ASSERT_EQUALS(8, platform.char_bit);
+        ASSERT_EQUALS(16, platform.short_bit);
+        ASSERT_EQUALS(32, platform.int_bit);
+        ASSERT_EQUALS(32, platform.long_bit);
+        ASSERT_EQUALS(64, platform.long_long_bit);
     }
 
-    void valid_config_native_1() {
-        // Verify if native Win32A platform is loaded correctly
-        cppcheck::Platform platform;
-        ASSERT(platform.platform(cppcheck::Platform::Win32A));
-        ASSERT_EQUALS(cppcheck::Platform::Win32A, platform.platformType);
-        ASSERT(platform.isWindowsPlatform());
-        ASSERT_EQUALS('\0', platform.defaultSign);
+    void valid_config_unix64() const {
+        // Verify if native Unix64 platform is loaded correctly
+        Platform platform;
+        PLATFORM(platform, Platform::Type::Unix64);
+        ASSERT_EQUALS(Platform::Type::Unix64, platform.type);
+        ASSERT(!platform.isWindows());
+        ASSERT_EQUALS(1, platform.sizeof_bool);
+        ASSERT_EQUALS(2, platform.sizeof_short);
+        ASSERT_EQUALS(4, platform.sizeof_int);
+        ASSERT_EQUALS(8, platform.sizeof_long);
+        ASSERT_EQUALS(8, platform.sizeof_long_long);
+        ASSERT_EQUALS(4, platform.sizeof_float);
+        ASSERT_EQUALS(8, platform.sizeof_double);
+        ASSERT_EQUALS(16, platform.sizeof_long_double);
+        ASSERT_EQUALS(4, platform.sizeof_wchar_t);
+        ASSERT_EQUALS(8, platform.sizeof_size_t);
+        ASSERT_EQUALS(8, platform.sizeof_pointer);
+        ASSERT_EQUALS('s', platform.defaultSign);
         ASSERT_EQUALS(8, platform.char_bit);
+        ASSERT_EQUALS(16, platform.short_bit);
+        ASSERT_EQUALS(32, platform.int_bit);
+        ASSERT_EQUALS(64, platform.long_bit);
+        ASSERT_EQUALS(64, platform.long_long_bit);
+        ASSERT_EQUALS(32, platform.float_bit);
+        ASSERT_EQUALS(64, platform.double_bit);
+        ASSERT_EQUALS(128, platform.long_double_bit);
+    }
+
+    void valid_config_win32w() const {
+        // Verify if native Win32W platform is loaded correctly
+        Platform platform;
+        PLATFORM(platform, Platform::Type::Win32W);
+        ASSERT_EQUALS(Platform::Type::Win32W, platform.type);
+        ASSERT(platform.isWindows());
         ASSERT_EQUALS(1, platform.sizeof_bool);
         ASSERT_EQUALS(2, platform.sizeof_short);
         ASSERT_EQUALS(4, platform.sizeof_int);
         ASSERT_EQUALS(4, platform.sizeof_long);
         ASSERT_EQUALS(8, platform.sizeof_long_long);
+        ASSERT_EQUALS(4, platform.sizeof_float);
+        ASSERT_EQUALS(8, platform.sizeof_double);
+        ASSERT_EQUALS(8, platform.sizeof_long_double);
+        ASSERT_EQUALS(2, platform.sizeof_wchar_t);
+        ASSERT_EQUALS(4, platform.sizeof_size_t);
+        ASSERT_EQUALS(4, platform.sizeof_pointer);
+        ASSERT_EQUALS('s', platform.defaultSign);
+        ASSERT_EQUALS(8, platform.char_bit);
         ASSERT_EQUALS(16, platform.short_bit);
         ASSERT_EQUALS(32, platform.int_bit);
         ASSERT_EQUALS(32, platform.long_bit);
         ASSERT_EQUALS(64, platform.long_long_bit);
+        ASSERT_EQUALS(32, platform.float_bit);
+        ASSERT_EQUALS(64, platform.double_bit);
+        ASSERT_EQUALS(64, platform.long_double_bit);
     }
 
-    void valid_config_native_2() {
-        // Verify if native Unix64 platform is loaded correctly
-        cppcheck::Platform platform;
-        ASSERT(platform.platform(cppcheck::Platform::Unix64));
-        ASSERT_EQUALS(cppcheck::Platform::Unix64, platform.platformType);
-        ASSERT(!platform.isWindowsPlatform());
-        ASSERT_EQUALS('\0', platform.defaultSign);
+    void valid_config_unix32() const {
+        // Verify if native Unix32 platform is loaded correctly
+        Platform platform;
+        PLATFORM(platform, Platform::Type::Unix32);
+        ASSERT_EQUALS(Platform::Type::Unix32, platform.type);
+        ASSERT(!platform.isWindows());
+        ASSERT_EQUALS(1, platform.sizeof_bool);
+        ASSERT_EQUALS(2, platform.sizeof_short);
+        ASSERT_EQUALS(4, platform.sizeof_int);
+        ASSERT_EQUALS(4, platform.sizeof_long);
+        ASSERT_EQUALS(8, platform.sizeof_long_long);
+        ASSERT_EQUALS(4, platform.sizeof_float);
+        ASSERT_EQUALS(8, platform.sizeof_double);
+        ASSERT_EQUALS(12, platform.sizeof_long_double);
+        ASSERT_EQUALS(4, platform.sizeof_wchar_t);
+        ASSERT_EQUALS(4, platform.sizeof_size_t);
+        ASSERT_EQUALS(4, platform.sizeof_pointer);
+        ASSERT_EQUALS('s', platform.defaultSign);
         ASSERT_EQUALS(8, platform.char_bit);
+        ASSERT_EQUALS(16, platform.short_bit);
+        ASSERT_EQUALS(32, platform.int_bit);
+        ASSERT_EQUALS(32, platform.long_bit);
+        ASSERT_EQUALS(64, platform.long_long_bit);
+        ASSERT_EQUALS(32, platform.float_bit);
+        ASSERT_EQUALS(64, platform.double_bit);
+        ASSERT_EQUALS(96, platform.long_double_bit);
+    }
+
+    void valid_config_win64() const {
+        // Verify if native Win64 platform is loaded correctly
+        Platform platform;
+        PLATFORM(platform, Platform::Type::Win64);
+        ASSERT_EQUALS(Platform::Type::Win64, platform.type);
+        ASSERT(platform.isWindows());
+        ASSERT_EQUALS(1, platform.sizeof_bool);
+        ASSERT_EQUALS(2, platform.sizeof_short);
         ASSERT_EQUALS(4, platform.sizeof_int);
+        ASSERT_EQUALS(4, platform.sizeof_long);
+        ASSERT_EQUALS(8, platform.sizeof_long_long);
+        ASSERT_EQUALS(4, platform.sizeof_float);
+        ASSERT_EQUALS(8, platform.sizeof_double);
+        ASSERT_EQUALS(8, platform.sizeof_long_double);
+        ASSERT_EQUALS(2, platform.sizeof_wchar_t);
+        ASSERT_EQUALS(8, platform.sizeof_size_t);
+        ASSERT_EQUALS(8, platform.sizeof_pointer);
+        ASSERT_EQUALS('s', platform.defaultSign);
+        ASSERT_EQUALS(8, platform.char_bit);
+        ASSERT_EQUALS(16, platform.short_bit);
         ASSERT_EQUALS(32, platform.int_bit);
-        ASSERT_EQUALS(8, platform.sizeof_long);
-        ASSERT_EQUALS(64, platform.long_bit);
+        ASSERT_EQUALS(32, platform.long_bit);
+        ASSERT_EQUALS(64, platform.long_long_bit);
+        ASSERT_EQUALS(32, platform.float_bit);
+        ASSERT_EQUALS(64, platform.double_bit);
+        ASSERT_EQUALS(64, platform.long_double_bit);
     }
 
-    void valid_config_file_1() {
+    void valid_config_file_1() const {
         // Valid platform configuration with all possible values specified.
         // Similar to the avr8 platform file.
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<platform>\n"
-                               "  <char_bit>8</char_bit>\n"
-                               "  <default-sign>unsigned</default-sign>\n"
-                               "  <sizeof>\n"
-                               "    <bool>1</bool>\n"
-                               "    <short>2</short>\n"
-                               "    <int>2</int>\n"
-                               "    <long>4</long>\n"
-                               "    <long-long>8</long-long>\n"
-                               "    <float>4</float>\n"
-                               "    <double>4</double>\n"
-                               "    <long-double>4</long-double>\n"
-                               "    <pointer>2</pointer>\n"
-                               "    <size_t>2</size_t>\n"
-                               "    <wchar_t>2</wchar_t>\n"
-                               "  </sizeof>\n"
-                               " </platform>";
-        cppcheck::Platform platform;
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<platform>\n"
+                                   "  <windows>false</windows>\n"
+                                   "  <char_bit>8</char_bit>\n"
+                                   "  <default-sign>unsigned</default-sign>\n"
+                                   "  <sizeof>\n"
+                                   "    <bool>1</bool>\n"
+                                   "    <short>2</short>\n"
+                                   "    <int>2</int>\n"
+                                   "    <long>4</long>\n"
+                                   "    <long-long>8</long-long>\n"
+                                   "    <float>4</float>\n"
+                                   "    <double>4</double>\n"
+                                   "    <long-double>4</long-double>\n"
+                                   "    <pointer>2</pointer>\n"
+                                   "    <size_t>2</size_t>\n"
+                                   "    <wchar_t>2</wchar_t>\n"
+                                   "  </sizeof>\n"
+                                   " </platform>";
+        PlatformTest platform;
         ASSERT(readPlatform(platform, xmldata));
-        ASSERT_EQUALS(platform.PlatformFile, platform.platformType);
-        ASSERT(!platform.isWindowsPlatform());
+        ASSERT_EQUALS(Platform::Type::File, platform.type);
+        ASSERT(!platform.isWindows());
         ASSERT_EQUALS(8, platform.char_bit);
         ASSERT_EQUALS('u', platform.defaultSign);
         ASSERT_EQUALS(1, platform.sizeof_bool);
@@ -140,31 +251,32 @@ class TestPlatform : public TestFixture {
         ASSERT_EQUALS(64, platform.long_long_bit);
     }
 
-    void valid_config_file_2() {
+    void valid_config_file_2() const {
         // Valid platform configuration with all possible values specified and
         // char_bit > 8.
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<platform>\n"
-                               "  <char_bit>20</char_bit>\n"
-                               "  <default-sign>signed</default-sign>\n"
-                               "  <sizeof>\n"
-                               "    <bool>1</bool>\n"
-                               "    <short>2</short>\n"
-                               "    <int>3</int>\n"
-                               "    <long>4</long>\n"
-                               "    <long-long>5</long-long>\n"
-                               "    <float>6</float>\n"
-                               "    <double>7</double>\n"
-                               "    <long-double>8</long-double>\n"
-                               "    <pointer>9</pointer>\n"
-                               "    <size_t>10</size_t>\n"
-                               "    <wchar_t>11</wchar_t>\n"
-                               "  </sizeof>\n"
-                               " </platform>";
-        cppcheck::Platform platform;
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<platform>\n"
+                                   "  <windows>true</windows>\n"
+                                   "  <char_bit>20</char_bit>\n"
+                                   "  <default-sign>signed</default-sign>\n"
+                                   "  <sizeof>\n"
+                                   "    <bool>1</bool>\n"
+                                   "    <short>2</short>\n"
+                                   "    <int>3</int>\n"
+                                   "    <long>4</long>\n"
+                                   "    <long-long>5</long-long>\n"
+                                   "    <float>6</float>\n"
+                                   "    <double>7</double>\n"
+                                   "    <long-double>8</long-double>\n"
+                                   "    <pointer>9</pointer>\n"
+                                   "    <size_t>10</size_t>\n"
+                                   "    <wchar_t>11</wchar_t>\n"
+                                   "  </sizeof>\n"
+                                   " </platform>";
+        PlatformTest platform;
         ASSERT(readPlatform(platform, xmldata));
-        ASSERT_EQUALS(platform.PlatformFile, platform.platformType);
-        ASSERT(!platform.isWindowsPlatform());
+        ASSERT_EQUALS(Platform::Type::File, platform.type);
+        ASSERT(platform.isWindows());
         ASSERT_EQUALS(20, platform.char_bit);
         ASSERT_EQUALS('s', platform.defaultSign);
         ASSERT_EQUALS(1, platform.sizeof_bool);
@@ -184,66 +296,59 @@ class TestPlatform : public TestFixture {
         ASSERT_EQUALS(100, platform.long_long_bit);
     }
 
-    void valid_config_file_3() {
-        // Valid platform configuration without any usable information.
+    void invalid_config_file_2() const {
+        // Invalid platform configuration without any usable information.
         // Similar like an empty file.
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<platform>\n"
-                               "  <char_bit1>8</char_bit1>\n"
-                               "  <default-sign1>unsigned</default-sign1>\n"
-                               "  <sizeof1>\n"
-                               "    <bool1>1</bool1>\n"
-                               "    <short1>2</short1>\n"
-                               "    <int1>3</int1>\n"
-                               "    <long1>4</long1>\n"
-                               "    <long-long1>5</long-long1>\n"
-                               "    <float1>6</float1>\n"
-                               "    <double1>7</double1>\n"
-                               "    <long-double1>8</long-double1>\n"
-                               "    <pointer1>9</pointer1>\n"
-                               "    <size_t1>10</size_t1>\n"
-                               "    <wchar_t1>11</wchar_t1>\n"
-                               "  </sizeof1>\n"
-                               " </platform>";
-        cppcheck::Platform platform;
-        ASSERT(platform.platform(cppcheck::Platform::Win64));
-        ASSERT(readPlatform(platform, xmldata));
-        ASSERT_EQUALS(platform.PlatformFile, platform.platformType);
-        ASSERT(!platform.isWindowsPlatform());
-        ASSERT_EQUALS(8, platform.char_bit);
-        ASSERT_EQUALS('\0', platform.defaultSign);
-        ASSERT_EQUALS(1, platform.sizeof_bool);
-        ASSERT_EQUALS(2, platform.sizeof_short);
-        ASSERT_EQUALS(4, platform.sizeof_int);
-        ASSERT_EQUALS(4, platform.sizeof_long);
-        ASSERT_EQUALS(8, platform.sizeof_long_long);
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<platform>\n"
+                                   "  <windows1>true</windows1>\n"
+                                   "  <char_bit1>8</char_bit1>\n"
+                                   "  <default-sign1>unsigned</default-sign1>\n"
+                                   "  <sizeof1>\n"
+                                   "    <bool1>1</bool1>\n"
+                                   "    <short1>2</short1>\n"
+                                   "    <int1>3</int1>\n"
+                                   "    <long1>4</long1>\n"
+                                   "    <long-long1>5</long-long1>\n"
+                                   "    <float1>6</float1>\n"
+                                   "    <double1>7</double1>\n"
+                                   "    <long-double1>8</long-double1>\n"
+                                   "    <pointer1>9</pointer1>\n"
+                                   "    <size_t1>10</size_t1>\n"
+                                   "    <wchar_t1>11</wchar_t1>\n"
+                                   "  </sizeof1>\n"
+                                   " </platform>";
+        PlatformTest platform;
+        // TODO: needs to fail - files need to be complete
+        TODO_ASSERT(!readPlatform(platform, xmldata));
     }
 
-    void valid_config_file_4() {
+    void valid_config_file_4() const {
         // Valid platform configuration with all possible values specified and
         // set to 0.
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<platform>\n"
-                               "  <char_bit>0</char_bit>\n"
-                               "  <default-sign>z</default-sign>\n"
-                               "  <sizeof>\n"
-                               "    <bool>0</bool>\n"
-                               "    <short>0</short>\n"
-                               "    <int>0</int>\n"
-                               "    <long>0</long>\n"
-                               "    <long-long>0</long-long>\n"
-                               "    <float>0</float>\n"
-                               "    <double>0</double>\n"
-                               "    <long-double>0</long-double>\n"
-                               "    <pointer>0</pointer>\n"
-                               "    <size_t>0</size_t>\n"
-                               "    <wchar_t>0</wchar_t>\n"
-                               "  </sizeof>\n"
-                               " </platform>";
-        cppcheck::Platform platform;
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<platform>\n"
+                                   "  <windows>true</windows>\n"
+                                   "  <char_bit>0</char_bit>\n"
+                                   "  <default-sign>z</default-sign>\n"
+                                   "  <sizeof>\n"
+                                   "    <bool>0</bool>\n"
+                                   "    <short>0</short>\n"
+                                   "    <int>0</int>\n"
+                                   "    <long>0</long>\n"
+                                   "    <long-long>0</long-long>\n"
+                                   "    <float>0</float>\n"
+                                   "    <double>0</double>\n"
+                                   "    <long-double>0</long-double>\n"
+                                   "    <pointer>0</pointer>\n"
+                                   "    <size_t>0</size_t>\n"
+                                   "    <wchar_t>0</wchar_t>\n"
+                                   "  </sizeof>\n"
+                                   " </platform>";
+        PlatformTest platform;
         ASSERT(readPlatform(platform, xmldata));
-        ASSERT_EQUALS(platform.PlatformFile, platform.platformType);
-        ASSERT(!platform.isWindowsPlatform());
+        ASSERT_EQUALS(Platform::Type::File, platform.type);
+        ASSERT(platform.isWindows());
         ASSERT_EQUALS(0, platform.char_bit);
         ASSERT_EQUALS('z', platform.defaultSign);
         ASSERT_EQUALS(0, platform.sizeof_bool);
@@ -263,66 +368,94 @@ class TestPlatform : public TestFixture {
         ASSERT_EQUALS(0, platform.long_long_bit);
     }
 
-    void invalid_config_file_1() {
+    void invalid_config_file_1() const {
         // Invalid XML file: mismatching elements "boolt" vs "bool".
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<platform>\n"
-                               "  <char_bit>8</char_bit>\n"
-                               "  <default-sign>unsigned</default-sign>\n"
-                               "  <sizeof>\n"
-                               "    <boolt>1</bool>\n"
-                               "    <short>2</short>\n"
-                               "    <int>2</int>\n"
-                               "    <long>4</long>\n"
-                               "    <long-long>8</long-long>\n"
-                               "    <float>4</float>\n"
-                               "    <double>4</double>\n"
-                               "    <long-double>4</long-double>\n"
-                               "    <pointer>2</pointer>\n"
-                               "    <size_t>2</size_t>\n"
-                               "    <wchar_t>2</wchar_t>\n"
-                               "  </sizeof>\n"
-                               " </platform>";
-        cppcheck::Platform platform;
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<platform>\n"
+                                   "  <windows>false</windows>\n"
+                                   "  <char_bit>8</char_bit>\n"
+                                   "  <default-sign>unsigned</default-sign>\n"
+                                   "  <sizeof>\n"
+                                   "    <boolt>1</bool>\n"
+                                   "    <short>2</short>\n"
+                                   "    <int>2</int>\n"
+                                   "    <long>4</long>\n"
+                                   "    <long-long>8</long-long>\n"
+                                   "    <float>4</float>\n"
+                                   "    <double>4</double>\n"
+                                   "    <long-double>4</long-double>\n"
+                                   "    <pointer>2</pointer>\n"
+                                   "    <size_t>2</size_t>\n"
+                                   "    <wchar_t>2</wchar_t>\n"
+                                   "  </sizeof>\n"
+                                   " </platform>";
+        PlatformTest platform;
         ASSERT(!readPlatform(platform, xmldata));
     }
 
-#if 0 // @TODO: Enable when Trac issue #8409 has been fixed
-    void empty_elements() {
+    void empty_elements() const {
         // Valid platform configuration without any usable information.
         // Similar like an empty file.
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<platform>\n"
-                               "  <char_bit></char_bit>\n"
-                               "  <default-sign></default-sign>\n"
-                               "  <sizeof>\n"
-                               "    <bool></bool>\n"
-                               "    <short></short>\n"
-                               "    <int></int>\n"
-                               "    <long></long>\n"
-                               "    <long-long></long-long>\n"
-                               "    <float></float>\n"
-                               "    <double></double>\n"
-                               "    <long-double></long-double>\n"
-                               "    <pointer></pointer>\n"
-                               "    <size_t></size_t>\n"
-                               "    <wchar_t></wchar_t>\n"
-                               "  </sizeof>\n"
-                               " </platform>";
-        cppcheck::Platform platform;
-        ASSERT(platform.platform(cppcheck::Platform::Win64));
-        ASSERT(readPlatform(platform, xmldata));
-        ASSERT_EQUALS(platform.PlatformFile, platform.platformType);
-        ASSERT(!platform.isWindowsPlatform());
-        ASSERT_EQUALS(8, platform.char_bit);
-        ASSERT_EQUALS('\0', platform.defaultSign);
-        ASSERT_EQUALS(1, platform.sizeof_bool);
-        ASSERT_EQUALS(2, platform.sizeof_short);
-        ASSERT_EQUALS(4, platform.sizeof_int);
-        ASSERT_EQUALS(4, platform.sizeof_long);
-        ASSERT_EQUALS(8, platform.sizeof_long_long);
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<platform>\n"
+                                   "  <windows></windows>\n"
+                                   "  <char_bit></char_bit>\n"
+                                   "  <default-sign></default-sign>\n"
+                                   "  <sizeof>\n"
+                                   "    <bool></bool>\n"
+                                   "    <short></short>\n"
+                                   "    <int></int>\n"
+                                   "    <long></long>\n"
+                                   "    <long-long></long-long>\n"
+                                   "    <float></float>\n"
+                                   "    <double></double>\n"
+                                   "    <long-double></long-double>\n"
+                                   "    <pointer></pointer>\n"
+                                   "    <size_t></size_t>\n"
+                                   "    <wchar_t></wchar_t>\n"
+                                   "  </sizeof>\n"
+                                   " </platform>";
+        PlatformTest platform;
+        ASSERT(!readPlatform(platform, xmldata));
+    }
+
+    void default_platform() const {
+        Platform platform;
+        ASSERT_EQUALS(Platform::Type::Native, platform.type);
+    }
+
+    void limitsDefines() const {
+        Platform platform;
+        ASSERT_EQUALS(true, platform.set(Platform::Unix64));
+        const std::string defs = "CHAR_BIT=8;SCHAR_MIN=-128;SCHAR_MAX=127;UCHAR_MAX=255;CHAR_MIN=0;CHAR_MAX=127;SHRT_MIN=-32768;SHRT_MAX=32767;USHRT_MAX=65535;INT_MIN=(-2147483647 - 1);INT_MAX=2147483647;UINT_MAX=4294967295;LONG_MIN=(-9223372036854775807L - 1L);LONG_MAX=9223372036854775807L;ULONG_MAX=18446744073709551615UL";
+        const std::string defs_c99 = "CHAR_BIT=8;SCHAR_MIN=-128;SCHAR_MAX=127;UCHAR_MAX=255;CHAR_MIN=0;CHAR_MAX=127;SHRT_MIN=-32768;SHRT_MAX=32767;USHRT_MAX=65535;INT_MIN=(-2147483647 - 1);INT_MAX=2147483647;UINT_MAX=4294967295;LONG_MIN=(-9223372036854775807L - 1L);LONG_MAX=9223372036854775807L;ULONG_MAX=18446744073709551615UL;LLONG_MIN=(-9223372036854775807LL - 1LL);LLONG_MAX=9223372036854775807LL;ULLONG_MAX=18446744073709551615ULL";
+        ASSERT_EQUALS(defs, platform.getLimitsDefines(Standards::cstd_t::C89));
+        ASSERT_EQUALS(defs_c99, platform.getLimitsDefines(Standards::cstd_t::C99));
+        ASSERT_EQUALS(defs_c99, platform.getLimitsDefines(Standards::cstd_t::CLatest));
+        ASSERT_EQUALS(defs, platform.getLimitsDefines(Standards::cppstd_t::CPP03));
+        ASSERT_EQUALS(defs_c99, platform.getLimitsDefines(Standards::cppstd_t::CPP11));
+        ASSERT_EQUALS(defs_c99, platform.getLimitsDefines(Standards::cppstd_t::CPPLatest));
+    }
+
+    void charMinMax() const {
+        Platform platform;
+        ASSERT_EQUALS(255, platform.unsignedCharMax());
+        ASSERT_EQUALS(127, platform.signedCharMax());
+        ASSERT_EQUALS(-128, platform.signedCharMin());
+    }
+
+    void no_root_node() const {
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>";
+        PlatformTest platform;
+        ASSERT(!readPlatform(platform, xmldata));
+    }
+
+    void wrong_root_node() const {
+        constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                   "<platforms/>";
+        PlatformTest platform;
+        ASSERT(!readPlatform(platform, xmldata));
     }
-#endif
 };
 
 REGISTER_TEST(TestPlatform)
diff --git a/test/testpostfixoperator.cpp b/test/testpostfixoperator.cpp
index 07614cd2909..9e95fabc949 100644
--- a/test/testpostfixoperator.cpp
+++ b/test/testpostfixoperator.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,44 +16,41 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include "checkpostfixoperator.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
 
+#include <cstddef>
 
 class TestPostfixOperator : public TestFixture {
 public:
-    TestPostfixOperator() : TestFixture("TestPostfixOperator") {
-    }
+    TestPostfixOperator() : TestFixture("TestPostfixOperator") {}
 
 private:
-    Settings settings;
-
-
-    void check(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
+    const Settings settings = settingsBuilder().severity(Severity::performance).build();
 
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check for postfix operators..
         CheckPostfixOperator checkPostfixOperator(&tokenizer, &settings, this);
         checkPostfixOperator.postfixOperator();
     }
 
-    void run() OVERRIDE {
-        settings.addEnabled("performance");
-
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(testsimple);
         TEST_CASE(testfor);
         TEST_CASE(testvolatile);
         TEST_CASE(testiterator);
         TEST_CASE(test2168);
+        TEST_CASE(pointerSimplest);
         TEST_CASE(pointer);   // #2321 - postincrement of pointer is OK
         TEST_CASE(testtemplate); // #4686
         TEST_CASE(testmember);
@@ -76,7 +73,7 @@ class TestPostfixOperator : public TestFixture {
               "    std::cout << k << std::endl;\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class K {};"
               "int main()\n"
@@ -87,7 +84,7 @@ class TestPostfixOperator : public TestFixture {
               "    std::cout << k << std::endl;\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (performance) Prefer prefix ++/-- operators for non-primitive types.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("struct K {};"
               "void foo()\n"
@@ -95,14 +92,14 @@ class TestPostfixOperator : public TestFixture {
               "    K k(0);\n"
               "    k++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Prefer prefix ++/-- operators for non-primitive types.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("struct K {};\n"
               "void foo(K& k)\n"
               "{\n"
               "    k++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Prefer prefix ++/-- operators for non-primitive types.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("union K {};"
               "void foo()\n"
@@ -110,7 +107,7 @@ class TestPostfixOperator : public TestFixture {
               "    K k(0);\n"
               "    k++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Prefer prefix ++/-- operators for non-primitive types.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("class K {};"
               "int main()\n"
@@ -123,7 +120,7 @@ class TestPostfixOperator : public TestFixture {
               "    std::cout << k << std::endl;\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (performance) Prefer prefix ++/-- operators for non-primitive types.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:9]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("class K {};"
               "int main()\n"
@@ -137,7 +134,7 @@ class TestPostfixOperator : public TestFixture {
               "    std::cout << k << std::endl;\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8]: (performance) Prefer prefix ++/-- operators for non-primitive types.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:5]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
 
         check("class K {};"
@@ -149,7 +146,7 @@ class TestPostfixOperator : public TestFixture {
               "    std::cout << k << std::endl;\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (performance) Prefer prefix ++/-- operators for non-primitive types.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("class K {};"
               "int main()\n"
@@ -160,7 +157,7 @@ class TestPostfixOperator : public TestFixture {
               "    std::cout << k << std::endl;\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class K {};"
               "int main()\n"
@@ -171,7 +168,7 @@ class TestPostfixOperator : public TestFixture {
               "    std::cout << k << std::endl;\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #9042
         check("template <class T>\n"
@@ -182,7 +179,7 @@ class TestPostfixOperator : public TestFixture {
               "template <class T>\n"
               "class s {};\n"
               "using BOOL = char;");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testfor() {
@@ -193,7 +190,7 @@ class TestPostfixOperator : public TestFixture {
               "    }\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class K {};\n"
               "int main()\n"
@@ -203,7 +200,7 @@ class TestPostfixOperator : public TestFixture {
               "    }\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Prefer prefix ++/-- operators for non-primitive types.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:28]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("class K {};\n"
               "int main()\n"
@@ -213,7 +210,7 @@ class TestPostfixOperator : public TestFixture {
               "    }\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class K {};\n"
               "int main()\n"
@@ -223,7 +220,7 @@ class TestPostfixOperator : public TestFixture {
               "    }\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Prefer prefix ++/-- operators for non-primitive types.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:27]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("class K {};\n"
               "int main(int argc, char *argv[])\n"
@@ -233,9 +230,12 @@ class TestPostfixOperator : public TestFixture {
               "    }\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
-
+        ASSERT_EQUALS("", errout_str());
 
+        check("void f(const std::string &s) {\n" // #7731
+              "    for (std::string::const_iterator i = s.begin(), r = s.end() - 1; i != r; r--) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:78]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
     }
 
     void testvolatile() {
@@ -248,7 +248,7 @@ class TestPostfixOperator : public TestFixture {
               "    std::cout << k << std::endl;\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (performance) Prefer prefix ++/-- operators for non-primitive types.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:5]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
     }
 
     void testiterator() {
@@ -263,7 +263,7 @@ class TestPostfixOperator : public TestFixture {
               "    v.clear();\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (performance) Prefer prefix ++/-- operators for non-primitive types.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:64]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("int main() {\n"
               "    std::vector<int> v;\n"
@@ -277,7 +277,7 @@ class TestPostfixOperator : public TestFixture {
               "    }\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:9]: (performance) Prefer prefix ++/-- operators for non-primitive types.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:8]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("int main() {\n"
               "    std::vector<int> v;\n"
@@ -290,7 +290,7 @@ class TestPostfixOperator : public TestFixture {
               "    }\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8]: (performance) Prefer prefix ++/-- operators for non-primitive types.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:8]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("int main() {\n"
               "    std::vector<int> v;\n"
@@ -304,21 +304,32 @@ class TestPostfixOperator : public TestFixture {
               "    }\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:9]: (performance) Prefer prefix ++/-- operators for non-primitive types.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:8]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
     }
 
     void test2168() {
-        check("--> declare allocator lock here\n"
-              "int main(){}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_THROW_INTERNAL(check("--> declare allocator lock here\n"
+                                    "int main(){}"),
+                              AST);
+    }
+
+    void pointerSimplest() {
+        check("void f(int* p){\n"
+              "    p++;\n"
+              "    std::cout << *p;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void pointer() {
         check("static struct class * ab;\n"
               "int * p;\n"
-              "p++;\n");
-        ASSERT_EQUALS("", errout.str());
+              "\n"
+              "void f() {\n"
+              "    p++;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testtemplate() {
@@ -326,7 +337,7 @@ class TestPostfixOperator : public TestFixture {
               "    std::vector<FilterConfigCacheEntry>::iterator aIter(aImport.begin());\n"
               "    aIter++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Prefer prefix ++/-- operators for non-primitive types.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
     }
 
     void testmember() {
@@ -335,14 +346,14 @@ class TestPostfixOperator : public TestFixture {
               "    B b;\n"
               "    b.a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Prefer prefix ++/-- operators for non-primitive types.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("bool foo() {\n"
               "    class A {}; class B {A a;};\n"
               "    B b;\n"
               "    foo(b.a++);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testcomma() {
@@ -351,7 +362,7 @@ class TestPostfixOperator : public TestFixture {
               "    A a;\n"
               "    i++, a++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Prefer prefix ++/-- operators for non-primitive types.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:10]: (performance) Prefer prefix ++/-- operators for non-primitive types. [postfixOperator]\n", errout_str());
 
         check("bool foo(int i) {\n"
               "    class A {};\n"
@@ -359,7 +370,7 @@ class TestPostfixOperator : public TestFixture {
               "    foo(i, a++);\n"
               "    foo(a++, i);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testauto() { // #8350
@@ -371,7 +382,7 @@ class TestPostfixOperator : public TestFixture {
               "    }\n"
               "    return a;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 };
 
diff --git a/test/testpreprocessor.cpp b/test/testpreprocessor.cpp
index 564b07588ff..d072ebbf2e3 100644
--- a/test/testpreprocessor.cpp
+++ b/test/testpreprocessor.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,56 +20,140 @@
 // The preprocessor that Cppcheck uses is a bit special. Instead of generating
 // the code for a known configuration, it generates the code for each configuration.
 
+#include "errortypes.h"
+#include "library.h"
+#include "path.h"
 #include "platform.h"
 #include "preprocessor.h"
 #include "settings.h"
-#include "testsuite.h"
+#include "standards.h"
+#include "suppressions.h"
+#include "tokenlist.h"
+#include "fixture.h"
+#include "helpers.h"
 
-#include <simplecpp.h>
 #include <cstring>
 #include <list>
 #include <map>
 #include <set>
+#include <stdexcept>
 #include <string>
+#include <utility>
 #include <vector>
 
+#include <simplecpp.h>
+
 class ErrorLogger;
 
 class TestPreprocessor : public TestFixture {
 public:
-    TestPreprocessor()
-        : TestFixture("TestPreprocessor")
-        , preprocessor0(settings0, this) {
-        settings0.addEnabled("information");
+    TestPreprocessor() : TestFixture("TestPreprocessor") {}
+
+private:
+    template<size_t size>
+    std::string expandMacros(const char (&code)[size], ErrorLogger &errorLogger) const {
+        simplecpp::OutputList outputList;
+        std::vector<std::string> files;
+        simplecpp::TokenList tokens1 = simplecpp::TokenList(code, files, "file.cpp", &outputList);
+        Preprocessor p(tokens1, settingsDefault, errorLogger, Path::identify(tokens1.getFiles()[0], false));
+        ASSERT(p.loadFiles(files));
+        simplecpp::TokenList tokens2 = p.preprocess("", files, outputList);
+        (void)p.reportOutput(outputList, true);
+        return tokens2.stringify();
     }
 
-    class OurPreprocessor : public Preprocessor {
-    public:
+    template<size_t size>
+    void preprocess(const char (&code)[size], std::vector<std::string> &files, const std::string& file0, TokenList& tokenlist, const simplecpp::DUI& dui)
+    {
+        if (!files.empty())
+            throw std::runtime_error("file list not empty");
 
-        static std::string expandMacros(const char code[], ErrorLogger *errorLogger = nullptr) {
-            std::istringstream istr(code);
-            simplecpp::OutputList outputList;
-            std::vector<std::string> files;
-            const simplecpp::TokenList tokens1 = simplecpp::TokenList(istr, files, "file.cpp", &outputList);
-            std::map<std::string, simplecpp::TokenList*> filedata;
-            simplecpp::TokenList tokens2(files);
-            simplecpp::preprocess(tokens2, tokens1, files, filedata, simplecpp::DUI(), &outputList);
-
-            if (errorLogger) {
-                static Settings settings;
-                Preprocessor p(settings, errorLogger);
-                p.reportOutput(outputList, true);
-            }
+        if (tokenlist.front())
+            throw std::runtime_error("token list not empty");
+
+        simplecpp::OutputList outputList;
+        const simplecpp::TokenList tokens1(code, files, file0, &outputList);
+
+        // Preprocess..
+        simplecpp::TokenList tokens2(files);
+        simplecpp::FileDataCache cache;
+        simplecpp::preprocess(tokens2, tokens1, files, cache, dui, &outputList);
+        Preprocessor preprocessor(tokens2, settingsDefault, *this, Standards::Language::C);
+        (void)preprocessor.reportOutput(outputList, true);
+
+        // Tokenizer..
+        tokenlist.createTokens(std::move(tokens2));
+    }
+
+    template<size_t size>
+    std::vector<RemarkComment> getRemarkComments(const char (&code)[size], ErrorLogger& errorLogger) const
+    {
+        std::vector<std::string> files;
+        simplecpp::TokenList tokens1(code, files, "test.cpp");
+
+        const Preprocessor preprocessor(tokens1, settingsDefault, errorLogger, Path::identify(tokens1.getFiles()[0], false));
+        return preprocessor.getRemarkComments();
+    }
+
+    static std::string getcodeforcfg(const Settings& settings, ErrorLogger& errorlogger, const char* code, std::size_t size, const std::string &cfg, const std::string &filename, SuppressionList *inlineSuppression = nullptr)
+    {
+        std::map<std::string, std::string> cfgcode = getcode(settings, errorlogger, code, size, std::set<std::string>{cfg}, filename, inlineSuppression);
+        const auto it = cfgcode.find(cfg);
+        if (it == cfgcode.end())
+            return "";
+        return it->second;
+    }
+
+    template<size_t size>
+    static std::string getcodeforcfg(const Settings& settings, ErrorLogger& errorlogger, const char (&code)[size], const std::string &cfg, const std::string &filename, SuppressionList *inlineSuppression = nullptr)
+    {
+        return getcodeforcfg(settings, errorlogger, code, size-1, cfg, filename, inlineSuppression);
+    }
+
+    template<size_t size>
+    static std::map<std::string, std::string> getcode(const Settings& settings, ErrorLogger& errorlogger, const char (&code)[size], const std::string &filename = "file.c")
+    {
+        return getcode(settings, errorlogger, code, size-1, {}, filename, nullptr);
+    }
+
+    static std::map<std::string, std::string> getcode(const Settings& settings, ErrorLogger& errorlogger, const char* code, std::size_t size, std::set<std::string> cfgs, const std::string &filename, SuppressionList *inlineSuppression)
+    {
+        simplecpp::OutputList outputList;
+        std::vector<std::string> files;
+
+        simplecpp::TokenList tokens({code, size}, files, Path::simplifyPath(filename), &outputList);
+
+        // TODO: we should be using the actual Preprocessor implementation
+        Preprocessor preprocessor(tokens, settings, errorlogger, Path::identify(tokens.getFiles()[0], false));
 
-            return tokens2.stringify();
+        // TODO: should be possible without a Preprocessor instance
+        if (preprocessor.reportOutput(outputList, true))
+            return {};
+
+        if (inlineSuppression)
+            preprocessor.inlineSuppressions(*inlineSuppression);
+        preprocessor.removeComments();
+        preprocessor.simplifyPragmaAsm();
+
+        std::map<std::string, std::string> cfgcode;
+        if (cfgs.empty())
+            cfgs = preprocessor.getConfigs();
+        for (const std::string & config : cfgs) {
+            try {
+                const bool writeLocations = (strstr(code, "#file") != nullptr) || (strstr(code, "#include") != nullptr);
+                cfgcode[config] = preprocessor.getcode(config, files, writeLocations);
+            } catch (const simplecpp::Output &) {
+                cfgcode[config] = "";
+            }
         }
-    };
 
-private:
-    Settings settings0;
-    Preprocessor preprocessor0;
+        return cfgcode;
+    }
+
+    const Settings settings0 = settingsBuilder().severity(Severity::information).build();
 
-    void run() OVERRIDE {
+    void run() override {
+        mNewTemplate = true;
 
         // The bug that started the whole work with the new preprocessor
         TEST_CASE(Bug2190219);
@@ -81,6 +165,7 @@ class TestPreprocessor : public TestFixture {
         TEST_CASE(error5);
         TEST_CASE(error6);
         TEST_CASE(error7);
+        TEST_CASE(error8); // #10170 -> previous #if configurations
 
         TEST_CASE(setPlatformInfo);
 
@@ -194,8 +279,15 @@ class TestPreprocessor : public TestFixture {
         TEST_CASE(invalid_define_1); // #2605 - hang for: '#define ='
         TEST_CASE(invalid_define_2); // #4036 - hang for: '#define () {(int f(x) }'
 
-        // inline suppression, missingInclude
-        TEST_CASE(inline_suppression_for_missing_include);
+        // inline suppression, missingInclude/missingIncludeSystem
+        TEST_CASE(inline_suppressions);
+        TEST_CASE(inline_suppressions_not_next_line);
+
+        // remark comment
+        TEST_CASE(remarkComment1);
+        TEST_CASE(remarkComment2);
+        TEST_CASE(remarkComment3);
+        TEST_CASE(remarkComment4);
 
         // Using -D to predefine symbols
         TEST_CASE(predefine1);
@@ -203,6 +295,10 @@ class TestPreprocessor : public TestFixture {
         TEST_CASE(predefine3);
         TEST_CASE(predefine4);
         TEST_CASE(predefine5);  // automatically define __cplusplus
+        TEST_CASE(predefine6);  // automatically define __STDC_VERSION__
+
+
+        TEST_CASE(strictAnsi);
 
         TEST_CASE(invalidElIf); // #2942 segfault
 
@@ -220,6 +316,18 @@ class TestPreprocessor : public TestFixture {
         TEST_CASE(getConfigs7e);
         TEST_CASE(getConfigs8);  // #if A==1  => cfg: A=1
         TEST_CASE(getConfigs10); // #5139
+        TEST_CASE(getConfigs11); // #9832 - include guards
+        TEST_CASE(getConfigs12); // #14222
+        TEST_CASE(getConfigs13); // #14222
+        TEST_CASE(getConfigs_gte); // #1059
+        TEST_CASE(getConfigs_lte); // #1059
+        TEST_CASE(getConfigs_gt); // #1059
+        TEST_CASE(getConfigs_lt); // #1059
+        TEST_CASE(getConfigs_eq_compound); // #1059
+        TEST_CASE(getConfigs_gte_compound); // #1059
+        TEST_CASE(getConfigs_lte_compound); // #1059
+        TEST_CASE(getConfigs_gt_compound); // #1059
+        TEST_CASE(getConfigs_lt_compound); // #1059
         TEST_CASE(getConfigsError);
 
         TEST_CASE(getConfigsD1);
@@ -232,8 +340,8 @@ class TestPreprocessor : public TestFixture {
         TEST_CASE(getConfigsU6);
         TEST_CASE(getConfigsU7);
 
-        TEST_CASE(validateCfg1);
-        TEST_CASE(validateCfg2);
+        TEST_CASE(getConfigsAndCodeIssue14317);
+        TEST_CASE(getConfigsMostGeneralConfigIssue14317);
 
         TEST_CASE(if_sizeof);
 
@@ -243,50 +351,66 @@ class TestPreprocessor : public TestFixture {
 
         TEST_CASE(wrongPathOnErrorDirective);
 
-        TEST_CASE(testDirectiveIncludeTypes);
-        TEST_CASE(testDirectiveIncludeLocations);
-        TEST_CASE(testDirectiveIncludeComments);
-    }
+        TEST_CASE(testMissingInclude);
+        TEST_CASE(testMissingInclude2);
+        TEST_CASE(testMissingInclude3);
+        TEST_CASE(testMissingInclude4);
+        TEST_CASE(testMissingInclude5);
+        TEST_CASE(testMissingInclude6);
+        TEST_CASE(testMissingSystemInclude);
+        TEST_CASE(testMissingSystemInclude2);
+        TEST_CASE(testMissingSystemInclude3);
+        TEST_CASE(testMissingSystemInclude4);
+        TEST_CASE(testMissingSystemInclude5);
+        TEST_CASE(testMissingIncludeMixed);
+        TEST_CASE(testMissingIncludeCheckConfig);
 
-    void preprocess(const char* code, std::map<std::string, std::string>& actual, const char filename[] = "file.c") {
-        errout.str("");
-        std::istringstream istr(code);
-        simplecpp::OutputList outputList;
-        std::vector<std::string> files;
-        simplecpp::TokenList tokens(istr, files, filename, &outputList);
-        tokens.removeComments();
-        preprocessor0.simplifyPragmaAsm(&tokens);
-        const std::set<std::string> configs(preprocessor0.getConfigs(tokens));
-        preprocessor0.setDirectives(tokens);
-        for (const std::string & config : configs) {
-            try {
-                const std::string &cfgcode = preprocessor0.getcode(tokens, config, files, std::string(code).find("#file") != std::string::npos);
-                actual[config] = cfgcode;
-            } catch (const simplecpp::Output &) {
-                actual[config] = "";
-            } catch (...) {
-            }
-        }
+        TEST_CASE(hasInclude);
+
+        TEST_CASE(limitsDefines);
+
+        TEST_CASE(hashCalculation);
+
+        TEST_CASE(standard);
+
+        TEST_CASE(writeLocations);
+
+        TEST_CASE(pragmaAsm);
     }
 
-    std::string getConfigsStr(const char filedata[], const char *arg = nullptr) {
+    template<size_t size>
+    std::string getConfigsStr(const char (&code)[size], const char *arg = nullptr, const char *library = nullptr) {
         Settings settings;
         if (arg && std::strncmp(arg,"-D",2)==0)
             settings.userDefines = arg + 2;
         if (arg && std::strncmp(arg,"-U",2)==0)
             settings.userUndefs.insert(arg+2);
-        Preprocessor preprocessor(settings, this);
+        if (library)
+            ASSERT(settings.library.load("", library, false).errorcode == Library::ErrorCode::OK);
         std::vector<std::string> files;
-        std::istringstream istr(filedata);
-        simplecpp::TokenList tokens(istr,files);
-        tokens.removeComments();
-        const std::set<std::string> configs = preprocessor.getConfigs(tokens);
+        simplecpp::OutputList outputList;
+        simplecpp::TokenList tokens(code,files,"test.c",&outputList);
+        Preprocessor preprocessor(tokens, settings, *this, Standards::Language::C); // TODO: do we need to consider #file?
+        ASSERT(preprocessor.loadFiles(files));
+        ASSERT(!preprocessor.reportOutput(outputList, true));
+        preprocessor.removeComments();
+        const std::set<std::string> configs = preprocessor.getConfigs();
         std::string ret;
         for (const std::string & config : configs)
             ret += config + '\n';
         return ret;
     }
 
+    template<size_t size>
+    std::size_t getHash(const char (&code)[size]) {
+        std::vector<std::string> files;
+        simplecpp::TokenList tokens(code,files,"test.c");
+        Preprocessor preprocessor(tokens, settingsDefault, *this, Standards::Language::C); // TODO: do we need to consider #file?
+        ASSERT(preprocessor.loadFiles(files));
+        preprocessor.removeComments();
+        return preprocessor.calculateHash("");
+    }
+
     void Bug2190219() {
         const char filedata[] = "#ifdef __cplusplus\n"
                                 "cpp\n"
@@ -296,23 +420,21 @@ class TestPreprocessor : public TestFixture {
 
         {
             // Preprocess => actual result..
-            std::map<std::string, std::string> actual;
-            preprocess(filedata, actual, "file.cpp");
+            const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata, "file.cpp");
 
             // Compare results..
             ASSERT_EQUALS(1U, actual.size());
-            ASSERT_EQUALS("\ncpp", actual[""]);
+            ASSERT_EQUALS("\ncpp", actual.at(""));
         }
 
         {
             // Ticket #7102 - skip __cplusplus in C code
             // Preprocess => actual result..
-            std::map<std::string, std::string> actual;
-            preprocess(filedata, actual, "file.c");
+            const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata, "file.c");
 
             // Compare results..
             ASSERT_EQUALS(1U, actual.size());
-            ASSERT_EQUALS("\n\n\nc", actual[""]);
+            ASSERT_EQUALS("\n\n\nc", actual.at(""));
         }
     }
 
@@ -322,7 +444,7 @@ class TestPreprocessor : public TestFixture {
                                 "#else\n"
                                 "#error abcd\n"
                                 "#endif\n";
-        ASSERT_EQUALS("\nA\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nA=A\n", getConfigsStr(filedata));
     }
 
     void error2() {
@@ -338,49 +460,39 @@ class TestPreprocessor : public TestFixture {
     }
 
     void error3() {
-        errout.str("");
-        Settings settings;
-        settings.userDefines = "__cplusplus";
-        Preprocessor preprocessor(settings, this);
-        const std::string code("#error hello world!\n");
-        preprocessor.getcode(code, "X", "test.c");
-        ASSERT_EQUALS("[test.c:1]: (error) #error hello world!\n", errout.str());
+        const auto settings = dinit(Settings, $.userDefines = "__cplusplus");
+        const char code[] = "#error hello world!\n";
+        (void)getcodeforcfg(settings, *this, code, "X", "test.c");
+        ASSERT_EQUALS("[test.c:1:2]: (error) #error hello world! [preprocessorErrorDirective]\n", errout_str());
     }
 
     // Ticket #2919 - wrong filename reported for #error
     void error4() {
         // In included file
         {
-            errout.str("");
-            Settings settings;
-            settings.userDefines = "TEST";
-            Preprocessor preprocessor(settings, this);
-            const std::string code("#file \"ab.h\"\n#error hello world!\n#endfile");
-            preprocessor.getcode(code, "TEST", "test.c");
-            ASSERT_EQUALS("[ab.h:1]: (error) #error hello world!\n", errout.str());
+            const auto settings = dinit(Settings, $.userDefines = "TEST");
+            const char code[] = "#file \"ab.h\"\n#error hello world!\n#endfile";
+            (void)getcodeforcfg(settings, *this, code, "TEST", "test.c");
+            ASSERT_EQUALS("[ab.h:1:2]: (error) #error hello world! [preprocessorErrorDirective]\n", errout_str());
         }
 
         // After including a file
         {
-            errout.str("");
-            Settings settings;
-            settings.userDefines = "TEST";
-            Preprocessor preprocessor(settings, this);
-            const std::string code("#file \"ab.h\"\n\n#endfile\n#error aaa");
-            preprocessor.getcode(code, "TEST", "test.c");
-            ASSERT_EQUALS("[test.c:2]: (error) #error aaa\n", errout.str());
+            const auto settings = dinit(Settings, $.userDefines = "TEST");
+            const char code[] = "#file \"ab.h\"\n\n#endfile\n#error aaa";
+            (void)getcodeforcfg(settings, *this, code, "TEST", "test.c");
+            ASSERT_EQUALS("[test.c:2:2]: (error) #error aaa [preprocessorErrorDirective]\n", errout_str());
         }
     }
 
     void error5() {
-        errout.str("");
-        Settings settings;
-        settings.userDefines = "FOO";
-        settings.force = true; // No message if --force is given
-        Preprocessor preprocessor(settings, this);
-        const std::string code("#error hello world!\n");
-        preprocessor.getcode(code, "X", "test.c");
-        ASSERT_EQUALS("", errout.str());
+        // No message if --force is given
+        const auto settings = dinit(Settings,
+                                    $.userDefines = "TEST",
+                                        $.force = true);
+        const char code[] = "#error hello world!\n";
+        (void)getcodeforcfg(settings, *this, code, "X", "test.c");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void error6() {
@@ -392,7 +504,7 @@ class TestPreprocessor : public TestFixture {
                                  "#else\n"
                                  "#error 2\n"
                                  "#endif\n";
-        ASSERT_EQUALS("\nA\nA;B\nB\n", getConfigsStr(filedata1));
+        ASSERT_EQUALS("\nA=A\nA=A;B=B\nB=B\n", getConfigsStr(filedata1));
 
         const char filedata2[] = "#ifndef A\n"
                                  "#error 1\n"
@@ -424,32 +536,49 @@ class TestPreprocessor : public TestFixture {
                                 "#else\n"
                                 "#error \"2\"\n"
                                 "#endif\n";
-        ASSERT_EQUALS("\nB\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nB=B\n", getConfigsStr(filedata));
     }
 
-    void setPlatformInfo() {
-        Settings settings;
-        Preprocessor preprocessor(settings, this);
+    void error8() {
+        const char filedata[] = "#ifdef A\n"
+                                "#ifdef B\n"
+                                "#endif\n"
+                                "#else\n"
+                                "#endif\n"
+                                "\n"
+                                "#ifndef C\n"
+                                "#error aa\n"
+                                "#endif";
+        ASSERT_EQUALS("A=A;B=B;C\nA=A;C\nC\n", getConfigsStr(filedata));
+    }
 
+    void setPlatformInfo() {
         // read code with simplecpp..
         const char filedata[] = "#if sizeof(long) == 4\n"
                                 "1\n"
                                 "#else\n"
                                 "2\n"
                                 "#endif\n";
-        std::istringstream istr(filedata);
-        std::vector<std::string> files;
-        simplecpp::TokenList tokens(istr, files, "test.c");
 
         // preprocess code with unix32 platform..
-        settings.platform(Settings::PlatformType::Unix32);
-        preprocessor.setPlatformInfo(&tokens);
-        ASSERT_EQUALS("\n1", preprocessor.getcode(tokens, "", files, false));
+        {
+            std::vector<std::string> files;
+            simplecpp::TokenList tokens(filedata, files, "test.c");
+            const Settings settings = settingsBuilder().platform(Platform::Type::Unix32).build();
+            Preprocessor preprocessor(tokens, settings, *this, Path::identify(tokens.getFiles()[0], false));
+            preprocessor.setPlatformInfo();
+            ASSERT_EQUALS("\n1", preprocessor.getcode("", files, false));
+        }
 
         // preprocess code with unix64 platform..
-        settings.platform(Settings::PlatformType::Unix64);
-        preprocessor.setPlatformInfo(&tokens);
-        ASSERT_EQUALS("\n\n\n2", preprocessor.getcode(tokens, "", files, false));
+        {
+            std::vector<std::string> files;
+            simplecpp::TokenList tokens(filedata, files, "test.c");
+            const Settings settings = settingsBuilder().platform(Platform::Type::Unix64).build();
+            Preprocessor preprocessor(tokens, settings, *this, Path::identify(tokens.getFiles()[0], false));
+            preprocessor.setPlatformInfo();
+            ASSERT_EQUALS("\n\n\n2", preprocessor.getcode("", files, false));
+        }
     }
 
     void includeguard1() {
@@ -461,7 +590,7 @@ class TestPreprocessor : public TestFixture {
                                 "#endfile\n"
                                 "#ifdef ABC\n"
                                 "#endif";
-        ASSERT_EQUALS("\nABC\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nABC=ABC\n", getConfigsStr(filedata));
     }
 
     void includeguard2() {
@@ -472,7 +601,7 @@ class TestPreprocessor : public TestFixture {
                                 "\n"
                                 "#endif\n"
                                 "#endfile\n";
-        ASSERT_EQUALS("\nABC\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nABC=ABC\n", getConfigsStr(filedata));
     }
 
 
@@ -486,13 +615,12 @@ class TestPreprocessor : public TestFixture {
                                 "int main() {}\n";
 
         // Preprocess => actual result..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
         // Expected configurations: "" and "ABC"
         ASSERT_EQUALS(2, actual.size());
-        ASSERT_EQUALS("\n\n\nint main ( ) { }", actual[""]);
-        ASSERT_EQUALS("\n#line 1 \"abc.h\"\nclass A { } ;\n#line 4 \"file.c\"\n int main ( ) { }", actual["ABC"]);
+        ASSERT_EQUALS("\n\n\nint main ( ) { }", actual.at(""));
+        ASSERT_EQUALS("\n#line 1 \"abc.h\"\nclass A { } ;\n#line 4 \"file.c\"\n int main ( ) { }", actual.at("ABC=ABC"));
     }
 
     void if0() {
@@ -529,7 +657,7 @@ class TestPreprocessor : public TestFixture {
                                     "#else\n"
                                     "GHI\n"
                                     "#endif\n";
-            ASSERT_EQUALS("\nDEF1\nDEF2\n", getConfigsStr(filedata));
+            ASSERT_EQUALS("\nDEF1=DEF1\nDEF2=DEF2\n", getConfigsStr(filedata));
         }
     }
 
@@ -539,7 +667,7 @@ class TestPreprocessor : public TestFixture {
                                 "#else\n"
                                 "    B\n"
                                 "#endif\n";
-        TODO_ASSERT_EQUALS("\nLIBVER=101\n", "\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nLIBVER=101\n", getConfigsStr(filedata));
     }
 
     void if_cond2() {
@@ -549,7 +677,7 @@ class TestPreprocessor : public TestFixture {
                                 "#if defined(A) && defined(B)\n"
                                 "ab\n"
                                 "#endif\n";
-        ASSERT_EQUALS("\nA\nA;B\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nA=A\nA=A;B=B\n", getConfigsStr(filedata));
 
         if_cond2b();
         if_cond2c();
@@ -566,7 +694,7 @@ class TestPreprocessor : public TestFixture {
                                 "#else\n"
                                 "a\n"
                                 "#endif\n";
-        TODO_ASSERT_EQUALS("\nA;B\n", "\nA\nB\n", getConfigsStr(filedata));
+        TODO_ASSERT_EQUALS("\nA;B=B\n", "\nA\nB=B\n", getConfigsStr(filedata));
     }
 
     void if_cond2c() {
@@ -580,7 +708,7 @@ class TestPreprocessor : public TestFixture {
                                 "#else\n"
                                 "a\n"
                                 "#endif\n";
-        TODO_ASSERT_EQUALS("\nA\nA;B\n", "\nA\nB\n", getConfigsStr(filedata));
+        TODO_ASSERT_EQUALS("\nA\nA;B=B\n", "\nA\nB=B\n", getConfigsStr(filedata));
     }
 
     void if_cond2d() {
@@ -599,7 +727,7 @@ class TestPreprocessor : public TestFixture {
                                 "!b\n"
                                 "#endif\n"
                                 "#endif\n";
-        ASSERT_EQUALS("\nA\nA;B\nB\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nA\nA;B=B\nB=B\n", getConfigsStr(filedata));
     }
 
     void if_cond2e() {
@@ -618,7 +746,7 @@ class TestPreprocessor : public TestFixture {
                                 "abc\n"
                                 "#endif\n"
                                 "#endif\n";
-        ASSERT_EQUALS("\nA\nA;B;C\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nA=A\nA=A;B=B;C=C\n", getConfigsStr(filedata));
     }
 
     void if_cond4() {
@@ -639,7 +767,7 @@ class TestPreprocessor : public TestFixture {
                                     "#endif\n"
                                     "}\n"
                                     "#endif\n";
-            ASSERT_EQUALS("\nA\nA;B\n", getConfigsStr(filedata));
+            ASSERT_EQUALS("\nA\nA;B=B\n", getConfigsStr(filedata));
         }
 
         {
@@ -674,20 +802,20 @@ class TestPreprocessor : public TestFixture {
                                 "#if defined(B) && defined(A)\n"
                                 "ef\n"
                                 "#endif\n";
-        ASSERT_EQUALS("\nA;B\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nA=A;B=B\n", getConfigsStr(filedata));
     }
 
     void if_cond6() {
         const char filedata[] = "\n"
                                 "#if defined(A) && defined(B))\n"
                                 "#endif\n";
-        ASSERT_EQUALS("\nA;B\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nA=A;B=B\n", getConfigsStr(filedata));
     }
 
     void if_cond8() {
         const char filedata[] = "#if defined(A) + defined(B) + defined(C) != 1\n"
                                 "#endif\n";
-        TODO_ASSERT_EQUALS("\nA\n", "\nA;B;C\n", getConfigsStr(filedata));
+        TODO_ASSERT_EQUALS("\nA=A\n", "\nA=A;B=B;C=C\n", getConfigsStr(filedata));
     }
 
 
@@ -705,8 +833,7 @@ class TestPreprocessor : public TestFixture {
                                 "#endif\n";
 
         // Preprocess => don't crash..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        (void)getcode(settings0, *this, filedata);
     }
 
     void if_cond11() {
@@ -715,9 +842,8 @@ class TestPreprocessor : public TestFixture {
                                 "#elif FLT_MANT_DIG < W_TYPE_SIZE\n"
                                 "#endif\n"
                                 "#endif\n";
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
-        ASSERT_EQUALS("", errout.str());
+        (void)getcode(settings0, *this, filedata);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void if_cond12() {
@@ -748,7 +874,7 @@ class TestPreprocessor : public TestFixture {
         const char filedata[] = "#if defined(DEF_10) || defined(DEF_11)\n"
                                 "a1;\n"
                                 "#endif\n";
-        ASSERT_EQUALS("\nDEF_10;DEF_11\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nDEF_10=DEF_10;DEF_11=DEF_11\n", getConfigsStr(filedata));
     }
 
     void if_or_2() {
@@ -759,86 +885,83 @@ class TestPreprocessor : public TestFixture {
     }
 
     void if_macro_eq_macro() {
-        const char *code = "#define A B\n"
-                           "#define B 1\n"
-                           "#define C 1\n"
-                           "#if A == C\n"
-                           "Wilma\n"
-                           "#else\n"
-                           "Betty\n"
-                           "#endif\n";
+        const char code[] = "#define A B\n"
+                            "#define B 1\n"
+                            "#define C 1\n"
+                            "#if A == C\n"
+                            "Wilma\n"
+                            "#else\n"
+                            "Betty\n"
+                            "#endif\n";
         ASSERT_EQUALS("\n", getConfigsStr(code));
     }
 
     void ticket_3675() {
-        const char* code = "#ifdef YYSTACKSIZE\n"
-                           "#define YYMAXDEPTH YYSTACKSIZE\n"
-                           "#else\n"
-                           "#define YYSTACKSIZE YYMAXDEPTH\n"
-                           "#endif\n"
-                           "#if YYDEBUG\n"
-                           "#endif\n";
-        std::map<std::string, std::string> actual;
-        preprocess(code, actual);
+        const char code[] = "#ifdef YYSTACKSIZE\n"
+                            "#define YYMAXDEPTH YYSTACKSIZE\n"
+                            "#else\n"
+                            "#define YYSTACKSIZE YYMAXDEPTH\n"
+                            "#endif\n"
+                            "#if YYDEBUG\n"
+                            "#endif\n";
+        (void)getcode(settings0, *this, code);
 
         // There's nothing to assert. It just needs to not hang.
     }
 
     void ticket_3699() {
-        const char* code = "#define INLINE __forceinline\n"
-                           "#define inline __forceinline\n"
-                           "#define __forceinline inline\n"
-                           "#if !defined(_WIN32)\n"
-                           "#endif\n"
-                           "INLINE inline __forceinline\n";
-        std::map<std::string, std::string> actual;
-        preprocess(code, actual);
+        const char code[] = "#define INLINE __forceinline\n"
+                            "#define inline __forceinline\n"
+                            "#define __forceinline inline\n"
+                            "#if !defined(_WIN32)\n"
+                            "#endif\n"
+                            "INLINE inline __forceinline\n";
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, code);
 
         // First, it must not hang. Second, inline must becomes inline, and __forceinline must become __forceinline.
-        ASSERT_EQUALS("\n\n\n\n\n$__forceinline $inline $__forceinline", actual[""]);
+        ASSERT_EQUALS("\n\n\n\n\n$__forceinline $inline $__forceinline", actual.at(""));
     }
 
     void ticket_4922() { // #4922
-        const char* code = "__asm__ \n"
-                           "{ int extern __value) 0; (double return (\"\" } extern\n"
-                           "__typeof __finite (__finite) __finite __inline \"__GI___finite\");";
-        std::map<std::string, std::string> actual;
-        preprocess(code, actual);
+        const char code[] = "__asm__ \n"
+                            "{ int extern __value) 0; (double return (\"\" } extern\n"
+                            "__typeof __finite (__finite) __finite __inline \"__GI___finite\");";
+        (void)getcode(settings0, *this, code);
     }
 
-    void macro_simple1() const {
+    void macro_simple1() {
         {
             const char filedata[] = "#define AAA(aa) f(aa)\n"
                                     "AAA(5);\n";
-            ASSERT_EQUALS("\nf ( 5 ) ;", OurPreprocessor::expandMacros(filedata));
+            ASSERT_EQUALS("\nf ( 5 ) ;", expandMacros(filedata, *this));
         }
 
         {
             const char filedata[] = "#define AAA(aa) f(aa)\n"
                                     "AAA (5);\n";
-            ASSERT_EQUALS("\nf ( 5 ) ;", OurPreprocessor::expandMacros(filedata));
+            ASSERT_EQUALS("\nf ( 5 ) ;", expandMacros(filedata, *this));
         }
     }
 
-    void macro_simple2() const {
+    void macro_simple2() {
         const char filedata[] = "#define min(x,y) x<y?x:y\n"
                                 "min(a(),b());\n";
-        ASSERT_EQUALS("\na ( ) < b ( ) ? a ( ) : b ( ) ;", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\na ( ) < b ( ) ? a ( ) : b ( ) ;", expandMacros(filedata, *this));
     }
 
-    void macro_simple3() const {
+    void macro_simple3() {
         const char filedata[] = "#define A 4\n"
                                 "A AA\n";
-        ASSERT_EQUALS("\n4 AA", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\n4 AA", expandMacros(filedata, *this));
     }
 
-    void macro_simple4() const {
+    void macro_simple4() {
         const char filedata[] = "#define TEMP_1 if( temp > 0 ) return 1;\n"
                                 "TEMP_1\n";
-        ASSERT_EQUALS("\nif ( temp > 0 ) return 1 ;", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\nif ( temp > 0 ) return 1 ;", expandMacros(filedata, *this));
     }
 
-    void macro_simple5() const {
+    void macro_simple5() {
         const char filedata[] = "#define ABC if( temp > 0 ) return 1;\n"
                                 "\n"
                                 "void foo()\n"
@@ -846,136 +969,135 @@ class TestPreprocessor : public TestFixture {
                                 "    int temp = 0;\n"
                                 "    ABC\n"
                                 "}\n";
-        ASSERT_EQUALS("\n\nvoid foo ( )\n{\nint temp = 0 ;\nif ( temp > 0 ) return 1 ;\n}", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\n\nvoid foo ( )\n{\nint temp = 0 ;\nif ( temp > 0 ) return 1 ;\n}", expandMacros(filedata, *this));
     }
 
-    void macro_simple6() const {
+    void macro_simple6() {
         const char filedata[] = "#define ABC (a+b+c)\n"
                                 "ABC\n";
-        ASSERT_EQUALS("\n( a + b + c )", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\n( a + b + c )", expandMacros(filedata, *this));
     }
 
-    void macro_simple7() const {
+    void macro_simple7() {
         const char filedata[] = "#define ABC(str) str\n"
                                 "ABC(\"(\")\n";
-        ASSERT_EQUALS("\n\"(\"", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\n\"(\"", expandMacros(filedata, *this));
     }
 
-    void macro_simple8() const {
+    void macro_simple8() {
         const char filedata[] = "#define ABC 123\n"
                                 "#define ABCD 1234\n"
                                 "ABC ABCD\n";
-        ASSERT_EQUALS("\n\n123 1234", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\n\n123 1234", expandMacros(filedata, *this));
     }
 
-    void macro_simple9() const {
+    void macro_simple9() {
         const char filedata[] = "#define ABC(a) f(a)\n"
                                 "ABC( \"\\\"\" );\n"
                                 "ABC( \"g\" );\n";
-        ASSERT_EQUALS("\nf ( \"\\\"\" ) ;\nf ( \"g\" ) ;", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\nf ( \"\\\"\" ) ;\nf ( \"g\" ) ;", expandMacros(filedata, *this));
     }
 
-    void macro_simple10() const {
+    void macro_simple10() {
         const char filedata[] = "#define ABC(t) t x\n"
                                 "ABC(unsigned long);\n";
-        ASSERT_EQUALS("\nunsigned long x ;", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\nunsigned long x ;", expandMacros(filedata, *this));
     }
 
-    void macro_simple11() const {
+    void macro_simple11() {
         const char filedata[] = "#define ABC(x) delete x\n"
                                 "ABC(a);\n";
-        ASSERT_EQUALS("\ndelete a ;", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\ndelete a ;", expandMacros(filedata, *this));
     }
 
-    void macro_simple12() const {
+    void macro_simple12() {
         const char filedata[] = "#define AB ab.AB\n"
                                 "AB.CD\n";
-        ASSERT_EQUALS("\nab . AB . CD", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\nab . AB . CD", expandMacros(filedata, *this));
     }
 
-    void macro_simple13() const {
+    void macro_simple13() {
         const char filedata[] = "#define TRACE(x)\n"
                                 "TRACE(;if(a))\n";
-        ASSERT_EQUALS("", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("", expandMacros(filedata, *this));
     }
 
-    void macro_simple14() const {
+    void macro_simple14() {
         const char filedata[] = "#define A \"  a  \"\n"
                                 "printf(A);\n";
-        ASSERT_EQUALS("\nprintf ( \"  a  \" ) ;", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\nprintf ( \"  a  \" ) ;", expandMacros(filedata, *this));
     }
 
-    void macro_simple15() const {
+    void macro_simple15() {
         const char filedata[] = "#define FOO\"foo\"\n"
                                 "FOO\n";
-        ASSERT_EQUALS("\n\"foo\"", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\n\"foo\"", expandMacros(filedata, *this));
     }
 
-    void macro_simple16() const {  // # 4703
+    void macro_simple16() {  // # 4703
         const char filedata[] = "#define MACRO( A, B, C ) class A##B##C##Creator {};\n"
                                 "MACRO( B\t, U , G )";
-        ASSERT_EQUALS("\nclass BUGCreator { } ;", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\nclass BUGCreator { } ;", expandMacros(filedata, *this));
     }
 
-    void macro_simple17() const {  // # 5074 - the Token::isExpandedMacro() doesn't always indicate properly if token comes from macro
+    void macro_simple17() {  // # 5074 - the Token::isExpandedMacro() doesn't always indicate properly if token comes from macro
         // It would probably be OK if the generated code was
         // "\n123+$123" since the first 123 comes from the source code
         const char filedata[] = "#define MACRO(A) A+123\n"
                                 "MACRO(123)";
-        ASSERT_EQUALS("\n123 + 123", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\n123 + 123", expandMacros(filedata, *this));
     }
 
-    void macro_simple18() const {  // (1e-7)
+    void macro_simple18() {  // (1e-7)
         const char filedata1[] = "#define A (1e-7)\n"
                                  "a=A;";
-        ASSERT_EQUALS("\na = ( 1e-7 ) ;", OurPreprocessor::expandMacros(filedata1));
+        ASSERT_EQUALS("\na = ( 1e-7 ) ;", expandMacros(filedata1, *this));
 
         const char filedata2[] = "#define A (1E-7)\n"
                                  "a=A;";
-        ASSERT_EQUALS("\na = ( 1E-7 ) ;", OurPreprocessor::expandMacros(filedata2));
+        ASSERT_EQUALS("\na = ( 1E-7 ) ;", expandMacros(filedata2, *this));
 
         const char filedata3[] = "#define A (1e+7)\n"
                                  "a=A;";
-        ASSERT_EQUALS("\na = ( 1e+7 ) ;", OurPreprocessor::expandMacros(filedata3));
+        ASSERT_EQUALS("\na = ( 1e+7 ) ;", expandMacros(filedata3, *this));
 
         const char filedata4[] = "#define A (1.e+7)\n"
                                  "a=A;";
-        ASSERT_EQUALS("\na = ( 1.e+7 ) ;", OurPreprocessor::expandMacros(filedata4));
+        ASSERT_EQUALS("\na = ( 1.e+7 ) ;", expandMacros(filedata4, *this));
 
         const char filedata5[] = "#define A (1.7f)\n"
                                  "a=A;";
-        ASSERT_EQUALS("\na = ( 1.7f ) ;", OurPreprocessor::expandMacros(filedata5));
+        ASSERT_EQUALS("\na = ( 1.7f ) ;", expandMacros(filedata5, *this));
 
         const char filedata6[] = "#define A (.1)\n"
                                  "a=A;";
-        ASSERT_EQUALS("\na = ( .1 ) ;", OurPreprocessor::expandMacros(filedata6));
+        ASSERT_EQUALS("\na = ( .1 ) ;", expandMacros(filedata6, *this));
 
         const char filedata7[] = "#define A (1.)\n"
                                  "a=A;";
-        ASSERT_EQUALS("\na = ( 1. ) ;", OurPreprocessor::expandMacros(filedata7));
+        ASSERT_EQUALS("\na = ( 1. ) ;", expandMacros(filedata7, *this));
 
         const char filedata8[] = "#define A (8.0E+007)\n"
                                  "a=A;";
-        ASSERT_EQUALS("\na = ( 8.0E+007 ) ;", OurPreprocessor::expandMacros(filedata8));
+        ASSERT_EQUALS("\na = ( 8.0E+007 ) ;", expandMacros(filedata8, *this));
     }
 
-    void macroInMacro1() const {
+    void macroInMacro1() {
         {
             const char filedata[] = "#define A(m) long n = m; n++;\n"
                                     "#define B(n) A(n)\n"
                                     "B(0)\n";
-            ASSERT_EQUALS("\n\nlong n = 0 ; n ++ ;", OurPreprocessor::expandMacros(filedata));
+            ASSERT_EQUALS("\n\nlong n = 0 ; n ++ ;", expandMacros(filedata, *this));
         }
 
         {
             const char filedata[] = "#define A B\n"
                                     "#define B 3\n"
                                     "A\n";
-            ASSERT_EQUALS("\n\n3", OurPreprocessor::expandMacros(filedata));
+            ASSERT_EQUALS("\n\n3", expandMacros(filedata, *this));
         }
 
         {
-            /* TODO: What to do here? since there are syntax error simplecpp outputs ""
             const char filedata[] = "#define BC(b, c...) 0##b * 0##c\n"
                                     "#define ABC(a, b...) a + BC(b)\n"
                                     "\n"
@@ -983,35 +1105,34 @@ class TestPreprocessor : public TestFixture {
                                     "ABC(2,3);\n"
                                     "ABC(4,5,6);\n";
 
-            ASSERT_EQUALS("\n\n\n1 + 0 * 0;\n2 + 03 * 0;\n4 + 05 * 06;", OurPreprocessor::expandMacros(filedata));
-            */
+            ASSERT_EQUALS("\n\n\n1 + 0 * 0 ;\n2 + 03 * 0 ;\n4 + 05 * 06 ;", expandMacros(filedata, *this));
         }
 
         {
             const char filedata[] = "#define A 4\n"
                                     "#define B(a) a,A\n"
                                     "B(2);\n";
-            ASSERT_EQUALS("\n\n2 , 4 ;", OurPreprocessor::expandMacros(filedata));
+            ASSERT_EQUALS("\n\n2 , 4 ;", expandMacros(filedata, *this));
         }
 
         {
             const char filedata[] = "#define A(x) (x)\n"
                                     "#define B )A(\n"
                                     "#define C )A(\n";
-            ASSERT_EQUALS("", OurPreprocessor::expandMacros(filedata));
+            ASSERT_EQUALS("", expandMacros(filedata, *this));
         }
 
         {
             const char filedata[] = "#define A(x) (x*2)\n"
                                     "#define B A(\n"
                                     "foo B(i));\n";
-            ASSERT_EQUALS("\n\nfoo ( ( i ) * 2 ) ;", OurPreprocessor::expandMacros(filedata));
+            ASSERT_EQUALS("\n\nfoo ( ( i ) * 2 ) ;", expandMacros(filedata, *this));
         }
 
         {
             const char filedata[] = "#define foo foo\n"
                                     "foo\n";
-            ASSERT_EQUALS("\nfoo", OurPreprocessor::expandMacros(filedata));
+            ASSERT_EQUALS("\nfoo", expandMacros(filedata, *this));
         }
 
         {
@@ -1020,7 +1141,7 @@ class TestPreprocessor : public TestFixture {
                 "#define A(name) void foo##name() { do { B(1, 2); }\n"
                 "A(0)\n"
                 "A(1)\n";
-            ASSERT_EQUALS("\n\nvoid foo0 ( ) { do { } while ( 0 ) ; }\nvoid foo1 ( ) { do { } while ( 0 ) ; }", OurPreprocessor::expandMacros(filedata));
+            ASSERT_EQUALS("\n\nvoid foo0 ( ) { do { } while ( 0 ) ; }\nvoid foo1 ( ) { do { } while ( 0 ) ; }", expandMacros(filedata, *this));
         }
 
         {
@@ -1028,7 +1149,7 @@ class TestPreprocessor : public TestFixture {
                 "#define B(x) (\n"
                 "#define A() B(xx)\n"
                 "B(1) A() ) )\n";
-            ASSERT_EQUALS("\n\n( ( ) )", OurPreprocessor::expandMacros(filedata));
+            ASSERT_EQUALS("\n\n( ( ) )", expandMacros(filedata, *this));
         }
 
         {
@@ -1036,25 +1157,25 @@ class TestPreprocessor : public TestFixture {
                 "#define PTR1 (\n"
                 "#define PTR2 PTR1 PTR1\n"
                 "int PTR2 PTR2 foo )))) = 0;\n";
-            ASSERT_EQUALS("\n\nint ( ( ( ( foo ) ) ) ) = 0 ;", OurPreprocessor::expandMacros(filedata));
+            ASSERT_EQUALS("\n\nint ( ( ( ( foo ) ) ) ) = 0 ;", expandMacros(filedata, *this));
         }
 
         {
             const char filedata[] =
                 "#define PTR1 (\n"
                 "PTR1 PTR1\n";
-            ASSERT_EQUALS("\n( (", OurPreprocessor::expandMacros(filedata));
+            ASSERT_EQUALS("\n( (", expandMacros(filedata, *this));
         }
     }
 
-    void macroInMacro2() const {
+    void macroInMacro2() {
         const char filedata[] = "#define A(x) a##x\n"
                                 "#define B 0\n"
                                 "A(B)\n";
-        ASSERT_EQUALS("\n\naB", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\n\naB", expandMacros(filedata, *this));
     }
 
-    void macro_linenumbers() const {
+    void macro_linenumbers() {
         const char filedata[] = "#define AAA(a)\n"
                                 "AAA(5\n"
                                 "\n"
@@ -1065,23 +1186,23 @@ class TestPreprocessor : public TestFixture {
                       "\n"
                       "\n"
                       "int a ;",
-                      OurPreprocessor::expandMacros(filedata));
+                      expandMacros(filedata, *this));
     }
 
-    void macro_nopar() const {
+    void macro_nopar() {
         const char filedata[] = "#define AAA( ) { NULL }\n"
                                 "AAA()\n";
-        ASSERT_EQUALS("\n{ NULL }", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\n{ NULL }", expandMacros(filedata, *this));
     }
 
-    void macro_incdec() const {
+    void macro_incdec() {
         const char filedata[] = "#define M1(X) 1+X\n"
                                 "#define M2(X) 2-X\n"
                                 "M1(+1) M2(-1)\n";
-        ASSERT_EQUALS("\n\n1 + + 1 2 - - 1", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\n\n1 + + 1 2 - - 1", expandMacros(filedata, *this));
     }
 
-    void macro_switchCase() const {
+    void macro_switchCase() {
         {
             // Make sure "case 2" doesn't become "case2"
             const char filedata[] = "#define A( b ) "
@@ -1090,14 +1211,14 @@ class TestPreprocessor : public TestFixture {
                                     " break; "
                                     "}\n"
                                     "A( 5 );\n";
-            ASSERT_EQUALS("\nswitch ( a ) { case 2 : break ; } ;", OurPreprocessor::expandMacros(filedata));
+            ASSERT_EQUALS("\nswitch ( a ) { case 2 : break ; } ;", expandMacros(filedata, *this));
         }
 
         {
             // Make sure "2 BB" doesn't become "2BB"
             const char filedata[] = "#define A() AA : 2 BB\n"
                                     "A();\n";
-            ASSERT_EQUALS("\nAA : 2 BB ;", OurPreprocessor::expandMacros(filedata));
+            ASSERT_EQUALS("\nAA : 2 BB ;", expandMacros(filedata, *this));
         }
 
         {
@@ -1105,7 +1226,7 @@ class TestPreprocessor : public TestFixture {
                                     "#define B() A\n"
                                     "#define C( a ) B() break;\n"
                                     "{C( 2 );\n";
-            ASSERT_EQUALS("\n\n\n{ } break ; ;", OurPreprocessor::expandMacros(filedata));
+            ASSERT_EQUALS("\n\n\n{ } break ; ;", expandMacros(filedata, *this));
         }
 
 
@@ -1114,7 +1235,7 @@ class TestPreprocessor : public TestFixture {
                                     "#define B() A\n"
                                     "#define C( a ) B() _break;\n"
                                     "{C( 2 );\n";
-            ASSERT_EQUALS("\n\n\n{ } _break ; ;", OurPreprocessor::expandMacros(filedata));
+            ASSERT_EQUALS("\n\n\n{ } _break ; ;", expandMacros(filedata, *this));
         }
 
 
@@ -1123,15 +1244,14 @@ class TestPreprocessor : public TestFixture {
                                     "#define B() A\n"
                                     "#define C( a ) B() 5;\n"
                                     "{C( 2 );\n";
-            ASSERT_EQUALS("\n\n\n{ } 5 ; ;", OurPreprocessor::expandMacros(filedata));
+            ASSERT_EQUALS("\n\n\n{ } 5 ; ;", expandMacros(filedata, *this));
         }
     }
 
-    void macro_NULL() const {
-        // Let the tokenizer handle NULL.
+    void macro_NULL() {
         // See ticket #4482 - UB when passing NULL to variadic function
-        ASSERT_EQUALS("\n0", OurPreprocessor::expandMacros("#define null 0\nnull"));
-        // TODO ASSERT_EQUALS("\nNULL", OurPreprocessor::expandMacros("#define NULL 0\nNULL"));
+        ASSERT_EQUALS("\n0", expandMacros("#define null 0\nnull", *this));
+        TODO_ASSERT_EQUALS("\nNULL", "\n0", expandMacros("#define NULL 0\nNULL", *this)); // TODO: Let the tokenizer handle NULL?
     }
 
     void string1() {
@@ -1141,27 +1261,26 @@ class TestPreprocessor : public TestFixture {
                                 "}\n";
 
         // Preprocess => actual result..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
         // Compare results..
         ASSERT_EQUALS(1, actual.size());
-        ASSERT_EQUALS("int main ( ) { const char * a = \"#define A\" ; }", actual[""]);
+        ASSERT_EQUALS("int main ( ) { const char * a = \"#define A\" ; }", actual.at(""));
     }
 
-    void string2() const {
+    void string2() {
         const char filedata[] = "#define AAA 123\n"
                                 "str = \"AAA\"\n";
 
         // Compare results..
-        ASSERT_EQUALS("\nstr = \"AAA\"", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\nstr = \"AAA\"", expandMacros(filedata, *this));
     }
 
-    void string3() const {
+    void string3() {
         const char filedata[] = "str(\";\");\n";
 
         // Compare results..
-        ASSERT_EQUALS("str ( \";\" ) ;", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("str ( \";\" ) ;", expandMacros(filedata, *this));
     }
 
 
@@ -1173,7 +1292,7 @@ class TestPreprocessor : public TestFixture {
                                     "AAA\n";
 
             // Compare results..
-            ASSERT_EQUALS("\n\n\nchar b = 0 ;", OurPreprocessor::expandMacros(filedata));
+            ASSERT_EQUALS("\n\n\nchar b = 0 ;", expandMacros(filedata, *this));
         }
 
         {
@@ -1182,48 +1301,48 @@ class TestPreprocessor : public TestFixture {
                                     "#undef z\n"
                                     "int z;\n"
                                     "z = 0;\n";
-            ASSERT_EQUALS("\n\nint z ;\nz = 0 ;", preprocessor0.getcode(filedata, "", ""));
+            ASSERT_EQUALS("\n\nint z ;\nz = 0 ;", getcodeforcfg(settings0, *this, filedata, "", "test.c"));
         }
     }
 
-    void defdef() const {
+    void defdef() {
         const char filedata[] = "#define AAA 123\n"
                                 "#define AAA 456\n"
                                 "#define AAA 789\n"
                                 "AAA\n";
 
         // Compare results..
-        ASSERT_EQUALS("\n\n\n789", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\n\n\n789", expandMacros(filedata, *this));
     }
 
-    void preprocessor_doublesharp() const {
+    void preprocessor_doublesharp() {
         // simple testcase without ##
         const char filedata1[] = "#define TEST(var,val) var = val\n"
                                  "TEST(foo,20);\n";
-        ASSERT_EQUALS("\nfoo = 20 ;", OurPreprocessor::expandMacros(filedata1));
+        ASSERT_EQUALS("\nfoo = 20 ;", expandMacros(filedata1, *this));
 
         // simple testcase with ##
         const char filedata2[] = "#define TEST(var,val) var##_##val = val\n"
                                  "TEST(foo,20);\n";
-        ASSERT_EQUALS("\nfoo_20 = 20 ;", OurPreprocessor::expandMacros(filedata2));
+        ASSERT_EQUALS("\nfoo_20 = 20 ;", expandMacros(filedata2, *this));
 
         // concat macroname
         const char filedata3[] = "#define ABCD 123\n"
                                  "#define A(B) A##B\n"
                                  "A(BCD)\n";
-        ASSERT_EQUALS("\n\n123", OurPreprocessor::expandMacros(filedata3));
+        ASSERT_EQUALS("\n\n123", expandMacros(filedata3, *this));
 
         // Ticket #1802 - inner ## must be expanded before outer macro
         const char filedata4[] = "#define A(B) A##B\n"
                                  "#define a(B) A(B)\n"
                                  "a(A(B))\n";
-        ASSERT_EQUALS("\n\nAAB", OurPreprocessor::expandMacros(filedata4));
+        ASSERT_EQUALS("\n\nAAB", expandMacros(filedata4, *this));
 
         // Ticket #1802 - inner ## must be expanded before outer macro
         const char filedata5[] = "#define AB(A,B) A##B\n"
                                  "#define ab(A,B) AB(A,B)\n"
                                  "ab(a,AB(b,c))\n";
-        ASSERT_EQUALS("\n\nabc", OurPreprocessor::expandMacros(filedata5));
+        ASSERT_EQUALS("\n\nabc", expandMacros(filedata5, *this));
 
         // Ticket #1802
         const char filedata6[] = "#define AB_(A,B) A ## B\n"
@@ -1231,7 +1350,7 @@ class TestPreprocessor : public TestFixture {
                                  "#define ab(suf) AB(X, AB_(_, suf))\n"
                                  "#define X x\n"
                                  "ab(y)\n";
-        ASSERT_EQUALS("\n\n\n\nx_y", OurPreprocessor::expandMacros(filedata6));
+        ASSERT_EQUALS("\n\n\n\nx_y", expandMacros(filedata6, *this));
     }
 
 
@@ -1244,57 +1363,53 @@ class TestPreprocessor : public TestFixture {
                                 "}\n";
 
         // Preprocess => actual result..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
         // Compare results..
         ASSERT_EQUALS(1, actual.size());
-        ASSERT_EQUALS("int main ( )\n{\nconst char * a = \"#include <string>\" ;\nreturn 0 ;\n}", actual[""]);
+        ASSERT_EQUALS("int main ( )\n{\nconst char * a = \"#include <string>\" ;\nreturn 0 ;\n}", actual.at(""));
     }
 
-
-
-
-    void va_args_1() const {
+    void va_args_1() {
         const char filedata[] = "#define DBG(fmt...) printf(fmt)\n"
                                 "DBG(\"[0x%lx-0x%lx)\", pstart, pend);\n";
 
         // Preprocess..
-        std::string actual = OurPreprocessor::expandMacros(filedata);
+        std::string actual = expandMacros(filedata, *this);
 
         ASSERT_EQUALS("\nprintf ( \"[0x%lx-0x%lx)\" , pstart , pend ) ;", actual);
     }
     /*
-        void va_args_2() const {
+        void va_args_2() {
             const char filedata[] = "#define DBG(fmt, args...) printf(fmt, ## args)\n"
                                     "DBG(\"hello\");\n";
 
             // Preprocess..
-            std::string actual = OurPreprocessor::expandMacros(filedata);
+            std::string actual = expandMacros(filedata, *this);
 
             // invalid code ASSERT_EQUALS("\nprintf ( \"hello\" ) ;", actual);
         }
-    */
-    void va_args_3() const {
+     */
+    void va_args_3() {
         const char filedata[] = "#define FRED(...) { fred(__VA_ARGS__); }\n"
                                 "FRED(123)\n";
-        ASSERT_EQUALS("\n{ fred ( 123 ) ; }", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\n{ fred ( 123 ) ; }", expandMacros(filedata, *this));
     }
 
-    void va_args_4() const {
+    void va_args_4() {
         const char filedata[] = "#define FRED(name, ...) name (__VA_ARGS__)\n"
                                 "FRED(abc, 123)\n";
-        ASSERT_EQUALS("\nabc ( 123 )", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\nabc ( 123 )", expandMacros(filedata, *this));
     }
 
-    void va_args_5() const {
+    void va_args_5() {
         const char filedata1[] = "#define A(...) #__VA_ARGS__\n"
                                  "A(123)\n";
-        ASSERT_EQUALS("\n\"123\"", OurPreprocessor::expandMacros(filedata1));
+        ASSERT_EQUALS("\n\"123\"", expandMacros(filedata1, *this));
 
         const char filedata2[] = "#define A(X,...) X(#__VA_ARGS__)\n"
                                  "A(f,123)\n";
-        ASSERT_EQUALS("\nf ( \"123\" )", OurPreprocessor::expandMacros(filedata2));
+        ASSERT_EQUALS("\nf ( \"123\" )", expandMacros(filedata2, *this));
     }
 
 
@@ -1308,61 +1423,60 @@ class TestPreprocessor : public TestFixture {
                                 "}\n";
 
         // Preprocess => actual result..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
         // Compare results..
         ASSERT_EQUALS(1, actual.size());
-        ASSERT_EQUALS("\nint main ( )\n{\nif ( $'ABCD' == 0 ) ;\nreturn 0 ;\n}", actual[""]);
+        ASSERT_EQUALS("\nint main ( )\n{\nif ( $'ABCD' == 0 ) ;\nreturn 0 ;\n}", actual.at(""));
     }
 
 
-    void stringify() const {
+    void stringify() {
         const char filedata[] = "#define STRINGIFY(x) #x\n"
                                 "STRINGIFY(abc)\n";
 
         // expand macros..
-        std::string actual = OurPreprocessor::expandMacros(filedata);
+        std::string actual = expandMacros(filedata, *this);
 
         ASSERT_EQUALS("\n\"abc\"", actual);
     }
 
-    void stringify2() const {
+    void stringify2() {
         const char filedata[] = "#define A(x) g(#x)\n"
                                 "A(abc);\n";
 
         // expand macros..
-        std::string actual = OurPreprocessor::expandMacros(filedata);
+        std::string actual = expandMacros(filedata, *this);
 
         ASSERT_EQUALS("\ng ( \"abc\" ) ;", actual);
     }
 
-    void stringify3() const {
+    void stringify3() {
         const char filedata[] = "#define A(x) g(#x)\n"
                                 "A( abc);\n";
 
         // expand macros..
-        std::string actual = OurPreprocessor::expandMacros(filedata);
+        std::string actual = expandMacros(filedata, *this);
 
         ASSERT_EQUALS("\ng ( \"abc\" ) ;", actual);
     }
 
-    void stringify4() const {
+    void stringify4() {
         const char filedata[] = "#define A(x) #x\n"
                                 "1 A(\n"
                                 "abc\n"
                                 ") 2\n";
 
         // expand macros..
-        std::string actual = OurPreprocessor::expandMacros(filedata);
+        std::string actual = expandMacros(filedata, *this);
 
         ASSERT_EQUALS("\n1 \"abc\"\n\n2", actual);
     }
 
-    void stringify5() const {
+    void stringify5() {
         const char filedata[] = "#define A(x) a(#x,x)\n"
                                 "A(foo(\"\\\"\"))\n";
-        ASSERT_EQUALS("\na ( \"foo(\\\"\\\\\\\"\\\")\" , foo ( \"\\\"\" ) )", OurPreprocessor::expandMacros(filedata));
+        ASSERT_EQUALS("\na ( \"foo(\\\"\\\\\\\"\\\")\" , foo ( \"\\\"\" ) )", expandMacros(filedata, *this));
     }
 
     void pragma() {
@@ -1372,12 +1486,11 @@ class TestPreprocessor : public TestFixture {
                                 "}\n";
 
         // Preprocess => actual result..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
         // Compare results..
         ASSERT_EQUALS(1, actual.size());
-        ASSERT_EQUALS("\nvoid f ( )\n{\n}", actual[""]);
+        ASSERT_EQUALS("\nvoid f ( )\n{\n}", actual.at(""));
     }
 
     void pragma_asm_1() {
@@ -1391,12 +1504,11 @@ class TestPreprocessor : public TestFixture {
                                 "bbb";
 
         // Preprocess => actual result..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
         // Compare results..
         ASSERT_EQUALS(1, actual.size());
-        ASSERT_EQUALS("asm ( )\n;\n\naaa\nasm ( ) ;\n\n\nbbb", actual[""]);
+        ASSERT_EQUALS("asm ( )\n;\n\naaa\nasm ( ) ;\n\n\nbbb", actual.at(""));
     }
 
     void pragma_asm_2() {
@@ -1406,12 +1518,11 @@ class TestPreprocessor : public TestFixture {
                                 "bbb";
 
         // Preprocess => actual result..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
         // Compare results..
         ASSERT_EQUALS(1, actual.size());
-        ASSERT_EQUALS("asm ( )\n;\n\nbbb", actual[""]);
+        ASSERT_EQUALS("asm ( )\n;\n\nbbb", actual.at(""));
     }
 
     void endifsemicolon() {
@@ -1421,14 +1532,13 @@ class TestPreprocessor : public TestFixture {
                                 "}\n";
 
         // Preprocess => actual result..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
         // Compare results..
         ASSERT_EQUALS(2, actual.size());
         const std::string expected("void f ( ) {\n\n\n}");
-        ASSERT_EQUALS(expected, actual[""]);
-        ASSERT_EQUALS(expected, actual["A"]);
+        ASSERT_EQUALS(expected, actual.at(""));
+        ASSERT_EQUALS(expected, actual.at("A=A"));
     }
 
     void handle_error() {
@@ -1442,11 +1552,10 @@ class TestPreprocessor : public TestFixture {
                                     "}\n";
 
             // Preprocess => actual result..
-            std::map<std::string, std::string> actual;
-            preprocess(filedata, actual);
+            const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
-            ASSERT_EQUALS("", actual[""]);
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS(0, actual.size());
+            ASSERT_EQUALS("[file.c:2:14]: (error) No pair for character ('). Can't process file. File is either invalid or unicode, which is currently not supported. [syntaxError]\n", errout_str());
         }
     }
 
@@ -1458,11 +1567,10 @@ class TestPreprocessor : public TestFixture {
                                     "#endif\n";
 
             // expand macros..
-            errout.str("");
-            const std::string actual(OurPreprocessor::expandMacros(filedata, this));
+            const std::string actual(expandMacros(filedata, *this));
 
             ASSERT_EQUALS("", actual);
-            ASSERT_EQUALS("[file.cpp:3]: (error) No pair for character (\"). Can't process file. File is either invalid or unicode, which is currently not supported.\n", errout.str());
+            ASSERT_EQUALS("[file.cpp:3:1]: (error) No pair for character (\"). Can't process file. File is either invalid or unicode, which is currently not supported. [syntaxError]\n", errout_str());
         }
 
         {
@@ -1472,11 +1580,10 @@ class TestPreprocessor : public TestFixture {
                                     "#endfile\n";
 
             // expand macros..
-            errout.str("");
-            const std::string actual(OurPreprocessor::expandMacros(filedata, this));
+            const std::string actual(expandMacros(filedata, *this));
 
             ASSERT_EQUALS("", actual);
-            ASSERT_EQUALS("[abc.h:2]: (error) No pair for character (\"). Can't process file. File is either invalid or unicode, which is currently not supported.\n", errout.str());
+            ASSERT_EQUALS("[abc.h:2:1]: (error) No pair for character (\"). Can't process file. File is either invalid or unicode, which is currently not supported. [syntaxError]\n", errout_str());
         }
 
         {
@@ -1486,11 +1593,10 @@ class TestPreprocessor : public TestFixture {
                                     "\"\n";
 
             // expand macros..
-            errout.str("");
-            const std::string actual(OurPreprocessor::expandMacros(filedata, this));
+            const std::string actual(expandMacros(filedata, *this));
 
             ASSERT_EQUALS("", actual);
-            ASSERT_EQUALS("[file.cpp:2]: (error) No pair for character (\"). Can't process file. File is either invalid or unicode, which is currently not supported.\n", errout.str());
+            ASSERT_EQUALS("[file.cpp:2:1]: (error) No pair for character (\"). Can't process file. File is either invalid or unicode, which is currently not supported. [syntaxError]\n", errout_str());
         }
 
         {
@@ -1499,11 +1605,10 @@ class TestPreprocessor : public TestFixture {
                                     "int a = A;\n";
 
             // expand macros..
-            errout.str("");
-            const std::string actual(OurPreprocessor::expandMacros(filedata, this));
+            const std::string actual(expandMacros(filedata, *this));
 
             ASSERT_EQUALS("", actual);
-            ASSERT_EQUALS("[file.cpp:2]: (error) No pair for character (\"). Can't process file. File is either invalid or unicode, which is currently not supported.\n", errout.str());
+            ASSERT_EQUALS("[file.cpp:2:11]: (error) No pair for character (\"). Can't process file. File is either invalid or unicode, which is currently not supported. [syntaxError]\n", errout_str());
         }
 
         {
@@ -1517,10 +1622,9 @@ class TestPreprocessor : public TestFixture {
                                     "}\n";
 
             // expand macros..
-            errout.str("");
-            OurPreprocessor::expandMacros(filedata, this);
+            (void)expandMacros(filedata, *this);
 
-            ASSERT_EQUALS("[file.cpp:7]: (error) No pair for character (\"). Can't process file. File is either invalid or unicode, which is currently not supported.\n", errout.str());
+            ASSERT_EQUALS("[file.cpp:7:12]: (error) No pair for character (\"). Can't process file. File is either invalid or unicode, which is currently not supported. [syntaxError]\n", errout_str());
         }
     }
 
@@ -1532,13 +1636,12 @@ class TestPreprocessor : public TestFixture {
                                 "  }\n";
 
         // Preprocess => actual result..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
         // Compare results..
         ASSERT_EQUALS(1, actual.size());
-        ASSERT_EQUALS("\nvoid f ( ) {\n$g $( ) ;\n}", actual[""]);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("\nvoid f ( ) {\n$g $( ) ;\n}", actual.at(""));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void conditionalDefine() {
@@ -1550,18 +1653,16 @@ class TestPreprocessor : public TestFixture {
                                 "N";
 
         // Preprocess => actual result..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
         // Compare results..
         ASSERT_EQUALS(2, actual.size());
-        ASSERT_EQUALS("\n\n\n\n\n$20", actual[""]);
-        ASSERT_EQUALS("\n\n\n\n\n$10", actual["A"]);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("\n\n\n\n\n$20", actual.at(""));
+        ASSERT_EQUALS("\n\n\n\n\n$10", actual.at("A=A"));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void macro_parameters() {
-        errout.str("");
         const char filedata[] = "#define BC(a, b, c, arg...) \\\n"
                                 "AB(a, b, c, ## arg)\n"
                                 "\n"
@@ -1571,13 +1672,12 @@ class TestPreprocessor : public TestFixture {
                                 "}\n";
 
         // Preprocess => actual result..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
         // Compare results..
         ASSERT_EQUALS(1, actual.size());
-        ASSERT_EQUALS("", actual[""]);
-        ASSERT_EQUALS("[file.c:6]: (error) failed to expand 'BC', Wrong number of parameters for macro 'BC'.\n", errout.str());
+        ASSERT_EQUALS("", actual.at(""));
+        ASSERT_EQUALS("[file.c:6:3]: (error) failed to expand 'BC', Wrong number of parameters for macro 'BC'. [syntaxError]\n", errout_str());
     }
 
     void newline_in_macro() {
@@ -1588,13 +1688,12 @@ class TestPreprocessor : public TestFixture {
                                 "}\n";
 
         // Preprocess => actual result..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
         // Compare results..
         ASSERT_EQUALS(1, actual.size());
-        ASSERT_EQUALS("\nvoid f ( )\n{\n$printf $( \"\\n\" $) ;\n}", actual[""]);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("\nvoid f ( )\n{\n$printf $( \"\\n\" $) ;\n}", actual.at(""));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void ifdef_ifdefined() {
@@ -1606,13 +1705,12 @@ class TestPreprocessor : public TestFixture {
                                 "#endif\n";
 
         // Preprocess => actual result..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
         // Compare results..
-        ASSERT_EQUALS("", actual[""]);
-        ASSERT_EQUALS("\nA\n\n\nA", actual["ABC"]);
         ASSERT_EQUALS(2, actual.size());
+        ASSERT_EQUALS("", actual.at(""));
+        ASSERT_EQUALS("\nA\n\n\nA", actual.at("ABC=ABC"));
     }
 
     void define_if1() {
@@ -1621,14 +1719,14 @@ class TestPreprocessor : public TestFixture {
                                     "#if A\n"
                                     "FOO\n"
                                     "#endif";
-            ASSERT_EQUALS("", preprocessor0.getcode(filedata,"",""));
+            ASSERT_EQUALS("", getcodeforcfg(settings0, *this, filedata,"","test.c"));
         }
         {
             const char filedata[] = "#define A 1\n"
                                     "#if A==1\n"
                                     "FOO\n"
                                     "#endif";
-            ASSERT_EQUALS("\n\nFOO", preprocessor0.getcode(filedata,"",""));
+            ASSERT_EQUALS("\n\nFOO", getcodeforcfg(settings0, *this, filedata,"","test.c"));
         }
     }
 
@@ -1638,7 +1736,7 @@ class TestPreprocessor : public TestFixture {
                                 "#if (B==A) || (B==C)\n"
                                 "FOO\n"
                                 "#endif";
-        ASSERT_EQUALS("\n\n\nFOO", preprocessor0.getcode(filedata,"",""));
+        ASSERT_EQUALS("\n\n\nFOO", getcodeforcfg(settings0, *this, filedata,"","test.c"));
     }
 
     void define_if3() {
@@ -1646,7 +1744,7 @@ class TestPreprocessor : public TestFixture {
                                 "#if (A==0)\n"
                                 "FOO\n"
                                 "#endif";
-        ASSERT_EQUALS("\n\nFOO", preprocessor0.getcode(filedata,"",""));
+        ASSERT_EQUALS("\n\nFOO", getcodeforcfg(settings0, *this, filedata,"","test.c"));
     }
 
     void define_if4() {
@@ -1654,7 +1752,7 @@ class TestPreprocessor : public TestFixture {
                                 "#if X==123\n"
                                 "FOO\n"
                                 "#endif";
-        ASSERT_EQUALS("\n\nFOO", preprocessor0.getcode(filedata,"",""));
+        ASSERT_EQUALS("\n\nFOO", getcodeforcfg(settings0, *this, filedata,"","test.c"));
     }
 
     void define_if5() { // #4516 - #define B (A & 0x00f0)
@@ -1664,7 +1762,7 @@ class TestPreprocessor : public TestFixture {
                                     "#if B==0x0010\n"
                                     "FOO\n"
                                     "#endif";
-            ASSERT_EQUALS("\n\n\nFOO", preprocessor0.getcode(filedata,"",""));
+            ASSERT_EQUALS("\n\n\nFOO", getcodeforcfg(settings0, *this, filedata,"","test.c"));
         }
         {
             const char filedata[] = "#define A 0x00f0\n"
@@ -1673,14 +1771,14 @@ class TestPreprocessor : public TestFixture {
                                     "#if C==0x0010\n"
                                     "FOO\n"
                                     "#endif";
-            ASSERT_EQUALS("\n\n\n\nFOO", preprocessor0.getcode(filedata,"",""));
+            ASSERT_EQUALS("\n\n\n\nFOO", getcodeforcfg(settings0, *this, filedata,"","test.c"));
         }
         {
             const char filedata[] = "#define A (1+A)\n" // don't hang for recursive macros
                                     "#if A==1\n"
                                     "FOO\n"
                                     "#endif";
-            ASSERT_EQUALS("\n\nFOO", preprocessor0.getcode(filedata,"",""));
+            ASSERT_EQUALS("\n\nFOO", getcodeforcfg(settings0, *this, filedata,"","test.c"));
         }
     }
 
@@ -1696,10 +1794,10 @@ class TestPreprocessor : public TestFixture {
                                 "#if B >= 0\n"
                                 "456\n"
                                 "#endif\n";
-        const std::string actualA0 = preprocessor0.getcode(filedata, "A=0", "test.c");
+        const std::string actualA0 = getcodeforcfg(settings0, *this, filedata, "A=0", "test.c");
         ASSERT_EQUALS(true,  actualA0.find("123") != std::string::npos);
         ASSERT_EQUALS(false, actualA0.find("456") != std::string::npos);
-        const std::string actualA1 = preprocessor0.getcode(filedata, "A=1", "test.c");
+        const std::string actualA1 = getcodeforcfg(settings0, *this, filedata, "A=1", "test.c");
         ASSERT_EQUALS(false, actualA1.find("123") != std::string::npos);
         ASSERT_EQUALS(true,  actualA1.find("456") != std::string::npos);
     }
@@ -1714,12 +1812,11 @@ class TestPreprocessor : public TestFixture {
                                     "#endif\n";
 
             // Preprocess => actual result..
-            std::map<std::string, std::string> actual;
-            preprocess(filedata, actual);
+            const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
             // Compare results..
-            ASSERT_EQUALS(1, (int)actual.size());
-            ASSERT_EQUALS("\n\n\n\nB", actual[""]);
+            ASSERT_EQUALS(1, actual.size());
+            ASSERT_EQUALS("\n\n\n\nB", actual.at(""));
         }
 
         {
@@ -1729,12 +1826,11 @@ class TestPreprocessor : public TestFixture {
                                     "#endif\n";
 
             // Preprocess => actual result..
-            std::map<std::string, std::string> actual;
-            preprocess(filedata, actual);
+            const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
             // Compare results..
-            ASSERT_EQUALS(1, (int)actual.size());
-            ASSERT_EQUALS("\n\n$1", actual[""]);
+            ASSERT_EQUALS(1, actual.size());
+            ASSERT_EQUALS("\n\n$1", actual.at(""));
         }
 
         {
@@ -1744,12 +1840,11 @@ class TestPreprocessor : public TestFixture {
                                     "#endif\n";
 
             // Preprocess => actual result..
-            std::map<std::string, std::string> actual;
-            preprocess(filedata, actual);
+            const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
             // Compare results..
-            ASSERT_EQUALS(1, (int)actual.size());
-            ASSERT_EQUALS("\n\n$1", actual[""]);
+            ASSERT_EQUALS(1, actual.size());
+            ASSERT_EQUALS("\n\n$1", actual.at(""));
         }
 
         {
@@ -1759,12 +1854,11 @@ class TestPreprocessor : public TestFixture {
                                     "#endif\n";
 
             // Preprocess => actual result..
-            std::map<std::string, std::string> actual;
-            preprocess(filedata, actual);
+            const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
             // Compare results..
-            ASSERT_EQUALS(1, (int)actual.size());
-            ASSERT_EQUALS("\n\n$1", actual[""]);
+            ASSERT_EQUALS(1, actual.size());
+            ASSERT_EQUALS("\n\n$1", actual.at(""));
         }
 
         {
@@ -1775,12 +1869,11 @@ class TestPreprocessor : public TestFixture {
                                     "A\n";
 
             // Preprocess => actual result..
-            std::map<std::string, std::string> actual;
-            preprocess(filedata, actual);
+            const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
             // Compare results..
-            ASSERT_EQUALS(1, (int)actual.size());
-            ASSERT_EQUALS("\n\n\n\n$1", actual[""]);
+            ASSERT_EQUALS(1, actual.size());
+            ASSERT_EQUALS("\n\n\n\n$1", actual.at(""));
         }
     }
 
@@ -1791,12 +1884,11 @@ class TestPreprocessor : public TestFixture {
                                 "#endif\n";
 
         // Preprocess => actual result..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
         // Compare results..
         ASSERT_EQUALS(1U, actual.size());
-        ASSERT_EQUALS("", actual[""]);
+        ASSERT_EQUALS("", actual.at(""));
     }
 
     void define_ifndef2() {
@@ -1809,8 +1901,8 @@ class TestPreprocessor : public TestFixture {
                                 "B me;\n";
 
         // Preprocess => actual result..
-        ASSERT_EQUALS("\n\n\n\n\n\n$int me ;", preprocessor0.getcode(filedata, "", "a.cpp"));
-        ASSERT_EQUALS("\n\n\n\n\n\n$char me ;", preprocessor0.getcode(filedata, "A", "a.cpp"));
+        ASSERT_EQUALS("\n\n\n\n\n\n$int me ;", getcodeforcfg(settings0, *this, filedata, "", "a.cpp"));
+        ASSERT_EQUALS("\n\n\n\n\n\n$char me ;", getcodeforcfg(settings0, *this, filedata, "A", "a.cpp"));
     }
 
     void ifndef_define() {
@@ -1820,11 +1912,10 @@ class TestPreprocessor : public TestFixture {
                                 "A(123);";
 
         // Preprocess => actual result..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
         ASSERT_EQUALS(1U, actual.size());
-        ASSERT_EQUALS("\n\n\n123 ;", actual[""]);
+        ASSERT_EQUALS("\n\n\n123 ;", actual.at(""));
     }
 
     void undef_ifdef() {
@@ -1834,8 +1925,8 @@ class TestPreprocessor : public TestFixture {
                                 "#endif\n";
 
         // Preprocess => actual result..
-        ASSERT_EQUALS("", preprocessor0.getcode(filedata, "", "a.cpp"));
-        ASSERT_EQUALS("", preprocessor0.getcode(filedata, "A", "a.cpp"));
+        ASSERT_EQUALS("", getcodeforcfg(settings0, *this, filedata, "", "a.cpp"));
+        ASSERT_EQUALS("", getcodeforcfg(settings0, *this, filedata, "A", "a.cpp"));
     }
 
     void redundant_config() {
@@ -1855,15 +1946,14 @@ class TestPreprocessor : public TestFixture {
 
 
         // Preprocess => actual result..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
         // Compare results..
-        ASSERT_EQUALS(4, (int)actual.size());
+        ASSERT_EQUALS(4, actual.size());
         ASSERT(actual.find("") != actual.end());
-        ASSERT(actual.find("BAR") != actual.end());
-        ASSERT(actual.find("FOO") != actual.end());
-        ASSERT(actual.find("BAR;FOO") != actual.end());
+        ASSERT(actual.find("BAR=BAR") != actual.end());
+        ASSERT(actual.find("FOO=FOO") != actual.end());
+        ASSERT(actual.find("BAR=BAR;FOO=FOO") != actual.end());
     }
 
 
@@ -1873,12 +1963,11 @@ class TestPreprocessor : public TestFixture {
                                 "#include \"notfound.h\"\n";
 
         // Preprocess => actual result..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
         // Compare results..
-        ASSERT_EQUALS("char a [ ] = \"#endfile\" ;\nchar b [ ] = \"#endfile\" ;", actual[""]);
-        ASSERT_EQUALS(1, (int)actual.size());
+        ASSERT_EQUALS(1, actual.size());
+        ASSERT_EQUALS("char a [ ] = \"#endfile\" ;\nchar b [ ] = \"#endfile\" ;", actual.at(""));
     }
 
     void dup_defines() {
@@ -1892,77 +1981,145 @@ class TestPreprocessor : public TestFixture {
                                 "#endif\n";
 
         // Preprocess => actual result..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
         // B will always be defined if A is defined; the following test
         // cases should be fixed whenever this other bug is fixed
         ASSERT_EQUALS(2U, actual.size());
 
-        if (actual.find("A") == actual.end()) {
-            ASSERT_EQUALS("A is checked", "failed");
-        } else {
-            ASSERT_EQUALS("A is checked", "A is checked");
-        }
+        ASSERT_EQUALS_MSG(true, (actual.find("A=A") != actual.end()), "A is expected to be checked but it was not checked");
 
-        if (actual.find("A;A;B") != actual.end()) {
-            ASSERT_EQUALS("A;A;B is NOT checked", "failed");
-        } else {
-            ASSERT_EQUALS("A;A;B is NOT checked", "A;A;B is NOT checked");
-        }
+        ASSERT_EQUALS_MSG(true, (actual.find("A=A;A=A;B=B") == actual.end()), "A;A;B is expected to NOT be checked but it was checked");
     }
 
     void invalid_define_1() {
-        std::map<std::string, std::string> actual;
-        preprocess("#define =\n", actual); // don't hang
+        (void)getcode(settings0, *this, "#define =\n");
+        ASSERT_EQUALS("[file.c:1:2]: (error) Failed to parse #define [syntaxError]\n", errout_str());
     }
 
     void invalid_define_2() {  // #4036
-        std::map<std::string, std::string> actual;
-        preprocess("#define () {(int f(x) }\n", actual); // don't hang
-    }
-
-    void inline_suppression_for_missing_include() {
-        Preprocessor::missingIncludeFlag = false;
-        Settings settings;
-        settings.inlineSuppressions = true;
-        settings.addEnabled("all");
-        Preprocessor preprocessor(settings, this);
-
-        std::istringstream src("// cppcheck-suppress missingInclude\n"
-                               "#include \"missing.h\"\n"
-                               "int x;");
-        std::string processedFile;
-        std::list<std::string> cfg;
-        std::list<std::string> paths;
-
-        // Don't report that the include is missing
-        errout.str("");
-        preprocessor.preprocess(src, processedFile, cfg, "test.c", paths);
-        ASSERT_EQUALS("", errout.str());
-        ASSERT_EQUALS(false, Preprocessor::missingIncludeFlag);
+        (void)getcode(settings0, *this, "#define () {(int f(x) }\n");
+        ASSERT_EQUALS("[file.c:1:2]: (error) Failed to parse #define [syntaxError]\n", errout_str());
+    }
+
+    void inline_suppressions() {
+        const auto settings = dinit(Settings,
+                                    $.inlineSuppressions = true,
+                                        $.checks.enable (Checks::missingInclude));
+
+        const char code[] = "// cppcheck-suppress missingInclude\n"
+                            "#include \"missing.h\"\n"
+                            "// cppcheck-suppress missingIncludeSystem\n"
+                            "#include <missing2.h>\n";
+        SuppressionList inlineSuppr;
+        (void)getcodeforcfg(settings, *this, code, "", "test.c", &inlineSuppr);
+
+        auto suppressions = inlineSuppr.getSuppressions();
+        ASSERT_EQUALS(2, suppressions.size());
+
+        auto suppr = suppressions.front();
+        suppressions.pop_front();
+        ASSERT_EQUALS("missingInclude", suppr.errorId);
+        ASSERT_EQUALS("test.c", suppr.fileName);
+        ASSERT_EQUALS(2, suppr.lineNumber);
+        ASSERT_EQUALS(false, suppr.checked);
+        ASSERT_EQUALS(false, suppr.matched);
+
+        suppr = suppressions.front();
+        suppressions.pop_front();
+        ASSERT_EQUALS("missingIncludeSystem", suppr.errorId);
+        ASSERT_EQUALS("test.c", suppr.fileName);
+        ASSERT_EQUALS(4, suppr.lineNumber);
+        ASSERT_EQUALS(false, suppr.checked);
+        ASSERT_EQUALS(false, suppr.matched);
+
+        ignore_errout(); // we are not interested in the output
+    }
+
+    void inline_suppressions_not_next_line() {
+        const auto settings = dinit(Settings,
+                                    $.inlineSuppressions = true,
+                                        $.checks.enable (Checks::missingInclude));
+
+        const char code[] = "// cppcheck-suppress missingInclude\n"
+                            "// some other comment\n"
+                            "#include \"missing.h\"\n"
+                            "// cppcheck-suppress missingIncludeSystem\n"
+                            "\n" // Empty line
+                            "#include <missing2.h>\n";
+        SuppressionList inlineSuppr;
+        (void)getcodeforcfg(settings, *this, code, "", "test.c", &inlineSuppr);
+
+        auto suppressions = inlineSuppr.getSuppressions();
+        ASSERT_EQUALS(2, suppressions.size());
+
+        auto suppr = suppressions.front();
+        suppressions.pop_front();
+        ASSERT_EQUALS("missingInclude", suppr.errorId);
+        ASSERT_EQUALS("test.c", suppr.fileName);
+        ASSERT_EQUALS(3, suppr.lineNumber);
+
+        suppr = suppressions.front();
+        suppressions.pop_front();
+        ASSERT_EQUALS("missingIncludeSystem", suppr.errorId);
+        ASSERT_EQUALS("test.c", suppr.fileName);
+        ASSERT_EQUALS(6, suppr.lineNumber);
+
+        ignore_errout();
+    }
+
+    void remarkComment1() {
+        const char code[] = "// REMARK: assignment with 1\n"
+                            "x=1;\n";
+        const auto remarkComments = getRemarkComments(code, *this);
+        ASSERT_EQUALS(1, remarkComments.size());
+        ASSERT_EQUALS(2, remarkComments[0].lineNumber);
+        ASSERT_EQUALS("assignment with 1", remarkComments[0].str);
+    }
+
+    void remarkComment2() {
+        const char code[] = "x=1; ///REMARK assignment with 1\n";
+        const auto remarkComments = getRemarkComments(code, *this);
+        ASSERT_EQUALS(1, remarkComments.size());
+        ASSERT_EQUALS(1, remarkComments[0].lineNumber);
+        ASSERT_EQUALS("assignment with 1", remarkComments[0].str);
+    }
+
+    void remarkComment3() {
+        const char code[] = "/**   REMARK: assignment with 1 */\n"
+                            "x=1;\n";
+        const auto remarkComments = getRemarkComments(code, *this);
+        ASSERT_EQUALS(1, remarkComments.size());
+        ASSERT_EQUALS(2, remarkComments[0].lineNumber);
+        ASSERT_EQUALS("assignment with 1 ", remarkComments[0].str);
+    }
+
+    void remarkComment4() {
+        const char code[] = "//REMARK /";
+        const auto remarkComments = getRemarkComments(code, *this);
+        ASSERT_EQUALS(0, remarkComments.size());
     }
 
     void predefine1() {
-        const std::string src("#if defined X || Y\n"
-                              "Fred & Wilma\n"
-                              "#endif\n");
-        std::string actual = preprocessor0.getcode(src, "X=1", "test.c");
+        const char code[] = "#if defined X || Y\n"
+                            "Fred & Wilma\n"
+                            "#endif\n";
+        std::string actual = getcodeforcfg(settings0, *this, code, "X=1", "test.c");
 
         ASSERT_EQUALS("\nFred & Wilma", actual);
     }
 
     void predefine2() {
-        const std::string src("#if defined(X) && Y\n"
-                              "Fred & Wilma\n"
-                              "#endif\n");
+        const char code[] = "#if defined(X) && Y\n"
+                            "Fred & Wilma\n"
+                            "#endif\n";
         {
-            std::string actual = preprocessor0.getcode(src, "X=1", "test.c");
+            std::string actual = getcodeforcfg(settings0, *this, code, "X=1", "test.c");
             ASSERT_EQUALS("", actual);
         }
 
         {
-            std::string actual = preprocessor0.getcode(src, "X=1;Y=2", "test.c");
+            std::string actual = getcodeforcfg(settings0, *this, code, "X=1;Y=2", "test.c");
             ASSERT_EQUALS("\nFred & Wilma", actual);
         }
     }
@@ -1974,29 +2131,53 @@ class TestPreprocessor : public TestFixture {
                             "#if (X == Y)\n"
                             "Fred & Wilma\n"
                             "#endif\n";
-        const std::string actual = preprocessor0.getcode(code, "TEST", "test.c");
+        const std::string actual = getcodeforcfg(settings0, *this, code, "TEST", "test.c");
         ASSERT_EQUALS("\n\n\nFred & Wilma", actual);
     }
 
     void predefine4() {
         // #3577
         const char code[] = "char buf[X];\n";
-        const std::string actual = preprocessor0.getcode(code, "X=123", "test.c");
+        const std::string actual = getcodeforcfg(settings0, *this, code, "X=123", "test.c");
         ASSERT_EQUALS("char buf [ $123 ] ;", actual);
     }
 
     void predefine5() {  // #3737, #5119 - automatically define __cplusplus
         // #3737...
         const char code[] = "#ifdef __cplusplus\n123\n#endif";
-        ASSERT_EQUALS("",      preprocessor0.getcode(code, "X=123", "test.c"));
-        ASSERT_EQUALS("\n123", preprocessor0.getcode(code, "X=123", "test.cpp"));
+        ASSERT_EQUALS("",      getcodeforcfg(settings0, *this, code, "", "test.c"));
+        ASSERT_EQUALS("\n123", getcodeforcfg(settings0, *this, code, "", "test.cpp"));
+    }
+
+    void predefine6() { // automatically define __STDC_VERSION__
+        const char code[] = "#ifdef __STDC_VERSION__\n123\n#endif";
+        ASSERT_EQUALS("\n123", getcodeforcfg(settings0, *this, code, "", "test.c"));
+        ASSERT_EQUALS("",      getcodeforcfg(settings0, *this, code, "", "test.cpp"));
+    }
+
+    void strictAnsi() {
+        const char code[] = "#ifdef __STRICT_ANSI__\n123\n#endif";
+        Settings settings;
+
+        settings.standards.setStd("gnu99");
+        ASSERT_EQUALS("", getcodeforcfg(settings, *this, code, "", "test.c"));
+
+        settings.standards.setStd("c99");
+        ASSERT_EQUALS("\n123", getcodeforcfg(settings, *this, code, "", "test.c"));
+
+        settings.standards.setStd("gnu++11");
+        ASSERT_EQUALS("", getcodeforcfg(settings, *this, code, "", "test.cpp"));
+
+        settings.standards.setStd("c++11");
+        ASSERT_EQUALS("\n123", getcodeforcfg(settings, *this, code, "", "test.cpp"));
     }
 
     void invalidElIf() {
         // #2942 - segfault
         const char code[] = "#elif (){\n";
-        const std::string actual = preprocessor0.getcode(code, "TEST", "test.c");
+        const std::string actual = getcodeforcfg(settings0, *this, code, "TEST", "test.c");
         ASSERT_EQUALS("", actual);
+        ASSERT_EQUALS("[test.c:1:2]: (error) #elif without #if [syntaxError]\n", errout_str());
     }
 
     void getConfigs1() {
@@ -2006,7 +2187,7 @@ class TestPreprocessor : public TestFixture {
                                 "    qwerty\n"
                                 "#endif  \n";
 
-        ASSERT_EQUALS("\nWIN32\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nWIN32=WIN32\n", getConfigsStr(filedata));
     }
 
     void getConfigs2() {
@@ -2027,7 +2208,7 @@ class TestPreprocessor : public TestFixture {
                                 "c\n"
                                 "#endif\n";
 
-        ASSERT_EQUALS("\nABC\nABC;DEF\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nABC=ABC\nABC=ABC;DEF=DEF\n", getConfigsStr(filedata));
     }
 
     void getConfigs4() {
@@ -2037,7 +2218,7 @@ class TestPreprocessor : public TestFixture {
                                 "#ifdef ABC\n"
                                 "A\n"
                                 "#endif\n";
-        ASSERT_EQUALS("\nABC\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nABC=ABC\n", getConfigsStr(filedata));
     }
 
     void getConfigs5() {
@@ -2049,7 +2230,7 @@ class TestPreprocessor : public TestFixture {
                                 "C\n"
                                 "#endif\n"
                                 "#endif\n";
-        ASSERT_EQUALS("\nABC\nDEF\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nABC=ABC\nDEF=DEF\n", getConfigsStr(filedata));
     }
 
     void getConfigs7() {
@@ -2059,7 +2240,7 @@ class TestPreprocessor : public TestFixture {
                                 "B\n"
                                 "#endif\n"
                                 "#endif\n";
-        ASSERT_EQUALS("\nABC\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nABC=ABC\n", getConfigsStr(filedata));
     }
 
     void getConfigs7a() {
@@ -2079,7 +2260,7 @@ class TestPreprocessor : public TestFixture {
                                 "B\n"
                                 "#endif\n"
                                 "#endif\n";
-        ASSERT_EQUALS("\nABC\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nABC=ABC\n", getConfigsStr(filedata));
     }
 
     void getConfigs7c() {
@@ -2089,7 +2270,7 @@ class TestPreprocessor : public TestFixture {
                                 "B\n"
                                 "#endif\n"
                                 "#endif\n";
-        ASSERT_EQUALS("\nABC\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nABC=ABC\n", getConfigsStr(filedata));
     }
 
     void getConfigs7d() {
@@ -2099,7 +2280,7 @@ class TestPreprocessor : public TestFixture {
                                 "B\n"
                                 "#endif\n"
                                 "#endif\n";
-        ASSERT_EQUALS("\nABC\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nABC=ABC\n", getConfigsStr(filedata));
     }
 
     void getConfigs7e() {
@@ -2112,7 +2293,7 @@ class TestPreprocessor : public TestFixture {
                                 "#endif\n"
                                 "#endfile\n"
                                 "#endif\n";
-        ASSERT_EQUALS("\nABC\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nABC=ABC\n", getConfigsStr(filedata));
     }
 
     void getConfigs8() {
@@ -2131,6 +2312,285 @@ class TestPreprocessor : public TestFixture {
         ASSERT_EQUALS("\n", getConfigsStr(filedata));
     }
 
+    void getConfigs11() { // #9832 - include guards
+        const char filedata[] = "#file \"test.h\"\n"
+                                "#if !defined(test_h)\n"
+                                "#define test_h\n"
+                                "123\n"
+                                "#endif\n"
+                                "#endfile\n";
+        ASSERT_EQUALS("\n", getConfigsStr(filedata));
+    }
+
+    void getConfigs12() { // #14222
+        const char filedata[] = "#ifdef INT8_MAX\n"
+                                "INT8_MAX\n"
+                                "#endif\n";
+        ASSERT_EQUALS("\n", getConfigsStr(filedata, nullptr, "std.cfg"));
+    }
+
+    void getConfigs13() { // #14222
+        const char filedata[] = "#ifdef __builtin_bswap16\n"
+                                "__builtin_bswap16(x);\n"
+                                "#endif\n";
+        ASSERT_EQUALS("\n", getConfigsStr(filedata, nullptr, "gnu.cfg"));
+    }
+
+    void getConfigs_gte() { // #1059
+        {
+            const char filedata[] = "#if A >= 1\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=1\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A >= 201112L\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=201112L\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A >= 12147483647\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=12147483647\n", getConfigsStr(filedata));
+        }
+    }
+
+    void getConfigs_lte() { // #1059
+        {
+            const char filedata[] = "#if A <= 1\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=1\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A <= 201112L\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=201112L\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A <= 12147483647\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=12147483647\n", getConfigsStr(filedata));
+        }
+    }
+
+    void getConfigs_gt() { // #1059
+        {
+            const char filedata[] = "#if A > 1\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=2\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A > 1L\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=2\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A > 1U\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=2\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A > 1UL\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=2\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A > 1Z\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=2\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A > 0x1\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=2\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A > 01\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=2\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A > 0b1\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=2\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A > 1t\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_THROW_INTERNAL_EQUALS(getConfigsStr(filedata), INTERNAL, "Internal Error. MathLib::toBigNumber: input was not completely consumed: 1t");
+        }
+        {
+            const char filedata[] = "#if A > 1.0\n"
+                                    "1\n"
+                                    "#endif\n";
+            TODO_ASSERT_THROW(getConfigsStr(filedata), InternalError); // floating point literals are not allowed
+        }
+        {
+            const char filedata[] = "#if A > 12147483647\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=12147483648\n", getConfigsStr(filedata));
+        }
+    }
+
+    void getConfigs_lt() { // #1059
+        {
+            const char filedata[] = "#if A < 1\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=0\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A < 1L\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=0\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A < 1U\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=0\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A < 1UL\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=0\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A < 1Z\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=0\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A < 0x1\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=0\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A < 01\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=0\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A < 0b1\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=0\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A < 1t\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_THROW_INTERNAL_EQUALS(getConfigsStr(filedata), INTERNAL, "Internal Error. MathLib::toBigNumber: input was not completely consumed: 1t");
+        }
+        {
+            const char filedata[] = "#if A < 1.0\n"
+                                    "1\n"
+                                    "#endif\n";
+            TODO_ASSERT_THROW(getConfigsStr(filedata), InternalError); // floating point literals are not allowed
+        }
+        {
+            const char filedata[] = "#if A < 12147483647\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=12147483646\n", getConfigsStr(filedata));
+        }
+    }
+
+    void getConfigs_eq_compound() { // #1059
+        {
+            const char filedata[] = "#if A == 1 && defined(B)\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=1;B=B\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A == 201112L && defined(B)\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=201112L;B=B\n", getConfigsStr(filedata));
+        }
+    }
+
+    void getConfigs_gte_compound() { // #1059
+        {
+            const char filedata[] = "#if A >= 1 && defined(B)\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=1;B=B\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A >= 201112L && defined(B)\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=201112L;B=B\n", getConfigsStr(filedata));
+        }
+    }
+
+    void getConfigs_lte_compound() { // #1059
+        {
+            const char filedata[] = "#if A <= 1 && defined(B)\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=1;B=B\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A <= 201112L && defined(B)\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=201112L;B=B\n", getConfigsStr(filedata));
+        }
+    }
+
+    void getConfigs_gt_compound() { // #1059
+        {
+            const char filedata[] = "#if A > 1 && defined(B)\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=2;B=B\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A > 201112L && defined(B)\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=201113;B=B\n", getConfigsStr(filedata));
+        }
+    }
+
+    void getConfigs_lt_compound() { // #1059
+        {
+            const char filedata[] = "#if A < 1 && defined(B)\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=0;B=B\n", getConfigsStr(filedata));
+        }
+        {
+            const char filedata[] = "#if A < 201112L && defined(B)\n"
+                                    "1\n"
+                                    "#endif\n";
+            ASSERT_EQUALS("\nA=201111;B=B\n", getConfigsStr(filedata));
+        }
+    }
+
     void getConfigsError() {
         const char filedata1[] = "#ifndef X\n"
                                  "#error \"!X\"\n"
@@ -2142,7 +2602,7 @@ class TestPreprocessor : public TestFixture {
                                  "#error \"!Y\"\n"
                                  "#endif\n"
                                  "#endif\n";
-        ASSERT_EQUALS("\nX\nY\n", getConfigsStr(filedata2));
+        ASSERT_EQUALS("\nX=X;Y\nY\n", getConfigsStr(filedata2));
     }
 
     void getConfigsD1() {
@@ -2152,14 +2612,14 @@ class TestPreprocessor : public TestFixture {
                                 "#endif\n"
                                 "#endif\n";
         ASSERT_EQUALS("\n", getConfigsStr(filedata, "-DX"));
-        ASSERT_EQUALS("\nX\nY\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nX=X\nY=Y\n", getConfigsStr(filedata));
     }
 
     void getConfigsU1() {
         const char filedata[] = "#ifdef X\n"
                                 "#endif\n";
         ASSERT_EQUALS("\n", getConfigsStr(filedata, "-UX"));
-        ASSERT_EQUALS("\nX\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nX=X\n", getConfigsStr(filedata));
     }
 
     void getConfigsU2() {
@@ -2183,8 +2643,8 @@ class TestPreprocessor : public TestFixture {
         const char filedata[] = "#if defined(X) || defined(Y) || defined(Z)\n"
                                 "#else\n"
                                 "#endif\n";
-        ASSERT_EQUALS("\nY;Z\n", getConfigsStr(filedata, "-UX"));
-        ASSERT_EQUALS("\nX;Y;Z\n", getConfigsStr(filedata));
+        ASSERT_EQUALS("\nY=Y;Z=Z\n", getConfigsStr(filedata, "-UX"));
+        ASSERT_EQUALS("\nX=X;Y=Y;Z=Z\n", getConfigsStr(filedata));
     }
 
     void getConfigsU5() {
@@ -2208,48 +2668,63 @@ class TestPreprocessor : public TestFixture {
         ASSERT_EQUALS("\nY\n", getConfigsStr(code, "-DX"));
     }
 
+    void getConfigsAndCodeIssue14317() {
+        const char filedata[] = "bool test() {\n"
+                                "return\n"
+                                "#if defined(isless)\n"
+                                "0 != isless(1.0, 2.0)\n"
+                                "#else\n"
+                                "0\n"
+                                "#endif\n"
+                                ";\n"
+                                "}\n";
+        // Test getConfigsStr()
+        ASSERT_EQUALS("\nisless=isless\n", getConfigsStr(filedata));
 
-    void validateCfg1() {
-        Preprocessor preprocessor(settings0, this);
-
-        std::vector<std::string> files(1, "test.c");
-        simplecpp::MacroUsage macroUsage(files, false);
-        macroUsage.useLocation.fileIndex = 0;
-        macroUsage.useLocation.line = 1;
-        macroUsage.macroName = "X";
-        std::list<simplecpp::MacroUsage> macroUsageList(1, macroUsage);
-
-        ASSERT_EQUALS(true, preprocessor.validateCfg("", macroUsageList));
-        ASSERT_EQUALS(false, preprocessor.validateCfg("X",macroUsageList));
-        ASSERT_EQUALS(false, preprocessor.validateCfg("A=42;X", macroUsageList));
-        ASSERT_EQUALS(true, preprocessor.validateCfg("X=1", macroUsageList));
-        ASSERT_EQUALS(true, preprocessor.validateCfg("Y", macroUsageList));
+        // Test getcode()
+        // Preprocess => actual result..
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, filedata);
 
-        macroUsageList.front().macroValueKnown = true; // #8404
-        ASSERT_EQUALS(true, preprocessor.validateCfg("X", macroUsageList));
+        // Expected configurations: "" and "ABC"
+        ASSERT_EQUALS(2, actual.size());
+        ASSERT_EQUALS("bool test ( ) {\nreturn\n\n\n\n0\n\n;\n}", actual.at(""));
+        ASSERT_EQUALS("bool test ( ) {\nreturn\n\n0 != $isless ( 1.0 , 2.0 )\n\n\n\n;\n}", actual.at("isless=isless"));
     }
 
-    void validateCfg2() {
-        const char filedata[] = "#ifdef ABC\n"
+    void getConfigsMostGeneralConfigIssue14317() {
+        // Verifies that the most general X (out of X=X and X) and Y=Y is returned
+        // For Z: First Z=Z is added to ret, then the ifndef else branch replaces Z=Z with the more general Z
+        const char filedata[] = "#ifdef X\n"
+                                "print(X);\n"
                                 "#endif\n"
-                                "int i = ABC;";
-
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual, "file.cpp");
-        ASSERT_EQUALS("[file.cpp:3]: (information) Skipping configuration 'ABC' since the value of 'ABC' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.\n", errout.str());
+                                "#if X\n"
+                                "print(X+1);\n"
+                                "#endif\n"
+                                "#if defined(Y)\n"
+                                "print(Y);\n"
+                                "#endif\n"
+                                "#ifdef Z\n"
+                                "print(Z);\n"
+                                "#endif\n"
+                                "#ifndef Z\n"
+                                "print(Z+1);\n"
+                                "#else\n"
+                                "print(Z+2);\n"
+                                "#endif\n";
+        // Test getConfigsStr()
+        ASSERT_EQUALS("\nX\nY=Y\nZ\n", getConfigsStr(filedata));
     }
 
     void if_sizeof() { // #4071
-        static const char* code = "#if sizeof(unsigned short) == 2\n"
-                                  "Fred & Wilma\n"
-                                  "#elif sizeof(unsigned short) == 4\n"
-                                  "Fred & Wilma\n"
-                                  "#else\n"
-                                  "#endif";
+        const char code[] = "#if sizeof(unsigned short) == 2\n"
+                            "Fred & Wilma\n"
+                            "#elif sizeof(unsigned short) == 4\n"
+                            "Fred & Wilma\n"
+                            "#else\n"
+                            "#endif";
 
-        std::map<std::string, std::string> actual;
-        preprocess(code, actual);
-        ASSERT_EQUALS("\nFred & Wilma", actual[""]);
+        const std::map<std::string, std::string> actual = getcode(settings0, *this, code);
+        ASSERT_EQUALS("\nFred & Wilma", actual.at(""));
     }
 
     void invalid_ifs() {
@@ -2265,8 +2740,10 @@ class TestPreprocessor : public TestFixture {
                                 "int x;\n";
 
         // Preprocess => don't crash..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        (void)getcode(settings0, *this, filedata);
+        ASSERT_EQUALS(
+            "[file.c:1:2]: (error) Syntax error in #ifdef [syntaxError]\n"
+            "[file.c:1:2]: (error) Syntax error in #ifdef [syntaxError]\n", errout_str());
     }
 
     void garbage() {
@@ -2275,100 +2752,380 @@ class TestPreprocessor : public TestFixture {
                                 "#if ! defined ( Y )    #endif";
 
         // Preprocess => don't crash..
-        std::map<std::string, std::string> actual;
-        preprocess(filedata, actual);
+        (void)getcode(settings0, *this, filedata);
     }
 
     void wrongPathOnErrorDirective() {
-        errout.str("");
+        const auto settings = dinit(Settings, $.userDefines = "foo");
+        const char code[] = "#error hello world!\n";
+        (void)getcodeforcfg(settings, *this, code, "X", "./././test.c");
+        ASSERT_EQUALS("[test.c:1:2]: (error) #error hello world! [preprocessorErrorDirective]\n", errout_str());
+    }
+
+    // test for existing local include
+    void testMissingInclude() {
+        const auto settings = dinit(Settings,
+                                    $.clearIncludeCache = true,
+                                        $.checks.enable (Checks::missingInclude),
+                                        $.templateFormat = "simple" // has no effect
+                                    );
+        setTemplateFormat("simple");
+
+        ScopedFile header("header.h", "");
+
+        const char code[] = "#include \"header.h\"";
+        (void)getcodeforcfg(settings, *this, code, "", "test.c");
+
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // test for missing local include
+    void testMissingInclude2() {
+        const auto settings = dinit(Settings,
+                                    $.clearIncludeCache = true,
+                                        $.checks.enable (Checks::missingInclude),
+                                        $.templateFormat = "simple" // has no effect
+                                    );
+        setTemplateFormat("simple");
+
+        const char code[] = "#include \"header.h\"";
+        (void)getcodeforcfg(settings, *this, code, "", "test.c");
+
+        ASSERT_EQUALS("test.c:1:2: information: Include file: \"header.h\" not found. [missingInclude]\n", errout_str());
+    }
+
+    // test for missing local include - no include path given
+    void testMissingInclude3() {
+        const auto settings = dinit(Settings,
+                                    $.clearIncludeCache = true,
+                                        $.checks.enable (Checks::missingInclude),
+                                        $.templateFormat = "simple" // has no effect
+                                    );
+        setTemplateFormat("simple");
+
+        ScopedFile header("header.h", "", "inc");
+
+        const char code[] = "#include \"header.h\"";
+        (void)getcodeforcfg(settings, *this, code, "", "test.c");
+
+        ASSERT_EQUALS("test.c:1:2: information: Include file: \"header.h\" not found. [missingInclude]\n", errout_str());
+    }
+
+    // test for existing local include - include path provided
+    void testMissingInclude4() {
+        const auto settings = dinit(Settings,
+                                    $.clearIncludeCache = true,
+                                        $.checks.enable (Checks::missingInclude),
+                                        $.includePaths.emplace_back ("inc"),
+                                        $.templateFormat = "simple" // has no effect
+                                    );
+        setTemplateFormat("simple");
+
+        ScopedFile header("header.h", "", "inc");
+
+        const char code[] = "#include \"inc/header.h\"";
+        (void)getcodeforcfg(settings, *this, code, "", "test.c");
+
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // test for existing local include - absolute path
+    void testMissingInclude5() {
+        const auto settings = dinit(Settings,
+                                    $.clearIncludeCache = true,
+                                        $.checks.enable (Checks::missingInclude),
+                                        $.includePaths.emplace_back ("inc"),
+                                        $.templateFormat = "simple" // has no effect
+                                    );
+        setTemplateFormat("simple");
+
+        ScopedFile header("header.h", "", Path::getCurrentPath());
+
+        std::string code("#include \"" + header.path() + "\"");
+        (void)getcodeforcfg(settings, *this, code.data(), code.size(), "", "test.c");
+
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // test for missing local include - absolute path
+    void testMissingInclude6() {
+        const auto settings = dinit(Settings,
+                                    $.clearIncludeCache = true,
+                                        $.checks.enable (Checks::missingInclude),
+                                        $.templateFormat = "simple" // has no effect
+                                    );
+        setTemplateFormat("simple");
+
+        const std::string header = Path::join(Path::getCurrentPath(), "header.h");
+
+        std::string code("#include \"" + header + "\"");
+        (void)getcodeforcfg(settings, *this, code.data(), code.size(), "", "test.c");
+
+        ASSERT_EQUALS("test.c:1:2: information: Include file: \"" + header + "\" not found. [missingInclude]\n", errout_str());
+    }
+
+    // test for missing system include - system includes are not searched for in relative path
+    void testMissingSystemInclude() {
+        const auto settings = dinit(Settings,
+                                    $.clearIncludeCache = true,
+                                        $.checks.enable (Checks::missingInclude),
+                                        $.templateFormat = "simple" // has no effect
+                                    );
+        setTemplateFormat("simple");
+
+        ScopedFile header("header.h", "");
+
+        const char code[] = "#include <header.h>";
+        (void)getcodeforcfg(settings, *this, code, "", "test.c");
+
+        ASSERT_EQUALS("test.c:1:2: information: Include file: <header.h> not found. Please note: Standard library headers do not need to be provided to get proper results. [missingIncludeSystem]\n", errout_str());
+    }
+
+    // test for missing system include
+    void testMissingSystemInclude2() {
+        const auto settings = dinit(Settings,
+                                    $.clearIncludeCache = true,
+                                        $.checks.enable (Checks::missingInclude),
+                                        $.templateFormat = "simple" // has no effect
+                                    );
+        setTemplateFormat("simple");
+
+        const char code[] = "#include <header.h>";
+        (void)getcodeforcfg(settings, *this, code, "", "test.c");
+
+        ASSERT_EQUALS("test.c:1:2: information: Include file: <header.h> not found. Please note: Standard library headers do not need to be provided to get proper results. [missingIncludeSystem]\n", errout_str());
+    }
+
+    // test for existing system include in system include path
+    void testMissingSystemInclude3() {
+        const auto settings = dinit(Settings,
+                                    $.clearIncludeCache = true,
+                                        $.checks.enable (Checks::missingInclude),
+                                        $.templateFormat = "simple", // has no effect
+                                        $.includePaths.emplace_back ("system")
+                                    );
+        setTemplateFormat("simple");
+
+        ScopedFile header("header.h", "", "system");
+
+        const char code[] = "#include <header.h>";
+        (void)getcodeforcfg(settings, *this, code, "", "test.c");
+
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // test for existing system include - absolute path
+    void testMissingSystemInclude4() {
+        const auto settings = dinit(Settings,
+                                    $.clearIncludeCache = true,
+                                        $.checks.enable (Checks::missingInclude),
+                                        $.includePaths.emplace_back ("inc");
+                                    $.templateFormat = "simple" // has no effect
+                                    );
+        setTemplateFormat("simple");
+
+        ScopedFile header("header.h", "", Path::getCurrentPath());
+
+        std::string code("#include <" + header.path() + ">");
+        (void)getcodeforcfg(settings, *this, code.data(), code.size(), "", "test.c");
+
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    // test for missing system include - absolute path
+    void testMissingSystemInclude5() {
+        const auto settings = dinit(Settings,
+                                    $.clearIncludeCache = true,
+                                        $.checks.enable (Checks::missingInclude),
+                                        $.templateFormat = "simple" // has no effect
+                                    );
+        setTemplateFormat("simple");
+
+        const std::string header = Path::join(Path::getCurrentPath(), "header.h");
+
+        std::string code("#include <" + header + ">");
+        (void)getcodeforcfg(settings, *this, code.data(), code.size(), "", "test.c");
+
+        ASSERT_EQUALS("test.c:1:2: information: Include file: <" + header + "> not found. Please note: Standard library headers do not need to be provided to get proper results. [missingIncludeSystem]\n", errout_str());
+    }
+
+    // test for missing local and system include
+    void testMissingIncludeMixed() {
+        const auto settings = dinit(Settings,
+                                    $.clearIncludeCache = true,
+                                        $.checks.enable (Checks::missingInclude),
+
+                                        $.templateFormat = "simple" // has no effect
+                                    );
+        setTemplateFormat("simple");
+
+        ScopedFile header("header.h", "");
+        ScopedFile header2("header2.h", "");
+
+        const char code[] = "#include \"missing.h\"\n"
+                            "#include <header.h>\n"
+                            "#include <missing2.h>\n"
+                            "#include \"header2.h\"";
+        (void)getcodeforcfg(settings, *this, code, "", "test.c");
+
+        ASSERT_EQUALS("test.c:1:2: information: Include file: \"missing.h\" not found. [missingInclude]\n"
+                      "test.c:2:2: information: Include file: <header.h> not found. Please note: Standard library headers do not need to be provided to get proper results. [missingIncludeSystem]\n"
+                      "test.c:3:2: information: Include file: <missing2.h> not found. Please note: Standard library headers do not need to be provided to get proper results. [missingIncludeSystem]\n", errout_str());
+    }
+
+    void testMissingIncludeCheckConfig() {
+        const auto settings = dinit(Settings,
+                                    $.clearIncludeCache = true,
+                                        $.checks.enable (Checks::missingInclude),
+                                        $.includePaths.emplace_back ("system");
+                                    $.templateFormat = "simple" // has no effect
+                                    );
+        setTemplateFormat("simple");
+
+        ScopedFile header("header.h", "");
+        ScopedFile header2("header2.h", "");
+        ScopedFile header3("header3.h", "", "system");
+        ScopedFile header4("header4.h", "", "inc");
+        ScopedFile header5("header5.h", "", Path::getCurrentPath());
+        ScopedFile header6("header6.h", "", Path::getCurrentPath());
+
+        const std::string missing3 = Path::join(Path::getCurrentPath(), "missing3.h");
+        const std::string missing4 = Path::join(Path::getCurrentPath(), "missing4.h");
+
+        std::string code("#include \"missing.h\"\n"
+                         "#include <header.h>\n"
+                         "#include <missing2.h>\n"
+                         "#include \"header2.h\"\n"
+                         "#include <header3.h>\n"
+                         "#include \"header4.h\"\n"
+                         "#include \"inc/header4.h\"\n"
+                         "#include \"" + header5.path() + "\"\n"
+                         "#include \"" + missing3 + "\"\n"
+                         "#include <" + header6.path() + ">\n"
+                         "#include <" + missing4 + ">\n");
+        (void)getcodeforcfg(settings, *this, code.data(), code.size(), "", "test.c");
+
+        ASSERT_EQUALS("test.c:1:2: information: Include file: \"missing.h\" not found. [missingInclude]\n"
+                      "test.c:2:2: information: Include file: <header.h> not found. Please note: Standard library headers do not need to be provided to get proper results. [missingIncludeSystem]\n"
+                      "test.c:3:2: information: Include file: <missing2.h> not found. Please note: Standard library headers do not need to be provided to get proper results. [missingIncludeSystem]\n"
+                      "test.c:6:2: information: Include file: \"header4.h\" not found. [missingInclude]\n"
+                      "test.c:9:2: information: Include file: \"" + missing3 + "\" not found. [missingInclude]\n"
+                      "test.c:11:2: information: Include file: <" + missing4 + "> not found. Please note: Standard library headers do not need to be provided to get proper results. [missingIncludeSystem]\n", errout_str());
+    }
+
+    void hasInclude() {
+        const char code[] = "#if __has_include(<directory/non-existent-header.h>)\n123\n#endif";
         Settings settings;
-        settings.userDefines = "foo";
-        Preprocessor preprocessor(settings, this);
-        const std::string code("#error hello world!\n");
-        preprocessor.getcode(code, "X", "./././test.c");
-        ASSERT_EQUALS("[test.c:1]: (error) #error hello world!\n", errout.str());
-    }
-
-    void testDirectiveIncludeTypes() {
-        const char filedata[] = "#define macro some definition\n"
-                                "#undef macro\n"
-                                "#ifdef macro\n"
-                                "#elif some (complex) condition\n"
-                                "#else\n"
-                                "#endif\n"
-                                "#if some other condition\n"
-                                "#pragma some proprietary content\n"
-                                "#\n" /* may appear in old C code */
-                                "#ident some text\n" /* may appear in old C code */
-                                "#unknownmacro some unpredictable text\n"
-                                "#warning some warning message\n"
-                                "#error some error message\n";
-        const char dumpdata[] = "  <directivelist>\n"
-
-                                "    <directive file=\"test.c\" linenr=\"1\" str=\"#define macro some definition\"/>\n"
-                                "    <directive file=\"test.c\" linenr=\"2\" str=\"#undef macro\"/>\n"
-                                "    <directive file=\"test.c\" linenr=\"3\" str=\"#ifdef macro\"/>\n"
-                                "    <directive file=\"test.c\" linenr=\"4\" str=\"#elif some (complex) condition\"/>\n"
-                                "    <directive file=\"test.c\" linenr=\"5\" str=\"#else\"/>\n"
-                                "    <directive file=\"test.c\" linenr=\"6\" str=\"#endif\"/>\n"
-                                "    <directive file=\"test.c\" linenr=\"7\" str=\"#if some other condition\"/>\n"
-                                "    <directive file=\"test.c\" linenr=\"8\" str=\"#pragma some proprietary content\"/>\n"
-                                "    <directive file=\"test.c\" linenr=\"9\" str=\"#\"/>\n"
-                                "    <directive file=\"test.c\" linenr=\"10\" str=\"#ident some text\"/>\n"
-                                "    <directive file=\"test.c\" linenr=\"11\" str=\"#unknownmacro some unpredictable text\"/>\n"
-                                "    <directive file=\"test.c\" linenr=\"12\" str=\"#warning some warning message\"/>\n"
-                                "    <directive file=\"test.c\" linenr=\"13\" str=\"#error some error message\"/>\n"
-                                "  </directivelist>\n";
-
-        std::ostringstream ostr;
-        Preprocessor preprocessor(settings0, this);
-        preprocessor.getcode(filedata, "", "test.c");
-        preprocessor.dump(ostr);
-        ASSERT_EQUALS(dumpdata, ostr.str());
-    }
-
-    void testDirectiveIncludeLocations() {
-        const char filedata[] = "#define macro1 val\n"
-                                "#file \"inc1.h\"\n"
-                                "#define macro2 val\n"
-                                "#file \"inc2.h\"\n"
-                                "#define macro3 val\n"
-                                "#endfile\n"
-                                "#define macro4 val\n"
-                                "#endfile\n"
-                                "#define macro5 val\n";
-        const char dumpdata[] = "  <directivelist>\n"
-                                "    <directive file=\"test.c\" linenr=\"1\" str=\"#define macro1 val\"/>\n"
-                                "    <directive file=\"test.c\" linenr=\"2\" str=\"#include &quot;inc1.h&quot;\"/>\n"
-                                "    <directive file=\"inc1.h\" linenr=\"1\" str=\"#define macro2 val\"/>\n"
-                                "    <directive file=\"inc1.h\" linenr=\"2\" str=\"#include &quot;inc2.h&quot;\"/>\n"
-                                "    <directive file=\"inc2.h\" linenr=\"1\" str=\"#define macro3 val\"/>\n"
-                                "    <directive file=\"inc1.h\" linenr=\"3\" str=\"#define macro4 val\"/>\n"
-                                "    <directive file=\"test.c\" linenr=\"3\" str=\"#define macro5 val\"/>\n"
-                                "  </directivelist>\n";
-
-        std::ostringstream ostr;
-        Preprocessor preprocessor(settings0, this);
-        preprocessor.getcode(filedata, "", "test.c");
-        preprocessor.dump(ostr);
-        ASSERT_EQUALS(dumpdata, ostr.str());
-    }
-
-    void testDirectiveIncludeComments() {
-        const char filedata[] = "#ifdef macro2 /* this will be removed */\n"
-                                "#else /* this will be removed too */\n"
-                                "#endif /* this will also be removed */\n";
-        const char dumpdata[] = "  <directivelist>\n"
-                                "    <directive file=\"test.c\" linenr=\"1\" str=\"#ifdef macro2\"/>\n"
-                                "    <directive file=\"test.c\" linenr=\"2\" str=\"#else\"/>\n"
-                                "    <directive file=\"test.c\" linenr=\"3\" str=\"#endif\"/>\n"
-                                "  </directivelist>\n";
-
-        std::ostringstream ostr;
-        Preprocessor preprocessor(settings0, this);
-        preprocessor.getcode(filedata, "", "test.c");
-        preprocessor.dump(ostr);
-        ASSERT_EQUALS(dumpdata, ostr.str());
+
+        settings.standards.setStd("c++11");
+        ASSERT_EQUALS("", getcodeforcfg(settings, *this, code, "", "test.cpp"));
+        ASSERT_EQUALS("[test.cpp:1:2]: (error) failed to evaluate #if condition, undefined function-like macro invocation: __has_include( ... ) [syntaxError]\n", errout_str()); // TODO: use individual ID
+
+        settings.standards.setStd("c++17");
+        ASSERT_EQUALS("", getcodeforcfg(settings, *this, code, "", "test.cpp"));
+        ASSERT_EQUALS("", errout_str());
+
+        settings.standards.setStd("gnu++11");
+        ASSERT_EQUALS("", getcodeforcfg(settings, *this, code, "", "test.cpp"));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void limitsDefines() {
+        // #11928 / #10045
+        const char code[] = "void f(long l) {\n"
+                            "  if (l > INT_MAX) {}\n"
+                            "}";
+        const std::string actual = getcodeforcfg(settings0, *this, code, "", "test.c");
+        ASSERT_EQUALS("void f ( long l ) {\n"
+                      "if ( l > $2147483647 ) { }\n"
+                      "}", actual);
+    }
+
+    void hashCalculation() {
+        // #12383
+        const char code[] = "int a;";
+        const char code2[] = "int  a;"; // extra space
+        const char code3[] = "\n\nint a;"; // extra new line
+
+        ASSERT_EQUALS(getHash(code), getHash(code));
+        ASSERT_EQUALS(getHash(code2), getHash(code2));
+        ASSERT_EQUALS(getHash(code3), getHash(code3));
+        ASSERT(getHash(code) != getHash(code2));
+        ASSERT(getHash(code) != getHash(code3));
+        ASSERT(getHash(code2) != getHash(code3));
+    }
+
+    void standard() {
+
+        const char code[] = "int a;";
+        // TODO: this bypasses the standard determined from the settings - the parameter should not be exposed
+        simplecpp::DUI dui;
+
+        {
+            dui.std = "c89";
+            std::vector<std::string> files;
+            TokenList tokenlist{settingsDefault, Standards::Language::CPP};
+            preprocess(code, files, "test.cpp", tokenlist, dui);
+            ASSERT(tokenlist.front());
+        }
+
+        {
+            dui.std = "gnu23";
+            std::vector<std::string> files;
+            TokenList tokenlist{settingsDefault, Standards::Language::CPP};
+            preprocess(code, files, "test.cpp", tokenlist, dui);
+            ASSERT(tokenlist.front());
+        }
+
+        {
+            dui.std = "c++98";
+            std::vector<std::string> files;
+            TokenList tokenlist{settingsDefault, Standards::Language::CPP};
+            preprocess(code, files, "test.cpp", tokenlist, dui);
+            ASSERT(tokenlist.front());
+        }
+
+        {
+            dui.std = "gnu++26";
+            std::vector<std::string> files;
+            TokenList tokenlist{settingsDefault, Standards::Language::CPP};
+            preprocess(code, files, "test.cpp", tokenlist, dui);
+            ASSERT(tokenlist.front());
+        }
+
+        {
+            dui.std = "gnu77";
+            std::vector<std::string> files;
+            TokenList tokenlist{settingsDefault, Standards::Language::CPP};
+            // TODO: can this happen from application code? if yes we need to turn it into a proper error
+            ASSERT_THROW_EQUALS(preprocess(code, files, "test.cpp", tokenlist, dui), std::runtime_error, "unexpected simplecpp::Output type 9");
+            ASSERT(!tokenlist.front()); // nothing is tokenized when an unknown standard is provided
+        }
+    }
+
+    void writeLocations()
+    {
+        const char inc[] = "class A {\n"
+                           "public:\n"
+                           "    void f() {}\n"
+                           "};";
+        const char code[] = R"(#include "test.h")";
+        ScopedFile header("test.h", inc);
+        const std::string processed = getcodeforcfg(settingsDefault, *this, code, "", "test.cpp");
+        ASSERT_EQUALS(
+            "\n"
+            "#line 1 \"test.h\"\n"
+            "class A {\n"
+            "public :\n"
+            "void f ( ) { }\n"
+            "} ;",
+            processed);
+    }
+
+    void pragmaAsm()
+    {
+        const char code[] = "#pragma asm";
+        ASSERT_THROW_INTERNAL(getcodeforcfg(settingsDefault, *this, code, "", "test.cpp"), InternalError::SYNTAX);
     }
 };
 
diff --git a/test/testprocessexecutor.cpp b/test/testprocessexecutor.cpp
new file mode 100644
index 00000000000..927c1f44723
--- /dev/null
+++ b/test/testprocessexecutor.cpp
@@ -0,0 +1,347 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+#include "fixture.h"
+
+#ifdef HAS_THREADING_MODEL_FORK
+#include "filesettings.h"
+#include "helpers.h"
+#include "processexecutor.h"
+#include "redirect.h"
+#include "settings.h"
+#include "standards.h"
+#include "suppressions.h"
+#include "timer.h"
+
+#include <cstdlib>
+#include <list>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
+#endif // HAS_THREADING_MODEL_FORK
+
+class TestProcessExecutorBase : public TestFixture {
+public:
+    TestProcessExecutorBase(const char * const name, bool useFS)
+        : TestFixture(name)
+#ifdef HAS_THREADING_MODEL_FORK
+        , useFS(useFS)
+#endif // HAS_THREADING_MODEL_FORK
+    {
+        (void)useFS;
+    }
+
+private:
+#ifdef HAS_THREADING_MODEL_FORK
+    /*const*/ Settings settings = settingsBuilder().library("std.cfg").build();
+    bool useFS;
+
+    std::string fprefix() const
+    {
+        if (useFS)
+            return "processfs";
+        return "process";
+    }
+
+    struct CheckOptions
+    {
+        bool quiet = true;
+        ShowTime showtime = ShowTime::NONE;
+        const char* plistOutput = nullptr;
+        std::vector<std::string> filesList;
+    };
+
+    /**
+     * Execute check using n jobs for y files which are have
+     * identical data, given within data.
+     */
+    void check(unsigned int jobs, int files, int result, const std::string &data, const CheckOptions& opt = make_default_obj{}) {
+        std::list<FileSettings> fileSettings;
+
+        std::list<FileWithDetails> filelist;
+        if (opt.filesList.empty()) {
+            for (int i = 1; i <= files; ++i) {
+                std::string f_s = fprefix() + "_" + std::to_string(i) + ".c";
+                filelist.emplace_back(f_s, Standards::Language::C, data.size());
+                if (useFS) {
+                    fileSettings.emplace_back(std::move(f_s), Standards::Language::C, data.size());
+                }
+            }
+        }
+        else {
+            for (const auto& f : opt.filesList)
+            {
+                filelist.emplace_back(f, Standards::Language::C, data.size());
+                if (useFS) {
+                    fileSettings.emplace_back(f, Standards::Language::C, data.size());
+                }
+            }
+        }
+
+        /*const*/ Settings s = settings;
+        s.jobs = jobs;
+        s.showtime = opt.showtime;
+        s.quiet = opt.quiet;
+        if (opt.plistOutput)
+            s.plistOutput = opt.plistOutput;
+        s.templateFormat = "{callstack}: ({severity}) {inconclusive:inconclusive: }{message}";
+        Suppressions supprs;
+        TimerResults timerResults;
+
+        // NOLINTNEXTLINE(performance-unnecessary-value-param)
+        auto executeFn = [](std::string,std::vector<std::string>,std::string,std::string&){
+            return EXIT_SUCCESS;
+        };
+
+        std::vector<std::unique_ptr<ScopedFile>> scopedfiles;
+        scopedfiles.reserve(filelist.size());
+        for (auto i = filelist.cbegin(); i != filelist.cend(); ++i)
+            scopedfiles.emplace_back(new ScopedFile(i->path(), data));
+
+        // clear files list so only fileSettings are used
+        if (useFS)
+            filelist.clear();
+
+        ProcessExecutor executor(filelist, fileSettings, s, supprs, *this, &timerResults, executeFn);
+        ASSERT_EQUALS(result, executor.check());
+    }
+#endif // HAS_THREADING_MODEL_FORK
+
+    void run() override {
+        mNewTemplate = true;
+#ifdef HAS_THREADING_MODEL_FORK
+        TEST_CASE(deadlock_with_many_errors);
+        TEST_CASE(many_threads);
+        TEST_CASE(many_threads_showtime);
+        TEST_CASE(many_threads_plist);
+        TEST_CASE(no_errors_more_files);
+        TEST_CASE(no_errors_less_files);
+        TEST_CASE(no_errors_equal_amount_files);
+        TEST_CASE(one_error_less_files);
+        TEST_CASE(one_error_several_files);
+        TEST_CASE(showtime_top5_file);
+        TEST_CASE(showtime_top5_summary);
+        TEST_CASE(showtime_file);
+        TEST_CASE(showtime_summary);
+        TEST_CASE(showtime_file_total);
+        TEST_CASE(suppress_error_library);
+        TEST_CASE(unique_errors);
+#endif // HAS_THREADING_MODEL_FORK
+    }
+
+#ifdef HAS_THREADING_MODEL_FORK
+    void deadlock_with_many_errors() {
+        std::ostringstream oss;
+        oss << "void f()\n"
+            << "{\n";
+        const int num_err = 1;
+        for (int i = 0; i < num_err; i++) {
+            oss << "  (void)(*((int*)0));\n";
+        }
+        oss << "}\n";
+        const int num_files = 3;
+        check(2, num_files, num_files, oss.str());
+        ASSERT_EQUALS(1LL * num_err * num_files, cppcheck::count_all_of(errout_str(), "(error) Null pointer dereference: (int*)0"));
+    }
+
+    void many_threads() {
+        const int num_files = 100;
+        check(16, num_files, num_files,
+              "void f()\n"
+              "{\n"
+              "  (void)(*((int*)0));\n"
+              "}");
+        ASSERT_EQUALS(num_files, cppcheck::count_all_of(errout_str(), "(error) Null pointer dereference: (int*)0"));
+    }
+
+    // #11249 - reports TSAN errors
+    void many_threads_showtime() {
+        SUPPRESS;
+        check(16, 100, 100,
+              "void f()\n"
+              "{\n"
+              "  (void)(*((int*)0));\n"
+              "}", dinit(CheckOptions, $.showtime = ShowTime::SUMMARY));
+        // we are not interested in the results - so just consume them
+        ignore_errout();
+    }
+
+    void many_threads_plist() {
+        const std::string plistOutput = "plist_" + fprefix() + "/";
+        ScopedFile plistFile("dummy", "", plistOutput);
+
+        check(16, 100, 100,
+              "void f()\n"
+              "{\n"
+              "  (void)(*((int*)0));\n"
+              "}", dinit(CheckOptions, $.plistOutput = plistOutput.c_str()));
+        // we are not interested in the results - so just consume them
+        ignore_errout();
+    }
+
+    void no_errors_more_files() {
+        check(2, 3, 0,
+              "int main()\n"
+              "{\n"
+              "  return 0;\n"
+              "}");
+    }
+
+    void no_errors_less_files() {
+        check(2, 1, 0,
+              "int main()\n"
+              "{\n"
+              "  return 0;\n"
+              "}");
+    }
+
+    void no_errors_equal_amount_files() {
+        check(2, 2, 0,
+              "int main()\n"
+              "{\n"
+              "  return 0;\n"
+              "}");
+    }
+
+    void one_error_less_files() {
+        check(2, 1, 1,
+              "void f()\n"
+              "{\n"
+              "  (void)(*((int*)0));\n"
+              "}");
+        ASSERT_EQUALS("[" + fprefix() + "_1.c:3:12]: (error) Null pointer dereference: (int*)0 [nullPointer]\n", errout_str());
+    }
+
+    void one_error_several_files() {
+        const int num_files = 20;
+        check(2, num_files, num_files,
+              "void f()\n"
+              "{\n"
+              "  (void)(*((int*)0));\n"
+              "}");
+        ASSERT_EQUALS(num_files, cppcheck::count_all_of(errout_str(), "(error) Null pointer dereference: (int*)0"));
+    }
+
+    // TODO: provide data which actually shows values above 0
+
+    // TODO: should this be logged only once like summary?
+    void showtime_top5_file() {
+        REDIRECT; // should not cause TSAN failures as the showtime logging is synchronized
+        check(2, 2, 0,
+              "int main() {}",
+              dinit(CheckOptions,
+                    $.showtime = ShowTime::TOP5_FILE));
+        // for each file: top5 results + overall + empty line
+        const std::string output_s = GET_REDIRECT_OUTPUT;
+        // for each file: top5 results + overall + empty line
+        TODO_ASSERT_EQUALS(static_cast<long long>(5 + 1 + 1) * 2, 0, cppcheck::count_all_of(output_s, '\n'));
+    }
+
+    void showtime_top5_summary() {
+        REDIRECT;
+        check(2, 2, 0,
+              "int main() {}",
+              dinit(CheckOptions,
+                    $.showtime = ShowTime::TOP5_SUMMARY));
+        const std::string output_s = GET_REDIRECT_OUTPUT;
+        // once: top5 results + overall + empty line
+        TODO_ASSERT_EQUALS(5 + 1 + 1, 1, cppcheck::count_all_of(output_s, '\n'));
+        // should only report the top5 once
+        ASSERT(output_s.find("1 result(s)") == std::string::npos);
+        TODO_ASSERT(output_s.find("2 result(s)") != std::string::npos);
+    }
+
+    void showtime_file() {
+        REDIRECT; // should not cause TSAN failures as the showtime logging is synchronized
+        check(2, 2, 0,
+              "int main() {}",
+              dinit(CheckOptions,
+                    $.showtime = ShowTime::FILE));
+        const std::string output_s = GET_REDIRECT_OUTPUT;
+        TODO_ASSERT_EQUALS(2, 0, cppcheck::count_all_of(output_s, "Overall time:"));
+    }
+
+    void showtime_summary() {
+        REDIRECT; // should not cause TSAN failures as the showtime logging is synchronized
+        check(2, 2, 0,
+              "int main() {}",
+              dinit(CheckOptions,
+                    $.showtime = ShowTime::SUMMARY));
+        const std::string output_s = GET_REDIRECT_OUTPUT;
+        // should only report the actual summary once
+        ASSERT(output_s.find("1 result(s)") == std::string::npos);
+        TODO_ASSERT(output_s.find("2 result(s)") != std::string::npos);
+    }
+
+    void showtime_file_total() {
+        REDIRECT; // should not cause TSAN failures as the showtime logging is synchronized
+        check(2, 2, 0,
+              "int main() {}",
+              dinit(CheckOptions,
+                    $.showtime = ShowTime::FILE_TOTAL));
+        const std::string output_s = GET_REDIRECT_OUTPUT;
+        TODO_ASSERT(output_s.find("Check time: " + fprefix() + "_1.c: ") != std::string::npos);
+        TODO_ASSERT(output_s.find("Check time: " + fprefix() + "_2.c: ") != std::string::npos);
+    }
+
+    void suppress_error_library() {
+        SUPPRESS;
+        const Settings settingsOld = settings; // TODO: get rid of this
+        const char xmldata[] = R"(<def format="2"><markup ext=".c" reporterrors="false"/></def>)";
+        settings = settingsBuilder().libraryxml(xmldata).build();
+        check(2, 1, 0,
+              "void f()\n"
+              "{\n"
+              "  (void)(*((int*)0));\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+        settings = settingsOld;
+    }
+
+    void unique_errors() {
+        SUPPRESS;
+        ScopedFile inc_h(fprefix() + ".h",
+                         "inline void f()\n"
+                         "{\n"
+                         "  (void)(*((int*)0));\n"
+                         "}");
+        check(2, 2, 2,
+              "#include \"" + inc_h.name() +"\"");
+        // this is made unique by the executor
+        ASSERT_EQUALS("[" + inc_h.name() + ":3:12]: (error) Null pointer dereference: (int*)0 [nullPointer]\n", errout_str());
+    }
+
+    // TODO: test whole program analysis
+#endif // HAS_THREADING_MODEL_FORK
+};
+
+class TestProcessExecutorFiles : public TestProcessExecutorBase {
+public:
+    TestProcessExecutorFiles() : TestProcessExecutorBase("TestProcessExecutorFiles", false) {}
+};
+
+class TestProcessExecutorFS : public TestProcessExecutorBase {
+public:
+    TestProcessExecutorFS() : TestProcessExecutorBase("TestProcessExecutorFS", true) {}
+};
+
+REGISTER_TEST(TestProcessExecutorFiles)
+REGISTER_TEST(TestProcessExecutorFS)
diff --git a/test/testprogrammemory.cpp b/test/testprogrammemory.cpp
new file mode 100644
index 00000000000..688efa0075b
--- /dev/null
+++ b/test/testprogrammemory.cpp
@@ -0,0 +1,106 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+#include "fixture.h"
+#include "helpers.h"
+#include "token.h"
+#include "programmemory.h"
+#include "utils.h"
+#include "vfvalue.h"
+
+#include <stdexcept>
+
+class TestProgramMemory : public TestFixture {
+public:
+    TestProgramMemory() : TestFixture("TestProgramMemory") {}
+
+private:
+    void run() override {
+        TEST_CASE(copyOnWrite);
+        TEST_CASE(hasValue);
+        TEST_CASE(getValue);
+        TEST_CASE(at);
+    }
+
+    void copyOnWrite() const {
+        SimpleTokenList tokenlist("1+1;");
+        Token* tok = tokenlist.front();
+        const nonneg int id = 123;
+        tok->exprId(id);
+
+        ProgramMemory pm;
+        const ValueFlow::Value* v = pm.getValue(id);
+        ASSERT(!v);
+        pm.setValue(tok, ValueFlow::Value{41});
+
+        v = pm.getValue(id);
+        ASSERT(v);
+        ASSERT_EQUALS(41, v->intvalue);
+
+        // create a copy
+        ProgramMemory pm2 = pm;
+
+        // make sure the value was copied
+        v = pm2.getValue(id);
+        ASSERT(v);
+        ASSERT_EQUALS(41, v->intvalue);
+
+        // set a value in the copy to trigger copy-on-write
+        pm2.setValue(tok, ValueFlow::Value{42});
+
+        // make another copy and set another value
+        ProgramMemory pm3 = pm2;
+
+        // set a value in the copy to trigger copy-on-write
+        pm3.setValue(tok, ValueFlow::Value{43});
+
+        // make sure the value was set
+        v = pm2.getValue(id);
+        ASSERT(v);
+        ASSERT_EQUALS(42, v->intvalue);
+
+        // make sure the value was set
+        v = pm3.getValue(id);
+        ASSERT(v);
+        ASSERT_EQUALS(43, v->intvalue);
+
+        // make sure the original value remains unchanged
+        v = pm.getValue(id);
+        ASSERT(v);
+        ASSERT_EQUALS(41, v->intvalue);
+    }
+
+    void hasValue() const {
+        ProgramMemory pm;
+        ASSERT(!pm.hasValue(123));
+    }
+
+    void getValue() const {
+        ProgramMemory pm;
+        ASSERT(!pm.getValue(123));
+    }
+
+    void at() const {
+        ProgramMemory pm;
+        ASSERT_THROW_EQUALS(pm.at(123), std::out_of_range, "ProgramMemory::at");
+        ASSERT_THROW_EQUALS(utils::as_const(pm).at(123), std::out_of_range, "ProgramMemory::at");
+    }
+};
+
+REGISTER_TEST(TestProgramMemory)
diff --git a/test/testregex.cpp b/test/testregex.cpp
new file mode 100644
index 00000000000..628ec3e6f5d
--- /dev/null
+++ b/test/testregex.cpp
@@ -0,0 +1,195 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifdef HAVE_RULES
+
+#include "fixture.h"
+#include "regex.h"
+
+#include <list>
+#include <memory>
+#include <string>
+#include <utility>
+
+class TestRegEx : public TestFixture {
+public:
+    TestRegEx() : TestFixture("TestRegEx") {}
+
+private:
+    void run() override {
+        TEST_CASE(match);
+        TEST_CASE(nomatch);
+        TEST_CASE(compileError);
+        TEST_CASE(copy);
+        TEST_CASE(multimatch);
+        TEST_CASE(partialmatch);
+        TEST_CASE(exactmatch);
+    }
+
+#define assertRegex(...) assertRegex_(__FILE__, __LINE__, __VA_ARGS__)
+    std::shared_ptr<Regex> assertRegex_(const char* file, int line, std::string pattern, const std::string& exp_err = "") const {
+        std::string regex_err;
+        auto r = Regex::create(std::move(pattern), regex_err);
+        if (exp_err.empty())
+            ASSERT_LOC(!!r.get(), file, line);
+        else
+            ASSERT_LOC(!r.get(), file, line); // only not set if we encountered an error
+        ASSERT_EQUALS_LOC(exp_err, regex_err, file, line);
+        return r;
+    }
+
+    void match() const {
+        const auto r = assertRegex("begin.*end");
+        int called = 0;
+        int s = -1;
+        int e = -1;
+        auto f = [&](int start, int end) {
+            ++called;
+            s = start;
+            e = end;
+        };
+        ASSERT_EQUALS("", r->match("begin-123-end", std::move(f)));
+        ASSERT_EQUALS(1, called);
+        ASSERT_EQUALS(0, s);
+        ASSERT_EQUALS(13, e);
+    }
+
+    void nomatch() const {
+        const auto r = assertRegex("begin.*end");
+        int called = 0;
+        auto f = [&](int /*start*/, int /*end*/) {
+            ++called;
+        };
+        ASSERT_EQUALS("", r->match("end-123-begin", std::move(f)));
+        ASSERT_EQUALS(0, called);
+    }
+
+    void compileError() const {
+        (void)assertRegex("[", "pcre_compile failed: missing terminating ] for character class");
+    }
+
+    void copy() const {
+        const auto r = assertRegex("begin.*end");
+
+        int called = 0;
+        int s = -1;
+        int e = -1;
+        auto f = [&](int start, int end) {
+            ++called;
+            s = start;
+            e = end;
+        };
+
+        {
+            // NOLINTNEXTLINE(performance-unnecessary-copy-initialization)
+            auto r2 = r;
+            ASSERT_EQUALS("", r2->match("begin-123-end", f));
+            ASSERT_EQUALS(1, called);
+            ASSERT_EQUALS(0, s);
+            ASSERT_EQUALS(13, e);
+        }
+
+        called = 0;
+        s = -1;
+        e = -1;
+        ASSERT_EQUALS("", r->match("begin-123-end", f));
+        ASSERT_EQUALS(1, called);
+        ASSERT_EQUALS(0, s);
+        ASSERT_EQUALS(13, e);
+    }
+
+    void multimatch() const {
+        const auto r = assertRegex("info:.*");
+
+        std::string input =
+            "info: start\n"
+            "info: init\n"
+            "warn: missing\n"
+            "warn: invalid\n"
+            "info: done\n"
+            "error: notclean\n";
+
+        std::list<std::string> matches;
+        auto f = [&](int start, int end) {
+            matches.push_back(input.substr(start, end - start));
+        };
+        ASSERT_EQUALS("", r->match(input, std::move(f)));
+        ASSERT_EQUALS(3, matches.size());
+        auto it = matches.cbegin();
+        ASSERT_EQUALS("info: start", *it);
+        ASSERT_EQUALS("info: init", *(++it));
+        ASSERT_EQUALS("info: done", *(++it));
+    }
+
+    void partialmatch() const {
+        const auto r = assertRegex("123");
+        int called = 0;
+        int s = -1;
+        int e = -1;
+        auto f = [&](int start, int end) {
+            ++called;
+            s = start;
+            e = end;
+        };
+        ASSERT_EQUALS("", r->match("begin-123-end", std::move(f)));
+        ASSERT_EQUALS(1, called);
+        ASSERT_EQUALS(6, s);
+        ASSERT_EQUALS(9, e);
+    }
+
+    void exactmatch() const {
+        const auto r = assertRegex("^123$");
+
+        int called = 0;
+        int s = -1;
+        int e = -1;
+        auto f = [&](int start, int end) {
+            ++called;
+            s = start;
+            e = end;
+        };
+
+        ASSERT_EQUALS("", r->match("begin-123-end", f));
+        ASSERT_EQUALS(0, called);
+        ASSERT_EQUALS(-1, s);
+        ASSERT_EQUALS(-1, e);
+
+        ASSERT_EQUALS("", r->match("123\n123", f));
+        ASSERT_EQUALS(0, called);
+        ASSERT_EQUALS(-1, s);
+        ASSERT_EQUALS(-1, e);
+
+        ASSERT_EQUALS("", r->match("123123", f));
+        ASSERT_EQUALS(0, called);
+        ASSERT_EQUALS(-1, s);
+        ASSERT_EQUALS(-1, e);
+
+        ASSERT_EQUALS("", r->match("123", f));
+        ASSERT_EQUALS(1, called);
+        ASSERT_EQUALS(0, s);
+        ASSERT_EQUALS(3, e);
+    }
+
+    // TODO: how to provoke a match() error?
+
+#undef assertRegex
+};
+
+REGISTER_TEST(TestRegEx)
+
+#endif // HAVE_RULES
diff --git a/test/testrunner.vcxproj b/test/testrunner.vcxproj
index d37a615042d..1c5230c5535 100755
--- a/test/testrunner.vcxproj
+++ b/test/testrunner.vcxproj
@@ -1,314 +1,345 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\lib\cppcheck.vcxproj">
-      <Project>{c183db5b-ad6c-423d-80ca-1f9549555a1a}</Project>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="..\cli\cmdlineparser.cpp" />
-    <ClCompile Include="..\cli\cppcheckexecutor.cpp" />
-    <ClCompile Include="..\cli\filelister.cpp" />
-    <ClCompile Include="..\cli\threadexecutor.cpp" />
-    <ClCompile Include="..\lib\astutils.cpp" />
-    <ClCompile Include="options.cpp" />
-    <ClCompile Include="test64bit.cpp" />
-    <ClCompile Include="testassert.cpp" />
-    <ClCompile Include="testastutils.cpp" />
-    <ClCompile Include="testautovariables.cpp" />
-    <ClCompile Include="testbool.cpp" />
-    <ClCompile Include="testboost.cpp" />
-    <ClCompile Include="testbufferoverrun.cpp" />
-    <ClCompile Include="testcharvar.cpp" />
-    <ClCompile Include="testclass.cpp" />
-    <ClCompile Include="testcmdlineparser.cpp" />
-    <ClCompile Include="testcondition.cpp" />
-    <ClCompile Include="testconstructors.cpp" />
-    <ClCompile Include="testcppcheck.cpp" />
-    <ClCompile Include="testerrorlogger.cpp" />
-    <ClCompile Include="testexceptionsafety.cpp" />
-    <ClCompile Include="testexprengine.cpp" />
-    <ClCompile Include="testfilelister.cpp" />
-    <ClCompile Include="testgarbage.cpp" />
-    <ClCompile Include="testimportproject.cpp" />
-    <ClCompile Include="testincompletestatement.cpp" />
-    <ClCompile Include="testinternal.cpp" />
-    <ClCompile Include="testio.cpp" />
-    <ClCompile Include="testleakautovar.cpp" />
-    <ClCompile Include="testlibrary.cpp" />
-    <ClCompile Include="testmathlib.cpp" />
-    <ClCompile Include="testmemleak.cpp" />
-    <ClCompile Include="testnullpointer.cpp" />
-    <ClCompile Include="testfunctions.cpp" />
-    <ClCompile Include="testoptions.cpp" />
-    <ClCompile Include="testother.cpp" />
-    <ClCompile Include="testpath.cpp" />
-    <ClCompile Include="testpathmatch.cpp" />
-    <ClCompile Include="testplatform.cpp" />
-    <ClCompile Include="testpostfixoperator.cpp" />
-    <ClCompile Include="testpreprocessor.cpp" />
-    <ClCompile Include="testrunner.cpp" />
-    <ClCompile Include="testsamples.cpp" />
-    <ClCompile Include="testsimplifytemplate.cpp" />
-    <ClCompile Include="testsimplifytokens.cpp" />
-    <ClCompile Include="testsimplifytypedef.cpp" />
-    <ClCompile Include="testsimplifyusing.cpp" />
-    <ClCompile Include="testsizeof.cpp" />
-    <ClCompile Include="teststl.cpp" />
-    <ClCompile Include="teststring.cpp" />
-    <ClCompile Include="testsuite.cpp">
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
-      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
-    </ClCompile>
-    <ClCompile Include="testsuppressions.cpp" />
-    <ClCompile Include="testsymboldatabase.cpp" />
-    <ClCompile Include="testthreadexecutor.cpp" />
-    <ClCompile Include="testtimer.cpp" />
-    <ClCompile Include="testtoken.cpp" />
-    <ClCompile Include="testtokenize.cpp" />
-    <ClCompile Include="testtokenlist.cpp" />
-    <ClCompile Include="testtype.cpp" />
-    <ClCompile Include="testuninitvar.cpp" />
-    <ClCompile Include="testunusedfunctions.cpp" />
-    <ClCompile Include="testunusedprivfunc.cpp" />
-    <ClCompile Include="testunusedvar.cpp" />
-    <ClCompile Include="testvaarg.cpp" />
-    <ClCompile Include="testvalueflow.cpp" />
-    <ClCompile Include="testvarid.cpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="..\cli\cmdlineparser.h" />
-    <ClInclude Include="..\cli\filelister.h" />
-    <ClInclude Include="..\cli\threadexecutor.h" />
-    <ClInclude Include="..\lib\config.h" />
-    <ClInclude Include="options.h" />
-    <ClInclude Include="redirect.h" />
-    <ClInclude Include="testsuite.h" />
-    <ClInclude Include="testutils.h" />
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}</ProjectGuid>
-    <RootNamespace>testrunner</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <CharacterSet>Unicode</CharacterSet>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <PlatformToolset>v142</PlatformToolset>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings" />
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">..\bin\debug\</OutDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">..\bin\debug\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">temp\$(Configuration)_$(PlatformName)\</IntDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">testrunner</TargetName>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">testrunner</TargetName>
-    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</IgnoreImportLibrary>
-    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</IgnoreImportLibrary>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">..\bin\</OutDir>
-    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">..\bin\</OutDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">temp\$(Configuration)_$(PlatformName)\</IntDir>
-    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">testrunner</TargetName>
-    <TargetName Condition="'$(Configuration)|$(Platform)'=='Release|x64'">testrunner</TargetName>
-    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</IgnoreImportLibrary>
-    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</IgnoreImportLibrary>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
-    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</LinkIncremental>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>..\cli;..\lib;..\externals;..\externals\simplecpp;..\externals\tinyxml;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <BufferSecurityCheck>true</BufferSecurityCheck>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>CPPCHECKLIB_IMPORT;SIMPLECPP_IMPORT;WIN32;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <WarningLevel>Level4</WarningLevel>
-      <DisableSpecificWarnings>4251;4482;4512</DisableSpecificWarnings>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>testsuite.h</PrecompiledHeaderFile>
-      <ForcedIncludeFiles>testsuite.h</ForcedIncludeFiles>
-      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
-      <LanguageStandard>stdcpplatest</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <SubSystem>Console</SubSystem>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <LargeAddressAware>true</LargeAddressAware>
-      <StackReserveSize>8000000</StackReserveSize>
-      <StackCommitSize>8000000</StackCommitSize>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>..\cli;..\lib;..\externals;..\externals\simplecpp;..\externals\tinyxml;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <BufferSecurityCheck>true</BufferSecurityCheck>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <Optimization>Disabled</Optimization>
-      <PreprocessorDefinitions>CPPCHECKLIB_IMPORT;SIMPLECPP_IMPORT;WIN32;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;_WIN64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <WarningLevel>Level4</WarningLevel>
-      <DisableSpecificWarnings>4251;4482;4512</DisableSpecificWarnings>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>testsuite.h</PrecompiledHeaderFile>
-      <ForcedIncludeFiles>testsuite.h</ForcedIncludeFiles>
-      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
-      <LanguageStandard>stdcpplatest</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <SubSystem>Console</SubSystem>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <StackReserveSize>8000000</StackReserveSize>
-      <StackCommitSize>8000000</StackCommitSize>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>..\cli;..\lib;..\externals;..\externals\simplecpp;..\externals\tinyxml;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <BufferSecurityCheck>false</BufferSecurityCheck>
-      <Optimization>MaxSpeed</Optimization>
-      <PreprocessorDefinitions>CPPCHECKLIB_IMPORT;SIMPLECPP_IMPORT;NDEBUG;WIN32;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <WarningLevel>Level4</WarningLevel>
-      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
-      <OmitFramePointers>true</OmitFramePointers>
-      <StringPooling>true</StringPooling>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <DisableSpecificWarnings>4251;4482;4512</DisableSpecificWarnings>
-      <DebugInformationFormat>
-      </DebugInformationFormat>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>testsuite.h</PrecompiledHeaderFile>
-      <ForcedIncludeFiles>testsuite.h</ForcedIncludeFiles>
-      <AdditionalOptions>/Zc:inline /Zc:throwingNew %(AdditionalOptions)</AdditionalOptions>
-      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
-      <LanguageStandard>stdcpplatest</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <SubSystem>Console</SubSystem>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <OptimizeReferences>true</OptimizeReferences>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <SetChecksum>true</SetChecksum>
-      <LargeAddressAware>true</LargeAddressAware>
-      <StackReserveSize>8000000</StackReserveSize>
-      <StackCommitSize>8000000</StackCommitSize>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <ClCompile>
-      <AdditionalIncludeDirectories>..\cli;..\lib;..\externals;..\externals\simplecpp;..\externals\tinyxml;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <BufferSecurityCheck>false</BufferSecurityCheck>
-      <Optimization>MaxSpeed</Optimization>
-      <PreprocessorDefinitions>CPPCHECKLIB_IMPORT;SIMPLECPP_IMPORT;NDEBUG;WIN32;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;_WIN64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <WarningLevel>Level4</WarningLevel>
-      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
-      <OmitFramePointers>true</OmitFramePointers>
-      <StringPooling>true</StringPooling>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <DisableSpecificWarnings>4251;4482;4512</DisableSpecificWarnings>
-      <DebugInformationFormat>
-      </DebugInformationFormat>
-      <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <PrecompiledHeader>Use</PrecompiledHeader>
-      <PrecompiledHeaderFile>testsuite.h</PrecompiledHeaderFile>
-      <ForcedIncludeFiles>testsuite.h</ForcedIncludeFiles>
-      <AdditionalOptions>/Zc:inline /Zc:throwingNew %(AdditionalOptions)</AdditionalOptions>
-      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
-      <LanguageStandard>stdcpplatest</LanguageStandard>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <DataExecutionPrevention>true</DataExecutionPrevention>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <IgnoreImportLibrary>true</IgnoreImportLibrary>
-      <SubSystem>Console</SubSystem>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <OptimizeReferences>true</OptimizeReferences>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <SetChecksum>true</SetChecksum>
-      <StackReserveSize>8000000</StackReserveSize>
-      <StackCommitSize>8000000</StackCommitSize>
-    </Link>
-  </ItemDefinitionGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets" />
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug-PCRE|x64">
+      <Configuration>Debug-PCRE</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release-PCRE|x64">
+      <Configuration>Release-PCRE</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\lib\cppcheck.vcxproj">
+      <Project>{c183db5b-ad6c-423d-80ca-1f9549555a1a}</Project>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup Label="SourceFiles">
+    <ClCompile Include="..\cli\cmdlineparser.cpp" />
+    <ClCompile Include="..\cli\cppcheckexecutor.cpp" />
+    <ClCompile Include="..\cli\executor.cpp" />
+    <ClCompile Include="..\cli\filelister.cpp" />
+    <ClCompile Include="..\cli\processexecutor.cpp" />
+    <ClCompile Include="..\cli\sehwrapper.cpp" />
+    <ClCompile Include="..\cli\signalhandler.cpp" />
+    <ClCompile Include="..\cli\singleexecutor.cpp" />
+    <ClCompile Include="..\cli\stacktrace.cpp" />
+    <ClCompile Include="..\cli\threadexecutor.cpp" />
+    <ClCompile Include="..\frontend\frontend.cpp" />
+    <ClCompile Include="fixture.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="helpers.cpp" />
+    <ClCompile Include="main.cpp" />
+    <ClCompile Include="options.cpp" />
+    <ClCompile Include="test64bit.cpp" />
+    <ClCompile Include="testanalyzerinformation.cpp" />
+    <ClCompile Include="testassert.cpp" />
+    <ClCompile Include="testastutils.cpp" />
+    <ClCompile Include="testautovariables.cpp" />
+    <ClCompile Include="testbool.cpp" />
+    <ClCompile Include="testbufferoverrun.cpp" />
+    <ClCompile Include="testcharvar.cpp" />
+    <ClCompile Include="testcheck.cpp" />
+    <ClCompile Include="testcheckersreport.cpp" />
+    <ClCompile Include="testclangimport.cpp" />
+    <ClCompile Include="testclass.cpp" />
+    <ClCompile Include="testcmdlineparser.cpp" />
+    <ClCompile Include="testcolor.cpp" />
+    <ClCompile Include="testcondition.cpp" />
+    <ClCompile Include="testconstructors.cpp" />
+    <ClCompile Include="testcppcheck.cpp" />
+    <ClCompile Include="testerrorlogger.cpp" />
+    <ClCompile Include="testexceptionsafety.cpp" />
+    <ClCompile Include="testexecutor.cpp" />
+    <ClCompile Include="testfilelister.cpp" />
+    <ClCompile Include="testfilesettings.cpp" />
+    <ClCompile Include="testfrontend.cpp" />
+    <ClCompile Include="testfunctions.cpp" />
+    <ClCompile Include="testgarbage.cpp" />
+    <ClCompile Include="testimportproject.cpp" />
+    <ClCompile Include="testincompletestatement.cpp" />
+    <ClCompile Include="testinternal.cpp" />
+    <ClCompile Include="testio.cpp" />
+    <ClCompile Include="testleakautovar.cpp" />
+    <ClCompile Include="testlibrary.cpp" />
+    <ClCompile Include="testmathlib.cpp" />
+    <ClCompile Include="testmemleak.cpp" />
+    <ClCompile Include="testnullpointer.cpp" />
+    <ClCompile Include="testoptions.cpp" />
+    <ClCompile Include="testother.cpp" />
+    <ClCompile Include="testpath.cpp" />
+    <ClCompile Include="testpathmatch.cpp" />
+    <ClCompile Include="testplatform.cpp" />
+    <ClCompile Include="testpostfixoperator.cpp" />
+    <ClCompile Include="testpreprocessor.cpp" />
+    <ClCompile Include="testprocessexecutor.cpp" />
+    <ClCompile Include="testprogrammemory.cpp" />
+    <ClCompile Include="testregex.cpp" />
+    <ClCompile Include="testsarifreport.cpp" />
+    <ClCompile Include="testsettings.cpp" />
+    <ClCompile Include="testsimplifytemplate.cpp" />
+    <ClCompile Include="testsimplifytokens.cpp" />
+    <ClCompile Include="testsimplifytypedef.cpp" />
+    <ClCompile Include="testsimplifyusing.cpp" />
+    <ClCompile Include="testsingleexecutor.cpp" />
+    <ClCompile Include="testsizeof.cpp" />
+    <ClCompile Include="teststandards.cpp" />
+    <ClCompile Include="teststl.cpp" />
+    <ClCompile Include="teststring.cpp" />
+    <ClCompile Include="testsummaries.cpp" />
+    <ClCompile Include="testsuppressions.cpp" />
+    <ClCompile Include="testsymboldatabase.cpp" />
+    <ClCompile Include="testthreadexecutor.cpp" />
+    <ClCompile Include="testtimer.cpp" />
+    <ClCompile Include="testtoken.cpp" />
+    <ClCompile Include="testtokenize.cpp" />
+    <ClCompile Include="testtokenlist.cpp" />
+    <ClCompile Include="testtokenrange.cpp" />
+    <ClCompile Include="testtype.cpp" />
+    <ClCompile Include="testuninitvar.cpp" />
+    <ClCompile Include="testunusedfunctions.cpp" />
+    <ClCompile Include="testunusedprivfunc.cpp" />
+    <ClCompile Include="testunusedvar.cpp" />
+    <ClCompile Include="testutils.cpp" />
+    <ClCompile Include="testvaarg.cpp" />
+    <ClCompile Include="testvalueflow.cpp" />
+    <ClCompile Include="testvarid.cpp" />
+    <ClCompile Include="testvfvalue.cpp" />
+  </ItemGroup>
+  <ItemGroup Label="HeaderFiles">
+    <ClInclude Include="..\cli\cmdlineparser.h" />
+    <ClInclude Include="..\cli\cppcheckexecutor.h" />
+    <ClInclude Include="..\cli\executor.h" />
+    <ClInclude Include="..\cli\filelister.h" />
+    <ClInclude Include="..\cli\processexecutor.h" />
+    <ClInclude Include="..\cli\sehwrapper.h" />
+    <ClInclude Include="..\cli\signalhandler.h" />
+    <ClInclude Include="..\cli\singleexecutor.h" />
+    <ClInclude Include="..\cli\stacktrace.h" />
+    <ClInclude Include="..\cli\threadexecutor.h" />
+    <ClInclude Include="..\frontend\frontend.h" />
+    <ClInclude Include="fixture.h" />
+    <ClInclude Include="helpers.h" />
+    <ClInclude Include="options.h" />
+    <ClInclude Include="precompiled.h" />
+    <ClInclude Include="redirect.h" />
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{4F7DCE5E-6CDE-38C4-9EA7-27AF3B25CEB4}</ProjectGuid>
+    <RootNamespace>testrunner</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+    <PlatformToolset>v142</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings" />
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">$(SolutionDir)bin\debug\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">$(SolutionDir)bin\debug\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
+    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">testrunner</TargetName>
+    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">testrunner</TargetName>
+    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</IgnoreImportLibrary>
+    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">true</IgnoreImportLibrary>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">$(SolutionDir)bin\</OutDir>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">$(SolutionDir)bin\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">temp\$(Configuration)_$(PlatformName)\</IntDir>
+    <TargetName Condition="'$(Configuration)|$(Platform)'=='Release|x64'">testrunner</TargetName>
+    <TargetName Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">testrunner</TargetName>
+    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</IgnoreImportLibrary>
+    <IgnoreImportLibrary Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">true</IgnoreImportLibrary>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</LinkIncremental>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">true</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>..\cli;..\frontend;..\lib;..\externals;..\externals\picojson;..\externals\simplecpp;..\externals\tinyxml2;$(BoostInclude);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <BufferSecurityCheck>true</BufferSecurityCheck>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>CPPCHECKLIB_IMPORT;SIMPLECPP_IMPORT;$(HaveBoost);_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <WarningLevel>Level4</WarningLevel>
+      <DisableSpecificWarnings>4018;4127;4146;4244;4251;4267;4389;4701;4706;4800;4805</DisableSpecificWarnings>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>precompiled.h</PrecompiledHeaderFile>
+      <ForcedIncludeFiles>precompiled.h</ForcedIncludeFiles>
+      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
+      <LanguageStandard>stdcpp14</LanguageStandard>
+      <AdditionalOptions>/Zc:throwingNew /Zc:__cplusplus %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <StackReserveSize>8000000</StackReserveSize>
+      <StackCommitSize>8000000</StackCommitSize>
+      <LargeAddressAware>true</LargeAddressAware>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>..\cli;..\frontend;..\lib;..\externals;..\externals\picojson;..\externals\simplecpp;..\externals\tinyxml2;$(BoostInclude);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <BufferSecurityCheck>true</BufferSecurityCheck>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>CPPCHECKLIB_IMPORT;SIMPLECPP_IMPORT;$(HaveBoost);HAVE_RULES;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
+      <WarningLevel>Level4</WarningLevel>
+      <DisableSpecificWarnings>4018;4127;4146;4244;4251;4267;4389;4701;4706;4800;4805</DisableSpecificWarnings>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>precompiled.h</PrecompiledHeaderFile>
+      <ForcedIncludeFiles>precompiled.h</ForcedIncludeFiles>
+      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
+      <LanguageStandard>stdcpp14</LanguageStandard>
+      <AdditionalOptions>/Zc:throwingNew /Zc:__cplusplus %(AdditionalOptions)</AdditionalOptions>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Console</SubSystem>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <StackReserveSize>8000000</StackReserveSize>
+      <StackCommitSize>8000000</StackCommitSize>
+      <LargeAddressAware>true</LargeAddressAware>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>..\cli;..\frontend;..\lib;..\externals;..\externals\picojson;..\externals\simplecpp;..\externals\tinyxml2;$(BoostInclude);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <Optimization>MaxSpeed</Optimization>
+      <PreprocessorDefinitions>CPPCHECKLIB_IMPORT;SIMPLECPP_IMPORT;$(HaveBoost);NDEBUG;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <WarningLevel>Level4</WarningLevel>
+      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <StringPooling>true</StringPooling>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <DisableSpecificWarnings>4018;4127;4146;4244;4251;4267;4389;4701;4706;4800;4805</DisableSpecificWarnings>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>precompiled.h</PrecompiledHeaderFile>
+      <ForcedIncludeFiles>precompiled.h</ForcedIncludeFiles>
+      <AdditionalOptions>/Zc:throwingNew /Zc:__cplusplus %(AdditionalOptions)</AdditionalOptions>
+      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
+      <LanguageStandard>stdcpp14</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <DataExecutionPrevention>true</DataExecutionPrevention>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <IgnoreImportLibrary>true</IgnoreImportLibrary>
+      <SubSystem>Console</SubSystem>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <SetChecksum>true</SetChecksum>
+      <StackReserveSize>8000000</StackReserveSize>
+      <StackCommitSize>8000000</StackCommitSize>
+      <LargeAddressAware>true</LargeAddressAware>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">
+    <ClCompile>
+      <AdditionalIncludeDirectories>..\cli;..\frontend;..\lib;..\externals;..\externals\picojson;..\externals\simplecpp;..\externals\tinyxml2;$(BoostInclude);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <Optimization>MaxSpeed</Optimization>
+      <PreprocessorDefinitions>CPPCHECKLIB_IMPORT;SIMPLECPP_IMPORT;$(HaveBoost);NDEBUG;HAVE_RULES;_CRT_SECURE_NO_WARNINGS;WIN32_LEAN_AND_MEAN;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+      <WarningLevel>Level4</WarningLevel>
+      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
+      <OmitFramePointers>true</OmitFramePointers>
+      <StringPooling>true</StringPooling>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <DisableSpecificWarnings>4018;4127;4146;4244;4251;4267;4389;4701;4706;4800;4805</DisableSpecificWarnings>
+      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+      <PrecompiledHeaderFile>precompiled.h</PrecompiledHeaderFile>
+      <ForcedIncludeFiles>precompiled.h</ForcedIncludeFiles>
+      <AdditionalOptions>/Zc:throwingNew /Zc:__cplusplus %(AdditionalOptions)</AdditionalOptions>
+      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
+      <LanguageStandard>stdcpp14</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>../externals;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <DataExecutionPrevention>true</DataExecutionPrevention>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <IgnoreImportLibrary>true</IgnoreImportLibrary>
+      <SubSystem>Console</SubSystem>
+      <SuppressStartupBanner>true</SuppressStartupBanner>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <SetChecksum>true</SetChecksum>
+      <StackReserveSize>8000000</StackReserveSize>
+      <StackCommitSize>8000000</StackCommitSize>
+      <LargeAddressAware>true</LargeAddressAware>
+    </Link>
+  </ItemDefinitionGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets" />
 </Project>
\ No newline at end of file
diff --git a/test/testrunner.vcxproj.filters b/test/testrunner.vcxproj.filters
index 9c413e6e9af..b02e6b97fa6 100644
--- a/test/testrunner.vcxproj.filters
+++ b/test/testrunner.vcxproj.filters
@@ -1,247 +1,334 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
-    </Filter>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
-    </Filter>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="options.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="test64bit.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testautovariables.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testbufferoverrun.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testcharvar.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testclass.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testcmdlineparser.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testconstructors.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testcppcheck.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testerrorlogger.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testexceptionsafety.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testfilelister.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testincompletestatement.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testmathlib.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testmemleak.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testnullpointer.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testoptions.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testother.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testpath.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testpathmatch.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testpostfixoperator.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testpreprocessor.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testrunner.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testsimplifytokens.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="teststl.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testsuite.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testsuppressions.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testsymboldatabase.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testthreadexecutor.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testtoken.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testtokenize.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testuninitvar.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testunusedfunctions.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testunusedprivfunc.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testunusedvar.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\cli\filelister.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\cli\threadexecutor.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\cli\cmdlineparser.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testio.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testboost.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testinternal.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testleakautovar.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testtimer.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\cli\cppcheckexecutor.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testbool.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testsizeof.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testassert.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testlibrary.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testvalueflow.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testsamples.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testvaarg.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="teststring.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testcondition.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testtype.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testvarid.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testsimplifytemplate.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testsimplifytypedef.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testgarbage.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testtokenlist.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testfunctions.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testimportproject.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testplatform.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testastutils.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\lib\astutils.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testsimplifyusing.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="testexprengine.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="options.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="redirect.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="testsuite.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="testutils.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\cli\filelister.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\cli\threadexecutor.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\cli\cmdlineparser.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\lib\config.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-  </ItemGroup>
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup Label="SourceFiles">
+    <ClCompile Include="options.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="test64bit.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testanalyzerinformation.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testautovariables.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testbufferoverrun.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testcharvar.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testclass.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testcmdlineparser.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testconstructors.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testcppcheck.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testerrorlogger.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testexceptionsafety.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testfilelister.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testincompletestatement.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testmathlib.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testmemleak.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testnullpointer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testoptions.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testother.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testpath.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testpathmatch.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testpostfixoperator.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testpreprocessor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testprocessexecutor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testsimplifytokens.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="teststl.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testsuppressions.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testsymboldatabase.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testthreadexecutor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testtoken.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testtokenize.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testuninitvar.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testunusedfunctions.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testunusedprivfunc.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testunusedvar.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\cli\filelister.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\cli\threadexecutor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\cli\cmdlineparser.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testio.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testinternal.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testleakautovar.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testtimer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\cli\cppcheckexecutor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testbool.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testsizeof.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testassert.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testlibrary.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testvalueflow.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testvaarg.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="teststring.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testcondition.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testtype.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testvarid.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testsimplifytemplate.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testsimplifytypedef.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testgarbage.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testtokenlist.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testfunctions.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testimportproject.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testplatform.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testastutils.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testsimplifyusing.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testutils.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testsummaries.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testtokenrange.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testclangimport.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\cli\signalhandler.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\cli\executor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\cli\processexecutor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\cli\singleexecutor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\cli\stacktrace.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="fixture.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="helpers.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="main.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testcolor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testsettings.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testsingleexecutor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testcheck.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testfilesettings.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testprogrammemory.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="teststandards.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\cli\sehwrapper.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testexecutor.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testvfvalue.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\frontend\frontend.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testfrontend.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="testregex.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup Label="HeaderFiles">
+    <ClInclude Include="options.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="redirect.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\cli\filelister.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\cli\threadexecutor.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\cli\cmdlineparser.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="precompiled.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\cli\cppcheckexecutor.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\cli\signalhandler.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\cli\executor.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\cli\processexecutor.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\cli\singleexecutor.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\cli\stacktrace.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="fixture.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="helpers.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\cli\sehwrapper.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\frontend\frontend.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/test/testsamples.cpp b/test/testsamples.cpp
deleted file mode 100644
index 5833496c943..00000000000
--- a/test/testsamples.cpp
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
-* Cppcheck - A tool for static C/C++ code analysis
-* Copyright (C) 2007-2019 Cppcheck team.
-*
-* This program is free software: you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by
-* the Free Software Foundation, either version 3 of the License, or
-* (at your option) any later version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "cppcheckexecutor.h"
-#include "errorlogger.h"
-#include "cppcheck.h"
-#include "filelister.h"
-#include "path.h"
-#include "pathmatch.h"
-#include "redirect.h"
-#include "testsuite.h"
-
-#include <algorithm>
-#include <cstddef>
-#include <cstring>
-#include <fstream>
-#include <iterator>
-#include <map>
-#include <sstream>
-#include <string>
-#include <utility>
-#include <vector>
-
-
-class TestSamples : public TestFixture {
-public:
-    TestSamples() : TestFixture("TestSamples") {
-    }
-
-private:
-
-    void run() OVERRIDE {
-        TEST_CASE(runSamples);
-        TEST_CASE(runConsoleCodePageTranslationOnWindows);
-    }
-
-    void runSamples() const {
-        REDIRECT;
-
-        std::map<std::string, std::size_t> files;
-        const std::vector<std::string> masks;
-        const PathMatch matcher(masks);
-#ifdef _WIN32
-        FileLister::recursiveAddFiles(files, "..\\samples", matcher);
-#else
-        FileLister::recursiveAddFiles(files, "samples", matcher);
-#endif
-        for (std::map<std::string, std::size_t>::const_iterator i = files.begin(); i != files.end(); ++i) {
-            if (i->first.find("memleak") != std::string::npos)
-                continue;
-            CLEAR_REDIRECT_ERROUT;
-            char* path = new char[i->first.size() + 1];
-            strcpy(path, i->first.c_str());
-            const char * const argv[] = {
-#ifdef _WIN32
-                ".\\..\\testrunner",
-#else
-                "./testrunner",
-#endif
-                "--enable=style,warning,performance,portability", "--inconclusive", "-rp", "-f", "-q", path
-            };
-            std::string filename = i->first.substr(i->first.find_last_of("/\\")+1);
-            if (filename == "good.cpp" || filename == "good.c") {
-                CppCheckExecutor exec;
-                exec.check(7, argv);
-                ASSERT_EQUALS_MSG("", GET_REDIRECT_ERROUT, i->first);
-            } else if (filename == "bad.cpp" || filename == "bad.c") {
-                CppCheckExecutor exec;
-                exec.check(7, argv);
-                std::string expected_filename = Path::getPathFromFilename(i->first) + "out.txt";
-                std::ifstream ifs(expected_filename);
-                std::string expected((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
-                std::string actual = GET_REDIRECT_ERROUT;
-                // We need some uniformization to make this work on Unix and Windows
-                std::replace(actual.begin(), actual.end(), '/', '\\'); // Uniformize slashes.
-                while (actual.find("..\\") != std::string::npos)
-                    actual.erase(actual.find("..\\"), 3); // Remove '..\'
-                ASSERT_EQUALS_MSG(expected, actual, i->first);
-            }
-            delete[] path;
-        }
-    }
-
-    class CppCheckExecutor2 : public CppCheckExecutor {
-    public:
-        void settings(const Settings &set) {
-            setSettings(set);
-        }
-
-    };
-
-    void runConsoleCodePageTranslationOnWindows() const {
-        REDIRECT;
-
-        std::vector<std::string> msgs = {
-            "ASCII",     // first entry should be using only ASCII
-            "kääk",
-            "Português"
-            //      "日本語",
-            //      "한국어",
-            //      "Русский",
-            //      "中文",
-        };
-
-        Settings set1;
-        Settings setXML;
-        setXML.xml = true;
-        setXML.xml_version = 2;
-        CppCheckExecutor2 exec;
-        exec.settings(set1);
-        CppCheckExecutor2 execXML;
-        execXML.settings(setXML);
-
-        for (std::vector<std::string>::const_iterator i = msgs.begin(); i != msgs.end(); ++i) {
-            CLEAR_REDIRECT_OUTPUT;
-            CLEAR_REDIRECT_ERROUT;
-
-            exec.reportOut(*i);
-
-            ErrorLogger::ErrorMessage errMessage;
-            errMessage.setmsg(*i);
-
-            // no xml option
-            exec.reportInfo(errMessage);
-
-#ifdef _WIN32
-            // expect changes through code page translation except for the 'ASCII' case
-            if (i == msgs.begin()) {
-                ASSERT_EQUALS(*i + "\n", GET_REDIRECT_OUTPUT);
-                ASSERT_EQUALS(*i + "\n", GET_REDIRECT_ERROUT);
-            } else {
-                ASSERT(*i + "\n" != GET_REDIRECT_OUTPUT);
-                ASSERT(*i + "\n" != GET_REDIRECT_ERROUT);
-            }
-#else
-            // do not expect any code page translation
-            ASSERT_EQUALS(*i + "\n", GET_REDIRECT_OUTPUT);
-            ASSERT_EQUALS(*i + "\n", GET_REDIRECT_ERROUT);
-#endif
-
-            CLEAR_REDIRECT_ERROUT;
-            // possible change of msg for xml option
-            // with ErrorLogger::ErrorMessage::fixInvalidChars(), plus additional XML formatting
-            execXML.reportInfo(errMessage);
-            // undo the effects of "ErrorLogger::ErrorMessage::fixInvalidChars()"
-            // replacing octal constants with characters
-            std::string myErr;
-            std::string myErrOrg = GET_REDIRECT_ERROUT;
-            std::string::const_iterator from = myErrOrg.begin();
-            while (from != myErrOrg.end()) {
-                if (*from == '\\') {
-                    ++from;
-                    unsigned c;
-                    // expect three digits
-                    std::istringstream es(std::string(from, from + 3));
-                    es >> std::oct >> c;
-                    ++from;
-                    ++from;
-                    myErr.push_back(c);
-                } else {
-                    myErr.push_back(*from);
-                }
-                ++from;
-            }
-
-            ASSERT(std::string::npos != myErr.find(*i));
-        }
-    }
-};
-
-REGISTER_TEST(TestSamples)
diff --git a/test/testsarifreport.cpp b/test/testsarifreport.cpp
new file mode 100644
index 00000000000..e9fc56d736d
--- /dev/null
+++ b/test/testsarifreport.cpp
@@ -0,0 +1,906 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "sarifreport.h"
+#include "errorlogger.h"
+#include "errortypes.h"
+#include "fixture.h"
+
+#include <cmath>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "json.h"
+
+class TestSarifReport : public TestFixture
+{
+public:
+    TestSarifReport() : TestFixture("TestSarifReport")
+    {}
+
+private:
+    void run() override
+    {
+        TEST_CASE(emptyReport);
+        TEST_CASE(singleError);
+        TEST_CASE(multipleErrors);
+        TEST_CASE(errorWithoutLocation);
+        TEST_CASE(errorWithMultipleLocations);
+        TEST_CASE(differentSeverityLevels);
+        TEST_CASE(securityRelatedErrors);
+        TEST_CASE(cweTagsPresent);
+        TEST_CASE(noCweNoSecurity);
+        TEST_CASE(inconclusiveCertainty);
+        TEST_CASE(criticalErrorId);
+        TEST_CASE(emptyDescriptions);
+        TEST_CASE(locationBoundaryValues);
+        TEST_CASE(duplicateRuleIds);
+        TEST_CASE(customProductName);
+        TEST_CASE(versionHandling);
+        TEST_CASE(securitySeverityMapping);
+        TEST_CASE(versionWithSpace);
+        TEST_CASE(customProductNameAndVersion);
+        TEST_CASE(normalizeLineColumnToOne);
+        TEST_CASE(internalAndDebugSeverity);
+        TEST_CASE(problemSeverityMapping);
+        TEST_CASE(mixedLocationAndNoLocation);
+    }
+
+    // Helper to create an ErrorMessage
+    static ErrorMessage createErrorMessage(const std::string& id,
+                                           Severity severity,
+                                           const std::string& msg,
+                                           const std::string& file = "test.cpp",
+                                           int line                = 10,
+                                           int column              = 5,
+                                           int cweId               = 0,
+                                           Certainty certainty     = Certainty::normal)
+    {
+        ErrorMessage::FileLocation loc(file, line, column);
+        ErrorMessage errorMessage({loc}, file, severity, msg, id, certainty);
+        if (cweId > 0)
+        {
+            errorMessage.cwe = CWE(cweId);
+        }
+        return errorMessage;
+    }
+
+    // Helper to parse JSON and validate structure
+    static bool parseAndValidateJson(const std::string& json, picojson::value& root)
+    {
+        std::string parseError = picojson::parse(root, json);
+        return parseError.empty() && root.is<picojson::object>();
+    }
+
+    void emptyReport()
+    {
+        SarifReport report;
+        std::string sarif = report.serialize("TestProduct");
+
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root = json.get<picojson::object>();
+        ASSERT_EQUALS("2.1.0", root.at("version").get<std::string>());
+        ASSERT(root.at("$schema").get<std::string>().find("sarif-schema-2.1.0") != std::string::npos);
+
+        // From SARIF specification (https://docs.oasis-open.org/sarif/sarif/v2.1.0/errata01/os/sarif-v2.1.0-errata01-os-complete.html#_Toc141790730):
+        // Although the order in which properties appear in a JSON object value is not semantically significant, the version property SHOULD appear first.
+        ASSERT_EQUALS("{\n  \"version\": \"2.1.0\"", sarif.substr(0,22));
+
+        const picojson::array& runs = root.at("runs").get<picojson::array>();
+        ASSERT_EQUALS(1U, runs.size());
+
+        const picojson::object& cur_run    = runs[0].get<picojson::object>();
+        const picojson::array& results = cur_run.at("results").get<picojson::array>();
+        ASSERT_EQUALS(0U, results.size());
+
+        const picojson::object& tool   = cur_run.at("tool").get<picojson::object>();
+        const picojson::object& driver = tool.at("driver").get<picojson::object>();
+        const picojson::array& rules   = driver.at("rules").get<picojson::array>();
+        ASSERT_EQUALS(0U, rules.size());
+    }
+
+    void singleError()
+    {
+        SarifReport report;
+        report.addFinding(createErrorMessage("nullPointer", Severity::error, "Null pointer dereference"));
+
+        std::string sarif = report.serialize("Cppcheck");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root = json.get<picojson::object>();
+        const picojson::array& runs  = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run  = runs[0].get<picojson::object>();
+
+        // Check results
+        const picojson::array& results = cur_run.at("results").get<picojson::array>();
+        ASSERT_EQUALS(1U, results.size());
+
+        const picojson::object& result = results[0].get<picojson::object>();
+        ASSERT_EQUALS("nullPointer", result.at("ruleId").get<std::string>());
+        ASSERT_EQUALS("error", result.at("level").get<std::string>());
+
+        const picojson::object& message = result.at("message").get<picojson::object>();
+        ASSERT_EQUALS("Null pointer dereference", message.at("text").get<std::string>());
+
+        // Check rules
+        const picojson::object& tool   = cur_run.at("tool").get<picojson::object>();
+        const picojson::object& driver = tool.at("driver").get<picojson::object>();
+        const picojson::array& rules   = driver.at("rules").get<picojson::array>();
+        ASSERT_EQUALS(1U, rules.size());
+
+        const picojson::object& rule = rules[0].get<picojson::object>();
+        ASSERT_EQUALS("nullPointer", rule.at("id").get<std::string>());
+    }
+
+    void multipleErrors()
+    {
+        SarifReport report;
+        report.addFinding(createErrorMessage("error1", Severity::error, "Error 1", "file1.cpp", 10, 5));
+        report.addFinding(createErrorMessage("error2", Severity::warning, "Error 2", "file2.cpp", 20, 10));
+        report.addFinding(createErrorMessage("error3", Severity::style, "Error 3", "file3.cpp", 30, 15));
+
+        std::string sarif = report.serialize("Cppcheck");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root = json.get<picojson::object>();
+        const picojson::array& runs  = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run  = runs[0].get<picojson::object>();
+
+        const picojson::array& results = cur_run.at("results").get<picojson::array>();
+        ASSERT_EQUALS(3U, results.size());
+
+        const picojson::object& tool   = cur_run.at("tool").get<picojson::object>();
+        const picojson::object& driver = tool.at("driver").get<picojson::object>();
+        const picojson::array& rules   = driver.at("rules").get<picojson::array>();
+        ASSERT_EQUALS(3U, rules.size());
+    }
+
+    void errorWithoutLocation()
+    {
+        SarifReport report;
+
+        // Create error without location (empty callStack)
+        ErrorMessage errorMessage(
+            {}, "test.cpp", Severity::error, "Error without location", "testError", Certainty::normal);
+        report.addFinding(errorMessage);
+
+        std::string sarif = report.serialize("Cppcheck");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root = json.get<picojson::object>();
+        const picojson::array& runs  = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run  = runs[0].get<picojson::object>();
+
+        // Should have no results (GitHub doesn't support findings without locations)
+        const picojson::array& results = cur_run.at("results").get<picojson::array>();
+        ASSERT_EQUALS(0U, results.size());
+
+        const picojson::object& tool   = cur_run.at("tool").get<picojson::object>();
+        const picojson::object& driver = tool.at("driver").get<picojson::object>();
+        const picojson::array& rules   = driver.at("rules").get<picojson::array>();
+        ASSERT_EQUALS(0U, rules.size());
+    }
+
+    void errorWithMultipleLocations()
+    {
+        SarifReport report;
+
+        ErrorMessage::FileLocation loc1("test1.cpp", 10, 5);
+        ErrorMessage::FileLocation loc2("test2.cpp", 20, 10);
+        ErrorMessage::FileLocation loc3("test3.cpp", 30, 15);
+
+        ErrorMessage errorMessage({loc1, loc2, loc3},
+                                  "test1.cpp",
+                                  Severity::error,
+                                  "Error with multiple locations",
+                                  "multiLocError",
+                                  Certainty::normal);
+        report.addFinding(errorMessage);
+
+        std::string sarif = report.serialize("Cppcheck");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root   = json.get<picojson::object>();
+        const picojson::array& runs    = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run    = runs[0].get<picojson::object>();
+        const picojson::array& results = cur_run.at("results").get<picojson::array>();
+
+        ASSERT_EQUALS(1U, results.size());
+
+        const picojson::object& result   = results[0].get<picojson::object>();
+        const picojson::array& locations = result.at("locations").get<picojson::array>();
+        ASSERT_EQUALS(3U, locations.size());
+
+        // Verify each location
+        const picojson::object& loc1Obj  = locations[0].get<picojson::object>();
+        const picojson::object& physLoc1 = loc1Obj.at("physicalLocation").get<picojson::object>();
+        const picojson::object& region1  = physLoc1.at("region").get<picojson::object>();
+        ASSERT_EQUALS(10, static_cast<int>(region1.at("startLine").get<double>()));
+        ASSERT_EQUALS(5, static_cast<int>(region1.at("startColumn").get<double>()));
+    }
+
+    void differentSeverityLevels()
+    {
+        SarifReport report;
+
+        report.addFinding(createErrorMessage("error1", Severity::error, "Error severity"));
+        report.addFinding(createErrorMessage("warning1", Severity::warning, "Warning severity"));
+        report.addFinding(createErrorMessage("style1", Severity::style, "Style severity"));
+        report.addFinding(createErrorMessage("perf1", Severity::performance, "Performance severity"));
+        report.addFinding(createErrorMessage("port1", Severity::portability, "Portability severity"));
+        report.addFinding(createErrorMessage("info1", Severity::information, "Information severity"));
+
+        std::string sarif = report.serialize("Cppcheck");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root = json.get<picojson::object>();
+        const picojson::array& runs  = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run  = runs[0].get<picojson::object>();
+
+        const picojson::array& results = cur_run.at("results").get<picojson::array>();
+        ASSERT_EQUALS(6U, results.size());
+
+        // Check severity mappings
+        ASSERT_EQUALS("error", results[0].get<picojson::object>().at("level").get<std::string>());    // error
+        ASSERT_EQUALS("error", results[1].get<picojson::object>().at("level").get<std::string>());    // warning
+        ASSERT_EQUALS("warning", results[2].get<picojson::object>().at("level").get<std::string>());  // style
+        ASSERT_EQUALS("warning", results[3].get<picojson::object>().at("level").get<std::string>());  // performance
+        ASSERT_EQUALS("warning", results[4].get<picojson::object>().at("level").get<std::string>());  // portability
+        ASSERT_EQUALS("note", results[5].get<picojson::object>().at("level").get<std::string>());     // information
+    }
+
+    void securityRelatedErrors()
+    {
+        SarifReport report;
+
+        // Add errors with CWE IDs
+        report.addFinding(createErrorMessage("nullPointer", Severity::error, "Null pointer", "test.cpp", 10, 5, 476));
+        report.addFinding(
+            createErrorMessage("bufferOverflow", Severity::error, "Buffer overflow", "test.cpp", 20, 5, 121));
+        report.addFinding(createErrorMessage("memleak", Severity::warning, "Memory leak", "test.cpp", 30, 5, 401));
+
+        std::string sarif = report.serialize("Cppcheck");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root   = json.get<picojson::object>();
+        const picojson::array& runs    = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run    = runs[0].get<picojson::object>();
+        const picojson::object& tool   = cur_run.at("tool").get<picojson::object>();
+        const picojson::object& driver = tool.at("driver").get<picojson::object>();
+        const picojson::array& rules   = driver.at("rules").get<picojson::array>();
+
+        for (const auto& rule : rules)
+        {
+            const picojson::object& r     = rule.get<picojson::object>();
+            const picojson::object& props = r.at("properties").get<picojson::object>();
+
+            // Should have security-severity
+            ASSERT(props.find("security-severity") != props.end());
+
+            // Should have tags with security and CWE
+            ASSERT(props.find("tags") != props.end());
+            const picojson::array& tags = props.at("tags").get<picojson::array>();
+
+            bool hasSecurityTag = false;
+            bool hasCweTag      = false;
+            for (const auto& tag : tags)
+            {
+                const std::string& tagStr = tag.get<std::string>();
+                if (tagStr == "security")
+                    hasSecurityTag = true;
+                if (tagStr.find("external/cwe/cwe-") == 0)
+                    hasCweTag = true;
+            }
+
+            ASSERT(hasSecurityTag);
+            ASSERT(hasCweTag);
+        }
+    }
+
+    void cweTagsPresent()
+    {
+        SarifReport report;
+
+        report.addFinding(createErrorMessage("testError", Severity::error, "Test error", "test.cpp", 10, 5, 119));
+
+        std::string sarif = report.serialize("Cppcheck");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root   = json.get<picojson::object>();
+        const picojson::array& runs    = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run    = runs[0].get<picojson::object>();
+        const picojson::object& tool   = cur_run.at("tool").get<picojson::object>();
+        const picojson::object& driver = tool.at("driver").get<picojson::object>();
+        const picojson::array& rules   = driver.at("rules").get<picojson::array>();
+
+        ASSERT_EQUALS(1U, rules.size());
+
+        const picojson::object& rule  = rules[0].get<picojson::object>();
+        const picojson::object& props = rule.at("properties").get<picojson::object>();
+        const picojson::array& tags   = props.at("tags").get<picojson::array>();
+
+        bool foundCwe119 = false;
+        for (const auto& tag : tags)
+        {
+            if (tag.get<std::string>() == "external/cwe/cwe-119")
+                foundCwe119 = true;
+        }
+
+        ASSERT(foundCwe119);
+    }
+
+    void noCweNoSecurity()
+    {
+        SarifReport report;
+
+        // Error without CWE ID should not have security properties
+        report.addFinding(createErrorMessage("styleError", Severity::style, "Style error", "test.cpp", 10, 5, 0));
+
+        std::string sarif = report.serialize("Cppcheck");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root   = json.get<picojson::object>();
+        const picojson::array& runs    = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run    = runs[0].get<picojson::object>();
+        const picojson::object& tool   = cur_run.at("tool").get<picojson::object>();
+        const picojson::object& driver = tool.at("driver").get<picojson::object>();
+        const picojson::array& rules   = driver.at("rules").get<picojson::array>();
+
+        ASSERT_EQUALS(1U, rules.size());
+
+        const picojson::object& rule  = rules[0].get<picojson::object>();
+        const picojson::object& props = rule.at("properties").get<picojson::object>();
+
+        // Should NOT have security-severity
+        ASSERT(props.find("security-severity") == props.end());
+
+        // Should NOT have tags (or if present, no security tag)
+        if (props.find("tags") != props.end())
+        {
+            const picojson::array& tags = props.at("tags").get<picojson::array>();
+            for (const auto& tag : tags)
+            {
+                ASSERT(tag.get<std::string>() != "security");
+            }
+        }
+    }
+
+    void inconclusiveCertainty()
+    {
+        SarifReport report;
+
+        report.addFinding(
+            createErrorMessage("test1", Severity::error, "Conclusive", "test.cpp", 10, 5, 0, Certainty::normal));
+        report.addFinding(createErrorMessage(
+                              "test2", Severity::error, "Inconclusive", "test.cpp", 20, 5, 0, Certainty::inconclusive));
+
+        std::string sarif = report.serialize("Cppcheck");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root   = json.get<picojson::object>();
+        const picojson::array& runs    = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run    = runs[0].get<picojson::object>();
+        const picojson::object& tool   = cur_run.at("tool").get<picojson::object>();
+        const picojson::object& driver = tool.at("driver").get<picojson::object>();
+        const picojson::array& rules   = driver.at("rules").get<picojson::array>();
+
+        ASSERT_EQUALS(2U, rules.size());
+
+        // Check precision values
+        const picojson::object& rule1  = rules[0].get<picojson::object>();
+        const picojson::object& props1 = rule1.at("properties").get<picojson::object>();
+        ASSERT_EQUALS("high", props1.at("precision").get<std::string>());
+
+        const picojson::object& rule2  = rules[1].get<picojson::object>();
+        const picojson::object& props2 = rule2.at("properties").get<picojson::object>();
+        ASSERT_EQUALS("medium", props2.at("precision").get<std::string>());
+    }
+
+    void criticalErrorId()
+    {
+        SarifReport report;
+
+        // Use a critical error ID (from ErrorLogger::isCriticalErrorId)
+        report.addFinding(createErrorMessage("syntaxError", Severity::error, "Syntax error"));
+
+        std::string sarif = report.serialize("Cppcheck");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root   = json.get<picojson::object>();
+        const picojson::array& runs    = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run    = runs[0].get<picojson::object>();
+        const picojson::array& results = cur_run.at("results").get<picojson::array>();
+
+        ASSERT_EQUALS(1U, results.size());
+
+        const picojson::object& result = results[0].get<picojson::object>();
+        // Critical errors should always map to "error" level
+        ASSERT_EQUALS("error", result.at("level").get<std::string>());
+    }
+
+    void emptyDescriptions()
+    {
+        SarifReport report;
+
+        report.addFinding(createErrorMessage("testError", Severity::error, "Test error"));
+
+        std::string sarif = report.serialize("Cppcheck");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root   = json.get<picojson::object>();
+        const picojson::array& runs    = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run    = runs[0].get<picojson::object>();
+        const picojson::object& tool   = cur_run.at("tool").get<picojson::object>();
+        const picojson::object& driver = tool.at("driver").get<picojson::object>();
+        const picojson::array& rules   = driver.at("rules").get<picojson::array>();
+
+        ASSERT_EQUALS(1U, rules.size());
+
+        const picojson::object& rule = rules[0].get<picojson::object>();
+
+        // All descriptions should be empty for GitHub integration
+        ASSERT_EQUALS("", rule.at("name").get<std::string>());
+        ASSERT_EQUALS("", rule.at("shortDescription").get<picojson::object>().at("text").get<std::string>());
+        ASSERT_EQUALS("", rule.at("fullDescription").get<picojson::object>().at("text").get<std::string>());
+        ASSERT_EQUALS("", rule.at("help").get<picojson::object>().at("text").get<std::string>());
+    }
+
+    void locationBoundaryValues()
+    {
+        SarifReport report;
+
+        // Test with line/column values that are 0
+        // Note: Negative values don't work correctly if FileLocation uses unsigned types
+        ErrorMessage::FileLocation loc1("test.cpp", 0, 0);
+        ErrorMessage::FileLocation loc2("test.cpp", 1, 1);
+
+        ErrorMessage errorMessage1({loc1}, "test.cpp", Severity::error, "Error at 0,0", "error1", Certainty::normal);
+        ErrorMessage errorMessage2({loc2}, "test.cpp", Severity::error, "Error at 1,1", "error2", Certainty::normal);
+
+        report.addFinding(errorMessage1);
+        report.addFinding(errorMessage2);
+
+        std::string sarif = report.serialize("Cppcheck");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root   = json.get<picojson::object>();
+        const picojson::array& runs    = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run    = runs[0].get<picojson::object>();
+        const picojson::array& results = cur_run.at("results").get<picojson::array>();
+
+        ASSERT_EQUALS(2U, results.size());
+
+        // Check first result (0,0 should be normalized to 1,1)
+        {
+            const picojson::object& res      = results[0].get<picojson::object>();
+            const picojson::array& locations = res.at("locations").get<picojson::array>();
+            const picojson::object& loc      = locations[0].get<picojson::object>();
+            const picojson::object& physLoc  = loc.at("physicalLocation").get<picojson::object>();
+            const picojson::object& region   = physLoc.at("region").get<picojson::object>();
+
+            int line   = static_cast<int>(region.at("startLine").get<double>());
+            int column = static_cast<int>(region.at("startColumn").get<double>());
+
+            // 0 should be normalized to 1
+            ASSERT_EQUALS(1, line);
+            ASSERT_EQUALS(1, column);
+        }
+
+        // Check second result (1,1 should stay as 1,1)
+        {
+            const picojson::object& res      = results[1].get<picojson::object>();
+            const picojson::array& locations = res.at("locations").get<picojson::array>();
+            const picojson::object& loc      = locations[0].get<picojson::object>();
+            const picojson::object& physLoc  = loc.at("physicalLocation").get<picojson::object>();
+            const picojson::object& region   = physLoc.at("region").get<picojson::object>();
+
+            int line   = static_cast<int>(region.at("startLine").get<double>());
+            int column = static_cast<int>(region.at("startColumn").get<double>());
+
+            ASSERT_EQUALS(1, line);
+            ASSERT_EQUALS(1, column);
+        }
+    }
+
+    void duplicateRuleIds()
+    {
+        SarifReport report;
+
+        // Add multiple errors with the same rule ID
+        report.addFinding(createErrorMessage("duplicateId", Severity::error, "First error", "file1.cpp", 10, 5));
+        report.addFinding(createErrorMessage("duplicateId", Severity::error, "Second error", "file2.cpp", 20, 10));
+        report.addFinding(createErrorMessage("duplicateId", Severity::error, "Third error", "file3.cpp", 30, 15));
+
+        std::string sarif = report.serialize("Cppcheck");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root = json.get<picojson::object>();
+        const picojson::array& runs  = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run  = runs[0].get<picojson::object>();
+
+        // Should have 3 results but only 1 rule
+        const picojson::array& results = cur_run.at("results").get<picojson::array>();
+        ASSERT_EQUALS(3U, results.size());
+
+        const picojson::object& tool   = cur_run.at("tool").get<picojson::object>();
+        const picojson::object& driver = tool.at("driver").get<picojson::object>();
+        const picojson::array& rules   = driver.at("rules").get<picojson::array>();
+        ASSERT_EQUALS(1U, rules.size());
+
+        const picojson::object& rule = rules[0].get<picojson::object>();
+        ASSERT_EQUALS("duplicateId", rule.at("id").get<std::string>());
+    }
+
+    void customProductName()
+    {
+        SarifReport report;
+        report.addFinding(createErrorMessage("testError", Severity::error, "Test error"));
+
+        // Test with custom product name
+        std::string sarif = report.serialize("CustomChecker");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root   = json.get<picojson::object>();
+        const picojson::array& runs    = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run    = runs[0].get<picojson::object>();
+        const picojson::object& tool   = cur_run.at("tool").get<picojson::object>();
+        const picojson::object& driver = tool.at("driver").get<picojson::object>();
+
+        // Should use "Cppcheck" as default when custom name doesn't parse
+        ASSERT_EQUALS("Cppcheck", driver.at("name").get<std::string>());
+    }
+
+    void versionHandling()
+    {
+        SarifReport report;
+        report.addFinding(createErrorMessage("testError", Severity::error, "Test error"));
+
+        std::string sarif = report.serialize("Cppcheck");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root   = json.get<picojson::object>();
+        const picojson::array& runs    = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run    = runs[0].get<picojson::object>();
+        const picojson::object& tool   = cur_run.at("tool").get<picojson::object>();
+        const picojson::object& driver = tool.at("driver").get<picojson::object>();
+
+        // Should have a semantic version
+        ASSERT(driver.find("semanticVersion") != driver.end());
+        const std::string version = driver.at("semanticVersion").get<std::string>();
+
+        // Version should not contain spaces (they should be stripped)
+        ASSERT(version.find(' ') == std::string::npos);
+    }
+
+    void securitySeverityMapping()
+    {
+        // Test the detailed security-severity mapping for different severity levels with CWE
+        SarifReport report;
+
+        // Error with CWE should get 9.9 (critical)
+        report.addFinding(createErrorMessage("error1", Severity::error, "Error with CWE", "test.cpp", 10, 5, 119));
+
+        // Warning with CWE should get 8.5 (high)
+        report.addFinding(
+            createErrorMessage("warning1", Severity::warning, "Warning with CWE", "test.cpp", 20, 5, 120));
+
+        // Style/Performance/Portability with CWE should get 5.5 (medium)
+        report.addFinding(createErrorMessage("style1", Severity::style, "Style with CWE", "test.cpp", 30, 5, 398));
+        report.addFinding(
+            createErrorMessage("perf1", Severity::performance, "Performance with CWE", "test.cpp", 40, 5, 407));
+        report.addFinding(
+            createErrorMessage("port1", Severity::portability, "Portability with CWE", "test.cpp", 50, 5, 562));
+
+        // Information with CWE should get 2.0 (low)
+        report.addFinding(createErrorMessage("info1", Severity::information, "Info with CWE", "test.cpp", 60, 5, 561));
+
+        std::string sarif = report.serialize("Cppcheck");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root   = json.get<picojson::object>();
+        const picojson::array& runs    = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run    = runs[0].get<picojson::object>();
+        const picojson::object& tool   = cur_run.at("tool").get<picojson::object>();
+        const picojson::object& driver = tool.at("driver").get<picojson::object>();
+        const picojson::array& rules   = driver.at("rules").get<picojson::array>();
+
+        // Check each rule's security-severity value
+        for (const auto& rule : rules)
+        {
+            const picojson::object& r     = rule.get<picojson::object>();
+            const std::string& id         = r.at("id").get<std::string>();
+            const picojson::object& props = r.at("properties").get<picojson::object>();
+
+            ASSERT(props.find("security-severity") != props.end());
+            const std::string& severity = props.at("security-severity").get<std::string>();
+            double severityValue        = std::stod(severity);
+
+            if (id == "error1")
+            {
+                // Use a tolerance for floating-point comparison to avoid warning
+                ASSERT(std::abs(severityValue - 9.9) < 0.01);
+            }
+            else if (id == "warning1")
+            {
+                ASSERT(std::abs(severityValue - 8.5) < 0.01);
+            }
+            else if (id == "style1" || id == "perf1" || id == "port1")
+            {
+                ASSERT(std::abs(severityValue - 5.5) < 0.01);
+            }
+            else if (id == "info1")
+            {
+                ASSERT(std::abs(severityValue - 2.0) < 0.01);
+            }
+        }
+    }
+
+    void versionWithSpace()
+    {
+        // Test that version strings with spaces are properly truncated
+        SarifReport report;
+        report.addFinding(createErrorMessage("testError", Severity::error, "Test error"));
+
+        // This test would need a way to inject a version with a space
+        // The current implementation gets version from CppCheck::version()
+        // This test verifies the space-trimming logic works
+        std::string sarif = report.serialize("Cppcheck");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root   = json.get<picojson::object>();
+        const picojson::array& runs    = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run    = runs[0].get<picojson::object>();
+        const picojson::object& tool   = cur_run.at("tool").get<picojson::object>();
+        const picojson::object& driver = tool.at("driver").get<picojson::object>();
+
+        const std::string& version = driver.at("semanticVersion").get<std::string>();
+        // Version should not contain any spaces
+        ASSERT(version.find(' ') == std::string::npos);
+    }
+
+    void customProductNameAndVersion()
+    {
+        // Test custom product name that includes version info
+        SarifReport report;
+        report.addFinding(createErrorMessage("testError", Severity::error, "Test error"));
+
+        // Test with product name that might parse differently
+        std::string sarif = report.serialize("MyChecker-1.0.0");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root   = json.get<picojson::object>();
+        const picojson::array& runs    = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run    = runs[0].get<picojson::object>();
+        const picojson::object& tool   = cur_run.at("tool").get<picojson::object>();
+        const picojson::object& driver = tool.at("driver").get<picojson::object>();
+
+        // Should have a name (either parsed or default)
+        ASSERT(driver.find("name") != driver.end());
+        ASSERT(driver.find("semanticVersion") != driver.end());
+    }
+
+    void normalizeLineColumnToOne()
+    {
+        SarifReport report;
+
+        // Test with 0 values
+        ErrorMessage::FileLocation loc0("test.cpp", 0, 0);
+        ErrorMessage errorMessage0({loc0}, "test.cpp", Severity::error, "Error at 0", "error0", Certainty::normal);
+        report.addFinding(errorMessage0);
+
+        // Test with positive values
+        ErrorMessage::FileLocation locPos("test.cpp", 10, 5);
+        ErrorMessage errorMessagePos(
+            {locPos}, "test.cpp", Severity::error, "Error at positive", "errorPos", Certainty::normal);
+        report.addFinding(errorMessagePos);
+
+        std::string sarif = report.serialize("Cppcheck");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root   = json.get<picojson::object>();
+        const picojson::array& runs    = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run    = runs[0].get<picojson::object>();
+        const picojson::array& results = cur_run.at("results").get<picojson::array>();
+
+        ASSERT_EQUALS(2U, results.size());
+
+        // Check first result with 0,0
+        const picojson::object& res0      = results[0].get<picojson::object>();
+        const picojson::array& locations0 = res0.at("locations").get<picojson::array>();
+        const picojson::object& loc0_obj  = locations0[0].get<picojson::object>();
+        const picojson::object& physLoc0  = loc0_obj.at("physicalLocation").get<picojson::object>();
+        const picojson::object& region0   = physLoc0.at("region").get<picojson::object>();
+
+        int line0   = static_cast<int>(region0.at("startLine").get<double>());
+        int column0 = static_cast<int>(region0.at("startColumn").get<double>());
+
+        // 0 values should be normalized to 1
+        ASSERT(line0 == 1);
+        ASSERT(column0 == 1);
+
+        // Check second result with positive values
+        const picojson::object& res1      = results[1].get<picojson::object>();
+        const picojson::array& locations1 = res1.at("locations").get<picojson::array>();
+        const picojson::object& loc1_obj  = locations1[0].get<picojson::object>();
+        const picojson::object& physLoc1  = loc1_obj.at("physicalLocation").get<picojson::object>();
+        const picojson::object& region1   = physLoc1.at("region").get<picojson::object>();
+
+        ASSERT_EQUALS(10, static_cast<int>(region1.at("startLine").get<double>()));
+        ASSERT_EQUALS(5, static_cast<int>(region1.at("startColumn").get<double>()));
+    }
+
+    void internalAndDebugSeverity()
+    {
+        // Test internal and debug severity levels
+        // Based on the implementation in sarifSeverity():
+        // - internal -> error
+        // - debug -> note
+        // - none -> note
+        SarifReport report;
+
+        // Create errors with internal and debug severities
+        ErrorMessage::FileLocation loc1("test.cpp", 10, 5);
+        ErrorMessage::FileLocation loc2("test.cpp", 20, 10);
+        ErrorMessage::FileLocation loc3("test.cpp", 30, 15);
+
+        ErrorMessage internal(
+            {loc1}, "test.cpp", Severity::internal, "Internal message", "internalError", Certainty::normal);
+        ErrorMessage debug({loc2}, "test.cpp", Severity::debug, "Debug message", "debugError", Certainty::normal);
+        ErrorMessage none({loc3}, "test.cpp", Severity::none, "None message", "noneError", Certainty::normal);
+
+        report.addFinding(internal);
+        report.addFinding(debug);
+        report.addFinding(none);
+
+        std::string sarif = report.serialize("Cppcheck");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root   = json.get<picojson::object>();
+        const picojson::array& runs    = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run    = runs[0].get<picojson::object>();
+        const picojson::array& results = cur_run.at("results").get<picojson::array>();
+
+        ASSERT_EQUALS(3U, results.size());
+
+        // Check the actual mapping
+        const picojson::object& res0 = results[0].get<picojson::object>();
+        const picojson::object& res1 = results[1].get<picojson::object>();
+        const picojson::object& res2 = results[2].get<picojson::object>();
+
+        const std::string level0 = res0.at("level").get<std::string>();
+        const std::string level1 = res1.at("level").get<std::string>();
+        const std::string level2 = res2.at("level").get<std::string>();
+
+        // Actual implementation behavior:
+        ASSERT_EQUALS("error", level0);  // internal -> error
+        ASSERT_EQUALS("note", level1);   // debug -> note
+        ASSERT_EQUALS("note", level2);   // none -> note
+    }
+
+    void problemSeverityMapping()
+    {
+        // Test that problem.severity property matches the SARIF severity
+        SarifReport report;
+
+        report.addFinding(createErrorMessage("error1", Severity::error, "Error"));
+        report.addFinding(createErrorMessage("warning1", Severity::warning, "Warning"));
+        report.addFinding(createErrorMessage("style1", Severity::style, "Style"));
+
+        std::string sarif = report.serialize("Cppcheck");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root   = json.get<picojson::object>();
+        const picojson::array& runs    = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run    = runs[0].get<picojson::object>();
+        const picojson::object& tool   = cur_run.at("tool").get<picojson::object>();
+        const picojson::object& driver = tool.at("driver").get<picojson::object>();
+        const picojson::array& rules   = driver.at("rules").get<picojson::array>();
+
+        for (const auto& rule : rules)
+        {
+            const picojson::object& r             = rule.get<picojson::object>();
+            const picojson::object& props         = r.at("properties").get<picojson::object>();
+            const picojson::object& defaultConfig = r.at("defaultConfiguration").get<picojson::object>();
+
+            // problem.severity should match defaultConfiguration.level
+            const std::string& problemSeverity = props.at("problem.severity").get<std::string>();
+            const std::string& defaultLevel    = defaultConfig.at("level").get<std::string>();
+
+            ASSERT_EQUALS(defaultLevel, problemSeverity);
+        }
+    }
+
+    void mixedLocationAndNoLocation()
+    {
+        // Test a mix of findings with and without locations
+        SarifReport report;
+
+        // Add findings with locations
+        report.addFinding(createErrorMessage("withLoc1", Severity::error, "Error with location", "test.cpp", 10, 5));
+        report.addFinding(
+            createErrorMessage("withLoc2", Severity::warning, "Warning with location", "test.cpp", 20, 5));
+
+        // Add findings without locations
+        ErrorMessage noLoc1({}, "test.cpp", Severity::error, "Error without location", "noLoc1", Certainty::normal);
+        ErrorMessage noLoc2({}, "test.cpp", Severity::warning, "Warning without location", "noLoc2", Certainty::normal);
+
+        report.addFinding(noLoc1);
+        report.addFinding(noLoc2);
+
+        // Add more with locations
+        report.addFinding(createErrorMessage("withLoc3", Severity::style, "Style with location", "test.cpp", 30, 5));
+
+        std::string sarif = report.serialize("Cppcheck");
+        picojson::value json;
+        ASSERT(parseAndValidateJson(sarif, json));
+
+        const picojson::object& root = json.get<picojson::object>();
+        const picojson::array& runs  = root.at("runs").get<picojson::array>();
+        const picojson::object& cur_run  = runs[0].get<picojson::object>();
+
+        // Should only have results for findings with locations
+        const picojson::array& results = cur_run.at("results").get<picojson::array>();
+        ASSERT_EQUALS(3U, results.size());
+
+        // Should only have rules for findings with locations
+        const picojson::object& tool   = cur_run.at("tool").get<picojson::object>();
+        const picojson::object& driver = tool.at("driver").get<picojson::object>();
+        const picojson::array& rules   = driver.at("rules").get<picojson::array>();
+        ASSERT_EQUALS(3U, rules.size());
+
+        // Verify the rule IDs are only for findings with locations
+        std::set<std::string> ruleIds;
+        for (const auto& rule : rules)
+        {
+            const picojson::object& r = rule.get<picojson::object>();
+            ruleIds.insert(r.at("id").get<std::string>());
+        }
+
+        ASSERT(ruleIds.find("withLoc1") != ruleIds.end());
+        ASSERT(ruleIds.find("withLoc2") != ruleIds.end());
+        ASSERT(ruleIds.find("withLoc3") != ruleIds.end());
+        ASSERT(ruleIds.find("noLoc1") == ruleIds.end());
+        ASSERT(ruleIds.find("noLoc2") == ruleIds.end());
+    }
+};
+
+REGISTER_TEST(TestSarifReport)
diff --git a/test/testsettings.cpp b/test/testsettings.cpp
new file mode 100644
index 00000000000..ddd11de3273
--- /dev/null
+++ b/test/testsettings.cpp
@@ -0,0 +1,361 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "errortypes.h"
+#include "settings.h"
+#include "fixture.h"
+#include "helpers.h"
+#include "suppressions.h"
+
+class TestSettings : public TestFixture {
+public:
+    TestSettings() : TestFixture("TestSettings") {}
+
+private:
+    void run() override {
+        TEST_CASE(simpleEnableGroup);
+        TEST_CASE(loadCppcheckCfg);
+        TEST_CASE(loadCppcheckCfgSafety);
+        TEST_CASE(getNameAndVersion);
+        TEST_CASE(checkLevelDefault);
+
+        TEST_CASE(getMaxConfigsDefault);
+        TEST_CASE(getMaxConfigsOpt);
+        TEST_CASE(getMaxConfigsForce);
+        TEST_CASE(getMaxConfigsOptAndForce);
+        TEST_CASE(getMaxConfigsDefines);
+        TEST_CASE(getMaxConfigsDefinesAndOpt);
+        TEST_CASE(getMaxConfigsOptAndProject);
+    }
+
+    void simpleEnableGroup() const {
+        SimpleEnableGroup<Checks> group;
+
+        ASSERT_EQUALS(0, group.intValue());
+        ASSERT_EQUALS(false, group.isEnabled(Checks::unusedFunction));
+        ASSERT_EQUALS(false, group.isEnabled(Checks::missingInclude));
+        ASSERT_EQUALS(false, group.isEnabled(Checks::internalCheck));
+
+        group.fill();
+
+        ASSERT_EQUALS(4294967295, group.intValue());
+        ASSERT_EQUALS(true, group.isEnabled(Checks::unusedFunction));
+        ASSERT_EQUALS(true, group.isEnabled(Checks::missingInclude));
+        ASSERT_EQUALS(true, group.isEnabled(Checks::internalCheck));
+
+        group.clear();
+
+        ASSERT_EQUALS(0, group.intValue());
+        ASSERT_EQUALS(false, group.isEnabled(Checks::unusedFunction));
+        ASSERT_EQUALS(false, group.isEnabled(Checks::missingInclude));
+        ASSERT_EQUALS(false, group.isEnabled(Checks::internalCheck));
+
+        group.enable(Checks::unusedFunction);
+        group.setEnabled(Checks::missingInclude, true);
+
+        ASSERT_EQUALS(3, group.intValue());
+        ASSERT_EQUALS(true, group.isEnabled(Checks::unusedFunction));
+        ASSERT_EQUALS(true, group.isEnabled(Checks::missingInclude));
+        ASSERT_EQUALS(false, group.isEnabled(Checks::internalCheck));
+
+        group.disable(Checks::unusedFunction);
+        group.setEnabled(Checks::missingInclude, false);
+
+        ASSERT_EQUALS(0, group.intValue());
+        ASSERT_EQUALS(false, group.isEnabled(Checks::unusedFunction));
+        ASSERT_EQUALS(false, group.isEnabled(Checks::missingInclude));
+        ASSERT_EQUALS(false, group.isEnabled(Checks::internalCheck));
+
+        SimpleEnableGroup<Checks> newGroup;
+        newGroup.enable(Checks::missingInclude);
+
+        group.enable(newGroup);
+
+        ASSERT_EQUALS(2, group.intValue());
+        ASSERT_EQUALS(false, group.isEnabled(Checks::unusedFunction));
+        ASSERT_EQUALS(true, group.isEnabled(Checks::missingInclude));
+        ASSERT_EQUALS(false, group.isEnabled(Checks::internalCheck));
+
+        group.disable(newGroup);
+
+        ASSERT_EQUALS(0, group.intValue());
+        ASSERT_EQUALS(false, group.isEnabled(Checks::unusedFunction));
+        ASSERT_EQUALS(false, group.isEnabled(Checks::missingInclude));
+        ASSERT_EQUALS(false, group.isEnabled(Checks::internalCheck));
+    }
+
+    void loadCppcheckCfg()
+    {
+        {
+            Settings s;
+            Suppressions supprs;
+            ASSERT_EQUALS("", Settings::loadCppcheckCfg(s, supprs));
+        }
+        {
+            Settings s;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg",
+                            "{}\n");
+            ASSERT_EQUALS("", Settings::loadCppcheckCfg(s, supprs));
+        }
+        {
+            Settings s;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg",
+                            "{\n");
+            ASSERT_EQUALS("not a valid JSON - syntax error at line 2 near: ", Settings::loadCppcheckCfg(s, supprs));
+        }
+        {
+            Settings s;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg",
+                            R"({"productName": ""}\n)");
+            ASSERT_EQUALS("", Settings::loadCppcheckCfg(s, supprs));
+            ASSERT_EQUALS("", s.cppcheckCfgProductName);
+        }
+        {
+            Settings s;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg",
+                            R"({"productName": "product"}\n)");
+            ASSERT_EQUALS("", Settings::loadCppcheckCfg(s, supprs));
+            ASSERT_EQUALS("product", s.cppcheckCfgProductName);
+        }
+        {
+            Settings s;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg",
+                            R"({"productName": 1}\n)");
+            ASSERT_EQUALS("'productName' is not a string", Settings::loadCppcheckCfg(s, supprs));
+        }
+        {
+            Settings s;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg",
+                            R"({"about": ""}\n)");
+            ASSERT_EQUALS("", Settings::loadCppcheckCfg(s, supprs));
+            ASSERT_EQUALS("", s.cppcheckCfgAbout);
+        }
+        {
+            Settings s;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg",
+                            R"({"about": "about"}\n)");
+            ASSERT_EQUALS("", Settings::loadCppcheckCfg(s, supprs));
+            ASSERT_EQUALS("about", s.cppcheckCfgAbout);
+        }
+        {
+            Settings s;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg",
+                            R"({"about": 1}\n)");
+            ASSERT_EQUALS("'about' is not a string", Settings::loadCppcheckCfg(s, supprs));
+        }
+        {
+            Settings s;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg",
+                            R"({"addons": []}\n)");
+            ASSERT_EQUALS("", Settings::loadCppcheckCfg(s, supprs));
+            ASSERT_EQUALS(0, s.addons.size());
+        }
+        {
+            Settings s;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg",
+                            R"({"addons": 1}\n)");
+            ASSERT_EQUALS("'addons' is not an array", Settings::loadCppcheckCfg(s, supprs));
+        }
+        {
+            Settings s;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg",
+                            R"({"addons": ["addon"]}\n)");
+            ASSERT_EQUALS("", Settings::loadCppcheckCfg(s, supprs));
+            ASSERT_EQUALS(1, s.addons.size());
+            ASSERT_EQUALS("addon", *s.addons.cbegin());
+        }
+        {
+            Settings s;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg",
+                            R"({"addons": [1]}\n)");
+            ASSERT_EQUALS("'addons' array entry is not a string", Settings::loadCppcheckCfg(s, supprs));
+        }
+        {
+            Settings s;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg",
+                            R"({"addons": []}\n)");
+            ASSERT_EQUALS("", Settings::loadCppcheckCfg(s, supprs));
+            ASSERT_EQUALS(0, s.addons.size());
+        }
+        {
+            Settings s;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg",
+                            R"({"suppressions": 1}\n)");
+            ASSERT_EQUALS("'suppressions' is not an array", Settings::loadCppcheckCfg(s, supprs));
+        }
+        {
+            Settings s;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg",
+                            R"({"suppressions": ["id"]}\n)");
+            ASSERT_EQUALS("", Settings::loadCppcheckCfg(s, supprs));
+            ASSERT_EQUALS(1, supprs.nomsg.getSuppressions().size());
+            ASSERT_EQUALS("id", supprs.nomsg.getSuppressions().cbegin()->errorId);
+        }
+        {
+            Settings s;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg",
+                            R"({"suppressions": [""]}\n)");
+            ASSERT_EQUALS("could not parse suppression '' - Failed to add suppression. No id.", Settings::loadCppcheckCfg(s, supprs));
+        }
+        {
+            Settings s;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg",
+                            R"({"suppressions": [1]}\n)");
+            ASSERT_EQUALS("'suppressions' array entry is not a string", Settings::loadCppcheckCfg(s, supprs));
+        }
+        {
+            Settings s;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg",
+                            R"({"manualUrl": "https://docs.notcppcheck.com/manual.pdf"})");
+            ASSERT_EQUALS("", Settings::loadCppcheckCfg(s, supprs));
+            ASSERT_EQUALS("https://docs.notcppcheck.com/manual.pdf", s.manualUrl);
+        }
+        {
+            Settings s;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg",
+                            R"({"manualUrl": 0}\n)");
+            ASSERT_EQUALS("'manualUrl' is not a string", Settings::loadCppcheckCfg(s, supprs));
+        }
+
+        // TODO: test with FILESDIR
+    }
+
+    void loadCppcheckCfgSafety() const
+    {
+        // Test the "safety" flag
+        {
+            Settings s;
+            s.safety = false;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg", "{}");
+            ASSERT_EQUALS("", Settings::loadCppcheckCfg(s, supprs));
+            ASSERT_EQUALS(false, s.safety);
+        }
+
+        {
+            Settings s;
+            s.safety = true;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg", "{\"safety\": false}");
+            ASSERT_EQUALS("", Settings::loadCppcheckCfg(s, supprs));
+            ASSERT_EQUALS(false, s.safety);
+        }
+
+        {
+            Settings s;
+            s.safety = false;
+            Suppressions supprs;
+            ScopedFile file("cppcheck.cfg", "{\"safety\": true}");
+            ASSERT_EQUALS("", Settings::loadCppcheckCfg(s, supprs));
+            ASSERT_EQUALS(true, s.safety);
+        }
+    }
+
+    void getNameAndVersion() const
+    {
+        {
+            const auto nameVersion = Settings::getNameAndVersion("Cppcheck Premium 12.3.4");
+            ASSERT_EQUALS("Cppcheck Premium", nameVersion.first);
+            ASSERT_EQUALS("12.3.4", nameVersion.second);
+        }
+
+        {
+            const auto nameVersion = Settings::getNameAndVersion("Cppcheck Premium 12.3.4s");
+            ASSERT_EQUALS("Cppcheck Premium", nameVersion.first);
+            ASSERT_EQUALS("12.3.4s", nameVersion.second);
+        }
+    }
+
+    void checkLevelDefault() const
+    {
+        Settings s;
+        ASSERT_EQUALS_ENUM(s.checkLevel, Settings::CheckLevel::exhaustive);
+        ASSERT_EQUALS(s.vfOptions.maxIfCount, -1);
+        ASSERT_EQUALS(s.vfOptions.maxSubFunctionArgs, 256);
+        ASSERT_EQUALS(true, s.vfOptions.doConditionExpressionAnalysis);
+        ASSERT_EQUALS(-1, s.vfOptions.maxForwardBranches);
+    }
+
+    void getMaxConfigsDefault() const {
+        Settings s;
+        ASSERT_EQUALS(12, s.getMaxConfigs());
+    }
+
+    void getMaxConfigsOpt() const {
+        Settings s;
+        s.maxConfigsOption = 1;
+        ASSERT_EQUALS(1, s.getMaxConfigs());
+    }
+
+    void getMaxConfigsForce() const {
+        Settings s;
+        s.force = true;
+        ASSERT(s.getMaxConfigs() > 1000);
+    }
+
+    void getMaxConfigsOptAndForce() const {
+        Settings s;
+        s.maxConfigsOption = 1;
+        s.force = true;
+        ASSERT(s.getMaxConfigs() > 1000);
+    }
+
+    void getMaxConfigsDefines() const {
+        Settings s;
+        s.userDefines = "X=1";
+        ASSERT_EQUALS(1, s.getMaxConfigs());
+    }
+
+    void getMaxConfigsDefinesAndOpt() const {
+        Settings s;
+        s.userDefines = "X=1";
+        s.maxConfigsOption = 3;
+        ASSERT_EQUALS(3, s.getMaxConfigs());
+    }
+
+    void getMaxConfigsOptAndProject() const {
+        Settings s;
+        s.maxConfigsOption = 3;
+        s.maxConfigsProject = 1;
+        ASSERT_EQUALS(3, s.getMaxConfigs());
+        s.maxConfigsProject = 10;
+        ASSERT_EQUALS(3, s.getMaxConfigs());
+    }
+};
+
+REGISTER_TEST(TestSettings)
diff --git a/test/testsimplifytemplate.cpp b/test/testsimplifytemplate.cpp
index 8bf07ead1a3..66b2e022679 100644
--- a/test/testsimplifytemplate.cpp
+++ b/test/testsimplifytemplate.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,29 +16,34 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-#include "config.h"
-#include "platform.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "settings.h"
+#include "standards.h"
 #include "templatesimplifier.h"
-#include "testsuite.h"
 #include "token.h"
 #include "tokenize.h"
+#include "tokenlist.h"
 
-struct InternalError;
+#include <cstring>
+#include <sstream>
+#include <string>
+#include <utility>
+#include <vector>
 
+class ErrorLogger;
 
 class TestSimplifyTemplate : public TestFixture {
 public:
-    TestSimplifyTemplate() : TestFixture("TestSimplifyTemplate") {
-    }
+    TestSimplifyTemplate() : TestFixture("TestSimplifyTemplate") {}
 
 private:
-    Settings settings;
-
-    void run() OVERRIDE {
-        settings.addEnabled("portability");
+    const Settings settings = settingsBuilder().severity(Severity::portability).build();
+    const Settings settings1 = settingsBuilder(settings).library("std.cfg").build();
+    const Settings settings1_d = settingsBuilder(settings1).debugwarnings().build();
 
+    void run() override {
         TEST_CASE(template1);
         TEST_CASE(template2);
         TEST_CASE(template3);
@@ -88,7 +93,6 @@ class TestSimplifyTemplate : public TestFixture {
         TEST_CASE(template48);  // #6134 - 100% CPU upon invalid code
         TEST_CASE(template49);  // #6237 - template instantiation
         TEST_CASE(template50);  // #4272 - simple partial specialization
-        TEST_CASE(template51);  // #6172 - crash upon valid code
         TEST_CASE(template52);  // #6437 - crash upon valid code
         TEST_CASE(template53);  // #4335 - bail out for valid code
         TEST_CASE(template54);  // #6587 - memory corruption upon valid code
@@ -188,8 +192,42 @@ class TestSimplifyTemplate : public TestFixture {
         TEST_CASE(template148); // syntax error
         TEST_CASE(template149); // unknown macro
         TEST_CASE(template150); // syntax error
+        TEST_CASE(template151); // crash
+        TEST_CASE(template152); // #9467
+        TEST_CASE(template153); // #9483
+        TEST_CASE(template154); // #9495
+        TEST_CASE(template155); // #9539
+        TEST_CASE(template156);
+        TEST_CASE(template157); // #9854
+        TEST_CASE(template158); // daca crash
+        TEST_CASE(template159); // #9886
+        TEST_CASE(template160);
+        TEST_CASE(template161);
+        TEST_CASE(template162);
+        TEST_CASE(template163); // #9685 syntax error
+        TEST_CASE(template164); // #9394
+        TEST_CASE(template165); // #10032 syntax error
+        TEST_CASE(template166); // #10081 hang
+        TEST_CASE(template167);
+        TEST_CASE(template168);
+        TEST_CASE(template169);
+        TEST_CASE(template170); // crash
+        TEST_CASE(template171); // crash
+        TEST_CASE(template172); // #10258 crash
+        TEST_CASE(template173); // #10332 crash
+        TEST_CASE(template174); // #10506 hang
+        TEST_CASE(template175); // #10908
+        TEST_CASE(template176); // #11146
+        TEST_CASE(template177);
+        TEST_CASE(template178);
+        TEST_CASE(template179);
+        TEST_CASE(template180);
+        TEST_CASE(template181);
+        TEST_CASE(template182); // #13770
+        TEST_CASE(template183);
         TEST_CASE(template_specialization_1);  // #7868 - template specialization template <typename T> struct S<C<T>> {..};
         TEST_CASE(template_specialization_2);  // #7868 - template specialization template <typename T> struct S<C<T>> {..};
+        TEST_CASE(template_specialization_3);
         TEST_CASE(template_enum);  // #6299 Syntax error in complex enum declaration (including template)
         TEST_CASE(template_unhandled);
         TEST_CASE(template_default_parameter);
@@ -210,6 +248,10 @@ class TestSimplifyTemplate : public TestFixture {
         TEST_CASE(template_namespace_9);
         TEST_CASE(template_namespace_10);
         TEST_CASE(template_namespace_11); // #7145
+        TEST_CASE(template_namespace_12);
+        TEST_CASE(template_namespace_13);
+        TEST_CASE(template_pointer_type);
+        TEST_CASE(template_array_type);
 
         // Test TemplateSimplifier::templateParameters
         TEST_CASE(templateParameters);
@@ -218,10 +260,13 @@ class TestSimplifyTemplate : public TestFixture {
 
         TEST_CASE(findTemplateDeclarationEnd);
 
+        TEST_CASE(getTemplateParametersInDeclaration);
+
         TEST_CASE(expandSpecialized1);
         TEST_CASE(expandSpecialized2);
         TEST_CASE(expandSpecialized3); // #8671
         TEST_CASE(expandSpecialized4);
+        TEST_CASE(expandSpecialized5); // #10494
 
         TEST_CASE(templateAlias1);
         TEST_CASE(templateAlias2);
@@ -230,16 +275,23 @@ class TestSimplifyTemplate : public TestFixture {
         TEST_CASE(templateAlias5);
 
         // Test TemplateSimplifier::instantiateMatch
-        TEST_CASE(instantiateMatch);
+        TEST_CASE(instantiateMatchTest);
         TEST_CASE(templateParameterWithoutName); // #8602 Template default parameter without name yields syntax error
 
         TEST_CASE(templateTypeDeduction1); // #8962
         TEST_CASE(templateTypeDeduction2);
+        TEST_CASE(templateTypeDeduction3);
+        TEST_CASE(templateTypeDeduction4); // #9983
+        TEST_CASE(templateTypeDeduction5);
 
         TEST_CASE(simplifyTemplateArgs1);
         TEST_CASE(simplifyTemplateArgs2);
+        TEST_CASE(simplifyTemplateArgs3);
 
         TEST_CASE(template_variadic_1); // #9144
+        TEST_CASE(template_variadic_2); // #4349
+        TEST_CASE(template_variadic_3); // #6172
+        TEST_CASE(template_variadic_4);
 
         TEST_CASE(template_variable_1);
         TEST_CASE(template_variable_2);
@@ -247,21 +299,73 @@ class TestSimplifyTemplate : public TestFixture {
         TEST_CASE(template_variable_4);
 
         TEST_CASE(simplifyDecltype);
+
+        TEST_CASE(castInExpansion);
+
+        TEST_CASE(fold_expression_1);
+        TEST_CASE(fold_expression_2);
+        TEST_CASE(fold_expression_3);
+        TEST_CASE(fold_expression_4);
+
+        TEST_CASE(concepts1);
+        TEST_CASE(requires1);
+        TEST_CASE(requires2);
+        TEST_CASE(requires3);
+        TEST_CASE(requires4);
+        TEST_CASE(requires5);
+
+        TEST_CASE(explicitBool1);
+        TEST_CASE(explicitBool2);
+
+        TEST_CASE(templateArgPreserveType); // #13882 - type of template argument
+
+        TEST_CASE(dumpTemplateArgFrom);
     }
 
-    std::string tok(const char code[], bool debugwarnings = false, Settings::PlatformType type = Settings::Native) {
-        errout.str("");
+    class TemplateSimplifierTest final : public TemplateSimplifier
+    {
+        friend class TestSimplifyTemplate;
+    };
+
+    class TokenizerTest final : public Tokenizer
+    {
+        friend class TestSimplifyTemplate;
+    public:
+        TokenizerTest(TokenList tokenList, ErrorLogger &errorLogger)
+            : Tokenizer(std::move(tokenList), errorLogger)
+        {}
+    };
+
+    struct CheckOptions
+    {
+        bool debugwarnings = false;
+    };
 
-        settings.debugwarnings = debugwarnings;
-        settings.platform(type);
-        Tokenizer tokenizer(&settings, this);
+#define tok(...) tok_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    std::string tok_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
+        const Settings& s = options.debugwarnings ? settings1_d : settings1;
+        SimpleTokenizer tokenizer(s, *this);
 
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         return tokenizer.tokens()->stringifyList(nullptr, true);
     }
 
+#define dump(...) dump_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    std::string dump_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
+        const Settings& s = options.debugwarnings ? settings1_d : settings1;
+        SimpleTokenizer tokenizer(s, *this);
+
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+
+        std::ostringstream ostr;
+        (tokenizer.dump)(ostr);
+
+        return ostr.str();
+    }
+
     void template1() {
         const char code[] = "template <class T> T f(T val) { T a; }\n"
                             "f<int>(10);";
@@ -442,7 +546,8 @@ class TestSimplifyTemplate : public TestFixture {
 
         // The expected result..
         const char expected[] = "class A<int> ; "
-                                "void f ( ) { A<int> a ; } ; "
+                                "void f ( ) { A<int> a ; } "
+                                "template < typename T > class B { void g ( ) { A < T > b ; b = A < T > :: h ( ) ; } } ; "
                                 "class A<int> { } ;";
 
         ASSERT_EQUALS(expected, tok(code));
@@ -608,7 +713,7 @@ class TestSimplifyTemplate : public TestFixture {
                                  "vec<4> v ; "
                                  "struct vec<4> { "
                                  "vec<4> ( ) { } "
-                                 "vec<4> ( const vec < 4 - 1 > & v ) { } "
+                                 "vec<4> ( const vec < ( int ) 4 - 1 > & v ) { } "
                                  "} ;";
 
         ASSERT_EQUALS(expected2, tok(code2));
@@ -823,14 +928,13 @@ class TestSimplifyTemplate : public TestFixture {
                             "class C: public A<char[M]> {};\n"
                             "\n"
                             "C<2> a;\n";
-        // TODO: expand A also
-        ASSERT_EQUALS("template < class T > class A { public: T x ; } ; class C<2> ; C<2> a ; class C<2> : public A < char [ 2 ] > { } ;", tok(code));
+        ASSERT_EQUALS("class A<char[2]> ; class C<2> ; C<2> a ; class C<2> : public A<char[2]> { } ; class A<char[2]> { public: char [ 2 ] x ; } ;", tok(code));
     }
 
     void template27() {
         // #3350 - template inside macro call
         const char code[] = "X(template<class T> class Fred);";
-        ASSERT_THROW(tok(code), InternalError);
+        ASSERT_THROW_INTERNAL(tok(code), SYNTAX);
     }
 
     void template28() {
@@ -919,7 +1023,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template <typename T> struct X { void f(X<T> &x) {} };\n"
                             "}\n"
                             "template <> int X<int>::Y(0);";
-        tok(code);
+        (void)tok(code);
     }
 
     void template35() { // #4074 - "A<'x'> a;" is not recognized as template instantiation
@@ -970,8 +1074,8 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     void template_unhandled() {
-        // An unhandled template usage should be simplified..
-        ASSERT_EQUALS("x<int> ( ) ;", tok("x<int>();"));
+        // An unhandled template usage should not be simplified..
+        ASSERT_EQUALS("x < int > ( ) ;", tok("x<int>();"));
     }
 
     void template38() { // #4832 - Crash on C++11 right angle brackets
@@ -1012,7 +1116,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "  vector<vector<int>> v;"
                             "  const vector<int> vi = static_cast<vector<int>>(v);"
                             "}";
-        tok(code);
+        (void)tok(code);
     }
 
     void template40() { // #5055 - false negatives when there is template specialization outside struct
@@ -1051,7 +1155,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "    return sizeof...(args);\n"
                             "  }();\n"
                             "}";
-        ASSERT_THROW(tok(code), InternalError);
+        ASSERT_THROW_INTERNAL(tok(code), SYNTAX);
     }
 
     void template43() { // #5097 - Assert due to '>>' in 'B<A<C>>' not being treated as end of template instantiation
@@ -1147,38 +1251,38 @@ class TestSimplifyTemplate : public TestFixture {
                                 "struct TypeMath<int,Constants::fourtytwo> { "
                                 "static const int mult = sizeof ( int ) * Constants :: fourtytwo ; "
                                 "} ;";
-        ASSERT_EQUALS(expected, tok(code, true));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(expected, tok(code, dinit(CheckOptions, $.debugwarnings = true)));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void template46() { // #5816
-        tok("template<class T, class U> struct A { static const int value = 0; }; "
-            "template <class T> struct B { "
-            "  enum { value = A<typename T::type, int>::value }; "
-            "};");
-        ASSERT_EQUALS("", errout.str());
-        tok("template <class T, class U> struct A {}; "
-            "enum { e = sizeof(A<int, int>) }; "
-            "template <class T, class U> struct B {};");
-        ASSERT_EQUALS("", errout.str());
-        tok("template<class T, class U> struct A { static const int value = 0; }; "
-            "template<class T> struct B { typedef int type; }; "
-            "template <class T> struct C { "
-            "  enum { value = A<typename B<T>::type, int>::value }; "
-            "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_NO_THROW(tok("template<class T, class U> struct A { static const int value = 0; }; "
+                            "template <class T> struct B { "
+                            "  enum { value = A<typename T::type, int>::value }; "
+                            "};"));
+        ASSERT_EQUALS("", errout_str());
+        ASSERT_NO_THROW(tok("template <class T, class U> struct A {}; "
+                            "enum { e = sizeof(A<int, int>) }; "
+                            "template <class T, class U> struct B {};"));
+        ASSERT_EQUALS("", errout_str());
+        ASSERT_NO_THROW(tok("template<class T, class U> struct A { static const int value = 0; }; "
+                            "template<class T> struct B { typedef int type; }; "
+                            "template <class T> struct C { "
+                            "  enum { value = A<typename B<T>::type, int>::value }; "
+                            "};"));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void template47() { // #6023
-        tok("template <typename T1, typename T2 = T3<T1> > class C1 {}; "
-            "class C2 : public C1<C2> {};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_NO_THROW(tok("template <typename T1, typename T2 = T3<T1> > class C1 {}; "
+                            "class C2 : public C1<C2> {};"));
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void template48() { // #6134
-        tok("template <int> int f( {  } ); "
-            "int foo = f<1>(0);");
-        ASSERT_EQUALS("", errout.str());
+    void template48() { // #6134 (hang)
+        (void)tok("template <int> int f( {  } ); "
+                  "int foo = f<1>(0);");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void template49() { // #6237
@@ -1218,17 +1322,6 @@ class TestSimplifyTemplate : public TestFixture {
         ASSERT_EQUALS(expected, tok(code));
     }
 
-    void template51() { // #6172
-        tok("template<int N, int ... M> struct A { "
-            "  static void foo() { "
-            "    int i = N; "
-            "  } "
-            "}; "
-            "void bar() { "
-            "  A<0>::foo(); "
-            "}");
-    }
-
     void template52() { // #6437
         const char code[] = "template <int value> int sum() { "
                             "  return value + sum<value/2>(); "
@@ -1245,7 +1338,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "int calculate_value<1,1> ( ) ; "
                                 "int value ; value = calculate_value<1,1> ( ) ; "
                                 "int calculate_value<1,1> ( ) { "
-                                "if ( 1 != 1 ) { "
+                                "if ( ( int ) 1 != ( int ) 1 ) { "
                                 "return sum<0> ( ) ; "
                                 "} else { "
                                 "return 0 ; "
@@ -1275,28 +1368,28 @@ class TestSimplifyTemplate : public TestFixture {
                                 "} ; "
                                 "const int x = Factorial<4> :: value ; "
                                 "struct Factorial<4> { "
-                                "enum Anonymous0 { value = 4 * Factorial<3> :: value } ; "
+                                "enum Anonymous0 { value = ( int ) 4 * Factorial<3> :: value } ; "
                                 "} ; "
                                 "struct Factorial<3> { "
-                                "enum Anonymous0 { value = 3 * Factorial<2> :: value } ; "
+                                "enum Anonymous0 { value = ( int ) 3 * Factorial<2> :: value } ; "
                                 "} ; "
                                 "struct Factorial<2> { "
-                                "enum Anonymous0 { value = 2 * Factorial<1> :: value } ; "
+                                "enum Anonymous0 { value = ( int ) 2 * Factorial<1> :: value } ; "
                                 "} ; "
                                 "struct Factorial<1> { "
-                                "enum Anonymous0 { value = 1 * Factorial<0> :: value } ; "
+                                "enum Anonymous0 { value = ( int ) 1 * Factorial<0> :: value } ; "
                                 "} ;";
-        ASSERT_EQUALS(expected, tok(code, true));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(expected, tok(code, dinit(CheckOptions, $.debugwarnings = true)));
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void template54() { // #6587
-        tok("template<typename _Tp> _Tp* fn(); "
-            "template <class T> struct A { "
-            "  template <class U, class S = decltype(fn<T>())> "
-            "  struct B { }; "
-            "}; "
-            "A<int> a;");
+    void template54() { // #6587 (use-after-free)
+        (void)tok("template<typename _Tp> _Tp* fn(); "
+                  "template <class T> struct A { "
+                  "  template <class U, class S = decltype(fn<T>())> "
+                  "  struct B { }; "
+                  "}; "
+                  "A<int> a;");
     }
 
     void template55() { // #6604
@@ -1346,16 +1439,16 @@ class TestSimplifyTemplate : public TestFixture {
                                 "} struct Foo<true> { "
                                 "std :: array < int , 1 > mfoo ; "
                                 "} ;";
-        ASSERT_EQUALS(expected, tok(code, true));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(expected, tok(code, dinit(CheckOptions, $.debugwarnings = true)));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void template57() { // #7891
         const char code[] = "template<class T> struct Test { Test(T); };\n"
                             "Test<unsigned long> test( 0 );";
-        const char exp [] = "struct Test<unsignedlong> ; "
-                            "Test<unsignedlong> test ( 0 ) ; "
-                            "struct Test<unsignedlong> { Test<unsignedlong> ( unsigned long ) ; } ;";
+        const char exp[] = "struct Test<unsignedlong> ; "
+                           "Test<unsignedlong> test ( 0 ) ; "
+                           "struct Test<unsignedlong> { Test<unsignedlong> ( unsigned long ) ; } ;";
         ASSERT_EQUALS(exp, tok(code));
     }
 
@@ -1402,10 +1495,10 @@ class TestSimplifyTemplate : public TestFixture {
                            "int diagonalGroupTest<4> ( ) ; "
                            "int main ( ) { return diagonalGroupTest<4> ( ) ; } "
                            "int diagonalGroupTest<4> ( ) { return Factorial<4> :: value ; } "
-                           "struct Factorial<4> { enum FacHelper { value = 4 * Factorial<3> :: value } ; } ; "
-                           "struct Factorial<3> { enum FacHelper { value = 3 * Factorial<2> :: value } ; } ; "
-                           "struct Factorial<2> { enum FacHelper { value = 2 * Factorial<1> :: value } ; } ; "
-                           "struct Factorial<1> { enum FacHelper { value = 1 * Factorial<0> :: value } ; } ;";
+                           "struct Factorial<4> { enum FacHelper { value = ( int ) 4 * Factorial<3> :: value } ; } ; "
+                           "struct Factorial<3> { enum FacHelper { value = ( int ) 3 * Factorial<2> :: value } ; } ; "
+                           "struct Factorial<2> { enum FacHelper { value = ( int ) 2 * Factorial<1> :: value } ; } ; "
+                           "struct Factorial<1> { enum FacHelper { value = ( int ) 1 * Factorial<0> :: value } ; } ;";
         ASSERT_EQUALS(exp, tok(code));
     }
 
@@ -1456,6 +1549,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template <class T, unsigned S> C3<T, S>::C3(const C3<T, S> &v) { C1<T *> c1; }\n"
                             "C3<int,6> c3;";
         const char exp[] = "struct C1<int*> ; "
+                           "template < class T > void f ( ) { x = y ? ( C1 < int > :: allocate ( 1 ) ) : 0 ; } "
                            "class C3<int,6> ; "
                            "C3<int,6> c3 ; "
                            "class C3<int,6> { } ; "
@@ -1488,25 +1582,25 @@ class TestSimplifyTemplate : public TestFixture {
                             "    t_func<1>();\n"
                             "}\n"
                             "};";
-        const char exp [] = "bool foo<int> ( ) ; "
-                            "struct A { "
-                            "void t_func<0> ( ) ; "
-                            "void t_func<1> ( ) ; "
-                            "void t_caller ( ) "
-                            "{ "
-                            "t_func<0> ( ) ; "
-                            "t_func<1> ( ) ; "
-                            "} "
-                            "} ; "
-                            "void A :: t_func<0> ( ) "
-                            "{ "
-                            "if ( 0 != 0 || foo<int> ( ) ) { ; } "
-                            "} "
-                            "void A :: t_func<1> ( ) "
-                            "{ "
-                            "if ( 1 != 0 || foo<int> ( ) ) { ; } "
-                            "} "
-                            "bool foo<int> ( ) { return true ; }";
+        const char exp[] = "bool foo<int> ( ) ; "
+                           "struct A { "
+                           "void t_func<0> ( ) ; "
+                           "void t_func<1> ( ) ; "
+                           "void t_caller ( ) "
+                           "{ "
+                           "t_func<0> ( ) ; "
+                           "t_func<1> ( ) ; "
+                           "} "
+                           "} ; "
+                           "void A :: t_func<0> ( ) "
+                           "{ "
+                           "if ( ( int ) 0 != 0 || foo<int> ( ) ) { ; } "
+                           "} "
+                           "void A :: t_func<1> ( ) "
+                           "{ "
+                           "if ( ( int ) 1 != 0 || foo<int> ( ) ) { ; } "
+                           "} "
+                           "bool foo<int> ( ) { return true ; }";
         ASSERT_EQUALS(exp, tok(code));
     }
 
@@ -1526,17 +1620,17 @@ class TestSimplifyTemplate : public TestFixture {
                             "  AssociationDAGlobalGraphObserver<string,unsigned int> grObs;\n"
                             " return 1;\n"
                             "}";
-        const char exp [] = "namespace bpp "
-                            "{ "
-                            "class AssociationDAGraphImplObserver<string,unsignedint,DAGlobalGraph> ; "
-                            "} "
-                            "using namespace bpp ; "
-                            "int main ( ) { "
-                            "bpp :: AssociationDAGraphImplObserver<string,unsignedint,DAGlobalGraph> grObs ; "
-                            "return 1 ; "
-                            "} class bpp :: AssociationDAGraphImplObserver<string,unsignedint,DAGlobalGraph> : "
-                            "public AssociationGraphImplObserver < std :: string , unsigned int , DAGlobalGraph > "
-                            "{ } ;";
+        const char exp[] = "namespace bpp "
+                           "{ "
+                           "class AssociationDAGraphImplObserver<string,unsignedint,DAGlobalGraph> ; "
+                           "} "
+                           "using namespace bpp ; "
+                           "int main ( ) { "
+                           "bpp :: AssociationDAGraphImplObserver<string,unsignedint,DAGlobalGraph> grObs ; "
+                           "return 1 ; "
+                           "} class bpp :: AssociationDAGraphImplObserver<string,unsignedint,DAGlobalGraph> : "
+                           "public AssociationGraphImplObserver < std :: string , unsigned int , DAGlobalGraph > "
+                           "{ } ;";
         ASSERT_EQUALS(exp, tok(code));
     }
 
@@ -1546,12 +1640,12 @@ class TestSimplifyTemplate : public TestFixture {
                             "};\n"
                             "template <class T> const int ** Fred<T>::foo() { return nullptr; }\n"
                             "Fred<int> fred;";
-        const char exp [] = "struct Fred<int> ; "
-                            "Fred<int> fred ; "
-                            "struct Fred<int> { "
-                            "const int * * foo ( ) ; "
-                            "} ; "
-                            "const int * * Fred<int> :: foo ( ) { return nullptr ; }";
+        const char exp[] = "struct Fred<int> ; "
+                           "Fred<int> fred ; "
+                           "struct Fred<int> { "
+                           "const int * * foo ( ) ; "
+                           "} ; "
+                           "const int * * Fred<int> :: foo ( ) { return nullptr ; }";
         ASSERT_EQUALS(exp, tok(code));
     }
 
@@ -1594,12 +1688,12 @@ class TestSimplifyTemplate : public TestFixture {
                             "    T value;\n"
                             "};\n"
                             "Fred<int> fred;";
-        const char exp [] = "union Fred<int> ; "
-                            "Fred<int> fred ; "
-                            "union Fred<int> { "
-                            "char dummy [ sizeof ( int ) ] ; "
-                            "int value ; "
-                            "} ;";
+        const char exp[] = "union Fred<int> ; "
+                           "Fred<int> fred ; "
+                           "union Fred<int> { "
+                           "char dummy [ sizeof ( int ) ] ; "
+                           "int value ; "
+                           "} ;";
         ASSERT_EQUALS(exp, tok(code));
     }
 
@@ -1609,12 +1703,12 @@ class TestSimplifyTemplate : public TestFixture {
                             "    template <class T> T lookup() { return test; }\n"
                             "    int Fun() { return lookup<int>(); }\n"
                             "};";
-        const char exp [] = "class Test { "
-                            "int test ; "
-                            "int lookup<int> ( ) ; "
-                            "int Fun ( ) { return lookup<int> ( ) ; } "
-                            "} ; "
-                            "int Test :: lookup<int> ( ) { return test ; }";
+        const char exp[] = "class Test { "
+                           "int test ; "
+                           "int lookup<int> ( ) ; "
+                           "int Fun ( ) { return lookup<int> ( ) ; } "
+                           "} ; "
+                           "int Test :: lookup<int> ( ) { return test ; }";
         ASSERT_EQUALS(exp, tok(code));
     }
 
@@ -1627,22 +1721,22 @@ class TestSimplifyTemplate : public TestFixture {
                             "class Bar : private Bar<void, void> {\n"
                             "   void foo() { }\n"
                             "};";
-        const char exp [] = "template < typename T , typename V , int KeySize = 0 > class Bar ; "
-                            "class Bar<void,void> ; "
-                            "class Bar<void,void> { "
-                            "} ; "
-                            "template < typename K , typename V , int KeySize = 0 > "
-                            "class Bar : private Bar<void,void> { "
-                            "void foo ( ) { } "
-                            "} ;";
-        const char act [] = "template < typename T , typename V , int KeySize = 0 > class Bar ; "
-                            "class Bar<void,void> { "
-                            "} ; "
-                            "class Bar<void,void> ; "
-                            "template < typename K , typename V , int KeySize = 0 > "
-                            "class Bar : private Bar<void,void> { "
-                            "void foo ( ) { } "
-                            "} ;";
+        const char exp[] = "template < typename T , typename V , int KeySize = 0 > class Bar ; "
+                           "class Bar<void,void> ; "
+                           "class Bar<void,void> { "
+                           "} ; "
+                           "template < typename K , typename V , int KeySize = 0 > "
+                           "class Bar : private Bar<void,void> { "
+                           "void foo ( ) { } "
+                           "} ;";
+        const char act[] = "template < typename T , typename V , int KeySize = 0 > class Bar ; "
+                           "class Bar<void,void> { "
+                           "} ; "
+                           "class Bar<void,void> ; "
+                           "template < typename K , typename V , int KeySize = 0 > "
+                           "class Bar : private Bar<void,void> { "
+                           "void foo ( ) { } "
+                           "} ;";
         TODO_ASSERT_EQUALS(exp, act, tok(code));
     }
 
@@ -1659,11 +1753,11 @@ class TestSimplifyTemplate : public TestFixture {
                             "}\n"
                             "\n"
                             "Reference< class XPropertyList > dostuff();";
-        const char exp [] = "int f1 ( int * pInterface , int x ) { return 0 ; } "
-                            "class Reference<XPropertyList> ; "
-                            "Reference<XPropertyList> dostuff ( ) ; "
-                            "class Reference<XPropertyList> { template < class XPropertyList > int i ( ) ; int * pInterface ; } ; "
-                            "int Reference<XPropertyList> :: i ( ) { return f1 ( pInterface , XPropertyList :: static_type ( ) ) ; }";
+        const char exp[] = "int f1 ( int * pInterface , int x ) { return 0 ; } "
+                           "class Reference<XPropertyList> ; "
+                           "Reference<XPropertyList> dostuff ( ) ; "
+                           "class Reference<XPropertyList> { template < class XPropertyList > int i ( ) ; int * pInterface ; } ; "
+                           "int Reference<XPropertyList> :: i ( ) { return f1 ( pInterface , XPropertyList :: static_type ( ) ) ; }";
         ASSERT_EQUALS(exp, tok(code));
     }
 
@@ -1672,10 +1766,10 @@ class TestSimplifyTemplate : public TestFixture {
                             "const Tokenizer<Node, Path> *tokenizer() const;\n"
                             "template <typename N, typename P>\n"
                             "Tokenizer<N, P>::Tokenizer() { }";
-        const char exp [] = "template < typename N , typename P > class Tokenizer ; "
-                            "const Tokenizer < Node , Path > * tokenizer ( ) const ; "
-                            "template < typename N , typename P > "
-                            "Tokenizer < N , P > :: Tokenizer ( ) { }";
+        const char exp[] = "template < typename N , typename P > class Tokenizer ; "
+                           "const Tokenizer < Node , Path > * tokenizer ( ) const ; "
+                           "template < typename N , typename P > "
+                           "Tokenizer < N , P > :: Tokenizer ( ) { }";
         ASSERT_EQUALS(exp, tok(code));
     }
 
@@ -1928,7 +2022,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "template<typename U, typename std::enable_if<(!std::is_fundamental<U>::value)>::type>\n"
                             "void C<T>::foo() {}";
         // @todo the output is very wrong but we are only worried about the crash for now
-        tok(code);
+        (void)tok(code);
     }
 
     void template86() { // crash
@@ -1943,14 +2037,14 @@ class TestSimplifyTemplate : public TestFixture {
                             "S<T> U<T>::u;\n"
                             "template S<int> U<int>::u;\n"
                             "S<int> &i = U<int>::u;";
-        tok(code);
+        (void)tok(code);
     }
 
     void template87() {
         const char code[] = "template<typename T>\n"
                             "T f1(T t) { return t; }\n"
-                            "template const char * f1<const char *>();\n"
-                            "template const char & f1<const char &>();";
+                            "template const char * f1<const char *>(const char *);\n"
+                            "template const char & f1<const char &>(const char &);";
         const char exp[] = "const char * f1<constchar*> ( const char * t ) ; "
                            "const char & f1<constchar&> ( const char & t ) ; "
                            "const char * f1<constchar*> ( const char * t ) { return t ; } "
@@ -2077,24 +2171,66 @@ class TestSimplifyTemplate : public TestFixture {
                                 "        template<typename T> T foo(T t) { return t; }\n"
                                 "        template<> char foo<char>(char a) { return a; }\n"
                                 "        template<> int foo<int>(int a) { return a; }\n"
+                                "        template short NS2::foo<short>(short);\n"
+                                "        template long NS1::NS2::foo<long>(long);\n"
                                 "    }\n"
                                 "    template float NS2::foo<float>(float);\n"
+                                "    template bool NS1::NS2::foo<bool>(bool);\n"
                                 "}\n"
                                 "template double NS1::NS2::foo<double>(double);";
             const char exp[] = "namespace NS1 { "
                                "namespace NS2 { "
                                "int foo<int> ( int a ) ; "
                                "char foo<char> ( char a ) ; "
+                               "short foo<short> ( short t ) ; "
+                               "long foo<long> ( long t ) ; "
                                "float foo<float> ( float t ) ; "
+                               "bool foo<bool> ( bool t ) ; "
                                "double foo<double> ( double t ) ; "
                                "char foo<char> ( char a ) { return a ; } "
                                "int foo<int> ( int a ) { return a ; } "
                                "} "
                                "} "
+                               "short NS1 :: NS2 :: foo<short> ( short t ) { return t ; } "
+                               "long NS1 :: NS2 :: foo<long> ( long t ) { return t ; } "
                                "float NS1 :: NS2 :: foo<float> ( float t ) { return t ; } "
+                               "bool NS1 :: NS2 :: foo<bool> ( bool t ) { return t ; } "
                                "double NS1 :: NS2 :: foo<double> ( double t ) { return t ; }";
             ASSERT_EQUALS(exp, tok(code));
         }
+        {
+            const char code[] = "namespace NS1 {\n"
+                                "    namespace NS {\n"
+                                "        template<typename T> T foo(T t) { return t; }\n"
+                                "        template<> char foo<char>(char a) { return a; }\n"
+                                "        template<> int foo<int>(int a) { return a; }\n"
+                                "        template short NS::foo<short>(short);\n"
+                                "        template long NS1::NS::foo<long>(long);\n"
+                                "    }\n"
+                                "    template float NS::foo<float>(float);\n"
+                                "    template bool NS1::NS::foo<bool>(bool);\n"
+                                "}\n"
+                                "template double NS1::NS::foo<double>(double);";
+            const char exp[] = "namespace NS1 { "
+                               "namespace NS { "
+                               "int foo<int> ( int a ) ; "
+                               "char foo<char> ( char a ) ; "
+                               "short foo<short> ( short t ) ; "
+                               "long foo<long> ( long t ) ; "
+                               "float foo<float> ( float t ) ; "
+                               "bool foo<bool> ( bool t ) ; "
+                               "double foo<double> ( double t ) ; "
+                               "char foo<char> ( char a ) { return a ; } "
+                               "int foo<int> ( int a ) { return a ; } "
+                               "} "
+                               "} "
+                               "short NS1 :: NS :: foo<short> ( short t ) { return t ; } "
+                               "long NS1 :: NS :: foo<long> ( long t ) { return t ; } "
+                               "float NS1 :: NS :: foo<float> ( float t ) { return t ; } "
+                               "bool NS1 :: NS :: foo<bool> ( bool t ) { return t ; } "
+                               "double NS1 :: NS :: foo<double> ( double t ) { return t ; }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
     }
 
     void template92() {
@@ -2212,10 +2348,10 @@ class TestSimplifyTemplate : public TestFixture {
                                 "long f1 = fib<1>;\n"
                                 "long f2 = fib<2>;\n"
                                 "long f3 = fib<3>;";
-            const char exp[] = "const long fib<2> = fib<1> + fib<0> ; "
-                               "const long fib<3> = fib<2> + fib<1> ; "
-                               "const long fib<0> = 0 ; "
-                               "const long fib<1> = 1 ; "
+            const char exp[] = "constexpr long fib<2> = fib<1> + fib<0> ; "
+                               "constexpr long fib<3> = fib<2> + fib<1> ; "
+                               "constexpr long fib<0> = 0 ; "
+                               "constexpr long fib<1> = 1 ; "
                                "long f0 ; f0 = fib<0> ; "
                                "long f1 ; f1 = fib<1> ; "
                                "long f2 ; f2 = fib<2> ; "
@@ -2230,12 +2366,12 @@ class TestSimplifyTemplate : public TestFixture {
                                 "template<>\n"
                                 "  constexpr long fib<1> = 1;\n"
                                 "long f5 = fib<5>;\n";
-            const char exp[] = "const long fib<5> = fib<4> + fib<3> ; "
-                               "const long fib<4> = fib<3> + fib<2> ; "
-                               "const long fib<3> = fib<2> + fib<1> ; "
-                               "const long fib<2> = fib<1> + fib<0> ; "
-                               "const long fib<0> = 0 ; "
-                               "const long fib<1> = 1 ; "
+            const char exp[] = "constexpr long fib<5> = fib<4> + fib<3> ; "
+                               "constexpr long fib<4> = fib<3> + fib<2> ; "
+                               "constexpr long fib<3> = fib<2> + fib<1> ; "
+                               "constexpr long fib<2> = fib<1> + fib<0> ; "
+                               "constexpr long fib<0> = 0 ; "
+                               "constexpr long fib<1> = 1 ; "
                                "long f5 ; f5 = fib<5> ;";
             ASSERT_EQUALS(exp, tok(code));
         }
@@ -2243,35 +2379,35 @@ class TestSimplifyTemplate : public TestFixture {
 
     void template97() {
         const char code[] ="namespace NS1 {\n"
-                           "    namespace NS2 {\n"
-                           "        namespace NS3 {\n"
-                           "            namespace NS4 {\n"
-                           "                template<class T>\n"
-                           "                class Fred {\n"
-                           "                    T * t;\n"
-                           "                public:\n"
-                           "                    Fred<T>() : t(nullptr) {}\n"
-                           "                };\n"
-                           "            }\n"
-                           "            using namespace NS4;\n"
-                           "            Fred<bool> fred_bool;\n"
-                           "            NS4::Fred<char> fred_char;\n"
-                           "        }\n"
-                           "        using namespace NS3;\n"
-                           "        NS4::Fred<short> fred_short;\n"
-                           "        using namespace NS3::NS4;\n"
-                           "        Fred<int> fred_int;\n"
-                           "        NS3::NS4::Fred<long> fred_long;\n"
-                           "        NS2::NS3::NS4::Fred<float> fred_float;\n"
-                           "        NS1::NS2::NS3::NS4::Fred<double> fred_double;\n"
-                           "    }\n"
-                           "    using namespace NS2;\n"
-                           "    NS3::NS4::Fred<float> fred_float1;\n"
-                           "    NS2::NS3::NS4::Fred<double> fred_double1;\n"
-                           "}\n"
-                           "using namespace NS1::NS2::NS3::NS4;\n"
-                           "Fred<bool> fred_bool1;\n"
-                           "NS1::NS2::NS3::NS4::Fred<int> fred_int1;";
+                            "    namespace NS2 {\n"
+                            "        namespace NS3 {\n"
+                            "            namespace NS4 {\n"
+                            "                template<class T>\n"
+                            "                class Fred {\n"
+                            "                    T * t;\n"
+                            "                public:\n"
+                            "                    Fred<T>() : t(nullptr) {}\n"
+                            "                };\n"
+                            "            }\n"
+                            "            using namespace NS4;\n"
+                            "            Fred<bool> fred_bool;\n"
+                            "            NS4::Fred<char> fred_char;\n"
+                            "        }\n"
+                            "        using namespace NS3;\n"
+                            "        NS4::Fred<short> fred_short;\n"
+                            "        using namespace NS3::NS4;\n"
+                            "        Fred<int> fred_int;\n"
+                            "        NS3::NS4::Fred<long> fred_long;\n"
+                            "        NS2::NS3::NS4::Fred<float> fred_float;\n"
+                            "        NS1::NS2::NS3::NS4::Fred<double> fred_double;\n"
+                            "    }\n"
+                            "    using namespace NS2;\n"
+                            "    NS3::NS4::Fred<float> fred_float1;\n"
+                            "    NS2::NS3::NS4::Fred<double> fred_double1;\n"
+                            "}\n"
+                            "using namespace NS1::NS2::NS3::NS4;\n"
+                            "Fred<bool> fred_bool1;\n"
+                            "NS1::NS2::NS3::NS4::Fred<int> fred_int1;";
         const char exp[] = "namespace NS1 { "
                            "namespace NS2 { "
                            "namespace NS3 { "
@@ -2406,13 +2542,13 @@ class TestSimplifyTemplate : public TestFixture {
                            "} ;";
 
         ASSERT_EQUALS(exp, tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void template102() { // #9005
         const char code[] = "namespace ns {\n"
                             "template <class T>\n"
-                            "struct is_floating_point \n"
+                            "struct is_floating_point\n"
                             ": std::integral_constant<bool, std::is_floating_point<T>::value || true>\n"
                             "{};\n"
                             "}\n"
@@ -2491,8 +2627,8 @@ class TestSimplifyTemplate : public TestFixture {
                             "template <typename T> class Fred {};\n"
                             "ObjectCache<Fred> _cache;";
         const char exp[] = "class ObjectCache<Fred> ; "
-                           "ObjectCache<Fred> _cache ; "
-                           "class ObjectCache<Fred> { } ;";
+                           "template < typename T > class Fred { } ; "
+                           "ObjectCache<Fred> _cache ; class ObjectCache<Fred> { } ;";
         ASSERT_EQUALS(exp, tok(code));
     }
 
@@ -2751,10 +2887,10 @@ class TestSimplifyTemplate : public TestFixture {
                                 "template <bool> struct e;\n"
                                 "template <typename a> using f = typename e<c<d<a>>::g>::h;";
             const char exp[] =  "template < typename a , a > struct b { } ; "
-                                "template < typename > struct c ; "
-                                "template < typename > struct d : b < bool , std :: is_polymorphic < int > { } > { } ; "
-                                "template < bool > struct e ; "
-                                "template < typename a > using f = typename e < c < d < a > > :: g > :: h ;";
+                               "template < typename > struct c ; "
+                               "template < typename > struct d : b < bool , std :: is_polymorphic < int > { } > { } ; "
+                               "template < bool > struct e ; "
+                               "template < typename a > using f = typename e < c < d < a > > :: g > :: h ;";
             ASSERT_EQUALS(exp, tok(code));
         }
         {
@@ -2763,9 +2899,9 @@ class TestSimplifyTemplate : public TestFixture {
                                 "template <typename a> struct d : b<bool, std::is_empty<a>{}> {};\n"
                                 "template <typename a> using e = typename c<std::is_final<a>{}, d<a>>::f;\n";
             const char exp[] =  "template < typename a , a > struct b ; "
-                                "template < bool , typename > struct c ; "
-                                "template < typename a > struct d : b < bool , std :: is_empty < a > { } > { } ; "
-                                "template < typename a > using e = typename c < std :: is_final < a > { } , d < a > > :: f ;";
+                               "template < bool , typename > struct c ; "
+                               "template < typename a > struct d : b < bool , std :: is_empty < a > { } > { } ; "
+                               "template < typename a > using e = typename c < std :: is_final < a > { } , d < a > > :: f ;";
             ASSERT_EQUALS(exp, tok(code));
         }
     }
@@ -2790,7 +2926,7 @@ class TestSimplifyTemplate : public TestFixture {
                            "struct f<b::B<0>> ; "
                            "} "
                            "} "
-                           "b :: f<b::B<0>> g1 ; struct b :: B<0> { using B<0> :: d ; } ; "
+                           "b :: f<b::B<0>> g1 ; struct b :: B<0> { using d = B<0> :: d ; } ; "
                            "struct b :: f<b::B<0>> { } ;";
         ASSERT_EQUALS(exp, tok(code));
     }
@@ -2849,8 +2985,8 @@ class TestSimplifyTemplate : public TestFixture {
                                 "constexpr auto funcBraced = [](auto x){ return T{x};};\n"
                                 "double f(int x) { return func<double>(x); }\n"
                                 "double fBraced(int x) { return funcBraced<int>(x); }";
-            const char exp[] = "const auto func<double> = [ ] ( auto x ) { return double ( x ) ; } ; "
-                               "const auto funcBraced<int> = [ ] ( auto x ) { return int { x } ; } ; "
+            const char exp[] = "constexpr auto func<double> = [ ] ( auto x ) { return double ( x ) ; } ; "
+                               "constexpr auto funcBraced<int> = [ ] ( auto x ) { return int { x } ; } ; "
                                "double f ( int x ) { return func<double> ( x ) ; } "
                                "double fBraced ( int x ) { return funcBraced<int> ( x ) ; }";
             ASSERT_EQUALS(exp, tok(code));
@@ -2862,8 +2998,8 @@ class TestSimplifyTemplate : public TestFixture {
                                 "    func<int>(x);\n"
                                 "    func<double>(x);\n"
                                 "}";
-            const char exp[] = "const auto func<int> = [ ] ( auto x ) { return int ( x ) ; } ; "
-                               "const auto func<double> = [ ] ( auto x ) { return double ( x ) ; } ; "
+            const char exp[] = "constexpr auto func<int> = [ ] ( auto x ) { return int ( x ) ; } ; "
+                               "constexpr auto func<double> = [ ] ( auto x ) { return double ( x ) ; } ; "
                                "void foo ( ) { "
                                "func<int> ( x ) ; "
                                "func<double> ( x ) ; "
@@ -2970,14 +3106,14 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     void template125() {
-        ASSERT_THROW(tok("template<int M, int N>\n"
-                         "class GCD {\n"
-                         "public:\n"
-                         "  enum { val = (N == 0) ? M : GCD<N, M % N>::val };\n"
-                         "};\n"
-                         "int main() {\n"
-                         "  GCD< 1, 0 >::val;\n"
-                         "}"), InternalError);
+        ASSERT_THROW_INTERNAL(tok("template<int M, int N>\n"
+                                  "class GCD {\n"
+                                  "public:\n"
+                                  "  enum { val = (N == 0) ? M : GCD<N, M % N>::val };\n"
+                                  "};\n"
+                                  "int main() {\n"
+                                  "  GCD< 1, 0 >::val;\n"
+                                  "}"), INSTANTIATION);
     }
 
     void template126() { // #9217
@@ -3000,19 +3136,19 @@ class TestSimplifyTemplate : public TestFixture {
                                "a<int> c ; "
                                "template < typename d > "
                                "template < typename b > "
-                               "const decltype ( auto ) a < d > :: operator() ( b & & ) const { } "
+                               "constexpr decltype ( auto ) a < d > :: operator() ( b && ) const { } "
                                "struct a<int> { "
-                               "template < typename b > const decltype ( auto ) operator() ( b & & ) const ; "
+                               "template < typename b > constexpr decltype ( auto ) operator() ( b && ) const ; "
                                "} ;";
             const char act[] = "struct a<int> ; "
                                "a<int> c ; "
                                "template < typename d > "
                                "template < typename b > "
-                               "const decltype ( auto ) a < d > :: operator() ( b & & ) const { } "
+                               "constexpr decltype ( auto ) a < d > :: operator() ( b && ) const { } "
                                "struct a<int> { "
-                               "template < typename b > const decltype ( auto ) operator() ( b & & ) const ; "
+                               "template < typename b > constexpr decltype ( auto ) operator() ( b && ) const ; "
                                "} ; "
-                               "const decltype ( auto ) a<int> :: operator() ( b & & ) const { }";
+                               "constexpr decltype ( auto ) a<int> :: operator() ( b && ) const { }";
             TODO_ASSERT_EQUALS(exp, act, tok(code));
         }
         {
@@ -3131,6 +3267,14 @@ class TestSimplifyTemplate : public TestFixture {
                                "struct b<1,false> { } ;";
             ASSERT_EQUALS(exp, tok(code));
         }
+        {
+            const char code[] = "template <long a, bool = 0 != a> struct b {};\n"
+                                "b<1> b1;";
+            const char exp[] = "struct b<1,true> ; "
+                               "b<1,true> b1 ; "
+                               "struct b<1,true> { } ;";
+            ASSERT_EQUALS(exp, tok(code));
+        }
         {
             const char code[] = "template <long a, bool = a < 0> struct b {};\n"
                                 "b<1> b1;";
@@ -3147,6 +3291,22 @@ class TestSimplifyTemplate : public TestFixture {
                                "struct b<1,true> { } ;";
             ASSERT_EQUALS(exp, tok(code));
         }
+        {
+            const char code[] = "template <long a, bool = 0 <= a> struct b {};\n"
+                                "b<1> b1;";
+            const char exp[] = "struct b<1,true> ; "
+                               "b<1,true> b1 ; "
+                               "struct b<1,true> { } ;";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+        {
+            const char code[] = "template <long a, bool = a >= 0> struct b {};\n"
+                                "b<1> b1;";
+            const char exp[] = "struct b<1,true> ; "
+                               "b<1,true> b1 ; "
+                               "struct b<1,true> { } ;";
+            ASSERT_EQUALS(exp, tok(code));
+        }
     }
 
     void template132() { // #9250
@@ -3162,7 +3322,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "  return foo<TrueFalse>();\n"
                             "}";
         const char exp[] = "struct TrueFalse { "
-                           "static const bool v ( ) { return true ; } "
+                           "static constexpr bool v ( ) { return true ; } "
                            "} ; "
                            "int global ; "
                            "int foo<TrueFalse> ( ) ; "
@@ -3283,8 +3443,8 @@ class TestSimplifyTemplate : public TestFixture {
                            "template < bool b , class > using c = typename a < b > :: d ; "
                            "template < class , template < class > class , class > struct e ; "
                            "template < class f , class g , class ... h > "
-                           "using i = typename e < f , g :: template fn , h ... > :: d ; "
-                           "template < class ... j > struct k : c < sizeof... ( j ) , int > :: template fn < j ... > { } ;";
+                           "using i = typename e < f , g :: fn , h ... > :: d ; "
+                           "template < class ... j > struct k : c < sizeof... ( j ) , int > :: fn < j ... > { } ;";
         ASSERT_EQUALS(exp, tok(code));
     }
 
@@ -3430,11 +3590,11 @@ class TestSimplifyTemplate : public TestFixture {
                                 "static_assert(!e<f<char>>());\n"
                                 "}";
             const char exp[] = "namespace a { "
-                               "const bool e<f<char>> ( ) ; "
+                               "constexpr bool e<f<char>> ( ) ; "
                                "class f<char> ; "
                                "static_assert ( ! e<f<char>> ( ) ) ; } "
                                "class a :: f<char> { f<char> ( a :: f < b :: d > ) ; } ; "
-                               "const bool a :: e<f<char>> ( ) { return false ; }";
+                               "constexpr bool a :: e<f<char>> ( ) { return false ; }";
             ASSERT_EQUALS(exp, tok(code));
         }
     }
@@ -3459,7 +3619,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "};";
         const char exp[] = "template < typename ... > struct a ; "
                            "template < typename b , typename c , typename ... d > struct a < b c :: * , d ... > { "
-                           "using b :: e ; "
+                           "using e = b :: e ; "
                            "static_assert ( e :: f ? sizeof... ( d ) : sizeof... ( d ) , \"\" ) ; "
                            "} ;";
         ASSERT_EQUALS(exp, tok(code));
@@ -3473,16 +3633,16 @@ class TestSimplifyTemplate : public TestFixture {
                             "using A2 = struct B2 { void f(T){} };\n"
                             "A2<bool> a2;\n"
                             "template<class T>\n"
-                            "using A3 = enum B3 {b = 0;};\n"
+                            "using A3 = enum B3 {b = 0};\n"
                             "A3<int> a3;";
         const char exp[] = "template < int N > "
-                           "using A1 = struct B1 { static const auto value = N ; } ; "
+                           "using A1 = struct B1 { static auto constexpr value = N ; } ; "
                            "A1 < 0 > a1 ; "
                            "template < class T > "
                            "using A2 = struct B2 { void f ( T ) { } } ; "
                            "A2 < bool > a2 ; "
                            "template < class T > "
-                           "using A3 = enum B3 { b = 0 ; } ; "
+                           "using A3 = enum B3 { b = 0 } ; "
                            "A3 < int > a3 ;";
         ASSERT_EQUALS(exp, tok(code));
     }
@@ -3549,7 +3709,7 @@ class TestSimplifyTemplate : public TestFixture {
         const char code[] = "BEGIN_VERSIONED_NAMESPACE_DECL\n"
                             "template<typename T> class Fred { };\n"
                             "END_VERSIONED_NAMESPACE_DECL";
-        ASSERT_THROW_EQUALS(tok(code), InternalError, "There is an unknown macro here somewhere. Configuration is required. If BEGIN_VERSIONED_NAMESPACE_DECL is a macro then please configure it.");
+        ASSERT_THROW_INTERNAL_EQUALS(tok(code), UNKNOWN_MACRO, "There is an unknown macro here somewhere. Configuration is required. If BEGIN_VERSIONED_NAMESPACE_DECL is a macro then please configure it.");
     }
 
     void template150() { // syntax error
@@ -3571,6 +3731,973 @@ class TestSimplifyTemplate : public TestFixture {
         ASSERT_EQUALS(exp, tok(code));
     }
 
+    void template151() { // crash
+        {
+            const char code[] = "class SimulationComponentGroupGenerator {\n"
+                                "  std::list<int, std::allocator<int>> build() const;\n"
+                                "};\n"
+                                "template <\n"
+                                "  class obj_type,\n"
+                                "  template<class> class allocator = std::allocator,\n"
+                                "  template<class, class> class data_container = std::list>\n"
+                                "class GenericConfigurationHandler {\n"
+                                "  data_container<int, std::allocator<int>> m_target_configurations;\n"
+                                "};\n"
+                                "class TargetConfigurationHandler : public GenericConfigurationHandler<int> { };";
+            const char exp[] = "class SimulationComponentGroupGenerator { "
+                               "std :: list < int , std :: allocator < int > > build ( ) const ; "
+                               "} ; "
+                               "class GenericConfigurationHandler<int,std::allocator,std::list> ; "
+                               "class TargetConfigurationHandler : public GenericConfigurationHandler<int,std::allocator,std::list> { } ; "
+                               "class GenericConfigurationHandler<int,std::allocator,std::list> { "
+                               "std :: list < int , std :: allocator < int > > m_target_configurations ; "
+                               "} ;";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+        {
+            const char code[] = "std::list<std::allocator<int>> a;\n"
+                                "template <class, template <class> class allocator = std::allocator> class b {};\n"
+                                "class c : b<int> {};";
+            const char exp[] = "std :: list < std :: allocator < int > > a ; "
+                               "class b<int,std::allocator> ; "
+                               "class c : b<int,std::allocator> { } ; "
+                               "class b<int,std::allocator> { } ;";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+        {
+            const char code[] = "template <typename> class a {};\n"
+                                "template class a<char>;\n"
+                                "template <class, template <class> class a = a> class b {};\n"
+                                "class c : b<int> {};";
+            const char exp[] = "class a<char> ; "
+                               "class b<int,a> ; "
+                               "class c : b<int,a> { } ; "
+                               "class b<int,a> { } ; "
+                               "class a<char> { } ;";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+    }
+
+    void template152() { // #9467
+        const char code[] = "class Foo {\n"
+                            "  template <unsigned int i>\n"
+                            "  bool bar() {\n"
+                            "    return true;\n"
+                            "  }\n"
+                            "};\n"
+                            "template <>\n"
+                            "bool Foo::bar<9>() {\n"
+                            "  return true;\n"
+                            "}\n"
+                            "int global() {\n"
+                            "  int bar = 1;\n"
+                            "  return bar;\n"
+                            "}";
+        const char exp[] = "class Foo { "
+                           "bool bar<9> ( ) ; "
+                           "template < unsigned int i > "
+                           "bool bar ( ) { "
+                           "return true ; "
+                           "} "
+                           "} ; "
+                           "bool Foo :: bar<9> ( ) { "
+                           "return true ; "
+                           "} "
+                           "int global ( ) { "
+                           "int bar ; bar = 1 ; "
+                           "return bar ; "
+                           "}";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template153() { // #9483
+        const char code[] = "template <class = b<decltype(a<h>())...>> void i();";
+        const char exp[] = "template < class = b < decltype ( a < h > ( ) ) ... > > void i ( ) ;";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template154() { // #9495
+        const char code[] = "template <typename S, enable_if_t<(is_compile_string<S>::value), int>> void i(S s);";
+        const char exp[] = "template < typename S , enable_if_t < ( is_compile_string < S > :: value ) , int > > void i ( S s ) ;";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template155() { // #9539
+        const char code[] = "template <int> int a = 0;\n"
+                            "struct b {\n"
+                            "  void operator[](int);\n"
+                            "};\n"
+                            "void c() {\n"
+                            "  b d;\n"
+                            "  d[a<0>];\n"
+                            "}";
+        const char exp[] = "int a<0> ; "
+                           "a<0> = 0 ; "
+                           "struct b { "
+                           "void operator[] ( int ) ; "
+                           "} ; "
+                           "void c ( ) { "
+                           "b d ; "
+                           "d [ a<0> ] ; "
+                           "}";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template156() {
+        const char code[] = "template <int a> struct c { static constexpr int d = a; };\n"
+                            "template <bool b> using e = c<b>;\n"
+                            "using f = e<false>;\n"
+                            "template <typename> struct g : f {};\n"
+                            "template <bool, class, class> using h = e<g<long>::d>;\n"
+                            "template <typename> using i = e<g<double>::d>;\n"
+                            "template <typename j> using k = e<i<j>::d>;\n"
+                            "template <typename j> using l = h<k<j>::d, e<1 < (j)0>, f>;\n"
+                            "template <typename> void m(int, int, int) { l<int> d; }\n"
+                            "void n() { m<int>(0, 4, 5); }";
+        (void)tok(code); // don't crash
+    }
+
+    void template157() { // #9854
+        const char code[] = "template <int a, bool c = a == int()> struct b1 { bool d = c; };\n"
+                            "template <int a, bool c = a != int()> struct b2 { bool d = c; };\n"
+                            "template <int a, bool c = a < int()> struct b3 { bool d = c; };\n"
+                            "template <int a, bool c = a <= int()> struct b4 { bool d = c; };\n"
+                            "template <int a, bool c = (a > int())> struct b5 { bool d = c; };\n"
+                            "template <int a, bool c = a >= int()> struct b6 { bool d = c; };\n"
+                            "b1<0> var1;\n"
+                            "b2<0> var2;\n"
+                            "b3<0> var3;\n"
+                            "b4<0> var4;\n"
+                            "b5<0> var5;\n"
+                            "b6<0> var6;";
+        const char exp[] = "struct b1<0,true> ; "
+                           "struct b2<0,false> ; "
+                           "struct b3<0,false> ; "
+                           "struct b4<0,true> ; "
+                           "struct b5<0,false> ; "
+                           "struct b6<0,true> ; "
+                           "b1<0,true> var1 ; "
+                           "b2<0,false> var2 ; "
+                           "b3<0,false> var3 ; "
+                           "b4<0,true> var4 ; "
+                           "b5<0,false> var5 ; "
+                           "b6<0,true> var6 ; "
+                           "struct b6<0,true> { bool d ; d = true ; } ; "
+                           "struct b5<0,false> { bool d ; d = false ; } ; "
+                           "struct b4<0,true> { bool d ; d = true ; } ; "
+                           "struct b3<0,false> { bool d ; d = false ; } ; "
+                           "struct b2<0,false> { bool d ; d = false ; } ; "
+                           "struct b1<0,true> { bool d ; d = true ; } ;";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template158() { // daca crash
+        const char code[] = "template <typename> class a0{};\n"
+                            "template <typename> class a1{};\n"
+                            "template <typename> class a2{};\n"
+                            "template <typename> class a3{};\n"
+                            "template <typename> class a4{};\n"
+                            "template <typename> class a5{};\n"
+                            "template <typename> class a6{};\n"
+                            "template <typename> class a7{};\n"
+                            "template <typename> class a8{};\n"
+                            "template <typename> class a9{};\n"
+                            "template <typename> class a10{};\n"
+                            "template <typename> class a11{};\n"
+                            "template <typename> class a12{};\n"
+                            "template <typename> class a13{};\n"
+                            "template <typename> class a14{};\n"
+                            "template <typename> class a15{};\n"
+                            "template <typename> class a16{};\n"
+                            "template <typename> class a17{};\n"
+                            "template <typename> class a18{};\n"
+                            "template <typename> class a19{};\n"
+                            "template <typename> class a20{};\n"
+                            "template <typename> class a21{};\n"
+                            "template <typename> class a22{};\n"
+                            "template <typename> class a23{};\n"
+                            "template <typename> class a24{};\n"
+                            "template <typename> class a25{};\n"
+                            "template <typename> class a26{};\n"
+                            "template <typename> class a27{};\n"
+                            "template <typename> class a28{};\n"
+                            "template <typename> class a29{};\n"
+                            "template <typename> class a30{};\n"
+                            "template <typename> class a31{};\n"
+                            "template <typename> class a32{};\n"
+                            "template <typename> class a33{};\n"
+                            "template <typename> class a34{};\n"
+                            "template <typename> class a35{};\n"
+                            "template <typename> class a36{};\n"
+                            "template <typename> class a37{};\n"
+                            "template <typename> class a38{};\n"
+                            "template <typename> class a39{};\n"
+                            "template <typename> class a40{};\n"
+                            "template <typename> class a41{};\n"
+                            "template <typename> class a42{};\n"
+                            "template <typename> class a43{};\n"
+                            "template <typename> class a44{};\n"
+                            "template <typename> class a45{};\n"
+                            "template <typename> class a46{};\n"
+                            "template <typename> class a47{};\n"
+                            "template <typename> class a48{};\n"
+                            "template <typename> class a49{};\n"
+                            "template <typename> class a50{};\n"
+                            "template <typename> class a51{};\n"
+                            "template <typename> class a52{};\n"
+                            "template <typename> class a53{};\n"
+                            "template <typename> class a54{};\n"
+                            "template <typename> class a55{};\n"
+                            "template <typename> class a56{};\n"
+                            "template <typename> class a57{};\n"
+                            "template <typename> class a58{};\n"
+                            "template <typename> class a59{};\n"
+                            "template <typename> class a60{};\n"
+                            "template <typename> class a61{};\n"
+                            "template <typename> class a62{};\n"
+                            "template <typename> class a63{};\n"
+                            "template <typename> class a64{};\n"
+                            "template <typename> class a65{};\n"
+                            "template <typename> class a66{};\n"
+                            "template <typename> class a67{};\n"
+                            "template <typename> class a68{};\n"
+                            "template <typename> class a69{};\n"
+                            "template <typename> class a70{};\n"
+                            "template <typename> class a71{};\n"
+                            "template <typename> class a72{};\n"
+                            "template <typename> class a73{};\n"
+                            "template <typename> class a74{};\n"
+                            "template <typename> class a75{};\n"
+                            "template <typename> class a76{};\n"
+                            "template <typename> class a77{};\n"
+                            "template <typename> class a78{};\n"
+                            "template <typename> class a79{};\n"
+                            "template <typename> class a80{};\n"
+                            "template <typename> class a81{};\n"
+                            "template <typename> class a82{};\n"
+                            "template <typename> class a83{};\n"
+                            "template <typename> class a84{};\n"
+                            "template <typename> class a85{};\n"
+                            "template <typename> class a86{};\n"
+                            "template <typename> class a87{};\n"
+                            "template <typename> class a88{};\n"
+                            "template <typename> class a89{};\n"
+                            "template <typename> class a90{};\n"
+                            "template <typename> class a91{};\n"
+                            "template <typename> class a92{};\n"
+                            "template <typename> class a93{};\n"
+                            "template <typename> class a94{};\n"
+                            "template <typename> class a95{};\n"
+                            "template <typename> class a96{};\n"
+                            "template <typename> class a97{};\n"
+                            "template <typename> class a98{};\n"
+                            "template <typename> class a99{};\n"
+                            "template <typename> class a100{};\n"
+                            "template <typename> class b {};\n"
+                            "b<a0<int>> d0;\n"
+                            "b<a1<int>> d1;\n"
+                            "b<a2<int>> d2;\n"
+                            "b<a3<int>> d3;\n"
+                            "b<a4<int>> d4;\n"
+                            "b<a5<int>> d5;\n"
+                            "b<a6<int>> d6;\n"
+                            "b<a7<int>> d7;\n"
+                            "b<a8<int>> d8;\n"
+                            "b<a9<int>> d9;\n"
+                            "b<a10<int>> d10;\n"
+                            "b<a11<int>> d11;\n"
+                            "b<a12<int>> d12;\n"
+                            "b<a13<int>> d13;\n"
+                            "b<a14<int>> d14;\n"
+                            "b<a15<int>> d15;\n"
+                            "b<a16<int>> d16;\n"
+                            "b<a17<int>> d17;\n"
+                            "b<a18<int>> d18;\n"
+                            "b<a19<int>> d19;\n"
+                            "b<a20<int>> d20;\n"
+                            "b<a21<int>> d21;\n"
+                            "b<a22<int>> d22;\n"
+                            "b<a23<int>> d23;\n"
+                            "b<a24<int>> d24;\n"
+                            "b<a25<int>> d25;\n"
+                            "b<a26<int>> d26;\n"
+                            "b<a27<int>> d27;\n"
+                            "b<a28<int>> d28;\n"
+                            "b<a29<int>> d29;\n"
+                            "b<a30<int>> d30;\n"
+                            "b<a31<int>> d31;\n"
+                            "b<a32<int>> d32;\n"
+                            "b<a33<int>> d33;\n"
+                            "b<a34<int>> d34;\n"
+                            "b<a35<int>> d35;\n"
+                            "b<a36<int>> d36;\n"
+                            "b<a37<int>> d37;\n"
+                            "b<a38<int>> d38;\n"
+                            "b<a39<int>> d39;\n"
+                            "b<a40<int>> d40;\n"
+                            "b<a41<int>> d41;\n"
+                            "b<a42<int>> d42;\n"
+                            "b<a43<int>> d43;\n"
+                            "b<a44<int>> d44;\n"
+                            "b<a45<int>> d45;\n"
+                            "b<a46<int>> d46;\n"
+                            "b<a47<int>> d47;\n"
+                            "b<a48<int>> d48;\n"
+                            "b<a49<int>> d49;\n"
+                            "b<a50<int>> d50;\n"
+                            "b<a51<int>> d51;\n"
+                            "b<a52<int>> d52;\n"
+                            "b<a53<int>> d53;\n"
+                            "b<a54<int>> d54;\n"
+                            "b<a55<int>> d55;\n"
+                            "b<a56<int>> d56;\n"
+                            "b<a57<int>> d57;\n"
+                            "b<a58<int>> d58;\n"
+                            "b<a59<int>> d59;\n"
+                            "b<a60<int>> d60;\n"
+                            "b<a61<int>> d61;\n"
+                            "b<a62<int>> d62;\n"
+                            "b<a63<int>> d63;\n"
+                            "b<a64<int>> d64;\n"
+                            "b<a65<int>> d65;\n"
+                            "b<a66<int>> d66;\n"
+                            "b<a67<int>> d67;\n"
+                            "b<a68<int>> d68;\n"
+                            "b<a69<int>> d69;\n"
+                            "b<a70<int>> d70;\n"
+                            "b<a71<int>> d71;\n"
+                            "b<a72<int>> d72;\n"
+                            "b<a73<int>> d73;\n"
+                            "b<a74<int>> d74;\n"
+                            "b<a75<int>> d75;\n"
+                            "b<a76<int>> d76;\n"
+                            "b<a77<int>> d77;\n"
+                            "b<a78<int>> d78;\n"
+                            "b<a79<int>> d79;\n"
+                            "b<a80<int>> d80;\n"
+                            "b<a81<int>> d81;\n"
+                            "b<a82<int>> d82;\n"
+                            "b<a83<int>> d83;\n"
+                            "b<a84<int>> d84;\n"
+                            "b<a85<int>> d85;\n"
+                            "b<a86<int>> d86;\n"
+                            "b<a87<int>> d87;\n"
+                            "b<a88<int>> d88;\n"
+                            "b<a89<int>> d89;\n"
+                            "b<a90<int>> d90;\n"
+                            "b<a91<int>> d91;\n"
+                            "b<a92<int>> d92;\n"
+                            "b<a93<int>> d93;\n"
+                            "b<a94<int>> d94;\n"
+                            "b<a95<int>> d95;\n"
+                            "b<a96<int>> d96;\n"
+                            "b<a97<int>> d97;\n"
+                            "b<a98<int>> d98;\n"
+                            "b<a99<int>> d99;\n"
+                            "b<a100<int>> d100;";
+        // don't bother checking the output because this is not instantiated properly
+        (void)tok(code); // don't crash
+
+        const char code2[] = "template<typename T> void f();\n" // #11489
+                             "template<typename T> void f(int);\n"
+                             "void g() {\n"
+                             "    f<int>();\n"
+                             "    f<char>(1);\n"
+                             "}\n"
+                             "template<typename T>\n"
+                             "void f(int) {}\n"
+                             "template<typename T>\n"
+                             "void f() {\n"
+                             "    f<T>(0);\n"
+                             "}\n";
+        const char exp2[] = "template < typename T > void f ( ) ; "
+                            "void f<char> ( int ) ; "
+                            "void f<int> ( int ) ; "
+                            "void g ( ) { f<int> ( ) ; f<char> ( 1 ) ; } "
+                            "void f<char> ( int ) { } "
+                            "void f<int> ( ) { f<int> ( 0 ) ; }";
+        ASSERT_EQUALS(exp2, tok(code2));
+    }
+
+    void template159() {  // #9886
+        const char code[] = "struct impl { template <class T> static T create(); };\n"
+                            "template<class T, class U, class = decltype(impl::create<T>()->impl::create<U>())>\n"
+                            "struct tester{};\n"
+                            "tester<impl*, int> ti;\n"
+                            "template<class T, class U, class = decltype(impl::create<T>()->impl::create<U>())>\n"
+                            "int test() { return 0; }\n"
+                            "int i = test<impl*, int>();";
+        const char exp[]  = "struct impl { template < class T > static T create ( ) ; } ; "
+                            "struct tester<impl*,int,decltype(impl::create<impl*>().impl::create<int>())> ; "
+                            "tester<impl*,int,decltype(impl::create<impl*>().impl::create<int>())> ti ; "
+                            "int test<impl*,int,decltype(impl::create<impl*>().impl::create<int>())> ( ) ; "
+                            "int i ; i = test<impl*,int,decltype(impl::create<impl*>().impl::create<int>())> ( ) ; "
+                            "int test<impl*,int,decltype(impl::create<impl*>().impl::create<int>())> ( ) { return 0 ; } "
+                            "struct tester<impl*,int,decltype(impl::create<impl*>().impl::create<int>())> { } ;";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template160() {
+        const char code[] = "struct Fred {\n"
+                            "    template <typename T> static void foo() { }\n"
+                            "    template <typename T> static void foo(T) { }\n"
+                            "};\n"
+                            "template void Fred::foo<char>();\n"
+                            "template <> void Fred::foo<bool>() { }\n"
+                            "template void Fred::foo<float>(float);\n"
+                            "template <> void Fred::foo<int>(int) { }";
+        const char exp[]  = "struct Fred { "
+                            "static void foo<bool> ( ) ; "
+                            "static void foo<char> ( ) ; "
+                            "static void foo<int> ( int ) ; "
+                            "static void foo<float> ( float ) ; "
+                            "} ; "
+                            "void Fred :: foo<bool> ( ) { } "
+                            "void Fred :: foo<int> ( int ) { } "
+                            "void Fred :: foo<float> ( float ) { } "
+                            "void Fred :: foo<char> ( ) { }";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template161() {
+        const char code[] = "struct JobEntry { };\n"
+                            "template<class T>\n"
+                            "struct adapter : public T {\n"
+                            "    template<class... Args>\n"
+                            "    adapter(Args&&... args) : T{ std::forward<Args>(args)... } {}\n"
+                            "};\n"
+                            "void foo() {\n"
+                            "   auto notifyJob = std::make_shared<adapter<JobEntry>> ();\n"
+                            "}";
+        const char exp[]  = "???";
+        const char act[]  = "struct JobEntry { } ; "
+                            "struct adapter<JobEntry> ; "
+                            "void foo ( ) { "
+                            "auto notifyJob ; notifyJob = std :: make_shared < adapter<JobEntry> > ( ) ; "
+                            "} "
+                            "struct adapter<JobEntry> : public JobEntry { "
+                            "template < class ... Args > "
+                            "adapter<JobEntry> ( Args && ... args ) : JobEntry { std :: forward < Args > ( args ) ... } { } "
+                            "} ;";
+        TODO_ASSERT_EQUALS(exp, act, tok(code));
+    }
+
+    void template162() {
+        const char code[] = "template <std::size_t N>\n"
+                            "struct CountryCode {\n"
+                            "    CountryCode(std::string cc);\n"
+                            "};"
+                            "template <std::size_t N>\n"
+                            "CountryCode<N>::CountryCode(std::string cc) : m_String{std::move(cc)} {\n"
+                            "}\n"
+                            "template class CountryCode<2>;\n"
+                            "template class CountryCode<3>;";
+        const char exp[]  = "struct CountryCode<2> ; "
+                            "struct CountryCode<3> ; "
+                            "struct CountryCode<2> { "
+                            "CountryCode<2> ( std :: string cc ) ; "
+                            "} ; "
+                            "CountryCode<2> :: CountryCode<2> ( std :: string cc ) : m_String { std :: move ( cc ) } { "
+                            "} "
+                            "struct CountryCode<3> { "
+                            "CountryCode<3> ( std :: string cc ) ; "
+                            "} ; "
+                            "CountryCode<3> :: CountryCode<3> ( std :: string cc ) : m_String { std :: move ( cc ) } { "
+                            "}";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template163() { // #9685 syntax error
+        const char code[] = "extern \"C++\" template < typename T > T * test ( ) { return nullptr ; }";
+        const char expected[] = "template < typename T > T * test ( ) { return nullptr ; }";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
+    void template164() {  // #9394
+        const char code[] = "template <class TYPE>\n"
+                            "struct A {\n"
+                            "    A();\n"
+                            "    ~A();\n"
+                            "    static void f();\n"
+                            "};\n"
+                            "template <class TYPE>\n"
+                            "A<TYPE>::A() { }\n"
+                            "template <class TYPE>\n"
+                            "A<TYPE>::~A() { }\n"
+                            "template <class TYPE>\n"
+                            "void A<TYPE>::f() { }\n"
+                            "template class A<int>;\n"
+                            "template class A<float>;";
+        const char exp[]  = "struct A<int> ; "
+                            "struct A<float> ; "
+                            "struct A<int> { "
+                            "A<int> ( ) ; "
+                            "~ A<int> ( ) ; "
+                            "static void f ( ) ; "
+                            "} ; "
+                            "A<int> :: A<int> ( ) { } "
+                            "A<int> :: ~ A<int> ( ) { } "
+                            "void A<int> :: f ( ) { } "
+                            "struct A<float> { "
+                            "A<float> ( ) ; "
+                            "~ A<float> ( ) ; "
+                            "static void f ( ) ; "
+                            "} ; "
+                            "A<float> :: A<float> ( ) { } "
+                            "A<float> :: ~ A<float> ( ) { } "
+                            "void A<float> :: f ( ) { }";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template165() { // #10032 syntax error
+        const char code[] = "struct MyStruct {\n"
+                            "    template<class T>\n"
+                            "    bool operator()(const T& l, const T& r) const {\n"
+                            "        return l.first < r.first;\n"
+                            "    }\n"
+                            "};";
+        const char exp[]  = "struct MyStruct { "
+                            "template < class T > "
+                            "bool operator() ( const T & l , const T & r ) const { "
+                            "return l . first < r . first ; "
+                            "} "
+                            "} ;";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template166() { // #10081 hang
+        const char code[] = "template <typename T, size_t k = (T::s < 3) ? 0 : 3>\n"
+                            "void foo() {}\n"
+                            "foo<T>();";
+        const char exp[]  = "void foo<T,(T::s<3)?0:3> ( ) ; "
+                            "foo<T,(T::s<3)?0:3> ( ) ; "
+                            "void foo<T,(T::s<3)?0:3> ( ) { }";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template167() {
+        const char code[] = "struct MathLib {\n"
+                            "    template<class T> static std::string toString(T value) {\n"
+                            "        return std::string{};\n"
+                            "    }\n"
+                            "};\n"
+                            "template<> std::string MathLib::toString(double value);\n"
+                            "template<> std::string MathLib::toString(double value) {\n"
+                            "    return std::string{std::to_string(value)};\n"
+                            "}\n"
+                            "void foo() {\n"
+                            "    std::string str = MathLib::toString(1.0);\n"
+                            "}";
+        const char exp[]  = "struct MathLib { "
+                            "static std :: string toString<double> ( double value ) ; "
+                            "template < class T > static std :: string toString ( T value ) { "
+                            "return std :: string { } ; "
+                            "} "
+                            "} ; "
+                            "std :: string MathLib :: toString<double> ( double value ) { "
+                            "return std :: string { std :: to_string ( value ) } ; "
+                            "} "
+                            "void foo ( ) { "
+                            "std :: string str ; str = MathLib :: toString<double> ( 1.0 ) ; "
+                            "}";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template168() {
+        const char code[] = "template < typename T, typename U > struct type { };\n"
+                            "template < > struct type < bool, bool > {};\n"
+                            "template < > struct type < unsigned char, unsigned char > {};\n"
+                            "template < > struct type < char, char > {};\n"
+                            "template < > struct type < signed char, signed char > {};\n"
+                            "template < > struct type < unsigned short, unsigned short > {};\n"
+                            "template < > struct type < short, short > {};\n"
+                            "template < > struct type < unsigned int, unsigned int > {};\n"
+                            "template < > struct type < int, int > {};\n"
+                            "template < > struct type < unsigned long long, unsigned long long > {};\n"
+                            "template < > struct type < long long, long long > {};\n"
+                            "template < > struct type < double, double > {};\n"
+                            "template < > struct type < float, float > {};\n"
+                            "template < > struct type < long double, long double > {};";
+        const char exp[]  = "struct type<longdouble,longdouble> ; "
+                            "struct type<float,float> ; "
+                            "struct type<double,double> ; "
+                            "struct type<longlong,longlong> ; "
+                            "struct type<unsignedlonglong,unsignedlonglong> ; "
+                            "struct type<int,int> ; "
+                            "struct type<unsignedint,unsignedint> ; "
+                            "struct type<short,short> ; "
+                            "struct type<unsignedshort,unsignedshort> ; "
+                            "struct type<signedchar,signedchar> ; "
+                            "struct type<char,char> ; "
+                            "struct type<unsignedchar,unsignedchar> ; "
+                            "struct type<bool,bool> ; "
+                            "template < typename T , typename U > struct type { } ; "
+                            "struct type<bool,bool> { } ; "
+                            "struct type<unsignedchar,unsignedchar> { } ; "
+                            "struct type<char,char> { } ; "
+                            "struct type<signedchar,signedchar> { } ; "
+                            "struct type<unsignedshort,unsignedshort> { } ; "
+                            "struct type<short,short> { } ; "
+                            "struct type<unsignedint,unsignedint> { } ; "
+                            "struct type<int,int> { } ; "
+                            "struct type<unsignedlonglong,unsignedlonglong> { } ; "
+                            "struct type<longlong,longlong> { } ; "
+                            "struct type<double,double> { } ; "
+                            "struct type<float,float> { } ; "
+                            "struct type<longdouble,longdouble> { } ;";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template169() {
+        const char code[] = "template < typename T> struct last { T t; };\n"
+                            "template < typename T > struct CImgList { T t; };\n"
+                            "CImgList < last < bool > > c1;\n"
+                            "CImgList < last < signed char > > c2;\n"
+                            "CImgList < last < unsigned char > > c3;\n"
+                            "CImgList < last < char > > c4;\n"
+                            "CImgList < last < unsigned short > > c5;\n"
+                            "CImgList < last < short > > c6;\n"
+                            "CImgList < last < unsigned int > > c7;\n"
+                            "CImgList < last < int > > c8;\n"
+                            "CImgList < last < unsigned long > > c9;\n"
+                            "CImgList < last < long > > c10;\n"
+                            "CImgList < last < unsigned long long > > c11;\n"
+                            "CImgList < last < long long > > c12;\n"
+                            "CImgList < last < float > > c13;\n"
+                            "CImgList < last < double > > c14;\n"
+                            "CImgList < last < long double > > c15;";
+        const char exp[]  = "struct last<bool> ; "
+                            "struct last<signedchar> ; "
+                            "struct last<unsignedchar> ; "
+                            "struct last<char> ; "
+                            "struct last<unsignedshort> ; "
+                            "struct last<short> ; "
+                            "struct last<unsignedint> ; "
+                            "struct last<int> ; "
+                            "struct last<unsignedlong> ; "
+                            "struct last<long> ; "
+                            "struct last<unsignedlonglong> ; "
+                            "struct last<longlong> ; "
+                            "struct last<float> ; "
+                            "struct last<double> ; "
+                            "struct last<longdouble> ; "
+                            "struct CImgList<last<bool>> ; "
+                            "struct CImgList<last<signedchar>> ; "
+                            "struct CImgList<last<unsignedchar>> ; "
+                            "struct CImgList<last<char>> ; "
+                            "struct CImgList<last<unsignedshort>> ; "
+                            "struct CImgList<last<short>> ; "
+                            "struct CImgList<last<unsignedint>> ; "
+                            "struct CImgList<last<int>> ; "
+                            "struct CImgList<last<unsignedlong>> ; "
+                            "struct CImgList<last<long>> ; "
+                            "struct CImgList<last<unsignedlonglong>> ; "
+                            "struct CImgList<last<longlong>> ; "
+                            "struct CImgList<last<float>> ; "
+                            "struct CImgList<last<double>> ; "
+                            "struct CImgList<last<longdouble>> ; "
+                            "CImgList<last<bool>> c1 ; "
+                            "CImgList<last<signedchar>> c2 ; "
+                            "CImgList<last<unsignedchar>> c3 ; "
+                            "CImgList<last<char>> c4 ; "
+                            "CImgList<last<unsignedshort>> c5 ; "
+                            "CImgList<last<short>> c6 ; "
+                            "CImgList<last<unsignedint>> c7 ; "
+                            "CImgList<last<int>> c8 ; "
+                            "CImgList<last<unsignedlong>> c9 ; "
+                            "CImgList<last<long>> c10 ; "
+                            "CImgList<last<unsignedlonglong>> c11 ; "
+                            "CImgList<last<longlong>> c12 ; "
+                            "CImgList<last<float>> c13 ; "
+                            "CImgList<last<double>> c14 ; "
+                            "CImgList<last<longdouble>> c15 ; "
+                            "struct CImgList<last<bool>> { last<bool> t ; } ; "
+                            "struct CImgList<last<signedchar>> { last<signedchar> t ; } ; "
+                            "struct CImgList<last<unsignedchar>> { last<unsignedchar> t ; } ; "
+                            "struct CImgList<last<char>> { last<char> t ; } ; "
+                            "struct CImgList<last<unsignedshort>> { last<unsignedshort> t ; } ; "
+                            "struct CImgList<last<short>> { last<short> t ; } ; "
+                            "struct CImgList<last<unsignedint>> { last<unsignedint> t ; } ; "
+                            "struct CImgList<last<int>> { last<int> t ; } ; "
+                            "struct CImgList<last<unsignedlong>> { last<unsignedlong> t ; } ; "
+                            "struct CImgList<last<long>> { last<long> t ; } ; "
+                            "struct CImgList<last<unsignedlonglong>> { last<unsignedlonglong> t ; } ; "
+                            "struct CImgList<last<longlong>> { last<longlong> t ; } ; "
+                            "struct CImgList<last<float>> { last<float> t ; } ; "
+                            "struct CImgList<last<double>> { last<double> t ; } ; "
+                            "struct CImgList<last<longdouble>> { last<longdouble> t ; } ; "
+                            "struct last<bool> { bool t ; } ; "
+                            "struct last<signedchar> { signed char t ; } ; "
+                            "struct last<unsignedchar> { unsigned char t ; } ; "
+                            "struct last<char> { char t ; } ; "
+                            "struct last<unsignedshort> { unsigned short t ; } ; "
+                            "struct last<short> { short t ; } ; "
+                            "struct last<unsignedint> { unsigned int t ; } ; "
+                            "struct last<int> { int t ; } ; "
+                            "struct last<unsignedlong> { unsigned long t ; } ; "
+                            "struct last<long> { long t ; } ; "
+                            "struct last<unsignedlonglong> { unsigned long long t ; } ; "
+                            "struct last<longlong> { long long t ; } ; "
+                            "struct last<float> { float t ; } ; "
+                            "struct last<double> { double t ; } ; "
+                            "struct last<longdouble> { long double t ; } ;";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template170() { // crash
+        const char code[] = "template <int b> int a = 0;\n"
+                            "void c() {\n"
+                            "  a<1>;\n"
+                            "  [](auto b) {};\n"
+                            "}";
+        const char exp[]  = "int a<1> ; a<1> = 0 ; "
+                            "void c ( ) { "
+                            "a<1> ; "
+                            "[ ] ( auto b ) { } ; "
+                            "}";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template171() { // crash
+        const char code[] = "template <int> struct c { enum { b }; };\n"
+                            "template <int> struct h { enum { d }; enum { e }; };\n"
+                            "template <int f, long = h<f>::d, int g = h<f>::e> class i { enum { e = c<g>::b }; };\n"
+                            "void j() { i<2> a; }";
+        const char exp[]  = "struct c<h<2>::e> ; "
+                            "struct h<2> ; "
+                            "class i<2,h<2>::d,h<2>::e> ; "
+                            "void j ( ) { i<2,h<2>::d,h<2>::e> a ; } "
+                            "class i<2,h<2>::d,h<2>::e> { enum Anonymous3 { e = c<h<2>::e> :: b } ; } ; "
+                            "struct h<2> { enum Anonymous1 { d } ; enum Anonymous2 { e } ; } ; "
+                            "struct c<h<2>::e> { enum Anonymous0 { b } ; } ;";
+        const char act[]  = "struct c<h<2>::e> ; "
+                            "template < int > struct h { enum Anonymous1 { d } ; enum Anonymous2 { e } ; } ; "
+                            "class i<2,h<2>::d,h<2>::e> ; "
+                            "void j ( ) { i<2,h<2>::d,h<2>::e> a ; } "
+                            "class i<2,h<2>::d,h<2>::e> { enum Anonymous3 { e = c<h<2>::e> :: b } ; } ; "
+                            "struct c<h<2>::e> { enum Anonymous0 { b } ; } ;";
+        TODO_ASSERT_EQUALS(exp, act, tok(code));
+    }
+
+    void template172() { // #10258 crash
+        const char code[] = "template<typename T, typename... Args>\n"
+                            "void bar(T t, Args&&... args) { }\n"
+                            "void foo() { bar<int>(0, 1); }";
+        const char exp[]  = "void bar<int> ( int t , Args && ... args ) ; "
+                            "void foo ( ) { bar<int> ( 0 , 1 ) ; } "
+                            "void bar<int> ( int t , Args && ... args ) { }";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template173() { // #10332 crash
+        const char code[] = "namespace a {\n"
+                            "template <typename, typename> struct b;\n"
+                            "template <template <typename, typename> class = b> class c;\n"
+                            "using d = c<>;\n"
+                            "template <template <typename, typename = void> class> class c {};\n"
+                            "}\n"
+                            "namespace std {\n"
+                            "template <> void swap<a::d>(a::d &, a::d &) {}\n"
+                            "}";
+        const char exp[]  = "namespace a { "
+                            "template < typename , typename > struct b ; "
+                            "template < template < typename , typename > class > class c ; "
+                            "class c<b> ; "
+                            "} "
+                            "namespace std { "
+                            "void swap<a::c<b>> ( a :: c<b> & , a :: c<b> & ) ; "
+                            "void swap<a::c<b>> ( a :: c<b> & , a :: c<b> & ) { } "
+                            "} "
+                            "class a :: c<b> { } ;";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template174()
+    { // #10506 hang
+        const char code[] = "namespace a {\n"
+                            "template <typename> using b = int;\n"
+                            "template <typename c> c d() { return d<b<c>>(); }\n"
+                            "}\n"
+                            "void e() { a::d<int>(); }\n";
+        const char exp[] = "namespace a { int d<int> ( ) ; } "
+                           "void e ( ) { a :: d<int> ( ) ; } "
+                           "int a :: d<int> ( ) { return d < int > ( ) ; }";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template175() // #10908
+    {
+        const char code[] = "template <typename T, int value> T Get() {return value;}\n"
+                            "char f() { Get<int,10>(); }\n";
+        const char exp[] = "int Get<int,10> ( ) ; "
+                           "char f ( ) { Get<int,10> ( ) ; } "
+                           "int Get<int,10> ( ) { return 10 ; }";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template176() // #11146 don't crash
+    {
+        const char code[] = "struct a {\n"
+                            "    template <typename> class b {};\n"
+                            "};\n"
+                            "struct c {\n"
+                            "    template <typename> a::b<int> d();\n"
+                            "    ;\n"
+                            "};\n"
+                            "template <typename> a::b<int> c::d() {}\n"
+                            "template <> class a::b<int> c::d<int>() { return {}; };\n";
+        const char exp[] = "struct a { "
+                           "class b<int> c :: d<int> ( ) ; "
+                           "template < typename > class b { } ; "
+                           "} ; "
+                           "struct c { a :: b<int> d<int> ( ) ; } ; "
+                           "class a :: b<int> c :: d<int> ( ) { return { } ; } ; "
+                           "a :: b<int> c :: d<int> ( ) { }";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template177() {
+        const char code[] = "template <typename Encoding, typename Allocator>\n"
+                            "class C { xyz<Encoding, Allocator> x; };\n"
+                            "C<UTF8<>, MemoryPoolAllocator<>> c;";
+        const char exp[] = "class C<UTF8<>,MemoryPoolAllocator<>> ; "
+                           "C<UTF8<>,MemoryPoolAllocator<>> c ; "
+                           "class C<UTF8<>,MemoryPoolAllocator<>> { xyz < UTF8 < > , MemoryPoolAllocator < > > x ; } ;";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template178() {
+        const char code[] = "template<typename T>\n" // #11893
+                            "void g() {\n"
+                            "    for (T i = 0; i < T{ 3 }; ++i) {}\n"
+                            "}\n"
+                            "void f() {\n"
+                            "    g<int>();\n"
+                            "}";
+        const char exp[] = "void g<int> ( ) ; void f ( ) { g<int> ( ) ; } void g<int> ( ) { for ( int i = 0 ; i < int { 3 } ; ++ i ) { } }";
+        ASSERT_EQUALS(exp, tok(code));
+
+        const char code2[] = "template<typename T>\n"
+                             "struct S {\n"
+                             "    T c;\n"
+                             "    template<typename U>\n"
+                             "    void g() {\n"
+                             "        for (U i = 0; i < U{ 3 }; ++i) {}\n"
+                             "    }\n"
+                             "};\n"
+                             "void f() {\n"
+                             "    S<char> s{};\n"
+                             "    s.g<int>();\n"
+                             "}";
+        const char exp2[] = "struct S<char> ; void f ( ) { S<char> s { } ; s . g<int> ( ) ; } struct S<char> { char c ; void g<int> ( ) ; } ; "
+                            "void S<char> :: g<int> ( ) { for ( int i = 0 ; i < int { 3 } ; ++ i ) { } }";
+        ASSERT_EQUALS(exp2, tok(code2));
+    }
+
+    void template179() {
+        const char code[] = "template <typename T, typename C>\n" // #13498
+                            "struct B {\n"
+                            "    int a;\n"
+                            "    int b;\n"
+                            "};\n"
+                            "template <typename T>\n"
+                            "struct B<T, void> {\n"
+                            "    int a;\n"
+                            "};\n"
+                            "void f() {\n"
+                            "    B<int, int>{ 0, {} };\n"
+                            "}\n";
+        const char exp[] = "struct B<int,int> ; "
+                           "template < typename T > struct B < T , void > { int a ; } ; "
+                           "void f ( ) { B<int,int> { 0 , { } } ; } "
+                           "struct B<int,int> { int a ; int b ; } ;";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template180() {
+        const char code[] = "template<int C>\n" // #13680
+                            "int f() {\n"
+                            "    return dostuff(C);\n"
+                            "}\n"
+                            "void g() {\n"
+                            "    f<static_cast<int>(0U)>();\n"
+                            "}\n";
+        const char exp[] = "int f<static_cast<int>(0U)> ( ) ; "
+                           "void g ( ) { "
+                           "f<static_cast<int>(0U)> ( ) ; "
+                           "} "
+                           "int f<static_cast<int>(0U)> ( ) { "
+                           "return dostuff ( static_cast < int > ( 0U ) ) ; "
+                           "}";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template181() {
+        const char code[] = "struct K { bool b; };\n" // #13747
+                            "template<bool b>\n"
+                            "void f(struct K* k) {\n"
+                            "    assert(b == k->b);\n"
+                            "}\n"
+                            "void g(struct K* k) {\n"
+                            "    f<false>(k);\n"
+                            "}\n";
+        const char exp[] = "struct K { bool b ; } ; "
+                           "void f<false> ( struct K * k ) ; "
+                           "void g ( struct K * k ) { "
+                           "f<false> ( k ) ; "
+                           "} "
+                           "void f<false> ( struct K * k ) { "
+                           "assert ( false == k . b ) ; "
+                           "}";
+        ASSERT_EQUALS(exp, tok(code));
+
+        const char code2[] = "namespace N { bool b = false; }\n" // #13759
+                             "template<bool b>\n"
+                             "void f() {\n"
+                             "    assert(b == N::b);\n"
+                             "}\n"
+                             "void g() {\n"
+                             "    f<false>();\n"
+                             "}\n";
+        const char exp2[] = "namespace N { bool b ; b = false ; } "
+                            "void f<false> ( ) ; "
+                            "void g ( ) { "
+                            "f<false> ( ) ; "
+                            "} "
+                            "void f<false> ( ) { "
+                            "assert ( false == N :: b ) ; "
+                            "}";
+        ASSERT_EQUALS(exp2, tok(code2));
+    }
+
+    void template182() {
+        const char code[] = "template <class...>\n"
+                            "auto f() {\n"
+                            "    return [](auto&&...) {};\n"
+                            "}\n";
+        const char exp[] = "template < class ... > auto f ( ) { return [ ] ( auto && ... ) { } ; }";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void template183() { // #11498
+        const char code[] = "template <typename T>\n"
+                            "struct S {\n"
+                            "    void f();\n"
+                            "    using X = decltype(&S<T>::f);\n"
+                            "private:\n"
+                            "    X x;\n"
+                            "};\n"
+                            "S<int> s;\n";
+        const char exp[] = "struct S<int> ; "
+                           "S<int> s ; "
+                           "struct S<int> { "
+                           "void f ( ) ; "
+                           "private: "
+                           "decltype ( & S<int> :: f ) x ; "
+                           "} ;";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
     void template_specialization_1() {  // #7868 - template specialization template <typename T> struct S<C<T>> {..};
         const char code[] = "template <typename T> struct C {};\n"
                             "template <typename T> struct S {a};\n"
@@ -3589,43 +4716,62 @@ class TestSimplifyTemplate : public TestFixture {
         ASSERT_EQUALS(exp, tok(code));
     }
 
+    void template_specialization_3() {
+        const char code[] = "namespace N {\n" // #12312
+                            "    template <typename T>\n"
+                            "    bool equal(const T&);\n"
+                            "    template <>\n"
+                            "    bool equal<int>(const int&) { return false; }\n"
+                            "}\n"
+                            "void f(bool equal, int i) { if (equal) {} }\n";
+        const char exp[] = "namespace N { "
+                           "bool equal<int> ( const int & ) ; "
+                           "template < typename T > "
+                           "bool equal ( const T & ) ; "
+                           "bool equal<int> ( const int & ) { return false ; } "
+                           "} "
+                           "void f ( bool equal , int i ) { if ( equal ) { } }";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
     void template_enum() {
-        const char code1[] = "template <class T>\n"
-                             "struct Unconst {\n"
-                             "    typedef T type;\n"
-                             "};\n"
-                             "template <class T>\n"
-                             "struct Unconst<const T> {\n"
-                             "    typedef T type;\n"
-                             "};\n"
-                             "template <class T>\n"
-                             "struct Unconst<const T&> {\n"
-                             "    typedef T& type;\n"
-                             "};\n"
-                             "template <class T>\n"
-                             "struct Unconst<T* const> {\n"
-                             "    typedef T* type;\n"
-                             "};\n"
-                             "template <class T1, class T2>\n"
-                             "struct type_equal {\n"
-                             "    enum {  value = 0   };\n"
-                             "};\n"
-                             "template <class T>\n"
-                             "struct type_equal<T, T> {\n"
-                             "    enum {  value = 1   };\n"
-                             "};\n"
-                             "template<class T>\n"
-                             "struct template_is_const\n"
-                             "{\n"
-                             "    enum {value = !type_equal<T, typename Unconst<T>::type>::value  };\n"
-                             "};";
-        const char exp1[] = "template < class T > struct Unconst { } ; "
-                            "template < class T > struct Unconst < const T > { } ; "
-                            "template < class T > struct Unconst < const T & > { } ; "
-                            "template < class T > struct Unconst < T * const > { } ; "
-                            "template < class T1 , class T2 > struct type_equal { enum Anonymous0 { value = 0 } ; } ; "
-                            "template < class T > struct type_equal < T , T > { enum Anonymous1 { value = 1 } ; } ;";
-        ASSERT_EQUALS(exp1, tok(code1));
+        const char code[] = "template <class T>\n"
+                            "struct Unconst {\n"
+                            "    typedef T type;\n"
+                            "};\n"
+                            "template <class T>\n"
+                            "struct Unconst<const T> {\n"
+                            "    typedef T type;\n"
+                            "};\n"
+                            "template <class T>\n"
+                            "struct Unconst<const T&> {\n"
+                            "    typedef T& type;\n"
+                            "};\n"
+                            "template <class T>\n"
+                            "struct Unconst<T* const> {\n"
+                            "    typedef T* type;\n"
+                            "};\n"
+                            "template <class T1, class T2>\n"
+                            "struct type_equal {\n"
+                            "    enum {  value = 0   };\n"
+                            "};\n"
+                            "template <class T>\n"
+                            "struct type_equal<T, T> {\n"
+                            "    enum {  value = 1   };\n"
+                            "};\n"
+                            "template<class T>\n"
+                            "struct template_is_const\n"
+                            "{\n"
+                            "    enum {value = !type_equal<T, typename Unconst<T>::type>::value  };\n"
+                            "};";
+        const char exp[] = "template < class T > struct Unconst { } ; "
+                           "template < class T > struct Unconst < const T > { } ; "
+                           "template < class T > struct Unconst < const T & > { } ; "
+                           "template < class T > struct Unconst < T * const > { } ; "
+                           "template < class T1 , class T2 > struct type_equal { enum Anonymous0 { value = 0 } ; } ; "
+                           "template < class T > struct type_equal < T , T > { enum Anonymous1 { value = 1 } ; } ; "
+                           "template < class T > struct template_is_const { enum Anonymous2 { value = ! type_equal < T , Unconst < T > :: type > :: value } ; } ;";
+        ASSERT_EQUALS(exp, tok(code));
     }
 
     void template_default_parameter() {
@@ -3683,15 +4829,15 @@ class TestSimplifyTemplate : public TestFixture {
                                 "    A<int,(int)2> a1;\n"
                                 "    A<int> a2;\n"
                                 "}\n";
-            const char expected[] = "class A<int,(int)2> ; "
+            const char expected[] = "class A<int,2> ; "
                                     "class A<int,3> ; "
                                     "void f ( ) "
                                     "{ "
-                                    "A<int,(int)2> a1 ; "
+                                    "A<int,2> a1 ; "
                                     "A<int,3> a2 ; "
                                     "} "
-                                    "class A<int,(int)2> "
-                                    "{ int ar [ ( int ) 2 ] ; } ; "
+                                    "class A<int,2> "
+                                    "{ int ar [ 2 ] ; } ; "
                                     "class A<int,3> "
                                     "{ int ar [ 3 ] ; } ;";
             ASSERT_EQUALS(expected, tok(code));
@@ -3711,10 +4857,10 @@ class TestSimplifyTemplate : public TestFixture {
             const char code[] = "template<class T, class U> class DefaultMemory {}; "
                                 "template<class Key, class Val, class Mem=DefaultMemory<Key,Val> > class thv_table_c  {}; "
                                 "thv_table_c<void *,void *> id_table_m;";
-            const char exp [] = "template < class T , class U > class DefaultMemory { } ; "
-                                "class thv_table_c<void*,void*,DefaultMemory<void*,void*>> ; "
-                                "thv_table_c<void*,void*,DefaultMemory<void*,void*>> id_table_m ; "
-                                "class thv_table_c<void*,void*,DefaultMemory<void*,void*>> { } ;";
+            const char exp[] = "template < class T , class U > class DefaultMemory { } ; "
+                               "class thv_table_c<void*,void*,DefaultMemory<void*,void*>> ; "
+                               "thv_table_c<void*,void*,DefaultMemory<void*,void*>> id_table_m ; "
+                               "class thv_table_c<void*,void*,DefaultMemory<void*,void*>> { } ;";
             ASSERT_EQUALS(exp, tok(code));
         }
         {
@@ -3846,6 +4992,26 @@ class TestSimplifyTemplate : public TestFixture {
 
             ASSERT_EQUALS(exp, tok(code));
         }
+        { // #10432
+            const char code[] = "template<int A = 128, class T = wchar_t>\n"
+                                "class Foo;\n"
+                                "template<int A, class T>\n"
+                                "class Foo\n"
+                                "{\n"
+                                "public:\n"
+                                "  T operator[](int Index) const;\n"
+                                "};\n"
+                                "template<int A, class T>\n"
+                                "T Foo<A, T>::operator[](int Index) const\n"
+                                "{\n"
+                                "  return T{};\n"
+                                "}\n"
+                                "Foo<> f;";
+            const char exp[] = "class Foo<128,wchar_t> ; Foo<128,wchar_t> f ; "
+                               "class Foo<128,wchar_t> { public: wchar_t operator[] ( int Index ) const ; } ; "
+                               "wchar_t Foo<128,wchar_t> :: operator[] ( int Index ) const { return wchar_t { } ; }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
     }
 
     void template_default_type() {
@@ -3871,10 +5037,10 @@ class TestSimplifyTemplate : public TestFixture {
                             "{\n"
                             "};\n";
 
-        tok(code);
+        (void)tok(code);
 
-        //ASSERT_EQUALS("[file1.cpp:15]: (error) Internal error: failed to instantiate template. The checking continues anyway.\n", errout.str());
-        ASSERT_EQUALS("", errout.str());
+        //ASSERT_EQUALS("[file1.cpp:15]: (error) Internal error: failed to instantiate template. The checking continues anyway.\n", errout_str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void template_typename() {
@@ -3903,88 +5069,101 @@ class TestSimplifyTemplate : public TestFixture {
         //         "no constructor" false positives
         const char code[] = "class Fred {\n"
                             "    template<class T> explicit Fred(T t) { }\n"
-                            "}";
-        ASSERT_EQUALS("class Fred { }", tok(code));
+                            "};";
+        ASSERT_EQUALS("class Fred { template < class T > explicit Fred ( T t ) { } } ;", tok(code));
 
         // #3532
         const char code2[] = "class Fred {\n"
                              "    template<class T> Fred(T t) { }\n"
-                             "}";
-        ASSERT_EQUALS("class Fred { template < class T > Fred ( T t ) { } }", tok(code2));
+                             "};";
+        ASSERT_EQUALS("class Fred { template < class T > Fred ( T t ) { } } ;", tok(code2));
     }
 
     void syntax_error_templates_1() {
         // ok code.. using ">" for a comparison
-        tok("x<y>z> xyz;\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_NO_THROW(tok("x<y>z> xyz;"));
+        ASSERT_EQUALS("", errout_str());
 
         // ok code
-        tok("template<class T> operator<(T a, T b) { }\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_NO_THROW(tok("template<class T> operator<(T a, T b) { }"));
+        ASSERT_EQUALS("", errout_str());
 
         // ok code (ticket #1984)
-        tok("void f(a) int a;\n"
-            "{ ;x<y; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_NO_THROW(tok("void f(a) int a;\n"
+                            "{ ;x<y; }"));
+        ASSERT_EQUALS("", errout_str());
 
         // ok code (ticket #1985)
-        tok("void f()\n"
-            "try { ;x<y; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_NO_THROW(tok("void f()\n"
+                            "{ try { ;x<y; } }"));
+        ASSERT_EQUALS("", errout_str());
 
         // ok code (ticket #3183)
-        tok("MACRO(({ i < x }))");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_NO_THROW(tok("MACRO(({ i < x }))"));
+        ASSERT_EQUALS("", errout_str());
 
         // bad code.. missing ">"
-        ASSERT_THROW(tok("x<y<int> xyz;\n"), InternalError);
+        ASSERT_THROW_INTERNAL(tok("x<y<int> xyz;\n"), SYNTAX);
 
         // bad code
-        ASSERT_THROW(tok("typedef\n"
-                         "    typename boost::mpl::if_c<\n"
-                         "          _visitableIndex < boost::mpl::size< typename _Visitables::ConcreteVisitables >::value\n"
-                         "          , ConcreteVisitable\n"
-                         "          , Dummy< _visitableIndex >\n"
-                         "    >::type ConcreteVisitableOrDummy;\n"), InternalError);
+        ASSERT_THROW_INTERNAL(tok("typedef\n"
+                                  "    typename boost::mpl::if_c<\n"
+                                  "          _visitableIndex < boost::mpl::size< typename _Visitables::ConcreteVisitables >::value\n"
+                                  "          , ConcreteVisitable\n"
+                                  "          , Dummy< _visitableIndex >\n"
+                                  "    >::type ConcreteVisitableOrDummy;\n"), SYNTAX);
 
         // code is ok, don't show syntax error
-        tok("struct A {int a;int b};\n"
-            "class Fred {"
-            "public:\n"
-            "    Fred() : a({1,2}) {\n"
-            "        for (int i=0;i<6;i++);\n" // <- no syntax error
-            "    }\n"
-            "private:\n"
-            "    A a;\n"
-            "};\n");
-        ASSERT_EQUALS("", errout.str());
-    }
-
-    void template_member_ptr() { // Ticket #5786
-        tok("struct A {}; "
-            "struct B { "
-            "template <void (A::*)() const> struct BB {}; "
-            "template <bool BT> static bool foo(int) { return true; } "
-            "void bar() { bool b = foo<true>(0); }"
-            "};");
-        tok("struct A {}; "
-            "struct B { "
-            "template <void (A::*)() volatile> struct BB {}; "
-            "template <bool BT> static bool foo(int) { return true; } "
-            "void bar() { bool b = foo<true>(0); }"
-            "};");
-        tok("struct A {}; "
-            "struct B { "
-            "template <void (A::*)() const volatile> struct BB {}; "
-            "template <bool BT> static bool foo(int) { return true; } "
-            "void bar() { bool b = foo<true>(0); }"
-            "};");
-        tok("struct A {}; "
-            "struct B { "
-            "template <void (A::*)() volatile const> struct BB {}; "
-            "template <bool BT> static bool foo(int) { return true; } "
-            "void bar() { bool b = foo<true>(0); }"
-            "};");
+        ASSERT_NO_THROW(tok("struct A {int a;int b};\n"
+                            "class Fred {"
+                            "public:\n"
+                            "    Fred() : a({1,2}) {\n"
+                            "        for (int i=0;i<6;i++);\n" // <- no syntax error
+                            "    }\n"
+                            "private:\n"
+                            "    A a;\n"
+                            "};"));
+        ASSERT_EQUALS("", errout_str());
+
+        //both of these should work but in cppcheck 2.1 only the first option will work (ticket #9843)
+        {
+            const std::string expected = "template < long Num > constexpr bool foo < bar < Num > > = true ;";
+            ASSERT_EQUALS(expected,
+                          tok("template <long Num>\n"
+                              "constexpr bool foo<bar<Num> > = true;\n"));
+            ASSERT_EQUALS("", errout_str());
+            ASSERT_EQUALS(expected,
+                          tok("template <long Num>\n"
+                              "constexpr bool foo<bar<Num>> = true;\n"));
+            ASSERT_EQUALS("", errout_str());
+        }
+    }
+
+    void template_member_ptr() { // Ticket #5786 (segmentation fault)
+        (void)tok("struct A {}; "
+                  "struct B { "
+                  "template <void (A::*)() const> struct BB {}; "
+                  "template <bool BT> static bool foo(int) { return true; } "
+                  "void bar() { bool b = foo<true>(0); }"
+                  "};");
+        (void)tok("struct A {}; "
+                  "struct B { "
+                  "template <void (A::*)() volatile> struct BB {}; "
+                  "template <bool BT> static bool foo(int) { return true; } "
+                  "void bar() { bool b = foo<true>(0); }"
+                  "};");
+        (void)tok("struct A {}; "
+                  "struct B { "
+                  "template <void (A::*)() const volatile> struct BB {}; "
+                  "template <bool BT> static bool foo(int) { return true; } "
+                  "void bar() { bool b = foo<true>(0); }"
+                  "};");
+        (void)tok("struct A {}; "
+                  "struct B { "
+                  "template <void (A::*)() volatile const> struct BB {}; "
+                  "template <bool BT> static bool foo(int) { return true; } "
+                  "void bar() { bool b = foo<true>(0); }"
+                  "};");
     }
 
     void template_namespace_1() {
@@ -4237,13 +5416,90 @@ class TestSimplifyTemplate : public TestFixture {
                       "} int MyNamespace :: TestClass :: TemplatedMethod<int> ( int t ) { return t ; }", tok(code));
     }
 
-    unsigned int templateParameters(const char code[]) {
-        Tokenizer tokenizer(&settings, this);
+    void template_namespace_12() {
+        const char code[] = "struct S {};\n" // #13444
+                            "namespace N {\n"
+                            "    template<>\n"
+                            "    struct hash<S> {};\n"
+                            "}\n"
+                            "struct T {\n"
+                            "    T(int i) : hash(i) {}\n"
+                            "    int hash;\n"
+                            "};\n";
+        ASSERT_EQUALS("struct S { } ; "
+                      "namespace N { "
+                      "struct hash<S> { } ; "
+                      "} "
+                      "struct T { "
+                      "T ( int i ) : hash ( i ) { } "
+                      "int hash ; "
+                      "} ;",
+                      tok(code));
+    }
+
+    void template_namespace_13() {
+        const char code[] = "namespace N {\n" // #13593
+                            "    template<typename T>\n"
+                            "    struct S {\n"
+                            "        using U = T*;\n"
+                            "    };\n"
+                            "}\n"
+                            "::N::S<int>::U u;\n";
+        ASSERT_EQUALS("namespace N { "
+                      "struct S<int> ; "
+                      "} "
+                      "int * u ; "
+                      "struct N :: S<int> { } ;",
+                      tok(code));
+    }
 
-        std::istringstream istr(code);
-        tokenizer.createTokens(istr, "test.cpp");
+    void template_pointer_type() {
+        const char code[] = "template<class T> void foo(const T x) {}\n"
+                            "void bar() { foo<int*>(0); }";
+        ASSERT_EQUALS("void foo<int*> ( int * const x ) ; "
+                      "void bar ( ) { foo<int*> ( 0 ) ; } "
+                      "void foo<int*> ( int * const x ) { }", tok(code));
+    }
+
+    void template_array_type() {
+        ASSERT_EQUALS("void foo<int[]> ( int [ ] x ) ; "
+                      "void bar ( ) { int y [ 3 ] ; foo<int[]> ( y ) ; } "
+                      "void foo<int[]> ( int [ ] x ) { }",
+                      tok("template <class T> void foo(T x) {};\n"
+                          "void bar() {\n"
+                          "  int y[3];\n"
+                          "  foo<int[]>(y);\n"
+                          "}"));
+        ASSERT_EQUALS("struct A<int[2]> ; "
+                      "A<int[2]> y ; "
+                      "struct A<int[2]> { int [ 2 ] x ; } ;",
+                      tok("template <class T> struct A { T x; };\n"
+                          "A<int[2]> y;"));
+
+        // Previously resulted in:
+        //   test.cpp:2:33: error: Syntax Error: AST broken, binary operator '>' doesn't have two operands. [internalAstError]
+        ASSERT_EQUALS("struct A<B<int>[]> ; "
+                      "struct B<B<int>> ; "
+                      "struct C<B<int>> ; "
+                      "C<B<int>> y ; "
+                      "struct C<B<int>> : B<B<int>> { } ; "
+                      "struct B<B<int>> { A<B<int>[]> x ; } ; "
+                      "struct A<B<int>[]> { } ;",
+                      tok("template <class  > struct A {};\n"
+                          "template <class T> struct B { A<T[]> x; };\n"
+                          "template <class T> struct C : B<T> {};\n"
+                          "C<B<int>> y;"));
+    }
+
+    template<size_t size>
+    unsigned int templateParameters(const char (&data)[size]) {
+        TokenList tokenlist{settings, Standards::Language::CPP};
+        tokenlist.appendFileIfNew("test.cpp");
+        if (!tokenlist.createTokensFromString(data))
+            return false;
+        TokenizerTest tokenizer(std::move(tokenlist), *this);
         tokenizer.createLinks();
-        tokenizer.mTemplateSimplifier->fixAngleBrackets();
+        tokenizer.splitTemplateRightAngleBrackets(false);
 
         for (const Token *tok1 = tokenizer.tokens(); tok1; tok1 = tok1->next()) {
             if (tok1->str() == "var1")
@@ -4272,6 +5528,8 @@ class TestSimplifyTemplate : public TestFixture {
         ASSERT_EQUALS(1U, templateParameters("X<int...> x;"));
         ASSERT_EQUALS(2U, templateParameters("X<class, typename...> x;"));
         ASSERT_EQUALS(2U, templateParameters("X<1, T> x;"));
+        ASSERT_EQUALS(1U, templateParameters("X<T[]> x;"));
+        ASSERT_EQUALS(1U, templateParameters("X<T[2]> x;"));
         ASSERT_EQUALS(1U, templateParameters("X<i == 0> x;"));
         ASSERT_EQUALS(2U, templateParameters("X<int, i>=0> x;"));
         ASSERT_EQUALS(3U, templateParameters("X<int, i>=0, i - 2> x;"));
@@ -4291,19 +5549,30 @@ class TestSimplifyTemplate : public TestFixture {
         ASSERT_EQUALS(2U, templateParameters("template<template<typename>...Foo,template<template<template<typename>>>> x;"));
         ASSERT_EQUALS(3U, templateParameters("template<template<typename>...Foo,int,template<template<template<typename>>>> x;"));
         ASSERT_EQUALS(4U, templateParameters("template<template<typename>...Foo,int,template<template<template<typename>>>,int> x;"));
+        ASSERT_EQUALS(2U, templateParameters("template<typename S, enable_if_t<(is_compile_string<S>::value), int>> void i(S s);"));
+        ASSERT_EQUALS(2U, templateParameters("template<typename c, b<(c::d), int>> void e();"));
+        ASSERT_EQUALS(3U, templateParameters("template <class T, class... Args, class Tup = std::tuple<Args&...>> constexpr void f() {}")); // #11351
+        ASSERT_EQUALS(3U, templateParameters("template <class T, class... Args, class Tup = std::tuple<Args&&...>> void f() {}"));
+        ASSERT_EQUALS(3U, templateParameters("template <class T, class... Args, class Tup = std::tuple<Args*...>> void f() {}"));
+        ASSERT_EQUALS(1U, templateParameters("S<4 < sizeof(uintptr_t)> x;"));
+        ASSERT_EQUALS(2U, templateParameters("template <typename... Ts, typename = std::enable_if_t<std::is_same<Ts..., int>::value>> void g() {}")); // #11915
+        ASSERT_EQUALS(1U, templateParameters("S<N::M<O<\"A\"_I>>> s;")); // #10837
     }
 
     // Helper function to unit test TemplateSimplifier::getTemplateNamePosition
-    int templateNamePositionHelper(const char code[], unsigned offset = 0) {
-        Tokenizer tokenizer(&settings, this);
-
-        std::istringstream istr(code);
-        tokenizer.createTokens(istr, "test.cpp");
+    template<size_t size>
+    int templateNamePositionHelper(const char (&data)[size], unsigned offset = 0) {
+        TokenList tokenlist{settings, Standards::Language::CPP};
+
+        tokenlist.appendFileIfNew("test.cpp");
+        if (!tokenlist.createTokensFromString(data))
+            return false;
+        TokenizerTest tokenizer(std::move(tokenlist), *this);
         tokenizer.createLinks();
-        tokenizer.mTemplateSimplifier->fixAngleBrackets();
+        tokenizer.splitTemplateRightAngleBrackets(false);
 
         const Token *_tok = tokenizer.tokens();
-        for (unsigned i = 0 ; i < offset ; ++i)
+        for (unsigned i = 0; i < offset; ++i)
             _tok = _tok->next();
         return tokenizer.mTemplateSimplifier->getTemplateNamePosition(_tok);
     }
@@ -4364,21 +5633,22 @@ class TestSimplifyTemplate : public TestFixture {
     }
 
     // Helper function to unit test TemplateSimplifier::findTemplateDeclarationEnd
-    bool findTemplateDeclarationEndHelper(const char code[], const char pattern[], unsigned offset = 0) {
-        Tokenizer tokenizer(&settings, this);
-
-        std::istringstream istr(code);
-        tokenizer.createTokens(istr, "test.cpp");
+    template<size_t size>
+    bool findTemplateDeclarationEndHelper(const char (&data)[size], const char pattern[], unsigned offset = 0) {
+        TokenList tokenlist{settings, Standards::Language::CPP};
+        if (!TokenListHelper::createTokensFromString(tokenlist, data, "test.cpp"))
+            return false;
+        TokenizerTest tokenizer(std::move(tokenlist), *this);
         tokenizer.createLinks();
-        tokenizer.mTemplateSimplifier->fixAngleBrackets();
+        tokenizer.splitTemplateRightAngleBrackets(false);
 
         const Token *_tok = tokenizer.tokens();
-        for (unsigned i = 0 ; i < offset ; ++i)
+        for (unsigned i = 0; i < offset; ++i)
             _tok = _tok->next();
 
         const Token *tok1 = TemplateSimplifier::findTemplateDeclarationEnd(_tok);
 
-        return (tok1 == Token::findsimplematch(tokenizer.list.front(), pattern));
+        return (tok1 == Token::findsimplematch(tokenizer.list.front(), pattern, strlen(pattern)));
     }
 
     void findTemplateDeclarationEnd() {
@@ -4392,6 +5662,38 @@ class TestSimplifyTemplate : public TestFixture {
         ASSERT(findTemplateDeclarationEndHelper("template <typename... f, c<h<e<typename f::d...>>::g>> void i(){} int x;", "} int x ;"));
     }
 
+    // Helper function to unit test TemplateSimplifier::getTemplateParametersInDeclaration
+    template<size_t size>
+    bool getTemplateParametersInDeclarationHelper(const char (&data)[size], const std::vector<std::string> & params) {
+        TokenList tokenlist{settings, Standards::Language::CPP};
+
+        if (!TokenListHelper::createTokensFromString(tokenlist, data, "test.cpp"))
+            return false;
+        TokenizerTest tokenizer(std::move(tokenlist), *this);
+        tokenizer.createLinks();
+        tokenizer.splitTemplateRightAngleBrackets(false);
+
+        std::vector<const Token *> typeParametersInDeclaration;
+        TemplateSimplifierTest::getTemplateParametersInDeclaration(tokenizer.tokens()->tokAt(2), typeParametersInDeclaration);
+
+        if (params.size() != typeParametersInDeclaration.size())
+            return false;
+
+        for (size_t i = 0; i < typeParametersInDeclaration.size(); ++i) {
+            if (typeParametersInDeclaration[i]->str() != params[i])
+                return false;
+        }
+        return true;
+    }
+
+    void getTemplateParametersInDeclaration() {
+        ASSERT(getTemplateParametersInDeclarationHelper("template<typename T> class Fred {};", std::vector<std::string> {"T"}));
+        ASSERT(getTemplateParametersInDeclarationHelper("template<typename T=int> class Fred {};", std::vector<std::string> {"T"}));
+        ASSERT(getTemplateParametersInDeclarationHelper("template<typename T,typename U> class Fred {};", std::vector<std::string> {"T","U"}));
+        ASSERT(getTemplateParametersInDeclarationHelper("template<typename T,typename U=int> class Fred {};", std::vector<std::string> {"T","U"}));
+        ASSERT(getTemplateParametersInDeclarationHelper("template<typename T=int,typename U=int> class Fred {};", std::vector<std::string> {"T","U"}));
+    }
+
     void expandSpecialized1() {
         ASSERT_EQUALS("class A<int> { } ;", tok("template<> class A<int> {};"));
         ASSERT_EQUALS("class A<int> : public B { } ;", tok("template<> class A<int> : public B {};"));
@@ -4505,7 +5807,7 @@ class TestSimplifyTemplate : public TestFixture {
                             "private:\n"
                             "    std::basic_ostream<unsigned char> &outputStream_;\n"
                             "};";
-        const char expected[] = "struct OutputU16<unsignedchar> final { "
+        const char expected[] = "struct OutputU16<unsignedchar> { "
                                 "explicit OutputU16<unsignedchar> ( std :: basic_ostream < unsigned char > & t ) : outputStream_ ( t ) { } "
                                 "void operator() ( unsigned short ) const ; "
                                 "private: "
@@ -4569,6 +5871,45 @@ class TestSimplifyTemplate : public TestFixture {
                                     "class C<int> { } ;";
             ASSERT_EQUALS(expected, tok(code));
         }
+        {
+            const char code[] = "class A {};\n"
+                                "template<typename T> struct B;\n"
+                                "template<> struct B<A> {};\n"
+                                "int f() {\n"
+                                "    int B[1] = {};\n"
+                                "    return B[0];\n"
+                                "}\n";
+            const char expected[] = "class A { } ; "
+                                    "struct B<A> ; "
+                                    "template < typename T > struct B ; "
+                                    "struct B<A> { } ; "
+                                    "int f ( ) { "
+                                    "int B [ 1 ] = { } ; "
+                                    "return B [ 0 ] ; "
+                                    "}";
+            ASSERT_EQUALS(expected, tok(code));
+        }
+    }
+
+    void expandSpecialized5() {
+        const char code[] = "template<typename T> class hash;\n" // #10494
+                            "template<> class hash<int> {};\n"
+                            "int f(int i) {\n"
+                            "    int hash = i;\n"
+                            "    const int a[2]{};\n"
+                            "    return a[hash];\n"
+                            "}\n";
+
+        const char expected[] = "class hash<int> ; "
+                                "template < typename T > class hash ; "
+                                "class hash<int> { } ; "
+                                "int f ( int i ) { "
+                                "int hash ; hash = i ; "
+                                "const int a [ 2 ] { } ; "
+                                "return a [ hash ] ; "
+                                "}";
+
+        ASSERT_EQUALS(expected, tok(code));
     }
 
     void templateAlias1() {
@@ -4626,16 +5967,17 @@ class TestSimplifyTemplate : public TestFixture {
         ASSERT_EQUALS(expected, tok(code));
     }
 
-    unsigned int instantiateMatch(const char code[], const std::size_t numberOfArguments, const char patternAfter[]) {
-        Tokenizer tokenizer(&settings, this);
+#define instantiateMatch(...) instantiateMatch_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    bool instantiateMatch_(const char* file, int line, const char (&code)[size], const std::size_t numberOfArguments, const char patternAfter[]) {
+        SimpleTokenizer tokenizer(settings, *this);
 
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp", "");
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
-        return TemplateSimplifier::instantiateMatch(tokenizer.tokens(), numberOfArguments, patternAfter);
+        return (TemplateSimplifierTest::instantiateMatch)(tokenizer.tokens(), numberOfArguments, false, patternAfter);
     }
 
-    void instantiateMatch() {
+    void instantiateMatchTest() {
         // Ticket #8175
         ASSERT_EQUALS(false,
                       instantiateMatch("ConvertHelper < From, To > c ;",
@@ -4740,7 +6082,7 @@ class TestSimplifyTemplate : public TestFixture {
                                 "void f<bool> ( bool n ) { ( void ) n ; }";
 
         ASSERT_EQUALS(expected, tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void templateTypeDeduction2() {
@@ -4769,6 +6111,181 @@ class TestSimplifyTemplate : public TestFixture {
         TODO_ASSERT_EQUALS(expected, actual, tok(code));
     }
 
+    void templateTypeDeduction3() {  // #9975
+        const char code[] = "struct A {\n"
+                            "    int a = 1;\n"
+                            "    void f() { g(1); }\n"
+                            "    template <typename T> void g(T x) { a = 2; }\n"
+                            "};\n"
+                            "int main() {\n"
+                            "    A a;\n"
+                            "    a.f();\n"
+                            "}";
+        const char exp[]  = "struct A { "
+                            "int a ; a = 1 ; "
+                            "void f ( ) { g<int> ( 1 ) ; } "
+                            "void g<int> ( int x ) ; "
+                            "} ; "
+                            "int main ( ) { "
+                            "A a ; "
+                            "a . f ( ) ; "
+                            "} void A :: g<int> ( int x ) { a = 2 ; }";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void templateTypeDeduction4() {  // #9983
+        {
+            const char code[] = "int a = 1;\n"
+                                "template <typename T> void f(T x, T y) { a = x + y; }\n"
+                                "void test() { f(0, 0); }";
+            const char exp[]  = "int a ; a = 1 ; "
+                                "void f<int> ( int x , int y ) ; "
+                                "void test ( ) { f<int> ( 0 , 0 ) ; } "
+                                "void f<int> ( int x , int y ) { a = x + y ; }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+        {
+            const char code[] = "int a = 1;\n"
+                                "template <typename T> void f(T x, double y) { a = x + y; }\n"
+                                "void test() { f(0, 0.0); }";
+            const char exp[]  = "int a ; a = 1 ; "
+                                "void f<int> ( int x , double y ) ; "
+                                "void test ( ) { f<int> ( 0 , 0.0 ) ; } "
+                                "void f<int> ( int x , double y ) { a = x + y ; }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+        {
+            const char code[] = "int a = 1;\n"
+                                "template <typename T> void f(double x, T y) { a = x + y; }\n"
+                                "void test() { f(0.0, 0); }";
+            const char exp[]  = "int a ; a = 1 ; "
+                                "void f<int> ( double x , int y ) ; "
+                                "void test ( ) { f<int> ( 0.0 , 0 ) ; } "
+                                "void f<int> ( double x , int y ) { a = x + y ; }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+
+        {
+            const char code[] = "int a = 1;\n"
+                                "template <typename T> void f(double x, T y) { a = x + y; }\n"
+                                "template <typename T> void f(int x, T y) { a = x + y; }\n"
+                                "void test() {\n"
+                                "    f(0, 0);\n"
+                                "    f(0.0, 0);\n"
+                                "    f(0, 0.0);\n"
+                                "    f(0.0, 0.0);\n"
+                                "}";
+            const char exp[]  = "int a ; a = 1 ; "
+                                "void f<int> ( int x , int y ) ; "
+                                "void f<int> ( double x , int y ) ; "
+                                "void f<double> ( int x , double y ) ; "
+                                "void f<double> ( double x , double y ) ; "
+                                "void test ( ) { "
+                                "f<int> ( 0 , 0 ) ; "
+                                "f<int> ( 0.0 , 0 ) ; "
+                                "f<double> ( 0 , 0.0 ) ; "
+                                "f<double> ( 0.0 , 0.0 ) ; "
+                                "} "
+                                "void f<int> ( int x , int y ) { a = x + y ; } "
+                                "void f<int> ( double x , int y ) { a = x + y ; } "
+                                "void f<double> ( int x , double y ) { a = x + y ; } "
+                                "void f<double> ( double x , double y ) { a = x + y ; }";
+
+            const char act[]  = "int a ; a = 1 ; "
+                                "template < typename T > void f ( double x , T y ) { a = x + y ; } "
+                                "void f<int> ( int x , int y ) ; void f<double> ( int x , double y ) ; "
+                                "void test ( ) { "
+                                "f<int> ( 0 , 0 ) ; "
+                                "f<int> ( 0.0 , 0 ) ; "
+                                "f<double> ( 0 , 0.0 ) ; "
+                                "f<double> ( 0.0 , 0.0 ) ; "
+                                "} "
+                                "void f<int> ( int x , int y ) { a = x + y ; } "
+                                "void f<double> ( int x , double y ) { a = x + y ; }";
+            TODO_ASSERT_EQUALS(exp, act, tok(code));
+        }
+        {
+            const char code[] = "int a = 1;\n"
+                                "template <typename T, typename U> void f(T x, U y) { a = x + y; }\n"
+                                "void test() { f(0, 0.0); }";
+            const char exp[]  = "int a ; a = 1 ; "
+                                "void f<int,double> ( int x , double y ) ; "
+                                "void test ( ) { f<int,double> ( 0 , 0.0 ) ; } "
+                                "void f<int,double> ( int x , double y ) { a = x + y ; }";
+            const char act[]  = "int a ; a = 1 ; "
+                                "template < typename T , typename U > void f ( T x , U y ) { a = x + y ; } "
+                                "void test ( ) { f ( 0 , 0.0 ) ; }";
+            TODO_ASSERT_EQUALS(exp, act, tok(code));
+        }
+    }
+
+    void templateTypeDeduction5() {
+        {
+            const char code[] = "class Fred {\n"
+                                "public:\n"
+                                "    template <class T> Fred(T t) { }\n"
+                                "};\n"
+                                "Fred fred1 = Fred(0);\n"
+                                "Fred fred2 = Fred(0.0);\n"
+                                "Fred fred3 = Fred(\"zero\");\n"
+                                "Fred fred4 = Fred(false);";
+            const char exp[]  = "class Fred { "
+                                "public: "
+                                "Fred<int> ( int t ) ; "
+                                "Fred<double> ( double t ) ; "
+                                "Fred<constchar*> ( const char * t ) ; "
+                                "Fred<bool> ( bool t ) ; "
+                                "} ; "
+                                "Fred fred1 ; fred1 = Fred<int> ( 0 ) ; "
+                                "Fred fred2 ; fred2 = Fred<double> ( 0.0 ) ; "
+                                "Fred fred3 ; fred3 = Fred<constchar*> ( \"zero\" ) ; "
+                                "Fred fred4 ; fred4 = Fred<bool> ( false ) ; "
+                                "Fred :: Fred<int> ( int t ) { } "
+                                "Fred :: Fred<double> ( double t ) { } "
+                                "Fred :: Fred<constchar*> ( const char * t ) { } "
+                                "Fred :: Fred<bool> ( bool t ) { }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+        {
+            const char code[] = "namespace NS {\n"
+                                "class Fred {\n"
+                                "public:\n"
+                                "    template <class T> Fred(T t) { }\n"
+                                "};\n"
+                                "Fred fred1 = Fred(0);\n"
+                                "Fred fred2 = Fred(0.0);\n"
+                                "Fred fred3 = Fred(\"zero\");\n"
+                                "Fred fred4 = Fred(false);\n"
+                                "}\n"
+                                "NS::Fred fred1 = NS::Fred(0);\n"
+                                "NS::Fred fred2 = NS::Fred(0.0);\n"
+                                "NS::Fred fred3 = NS::Fred(\"zero\");\n"
+                                "NS::Fred fred4 = NS::Fred(false);\n";
+            const char exp[]  = "namespace NS { "
+                                "class Fred { "
+                                "public: "
+                                "Fred<int> ( int t ) ; "
+                                "Fred<double> ( double t ) ; "
+                                "Fred<constchar*> ( const char * t ) ; "
+                                "Fred<bool> ( bool t ) ; "
+                                "} ; "
+                                "Fred fred1 ; fred1 = Fred<int> ( 0 ) ; "
+                                "Fred fred2 ; fred2 = Fred<double> ( 0.0 ) ; "
+                                "Fred fred3 ; fred3 = Fred<constchar*> ( \"zero\" ) ; "
+                                "Fred fred4 ; fred4 = Fred<bool> ( false ) ; "
+                                "} "
+                                "NS :: Fred fred1 ; fred1 = NS :: Fred<int> ( 0 ) ; "
+                                "NS :: Fred fred2 ; fred2 = NS :: Fred<double> ( 0.0 ) ; "
+                                "NS :: Fred fred3 ; fred3 = NS :: Fred<constchar*> ( \"zero\" ) ; "
+                                "NS :: Fred fred4 ; fred4 = NS :: Fred<bool> ( false ) ; "
+                                "NS :: Fred :: Fred<int> ( int t ) { } "
+                                "NS :: Fred :: Fred<double> ( double t ) { } "
+                                "NS :: Fred :: Fred<constchar*> ( const char * t ) { } "
+                                "NS :: Fred :: Fred<bool> ( bool t ) { }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+    }
+
     void simplifyTemplateArgs1() {
         ASSERT_EQUALS("foo<2> = 2 ; foo<2> ;", tok("template<int N> foo = N; foo < ( 2 ) >;"));
         ASSERT_EQUALS("foo<2> = 2 ; foo<2> ;", tok("template<int N> foo = N; foo < 1 + 1 >;"));
@@ -4796,6 +6313,35 @@ class TestSimplifyTemplate : public TestFixture {
         ASSERT_EQUALS(expected, tok(code));
     }
 
+    void simplifyTemplateArgs3() { // #11418
+        const char code[] = "template <class T> struct S {};\n"
+                            "template<typename T>\n"
+                            "T f() {}\n"
+                            "template<typename T, typename U>\n"
+                            "void g() {\n"
+                            "    S<decltype(true ? f<T>() : f<U>())> s1;\n"
+                            "    S<decltype(false ? f<T>() : f<U>())> s2;\n"
+                            "}\n"
+                            "void h() {\n"
+                            "    g<int, char>();\n"
+                            "}\n";
+        const char expected[] = "struct S<decltype((f<int>()))> ; "
+                                "struct S<decltype(f<char>())> ; "
+                                "int f<int> ( ) ; "
+                                "char f<char> ( ) ; "
+                                "void g<int,char> ( ) ; "
+                                "void h ( ) { g<int,char> ( ) ; } "
+                                "void g<int,char> ( ) { "
+                                "S<decltype((f<int>()))> s1 ; "
+                                "S<decltype(f<char>())> s2 ; "
+                                "} "
+                                "int f<int> ( ) { } "
+                                "char f<char> ( ) { } "
+                                "struct S<decltype((f<int>()))> { } ; "
+                                "struct S<decltype(f<char>())> { } ;";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
     void template_variadic_1() { // #9144
         const char code[] = "template <typename...> struct e {};\n"
                             "static_assert(sizeof(e<>) == sizeof(e<int,int>), \"\");";
@@ -4805,6 +6351,79 @@ class TestSimplifyTemplate : public TestFixture {
         ASSERT_EQUALS(expected, tok(code));
     }
 
+    void template_variadic_2() { // #4349
+        const char code[] = "template<typename T, typename... Args>\n"
+                            "void printf(const char *s, T value, Args... args) {}\n"
+                            "\n"
+                            "int main() {\n"
+                            "    printf<int, float>(\"\", foo, bar);\n"
+                            "}";
+        const char expected[] = "void printf<int,float> ( const char * s , int value , float ) ; "
+                                "int main ( ) { printf<int,float> ( \"\" , foo , bar ) ; } "
+                                "void printf<int,float> ( const char * s , int value , float ) { }";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
+    void template_variadic_3() { // #6172
+        const char code[] = "template<int N, int ... M> struct A { "
+                            "  static void foo() { "
+                            "    int i = N; "
+                            "  } "
+                            "}; "
+                            "void bar() { "
+                            "  A<0>::foo(); "
+                            "}";
+        const char expected[] = "struct A<0> ; "
+                                "void bar ( ) { A<0> :: foo ( ) ; } "
+                                "struct A<0> { static void foo ( ) { int i ; i = ( int ) 0 ; } } ;";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
+    void template_variadic_4() { // #11763
+        const char code[] = "template <int... N>\n"
+                            "class E {\n"
+                            "    template <int... I>\n"
+                            "    int f(int n, std::integer_sequence<int, I...>) {\n"
+                            "        return (((I == n) ? N : 0) + ...);\n"
+                            "    }\n"
+                            "};\n"
+                            "E<1, 3> e;\n";
+        const char expected[] = "class E<1,3> ; E<1,3> e ; "
+                                "class E<1,3> { "
+                                "template < int ... I > "
+                                "int f ( int n , std :: integer_sequence < int , I ... > ) { "
+                                "return ( ( ( I == n ) ? ( 1 , 3 ) : 0 ) + ... ) ; "  // TODO the simplification is not quite correct
+                                "} "
+                                "} ;";
+        ASSERT_EQUALS(expected, tok(code));
+
+        const char code2[] = "template <typename T>\n" // #13929
+                             "struct S {};\n"
+                             "template <typename T, template<typename...> typename C = S>\n"
+                             "struct A {\n"
+                             "    using x = C<T>;\n"
+                             "};\n"
+                             "A<int> a;\n";
+        const char expected2[] = "template < typename T > "
+                                 "struct S { } ; "
+                                 "struct A<int,S> ; "
+                                 "A<int,S> a ; "
+                                 "struct A<int,S> { } ;";
+        ASSERT_EQUALS(expected2, tok(code2));
+
+        const char code3[] = "template <int... N>\n" // #14477
+                             "    int f() {\n"
+                             "    return (0 | ... | (1, 2, 4));\n"
+                             "}\n"
+                             "int main() {\n"
+                             "    return f<1, 2, 4>();\n"
+                             "}\n";
+        const char expected3[] = "int f<1,2,4> ( ) ; "
+                                 "int main ( ) { return f<1,2,4> ( ) ; } "
+                                 "int f<1,2,4> ( ) { return ( 0 | ... | ( 1 , 2 , 4 ) ) ; }";
+        ASSERT_EQUALS(expected3, tok(code3));
+    }
+
     void template_variable_1() {
         {
             const char code[] = "template <int N> const int foo = N*N;\n"
@@ -4840,28 +6459,28 @@ class TestSimplifyTemplate : public TestFixture {
         {
             const char code[] = "template<class T> constexpr T pi = T(3.1415926535897932385L);\n"
                                 "float x = pi<float>;";
-            const char expected[] = "const float pi<float> = float ( 3.1415926535897932385L ) ; "
+            const char expected[] = "constexpr float pi<float> = float ( 3.1415926535897932385L ) ; "
                                     "float x ; x = pi<float> ;";
             ASSERT_EQUALS(expected, tok(code));
         }
         {
             const char code[] = "template<class> constexpr float pi = float(3.1415926535897932385L);\n"
                                 "float x = pi<float>;";
-            const char expected[] = "const float pi<float> = float ( 3.1415926535897932385L ) ; "
+            const char expected[] = "constexpr float pi<float> = float ( 3.1415926535897932385L ) ; "
                                     "float x ; x = pi<float> ;";
             ASSERT_EQUALS(expected, tok(code));
         }
         {
             const char code[] = "template<class T = float> constexpr T pi = T(3.1415926535897932385L);\n"
                                 "float x = pi<float>;";
-            const char expected[] = "const float pi<float> = float ( 3.1415926535897932385L ) ; "
+            const char expected[] = "constexpr float pi<float> = float ( 3.1415926535897932385L ) ; "
                                     "float x ; x = pi<float> ;";
             ASSERT_EQUALS(expected, tok(code));
         }
         {
             const char code[] = "template<class T = float> constexpr T pi = T(3.1415926535897932385L);\n"
                                 "float x = pi<>;";
-            const char expected[] = "const float pi<float> = float ( 3.1415926535897932385L ) ; "
+            const char expected[] = "constexpr float pi<float> = float ( 3.1415926535897932385L ) ; "
                                     "float x ; x = pi<float> ;";
             ASSERT_EQUALS(expected, tok(code));
         }
@@ -4871,35 +6490,35 @@ class TestSimplifyTemplate : public TestFixture {
         {
             const char code[] = "template<class T, int N> constexpr T foo = T(N*N);\n"
                                 "float x = foo<float,7>;";
-            const char expected[] = "const float foo<float,7> = float ( 49 ) ; "
+            const char expected[] = "constexpr float foo<float,7> = float ( 49 ) ; "
                                     "float x ; x = foo<float,7> ;";
             ASSERT_EQUALS(expected, tok(code));
         }
         {
             const char code[] = "template<class,int> constexpr float foo = float(7);\n"
                                 "float x = foo<float,7>;";
-            const char expected[] = "const float foo<float,7> = float ( 7 ) ; "
+            const char expected[] = "constexpr float foo<float,7> = float ( 7 ) ; "
                                     "float x ; x = foo<float,7> ;";
             ASSERT_EQUALS(expected, tok(code));
         }
         {
             const char code[] = "template<class T = float, int N = 7> constexpr T foo = T(7);\n"
                                 "double x = foo<double, 14>;";
-            const char expected[] = "const double foo<double,14> = double ( 7 ) ; "
+            const char expected[] = "constexpr double foo<double,14> = double ( 7 ) ; "
                                     "double x ; x = foo<double,14> ;";
             ASSERT_EQUALS(expected, tok(code));
         }
         {
             const char code[] = "template<class T = float, int N = 7> constexpr T foo = T(7);\n"
                                 "float x = foo<>;";
-            const char expected[] = "const float foo<float,7> = float ( 7 ) ; "
+            const char expected[] = "constexpr float foo<float,7> = float ( 7 ) ; "
                                     "float x ; x = foo<float,7> ;";
             ASSERT_EQUALS(expected, tok(code));
         }
         {
             const char code[] = "template<class T = float, int N = 7> constexpr T foo = T(7);\n"
                                 "double x = foo<double>;";
-            const char expected[] = "const double foo<double,7> = double ( 7 ) ; "
+            const char expected[] = "constexpr double foo<double,7> = double ( 7 ) ; "
                                     "double x ; x = foo<double,7> ;";
             ASSERT_EQUALS(expected, tok(code));
         }
@@ -4960,6 +6579,138 @@ class TestSimplifyTemplate : public TestFixture {
                                 "class type<longdouble> { } ;";
         ASSERT_EQUALS(expected, tok(code));
     }
+
+    void castInExpansion() {
+        const char code[] = "template <int N> class C { };\n"
+                            "template <typename TC> class Base {};\n"
+                            "template <typename TC> class Derived : private Base<TC> {};\n"
+                            "typedef Derived<C<static_cast<int>(-1)> > C_;\n"
+                            "class C3 { C_ c; };";
+        const char expected[] = "template < int N > class C { } ; "
+                                "class Base<C<static_cast<int>(-1)>> ; "
+                                "class Derived<C<static_cast<int>(-1)>> ; "
+                                "class C3 { Derived<C<static_cast<int>(-1)>> c ; } ; "
+                                "class Derived<C<static_cast<int>(-1)>> : private Base<C<static_cast<int>(-1)>> { } ; "
+                                "class Base<C<static_cast<int>(-1)>> { } ;";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
+    void fold_expression_1() {
+        const char code[] = "template<typename... Args> bool all(Args... args) { return (... && args); }\n"
+                            "x=all(true,false,true,true);";
+        const char expected[] = "template < typename ... Args > bool all ( Args ... args ) { return ( __cppcheck_fold_&&__ ( args ... ) ) ; } x = all ( true , false , true , true ) ;";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
+    void fold_expression_2() {
+        const char code[] = "template<typename... Args> bool all(Args... args) { return (args && ...); }\n"
+                            "x=all(true,false,true,true);";
+        const char expected[] = "template < typename ... Args > bool all ( Args ... args ) { return ( __cppcheck_fold_&&__ ( args ... ) ) ; } x = all ( true , false , true , true ) ;";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
+    void fold_expression_3() {
+        const char code[] = "template<typename... Args> int foo(Args... args) { return (12 * ... * args); }\n"
+                            "x=foo(1,2);";
+        const char expected[] = "template < typename ... Args > int foo ( Args ... args ) { return ( __cppcheck_fold_*__ ( args ... ) ) ; } x = foo ( 1 , 2 ) ;";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
+    void fold_expression_4() {
+        const char code[] = "template<typename... Args> int foo(Args... args) { return (args * ... * 123); }\n"
+                            "x=foo(1,2);";
+        const char expected[] = "template < typename ... Args > int foo ( Args ... args ) { return ( __cppcheck_fold_*__ ( args ... ) ) ; } x = foo ( 1 , 2 ) ;";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
+    void concepts1() {
+        const char code[] = "template <my_concept T> void f(T v) {}\n"
+                            "f<int>(123);";
+        const char expected[] = "void f<int> ( int v ) ; f<int> ( 123 ) ; void f<int> ( int v ) { }";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
+    void requires1() {
+        const char code[] = "template <class T> requires my_concept<T> void f(T v) {}\n"
+                            "f<int>(123);";
+        const char expected[] = "void f<int> ( int v ) ; f<int> ( 123 ) ; void f<int> ( int v ) { }";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
+    void requires2() {
+        const char code[] = "template<class T> requires (sizeof(T) > 1 && get_value<T>()) void f(T v){}\n"
+                            "f<int>(123);";
+        const char expected[] = "void f<int> ( int v ) ; f<int> ( 123 ) ; void f<int> ( int v ) { }";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
+    void requires3() {
+        const char code[] = "template<class T> requires c1<T> && c2<T> void f(T v){}\n"
+                            "f<int>(123);";
+        const char expected[] = "void f<int> ( int v ) ; f<int> ( 123 ) ; void f<int> ( int v ) { }";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
+    void requires4() {
+        const char code[] = "template <class T> void f(T v) requires my_concept<T> {}\n"
+                            "f<int>(123);";
+        const char expected[] = "void f<int> ( int v ) ; f<int> ( 123 ) ; void f<int> ( int v ) { }";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
+    void requires5() {
+        const char code[] = "template <class T>\n"
+                            "  requires requires (T x) { x + x; }\n"
+                            "  T add(T a, T b) { return a + b; }\n"
+                            "add<int>(123,456);";
+        const char expected[] = "int add<int> ( int a , int b ) ; add<int> ( 123 , 456 ) ; int add<int> ( int a , int b ) { return a + b ; }";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
+    void explicitBool1() {
+        const char code[] = "class Fred { explicit(true) Fred(int); };";
+        ASSERT_EQUALS("class Fred { explicit Fred ( int ) ; } ;", tok(code));
+    }
+
+    void explicitBool2() {
+        const char code[] = "class Fred { explicit(false) Fred(int); };";
+        ASSERT_EQUALS("class Fred { Fred ( int ) ; } ;", tok(code));
+    }
+
+    void templateArgPreserveType() { // #13882 - type of template argument
+        const char code[] = "template <uint32_t x> class Test {\n"
+                            "    uint32_t i = x;\n"
+                            "};\n"
+                            "Test<64> test;\n";
+        ASSERT_EQUALS("class Test<64> ; "
+                      "Test<64> test ; "
+                      "class Test<64> { uint32_t i ; i = ( uint32_t ) 64 ; } ;",
+                      tok(code));
+    }
+
+    void dumpTemplateArgFrom() {
+        const char code[] = "template<class T> void foo(T t) {}\n"
+                            "foo<int>(23);";
+        const std::string d = dump(code);
+        ASSERT(!d.empty());
+
+        // Assert that first 'int' token has templateArg location info
+        const std::string::size_type strpos1 = d.find(" str=\"int\" ");
+        ASSERT(strpos1 < d.size());
+        const std::string::size_type endpos1 = d.find('>', strpos1);
+        const std::string::size_type templateArgPos1 = d.find(" templateArgFileIndex=\"0\" templateArgLineNumber=\"2\" templateArgColumn=\"5\"");
+        ASSERT(templateArgPos1 > strpos1 && templateArgPos1 < endpos1);
+
+        // Assert that second 'int' token has templateArg location info
+        const std::string::size_type strpos2 = d.find(" str=\"int\" ", endpos1);
+        ASSERT(strpos2 < d.size());
+        const std::string::size_type endpos2 = d.find('>', strpos2);
+        const std::string::size_type templateArgPos2 = d.find(" templateArgFileIndex=\"0\" templateArgLineNumber=\"2\" templateArgColumn=\"5\"", endpos1);
+        ASSERT(templateArgPos2 > strpos2 && templateArgPos2 < endpos2);
+
+        // Assert there is no further unexpected templateArg location info
+        ASSERT(d.find(" templateArg", endpos2) == std::string::npos);
+    }
 };
 
 REGISTER_TEST(TestSimplifyTemplate)
diff --git a/test/testsimplifytokens.cpp b/test/testsimplifytokens.cpp
index 4d23b0d2b16..f55b1e83fc7 100644
--- a/test/testsimplifytokens.cpp
+++ b/test/testsimplifytokens.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,138 +16,50 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "errortypes.h"
+#include "helpers.h"
 #include "platform.h"
 #include "settings.h"
-#include "testsuite.h"
+#include "standards.h"
+#include "fixture.h"
 #include "token.h"
-#include "tokenize.h"
-#include "tokenlist.h"
 
-#include <ostream>
+#include <cstddef>
 #include <string>
 
-
 class TestSimplifyTokens : public TestFixture {
 public:
-    TestSimplifyTokens() : TestFixture("TestSimplifyTokens") {
-    }
+    TestSimplifyTokens() : TestFixture("TestSimplifyTokens") {}
 
 
 private:
-    Settings settings0;
-    Settings settings1;
-    Settings settings_std;
-    Settings settings_windows;
-
-    void run() OVERRIDE {
-        LOAD_LIB_2(settings_std.library, "std.cfg");
-        LOAD_LIB_2(settings_windows.library, "windows.cfg");
-        settings0.addEnabled("portability");
-        settings1.addEnabled("style");
-        settings_windows.addEnabled("portability");
-
-        // Make sure the Tokenizer::simplifyTokenList works.
-        // The order of the simplifications is important. So this test
-        // case shall make sure the simplifications are done in the
-        // correct order
-        TEST_CASE(simplifyTokenList1);
-
-        TEST_CASE(simplifyMathFunctions_sqrt);
-        TEST_CASE(simplifyMathFunctions_cbrt);
-        TEST_CASE(simplifyMathFunctions_exp);
-        TEST_CASE(simplifyMathFunctions_exp2);
-        TEST_CASE(simplifyMathFunctions_logb);
-        TEST_CASE(simplifyMathFunctions_log1p);
-        TEST_CASE(simplifyMathFunctions_ilogb);
-        TEST_CASE(simplifyMathFunctions_log10);
-        TEST_CASE(simplifyMathFunctions_log);
-        TEST_CASE(simplifyMathFunctions_log2);
-        TEST_CASE(simplifyMathFunctions_pow);
-        TEST_CASE(simplifyMathFunctions_fmin);
-        TEST_CASE(simplifyMathFunctions_fmax);
-        TEST_CASE(simplifyMathFunctions_acosh);
-        TEST_CASE(simplifyMathFunctions_acos);
-        TEST_CASE(simplifyMathFunctions_cosh);
-        TEST_CASE(simplifyMathFunctions_cos);
-        TEST_CASE(simplifyMathFunctions_erfc);
-        TEST_CASE(simplifyMathFunctions_erf);
-        TEST_CASE(simplifyMathFunctions_sin);
-        TEST_CASE(simplifyMathFunctions_sinh);
-        TEST_CASE(simplifyMathFunctions_asin);
-        TEST_CASE(simplifyMathFunctions_asinh);
-        TEST_CASE(simplifyMathFunctions_tan);
-        TEST_CASE(simplifyMathFunctions_tanh);
-        TEST_CASE(simplifyMathFunctions_atan);
-        TEST_CASE(simplifyMathFunctions_atanh);
-        TEST_CASE(simplifyMathFunctions_expm1);
-        TEST_CASE(simplifyMathExpressions); //ticket #1620
-
-        // foo(p = new char[10]);  =>  p = new char[10]; foo(p);
-        TEST_CASE(simplifyAssignmentInFunctionCall);
-
-        // ";a+=b;" => ";a=a+b;"
-        TEST_CASE(simplifyCompoundAssignment);
-
-        TEST_CASE(cast);
-        TEST_CASE(iftruefalse);
+    const Settings settings0 = settingsBuilder().severity(Severity::portability).build();
+    const Settings settings1 = settingsBuilder().severity(Severity::style).build();
+    const Settings settings_std = settingsBuilder().library("std.cfg").build();
+    const Settings settings_windows = settingsBuilder().library("windows.cfg").severity(Severity::portability).build();
+
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(combine_strings);
+        TEST_CASE(combine_wstrings);
+        TEST_CASE(combine_ustrings);
+        TEST_CASE(combine_Ustrings);
+        TEST_CASE(combine_u8strings);
+        TEST_CASE(combine_mixedstrings);
+
         TEST_CASE(double_plus);
         TEST_CASE(redundant_plus);
         TEST_CASE(redundant_plus_numbers);
-        TEST_CASE(parentheses1);
-        TEST_CASE(parenthesesVar);      // Remove redundant parentheses around variable .. "( %name% )"
         TEST_CASE(declareVar);
 
         TEST_CASE(declareArray);
 
         TEST_CASE(dontRemoveIncrement);
-        TEST_CASE(removePostIncrement);
-        TEST_CASE(removePreIncrement);
 
         TEST_CASE(elseif1);
 
-        TEST_CASE(sizeof_array);
-        TEST_CASE(sizeof5);
-        TEST_CASE(sizeof6);
-        TEST_CASE(sizeof7);
-        TEST_CASE(sizeof8);
-        TEST_CASE(sizeof9);
-        TEST_CASE(sizeof10);
-        TEST_CASE(sizeof11);
-        TEST_CASE(sizeof12);
-        TEST_CASE(sizeof13);
-        TEST_CASE(sizeof14);
-        TEST_CASE(sizeof15);
-        TEST_CASE(sizeof16);
-        TEST_CASE(sizeof17);
-        TEST_CASE(sizeof18);
-        TEST_CASE(sizeof19);    // #1891 - sizeof 'x'
-        TEST_CASE(sizeof20);    // #2024 - sizeof a)
-        TEST_CASE(sizeof21);    // #2232 - sizeof...(Args)
-        TEST_CASE(sizeof22);
-        TEST_CASE(sizeofsizeof);
-        TEST_CASE(casting);
-
-        TEST_CASE(strlen1);
-        TEST_CASE(strlen2);
-
         TEST_CASE(namespaces);
 
-        // Assignment in condition..
-        TEST_CASE(ifassign1);
-        TEST_CASE(ifAssignWithCast);
-        TEST_CASE(whileAssign1);
-        TEST_CASE(whileAssign2);
-        TEST_CASE(whileAssign3); // varid
-        TEST_CASE(whileAssign4); // links
-        TEST_CASE(doWhileAssign); // varid
-        TEST_CASE(test_4881); // similar to doWhileAssign (#4911), taken from #4881 with full code
-
-        TEST_CASE(combine_wstrings);
-        TEST_CASE(combine_ustrings);
-        TEST_CASE(combine_Ustrings);
-        TEST_CASE(combine_u8strings);
-
         // Simplify "not" to "!" (#345)
         TEST_CASE(not1);
 
@@ -160,62 +72,14 @@ class TestSimplifyTokens : public TestFixture {
         TEST_CASE(cAlternativeTokens);
 
         TEST_CASE(comma_keyword);
-        TEST_CASE(remove_comma);
-
-        // Simplify "?:"
-        TEST_CASE(simplifyConditionOperator);
-
-        // Simplify calculations
-        TEST_CASE(calculations);
-        TEST_CASE(comparisons);
-
-        //remove dead code after flow control statements
-        TEST_CASE(simplifyFlowControl);
-        TEST_CASE(flowControl);
-
-        // Simplify nested strcat() calls
-        TEST_CASE(strcat1);
-        TEST_CASE(strcat2);
-
-        TEST_CASE(simplifyAtol)
 
         TEST_CASE(simplifyOperator1);
         TEST_CASE(simplifyOperator2);
 
-        TEST_CASE(simplifyArrayAccessSyntax)
-        TEST_CASE(simplify_numeric_condition)
-        TEST_CASE(simplify_condition);
+        TEST_CASE(simplifyArrayAccessSyntax);
 
         TEST_CASE(pointeralias1);
-        TEST_CASE(pointeralias2);
         TEST_CASE(pointeralias3);
-        TEST_CASE(pointeralias4);
-
-        // simplify "while (0)"
-        TEST_CASE(while0);
-        // ticket #3140
-        TEST_CASE(while0for);
-        TEST_CASE(while1);
-
-        TEST_CASE(duplicateDefinition); // ticket #3565
-
-        // remove "std::" on some standard functions
-        TEST_CASE(removestd);
-
-        // Tokenizer::simplifyInitVar
-        TEST_CASE(simplifyInitVar);
-
-        // Tokenizer::simplifyReference
-        TEST_CASE(simplifyReference);
-
-        // x = realloc(y,0);  =>  free(y);x=0;
-        TEST_CASE(simplifyRealloc);
-
-        // while(f() && errno==EINTR) { } => while (f()) { }
-        TEST_CASE(simplifyErrNoInWhile);
-
-        // while(fclose(f)); => r = fclose(f); while(r){r=fclose(f);}
-        TEST_CASE(simplifyFuncInWhile);
 
         // struct ABC { } abc; => struct ABC { }; ABC abc;
         TEST_CASE(simplifyStructDecl1);
@@ -225,6 +89,7 @@ class TestSimplifyTokens : public TestFixture {
         TEST_CASE(simplifyStructDecl6); // ticket #3732
         TEST_CASE(simplifyStructDecl7); // ticket #476 (static anonymous struct array)
         TEST_CASE(simplifyStructDecl8); // ticket #7698
+        TEST_CASE(simplifyStructDecl9);
 
         // register int var; => int var;
         // inline int foo() {} => int foo() {}
@@ -233,1685 +98,260 @@ class TestSimplifyTokens : public TestFixture {
         // remove calling convention __cdecl, __stdcall, ...
         TEST_CASE(simplifyCallingConvention);
 
+        // remove __attribute, __attribute__
+        TEST_CASE(simplifyAttribute);
+
         TEST_CASE(simplifyFunctorCall);
 
         TEST_CASE(simplifyFunctionPointer); // ticket #5339 (simplify function pointer after comma)
 
-        TEST_CASE(redundant_semicolon);
-
         TEST_CASE(simplifyFunctionReturn);
 
-        // void foo(void) -> void foo()
-        TEST_CASE(removeVoidFromFunction);
-
-        TEST_CASE(return_strncat); // ticket # 2860 Returning value of strncat() reported as memory leak
-
-        // #3069 : for loop with 1 iteration
-        // for (x=0;x<1;x++) { .. }
-        // The for is redundant
-        TEST_CASE(removeRedundantFor);
-
         TEST_CASE(consecutiveBraces);
 
-        TEST_CASE(undefinedSizeArray);
-
-        TEST_CASE(simplifyArrayAddress);  // Replace "&str[num]" => "(str + num)"
-        TEST_CASE(simplifyCharAt);
         TEST_CASE(simplifyOverride); // ticket #5069
         TEST_CASE(simplifyNestedNamespace);
-        TEST_CASE(simplifyNamespaceAliases);
-    }
-
-    std::string tok(const char code[], bool simplify = true, Settings::PlatformType type = Settings::Native) {
-        errout.str("");
-
-        settings0.platform(type);
-        Tokenizer tokenizer(&settings0, this);
-
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-
-        if (simplify)
-            tokenizer.simplifyTokenList2();
-
-        return tokenizer.tokens()->stringifyList(nullptr, !simplify);
-    }
-
-    std::string tokWithWindows(const char code[], bool simplify = true, Settings::PlatformType type = Settings::Native) {
-        errout.str("");
-
-        settings_windows.platform(type);
-        Tokenizer tokenizer(&settings_windows, this);
-
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-
-        if (simplify)
-            tokenizer.simplifyTokenList2();
-
-        return tokenizer.tokens()->stringifyList(nullptr, !simplify);
-    }
-
-    std::string tok(const char code[], const char filename[], bool simplify = true) {
-        errout.str("");
-
-        Tokenizer tokenizer(&settings0, this);
-
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, filename);
-        if (simplify)
-            tokenizer.simplifyTokenList2();
+        TEST_CASE(simplifyNamespaceAliases1);
+        TEST_CASE(simplifyNamespaceAliases2); // ticket #10281
+        TEST_CASE(simplifyNamespaceAliases3);
+
+        TEST_CASE(simplifyKnownVariables2);
+        TEST_CASE(simplifyKnownVariables3);
+        TEST_CASE(simplifyKnownVariables4);
+        TEST_CASE(simplifyKnownVariables5);
+        TEST_CASE(simplifyKnownVariables13);
+        TEST_CASE(simplifyKnownVariables14);
+        TEST_CASE(simplifyKnownVariables16);
+        TEST_CASE(simplifyKnownVariables17);
+        TEST_CASE(simplifyKnownVariables18);
+        TEST_CASE(simplifyKnownVariables19);
+        TEST_CASE(simplifyKnownVariables21);
+        TEST_CASE(simplifyKnownVariables25);
+        // FIXME Does expression id handle these? TEST_CASE(simplifyKnownVariables29);    // ticket #1811
+        TEST_CASE(simplifyKnownVariables30);
+        TEST_CASE(simplifyKnownVariables34);
+        TEST_CASE(simplifyKnownVariables36);    // ticket #5972
+        TEST_CASE(simplifyKnownVariables42);    // ticket #2031 - known string value after strcpy
+        TEST_CASE(simplifyKnownVariables43);
+        TEST_CASE(simplifyKnownVariables44);    // ticket #3117 - don't simplify static variables
+        TEST_CASE(simplifyKnownVariables46);    // ticket #3587 - >>
+        TEST_CASE(simplifyKnownVariables47);    // ticket #3627 - >>
+        TEST_CASE(simplifyKnownVariables48);    // ticket #3754 - wrong simplification in for loop header
+        TEST_CASE(simplifyKnownVariables49);    // #3691 - continue in switch
+        TEST_CASE(simplifyKnownVariables50);    // #4066 sprintf changes
+        TEST_CASE(simplifyKnownVariables51);    // #4409 hang
+        TEST_CASE(simplifyKnownVariables54);    // #4913 'x' is not 0 after *--x=0;
+        TEST_CASE(simplifyKnownVariables56);    // ticket #5301 - >>
+        TEST_CASE(simplifyKnownVariables58);    // ticket #5268
+        TEST_CASE(simplifyKnownVariables59);    // skip for header
+        TEST_CASE(simplifyKnownVariables61);    // #7805
+        TEST_CASE(simplifyKnownVariables62);    // #5666 - p=&str[0]
+        TEST_CASE(simplifyKnownVariables63);    // #10798
+        TEST_CASE(simplifyKnownVariablesBailOutAssign1);
+        TEST_CASE(simplifyKnownVariablesBailOutAssign2);
+        TEST_CASE(simplifyKnownVariablesBailOutFor1);
+        TEST_CASE(simplifyKnownVariablesBailOutFor2);
+        TEST_CASE(simplifyKnownVariablesBailOutFor3);
+        TEST_CASE(simplifyKnownVariablesBailOutMemberFunction);
+        TEST_CASE(simplifyKnownVariablesBailOutConditionalIncrement);
+        TEST_CASE(simplifyKnownVariablesBailOutSwitchBreak); // ticket #2324
+        TEST_CASE(simplifyKnownVariablesClassMember);  // #2815 - value of class member may be changed by function call
+        TEST_CASE(simplifyKnownVariablesFunctionCalls); // Function calls (don't assume pass by reference)
+        TEST_CASE(simplifyKnownVariablesGlobalVars);
+        TEST_CASE(simplifyKnownVariablesNamespace); // #10059
+
+        TEST_CASE(simplify_constants6);     // Ticket #5625: Ternary operator as template parameter
+        TEST_CASE(simplifyVarDeclInitLists);
+    }
+
+    struct TokOptions
+    {
+        bool cpp = true;
+        Platform::Type type = Platform::Type::Native;
+    };
+
+#define tok(...) tok_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    std::string tok_(const char* file, int line, const char (&code)[size], const TokOptions& options = make_default_obj()) {
+        const Settings settings = settingsBuilder(settings0).platform(options.type).build();
+        SimpleTokenizer tokenizer(settings, *this, options.cpp);
+
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         return tokenizer.tokens()->stringifyList(nullptr, false);
     }
 
-    std::string tokWithNewlines(const char code[]) {
-        errout.str("");
-
-        Tokenizer tokenizer(&settings0, this);
-
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        tokenizer.simplifyTokenList2();
-
-        return tokenizer.tokens()->stringifyList(false, false, false, true, false);
-    }
-
-    std::string tokWithStdLib(const char code[]) {
-        errout.str("");
+    struct TokenizeAndStringifyOptions
+    {
+        Platform::Type platform = Platform::Type::Native;
+        bool cpp = true;
+    };
 
-        Tokenizer tokenizer(&settings_std, this);
+#define tokenizeAndStringify(...) tokenizeAndStringify_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    std::string tokenizeAndStringify_(const char* file, int linenr, const char (&code)[size], const TokenizeAndStringifyOptions& options = make_default_obj()) {
+        const Settings settings = settingsBuilder(settings1).debugwarnings().platform(options.platform).cpp(Standards::CPP03).build();
 
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-        tokenizer.simplifyTokenList2();
+        // tokenize..
+        SimpleTokenizer tokenizer(settings, *this, options.cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, linenr);
 
-        return tokenizer.tokens()->stringifyList(nullptr, false);
+        if (tokenizer.tokens())
+            return tokenizer.tokens()->stringifyList(false, true, false, true, false, nullptr, nullptr);
+        return "";
     }
 
-    std::string tokenizeDebugListing(const char code[], bool simplify = false, const char filename[] = "test.cpp") {
-        errout.str("");
-
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, filename);
-
-        if (simplify)
-            tokenizer.simplifyTokenList2();
+#define tokenizeDebugListing(...) tokenizeDebugListing_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    std::string tokenizeDebugListing_(const char* file, int line, const char (&code)[size]) {
+        SimpleTokenizer tokenizer(settings0, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // result..
         return tokenizer.tokens()->stringifyList(true);
     }
 
-    void simplifyTokenList1() {
-        // #1717 : The simplifyErrNoInWhile needs to be used before simplifyIfAndWhileAssign..
-        ASSERT_EQUALS("; x = f ( ) ; while ( x == -1 ) { x = f ( ) ; }",
-                      tok(";while((x=f())==-1 && errno==EINTR){}",true));
-    }
-
-
-    void simplifyMathFunctions_erfc() {
-        // verify erfc(), erfcf(), erfcl() - simplifcation
-        const char code_erfc[] ="void f(int x) {\n"
-                                " std::cout << erfc(x);\n" // do not simplify
-                                " std::cout << erfc(0L);\n" // simplify to 1
-                                "}";
-        const char expected_erfc[] = "void f ( int x ) {\n"
-                                     "std :: cout << erfc ( x ) ;\n"
-                                     "std :: cout << 1 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_erfc, tokWithNewlines(code_erfc));
-
-        const char code_erfcf[] ="void f(float x) {\n"
-                                 " std::cout << erfcf(x);\n" // do not simplify
-                                 " std::cout << erfcf(0.0f);\n" // simplify to 1
-                                 "}";
-        const char expected_erfcf[] = "void f ( float x ) {\n"
-                                      "std :: cout << erfcf ( x ) ;\n"
-                                      "std :: cout << 1 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_erfcf, tokWithNewlines(code_erfcf));
-
-        const char code_erfcl[] ="void f(long double x) {\n"
-                                 " std::cout << erfcl(x);\n" // do not simplify
-                                 " std::cout << erfcl(0.0f);\n" // simplify to 1
-                                 "}";
-        const char expected_erfcl[] = "void f ( double x ) {\n"
-                                      "std :: cout << erfcl ( x ) ;\n"
-                                      "std :: cout << 1 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_erfcl, tokWithNewlines(code_erfcl));
-    }
-
-    void simplifyMathFunctions_cos() {
-        // verify cos(), cosf(), cosl() - simplifcation
-        const char code_cos[] ="void f(int x) {\n"
-                               " std::cout << cos(x);\n" // do not simplify
-                               " std::cout << cos(0L);\n" // simplify to 1
-                               "}";
-        const char expected_cos[] = "void f ( int x ) {\n"
-                                    "std :: cout << cos ( x ) ;\n"
-                                    "std :: cout << 1 ;\n"
-                                    "}";
-        ASSERT_EQUALS(expected_cos, tokWithNewlines(code_cos));
-
-        const char code_cosf[] ="void f(float x) {\n"
-                                " std::cout << cosf(x);\n" // do not simplify
-                                " std::cout << cosf(0.0f);\n" // simplify to 1
-                                "}";
-        const char expected_cosf[] = "void f ( float x ) {\n"
-                                     "std :: cout << cosf ( x ) ;\n"
-                                     "std :: cout << 1 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_cosf, tokWithNewlines(code_cosf));
-
-        const char code_cosl[] ="void f(long double x) {\n"
-                                " std::cout << cosl(x);\n" // do not simplify
-                                " std::cout << cosl(0.0f);\n" // simplify to 1
-                                "}";
-        const char expected_cosl[] = "void f ( double x ) {\n"
-                                     "std :: cout << cosl ( x ) ;\n"
-                                     "std :: cout << 1 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_cosl, tokWithNewlines(code_cosl));
-    }
-
-    void simplifyMathFunctions_cosh() {
-        // verify cosh(), coshf(), coshl() - simplifcation
-        const char code_cosh[] ="void f(int x) {\n"
-                                " std::cout << cosh(x);\n" // do not simplify
-                                " std::cout << cosh(0L);\n" // simplify to 1
-                                "}";
-        const char expected_cosh[] = "void f ( int x ) {\n"
-                                     "std :: cout << cosh ( x ) ;\n"
-                                     "std :: cout << 1 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_cosh, tokWithNewlines(code_cosh));
-
-        const char code_coshf[] ="void f(float x) {\n"
-                                 " std::cout << coshf(x);\n" // do not simplify
-                                 " std::cout << coshf(0.0f);\n" // simplify to 1
-                                 "}";
-        const char expected_coshf[] = "void f ( float x ) {\n"
-                                      "std :: cout << coshf ( x ) ;\n"
-                                      "std :: cout << 1 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_coshf, tokWithNewlines(code_coshf));
-
-        const char code_coshl[] ="void f(long double x) {\n"
-                                 " std::cout << coshl(x);\n" // do not simplify
-                                 " std::cout << coshl(0.0f);\n" // simplify to 1
-                                 "}";
-        const char expected_coshl[] = "void f ( double x ) {\n"
-                                      "std :: cout << coshl ( x ) ;\n"
-                                      "std :: cout << 1 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_coshl, tokWithNewlines(code_coshl));
-    }
-
-    void simplifyMathFunctions_acos() {
-        // verify acos(), acosf(), acosl() - simplifcation
-        const char code_acos[] ="void f(int x) {\n"
-                                " std::cout << acos(x);\n" // do not simplify
-                                " std::cout << acos(1L);\n" // simplify to 0
-                                "}";
-        const char expected_acos[] = "void f ( int x ) {\n"
-                                     "std :: cout << acos ( x ) ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_acos, tokWithNewlines(code_acos));
-
-        const char code_acosf[] ="void f(float x) {\n"
-                                 " std::cout << acosf(x);\n" // do not simplify
-                                 " std::cout << acosf(1.0f);\n" // simplify to 0
-                                 "}";
-        const char expected_acosf[] = "void f ( float x ) {\n"
-                                      "std :: cout << acosf ( x ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_acosf, tokWithNewlines(code_acosf));
-
-        const char code_acosl[] ="void f(long double x) {\n"
-                                 " std::cout << acosl(x);\n" // do not simplify
-                                 " std::cout << acosl(1.0f);\n" // simplify to 0
-                                 "}";
-        const char expected_acosl[] = "void f ( double x ) {\n"
-                                      "std :: cout << acosl ( x ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_acosl, tokWithNewlines(code_acosl));
-    }
-
-    void simplifyMathFunctions_acosh() {
-        // verify acosh(), acoshf(), acoshl() - simplifcation
-        const char code_acosh[] ="void f(int x) {\n"
-                                 " std::cout << acosh(x);\n" // do not simplify
-                                 " std::cout << acosh(1L);\n" // simplify to 0
-                                 "}";
-        const char expected_acosh[] = "void f ( int x ) {\n"
-                                      "std :: cout << acosh ( x ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_acosh, tokWithNewlines(code_acosh));
-
-        const char code_acoshf[] ="void f(float x) {\n"
-                                  " std::cout << acoshf(x);\n" // do not simplify
-                                  " std::cout << acoshf(1.0f);\n" // simplify to 0
-                                  "}";
-        const char expected_acoshf[] = "void f ( float x ) {\n"
-                                       "std :: cout << acoshf ( x ) ;\n"
-                                       "std :: cout << 0 ;\n"
-                                       "}";
-        ASSERT_EQUALS(expected_acoshf, tokWithNewlines(code_acoshf));
-
-        const char code_acoshl[] ="void f(long double x) {\n"
-                                  " std::cout << acoshl(x);\n" // do not simplify
-                                  " std::cout << acoshl(1.0f);\n" // simplify to 0
-                                  "}";
-        const char expected_acoshl[] = "void f ( double x ) {\n"
-                                       "std :: cout << acoshl ( x ) ;\n"
-                                       "std :: cout << 0 ;\n"
-                                       "}";
-        ASSERT_EQUALS(expected_acoshl, tokWithNewlines(code_acoshl));
-    }
-
-    void simplifyMathFunctions_sqrt() {
-        // verify sqrt(), sqrtf(), sqrtl() - simplifcation
-        const char code_sqrt[] ="void f(int x) {\n"
-                                " std::cout << sqrt(x);\n" // do not simplify
-                                " std::cout << sqrt(-1);\n" // do not simplify
-                                " std::cout << sqrt(0L);\n" // simplify to 0
-                                " std::cout << sqrt(1L);\n" // simplify to 1
-                                "}";
-        const char expected_sqrt[] = "void f ( int x ) {\n"
-                                     "std :: cout << sqrt ( x ) ;\n"
-                                     "std :: cout << sqrt ( -1 ) ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "std :: cout << 1 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_sqrt, tokWithNewlines(code_sqrt));
-
-        const char code_sqrtf[] ="void f(float x) {\n"
-                                 " std::cout << sqrtf(x);\n" // do not simplify
-                                 " std::cout << sqrtf(-1.0f);\n" // do not simplify
-                                 " std::cout << sqrtf(0.0f);\n" // simplify to 0
-                                 " std::cout << sqrtf(1.0);\n" // simplify to 1
-                                 "}";
-        const char expected_sqrtf[] = "void f ( float x ) {\n"
-                                      "std :: cout << sqrtf ( x ) ;\n"
-                                      "std :: cout << sqrtf ( -1.0f ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "std :: cout << 1 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_sqrtf, tokWithNewlines(code_sqrtf));
-
-        const char code_sqrtl[] ="void f(long double x) {\n"
-                                 " std::cout << sqrtf(x);\n" // do not simplify
-                                 " std::cout << sqrtf(-1.0);\n" // do not simplify
-                                 " std::cout << sqrtf(0.0);\n" // simplify to 0
-                                 " std::cout << sqrtf(1.0);\n" // simplify to 1
-                                 "}";
-        const char expected_sqrtl[] = "void f ( double x ) {\n"
-                                      "std :: cout << sqrtf ( x ) ;\n"
-                                      "std :: cout << sqrtf ( -1.0 ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "std :: cout << 1 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_sqrtl, tokWithNewlines(code_sqrtl));
-    }
-
-    void simplifyMathFunctions_cbrt() {
-        // verify cbrt(), cbrtf(), cbrtl() - simplifcation
-        const char code_cbrt[] ="void f(int x) {\n"
-                                " std::cout << cbrt(x);\n" // do not simplify
-                                " std::cout << cbrt(-1);\n" // do not simplify
-                                " std::cout << cbrt(0L);\n" // simplify to 0
-                                " std::cout << cbrt(1L);\n" // simplify to 1
-                                "}";
-        const char expected_cbrt[] = "void f ( int x ) {\n"
-                                     "std :: cout << cbrt ( x ) ;\n"
-                                     "std :: cout << cbrt ( -1 ) ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "std :: cout << 1 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_cbrt, tokWithNewlines(code_cbrt));
-
-        const char code_cbrtf[] ="void f(float x) {\n"
-                                 " std::cout << cbrtf(x);\n" // do not simplify
-                                 " std::cout << cbrtf(-1.0f);\n" // do not simplify
-                                 " std::cout << cbrtf(0.0f);\n" // simplify to 0
-                                 " std::cout << cbrtf(1.0);\n" // simplify to 1
-                                 "}";
-        const char expected_cbrtf[] = "void f ( float x ) {\n"
-                                      "std :: cout << cbrtf ( x ) ;\n"
-                                      "std :: cout << cbrtf ( -1.0f ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "std :: cout << 1 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_cbrtf, tokWithNewlines(code_cbrtf));
-
-        const char code_cbrtl[] ="void f(long double x) {\n"
-                                 " std::cout << cbrtl(x);\n" // do not simplify
-                                 " std::cout << cbrtl(-1.0);\n" // do not simplify
-                                 " std::cout << cbrtl(0.0);\n" // simplify to 0
-                                 " std::cout << cbrtl(1.0);\n" // simplify to 1
-                                 "}";
-        const char expected_cbrtl[] = "void f ( double x ) {\n"
-                                      "std :: cout << cbrtl ( x ) ;\n"
-                                      "std :: cout << cbrtl ( -1.0 ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "std :: cout << 1 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_cbrtl, tokWithNewlines(code_cbrtl));
-    }
-
-    void simplifyMathFunctions_exp2() {
-        // verify exp2(), exp2f(), exp2l() - simplifcation
-        const char code_exp2[] ="void f(int x) {\n"
-                                " std::cout << exp2(x);\n" // do not simplify
-                                " std::cout << exp2(-1);\n" // do not simplify
-                                " std::cout << exp2(0L);\n" // simplify to 0
-                                " std::cout << exp2(1L);\n" // do not simplify
-                                "}";
-        const char expected_exp2[] = "void f ( int x ) {\n"
-                                     "std :: cout << exp2 ( x ) ;\n"
-                                     "std :: cout << exp2 ( -1 ) ;\n"
-                                     "std :: cout << 1 ;\n"
-                                     "std :: cout << exp2 ( 1L ) ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_exp2, tokWithNewlines(code_exp2));
-
-        const char code_exp2f[] ="void f(float x) {\n"
-                                 " std::cout << exp2f(x);\n" // do not simplify
-                                 " std::cout << exp2f(-1.0);\n" // do not simplify
-                                 " std::cout << exp2f(0.0);\n" // simplify to 1
-                                 " std::cout << exp2f(1.0);\n" // do not simplify
-                                 "}";
-        const char expected_exp2f[] = "void f ( float x ) {\n"
-                                      "std :: cout << exp2f ( x ) ;\n"
-                                      "std :: cout << exp2f ( -1.0 ) ;\n"
-                                      "std :: cout << 1 ;\n"
-                                      "std :: cout << exp2f ( 1.0 ) ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_exp2f, tokWithNewlines(code_exp2f));
-
-        const char code_exp2l[] ="void f(long double x) {\n"
-                                 " std::cout << exp2l(x);\n" // do not simplify
-                                 " std::cout << exp2l(-1.0);\n" // do not simplify
-                                 " std::cout << exp2l(0.0);\n" // simplify to 1
-                                 " std::cout << exp2l(1.0);\n" // do not simplify
-                                 "}";
-        const char expected_exp2l[] = "void f ( double x ) {\n"
-                                      "std :: cout << exp2l ( x ) ;\n"
-                                      "std :: cout << exp2l ( -1.0 ) ;\n"
-                                      "std :: cout << 1 ;\n"
-                                      "std :: cout << exp2l ( 1.0 ) ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_exp2l, tokWithNewlines(code_exp2l));
-    }
-
-    void simplifyMathFunctions_exp() {
-        // verify exp(), expf(), expl() - simplifcation
-        const char code_exp[] ="void f(int x) {\n"
-                               " std::cout << exp(x);\n" // do not simplify
-                               " std::cout << exp(-1);\n" // do not simplify
-                               " std::cout << exp(0L);\n" // simplify to 1
-                               " std::cout << exp(1L);\n" // do not simplify
-                               "}";
-        const char expected_exp[] = "void f ( int x ) {\n"
-                                    "std :: cout << exp ( x ) ;\n"
-                                    "std :: cout << exp ( -1 ) ;\n"
-                                    "std :: cout << 1 ;\n"
-                                    "std :: cout << exp ( 1L ) ;\n"
-                                    "}";
-        ASSERT_EQUALS(expected_exp, tokWithNewlines(code_exp));
-
-        const char code_expf[] ="void f(float x) {\n"
-                                " std::cout << expf(x);\n" // do not simplify
-                                " std::cout << expf(-1.0);\n" // do not simplify
-                                " std::cout << expf(0.0);\n" // simplify to 1
-                                " std::cout << expf(1.0);\n" // do not simplify
-                                "}";
-        const char expected_expf[] = "void f ( float x ) {\n"
-                                     "std :: cout << expf ( x ) ;\n"
-                                     "std :: cout << expf ( -1.0 ) ;\n"
-                                     "std :: cout << 1 ;\n"
-                                     "std :: cout << expf ( 1.0 ) ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_expf, tokWithNewlines(code_expf));
-
-        const char code_expl[] ="void f(long double x) {\n"
-                                " std::cout << expl(x);\n" // do not simplify
-                                " std::cout << expl(-1.0);\n" // do not simplify
-                                " std::cout << expl(0.0);\n" // simplify to 1
-                                " std::cout << expl(1.0);\n" // do not simplify
-                                "}";
-        const char expected_expl[] = "void f ( double x ) {\n"
-                                     "std :: cout << expl ( x ) ;\n"
-                                     "std :: cout << expl ( -1.0 ) ;\n"
-                                     "std :: cout << 1 ;\n"
-                                     "std :: cout << expl ( 1.0 ) ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_expl, tokWithNewlines(code_expl));
-    }
-
-    void simplifyMathFunctions_erf() {
-        // verify erf(), erff(), erfl() - simplifcation
-        const char code_erf[] ="void f(int x) {\n"
-                               " std::cout << erf(x);\n" // do not simplify
-                               " std::cout << erf(10);\n" // do not simplify
-                               " std::cout << erf(0L);\n" // simplify to 0
-                               "}";
-        const char expected_erf[] = "void f ( int x ) {\n"
-                                    "std :: cout << erf ( x ) ;\n"
-                                    "std :: cout << erf ( 10 ) ;\n"
-                                    "std :: cout << 0 ;\n"
-                                    "}";
-        ASSERT_EQUALS(expected_erf, tokWithNewlines(code_erf));
-
-        const char code_erff[] ="void f(float x) {\n"
-                                " std::cout << erff(x);\n" // do not simplify
-                                " std::cout << erff(10);\n" // do not simplify
-                                " std::cout << erff(0.0f);\n" // simplify to 0
-                                "}";
-        const char expected_erff[] = "void f ( float x ) {\n"
-                                     "std :: cout << erff ( x ) ;\n"
-                                     "std :: cout << erff ( 10 ) ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_erff, tokWithNewlines(code_erff));
-
-        const char code_erfl[] ="void f(long double x) {\n"
-                                " std::cout << erfl(x);\n" // do not simplify
-                                " std::cout << erfl(10.0f);\n" // do not simplify
-                                " std::cout << erfl(0.0f);\n" // simplify to 0
-                                "}";
-        const char expected_erfl[] = "void f ( double x ) {\n"
-                                     "std :: cout << erfl ( x ) ;\n"
-                                     "std :: cout << erfl ( 10.0f ) ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_erfl, tokWithNewlines(code_erfl));
-    }
-
-    void simplifyMathFunctions_atanh() {
-        // verify atanh(), atanhf(), atanhl() - simplifcation
-        const char code_atanh[] ="void f(int x) {\n"
-                                 " std::cout << atanh(x);\n" // do not simplify
-                                 " std::cout << atanh(10);\n" // do not simplify
-                                 " std::cout << atanh(0L);\n" // simplify to 0
-                                 "}";
-        const char expected_atanh[] = "void f ( int x ) {\n"
-                                      "std :: cout << atanh ( x ) ;\n"
-                                      "std :: cout << atanh ( 10 ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_atanh, tokWithNewlines(code_atanh));
-
-        const char code_atanhf[] ="void f(float x) {\n"
-                                  " std::cout << atanhf(x);\n" // do not simplify
-                                  " std::cout << atanhf(10);\n" // do not simplify
-                                  " std::cout << atanhf(0.0f);\n" // simplify to 0
-                                  "}";
-        const char expected_atanhf[] = "void f ( float x ) {\n"
-                                       "std :: cout << atanhf ( x ) ;\n"
-                                       "std :: cout << atanhf ( 10 ) ;\n"
-                                       "std :: cout << 0 ;\n"
-                                       "}";
-        ASSERT_EQUALS(expected_atanhf, tokWithNewlines(code_atanhf));
-
-        const char code_atanhl[] ="void f(long double x) {\n"
-                                  " std::cout << atanhl(x);\n" // do not simplify
-                                  " std::cout << atanhl(10.0f);\n" // do not simplify
-                                  " std::cout << atanhl(0.0d);\n" // do not simplify - invalid number!
-                                  " std::cout << atanhl(0.0f);\n" // simplify to 0
-                                  "}";
-        const char expected_atanhl[] = "void f ( double x ) {\n"
-                                       "std :: cout << atanhl ( x ) ;\n"
-                                       "std :: cout << atanhl ( 10.0f ) ;\n"
-                                       "std :: cout << atanhl ( 0.0d ) ;\n"
-                                       "std :: cout << 0 ;\n"
-                                       "}";
-        ASSERT_EQUALS(expected_atanhl, tokWithNewlines(code_atanhl));
-    }
-
-    void simplifyMathFunctions_atan() {
-        // verify atan(), atanf(), atanl() - simplifcation
-        const char code_atan[] ="void f(int x) {\n"
-                                " std::cout << atan(x);\n" // do not simplify
-                                " std::cout << atan(10);\n" // do not simplify
-                                " std::cout << atan(0L);\n" // simplify to 0
-                                "}";
-        const char expected_atan[] = "void f ( int x ) {\n"
-                                     "std :: cout << atan ( x ) ;\n"
-                                     "std :: cout << atan ( 10 ) ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_atan, tokWithNewlines(code_atan));
-
-        const char code_atanf[] ="void f(float x) {\n"
-                                 " std::cout << atanf(x);\n" // do not simplify
-                                 " std::cout << atanf(10);\n" // do not simplify
-                                 " std::cout << atanf(0.0f);\n" // simplify to 0
-                                 "}";
-        const char expected_atanf[] = "void f ( float x ) {\n"
-                                      "std :: cout << atanf ( x ) ;\n"
-                                      "std :: cout << atanf ( 10 ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_atanf, tokWithNewlines(code_atanf));
-
-        const char code_atanl[] ="void f(long double x) {\n"
-                                 " std::cout << atanl(x);\n" // do not simplify
-                                 " std::cout << atanl(10.0f);\n" // do not simplify
-                                 " std::cout << atanl(0.0f);\n" // simplify to 0
-                                 "}";
-        const char expected_atanl[] = "void f ( double x ) {\n"
-                                      "std :: cout << atanl ( x ) ;\n"
-                                      "std :: cout << atanl ( 10.0f ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_atanl, tokWithNewlines(code_atanl));
-    }
-
-    void simplifyMathFunctions_tanh() {
-        // verify tanh(), tanhf(), tanhl() - simplifcation
-        const char code_tanh[] ="void f(int x) {\n"
-                                " std::cout << tanh(x);\n" // do not simplify
-                                " std::cout << tanh(10);\n" // do not simplify
-                                " std::cout << tanh(0L);\n" // simplify to 0
-                                "}";
-        const char expected_tanh[] = "void f ( int x ) {\n"
-                                     "std :: cout << tanh ( x ) ;\n"
-                                     "std :: cout << tanh ( 10 ) ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_tanh, tokWithNewlines(code_tanh));
-
-        const char code_tanhf[] ="void f(float x) {\n"
-                                 " std::cout << tanhf(x);\n" // do not simplify
-                                 " std::cout << tanhf(10);\n" // do not simplify
-                                 " std::cout << tanhf(0.0f);\n" // simplify to 0
-                                 "}";
-        const char expected_tanhf[] = "void f ( float x ) {\n"
-                                      "std :: cout << tanhf ( x ) ;\n"
-                                      "std :: cout << tanhf ( 10 ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_tanhf, tokWithNewlines(code_tanhf));
-
-        const char code_tanhl[] ="void f(long double x) {\n"
-                                 " std::cout << tanhl(x);\n" // do not simplify
-                                 " std::cout << tanhl(10.0f);\n" // do not simplify
-                                 " std::cout << tanhl(0.0f);\n" // simplify to 0
-                                 "}";
-        const char expected_tanhl[] = "void f ( double x ) {\n"
-                                      "std :: cout << tanhl ( x ) ;\n"
-                                      "std :: cout << tanhl ( 10.0f ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_tanhl, tokWithNewlines(code_tanhl));
-    }
-
-    void simplifyMathFunctions_tan() {
-        // verify tan(), tanf(), tanl() - simplifcation
-        const char code_tan[] ="void f(int x) {\n"
-                               " std::cout << tan(x);\n" // do not simplify
-                               " std::cout << tan(10);\n" // do not simplify
-                               " std::cout << tan(0L);\n" // simplify to 0
-                               "}";
-        const char expected_tan[] = "void f ( int x ) {\n"
-                                    "std :: cout << tan ( x ) ;\n"
-                                    "std :: cout << tan ( 10 ) ;\n"
-                                    "std :: cout << 0 ;\n"
-                                    "}";
-        ASSERT_EQUALS(expected_tan, tokWithNewlines(code_tan));
-
-        const char code_tanf[] ="void f(float x) {\n"
-                                " std::cout << tanf(x);\n" // do not simplify
-                                " std::cout << tanf(10);\n" // do not simplify
-                                " std::cout << tanf(0.0f);\n" // simplify to 0
-                                "}";
-        const char expected_tanf[] = "void f ( float x ) {\n"
-                                     "std :: cout << tanf ( x ) ;\n"
-                                     "std :: cout << tanf ( 10 ) ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_tanf, tokWithNewlines(code_tanf));
-
-        const char code_tanl[] ="void f(long double x) {\n"
-                                " std::cout << tanl(x);\n" // do not simplify
-                                " std::cout << tanl(10.0f);\n" // do not simplify
-                                " std::cout << tanl(0.0f);\n" // simplify to 0
-                                "}";
-        const char expected_tanl[] = "void f ( double x ) {\n"
-                                     "std :: cout << tanl ( x ) ;\n"
-                                     "std :: cout << tanl ( 10.0f ) ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_tanl, tokWithNewlines(code_tanl));
-    }
-
-    void simplifyMathFunctions_expm1() {
-        // verify expm1(), expm1f(), expm1l() - simplifcation
-        const char code_expm1[] ="void f(int x) {\n"
-                                 " std::cout << expm1(x);\n" // do not simplify
-                                 " std::cout << expm1(10);\n" // do not simplify
-                                 " std::cout << expm1(0L);\n" // simplify to 0
-                                 "}";
-        const char expected_expm1[] = "void f ( int x ) {\n"
-                                      "std :: cout << expm1 ( x ) ;\n"
-                                      "std :: cout << expm1 ( 10 ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_expm1, tokWithNewlines(code_expm1));
-
-        const char code_expm1f[] ="void f(float x) {\n"
-                                  " std::cout << expm1f(x);\n" // do not simplify
-                                  " std::cout << expm1f(10);\n" // do not simplify
-                                  " std::cout << expm1f(0.0f);\n" // simplify to 0
-                                  "}";
-        const char expected_expm1f[] = "void f ( float x ) {\n"
-                                       "std :: cout << expm1f ( x ) ;\n"
-                                       "std :: cout << expm1f ( 10 ) ;\n"
-                                       "std :: cout << 0 ;\n"
-                                       "}";
-        ASSERT_EQUALS(expected_expm1f, tokWithNewlines(code_expm1f));
-
-        const char code_expm1l[] ="void f(long double x) {\n"
-                                  " std::cout << expm1l(x);\n" // do not simplify
-                                  " std::cout << expm1l(10.0f);\n" // do not simplify
-                                  " std::cout << expm1l(0.0f);\n" // simplify to 0
-                                  "}";
-        const char expected_expm1l[] = "void f ( double x ) {\n"
-                                       "std :: cout << expm1l ( x ) ;\n"
-                                       "std :: cout << expm1l ( 10.0f ) ;\n"
-                                       "std :: cout << 0 ;\n"
-                                       "}";
-        ASSERT_EQUALS(expected_expm1l, tokWithNewlines(code_expm1l));
-    }
-
-    void simplifyMathFunctions_asinh() {
-        // verify asinh(), asinhf(), asinhl() - simplifcation
-        const char code_asinh[] ="void f(int x) {\n"
-                                 " std::cout << asinh(x);\n" // do not simplify
-                                 " std::cout << asinh(10);\n" // do not simplify
-                                 " std::cout << asinh(0L);\n" // simplify to 0
-                                 "}";
-        const char expected_asinh[] = "void f ( int x ) {\n"
-                                      "std :: cout << asinh ( x ) ;\n"
-                                      "std :: cout << asinh ( 10 ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_asinh, tokWithNewlines(code_asinh));
-
-        const char code_asinhf[] ="void f(float x) {\n"
-                                  " std::cout << asinhf(x);\n" // do not simplify
-                                  " std::cout << asinhf(10);\n" // do not simplify
-                                  " std::cout << asinhf(0.0f);\n" // simplify to 0
-                                  "}";
-        const char expected_asinhf[] = "void f ( float x ) {\n"
-                                       "std :: cout << asinhf ( x ) ;\n"
-                                       "std :: cout << asinhf ( 10 ) ;\n"
-                                       "std :: cout << 0 ;\n"
-                                       "}";
-        ASSERT_EQUALS(expected_asinhf, tokWithNewlines(code_asinhf));
-
-        const char code_asinhl[] ="void f(long double x) {\n"
-                                  " std::cout << asinhl(x);\n" // do not simplify
-                                  " std::cout << asinhl(10.0f);\n" // do not simplify
-                                  " std::cout << asinhl(0.0f);\n" // simplify to 0
-                                  "}";
-        const char expected_asinhl[] = "void f ( double x ) {\n"
-                                       "std :: cout << asinhl ( x ) ;\n"
-                                       "std :: cout << asinhl ( 10.0f ) ;\n"
-                                       "std :: cout << 0 ;\n"
-                                       "}";
-        ASSERT_EQUALS(expected_asinhl, tokWithNewlines(code_asinhl));
-    }
-
-    void simplifyMathFunctions_asin() {
-        // verify asin(), asinf(), asinl() - simplifcation
-        const char code_asin[] ="void f(int x) {\n"
-                                " std::cout << asin(x);\n" // do not simplify
-                                " std::cout << asin(10);\n" // do not simplify
-                                " std::cout << asin(0L);\n" // simplify to 0
-                                "}";
-        const char expected_asin[] = "void f ( int x ) {\n"
-                                     "std :: cout << asin ( x ) ;\n"
-                                     "std :: cout << asin ( 10 ) ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_asin, tokWithNewlines(code_asin));
-
-        const char code_asinf[] ="void f(float x) {\n"
-                                 " std::cout << asinf(x);\n" // do not simplify
-                                 " std::cout << asinf(10);\n" // do not simplify
-                                 " std::cout << asinf(0.0f);\n" // simplify to 0
-                                 "}";
-        const char expected_asinf[] = "void f ( float x ) {\n"
-                                      "std :: cout << asinf ( x ) ;\n"
-                                      "std :: cout << asinf ( 10 ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_asinf, tokWithNewlines(code_asinf));
-
-        const char code_asinl[] ="void f(long double x) {\n"
-                                 " std::cout << asinl(x);\n" // do not simplify
-                                 " std::cout << asinl(10.0f);\n" // do not simplify
-                                 " std::cout << asinl(0.0f);\n" // simplify to 0
-                                 "}";
-        const char expected_asinl[] = "void f ( double x ) {\n"
-                                      "std :: cout << asinl ( x ) ;\n"
-                                      "std :: cout << asinl ( 10.0f ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_asinl, tokWithNewlines(code_asinl));
-    }
-
-    void simplifyMathFunctions_sinh() {
-        // verify sinh(), sinhf(), sinhl() - simplifcation
-        const char code_sinh[] ="void f(int x) {\n"
-                                " std::cout << sinh(x);\n" // do not simplify
-                                " std::cout << sinh(10);\n" // do not simplify
-                                " std::cout << sinh(0L);\n" // simplify to 0
-                                "}";
-        const char expected_sinh[] = "void f ( int x ) {\n"
-                                     "std :: cout << sinh ( x ) ;\n"
-                                     "std :: cout << sinh ( 10 ) ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_sinh, tokWithNewlines(code_sinh));
-
-        const char code_sinhf[] ="void f(float x) {\n"
-                                 " std::cout << sinhf(x);\n" // do not simplify
-                                 " std::cout << sinhf(10);\n" // do not simplify
-                                 " std::cout << sinhf(0.0f);\n" // simplify to 0
-                                 "}";
-        const char expected_sinhf[] = "void f ( float x ) {\n"
-                                      "std :: cout << sinhf ( x ) ;\n"
-                                      "std :: cout << sinhf ( 10 ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_sinhf, tokWithNewlines(code_sinhf));
-
-        const char code_sinhl[] ="void f(long double x) {\n"
-                                 " std::cout << sinhl(x);\n" // do not simplify
-                                 " std::cout << sinhl(10.0f);\n" // do not simplify
-                                 " std::cout << sinhl(0.0f);\n" // simplify to 0
-                                 "}";
-        const char expected_sinhl[] = "void f ( double x ) {\n"
-                                      "std :: cout << sinhl ( x ) ;\n"
-                                      "std :: cout << sinhl ( 10.0f ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_sinhl, tokWithNewlines(code_sinhl));
-    }
-
-    void simplifyMathFunctions_sin() {
-        // verify sin(), sinf(), sinl() - simplifcation
-        const char code_sin[] ="void f(int x) {\n"
-                               " std::cout << sin(x);\n" // do not simplify
-                               " std::cout << sin(10);\n" // do not simplify
-                               " std::cout << sin(0L);\n" // simplify to 0
-                               "}";
-        const char expected_sin[] = "void f ( int x ) {\n"
-                                    "std :: cout << sin ( x ) ;\n"
-                                    "std :: cout << sin ( 10 ) ;\n"
-                                    "std :: cout << 0 ;\n"
-                                    "}";
-        ASSERT_EQUALS(expected_sin, tokWithNewlines(code_sin));
-
-        const char code_sinf[] ="void f(float x) {\n"
-                                " std::cout << sinf(x);\n" // do not simplify
-                                " std::cout << sinf(10);\n" // do not simplify
-                                " std::cout << sinf(0.0f);\n" // simplify to 0
-                                "}";
-        const char expected_sinf[] = "void f ( float x ) {\n"
-                                     "std :: cout << sinf ( x ) ;\n"
-                                     "std :: cout << sinf ( 10 ) ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_sinf, tokWithNewlines(code_sinf));
-
-        const char code_sinl[] ="void f(long double x) {\n"
-                                " std::cout << sinl(x);\n" // do not simplify
-                                " std::cout << sinl(10.0f);\n" // do not simplify
-                                " std::cout << sinl(0.0f);\n" // simplify to 0
-                                "}";
-        const char expected_sinl[] = "void f ( double x ) {\n"
-                                     "std :: cout << sinl ( x ) ;\n"
-                                     "std :: cout << sinl ( 10.0f ) ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_sinl, tokWithNewlines(code_sinl));
-
-        // #6629
-        const char code[] = "class Foo { int sinf; Foo() : sinf(0) {} };";
-        const char expected[] = "class Foo { int sinf ; Foo ( ) : sinf ( 0 ) { } } ;";
-        ASSERT_EQUALS(expected, tokWithNewlines(code));
-    }
-
-    void simplifyMathFunctions_ilogb() {
-        // verify ilogb(), ilogbf(), ilogbl() - simplifcation
-        const char code_ilogb[] ="void f(int x) {\n"
-                                 " std::cout << ilogb(x);\n" // do not simplify
-                                 " std::cout << ilogb(10);\n" // do not simplify
-                                 " std::cout << ilogb(1L);\n" // simplify to 0
-                                 "}";
-        const char expected_ilogb[] = "void f ( int x ) {\n"
-                                      "std :: cout << ilogb ( x ) ;\n"
-                                      "std :: cout << ilogb ( 10 ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_ilogb, tokWithNewlines(code_ilogb));
-
-        const char code_ilogbf[] ="void f(float x) {\n"
-                                  " std::cout << ilogbf(x);\n" // do not simplify
-                                  " std::cout << ilogbf(10);\n" // do not simplify
-                                  " std::cout << ilogbf(1.0f);\n" // simplify to 0
-                                  "}";
-        const char expected_ilogbf[] = "void f ( float x ) {\n"
-                                       "std :: cout << ilogbf ( x ) ;\n"
-                                       "std :: cout << ilogbf ( 10 ) ;\n"
-                                       "std :: cout << 0 ;\n"
-                                       "}";
-        ASSERT_EQUALS(expected_ilogbf, tokWithNewlines(code_ilogbf));
-
-        const char code_ilogbl[] ="void f(long double x) {\n"
-                                  " std::cout << ilogbl(x);\n" // do not simplify
-                                  " std::cout << ilogbl(10.0f);\n" // do not simplify
-                                  " std::cout << ilogbl(1.0f);\n" // simplify to 0
-                                  "}";
-        const char expected_ilogbl[] = "void f ( double x ) {\n"
-                                       "std :: cout << ilogbl ( x ) ;\n"
-                                       "std :: cout << ilogbl ( 10.0f ) ;\n"
-                                       "std :: cout << 0 ;\n"
-                                       "}";
-        ASSERT_EQUALS(expected_ilogbl, tokWithNewlines(code_ilogbl));
-    }
-
-    void simplifyMathFunctions_logb() {
-        // verify logb(), logbf(), logbl() - simplifcation
-        const char code_logb[] ="void f(int x) {\n"
-                                " std::cout << logb(x);\n" // do not simplify
-                                " std::cout << logb(10);\n" // do not simplify
-                                " std::cout << logb(1L);\n" // simplify to 0
-                                "}";
-        const char expected_logb[] = "void f ( int x ) {\n"
-                                     "std :: cout << logb ( x ) ;\n"
-                                     "std :: cout << logb ( 10 ) ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_logb, tokWithNewlines(code_logb));
-
-        const char code_logbf[] ="void f(float x) {\n"
-                                 " std::cout << logbf(x);\n" // do not simplify
-                                 " std::cout << logbf(10);\n" // do not simplify
-                                 " std::cout << logbf(1.0f);\n" // simplify to 0
-                                 "}";
-        const char expected_logbf[] = "void f ( float x ) {\n"
-                                      "std :: cout << logbf ( x ) ;\n"
-                                      "std :: cout << logbf ( 10 ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_logbf, tokWithNewlines(code_logbf));
-
-        const char code_logbl[] ="void f(long double x) {\n"
-                                 " std::cout << logbl(x);\n" // do not simplify
-                                 " std::cout << logbl(10.0f);\n" // do not simplify
-                                 " std::cout << logbl(1.0f);\n" // simplify to 0
-                                 "}";
-        const char expected_logbl[] = "void f ( double x ) {\n"
-                                      "std :: cout << logbl ( x ) ;\n"
-                                      "std :: cout << logbl ( 10.0f ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_logbl, tokWithNewlines(code_logbl));
-    }
-
-    void simplifyMathFunctions_log1p() {
-        // verify log1p(), log1pf(), log1pl() - simplifcation
-        const char code_log1p[] ="void f(int x) {\n"
-                                 " std::cout << log1p(x);\n" // do not simplify
-                                 " std::cout << log1p(10);\n" // do not simplify
-                                 " std::cout << log1p(0L);\n" // simplify to 0
-                                 "}";
-        const char expected_log1p[] = "void f ( int x ) {\n"
-                                      "std :: cout << log1p ( x ) ;\n"
-                                      "std :: cout << log1p ( 10 ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_log1p, tokWithNewlines(code_log1p));
-
-        const char code_log1pf[] ="void f(float x) {\n"
-                                  " std::cout << log1pf(x);\n" // do not simplify
-                                  " std::cout << log1pf(10);\n" // do not simplify
-                                  " std::cout << log1pf(0.0f);\n" // simplify to 0
-                                  "}";
-        const char expected_log1pf[] = "void f ( float x ) {\n"
-                                       "std :: cout << log1pf ( x ) ;\n"
-                                       "std :: cout << log1pf ( 10 ) ;\n"
-                                       "std :: cout << 0 ;\n"
-                                       "}";
-        ASSERT_EQUALS(expected_log1pf, tokWithNewlines(code_log1pf));
-
-        const char code_log1pl[] ="void f(long double x) {\n"
-                                  " std::cout << log1pl(x);\n" // do not simplify
-                                  " std::cout << log1pl(10.0f);\n" // do not simplify
-                                  " std::cout << log1pl(0.0f);\n" // simplify to 0
-                                  "}";
-        const char expected_log1pl[] = "void f ( double x ) {\n"
-                                       "std :: cout << log1pl ( x ) ;\n"
-                                       "std :: cout << log1pl ( 10.0f ) ;\n"
-                                       "std :: cout << 0 ;\n"
-                                       "}";
-        ASSERT_EQUALS(expected_log1pl, tokWithNewlines(code_log1pl));
-    }
-
-    void simplifyMathFunctions_log10() {
-        // verify log10(), log10f(), log10l() - simplifcation
-        const char code_log10[] ="void f(int x) {\n"
-                                 " std::cout << log10(x);\n" // do not simplify
-                                 " std::cout << log10(10);\n" // do not simplify
-                                 " std::cout << log10(1L);\n" // simplify to 0
-                                 "}";
-        const char expected_log10[] = "void f ( int x ) {\n"
-                                      "std :: cout << log10 ( x ) ;\n"
-                                      "std :: cout << log10 ( 10 ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_log10, tokWithNewlines(code_log10));
-
-        const char code_log10f[] ="void f(float x) {\n"
-                                  " std::cout << log10f(x);\n" // do not simplify
-                                  " std::cout << log10f(10);\n" // do not simplify
-                                  " std::cout << log10f(1.0f);\n" // simplify to 0
-                                  "}";
-        const char expected_log10f[] = "void f ( float x ) {\n"
-                                       "std :: cout << log10f ( x ) ;\n"
-                                       "std :: cout << log10f ( 10 ) ;\n"
-                                       "std :: cout << 0 ;\n"
-                                       "}";
-        ASSERT_EQUALS(expected_log10f, tokWithNewlines(code_log10f));
-
-        const char code_log10l[] ="void f(long double x) {\n"
-                                  " std::cout << log10l(x);\n" // do not simplify
-                                  " std::cout << log10l(10.0f);\n" // do not simplify
-                                  " std::cout << log10l(1.0f);\n" // simplify to 0
-                                  "}";
-        const char expected_log10l[] = "void f ( double x ) {\n"
-                                       "std :: cout << log10l ( x ) ;\n"
-                                       "std :: cout << log10l ( 10.0f ) ;\n"
-                                       "std :: cout << 0 ;\n"
-                                       "}";
-        ASSERT_EQUALS(expected_log10l, tokWithNewlines(code_log10l));
-
-    }
-    void simplifyMathFunctions_log() {
-        // verify log(), logf(), logl() - simplifcation
-        const char code_log[] ="void f(int x) {\n"
-                               " std::cout << log(x);\n" // do not simplify
-                               " std::cout << log(10);\n" // do not simplify
-                               " std::cout << log(1L);\n" // simplify to 0
-                               "}";
-        const char expected_log[] = "void f ( int x ) {\n"
-                                    "std :: cout << log ( x ) ;\n"
-                                    "std :: cout << log ( 10 ) ;\n"
-                                    "std :: cout << 0 ;\n"
-                                    "}";
-        ASSERT_EQUALS(expected_log, tokWithNewlines(code_log));
-
-        const char code_logf[] ="void f(float x) {\n"
-                                " std::cout << logf(x);\n" // do not simplify
-                                " std::cout << logf(10);\n" // do not simplify
-                                " std::cout << logf(1.0f);\n" // simplify to 0
-                                "}";
-        const char expected_logf[] = "void f ( float x ) {\n"
-                                     "std :: cout << logf ( x ) ;\n"
-                                     "std :: cout << logf ( 10 ) ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_logf, tokWithNewlines(code_logf));
-
-        const char code_logl[] ="void f(long double x) {\n"
-                                " std::cout << logl(x);\n" // do not simplify
-                                " std::cout << logl(10.0f);\n" // do not simplify
-                                " std::cout << logl(1.0f);\n" // simplify to 0
-                                "}";
-        const char expected_logl[] = "void f ( double x ) {\n"
-                                     "std :: cout << logl ( x ) ;\n"
-                                     "std :: cout << logl ( 10.0f ) ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_logl, tokWithNewlines(code_logl));
-    }
-
-    void simplifyMathFunctions_log2() {
-        // verify log2(), log2f(), log2l() - simplifcation
-        const char code_log2[] ="void f(int x) {\n"
-                                " std::cout << log2(x);\n" // do not simplify
-                                " std::cout << log2(10);\n" // do not simplify
-                                " std::cout << log2(1L);\n" // simplify to 0
-                                "}";
-        const char expected_log2[] = "void f ( int x ) {\n"
-                                     "std :: cout << log2 ( x ) ;\n"
-                                     "std :: cout << log2 ( 10 ) ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_log2, tokWithNewlines(code_log2));
-
-        const char code_log2f[] ="void f(float x) {\n"
-                                 " std::cout << log2f(x);\n" // do not simplify
-                                 " std::cout << log2f(10);\n" // do not simplify
-                                 " std::cout << log2f(1.0f);\n" // simplify to 0
-                                 "}";
-        const char expected_log2f[] = "void f ( float x ) {\n"
-                                      "std :: cout << log2f ( x ) ;\n"
-                                      "std :: cout << log2f ( 10 ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_log2f, tokWithNewlines(code_log2f));
-
-        const char code_log2l[] ="void f(long double x) {\n"
-                                 " std::cout << log2l(x);\n" // do not simplify
-                                 " std::cout << log2l(10.0f);\n" // do not simplify
-                                 " std::cout << log2l(1.0f);\n" // simplify to 0
-                                 "}";
-        const char expected_log2l[] = "void f ( double x ) {\n"
-                                      "std :: cout << log2l ( x ) ;\n"
-                                      "std :: cout << log2l ( 10.0f ) ;\n"
-                                      "std :: cout << 0 ;\n"
-                                      "}";
-        ASSERT_EQUALS(expected_log2l, tokWithNewlines(code_log2l));
-    }
-
-    void simplifyMathFunctions_pow() {
-        // verify pow(),pow(),powl() - simplifcation
-        const char code_pow[] ="void f() {\n"
-                               " std::cout << pow(-1.0,1);\n"
-                               " std::cout << pow(1.0,1);\n"
-                               " std::cout << pow(0,1);\n"
-                               " std::cout << pow(1,-6);\n"
-                               " std::cout << powf(-1.0,1.0f);\n"
-                               " std::cout << powf(1.0,1.0f);\n"
-                               " std::cout << powf(0,1.0f);\n"
-                               " std::cout << powf(1.0,-6.0f);\n"
-                               " std::cout << powl(-1.0,1.0);\n"
-                               " std::cout << powl(1.0,1.0);\n"
-                               " std::cout << powl(0,1.0);\n"
-                               " std::cout << powl(1.0,-6.0d);\n"
-                               "}";
-
-        const char expected_pow[] = "void f ( ) {\n"
-                                    "std :: cout << -1.0 ;\n"
-                                    "std :: cout << 1 ;\n"
-                                    "std :: cout << 0 ;\n"
-                                    "std :: cout << 1 ;\n"
-                                    "std :: cout << -1.0 ;\n"
-                                    "std :: cout << 1 ;\n"
-                                    "std :: cout << 0 ;\n"
-                                    "std :: cout << 1 ;\n"
-                                    "std :: cout << -1.0 ;\n"
-                                    "std :: cout << 1 ;\n"
-                                    "std :: cout << 0 ;\n"
-                                    "std :: cout << 1 ;\n"
-                                    "}";
-        ASSERT_EQUALS(expected_pow, tokWithNewlines(code_pow));
-
-        // verify if code is simplified correctly.
-        // Do not simplify class members.
-        const char code_pow1[] = "int f(const Fred &fred) {return fred.pow(12,3);}";
-        const char expected_pow1[] = "int f ( const Fred & fred ) { return fred . pow ( 12 , 3 ) ; }";
-        ASSERT_EQUALS(expected_pow1, tokWithNewlines(code_pow1));
-
-        const char code_pow2[] = "int f() {return pow(0,0);}";
-        const char expected_pow2[] = "int f ( ) { return 1 ; }";
-        ASSERT_EQUALS(expected_pow2, tokWithNewlines(code_pow2));
-
-        const char code_pow3[] = "int f() {return pow(0,1);}";
-        const char expected_pow3[] = "int f ( ) { return 0 ; }";
-        ASSERT_EQUALS(expected_pow3, tokWithNewlines(code_pow3));
-
-        const char code_pow4[] = "int f() {return pow(1,0);}";
-        const char expected_pow4[] = "int f ( ) { return 1 ; }";
-        ASSERT_EQUALS(expected_pow4, tokWithNewlines(code_pow4));
-    }
-
-    void simplifyMathFunctions_fmin() {
-        // verify fmin,fminl,fminl simplifcation
-        const char code_fmin[] ="void f() {\n"
-                                " std::cout << fmin(-1.0,0);\n"
-                                " std::cout << fmin(1.0,0);\n"
-                                " std::cout << fmin(0,0);\n"
-                                " std::cout << fminf(-1.0,0);\n"
-                                " std::cout << fminf(1.0,0);\n"
-                                " std::cout << fminf(0,0);\n"
-                                " std::cout << fminl(-1.0,0);\n"
-                                " std::cout << fminl(1.0,0);\n"
-                                " std::cout << fminl(0,0);\n"
-                                "}";
-
-        const char expected_fmin[] = "void f ( ) {\n"
-                                     "std :: cout << -1.0 ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "std :: cout << -1.0 ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "std :: cout << -1.0 ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_fmin, tokWithNewlines(code_fmin));
-
-        // do not simplify this case
-        const char code_fmin1[] = "float f(float f) { return fmin(f,0);}";
-        const char expected_fmin1[] = "float f ( float f ) { return fmin ( f , 0 ) ; }";
-        ASSERT_EQUALS(expected_fmin1, tokWithNewlines(code_fmin1));
-    }
-
-    void simplifyMathFunctions_fmax() {
-        // verify fmax(),fmax(),fmaxl() simplifcation
-        const char code_fmax[] ="void f() {\n"
-                                " std::cout << fmax(-1.0,0);\n"
-                                " std::cout << fmax(1.0,0);\n"
-                                " std::cout << fmax(0,0);\n"
-                                " std::cout << fmaxf(-1.0,0);\n"
-                                " std::cout << fmaxf(1.0,0);\n"
-                                " std::cout << fmaxf(0,0);\n"
-                                " std::cout << fmaxl(-1.0,0);\n"
-                                " std::cout << fmaxl(1.0,0);\n"
-                                " std::cout << fmaxl(0,0);\n"
-                                "}";
-
-        const char expected_fmax[] = "void f ( ) {\n"
-                                     "std :: cout << 0 ;\n"
-                                     "std :: cout << 1.0 ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "std :: cout << 1.0 ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "std :: cout << 1.0 ;\n"
-                                     "std :: cout << 0 ;\n"
-                                     "}";
-        ASSERT_EQUALS(expected_fmax, tokWithNewlines(code_fmax));
-
-        // do not simplify this case
-        const char code_fmax1[] = "float f(float f) { return fmax(f,0);}";
-        const char expected_fmax1[] = "float f ( float f ) { return fmax ( f , 0 ) ; }";
-        ASSERT_EQUALS(expected_fmax1, tokWithNewlines(code_fmax1));
-    }
-
-    void simplifyMathExpressions() { //#1620
-        const char code1[] = "void foo() {\n"
-                             "    std::cout<<pow(sin(x),2)+pow(cos(x),2);\n"
-                             "    std::cout<<pow(sin(pow(sin(y),2)+pow(cos(y),2)),2)+pow(cos(pow(sin(y),2)+pow(cos(y),2)),2);\n"
-                             "    std::cout<<pow(sin(x),2.0)+pow(cos(x),2.0);\n"
-                             "    std::cout<<pow(sin(x*y+z),2.0)+pow(cos(x*y+z),2.0);\n"
-                             "    std::cout<<pow(sin(x*y+z),2)+pow(cos(x*y+z),2);\n"
-                             "    std::cout<<pow(cos(x),2)+pow(sin(x),2);\n"
-                             "    std::cout<<pow(cos(x),2.0)+pow(sin(x),2.0);\n"
-                             "    std::cout<<pow(cos(x*y+z),2.0)+pow(sin(x*y+z),2.0);\n"
-                             "    std::cout<<pow(cos(x*y+z),2)+pow(sin(x*y+z),2);\n"
-                             "    std::cout<<pow(sinh(x*y+z),2)-pow(cosh(x*y+z),2);\n"
-                             "    std::cout<<pow(sinh(x),2)-pow(cosh(x),2);\n"
-                             "    std::cout<<pow(sinh(x*y+z),2.0)-pow(cosh(x*y+z),2.0);\n"
-                             "    std::cout<<pow(sinh(x),2.0)-pow(cosh(x),2.0);\n"
-                             "    std::cout<<pow(cosh(x*y+z),2)-pow(sinh(x*y+z),2);\n"
-                             "    std::cout<<pow(cosh(x),2)-pow(sinh(x),2);\n"
-                             "    std::cout<<pow(cosh(x*y+z),2.0)-pow(sinh(x*y+z),2.0);\n"
-                             "    std::cout<<pow(cosh(x),2.0)-pow(sinh(x),2.0);\n"
-                             "    std::cout<<pow(cosh(pow(x,1)),2.0)-pow(sinh(pow(x,1)),2.0);\n"
-                             "}";
-
-        const char expected1[] = "void foo ( ) {\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "}";
-        ASSERT_EQUALS(expected1, tokWithNewlines(code1));
-
-        const char code2[] = "void f ( ) {\n"
-                             "a = pow ( sin ( x ) , 2 ) + pow ( cos ( y ) , 2 ) ;\n"
-                             "b = pow ( sinh ( x ) , 2 ) - pow ( cosh ( y ) , 2 ) ;\n"
-                             "c = pow ( sin ( x ) , 2.0 ) + pow ( cos ( y ) , 2.0 ) ;\n"
-                             "d = pow ( sinh ( x ) , 2.0 ) - pow ( cosh ( y ) , 2.0 ) ;\n"
-                             "e = pow ( cos ( x ) , 2 ) + pow ( sin ( y ) , 2 ) ;\n"
-                             "f = pow ( cosh ( x ) , 2 ) - pow ( sinh ( y ) , 2 ) ;\n"
-                             "g = pow ( cos ( x ) , 2.0 ) + pow ( sin ( y ) , 2.0 ) ;\n"
-                             "h = pow ( cosh ( x ) , 2.0 ) - pow ( sinh ( y ) , 2.0 ) ;\n"
-                             "}";
-        ASSERT_EQUALS(code2, tokWithNewlines(code2));
-
-        const char code3[] = "void foo() {\n"
-                             "    std::cout<<powf(sinf(x),2)+powf(cosf(x),2);\n"
-                             "    std::cout<<powf(sinf(powf(sinf(y),2)+powf(cosf(y),2)),2)+powf(cosf(powf(sinf(y),2)+powf(cosf(y),2)),2);\n"
-                             "    std::cout<<powf(sinf(x),2.0)+powf(cosf(x),2.0);\n"
-                             "    std::cout<<powf(sinf(x*y+z),2.0)+powf(cosf(x*y+z),2.0);\n"
-                             "    std::cout<<powf(sinf(x*y+z),2)+powf(cosf(x*y+z),2);\n"
-                             "    std::cout<<powf(cosf(x),2)+powf(sinf(x),2);\n"
-                             "    std::cout<<powf(cosf(x),2.0)+powf(sinf(x),2.0);\n"
-                             "    std::cout<<powf(cosf(x*y+z),2.0)+powf(sinf(x*y+z),2.0);\n"
-                             "    std::cout<<powf(cosf(x*y+z),2)+powf(sinf(x*y+z),2);\n"
-                             "    std::cout<<powf(sinhf(x*y+z),2)-powf(coshf(x*y+z),2);\n"
-                             "    std::cout<<powf(sinhf(x),2)-powf(coshf(x),2);\n"
-                             "    std::cout<<powf(sinhf(x*y+z),2.0)-powf(coshf(x*y+z),2.0);\n"
-                             "    std::cout<<powf(sinhf(x),2.0)-powf(coshf(x),2.0);\n"
-                             "    std::cout<<powf(coshf(x*y+z),2)-powf(sinhf(x*y+z),2);\n"
-                             "    std::cout<<powf(coshf(x),2)-powf(sinhf(x),2);\n"
-                             "    std::cout<<powf(coshf(x*y+z),2.0)-powf(sinhf(x*y+z),2.0);\n"
-                             "    std::cout<<powf(coshf(x),2.0)-powf(sinhf(x),2.0);\n"
-                             "    std::cout<<powf(coshf(powf(x,1)),2.0)-powf(sinhf(powf(x,1)),2.0);\n"
-                             "}";
-
-        const char expected3[] = "void foo ( ) {\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "}";
-        ASSERT_EQUALS(expected3, tokWithNewlines(code3));
-
-        const char code4[] = "void f ( ) {\n"
-                             "a = powf ( sinf ( x ) , 2 ) + powf ( cosf ( y ) , 2 ) ;\n"
-                             "b = powf ( sinhf ( x ) , 2 ) - powf ( coshf ( y ) , 2 ) ;\n"
-                             "c = powf ( sinf ( x ) , 2.0 ) + powf ( cosf ( y ) , 2.0 ) ;\n"
-                             "d = powf ( sinhf ( x ) , 2.0 ) - powf ( coshf ( y ) , 2.0 ) ;\n"
-                             "e = powf ( cosf ( x ) , 2 ) + powf ( sinf ( y ) , 2 ) ;\n"
-                             "f = powf ( coshf ( x ) , 2 ) - powf ( sinhf ( y ) , 2 ) ;\n"
-                             "g = powf ( cosf ( x ) , 2.0 ) + powf ( sinf ( y ) , 2.0 ) ;\n"
-                             "h = powf ( coshf ( x ) , 2.0 ) - powf ( sinhf ( y ) , 2.0 ) ;\n"
-                             "}";
-        ASSERT_EQUALS(code4, tokWithNewlines(code4));
-
-        const char code5[] = "void foo() {\n"
-                             "    std::cout<<powf(sinl(x),2)+powl(cosl(x),2);\n"
-                             "    std::cout<<pow(sinl(powl(sinl(y),2)+powl(cosl(y),2)),2)+powl(cosl(powl(sinl(y),2)+powl(cosl(y),2)),2);\n"
-                             "    std::cout<<powl(sinl(x),2.0)+powl(cosl(x),2.0);\n"
-                             "    std::cout<<powl(sinl(x*y+z),2.0)+powl(cosl(x*y+z),2.0);\n"
-                             "    std::cout<<powl(sinl(x*y+z),2)+powl(cosl(x*y+z),2);\n"
-                             "    std::cout<<powl(cosl(x),2)+powl(sinl(x),2);\n"
-                             "    std::cout<<powl(cosl(x),2.0)+powl(sinl(x),2.0);\n"
-                             "    std::cout<<powl(cosl(x*y+z),2.0)+powl(sinl(x*y+z),2.0);\n"
-                             "    std::cout<<powl(cosl(x*y+z),2)+powl(sinl(x*y+z),2);\n"
-                             "    std::cout<<powl(sinhl(x*y+z),2)-powl(coshl(x*y+z),2);\n"
-                             "    std::cout<<powl(sinhl(x),2)-powl(coshl(x),2);\n"
-                             "    std::cout<<powl(sinhl(x*y+z),2.0)-powl(coshl(x*y+z),2.0);\n"
-                             "    std::cout<<powl(sinhl(x),2.0)-powl(coshl(x),2.0);\n"
-                             "    std::cout<<powl(coshl(x*y+z),2)-powl(sinhl(x*y+z),2);\n"
-                             "    std::cout<<powl(coshl(x),2)-powl(sinhl(x),2);\n"
-                             "    std::cout<<powl(coshl(x*y+z),2.0)-powl(sinhl(x*y+z),2.0);\n"
-                             "    std::cout<<powl(coshl(x),2.0)-powl(sinhl(x),2.0);\n"
-                             "    std::cout<<powl(coshl(powl(x,1)),2.0)-powl(sinhl(powl(x,1)),2.0);\n"
-                             "}";
-
-        const char expected5[] = "void foo ( ) {\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << 1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "std :: cout << -1 ;\n"
-                                 "}";
-        ASSERT_EQUALS(expected5, tokWithNewlines(code5));
-
-
-        const char code6[] = "void f ( ) {\n"
-                             "a = powl ( sinl ( x ) , 2 ) + powl ( cosl ( y ) , 2 ) ;\n"
-                             "b = powl ( sinhl ( x ) , 2 ) - powl ( coshl ( y ) , 2 ) ;\n"
-                             "c = powl ( sinl ( x ) , 2.0 ) + powl ( cosl ( y ) , 2.0 ) ;\n"
-                             "d = powl ( sinhl ( x ) , 2.0 ) - powl ( coshl ( y ) , 2.0 ) ;\n"
-                             "e = powl ( cosl ( x ) , 2 ) + powl ( sinl ( y ) , 2 ) ;\n"
-                             "f = powl ( coshl ( x ) , 2 ) - powl ( sinhl ( y ) , 2 ) ;\n"
-                             "g = powl ( cosl ( x ) , 2.0 ) + powl ( sinl ( y ) , 2.0 ) ;\n"
-                             "h = powl ( coshl ( x ) , 2.0 ) - powl ( sinhl ( y ) , 2.0 ) ;\n"
-                             "}";
-        ASSERT_EQUALS(code6, tokWithNewlines(code6));
-    }
-
-
-    void simplifyAssignmentInFunctionCall() {
-        ASSERT_EQUALS("; x = g ( ) ; f ( x ) ;", tok(";f(x=g());"));
-        ASSERT_EQUALS("; hs = ( xyz_t ) { h . centerX , h . centerY , 1 + index } ; putInput ( hs , 1 ) ;", tok(";putInput(hs = (xyz_t) { h->centerX, h->centerY, 1 + index }, 1);"));
-    }
-
-    void simplifyCompoundAssignment() {
-        ASSERT_EQUALS("; x = x + y ;", tok("; x += y;"));
-        ASSERT_EQUALS("; x = x - y ;", tok("; x -= y;"));
-        ASSERT_EQUALS("; x = x * y ;", tok("; x *= y;"));
-        ASSERT_EQUALS("; x = x / y ;", tok("; x /= y;"));
-        ASSERT_EQUALS("; x = x % y ;", tok("; x %= y;"));
-        ASSERT_EQUALS("; x = x & y ;", tok("; x &= y;"));
-        ASSERT_EQUALS("; x = x | y ;", tok("; x |= y;"));
-        ASSERT_EQUALS("; x = x ^ y ;", tok("; x ^= y;"));
-        ASSERT_EQUALS("; x = x << y ;", tok("; x <<= y;"));
-        ASSERT_EQUALS("; x = x >> y ;", tok("; x >>= y;"));
-
-        ASSERT_EQUALS("{ x = x + y ; }", tok("{ x += y;}"));
-        ASSERT_EQUALS("{ x = x - y ; }", tok("{ x -= y;}"));
-        ASSERT_EQUALS("{ x = x * y ; }", tok("{ x *= y;}"));
-        ASSERT_EQUALS("{ x = x / y ; }", tok("{ x /= y;}"));
-        ASSERT_EQUALS("{ x = x % y ; }", tok("{ x %= y;}"));
-        ASSERT_EQUALS("{ x = x & y ; }", tok("{ x &= y;}"));
-        ASSERT_EQUALS("{ x = x | y ; }", tok("{ x |= y;}"));
-        ASSERT_EQUALS("{ x = x ^ y ; }", tok("{ x ^= y;}"));
-        ASSERT_EQUALS("{ x = x << y ; }", tok("{ x <<= y;}"));
-        ASSERT_EQUALS("{ x = x >> y ; }", tok("{ x >>= y;}"));
-
-        ASSERT_EQUALS("; * p = * p + y ;", tok("; *p += y;"));
-        ASSERT_EQUALS("; ( * p ) = ( * p ) + y ;", tok("; (*p) += y;"));
-        ASSERT_EQUALS("; * ( p [ 0 ] ) = * ( p [ 0 ] ) + y ;", tok("; *(p[0]) += y;"));
-        ASSERT_EQUALS("; p [ { 1 , 2 } ] = p [ { 1 , 2 } ] + y ;", tok("; p[{1,2}] += y;"));
-
-        ASSERT_EQUALS("void foo ( ) { switch ( n ) { case 0 : ; x = x + y ; break ; } }", tok("void foo() { switch (n) { case 0: x += y; break; } }"));
-
-        ASSERT_EQUALS("; x . y = x . y + 1 ;", tok("; x.y += 1;"));
-
-        ASSERT_EQUALS("; x [ 0 ] = x [ 0 ] + 1 ;", tok("; x[0] += 1;"));
-        ASSERT_EQUALS("; x [ y - 1 ] = x [ y - 1 ] + 1 ;", tok("; x[y-1] += 1;"));
-        ASSERT_EQUALS("; x [ y ] = x [ y ++ ] + 1 ;", tok("; x[y++] += 1;"));
-        ASSERT_EQUALS("; x [ ++ y ] = x [ y ] + 1 ;", tok("; x[++y] += 1;"));
-
-        ASSERT_EQUALS(";", tok(";x += 0;"));
-        TODO_ASSERT_EQUALS(";", "; x = x + '\\0' ;", tok("; x += '\\0'; "));
-        ASSERT_EQUALS(";", tok(";x -= 0;"));
-        ASSERT_EQUALS(";", tok(";x |= 0;"));
-        ASSERT_EQUALS(";", tok(";x *= 1;"));
-        ASSERT_EQUALS(";", tok(";x /= 1;"));
-
-        ASSERT_EQUALS("; a . x ( ) = a . x ( ) + 1 ;", tok("; a.x() += 1;"));
-        ASSERT_EQUALS("; x ( 1 ) = x ( 1 ) + 1 ;", tok("; x(1) += 1;"));
-
-        // #2368
-        ASSERT_EQUALS("{ j = j - i ; }", tok("if (false) {} else { j -= i; }"));
-
-        // #2714 - wrong simplification of "a += b?c:d;"
-        ASSERT_EQUALS("; a = a + ( b ? c : d ) ;", tok("; a+=b?c:d;"));
-        ASSERT_EQUALS("; a = a * ( b + 1 ) ;", tok("; a*=b+1;"));
-
-        ASSERT_EQUALS("; a = a + ( b && c ) ;", tok("; a+=b&&c;"));
-        ASSERT_EQUALS("; a = a * ( b || c ) ;", tok("; a*=b||c;"));
-        ASSERT_EQUALS("; a = a | ( b == c ) ;", tok("; a|=b==c;"));
-
-        // #3469
-        ASSERT_EQUALS("; a = a + ( b = 1 ) ;", tok("; a += b = 1;"));
-
-        // #7571
-        ASSERT_EQUALS("; foo = foo + [ & ] ( ) { } ;", tok("; foo += [&]() {int i;};"));
-
-        // #8796
-        ASSERT_EQUALS("{ return ( a = b ) += c ; }", tok("{ return (a = b) += c; }"));
-    }
-
-
-    void cast() {
-        ASSERT_EQUALS("if ( p == 0 ) { ; }", tok("if (p == (char *)0);"));
-        ASSERT_EQUALS("return str ;", tok("return (char *)str;"));
-
-        ASSERT_EQUALS("if ( * a )", tok("if ((char)*a)"));
-        ASSERT_EQUALS("if ( & a )", tok("if ((int)&a)"));
-        ASSERT_EQUALS("if ( * a )", tok("if ((unsigned int)(unsigned char)*a)"));
-        ASSERT_EQUALS("class A { A operator* ( int ) ; } ;", tok("class A { A operator *(int); };"));
-        ASSERT_EQUALS("class A { A operator* ( int ) const ; } ;", tok("class A { A operator *(int) const; };"));
-        ASSERT_EQUALS("if ( p == 0 ) { ; }", tok("if (p == (char *)(char *)0);"));
-        ASSERT_EQUALS("if ( p == 0 ) { ; }", tok("if (p == (char **)0);"));
-
-        // no simplification as the cast may be important here. see #2897 for example
-        ASSERT_EQUALS("; * ( ( char * ) p + 1 ) = 0 ;", tok("; *((char *)p + 1) = 0;"));
-
-        ASSERT_EQUALS("if ( true )", tok("if ((unsigned char)1)")); // #4164
-        ASSERT_EQUALS("f ( 200 )", tok("f((unsigned char)200)"));
-        ASSERT_EQUALS("f ( ( char ) 1234 )", tok("f((char)1234)")); // don't simplify downcast
-    }
 
 
-    void iftruefalse() {
-        {
-            const char code1[] = " void f() { int a; bool use = false; if( use ) { a=0; } else {a=1;} }";
-            const char code2[] = " void f() { int a; bool use = false; {a=1;} }";
-            ASSERT_EQUALS(tok(code2), tok(code1));
-        }
-
-        {
-            const char code1[] = " void f() { int a; bool use = true; if( use ) { a=0; } else {a=1;} }";
-            const char code2[] = " void f() { int a; bool use = true; { a=0; } }";
-            ASSERT_EQUALS(tok(code2), tok(code1));
-        }
-
-        {
-            const char code1[] = " void f() { int a; int use = 5; if( use ) { a=0; } else {a=1;} }";
-            const char code2[] = " void f() { int a; int use = 5; { a=0; } }";
-            ASSERT_EQUALS(tok(code2), tok(code1));
-        }
-
-        {
-            const char code1[] = " void f() { int a; int use = 0; if( use ) { a=0; } else {a=1;} }";
-            const char code2[] = " void f() { int a; int use = 0; {a=1;} }";
-            ASSERT_EQUALS(tok(code2), tok(code1));
-        }
-
-        {
-            const char code1[] = " void f() { int a; bool use = false; if( use ) a=0; else a=1; int c=1; }";
-            const char code2[] = " void f() { int a; bool use = false; { a=1; } int c=1; }";
-            ASSERT_EQUALS(tok(code2), tok(code1));
-        }
-
-        {
-            const char code1[] = " void f() { int a; bool use = true; if( use ) a=0; else a=1; int c=1; }";
-            const char code2[] = " void f() { int a; bool use = true; { a=0; } int c=1; }";
-            ASSERT_EQUALS(tok(code2), tok(code1));
-        }
-
-        {
-            const char code1[] = " void f() { int a; bool use = false; if( use ) a=0; else if( bb ) a=1; int c=1; }";
-            const char code2[] = " void f ( ) { int a ; bool use ; use = false ; { if ( bb ) { a = 1 ; } } int c ; c = 1 ; }";
-            ASSERT_EQUALS(tok(code2), tok(code1));
-        }
-
-        {
-            const char code1[] = " void f() { int a; bool use = true; if( use ) a=0; else if( bb ) a=1; int c=1; }";
-            const char code2[] = " void f() { int a; bool use = true; { a=0;} int c=1; }";
-            ASSERT_EQUALS(tok(code2), tok(code1));
-        }
-
-        {
-            const char code1[] = "void f() { int a; bool use = true; if( use ) a=0; else if( bb ) a=1; else if( cc ) a=33; else { gg = 0; } int c=1; }";
-            const char code2[] = "void f ( ) { }";
-            ASSERT_EQUALS(code2, tok(code1));
-        }
-
-        {
-            const char code1[] = " void f() { if( aa ) { a=0; } else if( true ) a=1; else { a=2; } }";
-            const char code2[] = " void f ( ) { if ( aa ) { a = 0 ; } else { { a = 1 ; } } }";
-            ASSERT_EQUALS(tok(code2), tok(code1));
-        }
-
-        {
-            const char code1[] = " void f() { if( aa ) { a=0; } else if( false ) a=1; else { a=2; } }";
-            const char code2[] = " void f ( ) { if ( aa ) { a = 0 ; } else { { a = 2 ; } } }";
-            ASSERT_EQUALS(tok(code2), tok(code1));
-        }
-
-        {
-            const char code1[] = "static const int x=1; void f() { if(x) { a=0; } }";
-            ASSERT_EQUALS("void f ( ) { a = 0 ; }", tok(code1));
-        }
-    }
-
     void combine_strings() {
         const char code1[] =  "void foo()\n"
-                              "{\n"
-                              "const char *a =\n"
-                              "{\n"
-                              "\"hello \"\n"
-                              "\"world\"\n"
-                              "};\n"
-                              "}\n";
+                             "{\n"
+                             "const char *a =\n"
+                             "{\n"
+                             "\"hello \"\n"
+                             "\"world\"\n"
+                             "};\n"
+                             "}\n";
 
         const char code2[] =  "void foo()\n"
-                              "{\n"
-                              "const char *a =\n"
-                              "{\n"
-                              "\"hello world\"\n"
-                              "};\n"
-                              "}\n";
+                             "{\n"
+                             "const char *a =\n"
+                             "{\n"
+                             "\"hello world\"\n"
+                             "};\n"
+                             "}\n";
         ASSERT_EQUALS(tok(code2), tok(code1));
+
+        const char code3[] = "x = L\"1\" TEXT(\"2\") L\"3\";";
+        ASSERT_EQUALS("x = L\"123\" ;", tok(code3, dinit(TokOptions, $.type = Platform::Type::Win64)));
+
+        const char code4[] = "x = TEXT(\"1\") L\"2\";";
+        ASSERT_EQUALS("x = L\"1\" L\"2\" ;", tok(code4, dinit(TokOptions, $.type = Platform::Type::Win64)));
     }
 
     void combine_wstrings() {
         const char code[] =  "a = L\"hello \"  L\"world\" ;\n";
 
-        const char expected[] =  "a = \"hello world\" ;";
+        const char expected[] =  "a = L\"hello world\" ;";
 
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings0, *this);
+        ASSERT(tokenizer.tokenize(code));
 
         ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
-        ASSERT_EQUALS(true, tokenizer.tokens()->tokAt(2)->isLong());
     }
 
     void combine_ustrings() {
         const char code[] =  "abcd = u\"ab\" u\"cd\";";
 
-        const char expected[] =  "abcd = \"abcd\" ;";
+        const char expected[] =  "abcd = u\"abcd\" ;";
 
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings0, *this);
+        ASSERT(tokenizer.tokenize(code));
 
         ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
-        ASSERT_EQUALS(true, tokenizer.tokens()->tokAt(2)->isLong());
     }
 
     void combine_Ustrings() {
         const char code[] =  "abcd = U\"ab\" U\"cd\";";
 
-        const char expected[] =  "abcd = \"abcd\" ;";
+        const char expected[] =  "abcd = U\"abcd\" ;";
 
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings0, *this);
+        ASSERT(tokenizer.tokenize(code));
 
         ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
-        ASSERT_EQUALS(true, tokenizer.tokens()->tokAt(2)->isLong());
     }
 
     void combine_u8strings() {
         const char code[] =  "abcd = u8\"ab\" u8\"cd\";";
 
-        const char expected[] =  "abcd = \"abcd\" ;";
+        const char expected[] =  "abcd = u8\"abcd\" ;";
+
+        SimpleTokenizer tokenizer(settings0, *this);
+        ASSERT(tokenizer.tokenize(code));
 
+        ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+    }
+
+    void combine_mixedstrings() {
+        const char code[] = "abcdef = \"ab\" L\"cd\" \"ef\";";
+
+        const char expected[] =  "abcdef = L\"abcdef\" ;";
 
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings0, *this);
+        ASSERT(tokenizer.tokenize(code));
 
         ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
-        ASSERT_EQUALS(false, tokenizer.tokens()->tokAt(2)->isLong());
     }
 
     void double_plus() {
         {
             const char code1[] =  "void foo( int a )\n"
-                                  "{\n"
-                                  "a++;\n"
-                                  "a--;\n"
-                                  "++a;\n"
-                                  "--a;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a++;\n"
+                                 "a--;\n"
+                                 "++a;\n"
+                                 "--a;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a ) { a ++ ; a -- ; ++ a ; -- a ; }", tok(code1));
         }
         {
             const char code1[] =  "void foo( int a )\n"
-                                  "{\n"
-                                  "a=a+a;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a+a;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a ) { a = a + a ; }", tok(code1));
         }
         {
             const char code1[] =  "void foo( int a, int b )\n"
-                                  "{\n"
-                                  "a=a+++b;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a+++b;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a , int b ) { a = a ++ + b ; }", tok(code1));
         }
         {
             const char code1[] =  "void foo( int a, int b )\n"
-                                  "{\n"
-                                  "a=a---b;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a---b;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a , int b ) { a = a -- - b ; }", tok(code1));
         }
         {
             const char code1[] =  "void foo( int a, int b )\n"
-                                  "{\n"
-                                  "a=a--+b;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a--+b;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a , int b ) { a = a -- + b ; }", tok(code1));
         }
         {
             const char code1[] =  "void foo( int a, int b )\n"
-                                  "{\n"
-                                  "a=a++-b;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a++-b;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a , int b ) { a = a ++ - b ; }", tok(code1));
         }
         {
             const char code1[] =  "void foo( int a, int b )\n"
-                                  "{\n"
-                                  "a=a+--b;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a+--b;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a , int b ) { a = a + -- b ; }", tok(code1));
         }
         {
             const char code1[] =  "void foo( int a, int b )\n"
-                                  "{\n"
-                                  "a=a-++b;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a-++b;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a , int b ) { a = a - ++ b ; }", tok(code1));
         }
     }
@@ -1919,51 +359,51 @@ class TestSimplifyTokens : public TestFixture {
     void redundant_plus() {
         {
             const char code1[] =  "void foo( int a, int b )\n"
-                                  "{\n"
-                                  "a=a + + b;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a + + b;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a , int b ) { a = a + b ; }", tok(code1));
         }
         {
             const char code1[] =  "void foo( int a, int b )\n"
-                                  "{\n"
-                                  "a=a + + + b;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a + + + b;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a , int b ) { a = a + b ; }", tok(code1));
         }
         {
             const char code1[] =  "void foo( int a, int b )\n"
-                                  "{\n"
-                                  "a=a + - b;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a + - b;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a , int b ) { a = a - b ; }", tok(code1));
         }
         {
             const char code1[] =  "void foo( int a, int b )\n"
-                                  "{\n"
-                                  "a=a - + b;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a - + b;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a , int b ) { a = a - b ; }", tok(code1));
         }
         {
             const char code1[] =  "void foo( int a, int b )\n"
-                                  "{\n"
-                                  "a=a - - b;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a - - b;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a , int b ) { a = a + b ; }", tok(code1));
         }
         {
             const char code1[] =  "void foo( int a, int b )\n"
-                                  "{\n"
-                                  "a=a - + - b;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a - + - b;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a , int b ) { a = a + b ; }", tok(code1));
         }
         {
             const char code1[] =  "void foo( int a, int b )\n"
-                                  "{\n"
-                                  "a=a - - - b;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a - - - b;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a , int b ) { a = a - b ; }", tok(code1));
         }
     }
@@ -1971,87 +411,56 @@ class TestSimplifyTokens : public TestFixture {
     void redundant_plus_numbers() {
         {
             const char code1[] =  "void foo( int a )\n"
-                                  "{\n"
-                                  "a=a + + 1;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a + + 1;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a ) { a = a + 1 ; }", tok(code1));
         }
         {
             const char code1[] =  "void foo( int a )\n"
-                                  "{\n"
-                                  "a=a + + + 1;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a + + + 1;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a ) { a = a + 1 ; }", tok(code1));
         }
         {
             const char code1[] =  "void foo( int a )\n"
-                                  "{\n"
-                                  "a=a + - 1;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a + - 1;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a ) { a = a - 1 ; }", tok(code1));
         }
         {
             const char code1[] =  "void foo( int a )\n"
-                                  "{\n"
-                                  "a=a - + 1;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a - + 1;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a ) { a = a - 1 ; }", tok(code1));
         }
         {
             const char code1[] =  "void foo( int a )\n"
-                                  "{\n"
-                                  "a=a - - 1;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a - - 1;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a ) { a = a + 1 ; }", tok(code1));
         }
         {
             const char code1[] =  "void foo( int a )\n"
-                                  "{\n"
-                                  "a=a - + - 1;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a - + - 1;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a ) { a = a + 1 ; }", tok(code1));
         }
         {
             const char code1[] =  "void foo( int a )\n"
-                                  "{\n"
-                                  "a=a - - - 1;\n"
-                                  "}\n";
+                                 "{\n"
+                                 "a=a - - - 1;\n"
+                                 "}\n";
             ASSERT_EQUALS("void foo ( int a ) { a = a - 1 ; }", tok(code1));
         }
     }
 
 
-    void parentheses1() {
-        ASSERT_EQUALS("a <= 110 ;", tok("a <= (10+100);"));
-        ASSERT_EQUALS("while ( x ( ) == -1 ) { }", tok("while((x()) == -1){ }"));
-    }
-
-    void parenthesesVar() {
-        // remove parentheses..
-        ASSERT_EQUALS("a = p ;", tok("a = (p);"));
-        ASSERT_EQUALS("if ( a < p ) { }", tok("if(a<(p)){}"));
-        ASSERT_EQUALS("void f ( ) { int p ; if ( p == -1 ) { } }", tok("void f(){int p; if((p)==-1){}}"));
-        ASSERT_EQUALS("void f ( ) { int p ; if ( -1 == p ) { } }", tok("void f(){int p; if(-1==(p)){}}"));
-        ASSERT_EQUALS("void f ( ) { int p ; if ( p ) { } }", tok("void f(){int p; if((p)){}}"));
-        ASSERT_EQUALS("return p ;", tok("return (p);"));
-        ASSERT_EQUALS("void f ( ) { int * p ; if ( * p == 0 ) { } }", tok("void f(){int *p; if (*(p) == 0) {}}"));
-        ASSERT_EQUALS("void f ( ) { int * p ; if ( * p == 0 ) { } }", tok("void f(){int *p; if (*p == 0) {}}"));
-        ASSERT_EQUALS("void f ( int & p ) { p = 1 ; }", tok("void f(int &p) {(p) = 1;}"));
-        ASSERT_EQUALS("void f ( ) { int p [ 10 ] ; p [ 0 ] = 1 ; }", tok("void f(){int p[10]; (p)[0] = 1;}"));
-        ASSERT_EQUALS("void f ( ) { int p ; if ( p == 0 ) { } }", tok("void f(){int p; if ((p) == 0) {}}"));
-        ASSERT_EQUALS("void f ( ) { int * p ; * p = 1 ; }", tok("void f(){int *p; *(p) = 1;}"));
-        ASSERT_EQUALS("void f ( ) { int p ; if ( p ) { } p = 1 ; }", tok("void f(){int p; if ( p ) { } (p) = 1;}"));
-        ASSERT_EQUALS("void f ( ) { a . b ; }", tok("void f ( ) { ( & a ) -> b ; }")); // Ticket #5776
-
-        // keep parentheses..
-        ASSERT_EQUALS("b = a ;", tok("b = (char)a;"));
-        ASSERT_EQUALS("cast < char * > ( p ) ;", tok("cast<char *>(p);"));
-        ASSERT_EQUALS("return ( a + b ) * c ;", tok("return (a+b)*c;"));
-        ASSERT_EQUALS("void f ( ) { int p ; if ( 2 * p == 0 ) { } }", tok("void f(){int p; if (2*p == 0) {}}"));
-        ASSERT_EQUALS("void f ( ) { DIR * f ; f = opendir ( dirname ) ; if ( closedir ( f ) ) { } }", tok("void f(){DIR * f = opendir(dirname);if (closedir(f)){}}"));
-        ASSERT_EQUALS("void foo ( int p ) { if ( p >= 0 ) { ; } }", tok("void foo(int p){if((p)>=0);}"));
-    }
-
     void declareVar() {
         const char code[] = "void f ( ) { char str [ 100 ] = \"100\" ; }";
         ASSERT_EQUALS(code, tok(code));
@@ -2101,59 +510,24 @@ class TestSimplifyTokens : public TestFixture {
         }
     }
 
-    void removePostIncrement() {
-        const char code[] = "void f(int &c)\n"
-                            "{\n"
-                            "    c = 0;\n"
-                            "    c++;\n"
-                            "    if (c>0) { c++; }\n"
-                            "    c++;\n"
-                            "}\n";
-        TODO_ASSERT_EQUALS("void f ( int & c ) { c = 3 ; { ; } ; }",
-                           "void f ( int & c ) { c = 1 ; { c ++ ; } c ++ ; }", tok(code));
-    }
-
-
-    void removePreIncrement() {
-        {
-            const char code[] = "void f(int &c)\n"
-                                "{\n"
-                                "    c = 0;\n"
-                                "    ++c;\n"
-                                "    if (c>0) { ++c; }\n"
-                                "    ++c;\n"
-                                "}\n";
-            TODO_ASSERT_EQUALS("void f ( int & c ) { c = 3 ; { ; } ; }",
-                               "void f ( int & c ) { c = 1 ; { ++ c ; } ++ c ; }", tok(code));
-        }
-
-        {
-            const char code[] = "void f()\n"
-                                "{\n"
-                                " char a[] = \"p\";\n"
-                                " ++a[0];\n"
-                                "}\n";
-            ASSERT_EQUALS("void f ( ) { char a [ 2 ] = \"p\" ; ++ a [ 0 ] ; }", tok(code));
-        }
-    }
 
     void elseif1() {
-        const char code[] = "else if(ab) { cd } else { ef }gh;";
-        ASSERT_EQUALS("\n\n##file 0\n1: else { if ( ab ) { cd } else { ef } } gh ;\n", tokenizeDebugListing(code));
+        const char code[] = "void f(){ if(x) {} else if(ab) { cd } else { ef }gh; }";
+        ASSERT_EQUALS("\n\n##file 0\n1: void f ( ) { if ( x ) { } else { if ( ab ) { cd } else { ef } } gh ; }\n", tokenizeDebugListing(code));
 
         // syntax error: assert there is no segmentation fault
-        ASSERT_EQUALS("\n\n##file 0\n1: else if ( x ) { }\n", tokenizeDebugListing("else if (x) { }"));
+        ASSERT_EQUALS("\n\n##file 0\n1: void f ( ) { if ( x ) { } else { if ( x ) { } } }\n", tokenizeDebugListing("void f(){ if(x) {} else if (x) { } }"));
 
         {
             const char src[] =  "void f(int g,int f) {\n"
-                                "if(g==1) {poo();}\n"
-                                "else if( g == 2 )\n"
-                                "{\n"
-                                " if( f == 0 ){coo();}\n"
-                                " else if( f==1)\n"
-                                "  goo();\n"
-                                "}\n"
-                                "}";
+                               "if(g==1) {poo();}\n"
+                               "else if( g == 2 )\n"
+                               "{\n"
+                               " if( f == 0 ){coo();}\n"
+                               " else if( f==1)\n"
+                               "  goo();\n"
+                               "}\n"
+                               "}";
 
             const char expected[] = "void f ( int g , int f ) "
                                     "{ "
@@ -2193,2750 +567,2083 @@ class TestSimplifyTokens : public TestFixture {
     }
 
 
-    unsigned int sizeofFromTokenizer(const char type[]) {
-        Tokenizer tokenizer(&settings0, this);
-        tokenizer.fillTypeSizes();
-        Token tok1;
-        tok1.str(type);
-        return tokenizer.sizeOfType(&tok1);
-    }
-
-
-
-    void sizeof_array() {
-        const char *code;
-
-        code = "void foo()\n"
-               "{\n"
-               "    int i[4];\n"
-               "    sizeof(i);\n"
-               "    sizeof(*i);\n"
-               "}\n";
-        ASSERT_EQUALS("void foo ( ) { int i [ 4 ] ; 16 ; 4 ; }", tok(code));
-
-        code = "static int i[4];\n"
-               "void f()\n"
-               "{\n"
-               "    int i[10];\n"
-               "    sizeof(i);\n"
-               "}\n";
-        ASSERT_EQUALS("static int i [ 4 ] ; void f ( ) { int i [ 10 ] ; 40 ; }", tok(code));
-        {
-            code = "int i[10];\n"
-                   "sizeof(i[0]);\n";
-            ASSERT_EQUALS("int i [ 10 ] ; 4 ;", tok(code));
-
-            code = "int i[10];\n"
-                   "sizeof i[0];\n";
-            ASSERT_EQUALS("int i [ 10 ] ; 4 ;", tok(code));
-        }
-
-        code = "char i[2][20];\n"
-               "sizeof(i[1]);\n"
-               "sizeof(i);";
-        ASSERT_EQUALS("char i [ 2 ] [ 20 ] ; 20 ; 40 ;", tok(code));
-
-        code = "char i[2][20][30];\n"
-               "sizeof(i[1][4][2]);\n"
-               "sizeof(***i);\n"
-               "sizeof(i[1][4]);\n"
-               "sizeof(**i);\n"
-               "sizeof(i[1]);\n"
-               "sizeof(*i);\n"
-               "sizeof(i);";
-        ASSERT_EQUALS("char i [ 2 ] [ 20 ] [ 30 ] ; 1 ; 1 ; 30 ; 30 ; 600 ; 600 ; 1200 ;", tok(code));
-
-        code = "sizeof(char[20]);\n"
-               "sizeof(char[20][3]);\n"
-               "sizeof(char[unknown][3]);";
-        ASSERT_EQUALS("20 ; 60 ; sizeof ( char [ unknown ] [ 3 ] ) ;", tok(code));
-    }
-
-    void sizeof5() {
-        const char code[] =
-            "const char * names[2];"
-            "for (int i = 0; i != sizeof(names[0]); i++)"
-            "{}";
-        std::ostringstream expected;
-        expected << "const char * names [ 2 ] ; for ( int i = 0 ; i != " << sizeofFromTokenizer("*") << " ; i ++ ) { }";
-        ASSERT_EQUALS(expected.str(), tok(code));
-    }
-
-    void sizeof6() {
-        const char code[] = ";int i;\n"
-                            "sizeof(i);\n";
-
-        std::ostringstream expected;
-        expected << "; int i ; " << sizeof(int) << " ;";
-
-        ASSERT_EQUALS(expected.str(), tok(code));
-    }
-
-    void sizeof7() {
-        const char code[] = ";INT32 i[10];\n"
-                            "sizeof(i[0]);\n";
-        ASSERT_EQUALS("; INT32 i [ 10 ] ; sizeof ( i [ 0 ] ) ;", tok(code, true, Settings::Native));
-        ASSERT_EQUALS("; int i [ 10 ] ; 4 ;", tokWithWindows(code, true, Settings::Win32A));
-    }
-
-    void sizeof8() {
-        {
-            const char code[] = "void f()\n"
-                                "{\n"
-                                "  char* ptrs[2];\n"
-                                "  a = sizeof( ptrs );\n"
-                                "}\n";
-            std::ostringstream oss;
-            oss << (sizeofFromTokenizer("*") * 2);
-            ASSERT_EQUALS("void f ( ) { char * ptrs [ 2 ] ; a = " + oss.str() + " ; }", tok(code));
-        }
-
-        {
-            const char code[] = "void f()\n"
-                                "{\n"
-                                "  char* ptrs[55];\n"
-                                "  a = sizeof( ptrs );\n"
-                                "}\n";
-            std::ostringstream oss;
-            oss << (sizeofFromTokenizer("*") * 55);
-            ASSERT_EQUALS("void f ( ) { char * ptrs [ 55 ] ; a = " + oss.str() + " ; }", tok(code));
-        }
-
-
-        {
-            const char code[] = "void f()\n"
-                                "{\n"
-                                "  char* ptrs;\n"
-                                "  a = sizeof( ptrs );\n"
-                                "}\n";
-            std::ostringstream oss;
-            oss << sizeofFromTokenizer("*");
-            ASSERT_EQUALS("void f ( ) { a = " + oss.str() + " ; }", tok(code));
-        }
-    }
-
-    void sizeof9() {
-        // ticket #487
+    void namespaces() {
         {
-            const char code[] = "; const char *str = \"1\"; sizeof(str);";
-
-            std::ostringstream expected;
-            expected << "; const char * str ; str = \"1\" ; " << sizeofFromTokenizer("*") << " ;";
+            const char code[] = "namespace std { }";
 
-            ASSERT_EQUALS(expected.str(), tok(code));
+            ASSERT_EQUALS(";", tok(code));
         }
 
         {
-            const char code[] = "; const char str[] = \"1\"; sizeof(str);";
-
-            std::ostringstream expected;
-            expected << "; const char str [ 2 ] = \"1\" ; " << sizeofFromTokenizer("char")*2 << " ;";
-
-            ASSERT_EQUALS(expected.str(), tok(code));
-        }
+            const char code[] = "; namespace std { }";
 
-        {
-            // Ticket #799
-            const char code[] = "; const char str[] = {'1'}; sizeof(str);";
-            ASSERT_EQUALS("; const char str [ 1 ] = { '1' } ; 1 ;", tok(code));
+            ASSERT_EQUALS(";", tok(code));
         }
 
         {
-            // Ticket #2087
-            const char code[] = "; const char str[] = {\"abc\"}; sizeof(str);";
-            ASSERT_EQUALS("; const char str [ 4 ] = \"abc\" ; 4 ;", tok(code));
-        }
+            const char code[] = "using namespace std; namespace a{ namespace b{ void f(){} } }";
 
-        // ticket #716 - sizeof string
-        {
-            std::ostringstream expected;
-            expected << "; " << (sizeof "123") << " ;";
+            const char expected[] = "namespace a { namespace b { void f ( ) { } } }";
 
-            ASSERT_EQUALS(expected.str(), tok("; sizeof \"123\";"));
-            ASSERT_EQUALS(expected.str(), tok("; sizeof(\"123\");"));
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "void f(char *a,char *b, char *c)"
-                                "{g(sizeof(a),sizeof(b),sizeof(c));}";
-            std::ostringstream expected;
-            expected << "void f ( char * a , char * b , char * c ) { g ( " <<
-                     sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " ) ; }";
-            ASSERT_EQUALS(expected.str(), tok(code));
-        }
+            const char code[] = "namespace b{ void f(){} }";
 
-        {
-            const char code[] = "void f(char a,char b, char c)"
-                                "{g(sizeof(a),sizeof(b),sizeof(c));}";
-            std::ostringstream expected;
-            expected << "void f ( char a , char b , char c ) { g ( " <<
-                     sizeofFromTokenizer("char") << " , " << sizeofFromTokenizer("char") << " , " << sizeofFromTokenizer("char") << " ) ; }";
-            ASSERT_EQUALS(expected.str(), tok(code));
-        }
+            const char expected[] = "namespace b { void f ( ) { } }";
 
-        {
-            const char code[] = "void f(const char *a,const char *b, const char *c)"
-                                "{g(sizeof(a),sizeof(b),sizeof(c));}";
-            std::ostringstream expected;
-            expected << "void f ( const char * a , const char * b , const char * c ) { g ( " <<
-                     sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " ) ; }";
-            ASSERT_EQUALS(expected.str(), tok(code));
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "void f(char a[10],char b[10], char c[10])"
-                                "{g(sizeof(a),sizeof(b),sizeof(c));}";
-            std::ostringstream expected;
-            expected << "void f ( char a [ 10 ] , char b [ 10 ] , char c [ 10 ] ) { g ( " <<
-                     sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " ) ; }";
-            ASSERT_EQUALS(expected.str(), tok(code));
-        }
+            const char code[] = "void f(int namespace) { }";
 
-        {
-            const char code[] = "void f(const char a[10],const char b[10], const char c[10])"
-                                "{g(sizeof(a),sizeof(b),sizeof(c));}";
-            std::ostringstream expected;
-            expected << "void f ( const char a [ 10 ] , "
-                     "const char b [ 10 ] , "
-                     "const char c [ 10 ] ) { g ( " <<
-                     sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " ) ; }";
-            ASSERT_EQUALS(expected.str(), tok(code));
+            ASSERT_THROW_INTERNAL(tok(code), SYNTAX);
         }
+    }
 
-        {
-            const char code[] = "void f(const char *a[10],const char *b[10], const char *c[10])"
-                                "{g(sizeof(a),sizeof(b),sizeof(c));}";
-            std::ostringstream expected;
-            expected << "void f ( const char * a [ 10 ] , "
-                     "const char * b [ 10 ] , "
-                     "const char * c [ 10 ] ) { g ( " <<
-                     sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " ) ; }";
-            ASSERT_EQUALS(expected.str(), tok(code));
-        }
+    void not1() {
+        ASSERT_EQUALS("void f ( ) { if ( ! p ) { ; } }", tok("void f() { if (not p); }", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( p && ! q ) { ; } }", tok("void f() { if (p && not q); }", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { a = ! ( p && q ) ; }", tok("void f() { a = not(p && q); }", dinit(TokOptions, $.cpp = false)));
+        // Don't simplify 'not' or 'compl' if they are defined as a type;
+        // in variable declaration and in function declaration/definition
+        ASSERT_EQUALS("struct not { int x ; } ;", tok("struct not { int x; };", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { not p ; compl c ; }", tok(" void f() { not p; compl c; }", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("void foo ( not i ) ;", tok("void foo(not i);", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("int foo ( not i ) { return g ( i ) ; }", tok("int foo(not i) { return g(i); }", dinit(TokOptions, $.cpp = false)));
+    }
 
-        {
-            const char code[] = "void f(char *a[10],char *b[10], char *c[10])"
-                                "{g(sizeof(a),sizeof(b),sizeof(c));}";
-            std::ostringstream expected;
-            expected << "void f ( char * a [ 10 ] , char * b [ 10 ] , char * c [ 10 ] ) { g ( " <<
-                     sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " , " << sizeofFromTokenizer("*") << " ) ; }";
-            ASSERT_EQUALS(expected.str(), tok(code));
-        }
+    void and1() {
+        ASSERT_EQUALS("void f ( ) { if ( p && q ) { ; } }",
+                      tok("void f() { if (p and q) ; }", dinit(TokOptions, $.cpp = false)));
 
-        {
-            std::ostringstream expected;
-            expected << "; " << sizeof("\"quote\"");
-            ASSERT_EQUALS(expected.str(), tok("; sizeof(\"\\\"quote\\\"\")"));
-        }
+        ASSERT_EQUALS("void f ( ) { if ( foo ( ) && q ) { ; } }",
+                      tok("void f() { if (foo() and q) ; }", dinit(TokOptions, $.cpp = false)));
 
-        {
-            std::ostringstream expected;
-            expected << "void f ( ) { char str [ 100 ] = \"100\" ; " << sizeofFromTokenizer("char")*100 << " }";
-            ASSERT_EQUALS(expected.str(), tok("void f ( ) { char str [ 100 ] = \"100\" ; sizeof ( str ) }"));
-        }
-    }
+        ASSERT_EQUALS("void f ( ) { if ( foo ( ) && bar ( ) ) { ; } }",
+                      tok("void f() { if (foo() and bar()) ; }", dinit(TokOptions, $.cpp = false)));
 
-    void sizeof10() {
-        // ticket #809
-        const char code[] = "int m ; "
-                            "compat_ulong_t um ; "
-                            "long size ; size = sizeof ( m ) / sizeof ( um ) ;";
+        ASSERT_EQUALS("void f ( ) { if ( p && bar ( ) ) { ; } }",
+                      tok("void f() { if (p and bar()) ; }", dinit(TokOptions, $.cpp = false)));
 
-        ASSERT_EQUALS(code, tok(code, true, Settings::Win32A));
-    }
+        ASSERT_EQUALS("void f ( ) { if ( p && ! q ) { ; } }",
+                      tok("void f() { if (p and not q) ; }", dinit(TokOptions, $.cpp = false)));
 
-    void sizeof11() {
-        // ticket #827
-        const char code[] = "void f()\n"
-                            "{\n"
-                            "    char buf2[4];\n"
-                            "    sizeof buf2;\n"
-                            "}\n"
-                            "\n"
-                            "void g()\n"
-                            "{\n"
-                            "    struct A a[2];\n"
-                            "    char buf[32];\n"
-                            "    sizeof buf;\n"
-                            "}";
+        ASSERT_EQUALS("void f ( ) { r = a && b ; }",
+                      tok("void f() { r = a and b; }", dinit(TokOptions, $.cpp = false)));
 
-        const char expected[] = "void f ( ) "
-                                "{"
-                                " char buf2 [ 4 ] ;"
-                                " 4 ; "
-                                "} "
-                                ""
-                                "void g ( ) "
-                                "{"
-                                " struct A a [ 2 ] ;"
-                                " char buf [ 32 ] ;"
-                                " 32 ; "
-                                "}";
+        ASSERT_EQUALS("void f ( ) { r = ( a || b ) && ( c || d ) ; }",
+                      tok("void f() { r = (a || b) and (c || d); }", dinit(TokOptions, $.cpp = false)));
 
-        ASSERT_EQUALS(expected, tok(code));
+        ASSERT_EQUALS("void f ( ) { if ( test1 [ i ] == 'A' && test2 [ i ] == 'C' ) { } }",
+                      tok("void f() { if (test1[i] == 'A' and test2[i] == 'C') {} }", dinit(TokOptions, $.cpp = false)));
     }
 
-    void sizeof12() {
-        // ticket #827
-        const char code[] = "void f()\n"
-                            "{\n"
-                            "    int *p;\n"
-                            "    (sizeof *p);\n"
-                            "}";
+    void or1() {
+        ASSERT_EQUALS("void f ( ) { if ( p || q ) { ; } }",
+                      tok("void f() { if (p or q) ; }", dinit(TokOptions, $.cpp = false)));
 
-        const char expected[] = "void f ( ) "
-                                "{"
-                                ""
-                                " 4 ; "
-                                "}";
+        ASSERT_EQUALS("void f ( ) { if ( foo ( ) || q ) { ; } }",
+                      tok("void f() { if (foo() or q) ; }", dinit(TokOptions, $.cpp = false)));
 
-        ASSERT_EQUALS(expected, tok(code));
-    }
+        ASSERT_EQUALS("void f ( ) { if ( foo ( ) || bar ( ) ) { ; } }",
+                      tok("void f() { if (foo() or bar()) ; }", dinit(TokOptions, $.cpp = false)));
 
-    void sizeof13() {
-        // ticket #851
-        const char code[] = "int main()\n"
-                            "{\n"
-                            "    char *a;\n"
-                            "    a = malloc(sizeof(*a));\n"
-                            "}\n"
-                            "\n"
-                            "struct B\n"
-                            "{\n"
-                            "    char * b[2];\n"
-                            "};";
-        const char expected[] = "int main ( ) "
-                                "{"
-                                " char * a ;"
-                                " a = malloc ( 1 ) ; "
-                                "} "
-                                "struct B "
-                                "{"
-                                " char * b [ 2 ] ; "
-                                "} ;";
-        ASSERT_EQUALS(expected, tok(code));
-    }
+        ASSERT_EQUALS("void f ( ) { if ( p || bar ( ) ) { ; } }",
+                      tok("void f() { if (p or bar()) ; }", dinit(TokOptions, $.cpp = false)));
 
-    void sizeof14() {
-        // ticket #954
-        const char code[] = "void f()\n"
-                            "{\n"
-                            "    A **a;\n"
-                            "    int aa = sizeof *(*a)->b;\n"
-                            "}\n";
-        const char expected[] = "void f ( ) "
-                                "{"
-                                " A * * a ;"
-                                " int aa ; aa = sizeof ( * ( * a ) . b ) ; "
-                                "}";
-        ASSERT_EQUALS(expected, tok(code));
+        ASSERT_EQUALS("void f ( ) { if ( p || ! q ) { ; } }",
+                      tok("void f() { if (p or not q) ; }", dinit(TokOptions, $.cpp = false)));
 
-        // #5064 - sizeof !! (a == 1);
-        ASSERT_EQUALS("sizeof ( ! ! ( a == 1 ) ) ;", tok("sizeof !!(a==1);"));
-    }
+        ASSERT_EQUALS("void f ( ) { r = a || b ; }",
+                      tok("void f() { r = a or b; }", dinit(TokOptions, $.cpp = false)));
 
-    void sizeof15() {
-        // ticket #1020
-        tok("void f()\n"
-            "{\n"
-            "    int *n;\n"
-            "    sizeof *(n);\n"
-            "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("void f ( ) { r = ( a && b ) || ( c && d ) ; }",
+                      tok("void f() { r = (a && b) or (c && d); }", dinit(TokOptions, $.cpp = false)));
     }
 
-    void sizeof16() {
-        // ticket #1027
-        const char code[] = "void f()\n"
-                            "{\n"
-                            "    int a;\n"
-                            "    printf(\"%i\", sizeof a++);\n"
-                            "}\n";
-        ASSERT_EQUALS("void f ( ) { int a ; printf ( \"%i\" , sizeof ( a ++ ) ) ; }", tok(code));
-        ASSERT_EQUALS("", errout.str());
-    }
+    void cAlternativeTokens() {
+        ASSERT_EQUALS("void f ( ) { err |= ( ( r & s ) && ! t ) ; }",
+                      tok("void f() { err or_eq ((r bitand s) and not t); }", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) const { r = f ( a [ 4 ] | 0x0F , ~ c , ! d ) ; }",
+                      tok("void f() const { r = f(a[4] bitor 0x0F, compl c, not d) ; }", dinit(TokOptions, $.cpp = false)));
 
-    void sizeof17() {
-        // ticket #1050
-        const char code[] = "void f()\n"
-                            "{\n"
-                            "    sizeof 1;\n"
-                            "    while (0);\n"
-                            "}\n";
-        ASSERT_EQUALS("void f ( ) { sizeof ( 1 ) ; }", tok(code));
-        ASSERT_EQUALS("", errout.str());
     }
 
-    void sizeof18() {
-        {
-            std::ostringstream expected;
-            expected << sizeof(short int);
-
-            {
-                const char code[] = "void f()\n"
-                                    "{\n"
-                                    "    sizeof(short int);\n"
-                                    "}\n";
-                ASSERT_EQUALS("void f ( ) { " + expected.str() + " ; }", tok(code));
-                ASSERT_EQUALS("", errout.str());
-            }
-
-            {
-                const char code[] = "void f()\n"
-                                    "{\n"
-                                    "    sizeof(unsigned short int);\n"
-                                    "}\n";
-                ASSERT_EQUALS("void f ( ) { " + expected.str() + " ; }", tok(code));
-                ASSERT_EQUALS("", errout.str());
-            }
-
-            {
-                const char code[] = "void f()\n"
-                                    "{\n"
-                                    "    sizeof(short unsigned int);\n"
-                                    "}\n";
-                ASSERT_EQUALS("void f ( ) { " + expected.str() + " ; }", tok(code));
-                ASSERT_EQUALS("", errout.str());
-            }
-
-            {
-                const char code[] = "void f()\n"
-                                    "{\n"
-                                    "    sizeof(signed short int);\n"
-                                    "}\n";
-                ASSERT_EQUALS("void f ( ) { " + expected.str() + " ; }", tok(code));
-                ASSERT_EQUALS("", errout.str());
-            }
-        }
-
-        {
-            std::ostringstream expected;
-            expected << sizeof(long long);
-
-            {
-                const char code[] = "void f()\n"
-                                    "{\n"
-                                    "    sizeof(long long);\n"
-                                    "}\n";
-                ASSERT_EQUALS("void f ( ) { " + expected.str() + " ; }", tok(code));
-                ASSERT_EQUALS("", errout.str());
-            }
-
-            {
-                const char code[] = "void f()\n"
-                                    "{\n"
-                                    "    sizeof(signed long long);\n"
-                                    "}\n";
-                ASSERT_EQUALS("void f ( ) { " + expected.str() + " ; }", tok(code));
-                ASSERT_EQUALS("", errout.str());
-            }
-
-            {
-                const char code[] = "void f()\n"
-                                    "{\n"
-                                    "    sizeof(unsigned long long);\n"
-                                    "}\n";
-                ASSERT_EQUALS("void f ( ) { " + expected.str() + " ; }", tok(code));
-                ASSERT_EQUALS("", errout.str());
-            }
-
-            {
-                const char code[] = "void f()\n"
-                                    "{\n"
-                                    "    sizeof(long unsigned long);\n"
-                                    "}\n";
-                ASSERT_EQUALS("void f ( ) { " + expected.str() + " ; }", tok(code));
-                ASSERT_EQUALS("", errout.str());
-            }
-
-            {
-                const char code[] = "void f()\n"
-                                    "{\n"
-                                    "    sizeof(long long int);\n"
-                                    "}\n";
-                ASSERT_EQUALS("void f ( ) { " + expected.str() + " ; }", tok(code));
-                ASSERT_EQUALS("", errout.str());
-            }
-
-            {
-                const char code[] = "void f()\n"
-                                    "{\n"
-                                    "    sizeof(signed long long int);\n"
-                                    "}\n";
-                ASSERT_EQUALS("void f ( ) { " + expected.str() + " ; }", tok(code));
-                ASSERT_EQUALS("", errout.str());
-            }
-
-            {
-                const char code[] = "void f()\n"
-                                    "{\n"
-                                    "    sizeof(unsigned long long int);\n"
-                                    "}\n";
-                ASSERT_EQUALS("void f ( ) { " + expected.str() + " ; }", tok(code));
-                ASSERT_EQUALS("", errout.str());
-            }
-
-            {
-                const char code[] = "void f()\n"
-                                    "{\n"
-                                    "    sizeof(long unsigned long int);\n"
-                                    "}\n";
-                ASSERT_EQUALS("void f ( ) { " + expected.str() + " ; }", tok(code));
-                ASSERT_EQUALS("", errout.str());
-            }
-        }
-
+    void comma_keyword() {
         {
-            const char code[] = "void f()\n"
+            const char code[] = "void foo()\n"
                                 "{\n"
-                                "    sizeof(char*);\n"
+                                "    char *a, *b;\n"
+                                "    delete a, delete b;\n"
                                 "}\n";
-            std::ostringstream expected;
-            expected << sizeof(int*);
-            ASSERT_EQUALS("void f ( ) { " + expected.str() + " ; }", tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("void foo ( ) { char * a ; char * b ; delete a , delete b ; }", tok(code));
         }
 
         {
-            const char code[] = "void f()\n"
+            const char code[] = "void foo()\n"
                                 "{\n"
-                                "    sizeof(unsigned int*);\n"
+                                "    struct A *a, *b;\n"
                                 "}\n";
-            std::ostringstream expected;
-            expected << sizeof(int*);
-            ASSERT_EQUALS("void f ( ) { " + expected.str() + " ; }", tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("void foo ( ) { struct A * a ; struct A * b ; }", tok(code));
         }
-    }
 
-    void sizeof19() {
-        // ticket #1891 - sizeof 'x'
         {
-            const char code[] = "void f()\n"
+            const char code[] = "void foo()\n"
                                 "{\n"
-                                "    sizeof 'x';\n"
+                                "    struct A **a, **b;\n"
                                 "}\n";
-            std::ostringstream sz;
-            sz << sizeof('x');
-            ASSERT_EQUALS("void f ( ) { " + sz.str() + " ; }", tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("void foo ( ) { struct A * * a ; struct A * * b ; }", tok(code));
         }
 
         {
-            const char code[] = "void f()\n"
+            const char code[] = "void foo()\n"
                                 "{\n"
-                                "    sizeof('x');\n"
+                                "    char *a, *b;\n"
+                                "    delete a, b;\n"
                                 "}\n";
-            std::ostringstream sz;
-            sz << sizeof('x');
-            ASSERT_EQUALS("void f ( ) { " + sz.str() + " ; }", tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("void foo ( ) { char * a ; char * b ; delete a , b ; }", tok(code));
         }
-    }
-
-    void sizeof20() {
-        // ticket #2024 - sizeof a)
-        const char code[] = "struct struct_a {\n"
-                            "  char a[20];\n"
-                            "};\n"
-                            "\n"
-                            "void foo() {\n"
-                            "  struct_a a;\n"
-                            "  append(sizeof a).append();\n"
-                            "}\n";
-        ASSERT_EQUALS("struct struct_a { char a [ 20 ] ; } ; "
-                      "void foo ( ) {"
-                      " struct_a a ;"
-                      " append ( sizeof ( a ) ) . append ( ) ; "
-                      "}", tok(code));
-    }
-
-    void sizeof21() {
-        // ticket #2232 - sizeof...(Args)
-        const char code[] = "struct Internal {\n"
-                            "    int operator()(const Args&... args) const {\n"
-                            "        int n = sizeof...(Args);\n"
-                            "        return n;\n"
-                            "    }\n"
-                            "};\n"
-                            "\n"
-                            "int main() {\n"
-                            "    Internal internal;\n"
-                            "    int n = 0; n = internal(1);\n"
-                            "    return 0;\n"
-                            "}\n";
-
-        // don't segfault
-        tok(code);
-    }
-
-    void sizeof22() {
-        // sizeof from library
-        const char code[] = "foo(sizeof(uint32_t), sizeof(std::uint32_t));";
-        TODO_ASSERT_EQUALS("foo ( 4 , 4 ) ;", "foo ( 4 , sizeof ( std :: uint32_t ) ) ;", tokWithStdLib(code));
-    }
-
-    void sizeofsizeof() {
-        // ticket #1682
-        const char code[] = "void f()\n"
-                            "{\n"
-                            "    sizeof sizeof 1;\n"
-                            "}\n";
-        ASSERT_EQUALS("void f ( ) { sizeof ( sizeof ( 1 ) ) ; }", tok(code));
-        ASSERT_EQUALS("", errout.str());
-    }
 
-    void casting() {
         {
-            const char code[] = "void f()\n"
+            const char code[] = "void foo()\n"
                                 "{\n"
-                                "for (int i = 0; i < static_cast<int>(3); ++i) {}\n"
+                                "    char *a, *b, *c;\n"
+                                "    delete a, b, c;\n"
                                 "}\n";
-
-            const char expected[] = "void f ( ) { for ( int i = 0 ; i < 3 ; ++ i ) { } }";
-
-            ASSERT_EQUALS(expected, tok(code));
+            // delete a; b; c; would be better but this will do too
+            ASSERT_EQUALS("void foo ( ) { char * a ; char * b ; char * c ; delete a , b , c ; }", tok(code));
         }
 
         {
-            const char code[] = "void f()\n"
+            const char code[] = "void foo()\n"
                                 "{\n"
-                                "    p = const_cast<char *> qtu ();\n"
+                                "    char *a, *b;\n"
+                                "    if (x)\n"
+                                "        delete a, b;\n"
                                 "}\n";
-
-            const char expected[] = "void f ( ) { p = const_cast < char * > qtu ( ) ; }";
-
-            ASSERT_EQUALS(expected, tok(code));
+            ASSERT_EQUALS("void foo ( ) { char * a ; char * b ; if ( x ) { delete a , b ; } }", tok(code));
         }
 
         {
-            // ticket #645
-            const char code[] = "void f()\n"
+            const char code[] = "void foo()\n"
                                 "{\n"
-                                "    return dynamic_cast<Foo *>((bar()));\n"
+                                "    char *a, *b, *c;\n"
+                                "    if (x) \n"
+                                "        delete a, b, c;\n"
                                 "}\n";
-            const char expected[] = "void f ( ) { return bar ( ) ; }";
-
-            ASSERT_EQUALS(expected, tok(code));
+            // delete a; b; c; would be better but this will do too
+            ASSERT_EQUALS("void foo ( ) { char * a ; char * b ; char * c ; if ( x ) { delete a , b , c ; } }", tok(code));
         }
-    }
-
-
-    void strlen1() {
-        ASSERT_EQUALS("4", tok("strlen(\"abcd\")"));
 
         {
-            const char code[] = "void f()\n"
+            const char code[] = "void foo()\n"
                                 "{\n"
-                                "    const char *s = \"abcd\";\n"
-                                "    strlen(s);\n"
+                                "    char **a, **b, **c;\n"
                                 "}\n";
-            const char expected[] = "void f ( ) "
-                                    "{"
-                                    " const char * s ;"
-                                    " s = \"abcd\" ;"
-                                    " 4 ; "
-                                    "}";
-            ASSERT_EQUALS(expected, tok(code));
+            ASSERT_EQUALS("void foo ( ) { char * * a ; char * * b ; char * * c ; }", tok(code));
         }
 
         {
-            const char code[] = "void f()\n"
+            const char code[] = "void foo()\n"
                                 "{\n"
-                                "    const char s [ ] = \"abcd\";\n"
-                                "    strlen(s);\n"
+                                "    delete [] a, a = 0;\n"
                                 "}\n";
-            const char expected[] = "void f ( ) "
-                                    "{"
-                                    " const char s [ 5 ] = \"abcd\" ;"
-                                    " 4 ; "
-                                    "}";
-            ASSERT_EQUALS(expected, tok(code));
+            ASSERT_EQUALS("void foo ( ) { delete [ ] a , a = 0 ; }", tok(code));
         }
 
-    }
-
-    void strlen2() {
-        // #4530 - make sure calculation with strlen is simplified
-        ASSERT_EQUALS("i = -4 ;",
-                      tok("i = (strlen(\"abcd\") - 8);"));
-    }
-
-
-    void namespaces() {
         {
-            const char code[] = "namespace std { }";
-
-            ASSERT_EQUALS("", tok(code));
+            const char code[] = "void foo()\n"
+                                "{\n"
+                                "    delete a, a = 0;\n"
+                                "}\n";
+            ASSERT_EQUALS("void foo ( ) { delete a , a = 0 ; }", tok(code));
         }
 
         {
-            const char code[] = "; namespace std { }";
-
-            ASSERT_EQUALS(";", tok(code));
+            const char code[] = "void foo()\n"
+                                "{\n"
+                                "    if( x ) delete a, a = 0;\n"
+                                "}\n";
+            ASSERT_EQUALS("void foo ( ) { if ( x ) { delete a , a = 0 ; } }", tok(code));
         }
 
         {
-            const char code[] = "using namespace std; namespace a{ namespace b{ void f(){} } }";
-
-            const char expected[] = "namespace a { namespace b { void f ( ) { } } }";
-
-            ASSERT_EQUALS(expected, tok(code));
+            const char code[] = "void f()\n"
+                                "{\n"
+                                "    for(int a,b; a < 10; a = a + 1, b = b + 1);\n"
+                                "}\n";
+            ASSERT_EQUALS("void f ( ) { for ( int a , b ; a < 10 ; a = a + 1 , b = b + 1 ) { ; } }", tok(code));
         }
 
         {
-            const char code[] = "namespace b{ void f(){} }";
-
-            const char expected[] = "namespace b { void f ( ) { } }";
-
-            ASSERT_EQUALS(expected, tok(code));
+            const char code[] = "void f()\n"
+                                "{\n"
+                                "    char buf[BUFSIZ], **p;\n"
+                                "    char *ptrs[BUFSIZ], **pp;\n"
+                                "}\n";
+            ASSERT_EQUALS("void f ( ) { char buf [ BUFSIZ ] ; char * * p ; char * ptrs [ BUFSIZ ] ; char * * pp ; }", tok(code));
         }
 
         {
-            const char code[] = "void f(int namespace) { }";
-
-            const char expected[] = "void f ( int namespace ) { }";
-
-            ASSERT_EQUALS(expected, tok(code));
+            // #4786 - don't replace , with ; in ".. : public B, C .." code
+            const char code[] = "template < class T = X > class A : public B , C { } ;";
+            ASSERT_EQUALS(code, tok(code));
         }
     }
 
-
-    std::string simplifyIfAndWhileAssign(const char code[]) {
-        // tokenize..
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
-
-        tokenizer.simplifyIfAndWhileAssign();
-
-        return tokenizer.tokens()->stringifyList(nullptr, false);
-    }
-
-    void ifassign1() {
-        ASSERT_EQUALS("; a = b ; if ( a ) { ; }", simplifyIfAndWhileAssign(";if(a=b);"));
-        ASSERT_EQUALS("; a = b ( ) ; if ( a ) { ; }", simplifyIfAndWhileAssign(";if((a=b()));"));
-        ASSERT_EQUALS("; a = b ( ) ; if ( ! ( a ) ) { ; }", simplifyIfAndWhileAssign(";if(!(a=b()));"));
-        ASSERT_EQUALS("; a . x = b ( ) ; if ( ! ( a . x ) ) { ; }", simplifyIfAndWhileAssign(";if(!(a->x=b()));"));
-        ASSERT_EQUALS("void f ( ) { A ( ) a = b ; if ( a ) { ; } }", simplifyIfAndWhileAssign("void f() { A() if(a=b); }"));
-        ASSERT_EQUALS("void foo ( int a ) { a = b ( ) ; if ( a >= 0 ) { ; } }", tok("void foo(int a) {if((a=b())>=0);}"));
-        TODO_ASSERT_EQUALS("void foo ( A a ) { a . c = b ( ) ; if ( 0 <= a . c ) { ; } }",
-                           "void foo ( A a ) { a . c = b ( ) ; if ( a . c >= 0 ) { ; } }",
-                           tok("void foo(A a) {if((a.c=b())>=0);}"));
-    }
-
-    void ifAssignWithCast() {
-        const char *code =  "void foo()\n"
-                            "{\n"
-                            "FILE *f;\n"
-                            "if( (f = fopen(\"foo\", \"r\")) == ((FILE*)NULL) )\n"
-                            "return(-1);\n"
-                            "fclose(f);\n"
-                            "}\n";
-        const char *expected = "void foo ( ) "
-                               "{ "
-                               "FILE * f ; "
-                               "f = fopen ( \"foo\" , \"r\" ) ; "
-                               "if ( f == NULL ) "
-                               "{ "
-                               "return -1 ; "
-                               "} "
-                               "fclose ( f ) ; "
-                               "}";
+    void simplifyOperator1() {
+        // #3237 - error merging namespaces with operators
+        const char code[] = "class c {\n"
+                            "public:\n"
+                            "    operator std::string() const;\n"
+                            "    operator string() const;\n"
+                            "};\n";
+        const char expected[] = "class c { "
+                                "public: "
+                                "operatorstd::string ( ) const ; "
+                                "operatorstring ( ) const ; "
+                                "} ;";
         ASSERT_EQUALS(expected, tok(code));
     }
 
-    void whileAssign1() {
-        ASSERT_EQUALS("; a = b ; while ( a ) { b = 0 ; a = b ; }", simplifyIfAndWhileAssign(";while(a=b) { b = 0; }"));
-        ASSERT_EQUALS("; a . b = c ; while ( a . b ) { c = 0 ; a . b = c ; }", simplifyIfAndWhileAssign(";while(a.b=c) { c=0; }"));
-        ASSERT_EQUALS("struct hfs_bnode * node ; "
-                      "struct hfs_btree * tree ; "
-                      "node = tree . node_hash [ i ++ ] ; "
-                      "while ( node ) { node = tree . node_hash [ i ++ ] ; }",
-                      tok("struct hfs_bnode *node;"
-                          "struct hfs_btree *tree;"
-                          "while ((node = tree->node_hash[i++])) { }"));
-        ASSERT_EQUALS("char * s ; s = new char [ 10 ] ; while ( ! s ) { s = new char [ 10 ] ; }",
-                      tok("char *s; while (0 == (s=new char[10])) { }"));
-    }
-
-    void whileAssign2() {
-        // #1909 - Internal error
-        tok("void f()\n"
-            "{\n"
-            "  int b;\n"
-            "  while (b = sizeof (struct foo { int i0;}))\n"
-            "    ;\n"
-            "  if (!(0 <= b ))\n"
-            "    ;\n"
-            "}");
-        ASSERT_EQUALS("", errout.str());
+    void simplifyOperator2() {
+        // #6576
+        ASSERT_EQUALS("template < class T > class SharedPtr { "
+                      "SharedPtr & operator= ( const SharedPtr < Y > & r ) ; "
+                      "} ; "
+                      "class TClass { "
+                      "public: TClass & operator= ( const TClass & rhs ) ; "
+                      "} ; "
+                      "TClass :: TClass ( const TClass & other ) { operator= ( other ) ; }",
+                      tok("template<class T>\n"
+                          "    class SharedPtr {\n"
+                          "    SharedPtr& operator=(SharedPtr<Y> const & r);\n"
+                          "};\n"
+                          "class TClass {\n"
+                          "public:\n"
+                          "    TClass& operator=(const TClass& rhs);\n"
+                          "};\n"
+                          "TClass::TClass(const TClass &other) {\n"
+                          "    operator=(other);\n"
+                          "}"));
     }
 
-    void whileAssign3() {
-        // #4254 - Variable id
-        const char code[] = "void f() {\n"
-                            "  int a;\n"
-                            "  while (a = x());\n"
-                            "}";
+    void simplifyArrayAccessSyntax() {
         ASSERT_EQUALS("\n\n##file 0\n"
-                      "1: void f ( ) {\n"
-                      "2: int a@1 ;\n"
-                      "3: a@1 = x ( ) ; while ( a@1 ) { ; a@1 = x ( ) ; }\n"
-                      "4: }\n", tokenizeDebugListing(code, true, "test.c"));
-    }
-
-    void whileAssign4() {
-        errout.str("");
-
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr("; while (!(m = q->push<Message>(x))) {}");
-        tokenizer.tokenize(istr, "test.cpp");
-        tokenizer.simplifyTokenList2();
-
-        ASSERT_EQUALS("; m = q . push < Message > ( x ) ; while ( ! m ) { m = q . push < Message > ( x ) ; }", tokenizer.tokens()->stringifyList(nullptr, false));
-        ASSERT(tokenizer.tokens()->tokAt(26) != nullptr);
-        if (tokenizer.tokens()->tokAt(26)) {
-            ASSERT(tokenizer.tokens()->linkAt(6) == tokenizer.tokens()->tokAt(8));
-            ASSERT(tokenizer.tokens()->linkAt(24) == tokenizer.tokens()->tokAt(26));
-        }
-    }
-
-    void doWhileAssign() {
-        ASSERT_EQUALS("; do { a = b ; } while ( a ) ;", simplifyIfAndWhileAssign(";do { } while(a=b);"));
-        ASSERT_EQUALS("; do { a . a = 0 ; a . b = c ; } while ( a . b ) ;", simplifyIfAndWhileAssign(";do { a.a = 0; } while(a.b=c);"));
-        ASSERT_EQUALS("struct hfs_bnode * node ; "
-                      "struct hfs_btree * tree ; "
-                      "do { node = tree . node_hash [ i ++ ] ; } while ( node ) ;",
-                      tok("struct hfs_bnode *node;"
-                          "struct hfs_btree *tree;"
-                          "do { } while((node = tree->node_hash[i++]));"));
-        ASSERT_EQUALS("char * s ; do { s = new char [ 10 ] ; } while ( ! s ) ;",
-                      tok("char *s; do { } while (0 == (s=new char[10]));"));
-        // #4911
-        ASSERT_EQUALS("; do { current = f ( ) ; } while ( ( current ) != NULL ) ;", simplifyIfAndWhileAssign(";do { } while((current=f()) != NULL);"));
-    }
-
-    void not1() {
-        ASSERT_EQUALS("void f ( ) { if ( ! p ) { ; } }", tok("void f() { if (not p); }", "test.c", false));
-        ASSERT_EQUALS("void f ( ) { if ( p && ! q ) { ; } }", tok("void f() { if (p && not q); }", "test.c", false));
-        ASSERT_EQUALS("void f ( ) { a = ! ( p && q ) ; }", tok("void f() { a = not(p && q); }", "test.c", false));
-        // Don't simplify 'not' or 'compl' if they are defined as a type;
-        // in variable declaration and in function declaration/definition
-        ASSERT_EQUALS("struct not { int x ; } ;", tok("struct not { int x; };", "test.c", false));
-        ASSERT_EQUALS("void f ( ) { not p ; compl c ; }", tok(" void f() { not p; compl c; }", "test.c", false));
-        ASSERT_EQUALS("void foo ( not i ) ;", tok("void foo(not i);", "test.c", false));
-        ASSERT_EQUALS("int foo ( not i ) { return g ( i ) ; }", tok("int foo(not i) { return g(i); }", "test.c", false));
-    }
-
-    void and1() {
-        ASSERT_EQUALS("void f ( ) { if ( p && q ) { ; } }",
-                      tok("void f() { if (p and q) ; }", "test.c", false));
-
-        ASSERT_EQUALS("void f ( ) { if ( foo ( ) && q ) { ; } }",
-                      tok("void f() { if (foo() and q) ; }", "test.c", false));
-
-        ASSERT_EQUALS("void f ( ) { if ( foo ( ) && bar ( ) ) { ; } }",
-                      tok("void f() { if (foo() and bar()) ; }", "test.c", false));
-
-        ASSERT_EQUALS("void f ( ) { if ( p && bar ( ) ) { ; } }",
-                      tok("void f() { if (p and bar()) ; }", "test.c", false));
-
-        ASSERT_EQUALS("void f ( ) { if ( p && ! q ) { ; } }",
-                      tok("void f() { if (p and not q) ; }", "test.c", false));
-
-        ASSERT_EQUALS("void f ( ) { r = a && b ; }",
-                      tok("void f() { r = a and b; }", "test.c", false));
-
-        ASSERT_EQUALS("void f ( ) { r = ( a || b ) && ( c || d ) ; }",
-                      tok("void f() { r = (a || b) and (c || d); }", "test.c", false));
-
-        ASSERT_EQUALS("void f ( ) { if ( test1 [ i ] == 'A' && test2 [ i ] == 'C' ) { } }",
-                      tok("void f() { if (test1[i] == 'A' and test2[i] == 'C') {} }", "test.c", false));
+                      "1: int a@1 ; a@1 [ 13 ] ;\n", tokenizeDebugListing("int a; 13[a];"));
     }
 
-    void or1() {
-        ASSERT_EQUALS("void f ( ) { if ( p || q ) { ; } }",
-                      tok("void f() { if (p or q) ; }", "test.c", false));
 
-        ASSERT_EQUALS("void f ( ) { if ( foo ( ) || q ) { ; } }",
-                      tok("void f() { if (foo() or q) ; }", "test.c", false));
+    void pointeralias1() {
+        {
+            const char code[] = "void f(char *p1)\n"
+                                "{\n"
+                                "    char *p = p1;\n"
+                                "    p1 = 0;"
+                                "    x(p);\n"
+                                "}\n";
 
-        ASSERT_EQUALS("void f ( ) { if ( foo ( ) || bar ( ) ) { ; } }",
-                      tok("void f() { if (foo() or bar()) ; }", "test.c", false));
+            const char expected[] = "void f ( char * p1 ) "
+                                    "{ "
+                                    "char * p ; p = p1 ; "
+                                    "p1 = 0 ; "
+                                    "x ( p ) ; "
+                                    "}";
 
-        ASSERT_EQUALS("void f ( ) { if ( p || bar ( ) ) { ; } }",
-                      tok("void f() { if (p or bar()) ; }", "test.c", false));
+            ASSERT_EQUALS(expected, tok(code));
+        }
 
-        ASSERT_EQUALS("void f ( ) { if ( p || ! q ) { ; } }",
-                      tok("void f() { if (p or not q) ; }", "test.c", false));
+        {
+            const char code[] = "void foo(Result* ptr)\n"
+                                "{\n"
+                                "    Result* obj = ptr;\n"
+                                "    ++obj->total;\n"
+                                "}\n";
 
-        ASSERT_EQUALS("void f ( ) { r = a || b ; }",
-                      tok("void f() { r = a or b; }", "test.c", false));
+            const char expected[] = "void foo ( Result * ptr ) "
+                                    "{ "
+                                    "Result * obj ; obj = ptr ; "
+                                    "++ obj . total ; "
+                                    "}";
 
-        ASSERT_EQUALS("void f ( ) { r = ( a && b ) || ( c && d ) ; }",
-                      tok("void f() { r = (a && b) or (c && d); }", "test.c", false));
+            ASSERT_EQUALS(expected, tok(code));
+        }
     }
 
-    void cAlternativeTokens() {
-        ASSERT_EQUALS("void f ( ) { err |= ( ( r & s ) && ! t ) ; }",
-                      tok("void f() { err or_eq ((r bitand s) and not t); }", "test.c", false));
-        ASSERT_EQUALS("void f ( ) const { r = f ( a [ 4 ] | 15 , ~ c , ! d ) ; }",
-                      tok("void f() const { r = f(a[4] bitor 0x0F, compl c, not d) ; }", "test.c", false));
-
+    void pointeralias3() {
+        const char code[] = "void f()\n"
+                            "{\n"
+                            "    int i, j, *p;\n"
+                            "    if (ab) p = &i;\n"
+                            "    else p = &j;\n"
+                            "    *p = 0;\n"
+                            "}\n";
+        const char expected[] = "void f ( ) "
+                                "{"
+                                " int i ; int j ; int * p ;"
+                                " if ( ab ) { p = & i ; }"
+                                " else { p = & j ; }"
+                                " * p = 0 ; "
+                                "}";
+        ASSERT_EQUALS(expected, tok(code));
     }
 
-    void comma_keyword() {
+    void simplifyStructDecl1() {
         {
-            const char code[] = "void foo()\n"
-                                "{\n"
-                                "    char *a, *b;\n"
-                                "    delete a, delete b;\n"
-                                "}\n";
-            ASSERT_EQUALS("void foo ( ) { char * a ; char * b ; delete a ; delete b ; }", tok(code));
+            const char code[] = "struct ABC { } abc;";
+            const char expected[] = "struct ABC { } ; struct ABC abc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "void foo()\n"
-                                "{\n"
-                                "    struct A *a, *b;\n"
-                                "}\n";
-            ASSERT_EQUALS("void foo ( ) { struct A * a ; struct A * b ; }", tok(code));
+            const char code[] = "struct ABC { } * pabc;";
+            const char expected[] = "struct ABC { } ; struct ABC * pabc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "void foo()\n"
-                                "{\n"
-                                "    struct A **a, **b;\n"
-                                "}\n";
-            ASSERT_EQUALS("void foo ( ) { struct A * * a ; struct A * * b ; }", tok(code));
+            const char code[] = "struct ABC { } abc[4];";
+            const char expected[] = "struct ABC { } ; struct ABC abc [ 4 ] ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "void foo()\n"
-                                "{\n"
-                                "    char *a, *b;\n"
-                                "    delete a, b;\n"
-                                "}\n";
-            ASSERT_EQUALS("void foo ( ) { char * a ; char * b ; delete a ; b ; }", tok(code));
+            const char code[] = "struct ABC { } abc, def;";
+            const char expected[] = "struct ABC { } ; struct ABC abc ; struct ABC def ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "void foo()\n"
-                                "{\n"
-                                "    char *a, *b, *c;\n"
-                                "    delete a, b, c;\n"
-                                "}\n";
-            // delete a; b; c; would be better but this will do too
-            ASSERT_EQUALS("void foo ( ) { char * a ; char * b ; char * c ; delete a ; b , c ; }", tok(code));
+            const char code[] = "struct ABC { } abc, * pabc;";
+            const char expected[] = "struct ABC { } ; struct ABC abc ; struct ABC * pabc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "void foo()\n"
-                                "{\n"
-                                "    char *a, *b;\n"
-                                "    if (x) \n"
-                                "        delete a, b;\n"
-                                "}\n";
-            ASSERT_EQUALS("void foo ( ) { char * a ; char * b ; if ( x ) { delete a ; b ; } }", tok(code));
+            const char code[] = "struct ABC { struct DEF {} def; } abc;";
+            const char expected[] = "struct ABC { struct DEF { } ; struct DEF def ; } ; struct ABC abc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "void foo()\n"
-                                "{\n"
-                                "    char *a, *b, *c;\n"
-                                "    if (x) \n"
-                                "        delete a, b, c;\n"
-                                "}\n";
-            // delete a; b; c; would be better but this will do too
-            ASSERT_EQUALS("void foo ( ) { char * a ; char * b ; char * c ; if ( x ) { delete a ; b , c ; } }", tok(code));
+            const char code[] = "struct { } abc;";
+            const char expected[] = "struct Anonymous0 { } ; struct Anonymous0 abc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "void foo()\n"
-                                "{\n"
-                                "    char **a, **b, **c;\n"
-                                "}\n";
-            ASSERT_EQUALS("void foo ( ) { char * * a ; char * * b ; char * * c ; }", tok(code));
+            const char code[] = "struct { } * pabc;";
+            const char expected[] = "struct Anonymous0 { } ; struct Anonymous0 * pabc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "int f()\n"
-                                "{\n"
-                                "    if (something)\n"
-                                "        return a(2, c(3, 4)), b(3), 10;\n"
-                                "    return a(), b(0, 0, 0), 10;\n"
-                                "}\n";
-            ASSERT_EQUALS("int f ( )"
-                          " {"
-                          " if ( something )"
-                          " {"
-                          " a ( 2 , c ( 3 , 4 ) ) ;"
-                          " b ( 3 ) ;"
-                          " return 10 ;"
-                          " }"
-                          " a ( ) ;"
-                          " b ( 0 , 0 , 0 ) ;"
-                          " return 10 ; "
-                          "}", tok(code));
+            const char code[] = "struct { } abc[4];";
+            const char expected[] = "struct Anonymous0 { } ; struct Anonymous0 abc [ 4 ] ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "void foo()\n"
-                                "{\n"
-                                "    delete [] a, a = 0;\n"
-                                "}\n";
-            ASSERT_EQUALS("void foo ( ) { delete [ ] a ; a = 0 ; }", tok(code));
+            const char code[] = "struct {int a;} const array[3] = {0};";
+            const char expected[] = "struct Anonymous0 { int a ; } ; struct Anonymous0 const array [ 3 ] = { 0 } ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "void foo()\n"
-                                "{\n"
-                                "    delete a, a = 0;\n"
-                                "}\n";
-            ASSERT_EQUALS("void foo ( ) { delete a ; a = 0 ; }", tok(code));
+            const char code[] = "static struct {int a;} const array[3] = {0};";
+            const char expected[] = "struct Anonymous0 { int a ; } ; static struct Anonymous0 const array [ 3 ] = { 0 } ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "void foo()\n"
-                                "{\n"
-                                "    if( x ) delete a, a = 0;\n"
-                                "}\n";
-            ASSERT_EQUALS("void foo ( ) { if ( x ) { delete a ; a = 0 ; } }", tok(code));
+            const char code[] = "struct { } abc, def;";
+            const char expected[] = "struct Anonymous0 { } ; struct Anonymous0 abc ; struct Anonymous0 def ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "void f()\n"
-                                "{\n"
-                                "    for(int a,b; a < 10; a = a + 1, b = b + 1);\n"
-                                "}\n";
-            ASSERT_EQUALS("void f ( ) { for ( int a , b ; a < 10 ; a = a + 1 , b = b + 1 ) { ; } }", tok(code));
+            const char code[] = "struct { } abc, * pabc;";
+            const char expected[] = "struct Anonymous0 { } ; struct Anonymous0 abc ; struct Anonymous0 * pabc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "void f()\n"
-                                "{\n"
-                                "    char buf[BUFSIZ], **p;\n"
-                                "    char *ptrs[BUFSIZ], **pp;\n"
-                                "}\n";
-            ASSERT_EQUALS("void f ( ) { char buf [ BUFSIZ ] ; char * * p ; char * ptrs [ BUFSIZ ] ; char * * pp ; }", tok(code));
+            const char code[] = "struct { struct DEF {} def; } abc;";
+            const char expected[] = "struct Anonymous0 { struct DEF { } ; struct DEF def ; } ; struct Anonymous0 abc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            // #4786 - don't replace , with ; in ".. : public B, C .." code
-            const char code[] = "template < class T = X > class A : public B , C { } ;";
-            ASSERT_EQUALS(code, tok(code));
+            const char code[] = "struct ABC { struct {} def; } abc;";
+            const char expected[] = "struct ABC { struct Anonymous0 { } ; struct Anonymous0 def ; } ; struct ABC abc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
-    }
 
-    void remove_comma() {
         {
-            const char code[] = "void f()\n"
-                                "{\n"
-                                "  int a,b;\n"
-                                "  if( a )\n"
-                                "  a=0,\n"
-                                "  b=0;\n"
-                                "}\n";
-            ASSERT_EQUALS("void f ( ) { int a ; int b ; if ( a ) { a = 0 ; b = 0 ; } }", tok(code));
+            const char code[] = "struct { struct {} def; } abc;";
+            const char expected[] = "struct Anonymous0 { struct Anonymous1 { } ; struct Anonymous1 def ; } ; struct Anonymous0 abc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            ASSERT_EQUALS("a ? ( b = c , d ) : e ;", tok("a ? b = c , d : e ;")); // Keep comma
+            const char code[] = "union ABC { int i; float f; } abc;";
+            const char expected[] = "union ABC { int i ; float f ; } ; union ABC abc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            ASSERT_EQUALS("; return a ? ( b = c , d ) : e ;", tok("; return a ? b = c , d : e ;")); // Keep comma
+            const char code[] = "struct ABC { struct {} def; };";
+            const char expected[] = "struct ABC { struct Anonymous0 { } ; struct Anonymous0 def ; } ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "void f()\n"
-                                "{\n"
-                                "  A a,b;\n"
-                                "  if( a.f )\n"
-                                "  a.f=b.f,\n"
-                                "  a.g=b.g;\n"
-                                "}\n";
-            ASSERT_EQUALS("void f ( ) { A a ; A b ; if ( a . f ) { a . f = b . f ; a . g = b . g ; } }", tok(code));
+            const char code[] = "struct ABC : public XYZ { struct {} def; };";
+            const char expected[] = "struct ABC : public XYZ { struct Anonymous0 { } ; struct Anonymous0 def ; } ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
-        // keep the comma in template specifiers..
         {
-            const char code[] = "void f()\n"
-                                "{\n"
-                                "  int a = b<T<char,3>, int>();\n"
-                                "}\n";
-            ASSERT_EQUALS("void f ( ) { int a ; a = b < T < char , 3 > , int > ( ) ; }", tok(code));
+            const char code[] = "struct { int x; }; int y;";
+            const char expected[] = "int x ; int y ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "void f() {\n"
-                                "  a = new std::map<std::string, std::string>;\n"
-                                "}\n";
-            ASSERT_EQUALS("void f ( ) { a = new std :: map < std :: string , std :: string > ; }", tok(code));
+            const char code[] = "struct { int x; };";
+            const char expected[] = "int x ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            // ticket #1327
-            const char code[] = "const C<1,2,3> foo ()\n"
-                                "{\n"
-                                "    return C<1,2,3>(x,y);\n"
-                                "}\n";
-            const char expected[]  = "const C < 1 , 2 , 3 > foo ( ) "
-                                     "{"
-                                     " return C < 1 , 2 , 3 > ( x , y ) ; "
-                                     "}";
+            const char code[] = "struct { };";
+            const char expected[] = ";";
             ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "int foo ()\n"
-                                "{\n"
-                                "    return doSomething(), 0;\n"
-                                "}\n";
-            const char expected[]  = "int foo ( ) "
-                                     "{"
-                                     " doSomething ( ) ; return 0 ; "
-                                     "}";
+            const char code[] = "struct { struct { struct { } ; } ; };";
+            const char expected[] = ";";
             ASSERT_EQUALS(expected, tok(code));
         }
 
+        // ticket 2464
         {
-            const char code[] = "int foo ()\n"
-                                "{\n"
-                                "    return a=1, b=2;\n"
-                                "}\n";
-            const char expected[]  = "int foo ( ) "
-                                     "{"
-                                     " a = 1 ; return b = 2 ; "
-                                     "}";
+            const char code[] = "static struct ABC { } abc ;";
+            const char expected[] = "struct ABC { } ; static struct ABC abc ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
+        // ticket #980
         {
-            const char code[]     = "tr = (struct reg){ .a = (1), .c = (2) };";
-            const char expected[] = "tr = ( struct reg ) { . a = 1 , . c = 2 } ;";
+            const char code[] = "void f() { int A(1),B(2),C=3,D,E(5),F=6; }";
+            const char expected[] = "void f ( ) { int A ( 1 ) ; int B ( 2 ) ; int C ; C = 3 ; int D ; int E ( 5 ) ; int F ; F = 6 ; }";
             ASSERT_EQUALS(expected, tok(code));
         }
-    }
 
-    void simplifyConditionOperator() {
+        // ticket #8284
         {
-            const char code[] = "(0?(false?1:2):3);";
-            ASSERT_EQUALS("( 3 ) ;", tok(code));
+            const char code[] = "void f() { class : foo<int> { } abc; }";
+            const char expected[] = "void f ( ) { class Anonymous0 : foo < int > { } ; Anonymous0 abc ; }";
+            ASSERT_EQUALS(expected, tok(code));
         }
+    }
 
-        {
-            const char code[] = "(1?(false?1:2):3);";
-            ASSERT_EQUALS("( 2 ) ;", tok(code));
-        }
+    void simplifyStructDecl2() { // ticket #2479 (segmentation fault)
+        const char code[] = "struct { char c; }";
+        const char expected[] = "struct { char c ; }";
+        ASSERT_EQUALS(expected, tok(code));
+    }
 
+    void simplifyStructDecl3() {
         {
-            const char code[] = "int a = (1?0:1 == 1?0:1);";
-            ASSERT_EQUALS("int a ; a = 0 ;", tok(code));
+            const char code[] = "class ABC { } abc;";
+            const char expected[] = "class ABC { } ; ABC abc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "(1?0:foo());";
-            ASSERT_EQUALS("( 0 ) ;", tok(code));
+            const char code[] = "class ABC { } * pabc;";
+            const char expected[] = "class ABC { } ; ABC * pabc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "void f () { switch(n) { case 1?0:foo(): break; }}";
-            ASSERT_EQUALS("void f ( ) { switch ( n ) { case 0 : ; break ; } }", tok(code));
+            const char code[] = "class ABC { } abc[4];";
+            const char expected[] = "class ABC { } ; ABC abc [ 4 ] ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "void f () { switch(n) { case 1?0?1:0:foo(): break; }}";
-            TODO_ASSERT_EQUALS("void f ( ) { switch ( n ) { case 0 : ; break ; } }", "void f ( ) { switch ( n ) { case ( 0 ) : ; break ; } }", tok(code));
+            const char code[] = "class ABC { } abc, def;";
+            const char expected[] = "class ABC { } ; ABC abc ; ABC def ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "void f () { switch(n) { case 0?foo():1: break; }}";
-            ASSERT_EQUALS("void f ( ) { switch ( n ) { case 1 : ; break ; } }", tok(code));
+            const char code[] = "class ABC { } abc, * pabc;";
+            const char expected[] = "class ABC { } ; ABC abc ; ABC * pabc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "( true ? a ( ) : b ( ) );";
-            ASSERT_EQUALS("( a ( ) ) ;", tok(code));
+            const char code[] = "class ABC { class DEF {} def; } abc;";
+            const char expected[] = "class ABC { class DEF { } ; DEF def ; } ; ABC abc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "( true ? abc . a : abc . b );";
-            ASSERT_EQUALS("( abc . a ) ;", tok(code));
+            const char code[] = "class { } abc;";
+            const char expected[] = "class { } abc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "void f()\n"
-                                "{\n"
-                                "  bool x = false;\n"
-                                "  int b = x ? 44 : 3;\n"
-                                "}\n";
-            ASSERT_EQUALS("void f ( ) { }", tok(code));
+            const char code[] = "class { } * pabc;";
+            const char expected[] = "class { } * pabc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "int vals[] = { 0x13, 1?0x01:0x00 };";
-            ASSERT_EQUALS("int vals [ 2 ] = { 19 , 1 } ;", tok(code));
+            const char code[] = "class { } abc[4];";
+            const char expected[] = "class { } abc [ 4 ] ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "int vals[] = { 0x13, 0?0x01:0x00 };";
-            ASSERT_EQUALS("int vals [ 2 ] = { 19 , 0 } ;", tok(code));
+            const char code[] = "class { } abc, def;";
+            const char expected[] = "class { } abc , def ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            const char code[] = "a = 1 ? 0 : ({ 0; });";
-            ASSERT_EQUALS("a = 0 ;", tok(code));
+            const char code[] = "class { } abc, * pabc;";
+            const char expected[] = "class { } abc , * pabc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
-        //GNU extension: "x ?: y" <-> "x ? x : y"
         {
-            const char code[] = "; a = 1 ? : x; b = 0 ? : 2;";
-            ASSERT_EQUALS("; a = 1 ; b = 2 ;", tok(code));
+            const char code[] = "struct { class DEF {} def; } abc;";
+            const char expected[] = "struct Anonymous0 { class DEF { } ; DEF def ; } ; struct Anonymous0 abc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
-        // Ticket #3572 (segmentation fault)
-        ASSERT_EQUALS("0 ; x = { ? y : z ; }", tok("0; x = { ? y : z; }"));
-
         {
-            // #3922 - (true)
-            ASSERT_EQUALS("; x = 2 ;", tok("; x = (true)?2:4;"));
-            ASSERT_EQUALS("; x = 4 ;", tok("; x = (false)?2:4;"));
-            ASSERT_EQUALS("; x = * a ;", tok("; x = (true)?*a:*b;"));
-            ASSERT_EQUALS("; x = * b ;", tok("; x = (false)?*a:*b;"));
-            ASSERT_EQUALS("void f ( ) { return 1 ; }", tok("void f() { char *p=0; return (p==0)?1:2; }"));
+            const char code[] = "class ABC { struct {} def; } abc;";
+            const char expected[] = "class ABC { struct Anonymous0 { } ; struct Anonymous0 def ; } ; ABC abc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
-            ASSERT_EQUALS("; type = decay_t < decltype ( declval < T > ( ) ) > ;",
-                          tok("; type = decay_t<decltype(true ? declval<T>() : declval<U>())>;"));
-            ASSERT_EQUALS("; type = decay_t < decltype ( declval < U > ( ) ) > ;",
-                          tok("; type = decay_t<decltype(false ? declval<T>() : declval<U>())>;"));
+            const char code[] = "class { class {} def; } abc;";
+            const char expected[] = "class { class { } def ; } abc ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
-    }
 
-    void calculations() {
-        {
-            const char code[] = "a[i+8+2];";
-            ASSERT_EQUALS("a [ i + 10 ] ;", tok(code));
-        }
         {
-            const char code[] = "a[8+2+i];";
-            ASSERT_EQUALS("a [ 10 + i ] ;", tok(code));
+            const char code[] = "class ABC { struct {} def; };";
+            const char expected[] = "class ABC { struct Anonymous0 { } ; struct Anonymous0 def ; } ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
+
         {
-            const char code[] = "a[i + 2 * (2 * 4)];";
-            ASSERT_EQUALS("a [ i + 16 ] ;", tok(code));
+            const char code[] = "class ABC : public XYZ { struct {} def; };";
+            const char expected[] = "class ABC : public XYZ { struct Anonymous0 { } ; struct Anonymous0 def ; } ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
+
         {
-            const char code[] = "a[i + 100 - 90];";
-            ASSERT_EQUALS("a [ i + 10 ] ;", tok(code));
+            const char code[] = "class { int x; }; int y;";
+            const char expected[] = "class { int x ; } ; int y ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
+
         {
-            const char code[] = "a[1+1+1+1+1+1+1+1+1+1-2+5-3];";
-            ASSERT_EQUALS("a [ 10 ] ;", tok(code));
+            const char code[] = "class { int x; };";
+            const char expected[] = "class { int x ; } ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
+
         {
-            const char code[] = "a[10+10-10-10];";
-            ASSERT_EQUALS("a [ 0 ] ;", tok(code));
+            const char code[] = "class { };";
+            const char expected[] = "class { } ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
+    }
 
-        ASSERT_EQUALS("a [ 4 ] ;", tok("a[1+3|4];"));
+    void simplifyStructDecl4() {
+        const char code[] = "class ABC {\n"
+                            "    void foo() {\n"
+                            "        union {\n"
+                            "            int i;\n"
+                            "            float f;\n"
+                            "        };\n"
+                            "        struct Fee { } fee;\n"
+                            "    }\n"
+                            "    union {\n"
+                            "        long long ll;\n"
+                            "        double d;\n"
+                            "    };\n"
+                            "} abc;\n";
+        const char expected[] = "class ABC { "
+                                "void foo ( ) { "
+                                "union { int i ; float f ; } ; "
+                                "struct Fee { } ; struct Fee fee ; "
+                                "} "
+                                "union { "
+                                "long ll ; "
+                                "double d ; "
+                                "} ; "
+                                "} ; ABC abc ;";
+        ASSERT_EQUALS(expected, tok(code));
+    }
 
-        ASSERT_EQUALS("x = 1 + 2 * y ;", tok("x=1+2*y;"));
-        ASSERT_EQUALS("x = 7 ;", tok("x=1+2*3;"));
-        ASSERT_EQUALS("x = 47185 ;", tok("x=(65536*72/100);"));
-        ASSERT_EQUALS("x = 900 ;", tok("x = 1500000 / ((145000 - 55000) * 1000 / 54000);"));
-        ASSERT_EQUALS("int a [ 8 ] ;", tok("int a[5+6/2];"));
-        ASSERT_EQUALS("int a [ 4 ] ;", tok("int a[(10)-1-5];"));
-        ASSERT_EQUALS("int a [ i - 9 ] ;", tok("int a[i - 10 + 1];"));
+    void simplifyStructDecl6() {
+        ASSERT_EQUALS("struct A { "
+                      "char integers [ X ] ; "
+                      "} ; struct A arrays ; arrays = { { 0 } } ;",
+                      tok("struct A {\n"
+                          "    char integers[X];\n"
+                          "} arrays = {{0}};"));
+    }
 
-        ASSERT_EQUALS("x = y ;", tok("x=0+y+0-0;"));
-        ASSERT_EQUALS("x = 0 ;", tok("x=0*y;"));
+    void simplifyStructDecl7() {
+        ASSERT_EQUALS("struct Anonymous0 { char x ; } ; struct Anonymous0 a [ 2 ] ;",
+                      tok("struct { char x; } a[2];"));
+        ASSERT_EQUALS("struct Anonymous0 { char x ; } ; static struct Anonymous0 a [ 2 ] ;",
+                      tok("static struct { char x; } a[2];"));
+    }
 
-        ASSERT_EQUALS("x = 501 ;", tok("x = 1000 + 2 >> 1;"));
-        ASSERT_EQUALS("x = 125 ;", tok("x = 1000 / 2 >> 2;"));
+    void simplifyStructDecl8() {
+        ASSERT_EQUALS("enum A { x , y , z } ; enum A a ; a = x ;", tok("enum A { x, y, z } a(x);"));
+        ASSERT_EQUALS("enum B { x , y , z } ; enum B b ; b = x ;", tok("enum B { x , y, z } b{x};"));
+        ASSERT_EQUALS("struct C { int i ; } ; struct C c ; c = C { 0 } ;", tok("struct C { int i; } c{0};"));
+        ASSERT_EQUALS("enum Anonymous0 { x , y , z } ; enum Anonymous0 d ; d = x ;", tok("enum { x, y, z } d(x);"));
+        ASSERT_EQUALS("enum Anonymous0 { x , y , z } ; enum Anonymous0 e ; e = x ;", tok("enum { x, y, z } e{x};"));
+        ASSERT_EQUALS("struct Anonymous0 { int i ; } ; struct Anonymous0 f ; f = Anonymous0 { 0 } ;", tok("struct { int i; } f{0};"));
+        ASSERT_EQUALS("struct Anonymous0 { } ; struct Anonymous0 x ; x = { 0 } ;", tok("struct {} x = {0};"));
+        ASSERT_EQUALS("enum G : short { x , y , z } ; enum G g ; g = x ;", tok("enum G : short { x, y, z } g(x);"));
+        ASSERT_EQUALS("enum H : short { x , y , z } ; enum H h ; h = x ;", tok("enum H : short { x, y, z } h{x};"));
+        ASSERT_EQUALS("enum class I : short { x , y , z } ; enum I i ; i = x ;", tok("enum class I : short { x, y, z } i(x);"));
+        ASSERT_EQUALS("enum class J : short { x , y , z } ; enum J j ; j = x ;", tok("enum class J : short { x, y, z } j{x};"));
+    }
+
+    void simplifyStructDecl9() {
+        const char *exp{};
+        {
+            const char code[] = "enum E : int;\n" // #12588
+                                "void f() {}\n"
+                                "namespace {\n"
+                                "    struct S {\n"
+                                "        explicit S(int i) : m(i) {}\n"
+                                "        int m;\n"
+                                "    };\n"
+                                "}\n"
+                                "void g() { S s(0); }\n";
+            exp = "enum E : int ; "
+                  "void f ( ) { } "
+                  "namespace { "
+                  "struct S { "
+                  "explicit S ( int i ) : m ( i ) { } "
+                  "int m ; "
+                  "} ; "
+                  "} "
+                  "void g ( ) { S s ( 0 ) ; }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+
+        {
+            const char code[] = "struct S {\n" // 12595
+                                "    explicit S() {\n"
+                                "        e = E1;\n"
+                                "    }\n"
+                                "    enum { E1 } e = E1;\n"
+                                "};\n";
+            exp = "struct S { "
+                  "explicit S ( ) { e = E1 ; } "
+                  "enum Anonymous0 { E1 } ; "
+                  "enum Anonymous0 e ; "
+                  "e = E1 ; "
+                  "} ;";
+            ASSERT_EQUALS(exp, tok(code));
+        }
 
         {
-            // Ticket #1997
-            const char code[] = "void * operator new[](size_t);";
-            ASSERT_EQUALS("void * operatornew[] ( long ) ;", tok(code, true, Settings::Win32A));
+            const char code[] = "struct S {\n"
+                                "    explicit S() {\n"
+                                "        e = E1;\n"
+                                "    }\n"
+                                "    enum : std::uint8_t { E1 } e = E1;\n"
+                                "};\n";
+            exp = "struct S { "
+                  "explicit S ( ) { e = E1 ; } "
+                  "enum Anonymous0 : std :: uint8_t { E1 } ; "
+                  "enum Anonymous0 e ; "
+                  "e = E1 ; "
+                  "} ;";
+            ASSERT_EQUALS(exp, tok(code));
         }
+    }
 
-        ASSERT_EQUALS("; a [ 0 ] ;", tok(";a[0*(*p)];"));
-
-        ASSERT_EQUALS(";", tok("; x = x + 0;"));
-
-        ASSERT_EQUALS("if ( a == 2 ) { ; }", tok("if (a==1+1);"));
-        ASSERT_EQUALS("if ( a + 2 != 6 ) { ; }", tok("if (a+1+1!=1+2+3);"));
-        ASSERT_EQUALS("if ( 4 < a ) { ; }", tok("if (14-2*5<a*4/(2*2));"));
+    void removeUnwantedKeywords() {
+        ASSERT_EQUALS("int var ;", tok("register int var ;"));
+        ASSERT_EQUALS("short var ;", tok("register short int var ;"));
+        ASSERT_EQUALS("int foo ( ) { }", tok("inline int foo ( ) { }"));
+        ASSERT_EQUALS("int foo ( ) { }", tok("__inline int foo ( ) { }"));
+        ASSERT_EQUALS("int foo ( ) { }", tok("__forceinline int foo ( ) { }"));
+        ASSERT_EQUALS("constexpr int foo ( ) { }", tok("constexpr int foo() { }"));
+        ASSERT_EQUALS("constexpr int foo ( ) { }", tok("consteval int foo() { }"));
+        ASSERT_EQUALS("int x ; x = 0 ;", tok("constinit int x = 0;"));
+        ASSERT_EQUALS("void f ( ) { int final [ 10 ] ; }", tok("void f() { int final[10]; }"));
+        ASSERT_EQUALS("int * p ;", tok("int * __restrict p;", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("int * * p ;", tok("int * __restrict__ * p;", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("void foo ( float * a , float * b ) ;", tok("void foo(float * __restrict__ a, float * __restrict__ b);", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("int * p ;", tok("int * restrict p;", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("int * * p ;", tok("int * restrict * p;", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("void foo ( float * a , float * b ) ;", tok("void foo(float * restrict a, float * restrict b);", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("void foo ( int restrict ) ;", tok("void foo(int restrict);"));
+        ASSERT_EQUALS("int * p ;", tok("typedef int * __restrict__ rint; rint p;", dinit(TokOptions, $.cpp = false)));
 
-        ASSERT_EQUALS("( y / 2 - 2 ) ;", tok("(y / 2 - 2);"));
-        ASSERT_EQUALS("( y % 2 - 2 ) ;", tok("(y % 2 - 2);"));
+        // don't remove struct members:
+        ASSERT_EQUALS("a = b . _inline ;", tok("a = b._inline;"));
 
-        ASSERT_EQUALS("( 4 ) ;", tok("(1 * 2 / 1 * 2);")); // #3722
+        ASSERT_EQUALS("int i ; i = 0 ;", tok("auto int i = 0;", dinit(TokOptions, $.cpp = false)));
+        ASSERT_EQUALS("auto i ; i = 0 ;", tok("auto i = 0;"));
+    }
 
-        ASSERT_EQUALS("x ( 60129542144 ) ;", tok("x(14<<4+17<<300%17);")); // #4931
-        ASSERT_EQUALS("x ( 1 ) ;", tok("x(8|5&6+0 && 7);")); // #6104
-        ASSERT_EQUALS("x ( 1 ) ;", tok("x(2 && 4<<4<<5 && 4);")); // #4933
-        ASSERT_EQUALS("x ( 1 ) ;", tok("x(9&&8%5%4/3);")); // #4931
-        ASSERT_EQUALS("x ( 1 ) ;", tok("x(2 && 2|5<<2%4);")); // #4931
-        ASSERT_EQUALS("x ( -2 << 6 | 1 ) ;", tok("x(1-3<<6|5/3);")); // #4931
-        ASSERT_EQUALS("x ( 2 ) ;", tok("x(2|0*0&2>>1+0%2*1);")); // #4931
-        ASSERT_EQUALS("x ( 0 & 4 != 1 ) ;", tok("x(4%1<<1&4!=1);")); // #4931 (can be simplified further but it's not a problem)
-        ASSERT_EQUALS("x ( true ) ;", tok("x(0&&4>0==2||4);")); // #4931
+    void simplifyCallingConvention() {
+        ASSERT_EQUALS("int f ( ) ;", tok("int __cdecl f();"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __stdcall f();"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __fastcall f();"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __clrcall f();"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __thiscall f();"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __syscall f();"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __pascal f();"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __fortran f();"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __far __cdecl f();"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __far __stdcall f();"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __far __fastcall f();"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __far __clrcall f();"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __far __thiscall f();"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __far __syscall f();"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __far __pascal f();"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int __far __fortran f();"));
+        ASSERT_EQUALS("int f ( ) ;", tok("int WINAPI f();", dinit(TokOptions, $.type = Platform::Type::Win32A)));
+        ASSERT_EQUALS("int f ( ) ;", tok("int APIENTRY f();", dinit(TokOptions, $.type = Platform::Type::Win32A)));
+        ASSERT_EQUALS("int f ( ) ;", tok("int CALLBACK f();", dinit(TokOptions, $.type = Platform::Type::Win32A)));
 
-        // don't remove these spaces..
-        ASSERT_EQUALS("new ( auto ) ( 4 ) ;", tok("new (auto)(4);"));
+        // don't simplify Microsoft defines in unix code (#7554)
+        ASSERT_EQUALS("enum E { CALLBACK } ;", tok("enum E { CALLBACK } ;", dinit(TokOptions, $.type = Platform::Type::Unix32)));
     }
 
-    void comparisons() {
-        ASSERT_EQUALS("( 1 ) ;", tok("( 1 < 2 );"));
-        ASSERT_EQUALS("( x && true ) ;", tok("( x && 1 < 2 );"));
-        ASSERT_EQUALS("( 5 ) ;", tok("( 1 < 2 && 3 < 4 ? 5 : 6 );"));
-        ASSERT_EQUALS("( 6 ) ;", tok("( 1 > 2 && 3 > 4 ? 5 : 6 );"));
+    void simplifyAttribute() {
+        ASSERT_EQUALS("int f ( ) ;", tok("__attribute__ ((visibility(\"default\"))) int f();"));
+        ASSERT_EQUALS("int f ( ) ;", tok("__attribute__((visibility(\"default\"))) int f();"));
+        ASSERT_EQUALS("int f ( ) ;", tok("__attribute ((visibility(\"default\"))) int f();"));
+        ASSERT_EQUALS("int f ( ) ;", tok("__attribute__ ((visibility(\"default\"))) __attribute__ ((warn_unused_result)) int f();"));
+        ASSERT_EQUALS("blah :: blah f ( ) ;", tok("__attribute__ ((visibility(\"default\"))) blah::blah f();"));
+        ASSERT_EQUALS("template < T > Result < T > f ( ) ;", tok("template<T> __attribute__ ((warn_unused_result)) Result<T> f();"));
+        ASSERT_EQUALS("template < T , U > Result < T , U > f ( ) ;", tok("template<T, U> __attribute__ ((warn_unused_result)) Result<T, U> f();"));
+        ASSERT_EQUALS("void ( * fp ) ( ) ; fp = nullptr ;", tok("typedef void (*fp_t)() __attribute__((noreturn)); fp_t fp = nullptr;")); // #12137
     }
 
-
-    void simplifyFlowControl() {
-        const char code1[] = "void f() {\n"
-                             "  return;\n"
-                             "  y();\n"
-                             "}";
-        ASSERT_EQUALS("void f ( ) { return ; }", tokWithStdLib(code1));
-
-        const char code2[] = "void f() {\n"
-                             "  exit(0);\n"
-                             "  y();\n"
-                             "}";
-        ASSERT_EQUALS("void f ( ) { exit ( 0 ) ; }", tokWithStdLib(code2));
-
-        const char code3[] = "void f() {\n"
-                             "  x.abort();\n"
-                             "  y();\n"
-                             "}";
-        ASSERT_EQUALS("void f ( ) { x . abort ( ) ; y ( ) ; }", tokWithStdLib(code3));
+    void simplifyFunctorCall() {
+        ASSERT_EQUALS("IncrementFunctor ( ) ( a ) ;", tok("IncrementFunctor()(a);"));
     }
 
-    void flowControl() {
-        {
-            ASSERT_EQUALS("void f ( ) { exit ( 0 ) ; }", tokWithStdLib("void f() { exit(0); foo(); }"));
-            ASSERT_EQUALS("void f ( ) { exit ( 0 ) ; }", tokWithStdLib("void f() { exit(0); if (m) foo(); }"));
-            ASSERT_EQUALS("void f ( int n ) { if ( n ) { exit ( 0 ) ; } foo ( ) ; }", tokWithStdLib("void f(int n) { if (n) { exit(0); } foo(); }"));
-            ASSERT_EQUALS("void f ( ) { exit ( 0 ) ; }", tokWithStdLib("void f() { exit(0); dead(); switch (n) { case 1: deadcode () ; default: deadcode (); } }"));
-
-            ASSERT_EQUALS("int f ( int n ) { switch ( n ) { case 0 : ; exit ( 0 ) ; default : ; exit ( 0 ) ; } exit ( 0 ) ; }",
-                          tokWithStdLib("int f(int n) { switch (n) {case 0: exit(0); n*=2; default: exit(0); n*=6;} exit(0); foo();}"));
-            //ticket #3132
-            ASSERT_EQUALS("void f ( int i ) { goto label ; { label : ; exit ( 0 ) ; } }", tokWithStdLib("void f (int i) { goto label; switch(i) { label: exit(0); } }"));
-            //ticket #3148
-            ASSERT_EQUALS("void f ( ) { MACRO ( exit ( 0 ) ) }", tokWithStdLib("void f() { MACRO(exit(0)) }"));
-            ASSERT_EQUALS("void f ( ) { MACRO ( exit ( 0 ) ; , NULL ) }", tokWithStdLib("void f() { MACRO(exit(0);, NULL) }"));
-            ASSERT_EQUALS("void f ( ) { MACRO ( bar1 , exit ( 0 ) ) }", tokWithStdLib("void f() { MACRO(bar1, exit(0)) }"));
-            ASSERT_EQUALS("void f ( ) { MACRO ( exit ( 0 ) ; bar2 , foo ) }", tokWithStdLib("void f() { MACRO(exit(0); bar2, foo) }"));
-        }
-
-        {
-            const char* code = "void f(){ "
-                               "   if (k>0) goto label; "
-                               "   exit(0); "
-                               "   if (tnt) "
-                               "   { "
-                               "       { "
-                               "           check(); "
-                               "           k=0; "
-                               "       } "
-                               "       label: "
-                               "       bar(); "
-                               "   } "
-                               "}";
-            ASSERT_EQUALS("void f ( ) { if ( k > 0 ) { goto label ; } exit ( 0 ) ; { label : ; bar ( ) ; } }", tokWithStdLib(code));
-        }
+    // #ticket #5339 (simplify function pointer after comma)
+    void simplifyFunctionPointer() {
+        ASSERT_EQUALS("f ( double x , double ( * y ) ( ) ) ;", tok("f (double x, double (*y) ());"));
+    }
 
+    void simplifyFunctionReturn() {
         {
-            const char* code = "void foo () {"
-                               "    exit(0);"
-                               "    {"
-                               "        boo();"
-                               "        while (n) { --n; }"
-                               "        {"
-                               "            label:"
-                               "            ok();"
-                               "        }"
-                               "    }"
-                               "}";
-            ASSERT_EQUALS("void foo ( ) { exit ( 0 ) ; { label : ; ok ( ) ; } }", tokWithStdLib(code));
+            const char code[] = "typedef void (*testfp)();\n"
+                                "struct Fred\n"
+                                "{\n"
+                                "    testfp get1() { return 0; }\n"
+                                "    void ( * get2 ( ) ) ( ) { return 0 ; }\n"
+                                "    testfp get3();\n"
+                                "    void ( * get4 ( ) ) ( );\n"
+                                "};";
+            const char expected[] = "struct Fred "
+                                    "{ "
+                                    "void * get1 ( ) { return 0 ; } "
+                                    "void * get2 ( ) { return 0 ; } "
+                                    "void * get3 ( ) ; "
+                                    "void * get4 ( ) ; "
+                                    "} ;";
+            ASSERT_EQUALS(expected, tok(code));
         }
-
         {
-            const char* code = "void foo () {"
-                               "    exit(0);"
-                               "    switch (n) {"
-                               "        case 1:"
-                               "            label:"
-                               "            foo(); break;"
-                               "        default:"
-                               "            break;"
-                               "    }"
-                               "}";
-            const char* expected = "void foo ( ) { exit ( 0 ) ; { label : ; foo ( ) ; break ; } }";
-            ASSERT_EQUALS(expected, tokWithStdLib(code));
+            const char code[] = "class Fred {\n"
+                                "    std::string s;\n"
+                                "    const std::string & foo();\n"
+                                "};\n"
+                                "const std::string & Fred::foo() { return \"\"; }";
+            const char expected[] = "class Fred { "
+                                    "std :: string s ; "
+                                    "const std :: string & foo ( ) ; "
+                                    "} ; "
+                                    "const std :: string & Fred :: foo ( ) { return \"\" ; }";
+            ASSERT_EQUALS(expected, tok(code));
         }
-
         {
-            const char* code = "void foo () {"
-                               "    exit(0);"
-                               "    switch (n) {"
-                               "        case 1:"
-                               "            {"
-                               "                foo();"
-                               "            }"
-                               "            label:"
-                               "            bar();"
-                               "    }"
-                               "}";
-            const char* expected = "void foo ( ) { exit ( 0 ) ; { label : ; bar ( ) ; } }";
-            ASSERT_EQUALS(expected, tokWithStdLib(code));
+            // Ticket #7916
+            // Tokenization would include "int fact < 2 > ( ) { return 2 > ( ) ; }" and generate
+            // a parse error (and use after free)
+            const char code[] = "extern \"C\" void abort ();\n"
+                                "template <int a> inline int fact2 ();\n"
+                                "template <int a> inline int fact () {\n"
+                                "  return a * fact2<a-1> ();\n"
+                                "}\n"
+                                "template <> inline int fact<1> () {\n"
+                                "  return 1;\n"
+                                "}\n"
+                                "template <int a> inline int fact2 () {\n"
+                                "  return a * fact<a-1>();\n"
+                                "}\n"
+                                "template <> inline int fact2<1> () {\n"
+                                "  return 1;\n"
+                                "}\n"
+                                "int main() {\n"
+                                "  fact2<3> ();\n"
+                                "  fact2<2> ();\n"
+                                "}";
+            (void)tok(code);
         }
+    }
 
-        {
-            const char* code = "void foo () {"
-                               "    exit(0);"
-                               "    switch (n) {"
-                               "        case a:"
-                               "            {"
-                               "                foo();"
-                               "            }"
-                               "        case b|c:"
-                               "            bar();"
-                               "    }"
-                               "}";
-            const char* expected = "void foo ( ) { exit ( 0 ) ; }";
-            ASSERT_EQUALS(expected, tokWithStdLib(code));
-        }
+    void consecutiveBraces() {
+        ASSERT_EQUALS("void f ( ) { }", tok("void f(){{}}"));
+        ASSERT_EQUALS("void f ( ) { }", tok("void f(){{{}}}"));
+        ASSERT_EQUALS("void f ( ) { for ( ; ; ) { } }", tok("void f () { for(;;){} }"));
+        ASSERT_EQUALS("void f ( ) { { scope_lock lock ; foo ( ) ; } { scope_lock lock ; bar ( ) ; } }", tok("void f () { {scope_lock lock; foo();} {scope_lock lock; bar();} }"));
+    }
 
-        {
-            const char* code = "void foo () {"
-                               "    exit(0);"
-                               "    switch (n) {"
-                               "        case 1:"
-                               "            label:"
-                               "            foo(); break;"
-                               "        default:"
-                               "            break; break;"
-                               "    }"
-                               "}";
-            const char* expected = "void foo ( ) { exit ( 0 ) ; { label : ; foo ( ) ; break ; } }";
-            ASSERT_EQUALS(expected, tokWithStdLib(code));
-        }
+    void simplifyOverride() { // ticket #5069
+        const char code[] = "void fun() {\n"
+                            "    unsigned char override[] = {0x01, 0x02};\n"
+                            "    doSomething(override, sizeof(override));\n"
+                            "}\n";
+        ASSERT_EQUALS("void fun ( ) { char override [ 2 ] = { 0x01 , 0x02 } ; doSomething ( override , sizeof ( override ) ) ; }",
+                      tok(code));
+    }
 
-        {
-            const char* code = "void foo () {"
-                               "    exit(0);"
-                               "    switch (n) {"
-                               "        case 1:"
-                               "            label:"
-                               "            foo(); break; break;"
-                               "        default:"
-                               "            break;"
-                               "    }"
-                               "}";
-            const char* expected = "void foo ( ) { exit ( 0 ) ; { label : ; foo ( ) ; break ; } }";
-            ASSERT_EQUALS(expected, tokWithStdLib(code));
-        }
+    void simplifyNestedNamespace() {
+        ASSERT_EQUALS("namespace A { namespace B { namespace C { int i ; } } }", tok("namespace A::B::C { int i; }"));
+    }
 
-        {
-            const char* code = "void foo () {"
-                               "    exit(0);"
-                               "    switch (n) {"
-                               "        case 1:"
-                               "            label:"
-                               "            foo(); break; break;"
-                               "        default:"
-                               "            break; break;"
+    void simplifyNamespaceAliases1() {
+        ASSERT_EQUALS(";",
+                      tok("namespace ios = boost::iostreams;"));
+        ASSERT_EQUALS("boost :: iostreams :: istream foo ( \"foo\" ) ;",
+                      tok("namespace ios = boost::iostreams; ios::istream foo(\"foo\");"));
+        ASSERT_EQUALS("boost :: iostreams :: istream foo ( \"foo\" ) ;",
+                      tok("using namespace std; namespace ios = boost::iostreams; ios::istream foo(\"foo\");"));
+        ASSERT_EQUALS(";",
+                      tok("using namespace std; namespace ios = boost::iostreams;"));
+        ASSERT_EQUALS("namespace NS { boost :: iostreams :: istream foo ( \"foo\" ) ; }",
+                      tok("namespace NS { using namespace std; namespace ios = boost::iostreams; ios::istream foo(\"foo\"); }"));
+
+        // duplicate namespace aliases
+        ASSERT_EQUALS(";",
+                      tok("namespace ios = boost::iostreams;\nnamespace ios = boost::iostreams;"));
+        ASSERT_EQUALS(";",
+                      tok("namespace ios = boost::iostreams;\nnamespace ios = boost::iostreams;\nnamespace ios = boost::iostreams;"));
+        ASSERT_EQUALS("namespace A { namespace B { void foo ( ) { bar ( A :: B :: ab ( ) ) ; } } }",
+                      tok("namespace A::B {"
+                          "namespace AB = A::B;"
+                          "void foo() {"
+                          "    namespace AB = A::B;" // duplicate declaration
+                          "    bar(AB::ab());"
+                          "}"
+                          "namespace AB = A::B;" //duplicate declaration
+                          "}"));
+        ASSERT_EQUALS(";",
+                      tok("namespace p = boost::python;\n"
+                          "namespace np = boost::numpy;\n"));
+
+        // redeclared nested namespace aliases
+        TODO_ASSERT_EQUALS("namespace A { namespace B { void foo ( ) { bar ( A :: B :: ab ( ) ) ; { baz ( A :: a ( ) ) ; } bar ( A :: B :: ab ( ) ) ; } } }",
+                           "namespace A { namespace B { void foo ( ) { bar ( A :: B :: ab ( ) ) ; { baz ( A :: B :: a ( ) ) ; } bar ( A :: B :: ab ( ) ) ; } } }",
+                           tok("namespace A::B {"
+                               "namespace AB = A::B;"
+                               "void foo() {"
+                               "    namespace AB = A::B;" // duplicate declaration
+                               "    bar(AB::ab());"
+                               "    {"
+                               "         namespace AB = A;"
+                               "         baz(AB::a());" // redeclaration OK
                                "    }"
-                               "}";
-            const char* expected = "void foo ( ) { exit ( 0 ) ; { label : ; foo ( ) ; break ; } }";
-            ASSERT_EQUALS(expected, tokWithStdLib(code));
-        }
+                               "    bar(AB::ab());"
+                               "}"
+                               "namespace AB = A::B;" //duplicate declaration
+                               "}"));
 
-        {
-            const char* code = "int f() { "
-                               "switch (x) { case 1: exit(0); bar(); tack; { ticak(); exit(0) } exit(0);"
-                               "case 2: exit(0); { random(); } tack(); "
-                               "switch(y) { case 1: exit(0); case 2: exit(0); } "
-                               "exit(0); } exit(0); }";
-            ASSERT_EQUALS("int f ( ) { switch ( x ) { case 1 : ; exit ( 0 ) ; case 2 : ; exit ( 0 ) ; } exit ( 0 ) ; }",tokWithStdLib(code));
-        }
+        // variable and namespace alias with same name
+        ASSERT_EQUALS("namespace external { namespace ns { "
+                      "class A { "
+                      "public: "
+                      "static void f ( const std :: string & json ) ; "
+                      "} ; "
+                      "} } "
+                      "namespace external { namespace ns { "
+                      "void A :: f ( const std :: string & json ) { } "
+                      "} }",
+                      tok("namespace external::ns {"
+                          "    class A {"
+                          "    public:"
+                          "        static void f(const std::string& json);"
+                          "    };"
+                          "}"
+                          "namespace json = rapidjson;"
+                          "namespace external::ns {"
+                          "    void A::f(const std::string& json) { }"
+                          "}"));
+    }
 
-        {
-            const char* code = "int f() {"
-                               "switch (x) { case 1: exit(0); bar(); tack; { ticak(); exit(0); } exit(0);"
-                               "case 2: switch(y) { case 1: exit(0); bar2(); foo(); case 2: exit(0); }"
-                               "exit(0); } exit(0); }";
-            const char* expected = "int f ( ) {"
-                                   " switch ( x ) { case 1 : ; exit ( 0 ) ;"
-                                   " case 2 : ; switch ( y ) { case 1 : ; exit ( 0 ) ; case 2 : ; exit ( 0 ) ; }"
-                                   " exit ( 0 ) ; } exit ( 0 ) ; }";
-            ASSERT_EQUALS(expected,tokWithStdLib(code));
-        }
+    void simplifyNamespaceAliases2() {
+        ASSERT_EQUALS("void foo ( ) "
+                      "{ "
+                      "int maxResults ; maxResults = :: a :: b :: c :: d :: ef :: MAX ; "
+                      "}",
+                      tok("namespace ef = ::a::b::c::d::ef;"
+                          "void foo()"
+                          "{"
+                          "  int maxResults = ::a::b::c::d::ef::MAX;"
+                          "}"));
+    }
 
-        {
-            const char* code = "void foo () {"
-                               "    switch (i) { case 0: switch (j) { case 0: exit(0); }"
-                               "        case 1: switch (j) { case -1: exit(0); }"
-                               "        case 2: switch (j) { case -2: exit(0); }"
-                               "        case 3: if (blah6) {exit(0);} break; } }";
-            const char* expected = "void foo ( ) {"
-                                   " switch ( i ) { case 0 : ; switch ( j ) { case 0 : ; exit ( 0 ) ; }"
-                                   " case 1 : ; switch ( j ) { case -1 : ; exit ( 0 ) ; }"
-                                   " case 2 : ; switch ( j ) { case -2 : ; exit ( 0 ) ; }"
-                                   " case 3 : ; if ( blah6 ) { exit ( 0 ) ; } break ; } }";
-            ASSERT_EQUALS(expected, tokWithStdLib(code));
-        }
+    void simplifyNamespaceAliases3() {
+        ASSERT_EQUALS("namespace N { namespace O { int g ( ) ; } } " // #12586
+                      "void f ( ) { "
+                      "int s ; s = 3 * :: N :: O :: g ( ) ; "
+                      "}",
+                      tok("namespace N { namespace O { int g(); } }\n"
+                          "namespace _n = ::N::O;\n"
+                          "void f() {\n"
+                          "    int s = 3 * ::_n::g();\n"
+                          "}\n"));
+    }
 
-        {
-            const char* code = "void foo () {"
-                               "    exit(0);"
-                               "    switch (i) { case 0: switch (j) { case 0: foo(); }"
-                               "        case 1: switch (j) { case -1: bar(); label:; ok(); }"
-                               "        case 3: if (blah6) { boo(); break; } } }";
-            const char* expected = "void foo ( ) { exit ( 0 ) ; { { label : ; ok ( ) ; } case 3 : ; if ( blah6 ) { boo ( ) ; break ; } } }";
-            ASSERT_EQUALS(expected, tokWithStdLib(code));
-        }
+#define simplifyKnownVariables(...) simplifyKnownVariables_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    std::string simplifyKnownVariables_(const char* file, int line, const char (&code)[size]) {
+        SimpleTokenizer tokenizer(settings0, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
-        {
-            const char* code = "void foo() {"
-                               "     switch ( t ) {"
-                               "     case 0:"
-                               "          if ( t ) switch ( b ) {}"
-                               "          break;"
-                               "     case 1:"
-                               "          exit(0);"
-                               "          return 0;"
-                               "     }"
-                               "     return 0;"
-                               "}";
-            const char* expected = "void foo ( ) {"
-                                   " switch ( t ) {"
-                                   " case 0 : ;"
-                                   " if ( t ) { switch ( b ) { } }"
-                                   " break ;"
-                                   " case 1 : ;"
-                                   " exit ( 0 ) ;"
-                                   " }"
-                                   " return 0 ; "
-                                   "}";
-            ASSERT_EQUALS(expected, tokWithStdLib(code));
-        }
+        return tokenizer.tokens()->stringifyList(nullptr, false);
+    }
 
-        {
-            const char code[] = "void foo()\n"
-                                "{\n"
-                                "    A *a = 0;\n"
-                                "    if (!a) {\n"
-                                "        nondeadcode;\n"
-                                "        return;\n"
-                                "        dead;\n"
-                                "    }\n"
-                                "    stilldead;\n"
-                                "    a->_a;\n"
-                                "}\n";
-            const char expected[] = "void foo ( ) "
-                                    "{"
-                                    " A * a ; a = 0 ; {"
-                                    " nondeadcode ;"
-                                    " return ;"
-                                    " } "
-                                    "}";
-            ASSERT_EQUALS(expected, tokWithStdLib(code));
-        }
+    void simplifyKnownVariables2() {
+        const char code[] = "void f()\n"
+                            "{\n"
+                            "    int a = 10;\n"
+                            "    a = g();\n"
+                            "    if (a);\n"
+                            "}\n";
 
-        {
-            const char code[] = "class Fred\n"
-                                "{\n"
-                                "public:\n"
-                                "    bool foo() const { return f; }\n"
-                                "    bool exit();\n"
-                                "\n"
-                                "private:\n"
-                                "   bool f;\n"
-                                "};\n";
-            const char expected[] = "class Fred "
-                                    "{"
-                                    " public:"
-                                    " bool foo ( ) const { return f ; }"
-                                    " bool exit ( ) ;"
-                                    ""
-                                    " private:"
-                                    " bool f ; "
-                                    "} ;";
-            ASSERT_EQUALS(expected, tokWithStdLib(code));
-        }
+        ASSERT_EQUALS(
+            "void f ( ) { int a ; a = 10 ; a = g ( ) ; if ( a ) { ; } }",
+            simplifyKnownVariables(code));
+    }
 
-        {
-            const char code[] = "class abort { };\n"
-                                "\n"
-                                "class Fred\n"
-                                "{\n"
-                                "    public:\n"
-                                "    bool foo() const { return f; }\n"
-                                "    abort exit();\n"
-                                "\n"
-                                "    private:\n"
-                                "bool f;\n"
-                                "};\n";
-            const char expected[] = "class abort { } ; "
-                                    "class Fred "
-                                    "{"
-                                    " public:"
-                                    " bool foo ( ) const { return f ; }"
-                                    " abort exit ( ) ;"
-                                    ""
-                                    " private:"
-                                    " bool f ; "
-                                    "} ;";
-            ASSERT_EQUALS(expected, tokWithStdLib(code));
-        }
+    void simplifyKnownVariables3() {
+        const char code[] = "void f()\n"
+                            "{\n"
+                            "    int a = 4;\n"
+                            "    while(true){\n"
+                            "    break;\n"
+                            "    a = 10;\n"
+                            "    }\n"
+                            "    if (a);\n"
+                            "}\n";
+
+        ASSERT_EQUALS(
+            "void f ( ) { int a ; a = 4 ; while ( true ) { break ; a = 10 ; } if ( a ) { ; } }",
+            simplifyKnownVariables(code));
+    }
 
-        ASSERT_EQUALS("void foo ( ) { exit ( 0 ) ; }",
-                      tokWithStdLib("void foo() { do { exit(0); } while (true); }"));
+    void simplifyKnownVariables4() {
+        const char code[] = "void f()\n"
+                            "{\n"
+                            "    int a = 4;\n"
+                            "    if ( g(a));\n"
+                            "}\n";
 
-        // #6187
-        tokWithStdLib("void foo() {\n"
-                      "  goto label;\n"
-                      "  for (int i = 0; i < 0; ++i) {\n"
-                      "    ;\n"
-                      "label:\n"
-                      "    ;\n"
-                      "  }\n"
-                      "}");
+        // TODO: if a is passed by value is is ok to simplify..
+        ASSERT_EQUALS(
+            "void f ( ) { int a ; a = 4 ; if ( g ( a ) ) { ; } }",
+            simplifyKnownVariables(code));
     }
 
-    void strcat1() {
-        const char code[] = "; strcat(strcat(strcat(strcat(strcat(strcat(dst, \"this \"), \"\"), \"is \"), \"a \"), \"test\"), \".\");";
-        const char expect[] = "; "
-                              "strcat ( dst , \"this \" ) ; "
-                              "strcat ( dst , \"\" ) ; "
-                              "strcat ( dst , \"is \" ) ; "
-                              "strcat ( dst , \"a \" ) ; "
-                              "strcat ( dst , \"test\" ) ; "
-                              "strcat ( dst , \".\" ) ;";
-
-        ASSERT_EQUALS(expect, tok(code));
+    void simplifyKnownVariables5() {
+        const char code[] = "void f()\n"
+                            "{\n"
+                            "    int a = 4;\n"
+                            "    if ( a = 5 );\n"
+                            "}\n";
+
+        ASSERT_EQUALS(
+            "void f ( ) { int a ; a = 4 ; if ( a = 5 ) { ; } }",
+            simplifyKnownVariables(code));
     }
-    void strcat2() {
-        const char code[] = "; strcat(strcat(dst, foo[0]), \" \");";
-        const char expect[] = "; "
-                              "strcat ( dst , foo [ 0 ] ) ; "
-                              "strcat ( dst , \" \" ) ;";
 
-        ASSERT_EQUALS(expect, tok(code));
+    void simplifyKnownVariables13() {
+        const char code[] = "void f()\n"
+                            "{\n"
+                            "    int i = 10;\n"
+                            "    while(--i) {}\n"
+                            "}\n";
+
+        ASSERT_EQUALS(
+            "void f ( ) { int i ; i = 10 ; while ( -- i ) { } }",
+            simplifyKnownVariables(code));
     }
 
-    void simplifyAtol() {
-        ASSERT_EQUALS("a = std :: atol ( x ) ;", tok("a = std::atol(x);"));
-        ASSERT_EQUALS("a = atol ( \"text\" ) ;", tok("a = atol(\"text\");"));
-        ASSERT_EQUALS("a = 0 ;", tok("a = std::atol(\"0\");"));
-        ASSERT_EQUALS("a = 10 ;", tok("a = atol(\"0xa\");"));
+    void simplifyKnownVariables14() {
+        // ticket #753
+        const char code[] = "void f ( ) { int n ; n = 1 ; do { ++ n ; } while ( n < 10 ) ; }";
+        ASSERT_EQUALS(code, simplifyKnownVariables(code));
     }
 
-    void simplifyOperator1() {
-        // #3237 - error merging namespaces with operators
-        const char code[] = "class c {\n"
-                            "public:\n"
-                            "    operator std::string() const;\n"
-                            "    operator string() const;\n"
-                            "};\n";
-        const char expected[] = "class c { "
-                                "public: "
-                                "operatorstd::string ( ) const ; "
-                                "operatorstring ( ) const ; "
-                                "} ;";
-        ASSERT_EQUALS(expected, tok(code));
+    void simplifyKnownVariables16() {
+        // ticket #807 - segmentation fault when macro isn't found
+        const char code[] = "void f ( ) { int n = 1; DISPATCH(while); }";
+        ASSERT_THROW_INTERNAL(simplifyKnownVariables(code), UNKNOWN_MACRO);
     }
 
-    void simplifyOperator2() {
-        // #6576
-        ASSERT_EQUALS("template < class T > class SharedPtr { "
-                      "SharedPtr & operator= ( SharedPtr < Y > const & r ) ; "
-                      "} ; "
-                      "class TClass { "
-                      "public: TClass & operator= ( const TClass & rhs ) ; "
-                      "} ; "
-                      "TClass :: TClass ( const TClass & other ) { operator= ( other ) ; }",
-                      tok("template<class T>\n"
-                          "    class SharedPtr {\n"
-                          "    SharedPtr& operator=(SharedPtr<Y> const & r);\n"
-                          "};\n"
-                          "class TClass {\n"
-                          "public:\n"
-                          "    TClass& operator=(const TClass& rhs);\n"
-                          "};\n"
-                          "TClass::TClass(const TClass &other) {\n"
-                          "    operator=(other);\n"
-                          "}"));
+    void simplifyKnownVariables17() {
+        // ticket #807 - segmentation fault when macro isn't found
+        const char code[] = "void f ( ) { char *s = malloc(100);mp_ptr p = s; p++; }";
+        ASSERT_EQUALS(
+            "void f ( ) { char * s ; s = malloc ( 100 ) ; mp_ptr p ; p = s ; p ++ ; }",
+            simplifyKnownVariables(code));
     }
 
-    void simplifyArrayAccessSyntax() {
-        ASSERT_EQUALS("\n\n##file 0\n"
-                      "1: int a@1 ; a@1 [ 13 ] ;\n", tokenizeDebugListing("int a; 13[a];"));
+    void simplifyKnownVariables18() {
+        const char code[] = "void f ( ) { char *s = malloc(100);mp_ptr p = s; ++p; }";
+        ASSERT_EQUALS(
+            "void f ( ) { char * s ; s = malloc ( 100 ) ; mp_ptr p ; p = s ; ++ p ; }",
+            simplifyKnownVariables(code));
     }
 
-    void simplify_numeric_condition() {
-        {
-            const char code[] =
-                "void f()\n"
-                "{\n"
-                "int x = 0;\n"
-                "if( !x || 0 )\n"
-                "{ g();\n"
-                "}\n"
-                "}";
+    void simplifyKnownVariables19() {
+        const char code[] = "void f ( ) { int i=0; do { if (i>0) { a(); } i=b(); } while (i != 12); }";
+        ASSERT_EQUALS(
+            "void f ( ) { int i ; i = 0 ; do { if ( i > 0 ) { a ( ) ; } i = b ( ) ; } while ( i != 12 ) ; }",
+            simplifyKnownVariables(code));
+    }
 
-            ASSERT_EQUALS("void f ( ) { g ( ) ; }", tok(code));
-        }
+    void simplifyKnownVariables21() {
+        ASSERT_EQUALS(
+            "void foo ( int i ) { int n ; n = i ; for ( i = 0 ; i < n ; ++ i ) { } }",
+            simplifyKnownVariables("void foo(int i) { int n = i; for (i = 0; i < n; ++i) { } }"));
+    }
 
+    void simplifyKnownVariables25() {
         {
-            const char code[] =
-                "void f()\n"
-                "{\n"
-                "int x = 1;\n"
-                "if( !x )\n"
-                "{ g();\n"
-                "}\n"
-                "}";
+            // This testcase is related to ticket #1646
+            const char code[] = "void foo(char *str)\n"
+                                "{\n"
+                                "    int i;\n"
+                                "    for (i=0;i<10;++i) {\n"
+                                "        if (*str == 0) goto label;\n"
+                                "    }\n"
+                                "    return;\n"
+                                "label:\n"
+                                "    str[i] = 0;\n"
+                                "}\n";
 
-            ASSERT_EQUALS("void f ( ) { }", tok(code));
+            // Current result
+            ASSERT_EQUALS(
+                "void foo ( char * str ) "
+                "{"
+                " int i ;"
+                " for ( i = 0 ; i < 10 ; ++ i ) {"
+                " if ( * str == 0 ) { goto label ; }"
+                " }"
+                " return ;"
+                " label : ;"
+                " str [ i ] = 0 ; "
+                "}",
+                simplifyKnownVariables(code));
         }
 
         {
-            const char code[] =
-                "void f()\n"
-                "{\n"
-                "bool x = true;\n"
-                "if( !x )\n"
-                "{ g();\n"
-                "}\n"
-                "}";
+            // This testcase is related to ticket #1646
+            const char code[] = "void foo(char *str)\n"
+                                "{\n"
+                                "    int i;\n"
+                                "    for (i=0;i<10;++i) { }\n"
+                                "    return;\n"
+                                "    str[i] = 0;\n"
+                                "}\n";
 
-            ASSERT_EQUALS("void f ( ) { }", tok(code));
+            // Current result
+            ASSERT_EQUALS(
+                "void foo ( char * str ) "
+                "{"
+                " int i ;"
+                " for ( i = 0 ; i < 10 ; ++ i ) { }"
+                " return ;"
+                " str [ i ] = 0 ; "
+                "}",
+                simplifyKnownVariables(code));
         }
+    }
 
+    // cppcheck-suppress unusedPrivateFunction
+    void simplifyKnownVariables29() { // ticket #1811
         {
-            const char code[] =
-                "void f()\n"
-                "{\n"
-                "bool x = false;\n"
-                "if( !x )\n"
-                "{ g();\n"
-                "}\n"
-                "}";
-
-            ASSERT_EQUALS("void f ( ) { g ( ) ; }", tok(code));
+            const char code[] = "int foo(int u, int v)\n"
+                                "{\n"
+                                "  int h = u;\n"
+                                "  int i = v;\n"
+                                "  return h + i;\n"
+                                "}\n";
+            const char expected[] = "\n\n"
+                                    "##file 0\n"
+                                    "1: int foo ( int u@1 , int v@2 )\n"
+                                    "2: {\n"
+                                    "3:\n"
+                                    "4:\n"
+                                    "5: return u@1 + v@2 ;\n"
+                                    "6: }\n";
+            ASSERT_EQUALS(expected, tokenizeDebugListing(code));
         }
 
         {
-            const char code[] = "void f()\n"
+            const char code[] = "int foo(int u, int v)\n"
                                 "{\n"
-                                "    if (5==5);\n"
+                                "  int h = u;\n"
+                                "  int i = v;\n"
+                                "  return h - i;\n"
                                 "}\n";
-
-            ASSERT_EQUALS("void f ( ) { ; }", tok(code));
+            const char expected[] = "\n\n"
+                                    "##file 0\n"
+                                    "1: int foo ( int u@1 , int v@2 )\n"
+                                    "2: {\n"
+                                    "3:\n"
+                                    "4:\n"
+                                    "5: return u@1 - v@2 ;\n"
+                                    "6: }\n";
+            ASSERT_EQUALS(expected, tokenizeDebugListing(code));
         }
 
         {
-            const char code[] = "void f()\n"
+            const char code[] = "int foo(int u, int v)\n"
                                 "{\n"
-                                "    if (4<5);\n"
+                                "  int h = u;\n"
+                                "  int i = v;\n"
+                                "  return h * i;\n"
                                 "}\n";
-
-            ASSERT_EQUALS("void f ( ) { ; }", tok(code));
+            const char expected[] = "\n\n"
+                                    "##file 0\n"
+                                    "1: int foo ( int u@1 , int v@2 )\n"
+                                    "2: {\n"
+                                    "3:\n"
+                                    "4:\n"
+                                    "5: return u@1 * v@2 ;\n"
+                                    "6: }\n";
+            ASSERT_EQUALS(expected, tokenizeDebugListing(code));
         }
 
         {
-            const char code[] = "void f()\n"
+            const char code[] = "int foo(int u, int v)\n"
                                 "{\n"
-                                "    if (5<5);\n"
+                                "  int h = u;\n"
+                                "  int i = v;\n"
+                                "  return h / i;\n"
                                 "}\n";
-
-            ASSERT_EQUALS("void f ( ) { }", tok(code));
+            const char expected[] = "\n\n"
+                                    "##file 0\n"
+                                    "1: int foo ( int u@1 , int v@2 )\n"
+                                    "2: {\n"
+                                    "3:\n"
+                                    "4:\n"
+                                    "5: return u@1 / v@2 ;\n"
+                                    "6: }\n";
+            ASSERT_EQUALS(expected, tokenizeDebugListing(code));
         }
 
         {
-            const char code[] = "void f()\n"
+            const char code[] = "int foo(int u, int v)\n"
                                 "{\n"
-                                "    if (13>12?true:false);\n"
+                                "  int h = u;\n"
+                                "  int i = v;\n"
+                                "  return h & i;\n"
                                 "}\n";
-
-            ASSERT_EQUALS("void f ( ) { ; }", tok(code));
+            const char expected[] = "\n\n"
+                                    "##file 0\n"
+                                    "1: int foo ( int u@1 , int v@2 )\n"
+                                    "2: {\n"
+                                    "3:\n"
+                                    "4:\n"
+                                    "5: return u@1 & v@2 ;\n"
+                                    "6: }\n";
+            ASSERT_EQUALS(expected, tokenizeDebugListing(code));
         }
 
         {
-            // #7849
-            const char code[] =
-                "void f() {\n"
-                "if (-1e-2 == -0.01) \n"
-                "    g();\n"
-                "else\n"
-                "    h();\n"
-                "}";
-            ASSERT_EQUALS("void f ( ) { if ( -1e-2 == -0.01 ) { g ( ) ; } else { h ( ) ; } }",
-                          tok(code));
+            const char code[] = "int foo(int u, int v)\n"
+                                "{\n"
+                                "  int h = u;\n"
+                                "  int i = v;\n"
+                                "  return h | i;\n"
+                                "}\n";
+            const char expected[] = "\n\n"
+                                    "##file 0\n"
+                                    "1: int foo ( int u@1 , int v@2 )\n"
+                                    "2: {\n"
+                                    "3:\n"
+                                    "4:\n"
+                                    "5: return u@1 | v@2 ;\n"
+                                    "6: }\n";
+            ASSERT_EQUALS(expected, tokenizeDebugListing(code));
         }
-    }
 
-    void simplify_condition() {
         {
-            const char code[] =
-                "void f(int a)\n"
-                "{\n"
-                "if (a && false) g();\n"
-                "}";
-            ASSERT_EQUALS("void f ( int a ) { }", tok(code));
+            const char code[] = "int foo(int u, int v)\n"
+                                "{\n"
+                                "  int h = u;\n"
+                                "  int i = v;\n"
+                                "  return h ^ i;\n"
+                                "}\n";
+            const char expected[] = "\n\n"
+                                    "##file 0\n"
+                                    "1: int foo ( int u@1 , int v@2 )\n"
+                                    "2: {\n"
+                                    "3:\n"
+                                    "4:\n"
+                                    "5: return u@1 ^ v@2 ;\n"
+                                    "6: }\n";
+            ASSERT_EQUALS(expected, tokenizeDebugListing(code));
         }
 
         {
-            const char code[] =
-                "void f(int a)\n"
-                "{\n"
-                "if (false && a) g();\n"
-                "}";
-            ASSERT_EQUALS("void f ( int a ) { }", tok(code));
+            const char code[] = "int foo(int u, int v)\n"
+                                "{\n"
+                                "  int h = u;\n"
+                                "  int i = v;\n"
+                                "  return h % i;\n"
+                                "}\n";
+            const char expected[] = "\n\n"
+                                    "##file 0\n"
+                                    "1: int foo ( int u@1 , int v@2 )\n"
+                                    "2: {\n"
+                                    "3:\n"
+                                    "4:\n"
+                                    "5: return u@1 % v@2 ;\n"
+                                    "6: }\n";
+            ASSERT_EQUALS(expected, tokenizeDebugListing(code));
         }
 
         {
-            const char code[] =
-                "void f(int a)\n"
-                "{\n"
-                "if (true || a) g();\n"
-                "}";
-            ASSERT_EQUALS("void f ( int a ) { g ( ) ; }", tok(code));
+            const char code[] = "int foo(int u, int v)\n"
+                                "{\n"
+                                "  int h = u;\n"
+                                "  int i = v;\n"
+                                "  return h >> i;\n"
+                                "}\n";
+            const char expected[] = "\n\n"
+                                    "##file 0\n"
+                                    "1: int foo ( int u@1 , int v@2 )\n"
+                                    "2: {\n"
+                                    "3:\n"
+                                    "4:\n"
+                                    "5: return u@1 >> v@2 ;\n"
+                                    "6: }\n";
+            ASSERT_EQUALS(expected, tokenizeDebugListing(code));
         }
 
         {
-            const char code[] =
-                "void f(int a)\n"
-                "{\n"
-                "if (a || true) g();\n"
-                "}";
-            ASSERT_EQUALS("void f ( int a ) { g ( ) ; }", tok(code));
+            const char code[] = "int foo(int u, int v)\n"
+                                "{\n"
+                                "  int h = u;\n"
+                                "  int i = v;\n"
+                                "  return h << i;\n"
+                                "}\n";
+            const char expected[] = "\n\n"
+                                    "##file 0\n"
+                                    "1: int foo ( int u@1 , int v@2 )\n"
+                                    "2: {\n"
+                                    "3:\n"
+                                    "4:\n"
+                                    "5: return u@1 << v@2 ;\n"
+                                    "6: }\n";
+            ASSERT_EQUALS(expected, tokenizeDebugListing(code));
         }
 
         {
-            const char code[] =
-                "void f(int a)\n"
-                "{\n"
-                "if (a || true || b) g();\n"
-                "}";
-            ASSERT_EQUALS("void f ( int a ) { g ( ) ; }", tok(code));
+            const char code[] = "bool foo(int u, int v)\n"
+                                "{\n"
+                                "  int h = u;\n"
+                                "  int i = v;\n"
+                                "  return h == i;\n"
+                                "}\n";
+            const char expected[] = "\n\n"
+                                    "##file 0\n"
+                                    "1: bool foo ( int u@1 , int v@2 )\n"
+                                    "2: {\n"
+                                    "3:\n"
+                                    "4:\n"
+                                    "5: return u@1 == v@2 ;\n"
+                                    "6: }\n";
+            ASSERT_EQUALS(expected, tokenizeDebugListing(code));
         }
 
         {
-            const char code[] =
-                "void f(int a)\n"
-                "{\n"
-                "if (a && false && b) g();\n"
-                "}";
-            ASSERT_EQUALS("void f ( int a ) { }", tok(code));
+            const char code[] = "bool foo(int u, int v)\n"
+                                "{\n"
+                                "  int h = u;\n"
+                                "  int i = v;\n"
+                                "  return h != i;\n"
+                                "}\n";
+            const char expected[] = "\n\n"
+                                    "##file 0\n"
+                                    "1: bool foo ( int u@1 , int v@2 )\n"
+                                    "2: {\n"
+                                    "3:\n"
+                                    "4:\n"
+                                    "5: return u@1 != v@2 ;\n"
+                                    "6: }\n";
+            ASSERT_EQUALS(expected, tokenizeDebugListing(code));
         }
 
         {
-            const char code[] =
-                "void f(int a)\n"
-                "{\n"
-                "if (a || (b && false && c) || d) g();\n"
-                "}";
-            ASSERT_EQUALS("void f ( int a ) { if ( a || d ) { g ( ) ; } }", tok(code));
+            const char code[] = "bool foo(int u, int v)\n"
+                                "{\n"
+                                "  int h = u;\n"
+                                "  int i = v;\n"
+                                "  return h > i;\n"
+                                "}\n";
+            const char expected[] = "\n\n"
+                                    "##file 0\n"
+                                    "1: bool foo ( int u@1 , int v@2 )\n"
+                                    "2: {\n"
+                                    "3:\n"
+                                    "4:\n"
+                                    "5: return u@1 > v@2 ;\n"
+                                    "6: }\n";
+            ASSERT_EQUALS(expected, tokenizeDebugListing(code));
         }
 
         {
-            const char code[] =
-                "void f(int a)\n"
-                "{\n"
-                "if ((a && b) || true || (c && d)) g();\n"
-                "}";
-            ASSERT_EQUALS("void f ( int a ) { g ( ) ; }", tok(code));
+            const char code[] = "bool foo(int u, int v)\n"
+                                "{\n"
+                                "  int h = u;\n"
+                                "  int i = v;\n"
+                                "  return h >= i;\n"
+                                "}\n";
+            const char expected[] = "\n\n"
+                                    "##file 0\n"
+                                    "1: bool foo ( int u@1 , int v@2 )\n"
+                                    "2: {\n"
+                                    "3:\n"
+                                    "4:\n"
+                                    "5: return u@1 >= v@2 ;\n"
+                                    "6: }\n";
+            ASSERT_EQUALS(expected, tokenizeDebugListing(code));
         }
 
         {
-            // #4931
-            const char code[] =
-                "void f() {\n"
-                "if (12 && 7) g();\n"
-                "}";
-            ASSERT_EQUALS("void f ( ) { g ( ) ; }", tok(code));
+            const char code[] = "bool foo(int u, int v)\n"
+                                "{\n"
+                                "  int h = u;\n"
+                                "  int i = v;\n"
+                                "  return h < i;\n"
+                                "}\n";
+            const char expected[] = "\n\n"
+                                    "##file 0\n"
+                                    "1: bool foo ( int u@1 , int v@2 )\n"
+                                    "2: {\n"
+                                    "3:\n"
+                                    "4:\n"
+                                    "5: return u@1 < v@2 ;\n"
+                                    "6: }\n";
+            ASSERT_EQUALS(expected, tokenizeDebugListing(code));
         }
-    }
 
-
-    void pointeralias1() {
         {
-            const char code[] = "void f(char *p1)\n"
+            const char code[] = "bool foo(int u, int v)\n"
                                 "{\n"
-                                "    char *p = p1;\n"
-                                "    p1 = 0;"
-                                "    x(p);\n"
+                                "  int h = u;\n"
+                                "  int i = v;\n"
+                                "  return h <= i;\n"
                                 "}\n";
-
-            const char expected[] = "void f ( char * p1 ) "
-                                    "{ "
-                                    "char * p ; p = p1 ; "
-                                    "p1 = 0 ; "
-                                    "x ( p ) ; "
-                                    "}";
-
-            ASSERT_EQUALS(expected, tok(code));
+            const char expected[] = "\n\n"
+                                    "##file 0\n"
+                                    "1: bool foo ( int u@1 , int v@2 )\n"
+                                    "2: {\n"
+                                    "3:\n"
+                                    "4:\n"
+                                    "5: return u@1 <= v@2 ;\n"
+                                    "6: }\n";
+            ASSERT_EQUALS(expected, tokenizeDebugListing(code));
         }
 
         {
-            const char code[] = "void foo(Result* ptr)\n"
+            const char code[] = "bool foo(int u, int v)\n"
                                 "{\n"
-                                "    Result* obj = ptr;\n"
-                                "    ++obj->total;\n"
+                                "  int h = u;\n"
+                                "  int i = v;\n"
+                                "  return h && i;\n"
                                 "}\n";
-
-            const char expected[] = "void foo ( Result * ptr ) "
-                                    "{ "
-                                    "Result * obj ; obj = ptr ; "
-                                    "++ obj . total ; "
-                                    "}";
-
-            ASSERT_EQUALS(expected, tok(code));
+            const char expected[] = "\n\n"
+                                    "##file 0\n"
+                                    "1: bool foo ( int u@1 , int v@2 )\n"
+                                    "2: {\n"
+                                    "3:\n"
+                                    "4:\n"
+                                    "5: return u@1 && v@2 ;\n"
+                                    "6: }\n";
+            ASSERT_EQUALS(expected, tokenizeDebugListing(code));
         }
-    }
 
-    void pointeralias2() {
-        const char code[] = "void f()\n"
-                            "{\n"
-                            "    int i;\n"
-                            "    int *p = &i;\n"
-                            "    return *p;\n"
+        {
+            const char code[] = "bool foo(int u, int v)\n"
+                                "{\n"
+                                "  int h = u;\n"
+                                "  int i = v;\n"
+                                "  return h || i;\n"
+                                "}\n";
+            const char expected[] = "\n\n"
+                                    "##file 0\n"
+                                    "1: bool foo ( int u@1 , int v@2 )\n"
+                                    "2: {\n"
+                                    "3:\n"
+                                    "4:\n"
+                                    "5: return u@1 || v@2 ;\n"
+                                    "6: }\n";
+            ASSERT_EQUALS(expected, tokenizeDebugListing(code));
+        }
+    }
+
+    void simplifyKnownVariables30() {
+        const char code[] = "int foo() {\n"
+                            "  iterator it1 = ints.begin();\n"
+                            "  iterator it2 = it1;\n"
+                            "  for (++it2;it2!=ints.end();++it2);\n"
                             "}\n";
-        ASSERT_EQUALS("void f ( ) { int i ; return i ; }", tok(code));
+        const char expected[] = "int foo ( ) {\n"
+                                "iterator it1 ; it1 = ints . begin ( ) ;\n"
+                                "iterator it2 ; it2 = it1 ;\n"
+                                "for ( ++ it2 ; it2 != ints . end ( ) ; ++ it2 ) { ; }\n"
+                                "}";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
 
-    void pointeralias3() {
-        const char code[] = "void f()\n"
-                            "{\n"
-                            "    int i, j, *p;\n"
-                            "    if (ab) p = &i;\n"
-                            "    else p = &j;\n"
-                            "    *p = 0;\n"
+    void simplifyKnownVariables34() {
+        const char code[] = "void f() {\n"
+                            "    int x = 10;\n"
+                            "    do { cin >> x; } while (x > 5);\n"
+                            "    a[x] = 0;\n"
                             "}\n";
-        const char expected[] = "void f ( ) "
-                                "{"
-                                " int i ; int j ; int * p ;"
-                                " if ( ab ) { p = & i ; }"
-                                " else { p = & j ; }"
-                                " * p = 0 ; "
+        const char expected[] = "void f ( ) {\n"
+                                "int x ; x = 10 ;\n"
+                                "do { cin >> x ; } while ( x > 5 ) ;\n"
+                                "a [ x ] = 0 ;\n"
                                 "}";
-        ASSERT_EQUALS(expected, tok(code));
-    }
-
-    void pointeralias4() {
-        const char code[] = "int f()\n"
-                            "{\n"
-                            "    int i;\n"
-                            "    int *p = &i;\n"
-                            "    *p = 5;\n"
-                            "    return i;\n"
-                            "}\n";
-        const char expected[] = "int f ( ) "
-                                "{"
-                                " return 5 ; "
-                                "}";
-        ASSERT_EQUALS(expected, tok(code));
-    }
-
-    void while0() {
-        ASSERT_EQUALS("; x = 1 ;", tok("; do { x = 1 ; } while (0);"));
-        ASSERT_EQUALS("; return 0 ;", tok("; do { return 0; } while (0);"));
-        ASSERT_EQUALS("void foo ( ) { goto label ; }", tok("void foo() { do { goto label; } while (0); }"));
-        ASSERT_EQUALS("; { continue ; }", tok("; do { continue ; } while (0);"));
-        ASSERT_EQUALS("; { break ; }", tok("; do { break; } while (0);"));
-        ASSERT_EQUALS(";", tok("; while (false) { a; }"));
-        ASSERT_EQUALS(";", tok("; while (false) { switch (n) { case 0: return; default: break; } n*=1; }"));
-    }
-
-    void while0for() {
-        // for (condition is always false)
-        ASSERT_EQUALS("void f ( ) { int i ; for ( i = 0 ; i < 0 ; i ++ ) { } }", tok("void f() { int i; for (i = 0; i < 0; i++) { a; } }"));
-        //ticket #3140
-        ASSERT_EQUALS("void f ( ) { int i ; for ( i = 0 ; i < 0 ; i ++ ) { } }", tok("void f() { int i; for (i = 0; i < 0; i++) { foo(); break; } }"));
-        ASSERT_EQUALS("void f ( ) { int i ; for ( i = 0 ; i < 0 ; i ++ ) { } }", tok("void f() { int i; for (i = 0; i < 0; i++) { foo(); continue; } }"));
-        ASSERT_EQUALS("void f ( ) { }", tok("void f() { for (int i = 0; i < 0; i++) { a; } }"));
-        ASSERT_EQUALS("void f ( ) { }", tok("void f() { for (unsigned int i = 0; i < 0; i++) { a; } }"));
-        ASSERT_EQUALS("void f ( ) { }", tok("void f() { for (long long i = 0; i < 0; i++) { a; } }"));
-        ASSERT_EQUALS("void f ( ) { }", tok("void f() { for (signed long long i = 0; i < 0; i++) { a; } }"));
-        ASSERT_EQUALS("void f ( ) { }", tok("void f() { int n = 0; for (signed long long i = 0; i < n; i++) { a; } }"));
-        // #8059
-        ASSERT_EQUALS("void f ( ) { int i ; for ( i = 0 ; i < 0 ; ++ i ) { } return i ; }", tok("void f() { int i; for (i=0;i<0;++i){ dostuff(); } return i; }"));
-    }
-
-    void while1() {
-        // ticket #1197
-        const char code[] = "void do {} while (0) { }";
-        const char expected[] = "void { }";
-        ASSERT_EQUALS(expected, tok(code));
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+        ASSERT_EQUALS(
+            "[test.cpp:3:10]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable cin [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
     }
 
-    void duplicateDefinition() { // #3565 - wrongly detects duplicate definition
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr("x ; return a not_eq x;");
-        tokenizer.tokenize(istr, "test.c");
-        Token *x_token = tokenizer.list.front()->tokAt(5);
-        ASSERT_EQUALS(false, tokenizer.duplicateDefinition(&x_token));
-    }
+    void simplifyKnownVariables36() {
 
-    void removestd() {
-        ASSERT_EQUALS("; strcpy ( a , b ) ;", tok("; std::strcpy(a,b);"));
-        ASSERT_EQUALS("; strcat ( a , b ) ;", tok("; std::strcat(a,b);"));
-        ASSERT_EQUALS("; strncpy ( a , b , 10 ) ;", tok("; std::strncpy(a,b,10);"));
-        ASSERT_EQUALS("; strncat ( a , b , 10 ) ;", tok("; std::strncat(a,b,10);"));
-        ASSERT_EQUALS("; free ( p ) ;", tok("; std::free(p);"));
-        ASSERT_EQUALS("; malloc ( 10 ) ;", tok("; std::malloc(10);"));
+        // Ticket #5972
+        const char code2[] = "void f() {"
+                             "  char buf[10] = \"ab\";"
+                             "    memset(buf, 0, 10);"
+                             "}";
+        const char expected2[] = "void f ( ) { char buf [ 10 ] = \"ab\" ; memset ( buf , 0 , 10 ) ; }";
+        ASSERT_EQUALS(expected2, tokenizeAndStringify(code2));
     }
 
-    void simplifyInitVar() {
-        // ticket #1005 - int *p(0); => int *p = 0;
+    void simplifyKnownVariables42() {
         {
-            const char code[] = "void foo() { int *p(0); }";
-            ASSERT_EQUALS("void foo ( ) { }", tok(code));
+            const char code[] = "void f() {\n"
+                                "   char a[10];\n"
+                                "   strcpy(a, \"hello\");\n"
+                                "   strcat(a, \"!\");\n"
+                                "}";
+            const char expected[] = "void f ( ) {\n"
+                                    "char a [ 10 ] ;\n"
+                                    "strcpy ( a , \"hello\" ) ;\n"
+                                    "strcat ( a , \"!\" ) ;\n"
+                                    "}";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code, dinit(TokenizeAndStringifyOptions, $.cpp = false)));
         }
 
         {
-            const char code[] = "void foo() { int p(0); }";
-            ASSERT_EQUALS("void foo ( ) { }", tok(code));
+            const char code[] = "void f() {"
+                                "    char *s = malloc(10);"
+                                "    strcpy(s, \"\");"
+                                "    free(s);"
+                                "}";
+            const char expected[] = "void f ( ) {"
+                                    " char * s ; s = malloc ( 10 ) ;"
+                                    " strcpy ( s , \"\" ) ;"
+                                    " free ( s ) ; "
+                                    "}";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
 
         {
-            const char code[] = "void a() { foo *p(0); }";
-            ASSERT_EQUALS("void a ( ) { }", tok(code));
+            const char code[] = "void f(char *p, char *q) {"
+                                "    strcpy(p, \"abc\");"
+                                "    q = p;"
+                                "}";
+            const char expected[] = "void f ( char * p , char * q ) {"
+                                    " strcpy ( p , \"abc\" ) ;"
+                                    " q = p ; "
+                                    "}";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
-    }
-
-    void simplifyReference() {
-        ASSERT_EQUALS("void f ( ) { int a ; a ++ ; }",
-                      tok("void f() { int a; int &b(a); b++; }"));
-        ASSERT_EQUALS("void f ( ) { int a ; a ++ ; }",
-                      tok("void f() { int a; int &b = a; b++; }"));
-
-        ASSERT_EQUALS("void test ( ) { c . f ( 7 ) ; }",
-                      tok("void test() { c.f(7); T3 &t3 = c; }")); // #6133
-    }
-
-    void simplifyRealloc() {
-        ASSERT_EQUALS("; free ( p ) ; p = 0 ;", tok("; p = realloc(p, 0);"));
-        ASSERT_EQUALS("; p = malloc ( 100 ) ;", tok("; p = realloc(0, 100);"));
-        ASSERT_EQUALS("; p = malloc ( 0 ) ;", tok("; p = realloc(0, 0);"));
-        ASSERT_EQUALS("; free ( q ) ; p = 0 ;", tok("; p = realloc(q, 0);"));
-        ASSERT_EQUALS("; free ( * q ) ; p = 0 ;", tok("; p = realloc(*q, 0);"));
-        ASSERT_EQUALS("; free ( f ( z ) ) ; p = 0 ;", tok("; p = realloc(f(z), 0);"));
-        ASSERT_EQUALS("; p = malloc ( n * m ) ;", tok("; p = realloc(0, n*m);"));
-        ASSERT_EQUALS("; p = malloc ( f ( 1 ) ) ;", tok("; p = realloc(0, f(1));"));
-    }
-
-    void simplifyErrNoInWhile() {
-        ASSERT_EQUALS("; while ( f ( ) ) { }",
-                      tok("; while (f() && errno == EINTR) { }"));
-        ASSERT_EQUALS("; while ( f ( ) ) { }",
-                      tok("; while (f() && (errno == EINTR)) { }"));
-    }
-
-    void simplifyFuncInWhile() {
-        ASSERT_EQUALS("int cppcheck:r1 = fclose ( f ) ; "
-                      "while ( cppcheck:r1 ) "
-                      "{ "
-                      "foo ( ) ; "
-                      "cppcheck:r1 = fclose ( f ) ; "
-                      "}",
-                      tok("while(fclose(f))foo();"));
-
-        ASSERT_EQUALS("int cppcheck:r1 = fclose ( f ) ; "
-                      "while ( cppcheck:r1 ) "
-                      "{ "
-                      "; cppcheck:r1 = fclose ( f ) ; "
-                      "}",
-                      tok("while(fclose(f));"));
-
-        ASSERT_EQUALS("int cppcheck:r1 = fclose ( f ) ; "
-                      "while ( cppcheck:r1 ) "
-                      "{ "
-                      "; cppcheck:r1 = fclose ( f ) ; "
-                      "} "
-                      "int cppcheck:r2 = fclose ( g ) ; "
-                      "while ( cppcheck:r2 ) "
-                      "{ "
-                      "; cppcheck:r2 = fclose ( g ) ; "
-                      "}",
-                      tok("while(fclose(f)); while(fclose(g));"));
-    }
 
-    void simplifyStructDecl1() {
+        // 3538
         {
-            const char code[] = "struct ABC { } abc;";
-            const char expected[] = "struct ABC { } ; struct ABC abc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
+            const char code[] = "void f() {\n"
+                                "    char s[10];\n"
+                                "    strcpy(s, \"123\");\n"
+                                "    if (s[6] == ' ');\n"
+                                "}";
+            const char expected[] = "void f ( ) {\n"
+                                    "char s [ 10 ] ;\n"
+                                    "strcpy ( s , \"123\" ) ;\n"
+                                    "if ( s [ 6 ] == ' ' ) { ; }\n"
+                                    "}";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+            ASSERT_EQUALS("", filter_valueflow(errout_str()));
         }
+    }
 
+    void simplifyKnownVariables43() {
         {
-            const char code[] = "struct ABC { } * pabc;";
-            const char expected[] = "struct ABC { } ; struct ABC * pabc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
+            const char code[] = "void f() {\n"
+                                "    int a, *p; p = &a;\n"
+                                "    { int a = *p; }\n"
+                                "}";
+            const char expected[] = "void f ( ) {\n"
+                                    "int a ; int * p ; p = & a ;\n"
+                                    "{ int a ; a = * p ; }\n"
+                                    "}";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
 
         {
-            const char code[] = "struct ABC { } abc[4];";
-            const char expected[] = "struct ABC { } ; struct ABC abc [ 4 ] ;";
-            ASSERT_EQUALS(expected, tok(code, false));
+            const char code[] = "void f() {\n"
+                                "    int *a, **p; p = &a;\n"
+                                "    { int *a = *p; }\n"
+                                "}";
+            const char expected[] = "void f ( ) {\n"
+                                    "int * a ; int * * p ; p = & a ;\n"
+                                    "{ int * a ; a = * p ; }\n"
+                                    "}";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
+    }
 
-        {
-            const char code[] = "struct ABC { } abc, def;";
-            const char expected[] = "struct ABC { } ; struct ABC abc ; struct ABC def ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+    void simplifyKnownVariables44() {
+        const char code[] = "void a() {\n"
+                            "    static int i = 10;\n"
+                            "    b(i++);\n"
+                            "}";
+        const char expected[] = "void a ( ) {\n"
+                                "static int i = 10 ;\n"
+                                "b ( i ++ ) ;\n"
+                                "}";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+    }
 
-        {
-            const char code[] = "struct ABC { } abc, * pabc;";
-            const char expected[] = "struct ABC { } ; struct ABC abc ; struct ABC * pabc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+    void simplifyKnownVariables46() {
+        const char code[] = "void f() {\n"
+                            "    int x = 0;\n"
+                            "    cin >> x;\n"
+                            "    return x;\n"
+                            "}";
 
-        {
-            const char code[] = "struct ABC { struct DEF {} def; } abc;";
-            const char expected[] = "struct ABC { struct DEF { } ; struct DEF def ; } ; struct ABC abc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+        const char expected[] = "void f ( ) {\n"
+                                "int x ; x = 0 ;\n"
+                                "cin >> x ;\n"
+                                "return x ;\n"
+                                "}";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+        ASSERT_EQUALS(
+            "[test.cpp:3:5]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable cin [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
+    }
 
-        {
-            const char code[] = "struct { } abc;";
-            const char expected[] = "struct Anonymous0 { } ; struct Anonymous0 abc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+    void simplifyKnownVariables47() {
+        // #3621
+        const char code[] = "void f() {\n"
+                            "    int x = 0;\n"
+                            "    cin >> std::hex >> x;\n"
+                            "}";
+        const char expected[] = "void f ( ) {\n"
+                                "int x ; x = 0 ;\n"
+                                "cin >> std :: hex >> x ;\n"
+                                "}";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+        ASSERT_EQUALS(
+            "[test.cpp:3:5]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable cin [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
+    }
 
-        {
-            const char code[] = "struct { } * pabc;";
-            const char expected[] = "struct Anonymous0 { } ; struct Anonymous0 * pabc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+    void simplifyKnownVariables48() {
+        // #3754
+        const char code[] = "void f(int sz) {\n"
+                            "    int i;\n"
+                            "    for (i = 0; ((i<sz) && (sz>3)); ++i) { }\n"
+                            "}";
+        const char expected[] = "void f ( int sz ) {\n"
+                                "int i ;\n"
+                                "for ( i = 0 ; ( i < sz ) && ( sz > 3 ) ; ++ i ) { }\n"
+                                "}";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code, dinit(TokenizeAndStringifyOptions, $.cpp = false)));
+    }
 
-        {
-            const char code[] = "struct { } abc[4];";
-            const char expected[] = "struct Anonymous0 { } ; struct Anonymous0 abc [ 4 ] ;";
-            ASSERT_EQUALS(expected, tok(code, false));
+    void simplifyKnownVariables49() { // #3691
+        const char code[] = "void f(int sz) {\n"
+                            "    switch (x) {\n"
+                            "    case 1: sz = 2; continue;\n"
+                            "    case 2: x = sz; break;\n"
+                            "    }\n"
+                            "}";
+        const char expected[] = "void f ( int sz ) {\n"
+                                "switch ( x ) {\n"
+                                "case 1 : ; sz = 2 ; continue ;\n"
+                                "case 2 : ; x = sz ; break ;\n"
+                                "}\n"
+                                "}";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code, dinit(TokenizeAndStringifyOptions, $.cpp = false)));
+        ASSERT_EQUALS(
+            "[test.c:2:13]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable x [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
+    }
+
+    void simplifyKnownVariables50() { // #4066
+        {
+            //don't simplify '&x'!
+            const char code[] = "const char * foo ( ) {\n"
+                                "const char x1 = 'b' ;\n"
+                                "f ( & x1 ) ;\n"
+                                "const char x2 = 'b' ;\n"
+                                "f ( y , & x2 ) ;\n"
+                                "const char x3 = 'b' ;\n"
+                                "t = & x3 ;\n"
+                                "const char x4 = 'b' ;\n"
+                                "t = y + & x4 ;\n"
+                                "const char x5 = 'b' ;\n"
+                                "z [ & x5 ] = y ;\n"
+                                "const char x6 = 'b' ;\n"
+                                "v = { & x6 } ;\n"
+                                "const char x7 = 'b' ;\n"
+                                "return & x7 ;\n"
+                                "}";
+            ASSERT_EQUALS(code, tokenizeAndStringify(code));
+            ASSERT_EQUALS(
+                "[test.cpp:5:5]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable y [valueFlowBailoutIncompleteVar]\n",
+                errout_str());
+        }
+        {
+            //don't simplify '&x'!
+            const char code[] = "const int * foo ( ) {\n"
+                                "const int x1 = 1 ;\n"
+                                "f ( & x1 ) ;\n"
+                                "const int x2 = 1 ;\n"
+                                "f ( y , & x2 ) ;\n"
+                                "const int x3 = 1 ;\n"
+                                "t = & x3 ;\n"
+                                "const int x4 = 1 ;\n"
+                                "t = y + & x4 ;\n"
+                                "const int x5 = 1 ;\n"
+                                "z [ & x5 ] = y ;\n"
+                                "const int x6 = 1 ;\n"
+                                "v = { & x6 } ;\n"
+                                "const int x7 = 1 ;\n"
+                                "return & x7 ;\n"
+                                "}";
+            ASSERT_EQUALS(code, tokenizeAndStringify(code));
+            ASSERT_EQUALS(
+                "[test.cpp:5:5]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable y [valueFlowBailoutIncompleteVar]\n",
+                errout_str());
         }
+    }
 
-        {
-            const char code[] = "struct {int a;} const array[3] = {0};";
-            const char expected[] = "struct Anonymous0 { int a ; } ; struct Anonymous0 const array [ 3 ] = { 0 } ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+    void simplifyKnownVariables51() { // #4409 hang
+        const char code[] = "void mhz_M(int enough) {\n"
+                            "  TYPE *x=&x, **p=x, **q = NULL;\n"
+                            "  BENCH1(q = _mhz_M(n); n = 1;)\n"
+                            "  use_pointer(q);\n"
+                            "}";
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(code), UNKNOWN_MACRO);
+    }
 
-        {
-            const char code[] = "static struct {int a;} const array[3] = {0};";
-            const char expected[] = "struct Anonymous0 { int a ; } ; static struct Anonymous0 const array [ 3 ] = { 0 } ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+    void simplifyKnownVariables54() { // #4913
+        ASSERT_EQUALS("void f ( int * p ) { * -- p = 0 ; * p = 0 ; }", tokenizeAndStringify("void f(int*p) { *--p=0; *p=0; }"));
+    }
 
-        {
-            const char code[] = "struct { } abc, def;";
-            const char expected[] = "struct Anonymous0 { } ; struct Anonymous0 abc ; struct Anonymous0 def ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+    void simplifyKnownVariables56() { // ticket #5301 - >>
+        ASSERT_EQUALS("void f ( ) { int a ; a = 0 ; int b ; b = 0 ; * p >> a >> b ; return a / b ; }",
+                      tokenizeAndStringify("void f() { int a=0,b=0; *p>>a>>b; return a/b; }"));
+        ASSERT_EQUALS(
+            "[test.cpp:1:26]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable p [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
+    }
 
-        {
-            const char code[] = "struct { } abc, * pabc;";
-            const char expected[] = "struct Anonymous0 { } ; struct Anonymous0 abc ; struct Anonymous0 * pabc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+    void simplifyKnownVariables58() { // #5268
+        const char code[] = "enum e { VAL1 = 1, VAL2 }; "
+                            "typedef char arr_t[VAL2]; "
+                            "int foo(int) ; "
+                            "void bar () { "
+                            "  throw foo (VAL1); "
+                            "} "
+                            "int baz() { "
+                            "  return sizeof(arr_t); "
+                            "}";
+        ASSERT_EQUALS("enum e { VAL1 = 1 , VAL2 } ; "
+                      "int foo ( int ) ; "
+                      "void bar ( ) { "
+                      "throw foo ( VAL1 ) ; "
+                      "} "
+                      "int baz ( ) { "
+                      "return sizeof ( char [ VAL2 ] ) ; "
+                      "}", tokenizeAndStringify(code));
+    }
 
-        {
-            const char code[] = "struct { struct DEF {} def; } abc;";
-            const char expected[] = "struct Anonymous0 { struct DEF { } ; struct DEF def ; } ; struct Anonymous0 abc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+    void simplifyKnownVariables59() { // #5062 - for head
+        const char code[] = "void f() {\n"
+                            "  int a[3], i, j;\n"
+                            "  for(i = 0, j = 1; i < 3, j < 12; i++,j++) {\n"
+                            "    a[i] = 0;\n"
+                            "  }\n"
+                            "}";
+        ASSERT_EQUALS("void f ( ) {\n"
+                      "int a [ 3 ] ; int i ; int j ;\n"
+                      "for ( i = 0 , j = 1 ; i < 3 , j < 12 ; i ++ , j ++ ) {\n"
+                      "a [ i ] = 0 ;\n"
+                      "}\n"
+                      "}", tokenizeAndStringify(code));
+    }
+
+    void simplifyKnownVariables61() { // #7805
+        ASSERT_NO_THROW(tokenizeAndStringify("static const int XX = 0;\n"
+                                             "enum E { XX };\n"
+                                             "struct s {\n"
+                                             "  enum Bar {\n"
+                                             "    XX,\n"
+                                             "    Other\n"
+                                             "  };\n"
+                                             "  enum { XX };\n"
+                                             "};"));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void simplifyKnownVariables62() { // #5666
+        ASSERT_EQUALS("void foo ( std :: string str ) {\n"
+                      "char * p ; p = & str [ 0 ] ;\n"
+                      "* p = 0 ;\n"
+                      "}",
+                      tokenizeAndStringify("void foo(std::string str) {\n"
+                                           "  char *p = &str[0];\n"
+                                           "  *p = 0;\n"
+                                           "}"));
+    }
 
-        {
-            const char code[] = "struct ABC { struct {} def; } abc;";
-            const char expected[] = "struct ABC { struct Anonymous0 { } ; struct Anonymous0 def ; } ; struct ABC abc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+    void simplifyKnownVariables63() { // #10798
+        ASSERT_NO_THROW(tokenizeAndStringify("typedef void (*a)();\n"
+                                             "enum class E { a };\n"));
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        {
-            const char code[] = "struct { struct {} def; } abc;";
-            const char expected[] = "struct Anonymous0 { struct Anonymous1 { } ; struct Anonymous1 def ; } ; struct Anonymous0 abc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+    void simplifyKnownVariablesBailOutAssign1() {
+        const char code[] = "int foo() {\n"
+                            "    int i; i = 0;\n"
+                            "    if (x) { i = 10; }\n"
+                            "    return i;\n"
+                            "}\n";
+        const char expected[] = "int foo ( ) {\n"
+                                "int i ; i = 0 ;\n"
+                                "if ( x ) { i = 10 ; }\n"
+                                "return i ;\n"
+                                "}";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+        ASSERT_EQUALS(
+            "[test.cpp:3:9]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable x [valueFlowBailoutIncompleteVar]\n",
+            filter_valueflow(errout_str()));
+    }
 
-        {
-            const char code[] = "union ABC { int i; float f; } abc;";
-            const char expected[] = "union ABC { int i ; float f ; } ; union ABC abc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+    void simplifyKnownVariablesBailOutAssign2() {
+        // ticket #3032 - assignment in condition
+        const char code[] = "void f(struct ABC *list) {\n"
+                            "    struct ABC *last = NULL;\n"
+                            "    nr = (last = list->prev)->nr;\n"  // <- don't replace "last" with 0
+                            "}\n";
+        const char expected[] = "void f ( struct ABC * list ) {\n"
+                                "struct ABC * last ; last = NULL ;\n"
+                                "nr = ( last = list . prev ) . nr ;\n"
+                                "}";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+        ASSERT_EQUALS(
+            "[test.cpp:3:5]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable nr [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
+    }
 
-        {
-            const char code[] = "struct ABC { struct {} def; };";
-            const char expected[] = "struct ABC { struct Anonymous0 { } ; struct Anonymous0 def ; } ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+    void simplifyKnownVariablesBailOutFor1() {
+        const char code[] = "void foo() {\n"
+                            "    for (int i = 0; i < 10; ++i) { }\n"
+                            "}\n";
+        const char expected[] = "void foo ( ) {\n"
+                                "for ( int i = 0 ; i < 10 ; ++ i ) { }\n"
+                                "}";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+        ASSERT_EQUALS("", errout_str());    // debug warnings
+    }
 
-        {
-            const char code[] = "struct ABC : public XYZ { struct {} def; };";
-            const char expected[] = "struct ABC : public XYZ { struct Anonymous0 { } ; struct Anonymous0 def ; } ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+    void simplifyKnownVariablesBailOutFor2() {
+        const char code[] = "void foo() {\n"
+                            "    int i = 0;\n"
+                            "    while (i < 10) { ++i; }\n"
+                            "}\n";
+        const char expected[] = "void foo ( ) {\n"
+                                "int i ; i = 0 ;\n"
+                                "while ( i < 10 ) { ++ i ; }\n"
+                                "}";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+        ASSERT_EQUALS("", errout_str());    // debug warnings
+    }
 
-        {
-            const char code[] = "struct { int x; }; int y;";
-            const char expected[] = "int x ; int y ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+    void simplifyKnownVariablesBailOutFor3() {
+        const char code[] = "void foo() {\n"
+                            "    for (std::string::size_type pos = 0; pos < 10; ++pos)\n"
+                            "    { }\n"
+                            "}\n";
+        const char expected[] = "void foo ( ) {\n"
+                                "for ( std :: string :: size_type pos = 0 ; pos < 10 ; ++ pos )\n"
+                                "{ }\n"
+                                "}";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+        ASSERT_EQUALS("", errout_str());    // debug warnings
+    }
 
-        {
-            const char code[] = "struct { int x; };";
-            const char expected[] = "int x ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+    void simplifyKnownVariablesBailOutMemberFunction() {
+        const char code[] = "void foo(obj a) {\n"
+                            "    obj b = a;\n"
+                            "    b.f();\n"
+                            "}\n";
+        const char expected[] = "void foo ( obj a ) {\n"
+                                "obj b ; b = a ;\n"
+                                "b . f ( ) ;\n"
+                                "}";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+    }
 
-        {
-            const char code[] = "struct { };";
-            const char expected[] = ";";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+    void simplifyKnownVariablesBailOutConditionalIncrement() {
+        const char code[] = "int f() {\n"
+                            "    int a = 0;\n"
+                            "    if (x) {\n"
+                            "        ++a;\n" // conditional increment
+                            "    }\n"
+                            "    return a;\n"
+                            "}\n";
+        (void)tokenizeAndStringify(code);
+        ASSERT_EQUALS(
+            "[test.cpp:3:9]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable x [valueFlowBailoutIncompleteVar]\n",
+            filter_valueflow(errout_str())); // no debug warnings
+    }
 
-        {
-            const char code[] = "struct { struct { struct { } ; } ; };";
-            const char expected[] = ";";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+    void simplifyKnownVariablesBailOutSwitchBreak() {
+        // Ticket #2324
+        const char code[] = "int f(char *x) {\n"
+                            "    char *p;\n"
+                            "    char *q;\n"
+                            "\n"
+                            "    switch (x & 0x3)\n"
+                            "    {\n"
+                            "        case 1:\n"
+                            "            p = x;\n"
+                            "            x = p;\n"
+                            "            break;\n"
+                            "        case 2:\n"
+                            "            q = x;\n" // x is not equal with p
+                            "            x = q;\n"
+                            "            break;\n"
+                            "    }\n"
+                            "}\n";
 
-        // ticket 2464
-        {
-            const char code[] = "static struct ABC { } abc ;";
-            const char expected[] = "struct ABC { } ; static struct ABC abc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+        const char expected[] = "int f ( char * x ) {\n"
+                                "char * p ;\n"
+                                "char * q ;\n"
+                                "\n"
+                                "switch ( x & 0x3 )\n"
+                                "{\n"
+                                "case 1 : ;\n"
+                                "p = x ;\n"
+                                "x = p ;\n"
+                                "break ;\n"
+                                "case 2 : ;\n"
+                                "q = x ;\n"
+                                "x = q ;\n"
+                                "break ;\n"
+                                "}\n"
+                                "}";
 
-        // ticket #980
-        {
-            const char code[] = "void f() { int A(1),B(2),C=3,D,E(5),F=6; }";
-            const char expected[] = "void f ( ) { int A ; A = 1 ; int B ; B = 2 ; int C ; C = 3 ; int D ; int E ; E = 5 ; int F ; F = 6 ; }";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+    }
 
-        // ticket #8284
+    void simplifyKnownVariablesFunctionCalls() {
         {
-            const char code[] = "void f() { class : foo<int> { } abc; }";
-            const char expected[] = "void f ( ) { class Anonymous0 : foo < int > { } ; Anonymous0 abc ; }";
-            ASSERT_EQUALS(expected, tok(code, false));
+            const char code[] = "void a(int &x);" // <- x is passed by reference
+                                "void b() {"
+                                "    int x = 123;"
+                                "    a(x);"       // <- don't replace with a(123);
+                                "}";
+            const char expected[] = "void a ( int & x ) ; void b ( ) { int x ; x = 123 ; a ( x ) ; }";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
     }
 
-    void simplifyStructDecl2() { // ticket #2479 (segmentation fault)
-        const char code[] = "struct { char c; }";
-        const char expected[] = "struct { char c ; }";
-        ASSERT_EQUALS(expected, tok(code, false));
+    void simplifyKnownVariablesGlobalVars() {
+        // #8054
+        const char code[] = "static int x;"
+                            "void f() {"
+                            "    x = 123;"
+                            "    while (!x) { dostuff(); }"
+                            "}";
+        ASSERT_EQUALS("static int x ; void f ( ) { x = 123 ; while ( ! x ) { dostuff ( ) ; } }", tokenizeAndStringify(code));
+        ASSERT_EQUALS("", filter_valueflow(errout_str()));
     }
 
-    void simplifyStructDecl3() {
-        {
-            const char code[] = "class ABC { } abc;";
-            const char expected[] = "class ABC { } ; ABC abc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
+    void simplifyKnownVariablesNamespace() {
+        { // #10059
+            const char code[] = "namespace N {\n"
+                                "    const int n = 0;\n"
+                                "    namespace M { const int m = 0; }\n"
+                                "}\n"
+                                "using namespace N;\n"
+                                "int i(n);\n"
+                                "int j(M::m);\n"
+                                "using namespace N::M;\n"
+                                "int k(m);\n"
+                                "int l(N::M::m);\n";
+            const char exp[]  = "\n\n##file 0\n"
+                                "1: namespace N {\n"
+                                "2: const int n@1 = 0 ;\n"
+                                "3: namespace M { const int m@2 = 0 ; }\n"
+                                "4: }\n"
+                                "5: using namespace N ;\n"
+                                "6: int i ( n@1 ) ;\n"
+                                "7: int j ( M :: m@2 ) ;\n"
+                                "8: using namespace N :: M ;\n"
+                                "9: int k ( m@2 ) ;\n"
+                                "10: int l ( N :: M :: m@2 ) ;\n";
+            ASSERT_EQUALS(exp, tokenizeDebugListing(code));
+        }
+        { // #10835
+            const char code[] = "using namespace X;\n"
+                                "namespace N {\n"
+                                "    struct A {\n"
+                                "        static int i;\n"
+                                "        struct B {\n"
+                                "            double x;\n"
+                                "            void f();\n"
+                                "        };\n"
+                                "    };\n"
+                                "}\n"
+                                "namespace N {\n"
+                                "    int A::i = 0;\n"
+                                "    void A::B::f() {\n"
+                                "        x = 0;\n"
+                                "    }\n"
+                                "}\n";
+            const char exp[]  = "\n\n##file 0\n"
+                                "1: using namespace X ;\n"
+                                "2: namespace N {\n"
+                                "3: struct A {\n"
+                                "4: static int i@1 ;\n"
+                                "5: struct B {\n"
+                                "6: double x@2 ;\n"
+                                "7: void f ( ) ;\n"
+                                "8: } ;\n"
+                                "9: } ;\n"
+                                "10: }\n"
+                                "11: namespace N {\n"
+                                "12: int A :: i@1 = 0 ;\n"
+                                "13: void A :: B :: f ( ) {\n"
+                                "14: x@2 = 0 ;\n"
+                                "15: }\n"
+                                "16: }\n";
+            ASSERT_EQUALS(exp, tokenizeDebugListing(code));
+        }
+    }
+
+    void simplifyKnownVariablesClassMember() {
+        // Ticket #2815
+        {
+            const char code[] = "char *a;\n"
+                                "void f(const char *s) {\n"
+                                "    a = NULL;\n"
+                                "    x();\n"
+                                "    memcpy(a, s, 10);\n"   // <- don't simplify "a" here
+                                "}\n";
+
+            const std::string s(tokenizeAndStringify(code));
+            ASSERT_EQUALS(true, s.find("memcpy ( a , s , 10 ) ;") != std::string::npos);
         }
 
+        // If the variable is local then perform simplification..
         {
-            const char code[] = "class ABC { } * pabc;";
-            const char expected[] = "class ABC { } ; ABC * pabc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
+            const char code[] = "void f(const char *s) {\n"
+                                "    char *a = NULL;\n"
+                                "    x();\n"
+                                "    memcpy(a, s, 10);\n"   // <- simplify "a"
+                                "}\n";
+
+            const std::string s(tokenizeAndStringify(code));
+            TODO_ASSERT_EQUALS(true, false, s.find("memcpy ( 0 , s , 10 ) ;") != std::string::npos);
         }
+    }
 
+    void simplify_constants6() { // Ticket #5625
         {
-            const char code[] = "class ABC { } abc[4];";
-            const char expected[] = "class ABC { } ; ABC abc [ 4 ] ;";
-            ASSERT_EQUALS(expected, tok(code, false));
+            const char code[] = "template < class T > struct foo ;\n"
+                                "void bar ( ) {\n"
+                                "foo < 1 ? 0 ? 1 : 6 : 2 > x ;\n"
+                                "foo < 1 ? 0 : 2 > y ;\n"
+                                "}";
+            const char exp[] = "template < class T > struct foo ; "
+                               "void bar ( ) { "
+                               "foo < 6 > x ; "
+                               "foo < 0 > y ; "
+                               "}";
+            ASSERT_EQUALS(exp, tok(code));
         }
-
         {
-            const char code[] = "class ABC { } abc, def;";
-            const char expected[] = "class ABC { } ; ABC abc ; ABC def ;";
-            ASSERT_EQUALS(expected, tok(code, false));
+            const char code[] = "bool b = true ? false : 1 > 2 ;";
+            const char exp[] = "bool b ; b = true ? false : 1 > 2 ;";
+            ASSERT_EQUALS(exp, tok(code));
         }
+    }
 
+    void simplifyVarDeclInitLists()
+    {
         {
-            const char code[] = "class ABC { } abc, * pabc;";
-            const char expected[] = "class ABC { } ; ABC abc ; ABC * pabc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
+            const char code[] = "std::vector<int> v{a * b, 1};";
+            const char exp[] = "std :: vector < int > v { a * b , 1 } ;";
+            ASSERT_EQUALS(exp, tok(code));
         }
-
         {
-            const char code[] = "class ABC { class DEF {} def; } abc;";
-            const char expected[] = "class ABC { class DEF { } ; DEF def ; } ; ABC abc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
+            const char code[] = "enum E { E0 } e{};";
+            const char exp[] = "enum E { E0 } ; enum E e ; e = { } ;";
+            ASSERT_EQUALS(exp, tok(code));
         }
-
-        {
-            const char code[] = "class { } abc;";
-            const char expected[] = "class { } abc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
-
-        {
-            const char code[] = "class { } * pabc;";
-            const char expected[] = "class { } * pabc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
-
-        {
-            const char code[] = "class { } abc[4];";
-            const char expected[] = "class { } abc [ 4 ] ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
-
-        {
-            const char code[] = "class { } abc, def;";
-            const char expected[] = "class { } abc , def ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
-
-        {
-            const char code[] = "class { } abc, * pabc;";
-            const char expected[] = "class { } abc , * pabc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
-
-        {
-            const char code[] = "struct { class DEF {} def; } abc;";
-            const char expected[] = "struct Anonymous0 { class DEF { } ; DEF def ; } ; struct Anonymous0 abc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
-
-        {
-            const char code[] = "class ABC { struct {} def; } abc;";
-            const char expected[] = "class ABC { struct Anonymous0 { } ; struct Anonymous0 def ; } ; ABC abc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
-
-        {
-            const char code[] = "class { class {} def; } abc;";
-            const char expected[] = "class { class { } def ; } abc ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
-
-        {
-            const char code[] = "class ABC { struct {} def; };";
-            const char expected[] = "class ABC { struct Anonymous0 { } ; struct Anonymous0 def ; } ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
-
-        {
-            const char code[] = "class ABC : public XYZ { struct {} def; };";
-            const char expected[] = "class ABC : public XYZ { struct Anonymous0 { } ; struct Anonymous0 def ; } ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
-
-        {
-            const char code[] = "class { int x; }; int y;";
-            const char expected[] = "class { int x ; } ; int y ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
-
-        {
-            const char code[] = "class { int x; };";
-            const char expected[] = "class { int x ; } ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
-
-        {
-            const char code[] = "class { };";
-            const char expected[] = "class { } ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
-
-        {
-            const char code[] = "class { struct { struct { } ; } ; };";
-            const char expected[] = "class { } ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
-    }
-
-    void simplifyStructDecl4() {
-        const char code[] = "class ABC {\n"
-                            "    void foo() {\n"
-                            "        union {\n"
-                            "            int i;\n"
-                            "            float f;\n"
-                            "        };\n"
-                            "        struct Fee { } fee;\n"
-                            "    }\n"
-                            "    union {\n"
-                            "        long long ll;\n"
-                            "        double d;\n"
-                            "    };\n"
-                            "} abc;\n";
-        const char expected[] = "class ABC { "
-                                "void foo ( ) { "
-                                "int i ; "
-                                "float & f = i ; "
-                                "struct Fee { } ; struct Fee fee ; "
-                                "} "
-                                "union { "
-                                "long long ll ; "
-                                "double d ; "
-                                "} ; "
-                                "} ; ABC abc ;";
-        ASSERT_EQUALS(expected, tok(code, false));
-    }
-
-    void simplifyStructDecl6() {
-        ASSERT_EQUALS("struct A { "
-                      "char integers [ X ] ; "
-                      "} ; struct A arrays ; arrays = { { 0 } } ;",
-                      tok("struct A {\n"
-                          "    char integers[X];\n"
-                          "} arrays = {{0}};", false));
-    }
-
-    void simplifyStructDecl7() {
-        ASSERT_EQUALS("struct Anonymous0 { char x ; } ; struct Anonymous0 a [ 2 ] ;",
-                      tok("struct { char x; } a[2];", false));
-        ASSERT_EQUALS("struct Anonymous0 { char x ; } ; static struct Anonymous0 a [ 2 ] ;",
-                      tok("static struct { char x; } a[2];", false));
-    }
-
-    void simplifyStructDecl8() {
-        ASSERT_EQUALS("enum A { x , y , z } ; enum A a ; a = x ;", tok("enum A { x, y, z } a(x);", false));
-        ASSERT_EQUALS("enum B { x , y , z } ; enum B b ; b = x ;", tok("enum B { x , y, z } b{x};", false));
-        ASSERT_EQUALS("struct C { int i ; } ; struct C c ; c = { 0 } ;", tok("struct C { int i; } c{0};", false));
-        ASSERT_EQUALS("enum Anonymous0 { x , y , z } ; enum Anonymous0 d ; d = x ;", tok("enum { x, y, z } d(x);", false));
-        ASSERT_EQUALS("enum Anonymous0 { x , y , z } ; enum Anonymous0 e ; e = x ;", tok("enum { x, y, z } e{x};", false));
-        ASSERT_EQUALS("struct Anonymous0 { int i ; } ; struct Anonymous0 f ; f = { 0 } ;", tok("struct { int i; } f{0};", false));
-        ASSERT_EQUALS("struct Anonymous0 { } ; struct Anonymous0 x ; x = { 0 } ;", tok("struct {} x = {0};", false));
-        ASSERT_EQUALS("enum G : short { x , y , z } ; enum G g ; g = x ;", tok("enum G : short { x, y, z } g(x);", false));
-        ASSERT_EQUALS("enum H : short { x , y , z } ; enum H h ; h = x ;", tok("enum H : short { x, y, z } h{x};", false));
-        ASSERT_EQUALS("enum class I : short { x , y , z } ; enum I i ; i = x ;", tok("enum class I : short { x, y, z } i(x);", false));
-        ASSERT_EQUALS("enum class J : short { x , y , z } ; enum J j ; j = x ;", tok("enum class J : short { x, y, z } j{x};", false));
-    }
-
-    void removeUnwantedKeywords() {
-        ASSERT_EQUALS("int var ;", tok("register int var ;", true));
-        ASSERT_EQUALS("short var ;", tok("register short int var ;", true));
-        ASSERT_EQUALS("int foo ( ) { }", tok("inline int foo ( ) { }", true));
-        ASSERT_EQUALS("int foo ( ) { }", tok("__inline int foo ( ) { }", true));
-        ASSERT_EQUALS("int foo ( ) { }", tok("__forceinline int foo ( ) { }", true));
-        ASSERT_EQUALS("const int foo ( ) { }", tok("constexpr int foo() { }", true));
-        ASSERT_EQUALS("void f ( ) { int final [ 10 ] ; }", tok("void f() { int final[10]; }", true));
-        ASSERT_EQUALS("int * p ;", tok("int * __restrict p;", "test.c"));
-        ASSERT_EQUALS("int * * p ;", tok("int * __restrict__ * p;", "test.c"));
-        ASSERT_EQUALS("void foo ( float * a , float * b ) ;", tok("void foo(float * __restrict__ a, float * __restrict__ b);", "test.c"));
-        ASSERT_EQUALS("int * p ;", tok("int * restrict p;", "test.c"));
-        ASSERT_EQUALS("int * * p ;", tok("int * restrict * p;", "test.c"));
-        ASSERT_EQUALS("void foo ( float * a , float * b ) ;", tok("void foo(float * restrict a, float * restrict b);", "test.c"));
-        ASSERT_EQUALS("void foo ( int restrict ) ;", tok("void foo(int restrict);"));
-        ASSERT_EQUALS("int * p ;", tok("typedef int * __restrict__ rint; rint p;", "test.c"));
-
-        // don't remove struct members:
-        ASSERT_EQUALS("a = b . _inline ;", tok("a = b._inline;", true));
-
-        ASSERT_EQUALS("int i ; i = 0 ;", tok("auto int i = 0;", "test.c"));
-        ASSERT_EQUALS("auto i ; i = 0 ;", tok("auto i = 0;", "test.cpp"));
-    }
-
-    void simplifyCallingConvention() {
-        ASSERT_EQUALS("int f ( ) ;", tok("int __cdecl f();", true));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __stdcall f();", true));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __fastcall f();", true));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __clrcall f();", true));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __thiscall f();", true));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __syscall f();", true));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __pascal f();", true));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __fortran f();", true));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __far __cdecl f();", true));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __far __stdcall f();", true));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __far __fastcall f();", true));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __far __clrcall f();", true));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __far __thiscall f();", true));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __far __syscall f();", true));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __far __pascal f();", true));
-        ASSERT_EQUALS("int f ( ) ;", tok("int __far __fortran f();", true));
-        ASSERT_EQUALS("int f ( ) ;", tok("int WINAPI f();", true, Settings::Win32A));
-        ASSERT_EQUALS("int f ( ) ;", tok("int APIENTRY f();", true, Settings::Win32A));
-        ASSERT_EQUALS("int f ( ) ;", tok("int CALLBACK f();", true, Settings::Win32A));
-
-        // don't simplify Microsoft defines in unix code (#7554)
-        ASSERT_EQUALS("enum E { CALLBACK } ;", tok("enum E { CALLBACK } ;", true, Settings::Unix32));
-    }
-
-    void simplifyFunctorCall() {
-        ASSERT_EQUALS("IncrementFunctor ( ) ( a ) ;", tok("IncrementFunctor()(a);", true));
-    }
-
-    // #ticket #5339 (simplify function pointer after comma)
-    void simplifyFunctionPointer() {
-        ASSERT_EQUALS("f ( double x , double * y ) ;", tok("f (double x, double (*y) ());", true));
-    }
-
-    void redundant_semicolon() {
-        ASSERT_EQUALS("void f ( ) { ; }", tok("void f() { ; }", false));
-        ASSERT_EQUALS("void f ( ) { ; }", tok("void f() { do { ; } while (0); }", true));
-    }
-
-    void simplifyFunctionReturn() {
-        {
-            const char code[] = "typedef void (*testfp)();\n"
-                                "struct Fred\n"
-                                "{\n"
-                                "    testfp get1() { return 0; }\n"
-                                "    void ( * get2 ( ) ) ( ) { return 0 ; }\n"
-                                "    testfp get3();\n"
-                                "    void ( * get4 ( ) ) ( );\n"
-                                "};";
-            const char expected[] = "struct Fred "
-                                    "{ "
-                                    "void * get1 ( ) { return 0 ; } "
-                                    "void * get2 ( ) { return 0 ; } "
-                                    "void * get3 ( ) ; "
-                                    "void * get4 ( ) ; "
-                                    "} ;";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
-        {
-            const char code[] = "class Fred {\n"
-                                "    std::string s;\n"
-                                "    const std::string & foo();\n"
-                                "};\n"
-                                "const std::string & Fred::foo() { return \"\"; }";
-            const char expected[] = "class Fred { "
-                                    "std :: string s ; "
-                                    "const std :: string & foo ( ) ; "
-                                    "} ; "
-                                    "const std :: string & Fred :: foo ( ) { return \"\" ; }";
-            ASSERT_EQUALS(expected, tok(code, false));
-        }
-        {
-            // Ticket #7916
-            // Tokenization would include "int fact < 2 > ( ) { return 2 > ( ) ; }" and generate
-            // a parse error (and use after free)
-            const char code[] = "extern \"C\" void abort ();\n"
-                                "template <int a> inline int fact2 ();\n"
-                                "template <int a> inline int fact () {\n"
-                                "  return a * fact2<a-1> ();\n"
-                                "}\n"
-                                "template <> inline int fact<1> () {\n"
-                                "  return 1;\n"
-                                "}\n"
-                                "template <int a> inline int fact2 () {\n"
-                                "  return a * fact<a-1>();\n"
-                                "}\n"
-                                "template <> inline int fact2<1> () {\n"
-                                "  return 1;\n"
-                                "}\n"
-                                "int main() {\n"
-                                "  fact2<3> ();\n"
-                                "  fact2<2> ();\n"
-                                "}";
-            tok(code);
-        }
-    }
-
-    void removeVoidFromFunction() {
-        ASSERT_EQUALS("void foo ( ) ;", tok("void foo(void);"));
-    }
-
-    void return_strncat() {
-        {
-            const char code[] = "char *f()\n"
-                                "{\n"
-                                "    char *temp=malloc(2);\n"
-                                "    strcpy(temp,\"\");\n"
-                                "    return (strncat(temp,\"a\",1));\n"
-                                "}";
-            ASSERT_EQUALS("char * f ( ) {"
-                          " char * temp ;"
-                          " temp = malloc ( 2 ) ;"
-                          " strcpy ( temp , \"\" ) ;"
-                          " strncat ( temp , \"a\" , 1 ) ;"
-                          " return temp ; "
-                          "}", tok(code, true));
-        }
-        {
-            const char code[] = "char *f()\n"
-                                "{\n"
-                                "    char **temp=malloc(8);\n"
-                                "    *temp = malloc(2);\n"
-                                "    strcpy(*temp,\"\");\n"
-                                "    return (strncat(*temp,\"a\",1));\n"
-                                "}";
-            ASSERT_EQUALS("char * f ( ) {"
-                          " char * * temp ;"
-                          " temp = malloc ( 8 ) ;"
-                          " * temp = malloc ( 2 ) ;"
-                          " strcpy ( * temp , \"\" ) ;"
-                          " strncat ( * temp , \"a\" , 1 ) ;"
-                          " return * temp ; "
-                          "}", tok(code, true));
-        }
-        {
-            const char code[] = "char *f()\n"
-                                "{\n"
-                                "    char **temp=malloc(8);\n"
-                                "    *temp = malloc(2);\n"
-                                "    strcpy(*temp,\"\");\n"
-                                "    return (strncat(temp[0],foo(b),calc(c-d)));\n"
-                                "}";
-            ASSERT_EQUALS("char * f ( ) {"
-                          " char * * temp ;"
-                          " temp = malloc ( 8 ) ;"
-                          " * temp = malloc ( 2 ) ;"
-                          " strcpy ( * temp , \"\" ) ;"
-                          " strncat ( temp [ 0 ] , foo ( b ) , calc ( c - d ) ) ;"
-                          " return temp [ 0 ] ; "
-                          "}", tok(code, true));
-        }
-    }
-
-    void removeRedundantFor() { // ticket #3069
-        {
-            const char code[] = "void f() {"
-                                "    for(x=0;x<1;x++) {"
-                                "        y = 1;"
-                                "    }"
-                                "}";
-            ASSERT_EQUALS("void f ( ) { { y = 1 ; } x = 1 ; }", tok(code, true));
-        }
-
-        {
-            const char code[] = "void f() {"
-                                "    for(x=0;x<1;x++) {"
-                                "        y = 1 + x;"
-                                "    }"
-                                "}";
-            ASSERT_EQUALS("void f ( ) { x = 0 ; { y = 1 + x ; } x = 1 ; }", tok(code, true));
-        }
-
-        {
-            const char code[] = "void f() {"
-                                "    foo();"
-                                "    for(int x=0;x<1;x++) {"
-                                "        y = 1 + x;"
-                                "    }"
-                                "}";
-            ASSERT_EQUALS("void f ( ) { foo ( ) ; { int x = 0 ; y = 1 + x ; } }", tok(code, true));
-        }
-    }
-
-    void consecutiveBraces() {
-        ASSERT_EQUALS("void f ( ) { }", tok("void f(){{}}", true));
-        ASSERT_EQUALS("void f ( ) { }", tok("void f(){{{}}}", true));
-        ASSERT_EQUALS("void f ( ) { for ( ; ; ) { } }", tok("void f () { for(;;){} }", true));
-        ASSERT_EQUALS("void f ( ) { { scope_lock lock ; foo ( ) ; } { scope_lock lock ; bar ( ) ; } }", tok("void f () { {scope_lock lock; foo();} {scope_lock lock; bar();} }", true));
-    }
-
-    void undefinedSizeArray() {
-        ASSERT_EQUALS("int * x ;", tok("int x [];"));
-        ASSERT_EQUALS("int * * x ;", tok("int x [][];"));
-        ASSERT_EQUALS("int * * x ;", tok("int * x [];"));
-        ASSERT_EQUALS("int * * * x ;", tok("int * x [][];"));
-        ASSERT_EQUALS("int * * * * x ;", tok("int * * x [][];"));
-        ASSERT_EQUALS("void f ( int x [ ] , double y [ ] ) { }", tok("void f(int x[], double y[]) { }"));
-        ASSERT_EQUALS("int x [ 13 ] = { [ 11 ] = 2 , [ 12 ] = 3 } ;", tok("int x[] = {[11]=2, [12]=3};"));
-    }
-
-    void simplifyArrayAddress() { // ticket #3304
-        const char code[] = "void foo() {\n"
-                            "    int a[10];\n"
-                            "    memset(&a[4], 0, 20*sizeof(int));\n"
-                            "}";
-        ASSERT_EQUALS("void foo ( ) {"
-                      " int a [ 10 ] ;"
-                      " memset ( a + 4 , 0 , 80 ) ;"
-                      " }", tok(code, true));
-    }
-
-    void simplifyCharAt() { // ticket #4481
-        ASSERT_EQUALS("'h' ;", tok("\"hello\"[0] ;"));
-        ASSERT_EQUALS("'\\n' ;", tok("\"\\n\"[0] ;"));
-        ASSERT_EQUALS("'\\0' ;", tok("\"hello\"[5] ;"));
-        ASSERT_EQUALS("'\\0' ;", tok("\"\"[0] ;"));
-        ASSERT_EQUALS("'\\0' ;", tok("\"\\0\"[0] ;"));
-        ASSERT_EQUALS("'\\n' ;", tok("\"hello\\nworld\"[5] ;"));
-        ASSERT_EQUALS("'w' ;", tok("\"hello world\"[6] ;"));
-        ASSERT_EQUALS("\"hello\" [ 7 ] ;", tok("\"hello\"[7] ;"));
-        ASSERT_EQUALS("\"hello\" [ -1 ] ;", tok("\"hello\"[-1] ;"));
-    }
-
-    void test_4881() {
-        const char code[] = "int evallex() {\n"
-                            "  int c, t;\n"
-                            "again:\n"
-                            "   do {\n"
-                            "      if ((c = macroid(c)) == EOF_CHAR || c == '\\n') {\n"
-                            "      }\n"
-                            "   } while ((t = type[c]) == LET && catenate());\n"
-                            "}\n";
-        ASSERT_EQUALS("int evallex ( ) { int c ; int t ; again : ; do { c = macroid ( c ) ; if ( c == EOF_CHAR || c == '\\n' ) { } t = type [ c ] ; } while ( t == LET && catenate ( ) ) ; }",
-                      tok(code, true));
-    }
-
-    void simplifyOverride() { // ticket #5069
-        const char code[] = "void fun() {\n"
-                            "    unsigned char override[] = {0x01, 0x02};\n"
-                            "    doSomething(override, sizeof(override));\n"
-                            "}\n";
-        ASSERT_EQUALS("void fun ( ) { char override [ 2 ] = { 1 , 2 } ; doSomething ( override , 2 ) ; }",
-                      tok(code, true));
-    }
-
-    void simplifyNestedNamespace() {
-        ASSERT_EQUALS("namespace A { namespace B { namespace C { int i ; } } }", tok("namespace A::B::C { int i; }"));
-    }
-
-    void simplifyNamespaceAliases() {
-        ASSERT_EQUALS(";",
-                      tok("namespace ios = boost::iostreams;"));
-        ASSERT_EQUALS("boost :: iostreams :: istream foo ( \"foo\" ) ;",
-                      tok("namespace ios = boost::iostreams; ios::istream foo(\"foo\");"));
-        ASSERT_EQUALS("boost :: iostreams :: istream foo ( \"foo\" ) ;",
-                      tok("using namespace std; namespace ios = boost::iostreams; ios::istream foo(\"foo\");"));
-        ASSERT_EQUALS(";",
-                      tok("using namespace std; namespace ios = boost::iostreams;"));
-        ASSERT_EQUALS("namespace NS { boost :: iostreams :: istream foo ( \"foo\" ) ; }",
-                      tok("namespace NS { using namespace std; namespace ios = boost::iostreams; ios::istream foo(\"foo\"); }"));
-
-        // duplicate namespace aliases
-        ASSERT_EQUALS(";",
-                      tok("namespace ios = boost::iostreams;\nnamespace ios = boost::iostreams;"));
-        ASSERT_EQUALS(";",
-                      tok("namespace ios = boost::iostreams;\nnamespace ios = boost::iostreams;\nnamespace ios = boost::iostreams;"));
-        ASSERT_EQUALS("namespace A { namespace B { void foo ( ) { bar ( A :: B :: ab ( ) ) ; } } }",
-                      tok("namespace A::B {"
-                          "namespace AB = A::B;"
-                          "void foo() {"
-                          "    namespace AB = A::B;" // duplicate declaration
-                          "    bar(AB::ab());"
-                          "}"
-                          "namespace AB = A::B;" //duplicate declaration
-                          "}"));
-
-        // redeclared nested namespace aliases
-        TODO_ASSERT_EQUALS("namespace A { namespace B { void foo ( ) { bar ( A :: B :: ab ( ) ) ; { baz ( A :: a ( ) ) ; } bar ( A :: B :: ab ( ) ) ; } } }",
-                           "namespace A { namespace B { void foo ( ) { bar ( A :: B :: ab ( ) ) ; { baz ( A :: B :: a ( ) ) ; } bar ( A :: B :: ab ( ) ) ; } } }",
-                           tok("namespace A::B {"
-                               "namespace AB = A::B;"
-                               "void foo() {"
-                               "    namespace AB = A::B;" // duplicate declaration
-                               "    bar(AB::ab());"
-                               "    {"
-                               "         namespace AB = A;"
-                               "         baz(AB::a());" // redeclaration OK
-                               "    }"
-                               "    bar(AB::ab());"
-                               "}"
-                               "namespace AB = A::B;" //duplicate declaration
-                               "}"));
     }
 };
 
diff --git a/test/testsimplifytypedef.cpp b/test/testsimplifytypedef.cpp
index 47c0c326698..12ee24ee5e1 100644
--- a/test/testsimplifytypedef.cpp
+++ b/test/testsimplifytypedef.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,38 +16,69 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
-#include "platform.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "settings.h"
-#include "testsuite.h"
+#include "standards.h"
 #include "token.h"
 #include "tokenize.h"
 #include "tokenlist.h"
 
-struct InternalError;
+#include <cstddef>
+#include <string>
+#include <utility>
 
+class ErrorLogger;
 
 class TestSimplifyTypedef : public TestFixture {
 public:
-    TestSimplifyTypedef() : TestFixture("TestSimplifyTypedef") {
-    }
+    TestSimplifyTypedef() : TestFixture("TestSimplifyTypedef") {}
 
 
 private:
-    Settings settings0;
-    Settings settings1;
-    Settings settings2;
-
-    void run() OVERRIDE {
-        settings0.addEnabled("style");
-        settings2.addEnabled("style");
-
-        TEST_CASE(simplifyTypedef1)
-        TEST_CASE(simplifyTypedef2)
-        TEST_CASE(simplifyTypedef3)
-        TEST_CASE(simplifyTypedef4)
-        TEST_CASE(simplifyTypedef5)
-        TEST_CASE(simplifyTypedef6)
+    const Settings settings0 = settingsBuilder().severity(Severity::style).build();
+    const Settings settings1 = settingsBuilder().severity(Severity::portability).build();
+
+    void run() override {
+        mNewTemplate = true;
+        TEST_CASE(c1);
+        TEST_CASE(c2);
+        TEST_CASE(canreplace1);
+        TEST_CASE(canreplace2);
+        TEST_CASE(canreplace3);
+        TEST_CASE(canreplace4);
+        TEST_CASE(cconst);
+        TEST_CASE(cstruct1);
+        TEST_CASE(cstruct2);
+        TEST_CASE(cstruct3);
+        TEST_CASE(cstruct3);
+        TEST_CASE(cstruct4);
+        TEST_CASE(cenum1);
+        TEST_CASE(cfunction1);
+        TEST_CASE(cfunction2);
+        TEST_CASE(cfunction3);
+        TEST_CASE(cfunction4);
+        TEST_CASE(cfp1);
+        TEST_CASE(cfp2);
+        TEST_CASE(cfp4);
+        TEST_CASE(cfp5);
+        TEST_CASE(cfp6);
+        TEST_CASE(cfp7);
+        TEST_CASE(carray1);
+        TEST_CASE(carray2);
+        TEST_CASE(carray3);
+        TEST_CASE(carray4);
+        TEST_CASE(cdonotreplace1);
+        TEST_CASE(cppfp1);
+        TEST_CASE(Generic1);
+
+        TEST_CASE(simplifyTypedef1);
+        TEST_CASE(simplifyTypedef2);
+        TEST_CASE(simplifyTypedef3);
+        TEST_CASE(simplifyTypedef4);
+        TEST_CASE(simplifyTypedef5);
+        TEST_CASE(simplifyTypedef6);
         TEST_CASE(simplifyTypedef7);
         TEST_CASE(simplifyTypedef8);
         TEST_CASE(simplifyTypedef9);
@@ -82,7 +113,9 @@ class TestSimplifyTypedef : public TestFixture {
         TEST_CASE(simplifyTypedef38);
         TEST_CASE(simplifyTypedef43); // ticket #1588
         TEST_CASE(simplifyTypedef44);
+        mNewTemplate = false;
         TEST_CASE(simplifyTypedef45); // ticket #1613
+        mNewTemplate = true;
         TEST_CASE(simplifyTypedef46);
         TEST_CASE(simplifyTypedef47);
         TEST_CASE(simplifyTypedef48); // ticket #1673
@@ -164,6 +197,39 @@ class TestSimplifyTypedef : public TestFixture {
         TEST_CASE(simplifyTypedef126); // ticket #5953
         TEST_CASE(simplifyTypedef127); // ticket #8878
         TEST_CASE(simplifyTypedef128); // ticket #9053
+        TEST_CASE(simplifyTypedef129);
+        TEST_CASE(simplifyTypedef130); // ticket #9446
+        TEST_CASE(simplifyTypedef131); // ticket #9446
+        TEST_CASE(simplifyTypedef132); // ticket #9739 - using
+        TEST_CASE(simplifyTypedef133); // ticket #9812 - using
+        TEST_CASE(simplifyTypedef134);
+        TEST_CASE(simplifyTypedef135); // ticket #10068
+        TEST_CASE(simplifyTypedef136);
+        TEST_CASE(simplifyTypedef137);
+        TEST_CASE(simplifyTypedef138);
+        mNewTemplate = false;
+        TEST_CASE(simplifyTypedef139);
+        mNewTemplate = true;
+        TEST_CASE(simplifyTypedef140); // #10798
+        TEST_CASE(simplifyTypedef141); // #10144
+        TEST_CASE(simplifyTypedef142); // T() when T is a pointer type
+        TEST_CASE(simplifyTypedef143); // #11506
+        TEST_CASE(simplifyTypedef144); // #9353
+        TEST_CASE(simplifyTypedef145); // #9353
+        TEST_CASE(simplifyTypedef146);
+        TEST_CASE(simplifyTypedef147);
+        TEST_CASE(simplifyTypedef148);
+        TEST_CASE(simplifyTypedef149);
+        TEST_CASE(simplifyTypedef150);
+        TEST_CASE(simplifyTypedef151);
+        TEST_CASE(simplifyTypedef152);
+        TEST_CASE(simplifyTypedef153);
+        TEST_CASE(simplifyTypedef154);
+        TEST_CASE(simplifyTypedef155);
+        TEST_CASE(simplifyTypedef156);
+        TEST_CASE(simplifyTypedef157);
+        TEST_CASE(simplifyTypedef158);
+        TEST_CASE(simplifyTypedef159);
 
         TEST_CASE(simplifyTypedefFunction1);
         TEST_CASE(simplifyTypedefFunction2); // ticket #1685
@@ -175,51 +241,329 @@ class TestSimplifyTypedef : public TestFixture {
         TEST_CASE(simplifyTypedefFunction8);
         TEST_CASE(simplifyTypedefFunction9);
         TEST_CASE(simplifyTypedefFunction10); // #5191
+        TEST_CASE(simplifyTypedefFunction11);
+
+        TEST_CASE(simplifyTypedefStruct); // #12081 - volatile struct
 
         TEST_CASE(simplifyTypedefShadow);  // #4445 - shadow variable
+
+        TEST_CASE(simplifyTypedefMacro);
+
+        TEST_CASE(simplifyTypedefOriginalName1);
+        TEST_CASE(simplifyTypedefOriginalName2);
+
+        TEST_CASE(simplifyTypedefTokenColumn1);
+        TEST_CASE(simplifyTypedefTokenColumn2);
+        TEST_CASE(simplifyTypedefTokenColumn3);
+
+        TEST_CASE(typedefInfo1);
+        TEST_CASE(typedefInfo2);
+        TEST_CASE(typedefInfo3);
+        TEST_CASE(typedefInfo4);
     }
 
-    std::string tok(const char code[], bool simplify = true, Settings::PlatformType type = Settings::Native, bool debugwarnings = true) {
-        errout.str("");
+    class TokenizerTest final : public Tokenizer
+    {
+        friend class TestSimplifyTypedef;
+    public:
+        TokenizerTest(TokenList tokenList, ErrorLogger &errorLogger)
+            : Tokenizer(std::move(tokenList), errorLogger)
+        {}
+    };
 
-        settings0.inconclusive = true;
-        settings0.debugwarnings = debugwarnings;   // show warnings about unhandled typedef
-        settings0.platform(type);
-        Tokenizer tokenizer(&settings0, this);
+    struct TokOptions
+    {
+        bool simplify = true;
+        bool debugwarnings = true;
+    };
 
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+#define tok(...) tok_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    std::string tok_(const char* file, int line, const char (&code)[size], const TokOptions& options = make_default_obj()) {
+        // show warnings about unhandled typedef
+        const Settings settings = settingsBuilder(settings0).certainty(Certainty::inconclusive).debugwarnings(options.debugwarnings).build();
+        SimpleTokenizer tokenizer(settings, *this);
 
-        if (simplify)
-            tokenizer.simplifyTokenList2();
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
-        return tokenizer.tokens()->stringifyList(nullptr, !simplify);
+        return tokenizer.tokens()->stringifyList(nullptr, !options.simplify);
     }
 
-    std::string simplifyTypedef(const char code[]) {
-        errout.str("");
+    template<size_t size>
+    std::string simplifyTypedef(const char (&data)[size]) {
+        TokenList tokenlist{settings1, Standards::Language::CPP};
+        if (!tokenlist.createTokensFromString(data))
+            return "";
+        TokenizerTest tokenizer(std::move(tokenlist), *this);
+        tokenizer.createLinks();
+        tokenizer.simplifyTypedef();
+
+        return tokenizer.tokens()->stringifyList(nullptr, false);
+    }
 
-        Tokenizer tokenizer(&settings1, this);
+    template<size_t size>
+    std::string simplifyTypedefP(const char (&code)[size]) {
+        SimpleTokenizer2 tokenizer(settings0, *this, code, "test.cpp");
 
-        std::istringstream istr(code);
-        tokenizer.list.createTokens(istr);
+        // Tokenize..
         tokenizer.createLinks();
         tokenizer.simplifyTypedef();
 
         return tokenizer.tokens()->stringifyList(nullptr, false);
     }
 
-    void checkSimplifyTypedef(const char code[]) {
-        errout.str("");
+#define checkSimplifyTypedef(...) checkSimplifyTypedef_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkSimplifyTypedef_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        settings2.inconclusive = true;
-        settings2.debugwarnings = true;   // show warnings about unhandled typedef
-        Tokenizer tokenizer(&settings2, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        // show warnings about unhandled typedef
+        const Settings settings = settingsBuilder(settings0).certainty(Certainty::inconclusive).debugwarnings().build();
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+    }
+
+
+    template<size_t size>
+    std::string simplifyTypedefC(const char (&data)[size]) {
+        TokenList tokenlist{settings1, Standards::Language::C};
+
+        if (!TokenListHelper::createTokensFromString(tokenlist, data, "file.c"))
+            return "";
+        TokenizerTest tokenizer(std::move(tokenlist), *this);
+        tokenizer.createLinks();
+        tokenizer.simplifyTypedef();
+        try {
+            tokenizer.validate();
+        } catch (const InternalError&) {
+            return "";
+        }
+        return tokenizer.tokens()->stringifyList(nullptr, false);
+    }
+
+    template<size_t size>
+    std::string dumpTypedefInfo(const char (&code)[size]) {
+        TokenList tokenlist{settings1, Standards::Language::C};
+        if (!TokenListHelper::createTokensFromString(tokenlist, code, "file.c"))
+            return {};
+        TokenizerTest tokenizer(std::move(tokenlist), *this);
+        tokenizer.createLinks();
+        tokenizer.simplifyTypedef();
+        try {
+            tokenizer.validate();
+        } catch (const InternalError&) {
+            return {};
+        }
+        return tokenizer.dumpTypedefInfo();
+    }
+
+    void c1() {
+        const char code[] = "typedef int t;\n"
+                            "t x;";
+        ASSERT_EQUALS("int x ;", simplifyTypedefC(code));
+    }
+
+    void c2() {
+        const char code[] = "void f1() { typedef int t; t x; }\n"
+                            "void f2() { typedef float t; t x; }\n";
+        ASSERT_EQUALS("void f1 ( ) { int x ; } void f2 ( ) { float x ; }", simplifyTypedefC(code));
+    }
+
+    void canreplace1() {
+        const char code[] = "typedef unsigned char u8;\n"
+                            "void f(uint8_t u8) { x = u8 & y; }\n";
+        ASSERT_EQUALS("void f ( uint8_t u8 ) { x = u8 & y ; }", simplifyTypedefC(code));
+    }
+
+    void canreplace2() {
+        const char code1[] = "typedef char* entry;\n"
+                             "void f(Y* entry) { for (entry=x->y; entry; entry = entry->next) {} }\n";
+        ASSERT_EQUALS("void f ( Y * entry ) { for ( entry = x -> y ; entry ; entry = entry -> next ) { } }", simplifyTypedefC(code1));
+
+        const char code2[] = "typedef char* entry;\n"
+                             "void f() { dostuff(entry * 2); }\n";
+        ASSERT_EQUALS("void f ( ) { dostuff ( entry * 2 ) ; }", simplifyTypedefC(code2));
+
+        const char code3[] = "typedef char* entry;\n"
+                             "void f() { dostuff(entry * y < z); }\n";
+        ASSERT_EQUALS("void f ( ) { dostuff ( entry * y < z ) ; }", simplifyTypedefC(code3));
+    }
+
+    void canreplace3() {
+        const char code1[] = "typedef char* c_str;\n" // #11640
+                             "struct S {\n"
+                             "    const char* g() const {\n"
+                             "        return s.c_str();\n"
+                             "    }\n"
+                             "    std::string s;\n"
+                             "};\n";
+        ASSERT_EQUALS("struct S { const char * g ( ) const { return s . c_str ( ) ; } std :: string s ; } ;", simplifyTypedefC(code1));
+    }
+
+    void canreplace4() {
+        const char code1[] = "typedef std::vector<int> X;\n" // #12026
+                             "struct S {\n"
+                             "    enum E { X };\n"
+                             "};\n";
+        ASSERT_EQUALS("struct S { enum E { X } ; } ;", simplifyTypedef(code1));
+    }
+
+    void cconst() {
+        const char code1[] = "typedef void* HWND;\n"
+                             "const HWND x;";
+        ASSERT_EQUALS("void * const x ;", simplifyTypedef(code1));
+
+        const char code2[] = "typedef void (*fp)();\n"
+                             "const fp x;";
+        ASSERT_EQUALS("void ( * const x ) ( ) ;", simplifyTypedef(code2));
+    }
+
+    void cstruct1() {
+        const char code[] = "typedef struct { int a; int b; } t;\n"
+                            "t x;";
+        ASSERT_EQUALS("struct t { int a ; int b ; } ; struct t x ;", simplifyTypedef(code));
+        ASSERT_EQUALS("struct t { int a ; int b ; } ; struct t x ;", simplifyTypedefC(code));
+    }
+
+    void cstruct2() {
+        const char code[] = "typedef enum { A, B } t;\n"
+                            "t x;";
+        ASSERT_EQUALS("enum t { A , B } ; enum t x ;", simplifyTypedef(code));
+        ASSERT_EQUALS("enum t { A , B } ; enum t x ;", simplifyTypedefC(code));
+    }
+
+    void cstruct3() {
+        const char code[] = "typedef struct s { int a; int b; } t;\n"
+                            "t x;";
+        ASSERT_EQUALS("struct s { int a ; int b ; } ; struct s x ;", simplifyTypedefC(code));
+    }
+
+    void cstruct4() {
+        const char code[] = "typedef struct s { int a; int b; } t;\n"
+                            "struct t x{};";
+        ASSERT_EQUALS("struct s { int a ; int b ; } ; struct s x { } ;", simplifyTypedefC(code));
+    }
+
+    void cenum1() {
+        const char code[] = "typedef enum { a, b } E;\n"
+                            "E e;";
+        ASSERT_EQUALS("enum E { a , b } ; enum E e ;", simplifyTypedefC(code));
     }
 
+    void cfunction1() {
+        const char code[] = "typedef int callback(int);\n"
+                            "callback* cb;";
+        ASSERT_EQUALS("int ( * cb ) ( int ) ;", simplifyTypedefC(code));
+    }
+
+    void cfunction2() {
+        const char code[] = "typedef int callback(int);\n"
+                            "typedef callback* callbackPtr;\n"
+                            "callbackPtr cb;";
+        ASSERT_EQUALS("int ( * cb ) ( int ) ;", simplifyTypedefC(code));
+    }
+
+    void cfunction3() {
+        const char code[] = "typedef int f(int);\n"
+                            "typedef const f cf;\n";
+        (void)simplifyTypedefC(code);
+        ASSERT_EQUALS("[file.c:2:9]: (portability) It is unspecified behavior to const qualify a function type. [invalidConstFunctionType]\n", errout_str());
+    }
+
+    void cfunction4() {
+        const char code[] = "typedef int (func_t) (int);\n" // #12625
+                            "int f(int*, func_t*, int);\n";
+        ASSERT_EQUALS("int f ( int * , int ( * ) ( int ) , int ) ;", simplifyTypedefC(code));
+    }
+
+    void cfp1() {
+        const char code[] = "typedef void (*fp)(void * p);\n"
+                            "fp x;";
+        ASSERT_EQUALS("void ( * x ) ( void * p ) ;", simplifyTypedefC(code));
+    }
+
+    void cfp2() {
+        const char code[] = "typedef void (*const fp)(void * p);\n"
+                            "fp x;";
+        ASSERT_EQUALS("void ( * const x ) ( void * p ) ;", simplifyTypedefC(code));
+    }
 
+    void cfp4() {
+        const char code[] = "typedef struct S Stype ;\n"
+                            "typedef void ( * F ) ( Stype * ) ;\n"
+                            "F func;";
+        ASSERT_EQUALS("void ( * func ) ( struct S * ) ;", simplifyTypedefC(code));
+    }
+
+    void cfp5() {
+        const char code[] = "typedef void (*fp)(void);\n"
+                            "typedef fp t;\n"
+                            "void foo(t p);";
+        ASSERT_EQUALS("void foo ( void ( * p ) ( void ) ) ;", simplifyTypedef(code));
+    }
+
+    void cfp6() {
+        const char code[] = "typedef void (*fp)(void);\n"
+                            "fp a[10];";
+        ASSERT_EQUALS("void ( * a [ 10 ] ) ( void ) ;", simplifyTypedef(code));
+    }
+
+    void cfp7() {
+        const char code[] = "typedef uint32_t ((*fp)(uint32_t n));\n" // #11725
+                            "uint32_t g();\n"
+                            "fp f;\n";
+        ASSERT_EQUALS("uint32_t g ( ) ; uint32_t ( * f ) ( uint32_t n ) ;", simplifyTypedef(code));
+    }
+
+    void carray1() {
+        const char code[] = "typedef int t[20];\n"
+                            "t x;";
+        ASSERT_EQUALS("int x [ 20 ] ;", simplifyTypedefC(code));
+    }
+
+    void carray2() {
+        const char code[] = "typedef double t[4];\n"
+                            "t x[10];";
+        ASSERT_EQUALS("double x [ 10 ] [ 4 ] ;", simplifyTypedef(code));
+    }
+
+    void carray3() {
+        const char code[] = "typedef int a[256];\n" // #11689
+                            "typedef a b[256];\n"
+                            "b* p;\n";
+        ASSERT_EQUALS("int ( * p ) [ 256 ] [ 256 ] ;", simplifyTypedef(code));
+
+        const char code1[] = "typedef int a[1];\n"
+                             "typedef a b[2];\n"
+                             "typedef b c[3];\n"
+                             "c* p;\n";
+        ASSERT_EQUALS("int ( * p ) [ 3 ] [ 2 ] [ 1 ] ;", simplifyTypedef(code1));
+    }
+
+    void carray4() {
+        const char code[] = "typedef int arr[12];\n" // #12019
+                            "void foo() { arr temp = {0}; }\n";
+        ASSERT_EQUALS("void foo ( ) { int temp [ 12 ] = { 0 } ; }", tok(code));
+    }
+
+    void cdonotreplace1() {
+        const char code[] = "typedef int t;\n"
+                            "int* t;";
+        ASSERT_EQUALS("int * t ;", simplifyTypedefC(code));
+    }
+
+
+    void cppfp1() {
+        const char code[] = "typedef void (*fp)(void);\n"
+                            "typedef fp t;\n"
+                            "void foo(t p);";
+        ASSERT_EQUALS("void foo ( void ( * p ) ( void ) ) ;", tok(code));
+    }
+
+    void Generic1() {
+        const char code[] = "typedef void func(void);\n"
+                            "_Generic((x), func: 1, default: 2);";
+        ASSERT_EQUALS("_Generic ( x , void ( ) : 1 , default : 2 ) ;", tok(code));
+    }
 
     void simplifyTypedef1() {
         const char code[] = "class A\n"
@@ -249,7 +593,7 @@ class TestSimplifyTypedef : public TestFixture {
             "a . foo ( ) ; "
             "wchar_t c ; c = 0 ; "
             "}";
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef2() {
@@ -319,7 +663,7 @@ class TestSimplifyTypedef : public TestFixture {
             "unsigned int uvar ; uvar = 2 ; "
             "return uvar / ivar ; "
             "}";
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef5() {
@@ -337,7 +681,7 @@ class TestSimplifyTypedef : public TestFixture {
             "struct yy_buffer_state * state ; "
             "}";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef6() {
@@ -347,21 +691,26 @@ class TestSimplifyTypedef : public TestFixture {
             "    typedef float float_t ;\n"
             "    inline VL::float_t fast_atan2(VL::float_t y, VL::float_t x){}\n"
             "}";
-
         const char expected[] =
             "namespace VL { "
             ""
             "float fast_atan2 ( float y , float x ) { } "
             "}";
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        // ticket #11373
+        const char code1[] =
+            "typedef int foo;\n"
+            "inline foo f();\n";
+        const char expected1[] = "int f ( ) ;";
+        ASSERT_EQUALS(expected1, tok(code1, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef7() {
         const char code[] = "typedef int abc ; "
                             "Fred :: abc f ;";
         const char expected[] = "Fred :: abc f ;";
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef8() {
@@ -392,7 +741,7 @@ class TestSimplifyTypedef : public TestFixture {
             "const int & trci ; "
             "const unsigned int & trcui ;";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef9() {
@@ -410,15 +759,15 @@ class TestSimplifyTypedef : public TestFixture {
         const char expected[] =
             "struct t { int a ; } ; "
             "struct U { int a ; } ; "
-            "struct Unnamed0 { int a ; } ; "
+            "struct V { int a ; } ; "
             "struct s s ; "
             "struct s * ps ; "
             "struct t t ; "
             "struct t * tp ; "
             "struct U u ; "
-            "struct Unnamed0 * v ;";
+            "struct V * v ;";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef10() {
@@ -436,15 +785,15 @@ class TestSimplifyTypedef : public TestFixture {
         const char expected[] =
             "union t { int a ; float b ; } ; "
             "union U { int a ; float b ; } ; "
-            "union Unnamed0 { int a ; float b ; } ; "
+            "union V { int a ; float b ; } ; "
             "union s s ; "
             "union s * ps ; "
             "union t t ; "
             "union t * tp ; "
             "union U u ; "
-            "union Unnamed0 * v ;";
+            "union V * v ;";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef11() {
@@ -455,10 +804,10 @@ class TestSimplifyTypedef : public TestFixture {
 
         const char expected[] = "enum abc { a = 0 , b = 1 , c = 2 } ; "
                                 "enum xyz { x = 0 , y = 1 , z = 2 } ; "
-                                "abc e1 ; "
+                                "enum abc e1 ; "
                                 "enum xyz e2 ;";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef12() {
@@ -477,18 +826,18 @@ class TestSimplifyTypedef : public TestFixture {
             "std :: vector < std :: vector < int > > v3 ; "
             "std :: list < int > :: iterator iter ;";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef13() {
-        // ticket # 1167
+        // ticket # 1167 (InternalError)
         const char code[] = "typedef std::pair<int(*)(void*), void*> Func;"
                             "typedef std::vector<Func> CallQueue;"
                             "int main() {}";
 
         // Tokenize and check output..
-        tok(code);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_NO_THROW(tok(code));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef14() {
@@ -506,8 +855,8 @@ class TestSimplifyTypedef : public TestFixture {
                             "};";
 
         // Tokenize and check output..
-        tok(code, true, Settings::Native, false);
-        ASSERT_EQUALS("", errout.str());
+        TODO_ASSERT_THROW(tok(code, dinit(TokOptions, $.debugwarnings = false)), InternalError); // TODO: Do not throw exception
+        //ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef15() {
@@ -517,7 +866,7 @@ class TestSimplifyTypedef : public TestFixture {
 
             const char expected[] = "char f [ 10 ] ;";
 
-            ASSERT_EQUALS(expected, tok(code, false));
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
         }
 
         {
@@ -526,12 +875,12 @@ class TestSimplifyTypedef : public TestFixture {
 
             const char expected[] = "unsigned char f [ 10 ] ;";
 
-            ASSERT_EQUALS(expected, tok(code, false));
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
         }
     }
 
     void simplifyTypedef16() {
-        // ticket # 1252
+        // ticket # 1252 (InternalError)
         const char code[] = "typedef char MOT8;\n"
                             "typedef  MOT8 CHFOO[4096];\n"
                             "typedef struct {\n"
@@ -539,8 +888,8 @@ class TestSimplifyTypedef : public TestFixture {
                             "} STRFOO;";
 
         // Tokenize and check output..
-        tok(code);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_NO_THROW(tok(code));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef17() {
@@ -552,7 +901,7 @@ class TestSimplifyTypedef : public TestFixture {
             "char * pc ; "
             "char c ;";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef18() {
@@ -575,7 +924,7 @@ class TestSimplifyTypedef : public TestFixture {
                 "struct A * b ; "
                 "struct A * * c ;";
 
-            ASSERT_EQUALS(expected, tok(code, false));
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
         }
 
         {
@@ -588,7 +937,7 @@ class TestSimplifyTypedef : public TestFixture {
                 "struct A a ; "
                 "struct A * * * * * * * * * b ;";
 
-            ASSERT_EQUALS(expected, tok(code, false));
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
         }
 
         {
@@ -603,7 +952,7 @@ class TestSimplifyTypedef : public TestFixture {
                 "struct Unnamed0 * b ; "
                 "struct Unnamed0 c ;";
 
-            ASSERT_EQUALS(expected, tok(code, false));
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
         }
     }
 
@@ -643,7 +992,7 @@ class TestSimplifyTypedef : public TestFixture {
                 "static void test ( ) { } "
                 "} ;";
 
-            ASSERT_EQUALS(expected, tok(code, false));
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
         }
 
         {
@@ -660,7 +1009,7 @@ class TestSimplifyTypedef : public TestFixture {
                 "static void * test ( void * p ) { return p ; } "
                 "} ;";
 
-            ASSERT_EQUALS(expected, tok(code, false));
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
         }
 
         {
@@ -677,7 +1026,7 @@ class TestSimplifyTypedef : public TestFixture {
                 "static unsigned int * test ( unsigned int * p ) { return p ; } "
                 "} ;";
 
-            ASSERT_EQUALS(expected, tok(code, false));
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
         }
 
         {
@@ -695,7 +1044,7 @@ class TestSimplifyTypedef : public TestFixture {
                 "static const unsigned int * test ( const unsigned int * p ) { return p ; } "
                 "} ;";
 
-            ASSERT_EQUALS(expected, tok(code, false));
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
         }
 
         {
@@ -712,7 +1061,7 @@ class TestSimplifyTypedef : public TestFixture {
                 "static void * test ( void * p ) { return p ; } "
                 "} ;";
 
-            ASSERT_EQUALS(expected, tok(code, false));
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
         }
     }
 
@@ -722,10 +1071,10 @@ class TestSimplifyTypedef : public TestFixture {
                             "void    addCallback1(Callback callback, int j) { }";
 
         const char expected[] =
-            "void addCallback ( bool * callback ) { } "
-            "void addCallback1 ( bool * callback , int j ) { }";
+            "void addCallback ( bool ( * callback ) ( int ) ) { } "
+            "void addCallback1 ( bool ( * callback ) ( int ) , int j ) { }";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef24() {
@@ -737,12 +1086,12 @@ class TestSimplifyTypedef : public TestFixture {
                                 "}";
 
             const char expected[] =
-                "void g ( int * f ) "
+                "void g ( int ( * f ) ( ) ) "
                 "{ "
-                "int * f2 ; f2 = ( int * ) f ; "
+                "int ( * f2 ) ( ) ; f2 = ( int * ) f ; "
                 "}";
 
-            ASSERT_EQUALS(expected, tok(code, false));
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
         }
 
         {
@@ -753,12 +1102,12 @@ class TestSimplifyTypedef : public TestFixture {
                                 "}";
 
             const char expected[] =
-                "void g ( int * f ) "
+                "void g ( int ( * f ) ( ) ) "
                 "{ "
-                "int * f2 ; f2 = static_cast < int * > ( f ) ; "
+                "int ( * f2 ) ( ) ; f2 = static_cast < int * > ( f ) ; "
                 "}";
 
-            ASSERT_EQUALS(expected, tok(code, false));
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
         }
     }
 
@@ -800,7 +1149,7 @@ class TestSimplifyTypedef : public TestFixture {
 
             const char expected[] = "void addCallback ( void ( * ( * callback ) ( ) ) ( ) ) ;";
 
-            ASSERT_EQUALS(expected, tok(code, false));
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
         }
 
         {
@@ -812,7 +1161,7 @@ class TestSimplifyTypedef : public TestFixture {
 
             const char expected[] = "struct mscrtc6845 * pc_video_start ( void ( * ( * choosevideomode ) ( running_machine * machine , int * width , int * height , struct mscrtc6845 * crtc ) ) ( bitmap_t * bitmap , struct mscrtc6845 * crtc ) ) ;";
 
-            ASSERT_EQUALS(expected, tok(code, false));
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
         }
     }
 
@@ -828,10 +1177,13 @@ class TestSimplifyTypedef : public TestFixture {
             "int main ( ) "
             "{ "
             ""
-            "VERIFY ( is_same < result_of < int ( * ( char , float ) ) ( float , double ) > :: type , int > :: value ) ; "
+            "VERIFY ( ( is_same < result_of < int ( * ( char , float ) ) ( float , double ) > :: type , int > :: value ) ) ; "
             "}";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
+        ASSERT_EQUALS(
+            "[test.cpp:4:67]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable value [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
     }
 
     void simplifyTypedef28() {
@@ -840,7 +1192,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         const char expected[] = "std :: pair < double , double > ( * f ) ( double ) ;";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef29() {
@@ -861,7 +1213,7 @@ class TestSimplifyTypedef : public TestFixture {
             "int t ; "
             "int ia [ N ] ;";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef30() {
@@ -877,7 +1229,7 @@ class TestSimplifyTypedef : public TestFixture {
             ":: std :: list < int > :: iterator ili ; "
             ":: std :: list < int > ila [ 10 ] ;";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef31() {
@@ -902,7 +1254,7 @@ class TestSimplifyTypedef : public TestFixture {
                                     "int A :: get ( ) const { return a ; } "
                                     "int i ; i = A :: a ;";
 
-            ASSERT_EQUALS(expected, tok(code, false));
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
         }
 
         {
@@ -924,7 +1276,7 @@ class TestSimplifyTypedef : public TestFixture {
                                     "int A :: get ( ) const { return a ; } "
                                     "int i ; i = A :: a ;";
 
-            ASSERT_EQUALS(expected, tok(code, false));
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
         }
     }
 
@@ -941,7 +1293,7 @@ class TestSimplifyTypedef : public TestFixture {
             "char * cp ; "
             "const char * ccp ;";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef33() {
@@ -1058,9 +1410,9 @@ class TestSimplifyTypedef : public TestFixture {
             "int A :: B :: C :: funC ( ) { return c ; } "
             "long A :: B :: C :: D :: funD ( ) { return d ; }";
 
-        ASSERT_EQUALS(expected, tok(code, false));
-        ASSERT_EQUALS(expected, tok(codePartialSpecified, false));
-        ASSERT_EQUALS(expected, tok(codeFullSpecified, false));
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
+        ASSERT_EQUALS(expected, tok(codePartialSpecified, dinit(TokOptions, $.simplify = false)));
+        ASSERT_EQUALS(expected, tok(codeFullSpecified, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef34() {
@@ -1075,10 +1427,14 @@ class TestSimplifyTypedef : public TestFixture {
             "class X { } ; "
             "int main ( ) "
             "{ "
-            "X * * Foo ; Foo = new X ( * ) ( const X & ) [ 2 ] ; "
+            "X ( * * Foo ) ( const X & ) ; Foo = new X ( * [ 2 ] ) ( const X & ) ; "
             "}";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        // TODO: Ideally some parentheses should be added. This code is compilable:
+        //    int (**Foo)(int);
+        //    Foo = new (int(*[2])(int)) ;
+
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef35() {
@@ -1149,10 +1505,8 @@ class TestSimplifyTypedef : public TestFixture {
                                 "return a + s ; "
                                 "}";
 
-        ASSERT_EQUALS(expected, tok(code, false));
-        ASSERT_EQUALS_WITHOUT_LINENUMBERS(
-            "[test.cpp:28]: (debug) valueflow.cpp:3109:valueFlowFunctionReturn bailout: function return; nontrivial function body\n"
-            , errout.str());
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
+        ASSERT_EQUALS_WITHOUT_LINENUMBERS("", errout_str());
     }
 
     void simplifyTypedef36() {
@@ -1166,7 +1520,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "{ "
                                 "* va_arg ( ap , void ( * * ) ( ) ) = 0 ; "
                                 "}";
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef37() {
@@ -1179,15 +1533,15 @@ class TestSimplifyTypedef : public TestFixture {
                                 "{ "
                                 "int i ; { } "
                                 "}";
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef38() {
         const char code[] = "typedef C A;\n"
                             "struct AB : public A, public B { };";
         const char expected[] = "struct AB : public C , public B { } ;";
-        ASSERT_EQUALS(expected, tok(code, false));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef43() {
@@ -1205,7 +1559,7 @@ class TestSimplifyTypedef : public TestFixture {
                                     "int alloclen ; "
                                     "} ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -1221,7 +1575,7 @@ class TestSimplifyTypedef : public TestFixture {
                                     "int alloclen ; "
                                     "} ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -1237,7 +1591,7 @@ class TestSimplifyTypedef : public TestFixture {
                                     "int alloclen ; "
                                     "} ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
     }
 
@@ -1253,7 +1607,7 @@ class TestSimplifyTypedef : public TestFixture {
                                     "{ "
                                     "} ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -1267,7 +1621,7 @@ class TestSimplifyTypedef : public TestFixture {
                                     "{ "
                                     "} ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -1281,7 +1635,7 @@ class TestSimplifyTypedef : public TestFixture {
                                     "{ "
                                     "} ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -1296,7 +1650,7 @@ class TestSimplifyTypedef : public TestFixture {
                                     "{ "
                                     "} ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -1311,7 +1665,32 @@ class TestSimplifyTypedef : public TestFixture {
                                     "{ "
                                     "} ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        {
+            const char code[] = "struct B {};\n" // #12141
+                                "typedef struct B B;\n"
+                                "namespace N {\n"
+                                "    struct D : public B {};\n"
+                                "}\n";
+
+            const char expected[] = "struct B { } ; namespace N { struct D : public B { } ; }";
+            ASSERT_EQUALS(expected, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        {
+            const char code[] = "struct B {};\n"
+                                "typedef const struct B CB;\n"
+                                "namespace N {\n"
+                                "    struct D : public CB {};\n"
+                                "}\n"
+                                "CB cb;\n";
+
+            const char expected[] = "struct B { } ; namespace N { struct D : public B { } ; } const struct B cb ;";
+            ASSERT_EQUALS(expected, tok(code));
+            ASSERT_EQUALS("", errout_str());
         }
     }
 
@@ -1323,7 +1702,10 @@ class TestSimplifyTypedef : public TestFixture {
                             "}";
 
         checkSimplifyTypedef(code);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS_WITHOUT_LINENUMBERS(
+            "[test.cpp:3]: (debug) valueflow.cpp:6541:(valueFlow) bailout: valueFlowAfterCondition: bailing in conditional block\n"
+            "[test.cpp:3]: (debug) valueflow.cpp:6541:(valueFlow) bailout: valueFlowAfterCondition: bailing in conditional block\n", // duplicate
+            errout_str());
     }
 
     void simplifyTypedef46() {
@@ -1342,7 +1724,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "I i;";
 
             // The expected result..
-            const char expected[] = "std :: pair < int , int > const i ;";
+            const char expected[] = "const std :: pair < int , int > i ;";
             ASSERT_EQUALS(expected, tok(code));
         }
 
@@ -1351,7 +1733,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "F f;";
 
             // The expected result..
-            const char expected[] = "void * f ;";
+            const char expected[] = "void ( * f ) ( ) ;";
             ASSERT_EQUALS(expected, tok(code));
         }
     }
@@ -1377,14 +1759,14 @@ class TestSimplifyTypedef : public TestFixture {
                             "typedef const Class & Const_Reference;\n"
                             "void some_method (Const_Reference x) const {}\n"
                             "void another_method (Const_Reference x) const {}\n"
-                            "}";
+                            "};";
 
         // The expected result..
         const char expected[] = "class Class2 { "
                                 ""
                                 "void some_method ( const Class & x ) const { } "
                                 "void another_method ( const Class & x ) const { } "
-                                "}";
+                                "} ;";
         ASSERT_EQUALS(expected, tok(code));
     }
 
@@ -1427,7 +1809,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "char ( * foo ( ) ) [ 10 ] { }";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -1435,7 +1817,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "LOCAL(type1) foo() { }";
 
             // this is invalid C, assert that an "unknown macro" warning is written
-            ASSERT_THROW(checkSimplifyTypedef(code), InternalError);
+            ASSERT_THROW_INTERNAL(checkSimplifyTypedef(code), UNKNOWN_MACRO);
         }
     }
 
@@ -1454,7 +1836,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "}";
 
         checkSimplifyTypedef(code);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef55() {
@@ -1473,7 +1855,7 @@ class TestSimplifyTypedef : public TestFixture {
 
         // Check for output..
         checkSimplifyTypedef(code);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef56() { // ticket #1829
@@ -1486,11 +1868,11 @@ class TestSimplifyTypedef : public TestFixture {
         // The expected result..
         const char expected[] = "struct C { "
                                 ""
-                                "const void * pr ; " // this gets simplified to a regular pointer
+                                "const void ( * pr ) ( ) ; "
                                 "operatorconstvoid(*)()& ( ) { return pr ; } "
                                 "} ;";
         ASSERT_EQUALS(expected, tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef57() { // ticket #1846
@@ -1505,7 +1887,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "int a ; a = int ( 1 ) * int ( 2 ) ; "
                                 "} ;";
         ASSERT_EQUALS(expected, tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef58() { // ticket #1963
@@ -1516,7 +1898,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "int coords [ 4 ] [ 2 ] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 } ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -1524,9 +1906,9 @@ class TestSimplifyTypedef : public TestFixture {
                                 "vec2_t coords[4][5][6+1] = {1,2,3,4,5,6,7,8};";
 
             // The expected result..
-            const char expected[] = "int coords [ 4 ] [ 5 ] [ 7 ] [ 2 ] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 } ;";
+            const char expected[] = "int coords [ 4 ] [ 5 ] [ 6 + 1 ] [ 2 ] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 } ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
     }
 
@@ -1537,7 +1919,7 @@ class TestSimplifyTypedef : public TestFixture {
         // The expected result..
         const char expected[] = "template < typename DISPATCHER > class SomeTemplateClass { } ;";
         ASSERT_EQUALS(expected, tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef60() { // ticket #2035
@@ -1549,9 +1931,9 @@ class TestSimplifyTypedef : public TestFixture {
                             "    localEntitiyAddFunc_t f;\n"
                             "}";
         // The expected result..
-        const char expected[] = "enum qboolean { qfalse , qtrue } ; void f ( ) { qboolean b ; qboolean * f ; }";
-        ASSERT_EQUALS(expected, tok(code, false));
-        ASSERT_EQUALS("", errout.str());
+        const char expected[] = "enum qboolean { qfalse , qtrue } ; void f ( ) { enum qboolean b ; enum qboolean ( * f ) ( struct le_s * , entity_t * ) ; }";
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef61() { // ticket #2074 and 2075
@@ -1560,14 +1942,14 @@ class TestSimplifyTypedef : public TestFixture {
 
         // Check for output..
         checkSimplifyTypedef(code1);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         const char code2[] = "typedef unsigned long uint32_t;\n"
                              "typedef uint32_t (*write_type_t) (uint32_t);";
 
         // Check for output..
         checkSimplifyTypedef(code2);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef62() { // ticket #2082
@@ -1579,8 +1961,8 @@ class TestSimplifyTypedef : public TestFixture {
 
         // The expected tokens..
         const char expected1[] = "void f ( ) { char a [ 256 ] ; char b [ 256 ] ; }";
-        ASSERT_EQUALS(expected1, tok(code1, false));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(expected1, tok(code1, dinit(TokOptions, $.simplify = false)));
+        ASSERT_EQUALS("", errout_str());
 
         const char code2[] = "typedef char TString[256];\n"
                              "void f()\n"
@@ -1589,9 +1971,9 @@ class TestSimplifyTypedef : public TestFixture {
                              "}";
 
         // The expected tokens..
-        const char expected2[] = "void f ( ) { char a [ 256 ] ; a = { 0 } ; char b [ 256 ] ; b = { 0 } ; }";
-        ASSERT_EQUALS(expected2, tok(code2, false, Settings::Native, false));
-        ASSERT_EQUALS("", errout.str());
+        const char expected2[] = "void f ( ) { char a [ 256 ] = { 0 } ; char b [ 256 ] = { 0 } ; }";
+        ASSERT_EQUALS(expected2, tok(code2, dinit(TokOptions, $.simplify = false, $.debugwarnings = false)));
+        ASSERT_EQUALS("", errout_str());
 
         const char code3[] = "typedef char TString[256];\n"
                              "void f()\n"
@@ -1601,8 +1983,8 @@ class TestSimplifyTypedef : public TestFixture {
 
         // The expected tokens..
         const char expected3[] = "void f ( ) { char a [ 256 ] ; a = \"\" ; char b [ 256 ] ; b = \"\" ; }";
-        ASSERT_EQUALS(expected3, tok(code3, false, Settings::Native, false));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(expected3, tok(code3, dinit(TokOptions, $.simplify = false, $.debugwarnings = false)));
+        ASSERT_EQUALS("", errout_str());
 
         const char code4[] = "typedef char TString[256];\n"
                              "void f()\n"
@@ -1612,8 +1994,8 @@ class TestSimplifyTypedef : public TestFixture {
 
         // The expected tokens..
         const char expected4[] = "void f ( ) { char a [ 256 ] ; a = \"1234\" ; char b [ 256 ] ; b = \"5678\" ; }";
-        ASSERT_EQUALS(expected4, tok(code4, false, Settings::Native, false));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(expected4, tok(code4, dinit(TokOptions, $.simplify = false, $.debugwarnings = false)));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef63() { // ticket #2175 'typedef float x[3];'
@@ -1621,15 +2003,15 @@ class TestSimplifyTypedef : public TestFixture {
                             "x a,b,c;";
         const std::string actual(tok(code));
         ASSERT_EQUALS("float a [ 3 ] ; float b [ 3 ] ; float c [ 3 ] ;", actual);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef64() {
-        const char code[] = "typedef __typeof__(__type1() + __type2()) __type;"
+        const char code[] = "typedef typeof(__type1() + __type2()) __type;"
                             "__type t;";
         const std::string actual(tok(code));
-        ASSERT_EQUALS("__typeof__ ( __type1 ( ) + __type2 ( ) ) t ;", actual);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("typeof ( __type1 ( ) + __type2 ( ) ) t ;", actual);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef65() { // ticket #2314
@@ -1638,16 +2020,16 @@ class TestSimplifyTypedef : public TestFixture {
                             "    Foo b(0);\n"
                             "    return b > Foo(10);\n"
                             "}";
-        const std::string actual(tok(code, true, Settings::Native, false));
+        const std::string actual(tok(code, dinit(TokOptions, $.debugwarnings = false)));
         ASSERT_EQUALS("int main ( ) { BAR < int > b ( 0 ) ; return b > BAR < int > ( 10 ) ; }", actual);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef66() { // ticket #2341
         const char code[] = "typedef long* GEN;\n"
                             "extern GEN (*foo)(long);";
-        tok(code);
-        ASSERT_EQUALS("", errout.str());
+        (void)tok(code);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef67() { // ticket #2354
@@ -1655,19 +2037,23 @@ class TestSimplifyTypedef : public TestFixture {
                             "void f ( ) {\n"
                             "    ((Function * (*) (char *, char *, int, int)) global[6]) ( \"assoc\", \"eggdrop\", 106, 0);\n"
                             "}";
+        // TODO should it be simplified as below instead?
+        // "( ( int ( * * ( * ) ( char * , char * , int , int ) ) ( ) ) global [ 6 ] ) ( \"assoc\" , \"eggdrop\" , 106 , 0 ) ; "
         const char expected[] = "void f ( ) { "
-                                "( ( int ( * * ( * ) ( char * , char * , int , int ) ) ( ) ) global [ 6 ] ) ( \"assoc\" , \"eggdrop\" , 106 , 0 ) ; "
+                                "( ( int * * * ) global [ 6 ] ) ( \"assoc\" , \"eggdrop\" , 106 , 0 ) ; "
                                 "}";
         ASSERT_EQUALS(expected, tok(code));
-        ASSERT_EQUALS_WITHOUT_LINENUMBERS("[test.cpp:3]: (debug) valueflow.cpp:1319:valueFlowTerminatingCondition bailout: Skipping function due to incomplete variable global\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:50]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable global [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
     }
 
     void simplifyTypedef68() { // ticket #2355
         const char code[] = "typedef FMAC1 void (* a) ();\n"
                             "void *(*b) ();";
         const std::string actual(tok(code));
-        ASSERT_EQUALS("void * * b ;", actual);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("void * ( * b ) ( ) ;", actual);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef69() { // ticket #2348
@@ -1681,7 +2067,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "int ( * * ( * compilerHookVector ) ( void ) ) ( ) ; "
                                 "} ;";
         ASSERT_EQUALS(expected, tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef70() { // ticket #2348
@@ -1689,7 +2075,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "pread_f *(*test_func)(char *filename);";
         const char expected[] = "int ( * ( * test_func ) ( char * filename ) ) ( int ) ;";
         ASSERT_EQUALS(expected, tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef71() { // ticket #2348
@@ -1698,14 +2084,14 @@ class TestSimplifyTypedef : public TestFixture {
                                 "RexxFunctionHandler *(efuncs[1]);";
             const char expected[] = "int ( * ( efuncs [ 1 ] ) ) ( ) ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
         {
             const char code[] = "typedef int RexxFunctionHandler();\n"
                                 "RexxFunctionHandler *(efuncs[]) = { NULL, NULL };";
             const char expected[] = "int ( * ( efuncs [ ] ) ) ( ) = { NULL , NULL } ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
     }
 
@@ -1721,7 +2107,7 @@ class TestSimplifyTypedef : public TestFixture {
                                     "operatorint** ( ) const { } "
                                     "} ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
         // inline local variable
         {
@@ -1734,7 +2120,7 @@ class TestSimplifyTypedef : public TestFixture {
                                     "void f1 ( ) const { int i ; } "
                                     "} ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
         // out of line member variable
         {
@@ -1749,7 +2135,7 @@ class TestSimplifyTypedef : public TestFixture {
                                     "} ; "
                                     "void Fred :: f1 ( ) const { int i ; f ( i ) ; }";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
         // out of line operator
         {
@@ -1764,7 +2150,7 @@ class TestSimplifyTypedef : public TestFixture {
                                     "} ; "
                                     "Fred :: operatorint** ( ) const { }";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
     }
 
@@ -1778,7 +2164,7 @@ class TestSimplifyTypedef : public TestFixture {
                                 "void f ( ) ; "
                                 "} ;";
         ASSERT_EQUALS(expected, tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef74() { // ticket #2414
@@ -1787,27 +2173,24 @@ class TestSimplifyTypedef : public TestFixture {
                             "state_t current_state = death;\n"
                             "static char get_runlevel(const state_t);";
         const char expected[] = "long ( * ( * current_state ) ( void ) ) ( void ) ; current_state = death ; "
-                                "static char get_runlevel ( const long ( * ( * ) ( void ) ) ( void ) ) ;";
+                                "static char get_runlevel ( long ( * ( * const ) ( void ) ) ( void ) ) ;";
         ASSERT_EQUALS(expected, tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef75() { // ticket #2426
         const char code[] = "typedef _Packed struct S { long l; };";
-        ASSERT_EQUALS("", tok(code, true, Settings::Native, false));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(";", tok(code, dinit(TokOptions, $.debugwarnings = false)));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef76() { // ticket #2453 segmentation fault
-        const char code[] = "void f1(typedef int x) {}";
-        const char expected[] = "void f1 ( typedef int x ) { }";
-        ASSERT_EQUALS(expected, tok(code, true, Settings::Native, false));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_THROW_INTERNAL(checkSimplifyTypedef("void f1(typedef int x) {}"), SYNTAX);
     }
 
     void simplifyTypedef77() { // ticket #2554
         const char code[] = "typedef char Str[10]; int x = sizeof(Str);";
-        const char expected[] = "int x ; x = 10 ;";
+        const char expected[] = "int x ; x = sizeof ( char [ 10 ] ) ;";
         ASSERT_EQUALS(expected, tok(code));
     }
 
@@ -1843,13 +2226,13 @@ class TestSimplifyTypedef : public TestFixture {
                                 "sizeof ( struct s ) ; "
                                 "} ;";
         ASSERT_EQUALS(expected, tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef81() { // ticket #2603 segmentation fault
-        ASSERT_THROW(checkSimplifyTypedef("typedef\n"), InternalError);
+        ASSERT_THROW_INTERNAL(checkSimplifyTypedef("typedef\n"), SYNTAX);
 
-        ASSERT_THROW(checkSimplifyTypedef("typedef constexpr\n"), InternalError);
+        ASSERT_THROW_INTERNAL(checkSimplifyTypedef("typedef constexpr\n"), SYNTAX);
     }
 
     void simplifyTypedef82() { // ticket #2403
@@ -1866,7 +2249,7 @@ class TestSimplifyTypedef : public TestFixture {
                              "  B * b = new B;\n"
                              "  b->f = new A::F * [ 10 ];\n"
                              "}");
-        ASSERT_EQUALS_WITHOUT_LINENUMBERS("[test.cpp:12]: (debug) valueflow.cpp:1319:valueFlowTerminatingCondition bailout: Skipping function due to incomplete variable idx\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef83() { // ticket #2620
@@ -1881,20 +2264,20 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedef84() { // ticket #2630 (segmentation fault)
         const char code1[] = "typedef y x () x";
-        ASSERT_THROW(checkSimplifyTypedef(code1), InternalError);
+        ASSERT_THROW_INTERNAL(checkSimplifyTypedef(code1), SYNTAX);
 
         const char code2[] = "typedef struct template <>";
-        ASSERT_THROW(checkSimplifyTypedef(code2), InternalError);
+        ASSERT_THROW_INTERNAL(checkSimplifyTypedef(code2), SYNTAX);
 
         const char code3[] = "typedef ::<>";
-        ASSERT_THROW(checkSimplifyTypedef(code3), InternalError);
+        ASSERT_THROW_INTERNAL(checkSimplifyTypedef(code3), SYNTAX);
     }
 
     void simplifyTypedef85() { // ticket #2651
         const char code[] = "typedef FOO ((BAR)(void, int, const int, int*));";
         const char expected[] = ";";
         ASSERT_EQUALS(expected, tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef86() { // ticket #2581
@@ -1911,21 +2294,21 @@ class TestSimplifyTypedef : public TestFixture {
                                 "safe_bool operator! ( ) const ; "
                                 "} ;";
         ASSERT_EQUALS(expected, tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef87() { // ticket #2651
         const char code[] = "typedef FOO (*(*BAR)(void, int, const int, int*));";
         const char expected[] = ";";
         ASSERT_EQUALS(expected, tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef88() { // ticket #2675
         const char code[] = "typedef short int (*x)(...);";
         const char expected[] = ";";
         ASSERT_EQUALS(expected, tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef89() { // ticket #2717
@@ -1935,7 +2318,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "};";
         const char expected[] = "class Fred { void func ( int ) const ; } ;";
         ASSERT_EQUALS(expected, tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef90() { // ticket #2718
@@ -1943,7 +2326,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "void f(const IA&) {};";
         const char expected[] = "void f ( const int ( & ) [ 2 ] ) { } ;";
         ASSERT_EQUALS(expected, tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef91() { // ticket #2716
@@ -1966,7 +2349,7 @@ class TestSimplifyTypedef : public TestFixture {
                                  "int * A :: f ( ) { } "
                                  "}";
         ASSERT_EQUALS(expected1, tok(code1));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         const char code2[] = "namespace NS {\n"
                              "    typedef int (*T)();\n"
@@ -1983,7 +2366,7 @@ class TestSimplifyTypedef : public TestFixture {
                                  "} "
                                  "int * NS :: A :: f ( ) { }";
         ASSERT_EQUALS(expected2, tok(code2));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         const char code3[] = "namespace NS1 {\n"
                              "    namespace NS2 {\n"
@@ -2012,7 +2395,7 @@ class TestSimplifyTypedef : public TestFixture {
                                  "} "
                                  "}";
         ASSERT_EQUALS(expected3, tok(code3));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         const char code4[] = "namespace NS1 {\n"
                              "    namespace NS2 {\n"
@@ -2037,15 +2420,15 @@ class TestSimplifyTypedef : public TestFixture {
                                  "int * NS2 :: A :: f ( ) { } "
                                  "}";
         ASSERT_EQUALS(expected4, tok(code4));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef92() { // ticket #2736 (segmentation fault)
         const char code[] = "typedef long Long;\n"
                             "namespace NS {\n"
                             "}";
-        ASSERT_EQUALS("", tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(";", tok(code));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef93() { // ticket #2738 (syntax error)
@@ -2053,7 +2436,7 @@ class TestSimplifyTypedef : public TestFixture {
                             "typedef struct s (*binop) (struct s, struct s);";
         const char expected[] = "struct s { double x ; } ;";
         ASSERT_EQUALS(expected, tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef94() { // ticket #1982
@@ -2072,7 +2455,7 @@ class TestSimplifyTypedef : public TestFixture {
                                  "} ; "
                                  "struct A :: data d ;";
         ASSERT_EQUALS(expected1, tok(code1));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         const char code2[] = "class A {\n"
                              "public:\n"
@@ -2089,7 +2472,7 @@ class TestSimplifyTypedef : public TestFixture {
                                  "} ; "
                                  "struct :: A :: data d ;";
         ASSERT_EQUALS(expected2, tok(code2));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         const char code3[] = "class A {\n"
                              "public:\n"
@@ -2106,7 +2489,7 @@ class TestSimplifyTypedef : public TestFixture {
                                  "} ; "
                                  "class B : public :: A :: data { } ;";
         ASSERT_EQUALS(expected3, tok(code3));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef95() { // ticket #2844
@@ -2117,34 +2500,34 @@ class TestSimplifyTypedef : public TestFixture {
                             "};";
         const char expected[] = "class symbol_table { "
                                 "public: "
-                                "expression_error :: error_code * f ; "
+                                "expression_error :: error_code ( * f ) ( void * , const char * , expression_space ) ; "
                                 "} ;";
-        ASSERT_EQUALS(expected, tok(code, true, Settings::Native, false));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.debugwarnings = false)));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef96() { // ticket #2886 (segmentation fault)
         const char code[] = "typedef struct x { }";
-        ASSERT_THROW(tok(code), InternalError);
+        ASSERT_THROW_INTERNAL(tok(code), SYNTAX);
     }
 
     void simplifyTypedef97() { // ticket #2983 (segmentation fault)
         const char code[] = "typedef x y\n"
                             "(A); y";
-        tok(code);
-        ASSERT_EQUALS("", errout.str());
+        (void)tok(code);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef99() { // ticket #2999
         const char code[] = "typedef struct Fred Fred;\n"
                             "struct Fred { };";
-        tok(code);
-        ASSERT_EQUALS("", errout.str());
+        (void)tok(code);
+        ASSERT_EQUALS("", errout_str());
 
         const char code1[] = "struct Fred { };\n"
                              "typedef struct Fred Fred;";
-        tok(code1);
-        ASSERT_EQUALS("", errout.str());
+        (void)tok(code1);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef100() { // ticket #3000
@@ -2154,14 +2537,14 @@ class TestSimplifyTypedef : public TestFixture {
                             "    fred = se_alloc(sizeof(struct Fred));\n"
                             "    return fred;\n"
                             "}";
-        tok(code);
-        ASSERT_EQUALS_WITHOUT_LINENUMBERS("[test.cpp:2]: (debug) valueflow.cpp:3109:valueFlowFunctionReturn bailout: function return; nontrivial function body\n", errout.str());
+        (void)tok(code);
+        ASSERT_EQUALS_WITHOUT_LINENUMBERS("", errout_str());
     }
 
     void simplifyTypedef101() { // ticket #3003 (segmentation fault)
         const char code[] = "typedef a x[];\n"
                             "y = x";
-        ASSERT_THROW(tok(code), InternalError);
+        ASSERT_EQUALS("y = x", tok(code));
     }
 
     void simplifyTypedef102() { // ticket #3004
@@ -2170,8 +2553,8 @@ class TestSimplifyTypedef : public TestFixture {
                             "{\n"
                             "    Fred * Fred;\n"
                             "}";
-        tok(code);
-        ASSERT_EQUALS("", errout.str());
+        (void)tok(code);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef103() { // ticket #3007
@@ -2180,30 +2563,30 @@ class TestSimplifyTypedef : public TestFixture {
                             "{\n"
                             "    Fred Fred;\n"
                             "}";
-        tok(code);
-        ASSERT_EQUALS("", errout.str());
+        (void)tok(code);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef104() { // ticket #3070
         const char code[] = "typedef int (*in_func) (void FAR *, unsigned char FAR * FAR *);";
         ASSERT_EQUALS(";", tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef105() { // ticket #3616 (segmentation fault)
         const char code[] = "( int typedef char x; ){}";
-        tok(code);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_THROW_INTERNAL(tok(code), SYNTAX);
     }
 
     void simplifyTypedef106() { // ticket #3619 (segmentation fault)
         const char code[] = "typedef void f ();\ntypedef { f }";
-        ASSERT_THROW(tok(code), InternalError);
+        ASSERT_THROW_INTERNAL_EQUALS(tok(code), INTERNAL, "Internal error. AST cyclic dependency.");
     }
 
     void simplifyTypedef107() { // ticket #3963 (bad code => segmentation fault)
         const char code[] = "typedef int x[]; int main() { return x }";
-        ASSERT_THROW(tok(code), InternalError);
+        ASSERT_EQUALS("int main ( ) { return x }", tok(code));
+        ignore_errout(); // we do not care about the output
     }
 
     void simplifyTypedef108() { // ticket #4777
@@ -2221,10 +2604,10 @@ class TestSimplifyTypedef : public TestFixture {
 
     void simplifyTypedef109() {
         const char code[] = "typedef int&& rref;\n"
-                            "rref var;";
-        const char expected[] = "int & & var ;";
+                            "rref var = 0;";
+        const char expected[] = "int && var = 0 ;";
         ASSERT_EQUALS(expected, tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef110() {
@@ -2283,8 +2666,8 @@ class TestSimplifyTypedef : public TestFixture {
                                 "} ; "
                                 "} "
                                 "}";
-        ASSERT_EQUALS(expected, tok(code, true, Settings::Native, false));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.debugwarnings = false)));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef111() {     // ticket #6345
@@ -2345,10 +2728,10 @@ class TestSimplifyTypedef : public TestFixture {
                                 "typename TrafoConfig > "
                                 "class AsmTraits1 { "
                                 "enum Anonymous0 { "
-                                "domain_dim = SpaceType :: TrafoType :: template Evaluator < SpaceType :: TrafoType :: ShapeType , DataType > :: Type :: domain_dim , "
+                                "domain_dim = SpaceType :: TrafoType :: Evaluator < SpaceType :: TrafoType :: ShapeType , DataType > :: Type :: domain_dim , "
                                 "} ; } ;";
         ASSERT_EQUALS(expected, tok(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef113() {     // ticket #7030
@@ -2371,8 +2754,8 @@ class TestSimplifyTypedef : public TestFixture {
                             "unsigned t2 ;";
         const char expected[] = "unsigned int t1 ; "
                                 "unsigned int t2 ;";
-        ASSERT_EQUALS(expected, tok(code, false));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef116() { // #5624
@@ -2387,8 +2770,8 @@ class TestSimplifyTypedef : public TestFixture {
                                 "for ( std :: vector < CharacterConversion > :: iterator it = c2c . begin ( ) ; it != c2c . end ( ) ; ++ it ) { } "
                                 "std :: vector < CharacterConversion > ( ) . swap ( c2c ) ; "
                                 "}";
-        ASSERT_EQUALS(expected, tok(code, false));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
+        ASSERT_EQUALS_WITHOUT_LINENUMBERS("", errout_str());
     }
 
     void simplifyTypedef117() { // #6507
@@ -2400,8 +2783,8 @@ class TestSimplifyTypedef : public TestFixture {
                                 "struct bstr bstr0 ( const char * s ) { "
                                 "return ( struct bstr ) { ( unsigned char * ) s , s ? strlen ( s ) : 0 } ; "
                                 "}";
-        ASSERT_EQUALS(expected, tok(code, false));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef118() { // #5749
@@ -2416,8 +2799,8 @@ class TestSimplifyTypedef : public TestFixture {
                                 "operatorintClassyClass::* ( ) { "
                                 "return & ClassyClass :: id ; "
                                 "} }";
-        ASSERT_EQUALS(expected, tok(code, false));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef119() { // #7541
@@ -2427,19 +2810,19 @@ class TestSimplifyTypedef : public TestFixture {
                             "}\n"
                             "namespace Baz { }\n"
                             "enum Bar { XX = 1 };";
-        const char exp [] = "enum Bar { XX = 1 } ;";
-        ASSERT_EQUALS(exp, tok(code, false));
-        ASSERT_EQUALS("", errout.str());
+        const char exp[] = "enum Bar { XX = 1 } ;";
+        ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef120() { // #8357
         const char code[] = "typedef char test_utf8_char[5];\n"
                             "static test_utf8_char const bad_chars[] = { };\n"
                             "static void report_good(bool passed, test_utf8_char const c) { };";
-        const char exp [] = "static const char bad_chars [ ] [ 5 ] = { } ; "
-                            "static void report_good ( bool passed , const char c [ 5 ] ) { } ;";
-        ASSERT_EQUALS(exp, tok(code, false));
-        ASSERT_EQUALS("", errout.str());
+        const char exp[] = "static const char bad_chars [ ] [ 5 ] = { } ; "
+                           "static void report_good ( bool passed , const char c [ 5 ] ) { } ;";
+        ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef121() { // #5766
@@ -2460,77 +2843,79 @@ class TestSimplifyTypedef : public TestFixture {
                             "mat3x3 & Fred::m() { return m3x3; }\n"
                             "const vec3 & Fred::vc() const { return v3; }\n"
                             "const mat3x3 & Fred::mc() const { return m3x3; }";
-        const char exp [] = "float v3 [ 3 ] ; "
-                            "float m3x3 [ 3 ] [ 3 ] ; "
-                            "const float ( & gv ( ) ) [ 3 ] { return v3 ; } "
-                            "const float ( & gm ( ) ) [ 3 ] [ 3 ] { return m3x3 ; } "
-                            "class Fred { "
-                            "public: "
-                            "float ( & v ( ) ) [ 3 ] ; "
-                            "float ( & m ( ) ) [ 3 ] [ 3 ] ; "
-                            "const float ( & vc ( ) const ) [ 3 ] ; "
-                            "const float ( & mc ( ) const ) [ 3 ] [ 3 ] ; "
-                            "} ; "
-                            "float ( & Fred :: v ( ) ) [ 3 ] { return v3 ; } "
-                            "float ( & Fred :: m ( ) ) [ 3 ] [ 3 ] { return m3x3 ; } "
-                            "const float ( & Fred :: vc ( ) const ) [ 3 ] { return v3 ; } "
-                            "const float ( & Fred :: mc ( ) const ) [ 3 ] [ 3 ] { return m3x3 ; }";
-        ASSERT_EQUALS(exp, tok(code, false));
-        ASSERT_EQUALS("", errout.str());
+        const char exp[] = "float v3 [ 3 ] ; "
+                           "float m3x3 [ 3 ] [ 3 ] ; "
+                           "const float * & gv ( ) { return v3 ; } "
+                           "const float * * & gm ( ) { return m3x3 ; } "
+                           "class Fred { "
+                           "public: "
+                           "float * & v ( ) ; "
+                           "float * * & m ( ) ; "
+                           "const float * & vc ( ) const ; "
+                           "const float * * & mc ( ) const ; "
+                           "} ; "
+                           "float * & Fred :: v ( ) { return v3 ; } "
+                           "float * * & Fred :: m ( ) { return m3x3 ; } "
+                           "const float * & Fred :: vc ( ) const { return v3 ; } "
+                           "const float * * & Fred :: mc ( ) const { return m3x3 ; }";
+        ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef122() { // segmentation fault
         const char code[] = "int result = [] { return git_run_cmd(\"update-index\",\"update-index -q --refresh\"); }();";
-        tok(code);
-        ASSERT_EQUALS("", errout.str());
+        (void)tok(code);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef123() { // ticket #7406
         const char code[] = "typedef int intvec[1];\n"
                             "Dummy<intvec> y;";
-        const char exp [] = "Dummy < int [ 1 ] > y ;";
-        ASSERT_EQUALS(exp, tok(code, false));
-        ASSERT_EQUALS("", errout.str());
+        const char exp[] = "Dummy < int [ 1 ] > y ;";
+        ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedef124() { // ticket #7792
         const char code[] = "typedef long unsigned int size_t;\n"
-                            "typedef size_t (my_func)(char *, size_t, size_t, void *);";
+                            "typedef size_t (my_func)(char *, size_t, size_t, void *);"
+                            "size_t f(size_t s);";
 
-        // Check for output..
-        checkSimplifyTypedef(code);
-        ASSERT_EQUALS_WITHOUT_LINENUMBERS("[test.cpp:1]: (debug) Failed to parse 'typedef long unsigned int size_t ;'. The checking continues anyway.\n", errout.str());
+        const char exp[] = "long f ( long s ) ;";
+        ASSERT_EQUALS(exp, tok(code));
+        ASSERT_EQUALS("", errout_str());
 
         const char code1[] = "typedef long unsigned int uint32_t;\n"
                              "typedef uint32_t (my_func)(char *, uint32_t, uint32_t, void *);";
 
         // Check for output..
         checkSimplifyTypedef(code1);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
     }
 
     void simplifyTypedef125() { // #8749
         const char code[] = "typedef char A[3];\n"
                             "char (*p)[3] = new A[4];";
-        const char exp [] = "char ( * p ) [ 3 ] = new char [ 4 ] [ 3 ] ;";
-        ASSERT_EQUALS(exp, tok(code, false));
+        const char exp[] = "char ( * p ) [ 3 ] = new char [ 4 ] [ 3 ] ;";
+        ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef126() { // #5953
         const char code[] = "typedef char automap_data_t[100];\n"
                             "void write_array(automap_data_t *data) {}";
-        const char exp [] = "void write_array ( char ( * data ) [ 100 ] ) { }";
-        ASSERT_EQUALS(exp, tok(code, false));
+        const char exp[] = "void write_array ( char ( * data ) [ 100 ] ) { }";
+        ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef127() { // #8878
         const char code[] = "class a; typedef int (a::*b); "
                             "template <long, class> struct c; "
                             "template <int g> struct d { enum { e = c<g, b>::f }; };";
-        const char exp [] = "class a ; "
-                            "template < long , class > struct c ;";
-        ASSERT_EQUALS(exp, tok(code, false));
+        const char exp[] = "class a ; "
+                           "template < long , class > struct c ; "
+                           "template < int g > struct d { enum Anonymous0 { e = c < g , int ( a :: * ) > :: f } ; } ;";
+        ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedef128() { // #9053
@@ -2538,10 +2923,893 @@ class TestSimplifyTypedef : public TestFixture {
                             "void f() {\n"
                             "    dostuff((const d){1,2,3,4});\n"
                             "}";
-        const char exp [] = "void f ( ) { "
-                            "dostuff ( ( const int [ 4 ] ) { 1 , 2 , 3 , 4 } ) ; "
+        const char exp[] = "void f ( ) { "
+                           "dostuff ( ( const int [ 4 ] ) { 1 , 2 , 3 , 4 } ) ; "
+                           "}";
+        ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
+    }
+
+    void simplifyTypedef129() {
+        {
+            const char code[] = "class c {\n"
+                                "  typedef char foo[4];\n"
+                                "  foo &f ;\n"
+                                "};";
+
+            const char exp[] = "class c { char ( & f ) [ 4 ] ; } ;";
+            ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
+        }
+
+        {
+            const char code[] = "class c {\n"
+                                "  typedef char foo[4];\n"
+                                "  const foo &f;\n"
+                                "};";
+
+            const char exp[] = "class c { const char ( & f ) [ 4 ] ; } ;";
+            ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
+        }
+
+        {
+            const char code[] = "class c {\n"
+                                "  typedef char foo[4];\n"
+                                "  foo _a;\n"
+                                "  constexpr const foo &c_str() const noexcept { return _a; }\n"
+                                "};";
+
+            const char exp[] = "class c { char _a [ 4 ] ; const constexpr char ( & c_str ( ) const noexcept ( true ) ) [ 4 ] { return _a ; } } ;";
+            ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
+        }
+
+        {
+            const char code[] = "class c {\n"
+                                "  typedef char foo[4];\n"
+                                "  foo _a;\n"
+                                "  constexpr operator foo &() noexcept { return _a; }\n"
+                                "};";
+
+            const char actual[] = "class c { char _a [ 4 ] ; constexpr char ( & operatorchar ( ) noexcept ( true ) ) [ 4 ] { return _a ; } } ;";
+            const char exp[] = "class c { char _a [ 4 ] ; char ( & operatorchar ( ) noexcept ( true ) ) [ 4 ] { return _a ; } } ;";
+            TODO_ASSERT_EQUALS(exp, actual, tok(code, dinit(TokOptions, $.simplify = false)));
+        }
+
+        {
+            const char code[] = "class c {\n"
+                                "  typedef char foo[4];\n"
+                                "  foo _a;\n"
+                                "  constexpr operator const foo &() const noexcept { return _a; }\n"
+                                "};";
+
+            const char actual[] = "class c { char _a [ 4 ] ; constexpr const char ( & operatorconstchar ( ) const noexcept ( true ) ) [ 4 ] { return _a ; } } ;";
+            const char exp[] = "class c { char _a [ 4 ] ; const char ( & operatorconstchar ( ) const noexcept ( true ) ) [ 4 ] { return _a ; } } ;";
+            TODO_ASSERT_EQUALS(exp, actual, tok(code, dinit(TokOptions, $.simplify = false)));
+        }
+    }
+
+    void simplifyTypedef130() { // #9446
+        const char code[] = "template <class, class> void a() {\n"
+                            "  typedef int(*b)[10];\n"
+                            "  a<b, b>();\n"
                             "}";
-        ASSERT_EQUALS(exp, tok(code, false));
+
+        const char exp[] = "template < class , class > void a ( ) { "
+                           "a < int ( * ) [ 10 ] , int ( * ) [ 10 ] > ( ) ; "
+                           "}";
+
+        ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
+    }
+
+    void simplifyTypedef131() {
+        const char code[] = "typedef unsigned char a4[4];\n"
+                            "a4 a4obj;\n"
+                            "a4 &&  a4_rref = std::move(a4obj);\n"
+                            "a4* a4p = &(a4obj);\n"
+                            "a4*&& a4p_rref = std::move(a4p);";
+
+        const char exp[] = "unsigned char a4obj [ 4 ] ; "
+                           "unsigned char ( && a4_rref ) [ 4 ] = std :: move ( a4obj ) ; "
+                           "unsigned char ( * a4p ) [ 4 ] ; "
+                           "a4p = & ( a4obj ) ; "
+                           "unsigned char ( * && a4p_rref ) [ 4 ] = std :: move ( a4p ) ;";
+
+        ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
+    }
+
+    void simplifyTypedef132() {
+        const char code[] = "namespace NamespaceA {\n"
+                            "    typedef int MySpecialType;\n"
+                            "}\n"
+                            "\n"
+                            "class A {\n"
+                            "    void DoSomething( NamespaceA::MySpecialType special );\n"
+                            "};\n"
+                            "\n"
+                            "using NamespaceA::MySpecialType;\n"
+                            "\n"
+                            "void A::DoSomething( MySpecialType wrongName ) {}";
+
+        const char exp[] = "class A { "
+                           "void DoSomething ( int special ) ; "
+                           "} ; "
+                           "void A :: DoSomething ( int wrongName ) { }";
+
+        ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.simplify = false)));
+    }
+
+    void simplifyTypedef133() { // #9812
+        const char code[] = "typedef unsigned char array_t[16];\n"
+                            "using array_p = const array_t *;\n"
+                            "array_p x;\n";
+        ASSERT_EQUALS("using array_p = const unsigned char ( * ) [ 16 ] ; array_p x ;", tok(code, dinit(TokOptions, $.simplify = false)));
+        ASSERT_EQUALS("[test.cpp:2:1]: (debug) Failed to parse 'using array_p = const unsigned char ( * ) [ 16 ] ;'. The checking continues anyway. [simplifyUsing]\n", errout_str());
+    }
+
+    void simplifyTypedef134() {
+        const char code[] = "namespace foo { typedef long long int64; }\n"
+                            "typedef int int32;\n"
+                            "namespace foo { int64 i; }\n"
+                            "int32 j;";
+        ASSERT_EQUALS("; namespace foo { long long i ; } int j ;", tok(code, dinit(TokOptions, $.simplify = false)));
+    }
+
+    void simplifyTypedef135() {
+        const char code[] = "namespace clangimport {\n"
+                            "    class AstNode;\n"
+                            "    typedef std::shared_ptr<AstNode> AstNodePtr;\n"
+                            "    class AstNode {\n"
+                            "    public:\n"
+                            "        AstNode() {}\n"
+                            "    private:\n"
+                            "        void createTokens();\n"
+                            "        void createScope(const std::vector<AstNodePtr> &children);\n"
+                            "    };\n"
+                            "}\n"
+                            "void clangimport::AstNode::createTokens() {\n"
+                            "    AstNodePtr range;\n"
+                            "    range->createTokens();\n"
+                            "}\n"
+                            "void clangimport::AstNode::createScope(const std::vector<AstNodePtr> & children2) { }";
+        const char expected[] = "namespace clangimport { "
+                                "class AstNode ; "
+                                "class AstNode { "
+                                "public: "
+                                "AstNode ( ) "
+                                "{ } "
+                                "private: "
+                                "void createTokens ( ) ; "
+                                "void createScope ( const std :: vector < std :: shared_ptr < AstNode > > & children ) ; "
+                                "} ; "
+                                "} "
+                                "void clangimport :: AstNode :: createTokens ( ) { "
+                                "std :: shared_ptr < AstNode > range ; "
+                                "range . createTokens ( ) ; "
+                                "} "
+                                "void clangimport :: AstNode :: createScope ( const std :: vector < std :: shared_ptr < AstNode > > & children2 ) { }";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
+    void simplifyTypedef136() {
+        const char code[] = "class C1 {};\n"
+                            "typedef class S1 {} S1;\n"
+                            "typedef class S2 : public C1 {} S2;\n"
+                            "typedef class {} S3;\n"
+                            "typedef class : public C1 {} S4;\n"
+                            "S1 s1;\n"
+                            "S2 s2;\n"
+                            "S3 s3;\n"
+                            "S4 s4;";
+
+        const char expected[] = "class C1 { } ; "
+                                "class S1 { } ; "
+                                "class S2 : public C1 { } ; "
+                                "class S3 { } ; "
+                                "class S4 : public C1 { } ; "
+                                "class S1 s1 ; "
+                                "class S2 s2 ; "
+                                "class S3 s3 ; "
+                                "class S4 s4 ;";
+
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
+    }
+
+    void simplifyTypedef137() { // #10054 debug: Executable scope 'x' with unknown function.
+        {
+            // original example: using "namespace external::ns1;" but redundant qualification
+            const char code[] = "namespace external {\n"
+                                "    namespace ns1 {\n"
+                                "        template <int size> struct B { };\n"
+                                "        typedef B<sizeof(bool)> V;\n"
+                                "    }\n"
+                                "}\n"
+                                "namespace ns {\n"
+                                "    struct A {\n"
+                                "        void f(external::ns1::V);\n"
+                                "    };\n"
+                                "}\n"
+                                "using namespace external::ns1;\n"
+                                "namespace ns {\n"
+                                "    void A::f(external::ns1::V) {}\n"
+                                "}";
+            const char exp[]  = "namespace external { "
+                                "namespace ns1 { "
+                                "struct B<1> ; "
+                                "} "
+                                "} "
+                                "namespace ns { "
+                                "struct A { "
+                                "void f ( external :: ns1 :: B<1> ) ; "
+                                "} ; "
+                                "} "
+                                "using namespace external :: ns1 ; "
+                                "namespace ns { "
+                                "void A :: f ( external :: ns1 :: B<1> ) { } "
+                                "} "
+                                "struct external :: ns1 :: B<1> { } ;";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            // no using "namespace external::ns1;"
+            const char code[] = "namespace external {\n"
+                                "    namespace ns1 {\n"
+                                "        template <int size> struct B { };\n"
+                                "        typedef B<sizeof(bool)> V;\n"
+                                "    }\n"
+                                "}\n"
+                                "namespace ns {\n"
+                                "    struct A {\n"
+                                "        void f(external::ns1::V);\n"
+                                "    };\n"
+                                "}\n"
+                                "namespace ns {\n"
+                                "    void A::f(external::ns1::V) {}\n"
+                                "}";
+            const char exp[]  = "namespace external { "
+                                "namespace ns1 { "
+                                "struct B<1> ; "
+                                "} "
+                                "} "
+                                "namespace ns { "
+                                "struct A { "
+                                "void f ( external :: ns1 :: B<1> ) ; "
+                                "} ; "
+                                "} "
+                                "namespace ns { "
+                                "void A :: f ( external :: ns1 :: B<1> ) { } "
+                                "} "
+                                "struct external :: ns1 :: B<1> { } ;";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            // using "namespace external::ns1;" without redundant qualification
+            const char code[] = "namespace external {\n"
+                                "    namespace ns1 {\n"
+                                "        template <int size> struct B { };\n"
+                                "        typedef B<sizeof(bool)> V;\n"
+                                "    }\n"
+                                "}\n"
+                                "namespace ns {\n"
+                                "    struct A {\n"
+                                "        void f(external::ns1::V);\n"
+                                "    };\n"
+                                "}\n"
+                                "using namespace external::ns1;\n"
+                                "namespace ns {\n"
+                                "    void A::f(V) {}\n"
+                                "}";
+            const char exp[]  = "namespace external { "
+                                "namespace ns1 { "
+                                "struct B<1> ; "
+                                "} "
+                                "} "
+                                "namespace ns { "
+                                "struct A { "
+                                "void f ( external :: ns1 :: B<1> ) ; "
+                                "} ; "
+                                "} "
+                                "using namespace external :: ns1 ; "
+                                "namespace ns { "
+                                "void A :: f ( external :: ns1 :: B<1> ) { } "
+                                "} "
+                                "struct external :: ns1 :: B<1> { } ;";
+            const char act[]  = "namespace external { "
+                                "namespace ns1 { "
+                                "struct B<1> ; "
+                                "} "
+                                "} "
+                                "namespace ns { "
+                                "struct A { "
+                                "void f ( external :: ns1 :: B<1> ) ; "
+                                "} ; "
+                                "} "
+                                "using namespace external :: ns1 ; "
+                                "namespace ns { "
+                                "void A :: f ( V ) { } "
+                                "} "
+                                "struct external :: ns1 :: B<1> { } ;";
+            TODO_ASSERT_EQUALS(exp, act, tok(code));
+            TODO_ASSERT_EQUALS("", "[test.cpp:14:13]: (debug) Executable scope 'f' with unknown function. [symbolDatabaseWarning]\n", errout_str());
+        }
+        {
+            // using "namespace external::ns1;" without redundant qualification on declaration and definition
+            const char code[] = "namespace external {\n"
+                                "    namespace ns1 {\n"
+                                "        template <int size> struct B { };\n"
+                                "        typedef B<sizeof(bool)> V;\n"
+                                "    }\n"
+                                "}\n"
+                                "using namespace external::ns1;\n"
+                                "namespace ns {\n"
+                                "    struct A {\n"
+                                "        void f(V);\n"
+                                "    };\n"
+                                "}\n"
+                                "namespace ns {\n"
+                                "    void A::f(V) {}\n"
+                                "}";
+            const char exp[]  = "namespace external { "
+                                "namespace ns1 { "
+                                "struct B<1> ; "
+                                "} "
+                                "} "
+                                "using namespace external :: ns1 ; "
+                                "namespace ns { "
+                                "struct A { "
+                                "void f ( external :: ns1 :: B<1> ) ; "
+                                "} ; "
+                                "} "
+                                "namespace ns { "
+                                "void A :: f ( external :: ns1 :: B<1> ) { } "
+                                "} "
+                                "struct external :: ns1 :: B<1> { } ;";
+            const char act[]  = "namespace external { "
+                                "namespace ns1 { "
+                                "template < int size > struct B { } ; "
+                                "} "
+                                "} "
+                                "using namespace external :: ns1 ; "
+                                "namespace ns { "
+                                "struct A { "
+                                "void f ( V ) ; "
+                                "} ; "
+                                "} "
+                                "namespace ns { "
+                                "void A :: f ( V ) { } "
+                                "}";
+            TODO_ASSERT_EQUALS(exp, act, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            const char code[] = "namespace external {\n"
+                                "    template <int size> struct B { };\n"
+                                "    namespace ns1 {\n"
+                                "        typedef B<sizeof(bool)> V;\n"
+                                "    }\n"
+                                "}\n"
+                                "namespace ns {\n"
+                                "    struct A {\n"
+                                "        void f(external::ns1::V);\n"
+                                "    };\n"
+                                "}\n"
+                                "namespace ns {\n"
+                                "    void A::f(external::ns1::V) {}\n"
+                                "}";
+            const char exp[]  = "namespace external { "
+                                "struct B<1> ; "
+                                "} "
+                                "namespace ns { "
+                                "struct A { "
+                                "void f ( external :: B<1> ) ; "
+                                "} ; "
+                                "} "
+                                "namespace ns { "
+                                "void A :: f ( external :: B<1> ) { } "
+                                "} "
+                                "struct external :: B<1> { } ;";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            const char code[] = "template <int size> struct B { };\n"
+                                "namespace external {\n"
+                                "    namespace ns1 {\n"
+                                "        typedef B<sizeof(bool)> V;\n"
+                                "    }\n"
+                                "}\n"
+                                "namespace ns {\n"
+                                "    struct A {\n"
+                                "        void f(external::ns1::V);\n"
+                                "    };\n"
+                                "}\n"
+                                "namespace ns {\n"
+                                "    void A::f(external::ns1::V) {}\n"
+                                "}";
+            const char exp[]  = "struct B<1> ; "
+                                "namespace ns { "
+                                "struct A { "
+                                "void f ( B<1> ) ; "
+                                "} ; "
+                                "} "
+                                "namespace ns { "
+                                "void A :: f ( B<1> ) { } "
+                                "} "
+                                "struct B<1> { } ;";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+    }
+
+    void simplifyTypedef138() {
+        const char code[] = "namespace foo { class Bar; }\n"
+                            "class Baz;\n"
+                            "typedef foo::Bar C;\n"
+                            "namespace bar {\n"
+                            "class C : Baz {};\n"
+                            "}\n";
+        ASSERT_EQUALS("namespace foo { class Bar ; } class Baz ; namespace bar { class C : Baz { } ; }", tok(code));
+    }
+
+    void simplifyTypedef139()
+    {
+        const char code[] = "typedef struct c a;\n"
+                            "struct {\n"
+                            "  a *b;\n"
+                            "} * d;\n"
+                            "void e(a *a) {\n"
+                            "  if (a < d[0].b) {}\n"
+                            "}\n";
+        ASSERT_EQUALS(
+            "struct Anonymous0 { struct c * b ; } ; struct Anonymous0 * d ; void e ( struct c * a ) { if ( a < d [ 0 ] . b ) { } }",
+            tok(code));
+        ASSERT_EQUALS_WITHOUT_LINENUMBERS(
+            "[test.cpp:6]: (debug) valueflow.cpp:6730:(valueFlow) bailout: valueFlowAfterCondition: bailing in conditional block\n"
+            "[test.cpp:6]: (debug) valueflow.cpp:6730:(valueFlow) bailout: valueFlowAfterCondition: bailing in conditional block\n", // duplicate
+            errout_str());
+    }
+
+    void simplifyTypedef140() {
+        { // #10798
+            const char code[] = "typedef void (*b)();\n"
+                                "enum class E { a, b, c };\n";
+            ASSERT_EQUALS("enum class E { a , b , c } ;", tok(code));
+        }
+        {
+            const char code[] = "typedef int A;\n"
+                                "enum class E { A };\n";
+            ASSERT_EQUALS("enum class E { A } ;", tok(code));
+        }
+        {
+            const char code[] = "namespace N {\n"
+                                "    struct S { enum E { E0 }; };\n"
+                                "}\n"
+                                "typedef N::S T;\n"
+                                "enum class E { a = T::E0 };\n";
+            ASSERT_EQUALS("namespace N { struct S { enum E { E0 } ; } ; } enum class E { a = N :: S :: E0 } ;", tok(code));
+        }
+        { // #11494
+            const char code[] = "typedef struct S {} KEY;\n"
+                                "class C { enum E { KEY }; };\n";
+            ASSERT_EQUALS("struct S { } ; class C { enum E { KEY } ; } ;", tok(code));
+        }
+    }
+
+    void simplifyTypedef141() { // #10144
+        const char code[] = "class C {\n"
+                            "    struct I {\n"
+                            "        using vt = const std::string;\n"
+                            "        using ptr = vt*;\n"
+                            "    };\n"
+                            "};\n";
+        ASSERT_EQUALS("class C { struct I { } ; } ;", tok(code));
+    }
+
+    void simplifyTypedef142() { // T() when T is a pointer type
+        // #11232
+        const char code1[] = "typedef int* T;\n"
+                             "a = T();\n";
+        ASSERT_EQUALS("a = ( int * ) 0 ;", tok(code1));
+
+        // #9479
+        const char code2[] = "typedef int* T;\n"
+                             "void f(T = T()){}\n";
+        ASSERT_EQUALS("void f ( int * = ( int * ) 0 ) { }", tok(code2));
+
+        // #11430
+        const char code3[] = "typedef char* T;\n"
+                             "T f() { return T(\"abc\"); }\n";
+        ASSERT_EQUALS("char * f ( ) { return ( ( char * ) ( \"abc\" ) ) ; }", tok(code3));
+
+        const char code4[] = "typedef struct _a *A;\n" // #13104
+                             "typedef struct _b* B;\n"
+                             "typedef A(get_t)(B);\n"
+                             "extern get_t* get;\n"
+                             "A f() {\n"
+                             "    return get(0);\n"
+                             "}\n";
+        ASSERT_EQUALS("extern struct _a * ( * get ) ( struct _b * ) ; "
+                      "struct _a * f ( ) { return get ( 0 ) ; }",
+                      tok(code4));
+
+        const char code5[] = "struct S { int x; };\n" // #13182
+                             "typedef S* PS;\n"
+                             "void f(void* a[], int i) {\n"
+                             "    PS(a[i])->x = i;\n"
+                             "}\n";
+        ASSERT_EQUALS("struct S { int x ; } ; "
+                      "void f ( void * a [ ] , int i ) { "
+                      "( ( S * ) ( a [ i ] ) ) . x = i ; "
+                      "}",
+                      tok(code5));
+    }
+
+    void simplifyTypedef143() { // #11506
+        const char code[] = "typedef struct { int i; } B;\n"
+                            "void f() {\n"
+                            "    struct D : B {\n"
+                            "        char c;\n"
+                            "    };\n"
+                            "}\n";
+        ASSERT_EQUALS("struct B { int i ; } ; void f ( ) { struct D : B { char c ; } ; }", tok(code));
+    }
+
+    void simplifyTypedef144() { // #9353
+        const char code[] = "typedef struct {} X;\n"
+                            "std::vector<X> v;\n";
+        ASSERT_EQUALS("struct X { } ; std :: vector < X > v ;", tok(code));
+    }
+
+    void simplifyTypedef145() {
+        { // #11634
+            const char code[] = "int typedef i;\n"
+                                "i main() {}\n";
+            ASSERT_EQUALS("int main ( ) { }", tok(code));
+        }
+
+        {
+            const char code[] = "struct {} typedef S;\n"
+                                "void f() {\n"
+                                "    S();\n"
+                                "}\n";
+            ASSERT_EQUALS("struct S { } ; void f ( ) { struct S ( ) ; }", tok(code));
+        }
+
+        {
+            const char code[] = "struct {} typedef S;\n" // don't crash
+                                "S();\n";
+            ASSERT_EQUALS("struct S { } ; struct S ( ) ;", tok(code));
+        }
+
+        { // #11693
+            const char code[] = "typedef unsigned char unsigned char;\n" // don't hang
+                                "void f(char);\n";
+            ASSERT_EQUALS("void f ( char ) ;", tok(code));
+        }
+
+        { // #10796
+            const char code[] = "typedef unsigned a[7];\n"
+                                "void f(unsigned N) {\n"
+                                "    a** p = new a * [N];\n"
+                                "}\n";
+            TODO_ASSERT_EQUALS("does not compile", "void f ( int N ) { int ( * * p ) [ 7 ] ; p = new int ( * ) [ N ] [ 7 ] ; }", tok(code));
+        }
+
+        { // #11772
+            const char code[] = "typedef t;\n" // don't crash on implicit int
+                                "void g() {\n"
+                                "    sizeof(t);\n"
+                                "}\n";
+            ASSERT_EQUALS("void g ( ) { sizeof ( t ) ; }", tok(code)); // TODO: handle implicit int
+            ignore_errout(); // we do not care about the output
+        }
+
+        {
+            const char code[] = "typedef t[3];\n"
+                                "void g() {\n"
+                                "    sizeof(t);\n"
+                                "}\n";
+            ASSERT_EQUALS("void g ( ) { sizeof ( t ) ; }", tok(code)); // TODO: handle implicit int
+            ignore_errout(); // we do not care about the output
+        }
+    }
+
+    void simplifyTypedef146() {
+        {
+            const char code[] = "namespace N {\n" // #11978
+                                "    typedef int T;\n"
+                                "    struct C {\n"
+                                "        C(T*);\n"
+                                "        void* p;\n"
+                                "    };\n"
+                                "}\n"
+                                "N::C::C(T*) : p(nullptr) {}\n";
+            ASSERT_EQUALS("namespace N { struct C { C ( int * ) ; void * p ; } ; } N :: C :: C ( int * ) : p ( nullptr ) { }", tok(code));
+        }
+
+        {
+            const char code[] = "namespace N {\n" // #11986
+                                "    typedef char U;\n"
+                                "    typedef int V;\n"
+                                "    struct S {};\n"
+                                "    struct T { void f(V*); };\n"
+                                "}\n"
+                                "void N::T::f(V*) {}\n"
+                                "namespace N {}\n";
+            ASSERT_EQUALS("namespace N { struct S { } ; struct T { void f ( int * ) ; } ; } void N :: T :: f ( int * ) { }", tok(code));
+        }
+
+        {
+            const char code[] = "namespace N {\n" // #12008
+                                "    typedef char U;\n"
+                                "    typedef int V;\n"
+                                "    struct S {\n"
+                                "        S(V* v);\n"
+                                "    };\n"
+                                "}\n"
+                                "void f() {}\n"
+                                "N::S::S(V* v) {}\n"
+                                "namespace N {}\n";
+            ASSERT_EQUALS("namespace N { struct S { S ( int * v ) ; } ; } void f ( ) { } N :: S :: S ( int * v ) { }", tok(code));
+        }
+    }
+
+    void simplifyTypedef147() {
+        const char code[] = "namespace N {\n" // #12014
+                            "    template<typename T>\n"
+                            "    struct S {};\n"
+                            "}\n"
+                            "typedef N::S<int> S;\n"
+                            "namespace N {\n"
+                            "    template<typename T>\n"
+                            "    struct U {\n"
+                            "        S<T> operator()() {\n"
+                            "            return {};\n"
+                            "        }\n"
+                            "    };\n"
+                            "}\n";
+        ASSERT_EQUALS("namespace N { template < typename T > struct S { } ; } namespace N { template < typename T > struct U { S < T > operator() ( ) { return { } ; } } ; }",
+                      tok(code));
+    }
+
+    void simplifyTypedef148() {
+        const char code[] = "typedef int& R;\n" // #12166
+                            "R r = i;\n";
+        ASSERT_EQUALS("int & r = i ;", tok(code));
+    }
+
+    void simplifyTypedef149() { // #12218
+        {
+            const char code[] = "namespace N {\n"
+                                "    typedef struct S {} S;\n"
+                                "}\n"
+                                "void g(int);\n"
+                                "void f() {\n"
+                                "    g(sizeof(struct N::S));\n"
+                                "}\n";
+            ASSERT_EQUALS("namespace N { struct S { } ; } void g ( int ) ; void f ( ) { g ( sizeof ( struct N :: S ) ) ; }", tok(code));
+        }
+
+        {
+            const char code[] = "namespace N {\n"
+                                "    typedef class C {} C;\n"
+                                "}\n"
+                                "void g(int);\n"
+                                "void f() {\n"
+                                "    g(sizeof(class N::C));\n"
+                                "}\n";
+            ASSERT_EQUALS("namespace N { class C { } ; } void g ( int ) ; void f ( ) { g ( sizeof ( class N :: C ) ) ; }", tok(code));
+        }
+
+        {
+            const char code[] = "namespace N {\n"
+                                "    typedef union U {} U;\n"
+                                "}\n"
+                                "void g(int);\n"
+                                "void f() {\n"
+                                "    g(sizeof(union N::U));\n"
+                                "}\n";
+            ASSERT_EQUALS("namespace N { union U { } ; } void g ( int ) ; void f ( ) { g ( sizeof ( union N :: U ) ) ; }", tok(code));
+        }
+
+        {
+            const char code[] = "namespace N {\n"
+                                "    typedef enum E {} E;\n"
+                                "}\n"
+                                "void g(int);\n"
+                                "void f() {\n"
+                                "    g(sizeof(enum N::E));\n"
+                                "}\n";
+            ASSERT_EQUALS("namespace N { enum E { } ; } void g ( int ) ; void f ( ) { g ( sizeof ( enum N :: E ) ) ; }", tok(code));
+        }
+    }
+
+    void simplifyTypedef150() { // #12475
+        const char *exp{};
+        const char code[] = "struct S {\n"
+                            "    std::vector<int> const& h(int);\n"
+                            "};\n"
+                            "typedef std::vector<int> const& (S::* func_t)(int);\n"
+                            "void g(func_t, int);\n"
+                            "void f() {\n"
+                            "    g(func_t(&S::h), 5);\n"
+                            "}\n";
+        exp = "struct S { "
+              "const std :: vector < int > & h ( int ) ; "
+              "} ; "
+              "void g ( const std :: vector < int > & ( S :: * ) ( int ) , int ) ; "
+              "void f ( ) { "
+              "g ( const std :: vector < int > & ( S :: * ( & S :: h ) ) ( int ) , 5 ) ; " // TODO: don't generate invalid code
+              "}";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void simplifyTypedef151() {
+        const char *exp{};
+        const char code[] = "namespace N {\n" // #12597
+                            "    typedef int T[10];\n"
+                            "    const T* f() { return static_cast<const T*>(nullptr); }\n"
+                            "}\n";
+        exp = "namespace N { "
+              "const int ( * f ( ) ) [ 10 ] { return static_cast < const int ( * ) [ 10 ] > ( nullptr ) ; } "
+              "}";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void simplifyTypedef152() {
+        const char *exp{};
+        const char code[] = "namespace O { struct T {}; }\n"
+                            "typedef O::T S;\n"
+                            "namespace M {\n"
+                            "    enum E { E0, S = 1 };\n"
+                            "    enum class F : ::std::int8_t { F0, S = 1 };\n"
+                            "}\n"
+                            "namespace N { enum { G0, S = 1 }; }\n";
+        exp = "namespace O { struct T { } ; } "
+              "namespace M { "
+              "enum E { E0 , S = 1 } ; "
+              "enum class F : :: std :: int8_t { F0 , S = 1 } ; "
+              "}"
+              " namespace N { enum Anonymous0 { G0 , S = 1 } ; "
+              "}";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void simplifyTypedef153() {
+        const char *exp{}; // #12647
+        const char code[] = "typedef unsigned long X;\n"
+                            "typedef unsigned long X;\n"
+                            "typedef X Y;\n"
+                            "typedef X* Yp;\n"
+                            "typedef X Ya[3];\n"
+                            "Y y;\n"
+                            "Yp yp;\n"
+                            "Ya ya;\n";
+        exp = "; long y ; long * yp ; long ya [ 3 ] ;";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void simplifyTypedef154() {
+        const char code[] = "typedef int T;\n"
+                            "typedef T T;\n"
+                            "T t = 0;\n";
+        const char exp[] = "int t ; t = 0 ;";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void simplifyTypedef155() {
+        const char code[] = "typedef struct S T;\n" // #12808
+                            "typedef struct S { int i; } T;\n"
+                            "extern \"C\" void f(T* t);\n";
+        const char exp[] = "struct S { int i ; } ; "
+                           "void f ( struct S * t ) ;";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void simplifyTypedef156() {
+        const char code[] = "typedef struct S_t {\n" // #12930
+                            "    enum E { E0 };\n"
+                            "    E e;\n"
+                            "} S;\n"
+                            "void f(S s) {\n"
+                            "    switch (s.e) {\n"
+                            "    case S::E0:\n"
+                            "        break;\n"
+                            "    }\n"
+                            "}\n";
+        const char exp[] = "struct S_t { "
+                           "enum E { E0 } ; "
+                           "E e ; "
+                           "} ; "
+                           "void f ( struct S_t s ) { "
+                           "switch ( s . e ) { "
+                           "case S_t :: E0 : ; "
+                           "break ; "
+                           "} "
+                           "}";
+        ASSERT_EQUALS(exp, tok(code));
+
+        const char code2[] = "typedef enum E_t { E0 } E;\n"
+                             "void f(E e) {\n"
+                             "    switch (e) {\n"
+                             "    case E::E0:\n"
+                             "        break;\n"
+                             "    }\n"
+                             "}\n";
+        const char exp2[] = "enum E_t { E0 } ; "
+                            "void f ( enum E_t e ) { "
+                            "switch ( e ) { "
+                            "case E_t :: E0 : ; "
+                            "break ; "
+                            "} "
+                            "}";
+        ASSERT_EQUALS(exp2, tok(code2));
+
+        const char code3[] = "typedef union U_t {\n"
+                             "    int i;\n"
+                             "    enum { E0 } e;\n"
+                             "} U;\n"
+                             "void f(U u) {\n"
+                             "    switch (u.e) {\n"
+                             "    case U::E0:\n"
+                             "        break;\n"
+                             "    }\n"
+                             "}\n";
+        const char exp3[] = "union U_t { "
+                            "int i ; "
+                            "enum Anonymous0 { E0 } ; "
+                            "enum Anonymous0 e ; "
+                            "} ; "
+                            "void f ( union U_t u ) { "
+                            "switch ( u . e ) { "
+                            "case U_t :: E0 : ; "
+                            "break ; "
+                            "} "
+                            "}";
+        ASSERT_EQUALS(exp3, tok(code3));
+
+        const char code4[] = "struct A { static const int i = 1; };\n" // #12947
+                             "typedef A B;\n"
+                             "int f() {\n"
+                             "    return B::i;\n"
+                             "}\n";
+        const char exp4[] = "struct A { "
+                            "static const int i = 1 ; "
+                            "} ; "
+                            "int f ( ) { "
+                            "return A :: i ; "
+                            "}";
+        ASSERT_EQUALS(exp4, tok(code4));
+    }
+
+    void simplifyTypedef157() {
+        const char code[] = "namespace NS1 {\n" // #13451
+                            "    typedef NS2::Bar Bar;\n"
+                            "    using NS2::MyType;\n"
+                            "}\n"
+                            "enum E : unsigned int {\n"
+                            "    zero = 0,\n"
+                            "    MyType = 1\n"
+                            "};\n"
+                            "namespace NS1 {}\n";
+        const char exp[] = "enum E : int { zero = 0 , MyType = 1 } ;";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void simplifyTypedef158() {
+        const char code[] = "void f() {\n"
+                            "    typedef const char* const triple[3];\n"
+                            "    static const triple data[] = { {\"a\" , \"b\" , \"c\" } };\n"
+                            "}\n";
+        const char exp[] = "void f ( ) { static const char * const data [ ] [ 3 ] = { { \"a\" , \"b\" , \"c\" } } ; }";
+        const char cur[] = "void f ( ) { static const char * const const data [ ] [ 3 ] = { { \"a\" , \"b\" , \"c\" } } ; }";
+        TODO_ASSERT_EQUALS(exp, cur, tok(code));
+    }
+
+    void simplifyTypedef159() {
+        const char code[] = "typedef void (*const func_t)();\n" // #14387
+                            "func_t g() { return nullptr; }\n";
+        const char exp[] = "void * const g ( ) { return nullptr ; }";
+        ASSERT_EQUALS(exp, tok(code));
     }
 
     void simplifyTypedefFunction1() {
@@ -2552,7 +3820,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( ) > func_queue ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2562,7 +3830,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( void ) > func_queue ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2572,7 +3840,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( int ) > func_queue ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2582,7 +3850,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( int * ) > func_queue ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2593,7 +3861,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( arg_class * ) > func_queue ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
 
@@ -2604,7 +3872,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( ) > func_queue ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2614,7 +3882,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( void ) > func_queue ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2624,7 +3892,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( int ) > func_queue ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2634,7 +3902,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( int * ) > func_queue ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2644,7 +3912,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( arg_class * ) > func_queue ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
 
@@ -2655,7 +3923,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( ) > func_queue ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2665,7 +3933,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( void ) > func_queue ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2675,7 +3943,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( int ) > func_queue ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2685,7 +3953,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( int * ) > func_queue ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2695,7 +3963,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( arg_class * ) > func_queue ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
 
@@ -2706,7 +3974,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( ) > func_queue ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2716,7 +3984,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( void ) > func_queue ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2726,7 +3994,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( int ) > func_queue ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2736,7 +4004,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( int * ) > func_queue ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2746,7 +4014,7 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             const char expected[] = "std :: queue < void ( * ) ( arg_class * ) > func_queue ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
     }
 
@@ -2778,14 +4046,14 @@ class TestSimplifyTypedef : public TestFixture {
 
             // The expected result..
             const char expected[] = "C f1 ( ) ; "
-                                    "C * f2 ; " // this gets simplified to a regular pointer
+                                    "C ( * f2 ) ( ) ; "
                                     "C ( & f3 ) ( ) ; "
-                                    "C * f4 ; " // this gets simplified to a regular pointer
-                                    "C * f5 ; " // this gets simplified to a regular pointer
-                                    "C * f6 ; " // this gets simplified to a regular pointer
-                                    "C * f7 ;"; // this gets simplified to a regular pointer
-            ASSERT_EQUALS(expected, tok(code, true, Settings::Native, false));
-            ASSERT_EQUALS("", errout.str());
+                                    "C ( * f4 ) ( ) ; "
+                                    "C ( * f5 ) ( ) ; "
+                                    "C ( * f6 ) ( ) ; "
+                                    "C ( * f7 ) ( ) ;";
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.debugwarnings = false)));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2807,14 +4075,14 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             // C const -> const C
             const char expected[] = "const C f1 ( ) ; "
-                                    "const C * f2 ; " // this gets simplified to a regular pointer
+                                    "const C ( * f2 ) ( ) ; "
                                     "const C ( & f3 ) ( ) ; "
-                                    "const C * f4 ; " // this gets simplified to a regular pointer
-                                    "const C * f5 ; " // this gets simplified to a regular pointer
-                                    "const C * f6 ; " // this gets simplified to a regular pointer
-                                    "const C * f7 ;"; // this gets simplified to a regular pointer
-            ASSERT_EQUALS(expected, tok(code, true, Settings::Native, false));
-            ASSERT_EQUALS("", errout.str());
+                                    "const C ( * f4 ) ( ) ; "
+                                    "const C ( * f5 ) ( ) ; "
+                                    "const C ( * f6 ) ( ) ; "
+                                    "const C ( * f7 ) ( ) ;";
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.debugwarnings = false)));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2835,14 +4103,14 @@ class TestSimplifyTypedef : public TestFixture {
 
             // The expected result..
             const char expected[] = "const C f1 ( ) ; "
-                                    "const C * f2 ; " // this gets simplified to a regular pointer
+                                    "const C ( * f2 ) ( ) ; "
                                     "const C ( & f3 ) ( ) ; "
-                                    "const C * f4 ; " // this gets simplified to a regular pointer
-                                    "const C * f5 ; " // this gets simplified to a regular pointer
-                                    "const C * f6 ; " // this gets simplified to a regular pointer
-                                    "const C * f7 ;"; // this gets simplified to a regular pointer
-            ASSERT_EQUALS(expected, tok(code, true, Settings::Native, false));
-            ASSERT_EQUALS("", errout.str());
+                                    "const C ( * f4 ) ( ) ; "
+                                    "const C ( * f5 ) ( ) ; "
+                                    "const C ( * f6 ) ( ) ; "
+                                    "const C ( * f7 ) ( ) ;";
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.debugwarnings = false)));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2863,14 +4131,14 @@ class TestSimplifyTypedef : public TestFixture {
 
             // The expected result..
             const char expected[] = "C * f1 ( ) ; "
-                                    "C * * f2 ; " // this gets simplified to a regular pointer
+                                    "C * ( * f2 ) ( ) ; "
                                     "C * ( & f3 ) ( ) ; "
-                                    "C * * f4 ; " // this gets simplified to a regular pointer
-                                    "C * * f5 ; " // this gets simplified to a regular pointer
-                                    "C * * f6 ; " // this gets simplified to a regular pointer
-                                    "C * * f7 ;"; // this gets simplified to a regular pointer
-            ASSERT_EQUALS(expected, tok(code, true, Settings::Native, false));
-            ASSERT_EQUALS("", errout.str());
+                                    "C * ( * f4 ) ( ) ; "
+                                    "C * ( * f5 ) ( ) ; "
+                                    "C * ( * f6 ) ( ) ; "
+                                    "C * ( * f7 ) ( ) ;";
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.debugwarnings = false)));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2891,14 +4159,14 @@ class TestSimplifyTypedef : public TestFixture {
 
             // The expected result..
             const char expected[] = "const C * f1 ( ) ; "
-                                    "const C * * f2 ; " // this gets simplified to a regular pointer
+                                    "const C * ( * f2 ) ( ) ; "
                                     "const C * ( & f3 ) ( ) ; "
-                                    "const C * * f4 ; " // this gets simplified to a regular pointer
-                                    "const C * * f5 ; " // this gets simplified to a regular pointer
-                                    "const C * * f6 ; " // this gets simplified to a regular pointer
-                                    "const C * * f7 ;"; // this gets simplified to a regular pointer
-            ASSERT_EQUALS(expected, tok(code, true, Settings::Native, false));
-            ASSERT_EQUALS("", errout.str());
+                                    "const C * ( * f4 ) ( ) ; "
+                                    "const C * ( * f5 ) ( ) ; "
+                                    "const C * ( * f6 ) ( ) ; "
+                                    "const C * ( * f7 ) ( ) ;";
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.debugwarnings = false)));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -2920,14 +4188,14 @@ class TestSimplifyTypedef : public TestFixture {
             // The expected result..
             // C const -> const C
             const char expected[] = "const C * f1 ( ) ; "
-                                    "const C * * f2 ; " // this gets simplified to a regular pointer
+                                    "const C * ( * f2 ) ( ) ; "
                                     "const C * ( & f3 ) ( ) ; "
-                                    "const C * * f4 ; " // this gets simplified to a regular pointer
-                                    "const C * * f5 ; " // this gets simplified to a regular pointer
-                                    "const C * * f6 ; " // this gets simplified to a regular pointer
-                                    "const C * * f7 ;"; // this gets simplified to a regular pointer
-            ASSERT_EQUALS(expected, tok(code, true, Settings::Native, false));
-            ASSERT_EQUALS("", errout.str());
+                                    "const C * ( * f4 ) ( ) ; "
+                                    "const C * ( * f5 ) ( ) ; "
+                                    "const C * ( * f6 ) ( ) ; "
+                                    "const C * ( * f7 ) ( ) ;";
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.debugwarnings = false)));
+            ASSERT_EQUALS("", errout_str());
         }
     }
 
@@ -2943,8 +4211,8 @@ class TestSimplifyTypedef : public TestFixture {
         const char expected[] = "int ( * ( * t1 ) ( bool ) ) ( int , int ) ; "
                                 "int * t2 ( bool ) ; "
                                 "int * t3 ( bool ) ;";
-        ASSERT_EQUALS(expected, tok(code, false));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedefFunction5() {
@@ -2974,20 +4242,20 @@ class TestSimplifyTypedef : public TestFixture {
                             "type12 t12;";
 
         // The expected result..
-        const char expected[] = "int * t1 ; " // simplified to regular pointer
-                                "int * const t2 ; "
-                                "int * volatile t3 ; "
-                                "int * const volatile t4 ; "
-                                "int * t5 ; "
-                                "int * const t6 ; "
-                                "int * volatile t7 ; "
-                                "int * const volatile t8 ; "
+        const char expected[] = "int ( * t1 ) ( float ) ; "
+                                "int ( * const t2 ) ( float ) ; "
+                                "int ( * volatile t3 ) ( float ) ; "
+                                "int ( * const volatile t4 ) ( float ) ; "
+                                "int ( * t5 ) ( float ) ; "
+                                "int ( * const t6 ) ( float ) ; "
+                                "int ( * volatile t7 ) ( float ) ; "
+                                "int ( * const volatile t8 ) ( float ) ; "
                                 "int ( :: C :: * t9 ) ( float ) ; "
                                 "int ( :: C :: * const t10 ) ( float ) ; "
                                 "int ( :: C :: * volatile t11 ) ( float ) ; "
                                 "int ( :: C :: * const volatile t12 ) ( float ) ;";
-        ASSERT_EQUALS(expected, tok(code, false));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedefFunction6() {
@@ -3013,8 +4281,8 @@ class TestSimplifyTypedef : public TestFixture {
                                 "void * Fred :: get3 ( ) { return 0 ; } "
                                 "void * Fred :: get4 ( ) { return 0 ; }";
 
-        ASSERT_EQUALS(expected, tok(code, false));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedefFunction7() {
@@ -3024,8 +4292,8 @@ class TestSimplifyTypedef : public TestFixture {
         // The expected result..
         const char expected[] = "void ( __gnu_cxx :: _SGIAssignableConcept < _Tp > :: * X ) ( ) ;";
 
-        ASSERT_EQUALS(expected, tok(code, false));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.simplify = false)));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyTypedefFunction8() {
@@ -3033,7 +4301,7 @@ class TestSimplifyTypedef : public TestFixture {
         const char code[] = "typedef int f_expand(const nrv_byte *);\n"
                             "void f(f_expand *(*get_fexp(int))){}";
         checkSimplifyTypedef(code);
-        TODO_ASSERT_EQUALS("", "[test.cpp:2]: (debug) Function::addArguments found argument 'int' with varid 0.\n", errout.str());  // make sure that there is no internal error
+        TODO_ASSERT_EQUALS("", "[test.cpp:2:29]: (debug) Function::addArguments found argument 'int' with varid 0. [varid0]\n", errout_str());  // make sure that there is no internal error
     }
 
     void simplifyTypedefFunction9() {
@@ -3053,7 +4321,7 @@ class TestSimplifyTypedef : public TestFixture {
                                     ":: C ( :: C :: * f3 ) ( ) volatile ; "
                                     ":: C ( :: C :: * f4 ) ( ) const volatile ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -3067,12 +4335,12 @@ class TestSimplifyTypedef : public TestFixture {
                                 "func4 f4;";
 
             // The expected result..
-            const char expected[] = "B :: C * f1 ; "
-                                    "B :: C * f2 ; "
-                                    "B :: C * f3 ; "
-                                    "B :: C * f4 ;";
-            ASSERT_EQUALS(expected, tok(code, true, Settings::Native, false));
-            ASSERT_EQUALS("", errout.str());
+            const char expected[] = "B :: C ( * f1 ) ( ) ; "
+                                    "B :: C ( * f2 ) ( ) ; "
+                                    "B :: C ( * f3 ) ( ) ; "
+                                    "B :: C ( * f4 ) ( ) ;";
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.debugwarnings = false)));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -3091,7 +4359,7 @@ class TestSimplifyTypedef : public TestFixture {
                                     ":: B :: C ( :: B :: C :: * f3 ) ( ) volatile ; "
                                     ":: B :: C ( :: B :: C :: * f4 ) ( ) const volatile ;";
             ASSERT_EQUALS(expected, tok(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -3105,12 +4373,12 @@ class TestSimplifyTypedef : public TestFixture {
                                 "func4 f4;";
 
             // The expected result..
-            const char expected[] = "A :: B :: C * f1 ; "
-                                    "A :: B :: C * f2 ; "
-                                    "A :: B :: C * f3 ; "
-                                    "A :: B :: C * f4 ;";
-            ASSERT_EQUALS(expected, tok(code, true, Settings::Native, false));
-            ASSERT_EQUALS("", errout.str());
+            const char expected[] = "A :: B :: C ( * f1 ) ( ) ; "
+                                    "A :: B :: C ( * f2 ) ( ) ; "
+                                    "A :: B :: C ( * f3 ) ( ) ; "
+                                    "A :: B :: C ( * f4 ) ( ) ;";
+            ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.debugwarnings = false)));
+            ASSERT_EQUALS("", errout_str());
         }
     }
 
@@ -3127,9 +4395,44 @@ class TestSimplifyTypedef : public TestFixture {
                       "namespace MySpace { "
                       "enum Format_E2 { FORMAT21 , FORMAT22 } ; enum Format_E2 Format_T2 ; "
                       "} "
-                      "Format_E1 * * t1 ; "
-                      "MySpace :: Format_E2 * * t2 ;",
-                      tok(code,false));
+                      "Format_E1 ( * * t1 ) ( ) ; "
+                      "MySpace :: Format_E2 ( * * t2 ) ( ) ;",
+                      tok(code,dinit(TokOptions, $.simplify = false)));
+    }
+
+    void simplifyTypedefFunction11() {
+        const char code[] = "typedef void (*func_t) (int);\n"
+                            "void g(int);\n"
+                            "void f(void* p) {\n"
+                            "    if (g != func_t(p)) {}\n"
+                            "    if (g != (func_t)p) {}\n"
+                            "}\n";
+        TODO_ASSERT_EQUALS("void g ( int ) ; "
+                           "void f ( void * p ) { "
+                           "if ( g != ( void ( * ) ( int ) ) ( p ) ) { } "
+                           "if ( g != ( void ( * ) ( int ) ) p ) { } "
+                           "}",
+                           "void g ( int ) ; "
+                           "void f ( void * p ) { "
+                           "if ( g != void * ( p ) ) { } "
+                           "if ( g != ( void * ) p ) { } "
+                           "}",
+                           tok(code,dinit(TokOptions, $.simplify = false)));
+        ignore_errout(); // we are not interested in the output
+    }
+
+    void simplifyTypedefStruct() {
+        const char code1[] = "typedef struct S { int x; } xyz;\n"
+                             "xyz var;";
+        ASSERT_EQUALS("struct S { int x ; } ; struct S var ;", tok(code1,dinit(TokOptions, $.simplify = false)));
+
+        const char code2[] = "typedef const struct S { int x; } xyz;\n"
+                             "xyz var;";
+        ASSERT_EQUALS("struct S { int x ; } ; const struct S var ;", tok(code2,dinit(TokOptions, $.simplify = false)));
+
+        const char code3[] = "typedef volatile struct S { int x; } xyz;\n"
+                             "xyz var;";
+        ASSERT_EQUALS("struct S { int x ; } ; volatile struct S var ;", tok(code3,dinit(TokOptions, $.simplify = false)));
     }
 
     void simplifyTypedefShadow() { // shadow variable (#4445)
@@ -3138,7 +4441,214 @@ class TestSimplifyTypedef : public TestFixture {
                             "    int abc, xyz;\n" // <- shadow variable
                             "}";
         ASSERT_EQUALS("struct xyz { int x ; } ; void f ( ) { int abc ; int xyz ; }",
-                      tok(code,false));
+                      tok(code,dinit(TokOptions, $.simplify = false)));
+    }
+
+    void simplifyTypedefMacro() {
+        const char code[] = "typedef uint32_t index_t;\n"
+                            "\n"
+                            "#define NO_SEGMENT     ((index_t)12)\n"
+                            "\n"
+                            "void foo(index_t prev_segment) {\n"
+                            "    if(prev_segment==NO_SEGMENT) {}\n" // <- test that index_t is replaced with uint32_t in the expanded tokens
+                            "}";
+        ASSERT_EQUALS("void foo ( uint32_t prev_segment ) { if ( prev_segment == ( ( uint32_t ) 12 ) ) { } }",
+                      simplifyTypedefP(code));
+    }
+
+    void simplifyTypedefOriginalName1() {
+        const char code[] = "typedef unsigned char uint8_t;"
+                            "typedef float (*rFunctionPointer_fp)(uint8_t, uint8_t);"
+                            "typedef enum eEnumDef {"
+                            "  ABC = 0,"
+                            "}eEnum_t;"
+                            "typedef enum {"
+                            "  ABC = 0,"
+                            "}eEnum2_t;"
+                            "typedef short int16_t;"
+                            "typedef struct stStructDef {"
+                            "  int16_t swA;"
+                            "}stStruct_t;"
+                            "double endOfTypeDef;"
+                            "eEnum2_t enum2Type;"
+                            "stStruct_t structType;"
+                            "eEnum_t enumType;"
+                            "uint8_t t;"
+                            "void test(rFunctionPointer_fp functionPointer);";
+
+        TokenList tokenlist{settings1, Standards::Language::C};
+        ASSERT(TokenListHelper::createTokensFromString(tokenlist, code, "file.c"));
+        TokenizerTest tokenizer(std::move(tokenlist), *this);
+        tokenizer.createLinks();
+        tokenizer.simplifyTypedef();
+
+        try {
+            tokenizer.validate();
+        }
+        catch (const InternalError&) {
+            ASSERT_EQUALS_MSG(false, true, "Validation of Tokenizer failed");
+        }
+
+        const Token* token;
+        // Get the Token which is at the end of all the Typedef's in this case i placed a variable
+        const Token* endOfTypeDef = Token::findsimplematch(tokenizer.list.front(), "endOfTypeDef", tokenizer.list.back());
+        // Search for the simplified char token and check its original Name
+        token = Token::findsimplematch(endOfTypeDef, "char", tokenizer.list.back());
+        ASSERT_EQUALS("uint8_t", token->originalName());
+        // Search for the simplified eEnumDef token and check its original Name
+        token = Token::findsimplematch(endOfTypeDef, "eEnumDef", tokenizer.list.back());
+        ASSERT_EQUALS("eEnum_t", token->originalName());
+        // Search for the eEnum2_t token as it does not have a name it should be the direct type name
+        token = Token::findsimplematch(endOfTypeDef, "eEnum2_t", tokenizer.list.back());
+        ASSERT_EQUALS("eEnum2_t", token->str());
+        // Search for the simplified stStructDef token and check its original Name
+        token = Token::findsimplematch(endOfTypeDef, "stStructDef", tokenizer.list.back());
+        ASSERT_EQUALS("stStruct_t", token->originalName());
+        // Search for the simplified short token and check its original Name, start from front to get the variable in the struct
+        token = Token::findsimplematch(tokenizer.list.front(), "short", tokenizer.list.back());
+        ASSERT_EQUALS("int16_t", token->originalName());
+        // Search for the simplified * token -> function pointer gets "(*" tokens infront of it
+        token = Token::findsimplematch(endOfTypeDef, "*", tokenizer.list.back());
+        ASSERT_EQUALS("rFunctionPointer_fp", token->originalName());
+    }
+
+    void simplifyTypedefOriginalName2() {
+        const char code[] = "typedef unsigned short uint16;\n"
+                            "typedef uint16 A;\n"
+                            "A a;";
+        TokenList tokenlist{ settings1, Standards::Language::C };
+        ASSERT(TokenListHelper::createTokensFromString(tokenlist, code, "file.c"));
+        TokenizerTest tokenizer(std::move(tokenlist), *this);
+        tokenizer.createLinks();
+        tokenizer.simplifyTypedef();
+
+        try {
+            tokenizer.validate();
+        }
+        catch (const InternalError&) {
+            ASSERT_EQUALS_MSG(false, true, "Validation of Tokenizer failed");
+        }
+        const Token* token = Token::findsimplematch(tokenizer.list.front(), "short");
+        ASSERT_EQUALS("A", token->originalName());
+    }
+
+    void simplifyTypedefTokenColumn1() {  // #13155
+        const char code[] = "void foo(void) {\n"
+                            "    typedef signed int MY_INT;\n"
+                            "    MY_INT x = 0;\n"
+                            "}";
+
+        TokenList tokenlist{settings1, Standards::Language::C};
+        ASSERT(TokenListHelper::createTokensFromString(tokenlist, code, "file.c"));
+        TokenizerTest tokenizer(std::move(tokenlist), *this);
+        tokenizer.createLinks();
+        tokenizer.simplifyTypedef();
+
+        const Token* x = Token::findsimplematch(tokenizer.list.front(), "x");
+        const Token* type = x->previous();
+        ASSERT_EQUALS("int", type->str());
+        ASSERT_EQUALS(5, type->column());
+    }
+
+    void simplifyTypedefTokenColumn2() {
+        const char code[] = "void foo(void) {\n"
+                            "    typedef signed int (*F)(int);\n"
+                            "    F x = 0;\n"
+                            "}";
+
+        TokenList tokenlist{settings1, Standards::Language::C};
+        ASSERT(TokenListHelper::createTokensFromString(tokenlist, code, "file.c"));
+        TokenizerTest tokenizer(std::move(tokenlist), *this);
+        tokenizer.createLinks();
+        tokenizer.simplifyTypedef();
+
+        const Token* x = Token::findsimplematch(tokenizer.list.front(), "x");
+        const Token* type = x->previous();
+        ASSERT_EQUALS("*", type->str());
+        ASSERT_EQUALS(5, type->column());
+    }
+
+    void simplifyTypedefTokenColumn3() { // #13368
+        const char code[] = "typedef struct S_ {} S;\n"
+                            "typedef S* P;\n"
+                            "void f(const P p);\n";
+        ASSERT_EQUALS("struct S_ { } ; void f ( struct S_ * const p ) ;", // don't crash
+                      tok(code));
+
+        const char code2[] = "struct S;\n"
+                             "typedef S& (S::* P)(const S&);\n"
+                             "void f(const P);\n";
+        ASSERT_EQUALS("struct S ; void f ( const S & ( S :: * ) ( const S & ) ) ;", // don't crash
+                      tok(code2));
+    }
+
+    void typedefInfo1() {
+        const std::string xml = dumpTypedefInfo("typedef int A;\nA x;");
+        ASSERT_EQUALS("  <typedef-info>\n"
+                      "    <info name=\"A\" file=\"file.c\" line=\"1\" column=\"1\" used=\"1\" isFunctionPointer=\"0\"/>\n"
+                      "  </typedef-info>\n",
+                      xml);
+    }
+
+    void typedefInfo2() {
+        const std::string xml = dumpTypedefInfo("typedef signed short int16_t;\n"
+                                                "typedef void ( *fp16 )( int16_t n );\n"
+                                                "void R_11_1 ( void ){\n"
+                                                "   typedef fp16 ( *pfp16 ) ( void );\n"
+                                                "}\n");
+        ASSERT_EQUALS("  <typedef-info>\n"
+                      "    <info name=\"fp16\" file=\"file.c\" line=\"2\" column=\"1\" used=\"1\" isFunctionPointer=\"1\">\n"
+                      "      <token line=\"2\" column=\"1\" str=\"typedef\"/>\n"
+                      "      <token line=\"2\" column=\"9\" str=\"void\"/>\n"
+                      "      <token line=\"2\" column=\"14\" str=\"(\"/>\n"
+                      "      <token line=\"2\" column=\"16\" str=\"*\"/>\n"
+                      "      <token line=\"2\" column=\"17\" str=\"fp16\"/>\n"
+                      "      <token line=\"2\" column=\"22\" str=\")\"/>\n"
+                      "      <token line=\"2\" column=\"23\" str=\"(\"/>\n"
+                      "      <token line=\"2\" column=\"25\" str=\"int16_t\"/>\n"
+                      "      <token line=\"2\" column=\"33\" str=\"n\"/>\n"
+                      "      <token line=\"2\" column=\"35\" str=\")\"/>\n"
+                      "    </info>\n"
+                      "    <info name=\"int16_t\" file=\"file.c\" line=\"1\" column=\"1\" used=\"1\" isFunctionPointer=\"0\"/>\n"
+                      "    <info name=\"pfp16\" file=\"file.c\" line=\"4\" column=\"4\" used=\"0\" isFunctionPointer=\"1\">\n"
+                      "      <token line=\"4\" column=\"4\" str=\"typedef\"/>\n"
+                      "      <token line=\"4\" column=\"12\" str=\"void\"/>\n"
+                      "      <token line=\"4\" column=\"12\" str=\"(\"/>\n"
+                      "      <token line=\"4\" column=\"12\" str=\"*\"/>\n"
+                      "      <token line=\"4\" column=\"17\" str=\"(\"/>\n"
+                      "      <token line=\"4\" column=\"19\" str=\"*\"/>\n"
+                      "      <token line=\"4\" column=\"20\" str=\"pfp16\"/>\n"
+                      "      <token line=\"4\" column=\"26\" str=\")\"/>\n"
+                      "      <token line=\"4\" column=\"28\" str=\"(\"/>\n"
+                      "      <token line=\"4\" column=\"30\" str=\"void\"/>\n"
+                      "      <token line=\"4\" column=\"35\" str=\")\"/>\n"
+                      "      <token line=\"4\" column=\"35\" str=\")\"/>\n"
+                      "      <token line=\"4\" column=\"35\" str=\"(\"/>\n"
+                      "      <token line=\"4\" column=\"35\" str=\"signed\"/>\n"
+                      "      <token line=\"4\" column=\"35\" str=\"short\"/>\n"
+                      "      <token line=\"4\" column=\"35\" str=\"n\"/>\n"
+                      "      <token line=\"4\" column=\"35\" str=\")\"/>\n"
+                      "    </info>\n"
+                      "  </typedef-info>\n",xml);
+    }
+
+    void typedefInfo3() {
+        const std::string xml = dumpTypedefInfo("int main() {\n"
+                                                "     using x::a;\n"
+                                                "     b = a + 2;\n"
+                                                "}\n");
+        ASSERT_EQUALS("",xml);
+    }
+
+    void typedefInfo4() {
+        const std::string xml = dumpTypedefInfo("typedef struct coord {\n"
+                                                "    uint16_t x;\n"
+                                                "    uint16_t y;\n"
+                                                "} coord;\n"
+                                                "coord c;");
+        ASSERT_EQUALS("  <typedef-info>\n"
+                      "    <info name=\"coord\" file=\"file.c\" line=\"1\" column=\"1\" tagline=\"1\" tagcolumn=\"16\" used=\"1\" isFunctionPointer=\"0\"/>\n"
+                      "  </typedef-info>\n", xml);
     }
 };
 
diff --git a/test/testsimplifyusing.cpp b/test/testsimplifyusing.cpp
index 1822047f30f..7359613510f 100644
--- a/test/testsimplifyusing.cpp
+++ b/test/testsimplifyusing.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,32 +16,28 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "platform.h"
 #include "settings.h"
-#include "testsuite.h"
+#include "standards.h"
 #include "token.h"
-#include "tokenize.h"
-#include "tokenlist.h"
-
-struct InternalError;
+#include "utils.h"
 
+#include <cstddef>
+#include <string>
 
 class TestSimplifyUsing : public TestFixture {
 public:
-    TestSimplifyUsing() : TestFixture("TestSimplifyUsing") {
-    }
+    TestSimplifyUsing() : TestFixture("TestSimplifyUsing") {}
 
 
 private:
-    Settings settings0;
-    Settings settings1;
-    Settings settings2;
-
-    void run() OVERRIDE {
-        settings0.addEnabled("style");
-        settings2.addEnabled("style");
+    const Settings settings0 = settingsBuilder().severity(Severity::style).build();
 
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(simplifyUsing1);
         TEST_CASE(simplifyUsing2);
         TEST_CASE(simplifyUsing3);
@@ -58,6 +54,29 @@ class TestSimplifyUsing : public TestFixture {
         TEST_CASE(simplifyUsing14);
         TEST_CASE(simplifyUsing15);
         TEST_CASE(simplifyUsing16);
+        TEST_CASE(simplifyUsing17);
+        TEST_CASE(simplifyUsing18);
+        TEST_CASE(simplifyUsing19);
+        TEST_CASE(simplifyUsing20);
+        TEST_CASE(simplifyUsing21);
+        TEST_CASE(simplifyUsing22);
+        TEST_CASE(simplifyUsing23);
+        TEST_CASE(simplifyUsing24);
+        TEST_CASE(simplifyUsing25);
+        TEST_CASE(simplifyUsing26); // #11090
+        TEST_CASE(simplifyUsing27);
+        TEST_CASE(simplifyUsing28);
+        TEST_CASE(simplifyUsing29);
+        TEST_CASE(simplifyUsing30);
+        TEST_CASE(simplifyUsing31);
+        TEST_CASE(simplifyUsing32);
+        TEST_CASE(simplifyUsing33);
+        TEST_CASE(simplifyUsing34);
+        TEST_CASE(simplifyUsing35);
+        TEST_CASE(simplifyUsing36);
+        TEST_CASE(simplifyUsing37);
+        TEST_CASE(simplifyUsing38);
+        TEST_CASE(simplifyUsing39);
 
         TEST_CASE(simplifyUsing8970);
         TEST_CASE(simplifyUsing8971);
@@ -66,23 +85,49 @@ class TestSimplifyUsing : public TestFixture {
         TEST_CASE(simplifyUsing9042);
         TEST_CASE(simplifyUsing9191);
         TEST_CASE(simplifyUsing9381);
+        TEST_CASE(simplifyUsing9385);
+        TEST_CASE(simplifyUsing9388);
+        TEST_CASE(simplifyUsing9518);
+        TEST_CASE(simplifyUsing9757);
+        TEST_CASE(simplifyUsing10008);
+        TEST_CASE(simplifyUsing10054);
+        TEST_CASE(simplifyUsing10136);
+        TEST_CASE(simplifyUsing10171);
+        TEST_CASE(simplifyUsing10172);
+        TEST_CASE(simplifyUsing10173);
+        TEST_CASE(simplifyUsing10335);
+        TEST_CASE(simplifyUsing10720);
+        TEST_CASE(simplifyUsing13873); // function declaration
+
+        TEST_CASE(scopeInfo1);
+        TEST_CASE(scopeInfo2);
     }
 
-    std::string tok(const char code[], bool simplify = true, Settings::PlatformType type = Settings::Native, bool debugwarnings = true) {
-        errout.str("");
-
-        settings0.inconclusive = true;
-        settings0.debugwarnings = debugwarnings;
-        settings0.platform(type);
-        Tokenizer tokenizer(&settings0, this);
-
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+    struct TokOptions
+    {
+        Platform::Type type = Platform::Type::Native;
+        bool debugwarnings = true;
+        bool preprocess = false;
+        Standards::cppstd_t cppstd = Standards::CPPLatest;
+    };
+
+#define tok(...) tok_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    std::string tok_(const char* file, int line, const char (&code)[size], const TokOptions& options = make_default_obj()) {
+        const Settings settings = settingsBuilder(settings0).certainty(Certainty::inconclusive).debugwarnings(options.debugwarnings)
+                                  .platform(options.type).cpp(options.cppstd).build();
+
+        if (options.preprocess) {
+            SimpleTokenizer2 tokenizer(settings, *this, code, "test.cpp");
+
+            ASSERT_LOC(tokenizer.simplifyTokens1(""), file, line);
+            return tokenizer.tokens()->stringifyList(nullptr);
+        }
 
-        if (simplify)
-            tokenizer.simplifyTokenList2();
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
-        return tokenizer.tokens()->stringifyList(nullptr, !simplify);
+        return tokenizer.tokens()->stringifyList(nullptr);
     }
 
     void simplifyUsing1() {
@@ -113,7 +158,7 @@ class TestSimplifyUsing : public TestFixture {
             "a . foo ( ) ; "
             "wchar_t c ; c = 0 ; "
             "}";
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code));
     }
 
     void simplifyUsing2() {
@@ -183,7 +228,7 @@ class TestSimplifyUsing : public TestFixture {
             "unsigned int uvar ; uvar = 2 ; "
             "return uvar / ivar ; "
             "}";
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code));
     }
 
     void simplifyUsing5() {
@@ -197,10 +242,10 @@ class TestSimplifyUsing : public TestFixture {
         const char expected[] =
             "void f ( ) "
             "{ "
-            "struct yy_buffer_state * state ; "
+            "yy_buffer_state * state ; "
             "}";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code));
     }
 
     void simplifyUsing6() {
@@ -216,14 +261,14 @@ class TestSimplifyUsing : public TestFixture {
             "float fast_atan2 ( float y , float x ) { } "
             "}";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code));
     }
 
     void simplifyUsing7() {
         const char code[] = "using abc = int; "
                             "Fred :: abc f ;";
         const char expected[] = "Fred :: abc f ;";
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code));
     }
 
     void simplifyUsing8() {
@@ -254,7 +299,7 @@ class TestSimplifyUsing : public TestFixture {
             "const int & trci ; "
             "const unsigned int & trcui ;";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code));
     }
 
     void simplifyUsing9() {
@@ -277,15 +322,15 @@ class TestSimplifyUsing : public TestFixture {
             "struct t { int a ; } ; "
             "struct U { int a ; } ; "
             "struct Unnamed0 { int a ; } ; "
-            "struct s s ; "
-            "struct s * ps ; "
-            "struct t t ; "
-            "struct t * tp ; "
-            "struct U u ; "
-            "struct U * v ; "
-            "struct Unnamed0 * w ;";
+            "s s ; "
+            "s * ps ; "
+            "t t ; "
+            "t * tp ; "
+            "U u ; "
+            "U * v ; "
+            "Unnamed0 * w ;";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code));
     }
 
     void simplifyUsing10() {
@@ -308,15 +353,15 @@ class TestSimplifyUsing : public TestFixture {
             "union t { int a ; float b ; } ; "
             "union U { int a ; float b ; } ; "
             "union Unnamed0 { int a ; float b ; } ; "
-            "union s s ; "
-            "union s * ps ; "
-            "union t t ; "
-            "union t * tp ; "
-            "union U u ; "
-            "union U * v ; "
-            "union Unnamed0 * w ;";
+            "s s ; "
+            "s * ps ; "
+            "t t ; "
+            "t * tp ; "
+            "U u ; "
+            "U * v ; "
+            "Unnamed0 * w ;";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code));
     }
 
     void simplifyUsing11() {
@@ -327,10 +372,10 @@ class TestSimplifyUsing : public TestFixture {
 
         const char expected[] = "enum abc { a = 0 , b = 1 , c = 2 } ; "
                                 "enum xyz { x = 0 , y = 1 , z = 2 } ; "
-                                "enum abc e1 ; "
-                                "enum xyz e2 ;";
+                                "abc e1 ; "
+                                "xyz e2 ;";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code));
     }
 
     void simplifyUsing12() {
@@ -348,7 +393,7 @@ class TestSimplifyUsing : public TestFixture {
                                 "std :: vector < std :: vector < int > > v3 ; "
                                 "std :: list < int > :: iterator iter ;";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code));
     }
 
     void simplifyUsing13() {
@@ -362,8 +407,8 @@ class TestSimplifyUsing : public TestFixture {
                                 "std :: vector < std :: pair < int ( * ) ( void * ) , void * > > q ; "
                                 "}";
 
-        ASSERT_EQUALS(expected, tok(code, false));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(expected, tok(code));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyUsing14() {
@@ -379,8 +424,8 @@ class TestSimplifyUsing : public TestFixture {
                             "    FP_M(val);"
                             "};";
 
-        tok(code, true, Settings::Native, false);
-        ASSERT_EQUALS("", errout.str());
+        TODO_ASSERT_THROW(tok(code, dinit(TokOptions, $.debugwarnings = false)), InternalError); // TODO: Do not throw AST validation exception
+        //ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyUsing15() {
@@ -390,7 +435,7 @@ class TestSimplifyUsing : public TestFixture {
 
             const char expected[] = "char f [ 10 ] ;";
 
-            ASSERT_EQUALS(expected, tok(code, false));
+            ASSERT_EQUALS(expected, tok(code));
         }
 
         {
@@ -399,7 +444,7 @@ class TestSimplifyUsing : public TestFixture {
 
             const char expected[] = "unsigned char f [ 10 ] ;";
 
-            ASSERT_EQUALS(expected, tok(code, false));
+            ASSERT_EQUALS(expected, tok(code));
         }
     }
 
@@ -414,10 +459,484 @@ class TestSimplifyUsing : public TestFixture {
         const char expected[] = "struct STRFOO { "
                                 "char freem [ 4096 ] ; "
                                 "} ; "
-                                "struct STRFOO s ;";
+                                "STRFOO s ;";
+
+        ASSERT_EQUALS(expected, tok(code));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void simplifyUsing17() {
+        const char code[] = "class C1 {};\n"
+                            "using S1 = class S1 {};\n"
+                            "using S2 = class S2 : public C1 {};\n"
+                            "using S3 = class {};\n"
+                            "using S4 = class : public C1 {};\n"
+                            "S1 s1;\n"
+                            "S2 s2;\n"
+                            "S3 s3;\n"
+                            "S4 s4;";
+
+        const char expected[] = "class C1 { } ; "
+                                "class S1 { } ; "
+                                "class S2 : public C1 { } ; "
+                                "class S3 { } ; "
+                                "class S4 : public C1 { } ; "
+                                "S1 s1 ; "
+                                "S2 s2 ; "
+                                "S3 s3 ; "
+                                "S4 s4 ;";
+
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
+    void simplifyUsing18() {
+        const char code[] = "{ { { using a = a; using a; } } }";
+        (void)tok(code); // don't crash
+    }
+
+    void simplifyUsing19() {
+        const char code[] = "namespace a {\n"
+                            "using b = int;\n"
+                            "void foo::c() { }\n"
+                            "void foo::d() { }\n"
+                            "void foo::e() {\n"
+                            "   using b = float;\n"
+                            "}\n"
+                            "}";
+        (void)tok(code); // don't hang
+        ignore_errout(); // we are not interested in the output
+    }
+
+    void simplifyUsing20() {
+        const char code[] = "namespace a {\n"
+                            "namespace b {\n"
+                            "namespace c {\n"
+                            "namespace d {\n"
+                            "namespace e {\n"
+                            "namespace f {\n"
+                            "namespace g {\n"
+                            "using Changeset = ::IAdaptionCallback::Changeset;\n"
+                            "using EProperty = searches::EProperty;\n"
+                            "using ChangesetValueType = Changeset::value_type;\n"
+                            "namespace {\n"
+                            "   template <class T>\n"
+                            "   auto modify(std::shared_ptr<T>& p) -> boost::optional<decltype(p->modify())> {\n"
+                            "      return nullptr;\n"
+                            "   }\n"
+                            "   template <class T>\n"
+                            "   std::list<T> getValidElements() {\n"
+                            "      return nullptr;\n"
+                            "   }\n"
+                            "}\n"
+                            "std::shared_ptr<ResourceConfiguration>\n"
+                            "foo::getConfiguration() {\n"
+                            "   return nullptr;\n"
+                            "}\n"
+                            "void\n"
+                            "foo::doRegister(const Input & Input) {\n"
+                            "   UNUSED( Input );\n"
+                            "}\n"
+                            "foo::MicroServiceReturnValue\n"
+                            "foo::post(SearchesPtr element, const Changeset& changeset)\n"
+                            "{\n"
+                            "   using EProperty = ab::ep;\n"
+                            "   static std::map<EProperty, std::pair<ElementPropertyHandler, CheckComponentState>> updateHandlers =\n"
+                            "   {\n"
+                            "      {EProperty::Needle, {&RSISearchesResource::updateNeedle,         &RSISearchesResource::isSearcherReady}},\n"
+                            "      {EProperty::SortBy, {&RSISearchesResource::updateResultsSorting, &RSISearchesResource::isSearcherReady}}\n"
+                            "   };\n"
+                            "   return nullptr;\n"
+                            "}\n"
+                            "}}}}}}}";
+        (void)tok(code); // don't hang
+        ignore_errout(); // we do not care about the output
+    }
+
+    void simplifyUsing21() {
+        const char code[] = "using a = b;\n"
+                            "enum {}";
+        (void)tok(code); // don't crash
+    }
+
+    void simplifyUsing22() {
+        const char code[] = "namespace aa { namespace bb { namespace cc { namespace dd { namespace ee {\n"
+                            "class fff {\n"
+                            "public:\n"
+                            "    using icmsp   = std::shared_ptr<aa::bb::ee::cm::api::icm>;\n"
+                            "private:\n"
+                            "    using Connection = boost::signals2::connection;\n"
+                            "    using ESdk = sdk::common::api::Sdk::ESdk;\n"
+                            "    using co = aa::bb::ee::com::api::com2;\n"
+                            "};\n"
+                            "fff::fff() : m_icm(icm) {\n"
+                            "    using ESdk = aa::bb::sdk::common::api::Sdk::ESdk;\n"
+                            "}\n"
+                            "}}}}}";
+        const char expected[] = "namespace aa { namespace bb { namespace cc { namespace dd { namespace ee { "
+                                "class fff { "
+                                "public: "
+                                "private: "
+                                "} ; "
+                                "fff :: fff ( ) : m_icm ( icm ) { "
+                                "} "
+                                "} } } } }";
+        ASSERT_EQUALS(expected, tok(code)); // don't hang
+        ignore_errout(); // we do not care about the output
+    }
+
+    void simplifyUsing23() {
+        const char code[] = "class cmcch {\n"
+                            "public:\n"
+                            "   cmcch(icmsp const& icm, Rtnf&& rtnf = {});\n"
+                            "private:\n"
+                            "    using escs = aa::bb::cc::dd::ee;\n"
+                            "private:\n"
+                            "   icmsp m_icm;\n"
+                            "   mutable std::atomic<rt> m_rt;\n"
+                            "};\n"
+                            "cmcch::cmcch(cmcch::icmsp const& icm, Rtnf&& rtnf)\n"
+                            "   : m_icm(icm)\n"
+                            "   , m_rt{rt::UNKNOWN_} {\n"
+                            "  using escs = yy::zz::aa::bb::cc::dd::ee;\n"
+                            "}";
+        const char expected[] = "class cmcch { "
+                                "public: "
+                                "cmcch ( const icmsp & icm , Rtnf && rtnf = { } ) ; "
+                                "private: "
+                                "private: "
+                                "icmsp m_icm ; "
+                                "mutable std :: atomic < rt > m_rt ; "
+                                "} ; "
+                                "cmcch :: cmcch ( const cmcch :: icmsp & icm , Rtnf && rtnf ) "
+                                ": m_icm ( icm ) "
+                                ", m_rt { rt :: UNKNOWN_ } { "
+                                "}";
+        ASSERT_EQUALS(expected, tok(code)); // don't hang
+    }
+
+    void simplifyUsing24() {
+        const char code[] = "using value_type = const ValueFlow::Value;\n"
+                            "value_type vt;";
+        const char expected[] = "const ValueFlow :: Value vt ;";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
+    void simplifyUsing25() {
+        const char code[] = "struct UnusualType {\n"
+                            "  using T = vtkm::Id;\n"
+                            "  T X;\n"
+                            "};\n"
+                            "namespace vtkm {\n"
+                            "template <>\n"
+                            "struct VecTraits<UnusualType> : VecTraits<UnusualType::T> { };\n"
+                            "}";
+        const char expected[] = "struct UnusualType { "
+                                "vtkm :: Id X ; "
+                                "} ; "
+                                "namespace vtkm { "
+                                "struct VecTraits<UnusualType> : VecTraits < vtkm :: Id > { } ; "
+                                "}";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
+    void simplifyUsing26() { // #11090
+        const char code[] = "namespace M {\n"
+                            "    struct A;\n"
+                            "    struct B;\n"
+                            "    struct C;\n"
+                            "    template<typename T>\n"
+                            "    struct F {};\n"
+                            "    template<>\n"
+                            "    struct F<B> : F<A> {};\n"
+                            "    template<>\n"
+                            "    struct F<C> : F<A> {};\n"
+                            "}\n"
+                            "namespace N {\n"
+                            "    using namespace M;\n"
+                            "    using A = void;\n"
+                            "}\n";
+        const char expected[] = "namespace M { "
+                                "struct A ; struct B ; struct C ; "
+                                "struct F<C> ; struct F<B> ; struct F<A> ; "
+                                "struct F<B> : F<A> { } ; struct F<C> : F<A> { } ; "
+                                "} "
+                                "namespace N { "
+                                "using namespace M ; "
+                                "} "
+                                "struct M :: F<A> { } ;";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
+    void simplifyUsing27() { // #11670
+        const char code[] = "namespace N {\n"
+                            "    template <class T>\n"
+                            "    struct S {\n"
+                            "        using iterator = T*;\n"
+                            "        iterator begin();\n"
+                            "    };\n"
+                            "}\n"
+                            "using I = N::S<int>;\n"
+                            "void f() {\n"
+                            "    I::iterator iter;\n"
+                            "}\n";
+        const char expected[] = "namespace N { struct S<int> ; } "
+                                "void f ( ) { int * iter ; } "
+                                "struct N :: S<int> { int * begin ( ) ; } ;";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
+    void simplifyUsing28() { // #11795
+        const char code[] = "void f() {\n"
+                            "    using T = int;\n"
+                            "    T* p{ new T };\n"
+                            "}\n";
+        const char expected[] = "void f ( ) { int * p { new int } ; }";
+        ASSERT_EQUALS(expected, tok(code));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void simplifyUsing29() { // #11981
+        const char code[] = "using T = int*;\n"
+                            "void f(T = T()) {}\n";
+        const char expected[] = "void f ( int * = ( int * ) 0 ) { }";
+        ASSERT_EQUALS(expected, tok(code));
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        ASSERT_EQUALS(expected, tok(code, false));
-        ASSERT_EQUALS("", errout.str());
+    void simplifyUsing30() {
+        {
+            const char code[] = "using std::to_string;\n" // #8454
+                                "void f() {\n"
+                                "    std::string str = to_string(1);\n"
+                                "}\n";
+            const char expected[] = "void f ( ) { std :: string str ; str = std :: to_string ( 1 ) ; }";
+            ASSERT_EQUALS(expected, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            const char code[] = "using std::cout, std::endl, std::cerr, std::ostringstream;\n"
+                                "cerr << \"abc\";\n";
+            const char expected[] = "std :: cerr << \"abc\" ;";
+            ASSERT_EQUALS(expected, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            const char code[] = "using std::string_view_literals::operator\"\"sv;\n";
+            const char expected[] = "using std :: string_view_literals :: operator\"\"sv ;";
+            ASSERT_EQUALS(expected, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            const char code[] = "template <typename T>\n"
+                                "class vector : public ::std::vector<T> {\n"
+                                "public:\n"
+                                "    using ::std::vector<T>::vector;\n"
+                                "    vector() {}\n"
+                                "};\n"
+                                "vector <int> v;\n";
+            const char expected[] = "class vector<int> ; "
+                                    "vector<int> v ; "
+                                    "class vector<int> : public :: std :: vector<int> { "
+                                    "public: "
+                                    "using vector<int> = :: std :: vector<int> :: vector<int> ; "
+                                    "vector<int> ( ) { } "
+                                    "} ;";
+            ASSERT_EQUALS(expected, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            const char code[] = "using namespace ::std;\n"
+                                "void f(const char* c) {\n"
+                                "    cout << std::string(c) << \"abc\";\n"
+                                "}\n";
+            const char expected[] = "using namespace :: std ; " // TODO: simplify cout?
+                                    "void f ( const char * c ) { "
+                                    "cout << std :: string ( c ) << \"abc\" ; "
+                                    "}";
+            ASSERT_EQUALS(expected, tok(code));
+            ASSERT_EQUALS(
+                "[test.cpp:3:5]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable cout [valueFlowBailoutIncompleteVar]\n",
+                errout_str());
+        }
+        {
+            const char code[] = "class T : private std::vector<std::pair<std::string, const int*>> {\n" // #12521
+                                "    using std::vector<std::pair<std::string, const int*>>::empty;\n"
+                                "};\n";
+            const char expected[] = "class T : private std :: vector < std :: pair < std :: string , const int * > > { "
+                                    "using empty = std :: vector < std :: pair < std :: string , const int * > > :: empty ; "
+                                    "} ;";
+            ASSERT_EQUALS(expected, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+    }
+
+    void simplifyUsing31() { // #11899
+        const char code[] = "struct B {\n"
+                            "    B();\n"
+                            "    void f();\n"
+                            "};\n"
+                            "struct D : B {\n"
+                            "    using B::B;\n"
+                            "    void g() {\n"
+                            "        B::f();\n"
+                            "    }\n"
+                            "    B b;\n"
+                            "};\n";
+        const char expected[] = "struct B { "
+                                "B ( ) ; "
+                                "void f ( ) ; "
+                                "} ; "
+                                "struct D : B { "
+                                "using B = B :: B ; "
+                                "void g ( ) { "
+                                "B :: f ( ) ; "
+                                "} "
+                                "B b ; "
+                                "} ;";
+        ASSERT_EQUALS(expected, tok(code));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void simplifyUsing32() {
+        const char code[] = "using T = int*;\n" // #11430
+                            "T f() { return T{}; }\n"
+                            "T g() { return T(malloc(4)); }\n";
+        const char expected[] = "int * f ( ) { return ( int * ) 0 ; } "
+                                "int * g ( ) { return ( int * ) ( malloc ( 4 ) ) ; }";
+        ASSERT_EQUALS(expected, tok(code));
+        ASSERT_EQUALS("", errout_str());
+
+        const char code2[] = "struct S {\n" // #13095
+                             "    using reference_type = int&;\n"
+                             "    reference_type get();\n"
+                             "    int i;\n"
+                             "};\n"
+                             "auto S::get() -> reference_type {\n"
+                             "    return i;\n"
+                             "}\n";
+        const char expected2[] = "struct S { "
+                                 "int & get ( ) ; "
+                                 "int i ; "
+                                 "} ; "
+                                 "auto S :: get ( ) . int & { return i ; }";
+        ASSERT_EQUALS(expected2, tok(code2));
+        TODO_ASSERT_EQUALS("",
+                           "[test.cpp:6:1]: (debug) auto token with no type. [autoNoType]\n"
+                           "", errout_str());
+
+        const char code3[] = "using V = int*;\n"
+                             "auto g() -> const volatile V { return {}; }\n";
+        const char expected3[] = "auto g ( ) . const volatile int * { return { } ; }";
+        ASSERT_EQUALS(expected3, tok(code3));
+        TODO_ASSERT_EQUALS("",
+                           "[test.cpp:2:1]: (debug) auto token with no type. [autoNoType]\n"
+                           "", errout_str());
+    }
+
+    void simplifyUsing33() { // #13090
+        const char code[] = "namespace N {\n"
+                            "    using T = int;\n"
+                            "    T f() { return (T)0; }\n"
+                            "}\n"
+                            "struct S {\n"
+                            "    using U = int;\n"
+                            "    U g() { return (U)0; }\n"
+                            "};\n";
+        const char expected[] = "namespace N { "
+                                "int f ( ) { return ( int ) 0 ; } "
+                                "} "
+                                "struct S { "
+                                "int g ( ) { return ( int ) 0 ; } "
+                                "} ;";
+        ASSERT_EQUALS(expected, tok(code));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void simplifyUsing34() { // #13295
+        const char code[] = "struct A {\n"
+                            "    static const int a = 1;\n"
+                            "};\n"
+                            "using B = struct A;\n"
+                            "void g(int);\n"
+                            "void f() {\n"
+                            "    g({ B::a });\n"
+                            "}\n";
+        const char expected[] = "struct A { "
+                                "static const int a = 1 ; "
+                                "} ; "
+                                "void g ( int ) ; "
+                                "void f ( ) { "
+                                "g ( { A :: a } ) ; "
+                                "}";
+        ASSERT_EQUALS(expected, tok(code));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void simplifyUsing35() { // #13492
+        const char code[] = "using a = b;\n"
+                            "using c = d;\n";
+        const char expected[] = ";";
+        ASSERT_EQUALS(expected, tok(code));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void simplifyUsing36() {
+        const char code[] = "using A::a;\n"
+                            "int c = B<int>::a;\n";
+        const char expected[] = "int c ; c = B < int > :: a ;";
+        ASSERT_EQUALS(expected, tok(code));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void simplifyUsing37() {
+        const char code1[] = "using fp1_t = int(*)(int);\n"
+                             "using fp2_t = int(* const)(int);\n"
+                             "fp1_t fp1;\n"
+                             "fp2_t fp2;\n";
+        const char expected1[] = "int ( * fp1 ) ( int ) ; int ( * const fp2 ) ( int ) ;";
+        ASSERT_EQUALS(expected1, tok(code1));
+        ASSERT_EQUALS("", errout_str());
+
+        const char code2[] = "using f_t = int(int);\n"
+                             "f_t* fp1;\n"
+                             "f_t* const fp2;\n";
+        const char expected2[] = "int ( * fp1 ) ( int ) ; int ( * const fp2 ) ( int ) ;";
+        ASSERT_EQUALS(expected2, tok(code2));
+        ASSERT_EQUALS("", errout_str());
+
+        const char code3[] = "using FP = std::string (*)();\n" // #14421
+                             "using FPC = std::string (*const)();\n"
+                             "FP fp;\n"
+                             "FPC fpc{};\n";
+        const char expected3[] = "std :: string ( * fp ) ( ) ; std :: string ( * const fpc ) ( ) { } ;";
+        ASSERT_EQUALS(expected3, tok(code3));
+        ASSERT_EQUALS("", errout_str());
+
+        const char code4[] = "using F = void(*)(char);\n" // #14429
+                             "F f(int);\n";
+        const char expected4[] = "void * f ( char ) ;";
+        ASSERT_EQUALS(expected4, tok(code4));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void simplifyUsing38() {
+        const char code[] = "using std::begin;\n" // #14424
+                            "using std::end;\n"
+                            "Unknown begin;\n"
+                            "int end;\n";
+        const char expected[] = "Unknown begin ; int end ;";
+        ASSERT_EQUALS(expected, tok(code));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void simplifyUsing39() {
+        const char code[] = "using std::wstring;\n" // #14578
+                            "wstring ws;";
+        const char expected[] = "std :: wstring ws ;";
+        ASSERT_EQUALS(expected, tok(code));
+        ASSERT_EQUALS("", errout_str());
+        ASSERT_EQUALS(expected, tok(code, dinit(TokOptions, $.cppstd = Standards::CPP03)));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyUsing8970() {
@@ -430,7 +949,7 @@ class TestSimplifyUsing : public TestFixture {
                                 "std :: vector < int > p ; "
                                 "} ;";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code));
     }
 
     void simplifyUsing8971() {
@@ -454,7 +973,7 @@ class TestSimplifyUsing : public TestFixture {
                                 "std :: vector < int > v2_ ; "
                                 "} ;";
 
-        ASSERT_EQUALS(expected, tok(code, false));
+        ASSERT_EQUALS(expected, tok(code));
     }
 
     void simplifyUsing8976() {
@@ -470,11 +989,11 @@ class TestSimplifyUsing : public TestFixture {
 
         const char exp[] = "int i ;";
 
-        ASSERT_EQUALS(exp, tok(code, true, Settings::Unix32));
-        ASSERT_EQUALS(exp, tok(code, true, Settings::Unix64));
-        ASSERT_EQUALS(exp, tok(code, true, Settings::Win32A));
-        ASSERT_EQUALS(exp, tok(code, true, Settings::Win32W));
-        ASSERT_EQUALS(exp, tok(code, true, Settings::Win64));
+        ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.type = Platform::Unix32)));
+        ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.type = Platform::Unix64)));
+        ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.type = Platform::Win32A)));
+        ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.type = Platform::Win32W)));
+        ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.type = Platform::Win64)));
     }
 
     void simplifyUsing9042() {
@@ -491,9 +1010,10 @@ class TestSimplifyUsing : public TestFixture {
                            "class c { "
                            "int i ; i = 0 ; "
                            "c ( ) { i -- ; } "
-                           "} ;";
+                           "} ; "
+                           "template < class T > class s { } ;";
 
-        ASSERT_EQUALS(exp, tok(code, true, Settings::Win64));
+        ASSERT_EQUALS(exp, tok(code, dinit(TokOptions, $.type = Platform::Win64)));
     }
 
     void simplifyUsing9191() {
@@ -511,9 +1031,7 @@ class TestSimplifyUsing : public TestFixture {
                             "  _LONG A;\n"
                             "}";
 
-        const char exp[] = "namespace NS1 { "
-                           "} "
-                           "void f1 ( ) { "
+        const char exp[] = "void f1 ( ) { "
                            "using namespace NS1 ; "
                            "signed long long A ; "
                            "} "
@@ -522,7 +1040,8 @@ class TestSimplifyUsing : public TestFixture {
                            "signed long long A ; "
                            "}";
 
-        ASSERT_EQUALS(exp, tok(code, false));
+        ASSERT_EQUALS(exp, tok(code));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyUsing9381() {
@@ -546,9 +1065,630 @@ class TestSimplifyUsing : public TestFixture {
                            "} "
                            "}";
 
-        ASSERT_EQUALS(exp, tok(code, false));
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void simplifyUsing9385() {
+        {
+            const char code[] = "class A {\n"
+                                "public:\n"
+                                "    using Foo = int;\n"
+                                "    A(Foo foo);\n"
+                                "    ~A();\n"
+                                "    void func(Foo foo);\n"
+                                "};\n"
+                                "A::A(Foo) { }\n"
+                                "A::~A() { Foo foo; }\n"
+                                "void A::func(Foo) { }";
+            const char exp[] = "class A { "
+                               "public: "
+                               "A ( int foo ) ; "
+                               "~ A ( ) ; "
+                               "void func ( int foo ) ; "
+                               "} ; "
+                               "A :: A ( int ) { } "
+                               "A :: ~ A ( ) { int foo ; } "
+                               "void A :: func ( int ) { }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+        {
+            const char code[] = "class A {\n"
+                                "public:\n"
+                                "    struct B {\n"
+                                "        using Foo = int;\n"
+                                "        B(Foo foo);\n"
+                                "        ~B();\n"
+                                "        void func(Foo foo);\n"
+                                "    };\n"
+                                "};\n"
+                                "A::B::B(Foo) { }\n"
+                                "A::B::~B() { Foo foo; }\n"
+                                "void A::B::func(Foo) { }";
+            const char exp[] = "class A { "
+                               "public: "
+                               "struct B { "
+                               "B ( int foo ) ; "
+                               "~ B ( ) ; "
+                               "void func ( int foo ) ; "
+                               "} ; "
+                               "} ; "
+                               "A :: B :: B ( int ) { } "
+                               "A :: B :: ~ B ( ) { int foo ; } "
+                               "void A :: B :: func ( int ) { }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+    }
+
+    void simplifyUsing9388() {
+        const char code[] = "class A {\n"
+                            "public:\n"
+                            "    using Type = int;\n"
+                            "    A(Type&);\n"
+                            "    Type& t_;\n"
+                            "};\n"
+                            "A::A(Type& t) : t_(t) { }";
+        const char exp[] = "class A { "
+                           "public: "
+                           "A ( int & ) ; "
+                           "int & t_ ; "
+                           "} ; "
+                           "A :: A ( int & t ) : t_ ( t ) { }";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void simplifyUsing9518() {
+        const char code[] = "namespace a {\n"
+                            "using a = enum {};\n"
+                            "}";
+        const char exp[] = "namespace a { "
+                           "enum a { } ; "
+                           "}";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void simplifyUsing9757() {
+        const char code[] = "enum class Type_t { Nil = 0 };\n"
+                            "template<Type_t type> class MappedType { };\n"
+                            "template<> class MappedType<Type_t::Nil> { using type = void; };\n"
+                            "std::string to_string (Example::Type_t type) {\n"
+                            "   switch (type) {}\n"
+                            "}";
+        const char exp[] = "enum class Type_t { Nil = 0 } ; "
+                           "class MappedType<Type_t::Nil> ; "
+                           "template < Type_t type > class MappedType { } ; "
+                           "class MappedType<Type_t::Nil> { } ; "
+                           "std :: string to_string ( Example :: Type_t type ) { "
+                           "switch ( type ) { } }";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void simplifyUsing10008() {
+        const char code[] = "namespace ns {\n"
+                            "    using ArrayType = std::vector<int>;\n"
+                            "}\n"
+                            "using namespace ns;\n"
+                            "static void f() {\n"
+                            "    const ArrayType arr;\n"
+                            "}";
+        const char exp[] = "using namespace ns ; "
+                           "static void f ( ) { "
+                           "const std :: vector < int > arr ; "
+                           "}";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void simplifyUsing10054() { // debug: Executable scope 'x' with unknown function.
+        {
+            // original example: using "namespace external::ns1;" but redundant qualification
+            const char code[] = "namespace external {\n"
+                                "    namespace ns1 {\n"
+                                "        template <int size> struct B { };\n"
+                                "        using V = B<sizeof(bool)>;\n"
+                                "    }\n"
+                                "}\n"
+                                "namespace ns {\n"
+                                "    struct A {\n"
+                                "        void f(external::ns1::V);\n"
+                                "    };\n"
+                                "}\n"
+                                "using namespace external::ns1;\n"
+                                "namespace ns {\n"
+                                "    void A::f(external::ns1::V) {}\n"
+                                "}";
+            const char exp[]  = "namespace external { "
+                                "namespace ns1 { "
+                                "struct B<1> ; "
+                                "} "
+                                "} "
+                                "namespace ns { "
+                                "struct A { "
+                                "void f ( external :: ns1 :: B<1> ) ; "
+                                "} ; "
+                                "} "
+                                "using namespace external :: ns1 ; "
+                                "namespace ns { "
+                                "void A :: f ( external :: ns1 :: B<1> ) { } "
+                                "} "
+                                "struct external :: ns1 :: B<1> { } ;";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            // no using "namespace external::ns1;"
+            const char code[] = "namespace external {\n"
+                                "    namespace ns1 {\n"
+                                "        template <int size> struct B { };\n"
+                                "        using V = B<sizeof(bool)>;\n"
+                                "    }\n"
+                                "}\n"
+                                "namespace ns {\n"
+                                "    struct A {\n"
+                                "        void f(external::ns1::V);\n"
+                                "    };\n"
+                                "}\n"
+                                "namespace ns {\n"
+                                "    void A::f(external::ns1::V) {}\n"
+                                "}";
+            const char exp[]  = "namespace external { "
+                                "namespace ns1 { "
+                                "struct B<1> ; "
+                                "} "
+                                "} "
+                                "namespace ns { "
+                                "struct A { "
+                                "void f ( external :: ns1 :: B<1> ) ; "
+                                "} ; "
+                                "} "
+                                "namespace ns { "
+                                "void A :: f ( external :: ns1 :: B<1> ) { } "
+                                "} "
+                                "struct external :: ns1 :: B<1> { } ;";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            // using "namespace external::ns1;" without redundant qualification
+            const char code[] = "namespace external {\n"
+                                "    namespace ns1 {\n"
+                                "        template <int size> struct B { };\n"
+                                "        using V = B<sizeof(bool)>;\n"
+                                "    }\n"
+                                "}\n"
+                                "namespace ns {\n"
+                                "    struct A {\n"
+                                "        void f(external::ns1::V);\n"
+                                "    };\n"
+                                "}\n"
+                                "using namespace external::ns1;\n"
+                                "namespace ns {\n"
+                                "    void A::f(V) {}\n"
+                                "}";
+            const char exp[]  = "namespace external { "
+                                "namespace ns1 { "
+                                "struct B<1> ; "
+                                "} "
+                                "} "
+                                "namespace ns { "
+                                "struct A { "
+                                "void f ( external :: ns1 :: B<1> ) ; "
+                                "} ; "
+                                "} "
+                                "using namespace external :: ns1 ; "
+                                "namespace ns { "
+                                "void A :: f ( external :: ns1 :: B<1> ) { } "
+                                "} "
+                                "struct external :: ns1 :: B<1> { } ;";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            // using "namespace external::ns1;" without redundant qualification on declaration and definition
+            const char code[] = "namespace external {\n"
+                                "    namespace ns1 {\n"
+                                "        template <int size> struct B { };\n"
+                                "        using V = B<sizeof(bool)>;\n"
+                                "    }\n"
+                                "}\n"
+                                "using namespace external::ns1;\n"
+                                "namespace ns {\n"
+                                "    struct A {\n"
+                                "        void f(V);\n"
+                                "    };\n"
+                                "}\n"
+                                "namespace ns {\n"
+                                "    void A::f(V) {}\n"
+                                "}";
+            const char exp[]  = "namespace external { "
+                                "namespace ns1 { "
+                                "struct B<1> ; "
+                                "} "
+                                "} "
+                                "using namespace external :: ns1 ; "
+                                "namespace ns { "
+                                "struct A { "
+                                "void f ( external :: ns1 :: B<1> ) ; "
+                                "} ; "
+                                "} "
+                                "namespace ns { "
+                                "void A :: f ( external :: ns1 :: B<1> ) { } "
+                                "} "
+                                "struct external :: ns1 :: B<1> { } ;";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            const char code[] = "namespace external {\n"
+                                "    template <int size> struct B { };\n"
+                                "    namespace ns1 {\n"
+                                "        using V = B<sizeof(bool)>;\n"
+                                "    }\n"
+                                "}\n"
+                                "namespace ns {\n"
+                                "    struct A {\n"
+                                "        void f(external::ns1::V);\n"
+                                "    };\n"
+                                "}\n"
+                                "namespace ns {\n"
+                                "    void A::f(external::ns1::V) {}\n"
+                                "}";
+            const char exp[]  = "namespace external { "
+                                "struct B<1> ; "
+                                "} "
+                                "namespace ns { "
+                                "struct A { "
+                                "void f ( external :: B<1> ) ; "
+                                "} ; "
+                                "} "
+                                "namespace ns { "
+                                "void A :: f ( external :: B<1> ) { } "
+                                "} "
+                                "struct external :: B<1> { } ;";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            const char code[] = "template <int size> struct B { };\n"
+                                "namespace external {\n"
+                                "    namespace ns1 {\n"
+                                "        using V = B<sizeof(bool)>;\n"
+                                "    }\n"
+                                "}\n"
+                                "namespace ns {\n"
+                                "    struct A {\n"
+                                "        void f(external::ns1::V);\n"
+                                "    };\n"
+                                "}\n"
+                                "namespace ns {\n"
+                                "    void A::f(external::ns1::V) {}\n"
+                                "}";
+            const char exp[]  = "struct B<1> ; "
+                                "namespace ns { "
+                                "struct A { "
+                                "void f ( B<1> ) ; "
+                                "} ; "
+                                "} "
+                                "namespace ns { "
+                                "void A :: f ( B<1> ) { } "
+                                "} "
+                                "struct B<1> { } ;";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+    }
+
+    void simplifyUsing10136() {
+        {
+            const char code[] = "class B {\n"
+                                "public:\n"
+                                "    using V = std::vector<char>;\n"
+                                "    virtual void f(const V&) const = 0;\n"
+                                "};\n"
+                                "class A final : public B {\n"
+                                "public:\n"
+                                "    void f(const V&) const override;\n"
+                                "};\n"
+                                "void A::f(const std::vector<char>&) const { }";
+            const char exp[]  = "class B { "
+                                "public: "
+                                "virtual void f ( const std :: vector < char > & ) const = 0 ; "
+                                "} ; "
+                                "class A : public B { "
+                                "public: "
+                                "void f ( const std :: vector < char > & ) const override ; "
+                                "} ; "
+                                "void A :: f ( const std :: vector < char > & ) const { }";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            const char code[] = "namespace NS1 {\n"
+                                "    class B {\n"
+                                "    public:\n"
+                                "        using V = std::vector<char>;\n"
+                                "        virtual void f(const V&) const = 0;\n"
+                                "    };\n"
+                                "}\n"
+                                "namespace NS2 {\n"
+                                "    class A : public NS1::B {\n"
+                                "    public:\n"
+                                "        void f(const V&) const override;\n"
+                                "    };\n"
+                                "    namespace NS3 {\n"
+                                "        class C : public A {\n"
+                                "        public:\n"
+                                "            void f(const V&) const override;\n"
+                                "        };\n"
+                                "        void C::f(const V&) const { }\n"
+                                "    }\n"
+                                "    void A::f(const V&) const { }\n"
+                                "}\n"
+                                "void foo() {\n"
+                                "    NS2::A a;\n"
+                                "    NS2::NS3::C c;\n"
+                                "    NS1::B::V v;\n"
+                                "    a.f(v);\n"
+                                "    c.f(v);\n"
+                                "}";
+            const char exp[]  = "namespace NS1 { "
+                                "class B { "
+                                "public: "
+                                "virtual void f ( const std :: vector < char > & ) const = 0 ; "
+                                "} ; "
+                                "} "
+                                "namespace NS2 { "
+                                "class A : public NS1 :: B { "
+                                "public: "
+                                "void f ( const std :: vector < char > & ) const override ; "
+                                "} ; "
+                                "namespace NS3 { "
+                                "class C : public A { "
+                                "public: "
+                                "void f ( const std :: vector < char > & ) const override ; "
+                                "} ; "
+                                "void C :: f ( const std :: vector < char > & ) const { } "
+                                "} "
+                                "void A :: f ( const std :: vector < char > & ) const { } "
+                                "} "
+                                "void foo ( ) { "
+                                "NS2 :: A a ; "
+                                "NS2 :: NS3 :: C c ; "
+                                "std :: vector < char > v ; "
+                                "a . f ( v ) ; "
+                                "c . f ( v ) ; "
+                                "}";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            const char code[] = "foo::ResultCodes_e\n"
+                                "GemImpl::setR(const ::foo::s _ipSource)\n"
+                                "{\n"
+                                "   M3_LOG_EE_DEBUG();\n"
+                                "   using MLSource = foo::s::Literal;\n"
+                                "   auto ret = foo::ResultCodes_e::NO_ERROR;\n"
+                                "   M3_LOG_INFO(\"foo(\" << static_cast<int>(_ipSource) << \")\");\n"
+                                "   return ret;\n"
+                                "}\n"
+                                "foo::ResultCodes_e\n"
+                                "GemImpl::getF(::foo::s &_ipSource)\n"
+                                "{\n"
+                                "   M3_LOG_EE_DEBUG();\n"
+                                "   auto ret = foo::ResultCodes_e::NO_ERROR;\n"
+                                "   return ret;\n"
+                                "}\n"
+                                "foo::ResultCodes_e\n"
+                                "GemImpl::setF(const ::foo::s _ipSource)\n"
+                                "{\n"
+                                "   M3_LOG_EE_DEBUG();\n"
+                                "   using MLSource = foo::s::Literal;\n"
+                                "   auto ret = foo::ResultCodes_e::NO_ERROR;\n"
+                                "   return ret;\n"
+                                "}";
+            (void)tok(code); // don't crash
+            ignore_errout(); // we do not care about the output
+        }
+    }
+
+    void simplifyUsing10171() {
+        const char code[] = "namespace ns {\n"
+                            "    class A {\n"
+                            "    public:\n"
+                            "        using V = std::vector<unsigned char>;\n"
+                            "        virtual void f(const V&) const = 0;\n"
+                            "    };\n"
+                            "    class B : public A {\n"
+                            "    public:\n"
+                            "        void f(const V&) const override;\n"
+                            "    };\n"
+                            "}\n"
+                            "namespace ns {\n"
+                            "    void B::f(const std::vector<unsigned char>&) const { }\n"
+                            "}";
+        const char exp[] = "namespace ns { "
+                           "class A { "
+                           "public: "
+                           "virtual void f ( const std :: vector < unsigned char > & ) const = 0 ; "
+                           "} ; "
+                           "class B : public A { "
+                           "public: "
+                           "void f ( const std :: vector < unsigned char > & ) const override ; "
+                           "} ; "
+                           "} "
+                           "namespace ns { "
+                           "void B :: f ( const std :: vector < unsigned char > & ) const { } "
+                           "}";
+        ASSERT_EQUALS(exp, tok(code));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void simplifyUsing10172() {
+        {
+            const char code[] = "namespace ns {\n"
+                                "    class A {\n"
+                                "    public:\n"
+                                "        using h = std::function<void()>;\n"
+                                "    };\n"
+                                "    class B : public A {\n"
+                                "        void f(h);\n"
+                                "    };\n"
+                                "}\n"
+                                "namespace ns {\n"
+                                "    void B::f(h) { }\n"
+                                "}";
+            const char exp[] = "namespace ns { "
+                               "class A { "
+                               "public: "
+                               "} ; "
+                               "class B : public A { "
+                               "void f ( std :: function < void ( ) > ) ; "
+                               "} ; "
+                               "} "
+                               "namespace ns { "
+                               "void B :: f ( std :: function < void ( ) > ) { } "
+                               "}";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            const char code[] = "namespace ns {\n"
+                                "namespace external {\n"
+                                "class A {\n"
+                                "public: \n"
+                                "  using h = std::function<void()>;\n"
+                                "};\n"
+                                "class B : public A {\n"
+                                "  void f(h);\n"
+                                "};\n"
+                                "}\n"
+                                "}\n"
+                                "namespace ns {\n"
+                                "namespace external {\n"
+                                "void B::f(h) {}\n"
+                                "}\n"
+                                "}";
+            const char exp[] = "namespace ns { "
+                               "namespace external { "
+                               "class A { "
+                               "public: "
+                               "} ; "
+                               "class B : public A { "
+                               "void f ( std :: function < void ( ) > ) ; "
+                               "} ; "
+                               "} "
+                               "} "
+                               "namespace ns { "
+                               "namespace external { "
+                               "void B :: f ( std :: function < void ( ) > ) { } "
+                               "} "
+                               "}";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
     }
 
+    void simplifyUsing10173() {
+        {
+            const char code[] = "std::ostream & operator<<(std::ostream &s, const Pr<st> p) {\n"
+                                "    return s;\n"
+                                "}\n"
+                                "void foo() {\n"
+                                "    using Pr = d::Pr<st>;\n"
+                                "    Pr p;\n"
+                                "}\n"
+                                "void bar() {\n"
+                                "   Pr<st> p;\n"
+                                "}";
+            const char exp[]  = "std :: ostream & operator<< ( std :: ostream & s , const Pr < st > p ) { "
+                                "return s ; "
+                                "} "
+                                "void foo ( ) { "
+                                "d :: Pr < st > p ; "
+                                "} "
+                                "void bar ( ) { "
+                                "Pr < st > p ; "
+                                "}";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            const char code[] = "namespace defsa {\n"
+                                "void xxx::foo() {\n"
+                                "   using NS1 = v1::l;\n"
+                                "}\n"
+                                "void xxx::bar() {\n"
+                                "   using NS1 = v1::l;\n"
+                                "}\n"
+                                "void xxx::foobar() {\n"
+                                "   using NS1 = v1::l;\n"
+                                "}\n"
+                                "}";
+            const char exp[]  = "namespace defsa { "
+                                "void xxx :: foo ( ) { "
+                                "} "
+                                "void xxx :: bar ( ) { "
+                                "} "
+                                "void xxx :: foobar ( ) { "
+                                "} "
+                                "}";
+            ASSERT_EQUALS(exp, tok(code));
+            ignore_errout(); // we do not care about the output
+        }
+    }
+
+    void simplifyUsing10335() {
+        const char code[] = "using uint8_t = unsigned char;\n"
+                            "enum E : uint8_t { E0 };";
+        const char exp[]  = "enum E : unsigned char { E0 } ;";
+        ASSERT_EQUALS(exp, tok(code));
+    }
+
+    void simplifyUsing10720() { // hang/segmentation fault
+        const char code[] = "template <typename... Ts>\n"
+                            "struct S {};\n"
+                            "#define STAMP(thiz, prev) using thiz = S<prev, prev, prev, prev, prev, prev, prev, prev, prev, prev>;\n"
+                            "STAMP(A, int);\n"
+                            "STAMP(B, A);\n"
+                            "STAMP(C, B);\n";
+        (void)tok(code, dinit(TokOptions, $.preprocess = true));
+        TODO_ASSERT(startsWith(errout_str(), "[test.cpp:6]: (debug) Failed to parse 'using C = S < S < S < int"));
+    }
+
+    void simplifyUsing13873() { // function declaration
+        const char code1[] = "using NS1::f;\n"
+                             "namespace NS1 { void f(); }\n";
+        ASSERT_EQUALS("namespace NS1 { void f ( ) ; }", tok(code1));
+
+        const char code2[] = "using NS1::f;\n"
+                             "void bar() { f(); }\n";
+        ASSERT_EQUALS("void bar ( ) { NS1 :: f ( ) ; }", tok(code2));
+
+        const char code3[] = "using NS1::f;\n"
+                             "namespace NS1 { void* f(); }\n";
+        ASSERT_EQUALS("namespace NS1 { void * f ( ) ; }", tok(code3));
+    }
+
+    void scopeInfo1() {
+        const char code[] = "struct A {\n"
+                            "    enum class Mode { UNKNOWN, ENABLED, NONE, };\n"
+                            "};\n"
+                            "\n"
+                            "namespace spdlog { class logger; }\n"
+                            "using LoggerPtr = std::shared_ptr<spdlog::logger>;";
+        (void)tok(code);
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void scopeInfo2() {
+        const char code[] = "struct A {\n"
+                            "    using Map = std::map<int, int>;\n"
+                            "    Map values;\n"
+                            "};\n"
+                            "\n"
+                            "static void getInitialProgramState(const A::Map& vars = A::Map {})\n"
+                            "{}\n";
+        (void)tok(code);
+        ASSERT_EQUALS("", errout_str());
+    }
 };
 
 REGISTER_TEST(TestSimplifyUsing)
diff --git a/test/testsingleexecutor.cpp b/test/testsingleexecutor.cpp
new file mode 100644
index 00000000000..3fb4c778043
--- /dev/null
+++ b/test/testsingleexecutor.cpp
@@ -0,0 +1,342 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "cppcheck.h"
+#include "filesettings.h"
+#include "fixture.h"
+#include "helpers.h"
+#include "redirect.h"
+#include "settings.h"
+#include "singleexecutor.h"
+#include "standards.h"
+#include "suppressions.h"
+#include "timer.h"
+
+#include <cstdlib>
+#include <list>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+class TestSingleExecutorBase : public TestFixture {
+protected:
+    TestSingleExecutorBase(const char * const name, bool useFS) : TestFixture(name), useFS(useFS) {}
+
+private:
+    /*const*/ Settings settings = settingsBuilder().library("std.cfg").build();
+    bool useFS;
+
+    std::string fprefix() const
+    {
+        if (useFS)
+            return "singlefs";
+        return "single";
+    }
+
+    static std::string zpad3(int i)
+    {
+        if (i < 10)
+            return "00" + std::to_string(i);
+        if (i < 100)
+            return "0" + std::to_string(i);
+        return std::to_string(i);
+    }
+
+    struct CheckOptions
+    {
+        bool quiet = true;
+        ShowTime showtime = ShowTime::NONE;
+        const char* plistOutput = nullptr;
+        std::vector<std::string> filesList;
+    };
+
+    void check(int files, int result, const std::string &data, const CheckOptions& opt = make_default_obj{}) {
+        std::list<FileSettings> fileSettings;
+
+        std::list<FileWithDetails> filelist;
+        if (opt.filesList.empty()) {
+            for (int i = 1; i <= files; ++i) {
+                std::string f_s = fprefix() + "_" + zpad3(i) + ".c";
+                filelist.emplace_back(f_s, Standards::Language::C, data.size());
+                if (useFS) {
+                    fileSettings.emplace_back(std::move(f_s), Standards::Language::C, data.size());
+                }
+            }
+        }
+        else {
+            for (const auto& f : opt.filesList)
+            {
+                filelist.emplace_back(f, Standards::Language::C, data.size());
+                if (useFS) {
+                    fileSettings.emplace_back(f, Standards::Language::C, data.size());
+                }
+            }
+        }
+
+        /*const*/ Settings s = settings;
+        s.showtime = opt.showtime;
+        s.quiet = opt.quiet;
+        if (opt.plistOutput)
+            s.plistOutput = opt.plistOutput;
+        s.templateFormat = "{callstack}: ({severity}) {inconclusive:inconclusive: }{message}"; // TODO: remove when we only longer rely on toString() in unique message handling?
+
+        Suppressions supprs;
+        TimerResults timerResults;
+
+        // NOLINTNEXTLINE(performance-unnecessary-value-param)
+        CppCheck cppcheck(s, supprs, *this, &timerResults, true, [](std::string,std::vector<std::string>,std::string,std::string&){
+            return EXIT_SUCCESS;
+        });
+
+        std::vector<std::unique_ptr<ScopedFile>> scopedfiles;
+        scopedfiles.reserve(filelist.size());
+        for (auto i = filelist.cbegin(); i != filelist.cend(); ++i)
+            scopedfiles.emplace_back(new ScopedFile(i->path(), data));
+
+        // clear files list so only fileSettings are used
+        if (useFS)
+            filelist.clear();
+
+        SingleExecutor executor(cppcheck, filelist, fileSettings, s, supprs, *this, &timerResults);
+        ASSERT_EQUALS(result, executor.check());
+    }
+
+    void run() override {
+        mNewTemplate = true;
+        TEST_CASE(many_files);
+        TEST_CASE(many_files_showtime);
+        TEST_CASE(many_files_plist);
+        TEST_CASE(no_errors_more_files);
+        TEST_CASE(no_errors_less_files);
+        TEST_CASE(no_errors_equal_amount_files);
+        TEST_CASE(one_error_less_files);
+        TEST_CASE(one_error_several_files);
+        TEST_CASE(showtime_top5_file);
+        TEST_CASE(showtime_top5_summary);
+        TEST_CASE(showtime_file);
+        TEST_CASE(showtime_summary);
+        TEST_CASE(showtime_file_total);
+        TEST_CASE(suppress_error_library);
+        TEST_CASE(unique_errors);
+    }
+
+    void many_files() {
+        const int num_files = 100;
+        check(num_files, num_files,
+              "void f()\n"
+              "{\n"
+              "  (void)(*((int*)0));\n"
+              "}", dinit(CheckOptions,
+                         $.quiet = false));
+        {
+            std::string expected;
+            for (int i = 1; i <= num_files; ++i) {
+                expected += "Checking " + fprefix() + "_" + zpad3(i) + ".c ...\n";
+                expected += std::to_string(i) + "/100 files checked " + std::to_string(i) + "% done\n";
+            }
+            ASSERT_EQUALS(expected, output_str());
+        }
+        {
+            std::string expected;
+            for (int i = 1; i <= num_files; ++i) {
+                expected += "[" + fprefix() + "_" + zpad3(i) + ".c:3:12]: (error) Null pointer dereference: (int*)0 [nullPointer]\n";
+            }
+            ASSERT_EQUALS(expected, errout_str());
+        }
+    }
+
+    void many_files_showtime() {
+        SUPPRESS;
+        check(100, 100,
+              "void f()\n"
+              "{\n"
+              "  (void)(*((int*)0));\n"
+              "}", dinit(CheckOptions, $.showtime = ShowTime::SUMMARY));
+        // we are not interested in the results - so just consume them
+        ignore_errout();
+    }
+
+    void many_files_plist() {
+        const std::string plistOutput = "plist_" + fprefix() + "/";
+        ScopedFile plistFile("dummy", "", plistOutput);
+
+        check(100, 100,
+              "void f()\n"
+              "{\n"
+              "  (void)(*((int*)0));\n"
+              "}", dinit(CheckOptions, $.plistOutput = plistOutput.c_str()));
+        // we are not interested in the results - so just consume them
+        ignore_errout();
+    }
+
+    void no_errors_more_files() {
+        check(3, 0,
+              "int main()\n"
+              "{\n"
+              "  return 0;\n"
+              "}");
+    }
+
+    void no_errors_less_files() {
+        check(1, 0,
+              "int main()\n"
+              "{\n"
+              "  return 0;\n"
+              "}");
+    }
+
+    void no_errors_equal_amount_files() {
+        check(2, 0,
+              "int main()\n"
+              "{\n"
+              "  return 0;\n"
+              "}");
+    }
+
+    void one_error_less_files() {
+        check(1, 1,
+              "void f()\n"
+              "{\n"
+              "  (void)(*((int*)0));\n"
+              "}");
+        ASSERT_EQUALS("[" + fprefix() + "_" + zpad3(1) + ".c:3:12]: (error) Null pointer dereference: (int*)0 [nullPointer]\n", errout_str());
+    }
+
+    void one_error_several_files() {
+        const int num_files = 20;
+        check(num_files, num_files,
+              "void f()\n"
+              "{\n"
+              "  (void)(*((int*)0));\n"
+              "}");
+        {
+            std::string expected;
+            for (int i = 1; i <= num_files; ++i) {
+                expected += "[" + fprefix() + "_" + zpad3(i) + ".c:3:12]: (error) Null pointer dereference: (int*)0 [nullPointer]\n";
+            }
+            ASSERT_EQUALS(expected, errout_str());
+        }
+    }
+
+// TODO: provide data which actually shows values above 0
+
+    void showtime_top5_file() {
+        REDIRECT;
+        check(2, 0,
+              "int main() {}",
+              dinit(CheckOptions,
+                    $.showtime = ShowTime::TOP5_FILE));
+        const std::string output_s = GET_REDIRECT_OUTPUT;
+        // for each file: top5 results + overall + total
+        ASSERT_EQUALS((5 + 1 + 1) * 2LL, cppcheck::count_all_of(output_s, '\n'));
+    }
+
+    void showtime_top5_summary() {
+        REDIRECT;
+        check(2, 0,
+              "int main() {}",
+              dinit(CheckOptions,
+                    $.showtime = ShowTime::TOP5_SUMMARY));
+        const std::string output_s = GET_REDIRECT_OUTPUT;
+        // once: top5 results + newline
+        ASSERT_EQUALS(5 + 1, cppcheck::count_all_of(output_s, '\n'));
+        // should only report the top5 once
+        ASSERT(output_s.find("1 result(s)") == std::string::npos);
+        ASSERT(output_s.find("2 result(s)") != std::string::npos);
+    }
+
+    void showtime_file() {
+        REDIRECT;
+        check(2, 0,
+              "int main() {}",
+              dinit(CheckOptions,
+                    $.showtime = ShowTime::FILE));
+        const std::string output_s = GET_REDIRECT_OUTPUT;
+        ASSERT_EQUALS(0, cppcheck::count_all_of(output_s, "Overall time:"));
+    }
+
+    void showtime_summary() {
+        REDIRECT;
+        check(2, 0,
+              "int main() {}",
+              dinit(CheckOptions,
+                    $.showtime = ShowTime::SUMMARY));
+        const std::string output_s = GET_REDIRECT_OUTPUT;
+        // should only report the actual summary once
+        ASSERT(output_s.find("1 result(s)") == std::string::npos);
+        ASSERT(output_s.find("2 result(s)") != std::string::npos);
+    }
+
+    void showtime_file_total() {
+        REDIRECT;
+        check(2, 0,
+              "int main() {}",
+              dinit(CheckOptions,
+                    $.showtime = ShowTime::FILE_TOTAL));
+        const std::string output_s = GET_REDIRECT_OUTPUT;
+        ASSERT(output_s.find("Check time: " + fprefix() + "_" + zpad3(1) + ".c: ") != std::string::npos);
+        ASSERT(output_s.find("Check time: " + fprefix() + "_" + zpad3(2) + ".c: ") != std::string::npos);
+    }
+
+    void suppress_error_library() {
+        SUPPRESS;
+        const Settings settingsOld = settings; // TODO: get rid of this
+        const char xmldata[] = R"(<def format="2"><markup ext=".c" reporterrors="false"/></def>)";
+        settings = settingsBuilder().libraryxml(xmldata).build();
+        check(1, 0,
+              "void f()\n"
+              "{\n"
+              "  (void)(*((int*)0));\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+        settings = settingsOld;
+    }
+
+    void unique_errors() {
+        SUPPRESS;
+        ScopedFile inc_h(fprefix() + ".h",
+                         "inline void f()\n"
+                         "{\n"
+                         "  (void)(*((int*)0));\n"
+                         "}");
+        check(2, 2,
+              "#include \"" + inc_h.name() + "\"");
+        // these are not actually made unique by the implementation. That needs to be done by the given ErrorLogger
+        ASSERT_EQUALS(
+            "[" + inc_h.name() + ":3:12]: (error) Null pointer dereference: (int*)0 [nullPointer]\n"
+            "[" + inc_h.name() + ":3:12]: (error) Null pointer dereference: (int*)0 [nullPointer]\n",
+            errout_str());
+    }
+
+    // TODO: test whole program analysis
+    // TODO: test unique errors
+};
+
+class TestSingleExecutorFiles : public TestSingleExecutorBase {
+public:
+    TestSingleExecutorFiles() : TestSingleExecutorBase("TestSingleExecutorFiles", false) {}
+};
+
+class TestSingleExecutorFS : public TestSingleExecutorBase {
+public:
+    TestSingleExecutorFS() : TestSingleExecutorBase("TestSingleExecutorFS", true) {}
+};
+
+REGISTER_TEST(TestSingleExecutorFiles)
+REGISTER_TEST(TestSingleExecutorFS)
diff --git a/test/testsizeof.cpp b/test/testsizeof.cpp
index 769a0d50717..ad8aa3192af 100644
--- a/test/testsizeof.cpp
+++ b/test/testsizeof.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,27 +17,23 @@
  */
 
 #include "checksizeof.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
 
-#include <simplecpp.h>
-#include <map>
-#include <vector>
+#include <cstddef>
+#include <string>
 
 class TestSizeof : public TestFixture {
 public:
-    TestSizeof() : TestFixture("TestSizeof") {
-    }
+    TestSizeof() : TestFixture("TestSizeof") {}
 
 private:
-    Settings settings;
-
-    void run() OVERRIDE {
-        settings.addEnabled("warning");
-        settings.addEnabled("portability");
-        settings.inconclusive = true;
+    const Settings settings = settingsBuilder().severity(Severity::warning).severity(Severity::portability).certainty(Certainty::inconclusive).library("std.cfg").build();
 
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(sizeofsizeof);
         TEST_CASE(sizeofCalculation);
         TEST_CASE(sizeofFunction);
@@ -51,42 +47,27 @@ class TestSizeof : public TestFixture {
         TEST_CASE(customStrncat);
     }
 
-    void check(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
-
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check...
-        CheckSizeof checkSizeof(&tokenizer, &settings, this);
-        checkSizeof.runChecks(&tokenizer, &settings, this);
+        runChecks<CheckSizeof>(tokenizer, this);
     }
 
-    void checkP(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
-
-        // Raw tokens..
-        std::vector<std::string> files(1, "test.cpp");
-        std::istringstream istr(code);
-        const simplecpp::TokenList tokens1(istr, files, files[0]);
-
-        // Preprocess..
-        simplecpp::TokenList tokens2(files);
-        std::map<std::string, simplecpp::TokenList*> filedata;
-        simplecpp::preprocess(tokens2, tokens1, files, filedata, simplecpp::DUI());
+#define checkP(...) checkP_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkP_(const char* file, int line, const char (&code)[size]) {
+        SimpleTokenizer2 tokenizer(settings, *this, code, "test.cpp");
 
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        tokenizer.createTokens(&tokens2);
-        tokenizer.simplifyTokens1("");
+        ASSERT_LOC(tokenizer.simplifyTokens1(""), file, line);
 
         // Check...
-        CheckSizeof checkSizeof(&tokenizer, &settings, this);
-        checkSizeof.runChecks(&tokenizer, &settings, this);
+        runChecks<CheckSizeof>(tokenizer, this);
     }
 
     void sizeofsizeof() {
@@ -94,48 +75,48 @@ class TestSizeof : public TestFixture {
               "{\n"
               "    int i = sizeof sizeof char;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Calling 'sizeof' on 'sizeof'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:13]: (warning) Calling 'sizeof' on 'sizeof'. [sizeofsizeof]\n", errout_str());
 
         check("void foo()\n"
               "{\n"
               "    int i = sizeof (sizeof long);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Calling 'sizeof' on 'sizeof'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:13]: (warning) Calling 'sizeof' on 'sizeof'. [sizeofsizeof]\n", errout_str());
 
         check("void foo(long *p)\n"
               "{\n"
               "    int i = sizeof (sizeof (p));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Calling 'sizeof' on 'sizeof'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:13]: (warning) Calling 'sizeof' on 'sizeof'. [sizeofsizeof]\n", errout_str());
     }
 
     void sizeofCalculation() {
         check("int a, b; int a,sizeof(a+b)");
-        ASSERT_EQUALS("[test.cpp:1]: (warning) Found calculation inside sizeof().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:25]: (warning) Found calculation inside sizeof(). [sizeofCalculation]\n", errout_str());
 
         check("int a, b; sizeof(a*b)");
-        ASSERT_EQUALS("[test.cpp:1]: (warning) Found calculation inside sizeof().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:19]: (warning) Found calculation inside sizeof(). [sizeofCalculation]\n", errout_str());
 
         check("int a, b; sizeof(-a)");
-        ASSERT_EQUALS("[test.cpp:1]: (warning) Found calculation inside sizeof().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:18]: (warning) Found calculation inside sizeof(). [sizeofCalculation]\n", errout_str());
 
         check("int a, b; sizeof(*a)");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("sizeof(void * const)");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("sizeof(int*[2])");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("sizeof(Fred**)");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("sizeof(foo++)");
-        ASSERT_EQUALS("[test.cpp:1]: (warning) Found calculation inside sizeof().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:11]: (warning) Found calculation inside sizeof(). [sizeofCalculation]\n", errout_str());
 
         check("sizeof(--foo)");
-        ASSERT_EQUALS("[test.cpp:1]: (warning) Found calculation inside sizeof().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:8]: (warning) Found calculation inside sizeof(). [sizeofCalculation]\n", errout_str());
 
         // #6888
         checkP("#define SIZEOF1   sizeof(i != 2)\n"
@@ -149,7 +130,7 @@ class TestSizeof : public TestFixture {
                "  VOIDCAST2(SIZEOF2);\n"
                "  return i + foo(1);\n"
                "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkP("#define SIZEOF1   sizeof(i != 2)\n"
                "#define SIZEOF2   ((sizeof(i != 2)))\n"
@@ -158,12 +139,12 @@ class TestSizeof : public TestFixture {
                "  SIZEOF2;\n"
                "  return i + foo(1);\n"
                "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning, inconclusive) Found calculation inside sizeof().\n"
-                      "[test.cpp:5]: (warning, inconclusive) Found calculation inside sizeof().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:3]: (warning, inconclusive) Found calculation inside sizeof(). [sizeofCalculation]\n"
+                      "[test.cpp:5:3]: (warning, inconclusive) Found calculation inside sizeof(). [sizeofCalculation]\n", errout_str());
 
         checkP("#define MACRO(data)  f(data, sizeof(data))\n"
                "x = MACRO((unsigned int *)data + 4);");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Found calculation inside sizeof().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning, inconclusive) Found calculation inside sizeof(). [sizeofCalculation]\n", errout_str());
     }
 
     void sizeofFunction() {
@@ -172,7 +153,7 @@ class TestSizeof : public TestFixture {
               "    int bar() { return 1; };\n"
               "}\n"
               "Foo f;int a=sizeof(f.bar());");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Found function call inside sizeof().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:13]: (warning) Found function call inside sizeof(). [sizeofFunctionCall]\n", errout_str());
 
         check("class Foo\n"
               "{\n"
@@ -180,35 +161,35 @@ class TestSizeof : public TestFixture {
               "    int bar() const { return 1; };\n"
               "}\n"
               "Foo f;int a=sizeof(f.bar());");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Foo\n"
               "{\n"
               "    int bar() { return 1; };\n"
               "}\n"
               "Foo * fp;int a=sizeof(fp->bar());");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Found function call inside sizeof().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:16]: (warning) Found function call inside sizeof(). [sizeofFunctionCall]\n", errout_str());
 
         check("int a=sizeof(foo());");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int foo() { return 1; }; int a=sizeof(foo());");
-        ASSERT_EQUALS("[test.cpp:1]: (warning) Found function call inside sizeof().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:32]: (warning) Found function call inside sizeof(). [sizeofFunctionCall]\n", errout_str());
 
         check("int foo() { return 1; }; sizeof(decltype(foo()));");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int foo(int) { return 1; }; int a=sizeof(foo(0))");
-        ASSERT_EQUALS("[test.cpp:1]: (warning) Found function call inside sizeof().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:35]: (warning) Found function call inside sizeof(). [sizeofFunctionCall]\n", errout_str());
 
         check("char * buf; int a=sizeof(*buf);");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int a=sizeof(foo())");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int foo(int) { return 1; }; char buf[1024]; int a=sizeof(buf), foo(0)");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("template<class T>\n"
               "struct A\n"
@@ -223,35 +204,37 @@ class TestSizeof : public TestFixture {
               "        Y = sizeof(f(g() << h())) == sizeof(A),\n"
               "        Z = X & Y\n"
               "    };\n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int g();\n"
+              "size_t f1() { return sizeof(x[0]); }\n"
+              "size_t f2() { return sizeof(g()); }\n");
+        ASSERT_EQUALS("[test.cpp:3:22]: (warning) Found function call inside sizeof(). [sizeofFunctionCall]\n", errout_str());
     }
 
     void sizeofForArrayParameter() {
         check("void f() {\n"
               "    int a[10];\n"
               "    std::cout << sizeof(a) / sizeof(int) << std::endl;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    unsigned int a = 2;\n"
               "    unsigned int b = 2;\n"
               "    int c[(a+b)];\n"
               "    std::cout << sizeof(c) / sizeof(int) << std::endl;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    unsigned int a = { 2 };\n"
               "    unsigned int b[] = { 0 };\n"
               "    int c[a[b[0]]];\n"
               "    std::cout << sizeof(c) / sizeof(int) << std::endl;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
 
         check("void f() {\n"
@@ -259,66 +242,57 @@ class TestSizeof : public TestFixture {
               "    unsigned int b = 2;\n"
               "    int c[(a[0]+b)];\n"
               "    std::cout << sizeof(c) / sizeof(int) << std::endl;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int a[] = { 1, 2, 3 };\n"
               "    std::cout << sizeof(a) / sizeof(int) << std::endl;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int a[3] = { 1, 2, 3 };\n"
               "    std::cout << sizeof(a) / sizeof(int) << std::endl;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f( int a[]) {\n"
               "    std::cout << sizeof(a) / sizeof(int) << std::endl;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Using 'sizeof' on array given as "
-                      "function argument returns size of a pointer.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:18]: (warning) Using 'sizeof' on array given as "
+                      "function argument returns size of a pointer. [sizeofwithsilentarraypointer]\n", errout_str());
 
         check("void f( int a[]) {\n"
               "    std::cout << sizeof a / sizeof(int) << std::endl;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Using 'sizeof' on array given as "
-                      "function argument returns size of a pointer.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:18]: (warning) Using 'sizeof' on array given as "
+                      "function argument returns size of a pointer. [sizeofwithsilentarraypointer]\n", errout_str());
 
         check("void f( int a[3] ) {\n"
               "    std::cout << sizeof(a) / sizeof(int) << std::endl;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Using 'sizeof' on array given as "
-                      "function argument returns size of a pointer.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:18]: (warning) Using 'sizeof' on array given as "
+                      "function argument returns size of a pointer. [sizeofwithsilentarraypointer]\n", errout_str());
 
         check("typedef char Fixname[1000];\n"
               "int f2(Fixname& f2v) {\n"
               "  int i = sizeof(f2v);\n"
               "  printf(\"sizeof f2v %d\", i);\n"
-              "   }\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "   }");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int *p) {\n"
               "    p[0] = 0;\n"
               "    int unused = sizeof(p);\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char p[] = \"test\";\n"
               "    int unused = sizeof(p);\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // ticket #2495
         check("void f() {\n"
@@ -331,96 +305,158 @@ class TestSizeof : public TestFixture {
               "      {1,0,1},\n"
               "    };\n"
               "    const int COL_MAX=sizeof(col)/sizeof(col[0]);\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // ticket #155
         check("void f() {\n"
               "    char buff1[1024*64],buff2[sizeof(buff1)*2];\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // ticket #2510
         check("void f( int a[], int b) {\n"
               "    std::cout << sizeof(a) / sizeof(int) << std::endl;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Using 'sizeof' on array given as "
-                      "function argument returns size of a pointer.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:18]: (warning) Using 'sizeof' on array given as "
+                      "function argument returns size of a pointer. [sizeofwithsilentarraypointer]\n", errout_str());
 
         // ticket #2510
         check("void f( int a[3] , int b[2] ) {\n"
               "    std::cout << sizeof(a) / sizeof(int) << std::endl;\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Using 'sizeof' on array given as "
-                      "function argument returns size of a pointer.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:18]: (warning) Using 'sizeof' on array given as "
+                      "function argument returns size of a pointer. [sizeofwithsilentarraypointer]\n", errout_str());
 
         // ticket #2510
         check("void f() {\n"
               "    char buff1[1024*64],buff2[sizeof(buff1)*(2+1)];\n"
-              "}\n"
-             );
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
     }
 
     void sizeofForNumericParameter() {
         check("void f() {\n"
               "    std::cout << sizeof(10) << std::endl;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Suspicious usage of 'sizeof' with a numeric constant as parameter.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:18]: (warning) Suspicious usage of 'sizeof' with a numeric constant as parameter. [sizeofwithnumericparameter]\n", errout_str());
 
         check("void f() {\n"
               "    std::cout << sizeof(-10) << std::endl;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Suspicious usage of 'sizeof' with a numeric constant as parameter.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:18]: (warning) Suspicious usage of 'sizeof' with a numeric constant as parameter. [sizeofwithnumericparameter]\n", errout_str());
 
         check("void f() {\n"
               "    std::cout << sizeof 10  << std::endl;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Suspicious usage of 'sizeof' with a numeric constant as parameter.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:18]: (warning) Suspicious usage of 'sizeof' with a numeric constant as parameter. [sizeofwithnumericparameter]\n", errout_str());
 
         check("void f() {\n"
               "    std::cout << sizeof -10  << std::endl;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Suspicious usage of 'sizeof' with a numeric constant as parameter.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:18]: (warning) Suspicious usage of 'sizeof' with a numeric constant as parameter. [sizeofwithnumericparameter]\n", errout_str());
     }
 
     void suspiciousSizeofCalculation() {
-        check("int* p;\n"
-              "return sizeof(p)/5;");
-        ASSERT_EQUALS("[test.cpp:2]: (warning, inconclusive) Division of result of sizeof() on pointer type.\n", errout.str());
+        check("void f() {\n"
+              "  int* p;\n"
+              "  return sizeof(p)/5;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:10]: (warning, inconclusive) Division of result of sizeof() on pointer type. [divideSizeof]\n", errout_str());
+
+        check("void f() {\n"
+              "  unknown p;\n"
+              "  return sizeof(p)/5;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "  return sizeof(unknown)/5;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "  int p;\n"
+              "  return sizeof(p)/5;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("unknown p;\n"
-              "return sizeof(p)/5;");
-        ASSERT_EQUALS("", errout.str());
+        check("void f() {\n"
+              "  int* p[5];\n"
+              "  return sizeof(p)/5;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+
+        check("void f() {\n"
+              "  return sizeof(foo)*sizeof(bar);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:10]: (warning, inconclusive) Multiplying sizeof() with sizeof() indicates a logic error. [multiplySizeof]\n", errout_str());
+
+        check("void f() {\n"
+              "  return (foo)*sizeof(bar);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "  return sizeof(foo)*bar;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("return sizeof(unknown)/5;");
-        ASSERT_EQUALS("", errout.str());
+        check("void f() {\n"
+              "  return (end - source) / sizeof(encode_block_type) * sizeof(encode_block_type);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("int p;\n"
-              "return sizeof(p)/5;");
-        ASSERT_EQUALS("", errout.str());
+        check("struct S { T* t; };\n" // #10179
+              "int f(S* s) {\n"
+              "    return g(sizeof(*s->t) / 4);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
 
-        check("int* p[5];\n"
-              "return sizeof(p)/5;");
-        ASSERT_EQUALS("", errout.str());
+        check("void f() {\n"
+              "    const char* a[N];\n"
+              "    for (int i = 0; i < (int)(sizeof(a) / sizeof(char*)); i++) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
 
+        check("int f(int** p) {\n"
+              "    return sizeof(p[0]) / 4;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:12]: (warning, inconclusive) Division of result of sizeof() on pointer type. [divideSizeof]\n", errout_str());
 
-        check("return sizeof(foo)*sizeof(bar);");
-        ASSERT_EQUALS("[test.cpp:1]: (warning, inconclusive) Multiplying sizeof() with sizeof() indicates a logic error.\n", errout.str());
+        check("struct S {\n"
+              "    unsigned char* s;\n"
+              "};\n"
+              "struct T {\n"
+              "    S s[38];\n"
+              "};\n"
+              "void f(T* t) {\n"
+              "    for (size_t i = 0; i < sizeof(t->s) / sizeof(t->s[0]); i++) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
 
-        check("return (foo)*sizeof(bar);");
-        ASSERT_EQUALS("", errout.str());
+        check("struct S {\n"
+              "    struct T {\n"
+              "        char* c[3];\n"
+              "    } t[1];\n"
+              "};\n"
+              "void f(S* s) {\n"
+              "    for (int i = 0; i != sizeof(s->t[0].c) / sizeof(char*); i++) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
 
-        check("return sizeof(foo)*bar;");
-        ASSERT_EQUALS("", errout.str());
+        check("void f(int32_t* buf, size_t len) {\n"
+              "    for (int i = 0; i < len / sizeof(buf[0]); i++) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
 
-        check("return (end - source) / sizeof(encode_block_type) * sizeof(encode_block_type);");
-        ASSERT_EQUALS("", errout.str());
+        check("void f(int32_t*** buf, size_t len) {\n"
+              "    for (int i = 0; i < len / sizeof(**buf[0]); i++) {}\n"
+              "    for (int i = 0; i < len / sizeof(*buf[0][0]); i++) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void checkPointerSizeof() {
@@ -428,49 +464,49 @@ class TestSizeof : public TestFixture {
               "    char *x = malloc(10);\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(*x));\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int));\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(x));\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Size of pointer 'x' used instead of size of its data.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = (int*)malloc(sizeof(x));\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Size of pointer 'x' used instead of size of its data.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = static_cast<int*>(malloc(sizeof(x)));\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Size of pointer 'x' used instead of size of its data.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(&x));\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Size of pointer 'x' used instead of size of its data.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int*));\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Size of pointer 'x' used instead of size of its data.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int));\n"
@@ -478,155 +514,155 @@ class TestSizeof : public TestFixture {
               "    int **y = malloc(sizeof(int*));\n"
               "    free(y);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(100 * sizeof(x));\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Size of pointer 'x' used instead of size of its data.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(x) * 100);\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Size of pointer 'x' used instead of size of its data.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof *x);\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof x);\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Size of pointer 'x' used instead of size of its data.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(100 * sizeof x);\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Size of pointer 'x' used instead of size of its data.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = calloc(1, sizeof(*x));\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = calloc(1, sizeof *x);\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = calloc(1, sizeof(x));\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Size of pointer 'x' used instead of size of its data.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = calloc(1, sizeof x);\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Size of pointer 'x' used instead of size of its data.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = calloc(1, sizeof(int));\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char x[10];\n"
               "    memset(x, 0, sizeof(x));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char* x[10];\n"
               "    memset(x, 0, sizeof(x));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    char x[10];\n"
               "    memset(x, 0, sizeof x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int));\n"
               "    memset(x, 0, sizeof(int));\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int));\n"
               "    memset(x, 0, sizeof(*x));\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int));\n"
               "    memset(x, 0, sizeof *x);\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int));\n"
               "    memset(x, 0, sizeof x);\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Size of pointer 'x' used instead of size of its data.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int));\n"
               "    memset(x, 0, sizeof(x));\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Size of pointer 'x' used instead of size of its data.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int) * 10);\n"
               "    memset(x, 0, sizeof(x) * 10);\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Size of pointer 'x' used instead of size of its data.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int) * 10);\n"
               "    memset(x, 0, sizeof x * 10);\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Size of pointer 'x' used instead of size of its data.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (warning) Size of pointer 'x' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int) * 10);\n"
               "    memset(x, 0, sizeof(*x) * 10);\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int) * 10);\n"
               "    memset(x, 0, sizeof *x * 10);\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    int *x = malloc(sizeof(int) * 10);\n"
               "    memset(x, 0, sizeof(int) * 10);\n"
               "    free(x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check(
             "int fun(const char *buf1)\n"
@@ -634,18 +670,18 @@ class TestSizeof : public TestFixture {
             "  const char *buf1_ex = \"foobarbaz\";\n"
             "  return strncmp(buf1, buf1_ex, sizeof(buf1_ex)) == 0;\n"
             "}");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Size of pointer 'buf1_ex' used instead of size of its data.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:24]: (warning) Size of pointer 'buf1_ex' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check(
             "int fun(const char *buf1) {\n"
             "  return strncmp(buf1, foo(buf2), sizeof(buf1)) == 0;\n"
             "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Size of pointer 'buf1' used instead of size of its data.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:18]: (warning) Size of pointer 'buf1' used instead of size of its data. [pointerSize]\n", errout_str());
 
         check("int fun(const char *buf2) {\n"
               "  return strncmp(buf1, buf2, sizeof(char*)) == 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Size of pointer 'buf2' used instead of size of its data.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:24]: (warning) Size of pointer 'buf2' used instead of size of its data. [pointerSize]\n", errout_str());
 
         // #ticket 3874
         check("void f()\n"
@@ -653,25 +689,25 @@ class TestSizeof : public TestFixture {
               " int * pIntArray[10];\n"
               " memset(pIntArray, 0, sizeof(pIntArray));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void FreeFileName(const char *s) {\n"
               "  CxString tbuf;\n"
               "  const char *p;\n"
               "  memcpy(s, siezof(s));\n" // non-standard memcpy
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "  module_config_t *tab = module;\n"
               "  memset(tab + confsize, 0, sizeof(tab[confsize]));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f(char* aug) {\n"
               "  memmove(aug + extra_string, aug, buf - (bfd_byte *)aug);\n" // #7100
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #7518
         check("bool create_iso_definition(cpp_reader *pfile, cpp_macro *macro) {\n"
@@ -679,13 +715,13 @@ class TestSizeof : public TestFixture {
               "  cpp_hashnode **params = malloc(sizeof(cpp_hashnode *) * macro->paramc);\n"
               "  memcpy(params, macro->params, sizeof(cpp_hashnode *) * macro->paramc);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void* foo() {\n"
               "  void* AtomName = malloc(sizeof(char *) * 34);\n"
               "  return AtomName;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void checkPointerSizeofStruct() {
@@ -693,7 +729,7 @@ class TestSizeof : public TestFixture {
               "    struct foo *ptr;\n"
               "    memset( ptr->bar, 0, sizeof ptr->bar );\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    struct foo {\n"
@@ -701,7 +737,7 @@ class TestSizeof : public TestFixture {
               "    }* ptr;\n"
               "    memset( ptr->bar, 0, sizeof ptr->bar );\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    struct foo {\n"
@@ -709,46 +745,58 @@ class TestSizeof : public TestFixture {
               "    }* ptr;\n"
               "    memset( ptr->bar, 0, sizeof ptr->bar );\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Size of pointer 'bar' used instead of size of its data.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:18]: (warning) Size of pointer 'bar' used instead of size of its data. [pointerSize]\n", errout_str());
     }
 
     void sizeofDivisionMemset() {
         check("void foo(memoryMapEntry_t* entry, memoryMapEntry_t* memoryMapEnd) {\n"
               "    memmove(entry, entry + 1, (memoryMapEnd - entry) / sizeof(entry));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Division by result of sizeof(). memmove() expects a size in bytes, did you intend to multiply instead?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:56]: (warning, inconclusive) Division of result of sizeof() on pointer type. [divideSizeof]\n"
+                      "[test.cpp:2:54]: (warning) Division by result of sizeof(). memmove() expects a size in bytes, did you intend to multiply instead? [sizeofDivisionMemfunc]\n",
+                      errout_str());
 
         check("Foo* allocFoo(int num) {\n"
               "    return malloc(num / sizeof(Foo));\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Division by result of sizeof(). malloc() expects a size in bytes, did you intend to multiply instead?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:23]: (warning) Division by result of sizeof(). malloc() expects a size in bytes, did you intend to multiply instead? [sizeofDivisionMemfunc]\n", errout_str());
 
         check("void f() {\n"
               "  char str[100];\n"
               "  strncpy(str, xyz, sizeof(str)/sizeof(str[0]));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n" // #9648
+              "    int a[5] = { 0 };\n"
+              "    int b[5];\n"
+              "    memcpy(b, a, ((sizeof(a) / sizeof(a[0])) - 1) * sizeof(a[0]));\n"
+              "    memcpy(b, a, sizeof(a[0]) * ((sizeof(a) / sizeof(a[0])) - 1));\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void sizeofVoid() {
         check("void f() {\n"
               "  int size = sizeof(void);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (portability) Behaviour of 'sizeof(void)' is not covered by the ISO C standard.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (portability) Behaviour of 'sizeof(void)' is not covered by the ISO C standard. [sizeofVoid]\n", errout_str());
 
         check("void f() {\n"
               "  void* p;\n"
               "  int size = sizeof(*p);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (portability) '*p' is of type 'void', the behaviour of 'sizeof(void)' is not covered by the ISO C standard.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:14]: (portability) '*p' is of type 'void', the behaviour of 'sizeof(void)' is not covered by the ISO C standard. [sizeofDereferencedVoidPointer]\n", errout_str());
 
         check("void f() {\n"
               "  void* p = malloc(10);\n"
               "  int* p2 = p + 4;\n"
               "  int* p3 = p - 1;\n"
+              "  int* p4 = 1 + p;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (portability) 'p' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined.\n"
-                      "[test.cpp:4]: (portability) 'p' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:15]: (portability) 'p' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n"
+                      "[test.cpp:4:15]: (portability) 'p' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n"
+                      "[test.cpp:5:15]: (portability) 'p' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n", errout_str());
 
         check("void f() {\n"
               "  void* p1 = malloc(10);\n"
@@ -756,8 +804,8 @@ class TestSizeof : public TestFixture {
               "  p1--;\n"
               "  p2++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (portability) 'p1' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined.\n"
-                      "[test.cpp:5]: (portability) 'p2' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (portability) 'p1' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n"
+                      "[test.cpp:5:5]: (portability) 'p2' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n", errout_str());
 
         check("void f() {\n"
               "  void* p1 = malloc(10);\n"
@@ -765,62 +813,62 @@ class TestSizeof : public TestFixture {
               "  p1-=4;\n"
               "  p2+=4;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (portability) 'p1' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined.\n"
-                      "[test.cpp:5]: (portability) 'p2' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (portability) 'p1' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n"
+                      "[test.cpp:5:5]: (portability) 'p2' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n", errout_str());
 
         check("void f() {\n"
               "  void* p = malloc(10);\n"
               "  int* p2 = &p + 4;\n"
               "  int* p3 = &p - 1;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  void** p1 = malloc(10);\n"
               "  p1--;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  void** p1;\n"
               "  int j = sizeof(*p1);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  void* p1[5];\n"
               "  int j = sizeof(*p1);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Calculations on void* with casts
 
         check("void f(void *data) {\n"
               "  *((unsigned char *)data + 1) = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(void *data) {\n"
               "  *((unsigned char *)(data) + 1) = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(void *data) {\n"
               "  unsigned char* c = (unsigned char *)(data + 1);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (portability) 'data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:45]: (portability) 'data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n", errout_str());
 
         check("void f(void *data) {\n"
               "  unsigned char* c = (unsigned char *)data++;\n"
               "  unsigned char* c2 = (unsigned char *)++data;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (portability) 'data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined.\n"
-                      "[test.cpp:3]: (portability) 'data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:43]: (portability) 'data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n"
+                      "[test.cpp:3:40]: (portability) 'data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n", errout_str());
 
         check("void f(void *data) {\n"
               "  void* data2 = data + 1;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (portability) 'data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:22]: (portability) 'data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n", errout_str());
 
         // #4908 (void pointer as a member of a struct/class)
         check("struct FOO {\n"
@@ -830,9 +878,9 @@ class TestSizeof : public TestFixture {
               "  char x = *((char*)(foo.data+1));\n"
               "  foo.data++;\n"
               "  return x;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:5]: (portability) 'foo.data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined.\n"
-                      "[test.cpp:6]: (portability) 'foo.data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:30]: (portability) 'foo.data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n"
+                      "[test.cpp:6:11]: (portability) 'foo.data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n", errout_str());
 
         check("struct FOO {\n"
               "  void *data;\n"
@@ -854,16 +902,16 @@ class TestSizeof : public TestFixture {
               "};\n"
               "void f4(struct BOO* boo) {\n"
               "  char c = *((char*)boo->data.data + 1);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("struct FOO {\n"
               "  void *data;\n"
               "};\n"
               "char f(struct FOO* foo) {\n"
               "  *(foo[1].data + 1) = 0;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:5]: (portability) 'foo[1].data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:17]: (portability) 'foo[1].data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n", errout_str());
 
         check("struct FOO {\n"
               "  void *data;\n"
@@ -871,12 +919,12 @@ class TestSizeof : public TestFixture {
               "void f2(struct FOO* foo) {\n"
               "  (foo[0]).data++;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (portability) '(foo[0]).data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:16]: (portability) '(foo[0]).data' is of type 'void *'. When using void pointers in calculations, the behaviour is undefined. [arithOperationsOnVoidPointer]\n", errout_str());
 
         // #6050 arithmetic on void**
         check("void* array[10];\n"
-              "void** b = array + 3;\n");
-        ASSERT_EQUALS("", errout.str());
+              "void** b = array + 3;");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void customStrncat() {
@@ -884,7 +932,7 @@ class TestSizeof : public TestFixture {
         check("char strncat ();\n"
               "int main () {\n"
               "  return strncat ();\n"
-              "}\n");
+              "}");
     }
 
 };
diff --git a/test/teststandards.cpp b/test/teststandards.cpp
new file mode 100644
index 00000000000..0786021dfc1
--- /dev/null
+++ b/test/teststandards.cpp
@@ -0,0 +1,144 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "fixture.h"
+#include "standards.h"
+
+class TestStandards : public TestFixture {
+public:
+    TestStandards() : TestFixture("TestStandards") {}
+
+private:
+    void run() override {
+        TEST_CASE(set);
+        TEST_CASE(setCPPAlias);
+        TEST_CASE(setCAlias);
+        TEST_CASE(getC);
+        TEST_CASE(getCPP);
+        TEST_CASE(setStd);
+    }
+
+    void set() const {
+        Standards stds;
+        ASSERT_EQUALS_ENUM(Standards::CLatest, stds.c);
+        ASSERT_EQUALS("", stds.stdValueC);
+        ASSERT_EQUALS_ENUM(Standards::CPPLatest, stds.cpp);
+        ASSERT_EQUALS("", stds.stdValueCPP);
+
+        ASSERT_EQUALS(true, stds.setC("c99"));
+        ASSERT_EQUALS_ENUM(Standards::C99, stds.c);
+        ASSERT_EQUALS("c99", stds.stdValueC);
+        ASSERT_EQUALS_ENUM(Standards::CPPLatest, stds.cpp);
+        ASSERT_EQUALS("", stds.stdValueCPP);
+
+        ASSERT_EQUALS(true, stds.setC("c11"));
+        ASSERT_EQUALS_ENUM(Standards::C11, stds.c);
+        ASSERT_EQUALS("c11", stds.stdValueC);
+        ASSERT_EQUALS_ENUM(Standards::CPPLatest, stds.cpp);
+        ASSERT_EQUALS("", stds.stdValueCPP);
+
+        ASSERT_EQUALS(true, stds.setCPP("c++11"));
+        ASSERT_EQUALS_ENUM(Standards::C11, stds.c);
+        ASSERT_EQUALS("c11", stds.stdValueC);
+        ASSERT_EQUALS_ENUM(Standards::CPP11, stds.cpp);
+        ASSERT_EQUALS("c++11", stds.stdValueCPP);
+
+        ASSERT_EQUALS(true, stds.setCPP("c++23"));
+        ASSERT_EQUALS_ENUM(Standards::C11, stds.c);
+        ASSERT_EQUALS("c11", stds.stdValueC);
+        ASSERT_EQUALS_ENUM(Standards::CPP23, stds.cpp);
+        ASSERT_EQUALS("c++23", stds.stdValueCPP);
+
+        ASSERT_EQUALS(false, stds.setC("c77"));
+        ASSERT_EQUALS_ENUM(Standards::C11, stds.c);
+        ASSERT_EQUALS("c11", stds.stdValueC);
+        ASSERT_EQUALS_ENUM(Standards::CPP23, stds.cpp);
+        ASSERT_EQUALS("c++23", stds.stdValueCPP);
+
+        ASSERT_EQUALS(false, stds.setCPP("c+77"));
+        ASSERT_EQUALS_ENUM(Standards::C11, stds.c);
+        ASSERT_EQUALS("c11", stds.stdValueC);
+        ASSERT_EQUALS_ENUM(Standards::CPP23, stds.cpp);
+        ASSERT_EQUALS("c++23", stds.stdValueCPP);
+
+        ASSERT_EQUALS(false, stds.setC("C23"));
+        ASSERT_EQUALS_ENUM(Standards::C11, stds.c);
+        ASSERT_EQUALS("c11", stds.stdValueC);
+        ASSERT_EQUALS_ENUM(Standards::CPP23, stds.cpp);
+        ASSERT_EQUALS("c++23", stds.stdValueCPP);
+
+        ASSERT_EQUALS(false, stds.setCPP("C++11"));
+        ASSERT_EQUALS_ENUM(Standards::C11, stds.c);
+        ASSERT_EQUALS("c11", stds.stdValueC);
+        ASSERT_EQUALS_ENUM(Standards::CPP23, stds.cpp);
+        ASSERT_EQUALS("c++23", stds.stdValueCPP);
+    }
+
+    void setCPPAlias() const {
+        Standards stds;
+        ASSERT_EQUALS(true, stds.setCPP("gnu++11"));
+        ASSERT_EQUALS_ENUM(Standards::CLatest, stds.c);
+        ASSERT_EQUALS("", stds.stdValueC);
+        ASSERT_EQUALS_ENUM(Standards::CPP11, stds.cpp);
+        ASSERT_EQUALS("gnu++11", stds.stdValueCPP);
+    }
+
+    void setCAlias() const {
+        Standards stds;
+        ASSERT_EQUALS(true, stds.setC("gnu17"));
+        ASSERT_EQUALS_ENUM(Standards::C17, stds.c);
+        ASSERT_EQUALS("gnu17", stds.stdValueC);
+        ASSERT_EQUALS_ENUM(Standards::CPPLatest, stds.cpp);
+        ASSERT_EQUALS("", stds.stdValueCPP);
+    }
+
+    void getC() const {
+        ASSERT_EQUALS_ENUM(Standards::C99, Standards::getC("c99"));
+        ASSERT_EQUALS_ENUM(Standards::C11, Standards::getC("c11"));
+        ASSERT_EQUALS_ENUM(Standards::C17, Standards::getC("gnu17"));
+        ASSERT_EQUALS_ENUM(Standards::C11, Standards::getC("iso9899:2011"));
+
+        ASSERT_EQUALS_ENUM(Standards::CLatest, Standards::getC(""));
+        ASSERT_EQUALS_ENUM(Standards::CLatest, Standards::getC("c77"));
+        ASSERT_EQUALS_ENUM(Standards::CLatest, Standards::getC("C99"));
+    }
+
+    void getCPP() const {
+        ASSERT_EQUALS_ENUM(Standards::CPP11, Standards::getCPP("c++11"));
+        ASSERT_EQUALS_ENUM(Standards::CPP23, Standards::getCPP("c++23"));
+        ASSERT_EQUALS_ENUM(Standards::CPP23, Standards::getCPP("gnu++23"));
+
+        ASSERT_EQUALS_ENUM(Standards::CPPLatest, Standards::getCPP(""));
+        ASSERT_EQUALS_ENUM(Standards::CPPLatest, Standards::getCPP("c++77"));
+        ASSERT_EQUALS_ENUM(Standards::CPPLatest, Standards::getCPP("C++11"));
+    }
+
+    void setStd() const {
+        Standards stds;
+        ASSERT(stds.setStd("c11"));
+        ASSERT(stds.setStd("c++11"));
+        ASSERT(stds.setStd("gnu11"));
+        ASSERT(stds.setStd("gnu++17"));
+        ASSERT(stds.setStd("iso9899:2011"));
+
+        ASSERT(!stds.setStd("C++11"));
+        ASSERT(!stds.setStd("Gnu++11"));
+    }
+};
+
+REGISTER_TEST(TestStandards)
diff --git a/test/teststl.cpp b/test/teststl.cpp
index 99e861144eb..2c88f17dd14 100644
--- a/test/teststl.cpp
+++ b/test/teststl.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,31 +17,31 @@
  */
 
 #include "checkstl.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "settings.h"
 #include "standards.h"
-#include "testsuite.h"
-#include "tokenize.h"
+#include "utils.h"
 
 #include <cstddef>
 #include <string>
 
-
 class TestStl : public TestFixture {
 public:
-    TestStl() : TestFixture("TestStl") {
-    }
+    TestStl() : TestFixture("TestStl") {}
 
 private:
-    Settings settings;
-
-    void run() OVERRIDE {
-        settings.addEnabled("warning");
-        settings.addEnabled("style");
-        settings.addEnabled("performance");
-        LOAD_LIB_2(settings.library, "std.cfg");
+    const Settings settings = settingsBuilder().severity(Severity::warning).severity(Severity::style).severity(Severity::performance).library("std.cfg").build();
+    const Settings settings_i = settingsBuilder(settings).certainty(Certainty::inconclusive).build();
+    const Settings settingsCpp03 = settingsBuilder(settings).cpp(Standards::CPP03).build();
 
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(outOfBounds);
+        TEST_CASE(outOfBoundsSymbolic);
         TEST_CASE(outOfBoundsIndexExpression);
+        TEST_CASE(outOfBoundsIterator);
 
         TEST_CASE(iterator1);
         TEST_CASE(iterator2);
@@ -64,8 +64,20 @@ class TestStl : public TestFixture {
         TEST_CASE(iterator19);
         TEST_CASE(iterator20);
         TEST_CASE(iterator21);
+        TEST_CASE(iterator22);
+        TEST_CASE(iterator23);
+        TEST_CASE(iterator24);
+        TEST_CASE(iterator25); // #9742
+        TEST_CASE(iterator26); // #9176
+        TEST_CASE(iterator27); // #10378
+        TEST_CASE(iterator28); // #10450
+        TEST_CASE(iterator29);
+        TEST_CASE(iterator30);
+        TEST_CASE(iterator31);
         TEST_CASE(iteratorExpression);
         TEST_CASE(iteratorSameExpression);
+        TEST_CASE(mismatchingContainerIterator);
+        TEST_CASE(eraseIteratorOutOfBounds);
 
         TEST_CASE(dereference);
         TEST_CASE(dereference_break);  // #3644 - handle "break"
@@ -74,6 +86,7 @@ class TestStl : public TestFixture {
         TEST_CASE(STLSize);
         TEST_CASE(STLSizeNoErr);
         TEST_CASE(negativeIndex);
+        TEST_CASE(negativeIndexMultiline);
         TEST_CASE(erase1);
         TEST_CASE(erase2);
         TEST_CASE(erase3);
@@ -111,6 +124,7 @@ class TestStl : public TestFixture {
         TEST_CASE(pushback13);
         TEST_CASE(insert1);
         TEST_CASE(insert2);
+        TEST_CASE(popback1);
 
         TEST_CASE(stlBoundaries1);
         TEST_CASE(stlBoundaries2);
@@ -156,161 +170,194 @@ class TestStl : public TestFixture {
         TEST_CASE(loopAlgoIncrement);
         TEST_CASE(loopAlgoConditional);
         TEST_CASE(loopAlgoMinMax);
+        TEST_CASE(loopAlgoMultipleReturn);
 
         TEST_CASE(invalidContainer);
+        TEST_CASE(invalidContainerLoop);
         TEST_CASE(findInsert);
+
+        TEST_CASE(checkKnownEmptyContainer);
+        TEST_CASE(checkMutexes);
     }
 
-    void check(const char code[], const bool inconclusive=false, const Standards::cppstd_t cppstandard=Standards::CPPLatest) {
-        // Clear the error buffer..
-        errout.str("");
+    struct CheckOptions
+    {
+        bool inconclusive = false;
+    };
 
-        settings.inconclusive = inconclusive;
-        settings.standards.cpp = cppstandard;
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
+        const Settings& s = options.inconclusive ? settings_i : settings;
 
+        check_(file, line, code, s);
+    }
 
-        // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const Settings& s) {
+        SimpleTokenizer tokenizer(s, *this);
 
-        CheckStl checkStl(&tokenizer, &settings, this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
-        tokenizer.tokenize(istr, "test.cpp");
-        checkStl.runChecks(&tokenizer, &settings, this);
+        runChecks<CheckStl>(tokenizer, this);
     }
 
-    void check(const std::string &code, const bool inconclusive=false) {
-        check(code.c_str(), inconclusive);
-    }
+    // TODO: get rid of this
+    void check_(const char* file, int line, const std::string& code) {
+        // Tokenize..
+        SimpleTokenizer tokenizer(settings, *this);
 
-    void checkNormal(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
+        runChecks<CheckStl>(tokenizer, this);
+    }
+
+#define checkNormal(...) checkNormal_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkNormal_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check..
-        CheckStl checkStl(&tokenizer, &settings, this);
-        checkStl.runChecks(&tokenizer, &settings, this);
+        runChecks<CheckStl>(tokenizer, this);
     }
 
     void outOfBounds() {
         setMultiline();
 
+        checkNormal("bool f(const int a, const int b)\n" // #8648
+                    "{\n"
+                    "    std::cout << a << b;\n"
+                    "    return true;\n"
+                    "}\n"
+                    "void f(const std::vector<int> &v)\n"
+                    "{\n"
+                    "    if(v.size() >=2 &&\n"
+                    "            bar(v[2], v[3]) )\n"                          // v[3] is accessed
+                    "    {;}\n"
+                    "}\n");
+        ASSERT_EQUALS("[test.cpp:9:18]: warning: Either the condition 'v.size()>=2' is redundant or size of 'v' can be 2. Expression 'v[2]' causes access out of bounds. [containerOutOfBounds]\n"
+                      "[test.cpp:8:17]: note: condition 'v.size()>=2'\n"
+                      "[test.cpp:9:18]: note: Access out of bounds\n"
+                      "[test.cpp:9:24]: warning: Either the condition 'v.size()>=2' is redundant or size of 'v' can be 2. Expression 'v[3]' causes access out of bounds. [containerOutOfBounds]\n"
+                      "[test.cpp:8:17]: note: condition 'v.size()>=2'\n"
+                      "[test.cpp:9:24]: note: Access out of bounds\n", errout_str());
+
         checkNormal("void f() {\n"
                     "  std::string s;\n"
                     "  s[10] = 1;\n"
                     "}");
-        ASSERT_EQUALS("test.cpp:3:error:Out of bounds access in expression 's[10]' because 's' is empty.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:4]: error: Out of bounds access in expression 's[10]' because 's' is empty. [containerOutOfBounds]\n", errout_str());
 
         checkNormal("void f() {\n"
                     "  std::string s = \"abcd\";\n"
                     "  s[10] = 1;\n"
                     "}");
-        ASSERT_EQUALS("test.cpp:3:error:Out of bounds access in 's[10]', if 's' size is 4 and '10' is 10\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:4]: error: Out of bounds access in 's[10]', if 's' size is 4 and '10' is 10 [containerOutOfBounds]\n", errout_str());
 
         checkNormal("void f(std::vector<int> v) {\n"
                     "    v.front();\n"
                     "    if (v.empty()) {}\n"
-                    "}\n");
-        ASSERT_EQUALS("test.cpp:2:warning:Either the condition 'v.empty()' is redundant or expression 'v.front()' cause access out of bounds.\n"
-                      "test.cpp:3:note:condition 'v.empty()'\n"
-                      "test.cpp:2:note:Access out of bounds\n", errout.str());
+                    "}");
+        ASSERT_EQUALS("[test.cpp:2:12]: warning: Either the condition 'v.empty()' is redundant or expression 'v.front()' causes access out of bounds. [containerOutOfBounds]\n"
+                      "[test.cpp:3:16]: note: condition 'v.empty()'\n"
+                      "[test.cpp:2:12]: note: Access out of bounds\n", errout_str());
 
         checkNormal("void f(std::vector<int> v) {\n"
                     "    if (v.size() == 3) {}\n"
                     "    v[16] = 0;\n"
-                    "}\n");
-        ASSERT_EQUALS("test.cpp:3:warning:Either the condition 'v.size()==3' is redundant or v size can be 3. Expression 'v[16]' cause access out of bounds.\n"
-                      "test.cpp:2:note:condition 'v.size()==3'\n"
-                      "test.cpp:3:note:Access out of bounds\n", errout.str());
+                    "}");
+        ASSERT_EQUALS("[test.cpp:3:6]: warning: Either the condition 'v.size()==3' is redundant or size of 'v' can be 3. Expression 'v[16]' causes access out of bounds. [containerOutOfBounds]\n"
+                      "[test.cpp:2:18]: note: condition 'v.size()==3'\n"
+                      "[test.cpp:3:6]: note: Access out of bounds\n", errout_str());
 
         checkNormal("void f(std::vector<int> v) {\n"
                     "    int i = 16;\n"
                     "    if (v.size() == 3) {\n"
                     "        v[i] = 0;\n"
                     "    }\n"
-                    "}\n");
-        ASSERT_EQUALS("test.cpp:4:warning:Either the condition 'v.size()==3' is redundant or v size can be 3. Expression 'v[i]' cause access out of bounds.\n"
-                      "test.cpp:3:note:condition 'v.size()==3'\n"
-                      "test.cpp:4:note:Access out of bounds\n", errout.str());
+                    "}");
+        ASSERT_EQUALS("[test.cpp:4:10]: warning: Either the condition 'v.size()==3' is redundant or size of 'v' can be 3. Expression 'v[i]' causes access out of bounds. [containerOutOfBounds]\n"
+                      "[test.cpp:3:18]: note: condition 'v.size()==3'\n"
+                      "[test.cpp:4:10]: note: Access out of bounds\n", errout_str());
 
         checkNormal("void f(std::vector<int> v, int i) {\n"
                     "    if (v.size() == 3 || i == 16) {}\n"
                     "    v[i] = 0;\n"
-                    "}\n");
-        ASSERT_EQUALS("", errout.str());
+                    "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkNormal("void f(std::map<int,int> x) {\n"
                     "    if (x.empty()) { x[1] = 2; }\n"
-                    "}\n");
-        ASSERT_EQUALS("", errout.str());
+                    "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkNormal("void f(std::string s) {\n"
                     "    if (s.size() == 1) {\n"
                     "        s[2] = 0;\n"
                     "    }\n"
-                    "}\n");
-        ASSERT_EQUALS("test.cpp:3:warning:Either the condition 's.size()==1' is redundant or s size can be 1. Expression 's[2]' cause access out of bounds.\n"
-                      "test.cpp:2:note:condition 's.size()==1'\n"
-                      "test.cpp:3:note:Access out of bounds\n", errout.str());
+                    "}");
+        ASSERT_EQUALS("[test.cpp:3:10]: warning: Either the condition 's.size()==1' is redundant or size of 's' can be 1. Expression 's[2]' causes access out of bounds. [containerOutOfBounds]\n"
+                      "[test.cpp:2:18]: note: condition 's.size()==1'\n"
+                      "[test.cpp:3:10]: note: Access out of bounds\n", errout_str());
 
         // Do not crash
         checkNormal("void a() {\n"
                     "  std::string b[];\n"
                     "  for (auto c : b)\n"
                     "    c.data();\n"
-                    "}\n");
-        ASSERT_EQUALS("", errout.str());
+                    "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkNormal("std::string f(std::string x) {\n"
                     "  if (x.empty()) return {};\n"
                     "  x[0];\n"
-                    "}\n");
-        ASSERT_EQUALS("", errout.str());
+                    "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkNormal("std::string f(std::string x) {\n"
                     "  if (x.empty()) return std::string{};\n"
                     "  x[0];\n"
-                    "}\n");
-        ASSERT_EQUALS("", errout.str());
+                    "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkNormal("void f() {\n"
                     "  std::string s;\n"
                     "  x = s.begin() + 1;\n"
-                    "}\n");
-        ASSERT_EQUALS("test.cpp:3:error:Out of bounds access in expression 's.begin()+1' because 's' is empty.\n", errout.str());
+                    "}");
+        ASSERT_EQUALS(
+            "[test.cpp:3:17]: error: Out of bounds access in expression 's.begin()+1' because 's' is empty. [containerOutOfBounds]\n"
+            "[test.cpp:3:17]: error: Out of bounds access in expression 's.begin()+1' because 's' is empty. [containerOutOfBounds]\n",   // duplicate
+            errout_str());
 
         checkNormal("void f(int x) {\n"
                     "  std::string s;\n"
-                    "  x = s.begin() + x;\n"
-                    "}\n");
-        ASSERT_EQUALS("test.cpp:3:error:Out of bounds access in expression 's.begin()+x' because 's' is empty and 'x' may be non-zero.\n", errout.str());
+                    "  auto it = s.begin() + x;\n"
+                    "}");
+        ASSERT_EQUALS("[test.cpp:3:23]: error: Out of bounds access in expression 's.begin()+x' because 's' is empty and 'x' may be non-zero. [containerOutOfBounds]\n", errout_str());
 
         checkNormal("char fstr1(){const std::string s = \"<a><b>\"; return s[42]; }\n"
-                    "wchar_t fwstr1(){const std::wstring s = L\"<a><b>\"; return s[42]; }\n");
-        ASSERT_EQUALS("test.cpp:1:error:Out of bounds access in 's[42]', if 's' size is 6 and '42' is 42\n"
-                      "test.cpp:2:error:Out of bounds access in 's[42]', if 's' size is 6 and '42' is 42\n", errout.str());
+                    "wchar_t fwstr1(){const std::wstring s = L\"<a><b>\"; return s[42]; }");
+        ASSERT_EQUALS("[test.cpp:1:54]: error: Out of bounds access in 's[42]', if 's' size is 6 and '42' is 42 [containerOutOfBounds]\n"
+                      "[test.cpp:2:60]: error: Out of bounds access in 's[42]', if 's' size is 6 and '42' is 42 [containerOutOfBounds]\n", errout_str());
 
         checkNormal("char fstr1(){const std::string s = \"<a><b>\"; return s[1]; }\n"
-                    "wchar_t fwstr1(){const std::wstring s = L\"<a><b>\"; return s[1]; }\n");
-        ASSERT_EQUALS("", errout.str());
+                    "wchar_t fwstr1(){const std::wstring s = L\"<a><b>\"; return s[1]; }");
+        ASSERT_EQUALS("", errout_str());
 
         checkNormal("int f() {\n"
                     "    std::vector<int> v;\n"
                     "    std::vector<int> * pv = &v;\n"
                     "    return (*pv)[42];\n"
-                    "}\n");
-        ASSERT_EQUALS("test.cpp:4:error:Out of bounds access in expression '(*pv)[42]' because '*pv' is empty.\n", errout.str());
+                    "}");
+        ASSERT_EQUALS("[test.cpp:4:17]: error: Out of bounds access in expression '(*pv)[42]' because '*pv' is empty. [containerOutOfBounds]\n", errout_str());
 
         checkNormal("void f() {\n"
                     "  std::string s;\n"
                     "  ++abc[s];\n"
                     "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // # 9274
         checkNormal("char f(bool b) {\n"
@@ -318,15 +365,657 @@ class TestStl : public TestFixture {
                     "    int x = 6;\n"
                     "    if(b) ++x;\n"
                     "    return s[x];\n"
-                    "}\n");
-        ASSERT_EQUALS("test.cpp:5:error:Out of bounds access in 's[x]', if 's' size is 6 and 'x' is 6\n", errout.str());
+                    "}");
+        ASSERT_EQUALS("[test.cpp:5:13]: error: Out of bounds access in 's[x]', if 's' size is 6 and 'x' is 6 [containerOutOfBounds]\n", errout_str());
 
         checkNormal("void f() {\n"
                     "    static const int N = 4;\n"
                     "    std::array<int, N> x;\n"
                     "    x[0] = 0;\n"
+                    "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("void f(bool b) {\n"
+                    "    std::vector<int> x;\n"
+                    "    if (b)\n"
+                    "        x.push_back(1);\n"
+                    "    if (x.size() < 2)\n"
+                    "        return;\n"
+                    "    x[0] = 2;\n"
+                    "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("void f(bool b) {\n"
+                    "    std::vector<int> v;\n"
+                    "    if(v.at(b?42:0)) {}\n"
+                    "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:12]: error: Out of bounds access in expression 'v.at(b?42:0)' because 'v' is empty. [containerOutOfBounds]\n",
+            errout_str());
+
+        checkNormal("void f(std::vector<int> v, bool b){\n"
+                    "    if (v.size() == 1)\n"
+                    "        if(v.at(b?42:0)) {}\n"
+                    "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:3:16]: warning: Either the condition 'v.size()==1' is redundant or size of 'v' can be 1. Expression 'v.at(b?42:0)' causes access out of bounds. [containerOutOfBounds]\n"
+            "[test.cpp:2:18]: note: condition 'v.size()==1'\n"
+            "[test.cpp:3:16]: note: Access out of bounds\n",
+            errout_str());
+
+        check("struct T {\n"
+              "  std::vector<int>* v;\n"
+              "};\n"
+              "struct S {\n"
+              "  T t;\n"
+              "};\n"
+              "long g(S& s);\n"
+              "int f() {\n"
+              "  std::vector<int> ArrS;\n"
+              "  S s = { { &ArrS } };\n"
+              "  g(s);\n"
+              "  return ArrS[0];\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct T {\n"
+              "  std::vector<int>* v;\n"
+              "};\n"
+              "struct S {\n"
+              "  std::vector<T> t;\n"
+              "};\n"
+              "long g(S& s);\n"
+              "int f() {\n"
+              "  std::vector<int> ArrS;\n"
+              "  S s = { { { &ArrS } } };\n"
+              "  g(s);\n"
+              "  return ArrS[0];\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct T {\n"
+              "  std::vector<int>* v;\n"
+              "};\n"
+              "struct S {\n"
+              "  std::vector<std::vector<T>> t;\n"
+              "};\n"
+              "long g(S& s);\n"
+              "int f() {\n"
+              "  std::vector<int> ArrS;\n"
+              "  S s = { { { { &ArrS } } } };\n"
+              "  g(s);\n"
+              "  return ArrS[0];\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct T {\n"
+              "  std::vector<int>* v;\n"
+              "};\n"
+              "struct S {\n"
+              "  T t;\n"
+              "};\n"
+              "long g(S& s);\n"
+              "int f() {\n"
+              "  std::vector<int> ArrS;\n"
+              "  S s { { &ArrS } };\n"
+              "  g(s);\n"
+              "  return ArrS[0];\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct T {\n"
+              "  std::vector<int>* v;\n"
+              "};\n"
+              "struct S {\n"
+              "  std::vector<T> t;\n"
+              "};\n"
+              "long g(S& s);\n"
+              "int f() {\n"
+              "  std::vector<int> ArrS;\n"
+              "  S s { { { &ArrS } } };\n"
+              "  g(s);\n"
+              "  return ArrS[0];\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct T {\n"
+              "  std::vector<int>* v;\n"
+              "};\n"
+              "struct S {\n"
+              "  std::vector<std::vector<T>> t;\n"
+              "};\n"
+              "long g(S& s);\n"
+              "int f() {\n"
+              "  std::vector<int> ArrS;\n"
+              "  S s { { { { &ArrS } } } };\n"
+              "  g(s);\n"
+              "  return ArrS[0];\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("extern void Bar(const double, const double);\n"
+                    "void f(std::vector<double> &r, const double ) {\n"
+                    "    std::vector<double> result;\n"
+                    "    double d = 0.0;\n"
+                    "    const double inc = 0.1;\n"
+                    "    for(unsigned int i = 0; i < 10; ++i) {\n"
+                    "        result.push_back(d);\n"
+                    "        d = (i + 1) * inc;\n"
+                    "    }\n"
+                    "    Bar(1.0, d);\n"
+                    "    Bar(10U, result.size());\n"
+                    "    Bar(0.0, result[0]);\n"
+                    "    Bar(0.34, result[1]);\n"
+                    "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("void f(size_t entries) {\n"
+                    "    std::vector<uint8_t> v;\n"
+                    "    if (v.size() < entries + 2)\n"
+                    "        v.resize(entries + 2);\n"
+                    "    v[0] = 1;\n"
+                    "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("void f(size_t entries) {\n"
+                    "    std::vector<uint8_t> v;\n"
+                    "    if (v.size() < entries)\n"
+                    "        v.resize(entries);\n"
+                    "    v[0] = 1;\n"
+                    "}\n");
+        ASSERT_EQUALS("[test.cpp:5:6]: error: Out of bounds access in expression 'v[0]' because 'v' is empty. [containerOutOfBounds]\n", errout_str());
+
+        checkNormal("void f(size_t entries) {\n"
+                    "    if (entries < 2) return;\n"
+                    "    std::vector<uint8_t> v;\n"
+                    "    if (v.size() < entries)\n"
+                    "        v.resize(entries);\n"
+                    "    v[0] = 1;\n"
+                    "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("void f(size_t entries) {\n"
+                    "    if (entries == 0) return;\n"
+                    "    std::vector<uint8_t> v;\n"
+                    "    if (v.size() < entries)\n"
+                    "        v.resize(entries);\n"
+                    "    v[0] = 1;\n"
+                    "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("void foo(std::vector<int>* PArr, int n) {\n"
+                    " std::vector<int> Arr;\n"
+                    " if (!PArr)\n"
+                    "   PArr = &Arr;\n"
+                    " PArr->resize(n);\n"
+                    " for (int i = 0; i < n; ++i)\n"
+                    "   (*PArr)[i] = 1;\n"
+                    "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("int f() {\n"
+                    "    std::vector<int> v;\n"
+                    "    std::vector<int> * pv = &v;\n"
+                    "    return (*pv).at(42);\n"
+                    "}\n");
+        ASSERT_EQUALS("[test.cpp:4:20]: error: Out of bounds access in expression '(*pv).at(42)' because '*pv' is empty. [containerOutOfBounds]\n",
+                      errout_str());
+
+        checkNormal("std::string f(const char* DirName) {\n"
+                    "  if (DirName == nullptr)\n"
+                    "      return {};\n"
+                    "  std::string Name{ DirName };\n"
+                    "  if (!Name.empty() && Name.back() != '\\\\')\n"
+                    "    Name += '\\\\';\n"
+                    "  return Name;\n"
+                    "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("bool f(bool b) {\n"
+                    "  std::vector<int> v;\n"
+                    "  if (b)\n"
+                    "    v.push_back(0);\n"
+                    "  for(auto i:v)\n"
+                    "    if (v[i] > 0)\n"
+                    "      return true;\n"
+                    "  return false;\n"
+                    "}\n");
+        ASSERT_EQUALS("[test.cpp:5:3]: style: Consider using std::any_of algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
+
+        checkNormal("std::vector<int> range(int n);\n"
+                    "bool f(bool b) {\n"
+                    "  std::vector<int> v;\n"
+                    "  if (b)\n"
+                    "    v.push_back(1);\n"
+                    "  assert(range(v.size()).size() == v.size());\n"
+                    "  for(auto i:range(v.size()))\n"
+                    "    if (v[i] > 0)\n"
+                    "      return true;\n"
+                    "  return false;\n"
+                    "}\n");
+        ASSERT_EQUALS("[test.cpp:7:3]: style: Consider using std::any_of algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
+
+        checkNormal("bool g();\n"
+                    "int f(int x) {\n"
+                    "    std::vector<int> v;\n"
+                    "    if (g())\n"
+                    "        v.emplace_back(x);\n"
+                    "    const auto n = (int)v.size();\n"
+                    "    for (int i = 0; i < n; ++i)\n"
+                    "        if (v[i] > 0)\n"
+                    "            return i;\n"
+                    "    return 0;\n"
+                    "}\n");
+        ASSERT_EQUALS("[test.cpp:8:0]: style: Consider using std::find_if algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
+
+        checkNormal("bool g();\n"
+                    "int f(int x) {\n"
+                    "    std::vector<int> v;\n"
+                    "    if (g())\n"
+                    "        v.emplace_back(x);\n"
+                    "    const auto n = static_cast<int>(v.size());\n"
+                    "    for (int i = 0; i < n; ++i)\n"
+                    "        if (v[i] > 0)\n"
+                    "            return i;\n"
+                    "    return 0;\n"
+                    "}\n");
+        ASSERT_EQUALS("[test.cpp:8:0]: style: Consider using std::find_if algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
+
+        checkNormal("bool g();\n"
+                    "void f(int x) {\n"
+                    "    std::vector<int> v;\n"
+                    "    if (g())\n"
+                    "        v.emplace_back(x);\n"
+                    "    const int n = v.size();\n"
+                    "    h(n);\n"
+                    "    for (int i = 0; i < n; ++i)\n"
+                    "        h(v[i]);\n"
+                    "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("void foo(const std::vector<int> &v) {\n"
+                    "    if(v.size() >=1 && v[0] == 4 && v[1] == 2){}\n"
+                    "}\n");
+        ASSERT_EQUALS("[test.cpp:2:38]: warning: Either the condition 'v.size()>=1' is redundant or size of 'v' can be 1. Expression 'v[1]' causes access out of bounds. [containerOutOfBounds]\n"
+                      "[test.cpp:2:17]: note: condition 'v.size()>=1'\n"
+                      "[test.cpp:2:38]: note: Access out of bounds\n", errout_str());
+
+        checkNormal("int f(int x, int y) {\n"
+                    "    std::vector<int> a = {0,1,2};\n"
+                    "    if(x<2)\n"
+                    "        y = a[x] + 1;\n"
+                    "    else\n"
+                    "        y = a[x];\n"
+                    "    return y;\n"
+                    "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:6:14]: warning: Either the condition 'x<2' is redundant or 'x' can have the value greater or equal to 3. Expression 'a[x]' causes access out of bounds. [containerOutOfBounds]\n"
+            "[test.cpp:3:9]: note: condition 'x<2'\n"
+            "[test.cpp:6:14]: note: Access out of bounds\n",
+            errout_str());
+
+        checkNormal("int f(std::vector<int> v) {\n"
+                    "    if (v.size() > 3)\n"
+                    "        return v[v.size() - 3];\n"
+                    "    return 0;\n"
+                    "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("void f(std::vector<int> v) {\n"
+                    "    v[v.size() - 1];\n"
+                    "    if (v.size() == 1) {}\n"
+                    "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("void f(int n) {\n"
+                    "    std::vector<int> v = {1, 2, 3, 4};\n"
+                    "    const int i = qMin(n, v.size());\n"
+                    "    if (i > 1)\n"
+                    "        v[i] = 1;\n"
+                    "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("void f(std::vector<int>& v, int i) {\n"
+                    "    if (i > -1) {\n"
+                    "        v.erase(v.begin() + i);\n"
+                    "        if (v.empty()) {}\n"
+                    "    }\n"
+                    "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("void g(const char *, ...) { exit(1); }\n" // #10025
+                    "void f(const char c[]) {\n"
+                    "    std::vector<int> v = get();\n"
+                    "    if (v.empty())\n"
+                    "        g(\"\", c[0]);\n"
+                    "    return h(&v[0], v.size()); \n"
+                    "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("void f(int i, std::vector<int> v) {\n" // #9157
+                    "    if (i <= (int)v.size()) {\n"
+                    "        if (v[i]) {}\n"
+                    "    }\n"
+                    "    if (i <= static_cast<int>(v.size())) {\n"
+                    "        if (v[i]) {}\n"
+                    "    }\n"
+                    "}\n");
+        ASSERT_EQUALS("[test.cpp:3:14]: warning: Either the condition 'i<=(int)v.size()' is redundant or 'i' can have the value v.size(). Expression 'v[i]' causes access out of bounds. [containerOutOfBounds]\n"
+                      "[test.cpp:2:11]: note: condition 'i<=(int)v.size()'\n"
+                      "[test.cpp:3:14]: note: Access out of bounds\n"
+                      "[test.cpp:6:14]: warning: Either the condition 'i<=static_cast<int>(v.size())' is redundant or 'i' can have the value v.size(). Expression 'v[i]' causes access out of bounds. [containerOutOfBounds]\n"
+                      "[test.cpp:5:11]: note: condition 'i<=static_cast<int>(v.size())'\n"
+                      "[test.cpp:6:14]: note: Access out of bounds\n",
+                      errout_str());
+
+        check("template<class Iterator>\n"
+              "void b(Iterator d) {\n"
+              "  std::string c = \"a\";\n"
+              "  d + c.length();\n"
+              "}\n"
+              "void f() {\n"
+              "  std::string buf;\n"
+              "  b(buf.begin());\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:5]: error: Out of bounds access in expression 'd+c.length()' because 'buf' is empty. [containerOutOfBounds]\n",
+                      errout_str());
+
+        check("template<class Iterator>\n"
+              "void b(Iterator d) {\n"
+              "  std::string c = \"a\";\n"
+              "  sort(d, d + c.length());\n"
+              "}\n"
+              "void f() {\n"
+              "  std::string buf;\n"
+              "  b(buf.begin());\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(const std::vector<int> &v) {\n"
+              "    return !v.empty() ? 42 : v.back();\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS(
+            "[test.cpp:2:36]: warning: Either the condition 'v.empty()' is redundant or expression 'v.back()' causes access out of bounds. [containerOutOfBounds]\n"
+            "[test.cpp:2:20]: note: condition 'v.empty()'\n"
+            "[test.cpp:2:36]: note: Access out of bounds\n",
+            errout_str());
+
+        check("std::vector<int> g() {\n" // #10779
+              "    std::vector<int> v(10);\n"
+              "    for(int i = 0; i <= 10; ++i)\n"
+              "        v[i] = 42;\n"
+              "    return v;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: error: Out of bounds access in 'v[i]', if 'v' size is 10 and 'i' is 10 [containerOutOfBounds]\n",
+                      errout_str());
+
+        check("void f() {\n"
+              "    int s = 2;\n"
+              "    std::vector <int> v(s);\n"
+              "    v[100] = 1;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:6]: error: Out of bounds access in 'v[100]', if 'v' size is 2 and '100' is 100 [containerOutOfBounds]\n",
+                      errout_str());
+
+        check("void f() {\n"
+              "    std::vector <int> v({ 1, 2, 3 });\n"
+              "    v[100] = 1;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:6]: error: Out of bounds access in 'v[100]', if 'v' size is 3 and '100' is 100 [containerOutOfBounds]\n",
+                      errout_str());
+
+        check("void f() {\n"
+              "    char c[] = { 1, 2, 3 };\n"
+              "    std::vector<char> v(c, sizeof(c) + c);\n"
+              "    v[100] = 1;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:6]: error: Out of bounds access in 'v[100]', if 'v' size is 3 and '100' is 100 [containerOutOfBounds]\n",
+                      errout_str());
+
+        check("void f() {\n"
+              "    char c[] = { 1, 2, 3 };\n"
+              "    std::vector<char> v{ c, c + sizeof(c) };\n"
+              "    v[100] = 1;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:6]: error: Out of bounds access in 'v[100]', if 'v' size is 3 and '100' is 100 [containerOutOfBounds]\n",
+                      errout_str());
+
+        check("void f() {\n"
+              "    int i[] = { 1, 2, 3 };\n"
+              "    std::vector<int> v(i, i + sizeof(i) / 4);\n"
+              "    v[100] = 1;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:6]: error: Out of bounds access in 'v[100]', if 'v' size is 3 and '100' is 100 [containerOutOfBounds]\n",
+                      errout_str());
+
+        check("void f() {\n" // #6615
+              "    int i[] = { 1, 2, 3 };\n"
+              "    std::vector<int> v(i, i + sizeof(i) / sizeof(int));\n"
+              "    v[100] = 1;\n"
+              "}\n");
+        TODO_ASSERT_EQUALS("test.cpp:4:error:Out of bounds access in 'v[100]', if 'v' size is 3 and '100' is 100\n",
+                           "",
+                           errout_str());
+
+        check("void f() {\n"
+              "    std::array<int, 10> a = {};\n"
+              "    a[10];\n"
+              "    constexpr std::array<int, 10> b = {};\n"
+              "    b[10];\n"
+              "    const std::array<int, 10> c = {};\n"
+              "    c[10];\n"
+              "    static constexpr std::array<int, 10> d = {};\n"
+              "    d[10];\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:6]: error: Out of bounds access in 'a[10]', if 'a' size is 10 and '10' is 10 [containerOutOfBounds]\n"
+                      "[test.cpp:5:6]: error: Out of bounds access in 'b[10]', if 'b' size is 10 and '10' is 10 [containerOutOfBounds]\n"
+                      "[test.cpp:7:6]: error: Out of bounds access in 'c[10]', if 'c' size is 10 and '10' is 10 [containerOutOfBounds]\n"
+                      "[test.cpp:9:6]: error: Out of bounds access in 'd[10]', if 'd' size is 10 and '10' is 10 [containerOutOfBounds]\n",
+                      errout_str());
+
+        check("struct test_fixed {\n"
+              "    std::array<int, 10> array = {};\n"
+              "    void index(int i) { array[i]; }\n"
+              "};\n"
+              "void f() {\n"
+              "    test_fixed x = test_fixed();\n"
+              "    x.index(10);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:30]: error: Out of bounds access in 'array[i]', if 'array' size is 10 and 'i' is 10 [containerOutOfBounds]\n",
+                      errout_str());
+
+        check("struct test_constexpr {\n"
+              "    static constexpr std::array<int, 10> array = {};\n"
+              "    void index(int i) { array[i]; }\n"
+              "};\n"
+              "void f() {\n"
+              "    test_constexpr x = test_constexpr();\n"
+              "    x.index(10);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:30]: error: Out of bounds access in 'array[i]', if 'array' size is 10 and 'i' is 10 [containerOutOfBounds]\n",
+                      errout_str());
+
+        checkNormal("struct A {\n"
+                    "    const std::vector<int>& v;\n"
+                    "    A(const std::vector<int>& x) : v(x)\n"
+                    "    {}\n"
+                    "    int f() const {\n"
+                    "        return v[0];\n"
+                    "    }\n"
+                    "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("struct A {\n"
+                    "    static const std::vector<int> v;\n"
+                    "    int f() const {\n"
+                    "        return v[0];\n"
+                    "    }\n"
+                    "};\n"
+                    "const std::vector<int> A::v = {1, 2};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("struct a {\n"
+                    "    std::vector<int> g() const;\n"
+                    "};\n"
+                    "int f(const a& b) {\n"
+                    "    auto c = b.g();\n"
+                    "    assert(not c.empty());\n"
+                    "    int d = c.front();\n"
+                    "    return d;\n"
+                    "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("std::string f() {\n"
+                    "    std::map<int, std::string> m = { { 1, \"1\" } };\n"
+                    "    return m.at(1);\n"
+                    "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("struct A {\n"
+                    "  virtual void init_v(std::vector<int> *v) = 0;\n"
+                    "};\n"
+                    "A* create_a();\n"
+                    "struct B {\n"
+                    "  B() : a(create_a()) {}\n"
+                    "  void init_v(std::vector<int> *v) {\n"
+                    "    a->init_v(v);\n"
+                    "  }\n"
+                    "  A* a;\n"
+                    "};\n"
+                    "void f() {\n"
+                    "  B b;\n"
+                    "  std::vector<int> v;\n"
+                    "  b.init_v(&v);\n"
+                    "  v[0];\n"
+                    "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("void f(std::vector<int>* v) {\n"
+                    "  if (v->empty())\n"
+                    "    v->push_back(1);\n"
+                    "  auto x = v->back();\n"
                     "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("template <typename T, uint8_t count>\n"
+                    "struct Foo {\n"
+                    "    std::array<T, count> items = {0};\n"
+                    "    T maxCount = count;\n"
+                    "    explicit Foo(const T& maxValue = (std::numeric_limits<T>::max)()) : maxCount(maxValue) {}\n"
+                    "    bool Set(const uint8_t idx) {\n"
+                    "        if (CheckBounds(idx) && items[idx] < maxCount) {\n"
+                    "            items[idx] += 1;\n"
+                    "            return true;\n"
+                    "        }\n"
+                    "        return false;\n"
+                    "    }\n"
+                    "    static bool CheckBounds(const uint8_t idx) { return idx < count; }\n"
+                    "};\n"
+                    "void f() {\n"
+                    "    Foo<uint8_t, 42U> x;\n"
+                    "    if (x.Set(42U)) {}\n"
+                    "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("struct S { void g(std::span<int>& r) const; };\n" // #11828
+                    "int f(const S& s) {\n"
+                    "    std::span<int> t;\n"
+                    "    s.g(t);\n"
+                    "    return t[0];\n"
+                    "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("char h() {\n"
+                    "    std::string s;\n"
+                    "    std::string_view sv(s);\n"
+                    "    return s[2];\n"
+                    "}\n");
+        ASSERT_EQUALS("[test.cpp:4:13]: error: Out of bounds access in expression 's[2]' because 's' is empty. [containerOutOfBounds]\n", errout_str());
+
+        checkNormal("void f() {\n" // #12738
+                    "    std::vector<double> v{ 0, 0.1 };\n"
+                    "    (void)v[0];\n"
+                    "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkNormal("int f(const std::vector<int>& v) {\n" // #8983
+                    "    return v[2];\n"
+                    "}\n"
+                    "int g() {\n"
+                    "    return f({});\n"
+                    "}\n"
+                    "int h() {\n"
+                    "    return f({ 1, 2 });\n"
+                    "}\n");
+        ASSERT_EQUALS("[test.cpp:2:13]: error: Out of bounds access in 'v[2]', if 'v' size is 2 and '2' is 2 [containerOutOfBounds]\n"
+                      "[test.cpp:2:13]: error: Out of bounds access in expression 'v[2]' because 'v' is empty. [containerOutOfBounds]\n",
+                      errout_str());
+
+        checkNormal("int f(int x, const std::vector<int>& v) {\n"
+                    "    return x + v[0];\n"
+                    "}\n"
+                    "int g() {\n"
+                    "    return f(1, {});\n"
+                    "}\n");
+        ASSERT_EQUALS("[test.cpp:2:17]: error: Out of bounds access in expression 'v[0]' because 'v' is empty. [containerOutOfBounds]\n",
+                      errout_str());
+
+        checkNormal("bool f(const std::string_view s) { return s[500] == 'x'; }\n" // #12046
+                    "bool g() { return f(\" \"); }\n");
+        ASSERT_EQUALS("[test.cpp:1:44]: error: Out of bounds access in 's[500]', if 's' size is 1 and '500' is 500 [containerOutOfBounds]\n",
+                      errout_str());
+
+        checkNormal("int main() {\n" // #14342
+                    "    const int a[] = { 1, 2, 3 };\n"
+                    "    std::span<const int> x{ a };\n"
+                    "    return x[3];\n"
+                    "}\n");
+        ASSERT_EQUALS("[test.cpp:4:13]: error: Out of bounds access in 'x[3]', if 'x' size is 1 and '3' is 3 [containerOutOfBounds]\n",
+                      errout_str());
+
+        checkNormal("int main() {\n"
+                    "    const char a[] = \"abc\";\n"
+                    "    std::string_view x{ a };\n"
+                    "    return x[5];\n"
+                    "}\n");
+        ASSERT_EQUALS("[test.cpp:4:13]: error: Out of bounds access in 'x[5]', if 'x' size is 4 and '5' is 5 [containerOutOfBounds]\n",
+                      errout_str());
+
+        checkNormal("int f(const std::string& v) {\n"
+                    "    return v[2];\n"
+                    "}\n"
+                    "int main() {\n"
+                    "    std::string_view x{ \"a\" };\n"
+                    "    return f(std::string(x));\n"
+                    "}\n");
+        ASSERT_EQUALS("[test.cpp:2:13]: error: Out of bounds access in 'v[2]', if 'v' size is 1 and '2' is 2 [containerOutOfBounds]\n",
+                      errout_str());
+    }
+
+    void outOfBoundsSymbolic()
+    {
+        check("void foo(std::string textline, int col) {\n"
+              "    if(col > textline.size())\n"
+              "        return false;\n"
+              "    int x = textline[col];\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:2:12] -> [test.cpp:4:21]: (warning) Either the condition 'col>textline.size()' is redundant or 'col' can have the value textline.size(). Expression 'textline[col]' causes access out of bounds. [containerOutOfBounds]\n",
+            errout_str());
+
+        check("void f(const std::vector<int>& v) {\n" // #12742
+              "    for (unsigned i = 0; i < v.size();)\n"
+              "        (void)v[i++];\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void outOfBoundsIndexExpression() {
@@ -335,42 +1024,109 @@ class TestStl : public TestFixture {
         checkNormal("void f(std::string s) {\n"
                     "  s[s.size()] = 1;\n"
                     "}");
-        ASSERT_EQUALS("test.cpp:2:error:Out of bounds access of s, index 's.size()' is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:3]: error: Out of bounds access of s, index 's.size()' is out of bounds. [containerOutOfBoundsIndexExpression]\n", errout_str());
 
         checkNormal("void f(std::string s) {\n"
                     "  s[s.size()+1] = 1;\n"
                     "}");
-        ASSERT_EQUALS("test.cpp:2:error:Out of bounds access of s, index 's.size()+1' is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:3]: error: Out of bounds access of s, index 's.size()+1' is out of bounds. [containerOutOfBoundsIndexExpression]\n", errout_str());
 
         checkNormal("void f(std::string s) {\n"
                     "  s[1+s.size()] = 1;\n"
                     "}");
-        ASSERT_EQUALS("test.cpp:2:error:Out of bounds access of s, index '1+s.size()' is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:3]: error: Out of bounds access of s, index '1+s.size()' is out of bounds. [containerOutOfBoundsIndexExpression]\n", errout_str());
 
         checkNormal("void f(std::string s) {\n"
                     "  s[x*s.size()] = 1;\n"
                     "}");
-        ASSERT_EQUALS("test.cpp:2:error:Out of bounds access of s, index 'x*s.size()' is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:3]: error: Out of bounds access of s, index 'x*s.size()' is out of bounds. [containerOutOfBoundsIndexExpression]\n", errout_str());
+
+        checkNormal("bool f(std::string_view& sv) {\n" // #10031
+                    "    return sv[sv.size()] == '\\0';\n"
+                    "}\n");
+        ASSERT_EQUALS("[test.cpp:2:12]: error: Out of bounds access of sv, index 'sv.size()' is out of bounds. [containerOutOfBoundsIndexExpression]\n", errout_str());
+    }
+    void outOfBoundsIterator() {
+        check("int f() {\n"
+              "    std::vector<int> v;\n"
+              "    auto it = v.begin();\n"
+              "    return *it;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:13]: (error) Out of bounds access in expression 'it' because 'v' is empty. [containerOutOfBounds]\n",
+                      errout_str());
+
+        check("int f() {\n"
+              "    std::vector<int> v;\n"
+              "    v.push_back(0);\n"
+              "    auto it = v.begin() + 1;\n"
+              "    return *it;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:13]: (error) Out of bounds access in 'it', if 'v' size is 1 and 'it' is at position 1 from the beginning [containerOutOfBounds]\n",
+                      errout_str());
+
+        check("int f() {\n"
+              "    std::vector<int> v;\n"
+              "    v.push_back(0);\n"
+              "    auto it = v.end() - 1;\n"
+              "    return *it;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f() {\n"
+              "    std::vector<int> v;\n"
+              "    v.push_back(0);\n"
+              "    auto it = v.end() - 2;\n"
+              "    return *it;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:13]: (error) Out of bounds access in 'it', if 'v' size is 1 and 'it' is at position 2 from the end [containerOutOfBounds]\n",
+                      errout_str());
+
+        check("void g(int);\n"
+              "void f(std::vector<int> x) {\n"
+              "    std::map<int, int> m;\n"
+              "    if (!m.empty()) {\n"
+              "        g(m.begin()->second);\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    std::vector<int> vec;\n"
+              "    std::vector<int>::iterator it = vec.begin();\n"
+              "    *it = 1;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:6]: (error) Out of bounds access in expression 'it' because 'vec' is empty. [containerOutOfBounds]\n",
+                      errout_str());
+
+        check("void f() {\n"
+              "    std::vector<int> vec;\n"
+              "    auto it = vec.begin();\n"
+              "    *it = 1;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:6]: (error) Out of bounds access in expression 'it' because 'vec' is empty. [containerOutOfBounds]\n",
+                      errout_str());
     }
 
     void iterator1() {
         check("void f()\n"
               "{\n"
-              "    list<int> l1;\n"
-              "    list<int> l2;\n"
-              "    for (list<int>::iterator it = l1.begin(); it != l2.end(); ++it)\n"
+              "    std::list<int> l1;\n"
+              "    std::list<int> l2;\n"
+              "    for (std::list<int>::iterator it = l1.begin(); it != l2.end(); ++it)\n"
               "    { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:5]: (error) Same iterator is used with different containers 'l1' and 'l2'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:40]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n",
+                      errout_str());
 
         check("void f()\n"
               "{\n"
-              "    list<int> l1;\n"
-              "    list<int> l2;\n"
-              "    for (list<int>::iterator it = l1.begin(); l2.end() != it; ++it)\n"
+              "    std::list<int> l1;\n"
+              "    std::list<int> l2;\n"
+              "    for (std::list<int>::iterator it = l1.begin(); l2.end() != it; ++it)\n"
               "    { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:5]: (error) Same iterator is used with different containers 'l2' and 'l1'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:52]: (error) Iterators of different containers 'l2' and 'l1' are used together. [mismatchingContainers]\n",
+                      errout_str());
 
         check("struct C { std::list<int> l1; void func(); };\n"
               "void C::func() {\n"
@@ -379,87 +1135,92 @@ class TestStl : public TestFixture {
               "    C c;\n"
               "    for (it = c.l1.begin(); it != c.l1.end(); ++it) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Same check with reverse iterator
         check("void f()\n"
               "{\n"
-              "    list<int> l1;\n"
-              "    list<int> l2;\n"
-              "    for (list<int>::const_reverse_iterator it = l1.rbegin(); it != l2.rend(); ++it)\n"
+              "    std::list<int> l1;\n"
+              "    std::list<int> l2;\n"
+              "    for (std::list<int>::const_reverse_iterator it = l1.rbegin(); it != l2.rend(); ++it)\n"
               "    { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:5]: (error) Same iterator is used with different containers 'l1' and 'l2'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:54]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n",
+                      errout_str());
     }
 
     void iterator2() {
         check("void foo()\n"
               "{\n"
-              "    list<int> l1;\n"
-              "    list<int> l2;\n"
-              "    list<int>::iterator it = l1.begin();\n"
+              "    std::list<int> l1;\n"
+              "    std::list<int> l2;\n"
+              "    std::list<int>::iterator it = l1.begin();\n"
               "    while (it != l2.end())\n"
               "    {\n"
               "        ++it;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:5]: (error) Same iterator is used with different containers 'l1' and 'l2'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:35]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n",
+                      errout_str());
 
         check("void foo()\n"
               "{\n"
-              "    list<int> l1;\n"
-              "    list<int> l2;\n"
-              "    list<int>::iterator it = l1.begin();\n"
+              "    std::list<int> l1;\n"
+              "    std::list<int> l2;\n"
+              "    std::list<int>::iterator it = l1.begin();\n"
               "    while (l2.end() != it)\n"
               "    {\n"
               "        ++it;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:5]: (error) Same iterator is used with different containers 'l2' and 'l1'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:12]: (error) Iterators of different containers 'l2' and 'l1' are used together. [mismatchingContainers]\n",
+                      errout_str());
     }
 
     void iterator3() {
         check("void foo()\n"
               "{\n"
-              "    list<int> l1;\n"
-              "    list<int> l2;\n"
-              "    list<int>::iterator it = l1.begin();\n"
+              "    std::list<int> l1;\n"
+              "    std::list<int> l2;\n"
+              "    std::list<int>::iterator it = l1.begin();\n"
               "    l2.insert(it, 0);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Same iterator is used with different containers 'l1' and 'l2'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:5]: (error) Same iterator is used with different containers 'l1' and 'l2'. [iterators1]\n"
+                      "[test.cpp:6:5]: (error) Iterator 'it' referring to container 'l1' is used with container 'l2'. [mismatchingContainerIterator]\n",
+                      errout_str());
 
         check("void foo() {\n" // #5803
-              "    list<int> l1;\n"
-              "    list<int> l2;\n"
-              "    list<int>::iterator it = l1.begin();\n"
+              "    std::list<int> l1;\n"
+              "    std::list<int> l2;\n"
+              "    std::list<int>::iterator it = l1.begin();\n"
               "    l2.insert(it, l1.end());\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n" // #7658
-              "    list<int> l1;\n"
-              "    list<int> l2;\n"
-              "    list<int>::iterator it = l1.begin();\n"
-              "    list<int>::iterator end = l1.end();\n"
+              "    std::list<int> l1;\n"
+              "    std::list<int> l2;\n"
+              "    std::list<int>::iterator it = l1.begin();\n"
+              "    std::list<int>::iterator end = l1.end();\n"
               "    l2.insert(it, end);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // only warn for insert when there are preciself 2 arguments.
         check("void foo() {\n"
-              "    list<int> l1;\n"
-              "    list<int> l2;\n"
-              "    list<int>::iterator it = l1.begin();\n"
+              "    std::list<int> l1;\n"
+              "    std::list<int> l2;\n"
+              "    std::list<int>::iterator it = l1.begin();\n"
               "    l2.insert(it);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void foo() {\n"
-              "    list<int> l1;\n"
-              "    list<int> l2;\n"
-              "    list<int>::iterator it = l1.begin();\n"
+              "    std::list<int> l1;\n"
+              "    std::list<int> l2;\n"
+              "    std::list<int>::iterator it = l1.begin();\n"
               "    l2.insert(it,0,1);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
     }
 
@@ -474,17 +1235,16 @@ class TestStl : public TestFixture {
               "        result.insert(cit->size());\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void iterator5() {
-        check("void foo()\n"
+        check("void foo(std::vector<int> ints1, std::vector<int> ints2)\n"
               "{\n"
-              "    std::vector<int> ints1;\n"
-              "    std::vector<int> ints2;\n"
               "    std::vector<int>::iterator it = std::find(ints1.begin(), ints2.end(), 22);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Iterators of different containers are used together.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:47]: (error) Iterators of different containers 'ints1' and 'ints2' are used together. [mismatchingContainers]\n",
+                      errout_str());
     }
 
     void iterator6() {
@@ -496,7 +1256,7 @@ class TestStl : public TestFixture {
               "    std::set<int>::iterator it2 = ints1.end();\n"
               "    ints2.insert(it1, it2);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(const std::set<int> &ints1)\n"
               "{\n"
@@ -505,59 +1265,51 @@ class TestStl : public TestFixture {
               "    std::set<int>::iterator it2 = ints2.end();\n"
               "    ints2.insert(it1, it2);\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:6]: (error) Iterators of different containers are used together.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:6]: (error) Iterators of different containers are used together.\n", "", errout_str());
     }
 
     void iterator7() {
-        check("void foo()\n"
+        check("void foo(std::vector<int> ints1, std::vector<int> ints2)\n"
               "{\n"
-              "    std::vector<int> ints1;\n"
-              "    std::vector<int> ints2;\n"
               "    std::vector<int>::iterator it = std::inplace_merge(ints1.begin(), std::advance(ints1.rbegin(), 5), ints2.end());\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Iterators of different containers are used together.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:56]: (error) Iterators of different containers 'ints1' and 'ints2' are used together. [mismatchingContainers]\n",
+                      errout_str());
 
-        check("void foo()\n"
+        check("void foo(std::vector<int> ints1, std::vector<int> ints2)\n"
               "{\n"
-              "    std::vector<int> ints1;\n"
-              "    std::vector<int> ints2;\n"
               "    std::vector<int>::iterator it = std::inplace_merge(ints1.begin(), std::advance(ints2.rbegin(), 5), ints1.end());\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void iterator8() {
-        check("void foo()\n"
+        check("void foo(std::vector<int> ints1, std::vector<int> ints2)\n"
               "{\n"
-              "    std::vector<int> ints1;\n"
-              "    std::vector<int> ints2;\n"
               "    std::vector<int>::iterator it = std::find_first_of(ints1.begin(), ints2.end(), ints1.begin(), ints1.end());\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Iterators of different containers are used together.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:56]: (error) Iterators of different containers 'ints1' and 'ints2' are used together. [mismatchingContainers]\n",
+                      errout_str());
 
-        check("void foo()\n"
+        check("void foo(std::vector<int> ints1, std::vector<int> ints2)\n"
               "{\n"
-              "    std::vector<int> ints1;\n"
-              "    std::vector<int> ints2;\n"
               "    std::vector<int>::iterator it = std::find_first_of(ints1.begin(), ints1.end(), ints2.begin(), ints1.end());\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Iterators of different containers are used together.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:84]: (error) Iterators of different containers 'ints2' and 'ints1' are used together. [mismatchingContainers]\n",
+                      errout_str());
 
-        check("void foo()\n"
+        check("void foo(std::vector<int> ints1, std::vector<int> ints2)\n"
               "{\n"
-              "    std::vector<int> ints1;\n"
-              "    std::vector<int> ints2;\n"
               "    std::vector<int>::iterator it = std::find_first_of(foo.bar.begin(), foo.bar.end()-6, ints2.begin(), ints1.end());\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Iterators of different containers are used together.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:90]: (error) Iterators of different containers 'ints2' and 'ints1' are used together. [mismatchingContainers]\n",
+                      errout_str());
 
-        check("void foo()\n"
+        check("void foo(std::vector<int> ints1, std::vector<int> ints2)\n"
               "{\n"
-              "    std::vector<int> ints1;\n"
-              "    std::vector<int> ints2;\n"
               "    std::vector<int>::iterator it = std::find_first_of(ints1.begin(), ints1.end(), ints2.begin(), ints2.end());\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6839
         check("void f(const std::wstring& a, const std::wstring& b) {\n"
@@ -568,10 +1320,11 @@ class TestStl : public TestFixture {
               "    const std::string fp1 = std::string(a.begin(), a.end());\n"
               "    const std::string tp2(a.begin(), a.end());\n"
               "}");
-        ASSERT_EQUALS(// TODO "[test.cpp:2]: (error) Iterators of different containers are used together.\n"
+        ASSERT_EQUALS( // TODO "[test.cpp:2]: (error) Iterators of different containers are used together.\n"
             // TODO "[test.cpp:3]: (error) Iterators of different containers are used together.\n"
-            "[test.cpp:4]: (error) Iterators of different containers are used together.\n"
-            "[test.cpp:5]: (error) Iterators of different containers are used together.\n", errout.str());
+            "[test.cpp:4:26]: (error) Iterators of different containers 'tp3' and 'a' are used together. [mismatchingContainers]\n"
+            "[test.cpp:5:26]: (error) Iterators of different containers 'tp4' and 'b' are used together. [mismatchingContainers]\n",
+            errout_str());
     }
 
     void iterator9() {
@@ -589,7 +1342,7 @@ class TestStl : public TestFixture {
               "        ++aI;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #2481
         check("void foo(std::vector<int> &r)\n"
@@ -605,7 +1358,7 @@ class TestStl : public TestFixture {
               "        ++aI;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Execution path checking..
         check("void foo(std::vector<int> &r, int c)\n"
@@ -624,7 +1377,7 @@ class TestStl : public TestFixture {
               "        ++aI;\n"
               "    }\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:14] (error) After insert(), the iterator 'aI' may be invalid.", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:14] (error) After insert(), the iterator 'aI' may be invalid.", "", errout_str());
     }
 
     void iterator10() {
@@ -639,7 +1392,8 @@ class TestStl : public TestFixture {
               "        if (it != s2.end()) continue;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:5]: (error) Same iterator is used with different containers 's1' and 's2'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:39]: (error) Iterators of different containers 's1' and 's2' are used together. [mismatchingContainers]\n",
+                      errout_str());
     }
 
     void iterator11() {
@@ -650,7 +1404,7 @@ class TestStl : public TestFixture {
               "    for(vector<int>::iterator x = myVector.begin(); x != myVector.end(); x++)\n"
               "        myMap.erase(*x);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void iterator12() {
@@ -661,7 +1415,8 @@ class TestStl : public TestFixture {
               "    std::map<int, int>::const_iterator it = map1.find(123);\n"
               "    if (it == map2.end()) { }"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:4]: (error) Same iterator is used with different containers 'map1' and 'map2'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:45]: (error) Iterators of different containers 'map1' and 'map2' are used together. [mismatchingContainers]\n",
+                      errout_str());
 
         check("void f() {\n"
               "    std::map<int, int> map1;\n"
@@ -669,14 +1424,15 @@ class TestStl : public TestFixture {
               "    std::map<int, int>::const_iterator it = map1.find(123);\n"
               "    if (map2.end() == it) { }"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:4]: (error) Same iterator is used with different containers 'map2' and 'map1'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9]: (error) Iterators of different containers 'map2' and 'map1' are used together. [mismatchingContainers]\n",
+                      errout_str());
 
         check("void f(std::string &s) {\n"
               "    int pos = s.find(x);\n"
               "    s.erase(pos);\n"
               "    s.erase(pos);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void iterator13() {
@@ -691,7 +1447,8 @@ class TestStl : public TestFixture {
               "    while (it!=a.end())\n"
               "        ++it;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:9] -> [test.cpp:8]: (error) Same iterator is used with different containers 't' and 'a'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:10]: (error) Iterators of different containers 't' and 'a' are used together. [mismatchingContainers]\n",
+                      errout_str());
 
         // #4062
         check("void f() {\n"
@@ -700,12 +1457,12 @@ class TestStl : public TestFixture {
               "    std::vector<int>::const_iterator it;\n"
               "    it = a.begin();\n"
               "    while (it!=a.end())\n"
-              "        v++it;\n"
+              "        ++it;\n"
               "    it = t.begin();\n"
               "    while (it!=t.end())\n"
               "        ++it;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    std::vector<int> a;\n"
@@ -716,11 +1473,11 @@ class TestStl : public TestFixture {
               "    else\n"
               "        it = t.begin();\n"
               "    while (z && it!=a.end())\n"
-              "        v++it;\n"
+              "        ++it;\n"
               "    while (!z && it!=t.end())\n"
-              "        v++it;\n"
+              "        ++it;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void iterator14() {
@@ -729,7 +1486,7 @@ class TestStl : public TestFixture {
               "    std::map<int,Foo>::const_iterator it;\n"
               "    for (it = x.find(0)->second.begin(); it != x.find(0)->second.end(); ++it) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void iterator15() {
@@ -737,7 +1494,7 @@ class TestStl : public TestFixture {
               "  std::list<int>::iterator pos = a.begin();\n"
               "  for(pos = x[0]->plist.begin(); pos != x[0]->plist.end(); ++pos) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void iterator16() {
@@ -752,7 +1509,8 @@ class TestStl : public TestFixture {
               "        ++it1;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:5] -> [test.cpp:6]: (error) Comparison of iterators from containers 'l1' and 'l2'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:36]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n",
+                      errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -765,7 +1523,8 @@ class TestStl : public TestFixture {
               "        ++it2;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:6] -> [test.cpp:5]: (error) Comparison of iterators from containers 'l2' and 'l1'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:36]: (error) Iterators of different containers 'l2' and 'l1' are used together. [mismatchingContainers]\n",
+                      errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -778,21 +1537,22 @@ class TestStl : public TestFixture {
               "        ++it1;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:6] -> [test.cpp:5]: (error) Comparison of iterators from containers 'l1' and 'l2'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:36]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n",
+                      errout_str());
 
         check("void foo()\n"
               "{\n"
-              "    std::list<int> l1;\n"
-              "    std::list<int> l2(10, 4);\n"
-              "    std::list<int>::iterator it1 = l1.begin();\n"
-              "    std::list<int>::iterator it2 = l2.find(4);\n"
+              "    std::set<int> l1;\n"
+              "    std::set<int> l2(10, 4);\n"
+              "    std::set<int>::iterator it1 = l1.begin();\n"
+              "    std::set<int>::iterator it2 = l2.find(4);\n"
               "    while (it1 != it2)\n"
               "    {\n"
               "        ++it1;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:6] -> [test.cpp:5]: (error) Comparison of iterators from containers 'l1' and 'l2'.\n", errout.str());
-
+        ASSERT_EQUALS("[test.cpp:5:35]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n",
+                      errout_str());
     }
 
     void iterator17() {
@@ -808,7 +1568,8 @@ class TestStl : public TestFixture {
               "        ++it1;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:5] -> [test.cpp:7]: (error) Comparison of iterators from containers 'l1' and 'l2'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:36]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n",
+                      errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -822,7 +1583,7 @@ class TestStl : public TestFixture {
               "    }\n"
               "    it2 = l2.end();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -837,7 +1598,7 @@ class TestStl : public TestFixture {
               "        ++it1;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -853,45 +1614,40 @@ class TestStl : public TestFixture {
               "        ++it1;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:10] -> [test.cpp:5] -> [test.cpp:9]: (error) Comparison of iterators from containers 'l1' and 'l2'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:36]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n",
+                      errout_str());
     }
 
     void iterator18() {
-        check("void foo()\n"
+        check("void foo(std::list<int> l1, std::list<int> l2)\n"
               "{\n"
-              "    std::list<int> l1;\n"
-              "    std::list<int> l2;\n"
               "    std::list<int>::iterator it1 = l1.begin();\n"
               "    std::list<int>::iterator it2 = l1.end();\n"
               "    while (++it1 != --it2)\n"
               "    {\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void foo()\n"
+        check("void foo(std::list<int> l1, std::list<int> l2)\n"
               "{\n"
-              "    std::list<int> l1;\n"
-              "    std::list<int> l2;\n"
               "    std::list<int>::iterator it1 = l1.begin();\n"
               "    std::list<int>::iterator it2 = l1.end();\n"
               "    while (it1++ != --it2)\n"
               "    {\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void foo()\n"
+        check("void foo(std::list<int> l1, std::list<int> l2)\n"
               "{\n"
-              "    std::list<int> l1;\n"
-              "    std::list<int> l2;\n"
               "    std::list<int>::iterator it1 = l1.begin();\n"
               "    std::list<int>::iterator it2 = l1.end();\n"
               "    if (--it2 > it1++)\n"
               "    {\n"
               "    }\n"
               "}");
-        TODO_ASSERT_EQUALS("", "[test.cpp:7]: (error) Dangerous comparison using operator< on iterator.\n", errout.str());
+        TODO_ASSERT_EQUALS("", "[test.cpp:5:15]: (error) Dangerous comparison using operator< on iterator. [stlBoundaries]\n", errout_str());
     }
 
     void iterator19() {
@@ -906,7 +1662,9 @@ class TestStl : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:4]: (error) Same iterator is used with containers 'l1' that are defined in different scopes.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:7:13] -> [test.cpp:4:36]: (error) Same iterator is used with containers 'l1' that are temporaries or defined in different scopes. [iterators3]\n",
+            errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -919,9 +1677,11 @@ class TestStl : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:4]: (error) Same iterator is used with containers 'l1' that are defined in different scopes.\n",
-                           "[test.cpp:7] -> [test.cpp:4]: (error) Same iterator is used with containers 'l1' that are defined in different scopes.\n[test.cpp:7]: (error) Dangerous comparison using operator< on iterator.\n",
-                           errout.str());
+        TODO_ASSERT_EQUALS(
+            "[test.cpp:7] -> [test.cpp:4]: (error) Same iterator is used with containers 'l1' that are defined in different scopes.\n",
+            "[test.cpp:7:19] -> [test.cpp:7:13]: (error) Same iterator is used with containers 'l1' that are temporaries or defined in different scopes. [iterators3]\n"
+            "[test.cpp:7:22]: (error) Dangerous comparison using operator< on iterator. [stlBoundaries]\n",
+            errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -935,7 +1695,9 @@ class TestStl : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:4] -> [test.cpp:7]: (error) Comparison of iterators from containers 'l1' that are defined in different scopes.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:8:13] -> [test.cpp:4:36]: (error) Same iterator is used with containers 'l1' that are temporaries or defined in different scopes. [iterators3]\n",
+            errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -949,12 +1711,35 @@ class TestStl : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:4] -> [test.cpp:7]: (error) Comparison of iterators from containers 'l1' that are defined in different scopes.\n", errout.str());
-
-    }
+        ASSERT_EQUALS(
+            "[test.cpp:8:13] -> [test.cpp:7:40]: (error) Same iterator is used with containers 'l1' that are temporaries or defined in different scopes. [iterators3]\n",
+            errout_str());
 
-    void iterator20() {
-        check("void foo()\n"
+        check("std::set<int> g() {\n"
+              "    static const std::set<int> s = {1};\n"
+              "    return s;\n"
+              "}\n"
+              "void f() {\n"
+              "    if (g().find(2) == g().end()) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:6:17] -> [test.cpp:6:10]: (error) Same iterator is used with containers 'g()' that are temporaries or defined in different scopes. [iterators3]\n",
+            errout_str());
+
+        check("std::set<long> f() {\n" // #5804
+              "    std::set<long> s;\n"
+              "    return s;\n"
+              "}\n"
+              "void g() {\n"
+              "    for (std::set<long>::iterator it = f().begin(); it != f().end(); ++it) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:6:53] -> [test.cpp:6:41]: (error) Same iterator is used with containers 'f()' that are temporaries or defined in different scopes. [iterators3]\n",
+            errout_str());
+    }
+
+    void iterator20() {
+        check("void foo()\n"
               "{\n"
               "    std::list<int> l1;\n"
               "    std::list<int> l2;\n"
@@ -966,7 +1751,8 @@ class TestStl : public TestFixture {
               "        ++it1;\n"
               "    }\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:7]: (error) Same iterator is used with different containers 'l2' and 'l1'.\n", "", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:36]: (error) Iterators of different containers 'l2' and 'l1' are used together. [mismatchingContainers]\n",
+                      errout_str());
 
         check("std::list<int> l3;\n"
               "std::list<int>::iterator bar()\n"
@@ -985,7 +1771,7 @@ class TestStl : public TestFixture {
               "        ++it1;\n"
               "    }\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:13] -> [test.cpp:10] -> [test.cpp:11]: (error) Comparison of iterators from containers 'l1' and 'l2'.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:13] -> [test.cpp:10] -> [test.cpp:11]: (error) Comparison of iterators from containers 'l1' and 'l2'.\n", "", errout_str());
 
     }
 
@@ -1003,8 +1789,9 @@ class TestStl : public TestFixture {
               "    {\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:6] -> [test.cpp:5]: (error) Comparison of iterators from containers 'l1' and 'l2'.\n"
-                      "[test.cpp:10] -> [test.cpp:6] -> [test.cpp:5]: (error) Comparison of iterators from containers 'l2' and 'l1'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:36]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n"
+                      "[test.cpp:6:36]: (error) Iterators of different containers 'l2' and 'l1' are used together. [mismatchingContainers]\n",
+                      errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -1016,8 +1803,195 @@ class TestStl : public TestFixture {
               "    {\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:6] -> [test.cpp:5]: (error) Comparison of iterators from containers 'l1' and 'l2'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:36]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n"
+                      "[test.cpp:5:36]: (error) Iterators of different containers 'l1' and 'l2' are used together. [mismatchingContainers]\n", // duplicate
+                      errout_str());
+    }
+
+    void iterator22() { // #7107
+        check("void foo() {\n"
+              "    std::list<int> &l = x.l;\n"
+              "    std::list<int>::iterator it = l.find(123);\n"
+              "    x.l.erase(it);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void iterator23() { // #9550
+        check("struct A {\n"
+              "    struct B {\n"
+              "        bool operator==(const A::B& b) const;\n"
+              "        int x;\n"
+              "        int y;\n"
+              "        int z;\n"
+              "    };\n"
+              "};\n"
+              "bool A::B::operator==(const A::B& b) const {\n"
+              "    return std::tie(x, y, z) == std::tie(b.x, b.y, b.z);\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void iterator24() {
+        // #9556
+        check("void f(int a, int b) {\n"
+              "  if (&a == &b) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(int a, int b) {\n"
+              "  if (std::for_each(&a, &b + 1, [](auto) {})) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:22]: (error) Iterators of different containers 'a' and 'b' are used together. [mismatchingContainers]\n",
+                      errout_str());
+
+        check("void f(int a, int b) {\n"
+              "  if (std::for_each(&a, &b, [](auto) {})) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:22]: (error) Iterators of different containers 'a' and 'b' are used together. [mismatchingContainers]\n",
+                      errout_str());
+
+        check("void f(int a) {\n"
+              "  if (std::for_each(&a, &a, [](auto) {})) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:21]: (style) Same iterators expression are used for algorithm. [sameIteratorExpression]\n", errout_str());
+
+        check("void f(int a) {\n"
+              "  if (std::for_each(&a, &a + 1, [](auto) {})) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void iterator25() {
+        // #9742
+        check("struct S {\n"
+              "  std::vector<int>& v;\n"
+              "};\n"
+              "struct T {\n"
+              "    bool operator()(const S& lhs, const S& rhs) const {\n"
+              "        return &lhs.v != &rhs.v;\n"
+              "    }\n"
+              "};");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void iterator26() { // #9176
+        check(
+            "#include <map>\n"
+            "int main()\n"
+            "{"
+            "  std::map<char const*, int> m{ {\"a\", 1} };\n"
+            "  if (auto iter = m.find(\"x\"); iter != m.end()) {\n"
+            "    return iter->second;\n"
+            "  }\n"
+            "  return 0;\n"
+            "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void iterator27() {
+        // #10378
+        check("struct A {\n"
+              "    int a;\n"
+              "    int b;\n"
+              "};\n"
+              "int f(std::map<int, A> m) {\n"
+              "    auto it =  m.find( 1 );\n"
+              "    const int a( it == m.cend() ? 0 : it->second.a );\n"
+              "    const int b( it == m.cend() ? 0 : it->second.b );\n"
+              "    return a + b;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void iterator28()
+    {
+        // #10450
+        check("struct S {\n"
+              "    struct Private {\n"
+              "        std::list<int> l;\n"
+              "    };\n"
+              "    std::unique_ptr<Private> p;\n"
+              "    int foo();\n"
+              "};\n"
+              "int S::foo() {\n"
+              "    for(auto iter = p->l.begin(); iter != p->l.end(); ++iter) {\n"
+              "        if(*iter == 1) {\n"
+              "            p->l.erase(iter);\n"
+              "            return 1;\n"
+              "        }\n"
+              "    }\n"
+              "    return 0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:10:24]: (style) Consider using std::find_if algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
+    }
+
+    void iterator29()
+    {
+        // #11511
+        check("std::vector<int>& g();\n"
+              "void f() {\n"
+              "    auto v = g();\n"
+              "    auto it = g().begin();\n"
+              "    while (it != g().end())\n"
+              "        it = v.erase(it);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:14]: (error) Iterator 'it' referring to container 'g()' is used with container 'v'. [mismatchingContainerIterator]\n", errout_str());
+
+        check("std::vector<int>& g(int);\n"
+              "void f(int i, int j) {\n"
+              "    auto& r = g(i);\n"
+              "    auto it = g(j).begin();\n"
+              "    while (it != g(j).end())\n"
+              "        it = r.erase(it);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:14]: (error) Iterator 'it' referring to container 'g(j)' is used with container 'r'. [mismatchingContainerIterator]\n", errout_str());
+
+        check("std::vector<int>& g();\n"
+              "void f() {\n"
+              "    auto& r = g();\n"
+              "    auto it = g().begin();\n"
+              "    while (it != g().end())\n"
+              "        it = r.erase(it);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void iterator30()
+    {
+        check("struct S {\n" // #12641
+              "    bool b;\n"
+              "    std::list<int> A, B;\n"
+              "    void f();\n"
+              "};\n"
+              "void S::f() {\n"
+              "    std::list<int>::iterator i = (b ? B : A).begin();\n"
+              "    while (i != (b ? B : A).end()) {\n"
+              "        ++i;\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
 
+    void iterator31()
+    {
+        check("struct S {\n" // #13327
+              "    std::string a;\n"
+              "};\n"
+              "struct T {\n"
+              "    S s;\n"
+              "};\n"
+              "bool f(const S& s) {\n"
+              "    std::string b;\n"
+              "    return s.a.c_str() == b.c_str();\n"
+              "}\n"
+              "bool g(const T& t) {\n"
+              "    std::string b;\n"
+              "    return t.s.a.c_str() == b.c_str();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:9:13]: (error) Iterators of different containers 's.a' and 'b' are used together. [mismatchingContainers]\n"
+                      "[test.cpp:13:15]: (error) Iterators of different containers 't.s.a' and 'b' are used together. [mismatchingContainers]\n",
+                      errout_str());
     }
 
     void iteratorExpression() {
@@ -1025,22 +1999,25 @@ class TestStl : public TestFixture {
               "std::vector<int>& g();\n"
               "void foo() {\n"
               "    (void)std::find(f().begin(), g().end(), 0);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Iterators to containers from different expressions 'f()' and 'g()' are used together.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:22]: (error) Iterators of different containers 'f()' and 'g()' are used together. [mismatchingContainers]\n",
+                      errout_str());
 
         check("std::vector<int>& f();\n"
               "std::vector<int>& g();\n"
               "void foo() {\n"
               "    if(f().begin() == g().end()) {}\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Iterators to containers from different expressions 'f()' and 'g()' are used together.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Iterators of different containers 'f()' and 'g()' are used together. [mismatchingContainers]\n",
+                      errout_str());
 
         check("std::vector<int>& f();\n"
               "std::vector<int>& g();\n"
               "void foo() {\n"
               "    auto size = f().end() - g().begin();\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Iterators to containers from different expressions 'f()' and 'g()' are used together.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:18]: (error) Iterators of different containers 'f()' and 'g()' are used together. [mismatchingContainers]\n",
+                      errout_str());
 
         check("struct A {\n"
               "    std::vector<int>& f();\n"
@@ -1048,8 +2025,10 @@ class TestStl : public TestFixture {
               "};\n"
               "void foo() {\n"
               "    (void)std::find(A().f().begin(), A().g().end(), 0);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:6]: (warning) Iterators to containers from different expressions 'A().f()' and 'A().g()' are used together.\n", errout.str());
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:6:26]: (error) Iterators of different containers 'A().f()' and 'A().g()' are used together. [mismatchingContainers]\n",
+            errout_str());
 
         check("struct A {\n"
               "    std::vector<int>& f();\n"
@@ -1057,15 +2036,17 @@ class TestStl : public TestFixture {
               "};\n"
               "void foo() {\n"
               "    (void)std::find(A{} .f().begin(), A{} .g().end(), 0);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:6]: (warning) Iterators to containers from different expressions 'A{}.f()' and 'A{}.g()' are used together.\n", errout.str());
+              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:6:27]: (error) Iterators of different containers 'A{}.f()' and 'A{}.g()' are used together. [mismatchingContainers]\n",
+            errout_str());
 
         check("std::vector<int>& f();\n"
               "std::vector<int>& g();\n"
               "void foo() {\n"
               "    (void)std::find(begin(f()), end(g()), 0);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (warning) Iterators to containers from different expressions 'f()' and 'g()' are used together.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:28]: (warning) Iterators to containers from different expressions 'f()' and 'g()' are used together. [mismatchingContainerExpression]\n", errout_str());
 
         check("struct A {\n"
               "    std::vector<int>& f();\n"
@@ -1073,26 +2054,25 @@ class TestStl : public TestFixture {
               "};\n"
               "void foo() {\n"
               "    (void)std::find(A().f().begin(), A().f().end(), 0);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("std::vector<int>& f();\n"
               "std::vector<int>& g();\n"
               "void foo() {\n"
               "    if(bar(f().begin()) == g().end()) {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("std::vector<int>& f();\n"
-              "std::vector<int>& g();\n"
               "void foo() {\n"
-              "    auto it = f().end();\n"
-              "    f().begin() - it\n"
-              "    f().begin()+1 - it\n"
-              "    f().begin() - (it + 1)\n"
-              "    f().begin() - f().end()\n"
-              "    f().begin()+1 - f().end()\n"
-              "    f().begin() - (f().end() + 1)\n"
+              "    auto it = f().end() - 1;\n"
+              "    f().begin() - it;\n"
+              "    f().begin()+1 - it;\n"
+              "    f().begin() - (it + 1);\n"
+              "    f().begin() - f().end();\n"
+              "    f().begin()+1 - f().end();\n"
+              "    f().begin() - (f().end() + 1);\n"
               "    (void)std::find(f().begin(), it, 0);\n"
               "    (void)std::find(f().begin(), it + 1, 0);\n"
               "    (void)std::find(f().begin() + 1, it + 1, 0);\n"
@@ -1105,78 +2085,327 @@ class TestStl : public TestFixture {
               "    (void)std::find(begin(f()) + 1, end(f()), 0);\n"
               "    (void)std::find(begin(f()), end(f()) - 1, 0);\n"
               "    (void)std::find(begin(f()) + 1, end(f()) - 1, 0);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:9:30]: (error) Dereference of an invalid iterator: f().end()+1 [derefInvalidIterator]\n", errout_str());
 
         check("std::vector<int>& f();\n"
-              "std::vector<int>& g();\n"
               "void foo() {\n"
               "    if(f().begin() == f().end()) {}\n"
               "    if(f().begin() == f().end()+1) {}\n"
               "    if(f().begin()+1 == f().end()) {}\n"
               "    if(f().begin()+1 == f().end()+1) {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:32]: (error) Dereference of an invalid iterator: f().end()+1 [derefInvalidIterator]\n"
+                      "[test.cpp:6:34]: (error) Dereference of an invalid iterator: f().end()+1 [derefInvalidIterator]\n",
+                      errout_str());
+
+        check("std::vector<int>& f();\n"
+              "void foo() {\n"
+              "    if(std::begin(f()) == std::end(f())) {}\n"
+              "    if(std::begin(f()) == std::end(f())+1) {}\n"
+              "    if(std::begin(f())+1 == std::end(f())) {}\n"
+              "    if(std::begin(f())+1 == std::end(f())+1) {}\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:4:40]: (error) Dereference of an invalid iterator: std::end(f())+1 [derefInvalidIterator]\n"
+                      "[test.cpp:6:42]: (error) Dereference of an invalid iterator: std::end(f())+1 [derefInvalidIterator]\n",
+                      errout_str());
 
         check("template<int N>\n"
               "std::vector<int>& f();\n"
               "void foo() {\n"
               "    if(f<1>().begin() == f<1>().end()) {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  if (a.begin().x == b.begin().x) {}\n"
               "  if (begin(a).x == begin(b).x) {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f() {\n"
-              "  std::list<int*> a;\n"
-              "  std::list<int*> b;\n"
+        check("void f(std::list<int*> a, std::list<int*> b) {\n"
               "  if (*a.begin() == *b.begin()) {}\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    if(f().begin(1) == f().end()) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo(const uint8_t* data, const uint32_t dataLength) {\n"
+              "    const uint32_t minimumLength = sizeof(uint16_t) + sizeof(uint16_t);\n"
+              "    if (dataLength >= minimumLength) {\n"
+              "        char* payload = new char[dataLength - minimumLength];\n"
+              "        std::copy(&data[minimumLength], &data[dataLength], payload);\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool f(const std::vector<int>& a, const std::vector<int>& b) {\n" // #11469
+              "    return (a.begin() - a.end()) == (b.begin() - b.end());\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #11469
+              "    const std::vector<int>* vec() const { return &v; }\n"
+              "    const std::vector<int> v;\n"
+              "};\n"
+              "void f(const S& a, const S& b) {\n"
+              "    if (a.vec()->begin() - a.vec()->end() != b.vec()->begin() - b.vec()->end()) {}\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void iteratorSameExpression() {
         check("void f(std::vector<int> v) {\n"
               "    std::for_each(v.begin(), v.begin(), [](int){});\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same iterators expression are used for algorithm.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:26]: (style) Same iterators expression are used for algorithm. [sameIteratorExpression]\n", errout_str());
 
         check("std::vector<int>& g();\n"
               "void f() {\n"
               "    std::for_each(g().begin(), g().begin(), [](int){});\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Same iterators expression are used for algorithm.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:28]: (style) Same iterators expression are used for algorithm. [sameIteratorExpression]\n", errout_str());
 
         check("void f(std::vector<int> v) {\n"
               "    std::for_each(v.end(), v.end(), [](int){});\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same iterators expression are used for algorithm.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:24]: (style) Same iterators expression are used for algorithm. [sameIteratorExpression]\n", errout_str());
 
         check("std::vector<int>& g();\n"
               "void f() {\n"
               "    std::for_each(g().end(), g().end(), [](int){});\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Same iterators expression are used for algorithm.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:26]: (style) Same iterators expression are used for algorithm. [sameIteratorExpression]\n", errout_str());
 
         check("std::vector<int>::iterator g();\n"
               "void f(std::vector<int> v) {\n"
               "    std::for_each(g(), g(), [](int){});\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Same iterators expression are used for algorithm.\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:20]: (style) Same iterators expression are used for algorithm. [sameIteratorExpression]\n", errout_str());
 
         check("void f(std::vector<int>::iterator it) {\n"
               "    std::for_each(it, it, [](int){});\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:19]: (style) Same iterators expression are used for algorithm. [sameIteratorExpression]\n", errout_str());
+    }
+
+    void mismatchingContainerIterator() {
+        check("std::vector<int> to_vector(int value) {\n"
+              "    std::vector<int> a, b;\n"
+              "    a.insert(b.end(), value);\n"
+              "    return a;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Iterator 'b.end()' referring to container 'b' is used with container 'a'. [mismatchingContainerIterator]\n", errout_str());
+
+        check("std::vector<int> f(std::vector<int> a, std::vector<int> b) {\n"
+              "    a.erase(b.begin());\n"
+              "    return a;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:5]: (error) Iterator 'b.begin()' referring to container 'b' is used with container 'a'. [mismatchingContainerIterator]\n", errout_str());
+
+        // #9973
+        check("void f() {\n"
+              "    std::list<int> l1;\n"
+              "    std::list<int> l2;\n"
+              "    std::list<int>& l = l2;\n"
+              "    for (auto it = l.begin(); it != l.end(); ++it) {\n"
+              "        if (*it == 1) {\n"
+              "            l.erase(it);\n"
+              "            break;\n"
+              "        }\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:23]: (style) Consider using std::find_if algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
+
+        // #10012
+        check("struct a {\n"
+              "    int b;\n"
+              "    int end() { return b; }\n"
+              "};\n"
+              "void f(a c, a d) {\n"
+              "    if (c.end() == d.end()) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10467
+        check("void f(std::array<std::vector<int>, N>& A) {\n"
+              "  for (auto& a : A) {\n"
+              "    auto it = std::find_if(a.begin(), a.end(), \n"
+              "                           [](auto i) { return i == 0; });\n"
+              "    if (it != a.end()) {}\n"
+              "  }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10604
+        check("struct S {\n"
+              "    std::vector<int> v;\n"
+              "};\n"
+              "void f(S& s, int m) {\n"
+              "    s.v.erase(s.v.begin() + m);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11093
+        check("struct S {\n"
+              "    std::vector<int> v1, v2;\n"
+              "    void f(bool b) {\n"
+              "        std::vector<int>& v = b ? v1 : v2;\n"
+              "        v.erase(v.begin());\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #12377
+        check("void f(bool b) {\n"
+              "    std::vector<int> *pv;\n"
+              "    if (b) {\n"
+              "        std::vector<int>& r = get1();\n"
+              "        pv = &r;\n"
+              "    }\n"
+              "    else {\n"
+              "        std::vector<int>& r = get2();\n"
+              "        pv = &r;\n"
+              "    }\n"
+              "    std::vector<int>::iterator it = pv->begin();\n"
+              "    it = pv->erase(it, it + 2);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n"
+              "    std::vector<int> v;\n"
+              "    void f() {\n"
+              "        std::vector<int>* p = &v;\n"
+              "        p->insert(std::find(p->begin(), p->end(), 0), 1);\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n"
+              "    std::vector<int> v;\n"
+              "    void f(int i) {\n"
+              "        std::vector<int>* p = &v;\n"
+              "        if (p->size() > i)\n"
+              "            p->erase(p->begin() + i, p->end());\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11067
+        check("struct S {\n"
+              "    std::vector<int> v;\n"
+              "    std::list<std::vector<int>::const_iterator> li;\n"
+              "    void f();\n"
+              "};\n"
+              "void S::f() {\n"
+              "    v.erase(*li.begin());\n"
+              "    li.pop_front();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::set<std::string>& a, std::stack<std::set<std::string>::iterator>& b) {\n"
+              "    while (!b.empty()) {\n"
+              "        a.erase(b.top());\n"
+              "        b.pop();\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::vector<int>& a, std::vector<std::vector<int>::iterator>& b) {\n"
+              "    auto it = b.begin();\n"
+              "    a.erase(*it);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("namespace N {\n" // #12443
+              "    std::vector<int> v;\n"
+              "}\n"
+              "using namespace N;\n"
+              "void f() {\n"
+              "    auto it = std::find(v.begin(), v.end(), 0);\n"
+              "    if (it != N::v.end()) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(void* p) {\n" // #12445
+              "    std::vector<int>&v = *(std::vector<int>*)(p);\n"
+              "    v.erase(v.begin(), v.end());\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #13408
+        check("void f(const std::vector<int>& v) {\n"
+              "    for (const auto& i : v) {\n"
+              "        if (std::distance(&*v.cbegin(), &i)) {}\n"
+              "    }   \n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void eraseIteratorOutOfBounds() {
+        check("void f() {\n"
+              "    std::vector<int> v;\n"
+              "    v.erase(v.begin());\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:7]: (error) Calling function 'erase()' on the iterator 'v.begin()' which is out of bounds. [eraseIteratorOutOfBounds]\n", errout_str());
+
+        check("void f() {\n"
+              "    std::vector<int> v;\n"
+              "    v.erase(v.end());\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:7]: (error) Calling function 'erase()' on the iterator 'v.end()' which is out of bounds. [eraseIteratorOutOfBounds]\n", errout_str());
+
+        check("void f() {\n"
+              "    std::vector<int> v;\n"
+              "    auto it = v.begin();\n"
+              "    v.erase(it);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:7]: (error) Calling function 'erase()' on the iterator 'it' which is out of bounds. [eraseIteratorOutOfBounds]\n", errout_str());
+
+        check("void f() {\n"
+              "    std::vector<int> v{ 1, 2, 3 };\n"
+              "    auto it = v.end();\n"
+              "    v.erase(it);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:7]: (error) Calling function 'erase()' on the iterator 'it' which is out of bounds. [eraseIteratorOutOfBounds]\n", errout_str());
+
+        check("void f() {\n"
+              "    std::vector<int> v{ 1, 2, 3 };\n"
+              "    auto it = v.begin();\n"
+              "    v.erase(it);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    std::vector<int> v{ 1, 2, 3 };\n"
+              "    v.erase(v.end() - 1);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    std::vector<int> v{ 1, 2, 3 };\n"
+              "    v.erase(v.begin() - 1);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:7]: (error) Calling function 'erase()' on the iterator 'v.begin()-1' which is out of bounds. [eraseIteratorOutOfBounds]\n"
+                      "[test.cpp:3:23]: (error) Dereference of an invalid iterator: v.begin()-1 [derefInvalidIterator]\n",
+                      errout_str());
+
+        check("void f(std::vector<int>& v, std::vector<int>::iterator it) {\n"
+              "    if (it == v.end()) {}\n"
+              "    v.erase(it);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:7]: (warning) Either the condition 'it==v.end()' is redundant or function 'erase()' is called on the iterator 'it' which is out of bounds. [eraseIteratorOutOfBoundsCond]\n",
+                      errout_str());
+
+        check("void f() {\n"
+              "    std::vector<int> v;\n"
+              "    ((v).erase)(v.begin());\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Same iterators expression are used for algorithm.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (error) Calling function 'erase()' on the iterator 'v.begin()' which is out of bounds. [eraseIteratorOutOfBounds]\n",
+                      errout_str());
     }
 
     // Dereferencing invalid pointer
@@ -1188,8 +2417,8 @@ class TestStl : public TestFixture {
               "    iter = ints.begin() + 2;\n"
               "    ints.erase(iter);\n"
               "    std::cout << (*iter) << std::endl;\n"
-              "}", true);
-        TODO_ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:6] -> [test.cpp:3] -> [test.cpp:7]: (error) Using iterator to local container 'ints' that may be invalid.\n", "[test.cpp:5] -> [test.cpp:6] -> [test.cpp:3] -> [test.cpp:7]: (error, inconclusive) Using iterator to local container 'ints' that may be invalid.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        TODO_ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:6] -> [test.cpp:3] -> [test.cpp:7]: (error) Using iterator to local container 'ints' that may be invalid.\n", "[test.cpp:5:22] -> [test.cpp:6:10] -> [test.cpp:3:22] -> [test.cpp:7:20]: (error, inconclusive) Using iterator to local container 'ints' that may be invalid. [invalidContainer]\n", errout_str());
 
         // #6554 "False positive eraseDereference - erase in while() loop"
         check("typedef std::map<Packet> packetMap;\n"
@@ -1201,7 +2430,7 @@ class TestStl : public TestFixture {
               "        for (unsigned pos = 0; pos < buf.size(); ) {     }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #8509 Uniform initialization ignored for iterator
         check("void f() {\n"
@@ -1209,7 +2438,7 @@ class TestStl : public TestFixture {
               "  std::vector<int>::const_iterator iter {ints.cbegin()};\n"
               "  std::cout << (*iter) << std::endl;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void dereference_break() {  // #3644
@@ -1226,7 +2455,7 @@ class TestStl : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void dereference_member() {
@@ -1238,7 +2467,9 @@ class TestStl : public TestFixture {
               "    ints.erase(iter);\n"
               "    std::cout << iter->first << std::endl;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:6]: (error) Iterator 'iter' used after element has been erased.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:18] -> [test.cpp:6:5]: (error) Iterator 'iter' used after element has been erased. [eraseDereference]\n"
+                      "[test.cpp:6:10]: (error) Calling function 'erase()' on the iterator 'iter' which is out of bounds. [eraseIteratorOutOfBounds]\n",
+                      errout_str());
 
         // Reverse iterator
         check("void f()\n"
@@ -1249,7 +2480,9 @@ class TestStl : public TestFixture {
               "    ints.erase(iter);\n"
               "    std::cout << iter->first << std::endl;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7] -> [test.cpp:6]: (error) Iterator 'iter' used after element has been erased.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:18] -> [test.cpp:6:5]: (error) Iterator 'iter' used after element has been erased. [eraseDereference]\n"
+                      "[test.cpp:6:10]: (error) Calling function 'erase()' on the iterator 'iter' which is out of bounds. [eraseIteratorOutOfBounds]\n",
+                      errout_str());
     }
 
     void dereference_auto() {
@@ -1259,15 +2492,15 @@ class TestStl : public TestFixture {
               "    auto iter = ints.begin() + 2;\n"
               "    ints.erase(iter);\n"
               "    std::cout << (*iter) << std::endl;\n"
-              "}", true);
-        TODO_ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:5] -> [test.cpp:3] -> [test.cpp:6]: (error) Using iterator to local container 'ints' that may be invalid.\n", "[test.cpp:4] -> [test.cpp:5] -> [test.cpp:3] -> [test.cpp:6]: (error, inconclusive) Using iterator to local container 'ints' that may be invalid.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        TODO_ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:5] -> [test.cpp:3] -> [test.cpp:6]: (error) Using iterator to local container 'ints' that may be invalid.\n", "[test.cpp:4:27] -> [test.cpp:5:10] -> [test.cpp:3:22] -> [test.cpp:6:20]: (error, inconclusive) Using iterator to local container 'ints' that may be invalid. [invalidContainer]\n", errout_str());
 
         check("void f() {\n"
               "    auto x = *myList.begin();\n"
               "    myList.erase(x);\n"
               "    auto b = x.first;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("const CXXRecordDecl *CXXRecordDecl::getTemplateInstantiationPattern() const {\n"
               "    if (auto *TD = dyn_cast<ClassTemplateSpecializationDecl>(this)) {\n"
@@ -1275,7 +2508,7 @@ class TestStl : public TestFixture {
               "    }\n"
               "    return nullptr;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void STLSize() {
@@ -1287,44 +2520,46 @@ class TestStl : public TestFixture {
               "       foo[ii] = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) When ii==foo.size(), foo[ii] is out of bounds.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:6:11]: (error) Out of bounds access in expression 'foo[ii]' because 'foo' is empty. [containerOutOfBounds]\n",
+            errout_str());
 
         check("void foo(std::vector<int> foo) {\n"
               "    for (unsigned int ii = 0; ii <= foo.size(); ++ii) {\n"
               "       foo.at(ii) = 0;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) When ii==foo.size(), foo.at(ii) is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (error) When ii==foo.size(), foo.at(ii) is out of bounds. [stlOutOfBounds]\n", errout_str());
 
-        check("void foo(const std::string& foo) {\n"
+        check("void foo(std::string& foo) {\n"
               "    for (unsigned int ii = 0; ii <= foo.length(); ++ii) {\n"
               "       foo[ii] = 'x';\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) When ii==foo.size(), foo[ii] is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (error) When ii==foo.size(), foo[ii] is out of bounds. [stlOutOfBounds]\n", errout_str());
 
-        check("void foo(const std::string& foo, unsigned int ii) {\n"
+        check("void foo(std::string& foo, unsigned int ii) {\n"
               "    if (ii <= foo.length()) {\n"
               "       foo[ii] = 'x';\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) When ii==foo.size(), foo[ii] is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (error) When ii==foo.size(), foo[ii] is out of bounds. [stlOutOfBounds]\n", errout_str());
 
-        check("void foo(const std::string& foo, unsigned int ii) {\n"
+        check("void foo(std::string& foo, unsigned int ii) {\n"
               "    do {\n"
               "       foo[ii] = 'x';\n"
               "       ++i;\n"
               "    } while(ii <= foo.length());\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) When ii==foo.size(), foo[ii] is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (error) When ii==foo.size(), foo[ii] is out of bounds. [stlOutOfBounds]\n", errout_str());
 
-        check("void foo(const std::string& foo, unsigned int ii) {\n"
+        check("void foo(std::string& foo, unsigned int ii) {\n"
               "    if (anything()) {\n"
               "    } else if (ii <= foo.length()) {\n"
               "       foo[ii] = 'x';\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) When ii==foo.size(), foo[ii] is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:11]: (error) When ii==foo.size(), foo[ii] is out of bounds. [stlOutOfBounds]\n", errout_str());
 
         check("void foo()\n"
               "{\n"
@@ -1336,12 +2571,19 @@ class TestStl : public TestFixture {
               "    int ii = 0;\n"
               "    foo[ii] = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    for (B b : D()) {}\n" // Don't crash on range-based for-loop
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo(std::vector<int> foo) {\n"
+              "    for (unsigned int ii = 0; ii <= foo.size() + 1; ++ii) {\n"
+              "       foo.at(ii) = 0;\n"
+              "    }\n"
+              "}");
+        TODO_ASSERT_EQUALS("[test.cpp:3:11]: (error) When ii==foo.size(), foo.at(ii) is out of bounds. [stlOutOfBounds]\n", "", errout_str());
     }
 
     void STLSizeNoErr() {
@@ -1354,7 +2596,7 @@ class TestStl : public TestFixture {
                   "       foo[ii] = 0;\n"
                   "    }\n"
                   "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -1365,7 +2607,7 @@ class TestStl : public TestFixture {
                   "    {\n"
                   "    }\n"
                   "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -1383,7 +2625,9 @@ class TestStl : public TestFixture {
                   "        }\n"
                   "    }\n"
                   "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS(
+                "[test.cpp:11:16]: (error) Out of bounds access in expression 'foo[ii]' because 'foo' is empty. [containerOutOfBounds]\n",
+                errout_str());
         }
 
         {
@@ -1392,7 +2636,16 @@ class TestStl : public TestFixture {
                   "    for (int i = 5; i <= data.size(); i++)\n"
                   "        data[i] = 0;\n"
                   "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        {
+            check("void foo(std::vector<int> foo) {\n"
+                  "    for (unsigned int ii = 0; ii <= foo.size() - 1; ++ii) {\n"
+                  "       foo.at(ii) = 0;\n"
+                  "    }\n"
+                  "}");
+            ASSERT_EQUALS("", errout_str());
         }
     }
 
@@ -1400,18 +2653,82 @@ class TestStl : public TestFixture {
         check("void f(const std::vector<int> &v) {\n"
               "  v[-11] = 123;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Array index -11 is out of bounds.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:3]: (error) Array index -11 is out of bounds. [negativeContainerIndex]\n", errout_str());
 
         check("int f(int x, const std::vector<int>& a) {\n"
               "    if (!(x < 5))\n"
               "        return a[x - 5];\n"
               "    else\n"
               "        return a[4 - x];\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::array<int,6> values;\n"
+              "int get_value();\n"
+              "int compute() {\n"
+              "    int i = get_value();\n"
+              "    if( i < 0 || i > 5)\n"
+              "        return -1;\n"
+              "    int sum = 0;\n"
+              "    for( int j = i+1; j < 7; ++j)\n"
+              "        sum += values[j-1];\n"
+              "    return sum;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct B { virtual int g() { return 0; } };\n" // #11831
+              "struct C {\n"
+              "    int h() const { return b->g(); }\n"
+              "    B* b;\n"
+              "};\n"
+              "struct O {\n"
+              "    int f() const;\n"
+              "    std::vector<int> v;\n"
+              "    C c;\n"
+              "};\n"
+              "int O::f() const { return v[c.h() - 1]; }\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const std::vector<int>& v) {\n" // #13196
+              "    if (v.empty())\n"
+              "        return;\n"
+              "    int idx = -1;\n"
+              "    for (int i = 0; i < v.size(); ++i) {\n"
+              "        idx = i;\n"
+              "    }\n"
+              "    (void)v[idx];\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        Settings s = settings;
+        s.daca = true;
+
+        check("void f() {\n"
+              "    const char a[][5] = { \"1\", \"true\", \"on\", \"yes\" };\n"
+              "}\n", s);
+        ASSERT_EQUALS("", errout_str());
     }
 
+    void negativeIndexMultiline() {
+        setMultiline();
+        Settings s = settings;
+        s.verbose = true;
 
+        check("bool valid(int);\n" // #11697
+              "void f(int i, const std::vector<int>& v) {\n"
+              "    if (!valid(i))\n"
+              "        return;\n"
+              "    if (v[i]) {}\n"
+              "}\n"
+              "void g(const std::vector<int>& w) {\n"
+              "    f(-1, w);\n"
+              "}\n", s);
+        ASSERT_EQUALS("[test.cpp:5:9]: warning: Array index -1 is out of bounds. [negativeContainerIndex]\n"
+                      "[test.cpp:8:8]: note: Calling function 'f', 1st argument '-1' value is -1\n"
+                      "[test.cpp:3:9]: note: Assuming condition is false\n"
+                      "[test.cpp:5:9]: note: Negative array index\n",
+                      errout_str());
+    }
 
     void erase1() {
         check("void f()\n"
@@ -1424,8 +2741,8 @@ class TestStl : public TestFixture {
               "        foo.erase(it);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:5]: (error) Iterator 'it' used after element has been erased.\n"
-                      "[test.cpp:7] -> [test.cpp:8]: (error) Iterator 'it' used after element has been erased.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5] -> [test.cpp:5:18]: (error) Iterator 'it' used after element has been erased. [eraseDereference]\n"
+                      "[test.cpp:7:5] -> [test.cpp:8:18]: (error) Iterator 'it' used after element has been erased. [eraseDereference]\n", errout_str());
 
         check("void f(std::list<int> &ints)\n"
               "{\n"
@@ -1433,7 +2750,7 @@ class TestStl : public TestFixture {
               "    i = ints.erase(i);\n"
               "    *i = 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -1441,18 +2758,18 @@ class TestStl : public TestFixture {
               "    while (i != x.y.end())\n"
               "        i = x.y.erase(i);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #2101
-        check("void f(vector< list<int> > &ints, unsigned int i)\n"
+        check("void f(vector< std::list<int> > &ints, unsigned int i)\n"
               "{\n"
-              "    list<int>::iterator it;\n"
+              "    std::list<int>::iterator it;\n"
               "    for(it = ints[i].begin(); it != ints[i].end(); it++) {\n"
               "        if (*it % 2)\n"
               "            it = ints[i].erase(it);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void erase2() {
@@ -1465,7 +2782,7 @@ class TestStl : public TestFixture {
               "        foo.erase(it);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void erase3() {
@@ -1475,7 +2792,7 @@ class TestStl : public TestFixture {
               "    foo.erase(it->a);\n"
               "    if (it->b);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void erase4() {
@@ -1487,7 +2804,7 @@ class TestStl : public TestFixture {
               "        foo.erase(it);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:6]: (error) Iterator 'it' used after element has been erased.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5] -> [test.cpp:6:18]: (error) Iterator 'it' used after element has been erased. [eraseDereference]\n", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -1497,7 +2814,7 @@ class TestStl : public TestFixture {
               "        foo.erase(it);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:6]: (error) Iterator 'it' used after element has been erased.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5] -> [test.cpp:6:18]: (error) Iterator 'it' used after element has been erased. [eraseDereference]\n", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -1507,7 +2824,7 @@ class TestStl : public TestFixture {
               "        foo.erase(it);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:6]: (error) Iterator 'it' used after element has been erased.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5] -> [test.cpp:6:18]: (error) Iterator 'it' used after element has been erased. [eraseDereference]\n", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -1517,7 +2834,7 @@ class TestStl : public TestFixture {
               "        foo.erase(++it);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:6]: (error) Iterator 'it' used after element has been erased.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5] -> [test.cpp:6:18]: (error) Iterator 'it' used after element has been erased. [eraseDereference]\n", errout_str());
     }
 
     void erase5() {
@@ -1531,7 +2848,7 @@ class TestStl : public TestFixture {
               "            foo.erase(it);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:8]: (error) Iterator 'it' used after element has been erased.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5] -> [test.cpp:8:22]: (error) Iterator 'it' used after element has been erased. [eraseDereference]\n", errout_str());
     }
 
     void erase6() {
@@ -1544,7 +2861,7 @@ class TestStl : public TestFixture {
               "        vec.erase(it);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void eraseBreak() {
@@ -1557,7 +2874,7 @@ class TestStl : public TestFixture {
               "            break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (error) Iterator 'it' used after element has been erased.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5] -> [test.cpp:5:18]: (error) Iterator 'it' used after element has been erased. [eraseDereference]\n", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -1569,7 +2886,7 @@ class TestStl : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int x)\n"
               "{\n"
@@ -1580,7 +2897,7 @@ class TestStl : public TestFixture {
               "            return;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:5]: (error) Iterator 'it' used after element has been erased.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5] -> [test.cpp:5:18]: (error) Iterator 'it' used after element has been erased. [eraseDereference]\n", errout_str());
 
     }
 
@@ -1597,7 +2914,7 @@ class TestStl : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(std::map<uint32, uint32> my_map) {\n" // #7365
               "  std::map<uint32, uint32>::iterator itr = my_map.begin();\n"
@@ -1610,7 +2927,7 @@ class TestStl : public TestFixture {
               "    break;\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void eraseReturn1() {
@@ -1624,7 +2941,7 @@ class TestStl : public TestFixture {
               "        return;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void eraseReturn2() {
@@ -1644,7 +2961,7 @@ class TestStl : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void eraseReturn3() {
@@ -1663,7 +2980,7 @@ class TestStl : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -1673,13 +2990,16 @@ class TestStl : public TestFixture {
               "    {\n"
               "        if (a) {\n"
               "            if (b)\n"
-              "                foo.erase(it);\n"
+              "                foo.erase(it);\n" // <- TODO: erase shound't cause inconclusive valueflow
               "            else\n"
               "                *it = 0;\n"
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:7] -> [test.cpp:8] -> [test.cpp:8] -> [test.cpp:7] -> [test.cpp:5] -> [test.cpp:9] -> [test.cpp:3] -> [test.cpp:5]: (error) Using iterator to local container 'foo' that may be invalid.\n", errout.str());
+        TODO_ASSERT_EQUALS(
+            "[test.cpp:5] -> [test.cpp:7] -> [test.cpp:8] -> [test.cpp:8] -> [test.cpp:7] -> [test.cpp:5] -> [test.cpp:9] -> [test.cpp:3] -> [test.cpp:5]: (error) Using iterator to local container 'foo' that may be invalid.\n",
+            "[test.cpp:5:24] -> [test.cpp:7:13] -> [test.cpp:8:17] -> [test.cpp:8:17] -> [test.cpp:7:13] -> [test.cpp:5:31] -> [test.cpp:9:21] -> [test.cpp:3:22] -> [test.cpp:5:28]: (error, inconclusive) Using iterator to local container 'foo' that may be invalid. [invalidContainer]\n",
+            errout_str());
     }
 
     void eraseGoto() {
@@ -1692,7 +3012,7 @@ class TestStl : public TestFixture {
               "    }\n"
               "bar:\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void eraseAssign1() {
@@ -1704,15 +3024,15 @@ class TestStl : public TestFixture {
               "        it = foo.begin();\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void eraseAssign2() {
-        check("void f(list<int> &ints)\n"
+        check("void f(std::list<int> &ints)\n"
               "{\n"
-              "    for (list<int>::iterator it = ints.begin(); it != ints.end();) {\n"
+              "    for (std::list<int>::iterator it = ints.begin(); it != ints.end();) {\n"
               "        if (*it == 123) {\n"
-              "            list<int>::iterator copy = it;\n"
+              "            std::list<int>::iterator copy = it;\n"
               "            ++copy;\n"
               "            ints.erase(it);\n"
               "            it = copy;\n"
@@ -1722,7 +3042,7 @@ class TestStl : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void eraseAssign3() {
@@ -1731,7 +3051,7 @@ class TestStl : public TestFixture {
               "    std::list<int>::const_iterator j = (*i).begin();\n"
               "    cout << *j << endl;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void eraseAssign4() {
@@ -1740,14 +3060,14 @@ class TestStl : public TestFixture {
               "  it = data.erase(it);\n"
               "  it = data.erase(it);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(Data data) {\n"
               "  std::list<int>::const_iterator it = data.ints.begin();\n"
               "  it = data.ints.erase(it);\n"
               "  it = data.ints.erase(it);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void eraseAssignByFunctionCall() {
@@ -1756,7 +3076,7 @@ class TestStl : public TestFixture {
               "    bar(i);\n"
               "    cout << *i;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void eraseErase() {
@@ -1766,8 +3086,8 @@ class TestStl : public TestFixture {
               "    iter = ints.begin() + 2;\n"
               "    ints.erase(iter);\n"
               "    ints.erase(iter);\n"
-              "}", true);
-        TODO_ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:4] -> [test.cpp:5] -> [test.cpp:1] -> [test.cpp:6]: (error) Using iterator to local container 'ints' that may be invalid.\n", "[test.cpp:1] -> [test.cpp:4] -> [test.cpp:5] -> [test.cpp:1] -> [test.cpp:6]: (error, inconclusive) Using iterator to local container 'ints' that may be invalid.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        TODO_ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:4] -> [test.cpp:5] -> [test.cpp:1] -> [test.cpp:6]: (error) Using iterator to local container 'ints' that may be invalid.\n", "[test.cpp:1:31] -> [test.cpp:4:22] -> [test.cpp:5:10] -> [test.cpp:1:27] -> [test.cpp:6:16]: (error, inconclusive) Using iterator to local container 'ints' that may be invalid. [invalidContainer]\n", errout_str());
     }
 
     void eraseByValue() {
@@ -1779,22 +3099,21 @@ class TestStl : public TestFixture {
               "        foo.erase(*it);\n"
               "    }\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:6]: (error) Iterator 'it' becomes invalid when deleted by value from 'foo'\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:6]: (error) Iterator 'it' becomes invalid when deleted by value from 'foo'\n", "", errout_str());
 
         check("int f(std::set<int> foo) {\n"
               "    std::set<int>::iterator it = foo.begin();\n"
               "    foo.erase(*it);\n"
               "    return *it;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:3]: (error) Iterator 'it' used after element has been erased.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:12] -> [test.cpp:3:5]: (error) Iterator 'it' used after element has been erased. [eraseDereference]\n", errout_str());
 
-        check("void f()\n"
+        check("void f(std::set<int> foo)\n"
               "{\n"
-              "    std::set<int> foo;\n"
               "    std::set<int>::iterator it = foo.begin();\n"
               "    foo.erase(*it);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #5669
         check("void f() {\n"
@@ -1802,14 +3121,14 @@ class TestStl : public TestFixture {
               "    m_SetLoadedFactories.erase(*aIt);\n"
               "    m_SetLoadedFactories.erase(aIt);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(const std::list<int>& m_ImplementationMap) {\n"
               "    std::list<int>::iterator aIt = m_ImplementationMap.begin();\n"
               "    m_ImplementationMap.erase(*aIt);\n"
               "    m_ImplementationMap.erase(aIt);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Invalid iterator: aIt\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Invalid iterator: aIt [invalidIterator1]\n", errout_str());
 
         check("void f(const std::list<int>& m_ImplementationMap) {\n"
               "    std::list<int>::iterator aIt = m_ImplementationMap.begin();\n"
@@ -1817,7 +3136,7 @@ class TestStl : public TestFixture {
               "    m_ImplementationMap.erase(*bIt);\n"
               "    m_ImplementationMap.erase(aIt);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void eraseIf() {
@@ -1825,37 +3144,30 @@ class TestStl : public TestFixture {
         check("void func(std::list<std::string> strlist) {\n"
               "    for (std::list<std::string>::iterator str = strlist.begin(); str != strlist.end(); str++) {\n"
               "        if (func2(*str)) {\n"
-              "    	       strlist.erase(str);\n"
+              "            strlist.erase(str);\n"
               "            if (strlist.empty())\n"
               "                 return;\n"
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:4]: (error) Iterator 'str' used after element has been erased.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5] -> [test.cpp:4:26]: (error) Iterator 'str' used after element has been erased. [eraseDereference]\n", errout_str());
     }
 
     void eraseOnVector() {
-        check("void f(const std::vector<int>& m_ImplementationMap) {\n"
-              "    std::vector<int>::iterator aIt = m_ImplementationMap.begin();\n"
-              "    m_ImplementationMap.erase(something(unknown));\n" // All iterators become invalidated when erasing from std::vector
-              "    m_ImplementationMap.erase(aIt);\n"
-              "}");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:2] -> [test.cpp:3] -> [test.cpp:1] -> [test.cpp:4]: (error) Using iterator to local container 'm_ImplementationMap' that may be invalid.\n", errout.str());
-
-        check("void f(const std::vector<int>& m_ImplementationMap) {\n"
-              "    std::vector<int>::iterator aIt = m_ImplementationMap.begin();\n"
-              "    m_ImplementationMap.erase(*aIt);\n" // All iterators become invalidated when erasing from std::vector
-              "    m_ImplementationMap.erase(aIt);\n"
+        check("void f(std::vector<int>& v) {\n"
+              "    std::vector<int>::iterator aIt = v.begin();\n"
+              "    v.erase(something(unknown));\n" // All iterators become invalidated when erasing from std::vector
+              "    v.erase(aIt);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:2] -> [test.cpp:3] -> [test.cpp:1] -> [test.cpp:4]: (error) Using iterator to local container 'm_ImplementationMap' that may be invalid.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:27] -> [test.cpp:2:45] -> [test.cpp:3:7] -> [test.cpp:1:26] -> [test.cpp:4:13]: (error) Using iterator to local container 'v' that may be invalid. [invalidContainer]\n", errout_str());
 
-        check("void f(const std::vector<int>& m_ImplementationMap) {\n"
-              "    std::vector<int>::iterator aIt = m_ImplementationMap.begin();\n"
-              "    std::vector<int>::iterator bIt = m_ImplementationMap.begin();\n"
-              "    m_ImplementationMap.erase(*bIt);\n" // All iterators become invalidated when erasing from std::vector
-              "    aIt = m_ImplementationMap.erase(aIt);\n"
+        check("void f(std::vector<int>& v) {\n"
+              "    std::vector<int>::iterator aIt = v.begin();\n"
+              "    std::vector<int>::iterator bIt = v.begin();\n"
+              "    v.erase(bIt);\n" // All iterators become invalidated when erasing from std::vector
+              "    aIt = v.erase(aIt);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:2] -> [test.cpp:4] -> [test.cpp:1] -> [test.cpp:5]: (error) Using iterator to local container 'm_ImplementationMap' that may be invalid.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:27] -> [test.cpp:2:45] -> [test.cpp:4:7] -> [test.cpp:1:26] -> [test.cpp:5:19]: (error) Using iterator to local container 'v' that may be invalid. [invalidContainer]\n", errout_str());
     }
 
     void pushback1() {
@@ -1865,7 +3177,7 @@ class TestStl : public TestFixture {
               "    foo.push_back(123);\n"
               "    *it;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:3] -> [test.cpp:4] -> [test.cpp:1] -> [test.cpp:5]: (error) Using iterator to local container 'foo' that may be invalid.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:35] -> [test.cpp:3:52] -> [test.cpp:4:9] -> [test.cpp:1:32] -> [test.cpp:5:6]: (error) Using iterator to local container 'foo' that may be invalid. [invalidContainer]\n", errout_str());
     }
 
     void pushback2() {
@@ -1878,7 +3190,7 @@ class TestStl : public TestFixture {
               "        *it = 456;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void pushback3() {
@@ -1892,7 +3204,7 @@ class TestStl : public TestFixture {
               "        foo.push_back(123);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:6] -> [test.cpp:8] -> [test.cpp:3] -> [test.cpp:6]: (error) Using iterator to local container 'foo' that may be invalid.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:24] -> [test.cpp:6:31] -> [test.cpp:8:13] -> [test.cpp:3:22] -> [test.cpp:6:28]: (error) Using iterator to local container 'foo' that may be invalid. [invalidContainer]\n", errout_str());
     }
 
     void pushback4() {
@@ -1904,7 +3216,7 @@ class TestStl : public TestFixture {
               "    ints.push_back(2);\n"
               "    *first;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:6] -> [test.cpp:3] -> [test.cpp:7]: (error) Using pointer to local variable 'ints' that may be invalid.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:18] -> [test.cpp:6:10] -> [test.cpp:3:22] -> [test.cpp:7:6]: (error) Using pointer to local variable 'ints' that may be invalid. [invalidContainer]\n", errout_str());
     }
 
     void pushback5() {
@@ -1921,7 +3233,7 @@ class TestStl : public TestFixture {
               "        v.push_back(*i);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void pushback6() {
@@ -1937,7 +3249,7 @@ class TestStl : public TestFixture {
               "            v.push_back(10);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:8] -> [test.cpp:8] -> [test.cpp:6] -> [test.cpp:9] -> [test.cpp:3] -> [test.cpp:6]: (error) Using iterator to local container 'v' that may be invalid.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:49] -> [test.cpp:8:17] -> [test.cpp:8:17] -> [test.cpp:6:56] -> [test.cpp:9:15] -> [test.cpp:3:22] -> [test.cpp:6:53]: (error) Using iterator to local container 'v' that may be invalid. [invalidContainer]\n", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -1950,7 +3262,7 @@ class TestStl : public TestFixture {
               "            v.push_back(10);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:8] -> [test.cpp:8] -> [test.cpp:6] -> [test.cpp:9] -> [test.cpp:3] -> [test.cpp:6]: (error) Using iterator to local container 'v' that may be invalid.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:49] -> [test.cpp:8:17] -> [test.cpp:8:17] -> [test.cpp:6:56] -> [test.cpp:9:15] -> [test.cpp:3:22] -> [test.cpp:6:53]: (error) Using iterator to local container 'v' that may be invalid. [invalidContainer]\n", errout_str());
     }
 
     void pushback7() {
@@ -1964,7 +3276,7 @@ class TestStl : public TestFixture {
               "        foo.push_back(123);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:6] -> [test.cpp:8] -> [test.cpp:3] -> [test.cpp:6]: (error) Using iterator to local container 'foo' that may be invalid.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:24] -> [test.cpp:6:31] -> [test.cpp:8:13] -> [test.cpp:3:22] -> [test.cpp:6:28]: (error) Using iterator to local container 'foo' that may be invalid. [invalidContainer]\n", errout_str());
     }
 
     void pushback8() {
@@ -1980,7 +3292,9 @@ class TestStl : public TestFixture {
               "        sum += *it;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:5] -> [test.cpp:3] -> [test.cpp:8]: (error) Using iterator to local container 'ints' that may be invalid.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:13]: (style) Consider using std::accumulate algorithm instead of a raw loop. [useStlAlgorithm]\n"
+                      "[test.cpp:4:52] -> [test.cpp:5:10] -> [test.cpp:3:22] -> [test.cpp:8:35]: (error) Using iterator to local container 'ints' that may be invalid. [invalidContainer]\n",
+                      errout_str());
     }
 
     void pushback9() {
@@ -2000,7 +3314,7 @@ class TestStl : public TestFixture {
               "        ++i;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void pushback10() {
@@ -2010,7 +3324,7 @@ class TestStl : public TestFixture {
               "    foo.reserve(100);\n"
               "    *it = 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:3] -> [test.cpp:4] -> [test.cpp:1] -> [test.cpp:5]: (error) Using iterator to local container 'foo' that may be invalid.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:29] -> [test.cpp:3:52] -> [test.cpp:4:9] -> [test.cpp:1:26] -> [test.cpp:5:6]: (error) Using iterator to local container 'foo' that may be invalid. [invalidContainer]\n", errout_str());
 
         // in loop
         check("void f()\n"
@@ -2023,7 +3337,7 @@ class TestStl : public TestFixture {
               "        foo.reserve(123);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:6] -> [test.cpp:8] -> [test.cpp:3] -> [test.cpp:6]: (error) Using iterator to local container 'foo' that may be invalid.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:24] -> [test.cpp:6:31] -> [test.cpp:8:13] -> [test.cpp:3:22] -> [test.cpp:6:28]: (error) Using iterator to local container 'foo' that may be invalid. [invalidContainer]\n", errout_str());
     }
 
     void pushback11() {
@@ -2037,7 +3351,7 @@ class TestStl : public TestFixture {
               "        ints.insert(it,0);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void pushback12() {
@@ -2053,7 +3367,9 @@ class TestStl : public TestFixture {
               "        *it;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:4] -> [test.cpp:6] -> [test.cpp:3] -> [test.cpp:4]: (error) Using iterator to local container 'vec' that may be invalid.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:4:54] -> [test.cpp:6:13] -> [test.cpp:3:25] -> [test.cpp:9:10]: (error, inconclusive) Using iterator to local container 'vec' that may be invalid. [invalidContainer]\n",
+            errout_str());
     }
 
     void pushback13() {
@@ -2063,7 +3379,7 @@ class TestStl : public TestFixture {
               "    const char *BufPtr = &FilenameBuffer[PreAppendSize];\n"
               "    return true;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void insert1() {
@@ -2073,7 +3389,7 @@ class TestStl : public TestFixture {
               "    ints.insert(ints.begin(), 1);\n"
               "    ++iter;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:3] -> [test.cpp:4] -> [test.cpp:1] -> [test.cpp:5]: (error) Using iterator to local container 'ints' that may be invalid.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:30] -> [test.cpp:3:49] -> [test.cpp:4:10] -> [test.cpp:1:26] -> [test.cpp:5:7]: (error) Using iterator to local container 'ints' that may be invalid. [invalidContainer]\n", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -2081,7 +3397,7 @@ class TestStl : public TestFixture {
               "    std::vector<int>::iterator iter = ints.begin();\n"
               "    ints.insert(iter, 1);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -2089,8 +3405,8 @@ class TestStl : public TestFixture {
               "    std::vector<int>::iterator iter = ints.begin();\n"
               "    ints.insert(iter, 1);\n"
               "    ints.insert(iter, 2);\n"
-              "}", true);
-        TODO_ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:5] -> [test.cpp:3] -> [test.cpp:6]: (error) Using iterator to local container 'ints' that may be invalid.\n", "[test.cpp:4] -> [test.cpp:5] -> [test.cpp:3] -> [test.cpp:6]: (error, inconclusive) Using iterator to local container 'ints' that may be invalid.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        TODO_ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:5] -> [test.cpp:3] -> [test.cpp:6]: (error) Using iterator to local container 'ints' that may be invalid.\n", "[test.cpp:4:49] -> [test.cpp:5:10] -> [test.cpp:3:22] -> [test.cpp:6:17]: (error, inconclusive) Using iterator to local container 'ints' that may be invalid. [invalidContainer]\n", errout_str());
 
         check("void* f(const std::vector<Bar>& bars) {\n"
               "    std::vector<Bar>::iterator i = bars.begin();\n"
@@ -2098,30 +3414,32 @@ class TestStl : public TestFixture {
               "    void* v = &i->foo;\n"
               "    return v;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:2] -> [test.cpp:3] -> [test.cpp:1] -> [test.cpp:4]: (error) Using iterator to local container 'bars' that may be invalid.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:37] -> [test.cpp:2:46] -> [test.cpp:3:10] -> [test.cpp:1:33] -> [test.cpp:4:16]: (error) Using iterator to local container 'bars' that may be invalid. [invalidContainer]\n", errout_str());
 
         check("Foo f(const std::vector<Bar>& bars) {\n"
               "    std::vector<Bar>::iterator i = bars.begin();\n"
               "    bars.insert(Bar());\n"
               "    return i->foo;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:2] -> [test.cpp:3] -> [test.cpp:1] -> [test.cpp:4]: (error) Using iterator to local container 'bars' that may be invalid.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:35] -> [test.cpp:2:46] -> [test.cpp:3:10] -> [test.cpp:1:31] -> [test.cpp:4:12]: (error) Using iterator to local container 'bars' that may be invalid. [invalidContainer]\n", errout_str());
 
         check("void f(const std::vector<Bar>& bars) {\n"
               "    for(std::vector<Bar>::iterator i = bars.begin(); i != bars.end(); ++i) {\n"
               "        i = bars.insert(i, bar);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
+        // TODO: This shouldn't be inconclusive
         check("void f(const std::vector<Bar>& bars) {\n"
               "    for(std::vector<Bar>::iterator i = bars.begin(); i != bars.end(); ++i) {\n"
               "        bars.insert(i, bar);\n"
               "        i = bars.insert(i, bar);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:2] -> [test.cpp:2] -> [test.cpp:3] -> [test.cpp:1] -> [test.cpp:2]: (error) Using iterator to local container 'bars' that may be invalid.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:36] -> [test.cpp:2:50] -> [test.cpp:3:14] -> [test.cpp:1:32] -> [test.cpp:4:25]: (error, inconclusive) Using iterator to local container 'bars' that may be invalid. [invalidContainer]\n", errout_str());
 
+        // TODO: This shouldn't be inconclusive
         check("void* f(const std::vector<Bar>& bars) {\n"
               "    std::vector<Bar>::iterator i = bars.begin();\n"
               "    bars.insert(i, Bar());\n"
@@ -2129,7 +3447,7 @@ class TestStl : public TestFixture {
               "    void* v = &i->foo;\n"
               "    return v;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:4] -> [test.cpp:1] -> [test.cpp:5] -> [test.cpp:4] -> [test.cpp:1] -> [test.cpp:6]: (error) Using pointer to local variable 'bars' that may be invalid.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:37] -> [test.cpp:2:46] -> [test.cpp:3:10] -> [test.cpp:1:33] -> [test.cpp:4:21]: (error, inconclusive) Using iterator to local container 'bars' that may be invalid. [invalidContainer]\n", errout_str());
     }
 
     void insert2() {
@@ -2141,7 +3459,7 @@ class TestStl : public TestFixture {
               "        break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(std::vector<int> &vec) {\n"
               "    for(std::vector<int>::iterator iter = vec.begin(); iter != vec.end(); ++iter)\n"
@@ -2152,20 +3470,40 @@ class TestStl : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
-    template<size_t n, typename T>
-    static size_t getArraylength(const T(&)[n]) {
-        return n;
-    }
+    void popback1() { // #11553
+        check("void f() {\n"
+              "    std::vector<int> v;\n"
+              "    v.pop_back();\n"
+              "    std::list<int> l;\n"
+              "    l.pop_front();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:15]: (error) Out of bounds access in expression 'v.pop_back()' because 'v' is empty. [containerOutOfBounds]\n"
+                      "[test.cpp:5:16]: (error) Out of bounds access in expression 'l.pop_front()' because 'l' is empty. [containerOutOfBounds]\n",
+                      errout_str());
 
-    void stlBoundaries1() {
+        check("void f(std::vector<int>& v) {\n"
+              "    if (v.empty()) {}\n"
+              "    v.pop_back();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:16] -> [test.cpp:3:15]: (warning) Either the condition 'v.empty()' is redundant or expression 'v.pop_back()' causes access out of bounds. [containerOutOfBounds]\n",
+                      errout_str());
+
+        check("void f(std::vector<int>& v) {\n"
+              "    v.pop_back();\n"
+              "    if (v.empty()) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void stlBoundaries1() {
         const std::string stlCont[] = {
             "list", "set", "multiset", "map", "multimap"
         };
 
-        for (size_t i = 0; i < getArraylength(stlCont); ++i) {
+        for (size_t i = 0; i < getArrayLength(stlCont); ++i) {
             check("void f()\n"
                   "{\n"
                   "    std::" + stlCont[i] + "<int>::iterator it;\n"
@@ -2173,21 +3511,21 @@ class TestStl : public TestFixture {
                   "        ;\n"
                   "}");
 
-            ASSERT_EQUALS_MSG("[test.cpp:4]: (error) Dangerous comparison using operator< on iterator.\n", errout.str(), stlCont[i]);
+            ASSERT_EQUALS_MSG("[test.cpp:4:25]: (error) Dangerous comparison using operator< on iterator. [stlBoundaries]\n", errout_str(), stlCont[i]);
         }
 
         check("void f() {\n"
               "    std::forward_list<int>::iterator it;\n"
               "    for (it = ab.begin(); ab.end() > it; ++it) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Dangerous comparison using operator< on iterator.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:36]: (error) Dangerous comparison using operator< on iterator. [stlBoundaries]\n", errout_str());
 
         // #5926 no FP Dangerous comparison using operator< on iterator on std::deque
         check("void f() {\n"
               "    std::deque<int>::iterator it;\n"
               "    for (it = ab.begin(); ab.end() > it; ++it) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void stlBoundaries2() {
@@ -2199,7 +3537,7 @@ class TestStl : public TestFixture {
               "    for (it = files.begin(); it < files.end(); it++) { };\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void stlBoundaries3() {
@@ -2213,13 +3551,13 @@ class TestStl : public TestFixture {
               "    }\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f() {\n"
               "    static set<Foo>::const_iterator current;\n"
               "    return 25 > current->bar;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Invalid iterator 'current' used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:17]: (error) Invalid iterator 'current' used. [eraseDereference]\n", errout_str());
     }
 
     void stlBoundaries4() {
@@ -2228,13 +3566,13 @@ class TestStl : public TestFixture {
               "    std::forward_list<std::vector<std::vector<int>>>::iterator it;\n"
               "    for (it = ab.begin(); ab.end() > it; ++it) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Dangerous comparison using operator< on iterator.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:36]: (error) Dangerous comparison using operator< on iterator. [stlBoundaries]\n", errout_str());
 
         // don't crash
         check("void f() {\n"
               "    if (list < 0) ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "    if (list < 0) {\n"
@@ -2242,7 +3580,7 @@ class TestStl : public TestFixture {
               "        for (it = ab.begin(); ab.end() > it; ++it) {}\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Dangerous comparison using operator< on iterator.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:40]: (error) Dangerous comparison using operator< on iterator. [stlBoundaries]\n", errout_str());
     }
 
     void stlBoundaries5() {
@@ -2250,8 +3588,8 @@ class TestStl : public TestFixture {
               "int foo() {\n"
               "    iterator i;\n"
               "    return i.foo();;\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("class iterator {\n"
               "    Class operator*();\n"
@@ -2261,8 +3599,8 @@ class TestStl : public TestFixture {
               "int foo() {\n"
               "    iterator i;\n"
               "    return i.foo();;\n"
-              "}", true);
-        ASSERT_EQUALS("[test.cpp:8]: (error, inconclusive) Invalid iterator 'i' used.\n", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:8:12]: (error, inconclusive) Invalid iterator 'i' used. [eraseDereference]\n", errout_str());
     }
 
     void stlBoundaries6() { // #7106
@@ -2272,8 +3610,8 @@ class TestStl : public TestFixture {
               "        {\n"
               "        }\n"
               "    }\n"
-              "}", true);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -2287,112 +3625,109 @@ class TestStl : public TestFixture {
               "{\n"
               "    if (s.find(12)) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked. [stlIfFind]\n", errout_str());
 
         // error (pointer)
         check("void f(std::set<int> *s)\n"
               "{\n"
               "    if ((*s).find(12)) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked. [stlIfFind]\n", errout_str());
 
         // error (pointer)
         check("void f(std::set<int> *s)\n"
               "{\n"
               "    if (s->find(12)) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked. [stlIfFind]\n", errout_str());
 
         // error (array-like pointer)
         check("void f(std::set<int> *s)\n"
               "{\n"
               "    if (s[0].find(12)) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked. [stlIfFind]\n", errout_str());
 
         // error (array)
         check("void f(std::set<int> s [10])\n"
               "{\n"
               "    if (s[0].find(12)) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked. [stlIfFind]\n", errout_str());
 
         // error (undefined length array)
         check("void f(std::set<int> s [])\n"
               "{\n"
               "    if (s[0].find(12)) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked. [stlIfFind]\n", errout_str());
 
         // error (vector)
         check("void f(std::vector<std::set<int> > s)\n"
               "{\n"
               "    if (s[0].find(12)) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked. [stlIfFind]\n", errout_str());
 
         // error (assignment)
         check("void f(std::set<int> s)\n"
               "{\n"
               "    if (a || (x = s.find(12))) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:19]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked. [stlIfFind]\n", errout_str());
 
         // ok (simple)
         check("void f(std::set<int> s)\n"
               "{\n"
               "    if (s.find(123) != s.end()) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ok (pointer)
         check("void f(std::set<int> *s)\n"
               "{\n"
               "    if ((*s).find(12) != s.end()) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ok (array-like pointer)
         check("void f(std::set<int> *s)\n"
               "{\n"
-              "    if (s[0].find(12) != s.end()) { }\n"
+              "    if (s[0].find(12) != s->end()) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ok (array)
         check("void f(std::set<int> s [10])\n"
               "{\n"
-              "    if (s[0].find(123) != s.end()) { }\n"
+              "    if (s[0].find(123) != s->end()) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ok (undefined length array)
         check("void f(std::set<int> s [])\n"
               "{\n"
-              "    if (s[0].find(123) != s.end()) { }\n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
-
-        // ok (vector)
-        check("void f(std::vector<std::set<int> > s)\n"
-              "{\n"
-              "    if (s[0].find(123) != s.end()) { }\n"
+              "    if (s[0].find(123) != s->end()) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ok (assignment)
         check("void f(std::set<int> s)\n"
               "{\n"
               "    if (a || (x = s.find(12)) != s.end()) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ok (dereference, #6402)
         check("void f(std::set<Foo> s) {\n"
               "    if (s.find(12).member) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
+        check("void f(std::set<int> s) {\n"
+              "    if (auto result = s.find(123); result != s.end()) {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // ---------------------------
         // std::find
@@ -2403,32 +3738,33 @@ class TestStl : public TestFixture {
               "{\n"
               "    if (std::find(a,b,c)) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (warning) Suspicious condition. The result of find() is an iterator, but it is not properly checked. [stlIfFind]\n", errout_str());
 
         // ok
         check("void f()\n"
               "{\n"
               "    if (std::find(a,b,c) != c) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ok (less than comparison, #6217)
         check("void f(std::vector<int> s)\n"
               "{\n"
               "    if (std::find(a, b, c) < d) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #3714 - segmentation fault for syntax error
-        check("void f() {\n"
-              "    if (()) { }\n"
-              "}");
+        ASSERT_THROW_INTERNAL(check("void f() {\n"
+                                    "    if (()) { }\n"
+                                    "}"),
+                              AST);
 
         // #3865
         check("void f() {\n"
               "    if ((std::find(a,b,c)) != b) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void if_str_find() {
@@ -2437,315 +3773,373 @@ class TestStl : public TestFixture {
               "{\n"
               "    if (s.find(\"abc\")) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Inefficient usage of string::find() in condition; string::starts_with() could be faster.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (performance) Inefficient usage of string::find() in condition; string::starts_with() could be faster. [stlIfStrFind]\n", errout_str());
 
         // error (pointer)
         check("void f(const std::string *s)\n"
               "{\n"
               "    if ((*s).find(\"abc\")) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Inefficient usage of string::find() in condition; string::starts_with() could be faster.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (performance) Inefficient usage of string::find() in condition; string::starts_with() could be faster. [stlIfStrFind]\n", errout_str());
 
         // error (pointer)
         check("void f(const std::string *s)\n"
               "{\n"
               "    if (s->find(\"abc\")) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Inefficient usage of string::find() in condition; string::starts_with() could be faster.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (performance) Inefficient usage of string::find() in condition; string::starts_with() could be faster. [stlIfStrFind]\n", errout_str());
 
         // error (vector)
         check("void f(const std::vector<std::string> &s)\n"
               "{\n"
               "    if (s[0].find(\"abc\")) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Inefficient usage of string::find() in condition; string::starts_with() could be faster.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (performance) Inefficient usage of string::find() in condition; string::starts_with() could be faster. [stlIfStrFind]\n", errout_str());
 
         // #3162
         check("void f(const std::string& s1, const std::string& s2)\n"
               "{\n"
               "    if ((!s1.empty()) && (0 == s1.find(s2))) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Inefficient usage of string::find() in condition; string::starts_with() could be faster.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:32]: (performance) Inefficient usage of string::find() in condition; string::starts_with() could be faster. [stlIfStrFind]\n", errout_str());
 
         // #4102
         check("void f(const std::string &define) {\n"
               "    if (define.find(\"=\") + 1U == define.size());\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(std::string a, std::string b) {\n"  // #4480
               "    if (a.find(\"<\") < b.find(\">\")) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(const std::string &s) {\n"
               "    if (foo(s.find(\"abc\"))) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #7349 - std::string::find_first_of
         check("void f(const std::string &s) {\n"
               "    if (s.find_first_of(\"abc\")==0) { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // # 10153
+        check("int main() {\n"
+              "  for (;;) {\n"
+              "    std::string line = getLine();\n"
+              "    if (line.find(\" GL_EXTENSIONS =\") < 12)\n"
+              "      return 1;\n"
+              "  }\n"
+              "  return 0;\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
 
     void size1() {
-        const char* code = "struct Fred {\n"
-                           "    void foo();\n"
-                           "    std::list<int> x;\n"
-                           "};\n"
-                           "void Fred::foo()\n"
-                           "{\n"
-                           "    if (x.size() == 0) {}\n"
-                           "}";
-        check(code, false, Standards::CPP03);
-        ASSERT_EQUALS("[test.cpp:7]: (performance) Possible inefficient checking for 'x' emptiness.\n", errout.str());
-        check(code);
-        ASSERT_EQUALS("", errout.str());
-
-        code = "std::list<int> x;\n"
-               "void f()\n"
-               "{\n"
-               "    if (x.size() == 0) {}\n"
-               "}";
-        check(code, false, Standards::CPP03);
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Possible inefficient checking for 'x' emptiness.\n", errout.str());
-        check(code);
-        ASSERT_EQUALS("", errout.str());
-
-        code = "void f()\n"
-               "{\n"
-               "    std::list<int> x;\n"
-               "    if (x.size() == 0) {}\n"
-               "}";
-        check(code, false, Standards::CPP03);
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Possible inefficient checking for 'x' emptiness.\n", errout.str());
-        check(code);
-        ASSERT_EQUALS("", errout.str());
-
-        code = "void f()\n"
-               "{\n"
-               "    std::list<int> x;\n"
-               "    if (0 == x.size()) {}\n"
-               "}";
-        check(code, false, Standards::CPP03);
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Possible inefficient checking for 'x' emptiness.\n", errout.str());
-        check(code);
-        ASSERT_EQUALS("", errout.str());
-
-        code = "void f()\n"
-               "{\n"
-               "    std::list<int> x;\n"
-               "    if (x.size() != 0) {}\n"
-               "}";
-        check(code, false, Standards::CPP03);
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Possible inefficient checking for 'x' emptiness.\n", errout.str());
-        check(code);
-        ASSERT_EQUALS("", errout.str());
-
-        code = "void f()\n"
-               "{\n"
-               "    std::list<int> x;\n"
-               "    if (0 != x.size()) {}\n"
-               "}";
-        check(code, false, Standards::CPP03);
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Possible inefficient checking for 'x' emptiness.\n", errout.str());
-        check(code);
-        ASSERT_EQUALS("", errout.str());
-
-        code = "void f()\n"
-               "{\n"
-               "    std::list<int> x;\n"
-               "    if (x.size() > 0) {}\n"
-               "}";
-        check(code, false, Standards::CPP03);
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Possible inefficient checking for 'x' emptiness.\n", errout.str());
-        check(code);
-        ASSERT_EQUALS("", errout.str());
-
-        code = "void f()\n"
-               "{\n"
-               "    std::list<int> x;\n"
-               "    if (0 < x.size()) {}\n"
-               "}";
-        check(code, false, Standards::CPP03);
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Possible inefficient checking for 'x' emptiness.\n", errout.str());
-        check(code);
-        ASSERT_EQUALS("", errout.str());
-
-        code =  "void f()\n"
-                "{\n"
-                "    std::list<int> x;\n"
-                "    if (x.size() >= 1) {}\n"
-                "}";
-        check(code, false, Standards::CPP03);
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Possible inefficient checking for 'x' emptiness.\n", errout.str());
-        check(code);
-        ASSERT_EQUALS("", errout.str());
-
-        code = "void f()\n"
-               "{\n"
-               "    std::list<int> x;\n"
-               "    if (x.size() < 1) {}\n"
-               "}";
-        check(code, false, Standards::CPP03);
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Possible inefficient checking for 'x' emptiness.\n", errout.str());
-        check(code);
-        ASSERT_EQUALS("", errout.str());
-
-        code = "void f()\n"
-               "{\n"
-               "    std::list<int> x;\n"
-               "    if (1 <= x.size()) {}\n"
-               "}";
-        check(code, false, Standards::CPP03);
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Possible inefficient checking for 'x' emptiness.\n", errout.str());
-        check(code);
-        ASSERT_EQUALS("", errout.str());
-
-        code = "void f()\n"
-               "{\n"
-               "    std::list<int> x;\n"
-               "    if (1 > x.size()) {}\n"
-               "}";
-        check(code, false, Standards::CPP03);
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Possible inefficient checking for 'x' emptiness.\n", errout.str());
-        check(code);
-        ASSERT_EQUALS("", errout.str());
-
-        code = "void f()\n"
-               "{\n"
-               "    std::list<int> x;\n"
-               "    if (x.size()) {}\n"
-               "}";
-        check(code, false, Standards::CPP03);
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Possible inefficient checking for 'x' emptiness.\n", errout.str());
-        check(code);
-        ASSERT_EQUALS("", errout.str());
-
-        code = "void f()\n"
-               "{\n"
-               "    std::list<int> x;\n"
-               "    if (!x.size()) {}\n"
-               "}";
-        check(code, false, Standards::CPP03);
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Possible inefficient checking for 'x' emptiness.\n", errout.str());
-        check(code);
-        ASSERT_EQUALS("", errout.str());
+        {
+            const char code[] = "struct Fred {\n"
+                                "    void foo();\n"
+                                "    std::list<int> x;\n"
+                                "};\n"
+                                "void Fred::foo()\n"
+                                "{\n"
+                                "    if (x.size() == 0) {}\n"
+                                "}";
+            check(code, settingsCpp03);
+            ASSERT_EQUALS("[test.cpp:7:9]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
+            check(code);
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        {
+            const char code[] = "std::list<int> x;\n"
+                                "void f()\n"
+                                "{\n"
+                                "    if (x.size() == 0) {}\n"
+                                "}";
+            check(code, settingsCpp03);
+            ASSERT_EQUALS("[test.cpp:4:9]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
+            check(code);
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        {
+            const char code[] = "void f()\n"
+                                "{\n"
+                                "    std::list<int> x;\n"
+                                "    if (x.size() == 0) {}\n"
+                                "}";
+            check(code, settingsCpp03);
+            ASSERT_EQUALS("[test.cpp:4:9]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
+            check(code);
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        {
+            const char code[] = "void f()\n"
+                                "{\n"
+                                "    std::list<int> x;\n"
+                                "    if (0 == x.size()) {}\n"
+                                "}";
+            check(code, settingsCpp03);
+            ASSERT_EQUALS("[test.cpp:4:14]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
+            check(code);
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        {
+            const char code[] = "void f()\n"
+                                "{\n"
+                                "    std::list<int> x;\n"
+                                "    if (x.size() != 0) {}\n"
+                                "}";
+            check(code, settingsCpp03);
+            ASSERT_EQUALS("[test.cpp:4:9]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
+            check(code);
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        {
+            const char code[] = "void f()\n"
+                                "{\n"
+                                "    std::list<int> x;\n"
+                                "    if (0 != x.size()) {}\n"
+                                "}";
+            check(code, settingsCpp03);
+            ASSERT_EQUALS("[test.cpp:4:14]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
+            check(code);
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        {
+            const char code[] = "void f()\n"
+                                "{\n"
+                                "    std::list<int> x;\n"
+                                "    if (x.size() > 0) {}\n"
+                                "}";
+            check(code, settingsCpp03);
+            ASSERT_EQUALS("[test.cpp:4:9]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
+            check(code);
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        {
+            const char code[] = "void f()\n"
+                                "{\n"
+                                "    std::list<int> x;\n"
+                                "    if (0 < x.size()) {}\n"
+                                "}";
+            check(code, settingsCpp03);
+            ASSERT_EQUALS("[test.cpp:4:13]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
+            check(code);
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        {
+            const char code[] =  "void f()\n"
+                                "{\n"
+                                "    std::list<int> x;\n"
+                                "    if (x.size() >= 1) {}\n"
+                                "}";
+            check(code, settingsCpp03);
+            ASSERT_EQUALS("[test.cpp:4:9]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
+            check(code);
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        {
+            const char code[] = "void f()\n"
+                                "{\n"
+                                "    std::list<int> x;\n"
+                                "    if (x.size() < 1) {}\n"
+                                "}";
+            check(code, settingsCpp03);
+            ASSERT_EQUALS("[test.cpp:4:9]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
+            check(code);
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        {
+            const char code[] = "void f()\n"
+                                "{\n"
+                                "    std::list<int> x;\n"
+                                "    if (1 <= x.size()) {}\n"
+                                "}";
+            check(code, settingsCpp03);
+            ASSERT_EQUALS("[test.cpp:4:14]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
+            check(code);
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        {
+            const char code[] = "void f()\n"
+                                "{\n"
+                                "    std::list<int> x;\n"
+                                "    if (1 > x.size()) {}\n"
+                                "}";
+            check(code, settingsCpp03);
+            ASSERT_EQUALS("[test.cpp:4:13]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
+            check(code);
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        {
+            const char code[] = "void f()\n"
+                                "{\n"
+                                "    std::list<int> x;\n"
+                                "    if (x.size()) {}\n"
+                                "}";
+            check(code, settingsCpp03);
+            ASSERT_EQUALS("[test.cpp:4:9]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
+            check(code);
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        {
+            const char code[] = "void f()\n"
+                                "{\n"
+                                "    std::list<int> x;\n"
+                                "    if (!x.size()) {}\n"
+                                "}";
+            check(code, settingsCpp03);
+            ASSERT_EQUALS("[test.cpp:4:10]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
+            check(code);
+            ASSERT_EQUALS("", errout_str());
+        }
 
         check("void f()\n"
               "{\n"
               "    std::list<int> x;\n"
               "    fun(x.size());\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        code ="void f()\n"
-              "{\n"
-              "    std::list<int> x;\n"
-              "    fun(!x.size());\n"
-              "}";
-        check(code, false, Standards::CPP03);
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Possible inefficient checking for 'x' emptiness.\n", errout.str());
-        check(code);
-        ASSERT_EQUALS("", errout.str());
-
-        code = "void f()\n"
-               "{\n"
-               "    std::list<int> x;\n"
-               "    fun(a && x.size());\n"
-               "}";
-        check(code, false, Standards::CPP03);
-        ASSERT_EQUALS("[test.cpp:4]: (performance) Possible inefficient checking for 'x' emptiness.\n", errout.str());
-        check(code);
-        ASSERT_EQUALS("", errout.str());
+        {
+            const char code[] ="void f()\n"
+                                "{\n"
+                                "    std::list<int> x;\n"
+                                "    fun(!x.size());\n"
+                                "}";
+            check(code, settingsCpp03);
+            ASSERT_EQUALS("[test.cpp:4:10]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
+            check(code);
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        {
+            const char code[] = "void f()\n"
+                                "{\n"
+                                "    std::list<int> x;\n"
+                                "    fun(a && x.size());\n"
+                                "}";
+            check(code, settingsCpp03);
+            ASSERT_EQUALS("[test.cpp:4:14]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n", errout_str());
+            check(code);
+            ASSERT_EQUALS("", errout_str());
+        }
 
         check("void f() {\n" // #4039
               "    std::list<int> x;\n"
               "    fun(width % x.size() != 0);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #4584
         check("void f() {\n"
               "    std::list<int> x;\n"
               "    if (foo + 1 > x.size()) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         check("void f() {\n"
               "    std::list<int> x;\n"
               "    if (x.size() < 1 + foo) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void size2() {
-        const char* code = "struct Fred {\n"
-                           "    std::list<int> x;\n"
-                           "};\n"
-                           "struct Wilma {\n"
-                           "    Fred f;\n"
-                           "    void foo();\n"
-                           "};\n"
-                           "void Wilma::foo()\n"
-                           "{\n"
-                           "    if (f.x.size() == 0) {}\n"
-                           "}";
-        check(code, false, Standards::CPP03);
-        ASSERT_EQUALS("[test.cpp:10]: (performance) Possible inefficient checking for 'x' emptiness.\n", errout.str());
+        const char code[] = "struct Fred {\n"
+                            "    std::list<int> x;\n"
+                            "};\n"
+                            "struct Wilma {\n"
+                            "    Fred f;\n"
+                            "    void foo();\n"
+                            "};\n"
+                            "void Wilma::foo()\n"
+                            "{\n"
+                            "    if (f.x.size() == 0) {}\n"
+                            "}";
+        check(code, settingsCpp03);
+        ASSERT_EQUALS(
+            "[test.cpp:10:11]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n"
+            "[test.cpp:10:11]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n",   // duplicate
+            errout_str());
+
         check(code);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void size3() {
-        const char* code = "namespace N {\n"
-                           "    class Zzz {\n"
-                           "    public:\n"
-                           "        std::list<int> x;\n"
-                           "    };\n"
-                           "}\n"
-                           "using namespace N;\n"
-                           "Zzz * zzz;\n"
-                           "int main() {\n"
-                           "    if (zzz->x.size() > 0) { }\n"
-                           "}";
-        check(code, false, Standards::CPP03);
-        ASSERT_EQUALS("[test.cpp:10]: (performance) Possible inefficient checking for 'x' emptiness.\n", errout.str());
-
-        code = "namespace N {\n"
-               "    class Zzz {\n"
-               "    public:\n"
-               "        std::list<int> x;\n"
-               "    };\n"
-               "}\n"
-               "using namespace N;\n"
-               "int main() {\n"
-               "    Zzz * zzz;\n"
-               "    if (zzz->x.size() > 0) { }\n"
-               "}";
-        check(code, false, Standards::CPP03);
-        ASSERT_EQUALS("[test.cpp:10]: (performance) Possible inefficient checking for 'x' emptiness.\n", errout.str());
-        check(code);
-        ASSERT_EQUALS("", errout.str());
+        {
+            const char code[] = "namespace N {\n"
+                                "    class Zzz {\n"
+                                "    public:\n"
+                                "        std::list<int> x;\n"
+                                "    };\n"
+                                "}\n"
+                                "using namespace N;\n"
+                                "Zzz * zzz;\n"
+                                "int main() {\n"
+                                "    if (zzz->x.size() > 0) { }\n"
+                                "}";
+            check(code, settingsCpp03);
+            ASSERT_EQUALS(
+                "[test.cpp:10:14]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n"
+                "[test.cpp:10:14]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n",   // duplicate
+                errout_str());
+        }
+
+        {
+            const char code[] = "namespace N {\n"
+                                "    class Zzz {\n"
+                                "    public:\n"
+                                "        std::list<int> x;\n"
+                                "    };\n"
+                                "}\n"
+                                "using namespace N;\n"
+                                "int main() {\n"
+                                "    Zzz * zzz;\n"
+                                "    if (zzz->x.size() > 0) { }\n"
+                                "}";
+            check(code, settingsCpp03);
+            ASSERT_EQUALS(
+                "[test.cpp:10:14]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n"
+                "[test.cpp:10:14]: (performance) Possible inefficient checking for 'x' emptiness. [stlSize]\n",   // duplicate
+                errout_str());
+
+            check(code);
+            ASSERT_EQUALS("", errout_str());
+        }
     }
 
     void size4() { // #2652 - don't warn about vector/deque
         check("void f(std::vector<int> &v) {\n"
               "    if (v.size() > 0U) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(std::deque<int> &v) {\n"
               "    if (v.size() > 0U) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(std::array<int,3> &a) {\n"
               "    if (a.size() > 0U) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void redundantCondition1() {
@@ -2754,7 +4148,7 @@ class TestStl : public TestFixture {
               "    if (haystack.find(needle) != haystack.end())\n"
               "        haystack.remove(needle);"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Redundant checking of STL container element existence before removing it.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Redundant checking of STL container element existence before removing it. [redundantIfRemove]\n", errout_str());
     }
 
     void missingInnerComparison1() {
@@ -2765,14 +4159,25 @@ class TestStl : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4] -> [test.cpp:2]: (warning) Missing bounds check for extra iterator increment in loop.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13] -> [test.cpp:2:71]: (warning) Missing bounds check for extra iterator increment in loop. [StlMissingComparison]\n", errout_str());
 
         check("void f(std::map<int,int> &ints) {\n"
               "    for (std::map<int,int>::iterator it = ints.begin(); it != ints.end(); ++it) {\n"
               "        ++it->second;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const std::vector<std::string> &v) {\n"
+              "    for(std::vector<std::string>::const_iterator it = v.begin(); it != v.end(); ++it) {\n"
+              "        if(it+2 != v.end())\n"
+              "        {\n"
+              "            ++it;\n"
+              "            ++it;\n"
+              "        }\n"
+              "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void missingInnerComparison2() {
@@ -2785,7 +4190,7 @@ class TestStl : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void missingInnerComparison3() {
@@ -2795,7 +4200,7 @@ class TestStl : public TestFixture {
               "        { }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void missingInnerComparison4() {
@@ -2807,7 +4212,7 @@ class TestStl : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:23]: (style) Consider using std::find_if algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("function f1(std::list<int> &l1) {\n"
               "    for(std::list<int>::iterator i = l1.begin(); i != l1.end(); i++) {\n"
@@ -2817,7 +4222,7 @@ class TestStl : public TestFixture {
               "        }\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:23]: (style) Consider using std::find_if algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
     }
 
     void missingInnerComparison5() {
@@ -2826,7 +4231,7 @@ class TestStl : public TestFixture {
               "        str[i++] = (*it).first;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void missingInnerComparison6() {
@@ -2835,7 +4240,7 @@ class TestStl : public TestFixture {
               "        it = s.insert(++it, 0);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void cstr() {
@@ -2843,50 +4248,50 @@ class TestStl : public TestFixture {
               "    std::string errmsg;\n"
               "    throw errmsg.c_str();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after throwing exception.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after throwing exception. [stlcstrthrow]\n", errout_str());
 
         check("const char *get_msg() {\n"
               "    std::string errmsg;\n"
               "    return errmsg.c_str();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("const char *get_msg() {\n"
               "    std::ostringstream errmsg;\n"
               "    return errmsg.str().c_str();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("const char *get_msg() {\n"
               "    std::string errmsg;\n"
               "    return std::string(\"ERROR: \" + errmsg).c_str();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("const char *get_msg() {\n"
               "    std::string errmsg;\n"
               "    return (\"ERROR: \" + errmsg).c_str();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("const char *get_msg() {\n"
               "    std::string errmsg;\n"
               "    return (\"ERROR: \" + std::string(\"crash me\")).c_str();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("void f() {\n"
               "    std::ostringstream errmsg;\n"
               "    const char *c = errmsg.str().c_str();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:17]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("std::string f();\n"
               "\n"
               "void foo() {\n"
               "    const char *c = f().c_str();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:17]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("class Foo {\n"
               "    const char *f();\n"
@@ -2895,7 +4300,7 @@ class TestStl : public TestFixture {
               "    std::string s;\n"
               "    return s.c_str();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("class Foo {\n"
               "    std::string GetVal() const;\n"
@@ -2904,27 +4309,27 @@ class TestStl : public TestFixture {
               "    Foo f;\n"
               "    return f.GetVal().c_str();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("const char* foo() {\n"
               "    static std::string text;\n"
               "    text = \"hello world\\n\";\n"
               "    return text.c_str();\n"
               "}");
-        ASSERT_EQUALS("", errout.str()); // #3427
+        ASSERT_EQUALS("", errout_str()); // #3427
 
         // Implicit conversion back to std::string
         check("std::string get_msg() {\n"
               "    std::string errmsg;\n"
               "    return errmsg.c_str();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Returning the result of c_str() in a function that returns std::string is slow and redundant.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (performance) Returning the result of c_str() in a function that returns std::string is slow and redundant. [stlcstrReturn]\n", errout_str());
 
         check("const std::string& get_msg() {\n"
               "    std::string errmsg;\n"
               "    return errmsg.c_str();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Returning the result of c_str() in a function that returns std::string is slow and redundant.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (performance) Returning the result of c_str() in a function that returns std::string is slow and redundant. [stlcstrReturn]\n", errout_str());
 
         check("class Foo {\n"
               "    std::string GetVal() const;\n"
@@ -2933,22 +4338,22 @@ class TestStl : public TestFixture {
               "    Foo f;\n"
               "    return f.GetVal().c_str();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (performance) Returning the result of c_str() in a function that returns std::string is slow and redundant.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:5]: (performance) Returning the result of c_str() in a function that returns std::string is slow and redundant. [stlcstrReturn]\n", errout_str());
 
         check("std::string get_msg() {\n"
               "    std::string errmsg;\n"
               "    return errmsg;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("std::string get_msg() {\n" // #3678
               "    MyStringClass errmsg;\n"
               "    return errmsg.c_str();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void Foo1(const std::string& str) {}\n"
-              "void Foo2(char* c, const std::string str) {}\n"
+              "void Foo2(const char* c, const std::string str) {}\n"
               "void Foo3(std::string& rstr) {}\n"
               "void Foo4(std::string str, const std::string& str) {}\n"
               "void Bar() {\n"
@@ -2966,13 +4371,13 @@ class TestStl : public TestFixture {
               "    Foo4(str.c_str(), str.c_str());\n"
               "}");
 
-        ASSERT_EQUALS("[test.cpp:9]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 1 is slow and redundant.\n"
-                      "[test.cpp:11]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 2 is slow and redundant.\n"
-                      "[test.cpp:14]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 1 is slow and redundant.\n"
-                      "[test.cpp:15]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 2 is slow and redundant.\n"
-                      "[test.cpp:16]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 2 is slow and redundant.\n"
-                      "[test.cpp:17]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 1 is slow and redundant.\n"
-                      "[test.cpp:17]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 2 is slow and redundant.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:5]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 1 is slow and redundant. [stlcstrParam]\n"
+                      "[test.cpp:11:5]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 2 is slow and redundant. [stlcstrParam]\n"
+                      "[test.cpp:14:5]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 1 is slow and redundant. [stlcstrParam]\n"
+                      "[test.cpp:15:5]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 2 is slow and redundant. [stlcstrParam]\n"
+                      "[test.cpp:16:5]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 2 is slow and redundant. [stlcstrParam]\n"
+                      "[test.cpp:17:5]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 1 is slow and redundant. [stlcstrParam]\n"
+                      "[test.cpp:17:5]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 2 is slow and redundant. [stlcstrParam]\n", errout_str());
 
         check("void Foo1(const std::string& str) {}\n"
               "void Foo2(char* c, const std::string str) {}\n"
@@ -2981,7 +4386,7 @@ class TestStl : public TestFixture {
               "    Foo1(str, foo);\n" // Don't crash
               "    Foo2(str.c_str());\n" // Don't crash
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Foo {\n"
               "    void func(std::string str) const {}\n"
@@ -2995,9 +4400,34 @@ class TestStl : public TestFixture {
               "    Foo::sfunc(str.c_str());\n"
               "    foo.func(str.c_str());\n"
               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:9]: (performance) Passing the result of c_str() to a function that takes std::string as argument 1 is slow and redundant.\n"
-                           "[test.cpp:10]: (performance) Passing the result of c_str() to a function that takes std::string as argument 1 is slow and redundant.\n",
-                           "", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:5]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 1 is slow and redundant. [stlcstrParam]\n"
+                      "[test.cpp:10:10]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 1 is slow and redundant. [stlcstrParam]\n"
+                      "[test.cpp:11:9]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 1 is slow and redundant. [stlcstrParam]\n",
+                      errout_str());
+
+        check("void f(const std::string& s);\n" // #8336
+              "struct T {\n"
+              "    std::string g();\n"
+              "    std::string a[1];\n"
+              "    struct U { std::string s; } u;"
+              "};\n"
+              "namespace N { namespace O { std::string s; } }\n"
+              "void g(const std::vector<std::string>& v, T& t) {\n"
+              "    for (std::vector<std::string>::const_iterator it = v.begin(); it != v.end(); ++it)\n"
+              "        f(it->c_str());\n"
+              "    f(v.begin()->c_str());\n"
+              "    f(t.g().c_str());\n"
+              "    f(t.a[0].c_str());\n"
+              "    f(t.u.s.c_str());\n"
+              "    f(N::O::s.c_str());\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:9:9]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 1 is slow and redundant. [stlcstrParam]\n"
+                      "[test.cpp:10:5]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 1 is slow and redundant. [stlcstrParam]\n"
+                      "[test.cpp:11:5]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 1 is slow and redundant. [stlcstrParam]\n"
+                      "[test.cpp:12:5]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 1 is slow and redundant. [stlcstrParam]\n"
+                      "[test.cpp:13:5]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 1 is slow and redundant. [stlcstrParam]\n"
+                      "[test.cpp:14:5]: (performance) Passing the result of c_str() to a function that takes std::string as argument no. 1 is slow and redundant. [stlcstrParam]\n",
+                      errout_str());
 
         check("void svgFile(const std::string &content, const std::string &fileName, const double end = 1000., const double start = 0.);\n"
               "void Bar(std::string filename) {\n"
@@ -3005,7 +4435,7 @@ class TestStl : public TestFixture {
               "    std::ofstream svgFile(filename.c_str(), std::ios::trunc);\n"
               "    svgFile << \"test\";\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void Foo(const char* p) {}\n"
               "void Foo(const std::string& str) {Foo(str.c_str());}\n" // Overloaded
@@ -3014,12 +4444,12 @@ class TestStl : public TestFixture {
               "    Foo(str);\n"
               "    Foo(str.c_str());\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int atoi(const std::string& str) {\n" // #3729: Don't suggest recursive call
               "    return atoi(str.c_str());\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("std::string hello()\n"
               "{\n"
@@ -3030,7 +4460,7 @@ class TestStl : public TestFixture {
               "{\n"
               "    return hello().c_str();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("class Fred {\n"
               "    std::string hello();\n"
@@ -3044,7 +4474,7 @@ class TestStl : public TestFixture {
               "{\n"
               "    return hello().c_str();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:11]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:11:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         // #4183 - using MyStringClass.c_str()
         check("void a(const std::string &str);\n"
@@ -3053,12 +4483,12 @@ class TestStl : public TestFixture {
               "    MyStringClass s;\n"
               "    a(s.c_str());\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("std::string Format(const char * name) {\n" // #4938
               "    return String::Format(\"%s:\", name).c_str();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #7480
         check("struct InternalMapInfo {\n"
@@ -3068,7 +4498,7 @@ class TestStl : public TestFixture {
               "    const InternalMapInfo* mapInfo = &internal_getMapInfo;\n"
               "    return mapInfo->author.c_str();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct InternalMapInfo {\n"
               "    std::string author;\n"
@@ -3077,7 +4507,7 @@ class TestStl : public TestFixture {
               "    const InternalMapInfo* mapInfo = &internal_getMapInfo;\n"
               "    return mapInfo->author.c_str();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (performance) Returning the result of c_str() in a function that returns std::string is slow and redundant.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:5]: (performance) Returning the result of c_str() in a function that returns std::string is slow and redundant. [stlcstrReturn]\n", errout_str());
 
         check("struct InternalMapInfo {\n"
               "    std::string author;\n"
@@ -3086,7 +4516,7 @@ class TestStl : public TestFixture {
               "    const InternalMapInfo mapInfo = internal_getMapInfo;\n"
               "    return mapInfo.author.c_str();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
 
         check("struct S {\n" // #7656
               "    std::string data;\n"
@@ -3096,7 +4526,7 @@ class TestStl : public TestFixture {
               "    const struct S &s = getS();\n"
               "    return s.data.c_str();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct S {\n" // #7930
               "    std::string data;\n"
@@ -3106,7 +4536,189 @@ class TestStl : public TestFixture {
               "    std::string &ref = s.data;\n"
               "    return ref.c_str();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:5]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
+
+        check("void f(const wchar_t* w, int i = 0, ...);\n" // #10357
+              "void f(const std::string& s, int i = 0);\n"
+              "void g(const std::wstring& p) {\n"
+              "    f(p.c_str());\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" //#9161
+              "    const char* f() const noexcept {\n"
+              "        return (\"\" + m).c_str();\n"
+              "    }\n"
+              "    std::string m;\n"
+              "};\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:9]: (error) Dangerous usage of c_str(). The value returned by c_str() is invalid after this call. [stlcstr]\n", errout_str());
+
+        check("struct S {\n" // #10493
+              "    void f(const char** pp);\n"
+              "    std::string s;\n"
+              "};\n"
+              "void S::f(const char** pp) {\n"
+              "    try {\n"
+              "        *pp = member.c_str();\n"
+              "    }\n"
+              "    catch (...) {\n"
+              "        s = \"xyz\";\n"
+              "        *pp = member.c_str();\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::string f(const std::string& a) {\n"
+              "    std::string b(a.c_str());\n"
+              "    return b;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:17]: (performance) Constructing a std::string from the result of c_str() is slow and redundant. [stlcstrConstructor]\n", errout_str());
+
+        check("std::string f(const std::string& a) {\n"
+              "    std::string b{ a.c_str() };\n"
+              "    return b;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:17]: (performance) Constructing a std::string from the result of c_str() is slow and redundant. [stlcstrConstructor]\n", errout_str());
+
+        check("std::string f(const std::string& a) {\n"
+              "    std::string b = a.c_str();\n"
+              "    return b;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:17]: (performance) Assigning the result of c_str() to a std::string is slow and redundant. [stlcstrAssignment]\n", errout_str());
+
+        check("std::string g(const std::string& a, const std::string& b) {\n"
+              "    return a + b.c_str();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:14]: (performance) Concatenating the result of c_str() and a std::string is slow and redundant. [stlcstrConcat]\n", errout_str());
+
+        check("std::string g(const std::string& a, const std::string& b) {\n"
+              "    return a.c_str() + b;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:22]: (performance) Concatenating the result of c_str() and a std::string is slow and redundant. [stlcstrConcat]\n", errout_str());
+
+        check("std::vector<double> v;\n" // don't crash
+              "int i;\n"
+              "void f() {\n"
+              "    const double* const QM_R__ buf(v.data() + i);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct T {\n" // #7515
+              "    std::string g();\n"
+              "    std::string a[1];\n"
+              "    std::vector<std::string> v;\n"
+              "};\n"
+              "void f(std::stringstream& strm, const std::string& s, T& t) {\n"
+              "    strm << s.c_str();\n"
+              "    strm << \"abc\" << s.c_str();\n"
+              "    strm << \"abc\" << s.c_str() << \"def\";\n"
+              "    strm << \"abc\" << t.g().c_str() << \"def\";\n"
+              "    strm << t.a[0].c_str();\n"
+              "    strm << t.v.begin()->c_str();\n"
+              "    auto it = t.v.begin()\n"
+              "    strm << it->c_str();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:7:10]: (performance) Passing the result of c_str() to a stream is slow and redundant. [stlcstrStream]\n"
+                      "[test.cpp:8:19]: (performance) Passing the result of c_str() to a stream is slow and redundant. [stlcstrStream]\n"
+                      "[test.cpp:9:19]: (performance) Passing the result of c_str() to a stream is slow and redundant. [stlcstrStream]\n"
+                      "[test.cpp:10:19]: (performance) Passing the result of c_str() to a stream is slow and redundant. [stlcstrStream]\n"
+                      "[test.cpp:11:10]: (performance) Passing the result of c_str() to a stream is slow and redundant. [stlcstrStream]\n"
+                      "[test.cpp:12:10]: (performance) Passing the result of c_str() to a stream is slow and redundant. [stlcstrStream]\n"
+                      "[test.cpp:14:10]: (performance) Passing the result of c_str() to a stream is slow and redundant. [stlcstrStream]\n",
+                      errout_str());
+
+        check("void f(const std::string& s) {\n"
+              "    std::cout << s.c_str();\n"
+              "    std::cerr << s.c_str();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:15]: (performance) Passing the result of c_str() to a stream is slow and redundant. [stlcstrStream]\n"
+                      "[test.cpp:3:15]: (performance) Passing the result of c_str() to a stream is slow and redundant. [stlcstrStream]\n",
+                      errout_str());
+
+        check("struct S { std::string str; };\n"
+              "struct T { S s; };\n"
+              "struct U { T t[1]; };\n"
+              "void f(const T& t, const U& u, std::string& str) {\n"
+              "    if (str.empty())\n"
+              "        str = t.s.str.c_str();\n"
+              "    else\n"
+              "        str = u.t[0].s.str.c_str();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:9]: (performance) Assigning the result of c_str() to a std::string is slow and redundant. [stlcstrAssignment]\n"
+                      "[test.cpp:8:9]: (performance) Assigning the result of c_str() to a std::string is slow and redundant. [stlcstrAssignment]\n",
+                      errout_str());
+
+        check("void f(std::string_view);\n" // #11547
+              "void g(const std::string & s) {\n"
+              "    f(s.c_str());\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:5]: (performance) Passing the result of c_str() to a function that takes std::string_view as argument no. 1 is slow and redundant. [stlcstrParam]\n",
+                      errout_str());
+
+        check("std::string_view f(const std::string& s) {\n"
+              "    std::string_view sv = s.c_str();\n"
+              "    return sv;\n"
+              "}\n"
+              "std::string_view g(const std::string& s) {\n"
+              "    std::string_view sv{ s.c_str() };\n"
+              "    return sv;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:22]: (performance) Assigning the result of c_str() to a std::string_view is slow and redundant. [stlcstrAssignment]\n"
+                      "[test.cpp:6:22]: (performance) Constructing a std::string_view from the result of c_str() is slow and redundant. [stlcstrConstructor]\n",
+                      errout_str());
+
+        check("void f(const std::string& s) {\n" // #11819
+              "    std::string_view sv(s.data(), 13);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { std::string x; };\n" // #11802
+              "std::vector<std::shared_ptr<S>> global;\n"
+              "const char* f() {\n"
+              "    auto s = std::make_shared<S>();\n"
+              "    global.push_back(s);\n"
+              "    return s->x.c_str();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::string f(const std::string& s) {\n" // #14533
+              "    auto x = std::string(\"abc\") + s.c_str();\n"
+              "    auto y = s.c_str() + std::string(\"def\");\n"
+              "    return x + y;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:33]: (performance) Concatenating the result of c_str() and a std::string is slow and redundant. [stlcstrConcat]\n"
+                      "[test.cpp:3:24]: (performance) Concatenating the result of c_str() and a std::string is slow and redundant. [stlcstrConcat]\n",
+                      errout_str());
+
+        check("std::string get();\n"
+              "std::string f(const std::string& s) {\n"
+              "    return get() + s.c_str();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:18]: (performance) Concatenating the result of c_str() and a std::string is slow and redundant. [stlcstrConcat]\n",
+                      errout_str());
+
+        check("std::string get();\n" // #14536
+              "    std::string f(const std::string& s) {\n"
+              "    return s + get().c_str();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:14]: (performance) Concatenating the result of c_str() and a std::string is slow and redundant. [stlcstrConcat]\n",
+                      errout_str());
+
+        check("std::string get();\n"
+              "std::string f(std::string & s) {\n"
+              "    s = get().c_str();\n"
+              "    std::string s2{ get().c_str() };\n"
+              "    return s2;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:5]: (performance) Assigning the result of c_str() to a std::string is slow and redundant. [stlcstrAssignment]\n"
+                      "[test.cpp:4:17]: (performance) Constructing a std::string from the result of c_str() is slow and redundant. [stlcstrConstructor]\n",
+                      errout_str());
+
+        check("void f() {\n"
+              "    std::string s;\n"
+              "    auto a = + s.c_str();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uselessCalls() {
@@ -3116,7 +4728,7 @@ class TestStl : public TestFixture {
               "    s1.swap(s2);\n"
               "    s2.swap(s2);\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -3124,7 +4736,7 @@ class TestStl : public TestFixture {
               "    s1.swap(s2);\n"
               "    s2.swap(s2);\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:5]: (performance) It is inefficient to swap a object with itself by calling 's2.swap(s2)'\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:5]: (performance) It is inefficient to swap a object with itself by calling 's2.swap(s2)' [uselessCallsSwap]\n", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -3134,7 +4746,7 @@ class TestStl : public TestFixture {
               "    s1.compare(s2.c_str());\n"
               "    s1.compare(0, s1.size(), s1);\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) It is inefficient to call 's2.compare(s2)' as it always returns 0.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:16]: (warning) It is inefficient to call 's2.compare(s2)' as it always returns 0. [uselessCallsCompare]\n", errout_str());
 
         // #7370 False positive uselessCallsCompare on unknown type
         check("class ReplayIteratorImpl{\n"
@@ -3145,7 +4757,7 @@ class TestStl : public TestFixture {
               "  }\n"
               "  WT_CURSOR *cursor_;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -3157,11 +4769,11 @@ class TestStl : public TestFixture {
               "    s1 = s2.substr(0,std::string::npos);\n"
               "    s1 = s2.substr(x+5-n, 0);\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:5]: (performance) Ineffective call of function \'substr\' because it returns a copy of "
-                      "the object. Use operator= instead.\n"
-                      "[test.cpp:8]: (performance) Ineffective call of function \'substr\' because it returns a copy of "
-                      "the object. Use operator= instead.\n"
-                      "[test.cpp:9]: (performance) Ineffective call of function \'substr\' because it returns an empty string.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10]: (performance) Ineffective call of function \'substr\' because it returns a copy of "
+                      "the object. Use operator= instead. [uselessCallsSubstr]\n"
+                      "[test.cpp:8:10]: (performance) Ineffective call of function \'substr\' because it returns a copy of "
+                      "the object. Use operator= instead. [uselessCallsSubstr]\n"
+                      "[test.cpp:9:10]: (performance) Ineffective call of function \'substr\' because it returns an empty string. [uselessCallsSubstr]\n", errout_str());
 
         check("void f()\n"
               "{\n"
@@ -3173,26 +4785,26 @@ class TestStl : public TestFixture {
               "    s1 = s2.substr(0,std::string::npos);\n"
               "    s1 = s2.substr(x+5-n, 0);\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int main()\n"
               "{\n"
               "    std::string str = \"a1b1\";\n"
               "    return str.find(str[1], 2);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool foo(std::vector<int>& v) {\n"
               "    v.empty();\n"
               "    return v.empty();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Ineffective call of function 'empty()'. Did you intend to call 'clear()' instead?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning) Ineffective call of function 'empty()'. Did you intend to call 'clear()' instead? [uselessCallsEmpty]\n", errout_str());
 
         check("void f() {\n" // #4938
               "    OdString str;\n"
               "    str.empty();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n" // #4032
               "    const std::string greeting(\"Hello World !!!\");\n"
@@ -3200,10 +4812,9 @@ class TestStl : public TestFixture {
               "    if (npos != std::string::npos)\n"
               "        std::cout << greeting.substr(0, npos) << std::endl;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        check("void f() {\n"
-              "    std::vector<int> a;\n"
+        check("void f(std::vector<int> a) {\n"
               "    std::remove(a.begin(), a.end(), val);\n"
               "    std::remove_if(a.begin(), a.end(), val);\n"
               "    std::unique(a.begin(), a.end(), val);\n"
@@ -3211,21 +4822,71 @@ class TestStl : public TestFixture {
               "    a.erase(std::remove(a.begin(), a.end(), val));\n"
               "    std::remove(\"foo.txt\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Return value of std::remove() ignored. Elements remain in container.\n"
-                      "[test.cpp:4]: (warning) Return value of std::remove_if() ignored. Elements remain in container.\n"
-                      "[test.cpp:5]: (warning) Return value of std::unique() ignored. Elements remain in container.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:5]: (warning) Return value of std::remove() ignored. Elements remain in container. [uselessCallsRemove]\n"
+                      "[test.cpp:3:5]: (warning) Return value of std::remove_if() ignored. Elements remain in container. [uselessCallsRemove]\n"
+                      "[test.cpp:4:5]: (warning) Return value of std::unique() ignored. Elements remain in container. [uselessCallsRemove]\n", errout_str());
 
         // #4431 - fp
         check("bool f() {\n"
               "    return x ? true : (y.empty());\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #8360
         check("void f(std::string s) {\n"
               "    for (;s.empty();) {}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // #11166
+        check("std::string f(std::string s) {\n"
+              "    s = s.substr(0, s.size() - 1);\n"
+              "    return s;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:9]: (performance) Ineffective call of function 'substr' because a prefix of the string is assigned to itself. Use resize() or pop_back() instead. [uselessCallsSubstr]\n",
+                      errout_str());
+
+        check("std::string f(std::string s, std::size_t start, std::size_t end, const std::string& i) {\n"
+              "    s = s.substr(0, start) + i + s.substr(end + 1);\n"
+              "    return s;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:9]: (performance) Ineffective call of function 'substr' because a prefix of the string is assigned to itself. Use replace() instead. [uselessCallsSubstr]\n",
+                      errout_str());
+
+        check("std::string f(std::string s, std::size_t end) {\n"
+              "    s = { s.begin(), s.begin() + end };\n"
+              "    return s;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:5]: (performance) Inefficient constructor call: container 's' is assigned a partial copy of itself. Use erase() or resize() instead. [uselessCallsConstructor]\n",
+                      errout_str());
+
+        check("std::list<int> f(std::list<int> l, std::size_t end) {\n"
+              "    l = { l.begin(), l.begin() + end };\n"
+              "    return l;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:5]: (performance) Inefficient constructor call: container 'l' is assigned a partial copy of itself. Use erase() or resize() instead. [uselessCallsConstructor]\n",
+                      errout_str());
+
+        check("std::string f(std::string s, std::size_t end) {\n"
+              "    s = std::string{ s.begin(), s.begin() + end };\n"
+              "    return s;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:5]: (performance) Inefficient constructor call: container 's' is assigned a partial copy of itself. Use erase() or resize() instead. [uselessCallsConstructor]\n",
+                      errout_str());
+
+        check("std::string f(std::string s, std::size_t end) {\n"
+              "    s = std::string(s.begin(), s.begin() + end);\n"
+              "    return s;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:5]: (performance) Inefficient constructor call: container 's' is assigned a partial copy of itself. Use erase() or resize() instead. [uselessCallsConstructor]\n",
+                      errout_str());
+
+        check("std::vector<int> f(std::vector<int> v, std::size_t end) {\n"
+              "    v = std::vector<int>(v.begin(), v.begin() + end);\n"
+              "    return v;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:5]: (performance) Inefficient constructor call: container 'v' is assigned a partial copy of itself. Use erase() or resize() instead. [uselessCallsConstructor]\n",
+                      errout_str());
     }
 
     void stabilityOfChecks() {
@@ -3238,9 +4899,9 @@ class TestStl : public TestFixture {
               "        x < vector < EffectivityRangeData<int >> >();\n"
               "        EffectivityRange<int> er;\n"
               "    }\n"
-              "    void shift() { EffectivityRangeData<int>::iterator it;  } \n"
-              "};\n");
-        ASSERT_EQUALS("", errout.str());
+              "    void shift() { EffectivityRangeData<int>::iterator it;  }\n"
+              "};");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void dereferenceInvalidIterator() {
@@ -3249,24 +4910,24 @@ class TestStl : public TestFixture {
               "    if (std::isalpha(*i) && i != str.end()) {\n"
               "        std::cout << *i;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Possible dereference of an invalid iterator: i\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:22]: (warning) Possible dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
         check("void foo(std::string::iterator& i) {\n"
               "    if(foo) { bar(); }\n"
               "    else if (std::isalpha(*i) && i != str.end()) {\n"
               "        std::cout << *i;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Possible dereference of an invalid iterator: i\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:27]: (warning) Possible dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
         // Test suggested correction doesn't report an error
         check("void foo(std::string::iterator& i) {\n"
               "    if (i != str.end() && std::isalpha(*i)) {\n"
               "        std::cout << *i;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // Test "while" with "&&" case
         check("void foo(std::string::iterator& i) {\n"
@@ -3274,16 +4935,16 @@ class TestStl : public TestFixture {
               "        std::cout << *i;\n"
               "        i ++;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Possible dereference of an invalid iterator: i\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:25]: (warning) Possible dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
         check("void foo(std::string::iterator& i) {\n"
               "    do {\n"
               "        std::cout << *i;\n"
               "        i ++;\n"
               "    } while (std::isalpha(*i) && i != str.end());\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:5]: (warning) Possible dereference of an invalid iterator: i\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:27]: (warning) Possible dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
         // Test "while" with "||" case
         check("void foo(std::string::iterator& i) {\n"
@@ -3291,8 +4952,8 @@ class TestStl : public TestFixture {
               "        std::cout << *i;\n"
               "        i ++;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Possible dereference of an invalid iterator: i\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:28]: (warning) Possible dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
         // Test fix for "while" with "||" case
         check("void foo(std::string::iterator& i) {\n"
@@ -3300,8 +4961,8 @@ class TestStl : public TestFixture {
               "        std::cout << *i;\n"
               "        i ++;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // Test "for" with "&&" case
         check("void foo(std::string::iterator& i) {\n"
@@ -3309,8 +4970,8 @@ class TestStl : public TestFixture {
               "        std::cout << *i;\n"
               "        i ++;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Possible dereference of an invalid iterator: i\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:25]: (warning) Possible dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
         // Test "for" with "||" case
         check("void foo(std::string::iterator& i) {\n"
@@ -3318,8 +4979,8 @@ class TestStl : public TestFixture {
               "        std::cout << *i;\n"
               "        i ++;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Possible dereference of an invalid iterator: i\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:25]: (warning) Possible dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
         // Test that a dereference outside the condition part of a "for"
         // loop does not result in a false positive
@@ -3328,24 +4989,24 @@ class TestStl : public TestFixture {
               "        std::cout << c;\n"
               "        i ++;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // Test that other "&&" terms in the condition don't invalidate the check
         check("void foo(char* c, std::string::iterator& i) {\n"
               "    if (*c && std::isalpha(*i) && i != str.end()) {\n"
               "        std::cout << *i;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Possible dereference of an invalid iterator: i\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:28]: (warning) Possible dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
         // Test that dereference of different variable doesn't trigger a false positive
         check("void foo(const char* c, std::string::iterator& i) {\n"
               "    if (std::isalpha(*c) && i != str.end()) {\n"
               "        std::cout << *c;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         // Test case involving "rend()" instead of "end()"
         check("void foo(std::string::iterator& i) {\n"
@@ -3353,96 +5014,379 @@ class TestStl : public TestFixture {
               "        std::cout << *i;\n"
               "        i ++;\n"
               "    }\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Possible dereference of an invalid iterator: i\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:25]: (warning) Possible dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
         // Test that mixed "&&" and "||" don't result in a false positive
         check("void foo(std::string::iterator& i) {\n"
               "    if ((i == str.end() || *i) || (isFoo() && i != str.end())) {\n"
               "        std::cout << \"foo\";\n"
               "    }\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    std::vector <int> v;\n"
+              "    std::vector <int>::iterator i = v.end();\n"
+              "    *i=0;\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
-    }
+        ASSERT_EQUALS("[test.cpp:4:6]: (error) Dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
-    void dereferenceInvalidIterator2() {
-        // Self-implemented iterator class
-        check("class iterator {\n"
-              "public:\n"
-              "    CCommitPointer m_ptr;\n"
-              "    iterator() {}\n"
-              "    CCommitPointer& operator*() {\n"
-              "        return m_ptr;\n"
-              "    }\n"
-              "    CCommitPointer* operator->() {\n"
-              "        return &m_ptr;\n"
-              "    }\n"
-              "    iterator& operator++() {\n"
-              "        ++m_ptr.m_place;\n"
-              "        return *this;\n"
-              "    }\n"
-              "    }; \n"
-              "    iterator begin() {\n"
-              "    iterator it; \n"
-              "    it->m_place = 0;\n"
-              "    return it; \n"
-              "}\n", true);
-        ASSERT_EQUALS("[test.cpp:18]: (error, inconclusive) Invalid iterator 'it' used.\n", errout.str());
-    }
+        check("void f() {\n"
+              "    std::vector <int> v;\n"
+              "    std::vector <int>::iterator i = std::end(v);\n"
+              "    *i=0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:6]: (error) Dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
-    void loopAlgoElementAssign() {
-        check("void foo() {\n"
-              "    for(int& x:v)\n"
-              "        x = 1;\n"
-              "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:3]: (style) Consider using std::fill algorithm instead of a raw loop.\n", errout.str());
+        check("void f(std::vector <int> v) {\n"
+              "    std::vector <int>::iterator i = v.end();\n"
+              "    *i=0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:6]: (error) Dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
-        check("void foo() {\n"
-              "    for(int& x:v)\n"
-              "        x = x + 1;\n"
-              "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:3]: (style) Consider using std::transform algorithm instead of a raw loop.\n", errout.str());
+        check("void f(std::vector <int> v) {\n"
+              "    std::vector <int>::iterator i = v.end();\n"
+              "    *(i+1)=0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:8]: (error) Dereference of an invalid iterator: i+1 [derefInvalidIterator]\n", errout_str());
 
-        check("void foo(int a, int b) {\n"
-              "    for(int& x:v)\n"
-              "        x = a + b;\n"
-              "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:3]: (style) Consider using std::fill or std::generate algorithm instead of a raw loop.\n", errout.str());
+        check("void f(std::vector <int> v) {\n"
+              "    std::vector <int>::iterator i = v.end();\n"
+              "    *(i-1)=0;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
 
-        check("void foo() {\n"
-              "    for(int& x:v)\n"
-              "        x += 1;\n"
-              "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:3]: (style) Consider using std::transform algorithm instead of a raw loop.\n", errout.str());
+        check("void f(std::vector <int> v) {\n"
+              "    std::vector <int>::iterator i = v.begin();\n"
+              "    *(i-1)=0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:8]: (error) Dereference of an invalid iterator: i-1 [derefInvalidIterator]\n", errout_str());
 
-        check("void foo() {\n"
-              "    for(int& x:v)\n"
-              "        x = f();\n"
-              "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:3]: (style) Consider using std::generate algorithm instead of a raw loop.\n", errout.str());
+        check("void f(std::vector <int> v) {\n"
+              "    std::vector <int>::iterator i = std::begin(v);\n"
+              "    *(i-1)=0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:8]: (error) Dereference of an invalid iterator: i-1 [derefInvalidIterator]\n", errout_str());
 
-        check("void foo() {\n"
-              "    for(int& x:v) {\n"
-              "        f();\n"
-              "        x = 1;\n"
-              "    }\n"
-              "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+        check("void f(std::vector <int> v, bool b) {\n"
+              "    std::vector <int>::iterator i = v.begin();\n"
+              "    if (b)\n"
+              "        i = v.end();\n"
+              "    *i=0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:6]: (warning) Possible dereference of an invalid iterator: i [derefInvalidIterator]\n", errout_str());
 
-        check("void foo() {\n"
-              "    for(int& x:v) {\n"
-              "        x = 1;\n"
-              "        f();\n"
-              "    }\n"
+        check("void f(std::vector <int> v, bool b) {\n"
+              "    std::vector <int>::iterator i = v.begin();\n"
+              "    if (b)\n"
+              "        i = v.end();\n"
+              "    *(i+1)=0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:8]: (warning) Possible dereference of an invalid iterator: i+1 [derefInvalidIterator]\n", errout_str());
+
+        check("void f(std::vector <int> v, bool b) {\n"
+              "    std::vector <int>::iterator i = v.begin();\n"
+              "    if (b)\n"
+              "        i = v.end();\n"
+              "    *(i-1)=0;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:8]: (warning) Possible dereference of an invalid iterator: i-1 [derefInvalidIterator]\n", errout_str());
+
+        check("int f(std::vector<int> v, int pos) {\n"
+              "    if (pos >= 0)\n"
+              "        return *(v.begin() + pos);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(std::vector<int> v, int i) {\n"
+              "    auto it = std::find(v.begin(), v.end(), i);\n"
+              "    if (it != v.end()) {}\n"
+              "    return *it;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:12] -> [test.cpp:4:13]: (warning) Either the condition 'it!=v.end()' is redundant or there is possible dereference of an invalid iterator: it. [derefInvalidIteratorRedundantCheck]\n", errout_str());
+
+        check("void f(std::vector<int> & v) {\n"
+              "    std::vector<int>::iterator i= v.begin();\n"
+              "    if(i == v.end() && *(i+1) == *i) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:3:27]: (warning) Either the condition 'i==v.end()' is redundant or there is possible dereference of an invalid iterator: i+1. [derefInvalidIteratorRedundantCheck]\n"
+                      "[test.cpp:3:10] -> [test.cpp:3:35]: (warning) Either the condition 'i==v.end()' is redundant or there is possible dereference of an invalid iterator: i. [derefInvalidIteratorRedundantCheck]\n", errout_str());
+
+
+        check("void f(std::vector<int> & v) {\n"
+              "    std::vector<int>::iterator i= v.begin();\n"
+              "    if(i == v.end() && *i == *(i+1)) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:3:25]: (warning) Either the condition 'i==v.end()' is redundant or there is possible dereference of an invalid iterator: i. [derefInvalidIteratorRedundantCheck]\n"
+                      "[test.cpp:3:10] -> [test.cpp:3:33]: (warning) Either the condition 'i==v.end()' is redundant or there is possible dereference of an invalid iterator: i+1. [derefInvalidIteratorRedundantCheck]\n", errout_str());
+
+        check("void f(std::vector<int> & v) {\n"
+              "    std::vector<int>::iterator i= v.begin();\n"
+              "    if(i != v.end() && *i == *(i+1)) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:3:33]: (warning) Either the condition 'i!=v.end()' is redundant or there is possible dereference of an invalid iterator: i+1. [derefInvalidIteratorRedundantCheck]\n", errout_str());
+
+        check("void f(std::vector<int> & v) {\n"
+              "    std::vector<int>::iterator i= v.begin();\n"
+              "    if(i != v.end()) {\n"
+              "        if (*(i+1) == *i) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:4:16]: (warning) Either the condition 'i!=v.end()' is redundant or there is possible dereference of an invalid iterator: i+1. [derefInvalidIteratorRedundantCheck]\n", errout_str());
+
+        check("void f(std::vector<int> & v) {\n"
+              "    std::vector<int>::iterator i= v.begin();\n"
+              "    if(i == v.end()) { return; }\n"
+              "    if (*(i+1) == *i) {}\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:4:12]: (warning) Either the condition 'i==v.end()' is redundant or there is possible dereference of an invalid iterator: i+1. [derefInvalidIteratorRedundantCheck]\n", errout_str());
+
+        check("void f(std::vector<int> & v) {\n"
+              "    std::vector<int>::iterator i= v.begin();\n"
+              "    if(i != v.end() && (i+1) != v.end() && *(i+1) == *i) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::string s) {\n"
+              "    for (std::string::const_iterator i = s.begin(); i != s.end(); ++i) {\n"
+              "        if (i != s.end() && (i + 1) != s.end() && *(i + 1) == *i) {\n"
+              "            if (!isalpha(*(i + 2))) {\n"
+              "                std::string modifier;\n"
+              "                modifier += *i;\n"
+              "                modifier += *(i + 1);\n"
+              "            }\n"
+              "        }\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:37] -> [test.cpp:4:30]: (warning) Either the condition '(i+1)!=s.end()' is redundant or there is possible dereference of an invalid iterator: i+2. [derefInvalidIteratorRedundantCheck]\n", errout_str());
+
+        check("void f(int v, std::map<int, int> &items) {\n"
+              "    for (auto it = items.begin(); it != items.end();)\n"
+              "        (it->first == v) ? it = items.erase(it) : ++it;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::string s) {\n"
+              "    for (std::string::const_iterator i = s.begin(); i != s.end(); ++i) {\n"
+              "        if (i != s.end() && (i + 1) != s.end() && *(i + 1) == *i) {\n"
+              "            if ((i + 2) != s.end() && !isalpha(*(i + 2))) {\n"
+              "                std::string modifier;\n"
+              "                modifier += *i;\n"
+              "                modifier += *(i + 1);\n"
+              "            }\n"
+              "        }\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(std::vector<int>::iterator it, const std::vector<int>& vector) {\n"
+              "    if (!(it != vector.end() && it != vector.begin()))\n"
+              "        throw std::out_of_range();\n"
+              "    if (it != vector.end() && *it == 0)\n"
+              "        return -1;\n"
+              "    return *it;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(std::vector<int> &vect) {\n"
+              "    const int &v = *vect.emplace(vect.end());\n"
+              "    return v;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("extern bool bar(int);\n"
+              "void f(std::vector<int> & v) {\n"
+              "    std::vector<int>::iterator i= v.begin();\n"
+              "    if(i == v.end() && bar(*(i+1)) ) {}\n"
+              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:4:10] -> [test.cpp:4:31]: (warning) Either the condition 'i==v.end()' is redundant or there is possible dereference of an invalid iterator: i+1. [derefInvalidIteratorRedundantCheck]\n",
+            errout_str());
+
+        // #10657
+        check("std::list<int> mValues;\n"
+              "typedef std::list<int>::iterator ValueIterator;\n"
+              "void foo(ValueIterator beginValue, ValueIterator endValue) {\n"
+              "    ValueIterator prevValue = beginValue;\n"
+              "    ValueIterator curValue = beginValue;\n"
+              "    for (++curValue; prevValue != endValue && curValue != mValues.end(); ++curValue) {\n"
+              "        a = bar(*curValue);\n"
+              "        prevValue = curValue;\n"
+              "    }\n"
+              "    if (endValue == mValues.end()) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10642
+        check("int f(std::vector<int> v) {\n"
+              "    return *(v.begin() + v.size() - 1);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10716
+        check("struct a;\n"
+              "class b {\n"
+              "  void c(std::map<std::string, a *> &);\n"
+              "  std::string d;\n"
+              "  std::map<std::string, std::set<std::string>> e;\n"
+              "};\n"
+              "void b::c(std::map<std::string, a *> &) {\n"
+              "  e.clear();\n"
+              "  auto f = *e[d].begin();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:9:23]: (error) Out of bounds access in expression 'e[d].begin()' because 'e[d]' is empty. [containerOutOfBounds]\n",
+                      errout_str());
+
+        // #10151
+        check("std::set<int>::iterator f(std::set<int>& s) {\n"
+              "for (auto it = s.begin(); it != s.end(); ++it)\n"
+              "    if (*it == 42)\n"
+              "        return s.erase(it);\n"
+              "    return s.end();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:0]: (style) Consider using std::find_if algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
+
+        // #11381
+        check("int f(std::map<int, int>& map) {\n"
+              "    auto it = map.find(1);\n"
+              "    if (it == map.end()) {\n"
+              "        bool bInserted;\n"
+              "        std::tie(it, bInserted) = map.emplace(1, 42);\n"
+              "    }\n"
+              "    return debug_valueflow(it)->second;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11557
+        check("bool f(const std::vector<int*>& v, std::vector<int*>::iterator it, bool b) {\n"
+              "    if (it == v.end())\n"
+              "        return false;\n"
+              "    if (b && ((it + 1) == v.end() || (*(it + 1)) != nullptr))\n"
+              "        return false;\n"
+              "    return true;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #6925
+        check("void f(const std::string& s, std::string::iterator i) {\n"
+              "    if (i != s.end() && *(i + 1) == *i) {\n"
+              "        if (i + 1 != s.end()) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:19] -> [test.cpp:2:29]: (warning) Either the condition 'i+1!=s.end()' is redundant or there is possible dereference of an invalid iterator: i+1. [derefInvalidIteratorRedundantCheck]\n",
+                      errout_str());
+
+        check("void f(bool b, std::vector<std::string> v) {\n" // #12680
+              "    if (!v.empty()) {\n"
+              "        auto it = v.begin();\n"
+              "        if (b) {\n"
+              "            v.clear();\n"
+              "            it = v.begin();\n"
+              "        }\n"
+              "        for (++it; it != v.end(); ++it) {}\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str()); // don't crash
+
+        check("void f(int);\n" // #13064
+              "void g() {\n"
+              "    std::vector<int> v{ 0 };\n"
+              "    auto it = std::find(v.begin(), v.end(), 0);\n"
+              "    if (it == v.end()) {\n"
+              "        f({});\n"
+              "        it = v.begin();\n"
+              "    }\n"
+              "    *it;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int g() {\n" // #13332
+              "    const std::vector<int> v = { 1, 2, 3, 4 };\n"
+              "    const std::vector<int>::const_iterator a[2] = { v.begin(), v.end() };\n"
+              "    return *a[0];\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void dereferenceInvalidIterator2() {
+        // Self-implemented iterator class
+        check("class iterator {\n"
+              "public:\n"
+              "    CCommitPointer m_ptr;\n"
+              "    iterator() {}\n"
+              "    CCommitPointer& operator*() {\n"
+              "        return m_ptr;\n"
+              "    }\n"
+              "    CCommitPointer* operator->() {\n"
+              "        return &m_ptr;\n"
+              "    }\n"
+              "    iterator& operator++() {\n"
+              "        ++m_ptr.m_place;\n"
+              "        return *this;\n"
+              "    }\n"
+              "    };\n"
+              "    iterator begin() {\n"
+              "    iterator it;\n"
+              "    it->m_place = 0;\n"
+              "    return it;\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:18:5]: (error, inconclusive) Invalid iterator 'it' used. [eraseDereference]\n", errout_str());
+    }
+
+    void loopAlgoElementAssign() {
+        check("void foo() {\n"
+              "    for(int& x:v)\n"
+              "        x = 1;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Consider using std::fill algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
+
+        check("void foo() {\n"
+              "    for(int& x:v)\n"
+              "        x = x + 1;\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Consider using std::transform algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
+
+        check("void foo(int a, int b) {\n"
+              "    for(int& x:v)\n"
+              "        x = a + b;\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Consider using std::fill or std::generate algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
+
+        check("void foo() {\n"
+              "    for(int& x:v)\n"
+              "        x += 1;\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Consider using std::transform algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
+
+        check("void foo() {\n"
+              "    for(int& x:v)\n"
+              "        x = f();\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Consider using std::generate algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
+
+        check("void foo() {\n"
+              "    for(int& x:v) {\n"
+              "        f();\n"
+              "        x = 1;\n"
+              "    }\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo() {\n"
+              "    for(int& x:v) {\n"
+              "        x = 1;\n"
+              "        f();\n"
+              "    }\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         // There should probably be a message for unconditional break
         check("void foo() {\n"
@@ -3451,15 +5395,15 @@ class TestStl : public TestFixture {
               "        break;\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    for(int& x:v)\n"
               "        x = ++x;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void loopAlgoAccumulateAssign() {
@@ -3468,32 +5412,32 @@ class TestStl : public TestFixture {
               "    for(int x:v)\n"
               "        n += x;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consider using std::accumulate algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Consider using std::accumulate algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("void foo() {\n"
               "    int n = 0;\n"
               "    for(int x:v)\n"
               "        n = n + x;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consider using std::accumulate algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Consider using std::accumulate algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("void foo() {\n"
               "    int n = 0;\n"
               "    for(int x:v)\n"
               "        n += 1;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consider using std::distance algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Consider using std::distance algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("void foo() {\n"
               "    int n = 0;\n"
               "    for(int x:v)\n"
               "        n = n + 1;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consider using std::distance algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Consider using std::distance algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("bool f(int);\n"
               "void foo() {\n"
@@ -3501,8 +5445,8 @@ class TestStl : public TestFixture {
               "    for(int x:v)\n"
               "        b &= f(x);\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:5]: (style) Consider using std::any_of, std::all_of, std::none_of, or std::accumulate algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(int);\n"
               "void foo() {\n"
@@ -3510,8 +5454,8 @@ class TestStl : public TestFixture {
               "    for(int x:v)\n"
               "        b |= f(x);\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:5]: (style) Consider using std::any_of, std::all_of, std::none_of, or std::accumulate algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(int);\n"
               "void foo() {\n"
@@ -3519,8 +5463,8 @@ class TestStl : public TestFixture {
               "    for(int x:v)\n"
               "        b = b && f(x);\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:5]: (style) Consider using std::any_of, std::all_of, std::none_of, or std::accumulate algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("bool f(int);\n"
               "void foo() {\n"
@@ -3528,16 +5472,107 @@ class TestStl : public TestFixture {
               "    for(int x:v)\n"
               "        b = b || f(x);\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:5]: (style) Consider using std::any_of, std::all_of, std::none_of, or std::accumulate algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    int n = 0;\n"
               "    for(int& x:v)\n"
               "        n = ++x;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::size_t f(const std::map<std::string, std::size_t>& m) {\n" // #10412
+              "    std::size_t t = 0;\n"
+              "    for (std::map<std::string, std::size_t>::const_iterator i = m.begin(); i != m.end(); ++i) {\n"
+              "        t += i->second;\n"
+              "    }\n"
+              "    for (std::map<std::string, std::size_t>::const_iterator i = m.begin(); i != m.end(); i++) {\n"
+              "        t += i->second;\n"
+              "    }\n"
+              "    return t; \n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Consider using std::accumulate algorithm instead of a raw loop. [useStlAlgorithm]\n"
+                      "[test.cpp:7:11]: (style) Consider using std::accumulate algorithm instead of a raw loop. [useStlAlgorithm]\n",
+                      errout_str());
+
+        check("int g(const std::vector<int>& v) {\n"
+              "    int t = 0;\n"
+              "    for (auto i = v.begin(); i != v.end(); ++i) {\n"
+              "        t += *i;\n"
+              "    }\n"
+              "    return t;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Consider using std::accumulate algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
+
+        check("auto g(const std::vector<int>& v) {\n"
+              "    std::vector<std::vector<int>::iterator> r;\n"
+              "    for (auto i = v.begin(); i != v.end(); ++i) {\n"
+              "        r.push_back(i);\n"
+              "    }\n"
+              "    return r;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::string f(std::vector<std::string> v) {\n"
+              "    std::string ret;\n"
+              "    for (const std::string& s : v)\n"
+              "        ret += s + '\\n';\n"
+              "    return ret;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::string f(const std::string& s) {\n"
+              "    std::string ret;\n"
+              "    for (char c : s)\n"
+              "        if (c != ' ')\n"
+              "            ret += i;\n"
+              "    return ret;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(const std::vector<int>& v) {\n"
+              "    int sum = 0;\n"
+              "    for (auto it = v.begin(); it != v.end(); it += 2)\n"
+              "        sum += *it;\n"
+              "    return sum;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(const std::vector<int>& v) {\n" // #12900
+              "    int x{};\n"
+              "    for (const auto i : v)\n"
+              "        x = dostuff(i);\n"
+              "    return x;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(const std::vector<int>& v) {\n" // #11493
+              "    int s = 0;\n"
+              "    for (std::size_t i = 0; i < v.size(); ++i)\n"
+              "        s += v[i];\n"
+              "    return s;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Consider using std::accumulate algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
+
+        check("int f(int n) {\n"
+              "    int s = 0;\n"
+              "    for (int i = 0; i < n; ++i)\n"
+              "        s += g(i);\n"
+              "    return s;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int g(int);\n"
+              "int f(const std::vector<int>&v, int n) {\n"
+              "    int s = 0;\n"
+              "    for (int i = 0; i < n; ++i) {\n"
+              "        s += g(i) + v[i];\n"
+              "    }\n"
+              "    return s;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void loopAlgoContainerInsert() {
@@ -3546,64 +5581,64 @@ class TestStl : public TestFixture {
               "    for(int x:v)\n"
               "        c.push_back(x);\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consider using std::copy algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Consider using std::copy algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("void foo() {\n"
               "    std::vector<int> c;\n"
               "    for(int x:v)\n"
               "        c.push_back(f(x));\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consider using std::transform algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Consider using std::transform algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("void foo() {\n"
               "    std::vector<int> c;\n"
               "    for(int x:v)\n"
               "        c.push_back(x + 1);\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consider using std::transform algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Consider using std::transform algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("void foo() {\n"
               "    std::vector<int> c;\n"
               "    for(int x:v)\n"
               "        c.push_front(x);\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consider using std::copy algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Consider using std::copy algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("void foo() {\n"
               "    std::vector<int> c;\n"
               "    for(int x:v)\n"
               "        c.push_front(f(x));\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consider using std::transform algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Consider using std::transform algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("void foo() {\n"
               "    std::vector<int> c;\n"
               "    for(int x:v)\n"
               "        c.push_front(x + 1);\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consider using std::transform algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Consider using std::transform algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("void foo() {\n"
               "    std::vector<int> c;\n"
               "    for(int x:v)\n"
               "        c.push_back(v);\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() {\n"
               "    std::vector<int> c;\n"
               "    for(int x:v)\n"
               "        c.push_back(0);\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void loopAlgoIncrement() {
@@ -3612,30 +5647,30 @@ class TestStl : public TestFixture {
               "    for(int x:v)\n"
               "        n++;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consider using std::distance algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:9]: (style) Consider using std::distance algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("void foo() {\n"
               "    int n = 0;\n"
               "    for(int x:v)\n"
               "        ++n;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consider using std::distance algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Consider using std::distance algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("void foo() {\n"
               "    for(int& x:v)\n"
               "        x++;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:3]: (style) Consider using std::transform algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Consider using std::transform algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("void foo() {\n"
               "    for(int& x:v)\n"
               "        ++x;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:3]: (style) Consider using std::transform algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Consider using std::transform algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
     }
 
     void loopAlgoConditional() {
@@ -3643,121 +5678,122 @@ class TestStl : public TestFixture {
               "void foo() {\n"
               "    for(int& x:v) {\n"
               "        if (pred(x)) {\n"
-              "            x = 1; \n"
+              "            x = 1;\n"
               "        }\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:5]: (style) Consider using std::replace_if algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:5:15]: (style) Consider using std::replace_if algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("bool pred(int x);\n"
               "void foo() {\n"
               "    int n = 0;\n"
               "    for(int x:v) {\n"
               "        if (pred(x)) {\n"
-              "            n += x; \n"
+              "            n += x;\n"
               "        }\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:6]: (style) Consider using std::accumulate algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:6:15]: (style) Consider using std::accumulate algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("bool pred(int x);\n"
               "void foo() {\n"
               "    int n = 0;\n"
               "    for(int x:v) {\n"
               "        if (pred(x)) {\n"
-              "            n += 1; \n"
+              "            n += 1;\n"
               "        }\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:6]: (style) Consider using std::count_if algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:6:15]: (style) Consider using std::count_if algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("bool pred(int x);\n"
               "void foo() {\n"
               "    int n = 0;\n"
               "    for(int x:v) {\n"
               "        if (pred(x)) {\n"
-              "            n++; \n"
+              "            n++;\n"
               "        }\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:6]: (style) Consider using std::count_if algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:6:13]: (style) Consider using std::count_if algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("bool pred(int x);\n"
               "void foo() {\n"
               "    for(int& x:v) {\n"
               "        if (pred(x)) {\n"
-              "            x = x + 1; \n"
+              "            x = x + 1;\n"
               "        }\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:5]: (style) Consider using std::transform algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:5:15]: (style) Consider using std::transform algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("bool pred(int x);\n"
               "void foo() {\n"
               "    std::vector<int> c;\n"
               "    for(int x:v) {\n"
               "        if (pred(x)) {\n"
-              "            c.push_back(x); \n"
+              "            c.push_back(x);\n"
               "        }\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:6]: (style) Consider using std::copy_if algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:6:14]: (style) Consider using std::copy_if algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("bool pred(int x);\n"
               "bool foo() {\n"
               "    for(int x:v) {\n"
               "        if (pred(x)) {\n"
-              "            return false; \n"
+              "            return false;\n"
               "        }\n"
               "    }\n"
               "    return true;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consider using std::any_of algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:5]: (style) Consider using std::all_of or std::none_of algorithm instead of a raw loop. [useStlAlgorithm]\n",
+                      errout_str());
 
         check("bool pred(int x);\n"
               "bool foo() {\n"
               "    for(int x:v) {\n"
               "        if (pred(x)) {\n"
-              "            break; \n"
+              "            break;\n"
               "        }\n"
               "    }\n"
               "    return true;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consider using std::any_of algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:22]: (style) Consider using std::any_of algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("bool pred(int x);\n"
               "void f();\n"
               "void foo() {\n"
               "    for(int x:v) {\n"
               "        if (pred(x)) {\n"
-              "            f(); \n"
-              "            break; \n"
+              "            f();\n"
+              "            break;\n"
               "        }\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:5]: (style) Consider using std::any_of algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:5:22]: (style) Consider using std::any_of algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("bool pred(int x);\n"
               "void f(int x);\n"
               "void foo() {\n"
               "    for(int x:v) {\n"
               "        if (pred(x)) {\n"
-              "            f(x); \n"
-              "            break; \n"
+              "            f(x);\n"
+              "            break;\n"
               "        }\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:5]: (style) Consider using std::find_if algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:5:22]: (style) Consider using std::find_if algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("bool pred(int x);\n"
               "bool foo() {\n"
@@ -3770,8 +5806,8 @@ class TestStl : public TestFixture {
               "    if(b) {}\n"
               "    return true;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:6]: (style) Consider using std::any_of, std::all_of, std::none_of, or std::accumulate algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("bool pred(int x);\n"
               "bool foo() {\n"
@@ -3783,8 +5819,8 @@ class TestStl : public TestFixture {
               "    }\n"
               "    return true;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:6]: (style) Consider using std::any_of, std::all_of, std::none_of, or std::accumulate algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("bool pred(int x);\n"
               "bool foo() {\n"
@@ -3796,20 +5832,20 @@ class TestStl : public TestFixture {
               "    }\n"
               "    return true;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:6]: (style) Consider using std::any_of, std::all_of, std::none_of, or std::accumulate algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("bool pred(int x);\n"
               "bool foo() {\n"
               "    for(int x:v) {\n"
               "        if (pred(x)) {\n"
-              "            return false; \n"
+              "            return false;\n"
               "        }\n"
               "        return true;\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         // There is no transform_if
         check("bool pred(int x);\n"
@@ -3817,24 +5853,24 @@ class TestStl : public TestFixture {
               "    std::vector<int> c;\n"
               "    for(int x:v) {\n"
               "        if (pred(x)) {\n"
-              "            c.push_back(x + 1); \n"
+              "            c.push_back(x + 1);\n"
               "        }\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("bool pred(int x);\n"
               "void foo() {\n"
               "    for(int& x:v) {\n"
               "        x++;\n"
               "        if (pred(x)) {\n"
-              "            x = 1; \n"
+              "            x = 1;\n"
               "        }\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("bool pred(int x);\n"
               "void f();\n"
@@ -3842,12 +5878,129 @@ class TestStl : public TestFixture {
               "    for(int x:v) {\n"
               "        if (pred(x)) {\n"
               "            if(x) { return; }\n"
-              "            break; \n"
+              "            break;\n"
               "        }\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool g(int);\n"
+              "int f(const std::vector<int>& v) {\n"
+              "    int ret = 0;\n"
+              "    for (const auto i : v)\n"
+              "        if (!g(i))\n"
+              "            ret = 1;\n"
+              "    return ret;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(const std::vector<int>& v) {\n"
+              "    int ret = 0;\n"
+              "    for (const auto i : v)\n"
+              "        if (i < 5)\n"
+              "            ret = 1;\n"
+              "    return ret;\n"
+              "}\n");
+        TODO_ASSERT_EQUALS("[test.cpp:5]: (style) Consider using std::any_of, std::all_of, std::none_of algorithm instead of a raw loop.\n",
+                           "",
+                           errout_str());
+
+        check("int f(const std::vector<int>& v) {\n"
+              "    int ret = 0;\n"
+              "    for (const auto i : v)\n"
+              "        if (i < 5) {\n"
+              "            ret = 1;\n"
+              "            break;\n"
+              "        }\n"
+              "    return ret;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:20]: (style) Consider using std::any_of algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
+
+        check("struct T {\n"
+              "    std::vector<int> v0, v1;\n"
+              "    void g();\n"
+              "};\n"
+              "void T::g() {\n"
+              "    for (std::vector<int>::const_iterator it0 = v0.cbegin(); it0 != v0.cend(); ++it0) {\n"
+              "        std::vector<int>::iterator it1;\n"
+              "        for (it1 = v1.begin(); it1 != v1.end(); ++it1)\n"
+              "            if (*it0 == *it1)\n"
+              "                break;\n"
+              "        if (it1 != v1.end())\n"
+              "            v1.erase(it1);\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:9:0]: (style) Consider using std::find_if algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
+
+        check("bool f(const std::set<std::string>& set, const std::string& f) {\n" // #11595
+              "    for (const std::string& s : set) {\n"
+              "        if (f.length() >= s.length() && f.compare(0, s.length(), s) == 0) {\n"
+              "            return true;\n"
+              "        }\n"
+              "    }\n"
+              "    return false;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:5]: (style) Consider using std::any_of algorithm instead of a raw loop. [useStlAlgorithm]\n",
+                      errout_str());
+
+        check("void f() {\n" // #12064
+              "    for (const auto& animal : { \"cat\", \"bat\", \"tiger\", \"rat\" })\n"
+              "        if (std::strlen(animal) > 4)\n"
+              "            throw 1;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool f(const std::vector<int>& v, const std::vector<int>& w, int n) {\n"
+              "    for (int i = 0; i < n; ++i)\n"
+              "        if (v[i] == w[i])\n"
+              "            return true;\n"
+              "    return false;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool f(int n) {\n"
+              "    for (int i = 0; i < n; ++i)\n"
+              "        if (g(i))\n"
+              "            return true;\n"
+              "    return false;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool g(int);\n"
+              "bool f(const std::vector<int>&v, int n) {\n"
+              "    bool b{};\n"
+              "    for (int i = 0; i < n; ++i) {\n"
+              "        if (v[i] > 0 && g(i)) {\n"
+              "            b = true;\n"
+              "            break;\n"
+              "        }\n"
+              "    }\n"
+              "    return b;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool get_index(const std::vector<int>& items, int value, size_t& index) {\n" // #14047
+              "    size_t current_index = 0;\n"
+              "    for (size_t i = 0; i < items.size(); ++i) {\n"
+              "        if (items[i] == value) {\n"
+              "            if (current_index != index) {\n"
+              "                current_index++;\n"
+              "                continue;\n"
+              "            }\n"
+              "            index = i;\n"
+              "            return true;\n"
+              "        }\n"
+              "    }\n"
+              "    return false;\n"
+              "}\n"
+              "int main() {\n"
+              "    std::vector<int> items{ 0, 1, 1, 1 };\n"
+              "    size_t index = 2;\n"
+              "    get_index(items, 1, index);\n"
+              "    return index;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void loopAlgoMinMax() {
@@ -3856,40 +6009,203 @@ class TestStl : public TestFixture {
               "    for(int x:v)\n"
               "        n = x > n ? x : n;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consider using std::max_element algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Consider using std::max_element algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("void foo() {\n"
               "    int n = 0;\n"
               "    for(int x:v)\n"
               "        n = x < n ? x : n;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consider using std::min_element algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Consider using std::min_element algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("void foo() {\n"
               "    int n = 0;\n"
               "    for(int x:v)\n"
               "        n = x > n ? n : x;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consider using std::min_element algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Consider using std::min_element algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("void foo() {\n"
               "    int n = 0;\n"
               "    for(int x:v)\n"
               "        n = x < n ? n : x;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consider using std::max_element algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Consider using std::max_element algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
 
         check("void foo(int m) {\n"
               "    int n = 0;\n"
               "    for(int x:v)\n"
               "        n = x > m ? x : n;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:4]: (style) Consider using std::accumulate algorithm instead of a raw loop.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Consider using std::accumulate algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
+
+        check("void f(const std::vector<int>& v) {\n" // #9091
+              "    int maxY = 0;\n"
+              "    for (int y : v) {\n"
+              "        if (y > maxY)\n"
+              "            maxY = y;\n"
+              "    }\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:5:18]: (style) Consider using std::max_element algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
+
+        check("int f(const std::vector<int>& v) {\n"
+              "    int minY = 0;\n"
+              "    for (int y : v) {\n"
+              "        if (y < minY)\n"
+              "            minY = y;\n"
+              "    }\n"
+              "    return minY;\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:5:18]: (style) Consider using std::min_element algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
+
+        check("int f(const std::vector<int>& v) {\n"
+              "    int max = 0;\n"
+              "    for (int i = 0; i < n; ++i)\n"
+              "        max = v[i] > max ? v[i] : max;\n"
+              "    return max;\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:13]: (style) Consider using std::max_element algorithm instead of a raw loop. [useStlAlgorithm]\n",
+                      errout_str());
+
+        check("int f(const std::vector<int>& v) {\n"
+              "    int min = 0;\n"
+              "    for (int i = 0; i < n; ++i)\n"
+              "        min = v[i] < min ? v[i] : min;\n"
+              "    return min;\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:13]: (style) Consider using std::min_element algorithm instead of a raw loop. [useStlAlgorithm]\n",
+                      errout_str());
+    }
+
+    void loopAlgoMultipleReturn()
+    {
+        check("bool f(const std::vector<int>& v) {\n"
+              "    for (auto i : v) {\n"
+              "        if (i < 0)\n"
+              "            continue;\n"
+              "        if (i)\n"
+              "            return true;\n"
+              "    }\n"
+              "    return false;\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:2:5]: (style) Consider using std::any_of algorithm instead of a raw loop. [useStlAlgorithm]\n",
+                      errout_str());
+
+        check("bool g(const std::vector<int>& v) {\n"
+              "    for (auto i : v) {\n"
+              "        if (i % 5 == 0)\n"
+              "            return true;\n"
+              "        if (i % 7 == 0)\n"
+              "            return true;\n"
+              "    }\n"
+              "    return false;\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:2:5]: (style) Consider using std::any_of algorithm instead of a raw loop. [useStlAlgorithm]\n",
+                      errout_str());
+
+        check("bool g(const std::vector<int>& v) {\n"
+              "    for (auto i : v) {\n"
+              "        if (i % 5 == 0)\n"
+              "            return false;\n"
+              "        if (i % 7 == 0)\n"
+              "            return true;\n"
+              "    }\n"
+              "    return false;\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool g(std::vector<int>& v) {\n"
+              "    for (auto& i : v) {\n"
+              "        if (i % 5 == 0)\n"
+              "            return false;\n"
+              "        if (i % 7 == 0)\n"
+              "            i++;\n"
+              "    }\n"
+              "    return false;\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool g(const std::vector<int>& v, int& j) {\n"
+              "    for (auto i : v) {\n"
+              "        if (i % 5 == 0)\n"
+              "            return false;\n"
+              "        if (i % 7 == 0)\n"
+              "            j++;\n"
+              "    }\n"
+              "    return false;\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool g(const std::vector<int>& v, int& j) {\n"
+              "    for (auto i : v) {\n"
+              "        int& k = j;\n"
+              "        if (i % 5 == 0)\n"
+              "            return false;\n"
+              "        if (i % 7 == 0)\n"
+              "            k++;\n"
+              "    }\n"
+              "    return false;\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool g(const std::vector<int>& v, int& j) {\n"
+              "    for (auto i : v) {\n"
+              "        int* k = &j;\n"
+              "        if (i % 5 == 0)\n"
+              "            return false;\n"
+              "        if (i % 7 == 0)\n"
+              "            (*k)++;\n"
+              "    }\n"
+              "    return false;\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool g(const std::vector<int>& v, int j) {\n"
+              "    for (auto i : v) {\n"
+              "        int k = j;\n"
+              "        if (i % 5 == 0)\n"
+              "            return false;\n"
+              "        if (i % 7 == 0)\n"
+              "            k++;\n"
+              "    }\n"
+              "    return false;\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:2:5]: (style) Consider using std::all_of or std::none_of algorithm instead of a raw loop. [useStlAlgorithm]\n",
+                      errout_str());
+
+        check("class C {\n"
+              "private:\n"
+              "    QString s;\n"
+              "public:\n"
+              "    C(QString);\n"
+              "private:\n"
+              "    void f() {\n"
+              "        QVERIFY(QDir(s).exists());\n"
+              "    }\n"
+              "    void f(const QStringList& d) {\n"
+              "        for (QString f : d)\n"
+              "          QDir(s);\n"
+              "    }\n"
+              "};\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void invalidContainer() {
@@ -3898,8 +6214,8 @@ class TestStl : public TestFixture {
               "    v.push_back(123);\n"
               "    std::cout << *v0 << std::endl;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:2] -> [test.cpp:3] -> [test.cpp:1] -> [test.cpp:4]: (error) Using iterator to local container 'v' that may be invalid.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:1:27] -> [test.cpp:2:22] -> [test.cpp:3:7] -> [test.cpp:1:26] -> [test.cpp:4:19]: (error) Using iterator to local container 'v' that may be invalid. [invalidContainer]\n", errout_str());
 
         check("std::string e();\n"
               "void a() {\n"
@@ -3910,16 +6226,16 @@ class TestStl : public TestFixture {
               "    if (d != f.end()) {}\n"
               "  }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(std::vector<int> &v) {\n"
               "    int *v0 = &v[0];\n"
               "    v.push_back(123);\n"
               "    std::cout << (*v0)[0] << std::endl;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:1] -> [test.cpp:2] -> [test.cpp:3] -> [test.cpp:1] -> [test.cpp:4]: (error) Using pointer to local variable 'v' that may be invalid.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:1:27] -> [test.cpp:2:15] -> [test.cpp:3:7] -> [test.cpp:1:26] -> [test.cpp:4:20]: (error) Using pointer to local variable 'v' that may be invalid. [invalidContainer]\n", errout_str());
 
         check("void f() {\n"
               "    std::vector<int> v = {1};\n"
@@ -3927,10 +6243,10 @@ class TestStl : public TestFixture {
               "    v.push_back(123);\n"
               "    std::cout << v0 << std::endl;\n"
               "}\n",
-              true);
+              dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS(
-            "[test.cpp:3] -> [test.cpp:3] -> [test.cpp:4] -> [test.cpp:5]: (error) Reference to v that may be invalid.\n",
-            errout.str());
+            "[test.cpp:3:13] -> [test.cpp:3:17] -> [test.cpp:4:7] -> [test.cpp:5:18]: (error) Reference to v that may be invalid. [invalidContainerReference]\n",
+            errout_str());
 
         check("void f() {\n"
               "    std::vector<int> v = {1};\n"
@@ -3938,37 +6254,37 @@ class TestStl : public TestFixture {
               "    v.push_back(123);\n"
               "    std::cout << v0 << std::endl;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:4] -> [test.cpp:5]: (error) Reference to v that may be invalid.\n",
-                      errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:13] -> [test.cpp:4:7] -> [test.cpp:5:18]: (error) Reference to v that may be invalid. [invalidContainerReference]\n",
+                      errout_str());
 
         check("void f(std::vector<int> &v) {\n"
               "    int &v0 = v.front();\n"
               "    v.push_back(123);\n"
               "    std::cout << v0 << std::endl;\n"
               "}\n",
-              true);
+              dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS(
-            "[test.cpp:2] -> [test.cpp:2] -> [test.cpp:1] -> [test.cpp:3] -> [test.cpp:4]: (error) Reference to v that may be invalid.\n",
-            errout.str());
+            "[test.cpp:2:13] -> [test.cpp:2:17] -> [test.cpp:1:27] -> [test.cpp:3:7] -> [test.cpp:4:18]: (error) Reference to v that may be invalid. [invalidContainerReference]\n",
+            errout_str());
 
         check("void f(std::vector<int> &v) {\n"
               "    int &v0 = v[0];\n"
               "    v.push_back(123);\n"
               "    std::cout << v0 << std::endl;\n"
               "}\n",
-              true);
+              dinit(CheckOptions, $.inconclusive = true));
         ASSERT_EQUALS(
-            "[test.cpp:2] -> [test.cpp:1] -> [test.cpp:3] -> [test.cpp:4]: (error) Reference to v that may be invalid.\n",
-            errout.str());
+            "[test.cpp:2:13] -> [test.cpp:1:27] -> [test.cpp:3:7] -> [test.cpp:4:18]: (error) Reference to v that may be invalid. [invalidContainerReference]\n",
+            errout_str());
 
         check("void f(std::vector<int> &v) {\n"
               "    std::vector<int> *v0 = &v;\n"
               "    v.push_back(123);\n"
               "    std::cout << (*v0)[0] << std::endl;\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("const std::vector<int> * g(int);\n"
               "void f() {\n"
@@ -3983,8 +6299,8 @@ class TestStl : public TestFixture {
               "        if (m == 0) {}\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("std::vector<std::string> g();\n"
               "void f() {\n"
@@ -3993,8 +6309,380 @@ class TestStl : public TestFixture {
               "    std::string z;\n"
               "    z += \"\";\n"
               "    z += y;\n"
-              "}\n",true);
-        ASSERT_EQUALS("", errout.str());
+              "}\n",dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::vector<char> v)\n"
+              "{\n"
+              "    auto *cur = v.data();\n"
+              "    auto *end = cur + v.size();\n"
+              "    while (cur < end) {\n"
+              "        v.erase(v.begin(), FindNext(v));\n"
+              "        cur = v.data();\n"
+              "        end = cur + v.size();\n"
+              "    }\n"
+              "}\n",dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        // #9598
+        check("void f(std::vector<std::string> v) {\n"
+              "    for (auto it = v.begin(); it != v.end(); it = v.erase(it))\n"
+              "        *it;\n"
+              "}\n",dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        // #9714
+        check("void f() {\n"
+              "  auto v = std::vector<std::string>();\n"
+              "  std::string x;\n"
+              "  v.push_back(x.insert(0, \"x\"));\n"
+              "  v.push_back(\"y\");\n"
+              "}\n",dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        // #9783
+        check("std::string GetTaskIDPerUUID(int);\n"
+              "void InitializeJumpList(CString s);\n"
+              "void foo() {\n"
+              "    CString sAppID = GetTaskIDPerUUID(123).c_str();\n"
+              "    InitializeJumpList(sAppID);\n"
+              "}\n",dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+        // #9796
+        check("struct A {};\n"
+              "void f() {\n"
+              "    std::vector<A *> v;\n"
+              "    A *a = new A();\n"
+              "    v.push_back(a);\n"
+              "    A *b = v.back();\n"
+              "    v.pop_back();\n"
+              "    delete b;\n"
+              "}\n",dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {};\n"
+              "void f() {\n"
+              "    std::vector<A *, std::allocator<A*>> v;\n"
+              "    A *a = new A();\n"
+              "    v.push_back(a);\n"
+              "    A *b = v.back();\n"
+              "    v.pop_back();\n"
+              "    delete b;\n"
+              "}\n",dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {};\n"
+              "void f() {\n"
+              "    std::vector<std::shared_ptr<A>> v;\n"
+              "    std::shared_ptr<A> a = std::make_shared<A>();\n"
+              "    v.push_back(a);\n"
+              "    std::shared_ptr<A> b = v.back();\n"
+              "    v.pop_back();\n"
+              "    delete b;\n"
+              "}\n",dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        // #9780
+        check("int f() {\n"
+              "    std::vector<int> vect;\n"
+              "    MyStruct info{};\n"
+              "    info.vect = &vect;\n"
+              "    vect.push_back(1);\n"
+              "    return info.ret;\n"
+              "}\n",dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        // #9133
+        check("struct Fred {\n"
+              "    std::vector<int> v;\n"
+              "    void foo();\n"
+              "    void bar();\n"
+              "};\n"
+              "void Fred::foo() {\n"
+              "    std::vector<int>::iterator it = v.begin();\n"
+              "    bar();\n"
+              "    it++;\n"
+              "}\n"
+              "void Fred::bar() {\n"
+              "    v.push_back(0);\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS(
+            "[test.cpp:7:44] -> [test.cpp:8:5] -> [test.cpp:12:7] -> [test.cpp:9:5]: (error) Using iterator to member container 'v' that may be invalid. [invalidContainer]\n",
+            errout_str());
+
+        check("void foo(std::vector<int>& v) {\n"
+              "    std::vector<int>::iterator it = v.begin();\n"
+              "    bar(v);\n"
+              "    it++;\n"
+              "}\n"
+              "void bar(std::vector<int>& v) {\n"
+              "    v.push_back(0);\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS(
+            "[test.cpp:1:29] -> [test.cpp:2:44] -> [test.cpp:3:5] -> [test.cpp:7:7] -> [test.cpp:1:28] -> [test.cpp:4:5]: (error) Using iterator to local container 'v' that may be invalid. [invalidContainer]\n",
+            errout_str());
+
+        // #10264
+        check("void f(std::vector<std::string>& x) {\n"
+              "  struct I {\n"
+              "    std::vector<std::string> *px{};\n"
+              "  };\n"
+              "  I i = { &x };\n"
+              "  x.clear();\n"
+              "  Parse(i);\n"
+              "}\n",dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "  std::string x;\n"
+              "  struct V {\n"
+              "    std::string* pStr{};\n"
+              "  };\n"
+              "  struct I {\n"
+              "    std::vector<V> v;\n"
+              "  };\n"
+              "  I b[] = {{{{ &x }}}};\n"
+              "  x = \"Arial\";\n"
+              "  I cb[1];\n"
+              "  for (long i = 0; i < 1; ++i)\n"
+              "    cb[i] = b[i];\n"
+              "}\n",dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        // #9836
+        check("void f() {\n"
+              "    auto v = std::vector<std::vector<std::string> >{ std::vector<std::string>{ \"hello\" } };\n"
+              "    auto p = &(v.at(0).at(0));\n"
+              "    v.clear();\n"
+              "    std::cout << *p << std::endl;\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS(
+            "[test.cpp:3:24] -> [test.cpp:3:18] -> [test.cpp:3:14] -> [test.cpp:4:7] -> [test.cpp:2:10] -> [test.cpp:5:19]: (error) Using pointer to local variable 'v' that may be invalid. [invalidContainer]\n",
+            errout_str());
+
+        check("struct A {\n"
+              "    const std::vector<int>* i;\n"
+              "    A(const std::vector<int>& v)\n"
+              "    : i(&v)\n"
+              "    {}\n"
+              "};\n"
+              "int f() {\n"
+              "    std::vector<int> v;\n"
+              "    A a{v};\n"
+              "    v.push_back(1);\n"
+              "    return a.i->front();\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "    const std::vector<int>* i;\n"
+              "    A(const std::vector<int>& v)\n"
+              "    : i(&v)\n"
+              "    {}\n"
+              "};\n"
+              "void g(const std::vector<int>& v);\n"
+              "void f() {\n"
+              "    std::vector<int> v;\n"
+              "    A a{v};\n"
+              "    v.push_back(1);\n"
+              "    g(a);\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        // #10984
+        check("void f() {\n"
+              "    std::vector<int> v;\n"
+              "    auto g = [&v]{};\n"
+              "    v.push_back(1);\n"
+              "    g();\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::vector<int> v) {\n"
+              "    auto it = v.begin();\n"
+              "    auto g = [&]{ std::cout << *it << std::endl;};\n"
+              "    v.push_back(1);\n"
+              "    g();\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS(
+            "[test.cpp:2:22] -> [test.cpp:3:33] -> [test.cpp:4:7] -> [test.cpp:1:25] -> [test.cpp:5:5]: (error) Using iterator to local container 'v' that may be invalid. [invalidContainer]\n",
+            errout_str());
+
+        check("void f(std::vector<int> v) {\n"
+              "    auto it = v.begin();\n"
+              "    auto g = [=]{ std::cout << *it << std::endl;};\n"
+              "    v.push_back(1);\n"
+              "    g();\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS(
+            "[test.cpp:2:22] -> [test.cpp:4:7] -> [test.cpp:1:25] -> [test.cpp:5:5]: (error) Using iterator to local container 'v' that may be invalid. [invalidContainer]\n",
+            errout_str());
+
+        check("struct A {\n"
+              "    int* p;\n"
+              "    void g();\n"
+              "};\n"
+              "void f(std::vector<int> v) {\n"
+              "    auto it = v.begin();\n"
+              "    A a{v.data()};\n"
+              "    v.push_back(1);\n"
+              "    a.g();\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS(
+            "[test.cpp:7:15] -> [test.cpp:8:7] -> [test.cpp:5:25] -> [test.cpp:9:5]: (error) Using object that points to local variable 'v' that may be invalid. [invalidContainer]\n",
+            errout_str());
+
+        check("struct A {\n"
+              "    int*& p;\n"
+              "    void g();\n"
+              "};\n"
+              "void f(std::vector<int> v) {\n"
+              "    auto* p = v.data();\n"
+              "    A a{p};\n"
+              "    v.push_back(1);\n"
+              "    a.g();\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS(
+            "[test.cpp:6:21] -> [test.cpp:7:9] -> [test.cpp:8:7] -> [test.cpp:5:25] -> [test.cpp:9:5]: (error) Using object that points to local variable 'v' that may be invalid. [invalidContainer]\n",
+            errout_str());
+
+        // #11028
+        check("void f(std::vector<int> c) {\n"
+              "    std::vector<int> d(c.begin(), c.end());\n"
+              "    c.erase(c.begin());\n"
+              "    d.push_back(0);\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        // #11147
+        check("void f(std::string& s) {\n"
+              "    if (!s.empty()) {\n"
+              "        std::string::iterator it = s.begin();\n"
+              "        s = s.substr(it - s.begin());\n"
+              "    }\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS(
+            "[test.cpp:4:13]: (performance) Ineffective call of function 'substr' because a prefix of the string is assigned to itself. Use resize() or pop_back() instead. [uselessCallsSubstr]\n",
+            errout_str());
+
+        // #11630
+        check("int main(int argc, const char* argv[]) {\n"
+              "    std::vector<std::string> args(argv + 1, argv + argc);\n"
+              "    args.push_back(\"-h\");\n"
+              "    args.front();\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::vector<int>& v) {\n" // #13108
+              "    auto it = unknown(v);\n"
+              "    auto w = std::vector<int>{ it, v.end() };\n"
+              "    v.erase(it, v.end());\n"
+              "    for (const auto& i : w) {}\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        // #13410
+        check("int f(std::vector<int>& v) {\n"
+              "    const int* i = &*v.cbegin();\n"
+              "    v.push_back(1);\n"
+              "    return *i;\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS(
+            "[test.cpp:1:26] -> [test.cpp:2:30] -> [test.cpp:1:26] -> [test.cpp:2:20] -> [test.cpp:2:20] -> [test.cpp:3:7] -> [test.cpp:1:25] -> [test.cpp:4:13]: (error) Using pointer to local variable 'v' that may be invalid. [invalidContainer]\n",
+            errout_str());
+
+        // #9834
+        check("struct CJ {\n"
+              "    std::string m_string1 = \"hello\";\n"
+              "};\n"
+              "void f() {\n"
+              "    std::vector<CJ> vec1;\n"
+              "    vec1.push_back(CJ());\n"
+              "    auto& a_ref = vec1.at(0).m_string1;\n"
+              "    vec1.clear();\n"
+              "    std::cout << a_ref << std::endl;\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS(
+            "[test.cpp:7:17] -> [test.cpp:7:24] -> [test.cpp:8:10] -> [test.cpp:9:18]: (error) Reference to vec1 that may be invalid. [invalidContainerReference]\n",
+            errout_str());
+    }
+
+    void invalidContainerLoop() {
+        // #9435
+        check("void f(std::vector<int> v) {\n"
+              "    for (auto i : v) {\n"
+              "        if (i < 5)\n"
+              "            v.push_back(i * 2);\n"
+              "    }\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:2:5] -> [test.cpp:4:15]: (error) Calling 'push_back' while iterating the container is invalid. [invalidContainerLoop]\n", errout_str());
+
+        // #9713
+        check("void f() {\n"
+              "  std::vector<int> v{1, 2, 3};\n"
+              "  for (int i : v) {\n"
+              "    if (i == 2) {\n"
+              "      v.clear();\n"
+              "      return;\n"
+              "    }\n"
+              "  }\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:17]: (style) Consider using std::any_of algorithm instead of a raw loop. [useStlAlgorithm]\n", errout_str());
+
+        check("struct A {\n"
+              "  std::vector<int> v;\n"
+              "  void add(int i) {\n"
+              "    v.push_back(i);\n"
+              "  } \n"
+              "  void f() {\n"
+              "    for(auto i:v)\n"
+              "      add(i);\n"
+              "  }\n"
+              "};\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS(
+            "[test.cpp:4:7] -> [test.cpp:7:5] -> [test.cpp:8:7]: (error) Calling 'add' while iterating the container is invalid. [invalidContainerLoop]\n",
+            errout_str());
+
+        check("struct S { int i; };\n" // #14013
+              "void f() {\n"
+              "    std::vector<std::unique_ptr<S>> v;\n"
+              "    for (int i = 0; i < 5; ++i) {\n"
+              "        std::unique_ptr<S>& r = v.emplace_back(std::make_unique<S>());\n"
+              "        r->i = 1;\n"
+              "    }\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S { int i; };\n"
+              "void f() {\n"
+              "    std::vector<std::unique_ptr<S>> v;\n"
+              "    for (int i = 0; i < 5; ++i) {\n"
+              "        std::unique_ptr<S>& r{ v.emplace_back(std::make_unique<S>()) };\n"
+              "        r->i = 1;\n"
+              "    }\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void findInsert() {
@@ -4003,8 +6691,8 @@ class TestStl : public TestFixture {
               "        s.insert(x);\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Searching before insertion is not necessary.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:18]: (performance) Searching before insertion is not necessary. [stlFindInsert]\n", errout_str());
 
         check("void f2(std::map<unsigned, unsigned>& m, unsigned x) {\n"
               "    if (m.find(x) == m.end()) {\n"
@@ -4013,24 +6701,24 @@ class TestStl : public TestFixture {
               "        m[x] = 1;\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Searching before insertion is not necessary.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:22]: (performance) Searching before insertion is not necessary. [stlFindInsert]\n", errout_str());
 
         check("void f3(std::map<unsigned, unsigned>& m, unsigned x) {\n"
               "    if (m.count(x) == 0) {\n"
               "        m.emplace(x, 1);\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Searching before insertion is not necessary.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:22]: (performance) Searching before insertion is not necessary. [stlFindInsert]\n", errout_str());
 
         check("void f4(std::set<unsigned>& s, unsigned x) {\n"
               "    if (s.find(x) == s.end()) {\n"
               "        s.insert(x);\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Searching before insertion is not necessary.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:18]: (performance) Searching before insertion is not necessary. [stlFindInsert]\n", errout_str());
 
         check("void f5(std::map<unsigned, unsigned>& m, unsigned x) {\n"
               "    if (m.count(x) == 0) {\n"
@@ -4039,24 +6727,24 @@ class TestStl : public TestFixture {
               "        m[x] = 1;\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Searching before insertion is not necessary.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:22]: (performance) Searching before insertion is not necessary. [stlFindInsert]\n", errout_str());
 
         check("void f6(std::map<unsigned, unsigned>& m, unsigned x) {\n"
               "    if (m.count(x) == 0) {\n"
               "        m.emplace(x, 1);\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Searching before insertion is not necessary.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:22]: (performance) Searching before insertion is not necessary. [stlFindInsert]\n", errout_str());
 
         check("void f1(std::unordered_set<unsigned>& s, unsigned x) {\n"
               "    if (s.find(x) == s.end()) {\n"
               "        s.insert(x);\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Searching before insertion is not necessary.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:18]: (performance) Searching before insertion is not necessary. [stlFindInsert]\n", errout_str());
 
         check("void f2(std::unordered_map<unsigned, unsigned>& m, unsigned x) {\n"
               "    if (m.find(x) == m.end()) {\n"
@@ -4065,24 +6753,24 @@ class TestStl : public TestFixture {
               "        m[x] = 1;\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Searching before insertion is not necessary.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:22]: (performance) Searching before insertion is not necessary. [stlFindInsert]\n", errout_str());
 
         check("void f3(std::unordered_map<unsigned, unsigned>& m, unsigned x) {\n"
               "    if (m.count(x) == 0) {\n"
               "        m.emplace(x, 1);\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Searching before insertion is not necessary.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:22]: (performance) Searching before insertion is not necessary. [stlFindInsert]\n", errout_str());
 
         check("void f4(std::unordered_set<unsigned>& s, unsigned x) {\n"
               "    if (s.find(x) == s.end()) {\n"
               "        s.insert(x);\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Searching before insertion is not necessary.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:18]: (performance) Searching before insertion is not necessary. [stlFindInsert]\n", errout_str());
 
         check("void f5(std::unordered_map<unsigned, unsigned>& m, unsigned x) {\n"
               "    if (m.count(x) == 0) {\n"
@@ -4091,16 +6779,16 @@ class TestStl : public TestFixture {
               "        m[x] = 1;\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Searching before insertion is not necessary.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:22]: (performance) Searching before insertion is not necessary. [stlFindInsert]\n", errout_str());
 
         check("void f6(std::unordered_map<unsigned, unsigned>& m, unsigned x) {\n"
               "    if (m.count(x) == 0) {\n"
               "        m.emplace(x, 1);\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("[test.cpp:3]: (performance) Searching before insertion is not necessary.\n", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:22]: (performance) Searching before insertion is not necessary. [stlFindInsert]\n", errout_str());
 
         check("void g1(std::map<unsigned, unsigned>& m, unsigned x) {\n"
               "    if (m.find(x) == m.end()) {\n"
@@ -4109,8 +6797,8 @@ class TestStl : public TestFixture {
               "        m[x] = 2;\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void g1(std::map<unsigned, unsigned>& m, unsigned x) {\n"
               "    if (m.count(x) == 0) {\n"
@@ -4119,24 +6807,24 @@ class TestStl : public TestFixture {
               "        m[x] = 2;\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f1(QSet<unsigned>& s, unsigned x) {\n"
               "    if (s.find(x) == s.end()) {\n"
               "        s.insert(x);\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f1(std::multiset<unsigned>& s, unsigned x) {\n"
               "    if (s.find(x) == s.end()) {\n"
               "        s.insert(x);\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f2(std::multimap<unsigned, unsigned>& m, unsigned x) {\n"
               "    if (m.find(x) == m.end()) {\n"
@@ -4145,24 +6833,24 @@ class TestStl : public TestFixture {
               "        m[x] = 1;\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f3(std::multimap<unsigned, unsigned>& m, unsigned x) {\n"
               "    if (m.count(x) == 0) {\n"
               "        m.emplace(x, 1);\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f4(std::multiset<unsigned>& s, unsigned x) {\n"
               "    if (s.find(x) == s.end()) {\n"
               "        s.insert(x);\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f5(std::multimap<unsigned, unsigned>& m, unsigned x) {\n"
               "    if (m.count(x) == 0) {\n"
@@ -4171,16 +6859,16 @@ class TestStl : public TestFixture {
               "        m[x] = 1;\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f1(std::unordered_multiset<unsigned>& s, unsigned x) {\n"
               "    if (s.find(x) == s.end()) {\n"
               "        s.insert(x);\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f2(std::unordered_multimap<unsigned, unsigned>& m, unsigned x) {\n"
               "    if (m.find(x) == m.end()) {\n"
@@ -4189,24 +6877,24 @@ class TestStl : public TestFixture {
               "        m[x] = 1;\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f3(std::unordered_multimap<unsigned, unsigned>& m, unsigned x) {\n"
               "    if (m.count(x) == 0) {\n"
               "        m.emplace(x, 1);\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f4(std::unordered_multiset<unsigned>& s, unsigned x) {\n"
               "    if (s.find(x) == s.end()) {\n"
               "        s.insert(x);\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
 
         check("void f5(std::unordered_multimap<unsigned, unsigned>& m, unsigned x) {\n"
               "    if (m.count(x) == 0) {\n"
@@ -4215,8 +6903,416 @@ class TestStl : public TestFixture {
               "        m[x] = 1;\n"
               "    }\n"
               "}\n",
-              true);
-        ASSERT_EQUALS("", errout.str());
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        // #9218 - not small type => do not warn if cpp standard is < c++17
+        {
+            Settings s = settings;
+            const char code[] = "void f1(std::set<LargeType>& s, const LargeType& x) {\n"
+                                "    if (s.find(x) == s.end()) {\n"
+                                "        s.insert(x);\n"
+                                "    }\n"
+                                "}\n";
+            s.standards.cpp = Standards::CPP11;
+            check(code, s);
+            ASSERT_EQUALS("", errout_str());
+            s.standards.cpp = Standards::CPP14;
+            check(code, s);
+            ASSERT_EQUALS("", errout_str());
+            s.standards.cpp = Standards::CPP17;
+            check(code, s);
+            ASSERT_EQUALS("[test.cpp:3:18]: (performance) Searching before insertion is not necessary. [stlFindInsert]\n", errout_str());
+        }
+
+        { // #10558
+            Settings s = settings;
+            s.standards.cpp = Standards::CPP03;
+            check("void foo() {\n"
+                  "   std::map<int, int> x;\n"
+                  "   int data = 0;\n"
+                  "   for(int i=0; i<10; ++i) {\n"
+                  "      data += 123;\n"
+                  "      if(x.find(5) == x.end())\n"
+                  "         x[5] = data;\n"
+                  "   }\n"
+                  "}", s);
+            ASSERT_EQUALS("", errout_str());
+
+            s.standards.cpp = Standards::CPP11;
+            check("void foo() {\n"
+                  "   std::map<int, int> x;\n"
+                  "   int data = 0;\n"
+                  "   for(int i=0; i<10; ++i) {\n"
+                  "      data += 123;\n"
+                  "      if(x.find(5) == x.end())\n"
+                  "         x[5] = data;\n"
+                  "   }\n"
+                  "}", s);
+            ASSERT_EQUALS("[test.cpp:7:17]: (performance) Searching before insertion is not necessary. Instead of 'x[5]=data' consider using 'x.emplace(5, data);'. [stlFindInsert]\n", errout_str());
+
+            check("void foo() {\n"
+                  "   std::map<int, int> x;\n"
+                  "   int data = 0;\n"
+                  "   for(int i=0; i<10; ++i) {\n"
+                  "      data += 123;\n"
+                  "      if(x.find(5) == x.end())\n"
+                  "         x[5] = data;\n"
+                  "   }\n"
+                  "}"); // TODO: use s?
+            ASSERT_EQUALS("[test.cpp:7:17]: (performance) Searching before insertion is not necessary. Instead of 'x[5]=data' consider using 'x.try_emplace(5, data);'. [stlFindInsert]\n", errout_str());
+        }
+    }
+
+    void checkKnownEmptyContainer() {
+        check("void f() {\n"
+              "    std::vector<int> v;\n"
+              "    for(auto x:v) {}\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:16]: (style) Iterating over container 'v' that is always empty. [knownEmptyContainer]\n", errout_str());
+
+        check("void f(std::vector<int> v) {\n"
+              "    v.clear();\n"
+              "    for(auto x:v) {}\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:16]: (style) Iterating over container 'v' that is always empty. [knownEmptyContainer]\n", errout_str());
+
+        check("void f(std::vector<int> v) {\n"
+              "    if (!v.empty()) { return; }\n"
+              "    for(auto x:v) {}\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:16]: (style) Iterating over container 'v' that is always empty. [knownEmptyContainer]\n", errout_str());
+
+        check("void f(std::vector<int> v) {\n"
+              "    if (v.empty()) { return; }\n"
+              "    for(auto x:v) {}\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    std::vector<int> v;\n"
+              "    std::sort(v.begin(), v.end());\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:22]: (style) Using sort with iterator 'v.begin()' that is always empty. [knownEmptyContainer]\n", errout_str());
+
+        check("void f() {\n" // #1201
+              "    std::vector<int> v1{ 0, 1 };\n"
+              "    std::vector<int> v2;\n"
+              "    std::copy(v1.begin(), v1.end(), v2.begin());\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:45]: (style) Using copy with iterator 'v2.begin()' that is always empty. [knownEmptyContainer]\n", errout_str());
+
+        check("void f() {\n"
+              "    std::vector<int> v;\n"
+              "    v.insert(v.end(), 1);\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct A {\n"
+              "    explicit A(std::vector<int>*);\n"
+              "};\n"
+              "A f() {\n"
+              "    std::vector<int> v;\n"
+              "    A a(&v);\n"
+              "    for(auto&& x:v) {}\n"
+              "    return a;\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("static void f1(std::list<std::string>& parameters) {\n"
+              "    parameters.push_back(a);\n"
+              "}\n"
+              "int f2(std::list<std::string>& parameters) {\n"
+              "    f1(parameters);\n"
+              "}\n"
+              "void f3() {\n"
+              "    std::list<std::string> parameters;\n"
+              "    int res = ::f2(parameters);\n"
+              "    for (auto param : parameters) {}\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("namespace ns {\n"
+              "    using ArrayType = std::vector<int>;\n"
+              "}\n"
+              "using namespace ns;\n"
+              "static void f() {\n"
+              "    const ArrayType arr;\n"
+              "    for (const auto &a : arr) {}\n"
+              "}",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:7:26]: (style) Iterating over container 'arr' that is always empty. [knownEmptyContainer]\n", errout_str());
+
+        check("struct S {\n"
+              "    std::vector<int> v;\n"
+              "};\n"
+              "void foo(S& s) {\n"
+              "    s.v.clear();\n"
+              "    bar(s);\n"
+              "    std::sort(s.v.begin(), s.v.end());\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const std::vector<int>& v, int e) {\n"
+              " if (!v.empty()) {\n"
+              "     if (e < 0 || true) {\n"
+              "         if (e < 0)\n"
+              "             return;\n"
+              "     }\n"
+              " }\n"
+              " for (auto i : v) {}\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    std::vector<int> v;\n"
+              "    auto& rv = v;\n"
+              "    rv.push_back(42);\n"
+              "    for (auto i : v) {}\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("extern void f(std::string&&);\n"
+              "static void func() {\n"
+              "    std::string s;\n"
+              "    const std::string& s_ref = s;\n"
+              "    f(std::move(s));\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct S {\n" // #12757
+              "    template<class T = int>\n"
+              "    void clear() {}\n"
+              "    template<class T = int>\n"
+              "    std::vector<T> get() const { return {}; }\n"
+              "    std::vector<int> m;\n"
+              "};\n"
+              "template<> void S::clear() { m.clear(); }\n"
+              "template<> std::vector<int> S::get() const {\n"
+              "    for (const auto& i : m) {}\n"
+              "    return {};\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(bool b) {\n" // #13121
+              "    static std::string s = {};\n"
+              "    for (auto c : s) {}\n"
+              "    if (b)\n"
+              "        s += \'a\';\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::vector<int>::iterator it) {\n" // #13727
+              "    std::vector<int> v;\n"
+              "    v.insert<std::vector<int>::iterator>(v.end(), it, it + 1);\n"
+              "    for (auto i : v) {}\n"
+              "}\n", dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void checkMutexes() {
+        check("void f() {\n"
+              "    static std::mutex m;\n"
+              "    static std::lock_guard<std::mutex> g(m);\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:40]: (warning) Lock guard is defined globally. Lock guards are intended to be local. A global lock guard could lead to a deadlock since it won't unlock until the end of the program. [globalLockGuard]\n", errout_str());
+
+        check("void f() {\n"
+              "    static std::mutex m;\n"
+              "    std::lock_guard<std::mutex> g(m);\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    static std::mutex m;\n"
+              "    static std::unique_lock<std::mutex> g(m, std::defer_lock);\n"
+              "    static std::lock(g);\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:41]: (warning) Lock guard is defined globally. Lock guards are intended to be local. A global lock guard could lead to a deadlock since it won't unlock until the end of the program. [globalLockGuard]\n", errout_str());
+
+        check("void f() {\n"
+              "    static std::mutex m;\n"
+              "    std::unique_lock<std::mutex> g(m, std::defer_lock);\n"
+              "    std::lock(g);\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f() {\n"
+              "    std::mutex m;\n"
+              "    std::lock_guard<std::mutex> g(m);\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:33]: (warning) The lock is ineffective because the mutex is locked at the same scope as the mutex itself. [localMutex]\n", errout_str());
+
+        check("void f() {\n"
+              "    std::mutex m;\n"
+              "    std::unique_lock<std::mutex> g(m);\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:34]: (warning) The lock is ineffective because the mutex is locked at the same scope as the mutex itself. [localMutex]\n", errout_str());
+
+        check("void f() {\n"
+              "    std::mutex m;\n"
+              "    std::unique_lock<std::mutex> g(m, std::defer_lock);\n"
+              "    std::lock(g);\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:3:34]: (warning) The lock is ineffective because the mutex is locked at the same scope as the mutex itself. [localMutex]\n", errout_str());
+
+        check("void g();\n"
+              "void f() {\n"
+              "    static std::mutex m;\n"
+              "    m.lock();\n"
+              "    g();\n"
+              "    m.unlock();\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void g();\n"
+              "void f() {\n"
+              "    std::mutex m;\n"
+              "    m.lock();\n"
+              "    g();\n"
+              "    m.unlock();\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:5]: (warning) The lock is ineffective because the mutex is locked at the same scope as the mutex itself. [localMutex]\n", errout_str());
+
+        check("class A {\n"
+              "    std::mutex m;\n"
+              "    void f() {\n"
+              "        std::lock_guard<std::mutex> g(m);\n"
+              "    }\n"
+              "};\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("class A {\n"
+              "    std::mutex m;\n"
+              "    void g();\n"
+              "    void f() {\n"
+              "        m.lock();\n"
+              "        g();\n"
+              "        m.unlock();\n"
+              "    }\n"
+              "};\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("class A {\n"
+              "    std::mutex m;\n"
+              "    void f() {\n"
+              "        static std::lock_guard<std::mutex> g(m);\n"
+              "    }\n"
+              "};\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:44]: (warning) Lock guard is defined globally. Lock guards are intended to be local. A global lock guard could lead to a deadlock since it won't unlock until the end of the program. [globalLockGuard]\n", errout_str());
+
+        check("std::mutex& h();\n"
+              "void f() {\n"
+              "    auto& m = h();\n"
+              "    std::lock_guard<std::mutex> g(m);\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void g();\n"
+              "std::mutex& h();\n"
+              "void f() {\n"
+              "    auto& m = h();\n"
+              "    m.lock();\n"
+              "    g();\n"
+              "    m.unlock();\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("std::mutex& h();\n"
+              "void f() {\n"
+              "    auto m = h();\n"
+              "    std::lock_guard<std::mutex> g(m);\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:4:33]: (warning) The lock is ineffective because the mutex is locked at the same scope as the mutex itself. [localMutex]\n", errout_str());
+
+        check("void g();\n"
+              "std::mutex& h();\n"
+              "void f() {\n"
+              "    auto m = h();\n"
+              "    m.lock();\n"
+              "    g();\n"
+              "    m.unlock();\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("[test.cpp:5:5]: (warning) The lock is ineffective because the mutex is locked at the same scope as the mutex itself. [localMutex]\n", errout_str());
+
+        check("void foo();\n"
+              "void bar();\n"
+              "void f() {\n"
+              "    std::mutex m;\n"
+              "    std::thread t([&m](){\n"
+              "        m.lock();\n"
+              "        foo();\n"
+              "        m.unlock();\n"
+              "    });\n"
+              "    m.lock();\n"
+              "    bar();\n"
+              "    m.unlock();\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo();\n"
+              "void bar();\n"
+              "void f() {\n"
+              "    std::mutex m;\n"
+              "    std::thread t([&m](){\n"
+              "        std::unique_lock<std::mutex> g{m};\n"
+              "        foo();\n"
+              "    });\n"
+              "    std::unique_lock<std::mutex> g{m};\n"
+              "    bar();\n"
+              "}\n",
+              dinit(CheckOptions, $.inconclusive = true));
+        ASSERT_EQUALS("", errout_str());
+
+        check("void foo() { int f = 0; auto g(f); g = g; }");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct foobar {\n"
+              "    int foo;\n"
+              "    std::shared_mutex foo_mtx;\n"
+              "    int bar;\n"
+              "    std::shared_mutex bar_mtx;\n"
+              "};\n"
+              "void f() {\n"
+              "    foobar xyz;\n"
+              "    {\n"
+              "        std::shared_lock shared_foo_lock(xyz.foo_mtx, std::defer_lock);\n"
+              "        std::shared_lock shared_bar_lock(xyz.bar_mtx, std::defer_lock);\n"
+              "        std::scoped_lock shared_multi_lock(shared_foo_lock, shared_bar_lock);\n"
+              "    }\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 };
 
diff --git a/test/teststring.cpp b/test/teststring.cpp
index 25664f8f4a2..051aa870788 100644
--- a/test/teststring.cpp
+++ b/test/teststring.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,23 +18,23 @@
 
 
 #include "checkstring.h"
+#include "errortypes.h"
+#include "helpers.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
+#include "fixture.h"
 
+#include <cstddef>
+#include <string>
 
 class TestString : public TestFixture {
 public:
-    TestString() : TestFixture("TestString") {
-    }
+    TestString() : TestFixture("TestString") {}
 
 private:
-    Settings settings;
-
-    void run() OVERRIDE {
-        settings.addEnabled("warning");
-        settings.addEnabled("style");
+    const Settings settings = settingsBuilder().severity(Severity::warning).severity(Severity::style).build();
 
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(stringLiteralWrite);
 
         TEST_CASE(alwaysTrueFalseStringCompare);
@@ -61,18 +61,21 @@ class TestString : public TestFixture {
         TEST_CASE(deadStrcmp);
     }
 
-    void check(const char code[], const char filename[] = "test.cpp") {
-        // Clear the error buffer..
-        errout.str("");
+    struct CheckOptions
+    {
+        bool cpp = true;
+    };
+
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
+        SimpleTokenizer2 tokenizer(settings, *this, code, options.cpp ? "test.cpp" : "test.c");
 
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, filename);
+        ASSERT_LOC(tokenizer.simplifyTokens1(""), file, line);
 
         // Check char variable usage..
-        CheckString checkString(&tokenizer, &settings, this);
-        checkString.runChecks(&tokenizer, &settings, this);
+        runChecks<CheckString>(tokenizer, this);
     }
 
     void stringLiteralWrite() {
@@ -80,19 +83,25 @@ class TestString : public TestFixture {
               "  char *abc = \"abc\";\n"
               "  abc[0] = 'a';\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (error) Modifying string literal \"abc\" directly or indirectly is undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:3] -> [test.cpp:2:15]: (error) Modifying string literal \"abc\" directly or indirectly is undefined behaviour. [stringLiteralWrite]\n", errout_str());
 
         check("void f() {\n"
               "  char *abc = \"abc\";\n"
               "  *abc = 'a';\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (error) Modifying string literal \"abc\" directly or indirectly is undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:4] -> [test.cpp:2:15]: (error) Modifying string literal \"abc\" directly or indirectly is undefined behaviour. [stringLiteralWrite]\n", errout_str());
+
+        check("void f() {\n"
+              "  char *abc = \"A very long string literal\";\n"
+              "  abc[0] = 'a';\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:3] -> [test.cpp:2:15]: (error) Modifying string literal \"A very long stri..\" directly or indirectly is undefined behaviour. [stringLiteralWrite]\n", errout_str());
 
         check("void f() {\n"
               "  QString abc = \"abc\";\n"
               "  abc[0] = 'a';\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo_FP1(char *p) {\n"
               "  p[1] = 'B';\n"
@@ -102,8 +111,8 @@ class TestString : public TestFixture {
               "  foo_FP1(s);\n"
               "}");
         ASSERT_EQUALS(
-            "[test.cpp:2] -> [test.cpp:5]: (error) Modifying string literal \"Y\" directly or indirectly is undefined behaviour.\n",
-            errout.str());
+            "[test.cpp:2:3] -> [test.cpp:5:13]: (error) Modifying string literal \"Y\" directly or indirectly is undefined behaviour. [stringLiteralWrite]\n",
+            errout_str());
 
         check("void foo_FP1(char *p) {\n"
               "  p[1] = 'B';\n"
@@ -112,19 +121,29 @@ class TestString : public TestFixture {
               "  char s[10] = \"Y\";\n"
               "  foo_FP1(s);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  wchar_t *abc = L\"abc\";\n"
               "  abc[0] = u'a';\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (error) Modifying string literal \"abc\" directly or indirectly is undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:3] -> [test.cpp:2:18]: (error) Modifying string literal L\"abc\" directly or indirectly is undefined behaviour. [stringLiteralWrite]\n", errout_str());
 
         check("void f() {\n"
               "  char16_t *abc = u\"abc\";\n"
               "  abc[0] = 'a';\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3] -> [test.cpp:2]: (error) Modifying string literal \"abc\" directly or indirectly is undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:3] -> [test.cpp:2:19]: (error) Modifying string literal u\"abc\" directly or indirectly is undefined behaviour. [stringLiteralWrite]\n", errout_str());
+
+        check("void foo() {\n" // #8332
+              "    int i;\n"
+              "    char *p  = \"string literal\";\n"
+              "    for( i = 0; i < strlen(p); i++) {\n"
+              "        p[i] = \'X\';\n" // <<
+              "    }\n"
+              "    printf(\"%s\\n\", p);\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:3:16]: (error) Modifying string literal \"string literal\" directly or indirectly is undefined behaviour. [stringLiteralWrite]\n", errout_str());
     }
 
     void alwaysTrueFalseStringCompare() {
@@ -142,18 +161,18 @@ class TestString : public TestFixture {
               "  if (wcscmp(L\"A\",L\"A\")){}\n"
               "  if (wcscasecmp(L\"A\",L\"A\")){}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Unnecessary comparison of static strings.\n"
-                      "[test.cpp:3]: (warning) Unnecessary comparison of static strings.\n"
-                      "[test.cpp:4]: (warning) Unnecessary comparison of static strings.\n"
-                      "[test.cpp:5]: (warning) Unnecessary comparison of static strings.\n"
-                      "[test.cpp:6]: (warning) Unnecessary comparison of static strings.\n"
-                      "[test.cpp:7]: (warning) Unnecessary comparison of static strings.\n"
-                      "[test.cpp:8]: (warning) Unnecessary comparison of static strings.\n"
-                      "[test.cpp:9]: (warning) Unnecessary comparison of static strings.\n"
-                      "[test.cpp:10]: (warning) Unnecessary comparison of static strings.\n"
-                      "[test.cpp:11]: (warning) Unnecessary comparison of static strings.\n"
-                      "[test.cpp:12]: (warning) Unnecessary comparison of static strings.\n"
-                      "[test.cpp:13]: (warning) Unnecessary comparison of static strings.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n"
+                      "[test.cpp:3:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n"
+                      "[test.cpp:4:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n"
+                      "[test.cpp:5:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n"
+                      "[test.cpp:6:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n"
+                      "[test.cpp:7:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n"
+                      "[test.cpp:8:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n"
+                      "[test.cpp:9:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n"
+                      "[test.cpp:10:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n"
+                      "[test.cpp:11:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n"
+                      "[test.cpp:12:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n"
+                      "[test.cpp:13:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n", errout_str());
 
         // avoid false positives when the address is modified #6415
         check("void f(void *p, int offset)  {\n"
@@ -162,7 +181,7 @@ class TestString : public TestFixture {
               "     if (!memcmp(offset + p, p, 42)){}\n"
               "     if (!memcmp(p, offset + p, 42)){}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // avoid false positives when the address is modified #6415
         check("void f(char *c, int offset)  {\n"
@@ -171,7 +190,7 @@ class TestString : public TestFixture {
               "     if (!memcmp(offset + c, c, 42)){}\n"
               "     if (!memcmp(c, offset + c, 42)){}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // avoid false positives when the address is modified #6415
         check("void f(std::string s, int offset)  {\n"
@@ -180,7 +199,13 @@ class TestString : public TestFixture {
               "     if (!memcmp(offset + s.c_str(), s.c_str(), 42)){}\n"
               "     if (!memcmp(s.c_str(), offset + s.c_str(), 42)){}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(void) {\n" // #13527
+              "    const wchar_t* str1 = L\"Hello\";\n"
+              "    return wcsicmp(str1, str1);\n" // <<
+              "}");
+        ASSERT_EQUALS("[test.cpp:3:12]: (warning) Comparison of identical string variables. [stringCompare]\n", errout_str());
 
         check("int main()\n"
               "{\n"
@@ -189,17 +214,17 @@ class TestString : public TestFixture {
               "    std::cout << \"Equal\";"
               "  }"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Unnecessary comparison of static strings.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n", errout_str());
 
         check("void f() {\n"
               "  if (strcmp($\"00FF00\", \"00FF00\") == 0) {}"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() {\n"
               "  if ($strcmp(\"00FF00\", \"00FF00\") == 0) {}"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int main()\n"
               "{\n"
@@ -208,7 +233,7 @@ class TestString : public TestFixture {
               "    std::cout << \"Equal\";"
               "  }"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Unnecessary comparison of static strings.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n", errout_str());
 
         check("int main()\n"
               "{\n"
@@ -217,7 +242,7 @@ class TestString : public TestFixture {
               "    std::cout << \"Equal\";"
               "  }"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Unnecessary comparison of static strings.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n", errout_str());
 
         check("int main()\n"
               "{\n"
@@ -226,7 +251,7 @@ class TestString : public TestFixture {
               "    std::cout << \"Equal\";"
               "  }"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int main()\n"
               "{\n"
@@ -235,7 +260,7 @@ class TestString : public TestFixture {
               "    std::cout << \"Equal\";"
               "  }"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Unnecessary comparison of static strings.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:7]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n", errout_str());
 
         check("int foo(const char *buf)\n"
               "{\n"
@@ -244,7 +269,7 @@ class TestString : public TestFixture {
               "    std::cout << \"Equal\";"
               "  }"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Comparison of identical string variables.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:7]: (warning) Comparison of identical string variables. [stringCompare]\n", errout_str());
 
         check("int foo(const std::string& buf)\n"
               "{\n"
@@ -253,122 +278,123 @@ class TestString : public TestFixture {
               "    std::cout << \"Equal\";"
               "  }"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Comparison of identical string variables.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:7]: (warning) Comparison of identical string variables. [stringCompare]\n", errout_str());
 
         check("int main() {\n"
               "  if (\"str\" == \"str\") {\n"
               "    std::cout << \"Equal\";\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Unnecessary comparison of static strings.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:6]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n", errout_str());
 
         check("int main() {\n"
               "  if (\"str\" != \"str\") {\n"
               "    std::cout << \"Equal\";\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Unnecessary comparison of static strings.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:6]: (warning) Unnecessary comparison of static strings. [staticStringCompare]\n", errout_str());
 
         check("int main() {\n"
               "  if (a+\"str\" != \"str\"+b) {\n"
               "    std::cout << \"Equal\";\n"
               "  }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void suspiciousStringCompare() {
         check("bool foo(char* c) {\n"
               "    return c == \"x\";\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) String literal compared with variable 'c'. Did you intend to use strcmp() instead?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (warning) String literal compared with variable 'c'. Did you intend to use strcmp() instead? [literalWithCharPtrCompare]\n", errout_str());
+
+        check("bool foo(char** c) {\n"
+              "    return c[3] == \"x\";\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:17]: (warning) String literal compared with variable 'c[3]'. Did you intend to use strcmp() instead? [literalWithCharPtrCompare]\n", errout_str());
 
         check("bool foo(wchar_t* c) {\n"
               "    return c == L\"x\";\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) String literal compared with variable 'c'. Did you intend to use wcscmp() instead?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (warning) String literal compared with variable 'c'. Did you intend to use wcscmp() instead? [literalWithCharPtrCompare]\n", errout_str());
 
         check("bool foo(const char* c) {\n"
               "    return \"x\" == c;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) String literal compared with variable 'c'. Did you intend to use strcmp() instead?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:16]: (warning) String literal compared with variable 'c'. Did you intend to use strcmp() instead? [literalWithCharPtrCompare]\n", errout_str());
 
         check("bool foo(char* c) {\n"
               "    return foo+\"x\" == c;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool foo(char* c) {\n"
               "    return \"x\" == c+foo;\n"
-              "}", "test.cpp");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("bool foo(char* c) {\n"
               "    return \"x\" == c+foo;\n"
-              "}", "test.c");
-        ASSERT_EQUALS("[test.c:2]: (warning) String literal compared with variable 'c'. Did you intend to use strcmp() instead?\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:2:16]: (warning) String literal compared with variable 'c+foo'. Did you intend to use strcmp() instead? [literalWithCharPtrCompare]\n", errout_str());
 
         check("bool foo(Foo c) {\n"
               "    return \"x\" == c.foo;\n"
-              "}", "test.cpp");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("bool foo(Foo c) {\n"
               "    return \"x\" == c.foo;\n"
-              "}", "test.c");
-        ASSERT_EQUALS("[test.c:2]: (warning) String literal compared with variable 'c.foo'. Did you intend to use strcmp() instead?\n", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:2:16]: (warning) String literal compared with variable 'c.foo'. Did you intend to use strcmp() instead? [literalWithCharPtrCompare]\n", errout_str());
 
         check("bool foo(const std::string& c) {\n"
               "    return \"x\" == c;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool foo(const Foo* c) {\n"
               "    return \"x\" == c->bar();\n" // #4314
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #4257
         check("bool foo() {\n"
               "MyString *str=Getter();\n"
-              "return *str==\"bug\"; }\n", "test.c");
-        ASSERT_EQUALS("[test.c:3]: (warning) String literal compared with variable '*str'. Did you intend to use strcmp() instead?\n", errout.str());
+              "return *str==\"bug\"; }\n", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:3:12]: (warning) String literal compared with variable '*str'. Did you intend to use strcmp() instead? [literalWithCharPtrCompare]\n", errout_str());
 
         // Ticket #4257
         check("bool foo() {\n"
               "MyString *str=Getter();\n"
               "return *str==\"bug\"; }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #4257
         check("bool foo() {\n"
               "MyString **str=OtherGetter();\n"
-              "return *str==\"bug\"; }");
-        TODO_ASSERT_EQUALS("[test.cpp:2]: (warning) String literal compared with variable 'c'. Did you intend to use strcmp() instead?\n",
-                           "",
-                           errout.str());
+              "return *str==\"bug\"; }", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:3:12]: (warning) String literal compared with variable '*str'. Did you intend to use strcmp() instead? [literalWithCharPtrCompare]\n", errout_str());
 
         // Ticket #4257
         check("bool foo() {\n"
               "MyString str=OtherGetter2();\n"
-              "return &str==\"bug\"; }");
-        TODO_ASSERT_EQUALS("[test.cpp:2]: (warning) String literal compared with variable 'c'. Did you intend to use strcmp() instead?\n",
-                           "",
-                           errout.str());
+              "return &str==\"bug\"; }", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:3:12]: (warning) String literal compared with variable '&str'. Did you intend to use strcmp() instead? [literalWithCharPtrCompare]\n", errout_str());
 
         // Ticket #5734
         check("int foo(char c) {\n"
-              "return c == '4';}", "test.cpp");
-        ASSERT_EQUALS("", errout.str());
+              "return c == '4';}");
+        ASSERT_EQUALS("", errout_str());
         check("int foo(char c) {\n"
-              "return c == '4';}", "test.c");
-        ASSERT_EQUALS("", errout.str());
+              "return c == '4';}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
         check("int foo(char c) {\n"
-              "return c == \"42\"[0];}", "test.cpp");
-        ASSERT_EQUALS("", errout.str());
+              "return c == \"42\"[0];}");
+        ASSERT_EQUALS("", errout_str());
         check("int foo(char c) {\n"
-              "return c == \"42\"[0];}", "test.c");
-        ASSERT_EQUALS("", errout.str());
+              "return c == \"42\"[0];}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
         // 5639 String literal compared with char buffer in a struct
         check("struct Example {\n"
@@ -377,75 +403,97 @@ class TestString : public TestFixture {
               "void foo() {\n"
               "   struct Example example;\n"
               "   if (example.buffer == \"test\") ;\n"
-              "}\n", "test.cpp");
-        ASSERT_EQUALS("[test.cpp:6]: (warning) String literal compared with variable 'example.buffer'. Did you intend to use strcmp() instead?\n", errout.str());
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:23]: (warning) String literal compared with variable 'example.buffer'. Did you intend to use strcmp() instead? [literalWithCharPtrCompare]\n", errout_str());
         check("struct Example {\n"
               "   char buffer[200];\n"
               "};\n"
               "void foo() {\n"
               "   struct Example example;\n"
               "   if (example.buffer == \"test\") ;\n"
-              "}\n", "test.c");
-        ASSERT_EQUALS("[test.c:6]: (warning) String literal compared with variable 'example.buffer'. Did you intend to use strcmp() instead?\n", errout.str());
+              "}\n", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:6:23]: (warning) String literal compared with variable 'example.buffer'. Did you intend to use strcmp() instead? [literalWithCharPtrCompare]\n", errout_str());
+
+        // #9726
+        check("void f(std::vector<std::string> theArgs) {\n"
+              "   std::string arg1(*theArgs.begin());\n"
+              "   if(arg1 == \"aaa\") {}\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void suspiciousStringCompare_char() {
         check("bool foo(char* c) {\n"
               "    return c == 'x';\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Char literal compared with pointer 'c'. Did you intend to dereference it?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (warning) Char literal compared with pointer 'c'. Did you intend to dereference it? [charLiteralWithCharPtrCompare]\n", errout_str());
 
         check("bool foo(wchar_t* c) {\n"
               "    return c == L'x';\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Char literal compared with pointer 'c'. Did you intend to dereference it?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:14]: (warning) Char literal compared with pointer 'c'. Did you intend to dereference it? [charLiteralWithCharPtrCompare]\n", errout_str());
 
         check("bool foo(char* c) {\n"
               "    return '\\0' != c;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Char literal compared with pointer 'c'. Did you intend to dereference it?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (warning) Char literal compared with pointer 'c'. Did you intend to dereference it? [charLiteralWithCharPtrCompare]\n", errout_str());
 
         check("bool foo(char c) {\n"
               "    return c == '\\0';\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool foo(char* c) {\n"
+              "    return c[0] == '\\0';\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool foo(char** c) {\n"
+              "    return c[0] == '\\0';\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:17]: (warning) Char literal compared with pointer 'c[0]'. Did you intend to dereference it? [charLiteralWithCharPtrCompare]\n", errout_str());
+
+        check("bool foo(char** c) {\n"
+              "    return *c == '\\0';\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:15]: (warning) Char literal compared with pointer '*c'. Did you intend to dereference it? [charLiteralWithCharPtrCompare]\n", errout_str());
 
         check("bool foo(char c) {\n"
               "    return c == 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool foo(char* c) {\n"
               "    return *c == 0;\n"
-              "}", "test.c");
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
         check("bool foo(char* c) {\n"
               "    return *c == 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("bool foo(Foo* c) {\n"
               "    return 0 == c->x;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo(char* c) {\n"
               "    if(c == '\\0') bar();\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Char literal compared with pointer 'c'. Did you intend to dereference it?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (warning) Char literal compared with pointer 'c'. Did you intend to dereference it? [charLiteralWithCharPtrCompare]\n", errout_str());
 
         check("void f() {\n"
               "  struct { struct { char *str; } x; } a;\n"
               "  return a.x.str == '\\0';"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) Char literal compared with pointer 'a.x.str'. Did you intend to dereference it?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:18]: (warning) Char literal compared with pointer 'a.x.str'. Did you intend to dereference it? [charLiteralWithCharPtrCompare]\n", errout_str());
 
         check("void f() {\n"
               "  struct { struct { char *str; } x; } a;\n"
               "  return *a.x.str == '\\0';"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -455,7 +503,7 @@ class TestString : public TestFixture {
               "    char buf[100];\n"
               "    snprintf(buf,100,\"%s\",buf);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Undefined behavior: Variable 'buf' is used as parameter and destination in snprintf().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:27]: (error) Undefined behavior: Variable 'buf' is used as parameter and destination in snprintf(). [sprintfOverlappingData]\n", errout_str());
     }
 
     void sprintf1() {
@@ -464,7 +512,7 @@ class TestString : public TestFixture {
               "    char buf[100];\n"
               "    sprintf(buf,\"%s\",buf);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Undefined behavior: Variable 'buf' is used as parameter and destination in sprintf().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:22]: (error) Undefined behavior: Variable 'buf' is used as parameter and destination in sprintf(). [sprintfOverlappingData]\n", errout_str());
     }
 
     void sprintf2() {
@@ -473,7 +521,7 @@ class TestString : public TestFixture {
               "    char buf[100];\n"
               "    sprintf(buf,\"%i\",sizeof(buf));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void sprintf3() {
@@ -483,7 +531,7 @@ class TestString : public TestFixture {
               "    sprintf(buf,\"%i\",sizeof(buf));\n"
               "    if (buf[0]);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void sprintf4() {
@@ -498,7 +546,7 @@ class TestString : public TestFixture {
               "    struct A a;\n"
               "    snprintf(a.filename, 128, \"%s\", filename);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void sprintf5() {
@@ -511,7 +559,7 @@ class TestString : public TestFixture {
               "{\n"
               "    snprintf(a->filename, 128, \"%s\", a->filename);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Undefined behavior: Variable 'a->filename' is used as parameter and destination in snprintf().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:39]: (error) Undefined behavior: Variable 'a->filename' is used as parameter and destination in snprintf(). [sprintfOverlappingData]\n", errout_str());
     }
 
     void sprintf6() {
@@ -520,7 +568,7 @@ class TestString : public TestFixture {
               "    char buf[100];\n"
               "    sprintf((char*)buf,\"%s\",(char*)buf);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Undefined behavior: Variable 'buf' is used as parameter and destination in sprintf().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:29]: (error) Undefined behavior: Variable 'buf' is used as parameter and destination in sprintf(). [sprintfOverlappingData]\n", errout_str());
     }
 
     void sprintf7() {
@@ -529,7 +577,7 @@ class TestString : public TestFixture {
               "    char buf[100];\n"
               "    sprintf((char*)(void*)buf,\"%s\",(void*)(char*)buf);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Undefined behavior: Variable 'buf' is used as parameter and destination in sprintf().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:36]: (error) Undefined behavior: Variable 'buf' is used as parameter and destination in sprintf(). [sprintfOverlappingData]\n", errout_str());
     }
 
     void wsprintf1() {
@@ -538,7 +586,7 @@ class TestString : public TestFixture {
               "    wchar_t buf[100];\n"
               "    swprintf(buf,10, \"%s\",buf);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Undefined behavior: Variable 'buf' is used as parameter and destination in swprintf().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:27]: (error) Undefined behavior: Variable 'buf' is used as parameter and destination in swprintf(). [sprintfOverlappingData]\n", errout_str());
     }
 
     void strPlusChar1() {
@@ -547,7 +595,7 @@ class TestString : public TestFixture {
               "{\n"
               "    const char *p = \"/usr\" + '/';\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Unusual pointer arithmetic. A value of type 'char' is added to a string literal.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:28]: (error) Unusual pointer arithmetic. A value of type 'char' is added to a string literal. [strPlusChar]\n", errout_str());
     }
 
     void strPlusChar2() {
@@ -557,7 +605,7 @@ class TestString : public TestFixture {
               "    char ch = 1;\n"
               "    const char *p = ch + \"/usr\";\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Strange looking pointer arithmetic..
         check("void foo()\n"
@@ -566,7 +614,7 @@ class TestString : public TestFixture {
               "    const char* psz = \"Bla\";\n"
               "    const std::string str = i + psz;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void strPlusChar3() {
@@ -576,7 +624,7 @@ class TestString : public TestFixture {
               "    std::string temp = \"/tmp\";\n"
               "    std::string path = temp + '/' + \"sub\" + '/';\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void strPlusChar4() {
@@ -585,100 +633,100 @@ class TestString : public TestFixture {
               "{\n"
               "    const wchar_t *p = L\"/usr\" + L'/';\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Unusual pointer arithmetic. A value of type 'wchar_t' is added to a string literal.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:32]: (error) Unusual pointer arithmetic. A value of type 'wchar_t' is added to a string literal. [strPlusChar]\n", errout_str());
 
         check("void foo(wchar_t c)\n"
               "{\n"
               "    const wchar_t *p = L\"/usr\" + c;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Unusual pointer arithmetic. A value of type 'wchar_t' is added to a string literal.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:32]: (error) Unusual pointer arithmetic. A value of type 'wchar_t' is added to a string literal. [strPlusChar]\n", errout_str());
     }
 
     void incorrectStringCompare() {
         check("int f() {\n"
               "    return test.substr( 0 , 4 ) == \"Hello\" ? 0 : 1 ;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) String literal \"Hello\" doesn't match length argument for substr().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (warning) String literal \"Hello\" doesn't match length argument for substr(). [incorrectStringCompare]\n", errout_str());
 
         check("int f() {\n"
               "    return test.substr( 0 , 4 ) == L\"Hello\" ? 0 : 1 ;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) String literal \"Hello\" doesn't match length argument for substr().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (warning) String literal L\"Hello\" doesn't match length argument for substr(). [incorrectStringCompare]\n", errout_str());
 
         check("int f() {\n"
               "    return test.substr( 0 , 5 ) == \"Hello\" ? 0 : 1 ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "    return \"Hello\" == test.substr( 0 , 4 ) ? 0 : 1 ;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) String literal \"Hello\" doesn't match length argument for substr().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:28]: (warning) String literal \"Hello\" doesn't match length argument for substr(). [incorrectStringCompare]\n", errout_str());
 
         check("int f() {\n"
               "    return \"Hello\" == foo.bar<int>().z[1].substr(i+j*4, 4) ? 0 : 1 ;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) String literal \"Hello\" doesn't match length argument for substr().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:43]: (warning) String literal \"Hello\" doesn't match length argument for substr(). [incorrectStringCompare]\n", errout_str());
 
         check("int f() {\n"
               "    return \"Hello\" == test.substr( 0 , 5 ) ? 0 : 1 ;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "    if (\"Hello\") { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true. [incorrectStringBooleanError]\n", errout_str());
 
         check("int f() {\n"
               "    if (\"Hello\" && test) { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:9]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true. [incorrectStringBooleanError]\n", errout_str());
 
         check("int f() {\n"
               "    if (test && \"Hello\") { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true. [incorrectStringBooleanError]\n", errout_str());
 
         check("int f() {\n"
               "    while (\"Hello\") { }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:12]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true. [incorrectStringBooleanError]\n", errout_str());
 
         check("int f() {\n"
               "    return \"Hello\" ? 1 : 2;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:12]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true. [incorrectStringBooleanError]\n", errout_str());
 
         check("int f() {\n"
               "    assert (test || \"Hello\");\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:21]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true. [incorrectStringBooleanError]\n", errout_str());
 
         check("int f() {\n"
               "    assert (test && \"Hello\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "    assert (\"Hello\" || test);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:13]: (warning) Conversion of string literal \"Hello\" to bool always evaluates to true. [incorrectStringBooleanError]\n", errout_str());
 
         check("int f() {\n"
               "    assert (\"Hello\" && test);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "    BOOST_ASSERT (\"Hello\" && test);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int f() {\n"
               "    return f2(\"Hello\");\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #7750 warn about char literals in boolean expressions
         check("void f() {\n"
@@ -687,36 +735,114 @@ class TestString : public TestFixture {
               "  if(1 && 'c'){}\n"
               "  int x = 'd' ? 1 : 2;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Conversion of char literal 'a' to bool always evaluates to true.\n"
-                      "[test.cpp:3]: (warning) Conversion of char literal 'b' to bool always evaluates to true.\n"
-                      "[test.cpp:4]: (warning) Conversion of char literal 'c' to bool always evaluates to true.\n"
-                      "[test.cpp:5]: (warning) Conversion of char literal 'd' to bool always evaluates to true.\n"
-                      , errout.str());
+        ASSERT_EQUALS("[test.cpp:2:6]: (warning) Conversion of char literal 'a' to bool always evaluates to true. [incorrectCharBooleanError]\n"
+                      "[test.cpp:3:6]: (warning) Conversion of char literal L'b' to bool always evaluates to true. [incorrectCharBooleanError]\n"
+                      "[test.cpp:4:11]: (warning) Conversion of char literal 'c' to bool always evaluates to true. [incorrectCharBooleanError]\n"
+                      "[test.cpp:5:11]: (warning) Conversion of char literal 'd' to bool always evaluates to true. [incorrectCharBooleanError]\n"
+                      , errout_str());
 
         check("void f() {\n"
               "  if('\\0'){}\n"
               "  if(L'\\0'){}\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:6]: (warning) Conversion of char literal '\\0' to bool always evaluates to false. [incorrectCharBooleanError]\n"
+                      "[test.cpp:3:6]: (warning) Conversion of char literal L'\\0' to bool always evaluates to false. [incorrectCharBooleanError]\n",
+                      errout_str());
 
         check("void f() {\n"
               "  if('\\0' || cond){}\n"
               "  if(L'\\0' || cond){}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Conversion of char literal '\\0' to bool always evaluates to false.\n"
-                      "[test.cpp:3]: (warning) Conversion of char literal '\\0' to bool always evaluates to false.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:6]: (warning) Conversion of char literal '\\0' to bool always evaluates to false. [incorrectCharBooleanError]\n"
+                      "[test.cpp:3:6]: (warning) Conversion of char literal L'\\0' to bool always evaluates to false. [incorrectCharBooleanError]\n", errout_str());
+
+        check("void f(bool b);\n" // #9450
+              "void f(std::string s);\n"
+              "void g() {\n"
+              "    f(\"abc\");\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:7]: (warning) Conversion of string literal \"abc\" to bool always evaluates to true. [incorrectStringBooleanError]\n", errout_str());
+
+        check("void g(bool);\n"
+              "    void f(std::map<std::string, std::vector<int>>&m) {\n"
+              "    if (m.count(\"abc\"))\n"
+              "        g(m[\"abc\"][0] ? true : false);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void g(bool b);\n"
+              "void f() {\n"
+              "    g('\\0');\n"
+              "    g('a');\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:7]: (warning) Conversion of char literal '\\0' to bool always evaluates to false. [incorrectCharBooleanError]\n"
+                      "[test.cpp:4:7]: (warning) Conversion of char literal 'a' to bool always evaluates to true. [incorrectCharBooleanError]\n",
+                      errout_str());
+
+        check("#define ERROR(msg) if (msg) printf(\"%s\\n\", msg);\n"
+              "void f() {\n"
+              "	  ERROR(\"abc\")\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void g(int, bool);\n"
+              "void f() {\n"
+              "    MyAssert(!\"abc\");\n"
+              "    g(2, !\"def\");\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:11]: (warning) Conversion of string literal \"def\" to bool always evaluates to true. [incorrectStringBooleanError]\n", errout_str());
+
+        check("bool f(const char *p) {\n"
+              "    if (*p == '\\0')\n"
+              "        return *p == '\\0';\n"
+              "    return false;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(const int* p, const int* q) {\n"
+              "    assert((p != NULL && q != NULL) || !\"abc\");\n"
+              "    ASSERT((void*)(\"def\") == 0);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("class C {\n" // #6109
+              "    void check(const char code[], bool validate = true, const char* filename = \"test.cpp\");\n"
+              "    void f() {\n"
+              "        check(\"class A<B&, C>;\", \"test.C\");\n"
+              "    }\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:4:34]: (warning) Conversion of string literal \"test.C\" to bool always evaluates to true. [incorrectStringBooleanError]\n", errout_str());
+
+        check("#define MACRO(C) if(!(C)) { error(__FILE__, __LINE__, __FUNCTION__, #C); return; }\n" // #13067
+              "void f() {\n"
+              "    MACRO(false && \"abc\");\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("#define strequ(s1,s2) ((void *)s1 && (void *)s2 && strcmp(s1, s2) == 0)\n" // #13093
+              "void f(const char* p) {\n"
+              "    if (strequ(p, \"ALL\")) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(std::string_view);\n"
+              "void f(bool);\n"
+              "void g() {\n"
+              "    f(\"\"sv);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void deadStrcmp() {
         check("void f(const char *str) {\n"
               "  if (strcmp(str, \"abc\") == 0 || strcmp(str, \"def\")) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) The expression 'strcmp(str,\"def\") != 0' is suspicious. It overlaps 'strcmp(str,\"abc\") == 0'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:40]: (warning) The expression 'strcmp(str,\"def\") != 0' is suspicious. It overlaps 'strcmp(str,\"abc\") == 0'. [overlappingStrcmp]\n", errout_str());
 
         check("void f(const wchar_t *str) {\n"
               "  if (wcscmp(str, L\"abc\") == 0 || wcscmp(str, L\"def\")) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) The expression 'wcscmp(str,L\"def\") != 0' is suspicious. It overlaps 'wcscmp(str,L\"abc\") == 0'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:41]: (warning) The expression 'wcscmp(str,L\"def\") != 0' is suspicious. It overlaps 'wcscmp(str,L\"abc\") == 0'. [overlappingStrcmp]\n", errout_str());
 
         check("struct X {\n"
               "  char *str;\n"
@@ -725,7 +851,7 @@ class TestString : public TestFixture {
               "void f(const struct X *x) {\n"
               "  if (strcmp(x->str, \"abc\") == 0 || strcmp(x->str, \"def\")) {}\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (warning) The expression 'strcmp(x->str,\"def\") != 0' is suspicious. It overlaps 'strcmp(x->str,\"abc\") == 0'.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:43]: (warning) The expression 'strcmp(x->str,\"def\") != 0' is suspicious. It overlaps 'strcmp(x->str,\"abc\") == 0'. [overlappingStrcmp]\n", errout_str());
     }
 };
 
diff --git a/test/testsuite.cpp b/test/testsuite.cpp
deleted file mode 100644
index ec7e198434f..00000000000
--- a/test/testsuite.cpp
+++ /dev/null
@@ -1,368 +0,0 @@
-/*
- * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "testsuite.h"
-
-#include "options.h"
-#include "redirect.h"
-
-#include <cstdio>
-#include <iostream>
-#include <string>
-
-std::ostringstream errout;
-std::ostringstream output;
-
-/**
- * TestRegistry
- **/
-
-struct CompareFixtures {
-    bool operator()(const TestFixture* lhs, const TestFixture* rhs) const {
-        return lhs->classname < rhs->classname;
-    }
-};
-
-typedef std::set<TestFixture*, CompareFixtures> TestSet;
-class TestRegistry {
-    TestSet _tests;
-public:
-
-    static TestRegistry &theInstance() {
-        static TestRegistry testreg;
-        return testreg;
-    }
-
-    void addTest(TestFixture *t) {
-        _tests.insert(t);
-    }
-
-    const TestSet &tests() const {
-        return _tests;
-    }
-};
-
-
-
-
-/**
- * TestFixture
- **/
-
-std::ostringstream TestFixture::errmsg;
-unsigned int       TestFixture::countTests;
-
-std::size_t TestFixture::fails_counter = 0;
-std::size_t TestFixture::todos_counter = 0;
-std::size_t TestFixture::succeeded_todos_counter = 0;
-std::set<std::string> TestFixture::missingLibs;
-
-TestFixture::TestFixture(const char * const _name)
-    :mVerbose(false),
-     quiet_tests(false),
-     classname(_name)
-{
-    TestRegistry::theInstance().addTest(this);
-}
-
-
-bool TestFixture::prepareTest(const char testname[])
-{
-    mVerbose = false;
-    mTemplateFormat.clear();
-    mTemplateLocation.clear();
-
-    // Check if tests should be executed
-    if (testToRun.empty() || testToRun == testname) {
-        // Tests will be executed - prepare them
-        mTestname = testname;
-        ++countTests;
-        if (quiet_tests) {
-            std::putchar('.'); // Use putchar to write through redirection of std::cout/cerr
-            std::fflush(stdout);
-        } else {
-            std::cout << classname << "::" << testname << std::endl;
-        }
-        return true;
-    }
-    return false;
-}
-
-std::string TestFixture::getLocationStr(const char * const filename, const unsigned int linenr) const
-{
-    std::ostringstream ret;
-    ret << filename << ':' << linenr << '(' << classname << "::" << mTestname << ')';
-    return ret.str();
-}
-
-static std::string writestr(const std::string &str, bool gccStyle = false)
-{
-    std::ostringstream ostr;
-    if (gccStyle)
-        ostr << '\"';
-    for (std::string::const_iterator i = str.begin(); i != str.end(); ++i) {
-        if (*i == '\n') {
-            ostr << "\\n";
-            if ((i+1) != str.end() && !gccStyle)
-                ostr << std::endl;
-        } else if (*i == '\t')
-            ostr << "\\t";
-        else if (*i == '\"')
-            ostr << "\\\"";
-        else
-            ostr << *i;
-    }
-    if (!str.empty() && !gccStyle)
-        ostr << std::endl;
-    else if (gccStyle)
-        ostr << '\"';
-    return ostr.str();
-}
-
-bool TestFixture::assert_(const char * const filename, const unsigned int linenr, const bool condition) const
-{
-    if (!condition) {
-        ++fails_counter;
-        errmsg << getLocationStr(filename, linenr) << ": Assertion failed." << std::endl << "_____" << std::endl;
-    }
-    return condition;
-}
-
-bool TestFixture::assertEquals(const char * const filename, const unsigned int linenr, const std::string &expected, const std::string &actual, const std::string &msg) const
-{
-    if (expected != actual) {
-        ++fails_counter;
-        errmsg << getLocationStr(filename, linenr) << ": Assertion failed. " << std::endl
-               << "Expected: " <<  std::endl
-               << writestr(expected)  << std::endl
-               << "Actual: " << std::endl
-               << writestr(actual) << std::endl;
-        if (!msg.empty())
-            errmsg << "Hint:" << std::endl <<  msg << std::endl;
-        errmsg << "_____" << std::endl;
-    }
-    return expected == actual;
-}
-
-std::string TestFixture::deleteLineNumber(const std::string &message) const
-{
-    std::string result(message);
-    // delete line number in "...:NUMBER:..."
-    std::string::size_type pos = 0;
-    while ((pos = result.find(':', pos)) != std::string::npos) {
-        // get number
-        if (pos + 1 == result.find_first_of("0123456789", pos + 1)) {
-            std::string::size_type after;
-            if ((after = result.find_first_not_of("0123456789", pos + 1)) != std::string::npos
-                && result.at(after) == ':') {
-                // erase NUMBER
-                result.erase(pos + 1, after - pos - 1);
-                pos = after;
-            } else {
-                ++pos;
-            }
-        } else {
-            ++pos;
-        }
-    }
-    return result;
-}
-
-void TestFixture::assertEqualsWithoutLineNumbers(const char * const filename, const unsigned int linenr, const std::string &expected, const std::string &actual, const std::string &msg) const
-{
-    assertEquals(filename, linenr, deleteLineNumber(expected), deleteLineNumber(actual), msg);
-}
-
-bool TestFixture::assertEquals(const char * const filename, const unsigned int linenr, const char expected[], const std::string& actual, const std::string &msg) const
-{
-    return assertEquals(filename, linenr, std::string(expected), actual, msg);
-}
-bool TestFixture::assertEquals(const char * const filename, const unsigned int linenr, const char expected[], const char actual[], const std::string &msg) const
-{
-    return assertEquals(filename, linenr, std::string(expected), std::string(actual), msg);
-}
-bool TestFixture::assertEquals(const char * const filename, const unsigned int linenr, const std::string& expected, const char actual[], const std::string &msg) const
-{
-    return assertEquals(filename, linenr, expected, std::string(actual), msg);
-}
-
-bool TestFixture::assertEquals(const char * const filename, const unsigned int linenr, const long long expected, const long long actual, const std::string &msg) const
-{
-    if (expected != actual) {
-        std::ostringstream ostr1;
-        ostr1 << expected;
-        std::ostringstream ostr2;
-        ostr2 << actual;
-        assertEquals(filename, linenr, ostr1.str(), ostr2.str(), msg);
-    }
-    return expected == actual;
-}
-
-void TestFixture::assertEqualsDouble(const char * const filename, const unsigned int linenr, const double expected, const double actual, const double tolerance, const std::string &msg) const
-{
-    if (expected < (actual - tolerance) || expected > (actual + tolerance)) {
-        std::ostringstream ostr1;
-        ostr1 << expected;
-        std::ostringstream ostr2;
-        ostr2 << actual;
-        assertEquals(filename, linenr, ostr1.str(), ostr2.str(), msg);
-    }
-}
-
-void TestFixture::todoAssertEquals(const char * const filename, const unsigned int linenr,
-                                   const std::string &wanted,
-                                   const std::string &current,
-                                   const std::string &actual) const
-{
-    if (wanted == actual) {
-        errmsg << getLocationStr(filename, linenr) << ": Assertion succeeded unexpectedly. "
-               << "Result: " << writestr(wanted, true)  << std::endl << "_____" << std::endl;
-
-        ++succeeded_todos_counter;
-    } else {
-        assertEquals(filename, linenr, current, actual);
-        ++todos_counter;
-    }
-}
-
-void TestFixture::todoAssertEquals(const char * const filename, const unsigned int linenr, const long long wanted, const long long current, const long long actual) const
-{
-    std::ostringstream wantedStr, currentStr, actualStr;
-    wantedStr << wanted;
-    currentStr << current;
-    actualStr << actual;
-    todoAssertEquals(filename, linenr, wantedStr.str(), currentStr.str(), actualStr.str());
-}
-
-void TestFixture::assertThrow(const char * const filename, const unsigned int linenr) const
-{
-    ++fails_counter;
-    errmsg << getLocationStr(filename, linenr) << ": Assertion succeeded. "
-           << "The expected exception was thrown" << std::endl << "_____" << std::endl;
-
-}
-
-void TestFixture::assertThrowFail(const char * const filename, const unsigned int linenr) const
-{
-    ++fails_counter;
-    errmsg << getLocationStr(filename, linenr) << ": Assertion failed. "
-           << "The expected exception was not thrown"  << std::endl << "_____" << std::endl;
-
-}
-
-void TestFixture::assertNoThrowFail(const char * const filename, const unsigned int linenr) const
-{
-    ++fails_counter;
-    errmsg << getLocationStr(filename, linenr) << ": Assertion failed. "
-           << "Unexpected exception was thrown"  << std::endl << "_____" << std::endl;
-
-}
-
-void TestFixture::complainMissingLib(const char * const libname) const
-{
-    missingLibs.insert(libname);
-}
-
-void TestFixture::printHelp()
-{
-    std::cout << "Testrunner - run Cppcheck tests\n"
-              "\n"
-              "Syntax:\n"
-              "    testrunner [OPTIONS] [TestClass::TestCase...]\n"
-              "    run all test cases:\n"
-              "        testrunner\n"
-              "    run all test cases in TestClass:\n"
-              "        testrunner TestClass\n"
-              "    run TestClass::TestCase:\n"
-              "        testrunner TestClass::TestCase\n"
-              "    run all test cases in TestClass1 and TestClass2::TestCase:\n"
-              "        testrunner TestClass1 TestClass2::TestCase\n"
-              "\n"
-              "Options:\n"
-              "    -q                   Do not print the test cases that have run.\n"
-              "    -h, --help           Print this help.\n";
-}
-
-void TestFixture::run(const std::string &str)
-{
-    testToRun = str;
-    if (quiet_tests) {
-        std::cout << '\n' << classname << ':';
-        REDIRECT;
-        run();
-    } else
-        run();
-}
-
-void TestFixture::processOptions(const options& args)
-{
-    quiet_tests = args.quiet();
-}
-
-std::size_t TestFixture::runTests(const options& args)
-{
-    countTests = 0;
-    errmsg.str("");
-
-    for (std::string classname : args.which_test()) {
-        std::string testname;
-        if (classname.find("::") != std::string::npos) {
-            testname = classname.substr(classname.find("::") + 2);
-            classname.erase(classname.find("::"));
-        }
-
-        for (TestFixture * test : TestRegistry::theInstance().tests()) {
-            if (classname.empty() || test->classname == classname) {
-                test->processOptions(args);
-                test->run(testname);
-            }
-        }
-    }
-
-    std::cout << "\n\nTesting Complete\nNumber of tests: " << countTests << std::endl;
-    std::cout << "Number of todos: " << todos_counter;
-    if (succeeded_todos_counter > 0)
-        std::cout << " (" << succeeded_todos_counter << " succeeded)";
-    std::cout << std::endl;
-    // calling flush here, to do all output before the error messages (in case the output is buffered)
-    std::cout.flush();
-
-    std::cerr << "Tests failed: " << fails_counter << std::endl << std::endl;
-    std::cerr << errmsg.str();
-
-    if (!missingLibs.empty()) {
-        std::cerr << "Missing libraries: ";
-        for (const std::string & missingLib : missingLibs)
-            std::cerr << missingLib << "  ";
-        std::cerr << std::endl << std::endl;
-    }
-    std::cerr.flush();
-    return fails_counter;
-}
-
-void TestFixture::reportOut(const std::string & outmsg)
-{
-    output << outmsg << std::endl;
-}
-
-void TestFixture::reportErr(const ErrorLogger::ErrorMessage &msg)
-{
-    const std::string errormessage(msg.toString(mVerbose, mTemplateFormat, mTemplateLocation));
-    if (errout.str().find(errormessage) == std::string::npos)
-        errout << errormessage << std::endl;
-}
diff --git a/test/testsuite.h b/test/testsuite.h
deleted file mode 100644
index b6aafd4ab0f..00000000000
--- a/test/testsuite.h
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef testsuiteH
-#define testsuiteH
-
-#include "config.h"
-#include "errorlogger.h"
-
-#include <cstddef>
-#include <set>
-#include <sstream>
-
-class options;
-
-class TestFixture : public ErrorLogger {
-private:
-    static std::ostringstream errmsg;
-    static unsigned int countTests;
-    static std::size_t fails_counter;
-    static std::size_t todos_counter;
-    static std::size_t succeeded_todos_counter;
-    static std::set<std::string> missingLibs;
-    bool mVerbose;
-    std::string mTemplateFormat;
-    std::string mTemplateLocation;
-    std::string mTestname;
-
-protected:
-    std::string testToRun;
-    bool quiet_tests;
-
-    virtual void run() = 0;
-
-    bool prepareTest(const char testname[]);
-    std::string getLocationStr(const char * const filename, const unsigned int linenr) const;
-
-    bool assert_(const char * const filename, const unsigned int linenr, const bool condition) const;
-
-    bool assertEquals(const char * const filename, const unsigned int linenr, const std::string &expected, const std::string &actual, const std::string &msg = emptyString) const;
-    void assertEqualsWithoutLineNumbers(const char * const filename, const unsigned int linenr, const std::string &expected, const std::string &actual, const std::string &msg = emptyString) const;
-    bool assertEquals(const char * const filename, const unsigned int linenr, const char expected[], const std::string& actual, const std::string &msg = emptyString) const;
-    bool assertEquals(const char * const filename, const unsigned int linenr, const char expected[], const char actual[], const std::string &msg = emptyString) const;
-    bool assertEquals(const char * const filename, const unsigned int linenr, const std::string& expected, const char actual[], const std::string &msg = emptyString) const;
-    bool assertEquals(const char * const filename, const unsigned int linenr, const long long expected, const long long actual, const std::string &msg = emptyString) const;
-    void assertEqualsDouble(const char * const filename, const unsigned int linenr, const double expected, const double actual, const double tolerance, const std::string &msg = emptyString) const;
-
-    void todoAssertEquals(const char * const filename, const unsigned int linenr, const std::string &wanted,
-                          const std::string &current, const std::string &actual) const;
-    void todoAssertEquals(const char * const filename, const unsigned int linenr, const long long wanted,
-                          const long long current, const long long actual) const;
-    void assertThrow(const char * const filename, const unsigned int linenr) const;
-    void assertThrowFail(const char * const filename, const unsigned int linenr) const;
-    void assertNoThrowFail(const char * const filename, const unsigned int linenr) const;
-    void complainMissingLib(const char * const libname) const;
-    std::string deleteLineNumber(const std::string &message) const;
-
-    void setVerbose(bool v) {
-        mVerbose = v;
-    }
-
-    void setMultiline() {
-        mTemplateFormat = "{file}:{line}:{severity}:{message}";
-        mTemplateLocation = "{file}:{line}:note:{info}";
-    }
-
-    void processOptions(const options& args);
-public:
-    void reportOut(const std::string &outmsg) OVERRIDE;
-    void reportErr(const ErrorLogger::ErrorMessage &msg) OVERRIDE;
-    void run(const std::string &str);
-    static void printHelp();
-    const std::string classname;
-
-    explicit TestFixture(const char * const _name);
-    ~TestFixture() OVERRIDE { }
-
-    static std::size_t runTests(const options& args);
-};
-
-extern std::ostringstream errout;
-extern std::ostringstream output;
-
-#define TEST_CASE( NAME )  if ( prepareTest(#NAME) ) { setVerbose(false); NAME(); }
-#define ASSERT( CONDITION )  if (!assert_(__FILE__, __LINE__, CONDITION)) return
-#define ASSERT_EQUALS( EXPECTED , ACTUAL )  if (!assertEquals(__FILE__, __LINE__, EXPECTED, ACTUAL)) return
-#define ASSERT_EQUALS_WITHOUT_LINENUMBERS( EXPECTED , ACTUAL )  assertEqualsWithoutLineNumbers(__FILE__, __LINE__, EXPECTED, ACTUAL)
-#define ASSERT_EQUALS_DOUBLE( EXPECTED , ACTUAL, TOLERANCE )  assertEqualsDouble(__FILE__, __LINE__, EXPECTED, ACTUAL, TOLERANCE)
-#define ASSERT_EQUALS_MSG( EXPECTED , ACTUAL, MSG )  assertEquals(__FILE__, __LINE__, EXPECTED, ACTUAL, MSG)
-#define ASSERT_THROW( CMD, EXCEPTION ) try { CMD ; assertThrowFail(__FILE__, __LINE__); } catch (const EXCEPTION&) { } catch (...) { assertThrowFail(__FILE__, __LINE__); }
-#define ASSERT_THROW_EQUALS( CMD, EXCEPTION, EXPECTED ) try { CMD ; assertThrowFail(__FILE__, __LINE__); } catch (const EXCEPTION&e) { assertEquals(__FILE__, __LINE__, EXPECTED, e.errorMessage); } catch (...) { assertThrowFail(__FILE__, __LINE__); }
-#define ASSERT_NO_THROW( CMD ) try { CMD ; } catch (...) { assertNoThrowFail(__FILE__, __LINE__); }
-#define TODO_ASSERT_THROW( CMD, EXCEPTION ) try { CMD ; } catch (const EXCEPTION&) { } catch (...) { assertThrow(__FILE__, __LINE__); }
-#define TODO_ASSERT( CONDITION ) { const bool condition=(CONDITION); todoAssertEquals(__FILE__, __LINE__, true, false, condition); }
-#define TODO_ASSERT_EQUALS( WANTED , CURRENT , ACTUAL ) todoAssertEquals(__FILE__, __LINE__, WANTED, CURRENT, ACTUAL)
-#define EXPECT_EQ( EXPECTED, ACTUAL ) assertEquals(__FILE__, __LINE__, EXPECTED, ACTUAL)
-#define REGISTER_TEST( CLASSNAME ) namespace { CLASSNAME instance_##CLASSNAME; }
-
-#ifdef _WIN32
-#define LOAD_LIB_2( LIB, NAME ) { if (((LIB).load("./testrunner", "../cfg/" NAME).errorcode != Library::OK) && ((LIB).load("./testrunner", "cfg/" NAME).errorcode != Library::OK)) { complainMissingLib(NAME); return; } }
-#else
-#define LOAD_LIB_2( LIB, NAME ) { if (((LIB).load("./testrunner", "cfg/" NAME).errorcode != Library::OK) && ((LIB).load("./bin/testrunner", "bin/cfg/" NAME).errorcode != Library::OK)) { complainMissingLib(NAME); return; } }
-#endif
-
-#endif
diff --git a/test/testsuites/clang/outofbound.c b/test/testsuites/clang/outofbound.c
deleted file mode 100644
index 60190b4bc35..00000000000
--- a/test/testsuites/clang/outofbound.c
+++ /dev/null
@@ -1,128 +0,0 @@
-// RUN: %clang_analyze_cc1 -Wno-array-bounds -analyzer-store=region -verify %s \
-// RUN:   -analyzer-checker=core \
-// RUN:   -analyzer-checker=unix \
-// RUN:   -analyzer-checker=alpha.security.ArrayBound \
-// RUN:   -analyzer-config unix.DynamicMemoryModeling:Optimistic=true
-
-typedef __typeof(sizeof(int)) size_t;
-void *malloc(size_t);
-void *calloc(size_t, size_t);
-
-char f1() {
-  char* s = "abcd";
-  char c = s[4]; // no-warning
-  return s[5] + c; // expected-warning{{Access out-of-bound array element (buffer overflow)}}
-}
-
-void f2() {
-  int *p = malloc(12);
-  p[3] = 4; // expected-warning{{Access out-of-bound array element (buffer overflow)}}
-}
-
-struct three_words {
-  int c[3];
-};
-
-struct seven_words {
-  int c[7];
-};
-
-void f3() {
-  struct three_words a, *p;
-  p = &a;
-  p[0] = a; // no-warning
-  p[1] = a; // expected-warning{{Access out-of-bound array element (buffer overflow)}}
-}
-
-void f4() {
-  struct seven_words c;
-  struct three_words a, *p = (struct three_words *)&c;
-  p[0] = a; // no-warning
-  p[1] = a; // no-warning
-  p[2] = a; // expected-warning{{Access out-of-bound array element (buffer overflow)}}
-}
-
-void f5() {
-  char *p = calloc(2,2);
-  p[3] = '.'; // no-warning
-  p[4] = '!'; // expected-warning{{out-of-bound}}
-}
-
-void f6() {
-  char a[2];
-  int *b = (int*)a;
-  b[1] = 3; // expected-warning{{out-of-bound}}
-}
-
-void f7() {
-  struct three_words a;
-  a.c[3] = 1; // expected-warning{{out-of-bound}}
-}
-
-void vla(int a) {
-  if (a == 5) {
-    int x[a];
-    x[4] = 4; // no-warning
-    x[5] = 5; // expected-warning{{out-of-bound}}
-  }
-}
-
-void alloca_region(int a) {
-  if (a == 5) {
-    char *x = __builtin_alloca(a);
-    x[4] = 4; // no-warning
-    x[5] = 5; // expected-warning{{out-of-bound}}
-  }
-}
-
-int symbolic_index(int a) {
-  int x[2] = {1, 2};
-  if (a == 2) {
-    return x[a]; // expected-warning{{out-of-bound}}
-  }
-  return 0;
-}
-
-int symbolic_index2(int a) {
-  int x[2] = {1, 2};
-  if (a < 0) {
-    return x[a]; // expected-warning{{out-of-bound}}
-  }
-  return 0;
-}
-
-int overflow_binary_search(double in) {
-  int eee = 16;
-  if (in < 1e-8 || in > 1e23) {
-    return 0;
-  } else {
-    static const double ins[] = {1e-8, 1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1,
-                                 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7,
-                                 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15,
-                                 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22};
-    if (in < ins[eee]) {
-      eee -= 8;
-    } else {
-      eee += 8;
-    }
-    if (in < ins[eee]) {
-      eee -= 4;
-    } else {
-      eee += 4;
-    }
-    if (in < ins[eee]) {
-      eee -= 2;
-    } else {
-      eee += 2;
-    }
-    if (in < ins[eee]) {
-      eee -= 1;
-    } else {
-      eee += 1;
-    }
-    if (in < ins[eee]) { // expected-warning {{Access out-of-bound array element (buffer overflow)}}
-      eee -= 1;
-    }
-  }
-  return eee;
-}
diff --git a/test/testsuites/clang/readme.txt b/test/testsuites/clang/readme.txt
deleted file mode 100644
index aac49ec20e4..00000000000
--- a/test/testsuites/clang/readme.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-arrayIndexOutOfBounds:
-~/llvm/tools/clang/test/Analysis/outofbound.c
-
diff --git a/test/testsuites/duma/leak1.c b/test/testsuites/duma/leak1.c
deleted file mode 100644
index fdbc4a65355..00000000000
--- a/test/testsuites/duma/leak1.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdio.h>
-
-int main() {
-  printf("Hello world!\n");
-
-  int* pI;
-  pI = (int*)malloc(sizeof(int));
-  printf("Let's leak a pointer to int\n");
-  *pI = 303;
-
-  return 0;
-}
diff --git a/test/testsuites/duma/leak1.cc b/test/testsuites/duma/leak1.cc
deleted file mode 100644
index 6f97dbdd908..00000000000
--- a/test/testsuites/duma/leak1.cc
+++ /dev/null
@@ -1,15 +0,0 @@
-#include <noduma.h>
-#include <iostream>
-#include <dumapp.h>
-
-using namespace std;
-
-int main() {
-  cout << "Hello world!" << endl;
-
-  int* pI = new int;
-  cerr << "Let's leak a pointer to int" << endl;
-  *pI = 303;
-
-  return 0;
-}
diff --git a/test/testsuites/duma/leak2.c b/test/testsuites/duma/leak2.c
deleted file mode 100644
index 923754d494e..00000000000
--- a/test/testsuites/duma/leak2.c
+++ /dev/null
@@ -1,20 +0,0 @@
-#include <stdio.h>
-
-int main() {
-  printf("Hello world!\n");
-
-  int* pI;
-  pI = (int*)malloc(10*sizeof(int));
-
-  printf("Let's leak a pointer to an array of 10 ints\n");
-  int i=0;
-  for (i=0; i<9; i++) {
-    pI[i] = 303+i;
-  }
-  int j=0;
-  for (j=0; j<9; j++) {
-    if (pI[j] != 303+j) printf("  Something strange is happening...\n");
-  }
-
-  return 0;
-}
diff --git a/test/testsuites/duma/leak2.cc b/test/testsuites/duma/leak2.cc
deleted file mode 100644
index e71db91d5ca..00000000000
--- a/test/testsuites/duma/leak2.cc
+++ /dev/null
@@ -1,20 +0,0 @@
-#include <noduma.h>
-#include <iostream>
-#include <dumapp.h>
-
-using namespace std;
-
-int main() {
-  cout << "Hello world!" << endl;
-
-  int* pI = new int[10];
-  cerr << "Let's leak a pointer to an array of 10 ints" << endl;
-  for (int i=0; i<9; i++) {
-    pI[i] = 303+i;
-  }
-  for (int i=0; i<9; i++) {
-    if (pI[i] != 303+i) cerr << "  Something strange is happening..." << endl;
-  }
-
-  return 0;
-}
diff --git a/test/testsuites/duma/memCheckers.html b/test/testsuites/duma/memCheckers.html
deleted file mode 100644
index 58bc149b91d..00000000000
--- a/test/testsuites/duma/memCheckers.html
+++ /dev/null
@@ -1,367 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html><head><title>Comparison of Free Memory Checkers</title>
-
-<link rel="start" type="text/html" href="http://www.cs.utexas.edu/%7Ejpmartin/index.html">
-<link rel="up" type="text/html" href="http://www.cs.utexas.edu/%7Ejpmartin/resources.html">
-<link rel="icon" type="image/png" href="http://www.cs.utexas.edu/%7Ejpmartin/longhorn_icon.png">
-
-
-<link rel="styleSheet" href="memCheckers-Dateien/jpstyle.css" title="default stylesheet">
-<link rel="Alternate StyleSheet" href="memCheckers-Dateien/boringstyle.css" title="alternate
-(old-fashioned) stylesheet"></head><body>
-
-<h1><a class="title" href="http://www.cs.utexas.edu/%7Ejpmartin/index.html">Jean-Philippe Martin</a> |
-<a class="title" href="http://www.cs.utexas.edu/%7Ejpmartin/resources.html">Resources</a> | Memory Checkers Comparison </h1>
-<hr>
-<p>
-
-</p><h3>Memory Checkers</h3>
-
-Memory checkers are debugging tools that help programmers find
-improper use of pointers, typically memory leaks.
-
-<p align="justify">
-There are some freely available memory checkers. I ran a series of
-very simple tests to determine what they can do. The <b>wrong</b>
-series of tests contains code that makes pointer mistakes that are not
-memory leaks, for example freeing a pointer twice, writing to
-uninitialized memory or using delete instead of delete []. The
-<b>leak</b> series of tests contains simple memory leaks,
-i.e. pointers that are allocated but not released. The <b>ok</b>
-series of tests contains programs that are correct and thus should not
-cause the memory checker to output any alarm message.
-</p>
-
-<h3>C tests</h3>
-
-(updated 3/10/2006)<p>
-
-<table border="1">
-  <colgroup>
-  </colgroup><colgroup span="3">
-  </colgroup><colgroup span="2">
-  </colgroup><colgroup>
-
-</colgroup><tbody><tr>
-  <th>Checker
-
-  </th><th><a class="title" href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong1.c">wrong1.c</a>
-  </th><th><a class="title" href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong3.c">wrong3.c</a>
-  </th><th><a class="title" href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong6.c">wrong6.c</a>
-  </th><th><a class="title" href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong7.c">wrong7.c</a>
-  </th><th><a class="title" href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/leak1.c">leak1.c</a>
-  </th><th><a class="title" href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/leak2.c">leak2.c</a>
-  </th><th><a class="title" href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/ok5.c">ok5.c </a>
-
-</th></tr>
-
-
-
-<tr align="center">
-  <td><a class="title" href="http://www.gnu.org/manual/glibc-2.2.5/html_node/Heap-Consistency-Checking.html">MALLOC_CHECK_</a>
-
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkred">missed</font></b>
-  </td><td><b><font color="darkred">missed</font></b>
- </td><td><b><font color="darkgreen">OK</font></b><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong7.out">*</a>
-  </td><td><b><font color="darkred">missed</font></b>
-  </td><td><b><font color="darkred">missed</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-</td></tr>
-
-<tr align="center">
-  <td><a class="title" href="http://dmalloc.com/">dmalloc</a>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkred">missed</font></b> 
-  </td><td><b><font color="darkred">missed</font></b> 
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-</td></tr>
-
-<tr align="center">
-  <td><a class="title" href="http://prj.softpixel.com/mcd/">memCheckDeluxe</a>
-
-  </td><td><b><font color="darkred">missed</font></b>
-  </td><td><b><font color="darkred">missed</font></b>
-  </td><td><b><font color="darkred">missed</font></b>
-  </td><td><b><font color="darkred">missed</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-</td></tr>
-
-<tr align="center">
-  <td><a class="title" href="http://www.linkdata.se/sourcecode.html">memwatch</a>
-
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkred">missed</font></b>
-  </td><td><b><font color="darkred">missed</font></b><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/memwatch-response.txt">*</a>
- </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-</td></tr>
-
-<tr align="center">
-  <td><a class="title" href="http://duma.sourceforge.net/">DUMA</a>
-  </td><td><b><font color="darkgreen">OK</font></b>
-<!-- segfaults on the bad write, but misses the bad read -->
-  </td><td><b><font color="darkred">missed</font></b> 
-  </td><td><b><font color="darkred">missed</font></b> 
-<!-- segfaults on the first bug. That counts as finding it -->
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK<a href="http://www.cs.utexas.edu/%7Ejpmartin/duma-l2c.txt">*</a></font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-</td></tr>
-
-
-
-<tr align="center">
-  <td><a class="title" href="http://devel-home.kde.org/%7Esewardj/">valgrind</a>
-
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkred">missed</font></b>
- </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-</td></tr>
-
-
-
-</tbody></table>
-
-</p><p>
-
-</p><h3>C++ tests</h3>
-
-<table border="1">
-<tbody><tr>
-  <th>Checker
-
-  </th><th><a class="title" href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong1.cc">wrong1.cc</a>
-  </th><th><a class="title" href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong2.cc">wrong2.cc</a>
-  </th><th><a class="title" href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong3.cc">wrong3.cc</a>
-  </th><th><a class="title" href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong4.cc">wrong4.cc</a>
-  </th><th><a class="title" href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong5.cc">wrong5.cc</a>
-  </th><th><a class="title" href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong6.cc">wrong6.cc</a>
-  </th><th><a class="title" href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/leak1.cc">leak1.cc</a>
-  </th><th><a class="title" href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/leak2.cc">leak2.cc</a>
-  </th><th><a class="title" href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/ok5.cc">ok5.cc</a>
-
-</th></tr>
-
-
-<tr align="center">
-  <td><a class="title" href="http://www.gnu.org/manual/glibc-2.2.5/html_node/Heap-Consistency-Checking.html">MALLOC_CHECK_</a>
-
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkred">missed</font></b>
-  </td><td><b><font color="darkred">missed</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkred">missed</font></b>
-  </td><td><b><font color="darkred">missed</font></b>
-  </td><td><b><font color="darkred">missed</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-</td></tr>
-
-<tr align="center">
-  <td><a class="title" href="http://dmalloc.com/">dmalloc</a>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/dmalloc-wrong2.txt">*</a></b>
-  </td><td><b><font color="darkred">missed</font><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/dmalloc-wrong3.txt">*</a></b>
-  </td><td><b><font color="darkred">missed</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkred">missed</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkred">missed</font><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/dmalloc-ok5.txt">*</a></b>
-</td></tr>
-
-<tr align="center">
-  <td><a class="title" href="http://duma.sourceforge.net/">DUMA</a>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-<!-- caught the write to uninitialized memory, but not the read -->
-  </td><td><b><font color="darkred">missed</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkred">missed</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkred">missed</font></b>
-</td></tr>
-
-
-<tr align="center">
-  <td><a class="title" href="http://devel-home.kde.org/%7Esewardj/">valgrind</a>
-
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK<a href="http://www.cs.utexas.edu/%7Ejpmartin/valgrind-w3cc.txt">*</a></font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkred">missed</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-  </td><td><b><font color="darkgreen">OK</font></b>
-</td></tr>
-
-</tbody></table>
-<p>
-
-</p><h3>Conclusion</h3>
-
-<p align="justify">
-memWatch and memCheckDeluxe are both memory leak detectors, and they
-passed all the memory leak tests. Memwatch wins this round because it
-was able to detect the double-free in wrong1.c and the out-of-bounds
-accesses in the dynamically allocated array of wrong7.c (not the
-static array of wrong6 - but no one else did, either).
-Both programs are designed to work with C and require a
-recompilation.
-</p>
-
-<p align="justify">
-MALLOC_CHECK_ is an interesting test: it is triggered simply by
-setting the environment variable MALLOC_CHECK_ to 1, and the rest of
-the magic is done by glibc (see the link in references, below). This
-is the easiest check to set up and it requires no recompilation. It
-detected the double free in wrong1 and the mismatched malloc/delete or
-new/free pairs in wrong2.cc and wrong5.cc. It was able to see that
-something was fishy in wrong7.c, but it reports a single error at the "free"
-instead of when we are accessing the memory instead of two errors, for
-each out-of-bounds access. MALLOC_CHECK_ cannot detect
-memory leaks and did not detect the use of uninitialized memory in
-wrong3.
-</p>
-
-<p align="justify">
-dmalloc is more than a leak detector, but it didn't detect as
-many bad cases as valgrind and requires a recompile. Also, its C++
-support is (in the author's words) minimal. In particular, I have not
-been able to get dmalloc to report line numbers with C++ (<a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/dmalloc-cpp.txt">log</a>), although that feature mostly
-works with C code - in both leak1.c and leak2.c it pointed to 
-the <tt>return()</tt> instead of the line that allocated the unfreed
-memory. Dmalloc also often reports unfreed memory, even for programs
-that are correct. This may be because of errors in the c++ library,
-but it makes the reports harder to read. In contrast, valgrind has a
-way to hide leaks that it knows about so its reports are more
-clear. See also the <a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/dmalloc-feedback.txt">author's comments</a>.
-</p>
-
-<p align="justify">
-valgrind is clearly the winner of this little contest. valgrind
-requires no recompilation of the program, so it's very easy to set
-up. It identified almost all of the incorrect pointer uses and memory
-leaks. The only test that it missed is wrong6, in which we break the
-bounds of an array. No other checker spotted that one, though. Also,
-valgrind has been improved since we ran this test, so it may perform
-even better than what we show here.
-</p>
-
-<p align="justify">
-DUMA is a very close second. The results I am posting here come from
-Koneru Srikanth (kpsrikanth at gmail dot com) who generously sent them
-to me. DUMA seems not to require a recompile, but the tests were run
-on recompiled code. DUMA performs really well. It was also able to
-detect out-of-bounds writes 
-(it is reported as failing wrong3.cc because it missed the
-out-of-bounds read). If for some reason valgrind does not work for
-you, then I recommend that you give DUMA a spin.
-
-
-</p><h3>Reference</h3>
-
-I tested:
-
-<ul>
-  <li><a href="http://www.gnu.org/manual/glibc-2.2.5/html_node/Heap-Consistency-Checking.html">MALLOC_CHECK_</a>
-  for glibc (C and C++: requires no recompilation)
-</li><li><a href="http://dmalloc.com/">dmalloc-5.2.2</a> (C, minimal C++ support; requires recompilation)
-</li><li><a href="http://prj.softpixel.com/mcd/">memCheckDeluxe-1.2.2</a> (C,
-some C++. Requires recompilation)
-</li><li><a href="http://www.linkdata.se/sourcecode.html">memwatch-2.71</a> (C
-only; requires recompilation)
-  </li><li><a href="http://devel-home.kde.org/%7Esewardj/">valgrind-1.9.6</a>
-  (C, C++ and more: requires no recompilation)
-  </li><li><a href="http://duma.sourceforge.net/">DUMA</a> version 2.4.26
-  (C and C++. Documentation says that no recompilation is needed, but
-  the tests were run on recompiled code) (as mentioned above, these tests
-  were contributed by Koneru Srikanth).
-</li></ul>
-
-I did not test:
-
-<ul>
-  <li><a href="http://perens.com/FreeSoftware/">electric fence-2.1</a>
-  (did not compile on first attempt (<a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/efence-output.txt">log</a>))
-  </li><li><a href="http://check.sourceforge.net/">Checker-0.9.9.1</a> (did
-  not compile on first attempt (<a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/checker-output.txt">log</a>); author suggests I use
-  valgrind instead)
-</li></ul>
-
-Test programs:
-
-<ul>
-  <li><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong1.c">wrong1.c</a>
-  </li><li><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong3.c">wrong3.c</a>
-  </li><li><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong6.c">wrong6.c</a>
-  </li><li><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong7.c">wrong7.c</a>
-  </li><li><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/leak1.c">leak1.c</a>
-  </li><li><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/leak2.c">leak2.c</a>
-  </li><li><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/ok5.c">ok5.c </a>
-
-  </li><li><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong1.cc">wrong1.cc</a>
-  </li><li><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong2.cc">wrong2.cc</a>
-  </li><li><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong3.cc">wrong3.cc</a>
-  </li><li><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong4.cc">wrong4.cc</a>
-  </li><li><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong5.cc">wrong5.cc</a>
-  </li><li><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/wrong6.cc">wrong6.cc</a>
-  </li><li><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/leak1.cc">leak1.cc</a>
-  </li><li><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/leak2.cc">leak2.cc</a>
-  </li><li><a href="http://www.cs.utexas.edu/%7Ejpmartin/memcheck/ok5.cc">ok5.cc</a>
-
-</li></ul>
-
-<h3>ToDo</h3>
-
-The following memory checkers have been mentioned to me but I haven't
-tried them yet:
-<ul>
-<li>mpatrol at http://www.cbmamiga.demon.co.uk/mpatrol/
-</li></ul>
-
-<h3>Change History</h3>
-
-March 10, 2006: added DUMA, contributed by Koneru Srikanth
-<br>
-Oct 6, 2003: mention of mpatrol
-<br>
-Sept 29, 2003: added dmalloc
-<br>
-June 25, 2003: minor change in the text
-<br>
-June 24, 2003: corrected result for memwatch's wrong1.c, added wrong7.c
-<br>
-June 15, 2003: initial release
-<p>
-
-Please <a href="http://www.cs.utexas.edu/%7Ejpmartin/contact.html">contact</a> me if you have feedback or
-would like to suggest another tool for the test.
-
-</p><p></p><hr>
- [<a accesskey="j" href="http://www.cs.utexas.edu/%7Ejpmartin/index.html"><b>J</b>P Martin</a>]
- [<a accesskey="s" href="http://www.cs.utexas.edu/%7Ejpmartin/resources.html">re<b>s</b>ources</a>]
- [<a accesskey="c" href="http://www.cs.utexas.edu/%7Ejpmartin/contact.html"><b>c</b>ontact information</a>]
-<p>
-</p><center>
-<a href="http://www.anybrowser.org/campaign/"><img src="memCheckers-Dateien/viewed-any.gif" alt="Best viewed with *any* browser" border="0" height="30" width="85"></a>
-</center>
-
-</body></html>
\ No newline at end of file
diff --git a/test/testsuites/duma/wrong1.c b/test/testsuites/duma/wrong1.c
deleted file mode 100644
index bcbbd211319..00000000000
--- a/test/testsuites/duma/wrong1.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-int main() {
-  printf("Hello world!\n");
-
-  int* pI = (int*)malloc(sizeof(int));
-  *pI=2;
-  free(pI);
-  printf("Now freeing a pointer twice...\n");
-  free(pI);
-  printf("Did you notice?\n");
-  return 0;
-}
diff --git a/test/testsuites/duma/wrong1.cc b/test/testsuites/duma/wrong1.cc
deleted file mode 100644
index ecb9c60852d..00000000000
--- a/test/testsuites/duma/wrong1.cc
+++ /dev/null
@@ -1,16 +0,0 @@
-#include <noduma.h>
-#include <iostream>
-#include <dumapp.h>
-
-using namespace std;
-
-int main() {
-  cout << "Hello world!" << endl;
-  int* pI = new int;
-  *pI=2;
-  delete(pI);
-  cerr << "Now deleting a pointer twice..." << endl;
-  delete(pI);
-  cerr << "Did you notice?" << endl;
-  return 0;
-}
diff --git a/test/testsuites/duma/wrong2.cc b/test/testsuites/duma/wrong2.cc
deleted file mode 100644
index 2c7786a297d..00000000000
--- a/test/testsuites/duma/wrong2.cc
+++ /dev/null
@@ -1,25 +0,0 @@
-#include <noduma.h>
-#include <iostream>
-#include <dumapp.h>
-
-using namespace std;
-
-int main() {
-  cout << "Hello world!" << endl;
-
-  int* pI = new int;
-  *pI=2;
-  cerr << "Now freeing a pointer instead of deleting it..." << endl;
-  free(pI);
-  cerr << "Did you notice?" << endl;
-
-
-  pI = new int;
-  delete(pI);
-  cerr << "Now deleting twice..." << endl;
-  delete(pI);
-  cerr << "Did you notice?" << endl;
-
-  cerr << "There should be 2 errors in this run" << endl;
-  return 0;
-}
diff --git a/test/testsuites/duma/wrong3.c b/test/testsuites/duma/wrong3.c
deleted file mode 100644
index 80b4c3998b3..00000000000
--- a/test/testsuites/duma/wrong3.c
+++ /dev/null
@@ -1,22 +0,0 @@
-#include <stdio.h>
-
-int main() {
-  printf("Hello world!\n");
-
-  int* pI = (int*)malloc(sizeof(int));
-  int j;
-  printf("Now reading uninitialized memory\n");
-  j = *pI+2;
-  printf("Did you notice? (value was %i)\n",j);
-  free(pI);
-  printf("(No memory leak here)\n");
-
-  int* pJ;
-  printf("Now writing to uninitialized pointer\n");
-  *pJ = j;
-  printf("Did you notice?\n");
-
-  // valgrind reports 8, but that's ok
-  printf("There should be 2 errors in this run\n");
-  return 0;
-}
diff --git a/test/testsuites/duma/wrong3.cc b/test/testsuites/duma/wrong3.cc
deleted file mode 100644
index 309b38e0ab7..00000000000
--- a/test/testsuites/duma/wrong3.cc
+++ /dev/null
@@ -1,26 +0,0 @@
-#include <noduma.h>
-#include <iostream>
-#include <dumapp.h>
-
-using namespace std;
-
-int main() {
-  cout << "Hello world!" << endl;
-
-  int* pI = new int;
-  int j;
-  cerr << "Now reading uninitialized memory" << endl;
-  j = *pI+2;
-  cerr << "Did you notice? (value was " << j << ") " << endl;
-  delete pI;
-  cerr << "(No memory leak here)" << endl;
-
-  int* pJ;
-  cerr << "Now writing to uninitialized pointer" << endl;
-  *pJ = j;
-  cerr << "Did you notice?" << endl;
-
-  // valgrind reports 4, but that's ok
-  cerr << "There should be 2 errors in this run" << endl;
-  return 0;
-}
diff --git a/test/testsuites/duma/wrong4.cc b/test/testsuites/duma/wrong4.cc
deleted file mode 100644
index 2e83c9b52a5..00000000000
--- a/test/testsuites/duma/wrong4.cc
+++ /dev/null
@@ -1,26 +0,0 @@
-#include <noduma.h>
-#include <iostream>
-#include <dumapp.h>
-
-using namespace std;
-
-int main() {
-  cout << "Hello world!" << endl;
-
-  {
-  int* pI = new int[10];
-  cerr << "Let's delete instead of delete [] " << endl;
-  delete pI;
-  cerr << "Did you notice?" << endl;
-  }
-
-  {
-  int* pI = new int[10];
-  cerr << "Now let's free instead of delete [] " << endl;
-  free(pI);
-  cerr << "Did you notice?" << endl;
-  }
-
-  cerr << "There should be 2 errors in this run" << endl;
-  return 0;
-}
diff --git a/test/testsuites/duma/wrong5.cc b/test/testsuites/duma/wrong5.cc
deleted file mode 100644
index 50c6b688534..00000000000
--- a/test/testsuites/duma/wrong5.cc
+++ /dev/null
@@ -1,39 +0,0 @@
-#include <noduma.h>
-#include <iostream>
-#include <string>
-#include <dumapp.h>
-
-using namespace std;
-
-class Test {
-public:
-  int a;
-  string stdstr;
-  
-  Test() {
-    a=2;
-    stdstr = "test";
-  }
-
-};
-
-int main() {
-  cout << "Hello world!" << endl;
-
-  {
-  Test* pI = new Test[10];
-  cerr << "Let's delete instead of delete [] " << endl;
-  delete pI;
-  cerr << "Did you notice?" << endl;
-  }
-
-  {
-  Test* pI = new Test[10];
-  cerr << "Now let's free instead of delete [] " << endl;
-  free(pI);
-  cerr << "Did you notice?" << endl;
-  }
-
-  cerr << "There should be 2 errors in this run" << endl;
-  return 0;
-}
diff --git a/test/testsuites/duma/wrong6.c b/test/testsuites/duma/wrong6.c
deleted file mode 100644
index 973e89b9df6..00000000000
--- a/test/testsuites/duma/wrong6.c
+++ /dev/null
@@ -1,19 +0,0 @@
-#include <stdio.h>
-
-struct Test {
-  int a;
-  char st[10];
-};
-
-int main() {
-  printf("Hello world!\n");
-
-  struct Test ar[10];
-  struct Test b;
-  printf("Let's index out of bounds \n");
-  ar[10].a=10;
-  printf("Did you notice?\n");
-  
-  printf("There should be 1 error in this run\n");
-  return 0;
-}
diff --git a/test/testsuites/duma/wrong6.cc b/test/testsuites/duma/wrong6.cc
deleted file mode 100644
index 85dd1ffefaf..00000000000
--- a/test/testsuites/duma/wrong6.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-#include <noduma.h>
-#include <iostream>
-#include <string>
-#include <dumapp.h>
-
-using namespace std;
-
-class Test {
-public:
-  int a;
-  string stdstr;
-  
-  Test() {
-    a=2;
-    stdstr = "test";
-  }
-
-  void doNothing() {
-    cout << "  hi!" << endl;
-  };
-
-};
-
-int main() {
-  cout << "Hello world!" << endl;
-
-  Test ar[10];
-  Test b;
-  cerr << "Let's index out of bounds " << endl;
-  ar[10].doNothing();
-  cerr << "Did you notice?" << endl;
-  
-  cerr << "There should be 1 error in this run" << endl;
-  return 0;
-}
diff --git a/test/testsuites/duma/wrong7.c b/test/testsuites/duma/wrong7.c
deleted file mode 100644
index 0faf6913ab1..00000000000
--- a/test/testsuites/duma/wrong7.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <stdio.h>
-
-int main() {
-  int *p;
-
-  p = (int*) malloc( sizeof(int) * 10 );
-  printf("Now writing before our allocated array\n");
-  p[-1] ^= 0x0F; /* bash before */
-  printf("... and now after our allocated array\n");
-  p[10] ^= 0x0F; /* bash after */
-  printf("Did you notice?\n");
-  free(p);
-}
diff --git a/test/testsuites/readme.txt b/test/testsuites/readme.txt
deleted file mode 100644
index f912f173029..00000000000
--- a/test/testsuites/readme.txt
+++ /dev/null
@@ -1 +0,0 @@
-Useful test cases taken from public test suites
diff --git a/test/testsummaries.cpp b/test/testsummaries.cpp
new file mode 100644
index 00000000000..7896ffeb750
--- /dev/null
+++ b/test/testsummaries.cpp
@@ -0,0 +1,60 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "fixture.h"
+#include "helpers.h"
+#include "summaries.h"
+
+#include <cstddef>
+#include <string>
+
+class TestSummaries : public TestFixture {
+public:
+    TestSummaries() : TestFixture("TestSummaries") {}
+
+private:
+    void run() override {
+
+        TEST_CASE(createSummaries1);
+        TEST_CASE(createSummariesGlobal);
+        TEST_CASE(createSummariesNoreturn);
+    }
+
+#define createSummaries(...) createSummaries_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    std::string createSummaries_(const char* file, int line, const char (&code)[size]) {
+        // tokenize..
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+        return Summaries::create(tokenizer, "", 0);
+    }
+
+    void createSummaries1() {
+        ASSERT_EQUALS("foo\n", createSummaries("void foo() {}"));
+    }
+
+    void createSummariesGlobal() {
+        ASSERT_EQUALS("foo global:[x]\n", createSummaries("int x; void foo() { x=0; }"));
+    }
+
+    void createSummariesNoreturn() {
+        ASSERT_EQUALS("foo call:[bar] noreturn:[bar]\n", createSummaries("void foo() { bar(); }"));
+    }
+};
+
+REGISTER_TEST(TestSummaries)
diff --git a/test/testsuppressions.cpp b/test/testsuppressions.cpp
index 43763daf38a..eaa524e3640 100644
--- a/test/testsuppressions.cpp
+++ b/test/testsuppressions.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,63 +16,147 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "addoninfo.h"
 #include "config.h"
 #include "cppcheck.h"
+#include "cppcheckexecutor.h"
+#include "errorlogger.h"
+#include "errortypes.h"
+#include "filesettings.h"
+#include "fixture.h"
+#include "helpers.h"
+#include "processexecutor.h"
 #include "settings.h"
+#include "singleexecutor.h"
+#include "standards.h"
 #include "suppressions.h"
-#include "testsuite.h"
 #include "threadexecutor.h"
-#include "path.h"
 
-#include <cstddef>
+#include <cstring>
+#include <initializer_list>
 #include <list>
 #include <map>
+#include <memory>
+#include <sstream>
 #include <string>
 #include <utility>
 #include <vector>
 
 class TestSuppressions : public TestFixture {
 public:
-    TestSuppressions() : TestFixture("TestSuppressions") {
-    }
+    TestSuppressions() : TestFixture("TestSuppressions") {}
 
 private:
 
-    void run() OVERRIDE {
+    class CppCheckExecutorTest final : public CppCheckExecutor
+    {
+        friend class TestSuppressions;
+    };
+
+    const std::string templateFormat{"{callstack}: ({severity}) {inconclusive:inconclusive: }{message}"};
+
+    void run() override {
+        mNewTemplate = true;
+        TEST_CASE(parseLine);
         TEST_CASE(suppressionsBadId1);
         TEST_CASE(suppressionsDosFormat);     // Ticket #1836
         TEST_CASE(suppressionsFileNameWithColon);    // Ticket #1919 - filename includes colon
         TEST_CASE(suppressionsGlob);
+        TEST_CASE(suppressionsGlobId);
         TEST_CASE(suppressionsFileNameWithExtraPath);
-        TEST_CASE(suppressionsSettings);
-        TEST_CASE(suppressionsMultiFile);
+        TEST_CASE(suppressionsSettingsFiles);
+        TEST_CASE(suppressionsSettingsFS);
+#ifdef HAS_THREADING_MODEL_THREAD
+        TEST_CASE(suppressionsSettingsThreadsFiles);
+        TEST_CASE(suppressionsSettingsThreadsFS);
+#endif // HAS_THREADING_MODEL_THREAD
+#ifdef HAS_THREADING_MODEL_FORK
+        TEST_CASE(suppressionsSettingsProcessesFiles);
+        TEST_CASE(suppressionsSettingsProcessesFS);
+#endif // HAS_THREADING_MODEL_FORK
+        TEST_CASE(suppressionsMultiFileFiles);
+        TEST_CASE(suppressionsMultiFileFS);
         TEST_CASE(suppressionsPathSeparator);
         TEST_CASE(suppressionsLine0);
         TEST_CASE(suppressionsFileComment);
 
         TEST_CASE(inlinesuppress);
-        TEST_CASE(inlinesuppress_symbolname);
+        TEST_CASE(inlinesuppress_symbolname_Files);
+        TEST_CASE(inlinesuppress_symbolname_FS);
         TEST_CASE(inlinesuppress_comment);
+        TEST_CASE(inlinesuppress_unchecked);
+
+        TEST_CASE(multi_inlinesuppress);
+        TEST_CASE(multi_inlinesuppress_comment);
 
         TEST_CASE(globalSuppressions); // Testing that global suppressions work (#8515)
 
         TEST_CASE(inlinesuppress_unusedFunction); // #4210 - unusedFunction
         TEST_CASE(globalsuppress_unusedFunction); // #4946
         TEST_CASE(suppressionWithRelativePaths); // #4733
-        TEST_CASE(suppressingSyntaxErrors); // #7076
-        TEST_CASE(suppressingSyntaxErrorsInline); // #5917
-        TEST_CASE(suppressingSyntaxErrorsWhileFileRead) // PR #1333
+        TEST_CASE(suppressingSyntaxErrorsFiles); // #7076
+        TEST_CASE(suppressingSyntaxErrorsFS); // #7076
+        TEST_CASE(suppressingSyntaxErrorsInlineFiles); // #5917
+        TEST_CASE(suppressingSyntaxErrorsInlineFS); // #5917
+        TEST_CASE(suppressingSimplecppErrorsWhileFileReadFiles); // PR #1333
+        TEST_CASE(suppressingSimplecppErrorsWhileFileReadFS); // PR #1333
         TEST_CASE(symbol);
 
-        TEST_CASE(unusedFunction);
+        TEST_CASE(unusedFunctionFiles);
+        TEST_CASE(unusedFunctionFS);
+
+        TEST_CASE(suppressingSyntaxErrorAndExitCodeFiles);
+        TEST_CASE(suppressingSyntaxErrorAndExitCodeFS);
+        TEST_CASE(suppressingSyntaxErrorAndExitCodeMultiFileFiles);
+        TEST_CASE(suppressingSyntaxErrorAndExitCodeMultiFileFS);
+        TEST_CASE(suppressLocal);
+
+        TEST_CASE(suppressUnmatchedSuppressions);
+        TEST_CASE(addSuppressionDuplicate);
+        TEST_CASE(updateSuppressionState);
+        TEST_CASE(addSuppressionLineMultiple);
+
+        TEST_CASE(suppressionsParseXmlFile);
+
+        TEST_CASE(toString);
+
+        TEST_CASE(suppressionFromErrorMessage);
+
+        TEST_CASE(suppressionWildcard);
+
+        TEST_CASE(polyspaceParseRange);
+        TEST_CASE(polyspaceParseIds);
+
+        TEST_CASE(polyspaceMisraC2012);
+        TEST_CASE(polyspacePremiumMisraC2012);
+        TEST_CASE(polyspaceMisraC2023);
+        TEST_CASE(polyspaceMisraCpp2008);
+        TEST_CASE(polyspaceMisraCpp2023);
+        TEST_CASE(polyspaceCertC);
+        TEST_CASE(polyspaceCertCpp);
+        TEST_CASE(polyspaceAutosar);
+        TEST_CASE(polyspaceIgnored);
+        TEST_CASE(polyspaceMultiple1);
+        TEST_CASE(polyspaceMultiple2);
+        TEST_CASE(polyspaceMultiple3);
+        TEST_CASE(polyspaceRange);
+        TEST_CASE(polyspaceBlock);
+        TEST_CASE(polyspaceExtraComments);
+    }
+
 
-        TEST_CASE(matchglob);
+    void parseLine() const {
+        ASSERT_EQUALS("bad:test.c:1", SuppressionList::parseLine("bad:test.c:1").toString());
 
-        TEST_CASE(suppressingSyntaxErrorAndExitCode);
+        // symbol
+        ASSERT_EQUALS("bad:test.c:1\nsymbol=x", SuppressionList::parseLine("bad:test.c:1\nsymbol=x").toString());
+
+        // polyspace
+        ASSERT_EQUALS("bad:test.c:1\npolyspace=1", SuppressionList::parseLine("bad:test.c:1\npolyspace=1").toString());
     }
 
     void suppressionsBadId1() const {
-        Suppressions suppressions;
+        SuppressionList suppressions;
         std::istringstream s1("123");
         ASSERT_EQUALS("Failed to add suppression. Invalid id \"123\"", suppressions.parseFile(s1));
 
@@ -80,14 +164,17 @@ class TestSuppressions : public TestFixture {
         ASSERT_EQUALS("", suppressions.parseFile(s2));
     }
 
-    Suppressions::ErrorMessage errorMessage(const std::string &errorId) const {
-        Suppressions::ErrorMessage ret;
+    static SuppressionList::ErrorMessage errorMessage(const std::string &errorId) {
+        SuppressionList::ErrorMessage ret;
         ret.errorId = errorId;
+        ret.hash = 0;
+        ret.lineNumber = 0;
+        ret.certainty = Certainty::normal;
         return ret;
     }
 
-    Suppressions::ErrorMessage errorMessage(const std::string &errorId, const std::string &file, int line) const {
-        Suppressions::ErrorMessage ret;
+    static SuppressionList::ErrorMessage errorMessage(const std::string &errorId, const std::string &file, int line) {
+        SuppressionList::ErrorMessage ret;
         ret.errorId = errorId;
         ret.setFileName(file);
         ret.lineNumber = line;
@@ -95,16 +182,18 @@ class TestSuppressions : public TestFixture {
     }
 
     void suppressionsDosFormat() const {
-        Suppressions suppressions;
-        std::istringstream s("abc\r\ndef\r\n");
+        SuppressionList suppressions;
+        std::istringstream s("abc\r\n"
+                             "def\r\n");
         ASSERT_EQUALS("", suppressions.parseFile(s));
         ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("abc")));
         ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("def")));
     }
 
     void suppressionsFileNameWithColon() const {
-        Suppressions suppressions;
-        std::istringstream s("errorid:c:\\foo.cpp\nerrorid:c:\\bar.cpp:12");
+        SuppressionList suppressions;
+        std::istringstream s("errorid:c:\\foo.cpp\n"
+                             "errorid:c:\\bar.cpp:12");
         ASSERT_EQUALS("", suppressions.parseFile(s));
         ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("errorid", "c:/foo.cpp", 1111)));
         ASSERT_EQUALS(false, suppressions.isSuppressed(errorMessage("errorid", "c:/bar.cpp", 10)));
@@ -114,15 +203,19 @@ class TestSuppressions : public TestFixture {
     void suppressionsGlob() const {
         // Check for syntax errors in glob
         {
-            Suppressions suppressions;
-            std::istringstream s("errorid:**.cpp\n");
-            ASSERT_EQUALS("Failed to add suppression. Invalid glob pattern '**.cpp'.", suppressions.parseFile(s));
+            SuppressionList suppressions;
+            std::istringstream s("errorid:*?.cpp\n");
+            ASSERT_EQUALS("Failed to add suppression. Invalid glob pattern '*?.cpp'.", suppressions.parseFile(s));
         }
 
         // Check that globbing works
         {
-            Suppressions suppressions;
-            std::istringstream s("errorid:x*.cpp\nerrorid:y?.cpp\nerrorid:test.c*");
+            SuppressionList suppressions;
+            std::istringstream s("errorid:x*.cpp\n"
+                                 "errorid:y?.cpp\n"
+                                 "errorid:test.c*\n"
+                                 "errorid:dir/**\n"
+                                 "errorid:**/abc**/xyz-??*.?pp\n");
             ASSERT_EQUALS("", suppressions.parseFile(s));
             ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("errorid", "xyz.cpp", 1)));
             ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("errorid", "xyz.cpp.cpp", 1)));
@@ -131,12 +224,22 @@ class TestSuppressions : public TestFixture {
             ASSERT_EQUALS(false, suppressions.isSuppressed(errorMessage("errorid", "y.cpp", 1)));
             ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("errorid", "test.c", 1)));
             ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("errorid", "test.cpp", 1)));
+
+            ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("errorid", "dir/test.cpp", 1)));
+            ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("errorid", "dir/deep/nested/test.cpp", 1)));
+            ASSERT_EQUALS(false, suppressions.isSuppressed(errorMessage("errorid", "yellow.cpp", 1)));
+            ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("errorid", "foo/sub/abc/sub/xyz-22aaa.cpp", 1)));
+            ASSERT_EQUALS(false, suppressions.isSuppressed(errorMessage("errorid", "foo/sub/abc-xyz-22.cpp", 1)));
+            ASSERT_EQUALS(false, suppressions.isSuppressed(errorMessage("errorid", "x/abcxyz-11.cpp", 1)));
         }
 
         // Check that both a filename match and a glob match apply
         {
-            Suppressions suppressions;
-            std::istringstream s("errorid:x*.cpp\nerrorid:xyz.cpp:1\nerrorid:a*.cpp:1\nerrorid:abc.cpp:2");
+            SuppressionList suppressions;
+            std::istringstream s("errorid:x*.cpp\n"
+                                 "errorid:xyz.cpp:1\n"
+                                 "errorid:a*.cpp:1\n"
+                                 "errorid:abc.cpp:2");
             ASSERT_EQUALS("", suppressions.parseFile(s));
             ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("errorid", "xyz.cpp", 1)));
             ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("errorid", "xyz.cpp", 2)));
@@ -145,225 +248,728 @@ class TestSuppressions : public TestFixture {
         }
     }
 
+    void suppressionsGlobId() const {
+        SuppressionList suppressions;
+        std::istringstream s("a*\n");
+        ASSERT_EQUALS("", suppressions.parseFile(s));
+        ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("abc", "xyz.cpp", 1)));
+        ASSERT_EQUALS(false, suppressions.isSuppressed(errorMessage("def", "xyz.cpp", 1)));
+    }
+
     void suppressionsFileNameWithExtraPath() const {
         // Ticket #2797
-        Suppressions suppressions;
-        suppressions.addSuppressionLine("errorid:./a.c:123");
+        SuppressionList suppressions;
+        ASSERT_EQUALS("", suppressions.addSuppressionLine("errorid:./a.c:123"));
         ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("errorid", "a.c", 123)));
         ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("errorid", "x/../a.c", 123)));
     }
 
-    void reportSuppressions(const Settings &settings, const std::map<std::string, std::string> &files) {
-        // make it verbose that this check is disabled
-        const bool unusedFunctionCheck = false;
-
-        if (settings.jointSuppressionReport) {
-            for (std::map<std::string, std::string>::const_iterator i = files.begin(); i != files.end(); ++i) {
-                reportUnmatchedSuppressions(settings.nomsg.getUnmatchedLocalSuppressions(i->first, unusedFunctionCheck));
-            }
-        }
+    unsigned int checkSuppressionFiles(const char code[], const std::string &suppression = "") {
+        return _checkSuppression(code, false, suppression);
+    }
 
-        reportUnmatchedSuppressions(settings.nomsg.getUnmatchedGlobalSuppressions(unusedFunctionCheck));
+    unsigned int checkSuppressionFS(const char code[], const std::string &suppression = "") {
+        return _checkSuppression(code, true, suppression);
     }
 
     // Check the suppression
-    unsigned int checkSuppression(const char code[], const std::string &suppression = emptyString) {
+    unsigned int _checkSuppression(const char code[], bool useFS, const std::string &suppression = "") {
         std::map<std::string, std::string> files;
         files["test.cpp"] = code;
 
-        return checkSuppression(files, suppression);
+        return _checkSuppression(files, useFS, suppression);
+    }
+
+    unsigned int checkSuppressionFiles(std::map<std::string, std::string> &f, const std::string &suppression = "") {
+        return _checkSuppression(f, false, suppression);
+    }
+
+    unsigned int checkSuppressionFS(std::map<std::string, std::string> &f, const std::string &suppression = "") {
+        return _checkSuppression(f, true, suppression);
     }
 
     // Check the suppression for multiple files
-    unsigned int checkSuppression(std::map<std::string, std::string> &files, const std::string &suppression = emptyString) {
-        // Clear the error log
-        errout.str("");
+    unsigned int _checkSuppression(std::map<std::string, std::string> &f, bool useFS, const std::string &suppression = "") {
+        std::list<FileSettings> fileSettings;
+
+        std::list<FileWithDetails> filelist;
+        for (auto i = f.cbegin(); i != f.cend(); ++i) {
+            filelist.emplace_back(i->first, Standards::Language::CPP, i->second.size());
+            if (useFS) {
+                fileSettings.emplace_back(i->first, Standards::Language::CPP, i->second.size());
+            }
+        }
+
+        Suppressions supprs;
+        if (!suppression.empty()) {
+            ASSERT_EQUALS("", supprs.nomsg.addSuppressionLine(suppression));
+        }
 
-        CppCheck cppCheck(*this, true);
-        Settings& settings = cppCheck.settings();
-        settings.exitCode = 1;
+        Settings settings;
+        settings.jobs = 1;
+        settings.quiet = true;
         settings.inlineSuppressions = true;
+        settings.severity.enable(Severity::information);
         if (suppression == "unusedFunction")
-            settings.addEnabled("unusedFunction");
-        settings.addEnabled("information");
-        settings.jointSuppressionReport = true;
-        if (!suppression.empty()) {
-            std::string r = settings.nomsg.addSuppressionLine(suppression);
-            EXPECT_EQ("", r);
+            settings.checks.setEnabled(Checks::unusedFunction, true);
+        settings.templateFormat = templateFormat;
+
+        std::vector<std::unique_ptr<ScopedFile>> scopedfiles;
+        scopedfiles.reserve(filelist.size());
+        for (auto i = f.cbegin(); i != f.cend(); ++i)
+            scopedfiles.emplace_back(new ScopedFile(i->first, i->second));
+
+        // clear files list so only fileSettings are used
+        if (useFS)
+            filelist.clear();
+
+        CppCheck cppCheck(settings, supprs, *this, nullptr, true, nullptr);
+        SingleExecutor executor(cppCheck, filelist, fileSettings, settings, supprs, *this, nullptr);
+        unsigned int exitCode = executor.check();
+
+        const bool err = CppCheckExecutorTest::reportUnmatchedSuppressions(settings, supprs.nomsg, filelist, fileSettings, *this);
+        if (err && exitCode == 0)
+            exitCode = 1;
+
+        return exitCode;
+    }
+
+#ifdef HAS_THREADING_MODEL_THREAD
+    unsigned int checkSuppressionThreadsFiles(const char code[], const std::string &suppression = "") {
+        return _checkSuppressionThreads(code, false, suppression);
+    }
+
+    unsigned int checkSuppressionThreadsFS(const char code[], const std::string &suppression = "") {
+        return _checkSuppressionThreads(code, true, suppression);
+    }
+
+    unsigned int _checkSuppressionThreads(const char code[], bool useFS, const std::string &suppression = "") {
+        std::list<FileSettings> fileSettings;
+
+        std::list<FileWithDetails> filelist;
+        filelist.emplace_back("test.cpp", Standards::Language::CPP, strlen(code));
+        if (useFS) {
+            fileSettings.emplace_back("test.cpp", Standards::Language::CPP, strlen(code));
         }
 
-        unsigned int exitCode = 0;
-        for (std::map<std::string, std::string>::const_iterator file = files.begin(); file != files.end(); ++file) {
-            exitCode |= cppCheck.check(file->first, file->second);
+        const auto settings = dinit(Settings,
+                                    $.jobs = 2,
+                                        $.quiet = true,
+                                        $.inlineSuppressions = true,
+                                        $.severity.enable (Severity::information),
+                                        $.templateFormat = templateFormat);
+
+        Suppressions supprs;
+        if (!suppression.empty()) {
+            ASSERT_EQUALS("", supprs.nomsg.addSuppressionLine(suppression));
         }
-        if (cppCheck.analyseWholeProgram())
-            exitCode |= settings.exitCode;
 
-        reportSuppressions(settings, files);
+        std::vector<std::unique_ptr<ScopedFile>> scopedfiles;
+        scopedfiles.reserve(filelist.size());
+        for (auto i = filelist.cbegin(); i != filelist.cend(); ++i)
+            scopedfiles.emplace_back(new ScopedFile(i->path(), code));
+
+        // clear files list so only fileSettings are used
+        if (useFS)
+            filelist.clear();
+
+        ThreadExecutor executor(filelist, fileSettings, settings, supprs, *this, nullptr, CppCheckExecutorTest::executeCommand);
+        unsigned int exitCode = executor.check();
+
+        const bool err = CppCheckExecutorTest::reportUnmatchedSuppressions(settings, supprs.nomsg, filelist, fileSettings, *this);
+        if (err && exitCode == 0)
+            exitCode = 1;
 
         return exitCode;
     }
+#endif // HAS_THREADING_MODEL_THREAD
 
-    unsigned int checkSuppressionThreads(const char code[], const std::string &suppression = emptyString) {
-        errout.str("");
-        output.str("");
+#ifdef HAS_THREADING_MODEL_FORK
+    unsigned int checkSuppressionProcessesFiles(const char code[], const std::string &suppression = "") {
+        return _checkSuppressionProcesses(code, false, suppression);
+    }
 
-        std::map<std::string, std::size_t> files;
-        files["test.cpp"] = 1;
+    unsigned int checkSuppressionProcessesFS(const char code[], const std::string &suppression = "") {
+        return _checkSuppressionProcesses(code, true, suppression);
+    }
 
-        Settings settings;
-        settings.jobs = 1;
-        settings.inlineSuppressions = true;
-        settings.addEnabled("information");
+    unsigned int _checkSuppressionProcesses(const char code[], bool useFS, const std::string &suppression = "") {
+        std::list<FileSettings> fileSettings;
+
+        std::list<FileWithDetails> filelist;
+        filelist.emplace_back("test.cpp", Standards::Language::CPP, strlen(code));
+        if (useFS) {
+            fileSettings.emplace_back("test.cpp", Standards::Language::CPP, strlen(code));
+        }
+
+        /*const*/ auto settings = dinit(Settings,
+                                        $.jobs = 2,
+                                            $.quiet = true,
+                                            $.inlineSuppressions = true);
+        settings.severity.enable(Severity::information);
+        settings.templateFormat = templateFormat;
+
+        Suppressions supprs;
         if (!suppression.empty()) {
-            EXPECT_EQ("", settings.nomsg.addSuppressionLine(suppression));
+            ASSERT_EQUALS("", supprs.nomsg.addSuppressionLine(suppression));
         }
-        ThreadExecutor executor(files, settings, *this);
-        for (std::map<std::string, std::size_t>::const_iterator i = files.begin(); i != files.end(); ++i)
-            executor.addFileContent(i->first, code);
 
-        const unsigned int exitCode = executor.check();
+        std::vector<std::unique_ptr<ScopedFile>> scopedfiles;
+        scopedfiles.reserve(filelist.size());
+        for (auto i = filelist.cbegin(); i != filelist.cend(); ++i)
+            scopedfiles.emplace_back(new ScopedFile(i->path(), code));
+
+        // clear files list so only fileSettings are used
+        if (useFS)
+            filelist.clear();
 
-        std::map<std::string, std::string> files_for_report;
-        for (std::map<std::string, std::size_t>::const_iterator file = files.begin(); file != files.end(); ++file)
-            files_for_report[file->first] = "";
+        ProcessExecutor executor(filelist, fileSettings, settings, supprs, *this, nullptr, CppCheckExecutorTest::executeCommand);
+        unsigned int exitCode = executor.check();
 
-        reportSuppressions(settings, files_for_report);
+        const bool err = CppCheckExecutorTest::reportUnmatchedSuppressions(settings, supprs.nomsg, filelist, fileSettings, *this);
+        if (err && exitCode == 0)
+            exitCode = 1;
 
         return exitCode;
     }
+#endif // HAS_THREADING_MODEL_FORK
 
     void runChecks(unsigned int (TestSuppressions::*check)(const char[], const std::string &)) {
-        // check to make sure the appropriate error is present
-        (this->*check)("void f() {\n"
-                       "    int a;\n"
-                       "    a++;\n"
-                       "}\n",
-                       "");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: a\n", errout.str());
+        // check to make sure the appropriate errors are present
+        ASSERT_EQUALS(1, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    a++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
+
+        ASSERT_EQUALS(1, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    a++;\n"
+                                        "    int b;\n"
+                                        "    b++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Uninitialized variable: a [uninitvar]\n"
+                      "[test.cpp:5:5]: (error) Uninitialized variable: b [uninitvar]\n", errout_str());
 
         // suppress uninitvar globally
-        (this->*check)("void f() {\n"
-                       "    int a;\n"
-                       "    a++;\n"
-                       "}\n",
-                       "uninitvar");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    a++;\n"
+                                        "}\n",
+                                        "uninitvar"));
+        ASSERT_EQUALS("", errout_str());
+
+        ASSERT_EQUALS(1, (this->*check)("void f() {\n"
+                                        "    // cppcheck-suppress-file uninitvar\n"
+                                        "    int a;\n"
+                                        "    a++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("[test.cpp:2:5]: (error) File suppression should be at the top of the file [invalidSuppression]\n"
+                      "[test.cpp:4:5]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
+
+        ASSERT_EQUALS(1, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    a++;\n"
+                                        "}\n"
+                                        "// cppcheck-suppress-file uninitvar\n",
+                                        ""));
+        ASSERT_EQUALS("[test.cpp:5:1]: (error) File suppression should be at the top of the file [invalidSuppression]\n"
+                      "[test.cpp:3:5]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
+
+        ASSERT_EQUALS(0, (this->*check)("// cppcheck-suppress-file uninitvar\n"
+                                        "void f() {\n"
+                                        "    int a;\n"
+                                        "    a++;\n"
+                                        "    int b;\n"
+                                        "    b++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
+
+        ASSERT_EQUALS(0, (this->*check)("/* Fake file description\n"
+                                        " * End\n"
+                                        " */\n"
+                                        "\n"
+                                        "// cppcheck-suppress-file uninitvar\n"
+                                        "\n"
+                                        "void f() {\n"
+                                        "    int a;\n"
+                                        "    a++;\n"
+                                        "    int b;\n"
+                                        "    b++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
+
+        ASSERT_EQUALS(0, (this->*check)("// cppcheck-suppress-file uninitvar\n"
+                                        "void f() {\n"
+                                        "    int a;\n"
+                                        "    a++;\n"
+                                        "    int b;\n"
+                                        "    b++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
 
         // suppress uninitvar globally, without error present
-        (this->*check)("void f() {\n"
-                       "    int a;\n"
-                       "    b++;\n"
-                       "}\n",
-                       "uninitvar");
-        ASSERT_EQUALS("(information) Unmatched suppression: uninitvar\n", errout.str());
+        ASSERT_EQUALS(1, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    b++;\n"
+                                        "}\n",
+                                        "uninitvar"));
+        ASSERT_EQUALS("(information) Unmatched suppression: uninitvar [unmatchedSuppression]\n", errout_str());
+
+        ASSERT_EQUALS(1, (this->*check)("// cppcheck-suppress-file uninitvar\n"
+                                        "void f() {\n"
+                                        "    int a;\n"
+                                        "    b++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("[test.cpp:1:0]: (information) Unmatched suppression: uninitvar [unmatchedSuppression]\n", errout_str());
 
         // suppress uninitvar for this file only
-        (this->*check)("void f() {\n"
-                       "    int a;\n"
-                       "    a++;\n"
-                       "}\n",
-                       "uninitvar:test.cpp");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    a++;\n"
+                                        "}\n",
+                                        "uninitvar:test.cpp"));
+        ASSERT_EQUALS("", errout_str());
 
         // suppress uninitvar for this file only, without error present
-        (this->*check)("void f() {\n"
-                       "    int a;\n"
-                       "    b++;\n"
-                       "}\n",
-                       "uninitvar:test.cpp");
-        ASSERT_EQUALS("[test.cpp]: (information) Unmatched suppression: uninitvar\n", errout.str());
+        ASSERT_EQUALS(1, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    b++;\n"
+                                        "}\n",
+                                        "uninitvar:test.cpp"));
+        ASSERT_EQUALS("[test.cpp:0:0]: (information) Unmatched suppression: uninitvar [unmatchedSuppression]\n", errout_str());
 
         // suppress all for this file only
-        (this->*check)("void f() {\n"
-                       "    int a;\n"
-                       "    a++;\n"
-                       "}\n",
-                       "*:test.cpp");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    a++;\n"
+                                        "}\n",
+                                        "*:test.cpp"));
+        ASSERT_EQUALS("", errout_str());
 
         // suppress all for this file only, without error present
-        (this->*check)("void f() {\n"
-                       "    int a;\n"
-                       "    b++;\n"
-                       "}\n",
-                       "*:test.cpp");
-        ASSERT_EQUALS("[test.cpp]: (information) Unmatched suppression: *\n", errout.str());
+        ASSERT_EQUALS(1, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    b++;\n"
+                                        "}\n",
+                                        "*:test.cpp"));
+        ASSERT_EQUALS("[test.cpp:0:0]: (information) Unmatched suppression: * [unmatchedSuppression]\n", errout_str());
 
         // suppress uninitvar for this file and line
-        (this->*check)("void f() {\n"
-                       "    int a;\n"
-                       "    a++;\n"
-                       "}\n",
-                       "uninitvar:test.cpp:3");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    a++;\n"
+                                        "}\n",
+                                        "uninitvar:test.cpp:3"));
+        ASSERT_EQUALS("", errout_str());
 
         // suppress uninitvar for this file and line, without error present
-        (this->*check)("void f() {\n"
-                       "    int a;\n"
-                       "    b++;\n"
-                       "}\n",
-                       "uninitvar:test.cpp:3");
-        ASSERT_EQUALS("[test.cpp:3]: (information) Unmatched suppression: uninitvar\n", errout.str());
+        ASSERT_EQUALS(1, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    b++;\n"
+                                        "}\n",
+                                        "uninitvar:test.cpp:3"));
+        ASSERT_EQUALS("[test.cpp:3:0]: (information) Unmatched suppression: uninitvar [unmatchedSuppression]\n", errout_str());
 
         // suppress uninitvar inline
-        (this->*check)("void f() {\n"
-                       "    int a;\n"
-                       "    // cppcheck-suppress uninitvar\n"
-                       "    a++;\n"
-                       "}\n",
-                       "");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    // cppcheck-suppress uninitvar\n"
+                                        "    a++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
 
         // suppress uninitvar inline
-        (this->*check)("void f() {\n"
-                       "    int a;\n"
-                       "    // cppcheck-suppress uninitvar\n"
-                       "\n"
-                       "    a++;\n"
-                       "}\n",
-                       "");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    // cppcheck-suppress uninitvar\n"
+                                        "\n"
+                                        "    a++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
 
         // suppress uninitvar inline
-        (this->*check)("void f() {\n"
-                       "    int a;\n"
-                       "    /* cppcheck-suppress uninitvar */\n"
-                       "    a++;\n"
-                       "}\n",
-                       "");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    a++;// cppcheck-suppress uninitvar\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
 
         // suppress uninitvar inline
-        (this->*check)("void f() {\n"
-                       "    int a;\n"
-                       "    /* cppcheck-suppress uninitvar */\n"
-                       "\n"
-                       "    a++;\n"
-                       "}\n",
-                       "");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    /* cppcheck-suppress uninitvar */\n"
+                                        "    a++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
+
+        // suppress uninitvar inline
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    /* cppcheck-suppress uninitvar */\n"
+                                        "\n"
+                                        "    a++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
+
+        // suppress uninitvar inline
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    a++;/* cppcheck-suppress uninitvar */\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
+
+        // suppress uninitvar inline
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    // cppcheck-suppress[uninitvar]\n"
+                                        "    a++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
+
+        // suppress uninitvar inline
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    // cppcheck-suppress[uninitvar]\n"
+                                        "    a++;\n"
+                                        "\n"
+                                        "    a++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
+
+        // suppress uninitvar inline
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    a++;// cppcheck-suppress[uninitvar]\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
+
+        // suppress uninitvar inline
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    /* cppcheck-suppress[uninitvar]*/\n"
+                                        "    a++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
+
+        // suppress uninitvar inline
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    /* cppcheck-suppress[uninitvar]*/\n"
+                                        "\n"
+                                        "    a++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
+
+        // suppress uninitvar inline
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    a++;/* cppcheck-suppress[uninitvar]*/\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
 
         // suppress uninitvar inline, with asm before (#6813)
-        (this->*check)("void f() {\n"
-                       "    __asm {\n"
-                       "        foo\n"
-                       "    }"
-                       "    int a;\n"
-                       "    // cppcheck-suppress uninitvar\n"
-                       "    a++;\n"
-                       "}",
-                       "");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    __asm {\n"
+                                        "        foo\n"
+                                        "    }"
+                                        "    int a;\n"
+                                        "    // cppcheck-suppress uninitvar\n"
+                                        "    a++;\n"
+                                        "}",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
 
         // suppress uninitvar inline, without error present
-        (this->*check)("void f() {\n"
-                       "    int a;\n"
-                       "    // cppcheck-suppress uninitvar\n"
-                       "    b++;\n"
-                       "}\n",
-                       "");
-        ASSERT_EQUALS("[test.cpp:4]: (information) Unmatched suppression: uninitvar\n", errout.str());
+        ASSERT_EQUALS(1, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    // cppcheck-suppress uninitvar\n"
+                                        "    b++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("[test.cpp:4:0]: (information) Unmatched suppression: uninitvar [unmatchedSuppression]\n", errout_str());
+
+        // suppress block inline checks
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    // cppcheck-suppress-begin uninitvar\n"
+                                        "    int a;\n"
+                                        "    a++;\n"
+                                        "    int b;\n"
+                                        "    b++;\n"
+                                        "    // cppcheck-suppress-end uninitvar\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
+
+        ASSERT_EQUALS(1, (this->*check)("void f() {\n"
+                                        "    // cppcheck-suppress-begin uninitvar\n"
+                                        "    int a;\n"
+                                        "    a++;\n"
+                                        "    int b;\n"
+                                        "    b++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("[test.cpp:2:5]: (error) Suppress Begin: No matching end [invalidSuppression]\n"
+                      "[test.cpp:4:5]: (error) Uninitialized variable: a [uninitvar]\n"
+                      "[test.cpp:6:5]: (error) Uninitialized variable: b [uninitvar]\n", errout_str());
+
+        ASSERT_EQUALS(1, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    a++;\n"
+                                        "    int b;\n"
+                                        "    b++;\n"
+                                        "    // cppcheck-suppress-end uninitvar\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("[test.cpp:6:5]: (error) Suppress End: No matching begin [invalidSuppression]\n"
+                      "[test.cpp:3:5]: (error) Uninitialized variable: a [uninitvar]\n"
+                      "[test.cpp:5:5]: (error) Uninitialized variable: b [uninitvar]\n", errout_str());
+
+        ASSERT_EQUALS(1, (this->*check)("// cppcheck-suppress: id\n"
+                                        "// cppcheck-suppress-unknown id\n"
+                                        "// cppcheck-suppress-begin-unknown id\n"
+                                        "// cppcheck-suppress-begin id4\n"
+                                        "void f() {}\n"
+                                        "// cppcheck-suppress-end-unknown id4\n",
+                                        ""));
+        ASSERT_EQUALS("[test.cpp:1:1]: (error) unknown suppression type 'cppcheck-suppress:' [invalidSuppression]\n"
+                      "[test.cpp:2:1]: (error) unknown suppression type 'cppcheck-suppress-unknown' [invalidSuppression]\n"
+                      "[test.cpp:3:1]: (error) unknown suppression type 'cppcheck-suppress-begin-unknown' [invalidSuppression]\n"
+                      "[test.cpp:6:1]: (error) unknown suppression type 'cppcheck-suppress-end-unknown' [invalidSuppression]\n"
+                      "[test.cpp:4:1]: (error) Suppress Begin: No matching end [invalidSuppression]\n", errout_str());
+
+        ASSERT_EQUALS(1, (this->*check)("// cppcheck-suppress-file\n"
+                                        "// cppcheck-suppress\n"
+                                        "// cppcheck-suppress \n"
+                                        "// cppcheck-suppress\t\n"
+                                        "// cppcheck-suppress []\n" // TODO
+                                        "// cppcheck-suppress-macro\n"
+                                        "// cppcheck-suppress-begin\n"
+                                        "// cppcheck-suppress-begin id0\n"
+                                        "void f() {}\n"
+                                        "// cppcheck-suppress-end\n",
+                                        ""));
+        ASSERT_EQUALS("[test.cpp:1:1]: (error) suppression without error ID [invalidSuppression]\n"
+                      "[test.cpp:2:1]: (error) suppression without error ID [invalidSuppression]\n"
+                      "[test.cpp:3:1]: (error) suppression without error ID [invalidSuppression]\n"
+                      "[test.cpp:4:1]: (error) suppression without error ID [invalidSuppression]\n"
+                      "[test.cpp:6:1]: (error) suppression without error ID [invalidSuppression]\n"
+                      "[test.cpp:7:1]: (error) suppression without error ID [invalidSuppression]\n"
+                      "[test.cpp:10:1]: (error) suppression without error ID [invalidSuppression]\n"
+                      "[test.cpp:8:1]: (error) Suppress Begin: No matching end [invalidSuppression]\n", errout_str());
+
+        ASSERT_EQUALS(1, (this->*check)("// cppcheck-suppress:\n"
+                                        "// cppcheck-suppress-unknown\n"
+                                        "// cppcheck-suppress-begin-unknown\n"
+                                        "// cppcheck-suppress-begin\n"
+                                        "void f() {}\n"
+                                        "// cppcheck-suppress-end-unknown\n",
+                                        ""));
+        // TODO: actually these are all invalid types
+        ASSERT_EQUALS("[test.cpp:1:1]: (error) suppression without error ID [invalidSuppression]\n"
+                      "[test.cpp:2:1]: (error) suppression without error ID [invalidSuppression]\n"
+                      "[test.cpp:3:1]: (error) suppression without error ID [invalidSuppression]\n"
+                      "[test.cpp:4:1]: (error) suppression without error ID [invalidSuppression]\n"
+                      "[test.cpp:6:1]: (error) suppression without error ID [invalidSuppression]\n", errout_str());
+
+        ASSERT_EQUALS(1, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    // cppcheck-suppress-begin uninitvar\n"
+                                        "    a++;\n"
+                                        "    // cppcheck-suppress-end uninitvar\n"
+                                        "    int b;\n"
+                                        "    b++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("[test.cpp:7:5]: (error) Uninitialized variable: b [uninitvar]\n", errout_str());
+
+        ASSERT_EQUALS(1, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    // cppcheck-suppress-begin uninitvar\n"
+                                        "    a++;\n"
+                                        "    // cppcheck-suppress-end uninitvar\n"
+                                        "    int b;\n"
+                                        "    b++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("[test.cpp:7:5]: (error) Uninitialized variable: b [uninitvar]\n", errout_str());
+
+        ASSERT_EQUALS(1, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    // cppcheck-suppress-begin[uninitvar]\n"
+                                        "    a++;\n"
+                                        "    // cppcheck-suppress-end[uninitvar]\n"
+                                        "    int b;\n"
+                                        "    b++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("[test.cpp:7:5]: (error) Uninitialized variable: b [uninitvar]\n", errout_str());
+
+        ASSERT_EQUALS(1, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    // cppcheck-suppress-begin [uninitvar]\n"
+                                        "    a++;\n"
+                                        "    // cppcheck-suppress-end [uninitvar]\n"
+                                        "    int b;\n"
+                                        "    b++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("[test.cpp:7:5]: (error) Uninitialized variable: b [uninitvar]\n", errout_str());
+
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    // cppcheck-suppress-begin uninitvar\n"
+                                        "    a++;\n"
+                                        "    // cppcheck-suppress-end uninitvar\n"
+                                        "    int b;\n"
+                                        "    // cppcheck-suppress-begin uninitvar\n"
+                                        "    b++;\n"
+                                        "    // cppcheck-suppress-end uninitvar\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
+
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    // cppcheck-suppress-begin uninitvar\n"
+                                        "    a++;\n"
+                                        "    // cppcheck-suppress-end uninitvar\n"
+                                        "    // cppcheck-suppress-begin uninitvar\n"
+                                        "    int b;\n"
+                                        "    b++;\n"
+                                        "    // cppcheck-suppress-end uninitvar\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
+
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    // cppcheck-suppress-begin [uninitvar]\n"
+                                        "    int a;\n"
+                                        "    // cppcheck-suppress-begin uninitvar\n"
+                                        "    a++;\n"
+                                        "    // cppcheck-suppress-end uninitvar\n"
+                                        "    int b;\n"
+                                        "    // cppcheck-suppress-begin uninitvar\n"
+                                        "    b++;\n"
+                                        "    // cppcheck-suppress-end uninitvar\n"
+                                        "    // cppcheck-suppress-end [uninitvar]\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
+
+        ASSERT_EQUALS(1, (this->*check)("void f() {\n"
+                                        "    // cppcheck-suppress-begin [uninitvar, syntaxError]\n"
+                                        "    int a;\n"
+                                        "    // cppcheck-suppress-begin uninitvar\n"
+                                        "    a++;\n"
+                                        "    // cppcheck-suppress-end uninitvar\n"
+                                        "    int b;\n"
+                                        "    // cppcheck-suppress-begin uninitvar\n"
+                                        "    b++;\n"
+                                        "    // cppcheck-suppress-end uninitvar\n"
+                                        "    // cppcheck-suppress-end [uninitvar, syntaxError]\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("[test.cpp:2:0]: (information) Unmatched suppression: syntaxError [unmatchedSuppression]\n", errout_str());
+
+        ASSERT_EQUALS(1, (this->*check)("// cppcheck-suppress-begin [uninitvar, syntaxError]\n"
+                                        "void f() {\n"
+                                        "    int a;\n"
+                                        "    // cppcheck-suppress-begin uninitvar\n"
+                                        "    a++;\n"
+                                        "    // cppcheck-suppress-end uninitvar\n"
+                                        "    int b;\n"
+                                        "    // cppcheck-suppress-begin uninitvar\n"
+                                        "    b++;\n"
+                                        "    // cppcheck-suppress-end uninitvar\n"
+                                        "}\n"
+                                        "// cppcheck-suppress-end [uninitvar, syntaxError]\n",
+                                        ""));
+        ASSERT_EQUALS("[test.cpp:1:0]: (information) Unmatched suppression: syntaxError [unmatchedSuppression]\n", errout_str());
+
+        ASSERT_EQUALS(1, (this->*check)("// cppcheck-suppress-begin [uninitvar, syntaxError]\n"
+                                        "void f() {\n"
+                                        "    int a;\n"
+                                        "    // cppcheck-suppress-begin uninitvar\n"
+                                        "    a++;\n"
+                                        "    // cppcheck-suppress-end uninitvar\n"
+                                        "    int b;\n"
+                                        "    // cppcheck-suppress-begin uninitvar\n"
+                                        "    b++;\n"
+                                        "    // cppcheck-suppress-end uninitvar\n"
+                                        "}\n"
+                                        "// cppcheck-suppress-end [uninitvar, syntaxError]",
+                                        ""));
+        ASSERT_EQUALS("[test.cpp:1:0]: (information) Unmatched suppression: syntaxError [unmatchedSuppression]\n", errout_str());
+
+        // test of multiple suppression types
+        ASSERT_EQUALS(0, (this->*check)("// cppcheck-suppress-file uninitvar\n"
+                                        "void f() {\n"
+                                        "    int a;\n"
+                                        "    // cppcheck-suppress-begin uninitvar\n"
+                                        "    // cppcheck-suppress uninitvar\n"
+                                        "    a++;\n"
+                                        "    // cppcheck-suppress-end uninitvar\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
+
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    // cppcheck-suppress-begin uninitvar\n"
+                                        "    // cppcheck-suppress uninitvar\n"
+                                        "    a++;\n"
+                                        "    // cppcheck-suppress-end uninitvar\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
+
+        ASSERT_EQUALS(0, (this->*check)("// cppcheck-suppress-file uninitvar\n"
+                                        "void f() {\n"
+                                        "    int a;\n"
+                                        "    // cppcheck-suppress uninitvar\n"
+                                        "    a++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
+
+        ASSERT_EQUALS(0, (this->*check)("// cppcheck-suppress-file uninitvar\n"
+                                        "void f() {\n"
+                                        "    int a;\n"
+                                        "    // cppcheck-suppress-begin uninitvar\n"
+                                        "    a++;\n"
+                                        "    // cppcheck-suppress-end uninitvar\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
+
+        ASSERT_EQUALS(1, (this->*check)("// cppcheck-suppress-file uninitvar\n"
+                                        "void f() {\n"
+                                        "    // cppcheck-suppress uninitvar\n"
+                                        "    int a;\n"
+                                        "    a++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("[test.cpp:4:0]: (information) Unmatched suppression: uninitvar [unmatchedSuppression]\n", errout_str());
 
         // #5746 - exitcode
         ASSERT_EQUALS(1U,
@@ -371,20 +977,59 @@ class TestSuppressions : public TestFixture {
                                      "  int a; return a;\n"
                                      "}\n",
                                      ""));
+        ASSERT_EQUALS("[test.cpp:2:17]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
+
         ASSERT_EQUALS(0U,
                       (this->*check)("int f() {\n"
                                      "  int a; return a;\n"
                                      "}\n",
                                      "uninitvar"));
+        ASSERT_EQUALS("", errout_str());
+
+        // TODO: check result
+        (this->*check)("// cppcheck-suppress-macro zerodiv\n"
+                       "#define DIV(A,B) A/B\n"
+                       "a = DIV(10,0);\n",
+                       "");
+        ASSERT_EQUALS("", errout_str());
+
+        // TODO: check result
+        (this->*check)("// cppcheck-suppress-macro abc\n"
+                       "#define DIV(A,B) A/B\n"
+                       "a = DIV(10,1);\n",
+                       "");
+        ASSERT_EQUALS("[test.cpp:2:0]: (information) Unmatched suppression: abc [unmatchedSuppression]\n", errout_str());
+    }
+
+    void suppressionsSettingsFiles() {
+        runChecks(&TestSuppressions::checkSuppressionFiles);
+    }
+
+    void suppressionsSettingsFS() {
+        runChecks(&TestSuppressions::checkSuppressionFS);
+    }
+
+#ifdef HAS_THREADING_MODEL_THREAD
+    void suppressionsSettingsThreadsFiles() {
+        runChecks(&TestSuppressions::checkSuppressionThreadsFiles);
+    }
+
+    void suppressionsSettingsThreadsFS() {
+        runChecks(&TestSuppressions::checkSuppressionThreadsFS);
     }
+#endif // HAS_THREADING_MODEL_THREAD
 
-    void suppressionsSettings() {
-        runChecks(&TestSuppressions::checkSuppression);
-        if (ThreadExecutor::isEnabled())
-            runChecks(&TestSuppressions::checkSuppressionThreads);
+#ifdef HAS_THREADING_MODEL_FORK
+    void suppressionsSettingsProcessesFiles() {
+        runChecks(&TestSuppressions::checkSuppressionProcessesFiles);
     }
 
-    void suppressionsMultiFile() {
+    void suppressionsSettingsProcessesFS() {
+        runChecks(&TestSuppressions::checkSuppressionProcessesFS);
+    }
+#endif // HAS_THREADING_MODEL_FORK
+
+    void suppressionsMultiFileInternal(unsigned int (TestSuppressions::*check)(std::map<std::string, std::string> &f, const std::string &)) {
         std::map<std::string, std::string> files;
         files["abc.cpp"] = "void f() {\n"
                            "}\n";
@@ -394,72 +1039,156 @@ class TestSuppressions : public TestFixture {
                            "}\n";
 
         // suppress uninitvar for this file and line
-        checkSuppression(files, "uninitvar:xyz.cpp:3");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(0, (this->*check)(files, "uninitvar:xyz.cpp:3"));
+        ASSERT_EQUALS("", errout_str());
     }
 
+    void suppressionsMultiFileFiles() {
+        suppressionsMultiFileInternal(&TestSuppressions::checkSuppressionFiles);
+    }
+
+    void suppressionsMultiFileFS() {
+        suppressionsMultiFileInternal(&TestSuppressions::checkSuppressionFS);
+    }
+
+    // TODO: this tests an internal function - should it be private?
     void suppressionsPathSeparator() const {
-        const Suppressions::Suppression s1("*", "test/foo/*");
-        ASSERT_EQUALS(true, s1.isSuppressed(errorMessage("someid", "test/foo/bar.cpp", 142)));
+        const SuppressionList::Suppression s1("*", "test/foo/*");
+        ASSERT_EQUALS_ENUM(SuppressionList::Suppression::Result::Matched, s1.isSuppressed(errorMessage("someid", "test/foo/bar.cpp", 142)));
 
-        const Suppressions::Suppression s2("abc", "include/1.h");
-        ASSERT_EQUALS(true, s2.isSuppressed(errorMessage("abc", "include/1.h", 142)));
+        const SuppressionList::Suppression s2("abc", "include/1.h");
+        ASSERT_EQUALS_ENUM(SuppressionList::Suppression::Result::Matched, s2.isSuppressed(errorMessage("abc", "include/1.h", 142)));
     }
 
-    void suppressionsLine0() {
-        Suppressions suppressions;
-        suppressions.addSuppressionLine("syntaxError:*:0");
+    void suppressionsLine0() const {
+        SuppressionList suppressions;
+        ASSERT_EQUALS("", suppressions.addSuppressionLine("syntaxError:*:0"));
         ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("syntaxError", "test.cpp", 0)));
     }
 
-    void suppressionsFileComment() {
-        std::istringstream file1("# comment\nabc");
-        Suppressions suppressions1;
-        suppressions1.parseFile(file1);
+    void suppressionsFileComment() const {
+        std::istringstream file1("# comment\n"
+                                 "abc");
+        SuppressionList suppressions1;
+        ASSERT_EQUALS("", suppressions1.parseFile(file1));
         ASSERT_EQUALS(true, suppressions1.isSuppressed(errorMessage("abc", "test.cpp", 123)));
 
-        std::istringstream file2("// comment\nabc");
-        Suppressions suppressions2;
-        suppressions2.parseFile(file2);
+        std::istringstream file2("// comment\n"
+                                 "abc");
+        SuppressionList suppressions2;
+        ASSERT_EQUALS("", suppressions2.parseFile(file2));
         ASSERT_EQUALS(true, suppressions2.isSuppressed(errorMessage("abc", "test.cpp", 123)));
+
+        std::istringstream file3("abc // comment");
+        SuppressionList suppressions3;
+        ASSERT_EQUALS("", suppressions3.parseFile(file3));
+        ASSERT_EQUALS(true, suppressions3.isSuppressed(errorMessage("abc", "test.cpp", 123)));
+
+        std::istringstream file4("abc\t\t # comment");
+        SuppressionList suppressions4;
+        ASSERT_EQUALS("", suppressions4.parseFile(file4));
+        ASSERT_EQUALS(true, suppressions4.isSuppressed(errorMessage("abc", "test.cpp", 123)));
+
+        std::istringstream file5("abc:test.cpp\t\t # comment");
+        SuppressionList suppressions5;
+        ASSERT_EQUALS("", suppressions5.parseFile(file5));
+        ASSERT_EQUALS(true, suppressions5.isSuppressed(errorMessage("abc", "test.cpp", 123)));
+
+        std::istringstream file6("abc:test.cpp:123\t\t # comment with . inside");
+        SuppressionList suppressions6;
+        ASSERT_EQUALS("", suppressions6.parseFile(file6));
+        ASSERT_EQUALS(true, suppressions6.isSuppressed(errorMessage("abc", "test.cpp", 123)));
+
+        std::istringstream file7(" // comment\n" // #11450
+                                 "abc");
+        SuppressionList suppressions7;
+        ASSERT_EQUALS("", suppressions7.parseFile(file7));
+        ASSERT_EQUALS(true, suppressions7.isSuppressed(errorMessage("abc", "test.cpp", 123)));
     }
 
-    void inlinesuppress() {
-        Suppressions::Suppression s;
+    void inlinesuppress() const {
+        SuppressionList::Suppression s;
         std::string msg;
+
+        // Suppress without attribute
         ASSERT_EQUALS(false, s.parseComment("/* some text */", &msg));
         ASSERT_EQUALS(false, s.parseComment("/* cppcheck-suppress */", &msg));
+        ASSERT_EQUALS(false, s.parseComment("/* cppcheck-suppress-file  */", &msg));
+        ASSERT_EQUALS(false, s.parseComment("/* cppcheck-suppress-begin */", &msg));
+        ASSERT_EQUALS(false, s.parseComment("/* cppcheck-suppress-end */", &msg));
 
+        // Correct suppress
         msg.clear();
         ASSERT_EQUALS(true, s.parseComment("/* cppcheck-suppress id */", &msg));
         ASSERT_EQUALS("", msg);
+        ASSERT_EQUALS("", s.extraComment);
+
+        msg.clear();
+        ASSERT_EQUALS(true, s.parseComment("/* cppcheck-suppress id ; extra */", &msg));
+        ASSERT_EQUALS("", msg);
+        ASSERT_EQUALS("extra", s.extraComment);
+
+        msg.clear();
+        ASSERT_EQUALS(true, s.parseComment("/* cppcheck-suppress id // extra */", &msg));
+        ASSERT_EQUALS("", msg);
+        ASSERT_EQUALS("extra", s.extraComment);
+
+        msg.clear();
+        ASSERT_EQUALS(true, s.parseComment("/* cppcheck-suppress-file id */", &msg));
+        ASSERT_EQUALS("", msg);
+
+        msg.clear();
+        ASSERT_EQUALS(true, s.parseComment("/* cppcheck-suppress-begin id */", &msg));
+        ASSERT_EQUALS("", msg);
+
+        msg.clear();
+        ASSERT_EQUALS(true, s.parseComment("/* cppcheck-suppress-end id */", &msg));
+        ASSERT_EQUALS("", msg);
+
+        // Bad cppcheck-suppress comment
+        ASSERT_EQUALS(false, s.parseComment("/* cppcheck-suppress-beggin id */", &msg));
+
+        // Bad attribute construction
+        const std::string badSuppressionAttribute = "Bad suppression attribute 'some'. You can write comments in the comment after a ; or //. Valid suppression attributes; symbolName=sym";
 
         ASSERT_EQUALS(true, s.parseComment("/* cppcheck-suppress id some text */", &msg));
-        ASSERT_EQUALS("Bad suppression attribute 'some'. You can write comments in the comment after a ; or //. Valid suppression attributes; symbolName=sym", msg);
+        ASSERT_EQUALS(badSuppressionAttribute, msg);
+        ASSERT_EQUALS(true, s.parseComment("/* cppcheck-suppress-file id some text */", &msg));
+        ASSERT_EQUALS(badSuppressionAttribute, msg);
+        ASSERT_EQUALS(true, s.parseComment("/* cppcheck-suppress-begin id some text */", &msg));
+        ASSERT_EQUALS(badSuppressionAttribute, msg);
+        ASSERT_EQUALS(true, s.parseComment("/* cppcheck-suppress-end id some text */", &msg));
+        ASSERT_EQUALS(badSuppressionAttribute, msg);
     }
 
-    void inlinesuppress_symbolname() {
-        Suppressions suppressions;
+    void inlinesuppress_symbolname_Internal(unsigned int (TestSuppressions::*check)(const char[], const std::string &)) {
+        ASSERT_EQUALS(0, (this->*check)("void f() {\n"
+                                        "    int a;\n"
+                                        "    /* cppcheck-suppress uninitvar symbolName=a */\n"
+                                        "    a++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("", errout_str());
+
+        ASSERT_EQUALS(1, (this->*check)("void f() {\n"
+                                        "    int a,b;\n"
+                                        "    /* cppcheck-suppress uninitvar symbolName=b */\n"
+                                        "    a++; b++;\n"
+                                        "}\n",
+                                        ""));
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
+    }
 
-        checkSuppression("void f() {\n"
-                         "    int a;\n"
-                         "    /* cppcheck-suppress uninitvar symbolName=a */\n"
-                         "    a++;\n"
-                         "}\n",
-                         "");
-        ASSERT_EQUALS("", errout.str());
+    void inlinesuppress_symbolname_Files() {
+        inlinesuppress_symbolname_Internal(&TestSuppressions::checkSuppressionFiles);
+    }
 
-        checkSuppression("void f() {\n"
-                         "    int a,b;\n"
-                         "    /* cppcheck-suppress uninitvar symbolName=b */\n"
-                         "    a++; b++;\n"
-                         "}\n",
-                         "");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: a\n", errout.str());
+    void inlinesuppress_symbolname_FS() {
+        inlinesuppress_symbolname_Internal(&TestSuppressions::checkSuppressionFS);
     }
 
-    void inlinesuppress_comment() {
-        Suppressions::Suppression s;
+    void inlinesuppress_comment() const {
+        SuppressionList::Suppression s;
         std::string errMsg;
         ASSERT_EQUALS(true, s.parseComment("// cppcheck-suppress abc ; some comment", &errMsg));
         ASSERT_EQUALS("", errMsg);
@@ -469,47 +1198,189 @@ class TestSuppressions : public TestFixture {
         ASSERT_EQUALS("", errMsg);
     }
 
+    // TODO: tests internal function - should it be private?
+    void inlinesuppress_unchecked() const {
+        SuppressionList::Suppression s;
+        std::string errMsg;
+        ASSERT_EQUALS(true, s.parseComment("// cppcheck-suppress abc", &errMsg));
+        ASSERT_EQUALS("", errMsg);
+        s.lineNumber = 5;
+
+        ASSERT_EQUALS_ENUM(SuppressionList::Suppression::Result::None, s.isSuppressed(errorMessage("id", "test.cpp", 11)));
+        ASSERT_EQUALS_ENUM(SuppressionList::Suppression::Result::Checked, s.isSuppressed(errorMessage("id", "test.cpp", 5)));
+        ASSERT_EQUALS_ENUM(SuppressionList::Suppression::Result::Matched, s.isSuppressed(errorMessage("abc", "test.cpp", 5)));
+    }
+
+    void multi_inlinesuppress() const {
+        std::vector<SuppressionList::Suppression> suppressions;
+        std::string errMsg;
+
+        errMsg = "";
+        suppressions=SuppressionList::parseMultiSuppressComment("// cppcheck-suppress[errorId]", &errMsg);
+        ASSERT_EQUALS(1, suppressions.size());
+        ASSERT_EQUALS("errorId", suppressions[0].errorId);
+        ASSERT_EQUALS("", suppressions[0].symbolName);
+        ASSERT_EQUALS("", errMsg);
+
+        errMsg = "";
+        suppressions=SuppressionList::parseMultiSuppressComment("// cppcheck-suppress-begin[errorId]", &errMsg);
+        ASSERT_EQUALS(1, suppressions.size());
+        ASSERT_EQUALS("errorId", suppressions[0].errorId);
+        ASSERT_EQUALS("", suppressions[0].symbolName);
+        ASSERT_EQUALS("", errMsg);
+
+        errMsg = "";
+        suppressions=SuppressionList::parseMultiSuppressComment("// cppcheck-suppress-begin [errorId]", &errMsg);
+        ASSERT_EQUALS(1, suppressions.size());
+        ASSERT_EQUALS("errorId", suppressions[0].errorId);
+        ASSERT_EQUALS("", suppressions[0].symbolName);
+        ASSERT_EQUALS("", errMsg);
+
+        errMsg = "";
+        suppressions=SuppressionList::parseMultiSuppressComment("// cppcheck-suppress-end[errorId]", &errMsg);
+        ASSERT_EQUALS(1, suppressions.size());
+        ASSERT_EQUALS("errorId", suppressions[0].errorId);
+        ASSERT_EQUALS("", suppressions[0].symbolName);
+        ASSERT_EQUALS("", errMsg);
+
+        errMsg = "";
+        suppressions=SuppressionList::parseMultiSuppressComment("// cppcheck-suppress-end [errorId]", &errMsg);
+        ASSERT_EQUALS(1, suppressions.size());
+        ASSERT_EQUALS("errorId", suppressions[0].errorId);
+        ASSERT_EQUALS("", suppressions[0].symbolName);
+        ASSERT_EQUALS("", errMsg);
+
+        errMsg = "";
+        suppressions=SuppressionList::parseMultiSuppressComment("// cppcheck-suppress-file[errorId]", &errMsg);
+        ASSERT_EQUALS(1, suppressions.size());
+        ASSERT_EQUALS("errorId", suppressions[0].errorId);
+        ASSERT_EQUALS("", suppressions[0].symbolName);
+        ASSERT_EQUALS("", errMsg);
+
+        errMsg = "";
+        suppressions=SuppressionList::parseMultiSuppressComment("// cppcheck-suppress-file [errorId]", &errMsg);
+        ASSERT_EQUALS(1, suppressions.size());
+        ASSERT_EQUALS("errorId", suppressions[0].errorId);
+        ASSERT_EQUALS("", suppressions[0].symbolName);
+        ASSERT_EQUALS("", errMsg);
+
+        errMsg = "";
+        suppressions=SuppressionList::parseMultiSuppressComment("// cppcheck-suppress[errorId symbolName=arr]", &errMsg);
+        ASSERT_EQUALS(1, suppressions.size());
+        ASSERT_EQUALS("errorId", suppressions[0].errorId);
+        ASSERT_EQUALS("arr", suppressions[0].symbolName);
+        ASSERT_EQUALS("", errMsg);
+
+        errMsg = "";
+        suppressions=SuppressionList::parseMultiSuppressComment("// cppcheck-suppress[errorId symbolName=]", &errMsg);
+        ASSERT_EQUALS(1, suppressions.size());
+        ASSERT_EQUALS("errorId", suppressions[0].errorId);
+        ASSERT_EQUALS("", suppressions[0].symbolName);
+        ASSERT_EQUALS("", errMsg);
+
+        errMsg = "";
+        suppressions=SuppressionList::parseMultiSuppressComment("// cppcheck-suppress[errorId1, errorId2 symbolName=arr]", &errMsg);
+        ASSERT_EQUALS(2, suppressions.size());
+        ASSERT_EQUALS("errorId1", suppressions[0].errorId);
+        ASSERT_EQUALS("", suppressions[0].symbolName);
+        ASSERT_EQUALS("errorId2", suppressions[1].errorId);
+        ASSERT_EQUALS("arr", suppressions[1].symbolName);
+        ASSERT_EQUALS("", errMsg);
+
+        errMsg = "";
+        suppressions=SuppressionList::parseMultiSuppressComment("// cppcheck-suppress[]", &errMsg);
+        ASSERT_EQUALS(0, suppressions.size());
+        ASSERT_EQUALS(true, errMsg.empty());
+
+        errMsg = "";
+        suppressions=SuppressionList::parseMultiSuppressComment("// cppcheck-suppress[errorId", &errMsg);
+        ASSERT_EQUALS(0, suppressions.size());
+        ASSERT_EQUALS(false, errMsg.empty());
+
+        errMsg = "";
+        suppressions=SuppressionList::parseMultiSuppressComment("// cppcheck-suppress errorId", &errMsg);
+        ASSERT_EQUALS(0, suppressions.size());
+        ASSERT_EQUALS(false, errMsg.empty());
+
+        errMsg = "";
+        suppressions=SuppressionList::parseMultiSuppressComment("// cppcheck-suppress[errorId1 errorId2 symbolName=arr]", &errMsg);
+        ASSERT_EQUALS(0, suppressions.size());
+        ASSERT_EQUALS(false, errMsg.empty());
+
+        errMsg = "";
+        suppressions=SuppressionList::parseMultiSuppressComment("// cppcheck-suppress[errorId1, errorId2 symbol=arr]", &errMsg);
+        ASSERT_EQUALS(0, suppressions.size());
+        ASSERT_EQUALS(false, errMsg.empty());
+
+        errMsg = "";
+        suppressions=SuppressionList::parseMultiSuppressComment("// cppcheck-suppress[errorId1, errorId2 symbolName]", &errMsg);
+        ASSERT_EQUALS(0, suppressions.size());
+        ASSERT_EQUALS(false, errMsg.empty());
+    }
+
+    void multi_inlinesuppress_comment() const {
+        std::vector<SuppressionList::Suppression> suppressions;
+        std::string errMsg;
+
+        errMsg = "";
+        suppressions=SuppressionList::parseMultiSuppressComment("//cppcheck-suppress[errorId1, errorId2 symbolName=arr]", &errMsg);
+        ASSERT_EQUALS(2, suppressions.size());
+        ASSERT_EQUALS(true, errMsg.empty());
+
+        errMsg = "";
+        suppressions=SuppressionList::parseMultiSuppressComment("//cppcheck-suppress[errorId1, errorId2 symbolName=arr] some text", &errMsg);
+        ASSERT_EQUALS(2, suppressions.size());
+        ASSERT_EQUALS(true, errMsg.empty());
+
+        errMsg = "";
+        suppressions=SuppressionList::parseMultiSuppressComment("/*cppcheck-suppress[errorId1, errorId2 symbolName=arr]*/", &errMsg);
+        ASSERT_EQUALS(2, suppressions.size());
+        ASSERT_EQUALS(true, errMsg.empty());
+    }
+
     void globalSuppressions() { // Testing that Cppcheck::useGlobalSuppressions works (#8515)
-        errout.str("");
+        const auto settings = dinit(Settings,
+                                    $.quiet = true,
+                                        $.exitCode = 1,
+                                        $.templateFormat = templateFormat);
+
+        Suppressions supprs;
+        ASSERT_EQUALS("", supprs.nomsg.addSuppressionLine("uninitvar"));
 
-        CppCheck cppCheck(*this, false); // <- do not "use global suppressions". pretend this is a thread that just checks a file.
-        Settings& settings = cppCheck.settings();
-        settings.nomsg.addSuppressionLine("uninitvar");
-        settings.exitCode = 1;
+        CppCheck cppCheck(settings, supprs, *this, nullptr, false, nullptr); // <- do not "use global suppressions". pretend this is a thread that just checks a file.
 
         const char code[] = "int f() { int a; return a; }";
-        ASSERT_EQUALS(0, cppCheck.check("test.c", code)); // <- no unsuppressed error is seen
-        ASSERT_EQUALS("[test.c:1]: (error) Uninitialized variable: a\n", errout.str()); // <- report error so ThreadExecutor can suppress it and make sure the global suppression is matched.
+        ASSERT_EQUALS(0, cppCheck.checkBuffer(FileWithDetails("test.c", Standards::Language::C, 0),code, sizeof(code))); // <- no unsuppressed error is seen
+        ASSERT_EQUALS("[test.c:1:25]: (error) Uninitialized variable: a [uninitvar]\n", errout_str()); // <- report error so ThreadExecutor can suppress it and make sure the global suppression is matched.
     }
 
     void inlinesuppress_unusedFunction() const { // #4210, #4946 - wrong report of "unmatchedSuppression" for "unusedFunction"
-        Suppressions suppressions;
-        suppressions.addSuppression(Suppressions::Suppression("unusedFunction", "test.c", 3));
-        ASSERT_EQUALS(true, !suppressions.getUnmatchedLocalSuppressions("test.c", true).empty());
-        ASSERT_EQUALS(false, !suppressions.getUnmatchedGlobalSuppressions(true).empty());
-        ASSERT_EQUALS(false, !suppressions.getUnmatchedLocalSuppressions("test.c", false).empty());
-        ASSERT_EQUALS(false, !suppressions.getUnmatchedGlobalSuppressions(false).empty());
+        SuppressionList suppressions;
+        SuppressionList::Suppression suppression("unusedFunction", "test.c", 3);
+        suppression.checked = true; // have to do this because fixes for #5704
+        ASSERT_EQUALS("", suppressions.addSuppression(std::move(suppression)));
+        ASSERT_EQUALS(true, !suppressions.getUnmatchedLocalSuppressions(FileWithDetails("test.c", Standards::Language::C, 0)).empty());
+        ASSERT_EQUALS(false, !suppressions.getUnmatchedGlobalSuppressions().empty());
     }
 
     void globalsuppress_unusedFunction() const { // #4946 - wrong report of "unmatchedSuppression" for "unusedFunction"
-        Suppressions suppressions;
-        suppressions.addSuppressionLine("unusedFunction:*");
-        ASSERT_EQUALS(false, !suppressions.getUnmatchedLocalSuppressions("test.c", true).empty());
-        ASSERT_EQUALS(true, !suppressions.getUnmatchedGlobalSuppressions(true).empty());
-        ASSERT_EQUALS(false, !suppressions.getUnmatchedLocalSuppressions("test.c", false).empty());
-        ASSERT_EQUALS(false, !suppressions.getUnmatchedGlobalSuppressions(false).empty());
+        SuppressionList suppressions;
+        ASSERT_EQUALS("", suppressions.addSuppressionLine("unusedFunction:*"));
+        ASSERT_EQUALS(false, suppressions.isSuppressed(errorMessage("errorid")));
+        ASSERT_EQUALS(false, !suppressions.getUnmatchedLocalSuppressions(FileWithDetails("test.c", Standards::Language::C, 0)).empty());
+        ASSERT_EQUALS(true, !suppressions.getUnmatchedGlobalSuppressions().empty());
     }
 
     void suppressionWithRelativePaths() {
-        // Clear the error log
-        errout.str("");
+        Suppressions supprs;
 
-        CppCheck cppCheck(*this, true);
-        Settings& settings = cppCheck.settings();
-        settings.addEnabled("style");
+        Settings settings;
+        settings.quiet = true;
+        settings.severity.enable(Severity::style);
         settings.inlineSuppressions = true;
         settings.relativePaths = true;
         settings.basePaths.emplace_back("/somewhere");
+        settings.templateFormat = templateFormat;
         const char code[] =
             "struct Point\n"
             "{\n"
@@ -518,37 +1389,51 @@ class TestSuppressions : public TestFixture {
             "    // cppcheck-suppress unusedStructMember\n"
             "    int y;\n"
             "};";
-        cppCheck.check("/somewhere/test.cpp", code);
-        ASSERT_EQUALS("",errout.str());
+        CppCheck cppCheck(settings, supprs, *this, nullptr, true, nullptr);
+        ASSERT_EQUALS(0, cppCheck.checkBuffer(FileWithDetails("/somewhere/test.cpp", Standards::Language::CPP, 0), code, sizeof(code)));
+        ASSERT_EQUALS("",errout_str());
     }
 
-    void suppressingSyntaxErrors() { // syntaxErrors should be suppressible (#7076)
-        std::map<std::string, std::string> files;
-        files["test.cpp"] = "if if\n";
+    void suppressingSyntaxErrorsInternal(unsigned int (TestSuppressions::*check)(const char[], const std::string &)) { // syntaxErrors should be suppressible (#7076)
+        const char code[] = "if if\n";
 
-        checkSuppression(files, "syntaxError:test.cpp:1");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(0, (this->*check)(code, "syntaxError:test.cpp:1"));
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void suppressingSyntaxErrorsInline() { // syntaxErrors should be suppressible (#5917)
-        std::map<std::string, std::string> files;
-        files["test.cpp"] = "double result(0.0);\n"
+    void suppressingSyntaxErrorsFiles() {
+        suppressingSyntaxErrorsInternal(&TestSuppressions::checkSuppressionFiles);
+    }
+
+    void suppressingSyntaxErrorsFS() {
+        suppressingSyntaxErrorsInternal(&TestSuppressions::checkSuppressionFiles);
+    }
+
+    void suppressingSyntaxErrorsInlineInternal(unsigned int (TestSuppressions::*check)(const char[], const std::string &)) { // syntaxErrors should be suppressible (#5917)
+        const char code[] = "double result(0.0);\n"
                             "_asm\n"
                             "{\n"
                             "   // cppcheck-suppress syntaxError\n"
-                            "   push  EAX               ; save EAX for callers \n"
+                            "   push  EAX               ; save EAX for callers\n"
                             "   mov   EAX,Real10        ; get the address pointed to by Real10\n"
                             "   fld   TBYTE PTR [EAX]   ; load an extended real (10 bytes)\n"
                             "   fstp  QWORD PTR result  ; store a double (8 bytes)\n"
                             "   pop   EAX               ; restore EAX\n"
                             "}";
-        checkSuppression(files, "");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(0, (this->*check)(code, ""));
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void suppressingSyntaxErrorsWhileFileRead() { // syntaxError while file read should be suppressible (PR #1333)
-        std::map<std::string, std::string> files;
-        files["test.cpp"] = "CONST (genType, KS_CONST) genService[KS_CFG_NR_OF_NVM_BLOCKS] =\n"
+    void suppressingSyntaxErrorsInlineFiles() {
+        suppressingSyntaxErrorsInlineInternal(&TestSuppressions::checkSuppressionFiles);
+    }
+
+    void suppressingSyntaxErrorsInlineFS() {
+        suppressingSyntaxErrorsInlineInternal(&TestSuppressions::checkSuppressionFS);
+    }
+
+    void suppressingSimplecppErrorsWhileFileReadInternal(unsigned int (TestSuppressions::*check)(const char[], const std::string &)) { // syntaxError while file read should be suppressible (PR #1333)
+        const char code[] = "CONST (genType, KS_CONST) genService[KS_CFG_NR_OF_NVM_BLOCKS] =\n"
                             "{\n"
                             "[!VAR \"BC\" = \"$BC + 1\"!][!//\n"
                             "[!IF \"(as:modconf('Ks')[1]/KsGeneral/KsType = 'KS_CFG_TYPE_KS_MASTER') and\n"
@@ -561,83 +1446,748 @@ class TestSuppressions : public TestFixture {
                             "[!VAR \"BC\" = \"$BC + 1\"!][!//\n"
                             "[!ENDIF!][!//\n"
                             "};";
-        checkSuppression(files, "syntaxError:test.cpp:4");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(0, (this->*check)(code, "syntaxError:test.cpp:4"));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void suppressingSimplecppErrorsWhileFileReadFiles() {
+        suppressingSimplecppErrorsWhileFileReadInternal(&TestSuppressions::checkSuppressionFiles);
     }
 
-    void symbol() {
-        Suppressions::Suppression s;
+    void suppressingSimplecppErrorsWhileFileReadFS() {
+        suppressingSimplecppErrorsWhileFileReadInternal(&TestSuppressions::checkSuppressionFiles);
+    }
+
+    // TODO: this tests an internal function - should it be private?
+    void symbol() const {
+        SuppressionList::Suppression s;
+        s.fileName = "test.cpp";
         s.errorId = "foo";
         s.symbolName = "array*";
 
-        Suppressions::ErrorMessage errorMsg;
+        SuppressionList::ErrorMessage errorMsg;
         errorMsg.errorId = "foo";
+        errorMsg.symbolNames = "";
+        ASSERT_EQUALS_ENUM(SuppressionList::Suppression::Result::None, s.isSuppressed(errorMsg));
         errorMsg.setFileName("test.cpp");
         errorMsg.lineNumber = 123;
-        errorMsg.symbolNames = "";
-        ASSERT_EQUALS(false, s.isSuppressed(errorMsg));
+        ASSERT_EQUALS_ENUM(SuppressionList::Suppression::Result::Checked, s.isSuppressed(errorMsg));
         errorMsg.symbolNames = "x\n";
-        ASSERT_EQUALS(false, s.isSuppressed(errorMsg));
+        ASSERT_EQUALS_ENUM(SuppressionList::Suppression::Result::Checked, s.isSuppressed(errorMsg));
         errorMsg.symbolNames = "array1\n";
-        ASSERT_EQUALS(true, s.isSuppressed(errorMsg));
-        errorMsg.symbolNames = "x\narray2\n";
-        ASSERT_EQUALS(true, s.isSuppressed(errorMsg));
-        errorMsg.symbolNames = "array3\nx\n";
-        ASSERT_EQUALS(true, s.isSuppressed(errorMsg));
+        ASSERT_EQUALS_ENUM(SuppressionList::Suppression::Result::Matched, s.isSuppressed(errorMsg));
+        errorMsg.symbolNames = "x\n"
+                               "array2\n";
+        ASSERT_EQUALS_ENUM(SuppressionList::Suppression::Result::Matched, s.isSuppressed(errorMsg));
+        errorMsg.symbolNames = "array3\n"
+                               "x\n";
+        ASSERT_EQUALS_ENUM(SuppressionList::Suppression::Result::Matched, s.isSuppressed(errorMsg));
     }
 
-    void unusedFunction() {
-        ASSERT_EQUALS(0, checkSuppression("void f() {}", "unusedFunction"));
+    void unusedFunctionInternal(unsigned int (TestSuppressions::*check)(const char[], const std::string &)) {
+        ASSERT_EQUALS(0, (this->*check)("void f() {}", "unusedFunction"));
     }
 
-    void matchglob() {
-        ASSERT_EQUALS(true, Suppressions::matchglob("*", "xyz"));
-        ASSERT_EQUALS(true, Suppressions::matchglob("x*", "xyz"));
-        ASSERT_EQUALS(true, Suppressions::matchglob("*z", "xyz"));
-        ASSERT_EQUALS(true, Suppressions::matchglob("*y*", "xyz"));
-        ASSERT_EQUALS(true, Suppressions::matchglob("*y*", "yz"));
-        ASSERT_EQUALS(false, Suppressions::matchglob("*y*", "abc"));
-        ASSERT_EQUALS(true, Suppressions::matchglob("*", "x/y/z"));
-        ASSERT_EQUALS(true, Suppressions::matchglob("*/y/z", "x/y/z"));
+    void unusedFunctionFiles() {
+        unusedFunctionInternal(&TestSuppressions::checkSuppressionFiles);
+    }
 
-        ASSERT_EQUALS(false, Suppressions::matchglob("?", "xyz"));
-        ASSERT_EQUALS(false, Suppressions::matchglob("x?", "xyz"));
-        ASSERT_EQUALS(false, Suppressions::matchglob("?z", "xyz"));
-        ASSERT_EQUALS(true, Suppressions::matchglob("?y?", "xyz"));
-        ASSERT_EQUALS(true, Suppressions::matchglob("?/?/?", "x/y/z"));
+    void unusedFunctionFS() {
+        unusedFunctionInternal(&TestSuppressions::checkSuppressionFS);
     }
 
-    void suppressingSyntaxErrorAndExitCode() {
-        std::map<std::string, std::string> files;
-        files["test.cpp"] = "fi if;";
+    void suppressingSyntaxErrorAndExitCodeInternal(unsigned int (TestSuppressions::*check)(const char[], const std::string &)) {
+        const char code[] = "fi if;";
 
-        ASSERT_EQUALS(0, checkSuppression(files, "*:test.cpp"));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(0, (this->*check)(code, "*:test.cpp"));
+        ASSERT_EQUALS("", errout_str());
+
+        // TODO: this test never worked
+        // multi error in file, but only suppression one error
+        //const char code2[] = "fi fi\n"
+        //                     "if if;";
+        //ASSERT_EQUALS(1, (this->*check)(code2, "*:test.cpp:1"));  // suppress all error at line 1 of test.cpp
+        //ASSERT_EQUALS("[test.cpp:2]: (error) syntax error\n", errout_str());
 
+        // multi error in file, but only suppression one error (2)
+        const char code3[] = "void f(int x, int y){\n"
+                             "    int a = x/0;\n"
+                             "    int b = y/0;\n"
+                             "}\n"
+                             "f(0, 1);\n";
+        ASSERT_EQUALS(1, (this->*check)(code3, "zerodiv:test.cpp:3"));  // suppress 'zerodiv' at line 3 of test.cpp
+        ASSERT_EQUALS("[test.cpp:2:14]: (error) Division by zero. [zerodiv]\n", errout_str());
+    }
+
+    void suppressingSyntaxErrorAndExitCodeFiles() {
+        suppressingSyntaxErrorAndExitCodeInternal(&TestSuppressions::checkSuppressionFiles);
+    }
+
+    void suppressingSyntaxErrorAndExitCodeFS() {
+        suppressingSyntaxErrorAndExitCodeInternal(&TestSuppressions::checkSuppressionFS);
+    }
+
+    void suppressingSyntaxErrorAndExitCodeMultiFileInternal(unsigned int (TestSuppressions::*check)(std::map<std::string, std::string> &f, const std::string &)) {
         // multi files, but only suppression one
         std::map<std::string, std::string> mfiles;
         mfiles["test.cpp"] = "fi if;";
         mfiles["test2.cpp"] = "fi if";
-        ASSERT_EQUALS(1, checkSuppression(mfiles, "*:test.cpp"));
-        ASSERT_EQUALS("[test2.cpp:1]: (error) syntax error\n", errout.str());
+        ASSERT_EQUALS(1, (this->*check)(mfiles, "*:test.cpp"));
+        ASSERT_EQUALS("[test2.cpp:1:4]: (error) syntax error [syntaxError]\n", errout_str());
+    }
 
-        // multi error in file, but only suppression one error
-        std::map<std::string, std::string> file2;
-        file2["test.cpp"] = "fi fi\n"
-                            "if if;";
-        ASSERT_EQUALS(1, checkSuppression(file2, "*:test.cpp:1"));  // suppress all error at line 1 of test.cpp
-        ASSERT_EQUALS("[test.cpp:2]: (error) syntax error\n", errout.str());
+    void suppressingSyntaxErrorAndExitCodeMultiFileFiles() {
+        suppressingSyntaxErrorAndExitCodeMultiFileInternal(&TestSuppressions::checkSuppressionFiles);
+    }
 
-        // multi error in file, but only suppression one error (2)
-        std::map<std::string, std::string> file3;
-        file3["test.cpp"] = "void f(int x, int y){\n"
-                            "    int a = x/0;\n"
-                            "    int b = y/0;\n"
-                            "}\n"
-                            "f(0, 1);\n";
-        ASSERT_EQUALS(1, checkSuppression(file3, "zerodiv:test.cpp:3"));  // suppress 'errordiv' at line 3 of test.cpp
+    void suppressingSyntaxErrorAndExitCodeMultiFileFS() {
+        suppressingSyntaxErrorAndExitCodeMultiFileInternal(&TestSuppressions::checkSuppressionFS);
+    }
+
+    void suppressLocal() const {
+        SuppressionList suppressions;
+        std::istringstream s("errorid:test.cpp\n"
+                             "errorid2");
+        ASSERT_EQUALS("", suppressions.parseFile(s));
+        ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("errorid", "test.cpp", 1)));
+        ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("errorid", "test.cpp", 1), false));
+        ASSERT_EQUALS(false, suppressions.isSuppressed(errorMessage("errorid", "test2.cpp", 1)));
+        ASSERT_EQUALS(false, suppressions.isSuppressed(errorMessage("errorid", "test2.cpp", 1), false));
+        ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("errorid2", "test.cpp", 1)));
+        ASSERT_EQUALS(false, suppressions.isSuppressed(errorMessage("errorid2", "test.cpp", 1), false));
+        ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("errorid2", "test2.cpp", 1)));
+        ASSERT_EQUALS(false, suppressions.isSuppressed(errorMessage("errorid2", "test2.cpp", 1), false));
+    }
+
+    static void addCheckedSuppression(SuppressionList& supprs, SuppressionList::Suppression suppr)
+    {
+        suppr.checked = true;
+        supprs.addSuppression(std::move(suppr));
+    }
+
+    void suppressUnmatchedSuppressions() {
+        const std::list<FileWithDetails> files = { {"a.c", Standards::Language::C, 0}};
+        const std::list<FileSettings> fs;
+
+        // No unmatched suppression
+        {
+            SuppressionList suppressions;
+            ASSERT_EQUALS(false, CppCheckExecutorTest::reportUnmatchedSuppressions(settingsDefault, suppressions, files, fs, *this));
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        // suppress all unmatchedSuppression
+        {
+            SuppressionList suppressions;
+            addCheckedSuppression(suppressions, {"abc", "a.c", 10U});
+            addCheckedSuppression(suppressions, {"unmatchedSuppression", "*", SuppressionList::Suppression::NO_LINE});
+            ASSERT_EQUALS(false, CppCheckExecutorTest::reportUnmatchedSuppressions(settingsDefault, suppressions, files, fs, *this));
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        // suppress all unmatchedSuppression (corresponds to "--suppress=unmatchedSuppression")
+        {
+            SuppressionList suppressions;
+            addCheckedSuppression(suppressions, {"abc", "a.c", 10U});
+            addCheckedSuppression(suppressions, {"unmatchedSuppression", "", SuppressionList::Suppression::NO_LINE});
+            ASSERT_EQUALS(false, CppCheckExecutorTest::reportUnmatchedSuppressions(settingsDefault, suppressions, files, fs, *this));
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        // suppress all unmatchedSuppression in a.c
+        {
+            SuppressionList suppressions;
+            addCheckedSuppression(suppressions, {"abc", "a.c", 10U});
+            addCheckedSuppression(suppressions, {"unmatchedSuppression", "a.c", SuppressionList::Suppression::NO_LINE});
+            ASSERT_EQUALS(false, CppCheckExecutorTest::reportUnmatchedSuppressions(settingsDefault, suppressions, files, fs, *this));
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        // suppress unmatchedSuppression in a.c at line 10
+        {
+            SuppressionList suppressions;
+            addCheckedSuppression(suppressions, {"abc", "a.c", 10U});
+            addCheckedSuppression(suppressions, {"unmatchedSuppression", "a.c", 10U});
+            ASSERT_EQUALS(false, CppCheckExecutorTest::reportUnmatchedSuppressions(settingsDefault, suppressions, files, fs, *this));
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        // don't suppress unmatchedSuppression when file is mismatching
+        {
+            SuppressionList suppressions;
+            addCheckedSuppression(suppressions, {"abc", "a.c", 10U});
+            addCheckedSuppression(suppressions, {"unmatchedSuppression", "b.c", SuppressionList::Suppression::NO_LINE});
+            ASSERT_EQUALS(true, CppCheckExecutorTest::reportUnmatchedSuppressions(settingsDefault, suppressions, files, fs, *this));
+            ASSERT_EQUALS("[a.c:10:0]: (information) Unmatched suppression: abc [unmatchedSuppression]\n", errout_str());
+        }
+
+        // don't suppress unmatchedSuppression when line is mismatching
+        {
+            SuppressionList suppressions;
+            addCheckedSuppression(suppressions, {"abc", "a.c", 10U});
+            addCheckedSuppression(suppressions, {"unmatchedSuppression", "a.c", 1U});
+            ASSERT_EQUALS(true, CppCheckExecutorTest::reportUnmatchedSuppressions(settingsDefault, suppressions, files, fs, *this));
+            ASSERT_EQUALS("[a.c:10:0]: (information) Unmatched suppression: abc [unmatchedSuppression]\n", errout_str());
+        }
+    }
+
+    void suppressionsParseXmlFile() const {
+        {
+            ScopedFile file("suppressparsexml.xml",
+                            "<suppressions>\n"
+                            "<suppress>\n"
+                            "<id>uninitvar</id>\n"
+                            "<fileName>file.c</fileName>\n"
+                            "<lineNumber>10</lineNumber>\n"
+                            "<symbolName>sym</symbolName>\n"
+                            "</suppress>\n"
+                            "</suppressions>");
+
+            SuppressionList supprList;
+            ASSERT_EQUALS("", supprList.parseXmlFile(file.path().c_str()));
+            const auto& supprs = supprList.getSuppressions();
+            ASSERT_EQUALS(1, supprs.size());
+            const auto& suppr = *supprs.cbegin();
+            ASSERT_EQUALS("uninitvar", suppr.errorId);
+            ASSERT_EQUALS("file.c", suppr.fileName);
+            ASSERT_EQUALS(10, suppr.lineNumber);
+            ASSERT_EQUALS("sym", suppr.symbolName);
+        }
+
+        // no file specified
+        {
+            SuppressionList supprList;
+            ASSERT_EQUALS("failed to load suppressions XML '' (XML_ERROR_FILE_NOT_FOUND).", supprList.parseXmlFile(""));
+        }
+
+        // missing file
+        {
+            SuppressionList supprList;
+            ASSERT_EQUALS("failed to load suppressions XML 'suppressparsexml.xml' (XML_ERROR_FILE_NOT_FOUND).", supprList.parseXmlFile("suppressparsexml.xml"));
+        }
+
+        // empty file
+        {
+            ScopedFile file("suppressparsexml.xml",
+                            "");
+
+            SuppressionList supprList;
+            ASSERT_EQUALS("failed to load suppressions XML 'suppressparsexml.xml' (XML_ERROR_EMPTY_DOCUMENT).", supprList.parseXmlFile(file.path().c_str()));
+        }
+
+        // wrong root node
+        {
+            ScopedFile file("suppressparsexml.xml",
+                            "<suppress/>\n");
+
+            SuppressionList supprList;
+            ASSERT_EQUALS("", supprList.parseXmlFile(file.path().c_str()));
+        }
+
+        // no root node
+        {
+            ScopedFile file("suppressparsexml.xml",
+                            "<?xml version=\"1.0\"?>\n");
+
+            SuppressionList supprList;
+            ASSERT_EQUALS("failed to load suppressions XML 'suppressparsexml.xml' (no root node found).", supprList.parseXmlFile(file.path().c_str()));
+        }
+
+        // unknown element
+        {
+            ScopedFile file("suppressparsexml.xml",
+                            "<suppressions>\n"
+                            "<suppress>\n"
+                            "<eid>uninitvar</eid>\n"
+                            "</suppress>\n"
+                            "</suppressions>");
+
+            SuppressionList supprList;
+            ASSERT_EQUALS("unknown element 'eid' in suppressions XML 'suppressparsexml.xml', expected id/fileName/lineNumber/symbolName/hash.", supprList.parseXmlFile(file.path().c_str()));
+        }
+    }
+
+    void addSuppressionDuplicate() const {
+        SuppressionList supprs;
+
+        SuppressionList::Suppression s;
+        s.errorId = "uninitvar";
+
+        ASSERT_EQUALS("", supprs.addSuppression(s));
+        ASSERT_EQUALS("suppression 'uninitvar' already exists", supprs.addSuppression(s));
+    }
+
+    void updateSuppressionState() const {
+        {
+            SuppressionList supprs;
+
+            SuppressionList::Suppression s;
+            s.errorId = "uninitVar";
+            ASSERT_EQUALS(false, supprs.updateSuppressionState(s));
+        }
+        {
+            SuppressionList supprs;
+
+            SuppressionList::Suppression s;
+            s.errorId = "uninitVar";
+
+            ASSERT_EQUALS("", supprs.addSuppression(s));
+
+            ASSERT_EQUALS(true, supprs.updateSuppressionState(s));
+
+            const std::list<SuppressionList::Suppression> l = supprs.getUnmatchedGlobalSuppressions();
+            ASSERT_EQUALS(1, l.size());
+        }
+        {
+            SuppressionList supprs;
+
+            SuppressionList::Suppression s;
+            s.errorId = "uninitVar";
+            s.matched = false;
+
+            ASSERT_EQUALS("", supprs.addSuppression(s));
+
+            s.matched = true;
+            ASSERT_EQUALS(true, supprs.updateSuppressionState(s));
+
+            const std::list<SuppressionList::Suppression> l = supprs.getUnmatchedGlobalSuppressions();
+            ASSERT_EQUALS(0, l.size());
+        }
     }
 
+    void addSuppressionLineMultiple() const {
+        SuppressionList supprlist;
+
+        ASSERT_EQUALS("", supprlist.addSuppressionLine("syntaxError"));
+        ASSERT_EQUALS("", supprlist.addSuppressionLine("uninitvar:1.c"));
+        ASSERT_EQUALS("", supprlist.addSuppressionLine("memleak:1.c"));
+        ASSERT_EQUALS("", supprlist.addSuppressionLine("uninitvar:2.c"));
+        ASSERT_EQUALS("", supprlist.addSuppressionLine("memleak:3.c:12 # first"));
+        ASSERT_EQUALS("", supprlist.addSuppressionLine("memleak:3.c:22 // second"));
+
+        const auto& supprs = supprlist.getSuppressions();
+        ASSERT_EQUALS(6, supprs.size());
+
+        auto it = supprs.cbegin();
+
+        ASSERT_EQUALS("syntaxError", it->errorId);
+        ASSERT_EQUALS("", it->fileName);
+        ASSERT_EQUALS(SuppressionList::Suppression::NO_LINE, it->lineNumber);
+        ++it;
+
+        ASSERT_EQUALS("uninitvar", it->errorId);
+        ASSERT_EQUALS("1.c", it->fileName);
+        ASSERT_EQUALS(SuppressionList::Suppression::NO_LINE, it->lineNumber);
+        ++it;
+
+        ASSERT_EQUALS("memleak", it->errorId);
+        ASSERT_EQUALS("1.c", it->fileName);
+        ASSERT_EQUALS(SuppressionList::Suppression::NO_LINE, it->lineNumber);
+        ++it;
+
+        ASSERT_EQUALS("uninitvar", it->errorId);
+        ASSERT_EQUALS("2.c", it->fileName);
+        ASSERT_EQUALS(SuppressionList::Suppression::NO_LINE, it->lineNumber);
+        ++it;
+
+        ASSERT_EQUALS("memleak", it->errorId);
+        ASSERT_EQUALS("3.c", it->fileName);
+        ASSERT_EQUALS(12, it->lineNumber);
+        ++it;
+
+        ASSERT_EQUALS("memleak", it->errorId);
+        ASSERT_EQUALS("3.c", it->fileName);
+        ASSERT_EQUALS(22, it->lineNumber);
+    }
+
+    void toString() const
+    {
+        {
+            SuppressionList::Suppression s;
+            s.errorId = "unitvar";
+            ASSERT_EQUALS("unitvar", s.toString());
+        }
+        {
+            SuppressionList::Suppression s;
+            s.errorId = "unitvar";
+            s.fileName = "test.cpp";
+            ASSERT_EQUALS("unitvar:test.cpp", s.toString());
+        }
+        {
+            SuppressionList::Suppression s;
+            s.errorId = "unitvar";
+            s.fileName = "test.cpp";
+            s.lineNumber = 12;
+            ASSERT_EQUALS("unitvar:test.cpp:12", s.toString());
+        }
+        {
+            SuppressionList::Suppression s;
+            s.errorId = "unitvar";
+            s.symbolName = "sym";
+            ASSERT_EQUALS("unitvar\nsymbol=sym", s.toString());
+        }
+    }
+
+    void suppressionFromErrorMessage() const {
+        {
+            const ErrorMessage msg({}, "test1.cpp", Severity::information, "msg", "id", Certainty::inconclusive);
+            const auto msg_s = SuppressionList::ErrorMessage::fromErrorMessage(msg, {"m1", "m2"});
+            ASSERT_EQUALS("test1.cpp", msg_s.getFileName());
+            ASSERT_EQUALS(SuppressionList::Suppression::NO_LINE, msg_s.lineNumber);
+            ASSERT_EQUALS("id", msg_s.errorId);
+            ASSERT_EQUALS_ENUM(Certainty::inconclusive, msg_s.certainty);
+            ASSERT_EQUALS("", msg_s.symbolNames);
+            ASSERT_EQUALS(2, msg_s.macroNames.size());
+            auto it = msg_s.macroNames.cbegin();
+            ASSERT_EQUALS("m1", *it);
+            ++it;
+            ASSERT_EQUALS("m2", *it);
+        }
+        {
+            std::list<ErrorMessage::FileLocation> loc;
+            loc.emplace_back("test1.cpp", 1, 1);
+            const ErrorMessage msg(std::move(loc), "test1.cpp", Severity::information, "msg", "id", Certainty::normal);
+            const auto msg_s = SuppressionList::ErrorMessage::fromErrorMessage(msg, {});
+            ASSERT_EQUALS("test1.cpp", msg_s.getFileName());
+            ASSERT_EQUALS(1, msg_s.lineNumber);
+        }
+        {
+            std::list<ErrorMessage::FileLocation> loc;
+            loc.emplace_back("test1.cpp", 1, 1);
+            loc.emplace_back("test2.cpp", 2, 2);
+            loc.emplace_back("test3.cpp", 3, 3);
+            const ErrorMessage msg(std::move(loc), "test1.cpp", Severity::information, "msg", "id", Certainty::normal);
+            const auto msg_s = SuppressionList::ErrorMessage::fromErrorMessage(msg, {});
+            ASSERT_EQUALS("test3.cpp", msg_s.getFileName());
+            ASSERT_EQUALS(3, msg_s.lineNumber);
+        }
+    }
+
+    void suppressionWildcard() const {
+        {
+            SuppressionList suppressions;
+            ASSERT_EQUALS("", suppressions.addSuppressionLine("id:test*.cpp"));
+
+            ASSERT_EQUALS(false, suppressions.isSuppressed(errorMessage("abc", "xyz.cpp", 1)));
+            {
+                const auto supprs = suppressions.getSuppressions();
+                const auto suppr = supprs.cbegin();
+                ASSERT(!suppr->checked);
+                ASSERT(!suppr->matched);
+            }
+            ASSERT(suppressions.getUnmatchedGlobalSuppressions().empty());
+        }
+
+        {
+            SuppressionList suppressions;
+            ASSERT_EQUALS("", suppressions.addSuppressionLine("id:test*.cpp"));
+
+            ASSERT_EQUALS(false, suppressions.isSuppressed(errorMessage("abc", "test.cpp", 1)));
+            {
+                const auto supprs = suppressions.getSuppressions();
+                const auto suppr = supprs.cbegin();
+                ASSERT(suppr->checked);
+                ASSERT(!suppr->matched);
+            }
+            ASSERT(!suppressions.getUnmatchedGlobalSuppressions().empty());
+        }
+
+        {
+            SuppressionList suppressions;
+            ASSERT_EQUALS("", suppressions.addSuppressionLine("id:test*.cpp"));
+
+            ASSERT_EQUALS(false, suppressions.isSuppressed(errorMessage("id2", "test.cpp", 1)));
+            {
+                const auto supprs = suppressions.getSuppressions();
+                const auto suppr = supprs.cbegin();
+                ASSERT(suppr->checked);
+                ASSERT(!suppr->matched);
+            }
+            ASSERT(!suppressions.getUnmatchedGlobalSuppressions().empty());
+        }
+
+        {
+            SuppressionList suppressions;
+            ASSERT_EQUALS("", suppressions.addSuppressionLine("id:test*.cpp"));
+            ASSERT_EQUALS(true, suppressions.isSuppressed(errorMessage("id", "test.cpp", 1)));
+            {
+                const auto supprs = suppressions.getSuppressions();
+                const auto suppr = supprs.cbegin();
+                ASSERT(suppr->checked);
+                ASSERT(suppr->matched);
+            }
+            ASSERT(suppressions.getUnmatchedGlobalSuppressions().empty());
+        }
+
+        {
+            SuppressionList suppressions;
+            ASSERT_EQUALS("", suppressions.addSuppressionLine("*:test*.cpp"));
+            // the empty ID should be disallowed but it is use as a hack to mark wildcards on error IDs as checked
+            ASSERT_EQUALS(false, suppressions.isSuppressed(errorMessage("", "test.cpp", 1)));
+            {
+                const auto supprs = suppressions.getSuppressions();
+                const auto suppr = supprs.cbegin();
+                ASSERT(suppr->checked);
+                ASSERT(!suppr->matched);
+            }
+            ASSERT(!suppressions.getUnmatchedGlobalSuppressions().empty());
+        }
+    }
+
+    static std::string polyspaceParseIdsResults(const std::string& comment, std::string::size_type pos) {
+        std::string ret;
+        for (const auto& fr: polyspace::Parser::parseFamilyRules(comment,pos)) {
+            if (!fr.second.empty())
+                ret += ',' + fr.first + ':' + fr.second;
+        }
+        return ret.empty() ? ret : ret.substr(1);
+    }
+
+    void polyspaceParseRange() const {
+        std::string::size_type pos;
+
+        // Happy case
+        pos = 0;
+        ASSERT_EQUALS(12, polyspace::Parser::parseRange(" +12 ",pos));
+        ASSERT_EQUALS(4U, pos);
+
+        // Invalid range => pos will point at the token
+        pos = 0;
+        ASSERT_EQUALS(0, polyspace::Parser::parseRange(" ",pos));
+        ASSERT_EQUALS(std::string::npos, pos);
+
+        pos = 0;
+        ASSERT_EQUALS(0, polyspace::Parser::parseRange(" test ",pos));
+        ASSERT_EQUALS(1U, pos);
+
+        pos = 0;
+        ASSERT_EQUALS(0, polyspace::Parser::parseRange(" +",pos));
+        ASSERT_EQUALS(1U, pos);
+
+        pos = 0;
+        ASSERT_EQUALS(0, polyspace::Parser::parseRange(" +12",pos));
+        ASSERT_EQUALS(1U, pos);
+
+        pos = 0;
+        ASSERT_EQUALS(0, polyspace::Parser::parseRange(" +A ",pos));
+        ASSERT_EQUALS(1U, pos);
+    }
+
+    void polyspaceParseIds() const {
+        ASSERT_EQUALS("test:12", polyspaceParseIdsResults("abc test:12",3));
+        ASSERT_EQUALS("test:12", polyspaceParseIdsResults("abc test:12 [12]",3));
+        ASSERT_EQUALS("test:12", polyspaceParseIdsResults("abc test:12 */",3));
+        ASSERT_EQUALS("test:1*", polyspaceParseIdsResults("abc test:1* */",3));
+        ASSERT_EQUALS("test:*", polyspaceParseIdsResults("// abc test:*",6));
+        // -_.
+        ASSERT_EQUALS("test:1-2.3", polyspaceParseIdsResults("abc test:1-2.3",3));
+        ASSERT_EQUALS("t-e_s.t:12", polyspaceParseIdsResults("abc t-e_s.t : 12",3));
+        // multiple ids
+        ASSERT_EQUALS("d:1,d:2", polyspaceParseIdsResults("abc d:1,2",3));
+        ASSERT_EQUALS("d:1,d:2,e:3,e:4,f:6", polyspaceParseIdsResults("abc d:1,2 e: 3 , 4 f : 6 ",3));
+    }
+
+    struct PolyspaceComment {
+        std::string text;
+        int line;
+
+        PolyspaceComment(const std::string &&text, int line)
+            : text(text)
+            , line(line)
+        {}
+    };
+
+    struct PolyspaceParseResult {
+        std::string errorId;
+        int lineNumber;
+        std::string extraComment;
+        SuppressionList::Type type = SuppressionList::Type::unique;
+        int lineBegin = SuppressionList::Suppression::NO_LINE;
+        int lineEnd = SuppressionList::Suppression::NO_LINE;
+
+        PolyspaceParseResult(const std::string &&errorId,
+                             int lineNumber,
+                             const std::string &&extraComment = "",
+                             SuppressionList::Type type = SuppressionList::Type::unique,
+                             int lineBegin = SuppressionList::Suppression::NO_LINE,
+                             int lineEnd = SuppressionList::Suppression::NO_LINE)
+            : errorId(errorId)
+            , lineNumber(lineNumber)
+            , extraComment(extraComment)
+            , type(type)
+            , lineBegin(lineBegin)
+            , lineEnd(lineEnd)
+        {}
+    };
+
+    void testPolyspaceSuppression(const std::string& addon,
+                                  const std::string& premiumArgs,
+                                  const PolyspaceComment& comment,
+                                  std::initializer_list<PolyspaceParseResult> results) const
+    {
+        SuppressionList list;
+        Settings settings;
+        if (!addon.empty()) {
+            AddonInfo info;
+            info.name = addon;
+            settings.addonInfos.push_back(info);
+        }
+        settings.premiumArgs = premiumArgs;
+        polyspace::Parser parser(settings);
+
+        const std::string fileName = "file.c";
+        const auto supprs = parser.parse(comment.text, comment.line, fileName);
+
+        ASSERT_EQUALS(results.size(), supprs.size());
+
+        auto supprIt = supprs.cbegin();
+        const auto *resultIt = results.begin();
+
+        for (; supprIt != supprs.cend(); supprIt++, resultIt++) {
+            ASSERT(supprIt->isPolyspace);
+            ASSERT(supprIt->isInline);
+            ASSERT_EQUALS(fileName, supprIt->fileName);
+            ASSERT_EQUALS(resultIt->errorId, supprIt->errorId);
+            ASSERT_EQUALS(resultIt->extraComment, supprIt->extraComment);
+            ASSERT_EQUALS_ENUM(resultIt->type, supprIt->type);
+            ASSERT_EQUALS(resultIt->lineNumber, supprIt->lineNumber);
+            ASSERT_EQUALS(resultIt->lineBegin, supprIt->lineBegin);
+            ASSERT_EQUALS(resultIt->lineEnd, supprIt->lineEnd);
+        }
+    }
+
+    void polyspaceMisraC2012() const {
+        testPolyspaceSuppression(
+            "misra", "",
+            { "/* polyspace MISRA2012 : 2.7 */", 1 },
+            { { "misra-c2012-2.7", 1 } }
+            );
+    }
+
+    void polyspacePremiumMisraC2012() const {
+        testPolyspaceSuppression(
+            "", "--misra-c-2012",
+            { "/* polyspace MISRA2012 : 2.7 */", 1 },
+            { { "premium-misra-c-2012-2.7", 1 } }
+            );
+    }
+
+    void polyspaceMisraC2023() const {
+        testPolyspaceSuppression(
+            "", "--misra-c-2023",
+            { "// polyspace MISRA-C-2023 : *", 2 },
+            { { "premium-misra-c-2023-*", 2 } }
+            );
+    }
+
+    void polyspaceMisraCpp2008() const {
+        testPolyspaceSuppression(
+            "", "--misra-cpp-2008",
+            { "// polyspace MISRA-CPP : 7-1-1", 1 },
+            { { "premium-misra-cpp-2008-7-1-1", 1 } }
+            );
+    }
+
+    void polyspaceMisraCpp2023() const {
+        testPolyspaceSuppression(
+            "", "--misra-cpp-2023",
+            { "// polyspace MISRA-CPP-2023 : 4.6.1", 1 },
+            { { "premium-misra-cpp-2023-4.6.1", 1 } }
+            );
+    }
+
+    void polyspaceCertC() const {
+        testPolyspaceSuppression(
+            "", "--cert-c",
+            { "// polyspace CERT-C : PRE30", 1 },
+            { { "premium-cert-c-PRE30", 1 } }
+            );
+    }
+
+    void polyspaceCertCpp() const {
+        testPolyspaceSuppression(
+            "", "--cert-cpp",
+            { "// polyspace CERT-CPP : CTR51", 1 },
+            { { "premium-cert-cpp-CTR51", 1 } }
+            );
+    }
+
+    void polyspaceAutosar() const {
+        testPolyspaceSuppression(
+            "", "--autosar",
+            { "// polyspace AUTOSAR-CPP14 : a2-10-1", 1 },
+            { { "premium-autosar-a2-10-1", 1 } }
+            );
+    }
+
+    void polyspaceIgnored() const {
+        testPolyspaceSuppression(
+            "", "",
+            { "// polyspace DEFECT : INT_OVFL AUTOSAR-CPP14 : a2-10-1", 1 },
+            {}
+            );
+    }
+
+    void polyspaceMultiple1() const {
+        testPolyspaceSuppression(
+            "", "--misra-c-2012",
+            { "/* polyspace MISRA2012 : 2.7, 9.1 */", 1 },
+            { { "premium-misra-c-2012-2.7", 1 },
+                { "premium-misra-c-2012-9.1", 1 } }
+            );
+    }
+
+    void polyspaceMultiple2() const {
+        testPolyspaceSuppression(
+            "", "--misra-c-2012 --misra-cpp-2008",
+            { "/* polyspace MISRA2012 : 2.7 MISRA-CPP : 7-1-1 */", 1 },
+            { { "premium-misra-c-2012-2.7", 1 },
+                { "premium-misra-cpp-2008-7-1-1", 1 } }
+            );
+    }
+
+    void polyspaceMultiple3() const {
+        testPolyspaceSuppression(
+            "", "--misra-c-2012 --misra-cpp-2008",
+            { "/* polyspace MISRA2012 : 2.7 [Justified:Low] \"comment 1\" polyspace MISRA-CPP : 7-1-1 \"comment 2\"*/", 1 },
+            { { "premium-misra-c-2012-2.7", 1, "comment 1" },
+                { "premium-misra-cpp-2008-7-1-1", 1, "comment 2" }, }
+            );
+    }
+
+    void polyspaceRange() const {
+        testPolyspaceSuppression(
+            "", "--misra-c-2012",
+            { "/* polyspace +3 MISRA2012 : 2.7 */", 1 },
+            { { "premium-misra-c-2012-2.7", 1, "", SuppressionList::Type::block, 1, 4 } }
+            );
+    }
+
+    void polyspaceBlock() const {
+        testPolyspaceSuppression(
+            "", "--misra-c-2012",
+            { "/* polyspace-begin MISRA2012 : 2.7 */", 1 },
+            { { "premium-misra-c-2012-2.7", 1, "", SuppressionList::Type::blockBegin } }
+            );
+
+        testPolyspaceSuppression(
+            "", "--misra-c-2012",
+            { "/* polyspace-end MISRA2012 : 2.7 */", 1 },
+            { { "premium-misra-c-2012-2.7", 1, "", SuppressionList::Type::blockEnd } }
+            );
+
+    }
+
+    void polyspaceExtraComments() const {
+        testPolyspaceSuppression(
+            "", "--misra-c-2012 --misra-cpp-2008",
+            { "/* polyspace MISRA2012 : 2.7 MISRA-CPP : 7-1-1 \"comment 1\" polyspace MISRA2012 : 8.1, 8.3 \"comment 2\" */", 1 },
+            { { "premium-misra-c-2012-2.7", 1, "comment 1" },
+                { "premium-misra-cpp-2008-7-1-1", 1, "comment 1" },
+                { "premium-misra-c-2012-8.1", 1, "comment 2" },
+                { "premium-misra-c-2012-8.3", 1, "comment 2" }, }
+            );
+    }
 };
 
 REGISTER_TEST(TestSuppressions)
diff --git a/test/testsymboldatabase.cpp b/test/testsymboldatabase.cpp
index 1ffd8b92ded..05dd0ab9b8f 100644
--- a/test/testsymboldatabase.cpp
+++ b/test/testsymboldatabase.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,70 +16,126 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "platform.h"
 #include "settings.h"
+#include "sourcelocation.h"
 #include "symboldatabase.h"
-#include "testsuite.h"
-#include "testutils.h"
 #include "token.h"
 #include "tokenize.h"
 #include "tokenlist.h"
-#include "utils.h"
 
-#include <climits>
-#include <cstddef>
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <iterator>
 #include <list>
-#include <map>
 #include <set>
 #include <sstream>
 #include <stdexcept>
 #include <string>
 #include <vector>
 
-struct InternalError;
+class TestSymbolDatabase;
 
 #define GET_SYMBOL_DB(code) \
-    Tokenizer tokenizer(&settings1, this); \
-    const SymbolDatabase *db = getSymbolDB_inner(tokenizer, code, "test.cpp"); \
-    ASSERT(db);
+    SimpleTokenizer tokenizer(settings1, *this); \
+    const SymbolDatabase *db = getSymbolDB_inner(tokenizer, code); \
+    ASSERT(db); \
+    do {} while (false)
 
 #define GET_SYMBOL_DB_C(code) \
-    Tokenizer tokenizer(&settings1, this); \
-    const SymbolDatabase *db = getSymbolDB_inner(tokenizer, code, "test.c");
+    SimpleTokenizer tokenizer(settings1, *this, false); \
+    const SymbolDatabase *db = getSymbolDB_inner(tokenizer, code); \
+    do {} while (false)
 
-class TestSymbolDatabase: public TestFixture {
+#define GET_SYMBOL_DB_DBG(code) \
+    SimpleTokenizer tokenizer(settingsDbg, *this); \
+    const SymbolDatabase *db = getSymbolDB_inner(tokenizer, code); \
+    ASSERT(db); \
+    do {} while (false)
+
+class TestSymbolDatabase : public TestFixture {
 public:
-    TestSymbolDatabase()
-        :TestFixture("TestSymbolDatabase")
-        ,nullScope(nullptr, nullptr, nullptr)
-        ,vartok(nullptr)
-        ,typetok(nullptr) {
-    }
+    TestSymbolDatabase() : TestFixture("TestSymbolDatabase") {}
 
 private:
-    const Scope nullScope;
-    const Token* vartok;
-    const Token* typetok;
-    Settings settings1;
-    Settings settings2;
+    const Token* vartok{nullptr};
+    const Token* typetok{nullptr};
+    const Settings settings1 = settingsBuilder().library("std.cfg").build();
+    const Settings settings2 = settingsBuilder().platform(Platform::Type::Unspecified).build();
+    const Settings settingsDbg = settingsBuilder().library("std.cfg").debugwarnings(true).build();
 
     void reset() {
         vartok = nullptr;
         typetok = nullptr;
     }
 
-    const static SymbolDatabase* getSymbolDB_inner(Tokenizer& tokenizer, const char* code, const char* filename) {
-        errout.str("");
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, filename);
-        return tokenizer.getSymbolDatabase();
+    template<size_t size>
+    static const SymbolDatabase* getSymbolDB_inner(SimpleTokenizer& tokenizer, const char (&code)[size]) {
+        return tokenizer.tokenize(code) ? tokenizer.getSymbolDatabase() : nullptr;
     }
 
-    static const Scope *findFunctionScopeByToken(const SymbolDatabase * db, const Token *tok) {
-        std::list<Scope>::const_iterator scope;
+    static const Token* findToken(Tokenizer& tokenizer, const std::string& expr, unsigned int exprline)
+    {
+        for (const Token* tok = tokenizer.tokens(); tok; tok = tok->next()) {
+            if (Token::simpleMatch(tok, expr.c_str(), expr.size()) && tok->linenr() == exprline) {
+                return tok;
+            }
+        }
+        return nullptr;
+    }
+
+    static std::string asExprIdString(const Token* tok)
+    {
+        return tok->expressionString() + "@" + std::to_string(tok->exprId());
+    }
+
+    template<size_t size>
+    std::string testExprIdEqual(const char (&code)[size],
+                                const std::string& expr1,
+                                unsigned int exprline1,
+                                const std::string& expr2,
+                                unsigned int exprline2,
+                                SourceLocation loc = SourceLocation::current())
+    {
+        SimpleTokenizer tokenizer(settings1, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), loc.file_name(), loc.line());
+
+        const Token* tok1 = findToken(tokenizer, expr1, exprline1);
+        const Token* tok2 = findToken(tokenizer, expr2, exprline2);
+
+        if (!tok1)
+            return "'" + expr1 + "'" + " not found";
+        if (!tok2)
+            return "'" + expr2 + "'" + " not found";
+        if (tok1->exprId() == 0)
+            return asExprIdString(tok1) + " has not exprId";
+        if (tok2->exprId() == 0)
+            return asExprIdString(tok2) + " has not exprId";
+
+        if (tok1->exprId() != tok2->exprId())
+            return asExprIdString(tok1) + " != " + asExprIdString(tok2);
+
+        return "";
+    }
+    template<size_t size>
+    bool testExprIdNotEqual(const char (&code)[size],
+                            const std::string& expr1,
+                            unsigned int exprline1,
+                            const std::string& expr2,
+                            unsigned int exprline2,
+                            SourceLocation loc = SourceLocation::current())
+    {
+        std::string result = testExprIdEqual(code, expr1, exprline1, expr2, exprline2, loc);
+        return !result.empty();
+    }
 
-        for (scope = db->scopeList.begin(); scope != db->scopeList.end(); ++scope) {
-            if (scope->type == Scope::eFunction) {
+    static const Scope *findFunctionScopeByToken(const SymbolDatabase * db, const Token *tok) {
+        for (auto scope = db->scopeList.cbegin(); scope != db->scopeList.cend(); ++scope) {
+            if (scope->type == ScopeType::eFunction) {
                 if (scope->classDef == tok)
                     return &(*scope);
             }
@@ -96,21 +152,23 @@ class TestSymbolDatabase: public TestFixture {
                 currScope = currScope->nestedIn;
         }
         while (currScope) {
-            for (const Function & i : currScope->functionList) {
-                if (i.tokenDef->str() == str)
-                    return &i;
-            }
+            auto it = std::find_if(currScope->functionList.cbegin(), currScope->functionList.cend(), [&](const Function& f) {
+                return f.tokenDef->str() == str;
+            });
+            if (it != currScope->functionList.end())
+                return &*it;
             currScope = currScope->nestedIn;
         }
         return nullptr;
     }
 
-    void run() OVERRIDE {
-        LOAD_LIB_2(settings1.library, "std.cfg");
-        settings2.platform(Settings::Unspecified);
-
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(array);
-        TEST_CASE(stlarray);
+        TEST_CASE(array_ptr);
+        TEST_CASE(stlarray1);
+        TEST_CASE(stlarray2);
+        TEST_CASE(stlarray3);
 
         TEST_CASE(test_isVariableDeclarationCanHandleNull);
         TEST_CASE(test_isVariableDeclarationIdentifiesSimpleDeclaration);
@@ -121,6 +179,7 @@ class TestSymbolDatabase: public TestFixture {
         TEST_CASE(test_isVariableDeclarationIdentifiesScopedStdDeclaration);
         TEST_CASE(test_isVariableDeclarationIdentifiesManyScopes);
         TEST_CASE(test_isVariableDeclarationIdentifiesPointers);
+        TEST_CASE(test_isVariableDeclarationIdentifiesPointers2);
         TEST_CASE(test_isVariableDeclarationDoesNotIdentifyConstness);
         TEST_CASE(test_isVariableDeclarationIdentifiesFirstOfManyVariables);
         TEST_CASE(test_isVariableDeclarationIdentifiesScopedPointerDeclaration);
@@ -128,7 +187,10 @@ class TestSymbolDatabase: public TestFixture {
         TEST_CASE(test_isVariableDeclarationIdentifiesDeclarationWithMultipleIndirection);
         TEST_CASE(test_isVariableDeclarationIdentifiesArray);
         TEST_CASE(test_isVariableDeclarationIdentifiesPointerArray);
-        TEST_CASE(test_isVariableDeclarationIdentifiesOfArrayPointers);
+        TEST_CASE(test_isVariableDeclarationIdentifiesOfArrayPointers1);
+        TEST_CASE(test_isVariableDeclarationIdentifiesOfArrayPointers2);
+        TEST_CASE(test_isVariableDeclarationIdentifiesOfArrayPointers3);
+        TEST_CASE(test_isVariableDeclarationIdentifiesArrayOfFunctionPointers);
         TEST_CASE(isVariableDeclarationIdentifiesTemplatedPointerVariable);
         TEST_CASE(isVariableDeclarationIdentifiesTemplatedPointerToPointerVariable);
         TEST_CASE(isVariableDeclarationIdentifiesTemplatedArrayVariable);
@@ -141,25 +203,38 @@ class TestSymbolDatabase: public TestFixture {
         TEST_CASE(isVariableDeclarationPointerConst);
         TEST_CASE(isVariableDeclarationRValueRef);
         TEST_CASE(isVariableDeclarationDoesNotIdentifyCase);
+        TEST_CASE(isVariableDeclarationIf);
         TEST_CASE(isVariableStlType);
         TEST_CASE(isVariablePointerToConstPointer);
         TEST_CASE(isVariablePointerToVolatilePointer);
         TEST_CASE(isVariablePointerToConstVolatilePointer);
         TEST_CASE(isVariableMultiplePointersAndQualifiers);
+        TEST_CASE(variableVolatile);
+        TEST_CASE(variableConstexpr);
+        TEST_CASE(isVariableDecltype);
+        TEST_CASE(isVariableAlignas);
 
         TEST_CASE(VariableValueType1);
         TEST_CASE(VariableValueType2);
         TEST_CASE(VariableValueType3);
+        TEST_CASE(VariableValueType4); // smart pointer type
+        TEST_CASE(VariableValueType5); // smart pointer type
+        TEST_CASE(VariableValueType6); // smart pointer type
+        TEST_CASE(VariableValueTypeReferences);
+        TEST_CASE(VariableValueTypeTemplate);
 
         TEST_CASE(findVariableType1);
         TEST_CASE(findVariableType2);
         TEST_CASE(findVariableType3);
+        TEST_CASE(findVariableTypeExternC);
 
         TEST_CASE(rangeBasedFor);
 
+        TEST_CASE(memberVar1);
         TEST_CASE(arrayMemberVar1);
         TEST_CASE(arrayMemberVar2);
         TEST_CASE(arrayMemberVar3);
+        TEST_CASE(arrayMemberVar4);
         TEST_CASE(staticMemberVar);
         TEST_CASE(getVariableFromVarIdBoundsCheck);
 
@@ -170,6 +245,7 @@ class TestSymbolDatabase: public TestFixture {
         TEST_CASE(hasMissingInlineClassFunction);
         TEST_CASE(hasClassFunction);
         TEST_CASE(hasClassFunction_trailingReturnType);
+        TEST_CASE(hasClassFunction_decltype_auto);
 
         TEST_CASE(hasRegularFunctionReturningFunctionPointer);
         TEST_CASE(hasInlineClassFunctionReturningFunctionPointer);
@@ -183,11 +259,15 @@ class TestSymbolDatabase: public TestFixture {
         TEST_CASE(testConstructors);
         TEST_CASE(functionDeclarationTemplate);
         TEST_CASE(functionDeclarations);
+        TEST_CASE(functionDeclarations2);
+        TEST_CASE(constexprFunction);
         TEST_CASE(constructorInitialization);
         TEST_CASE(memberFunctionOfUnknownClassMacro1);
         TEST_CASE(memberFunctionOfUnknownClassMacro2);
         TEST_CASE(memberFunctionOfUnknownClassMacro3);
         TEST_CASE(functionLinkage);
+        TEST_CASE(externalFunctionsInsideAFunction);    // #12420
+        TEST_CASE(namespacedFunctionInsideExternBlock); // #12420
 
         TEST_CASE(classWithFriend);
 
@@ -216,13 +296,30 @@ class TestSymbolDatabase: public TestFixture {
         TEST_CASE(functionArgs12); // #7661
         TEST_CASE(functionArgs13); // #7697
         TEST_CASE(functionArgs14); // #9055
+        TEST_CASE(functionArgs15); // #7159
+        TEST_CASE(functionArgs16); // #9591
+        TEST_CASE(functionArgs17);
+        TEST_CASE(functionArgs18); // #10376
+        TEST_CASE(functionArgs19); // #10376
+        TEST_CASE(functionArgs20);
+        TEST_CASE(functionArgs21);
+        TEST_CASE(functionArgs22); // #13945
 
         TEST_CASE(functionImplicitlyVirtual);
+        TEST_CASE(functionGetOverridden);
+
+        TEST_CASE(functionIsInlineKeyword);
+
+        TEST_CASE(functionStatic);
+
+        TEST_CASE(functionReturnsReference); // Function::returnsReference
 
         TEST_CASE(namespaces1);
         TEST_CASE(namespaces2);
         TEST_CASE(namespaces3);  // #3854 - unknown macro
         TEST_CASE(namespaces4);
+        TEST_CASE(namespaces5); // #13967
+        TEST_CASE(needInitialization);
 
         TEST_CASE(tryCatch1);
 
@@ -299,8 +396,54 @@ class TestSymbolDatabase: public TestFixture {
         TEST_CASE(symboldatabase76); // #9056
         TEST_CASE(symboldatabase77); // #8663
         TEST_CASE(symboldatabase78); // #9147
+        TEST_CASE(symboldatabase79); // #9392
+        TEST_CASE(symboldatabase80); // #9389
+        TEST_CASE(symboldatabase81); // #9411
+        TEST_CASE(symboldatabase82);
+        TEST_CASE(symboldatabase83); // #9431
+        TEST_CASE(symboldatabase84);
+        TEST_CASE(symboldatabase85);
+        TEST_CASE(symboldatabase86);
+        TEST_CASE(symboldatabase87); // #9922 'extern const char ( * x [ 256 ] ) ;'
+        TEST_CASE(symboldatabase88); // #10040 (using namespace)
+        TEST_CASE(symboldatabase89); // valuetype name
+        TEST_CASE(symboldatabase90);
+        TEST_CASE(symboldatabase91);
+        TEST_CASE(symboldatabase92); // daca crash
+        TEST_CASE(symboldatabase93); // alignas attribute
+        TEST_CASE(symboldatabase94); // structured bindings
+        TEST_CASE(symboldatabase95); // #10295
+        TEST_CASE(symboldatabase96); // #10126
+        TEST_CASE(symboldatabase97); // #10598 - final class
+        TEST_CASE(symboldatabase98); // #10451
+        TEST_CASE(symboldatabase99); // #10864
+        TEST_CASE(symboldatabase100); // #10174
+        TEST_CASE(symboldatabase101);
+        TEST_CASE(symboldatabase102);
+        TEST_CASE(symboldatabase103);
+        TEST_CASE(symboldatabase104);
+        TEST_CASE(symboldatabase105);
+        TEST_CASE(symboldatabase106);
+        TEST_CASE(symboldatabase107);
+        TEST_CASE(symboldatabase108);
+        TEST_CASE(symboldatabase109); // #13553
+        TEST_CASE(symboldatabase110);
+        TEST_CASE(symboldatabase111); // [[fallthrough]]
+        TEST_CASE(symboldatabase112); // explicit operator
 
         TEST_CASE(createSymbolDatabaseFindAllScopes1);
+        TEST_CASE(createSymbolDatabaseFindAllScopes2);
+        TEST_CASE(createSymbolDatabaseFindAllScopes3);
+        TEST_CASE(createSymbolDatabaseFindAllScopes4);
+        TEST_CASE(createSymbolDatabaseFindAllScopes5);
+        TEST_CASE(createSymbolDatabaseFindAllScopes6);
+        TEST_CASE(createSymbolDatabaseFindAllScopes7);
+        TEST_CASE(createSymbolDatabaseFindAllScopes8); // #12761
+        TEST_CASE(createSymbolDatabaseFindAllScopes9);
+        TEST_CASE(createSymbolDatabaseFindAllScopes10);
+        TEST_CASE(createSymbolDatabaseFindAllScopes11);
+
+        TEST_CASE(createSymbolDatabaseIncompleteVars);
 
         TEST_CASE(enum1);
         TEST_CASE(enum2);
@@ -309,6 +452,21 @@ class TestSymbolDatabase: public TestFixture {
         TEST_CASE(enum5);
         TEST_CASE(enum6);
         TEST_CASE(enum7);
+        TEST_CASE(enum8);
+        TEST_CASE(enum9);
+        TEST_CASE(enum10); // #11001
+        TEST_CASE(enum11);
+        TEST_CASE(enum12);
+        TEST_CASE(enum13);
+        TEST_CASE(enum14);
+        TEST_CASE(enum15);
+        TEST_CASE(enum16);
+        TEST_CASE(enum17);
+        TEST_CASE(enum18);
+        TEST_CASE(enum19);
+        TEST_CASE(enum20); // #14419
+
+        TEST_CASE(struct1);
 
         TEST_CASE(sizeOfType);
 
@@ -317,6 +475,8 @@ class TestSymbolDatabase: public TestFixture {
 
         TEST_CASE(isFunction1); // UNKNOWN_MACRO(a,b) { .. }
         TEST_CASE(isFunction2);
+        TEST_CASE(isFunction3);
+        TEST_CASE(isFunction4);
 
         TEST_CASE(findFunction1);
         TEST_CASE(findFunction2); // mismatch: parameter passed by address => reference argument
@@ -328,7 +488,6 @@ class TestSymbolDatabase: public TestFixture {
         TEST_CASE(findFunction8);
         TEST_CASE(findFunction9);
         TEST_CASE(findFunction10); // #7673
-        TEST_CASE(findFunction11);
         TEST_CASE(findFunction12);
         TEST_CASE(findFunction13);
         TEST_CASE(findFunction14);
@@ -345,7 +504,48 @@ class TestSymbolDatabase: public TestFixture {
         TEST_CASE(findFunction25); // std::vector<std::shared_ptr<Fred>>
         TEST_CASE(findFunction26); // #8668 - pointer parameter in function call, const pointer function argument
         TEST_CASE(findFunction27);
+        TEST_CASE(findFunction28);
+        TEST_CASE(findFunction29);
+        TEST_CASE(findFunction30);
+        TEST_CASE(findFunction31);
+        TEST_CASE(findFunction32); // C: relax type matching
+        TEST_CASE(findFunction33); // #9885 variadic function
+        TEST_CASE(findFunction34); // #10061
+        TEST_CASE(findFunction35);
+        TEST_CASE(findFunction36); // #10122
+        TEST_CASE(findFunction37); // #10124
+        TEST_CASE(findFunction38); // #10125
+        TEST_CASE(findFunction39); // #10127
+        TEST_CASE(findFunction40); // #10135
+        TEST_CASE(findFunction41); // #10202
+        TEST_CASE(findFunction42);
+        TEST_CASE(findFunction43); // #10087
+        TEST_CASE(findFunction44); // #11182
+        TEST_CASE(findFunction45);
+        TEST_CASE(findFunction46);
+        TEST_CASE(findFunction47);
+        TEST_CASE(findFunction48);
+        TEST_CASE(findFunction49); // #11888
+        TEST_CASE(findFunction50); // #11904 - method with same name and arguments in derived class
+        TEST_CASE(findFunction51); // #11975 - method with same name in derived class
+        TEST_CASE(findFunction52);
+        TEST_CASE(findFunction53);
+        TEST_CASE(findFunction54);
+        TEST_CASE(findFunction55); // #13004
+        TEST_CASE(findFunction56);
+        TEST_CASE(findFunction57);
+        TEST_CASE(findFunction58); // #13310
+        TEST_CASE(findFunction59);
+        TEST_CASE(findFunction60);
+        TEST_CASE(findFunction61);
+        TEST_CASE(findFunction62); // #14272 - pointer passed to function is const
+        TEST_CASE(findFunctionRef1);
+        TEST_CASE(findFunctionRef2); // #13328
         TEST_CASE(findFunctionContainer);
+        TEST_CASE(findFunctionExternC);
+        TEST_CASE(findFunctionGlobalScope); // ::foo
+
+        TEST_CASE(overloadedFunction1);
 
         TEST_CASE(valueTypeMatchParameter); // ValueType::matchParameter
 
@@ -357,10 +557,14 @@ class TestSymbolDatabase: public TestFixture {
         TEST_CASE(throwFunction1);
         TEST_CASE(throwFunction2);
 
+        TEST_CASE(constAttributeFunction);
+        TEST_CASE(pureAttributeFunction);
+
         TEST_CASE(nothrowAttributeFunction);
         TEST_CASE(nothrowDeclspecFunction);
 
         TEST_CASE(noreturnAttributeFunction);
+        TEST_CASE(nodiscardAttributeFunction);
 
         TEST_CASE(varTypesIntegral); // known integral
         TEST_CASE(varTypesFloating); // known floating
@@ -371,12 +575,18 @@ class TestSymbolDatabase: public TestFixture {
         TEST_CASE(lambda); // #5867
         TEST_CASE(lambda2); // #7473
         TEST_CASE(lambda3);
+        TEST_CASE(lambda4);
+        TEST_CASE(lambda5);
 
         TEST_CASE(circularDependencies); // #6298
 
         TEST_CASE(executableScopeWithUnknownFunction);
 
-        TEST_CASE(valuetype);
+        TEST_CASE(valueType1);
+        TEST_CASE(valueType2);
+        TEST_CASE(valueType3);
+        TEST_CASE(valueTypeThis);
+        TEST_CASE(valueTypeChar);
 
         TEST_CASE(variadic1); // #7453
         TEST_CASE(variadic2); // #7649
@@ -396,59 +606,164 @@ class TestSymbolDatabase: public TestFixture {
         TEST_CASE(auto10); // #8020
         TEST_CASE(auto11); // #8964 - const auto startX = x;
         TEST_CASE(auto12); // #8993 - const std::string &x; auto y = x; if (y.empty()) ..
+        TEST_CASE(auto13);
+        TEST_CASE(auto14);
+        TEST_CASE(auto15); // C++17 auto deduction from braced-init-list
+        TEST_CASE(auto16);
+        TEST_CASE(auto17); // #11163
+        TEST_CASE(auto18);
+        TEST_CASE(auto19);
+        TEST_CASE(auto20);
+        TEST_CASE(auto21);
+        TEST_CASE(auto22);
+        TEST_CASE(auto23);
 
         TEST_CASE(unionWithConstructor);
 
         TEST_CASE(incomplete_type); // #9255 (infinite recursion)
+        TEST_CASE(exprIds);
+        TEST_CASE(testValuetypeOriginalName);
+
+        TEST_CASE(dumpFriend); // Check if isFriend added to dump file
+
+        TEST_CASE(smartPointerLookupCtor); // #13719);
+
+        TEST_CASE(stdintFunction);
+
+        TEST_CASE(userDefinedLiteral);
     }
 
     void array() {
         GET_SYMBOL_DB_C("int a[10+2];");
         ASSERT(db != nullptr);
-        if (!db)
-            return;
+
         ASSERT(db->variableList().size() == 2); // the first one is not used
         const Variable * v = db->getVariableFromVarId(1);
         ASSERT(v != nullptr);
-        if (!v)
-            return;
+
         ASSERT(v->isArray());
         ASSERT_EQUALS(1U, v->dimensions().size());
         ASSERT_EQUALS(12U, v->dimension(0));
     }
 
-    void stlarray() {
-        GET_SYMBOL_DB("std::array<int, (16 + 4)> arr;");
+    void array_ptr() {
+        GET_SYMBOL_DB("const char* a[] = { \"abc\" };\n"
+                      "const char* b[] = { \"def\", \"ghijkl\" };");
         ASSERT(db != nullptr);
-        if (!db)
-            return;
-        ASSERT(db->variableList().size() == 2); // the first one is not used
+
+        ASSERT(db->variableList().size() == 3); // the first one is not used
+        const Variable* v = db->getVariableFromVarId(1);
+        ASSERT(v != nullptr);
+
+        ASSERT(v->isArray());
+        ASSERT(v->isPointerArray());
+        ASSERT_EQUALS(1U, v->dimensions().size());
+        ASSERT_EQUALS(1U, v->dimension(0));
+
+        v = db->getVariableFromVarId(2);
+        ASSERT(v != nullptr);
+
+        ASSERT(v->isArray());
+        ASSERT(v->isPointerArray());
+        ASSERT_EQUALS(1U, v->dimensions().size());
+        ASSERT_EQUALS(2U, v->dimension(0));
+    }
+
+    void stlarray1() {
+        GET_SYMBOL_DB("std::array<int, 16 + 4> arr;");
+        ASSERT(db != nullptr);
+
+        ASSERT_EQUALS(2, db->variableList().size()); // the first one is not used
         const Variable * v = db->getVariableFromVarId(1);
         ASSERT(v != nullptr);
-        if (!v)
-            return;
+
+        ASSERT(v->isArray());
+        ASSERT_EQUALS(1U, v->dimensions().size());
+        ASSERT_EQUALS(20U, v->dimension(0));
+    }
+
+    void stlarray2() {
+        GET_SYMBOL_DB("constexpr int sz = 16; std::array<int, sz + 4> arr;");
+        ASSERT(db != nullptr);
+
+        ASSERT_EQUALS(3, db->variableList().size()); // the first one is not used
+        const Variable * v = db->getVariableFromVarId(2);
+        ASSERT(v != nullptr);
+
         ASSERT(v->isArray());
         ASSERT_EQUALS(1U, v->dimensions().size());
         ASSERT_EQUALS(20U, v->dimension(0));
     }
 
+    void stlarray3() {
+        GET_SYMBOL_DB("std::array<int, 4> a;\n"
+                      "std::array<int, 4> b[2];\n"
+                      "const std::array<int, 4>& r = a;\n");
+        ASSERT(db != nullptr);
+
+        ASSERT_EQUALS(4, db->variableList().size()); // the first one is not used
+        auto it = db->variableList().begin() + 1;
+
+        ASSERT((*it)->isArray());
+        ASSERT(!(*it)->isPointer());
+        ASSERT(!(*it)->isReference());
+        ASSERT_EQUALS(1U, (*it)->dimensions().size());
+        ASSERT_EQUALS(4U, (*it)->dimension(0));
+        const ValueType* vt = (*it)->valueType();
+        ASSERT(vt);
+        ASSERT(vt->container);
+        ASSERT_EQUALS(vt->pointer, 0);
+        const Token* tok = (*it)->nameToken();
+        ASSERT(tok && (vt = tok->valueType()));
+        ASSERT_EQUALS(vt->pointer, 0);
+
+        ++it;
+        ASSERT((*it)->isArray());
+        ASSERT(!(*it)->isPointer());
+        ASSERT(!(*it)->isReference());
+        ASSERT_EQUALS(1U, (*it)->dimensions().size());
+        ASSERT_EQUALS(4U, (*it)->dimension(0));
+        vt = (*it)->valueType();
+        ASSERT_EQUALS(vt->pointer, 0);
+        tok = (*it)->nameToken();
+        ASSERT(tok && (vt = tok->valueType()));
+        ASSERT_EQUALS(vt->pointer, 1);
+
+        ++it;
+        ASSERT((*it)->isArray());
+        ASSERT(!(*it)->isPointer());
+        ASSERT((*it)->isReference());
+        ASSERT((*it)->isConst());
+        ASSERT_EQUALS(1U, (*it)->dimensions().size());
+        ASSERT_EQUALS(4U, (*it)->dimension(0));
+        vt = (*it)->valueType();
+        ASSERT_EQUALS(vt->pointer, 0);
+        ASSERT(vt->reference == Reference::LValue);
+        tok = (*it)->nameToken();
+        ASSERT(tok && (vt = tok->valueType()));
+        ASSERT_EQUALS(vt->pointer, 0);
+        ASSERT_EQUALS(vt->constness, 1);
+        ASSERT(vt->reference == Reference::LValue);
+    }
+
     void test_isVariableDeclarationCanHandleNull() {
         reset();
-        const bool result = nullScope.isVariableDeclaration(nullptr, vartok, typetok);
+        GET_SYMBOL_DB("void main(){}");
+        const bool result = db->scopeList.front().isVariableDeclaration(nullptr, vartok, typetok);
         ASSERT_EQUALS(false, result);
         ASSERT(nullptr == vartok);
         ASSERT(nullptr == typetok);
-        Variable v(nullptr, nullptr, nullptr, 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(nullptr, nullptr, nullptr, 0, AccessControl::Public, nullptr, nullptr, settings1);
     }
 
     void test_isVariableDeclarationIdentifiesSimpleDeclaration() {
         reset();
-        givenACodeSampleToTokenize simpleDeclaration("int x;");
-        const bool result = nullScope.isVariableDeclaration(simpleDeclaration.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("int x;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("x", vartok->str());
         ASSERT_EQUALS("int", typetok->str());
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(false == v.isPointer());
         ASSERT(false == v.isReference());
@@ -456,12 +771,12 @@ class TestSymbolDatabase: public TestFixture {
 
     void test_isVariableDeclarationIdentifiesInitialization() {
         reset();
-        givenACodeSampleToTokenize simpleDeclaration("int x (1);");
-        const bool result = nullScope.isVariableDeclaration(simpleDeclaration.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("int x (1);");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("x", vartok->str());
         ASSERT_EQUALS("int", typetok->str());
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(false == v.isPointer());
         ASSERT(false == v.isReference());
@@ -469,12 +784,12 @@ class TestSymbolDatabase: public TestFixture {
 
     void test_isVariableDeclarationIdentifiesCpp11Initialization() {
         reset();
-        givenACodeSampleToTokenize simpleDeclaration("int x {1};");
-        const bool result = nullScope.isVariableDeclaration(simpleDeclaration.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("int x {1};");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("x", vartok->str());
         ASSERT_EQUALS("int", typetok->str());
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(false == v.isPointer());
         ASSERT(false == v.isReference());
@@ -482,12 +797,12 @@ class TestSymbolDatabase: public TestFixture {
 
     void test_isVariableDeclarationIdentifiesScopedDeclaration() {
         reset();
-        givenACodeSampleToTokenize ScopedDeclaration("::int x;");
-        const bool result = nullScope.isVariableDeclaration(ScopedDeclaration.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("::int x;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("x", vartok->str());
         ASSERT_EQUALS("int", typetok->str());
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(false == v.isPointer());
         ASSERT(false == v.isReference());
@@ -495,12 +810,12 @@ class TestSymbolDatabase: public TestFixture {
 
     void test_isVariableDeclarationIdentifiesStdDeclaration() {
         reset();
-        givenACodeSampleToTokenize StdDeclaration("std::string x;");
-        const bool result = nullScope.isVariableDeclaration(StdDeclaration.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("std::string x;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("x", vartok->str());
         ASSERT_EQUALS("string", typetok->str());
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(false == v.isPointer());
         ASSERT(false == v.isReference());
@@ -508,12 +823,12 @@ class TestSymbolDatabase: public TestFixture {
 
     void test_isVariableDeclarationIdentifiesScopedStdDeclaration() {
         reset();
-        givenACodeSampleToTokenize StdDeclaration("::std::string x;");
-        const bool result = nullScope.isVariableDeclaration(StdDeclaration.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("::std::string x;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("x", vartok->str());
         ASSERT_EQUALS("string", typetok->str());
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(false == v.isPointer());
         ASSERT(false == v.isReference());
@@ -521,54 +836,71 @@ class TestSymbolDatabase: public TestFixture {
 
     void test_isVariableDeclarationIdentifiesManyScopes() {
         reset();
-        givenACodeSampleToTokenize manyScopes("AA::BB::CC::DD::EE x;");
-        const bool result = nullScope.isVariableDeclaration(manyScopes.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("AA::BB::CC::DD::EE x;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("x", vartok->str());
         ASSERT_EQUALS("EE", typetok->str());
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(false == v.isPointer());
         ASSERT(false == v.isReference());
     }
 
     void test_isVariableDeclarationIdentifiesPointers() {
-        reset();
-        givenACodeSampleToTokenize pointer("int* p;");
-        const bool result1 = nullScope.isVariableDeclaration(pointer.tokens(), vartok, typetok);
-        ASSERT_EQUALS(true, result1);
-        ASSERT_EQUALS("p", vartok->str());
-        ASSERT_EQUALS("int", typetok->str());
-        Variable v1(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
-        ASSERT(false == v1.isArray());
-        ASSERT(true == v1.isPointer());
-        ASSERT(false == v1.isReference());
+        {
+            reset();
+            GET_SYMBOL_DB("int* p;");
+            const bool result1 = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
+            ASSERT_EQUALS(true, result1);
+            ASSERT_EQUALS("p", vartok->str());
+            ASSERT_EQUALS("int", typetok->str());
+            Variable v1(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
+            ASSERT(false == v1.isArray());
+            ASSERT(true == v1.isPointer());
+            ASSERT(false == v1.isReference());
+        }
+        {
+            reset();
+            SimpleTokenizer constpointer(*this);
+            ASSERT(constpointer.tokenize("const int* p;"));
+            Variable v2(constpointer.tokens()->tokAt(3), constpointer.tokens()->next(), constpointer.tokens()->tokAt(2), 0, AccessControl::Public, nullptr, nullptr, settings1);
+            ASSERT(false == v2.isArray());
+            ASSERT(true == v2.isPointer());
+            ASSERT(false == v2.isConst());
+            ASSERT(false == v2.isReference());
+        }
+        {
+            reset();
+            GET_SYMBOL_DB("int* const p;");
+            const bool result2 = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
+            ASSERT_EQUALS(true, result2);
+            ASSERT_EQUALS("p", vartok->str());
+            ASSERT_EQUALS("int", typetok->str());
+            Variable v3(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
+            ASSERT(false == v3.isArray());
+            ASSERT(true == v3.isPointer());
+            ASSERT(true == v3.isConst());
+            ASSERT(false == v3.isReference());
+        }
+    }
 
-        reset();
-        givenACodeSampleToTokenize constpointer("const int* p;");
-        Variable v2(constpointer.tokens()->tokAt(3), constpointer.tokens()->next(), constpointer.tokens()->tokAt(2), 0, AccessControl::Public, nullptr, nullptr, &settings1);
-        ASSERT(false == v2.isArray());
-        ASSERT(true == v2.isPointer());
-        ASSERT(false == v2.isConst());
-        ASSERT(false == v2.isReference());
+    void test_isVariableDeclarationIdentifiesPointers2() {
 
-        reset();
-        givenACodeSampleToTokenize pointerconst("int* const p;");
-        const bool result2 = nullScope.isVariableDeclaration(pointerconst.tokens(), vartok, typetok);
-        ASSERT_EQUALS(true, result2);
-        ASSERT_EQUALS("p", vartok->str());
-        ASSERT_EQUALS("int", typetok->str());
-        Variable v3(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
-        ASSERT(false == v3.isArray());
-        ASSERT(true == v3.isPointer());
-        ASSERT(true == v3.isConst());
-        ASSERT(false == v3.isReference());
+        GET_SYMBOL_DB("void slurpInManifest() {\n"
+                      "  std::string tmpiostring(*tI);\n"
+                      "  if(tmpiostring==\"infoonly\"){}\n"
+                      "}");
+
+        const Token *tok = Token::findsimplematch(tokenizer.tokens(), "tmpiostring ==");
+        ASSERT(tok->variable());
+        ASSERT(!tok->variable()->isPointer());
     }
 
     void test_isVariableDeclarationDoesNotIdentifyConstness() {
         reset();
-        givenACodeSampleToTokenize constness("const int* cp;");
-        const bool result = nullScope.isVariableDeclaration(constness.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("const int* cp;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(false, result);
         ASSERT(nullptr == vartok);
         ASSERT(nullptr == typetok);
@@ -576,12 +908,12 @@ class TestSymbolDatabase: public TestFixture {
 
     void test_isVariableDeclarationIdentifiesFirstOfManyVariables() {
         reset();
-        givenACodeSampleToTokenize multipleDeclaration("int first, second;");
-        const bool result = nullScope.isVariableDeclaration(multipleDeclaration.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("int first, second;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("first", vartok->str());
         ASSERT_EQUALS("int", typetok->str());
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(false == v.isPointer());
         ASSERT(false == v.isReference());
@@ -589,12 +921,12 @@ class TestSymbolDatabase: public TestFixture {
 
     void test_isVariableDeclarationIdentifiesScopedPointerDeclaration() {
         reset();
-        givenACodeSampleToTokenize manyScopes("AA::BB::CC::DD::EE* p;");
-        const bool result = nullScope.isVariableDeclaration(manyScopes.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("AA::BB::CC::DD::EE* p;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("p", vartok->str());
         ASSERT_EQUALS("EE", typetok->str());
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(true == v.isPointer());
         ASSERT(false == v.isReference());
@@ -602,12 +934,12 @@ class TestSymbolDatabase: public TestFixture {
 
     void test_isVariableDeclarationIdentifiesDeclarationWithIndirection() {
         reset();
-        givenACodeSampleToTokenize pointerToPointer("int** pp;");
-        const bool result = nullScope.isVariableDeclaration(pointerToPointer.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("int** pp;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("pp", vartok->str());
         ASSERT_EQUALS("int", typetok->str());
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(true == v.isPointer());
         ASSERT(false == v.isReference());
@@ -615,12 +947,12 @@ class TestSymbolDatabase: public TestFixture {
 
     void test_isVariableDeclarationIdentifiesDeclarationWithMultipleIndirection() {
         reset();
-        givenACodeSampleToTokenize pointerToPointer("int***** p;");
-        const bool result = nullScope.isVariableDeclaration(pointerToPointer.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("int***** p;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("p", vartok->str());
         ASSERT_EQUALS("int", typetok->str());
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(true == v.isPointer());
         ASSERT(false == v.isReference());
@@ -628,12 +960,12 @@ class TestSymbolDatabase: public TestFixture {
 
     void test_isVariableDeclarationIdentifiesArray() {
         reset();
-        givenACodeSampleToTokenize arr("::std::string v[3];");
-        const bool result = nullScope.isVariableDeclaration(arr.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("::std::string v[3];");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("v", vartok->str());
         ASSERT_EQUALS("string", typetok->str());
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(true == v.isArray());
         ASSERT(false == v.isPointer());
         ASSERT(false == v.isPointerArray());
@@ -642,12 +974,12 @@ class TestSymbolDatabase: public TestFixture {
 
     void test_isVariableDeclarationIdentifiesPointerArray() {
         reset();
-        givenACodeSampleToTokenize arr("A *a[5];");
-        const bool result = nullScope.isVariableDeclaration(arr.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("A *a[5];");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("a", vartok->str());
         ASSERT_EQUALS("A", typetok->str());
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isPointer());
         ASSERT(true == v.isArray());
         ASSERT(false == v.isPointerToArray());
@@ -655,14 +987,44 @@ class TestSymbolDatabase: public TestFixture {
         ASSERT(false == v.isReference());
     }
 
-    void test_isVariableDeclarationIdentifiesOfArrayPointers() {
+    void test_isVariableDeclarationIdentifiesOfArrayPointers1() {
+        reset();
+        GET_SYMBOL_DB("A (*a)[5];");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
+        ASSERT_EQUALS(true, result);
+        ASSERT_EQUALS("a", vartok->str());
+        ASSERT_EQUALS("A", typetok->str());
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
+        ASSERT(true == v.isPointer());
+        ASSERT(false == v.isArray());
+        ASSERT(true == v.isPointerToArray());
+        ASSERT(false == v.isPointerArray());
+        ASSERT(false == v.isReference());
+    }
+
+    void test_isVariableDeclarationIdentifiesOfArrayPointers2() {
+        reset();
+        GET_SYMBOL_DB("A (*const a)[5];");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
+        ASSERT_EQUALS(true, result);
+        ASSERT_EQUALS("a", vartok->str());
+        ASSERT_EQUALS("A", typetok->str());
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
+        ASSERT(true == v.isPointer());
+        ASSERT(false == v.isArray());
+        ASSERT(true == v.isPointerToArray());
+        ASSERT(false == v.isPointerArray());
+        ASSERT(false == v.isReference());
+    }
+
+    void test_isVariableDeclarationIdentifiesOfArrayPointers3() {
         reset();
-        givenACodeSampleToTokenize arr("A (*a)[5];");
-        const bool result = nullScope.isVariableDeclaration(arr.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("A (** a)[5];");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("a", vartok->str());
         ASSERT_EQUALS("A", typetok->str());
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(true == v.isPointer());
         ASSERT(false == v.isArray());
         ASSERT(true == v.isPointerToArray());
@@ -670,14 +1032,30 @@ class TestSymbolDatabase: public TestFixture {
         ASSERT(false == v.isReference());
     }
 
+    void test_isVariableDeclarationIdentifiesArrayOfFunctionPointers() {
+        reset();
+        GET_SYMBOL_DB("int (*a[])(int) = { g };"); // #11596
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
+        ASSERT_EQUALS(true, result);
+        ASSERT_EQUALS("a", vartok->str());
+        ASSERT_EQUALS("int", typetok->str());
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
+        ASSERT(false == v.isPointer());
+        ASSERT(true == v.isArray());
+        ASSERT(false == v.isPointerToArray());
+        ASSERT(true == v.isPointerArray());
+        ASSERT(false == v.isReference());
+        ASSERT(true == v.isInit());
+    }
+
     void isVariableDeclarationIdentifiesTemplatedPointerVariable() {
         reset();
-        givenACodeSampleToTokenize var("std::set<char>* chars;");
-        const bool result = nullScope.isVariableDeclaration(var.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("std::set<char>* chars;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("chars", vartok->str());
         ASSERT_EQUALS("set", typetok->str());
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(true == v.isPointer());
         ASSERT(false == v.isReference());
@@ -685,12 +1063,12 @@ class TestSymbolDatabase: public TestFixture {
 
     void isVariableDeclarationIdentifiesTemplatedPointerToPointerVariable() {
         reset();
-        givenACodeSampleToTokenize var("std::deque<int>*** ints;");
-        const bool result = nullScope.isVariableDeclaration(var.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("std::deque<int>*** ints;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("ints", vartok->str());
         ASSERT_EQUALS("deque", typetok->str());
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(true == v.isPointer());
         ASSERT(false == v.isReference());
@@ -698,12 +1076,12 @@ class TestSymbolDatabase: public TestFixture {
 
     void isVariableDeclarationIdentifiesTemplatedArrayVariable() {
         reset();
-        givenACodeSampleToTokenize var("std::deque<int> ints[3];");
-        const bool result = nullScope.isVariableDeclaration(var.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("std::deque<int> ints[3];");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("ints", vartok->str());
         ASSERT_EQUALS("deque", typetok->str());
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(true == v.isArray());
         ASSERT(false == v.isPointer());
         ASSERT(false == v.isReference());
@@ -711,12 +1089,12 @@ class TestSymbolDatabase: public TestFixture {
 
     void isVariableDeclarationIdentifiesTemplatedVariable() {
         reset();
-        givenACodeSampleToTokenize var("std::vector<int> ints;");
-        const bool result = nullScope.isVariableDeclaration(var.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("std::vector<int> ints;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("ints", vartok->str());
         ASSERT_EQUALS("vector", typetok->str());
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(false == v.isPointer());
         ASSERT(false == v.isReference());
@@ -724,12 +1102,12 @@ class TestSymbolDatabase: public TestFixture {
 
     void isVariableDeclarationIdentifiesTemplatedVariableIterator() {
         reset();
-        givenACodeSampleToTokenize var("std::list<int>::const_iterator floats;");
-        const bool result = nullScope.isVariableDeclaration(var.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("std::list<int>::const_iterator floats;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("floats", vartok->str());
         ASSERT_EQUALS("const_iterator", typetok->str());
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(false == v.isPointer());
         ASSERT(false == v.isReference());
@@ -737,66 +1115,70 @@ class TestSymbolDatabase: public TestFixture {
 
     void isVariableDeclarationIdentifiesNestedTemplateVariable() {
         reset();
-        givenACodeSampleToTokenize var("std::deque<std::set<int> > intsets;");
-        const bool result = nullScope.isVariableDeclaration(var.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("std::deque<std::set<int> > intsets;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
         ASSERT_EQUALS("intsets", vartok->str());
         ASSERT_EQUALS("deque", typetok->str());
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(false == v.isPointer());
         ASSERT(false == v.isReference());
     }
 
     void isVariableDeclarationIdentifiesReference() {
-        reset();
-        givenACodeSampleToTokenize var1("int& foo;");
-        const bool result1 = nullScope.isVariableDeclaration(var1.tokens(), vartok, typetok);
-        ASSERT_EQUALS(true, result1);
-        Variable v1(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
-        ASSERT(false == v1.isArray());
-        ASSERT(false == v1.isPointer());
-        ASSERT(true == v1.isReference());
-
-        reset();
-        givenACodeSampleToTokenize var2("foo*& bar;");
-        const bool result2 = nullScope.isVariableDeclaration(var2.tokens(), vartok, typetok);
-        ASSERT_EQUALS(true, result2);
-        Variable v2(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
-        ASSERT(false == v2.isArray());
-        ASSERT(true == v2.isPointer());
-        ASSERT(true == v2.isReference());
-
-        reset();
-        givenACodeSampleToTokenize var3("std::vector<int>& foo;");
-        const bool result3 = nullScope.isVariableDeclaration(var3.tokens(), vartok, typetok);
-        ASSERT_EQUALS(true, result3);
-        Variable v3(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
-        ASSERT(false == v3.isArray());
-        ASSERT(false == v3.isPointer());
-        ASSERT(true == v3.isReference());
+        {
+            reset();
+            GET_SYMBOL_DB("int& foo;");
+            const bool result1 = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
+            ASSERT_EQUALS(true, result1);
+            Variable v1(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
+            ASSERT(false == v1.isArray());
+            ASSERT(false == v1.isPointer());
+            ASSERT(true == v1.isReference());
+        }
+        {
+            reset();
+            GET_SYMBOL_DB("foo*& bar;");
+            const bool result2 = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
+            ASSERT_EQUALS(true, result2);
+            Variable v2(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
+            ASSERT(false == v2.isArray());
+            ASSERT(true == v2.isPointer());
+            ASSERT(true == v2.isReference());
+        }
+        {
+            reset();
+            GET_SYMBOL_DB("std::vector<int>& foo;");
+            const bool result3 = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
+            ASSERT_EQUALS(true, result3);
+            Variable v3(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
+            ASSERT(false == v3.isArray());
+            ASSERT(false == v3.isPointer());
+            ASSERT(true == v3.isReference());
+        }
     }
 
     void isVariableDeclarationDoesNotIdentifyTemplateClass() {
         reset();
-        givenACodeSampleToTokenize var("template <class T> class SomeClass{};");
-        const bool result = nullScope.isVariableDeclaration(var.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("template <class T> class SomeClass{};");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(false, result);
     }
 
     void isVariableDeclarationDoesNotIdentifyCppCast() {
         reset();
-        givenACodeSampleToTokenize var("reinterpret_cast <char *> (code)[0] = 0;");
-        const bool result = nullScope.isVariableDeclaration(var.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("reinterpret_cast <char *> (code)[0] = 0;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(false, result);
     }
 
     void isVariableDeclarationPointerConst() {
         reset();
-        givenACodeSampleToTokenize var("std::string const* s;");
-        const bool result = nullScope.isVariableDeclaration(var.tokens()->next(), vartok, typetok);
+        GET_SYMBOL_DB("std::string const* s;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens()->next(), vartok, typetok);
         ASSERT_EQUALS(true, result);
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(true == v.isPointer());
         ASSERT(false == v.isReference());
@@ -804,15 +1186,15 @@ class TestSymbolDatabase: public TestFixture {
 
     void isVariableDeclarationRValueRef() {
         reset();
-        givenACodeSampleToTokenize var("int&& i;");
-        const bool result = nullScope.isVariableDeclaration(var.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("int&& i;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(false == v.isPointer());
         ASSERT(true == v.isReference());
         ASSERT(true == v.isRValueReference());
-        ASSERT(var.tokens()->tokAt(2)->scope() != nullptr);
+        ASSERT(tokenizer.tokens()->tokAt(2)->scope() != nullptr);
     }
 
     void isVariableDeclarationDoesNotIdentifyCase() {
@@ -827,9 +1209,26 @@ class TestSymbolDatabase: public TestFixture {
         ASSERT_EQUALS("a", b->typeStartToken()->str());
     }
 
+    void isVariableDeclarationIf() {
+        GET_SYMBOL_DB("void foo() {\n"
+                      "    for (auto& elem : items) {\n"
+                      "        if (auto x = bar()) { int y = 3; }\n"
+                      "    }\n"
+                      "}");
+        const Token *x = Token::findsimplematch(tokenizer.tokens(), "x");
+        ASSERT(x);
+        ASSERT(x->varId());
+        ASSERT(x->variable());
+
+        const Token *y = Token::findsimplematch(tokenizer.tokens(), "y");
+        ASSERT(y);
+        ASSERT(y->varId());
+        ASSERT(y->variable());
+    }
+
     void VariableValueType1() {
         GET_SYMBOL_DB("typedef uint8_t u8;\n"
-                      "static u8 x;\n");
+                      "static u8 x;");
         const Variable* x = db->getVariableFromVarId(1);
         ASSERT_EQUALS("x", x->name());
         ASSERT(x->valueType()->isIntegral());
@@ -837,7 +1236,7 @@ class TestSymbolDatabase: public TestFixture {
 
     void VariableValueType2() {
         GET_SYMBOL_DB("using u8 = uint8_t;\n"
-                      "static u8 x;\n");
+                      "static u8 x;");
         const Variable* x = db->getVariableFromVarId(1);
         ASSERT_EQUALS("x", x->name());
         ASSERT(x->valueType()->isIntegral());
@@ -846,7 +1245,7 @@ class TestSymbolDatabase: public TestFixture {
     void VariableValueType3() {
         // std::string::size_type
         {
-            GET_SYMBOL_DB("void f(std::string::size_type x);\n");
+            GET_SYMBOL_DB("void f(std::string::size_type x);");
             const Variable* const x = db->getVariableFromVarId(1);
             ASSERT_EQUALS("x", x->name());
             // TODO: Configure std::string::size_type somehow.
@@ -855,7 +1254,7 @@ class TestSymbolDatabase: public TestFixture {
         }
         // std::wstring::size_type
         {
-            GET_SYMBOL_DB("void f(std::wstring::size_type x);\n");
+            GET_SYMBOL_DB("void f(std::wstring::size_type x);");
             const Variable* const x = db->getVariableFromVarId(1);
             ASSERT_EQUALS("x", x->name());
             // TODO: Configure std::wstring::size_type somehow.
@@ -864,7 +1263,7 @@ class TestSymbolDatabase: public TestFixture {
         }
         // std::u16string::size_type
         {
-            GET_SYMBOL_DB("void f(std::u16string::size_type x);\n");
+            GET_SYMBOL_DB("void f(std::u16string::size_type x);");
             const Variable* const x = db->getVariableFromVarId(1);
             ASSERT_EQUALS("x", x->name());
             // TODO: Configure std::u16string::size_type somehow.
@@ -873,7 +1272,7 @@ class TestSymbolDatabase: public TestFixture {
         }
         // std::u32string::size_type
         {
-            GET_SYMBOL_DB("void f(std::u32string::size_type x);\n");
+            GET_SYMBOL_DB("void f(std::u32string::size_type x);");
             const Variable* const x = db->getVariableFromVarId(1);
             ASSERT_EQUALS("x", x->name());
             // TODO: Configure std::u32string::size_type somehow.
@@ -882,6 +1281,261 @@ class TestSymbolDatabase: public TestFixture {
         }
     }
 
+    void VariableValueType4() {
+        GET_SYMBOL_DB("class C {\n"
+                      "public:\n"
+                      "  std::shared_ptr<C> x;\n"
+                      "};");
+
+        const Variable* const x = db->getVariableFromVarId(1);
+        ASSERT(x->valueType());
+        ASSERT(x->valueType()->smartPointerType);
+    }
+
+    void VariableValueType5() {
+        GET_SYMBOL_DB("class C {};\n"
+                      "void foo(std::shared_ptr<C>* p) {}");
+
+        const Variable* const p = db->getVariableFromVarId(1);
+        ASSERT(p->valueType());
+        ASSERT(p->valueType()->smartPointerTypeToken);
+        ASSERT(p->valueType()->pointer == 1);
+    }
+
+    void VariableValueType6() {
+        GET_SYMBOL_DB("struct Data{};\n"
+                      "void foo() { std::unique_ptr<Data> data = std::unique_ptr<Data>(new Data); }");
+
+        const Token* check = Token::findsimplematch(tokenizer.tokens(), "( new");
+        ASSERT(check);
+        ASSERT(check->valueType());
+        ASSERT(check->valueType()->smartPointerTypeToken);
+    }
+
+    void VariableValueTypeReferences() {
+        {
+            GET_SYMBOL_DB("void foo(int x) {}\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 0);
+            ASSERT(p->valueType()->constness == 0);
+            ASSERT(p->valueType()->volatileness == 0);
+            ASSERT(p->valueType()->reference == Reference::None);
+        }
+
+        {
+            GET_SYMBOL_DB("void foo(volatile int x) {}\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 0);
+            ASSERT(p->valueType()->constness == 0);
+            ASSERT(p->valueType()->volatileness == 1);
+            ASSERT(p->valueType()->reference == Reference::None);
+        }
+        {
+            GET_SYMBOL_DB("void foo(int* x) {}\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 1);
+            ASSERT(p->valueType()->constness == 0);
+            ASSERT(p->valueType()->volatileness == 0);
+            ASSERT(p->valueType()->reference == Reference::None);
+        }
+        {
+            GET_SYMBOL_DB("void foo(int& x) {}\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 0);
+            ASSERT(p->valueType()->constness == 0);
+            ASSERT(p->valueType()->volatileness == 0);
+            ASSERT(p->valueType()->reference == Reference::LValue);
+        }
+        {
+            GET_SYMBOL_DB("void foo(int&& x) {}\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 0);
+            ASSERT(p->valueType()->constness == 0);
+            ASSERT(p->valueType()->volatileness == 0);
+            ASSERT(p->valueType()->reference == Reference::RValue);
+        }
+        {
+            GET_SYMBOL_DB("void foo(int*& x) {}\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 1);
+            ASSERT(p->valueType()->constness == 0);
+            ASSERT(p->valueType()->volatileness == 0);
+            ASSERT(p->valueType()->reference == Reference::LValue);
+        }
+        {
+            GET_SYMBOL_DB("void foo(int*&& x) {}\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 1);
+            ASSERT(p->valueType()->constness == 0);
+            ASSERT(p->valueType()->volatileness == 0);
+            ASSERT(p->valueType()->reference == Reference::RValue);
+        }
+        {
+            GET_SYMBOL_DB("void foo(int**& x) {}\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 2);
+            ASSERT(p->valueType()->constness == 0);
+            ASSERT(p->valueType()->volatileness == 0);
+            ASSERT(p->valueType()->reference == Reference::LValue);
+        }
+        {
+            GET_SYMBOL_DB("void foo(int**&& x) {}\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 2);
+            ASSERT(p->valueType()->constness == 0);
+            ASSERT(p->valueType()->volatileness == 0);
+            ASSERT(p->valueType()->reference == Reference::RValue);
+        }
+        {
+            GET_SYMBOL_DB("void foo(const int& x) {}\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 0);
+            ASSERT(p->valueType()->constness == 1);
+            ASSERT(p->valueType()->volatileness == 0);
+            ASSERT(p->valueType()->reference == Reference::LValue);
+        }
+        {
+            GET_SYMBOL_DB("void foo(const int&& x) {}\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 0);
+            ASSERT(p->valueType()->constness == 1);
+            ASSERT(p->valueType()->volatileness == 0);
+            ASSERT(p->valueType()->reference == Reference::RValue);
+        }
+        {
+            GET_SYMBOL_DB("void foo(const int*& x) {}\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 1);
+            ASSERT(p->valueType()->constness == 1);
+            ASSERT(p->valueType()->volatileness == 0);
+            ASSERT(p->valueType()->reference == Reference::LValue);
+        }
+        {
+            GET_SYMBOL_DB("void foo(const int*&& x) {}\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 1);
+            ASSERT(p->valueType()->constness == 1);
+            ASSERT(p->valueType()->volatileness == 0);
+            ASSERT(p->valueType()->reference == Reference::RValue);
+        }
+        {
+            GET_SYMBOL_DB("void foo(int* const & x) {}\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 1);
+            ASSERT(p->valueType()->constness == 2);
+            ASSERT(p->valueType()->volatileness == 0);
+            ASSERT(p->valueType()->reference == Reference::LValue);
+        }
+        {
+            GET_SYMBOL_DB("void foo(int* const && x) {}\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 1);
+            ASSERT(p->valueType()->constness == 2);
+            ASSERT(p->valueType()->volatileness == 0);
+            ASSERT(p->valueType()->reference == Reference::RValue);
+        }
+        {
+            GET_SYMBOL_DB("extern const volatile int* test[];\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 1);
+            ASSERT(p->valueType()->constness == 1);
+            ASSERT(p->valueType()->volatileness == 1);
+            ASSERT(p->valueType()->reference == Reference::None);
+        }
+        {
+            GET_SYMBOL_DB("extern const int* volatile test[];\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 1);
+            ASSERT(p->valueType()->constness == 1);
+            ASSERT(p->valueType()->volatileness == 2);
+            ASSERT(p->valueType()->reference == Reference::None);
+        }
+        {
+            GET_SYMBOL_DB_C("typedef unsigned char uint8_t;\n uint8_t ubVar = 0;\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 0);
+            ASSERT(p->valueType()->constness == 0);
+            ASSERT(p->valueType()->volatileness == 0);
+            ASSERT(p->valueType()->originalTypeName == "uint8_t");
+            ASSERT(p->valueType()->reference == Reference::None);
+        }
+        {
+            GET_SYMBOL_DB_C("typedef enum eEnumDef {CPPCHECK=0}eEnum_t;\n eEnum_t eVar = CPPCHECK;\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 0);
+            ASSERT(p->valueType()->constness == 0);
+            ASSERT(p->valueType()->volatileness == 0);
+            ASSERT(p->valueType()->originalTypeName == "eEnum_t");
+            ASSERT(p->valueType()->reference == Reference::None);
+        }
+        {
+            GET_SYMBOL_DB_C("typedef unsigned char uint8_t;\n typedef struct stStructDef {uint8_t ubTest;}stStruct_t;\n stStruct_t stVar;\n");
+            const Variable* p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 0);
+            ASSERT(p->valueType()->constness == 0);
+            ASSERT(p->valueType()->volatileness == 0);
+            ASSERT(p->valueType()->originalTypeName == "uint8_t");
+            ASSERT(p->valueType()->reference == Reference::None);
+            p = db->getVariableFromVarId(2);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 0);
+            ASSERT(p->valueType()->constness == 0);
+            ASSERT(p->valueType()->volatileness == 0);
+            ASSERT(p->valueType()->originalTypeName == "stStruct_t");
+            ASSERT(p->valueType()->reference == Reference::None);
+        }
+        {
+            GET_SYMBOL_DB_C("typedef int (*ubFunctionPointer_fp)(int);\n void test(ubFunctionPointer_fp functionPointer);\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 1);
+            ASSERT(p->valueType()->constness == 0);
+            ASSERT(p->valueType()->volatileness == 0);
+            ASSERT(p->valueType()->originalTypeName == "ubFunctionPointer_fp");
+            ASSERT(p->valueType()->reference == Reference::None);
+        }
+    }
+
+    void VariableValueTypeTemplate() {
+        {
+            GET_SYMBOL_DB("template <class T>\n" // #12393
+                          "struct S {\n"
+                          "    struct U {\n"
+                          "        S<T>* p;\n"
+                          "    };\n"
+                          "    U u;\n"
+                          "};\n");
+            const Variable* const p = db->getVariableFromVarId(1);
+            ASSERT_EQUALS(p->name(), "p");
+            ASSERT(p->valueType());
+            ASSERT(p->valueType()->pointer == 1);
+            ASSERT(p->valueType()->constness == 0);
+            ASSERT(p->valueType()->reference == Reference::None);
+            ASSERT_EQUALS(p->scope()->className, "U");
+            ASSERT_EQUALS(p->typeScope()->className, "S");
+        }
+    }
+
     void findVariableType1() {
         GET_SYMBOL_DB("class A {\n"
                       "public:\n"
@@ -895,8 +1549,7 @@ class TestSymbolDatabase: public TestFixture {
                       "    b.x = 1;\n"
                       "}");
         ASSERT(db != nullptr);
-        if (!db)
-            return;
+
         const Variable* bvar = db->getVariableFromVarId(1);
         ASSERT_EQUALS("b", bvar->name());
         ASSERT(bvar->type() != nullptr);
@@ -922,8 +1575,7 @@ class TestSymbolDatabase: public TestFixture {
                       "    c.x = 1;\n"
                       "}");
         ASSERT(db != nullptr);
-        if (!db)
-            return;
+
         const Variable* cvar = db->getVariableFromVarId(3);
         ASSERT_EQUALS("c", cvar->name());
         ASSERT(cvar->type() != nullptr);
@@ -948,6 +1600,18 @@ class TestSymbolDatabase: public TestFixture {
         ASSERT(avar && avar->type() != nullptr);
     }
 
+    void findVariableTypeExternC() {
+        GET_SYMBOL_DB("extern \"C\" { typedef int INT; }\n"
+                      "void bar() {\n"
+                      "    INT x = 3;\n"
+                      "}");
+        (void)db;
+        const Variable* avar = Token::findsimplematch(tokenizer.tokens(), "x")->variable();
+        ASSERT(avar);
+        ASSERT(avar->valueType() != nullptr);
+        ASSERT(avar->valueType()->str() == "signed int");
+    }
+
     void rangeBasedFor() {
         GET_SYMBOL_DB("void reset() {\n"
                       "    for(auto& e : array)\n"
@@ -955,24 +1619,20 @@ class TestSymbolDatabase: public TestFixture {
                       "}");
 
         ASSERT(db != nullptr);
-        if (!db)
-            return;
-        ASSERT(db->scopeList.back().type == Scope::eFor);
+
+        ASSERT(db->scopeList.back().type == ScopeType::eFor);
         ASSERT_EQUALS(2, db->variableList().size());
-        if (db->variableList().size() < 2)
-            return;
+
         const Variable* e = db->getVariableFromVarId(1);
         ASSERT(e && e->isReference() && e->isLocal());
     }
     void isVariableStlType() {
         {
             reset();
-            std::istringstream code("std::string s;");
-            TokenList list(nullptr);
-            list.createTokens(code, "test.cpp");
-            const bool result = nullScope.isVariableDeclaration(list.front(), vartok, typetok);
+            GET_SYMBOL_DB("std::string s;");
+            const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
             ASSERT_EQUALS(true, result);
-            Variable v(vartok, list.front(), list.back(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+            Variable v(vartok, tokenizer.tokens(), tokenizer.list.back(), 0, AccessControl::Public, nullptr, nullptr, settings1);
             static const std::set<std::string> types = { "string", "wstring" };
             static const std::set<std::string> no_types = { "set" };
             ASSERT_EQUALS(true, v.isStlType());
@@ -982,13 +1642,10 @@ class TestSymbolDatabase: public TestFixture {
         }
         {
             reset();
-            std::istringstream code("std::vector<int> v;");
-            TokenList list(nullptr);
-            list.createTokens(code, "test.cpp");
-            list.front()->tokAt(3)->link(list.front()->tokAt(5));
-            const bool result = nullScope.isVariableDeclaration(list.front(), vartok, typetok);
+            GET_SYMBOL_DB("std::vector<int> v;");
+            const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
             ASSERT_EQUALS(true, result);
-            Variable v(vartok, list.front(), list.back(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+            Variable v(vartok, tokenizer.tokens(), tokenizer.list.back(), 0, AccessControl::Public, nullptr, nullptr, settings1);
             static const std::set<std::string> types = { "bitset", "set", "vector", "wstring" };
             static const std::set<std::string> no_types = { "bitset", "map", "set" };
             ASSERT_EQUALS(true, v.isStlType());
@@ -998,12 +1655,10 @@ class TestSymbolDatabase: public TestFixture {
         }
         {
             reset();
-            std::istringstream code("SomeClass s;");
-            TokenList list(nullptr);
-            list.createTokens(code, "test.cpp");
-            const bool result = nullScope.isVariableDeclaration(list.front(), vartok, typetok);
+            GET_SYMBOL_DB("SomeClass s;");
+            const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
             ASSERT_EQUALS(true, result);
-            Variable v(vartok, list.front(), list.back(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+            Variable v(vartok, tokenizer.tokens(), tokenizer.list.back(), 0, AccessControl::Public, nullptr, nullptr, settings1);
             static const std::set<std::string> types = { "bitset", "set", "vector" };
             ASSERT_EQUALS(false, v.isStlType());
             ASSERT_EQUALS(false, v.isStlType(types));
@@ -1013,10 +1668,10 @@ class TestSymbolDatabase: public TestFixture {
 
     void isVariablePointerToConstPointer() {
         reset();
-        givenACodeSampleToTokenize var("char* const * s;");
-        bool result = nullScope.isVariableDeclaration(var.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("char* const * s;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(true == v.isPointer());
         ASSERT(false == v.isReference());
@@ -1024,10 +1679,10 @@ class TestSymbolDatabase: public TestFixture {
 
     void isVariablePointerToVolatilePointer() {
         reset();
-        givenACodeSampleToTokenize var("char* volatile * s;");
-        bool result = nullScope.isVariableDeclaration(var.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("char* volatile * s;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(true == v.isPointer());
         ASSERT(false == v.isReference());
@@ -1035,10 +1690,10 @@ class TestSymbolDatabase: public TestFixture {
 
     void isVariablePointerToConstVolatilePointer() {
         reset();
-        givenACodeSampleToTokenize var("char* const volatile * s;");
-        bool result = nullScope.isVariableDeclaration(var.tokens(), vartok, typetok);
+        GET_SYMBOL_DB("char* const volatile * s;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens(), vartok, typetok);
         ASSERT_EQUALS(true, result);
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(true == v.isPointer());
         ASSERT(false == v.isReference());
@@ -1046,15 +1701,96 @@ class TestSymbolDatabase: public TestFixture {
 
     void isVariableMultiplePointersAndQualifiers() {
         reset();
-        givenACodeSampleToTokenize var("const char* const volatile * const volatile * const volatile * const volatile s;");
-        bool result = nullScope.isVariableDeclaration(var.tokens()->next(), vartok, typetok);
+        GET_SYMBOL_DB("const char* const volatile * const volatile * const volatile * const volatile s;");
+        const bool result = db->scopeList.front().isVariableDeclaration(tokenizer.tokens()->next(), vartok, typetok);
         ASSERT_EQUALS(true, result);
-        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, &settings1);
+        Variable v(vartok, typetok, vartok->previous(), 0, AccessControl::Public, nullptr, nullptr, settings1);
         ASSERT(false == v.isArray());
         ASSERT(true == v.isPointer());
         ASSERT(false == v.isReference());
     }
 
+    void variableVolatile() {
+        GET_SYMBOL_DB("std::atomic<int> x;\n"
+                      "volatile int y;");
+
+        const Token *x = Token::findsimplematch(tokenizer.tokens(), "x");
+        ASSERT(x);
+        ASSERT(x->variable());
+        ASSERT(x->variable()->isVolatile());
+
+        const Token *y = Token::findsimplematch(tokenizer.tokens(), "y");
+        ASSERT(y);
+        ASSERT(y->variable());
+        ASSERT(y->variable()->isVolatile());
+    }
+
+    void variableConstexpr() {
+        GET_SYMBOL_DB("constexpr int x = 16;");
+
+        const Token *x = Token::findsimplematch(tokenizer.tokens(), "x");
+        ASSERT(x);
+        ASSERT(x->variable());
+        ASSERT(x->variable()->isConst());
+        ASSERT(x->variable()->isStatic());
+        ASSERT(x->valueType());
+        ASSERT(x->valueType()->pointer == 0);
+        ASSERT(x->valueType()->constness == 1);
+        ASSERT(x->valueType()->reference == Reference::None);
+    }
+
+    void isVariableDecltype() {
+        GET_SYMBOL_DB("int x;\n"
+                      "decltype(x) a;\n"
+                      "const decltype(x) b;\n"
+                      "decltype(x) *c;\n");
+        ASSERT(db);
+        ASSERT_EQUALS(4, db->scopeList.front().varlist.size());
+
+        const Variable *a = Token::findsimplematch(tokenizer.tokens(), "a")->variable();
+        ASSERT(a);
+        ASSERT_EQUALS("a", a->name());
+        ASSERT(a->valueType());
+        ASSERT_EQUALS("signed int", a->valueType()->str());
+
+        const Variable *b = Token::findsimplematch(tokenizer.tokens(), "b")->variable();
+        ASSERT(b);
+        ASSERT_EQUALS("b", b->name());
+        ASSERT(b->valueType());
+        ASSERT_EQUALS("const signed int", b->valueType()->str());
+
+        const Variable *c = Token::findsimplematch(tokenizer.tokens(), "c")->variable();
+        ASSERT(c);
+        ASSERT_EQUALS("c", c->name());
+        ASSERT(c->valueType());
+        ASSERT_EQUALS("signed int *", c->valueType()->str());
+    }
+
+    void isVariableAlignas() {
+        GET_SYMBOL_DB_C("extern alignas(16) int x;\n"
+                        "alignas(16) int x;\n");
+        ASSERT(db);
+        ASSERT_EQUALS(2, db->scopeList.front().varlist.size());
+        const Variable *x1 = Token::findsimplematch(tokenizer.tokens(), "x")->variable();
+        ASSERT(x1 && Token::simpleMatch(x1->typeStartToken(), "int x ;"));
+    }
+
+    void memberVar1() {
+        GET_SYMBOL_DB("struct Foo {\n"
+                      "    int x;\n"
+                      "};\n"
+                      "struct Bar : public Foo {};\n"
+                      "void f() {\n"
+                      "    struct Bar bar;\n"
+                      "    bar.x = 123;\n"  // <- x should get a variable() pointer
+                      "}");
+
+        ASSERT(db != nullptr);
+        const Token *tok = Token::findsimplematch(tokenizer.tokens(), "x =");
+        ASSERT(tok->variable());
+        ASSERT(Token::simpleMatch(tok->variable()->typeStartToken(), "int x ;"));
+    }
+
     void arrayMemberVar1() {
         GET_SYMBOL_DB("struct Foo {\n"
                       "    int x;\n"
@@ -1103,6 +1839,19 @@ class TestSymbolDatabase: public TestFixture {
         ASSERT(tok && tok->varId() == 3U); // It's possible to set a varId
     }
 
+    void arrayMemberVar4() {
+        GET_SYMBOL_DB("struct S { unsigned char* s; };\n"
+                      "struct T { S s[38]; };\n"
+                      "void f(T* t) {\n"
+                      "    t->s;\n"
+                      "}\n");
+        const Token *tok = Token::findsimplematch(tokenizer.tokens(), ". s");
+        tok = tok ? tok->next() : nullptr;
+        ASSERT(db != nullptr);
+        ASSERT(tok && tok->variable() && Token::simpleMatch(tok->variable()->typeStartToken(), "S s [ 38 ] ;"));
+        ASSERT(tok && tok->varId() == 4U);
+    }
+
     void staticMemberVar() {
         GET_SYMBOL_DB("class Foo {\n"
                       "    static const double d;\n"
@@ -1116,139 +1865,134 @@ class TestSymbolDatabase: public TestFixture {
 
     void getVariableFromVarIdBoundsCheck() {
         GET_SYMBOL_DB("int x;\n"
-                      "int y;\n");
+                      "int y;");
 
         const Variable* v = db->getVariableFromVarId(2);
         // three elements: varId 0 also counts via a fake-entry
         ASSERT(v && db->variableList().size() == 3);
 
-        ASSERT_THROW(db->getVariableFromVarId(3), std::out_of_range);
+        // TODO: we should provide our own error message
+#ifdef _MSC_VER
+        ASSERT_THROW_EQUALS(db->getVariableFromVarId(3), std::out_of_range, "invalid vector subscript");
+#elif !defined(_LIBCPP_VERSION)
+        ASSERT_THROW_EQUALS(db->getVariableFromVarId(3), std::out_of_range, "vector::_M_range_check: __n (which is 3) >= this->size() (which is 3)");
+#else
+        ASSERT_THROW_EQUALS(db->getVariableFromVarId(3), std::out_of_range, "vector");
+#endif
     }
 
     void hasRegularFunction() {
-        GET_SYMBOL_DB("void func() { }\n")
+        GET_SYMBOL_DB("void func() { }");
 
         // 2 scopes: Global and Function
         ASSERT(db && db->scopeList.size() == 2);
 
-        if (db) {
-            const Scope *scope = findFunctionScopeByToken(db, tokenizer.tokens()->next());
+        const Scope *scope = findFunctionScopeByToken(db, tokenizer.tokens()->next());
 
-            ASSERT(scope && scope->className == "func");
-            if (!scope)
-                return;
-            ASSERT(scope->functionOf == nullptr);
+        ASSERT(scope && scope->className == "func");
 
-            const Function *function = findFunctionByName("func", &db->scopeList.front());
+        ASSERT(scope->functionOf == nullptr);
 
-            ASSERT(function && function->token->str() == "func");
-            ASSERT(function && function->token == tokenizer.tokens()->next());
-            ASSERT(function && function->hasBody());
-            ASSERT(function && function->functionScope == scope && scope->function == function && function->nestedIn != scope);
-            ASSERT(function && function->retDef == tokenizer.tokens());
-        }
+        const Function *function = findFunctionByName("func", &db->scopeList.front());
+
+        ASSERT(function && function->token->str() == "func");
+        ASSERT(function && function->token == tokenizer.tokens()->next());
+        ASSERT(function && function->hasBody());
+        ASSERT(function && function->functionScope == scope && scope->function == function && function->nestedIn != scope);
+        ASSERT(function && function->retDef == tokenizer.tokens());
     }
 
     void hasRegularFunction_trailingReturnType() {
-        GET_SYMBOL_DB("auto func() -> int { }")
+        GET_SYMBOL_DB("auto func() -> int { }");
 
         // 2 scopes: Global and Function
         ASSERT(db && db->scopeList.size() == 2);
 
-        if (db) {
-            const Scope *scope = findFunctionScopeByToken(db, tokenizer.tokens()->next());
+        const Scope *scope = findFunctionScopeByToken(db, tokenizer.tokens()->next());
 
-            ASSERT(scope && scope->className == "func");
-            if (!scope)
-                return;
-            ASSERT(scope->functionOf == nullptr);
+        ASSERT(scope && scope->className == "func");
 
-            const Function *function = findFunctionByName("func", &db->scopeList.front());
+        ASSERT(scope->functionOf == nullptr);
 
-            ASSERT(function && function->token->str() == "func");
-            ASSERT(function && function->token == tokenizer.tokens()->next());
-            ASSERT(function && function->hasBody());
-            ASSERT(function && function->functionScope == scope && scope->function == function && function->nestedIn != scope);
-            ASSERT(function && function->retDef == tokenizer.tokens()->tokAt(5));
-        }
+        const Function *function = findFunctionByName("func", &db->scopeList.front());
+
+        ASSERT(function && function->token->str() == "func");
+        ASSERT(function && function->token == tokenizer.tokens()->next());
+        ASSERT(function && function->hasBody());
+        ASSERT(function && function->functionScope == scope && scope->function == function && function->nestedIn != scope);
+        ASSERT(function && function->retDef == tokenizer.tokens()->tokAt(5));
     }
 
     void hasInlineClassFunction() {
-        GET_SYMBOL_DB("class Fred { void func() { } };\n")
+        GET_SYMBOL_DB("class Fred { void func() { } };");
 
         // 3 scopes: Global, Class, and Function
         ASSERT(db && db->scopeList.size() == 3);
 
-        if (db) {
-            const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");
+        const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");
 
-            const Scope *scope = findFunctionScopeByToken(db, functionToken);
+        const Scope *scope = findFunctionScopeByToken(db, functionToken);
 
-            ASSERT(scope && scope->className == "func");
-            if (!scope)
-                return;
-            ASSERT(scope->functionOf && scope->functionOf == db->findScopeByName("Fred"));
+        ASSERT(scope && scope->className == "func");
 
-            const Function *function = findFunctionByName("func", &db->scopeList.back());
+        ASSERT(scope->functionOf && scope->functionOf == db->findScopeByName("Fred"));
 
-            ASSERT(function && function->token->str() == "func");
-            ASSERT(function && function->token == functionToken);
-            ASSERT(function && function->hasBody() && function->isInline());
-            ASSERT(function && function->functionScope == scope && scope->function == function && function->nestedIn == db->findScopeByName("Fred"));
-            ASSERT(function && function->retDef == functionToken->previous());
+        const Function *function = findFunctionByName("func", &db->scopeList.back());
 
-            ASSERT(db && db->findScopeByName("Fred") && db->findScopeByName("Fred")->definedType->getFunction("func") == function);
-        }
+        ASSERT(function && function->token->str() == "func");
+        ASSERT(function && function->token == functionToken);
+        ASSERT(function && function->hasBody() && function->isInline());
+        ASSERT(function && function->functionScope == scope && scope->function == function && function->nestedIn == db->findScopeByName("Fred"));
+        ASSERT(function && function->retDef == functionToken->previous());
+
+        ASSERT(db);
+        ASSERT(db->findScopeByName("Fred") && db->findScopeByName("Fred")->definedType->getFunction("func") == function);
     }
 
 
     void hasInlineClassFunction_trailingReturnType() {
-        GET_SYMBOL_DB("class Fred { auto func() -> int { } };")
+        GET_SYMBOL_DB("class Fred { auto func() -> int { } };");
 
         // 3 scopes: Global, Class, and Function
         ASSERT(db && db->scopeList.size() == 3);
 
-        if (db) {
-            const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");
+        const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");
 
-            const Scope *scope = findFunctionScopeByToken(db, functionToken);
+        const Scope *scope = findFunctionScopeByToken(db, functionToken);
 
-            ASSERT(scope && scope->className == "func");
-            if (!scope)
-                return;
-            ASSERT(scope->functionOf && scope->functionOf == db->findScopeByName("Fred"));
+        ASSERT(scope && scope->className == "func");
 
-            const Function *function = findFunctionByName("func", &db->scopeList.back());
+        ASSERT(scope->functionOf && scope->functionOf == db->findScopeByName("Fred"));
 
-            ASSERT(function && function->token->str() == "func");
-            ASSERT(function && function->token == functionToken);
-            ASSERT(function && function->hasBody() && function->isInline());
-            ASSERT(function && function->functionScope == scope && scope->function == function && function->nestedIn == db->findScopeByName("Fred"));
-            ASSERT(function && function->retDef == functionToken->tokAt(4));
+        const Function *function = findFunctionByName("func", &db->scopeList.back());
 
-            ASSERT(db && db->findScopeByName("Fred") && db->findScopeByName("Fred")->definedType->getFunction("func") == function);
-        }
+        ASSERT(function && function->token->str() == "func");
+        ASSERT(function && function->token == functionToken);
+        ASSERT(function && function->hasBody() && function->isInline());
+        ASSERT(function && function->functionScope == scope && scope->function == function && function->nestedIn == db->findScopeByName("Fred"));
+        ASSERT(function && function->retDef == functionToken->tokAt(4));
+
+        ASSERT(db);
+        ASSERT(db->findScopeByName("Fred") && db->findScopeByName("Fred")->definedType->getFunction("func") == function);
     }
 
     void hasMissingInlineClassFunction() {
-        GET_SYMBOL_DB("class Fred { void func(); };\n")
+        GET_SYMBOL_DB("class Fred { void func(); };");
 
         // 2 scopes: Global and Class (no Function scope because there is no function implementation)
         ASSERT(db && db->scopeList.size() == 2);
 
-        if (db) {
-            const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");
+        const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");
 
-            const Scope *scope = findFunctionScopeByToken(db, functionToken);
+        const Scope *scope = findFunctionScopeByToken(db, functionToken);
 
-            ASSERT(scope == nullptr);
+        ASSERT(scope == nullptr);
 
-            const Function *function = findFunctionByName("func", &db->scopeList.back());
+        const Function *function = findFunctionByName("func", &db->scopeList.back());
 
-            ASSERT(function && function->token->str() == "func");
-            ASSERT(function && function->token == functionToken);
-            ASSERT(function && !function->hasBody());
-        }
+        ASSERT(function && function->token->str() == "func");
+        ASSERT(function && function->token == functionToken);
+        ASSERT(function && !function->hasBody());
     }
 
     void hasInlineClassOperatorTemplate() {
@@ -1257,181 +2001,185 @@ class TestSymbolDatabase: public TestFixture {
         // 3 scopes: Global, Class, and Function
         ASSERT(db && db->scopeList.size() == 3);
 
-        if (db) {
-            const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "operator=");
+        const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "operator=");
 
-            const Scope *scope = findFunctionScopeByToken(db, functionToken);
+        const Scope *scope = findFunctionScopeByToken(db, functionToken);
 
-            ASSERT(scope && scope->className == "operator=");
-            if (!scope)
-                return;
-            ASSERT(scope->functionOf && scope->functionOf == db->findScopeByName("Fred"));
+        ASSERT(scope && scope->className == "operator=");
 
-            const Function *function = findFunctionByName("operator=", &db->scopeList.back());
+        ASSERT(scope->functionOf && scope->functionOf == db->findScopeByName("Fred"));
 
-            ASSERT(function && function->token->str() == "operator=");
-            ASSERT(function && function->token == functionToken);
-            ASSERT(function && function->hasBody() && function->isInline());
-            ASSERT(function && function->functionScope == scope && scope->function == function && function->nestedIn == db->findScopeByName("Fred"));
-            ASSERT(function && function->retDef == functionToken->tokAt(-2));
+        const Function *function = findFunctionByName("operator=", &db->scopeList.back());
 
-            ASSERT(db && db->findScopeByName("Fred") && db->findScopeByName("Fred")->definedType->getFunction("operator=") == function);
-        }
+        ASSERT(function && function->token->str() == "operator=");
+        ASSERT(function && function->token == functionToken);
+        ASSERT(function && function->hasBody() && function->isInline());
+        ASSERT(function && function->functionScope == scope && scope->function == function && function->nestedIn == db->findScopeByName("Fred"));
+        ASSERT(function && function->retDef == functionToken->tokAt(-2));
+
+        ASSERT(db);
+        ASSERT(db->findScopeByName("Fred") && db->findScopeByName("Fred")->definedType->getFunction("operator=") == function);
     }
 
     void hasClassFunction() {
-        GET_SYMBOL_DB("class Fred { void func(); }; void Fred::func() { }\n")
+        GET_SYMBOL_DB("class Fred { void func(); }; void Fred::func() { }");
 
         // 3 scopes: Global, Class, and Function
         ASSERT(db && db->scopeList.size() == 3);
 
-        if (db) {
-            const Token * const functionToken = Token::findsimplematch(tokenizer.tokens()->linkAt(2), "func");
+        const Token * const functionToken = Token::findsimplematch(tokenizer.tokens()->linkAt(2), "func");
 
-            const Scope *scope = findFunctionScopeByToken(db, functionToken);
+        const Scope *scope = findFunctionScopeByToken(db, functionToken);
 
-            ASSERT(scope && scope->className == "func");
-            if (!scope)
-                return;
-            ASSERT(scope->functionOf && scope->functionOf == db->findScopeByName("Fred"));
+        ASSERT(scope && scope->className == "func");
 
-            const Function *function = findFunctionByName("func", &db->scopeList.back());
+        ASSERT(scope->functionOf && scope->functionOf == db->findScopeByName("Fred"));
 
-            ASSERT(function && function->token->str() == "func");
-            ASSERT(function && function->token == functionToken);
-            ASSERT(function && function->hasBody() && !function->isInline());
-            ASSERT(function && function->functionScope == scope && scope->function == function && function->nestedIn == db->findScopeByName("Fred"));
-        }
+        const Function *function = findFunctionByName("func", &db->scopeList.back());
+
+        ASSERT(function && function->token->str() == "func");
+        ASSERT(function && function->token == functionToken);
+        ASSERT(function && function->hasBody() && !function->isInline());
+        ASSERT(function && function->functionScope == scope && scope->function == function && function->nestedIn == db->findScopeByName("Fred"));
     }
 
     void hasClassFunction_trailingReturnType() {
-        GET_SYMBOL_DB("class Fred { auto func() -> int; }; auto Fred::func() -> int { }\n");
+        GET_SYMBOL_DB("class Fred { auto func() -> int; }; auto Fred::func() -> int { }");
 
         // 3 scopes: Global, Class, and Function
         ASSERT(db && db->scopeList.size() == 3);
 
-        if (db) {
-            const Token * const functionToken = Token::findsimplematch(tokenizer.tokens()->linkAt(2), "func");
+        const Token * const functionToken = Token::findsimplematch(tokenizer.tokens()->linkAt(2), "func");
 
-            const Scope *scope = findFunctionScopeByToken(db, functionToken);
+        const Scope *scope = findFunctionScopeByToken(db, functionToken);
 
-            ASSERT(scope && scope->className == "func");
-            if (!scope)
-                return;
-            ASSERT(scope->functionOf && scope->functionOf == db->findScopeByName("Fred"));
+        ASSERT(scope && scope->className == "func");
 
-            const Function *function = findFunctionByName("func", &db->scopeList.back());
+        ASSERT(scope->functionOf && scope->functionOf == db->findScopeByName("Fred"));
 
-            ASSERT(function && function->token->str() == "func");
-            ASSERT(function && function->token == functionToken);
-            ASSERT(function && function->hasBody() && !function->isInline());
-            ASSERT(function && function->functionScope == scope && scope->function == function && function->nestedIn == db->findScopeByName("Fred"));
-        }
+        const Function *function = findFunctionByName("func", &db->scopeList.back());
+
+        ASSERT(function && function->token->str() == "func");
+        ASSERT(function && function->token == functionToken);
+        ASSERT(function && function->hasBody() && !function->isInline());
+        ASSERT(function && function->functionScope == scope && scope->function == function && function->nestedIn == db->findScopeByName("Fred"));
+    }
+
+    void hasClassFunction_decltype_auto()
+    {
+        GET_SYMBOL_DB("struct d { decltype(auto) f() {} };");
+
+        // 3 scopes: Global, Class, and Function
+        ASSERT(db && db->scopeList.size() == 3);
+
+        const Token* const functionToken = Token::findsimplematch(tokenizer.tokens(), "f");
+
+        const Scope* scope = findFunctionScopeByToken(db, functionToken);
+
+        ASSERT(scope && scope->className == "f");
+
+        ASSERT(scope->functionOf && scope->functionOf == db->findScopeByName("d"));
+
+        const Function* function = findFunctionByName("f", &db->scopeList.back());
+
+        ASSERT(function && function->token->str() == "f");
+        ASSERT(function && function->token == functionToken);
+        ASSERT(function && function->hasBody());
     }
 
     void hasRegularFunctionReturningFunctionPointer() {
-        GET_SYMBOL_DB("void (*func(int f))(char) { }\n")
+        GET_SYMBOL_DB("void (*func(int f))(char) { }");
 
         // 2 scopes: Global and Function
         ASSERT(db && db->scopeList.size() == 2);
 
-        if (db) {
-            const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");
+        const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");
 
-            const Scope *scope = findFunctionScopeByToken(db, functionToken);
+        const Scope *scope = findFunctionScopeByToken(db, functionToken);
 
-            ASSERT(scope && scope->className == "func");
+        ASSERT(scope && scope->className == "func");
 
-            const Function *function = findFunctionByName("func", &db->scopeList.front());
+        const Function *function = findFunctionByName("func", &db->scopeList.front());
 
-            ASSERT(function && function->token->str() == "func");
-            ASSERT(function && function->token == functionToken);
-            ASSERT(function && function->hasBody());
-        }
+        ASSERT(function && function->token->str() == "func");
+        ASSERT(function && function->token == functionToken);
+        ASSERT(function && function->hasBody());
     }
 
     void hasInlineClassFunctionReturningFunctionPointer() {
-        GET_SYMBOL_DB("class Fred { void (*func(int f))(char) { } };\n")
+        GET_SYMBOL_DB("class Fred { void (*func(int f))(char) { } };");
 
         // 3 scopes: Global, Class, and Function
         ASSERT(db && db->scopeList.size() == 3);
 
-        if (db) {
-            const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");
+        const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");
 
-            const Scope *scope = findFunctionScopeByToken(db, functionToken);
+        const Scope *scope = findFunctionScopeByToken(db, functionToken);
 
-            ASSERT(scope && scope->className == "func");
+        ASSERT(scope && scope->className == "func");
 
-            const Function *function = findFunctionByName("func", &db->scopeList.back());
+        const Function *function = findFunctionByName("func", &db->scopeList.back());
 
-            ASSERT(function && function->token->str() == "func");
-            ASSERT(function && function->token == functionToken);
-            ASSERT(function && function->hasBody() && function->isInline());
-        }
+        ASSERT(function && function->token->str() == "func");
+        ASSERT(function && function->token == functionToken);
+        ASSERT(function && function->hasBody() && function->isInline());
     }
 
     void hasMissingInlineClassFunctionReturningFunctionPointer() {
-        GET_SYMBOL_DB("class Fred { void (*func(int f))(char); };\n")
+        GET_SYMBOL_DB("class Fred { void (*func(int f))(char); };");
 
         // 2 scopes: Global and Class (no Function scope because there is no function implementation)
         ASSERT(db && db->scopeList.size() == 2);
 
-        if (db) {
-            const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");
+        const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");
 
-            const Scope *scope = findFunctionScopeByToken(db, functionToken);
+        const Scope *scope = findFunctionScopeByToken(db, functionToken);
 
-            ASSERT(scope == nullptr);
+        ASSERT(scope == nullptr);
 
-            const Function *function = findFunctionByName("func", &db->scopeList.back());
+        const Function *function = findFunctionByName("func", &db->scopeList.back());
 
-            ASSERT(function && function->token->str() == "func");
-            ASSERT(function && function->token == functionToken);
-            ASSERT(function && !function->hasBody());
-        }
+        ASSERT(function && function->token->str() == "func");
+        ASSERT(function && function->token == functionToken);
+        ASSERT(function && !function->hasBody());
     }
 
     void hasClassFunctionReturningFunctionPointer() {
-        GET_SYMBOL_DB("class Fred { void (*func(int f))(char); }; void (*Fred::func(int f))(char) { }\n")
+        GET_SYMBOL_DB("class Fred { void (*func(int f))(char); }; void (*Fred::func(int f))(char) { }");
 
         // 3 scopes: Global, Class, and Function
         ASSERT(db && db->scopeList.size() == 3);
 
-        if (db) {
-            const Token * const functionToken = Token::findsimplematch(tokenizer.tokens()->linkAt(2), "func");
+        const Token * const functionToken = Token::findsimplematch(tokenizer.tokens()->linkAt(2), "func");
 
-            const Scope *scope = findFunctionScopeByToken(db, functionToken);
+        const Scope *scope = findFunctionScopeByToken(db, functionToken);
 
-            ASSERT(scope && scope->className == "func");
+        ASSERT(scope && scope->className == "func");
 
-            const Function *function = findFunctionByName("func", &db->scopeList.back());
+        const Function *function = findFunctionByName("func", &db->scopeList.back());
 
-            ASSERT(function && function->token->str() == "func");
-            ASSERT(function && function->token == functionToken);
-            ASSERT(function && function->hasBody() && !function->isInline());
-        }
+        ASSERT(function && function->token->str() == "func");
+        ASSERT(function && function->token == functionToken);
+        ASSERT(function && function->hasBody() && !function->isInline());
     }
 
     void methodWithRedundantScope() {
-        GET_SYMBOL_DB("class Fred { void Fred::func() {} };\n")
+        GET_SYMBOL_DB("class Fred { void Fred::func() {} };");
 
         // 3 scopes: Global, Class, and Function
         ASSERT(db && db->scopeList.size() == 3);
 
-        if (db) {
-            const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");
+        const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");
 
-            const Scope *scope = findFunctionScopeByToken(db, functionToken);
+        const Scope *scope = findFunctionScopeByToken(db, functionToken);
 
-            ASSERT(scope && scope->className == "func");
+        ASSERT(scope && scope->className == "func");
 
-            const Function *function = findFunctionByName("func", &db->scopeList.back());
+        const Function *function = findFunctionByName("func", &db->scopeList.back());
 
-            ASSERT(function && function->token->str() == "func");
-            ASSERT(function && function->token == functionToken);
-            ASSERT(function && function->hasBody() && function->isInline());
-        }
+        ASSERT(function && function->token->str() == "func");
+        ASSERT(function && function->token == functionToken);
+        ASSERT(function && function->hasBody() && function->isInline());
     }
 
     void complexFunctionArrayPtr() {
@@ -1448,20 +2196,19 @@ class TestSymbolDatabase: public TestFixture {
 
         ASSERT(db != nullptr);
 
-        if (db) {
-            ASSERT_EQUALS(10, db->variableList().size() - 1);
-            ASSERT_EQUALS(true, db->getVariableFromVarId(1) && db->getVariableFromVarId(1)->dimensions().size() == 1);
-            ASSERT_EQUALS(true, db->getVariableFromVarId(2) != nullptr);
-            ASSERT_EQUALS(true, db->getVariableFromVarId(3) && db->getVariableFromVarId(3)->dimensions().size() == 0);
-            ASSERT_EQUALS(true, db->getVariableFromVarId(4) != nullptr);
-            ASSERT_EQUALS(true, db->getVariableFromVarId(5) != nullptr);
-            ASSERT_EQUALS(true, db->getVariableFromVarId(6) && db->getVariableFromVarId(6)->dimensions().size() == 1);
-            ASSERT_EQUALS(true, db->getVariableFromVarId(7) && db->getVariableFromVarId(7)->dimensions().size() == 1);
-            ASSERT_EQUALS(true, db->getVariableFromVarId(8) && db->getVariableFromVarId(8)->dimensions().size() == 1);
-            ASSERT_EQUALS(true, db->getVariableFromVarId(9) && db->getVariableFromVarId(9)->dimensions().size() == 1);
-            ASSERT_EQUALS(true, db->getVariableFromVarId(10) && db->getVariableFromVarId(10)->dimensions().size() == 1);
-            ASSERT_EQUALS("", errout.str());
-        }
+        ASSERT_EQUALS(10, db->variableList().size() - 1);
+        ASSERT_EQUALS(true, db->getVariableFromVarId(1) && db->getVariableFromVarId(1)->dimensions().size() == 1);
+        ASSERT_EQUALS(true, db->getVariableFromVarId(2) != nullptr);
+        // NOLINTNEXTLINE(readability-container-size-empty)
+        ASSERT_EQUALS(true, db->getVariableFromVarId(3) && db->getVariableFromVarId(3)->dimensions().size() == 0);
+        ASSERT_EQUALS(true, db->getVariableFromVarId(4) != nullptr);
+        ASSERT_EQUALS(true, db->getVariableFromVarId(5) != nullptr);
+        ASSERT_EQUALS(true, db->getVariableFromVarId(6) && db->getVariableFromVarId(6)->dimensions().size() == 1);
+        ASSERT_EQUALS(true, db->getVariableFromVarId(7) && db->getVariableFromVarId(7)->dimensions().size() == 1);
+        ASSERT_EQUALS(true, db->getVariableFromVarId(8) && db->getVariableFromVarId(8)->dimensions().size() == 1);
+        ASSERT_EQUALS(true, db->getVariableFromVarId(9) && db->getVariableFromVarId(9)->dimensions().size() == 1);
+        ASSERT_EQUALS(true, db->getVariableFromVarId(10) && db->getVariableFromVarId(10)->dimensions().size() == 1);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void pointerToMemberFunction() {
@@ -1469,145 +2216,182 @@ class TestSymbolDatabase: public TestFixture {
 
         ASSERT(db != nullptr);
 
-        if (db) {
-            ASSERT_EQUALS(1, db->variableList().size() - 1);
-            ASSERT_EQUALS(true, db->getVariableFromVarId(1) != nullptr);
-            if (db->getVariableFromVarId(1))
-                ASSERT_EQUALS("pFun", db->getVariableFromVarId(1)->name());
-            ASSERT_EQUALS("", errout.str());
-        }
+        ASSERT_EQUALS(1, db->variableList().size() - 1);
+        ASSERT_EQUALS(true, db->getVariableFromVarId(1) != nullptr);
+
+        ASSERT_EQUALS("pFun", db->getVariableFromVarId(1)->name());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void hasSubClassConstructor() {
         GET_SYMBOL_DB("class Foo { class Sub; }; class Foo::Sub { Sub() {} };");
         ASSERT(db != nullptr);
 
-        if (db) {
-            bool seen_something = false;
-            for (const Scope & scope : db->scopeList) {
-                for (std::list<Function>::const_iterator func = scope.functionList.begin(); func != scope.functionList.end(); ++func) {
-                    ASSERT_EQUALS("Sub", func->token->str());
-                    ASSERT_EQUALS(true, func->hasBody());
-                    ASSERT_EQUALS(Function::eConstructor, func->type);
-                    seen_something = true;
-                }
+        bool seen_something = false;
+        for (const Scope & scope : db->scopeList) {
+            for (auto func = scope.functionList.cbegin(); func != scope.functionList.cend(); ++func) {
+                ASSERT_EQUALS("Sub", func->token->str());
+                ASSERT_EQUALS(true, func->hasBody());
+                ASSERT_EQUALS_ENUM(FunctionType::eConstructor, func->type);
+                seen_something = true;
             }
-            ASSERT_EQUALS(true, seen_something);
         }
+        ASSERT_EQUALS(true, seen_something);
     }
 
     void testConstructors() {
         {
             GET_SYMBOL_DB("class Foo { Foo(); };");
             const Function* ctor = tokenizer.tokens()->tokAt(3)->function();
-            ASSERT(db && ctor && ctor->type == Function::eConstructor);
+            ASSERT(db && ctor && ctor->type == FunctionType::eConstructor);
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
             GET_SYMBOL_DB("class Foo { Foo(Foo f); };");
             const Function* ctor = tokenizer.tokens()->tokAt(3)->function();
-            ASSERT(db && ctor && ctor->type == Function::eConstructor && !ctor->isExplicit());
+            ASSERT(db && ctor && ctor->type == FunctionType::eConstructor && !ctor->isExplicit());
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
             GET_SYMBOL_DB("class Foo { explicit Foo(Foo f); };");
             const Function* ctor = tokenizer.tokens()->tokAt(4)->function();
-            ASSERT(db && ctor && ctor->type == Function::eConstructor && ctor->isExplicit());
+            ASSERT(db && ctor && ctor->type == FunctionType::eConstructor && ctor->isExplicit());
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
             GET_SYMBOL_DB("class Foo { Foo(Bar& f); };");
             const Function* ctor = tokenizer.tokens()->tokAt(3)->function();
-            ASSERT(db && ctor && ctor->type == Function::eConstructor);
+            ASSERT(db && ctor && ctor->type == FunctionType::eConstructor);
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
             GET_SYMBOL_DB("class Foo { Foo(Foo& f); };");
             const Function* ctor = tokenizer.tokens()->tokAt(3)->function();
-            ASSERT(db && ctor && ctor->type == Function::eCopyConstructor);
+            ASSERT(db && ctor && ctor->type == FunctionType::eCopyConstructor);
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
             GET_SYMBOL_DB("class Foo { Foo(const Foo &f); };");
             const Function* ctor = tokenizer.tokens()->tokAt(3)->function();
-            ASSERT(db && ctor && ctor->type == Function::eCopyConstructor);
+            ASSERT(db && ctor && ctor->type == FunctionType::eCopyConstructor);
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
             GET_SYMBOL_DB("template <T> class Foo { Foo(Foo<T>& f); };");
             const Function* ctor = tokenizer.tokens()->tokAt(7)->function();
-            ASSERT(db && ctor && ctor->type == Function::eCopyConstructor);
+            ASSERT(db && ctor && ctor->type == FunctionType::eCopyConstructor);
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
             GET_SYMBOL_DB("class Foo { Foo(Foo& f, int default = 0); };");
             const Function* ctor = tokenizer.tokens()->tokAt(3)->function();
-            ASSERT(db && ctor && ctor->type == Function::eCopyConstructor);
+            ASSERT(db && ctor && ctor->type == FunctionType::eCopyConstructor);
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
             GET_SYMBOL_DB("class Foo { Foo(Foo& f, char noDefault); };");
             const Function* ctor = tokenizer.tokens()->tokAt(3)->function();
-            ASSERT(db && ctor && ctor->type == Function::eConstructor);
+            ASSERT(db && ctor && ctor->type == FunctionType::eConstructor);
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
             GET_SYMBOL_DB("class Foo { Foo(Foo&& f); };");
             const Function* ctor = tokenizer.tokens()->tokAt(3)->function();
-            ASSERT(db && ctor && ctor->type == Function::eMoveConstructor);
+            ASSERT(db && ctor && ctor->type == FunctionType::eMoveConstructor);
             ASSERT(ctor && ctor->retDef == nullptr);
         }
         {
-            GET_SYMBOL_DB("class Foo { Foo(Foo & & f, int default = 1, bool defaultToo = true); };");
+            GET_SYMBOL_DB("class Foo { Foo(Foo&& f, int default = 1, bool defaultToo = true); };");
             const Function* ctor = tokenizer.tokens()->tokAt(3)->function();
-            ASSERT(db && ctor && ctor->type == Function::eMoveConstructor);
+            ASSERT(db && ctor && ctor->type == FunctionType::eMoveConstructor);
             ASSERT(ctor && ctor->retDef == nullptr);
         }
+        {
+            GET_SYMBOL_DB("void f() { extern void f(); }");
+            ASSERT(db && db->scopeList.size() == 2);
+            const Function* f = findFunctionByName("f", &db->scopeList.back());
+            ASSERT(f && f->type == FunctionType::eFunction);
+        }
     }
 
     void functionDeclarationTemplate() {
-        GET_SYMBOL_DB("std::map<int, string> foo() {}")
+        GET_SYMBOL_DB("std::map<int, string> foo() {}");
 
         // 2 scopes: Global and Function
         ASSERT(db && db->scopeList.size() == 2 && findFunctionByName("foo", &db->scopeList.back()));
 
-        if (db) {
-            const Scope *scope = &db->scopeList.front();
+        const Scope *scope = &db->scopeList.front();
 
-            ASSERT(scope && scope->functionList.size() == 1);
+        ASSERT(scope && scope->functionList.size() == 1);
 
-            const Function *foo = &scope->functionList.front();
+        const Function *foo = &scope->functionList.front();
 
-            ASSERT(foo && foo->token->str() == "foo");
-            ASSERT(foo && foo->hasBody());
-        }
+        ASSERT(foo && foo->token->str() == "foo");
+        ASSERT(foo && foo->hasBody());
     }
 
     void functionDeclarations() {
-        GET_SYMBOL_DB("void foo();\nvoid foo();\nint foo(int i);\nvoid foo() {}")
+        GET_SYMBOL_DB("void foo();\nvoid foo();\nint foo(int i);\nvoid foo() {}");
 
         // 2 scopes: Global and Function
         ASSERT(db && db->scopeList.size() == 2 && findFunctionByName("foo", &db->scopeList.back()));
 
-        if (db) {
-            const Scope *scope = &db->scopeList.front();
+        const Scope *scope = &db->scopeList.front();
 
-            ASSERT(scope && scope->functionList.size() == 2);
+        ASSERT(scope && scope->functionList.size() == 2);
 
-            const Function *foo = &scope->functionList.front();
-            const Function *foo_int = &scope->functionList.back();
+        const Function *foo = &scope->functionList.front();
+        const Function *foo_int = &scope->functionList.back();
 
-            ASSERT(foo && foo->token->str() == "foo");
-            ASSERT(foo && foo->hasBody());
-            ASSERT(foo && foo->token->strAt(2) == ")");
+        ASSERT(foo && foo->token->str() == "foo");
+        ASSERT(foo && foo->hasBody());
+        ASSERT(foo && foo->token->strAt(2) == ")");
 
-            ASSERT(foo_int && !foo_int->token);
-            ASSERT(foo_int && foo_int->tokenDef->str() == "foo");
-            ASSERT(foo_int && !foo_int->hasBody());
-            ASSERT(foo_int && foo_int->tokenDef->strAt(2) == "int");
+        ASSERT(foo_int && !foo_int->token);
+        ASSERT(foo_int && foo_int->tokenDef->str() == "foo");
+        ASSERT(foo_int && !foo_int->hasBody());
+        ASSERT(foo_int && foo_int->tokenDef->strAt(2) == "int");
 
-            ASSERT(&foo_int->argumentList.front() == db->getVariableFromVarId(1));
-        }
+        ASSERT(&foo_int->argumentList.front() == db->getVariableFromVarId(1));
+    }
+
+    void functionDeclarations2() {
+        GET_SYMBOL_DB("std::array<int,2> foo(int x);");
+
+        // 1 scopes: Global
+        ASSERT(db && db->scopeList.size() == 1);
+
+        const Scope *scope = &db->scopeList.front();
+
+        ASSERT(scope && scope->functionList.size() == 1);
+
+        const Function *foo = &scope->functionList.front();
+
+        ASSERT(foo);
+        ASSERT(foo->tokenDef->str() == "foo");
+        ASSERT(!foo->hasBody());
+
+        const Token*parenthesis = foo->tokenDef->next();
+        ASSERT(parenthesis->str() == "(" && parenthesis->strAt(-1) == "foo");
+        ASSERT(parenthesis->valueType()->type == ValueType::Type::CONTAINER);
+    }
+
+    void constexprFunction() {
+        GET_SYMBOL_DB("constexpr int foo();");
+
+        // 1 scopes: Global
+        ASSERT(db && db->scopeList.size() == 1);
+
+        const Scope *scope = &db->scopeList.front();
+
+        ASSERT(scope && scope->functionList.size() == 1);
+
+        const Function *foo = &scope->functionList.front();
+
+        ASSERT(foo);
+        ASSERT(foo->tokenDef->str() == "foo");
+        ASSERT(!foo->hasBody());
+        ASSERT(foo->isConstexpr());
     }
 
     void constructorInitialization() {
@@ -1617,10 +2401,8 @@ class TestSymbolDatabase: public TestFixture {
         // 1 scope: Global
         ASSERT(db && db->scopeList.size() == 1);
 
-        if (db && !db->scopeList.empty()) {
-            // No functions
-            ASSERT(db->scopeList.front().functionList.empty());
-        }
+        // No functions
+        ASSERT(db->scopeList.front().functionList.empty());
     }
 
     void memberFunctionOfUnknownClassMacro1() {
@@ -1630,13 +2412,11 @@ class TestSymbolDatabase: public TestFixture {
                       "    if (pDocSh && !getCellRangesForAddress(nFlags)) ;\n"
                       "}");
 
-        ASSERT(db && errout.str().empty());
+        ASSERT(db && errout_str().empty());
 
-        if (db) {
-            const Scope *scope = db->findScopeByName("getFormula1");
-            ASSERT(scope != nullptr);
-            ASSERT(scope && scope->nestedIn == &db->scopeList.front());
-        }
+        const Scope *scope = db->findScopeByName("getFormula1");
+        ASSERT(scope != nullptr);
+        ASSERT(scope && scope->nestedIn == &db->scopeList.front());
     }
 
     void memberFunctionOfUnknownClassMacro2() {
@@ -1646,17 +2426,15 @@ class TestSymbolDatabase: public TestFixture {
                       "    if (pDocSh && !getCellRangesForAddress(nFlags)) ;\n"
                       "}");
 
-        ASSERT(db && errout.str().empty());
+        ASSERT(db && errout_str().empty());
 
-        if (db) {
-            const Scope *scope = db->findScopeByName("getFormula1");
-            ASSERT(scope != nullptr);
-            ASSERT(scope && scope->nestedIn == &db->scopeList.front());
+        const Scope *scope = db->findScopeByName("getFormula1");
+        ASSERT(scope != nullptr);
+        ASSERT(scope && scope->nestedIn == &db->scopeList.front());
 
-            scope = db->findScopeByName("getServiceImplName");
-            ASSERT(scope != nullptr);
-            ASSERT(scope && scope->nestedIn && scope->nestedIn->className == "ScVbaFormatCondition");
-        }
+        scope = db->findScopeByName("getServiceImplName");
+        ASSERT(scope != nullptr);
+        ASSERT(scope && scope->nestedIn && scope->nestedIn->className == "ScVbaFormatCondition");
     }
 
     void memberFunctionOfUnknownClassMacro3() {
@@ -1666,13 +2444,11 @@ class TestSymbolDatabase: public TestFixture {
                       "    if (pDocSh && !getCellRangesForAddress(nFlags)) ;\n"
                       "}");
 
-        ASSERT(db && errout.str().empty());
+        ASSERT(db && errout_str().empty());
 
-        if (db) {
-            const Scope *scope = db->findScopeByName("getFormula1");
-            ASSERT(scope != nullptr);
-            ASSERT(scope && scope->nestedIn == &db->scopeList.front());
-        }
+        const Scope *scope = db->findScopeByName("getFormula1");
+        ASSERT(scope != nullptr);
+        ASSERT(scope && scope->nestedIn == &db->scopeList.front());
     }
 
     void functionLinkage() {
@@ -1683,51 +2459,76 @@ class TestSymbolDatabase: public TestFixture {
                       "extern void f5() { };\n"
                       "void f6() { }");
 
-        ASSERT(db && errout.str().empty());
+        ASSERT(db && errout_str().empty());
 
-        if (db) {
-            const Token *f = Token::findsimplematch(tokenizer.tokens(), "f1");
-            ASSERT(f && f->function() && f->function()->isStaticLocal() && f->function()->retDef->str() == "void");
+        const Token *f = Token::findsimplematch(tokenizer.tokens(), "f1");
+        ASSERT(f && f->function() && f->function()->isStaticLocal() && f->function()->retDef->str() == "void");
 
-            f = Token::findsimplematch(tokenizer.tokens(), "f2");
-            ASSERT(f && f->function() && !f->function()->isStaticLocal() && f->function()->retDef->str() == "void");
+        f = Token::findsimplematch(tokenizer.tokens(), "f2");
+        ASSERT(f && f->function() && !f->function()->isStaticLocal() && f->function()->retDef->str() == "void");
 
-            f = Token::findsimplematch(tokenizer.tokens(), "f3");
-            ASSERT(f && f->function() && f->function()->isExtern() && f->function()->retDef->str() == "void");
+        f = Token::findsimplematch(tokenizer.tokens(), "f3");
+        ASSERT(f && f->function() && f->function()->isExtern() && f->function()->retDef->str() == "void");
 
-            f = Token::findsimplematch(tokenizer.tokens(), "f4");
-            ASSERT(f && f->function() && !f->function()->isExtern() && f->function()->retDef->str() == "void");
+        f = Token::findsimplematch(tokenizer.tokens(), "f4");
+        ASSERT(f && f->function() && !f->function()->isExtern() && f->function()->retDef->str() == "void");
 
-            f = Token::findsimplematch(tokenizer.tokens(), "f5");
-            ASSERT(f && f->function() && f->function()->isExtern() && f->function()->retDef->str() == "void");
+        f = Token::findsimplematch(tokenizer.tokens(), "f5");
+        ASSERT(f && f->function() && f->function()->isExtern() && f->function()->retDef->str() == "void");
 
-            f = Token::findsimplematch(tokenizer.tokens(), "f6");
-            ASSERT(f && f->function() && !f->function()->isExtern() && f->function()->retDef->str() == "void");
-        }
+        f = Token::findsimplematch(tokenizer.tokens(), "f6");
+        ASSERT(f && f->function() && !f->function()->isExtern() && f->function()->retDef->str() == "void");
+    }
+
+    void externalFunctionsInsideAFunction() {
+        GET_SYMBOL_DB("void foo( void )\n"
+                      "{\n"
+                      "    extern void bar( void );\n"
+                      "    bar();\n"
+                      "}\n");
+
+        ASSERT(db && errout_str().empty());
+
+        const Token *f = Token::findsimplematch(tokenizer.tokens(), "bar");
+        ASSERT(f && f->function() && f->function()->isExtern() && f == f->function()->tokenDef && f->function()->retDef->str() == "void");
+
+        const Token *call = Token::findsimplematch(f->next(), "bar");
+        ASSERT(call && call->function() == f->function());
+    }
+
+    void namespacedFunctionInsideExternBlock() {
+        // Should not crash
+        GET_SYMBOL_DB("namespace N {\n"
+                      "    void f();\n"
+                      "}\n"
+                      "extern \"C\" {\n"
+                      "    void f() {\n"
+                      "        N::f();\n"
+                      "    }\n"
+                      "}\n");
+
+        ASSERT(db && errout_str().empty());
     }
 
     void classWithFriend() {
-        GET_SYMBOL_DB("class Foo {}; class Bar1 { friend class Foo; }; class Bar2 { friend Foo; };")
+        GET_SYMBOL_DB("class Foo {}; class Bar1 { friend class Foo; }; class Bar2 { friend Foo; };");
         // 3 scopes: Global, 3 classes
         ASSERT(db && db->scopeList.size() == 4);
-        if (db) {
-            const Scope* foo = db->findScopeByName("Foo");
-            ASSERT(foo != nullptr);
-            const Scope* bar1 = db->findScopeByName("Bar1");
-            ASSERT(bar1 != nullptr);
-            const Scope* bar2 = db->findScopeByName("Bar2");
-            ASSERT(bar2 != nullptr);
-
-            if (foo && bar1 && bar2) {
-                ASSERT(bar1->definedType->friendList.size() == 1 && bar1->definedType->friendList.front().nameEnd->str() == "Foo" && bar1->definedType->friendList.front().type == foo->definedType);
-                ASSERT(bar2->definedType->friendList.size() == 1 && bar2->definedType->friendList.front().nameEnd->str() == "Foo" && bar2->definedType->friendList.front().type == foo->definedType);
-            }
-        }
+
+        const Scope* foo = db->findScopeByName("Foo");
+        ASSERT(foo != nullptr);
+        const Scope* bar1 = db->findScopeByName("Bar1");
+        ASSERT(bar1 != nullptr);
+        const Scope* bar2 = db->findScopeByName("Bar2");
+        ASSERT(bar2 != nullptr);
+
+        ASSERT(bar1->definedType->friendList.size() == 1 && bar1->definedType->friendList.front().nameEnd->str() == "Foo" && bar1->definedType->friendList.front().type == foo->definedType);
+        ASSERT(bar2->definedType->friendList.size() == 1 && bar2->definedType->friendList.front().nameEnd->str() == "Foo" && bar2->definedType->friendList.front().type == foo->definedType);
     }
 
     void parseFunctionCorrect() {
         // ticket 3188 - "if" statement parsed as function
-        GET_SYMBOL_DB("void func(i) int i; { if (i == 1) return; }\n")
+        GET_SYMBOL_DB("void func(i) int i; { if (i == 1) return; }");
         ASSERT(db != nullptr);
 
         // 3 scopes: Global, function, if
@@ -1740,7 +2541,7 @@ class TestSymbolDatabase: public TestFixture {
     void parseFunctionDeclarationCorrect() {
         GET_SYMBOL_DB("void func();\n"
                       "int bar() {}\n"
-                      "void func() {}")
+                      "void func() {}");
         ASSERT_EQUALS(3, db->findScopeByName("func")->bodyStart->linenr());
     }
 
@@ -1754,48 +2555,41 @@ class TestSymbolDatabase: public TestFixture {
     }
 
     void hasGlobalVariables1() {
-        GET_SYMBOL_DB("int i;\n")
+        GET_SYMBOL_DB("int i;");
 
         ASSERT(db && db->scopeList.size() == 1);
-        if (db && db->scopeList.size() == 1) {
-            std::list<Scope>::const_iterator it = db->scopeList.begin();
-            ASSERT(it->varlist.size() == 1);
-            if (it->varlist.size() == 1) {
-                std::list<Variable>::const_iterator var = it->varlist.begin();
-                ASSERT(var->name() == "i");
-                ASSERT(var->typeStartToken()->str() == "int");
-            }
-        }
+
+        const auto it = db->scopeList.cbegin();
+        ASSERT(it->varlist.size() == 1);
+        const auto var = it->varlist.cbegin();
+        ASSERT(var->name() == "i");
+        ASSERT(var->typeStartToken()->str() == "int");
     }
 
     void hasGlobalVariables2() {
-        GET_SYMBOL_DB("int array[2][2];\n")
+        GET_SYMBOL_DB("int array[2][2];");
 
         ASSERT(db && db->scopeList.size() == 1);
-        if (db && db->scopeList.size() == 1) {
-            std::list<Scope>::const_iterator it = db->scopeList.begin();
-            ASSERT(it->varlist.size() == 1);
-            if (it->varlist.size() == 1) {
-                std::list<Variable>::const_iterator var = it->varlist.begin();
-                ASSERT(var->name() == "array");
-                ASSERT(var->typeStartToken()->str() == "int");
-            }
-        }
+
+        const auto it = db->scopeList.cbegin();
+        ASSERT(it->varlist.size() == 1);
+
+        const auto var = it->varlist.cbegin();
+        ASSERT(var->name() == "array");
+        ASSERT(var->typeStartToken()->str() == "int");
     }
 
     void hasGlobalVariables3() {
-        GET_SYMBOL_DB("int array[2][2] = { { 0, 0 }, { 0, 0 } };\n")
+        GET_SYMBOL_DB("int array[2][2] = { { 0, 0 }, { 0, 0 } };");
 
         ASSERT(db && db->scopeList.size() == 1);
-        if (db && db->scopeList.size() == 1) {
-            std::list<Scope>::const_iterator it = db->scopeList.begin();
-            ASSERT(it->varlist.size() == 1);
-            if (it->varlist.size() == 1) {
-                std::list<Variable>::const_iterator var = it->varlist.begin();
-                ASSERT(var->name() == "array");
-                ASSERT(var->typeStartToken()->str() == "int");
-            }
-        }
+
+        const auto it = db->scopeList.cbegin();
+        ASSERT(it->varlist.size() == 1);
+
+        const auto var = it->varlist.cbegin();
+        ASSERT(var->name() == "array");
+        ASSERT(var->typeStartToken()->str() == "int");
     }
 
     void checkTypeStartEndToken1() {
@@ -1803,22 +2597,21 @@ class TestSymbolDatabase: public TestFixture {
                       "static const std::string j;\n"
                       "const std::string* k;\n"
                       "const char m[];\n"
-                      "void f(const char* const l;) {}");
+                      "void f(const char* const l) {}");
 
         ASSERT(db && db->variableList().size() == 6 && db->getVariableFromVarId(1) && db->getVariableFromVarId(2) && db->getVariableFromVarId(3) && db->getVariableFromVarId(4) && db->getVariableFromVarId(5));
-        if (db && db->getVariableFromVarId(1) && db->getVariableFromVarId(2) && db->getVariableFromVarId(3) && db->getVariableFromVarId(4) && db->getVariableFromVarId(5)) {
-            ASSERT_EQUALS("std", db->getVariableFromVarId(1)->typeStartToken()->str());
-            ASSERT_EQUALS("std", db->getVariableFromVarId(2)->typeStartToken()->str());
-            ASSERT_EQUALS("std", db->getVariableFromVarId(3)->typeStartToken()->str());
-            ASSERT_EQUALS("char", db->getVariableFromVarId(4)->typeStartToken()->str());
-            ASSERT_EQUALS("char", db->getVariableFromVarId(5)->typeStartToken()->str());
 
-            ASSERT_EQUALS("string", db->getVariableFromVarId(1)->typeEndToken()->str());
-            ASSERT_EQUALS("string", db->getVariableFromVarId(2)->typeEndToken()->str());
-            ASSERT_EQUALS("*", db->getVariableFromVarId(3)->typeEndToken()->str());
-            ASSERT_EQUALS("char", db->getVariableFromVarId(4)->typeEndToken()->str());
-            ASSERT_EQUALS("*", db->getVariableFromVarId(5)->typeEndToken()->str());
-        }
+        ASSERT_EQUALS("std", db->getVariableFromVarId(1)->typeStartToken()->str());
+        ASSERT_EQUALS("std", db->getVariableFromVarId(2)->typeStartToken()->str());
+        ASSERT_EQUALS("std", db->getVariableFromVarId(3)->typeStartToken()->str());
+        ASSERT_EQUALS("char", db->getVariableFromVarId(4)->typeStartToken()->str());
+        ASSERT_EQUALS("char", db->getVariableFromVarId(5)->typeStartToken()->str());
+
+        ASSERT_EQUALS("string", db->getVariableFromVarId(1)->typeEndToken()->str());
+        ASSERT_EQUALS("string", db->getVariableFromVarId(2)->typeEndToken()->str());
+        ASSERT_EQUALS("*", db->getVariableFromVarId(3)->typeEndToken()->str());
+        ASSERT_EQUALS("char", db->getVariableFromVarId(4)->typeEndToken()->str());
+        ASSERT_EQUALS("*", db->getVariableFromVarId(5)->typeEndToken()->str());
     }
 
     void checkTypeStartEndToken2() {
@@ -1841,31 +2634,28 @@ class TestSymbolDatabase: public TestFixture {
         GET_SYMBOL_DB("void f(const char) {}");
 
         ASSERT(db && db->functionScopes.size()==1U);
-        if (db && db->functionScopes.size()==1U) {
-            const Function * const f = db->functionScopes.front()->function;
-            ASSERT_EQUALS(1U, f->argCount());
-            const Variable * const arg1 = f->getArgumentVar(0);
-            ASSERT_EQUALS("char", arg1->typeStartToken()->str());
-            ASSERT_EQUALS("char", arg1->typeEndToken()->str());
-        }
-    }
 
-    void check(const char code[], bool debug = true, const char filename[] = "test.cpp") {
-        // Clear the error log
-        errout.str("");
+        const Function * const f = db->functionScopes.front()->function;
+        ASSERT_EQUALS(1U, f->argCount());
+        ASSERT_EQUALS(0U, f->initializedArgCount());
+        ASSERT_EQUALS(1U, f->minArgCount());
+        const Variable * const arg1 = f->getArgumentVar(0);
+        ASSERT_EQUALS("char", arg1->typeStartToken()->str());
+        ASSERT_EQUALS("char", arg1->typeEndToken()->str());
+    }
 
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], bool debug = true, bool cpp = true, const Settings* pSettings = nullptr) {
         // Check..
-        settings1.debugwarnings = debug;
+        const Settings settings = settingsBuilder(pSettings ? *pSettings : settings1).debugwarnings(debug).build();
 
         // Tokenize..
-        Tokenizer tokenizer(&settings1, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, filename);
+        SimpleTokenizer tokenizer(settings, *this, cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // force symbol database creation
         tokenizer.createSymbolDatabase();
-
-        settings1.debugwarnings = false;
     }
 
     void functionArgs1() {
@@ -1875,10 +2665,10 @@ class TestSymbolDatabase: public TestFixture {
             const Variable* v = db->getVariableFromVarId(1);
             ASSERT(v && v->isReference() && v->isConst() && v->isArgument());
             const Scope* f = db->findScopeByName("f");
-            ASSERT(f && f->type == Scope::eFunction && f->function);
-            if (f && f->function)
-                ASSERT(f->function->argumentList.size() == 2 && f->function->argumentList.front().index() == 0 && f->function->argumentList.front().name() == "" && f->function->argumentList.back().index() == 1);
-            ASSERT_EQUALS("", errout.str());
+            ASSERT(f && f->type == ScopeType::eFunction && f->function);
+
+            ASSERT(f->function->argumentList.size() == 2 && f->function->argumentList.front().index() == 0 && f->function->argumentList.front().name().empty() && f->function->argumentList.back().index() == 1);
+            ASSERT_EQUALS("", errout_str());
         }
         {
             GET_SYMBOL_DB("void g(std::map<std::string, std::vector<int> > m) { }");
@@ -1886,32 +2676,32 @@ class TestSymbolDatabase: public TestFixture {
             const Variable* m = db->getVariableFromVarId(1);
             ASSERT(m && !m->isReference() && !m->isConst() && m->isArgument() && m->isClass());
             const Scope* g = db->findScopeByName("g");
-            ASSERT(g && g->type == Scope::eFunction && g->function && g->function->argumentList.size() == 1 && g->function->argumentList.front().index() == 0);
-            ASSERT_EQUALS("", errout.str());
+            ASSERT(g && g->type == ScopeType::eFunction && g->function && g->function->argumentList.size() == 1 && g->function->argumentList.front().index() == 0);
+            ASSERT_EQUALS("", errout_str());
         }
         {
             GET_SYMBOL_DB("void g(std::map<int, int> m = std::map<int, int>()) { }");
             const Scope* g = db->findScopeByName("g");
-            ASSERT(g && g->type == Scope::eFunction && g->function && g->function->argumentList.size() == 1 && g->function->argumentList.front().index() == 0 && g->function->initializedArgCount() == 1);
-            ASSERT_EQUALS("", errout.str());
+            ASSERT(g && g->type == ScopeType::eFunction && g->function && g->function->argumentList.size() == 1 && g->function->argumentList.front().index() == 0 && g->function->initializedArgCount() == 1);
+            ASSERT_EQUALS("", errout_str());
         }
         {
             GET_SYMBOL_DB("void g(int = 0) { }");
             const Scope* g = db->findScopeByName("g");
-            ASSERT(g && g->type == Scope::eFunction && g->function && g->function->argumentList.size() == 1 && g->function->argumentList.front().hasDefault());
-            ASSERT_EQUALS("", errout.str());
+            ASSERT(g && g->type == ScopeType::eFunction && g->function && g->function->argumentList.size() == 1 && g->function->argumentList.front().hasDefault());
+            ASSERT_EQUALS("", errout_str());
         }
         {
             GET_SYMBOL_DB("void g(int*) { }"); // unnamed pointer argument (#8052)
             const Scope* g = db->findScopeByName("g");
-            ASSERT(g && g->type == Scope::eFunction && g->function && g->function->argumentList.size() == 1 && g->function->argumentList.front().nameToken() == nullptr && g->function->argumentList.front().isPointer());
-            ASSERT_EQUALS("", errout.str());
+            ASSERT(g && g->type == ScopeType::eFunction && g->function && g->function->argumentList.size() == 1 && g->function->argumentList.front().nameToken() == nullptr && g->function->argumentList.front().isPointer());
+            ASSERT_EQUALS("", errout_str());
         }
         {
             GET_SYMBOL_DB("void g(int* const) { }"); // 'const' is not the name of the variable - #5882
             const Scope* g = db->findScopeByName("g");
-            ASSERT(g && g->type == Scope::eFunction && g->function && g->function->argumentList.size() == 1 && g->function->argumentList.front().nameToken() == nullptr);
-            ASSERT_EQUALS("", errout.str());
+            ASSERT(g && g->type == ScopeType::eFunction && g->function && g->function->argumentList.size() == 1 && g->function->argumentList.front().nameToken() == nullptr);
+            ASSERT_EQUALS("", errout_str());
         }
     }
 
@@ -1931,16 +2721,15 @@ class TestSymbolDatabase: public TestFixture {
         ASSERT_EQUALS(true, db->scopeList.front().functionList.size() == 1UL);
         const Function *func = &db->scopeList.front().functionList.front();
         ASSERT_EQUALS(true, func && func->argumentList.size() == 2UL);
-        if (func && func->argumentList.size() == 2UL) {
-            const Variable *first = &func->argumentList.front();
-            ASSERT_EQUALS(0UL, first->name().size());
-            ASSERT_EQUALS(1UL, first->dimensions().size());
-            ASSERT_EQUALS(10UL, first->dimension(0));
-            const Variable *second = &func->argumentList.back();
-            ASSERT_EQUALS(0UL, second->name().size());
-            ASSERT_EQUALS(1UL, second->dimensions().size());
-            ASSERT_EQUALS(10UL, second->dimension(0));
-        }
+
+        const Variable *first = &func->argumentList.front();
+        ASSERT_EQUALS(0UL, first->name().size());
+        ASSERT_EQUALS(1UL, first->dimensions().size());
+        ASSERT_EQUALS(10UL, first->dimension(0));
+        const Variable *second = &func->argumentList.back();
+        ASSERT_EQUALS(0UL, second->name().size());
+        ASSERT_EQUALS(1UL, second->dimensions().size());
+        ASSERT_EQUALS(10UL, second->dimension(0));
     }
 
     void functionArgs5() { // #7650
@@ -1950,18 +2739,12 @@ class TestSymbolDatabase: public TestFixture {
                       "  void f(enum ABC abc) {}\n"
                       "};");
         ASSERT_EQUALS(true, db != nullptr);
-        if (db) {
-            const Token *f = Token::findsimplematch(tokenizer.tokens(), "f ( enum");
-            ASSERT_EQUALS(true, f && f->function());
-            if (f && f->function()) {
-                const Function *func = f->function();
-                ASSERT_EQUALS(true, func->argumentList.size() == 1 && func->argumentList.front().type());
-                if (func->argumentList.size() == 1 && func->argumentList.front().type()) {
-                    const Type * type = func->argumentList.front().type();
-                    ASSERT_EQUALS(true, type->isEnumType());
-                }
-            }
-        }
+        const Token *f = Token::findsimplematch(tokenizer.tokens(), "f ( enum");
+        ASSERT_EQUALS(true, f && f->function());
+        const Function *func = f->function();
+        ASSERT_EQUALS(true, func->argumentList.size() == 1 && func->argumentList.front().type());
+        const Type * type = func->argumentList.front().type();
+        ASSERT_EQUALS(true, type->isEnumType());
     }
 
     void functionArgs6() { // #7651
@@ -1971,18 +2754,12 @@ class TestSymbolDatabase: public TestFixture {
                       "  void f(ABC abc) {}\n"
                       "};");
         ASSERT_EQUALS(true, db != nullptr);
-        if (db) {
-            const Token *f = Token::findsimplematch(tokenizer.tokens(), "f ( ABC");
-            ASSERT_EQUALS(true, f && f->function());
-            if (f && f->function()) {
-                const Function *func = f->function();
-                ASSERT_EQUALS(true, func->argumentList.size() == 1 && func->argumentList.front().type());
-                if (func->argumentList.size() == 1 && func->argumentList.front().type()) {
-                    const Type * type = func->argumentList.front().type();
-                    ASSERT_EQUALS(true, type->isEnumType());
-                }
-            }
-        }
+        const Token *f = Token::findsimplematch(tokenizer.tokens(), "f ( ABC");
+        ASSERT_EQUALS(true, f && f->function());
+        const Function *func = f->function();
+        ASSERT_EQUALS(true, func->argumentList.size() == 1 && func->argumentList.front().type());
+        const Type * type = func->argumentList.front().type();
+        ASSERT_EQUALS(true, type->isEnumType());
     }
 
     void functionArgs7() { // #7652
@@ -1991,84 +2768,60 @@ class TestSymbolDatabase: public TestFixture {
                           "int foo(struct AB *ab);\n"
                           "void bar() {\n"
                           "  struct AB ab;\n"
-                          "  foo(&ab); \n"
+                          "  foo(&ab);\n"
                           "};");
             ASSERT_EQUALS(true, db != nullptr);
-            if (db) {
-                const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( & ab");
-                ASSERT_EQUALS(true, f && f->function());
-                if (f && f->function()) {
-                    const Function *func = f->function();
-                    ASSERT_EQUALS(true, func->tokenDef->linenr() == 2 && func->argumentList.size() == 1 && func->argumentList.front().type());
-                    if (func->argumentList.size() == 1 && func->argumentList.front().type()) {
-                        const Type * type = func->argumentList.front().type();
-                        ASSERT_EQUALS(true, type->classDef->linenr() == 1);
-                    }
-                }
-            }
+            const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( & ab");
+            ASSERT_EQUALS(true, f && f->function());
+            const Function *func = f->function();
+            ASSERT_EQUALS(true, func->tokenDef->linenr() == 2 && func->argumentList.size() == 1 && func->argumentList.front().type());
+            const Type * type = func->argumentList.front().type();
+            ASSERT_EQUALS(true, type->classDef->linenr() == 1);
         }
         {
             GET_SYMBOL_DB("struct AB { int a; int b; };\n"
                           "int foo(AB *ab);\n"
                           "void bar() {\n"
                           "  struct AB ab;\n"
-                          "  foo(&ab); \n"
+                          "  foo(&ab);\n"
                           "};");
             ASSERT_EQUALS(true, db != nullptr);
-            if (db) {
-                const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( & ab");
-                ASSERT_EQUALS(true, f && f->function());
-                if (f && f->function()) {
-                    const Function *func = f->function();
-                    ASSERT_EQUALS(true, func->tokenDef->linenr() == 2 && func->argumentList.size() == 1 && func->argumentList.front().type());
-                    if (func->argumentList.size() == 1 && func->argumentList.front().type()) {
-                        const Type * type = func->argumentList.front().type();
-                        ASSERT_EQUALS(true, type->classDef->linenr() == 1);
-                    }
-                }
-            }
+            const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( & ab");
+            ASSERT_EQUALS(true, f && f->function());
+            const Function *func = f->function();
+            ASSERT_EQUALS(true, func->tokenDef->linenr() == 2 && func->argumentList.size() == 1 && func->argumentList.front().type());
+            const Type * type = func->argumentList.front().type();
+            ASSERT_EQUALS(true, type->classDef->linenr() == 1);
         }
         {
             GET_SYMBOL_DB("struct AB { int a; int b; };\n"
                           "int foo(struct AB *ab);\n"
                           "void bar() {\n"
                           "  AB ab;\n"
-                          "  foo(&ab); \n"
+                          "  foo(&ab);\n"
                           "};");
             ASSERT_EQUALS(true, db != nullptr);
-            if (db) {
-                const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( & ab");
-                ASSERT_EQUALS(true, f && f->function());
-                if (f && f->function()) {
-                    const Function *func = f->function();
-                    ASSERT_EQUALS(true, func->tokenDef->linenr() == 2 && func->argumentList.size() == 1 && func->argumentList.front().type());
-                    if (func->argumentList.size() == 1 && func->argumentList.front().type()) {
-                        const Type * type = func->argumentList.front().type();
-                        ASSERT_EQUALS(true, type->classDef->linenr() == 1);
-                    }
-                }
-            }
+            const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( & ab");
+            ASSERT_EQUALS(true, f && f->function());
+            const Function *func = f->function();
+            ASSERT_EQUALS(true, func->tokenDef->linenr() == 2 && func->argumentList.size() == 1 && func->argumentList.front().type());
+            const Type * type = func->argumentList.front().type();
+            ASSERT_EQUALS(true, type->classDef->linenr() == 1);
         }
         {
             GET_SYMBOL_DB("struct AB { int a; int b; };\n"
                           "int foo(AB *ab);\n"
                           "void bar() {\n"
                           "  AB ab;\n"
-                          "  foo(&ab); \n"
+                          "  foo(&ab);\n"
                           "};");
             ASSERT_EQUALS(true, db != nullptr);
-            if (db) {
-                const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( & ab");
-                ASSERT_EQUALS(true, f && f->function());
-                if (f && f->function()) {
-                    const Function *func = f->function();
-                    ASSERT_EQUALS(true, func->tokenDef->linenr() == 2 && func->argumentList.size() == 1 && func->argumentList.front().type());
-                    if (func->argumentList.size() == 1 && func->argumentList.front().type()) {
-                        const Type * type = func->argumentList.front().type();
-                        ASSERT_EQUALS(true, type->classDef->linenr() == 1);
-                    }
-                }
-            }
+            const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( & ab");
+            ASSERT_EQUALS(true, f && f->function());
+            const Function *func = f->function();
+            ASSERT_EQUALS(true, func->tokenDef->linenr() == 2 && func->argumentList.size() == 1 && func->argumentList.front().type());
+            const Type * type = func->argumentList.front().type();
+            ASSERT_EQUALS(true, type->classDef->linenr() == 1);
         }
     }
 
@@ -2082,18 +2835,12 @@ class TestSymbolDatabase: public TestFixture {
                       "  foo(b);\n"
                       "}");
         ASSERT_EQUALS(true, db != nullptr);
-        if (db) {
-            const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( b");
-            ASSERT_EQUALS(true, f && f->function());
-            if (f && f->function()) {
-                const Function *func = f->function();
-                ASSERT_EQUALS(true, func->tokenDef->linenr() == 4 && func->argumentList.size() == 1 && func->argumentList.front().type());
-                if (func->argumentList.size() == 1 && func->argumentList.front().type()) {
-                    const Type * type = func->argumentList.front().type();
-                    ASSERT_EQUALS(true, type->isStructType());
-                }
-            }
-        }
+        const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( b");
+        ASSERT_EQUALS(true, f && f->function());
+        const Function *func = f->function();
+        ASSERT_EQUALS(true, func->tokenDef->linenr() == 4 && func->argumentList.size() == 1 && func->argumentList.front().type());
+        const Type * type = func->argumentList.front().type();
+        ASSERT_EQUALS(true, type->isStructType());
     }
 
     void functionArgs9() { // #7657
@@ -2104,18 +2851,12 @@ class TestSymbolDatabase: public TestFixture {
                       "};\n"
                       "void foo(A::B::C c) { }");
         ASSERT_EQUALS(true, db != nullptr);
-        if (db) {
-            const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo (");
-            ASSERT_EQUALS(true, f && f->function());
-            if (f && f->function()) {
-                const Function *func = f->function();
-                ASSERT_EQUALS(true, func->argumentList.size() == 1 && func->argumentList.front().type());
-                if (func->argumentList.size() == 1 && func->argumentList.front().type()) {
-                    const Type * type = func->argumentList.front().type();
-                    ASSERT_EQUALS(true, type->isEnumType());
-                }
-            }
-        }
+        const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo (");
+        ASSERT_EQUALS(true, f && f->function());
+        const Function *func = f->function();
+        ASSERT_EQUALS(true, func->argumentList.size() == 1 && func->argumentList.front().type());
+        const Type * type = func->argumentList.front().type();
+        ASSERT_EQUALS(true, type->isEnumType());
     }
 
     void functionArgs10() {
@@ -2125,21 +2866,15 @@ class TestSymbolDatabase: public TestFixture {
                       "};\n"
                       "Fred::Fred(Whitespace whitespace) { }");
         ASSERT_EQUALS(true, db != nullptr);
-        if (db) {
-            ASSERT_EQUALS(3, db->scopeList.size());
-            if (db->scopeList.size() == 3) {
-                std::list<Scope>::const_iterator scope = db->scopeList.begin();
-                ++scope;
-                ASSERT_EQUALS((unsigned int)Scope::eClass, (unsigned int)scope->type);
-                ASSERT_EQUALS(1, scope->functionList.size());
-                ASSERT(scope->functionList.begin()->functionScope != nullptr);
-                if (scope->functionList.begin()->functionScope) {
-                    const Scope * functionScope = scope->functionList.begin()->functionScope;
-                    ++scope;
-                    ASSERT(functionScope == &*scope);
-                }
-            }
-        }
+        ASSERT_EQUALS(3, db->scopeList.size());
+        auto scope = db->scopeList.cbegin();
+        ++scope;
+        ASSERT_EQUALS_ENUM(ScopeType::eClass, scope->type);
+        ASSERT_EQUALS(1, scope->functionList.size());
+        ASSERT(scope->functionList.cbegin()->functionScope != nullptr);
+        const Scope * functionScope = scope->functionList.cbegin()->functionScope;
+        ++scope;
+        ASSERT(functionScope == &*scope);
     }
 
     void functionArgs11() {
@@ -2149,21 +2884,15 @@ class TestSymbolDatabase: public TestFixture {
                       "};\n"
                       "void Fred::foo(char b[16]) { }");
         ASSERT_EQUALS(true, db != nullptr);
-        if (db) {
-            ASSERT_EQUALS(3, db->scopeList.size());
-            if (db->scopeList.size() == 3) {
-                std::list<Scope>::const_iterator scope = db->scopeList.begin();
-                ++scope;
-                ASSERT_EQUALS((unsigned int)Scope::eClass, (unsigned int)scope->type);
-                ASSERT_EQUALS(1, scope->functionList.size());
-                ASSERT(scope->functionList.begin()->functionScope != nullptr);
-                if (scope->functionList.begin()->functionScope) {
-                    const Scope * functionScope = scope->functionList.begin()->functionScope;
-                    ++scope;
-                    ASSERT(functionScope == &*scope);
-                }
-            }
-        }
+        ASSERT_EQUALS(3, db->scopeList.size());
+        auto scope = db->scopeList.cbegin();
+        ++scope;
+        ASSERT_EQUALS_ENUM(ScopeType::eClass, scope->type);
+        ASSERT_EQUALS(1, scope->functionList.size());
+        ASSERT(scope->functionList.cbegin()->functionScope != nullptr);
+        const Scope * functionScope = scope->functionList.cbegin()->functionScope;
+        ++scope;
+        ASSERT(functionScope == &*scope);
     }
 
     void functionArgs12() { // #7661
@@ -2176,18 +2905,12 @@ class TestSymbolDatabase: public TestFixture {
                       "};");
 
         ASSERT_EQUALS(true, db != nullptr);
-        if (db) {
-            const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo (");
-            ASSERT_EQUALS(true, f && f->function());
-            if (f && f->function()) {
-                const Function *func = f->function();
-                ASSERT_EQUALS(true, func->argumentList.size() == 1 && func->argumentList.front().type());
-                if (func->argumentList.size() == 1 && func->argumentList.front().type()) {
-                    const Type * type = func->argumentList.front().type();
-                    ASSERT_EQUALS(true, type->isEnumType());
-                }
-            }
-        }
+        const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo (");
+        ASSERT_EQUALS(true, f && f->function());
+        const Function *func = f->function();
+        ASSERT_EQUALS(true, func->argumentList.size() == 1 && func->argumentList.front().type());
+        const Type * type = func->argumentList.front().type();
+        ASSERT_EQUALS(true, type->isEnumType());
     }
 
     void functionArgs13() { // #7697
@@ -2203,28 +2926,19 @@ class TestSymbolDatabase: public TestFixture {
                       "B::B(A::S s) { }");
 
         ASSERT_EQUALS(true, db != nullptr);
-        if (db) {
-            const Token *f = Token::findsimplematch(tokenizer.tokens(), "B ( A :: E");
-            ASSERT_EQUALS(true, f && f->function());
-            if (f && f->function()) {
-                const Function *func = f->function();
-                ASSERT_EQUALS(true, func->argumentList.size() == 1 && func->argumentList.front().type());
-                if (func->argumentList.size() == 1 && func->argumentList.front().type()) {
-                    const Type * type = func->argumentList.front().type();
-                    ASSERT_EQUALS(true, type->isEnumType() && type->name() == "E");
-                }
-            }
-            f = Token::findsimplematch(tokenizer.tokens(), "B ( A :: S");
-            ASSERT_EQUALS(true, f && f->function());
-            if (f && f->function()) {
-                const Function *func = f->function();
-                ASSERT_EQUALS(true, func->argumentList.size() == 1 && func->argumentList.front().type());
-                if (func->argumentList.size() == 1 && func->argumentList.front().type()) {
-                    const Type * type = func->argumentList.front().type();
-                    ASSERT_EQUALS(true, type->isStructType() && type->name() == "S");
-                }
-            }
-        }
+        const Token *f = Token::findsimplematch(tokenizer.tokens(), "B ( A :: E");
+        ASSERT_EQUALS(true, f && f->function());
+        const Function *func = f->function();
+        ASSERT_EQUALS(true, func->argumentList.size() == 1 && func->argumentList.front().type());
+        const Type * type = func->argumentList.front().type();
+        ASSERT_EQUALS(true, type->isEnumType() && type->name() == "E");
+
+        f = Token::findsimplematch(tokenizer.tokens(), "B ( A :: S");
+        ASSERT_EQUALS(true, f && f->function());
+        const Function *func2 = f->function();
+        ASSERT_EQUALS(true, func2->argumentList.size() == 1 && func2->argumentList.front().type());
+        const Type * type2 = func2->argumentList.front().type();
+        ASSERT_EQUALS(true, type2->isStructType() && type2->name() == "S");
     }
 
     void functionArgs14() { // #7697
@@ -2233,6 +2947,150 @@ class TestSymbolDatabase: public TestFixture {
         const Function *func = tokenizer.tokens()->next()->function();
         ASSERT_EQUALS(true, func != nullptr);
         ASSERT_EQUALS(2, func ? func->argCount() : 0);
+        ASSERT_EQUALS(0, func ? func->initializedArgCount() : 1);
+        ASSERT_EQUALS(2, func ? func->minArgCount() : 0);
+    }
+
+    void functionArgs15() { // #7159
+        const char code[] =
+            "class Class {\n"
+            "    void Method(\n"
+            "        char c = []()->char {\n"
+            "            int d = rand();\n"// the '=' on this line used to reproduce the defect
+            "            return d;\n"
+            "        }()\n"
+            "    );\n"
+            "};\n";
+        GET_SYMBOL_DB(code);
+        ASSERT(db);
+        ASSERT_EQUALS(2, db->scopeList.size());
+        const Scope& classScope = db->scopeList.back();
+        ASSERT_EQUALS_ENUM(ScopeType::eClass, classScope.type);
+        ASSERT_EQUALS("Class", classScope.className);
+        ASSERT_EQUALS(1, classScope.functionList.size());
+        const Function& method = classScope.functionList.front();
+        ASSERT_EQUALS("Method", method.name());
+        ASSERT_EQUALS(1, method.argCount());
+        ASSERT_EQUALS(1, method.initializedArgCount());
+        ASSERT_EQUALS(0, method.minArgCount());
+    }
+
+    void functionArgs16() { // #9591
+        const char code[] =
+            "struct A { int var; };\n"
+            "void foo(int x, decltype(A::var) *&p) {}";
+        GET_SYMBOL_DB(code);
+        ASSERT(db);
+        const Scope *scope = db->functionScopes.front();
+        const Function *func = scope->function;
+        ASSERT_EQUALS(2, func->argCount());
+        const Variable *arg2 = func->getArgumentVar(1);
+        ASSERT_EQUALS("p", arg2->name());
+        ASSERT(arg2->isPointer());
+        ASSERT(arg2->isReference());
+    }
+
+    void functionArgs17() {
+        const char code[] = "void f(int (*fp)(), int x, int y) {}";
+        GET_SYMBOL_DB(code);
+        ASSERT(db != nullptr);
+        const Scope *scope = db->functionScopes.front();
+        const Function *func = scope->function;
+        ASSERT_EQUALS(3, func->argCount());
+    }
+
+    void functionArgs18() {
+        const char code[] = "void f(int (*param1)[2], int param2) {}";
+        GET_SYMBOL_DB(code);
+        ASSERT(db != nullptr);
+        const Scope *scope = db->functionScopes.front();
+        const Function *func = scope->function;
+        ASSERT_EQUALS(2, func->argCount());
+    }
+
+    void functionArgs19() {
+        const char code[] = "void f(int (*fp)(int), int x, int y) {}";
+        GET_SYMBOL_DB(code);
+        ASSERT(db != nullptr);
+        const Scope *scope = db->functionScopes.front();
+        const Function *func = scope->function;
+        ASSERT_EQUALS(3, func->argCount());
+    }
+
+    void functionArgs20() {
+        {
+            const char code[] = "void f(void *(*g)(void *) = [](void *p) { return p; }) {}"; // #11769
+            GET_SYMBOL_DB(code);
+            ASSERT(db != nullptr);
+            const Scope *scope = db->functionScopes.front();
+            const Function *func = scope->function;
+            ASSERT_EQUALS(1, func->argCount());
+            const Variable* arg = func->getArgumentVar(0);
+            TODO_ASSERT(arg->hasDefault());
+        }
+        {
+            const char code[] = "void f() { auto g = [&](const std::function<int(int)>& h = [](int i) -> int { return i; }) {}; }"; // #12338
+            GET_SYMBOL_DB(code);
+            ASSERT(db != nullptr);
+            ASSERT_EQUALS(3, db->scopeList.size());
+            ASSERT_EQUALS_ENUM(ScopeType::eLambda, db->scopeList.back().type);
+        }
+        {
+            const char code[] = "void f() {\n"
+                                "    auto g = [&](const std::function<const std::vector<int>&(const std::vector<int>&)>& h = [](const std::vector<int>& v) -> const std::vector<int>& { return v; }) {};\n"
+                                "}\n";
+            GET_SYMBOL_DB(code);
+            ASSERT(db != nullptr);
+            ASSERT_EQUALS(3, db->scopeList.size());
+            ASSERT_EQUALS_ENUM(ScopeType::eLambda, db->scopeList.back().type);
+        }
+        {
+            const char code[] = "void f() {\n"
+                                "    auto g = [&](const std::function<int(int)>& h = [](int i) -> decltype(0) { return i; }) {};\n"
+                                "}\n";
+            GET_SYMBOL_DB(code);
+            ASSERT(db != nullptr);
+            ASSERT_EQUALS(3, db->scopeList.size());
+            ASSERT_EQUALS_ENUM(ScopeType::eLambda, db->scopeList.back().type);
+        }
+    }
+
+    void functionArgs21() {
+        const char code[] = "void f(std::vector<int>::size_type) {}\n" // #11408
+                            "template<typename T>\n"
+                            "struct S { using t = int; };\n"
+                            "template<typename T>\n"
+                            "S<T> operator+(const S<T>&lhs, typename S<T>::t) { return lhs; }";
+        GET_SYMBOL_DB(code);
+        ASSERT(db != nullptr);
+        auto it = db->functionScopes.begin();
+        const Function *func = (*it)->function;
+        ASSERT_EQUALS("f", func->name());
+        ASSERT_EQUALS(1, func->argCount());
+        const Variable* arg = func->getArgumentVar(0);
+        ASSERT_EQUALS("", arg->name());
+        ++it;
+        func = (*it)->function;
+        ASSERT_EQUALS("operator+", func->name());
+        ASSERT_EQUALS(2, func->argCount());
+        arg = func->getArgumentVar(1);
+        ASSERT_EQUALS("", arg->name());
+    }
+
+    void functionArgs22() {
+        const char code[] = "typedef void (*callback_fn)(void);\n"
+                            "void ext_func(const callback_fn cb, size_t v) {}\n";
+        GET_SYMBOL_DB(code);
+        ASSERT(db != nullptr);
+        ASSERT_EQUALS(1U, db->functionScopes.size());
+        const auto it = db->functionScopes.cbegin();
+        const Function *func = (*it)->function;
+        ASSERT_EQUALS("ext_func", func->name());
+        ASSERT_EQUALS(2, func->argCount());
+        const Variable *arg = func->getArgumentVar(0);
+        ASSERT_EQUALS("cb", arg->name());
+        arg = func->getArgumentVar(1);
+        ASSERT_EQUALS("v", arg->name());
     }
 
     void functionImplicitlyVirtual() {
@@ -2240,13 +3098,53 @@ class TestSymbolDatabase: public TestFixture {
                       "class derived : base { void f(); };\n"
                       "void derived::f() {}");
         ASSERT(db != nullptr);
-        if (!db)
-            return;
         ASSERT_EQUALS(4, db->scopeList.size());
         const Function *function = db->scopeList.back().function;
         ASSERT_EQUALS(true, function && function->isImplicitlyVirtual(false));
     }
 
+    void functionGetOverridden() {
+        GET_SYMBOL_DB("struct B { virtual void f(); };\n"
+                      "struct D : B {\n"
+                      "public:\n"
+                      "    void f() override;\n"
+                      "};\n"
+                      "struct D2 : D { void f() override {} };\n");
+        ASSERT(db != nullptr);
+        ASSERT_EQUALS(5, db->scopeList.size());
+        const Function *func = db->scopeList.back().function;
+        ASSERT(func && func->nestedIn);
+        ASSERT_EQUALS("D2", func->nestedIn->className);
+        bool foundAllBaseClasses{};
+        const Function* baseFunc = func->getOverriddenFunction(&foundAllBaseClasses);
+        ASSERT(baseFunc && baseFunc->nestedIn && foundAllBaseClasses);
+        ASSERT_EQUALS("D", baseFunc->nestedIn->className);
+    }
+
+    void functionIsInlineKeyword() {
+        GET_SYMBOL_DB("inline void fs() {}");
+        (void)db;
+        const Function *func = db->scopeList.back().function;
+        ASSERT(func);
+        ASSERT(func->isInlineKeyword());
+    }
+
+    void functionStatic() {
+        GET_SYMBOL_DB("static void fs() {  }");
+        (void)db;
+        const Function *func = db->scopeList.back().function;
+        ASSERT(func);
+        ASSERT(func->isStatic());
+    }
+
+    void functionReturnsReference() {
+        GET_SYMBOL_DB("Fred::Reference foo();");
+        ASSERT_EQUALS(1, db->scopeList.back().functionList.size());
+        const Function &func = *db->scopeList.back().functionList.cbegin();
+        ASSERT(!Function::returnsReference(&func, false));
+        ASSERT(Function::returnsReference(&func, true));
+    }
+
     void namespaces1() {
         GET_SYMBOL_DB("namespace fred {\n"
                       "    namespace barney {\n"
@@ -2256,13 +3154,10 @@ class TestSymbolDatabase: public TestFixture {
                       "namespace barney { X::X(int) { } }");
 
         // Locate the scope for the class..
-        const Scope *scope = nullptr;
-        for (const Scope & it : db->scopeList) {
-            if (it.isClassOrStruct()) {
-                scope = &it;
-                break;
-            }
-        }
+        auto it = std::find_if(db->scopeList.cbegin(), db->scopeList.cend(), [](const Scope& s) {
+            return s.isClassOrStruct();
+        });
+        const Scope *scope = (it == db->scopeList.end()) ? nullptr : &*it;
 
         ASSERT(scope != nullptr);
         if (!scope)
@@ -2290,13 +3185,10 @@ class TestSymbolDatabase: public TestFixture {
                       "}");
 
         // Locate the scope for the class..
-        const Scope *scope = nullptr;
-        for (const Scope & it : db->scopeList) {
-            if (it.isClassOrStruct()) {
-                scope = &it;
-                break;
-            }
-        }
+        auto it = std::find_if(db->scopeList.cbegin(), db->scopeList.cend(), [](const Scope& s) {
+            return s.isClassOrStruct();
+        });
+        const Scope* scope = (it == db->scopeList.end()) ? nullptr : &*it;
 
         ASSERT(scope != nullptr);
         if (!scope)
@@ -2315,8 +3207,8 @@ class TestSymbolDatabase: public TestFixture {
         GET_SYMBOL_DB("namespace fred UNKNOWN_MACRO(default) {\n"
                       "}");
         ASSERT_EQUALS(2U, db->scopeList.size());
-        ASSERT_EQUALS(Scope::eGlobal, db->scopeList.front().type);
-        ASSERT_EQUALS(Scope::eNamespace, db->scopeList.back().type);
+        ASSERT_EQUALS_ENUM(ScopeType::eGlobal, db->scopeList.front().type);
+        ASSERT_EQUALS_ENUM(ScopeType::eNamespace, db->scopeList.back().type);
     }
 
     void namespaces4() { // #4698 - type lookup
@@ -2329,6 +3221,46 @@ class TestSymbolDatabase: public TestFixture {
         ASSERT_EQUALS(2U, fredAType->classDef->linenr());
     }
 
+    void namespaces5() { // #13967
+        GET_SYMBOL_DB("namespace test {\n"
+                      "  template <int S>\n"
+                      "  struct Test { int x[S]; };\n"
+                      "  const Test<64> test;\n"
+                      "}\n");
+        const Variable *x = db->getVariableFromVarId(2U);
+        ASSERT_EQUALS("x", x->name());
+        const Scope *scope = x->scope();
+        ASSERT(scope->nestedIn);
+        ASSERT_EQUALS("test", scope->nestedIn->className);
+    }
+
+    void needInitialization() {
+        {
+            GET_SYMBOL_DB_DBG("template <typename T>\n" // #10259
+                              "struct A {\n"
+                              "    using type = T;\n"
+                              "    type t_;\n"
+                              "};\n");
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            GET_SYMBOL_DB_DBG("class T;\n" // #12367
+                              "struct S {\n"
+                              "    S(T& t);\n"
+                              "    T& _t;\n"
+                              "};\n");
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            GET_SYMBOL_DB_DBG("struct S {\n" // #12395
+                              "    static S s;\n"
+                              "};\n");
+            ASSERT_EQUALS("", errout_str());
+            const Variable* const s = db->getVariableFromVarId(1);
+            ASSERT(s->scope()->definedType->needInitialization == Type::NeedInitialization::False);
+        }
+    }
+
     void tryCatch1() {
         const char str[] = "void foo() {\n"
                            "    try { }\n"
@@ -2338,7 +3270,7 @@ class TestSymbolDatabase: public TestFixture {
                            "    catch (X::Error4 x) { }\n"
                            "}";
         GET_SYMBOL_DB(str);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         ASSERT(db && db->variableList().size() == 5); // index 0 + 4 variables
         ASSERT(db && db->scopeList.size() == 7); // global + function + try + 4 catch
     }
@@ -2348,25 +3280,25 @@ class TestSymbolDatabase: public TestFixture {
         check("namespace foo {\n"
               "    class bar;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class foo : public bar < int, int> {\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase2() {
         check("class foo {\n"
-              "public slots :\n"
+              "public:\n"
               "foo() { }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class foo {\n"
               "class bar;\n"
               "foo() { }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase3() {
@@ -2374,18 +3306,23 @@ class TestSymbolDatabase: public TestFixture {
               "struct A {\n"
               "    friend func_type f : 2;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase4() {
         check("static void function_declaration_before(void) __attribute__((__used__));\n"
               "static void function_declaration_before(void) {}\n"
               "static void function_declaration_after(void) {}\n"
-              "static void function_declaration_after(void) __attribute__((__used__));\n");
-        ASSERT_EQUALS("", errout.str());
+              "static void function_declaration_after(void) __attribute__((__used__));");
+        ASSERT_EQUALS("", errout_str());
+
+        check("main(int argc, char *argv[]) { }", true, false);
+        ASSERT_EQUALS("", errout_str());
 
-        check("main(int argc, char *argv[]) { }", true, "test.c");
-        ASSERT_EQUALS("[test.c:1]: (debug) SymbolDatabase::isFunction found C function 'main' without a return type.\n", errout.str());
+        const Settings s = settingsBuilder(settings1).severity(Severity::portability).build();
+        check("main(int argc, char *argv[]) { }", false, false, &s);
+        ASSERT_EQUALS("[test.c:1:1]: (portability) Omitted return type of function 'main' defaults to int, this is not supported by ISO C99 and later standards. [returnImplicitInt]\n",
+                      errout_str());
 
         check("namespace boost {\n"
               "    std::locale generate_locale()\n"
@@ -2393,7 +3330,7 @@ class TestSymbolDatabase: public TestFixture {
               "        return std::locale();\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("namespace X {\n"
               "    static void function_declaration_before(void) __attribute__((__used__));\n"
@@ -2401,20 +3338,22 @@ class TestSymbolDatabase: public TestFixture {
               "    static void function_declaration_after(void) {}\n"
               "    static void function_declaration_after(void) __attribute__((__used__));\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("testing::testing()\n"
               "{\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:1]: (debug) Executable scope 'testing' with unknown function.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:1:10]: (debug) Executable scope 'testing' with unknown function. [symbolDatabaseWarning]\n"
+            "[test.cpp:1:10]: (debug) Executable scope 'testing' with unknown function. [symbolDatabaseWarning]\n", // duplicate
+            errout_str());
     }
 
     void symboldatabase5() {
         // ticket #2178 - segmentation fault
-        check("int CL_INLINE_DECL(integer_decode_float) (int x) {\n"
-              "    return (sign ? cl_I() : 0);\n"
-              "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_THROW_INTERNAL(check("int CL_INLINE_DECL(integer_decode_float) (int x) {\n"
+                                    "    return (sign ? cl_I() : 0);\n"
+                                    "}"), UNKNOWN_MACRO);
     }
 
     void symboldatabase6() {
@@ -2426,7 +3365,7 @@ class TestSymbolDatabase: public TestFixture {
               "Y<X<1>> x3;\n"
               "Y<X<6>>1>> x4;\n"
               "Y<X<(6>>1)>> x5;\n", false);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase7() {
@@ -2441,7 +3380,7 @@ class TestSymbolDatabase: public TestFixture {
               "public:\n"
               "    int f() { return C< ::D,int>::f(); }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase8() {
@@ -2455,7 +3394,7 @@ class TestSymbolDatabase: public TestFixture {
               "    }\n"
               "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase9() {
@@ -2469,7 +3408,7 @@ class TestSymbolDatabase: public TestFixture {
               "    }\n"
               "};\n", false);
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase10() {
@@ -2482,7 +3421,7 @@ class TestSymbolDatabase: public TestFixture {
               "  friend void A::f();\n"
               "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase11() {
@@ -2492,7 +3431,7 @@ class TestSymbolDatabase: public TestFixture {
               "  int i : (false ? g () : 1);\n"
               "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase12() {
@@ -2501,7 +3440,7 @@ class TestSymbolDatabase: public TestFixture {
               "    void bar2 () = __null;\n"
               "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase13() {
@@ -2510,32 +3449,35 @@ class TestSymbolDatabase: public TestFixture {
               "    void bar2 () = A::f;\n"
               "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase14() {
         // ticket #2589 - segmentation fault
-        ASSERT_THROW(check("struct B : A\n"), InternalError);
+        ASSERT_THROW_INTERNAL(check("struct B : A\n"), SYNTAX);
     }
 
     void symboldatabase17() {
         // ticket #2657 - segmentation fault
-        check("return f(){}");
+        check("{return f(){}}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase19() {
         // ticket #2991 - segmentation fault
         check("::y(){x}");
 
-        ASSERT_EQUALS_WITHOUT_LINENUMBERS("[test.cpp:1]: (debug) Executable scope 'y' with unknown function.\n"
-                                          "[test.cpp:1]: (debug) valueflow.cpp:1321:valueFlowTerminatingCondition bailout: Skipping function due to incomplete variable x\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:1:3]: (debug) Executable scope 'y' with unknown function. [symbolDatabaseWarning]\n"
+            "[test.cpp:1:7]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable x [valueFlowBailoutIncompleteVar]\n"
+            "[test.cpp:1:3]: (debug) Executable scope 'y' with unknown function. [symbolDatabaseWarning]\n", // duplicate
+            errout_str());
     }
 
     void symboldatabase20() {
         // ticket #3013 - segmentation fault
-        ASSERT_THROW(check("struct x : virtual y\n"), InternalError);
+        ASSERT_THROW_INTERNAL(check("struct x : virtual y\n"), SYNTAX);
     }
 
     void symboldatabase21() {
@@ -2547,14 +3489,14 @@ class TestSymbolDatabase: public TestFixture {
               "    Foo foo;\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // ticket 3437 (segmentation fault)
     void symboldatabase22() {
         check("template <class C> struct A {};\n"
-              "A<int> a;\n");
-        ASSERT_EQUALS("", errout.str());
+              "A<int> a;");
+        ASSERT_EQUALS("", errout_str());
     }
 
     // ticket 3435 (std::vector)
@@ -2580,14 +3522,11 @@ class TestSymbolDatabase: public TestFixture {
         ASSERT_EQUALS(4U, db->scopeList.size());
 
         // Find the scope for the Fred struct..
-        const Scope *fredScope = nullptr;
-        for (const Scope & scope : db->scopeList) {
-            if (scope.isClassOrStruct() && scope.className == "Fred")
-                fredScope = &scope;
-        }
+        auto it = std::find_if(db->scopeList.cbegin(), db->scopeList.cend(), [&](const Scope& scope) {
+            return scope.isClassOrStruct() && scope.className == "Fred";
+        });
+        const Scope* fredScope = (it == db->scopeList.end()) ? nullptr : &*it;
         ASSERT(fredScope != nullptr);
-        if (fredScope == nullptr)
-            return;
 
         // The struct Fred has two functions, a constructor and a destructor
         ASSERT_EQUALS(2U, fredScope->functionList.size());
@@ -2595,11 +3534,11 @@ class TestSymbolDatabase: public TestFixture {
         // Get linenumbers where the bodies for the constructor and destructor are..
         unsigned int constructor = 0;
         unsigned int destructor = 0;
-        for (const Function & it : fredScope->functionList) {
-            if (it.type == Function::eConstructor)
-                constructor = it.token->linenr();  // line number for constructor body
-            if (it.type == Function::eDestructor)
-                destructor = it.token->linenr();  // line number for destructor body
+        for (const Function& f : fredScope->functionList) {
+            if (f.type == FunctionType::eConstructor)
+                constructor = f.token->linenr();  // line number for constructor body
+            if (f.type == FunctionType::eDestructor)
+                destructor = f.token->linenr();  // line number for destructor body
         }
 
         // The body for the constructor is located at line 5..
@@ -2617,7 +3556,7 @@ class TestSymbolDatabase: public TestFixture {
                            "    throw bar;\n"
                            "}";
         GET_SYMBOL_DB(str);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         ASSERT(db && db->variableList().size() == 2); // index 0 + 1 variable
     }
 
@@ -2627,7 +3566,7 @@ class TestSymbolDatabase: public TestFixture {
                            "    throw bar;\n"
                            "}";
         GET_SYMBOL_DB_C(str);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         ASSERT(db && db->variableList().size() == 2); // index 0 + 1 variable
     }
 
@@ -2638,7 +3577,7 @@ class TestSymbolDatabase: public TestFixture {
               "    B1()\n"
               "    {} C(int) : B1() class\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase28() {
@@ -2652,7 +3591,7 @@ class TestSymbolDatabase: public TestFixture {
         check("struct B : A {\n"
               "    B() : A {}\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase30() {
@@ -2684,11 +3623,10 @@ class TestSymbolDatabase: public TestFixture {
                       "::Foo::Sub::Sub() { }\n"
                       "class Foo;\n"
                       "class Bar;\n"
-                      "class Sub;\n");
+                      "class Sub;");
         ASSERT(db && db->typeList.size() == 5);
-        if (!db || db->typeList.size() < 5)
-            return;
-        std::list<Type>::const_iterator i = db->typeList.begin();
+
+        auto i = db->typeList.cbegin();
         const Type* Foo = &(*i++);
         const Type* Bar = &(*i++);
         const Type* Sub = &(*i++);
@@ -2728,18 +3666,17 @@ class TestSymbolDatabase: public TestFixture {
               "struct S {\n"
               "  _Atomic union { int n; };\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:1]: (debug) Failed to parse 'typedef _Atomic ( int ) & atomic_int_ref ;'. The checking continues anyway. [simplifyTypedef]\n", errout_str());
     }
 
     void symboldatabase35() { // ticket #4806 and #4841
         check("class FragmentQueue : public CL_NS(util)::PriorityQueue<CL_NS(util)::Deletor::Object<TextFragment> >\n"
               "{};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase36() { // ticket #4892
-        check("void struct ( ) { if ( 1 ) } int main ( ) { }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_THROW_INTERNAL(check("void struct ( ) { if ( 1 ) } int main ( ) { }"), SYNTAX);
     }
 
     void symboldatabase37() {
@@ -2753,11 +3690,10 @@ class TestSymbolDatabase: public TestFixture {
                       "    Fred(const struct Barney & b) { barney = b; }\n"
                       "private:\n"
                       "    struct Barney barney;\n"
-                      "};\n");
+                      "};");
         ASSERT(db && db->typeList.size() == 3);
-        if (!db || db->typeList.size() != 3)
-            return;
-        std::list<Type>::const_iterator i = db->typeList.begin();
+
+        auto i = db->typeList.cbegin();
         const Type* Fred = &(*i++);
         const Type* Wilma = &(*i++);
         const Type* Barney = &(*i++);
@@ -2765,8 +3701,7 @@ class TestSymbolDatabase: public TestFixture {
         ASSERT(Wilma && Wilma->classDef && Wilma->classScope && Wilma->enclosingScope && Wilma->name() == "Wilma");
         ASSERT(Barney && Barney->classDef && Barney->classScope && Barney->enclosingScope && Barney->name() == "Barney");
         ASSERT(db->variableList().size() == 5);
-        if (db->variableList().size() != 5)
-            return;
+
         ASSERT(db->getVariableFromVarId(1) && db->getVariableFromVarId(1)->type() && db->getVariableFromVarId(1)->type()->name() == "Barney");
         ASSERT(db->getVariableFromVarId(2) && db->getVariableFromVarId(2)->type() && db->getVariableFromVarId(2)->type()->name() == "Wilma");
         ASSERT(db->getVariableFromVarId(3) && db->getVariableFromVarId(3)->type() && db->getVariableFromVarId(3)->type()->name() == "Barney");
@@ -2788,17 +3723,17 @@ class TestSymbolDatabase: public TestFixture {
         check("void f() {\n"
               "    try {  }\n"
               "    catch (std::bad_alloc) {  }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase41() { // ticket #5197 (unknown macro)
-        GET_SYMBOL_DB("struct X1 { MACRO1 f(int spd) MACRO2; };\n");
+        GET_SYMBOL_DB("struct X1 { MACRO1 f(int spd) MACRO2; };");
         ASSERT(db && db->findScopeByName("X1") && db->findScopeByName("X1")->functionList.size() == 1 && !db->findScopeByName("X1")->functionList.front().hasBody());
     }
 
     void symboldatabase42() { // only put variables in variable list
-        GET_SYMBOL_DB("void f() { extern int x(); }\n");
+        GET_SYMBOL_DB("void f() { extern int x(); }");
         ASSERT(db != nullptr);
         const Scope * const fscope = db ? db->findScopeByName("f") : nullptr;
         ASSERT(fscope != nullptr);
@@ -2808,8 +3743,8 @@ class TestSymbolDatabase: public TestFixture {
     void symboldatabase43() { // ticket #4738
         check("void f() {\n"
               "    new int;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase44() {
@@ -2847,14 +3782,14 @@ class TestSymbolDatabase: public TestFixture {
             ASSERT(db->getVariableFromVarId(i) != nullptr);
 
         ASSERT_EQUALS(4U, db->scopeList.size());
-        std::list<Scope>::const_iterator scope = db->scopeList.begin();
-        ASSERT_EQUALS(Scope::eGlobal, scope->type);
+        auto scope = db->scopeList.cbegin();
+        ASSERT_EQUALS_ENUM(ScopeType::eGlobal, scope->type);
         ++scope;
-        ASSERT_EQUALS(Scope::eStruct, scope->type);
+        ASSERT_EQUALS_ENUM(ScopeType::eStruct, scope->type);
         ++scope;
-        ASSERT_EQUALS(Scope::eStruct, scope->type);
+        ASSERT_EQUALS_ENUM(ScopeType::eStruct, scope->type);
         ++scope;
-        ASSERT_EQUALS(Scope::eFunction, scope->type);
+        ASSERT_EQUALS_ENUM(ScopeType::eFunction, scope->type);
     }
 
     void symboldatabase46() { // #6171 (anonymous namespace)
@@ -2865,16 +3800,16 @@ class TestSymbolDatabase: public TestFixture {
 
         ASSERT(db != nullptr);
         ASSERT_EQUALS(4U, db->scopeList.size());
-        std::list<Scope>::const_iterator scope = db->scopeList.begin();
-        ASSERT_EQUALS(Scope::eGlobal, scope->type);
+        auto scope = db->scopeList.cbegin();
+        ASSERT_EQUALS_ENUM(ScopeType::eGlobal, scope->type);
         ++scope;
-        ASSERT_EQUALS(Scope::eStruct, scope->type);
+        ASSERT_EQUALS_ENUM(ScopeType::eStruct, scope->type);
         ASSERT_EQUALS(scope->className, "S");
         ++scope;
-        ASSERT_EQUALS(Scope::eNamespace, scope->type);
+        ASSERT_EQUALS_ENUM(ScopeType::eNamespace, scope->type);
         ASSERT_EQUALS(scope->className, "");
         ++scope;
-        ASSERT_EQUALS(Scope::eStruct, scope->type);
+        ASSERT_EQUALS_ENUM(ScopeType::eStruct, scope->type);
         ASSERT_EQUALS(scope->className, "S");
     }
 
@@ -2900,22 +3835,22 @@ class TestSymbolDatabase: public TestFixture {
                       "}\n"
                       "using namespace NS;\n"
                       "MyClass::~MyClass() { }\n"
-                      "MyClass::MyClass() { }\n");
+                      "MyClass::MyClass() { }");
         ASSERT(db && !db->functionScopes.empty() && db->functionScopes.front()->function && db->functionScopes.front()->function->functionScope == db->functionScopes.front());
 
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "MyClass ( ) ;");
-        ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 3  && f->function()->token->linenr() == 9);
+        ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 3 && f->function()->token->linenr() == 9);
 
         f = Token::findsimplematch(tokenizer.tokens(), "~ MyClass ( ) ;");
         f = f->next();
-        ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 4  && f->function()->token->linenr() == 8);
+        ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 4 && f->function()->token->linenr() == 8);
     }
 
     void symboldatabase49() { // #6424
         GET_SYMBOL_DB("namespace Ns { class C; }\n"
                       "void f1() { char *p; *p = 0; }\n"
                       "class Ns::C* p;\n"
-                      "void f2() { char *p; *p = 0; }\n");
+                      "void f2() { char *p; *p = 0; }");
         ASSERT(db != nullptr);
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "p ; void f2");
         ASSERT_EQUALS(true, db && f && f->variable());
@@ -2952,16 +3887,14 @@ class TestSymbolDatabase: public TestFixture {
                       "static const float f3 = 2 * std::foo3(a, b);\n"
                       "static const float f4 = c * foo4(a, b);\n"
                       "static const int i1 = 2 & foo5(a, b);\n"
-                      "static const bool b1 = 2 > foo6(a, b);\n");
+                      "static const bool b1 = 2 > foo6(a, b);");
         ASSERT(db != nullptr);
-        if (db) {
-            ASSERT(findFunctionByName("foo1", &db->scopeList.front()) == nullptr);
-            ASSERT(findFunctionByName("foo2", &db->scopeList.front()) == nullptr);
-            ASSERT(findFunctionByName("foo3", &db->scopeList.front()) == nullptr);
-            ASSERT(findFunctionByName("foo4", &db->scopeList.front()) == nullptr);
-            ASSERT(findFunctionByName("foo5", &db->scopeList.front()) == nullptr);
-            ASSERT(findFunctionByName("foo6", &db->scopeList.front()) == nullptr);
-        }
+        ASSERT(findFunctionByName("foo1", &db->scopeList.front()) == nullptr);
+        ASSERT(findFunctionByName("foo2", &db->scopeList.front()) == nullptr);
+        ASSERT(findFunctionByName("foo3", &db->scopeList.front()) == nullptr);
+        ASSERT(findFunctionByName("foo4", &db->scopeList.front()) == nullptr);
+        ASSERT(findFunctionByName("foo5", &db->scopeList.front()) == nullptr);
+        ASSERT(findFunctionByName("foo6", &db->scopeList.front()) == nullptr);
     }
 
     void symboldatabase52() { // #6581
@@ -2971,12 +3904,10 @@ class TestSymbolDatabase: public TestFixture {
                       "}");
 
         ASSERT(db != nullptr);
-        if (db) {
-            ASSERT_EQUALS(2, db->scopeList.size());
-            ASSERT_EQUALS(2, db->variableList().size()-1);
-            ASSERT(db->getVariableFromVarId(1) != nullptr);
-            ASSERT(db->getVariableFromVarId(2) != nullptr);
-        }
+        ASSERT_EQUALS(2, db->scopeList.size());
+        ASSERT_EQUALS(2, db->variableList().size()-1);
+        ASSERT(db->getVariableFromVarId(1) != nullptr);
+        ASSERT(db->getVariableFromVarId(2) != nullptr);
     }
 
     void symboldatabase53() { // #7124
@@ -2984,12 +3915,10 @@ class TestSymbolDatabase: public TestFixture {
                       "std::int32_t y;");
 
         ASSERT(db != nullptr);
-        if (db) {
-            ASSERT(db->getVariableFromVarId(1) != nullptr);
-            ASSERT(db->getVariableFromVarId(2) != nullptr);
-            ASSERT_EQUALS(false, db->getVariableFromVarId(1)->isClass());
-            ASSERT_EQUALS(false, db->getVariableFromVarId(2)->isClass());
-        }
+        ASSERT(db->getVariableFromVarId(1) != nullptr);
+        ASSERT(db->getVariableFromVarId(2) != nullptr);
+        ASSERT_EQUALS(false, db->getVariableFromVarId(1)->isClass());
+        ASSERT_EQUALS(false, db->getVariableFromVarId(2)->isClass());
     }
 
     void symboldatabase54() { // #7343
@@ -3000,11 +3929,9 @@ class TestSymbolDatabase: public TestFixture {
                       "};");
 
         ASSERT(db != nullptr);
-        if (db) {
-            ASSERT_EQUALS(1U, db->functionScopes.size());
-            ASSERT_EQUALS("getReg", db->functionScopes.front()->className);
-            ASSERT_EQUALS(true, db->functionScopes.front()->function->hasOverrideSpecifier());
-        }
+        ASSERT_EQUALS(1U, db->functionScopes.size());
+        ASSERT_EQUALS("getReg", db->functionScopes.front()->className);
+        ASSERT_EQUALS(true, db->functionScopes.front()->function->hasOverrideSpecifier());
     }
 
     void symboldatabase55() { // #7767
@@ -3013,10 +3940,8 @@ class TestSymbolDatabase: public TestFixture {
                       "}");
 
         ASSERT(db != nullptr);
-        if (db) {
-            ASSERT_EQUALS(1U, db->functionScopes.size());
-            ASSERT_EQUALS("testfunc", db->functionScopes.front()->className);
-        }
+        ASSERT_EQUALS(1U, db->functionScopes.size());
+        ASSERT_EQUALS("testfunc", db->functionScopes.front()->className);
     }
 
     void symboldatabase56() { // #7909
@@ -3030,11 +3955,9 @@ class TestSymbolDatabase: public TestFixture {
                           "}");
 
             ASSERT(db != nullptr);
-            if (db) {
-                ASSERT_EQUALS(0U, db->functionScopes.size());
-                ASSERT(db->scopeList.back().type == Scope::eClass && db->scopeList.back().className == "NestedClass");
-                ASSERT(db->scopeList.back().functionList.size() == 1U && !db->scopeList.back().functionList.front().hasBody());
-            }
+            ASSERT_EQUALS(0U, db->functionScopes.size());
+            ASSERT(db->scopeList.back().type == ScopeType::eClass && db->scopeList.back().className == "NestedClass");
+            ASSERT(db->scopeList.back().functionList.size() == 1U && !db->scopeList.back().functionList.front().hasBody());
         }
         {
             GET_SYMBOL_DB("class Class {\n"
@@ -3043,21 +3966,17 @@ class TestSymbolDatabase: public TestFixture {
                           "}");
 
             ASSERT(db != nullptr);
-            if (db) {
-                ASSERT_EQUALS(1U, db->functionScopes.size());
-                ASSERT(db->scopeList.back().type == Scope::eFunction && db->scopeList.back().className == "f2");
-                ASSERT(db->scopeList.back().function && db->scopeList.back().function->hasBody());
-            }
+            ASSERT_EQUALS(1U, db->functionScopes.size());
+            ASSERT(db->scopeList.back().type == ScopeType::eFunction && db->scopeList.back().className == "f2");
+            ASSERT(db->scopeList.back().function && db->scopeList.back().function->hasBody());
         }
         {
             GET_SYMBOL_DB_C("friend f1();\n"
-                            "friend f2() { }\n");
+                            "friend f2() { }");
 
             ASSERT(db != nullptr);
-            if (db) {
-                ASSERT_EQUALS(2U, db->scopeList.size());
-                ASSERT_EQUALS(2U, db->scopeList.begin()->functionList.size());
-            }
+            ASSERT_EQUALS(2U, db->scopeList.size());
+            ASSERT_EQUALS(2U, db->scopeList.cbegin()->functionList.size());
         }
     }
 
@@ -3070,16 +3989,12 @@ class TestSymbolDatabase: public TestFixture {
                       "         return 1;\n"
                       "}");
         ASSERT(db != nullptr);
-        if (db) {
-            ASSERT(db->scopeList.size() == 4U);
-            if (db->scopeList.size() == 4U) {
-                std::list<Scope>::const_iterator it = db->scopeList.begin();
-                ASSERT(it->type == Scope::eGlobal);
-                ASSERT((++it)->type == Scope::eFunction);
-                ASSERT((++it)->type == Scope::eIf);
-                ASSERT((++it)->type == Scope::eElse);
-            }
-        }
+        ASSERT(db->scopeList.size() == 4U);
+        auto it = db->scopeList.cbegin();
+        ASSERT(it->type == ScopeType::eGlobal);
+        ASSERT((++it)->type == ScopeType::eFunction);
+        ASSERT((++it)->type == ScopeType::eIf);
+        ASSERT((++it)->type == ScopeType::eElse);
     }
 
     void symboldatabase58() { // #6985 (using namespace type lookup)
@@ -3094,25 +4009,15 @@ class TestSymbolDatabase: public TestFixture {
                       "    };\n"
                       "};");
         ASSERT(db != nullptr);
-        if (db) {
-            ASSERT(db->typeList.size() == 3U);
-            if (db->typeList.size() == 3U) {
-                std::list<Type>::const_iterator it = db->typeList.begin();
-                const Type * classB = &(*it);
-                const Type * classC = &(*(++it));
-                const Type * classA = &(*(++it));
-                ASSERT(classA->name() == "A" && classB->name() == "B" && classC->name() == "C");
-                if (classA->name() == "A" && classB->name() == "B" && classC->name() == "C") {
-                    ASSERT(classA->derivedFrom.size() == 1U);
-                    if (classA->derivedFrom.size() == 1) {
-                        ASSERT(classA->derivedFrom[0].type != nullptr);
-                        if (classA->derivedFrom[0].type != nullptr) {
-                            ASSERT(classA->derivedFrom[0].type == classB);
-                        }
-                    }
-                }
-            }
-        }
+        ASSERT(db->typeList.size() == 3U);
+        auto it = db->typeList.cbegin();
+        const Type * classB = &(*it);
+        const Type * classC = &(*(++it));
+        const Type * classA = &(*(++it));
+        ASSERT(classA->name() == "A" && classB->name() == "B" && classC->name() == "C");
+        ASSERT(classA->derivedFrom.size() == 1U);
+        ASSERT(classA->derivedFrom[0].type != nullptr);
+        ASSERT(classA->derivedFrom[0].type == classB);
     }
 
     void symboldatabase59() { // #8465
@@ -3157,17 +4062,11 @@ class TestSymbolDatabase: public TestFixture {
                           "}");
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 5);
-            if (db && db->scopeList.size() == 5) {
-                const Scope *scope = db->findScopeByName("A");
-                ASSERT(scope != nullptr);
-                if (scope) {
-                    const Function *function = findFunctionByName("Foo", scope);
-                    ASSERT(function != nullptr);
-                    if (function) {
-                        ASSERT(function->hasBody());
-                    }
-                }
-            }
+            const Scope *scope = db->findScopeByName("A");
+            ASSERT(scope != nullptr);
+            const Function *function = findFunctionByName("Foo", scope);
+            ASSERT(function != nullptr);
+            ASSERT(function->hasBody());
         }
         {
             GET_SYMBOL_DB("class A {\n"
@@ -3182,17 +4081,11 @@ class TestSymbolDatabase: public TestFixture {
                           "}");
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 5);
-            if (db && db->scopeList.size() == 5) {
-                const Scope *scope = db->findScopeByName("A");
-                ASSERT(scope != nullptr);
-                if (scope) {
-                    const Function *function = findFunctionByName("Foo", scope);
-                    ASSERT(function != nullptr);
-                    if (function) {
-                        ASSERT(function->hasBody());
-                    }
-                }
-            }
+            const Scope *scope = db->findScopeByName("A");
+            ASSERT(scope != nullptr);
+            const Function *function = findFunctionByName("Foo", scope);
+            ASSERT(function != nullptr);
+            ASSERT(function->hasBody());
         }
         {
             GET_SYMBOL_DB("struct A {\n"
@@ -3207,17 +4100,11 @@ class TestSymbolDatabase: public TestFixture {
                           "}");
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 5);
-            if (db && db->scopeList.size() == 5) {
-                const Scope *scope = db->findScopeByName("A");
-                ASSERT(scope != nullptr);
-                if (scope) {
-                    const Function *function = findFunctionByName("Foo", scope);
-                    ASSERT(function != nullptr);
-                    if (function) {
-                        ASSERT(function->hasBody());
-                    }
-                }
-            }
+            const Scope *scope = db->findScopeByName("A");
+            ASSERT(scope != nullptr);
+            const Function *function = findFunctionByName("Foo", scope);
+            ASSERT(function != nullptr);
+            ASSERT(function->hasBody());
         }
         {
             GET_SYMBOL_DB("struct A {\n"
@@ -3232,17 +4119,11 @@ class TestSymbolDatabase: public TestFixture {
                           "}");
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 5);
-            if (db && db->scopeList.size() == 5) {
-                const Scope *scope = db->findScopeByName("A");
-                ASSERT(scope != nullptr);
-                if (scope) {
-                    const Function *function = findFunctionByName("Foo", scope);
-                    ASSERT(function != nullptr);
-                    if (function) {
-                        ASSERT(function->hasBody());
-                    }
-                }
-            }
+            const Scope *scope = db->findScopeByName("A");
+            ASSERT(scope != nullptr);
+            const Function *function = findFunctionByName("Foo", scope);
+            ASSERT(function != nullptr);
+            ASSERT(function->hasBody());
         }
     }
 
@@ -3659,7 +4540,7 @@ class TestSymbolDatabase: public TestFixture {
                           "    ~impl() { }\n"
                           "    impl(const impl &) { }\n"
                           "    void foo(const impl &, const impl &) const { }\n"
-                          "};\n");
+                          "};");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 7);
@@ -3702,7 +4583,7 @@ class TestSymbolDatabase: public TestFixture {
                           "template <typename A> Fred<A>::impl::impl() { }\n"
                           "template <typename A> Fred<A>::impl::~impl() { }\n"
                           "template <typename A> Fred<A>::impl::impl(const Fred<A>::impl &) { }\n"
-                          "template <typename A> void Fred<A>::impl::foo(const Fred<A>::impl &, const Fred<A>::impl &) const { }\n");
+                          "template <typename A> void Fred<A>::impl::foo(const Fred<A>::impl &, const Fred<A>::impl &) const { }");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 7);
@@ -3833,7 +4714,7 @@ class TestSymbolDatabase: public TestFixture {
                           "template <typename A> NS::Fred<A>::impl::impl() { }\n"
                           "template <typename A> NS::Fred<A>::impl::~impl() { }\n"
                           "template <typename A> NS::Fred<A>::impl::impl(const NS::Fred<A>::impl &) { }\n"
-                          "template <typename A> void NS::Fred<A>::impl::foo(const NS::Fred<A>::impl &, const NS::Fred<A>::impl &) const { }\n");
+                          "template <typename A> void NS::Fred<A>::impl::foo(const NS::Fred<A>::impl &, const NS::Fred<A>::impl &) const { }");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 8);
@@ -3919,7 +4800,7 @@ class TestSymbolDatabase: public TestFixture {
                           "template <typename A> NS::Fred<A>::impl::impl() { }\n"
                           "template <typename A> NS::Fred<A>::impl::~impl() { }\n"
                           "template <typename A> NS::Fred<A>::impl::impl(const NS::Fred<A>::impl &) { }\n"
-                          "template <typename A> void NS::Fred<A>::impl::foo(const NS::Fred<A>::impl &, const NS::Fred<A>::impl &) const { }\n");
+                          "template <typename A> void NS::Fred<A>::impl::foo(const NS::Fred<A>::impl &, const NS::Fred<A>::impl &) const { }");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 8);
@@ -4012,7 +4893,7 @@ class TestSymbolDatabase: public TestFixture {
                           "template <typename A> Fred<A>::impl::impl() { }\n"
                           "template <typename A> Fred<A>::impl::~impl() { }\n"
                           "template <typename A> Fred<A>::impl::impl(const Fred<A>::impl &) { }\n"
-                          "template <typename A> void Fred<A>::impl::foo(const Fred<A>::impl &, const Fred<A>::impl &) const { }\n");
+                          "template <typename A> void Fred<A>::impl::foo(const Fred<A>::impl &, const Fred<A>::impl &) const { }");
 
             ASSERT(db != nullptr);
             ASSERT(db && db->scopeList.size() == 8);
@@ -4049,7 +4930,13 @@ class TestSymbolDatabase: public TestFixture {
     void symboldatabase65() {
         // don't crash on missing links from instantiation of template with typedef
         check("int ( * X0 ) ( long ) < int ( ) ( long ) > :: f0 ( int * ) { return 0 ; }");
-        ASSERT_EQUALS("[test.cpp:1]: (debug) SymbolDatabase::findFunction found '>' without link.\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("int g();\n" // #11385
+              "void f(int i) {\n"
+              "    if (i > ::g()) {}\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void symboldatabase66() { // #8540
@@ -4077,7 +4964,7 @@ class TestSymbolDatabase: public TestFixture {
                       "struct Foo : Bar {\n"
                       "    virtual std::string get_endpoint_url() const noexcept override final;\n"
                       "};");
-        const Token *f = db ? Token::findsimplematch(tokenizer.tokens(), "get_endpoint_url ( ) const noexcept ;") : nullptr;
+        const Token *f = db ? Token::findsimplematch(tokenizer.tokens(), "get_endpoint_url ( ) const noexcept ( true ) ;") : nullptr;
         ASSERT(f != nullptr);
         ASSERT(f && f->function() && f->function()->token->linenr() == 2);
         ASSERT(f && f->function() && f->function()->hasVirtualSpecifier());
@@ -4085,7 +4972,7 @@ class TestSymbolDatabase: public TestFixture {
         ASSERT(f && f->function() && !f->function()->hasFinalSpecifier());
         ASSERT(f && f->function() && f->function()->isConst());
         ASSERT(f && f->function() && f->function()->isNoExcept());
-        f = db ? Token::findsimplematch(tokenizer.tokens(), "get_endpoint_url ( ) const noexcept override final ;") : nullptr;
+        f = db ? Token::findsimplematch(tokenizer.tokens(), "get_endpoint_url ( ) const noexcept ( true ) override final ;") : nullptr;
         ASSERT(f != nullptr);
         ASSERT(f && f->function() && f->function()->token->linenr() == 5);
         ASSERT(f && f->function() && f->function()->hasVirtualSpecifier());
@@ -4165,7 +5052,7 @@ class TestSymbolDatabase: public TestFixture {
         const Token * f = db ? Token::findsimplematch(tokenizer.tokens(), "B ( const B & ) { }") : nullptr;
         ASSERT(f != nullptr);
         ASSERT(f && f->function() && f->function()->token->linenr() == 4);
-        ASSERT(f && f->function() && f->function()->type == Function::eCopyConstructor);
+        ASSERT(f && f->function() && f->function()->type == FunctionType::eCopyConstructor);
     }
 
     void symboldatabase74() { // #8838 - final
@@ -4180,40 +5067,58 @@ class TestSymbolDatabase: public TestFixture {
     }
 
     void symboldatabase75() {
-        GET_SYMBOL_DB("template <typename T>\n"
-                      "class optional {\n"
-                      "  auto     value() & -> T &;\n"
-                      "  auto     value() && -> T &&;\n"
-                      "  auto     value() const& -> T const &;\n"
-                      "};\n"
-                      "template <typename T>\n"
-                      "auto optional<T>::value() & -> T & {}\n"
-                      "template <typename T>\n"
-                      "auto optional<T>::value() && -> T && {}\n"
-                      "template <typename T>\n"
-                      "auto optional<T>::value() const & -> T const & {}\n"
-                      "optional<int> i;");
-
-        ASSERT_EQUALS(5, db->scopeList.size());
-        ASSERT_EQUALS(3, db->functionScopes.size());
-
-        const Scope *f = db->functionScopes[0];
-        ASSERT(f->function->hasBody());
-        ASSERT(!f->function->isConst());
-        ASSERT(f->function->hasTrailingReturnType());
-        ASSERT(f->function->hasLvalRefQualifier());
+        {
+            GET_SYMBOL_DB("template <typename T>\n"
+                          "class optional {\n"
+                          "  auto     value() & -> T &;\n"
+                          "  auto     value() && -> T &&;\n"
+                          "  auto     value() const& -> T const &;\n"
+                          "};\n"
+                          "template <typename T>\n"
+                          "auto optional<T>::value() & -> T & {}\n"
+                          "template <typename T>\n"
+                          "auto optional<T>::value() && -> T && {}\n"
+                          "template <typename T>\n"
+                          "auto optional<T>::value() const & -> T const & {}\n"
+                          "optional<int> i;");
+
+            ASSERT_EQUALS(5, db->scopeList.size());
+            ASSERT_EQUALS(3, db->functionScopes.size());
+
+            const Scope *f = db->functionScopes[0];
+            ASSERT(f->function->hasBody());
+            ASSERT(!f->function->isConst());
+            ASSERT(f->function->hasTrailingReturnType());
+            ASSERT(f->function->hasLvalRefQualifier());
+
+            f = db->functionScopes[1];
+            ASSERT(f->function->hasBody());
+            ASSERT(!f->function->isConst());
+            ASSERT(f->function->hasTrailingReturnType());
+            ASSERT(f->function->hasRvalRefQualifier());
+
+            f = db->functionScopes[2];
+            ASSERT(f->function->hasBody());
+            ASSERT(f->function->isConst());
+            ASSERT(f->function->hasTrailingReturnType());
+            ASSERT(f->function->hasLvalRefQualifier());
+        }
+        {
+            GET_SYMBOL_DB("struct S {\n" // #12962
+                          "    auto bar() const noexcept -> std::string const& { return m; }\n"
+                          "    std::string m;\n"
+                          "};\n");
 
-        f = db->functionScopes[1];
-        ASSERT(f->function->hasBody());
-        ASSERT(!f->function->isConst());
-        ASSERT(f->function->hasTrailingReturnType());
-        ASSERT(f->function->hasRvalRefQualifier());
+            ASSERT_EQUALS(3, db->scopeList.size());
+            ASSERT_EQUALS(1, db->functionScopes.size());
 
-        f = db->functionScopes[2];
-        ASSERT(f->function->hasBody());
-        ASSERT(f->function->isConst());
-        ASSERT(f->function->hasTrailingReturnType());
-        ASSERT(f->function->hasLvalRefQualifier());
+            const Scope* f = db->functionScopes[0];
+            ASSERT(f->function->hasBody());
+            ASSERT(f->function->isConst());
+            ASSERT(f->function->hasTrailingReturnType());
+            ASSERT(f->function->isNoExcept());
+            ASSERT(Function::returnsReference(f->function));
+        }
     }
 
     void symboldatabase76() { // #9056
@@ -4242,194 +5147,1272 @@ class TestSymbolDatabase: public TestFixture {
                       "}\n"
                       "void e() { using c = a<>; }");
         ASSERT(db != nullptr);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void createSymbolDatabaseFindAllScopes1() {
-        GET_SYMBOL_DB("void f() { union {int x; char *p;} a={0}; }");
-        ASSERT(db->scopeList.size() == 3);
-        ASSERT_EQUALS(Scope::eUnion, db->scopeList.back().type);
+    void symboldatabase79() { // #9392
+        {
+            GET_SYMBOL_DB("class C { C(); };\n"
+                          "C::C() = default;");
+            ASSERT(db->scopeList.size() == 2);
+            ASSERT(db->scopeList.back().functionList.size() == 1);
+            ASSERT(db->scopeList.back().functionList.front().isDefault() == true);
+        }
+        {
+            GET_SYMBOL_DB("namespace ns {\n"
+                          "class C { C(); };\n"
+                          "}\n"
+                          "using namespace ns;\n"
+                          "C::C() = default;");
+            ASSERT(db->scopeList.size() == 3);
+            ASSERT(db->scopeList.back().functionList.size() == 1);
+            ASSERT(db->scopeList.back().functionList.front().isDefault() == true);
+        }
+        {
+            GET_SYMBOL_DB("class C { ~C(); };\n"
+                          "C::~C() = default;");
+            ASSERT(db->scopeList.size() == 2);
+            ASSERT(db->scopeList.back().functionList.size() == 1);
+            ASSERT(db->scopeList.back().functionList.front().isDefault() == true);
+            ASSERT(db->scopeList.back().functionList.front().isDestructor() == true);
+        }
+        {
+            GET_SYMBOL_DB("namespace ns {\n"
+                          "class C { ~C(); };\n"
+                          "}\n"
+                          "using namespace ns;\n"
+                          "C::~C() = default;");
+            ASSERT(db->scopeList.size() == 3);
+            ASSERT(db->scopeList.back().functionList.size() == 1);
+            ASSERT(db->scopeList.back().functionList.front().isDefault() == true);
+            ASSERT(db->scopeList.back().functionList.front().isDestructor() == true);
+        }
     }
 
-    void enum1() {
-        GET_SYMBOL_DB("enum BOOL { FALSE, TRUE }; enum BOOL b;");
-
-        /* there is a enum scope with the name BOOL */
-        ASSERT(db && db->scopeList.back().type == Scope::eEnum && db->scopeList.back().className == "BOOL");
-
-        /* b is a enum variable, type is BOOL */
-        ASSERT(db && db->getVariableFromVarId(1)->isEnumType());
+    void symboldatabase80() { // #9389
+        {
+            GET_SYMBOL_DB("namespace ns {\n"
+                          "class A {};\n"
+                          "}\n"
+                          "class AA {\n"
+                          "private:\n"
+                          "    void f(const ns::A&);\n"
+                          "};\n"
+                          "using namespace ns;\n"
+                          "void AA::f(const A&) { }");
+            ASSERT(db->scopeList.size() == 5);
+            ASSERT(db->functionScopes.size() == 1);
+            const Scope *scope = db->findScopeByName("AA");
+            ASSERT(scope);
+            ASSERT(scope->functionList.size() == 1);
+            ASSERT(scope->functionList.front().name() == "f");
+            ASSERT(scope->functionList.front().hasBody() == true);
+        }
+        {
+            GET_SYMBOL_DB("namespace ns {\n"
+                          "namespace ns1 {\n"
+                          "class A {};\n"
+                          "}\n"
+                          "}\n"
+                          "class AA {\n"
+                          "private:\n"
+                          "    void f(const ns::ns1::A&);\n"
+                          "};\n"
+                          "using namespace ns::ns1;\n"
+                          "void AA::f(const A&) { }");
+            ASSERT(db->scopeList.size() == 6);
+            ASSERT(db->functionScopes.size() == 1);
+            const Scope *scope = db->findScopeByName("AA");
+            ASSERT(scope);
+            ASSERT(scope->functionList.size() == 1);
+            ASSERT(scope->functionList.front().name() == "f");
+            ASSERT(scope->functionList.front().hasBody() == true);
+        }
+        {
+            GET_SYMBOL_DB("namespace ns {\n"
+                          "namespace ns1 {\n"
+                          "class A {};\n"
+                          "}\n"
+                          "}\n"
+                          "class AA {\n"
+                          "private:\n"
+                          "    void f(const ns::ns1::A&);\n"
+                          "};\n"
+                          "using namespace ns;\n"
+                          "void AA::f(const ns1::A&) { }");
+            ASSERT(db->scopeList.size() == 6);
+            ASSERT(db->functionScopes.size() == 1);
+            const Scope *scope = db->findScopeByName("AA");
+            ASSERT(scope);
+            ASSERT(scope->functionList.size() == 1);
+            ASSERT(scope->functionList.front().name() == "f");
+            ASSERT(scope->functionList.front().hasBody() == true);
+        }
     }
 
-    void enum2() {
-        GET_SYMBOL_DB("enum BOOL { FALSE, TRUE } b;");
-
-        /* there is a enum scope with the name BOOL */
-        ASSERT(db && db->scopeList.back().type == Scope::eEnum && db->scopeList.back().className == "BOOL");
+    void symboldatabase81() { // #9411
+        {
+            GET_SYMBOL_DB("namespace Terminal {\n"
+                          "    class Complete {\n"
+                          "    public:\n"
+                          "        std::string act(const Parser::Action *act);\n"
+                          "    };\n"
+                          "}\n"
+                          "using namespace std;\n"
+                          "using namespace Parser;\n"
+                          "using namespace Terminal;\n"
+                          "string Complete::act(const Action *act) { }");
+            ASSERT(db->scopeList.size() == 4);
+            ASSERT(db->functionScopes.size() == 1);
+            const Scope *scope = db->findScopeByName("Complete");
+            ASSERT(scope);
+            ASSERT(scope->functionList.size() == 1);
+            ASSERT(scope->functionList.front().name() == "act");
+            ASSERT(scope->functionList.front().hasBody() == true);
+        }
+        {
+            GET_SYMBOL_DB("namespace Terminal {\n"
+                          "    class Complete {\n"
+                          "    public:\n"
+                          "        std::string act(const Foo::Parser::Action *act);\n"
+                          "    };\n"
+                          "}\n"
+                          "using namespace std;\n"
+                          "using namespace Foo::Parser;\n"
+                          "using namespace Terminal;\n"
+                          "string Complete::act(const Action *act) { }");
+            ASSERT(db->scopeList.size() == 4);
+            ASSERT(db->functionScopes.size() == 1);
+            const Scope *scope = db->findScopeByName("Complete");
+            ASSERT(scope);
+            ASSERT(scope->functionList.size() == 1);
+            ASSERT(scope->functionList.front().name() == "act");
+            ASSERT(scope->functionList.front().hasBody() == true);
+        }
+    }
+
+    void symboldatabase82() {
+        GET_SYMBOL_DB("namespace foo { void foo() {} }");
+        ASSERT(db->functionScopes.size() == 1);
+        ASSERT_EQUALS(false, db->functionScopes[0]->function->isConstructor());
+    }
+
+    void symboldatabase83() { // #9431
+        GET_SYMBOL_DB_DBG("struct a { a() noexcept; };\n"
+                          "a::a() noexcept = default;");
+        const Scope *scope = db->findScopeByName("a");
+        ASSERT(scope);
+        ASSERT(scope->functionList.size() == 1);
+        ASSERT(scope->functionList.front().name() == "a");
+        ASSERT(scope->functionList.front().hasBody() == false);
+        ASSERT(scope->functionList.front().isConstructor() == true);
+        ASSERT(scope->functionList.front().isDefault() == true);
+        ASSERT(scope->functionList.front().isNoExcept() == true);
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void symboldatabase84() {
+        {
+            GET_SYMBOL_DB_DBG("struct a { a() noexcept(false); };\n"
+                              "a::a() noexcept(false) = default;");
+            const Scope *scope = db->findScopeByName("a");
+            ASSERT(scope);
+            ASSERT(scope->functionList.size() == 1);
+            ASSERT(scope->functionList.front().name() == "a");
+            ASSERT(scope->functionList.front().hasBody() == false);
+            ASSERT(scope->functionList.front().isConstructor() == true);
+            ASSERT(scope->functionList.front().isDefault() == true);
+            ASSERT(scope->functionList.front().isNoExcept() == false);
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            GET_SYMBOL_DB_DBG("struct a { a() noexcept(true); };\n"
+                              "a::a() noexcept(true) = default;");
+            const Scope *scope = db->findScopeByName("a");
+            ASSERT(scope);
+            ASSERT(scope->functionList.size() == 1);
+            ASSERT(scope->functionList.front().name() == "a");
+            ASSERT(scope->functionList.front().hasBody() == false);
+            ASSERT(scope->functionList.front().isConstructor() == true);
+            ASSERT(scope->functionList.front().isDefault() == true);
+            ASSERT(scope->functionList.front().isNoExcept() == true);
+            ASSERT_EQUALS("", errout_str());
+        }
+    }
 
-        /* b is a enum variable, type is BOOL */
-        ASSERT(db && db->getVariableFromVarId(1)->isEnumType());
+    void symboldatabase85() {
+        GET_SYMBOL_DB("class Fred {\n"
+                      "  enum Mode { Mode1, Mode2, Mode3 };\n"
+                      "  void f() { _mode = x; }\n"
+                      "  Mode _mode;\n"
+                      "  DECLARE_PROPERTY_FIELD(_mode);\n"
+                      "};");
+        const Token *vartok1 = Token::findsimplematch(tokenizer.tokens(), "_mode =");
+        ASSERT(vartok1);
+        ASSERT(vartok1->variable());
+        ASSERT(vartok1->variable()->scope());
+
+        const Token *vartok2 = Token::findsimplematch(tokenizer.tokens(), "( _mode ) ;")->next();
+        ASSERT_EQUALS(std::intptr_t(vartok1->variable()), std::intptr_t(vartok2->variable()));
+    }
+
+    void symboldatabase86() {
+        GET_SYMBOL_DB("class C { auto operator=(const C&) -> C&; };\n"
+                      "auto C::operator=(const C&) -> C& = default;");
+        ASSERT(db->scopeList.size() == 2);
+        ASSERT(db->scopeList.back().functionList.size() == 1);
+        ASSERT(db->scopeList.back().functionList.front().isDefault() == true);
+        ASSERT(db->scopeList.back().functionList.front().hasBody() == false);
+    }
+
+    void symboldatabase87() { // #9922 'extern const char ( * x [ 256 ] ) ;'
+        GET_SYMBOL_DB("extern const char ( * x [ 256 ] ) ;");
+        const Token *xtok = Token::findsimplematch(tokenizer.tokens(), "x");
+        ASSERT(xtok->variable());
+    }
+
+    void symboldatabase88() { // #10040 (using namespace)
+        check("namespace external {\n"
+              "namespace ns {\n"
+              "enum class s { O };\n"
+              "}\n"
+              "}\n"
+              "namespace internal {\n"
+              "namespace ns1 {\n"
+              "template <typename T>\n"
+              "void make(external::ns::s) {\n"
+              "}\n"
+              "}\n"
+              "}\n"
+              "using namespace external::ns;\n"
+              "struct A { };\n"
+              "static void make(external::ns::s ss) {\n"
+              "  internal::ns1::make<A>(ss);\n"
+              "}\n", true);
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void enum3() {
-        GET_SYMBOL_DB("enum ABC { A=11,B,C=A+B };");
-        ASSERT(db && db->scopeList.back().type == Scope::eEnum);
-        if (db) {
-            /* There is an enum A with value 11 */
-            const Enumerator *A = db->scopeList.back().findEnumerator("A");
-            ASSERT(A && A->value==11 && A->value_known);
+    void symboldatabase89() { // valuetype name
+        GET_SYMBOL_DB("namespace external {\n"
+                      "namespace ns1 {\n"
+                      "class A {\n"
+                      "public:\n"
+                      "  struct S { };\n"
+                      "  A(const S&) { }\n"
+                      "};\n"
+                      "static const A::S AS = A::S();\n"
+                      "}\n"
+                      "}\n"
+                      "using namespace external::ns1;\n"
+                      "A a{AS};");
+        const Token *vartok1 = Token::findsimplematch(tokenizer.tokens(), "A a");
+        ASSERT(vartok1);
+        ASSERT(vartok1->next());
+        ASSERT(vartok1->next()->variable());
+        ASSERT(vartok1->next()->variable()->valueType());
+        ASSERT(vartok1->next()->variable()->valueType()->str() == "external::ns1::A");
+    }
 
-            /* There is an enum B with value 12 */
-            const Enumerator *B = db->scopeList.back().findEnumerator("B");
-            ASSERT(B && B->value==12 && B->value_known);
+    void symboldatabase90() {
+        GET_SYMBOL_DB("struct Fred {\n"
+                      "    void foo(const int * const x);\n"
+                      "};\n"
+                      "void Fred::foo(const int * x) { }");
+        ASSERT_EQUALS("", errout_str());
+        const Token *functok = Token::findsimplematch(tokenizer.tokens(), "foo ( const int * x )");
+        ASSERT(functok);
+        ASSERT(functok->function());
+        ASSERT(functok->function()->name() == "foo");
+    }
+
+    void symboldatabase91() {
+        GET_SYMBOL_DB("namespace Fred {\n"
+                      "    struct Value {};\n"
+                      "    void foo(const std::vector<std::function<void(const Fred::Value &)>> &callbacks);\n"
+                      "}\n"
+                      "void Fred::foo(const std::vector<std::function<void(const Fred::Value &)>> &callbacks) { }");
+        ASSERT_EQUALS("", errout_str());
+        const Token *functok = Token::findsimplematch(tokenizer.tokens(),
+                                                      "foo ( const std :: vector < std :: function < void ( const Fred :: Value & ) > > & callbacks ) { }");
+        ASSERT(functok);
+        ASSERT(functok->function());
+        ASSERT(functok->function()->name() == "foo");
+    }
 
-            /* There is an enum C with value 23 */
-            const Enumerator *C = db->scopeList.back().findEnumerator("C");
-            ASSERT(C && C->value==23 && C->value_known);
+    void symboldatabase92() { // daca crash
+        {
+            GET_SYMBOL_DB("template <size_t, typename...> struct a;\n"
+                          "template <size_t b, typename c, typename... d>\n"
+                          "struct a<b, c, d...> : a<1, d...> {};\n"
+                          "template <typename... e> struct f : a<0, e...> {};");
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            GET_SYMBOL_DB("b.f();");
+            ASSERT_EQUALS("", errout_str());
         }
     }
 
-    void enum4() { // #7493
-        GET_SYMBOL_DB("enum Offsets { O1, O2, O3=5, O4 };\n"
-                      "enum MyEnums { E1=O1+1, E2, E3=O3+1 };");
+    void symboldatabase93() { // alignas attribute
+        GET_SYMBOL_DB("struct alignas(int) A{\n"
+                      "};\n"
+                      );
         ASSERT(db != nullptr);
-        if (!db)
-            return;
-        ASSERT_EQUALS(3U, db->scopeList.size());
+        const Scope* scope = db->findScopeByName("A");
+        ASSERT(scope);
+    }
 
-        // Assert that all enum values are known
-        std::list<Scope>::const_iterator scope = db->scopeList.begin();
+    void symboldatabase94() { // structured bindings
+        GET_SYMBOL_DB("int foo() { auto [x,y] = xy(); return x+y; }");
+        ASSERT(db != nullptr);
+        ASSERT(db->getVariableFromVarId(1) != nullptr);
+        ASSERT(db->getVariableFromVarId(2) != nullptr);
+    }
 
-        // Offsets
-        ++scope;
-        ASSERT_EQUALS((unsigned int)Scope::eEnum, (unsigned int)scope->type);
-        ASSERT_EQUALS(4U, scope->enumeratorList.size());
+    void symboldatabase95() { // #10295
+        GET_SYMBOL_DB("struct B {\n"
+                      "    void foo1(void);\n"
+                      "    void foo2();\n"
+                      "};\n"
+                      "void B::foo1() {}\n"
+                      "void B::foo2(void) {}\n");
+        ASSERT_EQUALS("", errout_str());
+        const Token *functok = Token::findsimplematch(tokenizer.tokens(), "foo1 ( ) { }");
+        ASSERT(functok);
+        ASSERT(functok->function());
+        ASSERT(functok->function()->name() == "foo1");
+        functok = Token::findsimplematch(tokenizer.tokens(), "foo2 ( ) { }");
+        ASSERT(functok);
+        ASSERT(functok->function());
+        ASSERT(functok->function()->name() == "foo2");
+    }
+
+    void symboldatabase96() { // #10126
+        GET_SYMBOL_DB("struct A {\n"
+                      "    int i, j;\n"
+                      "};\n"
+                      "std::map<int, A> m{ { 0, A{0,0} }, {0, A{0,0} } };\n");
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        ASSERT(scope->enumeratorList[0].name->enumerator() == &scope->enumeratorList[0]);
-        ASSERT_EQUALS((unsigned int)Token::eEnumerator, (unsigned int)scope->enumeratorList[0].name->tokType());
-        ASSERT(scope->enumeratorList[0].scope == &*scope);
-        ASSERT_EQUALS("O1", scope->enumeratorList[0].name->str());
-        ASSERT(scope->enumeratorList[0].start == nullptr);
-        ASSERT(scope->enumeratorList[0].end == nullptr);
-        ASSERT_EQUALS(true, scope->enumeratorList[0].value_known);
-        ASSERT_EQUALS(0, scope->enumeratorList[0].value);
+    void symboldatabase97() { // #10598 - final class
+        GET_SYMBOL_DB("template<> struct A<void> final {\n"
+                      "    A() {}\n"
+                      "};\n");
+        ASSERT(db);
+        ASSERT_EQUALS(3, db->scopeList.size());
 
-        ASSERT(scope->enumeratorList[1].name->enumerator() == &scope->enumeratorList[1]);
-        ASSERT_EQUALS((unsigned int)Token::eEnumerator, (unsigned int)scope->enumeratorList[1].name->tokType());
-        ASSERT(scope->enumeratorList[1].scope == &*scope);
-        ASSERT_EQUALS("O2", scope->enumeratorList[1].name->str());
-        ASSERT(scope->enumeratorList[1].start == nullptr);
-        ASSERT(scope->enumeratorList[1].end == nullptr);
-        ASSERT_EQUALS(true, scope->enumeratorList[1].value_known);
-        ASSERT_EQUALS(1, scope->enumeratorList[1].value);
+        const Token *functok = Token::findmatch(tokenizer.tokens(), "%name% (");
+        ASSERT(functok);
+        ASSERT(functok->function());
+        ASSERT_EQUALS_ENUM(functok->function()->type, FunctionType::eConstructor);
+    }
 
-        ASSERT(scope->enumeratorList[2].name->enumerator() == &scope->enumeratorList[2]);
-        ASSERT_EQUALS((unsigned int)Token::eEnumerator, (unsigned int)scope->enumeratorList[2].name->tokType());
-        ASSERT(scope->enumeratorList[2].scope == &*scope);
-        ASSERT_EQUALS("O3", scope->enumeratorList[2].name->str());
-        ASSERT(scope->enumeratorList[2].start != nullptr);
-        ASSERT(scope->enumeratorList[2].end != nullptr);
-        ASSERT_EQUALS(true, scope->enumeratorList[2].value_known);
-        ASSERT_EQUALS(5, scope->enumeratorList[2].value);
+    void symboldatabase98() { // #10451
+        {
+            GET_SYMBOL_DB("struct A { typedef struct {} B; };\n"
+                          "void f() {\n"
+                          "    auto g = [](A::B b) -> void { A::B b2 = b; };\n"
+                          "};\n");
+            ASSERT(db);
+            ASSERT_EQUALS(5, db->scopeList.size());
+        }
+        {
+            GET_SYMBOL_DB("typedef union {\n"
+                          "    int i;\n"
+                          "} U;\n"
+                          "template <auto U::*>\n"
+                          "void f();\n");
+            ASSERT(db);
+            ASSERT_EQUALS(2, db->scopeList.size());
+        }
+    }
 
-        ASSERT(scope->enumeratorList[3].name->enumerator() == &scope->enumeratorList[3]);
-        ASSERT_EQUALS((unsigned int)Token::eEnumerator, (unsigned int)scope->enumeratorList[3].name->tokType());
-        ASSERT(scope->enumeratorList[3].scope == &*scope);
-        ASSERT_EQUALS("O4", scope->enumeratorList[3].name->str());
-        ASSERT(scope->enumeratorList[3].start == nullptr);
-        ASSERT(scope->enumeratorList[3].end == nullptr);
-        ASSERT_EQUALS(true, scope->enumeratorList[3].value_known);
-        ASSERT_EQUALS(6, scope->enumeratorList[3].value);
+    void symboldatabase99() { // #10864
+        check("void f() { std::map<std::string, int> m; }");
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        // MyEnums
-        ++scope;
-        ASSERT_EQUALS((unsigned int)Scope::eEnum, (unsigned int)scope->type);
-        ASSERT_EQUALS(3U, scope->enumeratorList.size());
+    void symboldatabase100() {
+        {
+            GET_SYMBOL_DB("namespace N {\n" // #10174
+                          "    struct S {};\n"
+                          "    struct T { void f(S s); };\n"
+                          "    void T::f(N::S s) {}\n"
+                          "}\n");
+            ASSERT(db);
+            ASSERT_EQUALS(1, db->functionScopes.size());
+            auto it = std::find_if(db->scopeList.cbegin(), db->scopeList.cend(), [](const Scope& s) {
+                return s.className == "T";
+            });
+            ASSERT(it != db->scopeList.end());
+            const Function* function = findFunctionByName("f", &*it);
+            ASSERT(function && function->token->str() == "f");
+            ASSERT(function->hasBody());
+        }
+        {
+            GET_SYMBOL_DB("namespace N {\n" // #10198
+                          "    class I {};\n"
+                          "    class A {\n"
+                          "    public:\n"
+                          "        A(I*);\n"
+                          "    };\n"
+                          "}\n"
+                          "using N::I;\n"
+                          "namespace N {\n"
+                          "    A::A(I*) {}\n"
+                          "}\n");
+            ASSERT(db);
+            ASSERT_EQUALS(1, db->functionScopes.size());
+            auto it = std::find_if(db->scopeList.cbegin(), db->scopeList.cend(), [](const Scope& s) {
+                return s.className == "A";
+            });
+            ASSERT(it != db->scopeList.end());
+            const Function* function = findFunctionByName("A", &*it);
+            ASSERT(function && function->token->str() == "A");
+            ASSERT(function->hasBody());
+        }
+        {
+            GET_SYMBOL_DB("namespace N {\n" // #10260
+                          "    namespace O {\n"
+                          "        struct B;\n"
+                          "    }\n"
+                          "}\n"
+                          "struct I {\n"
+                          "    using B = N::O::B;\n"
+                          "};\n"
+                          "struct A : I {\n"
+                          "    void f(B*);\n"
+                          "};\n"
+                          "void A::f(N::O::B*) {}\n");
+            ASSERT(db);
+            ASSERT_EQUALS(1, db->functionScopes.size());
+            auto it = std::find_if(db->scopeList.cbegin(), db->scopeList.cend(), [](const Scope& s) {
+                return s.className == "A";
+            });
+            ASSERT(it != db->scopeList.end());
+            const Function* function = findFunctionByName("f", &*it);
+            ASSERT(function && function->token->str() == "f");
+            ASSERT(function->hasBody());
+        }
+    }
+
+    void symboldatabase101() {
+        GET_SYMBOL_DB("struct A { bool b; };\n"
+                      "void f(const std::vector<A>& v) {\n"
+                      "    std::vector<A>::const_iterator it = b.begin();\n"
+                      "    if (it->b) {}\n"
+                      "}\n");
+        ASSERT(db);
+        const Token* it = Token::findsimplematch(tokenizer.tokens(), "it . b");
+        ASSERT(it);
+        ASSERT(it->tokAt(2));
+        ASSERT(it->tokAt(2)->variable());
+    }
 
-        ASSERT(scope->enumeratorList[0].name->enumerator() == &scope->enumeratorList[0]);
-        ASSERT_EQUALS((unsigned int)Token::eEnumerator, (unsigned int)scope->enumeratorList[0].name->tokType());
-        ASSERT(scope->enumeratorList[0].scope == &*scope);
-        ASSERT_EQUALS("E1", scope->enumeratorList[0].name->str());
-        ASSERT(scope->enumeratorList[0].start != nullptr);
-        ASSERT(scope->enumeratorList[0].end != nullptr);
-        ASSERT_EQUALS(true, scope->enumeratorList[0].value_known);
-        ASSERT_EQUALS(1, scope->enumeratorList[0].value);
+    void symboldatabase102() {
+        GET_SYMBOL_DB("std::string f() = delete;\n"
+                      "void g() {}");
+        ASSERT(db);
+        ASSERT(db->scopeList.size() == 2);
+        ASSERT(db->scopeList.front().type == ScopeType::eGlobal);
+        ASSERT(db->scopeList.back().className == "g");
+    }
 
-        ASSERT(scope->enumeratorList[1].name->enumerator() == &scope->enumeratorList[1]);
-        ASSERT_EQUALS((unsigned int)Token::eEnumerator, (unsigned int)scope->enumeratorList[1].name->tokType());
-        ASSERT(scope->enumeratorList[1].scope == &*scope);
-        ASSERT_EQUALS("E2", scope->enumeratorList[1].name->str());
-        ASSERT(scope->enumeratorList[1].start == nullptr);
-        ASSERT(scope->enumeratorList[1].end == nullptr);
-        ASSERT_EQUALS(true, scope->enumeratorList[1].value_known);
-        ASSERT_EQUALS(2, scope->enumeratorList[1].value);
+    void symboldatabase103() {
+        GET_SYMBOL_DB("void f() {\n"
+                      "using lambda = decltype([]() { return true; });\n"
+                      "lambda{}();\n"
+                      "}\n");
+        ASSERT(db != nullptr);
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        ASSERT(scope->enumeratorList[2].name->enumerator() == &scope->enumeratorList[2]);
-        ASSERT_EQUALS((unsigned int)Token::eEnumerator, (unsigned int)scope->enumeratorList[2].name->tokType());
-        ASSERT(scope->enumeratorList[2].scope == &*scope);
-        ASSERT_EQUALS("E3", scope->enumeratorList[2].name->str());
-        ASSERT(scope->enumeratorList[2].start != nullptr);
-        ASSERT(scope->enumeratorList[2].end != nullptr);
-        ASSERT_EQUALS(true, scope->enumeratorList[2].value_known);
-        ASSERT_EQUALS(6, scope->enumeratorList[2].value);
+    void symboldatabase104() {
+        {
+            GET_SYMBOL_DB_DBG("struct S {\n" // #11535
+                              "    void f1(char* const c);\n"
+                              "    void f2(char* const c);\n"
+                              "    void f3(char* const);\n"
+                              "    void f4(char* c);\n"
+                              "    void f5(char* c);\n"
+                              "    void f6(char*);\n"
+                              "};\n"
+                              "void S::f1(char* c) {}\n"
+                              "void S::f2(char*) {}\n"
+                              "void S::f3(char* c) {}\n"
+                              "void S::f4(char* const c) {}\n"
+                              "void S::f5(char* const) {}\n"
+                              "void S::f6(char* const c) {}\n");
+            ASSERT(db != nullptr);
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            GET_SYMBOL_DB_DBG("struct S2 {\n" // #11602
+                              "    enum E {};\n"
+                              "};\n"
+                              "struct S1 {\n"
+                              "    void f(S2::E) const;\n"
+                              "};\n"
+                              "void S1::f(const S2::E) const {}\n");
+            ASSERT(db != nullptr);
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            GET_SYMBOL_DB_DBG("struct S {\n"
+                              "    void f(const bool b = false);\n"
+                              "};\n"
+                              "void S::f(const bool b) {}\n");
+            ASSERT(db != nullptr);
+            ASSERT_EQUALS("", errout_str());
+        }
     }
 
-    void enum5() {
-        GET_SYMBOL_DB("enum { A = 10, B = 2 };\n"
-                      "int a[10 + 2];\n"
-                      "int b[A];\n"
-                      "int c[A + 2];\n"
-                      "int d[10 + B];\n"
-                      "int e[A + B];\n");
-        ASSERT(db != nullptr);
-        if (!db)
-            return;
-        ASSERT_EQUALS(2U, db->scopeList.size());
+    void symboldatabase105() {
+        {
+            GET_SYMBOL_DB_DBG("template <class T>\n"
+                              "struct S : public std::deque<T> {\n"
+                              "    using std::deque<T>::clear;\n"
+                              "    void f();\n"
+                              "};\n"
+                              "template <class T>\n"
+                              "void S<T>::f() {\n"
+                              "    clear();\n"
+                              "}\n");
+            ASSERT(db != nullptr);
+            ASSERT_EQUALS("", errout_str());
+            const Token* const c = Token::findsimplematch(tokenizer.tokens(), "clear (");
+            ASSERT(!c->type());
+        }
+    }
 
-        // Assert that all enum values are known
-        std::list<Scope>::const_iterator scope = db->scopeList.begin();
+    void symboldatabase106() {
+        {
+            GET_SYMBOL_DB_DBG("namespace N {\n" // #12958 - don't crash
+                              "    namespace O {\n"
+                              "        using namespace N::O;\n"
+                              "    }\n"
+                              "}\n");
+            ASSERT(db != nullptr);
+            ASSERT_EQUALS("", errout_str());
+        }
+        {
+            GET_SYMBOL_DB_DBG("namespace N {\n"
+                              "    struct S {};\n"
+                              "}\n"
+                              "namespace O {\n"
+                              "    using namespace N;\n"
+                              "}\n"
+                              "namespace N {\n"
+                              "    using namespace O;\n"
+                              "    struct T {};\n"
+                              "}\n");
+            ASSERT(db != nullptr);
+            ASSERT_EQUALS("", errout_str());
+        }
+    }
 
-        ++scope;
-        ASSERT_EQUALS((unsigned int)Scope::eEnum, (unsigned int)scope->type);
-        ASSERT_EQUALS(2U, scope->enumeratorList.size());
-        ASSERT_EQUALS(true, scope->enumeratorList[0].value_known);
-        ASSERT_EQUALS(10, scope->enumeratorList[0].value);
-        ASSERT_EQUALS(true, scope->enumeratorList[1].value_known);
-        ASSERT_EQUALS(2, scope->enumeratorList[1].value);
+    void symboldatabase107() {
+        {
+            GET_SYMBOL_DB_DBG("void g(int);\n" // #13329
+                              "void f(int** pp) {\n"
+                              "    for (int i = 0; i < 2; i++) {\n"
+                              "        g(*pp[i]);\n"
+                              "    }\n"
+                              "}\n");
+            ASSERT(db != nullptr);
+            ASSERT_EQUALS("", errout_str());
+            ASSERT_EQUALS(3, db->scopeList.size());
+            ASSERT_EQUALS_ENUM(ScopeType::eFor, db->scopeList.back().type);
+            ASSERT_EQUALS(1, db->scopeList.back().varlist.size());
+            ASSERT_EQUALS("i", db->scopeList.back().varlist.back().name());
+        }
+        {
+            GET_SYMBOL_DB_DBG("void bar(int) {}\n" // #9960
+                              "void foo() {\n"
+                              "    std::vector<int*> a(10);\n"
+                              "    for (int i = 0; i < 10; i++)\n"
+                              "        bar(*a[4]);\n"
+                              "}\n");
+            ASSERT(db != nullptr);
+            ASSERT_EQUALS("", errout_str());
+            ASSERT_EQUALS(4, db->scopeList.size());
+            ASSERT_EQUALS_ENUM(ScopeType::eFor, db->scopeList.back().type);
+            ASSERT_EQUALS(1, db->scopeList.back().varlist.size());
+            ASSERT_EQUALS("i", db->scopeList.back().varlist.back().name());
+        }
+    }
 
-        ASSERT(db->variableList().size() == 6); // the first one is not used
-        const Variable * v = db->getVariableFromVarId(1);
-        ASSERT(v != nullptr);
-        if (!v)
-            return;
-        ASSERT(v->isArray());
-        ASSERT_EQUALS(1U, v->dimensions().size());
+    void symboldatabase108() {
+        {
+            GET_SYMBOL_DB("struct S {\n" // #13442
+                          "    S() = delete;\n"
+                          "    S(int a) : i(a) {}\n"
+                          "    ~S();\n"
+                          "    int i;\n"
+                          "};\n"
+                          "S::~S() = default;\n");
+            ASSERT_EQUALS(db->scopeList.size(), 3);
+            auto scope = db->scopeList.begin();
+            ++scope;
+            ASSERT_EQUALS(scope->className, "S");
+            const auto& flist = scope->functionList;
+            ASSERT_EQUALS(flist.size(), 3);
+            auto it = flist.begin();
+            ASSERT_EQUALS(it->name(), "S");
+            ASSERT_EQUALS(it->tokenDef->linenr(), 2);
+            ASSERT(it->isDelete());
+            ASSERT(!it->isDefault());
+            ASSERT_EQUALS_ENUM(it->type, FunctionType::eConstructor);
+            ++it;
+            ASSERT_EQUALS(it->name(), "S");
+            ASSERT_EQUALS(it->tokenDef->linenr(), 3);
+            ASSERT(!it->isDelete());
+            ASSERT(!it->isDefault());
+            ASSERT_EQUALS_ENUM(it->type, FunctionType::eConstructor);
+            ++it;
+            ASSERT_EQUALS(it->name(), "S");
+            ASSERT_EQUALS(it->tokenDef->linenr(), 4);
+            ASSERT(!it->isDelete());
+            ASSERT(it->isDefault());
+            ASSERT_EQUALS_ENUM(it->type, FunctionType::eDestructor);
+        }
+        {
+            GET_SYMBOL_DB("struct S {\n" // #13637
+                          "    ~S();\n"
+                          "};\n"
+                          "S::~S() = delete;\n");
+            ASSERT_EQUALS(db->scopeList.size(), 2);
+            auto scope = db->scopeList.begin();
+            ASSERT(!scope->functionOf);
+            ++scope;
+            ASSERT_EQUALS(scope->className, "S");
+            ASSERT_EQUALS(scope->functionList.size(), 1);
+            auto it = scope->functionList.begin();
+            ASSERT_EQUALS(it->name(), "S");
+            ASSERT_EQUALS(it->tokenDef->linenr(), 2);
+            ASSERT(it->isDelete());
+            ASSERT(!it->isDefault());
+            ASSERT_EQUALS_ENUM(it->type, FunctionType::eDestructor);
+        }
+    }
+
+    void symboldatabase109() { // #13553
+        GET_SYMBOL_DB("extern \"C\" {\n"
+                      "class Base {\n"
+                      "public:\n"
+                      "    virtual void show(void) = 0;\n"
+                      "};\n"
+                      "}\n");
+        const Token *f = db ? Token::findsimplematch(tokenizer.tokens(), "show") : nullptr;
+        ASSERT(f != nullptr);
+        ASSERT(f && f->function() && f->function()->hasVirtualSpecifier());
+    }
+
+    void symboldatabase110() { // #13498
+        GET_SYMBOL_DB("struct A;\n"
+                      "template <typename T, typename C>\n"
+                      "struct B {\n"
+                      "    const A& a;\n"
+                      "    const std::vector<C>& c;\n"
+                      "};\n"
+                      "template <typename T>\n"
+                      "struct B<T, void> {\n"
+                      "    const A& a;\n"
+                      "};\n"
+                      "template <typename T, typename C>\n"
+                      "void f(const A & a, const std::vector<C>&c) {\n"
+                      "    B<T, C>{ a, c };\n"
+                      "}\n");
+        const Token *B = db ? Token::findsimplematch(tokenizer.tokens(), "B < T , C >") : nullptr;
+        ASSERT(B && !B->type());
+    }
+
+    void symboldatabase111() {
+        GET_SYMBOL_DB("void f(int n) {\n"
+                      "    void g(), h(), i();\n"
+                      "    switch (n) {\n"
+                      "        case 1:\n"
+                      "        case 2:\n"
+                      "            g();\n"
+                      "            [[fallthrough]];\n"
+                      "        case 3:\n"
+                      "            h();\n"
+                      "            break;\n"
+                      "        default:\n"
+                      "            i();\n"
+                      "            break;\n"
+                      "    }\n"
+                      "}");
+        ASSERT(db != nullptr);
+        ASSERT_EQUALS("", errout_str());
+        const Token *case3 = Token::findsimplematch(tokenizer.tokens(), "case 3");
+        ASSERT(case3 && case3->isAttributeFallthrough());
+    }
+
+    void symboldatabase112() { // explicit operator
+        GET_SYMBOL_DB("class S {\n"
+                      "    explicit constexpr operator bool() const noexcept { return ptr_ != nullptr; }\n"
+                      "private:\n"
+                      "    void *ptr_{nullptr};\n"
+                      "};\n");
+        const Token *f = db ? Token::findsimplematch(tokenizer.tokens(), "operatorbool") : nullptr;
+        ASSERT(f != nullptr);
+        ASSERT(f && f->function() && f->function()->isExplicit());
+    }
+
+    void createSymbolDatabaseFindAllScopes1() {
+        GET_SYMBOL_DB("void f() { union {int x; char *p;} a={0}; }");
+        ASSERT(db->scopeList.size() == 3);
+        ASSERT_EQUALS_ENUM(ScopeType::eUnion, db->scopeList.back().type);
+    }
+
+    void createSymbolDatabaseFindAllScopes2() {
+        GET_SYMBOL_DB("namespace ns { auto var1{0}; }\n"
+                      "namespace ns { auto var2{0}; }\n");
+        ASSERT(db);
+        ASSERT_EQUALS(2, db->scopeList.size());
+        ASSERT_EQUALS(2, db->scopeList.back().varlist.size());
+        const Token* const var1 = Token::findsimplematch(tokenizer.tokens(), "var1");
+        const Token* const var2 = Token::findsimplematch(tokenizer.tokens(), "var2");
+        ASSERT(var1->variable());
+        ASSERT(var2->variable());
+    }
+
+    void createSymbolDatabaseFindAllScopes3() {
+        GET_SYMBOL_DB("namespace ns {\n"
+                      "\n"
+                      "namespace ns_details {\n"
+                      "template <typename T, typename = void> struct has_A : std::false_type {};\n"
+                      "template <typename T> struct has_A<T, typename make_void<typename T::A>::type> : std::true_type {};\n"
+                      "template <typename T, bool> struct is_A_impl : public std::is_trivially_copyable<T> {};\n"
+                      "template <typename T> struct is_A_impl<T, true> : public std::is_same<typename T::A, std::true_type> {};\n"
+                      "}\n"
+                      "\n"
+                      "template <typename T> struct is_A : ns_details::is_A_impl<T, ns_details::has_A<T>::value> {};\n"
+                      "template <class T, class U> struct is_A<std::pair<T, U>> : std::integral_constant<bool, is_A<T>::value && is_A<U>::value> {};\n"
+                      "}\n"
+                      "\n"
+                      "extern \"C\" {\n"
+                      "static const int foo = 8;\n"
+                      "}\n");
+        ASSERT(db);
+        ASSERT_EQUALS(9, db->scopeList.size());
+        ASSERT_EQUALS(1, db->scopeList.front().varlist.size());
+        auto list = db->scopeList;
+        list.pop_front();
+        ASSERT_EQUALS(true, std::all_of(list.cbegin(), list.cend(), [](const Scope& scope) {
+            return scope.varlist.empty();
+        }));
+    }
+
+    void createSymbolDatabaseFindAllScopes4()
+    {
+        GET_SYMBOL_DB("struct a {\n"
+                      "  void b() {\n"
+                      "    std::set<int> c;\n"
+                      "    a{[&] {\n"
+                      "      auto d{c.lower_bound(0)};\n"
+                      "      c.emplace_hint(d);\n"
+                      "    }};\n"
+                      "  }\n"
+                      "  template <class e> a(e);\n"
+                      "};\n");
+        ASSERT(db);
+        ASSERT_EQUALS(4, db->scopeList.size());
+        const Token* const var1 = Token::findsimplematch(tokenizer.tokens(), "d");
+        ASSERT(var1->variable());
+    }
+
+    void createSymbolDatabaseFindAllScopes5()
+    {
+        GET_SYMBOL_DB("class C {\n" // #11444
+                      "public:\n"
+                      "    template<typename T>\n"
+                      "    class D;\n"
+                      "    template<typename T>\n"
+                      "    struct O : public std::false_type {};\n"
+                      "};\n"
+                      "template<typename T>\n"
+                      "struct C::O<std::optional<T>> : public std::true_type {};\n"
+                      "template<typename T>\n"
+                      "class C::D {};\n"
+                      "struct S {\n"
+                      "    S(int i) : m(i) {}\n"
+                      "    static const S IN;\n"
+                      "    int m;\n"
+                      "};\n"
+                      "const S S::IN(1);\n");
+        ASSERT(db);
+        ASSERT_EQUALS(7, db->scopeList.size());
+        const Token* const var = Token::findsimplematch(tokenizer.tokens(), "IN (");
+        ASSERT(var && var->variable());
+        ASSERT_EQUALS(var->variable()->name(), "IN");
+        auto it = db->scopeList.cbegin();
+        std::advance(it, 5);
+        ASSERT_EQUALS(it->className, "S");
+        ASSERT_EQUALS(var->variable()->scope(), &*it);
+    }
+
+    void createSymbolDatabaseFindAllScopes6()
+    {
+        GET_SYMBOL_DB("class A {\n"
+                      "public:\n"
+                      "  class Nested {\n"
+                      "  public:\n"
+                      "    virtual ~Nested() = default;\n"
+                      "  };\n"
+                      "};\n"
+                      "class B {\n"
+                      "public:\n"
+                      "  class Nested {\n"
+                      "  public:\n"
+                      "    virtual ~Nested() = default;\n"
+                      "  };\n"
+                      "};\n"
+                      "class C : public A, public B {\n"
+                      "public:\n"
+                      "  class Nested : public A::Nested, public B::Nested {};\n"
+                      "};\n");
+        ASSERT(db);
+        ASSERT_EQUALS(6, db->typeList.size());
+        auto it = db->typeList.cbegin();
+        const Type& classA = *it++;
+        const Type& classNA = *it++;
+        const Type& classB = *it++;
+        const Type& classNB = *it++;
+        const Type& classC = *it++;
+        const Type& classNC = *it++;
+        ASSERT(classA.name() == "A" && classB.name() == "B" && classC.name() == "C");
+        ASSERT(classNA.name() == "Nested" && classNB.name() == "Nested" && classNC.name() == "Nested");
+        ASSERT(classA.derivedFrom.empty() && classB.derivedFrom.empty());
+        ASSERT_EQUALS(classC.derivedFrom.size(), 2U);
+        ASSERT_EQUALS(classC.derivedFrom[0].type, &classA);
+        ASSERT_EQUALS(classC.derivedFrom[1].type, &classB);
+        ASSERT(classNA.derivedFrom.empty() && classNB.derivedFrom.empty());
+        ASSERT_EQUALS(classNC.derivedFrom.size(), 2U);
+        ASSERT_EQUALS(classNC.derivedFrom[0].type, &classNA);
+        ASSERT_EQUALS(classNC.derivedFrom[1].type, &classNB);
+    }
+
+    void createSymbolDatabaseFindAllScopes7()
+    {
+        {
+            GET_SYMBOL_DB("namespace {\n"
+                          "    struct S {\n"
+                          "        void f();\n"
+                          "    };\n"
+                          "}\n"
+                          "void S::f() {}\n");
+            ASSERT(db);
+            ASSERT_EQUALS(4, db->scopeList.size());
+            auto anon = db->scopeList.begin();
+            ++anon;
+            ASSERT(anon->className.empty());
+            ASSERT_EQUALS_ENUM(anon->type, ScopeType::eNamespace);
+            auto S = anon;
+            ++S;
+            ASSERT_EQUALS_ENUM(S->type, ScopeType::eStruct);
+            ASSERT_EQUALS(S->className, "S");
+            ASSERT_EQUALS(S->nestedIn, &*anon);
+            const Token* f = Token::findsimplematch(tokenizer.tokens(), "f ( ) {");
+            ASSERT(f && f->function() && f->function()->functionScope && f->function()->functionScope->bodyStart);
+            ASSERT_EQUALS(f->function()->functionScope->functionOf, &*S);
+            ASSERT_EQUALS(f->function()->functionScope->bodyStart->linenr(), 6);
+        }
+        {
+            GET_SYMBOL_DB("namespace {\n"
+                          "    int i = 0;\n"
+                          "}\n"
+                          "namespace N {\n"
+                          "    namespace {\n"
+                          "        template<typename T>\n"
+                          "        struct S {\n"
+                          "            void f();\n"
+                          "        };\n"
+                          "        template<typename T>\n"
+                          "        void S<T>::f() {}\n"
+                          "    }\n"
+                          "    S<int> g() { return {}; }\n"
+                          "}\n");
+            ASSERT(db); // don't crash
+            ASSERT_EQUALS("", errout_str());
+        }
+    }
+
+    void createSymbolDatabaseFindAllScopes8() // #12761
+    {
+        // There are 2 myst constructors. They should belong to different scopes.
+        GET_SYMBOL_DB("template <class A = void, class B = void, class C = void>\n"
+                      "class Test {\n"
+                      "private:\n"
+                      "  template <class T>\n"
+                      "  struct myst {\n"
+                      "    T* x;\n"
+                      "    myst(T* y) : x(y){};\n"  // <- myst constructor
+                      "  };\n"
+                      "};\n"
+                      "\n"
+                      "template <class A, class B> class Test<A, B, void> {};\n"
+                      "\n"
+                      "template <>\n"
+                      "class Test<void, void, void> {\n"
+                      "private:\n"
+                      "  template <class T>\n"
+                      "  struct myst {\n"
+                      "    T* x;\n"
+                      "    myst(T* y) : x(y){};\n"  // <- myst constructor
+                      "  };\n"
+                      "};");
+        ASSERT(db);
+
+        const Token* myst1 = Token::findsimplematch(tokenizer.tokens(), "myst ( T * y )");
+        const Token* myst2 = Token::findsimplematch(myst1->next(), "myst ( T * y )");
+        ASSERT(myst1);
+        ASSERT(myst2);
+        ASSERT(myst1->scope() != myst2->scope());
+    }
+
+    void createSymbolDatabaseFindAllScopes9() // #12943
+    {
+        GET_SYMBOL_DB("void f(int n) {\n"
+                      "    if ([](int i) { return i == 2; }(n)) {}\n"
+                      "}\n");
+        ASSERT(db && db->scopeList.size() == 4);
+        ASSERT_EQUALS_ENUM(db->scopeList.back().type, ScopeType::eLambda);
+    }
+
+    void createSymbolDatabaseFindAllScopes10() {
+        {
+            GET_SYMBOL_DB("void g() {\n"
+                          "    for (int i = 0, r = 1; i < r; ++i) {}\n"
+                          "}\n");
+            ASSERT(db);
+            ASSERT_EQUALS(3, db->scopeList.size());
+            ASSERT_EQUALS(2, db->scopeList.back().varlist.size());
+            const Token* const iTok = Token::findsimplematch(tokenizer.tokens(), "i");
+            const Token* const rTok = Token::findsimplematch(iTok, "r");
+            const Variable* i = iTok->variable(), * r = rTok->variable();
+            ASSERT(i != nullptr && r != nullptr);
+            ASSERT_EQUALS(i->typeStartToken(), r->typeStartToken());
+            ASSERT(i->valueType()->isTypeEqual(r->valueType()));
+        }
+        {
+            GET_SYMBOL_DB("void f() {\n" // #13697
+                          "    typedef void (*func_t)();\n"
+                          "    func_t a[] = { nullptr };\n"
+                          "    for (func_t* fp = a; *fp; fp++) {}\n"
+                          "}\n");
+            ASSERT(db); // don't hang
+            ASSERT_EQUALS(3, db->scopeList.size());
+            ASSERT_EQUALS(1, db->scopeList.back().varlist.size());
+            const Token* const fp = Token::findsimplematch(tokenizer.tokens(), "fp");
+            ASSERT(fp && fp->variable());
+        }
+    }
+
+    void createSymbolDatabaseFindAllScopes11() // #13685
+    {
+        GET_SYMBOL_DB("int f() {\n"
+                      "    int x;\n"
+                      "    if (!({ int *p = &x; *p = 1; 1; }))\n"
+                      "        return 0;\n"
+                      "    return x;\n"
+                      "}\n");
+        ASSERT(db && db->scopeList.size() == 4);
+
+        auto it = db->scopeList.begin();
+        std::advance(it, 3);
+        const Scope& compoundScope = *it;
+        ASSERT_EQUALS_ENUM(ScopeType::eUnconditional, compoundScope.type);
+        ASSERT_EQUALS_ENUM(ScopeType::eFunction, compoundScope.nestedIn->type);
+        ASSERT_EQUALS("f", compoundScope.nestedIn->className);
+    }
+
+    void createSymbolDatabaseIncompleteVars()
+    {
+        {
+            GET_SYMBOL_DB("void f() {\n"
+                          "    auto s1 = std::string{ \"abc\" };\n"
+                          "    auto s2 = std::string(\"def\");\n"
+                          "}\n");
+            ASSERT(db && errout_str().empty());
+            const Token* s1 = Token::findsimplematch(tokenizer.tokens(), "string {");
+            ASSERT(s1 && !s1->isIncompleteVar());
+            const Token* s2 = Token::findsimplematch(s1, "string (");
+            ASSERT(s2 && !s2->isIncompleteVar());
+        }
+        {
+            GET_SYMBOL_DB("std::string f(int n, std::type_info t) {\n"
+                          "    std::vector<std::string*> v(n);\n"
+                          "    g<const std::string &>();\n"
+                          "    if (static_cast<int>(x)) {}\n"
+                          "    if (t == typeid(std::string)) {}\n"
+                          "    return (std::string) \"abc\";\n"
+                          "}\n");
+            ASSERT(db && errout_str().empty());
+            const Token* s1 = Token::findsimplematch(tokenizer.tokens(), "string *");
+            ASSERT(s1 && !s1->isIncompleteVar());
+            const Token* s2 = Token::findsimplematch(s1, "string &");
+            ASSERT(s2 && !s2->isIncompleteVar());
+            const Token* x = Token::findsimplematch(s2, "x");
+            ASSERT(x && x->isIncompleteVar());
+            const Token* s3 = Token::findsimplematch(x, "string )");
+            ASSERT(s3 && !s3->isIncompleteVar());
+            const Token* s4 = Token::findsimplematch(s3->next(), "string )");
+            ASSERT(s4 && !s4->isIncompleteVar());
+        }
+        {
+            GET_SYMBOL_DB("void destroy(int*, void (*cb_dealloc)(void *));\n"
+                          "void f(int* p, int* q, int* r) {\n"
+                          "    destroy(p, free);\n"
+                          "    destroy(q, std::free);\n"
+                          "    destroy(r, N::free);\n"
+                          "}\n");
+            ASSERT(db && errout_str().empty());
+            const Token* free1 = Token::findsimplematch(tokenizer.tokens(), "free");
+            ASSERT(free1 && !free1->isIncompleteVar());
+            const Token* free2 = Token::findsimplematch(free1->next(), "free");
+            ASSERT(free2 && !free2->isIncompleteVar());
+            const Token* free3 = Token::findsimplematch(free2->next(), "free");
+            ASSERT(free3 && free3->isIncompleteVar());
+        }
+        {
+            GET_SYMBOL_DB("void f(QObject* p, const char* s) {\n"
+                          "    QWidget* w = dynamic_cast<QWidget*>(p);\n"
+                          "    g(static_cast<const std::string>(s));\n"
+                          "    const std::uint64_t* const data = nullptr;\n"
+                          "}\n");
+            ASSERT(db && errout_str().empty());
+            const Token* qw = Token::findsimplematch(tokenizer.tokens(), "QWidget * >");
+            ASSERT(qw && !qw->isIncompleteVar());
+            const Token* s = Token::findsimplematch(qw, "string >");
+            ASSERT(s && !s->isIncompleteVar());
+            const Token* u = Token::findsimplematch(s, "uint64_t");
+            ASSERT(u && !u->isIncompleteVar());
+        }
+        {
+            GET_SYMBOL_DB("void f() {\n"
+                          "    std::string* p = new std::string;\n"
+                          "    std::string* q = new std::string(\"abc\");\n"
+                          "    std::string* r = new std::string{ \"def\" };\n"
+                          "    std::string* s = new std::string[3]{ \"ghi\" };\n"
+                          "}\n");
+            ASSERT(db && errout_str().empty());
+            const Token* s1 = Token::findsimplematch(tokenizer.tokens(), "string ;");
+            ASSERT(s1 && !s1->isIncompleteVar());
+            const Token* s2 = Token::findsimplematch(s1->next(), "string (");
+            ASSERT(s2 && !s2->isIncompleteVar());
+            const Token* s3 = Token::findsimplematch(s2->next(), "string {");
+            ASSERT(s3 && !s3->isIncompleteVar());
+            const Token* s4 = Token::findsimplematch(s3->next(), "string [");
+            ASSERT(s4 && !s4->isIncompleteVar());
+        }
+        {
+            GET_SYMBOL_DB("void f() {\n"
+                          "    T** p;\n"
+                          "    T*** q;\n"
+                          "    T** const * r;\n"
+                          "}\n");
+            ASSERT(db && errout_str().empty());
+            const Token* p = Token::findsimplematch(tokenizer.tokens(), "p");
+            ASSERT(p && !p->isIncompleteVar());
+            const Token* q = Token::findsimplematch(p, "q");
+            ASSERT(q && !q->isIncompleteVar());
+            const Token* r = Token::findsimplematch(q, "r");
+            ASSERT(r && !r->isIncompleteVar());
+        }
+        {
+            GET_SYMBOL_DB("void f() {\n" // #12571
+                          "    auto g = []() -> std::string* {\n"
+                          "        return nullptr;\n"
+                          "    };\n"
+                          "}\n");
+            ASSERT(db && errout_str().empty());
+            const Token* s = Token::findsimplematch(tokenizer.tokens(), "string");
+            ASSERT(s && !s->isIncompleteVar());
+        }
+        {
+            GET_SYMBOL_DB("void f() {\n" // #12583
+                          "    using namespace N;\n"
+                          "}\n");
+            ASSERT(db && errout_str().empty());
+            const Token* N = Token::findsimplematch(tokenizer.tokens(), "N");
+            ASSERT(N && !N->isIncompleteVar());
+        }
+    }
+
+    void enum1() {
+        GET_SYMBOL_DB("enum BOOL { FALSE, TRUE }; enum BOOL b;");
+
+        /* there is a enum scope with the name BOOL */
+        ASSERT(db && db->scopeList.back().type == ScopeType::eEnum && db->scopeList.back().className == "BOOL");
+
+        /* b is a enum variable, type is BOOL */
+        ASSERT(db && db->getVariableFromVarId(1)->isEnumType());
+    }
+
+    void enum2() {
+        GET_SYMBOL_DB("enum BOOL { FALSE, TRUE } b;");
+
+        /* there is a enum scope with the name BOOL */
+        ASSERT(db && db->scopeList.back().type == ScopeType::eEnum && db->scopeList.back().className == "BOOL");
+
+        /* b is a enum variable, type is BOOL */
+        ASSERT(db && db->getVariableFromVarId(1)->isEnumType());
+    }
+
+    void enum3() {
+        GET_SYMBOL_DB("enum ABC { A=11,B,C=A+B };");
+        ASSERT(db && db->scopeList.back().type == ScopeType::eEnum);
+
+        /* There is an enum A with value 11 */
+        const Enumerator *A = db->scopeList.back().findEnumerator("A");
+        ASSERT(A && A->value==11 && A->value_known);
+
+        /* There is an enum B with value 12 */
+        const Enumerator *B = db->scopeList.back().findEnumerator("B");
+        ASSERT(B && B->value==12 && B->value_known);
+
+        /* There is an enum C with value 23 */
+        const Enumerator *C = db->scopeList.back().findEnumerator("C");
+        ASSERT(C && C->value==23 && C->value_known);
+    }
+
+    void enum4() { // #7493
+        GET_SYMBOL_DB("enum Offsets { O1, O2, O3=5, O4 };\n"
+                      "enum MyEnums { E1=O1+1, E2, E3=O3+1 };");
+        ASSERT(db != nullptr);
+
+        ASSERT_EQUALS(3U, db->scopeList.size());
+
+        // Assert that all enum values are known
+        auto scope = db->scopeList.cbegin();
+
+        // Offsets
+        ++scope;
+        ASSERT_EQUALS_ENUM(ScopeType::eEnum, scope->type);
+        ASSERT_EQUALS(4U, scope->enumeratorList.size());
+
+        ASSERT(scope->enumeratorList[0].name->enumerator() == &scope->enumeratorList[0]);
+        ASSERT_EQUALS_ENUM(Token::eEnumerator, scope->enumeratorList[0].name->tokType());
+        ASSERT(scope->enumeratorList[0].scope == &*scope);
+        ASSERT_EQUALS("O1", scope->enumeratorList[0].name->str());
+        ASSERT(scope->enumeratorList[0].start == nullptr);
+        ASSERT(scope->enumeratorList[0].end == nullptr);
+        ASSERT_EQUALS(true, scope->enumeratorList[0].value_known);
+        ASSERT_EQUALS(0, scope->enumeratorList[0].value);
+
+        ASSERT(scope->enumeratorList[1].name->enumerator() == &scope->enumeratorList[1]);
+        ASSERT_EQUALS_ENUM(Token::eEnumerator, scope->enumeratorList[1].name->tokType());
+        ASSERT(scope->enumeratorList[1].scope == &*scope);
+        ASSERT_EQUALS("O2", scope->enumeratorList[1].name->str());
+        ASSERT(scope->enumeratorList[1].start == nullptr);
+        ASSERT(scope->enumeratorList[1].end == nullptr);
+        ASSERT_EQUALS(true, scope->enumeratorList[1].value_known);
+        ASSERT_EQUALS(1, scope->enumeratorList[1].value);
+
+        ASSERT(scope->enumeratorList[2].name->enumerator() == &scope->enumeratorList[2]);
+        ASSERT_EQUALS_ENUM(Token::eEnumerator, scope->enumeratorList[2].name->tokType());
+        ASSERT(scope->enumeratorList[2].scope == &*scope);
+        ASSERT_EQUALS("O3", scope->enumeratorList[2].name->str());
+        ASSERT(scope->enumeratorList[2].start != nullptr);
+        ASSERT(scope->enumeratorList[2].end != nullptr);
+        ASSERT_EQUALS(true, scope->enumeratorList[2].value_known);
+        ASSERT_EQUALS(5, scope->enumeratorList[2].value);
+
+        ASSERT(scope->enumeratorList[3].name->enumerator() == &scope->enumeratorList[3]);
+        ASSERT_EQUALS_ENUM(Token::eEnumerator, scope->enumeratorList[3].name->tokType());
+        ASSERT(scope->enumeratorList[3].scope == &*scope);
+        ASSERT_EQUALS("O4", scope->enumeratorList[3].name->str());
+        ASSERT(scope->enumeratorList[3].start == nullptr);
+        ASSERT(scope->enumeratorList[3].end == nullptr);
+        ASSERT_EQUALS(true, scope->enumeratorList[3].value_known);
+        ASSERT_EQUALS(6, scope->enumeratorList[3].value);
+
+        // MyEnums
+        ++scope;
+        ASSERT_EQUALS_ENUM(ScopeType::eEnum, scope->type);
+        ASSERT_EQUALS(3U, scope->enumeratorList.size());
+
+        ASSERT(scope->enumeratorList[0].name->enumerator() == &scope->enumeratorList[0]);
+        ASSERT_EQUALS_ENUM(Token::eEnumerator, scope->enumeratorList[0].name->tokType());
+        ASSERT(scope->enumeratorList[0].scope == &*scope);
+        ASSERT_EQUALS("E1", scope->enumeratorList[0].name->str());
+        ASSERT(scope->enumeratorList[0].start != nullptr);
+        ASSERT(scope->enumeratorList[0].end != nullptr);
+        ASSERT_EQUALS(true, scope->enumeratorList[0].value_known);
+        ASSERT_EQUALS(1, scope->enumeratorList[0].value);
+
+        ASSERT(scope->enumeratorList[1].name->enumerator() == &scope->enumeratorList[1]);
+        ASSERT_EQUALS_ENUM(Token::eEnumerator, scope->enumeratorList[1].name->tokType());
+        ASSERT(scope->enumeratorList[1].scope == &*scope);
+        ASSERT_EQUALS("E2", scope->enumeratorList[1].name->str());
+        ASSERT(scope->enumeratorList[1].start == nullptr);
+        ASSERT(scope->enumeratorList[1].end == nullptr);
+        ASSERT_EQUALS(true, scope->enumeratorList[1].value_known);
+        ASSERT_EQUALS(2, scope->enumeratorList[1].value);
+
+        ASSERT(scope->enumeratorList[2].name->enumerator() == &scope->enumeratorList[2]);
+        ASSERT_EQUALS_ENUM(Token::eEnumerator, scope->enumeratorList[2].name->tokType());
+        ASSERT(scope->enumeratorList[2].scope == &*scope);
+        ASSERT_EQUALS("E3", scope->enumeratorList[2].name->str());
+        ASSERT(scope->enumeratorList[2].start != nullptr);
+        ASSERT(scope->enumeratorList[2].end != nullptr);
+        ASSERT_EQUALS(true, scope->enumeratorList[2].value_known);
+        ASSERT_EQUALS(6, scope->enumeratorList[2].value);
+    }
+
+    void enum5() {
+        GET_SYMBOL_DB("enum { A = 10, B = 2 };\n"
+                      "int a[10 + 2];\n"
+                      "int b[A];\n"
+                      "int c[A + 2];\n"
+                      "int d[10 + B];\n"
+                      "int e[A + B];");
+        ASSERT(db != nullptr);
+
+        ASSERT_EQUALS(2U, db->scopeList.size());
+
+        // Assert that all enum values are known
+        auto scope = db->scopeList.cbegin();
+
+        ++scope;
+        ASSERT_EQUALS_ENUM(ScopeType::eEnum, scope->type);
+        ASSERT_EQUALS(2U, scope->enumeratorList.size());
+        ASSERT_EQUALS(true, scope->enumeratorList[0].value_known);
+        ASSERT_EQUALS(10, scope->enumeratorList[0].value);
+        ASSERT_EQUALS(true, scope->enumeratorList[1].value_known);
+        ASSERT_EQUALS(2, scope->enumeratorList[1].value);
+
+        ASSERT(db->variableList().size() == 6); // the first one is not used
+        const Variable * v = db->getVariableFromVarId(1);
+        ASSERT(v != nullptr);
+
+        ASSERT(v->isArray());
+        ASSERT_EQUALS(1U, v->dimensions().size());
         ASSERT_EQUALS(12U, v->dimension(0));
         v = db->getVariableFromVarId(2);
         ASSERT(v != nullptr);
-        if (!v)
-            return;
+
         ASSERT(v->isArray());
         ASSERT_EQUALS(1U, v->dimensions().size());
         ASSERT_EQUALS(10U, v->dimension(0));
         v = db->getVariableFromVarId(3);
         ASSERT(v != nullptr);
-        if (!v)
-            return;
+
         ASSERT(v->isArray());
         ASSERT_EQUALS(1U, v->dimensions().size());
         ASSERT_EQUALS(12U, v->dimension(0));
         v = db->getVariableFromVarId(4);
         ASSERT(v != nullptr);
-        if (!v)
-            return;
+
         ASSERT(v->isArray());
         ASSERT_EQUALS(1U, v->dimensions().size());
         ASSERT_EQUALS(12U, v->dimension(0));
         v = db->getVariableFromVarId(5);
         ASSERT(v != nullptr);
-        if (!v)
-            return;
+
         ASSERT(v->isArray());
         ASSERT_EQUALS(1U, v->dimensions().size());
         ASSERT_EQUALS(12U, v->dimension(0));
@@ -4443,29 +6426,24 @@ class TestSymbolDatabase: public TestFixture {
                       "    Enum func(Enum e) { return e; }\n"
                       "};");
         ASSERT(db != nullptr);
-        if (!db)
-            return;
+
         const Token * const functionToken = Token::findsimplematch(tokenizer.tokens(), "func");
         ASSERT(functionToken != nullptr);
-        if (!functionToken)
-            return;
+
         const Function *function = functionToken->function();
         ASSERT(function != nullptr);
-        if (!function)
-            return;
+
         ASSERT(function->token->str() == "func");
         ASSERT(function->retDef && function->retDef->str() == "Enum");
         ASSERT(function->retType && function->retType->name() == "Enum");
     }
 
 #define TEST(S) \
-        v = db->getVariableFromVarId(id++); \
-        ASSERT(v != nullptr); \
-        if (!v) \
-            return; \
-        ASSERT(v->isArray()); \
-        ASSERT_EQUALS(1U, v->dimensions().size()); \
-        ASSERT_EQUALS(S, v->dimension(0))
+    v = db->getVariableFromVarId(id++); \
+    ASSERT(v != nullptr); \
+    ASSERT(v->isArray()); \
+    ASSERT_EQUALS(1U, v->dimensions().size()); \
+    ASSERT_EQUALS(S, v->dimension(0))
 
     void enum7() {
         GET_SYMBOL_DB("enum E { X };\n"
@@ -4485,25 +6463,474 @@ class TestSymbolDatabase: public TestFixture {
                       "char array9[sizeof(EL)];\n"
                       "char array10[sizeof(L)];\n"
                       "char array11[sizeof(ELL)];\n"
-                      "char array12[sizeof(LL)];\n");
+                      "char array12[sizeof(LL)];");
         ASSERT(db != nullptr);
-        if (!db)
-            return;
+
         ASSERT(db->variableList().size() == 13); // the first one is not used
         const Variable * v;
         unsigned int id = 1;
-        TEST(settings1.sizeof_int);
-        TEST(settings1.sizeof_int);
+        TEST(settings1.platform.sizeof_int);
+        TEST(settings1.platform.sizeof_int);
         TEST(1);
         TEST(1);
-        TEST(settings1.sizeof_short);
-        TEST(settings1.sizeof_short);
-        TEST(settings1.sizeof_int);
-        TEST(settings1.sizeof_int);
-        TEST(settings1.sizeof_long);
-        TEST(settings1.sizeof_long);
-        TEST(settings1.sizeof_long_long);
-        TEST(settings1.sizeof_long_long);
+        TEST(settings1.platform.sizeof_short);
+        TEST(settings1.platform.sizeof_short);
+        TEST(settings1.platform.sizeof_int);
+        TEST(settings1.platform.sizeof_int);
+        TEST(settings1.platform.sizeof_long);
+        TEST(settings1.platform.sizeof_long);
+        TEST(settings1.platform.sizeof_long_long);
+        TEST(settings1.platform.sizeof_long_long);
+    }
+
+    void enum8() {
+        GET_SYMBOL_DB("enum E { X0 = x, X1, X2 = 2, X3, X4 = y, X5 };\n");
+        ASSERT(db != nullptr);
+        const Enumerator *X0 = db->scopeList.back().findEnumerator("X0");
+        ASSERT(X0);
+        ASSERT(!X0->value_known);
+        const Enumerator *X1 = db->scopeList.back().findEnumerator("X1");
+        ASSERT(X1);
+        ASSERT(!X1->value_known);
+        const Enumerator *X2 = db->scopeList.back().findEnumerator("X2");
+        ASSERT(X2);
+        ASSERT(X2->value_known);
+        ASSERT_EQUALS(X2->value, 2);
+        const Enumerator *X3 = db->scopeList.back().findEnumerator("X3");
+        ASSERT(X3);
+        ASSERT(X3->value_known);
+        ASSERT_EQUALS(X3->value, 3);
+        const Enumerator *X4 = db->scopeList.back().findEnumerator("X4");
+        ASSERT(X4);
+        ASSERT(!X4->value_known);
+        const Enumerator *X5 = db->scopeList.back().findEnumerator("X5");
+        ASSERT(X5);
+        ASSERT(!X5->value_known);
+    }
+
+    void enum9() {
+        GET_SYMBOL_DB("const int x = 7; enum E { X0 = x, X1 };\n");
+        ASSERT(db != nullptr);
+        const Enumerator *X0 = db->scopeList.back().findEnumerator("X0");
+        ASSERT(X0);
+        ASSERT(X0->value_known);
+        ASSERT_EQUALS(X0->value, 7);
+        const Enumerator *X1 = db->scopeList.back().findEnumerator("X1");
+        ASSERT(X1);
+        ASSERT(X1->value_known);
+        ASSERT_EQUALS(X1->value, 8);
+    }
+
+    void enum10() { // #11001
+        GET_SYMBOL_DB_C("int b = sizeof(enum etag {X, Y});\n");
+        ASSERT(db != nullptr);
+        const Enumerator *X = db->scopeList.back().findEnumerator("X");
+        ASSERT(X);
+        ASSERT(X->value_known);
+        ASSERT_EQUALS(X->value, 0);
+        const Enumerator *Y = db->scopeList.back().findEnumerator("Y");
+        ASSERT(Y);
+        ASSERT(Y->value_known);
+        ASSERT_EQUALS(Y->value, 1);
+    }
+
+    void enum11() {
+        check("enum class E;\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void enum12() {
+        GET_SYMBOL_DB_C("struct { enum E { E0 }; } t;\n"
+                        "void f() {\n"
+                        "    if (t.E0) {}\n"
+                        "}\n");
+        ASSERT(db != nullptr);
+        auto it = db->scopeList.begin();
+        std::advance(it, 2);
+        const Enumerator* E0 = it->findEnumerator("E0");
+        ASSERT(E0 && E0->value_known);
+        ASSERT_EQUALS(E0->value, 0);
+        const Token* const e = Token::findsimplematch(tokenizer.tokens(), "E0 )");
+        ASSERT(e && e->enumerator());
+        ASSERT_EQUALS(e->enumerator(), E0);
+    }
+
+    void enum13() {
+        GET_SYMBOL_DB("struct S { enum E { E0, E1 }; };\n"
+                      "void f(bool b) {\n"
+                      "    auto e = b ? S::E0 : S::E1;\n"
+                      "}\n");
+        ASSERT(db != nullptr);
+        auto it = db->scopeList.begin();
+        std::advance(it, 2);
+        const Enumerator* E1 = it->findEnumerator("E1");
+        ASSERT(E1 && E1->value_known);
+        ASSERT_EQUALS(E1->value, 1);
+        const Token* const a = Token::findsimplematch(tokenizer.tokens(), "auto");
+        ASSERT(a && a->valueType());
+        ASSERT(E1->scope == a->valueType()->typeScope);
+    }
+
+    void enum14() {
+        GET_SYMBOL_DB("void f() {\n" // #11421
+                      "    enum E { A = 0, B = 0xFFFFFFFFFFFFFFFFull, C = 0x7FFFFFFFFFFFFFFF };\n"
+                      "    E e = B;\n"
+                      "    auto s1 = e >> 32;\n"
+                      "    auto s2 = B >> 32;\n"
+                      "    enum F { F0 = sizeof(int) };\n"
+                      "    F f = F0;\n"
+                      "}\n");
+        ASSERT(db != nullptr);
+        auto it = db->scopeList.begin();
+        std::advance(it, 2);
+        const Enumerator* B = it->findEnumerator("B");
+        ASSERT(B);
+        TODO_ASSERT(B->value_known);
+        const Enumerator* C = it->findEnumerator("C");
+        ASSERT(C && C->value_known);
+        const Token* const s1 = Token::findsimplematch(tokenizer.tokens(), "s1 =");
+        ASSERT(s1 && s1->valueType());
+        ASSERT_EQUALS(s1->valueType()->type, ValueType::Type::LONGLONG);
+        const Token* const s2 = Token::findsimplematch(s1, "s2 =");
+        ASSERT(s2 && s2->valueType());
+        ASSERT_EQUALS(s2->valueType()->type, ValueType::Type::LONGLONG);
+        ++it;
+        const Enumerator* F0 = it->findEnumerator("F0");
+        ASSERT(F0 && F0->value_known);
+        const Token* const f = Token::findsimplematch(s2, "f =");
+        ASSERT(f && f->valueType());
+        ASSERT_EQUALS(f->valueType()->type, ValueType::Type::INT);
+    }
+
+    void enum15() {
+        {
+            GET_SYMBOL_DB("struct S {\n"
+                          "    S();\n"
+                          "    enum E { E0 };\n"
+                          "};\n"
+                          "S::S() {\n"
+                          "    E e = E::E0;\n"
+                          "}\n");
+            ASSERT(db != nullptr);
+            auto it = db->scopeList.begin();
+            std::advance(it, 2);
+            const Enumerator* E0 = it->findEnumerator("E0");
+            ASSERT(E0 && E0->value_known && E0->value == 0);
+            const Token* const e = Token::findsimplematch(tokenizer.tokens(), "E0 ;");
+            ASSERT(e && e->enumerator());
+            ASSERT_EQUALS(E0, e->enumerator());
+        }
+        {
+            GET_SYMBOL_DB("struct S {\n"
+                          "    S(bool x);\n"
+                          "    enum E { E0 };\n"
+                          "};\n"
+                          "S::S(bool x) {\n"
+                          "    if (x)\n"
+                          "        E e = E::E0;\n"
+                          "}\n");
+            ASSERT(db != nullptr);
+            auto it = db->scopeList.begin();
+            std::advance(it, 2);
+            const Enumerator* E0 = it->findEnumerator("E0");
+            ASSERT(E0 && E0->value_known && E0->value == 0);
+            const Token* const e = Token::findsimplematch(tokenizer.tokens(), "E0 ;");
+            ASSERT(e && e->enumerator());
+            ASSERT_EQUALS(E0, e->enumerator());
+        }
+        {
+            GET_SYMBOL_DB("struct S {\n"
+                          "    enum E { E0 };\n"
+                          "    void f(int i);\n"
+                          "    S();\n"
+                          "    int m;\n"
+                          "};\n"
+                          "S::S() : m(E0) {}\n"
+                          "void S::f(int i) {\n"
+                          "    if (i != E0) {}\n"
+                          "}\n");
+            ASSERT(db != nullptr);
+            auto it = db->scopeList.begin();
+            std::advance(it, 2);
+            const Enumerator* E0 = it->findEnumerator("E0");
+            ASSERT(E0 && E0->value_known && E0->value == 0);
+            const Token* e = Token::findsimplematch(tokenizer.tokens(), "E0 )");
+            ASSERT(e && e->enumerator());
+            ASSERT_EQUALS(E0, e->enumerator());
+            e = Token::findsimplematch(e->next(), "E0 )");
+            ASSERT(e && e->enumerator());
+            ASSERT_EQUALS(E0, e->enumerator());
+        }
+        {
+            GET_SYMBOL_DB("struct S {\n"
+                          "    enum class E {\n"
+                          "        A, D\n"
+                          "    } e = E::D;\n"
+                          "};\n"
+                          "struct E {\n"
+                          "    enum { A, B, C, D };\n"
+                          "};\n");
+            ASSERT(db != nullptr);
+            auto it = db->scopeList.begin();
+            std::advance(it, 2);
+            ASSERT_EQUALS(it->className, "E");
+            ASSERT(it->nestedIn);
+            ASSERT_EQUALS(it->nestedIn->className, "S");
+            const Enumerator* D = it->findEnumerator("D");
+            ASSERT(D && D->value_known && D->value == 1);
+            const Token* tok = Token::findsimplematch(tokenizer.tokens(), "D ;");
+            ASSERT(tok && tok->enumerator());
+            ASSERT_EQUALS(D, tok->enumerator());
+        }
+    }
+
+    void enum16() {
+        {
+            GET_SYMBOL_DB("struct B {\n" // #12538
+                          "    struct S {\n"
+                          "        enum E { E0 = 0 };\n"
+                          "    };\n"
+                          "};\n"
+                          "struct D : B {\n"
+                          "    S::E f() const {\n"
+                          "        return S::E0;\n"
+                          "    }\n"
+                          "};\n");
+            ASSERT(db != nullptr);
+            auto it = db->scopeList.begin();
+            std::advance(it, 3);
+            const Enumerator* E0 = it->findEnumerator("E0");
+            ASSERT(E0 && E0->value_known && E0->value == 0);
+            const Token* const e = Token::findsimplematch(tokenizer.tokens(), "E0 ;");
+            ASSERT(e && e->enumerator());
+            ASSERT_EQUALS(E0, e->enumerator());
+        }
+        {
+            GET_SYMBOL_DB("namespace ns {\n" // #12567
+                          "    struct S1 {\n"
+                          "        enum E { E1 } e;\n"
+                          "    };\n"
+                          "    struct S2 {\n"
+                          "        static void f();\n"
+                          "    };\n"
+                          "}\n"
+                          "void ns::S2::f() {\n"
+                          "    S1 s;\n"
+                          "    s.e = S1::E1;\n"
+                          "}\n");
+            ASSERT(db != nullptr);
+            auto it = db->scopeList.begin();
+            std::advance(it, 3);
+            const Enumerator* E1 = it->findEnumerator("E1");
+            ASSERT(E1 && E1->value_known && E1->value == 0);
+            const Token* const e = Token::findsimplematch(tokenizer.tokens(), "E1 ;");
+            ASSERT(e && e->enumerator());
+            ASSERT_EQUALS(E1, e->enumerator());
+        }
+        {
+            GET_SYMBOL_DB("namespace N {\n"
+                          "    struct S1 {\n"
+                          "        enum E { E1 } e;\n"
+                          "    };\n"
+                          "    namespace O {\n"
+                          "        struct S2 {\n"
+                          "            static void f();\n"
+                          "        };\n"
+                          "    }\n"
+                          "}\n"
+                          "void N::O::S2::f() {\n"
+                          "    S1 s;\n"
+                          "    s.e = S1::E1;\n"
+                          "}\n");
+            ASSERT(db != nullptr);
+            auto it = db->scopeList.begin();
+            std::advance(it, 3);
+            const Enumerator* E1 = it->findEnumerator("E1");
+            ASSERT(E1 && E1->value_known && E1->value == 0);
+            const Token* const e = Token::findsimplematch(tokenizer.tokens(), "E1 ;");
+            ASSERT(e && e->enumerator());
+            ASSERT_EQUALS(E1, e->enumerator());
+        }
+        {
+            GET_SYMBOL_DB("enum class E { inc };\n" // #12585
+                          "struct C {\n"
+                          "    void f1();\n"
+                          "    bool f2(bool inc);\n"
+                          "};\n"
+                          "void C::f1() { const E e = E::inc; }\n"
+                          "void C::f2(bool inc) { return false; }\n");
+            ASSERT(db != nullptr);
+            auto it = db->scopeList.begin();
+            std::advance(it, 1);
+            const Enumerator* inc = it->findEnumerator("inc");
+            ASSERT(inc && inc->value_known && inc->value == 0);
+            const Token* const i = Token::findsimplematch(tokenizer.tokens(), "inc ;");
+            ASSERT(i && i->enumerator());
+            ASSERT_EQUALS(inc, i->enumerator());
+        }
+    }
+
+    void enum17() {
+        {
+            GET_SYMBOL_DB("struct S {\n" // #12564
+                          "    enum class E : std::uint8_t;\n"
+                          "    enum class E : std::uint8_t { E0 };\n"
+                          "    static void f(S::E e) {\n"
+                          "        if (e == S::E::E0) {}\n"
+                          "    }\n"
+                          "};\n");
+            ASSERT(db != nullptr);
+            auto it = db->scopeList.begin();
+            std::advance(it, 2);
+            const Enumerator* E0 = it->findEnumerator("E0");
+            ASSERT(E0 && E0->value_known && E0->value == 0);
+            const Token* const e = Token::findsimplematch(tokenizer.tokens(), "E0 )");
+            ASSERT(e && e->enumerator());
+            ASSERT_EQUALS(E0, e->enumerator());
+        }
+    }
+
+    void enum18() {
+        {
+            GET_SYMBOL_DB("namespace {\n"
+                          "    enum { E0 };\n"
+                          "}\n"
+                          "void f() {\n"
+                          "    if (0 > E0) {}\n"
+                          "}\n");
+            ASSERT(db != nullptr);
+            auto it = db->scopeList.begin();
+            std::advance(it, 2);
+            const Enumerator* E0 = it->findEnumerator("E0");
+            ASSERT(E0 && E0->value_known && E0->value == 0);
+            const Token* const e = Token::findsimplematch(tokenizer.tokens(), "E0 )");
+            ASSERT(e && e->enumerator());
+            ASSERT_EQUALS(E0, e->enumerator());
+        }
+        {
+            GET_SYMBOL_DB("namespace ns {\n" // #12114
+                          "    enum { V1 };\n"
+                          "    struct C1 {\n"
+                          "        enum { V2 };\n"
+                          "    };\n"
+                          "}\n"
+                          "using namespace ns;\n"
+                          "void f() {\n"
+                          "    if (0 > V1) {}\n"
+                          "    if (0 > C1::V2) {}\n"
+                          "}\n");
+            ASSERT(db != nullptr);
+            auto it = db->scopeList.begin();
+            std::advance(it, 2);
+            const Enumerator* V1 = it->findEnumerator("V1");
+            ASSERT(V1 && V1->value_known && V1->value == 0);
+            const Token* const e1 = Token::findsimplematch(tokenizer.tokens(), "V1 )");
+            ASSERT(e1 && e1->enumerator());
+            ASSERT_EQUALS(V1, e1->enumerator());
+            std::advance(it, 2);
+            const Enumerator* V2 = it->findEnumerator("V2");
+            ASSERT(V2 && V2->value_known && V2->value == 0);
+            const Token* const e2 = Token::findsimplematch(tokenizer.tokens(), "V2 )");
+            ASSERT(e2 && e2->enumerator());
+            ASSERT_EQUALS(V2, e2->enumerator());
+        }
+        {
+            GET_SYMBOL_DB("namespace ns {\n"
+                          "    enum { V1 };\n"
+                          "    struct C1 {\n"
+                          "        enum { V2 };\n"
+                          "    };\n"
+                          "}\n"
+                          "void f() {\n"
+                          "    using namespace ns;\n"
+                          "    if (0 > V1) {}\n"
+                          "    if (0 > C1::V2) {}\n"
+                          "}\n");
+            ASSERT(db != nullptr);
+            auto it = db->scopeList.begin();
+            std::advance(it, 2);
+            const Enumerator* V1 = it->findEnumerator("V1");
+            ASSERT(V1 && V1->value_known && V1->value == 0);
+            const Token* const e1 = Token::findsimplematch(tokenizer.tokens(), "V1 )");
+            ASSERT(e1 && e1->enumerator());
+            ASSERT_EQUALS(V1, e1->enumerator());
+            std::advance(it, 2);
+            const Enumerator* V2 = it->findEnumerator("V2");
+            ASSERT(V2 && V2->value_known && V2->value == 0);
+            const Token* const e2 = Token::findsimplematch(tokenizer.tokens(), "V2 )");
+            ASSERT(e2 && e2->enumerator());
+            ASSERT_EQUALS(V2, e2->enumerator());
+        }
+    }
+
+    void enum19() {
+        {
+            GET_SYMBOL_DB("enum : std::int8_t { I = -1 };\n" // #13528
+                          "enum : int8_t { J = -1 };\n"
+                          "enum : char { K = -1 };\n");
+            const Token* I = Token::findsimplematch(tokenizer.tokens(), "I");
+            ASSERT(I && I->valueType() && I->valueType()->isEnum());
+            ASSERT_EQUALS(I->valueType()->type, ValueType::CHAR);
+            const Token* J = Token::findsimplematch(I, "J");
+            ASSERT(J && J->valueType() && J->valueType()->isEnum());
+            ASSERT_EQUALS(J->valueType()->type, ValueType::CHAR);
+            const Token* K = Token::findsimplematch(J, "K");
+            ASSERT(K && K->valueType() && K->valueType()->isEnum());
+            ASSERT_EQUALS(K->valueType()->type, ValueType::CHAR);
+        }
+    }
+
+    void enum20() { // #14419
+        {
+            GET_SYMBOL_DB("enum class myclass : uint8_t { A = 0U };\n");
+            const Token *A = Token::findsimplematch(tokenizer.tokens(), "A");
+            ASSERT(A && A->valueType() && A->valueType()->isEnum());
+            ASSERT_EQUALS_ENUM(ValueType::CHAR, A->valueType()->type);
+            ASSERT_EQUALS_ENUM(ValueType::UNSIGNED, A->valueType()->sign);
+        }
+        {
+            GET_SYMBOL_DB("enum myclass : uint8_t { A = 0U };\n");
+            const Token *A = Token::findsimplematch(tokenizer.tokens(), "A");
+            ASSERT(A && A->valueType() && A->valueType()->isEnum());
+            ASSERT_EQUALS_ENUM(ValueType::CHAR, A->valueType()->type);
+            ASSERT_EQUALS_ENUM(ValueType::UNSIGNED, A->valueType()->sign);
+        }
+    }
+
+    void struct1() {
+        GET_SYMBOL_DB_C("struct deer {\n"
+                        "   uint16_t a;\n"
+                        "   uint16_t b;\n"
+                        "};\n"
+                        "void herd ( void ) {\n"
+                        "   struct deer {\n"
+                        "     uint16_t a;\n"
+                        "   };\n"
+                        "}");
+
+        ASSERT_EQUALS("", errout_str());
+        ASSERT(db);
+
+        const Token* deer = Token::findsimplematch(tokenizer.tokens(), "deer {");
+        ASSERT(deer);
+        ASSERT(deer->type());
+        ASSERT(deer->type()->classScope);
+        const Token* tok = deer->next();
+        ASSERT(tok->scope());
+        ASSERT_EQUALS_ENUM(ScopeType::eStruct, tok->scope()->type);
+        ASSERT_EQUALS(tok, tok->scope()->bodyStart);
+        ASSERT_EQUALS(tok->scope(), deer->type()->classScope);
+
+        const Token* secondDeer = Token::findsimplematch(tok, "deer {");
+        ASSERT(secondDeer);
+        ASSERT(secondDeer != deer);
+        ASSERT(secondDeer->type());
+        ASSERT(secondDeer->type()->classScope);
+        tok = secondDeer->next();
+        ASSERT(tok->scope());
+        ASSERT_EQUALS_ENUM(ScopeType::eStruct, tok->scope()->type);
+        ASSERT_EQUALS(tok, tok->scope()->bodyStart);
+        ASSERT_EQUALS(tok->scope(), secondDeer->type()->classScope);
     }
 
     void sizeOfType() {
@@ -4514,7 +6941,7 @@ class TestSymbolDatabase: public TestFixture {
                       "    int i = abc[ARRAY_SIZE(cats)];\n"
                       "}");
         const Token *e = Token::findsimplematch(tokenizer.tokens(), "e abc");
-        db->sizeOfType(e);  // <- don't crash
+        (void)db->sizeOfType(e);  // <- don't crash
     }
 
     void isImplicitlyVirtual() {
@@ -4607,8 +7034,7 @@ class TestSymbolDatabase: public TestFixture {
                           "   }\n"
                           "};");
             ASSERT(db && db->findScopeByName("Bar") && !db->findScopeByName("Bar")->functionList.empty() && !db->findScopeByName("Bar")->functionList.front().isImplicitlyVirtual(false));
-            if (db && db->findScopeByName("Bar"))
-                ASSERT_EQUALS(1, db->findScopeByName("Bar")->functionList.size());
+            ASSERT_EQUALS(1, db->findScopeByName("Bar")->functionList.size());
         }
 
         // #5590
@@ -4640,13 +7066,11 @@ class TestSymbolDatabase: public TestFixture {
                       "    void g();\n"
                       "};");
         ASSERT(db && db->scopeList.back().functionList.size() == 4);
-        if (db && db->scopeList.back().functionList.size() == 4) {
-            std::list<Function>::const_iterator it = db->scopeList.back().functionList.begin();
-            ASSERT((it++)->isPure());
-            ASSERT((it++)->isPure());
-            ASSERT(!(it++)->isPure());
-            ASSERT(!(it++)->isPure());
-        }
+        auto it = db->scopeList.back().functionList.cbegin();
+        ASSERT((it++)->isPure());
+        ASSERT((it++)->isPure());
+        ASSERT(!(it++)->isPure());
+        ASSERT(!(it++)->isPure());
     }
 
     void isFunction1() { // #5602 - UNKNOWN_MACRO(a,b) { .. }
@@ -4674,12 +7098,38 @@ class TestSymbolDatabase: public TestFixture {
                       "    *PTRRELOC(&x) = &y;\n"
                       "}");
         ASSERT(db != nullptr);
-        ASSERT(db && !db->isFunction(Token::findsimplematch(tokenizer.tokens(), "PTRRELOC ( &"), &db->scopeList.back(), nullptr, nullptr, nullptr));
+        const Token *funcStart, *argStart, *declEnd;
+        ASSERT(db && !db->isFunction(Token::findsimplematch(tokenizer.tokens(), "PTRRELOC ( &"), &db->scopeList.back(), funcStart, argStart, declEnd));
         ASSERT(db->findScopeByName("set_cur_cpu_spec") != nullptr);
         ASSERT(db->findScopeByName("setup_cpu_spec") != nullptr);
         ASSERT(db->findScopeByName("PTRRELOC") == nullptr);
     }
 
+    void isFunction3() {
+        GET_SYMBOL_DB("std::vector<int>&& f(std::vector<int>& v) {\n"
+                      "    v.push_back(1);\n"
+                      "    return std::move(v);\n"
+                      "}");
+        ASSERT(db != nullptr);
+        ASSERT_EQUALS(2, db->scopeList.size());
+        const Token* ret = Token::findsimplematch(tokenizer.tokens(), "return");
+        ASSERT(ret != nullptr);
+        ASSERT(ret->scope() && ret->scope()->type == ScopeType::eFunction);
+    }
+
+    void isFunction4() {
+        GET_SYMBOL_DB("struct S (*a[10]);\n" // #13787
+                      "void f(int i, struct S* p) {\n"
+                      "    a[i] = &p[i];\n"
+                      "}\n");
+        ASSERT(db != nullptr);
+        ASSERT_EQUALS(2, db->scopeList.size());
+        ASSERT_EQUALS(1, db->scopeList.front().functionList.size());
+        const Token* a = Token::findsimplematch(tokenizer.tokens(), "a [ i");
+        ASSERT(a && a->variable());
+        ASSERT(a->variable()->scope() && a->variable()->scope()->type == ScopeType::eGlobal);
+    }
+
 
     void findFunction1() {
         GET_SYMBOL_DB("int foo(int x);\n" /* 1 */
@@ -4688,27 +7138,24 @@ class TestSymbolDatabase: public TestFixture {
                       "    foo();\n"      /* 4 */
                       "    foo(1);\n"     /* 5 */
                       "}");               /* 6 */
-        ASSERT_EQUALS("", errout.str());
-        if (db) {
-            const Scope * bar = db->findScopeByName("bar");
-            ASSERT(bar != nullptr);
-            if (bar) {
-                const unsigned int linenrs[2] = { 2, 1 };
-                unsigned int index = 0;
-                for (const Token * tok = bar->bodyStart->next(); tok != bar->bodyEnd; tok = tok->next()) {
-                    if (Token::Match(tok, "%name% (") && !tok->varId() && Token::simpleMatch(tok->linkAt(1), ") ;")) {
-                        const Function * function = db->findFunction(tok);
-                        ASSERT(function != nullptr);
-                        if (function) {
-                            std::stringstream expected;
-                            expected << "Function call on line " << tok->linenr() << " calls function on line " << linenrs[index] << std::endl;
-                            std::stringstream actual;
-                            actual << "Function call on line " << tok->linenr() << " calls function on line " << function->tokenDef->linenr() << std::endl;
-                            ASSERT_EQUALS(expected.str(), actual.str());
-                        }
-                        index++;
-                    }
+        ASSERT_EQUALS("", errout_str());
+        ASSERT(db);
+        const Scope * bar = db->findScopeByName("bar");
+        ASSERT(bar != nullptr);
+        constexpr unsigned int linenrs[2] = { 2, 1 };
+        unsigned int index = 0;
+        for (const Token * tok = bar->bodyStart->next(); tok != bar->bodyEnd; tok = tok->next()) {
+            if (Token::Match(tok, "%name% (") && !tok->varId() && Token::simpleMatch(tok->linkAt(1), ") ;")) {
+                const Function * function = db->findFunction(tok);
+                ASSERT(function != nullptr);
+                if (function) {
+                    std::stringstream expected;
+                    expected << "Function call on line " << tok->linenr() << " calls function on line " << linenrs[index] << std::endl;
+                    std::stringstream actual;
+                    actual << "Function call on line " << tok->linenr() << " calls function on line " << function->tokenDef->linenr() << std::endl;
+                    ASSERT_EQUALS(expected.str(), actual.str());
                 }
+                index++;
             }
         }
     }
@@ -4721,7 +7168,7 @@ class TestSymbolDatabase: public TestFixture {
                       "    func(x, &t);\n"
                       "}");
         const Token *callfunc = Token::findsimplematch(tokenizer.tokens(), "func ( x , & t ) ;");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS(true,  db != nullptr); // not null
         ASSERT_EQUALS(true,  callfunc != nullptr); // not null
         ASSERT_EQUALS(false, (callfunc && callfunc->function())); // callfunc->function() should be null
@@ -4736,7 +7183,7 @@ class TestSymbolDatabase: public TestFixture {
                       "}");
 
         const Token *callfunc = Token::findsimplematch(tokenizer.tokens(), "d . foo ( ) ;");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS(true, db != nullptr); // not null
         ASSERT_EQUALS(true, callfunc != nullptr); // not null
         ASSERT_EQUALS(true, callfunc && callfunc->tokAt(2)->function() && callfunc->tokAt(2)->function()->tokenDef->linenr() == 2); // should find function on line 2
@@ -4803,7 +7250,7 @@ class TestSymbolDatabase: public TestFixture {
                       "    foo(crld);\n"
                       "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( 1 ) ;");
         ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 2);
@@ -4929,9 +7376,9 @@ class TestSymbolDatabase: public TestFixture {
                       "        power.nodeResults().size();\n"
                       "        assert(power.nodeResults().size()==ground.nodeResults().size());\n"
                       "    }\n"
-                      "};")
+                      "};");
         const Token *callfunc = Token::findsimplematch(tokenizer.tokens(), "power . nodeResults ( ) . size ( ) ;");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS(true, db != nullptr); // not null
         ASSERT_EQUALS(true, callfunc != nullptr); // not null
         ASSERT_EQUALS(true, callfunc && callfunc->tokAt(2)->function() && callfunc->tokAt(2)->function()->tokenDef->linenr() == 3);
@@ -4957,8 +7404,8 @@ class TestSymbolDatabase: public TestFixture {
                       "void S::g() &&{ }\n"
                       "void S::g() const   { }\n"
                       "void S::g() const & { }\n"
-                      "void S::g() const &&{ }\n");
-        ASSERT_EQUALS("", errout.str());
+                      "void S::g() const &&{ }");
+        ASSERT_EQUALS("", errout_str());
 
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "f ( ) {");
         ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 2);
@@ -5020,7 +7467,7 @@ class TestSymbolDatabase: public TestFixture {
                       "    void foo(const int * p);\n"
                       "};\n"
                       "void Fred::foo(const int * const p) { }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( const int * const p ) {");
         ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 2);
@@ -5031,25 +7478,12 @@ class TestSymbolDatabase: public TestFixture {
                       "    void foo(const int * p);\n"
                       "};\n"
                       "void Fred::foo(const int p []) { }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( const int p [ ] ) {");
         ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 2);
     }
 
-    void findFunction11() {
-        GET_SYMBOL_DB("class Fred : public QObject {\n"
-                      "    Q_OBJECT\n"
-                      "private slots:\n"
-                      "    void foo();\n"
-                      "};\n"
-                      "void Fred::foo() { }");
-        ASSERT_EQUALS("", errout.str());
-
-        const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( ) {");
-        ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 4);
-    }
-
     void findFunction12() {
         GET_SYMBOL_DB("void foo(std::string a) { }\n"
                       "void foo(long long a) { }\n"
@@ -5062,7 +7496,7 @@ class TestSymbolDatabase: public TestFixture {
                       "    foo(\"\");\n"
                       "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( 0 ) ;");
         ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 2);
@@ -5090,50 +7524,31 @@ class TestSymbolDatabase: public TestFixture {
                       "void foo(int* a) { }\n"
                       "void foo(void* a) { }\n"
                       "void func(int i, const float f, int* ip, float* fp, char* cp) {\n"
-                      "    foo(0);\n"
-                      "    foo(0L);\n"
                       "    foo(0.f);\n"
-                      "    foo(false);\n"
                       "    foo(bar());\n"
-                      "    foo(i);\n"
                       "    foo(f);\n"
                       "    foo(&i);\n"
-                      "    foo(&f);\n"
                       "    foo(ip);\n"
                       "    foo(fp);\n"
                       "    foo(cp);\n"
                       "    foo(\"\");\n"
                       "}");
 
-        ASSERT_EQUALS("", errout.str());
-
-        const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( 0 ) ;");
-        ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 3);
-
-        f = Token::findsimplematch(tokenizer.tokens(), "foo ( 0L ) ;");
-        ASSERT_EQUALS(true, f && f->function() && f->function()->tokenDef->linenr() == 3);
-
-        f = Token::findsimplematch(tokenizer.tokens(), "foo ( 0.f ) ;");
-        ASSERT_EQUALS(true, f && f->function() && f->function()->tokenDef->linenr() == 2);
+        ASSERT_EQUALS("", errout_str());
 
-        f = Token::findsimplematch(tokenizer.tokens(), "foo ( false ) ;");
-        ASSERT_EQUALS(true, f && f->function() && f->function()->tokenDef->linenr() == 3);
+        const Token* f = Token::findsimplematch(tokenizer.tokens(), "foo ( 0.f ) ;");
+        ASSERT_EQUALS(true, f && f->function());
+        TODO_ASSERT_EQUALS(2, 3, f->function()->tokenDef->linenr());
 
         f = Token::findsimplematch(tokenizer.tokens(), "foo ( bar ( ) ) ;");
         ASSERT_EQUALS(true, f && f->function() == nullptr);
 
-        f = Token::findsimplematch(tokenizer.tokens(), "foo ( i ) ;");
-        ASSERT_EQUALS(true, f && f->function() && f->function()->tokenDef->linenr() == 3);
-
         f = Token::findsimplematch(tokenizer.tokens(), "foo ( f ) ;");
         ASSERT_EQUALS(true, f && f->function() && f->function()->tokenDef->linenr() == 2);
 
         f = Token::findsimplematch(tokenizer.tokens(), "foo ( & i ) ;");
         ASSERT_EQUALS(true, f && f->function() && f->function()->tokenDef->linenr() == 4);
 
-        f = Token::findsimplematch(tokenizer.tokens(), "foo ( & f ) ;");
-        ASSERT_EQUALS(true, f && f->function() == nullptr);
-
         f = Token::findsimplematch(tokenizer.tokens(), "foo ( ip ) ;");
         ASSERT_EQUALS(true, f && f->function() && f->function()->tokenDef->linenr() == 4);
 
@@ -5167,7 +7582,7 @@ class TestSymbolDatabase: public TestFixture {
                       "    foo2(NULL);\n"
                       "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( ip ) ;");
         ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 1);
@@ -5176,10 +7591,10 @@ class TestSymbolDatabase: public TestFixture {
         ASSERT_EQUALS(true, f && f->function() && f->function()->tokenDef->linenr() == 2);
 
         f = Token::findsimplematch(tokenizer.tokens(), "foo ( cp ) ;");
-        ASSERT_EQUALS(true, f && f->function() && f->function()->tokenDef->linenr() == 3);
+        TODO_ASSERT(f && f->function() && f->function()->tokenDef->linenr() == 3);
 
         f = Token::findsimplematch(tokenizer.tokens(), "foo ( ccp ) ;");
-        ASSERT_EQUALS(true, f && f->function() == nullptr);
+        ASSERT_EQUALS(true, f && f->function() && f->function()->tokenDef->linenr() == 5);
 
         f = Token::findsimplematch(tokenizer.tokens(), "foo ( f ) ;");
         ASSERT_EQUALS(true, f && f->function() && f->function()->tokenDef->linenr() == 4);
@@ -5201,6 +7616,7 @@ class TestSymbolDatabase: public TestFixture {
         GET_SYMBOL_DB("void foo1(int, char* a) { }\n"
                       "void foo1(int, char a) { }\n"
                       "void foo1(int, wchar_t a) { }\n"
+                      "void foo1(int, char16_t a) { }\n"
                       "void foo2(int, float a) { }\n"
                       "void foo2(int, wchar_t a) { }\n"
                       "void foo3(int, float a) { }\n"
@@ -5208,13 +7624,14 @@ class TestSymbolDatabase: public TestFixture {
                       "void func() {\n"
                       "    foo1(1, 'c');\n"
                       "    foo1(2, L'c');\n"
-                      "    foo2(3, 'c');\n"
-                      "    foo2(4, L'c');\n"
-                      "    foo3(5, 'c');\n"
-                      "    foo3(6, L'c');\n"
+                      "    foo1(3, u'c');\n"
+                      "    foo2(4, 'c');\n"
+                      "    foo2(5, L'c');\n"
+                      "    foo3(6, 'c');\n"
+                      "    foo3(7, L'c');\n"
                       "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo1 ( 1");
         ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 2);
@@ -5222,18 +7639,21 @@ class TestSymbolDatabase: public TestFixture {
         f = Token::findsimplematch(tokenizer.tokens(), "foo1 ( 2");
         ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 3);
 
-        f = Token::findsimplematch(tokenizer.tokens(), "foo2 ( 3");
-        ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 5);
+        f = Token::findsimplematch(tokenizer.tokens(), "foo1 ( 3");
+        ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 4);
 
         f = Token::findsimplematch(tokenizer.tokens(), "foo2 ( 4");
-        ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 5);
+        ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 6);
 
-        f = Token::findsimplematch(tokenizer.tokens(), "foo3 ( 5");
-        ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 7);
+        f = Token::findsimplematch(tokenizer.tokens(), "foo2 ( 5");
+        ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 6);
+
+        f = Token::findsimplematch(tokenizer.tokens(), "foo3 ( 6");
+        ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 8);
 
         // Error: ambiguous function call
-        //f = Token::findsimplematch(tokenizer.tokens(), "foo3 ( 6");
-        //ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 7);
+        //f = Token::findsimplematch(tokenizer.tokens(), "foo3 ( 7");
+        //ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 8);
     }
 
     void findFunction16() {
@@ -5251,7 +7671,7 @@ class TestSymbolDatabase: public TestFixture {
                       "    foo(c.fp);\n"
                       "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( c . i ) ;");
         ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 3);
@@ -5288,7 +7708,7 @@ class TestSymbolDatabase: public TestFixture {
                       "    foo(f + i);\n"
                       "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "foo ( i + i ) ;");
         ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 1);
@@ -5314,7 +7734,7 @@ class TestSymbolDatabase: public TestFixture {
                       "    void b() { f(1.f); }\n"
                       "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "f ( 1 ) ;");
         ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 2);
@@ -5359,7 +7779,7 @@ class TestSymbolDatabase: public TestFixture {
                       "    }\n"
                       "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         ASSERT(db);
 
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "get ( get ( v1 ) ) ;");
@@ -5370,11 +7790,7 @@ class TestSymbolDatabase: public TestFixture {
         f = Token::findsimplematch(tokenizer.tokens(), "get ( get ( v2 ) ) ;");
         ASSERT(f);
         ASSERT(f->function());
-        if (std::numeric_limits<char>::is_signed) {
-            ASSERT_EQUALS(5, f->function()->tokenDef->linenr());
-        } else {
-            ASSERT_EQUALS(10, f->function()->tokenDef->linenr());
-        }
+        ASSERT_EQUALS(5, f->function()->tokenDef->linenr());
 
         f = Token::findsimplematch(tokenizer.tokens(), "get ( get ( v3 ) ) ;");
         ASSERT(f);
@@ -5404,11 +7820,7 @@ class TestSymbolDatabase: public TestFixture {
         f = Token::findsimplematch(tokenizer.tokens(), "get ( get ( v8 ) ) ;");
         ASSERT(f);
         ASSERT(f->function());
-        if (std::numeric_limits<char>::is_signed) {
-            ASSERT_EQUALS(5, f->function()->tokenDef->linenr());
-        } else {
-            ASSERT_EQUALS(10, f->function()->tokenDef->linenr());
-        }
+        ASSERT_EQUALS(11, f->function()->tokenDef->linenr());
 
         f = Token::findsimplematch(tokenizer.tokens(), "get ( get ( v9 ) ) ;");
         ASSERT(f);
@@ -5460,121 +7872,947 @@ class TestSymbolDatabase: public TestFixture {
                       "    int _y;\n"
                       "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        const Token *f = Token::findsimplematch(tokenizer.tokens(), "copy ( & f ) ;");
+        ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 7);
+
+        f = Token::findsimplematch(tokenizer.tokens(), "copy ( * f ) ;");
+        ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 12);
+    }
+
+    void findFunction21() { // # 8558
+        GET_SYMBOL_DB("struct foo {\n"
+                      "    int GetThing( ) const { return m_thing; }\n"
+                      "    int* GetThing( ) { return &m_thing; }\n"
+                      "};\n"
+                      "\n"
+                      "void f(foo *myFoo) {\n"
+                      "    int* myThing = myFoo->GetThing();\n"
+                      "}");
+
+        ASSERT(db != nullptr);
+
+        const Token *tok1 = Token::findsimplematch(tokenizer.tokens(), "myFoo . GetThing ( ) ;");
+
+        const Function *f = tok1 && tok1->tokAt(2) ? tok1->tokAt(2)->function() : nullptr;
+        ASSERT(f != nullptr);
+        ASSERT_EQUALS(true, f && !f->isConst());
+    }
+
+    void findFunction22() { // # 8558
+        GET_SYMBOL_DB("struct foo {\n"
+                      "    int GetThing( ) const { return m_thing; }\n"
+                      "    int* GetThing( ) { return &m_thing; }\n"
+                      "};\n"
+                      "\n"
+                      "void f(const foo *myFoo) {\n"
+                      "    int* myThing = myFoo->GetThing();\n"
+                      "}");
+
+        ASSERT(db != nullptr);
+
+        const Token *tok1 = Token::findsimplematch(tokenizer.tokens(), ". GetThing ( ) ;")->next();
+
+        const Function *f = tok1 ? tok1->function() : nullptr;
+        ASSERT(f != nullptr);
+        ASSERT_EQUALS(true, f && f->isConst());
+    }
+
+    void findFunction23() { // # 8558
+        GET_SYMBOL_DB("struct foo {\n"
+                      "    int GetThing( ) const { return m_thing; }\n"
+                      "    int* GetThing( ) { return &m_thing; }\n"
+                      "};\n"
+                      "\n"
+                      "void f(foo *myFoo) {\n"
+                      "    int* myThing = ((const foo *)myFoo)->GetThing();\n"
+                      "}");
+
+        ASSERT(db != nullptr);
+
+        const Token *tok1 = Token::findsimplematch(tokenizer.tokens(), ". GetThing ( ) ;")->next();
+
+        const Function *f = tok1 ? tok1->function() : nullptr;
+        ASSERT(f != nullptr);
+        ASSERT_EQUALS(true, f && f->isConst());
+    }
+
+    void findFunction24() { // smart pointers
+        GET_SYMBOL_DB("struct foo {\n"
+                      "  void dostuff();\n"
+                      "}\n"
+                      "\n"
+                      "void f(std::shared_ptr<foo> p) {\n"
+                      "  p->dostuff();\n"
+                      "}");
+        ASSERT(db != nullptr);
+        const Token *tok1 = Token::findsimplematch(tokenizer.tokens(), ". dostuff ( ) ;")->next();
+        ASSERT(tok1->function());
+    }
+
+    void findFunction25() { // std::vector<std::shared_ptr<Fred>>
+        GET_SYMBOL_DB("struct foo {\n"
+                      "  void dostuff();\n"
+                      "}\n"
+                      "\n"
+                      "void f1(std::vector<std::shared_ptr<foo>> v)\n"
+                      "{\n"
+                      "    for (auto p : v)\n"
+                      "    {\n"
+                      "        p->dostuff();\n"
+                      "    }\n"
+                      "}");
+        ASSERT(db != nullptr);
+        const Token *tok1 = Token::findsimplematch(tokenizer.tokens(), ". dostuff ( ) ;")->next();
+        ASSERT(tok1->function());
+    }
+
+    void findFunction26() {
+        GET_SYMBOL_DB("void dostuff(const int *p) {}\n"
+                      "void dostuff(float) {}\n"
+                      "void f(int *p) {\n"
+                      "  dostuff(p);\n"
+                      "}");
+        ASSERT(db != nullptr);
+        const Token *dostuff1 = Token::findsimplematch(tokenizer.tokens(), "dostuff ( p ) ;");
+        ASSERT(dostuff1->function());
+        ASSERT(dostuff1->function() && dostuff1->function()->token);
+        ASSERT(dostuff1->function() && dostuff1->function()->token && dostuff1->function()->token->linenr() == 1);
+    }
+
+    void findFunction27() {
+        GET_SYMBOL_DB("namespace { void a(int); }\n"
+                      "void f() { a(9); }");
+        const Token *a = Token::findsimplematch(tokenizer.tokens(), "a ( 9 )");
+        ASSERT(a);
+        ASSERT(a->function());
+    }
+
+    void findFunction28() {
+        GET_SYMBOL_DB("namespace { void a(int); }\n"
+                      "struct S {\n"
+                      "  void foo() { a(7); }\n"
+                      "  void a(int);\n"
+                      "};");
+        const Token *a = Token::findsimplematch(tokenizer.tokens(), "a ( 7 )");
+        ASSERT(a);
+        ASSERT(a->function());
+        ASSERT(a->function()->token);
+        ASSERT_EQUALS(4, a->function()->token->linenr());
+    }
+
+    void findFunction29() {
+        GET_SYMBOL_DB("struct A {\n"
+                      "    int foo() const;\n"
+                      "};\n"
+                      "\n"
+                      "struct B {\n"
+                      "    A a;\n"
+                      "};\n"
+                      "\n"
+                      "typedef std::shared_ptr<B> BPtr;\n"
+                      "\n"
+                      "void bar(BPtr b) {\n"
+                      "    int x = b->a.foo();\n"
+                      "}");
+        const Token *foo = Token::findsimplematch(tokenizer.tokens(), "foo ( ) ;");
+        ASSERT(foo);
+        ASSERT(foo->function());
+        ASSERT(foo->function()->token);
+        ASSERT_EQUALS(2, foo->function()->token->linenr());
+    }
+
+    void findFunction30() {
+        GET_SYMBOL_DB("struct A;\n"
+                      "void foo(std::shared_ptr<A> ptr) {\n"
+                      "    int x = ptr->bar();\n"
+                      "}");
+        const Token *bar = Token::findsimplematch(tokenizer.tokens(), "bar ( ) ;");
+        ASSERT(bar);
+        ASSERT(!bar->function());
+    }
+
+    void findFunction31() {
+        GET_SYMBOL_DB("void foo(bool);\n"
+                      "void foo(std::string s);\n"
+                      "void bar() { foo(\"123\"); }");
+        const Token *foo = Token::findsimplematch(tokenizer.tokens(), "foo ( \"123\" ) ;");
+        ASSERT(foo);
+        ASSERT(foo->function());
+        ASSERT(foo->function()->tokenDef);
+        ASSERT_EQUALS(1, foo->function()->tokenDef->linenr());
+    }
+
+    void findFunction32() {
+        GET_SYMBOL_DB_C("void foo(char *p);\n"
+                        "void bar() { foo(\"123\"); }");
+        (void)db;
+        const Token *foo = Token::findsimplematch(tokenizer.tokens(), "foo ( \"123\" ) ;");
+        ASSERT(foo);
+        ASSERT(foo->function());
+        ASSERT(foo->function()->tokenDef);
+        ASSERT_EQUALS(1, foo->function()->tokenDef->linenr());
+    }
+
+    void findFunction33() {
+        {
+            GET_SYMBOL_DB("class Base {\n"
+                          "    int i{};\n"
+                          "public:\n"
+                          "    void foo(...) const { bar(); }\n"
+                          "    int bar() const { return i; }\n"
+                          "};\n"
+                          "class Derived : public Base {\n"
+                          "public:\n"
+                          "    void doIt() const {\n"
+                          "        foo();\n"
+                          "    }\n"
+                          "};");
+            (void)db;
+            const Token *foo = Token::findsimplematch(tokenizer.tokens(), "foo ( ) ;");
+            ASSERT(foo);
+            ASSERT(foo->function());
+            ASSERT(foo->function()->tokenDef);
+            ASSERT_EQUALS(4, foo->function()->tokenDef->linenr());
+        }
+        {
+            GET_SYMBOL_DB("class Base {\n"
+                          "    int i{};\n"
+                          "public:\n"
+                          "    void foo(...) const { bar(); }\n"
+                          "    int bar() const { return i; }\n"
+                          "};\n"
+                          "class Derived : public Base {\n"
+                          "public:\n"
+                          "    void doIt() const {\n"
+                          "        foo(1);\n"
+                          "    }\n"
+                          "};");
+            (void)db;
+            const Token *foo = Token::findsimplematch(tokenizer.tokens(), "foo ( 1 ) ;");
+            ASSERT(foo);
+            ASSERT(foo->function());
+            ASSERT(foo->function()->tokenDef);
+            ASSERT_EQUALS(4, foo->function()->tokenDef->linenr());
+        }
+        {
+            GET_SYMBOL_DB("class Base {\n"
+                          "    int i{};\n"
+                          "public:\n"
+                          "    void foo(...) const { bar(); }\n"
+                          "    int bar() const { return i; }\n"
+                          "};\n"
+                          "class Derived : public Base {\n"
+                          "public:\n"
+                          "    void doIt() const {\n"
+                          "        foo(1,2);\n"
+                          "    }\n"
+                          "};");
+            (void)db;
+            const Token *foo = Token::findsimplematch(tokenizer.tokens(), "foo ( 1 , 2 ) ;");
+            ASSERT(foo);
+            ASSERT(foo->function());
+            ASSERT(foo->function()->tokenDef);
+            ASSERT_EQUALS(4, foo->function()->tokenDef->linenr());
+        }
+        {
+            GET_SYMBOL_DB("class Base {\n"
+                          "    int i{};\n"
+                          "public:\n"
+                          "    void foo(int, ...) const { bar(); }\n"
+                          "    int bar() const { return i; }\n"
+                          "};\n"
+                          "class Derived : public Base {\n"
+                          "public:\n"
+                          "    void doIt() const {\n"
+                          "        foo(1);\n"
+                          "    }\n"
+                          "};");
+            (void)db;
+            const Token *foo = Token::findsimplematch(tokenizer.tokens(), "foo ( 1 ) ;");
+            ASSERT(foo);
+            ASSERT(foo->function());
+            ASSERT(foo->function()->tokenDef);
+            ASSERT_EQUALS(4, foo->function()->tokenDef->linenr());
+        }
+        {
+            GET_SYMBOL_DB("class Base {\n"
+                          "    int i{};\n"
+                          "public:\n"
+                          "    void foo(int,...) const { bar(); }\n"
+                          "    int bar() const { return i; }\n"
+                          "};\n"
+                          "class Derived : public Base {\n"
+                          "public:\n"
+                          "    void doIt() const {\n"
+                          "        foo(1,2);\n"
+                          "    }\n"
+                          "};");
+            (void)db;
+            const Token *foo = Token::findsimplematch(tokenizer.tokens(), "foo ( 1 , 2 ) ;");
+            ASSERT(foo);
+            ASSERT(foo->function());
+            ASSERT(foo->function()->tokenDef);
+            ASSERT_EQUALS(4, foo->function()->tokenDef->linenr());
+        }
+        {
+            GET_SYMBOL_DB("class Base {\n"
+                          "    int i{};\n"
+                          "public:\n"
+                          "    void foo(int,...) const { bar(); }\n"
+                          "    int bar() const { return i; }\n"
+                          "};\n"
+                          "class Derived : public Base {\n"
+                          "public:\n"
+                          "    void doIt() const {\n"
+                          "        foo(1, 2, 3);\n"
+                          "    }\n"
+                          "};");
+            (void)db;
+            const Token *foo = Token::findsimplematch(tokenizer.tokens(), "foo ( 1 , 2 , 3 ) ;");
+            ASSERT(foo);
+            ASSERT(foo->function());
+            ASSERT(foo->function()->tokenDef);
+            ASSERT_EQUALS(4, foo->function()->tokenDef->linenr());
+        }
+    }
+
+    void findFunction34() {
+        GET_SYMBOL_DB("namespace cppcheck {\n"
+                      "    class Platform {\n"
+                      "    public:\n"
+                      "        enum PlatformType { Unspecified };\n"
+                      "    };\n"
+                      "}\n"
+                      "class ImportProject {\n"
+                      "    void selectOneVsConfig(cppcheck::Platform::PlatformType);\n"
+                      "};\n"
+                      "class Settings : public cppcheck::Platform { };\n"
+                      "void ImportProject::selectOneVsConfig(Settings::PlatformType) { }");
+        (void)db;
+        const Token *foo = Token::findsimplematch(tokenizer.tokens(), "selectOneVsConfig ( Settings :: PlatformType ) { }");
+        ASSERT(foo);
+        ASSERT(foo->function());
+        ASSERT(foo->function()->tokenDef);
+        ASSERT_EQUALS(8, foo->function()->tokenDef->linenr());
+    }
+
+    void findFunction35() {
+        GET_SYMBOL_DB("namespace clangimport {\n"
+                      "    class AstNode {\n"
+                      "    public:\n"
+                      "        AstNode();\n"
+                      "        void createTokens();\n"
+                      "    };\n"
+                      "}\n"
+                      "::clangimport::AstNode::AstNode() { }\n"
+                      "void ::clangimport::AstNode::createTokens() { }");
+        (void)db;
+        const Token *foo = Token::findsimplematch(tokenizer.tokens(), "AstNode ( ) { }");
+        ASSERT(foo);
+        ASSERT(foo->function());
+        ASSERT(foo->function()->tokenDef);
+        ASSERT_EQUALS(4, foo->function()->tokenDef->linenr());
+        foo = Token::findsimplematch(tokenizer.tokens(), "createTokens ( ) { }");
+        ASSERT(foo);
+        ASSERT(foo->function());
+        ASSERT(foo->function()->tokenDef);
+        ASSERT_EQUALS(5, foo->function()->tokenDef->linenr());
+    }
+
+    void findFunction36() { // #10122
+        GET_SYMBOL_DB("namespace external {\n"
+                      "    enum class T { };\n"
+                      "}\n"
+                      "namespace ns {\n"
+                      "    class A {\n"
+                      "    public:\n"
+                      "        void f(external::T);\n"
+                      "    };\n"
+                      "}\n"
+                      "namespace ns {\n"
+                      "    void A::f(external::T link_type) { }\n"
+                      "}");
+        ASSERT_EQUALS("", errout_str());
+        const Token *functok = Token::findsimplematch(tokenizer.tokens(), "f ( external :: T link_type )");
+        ASSERT(functok);
+        ASSERT(functok->function());
+        ASSERT(functok->function()->name() == "f");
+        ASSERT_EQUALS(7, functok->function()->tokenDef->linenr());
+    }
+
+    void findFunction37() { // #10124
+        GET_SYMBOL_DB("namespace ns {\n"
+                      "    class V { };\n"
+                      "}\n"
+                      "class A {\n"
+                      "public:\n"
+                      "    void f(const ns::V&);\n"
+                      "};\n"
+                      "using ::ns::V;\n"
+                      "void A::f(const V&) { }");
+        ASSERT_EQUALS("", errout_str());
+        const Token *functok = Token::findsimplematch(tokenizer.tokens(), "f ( const :: ns :: V & )");
+        ASSERT(functok);
+        ASSERT(functok->function());
+        ASSERT(functok->function()->name() == "f");
+        ASSERT_EQUALS(6, functok->function()->tokenDef->linenr());
+    }
+
+    void findFunction38() { // #10125
+        GET_SYMBOL_DB("namespace ns {\n"
+                      "    class V { };\n"
+                      "    using Var = V;\n"
+                      "}\n"
+                      "class A {\n"
+                      "    void f(const ns::Var&);\n"
+                      "};\n"
+                      "using ::ns::Var;\n"
+                      "void A::f(const Var&) {}");
+        ASSERT_EQUALS("", errout_str());
+        const Token *functok = Token::findsimplematch(tokenizer.tokens(), "f ( const :: ns :: V & )");
+        ASSERT(functok);
+        ASSERT(functok->function());
+        ASSERT(functok->function()->name() == "f");
+        ASSERT_EQUALS(6, functok->function()->tokenDef->linenr());
+    }
+
+    void findFunction39() { // #10127
+        GET_SYMBOL_DB("namespace external {\n"
+                      "    class V {\n"
+                      "    public:\n"
+                      "        using I = int;\n"
+                      "    };\n"
+                      "}\n"
+                      "class A {\n"
+                      "    void f(external::V::I);\n"
+                      "};\n"
+                      "using ::external::V;\n"
+                      "void A::f(V::I) {}");
+        ASSERT_EQUALS("", errout_str());
+        const Token *functok = Token::findsimplematch(tokenizer.tokens(), "f ( int )");
+        ASSERT(functok);
+        ASSERT(functok->function());
+        ASSERT(functok->function()->name() == "f");
+        ASSERT_EQUALS(8, functok->function()->tokenDef->linenr());
+    }
+
+    void findFunction40() { // #10135
+        GET_SYMBOL_DB("class E : public std::exception {\n"
+                      "public:\n"
+                      "    const char* what() const noexcept override;\n"
+                      "};\n"
+                      "const char* E::what() const noexcept {\n"
+                      "    return nullptr;\n"
+                      "}");
+        ASSERT_EQUALS("", errout_str());
+        const Token *functok = Token::findsimplematch(tokenizer.tokens(), "what ( ) const noexcept ( true ) {");
+        ASSERT(functok);
+        ASSERT(functok->function());
+        ASSERT(functok->function()->name() == "what");
+        ASSERT_EQUALS(3, functok->function()->tokenDef->linenr());
+    }
+
+    void findFunction41() { // #10202
+        {
+            GET_SYMBOL_DB("struct A {};\n"
+                          "const int* g(const A&);\n"
+                          "int* g(A&);\n"
+                          "void f(A& x) {\n"
+                          "    int* y = g(x);\n"
+                          "    *y = 0;\n"
+                          "}\n");
+            ASSERT_EQUALS("", errout_str());
+            const Token *functok = Token::findsimplematch(tokenizer.tokens(), "g ( x )");
+            ASSERT(functok);
+            ASSERT(functok->function());
+            ASSERT(functok->function()->name() == "g");
+            ASSERT_EQUALS(3, functok->function()->tokenDef->linenr());
+        }
+        {
+            GET_SYMBOL_DB("struct A {};\n"
+                          "const int* g(const A&);\n"
+                          "int* g(A&);\n"
+                          "void f(const A& x) {\n"
+                          "    int* y = g(x);\n"
+                          "    *y = 0;\n"
+                          "}\n");
+            ASSERT_EQUALS("", errout_str());
+            const Token *functok = Token::findsimplematch(tokenizer.tokens(), "g ( x )");
+            ASSERT(functok);
+            ASSERT(functok->function());
+            ASSERT(functok->function()->name() == "g");
+            ASSERT_EQUALS(2, functok->function()->tokenDef->linenr());
+        }
+    }
+
+    void findFunction42() {
+        GET_SYMBOL_DB("void a(const std::string &, const std::string &);\n"
+                      "void a(long, long);\n"
+                      "void b() { a(true, false); }\n");
+        ASSERT_EQUALS("", errout_str());
+        const Token *functok = Token::findsimplematch(tokenizer.tokens(), "a ( true , false )");
+        ASSERT(functok);
+        ASSERT(functok->function());
+        ASSERT(functok->function()->name() == "a");
+        ASSERT_EQUALS(2, functok->function()->tokenDef->linenr());
+    }
+
+    void findFunction43() { // #10087
+        {
+            GET_SYMBOL_DB("struct A {};\n"
+                          "const A* g(const std::string&);\n"
+                          "const A& g(std::vector<A>::size_type i);\n"
+                          "const A& f(std::vector<A>::size_type i) { return g(i); }\n");
+            ASSERT_EQUALS("", errout_str());
+            const Token *functok = Token::findsimplematch(tokenizer.tokens(), "g ( i )");
+            ASSERT(functok);
+            ASSERT(functok->function());
+            ASSERT(functok->function()->name() == "g");
+            ASSERT_EQUALS(3, functok->function()->tokenDef->linenr());
+        }
+        {
+            GET_SYMBOL_DB("struct A {};\n"
+                          "const A& g(std::vector<A>::size_type i);\n"
+                          "const A* g(const std::string&);\n"
+                          "const A& f(std::vector<A>::size_type i) { return g(i); }\n");
+            ASSERT_EQUALS("", errout_str());
+            const Token *functok = Token::findsimplematch(tokenizer.tokens(), "g ( i )");
+            ASSERT(functok);
+            ASSERT(functok->function());
+            ASSERT(functok->function()->name() == "g");
+            ASSERT_EQUALS(2, functok->function()->tokenDef->linenr());
+        }
+    }
+
+    void findFunction44() { // #11182
+        {
+            GET_SYMBOL_DB("struct T { enum E { E0 }; };\n"
+                          "struct S {\n"
+                          "    void f(const void*, T::E) {}\n"
+                          "    void f(const int&, T::E) {}\n"
+                          "    void g() { f(nullptr, T::E0); }\n"
+                          "};\n");
+            ASSERT_EQUALS("", errout_str());
+            const Token *functok = Token::findsimplematch(tokenizer.tokens(), "f ( nullptr");
+            ASSERT(functok);
+            ASSERT(functok->function());
+            ASSERT(functok->function()->name() == "f");
+            ASSERT_EQUALS(3, functok->function()->tokenDef->linenr());
+        }
+        {
+            GET_SYMBOL_DB("enum E { E0 };\n"
+                          "struct S {\n"
+                          "    void f(int*, int) {}\n"
+                          "    void f(int, int) {}\n"
+                          "    void g() { f(nullptr, E0); }\n"
+                          "};\n");
+            ASSERT_EQUALS("", errout_str());
+            const Token *functok = Token::findsimplematch(tokenizer.tokens(), "f ( nullptr");
+            ASSERT(functok);
+            ASSERT(functok->function());
+            ASSERT(functok->function()->name() == "f");
+            ASSERT_EQUALS(3, functok->function()->tokenDef->linenr());
+        }
+        {
+            GET_SYMBOL_DB("struct T { enum E { E0 }; } t; \n" // #11559
+                          "void f(const void*, T::E) {}\n"
+                          "void f(const int&, T::E) {}\n"
+                          "void g() {\n"
+                          "    f(nullptr, t.E0);\n"
+                          "}\n");
+            ASSERT_EQUALS("", errout_str());
+            const Token *functok = Token::findsimplematch(tokenizer.tokens(), "f ( nullptr");
+            ASSERT(functok);
+            ASSERT(functok->function());
+            ASSERT(functok->function()->name() == "f");
+            ASSERT_EQUALS(2, functok->function()->tokenDef->linenr());
+        }
+    }
+
+    void findFunction45() {
+        GET_SYMBOL_DB("struct S { void g(int); };\n"
+                      "void f(std::vector<S>& v) {\n"
+                      "    std::vector<S>::iterator it = v.begin();\n"
+                      "    it->g(1);\n"
+                      "}\n");
+        ASSERT_EQUALS("", errout_str());
+        const Token *functok = Token::findsimplematch(tokenizer.tokens(), "g ( 1");
+        ASSERT(functok);
+        ASSERT(functok->function());
+        ASSERT(functok->function()->name() == "g");
+        ASSERT_EQUALS(1, functok->function()->tokenDef->linenr());
+    }
+
+    void findFunction46() {
+        GET_SYMBOL_DB("struct S {\n" // #11531
+                      "    const int* g(int i, int j) const;\n"
+                      "    int* g(int i, int j);\n"
+                      "};\n"
+                      "enum E { E0 };\n"
+                      "void f(S& s, int i) {\n"
+                      "    int* p = s.g(E0, i);\n"
+                      "    *p = 0;\n"
+                      "}\n");
+        ASSERT_EQUALS("", errout_str());
+        const Token *functok = Token::findsimplematch(tokenizer.tokens(), "g ( E0");
+        ASSERT(functok && functok->function());
+        ASSERT(functok->function()->name() == "g");
+        ASSERT_EQUALS(3, functok->function()->tokenDef->linenr());
+    }
+
+    void findFunction47() { // #8592
+        {
+            GET_SYMBOL_DB("namespace N {\n"
+                          "    void toupper(std::string& str);\n"
+                          "}\n"
+                          "void f(std::string s) {\n"
+                          "    using namespace N;\n"
+                          "    toupper(s);\n"
+                          "}\n");
+            ASSERT_EQUALS("", errout_str());
+            const Token *functok = Token::findsimplematch(tokenizer.tokens(), "toupper ( s");
+            ASSERT(functok && functok->function());
+            ASSERT(functok->function()->name() == "toupper");
+            ASSERT_EQUALS(2, functok->function()->tokenDef->linenr());
+        }
+        {
+            GET_SYMBOL_DB("namespace N {\n"
+                          "    void toupper(std::string& str);\n"
+                          "}\n"
+                          "using namespace N;\n"
+                          "void f(std::string s) {\n"
+                          "    toupper(s);\n"
+                          "}\n");
+            ASSERT_EQUALS("", errout_str());
+            const Token *functok = Token::findsimplematch(tokenizer.tokens(), "toupper ( s");
+            ASSERT(functok && functok->function());
+            ASSERT(functok->function()->name() == "toupper");
+            ASSERT_EQUALS(2, functok->function()->tokenDef->linenr());
+        }
+    }
 
-        const Token *f = Token::findsimplematch(tokenizer.tokens(), "copy ( & f ) ;");
-        ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 7);
+    void findFunction48() {
+        GET_SYMBOL_DB("struct S {\n"
+                      "    S() {}\n"
+                      "    std::list<S> l;\n"
+                      "};\n");
+        ASSERT_EQUALS("", errout_str());
+        const Token* typeTok = Token::findsimplematch(tokenizer.tokens(), "S >");
+        ASSERT(typeTok && typeTok->type());
+        ASSERT(typeTok->type()->name() == "S");
+        ASSERT_EQUALS(1, typeTok->type()->classDef->linenr());
+    }
+
+    void findFunction49() {
+        GET_SYMBOL_DB("struct B {};\n"
+                      "struct D : B {};\n"
+                      "void f(bool = false, bool = true);\n"
+                      "void f(B*, bool, bool = true);\n"
+                      "void g() {\n"
+                      "    D d;\n"
+                      "    f(&d, true);\n"
+                      "}\n");
+        ASSERT_EQUALS("", errout_str());
+        const Token* ftok = Token::findsimplematch(tokenizer.tokens(), "f ( &");
+        ASSERT(ftok && ftok->function());
+        ASSERT(ftok->function()->name() == "f");
+        ASSERT_EQUALS(4, ftok->function()->tokenDef->linenr());
+    }
+
+    void findFunction50() {
+        {
+            GET_SYMBOL_DB("struct B { B(); void init(unsigned int value); };\n"
+                          "struct D: B { D(); void init(unsigned int value); };\n"
+                          "D::D() { init(0); }\n"
+                          "void D::init(unsigned int value) {}\n");
+            const Token* call = Token::findsimplematch(tokenizer.tokens(), "init ( 0 ) ;");
+            ASSERT(call && call->function() && call->function()->functionScope);
+        }
 
-        f = Token::findsimplematch(tokenizer.tokens(), "copy ( * f ) ;");
-        ASSERT_EQUALS(true, db && f && f->function() && f->function()->tokenDef->linenr() == 12);
+        {
+            GET_SYMBOL_DB("struct B { B(); void init(unsigned int value); };\n"
+                          "struct D: B { D(); void init(unsigned int value); };\n"
+                          "D::D() { init(0ULL); }\n"
+                          "void D::init(unsigned int value) {}\n");
+            const Token* call = Token::findsimplematch(tokenizer.tokens(), "init ( 0ULL ) ;");
+            ASSERT(call && call->function() && call->function()->functionScope);
+        }
     }
 
-    void findFunction21() { // # 8558
-        GET_SYMBOL_DB("struct foo {\n"
-                      "    int GetThing( ) const { return m_thing; }\n"
-                      "    int* GetThing( ) { return &m_thing; }\n"
-                      "};\n"
-                      "\n"
-                      "void f(foo *myFoo) {\n"
-                      "    int* myThing = myFoo->GetThing();\n"
-                      "}");
-
-        ASSERT(db != nullptr);
+    void findFunction51() {
+        // Both A and B defines the method test but with different arguments.
+        // The call to test in B should match the method in B. The match is close enough.
+        {
+            GET_SYMBOL_DB("class A {\n"
+                          "public:\n"
+                          "    void test(bool a = true);\n"
+                          "};\n"
+                          "\n"
+                          "class B : public A {\n"
+                          "public:\n"
+                          "  B(): b_obj(this) { b_obj->test(\"1\"); }\n"
+                          "  void test(const std::string& str_obj);\n"
+                          "  B* b_obj;\n"
+                          "};");
+            const Token* call = Token::findsimplematch(tokenizer.tokens(), "test ( \"1\" ) ;");
+            ASSERT(call);
+            ASSERT(call->function());
+            ASSERT(call->function()->tokenDef);
+            ASSERT_EQUALS(9, call->function()->tokenDef->linenr());
+        }
+        {
+            GET_SYMBOL_DB("struct STR { STR(const char * p); };\n"
+                          "class A {\n"
+                          "public:\n"
+                          "    void test(bool a = true);\n"
+                          "};\n"
+                          "\n"
+                          "class B : public A {\n"
+                          "public:\n"
+                          "  B(): b_obj(this) { b_obj->test(\"1\"); }\n"
+                          "  void test(const STR& str_obj);\n"
+                          "  B* b_obj;\n"
+                          "};");
+            const Token* call = Token::findsimplematch(tokenizer.tokens(), "test ( \"1\" ) ;");
+            ASSERT(call);
+            ASSERT(call->function());
+            ASSERT(call->function()->tokenDef);
+            ASSERT_EQUALS(10, call->function()->tokenDef->linenr());
+        }
+        {
+            GET_SYMBOL_DB("struct STR { STR(const char * p); };\n"
+                          "class A {\n"
+                          "public:\n"
+                          "    void test(bool a = true, int b = 0);\n"
+                          "};\n"
+                          "\n"
+                          "class B : public A {\n"
+                          "public:\n"
+                          "  B(): b_obj(this) { b_obj->test(\"1\"); }\n"
+                          "  void test(const STR& str_obj);\n"
+                          "  B* b_obj;\n"
+                          "};");
+            const Token* call = Token::findsimplematch(tokenizer.tokens(), "test ( \"1\" ) ;");
+            ASSERT(call);
+            ASSERT(call->function());
+            ASSERT(call->function()->tokenDef);
+            ASSERT_EQUALS(10, call->function()->tokenDef->linenr());
+        }
+    }
 
-        const Token *tok1 = Token::findsimplematch(tokenizer.tokens(), "myFoo . GetThing ( ) ;");
+    void findFunction52() {
+        GET_SYMBOL_DB("int g();\n"
+                      "void f() {\n"
+                      "    if (g != 0) {}\n"
+                      "}\n");
+        const Token* g = Token::findsimplematch(tokenizer.tokens(), "g !=");
+        ASSERT(g->function() && g->function()->tokenDef);
+        ASSERT(g->function()->tokenDef->linenr() == 1);
+    }
 
-        const Function *f = tok1 && tok1->tokAt(2) ? tok1->tokAt(2)->function() : nullptr;
-        ASSERT(f != nullptr);
-        ASSERT_EQUALS(true, f && !f->isConst());
+    void findFunction53() {
+        GET_SYMBOL_DB("namespace N {\n" // #12208
+                      "    struct S {\n"
+                      "        S(const int*);\n"
+                      "    };\n"
+                      "}\n"
+                      "void f(int& r) {\n"
+                      "    N::S(&r);\n"
+                      "}\n");
+        const Token* S = Token::findsimplematch(tokenizer.tokens(), "S ( &");
+        ASSERT(S->function() && S->function()->tokenDef);
+        ASSERT(S->function()->tokenDef->linenr() == 3);
+        ASSERT(S->function()->isConstructor());
     }
 
-    void findFunction22() { // # 8558
-        GET_SYMBOL_DB("struct foo {\n"
-                      "    int GetThing( ) const { return m_thing; }\n"
-                      "    int* GetThing( ) { return &m_thing; }\n"
+    void findFunction54() {
+        {
+            GET_SYMBOL_DB("struct S {\n"
+                          "    explicit S(int& r) { if (r) {} }\n"
+                          "    bool f(const std::map<int, S>& m);\n"
+                          "};\n");
+            const Token* S = Token::findsimplematch(tokenizer.tokens(), "S (");
+            ASSERT(S && S->function());
+            ASSERT(S->function()->isConstructor());
+            ASSERT(!S->function()->functionPointerUsage);
+            S = Token::findsimplematch(S->next(), "S >");
+            ASSERT(S && S->type());
+            ASSERT_EQUALS(S->type()->name(), "S");
+        }
+        {
+            GET_SYMBOL_DB("struct S {\n"
+                          "    explicit S(int& r) { if (r) {} }\n"
+                          "    bool f(const std::map<int, S, std::allocator<S>>& m);\n"
+                          "};\n");
+            const Token* S = Token::findsimplematch(tokenizer.tokens(), "S (");
+            ASSERT(S && S->function());
+            ASSERT(S->function()->isConstructor());
+            ASSERT(!S->function()->functionPointerUsage);
+            S = Token::findsimplematch(S->next(), "S ,");
+            ASSERT(S && S->type());
+            ASSERT_EQUALS(S->type()->name(), "S");
+            S = Token::findsimplematch(S->next(), "S >");
+            ASSERT(S && S->type());
+            ASSERT_EQUALS(S->type()->name(), "S");
+        }
+    }
+
+    void findFunction55() {
+        GET_SYMBOL_DB("struct Token { int x; };\n"
+                      "static void f(std::size_t s);\n"
+                      "static void f(const Token* ptr);\n"
+                      "static void f2(const std::vector<Token*>& args) { f(args[0]); }\n");
+        const Token* f = Token::findsimplematch(tokenizer.tokens(), "f ( args [ 0 ] )");
+        ASSERT(f && f->function());
+        ASSERT(Token::simpleMatch(f->function()->tokenDef, "f ( const Token * ptr ) ;"));
+    }
+
+    void findFunction56() { // #13125
+        GET_SYMBOL_DB("void f(const char* fn, int i, const char e[], const std::string& a);\n"
+                      "void f(const char* fn, int i, const char e[], const char a[]);\n"
+                      "void g(const char x[], const std::string& s) {\n"
+                      "    f(\"abc\", 65, x, s);\n"
+                      "}\n");
+        const Token* f = Token::findsimplematch(tokenizer.tokens(), "f ( \"abc\"");
+        ASSERT(f && f->function());
+        ASSERT_EQUALS(f->function()->tokenDef->linenr(), 1);
+    }
+
+    void findFunction57() { // #13051
+        GET_SYMBOL_DB("struct S {\n"
+                      "    ~S();\n"
+                      "    void f();\n"
                       "};\n"
-                      "\n"
-                      "void f(const foo *myFoo) {\n"
-                      "    int* myThing = myFoo->GetThing();\n"
-                      "}");
-
-        ASSERT(db != nullptr);
+                      "struct T {\n"
+                      "    T();\n"
+                      "};\n"
+                      "void S::f() {\n"
+                      "    auto s1 = new S;\n"
+                      "    auto s2 = new S();\n"
+                      "    auto t = new T();\n"
+                      "}\n");
+        const Token* S = Token::findsimplematch(tokenizer.tokens(), "S ;");
+        ASSERT(S && S->type());
+        ASSERT_EQUALS(S->type()->classDef->linenr(), 1);
+        S = Token::findsimplematch(S, "S (");
+        ASSERT(S && S->type());
+        ASSERT_EQUALS(S->type()->classDef->linenr(), 1);
+        const Token* T = Token::findsimplematch(S, "T (");
+        ASSERT(T && T->function());
+        ASSERT_EQUALS(T->function()->tokenDef->linenr(), 6);
+    }
+
+    void findFunction58() { // #13310
+        GET_SYMBOL_DB("class C {\n"
+                      "    enum class abc : uint8_t {\n"
+                      "        a,b,c\n"
+                      "    };\n"
+                      "    void a();\n"
+                      "};\n");
+        const Token *a1 = Token::findsimplematch(tokenizer.tokens(), "a ,");
+        ASSERT(a1 && !a1->function());
+        const Token *a2 = Token::findsimplematch(tokenizer.tokens(), "a (");
+        ASSERT(a2 && a2->function());
+    }
 
-        const Token *tok1 = Token::findsimplematch(tokenizer.tokens(), ". GetThing ( ) ;")->next();
+    void findFunction59() { // #13464
+        GET_SYMBOL_DB("void foo(const char[], const std::string&);\n"
+                      "void foo(const std::string&, const std::string&);\n"
+                      "void f() {\n"
+                      "    foo(\"\", \"\");\n"
+                      "}\n");
+        const Token* foo = Token::findsimplematch(tokenizer.tokens(), "foo ( \"\"");
+        ASSERT(foo && foo->function());
+        ASSERT_EQUALS(foo->function()->tokenDef->linenr(), 1);
+    }
 
-        const Function *f = tok1 ? tok1->function() : nullptr;
-        ASSERT(f != nullptr);
-        ASSERT_EQUALS(true, f && f->isConst());
+    void findFunction60() { // #12910
+        GET_SYMBOL_DB("template <class T>\n"
+                      "void fun(T& t, bool x = false) {\n"
+                      "    t.push_back(0);\n"
+                      "}\n"
+                      "template <class T>\n"
+                      "void fun(bool x = false) {\n"
+                      "    T t;\n"
+                      "    fun(t, x);\n"
+                      "}\n"
+                      "int f() {\n"
+                      "    fun<std::vector<int>>(true);\n"
+                      "    std::vector<int> v;\n"
+                      "    fun(v);\n"
+                      "    return v.back();\n"
+                      "}\n");
+        const Token* fun = Token::findsimplematch(tokenizer.tokens(), "fun ( v");
+        ASSERT(fun && !fun->function());
+    }
+
+    void findFunction61() {
+        GET_SYMBOL_DB("namespace N {\n" // #13975
+                      "    struct B {\n"
+                      "        virtual ~B() = default;\n"
+                      "    };\n"
+                      "    struct D : B {\n"
+                      "        D() : B() {}\n"
+                      "    };\n"
+                      "}\n");
+        const Token* fun = Token::findsimplematch(tokenizer.tokens(), "B ( ) {");
+        ASSERT(fun && !fun->function());
     }
 
-    void findFunction23() { // # 8558
-        GET_SYMBOL_DB("struct foo {\n"
-                      "    int GetThing( ) const { return m_thing; }\n"
-                      "    int* GetThing( ) { return &m_thing; }\n"
+    void findFunction62() { // #14272
+        GET_SYMBOL_DB("class Token {\n"
+                      "    std::string stringifyList(const Token* end, bool attributes = true) const;\n"
+                      "    std::string stringifyList(bool varid = false) const;\n"
                       "};\n"
                       "\n"
-                      "void f(foo *myFoo) {\n"
-                      "    int* myThing = ((const foo *)myFoo)->GetThing();\n"
-                      "}");
-
-        ASSERT(db != nullptr);
-
-        const Token *tok1 = Token::findsimplematch(tokenizer.tokens(), ". GetThing ( ) ;")->next();
-
-        const Function *f = tok1 ? tok1->function() : nullptr;
-        ASSERT(f != nullptr);
-        ASSERT_EQUALS(true, f && f->isConst());
-    }
-
-    void findFunction24() { // smart pointers
-        GET_SYMBOL_DB("struct foo {\n"
-                      "  void dostuff();\n"
+                      "void foo(const Token * const tokIf) {\n"
+                      "    tokIf->stringifyList(tokIf);\n"
+                      "}\n");
+        const Token* functionCall = Token::findsimplematch(tokenizer.tokens(), "stringifyList ( tokIf )");
+        ASSERT(functionCall);
+        ASSERT(functionCall->function());
+        ASSERT(functionCall->function()->token);
+        ASSERT_EQUALS(2, functionCall->function()->token->linenr());
+    }
+
+    void findFunctionRef1() {
+        GET_SYMBOL_DB("struct X {\n"
+                      "    const std::vector<int> getInts() const & { return mInts; }\n"
+                      "    std::vector<int> getInts() && { return mInts; }\n"
+                      "    std::vector<int> mInts;\n"
                       "}\n"
                       "\n"
-                      "void f(std::shared_ptr<foo> p) {\n"
-                      "  p->dostuff();\n"
-                      "}");
-        ASSERT(db != nullptr);
-        const Token *tok1 = Token::findsimplematch(tokenizer.tokens(), ". dostuff ( ) ;")->next();
-        ASSERT(tok1->function());
+                      "void foo(X &x) {\n"
+                      "    x.getInts();\n"
+                      "}\n");
+        const Token* x = Token::findsimplematch(tokenizer.tokens(), "x . getInts ( ) ;");
+        ASSERT(x);
+        const Token* f = x->tokAt(2);
+        ASSERT(f);
+        ASSERT(f->function());
+        ASSERT(f->function()->tokenDef);
+        ASSERT_EQUALS(2, f->function()->tokenDef->linenr());
     }
 
-    void findFunction25() { // std::vector<std::shared_ptr<Fred>>
-        GET_SYMBOL_DB("struct foo {\n"
-                      "  void dostuff();\n"
+    void findFunctionRef2() {
+        GET_SYMBOL_DB("struct X {\n"
+                      "    const int& foo() const &;\n" // <- this function is called
+                      "    int foo() &&;\n"
                       "}\n"
                       "\n"
-                      "void f1(std::vector<std::shared_ptr<foo>> v)\n"
-                      "{\n"
-                      "    for (auto p : v)\n"
-                      "    {\n"
-                      "        p->dostuff();\n"
-                      "    }\n"
-                      "}");
-        ASSERT(db != nullptr);
-        const Token *tok1 = Token::findsimplematch(tokenizer.tokens(), ". dostuff ( ) ;")->next();
-        ASSERT(tok1->function());
-    }
-
-    void findFunction26() {
-        GET_SYMBOL_DB("void dostuff(const int *p) {}\n"
-                      "void dostuff(float) {}\n"
-                      "void f(int *p) {\n"
-                      "  dostuff(p);\n"
-                      "}");
-        ASSERT(db != nullptr);
-        const Token *dostuff1 = Token::findsimplematch(tokenizer.tokens(), "dostuff ( p ) ;");
-        ASSERT(dostuff1->function());
-        ASSERT(dostuff1->function() && dostuff1->function()->token);
-        ASSERT(dostuff1->function() && dostuff1->function()->token && dostuff1->function()->token->linenr() == 1);
-    }
-
-    void findFunction27() {
-        GET_SYMBOL_DB("namespace { void a(int); }\n"
-                      "void f() { a(9); }");
-        const Token *a = Token::findsimplematch(tokenizer.tokens(), "a ( 9 )");
-        ASSERT(a);
-        ASSERT(a->function());
+                      "void foo() {\n"
+                      "    X x;\n"
+                      "    x.foo();\n"
+                      "}\n");
+        const Token* x = Token::findsimplematch(tokenizer.tokens(), "x . foo ( ) ;");
+        ASSERT(x);
+        const Token* f = x->tokAt(2);
+        ASSERT(f);
+        ASSERT(f->function());
+        ASSERT(f->function()->tokenDef);
+        ASSERT_EQUALS(2, f->function()->tokenDef->linenr());
     }
 
     void findFunctionContainer() {
@@ -5601,61 +8839,100 @@ class TestSymbolDatabase: public TestFixture {
         }
     }
 
-    void valueTypeMatchParameter() {
+    void findFunctionExternC() {
+        GET_SYMBOL_DB("extern \"C\" { void foo(int); }\n"
+                      "void bar() {\n"
+                      "    foo(42);\n"
+                      "}");
+        const Token *a = Token::findsimplematch(tokenizer.tokens(), "foo ( 42 )");
+        ASSERT(a);
+        ASSERT(a->function());
+    }
+
+    void findFunctionGlobalScope() {
+        GET_SYMBOL_DB("struct S {\n"
+                      "    void foo();\n"
+                      "    int x;\n"
+                      "};\n"
+                      "\n"
+                      "int bar(int x);\n"
+                      "\n"
+                      "void S::foo() {\n"
+                      "    x = ::bar(x);\n"
+                      "}");
+        const Token *bar = Token::findsimplematch(tokenizer.tokens(), "bar ( x )");
+        ASSERT(bar);
+        ASSERT(bar->function());
+    }
+
+    void overloadedFunction1() {
+        GET_SYMBOL_DB("struct S {\n"
+                      "    int operator()(int);\n"
+                      "};\n"
+                      "\n"
+                      "void foo(S x) {\n"
+                      "    x(123);\n"
+                      "}");
+        const Token *tok = Token::findsimplematch(tokenizer.tokens(), "x . operator() ( 123 )");
+        ASSERT(tok);
+        ASSERT(tok->tokAt(2)->function());
+    }
+
+    void valueTypeMatchParameter() const {
         ValueType vt_int(ValueType::Sign::SIGNED, ValueType::Type::INT, 0);
         ValueType vt_const_int(ValueType::Sign::SIGNED, ValueType::Type::INT, 0, 1);
-        ASSERT_EQUALS((int)ValueType::MatchResult::SAME, (int)ValueType::matchParameter(&vt_int, &vt_int));
-        ASSERT_EQUALS((int)ValueType::MatchResult::SAME, (int)ValueType::matchParameter(&vt_const_int, &vt_int));
-        ASSERT_EQUALS((int)ValueType::MatchResult::SAME, (int)ValueType::matchParameter(&vt_int, &vt_const_int));
+        ASSERT_EQUALS_ENUM(ValueType::MatchResult::SAME, ValueType::matchParameter(&vt_int, &vt_int));
+        ASSERT_EQUALS_ENUM(ValueType::MatchResult::SAME, ValueType::matchParameter(&vt_const_int, &vt_int));
+        ASSERT_EQUALS_ENUM(ValueType::MatchResult::SAME, ValueType::matchParameter(&vt_int, &vt_const_int));
 
         ValueType vt_char_pointer(ValueType::Sign::SIGNED, ValueType::Type::CHAR, 1);
         ValueType vt_void_pointer(ValueType::Sign::SIGNED, ValueType::Type::VOID, 1); // compatible
         ValueType vt_int_pointer(ValueType::Sign::SIGNED, ValueType::Type::INT, 1); // not compatible
-        ASSERT_EQUALS((int)ValueType::MatchResult::FALLBACK1, (int)ValueType::matchParameter(&vt_char_pointer, &vt_void_pointer));
-        ASSERT_EQUALS((int)ValueType::MatchResult::NOMATCH, (int)ValueType::matchParameter(&vt_char_pointer, &vt_int_pointer));
+        ASSERT_EQUALS_ENUM(ValueType::MatchResult::FALLBACK1, ValueType::matchParameter(&vt_char_pointer, &vt_void_pointer));
+        ASSERT_EQUALS_ENUM(ValueType::MatchResult::NOMATCH, ValueType::matchParameter(&vt_char_pointer, &vt_int_pointer));
 
         ValueType vt_char_pointer2(ValueType::Sign::SIGNED, ValueType::Type::CHAR, 2);
-        ASSERT_EQUALS((int)ValueType::MatchResult::FALLBACK1, (int)ValueType::matchParameter(&vt_char_pointer2, &vt_void_pointer));
+        ASSERT_EQUALS_ENUM(ValueType::MatchResult::FALLBACK1, ValueType::matchParameter(&vt_char_pointer2, &vt_void_pointer));
 
         ValueType vt_const_float_pointer(ValueType::Sign::UNKNOWN_SIGN, ValueType::Type::FLOAT, 1, 1);
         ValueType vt_long_long(ValueType::Sign::SIGNED, ValueType::Type::LONGLONG, 0, 0);
-        ASSERT_EQUALS((int)ValueType::MatchResult::NOMATCH, (int)ValueType::matchParameter(&vt_const_float_pointer, &vt_long_long));
+        ASSERT_EQUALS_ENUM(ValueType::MatchResult::NOMATCH, ValueType::matchParameter(&vt_const_float_pointer, &vt_long_long));
     }
 
-#define FUNC(x) const Function *x = findFunctionByName(#x, &db->scopeList.front()); \
-                ASSERT_EQUALS(true, x != nullptr);                                  \
-                if (x) ASSERT_EQUALS(true, x->isNoExcept());
+#define FUNC(x) do { \
+        const Function *x = findFunctionByName(#x, &db->scopeList.front()); \
+        ASSERT_EQUALS(true, x != nullptr);                                  \
+        ASSERT_EQUALS(true, x->isNoExcept()); \
+} while (false)
 
     void noexceptFunction1() {
         GET_SYMBOL_DB("void func1() noexcept;\n"
                       "void func2() noexcept { }\n"
                       "void func3() noexcept(true);\n"
-                      "void func4() noexcept(true) { }\n");
-        ASSERT_EQUALS("", errout.str());
+                      "void func4() noexcept(true) { }");
+        ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS(true,  db != nullptr); // not null
 
-        if (db) {
-            FUNC(func1);
-            FUNC(func2);
-            FUNC(func3);
-            FUNC(func4);
-        }
+        FUNC(func1);
+        FUNC(func2);
+        FUNC(func3);
+        FUNC(func4);
     }
 
     void noexceptFunction2() {
-        GET_SYMBOL_DB("template <class T> void self_assign(T& t) noexcept(noexcept(t = t)) {t = t; }\n");
+        GET_SYMBOL_DB("template <class T> void self_assign(T& t) noexcept(noexcept(t = t)) {t = t; }");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS(true,  db != nullptr); // not null
 
-        if (db) {
-            FUNC(self_assign);
-        }
+        FUNC(self_assign);
     }
 
-#define CLASS_FUNC(x, y, z) const Function *x = findFunctionByName(#x, y); \
-                         ASSERT_EQUALS(true, x != nullptr);             \
-                         if (x) ASSERT_EQUALS(z, x->isNoExcept());
+#define CLASS_FUNC(x, y, z) do { \
+        const Function *x = findFunctionByName(#x, y); \
+        ASSERT_EQUALS(true, x != nullptr);             \
+        ASSERT_EQUALS(z, x->isNoExcept()); \
+} while (false)
 
     void noexceptFunction3() {
         GET_SYMBOL_DB("struct Fred {\n"
@@ -5673,28 +8950,24 @@ class TestSymbolDatabase: public TestFixture {
                       "    void func12() const noexcept(true) = 0;\n"
                       "    void func13() const noexcept(false) = 0;\n"
                       "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS(true,  db != nullptr); // not null
 
-        if (db) {
-            const Scope *fred = db->findScopeByName("Fred");
-            ASSERT_EQUALS(true, fred != nullptr);
-            if (fred) {
-                CLASS_FUNC(func1, fred, true);
-                CLASS_FUNC(func2, fred, true);
-                CLASS_FUNC(func3, fred, true);
-                CLASS_FUNC(func4, fred, true);
-                CLASS_FUNC(func5, fred, true);
-                CLASS_FUNC(func6, fred, true);
-                CLASS_FUNC(func7, fred, true);
-                CLASS_FUNC(func8, fred, true);
-                CLASS_FUNC(func9, fred, true);
-                CLASS_FUNC(func10, fred, true);
-                CLASS_FUNC(func11, fred, true);
-                CLASS_FUNC(func12, fred, true);
-                CLASS_FUNC(func13, fred, false);
-            }
-        }
+        const Scope *fred = db->findScopeByName("Fred");
+        ASSERT_EQUALS(true, fred != nullptr);
+        CLASS_FUNC(func1, fred, true);
+        CLASS_FUNC(func2, fred, true);
+        CLASS_FUNC(func3, fred, true);
+        CLASS_FUNC(func4, fred, true);
+        CLASS_FUNC(func5, fred, true);
+        CLASS_FUNC(func6, fred, true);
+        CLASS_FUNC(func7, fred, true);
+        CLASS_FUNC(func8, fred, true);
+        CLASS_FUNC(func9, fred, true);
+        CLASS_FUNC(func10, fred, true);
+        CLASS_FUNC(func11, fred, true);
+        CLASS_FUNC(func12, fred, true);
+        CLASS_FUNC(func13, fred, false);
     }
 
     void noexceptFunction4() {
@@ -5708,42 +8981,39 @@ class TestSymbolDatabase: public TestFixture {
                       "   A a;\n"
                       "   B(B&& b) noexcept\n"
                       "   :a(std::move(b.a)) { }\n"
-                      "};\n");
-        ASSERT_EQUALS("", errout.str());
-        ASSERT_EQUALS(true,  db != nullptr); // not null
-
-        if (db) {
-            const Scope *b = db->findScopeByName("B");
-            ASSERT_EQUALS(true, b != nullptr);
-            if (b) {
-                CLASS_FUNC(B, b, true);
-            }
-        }
+                      "};");
+        ASSERT_EQUALS("", errout_str());
+        ASSERT(db != nullptr); // not null
+        const Scope *b = db->findScopeByName("B");
+        ASSERT(b != nullptr);
+        CLASS_FUNC(B, b, true);
     }
 
-#define FUNC_THROW(x) const Function *x = findFunctionByName(#x, &db->scopeList.front()); \
-                      ASSERT_EQUALS(true, x != nullptr);                                  \
-                      if (x) ASSERT_EQUALS(true, x->isThrow());
+#define FUNC_THROW(x) do { \
+        const Function *x = findFunctionByName(#x, &db->scopeList.front()); \
+        ASSERT_EQUALS(true, x != nullptr);                                  \
+        ASSERT_EQUALS(true, x->isThrow()); \
+} while (false)
 
     void throwFunction1() {
         GET_SYMBOL_DB("void func1() throw();\n"
                       "void func2() throw() { }\n"
                       "void func3() throw(int);\n"
-                      "void func4() throw(int) { }\n");
-        ASSERT_EQUALS("", errout.str());
-        ASSERT_EQUALS(true,  db != nullptr); // not null
+                      "void func4() throw(int) { }");
+        ASSERT_EQUALS("", errout_str());
+        ASSERT(db != nullptr); // not null
 
-        if (db) {
-            FUNC_THROW(func1);
-            FUNC_THROW(func2);
-            FUNC_THROW(func3);
-            FUNC_THROW(func4);
-        }
+        FUNC_THROW(func1);
+        FUNC_THROW(func2);
+        FUNC_THROW(func3);
+        FUNC_THROW(func4);
     }
 
-#define CLASS_FUNC_THROW(x, y) const Function *x = findFunctionByName(#x, y); \
-                               ASSERT_EQUALS(true, x != nullptr);             \
-                               if (x) ASSERT_EQUALS(true, x->isThrow());
+#define CLASS_FUNC_THROW(x, y) do { \
+        const Function *x = findFunctionByName(#x, y); \
+        ASSERT_EQUALS(true, x != nullptr);             \
+        ASSERT_EQUALS(true, x->isThrow()); \
+} while (false)
     void throwFunction2() {
         GET_SYMBOL_DB("struct Fred {\n"
                       "    void func1() throw();\n"
@@ -5759,54 +9029,64 @@ class TestSymbolDatabase: public TestFixture {
                       "    void func11() const throw() = 0;\n"
                       "    void func12() const throw(int) = 0;\n"
                       "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS(true,  db != nullptr); // not null
 
-        if (db) {
-            const Scope *fred = db->findScopeByName("Fred");
-            ASSERT_EQUALS(true, fred != nullptr);
-            if (fred) {
-                CLASS_FUNC_THROW(func1, fred);
-                CLASS_FUNC_THROW(func2, fred);
-                CLASS_FUNC_THROW(func3, fred);
-                CLASS_FUNC_THROW(func4, fred);
-                CLASS_FUNC_THROW(func5, fred);
-                CLASS_FUNC_THROW(func6, fred);
-                CLASS_FUNC_THROW(func7, fred);
-                CLASS_FUNC_THROW(func8, fred);
-                CLASS_FUNC_THROW(func9, fred);
-                CLASS_FUNC_THROW(func10, fred);
-                CLASS_FUNC_THROW(func11, fred);
-                CLASS_FUNC_THROW(func12, fred);
-            }
-        }
+        const Scope *fred = db->findScopeByName("Fred");
+        ASSERT_EQUALS(true, fred != nullptr);
+        CLASS_FUNC_THROW(func1, fred);
+        CLASS_FUNC_THROW(func2, fred);
+        CLASS_FUNC_THROW(func3, fred);
+        CLASS_FUNC_THROW(func4, fred);
+        CLASS_FUNC_THROW(func5, fred);
+        CLASS_FUNC_THROW(func6, fred);
+        CLASS_FUNC_THROW(func7, fred);
+        CLASS_FUNC_THROW(func8, fred);
+        CLASS_FUNC_THROW(func9, fred);
+        CLASS_FUNC_THROW(func10, fred);
+        CLASS_FUNC_THROW(func11, fred);
+        CLASS_FUNC_THROW(func12, fred);
+    }
+
+    void constAttributeFunction() {
+        GET_SYMBOL_DB("void func(void) __attribute__((const));");
+        ASSERT_EQUALS("", errout_str());
+        ASSERT_EQUALS(true, db != nullptr); // not null
+
+        const Function* func = findFunctionByName("func", &db->scopeList.front());
+        ASSERT_EQUALS(true, func != nullptr);
+        ASSERT_EQUALS(true, func->isAttributeConst());
+    }
+
+    void pureAttributeFunction() {
+        GET_SYMBOL_DB("void func(void) __attribute__((pure));");
+        ASSERT_EQUALS("", errout_str());
+        ASSERT_EQUALS(true, db != nullptr); // not null
+
+        const Function* func = findFunctionByName("func", &db->scopeList.front());
+        ASSERT_EQUALS(true, func != nullptr);
+        ASSERT_EQUALS(true, func->isAttributePure());
     }
 
     void nothrowAttributeFunction() {
         GET_SYMBOL_DB("void func() __attribute__((nothrow));\n"
-                      "void func() { }\n");
-        ASSERT_EQUALS("", errout.str());
+                      "void func() { }");
+        ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS(true,  db != nullptr); // not null
 
-        if (db) {
-            const Function *func = findFunctionByName("func", &db->scopeList.front());
-            ASSERT_EQUALS(true, func != nullptr);
-            if (func)
-                ASSERT_EQUALS(true, func->isAttributeNothrow());
-        }
+        const Function *func = findFunctionByName("func", &db->scopeList.front());
+        ASSERT_EQUALS(true, func != nullptr);
+        ASSERT_EQUALS(true, func->isAttributeNothrow());
     }
 
     void nothrowDeclspecFunction() {
-        GET_SYMBOL_DB("void __declspec(nothrow) func() { }\n");
-        ASSERT_EQUALS("", errout.str());
+        GET_SYMBOL_DB("void __declspec(nothrow) func() { }");
+        ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS(true,  db != nullptr); // not null
 
-        if (db) {
-            const Function *func = findFunctionByName("func", &db->scopeList.front());
-            ASSERT_EQUALS(true, func != nullptr);
-            if (func)
-                ASSERT_EQUALS(true, func->isAttributeNothrow());
-        }
+        const Function *func = findFunctionByName("func", &db->scopeList.front());
+        ASSERT_EQUALS(true, func != nullptr);
+        ASSERT_EQUALS(true, func->isAttributeNothrow());
     }
 
     void noreturnAttributeFunction() {
@@ -5814,98 +9094,132 @@ class TestSymbolDatabase: public TestFixture {
                       "void func1() { }\n"
                       "[[noreturn]] void func2();\n"
                       "[[noreturn]] void func3() { }\n"
-                      "template <class T> [[noreturn]] void func4() { }");
-        ASSERT_EQUALS("", errout.str());
+                      "template <class T> [[noreturn]] void func4() { }\n"
+                      "[[noreturn]] [[gnu::format(printf, 1, 2)]] void func5(const char*, ...);\n"
+                      "[[gnu::format(printf, 1, 2)]] [[noreturn]] void func6(const char*, ...);\n"
+                      );
+        ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS(true,  db != nullptr); // not null
 
-        if (db) {
-            const Function *func = findFunctionByName("func1", &db->scopeList.front());
-            ASSERT_EQUALS(true, func != nullptr);
-            if (func)
-                ASSERT_EQUALS(true, func->isAttributeNoreturn());
-            func = findFunctionByName("func2", &db->scopeList.front());
-            ASSERT_EQUALS(true, func != nullptr);
-            if (func)
-                ASSERT_EQUALS(true, func->isAttributeNoreturn());
-            func = findFunctionByName("func3", &db->scopeList.front());
-            ASSERT_EQUALS(true, func != nullptr);
-            if (func)
-                ASSERT_EQUALS(true, func->isAttributeNoreturn());
-            func = findFunctionByName("func4", &db->scopeList.front());
-            ASSERT_EQUALS(true, func != nullptr);
-            if (func)
-                ASSERT_EQUALS(true, func->isAttributeNoreturn());
-        }
+        const Function *func = findFunctionByName("func1", &db->scopeList.front());
+        ASSERT_EQUALS(true, func != nullptr);
+        ASSERT_EQUALS(true, func->isAttributeNoreturn());
+
+        func = findFunctionByName("func2", &db->scopeList.front());
+        ASSERT_EQUALS(true, func != nullptr);
+        ASSERT_EQUALS(true, func->isAttributeNoreturn());
+
+        func = findFunctionByName("func3", &db->scopeList.front());
+        ASSERT_EQUALS(true, func != nullptr);
+        ASSERT_EQUALS(true, func->isAttributeNoreturn());
+
+        func = findFunctionByName("func4", &db->scopeList.front());
+        ASSERT_EQUALS(true, func != nullptr);
+        ASSERT_EQUALS(true, func->isAttributeNoreturn());
+
+        func = findFunctionByName("func5", &db->scopeList.front());
+        ASSERT_EQUALS(true, func != nullptr);
+        ASSERT_EQUALS(true, func->isAttributeNoreturn());
+
+        func = findFunctionByName("func6", &db->scopeList.front());
+        ASSERT_EQUALS(true, func != nullptr);
+        ASSERT_EQUALS(true, func->isAttributeNoreturn());
+
+    }
+
+    void nodiscardAttributeFunction() {
+        GET_SYMBOL_DB("[[nodiscard]] int func1();\n"
+                      "int func1() { }\n"
+                      "[[nodiscard]] int func2();\n"
+                      "[[nodiscard]] int func3() { }\n"
+                      "template <class T> [[nodiscard]] int func4() { }"
+                      "std::pair<bool, char> [[nodiscard]] func5();\n"
+                      "[[nodiscard]] std::pair<bool, char> func6();\n"
+                      );
+        ASSERT_EQUALS("", errout_str());
+        ASSERT_EQUALS(true,  db != nullptr); // not null
+
+        const Function *func = findFunctionByName("func1", &db->scopeList.front());
+        ASSERT_EQUALS(true, func != nullptr);
+        ASSERT_EQUALS(true, func->isAttributeNodiscard());
+
+        func = findFunctionByName("func2", &db->scopeList.front());
+        ASSERT_EQUALS(true, func != nullptr);
+        ASSERT_EQUALS(true, func->isAttributeNodiscard());
+
+        func = findFunctionByName("func3", &db->scopeList.front());
+        ASSERT_EQUALS(true, func != nullptr);
+        ASSERT_EQUALS(true, func->isAttributeNodiscard());
+
+        func = findFunctionByName("func4", &db->scopeList.front());
+        ASSERT_EQUALS(true, func != nullptr);
+        ASSERT_EQUALS(true, func->isAttributeNodiscard());
+
+        func = findFunctionByName("func5", &db->scopeList.front());
+        ASSERT_EQUALS(true, func != nullptr);
+        ASSERT_EQUALS(true, func->isAttributeNodiscard());
+
+        func = findFunctionByName("func6", &db->scopeList.front());
+        ASSERT_EQUALS(true, func != nullptr);
+        ASSERT_EQUALS(true, func->isAttributeNodiscard());
     }
 
     void varTypesIntegral() {
         GET_SYMBOL_DB("void f() { bool b; char c; unsigned char uc; short s; unsigned short us; int i; unsigned u; unsigned int ui; long l; unsigned long ul; long long ll; }");
         const Variable *b = db->getVariableFromVarId(1);
         ASSERT(b != nullptr);
-        if (b) {
-            ASSERT_EQUALS("b", b->nameToken()->str());
-            ASSERT_EQUALS(false, b->isFloatingType());
-        }
+        ASSERT_EQUALS("b", b->nameToken()->str());
+        ASSERT_EQUALS(false, b->isFloatingType());
+
         const Variable *c = db->getVariableFromVarId(2);
         ASSERT(c != nullptr);
-        if (c) {
-            ASSERT_EQUALS("c", c->nameToken()->str());
-            ASSERT_EQUALS(false, c->isFloatingType());
-        }
+        ASSERT_EQUALS("c", c->nameToken()->str());
+        ASSERT_EQUALS(false, c->isFloatingType());
+
         const Variable *uc = db->getVariableFromVarId(3);
         ASSERT(uc != nullptr);
-        if (uc) {
-            ASSERT_EQUALS("uc", uc->nameToken()->str());
-            ASSERT_EQUALS(false, uc->isFloatingType());
-        }
+        ASSERT_EQUALS("uc", uc->nameToken()->str());
+        ASSERT_EQUALS(false, uc->isFloatingType());
+
         const Variable *s = db->getVariableFromVarId(4);
         ASSERT(s != nullptr);
-        if (s) {
-            ASSERT_EQUALS("s", s->nameToken()->str());
-            ASSERT_EQUALS(false, s->isFloatingType());
-        }
+        ASSERT_EQUALS("s", s->nameToken()->str());
+        ASSERT_EQUALS(false, s->isFloatingType());
+
         const Variable *us = db->getVariableFromVarId(5);
         ASSERT(us != nullptr);
-        if (us) {
-            ASSERT_EQUALS("us", us->nameToken()->str());
-            ASSERT_EQUALS(false, us->isFloatingType());
-        }
+        ASSERT_EQUALS("us", us->nameToken()->str());
+        ASSERT_EQUALS(false, us->isFloatingType());
+
         const Variable *i = db->getVariableFromVarId(6);
         ASSERT(i != nullptr);
-        if (i) {
-            ASSERT_EQUALS("i", i->nameToken()->str());
-            ASSERT_EQUALS(false, i->isFloatingType());
-        }
+        ASSERT_EQUALS("i", i->nameToken()->str());
+        ASSERT_EQUALS(false, i->isFloatingType());
+
         const Variable *u = db->getVariableFromVarId(7);
         ASSERT(u != nullptr);
-        if (u) {
-            ASSERT_EQUALS("u", u->nameToken()->str());
-            ASSERT_EQUALS(false, u->isFloatingType());
-        }
+        ASSERT_EQUALS("u", u->nameToken()->str());
+        ASSERT_EQUALS(false, u->isFloatingType());
+
         const Variable *ui = db->getVariableFromVarId(8);
         ASSERT(ui != nullptr);
-        if (ui) {
-            ASSERT_EQUALS("ui", ui->nameToken()->str());
-            ASSERT_EQUALS(false, ui->isFloatingType());
-        }
+        ASSERT_EQUALS("ui", ui->nameToken()->str());
+        ASSERT_EQUALS(false, ui->isFloatingType());
+
         const Variable *l = db->getVariableFromVarId(9);
         ASSERT(l != nullptr);
-        if (l) {
-            ASSERT_EQUALS("l", l->nameToken()->str());
-            ASSERT_EQUALS(false, l->isFloatingType());
-        }
+        ASSERT_EQUALS("l", l->nameToken()->str());
+        ASSERT_EQUALS(false, l->isFloatingType());
+
         const Variable *ul = db->getVariableFromVarId(10);
         ASSERT(ul != nullptr);
-        if (ul) {
-            ASSERT_EQUALS("ul", ul->nameToken()->str());
-            ASSERT_EQUALS(false, ul->isFloatingType());
-        }
+        ASSERT_EQUALS("ul", ul->nameToken()->str());
+        ASSERT_EQUALS(false, ul->isFloatingType());
+
         const Variable *ll = db->getVariableFromVarId(11);
         ASSERT(ll != nullptr);
-        if (ll) {
-            ASSERT_EQUALS("ll", ll->nameToken()->str());
-            ASSERT_EQUALS(false, ll->isFloatingType());
-        }
+        ASSERT_EQUALS("ll", ll->nameToken()->str());
+        ASSERT_EQUALS(false, ll->isFloatingType());
     }
 
     void varTypesFloating() {
@@ -5913,49 +9227,40 @@ class TestSymbolDatabase: public TestFixture {
             GET_SYMBOL_DB("void f() { float f; double d; long double ld; }");
             const Variable *f = db->getVariableFromVarId(1);
             ASSERT(f != nullptr);
-            if (f) {
-                ASSERT_EQUALS("f", f->nameToken()->str());
-                ASSERT_EQUALS(true, f->isFloatingType());
-            }
+            ASSERT_EQUALS("f", f->nameToken()->str());
+            ASSERT_EQUALS(true, f->isFloatingType());
+
             const Variable *d = db->getVariableFromVarId(2);
             ASSERT(d != nullptr);
-            if (d) {
-                ASSERT_EQUALS("d", d->nameToken()->str());
-                ASSERT_EQUALS(true, d->isFloatingType());
-            }
+            ASSERT_EQUALS("d", d->nameToken()->str());
+            ASSERT_EQUALS(true, d->isFloatingType());
+
             const Variable *ld = db->getVariableFromVarId(3);
             ASSERT(ld != nullptr);
-            if (ld) {
-                ASSERT_EQUALS("ld", ld->nameToken()->str());
-                ASSERT_EQUALS(true, ld->isFloatingType());
-            }
+            ASSERT_EQUALS("ld", ld->nameToken()->str());
+            ASSERT_EQUALS(true, ld->isFloatingType());
         }
         {
             GET_SYMBOL_DB("void f() { float * f; static const float * scf; }");
             const Variable *f = db->getVariableFromVarId(1);
             ASSERT(f != nullptr);
-            if (f) {
-                ASSERT_EQUALS("f", f->nameToken()->str());
-                ASSERT_EQUALS(true, f->isFloatingType());
-                ASSERT_EQUALS(true, f->isArrayOrPointer());
-            }
+            ASSERT_EQUALS("f", f->nameToken()->str());
+            ASSERT_EQUALS(true, f->isFloatingType());
+            ASSERT_EQUALS(true, f->isArrayOrPointer());
+
             const Variable *scf = db->getVariableFromVarId(2);
             ASSERT(scf != nullptr);
-            if (scf) {
-                ASSERT_EQUALS("scf", scf->nameToken()->str());
-                ASSERT_EQUALS(true, scf->isFloatingType());
-                ASSERT_EQUALS(true, scf->isArrayOrPointer());
-            }
+            ASSERT_EQUALS("scf", scf->nameToken()->str());
+            ASSERT_EQUALS(true, scf->isFloatingType());
+            ASSERT_EQUALS(true, scf->isArrayOrPointer());
         }
         {
             GET_SYMBOL_DB("void f() { float fa[42]; }");
             const Variable *fa = db->getVariableFromVarId(1);
             ASSERT(fa != nullptr);
-            if (fa) {
-                ASSERT_EQUALS("fa", fa->nameToken()->str());
-                ASSERT_EQUALS(true, fa->isFloatingType());
-                ASSERT_EQUALS(true, fa->isArrayOrPointer());
-            }
+            ASSERT_EQUALS("fa", fa->nameToken()->str());
+            ASSERT_EQUALS(true, fa->isFloatingType());
+            ASSERT_EQUALS(true, fa->isArrayOrPointer());
         }
     }
 
@@ -5963,16 +9268,13 @@ class TestSymbolDatabase: public TestFixture {
         GET_SYMBOL_DB("void f() { class A {} a; void *b;  }");
         const Variable *a = db->getVariableFromVarId(1);
         ASSERT(a != nullptr);
-        if (a) {
-            ASSERT_EQUALS("a", a->nameToken()->str());
-            ASSERT_EQUALS(false, a->isFloatingType());
-        }
+        ASSERT_EQUALS("a", a->nameToken()->str());
+        ASSERT_EQUALS(false, a->isFloatingType());
+
         const Variable *b = db->getVariableFromVarId(2);
         ASSERT(b != nullptr);
-        if (b) {
-            ASSERT_EQUALS("b", b->nameToken()->str());
-            ASSERT_EQUALS(false, b->isFloatingType());
-        }
+        ASSERT_EQUALS("b", b->nameToken()->str());
+        ASSERT_EQUALS(false, b->isFloatingType());
     }
 
     void functionPrototype() {
@@ -5983,7 +9285,7 @@ class TestSymbolDatabase: public TestFixture {
               "    int func4(int);\n"
               "    return func4(x);\n"
               "}\n", true);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void lambda() {
@@ -5998,14 +9300,12 @@ class TestSymbolDatabase: public TestFixture {
                       "}");
 
         ASSERT(db && db->scopeList.size() == 3);
-        if (db && db->scopeList.size() == 3) {
-            std::list<Scope>::const_iterator scope = db->scopeList.begin();
-            ASSERT_EQUALS(Scope::eGlobal, scope->type);
-            ++scope;
-            ASSERT_EQUALS(Scope::eFunction, scope->type);
-            ++scope;
-            ASSERT_EQUALS(Scope::eLambda, scope->type);
-        }
+        auto scope = db->scopeList.cbegin();
+        ASSERT_EQUALS_ENUM(ScopeType::eGlobal, scope->type);
+        ++scope;
+        ASSERT_EQUALS_ENUM(ScopeType::eFunction, scope->type);
+        ++scope;
+        ASSERT_EQUALS_ENUM(ScopeType::eLambda, scope->type);
     }
 
     void lambda2() {
@@ -6014,36 +9314,73 @@ class TestSymbolDatabase: public TestFixture {
                       "    auto lambda = [&]() -> bool\n"
                       "    {\n"
                       "        float x = 1.0f;\n"
-                      "    }\n"
+                      "    };\n"
                       "    lambda();\n"
                       "}");
 
         ASSERT(db && db->scopeList.size() == 3);
-        if (db && db->scopeList.size() == 3) {
-            std::list<Scope>::const_iterator scope = db->scopeList.begin();
-            ASSERT_EQUALS(Scope::eGlobal, scope->type);
-            ++scope;
-            ASSERT_EQUALS(Scope::eFunction, scope->type);
-            ++scope;
-            ASSERT_EQUALS(Scope::eLambda, scope->type);
-        }
+        auto scope = db->scopeList.cbegin();
+        ASSERT_EQUALS_ENUM(ScopeType::eGlobal, scope->type);
+        ++scope;
+        ASSERT_EQUALS_ENUM(ScopeType::eFunction, scope->type);
+        ++scope;
+        ASSERT_EQUALS_ENUM(ScopeType::eLambda, scope->type);
     }
 
-
     void lambda3() {
         GET_SYMBOL_DB("void func() {\n"
-                      "    auto f = []() mutable {}\n"
+                      "    auto f = []() mutable {};\n"
                       "}");
 
         ASSERT(db && db->scopeList.size() == 3);
-        if (db && db->scopeList.size() == 3) {
-            std::list<Scope>::const_iterator scope = db->scopeList.begin();
-            ASSERT_EQUALS(Scope::eGlobal, scope->type);
-            ++scope;
-            ASSERT_EQUALS(Scope::eFunction, scope->type);
-            ++scope;
-            ASSERT_EQUALS(Scope::eLambda, scope->type);
-        }
+        auto scope = db->scopeList.cbegin();
+        ASSERT_EQUALS_ENUM(ScopeType::eGlobal, scope->type);
+        ++scope;
+        ASSERT_EQUALS_ENUM(ScopeType::eFunction, scope->type);
+        ++scope;
+        ASSERT_EQUALS_ENUM(ScopeType::eLambda, scope->type);
+    }
+
+    void lambda4() { // #11719
+        GET_SYMBOL_DB("struct S { int* p; };\n"
+                      "auto g = []() {\n"
+                      "    S s;\n"
+                      "    s.p = new int;\n"
+                      "};\n");
+
+        ASSERT(db && db->scopeList.size() == 3);
+        auto scope = db->scopeList.cbegin();
+        ASSERT_EQUALS_ENUM(ScopeType::eGlobal, scope->type);
+        ++scope;
+        ASSERT_EQUALS_ENUM(ScopeType::eStruct, scope->type);
+        ++scope;
+        ASSERT_EQUALS_ENUM(ScopeType::eLambda, scope->type);
+        ASSERT_EQUALS(1, scope->varlist.size());
+        const Variable& s = scope->varlist.front();
+        ASSERT_EQUALS(s.name(), "s");
+        ASSERT(s.type());
+        --scope;
+        ASSERT_EQUALS(s.type()->classScope, &*scope);
+    }
+
+    void lambda5() { // #11275
+        GET_SYMBOL_DB("int* f() {\n"
+                      "    auto g = []<typename T>() {\n"
+                      "        return true;\n"
+                      "    };\n"
+                      "    return nullptr;\n"
+                      "}\n");
+
+        ASSERT(db && db->scopeList.size() == 3);
+        auto scope = db->scopeList.cbegin();
+        ASSERT_EQUALS_ENUM(ScopeType::eGlobal, scope->type);
+        ++scope;
+        ASSERT_EQUALS_ENUM(ScopeType::eFunction, scope->type);
+        ++scope;
+        ASSERT_EQUALS_ENUM(ScopeType::eLambda, scope->type);
+        const Token* ret = Token::findsimplematch(tokenizer.tokens(), "return true");
+        ASSERT(ret && ret->scope());
+        ASSERT_EQUALS_ENUM(ret->scope()->type, ScopeType::eLambda);
     }
 
     // #6298 "stack overflow in Scope::findFunctionInBase (endless recursion)"
@@ -6063,53 +9400,87 @@ class TestSymbolDatabase: public TestFixture {
     }
 
     void executableScopeWithUnknownFunction() {
-        GET_SYMBOL_DB("class Fred {\n"
-                      "    void foo(const std::string & a = "");\n"
-                      "};\n"
-                      "Fred::foo(const std::string & b) { }\n");
+        {
+            GET_SYMBOL_DB("class Fred {\n"
+                          "    void foo(const std::string & a = \"\");\n"
+                          "};\n"
+                          "Fred::foo(const std::string & b) { }");
 
-        ASSERT(db && db->scopeList.size() == 3);
-        if (db && db->scopeList.size() == 3) {
-            std::list<Scope>::const_iterator scope = db->scopeList.begin();
-            ASSERT_EQUALS(Scope::eGlobal, scope->type);
+            ASSERT(db && db->scopeList.size() == 3);
+            auto scope = db->scopeList.cbegin();
+            ASSERT_EQUALS_ENUM(ScopeType::eGlobal, scope->type);
             ++scope;
-            ASSERT_EQUALS(Scope::eClass, scope->type);
-            const Scope * class_scope = &*scope;
+            ASSERT_EQUALS_ENUM(ScopeType::eClass, scope->type);
+            const Scope* class_scope = &*scope;
             ++scope;
             ASSERT(class_scope->functionList.size() == 1);
-            if (class_scope->functionList.size() == 1) {
-                ASSERT(class_scope->functionList.begin()->hasBody());
-                ASSERT(class_scope->functionList.begin()->functionScope == &*scope);
-            }
+            ASSERT(class_scope->functionList.cbegin()->hasBody());
+            ASSERT(class_scope->functionList.cbegin()->functionScope == &*scope);
         }
-    }
+        {
+            GET_SYMBOL_DB("bool f(bool (*g)(int));\n"
+                          "bool f(bool (*g)(int)) { return g(0); }\n");
 
-    std::string typeOf(const char code[], const char pattern[], const char filename[] = "test.cpp", const Settings *settings = nullptr) {
-        Tokenizer tokenizer(settings ? settings : &settings2, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, filename);
+            ASSERT(db && db->scopeList.size() == 2);
+            auto scope = db->scopeList.cbegin();
+            ASSERT_EQUALS_ENUM(ScopeType::eGlobal, scope->type);
+            ASSERT(scope->functionList.size() == 1);
+            ++scope;
+            ASSERT_EQUALS_ENUM(ScopeType::eFunction, scope->type);
+        }
+    }
+#define typeOf(...) typeOf_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    std::string typeOf_(const char* file, int line, const char (&code)[size], const char pattern[], bool cpp = true, const Settings *settings = nullptr) {
+        SimpleTokenizer tokenizer(settings ? *settings : settings2, *this, cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
         const Token* tok;
         for (tok = tokenizer.list.back(); tok; tok = tok->previous())
-            if (Token::simpleMatch(tok, pattern))
+            if (Token::simpleMatch(tok, pattern, strlen(pattern)))
                 break;
         return tok->valueType() ? tok->valueType()->str() : std::string();
     }
 
-    void valuetype() {
+    void valueType1() {
         // stringification
         ASSERT_EQUALS("", ValueType().str());
 
-        Settings s;
-        s.int_bit = 16;
-        s.long_bit = 32;
-        s.long_long_bit = 64;
+        const auto s = dinit(Settings,
+                             $.platform.int_bit = 16,
+                                 $.platform.long_bit = 32,
+                                 $.platform.long_long_bit = 64);
+
+        const auto sSameSize = dinit(Settings,
+                                     $.platform.int_bit = 32,
+                                         $.platform.long_bit = 64,
+                                         $.platform.long_long_bit = 64);
 
         // numbers
-        ASSERT_EQUALS("signed int", typeOf("1;", "1", "test.c", &s));
-        ASSERT_EQUALS("signed int", typeOf("32767;", "32767", "test.c", &s));
-        ASSERT_EQUALS("signed long", typeOf("32768;", "32768", "test.c", &s));
-        ASSERT_EQUALS("unsigned int", typeOf("32768U;", "32768U", "test.c", &s));
-        ASSERT_EQUALS("signed long long", typeOf("2147483648;", "2147483648", "test.c", &s));
+        ASSERT_EQUALS("signed int", typeOf("1;", "1", false, &s));
+        ASSERT_EQUALS("signed int", typeOf("(-1);", "-1", false, &s));
+        ASSERT_EQUALS("signed int", typeOf("32767;", "32767", false, &s));
+        ASSERT_EQUALS("signed int", typeOf("(-32767);", "-32767", false, &s));
+        ASSERT_EQUALS("signed long", typeOf("32768;", "32768", false, &s));
+        ASSERT_EQUALS("signed long", typeOf("(-32768);", "-32768", false, &s));
+        ASSERT_EQUALS("signed long", typeOf("32768l;", "32768l", false, &s));
+        ASSERT_EQUALS("unsigned int", typeOf("32768U;", "32768U", false, &s));
+        ASSERT_EQUALS("signed long long", typeOf("2147483648;", "2147483648", false, &s));
+        ASSERT_EQUALS("unsigned long", typeOf("2147483648u;", "2147483648u", false, &s));
+        ASSERT_EQUALS("signed long long", typeOf("2147483648L;", "2147483648L", false, &s));
+        ASSERT_EQUALS("unsigned long long", typeOf("18446744069414584320;", "18446744069414584320", false, &s));
+        ASSERT_EQUALS("signed int", typeOf("0xFF;", "0xFF", false, &s));
+        ASSERT_EQUALS("unsigned int", typeOf("0xFFU;", "0xFFU", false, &s));
+        ASSERT_EQUALS("unsigned int", typeOf("0xFFFF;", "0xFFFF", false, &s));
+        ASSERT_EQUALS("signed long", typeOf("0xFFFFFF;", "0xFFFFFF", false, &s));
+        ASSERT_EQUALS("unsigned long", typeOf("0xFFFFFFU;", "0xFFFFFFU", false, &s));
+        ASSERT_EQUALS("unsigned long", typeOf("0xFFFFFFFF;", "0xFFFFFFFF", false, &s));
+        ASSERT_EQUALS("signed long long", typeOf("0xFFFFFFFFFFFF;", "0xFFFFFFFFFFFF", false, &s));
+        ASSERT_EQUALS("unsigned long long", typeOf("0xFFFFFFFFFFFFU;", "0xFFFFFFFFFFFFU", false, &s));
+        ASSERT_EQUALS("unsigned long long", typeOf("0xFFFFFFFF00000000;", "0xFFFFFFFF00000000", false, &s));
+
+        ASSERT_EQUALS("signed long", typeOf("2147483648;", "2147483648", false, &sSameSize));
+        ASSERT_EQUALS("unsigned long", typeOf("0xc000000000000000;", "0xc000000000000000", false, &sSameSize));
+
         ASSERT_EQUALS("unsigned int", typeOf("1U;", "1U"));
         ASSERT_EQUALS("signed long", typeOf("1L;", "1L"));
         ASSERT_EQUALS("unsigned long", typeOf("1UL;", "1UL"));
@@ -6124,11 +9495,26 @@ class TestSymbolDatabase: public TestFixture {
         ASSERT_EQUALS("signed long long", typeOf("1ll;", "1ll"));
         ASSERT_EQUALS("unsigned long long", typeOf("1ull;", "1ull"));
         ASSERT_EQUALS("unsigned long long", typeOf("1llu;", "1llu"));
+        ASSERT_EQUALS("signed int", typeOf("01;", "01"));
+        ASSERT_EQUALS("unsigned int", typeOf("01U;", "01U"));
+        ASSERT_EQUALS("signed long", typeOf("01L;", "01L"));
+        ASSERT_EQUALS("unsigned long", typeOf("01UL;", "01UL"));
+        ASSERT_EQUALS("signed long long", typeOf("01LL;", "01LL"));
+        ASSERT_EQUALS("unsigned long long", typeOf("01ULL;", "01ULL"));
+        ASSERT_EQUALS("signed int", typeOf("0B1;", "0B1"));
+        ASSERT_EQUALS("signed int", typeOf("0b1;", "0b1"));
+        ASSERT_EQUALS("unsigned int", typeOf("0b1U;", "0b1U"));
+        ASSERT_EQUALS("signed long", typeOf("0b1L;", "0b1L"));
+        ASSERT_EQUALS("unsigned long", typeOf("0b1UL;", "0b1UL"));
+        ASSERT_EQUALS("signed long long", typeOf("0b1LL;", "0b1LL"));
+        ASSERT_EQUALS("unsigned long long", typeOf("0b1ULL;", "0b1ULL"));
         ASSERT_EQUALS("float", typeOf("1.0F;", "1.0F"));
         ASSERT_EQUALS("float", typeOf("1.0f;", "1.0f"));
         ASSERT_EQUALS("double", typeOf("1.0;", "1.0"));
         ASSERT_EQUALS("double", typeOf("1E3;", "1E3"));
+        ASSERT_EQUALS("double", typeOf("0x1.2p3;", "0x1.2p3"));
         ASSERT_EQUALS("long double", typeOf("1.23L;", "1.23L"));
+        ASSERT_EQUALS("long double", typeOf("1.23l;", "1.23l"));
 
         // Constant calculations
         ASSERT_EQUALS("signed int", typeOf("1 + 2;", "+"));
@@ -6149,6 +9535,15 @@ class TestSymbolDatabase: public TestFixture {
         ASSERT_EQUALS("signed long", typeOf("(signed long)1 + (unsigned int)2;", "+"));
         ASSERT_EQUALS("unsigned long", typeOf("(unsigned long)1 + (signed int)2;", "+"));
 
+        // char
+        ASSERT_EQUALS("char", typeOf("'a';", "'a'", true));
+        ASSERT_EQUALS("char", typeOf("'\\\'';", "'\\\''", true));
+        ASSERT_EQUALS("signed int", typeOf("'a';", "'a'", false));
+        ASSERT_EQUALS("wchar_t", typeOf("L'a';", "L'a'", true));
+        ASSERT_EQUALS("wchar_t", typeOf("L'a';", "L'a'", false));
+        ASSERT_EQUALS("signed int", typeOf("'aaa';", "'aaa'", true));
+        ASSERT_EQUALS("signed int", typeOf("'aaa';", "'aaa'", false));
+
         // char *
         ASSERT_EQUALS("const char *", typeOf("\"hello\" + 1;", "+"));
         ASSERT_EQUALS("const char",  typeOf("\"hello\"[1];", "["));
@@ -6180,6 +9575,10 @@ class TestSymbolDatabase: public TestFixture {
         ASSERT_EQUALS("AB *", typeOf("struct AB {int a; int b;}; struct AB ab; x=&ab;", "&"));
         ASSERT_EQUALS("A::BC *", typeOf("namespace A { struct BC { int b; int c; }; }; struct A::BC abc; x=&abc;", "&"));
         ASSERT_EQUALS("A::BC *", typeOf("namespace A { struct BC { int b; int c; }; }; struct A::BC *abc; x=abc+1;", "+"));
+        ASSERT_EQUALS("signed int", typeOf("auto a(int& x, int& y) { return x + y; }", "+"));
+        ASSERT_EQUALS("signed int", typeOf("auto a(int& x) { return x << 1; }", "<<"));
+        ASSERT_EQUALS("signed int", typeOf("void a(int& x, int& y) { x = y; }", "=")); //Debatably this should be a signed int & but we'll stick with the current behavior for now
+        ASSERT_EQUALS("signed int", typeOf("auto a(int* y) { return *y; }", "*")); //Debatably this should be a signed int & but we'll stick with the current behavior for now
 
         // Unary arithmetic/bit operators
         ASSERT_EQUALS("signed int", typeOf("int x; a = -x;", "-"));
@@ -6204,10 +9603,11 @@ class TestSymbolDatabase: public TestFixture {
         // shift => result has same type as lhs
         ASSERT_EQUALS("signed int", typeOf("int x; a = x << 1U;", "<<"));
         ASSERT_EQUALS("signed int", typeOf("int x; a = x >> 1U;", ">>"));
-        ASSERT_EQUALS("",           typeOf("a = 12 >> x;", ">>", "test.cpp")); // >> might be overloaded
-        ASSERT_EQUALS("signed int", typeOf("a = 12 >> x;", ">>", "test.c"));
-        ASSERT_EQUALS("",           typeOf("a = 12 << x;", "<<", "test.cpp")); // << might be overloaded
-        ASSERT_EQUALS("signed int", typeOf("a = 12 << x;", "<<", "test.c"));
+        ASSERT_EQUALS("",           typeOf("a = 12 >> x;", ">>", true)); // >> might be overloaded
+        ASSERT_EQUALS("signed int", typeOf("a = 12 >> x;", ">>", false));
+        ASSERT_EQUALS("",           typeOf("a = 12 << x;", "<<", true)); // << might be overloaded
+        ASSERT_EQUALS("signed int", typeOf("a = 12 << x;", "<<", false));
+        ASSERT_EQUALS("signed int", typeOf("a = true << 1U;", "<<"));
 
         // assignment => result has same type as lhs
         ASSERT_EQUALS("unsigned short", typeOf("unsigned short x; x = 3;", "="));
@@ -6216,8 +9616,10 @@ class TestSymbolDatabase: public TestFixture {
         ASSERT_EQUALS("void * *", typeOf("void * x[10]; a = x + 0;", "+"));
         ASSERT_EQUALS("signed int *", typeOf("int x[10]; a = x + 1;", "+"));
         ASSERT_EQUALS("signed int",  typeOf("int x[10]; a = x[0] + 1;", "+"));
-        ASSERT_EQUALS("",            typeOf("a = x[\"hello\"];", "[", "test.cpp"));
-        ASSERT_EQUALS("const char",  typeOf("a = x[\"hello\"];", "[", "test.c"));
+        ASSERT_EQUALS("",            typeOf("a = x[\"hello\"];", "[", true));
+        ASSERT_EQUALS("const char",  typeOf("a = x[\"hello\"];", "[", false));
+        ASSERT_EQUALS("signed int *", typeOf("int x[10]; a = &x;", "&"));
+        ASSERT_EQUALS("signed int *", typeOf("int x[10]; a = &x[1];", "&"));
 
         // cast..
         ASSERT_EQUALS("void *", typeOf("a = (void *)0;", "("));
@@ -6247,13 +9649,20 @@ class TestSymbolDatabase: public TestFixture {
         ASSERT_EQUALS("signed int", typeOf("auto a(int) -> int; a(5);", "( 5"));
         ASSERT_EQUALS("unsigned long", typeOf("sizeof(x);", "("));
         ASSERT_EQUALS("signed int", typeOf("int (*a)(int); a(5);", "( 5"));
+        ASSERT_EQUALS("s", typeOf("struct s { s foo(); s(int, int); }; s s::foo() { return s(1, 2); } ", "( 1 , 2 )"));
+        // Some standard template functions.. TODO library configuration
+        ASSERT_EQUALS("signed int &&", typeOf("std::move(5);", "( 5 )"));
+        ASSERT_EQUALS("signed int", typeOf("using F = int(int*); F* f; f(ptr);", "( ptr")); // #9792
+
+        // calling constructor..
+        ASSERT_EQUALS("s", typeOf("struct s { s(int); }; s::s(int){} void foo() { throw s(1); } ", "( 1 )")); // #13100
 
         // struct member..
         ASSERT_EQUALS("signed int", typeOf("struct AB { int a; int b; } ab; x = ab.a;", "."));
         ASSERT_EQUALS("signed int", typeOf("struct AB { int a; int b; } *ab; x = ab[1].a;", "."));
 
         // Overloaded operators
-        ASSERT_EQUALS("Fred", typeOf("class Fred { Fred& operator<(int); }; void f() { Fred fred; x=fred<123; }", "<"));
+        ASSERT_EQUALS("Fred &", typeOf("class Fred { Fred& operator<(int); }; void f() { Fred fred; x=fred<123; }", "<"));
 
         // Static members
         ASSERT_EQUALS("signed int", typeOf("struct AB { static int a; }; x = AB::a;", "::"));
@@ -6274,69 +9683,156 @@ class TestSymbolDatabase: public TestFixture {
         ASSERT_EQUALS("signed long long", typeOf("enum E : long long { }; void foo() { E e[3]; bar(e[0]); }", "[ 0"));
         ASSERT_EQUALS("unsigned long long", typeOf("enum E : unsigned long long { }; void foo() { E e[3]; bar(e[0]); }", "[ 0"));
 
+#define CHECK_LIBRARY_FUNCTION_RETURN_TYPE(type) do { \
+        const char xmldata[] = "<?xml version=\"1.0\"?>\n" \
+                               "<def>\n" \
+                               "<function name=\"g\">\n" \
+                               "<returnValue type=\"" #type "\"/>\n" \
+                               "</function>\n" \
+                               "</def>";              \
+        const Settings sF = settingsBuilder().libraryxml(xmldata).build(); \
+        ASSERT_EQUALS(#type, typeOf("void f() { auto x = g(); }", "x", true, &sF)); \
+} while (false)
+        // *INDENT-OFF*
+        CHECK_LIBRARY_FUNCTION_RETURN_TYPE(bool);
+        CHECK_LIBRARY_FUNCTION_RETURN_TYPE(signed char);
+        CHECK_LIBRARY_FUNCTION_RETURN_TYPE(unsigned char);
+        CHECK_LIBRARY_FUNCTION_RETURN_TYPE(signed short);
+        CHECK_LIBRARY_FUNCTION_RETURN_TYPE(unsigned short);
+        CHECK_LIBRARY_FUNCTION_RETURN_TYPE(signed int);
+        CHECK_LIBRARY_FUNCTION_RETURN_TYPE(unsigned int);
+        CHECK_LIBRARY_FUNCTION_RETURN_TYPE(signed long);
+        CHECK_LIBRARY_FUNCTION_RETURN_TYPE(unsigned long);
+        CHECK_LIBRARY_FUNCTION_RETURN_TYPE(signed long long);
+        CHECK_LIBRARY_FUNCTION_RETURN_TYPE(unsigned long long);
+        CHECK_LIBRARY_FUNCTION_RETURN_TYPE(void *);
+        CHECK_LIBRARY_FUNCTION_RETURN_TYPE(void * *);
+        CHECK_LIBRARY_FUNCTION_RETURN_TYPE(const void *);
+        // *INDENT-ON*
+#undef CHECK_LIBRARY_FUNCTION_RETURN_TYPE
+
         // Library types
+        {
+            // Char types
+            constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                       "<def>\n"
+                                       "  <podtype name=\"char8_t\" sign=\"u\" size=\"1\"/>\n"
+                                       "  <podtype name=\"char16_t\" sign=\"u\" size=\"2\"/>\n"
+                                       "  <podtype name=\"char32_t\" sign=\"u\" size=\"4\"/>\n"
+                                       "</def>";
+            /*const*/ Settings settings = settingsBuilder().libraryxml(xmldata).build();
+            settings.platform.sizeof_short = 2;
+            settings.platform.sizeof_int = 4;
+
+            ASSERT_EQUALS("unsigned char", typeOf("u8'a';", "u8'a'", true, &settings));
+            ASSERT_EQUALS("unsigned short", typeOf("u'a';", "u'a'", true, &settings));
+            ASSERT_EQUALS("unsigned int", typeOf("U'a';", "U'a'", true, &settings));
+            ASSERT_EQUALS("const unsigned char *", typeOf("u8\"a\";", "u8\"a\"", true, &settings));
+            ASSERT_EQUALS("const unsigned short *", typeOf("u\"a\";", "u\"a\"", true, &settings));
+            ASSERT_EQUALS("const unsigned int *", typeOf("U\"a\";", "U\"a\"", true, &settings));
+        }
         {
             // PodType
-            Settings settingsWin64;
-            settingsWin64.platformType = Settings::Win64;
-            const Library::PodType u32 = { 4, 'u' };
-            const Library::PodType podtype2 = { 0, 'u', Library::PodType::INT };
-            settingsWin64.library.mPodTypes["u32"] = u32;
-            settingsWin64.library.mPodTypes["xyz::x"] = u32;
-            settingsWin64.library.mPodTypes["podtype2"] = podtype2;
+            constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                       "<def>\n"
+                                       "  <podtype name=\"u32\" sign=\"u\" size=\"4\"/>\n"
+                                       "  <podtype name=\"xyz::x\" sign=\"u\" size=\"4\"/>\n"
+                                       "  <podtype name=\"podtype2\" sign=\"u\" size=\"0\" stdtype=\"int\"/>\n"
+                                       "</def>";
+            const Settings settingsWin64 = settingsBuilder().platform(Platform::Type::Win64).libraryxml(xmldata).build();
             ValueType vt;
-            ASSERT_EQUALS(true, vt.fromLibraryType("u32", &settingsWin64));
-            ASSERT_EQUALS(true, vt.fromLibraryType("xyz::x", &settingsWin64));
+            ASSERT_EQUALS(true, vt.fromLibraryType("u32", settingsWin64));
+            ASSERT_EQUALS(true, vt.fromLibraryType("xyz::x", settingsWin64));
             ASSERT_EQUALS(ValueType::Type::INT, vt.type);
             ValueType vt2;
-            ASSERT_EQUALS(true, vt2.fromLibraryType("podtype2", &settingsWin64));
+            ASSERT_EQUALS(true, vt2.fromLibraryType("podtype2", settingsWin64));
             ASSERT_EQUALS(ValueType::Type::INT, vt2.type);
-            ASSERT_EQUALS("unsigned int *", typeOf(";void *data = new u32[10];", "new", "test.cpp", &settingsWin64));
-            ASSERT_EQUALS("unsigned int *", typeOf(";void *data = new xyz::x[10];", "new", "test.cpp", &settingsWin64));
-            ASSERT_EQUALS("unsigned int", typeOf("; x = (xyz::x)12;", "(", "test.cpp", &settingsWin64));
+            ASSERT_EQUALS("unsigned int *", typeOf(";void *data = new u32[10];", "new", true, &settingsWin64));
+            ASSERT_EQUALS("unsigned int *", typeOf(";void *data = new xyz::x[10];", "new", true, &settingsWin64));
+            ASSERT_EQUALS("unsigned int", typeOf("; x = (xyz::x)12;", "(", true, &settingsWin64));
+            ASSERT_EQUALS("unsigned int", typeOf(";u32(12);", "(", true, &settingsWin64));
+            ASSERT_EQUALS("unsigned int", typeOf("x = u32(y[i]);", "(", true, &settingsWin64));
         }
         {
             // PlatformType
-            Settings settingsUnix32;
-            settingsUnix32.platformType = Settings::Unix32;
-            Library::PlatformType s32;
-            s32.mType = "int";
-            settingsUnix32.library.mPlatforms[settingsUnix32.platformString()].mPlatformTypes["s32"] = s32;
+            constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                       "<def>\n"
+                                       "  <platformtype name=\"s32\" value=\"int\">\n"
+                                       "    <platform type=\"unix32\"/>\n"
+                                       "  </platformtype>\n"
+                                       "</def>";
+            const Settings settingsUnix32 = settingsBuilder().platform(Platform::Type::Unix32).libraryxml(xmldata).build();
             ValueType vt;
-            ASSERT_EQUALS(true, vt.fromLibraryType("s32", &settingsUnix32));
+            ASSERT_EQUALS(true, vt.fromLibraryType("s32", settingsUnix32));
             ASSERT_EQUALS(ValueType::Type::INT, vt.type);
         }
         {
             // PlatformType - wchar_t
-            Settings settingsWin64;
-            settingsWin64.platformType = Settings::Win64;
-            Library::PlatformType lpctstr;
-            lpctstr.mType = "wchar_t";
-            settingsWin64.library.mPlatforms[settingsWin64.platformString()].mPlatformTypes["LPCTSTR"] = lpctstr;
+            constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                       "<def>\n"
+                                       "  <platformtype name=\"LPCTSTR\" value=\"wchar_t\">\n"
+                                       "    <platform type=\"win64\"/>\n"
+                                       "  </platformtype>\n"
+                                       "</def>";
+            const Settings settingsWin64 = settingsBuilder().platform(Platform::Type::Win64).libraryxml(xmldata).build();
             ValueType vt;
-            ASSERT_EQUALS(true, vt.fromLibraryType("LPCTSTR", &settingsWin64));
+            ASSERT_EQUALS(true, vt.fromLibraryType("LPCTSTR", settingsWin64));
             ASSERT_EQUALS(ValueType::Type::WCHAR_T, vt.type);
         }
         {
             // Container
-            Settings sC;
-            Library::Container c;
-            c.startPattern = "C";
-            c.startPattern2 = "C !!::";
-            sC.library.containers["C"] = c;
-            ASSERT_EQUALS("container(C) *", typeOf("C*c=new C;","new","test.cpp",&sC));
-            ASSERT_EQUALS("container(C) *", typeOf("x=(C*)c;","(","test.cpp",&sC));
+            constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                       "<def>\n"
+                                       "  <container id=\"C\" startPattern=\"C\"/>\n"
+                                       "</def>";
+            const Settings sC = settingsBuilder().libraryxml(xmldata).build();
+            ASSERT_EQUALS("container(C) *", typeOf("C*c=new C;","new",true,&sC));
+            ASSERT_EQUALS("container(C) *", typeOf("x=(C*)c;","(",true,&sC));
+            ASSERT_EQUALS("container(C)", typeOf("C c = C();","(",true,&sC));
         }
         {
             // Container (vector)
-            Settings set;
-            Library::Container vector;
-            vector.startPattern = "Vector";
-            vector.startPattern2 = "Vector !!::";
-            vector.type_templateArgNo = 0;
-            vector.arrayLike_indexOp = true;
-            set.library.containers["Vector"] = vector;
-            ASSERT_EQUALS("signed int", typeOf("Vector<int> v; v[0]=3;", "[", "test.cpp", &set));
+            constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                       "<def>\n"
+                                       "  <container id=\"Vector\" startPattern=\"Vector &lt;\">\n"
+                                       "    <type templateParameter=\"0\"/>\n"
+                                       "    <access indexOperator=\"array-like\">\n"
+                                       "      <function name=\"front\" yields=\"item\"/>\n"
+                                       "      <function name=\"data\" yields=\"buffer\"/>\n"
+                                       "      <function name=\"begin\" yields=\"start-iterator\"/>\n"
+                                       "    </access>\n"
+                                       "  </container>\n"
+                                       "  <container id=\"test::string\" startPattern=\"test :: string\">\n"
+                                       "    <type string=\"std-like\"/>\n"
+                                       "    <access indexOperator=\"array-like\"/>\n"
+                                       "  </container>\n"
+                                       "</def>";
+            const Settings set = settingsBuilder().libraryxml(xmldata).build();
+            ASSERT_EQUALS("signed int", typeOf("Vector<int> v; v[0]=3;", "[", true, &set));
+            ASSERT_EQUALS("container(test :: string)", typeOf("{return test::string();}", "(", true, &set));
+            ASSERT_EQUALS(
+                "container(test :: string)",
+                typeOf("void foo(Vector<test::string> v) { for (auto s: v) { x=s+s; } }", "s", true, &set));
+            ASSERT_EQUALS(
+                "container(test :: string)",
+                typeOf("void foo(Vector<test::string> v) { for (auto s: v) { x=s+s; } }", "+", true, &set));
+            ASSERT_EQUALS("container(test :: string) &",
+                          typeOf("Vector<test::string> v; x = v.front();", "(", true, &set));
+            ASSERT_EQUALS("container(test :: string) *",
+                          typeOf("Vector<test::string> v; x = v.data();", "(", true, &set));
+            ASSERT_EQUALS("signed int &", typeOf("Vector<int> v; x = v.front();", "(", true, &set));
+            ASSERT_EQUALS("signed int *", typeOf("Vector<int> v; x = v.data();", "(", true, &set));
+            ASSERT_EQUALS("signed int * *", typeOf("Vector<int*> v; x = v.data();", "(", true, &set));
+            ASSERT_EQUALS("iterator(Vector <)", typeOf("Vector<int> v; x = v.begin();", "(", true, &set));
+            ASSERT_EQUALS("signed int &", typeOf("Vector<int> v; x = *v.begin();", "*", true, &set));
+            ASSERT_EQUALS("container(test :: string)",
+                          typeOf("void foo(){test::string s; return \"x\"+s;}", "+", true, &set));
+            ASSERT_EQUALS("container(test :: string)",
+                          typeOf("void foo(){test::string s; return s+\"x\";}", "+", true, &set));
+            ASSERT_EQUALS("container(test :: string)",
+                          typeOf("void foo(){test::string s; return 'x'+s;}", "+", true, &set));
+            ASSERT_EQUALS("container(test :: string)",
+                          typeOf("void foo(){test::string s; return s+'x';}", "+", true, &set));
         }
 
         // new
@@ -6345,16 +9841,326 @@ class TestSymbolDatabase: public TestFixture {
         // auto variables
         ASSERT_EQUALS("signed int", typeOf("; auto x = 3;", "x"));
         ASSERT_EQUALS("signed int *", typeOf("; auto *p = (int *)0;", "p"));
+        ASSERT_EQUALS("const signed int *", typeOf("; auto *p = (const int *)0;", "p"));
+        ASSERT_EQUALS("const signed int *", typeOf("; auto *p = (constexpr int *)0;", "p"));
+        ASSERT_EQUALS("const signed int *", typeOf("; const auto *p = (int *)0;", "p"));
+        ASSERT_EQUALS("const signed int *", typeOf("; constexpr auto *p = (int *)0;", "p"));
+        ASSERT_EQUALS("const signed int *", typeOf("; const auto *p = (const int *)0;", "p"));
+        ASSERT_EQUALS("const signed int *", typeOf("; constexpr auto *p = (constexpr int *)0;", "p"));
+        ASSERT_EQUALS("const signed int *", typeOf("; const constexpr auto *p = (int *)0;", "p"));
         ASSERT_EQUALS("signed int *", typeOf("; auto data = new int[100];", "data"));
         ASSERT_EQUALS("signed int", typeOf("; auto data = new X::Y; int x=1000; x=x/5;", "/")); // #7970
         ASSERT_EQUALS("signed int *", typeOf("; auto data = new (nothrow) int[100];", "data"));
         ASSERT_EQUALS("signed int *", typeOf("; auto data = new (std::nothrow) int[100];", "data"));
-        ASSERT_EQUALS("const signed short", typeOf("short values[10]; void f() { for (const auto *x : values); }", "x"));
+        ASSERT_EQUALS("const signed short", typeOf("short values[10]; void f() { for (const auto x : values); }", "x"));
+        ASSERT_EQUALS("const signed short &", typeOf("short values[10]; void f() { for (const auto& x : values); }", "x"));
+        ASSERT_EQUALS("signed short &", typeOf("short values[10]; void f() { for (auto& x : values); }", "x"));
+        ASSERT_EQUALS("signed int * &", typeOf("int* values[10]; void f() { for (auto& p : values); }", "p"));
+        ASSERT_EQUALS("signed int * const &", typeOf("int* values[10]; void f() { for (const auto& p : values); }", "p"));
+        ASSERT_EQUALS("const signed int *", typeOf("int* values[10]; void f() { for (const auto* p : values); }", "p"));
         ASSERT_EQUALS("const signed int", typeOf("; const auto x = 3;", "x"));
+        ASSERT_EQUALS("const signed int", typeOf("; constexpr auto x = 3;", "x"));
+        ASSERT_EQUALS("const signed int", typeOf("; const constexpr auto x = 3;", "x"));
+        ASSERT_EQUALS("void * const", typeOf("typedef void* HWND; const HWND x = 0;", "x"));
 
         // Variable declaration
         ASSERT_EQUALS("char *", typeOf("; char abc[] = \"abc\";", "["));
         ASSERT_EQUALS("", typeOf("; int x[10] = { [3]=1 };", "[ 3 ]"));
+
+        // std::make_shared
+        {
+            constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                       "<def>\n"
+                                       "  <smart-pointer class-name=\"std::shared_ptr\"/>\n"
+                                       "</def>";
+            const Settings set = settingsBuilder().libraryxml(xmldata).build();
+            ASSERT_EQUALS("smart-pointer(std::shared_ptr)",
+                          typeOf("class C {}; x = std::make_shared<C>();", "(", true, &set));
+        }
+
+        // return
+        {
+            // Container
+            constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                       "<def>\n"
+                                       "  <container id=\"C\" startPattern=\"C\"/>\n"
+                                       "</def>";
+            const Settings sC = settingsBuilder().libraryxml(xmldata).build();
+            ASSERT_EQUALS("container(C)", typeOf("C f(char *p) { char data[10]; return data; }", "return", true, &sC));
+        }
+        // Smart pointer
+        {
+            constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                       "<def>\n"
+                                       "  <smart-pointer class-name=\"MyPtr\"/>\n"
+                                       "</def>";
+            const Settings set = settingsBuilder().libraryxml(xmldata).build();
+            ASSERT_EQUALS("smart-pointer(MyPtr)",
+                          typeOf("void f() { MyPtr<int> p; return p; }", "p ;", true, &set));
+            ASSERT_EQUALS("signed int", typeOf("void f() { MyPtr<int> p; return *p; }", "* p ;", true, &set));
+            ASSERT_EQUALS("smart-pointer(MyPtr)", typeOf("void f() {return MyPtr<int>();}", "(", true, &set));
+        }
+    }
+
+    void valueType2() {
+        GET_SYMBOL_DB("int i;\n"
+                      "bool b;\n"
+                      "Unknown u;\n"
+                      "std::string s;\n"
+                      "std::vector<int> v;\n"
+                      "std::map<int, void*>::const_iterator it;\n"
+                      "void* p;\n"
+                      "\n"
+                      "void f() {\n"
+                      "    func(i, b, u, s, v, it, p);\n"
+                      "}");
+
+        const Token* tok = tokenizer.tokens();
+
+        for (int i = 0; i < 2; i++) {
+            tok = Token::findsimplematch(tok, "i");
+            ASSERT(tok && tok->valueType());
+            ASSERT_EQUALS("signed int", tok->valueType()->str());
+
+            tok = Token::findsimplematch(tok, "b");
+            ASSERT(tok && tok->valueType());
+            ASSERT_EQUALS("bool", tok->valueType()->str());
+
+            tok = Token::findsimplematch(tok, "u");
+            ASSERT(tok && !tok->valueType());
+
+            tok = Token::findsimplematch(tok, "s");
+            ASSERT(tok && tok->valueType());
+            ASSERT_EQUALS("container(std :: string|wstring|u16string|u32string)", tok->valueType()->str());
+            ASSERT(tok->valueType()->container && tok->valueType()->container->stdStringLike);
+
+            tok = Token::findsimplematch(tok, "v");
+            ASSERT(tok && tok->valueType());
+            ASSERT_EQUALS("container(std :: vector <)", tok->valueType()->str());
+            ASSERT(tok->valueType()->container && !tok->valueType()->container->stdStringLike);
+
+            tok = Token::findsimplematch(tok, "it");
+            ASSERT(tok && tok->valueType());
+            ASSERT_EQUALS("iterator(std :: map|unordered_map <)", tok->valueType()->str());
+        }
+    }
+
+    void valueType3() {
+        {
+            GET_SYMBOL_DB("void f(std::vector<std::unordered_map<int, std::unordered_set<int>>>& v, int i, int j) {\n"
+                          "    auto& s = v[i][j];\n"
+                          "    s.insert(0);\n"
+                          "}\n");
+            ASSERT_EQUALS("", errout_str());
+
+            const Token* tok = tokenizer.tokens();
+            tok = Token::findsimplematch(tok, "s .");
+            ASSERT(tok && tok->valueType());
+            ASSERT_EQUALS("container(std :: set|unordered_set <) &", tok->valueType()->str());
+        }
+        {
+            GET_SYMBOL_DB("void f(std::vector<int> v) {\n"
+                          "    auto it = std::find(v.begin(), v.end(), 0);\n"
+                          "}\n");
+            ASSERT_EQUALS("", errout_str());
+
+            const Token* tok = tokenizer.tokens();
+            tok = Token::findsimplematch(tok, "auto");
+            ASSERT(tok && tok->valueType());
+            ASSERT_EQUALS("iterator(std :: vector <)", tok->valueType()->str());
+        }
+        {
+            GET_SYMBOL_DB("void f(std::vector<int>::iterator beg, std::vector<int>::iterator end) {\n"
+                          "    auto it = std::find(beg, end, 0);\n"
+                          "}\n");
+            ASSERT_EQUALS("", errout_str());
+
+            const Token* tok = tokenizer.tokens();
+            tok = Token::findsimplematch(tok, "auto");
+            ASSERT(tok && tok->valueType());
+            ASSERT_EQUALS("iterator(std :: vector <)", tok->valueType()->str());
+        }
+        {
+            GET_SYMBOL_DB("struct S {\n"
+                          "    S() {}\n"
+                          "    std::vector<std::shared_ptr<S>> v;\n"
+                          "    void f(int i) const;\n"
+                          "};\n"
+                          "void S::f(int i) const {\n"
+                          "    for (const auto& c : v)\n"
+                          "        c->f(i);\n"
+                          "}\n");
+            ASSERT_EQUALS("", errout_str());
+
+            const Token* tok = tokenizer.tokens();
+            tok = Token::findsimplematch(tok, "auto");
+            ASSERT(tok && tok->valueType() && tok->scope() && tok->scope()->functionOf);
+            const Type* smpType = tok->valueType()->smartPointerType;
+            ASSERT(smpType && smpType == tok->scope()->functionOf->definedType);
+        }
+        {
+            GET_SYMBOL_DB("struct S { int i; };\n"
+                          "void f(const std::vector<S>& v) {\n"
+                          "    auto it = std::find_if(std::begin(v), std::end(v), [](const S& s) { return s.i != 0; });\n"
+                          "}\n");
+            ASSERT_EQUALS("", errout_str());
+
+            const Token* tok = tokenizer.tokens();
+            tok = Token::findsimplematch(tok, "auto");
+            ASSERT(tok && tok->valueType());
+            ASSERT_EQUALS("iterator(std :: vector <)", tok->valueType()->str());
+        }
+        {
+            GET_SYMBOL_DB("struct S { std::vector<int> v; };\n"
+                          "struct T { S s; };\n"
+                          "void f(T* t) {\n"
+                          "    auto it = std::find(t->s.v.begin(), t->s.v.end(), 0);\n"
+                          "}\n");
+            ASSERT_EQUALS("", errout_str());
+
+            const Token* tok = tokenizer.tokens();
+            tok = Token::findsimplematch(tok, "auto");
+            ASSERT(tok && tok->valueType());
+            ASSERT_EQUALS("iterator(std :: vector <)", tok->valueType()->str());
+        }
+        {
+            GET_SYMBOL_DB("struct S { std::vector<int> v[1][1]; };\n"
+                          "struct T { S s[1]; };\n"
+                          "void f(T * t) {\n"
+                          "    auto it = std::find(t->s[0].v[0][0].begin(), t->s[0].v[0][0].end(), 0);\n"
+                          "}\n");
+            ASSERT_EQUALS("", errout_str());
+
+            const Token* tok = tokenizer.tokens();
+            tok = Token::findsimplematch(tok, "auto");
+            ASSERT(tok && tok->valueType());
+            ASSERT_EQUALS("iterator(std :: vector <)", tok->valueType()->str());
+        }
+        {
+            GET_SYMBOL_DB("std::vector<int>& g();\n"
+                          "void f() {\n"
+                          "    auto it = std::find(g().begin(), g().end(), 0);\n"
+                          "}\n");
+            ASSERT_EQUALS("", errout_str());
+
+            const Token* tok = tokenizer.tokens();
+            tok = Token::findsimplematch(tok, "auto");
+            ASSERT(tok && tok->valueType());
+            ASSERT_EQUALS("iterator(std :: vector <)", tok->valueType()->str());
+        }
+        {
+            GET_SYMBOL_DB("struct T { std::set<std::string> s; };\n"
+                          "struct U { std::shared_ptr<T> get(); };\n"
+                          "void f(U* u) {\n"
+                          "    for (const auto& str : u->get()->s) {}\n"
+                          "}\n");
+            ASSERT_EQUALS("", errout_str());
+
+            const Token* tok = tokenizer.tokens();
+            tok = Token::findsimplematch(tok, "auto");
+            ASSERT(tok && tok->valueType());
+            ASSERT_EQUALS("const container(std :: string|wstring|u16string|u32string) &", tok->valueType()->str());
+        }
+        {
+            GET_SYMBOL_DB("void f(std::vector<int>& v) {\n"
+                          "    for (auto& i : v)\n"
+                          "        i = 0;\n"
+                          "    for (auto&& j : v)\n"
+                          "        j = 1;\n"
+                          "}\n");
+            ASSERT_EQUALS("", errout_str());
+
+            const Token* tok = tokenizer.tokens();
+            tok = Token::findsimplematch(tok, "auto &");
+            ASSERT(tok && tok->valueType());
+            ASSERT_EQUALS("signed int &", tok->valueType()->str());
+            tok = Token::findsimplematch(tok, "i :");
+            ASSERT(tok && tok->valueType());
+            ASSERT(tok->valueType()->reference == Reference::LValue);
+            tok = Token::findsimplematch(tok, "i =");
+            ASSERT(tok && tok->valueType());
+            ASSERT(tok->valueType()->reference == Reference::LValue);
+            tok = Token::findsimplematch(tok, "auto &&");
+            ASSERT(tok && tok->valueType());
+            ASSERT_EQUALS("signed int &&", tok->valueType()->str());
+            tok = Token::findsimplematch(tok, "j =");
+            ASSERT(tok && tok->valueType());
+            ASSERT(tok->valueType()->reference == Reference::RValue);
+        }
+        {
+            GET_SYMBOL_DB("void f(std::vector<int*>& v) {\n"
+                          "    for (const auto& p : v)\n"
+                          "        if (p == nullptr) {}\n"
+                          "}\n");
+            ASSERT_EQUALS("", errout_str());
+
+            const Token* tok = tokenizer.tokens();
+            tok = Token::findsimplematch(tok, "auto");
+            ASSERT(tok && tok->valueType());
+            ASSERT_EQUALS("signed int * const &", tok->valueType()->str());
+            tok = Token::findsimplematch(tok, "p :");
+            ASSERT(tok && tok->valueType());
+            ASSERT_EQUALS("signed int * const &", tok->valueType()->str());
+            ASSERT(tok->variable() && tok->variable()->valueType());
+            ASSERT_EQUALS("signed int * const &", tok->variable()->valueType()->str());
+            tok = Token::findsimplematch(tok, "p ==");
+            ASSERT(tok && tok->valueType());
+            ASSERT_EQUALS("signed int * const &", tok->valueType()->str());
+            ASSERT(tok->variable() && tok->variable()->valueType());
+            ASSERT_EQUALS("signed int * const &", tok->variable()->valueType()->str());
+        }
+        {
+            GET_SYMBOL_DB("auto a = 1;\n");
+            ASSERT_EQUALS("", errout_str());
+
+            const Token* tok = tokenizer.tokens();
+            tok = Token::findsimplematch(tok, "auto");
+            ASSERT(tok && tok->valueType());
+            ASSERT_EQUALS("signed int", tok->valueType()->str());
+        }
+        {
+            GET_SYMBOL_DB("void f(const std::string& s) {\n"
+                          "    const auto* const p = s.data();\n"
+                          "}\n");
+            ASSERT_EQUALS("", errout_str());
+
+            const Token* tok = tokenizer.tokens();
+            tok = Token::findsimplematch(tok, "auto");
+            ASSERT(tok && tok->valueType());
+            ASSERT_EQUALS(ValueType::CHAR, tok->valueType()->type);
+            ASSERT_EQUALS(1, tok->valueType()->constness);
+            ASSERT_EQUALS(0, tok->valueType()->pointer);
+            tok = Token::findsimplematch(tok, "p");
+            ASSERT(tok && tok->variable() && tok->variable()->valueType());
+            ASSERT_EQUALS(ValueType::CHAR, tok->variable()->valueType()->type);
+            ASSERT_EQUALS(3, tok->variable()->valueType()->constness);
+            ASSERT_EQUALS(1, tok->variable()->valueType()->pointer);
+        }
+        {
+            GET_SYMBOL_DB("std::string f(const std::string& s) {\n"
+                          "    auto t = s.substr(3, 7);\n"
+                          "    auto r = t.substr(1, 2);\n"
+                          "    return r;\n"
+                          "}\n");
+            ASSERT_EQUALS("", errout_str());
+
+            const Token* tok = tokenizer.tokens();
+            tok = Token::findsimplematch(tok, "auto r");
+            ASSERT(tok);
+            TODO_ASSERT(tok->valueType() && "container(std :: string|wstring|u16string|u32string)" == tok->valueType()->str());
+        }
+    }
+
+    void valueTypeThis() {
+        ASSERT_EQUALS("C *", typeOf("class C { C() { *this = 0; } };", "this"));
+        ASSERT_EQUALS("const C *", typeOf("class C { void foo() const; }; void C::foo() const { *this = 0; }", "this"));
+    }
+
+    void valueTypeChar() {
+        Settings s = settings2;
+        s.platform.defaultSign = 's';
+        ASSERT_EQUALS("char", typeOf("char c; c = 'x';", "c =", true, &s));
+        ASSERT_EQUALS("char", typeOf("char buf[10]; buf[0] = 'x';", "[ 0 ]", true, &s));
     }
 
     void variadic1() { // #7453
@@ -6450,13 +10256,9 @@ class TestSymbolDatabase: public TestFixture {
         GET_SYMBOL_DB_C("func() { }");
 
         ASSERT(db && db->functionScopes.size() == 1);
-        if (db && db->functionScopes.size() == 1) {
-            ASSERT(db->functionScopes[0]->function != nullptr);
-            if (db->functionScopes[0]->function != nullptr) {
-                const Token *retDef = db->functionScopes[0]->function->retDef;
-                ASSERT_EQUALS("func", retDef ? retDef->str() : "");
-            }
-        }
+        ASSERT(db->functionScopes[0]->function != nullptr);
+        const Token *retDef = db->functionScopes[0]->function->retDef;
+        ASSERT_EQUALS("func", retDef ? retDef->str() : "");
     }
 
     void auto1() {
@@ -6693,7 +10495,7 @@ class TestSymbolDatabase: public TestFixture {
         ASSERT(autotok && autotok->type() && autotok->type()->name() == "S");
 
         autotok = Token::findsimplematch(autotok->next(), "auto & c");
-        ASSERT(autotok && autotok->valueType() && autotok->valueType()->pointer == 0 && autotok->valueType()->constness == 0 && autotok->valueType()->typeScope && autotok->valueType()->typeScope->definedType && autotok->valueType()->typeScope->definedType->name() == "S");
+        ASSERT(autotok && autotok->valueType() && autotok->valueType()->pointer == 0 && autotok->valueType()->constness == 1 && autotok->valueType()->typeScope && autotok->valueType()->typeScope->definedType && autotok->valueType()->typeScope->definedType->name() == "S");
         ASSERT(autotok && autotok->type() && autotok->type()->name() == "S");
 
         autotok = Token::findsimplematch(autotok->next(), "auto * d");
@@ -6701,7 +10503,7 @@ class TestSymbolDatabase: public TestFixture {
         ASSERT(autotok && autotok->type() && autotok->type()->name() == "S");
 
         autotok = Token::findsimplematch(autotok->next(), "auto * e");
-        ASSERT(autotok && autotok->valueType() && autotok->valueType()->pointer == 0 && autotok->valueType()->constness == 0 && autotok->valueType()->typeScope && autotok->valueType()->typeScope->definedType && autotok->valueType()->typeScope->definedType->name() == "S");
+        ASSERT(autotok && autotok->valueType() && autotok->valueType()->pointer == 0 && autotok->valueType()->constness == 1 && autotok->valueType()->typeScope && autotok->valueType()->typeScope->definedType && autotok->valueType()->typeScope->definedType->name() == "S");
         ASSERT(autotok && autotok->type() && autotok->type()->name() == "S");
 
         vartok = Token::findsimplematch(tokenizer.tokens(), "a :");
@@ -6859,14 +10661,14 @@ class TestSymbolDatabase: public TestFixture {
         autotok = Token::findsimplematch(autotok, "auto v4");
         ASSERT(autotok);
         ASSERT(autotok->valueType());
-        TODO_ASSERT_EQUALS(0, 1, autotok->valueType()->constness);
+        ASSERT_EQUALS(3, autotok->valueType()->constness);
         ASSERT_EQUALS(1, autotok->valueType()->pointer);
         ASSERT_EQUALS(ValueType::SIGNED, autotok->valueType()->sign);
         ASSERT_EQUALS(ValueType::INT, autotok->valueType()->type);
         vartok = Token::findsimplematch(autotok, "v4 =");
         ASSERT(autotok);
         ASSERT(autotok->valueType());
-        ASSERT_EQUALS(1, vartok->valueType()->constness);
+        ASSERT_EQUALS(3, vartok->valueType()->constness);
         ASSERT_EQUALS(1, vartok->valueType()->pointer);
         ASSERT_EQUALS(ValueType::SIGNED, vartok->valueType()->sign);
         ASSERT_EQUALS(ValueType::INT, vartok->valueType()->type);
@@ -6939,14 +10741,14 @@ class TestSymbolDatabase: public TestFixture {
         autotok = Token::findsimplematch(autotok, "auto v9");
         ASSERT(autotok);
         ASSERT(autotok->valueType());
-        TODO_ASSERT_EQUALS(0, 1, autotok->valueType()->constness);
+        ASSERT_EQUALS(3, autotok->valueType()->constness);
         ASSERT_EQUALS(1, autotok->valueType()->pointer);
         ASSERT_EQUALS(ValueType::SIGNED, autotok->valueType()->sign);
         ASSERT_EQUALS(ValueType::INT, autotok->valueType()->type);
         vartok = Token::findsimplematch(autotok, "v9 =");
         ASSERT(autotok);
         ASSERT(autotok->valueType());
-        ASSERT_EQUALS(1, vartok->valueType()->constness);
+        ASSERT_EQUALS(3, vartok->valueType()->constness);
         ASSERT_EQUALS(1, vartok->valueType()->pointer);
         ASSERT_EQUALS(ValueType::SIGNED, vartok->valueType()->sign);
         ASSERT_EQUALS(ValueType::INT, vartok->valueType()->type);
@@ -6970,22 +10772,19 @@ class TestSymbolDatabase: public TestFixture {
         // auto = int, v11 = int
         autotok = Token::findsimplematch(autotok, "auto v11");
         ASSERT(autotok);
-        TODO_ASSERT(autotok->valueType());
-        if (autotok->valueType()) {
-            ASSERT_EQUALS(0, autotok->valueType()->constness);
-            ASSERT_EQUALS(0, autotok->valueType()->pointer);
-            ASSERT_EQUALS(ValueType::SIGNED, autotok->valueType()->sign);
-            ASSERT_EQUALS(ValueType::INT, autotok->valueType()->type);
-        }
+        ASSERT(autotok->valueType());
+        ASSERT_EQUALS(0, autotok->valueType()->constness);
+        ASSERT_EQUALS(0, autotok->valueType()->pointer);
+        ASSERT_EQUALS(ValueType::SIGNED, autotok->valueType()->sign);
+        ASSERT_EQUALS(ValueType::INT, autotok->valueType()->type);
+
         vartok = autotok->next();
         ASSERT(autotok);
-        TODO_ASSERT(autotok->valueType());
-        if (vartok->valueType()) {
-            ASSERT_EQUALS(0, vartok->valueType()->constness);
-            ASSERT_EQUALS(0, vartok->valueType()->pointer);
-            ASSERT_EQUALS(ValueType::SIGNED, vartok->valueType()->sign);
-            ASSERT_EQUALS(ValueType::INT, vartok->valueType()->type);
-        }
+        ASSERT(autotok->valueType());
+        ASSERT_EQUALS(0, vartok->valueType()->constness);
+        ASSERT_EQUALS(0, vartok->valueType()->pointer);
+        ASSERT_EQUALS(ValueType::SIGNED, vartok->valueType()->sign);
+        ASSERT_EQUALS(ValueType::INT, vartok->valueType()->type);
     }
 
     void auto8() {
@@ -7078,6 +10877,201 @@ class TestSymbolDatabase: public TestFixture {
         ASSERT(tok && tok->valueType() && tok->valueType()->container);
     }
 
+    void auto13() {
+        GET_SYMBOL_DB("uint8_t *get();\n"
+                      "\n"
+                      "uint8_t *test()\n"
+                      "{\n"
+                      "    auto *next = get();\n"
+                      "    return next;\n"
+                      "}");
+
+        const Token *tok;
+
+        tok = Token::findsimplematch(tokenizer.tokens(), "return")->next();
+        ASSERT(tok);
+        ASSERT(tok->valueType());
+        ASSERT(tok->valueType()->pointer);
+        ASSERT(tok->variable()->valueType());
+        ASSERT(tok->variable()->valueType()->pointer);
+    }
+
+    void auto14() { // #9892 - crash in Token::declType
+        GET_SYMBOL_DB("static void foo() {\n"
+                      "    auto combo = widget->combo = new Combo{};\n"
+                      "    combo->addItem();\n"
+                      "}");
+
+        const Token *tok;
+
+        tok = Token::findsimplematch(tokenizer.tokens(), "combo =");
+        ASSERT(tok && !tok->valueType());
+    }
+
+    void auto15() {
+        GET_SYMBOL_DB("auto var1{3};\n"
+                      "auto var2{4.0};");
+        ASSERT_EQUALS(3, db->variableList().size());
+        const Variable *var1 = db->variableList()[1];
+        ASSERT(var1->valueType());
+        ASSERT_EQUALS(ValueType::Type::INT, var1->valueType()->type);
+        const Variable *var2 = db->variableList()[2];
+        ASSERT(var2->valueType());
+        ASSERT_EQUALS(ValueType::Type::DOUBLE, var2->valueType()->type);
+    }
+
+    void auto16() {
+        GET_SYMBOL_DB("void foo(std::map<std::string, bool> x) {\n"
+                      "    for (const auto& i: x) {}\n"
+                      "}\n");
+        ASSERT_EQUALS(3, db->variableList().size());
+        const Variable *i = db->variableList().back();
+        ASSERT(i->valueType());
+        ASSERT_EQUALS(ValueType::Type::RECORD, i->valueType()->type);
+    }
+
+    void auto17() { // #11163 don't hang
+        GET_SYMBOL_DB("void f() {\n"
+                      "    std::shared_ptr<int> s1;\n"
+                      "    auto s2 = std::shared_ptr(s1);\n"
+                      "}\n"
+                      "void g() {\n"
+                      "    std::shared_ptr<int> s;\n"
+                      "    auto w = std::weak_ptr(s);\n"
+                      "}\n");
+        ASSERT_EQUALS(5, db->variableList().size());
+    }
+
+    void auto18() {
+        GET_SYMBOL_DB("void f(const int* p) {\n"
+                      "    const int* const& r = p;\n"
+                      "    const auto& s = p;\n"
+                      "}\n");
+        ASSERT_EQUALS(4, db->variableList().size());
+
+        const Variable* r = db->variableList()[2];
+        ASSERT(r->isReference());
+        ASSERT(r->isConst());
+        ASSERT(r->isPointer());
+        const Token* varTok = Token::findsimplematch(tokenizer.tokens(), "r");
+        ASSERT(varTok && varTok->valueType());
+        ASSERT_EQUALS(varTok->valueType()->constness, 3);
+        ASSERT_EQUALS(varTok->valueType()->pointer, 1);
+        ASSERT(varTok->valueType()->reference == Reference::LValue);
+
+        const Variable* s = db->variableList()[3];
+        ASSERT(s->isReference());
+        ASSERT(s->isConst());
+        ASSERT(s->isPointer());
+        const Token* autoTok = Token::findsimplematch(tokenizer.tokens(), "auto");
+        ASSERT(autoTok && autoTok->valueType());
+        ASSERT_EQUALS(autoTok->valueType()->constness, 3);
+        ASSERT_EQUALS(autoTok->valueType()->pointer, 1);
+    }
+
+    void auto19() { // #11517
+        {
+            GET_SYMBOL_DB("void f(const std::vector<void*>& v) {\n"
+                          "    for (const auto* h : v)\n"
+                          "        if (h) {}\n"
+                          "}\n");
+            ASSERT_EQUALS(3, db->variableList().size());
+
+            const Variable* h = db->variableList()[2];
+            ASSERT(h->isPointer());
+            ASSERT(!h->isConst());
+            const Token* varTok = Token::findsimplematch(tokenizer.tokens(), "h )");
+            ASSERT(varTok && varTok->valueType());
+            ASSERT_EQUALS(varTok->valueType()->constness, 1);
+            ASSERT_EQUALS(varTok->valueType()->pointer, 1);
+        }
+        {
+            GET_SYMBOL_DB("struct B { virtual void f() {} };\n"
+                          "struct D : B {};\n"
+                          "void g(const std::vector<B*>& v) {\n"
+                          "    for (auto* b : v)\n"
+                          "        if (auto d = dynamic_cast<D*>(b))\n"
+                          "            d->f();\n"
+                          "}\n");
+            ASSERT_EQUALS(4, db->variableList().size());
+
+            const Variable* b = db->variableList()[2];
+            ASSERT(b->isPointer());
+            ASSERT(!b->isConst());
+            const Token* varTok = Token::findsimplematch(tokenizer.tokens(), "b )");
+            ASSERT(varTok && varTok->valueType());
+            ASSERT_EQUALS(varTok->valueType()->constness, 0);
+            ASSERT_EQUALS(varTok->valueType()->pointer, 1);
+        }
+    }
+
+    void auto20() {
+        GET_SYMBOL_DB("enum A { A0 };\n"
+                      "enum B { B0 };\n"
+                      "const int& g(A a);\n"
+                      "const int& g(B b);\n"
+                      "void f() {\n"
+                      "    const auto& r = g(B::B0);\n"
+                      "}\n");
+        const Token* a = Token::findsimplematch(tokenizer.tokens(), "auto");
+        ASSERT(a && a->valueType());
+        ASSERT_EQUALS(a->valueType()->type, ValueType::INT);
+        const Token* g = Token::findsimplematch(a, "g ( B ::");
+        ASSERT(g && g->function());
+        ASSERT_EQUALS(g->function()->tokenDef->linenr(), 4);
+    }
+
+    void auto21() {
+        GET_SYMBOL_DB("int f(bool b) {\n"
+                      "    std::vector<int> v1(1), v2(2);\n"
+                      "    auto& v = b ? v1 : v2;\n"
+                      "    v.push_back(1);\n"
+                      "    return v.size();\n"
+                      "}\n");
+        ASSERT_EQUALS("", errout_str());
+        const Token* a = Token::findsimplematch(tokenizer.tokens(), "auto");
+        ASSERT(a && a->valueType());
+        ASSERT_EQUALS(a->valueType()->type, ValueType::CONTAINER);
+        const Token* v = Token::findsimplematch(a, "v . size");
+        ASSERT(v && v->valueType());
+        ASSERT_EQUALS(v->valueType()->type, ValueType::CONTAINER);
+        ASSERT(v->variable() && v->variable()->isReference());
+    }
+
+    void auto22() {
+        GET_SYMBOL_DB("void f(std::vector<std::string>& v, bool b) {\n"
+                      "    auto& s = b ? v[0] : v[1];\n"
+                      "    s += \"abc\";\n"
+                      "}\n");
+        ASSERT_EQUALS("", errout_str());
+        const Token* a = Token::findsimplematch(tokenizer.tokens(), "auto");
+        ASSERT(a && a->valueType());
+        ASSERT_EQUALS(a->valueType()->type, ValueType::CONTAINER);
+        const Token* s = Token::findsimplematch(a, "s +=");
+        ASSERT(s && s->valueType());
+        ASSERT_EQUALS(s->valueType()->type, ValueType::CONTAINER);
+        ASSERT(s->valueType()->reference == Reference::LValue);
+        ASSERT(s->variable() && s->variable()->isReference());
+    }
+
+    void auto23() {
+        GET_SYMBOL_DB("struct S { int* p; };\n" // #12168
+                      "void f(const S& s) {\n"
+                      "    auto q = s.p;\n"
+                      "}\n");
+        ASSERT_EQUALS("", errout_str());
+        const Token* a = Token::findsimplematch(tokenizer.tokens(), "auto");
+        ASSERT(a && a->valueType());
+        ASSERT_EQUALS(a->valueType()->type, ValueType::INT);
+        ASSERT_EQUALS(a->valueType()->pointer, 1);
+        ASSERT_EQUALS(a->valueType()->constness, 0);
+        const Token* dot = Token::findsimplematch(a, ".");
+        ASSERT(dot && dot->valueType());
+        ASSERT_EQUALS(dot->valueType()->type, ValueType::INT);
+        ASSERT_EQUALS(dot->valueType()->pointer, 1);
+        ASSERT_EQUALS(dot->valueType()->constness, 2);
+    }
+
     void unionWithConstructor() {
         GET_SYMBOL_DB("union Fred {\n"
                       "    Fred(int x) : i(x) { }\n"
@@ -7086,7 +11080,7 @@ class TestSymbolDatabase: public TestFixture {
                       "    float f;\n"
                       "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         const Token *f = Token::findsimplematch(tokenizer.tokens(), "Fred ( int");
         ASSERT(f && f->function() && f->function()->tokenDef->linenr() == 2);
@@ -7110,7 +11104,328 @@ class TestSymbolDatabase: public TestFixture {
                       "  }\n"
                       "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void exprIds()
+    {
+        {
+            const char code[] = "int f(int a) {\n"
+                                "    return a +\n"
+                                "           a;\n"
+                                "}\n";
+            ASSERT_EQUALS("", testExprIdEqual(code, "a", 2U, "a", 3U));
+        }
+
+        {
+            const char code[] = "int f(int a, int b) {\n"
+                                "    return a +\n"
+                                "           b;\n"
+                                "}\n";
+            ASSERT_EQUALS(true, testExprIdNotEqual(code, "a", 2U, "b", 3U));
+        }
+
+        {
+            const char code[] = "int f(int a) {\n"
+                                "    int x = a++;\n"
+                                "    int y = a++;\n"
+                                "    return x + a;\n"
+                                "}\n";
+            ASSERT_EQUALS(true, testExprIdNotEqual(code, "++", 2U, "++", 3U));
+        }
+
+        {
+            const char code[] = "int f(int a) {\n"
+                                "    int x = a;\n"
+                                "    return x + a;\n"
+                                "}\n";
+            ASSERT_EQUALS(true, testExprIdNotEqual(code, "x", 3U, "a", 3U));
+        }
+
+        {
+            const char code[] = "int f(int a) {\n"
+                                "    int& x = a;\n"
+                                "    return x + a;\n"
+                                "}\n";
+            TODO_ASSERT_EQUALS("", "x@2 != a@1", testExprIdEqual(code, "x", 3U, "a", 3U));
+        }
+
+        {
+            const char code[] = "int f(int a) {\n"
+                                "    int& x = a;\n"
+                                "    return (x + 1) +\n"
+                                "           (a + 1);\n"
+                                "}\n";
+            ASSERT_EQUALS("", testExprIdEqual(code, "+", 3U, "+", 4U));
+        }
+
+        {
+            const char code[] = "int& g(int& x) { return x; }\n"
+                                "int f(int a) {\n"
+                                "    return (g(a) + 1) +\n"
+                                "           (a + 1);\n"
+                                "}\n";
+            ASSERT_EQUALS("", testExprIdEqual(code, "+", 3U, "+", 4U));
+        }
+
+        {
+            const char code[] = "int f(int a, int b) {\n"
+                                "    int x = (b-a)-a;\n"
+                                "    int y = (b-a)-a;\n"
+                                "    return x + y;\n"
+                                "}\n";
+            ASSERT_EQUALS("", testExprIdEqual(code, "- a ;", 2U, "- a ;", 3U));
+            ASSERT_EQUALS("", testExprIdEqual(code, "- a )", 2U, "- a )", 3U));
+            ASSERT_EQUALS(true, testExprIdNotEqual(code, "- a )", 2U, "- a ;", 3U));
+        }
+
+        {
+            const char code[] = "int f(int a, int b) {\n"
+                                "    int x = a-(b-a);\n"
+                                "    int y = a-(b-a);\n"
+                                "    return x + y;\n"
+                                "}\n";
+            ASSERT_EQUALS("", testExprIdEqual(code, "- ( b", 2U, "- ( b", 3U));
+            ASSERT_EQUALS("", testExprIdEqual(code, "- a )", 2U, "- a )", 3U));
+            ASSERT_EQUALS(true, testExprIdNotEqual(code, "- a )", 2U, "- ( b", 3U));
+        }
+
+        {
+            const char code[] = "void f(int a, int b) {\n"
+                                "    int x = (b+a)+a;\n"
+                                "    int y = a+(b+a);\n"
+                                "    return x + y;\n"
+                                "}\n";
+            ASSERT_EQUALS("", testExprIdEqual(code, "+ a ;", 2U, "+ ( b", 3U));
+            ASSERT_EQUALS("", testExprIdEqual(code, "+ a ) +", 2U, "+ a ) ;", 3U));
+            ASSERT_EQUALS(true, testExprIdNotEqual(code, "+ a ;", 2U, "+ a )", 3U));
+        }
+
+        {
+            const char code[] = "void f(int a, int b) {\n"
+                                "    int x = (b+a)+a;\n"
+                                "    int y = a+(a+b);\n"
+                                "    return x + y;\n"
+                                "}\n";
+            ASSERT_EQUALS("", testExprIdEqual(code, "+ a ;", 2U, "+ ( a", 3U));
+            ASSERT_EQUALS("", testExprIdEqual(code, "+ a ) +", 2U, "+ b ) ;", 3U));
+            ASSERT_EQUALS(true, testExprIdNotEqual(code, "+ a ;", 2U, "+ b", 3U));
+        }
+
+        {
+            const char code[] = "struct A { int x; };\n"
+                                "void f(A a, int b) {\n"
+                                "    int x = (b-a.x)-a.x;\n"
+                                "    int y = (b-a.x)-a.x;\n"
+                                "    return x + y;\n"
+                                "}\n";
+            ASSERT_EQUALS("", testExprIdEqual(code, "- a . x ;", 3U, "- a . x ;", 4U));
+            ASSERT_EQUALS("", testExprIdEqual(code, "- a . x )", 3U, "- a . x )", 4U));
+        }
+
+        {
+            const char code[] = "struct A { int x; };\n"
+                                "void f(A a, int b) {\n"
+                                "    int x = a.x-(b-a.x);\n"
+                                "    int y = a.x-(b-a.x);\n"
+                                "    return x + y;\n"
+                                "}\n";
+            ASSERT_EQUALS("", testExprIdEqual(code, "- ( b", 3U, "- ( b", 4U));
+            ASSERT_EQUALS("", testExprIdEqual(code, "- a . x )", 3U, "- a . x )", 4U));
+        }
+
+        {
+            const char code[] = "struct A { int x; };\n"
+                                "void f(A a) {\n"
+                                "    int x = a.x;\n"
+                                "    int y = a.x;\n"
+                                "    return x + y;\n"
+                                "}\n";
+            ASSERT_EQUALS("", testExprIdEqual(code, ". x", 3U, ". x", 4U));
+        }
+
+        {
+            const char code[] = "struct A { int x; };\n"
+                                "void f(A a, A b) {\n"
+                                "    int x = a.x;\n"
+                                "    int y = b.x;\n"
+                                "    return x + y;\n"
+                                "}\n";
+            ASSERT_EQUALS(true, testExprIdNotEqual(code, ". x", 3U, ". x", 4U));
+        }
+
+        {
+            const char code[] = "struct A { int y; };\n"
+                                "struct B { A x; }\n"
+                                "void f(B a) {\n"
+                                "    int x = a.x.y;\n"
+                                "    int y = a.x.y;\n"
+                                "    return x + y;\n"
+                                "}\n";
+            ASSERT_EQUALS("", testExprIdEqual(code, ". x . y", 4U, ". x . y", 5U));
+            ASSERT_EQUALS("", testExprIdEqual(code, ". y", 4U, ". y", 5U));
+        }
+
+        {
+            const char code[] = "struct A { int y; };\n"
+                                "struct B { A x; }\n"
+                                "void f(B a, B b) {\n"
+                                "    int x = a.x.y;\n"
+                                "    int y = b.x.y;\n"
+                                "    return x + y;\n"
+                                "}\n";
+            ASSERT_EQUALS(true, testExprIdNotEqual(code, ". x . y", 4U, ". x . y", 5U));
+            ASSERT_EQUALS(true, testExprIdNotEqual(code, ". y", 4U, ". y", 5U));
+        }
+
+        {
+            const char code[] = "struct A { int g(); };\n"
+                                "struct B { A x; }\n"
+                                "void f(B a) {\n"
+                                "    int x = a.x.g();\n"
+                                "    int y = a.x.g();\n"
+                                "    return x + y;\n"
+                                "}\n";
+            ASSERT_EQUALS("", testExprIdEqual(code, ". x . g ( )", 4U, ". x . g ( )", 5U));
+            ASSERT_EQUALS("", testExprIdEqual(code, ". g ( )", 4U, ". g ( )", 5U));
+        }
+
+        {
+            const char code[] = "struct A { int g(int, int); };\n"
+                                "struct B { A x; }\n"
+                                "void f(B a, int b, int c) {\n"
+                                "    int x = a.x.g(b, c);\n"
+                                "    int y = a.x.g(b, c);\n"
+                                "    return x + y;\n"
+                                "}\n";
+            ASSERT_EQUALS("", testExprIdEqual(code, ". x . g ( b , c )", 4U, ". x . g ( b , c )", 5U));
+            ASSERT_EQUALS("", testExprIdEqual(code, ". g ( b , c )", 4U, ". g ( b , c )", 5U));
+        }
+
+        {
+            const char code[] = "int g();\n"
+                                "void f() {\n"
+                                "    int x = g();\n"
+                                "    int y = g();\n"
+                                "    return x + y;\n"
+                                "}\n";
+            ASSERT_EQUALS("", testExprIdEqual(code, "(", 3U, "(", 4U));
+        }
+
+        {
+            const char code[] = "struct A { int g(); };\n"
+                                "void f() {\n"
+                                "    int x = A::g();\n"
+                                "    int y = A::g();\n"
+                                "    return x + y;\n"
+                                "}\n";
+            ASSERT_EQUALS("", testExprIdEqual(code, "(", 3U, "(", 4U));
+        }
+
+        {
+            const char code[] = "int g();\n"
+                                "void f(int a, int b) {\n"
+                                "    int x = g(a, b);\n"
+                                "    int y = g(a, b);\n"
+                                "    return x + y;\n"
+                                "}\n";
+            ASSERT_EQUALS("", testExprIdEqual(code, "(", 3U, "(", 4U));
+        }
+
+        {
+            const char code[] = "struct A { int g(); };\n"
+                                "void f() {\n"
+                                "    int x = A::g(a, b);\n"
+                                "    int y = A::g(a, b);\n"
+                                "    return x + y;\n"
+                                "}\n";
+            ASSERT_EQUALS("", testExprIdEqual(code, "(", 3U, "(", 4U));
+        }
+
+        {
+            const char code[] = "int g();\n"
+                                "void f(int a, int b) {\n"
+                                "    int x = g(a, b);\n"
+                                "    int y = g(b, a);\n"
+                                "    return x + y;\n"
+                                "}\n";
+            ASSERT_EQUALS(true, testExprIdNotEqual(code, "(", 3U, "(", 4U));
+        }
+
+        {
+            const char code[] = "struct A { int g(); };\n"
+                                "void f() {\n"
+                                "    int x = A::g(a, b);\n"
+                                "    int y = A::g(b, a);\n"
+                                "    return x + y;\n"
+                                "}\n";
+            ASSERT_EQUALS(true, testExprIdNotEqual(code, "(", 3U, "(", 4U));
+        }
+    }
+
+    void testValuetypeOriginalName() {
+        {
+            GET_SYMBOL_DB("typedef void ( *fp16 )( int16_t n );\n"
+                          "typedef void ( *fp32 )( int32_t n );\n"
+                          "void R_11_1 ( void ) {\n"
+                          "   fp16 fp1 = NULL;\n"
+                          "   fp32 fp2 = ( fp32) fp1;\n"
+                          "}\n");
+            const Token* tok = Token::findsimplematch(tokenizer.tokens(), "( void * ) fp1");
+            ASSERT_EQUALS(tok->isCast(), true);
+            ASSERT(tok->valueType());
+            ASSERT(tok->valueType()->originalTypeName == "fp32");
+            ASSERT(tok->valueType()->pointer == 1);
+            ASSERT(tok->valueType()->constness == 0);
+        }
+
+        {
+            GET_SYMBOL_DB("typedef void ( *fp16 )( int16_t n );\n"
+                          "fp16 fp3 = ( fp16 ) 0x8000;");
+            const Token* tok = Token::findsimplematch(tokenizer.tokens(), "( void * ) 0x8000");
+            ASSERT_EQUALS(tok->isCast(), true);
+            ASSERT(tok->valueType());
+            ASSERT(tok->valueType()->originalTypeName == "fp16");
+            ASSERT(tok->valueType()->pointer == 1);
+            ASSERT(tok->valueType()->constness == 0);
+        }
+    }
+
+    void dumpFriend() {
+        GET_SYMBOL_DB("class Foo {\n"
+                      "    Foo();\n"
+                      "    int x{};\n"
+                      "    friend bool operator==(const Foo&lhs, const Foo&rhs) {\n"
+                      "        return lhs.x == rhs.x;\n"
+                      "    }\n"
+                      "};");
+        std::ostringstream ostr;
+        db->printXml(ostr);
+        ASSERT(ostr.str().find(" isFriend=\"true\"") != std::string::npos);
+    }
+
+    void smartPointerLookupCtor() { // #13719
+        // do not crash in smartpointer lookup
+        GET_SYMBOL_DB("struct S { int v; S(int i); };\n"
+                      "void f() { S(0).v; }");
+
+        ASSERT(db);
+    }
+
+    void stdintFunction() {
+        GET_SYMBOL_DB("a = UINT32_C(60);");
+        const Token* tok = Token::findsimplematch(tokenizer.tokens(), "UINT32_C (");
+        ASSERT(tok != nullptr);
+        ASSERT_EQUALS(tok->next()->valueType()->sign, ValueType::Sign::UNSIGNED);
+        ASSERT_EQUALS(tok->next()->valueType()->type, ValueType::Type::INT);
+    }
+
+    void userDefinedLiteral() {
+        GET_SYMBOL_DB("_ 1p;");
+        const Token *x = Token::findsimplematch(tokenizer.tokens(), "1p");
+        ASSERT(x);
+        ASSERT(!x->varId());
+        ASSERT(!x->variable());
     }
 };
 
diff --git a/test/testthreadexecutor.cpp b/test/testthreadexecutor.cpp
index 3b4a8449ad3..c99d7753d12 100644
--- a/test/testthreadexecutor.cpp
+++ b/test/testthreadexecutor.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,82 +16,186 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "config.h"
+#include "fixture.h"
+
+#ifdef HAS_THREADING_MODEL_THREAD
+#include "filesettings.h"
+#include "helpers.h"
+#include "redirect.h"
 #include "settings.h"
-#include "testsuite.h"
+#include "standards.h"
+#include "suppressions.h"
 #include "threadexecutor.h"
+#include "timer.h"
 
-#include <cstddef>
-#include <map>
-#include <ostream>
+#include <cstdlib>
+#include <list>
+#include <memory>
+#include <sstream>
 #include <string>
 #include <utility>
+#include <vector>
+#endif // HAS_THREADING_MODEL_THREAD
 
-class TestThreadExecutor : public TestFixture {
+class TestThreadExecutorBase : public TestFixture {
 public:
-    TestThreadExecutor() : TestFixture("TestThreadExecutor") {
+    TestThreadExecutorBase(const char * const name, bool useFS)
+        : TestFixture(name)
+#ifdef HAS_THREADING_MODEL_THREAD
+        , useFS(useFS)
+#endif // HAS_THREADING_MODEL_THREAD
+    {
+        (void)useFS;
     }
 
 private:
-    Settings settings;
+#ifdef HAS_THREADING_MODEL_THREAD
+    /*const*/ Settings settings = settingsBuilder().library("std.cfg").build();
+    bool useFS;
+
+    std::string fprefix() const
+    {
+        if (useFS)
+            return "threadfs";
+        return "thread";
+    }
+
+    struct CheckOptions
+    {
+        bool quiet = true;
+        ShowTime showtime = ShowTime::NONE;
+        const char* plistOutput = nullptr;
+        std::vector<std::string> filesList;
+    };
 
     /**
      * Execute check using n jobs for y files which are have
      * identical data, given within data.
      */
-    void check(unsigned int jobs, int files, int result, const std::string &data) {
-        errout.str("");
-        output.str("");
-        if (!ThreadExecutor::isEnabled()) {
-            // Skip this check on systems which don't use this feature
-            return;
-        }
+    void check(unsigned int jobs, int files, int result, const std::string &data, const CheckOptions& opt = make_default_obj{}) {
+        std::list<FileSettings> fileSettings;
 
-        std::map<std::string, std::size_t> filemap;
-        for (int i = 1; i <= files; ++i) {
-            std::ostringstream oss;
-            oss << "file_" << i << ".cpp";
-            filemap[oss.str()] = 1;
+        std::list<FileWithDetails> filelist;
+        if (opt.filesList.empty()) {
+            for (int i = 1; i <= files; ++i) {
+                std::string f_s = fprefix() + "_" + std::to_string(i) + ".c";
+                filelist.emplace_back(f_s, Standards::Language::C, data.size());
+                if (useFS) {
+                    fileSettings.emplace_back(std::move(f_s), Standards::Language::C, data.size());
+                }
+            }
+        }
+        else {
+            for (const auto& f : opt.filesList)
+            {
+                filelist.emplace_back(f, Standards::Language::C, data.size());
+                if (useFS) {
+                    fileSettings.emplace_back(f, Standards::Language::C, data.size());
+                }
+            }
         }
 
-        settings.jobs = jobs;
-        ThreadExecutor executor(filemap, settings, *this);
-        for (std::map<std::string, std::size_t>::const_iterator i = filemap.begin(); i != filemap.end(); ++i)
-            executor.addFileContent(i->first, data);
+        /*const*/ Settings s = settings;
+        s.jobs = jobs;
+        s.showtime = opt.showtime;
+        s.quiet = opt.quiet;
+        if (opt.plistOutput)
+            s.plistOutput = opt.plistOutput;
+        s.templateFormat = "{callstack}: ({severity}) {inconclusive:inconclusive: }{message}"; // TODO: remove when we only longer rely on toString() in unique message handling?
+
+        Suppressions supprs;
+        TimerResults timerResults;
+
+        // NOLINTNEXTLINE(performance-unnecessary-value-param)
+        auto executeFn = [](std::string,std::vector<std::string>,std::string,std::string&){
+            return EXIT_SUCCESS;
+        };
 
+        std::vector<std::unique_ptr<ScopedFile>> scopedfiles;
+        scopedfiles.reserve(filelist.size());
+        for (auto i = filelist.cbegin(); i != filelist.cend(); ++i)
+            scopedfiles.emplace_back(new ScopedFile(i->path(), data));
+
+        // clear files list so only fileSettings are used
+        if (useFS)
+            filelist.clear();
+
+        ThreadExecutor executor(filelist, fileSettings, s, supprs, *this, &timerResults, executeFn);
         ASSERT_EQUALS(result, executor.check());
     }
+#endif // HAS_THREADING_MODEL_THREAD
 
-    void run() OVERRIDE {
-        LOAD_LIB_2(settings.library, "std.cfg");
-
+    void run() override {
+        mNewTemplate = true;
+#ifdef HAS_THREADING_MODEL_THREAD
         TEST_CASE(deadlock_with_many_errors);
         TEST_CASE(many_threads);
+        TEST_CASE(many_threads_showtime);
+        TEST_CASE(many_threads_plist);
         TEST_CASE(no_errors_more_files);
         TEST_CASE(no_errors_less_files);
         TEST_CASE(no_errors_equal_amount_files);
         TEST_CASE(one_error_less_files);
         TEST_CASE(one_error_several_files);
+        TEST_CASE(showtime_top5_file);
+        TEST_CASE(showtime_top5_summary);
+        TEST_CASE(showtime_file);
+        TEST_CASE(showtime_summary);
+        TEST_CASE(showtime_file_total);
+        TEST_CASE(suppress_error_library);
+        TEST_CASE(unique_errors);
+#endif // HAS_THREADING_MODEL_THREAD
     }
 
+#ifdef HAS_THREADING_MODEL_THREAD
     void deadlock_with_many_errors() {
         std::ostringstream oss;
-        oss << "int main()\n"
+        oss << "void f()\n"
             << "{\n";
-        for (int i = 0; i < 500; i++)
-            oss << "  {char *a = malloc(10);}\n";
-
-        oss << "  return 0;\n"
-            << "}\n";
-        check(2, 3, 3, oss.str());
+        const int num_err = 1;
+        for (int i = 0; i < num_err; i++) {
+            oss << "  (void)(*((int*)0));\n";
+        }
+        oss << "}\n";
+        const int num_files = 3;
+        check(2, num_files, num_files, oss.str());
+        ASSERT_EQUALS(1LL * num_err * num_files, cppcheck::count_all_of(errout_str(), "(error) Null pointer dereference: (int*)0"));
     }
 
     void many_threads() {
-        check(16, 100, 100,
-              "int main()\n"
+        const int num_files = 100;
+        check(16, num_files, num_files,
+              "void f()\n"
               "{\n"
-              "  char *a = malloc(10);\n"
-              "  return 0;\n"
+              "  (void)(*((int*)0));\n"
               "}");
+        ASSERT_EQUALS(num_files, cppcheck::count_all_of(errout_str(), "(error) Null pointer dereference: (int*)0"));
+    }
+
+    // #11249 - reports TSAN errors - only applies to threads not processes though
+    void many_threads_showtime() {
+        SUPPRESS;
+        check(16, 100, 100,
+              "void f()\n"
+              "{\n"
+              "  (void)(*((int*)0));\n"
+              "}", dinit(CheckOptions, $.showtime = ShowTime::SUMMARY));
+        // we are not interested in the results - so just consume them
+        ignore_errout();
+    }
+
+    void many_threads_plist() {
+        const std::string plistOutput = "plist_" + fprefix() + "/";
+        ScopedFile plistFile("dummy", "", plistOutput);
+
+        check(16, 100, 100,
+              "void f()\n"
+              "{\n"
+              "  (void)(*((int*)0));\n"
+              "}", dinit(CheckOptions, $.plistOutput = plistOutput.c_str()));
+        // we are not interested in the results - so just consume them
+        ignore_errout();
     }
 
     void no_errors_more_files() {
@@ -120,21 +224,124 @@ class TestThreadExecutor : public TestFixture {
 
     void one_error_less_files() {
         check(2, 1, 1,
-              "int main()\n"
+              "void f()\n"
               "{\n"
-              "  {char *a = malloc(10);}\n"
-              "  return 0;\n"
+              "  (void)(*((int*)0));\n"
               "}");
+        ASSERT_EQUALS("[" + fprefix() + "_1.c:3:12]: (error) Null pointer dereference: (int*)0 [nullPointer]\n", errout_str());
     }
 
     void one_error_several_files() {
-        check(2, 20, 20,
-              "int main()\n"
+        const int num_files = 20;
+        check(2, num_files, num_files,
+              "void f()\n"
               "{\n"
-              "  {char *a = malloc(10);}\n"
-              "  return 0;\n"
+              "  (void)(*((int*)0));\n"
               "}");
+        ASSERT_EQUALS(num_files, cppcheck::count_all_of(errout_str(), "(error) Null pointer dereference: (int*)0"));
     }
+
+    // TODO: provide data which actually shows values above 0
+
+    // TODO: should this be logged only once like summary?
+    void showtime_top5_file() {
+        REDIRECT; // should not cause TSAN failures as the showtime logging is synchronized
+        check(2, 2, 0,
+              "int main() {}",
+              dinit(CheckOptions,
+                    $.showtime = ShowTime::TOP5_FILE));
+        const std::string output_s = GET_REDIRECT_OUTPUT;
+        // for each file: top5 results + newline + overall
+        ASSERT_EQUALS((5 + 1 + 1) * 2LL, cppcheck::count_all_of(output_s, '\n'));
+    }
+
+    void showtime_top5_summary() {
+        REDIRECT;
+        check(2, 2, 0,
+              "int main() {}",
+              dinit(CheckOptions,
+                    $.showtime = ShowTime::TOP5_SUMMARY));
+        const std::string output_s = GET_REDIRECT_OUTPUT;
+        // once: top5 results + newline
+        ASSERT_EQUALS(5 + 1, cppcheck::count_all_of(output_s, '\n'));
+        // should only report the top5 once
+        ASSERT(output_s.find("1 result(s)") == std::string::npos);
+        ASSERT(output_s.find("2 result(s)") != std::string::npos);
+    }
+
+    void showtime_file() {
+        REDIRECT; // should not cause TSAN failures as the showtime logging is synchronized
+        check(2, 2, 0,
+              "int main() {}",
+              dinit(CheckOptions,
+                    $.showtime = ShowTime::FILE));
+        const std::string output_s = GET_REDIRECT_OUTPUT;
+        ASSERT_EQUALS(0, cppcheck::count_all_of(output_s, "Overall time:"));
+    }
+
+    void showtime_summary() {
+        REDIRECT; // should not cause TSAN failures as the showtime logging is synchronized
+        check(2, 2, 0,
+              "int main() {}",
+              dinit(CheckOptions,
+                    $.showtime = ShowTime::SUMMARY));
+        const std::string output_s = GET_REDIRECT_OUTPUT;
+        // should only report the actual summary once
+        ASSERT(output_s.find("1 result(s)") == std::string::npos);
+        ASSERT(output_s.find("2 result(s)") != std::string::npos);
+    }
+
+    void showtime_file_total() {
+        REDIRECT; // should not cause TSAN failures as the showtime logging is synchronized
+        check(2, 2, 0,
+              "int main() {}",
+              dinit(CheckOptions,
+                    $.showtime = ShowTime::FILE_TOTAL));
+        const std::string output_s = GET_REDIRECT_OUTPUT;
+        ASSERT(output_s.find("Check time: " + fprefix() + "_1.c: ") != std::string::npos);
+        ASSERT(output_s.find("Check time: " + fprefix() + "_2.c: ") != std::string::npos);
+    }
+
+    void suppress_error_library() {
+        SUPPRESS;
+        const Settings settingsOld = settings; // TODO: get rid of this
+        const char xmldata[] = R"(<def format="2"><markup ext=".c" reporterrors="false"/></def>)";
+        settings = settingsBuilder().libraryxml(xmldata).build();
+        check(2, 1, 0,
+              "void f()\n"
+              "{\n"
+              "  (void)(*((int*)0));\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+        settings = settingsOld;
+    }
+
+    void unique_errors() {
+        SUPPRESS;
+        ScopedFile inc_h(fprefix() + ".h",
+                         "inline void f()\n"
+                         "{\n"
+                         "  (void)(*((int*)0));\n"
+                         "}");
+        check(2, 2, 2,
+              "#include \"" + inc_h.name() +"\"");
+        // this is made unique by the executor
+        ASSERT_EQUALS("[" + inc_h.name() + ":3:12]: (error) Null pointer dereference: (int*)0 [nullPointer]\n", errout_str());
+    }
+
+    // TODO: test whole program analysis
+#endif // HAS_THREADING_MODEL_THREAD
+};
+
+class TestThreadExecutorFiles : public TestThreadExecutorBase {
+public:
+    TestThreadExecutorFiles() : TestThreadExecutorBase("TestThreadExecutorFiles", false) {}
+};
+
+class TestThreadExecutorFS : public TestThreadExecutorBase {
+public:
+    TestThreadExecutorFS() : TestThreadExecutorBase("TestThreadExecutorFS", true) {}
 };
 
-REGISTER_TEST(TestThreadExecutor)
+REGISTER_TEST(TestThreadExecutorFiles)
+REGISTER_TEST(TestThreadExecutorFS)
diff --git a/test/testtimer.cpp b/test/testtimer.cpp
index eb02990d0c0..c8d468b1afb 100644
--- a/test/testtimer.cpp
+++ b/test/testtimer.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,30 +16,27 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "testsuite.h"
+#include "fixture.h"
 #include "timer.h"
 
-#include <cmath>
-#include <ctime>
+#include <chrono>
 
 class TestTimer : public TestFixture {
 public:
-    TestTimer() : TestFixture("TestTimer") {
-    }
+    TestTimer() : TestFixture("TestTimer") {}
 
 private:
 
-    void run() OVERRIDE {
+    void run() override {
         TEST_CASE(result);
     }
 
     void result() const {
         TimerResultsData t1;
-        t1.mClocks = ~(std::clock_t)0;
-        ASSERT(t1.seconds() > 100.0);
+        t1.mDuration = std::chrono::milliseconds{1234};
+        ASSERT(t1.getSeconds().count() > 1.233 && t1.getSeconds().count() < 1.235);
 
-        t1.mClocks = CLOCKS_PER_SEC * 5 / 2;
-        ASSERT(std::fabs(t1.seconds()-2.5) < 0.01);
+        // TODO : more tests
     }
 };
 
diff --git a/test/testtoken.cpp b/test/testtoken.cpp
index 3f11654f667..2b411324dc7 100644
--- a/test/testtoken.cpp
+++ b/test/testtoken.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,25 +16,33 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "fixture.h"
+#include "helpers.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "testutils.h"
+#include "standards.h"
 #include "token.h"
-#include "tokenize.h"
 #include "tokenlist.h"
+#include "vfvalue.h"
 
+#include <algorithm>
+#include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
-struct InternalError;
-
 
 class TestToken : public TestFixture {
 public:
-    TestToken() : TestFixture("TestToken") {
-    }
+    TestToken() : TestFixture("TestToken") {}
 
 private:
+    class TokenTest final : public Token
+    {
+        friend class TestToken;
+    };
+
+    const TokenList list{settingsDefault, Standards::Language::C};
+
     std::vector<std::string> arithmeticalOps;
     std::vector<std::string> logicalOps;
     std::vector<std::string> bitOps;
@@ -42,7 +50,7 @@ class TestToken : public TestFixture {
     std::vector<std::string> extendedOps;
     std::vector<std::string> assignmentOps;
 
-    void run() OVERRIDE {
+    void run() override {
         arithmeticalOps = { "+", "-", "*", "/", "%", "<<", ">>" };
         logicalOps = { "&&", "||", "!" };
         comparisonOps = { "==", "!=", "<", "<=", ">", ">=" };
@@ -56,10 +64,12 @@ class TestToken : public TestFixture {
         TEST_CASE(multiCompare3);                   // false positive for %or% on code using "|="
         TEST_CASE(multiCompare4);
         TEST_CASE(multiCompare5);
+        TEST_CASE(charTypes);
+        TEST_CASE(stringTypes);
         TEST_CASE(getStrLength);
         TEST_CASE(getStrSize);
-        TEST_CASE(getCharAt);
         TEST_CASE(strValue);
+        TEST_CASE(concatStr);
 
         TEST_CASE(deleteLast);
         TEST_CASE(deleteFirst);
@@ -89,14 +99,13 @@ class TestToken : public TestFixture {
         TEST_CASE(literals);
         TEST_CASE(operators);
 
-        TEST_CASE(updateProperties)
-        TEST_CASE(updatePropertiesConcatStr)
-        TEST_CASE(isNameGuarantees1)
-        TEST_CASE(isNameGuarantees2)
-        TEST_CASE(isNameGuarantees3)
-        TEST_CASE(isNameGuarantees4)
-        TEST_CASE(isNameGuarantees5)
-        TEST_CASE(isNameGuarantees6)
+        TEST_CASE(updateProperties);
+        TEST_CASE(isNameGuarantees1);
+        TEST_CASE(isNameGuarantees2);
+        TEST_CASE(isNameGuarantees3);
+        TEST_CASE(isNameGuarantees4);
+        TEST_CASE(isNameGuarantees5);
+        TEST_CASE(isNameGuarantees6);
 
         TEST_CASE(canFindMatchingBracketsNeedsOpen);
         TEST_CASE(canFindMatchingBracketsInnerPair);
@@ -104,97 +113,142 @@ class TestToken : public TestFixture {
         TEST_CASE(canFindMatchingBracketsWithTooManyClosing);
         TEST_CASE(canFindMatchingBracketsWithTooManyOpening);
         TEST_CASE(findClosingBracket);
+        TEST_CASE(findClosingBracket2);
+        TEST_CASE(findClosingBracket3);
+        TEST_CASE(findClosingBracket4);
 
         TEST_CASE(expressionString);
 
         TEST_CASE(hasKnownIntValue);
+
+        TEST_CASE(update_property_info);
+        TEST_CASE(update_property_info_evariable);
+        TEST_CASE(update_property_info_ekeyword_c);
+        TEST_CASE(update_property_info_ekeyword_cpp);
+        TEST_CASE(update_property_info_ebracket_link);
+        TEST_CASE(update_property_info_ecomparisonop_link);
+        TEST_CASE(update_property_info_etype_c);
+        TEST_CASE(update_property_info_etype_cpp);
+        TEST_CASE(update_property_info_replace); // #13743
+
+        TEST_CASE(varid_reset);
     }
 
     void nextprevious() const {
-        Token *token = new Token();
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        auto *token = new Token(list, std::move(tokensFrontBack));
         token->str("1");
-        token->insertToken("2");
-        token->next()->insertToken("3");
+        (void)token->insertToken("2");
+        (void)token->next()->insertToken("3");
         Token *last = token->tokAt(2);
         ASSERT_EQUALS(token->str(), "1");
-        ASSERT_EQUALS(token->next()->str(), "2");
+        ASSERT_EQUALS(token->strAt(1), "2");
         ASSERT_EQUALS(token->tokAt(2)->str(), "3");
-        if (last->next())
-            ASSERT_EQUALS("Null was expected", "");
+        ASSERT_EQUALS_MSG(true, last->next() == nullptr, "Null was expected");
 
         ASSERT_EQUALS(last->str(), "3");
-        ASSERT_EQUALS(last->previous()->str(), "2");
+        ASSERT_EQUALS(last->strAt(-1), "2");
         ASSERT_EQUALS(last->tokAt(-2)->str(), "1");
-        if (token->previous())
-            ASSERT_EQUALS("Null was expected", "");
+        ASSERT_EQUALS_MSG(true, token->previous() == nullptr, "Null was expected");
 
         TokenList::deleteTokens(token);
     }
 
-    bool Match(const std::string &code, const std::string &pattern, unsigned int varid=0) {
-        static const Settings settings;
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(";" + code + ";");
+#define MatchCheck(...) MatchCheck_(__FILE__, __LINE__, __VA_ARGS__)
+    bool MatchCheck_(const char* file, int line, const std::string& code, const std::string& pattern) {
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        const std::string code2 = ";" + code + ";";
         try {
-            tokenizer.tokenize(istr, "test.cpp");
+            ASSERT_LOC(tokenizer.tokenize(code2), file, line);
         } catch (...) {}
-        return Token::Match(tokenizer.tokens()->next(), pattern.c_str(), varid);
+        return Token::Match(tokenizer.tokens()->next(), pattern.c_str());
     }
 
     void multiCompare() const {
         // Test for found
-        Token one;
-        one.str("one");
-        ASSERT_EQUALS(1, Token::multiCompare(&one, "one|two", 0));
+        {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token one(list, std::move(tokensFrontBack));
+            one.str("one");
+            ASSERT_EQUALS(1, TokenTest::multiCompare(&one, "one|two", 0));
+        }
 
-        Token two;
-        two.str("two");
-        ASSERT_EQUALS(1, Token::multiCompare(&two, "one|two", 0));
-        ASSERT_EQUALS(1, Token::multiCompare(&two, "verybig|two|", 0));
+        {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token two(list, std::move(tokensFrontBack));
+            two.str("two");
+            ASSERT_EQUALS(1, TokenTest::multiCompare(&two, "one|two", 0));
+            ASSERT_EQUALS(1, TokenTest::multiCompare(&two, "verybig|two|", 0));
+        }
 
         // Test for empty string found
-        Token notfound;
-        notfound.str("notfound");
-        ASSERT_EQUALS(0, Token::multiCompare(&notfound, "one|two|", 0));
-
-        // Test for not found
-        ASSERT_EQUALS(static_cast<unsigned int>(-1), static_cast<unsigned int>(Token::multiCompare(&notfound, "one|two", 0)));
+        {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token notfound(list, std::move(tokensFrontBack));
+            notfound.str("notfound");
+            ASSERT_EQUALS(0, TokenTest::multiCompare(&notfound, "one|two|", 0));
+
+            // Test for not found
+            ASSERT_EQUALS(-1, TokenTest::multiCompare(&notfound, "one|two", 0));
+        }
 
-        Token s;
-        s.str("s");
-        ASSERT_EQUALS(static_cast<unsigned int>(-1), static_cast<unsigned int>(Token::multiCompare(&s, "verybig|two", 0)));
+        {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token s(list, std::move(tokensFrontBack));
+            s.str("s");
+            ASSERT_EQUALS(-1, TokenTest::multiCompare(&s, "verybig|two", 0));
+        }
 
-        Token ne;
-        ne.str("ne");
-        ASSERT_EQUALS(static_cast<unsigned int>(-1), static_cast<unsigned int>(Token::multiCompare(&ne, "one|two", 0)));
+        {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token ne(list, std::move(tokensFrontBack));
+            ne.str("ne");
+            ASSERT_EQUALS(-1, TokenTest::multiCompare(&ne, "one|two", 0));
+        }
 
-        Token a;
-        a.str("a");
-        ASSERT_EQUALS(static_cast<unsigned int>(-1), static_cast<unsigned int>(Token::multiCompare(&a, "abc|def", 0)));
+        {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token a(list, std::move(tokensFrontBack));
+            a.str("a");
+            ASSERT_EQUALS(-1, TokenTest::multiCompare(&a, "abc|def", 0));
+        }
 
-        Token abcd;
-        abcd.str("abcd");
-        ASSERT_EQUALS(static_cast<unsigned int>(-1), static_cast<unsigned int>(Token::multiCompare(&abcd, "abc|def", 0)));
+        {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token abcd(list, std::move(tokensFrontBack));
+            abcd.str("abcd");
+            ASSERT_EQUALS(-1, TokenTest::multiCompare(&abcd, "abc|def", 0));
+        }
 
-        Token def;
-        def.str("default");
-        ASSERT_EQUALS(static_cast<unsigned int>(-1), static_cast<unsigned int>(Token::multiCompare(&def, "abc|def", 0)));
+        {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token def(list, std::move(tokensFrontBack));
+            def.str("default");
+            ASSERT_EQUALS(-1, TokenTest::multiCompare(&def, "abc|def", 0));
+        }
 
         // %op%
-        Token plus;
-        plus.str("+");
-        ASSERT_EQUALS(1, Token::multiCompare(&plus, "one|%op%", 0));
-        ASSERT_EQUALS(1, Token::multiCompare(&plus, "%op%|two", 0));
-        Token x;
-        x.str("x");
-        ASSERT_EQUALS(-1, Token::multiCompare(&x, "one|%op%", 0));
-        ASSERT_EQUALS(-1, Token::multiCompare(&x, "%op%|two", 0));
+        {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token plus(list, std::move(tokensFrontBack));
+            plus.str("+");
+            ASSERT_EQUALS(1, TokenTest::multiCompare(&plus, "one|%op%", 0));
+            ASSERT_EQUALS(1, TokenTest::multiCompare(&plus, "%op%|two", 0));
+        }
+        {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token x(list, std::move(tokensFrontBack));
+            x.str("x");
+            ASSERT_EQUALS(-1, TokenTest::multiCompare(&x, "one|%op%", 0));
+            ASSERT_EQUALS(-1, TokenTest::multiCompare(&x, "%op%|two", 0));
+        }
+
     }
 
     void multiCompare2() const { // #3294
         // Original pattern that failed: [[,(=<>+-*|&^] %num% [+-*/] %num% ]|,|)|;|=|%op%
-        givenACodeSampleToTokenize toks("a == 1", true);
-        ASSERT_EQUALS(true, Token::Match(toks.tokens(), "a =|%op%"));
+        const SimpleTokenList toks("a == 1");
+        ASSERT_EQUALS(true, Token::Match(toks.front(), "a =|%op%"));
     }
 
     void multiCompare3() const {
@@ -202,55 +256,56 @@ class TestToken : public TestFixture {
         // Code snippet that failed: "return lv@86 |= rv@87 ;"
 
         // Note: Also test "reverse" alternative pattern, two different code paths to handle it
-        givenACodeSampleToTokenize toks("return a |= b ;", true);
-        ASSERT_EQUALS(false, Token::Match(toks.tokens(), "return %name% xyz|%or% %name% ;"));
-        ASSERT_EQUALS(false, Token::Match(toks.tokens(), "return %name% %or%|xyz %name% ;"));
+        const SimpleTokenList toks("return a |= b ;");
+        ASSERT_EQUALS(false, Token::Match(toks.front(), "return %name% xyz|%or% %name% ;"));
+        ASSERT_EQUALS(false, Token::Match(toks.front(), "return %name% %or%|xyz %name% ;"));
 
-        givenACodeSampleToTokenize toks2("return a | b ;", true);
-        ASSERT_EQUALS(true, Token::Match(toks2.tokens(), "return %name% xyz|%or% %name% ;"));
-        ASSERT_EQUALS(true, Token::Match(toks2.tokens(), "return %name% %or%|xyz %name% ;"));
+        const SimpleTokenList toks2("return a | b ;");
+        ASSERT_EQUALS(true, Token::Match(toks2.front(), "return %name% xyz|%or% %name% ;"));
+        ASSERT_EQUALS(true, Token::Match(toks2.front(), "return %name% %or%|xyz %name% ;"));
 
-        givenACodeSampleToTokenize toks3("return a || b ;", true);
-        ASSERT_EQUALS(false, Token::Match(toks3.tokens(), "return %name% xyz|%or% %name% ;"));
-        ASSERT_EQUALS(false, Token::Match(toks3.tokens(), "return %name% %or%|xyz %name% ;"));
+        const SimpleTokenList toks3("return a || b ;");
+        ASSERT_EQUALS(false, Token::Match(toks3.front(), "return %name% xyz|%or% %name% ;"));
+        ASSERT_EQUALS(false, Token::Match(toks3.front(), "return %name% %or%|xyz %name% ;"));
 
-        ASSERT_EQUALS(true, Token::Match(toks3.tokens(), "return %name% xyz|%oror% %name% ;"));
-        ASSERT_EQUALS(true, Token::Match(toks3.tokens(), "return %name% %oror%|xyz %name% ;"));
+        ASSERT_EQUALS(true, Token::Match(toks3.front(), "return %name% xyz|%oror% %name% ;"));
+        ASSERT_EQUALS(true, Token::Match(toks3.front(), "return %name% %oror%|xyz %name% ;"));
 
-        givenACodeSampleToTokenize toks4("a % b ;", true);
-        ASSERT_EQUALS(true, Token::Match(toks4.tokens(), "%name% >>|<<|&|%or%|^|% %name% ;"));
-        ASSERT_EQUALS(true, Token::Match(toks4.tokens(), "%name% %|>>|<<|&|%or%|^ %name% ;"));
-        ASSERT_EQUALS(true, Token::Match(toks4.tokens(), "%name% >>|<<|&|%or%|%|^ %name% ;"));
+        const SimpleTokenList toks4("a % b ;");
+        ASSERT_EQUALS(true, Token::Match(toks4.front(), "%name% >>|<<|&|%or%|^|% %name% ;"));
+        ASSERT_EQUALS(true, Token::Match(toks4.front(), "%name% %|>>|<<|&|%or%|^ %name% ;"));
+        ASSERT_EQUALS(true, Token::Match(toks4.front(), "%name% >>|<<|&|%or%|%|^ %name% ;"));
 
         //%name%|%num% support
-        givenACodeSampleToTokenize num("100", true);
-        ASSERT_EQUALS(true, Token::Match(num.tokens(), "%num%|%name%"));
-        ASSERT_EQUALS(true, Token::Match(num.tokens(), "%name%|%num%"));
-        ASSERT_EQUALS(true, Token::Match(num.tokens(), "%name%|%num%|%bool%"));
-        ASSERT_EQUALS(true, Token::Match(num.tokens(), "%name%|%bool%|%num%"));
-        ASSERT_EQUALS(true, Token::Match(num.tokens(), "%name%|%bool%|%str%|%num%"));
-        ASSERT_EQUALS(false, Token::Match(num.tokens(), "%bool%|%name%"));
-        ASSERT_EQUALS(false, Token::Match(num.tokens(), "%type%|%bool%|%char%"));
-        ASSERT_EQUALS(true, Token::Match(num.tokens(), "%type%|%bool%|100"));
-
-        givenACodeSampleToTokenize numparen("( 100 )", true);
-        ASSERT_EQUALS(true, Token::Match(numparen.tokens(), "(| %num%|%name% )|"));
-        ASSERT_EQUALS(true, Token::Match(numparen.tokens(), "(| %name%|%num% )|"));
-        ASSERT_EQUALS(true, Token::Match(numparen.tokens(), "(| %name%|%num%|%bool% )|"));
-        ASSERT_EQUALS(true, Token::Match(numparen.tokens(), "(| %name%|%bool%|%num% )|"));
-        ASSERT_EQUALS(true, Token::Match(numparen.tokens(), "(| %name%|%bool%|%str%|%num% )|"));
-        ASSERT_EQUALS(false, Token::Match(numparen.tokens(), "(| %bool%|%name% )|"));
-
-        ASSERT_EQUALS(true, Token::Match(numparen.tokens(), "(| 100 %num%|%name%| )|"));
-        ASSERT_EQUALS(true, Token::Match(numparen.tokens(), "(| 100 %name%|%num%| )|"));
-        ASSERT_EQUALS(true, Token::Match(numparen.tokens(), "(| 100 %name%|%num%|%bool%| )|"));
-        ASSERT_EQUALS(true, Token::Match(numparen.tokens(), "(| 100 %name%|%bool%|%num%| )|"));
-        ASSERT_EQUALS(true, Token::Match(numparen.tokens(), "(| 100 %name%|%bool%|%str%|%num%| )|"));
-        ASSERT_EQUALS(true, Token::Match(numparen.tokens(), "(| 100 %bool%|%name%| )|"));
-    }
-
-    void multiCompare4() const {
-        givenACodeSampleToTokenize var("std :: queue < int > foo ;");
+        const SimpleTokenList num("100");
+        ASSERT_EQUALS(true, Token::Match(num.front(), "%num%|%name%"));
+        ASSERT_EQUALS(true, Token::Match(num.front(), "%name%|%num%"));
+        ASSERT_EQUALS(true, Token::Match(num.front(), "%name%|%num%|%bool%"));
+        ASSERT_EQUALS(true, Token::Match(num.front(), "%name%|%bool%|%num%"));
+        ASSERT_EQUALS(true, Token::Match(num.front(), "%name%|%bool%|%str%|%num%"));
+        ASSERT_EQUALS(false, Token::Match(num.front(), "%bool%|%name%"));
+        ASSERT_EQUALS(false, Token::Match(num.front(), "%type%|%bool%|%char%"));
+        ASSERT_EQUALS(true, Token::Match(num.front(), "%type%|%bool%|100"));
+
+        const SimpleTokenList numparen("( 100 )");
+        ASSERT_EQUALS(true, Token::Match(numparen.front(), "(| %num%|%name% )|"));
+        ASSERT_EQUALS(true, Token::Match(numparen.front(), "(| %name%|%num% )|"));
+        ASSERT_EQUALS(true, Token::Match(numparen.front(), "(| %name%|%num%|%bool% )|"));
+        ASSERT_EQUALS(true, Token::Match(numparen.front(), "(| %name%|%bool%|%num% )|"));
+        ASSERT_EQUALS(true, Token::Match(numparen.front(), "(| %name%|%bool%|%str%|%num% )|"));
+        ASSERT_EQUALS(false, Token::Match(numparen.front(), "(| %bool%|%name% )|"));
+
+        ASSERT_EQUALS(true, Token::Match(numparen.front(), "(| 100 %num%|%name%| )|"));
+        ASSERT_EQUALS(true, Token::Match(numparen.front(), "(| 100 %name%|%num%| )|"));
+        ASSERT_EQUALS(true, Token::Match(numparen.front(), "(| 100 %name%|%num%|%bool%| )|"));
+        ASSERT_EQUALS(true, Token::Match(numparen.front(), "(| 100 %name%|%bool%|%num%| )|"));
+        ASSERT_EQUALS(true, Token::Match(numparen.front(), "(| 100 %name%|%bool%|%str%|%num%| )|"));
+        ASSERT_EQUALS(true, Token::Match(numparen.front(), "(| 100 %bool%|%name%| )|"));
+    }
+
+    void multiCompare4() {
+        SimpleTokenizer var(*this);
+        ASSERT(var.tokenize("std :: queue < int > foo ;"));
 
         ASSERT_EQUALS(Token::eBracket, var.tokens()->tokAt(3)->tokType());
         ASSERT_EQUALS(Token::eBracket, var.tokens()->tokAt(5)->tokType());
@@ -261,13 +316,137 @@ class TestToken : public TestFixture {
     }
 
     void multiCompare5() const {
-        Token tok;
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token tok(list, std::move(tokensFrontBack));
         tok.str("||");
-        ASSERT_EQUALS(true, Token::multiCompare(&tok, "+|%or%|%oror%", 0) >= 0);
+        ASSERT_EQUALS(true, TokenTest::multiCompare(&tok, "+|%or%|%oror%", 0) >= 0);
+    }
+
+    void charTypes() const {
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token tok(list, std::move(tokensFrontBack));
+
+        tok.str("'a'");
+        ASSERT_EQUALS(true, tok.isCChar());
+        ASSERT_EQUALS(false, tok.isUtf8());
+        ASSERT_EQUALS(false, tok.isUtf16());
+        ASSERT_EQUALS(false, tok.isUtf32());
+        ASSERT_EQUALS(false, tok.isLong());
+        ASSERT_EQUALS(false, tok.isCMultiChar());
+
+        tok.str("u8'a'");
+        ASSERT_EQUALS(false, tok.isCChar());
+        ASSERT_EQUALS(true, tok.isUtf8());
+        ASSERT_EQUALS(false, tok.isUtf16());
+        ASSERT_EQUALS(false, tok.isUtf32());
+        ASSERT_EQUALS(false, tok.isLong());
+        ASSERT_EQUALS(false, tok.isCMultiChar());
+
+        tok.str("u'a'");
+        ASSERT_EQUALS(false, tok.isCChar());
+        ASSERT_EQUALS(false, tok.isUtf8());
+        ASSERT_EQUALS(true, tok.isUtf16());
+        ASSERT_EQUALS(false, tok.isUtf32());
+        ASSERT_EQUALS(false, tok.isLong());
+        ASSERT_EQUALS(false, tok.isCMultiChar());
+
+        tok.str("U'a'");
+        ASSERT_EQUALS(false, tok.isCChar());
+        ASSERT_EQUALS(false, tok.isUtf8());
+        ASSERT_EQUALS(false, tok.isUtf16());
+        ASSERT_EQUALS(true, tok.isUtf32());
+        ASSERT_EQUALS(false, tok.isLong());
+        ASSERT_EQUALS(false, tok.isCMultiChar());
+
+        tok.str("L'a'");
+        ASSERT_EQUALS(false, tok.isCChar());
+        ASSERT_EQUALS(false, tok.isUtf8());
+        ASSERT_EQUALS(false, tok.isUtf16());
+        ASSERT_EQUALS(false, tok.isUtf32());
+        ASSERT_EQUALS(true, tok.isLong());
+        ASSERT_EQUALS(false, tok.isCMultiChar());
+
+        tok.str("'aaa'");
+        ASSERT_EQUALS(false, tok.isCChar());
+        ASSERT_EQUALS(false, tok.isUtf8());
+        ASSERT_EQUALS(false, tok.isUtf16());
+        ASSERT_EQUALS(false, tok.isUtf32());
+        ASSERT_EQUALS(false, tok.isLong());
+        ASSERT_EQUALS(true, tok.isCMultiChar());
+
+        tok.str("'\\''");
+        ASSERT_EQUALS(true, tok.isCChar());
+        ASSERT_EQUALS(false, tok.isUtf8());
+        ASSERT_EQUALS(false, tok.isUtf16());
+        ASSERT_EQUALS(false, tok.isUtf32());
+        ASSERT_EQUALS(false, tok.isLong());
+        ASSERT_EQUALS(false, tok.isCMultiChar());
+
+        tok.str("'\\r\\n'");
+        ASSERT_EQUALS(false, tok.isCChar());
+        ASSERT_EQUALS(false, tok.isUtf8());
+        ASSERT_EQUALS(false, tok.isUtf16());
+        ASSERT_EQUALS(false, tok.isUtf32());
+        ASSERT_EQUALS(false, tok.isLong());
+        ASSERT_EQUALS(true, tok.isCMultiChar());
+
+        tok.str("'\\x10'");
+        ASSERT_EQUALS(true, tok.isCChar());
+        ASSERT_EQUALS(false, tok.isUtf8());
+        ASSERT_EQUALS(false, tok.isUtf16());
+        ASSERT_EQUALS(false, tok.isUtf32());
+        ASSERT_EQUALS(false, tok.isLong());
+        ASSERT_EQUALS(false, tok.isCMultiChar());
+    }
+
+    void stringTypes() const {
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token tok(list, std::move(tokensFrontBack));
+
+        tok.str("\"a\"");
+        ASSERT_EQUALS(true, tok.isCChar());
+        ASSERT_EQUALS(false, tok.isUtf8());
+        ASSERT_EQUALS(false, tok.isUtf16());
+        ASSERT_EQUALS(false, tok.isUtf32());
+        ASSERT_EQUALS(false, tok.isLong());
+        ASSERT_EQUALS(false, tok.isCMultiChar());
+
+        tok.str("u8\"a\"");
+        ASSERT_EQUALS(false, tok.isCChar());
+        ASSERT_EQUALS(true, tok.isUtf8());
+        ASSERT_EQUALS(false, tok.isUtf16());
+        ASSERT_EQUALS(false, tok.isUtf32());
+        ASSERT_EQUALS(false, tok.isLong());
+        ASSERT_EQUALS(false, tok.isCMultiChar());
+
+        tok.str("u\"a\"");
+        ASSERT_EQUALS(false, tok.isCChar());
+        ASSERT_EQUALS(false, tok.isUtf8());
+        ASSERT_EQUALS(true, tok.isUtf16());
+        ASSERT_EQUALS(false, tok.isUtf32());
+        ASSERT_EQUALS(false, tok.isLong());
+        ASSERT_EQUALS(false, tok.isCMultiChar());
+
+        tok.str("U\"a\"");
+        ASSERT_EQUALS(false, tok.isCChar());
+        ASSERT_EQUALS(false, tok.isUtf8());
+        ASSERT_EQUALS(false, tok.isUtf16());
+        ASSERT_EQUALS(true, tok.isUtf32());
+        ASSERT_EQUALS(false, tok.isLong());
+        ASSERT_EQUALS(false, tok.isCMultiChar());
+
+        tok.str("L\"a\"");
+        ASSERT_EQUALS(false, tok.isCChar());
+        ASSERT_EQUALS(false, tok.isUtf8());
+        ASSERT_EQUALS(false, tok.isUtf16());
+        ASSERT_EQUALS(false, tok.isUtf32());
+        ASSERT_EQUALS(true, tok.isLong());
+        ASSERT_EQUALS(false, tok.isCMultiChar());
     }
 
     void getStrLength() const {
-        Token tok;
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token tok(list, std::move(tokensFrontBack));
 
         tok.str("\"\"");
         ASSERT_EQUALS(0, Token::getStrLength(&tok));
@@ -295,45 +474,25 @@ class TestToken : public TestFixture {
     }
 
     void getStrSize() const {
-        Token tok;
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token tok(list, std::move(tokensFrontBack));
 
         tok.str("\"\"");
-        ASSERT_EQUALS(sizeof(""), Token::getStrSize(&tok));
+        ASSERT_EQUALS(sizeof(""), Token::getStrSize(&tok, settingsDefault));
 
         tok.str("\"abc\"");
-        ASSERT_EQUALS(sizeof("abc"), Token::getStrSize(&tok));
+        ASSERT_EQUALS(sizeof("abc"), Token::getStrSize(&tok, settingsDefault));
 
         tok.str("\"\\0abc\"");
-        ASSERT_EQUALS(sizeof("\0abc"), Token::getStrSize(&tok));
+        ASSERT_EQUALS(sizeof("\0abc"), Token::getStrSize(&tok, settingsDefault));
 
         tok.str("\"\\\\\"");
-        ASSERT_EQUALS(sizeof("\\"), Token::getStrSize(&tok));
-    }
-
-    void getCharAt() const {
-        Token tok;
-
-        tok.str("\"asdf\"");
-        ASSERT_EQUALS("a", Token::getCharAt(&tok, 0));
-        ASSERT_EQUALS("s", Token::getCharAt(&tok, 1));
-
-        tok.str("\"a\\ts\"");
-        ASSERT_EQUALS("\\t", Token::getCharAt(&tok, 1));
-
-        tok.str("\"\"");
-        ASSERT_EQUALS("\\0", Token::getCharAt(&tok, 0));
-
-        tok.str("L\"a\\ts\"");
-        ASSERT_EQUALS("a", Token::getCharAt(&tok, 0));
-        ASSERT_EQUALS("\\t", Token::getCharAt(&tok, 1));
-
-        tok.str("u\"a\\ts\"");
-        ASSERT_EQUALS("\\t", Token::getCharAt(&tok, 1));
-        ASSERT_EQUALS("s", Token::getCharAt(&tok, 2));
+        ASSERT_EQUALS(sizeof("\\"), Token::getStrSize(&tok, settingsDefault));
     }
 
     void strValue() const {
-        Token tok;
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token tok(list, std::move(tokensFrontBack));
 
         tok.str("\"\"");
         ASSERT_EQUALS("", tok.strValue());
@@ -363,148 +522,195 @@ class TestToken : public TestFixture {
         ASSERT_EQUALS("a", tok.strValue());
     }
 
+    void concatStr() const {
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token tok(list, std::move(tokensFrontBack));
+
+        tok.str("\"\"");
+        tok.concatStr("\"\"");
+        ASSERT_EQUALS("", tok.strValue());
+        ASSERT(tok.isCChar());
+
+        tok.str("\"ab\"");
+        tok.concatStr("\"cd\"");
+        ASSERT_EQUALS("abcd", tok.strValue());
+        ASSERT(tok.isCChar());
+
+        tok.str("L\"ab\"");
+        tok.concatStr("L\"cd\"");
+        ASSERT_EQUALS("abcd", tok.strValue());
+        ASSERT(tok.isLong());
+
+        tok.str("L\"ab\"");
+        tok.concatStr("\"cd\"");
+        ASSERT_EQUALS("abcd", tok.strValue());
+        ASSERT(tok.isLong());
+
+        tok.str("\"ab\"");
+        tok.concatStr("L\"cd\"");
+        ASSERT_EQUALS("abcd", tok.strValue());
+        ASSERT(tok.isLong());
+
+        tok.str("\"ab\"");
+        tok.concatStr("L\"\"");
+        ASSERT_EQUALS("ab", tok.strValue());
+        ASSERT(tok.isLong());
+
+        tok.str("\"ab\"");
+        tok.concatStr("u8\"cd\"");
+        ASSERT_EQUALS("abcd", tok.strValue());
+        ASSERT(tok.isUtf8());
+    }
 
     void deleteLast() const {
-        TokensFrontBack listEnds{ nullptr };
-        Token ** const tokensBack = &(listEnds.back);
-        Token tok(&listEnds);
-        tok.insertToken("aba");
+        auto listEnds = std::make_shared<TokensFrontBack>();
+        Token ** const tokensBack = &(listEnds->back);
+        Token tok(list, listEnds);
+        (void)tok.insertToken("aba");
         ASSERT_EQUALS(true, *tokensBack == tok.next());
         tok.deleteNext();
         ASSERT_EQUALS(true, *tokensBack == &tok);
     }
 
     void deleteFirst() const {
-        TokensFrontBack listEnds{ nullptr };
-        Token ** const tokensFront = &(listEnds.front);
-        Token tok(&listEnds);
+        auto listEnds = std::make_shared<TokensFrontBack>();
+        Token ** const tokensFront = &(listEnds->front);
+        Token tok(list, listEnds);
 
-        tok.insertToken("aba");
+        (void)tok.insertToken("aba");
 
         ASSERT_EQUALS(true, *tokensFront == tok.previous());
         tok.deletePrevious();
         ASSERT_EQUALS(true, *tokensFront == &tok);
     }
 
-    void nextArgument() const {
-        givenACodeSampleToTokenize example1("foo(1, 2, 3, 4);");
+    void nextArgument() {
+        SimpleTokenizer example1(*this);
+        ASSERT(example1.tokenize("foo(1, 2, 3, 4);"));
         ASSERT_EQUALS(true, Token::simpleMatch(example1.tokens()->tokAt(2)->nextArgument(), "2 , 3"));
         ASSERT_EQUALS(true, Token::simpleMatch(example1.tokens()->tokAt(4)->nextArgument(), "3 , 4"));
 
-        givenACodeSampleToTokenize example2("foo();");
+        SimpleTokenizer example2(*this);
+        ASSERT(example2.tokenize("foo();"));
         ASSERT_EQUALS(true, example2.tokens()->tokAt(2)->nextArgument() == nullptr);
 
-        givenACodeSampleToTokenize example3("foo(bar(a, b), 2, 3);");
+        SimpleTokenizer example3(*this);
+        ASSERT(example3.tokenize("foo(bar(a, b), 2, 3);"));
         ASSERT_EQUALS(true, Token::simpleMatch(example3.tokens()->tokAt(2)->nextArgument(), "2 , 3"));
 
-        givenACodeSampleToTokenize example4("foo(x.i[1], \"\", 3);");
+        SimpleTokenizer example4(*this);
+        ASSERT(example4.tokenize("foo(x.i[1], \"\", 3);"));
         ASSERT_EQUALS(true, Token::simpleMatch(example4.tokens()->tokAt(2)->nextArgument(), "\"\" , 3"));
     }
 
     void eraseTokens() const {
-        givenACodeSampleToTokenize code("begin ; { this code will be removed } end", true);
-        Token::eraseTokens(code.tokens()->next(), code.tokens()->tokAt(9));
-        ASSERT_EQUALS("begin ; end", code.tokens()->stringifyList(nullptr, false));
+        SimpleTokenList code("begin ; { this code will be removed } end", Standards::Language::C);
+        Token::eraseTokens(code.front()->next(), code.front()->tokAt(9));
+        ASSERT_EQUALS("begin ; end", code.front()->stringifyList(nullptr, false));
     }
 
 
     void matchAny() const {
-        givenACodeSampleToTokenize varBitOrVar("abc|def", true);
-        ASSERT_EQUALS(true, Token::Match(varBitOrVar.tokens(), "%name% %or% %name%"));
+        const SimpleTokenList varBitOrVar("abc|def");
+        ASSERT_EQUALS(true, Token::Match(varBitOrVar.front(), "%name% %or% %name%"));
 
-        givenACodeSampleToTokenize varLogOrVar("abc||def", true);
-        ASSERT_EQUALS(true, Token::Match(varLogOrVar.tokens(), "%name% %oror% %name%"));
+        const SimpleTokenList varLogOrVar("abc||def");
+        ASSERT_EQUALS(true, Token::Match(varLogOrVar.front(), "%name% %oror% %name%"));
     }
 
     void matchSingleChar() const {
-        givenACodeSampleToTokenize singleChar("a", true);
-        ASSERT_EQUALS(true, Token::Match(singleChar.tokens(), "[a|bc]"));
-        ASSERT_EQUALS(false, Token::Match(singleChar.tokens(), "[d|ef]"));
+        const SimpleTokenList singleChar("a");
+        ASSERT_EQUALS(true, Token::Match(singleChar.front(), "[a|bc]"));
+        ASSERT_EQUALS(false, Token::Match(singleChar.front(), "[d|ef]"));
 
-        Token multiChar;
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token multiChar(list, std::move(tokensFrontBack));
         multiChar.str("[ab");
         ASSERT_EQUALS(false, Token::Match(&multiChar, "[ab|def]"));
     }
 
     void matchNothingOrAnyNotElse() const {
-        givenACodeSampleToTokenize empty_String("", true);
-        ASSERT_EQUALS(true, Token::Match(empty_String.tokens(), "!!else"));
-        ASSERT_EQUALS(false, Token::Match(empty_String.tokens(), "!!else something"));
+        const SimpleTokenList empty_String("");
+        ASSERT_EQUALS(true, Token::Match(empty_String.front(), "!!else"));
+        ASSERT_EQUALS(false, Token::Match(empty_String.front(), "!!else something"));
 
-        givenACodeSampleToTokenize ifSemicolon("if ;", true);
-        ASSERT_EQUALS(true, Token::Match(ifSemicolon.tokens(), "if ; !!else"));
+        const SimpleTokenList ifSemicolon("if ;");
+        ASSERT_EQUALS(true, Token::Match(ifSemicolon.front(), "if ; !!else"));
 
-        givenACodeSampleToTokenize ifSemicolonSomething("if ; something", true);
-        ASSERT_EQUALS(true, Token::Match(ifSemicolonSomething.tokens(), "if ; !!else"));
+        const SimpleTokenList ifSemicolonSomething("if ; something");
+        ASSERT_EQUALS(true, Token::Match(ifSemicolonSomething.front(), "if ; !!else"));
 
-        givenACodeSampleToTokenize justElse("else", true);
-        ASSERT_EQUALS(false, Token::Match(justElse.tokens(), "!!else"));
+        const SimpleTokenList justElse("else");
+        ASSERT_EQUALS(false, Token::Match(justElse.front(), "!!else"));
 
-        givenACodeSampleToTokenize ifSemicolonElse("if ; else", true);
-        ASSERT_EQUALS(false, Token::Match(ifSemicolonElse.tokens(), "if ; !!else"));
+        const SimpleTokenList ifSemicolonElse("if ; else");
+        ASSERT_EQUALS(false, Token::Match(ifSemicolonElse.front(), "if ; !!else"));
     }
 
-    void matchType() const {
-        givenACodeSampleToTokenize type("abc", true);
-        ASSERT_EQUALS(true, Token::Match(type.tokens(), "%type%"));
+    void matchType() {
+        const SimpleTokenList type("abc");
+        ASSERT_EQUALS(true, Token::Match(type.front(), "%type%"));
 
-        givenACodeSampleToTokenize isVar("int a = 3 ;");
+        SimpleTokenizer isVar(*this);
+        ASSERT(isVar.tokenize("int a = 3 ;"));
         ASSERT_EQUALS(true, Token::Match(isVar.tokens(), "%type%"));
         ASSERT_EQUALS(true, Token::Match(isVar.tokens(), "%type% %name%"));
         ASSERT_EQUALS(false, Token::Match(isVar.tokens(), "%type% %type%"));
 
-        givenACodeSampleToTokenize noType1_cpp("delete", true, true);
-        ASSERT_EQUALS(false, Token::Match(noType1_cpp.tokens(), "%type%"));
+        // TODO: %type% should not match keywords other than fundamental types
+        const SimpleTokenList noType1_cpp("delete");
+        ASSERT_EQUALS(true, Token::Match(noType1_cpp.front(), "%type%"));
 
-        givenACodeSampleToTokenize noType1_c("delete", true, false);
-        ASSERT_EQUALS(true, Token::Match(noType1_c.tokens(), "%type%"));
+        const SimpleTokenList noType1_c("delete", Standards::Language::C);
+        ASSERT_EQUALS(true, Token::Match(noType1_c.front(), "%type%"));
 
-        givenACodeSampleToTokenize noType2("void delete", true);
-        ASSERT_EQUALS(false, Token::Match(noType2.tokens(), "!!foo %type%"));
+        const SimpleTokenList noType2("void delete");
+        ASSERT_EQUALS(true, Token::Match(noType2.front(), "!!foo %type%"));
     }
 
     void matchChar() const {
-        givenACodeSampleToTokenize chr1("'a'", true);
-        ASSERT_EQUALS(true, Token::Match(chr1.tokens(), "%char%"));
+        const SimpleTokenList chr1("'a'");
+        ASSERT_EQUALS(true, Token::Match(chr1.front(), "%char%"));
 
-        givenACodeSampleToTokenize chr2("'1'", true);
-        ASSERT_EQUALS(true, Token::Match(chr2.tokens(), "%char%"));
+        const SimpleTokenList chr2("'1'");
+        ASSERT_EQUALS(true, Token::Match(chr2.front(), "%char%"));
 
-        givenACodeSampleToTokenize noChr("\"10\"", true);
-        ASSERT_EQUALS(false, Token::Match(noChr.tokens(), "%char%"));
+        const SimpleTokenList noChr("\"10\"");
+        ASSERT_EQUALS(false, Token::Match(noChr.front(), "%char%"));
     }
 
     void matchCompOp() const {
-        givenACodeSampleToTokenize comp1("<=", true);
-        ASSERT_EQUALS(true, Token::Match(comp1.tokens(), "%comp%"));
+        const SimpleTokenList comp1("<=");
+        ASSERT_EQUALS(true, Token::Match(comp1.front(), "%comp%"));
 
-        givenACodeSampleToTokenize comp2(">", true);
-        ASSERT_EQUALS(true, Token::Match(comp2.tokens(), "%comp%"));
+        const SimpleTokenList comp2(">");
+        ASSERT_EQUALS(true, Token::Match(comp2.front(), "%comp%"));
 
-        givenACodeSampleToTokenize noComp("=", true);
-        ASSERT_EQUALS(false, Token::Match(noComp.tokens(), "%comp%"));
+        const SimpleTokenList noComp("=");
+        ASSERT_EQUALS(false, Token::Match(noComp.front(), "%comp%"));
     }
 
     void matchStr() const {
-        givenACodeSampleToTokenize noStr1("abc", true);
-        ASSERT_EQUALS(false, Token::Match(noStr1.tokens(), "%str%"));
+        const SimpleTokenList noStr1("abc");
+        ASSERT_EQUALS(false, Token::Match(noStr1.front(), "%str%"));
 
-        givenACodeSampleToTokenize noStr2("'a'", true);
-        ASSERT_EQUALS(false, Token::Match(noStr2.tokens(), "%str%"));
+        const SimpleTokenList noStr2("'a'");
+        ASSERT_EQUALS(false, Token::Match(noStr2.front(), "%str%"));
 
-        givenACodeSampleToTokenize str("\"abc\"", true);
-        ASSERT_EQUALS(true, Token::Match(str.tokens(), "%str%"));
+        const SimpleTokenList str("\"abc\"");
+        ASSERT_EQUALS(true, Token::Match(str.front(), "%str%"));
 
         // Empty string
-        givenACodeSampleToTokenize emptyStr("\"\"", true);
-        ASSERT_EQUALS(true, Token::Match(emptyStr.tokens(), "%str%"));
+        const SimpleTokenList emptyStr("\"\"");
+        ASSERT_EQUALS(true, Token::Match(emptyStr.front(), "%str%"));
     }
 
-    void matchVarid() const {
-        givenACodeSampleToTokenize var("int a ; int b ;");
+    void matchVarid() {
+        SimpleTokenizer var(*this);
+        ASSERT(var.tokenize("int a ; int b ;"));
 
         // Varid == 0 should throw exception
-        ASSERT_THROW((void)Token::Match(var.tokens(), "%type% %varid% ; %type% %name%", 0),InternalError);
+        ASSERT_THROW_INTERNAL_EQUALS((void)Token::Match(var.tokens(), "%type% %varid% ; %type% %name%", 0),INTERNAL,"Internal error. Token::Match called with varid 0.");
 
         ASSERT_EQUALS(true, Token::Match(var.tokens(), "%type% %varid% ; %type% %name%", 1));
         ASSERT_EQUALS(true, Token::Match(var.tokens(), "%type% %name% ; %type% %varid%", 2));
@@ -518,96 +724,96 @@ class TestToken : public TestFixture {
     }
 
     void matchNumeric() const {
-        givenACodeSampleToTokenize nonNumeric("abc", true);
-        ASSERT_EQUALS(false, Token::Match(nonNumeric.tokens(), "%num%"));
+        const SimpleTokenList nonNumeric("abc");
+        ASSERT_EQUALS(false, Token::Match(nonNumeric.front(), "%num%"));
 
-        givenACodeSampleToTokenize binary("101010b", true);
-        ASSERT_EQUALS(true, Token::Match(binary.tokens(), "%num%"));
+        const SimpleTokenList msLiteral("5ms"); // #11438
+        ASSERT_EQUALS(false, Token::Match(msLiteral.front(), "%num%"));
 
-        givenACodeSampleToTokenize octal("0123", true);
-        ASSERT_EQUALS(true, Token::Match(octal.tokens(), "%num%"));
+        const SimpleTokenList sLiteral("3s");
+        ASSERT_EQUALS(false, Token::Match(sLiteral.front(), "%num%"));
 
-        givenACodeSampleToTokenize decimal("4567", true);
-        ASSERT_EQUALS(true, Token::Match(decimal.tokens(), "%num%"));
+        const SimpleTokenList octal("0123");
+        ASSERT_EQUALS(true, Token::Match(octal.front(), "%num%"));
 
-        givenACodeSampleToTokenize hexadecimal("0xDEADBEEF", true);
-        ASSERT_EQUALS(true, Token::Match(hexadecimal.tokens(), "%num%"));
+        const SimpleTokenList decimal("4567");
+        ASSERT_EQUALS(true, Token::Match(decimal.front(), "%num%"));
 
-        givenACodeSampleToTokenize floatingPoint("0.0f", true);
-        ASSERT_EQUALS(true, Token::Match(floatingPoint.tokens(), "%num%"));
+        const SimpleTokenList hexadecimal("0xDEADBEEF");
+        ASSERT_EQUALS(true, Token::Match(hexadecimal.front(), "%num%"));
 
-        givenACodeSampleToTokenize doublePrecision("0.0d", true);
-        ASSERT_EQUALS(true, Token::Match(doublePrecision.tokens(), "%num%"));
+        const SimpleTokenList floatingPoint("0.0f");
+        ASSERT_EQUALS(true, Token::Match(floatingPoint.front(), "%num%"));
 
-        givenACodeSampleToTokenize signedLong("0L", true);
-        ASSERT_EQUALS(true, Token::Match(signedLong.tokens(), "%num%"));
+        const SimpleTokenList signedLong("0L");
+        ASSERT_EQUALS(true, Token::Match(signedLong.front(), "%num%"));
 
-        givenACodeSampleToTokenize negativeSignedLong("-0L", true);
-        ASSERT_EQUALS(true, Token::Match(negativeSignedLong.tokens(), "- %num%"));
+        const SimpleTokenList negativeSignedLong("-0L");
+        ASSERT_EQUALS(true, Token::Match(negativeSignedLong.front(), "- %num%"));
 
-        givenACodeSampleToTokenize positiveSignedLong("+0L", true);
-        ASSERT_EQUALS(true, Token::Match(positiveSignedLong.tokens(), "+ %num%"));
+        const SimpleTokenList positiveSignedLong("+0L");
+        ASSERT_EQUALS(true, Token::Match(positiveSignedLong.front(), "+ %num%"));
 
-        givenACodeSampleToTokenize unsignedInt("0U", true);
-        ASSERT_EQUALS(true, Token::Match(unsignedInt.tokens(), "%num%"));
+        const SimpleTokenList unsignedInt("0U");
+        ASSERT_EQUALS(true, Token::Match(unsignedInt.front(), "%num%"));
 
-        givenACodeSampleToTokenize unsignedLong("0UL", true);
-        ASSERT_EQUALS(true, Token::Match(unsignedLong.tokens(), "%num%"));
+        const SimpleTokenList unsignedLong("0UL");
+        ASSERT_EQUALS(true, Token::Match(unsignedLong.front(), "%num%"));
 
-        givenACodeSampleToTokenize unsignedLongLong("0ULL", true);
-        ASSERT_EQUALS(true, Token::Match(unsignedLongLong.tokens(), "%num%"));
+        const SimpleTokenList unsignedLongLong("0ULL");
+        ASSERT_EQUALS(true, Token::Match(unsignedLongLong.front(), "%num%"));
 
-        givenACodeSampleToTokenize positive("+666", true);
-        ASSERT_EQUALS(true, Token::Match(positive.tokens(), "+ %num%"));
+        const SimpleTokenList positive("+666");
+        ASSERT_EQUALS(true, Token::Match(positive.front(), "+ %num%"));
 
-        givenACodeSampleToTokenize negative("-42", true);
-        ASSERT_EQUALS(true, Token::Match(negative.tokens(), "- %num%"));
+        const SimpleTokenList negative("-42");
+        ASSERT_EQUALS(true, Token::Match(negative.front(), "- %num%"));
 
-        givenACodeSampleToTokenize negativeNull("-.0", true);
-        ASSERT_EQUALS(true, Token::Match(negativeNull.tokens(), "- %num%"));
+        const SimpleTokenList negativeNull("-.0");
+        ASSERT_EQUALS(true, Token::Match(negativeNull.front(), "- %num%"));
 
-        givenACodeSampleToTokenize positiveNull("+.0", true);
-        ASSERT_EQUALS(true, Token::Match(positiveNull.tokens(), "+ %num%"));
+        const SimpleTokenList positiveNull("+.0");
+        ASSERT_EQUALS(true, Token::Match(positiveNull.front(), "+ %num%"));
     }
 
 
     void matchBoolean() const {
-        givenACodeSampleToTokenize yes("YES", true);
-        ASSERT_EQUALS(false, Token::Match(yes.tokens(), "%bool%"));
+        const SimpleTokenList yes("YES");
+        ASSERT_EQUALS(false, Token::Match(yes.front(), "%bool%"));
 
-        givenACodeSampleToTokenize positive("true", true);
-        ASSERT_EQUALS(true, Token::Match(positive.tokens(), "%bool%"));
+        const SimpleTokenList positive("true");
+        ASSERT_EQUALS(true, Token::Match(positive.front(), "%bool%"));
 
-        givenACodeSampleToTokenize negative("false", true);
-        ASSERT_EQUALS(true, Token::Match(negative.tokens(), "%bool%"));
+        const SimpleTokenList negative("false");
+        ASSERT_EQUALS(true, Token::Match(negative.front(), "%bool%"));
     }
 
     void matchOr() const {
-        givenACodeSampleToTokenize bitwiseOr(";|;", true);
-        ASSERT_EQUALS(true,  Token::Match(bitwiseOr.tokens(), "; %or%"));
-        ASSERT_EQUALS(true,  Token::Match(bitwiseOr.tokens(), "; %op%"));
-        ASSERT_EQUALS(false, Token::Match(bitwiseOr.tokens(), "; %oror%"));
-
-        givenACodeSampleToTokenize bitwiseOrAssignment(";|=;");
-        ASSERT_EQUALS(false,  Token::Match(bitwiseOrAssignment.tokens(), "; %or%"));
-        ASSERT_EQUALS(true,  Token::Match(bitwiseOrAssignment.tokens(), "; %op%"));
-        ASSERT_EQUALS(false, Token::Match(bitwiseOrAssignment.tokens(), "; %oror%"));
-
-        givenACodeSampleToTokenize logicalOr(";||;", true);
-        ASSERT_EQUALS(false, Token::Match(logicalOr.tokens(), "; %or%"));
-        ASSERT_EQUALS(true,  Token::Match(logicalOr.tokens(), "; %op%"));
-        ASSERT_EQUALS(true,  Token::Match(logicalOr.tokens(), "; %oror%"));
-        ASSERT_EQUALS(true,  Token::Match(logicalOr.tokens(), "; &&|%oror%"));
-        ASSERT_EQUALS(true,  Token::Match(logicalOr.tokens(), "; %oror%|&&"));
-
-        givenACodeSampleToTokenize logicalAnd(";&&;", true);
-        ASSERT_EQUALS(true, Token::simpleMatch(logicalAnd.tokens(), "; &&"));
-        ASSERT_EQUALS(true, Token::Match(logicalAnd.tokens(), "; &&|%oror%"));
-        ASSERT_EQUALS(true, Token::Match(logicalAnd.tokens(), "; %oror%|&&"));
+        const SimpleTokenList bitwiseOr(";|;");
+        ASSERT_EQUALS(true,  Token::Match(bitwiseOr.front(), "; %or%"));
+        ASSERT_EQUALS(true,  Token::Match(bitwiseOr.front(), "; %op%"));
+        ASSERT_EQUALS(false, Token::Match(bitwiseOr.front(), "; %oror%"));
+
+        const SimpleTokenList bitwiseOrAssignment(";|=;");
+        ASSERT_EQUALS(false,  Token::Match(bitwiseOrAssignment.front(), "; %or%"));
+        ASSERT_EQUALS(true,  Token::Match(bitwiseOrAssignment.front(), "; %op%"));
+        ASSERT_EQUALS(false, Token::Match(bitwiseOrAssignment.front(), "; %oror%"));
+
+        const SimpleTokenList logicalOr(";||;");
+        ASSERT_EQUALS(false, Token::Match(logicalOr.front(), "; %or%"));
+        ASSERT_EQUALS(true,  Token::Match(logicalOr.front(), "; %op%"));
+        ASSERT_EQUALS(true,  Token::Match(logicalOr.front(), "; %oror%"));
+        ASSERT_EQUALS(true,  Token::Match(logicalOr.front(), "; &&|%oror%"));
+        ASSERT_EQUALS(true,  Token::Match(logicalOr.front(), "; %oror%|&&"));
+
+        const SimpleTokenList logicalAnd(";&&;");
+        ASSERT_EQUALS(true, Token::simpleMatch(logicalAnd.front(), "; &&"));
+        ASSERT_EQUALS(true, Token::Match(logicalAnd.front(), "; &&|%oror%"));
+        ASSERT_EQUALS(true, Token::Match(logicalAnd.front(), "; %oror%|&&"));
     }
 
     static void append_vector(std::vector<std::string> &dest, const std::vector<std::string> &src) {
-        dest.insert(dest.end(), src.begin(), src.end());
+        dest.insert(dest.end(), src.cbegin(), src.cend());
     }
 
     void matchOp() {
@@ -618,18 +824,16 @@ class TestToken : public TestFixture {
         append_vector(test_ops, logicalOps);
         append_vector(test_ops, assignmentOps);
 
-        std::vector<std::string>::const_iterator test_op, test_ops_end = test_ops.end();
-        for (test_op = test_ops.begin(); test_op != test_ops_end; ++test_op) {
-            ASSERT_EQUALS(true, Match(*test_op, "%op%"));
-        }
+        ASSERT_EQUALS(true, std::all_of(test_ops.cbegin(), test_ops.cend(), [&](const std::string& s) {
+            return MatchCheck(s, "%op%");
+        }));
 
         // Negative test against other operators
         std::vector<std::string> other_ops;
         append_vector(other_ops, extendedOps);
 
-        std::vector<std::string>::const_iterator other_op, other_ops_end = other_ops.end();
-        for (other_op = other_ops.begin(); other_op != other_ops_end; ++other_op) {
-            ASSERT_EQUALS_MSG(false, Match(*other_op, "%op%"), "Failing other operator: " + *other_op);
+        for (auto other_op = other_ops.cbegin(); other_op != other_ops.cend(); ++other_op) {
+            ASSERT_EQUALS_MSG(false, MatchCheck(*other_op, "%op%"), "Failing other operator: " + *other_op);
         }
     }
 
@@ -640,27 +844,25 @@ class TestToken : public TestFixture {
         append_vector(test_ops, comparisonOps);
         append_vector(test_ops, logicalOps);
 
-        std::vector<std::string>::const_iterator test_op, test_ops_end = test_ops.end();
-        for (test_op = test_ops.begin(); test_op != test_ops_end; ++test_op) {
-            ASSERT_EQUALS(true, Match(*test_op, "%cop%"));
-        }
+        ASSERT_EQUALS(true, std::all_of(test_ops.cbegin(), test_ops.cend(), [&](const std::string& s) {
+            return MatchCheck(s, "%cop%");
+        }));
 
         // Negative test against other operators
         std::vector<std::string> other_ops;
         append_vector(other_ops, extendedOps);
         append_vector(other_ops, assignmentOps);
 
-        std::vector<std::string>::const_iterator other_op, other_ops_end = other_ops.end();
-        for (other_op = other_ops.begin(); other_op != other_ops_end; ++other_op) {
-            ASSERT_EQUALS_MSG(false, Match(*other_op, "%cop%"), "Failing other operator: " + *other_op);
+        for (auto other_op = other_ops.cbegin(); other_op != other_ops.cend(); ++other_op) {
+            ASSERT_EQUALS_MSG(false, MatchCheck(*other_op, "%cop%"), "Failing other operator: " + *other_op);
         }
     }
 
 
     void isArithmeticalOp() const {
-        std::vector<std::string>::const_iterator test_op, test_ops_end = arithmeticalOps.end();
-        for (test_op = arithmeticalOps.begin(); test_op != test_ops_end; ++test_op) {
-            Token tok;
+        for (auto test_op = arithmeticalOps.cbegin(); test_op != arithmeticalOps.cend(); ++test_op) {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list, std::move(tokensFrontBack));
             tok.str(*test_op);
             ASSERT_EQUALS(true, tok.isArithmeticalOp());
         }
@@ -673,9 +875,9 @@ class TestToken : public TestFixture {
         append_vector(other_ops, extendedOps);
         append_vector(other_ops, assignmentOps);
 
-        std::vector<std::string>::const_iterator other_op, other_ops_end = other_ops.end();
-        for (other_op = other_ops.begin(); other_op != other_ops_end; ++other_op) {
-            Token tok;
+        for (auto other_op = other_ops.cbegin(); other_op != other_ops.cend(); ++other_op) {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list, std::move(tokensFrontBack));
             tok.str(*other_op);
             ASSERT_EQUALS_MSG(false, tok.isArithmeticalOp(), "Failing arithmetical operator: " + *other_op);
         }
@@ -689,9 +891,9 @@ class TestToken : public TestFixture {
         append_vector(test_ops, logicalOps);
         append_vector(test_ops, assignmentOps);
 
-        std::vector<std::string>::const_iterator test_op, test_ops_end = test_ops.end();
-        for (test_op = test_ops.begin(); test_op != test_ops_end; ++test_op) {
-            Token tok;
+        for (auto test_op = test_ops.cbegin(); test_op != test_ops.cend(); ++test_op) {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list, std::move(tokensFrontBack));
             tok.str(*test_op);
             ASSERT_EQUALS(true, tok.isOp());
         }
@@ -700,9 +902,9 @@ class TestToken : public TestFixture {
         std::vector<std::string> other_ops;
         append_vector(other_ops, extendedOps);
 
-        std::vector<std::string>::const_iterator other_op, other_ops_end = other_ops.end();
-        for (other_op = other_ops.begin(); other_op != other_ops_end; ++other_op) {
-            Token tok;
+        for (auto other_op = other_ops.cbegin(); other_op != other_ops.cend(); ++other_op) {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list, std::move(tokensFrontBack));
             tok.str(*other_op);
             ASSERT_EQUALS_MSG(false, tok.isOp(), "Failing normal operator: " + *other_op);
         }
@@ -715,9 +917,9 @@ class TestToken : public TestFixture {
         append_vector(test_ops, comparisonOps);
         append_vector(test_ops, logicalOps);
 
-        std::vector<std::string>::const_iterator test_op, test_ops_end = test_ops.end();
-        for (test_op = test_ops.begin(); test_op != test_ops_end; ++test_op) {
-            Token tok;
+        for (auto test_op = test_ops.cbegin(); test_op != test_ops.cend(); ++test_op) {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list, std::move(tokensFrontBack));
             tok.str(*test_op);
             ASSERT_EQUALS(true, tok.isConstOp());
         }
@@ -727,9 +929,9 @@ class TestToken : public TestFixture {
         append_vector(other_ops, extendedOps);
         append_vector(other_ops, assignmentOps);
 
-        std::vector<std::string>::const_iterator other_op, other_ops_end = other_ops.end();
-        for (other_op = other_ops.begin(); other_op != other_ops_end; ++other_op) {
-            Token tok;
+        for (auto other_op = other_ops.cbegin(); other_op != other_ops.cend(); ++other_op) {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list, std::move(tokensFrontBack));
             tok.str(*other_op);
             ASSERT_EQUALS_MSG(false, tok.isConstOp(), "Failing normal operator: " + *other_op);
         }
@@ -743,26 +945,26 @@ class TestToken : public TestFixture {
         append_vector(test_ops, logicalOps);
         append_vector(test_ops, extendedOps);
 
-        std::vector<std::string>::const_iterator test_op, test_ops_end = test_ops.end();
-        for (test_op = test_ops.begin(); test_op != test_ops_end; ++test_op) {
-            Token tok;
+        for (auto test_op = test_ops.cbegin(); test_op != test_ops.cend(); ++test_op) {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list, std::move(tokensFrontBack));
             tok.str(*test_op);
             ASSERT_EQUALS(true, tok.isExtendedOp());
         }
 
         // Negative test against assignment operators
-        std::vector<std::string>::const_iterator other_op, other_ops_end = assignmentOps.end();
-        for (other_op = assignmentOps.begin(); other_op != other_ops_end; ++other_op) {
-            Token tok;
+        for (auto other_op = assignmentOps.cbegin(); other_op != assignmentOps.cend(); ++other_op) {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list, std::move(tokensFrontBack));
             tok.str(*other_op);
             ASSERT_EQUALS_MSG(false, tok.isExtendedOp(), "Failing assignment operator: " + *other_op);
         }
     }
 
     void isAssignmentOp() const {
-        std::vector<std::string>::const_iterator test_op, test_ops_end = assignmentOps.end();
-        for (test_op = assignmentOps.begin(); test_op != test_ops_end; ++test_op) {
-            Token tok;
+        for (auto test_op = assignmentOps.cbegin(); test_op != assignmentOps.cend(); ++test_op) {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list, std::move(tokensFrontBack));
             tok.str(*test_op);
             ASSERT_EQUALS(true, tok.isAssignmentOp());
         }
@@ -775,37 +977,41 @@ class TestToken : public TestFixture {
         append_vector(other_ops, logicalOps);
         append_vector(other_ops, extendedOps);
 
-        std::vector<std::string>::const_iterator other_op, other_ops_end = other_ops.end();
-        for (other_op = other_ops.begin(); other_op != other_ops_end; ++other_op) {
-            Token tok;
+        for (auto other_op = other_ops.cbegin(); other_op != other_ops.cend(); ++other_op) {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list, std::move(tokensFrontBack));
             tok.str(*other_op);
             ASSERT_EQUALS_MSG(false, tok.isAssignmentOp(), "Failing assignment operator: " + *other_op);
         }
     }
 
     void operators() const {
-        std::vector<std::string>::const_iterator test_op;
-        for (test_op = extendedOps.begin(); test_op != extendedOps.end(); ++test_op) {
-            Token tok;
+        for (auto test_op = extendedOps.cbegin(); test_op != extendedOps.cend(); ++test_op) {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list, std::move(tokensFrontBack));
             tok.str(*test_op);
             ASSERT_EQUALS(Token::eExtendedOp, tok.tokType());
         }
-        for (test_op = logicalOps.begin(); test_op != logicalOps.end(); ++test_op) {
-            Token tok;
+        for (auto test_op = logicalOps.cbegin(); test_op != logicalOps.cend(); ++test_op) {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list, std::move(tokensFrontBack));
             tok.str(*test_op);
             ASSERT_EQUALS(Token::eLogicalOp, tok.tokType());
         }
-        for (test_op = bitOps.begin(); test_op != bitOps.end(); ++test_op) {
-            Token tok;
+        for (auto test_op = bitOps.cbegin(); test_op != bitOps.cend(); ++test_op) {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list, std::move(tokensFrontBack));
             tok.str(*test_op);
             ASSERT_EQUALS(Token::eBitOp, tok.tokType());
         }
-        for (test_op = comparisonOps.begin(); test_op != comparisonOps.end(); ++test_op) {
-            Token tok;
+        for (auto test_op = comparisonOps.cbegin(); test_op != comparisonOps.cend(); ++test_op) {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list, std::move(tokensFrontBack));
             tok.str(*test_op);
             ASSERT_EQUALS(Token::eComparisonOp, tok.tokType());
         }
-        Token tok;
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token tok(list, std::move(tokensFrontBack));
         tok.str("++");
         ASSERT_EQUALS(Token::eIncDecOp, tok.tokType());
         tok.str("--");
@@ -813,7 +1019,8 @@ class TestToken : public TestFixture {
     }
 
     void literals() const {
-        Token tok;
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token tok(list, std::move(tokensFrontBack));
 
         tok.str("\"foo\"");
         ASSERT(tok.tokType() == Token::eString);
@@ -842,15 +1049,16 @@ class TestToken : public TestFixture {
         standard_types.emplace_back("double");
         standard_types.emplace_back("size_t");
 
-        std::vector<std::string>::const_iterator test_op, test_ops_end = standard_types.end();
-        for (test_op = standard_types.begin(); test_op != test_ops_end; ++test_op) {
-            Token tok;
+        for (auto test_op = standard_types.cbegin(); test_op != standard_types.cend(); ++test_op) {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list, std::move(tokensFrontBack));
             tok.str(*test_op);
             ASSERT_EQUALS_MSG(true, tok.isStandardType(), "Failing standard type: " + *test_op);
         }
 
         // Negative test
-        Token tok;
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token tok(list, std::move(tokensFrontBack));
         tok.str("string");
         ASSERT_EQUALS(false, tok.isStandardType());
 
@@ -866,7 +1074,8 @@ class TestToken : public TestFixture {
     }
 
     void updateProperties() const {
-        Token tok;
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token tok(list, std::move(tokensFrontBack));
         tok.str("foobar");
 
         ASSERT_EQUALS(true, tok.isName());
@@ -878,89 +1087,88 @@ class TestToken : public TestFixture {
         ASSERT_EQUALS(true, tok.isNumber());
     }
 
-    void updatePropertiesConcatStr() const {
-        Token tok;
-        tok.str("true");
-
-        ASSERT_EQUALS(true, tok.isBoolean());
-
-        tok.concatStr("123");
-
-        ASSERT_EQUALS(false, tok.isBoolean());
-        ASSERT_EQUALS("tru23", tok.str());
-    }
-
     void isNameGuarantees1() const {
-        Token tok;
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token tok(list, std::move(tokensFrontBack));
         tok.str("Name");
         ASSERT_EQUALS(true, tok.isName());
     }
 
     void isNameGuarantees2() const {
-        Token tok;
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token tok(list, std::move(tokensFrontBack));
         tok.str("_name");
         ASSERT_EQUALS(true, tok.isName());
     }
 
     void isNameGuarantees3() const {
-        Token tok;
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token tok(list, std::move(tokensFrontBack));
         tok.str("_123");
         ASSERT_EQUALS(true, tok.isName());
     }
 
     void isNameGuarantees4() const {
-        Token tok;
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token tok(list, std::move(tokensFrontBack));
         tok.str("123456");
         ASSERT_EQUALS(false, tok.isName());
         ASSERT_EQUALS(true, tok.isNumber());
     }
 
     void isNameGuarantees5() const {
-        Token tok;
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token tok(list, std::move(tokensFrontBack));
         tok.str("a123456");
         ASSERT_EQUALS(true, tok.isName());
         ASSERT_EQUALS(false, tok.isNumber());
     }
 
     void isNameGuarantees6() const {
-        Token tok;
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token tok(list, std::move(tokensFrontBack));
         tok.str("$f");
         ASSERT_EQUALS(true, tok.isName());
     }
 
-    void canFindMatchingBracketsNeedsOpen() const {
-        givenACodeSampleToTokenize var("std::deque<std::set<int> > intsets;");
+    void canFindMatchingBracketsNeedsOpen() {
+        SimpleTokenizer var(*this);
+        ASSERT(var.tokenize("std::deque<std::set<int> > intsets;"));
 
         const Token* const t = var.tokens()->findClosingBracket();
         ASSERT(t == nullptr);
     }
 
-    void canFindMatchingBracketsInnerPair() const {
-        givenACodeSampleToTokenize var("std::deque<std::set<int> > intsets;");
+    void canFindMatchingBracketsInnerPair() {
+        SimpleTokenizer var(*this);
+        ASSERT(var.tokenize("std::deque<std::set<int> > intsets;"));
 
         const Token * const t = var.tokens()->tokAt(7)->findClosingBracket();
         ASSERT_EQUALS(">", t->str());
         ASSERT(var.tokens()->tokAt(9) == t);
     }
 
-    void canFindMatchingBracketsOuterPair() const {
-        givenACodeSampleToTokenize var("std::deque<std::set<int> > intsets;");
+    void canFindMatchingBracketsOuterPair() {
+        SimpleTokenizer var(*this);
+        ASSERT(var.tokenize("std::deque<std::set<int> > intsets;"));
 
         const Token* const t = var.tokens()->tokAt(3)->findClosingBracket();
         ASSERT_EQUALS(">", t->str());
         ASSERT(var.tokens()->tokAt(10) == t);
     }
 
-    void canFindMatchingBracketsWithTooManyClosing() const {
-        givenACodeSampleToTokenize var("X< 1>2 > x1;\n");
+    void canFindMatchingBracketsWithTooManyClosing() {
+        SimpleTokenizer var(*this);
+        ASSERT(var.tokenize("X< 1>2 > x1;"));
 
         const Token* const t = var.tokens()->next()->findClosingBracket();
         ASSERT_EQUALS(">", t->str());
         ASSERT(var.tokens()->tokAt(3) == t);
     }
 
-    void canFindMatchingBracketsWithTooManyOpening() const {
-        givenACodeSampleToTokenize var("X < (2 < 1) > x1;\n");
+    void canFindMatchingBracketsWithTooManyOpening() {
+        SimpleTokenizer var(*this);
+        ASSERT(var.tokenize("X < (2 < 1) > x1;"));
 
         const Token* t = var.tokens()->next()->findClosingBracket();
         ASSERT(t != nullptr && t->str() == ">");
@@ -970,42 +1178,348 @@ class TestToken : public TestFixture {
     }
 
     void findClosingBracket() {
-        givenACodeSampleToTokenize var("template<typename X, typename...Y> struct S : public Fred<Wilma<Y...>> {}");
+        SimpleTokenizer var(*this);
+        ASSERT(var.tokenize("template<typename X, typename...Y> struct S : public Fred<Wilma<Y...>> {}"));
 
         const Token* const t = var.tokens()->next()->findClosingBracket();
         ASSERT(Token::simpleMatch(t, "> struct"));
     }
 
+    void findClosingBracket2() {
+        SimpleTokenizer var(*this); // #11275
+        ASSERT(var.tokenize("const auto g = []<typename T>() {};\n"));
+
+        const Token* const t = Token::findsimplematch(var.tokens(), "<");
+        ASSERT(t && Token::simpleMatch(t->findClosingBracket(), ">"));
+    }
+
+    void findClosingBracket3() {
+        SimpleTokenizer var(*this); // #12789
+        ASSERT(var.tokenize("template <size_t I = 0, typename... ArgsT, std::enable_if_t<I < sizeof...(ArgsT)>* = nullptr>\n"
+                            "void f();\n"));
+        const Token* const t = Token::findsimplematch(var.tokens(), "<");
+        ASSERT(t && Token::simpleMatch(t->findClosingBracket(), ">"));
+    }
+
+    void findClosingBracket4() {
+        SimpleTokenizer var(*this); // #12923
+        ASSERT(var.tokenize("template<template<class E> class T = std::vector, class U = std::vector<int>, class V = void>\n"
+                            "class C;\n"));
+        const Token *const t = Token::findsimplematch(var.tokens(), "<");
+        ASSERT(t);
+        const Token *const closing = t->findClosingBracket();
+        ASSERT(closing && closing == var.tokens()->tokAt(28));
+    }
+
     void expressionString() {
-        givenACodeSampleToTokenize var1("void f() { *((unsigned long long *)x) = 0; }");
+        SimpleTokenizer var1(*this);
+        ASSERT(var1.tokenize("void f() { *((unsigned long long *)x) = 0; }"));
         const Token *const tok1 = Token::findsimplematch(var1.tokens(), "*");
         ASSERT_EQUALS("*((unsigned long long*)x)", tok1->expressionString());
 
-        givenACodeSampleToTokenize var2("typedef unsigned long long u64; void f() { *((u64 *)x) = 0; }");
+        SimpleTokenizer var2(*this);
+        ASSERT(var2.tokenize("typedef unsigned long long u64; void f() { *((u64 *)x) = 0; }"));
         const Token *const tok2 = Token::findsimplematch(var2.tokens(), "*");
         ASSERT_EQUALS("*((unsigned long long*)x)", tok2->expressionString());
 
-        givenACodeSampleToTokenize data3("return (t){1,2};");
-        ASSERT_EQUALS("return(t){1,2}", data3.tokens()->expressionString());
+        SimpleTokenizer data3(*this);
+        ASSERT(data3.tokenize("void f() { return (t){1,2}; }"));
+        ASSERT_EQUALS("return(t){1,2}", data3.tokens()->tokAt(5)->expressionString());
+
+        SimpleTokenizer data4(*this);
+        ASSERT(data4.tokenize("void f() { return L\"a\"; }"));
+        ASSERT_EQUALS("returnL\"a\"", data4.tokens()->tokAt(5)->expressionString());
+
+        SimpleTokenizer data5(*this);
+        ASSERT(data5.tokenize("void f() { return U\"a\"; }"));
+        ASSERT_EQUALS("returnU\"a\"", data5.tokens()->tokAt(5)->expressionString());
 
-        givenACodeSampleToTokenize data4("return L\"a\";");
-        ASSERT_EQUALS("returnL\"a\"", data4.tokens()->expressionString());
+        SimpleTokenizer data6(*this);
+        ASSERT(data6.tokenize("x = \"\\0\\x1\\x2\\x3\\x4\\x5\\x6\\x7\";"));
+        ASSERT_EQUALS("x=\"\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\"", data6.tokens()->next()->expressionString());
     }
 
-    void hasKnownIntValue() {
+    void hasKnownIntValue() const {
         // pointer might be NULL
         ValueFlow::Value v1(0);
 
         // pointer points at buffer that is 2 bytes
         ValueFlow::Value v2(2);
-        v2.valueType = ValueFlow::Value::BUFFER_SIZE;
+        v2.valueType = ValueFlow::Value::ValueType::BUFFER_SIZE;
         v2.setKnown();
 
-        Token token;
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token token(list, std::move(tokensFrontBack));
         ASSERT_EQUALS(true, token.addValue(v1));
         ASSERT_EQUALS(true, token.addValue(v2));
         ASSERT_EQUALS(false, token.hasKnownIntValue());
     }
+
+#define assert_tok(...) _assert_tok(__FILE__, __LINE__, __VA_ARGS__)
+    void _assert_tok(const char* file, int line, const Token* tok, Token::Type t, bool l = false, bool std = false, bool ctrl = false) const
+    {
+        ASSERT_LOC_MSG(tok, "tok", file, line);
+        ASSERT_EQUALS_ENUM_LOC_MSG(t, tok->tokType(), "tokType", file, line);
+        ASSERT_EQUALS_LOC_MSG(l, tok->isLong(), "isLong", file, line);
+        ASSERT_EQUALS_LOC_MSG(std, tok->isStandardType(), "isStandardType", file, line);
+        ASSERT_EQUALS_LOC_MSG(ctrl, tok->isControlFlowKeyword(), "isControlFlowKeyword", file, line);
+    }
+
+    void _assert_tok(const char* file, int line, const std::string& s, Token::Type t, bool l = false, bool std = false, bool ctrl = false) const
+    {
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token tok(list, std::move(tokensFrontBack));
+        tok.str(s);
+        _assert_tok(file, line, &tok, t, l, std, ctrl);
+    }
+
+    void update_property_info() const
+    {
+        assert_tok("", Token::Type::eNone);
+        assert_tok("true", Token::Type::eBoolean);
+        assert_tok("false", Token::Type::eBoolean);
+        assert_tok("\"\"", Token::Type::eString);
+        assert_tok("L\"\"", Token::Type::eString, /*l=*/ true);
+        assert_tok("'a'", Token::Type::eChar);
+        assert_tok("L'a'", Token::Type::eChar, /*l=*/ true);
+        // eVariable has separate test
+        // eKeyword with specific languages and standards has separate tests
+        assert_tok("sizeof", Token::Type::eKeyword);
+        assert_tok("goto", Token::Type::eKeyword, /*l=*/ false, /*std=*/ false, /*ctrl=*/ true);
+        assert_tok("asm", Token::Type::eKeyword);
+        assert_tok("a", Token::Type::eName);
+        assert_tok("_a", Token::Type::eName);
+        assert_tok("$a", Token::Type::eName);
+        assert_tok("bool2", Token::Type::eName);
+        assert_tok("0", Token::Type::eNumber);
+        assert_tok("-0", Token::Type::eNumber);
+        assert_tok("+0", Token::Type::eNumber);
+        assert_tok("0xa", Token::Type::eNumber);
+        assert_tok("010", Token::Type::eNumber);
+        assert_tok("0b0", Token::Type::eNumber);
+        assert_tok("0.0", Token::Type::eNumber);
+        assert_tok("0x0.3p10", Token::Type::eNumber);
+        assert_tok("0z", Token::Type::eNumber); // TODO: not a valid number
+        assert_tok("0_km", Token::Type::eLiteral); // user literal
+        assert_tok("=", Token::Type::eAssignmentOp);
+        assert_tok("<<=", Token::Type::eAssignmentOp);
+        assert_tok(">>=", Token::Type::eAssignmentOp);
+        assert_tok("+=", Token::Type::eAssignmentOp);
+        assert_tok("-=", Token::Type::eAssignmentOp);
+        assert_tok("*=", Token::Type::eAssignmentOp);
+        assert_tok("/=", Token::Type::eAssignmentOp);
+        assert_tok("%=", Token::Type::eAssignmentOp);
+        assert_tok("&=", Token::Type::eAssignmentOp);
+        assert_tok("|=", Token::Type::eAssignmentOp);
+        assert_tok("^=", Token::Type::eAssignmentOp);
+        assert_tok(",", Token::Type::eExtendedOp);
+        assert_tok("[", Token::Type::eExtendedOp);
+        assert_tok("]", Token::Type::eExtendedOp);
+        assert_tok("(", Token::Type::eExtendedOp);
+        assert_tok(")", Token::Type::eExtendedOp);
+        assert_tok("?", Token::Type::eExtendedOp);
+        assert_tok(":", Token::Type::eExtendedOp);
+        assert_tok("<<", Token::Type::eArithmeticalOp);
+        assert_tok(">>", Token::Type::eArithmeticalOp);
+        assert_tok("+", Token::Type::eArithmeticalOp);
+        assert_tok("-", Token::Type::eArithmeticalOp);
+        assert_tok("*", Token::Type::eArithmeticalOp);
+        assert_tok("/", Token::Type::eArithmeticalOp);
+        assert_tok("%", Token::Type::eArithmeticalOp);
+        assert_tok("&", Token::Type::eBitOp);
+        assert_tok("|", Token::Type::eBitOp);
+        assert_tok("^", Token::Type::eBitOp);
+        assert_tok("~", Token::Type::eBitOp);
+        assert_tok("&&", Token::Type::eLogicalOp);
+        assert_tok("||", Token::Type::eLogicalOp);
+        assert_tok("!", Token::Type::eLogicalOp);
+        assert_tok("==", Token::Type::eComparisonOp);
+        assert_tok("!=", Token::Type::eComparisonOp);
+        assert_tok("<", Token::Type::eComparisonOp);
+        assert_tok("<=", Token::Type::eComparisonOp);
+        assert_tok(">", Token::Type::eComparisonOp);
+        assert_tok(">=", Token::Type::eComparisonOp);
+        // eComparisonOp with link has a separate test
+        assert_tok("<=>", Token::Type::eComparisonOp);
+        assert_tok("++", Token::Type::eIncDecOp);
+        assert_tok("--", Token::Type::eIncDecOp);
+        assert_tok("{", Token::Type::eBracket);
+        assert_tok("}", Token::Type::eBracket);
+        // < and > with link have a separate test
+        assert_tok("...", Token::Type::eEllipsis);
+        assert_tok(";", Token::Type::eOther);
+        // eType with specific languages and standards has separate tests
+        assert_tok("void", Token::Type::eType, /*l=*/ false, /*std=*/ true);
+    }
+
+    void update_property_info_evariable() const
+    {
+        {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list, std::move(tokensFrontBack));
+            tok.str("var1");
+            tok.varId(17);
+            assert_tok(&tok, Token::Type::eVariable);
+        }
+    }
+
+    void update_property_info_ekeyword_c() const
+    {
+        {
+            const Settings s = settingsBuilder().c(Standards::cstd_t::C89).build();
+            TokenList list_c{s, Standards::Language::C};
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list_c, std::move(tokensFrontBack));
+            tok.str("alignas"); // not a C89 keyword
+            assert_tok(&tok, Token::Type::eName);
+        }
+        {
+            TokenList list_c{settingsDefault, Standards::Language::C};
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list_c, std::move(tokensFrontBack));
+            tok.str("alignas"); // a C23 keyword
+            assert_tok(&tok, Token::Type::eKeyword);
+        }
+        {
+            TokenList list_c{settingsDefault, Standards::Language::C};
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list_c, std::move(tokensFrontBack));
+            tok.str("and_eq"); // a C++ keyword
+            assert_tok(&tok, Token::Type::eName);
+        }
+    }
+
+    void update_property_info_ekeyword_cpp() const
+    {
+        {
+            const Settings s = settingsBuilder().cpp(Standards::cppstd_t::CPP03).build();
+            TokenList list_cpp{s, Standards::Language::CPP};
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list_cpp, std::move(tokensFrontBack));
+            tok.str("consteval"); // not a C++03 keyword
+            assert_tok(&tok, Token::Type::eName);
+        }
+        {
+            TokenList list_cpp{settingsDefault, Standards::Language::CPP};
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list_cpp, std::move(tokensFrontBack));
+            tok.str("consteval"); // a C++20 keyword
+            assert_tok(&tok, Token::Type::eKeyword);
+        }
+        {
+            TokenList list_cpp{settingsDefault, Standards::Language::CPP};
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list_cpp, std::move(tokensFrontBack));
+            tok.str("typeof_unqual"); // a C keyword
+            assert_tok(&tok, Token::Type::eName);
+        }
+    }
+
+    void update_property_info_ebracket_link() const
+    {
+        {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list, tokensFrontBack);
+            tok.str("<");
+
+            Token tok2(list, std::move(tokensFrontBack));
+            tok.link(&tok2);
+            assert_tok(&tok, Token::Type::eBracket);
+        }
+
+        {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list, tokensFrontBack);
+
+            Token tok2(list, std::move(tokensFrontBack));
+            tok.link(&tok2);
+
+            tok.str("<");
+            assert_tok(&tok, Token::Type::eBracket);
+        }
+    }
+
+    void update_property_info_ecomparisonop_link() const
+    {
+        {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list, tokensFrontBack);
+            tok.str("==");
+
+            Token tok2(list, std::move(tokensFrontBack));
+            tok.link(&tok2); // TODO: does not (and probably should not) update
+            assert_tok(&tok, Token::Type::eComparisonOp);
+        }
+
+        {
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list, tokensFrontBack);
+
+            Token tok2(list, std::move(tokensFrontBack));
+            tok.link(&tok2);
+
+            tok.str("==");
+            assert_tok(&tok, Token::Type::eOther); // TODO: this looks wrong
+        }
+    }
+
+    void update_property_info_etype_c() const
+    {
+        {
+            TokenList list_c{settingsDefault, Standards::Language::C};
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list_c, std::move(tokensFrontBack));
+            tok.str("char"); // not treated as keyword in TokenList::isKeyword()
+            assert_tok(&tok, Token::Type::eType, /*l=*/ false, /*std=*/ true);
+        }
+        {
+            TokenList list_c{settingsDefault, Standards::Language::C};
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list_c, std::move(tokensFrontBack));
+            tok.str("size_t"); // not treated as keyword in TokenList::isKeyword()
+            assert_tok(&tok, Token::Type::eType, /*l=*/ false, /*std=*/ true);
+        }
+    }
+
+    void update_property_info_etype_cpp() const
+    {
+        {
+            TokenList list_cpp{settingsDefault, Standards::Language::CPP};
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list_cpp, std::move(tokensFrontBack));
+            tok.str("bool"); // not treated as keyword in TokenList::isKeyword()
+            assert_tok(&tok, Token::Type::eType, /*l=*/ false, /*std=*/ true);
+        }
+        {
+            TokenList list_cpp{settingsDefault, Standards::Language::CPP};
+            auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+            Token tok(list_cpp, std::move(tokensFrontBack));
+            tok.str("size_t");
+            assert_tok(&tok, Token::Type::eType, /*l=*/ false, /*std=*/ true);
+        }
+    }
+
+    void update_property_info_replace() const // #13743
+    {
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token tok(list, std::move(tokensFrontBack));
+        tok.str("size_t");
+        assert_tok(&tok, Token::Type::eType, false, true);
+        tok.str("long");
+        assert_tok(&tok, Token::Type::eType, false, true);
+    }
+
+    void varid_reset() const
+    {
+        TokenList list_c{settingsDefault, Standards::Language::C};
+        auto tokensFrontBack = std::make_shared<TokensFrontBack>();
+        Token tok(list_c, std::move(tokensFrontBack));
+        tok.str("int"); // not treated as keyword in TokenList::isKeyword()
+        assert_tok(&tok, Token::Type::eType, /*l=*/ false, /*std=*/ true);
+        tok.varId(0);
+        assert_tok(&tok, Token::Type::eType, /*l=*/ false, /*std=*/ true);
+    }
+#undef assert_tok
 };
 
 REGISTER_TEST(TestToken)
diff --git a/test/testtokenize.cpp b/test/testtokenize.cpp
index 513cfba712f..6eb47ec5f53 100644
--- a/test/testtokenize.cpp
+++ b/test/testtokenize.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,43 +16,54 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "config.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
+#include "path.h"
 #include "platform.h"
 #include "preprocessor.h" // usually tests here should not use preprocessor...
 #include "settings.h"
 #include "standards.h"
-#include "testsuite.h"
 #include "token.h"
 #include "tokenize.h"
 #include "tokenlist.h"
 
+#include <cstdint>
+#include <cstring>
 #include <list>
 #include <set>
 #include <sstream>
 #include <string>
+#include <utility>
+#include <vector>
 
-struct InternalError;
+#include <simplecpp.h>
+
+class ErrorLogger;
 
 class TestTokenizer : public TestFixture {
 public:
-    TestTokenizer() : TestFixture("TestTokenizer") {
-    }
+    TestTokenizer() : TestFixture("TestTokenizer") {}
 
 private:
-    Settings settings0;
-    Settings settings1;
-    Settings settings2;
-    Settings settings_windows;
-
-    void run() OVERRIDE {
-        LOAD_LIB_2(settings_windows.library, "windows.cfg");
-
+    const Settings settings1 = settingsBuilder().library("std.cfg").debugwarnings().build();
+    const Settings settings2 = settingsBuilder(settings1).cpp(Standards::CPP11).c(Standards::C11).build();
+    const Settings settings2_win32a = settingsBuilder(settings2).platform(Platform::Type::Win32A).build();
+    const Settings settings2_win32w = settingsBuilder(settings2).platform(Platform::Type::Win32W).build();
+    const Settings settings2_win64 = settingsBuilder(settings2).platform(Platform::Type::Win64).build();
+    const Settings settings2_unix32 = settingsBuilder(settings2).platform(Platform::Type::Unix32).build();
+    const Settings settings2_unix64 = settingsBuilder(settings2).platform(Platform::Type::Unix64).build();
+    const Settings settings3 = settingsBuilder().c(Standards::C89).cpp(Standards::CPP03).build();
+    const Settings settings_windows = settingsBuilder().library("windows.cfg").debugwarnings().cpp(Standards::CPP11).build();
+    const Settings settings_win32a = settingsBuilder(settings_windows).platform(Platform::Type::Win32A).build();
+    const Settings settings_win32w = settingsBuilder(settings_windows).platform(Platform::Type::Win32W).build();
+
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(tokenize1);
         TEST_CASE(tokenize2);
-        TEST_CASE(tokenize3);
         TEST_CASE(tokenize4);
         TEST_CASE(tokenize5);
-        TEST_CASE(tokenize6);   // array access. replace "*(p+1)" => "p[1]"
         TEST_CASE(tokenize7);
         TEST_CASE(tokenize8);
         TEST_CASE(tokenize9);
@@ -76,6 +87,11 @@ class TestTokenizer : public TestFixture {
         TEST_CASE(tokenize35);  // #8361
         TEST_CASE(tokenize36);  // #8436
         TEST_CASE(tokenize37);  // #8550
+        TEST_CASE(tokenize38);  // #9569
+        TEST_CASE(tokenize39);  // #9771
+        TEST_CASE(tokenize40);  // #13181
+        TEST_CASE(tokenize41);  // #13847
+        TEST_CASE(tokenize42);  // #13861
 
         TEST_CASE(validate);
 
@@ -83,6 +99,8 @@ class TestTokenizer : public TestFixture {
 
         TEST_CASE(syntax_case_default);
 
+        TEST_CASE(removePragma);
+
         TEST_CASE(foreach);     // #3690
         TEST_CASE(ifconstexpr);
 
@@ -92,24 +110,8 @@ class TestTokenizer : public TestFixture {
 
         TEST_CASE(longtok);
 
-        TEST_CASE(removeUnusedTemplates);
-
-        TEST_CASE(simplifyCasts1);
-        TEST_CASE(simplifyCasts2);
-        TEST_CASE(simplifyCasts3);
-        TEST_CASE(simplifyCasts4);
-        TEST_CASE(simplifyCasts5);
-        TEST_CASE(simplifyCasts7);
-        TEST_CASE(simplifyCasts8);
-        TEST_CASE(simplifyCasts9);
-        TEST_CASE(simplifyCasts10);
-        TEST_CASE(simplifyCasts11);
-        TEST_CASE(simplifyCasts12);
-        TEST_CASE(simplifyCasts13);
-        TEST_CASE(simplifyCasts14);
-        TEST_CASE(simplifyCasts15); // #5996 - don't remove cast in 'a+static_cast<int>(b?60:0)'
-        TEST_CASE(simplifyCasts16); // #6278
-        TEST_CASE(simplifyCasts17); // #6110 - don't remove any parentheses in 'a(b)(c)'
+        TEST_CASE(simplifyHeadersAndUnusedTemplates1);
+        TEST_CASE(simplifyHeadersAndUnusedTemplates2);
 
         TEST_CASE(simplifyAt);
 
@@ -123,7 +125,6 @@ class TestTokenizer : public TestFixture {
         TEST_CASE(ifAddBraces5);
         TEST_CASE(ifAddBraces7);
         TEST_CASE(ifAddBraces9);
-        TEST_CASE(ifAddBraces10);
         TEST_CASE(ifAddBraces11);
         TEST_CASE(ifAddBraces12);
         TEST_CASE(ifAddBraces13);
@@ -133,102 +134,35 @@ class TestTokenizer : public TestFixture {
         TEST_CASE(ifAddBraces18); // #3424 - if if { } else else
         TEST_CASE(ifAddBraces19); // #3928 - if for if else
         TEST_CASE(ifAddBraces20); // #5012 - syntax error 'else }'
-        TEST_CASE(ifAddBraces21); // #5332 - if (x) label: {} ..
+        TEST_CASE(ifAddBracesLabels); // #5332 - if (x) label: {} ..
+
+        TEST_CASE(switchAddBracesLabels);
 
         TEST_CASE(whileAddBraces);
+        TEST_CASE(whileAddBracesLabels);
+
         TEST_CASE(doWhileAddBraces);
+        TEST_CASE(doWhileAddBracesLabels);
 
         TEST_CASE(forAddBraces1);
         TEST_CASE(forAddBraces2); // #5088
+        TEST_CASE(forAddBracesLabels);
 
-        TEST_CASE(simplifyKnownVariables1);
-        TEST_CASE(simplifyKnownVariables2);
-        TEST_CASE(simplifyKnownVariables3);
-        TEST_CASE(simplifyKnownVariables4);
-        TEST_CASE(simplifyKnownVariables5);
-        TEST_CASE(simplifyKnownVariables6);
-        TEST_CASE(simplifyKnownVariables7);
-        TEST_CASE(simplifyKnownVariables8);
-        TEST_CASE(simplifyKnownVariables9);
-        TEST_CASE(simplifyKnownVariables10);
-        TEST_CASE(simplifyKnownVariables11);
-        TEST_CASE(simplifyKnownVariables13);
-        TEST_CASE(simplifyKnownVariables14);
-        TEST_CASE(simplifyKnownVariables15);
-        TEST_CASE(simplifyKnownVariables16);
-        TEST_CASE(simplifyKnownVariables17);
-        TEST_CASE(simplifyKnownVariables18);
-        TEST_CASE(simplifyKnownVariables19);
-        TEST_CASE(simplifyKnownVariables20);
-        TEST_CASE(simplifyKnownVariables21);
-        TEST_CASE(simplifyKnownVariables22);
-        TEST_CASE(simplifyKnownVariables23);
-        TEST_CASE(simplifyKnownVariables25);
-        TEST_CASE(simplifyKnownVariables27);
-        TEST_CASE(simplifyKnownVariables28);
-        TEST_CASE(simplifyKnownVariables29);    // ticket #1811
-        TEST_CASE(simplifyKnownVariables30);
-        TEST_CASE(simplifyKnownVariables31);
-        TEST_CASE(simplifyKnownVariables32);    // const
-        TEST_CASE(simplifyKnownVariables33);    // struct variable
-        TEST_CASE(simplifyKnownVariables34);
-        TEST_CASE(simplifyKnownVariables35);    // ticket #2353 - False positive: Division by zero 'if (x == 0) return 0; return 10 / x;'
-        TEST_CASE(simplifyKnownVariables36);    // ticket #2304 - known value for strcpy parameter
-        TEST_CASE(simplifyKnownVariables37);    // ticket #2398 - false positive caused by no simplification in for loop
-        TEST_CASE(simplifyKnownVariables38);    // ticket #2399 - simplify conditions
-        TEST_CASE(simplifyKnownVariables39);
-        TEST_CASE(simplifyKnownVariables40);
-        TEST_CASE(simplifyKnownVariables41);    // p=&x; if (p) ..
-        TEST_CASE(simplifyKnownVariables42);    // ticket #2031 - known string value after strcpy
-        TEST_CASE(simplifyKnownVariables43);
-        TEST_CASE(simplifyKnownVariables44);    // ticket #3117 - don't simplify static variables
-        TEST_CASE(simplifyKnownVariables45);    // ticket #3281 - static constant variable not simplified
-        TEST_CASE(simplifyKnownVariables46);    // ticket #3587 - >>
-        TEST_CASE(simplifyKnownVariables47);    // ticket #3627 - >>
-        TEST_CASE(simplifyKnownVariables48);    // ticket #3754 - wrong simplification in for loop header
-        TEST_CASE(simplifyKnownVariables49);    // #3691 - continue in switch
-        TEST_CASE(simplifyKnownVariables50);    // #4066 sprintf changes
-        TEST_CASE(simplifyKnownVariables51);    // #4409 hang
-        TEST_CASE(simplifyKnownVariables52);    // #4728 "= x %cop%"
-        TEST_CASE(simplifyKnownVariables53);    // references
-        TEST_CASE(simplifyKnownVariables54);    // #4913 'x' is not 0 after *--x=0;
-        TEST_CASE(simplifyKnownVariables55);    // pointer alias
-        TEST_CASE(simplifyKnownVariables56);    // ticket #5301 - >>
-        TEST_CASE(simplifyKnownVariables57);    // ticket #4724
-        TEST_CASE(simplifyKnownVariables58);    // ticket #5268
-        TEST_CASE(simplifyKnownVariables59);    // skip for header
-        TEST_CASE(simplifyKnownVariables60);    // #6829
-        TEST_CASE(simplifyKnownVariables61);    // #7805
-        TEST_CASE(simplifyKnownVariables62);    // #5666 - p=&str[0]
-        TEST_CASE(simplifyKnownVariablesBailOutAssign1);
-        TEST_CASE(simplifyKnownVariablesBailOutAssign2);
-        TEST_CASE(simplifyKnownVariablesBailOutAssign3); // #4395 - nested assignments
-        TEST_CASE(simplifyKnownVariablesBailOutFor1);
-        TEST_CASE(simplifyKnownVariablesBailOutFor2);
-        TEST_CASE(simplifyKnownVariablesBailOutFor3);
-        TEST_CASE(simplifyKnownVariablesBailOutMemberFunction);
-        TEST_CASE(simplifyKnownVariablesBailOutConditionalIncrement);
-        TEST_CASE(simplifyKnownVariablesBailOutSwitchBreak); // ticket #2324
-        TEST_CASE(simplifyKnownVariablesFloat);    // #2454 - float variable
-        TEST_CASE(simplifyKnownVariablesClassMember);  // #2815 - value of class member may be changed by function call
-        TEST_CASE(simplifyKnownVariablesFunctionCalls); // Function calls (don't assume pass by reference)
-        TEST_CASE(simplifyKnownVariablesGlobalVars);
-        TEST_CASE(simplifyKnownVariablesReturn);   // 3500 - return
-        TEST_CASE(simplifyKnownVariablesPointerAliasFunctionCall); // #7440
         TEST_CASE(simplifyExternC);
         TEST_CASE(simplifyKeyword); // #5842 - remove C99 static keyword between []
 
-        TEST_CASE(isZeroNumber);
         TEST_CASE(isOneNumber);
-        TEST_CASE(isTwoNumber);
 
         TEST_CASE(simplifyFunctionParameters);
         TEST_CASE(simplifyFunctionParameters1); // #3721
         TEST_CASE(simplifyFunctionParameters2); // #4430
         TEST_CASE(simplifyFunctionParameters3); // #4436
+        TEST_CASE(simplifyFunctionParameters4); // #9421
         TEST_CASE(simplifyFunctionParametersMultiTemplate);
         TEST_CASE(simplifyFunctionParametersErrors);
 
+        TEST_CASE(simplifyFunctionTryCatch);
+
         TEST_CASE(removeParentheses1);       // Ticket #61
         TEST_CASE(removeParentheses3);
         TEST_CASE(removeParentheses4);       // Ticket #390
@@ -252,16 +186,15 @@ class TestTokenizer : public TestFixture {
         TEST_CASE(removeParentheses22);
         TEST_CASE(removeParentheses23);      // Ticket #6103 - Infinite loop upon valid input
         TEST_CASE(removeParentheses24);      // Ticket #7040
+        TEST_CASE(removeParentheses25);      // daca@home - a=(b,c)
+        TEST_CASE(removeParentheses26);      // Ticket #8875 a[0](0)
+        TEST_CASE(removeParentheses27);
+        TEST_CASE(removeParentheses28);      // #12164 - don't remove parentheses in '(expr1) ? (expr2) : (expr3);'
+        TEST_CASE(removeParantheses29);      // #13735
+        TEST_CASE(removeParentheses30);
 
         TEST_CASE(tokenize_double);
         TEST_CASE(tokenize_strings);
-        TEST_CASE(simplify_constants);
-        TEST_CASE(simplify_constants2);
-        TEST_CASE(simplify_constants3);
-        TEST_CASE(simplify_constants4);
-        TEST_CASE(simplify_constants5);
-        TEST_CASE(simplify_constants6);     // Ticket #5625: Ternary operator as template parameter
-        TEST_CASE(simplifyMulAndParens);    // Ticket #2784 + #3184
 
         TEST_CASE(simplifyStructDecl);
 
@@ -293,8 +226,16 @@ class TestTokenizer : public TestFixture {
         TEST_CASE(vardecl25);  // #4799 - segmentation fault
         TEST_CASE(vardecl26);  // #5907 - incorrect handling of extern declarations
         TEST_CASE(vardecl27);  // #7850 - crash on valid C code
+        TEST_CASE(vardecl28);
+        TEST_CASE(vardecl29); // #9282
+        TEST_CASE(vardecl30);
+        TEST_CASE(vardecl31); // function pointer init
+        TEST_CASE(vardecl32);
+        TEST_CASE(vardecl33);
+        TEST_CASE(vardecl34);
         TEST_CASE(vardecl_stl_1);
         TEST_CASE(vardecl_stl_2);
+        TEST_CASE(vardecl_stl_3);
         TEST_CASE(vardecl_template_1);
         TEST_CASE(vardecl_template_2);
         TEST_CASE(vardecl_union);
@@ -305,37 +246,54 @@ class TestTokenizer : public TestFixture {
         TEST_CASE(volatile_variables);
 
         // unsigned i; => unsigned int i;
-        TEST_CASE(unsigned1);
-        TEST_CASE(unsigned2);
-        TEST_CASE(unsigned3);   // template arguments
+        TEST_CASE(implicitIntConst);
+        TEST_CASE(implicitIntExtern);
+        TEST_CASE(implicitIntSigned1);
+        TEST_CASE(implicitIntUnsigned1);
+        TEST_CASE(implicitIntUnsigned2);
+        TEST_CASE(implicitIntUnsigned3);   // template arguments
 
         TEST_CASE(simplifyStdType); // #4947, #4950, #4951
 
         TEST_CASE(createLinks);
         TEST_CASE(createLinks2);
-        TEST_CASE(signed1);
 
         TEST_CASE(simplifyString);
         TEST_CASE(simplifyConst);
         TEST_CASE(switchCase);
 
         TEST_CASE(simplifyPointerToStandardType);
-        TEST_CASE(functionpointer1);
-        TEST_CASE(functionpointer2);
-        TEST_CASE(functionpointer3);
-        TEST_CASE(functionpointer4);
-        TEST_CASE(functionpointer5);
-        TEST_CASE(functionpointer6);
-        TEST_CASE(functionpointer7);
-        TEST_CASE(functionpointer8); // #7410 - throw
-        TEST_CASE(functionpointer9); // #6113 - function call with function pointer
-
-        TEST_CASE(removeRedundantAssignment);
+        TEST_CASE(simplifyFunctionPointers1);
+        TEST_CASE(simplifyFunctionPointers2);
+        TEST_CASE(simplifyFunctionPointers3);
+        TEST_CASE(simplifyFunctionPointers4);
+        TEST_CASE(simplifyFunctionPointers5);
+        TEST_CASE(simplifyFunctionPointers6);
+        TEST_CASE(simplifyFunctionPointers7);
+        TEST_CASE(simplifyFunctionPointers8); // #7410 - throw
+        TEST_CASE(simplifyFunctionPointers9); // #6113 - function call with function pointer
 
         TEST_CASE(removedeclspec);
         TEST_CASE(removeattribute);
-        TEST_CASE(functionAttributeBefore);
-        TEST_CASE(functionAttributeAfter);
+        TEST_CASE(functionAttributeBefore1);
+        TEST_CASE(functionAttributeBefore2);
+        TEST_CASE(functionAttributeBefore3);
+        TEST_CASE(functionAttributeBefore4);
+        TEST_CASE(functionAttributeBefore5); // __declspec(dllexport)
+        TEST_CASE(functionAttributeAfter1);
+        TEST_CASE(functionAttributeAfter2);
+        TEST_CASE(functionAttributeListBefore);
+        TEST_CASE(functionAttributeListAfter);
+        TEST_CASE(functionAttributeListAfter2);
+        TEST_CASE(cppMaybeUnusedBefore);
+        TEST_CASE(cppMaybeUnusedAfter1);
+        TEST_CASE(cppMaybeUnusedAfter2);
+        TEST_CASE(cppMaybeUnusedStructuredBinding);
+
+        TEST_CASE(attributeAlignasBefore);
+        TEST_CASE(attributeAlignasAfter);
+
+        TEST_CASE(splitTemplateRightAngleBrackets);
 
         TEST_CASE(cpp03template1);
         TEST_CASE(cpp0xtemplate1);
@@ -346,11 +304,14 @@ class TestTokenizer : public TestFixture {
         TEST_CASE(cpp14template); // Ticket #6708
 
         TEST_CASE(arraySize);
+        TEST_CASE(arraySizeAfterValueFlow);
 
         TEST_CASE(labels);
         TEST_CASE(simplifyInitVar);
         TEST_CASE(simplifyInitVar2);
         TEST_CASE(simplifyInitVar3);
+        TEST_CASE(simplifyInitVar4);
+        TEST_CASE(simplifyInitVar5);
 
         TEST_CASE(bitfields1);
         TEST_CASE(bitfields2);
@@ -364,9 +325,13 @@ class TestTokenizer : public TestFixture {
         TEST_CASE(bitfields10);
         TEST_CASE(bitfields12); // ticket #3485 (segmentation fault)
         TEST_CASE(bitfields13); // ticket #3502 (segmentation fault)
-        TEST_CASE(bitfields14); // ticket #4561 (segfault for 'class a { signals: };')
         TEST_CASE(bitfields15); // ticket #7747 (enum Foo {A,B}:4;)
         TEST_CASE(bitfields16); // Save bitfield bit count
+        TEST_CASE(bitfields17);
+        TEST_CASE(bitfields18);
+        TEST_CASE(bitfields19); // ticket #13733
+        TEST_CASE(bitfields20);
+        TEST_CASE(bitfields21);
 
         TEST_CASE(simplifyNamespaceStd);
 
@@ -374,17 +339,12 @@ class TestTokenizer : public TestFixture {
         TEST_CASE(microsoftString);
 
         TEST_CASE(borland);
-
-        TEST_CASE(Qt);
-
         TEST_CASE(simplifySQL);
 
         TEST_CASE(simplifyCAlternativeTokens);
 
-        TEST_CASE(simplifyCalculations);
-
         // x = ({ 123; });  =>  { x = 123; }
-        TEST_CASE(simplifyRoundCurlyParentheses);
+        TEST_CASE(simplifyCompoundStatements);
 
         TEST_CASE(simplifyOperatorName1);
         TEST_CASE(simplifyOperatorName2);
@@ -400,24 +360,43 @@ class TestTokenizer : public TestFixture {
         TEST_CASE(simplifyOperatorName12); // #9110
         TEST_CASE(simplifyOperatorName13); // user defined literal
         TEST_CASE(simplifyOperatorName14); // std::complex operator "" if
+        TEST_CASE(simplifyOperatorName15); // ticket #9468 syntaxError
+        TEST_CASE(simplifyOperatorName16); // ticket #9472
+        TEST_CASE(simplifyOperatorName17);
+        TEST_CASE(simplifyOperatorName18); // global namespace
+        TEST_CASE(simplifyOperatorName19);
+        TEST_CASE(simplifyOperatorName20);
+        TEST_CASE(simplifyOperatorName21);
+        TEST_CASE(simplifyOperatorName22);
+        TEST_CASE(simplifyOperatorName23);
+        TEST_CASE(simplifyOperatorName24);
+        TEST_CASE(simplifyOperatorName25);
+        TEST_CASE(simplifyOperatorName26);
+        TEST_CASE(simplifyOperatorName27);
+        TEST_CASE(simplifyOperatorName28);
+        TEST_CASE(simplifyOperatorName29); // spaceship operator
+        TEST_CASE(simplifyOperatorName30);
+        TEST_CASE(simplifyOperatorName31); // #6342
+        TEST_CASE(simplifyOperatorName32); // #10256
+        TEST_CASE(simplifyOperatorName33); // #10138
+
+        TEST_CASE(simplifyOverloadedOperators1);
+        TEST_CASE(simplifyOverloadedOperators2); // (*this)(123)
+        TEST_CASE(simplifyOverloadedOperators3); // #9881 - hang
 
         TEST_CASE(simplifyNullArray);
 
         // Some simple cleanups of unhandled macros in the global scope
         TEST_CASE(removeMacrosInGlobalScope);
-        TEST_CASE(removeMacroInVarDecl);
+
+        TEST_CASE(addSemicolonAfterUnknownMacro);
 
         // a = b = 0;
         TEST_CASE(multipleAssignment);
 
-        TEST_CASE(sizeOfCharLiteral);
         TEST_CASE(platformWin);
-        TEST_CASE(platformWin32);
         TEST_CASE(platformWin32A);
         TEST_CASE(platformWin32W);
-        TEST_CASE(platformWin64);
-        TEST_CASE(platformUnix32);
-        TEST_CASE(platformUnix64);
         TEST_CASE(platformWin32AStringCat); // ticket #5015
         TEST_CASE(platformWin32WStringCat); // ticket #5015
         TEST_CASE(platformWinWithNamespace);
@@ -428,7 +407,7 @@ class TestTokenizer : public TestFixture {
 
         TEST_CASE(simplifyCaseRange);
 
-        TEST_CASE(compileLimits); // #5592 crash: gcc: testsuit: gcc.c-torture/compile/limits-declparen.c
+        TEST_CASE(simplifyEmptyNamespaces);
 
         TEST_CASE(prepareTernaryOpForAST);
 
@@ -441,10 +420,23 @@ class TestTokenizer : public TestFixture {
         TEST_CASE(astunaryop);
         TEST_CASE(astfunction);
         TEST_CASE(asttemplate);
+        TEST_CASE(astrequires);
         TEST_CASE(astcast);
         TEST_CASE(astlambda);
         TEST_CASE(astcase);
+        TEST_CASE(astrefqualifier);
+        TEST_CASE(astthrowdelete);
+        TEST_CASE(asttrailingdecltype);
+        TEST_CASE(astnoexcept);
         TEST_CASE(astvardecl);
+        TEST_CASE(astnewscoped);
+        TEST_CASE(astdecltypescope);
+        TEST_CASE(astdesignatedinit);
+        TEST_CASE(astrvaluedecl);
+        TEST_CASE(astorkeyword);
+        TEST_CASE(astenumdecl);
+        TEST_CASE(astcompound);
+        TEST_CASE(astfuncdecl);
 
         TEST_CASE(startOfExecutableScope);
 
@@ -452,6 +444,8 @@ class TestTokenizer : public TestFixture {
 
         TEST_CASE(sizeofAddParentheses);
 
+        TEST_CASE(reportUnknownMacros);
+
         // Make sure the Tokenizer::findGarbageCode() does not have false positives
         // The TestGarbage ensures that there are true positives
         TEST_CASE(findGarbageCode);
@@ -459,112 +453,168 @@ class TestTokenizer : public TestFixture {
         TEST_CASE(checkTemplates);
         TEST_CASE(checkNamespaces);
         TEST_CASE(checkLambdas);
+        TEST_CASE(checkIfCppCast);
+        TEST_CASE(checkRefQualifiers);
+        TEST_CASE(checkConditionBlock);
+        TEST_CASE(checkUnknownCircularVar);
+        TEST_CASE(checkRequires);
 
         // #9052
         TEST_CASE(noCrash1);
         TEST_CASE(noCrash2);
+        TEST_CASE(noCrash3);
+        TEST_CASE(noCrash4);
+        TEST_CASE(noCrash5); // #10603
+        TEST_CASE(noCrash6); // #10212
+        TEST_CASE(noCrash7);
 
         // --check-config
         TEST_CASE(checkConfiguration);
 
-        TEST_CASE(unknownType); // #8952
-
         TEST_CASE(unknownMacroBeforeReturn);
-    }
 
-    std::string tokenizeAndStringify(const char code[], bool simplify = false, bool expand = true, Settings::PlatformType platform = Settings::Native, const char* filename = "test.cpp", bool cpp11 = true) {
-        errout.str("");
+        TEST_CASE(cppKeywordInCSource);
 
-        settings1.debugwarnings = true;
-        settings1.platform(platform);
-        settings1.standards.cpp = cpp11 ? Standards::CPP11 : Standards::CPP03;
+        TEST_CASE(cppcast);
 
-        // tokenize..
-        Tokenizer tokenizer(&settings1, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, filename);
-        if (simplify)
-            tokenizer.simplifyTokenList2();
-
-        // filter out ValueFlow messages..
-        const std::string debugwarnings = errout.str();
-        errout.str("");
-        std::istringstream istr2(debugwarnings);
-        std::string line;
-        while (std::getline(istr2,line)) {
-            if (line.find("valueflow.cpp") == std::string::npos)
-                errout << line << "\n";
-        }
+        TEST_CASE(checkHeader1);
 
-        if (tokenizer.tokens())
-            return tokenizer.tokens()->stringifyList(false, expand, false, true, false, nullptr, nullptr);
-        else
-            return "";
+        TEST_CASE(removeExtraTemplateKeywords);
+
+        TEST_CASE(removeAlignas1);
+        TEST_CASE(removeAlignas2); // Do not remove alignof in the same way
+        TEST_CASE(removeAlignas3); // remove alignas in C11 code
+        TEST_CASE(dumpAlignas);
+
+        TEST_CASE(simplifyCoroutines);
+
+        TEST_CASE(simplifySpaceshipOperator);
+
+        TEST_CASE(simplifyIfSwitchForInit1);
+        TEST_CASE(simplifyIfSwitchForInit2);
+        TEST_CASE(simplifyIfSwitchForInit3);
+        TEST_CASE(simplifyIfSwitchForInit4);
+        TEST_CASE(simplifyIfSwitchForInit5);
+
+        TEST_CASE(newPlacementArgsCppInit); // #13775
+
+        TEST_CASE(cpp20_default_bitfield_initializer);
+
+        TEST_CASE(cpp11init);
+
+        TEST_CASE(testDirectiveIncludeTypes);
+        TEST_CASE(testDirectiveIncludeLocations);
+        TEST_CASE(testDirectiveIncludeComments);
+        TEST_CASE(testDirectiveRelativePath);
+
+        TEST_CASE(funcnameInParenthesis1); // #13554
+        TEST_CASE(funcnameInParenthesis2); // #13578
+        TEST_CASE(funcnameInParenthesis3); // #13585
+
+        TEST_CASE(genericInIf); // #13561
+
+        TEST_CASE(preincrementInLambda); // #13312
+
+        TEST_CASE(atomicCast); // #12605
+        TEST_CASE(constFunctionPtrTypedef); // #12135
+
+        TEST_CASE(simplifyPlatformTypes);
+
+        TEST_CASE(dumpFallthrough);
+
+        TEST_CASE(simplifyRedundantParentheses);
+
+        TEST_CASE(simplifyEnum1);
+
+        TEST_CASE(simplifyEnum2);
     }
 
-    std::string tokenizeAndStringifyWindows(const char code[], bool simplify = false, bool expand = true, Settings::PlatformType platform = Settings::Native, const char* filename = "test.cpp", bool cpp11 = true) {
-        errout.str("");
+    class TokenizerTest final : public Tokenizer
+    {
+        friend class TestTokenizer;
+    public:
+        TokenizerTest(TokenList tokenList, ErrorLogger &errorLogger)
+            : Tokenizer(std::move(tokenList), errorLogger)
+        {}
+    };
 
-        settings_windows.debugwarnings = true;
-        settings_windows.platform(platform);
-        settings_windows.standards.cpp = cpp11 ? Standards::CPP11 : Standards::CPP03;
+    struct TokenizeOptions
+    {
+        bool expand = true;
+        bool cpp = true;
+    };
 
+#define tokenizeAndStringify(...) tokenizeAndStringify_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    std::string tokenizeAndStringify_(const char* file, int linenr, const char (&code)[size], const TokenizeOptions& opt = make_default_obj{}) {
         // tokenize..
-        Tokenizer tokenizer(&settings_windows, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, filename);
-        if (simplify)
-            tokenizer.simplifyTokenList2();
-
-        // filter out ValueFlow messages..
-        const std::string debugwarnings = errout.str();
-        errout.str("");
-        std::istringstream istr2(debugwarnings);
-        std::string line;
-        while (std::getline(istr2,line)) {
-            if (line.find("valueflow.cpp") == std::string::npos)
-                errout << line << "\n";
-        }
+        SimpleTokenizer tokenizer(settings2, *this, opt.cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, linenr);
 
         if (tokenizer.tokens())
-            return tokenizer.tokens()->stringifyList(false, expand, false, true, false, nullptr, nullptr);
-        else
-            return "";
+            return tokenizer.tokens()->stringifyList(false, opt.expand, false, true, false, nullptr, nullptr);
+        return "";
     }
 
-    std::string tokenizeAndStringify(const char code[], const Settings &settings) {
-        errout.str("");
+    // TODO: get rid of this
+    std::string tokenizeAndStringify_(const char* file, int linenr, const std::string& code) {
+        SimpleTokenizer tokenizer(settings2, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, linenr);
+
+        if (tokenizer.tokens())
+            return tokenizer.tokens()->stringifyList(false, true, false, true, false, nullptr, nullptr);
+        return "";
+    }
 
+    template<size_t size>
+    std::string tokenizeAndStringify_(const char* file, int line, const char (&code)[size], const Settings &settings, bool cpp = true, bool expand = true) {
         // tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this, cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
         if (!tokenizer.tokens())
             return "";
-        return tokenizer.tokens()->stringifyList(false, true, false, true, false, nullptr, nullptr);
+        return tokenizer.tokens()->stringifyList(false, expand, false, true, false, nullptr, nullptr);
     }
 
-    std::string tokenizeDebugListing(const char code[], bool simplify = false, const char filename[] = "test.cpp") {
-        errout.str("");
+#define tokenizeDebugListing(...) tokenizeDebugListing_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    std::string tokenizeDebugListing_(const char* file, int line, const char (&code)[size], bool cpp = true) {
+        SimpleTokenizer tokenizer(settings3, *this, cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+
+        // result..
+        return tokenizer.tokens()->stringifyList(true,true,true,true,false);
+    }
 
-        settings2.standards.c = Standards::C89;
-        settings2.standards.cpp = Standards::CPP03;
+    template<size_t size>
+    void directiveDump(const char (&code)[size], std::ostream& ostr) {
+        directiveDump(code, "test.c", settingsDefault, ostr);
+    }
 
-        Tokenizer tokenizer(&settings2, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, filename);
+    template<size_t size>
+    void directiveDump(const char (&code)[size], const char filename[], const Settings& settings, std::ostream& ostr) {
+        simplecpp::OutputList outputList;
+        std::vector<std::string> files;
+        simplecpp::TokenList tokens1(code, files, filename, &outputList);
+        Preprocessor preprocessor(tokens1, settings, *this, Path::identify(tokens1.getFiles()[0], false));
+        (void)preprocessor.reportOutput(outputList, true);
+        ASSERT(preprocessor.loadFiles(files));
+        std::list<Directive> directives = preprocessor.createDirectives();
 
-        if (simplify)
-            tokenizer.simplifyTokenList2();
+        TokenList tokenlist{settings, Path::identify(filename, false)};
+        Tokenizer tokenizer(std::move(tokenlist), *this);
+        tokenizer.setDirectives(std::move(directives));
 
-        // result..
-        return tokenizer.tokens()->stringifyList(true,true,true,true,false);
+        tokenizer.dump(ostr);
     }
 
     void tokenize1() {
         const char code[] = "void f ( )\n"
                             "{ if ( p . y ( ) > yof ) { } }";
         ASSERT_EQUALS(code, tokenizeAndStringify(code));
+        ASSERT_EQUALS(
+            "[test.cpp:2:20]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable yof [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
     }
 
     void tokenize2() {
@@ -572,20 +622,6 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("{ sizeof ( a ) , sizeof ( b ) }", tokenizeAndStringify(code));
     }
 
-    void tokenize3() {
-        const char code[] = "void foo()\n"
-                            "{\n"
-                            "    int i;\n"
-                            "    ABC(for(i=0;i<10;i++) x());\n"
-                            "}";
-        ASSERT_EQUALS("void foo ( )\n"
-                      "{\n"
-                      "int i ;\n"
-                      "ABC ( for ( i = 0 ; i < 10 ; i ++ ) x ( ) ) ;\n"
-                      "}", tokenizeAndStringify(code));
-        ASSERT_EQUALS("", errout.str());
-    }
-
     void tokenize4() {
         const char code[] = "class foo\n"
                             "{\n"
@@ -597,7 +633,7 @@ class TestTokenizer : public TestFixture {
                       "public:\n"
                       "const int i ;\n"
                       "}", tokenizeAndStringify(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void tokenize5() {
@@ -606,56 +642,13 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("; 1E-2 ;", tokenizeAndStringify("; 1E-2 ;"));
     }
 
-    void tokenize6() {
-        // "&p[1]" => "p+1"
-        /*
-        ASSERT_EQUALS("; x = p + n ;", tokenizeAndStringify("; x = & p [ n ] ;", true));
-        ASSERT_EQUALS("; x = ( p + n ) [ m ] ;", tokenizeAndStringify("; x = & p [ n ] [ m ] ;", true));
-        ASSERT_EQUALS("; x = y & p [ n ] ;", tokenizeAndStringify("; x = y & p [ n ] ;", true));
-        ASSERT_EQUALS("; x = 10 & p [ n ] ;", tokenizeAndStringify(";  x = 10 & p [ n ] ;", true));
-        ASSERT_EQUALS("; x = y [ 10 ] & p [ n ] ;", tokenizeAndStringify("; x = y [ 10 ] & p [ n ] ;", true));
-        ASSERT_EQUALS("; x = ( a + m ) & p [ n ] ;", tokenizeAndStringify("; x = ( a + m ) & p [ n ] ;", true));*/
-        // "*(p+1)" => "p[1]"
-        ASSERT_EQUALS("; x = p [ 1 ] ;", tokenizeAndStringify("; x = * ( p + 1 ) ;", true));
-        ASSERT_EQUALS("; x = p [ 10 ] ;", tokenizeAndStringify("; x = * ( p + 0xA ) ;", true));
-        ASSERT_EQUALS("; x = p [ n ] ;", tokenizeAndStringify("; x = * ( p + n ) ;", true));
-        ASSERT_EQUALS("; x = y * ( p + n ) ;", tokenizeAndStringify("; x = y * ( p + n ) ;", true));
-        ASSERT_EQUALS("; x = 10 * ( p + n ) ;", tokenizeAndStringify("; x = 10 * ( p + n ) ;", true));
-        ASSERT_EQUALS("; x = y [ 10 ] * ( p + n ) ;", tokenizeAndStringify("; x = y [ 10 ] * ( p + n ) ;", true));
-        ASSERT_EQUALS("; x = ( a + m ) * ( p + n ) ;", tokenizeAndStringify("; x = ( a + m ) * ( p + n ) ;", true));
-
-        // "*(p-1)" => "p[-1]" and "*(p-n)" => "p[-n]"
-        ASSERT_EQUALS("; x = p [ -1 ] ;", tokenizeAndStringify("; x = *(p - 1);", true));
-        ASSERT_EQUALS("; x = p [ -10 ] ;", tokenizeAndStringify("; x = *(p - 0xA);", true));
-        ASSERT_EQUALS("; x = p [ - n ] ;", tokenizeAndStringify("; x = *(p - n);", true));
-        ASSERT_EQUALS("; x = y * ( p - 1 ) ;", tokenizeAndStringify("; x = y * (p - 1);", true));
-        ASSERT_EQUALS("; x = 10 * ( p - 1 ) ;", tokenizeAndStringify("; x = 10 * (p - 1);", true));
-        ASSERT_EQUALS("; x = y [ 10 ] * ( p - 1 ) ;", tokenizeAndStringify("; x = y[10] * (p - 1);", true));
-        ASSERT_EQUALS("; x = ( a - m ) * ( p - n ) ;", tokenizeAndStringify("; x = (a - m) * (p - n);", true));
-
-        // Test that the array-index simplification is not applied when there's no dereference:
-        // "(x-y)" => "(x-y)" and "(x+y)" => "(x+y)"
-        ASSERT_EQUALS("; a = b * ( x - y ) ;", tokenizeAndStringify("; a = b * (x - y);", true));
-        ASSERT_EQUALS("; a = b * x [ - y ] ;", tokenizeAndStringify("; a = b * *(x - y);", true));
-        ASSERT_EQUALS("; a = a * ( x - y ) ;", tokenizeAndStringify("; a *= (x - y);", true));
-        ASSERT_EQUALS("; z = a ++ * ( x - y ) ;", tokenizeAndStringify("; z = a++ * (x - y);", true));
-        ASSERT_EQUALS("; z = a ++ * ( x + y ) ;", tokenizeAndStringify("; z = a++ * (x + y);", true));
-        ASSERT_EQUALS("; z = a -- * ( x - y ) ;", tokenizeAndStringify("; z = a-- * (x - y);", true));
-        ASSERT_EQUALS("; z = a -- * ( x + y ) ;", tokenizeAndStringify("; z = a-- * (x + y);", true));
-        ASSERT_EQUALS("; z = 'a' * ( x - y ) ;", tokenizeAndStringify("; z = 'a' * (x - y);", true));
-        ASSERT_EQUALS("; z = \"a\" * ( x - y ) ;", tokenizeAndStringify("; z = \"a\" * (x - y);", true));
-        ASSERT_EQUALS("; z = 'a' * ( x + y ) ;", tokenizeAndStringify("; z = 'a' * (x + y);", true));
-        ASSERT_EQUALS("; z = \"a\" * ( x + y ) ;", tokenizeAndStringify("; z = \"a\" * (x + y);", true));
-        ASSERT_EQUALS("; z = foo ( ) * ( x + y ) ;", tokenizeAndStringify("; z = foo() * (x + y);", true));
-    }
-
     void tokenize7() {
         const char code[] = "void f() {\n"
                             "    int x1 = 1;\n"
                             "    int x2(x1);\n"
                             "}\n";
-        ASSERT_EQUALS("void f ( ) {\nint x1 ; x1 = 1 ;\nint x2 ; x2 = x1 ;\n}",
-                      tokenizeAndStringify(code, false));
+        ASSERT_EQUALS("void f ( ) {\nint x1 ; x1 = 1 ;\nint x2 ( x1 ) ;\n}",
+                      tokenizeAndStringify(code));
     }
 
     void tokenize8() {
@@ -664,10 +657,10 @@ class TestTokenizer : public TestFixture {
                             "    int x2(x1);\n"
                             "}\n";
         ASSERT_EQUALS("1: void f ( ) {\n"
-                      "2: int x1@1 ; x1@1 = g ( ) ;\n"
-                      "3: int x2@2 ; x2@2 = x1@1 ;\n"
+                      "2: int x1@1 ( g ( ) ) ;\n"
+                      "3: int x2@2 ( x1@1 ) ;\n"
                       "4: }\n",
-                      tokenizeDebugListing(code, false));
+                      tokenizeDebugListing(code));
     }
 
     void tokenize9() {
@@ -676,12 +669,12 @@ class TestTokenizer : public TestFixture {
                             "void f() {\n"
                             "    fpp x = (fpp)f();\n"
                             "}";
-        tokenizeAndStringify(code, false);
-        ASSERT_EQUALS("", errout.str());
+        (void)tokenizeAndStringify(code);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void tokenize11() {
-        ASSERT_EQUALS("X * sizeof ( Y ( ) ) ;", tokenizeAndStringify("X * sizeof(Y());", false));
+        ASSERT_EQUALS("X * sizeof ( Y ( ) ) ;", tokenizeAndStringify("X * sizeof(Y());"));
     }
 
     // bailout if there is "@" - it is not handled well
@@ -690,26 +683,26 @@ class TestTokenizer : public TestFixture {
                             "-(Foo *)foo: (Bar *)bar\n"
                             "{ }\n"
                             "@end\n";
-        ASSERT_THROW(tokenizeAndStringify(code), InternalError);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(code), SYNTAX);
     }
 
     // Ticket #2361: 0X10 => 16
     void tokenize14() {
-        ASSERT_EQUALS("; 16 ;", tokenizeAndStringify(";0x10;"));
-        ASSERT_EQUALS("; 16 ;", tokenizeAndStringify(";0X10;"));
-        ASSERT_EQUALS("; 292 ;", tokenizeAndStringify(";0444;"));
+        ASSERT_EQUALS("; 0x10 ;", tokenizeAndStringify(";0x10;"));
+        ASSERT_EQUALS("; 0X10 ;", tokenizeAndStringify(";0X10;"));
+        ASSERT_EQUALS("; 0444 ;", tokenizeAndStringify(";0444;"));
     }
 
     // Ticket #8050
     void tokenizeHexWithSuffix() {
-        ASSERT_EQUALS("; 16777215 ;", tokenizeAndStringify(";0xFFFFFF;"));
-        ASSERT_EQUALS("; 16777215U ;", tokenizeAndStringify(";0xFFFFFFu;"));
-        ASSERT_EQUALS("; 16777215UL ;", tokenizeAndStringify(";0xFFFFFFul;"));
+        ASSERT_EQUALS("; 0xFFFFFF ;", tokenizeAndStringify(";0xFFFFFF;"));
+        ASSERT_EQUALS("; 0xFFFFFFu ;", tokenizeAndStringify(";0xFFFFFFu;"));
+        ASSERT_EQUALS("; 0xFFFFFFul ;", tokenizeAndStringify(";0xFFFFFFul;"));
 
         // Number of digits decides about internal representation...
-        ASSERT_EQUALS("; 4294967295U ;", tokenizeAndStringify(";0xFFFFFFFF;"));
-        ASSERT_EQUALS("; 4294967295U ;", tokenizeAndStringify(";0xFFFFFFFFu;"));
-        ASSERT_EQUALS("; 4294967295UL ;", tokenizeAndStringify(";0xFFFFFFFFul;"));
+        ASSERT_EQUALS("; 0xFFFFFFFF ;", tokenizeAndStringify(";0xFFFFFFFF;"));
+        ASSERT_EQUALS("; 0xFFFFFFFFu ;", tokenizeAndStringify(";0xFFFFFFFFu;"));
+        ASSERT_EQUALS("; 0xFFFFFFFFul ;", tokenizeAndStringify(";0xFFFFFFFFul;"));
     }
 
     // Ticket #2429: 0.125
@@ -728,7 +721,7 @@ class TestTokenizer : public TestFixture {
 
     void tokenize19() {
         // #3006 - added hasComplicatedSyntaxErrorsInTemplates to avoid segmentation fault
-        ASSERT_THROW(tokenizeAndStringify("x < () <"), InternalError);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("x < () <"), SYNTAX);
 
         // #3496 - make sure hasComplicatedSyntaxErrorsInTemplates works
         ASSERT_EQUALS("void a ( Fred * f ) { for ( ; n < f . x ( ) ; ) { } }",
@@ -749,10 +742,11 @@ class TestTokenizer : public TestFixture {
                                            "        v[dim]->f();\n"
                                            "    }\n"
                                            "};"));
+        ignore_errout(); // we do not care about the output
     }
 
     void tokenize21() { // tokenize 0x0E-7
-        ASSERT_EQUALS("14 - 7 ;", tokenizeAndStringify("0x0E-7;"));
+        ASSERT_EQUALS("0x0E - 7 ;", tokenizeAndStringify("0x0E-7;"));
     }
 
     void tokenize22() { // tokenize special marker $ from preprocessor
@@ -765,38 +759,38 @@ class TestTokenizer : public TestFixture {
 
     // #4239 - segfault for "f ( struct { int typedef T x ; } ) { }"
     void tokenize25() {
-        ASSERT_THROW(tokenizeAndStringify("f ( struct { int typedef T x ; } ) { }"), InternalError);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("f ( struct { int typedef T x ; } ) { }"), SYNTAX);
     }
 
     // #4245 - segfault
     void tokenize26() {
-        ASSERT_THROW(tokenizeAndStringify("class x { protected : template < int y = } ;"), InternalError); // Garbage code
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("class x { protected : template < int y = } ;"), SYNTAX); // Garbage code
     }
 
     void tokenize27() {
         // #4525 - segfault
-        tokenizeAndStringify("struct except_spec_d_good : except_spec_a, except_spec_b {\n"
-                             "~except_spec_d_good();\n"
-                             "};\n"
-                             "struct S { S(); };\n"
-                             "S::S() __attribute((pure)) = default;"
-                            );
+        (void)tokenizeAndStringify("struct except_spec_d_good : except_spec_a, except_spec_b {\n"
+                                   "~except_spec_d_good();\n"
+                                   "};\n"
+                                   "struct S { S(); };\n"
+                                   "S::S() __attribute((pure)) = default;"
+                                   );
 
         // original code: glibc-2.18/posix/bug-regex20.c
-        tokenizeAndStringify("static unsigned int re_string_context_at (const re_string_t *input, int idx, int eflags) internal_function __attribute__ ((pure));");
+        (void)tokenizeAndStringify("static unsigned int re_string_context_at (const re_string_t *input, int idx, int eflags) internal_function __attribute__ ((pure));");
     }
 
     // #3503 - don't "simplify" SetFunction member function to a variable
     void tokenize31() {
         ASSERT_EQUALS("struct TTestClass { TTestClass ( ) { }\n"
-                      "void SetFunction ( Other * m_f ) { }\n"
+                      "void SetFunction ( Other ( * m_f ) ( ) ) { }\n"
                       "} ;",
                       tokenizeAndStringify("struct TTestClass { TTestClass() { }\n"
                                            "    void SetFunction(Other(*m_f)()) { }\n"
                                            "};"));
 
         ASSERT_EQUALS("struct TTestClass { TTestClass ( ) { }\n"
-                      "void SetFunction ( Other * m_f ) ;\n"
+                      "void SetFunction ( Other ( * m_f ) ( ) ) ;\n"
                       "} ;",
                       tokenizeAndStringify("struct TTestClass { TTestClass() { }\n"
                                            "    void SetFunction(Other(*m_f)());\n"
@@ -806,17 +800,17 @@ class TestTokenizer : public TestFixture {
     // #5884 - Avoid left shift of negative integer value.
     void tokenize32() {
         // Do not simplify negative integer left shifts.
-        const char * code = "void f ( ) { int max_x ; max_x = -10000 << 16 ; }";
+        const char code[] = "void f ( ) { int max_x ; max_x = -10000 << 16 ; }";
         ASSERT_EQUALS(code, tokenizeAndStringify(code));
     }
 
     // #5780 Various crashes on valid template code in Tokenizer::setVarId()
     void tokenize33() {
-        const char * code = "template<typename T, typename A = Alloc<T>> struct vector {};\n"
+        const char code[] = "template<typename T, typename A = Alloc<T>> struct vector {};\n"
                             "void z() {\n"
                             "    vector<int> VI;\n"
                             "}\n";
-        tokenizeAndStringify(code, true);
+        (void)tokenizeAndStringify(code);
     }
 
     void tokenize34() { // #8031
@@ -827,13 +821,13 @@ class TestTokenizer : public TestFixture {
                                 "};\n"
                                 "Container::Container() : mElements(nullptr) {}\n"
                                 "Container intContainer;";
-            const char exp [] = "1: struct Container {\n"
-                                "2: Container ( ) ;\n"
-                                "3: int * mElements@1 ;\n"
-                                "4: } ;\n"
-                                "5: Container :: Container ( ) : mElements@1 ( nullptr ) { }\n"
-                                "6: Container intContainer@2 ;\n";
-            ASSERT_EQUALS(exp, tokenizeDebugListing(code, /*simplify=*/true));
+            const char exp[] = "1: struct Container {\n"
+                               "2: Container ( ) ;\n"
+                               "3: int * mElements@1 ;\n"
+                               "4: } ;\n"
+                               "5: Container :: Container ( ) : mElements@1 ( nullptr ) { }\n"
+                               "6: Container intContainer@2 ;\n";
+            ASSERT_EQUALS(exp, tokenizeDebugListing(code));
         }
         {
             const char code[] = "template<class T> struct Container {\n"
@@ -842,22 +836,23 @@ class TestTokenizer : public TestFixture {
                                 "};\n"
                                 "template <class T> Container<T>::Container() : mElements(nullptr) {}\n"
                                 "Container<int> intContainer;";
-            const char exp [] = "1: struct Container<int> ;\n"
-                                "2:\n"
-                                "|\n"
-                                "5:\n"
-                                "6: Container<int> intContainer@1 ; struct Container<int> {\n"
-                                "2: Container<int> ( ) ;\n"
-                                "3: int * mElements@2 ;\n"
-                                "4: } ;\n"
-                                "5: Container<int> :: Container<int> ( ) : mElements@2 ( nullptr ) { }\n";
-            ASSERT_EQUALS(exp, tokenizeDebugListing(code, /*simplify=*/true));
+            const char exp[] = "1: struct Container<int> ;\n"
+                               "2:\n"
+                               "|\n"
+                               "5:\n"
+                               "6: Container<int> intContainer@1 ;\n"
+                               "1: struct Container<int> {\n"
+                               "2: Container<int> ( ) ;\n"
+                               "3: int * mElements@2 ;\n"
+                               "4: } ;\n"
+                               "5: Container<int> :: Container<int> ( ) : mElements@2 ( nullptr ) { }\n";
+            ASSERT_EQUALS(exp, tokenizeDebugListing(code));
         }
     }
 
     void tokenize35() { // #8361
-        tokenizeAndStringify("typedef int CRCWord; "
-                             "template<typename T> ::CRCWord const Compute(T const t) { return 0; }");
+        ASSERT_NO_THROW(tokenizeAndStringify("typedef int CRCWord; "
+                                             "template<typename T> ::CRCWord const Compute(T const t) { return 0; }"));
     }
 
     void tokenize36() { // #8436
@@ -869,85 +864,174 @@ class TestTokenizer : public TestFixture {
         const char codeC[] = "class name { public: static void init ( ) {} } ; "
                              "typedef class name N; "
                              "void foo ( ) { return N :: init ( ) ; }";
-        const char expC [] = "class name { public: static void init ( ) { } } ; "
-                             "void foo ( ) { return name :: init ( ) ; }";
+        const char expC[] = "class name { public: static void init ( ) { } } ; "
+                            "void foo ( ) { return name :: init ( ) ; }";
         ASSERT_EQUALS(expC, tokenizeAndStringify(codeC));
         const char codeS[] = "class name { public: static void init ( ) {} } ; "
                              "typedef struct name N; "
                              "void foo ( ) { return N :: init ( ) ; }";
-        const char expS [] = "class name { public: static void init ( ) { } } ; "
-                             "void foo ( ) { return name :: init ( ) ; }";
+        const char expS[] = "class name { public: static void init ( ) { } } ; "
+                            "void foo ( ) { return name :: init ( ) ; }";
         ASSERT_EQUALS(expS, tokenizeAndStringify(codeS));
     }
 
+    void tokenize38() { // #9569
+        const char code[] = "using Binary = std::vector<char>; enum Type { Binary };";
+        const char exp[]  = "enum Type { Binary } ;";
+        ASSERT_EQUALS(exp, tokenizeAndStringify(code));
+    }
+
+    void tokenize39() { // #9771
+        const char code[] = "template <typename T> class Foo;"
+                            "template <typename T> bool operator!=(const Foo<T> &, const Foo<T> &);"
+                            "template <typename T> class Foo { friend bool operator!= <> (const Foo<T> &, const Foo<T> &); };";
+        const char exp[]  = "template < typename T > class Foo ; "
+                            "template < typename T > bool operator!= ( const Foo < T > & , const Foo < T > & ) ; "
+                            "template < typename T > class Foo { friend bool operator!= < > ( const Foo < T > & , const Foo < T > & ) ; } ;";
+        ASSERT_EQUALS(exp, tokenizeAndStringify(code));
+    }
+
+    void tokenize40() { // #13181
+        const char code[] = "struct A { double eps(double); };\n"
+                            "A operator \"\"_a(long double);\n"
+                            "void f() {\n"
+                            "    double d = 1.23;\n"
+                            "    if (d == 1.2_a .eps(.1)) {}\n"
+                            "}\n";
+        (void) tokenizeAndStringify(code);
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void tokenize41() { // #13847
+        const char code[] = "int main() {\n"
+                            "     using x::a;\n"
+                            "     b = a + 2;\n"
+                            "}\n";
+        ASSERT_EQUALS("int main ( ) {\n"
+                      "\n"
+                      "b = x :: a + 2 ;\n"
+                      "}", tokenizeAndStringify(code));
+        (void)errout_str();
+    }
+
+    void tokenize42() { // #13861
+        const char code[] = "struct AB { int a; int b; };\n"
+                            "namespace ns { typedef AB S[10]; }\n"
+                            "void foo(void) {\n"
+                            "    ns::S x = {0};\n"
+                            "    x[1].a = 2;\n"
+                            "}\n";
+        ASSERT_EQUALS("struct AB { int a ; int b ; } ;\n"
+                      "\n"
+                      "void foo ( ) {\n"
+                      "AB x [ 10 ] = { 0 } ;\n"
+                      "x [ 1 ] . a = 2 ;\n"
+                      "}", tokenizeAndStringify(code));
+        (void)errout_str();
+    }
+
     void validate() {
         // C++ code in C file
-        ASSERT_THROW(tokenizeAndStringify(";using namespace std;",false,false,Settings::Native,"test.c"), InternalError);
-        ASSERT_THROW(tokenizeAndStringify(";std::map<int,int> m;",false,false,Settings::Native,"test.c"), InternalError);
-        ASSERT_THROW(tokenizeAndStringify(";template<class T> class X { };",false,false,Settings::Native,"test.c"), InternalError);
-        ASSERT_THROW(tokenizeAndStringify("int X<Y>() {};",false,false,Settings::Native,"test.c"), InternalError);
-        ASSERT_THROW(tokenizeAndStringify("void foo(int i) { reinterpret_cast<char>(i) };",false,false,Settings::Native,"test.h"), InternalError);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(";using namespace std;",dinit(TokenizeOptions, $.expand = false, $.cpp = false)), SYNTAX);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(";std::map<int,int> m;",dinit(TokenizeOptions, $.expand = false, $.cpp = false)), SYNTAX);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(";template<class T> class X { };",dinit(TokenizeOptions, $.expand = false, $.cpp = false)), SYNTAX);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("int X<Y>() {};",dinit(TokenizeOptions, $.expand = false, $.cpp = false)), SYNTAX);
+        {
+            TokenList tokenlist{settings1, Standards::Language::C}; // headers are treated as C files
+            const char code[] = "void foo(int i) { reinterpret_cast<char>(i) };";
+            tokenlist.appendFileIfNew("test.h");
+            ASSERT(tokenlist.createTokensFromString(code));
+            Tokenizer tokenizer(std::move(tokenlist), *this);
+            ASSERT_THROW_INTERNAL(tokenizer.simplifyTokens1(""), SYNTAX);
+        }
     }
 
     void objectiveC() {
-        ASSERT_THROW(tokenizeAndStringify("void f() { [foo bar]; }"), InternalError);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void f() { [foo bar]; }"), SYNTAX);
     }
 
     void syntax_case_default() { // correct syntax
-        tokenizeAndStringify("void f() {switch (n) { case 0: z(); break;}}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_NO_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case 0: z(); break;}}"));
+        ASSERT_EQUALS("", errout_str());
 
-        tokenizeAndStringify("void f() {switch (n) { case 0:; break;}}");
-        ASSERT_EQUALS("", errout.str());
+        (void)tokenizeAndStringify("void f(int n) {switch (n) { case 0:; break;}}");
+        ASSERT_EQUALS("", errout_str());
 
-        tokenizeAndStringify("void f() {switch (n) { case 0?1:2 : z(); break;}}");
-        ASSERT_EQUALS("", errout.str());
+        // TODO: Do not throw AST validation exception
+        TODO_ASSERT_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case 0?1:2 : z(); break;}}"), InternalError);
+        //ASSERT_EQUALS("", errout_str());
 
-        tokenizeAndStringify("void f() {switch (n) { case 0?(1?3:4):2 : z(); break;}}");
-        ASSERT_EQUALS("", errout.str());
+        // TODO: Do not throw AST validation exception
+        TODO_ASSERT_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case 0?(1?3:4):2 : z(); break;}}"), InternalError);
+        ASSERT_EQUALS("", errout_str());
 
         //allow GCC '({ %name%|%num%|%bool% ; })' statement expression extension
-        tokenizeAndStringify("void f() {switch (n) { case 0?({0;}):1: z(); break;}}");
-        ASSERT_EQUALS("", errout.str());
+        // TODO: Do not throw AST validation exception
+        TODO_ASSERT_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case 0?({0;}):1: z(); break;}}"), InternalError);
+        ASSERT_EQUALS("", errout_str());
 
         //'b' can be or a macro or an undefined enum
-        tokenizeAndStringify("void f() {switch (n) { case b: z(); break;}}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_NO_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case b: z(); break;}}"));
+        ASSERT_EQUALS("", errout_str());
 
         //valid, when there's this declaration: 'constexpr int g() { return 2; }'
-        tokenizeAndStringify("void f() {switch (n) { case g(): z(); break;}}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_NO_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case g(): z(); break;}}"));
+        ASSERT_EQUALS("", errout_str());
 
         //valid, when there's also this declaration: 'constexpr int g[1] = {0};'
-        tokenizeAndStringify("void f() {switch (n) { case g[0]: z(); break;}}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_NO_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case g[0]: z(); break;}}"));
+        ASSERT_EQUALS(
+            "[test.cpp:1:34]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable g [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
 
         //valid, similar to above case
-        tokenizeAndStringify("void f() {switch (n) { case *g: z(); break;}}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_NO_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case *g: z(); break;}}"));
+        ASSERT_EQUALS("", errout_str());
 
         //valid, when 'x' and 'y' are constexpr.
-        tokenizeAndStringify("void f() {switch (n) { case sqrt(x+y): z(); break;}}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_NO_THROW(tokenizeAndStringify("void f(int n) {switch (n) { case sqrt(x+y): z(); break;}}"));
+        ASSERT_EQUALS(
+            "[test.cpp:1:39]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable x [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
+    }
+
+    void removePragma() {
+        const char code[] = "_Pragma(\"abc\") int x;";
+        const Settings s_c89 = settingsBuilder().c(Standards::C89).build();
+        ASSERT_EQUALS("_Pragma ( \"abc\" ) int x ;", tokenizeAndStringify(code, s_c89, false));
+        const Settings s_clatest;
+        ASSERT_EQUALS("int x ;", tokenizeAndStringify(code, s_clatest, false));
+
+        const Settings s_cpp03 = settingsBuilder().cpp(Standards::CPP03).build();
+        ASSERT_EQUALS("_Pragma ( \"abc\" ) int x ;", tokenizeAndStringify(code, s_cpp03, true));
+        const Settings s_cpplatest;
+        ASSERT_EQUALS("int x ;", tokenizeAndStringify(code, s_cpplatest, true));
     }
 
     void foreach () {
         // #3690,#5154
         const char code[] ="void f() { for each ( char c in MyString ) { Console::Write(c); } }";
-        ASSERT_EQUALS("void f ( ) { asm ( \"char c in MyString\" ) { Console :: Write ( c ) ; } }", tokenizeAndStringify(code));
+        ASSERT_EQUALS("void f ( ) { for ( char c : MyString ) { Console :: Write ( c ) ; } }", tokenizeAndStringify(code));
+        ASSERT_EQUALS(
+            "[test.cpp:1:33]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable MyString [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
     }
 
     void ifconstexpr() {
         ASSERT_EQUALS("void f ( ) { if ( FOO ) { bar ( c ) ; } }", tokenizeAndStringify("void f() { if constexpr ( FOO ) { bar(c); } }"));
+        ASSERT_EQUALS(
+            "[test.cpp:1:27]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable FOO [valueFlowBailoutIncompleteVar]\n",
+            filter_valueflow(errout_str()));
     }
 
     void combineOperators() {
-        ASSERT_EQUALS("; private: ;", tokenizeAndStringify(";private:;", false));
-        ASSERT_EQUALS("; protected: ;", tokenizeAndStringify(";protected:;", false));
-        ASSERT_EQUALS("; public: ;", tokenizeAndStringify(";public:;", false));
-        ASSERT_EQUALS("; __published: ;", tokenizeAndStringify(";__published:;", false));
-        ASSERT_EQUALS("a . public : ;", tokenizeAndStringify("a.public:;", false));
-        ASSERT_EQUALS("void f ( x & = 2 ) ;", tokenizeAndStringify("void f(x &= 2);", false));
+        ASSERT_EQUALS("; private: ;", tokenizeAndStringify(";private:;"));
+        ASSERT_EQUALS("; protected: ;", tokenizeAndStringify(";protected:;"));
+        ASSERT_EQUALS("; public: ;", tokenizeAndStringify(";public:;"));
+        ASSERT_EQUALS("; __published: ;", tokenizeAndStringify(";__published:;"));
+        ASSERT_EQUALS("a . public : ;", tokenizeAndStringify("a.public:;"));
+        ASSERT_EQUALS("void f ( x & = 2 ) ;", tokenizeAndStringify("void f(x &= 2);"));
+        ASSERT_EQUALS("const_cast < a * > ( & e )", tokenizeAndStringify("const_cast<a*>(&e)"));
     }
 
     void concatenateNegativeNumber() {
@@ -958,133 +1042,71 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("int x [ 2 ] = { -2 , 1 }", tokenizeAndStringify("int x[2] = {-2,1}"));
 
         ASSERT_EQUALS("f ( 123 )", tokenizeAndStringify("f(+123)"));
+
+        ASSERT_EQUALS("std :: extent_v < A > - 1 ;", tokenizeAndStringify("std::extent_v<A> - 1;")); // #11341
     }
 
 
 
     void longtok() {
         const std::string filedata(10000, 'a');
-        ASSERT_EQUALS(filedata, tokenizeAndStringify(filedata.c_str(), true));
+        ASSERT_EQUALS(filedata, tokenizeAndStringify(filedata));
     }
 
 
-    void removeUnusedTemplates() {
-        Settings s;
-        s.checkUnusedTemplates = false;
+    void simplifyHeadersAndUnusedTemplates1() {
+        const Settings s = settingsBuilder().checkUnusedTemplates(false).build();
         ASSERT_EQUALS(";",
                       tokenizeAndStringify("; template <typename... a> uint8_t b(std::tuple<uint8_t> d) {\n"
                                            "  std::tuple<a...> c{std::move(d)};\n"
                                            "  return std::get<0>(c);\n"
                                            "}", s));
+        ASSERT_EQUALS("int g ( int ) ;",
+                      tokenizeAndStringify("int g(int);\n"
+                                           "template <class F, class... Ts> auto h(F f, Ts... xs) {\n"
+                                           "    auto e = f(g(xs)...);\n"
+                                           "    return e;\n"
+                                           "}", s));
     }
 
+    void simplifyHeadersAndUnusedTemplates2() {
+        const char code[] = "; template< typename T, u_int uBAR = 0 >\n"
+                            "class Foo {\n"
+                            "public:\n"
+                            "    void FooBar() {\n"
+                            "        new ( (uBAR ? uBAR : sizeof(T))) T;\n"
+                            "    }\n"
+                            "};";
 
-    // Don’t remove "(int *)"..
-    void simplifyCasts1() {
-        const char code[] = "int *f(int *);";
-        ASSERT_EQUALS("int * f ( int * ) ;", tokenizeAndStringify(code, true));
-    }
-
-    // remove static_cast..
-    void simplifyCasts2() {
-        const char code[] = "t = (static_cast<std::vector<int> *>(&p));\n";
-        ASSERT_EQUALS("t = & p ;", tokenizeAndStringify(code, true));
-    }
-
-    void simplifyCasts3() {
-        // ticket #961
-        const char code[] = "assert (iplen >= (unsigned) ipv4->ip_hl * 4 + 20);";
-        const char expected[] = "assert ( iplen >= ipv4 . ip_hl * 4 + 20 ) ;";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-    }
-
-    void simplifyCasts4() {
-        // ticket #970
-        const char code[] = "if (a >= (unsigned)(b)) {}";
-        const char expected[] = "if ( a >= ( unsigned int ) ( b ) ) { }";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-    }
-
-    void simplifyCasts5() {
-        // ticket #1817
-        ASSERT_EQUALS("a . data = f ;", tokenizeAndStringify("a->data = reinterpret_cast<void*>(static_cast<intptr_t>(f));", true));
-    }
-
-    void simplifyCasts7() {
-        ASSERT_EQUALS("str = malloc ( 3 )", tokenizeAndStringify("str=(char **)malloc(3)", true));
-    }
-
-    void simplifyCasts8() {
-        ASSERT_EQUALS("ptr1 = ptr2", tokenizeAndStringify("ptr1=(int *   **)ptr2", true));
-    }
-
-    void simplifyCasts9() {
-        ASSERT_EQUALS("f ( ( double ) ( v1 ) * v2 )", tokenizeAndStringify("f((double)(v1)*v2)", true));
-        ASSERT_EQUALS("int v1 ; f ( ( double ) ( v1 ) * v2 )", tokenizeAndStringify("int v1; f((double)(v1)*v2)", true));
-        ASSERT_EQUALS("f ( ( A ) ( B ) & x )", tokenizeAndStringify("f((A)(B)&x)", true)); // #4439
-    }
-
-    void simplifyCasts10() {
-        ASSERT_EQUALS("; ( * f ) ( p ) ;", tokenizeAndStringify("; (*(void (*)(char *))f)(p);", true));
-    }
-
-    void simplifyCasts11() {
-        ASSERT_EQUALS("; x = 0 ;", tokenizeAndStringify("; *(int *)&x = 0;", true));
-    }
-
-    void simplifyCasts12() {
-        // #3935 - don't remove this cast
-        ASSERT_EQUALS("; ( ( short * ) data ) [ 5 ] = 0 ;", tokenizeAndStringify("; ((short*)data)[5] = 0;", true));
-    }
-
-    void simplifyCasts13() {
-        // casting deref / address of
-        ASSERT_EQUALS("; int x ; x = * y ;", tokenizeAndStringify(";int x=(int)*y;",true));
-        ASSERT_EQUALS("; int x ; x = & y ;", tokenizeAndStringify(";int x=(int)&y;",true));
-        TODO_ASSERT_EQUALS("; int x ; x = ( INT ) * y ;",
-                           "; int x ; x = * y ;",
-                           tokenizeAndStringify(";int x=(INT)*y;",true)); // INT might be a variable
-        TODO_ASSERT_EQUALS("; int x ; x = ( INT ) & y ;",
-                           "; int x ; x = & y ;",
-                           tokenizeAndStringify(";int x=(INT)&y;",true)); // INT might be a variable
-
-        // #4899 - False positive on unused variable
-        ASSERT_EQUALS("; float angle ; angle = tilt ;", tokenizeAndStringify("; float angle = (float) tilt;", true)); // status quo
-        ASSERT_EQUALS("; float angle ; angle = ( float ) - tilt ;", tokenizeAndStringify("; float angle = (float) -tilt;", true));
-        ASSERT_EQUALS("; float angle ; angle = ( float ) + tilt ;", tokenizeAndStringify("; float angle = (float) +tilt;", true));
-        ASSERT_EQUALS("; int a ; a = ( int ) ~ c ;", tokenizeAndStringify("; int a = (int)~c;", true));
-    }
-
-    void simplifyCasts14() { // const
-        // #5081
-        ASSERT_EQUALS("( ! ( & s ) . a ) ;", tokenizeAndStringify("(! ( (struct S const *) &s)->a);", true));
-        // #5244
-        ASSERT_EQUALS("bar ( & ptr ) ;", tokenizeAndStringify("bar((const X**)&ptr);",true));
-    }
-
-    void simplifyCasts15() { // #5996 - don't remove cast in 'a+static_cast<int>(b?60:0)'
-        ASSERT_EQUALS("a + ( b ? 60 : 0 ) ;",
-                      tokenizeAndStringify("a + static_cast<int>(b ? 60 : 0);", true));
-    }
-
-    void simplifyCasts16() { // #6278
-        ASSERT_EQUALS("Get ( pArray ) ;",
-                      tokenizeAndStringify("Get((CObject*&)pArray);", true));
-    }
+        {
+            const Settings s = settingsBuilder().checkUnusedTemplates(false).build();
+            ASSERT_EQUALS(";", tokenizeAndStringify(code, s));
+        }
 
-    void simplifyCasts17() { // #6110 - don't remove any parentheses in 'a(b)(c)'
-        ASSERT_EQUALS("if ( a ( b ) ( c ) >= 3 )",
-                      tokenizeAndStringify("if (a(b)(c) >= 3)", true));
+        {
+            ASSERT_EQUALS("; template < typename T , u_int uBAR = 0 >\n"
+                          "class Foo {\n"
+                          "public:\n"
+                          "void FooBar ( ) {\n"
+                          "new ( uBAR ? uBAR : sizeof ( T ) ) T ;\n"
+                          "}\n"
+                          "} ;", tokenizeAndStringify(code, settingsDefault));
+        }
     }
 
     void simplifyAt() {
         ASSERT_EQUALS("int x ;", tokenizeAndStringify("int x@123;"));
         ASSERT_EQUALS("bool x ;", tokenizeAndStringify("bool x@123:1;"));
         ASSERT_EQUALS("char PORTB ; bool PB3 ;", tokenizeAndStringify("char PORTB @ 0x10; bool PB3 @ PORTB:3;\n"));
+        ASSERT_EQUALS("int x ;", tokenizeAndStringify("int x @ (0x1000 + 18);"));
 
         ASSERT_EQUALS("int x [ 10 ] ;", tokenizeAndStringify("int x[10]@0x100;"));
 
+        ASSERT_EQUALS("void ( * f [ ] ) ( void ) ;", tokenizeAndStringify("void (*f[])(void)@0x100;")); // #13458
+
         ASSERT_EQUALS("interrupt@ f ( ) { }", tokenizeAndStringify("@interrupt f() {}"));
+
+        ASSERT_EQUALS("const short MyVariable = 0xF0F0 ;", tokenizeAndStringify("const short MyVariable @ \"MYOWNSECTION\" = 0xF0F0; ")); // #12602
     }
 
     void inlineasm() {
@@ -1103,40 +1125,46 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("asm ( \"mov ax , bx\" ) ; int a ;", tokenizeAndStringify("asm { mov ax,bx } int a;"));
         ASSERT_EQUALS("asm\n\n( \"mov ax , bx\" ) ;", tokenizeAndStringify("__asm\nmov ax,bx\n__endasm;"));
         ASSERT_EQUALS("asm\n\n( \"push b ; for if\" ) ;", tokenizeAndStringify("__asm\npush b ; for if\n__endasm;"));
+        ASSERT_EQUALS("asm ( \"\"mov ax , bx\"\" ) ;", tokenizeAndStringify("asm volatile (\"mov ax , bx\");"));
+        ASSERT_EQUALS("asm ( \"\"mov ax , bx\"\" ) ;", tokenizeAndStringify("asm goto (\"mov ax , bx\");"));
+        ASSERT_EQUALS("asm ( \"\"mov ax , bx\"\" ) ;", tokenizeAndStringify("asm inline (\"mov ax , bx\");"));
 
         // 'asm ( ) ;' should be in the same line
-        ASSERT_EQUALS(";\n\nasm ( \"\"mov ax,bx\"\" ) ;", tokenizeAndStringify(";\n\n__asm__ volatile ( \"mov ax,bx\" );", true));
+        ASSERT_EQUALS(";\n\nasm ( \"\"mov ax,bx\"\" ) ;", tokenizeAndStringify(";\n\n__asm__ volatile ( \"mov ax,bx\" );"));
+
+        ASSERT_EQUALS("void func1 ( ) ;", tokenizeAndStringify("void func1() __asm__(\"...\") __attribute__();"));
+
+        // #14250 - assembler function
+        const char code[] = "__asm void dostuff(uint32_t x) { "
+                            "%reg x "
+                            "  e_lis r7, (lf)@h "
+                            "%error "
+                            "}";
+        ASSERT_EQUALS("void dostuff ( uint32_t x ) { asm ( \"% reg x e_lis r7 , ( lf ) @ h % error\" ) ; }",
+                      tokenizeAndStringify(code));
     }
 
     // #4725 - ^{}
     void simplifyAsm2() {
-        ASSERT_THROW(ASSERT_EQUALS("void f ( ) { asm ( \"^{}\" ) ; }", tokenizeAndStringify("void f() { ^{} }")), InternalError);
-        ASSERT_THROW(ASSERT_EQUALS("void f ( ) { x ( asm ( \"^{}\" ) ) ; }", tokenizeAndStringify("void f() { x(^{}); }")), InternalError);
-        ASSERT_THROW(ASSERT_EQUALS("void f ( ) { foo ( A ( ) , asm ( \"^{bar();}\" ) ) ; }", tokenizeAndStringify("void f() { foo(A(), ^{ bar(); }); }")), InternalError);
-        ASSERT_THROW(ASSERT_EQUALS("int f0 ( Args args ) { asm ( \"asm(\"return^{returnsizeof...(Args);}()\")+^{returnsizeof...(args);}()\" )\n"
-                                   "2:\n"
-                                   "|\n"
-                                   "5:\n"
-                                   "6: ;\n"
-                                   "} ;", tokenizeAndStringify("int f0(Args args) {\n"
-                                           "    return ^{\n"
-                                           "        return sizeof...(Args);\n"
-                                           "    }() + ^ {\n"
-                                           "        return sizeof...(args);\n"
-                                           "    }();\n"
-                                           "};")), InternalError);
-        ASSERT_THROW(ASSERT_EQUALS("int ( ^ block ) ( void ) = asm ( \"^{staticinttest=0;returntest;}\" )\n\n\n;",
-                                   tokenizeAndStringify("int(^block)(void) = ^{\n"
-                                           "    static int test = 0;\n"
-                                           "    return test;\n"
-                                           "};")), InternalError);
-
-        ASSERT_THROW(ASSERT_EQUALS("; return f ( a [ b = c ] , asm ( \"^{}\" ) ) ;",
-                                   tokenizeAndStringify("; return f(a[b=c],^{});")), InternalError); // #7185
-        ASSERT_EQUALS("; return f ( asm ( \"^(void){somecode}\" ) ) ;",
-                      tokenizeAndStringify("; return f(^(void){somecode});"));
-        ASSERT_THROW(ASSERT_EQUALS("; asm ( \"a?(b?(c,asm(\"^{}\")):0):^{}\" ) ;",
-                                   tokenizeAndStringify(";a?(b?(c,^{}):0):^{};")), InternalError);
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { ^{} }"), SYNTAX, "syntax error");
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { x(^{}); }"), SYNTAX, "syntax error");
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { foo(A(), ^{ bar(); }); }"), SYNTAX, "syntax error");
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("int f0(Args args) {\n"
+                                                          "    return ^{\n"
+                                                          "        return sizeof...(Args);\n"
+                                                          "    }() + ^ {\n"
+                                                          "        return sizeof...(args);\n"
+                                                          "    }();\n"
+                                                          "};"), SYNTAX, "syntax error");
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("int(^block)(void) = ^{\n"
+                                                          "    static int test = 0;\n"
+                                                          "    return test;\n"
+                                                          "};"), SYNTAX, "syntax error");
+
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("; return f(a[b=c],^{});"), SYNTAX, "syntax error: keyword 'return' is not allowed in global scope"); // #7185
+        ASSERT_EQUALS("{ return f ( asm ( \"^(void){somecode}\" ) ) ; }",
+                      tokenizeAndStringify("{ return f(^(void){somecode}); }"));
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify(";a?(b?(c,^{}):0):^{};"), SYNTAX, "syntax error");
         ASSERT_EQUALS("template < typename T > "
                       "CImg < T > operator| ( const char * const expression , const CImg < T > & img ) { "
                       "return img | expression ; "
@@ -1173,7 +1201,10 @@ class TestTokenizer : public TestFixture {
                       "{\n"
                       "if ( a ) { ; }\n"
                       "else { ; }\n"
-                      "}", tokenizeAndStringify(code, true));
+                      "}", tokenizeAndStringify(code));
+        ASSERT_EQUALS(
+            "[test.cpp:3:9]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable a [valueFlowBailoutIncompleteVar]\n",
+            filter_valueflow(errout_str()));
     }
 
     void ifAddBraces2() {
@@ -1184,7 +1215,10 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("void f ( )\n"
                       "{\n"
                       "if ( a ) { if ( b ) { } }\n"
-                      "}", tokenizeAndStringify(code, true));
+                      "}", tokenizeAndStringify(code));
+        ASSERT_EQUALS(
+            "[test.cpp:3:9]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable a [valueFlowBailoutIncompleteVar]\n",
+            filter_valueflow(errout_str()));
     }
 
     void ifAddBraces3() {
@@ -1195,7 +1229,10 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("void f ( )\n"
                       "{\n"
                       "if ( a ) { for ( ; ; ) { } }\n"
-                      "}", tokenizeAndStringify(code, true));
+                      "}", tokenizeAndStringify(code));
+        ASSERT_EQUALS(
+            "[test.cpp:3:9]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable a [valueFlowBailoutIncompleteVar]\n",
+            filter_valueflow(errout_str()));
     }
 
     void ifAddBraces4() {
@@ -1214,7 +1251,10 @@ class TestTokenizer : public TestFixture {
                       "for ( ; ; )\n"
                       "{ } }\n"
                       "return str ;\n"
-                      "}", tokenizeAndStringify(code, true));
+                      "}", tokenizeAndStringify(code));
+        ASSERT_EQUALS(
+            "[test.cpp:4:9]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable somecondition [valueFlowBailoutIncompleteVar]\n",
+            filter_valueflow(errout_str()));
     }
 
     void ifAddBraces5() {
@@ -1230,10 +1270,10 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("void f ( )\n"
                       "{\n"
                       "for ( int i = 0 ; i < 2 ; i ++ ) {\n"
-                      "\n"
-                      "return ; }\n\n"
+                      "if ( true ) {\n"
+                      "return ; } }\n\n"
                       "return ;\n"
-                      "}", tokenizeAndStringify(code, true));
+                      "}", tokenizeAndStringify(code));
     }
 
     void ifAddBraces7() {
@@ -1248,7 +1288,8 @@ class TestTokenizer : public TestFixture {
                       "int a ;\n"
                       "if ( a ) {\n"
                       "( { a = 4 ; } ) , ( { a = 5 ; } ) ; }\n"
-                      "}", tokenizeAndStringify(code, true));
+                      "}", tokenizeAndStringify(code));
+        ASSERT_EQUALS("", filter_valueflow(errout_str()));
     }
 
     void ifAddBraces9() {
@@ -1258,50 +1299,38 @@ class TestTokenizer : public TestFixture {
             "    for (int k=0; k<VectorSize; k++)"
             "        LOG_OUT(ID_Vector[k])"
             "}";
-        const char expected[] =
-            "void f ( ) { "
-            "for ( int k = 0 ; k < VectorSize ; k ++ ) "
-            "LOG_OUT ( ID_Vector [ k ] ) "
-            "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-    }
-
-    void ifAddBraces10() {
-        // ticket #1361
-        const char code[] = "{ DEBUG(if (x) y; else z); }";
-        const char expected[] = "{ DEBUG ( if ( x ) { y ; } else z ) ; }";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(code), UNKNOWN_MACRO);
     }
 
     void ifAddBraces11() {
         const char code[] = "{ if (x) if (y) ; else ; }";
         const char expected[] = "{ if ( x ) { if ( y ) { ; } else { ; } } }";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
 
     void ifAddBraces12() {
         // ticket #1424
         const char code[] = "{ if (x) do { } while(x); }";
         const char expected[] = "{ if ( x ) { do { } while ( x ) ; } }";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
 
     void ifAddBraces13() {
         // ticket #1809
         const char code[] = "{ if (x) if (y) { } else { } else { } }";
         const char expected[] = "{ if ( x ) { if ( y ) { } else { } } else { } }";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
 
         // ticket #1809
         const char code2[] = "{ if (x) while (y) { } else { } }";
         const char expected2[] = "{ if ( x ) { while ( y ) { } } else { } }";
-        ASSERT_EQUALS(expected2, tokenizeAndStringify(code2, true));
+        ASSERT_EQUALS(expected2, tokenizeAndStringify(code2));
     }
 
     void ifAddBraces15() {
         // ticket #2616 - unknown macro before if
         // TODO: Remove "A" or change it to ";A;". Then cleanup Tokenizer::ifAddBraces().
-        ASSERT_EQUALS("{ A if ( x ) { y ( ) ; } }", tokenizeAndStringify("{A if(x)y();}", false));
+        ASSERT_EQUALS("{ A if ( x ) { y ( ) ; } }", tokenizeAndStringify("{A if(x)y();}"));
     }
 
     void ifAddBraces16() {
@@ -1312,6 +1341,9 @@ class TestTokenizer : public TestFixture {
                                 "}";
             ASSERT_EQUALS("void f ( ) { ( void ) ( { if ( * p ) { ( * p ) = x ( ) ; } } ) }",
                           tokenizeAndStringify(code));
+            ASSERT_EQUALS(
+                "[test.cpp:1:27]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable p [valueFlowBailoutIncompleteVar]\n",
+                filter_valueflow(errout_str()));
         }
     }
 
@@ -1331,16 +1363,19 @@ class TestTokenizer : public TestFixture {
                       "\n"
                       "else {\n"
                       "bar2 ( ) ; }\n"
-                      "}", tokenizeAndStringify(code, true));
+                      "}", tokenizeAndStringify(code));
+        ASSERT_EQUALS(
+            "[test.cpp:3:9]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable a [valueFlowBailoutIncompleteVar]\n",
+            filter_valueflow(errout_str()));
     }
 
     void ifAddBraces18() {
         // ticket #3424 - if if { } else else
         ASSERT_EQUALS("{ if ( x ) { if ( y ) { } else { ; } } else { ; } }",
-                      tokenizeAndStringify("{ if(x) if(y){}else;else;}", false));
+                      tokenizeAndStringify("{ if(x) if(y){}else;else;}"));
 
         ASSERT_EQUALS("{ if ( x ) { if ( y ) { if ( z ) { } else { ; } } else { ; } } else { ; } }",
-                      tokenizeAndStringify("{ if(x) if(y) if(z){}else;else;else;}", false));
+                      tokenizeAndStringify("{ if(x) if(y) if(z){}else;else;else;}"));
     }
 
     void ifAddBraces19() {
@@ -1362,44 +1397,155 @@ class TestTokenizer : public TestFixture {
                       "bar1 ( ) ; }\n"
                       "else {\n"
                       "bar2 ( ) ; } } }\n"
-                      "}", tokenizeAndStringify(code, true));
+                      "}", tokenizeAndStringify(code));
+        ASSERT_EQUALS(
+            "[test.cpp:3:9]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable a [valueFlowBailoutIncompleteVar]\n",
+            filter_valueflow(errout_str()));
     }
 
     void ifAddBraces20() { // #5012 - syntax error 'else }'
         const char code[] = "void f() { if(x) {} else }";
-        ASSERT_THROW(tokenizeAndStringify(code, true), InternalError);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(code), SYNTAX);
+    }
+
+    void ifAddBracesLabels() {
+        // Labels before statement
+        ASSERT_EQUALS("int f ( int x ) {\n"
+                      "if ( x ) {\n"
+                      "l1 : ; l2 : ; return x ; }\n"
+                      "}",
+                      tokenizeAndStringify("int f(int x) {\n"
+                                           "  if (x)\n"
+                                           "  l1: l2: return x;\n"
+                                           "}"));
+        ASSERT_EQUALS("", filter_valueflow(errout_str()));
+
+        // Labels before {
+        ASSERT_EQUALS("int f ( int x ) {\n"
+                      "if ( x )\n"
+                      "{ l1 : ; l2 : ; return x ; }\n"
+                      "}",
+                      tokenizeAndStringify("int f(int x) {\n"
+                                           "  if (x)\n"
+                                           "  l1: l2: { return x; }\n"
+                                           "}"));
+        ASSERT_EQUALS("", filter_valueflow(errout_str()));
+
+        // Labels before try/catch
+        ASSERT_EQUALS("int f ( int x ) {\n"
+                      "if ( x ) {\n"
+                      "l1 : ; l2 : ;\n"
+                      "try { throw 1 ; }\n"
+                      "catch ( ... ) { return x ; } }\n"
+                      "}",
+                      tokenizeAndStringify("int f(int x) {\n"
+                                           "  if (x)\n"
+                                           "  l1: l2:\n"
+                                           "    try { throw 1; }\n"
+                                           "    catch(...) { return x; }\n"
+                                           "}"));
+        ASSERT_EQUALS("", filter_valueflow(errout_str()));
     }
 
-    void ifAddBraces21() { // #5332 - if (x) label: {} ...
-        const char code[] = "void f() { if(x) label: {} a=1; }";
-        ASSERT_EQUALS("void f ( ) { if ( x ) { label : ; { } } a = 1 ; }", tokenizeAndStringify(code, false));
+    void switchAddBracesLabels() {
+        // Labels before statement
+        ASSERT_EQUALS("int f ( int x ) {\n"
+                      "switch ( x ) {\n"
+                      "l1 : ; case 0 : ; l2 : ; case ( 1 ) : ; return x ; }\n"
+                      "}",
+                      tokenizeAndStringify("int f(int x) {\n"
+                                           "  switch (x)\n"
+                                           "  l1: case 0: l2: case (1): return x;\n"
+                                           "}"));
+
+        // Labels before {
+        ASSERT_EQUALS("int f ( int x ) {\n"
+                      "switch ( x )\n"
+                      "{ l1 : ; case 0 : ; l2 : ; case ( 1 ) : ; return x ; }\n"
+                      "}",
+                      tokenizeAndStringify("int f(int x) {\n"
+                                           "  switch (x)\n"
+                                           "  l1: case 0: l2: case (1): { return x; }\n"
+                                           "}"));
+
+        // Labels before try/catch
+        ASSERT_EQUALS("int f ( int x ) {\n"
+                      "switch ( x ) {\n"
+                      "l1 : ; case 0 : ; l2 : ; case ( 1 ) : ;\n"
+                      "try { throw 1 ; }\n"
+                      "catch ( ... ) { return x ; } }\n"
+                      "}",
+                      tokenizeAndStringify("int f(int x) {\n"
+                                           "  switch (x)\n"
+                                           "  l1: case 0: l2: case (1):\n"
+                                           "    try { throw 1; }\n"
+                                           "    catch(...) { return x; }\n"
+                                           "}"));
     }
 
     void whileAddBraces() {
-        const char code[] = ";while(a);";
-        ASSERT_EQUALS("; while ( a ) { ; }", tokenizeAndStringify(code, true));
+        const char code[] = "{while(a);}";
+        ASSERT_EQUALS("{ while ( a ) { ; } }", tokenizeAndStringify(code));
+    }
+
+    void whileAddBracesLabels() {
+        // Labels before statement
+        ASSERT_EQUALS("void f ( int x ) {\n"
+                      "while ( x ) {\n"
+                      "l1 : ; l2 : ; -- x ; }\n"
+                      "}",
+                      tokenizeAndStringify("void f(int x) {\n"
+                                           "  while (x)\n"
+                                           "  l1: l2: --x;\n"
+                                           "}"));
+        ASSERT_EQUALS("", filter_valueflow(errout_str()));
+
+        // Labels before {
+        ASSERT_EQUALS("void f ( int x ) {\n"
+                      "while ( x )\n"
+                      "{ l1 : ; l2 : ; -- x ; }\n"
+                      "}",
+                      tokenizeAndStringify("void f(int x) {\n"
+                                           "  while (x)\n"
+                                           "  l1: l2: { -- x; }\n"
+                                           "}"));
+        ASSERT_EQUALS("", filter_valueflow(errout_str()));
+
+        // Labels before try/catch
+        ASSERT_EQUALS("void f ( int x ) {\n"
+                      "while ( x ) {\n"
+                      "l1 : ; l2 : ;\n"
+                      "try { throw 1 ; }\n"
+                      "catch ( ... ) { -- x ; } }\n"
+                      "}",
+                      tokenizeAndStringify("void f(int x) {\n"
+                                           "  while (x)\n"
+                                           "  l1: l2:\n"
+                                           "    try { throw 1; }\n"
+                                           "    catch(...) { --x; }\n"
+                                           "}"));
+        ASSERT_EQUALS("", filter_valueflow(errout_str()));
     }
 
     void doWhileAddBraces() {
         {
-            const char code[] = "do ; while (0);";
-            const char result[] = "do { ; } while ( 0 ) ;";
+            const char code[] = "{do ; while (0);}";
+            const char result[] = "{ do { ; } while ( 0 ) ; }";
 
-            ASSERT_EQUALS(result, tokenizeAndStringify(code, false));
+            ASSERT_EQUALS(result, tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "UNKNOWN_MACRO ( do ) ; while ( a -- ) ;";
-            const char result[] = "UNKNOWN_MACRO ( do ) ; while ( a -- ) { ; }";
-
-            ASSERT_EQUALS(result, tokenizeAndStringify(code, true));
+            const char code[] = "{ UNKNOWN_MACRO ( do ) ; while ( a -- ) ; }";
+            ASSERT_THROW_INTERNAL(tokenizeAndStringify(code), SYNTAX);
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "UNKNOWN_MACRO ( do , foo ) ; while ( a -- ) ;";
-            const char result[] = "UNKNOWN_MACRO ( do , foo ) ; while ( a -- ) { ; }";
-
-            ASSERT_EQUALS(result, tokenizeAndStringify(code, true));
+            const char code[] = "{ UNKNOWN_MACRO ( do , foo ) ; while ( a -- ) ; }";
+            ASSERT_THROW_INTERNAL(tokenizeAndStringify(code), SYNTAX);
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -1412,14 +1558,15 @@ class TestTokenizer : public TestFixture {
                                 " return 0 ;\n"
                                 "}\n";
             const char result[] =   "void foo ( int c , int d ) {\n"
-                                    "do {\n"
-                                    "if ( c ) {\n"
-                                    "while ( c ) { c -- ; }\n"
-                                    "} }\n"
-                                    "while ( -- d > 0 ) ;\n"
-                                    "return 0 ;\n"
-                                    "}";
-            ASSERT_EQUALS(result, tokenizeAndStringify(code, true));
+                                  "do {\n"
+                                  "if ( c ) {\n"
+                                  "while ( c ) { c -- ; }\n"
+                                  "} }\n"
+                                  "while ( -- d > 0 ) ;\n"
+                                  "return 0 ;\n"
+                                  "}";
+            ASSERT_EQUALS(result, tokenizeAndStringify(code));
+            ASSERT_EQUALS("", filter_valueflow(errout_str()));
         }
 
         {
@@ -1430,12 +1577,13 @@ class TestTokenizer : public TestFixture {
                                 " return 0 ;\n"
                                 "}\n";
             const char result[] =   "void foo ( int c , int d ) {\n"
-                                    "do {\n"
-                                    "do { c -- ; } while ( c ) ; }\n"
-                                    "while ( -- d > 0 ) ;\n"
-                                    "return 0 ;\n"
-                                    "}";
-            ASSERT_EQUALS(result, tokenizeAndStringify(code, true));
+                                  "do {\n"
+                                  "do { c -- ; } while ( c ) ; }\n"
+                                  "while ( -- d > 0 ) ;\n"
+                                  "return 0 ;\n"
+                                  "}";
+            ASSERT_EQUALS(result, tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -1446,10 +1594,55 @@ class TestTokenizer : public TestFixture {
             const char result[] = "void foo ( ) {\n"
                                   "do { while ( x ) { f ( ) ; } } while ( y ) ;\n"
                                   "}";
-            ASSERT_EQUALS(result, tokenizeAndStringify(code, true));
+            ASSERT_EQUALS(result, tokenizeAndStringify(code));
+            ASSERT_EQUALS(
+                "[test.cpp:2:17]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable x [valueFlowBailoutIncompleteVar]\n",
+                filter_valueflow(errout_str()));
         }
     }
 
+    void doWhileAddBracesLabels() {
+        // Labels before statement
+        ASSERT_EQUALS("void f ( int x ) {\n"
+                      "do {\n"
+                      "l1 : ; l2 : ; -- x ; }\n"
+                      "while ( x ) ;\n"
+                      "}",
+                      tokenizeAndStringify("void f(int x) {\n"
+                                           "  do\n"
+                                           "  l1: l2: --x;\n"
+                                           "  while (x);\n"
+                                           "}"));
+
+        // Labels before {
+        ASSERT_EQUALS("void f ( int x ) {\n"
+                      "do\n"
+                      "{ l1 : ; l2 : ; -- x ; }\n"
+                      "while ( x ) ;\n"
+                      "}",
+                      tokenizeAndStringify("void f(int x) {\n"
+                                           "  do\n"
+                                           "  l1: l2: { -- x; }\n"
+                                           "  while (x);\n"
+                                           "}"));
+
+        // Labels before try/catch
+        ASSERT_EQUALS("void f ( int x ) {\n"
+                      "do {\n"
+                      "l1 : ; l2 : ;\n"
+                      "try { throw 1 ; }\n"
+                      "catch ( ... ) { -- x ; } }\n"
+                      "while ( x ) ;\n"
+                      "}",
+                      tokenizeAndStringify("void f(int x) {\n"
+                                           "  do\n"
+                                           "  l1: l2:\n"
+                                           "    try { throw 1; }\n"
+                                           "    catch(...) { --x; }\n"
+                                           "  while (x);\n"
+                                           "}"));
+    }
+
     void forAddBraces1() {
         {
             const char code[] = "void f() {\n"
@@ -1462,7 +1655,10 @@ class TestTokenizer : public TestFixture {
                                     "if ( a ) { }\n"
                                     "else { } }\n"
                                     "}";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+            ASSERT_EQUALS(
+                "[test.cpp:3:14]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable a [valueFlowBailoutIncompleteVar]\n",
+                filter_valueflow(errout_str()));
         }
 
         {
@@ -1478,7 +1674,10 @@ class TestTokenizer : public TestFixture {
                                     "else { if ( b ) { }\n"
                                     "else { } } }\n"
                                     "}";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+            ASSERT_EQUALS(
+                "[test.cpp:3:14]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable a [valueFlowBailoutIncompleteVar]\n",
+                filter_valueflow(errout_str()));
         }
     }
 
@@ -1489,1665 +1688,132 @@ class TestTokenizer : public TestFixture {
         const char expected[] = "void f ( ) {\n"
                                 "for ( ; ; ) { try { } catch ( ... ) { } }\n"
                                 "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
 
-    std::string simplifyKnownVariables(const char code[]) {
-        errout.str("");
-
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+    void forAddBracesLabels() {
+        // Labels before statement
+        ASSERT_EQUALS("void f ( int x ) {\n"
+                      "for ( ; x ; ) {\n"
+                      "l1 : ; l2 : ; -- x ; }\n"
+                      "}",
+                      tokenizeAndStringify("void f(int x) {\n"
+                                           "  for ( ; x; )\n"
+                                           "  l1: l2: --x;\n"
+                                           "}"));
 
-        tokenizer.simplifyKnownVariables();
+        // Labels before {
+        ASSERT_EQUALS("void f ( int x ) {\n"
+                      "for ( ; x ; )\n"
+                      "{ l1 : ; l2 : ; -- x ; }\n"
+                      "}",
+                      tokenizeAndStringify("void f(int x) {\n"
+                                           "  for ( ; x; )\n"
+                                           "  l1: l2: { -- x; }\n"
+                                           "}"));
 
-        return tokenizer.tokens()->stringifyList(nullptr, false);
+        // Labels before try/catch
+        ASSERT_EQUALS("void f ( int x ) {\n"
+                      "for ( ; x ; ) {\n"
+                      "l1 : ; l2 : ;\n"
+                      "try { throw 1 ; }\n"
+                      "catch ( ... ) { -- x ; } }\n"
+                      "}",
+                      tokenizeAndStringify("void f(int x) {\n"
+                                           "  for ( ; x; )\n"
+                                           "  l1: l2:\n"
+                                           "    try { throw 1; }\n"
+                                           "    catch(...) { --x; }\n"
+                                           "}"));
     }
 
-    void simplifyKnownVariables1() {
+
+    void simplifyExternC() {
+        const char expected[] = "int foo ( ) ;";
         {
-            const char code[] = "void f()\n"
-                                "{\n"
-                                "    int a = 10;\n"
-                                "    if (a);\n"
-                                "}\n";
+            const char code[] = "extern \"C\" int foo();";
+            // tokenize..
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            // Expected result..
+            ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+            ASSERT(tokenizer.tokens()->next()->isExternC());
+        }
+        {
+            const char code[] = "extern \"C\" { int foo(); }";
+            // tokenize..
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            // Expected result..
+            ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+            ASSERT(tokenizer.tokens()->next()->isExternC());
+        }
+        {
+            const char code[] = "extern \"C++\" int foo();";
+            // tokenize..
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            // Expected result..
+            ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+            ASSERT(!tokenizer.tokens()->next()->isExternC());
+        }
+        {
+            const char code[] = "extern \"C++\" { int foo(); }";
+            // tokenize..
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            // Expected result..
+            ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+            ASSERT(!tokenizer.tokens()->next()->isExternC());
+        }
+    }
 
-            ASSERT_EQUALS(
-                "void f ( ) { int a ; a = 10 ; if ( 10 ) { ; } }",
-                simplifyKnownVariables(code));
+    void simplifyFunctionParameters() {
+        {
+            const char code[] = "char a [ ABC ( DEF ) ] ;";
+            ASSERT_EQUALS(code, tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "void f()\n"
-                                "{\n"
-                                "    int a = 10;\n"
-                                "    if (!a);\n"
-                                "}\n";
+            const char code[] = "module ( a , a , sizeof ( a ) , 0444 ) ;";
+            ASSERT_EQUALS("module ( a , a , sizeof ( a ) , 0444 ) ;", tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        ASSERT_EQUALS("void f ( int x ) { }", tokenizeAndStringify("void f(x) int x; { }"));
+        ASSERT_EQUALS("", errout_str());
+        ASSERT_EQUALS("void f ( int x , char y ) { }", tokenizeAndStringify("void f(x,y) int x; char y; { }"));
+        ASSERT_EQUALS("", errout_str());
+        ASSERT_EQUALS("int main ( int argc , char * argv [ ] ) { }", tokenizeAndStringify("int main(argc,argv) int argc; char *argv[]; { }"));
+        ASSERT_EQUALS("", errout_str());
+        ASSERT_EQUALS("int f ( int p , int w , float d ) { }", tokenizeAndStringify("int f(p,w,d) float d; { }"));
+        ASSERT_EQUALS("", errout_str());
+
+        // #1067 - Not simplified. Feel free to fix so it is simplified correctly but this syntax is obsolescent.
+        ASSERT_EQUALS("int ( * d ( a , b , c ) ) ( ) int a ; int b ; int c ; { }", tokenizeAndStringify("int (*d(a,b,c))()int a,b,c; { }"));
+        ASSERT_EQUALS("", errout_str());
 
+        {
+            // This is not a function but the pattern is similar..
+            const char code[] = "void foo()"
+                                "{"
+                                "    if (x)"
+                                "        int x;"
+                                "    { }"
+                                "}";
+            ASSERT_EQUALS("void foo ( ) { if ( x ) { int x ; } { } }", tokenizeAndStringify(code));
             ASSERT_EQUALS(
-                "void f ( ) { int a ; a = 10 ; if ( ! 10 ) { ; } }",
-                simplifyKnownVariables(code));
+                "[test.cpp:1:20]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable x [valueFlowBailoutIncompleteVar]\n",
+                filter_valueflow(errout_str()));
         }
     }
 
-    void simplifyKnownVariables2() {
-        const char code[] = "void f()\n"
-                            "{\n"
-                            "    int a = 10;\n"
-                            "    a = g();\n"
-                            "    if (a);\n"
-                            "}\n";
-
-        ASSERT_EQUALS(
-            "void f ( ) { int a ; a = 10 ; a = g ( ) ; if ( a ) { ; } }",
-            simplifyKnownVariables(code));
-    }
-
-    void simplifyKnownVariables3() {
-        const char code[] = "void f()\n"
-                            "{\n"
-                            "    int a = 4;\n"
-                            "    while(true){\n"
-                            "    break;\n"
-                            "    a = 10;\n"
-                            "    }\n"
-                            "    if (a);\n"
-                            "}\n";
-
-        ASSERT_EQUALS(
-            "void f ( ) { int a ; a = 4 ; while ( true ) { break ; a = 10 ; } if ( a ) { ; } }",
-            simplifyKnownVariables(code));
-    }
-
-    void simplifyKnownVariables4() {
-        const char code[] = "void f()\n"
-                            "{\n"
-                            "    int a = 4;\n"
-                            "    if ( g(a));\n"
-                            "}\n";
-
-        // TODO: if a is passed by value is is ok to simplify..
-        ASSERT_EQUALS(
-            "void f ( ) { int a ; a = 4 ; if ( g ( a ) ) { ; } }",
-            simplifyKnownVariables(code));
-    }
-
-    void simplifyKnownVariables5() {
-        const char code[] = "void f()\n"
-                            "{\n"
-                            "    int a = 4;\n"
-                            "    if ( a = 5 );\n"
-                            "}\n";
-
-        ASSERT_EQUALS(
-            "void f ( ) { int a ; a = 4 ; if ( a = 5 ) { ; } }",
-            simplifyKnownVariables(code));
-    }
-
-    void simplifyKnownVariables6() {
-        const char code[] = "void f()\n"
-                            "{\n"
-                            "    char str[2];"
-                            "    int a = 4;\n"
-                            "    str[a] = 0;\n"
-                            "}\n";
-
-        ASSERT_EQUALS(
-            "void f ( ) { char str [ 2 ] ; int a ; a = 4 ; str [ 4 ] = 0 ; }",
-            simplifyKnownVariables(code));
-    }
-
-    void simplifyKnownVariables7() {
-        const char code[] = "void foo()\n"
-                            "{\n"
-                            "    int i = 22;\n"
-                            "    abc[i++] = 1;\n"
-                            "    abc[++i] = 2;\n"
-                            "}\n";
-
-        ASSERT_EQUALS(
-            "void foo ( ) { int i ; i = 24 ; abc [ 22 ] = 1 ; abc [ 24 ] = 2 ; }",
-            simplifyKnownVariables(code));
-    }
-
-    void simplifyKnownVariables8() {
-        const char code[] = "void foo()\n"
-                            "{\n"
-                            "    int i = 22;\n"
-                            "    i++;\n"
-                            "    abc[i] = 0;\n"
-                            "}\n";
-
-        ASSERT_EQUALS(
-            "void foo ( ) { int i ; i = 23 ; abc [ 23 ] = 0 ; }",
-            simplifyKnownVariables(code));
-    }
-
-    void simplifyKnownVariables9() {
-        const char code[] = "void foo()\n"
-                            "{\n"
-                            "    int a = 1, b = 2;\n"
-                            "    if (a < b)\n"
-                            "        ;\n"
-                            "}\n";
-
-        ASSERT_EQUALS(
-            "void foo ( ) { int a ; a = 1 ; int b ; b = 2 ; if ( 1 < 2 ) { ; } }",
-            simplifyKnownVariables(code));
-    }
-
-    void simplifyKnownVariables10() {
-        {
-            const char code[] = "void f()\n"
-                                "{\n"
-                                "  bool b=false;\n"
-                                "\n"
-                                "  {\n"
-                                "    b = true;\n"
-                                "  }\n"
-                                "\n"
-                                "  if( b )\n"
-                                "  {\n"
-                                "    a();\n"
-                                "  }\n"
-                                "}\n";
-
-            const std::string expected1("void f ( ) {"
-                                        " bool b ; b = false ;"
-                                        " { b = true ; }");
-
-            TODO_ASSERT_EQUALS(
-                expected1 + " if ( true ) { a ( ) ; } }",
-                expected1 + " if ( b ) { a ( ) ; } }",
-                simplifyKnownVariables(code));
-
-        }
-
-        {
-            const char code[] = "void f()\n"
-                                "{\n"
-                                "  bool b=false;\n"
-                                "  { b = false; }\n"
-                                "  {\n"
-                                "    b = true;\n"
-                                "  }\n"
-                                "\n"
-                                "  if( b )\n"
-                                "  {\n"
-                                "    a();\n"
-                                "  }\n"
-                                "}\n";
-
-            TODO_ASSERT_EQUALS(
-                "void f ( ) { bool b ; b = false ; { b = false ; } { b = true ; } if ( true ) { a ( ) ; } }",
-                "void f ( ) { bool b ; b = false ; { b = false ; } { b = true ; } if ( b ) { a ( ) ; } }",
-                simplifyKnownVariables(code));
-        }
-
-        {
-            const char code[] = "void f()\n"
-                                "{\n"
-                                "  int b=0;\n"
-                                "  b = 1;\n"
-                                "  for( int i = 0; i < 10; i++ )"
-                                "  {\n"
-                                "  }\n"
-                                "\n"
-                                "  return b;\n"
-                                "}\n";
-
-            ASSERT_EQUALS(
-                "void f ( ) { int b ; b = 0 ; b = 1 ; for ( int i = 0 ; i < 10 ; i ++ ) { } return 1 ; }",
-                simplifyKnownVariables(code));
-        }
-    }
-
-    void simplifyKnownVariables11() {
-        const char code[] = "const int foo = 0;\n"
-                            "int main()\n"
-                            "{\n"
-                            "  int foo=0;\n"
-                            "}\n";
-
-        ASSERT_EQUALS(
-            "int main ( ) { int foo ; foo = 0 ; }",
-            simplifyKnownVariables(code));
-    }
-
-    void simplifyKnownVariables13() {
-        const char code[] = "void f()\n"
-                            "{\n"
-                            "    int i = 10;\n"
-                            "    while(--i) {}\n"
-                            "}\n";
-
-        ASSERT_EQUALS(
-            "void f ( ) { int i ; i = 10 ; while ( -- i ) { } }",
-            simplifyKnownVariables(code));
-    }
-
-    void simplifyKnownVariables14() {
-        // ticket #753
-        const char code[] = "void f ( ) { int n ; n = 1 ; do { ++ n ; } while ( n < 10 ) ; }";
-        ASSERT_EQUALS(code, simplifyKnownVariables(code));
-    }
-
-    void simplifyKnownVariables15() {
-        {
-            const char code[] = "int main()\n"
-                                "{\n"
-                                "  int x=5;\n"
-                                "  std::cout << 10 / x << std::endl;\n"
-                                "}\n";
-
-            ASSERT_EQUALS(
-                "int main ( ) { int x ; x = 5 ; std :: cout << 10 / 5 << std :: endl ; }",
-                simplifyKnownVariables(code));
-        }
-
-        {
-            const char code[] = "int main()\n"
-                                "{\n"
-                                "  int x=5;\n"
-                                "  std::cout << x / ( x == 1 ) << std::endl;\n"
-                                "}\n";
-
-            ASSERT_EQUALS(
-                "int main ( ) { int x ; x = 5 ; std :: cout << 5 / ( 5 == 1 ) << std :: endl ; }",
-                simplifyKnownVariables(code));
-        }
-    }
-
-    void simplifyKnownVariables16() {
-        // ticket #807 - segmentation fault when macro isn't found
-        const char code[] = "void f ( ) { int n = 1; DISPATCH(while); }";
-        ASSERT_THROW(simplifyKnownVariables(code), InternalError);
-    }
-
-    void simplifyKnownVariables17() {
-        // ticket #807 - segmentation fault when macro isn't found
-        const char code[] = "void f ( ) { char *s = malloc(100);mp_ptr p = s; p++; }";
-        ASSERT_EQUALS(
-            "void f ( ) { char * s ; s = malloc ( 100 ) ; mp_ptr p ; p = s ; p ++ ; }",
-            simplifyKnownVariables(code));
-    }
-
-    void simplifyKnownVariables18() {
-        const char code[] = "void f ( ) { char *s = malloc(100);mp_ptr p = s; ++p; }";
-        ASSERT_EQUALS(
-            "void f ( ) { char * s ; s = malloc ( 100 ) ; mp_ptr p ; p = s ; ++ p ; }",
-            simplifyKnownVariables(code));
-    }
-
-    void simplifyKnownVariables19() {
-        const char code[] = "void f ( ) { int i=0; do { if (i>0) { a(); } i=b(); } while (i != 12); }";
-        ASSERT_EQUALS(
-            "void f ( ) { int i ; i = 0 ; do { if ( i > 0 ) { a ( ) ; } i = b ( ) ; } while ( i != 12 ) ; }",
-            simplifyKnownVariables(code));
-    }
-
-    void simplifyKnownVariables20() {
-        const char code[] = "void f()\n"
-                            "{\n"
-                            "    int i = 0;\n"
-                            "    if (x) {\n"
-                            "        if (i) i=0;\n"
-                            "    }\n"
-                            "}\n";
-
-        ASSERT_EQUALS(
-            "void f ( ) { int i ; i = 0 ; if ( x ) { if ( 0 ) { i = 0 ; } } }",
-            simplifyKnownVariables(code));
-    }
-
-    void simplifyKnownVariables21() {
-        const char code[] = "void foo() { int n = 10; for (int i = 0; i < n; ++i) { } }";
-
-        ASSERT_EQUALS(
-            "void foo ( ) { int n ; n = 10 ; for ( int i = 0 ; i < 10 ; ++ i ) { } }",
-            simplifyKnownVariables(code));
-
-        ASSERT_EQUALS(
-            "void foo ( int i ) { int n ; n = i ; for ( i = 0 ; i < n ; ++ i ) { } }",
-            simplifyKnownVariables("void foo(int i) { int n = i; for (i = 0; i < n; ++i) { } }"));
-    }
-
-    void simplifyKnownVariables22() {
-        // This testcase is related to ticket #1169
-        {
-            const char code[] = "void foo()\n"
-                                "{\n"
-                                "    int n = 10;\n"
-                                "    i = (n >> 1);\n"
-                                "}\n";
-
-            ASSERT_EQUALS(
-                "void foo ( ) { int n ; n = 10 ; i = 10 >> 1 ; }",
-                simplifyKnownVariables(code));
-        }
-        {
-            const char code[] = "void foo()\n"
-                                "{\n"
-                                "    int n = 10;\n"
-                                "    i = (n << 1);\n"
-                                "}\n";
-
-            ASSERT_EQUALS(
-                "void foo ( ) { int n ; n = 10 ; i = 10 << 1 ; }",
-                simplifyKnownVariables(code));
-        }
-        {
-            const char code[] = "void foo()\n"
-                                "{\n"
-                                "    int n = 10;\n"
-                                "    i = (1 << n);\n"
-                                "}\n";
-
-            ASSERT_EQUALS(
-                "void foo ( ) { int n ; n = 10 ; i = 1 << 10 ; }",
-                simplifyKnownVariables(code));
-        }
-        {
-            const char code[] = "void foo()\n"
-                                "{\n"
-                                "    int n = 10;\n"
-                                "    i = (1 >> n);\n"
-                                "}\n";
-
-            ASSERT_EQUALS(
-                "void foo ( ) { int n ; n = 10 ; i = 1 >> 10 ; }",
-                simplifyKnownVariables(code));
-        }
-    }
-
-    void simplifyKnownVariables23() {
-        // This testcase is related to ticket #1596
-        const char code[] = "void foo(int x)\n"
-                            "{\n"
-                            "    int a[10], c = 0;\n"
-                            "    if (x) {\n"
-                            "        a[c] = 0;\n"
-                            "        c++;\n"
-                            "    } else {\n"
-                            "        a[c] = 0;\n"
-                            "    }\n"
-                            "}\n";
-
-        TODO_ASSERT_EQUALS(
-            "void foo ( int x ) "
-            "{"
-            " int a [ 10 ] ; int c ; c = 0 ;"
-            " if ( x ) { a [ 0 ] = 0 ; c = 1 ; }"
-            " else { a [ 0 ] = 0 ; } "
-            "}",
-
-            "void foo ( int x ) "
-            "{"
-            " int a [ 10 ] ; int c ; c = 0 ;"
-            " if ( x ) { a [ 0 ] = 0 ; c ++ ; }"
-            " else { a [ c ] = 0 ; } "
-            "}",
-
-            simplifyKnownVariables(code));
-    }
-
-    void simplifyKnownVariables25() {
-        {
-            // This testcase is related to ticket #1646
-            const char code[] = "void foo(char *str)\n"
-                                "{\n"
-                                "    int i;\n"
-                                "    for (i=0;i<10;++i) {\n"
-                                "        if (*str == 0) goto label;\n"
-                                "    }\n"
-                                "    return;\n"
-                                "label:\n"
-                                "    str[i] = 0;\n"
-                                "}\n";
-
-            // Current result
-            ASSERT_EQUALS(
-                "void foo ( char * str ) "
-                "{"
-                " int i ;"
-                " for ( i = 0 ; i < 10 ; ++ i ) {"
-                " if ( * str == 0 ) { goto label ; }"
-                " }"
-                " return ;"
-                " label : ;"
-                " str [ i ] = 0 ; "
-                "}",
-                simplifyKnownVariables(code));
-        }
-
-        {
-            // This testcase is related to ticket #1646
-            const char code[] = "void foo(char *str)\n"
-                                "{\n"
-                                "    int i;\n"
-                                "    for (i=0;i<10;++i) { }\n"
-                                "    return;\n"
-                                "    str[i] = 0;\n"
-                                "}\n";
-
-            // Current result
-            ASSERT_EQUALS(
-                "void foo ( char * str ) "
-                "{"
-                " int i ;"
-                " for ( i = 0 ; i < 10 ; ++ i ) { }"
-                " return ;"
-                " str [ i ] = 0 ; "
-                "}",
-                simplifyKnownVariables(code));
-        }
-    }
-
-    void simplifyKnownVariables27() {
-        // This testcase is related to ticket #1633
-        const char code[] = "void foo()\n"
-                            "{\n"
-                            "    int i1 = 1;\n"
-                            "    int i2 = 2;\n"
-                            "    int i3 = (i1 + i2) * 3;\n"
-                            "}\n";
-        ASSERT_EQUALS(
-            "void foo ( ) "
-            "{"
-            " int i1 ; i1 = 1 ;"
-            " int i2 ; i2 = 2 ;"
-            " int i3 ; i3 = ( 1 + 2 ) * 3 ; "
-            "}",
-            simplifyKnownVariables(code));
-    }
-
-    void simplifyKnownVariables28() {
-        const char code[] = "void foo(int g)\n"
-                            "{\n"
-                            "  int i = 2;\n"
-                            "  if (g) {\n"
-                            "  }\n"
-                            "  if (i > 0) {\n"
-                            "  }\n"
-                            "}\n";
-        ASSERT_EQUALS(
-            "void foo ( int g ) "
-            "{"
-            " int i ; i = 2 ;"
-            " if ( g ) { }"
-            " if ( 2 > 0 ) { } "
-            "}",
-            simplifyKnownVariables(code));
-    }
-
-    void simplifyKnownVariables29() { // ticket #1811
-        {
-            const char code[] = "int foo(int u, int v)\n"
-                                "{\n"
-                                "  int h = u;\n"
-                                "  int i = v;\n"
-                                "  return h + i;\n"
-                                "}\n";
-            const char expected[] = "1: int foo ( int u@1 , int v@2 )\n"
-                                    "2: {\n"
-                                    "3:\n"
-                                    "4:\n"
-                                    "5: return u@1 + v@2 ;\n"
-                                    "6: }\n";
-            ASSERT_EQUALS(expected, tokenizeDebugListing(code, true));
-        }
-
-        {
-            const char code[] = "int foo(int u, int v)\n"
-                                "{\n"
-                                "  int h = u;\n"
-                                "  int i = v;\n"
-                                "  return h - i;\n"
-                                "}\n";
-            const char expected[] = "1: int foo ( int u@1 , int v@2 )\n"
-                                    "2: {\n"
-                                    "3:\n"
-                                    "4:\n"
-                                    "5: return u@1 - v@2 ;\n"
-                                    "6: }\n";
-            ASSERT_EQUALS(expected, tokenizeDebugListing(code, true));
-        }
-
-        {
-            const char code[] = "int foo(int u, int v)\n"
-                                "{\n"
-                                "  int h = u;\n"
-                                "  int i = v;\n"
-                                "  return h * i;\n"
-                                "}\n";
-            const char expected[] = "1: int foo ( int u@1 , int v@2 )\n"
-                                    "2: {\n"
-                                    "3:\n"
-                                    "4:\n"
-                                    "5: return u@1 * v@2 ;\n"
-                                    "6: }\n";
-            ASSERT_EQUALS(expected, tokenizeDebugListing(code, true));
-        }
-
-        {
-            const char code[] = "int foo(int u, int v)\n"
-                                "{\n"
-                                "  int h = u;\n"
-                                "  int i = v;\n"
-                                "  return h / i;\n"
-                                "}\n";
-            const char expected[] = "1: int foo ( int u@1 , int v@2 )\n"
-                                    "2: {\n"
-                                    "3:\n"
-                                    "4:\n"
-                                    "5: return u@1 / v@2 ;\n"
-                                    "6: }\n";
-            ASSERT_EQUALS(expected, tokenizeDebugListing(code, true));
-        }
-
-        {
-            const char code[] = "int foo(int u, int v)\n"
-                                "{\n"
-                                "  int h = u;\n"
-                                "  int i = v;\n"
-                                "  return h & i;\n"
-                                "}\n";
-            const char expected[] = "1: int foo ( int u@1 , int v@2 )\n"
-                                    "2: {\n"
-                                    "3:\n"
-                                    "4:\n"
-                                    "5: return u@1 & v@2 ;\n"
-                                    "6: }\n";
-            ASSERT_EQUALS(expected, tokenizeDebugListing(code, true));
-        }
-
-        {
-            const char code[] = "int foo(int u, int v)\n"
-                                "{\n"
-                                "  int h = u;\n"
-                                "  int i = v;\n"
-                                "  return h | i;\n"
-                                "}\n";
-            const char expected[] = "1: int foo ( int u@1 , int v@2 )\n"
-                                    "2: {\n"
-                                    "3:\n"
-                                    "4:\n"
-                                    "5: return u@1 | v@2 ;\n"
-                                    "6: }\n";
-            ASSERT_EQUALS(expected, tokenizeDebugListing(code, true));
-        }
-
-        {
-            const char code[] = "int foo(int u, int v)\n"
-                                "{\n"
-                                "  int h = u;\n"
-                                "  int i = v;\n"
-                                "  return h ^ i;\n"
-                                "}\n";
-            const char expected[] = "1: int foo ( int u@1 , int v@2 )\n"
-                                    "2: {\n"
-                                    "3:\n"
-                                    "4:\n"
-                                    "5: return u@1 ^ v@2 ;\n"
-                                    "6: }\n";
-            ASSERT_EQUALS(expected, tokenizeDebugListing(code, true));
-        }
-
-        {
-            const char code[] = "int foo(int u, int v)\n"
-                                "{\n"
-                                "  int h = u;\n"
-                                "  int i = v;\n"
-                                "  return h % i;\n"
-                                "}\n";
-            const char expected[] = "1: int foo ( int u@1 , int v@2 )\n"
-                                    "2: {\n"
-                                    "3:\n"
-                                    "4:\n"
-                                    "5: return u@1 % v@2 ;\n"
-                                    "6: }\n";
-            ASSERT_EQUALS(expected, tokenizeDebugListing(code, true));
-        }
-
-        {
-            const char code[] = "int foo(int u, int v)\n"
-                                "{\n"
-                                "  int h = u;\n"
-                                "  int i = v;\n"
-                                "  return h >> i;\n"
-                                "}\n";
-            const char expected[] = "1: int foo ( int u@1 , int v@2 )\n"
-                                    "2: {\n"
-                                    "3:\n"
-                                    "4:\n"
-                                    "5: return u@1 >> v@2 ;\n"
-                                    "6: }\n";
-            ASSERT_EQUALS(expected, tokenizeDebugListing(code, true));
-        }
-
-        {
-            const char code[] = "int foo(int u, int v)\n"
-                                "{\n"
-                                "  int h = u;\n"
-                                "  int i = v;\n"
-                                "  return h << i;\n"
-                                "}\n";
-            const char expected[] = "1: int foo ( int u@1 , int v@2 )\n"
-                                    "2: {\n"
-                                    "3:\n"
-                                    "4:\n"
-                                    "5: return u@1 << v@2 ;\n"
-                                    "6: }\n";
-            ASSERT_EQUALS(expected, tokenizeDebugListing(code, true));
-        }
-
-        {
-            const char code[] = "bool foo(int u, int v)\n"
-                                "{\n"
-                                "  int h = u;\n"
-                                "  int i = v;\n"
-                                "  return h == i;\n"
-                                "}\n";
-            const char expected[] = "1: bool foo ( int u@1 , int v@2 )\n"
-                                    "2: {\n"
-                                    "3:\n"
-                                    "4:\n"
-                                    "5: return u@1 == v@2 ;\n"
-                                    "6: }\n";
-            ASSERT_EQUALS(expected, tokenizeDebugListing(code, true));
-        }
-
-        {
-            const char code[] = "bool foo(int u, int v)\n"
-                                "{\n"
-                                "  int h = u;\n"
-                                "  int i = v;\n"
-                                "  return h != i;\n"
-                                "}\n";
-            const char expected[] = "1: bool foo ( int u@1 , int v@2 )\n"
-                                    "2: {\n"
-                                    "3:\n"
-                                    "4:\n"
-                                    "5: return u@1 != v@2 ;\n"
-                                    "6: }\n";
-            ASSERT_EQUALS(expected, tokenizeDebugListing(code, true));
-        }
-
-        {
-            const char code[] = "bool foo(int u, int v)\n"
-                                "{\n"
-                                "  int h = u;\n"
-                                "  int i = v;\n"
-                                "  return h > i;\n"
-                                "}\n";
-            const char expected[] = "1: bool foo ( int u@1 , int v@2 )\n"
-                                    "2: {\n"
-                                    "3:\n"
-                                    "4:\n"
-                                    "5: return u@1 > v@2 ;\n"
-                                    "6: }\n";
-            ASSERT_EQUALS(expected, tokenizeDebugListing(code, true));
-        }
-
-        {
-            const char code[] = "bool foo(int u, int v)\n"
-                                "{\n"
-                                "  int h = u;\n"
-                                "  int i = v;\n"
-                                "  return h >= i;\n"
-                                "}\n";
-            const char expected[] = "1: bool foo ( int u@1 , int v@2 )\n"
-                                    "2: {\n"
-                                    "3:\n"
-                                    "4:\n"
-                                    "5: return u@1 >= v@2 ;\n"
-                                    "6: }\n";
-            ASSERT_EQUALS(expected, tokenizeDebugListing(code, true));
-        }
-
-        {
-            const char code[] = "bool foo(int u, int v)\n"
-                                "{\n"
-                                "  int h = u;\n"
-                                "  int i = v;\n"
-                                "  return h < i;\n"
-                                "}\n";
-            const char expected[] = "1: bool foo ( int u@1 , int v@2 )\n"
-                                    "2: {\n"
-                                    "3:\n"
-                                    "4:\n"
-                                    "5: return u@1 < v@2 ;\n"
-                                    "6: }\n";
-            ASSERT_EQUALS(expected, tokenizeDebugListing(code, true));
-        }
-
-        {
-            const char code[] = "bool foo(int u, int v)\n"
-                                "{\n"
-                                "  int h = u;\n"
-                                "  int i = v;\n"
-                                "  return h <= i;\n"
-                                "}\n";
-            const char expected[] = "1: bool foo ( int u@1 , int v@2 )\n"
-                                    "2: {\n"
-                                    "3:\n"
-                                    "4:\n"
-                                    "5: return u@1 <= v@2 ;\n"
-                                    "6: }\n";
-            ASSERT_EQUALS(expected, tokenizeDebugListing(code, true));
-        }
-
-        {
-            const char code[] = "bool foo(int u, int v)\n"
-                                "{\n"
-                                "  int h = u;\n"
-                                "  int i = v;\n"
-                                "  return h && i;\n"
-                                "}\n";
-            const char wanted[] = "1: bool foo ( int u@1 , int v@2 )\n"
-                                  "2: {\n"
-                                  "3:\n"
-                                  "4:\n"
-                                  "5: return u@1 && v@2 ;\n"
-                                  "6: }\n";
-            ASSERT_EQUALS(wanted, tokenizeDebugListing(code, true));
-        }
-
-        {
-            const char code[] = "bool foo(int u, int v)\n"
-                                "{\n"
-                                "  int h = u;\n"
-                                "  int i = v;\n"
-                                "  return h || i;\n"
-                                "}\n";
-            const char wanted[] = "1: bool foo ( int u@1 , int v@2 )\n"
-                                  "2: {\n"
-                                  "3:\n"
-                                  "4:\n"
-                                  "5: return u@1 || v@2 ;\n"
-                                  "6: }\n";
-            ASSERT_EQUALS(wanted, tokenizeDebugListing(code, true));
-        }
-    }
-
-    void simplifyKnownVariables30() {
-        const char code[] = "int foo() {\n"
-                            "  iterator it1 = ints.begin();\n"
-                            "  iterator it2 = it1;\n"
-                            "  for (++it2;it2!=ints.end();++it2);\n"
-                            "}\n";
-        const char expected[] = "int foo ( ) {\n"
-                                "iterator it1 ; it1 = ints . begin ( ) ;\n"
-                                "iterator it2 ; it2 = it1 ;\n"
-                                "for ( ++ it2 ; it2 != ints . end ( ) ; ++ it2 ) { ; }\n"
-                                "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-    }
-
-    void simplifyKnownVariables31() {
-        const char code[] = "void foo(const char str[]) {\n"
-                            "    const char *p = str;\n"
-                            "    if (p[0] == 0) {\n"
-                            "    }\n"
-                            "}\n";
-        const char expected[] = "void foo ( const char str [ ] ) {\n"
-                                "const char * p ; p = str ;\n"
-                                "if ( str [ 0 ] == 0 ) {\n"
-                                "}\n"
-                                "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-    }
-
-    void simplifyKnownVariables32() {
-        {
-            const char code[] = "void foo() {\n"
-                                "    const int x = 0;\n"
-                                "    bar(0,x);\n"
-                                "}\n";
-            const char expected[] = "void foo ( ) {\n\nbar ( 0 , 0 ) ;\n}";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-        }
-
-        {
-            const char code[] = "static int const SZ = 22; char str[SZ];\n";
-            ASSERT_EQUALS("char str [ 22 ] ;", tokenizeAndStringify(code,true));
-        }
-    }
-
-    void simplifyKnownVariables33() {
-        const char code[] = "static void foo(struct Foo *foo) {\n"
-                            "    foo->a = 23;\n"
-                            "    x[foo->a] = 0;\n"
-                            "}\n";
-        const char expected[] = "static void foo ( struct Foo * foo ) {\n"
-                                "foo . a = 23 ;\n"
-                                "x [ 23 ] = 0 ;\n"
-                                "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-    }
-
-    void simplifyKnownVariables34() {
-        const char code[] = "void f() {\n"
-                            "    int x = 10;\n"
-                            "    do { cin >> x; } while (x > 5);\n"
-                            "    a[x] = 0;\n"
-                            "}\n";
-        const char expected[] = "void f ( ) {\n"
-                                "int x ; x = 10 ;\n"
-                                "do { cin >> x ; } while ( x > 5 ) ;\n"
-                                "a [ x ] = 0 ;\n"
-                                "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-    }
-
-    void simplifyKnownVariables35() {
-        // Ticket #2353
-        const char code[] = "int f() {"
-                            "    int x = 0;"
-                            "    if (x == 0) {"
-                            "        return 0;"
-                            "    }"
-                            "    return 10 / x;"
-                            "}";
-        const char expected[] = "int f ( ) { int x ; x = 0 ; { return 0 ; } }";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-    }
-
-    void simplifyKnownVariables36() {
-        // Ticket #2304
-        const char code[] = "void f() {"
-                            "    const char *q = \"hello\";"
-                            "    strcpy(p, q);"
-                            "}";
-        const char expected[] = "void f ( ) { const char * q ; q = \"hello\" ; strcpy ( p , \"hello\" ) ; }";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-
-        // Ticket #5972
-        const char code2[] = "void f() {"
-                             "  char buf[10] = \"ab\";"
-                             "    memset(buf, 0, 10);"
-                             "}";
-        const char expected2[] = "void f ( ) { char buf [ 10 ] = \"ab\" ; memset ( buf , 0 , 10 ) ; }";
-        ASSERT_EQUALS(expected2, tokenizeAndStringify(code2, true));
-    }
-
-    void simplifyKnownVariables37() {
-        // Ticket #2398 - no simplification in for loop
-        const char code[] = "void f() {\n"
-                            "    double x = 0;\n"
-                            "    for (int iter=0; iter<42; iter++) {\n"
-                            "        int EvaldF = 1;\n"
-                            "        if (EvaldF)\n"
-                            "            Eval (x);\n"
-                            "    }\n"
-                            "}";
-        const char expected[] = "void f ( ) {\n"
-                                "double x ; x = 0 ;\n"
-                                "for ( int iter = 0 ; iter < 42 ; iter ++ ) {\n"
-                                "\n"
-                                "\n"
-                                "Eval ( x ) ;\n"
-                                "}\n"
-                                "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-    }
-
-    void simplifyKnownVariables38() {
-        // Ticket #2399 - simplify conditions
-        const char code[] = "void f() {\n"
-                            "    int x = 0;\n"
-                            "    int y = 1;\n"
-                            "    if (x || y);\n"
-                            "}";
-        const char expected[] = "void f ( ) {\n"
-                                "\n"
-                                "\n"
-                                ";\n"
-                                "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-    }
-
-    void simplifyKnownVariables39() {
-        // Ticket #2296 - simplify pointer alias 'delete p;'
-        {
-            const char code[] = "void f() {\n"
-                                "    int *x;\n"
-                                "    int *y = x;\n"
-                                "    delete y;\n"
-                                "}";
-            ASSERT_EQUALS("void f ( ) {\nint * x ;\n\ndelete x ;\n}", tokenizeAndStringify(code, true));
-        }
-        {
-            const char code[] = "void f() {\n"
-                                "    int *x;\n"
-                                "    int *y = x;\n"
-                                "    delete [] y;\n"
-                                "}";
-            ASSERT_EQUALS("void f ( ) {\nint * x ;\n\ndelete [ ] x ;\n}", tokenizeAndStringify(code, true));
-        }
-    }
-
-
-    void simplifyKnownVariables40() {
-        const char code[] = "void f() {\n"
-                            "    char c1 = 'a';\n"
-                            "    char c2 = { c1 };\n"
-                            "}";
-        ASSERT_EQUALS("void f ( ) {\n\nchar c2 ; c2 = { 'a' } ;\n}", tokenizeAndStringify(code, true));
-    }
-
-    void simplifyKnownVariables41() {
-        const char code[] = "void f() {\n"
-                            "    int x = 0;\n"
-                            "    const int *p; p = &x;\n"
-                            "    if (p) { return 0; }\n"
-                            "}";
-        ASSERT_EQUALS("void f ( ) {\nint x ; x = 0 ;\nconst int * p ; p = & x ;\nif ( & x ) { return 0 ; }\n}", tokenizeAndStringify(code, true));
-    }
-
-    void simplifyKnownVariables42() {
-        {
-            const char code[] = "void f() {\n"
-                                "    char str1[10], str2[10];\n"
-                                "    strcpy(str1, \"abc\");\n"
-                                "    strcpy(str2, str1);\n"
-                                "}";
-            const char expected[] = "void f ( ) {\n"
-                                    "char str1 [ 10 ] ; char str2 [ 10 ] ;\n"
-                                    "strcpy ( str1 , \"abc\" ) ;\n"
-                                    "strcpy ( str2 , \"abc\" ) ;\n"
-                                    "}";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-        }
-
-        {
-            const char code[] = "void f() {\n"
-                                "   char a[10];\n"
-                                "   strcpy(a, \"hello\");\n"
-                                "   strcat(a, \"!\");\n"
-                                "}";
-            const char expected[] = "void f ( ) {\n"
-                                    "char a [ 10 ] ;\n"
-                                    "strcpy ( a , \"hello\" ) ;\n"
-                                    "strcat ( a , \"!\" ) ;\n"
-                                    "}";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code, true, true, Settings::Native, "test.c"));
-        }
-
-        {
-            const char code[] = "void f() {"
-                                "    char *s = malloc(10);"
-                                "    strcpy(s, \"\");"
-                                "    free(s);"
-                                "}";
-            const char expected[] = "void f ( ) {"
-                                    " char * s ; s = malloc ( 10 ) ;"
-                                    " strcpy ( s , \"\" ) ;"
-                                    " free ( s ) ; "
-                                    "}";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-        }
-
-        {
-            const char code[] = "void f(char *p, char *q) {"
-                                "    strcpy(p, \"abc\");"
-                                "    q = p;"
-                                "}";
-            const char expected[] = "void f ( char * p , char * q ) {"
-                                    " strcpy ( p , \"abc\" ) ;"
-                                    " q = p ; "
-                                    "}";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-        }
-
-        // 3538
-        {
-            const char code[] = "void f() {\n"
-                                "    char s[10];\n"
-                                "    strcpy(s, \"123\");\n"
-                                "    if (s[6] == ' ');\n"
-                                "}";
-            const char expected[] = "void f ( ) {\n"
-                                    "char s [ 10 ] ;\n"
-                                    "strcpy ( s , \"123\" ) ;\n"
-                                    "if ( s [ 6 ] == ' ' ) { ; }\n"
-                                    "}";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code,true));
-        }
-    }
-
-    void simplifyKnownVariables43() {
-        {
-            const char code[] = "void f() {\n"
-                                "    int a, *p; p = &a;\n"
-                                "    { int a = *p; }\n"
-                                "}";
-            const char expected[] = "void f ( ) {\n"
-                                    "int a ; int * p ; p = & a ;\n"
-                                    "{ int a ; a = * p ; }\n"
-                                    "}";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-        }
-
-        {
-            const char code[] = "void f() {\n"
-                                "    int *a, **p; p = &a;\n"
-                                "    { int *a = *p; }\n"
-                                "}";
-            const char expected[] = "void f ( ) {\n"
-                                    "int * a ; int * * p ; p = & a ;\n"
-                                    "{ int * a ; a = * p ; }\n"
-                                    "}";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-        }
-    }
-
-    void simplifyKnownVariables44() {
-        const char code[] = "void a() {\n"
-                            "    static int i = 10;\n"
-                            "    b(i++);\n"
-                            "}";
-        const char expected[] = "void a ( ) {\n"
-                                "static int i = 10 ;\n"
-                                "b ( i ++ ) ;\n"
-                                "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-    }
-
-    void simplifyKnownVariables45() {
-        const char code[] = "class Fred {\n"
-                            "private:\n"
-                            "    const static int NUM = 2;\n"
-                            "    int array[NUM];\n"
-                            "}";
-        const char expected[] = "class Fred {\n"
-                                "private:\n"
-                                "\n"
-                                "int array [ 2 ] ;\n"
-                                "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-    }
-
-    void simplifyKnownVariables46() {
-        const char code[] = "void f() {\n"
-                            "    int x = 0;\n"
-                            "    cin >> x;\n"
-                            "    return x;\n"
-                            "}";
-
-        {
-            const char expected[] = "void f ( ) {\n"
-                                    "int x ; x = 0 ;\n"
-                                    "cin >> x ;\n"
-                                    "return x ;\n"
-                                    "}";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code, true, true, Settings::Native, "test.cpp"));
-        }
-
-        {
-            const char expected[] = "void f ( ) {\n"
-                                    "\n"
-                                    "cin >> 0 ;\n"
-                                    "return 0 ;\n"
-                                    "}";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code, true, true, Settings::Native, "test.c"));
-        }
-    }
-
-    void simplifyKnownVariables47() {
-        // #3621
-        const char code[] = "void f() {\n"
-                            "    int x = 0;\n"
-                            "    cin >> std::hex >> x;\n"
-                            "}";
-        const char expected[] = "void f ( ) {\n"
-                                "int x ; x = 0 ;\n"
-                                "cin >> std :: hex >> x ;\n"
-                                "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true, true, Settings::Native, "test.cpp"));
-    }
-
-    void simplifyKnownVariables48() {
-        // #3754
-        const char code[] = "void f(int sz) {\n"
-                            "    int i;\n"
-                            "    for (i = 0; ((i<sz) && (sz>3)); ++i) { }\n"
-                            "}";
-        const char expected[] = "void f ( int sz ) {\n"
-                                "int i ;\n"
-                                "for ( i = 0 ; ( i < sz ) && ( sz > 3 ) ; ++ i ) { }\n"
-                                "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true, true, Settings::Native, "test.c"));
-    }
-
-    void simplifyKnownVariables49() { // #3691
-        const char code[] = "void f(int sz) {\n"
-                            "    switch (x) {\n"
-                            "    case 1: sz = 2; continue;\n"
-                            "    case 2: x = sz; break;\n"
-                            "    }\n"
-                            "}";
-        const char expected[] = "void f ( int sz ) {\n"
-                                "switch ( x ) {\n"
-                                "case 1 : ; sz = 2 ; continue ;\n"
-                                "case 2 : ; x = sz ; break ;\n"
-                                "}\n"
-                                "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true, true, Settings::Native, "test.c"));
-    }
-
-    void simplifyKnownVariables50() { // #4066
-        {
-            const char code[] = "void f() {\n"
-                                "    char str1[10], str2[10];\n"
-                                "    sprintf(str1, \"%%\");\n"
-                                "    strcpy(str2, str1);\n"
-                                "}";
-            const char expected[] = "void f ( ) {\n"
-                                    "char str1 [ 10 ] ; char str2 [ 10 ] ;\n"
-                                    "sprintf ( str1 , \"%%\" ) ;\n"
-                                    "strcpy ( str2 , \"%\" ) ;\n"
-                                    "}";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-        }
-        {
-            const char code[] = "void f() {\n"
-                                "    char str1[25], str2[25];\n"
-                                "    sprintf(str1, \"abcdef%%%% and %% and %\");\n"
-                                "    strcpy(str2, str1);\n"
-                                "}";
-            const char expected[] = "void f ( ) {\n"
-                                    "char str1 [ 25 ] ; char str2 [ 25 ] ;\n"
-                                    "sprintf ( str1 , \"abcdef%%%% and %% and %\" ) ;\n"
-                                    "strcpy ( str2 , \"abcdef%% and % and %\" ) ;\n"
-                                    "}";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-        }
-        {
-            const char code[] = "void f() {\n"
-                                "    char str1[10], str2[10];\n"
-                                "    sprintf(str1, \"abc\");\n"
-                                "    strcpy(str2, str1);\n"
-                                "}";
-            const char expected[] = "void f ( ) {\n"
-                                    "char str1 [ 10 ] ; char str2 [ 10 ] ;\n"
-                                    "sprintf ( str1 , \"abc\" ) ;\n"
-                                    "strcpy ( str2 , \"abc\" ) ;\n"
-                                    "}";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-        }
-        {
-            //don't simplify '&x'!
-            const char code[] = "const char * foo ( ) {\n"
-                                "const char x1 = 'b' ;\n"
-                                "f ( & x1 ) ;\n"
-                                "const char x2 = 'b' ;\n"
-                                "f ( y , & x2 ) ;\n"
-                                "const char x3 = 'b' ;\n"
-                                "t = & x3 ;\n"
-                                "const char x4 = 'b' ;\n"
-                                "t = y + & x4 ;\n"
-                                "const char x5 = 'b' ;\n"
-                                "z [ & x5 ] = y ;\n"
-                                "const char x6 = 'b' ;\n"
-                                "v = { & x6 } ;\n"
-                                "const char x7 = 'b' ;\n"
-                                "return & x7 ;\n"
-                                "}";
-            ASSERT_EQUALS(code, tokenizeAndStringify(code, true));
-        }
-        {
-            //don't simplify '&x'!
-            const char code[] = "const int * foo ( ) {\n"
-                                "const int x1 = 1 ;\n"
-                                "f ( & x1 ) ;\n"
-                                "const int x2 = 1 ;\n"
-                                "f ( y , & x2 ) ;\n"
-                                "const int x3 = 1 ;\n"
-                                "t = & x3 ;\n"
-                                "const int x4 = 1 ;\n"
-                                "t = y + & x4 ;\n"
-                                "const int x5 = 1 ;\n"
-                                "z [ & x5 ] = y ;\n"
-                                "const int x6 = 1 ;\n"
-                                "v = { & x6 } ;\n"
-                                "const int x7 = 1 ;\n"
-                                "return & x7 ;\n"
-                                "}";
-            ASSERT_EQUALS(code, tokenizeAndStringify(code, true));
-        }
-    }
-
-    void simplifyKnownVariables51() { // #4409 hang
-        const char code[] = "void mhz_M(int enough) {\n"
-                            "  TYPE *x=&x, **p=x, **q = NULL;\n"
-                            "  BENCH1(q = _mhz_M(n); n = 1;)\n"
-                            "  use_pointer(q);\n"
-                            "}";
-        tokenizeAndStringify(code, true); // don't hang
-    }
-
-    void simplifyKnownVariables52() { // #4728 "= x %op%"
-        ASSERT_EQUALS("void f ( ) { int y ; y = 34 + z ; }", tokenizeAndStringify("void f() { int x=34; int y=x+z; }", true));
-        ASSERT_EQUALS("void f ( ) { int y ; y = 34 - z ; }", tokenizeAndStringify("void f() { int x=34; int y=x-z; }", true));
-        ASSERT_EQUALS("void f ( ) { int y ; y = 34 * z ; }", tokenizeAndStringify("void f() { int x=34; int y=x*z; }", true));
-        ASSERT_EQUALS("void f ( ) { int y ; y = 34 / z ; }", tokenizeAndStringify("void f() { int x=34; int y=x/z; }", true));
-        ASSERT_EQUALS("void f ( ) { int y ; y = 34 % z ; }", tokenizeAndStringify("void f() { int x=34; int y=x%z; }", true));
-        ASSERT_EQUALS("void f ( ) { int y ; y = 34 & z ; }", tokenizeAndStringify("void f() { int x=34; int y=x&z; }", true));
-        ASSERT_EQUALS("void f ( ) { int y ; y = 34 | z ; }", tokenizeAndStringify("void f() { int x=34; int y=x|z; }", true));
-        ASSERT_EQUALS("void f ( ) { int y ; y = 34 ^ z ; }", tokenizeAndStringify("void f() { int x=34; int y=x^z; }", true));
-        ASSERT_EQUALS("void f ( ) { int y ; y = 34 << z ; }", tokenizeAndStringify("void f() { int x=34; int y=x<<z; }", true));
-        ASSERT_EQUALS("void f ( ) { int y ; y = 34 >> z ; }", tokenizeAndStringify("void f() { int x=34; int y=x>>z; }", true));
-        ASSERT_EQUALS("void f ( ) { int y ; y = 34 && z ; }", tokenizeAndStringify("void f() { int x=34; int y=x&&z; }", true));
-        ASSERT_EQUALS("void f ( ) { int y ; y = 34 || z ; }", tokenizeAndStringify("void f() { int x=34; int y=x||z; }", true));
-        ASSERT_EQUALS("void f ( ) { int y ; y = 34 > z ; }", tokenizeAndStringify("void f() { int x=34; int y=x>z; }", true));
-        ASSERT_EQUALS("void f ( ) { int y ; y = 34 >= z ; }", tokenizeAndStringify("void f() { int x=34; int y=x>=z; }", true));
-        ASSERT_EQUALS("void f ( ) { int y ; y = 34 < z ; }", tokenizeAndStringify("void f() { int x=34; int y=x<z; }", true));
-        ASSERT_EQUALS("void f ( ) { int y ; y = 34 <= z ; }", tokenizeAndStringify("void f() { int x=34; int y=x<=z; }", true));
-        ASSERT_EQUALS("void f ( ) { int y ; y = 34 == z ; }", tokenizeAndStringify("void f() { int x=34; int y=x==z; }", true));
-        ASSERT_EQUALS("void f ( ) { int y ; y = 34 != z ; }", tokenizeAndStringify("void f() { int x=34; int y=x!=z; }", true));
-
-        // #4007
-        ASSERT_EQUALS("void f ( ) { }", tokenizeAndStringify("void f() { char *p = 0; int result = p && (!*p); }", true));
-        ASSERT_EQUALS("void f ( ) { }", tokenizeAndStringify("void f() { Foo *p = 0; bool b = (p && (p->type() == 1)); }", true));
-    }
-
-    void simplifyKnownVariables53() { // references
-        ASSERT_EQUALS("void f ( ) { int x ; x = abc ( ) ; }", tokenizeAndStringify("void f() { int x; int &ref=x; ref=abc(); }", true));
-        ASSERT_EQUALS("void f ( ) { int * p ; p = abc ( ) ; }", tokenizeAndStringify("void f() { int *p; int *&ref=p; ref=abc(); }", true));
-    }
-
-    void simplifyKnownVariables54() { // #4913
-        ASSERT_EQUALS("void f ( int * p ) { * -- p = 0 ; * p = 0 ; }", tokenizeAndStringify("void f(int*p) { *--p=0; *p=0; }", true));
-    }
-
-    void simplifyKnownVariables55() { // pointer alias
-        ASSERT_EQUALS("void f ( ) { int a ; if ( a > 0 ) { } }", tokenizeAndStringify("void f() { int a; int *p=&a; if (*p>0) {} }", true));
-        ASSERT_EQUALS("void f ( ) { int a ; struct AB ab ; ab . a = & a ; if ( a > 0 ) { } }", tokenizeAndStringify("void f() { int a; struct AB ab; ab.a = &a; if (*ab.a>0) {} }", true));
-        ASSERT_EQUALS("void f ( ) { int a ; if ( x > a ) { } }", tokenizeAndStringify("void f() { int a; int *p=&a; if (x>*p) {} }", true));
-    }
-
-    void simplifyKnownVariables56() { // ticket #5301 - >>
-        ASSERT_EQUALS("void f ( ) { int a ; a = 0 ; int b ; b = 0 ; * p >> a >> b ; return a / b ; }",
-                      tokenizeAndStringify("void f() { int a=0,b=0; *p>>a>>b; return a/b; }", true));
-    }
-
-    void simplifyKnownVariables57() { // #4724
-        ASSERT_EQUALS("unsigned long long x ; x = 9223372036854775808UL ;", tokenizeAndStringify("unsigned long long x = 1UL << 63 ;", true));
-        ASSERT_EQUALS("long long x ; x = -9223372036854775808L ;", tokenizeAndStringify("long long x = 1L << 63 ;", true));
-    }
-
-    void simplifyKnownVariables58() { // #5268
-        const char code[] = "enum e { VAL1 = 1, VAL2 }; "
-                            "typedef char arr_t[VAL2]; "
-                            "int foo(int) ; "
-                            "void bar () { "
-                            "  throw foo (VAL1); "
-                            "} "
-                            "int baz() { "
-                            "  return sizeof(arr_t); "
-                            "}";
-        ASSERT_EQUALS("enum e { VAL1 = 1 , VAL2 } ; "
-                      "int foo ( int ) ; "
-                      "void bar ( ) { "
-                      "throw foo ( VAL1 ) ; "
-                      "} "
-                      "int baz ( ) { "
-                      "return sizeof ( char [ VAL2 ] ) ; "
-                      "}", tokenizeAndStringify(code, true));
-    }
-
-    void simplifyKnownVariables59() { // #5062 - for head
-        const char code[] = "void f() {\n"
-                            "  int a[3], i, j;\n"
-                            "  for(i = 0, j = 1; i < 3, j < 12; i++,j++) {\n"
-                            "    a[i] = 0;\n"
-                            "  }\n"
-                            "}";
-        ASSERT_EQUALS("void f ( ) {\n"
-                      "int a [ 3 ] ; int i ; int j ;\n"
-                      "for ( i = 0 , j = 1 ; i < 3 , j < 12 ; i ++ , j ++ ) {\n"
-                      "a [ i ] = 0 ;\n"
-                      "}\n"
-                      "}", tokenizeAndStringify(code, true));
-    }
-
-    void simplifyKnownVariables60() { // #6829
-        const char code[] = "void f() {\n"
-                            "  int i = 1;\n"
-                            "  const int * const constPtrToConst = &i;\n"
-                            "  std::cout << *constPtrToConst << std::endl;\n"
-                            "  std::cout << constPtrToConst << std::endl;\n"
-                            "}";
-        ASSERT_EQUALS("void f ( ) {\n"
-                      "int i ; i = 1 ;\n"
-                      "const int * const constPtrToConst ; constPtrToConst = & i ;\n"
-                      "std :: cout << i << std :: endl ;\n"
-                      "std :: cout << & i << std :: endl ;\n"
-                      "}", tokenizeAndStringify(code, true));
-    }
-
-    void simplifyKnownVariables61() { // #7805
-        tokenizeAndStringify("static const int XX = 0;\n"
-                             "enum E { XX };\n"
-                             "struct s {\n"
-                             "  enum Bar {\n"
-                             "    XX,\n"
-                             "    Other\n"
-                             "  };\n"
-                             "  enum { XX };\n"
-                             "};", /*simplify=*/true);
-        ASSERT_EQUALS("", errout.str());
-    }
-
-    void simplifyKnownVariables62() { // #5666
-        ASSERT_EQUALS("void foo ( std :: string str ) {\n"
-                      "char * p ; p = & str [ 0 ] ;\n"
-                      "* p = 0 ;\n"
-                      "}",
-                      tokenizeAndStringify("void foo(std::string str) {\n"
-                                           "  char *p = &str[0];\n"
-                                           "  *p = 0;\n"
-                                           "}", /*simplify=*/true));
-    }
-
-    void simplifyKnownVariablesBailOutAssign1() {
-        const char code[] = "int foo() {\n"
-                            "    int i; i = 0;\n"
-                            "    if (x) { i = 10; }\n"
-                            "    return i;\n"
-                            "}\n";
-        const char expected[] = "int foo ( ) {\n"
-                                "int i ; i = 0 ;\n"
-                                "if ( x ) { i = 10 ; }\n"
-                                "return i ;\n"
-                                "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-    }
-
-    void simplifyKnownVariablesBailOutAssign2() {
-        // ticket #3032 - assignment in condition
-        const char code[] = "void f(struct ABC *list) {\n"
-                            "    struct ABC *last = NULL;\n"
-                            "    nr = (last = list->prev)->nr;\n"  // <- don't replace "last" with 0
-                            "}\n";
-        const char expected[] = "void f ( struct ABC * list ) {\n"
-                                "struct ABC * last ; last = NULL ;\n"
-                                "nr = ( last = list . prev ) . nr ;\n"
-                                "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-    }
-
-    void simplifyKnownVariablesBailOutAssign3() { // #4395 - nested assignments
-        const char code[] = "void f() {\n"
-                            "    int *p = 0;\n"
-                            "    a = p = (VdbeCursor*)pMem->z;\n"
-                            "    return p ;\n"
-                            "}\n";
-        const char expected[] = "void f ( ) {\n"
-                                "int * p ; p = 0 ;\n"
-                                "a = p = pMem . z ;\n"
-                                "return p ;\n"
-                                "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-    }
-
-    void simplifyKnownVariablesBailOutFor1() {
-        const char code[] = "void foo() {\n"
-                            "    for (int i = 0; i < 10; ++i) { }\n"
-                            "}\n";
-        const char expected[] = "void foo ( ) {\n"
-                                "for ( int i = 0 ; i < 10 ; ++ i ) { }\n"
-                                "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-        ASSERT_EQUALS("", errout.str());    // debug warnings
-    }
-
-    void simplifyKnownVariablesBailOutFor2() {
-        const char code[] = "void foo() {\n"
-                            "    int i = 0;\n"
-                            "    while (i < 10) { ++i; }\n"
-                            "}\n";
-        const char expected[] = "void foo ( ) {\n"
-                                "int i ; i = 0 ;\n"
-                                "while ( i < 10 ) { ++ i ; }\n"
-                                "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-        ASSERT_EQUALS("", errout.str());    // debug warnings
-    }
-
-    void simplifyKnownVariablesBailOutFor3() {
-        const char code[] = "void foo() {\n"
-                            "    for (std::string::size_type pos = 0; pos < 10; ++pos)\n"
-                            "    { }\n"
-                            "}\n";
-        const char expected[] = "void foo ( ) {\n"
-                                "for ( std :: string :: size_type pos = 0 ; pos < 10 ; ++ pos )\n"
-                                "{ }\n"
-                                "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-        ASSERT_EQUALS("", errout.str());    // debug warnings
-    }
-
-    void simplifyKnownVariablesBailOutMemberFunction() {
-        const char code[] = "void foo(obj a) {\n"
-                            "    obj b = a;\n"
-                            "    b.f();\n"
-                            "}\n";
-        const char expected[] = "void foo ( obj a ) {\n"
-                                "obj b ; b = a ;\n"
-                                "b . f ( ) ;\n"
-                                "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true));
-    }
-
-    void simplifyKnownVariablesBailOutConditionalIncrement() {
-        const char code[] = "int f() {\n"
-                            "    int a = 0;\n"
-                            "    if (x) {\n"
-                            "        ++a;\n" // conditional increment
-                            "    }\n"
-                            "    return a;\n"
-                            "}\n";
-        tokenizeAndStringify(code,true);
-        ASSERT_EQUALS("", errout.str());     // no debug warnings
-    }
-
-    void simplifyKnownVariablesBailOutSwitchBreak() {
-        // Ticket #2324
-        const char code[] = "int f(char *x) {\n"
-                            "    char *p;\n"
-                            "    char *q;\n"
-                            "\n"
-                            "    switch (x & 0x3)\n"
-                            "    {\n"
-                            "        case 1:\n"
-                            "            p = x;\n"
-                            "            x = p;\n"
-                            "            break;\n"
-                            "        case 2:\n"
-                            "            q = x;\n" // x is not equal with p
-                            "            x = q;\n"
-                            "            break;\n"
-                            "    }\n"
-                            "}\n";
-
-        const char expected[] = "int f ( char * x ) {\n"
-                                "char * p ;\n"
-                                "char * q ;\n"
-                                "\n"
-                                "switch ( x & 3 )\n"
-                                "{\n"
-                                "case 1 : ;\n"
-                                "p = x ;\n"
-                                "x = p ;\n"
-                                "break ;\n"
-                                "case 2 : ;\n"
-                                "q = x ;\n"
-                                "x = q ;\n"
-                                "break ;\n"
-                                "}\n"
-                                "}";
-
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code,true));
-    }
-
-    void simplifyKnownVariablesFloat() {
-        // Ticket #2454
-        const char code[] = "void f() {\n"
-                            "    float a = 40;\n"
-                            "    x(10 / a);\n"
-                            "}\n";
-
-        const char expected[] = "void f ( ) {\n\nx ( 0.25 ) ;\n}";
-
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code,true));
-
-        // Ticket #4227
-        const char code2[] = "double f() {"
-                             "    double a = false;"
-                             "    return a;"
-                             "}";
-        ASSERT_EQUALS("double f ( ) { return 0.0 ; }", tokenizeAndStringify(code2,true));
-
-        // Ticket #5485
-        const char code3[] = "void f() {"
-                             "    double a = 1e+007;\n"
-                             "    std::cout << a;\n"
-                             "}";
-        ASSERT_EQUALS("void f ( ) {\nstd :: cout << 1e+007 ;\n}", tokenizeAndStringify(code3,true));
-
-        const char code4[] = "void f() {"
-                             "    double a = 1;\n"
-                             "    std::cout << a;\n"
-                             "}";
-        ASSERT_EQUALS("void f ( ) {\nstd :: cout << 1.0 ;\n}", tokenizeAndStringify(code4,true));
-    }
-
-    void simplifyKnownVariablesFunctionCalls() {
-        {
-            const char code[] = "void a(int x);"  // <- x is passed by value
-                                "void b() {"
-                                "    int x = 123;"
-                                "    a(x);"       // <- replace with a(123);
-                                "}";
-            const char expected[] = "void a ( int x ) ; void b ( ) { a ( 123 ) ; }";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code,true));
-        }
-
-        {
-            const char code[] = "void a(int &x);" // <- x is passed by reference
-                                "void b() {"
-                                "    int x = 123;"
-                                "    a(x);"       // <- don't replace with a(123);
-                                "}";
-            const char expected[] = "void a ( int & x ) ; void b ( ) { int x ; x = 123 ; a ( x ) ; }";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code,true));
-        }
-    }
-
-    void simplifyKnownVariablesGlobalVars() {
-        // #8054
-        const char code[] = "static int x;"
-                            "void f() {"
-                            "    x = 123;"
-                            "    while (!x) { dostuff(); }"
-                            "}";
-        ASSERT_EQUALS("static int x ; void f ( ) { x = 123 ; while ( ! x ) { dostuff ( ) ; } }", tokenizeAndStringify(code,true));
-    }
-
-    void simplifyKnownVariablesReturn() {
-        const char code[] = "int a() {"
-                            "    int x = 123;"
-                            "    return (x);"
-                            "}";
-        ASSERT_EQUALS("int a ( ) { return 123 ; }", tokenizeAndStringify(code,true));
-    }
-
-    void simplifyKnownVariablesPointerAliasFunctionCall() { // #7440
-        const char code[] = "int main() {\n"
-                            "  char* data = new char[100];\n"
-                            "  char** dataPtr = &data;\n"
-                            "  printf(\"test\");\n"
-                            "  delete [] *dataPtr;\n"
-                            "}";
-        const char exp[]  = "int main ( ) {\n"
-                            "char * data ; data = new char [ 100 ] ;\n"
-                            "char * * dataPtr ; dataPtr = & data ;\n"
-                            "printf ( \"test\" ) ;\n"
-                            "delete [ ] data ;\n"
-                            "}";
-        ASSERT_EQUALS(exp, tokenizeAndStringify(code, /*simplify=*/true));
-    }
-
-    void simplifyKnownVariablesClassMember() {
-        // Ticket #2815
-        {
-            const char code[] = "char *a;\n"
-                                "void f(const char *s) {\n"
-                                "    a = NULL;\n"
-                                "    x();\n"
-                                "    memcpy(a, s, 10);\n"   // <- don't simplify "a" here
-                                "}\n";
-
-            const std::string s(tokenizeAndStringify(code, true));
-            ASSERT_EQUALS(true, s.find("memcpy ( a , s , 10 ) ;") != std::string::npos);
-        }
-
-        // If the variable is local then perform simplification..
-        {
-            const char code[] = "void f(const char *s) {\n"
-                                "    char *a = NULL;\n"
-                                "    x();\n"
-                                "    memcpy(a, s, 10);\n"   // <- simplify "a"
-                                "}\n";
-
-            const std::string s(tokenizeAndStringify(code, true));
-            TODO_ASSERT_EQUALS(true, false, s.find("memcpy ( 0 , s , 10 ) ;") != std::string::npos);
-        }
-    }
-
-    void simplifyExternC() {
-        ASSERT_EQUALS("int foo ( ) ;", tokenizeAndStringify("extern \"C\" int foo();"));
-        ASSERT_EQUALS("int foo ( ) ;", tokenizeAndStringify("extern \"C\" { int foo(); }"));
-    }
-
-    void simplifyFunctionParameters() {
-        {
-            const char code[] = "char a [ ABC ( DEF ) ] ;";
-            ASSERT_EQUALS(code, tokenizeAndStringify(code));
-        }
-
-        {
-            const char code[] = "module ( a , a , sizeof ( a ) , 0444 ) ;";
-            ASSERT_EQUALS("module ( a , a , sizeof ( a ) , 292 ) ;", tokenizeAndStringify(code));
-        }
-
-        ASSERT_EQUALS("void f ( int x ) { }", tokenizeAndStringify("void f(x) int x; { }"));
-        ASSERT_EQUALS("void f ( int x , char y ) { }", tokenizeAndStringify("void f(x,y) int x; char y; { }"));
-        ASSERT_EQUALS("int main ( int argc , char * argv [ ] ) { }", tokenizeAndStringify("int main(argc,argv) int argc; char *argv[]; { }"));
-        ASSERT_EQUALS("int f ( int p , int w , float d ) { }", tokenizeAndStringify("int f(p,w,d) float d; { }"));
-
-        // #1067 - Not simplified. Feel free to fix so it is simplified correctly but this syntax is obsolescent.
-        ASSERT_EQUALS("int ( * d ( a , b , c ) ) ( ) int a ; int b ; int c ; { }", tokenizeAndStringify("int (*d(a,b,c))()int a,b,c; { }"));
-
-        {
-            // This is not a function but the pattern is similar..
-            const char code[] = "void foo()"
-                                "{"
-                                "    if (x)"
-                                "        int x;"
-                                "    { }"
-                                "}";
-            ASSERT_EQUALS("void foo ( ) { if ( x ) { } { } }", tokenizeAndStringify(code, true));
-        }
-    }
-
-    void simplifyFunctionParameters1() { // ticket #3721
-
-        const char code[] = "typedef float ufloat;\n"
-                            "typedef short ftnlen;\n"
-                            "int f(p,w,d,e,len) ufloat *p; ftnlen len;\n"
+    void simplifyFunctionParameters1() { // ticket #3721
+
+        const char code[] = "typedef float ufloat;\n"
+                            "typedef short ftnlen;\n"
+                            "int f(p,w,d,e,len) ufloat *p; ftnlen len;\n"
                             "{\n"
                             "}\n";
         ASSERT_EQUALS("int f ( float * p , int w , int d , int e , short len )\n"
@@ -3176,37 +1842,82 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS(code, tokenizeAndStringify(code));
     }
 
+    void simplifyFunctionParameters4() { // #9421
+        const char code[] = "int foo :: bar ( int , int ) const ;";
+        ASSERT_EQUALS(code, tokenizeAndStringify(code));
+    }
+
     void simplifyFunctionParametersMultiTemplate() {
         const char code[] = "template < typename T1 > template < typename T2 > "
                             "void A < T1 > :: foo ( T2 ) { }";
         ASSERT_EQUALS(code, tokenizeAndStringify(code));
+        ASSERT_EQUALS("[test.cpp:1:68]: (debug) Executable scope 'foo' with unknown function. [symbolDatabaseWarning]\n", errout_str());
     }
 
     void simplifyFunctionParametersErrors() {
         //same parameters...
-        ASSERT_THROW(tokenizeAndStringify("void foo(x, x)\n"
-                                          " int x;\n"
-                                          " int x;\n"
-                                          "{}\n"), InternalError);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void foo(x, x)\n"
+                                                   " int x;\n"
+                                                   " int x;\n"
+                                                   "{}\n"), SYNTAX);
 
-        ASSERT_THROW(tokenizeAndStringify("void foo(x, y)\n"
-                                          " int x;\n"
-                                          " int x;\n"
-                                          "{}\n"), InternalError);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void foo(x, y)\n"
+                                                   " int x;\n"
+                                                   " int x;\n"
+                                                   "{}\n"), SYNTAX);
 
-        tokenizeAndStringify("void foo(int, int)\n"
-                             "{}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_NO_THROW(tokenizeAndStringify("void foo(int, int)\n"
+                                             "{}"));
+        ASSERT_EQUALS("", errout_str());
 
         // #3848 - Don't hang
-        tokenizeAndStringify("sal_Bool ShapeHasText(sal_uLong, sal_uLong) const {\n"
-                             "    return sal_True;\n"
-                             "}\n"
-                             "void CreateSdrOLEFromStorage() {\n"
-                             "    comphelper::EmbeddedObjectContainer aCnt( xDestStorage );\n"
-                             "    { }\n"
-                             "}");
-        ASSERT_EQUALS("", errout.str());
+        (void)tokenizeAndStringify("sal_Bool ShapeHasText(sal_uLong, sal_uLong) const {\n"
+                                   "    return sal_True;\n"
+                                   "}\n"
+                                   "void CreateSdrOLEFromStorage() {\n"
+                                   "    comphelper::EmbeddedObjectContainer aCnt( xDestStorage );\n"
+                                   "    { }\n"
+                                   "}");
+        ignore_errout();
+    }
+
+    void simplifyFunctionTryCatch() {
+        ASSERT_EQUALS("void foo ( ) { try {\n"
+                      "} catch ( int ) {\n"
+                      "} catch ( char ) {\n"
+                      "} }",
+                      tokenizeAndStringify("void foo() try {\n"
+                                           "} catch (int) {\n"
+                                           "} catch (char) {\n"
+                                           "}"));
+
+        ASSERT_EQUALS("void foo ( ) { try {\n"
+                      "struct S {\n"
+                      "void bar ( ) { try {\n"
+                      "} catch ( int ) {\n"
+                      "} catch ( char ) {\n"
+                      "} }\n"
+                      "} ;\n"
+                      "} catch ( long ) {\n"
+                      "} }",
+                      tokenizeAndStringify("void foo() try {\n"
+                                           "  struct S {\n"
+                                           "    void bar() try {\n"
+                                           "    } catch (int) {\n"
+                                           "    } catch (char) {\n"
+                                           "    }\n"
+                                           "  };\n"
+                                           "} catch (long) {\n"
+                                           "}"));
+
+        ASSERT_EQUALS("struct S { void func ( ) const ; } ;\n"
+                      "void S :: func ( ) const {\n"
+                      "try { f ( ) ; }\n"
+                      "catch ( ... ) { g ( ) ; } }",
+                      tokenizeAndStringify("struct S { void func() const; };\n"
+                                           "void S::func() const\n"
+                                           "try { f(); }\n"
+                                           "catch (...) { g(); }\n"));
     }
 
     // Simplify "((..))" into "(..)"
@@ -3216,7 +1927,10 @@ class TestTokenizer : public TestFixture {
                             "    free(((void*)p));"
                             "}";
 
-        ASSERT_EQUALS("void foo ( ) { free ( p ) ; }", tokenizeAndStringify(code, true));
+        ASSERT_EQUALS("void foo ( ) { free ( ( void * ) p ) ; }", tokenizeAndStringify(code));
+        ASSERT_EQUALS(
+            "[test.cpp:1:29]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable p [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
     }
 
     void removeParentheses3() {
@@ -3225,7 +1939,7 @@ class TestTokenizer : public TestFixture {
                                 "{"
                                 "    if (( true )==(true)){}"
                                 "}";
-            ASSERT_EQUALS("void foo ( ) { }", tokenizeAndStringify(code, true));
+            ASSERT_EQUALS("void foo ( ) { if ( true == true ) { } }", tokenizeAndStringify(code));
         }
 
         {
@@ -3233,7 +1947,7 @@ class TestTokenizer : public TestFixture {
                                 "{"
                                 "    if (( 2 )==(2)){}"
                                 "}";
-            ASSERT_EQUALS("void foo ( ) { }", tokenizeAndStringify(code, true));
+            ASSERT_EQUALS("void foo ( ) { if ( 2 == 2 ) { } }", tokenizeAndStringify(code));
         }
 
         {
@@ -3252,6 +1966,9 @@ class TestTokenizer : public TestFixture {
                             "    (free(p));"
                             "}";
         ASSERT_EQUALS("void foo ( ) { free ( p ) ; }", tokenizeAndStringify(code));
+        ASSERT_EQUALS(
+            "[test.cpp:1:22]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable p [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
     }
 
     void removeParentheses5() {
@@ -3262,6 +1979,9 @@ class TestTokenizer : public TestFixture {
                                 "    (delete p);"
                                 "}";
             ASSERT_EQUALS("void foo ( ) { delete p ; }", tokenizeAndStringify(code));
+            ASSERT_EQUALS(
+                "[test.cpp:1:24]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable p [valueFlowBailoutIncompleteVar]\n",
+                errout_str());
         }
 
         // Simplify "( delete [] x )" into "delete [] x"
@@ -3271,6 +1991,9 @@ class TestTokenizer : public TestFixture {
                                 "    (delete [] p);"
                                 "}";
             ASSERT_EQUALS("void foo ( ) { delete [ ] p ; }", tokenizeAndStringify(code));
+            ASSERT_EQUALS(
+                "[test.cpp:1:27]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable p [valueFlowBailoutIncompleteVar]\n",
+                errout_str());
         }
     }
 
@@ -3289,14 +2012,14 @@ class TestTokenizer : public TestFixture {
 
     void removeParentheses7() {
         const char code[] = ";char *p; (delete(p), (p)=0);";
-        ASSERT_EQUALS("; char * p ; delete p ; p = 0 ;", tokenizeAndStringify(code,true));
+        ASSERT_EQUALS("; char * p ; delete ( p ) , p = 0 ;", tokenizeAndStringify(code));
     }
 
     void removeParentheses8() {
         const char code[] = "struct foo {\n"
                             "    void operator delete(void *obj, size_t sz);\n"
                             "}\n";
-        const std::string actual(tokenizeAndStringify(code, false, true, Settings::Win32A));
+        const std::string actual(tokenizeAndStringify(code, settings2_win32a));
 
         const char expected[] = "struct foo {\n"
                                 "void operatordelete ( void * obj , unsigned long sz ) ;\n"
@@ -3306,65 +2029,65 @@ class TestTokenizer : public TestFixture {
     }
 
     void removeParentheses9() {
-        ASSERT_EQUALS("void delete ( double num ) ;", tokenizeAndStringify("void delete(double num);", false));
+        ASSERT_EQUALS("void delete ( double num ) ;", tokenizeAndStringify("void delete(double num);"));
     }
 
     void removeParentheses10() {
-        ASSERT_EQUALS("p = buf + 8 ;", tokenizeAndStringify("p = (buf + 8);", false));
+        ASSERT_EQUALS("p = buf + 8 ;", tokenizeAndStringify("p = (buf + 8);"));
     }
 
     void removeParentheses11() {
         // #2502
-        ASSERT_EQUALS("{ } x ( ) ;", tokenizeAndStringify("{}(x());", false));
+        ASSERT_EQUALS("{ } x ( ) ;", tokenizeAndStringify("{}(x());"));
     }
 
     void removeParentheses12() {
         // #2760
-        ASSERT_EQUALS(", x = 0 ;", tokenizeAndStringify(",(x)=0;", false));
+        ASSERT_EQUALS(", x = 0 ;", tokenizeAndStringify(",(x)=0;"));
     }
 
     void removeParentheses13() {
-        ASSERT_EQUALS("; f ( a + b , c ) ;", tokenizeAndStringify(";f((a+b),c);", false));
-        ASSERT_EQUALS("; x = y [ a + b ] ;", tokenizeAndStringify(";x=y[(a+b)];", false));
+        ASSERT_EQUALS("; f ( a + b , c ) ;", tokenizeAndStringify(";f((a+b),c);"));
+        ASSERT_EQUALS("; x = y [ a + b ] ;", tokenizeAndStringify(";x=y[(a+b)];"));
     }
 
     void removeParentheses14() {
-        ASSERT_EQUALS("; if ( ( i & 1 ) == 0 ) { ; } ;", tokenizeAndStringify("; if ( (i & 1) == 0 ); ;", false));
+        ASSERT_EQUALS("{ if ( ( i & 1 ) == 0 ) { ; } }", tokenizeAndStringify("{ if ( (i & 1) == 0 ); }"));
     }
 
     void removeParentheses15() {
-        ASSERT_EQUALS("a = b ? c : 123 ;", tokenizeAndStringify("a = b ? c : (123);", false));
-        ASSERT_EQUALS("a = b ? c : ( 123 + 456 ) ;", tokenizeAndStringify("a = b ? c : ((123)+(456));", false));
-        ASSERT_EQUALS("a = b ? 123 : c ;", tokenizeAndStringify("a = b ? (123) : c;", false));
+        ASSERT_EQUALS("a = b ? c : 123 ;", tokenizeAndStringify("a = b ? c : (123);"));
+        ASSERT_EQUALS("a = b ? c : ( 123 + 456 ) ;", tokenizeAndStringify("a = b ? c : ((123)+(456));"));
+        ASSERT_EQUALS("a = b ? ( 123 ) : c ;", tokenizeAndStringify("a = b ? (123) : c;"));
 
         // #4316
-        ASSERT_EQUALS("a = b ? c : ( d = 1 , 0 ) ;", tokenizeAndStringify("a = b ? c : (d=1,0);", false));
+        ASSERT_EQUALS("a = b ? c : ( d = 1 , 0 ) ;", tokenizeAndStringify("a = b ? c : (d=1,0);"));
     }
 
     void removeParentheses16() { // *(x.y)=
         // #4423
-        ASSERT_EQUALS("; * x = 0 ;", tokenizeAndStringify(";*(x)=0;", false));
-        ASSERT_EQUALS("; * x . y = 0 ;", tokenizeAndStringify(";*(x.y)=0;", false));
+        ASSERT_EQUALS("; * x = 0 ;", tokenizeAndStringify(";*(x)=0;"));
+        ASSERT_EQUALS("; * x . y = 0 ;", tokenizeAndStringify(";*(x.y)=0;"));
     }
 
     void removeParentheses17() { // a ? b : (c > 0 ? d : e)
-        ASSERT_EQUALS("a ? b : ( c > 0 ? d : e ) ;", tokenizeAndStringify("a?b:(c>0?d:e);", false));
+        ASSERT_EQUALS("a ? b : ( c > 0 ? d : e ) ;", tokenizeAndStringify("a?b:(c>0?d:e);"));
     }
 
     void removeParentheses18() {
-        ASSERT_EQUALS("float ( * a ) [ 2 ] ;", tokenizeAndStringify("float(*a)[2];", false));
+        ASSERT_EQUALS("float ( * a ) [ 2 ] ;", tokenizeAndStringify("float(*a)[2];"));
     }
 
     void removeParentheses19() {
-        ASSERT_EQUALS("( ( ( typeof ( X ) ) * ) 0 ) ;", tokenizeAndStringify("(((typeof(X))*)0);", false));
+        ASSERT_EQUALS("( ( ( typeof ( X ) ) * ) 0 ) ;", tokenizeAndStringify("(((typeof(X))*)0);"));
     }
 
     void removeParentheses20() {
-        ASSERT_EQUALS("a < b < int > > ( 2 ) ;", tokenizeAndStringify("a<b<int>>(2);", false));
+        ASSERT_EQUALS("a < b < int > > ( 2 ) ;", tokenizeAndStringify("a<b<int>>(2);"));
     }
 
     void removeParentheses21() {
-        ASSERT_EQUALS("a = ( int ) - b ;", tokenizeAndStringify("a = ((int)-b);", false));
+        ASSERT_EQUALS("a = ( int ) - b ;", tokenizeAndStringify("a = ((int)-b);"));
     }
 
     void removeParentheses22() {
@@ -3373,11 +2096,11 @@ class TestTokenizer : public TestFixture {
                              "char &(b); "
                              "const static char *(c); "
                              "} ;";
-        static char  exp[] = "struct S { "
-                             "char * a ; "
-                             "char & b ; "
-                             "static const char * c ; "
-                             "} ;";
+        static const char exp[] = "struct S { "
+                                  "char * a ; "
+                                  "char & b ; "
+                                  "static const char * c ; "
+                                  "} ;";
         ASSERT_EQUALS(exp, tokenizeAndStringify(code));
     }
 
@@ -3385,37 +2108,94 @@ class TestTokenizer : public TestFixture {
         // Reported case
         {
             static char code[] = "; * * p f ( ) int = { new int ( * [ 2 ] ) ; void }";
-            static char  exp[] = "; * * p f ( ) int = { new int ( * [ 2 ] ) ; void }";
+            static const char exp[] = "; * * p f ( ) int = { new int ( * [ 2 ] ) ; void }";
             ASSERT_EQUALS(exp, tokenizeAndStringify(code));
         }
         // Various valid cases
         {
             static char code[] = "int * f [ 1 ] = { new ( int ) } ;";
-            static char  exp[] = "int * f [ 1 ] = { new int } ;";
+            static const char exp[] = "int * f [ 1 ] = { new int } ;";
             ASSERT_EQUALS(exp, tokenizeAndStringify(code));
         }
         {
             static char code[] = "int * * f [ 1 ] = { new ( int ) [ 1 ] } ;";
-            static char  exp[] = "int * * f [ 1 ] = { new int [ 1 ] } ;";
+            static const char exp[] = "int * * f [ 1 ] = { new int [ 1 ] } ;";
             ASSERT_EQUALS(exp, tokenizeAndStringify(code));
         }
         {
             static char code[] = "list < int > * f [ 1 ] = { new ( list < int > ) } ;";
-            static char  exp[] = "list < int > * f [ 1 ] = { new list < int > } ;";
+            static const char exp[] = "list < int > * f [ 1 ] = { new list < int > } ;";
             ASSERT_EQUALS(exp, tokenizeAndStringify(code));
         }
         // don't remove parentheses in operator new overload
         {
             static char code[] = "void *operator new(__SIZE_TYPE__, int);";
-            static char  exp[] = "void * operatornew ( __SIZE_TYPE__ , int ) ;";
+            static const char exp[] = "void * operatornew ( __SIZE_TYPE__ , int ) ;";
             ASSERT_EQUALS(exp, tokenizeAndStringify(code));
         }
     }
 
     void removeParentheses24() { // Ticket #7040
         static char code[] = "std::hash<decltype(t._data)>()(t._data);";
-        static char  exp[] = "std :: hash < decltype ( t . _data ) > ( ) ( t . _data ) ;";
+        static const char exp[] = "std :: hash < decltype ( t . _data ) > ( ) ( t . _data ) ;";
+        ASSERT_EQUALS(exp, tokenizeAndStringify(code));
+    }
+
+    void removeParentheses25() { // daca@home - a=(b,c)
+        static char code[] = "a=(b,c);";
+        static const char exp[] = "a = ( b , c ) ;";
+        ASSERT_EQUALS(exp, tokenizeAndStringify(code));
+    }
+
+    void removeParentheses26() { // Ticket #8875 a[0](0)
+        static char code[] = "a[0](0);";
+        static const char exp[] = "a [ 0 ] ( 0 ) ;";
+        ASSERT_EQUALS(exp, tokenizeAndStringify(code));
+    }
+
+    void removeParentheses27() {
+        static char code[] = "struct S { int i; };\n"
+                             "void g(int, int);\n"
+                             "void f(S s, int j) {\n"
+                             "    g(j, (decltype(s.i))j * s.i);\n"
+                             "}\n";
+        static const char exp[] = "struct S { int i ; } ;\n"
+                                  "void g ( int , int ) ;\n"
+                                  "void f ( S s , int j ) {\n"
+                                  "g ( j , ( decltype ( s . i ) ) j * s . i ) ;\n"
+                                  "}";
+        ASSERT_EQUALS(exp, tokenizeAndStringify(code));
+    }
+
+    void removeParentheses28() { // Ticket #12164
+        static char code[] = "temp1 = (value > 100U) ? (value+100U) : (value-50U);";
+        static const char exp[] = "temp1 = ( value > 100U ) ? ( value + 100U ) : ( value - 50U ) ;";
+        ASSERT_EQUALS(exp, tokenizeAndStringify(code));
+    }
+
+    void removeParantheses29() { // Ticket #13735
+        static char code[] = "double foo(void)\n"
+                             "{\n"
+                             "return (modf)(12.3, NULL);\n"
+                             "}";
+        static const char exp[] = "double foo ( )\n"
+                                  "{\n"
+                                  "return modf ( 12.3 , NULL ) ;\n"
+                                  "}";
+        ASSERT_EQUALS(exp, tokenizeAndStringify(code));
+    }
+
+    void removeParentheses30() {
+        static char code[] = "void f (Node *node) {\n"
+                             "    if (node->data && (node->provider)->free)\n"
+                             "        (node->provider)->free (node);\n"
+                             "}\n";
+        static const char exp[] = "void f ( Node * node ) {\n"
+                                  "if ( node . data && ( node . provider ) . free ) {\n"
+                                  "node . provider . free ( node ) ; }\n"
+                                  "}";
         ASSERT_EQUALS(exp, tokenizeAndStringify(code));
+        (void) errout_str();
     }
 
     void tokenize_double() {
@@ -3437,13 +2217,13 @@ class TestTokenizer : public TestFixture {
 
     void tokenize_strings() {
         const char code[] =   "void f() {\n"
-                              "const char *a =\n"
-                              "{\n"
-                              "\"hello \"\n"
-                              "\"more \"\n"
-                              "\"world\"\n"
-                              "};\n"
-                              "}";
+                            "const char *a =\n"
+                            "{\n"
+                            "\"hello \"\n"
+                            "\"more \"\n"
+                            "\"world\"\n"
+                            "};\n"
+                            "}";
         ASSERT_EQUALS("void f ( ) {\n"
                       "const char * a ; a =\n"
                       "{\n"
@@ -3454,132 +2234,24 @@ class TestTokenizer : public TestFixture {
                       "}", tokenizeAndStringify(code));
     }
 
-    void simplify_constants() {
-        const char code[] =
-            "void f() {\n"
-            "const int a = 45;\n"
-            "if( a )\n"
-            "{ int b = a; }\n"
-            "}\n"
-            "void g() {\n"
-            "int a = 2;\n"
-            "}";
-        ASSERT_EQUALS("void f ( ) {\n"
-                      "\n"
-                      "\n"
-                      "\n"
-                      "}\n"
-                      "void g ( ) {\n"
-                      "\n"
-                      "}", tokenizeAndStringify(code, true));
-    }
-
-    void simplify_constants2() {
-        const char code[] =
-            "void f( Foo &foo, Foo *foo2 ) {\n"
-            "const int a = 45;\n"
-            "foo.a=a+a;\n"
-            "foo2->a=a;\n"
-            "}";
-        ASSERT_EQUALS("void f ( Foo & foo , Foo * foo2 ) {\n"
-                      "\n"
-                      "foo . a = 90 ;\n"
-                      "foo2 . a = 45 ;\n"
-                      "}", tokenizeAndStringify(code, true));
-    }
-
-    void simplify_constants3() {
-        const char code[] =
-            "static const char str[] = \"abcd\";\n"
-            "static const unsigned int SZ = sizeof(str);\n"
-            "void f() {\n"
-            "a = SZ;\n"
-            "}\n";
-        const char expected[] =
-            "static const char str [ 5 ] = \"abcd\" ;\n\nvoid f ( ) {\na = 5 ;\n}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code,true));
-    }
-
-    void simplify_constants4() {
-        const char code[] = "static const int bSize = 4;\n"
-                            "static const int aSize = 50;\n"
-                            "x = bSize;\n"
-                            "y = aSize;\n";
-        ASSERT_EQUALS("x = 4 ;\ny = 50 ;", tokenizeAndStringify(code,true));
-    }
-
-    void simplify_constants5() {
-        const char code[] = "int buffer[10];\n"
-                            "static const int NELEMS = sizeof(buffer)/sizeof(int);\n"
-                            "static const int NELEMS2(sizeof(buffer)/sizeof(int));\n"
-                            "x = NELEMS;\n"
-                            "y = NELEMS2;\n";
-        ASSERT_EQUALS("int buffer [ 10 ] ;\n\n\nx = 10 ;\ny = 10 ;", tokenizeAndStringify(code,true));
-    }
-
-    void simplify_constants6() { // Ticket #5625
-        {
-            const char code[] = "template < class T > struct foo ;\n"
-                                "void bar ( ) {\n"
-                                "foo < 1 ? 0 ? 1 : 6 : 2 > x ;\n"
-                                "foo < 1 ? 0 : 2 > y ;\n"
-                                "}";
-            const char exp [] = "template < class T > struct foo ;\n"
-                                "void bar ( ) {\n"
-                                "foo < 6 > x ;\n"
-                                "foo < 0 > y ;\n"
-                                "}";
-            ASSERT_EQUALS(exp, tokenizeAndStringify(code, true));
-        }
-        {
-            const char code[] = "bool b = true ? false : 1 > 2 ;";
-            const char exp [] = "bool b ; b = false ;";
-            ASSERT_EQUALS(exp, tokenizeAndStringify(code, true));
-        }
-    }
-
-    void simplifyMulAndParens() {
-        // (error) Resource leak
-        const char code[] = "void f() {"
-                            "   *&n1=open();"
-                            "   *&(n2)=open();"
-                            "   *(&n3)=open();"
-                            "   *&*&n4=open();"
-                            "   *&*&*&(n5)=open();"
-                            "   *&*&(*&n6)=open();"
-                            "   *&*(&*&n7)=open();"
-                            "   *(&*&n8)=open();"
-                            "   *&(*&*&(*&n9))=open();"
-                            "   (n10) = open();"
-                            "   ((n11)) = open();"
-                            "   ((*&n12))=open();"
-                            "   *(&(*&n13))=open();"
-                            "   ((*&(*&n14)))=open();"
-                            "   ((*&(*&n15)))+=10;"
-                            "}";
-        const char expected[] = "void f ( ) {"
-                                " n1 = open ( ) ;"
-                                " n2 = open ( ) ;"
-                                " n3 = open ( ) ;"
-                                " n4 = open ( ) ;"
-                                " n5 = open ( ) ;"
-                                " n6 = open ( ) ;"
-                                " n7 = open ( ) ;"
-                                " n8 = open ( ) ;"
-                                " n9 = open ( ) ;"
-                                " n10 = open ( ) ;"
-                                " n11 = open ( ) ;"
-                                " n12 = open ( ) ;"
-                                " n13 = open ( ) ;"
-                                " n14 = open ( ) ;"
-                                " n15 += 10 ; "
-                                "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
-    }
-
     void simplifyStructDecl() {
         const char code[] = "const struct A { int a; int b; } a;";
         ASSERT_EQUALS("struct A { int a ; int b ; } ; const struct A a ;", tokenizeAndStringify(code));
+
+        // #9519
+        const char code2[] = "enum A {} (a);";
+        const char expected2[] = "enum A { } ; enum A a ;";
+        ASSERT_EQUALS(expected2, tokenizeAndStringify(code2));
+
+        // #11052
+        const char code3[] = "struct a { int b; } static e[1];";
+        const char expected3[] = "struct a { int b ; } ; struct a static e [ 1 ] ;";
+        ASSERT_EQUALS(expected3, tokenizeAndStringify(code3));
+
+        // #11013 - Do not remove unnamed struct in union
+        const char code4[] = "union U { struct { int a; int b; }; int ab[2]; };";
+        const char expected4[] = "union U { struct { int a ; int b ; } ; int ab [ 2 ] ; } ;";
+        ASSERT_EQUALS(expected4, tokenizeAndStringify(code4));
     }
 
     void vardecl1() {
@@ -3625,7 +2297,7 @@ class TestTokenizer : public TestFixture {
 
         const char code5[] = "const void * volatile p = NULL;";
         const char res5[]  = "const void * volatile p ; p = NULL ;";
-        ASSERT_EQUALS(res5, tokenizeAndStringify(code5));;
+        ASSERT_EQUALS(res5, tokenizeAndStringify(code5));
     }
 
     void vardecl5() {
@@ -3634,6 +2306,9 @@ class TestTokenizer : public TestFixture {
                       "}", tokenizeAndStringify("void foo(int nX) {\n"
                                                 "    int addI = frontPoint == 2 || frontPoint == 1 ? i = 0, 1 : (i = nX - 2, -1);\n"
                                                 "}"));
+        ASSERT_EQUALS(
+            "[test.cpp:2:16]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable frontPoint [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
     }
 
     void vardecl_stl_1() {
@@ -3660,13 +2335,22 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("{ std :: vector < int > x ; x = y ; }", tokenizeAndStringify(code2));
     }
 
+    void vardecl_stl_3()
+    {
+        const char code1[] = "{ std::string const x = \"abc\"; }";
+        ASSERT_EQUALS("{ const std :: string x = \"abc\" ; }", tokenizeAndStringify(code1));
+
+        const char code2[] = "{ std::vector<int> const x = y; }";
+        ASSERT_EQUALS("{ const std :: vector < int > x = y ; }", tokenizeAndStringify(code2));
+    }
+
     void vardecl_template_1() {
         // ticket #1046
         const char code1[] = "b<(1<<24),10,24> u, v;";
         const char res1[]  = "b < 16777216 , 10 , 24 > u ; b < 16777216 , 10 , 24 > v ;";
         ASSERT_EQUALS(res1, tokenizeAndStringify(code1));
         // ticket #3571 (segmentation fault)
-        tokenizeAndStringify("template <int i = (3>4) > class X4 {};");
+        (void)tokenizeAndStringify("template <int i = (3>4) > class X4 {};");
     }
 
     void vardecl_template_2() {
@@ -3688,7 +2372,7 @@ class TestTokenizer : public TestFixture {
                              "         long y;\n"
                              "     };\n"
                              "}";
-        ASSERT_EQUALS("void f ( ) {\n\nint x ;\nlong & y = x ;\n\n}", tokenizeAndStringify(code2));
+        ASSERT_EQUALS("void f ( ) {\nunion {\nint x ;\nlong y ;\n} ;\n}", tokenizeAndStringify(code2));
 
         // ticket #3927
         const char code3[] = "union xy *p = NULL;";
@@ -3791,6 +2475,19 @@ class TestTokenizer : public TestFixture {
                           "} ;",
                           tokenizeAndStringify(code));
         }
+
+        {
+            // Ticket #9515
+            const char code[] = "void(a)(void) {\n"
+                                "    static int b;\n"
+                                "    if (b) {}\n"
+                                "}\n";
+            ASSERT_EQUALS("void ( a ) ( void ) {\n"
+                          "static int b ;\n"
+                          "if ( b ) { }\n"
+                          "}",
+                          tokenizeAndStringify(code));
+        }
     }
 
     void vardecl6() {
@@ -3852,11 +2549,15 @@ class TestTokenizer : public TestFixture {
                             "    int a = (x < y) ? 1 : 0;\n"
                             "}";
         ASSERT_EQUALS("void f ( ) {\nint a ; a = ( x < y ) ? 1 : 0 ;\n}", tokenizeAndStringify(code));
+        ASSERT_EQUALS(
+            "[test.cpp:2:14]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable x [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
     }
 
     void vardecl14() {
+        const Settings s = settingsBuilder(settings1).cpp(Standards::CPP03).build();
         const char code[] = "::std::tr1::shared_ptr<int> pNum1, pNum2;\n";
-        ASSERT_EQUALS(":: std :: tr1 :: shared_ptr < int > pNum1 ; :: std :: tr1 :: shared_ptr < int > pNum2 ;", tokenizeAndStringify(code, false, false, Settings::Native, "test.cpp", false));
+        ASSERT_EQUALS(":: std :: tr1 :: shared_ptr < int > pNum1 ; :: std :: tr1 :: shared_ptr < int > pNum2 ;", tokenizeAndStringify(code, s, true, false));
     }
 
     void vardecl15() {
@@ -3892,6 +2593,9 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("void f ( ) {\n"
                       "g ( ( double ) v1 * v2 , v3 , v4 ) ;\n"
                       "}", tokenizeAndStringify(code));
+        ASSERT_EQUALS(
+            "[test.cpp:2:15]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable v1 [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
     }
 
     void vardecl19() {
@@ -3903,9 +2607,8 @@ class TestTokenizer : public TestFixture {
                                 "}\n";
 
             ASSERT_EQUALS("void func (\n"
-                          "int in ,\n"
-                          "int r ,\n"
-                          "int m )\n"
+                          "int in , int r , int m\n"
+                          ")\n"
                           "{\n"
                           "}", tokenizeAndStringify(code));
         }
@@ -3916,7 +2619,8 @@ class TestTokenizer : public TestFixture {
                                 "}\n";
 
             ASSERT_EQUALS("void f (\n"
-                          "char * r )\n"
+                          "char * r\n"
+                          ")\n"
                           "\n"
                           "{\n"
                           "}", tokenizeAndStringify(code));
@@ -3937,7 +2641,8 @@ class TestTokenizer : public TestFixture {
                                 "}\n";
 
             ASSERT_EQUALS("void f (\n"
-                          "char * r )\n"
+                          "char * r\n"
+                          ")\n"
                           "\n"
                           "{\n"
                           "}", tokenizeAndStringify(code));
@@ -3951,8 +2656,8 @@ class TestTokenizer : public TestFixture {
 
             ASSERT_EQUALS("void f (\n"
                           "char * r ,\n"
-                          "\n"
-                          "char * s )\n"
+                          "char * s\n"
+                          ")\n"
                           "\n"
                           "\n"
                           "{\n"
@@ -3965,9 +2670,8 @@ class TestTokenizer : public TestFixture {
                                 "}\n";
 
             ASSERT_EQUALS("void f (\n"
-                          "char * r ,\n"
-                          "char * s ,\n"
-                          "char * t )\n"
+                          "char * r , char * s , char * t\n"
+                          ")\n"
                           "\n"
                           "{\n"
                           "}", tokenizeAndStringify(code));
@@ -3993,6 +2697,7 @@ class TestTokenizer : public TestFixture {
                       "{\n"
                       "const int X = 0 ;\n"
                       "}", tokenizeAndStringify(code));
+        ASSERT_EQUALS("[test.cpp:1:9]: (debug) Executable scope 'b' with unknown function. [symbolDatabaseWarning]\n", errout_str());
     }
 
     void vardecl21() { // type in namespace
@@ -4016,11 +2721,11 @@ class TestTokenizer : public TestFixture {
     }
 
     void vardecl22() {  // #4211 - segmentation fault
-        tokenizeAndStringify("A<B<C<int>> >* p = 0;");
+        (void)tokenizeAndStringify("A<B<C<int>> >* p = 0;");
     }
 
     void vardecl23() {  // #4276 - segmentation fault
-        ASSERT_THROW(tokenizeAndStringify("class a { protected : template < class int x = 1 ; public : int f ( ) ; }"), InternalError);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("class a { protected : template < class int x = 1 ; public : int f ( ) ; }"), SYNTAX);
     }
 
     void vardecl24() {  // #4187 - variable declaration within lambda function
@@ -4052,37 +2757,119 @@ class TestTokenizer : public TestFixture {
     }
 
     void vardecl25() {  // #4799 - segmentation fault
-        tokenizeAndStringify("void A::func(P g) const {}\n"
-                             "void A::a() {\n"
-                             "   b = new d(  [this]( const P & p) -> double { return this->func(p);}  );\n"
-                             "}");
+        (void)tokenizeAndStringify("void A::func(P g) const {}\n"
+                                   "void A::a() {\n"
+                                   "   b = new d(  [this]( const P & p) -> double { return this->func(p);}  );\n"
+                                   "}");
+        ignore_errout();
     }
 
     void vardecl26() { // #5907
         const char code[] = "extern int *new, obj, player;";
         const char expected[] = "extern int * new ; extern int obj ; extern int player ;";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, false, true, Settings::Native, "test.c"));
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
         ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+        ASSERT_EQUALS("[test.cpp:1:13]: (debug) Scope::checkVariable found variable 'new' with varid 0. [varid0]\n", errout_str());
     }
 
-    void vardecl27() { // #7850
+    void vardecl27() { // #7850 (segmentation fault)
         const char code[] = "extern int foo(char);\n"
                             "void* class(char c) {\n"
                             "  if (foo(c))\n"
                             "    return 0;\n"
                             "  return 0;\n"
                             "}";
-        tokenizeAndStringify(code, /*simplify=*/false, /*expand=*/true, Settings::Native, "test.c");
+        (void)tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false));
+    }
+
+    void vardecl28() {
+        const char code[] = "unsigned short f(void) {\n"
+                            "    unsigned short const int x = 1;\n"
+                            "    return x;\n"
+                            "}";
+        ASSERT_EQUALS("unsigned short f ( ) {\n"
+                      "const unsigned short x ; x = 1 ;\n"
+                      "return x ;\n"
+                      "}",
+                      tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
+    }
+
+    void vardecl29() { // #9282
+        {
+            const char code[] = "double f1() noexcept, f2(double) noexcept;";
+            ASSERT_EQUALS("double f1 ( ) noexcept ( true ) ; double f2 ( double ) noexcept ( true ) ;",
+                          tokenizeAndStringify(code));
+        }
+
+        {
+            const char code[] = "class C {\n"
+                                "    double f1() const noexcept, f2 (double) const noexcept;\n"
+                                "};\n";
+            ASSERT_EQUALS("class C {\n"
+                          "double f1 ( ) const noexcept ( true ) ; double f2 ( double ) const noexcept ( true ) ;\n"
+                          "} ;",
+                          tokenizeAndStringify(code));
+        }
+    }
+
+    void vardecl30() {
+        const char code[] = "struct D {} const d;";
+        ASSERT_EQUALS("struct D { } ; struct D const d ;",
+                      tokenizeAndStringify(code));
+        ASSERT_EQUALS("struct D { } ; struct D const d ;",
+                      tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
+    }
+
+    void vardecl31() {
+        {
+            const char code[] = "void foo() { int (*fptr)() = 0; }";
+            ASSERT_EQUALS("void foo ( ) { int ( * fptr ) ( ) ; fptr = 0 ; }", tokenizeAndStringify(code));
+        }
+
+        {
+            const char code[] = "void foo() { int (*fptr)(int) = 0; }";
+            ASSERT_EQUALS("void foo ( ) { int ( * fptr ) ( int ) ; fptr = 0 ; }", tokenizeAndStringify(code));
+        }
+    }
+
+    void vardecl32() {
+        {
+            const char code[] = "static enum { E } f() { return E; }";
+            ASSERT_EQUALS("enum Anonymous0 { E } ; static enum Anonymous0 f ( ) { return E ; }", tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
+        }
+    }
+
+    void vardecl33() {
+        {
+            const char code[] = "static enum { E } *f() { return NULL; }";
+            ASSERT_EQUALS("enum Anonymous0 { E } ; static enum Anonymous0 * f ( ) { return NULL ; }", tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
+        }
+    }
+
+    void vardecl34() {
+        {
+            const char code[] = "static enum { E } const *f() { return NULL; }";
+            ASSERT_EQUALS("enum Anonymous0 { E } ; static enum Anonymous0 const * f ( ) { return NULL ; }", tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
+        }
     }
 
     void volatile_variables() {
-        const char code[] = "volatile int a=0;\n"
-                            "volatile int b=0;\n"
-                            "volatile int c=0;\n";
+        {
+            const char code[] = "volatile int a=0;\n"
+                                "volatile int b=0;\n"
+                                "volatile int c=0;\n";
 
-        const std::string actual(tokenizeAndStringify(code));
+            const std::string actual(tokenizeAndStringify(code));
+
+            ASSERT_EQUALS("volatile int a ; a = 0 ;\nvolatile int b ; b = 0 ;\nvolatile int c ; c = 0 ;", actual);
+        }
+        {
+            const char code[] = "char *volatile s1, *volatile s2;\n"; // #11004
 
-        ASSERT_EQUALS("volatile int a ; a = 0 ;\nvolatile int b ; b = 0 ;\nvolatile int c ; c = 0 ;", actual);
+            const std::string actual(tokenizeAndStringify(code));
+
+            ASSERT_EQUALS("char * volatile s1 ; char * volatile s2 ;", actual);
+        }
     }
 
 
@@ -4092,18 +2879,18 @@ class TestTokenizer : public TestFixture {
             ASSERT_EQUALS("void f ( int a [ 5 ] ) ;", tokenizeAndStringify(code));
         }
         {
-            const char in4 [] = "struct B final : A { void foo(); };";
-            const char out4 [] = "struct B : A { void foo ( ) ; } ;";
+            const char in4[] = "struct B final : A { void foo(); };";
+            const char out4[] = "struct B : A { void foo ( ) ; } ;";
             ASSERT_EQUALS(out4, tokenizeAndStringify(in4));
 
-            const char in5 [] = "struct ArrayItemsValidator final {\n"
-                                "    SchemaError validate() const override {\n"
-                                "        for (; pos < value.size(); ++pos) {\n"
-                                "        }\n"
-                                "        return none;\n"
-                                "    }\n"
-                                "};\n";
-            const char out5 [] =
+            const char in5[] = "struct ArrayItemsValidator final {\n"
+                               "    SchemaError validate() const override {\n"
+                               "        for (; pos < value.size(); ++pos) {\n"
+                               "        }\n"
+                               "        return none;\n"
+                               "    }\n"
+                               "};\n";
+            const char out5[] =
                 "struct ArrayItemsValidator {\n"
                 "SchemaError validate ( ) const override {\n"
                 "for ( ; pos < value . size ( ) ; ++ pos ) {\n"
@@ -4113,6 +2900,9 @@ class TestTokenizer : public TestFixture {
                 "} ;";
 
             ASSERT_EQUALS(out5, tokenizeAndStringify(in5));
+            ASSERT_EQUALS(
+                "[test.cpp:3:16]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable pos [valueFlowBailoutIncompleteVar]\n",
+                errout_str());
         }
         {
             // Ticket #8679
@@ -4121,12 +2911,26 @@ class TestTokenizer : public TestFixture {
             ASSERT_EQUALS("static void * thread_local_var ; "
                           "void * thread_local_var_2 ;", tokenizeAndStringify(code));
         }
+
+        ASSERT_EQUALS("class Fred { } ;", tokenizeAndStringify("class DLLEXPORT Fred final { };"));
+    }
+
+    void implicitIntConst() {
+        ASSERT_EQUALS("const int x ;", tokenizeAndStringify("const x;", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("const int * x ;", tokenizeAndStringify("const *x;", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("const int * f ( ) ;", tokenizeAndStringify("const *f();", dinit(TokenizeOptions, $.cpp = false)));
+    }
+
+    void implicitIntExtern() {
+        ASSERT_EQUALS("extern int x ;", tokenizeAndStringify("extern x;", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("extern int * x ;", tokenizeAndStringify("extern *x;", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("const int * f ( ) ;", tokenizeAndStringify("const *f();", dinit(TokenizeOptions, $.cpp = false)));
     }
 
     /**
      * tokenize "signed i" => "signed int i"
      */
-    void signed1() {
+    void implicitIntSigned1() {
         {
             const char code1[] = "void foo ( signed int , float ) ;";
             ASSERT_EQUALS(code1, tokenizeAndStringify(code1));
@@ -4160,7 +2964,7 @@ class TestTokenizer : public TestFixture {
      * tokenize "unsigned i" => "unsigned int i"
      * tokenize "unsigned" => "unsigned int"
      */
-    void unsigned1() {
+    void implicitIntUnsigned1() {
         // No changes..
         {
             const char code[] = "void foo ( unsigned int , float ) ;";
@@ -4195,29 +2999,29 @@ class TestTokenizer : public TestFixture {
         }
     }
 
-    void unsigned2() {
+    void implicitIntUnsigned2() {
         const char code[] = "i = (unsigned)j;";
         const char expected[] = "i = ( unsigned int ) j ;";
         ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
 
     // simplify "unsigned" when using templates..
-    void unsigned3() {
+    void implicitIntUnsigned3() {
         {
             const char code[] = "; foo<unsigned>();";
-            const char expected[] = "; foo<int> ( ) ;";
+            const char expected[] = "; foo < unsigned int > ( ) ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
 
         {
             const char code[] = "; foo<unsigned int>();";
-            const char expected[] = "; foo<int> ( ) ;";
+            const char expected[] = "; foo < unsigned int > ( ) ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
     }
 
     void simplifyStdType() { // #4947, #4950, #4951
-        // usigned long long
+        // unsigned long long
         {
             const char code[] = "long long unsigned int x;";
             const char expected[] = "unsigned long long x ;";
@@ -4279,7 +3083,7 @@ class TestTokenizer : public TestFixture {
             const char expected[] = "signed long long x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
-        // usigned short
+        // unsigned short
         {
             const char code[] = "short unsigned int x;";
             const char expected[] = "unsigned short x ;";
@@ -4348,28 +3152,33 @@ class TestTokenizer : public TestFixture {
         }
         {
             const char code[] = "float complex x;";
-            const char expected[] = "_Complex float x ;";
+            const char expected[] = "float complex x ;";
             ASSERT_EQUALS(expected, tokenizeAndStringify(code));
         }
+        {
+            const char code[] = "float complex x;";
+            const char expected[] = "_Complex float x ;";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
+        }
         {
             const char code[] = "complex float x;";
             const char expected[] = "_Complex float x ;";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
         }
         {
             const char code[] = "complex long double x;";
             const char expected[] = "_Complex long double x ;";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
         }
         {
             const char code[] = "long double complex x;";
             const char expected[] = "_Complex long double x ;";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
         }
         {
             const char code[] = "double complex;";
             const char expected[] = "double complex ;";
-            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
         }
     }
 
@@ -4378,10 +3187,8 @@ class TestTokenizer : public TestFixture {
             const char code[] = "class A{\n"
                                 " void f() {}\n"
                                 "};";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
             // A body {}
             ASSERT_EQUALS(true, tok->linkAt(2) == tok->tokAt(9));
@@ -4395,7 +3202,7 @@ class TestTokenizer : public TestFixture {
             ASSERT_EQUALS(true, tok->linkAt(5) == tok->tokAt(6));
             ASSERT_EQUALS(true, tok->linkAt(6) == tok->tokAt(5));
 
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -4403,10 +3210,8 @@ class TestTokenizer : public TestFixture {
                                 " char a[10];\n"
                                 " char *b ; b = new char[a[0]];\n"
                                 "};";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
             // a[10]
             ASSERT_EQUALS(true, tok->linkAt(7) == tok->tokAt(9));
@@ -4420,17 +3225,15 @@ class TestTokenizer : public TestFixture {
             ASSERT_EQUALS(true, tok->linkAt(21) == tok->tokAt(23));
             ASSERT_EQUALS(true, tok->linkAt(23) == tok->tokAt(21));
 
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "void f(){\n"
                                 " foo(g());\n"
                                 "};";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
             // foo(
             ASSERT_EQUALS(true, tok->linkAt(6) == tok->tokAt(10));
@@ -4440,17 +3243,15 @@ class TestTokenizer : public TestFixture {
             ASSERT_EQUALS(true, tok->linkAt(8) == tok->tokAt(9));
             ASSERT_EQUALS(true, tok->linkAt(9) == tok->tokAt(8));
 
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "bool foo(C<z> a, bar<int, x<float>>& f, int b) {\n"
                                 "    return(a<b && b>f);\n"
                                 "}";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
             // template<
             ASSERT_EQUALS(true, tok->tokAt(6) == tok->linkAt(4));
@@ -4468,66 +3269,58 @@ class TestTokenizer : public TestFixture {
             ASSERT_EQUALS(true, nullptr == tok->linkAt(28));
             ASSERT_EQUALS(true, nullptr == tok->linkAt(32));
 
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "void foo() {\n"
                                 "    return static_cast<bar>(a);\n"
                                 "}";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
 
             // static_cast<
             ASSERT_EQUALS(true, tok->tokAt(9) == tok->linkAt(7));
             ASSERT_EQUALS(true, tok->tokAt(7) == tok->linkAt(9));
 
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "void foo() {\n"
                                 "    nvwa<(x > y)> ERROR_nnn;\n"
                                 "}";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
 
             // nvwa<(x > y)>
             ASSERT_EQUALS(true, tok->tokAt(12) == tok->linkAt(6));
             ASSERT_EQUALS(true, tok->tokAt(6) == tok->linkAt(12));
 
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             // #4860
             const char code[] = "class A : public B<int> {};";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
 
             // B<..>
             ASSERT_EQUALS(true, tok->tokAt(5) == tok->linkAt(7));
             ASSERT_EQUALS(true, tok->linkAt(5) == tok->tokAt(7));
 
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             // #4860
             const char code[] = "Bar<Typelist< int, Typelist< int, Typelist< int, FooNullType>>>>::set(1, 2, 3);";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
 
             ASSERT_EQUALS(true, tok->tokAt(1) == tok->linkAt(18));
@@ -4535,16 +3328,14 @@ class TestTokenizer : public TestFixture {
             ASSERT_EQUALS(true, tok->tokAt(7) == tok->linkAt(16));
             ASSERT_EQUALS(true, tok->tokAt(11) == tok->linkAt(15));
 
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             // #5627
             const char code[] = "new Foo<Bar>[10];";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
 
             ASSERT_EQUALS(true, tok->tokAt(2) == tok->linkAt(4));
@@ -4552,30 +3343,26 @@ class TestTokenizer : public TestFixture {
             ASSERT_EQUALS(true, tok->tokAt(5) == tok->linkAt(7));
             ASSERT_EQUALS(true, tok->tokAt(7) == tok->linkAt(5));
 
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
         {
             // #6242
             const char code[] = "func = integral_<uchar, int, double>;";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
 
             ASSERT_EQUALS(true, tok->tokAt(3) == tok->linkAt(9));
             ASSERT_EQUALS(true, tok->linkAt(3) == tok->tokAt(9));
 
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             // if (a < b || c > d) { }
-            const char code[] = "if (a < b || c > d);";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            const char code[] = "{ if (a < b || c > d); }";
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
 
             ASSERT_EQUALS(true, tok->linkAt(3) == nullptr);
@@ -4584,10 +3371,8 @@ class TestTokenizer : public TestFixture {
         {
             // bool f = a < b || c > d
             const char code[] = "bool f = a < b || c > d;";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
 
             ASSERT_EQUALS(true, tok->linkAt(4) == nullptr);
@@ -4596,10 +3381,8 @@ class TestTokenizer : public TestFixture {
         {
             // template
             const char code[] = "a < b || c > d;";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
 
             ASSERT_EQUALS(true, tok->linkAt(1) == tok->tokAt(5));
@@ -4607,11 +3390,9 @@ class TestTokenizer : public TestFixture {
 
         {
             // if (a < ... > d) { }
-            const char code[] = "if (a < b || c == 3 || d > e);";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            const char code[] = "{ if (a < b || c == 3 || d > e); }";
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
 
             ASSERT_EQUALS(true, tok->linkAt(3) == nullptr);
@@ -4620,10 +3401,8 @@ class TestTokenizer : public TestFixture {
         {
             // template
             const char code[] = "a<b==3 || c> d;";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
             ASSERT_EQUALS(true, tok->linkAt(1) == tok->tokAt(7));
         }
@@ -4631,20 +3410,16 @@ class TestTokenizer : public TestFixture {
         {
             // template
             const char code[] = "a<b || c==4> d;";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
             ASSERT_EQUALS(true, tok->linkAt(1) == tok->tokAt(7));
         }
 
         {
             const char code[] = "template < f = b || c > struct S;";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
             ASSERT_EQUALS(true, tok->linkAt(1) == tok->tokAt(7));
             ASSERT_EQUALS(true, tok->tokAt(1) == tok->linkAt(7));
@@ -4652,10 +3427,8 @@ class TestTokenizer : public TestFixture {
 
         {
             const char code[] = "struct A : B<c&&d> {};";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
             ASSERT_EQUALS(true, tok->linkAt(4) == tok->tokAt(8));
             ASSERT_EQUALS(true, tok->tokAt(4) == tok->linkAt(8));
@@ -4663,10 +3436,8 @@ class TestTokenizer : public TestFixture {
 
         {
             const char code[] = "Data<T&&>;";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
             ASSERT_EQUALS(true, tok->linkAt(1) == tok->tokAt(4));
             ASSERT_EQUALS(true, tok->tokAt(1) == tok->linkAt(4));
@@ -4675,10 +3446,8 @@ class TestTokenizer : public TestFixture {
         {
             // #6601
             const char code[] = "template<class R> struct FuncType<R(&)()> : FuncType<R()> { };";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = tokenizer.tokens();
 
             ASSERT_EQUALS(true, tok->linkAt(1) == tok->tokAt(4)); // <class R>
@@ -4695,10 +3464,8 @@ class TestTokenizer : public TestFixture {
         {
             // #7158
             const char code[] = "enum { value = boost::mpl::at_c<B, C> };";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok = Token::findsimplematch(tokenizer.tokens(), "<");
             ASSERT_EQUALS(true, tok->link() == tok->tokAt(4));
             ASSERT_EQUALS(true, tok->linkAt(4) == tok);
@@ -4709,10 +3476,8 @@ class TestTokenizer : public TestFixture {
             const char code[] = "template <typename T, typename U>\n"
                                 "struct CheckedDivOp< T, U, typename std::enable_if<std::is_floating_point<T>::value || std::is_floating_point<U>::value>::type> {\n"
                                 "};\n";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok1 = Token::findsimplematch(tokenizer.tokens(), "struct")->tokAt(2);
             const Token *tok2 = Token::findsimplematch(tokenizer.tokens(), "{")->previous();
             ASSERT_EQUALS(true, tok1->link() == tok2);
@@ -4722,10 +3487,8 @@ class TestTokenizer : public TestFixture {
         {
             // #7975
             const char code[] = "template <class C> X<Y&&Z, C*> copy() {};\n";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok1 = Token::findsimplematch(tokenizer.tokens(), "< Y");
             const Token *tok2 = Token::findsimplematch(tok1, "> copy");
             ASSERT_EQUALS(true, tok1->link() == tok2);
@@ -4735,10 +3498,8 @@ class TestTokenizer : public TestFixture {
         {
             // #8006
             const char code[] = "C<int> && a = b;";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok1 = tokenizer.tokens()->next();
             const Token *tok2 = tok1->tokAt(2);
             ASSERT_EQUALS(true, tok1->link() == tok2);
@@ -4748,10 +3509,8 @@ class TestTokenizer : public TestFixture {
         {
             // #8115
             const char code[] = "void Test(C<int> && c);";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *tok1 = Token::findsimplematch(tokenizer.tokens(), "<");
             const Token *tok2 = tok1->tokAt(2);
             ASSERT_EQUALS(true, tok1->link() == tok2);
@@ -4761,39 +3520,46 @@ class TestTokenizer : public TestFixture {
             // #8654
             const char code[] = "template<int N> struct A {}; "
                                 "template<int... Ns> struct foo : A<Ns>... {};";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             const Token *A = Token::findsimplematch(tokenizer.tokens(), "A <");
-            ASSERT_EQUALS(true, A->next()->link() == A->tokAt(3));
+            ASSERT_EQUALS(true, A->linkAt(1) == A->tokAt(3));
         }
         {
             // #8851
             const char code[] = "template<typename std::enable_if<!(std::value1) && std::value2>::type>"
                                 "void basic_json() {}";
-            errout.str("");
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
-            ASSERT_EQUALS(true, Token::simpleMatch(tokenizer.tokens()->next()->link(), "> void"));
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            ASSERT_EQUALS(true, Token::simpleMatch(tokenizer.tokens()->linkAt(1), "> void"));
         }
 
         {
             // #9094 - template usage or comparison?
             const char code[] = "a = f(x%x<--a==x>x);";
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             ASSERT(nullptr == Token::findsimplematch(tokenizer.tokens(), "<")->link());
         }
 
+        {
+            // #11319
+            const char code[] = "using std::same_as;\n"
+                                "template<same_as<int> T>\n"
+                                "void f();";
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            const Token *tok1 = Token::findsimplematch(tokenizer.tokens(), "template <");
+            const Token *tok2 = Token ::findsimplematch(tokenizer.tokens(), "same_as <");
+            ASSERT(tok1->linkAt(1) == tok1->tokAt(7));
+            ASSERT(tok2->linkAt(1) == tok2->tokAt(3));
+        }
+
         {
             // #9131 - template usage or comparison?
             const char code[] = "using std::list; list<t *> l;";
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             ASSERT(nullptr != Token::findsimplematch(tokenizer.tokens(), "<")->link());
         }
 
@@ -4803,9 +3569,8 @@ class TestTokenizer : public TestFixture {
                                 "{\n"
                                 "    for (set<ParticleSource*>::iterator i = sources.begin(); i != sources.end(); ++i) {}\n"
                                 "}";
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             ASSERT(nullptr != Token::findsimplematch(tokenizer.tokens(), "<")->link());
         }
 
@@ -4815,9 +3580,8 @@ class TestTokenizer : public TestFixture {
                                 "  a<> b;\n"
                                 "  b.a<>::c();\n"
                                 "}\n";
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             ASSERT(nullptr != Token::findsimplematch(tokenizer.tokens(), "> ::")->link());
         }
 
@@ -4827,9 +3591,8 @@ class TestTokenizer : public TestFixture {
                                 "template <char... b> struct c {\n"
                                 "  void d() { a<b...>[0]; }\n"
                                 "};\n";
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             ASSERT(nullptr != Token::findsimplematch(tokenizer.tokens(), "> [")->link());
         }
 
@@ -4840,9 +3603,8 @@ class TestTokenizer : public TestFixture {
                                 "template <typename e> using f = c<e() && sizeof(int), int>;\n"
                                 "template <typename e, typename = f<e>> struct g {};\n"
                                 "template <typename e> using baz = g<e>;\n";
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             ASSERT(nullptr != Token::findsimplematch(tokenizer.tokens(), "> ;")->link());
         }
 
@@ -4855,9 +3617,8 @@ class TestTokenizer : public TestFixture {
                                 "template <int> using c = a;\n"
                                 "template <int d> c<d> e;\n"
                                 "auto f = -e<1> == 0;\n";
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             ASSERT(nullptr != Token::findsimplematch(tokenizer.tokens(), "> ==")->link());
         }
 
@@ -4874,16 +3635,206 @@ class TestTokenizer : public TestFixture {
                                 "constexpr void b<a, d>::operator()(c &&) const {\n"
                                 "  i<3>.f([] {});\n"
                                 "}\n";
-            Tokenizer tokenizer(&settings0, this);
-            std::istringstream istr(code);
-            tokenizer.tokenize(istr, "test.cpp");
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
             ASSERT(nullptr != Token::findsimplematch(tokenizer.tokens(), "> . f (")->link());
         }
+
+        {
+            // #10491
+            const char code[] = "template <template <class> class> struct a;\n";
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            const Token* tok1 = Token::findsimplematch(tokenizer.tokens(), "< class");
+            const Token* tok2 = Token::findsimplematch(tok1, "> class");
+            ASSERT_EQUALS(true, tok1->link() == tok2);
+            ASSERT_EQUALS(true, tok2->link() == tok1);
+        }
+
+        {
+            // #10491
+            const char code[] = "template <template <class> class> struct a;\n";
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            const Token* tok1 = Token::findsimplematch(tokenizer.tokens(), "< template");
+            const Token* tok2 = Token::findsimplematch(tok1, "> struct");
+            ASSERT_EQUALS(true, tok1->link() == tok2);
+            ASSERT_EQUALS(true, tok2->link() == tok1);
+        }
+
+        {
+            // #10552
+            const char code[] = "v.value<QPair<int, int>>()\n";
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            const Token* tok1 = Token::findsimplematch(tokenizer.tokens(), "< QPair");
+            const Token* tok2 = Token::findsimplematch(tok1, "> (");
+            ASSERT_EQUALS(true, tok1->link() == tok2);
+            ASSERT_EQUALS(true, tok2->link() == tok1);
+        }
+
+        {
+            // #10552
+            const char code[] = "v.value<QPair<int, int>>()\n";
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            const Token* tok1 = Token::findsimplematch(tokenizer.tokens(), "< int");
+            const Token* tok2 = Token::findsimplematch(tok1, "> > (");
+            ASSERT_EQUALS(true, tok1->link() == tok2);
+            ASSERT_EQUALS(true, tok2->link() == tok1);
+        }
+
+        {
+            // #10615
+            const char code[] = "struct A : public B<__is_constructible()>{};\n";
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            const Token* tok1 = Token::findsimplematch(tokenizer.tokens(), "< >");
+            const Token* tok2 = Token::findsimplematch(tok1, "> { } >");
+            ASSERT_EQUALS(true, tok1->link() == tok2);
+            ASSERT_EQUALS(true, tok2->link() == tok1);
+        }
+
+        {
+            // #10664
+            const char code[] = "class C1 : public T1<D2<C2>const> {};\n";
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            const Token* tok1 = Token::findsimplematch(tokenizer.tokens(), "< C2");
+            const Token* tok2 = Token::findsimplematch(tok1, "> const");
+            ASSERT_EQUALS(true, tok1->link() == tok2);
+            ASSERT_EQUALS(true, tok2->link() == tok1);
+        }
+
+        {
+            // #11453
+            const char code[] = "template<typename T>\n"
+                                "std::array<T, 1> a{};\n"
+                                "void f() {\n"
+                                "    if (a<int>[0]) {}\n"
+                                "}\n";
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            const Token* tok1 = Token::findsimplematch(tokenizer.tokens(), "< int");
+            const Token* tok2 = Token::findsimplematch(tok1, "> [");
+            ASSERT_EQUALS(true, tok1->link() == tok2);
+            ASSERT_EQUALS(true, tok2->link() == tok1);
+        }
+
+        {
+            // #11490
+            const char code[] = "void g() {\n"
+                                "    int b[2] = {};\n"
+                                "    if (b[idx<1>]) {}\n"
+                                "}\n";
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            const Token* tok1 = Token::findsimplematch(tokenizer.tokens(), "< 1");
+            const Token* tok2 = Token::findsimplematch(tok1, "> ]");
+            ASSERT_EQUALS(true, tok1->link() == tok2);
+            ASSERT_EQUALS(true, tok2->link() == tok1);
+        }
+
+        { // #11275
+            const char code[] = "void f() {\n"
+                                "    []<typename T>() {};\n"
+                                "}\n";
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            const Token* tok1 = Token::findsimplematch(tokenizer.tokens(), "< T");
+            const Token* tok2 = Token::findsimplematch(tok1, "> (");
+            ASSERT_EQUALS(true, tok1->link() == tok2);
+            ASSERT_EQUALS(true, tok2->link() == tok1);
+        }
+
+        { // #11810
+            const char code[] = "void f() {\n"
+                                "    auto g = [] <typename A, typename B> (A a, B&& b) { return a < b; };\n"
+                                "}\n";
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            const Token* tok1 = Token::findsimplematch(tokenizer.tokens(), "< A");
+            const Token* tok2 = Token::findsimplematch(tok1, "> (");
+            ASSERT_EQUALS(true, tok1->link() == tok2);
+            ASSERT_EQUALS(true, tok2->link() == tok1);
+        }
+
+        {
+            const char code[] = "void f() {\n"
+                                "    auto g = [] <typename U> () {\n"
+                                "        return [] <typename T> () {};\n"
+                                "    };\n"
+                                "}\n";
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            const Token* tok1 = Token::findsimplematch(tokenizer.tokens(), "< T");
+            const Token* tok2 = Token::findsimplematch(tok1, "> (");
+            ASSERT_EQUALS(true, tok1->link() == tok2);
+            ASSERT_EQUALS(true, tok2->link() == tok1);
+        }
+
+        {
+            const char code[] = "struct S {\n" // #11840
+                                "    template<typename T, typename U>\n"
+                                "    void operator() (int);\n"
+                                "};\n"
+                                "void f() {\n"
+                                "    S s;\n"
+                                "    s.operator()<int, int>(1);\n"
+                                "}\n";
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            const Token* tok1 = Token::findsimplematch(tokenizer.tokens(), "< int");
+            const Token* tok2 = Token::findsimplematch(tok1, "> (");
+            ASSERT_EQUALS(true, tok1->link() == tok2);
+            ASSERT_EQUALS(true, tok2->link() == tok1);
+        }
+
+        {
+            const char code[] = "template<typename T>\n"
+                                "auto f() {\n"
+                                "    return std::integral_constant<\n"
+                                "        bool,\n"
+                                "        std::is_same<typename T::size_type, std::size_t>::value && std::is_same<typename T::size_type, std::size_t>::value\n"
+                                "        >();\n"
+                                "}\n";
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            const Token* tok1 = Token::findsimplematch(tokenizer.tokens(), "< bool");
+            const Token* tok2 = Token::findsimplematch(tok1, "> (");
+            ASSERT_EQUALS(true, tok1->link() == tok2);
+            ASSERT_EQUALS(true, tok2->link() == tok1);
+        }
+
+        {
+            const char code[] = "double f() {\n"
+                                "    return std::is_same_v<int, double> ? 1e-7 : 1e-3;\n"
+                                "}\n";
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            const Token* tok1 = Token::findsimplematch(tokenizer.tokens(), "< int");
+            const Token* tok2 = Token::findsimplematch(tok1, "> ?");
+            ASSERT_EQUALS(true, tok1->link() == tok2);
+            ASSERT_EQUALS(true, tok2->link() == tok1);
+        }
+
+        {
+            const char code[] = "template <typename Fn, typename... Args>\n" // #14612
+                                "void f(Fn && fn, Args&&... args) {\n"
+                                "    static_assert(std::is_invocable_v<Fn&&, Args&&...>);\n"
+                                "}\n";
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            const Token* tok1 = Token::findsimplematch(tokenizer.tokens(), "< Fn");
+            const Token* tok2 = Token::findsimplematch(tok1, "> )");
+            ASSERT_EQUALS(true, tok1->link() == tok2);
+            ASSERT_EQUALS(true, tok2->link() == tok1);
+        }
     }
 
     void simplifyString() {
-        errout.str("");
-        Tokenizer tokenizer(&settings0, this);
+        TokenList tokenlist{settingsDefault, Standards::Language::CPP};
+        TokenizerTest tokenizer(std::move(tokenlist), *this);
         ASSERT_EQUALS("\"abc\"", tokenizer.simplifyString("\"abc\""));
         ASSERT_EQUALS("\"\n\"", tokenizer.simplifyString("\"\\xa\""));
         ASSERT_EQUALS("\"3\"", tokenizer.simplifyString("\"\\x33\""));
@@ -4941,8 +3892,8 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("void foo ( int i ) { switch ( i ) { case -1 : ; break ; } }",
                       tokenizeAndStringify("void foo (int i) { switch(i) { case -1: break; } }"));
         //ticket #3227
-        ASSERT_EQUALS("void foo ( ) { switch ( n ) { label : ; case 1 : ; label1 : ; label2 : ; break ; } }",
-                      tokenizeAndStringify("void foo(){ switch (n){ label: case 1: label1: label2: break; }}"));
+        ASSERT_EQUALS("void foo ( int n ) { switch ( n ) { label : ; case 1 : ; label1 : ; label2 : ; break ; } }",
+                      tokenizeAndStringify("void foo(int n){ switch (n){ label: case 1: label1: label2: break; }}"));
         //ticket #8345
         ASSERT_EQUALS("void foo ( ) { switch ( 0 ) { case 0 : ; default : ; } }",
                       tokenizeAndStringify("void foo () { switch(0) case 0 : default : ; }"));
@@ -4950,141 +3901,136 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("void foo ( ) { enum Anonymous0 : int { Six = 6 } ; return Six ; }",
                       tokenizeAndStringify("void foo () { enum : int { Six = 6 } ; return Six ; }"));
         // ticket #8281
-        tokenizeAndStringify("void lzma_decode(int i) { "
-                             "  bool state; "
-                             "  switch (i) "
-                             "  while (true) { "
-                             "     state=false; "
-                             "   case 1: "
-                             "      ; "
-                             "  }"
-                             "}");
+        ASSERT_NO_THROW(tokenizeAndStringify("void lzma_decode(int i) { "
+                                             "  bool state; "
+                                             "  switch (i) "
+                                             "  while (true) { "
+                                             "     state=false; "
+                                             "   case 1: "
+                                             "      ; "
+                                             "  }"
+                                             "}"));
         // ticket #8417
-        tokenizeAndStringify("void printOwnedAttributes(int mode) { "
-                             "  switch(mode) case 0: { break; } "
-                             "}");
-        ASSERT_THROW(tokenizeAndStringify("void printOwnedAttributes(int mode) { "
-                                          "  switch(mode) case 0: { break; } case 1: ; "
-                                          "}"),
-                     InternalError);
+        ASSERT_NO_THROW(tokenizeAndStringify("void printOwnedAttributes(int mode) { "
+                                             "  switch(mode) case 0: { break; } "
+                                             "}"));
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void printOwnedAttributes(int mode) { "
+                                                   "  switch(mode) case 0: { break; } case 1: ; "
+                                                   "}"),
+                              SYNTAX);
     }
 
     void simplifyPointerToStandardType() {
         // Pointer to standard type
         ASSERT_EQUALS("char buf [ 100 ] ; readlink ( path , buf , 99 ) ;",
                       tokenizeAndStringify("char buf[100] ; readlink(path, &buf[0], 99);",
-                                           false, true, Settings::Native, "test.c"));
+                                           dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("", errout_str());
 
         ASSERT_EQUALS("void foo ( char * c ) { if ( 1 == ( 1 & c [ 0 ] ) ) { } }",
                       tokenizeAndStringify("void foo(char *c) { if (1==(1 & c[0])) {} }",
-                                           false, true, Settings::Native, "test.c"));
+                                           dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("", filter_valueflow(errout_str()));
 
         // Simplification of unknown type - C only
         ASSERT_EQUALS("foo data [ 100 ] ; something ( foo ) ;",
-                      tokenizeAndStringify("foo data[100]; something(&foo[0]);", false, true, Settings::Native, "test.c"));
+                      tokenizeAndStringify("foo data[100]; something(&foo[0]);", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("", errout_str());
 
         // C++: No pointer simplification
         ASSERT_EQUALS("foo data [ 100 ] ; something ( & foo [ 0 ] ) ;",
                       tokenizeAndStringify("foo data[100]; something(&foo[0]);"));
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void functionpointer1() {
-        ASSERT_EQUALS("void * f ;", tokenizeAndStringify("void (*f)();"));
-        ASSERT_EQUALS("void * * f ;", tokenizeAndStringify("void *(*f)();"));
-        ASSERT_EQUALS("unsigned int * f ;", tokenizeAndStringify("unsigned int (*f)();"));
-        ASSERT_EQUALS("unsigned int * * f ;", tokenizeAndStringify("unsigned int * (*f)();"));
+    void simplifyFunctionPointers1() {
+        ASSERT_EQUALS("void ( * f ) ( ) ;", tokenizeAndStringify("void (*f)();"));
+        ASSERT_EQUALS("void * ( * f ) ( ) ;", tokenizeAndStringify("void *(*f)();"));
+        ASSERT_EQUALS("unsigned int ( * f ) ( ) ;", tokenizeAndStringify("unsigned int (*f)();"));
+        ASSERT_EQUALS("unsigned int * ( * f ) ( ) ;", tokenizeAndStringify("unsigned int * (*f)();"));
+        ASSERT_EQUALS("void ( * f [ 2 ] ) ( ) ;", tokenizeAndStringify("void (*f[2])();"));
+        ASSERT_EQUALS("void ( * f [ 2 ] ) ( void ) ;", tokenizeAndStringify("typedef void func_t(void); func_t *f[2];")); // #10581
     }
 
-    void functionpointer2() {
+    void simplifyFunctionPointers2() {
         const char code[] = "typedef void (* PF)();"
                             "void f1 ( ) { }"
                             "PF pf = &f1;"
                             "PF pfs[] = { &f1, &f1 };";
         const char expected[] = "void f1 ( ) { } "
-                                "void * pf ; pf = & f1 ; "
-                                "void * pfs [ 2 ] = { & f1 , & f1 } ;";
+                                "void ( * pf ) ( ) ; pf = & f1 ; "
+                                "void ( * pfs [ ] ) ( ) = { & f1 , & f1 } ;";
         ASSERT_EQUALS(expected, tokenizeAndStringify(code));
     }
 
-    void functionpointer3() {
+    void simplifyFunctionPointers3() {
         // Related with ticket #2873
         const char code[] = "void f() {\n"
-                            "(void)(xy(*p)(0);)"
+                            "(void)(xy(*p)(0));"
                             "\n}";
         const char expected[] = "void f ( ) {\n"
-                                "( void ) ( xy ( * p ) ( 0 ) ; )\n"
+                                "( void ) ( xy ( * p ) ( 0 ) ) ;\n"
                                 "}";
         ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+        ASSERT_EQUALS(
+            "[test.cpp:2:12]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable p [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
     }
 
-    void functionpointer4() {
+    void simplifyFunctionPointers4() {
         const char code[] = "struct S\n"
                             "{\n"
                             "    typedef void (*FP)();\n"
                             "    virtual FP getFP();\n"
-                            "    virtual void execute();\n"
-                            "};\n"
-                            "void f() {\n"
-                            "  int a[9];\n"
-                            "}\n";
+                            "};";
         const char expected[] = "1: struct S\n"
                                 "2: {\n"
                                 "3:\n"
                                 "4: virtual void * getFP ( ) ;\n"
-                                "5: virtual void execute ( ) ;\n"
-                                "6: } ;\n"
-                                "7: void f ( ) {\n"
-                                "8: int a@1 [ 9 ] ;\n"
-                                "9: }\n";
-        ASSERT_EQUALS(expected, tokenizeDebugListing(code, false));
+                                "5: } ;\n";
+        ASSERT_EQUALS(expected, tokenizeDebugListing(code));
     }
 
-    void functionpointer5() {
+    void simplifyFunctionPointers5() {
         const char code[] = ";void (*fp[])(int a) = {0,0,0};";
-        const char expected[] = "1: ; void * fp@1 [ 3 ] = { 0 , 0 , 0 } ;\n";
-        ASSERT_EQUALS(expected, tokenizeDebugListing(code, false));
+        const char expected[] = "1: ; void ( * fp@1 [ ] ) ( int ) = { 0 , 0 , 0 } ;\n"; // TODO: Array dimension
+        ASSERT_EQUALS(expected, tokenizeDebugListing(code));
     }
 
-    void functionpointer6() {
-        const char code1[] = ";void (*fp(f))(int);";
-        const char expected1[] = "1: ; void * fp ( f ) ;\n"; // No varId - it could be a function
-        ASSERT_EQUALS(expected1, tokenizeDebugListing(code1, false));
+    void simplifyFunctionPointers6() {
+        const char code1[] = "void (*fp(void))(int) {}";
+        const char expected1[] = "1: void * fp ( ) { }\n";
+        ASSERT_EQUALS(expected1, tokenizeDebugListing(code1));
 
-        const char code2[] = ";std::string (*fp(f))(int);";
-        const char expected2[] = "1: ; std :: string * fp ( f ) ;\n";
-        ASSERT_EQUALS(expected2, tokenizeDebugListing(code2, false));
+        const char code2[] = "std::string (*fp(void))(int);";
+        const char expected2[] = "1: std :: string * fp ( ) ;\n";
+        ASSERT_EQUALS(expected2, tokenizeDebugListing(code2));
     }
 
-    void functionpointer7() {
+    void simplifyFunctionPointers7() {
         const char code1[] = "void (X::*y)();";
-        const char expected1[] = "1: void * y@1 ;\n";
-        ASSERT_EQUALS(expected1, tokenizeDebugListing(code1, false));
+        const char expected1[] = "1: void ( * y@1 ) ( ) ;\n";
+        ASSERT_EQUALS(expected1, tokenizeDebugListing(code1));
     }
 
-    void functionpointer8() {
+    void simplifyFunctionPointers8() {
         const char code1[] = "int (*f)() throw(int);";
-        const char expected1[] = "1: int * f@1 ;\n";
-        ASSERT_EQUALS(expected1, tokenizeDebugListing(code1, false));
+        const char expected1[] = "1: int ( * f@1 ) ( ) ;\n";
+        ASSERT_EQUALS(expected1, tokenizeDebugListing(code1));
     }
 
-    void functionpointer9() { // function call with function pointer
+    void simplifyFunctionPointers9() { // function call with function pointer
         const char code1[] = "int f() { (*f)(); }";
         const char expected1[] = "1: int f ( ) { ( * f ) ( ) ; }\n";
-        ASSERT_EQUALS(expected1, tokenizeDebugListing(code1, false));
+        ASSERT_EQUALS(expected1, tokenizeDebugListing(code1));
 
         const char code2[] = "int f() { return (*f)(); }";
         const char expected2[] = "1: int f ( ) { return ( * f ) ( ) ; }\n";
-        ASSERT_EQUALS(expected2, tokenizeDebugListing(code2, false));
+        ASSERT_EQUALS(expected2, tokenizeDebugListing(code2));
 
         const char code3[] = "int f() { throw (*f)(); }";
         const char expected3[] = "1: int f ( ) { throw ( * f ) ( ) ; }\n";
-        ASSERT_EQUALS(expected3, tokenizeDebugListing(code3, false));
-    }
-
-    void removeRedundantAssignment() {
-        ASSERT_EQUALS("void f ( ) { }", tokenizeAndStringify("void f() { int *p, *q; p = q; }", true));
-        ASSERT_EQUALS("void f ( ) { }", tokenizeAndStringify("void f() { int *p = 0, *q; p = q; }", true));
-        ASSERT_EQUALS("int f ( int * x ) { return * x ; }", tokenizeAndStringify("int f(int *x) { return *x; }", true));
+        ASSERT_EQUALS(expected3, tokenizeDebugListing(code3));
     }
 
     void removedeclspec() {
@@ -5109,20 +4055,18 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("struct Payload_IR_config { uint8_t tap [ 16 ] ; } ;", tokenizeAndStringify("struct __attribute__((packed, gcc_struct)) Payload_IR_config { uint8_t tap[16]; };"));
     }
 
-    void functionAttributeBefore() {
+    void functionAttributeBefore1() {
         const char code[] = "void __attribute__((pure)) __attribute__((nothrow)) __attribute__((const)) func1();\n"
                             "void __attribute__((__pure__)) __attribute__((__nothrow__)) __attribute__((__const__)) func2();\n"
                             "void __attribute__((nothrow)) __attribute__((pure)) __attribute__((const)) func3();\n"
                             "void __attribute__((__nothrow__)) __attribute__((__pure__)) __attribute__((__const__)) func4();\n"
-                            "void __attribute__((noreturn)) func5();";
-        const char expected[] = "void func1 ( ) ; void func2 ( ) ; void func3 ( ) ; void func4 ( ) ; void func5 ( ) ;";
-
-        errout.str("");
+                            "void __attribute__((noreturn)) func5();\n"
+                            "void __attribute__((__visibility__(\"default\"))) func6();";
+        const char expected[] = "void func1 ( ) ; void func2 ( ) ; void func3 ( ) ; void func4 ( ) ; void func5 ( ) ; void func6 ( ) ;";
 
         // tokenize..
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT(tokenizer.tokenize(code));
 
         // Expected result..
         ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
@@ -5132,15 +4076,72 @@ class TestTokenizer : public TestFixture {
         const Token * func3 = Token::findsimplematch(tokenizer.tokens(), "func3");
         const Token * func4 = Token::findsimplematch(tokenizer.tokens(), "func4");
         const Token * func5 = Token::findsimplematch(tokenizer.tokens(), "func5");
+        const Token * func6 = Token::findsimplematch(tokenizer.tokens(), "func6");
 
-        ASSERT(func1 && func1->isAttributePure() && func1->isAttributeNothrow() && func1->isAttributeConst());
-        ASSERT(func2 && func2->isAttributePure() && func2->isAttributeNothrow() && func2->isAttributeConst());
-        ASSERT(func3 && func3->isAttributePure() && func3->isAttributeNothrow() && func3->isAttributeConst());
-        ASSERT(func4 && func4->isAttributePure() && func4->isAttributeNothrow() && func4->isAttributeConst());
+        ASSERT(func1 && func1->isAttributePure() && func1->isAttributeNothrow() && func1->isAttributeConst() && !func1->isAttributeExport());
+        ASSERT(func2 && func2->isAttributePure() && func2->isAttributeNothrow() && func2->isAttributeConst() && !func2->isAttributeExport());
+        ASSERT(func3 && func3->isAttributePure() && func3->isAttributeNothrow() && func3->isAttributeConst() && !func3->isAttributeExport());
+        ASSERT(func4 && func4->isAttributePure() && func4->isAttributeNothrow() && func4->isAttributeConst() && !func4->isAttributeExport());
         ASSERT(func5 && func5->isAttributeNoreturn());
+        ASSERT(func6 && func6->isAttributeExport());
     }
 
-    void functionAttributeAfter() {
+    void functionAttributeBefore2() {
+        const char code[] = "extern vas_f *VAS_Fail __attribute__((__noreturn__));";
+        const char expected[] = "extern vas_f * VAS_Fail ;";
+
+        // tokenize..
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT(tokenizer.tokenize(code));
+        ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+
+        const Token * VAS_Fail = Token::findsimplematch(tokenizer.tokens(), "VAS_Fail");
+        ASSERT(VAS_Fail && VAS_Fail->isAttributeNoreturn());
+    }
+
+    void functionAttributeBefore3() { // #10978
+        const char code[] = "void __attribute__((__noreturn__)) (*func_notret)(void);";
+        const char expected[] = "void ( * func_notret ) ( void ) ;";
+
+        // tokenize..
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT(tokenizer.tokenize(code));
+        ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+
+        const Token* func_notret = Token::findsimplematch(tokenizer.tokens(), "func_notret");
+        ASSERT(func_notret && func_notret->isAttributeNoreturn());
+    }
+
+    void functionAttributeBefore4() {
+        const char code[] = "__attribute__((const)) int& foo();";
+        const char expected[] = "int & foo ( ) ;";
+
+        // tokenize..
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT(tokenizer.tokenize(code));
+        ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+
+        const Token* foo = Token::findsimplematch(tokenizer.tokens(), "foo");
+        ASSERT(foo && foo->isAttributeConst());
+    }
+
+    void functionAttributeBefore5() { // __declspec(dllexport)
+        const char code[] = "void __declspec(dllexport) func1();\n";
+        const char expected[] = "void func1 ( ) ;";
+
+        // tokenize..
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT(tokenizer.tokenize(code));
+
+        // Expected result..
+        ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+
+        const Token * func1 = Token::findsimplematch(tokenizer.tokens(), "func1");
+
+        ASSERT(func1 && func1->isAttributeExport());
+    }
+
+    void functionAttributeAfter1() {
         const char code[] = "void func1() __attribute__((pure)) __attribute__((nothrow)) __attribute__((const));\n"
                             "void func2() __attribute__((__pure__)) __attribute__((__nothrow__)) __attribute__((__const__));\n"
                             "void func3() __attribute__((nothrow)) __attribute__((pure)) __attribute__((const));\n"
@@ -5148,12 +4149,97 @@ class TestTokenizer : public TestFixture {
                             "void func5() __attribute__((noreturn));";
         const char expected[] = "void func1 ( ) ; void func2 ( ) ; void func3 ( ) ; void func4 ( ) ; void func5 ( ) ;";
 
-        errout.str("");
+        // tokenize..
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT(tokenizer.tokenize(code));
+
+        // Expected result..
+        ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+
+        const Token * func1 = Token::findsimplematch(tokenizer.tokens(), "func1");
+        const Token * func2 = Token::findsimplematch(tokenizer.tokens(), "func2");
+        const Token * func3 = Token::findsimplematch(tokenizer.tokens(), "func3");
+        const Token * func4 = Token::findsimplematch(tokenizer.tokens(), "func4");
+        const Token * func5 = Token::findsimplematch(tokenizer.tokens(), "func5");
+
+        ASSERT(func1 && func1->isAttributePure() && func1->isAttributeNothrow() && func1->isAttributeConst());
+        ASSERT(func2 && func2->isAttributePure() && func2->isAttributeNothrow() && func2->isAttributeConst());
+        ASSERT(func3 && func3->isAttributePure() && func3->isAttributeNothrow() && func3->isAttributeConst());
+        ASSERT(func4 && func4->isAttributePure() && func4->isAttributeNothrow() && func4->isAttributeConst());
+        ASSERT(func5 && func5->isAttributeNoreturn());
+    }
+
+    void functionAttributeAfter2() {
+        const char code[] = "class foo {\n"
+                            "public:\n"
+                            "    bool operator==(const foo &) __attribute__((__pure__));\n"
+                            "};";
+        const char expected[] = "class foo { public: bool operator== ( const foo & ) ; } ;";
+
+        // tokenize..
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT(tokenizer.tokenize(code));
+
+        // Expected result..
+        ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+
+        const Token *tok = Token::findsimplematch(tokenizer.tokens(), "operator==");
+        ASSERT(tok && tok->isAttributePure());
+    }
+
+    void functionAttributeListBefore() {
+        const char code[] = "void __attribute__((pure,nothrow,const)) func1();\n"
+                            "void __attribute__((__pure__,__nothrow__,__const__)) func2();\n"
+                            "void __attribute__((nothrow,pure,const)) func3();\n"
+                            "void __attribute__((__nothrow__,__pure__,__const__)) func4();\n"
+                            "void __attribute__((noreturn,format(printf,1,2))) func5();\n"
+                            "void __attribute__((__nothrow__)) __attribute__((__pure__,__const__)) func6();\n"
+                            "void __attribute__((__nothrow__,__pure__)) __attribute__((__const__)) func7();\n"
+                            "void __attribute__((noreturn)) __attribute__(()) __attribute__((nothrow,pure,const)) func8();";
+        const char expected[] = "void func1 ( ) ; void func2 ( ) ; void func3 ( ) ; void func4 ( ) ; void func5 ( ) ; "
+                                "void func6 ( ) ; void func7 ( ) ; void func8 ( ) ;";
+
+        // tokenize..
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT(tokenizer.tokenize(code));
+
+        // Expected result..
+        ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+
+        const Token * func1 = Token::findsimplematch(tokenizer.tokens(), "func1");
+        const Token * func2 = Token::findsimplematch(tokenizer.tokens(), "func2");
+        const Token * func3 = Token::findsimplematch(tokenizer.tokens(), "func3");
+        const Token * func4 = Token::findsimplematch(tokenizer.tokens(), "func4");
+        const Token * func5 = Token::findsimplematch(tokenizer.tokens(), "func5");
+        const Token * func6 = Token::findsimplematch(tokenizer.tokens(), "func6");
+        const Token * func7 = Token::findsimplematch(tokenizer.tokens(), "func7");
+        const Token * func8 = Token::findsimplematch(tokenizer.tokens(), "func8");
+
+        ASSERT(func1 && func1->isAttributePure() && func1->isAttributeNothrow() && func1->isAttributeConst());
+        ASSERT(func2 && func2->isAttributePure() && func2->isAttributeNothrow() && func2->isAttributeConst());
+        ASSERT(func3 && func3->isAttributePure() && func3->isAttributeNothrow() && func3->isAttributeConst());
+        ASSERT(func4 && func4->isAttributePure() && func4->isAttributeNothrow() && func4->isAttributeConst());
+        ASSERT(func5 && func5->isAttributeNoreturn());
+        ASSERT(func6 && func6->isAttributePure() && func6->isAttributeNothrow() && func6->isAttributeConst());
+        ASSERT(func7 && func7->isAttributePure() && func7->isAttributeNothrow() && func7->isAttributeConst());
+        ASSERT(func8 && func8->isAttributeNoreturn() && func8->isAttributePure() && func8->isAttributeNothrow() && func8->isAttributeConst());
+    }
+
+    void functionAttributeListAfter() {
+        const char code[] = "void func1() __attribute__((pure,nothrow,const));\n"
+                            "void func2() __attribute__((__pure__,__nothrow__,__const__));\n"
+                            "void func3() __attribute__((nothrow,pure,const));\n"
+                            "void func4() __attribute__((__nothrow__,__pure__,__const__));\n"
+                            "void func5() __attribute__((noreturn,format(printf,1,2)));\n"
+                            "void func6() __attribute__((__nothrow__)) __attribute__((__pure__,__const__));\n"
+                            "void func7() __attribute__((__nothrow__,__pure__)) __attribute__((__const__));\n"
+                            "void func8() __attribute__((noreturn)) __attribute__(()) __attribute__((nothrow,pure,const));";
+        const char expected[] = "void func1 ( ) ; void func2 ( ) ; void func3 ( ) ; void func4 ( ) ; void func5 ( ) ; "
+                                "void func6 ( ) ; void func7 ( ) ; void func8 ( ) ;";
 
         // tokenize..
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT(tokenizer.tokenize(code));
 
         // Expected result..
         ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
@@ -5163,125 +4249,273 @@ class TestTokenizer : public TestFixture {
         const Token * func3 = Token::findsimplematch(tokenizer.tokens(), "func3");
         const Token * func4 = Token::findsimplematch(tokenizer.tokens(), "func4");
         const Token * func5 = Token::findsimplematch(tokenizer.tokens(), "func5");
+        const Token * func6 = Token::findsimplematch(tokenizer.tokens(), "func6");
+        const Token * func7 = Token::findsimplematch(tokenizer.tokens(), "func7");
+        const Token * func8 = Token::findsimplematch(tokenizer.tokens(), "func8");
 
         ASSERT(func1 && func1->isAttributePure() && func1->isAttributeNothrow() && func1->isAttributeConst());
         ASSERT(func2 && func2->isAttributePure() && func2->isAttributeNothrow() && func2->isAttributeConst());
         ASSERT(func3 && func3->isAttributePure() && func3->isAttributeNothrow() && func3->isAttributeConst());
         ASSERT(func4 && func4->isAttributePure() && func4->isAttributeNothrow() && func4->isAttributeConst());
         ASSERT(func5 && func5->isAttributeNoreturn());
+        ASSERT(func6 && func6->isAttributePure() && func6->isAttributeNothrow() && func6->isAttributeConst());
+        ASSERT(func7 && func7->isAttributePure() && func7->isAttributeNothrow() && func7->isAttributeConst());
+        ASSERT(func8 && func8->isAttributeNoreturn() && func8->isAttributePure() && func8->isAttributeNothrow() && func8->isAttributeConst());
+    }
+
+    void functionAttributeListAfter2() {
+        const char code[] = "[[noreturn]] void func1(const char *format, ...) __attribute__((format(printf, 1, 2)));\n" // #14181
+                            "void func2() __attribute__((unused));\n"; // #14183
+        const char expected[] = "void func1 ( const char * format , ... ) ; void func2 ( ) ;";
+
+        // tokenize..
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT(tokenizer.tokenize(code));
+
+        // Expected result..
+        ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+
+        const Token * func1 = Token::findsimplematch(tokenizer.tokens(), "func1");
+        const Token * func2 = Token::findsimplematch(tokenizer.tokens(), "func2");
+
+        ASSERT(func1 && func1->isAttributeNoreturn());
+        ASSERT(func2 && func2->isAttributeUnused());
+    }
+
+    void cppMaybeUnusedBefore() {
+        const char code[] = "[[maybe_unused]] int var {};";
+        const char expected[] = "int var { } ;";
+
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT(tokenizer.tokenize(code));
+
+        ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+
+        const Token *var = Token::findsimplematch(tokenizer.tokens(), "var");
+        ASSERT(var && var->isAttributeMaybeUnused());
+    }
+
+    void cppMaybeUnusedAfter1() {
+        const char code[] = "int var [[maybe_unused]] {};";
+        const char expected[] = "int var { } ;";
+
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT(tokenizer.tokenize(code));
+
+        ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+
+        const Token *var = Token::findsimplematch(tokenizer.tokens(), "var");
+        ASSERT(var && var->isAttributeMaybeUnused());
+    }
+
+    void cppMaybeUnusedAfter2() {
+        const char code[] = "std::string var [[maybe_unused]];";
+        const char expected[] = "std :: string var ;";
+
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT(tokenizer.tokenize(code));
+
+        ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+
+        const Token *var = Token::findsimplematch(tokenizer.tokens(), "var");
+        ASSERT(var && var->isAttributeMaybeUnused());
+    }
+
+    void cppMaybeUnusedStructuredBinding() {
+        const char code[] = "[[maybe_unused]] auto [var1, var2] = f();";
+        const char expected[] = "auto [ var1 , var2 ] = f ( ) ;";
+
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT(tokenizer.tokenize(code));
+
+        ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+
+        const Token *var1 = Token::findsimplematch(tokenizer.tokens(), "var1");
+        ASSERT(var1 && var1->isAttributeMaybeUnused());
+        const Token *var2 = Token::findsimplematch(tokenizer.tokens(), "var2");
+        ASSERT(var2 && var2->isAttributeMaybeUnused());
+    }
+
+    void attributeAlignasBefore() {
+        const char code[] = "alignas(long) unsigned char buffer[sizeof(long)];";
+        const char expected[] = "char buffer [ sizeof ( long ) ] ;";
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT(tokenizer.tokenize(code));
+
+        ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+
+        const Token *var = Token::findsimplematch(tokenizer.tokens(), "buffer");
+        ASSERT(var);
+        ASSERT(var->hasAttributeAlignas());
+        ASSERT(var->getAttributeAlignas().size() == 1);
+        ASSERT_EQUALS(var->getAttributeAlignas()[0], "long");
+    }
+
+    void attributeAlignasAfter() {
+        const char code[] = "unsigned char buffer[sizeof(long)] alignas(long);";
+        const char expected[] = "char buffer [ sizeof ( long ) ] ;";
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT(tokenizer.tokenize(code));
+
+        ASSERT_EQUALS(expected, tokenizer.tokens()->stringifyList(nullptr, false));
+
+        const Token *var = Token::findsimplematch(tokenizer.tokens(), "buffer");
+        ASSERT(var);
+        ASSERT(var->hasAttributeAlignas());
+        ASSERT(var->getAttributeAlignas().size() == 1);
+        ASSERT_EQUALS(var->getAttributeAlignas()[0], "long");
+    }
+
+    void splitTemplateRightAngleBrackets() {
+        {
+            const char code[] = "; z = x < 0 ? x >> y : x >> y;";
+            ASSERT_EQUALS("; z = x < 0 ? x >> y : x >> y ;", tokenizeAndStringify(code));
+        }
+        {
+            // ftp://ftp.de.debian.org/debian/pool/main/f/ffmpeg/ffmpeg_4.3.1.orig.tar.xz
+            // ffmpeg-4.3.1/libavcodec/mpeg4videodec.c:376
+            const char code[] = "void f ( ) {\n"
+                                "    int shift_y = ctx->sprite_shift[0];\n"
+                                "    int shift_c = ctx->sprite_shift[1];\n"
+                                "    if ( shift_c < 0 || shift_y < 0 ||\n"
+                                "         FFABS ( sprite_offset [ 0 ] [ i ] ) >= INT_MAX >> shift_y ||\n"
+                                "         FFABS ( sprite_offset [ 1 ] [ i ] ) >= INT_MAX >> shift_c ||\n"
+                                "         FFABS ( sprite_delta [ 0 ] [ i ] ) >= INT_MAX >> shift_y ||\n"
+                                "         FFABS ( sprite_delta [ 1 ] [ i ] ) >= INT_MAX >> shift_y ) ;\n"
+                                "}";
+            ASSERT_EQUALS(std::string::npos, tokenizeAndStringify(code).find("> >"));
+            ASSERT_EQUALS(
+                "[test.cpp:2:24]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable sprite_shift [valueFlowBailoutIncompleteVar]\n",
+                errout_str());
+        }
+        {
+            const char code[] = "struct S { bool vector; };\n"
+                                "struct T { std::vector<std::shared_ptr<int>> v; };\n";
+            ASSERT_EQUALS("struct S { bool vector ; } ;\n"
+                          "struct T { std :: vector < std :: shared_ptr < int > > v ; } ;",
+                          tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
+        }
     }
 
     void cpp03template1() {
         {
-            const char *code = "template<typename> struct extent {};";
+            const char code[] = "template<typename> struct extent {};";
             ASSERT_EQUALS("template < typename > struct extent { } ;", tokenizeAndStringify(code));
         }
         {
-            const char *code = "template<typename> struct extent;";
+            const char code[] = "template<typename> struct extent;";
             ASSERT_EQUALS("template < typename > struct extent ;", tokenizeAndStringify(code));
         }
         {
-            const char *code = "template<typename, unsigned = 0> struct extent;";
+            const char code[] = "template<typename, unsigned = 0> struct extent;";
             ASSERT_EQUALS("template < typename , unsigned int = 0 > struct extent ;", tokenizeAndStringify(code));
         }
     }
 
     void cpp0xtemplate1() {
-        const char *code = "template <class T>\n"
-                           "void fn2 (T t = []{return 1;}())\n"
-                           "{}\n"
-                           "int main()\n"
-                           "{\n"
-                           "  fn2<int>();\n"
-                           "}\n";
+        const char code[] = "template <class T>\n"
+                            "void fn2 (T t = []{return 1;}())\n"
+                            "{}\n"
+                            "int main()\n"
+                            "{\n"
+                            "  fn2<int>();\n"
+                            "}\n";
         ASSERT_EQUALS("void fn2<int> ( int t = [ ] { return 1 ; } ( ) ) ;\n"
-                      "\n"
                       "\n"
                       "int main ( )\n"
                       "{\n"
                       "fn2<int> ( ) ;\n"
-                      "} void fn2<int> ( int t = [ ] { return 1 ; } ( ) )\n"
+                      "}\n"
+                      "void fn2<int> ( int t = [ ] { return 1 ; } ( ) )\n"
                       "{ }", tokenizeAndStringify(code));
     }
 
     void cpp0xtemplate2() {
         // tokenize ">>" into "> >"
-        const char *code = "list<list<int>> ints;\n";
+        const char code[] = "list<list<int>> ints;\n";
         ASSERT_EQUALS("list < list < int > > ints ;", tokenizeAndStringify(code));
     }
 
     void cpp0xtemplate3() {
         // #2549
-        const char *code = "template<class T, T t = (T)0>\n"
-                           "struct S\n"
-                           "{};\n"
-                           "S<int> s;\n";
-        ASSERT_EQUALS("struct S<int,(int)0> ;\n"
+        const char code[] = "template<class T, T t = (T)0>\n"
+                            "struct S\n"
+                            "{};\n"
+                            "S<int> s;\n";
+        ASSERT_EQUALS("struct S<int,0> ;\n"
                       "\n"
                       "\n"
-                      "S<int,(int)0> s ; struct S<int,(int)0>\n"
+                      "S<int,0> s ;\n"
+                      "struct S<int,0>\n"
                       "{ } ;",
                       tokenizeAndStringify(code));
     }
 
     void cpp0xtemplate4() { // #6181, #6354, #6414
-        tokenizeAndStringify("class A; "
-                             "template <class T> class Disposer; "
-                             "template <typename T, class D = Disposer<T>> class Shim {}; "
-                             "class B : public Shim<A> {};");
-        tokenizeAndStringify("template <class ELFT> class ELFObjectImage {}; "
-                             "ObjectImage *createObjectImage() { "
-                             "  return new ELFObjectImage<ELFType<little>>(Obj); "
-                             "} "
-                             "void resolveX86_64Relocation() { "
-                             "  reinterpret_cast<int>(0); "
-                             "}");
-        tokenizeAndStringify("template<typename value_type, typename function_type> "
-                             "value_type Base(const value_type x, const value_type dx, function_type func, int type_deriv) { "
-                             "   return 0.0; "
-                             "}; "
-                             "namespace { "
-                             "  template<class DC> class C { "
-                             "    void Fun(int G, const double x); "
-                             "  }; "
-                             "  template<class DC> void C<DC>::Fun(int G, const double x) {"
-                             "    Base<double, CDFFunctor<DC>>(2, 2, f, 0); "
-                             "  }; "
-                             "  template<class DC> class C2 {}; "
-                             "}");
+        // #6181
+        ASSERT_NO_THROW(tokenizeAndStringify("class A; "
+                                             "template <class T> class Disposer; "
+                                             "template <typename T, class D = Disposer<T>> class Shim {}; "
+                                             "class B : public Shim<A> {};"));
+        // #6354 (segmentation fault)
+        (void)tokenizeAndStringify("template <class ELFT> class ELFObjectImage {}; "
+                                   "ObjectImage *createObjectImage() { "
+                                   "  return new ELFObjectImage<ELFType<little>>(Obj); "
+                                   "} "
+                                   "void resolveX86_64Relocation() { "
+                                   "  reinterpret_cast<int>(0); "
+                                   "}");
+        // #6414
+        ASSERT_NO_THROW(tokenizeAndStringify("template<typename value_type, typename function_type> "
+                                             "value_type Base(const value_type x, const value_type dx, function_type func, int type_deriv) { "
+                                             "   return 0.0; "
+                                             "}; "
+                                             "namespace { "
+                                             "  template<class DC> class C { "
+                                             "    void Fun(int G, const double x); "
+                                             "  }; "
+                                             "  template<class DC> void C<DC>::Fun(int G, const double x) {"
+                                             "    Base<double, CDFFunctor<DC>>(2, 2, f, 0); "
+                                             "  }; "
+                                             "  template<class DC> class C2 {}; "
+                                             "}"));
+
+        ignore_errout();
     }
 
     void cpp0xtemplate5() { // #9154
         {
-            const char *code = "struct s<x<u...>>;";
+            const char code[] = "struct s<x<u...>>;";
             ASSERT_EQUALS("struct s < x < u ... > > ;",
                           tokenizeAndStringify(code));
         }
         {
-            const char *code = "template <class f> using c = e<i<q<f,r>,b...>>;";
+            const char code[] = "template <class f> using c = e<i<q<f,r>,b...>>;";
             ASSERT_EQUALS("template < class f > using c = e < i < q < f , r > , b ... > > ;",
                           tokenizeAndStringify(code));
         }
         {
-            const char *code = "struct s<x<u...>> { };";
+            const char code[] = "struct s<x<u...>> { };";
             ASSERT_EQUALS("struct s < x < u ... > > { } ;",
                           tokenizeAndStringify(code));
         }
         {
-            const char *code = "struct q : s<x<u...>> { };";
+            const char code[] = "struct q : s<x<u...>> { };";
             ASSERT_EQUALS("struct q : s < x < u ... > > { } ;",
                           tokenizeAndStringify(code));
         }
         {
-            const char *code = "struct q : private s<x<u...>> { };";
+            const char code[] = "struct q : private s<x<u...>> { };";
             ASSERT_EQUALS("struct q : private s < x < u ... > > { } ;",
                           tokenizeAndStringify(code));
         }
     }
 
     void cpp14template() { // Ticket #6708
-        tokenizeAndStringify("template <typename T> "
-                             "decltype(auto) forward(T& t) { return 0; }");
+        (void)tokenizeAndStringify("template <typename T> "
+                                   "decltype(auto) forward(T& t) { return 0; }");
+        ASSERT_EQUALS("[test.cpp:1:32]: (debug) auto token with no type. [autoNoType]\n", errout_str());
     }
 
     void arraySize() {
@@ -5291,10 +4525,19 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("; int a [ 1 ] = { foo < bar1 , bar2 > ( 123 , 4 ) } ;", tokenizeAndStringify(";int a[]={foo<bar1,bar2>(123,4)};"));
         ASSERT_EQUALS("; int a [ 2 ] = { b > c ? 1 : 2 , 3 } ;", tokenizeAndStringify(";int a[]={ b>c?1:2,3};"));
         ASSERT_EQUALS("int main ( ) { int a [ 2 ] = { b < c ? 1 : 2 , 3 } }", tokenizeAndStringify("int main(){int a[]={b<c?1:2,3}}"));
+        ASSERT_EQUALS(
+            "[test.cpp:1:21]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable b [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
         ASSERT_EQUALS("; int a [ 3 ] = { ABC , 2 , 3 } ;", tokenizeAndStringify(";int a[]={ABC,2,3};"));
         ASSERT_EQUALS("; int a [ 3 ] = { [ 2 ] = 5 } ;", tokenizeAndStringify(";int a[]={ [2] = 5 };"));
         ASSERT_EQUALS("; int a [ 5 ] = { 1 , 2 , [ 2 ] = 5 , 3 , 4 } ;", tokenizeAndStringify(";int a[]={ 1, 2, [2] = 5, 3, 4 };"));
         ASSERT_EQUALS("; int a [ ] = { 1 , 2 , [ x ] = 5 , 3 , 4 } ;", tokenizeAndStringify(";int a[]={ 1, 2, [x] = 5, 3, 4 };"));
+        ASSERT_EQUALS("; const char c [ 4 ] = \"abc\" ;", tokenizeAndStringify(";const char c[] = { \"abc\" };"));
+    }
+
+    void arraySizeAfterValueFlow() {
+        const char code[] = "enum {X=10}; int a[] = {[X]=1};";
+        ASSERT_EQUALS("enum Anonymous0 { X = 10 } ; int a [ 11 ] = { [ X ] = 1 } ;", tokenizeAndStringify(code));
     }
 
     void labels() {
@@ -5317,153 +4560,155 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("void f ( ) { ab : ; { & b = 0 ; } }", tokenizeAndStringify("void f() { ab: { &b=0;} }"));
         ASSERT_EQUALS("void f ( ) { ab : ; { & ( * b . x ) = 0 ; } }", tokenizeAndStringify("void f() { ab: {&(*b.x)=0;} }"));
         //with unhandled MACRO() code
-        ASSERT_EQUALS("void f ( ) { MACRO ( ab : b = 0 ; , foo ) }", tokenizeAndStringify("void f() { MACRO(ab: b=0;, foo)}"));
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void f() { MACRO(ab: b=0;, foo)}"), UNKNOWN_MACRO);
         ASSERT_EQUALS("void f ( ) { MACRO ( bar , ab : { & ( * b . x ) = 0 ; } ) }", tokenizeAndStringify("void f() { MACRO(bar, ab: {&(*b.x)=0;})}"));
+
+        ignore_errout();
     }
 
     void simplifyInitVar() {
         {
             const char code[] = "int i ; int p(0);";
-            ASSERT_EQUALS("int i ; int p ; p = 0 ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("int i ; int p ( 0 ) ;", tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "int i; int *p(0);";
-            ASSERT_EQUALS("int i ; int * p ; p = 0 ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("int i ; int * p ( 0 ) ;", tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "int p(0);";
-            ASSERT_EQUALS("int p ; p = 0 ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("int p ( 0 ) ;", tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "int *p(0);";
-            ASSERT_EQUALS("int * p ; p = 0 ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("int * p ( 0 ) ;", tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "int i ; int p(i);";
-            ASSERT_EQUALS("int i ; int p ; p = i ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("int i ; int p ( i ) ;", tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "int i; int *p(&i);";
-            ASSERT_EQUALS("int i ; int * p ; p = & i ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("int i ; int * p ( & i ) ;", tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "int i; void *p(&i);";
-            ASSERT_EQUALS("int i ; void * p ; p = & i ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("int i ; void * p ( & i ) ;", tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "struct S { }; struct S s; struct S *p(&s);";
-            ASSERT_EQUALS("struct S { } ; struct S s ; struct S * p ; p = & s ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("struct S { } ; struct S s ; struct S * p ( & s ) ;", tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "struct S { }; S s; S *p(&s);";
-            ASSERT_EQUALS("struct S { } ; S s ; S * p ; p = & s ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("struct S { } ; S s ; S * p ( & s ) ;", tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "union S { int i; float f; }; union S s; union S *p(&s);";
-            ASSERT_EQUALS("union S { int i ; float f ; } ; union S s ; union S * p ; p = & s ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("union S { int i ; float f ; } ; union S s ; union S * p ( & s ) ;", tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "union S { int i; float f; }; S s; S *p(&s);";
-            ASSERT_EQUALS("union S { int i ; float f ; } ; S s ; S * p ; p = & s ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("union S { int i ; float f ; } ; S s ; S * p ( & s ) ;", tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "class C { }; class C c; class C *p(&c);";
-            ASSERT_EQUALS("class C { } ; class C c ; class C * p ; p = & c ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("class C { } ; class C c ; class C * p ( & c ) ;", tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "class C { }; C c; C *p(&c);";
-            ASSERT_EQUALS("class C { } ; C c ; C * p ; p = & c ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("class C { } ; C c ; C * p ( & c ) ;", tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "struct S { }; struct S s; struct S s1(s);";
             ASSERT_EQUALS("struct S { } ; struct S s ; struct S s1 ( s ) ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "struct S { }; S s; S s1(s);";
             ASSERT_EQUALS("struct S { } ; S s ; S s1 ( s ) ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "struct S { }; struct S s; struct S s1(&s);";
             ASSERT_EQUALS("struct S { } ; struct S s ; struct S s1 ( & s ) ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "struct S { }; S s; S s1(&s);";
             ASSERT_EQUALS("struct S { } ; S s ; S s1 ( & s ) ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "class S { int function(); };";
             ASSERT_EQUALS("class S { int function ( ) ; } ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "class S { int function(void); };";
             ASSERT_EQUALS("class S { int function ( ) ; } ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "class S { int function(int); };";
             ASSERT_EQUALS("class S { int function ( int ) ; } ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "int function(void);";
             ASSERT_EQUALS("int function ( ) ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "int function(int);";
             ASSERT_EQUALS("int function ( int ) ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "extern int function(void);";
             ASSERT_EQUALS("extern int function ( ) ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "int function1(void); int function2(void);";
             ASSERT_EQUALS("int function1 ( ) ; int function2 ( ) ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
@@ -5471,71 +4716,45 @@ class TestTokenizer : public TestFixture {
             // We can't tell if this a function prototype or a variable without knowing
             // what A is. Since A is undefined, just leave it alone.
             ASSERT_EQUALS("int function ( A ) ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "int i; int function(A);";
             ASSERT_EQUALS("int i ; int function ( A ) ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "class A { } ; int foo(A);";
             ASSERT_EQUALS("class A { } ; int foo ( A ) ;", tokenizeAndStringify(code));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "class A { } ; A a; int foo(a);";
-            ASSERT_EQUALS("class A { } ; A a ; int foo ; foo = a ;", tokenizeAndStringify(code, false));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("class A { } ; A a ; int foo ( a ) ;", tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
             const char code[] = "int x(f());";
-            ASSERT_EQUALS("int x ; x = f ( ) ;", tokenizeAndStringify(code, false));
-            ASSERT_EQUALS("", errout.str());
-        }
-
-        {
-            const char code[] = "return doSomething(X), 0;";
-            ASSERT_EQUALS("return doSomething ( X ) , 0 ;", tokenizeAndStringify(code, false));
-            ASSERT_EQUALS("", errout.str());
-        }
-
-        {
-            const char code[] = "const int x(1);"
-                                "const int y(2);"
-                                "const int z((x+1)*y);"
-                                "f(z);";
-            ASSERT_EQUALS("f ( 4 ) ;", tokenizeAndStringify(code, true));
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("int x ( f ( ) ) ;", tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "const int x(1);"
-                                "const int y(2);"
-                                "const int z((x+1)*y);"
-                                "f(&z);";
-            ASSERT_EQUALS("const int z ( 4 ) ; f ( & z ) ;", tokenizeAndStringify(code, true));
-            ASSERT_EQUALS("", errout.str());
+            const char code[] = "{ return doSomething(X), 0; }";
+            ASSERT_EQUALS("{ return doSomething ( X ) , 0 ; }", tokenizeAndStringify(code));
+            ASSERT_EQUALS("", errout_str());
         }
 
         {
-            const char code[] = "const bool x(true);"
-                                "const bool y(!x);"
-                                "f(y);";
-            ASSERT_EQUALS("f ( false ) ;", tokenizeAndStringify(code, true));
-            ASSERT_EQUALS("", errout.str());
-        }
-
-        {
-            const char code[] = "const bool x(true);"
-                                "const bool y(!x);"
-                                "f(&y);";
-            ASSERT_EQUALS("const bool y ( false ) ; f ( & y ) ;", tokenizeAndStringify(code, true));
-            ASSERT_EQUALS("", errout.str());
+            // 13893
+            const char code[] = "namespace test { bool foo; }";
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT(tokenizer.tokenize(code));
+            ASSERT(!tokenizer.tokens()->tokAt(2)->isInitBracket());
         }
     }
 
@@ -5545,7 +4764,7 @@ class TestTokenizer : public TestFixture {
                             "    unsigned int a(0),b(0);\n"
                             "}";
         ASSERT_EQUALS("void f ( ) {\n"
-                      "unsigned int a ; a = 0 ; unsigned int b ; b = 0 ;\n"
+                      "unsigned int a ( 0 ) ; unsigned int b ( 0 ) ;\n"
                       "}", tokenizeAndStringify(code));
     }
 
@@ -5554,179 +4773,187 @@ class TestTokenizer : public TestFixture {
                             "    int *a(0),b(0);\n"
                             "}";
         ASSERT_EQUALS("void f ( ) {\n"
-                      "int * a ; a = 0 ; int b ; b = 0 ;\n"
+                      "int * a ( 0 ) ; int b ( 0 ) ;\n"
+                      "}", tokenizeAndStringify(code));
+    }
+
+    void simplifyInitVar4() {
+        const char code[] = "void f() {\n"
+                            "    uint32_t x{0};\n"
+                            "}";
+        ASSERT_EQUALS("void f ( ) {\n"
+                      "uint32_t x { 0 } ;\n"
                       "}", tokenizeAndStringify(code));
     }
 
+    void simplifyInitVar5() { // #14218
+        const char code[] = "int c[1]{}, b;";
+        ASSERT_EQUALS("int c [ 1 ] { } ; int b ;", tokenizeAndStringify(code));
+    }
+
     void bitfields1() {
         const char code1[] = "struct A { bool x : 1; };";
-        ASSERT_EQUALS("struct A { bool x ; } ;", tokenizeAndStringify(code1,false));
+        ASSERT_EQUALS("struct A { bool x ; } ;", tokenizeAndStringify(code1));
 
         const char code2[] = "struct A { char x : 3; };";
-        ASSERT_EQUALS("struct A { char x ; } ;", tokenizeAndStringify(code2,false));
+        ASSERT_EQUALS("struct A { char x ; } ;", tokenizeAndStringify(code2));
 
         const char code3[] = "struct A { short x : 3; };";
-        ASSERT_EQUALS("struct A { short x ; } ;", tokenizeAndStringify(code3,false));
+        ASSERT_EQUALS("struct A { short x ; } ;", tokenizeAndStringify(code3));
 
         const char code4[] = "struct A { int x : 3; };";
-        ASSERT_EQUALS("struct A { int x ; } ;", tokenizeAndStringify(code4,false));
+        ASSERT_EQUALS("struct A { int x ; } ;", tokenizeAndStringify(code4));
 
         const char code5[] = "struct A { long x : 3; };";
-        ASSERT_EQUALS("struct A { long x ; } ;", tokenizeAndStringify(code5,false));
+        ASSERT_EQUALS("struct A { long x ; } ;", tokenizeAndStringify(code5));
 
         const char code6[] = "struct A { __int8 x : 3; };";
-        ASSERT_EQUALS("struct A { char x ; } ;", tokenizeAndStringifyWindows(code6,false, true, Settings::Win32A));
+        ASSERT_EQUALS("struct A { char x ; } ;", tokenizeAndStringify(code6, settings_win32a));
 
         const char code7[] = "struct A { __int16 x : 3; };";
-        ASSERT_EQUALS("struct A { short x ; } ;", tokenizeAndStringifyWindows(code7,false, true, Settings::Win32A));
+        ASSERT_EQUALS("struct A { short x ; } ;", tokenizeAndStringify(code7,settings_win32a));
 
         const char code8[] = "struct A { __int32 x : 3; };";
-        ASSERT_EQUALS("struct A { int x ; } ;", tokenizeAndStringifyWindows(code8,false, true, Settings::Win32A));
+        ASSERT_EQUALS("struct A { int x ; } ;", tokenizeAndStringify(code8, settings_win32a));
 
         const char code9[] = "struct A { __int64 x : 3; };";
-        ASSERT_EQUALS("struct A { long long x ; } ;", tokenizeAndStringifyWindows(code9,false, true, Settings::Win32A));
+        ASSERT_EQUALS("struct A { long long x ; } ;", tokenizeAndStringify(code9, settings_win32a));
 
         const char code10[] = "struct A { unsigned char x : 3; };";
-        ASSERT_EQUALS("struct A { unsigned char x ; } ;", tokenizeAndStringify(code10,false));
+        ASSERT_EQUALS("struct A { unsigned char x ; } ;", tokenizeAndStringify(code10));
 
         const char code11[] = "struct A { unsigned short x : 3; };";
-        ASSERT_EQUALS("struct A { unsigned short x ; } ;", tokenizeAndStringify(code11,false));
+        ASSERT_EQUALS("struct A { unsigned short x ; } ;", tokenizeAndStringify(code11));
 
         const char code12[] = "struct A { unsigned int x : 3; };";
-        ASSERT_EQUALS("struct A { unsigned int x ; } ;", tokenizeAndStringify(code12,false));
+        ASSERT_EQUALS("struct A { unsigned int x ; } ;", tokenizeAndStringify(code12));
 
         const char code13[] = "struct A { unsigned long x : 3; };";
-        ASSERT_EQUALS("struct A { unsigned long x ; } ;", tokenizeAndStringify(code13,false));
+        ASSERT_EQUALS("struct A { unsigned long x ; } ;", tokenizeAndStringify(code13));
 
         const char code14[] = "struct A { unsigned __int8 x : 3; };";
-        ASSERT_EQUALS("struct A { unsigned char x ; } ;", tokenizeAndStringifyWindows(code14,false, true, Settings::Win32A));
+        ASSERT_EQUALS("struct A { unsigned char x ; } ;", tokenizeAndStringify(code14, settings_win32a));
 
         const char code15[] = "struct A { unsigned __int16 x : 3; };";
-        ASSERT_EQUALS("struct A { unsigned short x ; } ;", tokenizeAndStringifyWindows(code15,false, true, Settings::Win32A));
+        ASSERT_EQUALS("struct A { unsigned short x ; } ;", tokenizeAndStringify(code15, settings_win32a));
 
         const char code16[] = "struct A { unsigned __int32 x : 3; };";
-        ASSERT_EQUALS("struct A { unsigned int x ; } ;", tokenizeAndStringifyWindows(code16,false, true, Settings::Win32A));
+        ASSERT_EQUALS("struct A { unsigned int x ; } ;", tokenizeAndStringify(code16, settings_win32a));
 
         const char code17[] = "struct A { unsigned __int64 x : 3; };";
-        ASSERT_EQUALS("struct A { unsigned long long x ; } ;", tokenizeAndStringifyWindows(code17,false, true, Settings::Win32A));
+        ASSERT_EQUALS("struct A { unsigned long long x ; } ;", tokenizeAndStringify(code17, settings_win32a));
 
         const char code18[] = "struct A { signed char x : 3; };";
-        ASSERT_EQUALS("struct A { signed char x ; } ;", tokenizeAndStringify(code18,false));
+        ASSERT_EQUALS("struct A { signed char x ; } ;", tokenizeAndStringify(code18));
 
         const char code19[] = "struct A { signed short x : 3; };";
-        ASSERT_EQUALS("struct A { signed short x ; } ;", tokenizeAndStringify(code19,false));
+        ASSERT_EQUALS("struct A { signed short x ; } ;", tokenizeAndStringify(code19));
 
         const char code20[] = "struct A { signed int x : 3; };";
-        ASSERT_EQUALS("struct A { signed int x ; } ;", tokenizeAndStringify(code20,false));
+        ASSERT_EQUALS("struct A { signed int x ; } ;", tokenizeAndStringify(code20));
 
         const char code21[] = "struct A { signed long x : 3; };";
-        ASSERT_EQUALS("struct A { signed long x ; } ;", tokenizeAndStringifyWindows(code21,false));
+        ASSERT_EQUALS("struct A { signed long x ; } ;", tokenizeAndStringify(code21, settings_windows));
 
         const char code22[] = "struct A { signed __int8 x : 3; };";
-        ASSERT_EQUALS("struct A { signed char x ; } ;", tokenizeAndStringifyWindows(code22,false, true, Settings::Win32A));
+        ASSERT_EQUALS("struct A { signed char x ; } ;", tokenizeAndStringify(code22, settings_win32a));
 
         const char code23[] = "struct A { signed __int16 x : 3; };";
-        ASSERT_EQUALS("struct A { signed short x ; } ;", tokenizeAndStringifyWindows(code23,false, true, Settings::Win32A));
+        ASSERT_EQUALS("struct A { signed short x ; } ;", tokenizeAndStringify(code23, settings_win32a));
 
         const char code24[] = "struct A { signed __int32 x : 3; };";
-        ASSERT_EQUALS("struct A { signed int x ; } ;", tokenizeAndStringifyWindows(code24,false, true, Settings::Win32A));
+        ASSERT_EQUALS("struct A { signed int x ; } ;", tokenizeAndStringify(code24, settings_win32a));
 
         const char code25[] = "struct A { signed __int64 x : 3; };";
-        ASSERT_EQUALS("struct A { signed long long x ; } ;", tokenizeAndStringifyWindows(code25,false, true, Settings::Win32A));
+        ASSERT_EQUALS("struct A { signed long long x ; } ;", tokenizeAndStringify(code25, settings_win32a));
     }
 
     void bitfields2() {
         const char code1[] = "struct A { public: int x : 3; };";
-        ASSERT_EQUALS("struct A { public: int x ; } ;", tokenizeAndStringify(code1,false));
+        ASSERT_EQUALS("struct A { public: int x ; } ;", tokenizeAndStringify(code1));
 
         const char code2[] = "struct A { public: unsigned long x : 3; };";
-        ASSERT_EQUALS("struct A { public: unsigned long x ; } ;", tokenizeAndStringify(code2,false));
+        ASSERT_EQUALS("struct A { public: unsigned long x ; } ;", tokenizeAndStringify(code2));
 
         const char code3[] = "struct A { protected: int x : 3; };";
-        ASSERT_EQUALS("struct A { protected: int x ; } ;", tokenizeAndStringify(code3,false));
+        ASSERT_EQUALS("struct A { protected: int x ; } ;", tokenizeAndStringify(code3));
 
         const char code4[] = "struct A { protected: unsigned long x : 3; };";
-        ASSERT_EQUALS("struct A { protected: unsigned long x ; } ;", tokenizeAndStringify(code4,false));
+        ASSERT_EQUALS("struct A { protected: unsigned long x ; } ;", tokenizeAndStringify(code4));
 
         const char code5[] = "struct A { private: int x : 3; };";
-        ASSERT_EQUALS("struct A { private: int x ; } ;", tokenizeAndStringify(code5,false));
+        ASSERT_EQUALS("struct A { private: int x ; } ;", tokenizeAndStringify(code5));
 
         const char code6[] = "struct A { private: unsigned long x : 3; };";
-        ASSERT_EQUALS("struct A { private: unsigned long x ; } ;", tokenizeAndStringify(code6,false));
+        ASSERT_EQUALS("struct A { private: unsigned long x ; } ;", tokenizeAndStringify(code6));
     }
 
     void bitfields3() {
         const char code1[] = "struct A { const int x : 3; };";
-        ASSERT_EQUALS("struct A { const int x ; } ;", tokenizeAndStringify(code1,false));
+        ASSERT_EQUALS("struct A { const int x ; } ;", tokenizeAndStringify(code1));
 
         const char code2[] = "struct A { const unsigned long x : 3; };";
-        ASSERT_EQUALS("struct A { const unsigned long x ; } ;", tokenizeAndStringify(code2,false));
+        ASSERT_EQUALS("struct A { const unsigned long x ; } ;", tokenizeAndStringify(code2));
 
         const char code3[] = "struct A { public: const int x : 3; };";
-        ASSERT_EQUALS("struct A { public: const int x ; } ;", tokenizeAndStringify(code3,false));
+        ASSERT_EQUALS("struct A { public: const int x ; } ;", tokenizeAndStringify(code3));
 
         const char code4[] = "struct A { public: const unsigned long x : 3; };";
-        ASSERT_EQUALS("struct A { public: const unsigned long x ; } ;", tokenizeAndStringify(code4,false));
+        ASSERT_EQUALS("struct A { public: const unsigned long x ; } ;", tokenizeAndStringify(code4));
     }
 
     void bitfields4() { // ticket #1956
         const char code1[] = "struct A { CHAR x : 3; };";
-        ASSERT_EQUALS("struct A { CHAR x ; } ;", tokenizeAndStringify(code1,false));
+        ASSERT_EQUALS("struct A { CHAR x ; } ;", tokenizeAndStringify(code1));
 
         const char code2[] = "struct A { UCHAR x : 3; };";
-        ASSERT_EQUALS("struct A { UCHAR x ; } ;", tokenizeAndStringify(code2,false));
+        ASSERT_EQUALS("struct A { UCHAR x ; } ;", tokenizeAndStringify(code2));
 
         const char code3[] = "struct A { BYTE x : 3; };";
-        ASSERT_EQUALS("struct A { BYTE x ; } ;", tokenizeAndStringify(code3,false));
+        ASSERT_EQUALS("struct A { BYTE x ; } ;", tokenizeAndStringify(code3));
 
         const char code4[] = "struct A { WORD x : 3; };";
-        ASSERT_EQUALS("struct A { WORD x ; } ;", tokenizeAndStringify(code4,false));
+        ASSERT_EQUALS("struct A { WORD x ; } ;", tokenizeAndStringify(code4));
 
         const char code5[] = "struct A { DWORD x : 3; };";
-        ASSERT_EQUALS("struct A { DWORD x ; } ;", tokenizeAndStringify(code5,false));
+        ASSERT_EQUALS("struct A { DWORD x ; } ;", tokenizeAndStringify(code5));
 
         const char code6[] = "struct A { LONG x : 3; };";
-        ASSERT_EQUALS("struct A { LONG x ; } ;", tokenizeAndStringify(code6,false));
+        ASSERT_EQUALS("struct A { LONG x ; } ;", tokenizeAndStringify(code6));
 
         const char code7[] = "struct A { UINT8 x : 3; };";
-        ASSERT_EQUALS("struct A { UINT8 x ; } ;", tokenizeAndStringify(code7,false));
+        ASSERT_EQUALS("struct A { UINT8 x ; } ;", tokenizeAndStringify(code7));
 
         const char code8[] = "struct A { UINT16 x : 3; };";
-        ASSERT_EQUALS("struct A { UINT16 x ; } ;", tokenizeAndStringify(code8,false));
+        ASSERT_EQUALS("struct A { UINT16 x ; } ;", tokenizeAndStringify(code8));
 
         const char code9[] = "struct A { UINT32 x : 3; };";
-        ASSERT_EQUALS("struct A { UINT32 x ; } ;", tokenizeAndStringify(code9,false));
+        ASSERT_EQUALS("struct A { UINT32 x ; } ;", tokenizeAndStringify(code9));
 
         const char code10[] = "struct A { UINT64 x : 3; };";
-        ASSERT_EQUALS("struct A { UINT64 x ; } ;", tokenizeAndStringify(code10,false));
+        ASSERT_EQUALS("struct A { UINT64 x ; } ;", tokenizeAndStringify(code10));
     }
 
     void bitfields5() { // ticket #1956
         const char code1[] = "struct RGB { unsigned int r : 3, g : 3, b : 2; };";
-        ASSERT_EQUALS("struct RGB { unsigned int r ; unsigned int g ; unsigned int b ; } ;", tokenizeAndStringify(code1,false));
+        ASSERT_EQUALS("struct RGB { unsigned int r ; unsigned int g ; unsigned int b ; } ;", tokenizeAndStringify(code1));
 
         const char code2[] = "struct A { int a : 3; int : 3; int c : 3; };";
-        ASSERT_EQUALS("struct A { int a ; int c ; } ;", tokenizeAndStringify(code2,false));
+        ASSERT_EQUALS("struct A { int a ; int anonymous@0 ; int c ; } ;", tokenizeAndStringify(code2));
 
         const char code3[] = "struct A { virtual void f() {} int f1 : 1; };";
-        ASSERT_EQUALS("struct A { virtual void f ( ) { } int f1 ; } ;", tokenizeAndStringify(code3,false));
+        ASSERT_EQUALS("struct A { virtual void f ( ) { } int f1 ; } ;", tokenizeAndStringify(code3));
     }
 
     void bitfields6() { // ticket #2595
         const char code1[] = "struct A { bool b : true; };";
-        ASSERT_EQUALS("struct A { bool b ; } ;", tokenizeAndStringify(code1,false));
+        ASSERT_EQUALS("struct A { bool b ; } ;", tokenizeAndStringify(code1));
 
         const char code2[] = "struct A { bool b : true, c : true; };";
-        ASSERT_EQUALS("struct A { bool b ; bool c ; } ;", tokenizeAndStringify(code2,false));
+        ASSERT_EQUALS("struct A { bool b ; bool c ; } ;", tokenizeAndStringify(code2));
 
         const char code3[] = "struct A { bool : true; };";
-        ASSERT_EQUALS("struct A { } ;", tokenizeAndStringify(code3,false));
-
-        const char code4[] = "void f(int a) { switch (a) { case b: break; } }";
-        ASSERT_EQUALS("void f ( int a ) { switch ( a ) { case b : ; break ; } }", tokenizeAndStringify(code4,true));
-
-        const char code5[] = "void f(int a) { switch (a) { default: break; } }";
-        ASSERT_EQUALS("void f ( int a ) { switch ( a ) { default : ; break ; } }", tokenizeAndStringify(code5,true));
+        ASSERT_EQUALS("struct A { bool anonymous@0 ; } ;", tokenizeAndStringify(code3));
     }
 
     void bitfields7() { // ticket #1987
@@ -5736,8 +4963,8 @@ class TestTokenizer : public TestFixture {
         const char expected[] = "struct Descriptor { "
                                 "unsigned int element_size ; "
                                 "} ;";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code,false));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void bitfields8() {
@@ -5751,8 +4978,8 @@ class TestTokenizer : public TestFixture {
                                 "{ "
                                 "int f ( ) ; "
                                 "} ;";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code,false));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void bitfields9() { // ticket #2706
@@ -5763,8 +4990,8 @@ class TestTokenizer : public TestFixture {
                             "        ;\n"
                             "    }\n"
                             "};";
-        tokenizeAndStringify(code,false);
-        ASSERT_EQUALS("", errout.str());
+        (void)tokenizeAndStringify(code);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void bitfields10() { // ticket #2737
@@ -5772,20 +4999,16 @@ class TestTokenizer : public TestFixture {
                             "MACRO "
                             "default: { }"
                             ";";
-        ASSERT_EQUALS("{ } MACRO default : { } ;", tokenizeAndStringify(code,false));
+        ASSERT_EQUALS("{ } MACRO default : { } ;", tokenizeAndStringify(code));
     }
 
     void bitfields12() { // ticket #3485 (segmentation fault)
         const char code[] = "{a:1;};\n";
-        ASSERT_EQUALS("{ } ;", tokenizeAndStringify(code,false));
+        ASSERT_EQUALS("{ a anonymous@0 ; } ;", tokenizeAndStringify(code));
     }
 
     void bitfields13() { // ticket #3502 (segmentation fault)
-        ASSERT_EQUALS("x y ;", tokenizeAndStringify("struct{x y:};\n",false));
-    }
-
-    void bitfields14() { // #4561 - crash for 'signals:'
-        ASSERT_EQUALS("class x { signals : } ;", tokenizeAndStringify("class x { signals: };\n",false));
+        ASSERT_NO_THROW(tokenizeAndStringify("struct{x y:};\n"));
     }
 
     void bitfields15() { // #7747 - enum Foo {A,B}:4;
@@ -5801,107 +5024,200 @@ class TestTokenizer : public TestFixture {
                       tokenizeAndStringify("struct AB {\n"
                                            "  enum Foo {A,B} foo : 4;\n"
                                            "};"));
+
+        ASSERT_EQUALS("struct S {\n" // #14324
+                      "enum E : int { E0 , E1 } ; enum E e ;\n"
+                      "} ;",
+                      tokenizeAndStringify("struct S {\n"
+                                           "    enum E : int { E0, E1 } e : 2;\n"
+                                           "};\n"));
+
+        ASSERT_EQUALS("struct S {\n"
+                      "enum class E : std :: uint8_t { E0 , E1 } ; enum E e ;\n"
+                      "} ;",
+                      tokenizeAndStringify("struct S {\n"
+                                           "    enum class E : std::uint8_t { E0, E1 } e : 2;\n"
+                                           "};\n"));
     }
 
     void bitfields16() {
         const char code[] = "struct A { unsigned int x : 1; };";
 
-        errout.str("");
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT(tokenizer.tokenize(code));
         const Token *x = Token::findsimplematch(tokenizer.tokens(), "x");
         ASSERT_EQUALS(1, x->bits());
     }
 
+    void bitfields17() {
+        const char code[] = "struct S {\n" // #13722
+                            "    volatile uint32_t a : 10;\n"
+                            "    volatile uint32_t   : 6;\n"
+                            "    volatile uint32_t b : 10;\n"
+                            "    volatile uint32_t   : 6;\n"
+                            "};\n";
+        const char expected[] = "struct S {\n"
+                                "volatile uint32_t a ;\n"
+                                "volatile uint32_t anonymous@0 ;\n"
+                                "volatile uint32_t b ;\n"
+                                "volatile uint32_t anonymous@1 ;\n"
+                                "} ;";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+
+        const char code2[] = "struct S {\n"
+                             "    const volatile uint32_t a : 10;\n"
+                             "    const volatile uint32_t   : 6;\n"
+                             "};\n";
+        const char expected2[] = "struct S {\n"
+                                 "const volatile uint32_t a ;\n"
+                                 "const volatile uint32_t anonymous@0 ;\n"
+                                 "} ;";
+        ASSERT_EQUALS(expected2, tokenizeAndStringify(code2));
+    }
+
+    void bitfields18() {
+        const char code[] = "struct S { unsigned int a : 100000; };";
+        (void) tokenizeAndStringify(code);
+        ASSERT_EQUALS("[test.cpp:1:29]: (warning) Bit-field size exceeds max number of bits 32767 [tooLargeBitField]\n", errout_str());
+    }
+
+    void bitfields19() {
+        const char code[] = "struct S { volatile std::uint32_t a : 10; };";
+        ASSERT_EQUALS("struct S { volatile std :: uint32_t a ; } ;", tokenizeAndStringify(code));
+    }
+
+    void bitfields20() {
+        const char code[] = "struct S { volatile ::uint32_t a : 10; };";
+        ASSERT_EQUALS("struct S { volatile :: uint32_t a ; } ;", tokenizeAndStringify(code));
+    }
+
+    void bitfields21() {
+        const char code[] = "struct S { uint32_t a : 1, b : 1; };";
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT(tokenizer.tokenize(code));
+        const Token *a = Token::findsimplematch(tokenizer.tokens(), "a");
+        ASSERT_EQUALS(1, a->bits());
+        const Token *b = Token::findsimplematch(tokenizer.tokens(), "b");
+        ASSERT_EQUALS(1, b->bits());
+    }
+
     void simplifyNamespaceStd() {
-        const char *code, *expected;
-
-        code = "map<foo, bar> m;"; // namespace std is not used
-        ASSERT_EQUALS("map < foo , bar > m ;", tokenizeAndStringify(code, false));
-
-        code = "using namespace std;\n"
-               "map<foo, bar> m;";
-        ASSERT_EQUALS("std :: map < foo , bar > m ;", tokenizeAndStringify(code, false));
-
-        code = "using namespace std;\n"
-               "string s;";
-        ASSERT_EQUALS("std :: string s ;", tokenizeAndStringify(code, false));
-
-        code = "using namespace std;\n"
-               "void foo() {swap(a, b); }";
-        ASSERT_EQUALS("void foo ( ) { std :: swap ( a , b ) ; }", tokenizeAndStringify(code, false));
-
-        code = "using namespace std;\n"
-               "void search() {}";
-        ASSERT_EQUALS("void search ( ) { }", tokenizeAndStringify(code, false));
-
-        code = "using namespace std;\n"
-               "void search();\n"
-               "void dostuff() { search(); }";
-        ASSERT_EQUALS("void search ( ) ;\nvoid dostuff ( ) { search ( ) ; }", tokenizeAndStringify(code, false));
-
-        code = "using namespace std;\n"
-               "void foo() {map(a, b); }"; // That's obviously not std::map<>
-        ASSERT_EQUALS("void foo ( ) { map ( a , b ) ; }", tokenizeAndStringify(code, false));
-
-        code = "using namespace std;\n"
-               "string<wchar_t> s;"; // That's obviously not std::string
-        ASSERT_EQUALS("string < wchar_t > s ;", tokenizeAndStringify(code, false));
-
-        code = "using namespace std;\n"
-               "swap s;"; // That's obviously not std::swap
-        ASSERT_EQUALS("swap s ;", tokenizeAndStringify(code, false));
-
-        code = "using namespace std;\n"
-               "std::string s;";
-        ASSERT_EQUALS("std :: string s ;", tokenizeAndStringify(code, false));
-
-        code = "using namespace std;\n"
-               "tr1::function <void(int)> f;";
-        ASSERT_EQUALS("tr1 :: function < void ( int ) > f ;", tokenizeAndStringify(code, false, true, Settings::Native, "test.cpp", false));
-        ASSERT_EQUALS("std :: function < void ( int ) > f ;", tokenizeAndStringify(code, false, true, Settings::Native, "test.cpp", true));
-
-        code = "std::tr1::function <void(int)> f;";
-        ASSERT_EQUALS("std :: tr1 :: function < void ( int ) > f ;", tokenizeAndStringify(code, false, true, Settings::Native, "test.cpp", false));
-        ASSERT_EQUALS("std :: function < void ( int ) > f ;", tokenizeAndStringify(code, false, true, Settings::Native, "test.cpp", true));
-
-        // #4042 (Do not add 'std ::' to variables)
-        code = "using namespace std;\n"
-               "const char * string = \"Hi\";";
-        ASSERT_EQUALS("const char * string ; string = \"Hi\" ;", tokenizeAndStringify(code, false));
-
-        code = "using namespace std;\n"
-               "string f(const char * string) {\n"
-               "    cout << string << endl;\n"
-               "    return string;\n"
-               "}";
-        expected = "std :: string f ( const char * string ) {\n"
-                   "std :: cout << string << std :: endl ;\n"
-                   "return string ;\n"
-                   "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, false));
-
-        code = "using namespace std;\n"
-               "try { }\n"
-               "catch(std::exception &exception) { }";
-        expected = "try { }\n"
-                   "catch ( std :: exception & exception ) { }";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, false));
-
-        // #5773 (Don't prepend 'std ::' to function definitions)
-        code = "using namespace std;\n"
-               "class C {\n"
-               "    void search() {}\n"
-               "    void search() const {}\n"
-               "    void search() THROW_MACRO {}\n"
-               "};";
-        expected = "class C {\n"
-                   "void search ( ) { }\n"
-                   "void search ( ) const { }\n"
-                   "void search ( ) { }\n"
-                   "} ;";
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, false));
+        const char *expected;
+
+        {
+            const char code[] = "map<foo, bar> m;"; // namespace std is not used
+            ASSERT_EQUALS("map < foo , bar > m ;", tokenizeAndStringify(code));
+        }
+
+        {
+            const char code[] = "using namespace std;\n"
+                                "map<foo, bar> m;";
+            ASSERT_EQUALS("std :: map < foo , bar > m ;", tokenizeAndStringify(code));
+        }
+
+        {
+            const char code[] = "using namespace std;\n"
+                                "string s;";
+            ASSERT_EQUALS("std :: string s ;", tokenizeAndStringify(code));
+        }
+
+        {
+            const char code[] = "using namespace std;\n"
+                                "void foo() {swap(a, b); }";
+            ASSERT_EQUALS("void foo ( ) { std :: swap ( a , b ) ; }", tokenizeAndStringify(code));
+        }
+
+        {
+            const char code[] = "using namespace std;\n"
+                                "void search() {}";
+            ASSERT_EQUALS("void search ( ) { }", tokenizeAndStringify(code));
+        }
+
+        {
+            const char code[] = "using namespace std;\n"
+                                "void search();\n"
+                                "void dostuff() { search(); }";
+            ASSERT_EQUALS("void search ( ) ;\nvoid dostuff ( ) { search ( ) ; }", tokenizeAndStringify(code));
+        }
+
+        {
+            const char code[] = "using namespace std;\n"
+                                "void foo() {map(a, b); }"; // That's obviously not std::map<>
+            ASSERT_EQUALS("void foo ( ) { map ( a , b ) ; }", tokenizeAndStringify(code));
+        }
+
+        {
+            const char code[] = "using namespace std;\n"
+                                "string<wchar_t> s;"; // That's obviously not std::string
+            TODO_ASSERT_EQUALS("string < wchar_t > s ;", "std :: string < wchar_t > s ;", tokenizeAndStringify(code));
+        }
+
+        {
+            const char code[] = "using namespace std;\n"
+                                "swap s;"; // That's obviously not std::swap
+            ASSERT_EQUALS("swap s ;", tokenizeAndStringify(code));
+        }
+
+        {
+            const char code[] = "using namespace std;\n"
+                                "std::string s;";
+            ASSERT_EQUALS("std :: string s ;", tokenizeAndStringify(code));
+        }
+
+        { // #4042 (Do not add 'std ::' to variables)
+            const char code[] = "using namespace std;\n"
+                                "const char * string = \"Hi\";";
+            ASSERT_EQUALS("const char * string ; string = \"Hi\" ;", tokenizeAndStringify(code));
+        }
+
+        {
+            const char code[] = "using namespace std;\n"
+                                "string f(const char * string) {\n"
+                                "    cout << string << endl;\n"
+                                "    return string;\n"
+                                "}";
+            expected = "std :: string f ( const char * string ) {\n"
+                       "std :: cout << string << std :: endl ;\n"
+                       "return string ;\n"
+                       "}";
+            TODO_ASSERT_EQUALS(expected,
+                               "std :: string f ( const char * string ) {\n"
+                               "cout << string << endl ;\n"
+                               "return string ;\n"
+                               "}",
+                               tokenizeAndStringify(code));
+            ASSERT_EQUALS(
+                "[test.cpp:3:5]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable cout [valueFlowBailoutIncompleteVar]\n",
+                errout_str());
+        }
+
+        {
+            const char code[] = "using namespace std;\n"
+                                "void f() {\n"
+                                "  try { }\n"
+                                "  catch(std::exception &exception) { }\n"
+                                "}";
+            expected = "void f ( ) {\n"
+                       "try { }\n"
+                       "catch ( std :: exception & exception ) { }\n"
+                       "}";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+        }
+
+        { // #5773 (Don't prepend 'std ::' to function definitions)
+            const char code[] = "using namespace std;\n"
+                                "class C {\n"
+                                "    void search() {}\n"
+                                "    void search() const {}\n"
+                                "    void search() THROW_MACRO {}\n"
+                                "};";
+            expected = "class C {\n"
+                       "void search ( ) { }\n"
+                       "void search ( ) const { }\n"
+                       "void search ( ) { }\n"
+                       "} ;";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+        }
 
         // Ticket #8091
         ASSERT_EQUALS("enum Anonymous0 { string } ;",
@@ -5929,299 +5245,207 @@ class TestTokenizer : public TestFixture {
         // Handle garbage enum code "well"
         ASSERT_EQUALS("enum E : int ; void foo ( ) { std :: string s ; }",
                       tokenizeAndStringify("using namespace std; enum E : int ; void foo ( ) { string s ; }"));
+
+        ASSERT_NO_THROW(tokenizeAndStringify("NS_BEGIN(IMAGEIO_2D_DICOM) using namespace std; NS_END")); // #11045
+
+        {
+            const char code[] = "using namespace std;\n"
+                                "void f(const unique_ptr<int>& p) {\n"
+                                "    if (!p)\n"
+                                "        throw runtime_error(\"abc\");\n"
+                                "}";
+            expected = "void f ( const std :: unique_ptr < int > & p ) {\n"
+                       "if ( ! p ) {\n"
+                       "throw std :: runtime_error ( \"abc\" ) ; }\n"
+                       "}";
+            TODO_ASSERT_EQUALS(expected,
+                               "void f ( const std :: unique_ptr < int > & p ) {\n"
+                               "if ( ! p ) {\n"
+                               "throw runtime_error ( \"abc\" ) ; }\n"
+                               "}",
+                               tokenizeAndStringify(code));
+        }
+
+        {
+            const char code[] = "using namespace std;\n" // #8454
+                                "void f() { string str = to_string(1); }\n";
+            expected = "void f ( ) { std :: string str ; str = std :: to_string ( 1 ) ; }";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+        }
+
+        {
+            const char code[] = "using namespace std;\n"
+                                "vector<int>&& f(vector<int>& v) {\n"
+                                "    v.push_back(1);\n"
+                                "    return move(v);\n"
+                                "}\n";
+            expected = "std :: vector < int > && f ( std :: vector < int > & v ) {\n"
+                       "v . push_back ( 1 ) ;\n"
+                       "return std :: move ( v ) ;\n"
+                       "}";
+            ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+        }
     }
 
     void microsoftMemory() {
         const char code1a[] = "void foo() { int a[10], b[10]; CopyMemory(a, b, sizeof(a)); }";
-        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; int b [ 10 ] ; memcpy ( a , b , sizeof ( a ) ) ; }", tokenizeAndStringify(code1a,false,true,Settings::Win32A));
+        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; int b [ 10 ] ; memcpy ( a , b , sizeof ( a ) ) ; }", tokenizeAndStringify(code1a,settings2_win32a));
 
         const char code1b[] = "void foo() { int a[10], b[10]; RtlCopyMemory(a, b, sizeof(a)); }";
-        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; int b [ 10 ] ; memcpy ( a , b , sizeof ( a ) ) ; }", tokenizeAndStringify(code1b,false,true,Settings::Win32A));
+        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; int b [ 10 ] ; memcpy ( a , b , sizeof ( a ) ) ; }", tokenizeAndStringify(code1b,settings2_win32a));
 
         const char code1c[] = "void foo() { int a[10], b[10]; RtlCopyBytes(a, b, sizeof(a)); }";
-        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; int b [ 10 ] ; memcpy ( a , b , sizeof ( a ) ) ; }", tokenizeAndStringify(code1c,false,true,Settings::Win32A));
+        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; int b [ 10 ] ; memcpy ( a , b , sizeof ( a ) ) ; }", tokenizeAndStringify(code1c,settings2_win32a));
 
         const char code2a[] = "void foo() { int a[10]; FillMemory(a, sizeof(a), 255); }";
-        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 255 , sizeof ( a ) ) ; }", tokenizeAndStringify(code2a,false,true,Settings::Win32A));
+        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 255 , sizeof ( a ) ) ; }", tokenizeAndStringify(code2a,settings2_win32a));
         const char code2b[] = "void foo() { int a[10]; RtlFillMemory(a, sizeof(a), 255); }";
-        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 255 , sizeof ( a ) ) ; }", tokenizeAndStringify(code2b,false,true,Settings::Win32A));
+        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 255 , sizeof ( a ) ) ; }", tokenizeAndStringify(code2b,settings2_win32a));
         const char code2c[] = "void foo() { int a[10]; RtlFillBytes(a, sizeof(a), 255); }";
-        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 255 , sizeof ( a ) ) ; }", tokenizeAndStringify(code2c,false,true,Settings::Win32A));
+        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 255 , sizeof ( a ) ) ; }", tokenizeAndStringify(code2c,settings2_win32a));
 
         const char code3a[] = "void foo() { int a[10], b[10]; MoveMemory(a, b, sizeof(a)); }";
-        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; int b [ 10 ] ; memmove ( a , b , sizeof ( a ) ) ; }", tokenizeAndStringify(code3a,false,true,Settings::Win32A));
+        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; int b [ 10 ] ; memmove ( a , b , sizeof ( a ) ) ; }", tokenizeAndStringify(code3a,settings2_win32a));
         const char code3b[] = "void foo() { int a[10], b[10]; RtlMoveMemory(a, b, sizeof(a)); }";
-        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; int b [ 10 ] ; memmove ( a , b , sizeof ( a ) ) ; }", tokenizeAndStringify(code3b,false,true,Settings::Win32A));
+        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; int b [ 10 ] ; memmove ( a , b , sizeof ( a ) ) ; }", tokenizeAndStringify(code3b,settings2_win32a));
 
         const char code4a[] = "void foo() { int a[10]; ZeroMemory(a, sizeof(a)); }";
-        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 0 , sizeof ( a ) ) ; }", tokenizeAndStringify(code4a,false,true,Settings::Win32A));
+        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 0 , sizeof ( a ) ) ; }", tokenizeAndStringify(code4a,settings2_win32a));
         const char code4b[] = "void foo() { int a[10]; RtlZeroMemory(a, sizeof(a)); }";
-        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 0 , sizeof ( a ) ) ; }", tokenizeAndStringify(code4b,false,true,Settings::Win32A));
+        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 0 , sizeof ( a ) ) ; }", tokenizeAndStringify(code4b,settings2_win32a));
         const char code4c[] = "void foo() { int a[10]; RtlZeroBytes(a, sizeof(a)); }";
-        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 0 , sizeof ( a ) ) ; }", tokenizeAndStringify(code4c,false,true,Settings::Win32A));
+        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 0 , sizeof ( a ) ) ; }", tokenizeAndStringify(code4c,settings2_win32a));
         const char code4d[] = "void foo() { int a[10]; RtlSecureZeroMemory(a, sizeof(a)); }";
-        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 0 , sizeof ( a ) ) ; }", tokenizeAndStringify(code4d,false,true,Settings::Win32A));
+        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; memset ( a , 0 , sizeof ( a ) ) ; }", tokenizeAndStringify(code4d,settings2_win32a));
 
         const char code5[] = "void foo() { int a[10], b[10]; RtlCompareMemory(a, b, sizeof(a)); }";
-        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; int b [ 10 ] ; memcmp ( a , b , sizeof ( a ) ) ; }", tokenizeAndStringify(code5,false,true,Settings::Win32A));
+        ASSERT_EQUALS("void foo ( ) { int a [ 10 ] ; int b [ 10 ] ; memcmp ( a , b , sizeof ( a ) ) ; }", tokenizeAndStringify(code5,settings2_win32a));
 
         const char code6[] = "void foo() { ZeroMemory(f(1, g(a, b)), h(i, j(0, 1))); }";
-        ASSERT_EQUALS("void foo ( ) { memset ( f ( 1 , g ( a , b ) ) , 0 , h ( i , j ( 0 , 1 ) ) ) ; }", tokenizeAndStringify(code6,false,true,Settings::Win32A));
+        ASSERT_EQUALS("void foo ( ) { memset ( f ( 1 , g ( a , b ) ) , 0 , h ( i , j ( 0 , 1 ) ) ) ; }", tokenizeAndStringify(code6,settings2_win32a));
 
         const char code7[] = "void foo() { FillMemory(f(1, g(a, b)), h(i, j(0, 1)), 255); }";
-        ASSERT_EQUALS("void foo ( ) { memset ( f ( 1 , g ( a , b ) ) , 255 , h ( i , j ( 0 , 1 ) ) ) ; }", tokenizeAndStringify(code7,false,true,Settings::Win32A));
+        ASSERT_EQUALS("void foo ( ) { memset ( f ( 1 , g ( a , b ) ) , 255 , h ( i , j ( 0 , 1 ) ) ) ; }", tokenizeAndStringify(code7,settings2_win32a));
     }
 
     void microsoftString() {
         const char code1a[] = "void foo() { _tprintf (_T(\"test\") _T(\"1\")); }";
-        ASSERT_EQUALS("void foo ( ) { printf ( \"test1\" ) ; }", tokenizeAndStringify(code1a, false, true, Settings::Win32A));
+        ASSERT_EQUALS("void foo ( ) { printf ( \"test1\" ) ; }", tokenizeAndStringify(code1a, settings2_win32a));
         const char code1b[] = "void foo() { _tprintf (_TEXT(\"test\") _TEXT(\"2\")); }";
-        ASSERT_EQUALS("void foo ( ) { printf ( \"test2\" ) ; }", tokenizeAndStringify(code1b, false, true, Settings::Win32A));
+        ASSERT_EQUALS("void foo ( ) { printf ( \"test2\" ) ; }", tokenizeAndStringify(code1b, settings2_win32a));
         const char code1c[] = "void foo() { _tprintf (TEXT(\"test\") TEXT(\"3\")); }";
-        ASSERT_EQUALS("void foo ( ) { printf ( \"test3\" ) ; }", tokenizeAndStringify(code1c, false, true, Settings::Win32A));
+        ASSERT_EQUALS("void foo ( ) { printf ( \"test3\" ) ; }", tokenizeAndStringify(code1c, settings2_win32a));
 
         const char code2a[] = "void foo() { _tprintf (_T(\"test\") _T(\"1\")); }";
-        ASSERT_EQUALS("void foo ( ) { wprintf ( L\"test1\" ) ; }", tokenizeAndStringify(code2a, false, true, Settings::Win32W));
-        ASSERT_EQUALS("void foo ( ) { wprintf ( L\"test1\" ) ; }", tokenizeAndStringify(code2a, false, true, Settings::Win64));
+        ASSERT_EQUALS("void foo ( ) { wprintf ( L\"test1\" ) ; }", tokenizeAndStringify(code2a, settings2_win32w));
+        ASSERT_EQUALS("void foo ( ) { wprintf ( L\"test1\" ) ; }", tokenizeAndStringify(code2a, settings2_win64));
         const char code2b[] = "void foo() { _tprintf (_TEXT(\"test\") _TEXT(\"2\")); }";
-        ASSERT_EQUALS("void foo ( ) { wprintf ( L\"test2\" ) ; }", tokenizeAndStringify(code2b, false, true, Settings::Win32W));
-        ASSERT_EQUALS("void foo ( ) { wprintf ( L\"test2\" ) ; }", tokenizeAndStringify(code2b, false, true, Settings::Win64));
+        ASSERT_EQUALS("void foo ( ) { wprintf ( L\"test2\" ) ; }", tokenizeAndStringify(code2b, settings2_win32w));
+        ASSERT_EQUALS("void foo ( ) { wprintf ( L\"test2\" ) ; }", tokenizeAndStringify(code2b, settings2_win64));
         const char code2c[] = "void foo() { _tprintf (TEXT(\"test\") TEXT(\"3\")); }";
-        ASSERT_EQUALS("void foo ( ) { wprintf ( L\"test3\" ) ; }", tokenizeAndStringify(code2c, false, true, Settings::Win32W));
-        ASSERT_EQUALS("void foo ( ) { wprintf ( L\"test3\" ) ; }", tokenizeAndStringify(code2c, false, true, Settings::Win64));
+        ASSERT_EQUALS("void foo ( ) { wprintf ( L\"test3\" ) ; }", tokenizeAndStringify(code2c, settings2_win32w));
+        ASSERT_EQUALS("void foo ( ) { wprintf ( L\"test3\" ) ; }", tokenizeAndStringify(code2c, settings2_win64));
     }
 
     void borland() {
         // __closure
-        ASSERT_EQUALS("int * a ;",
-                      tokenizeAndStringify("int (__closure *a)();", false, true, Settings::Win32A));
+        ASSERT_EQUALS("int ( * a ) ( ) ;",  // TODO VarId
+                      tokenizeAndStringify("int (__closure *a)();", settings2_win32a));
 
         // __property
         ASSERT_EQUALS("class Fred { ; __property ; } ;",
-                      tokenizeAndStringify("class Fred { __property int x = { } };", false, true, Settings::Win32A));
-    }
-
-    void Qt() {
-        const char code1[] = "class Counter : public QObject "
-                             "{ "
-                             "    Q_OBJECT "
-                             "public: "
-                             "    Counter() { m_value = 0; } "
-                             "    int value() const { return m_value; } "
-                             "public slots: "
-                             "    void setValue(int value); "
-                             "signals: "
-                             "    void valueChanged(int newValue); "
-                             "private: "
-                             "    int m_value; "
-                             "}; "
-                             "void Counter::setValue(int value) "
-                             "{ "
-                             "    if (value != m_value) { "
-                             "        m_value = value; "
-                             "        emit valueChanged(value); "
-                             "    } "
-                             "}";
-
-        const char result1 [] = "class Counter : public QObject "
-                                "{ "
-                                "public: "
-                                "Counter ( ) { m_value = 0 ; } "
-                                "int value ( ) const { return m_value ; } "
-                                "public: "
-                                "void setValue ( int value ) ; "
-                                "protected: "
-                                "void valueChanged ( int newValue ) ; "
-                                "private: "
-                                "int m_value ; "
-                                "} ; "
-                                "void Counter :: setValue ( int value ) "
-                                "{ "
-                                "if ( value != m_value ) { "
-                                "m_value = value ; "
-                                "valueChanged ( value ) ; "
-                                "} "
-                                "}";
-
-        ASSERT_EQUALS(result1, tokenizeAndStringify(code1,false));
-
-        const char code2[] = "class Counter : public QObject "
-                             "{ "
-                             "    Q_OBJECT "
-                             "public: "
-                             "    Counter() { m_value = 0; } "
-                             "    int value() const { return m_value; } "
-                             "public Q_SLOTS: "
-                             "    void setValue(int value); "
-                             "Q_SIGNALS: "
-                             "    void valueChanged(int newValue); "
-                             "private: "
-                             "    int m_value; "
-                             "};"
-                             "void Counter::setValue(int value) "
-                             "{ "
-                             "    if (value != m_value) { "
-                             "        m_value = value; "
-                             "        emit valueChanged(value); "
-                             "    } "
-                             "}";
-
-        const char result2 [] = "class Counter : public QObject "
-                                "{ "
-                                "public: "
-                                "Counter ( ) { m_value = 0 ; } "
-                                "int value ( ) const { return m_value ; } "
-                                "public: "
-                                "void setValue ( int value ) ; "
-                                "protected: "
-                                "void valueChanged ( int newValue ) ; "
-                                "private: "
-                                "int m_value ; "
-                                "} ; "
-                                "void Counter :: setValue ( int value ) "
-                                "{ "
-                                "if ( value != m_value ) { "
-                                "m_value = value ; "
-                                "valueChanged ( value ) ; "
-                                "} "
-                                "}";
-
-        ASSERT_EQUALS(result2, tokenizeAndStringify(code2,false));
-
-        const char code3[] = "class MyObject : public QObject {"
-                             "    MyObject() {}"
-                             "    ~MyObject() {}"
-                             "    public slots:"
-                             "    signals:"
-                             "        void test() {}"
-                             "};";
-        const char result3 [] = "class MyObject : public QObject { "
-                                "MyObject ( ) { } "
-                                "~ MyObject ( ) { } "
-                                "public: "
-                                "protected: "
-                                "void test ( ) { } "
-                                "} ;";
-
-        ASSERT_EQUALS(result3, tokenizeAndStringify(code3,false));
-        ASSERT_EQUALS("", errout.str());
-
-        const char code4[] = "class MyObject : public QObject {"
-                             "    Q_OBJECT "
-                             "public slots:"
-                             "};";
-        const char result4[] = "class MyObject : public QObject { "
-                               "public: "
-                               "} ;";
-
-        ASSERT_EQUALS(result4, tokenizeAndStringify(code4,false));
+                      tokenizeAndStringify("class Fred { __property int x = { } };", settings2_win32a));
     }
 
     void simplifySQL() {
         // Oracle PRO*C extensions for inline SQL. Just replace the SQL with "asm()" to fix wrong error messages
         // ticket: #1959
-        ASSERT_EQUALS("asm ( \"\"__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL SELECT A FROM B\"\" ) ;", tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL SELECT A FROM B;",false));
-        ASSERT_THROW(tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL",false), InternalError);
+        ASSERT_EQUALS("asm ( \"\"__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL SELECT A FROM B\"\" ) ;", tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL SELECT A FROM B;"));
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL"), SYNTAX);
 
         ASSERT_EQUALS("asm ( \"\"__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL EXECUTE BEGIN Proc1 ( A ) ; END ; END - __CPPCHECK_EMBEDDED_SQL_EXEC__\"\" ) ; asm ( \"\"__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL COMMIT\"\" ) ;",
-                      tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL EXECUTE BEGIN Proc1(A); END; END-__CPPCHECK_EMBEDDED_SQL_EXEC__; __CPPCHECK_EMBEDDED_SQL_EXEC__ SQL COMMIT;",false));
+                      tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL EXECUTE BEGIN Proc1(A); END; END-__CPPCHECK_EMBEDDED_SQL_EXEC__; __CPPCHECK_EMBEDDED_SQL_EXEC__ SQL COMMIT;"));
         ASSERT_EQUALS("asm ( \"\"__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL UPDATE A SET B = C\"\" ) ; asm ( \"\"__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL COMMIT\"\" ) ;",
-                      tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL UPDATE A SET B = C; __CPPCHECK_EMBEDDED_SQL_EXEC__ SQL COMMIT;",false));
+                      tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL UPDATE A SET B = C; __CPPCHECK_EMBEDDED_SQL_EXEC__ SQL COMMIT;"));
         ASSERT_EQUALS("asm ( \"\"__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL COMMIT\"\" ) ; asm ( \"\"__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL EXECUTE BEGIN Proc1 ( A ) ; END ; END - __CPPCHECK_EMBEDDED_SQL_EXEC__\"\" ) ;",
-                      tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL COMMIT; __CPPCHECK_EMBEDDED_SQL_EXEC__ SQL EXECUTE BEGIN Proc1(A); END; END-__CPPCHECK_EMBEDDED_SQL_EXEC__;",false));
+                      tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL COMMIT; __CPPCHECK_EMBEDDED_SQL_EXEC__ SQL EXECUTE BEGIN Proc1(A); END; END-__CPPCHECK_EMBEDDED_SQL_EXEC__;"));
 
-        ASSERT_THROW(tokenizeAndStringify("int f(){ __CPPCHECK_EMBEDDED_SQL_EXEC__ SQL } int a;",false), InternalError);
-        ASSERT_THROW(tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL int f(){",false), InternalError);
-        ASSERT_THROW(tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL END-__CPPCHECK_EMBEDDED_SQL_EXEC__ int a;",false), InternalError);
-        ASSERT_NO_THROW(tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL UPDATE A SET B = :&b->b1, C = :c::c1;",false));
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("int f(){ __CPPCHECK_EMBEDDED_SQL_EXEC__ SQL } int a;"), SYNTAX);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL int f(){"), SYNTAX);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL END-__CPPCHECK_EMBEDDED_SQL_EXEC__ int a;"), SYNTAX);
+        ASSERT_NO_THROW(tokenizeAndStringify("__CPPCHECK_EMBEDDED_SQL_EXEC__ SQL UPDATE A SET B = :&b->b1, C = :c::c1;"));
     }
 
     void simplifyCAlternativeTokens() {
-        ASSERT_EQUALS("void f ( ) { if ( a && b ) { ; } }", tokenizeAndStringify("void f() { if (a and b); }", false, true, Settings::Native, "test.c"));
-        ASSERT_EQUALS("void f ( ) { if ( a && b ) { ; } }", tokenizeAndStringify("void f() { if (a and b); }", false, true, Settings::Native, "test.cpp"));
-        ASSERT_EQUALS("void f ( ) { if ( a || b ) { ; } }", tokenizeAndStringify("void f() { if (a or b); }", false, true, Settings::Native, "test.c"));
-        ASSERT_EQUALS("void f ( ) { if ( a || b ) { ; } }", tokenizeAndStringify("void f() { if (a or b); }", false, true, Settings::Native, "test.cpp"));
-        ASSERT_EQUALS("void f ( ) { if ( a & b ) { ; } }", tokenizeAndStringify("void f() { if (a bitand b); }", false, true, Settings::Native, "test.c"));
-        ASSERT_EQUALS("void f ( ) { if ( a & b ) { ; } }", tokenizeAndStringify("void f() { if (a bitand b); }", false, true, Settings::Native, "test.cpp"));
-        ASSERT_EQUALS("void f ( ) { if ( a | b ) { ; } }", tokenizeAndStringify("void f() { if (a bitor b); }", false, true, Settings::Native, "test.c"));
-        ASSERT_EQUALS("void f ( ) { if ( a | b ) { ; } }", tokenizeAndStringify("void f() { if (a bitor b); }", false, true, Settings::Native, "test.cpp"));
-        ASSERT_EQUALS("void f ( ) { if ( a ^ b ) { ; } }", tokenizeAndStringify("void f() { if (a xor b); }", false, true, Settings::Native, "test.c"));
-        ASSERT_EQUALS("void f ( ) { if ( a ^ b ) { ; } }", tokenizeAndStringify("void f() { if (a xor b); }", false, true, Settings::Native, "test.cpp"));
-        ASSERT_EQUALS("void f ( ) { if ( ~ b ) { ; } }", tokenizeAndStringify("void f() { if (compl b); }", false, true, Settings::Native, "test.c"));
-        ASSERT_EQUALS("void f ( ) { if ( ~ b ) { ; } }", tokenizeAndStringify("void f() { if (compl b); }", false, true, Settings::Native, "test.cpp"));
-        ASSERT_EQUALS("void f ( ) { if ( ! b ) { ; } }", tokenizeAndStringify("void f() { if (not b); }", false, true, Settings::Native, "test.c"));
-        ASSERT_EQUALS("void f ( ) { if ( ! b ) { ; } }", tokenizeAndStringify("void f() { if (not b); }", false, true, Settings::Native, "test.cpp"));
-        ASSERT_EQUALS("void f ( ) { if ( a != b ) { ; } }", tokenizeAndStringify("void f() { if (a not_eq b); }", false, true, Settings::Native, "test.c"));
-        ASSERT_EQUALS("void f ( ) { if ( a != b ) { ; } }", tokenizeAndStringify("void f() { if (a not_eq b); }", false, true, Settings::Native, "test.cpp"));
+        ASSERT_EQUALS("void or ( ) ;", tokenizeAndStringify("void or(void);", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( a && b ) { ; } }", tokenizeAndStringify("void f() { if (a and b); }", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( a && b ) { ; } }", tokenizeAndStringify("void f() { if (a and b); }"));
+        ASSERT_EQUALS("void f ( ) { if ( a || b ) { ; } }", tokenizeAndStringify("void f() { if (a or b); }", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( a || b ) { ; } }", tokenizeAndStringify("void f() { if (a or b); }"));
+        ASSERT_EQUALS("void f ( ) { if ( a & b ) { ; } }", tokenizeAndStringify("void f() { if (a bitand b); }", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( a & b ) { ; } }", tokenizeAndStringify("void f() { if (a bitand b); }"));
+        ASSERT_EQUALS("void f ( ) { if ( a | b ) { ; } }", tokenizeAndStringify("void f() { if (a bitor b); }", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( a | b ) { ; } }", tokenizeAndStringify("void f() { if (a bitor b); }"));
+        ASSERT_EQUALS("void f ( ) { if ( a ^ b ) { ; } }", tokenizeAndStringify("void f() { if (a xor b); }", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( a ^ b ) { ; } }", tokenizeAndStringify("void f() { if (a xor b); }"));
+        ASSERT_EQUALS("void f ( ) { if ( ~ b ) { ; } }", tokenizeAndStringify("void f() { if (compl b); }", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( ~ b ) { ; } }", tokenizeAndStringify("void f() { if (compl b); }"));
+        ASSERT_EQUALS("void f ( ) { if ( ! b ) { ; } }", tokenizeAndStringify("void f() { if (not b); }", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( ! b ) { ; } }", tokenizeAndStringify("void f() { if (not b); }"));
+        ASSERT_EQUALS("void f ( ) const { if ( ! b ) { ; } }", tokenizeAndStringify("void f() const { if (not b); }"));
+        ASSERT_EQUALS("void f ( ) { if ( a != b ) { ; } }", tokenizeAndStringify("void f() { if (a not_eq b); }", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( a != b ) { ; } }", tokenizeAndStringify("void f() { if (a not_eq b); }"));
         // #6201
-        ASSERT_EQUALS("void f ( ) { if ( ! c || ! memcmp ( a , b , s ) ) { ; } }", tokenizeAndStringify("void f() { if (!c or !memcmp(a, b, s)); }", false, true, Settings::Native, "test.c"));
-        ASSERT_EQUALS("void f ( ) { if ( ! c || ! memcmp ( a , b , s ) ) { ; } }", tokenizeAndStringify("void f() { if (!c or !memcmp(a, b, s)); }", false, true, Settings::Native, "test.cpp"));
+        ASSERT_EQUALS("void f ( ) { if ( ! c || ! memcmp ( a , b , s ) ) { ; } }", tokenizeAndStringify("void f() { if (!c or !memcmp(a, b, s)); }", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( ! c || ! memcmp ( a , b , s ) ) { ; } }", tokenizeAndStringify("void f() { if (!c or !memcmp(a, b, s)); }"));
         // #6029
-        ASSERT_EQUALS("void f ( ) { if ( ! b ) { } }", tokenizeAndStringify("void f() { if (not b){} }", false, true, Settings::Native, "test.c"));
-        ASSERT_EQUALS("void f ( ) { if ( ! b ) { } }", tokenizeAndStringify("void f() { if (not b){} }", false, true, Settings::Native, "test.cpp"));
+        ASSERT_EQUALS("void f ( ) { if ( ! b ) { } }", tokenizeAndStringify("void f() { if (not b){} }", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( ! b ) { } }", tokenizeAndStringify("void f() { if (not b){} }"));
         // #6207
-        ASSERT_EQUALS("void f ( ) { if ( not = x ) { } }", tokenizeAndStringify("void f() { if (not=x){} }", false, true, Settings::Native, "test.c"));
-        ASSERT_EQUALS("void f ( ) { if ( not = x ) { } }", tokenizeAndStringify("void f() { if (not=x){} }", false, true, Settings::Native, "test.cpp"));
+        ASSERT_EQUALS("void f ( ) { if ( not = x ) { } }", tokenizeAndStringify("void f() { if (not=x){} }", dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS("void f ( ) { if ( not = x ) { } }", tokenizeAndStringify("void f() { if (not=x){} }"));
         // #8029
-        ASSERT_EQUALS("void f ( struct S * s ) { x = s . and + 1 ; }", tokenizeAndStringify("void f(struct S *s) { x = s->and + 1; }", false, true, Settings::Native, "test.c"));
+        ASSERT_EQUALS("void f ( struct S * s ) { x = s . and + 1 ; }", tokenizeAndStringify("void f(struct S *s) { x = s->and + 1; }", dinit(TokenizeOptions, $.cpp = false)));
         // #8745
         ASSERT_EQUALS("void f ( ) { if ( x ) { or = 0 ; } }", tokenizeAndStringify("void f() { if (x) or = 0; }"));
+        // #9324
+        ASSERT_EQUALS("void f ( const char * str ) { while ( * str == '!' || * str == '[' ) { } }",
+                      tokenizeAndStringify("void f(const char *str) { while (*str=='!' or *str=='['){} }"));
+        // #9920
+        ASSERT_EQUALS("result = ch != s . end ( ) && * ch == ':' ;", tokenizeAndStringify("result = ch != s.end() and *ch == ':';", dinit(TokenizeOptions, $.cpp = false)));
+
+        // #8975
+        ASSERT_EQUALS("void foo ( ) {\n"
+                      "char * or ;\n"
+                      "while ( ( * or != 0 ) && ( * or != '|' ) ) { or ++ ; }\n"
+                      "}",
+                      tokenizeAndStringify(
+                          "void foo() {\n"
+                          "  char *or;\n"
+                          "  while ((*or != 0) && (*or != '|')) or++;\n"
+                          "}", dinit(TokenizeOptions, $.cpp = false)));
+        // #10013
+        ASSERT_EQUALS("void f ( ) { x = ! 123 ; }", tokenizeAndStringify("void f() { x = not 123; }"));
+
+        { // #12476
+            const char code[] = "struct S { int a, b; };"
+                                "void f(struct S* compl) {"
+                                "    compl->a = compl->b;"
+                                "}";
+            const char exp[] = "struct S { int a ; int b ; } ; void f ( struct S * compl ) { compl . a = compl . b ; }";
+            ASSERT_EQUALS(exp, tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
+        }
+
+        //ASSERT_EQUALS("", filter_valueflow(errout_str()));
+        ignore_errout();
     }
 
-    void simplifyCalculations() {
-        ASSERT_EQUALS("void foo ( char str [ ] ) { char x ; x = * str ; }",
-                      tokenizeAndStringify("void foo ( char str [ ] ) { char x = 0 | ( * str ) ; }", true));
-        ASSERT_EQUALS("void foo ( ) { if ( b ) { } }",
-                      tokenizeAndStringify("void foo ( ) { if (b + 0) { } }", true));
-        ASSERT_EQUALS("void foo ( ) { if ( b ) { } }",
-                      tokenizeAndStringify("void foo ( ) { if (0 + b) { } }", true));
-        ASSERT_EQUALS("void foo ( ) { if ( b ) { } }",
-                      tokenizeAndStringify("void foo ( ) { if (b - 0) { } }", true));
-        ASSERT_EQUALS("void foo ( ) { if ( b ) { } }",
-                      tokenizeAndStringify("void foo ( ) { if (b * 1) { } }", true));
-        ASSERT_EQUALS("void foo ( ) { if ( b ) { } }",
-                      tokenizeAndStringify("void foo ( ) { if (1 * b) { } }", true));
-        //ASSERT_EQUALS("void foo ( ) { if ( b ) { } }",
-        //              tokenizeAndStringify("void foo ( ) { if (b / 1) { } }", true));
-        ASSERT_EQUALS("void foo ( ) { if ( b ) { } }",
-                      tokenizeAndStringify("void foo ( ) { if (b | 0) { } }", true));
-        ASSERT_EQUALS("void foo ( ) { if ( b ) { } }",
-                      tokenizeAndStringify("void foo ( ) { if (0 | b) { } }", true));
-        ASSERT_EQUALS("void foo ( int b ) { int a ; a = b ; bar ( a ) ; }",
-                      tokenizeAndStringify("void foo ( int b ) { int a = b | 0 ; bar ( a ) ; }", true));
-        ASSERT_EQUALS("void foo ( int b ) { int a ; a = b ; bar ( a ) ; }",
-                      tokenizeAndStringify("void foo ( int b ) { int a = 0 | b ; bar ( a ) ; }", true));
-
-        // ticket #3093
-        ASSERT_EQUALS("int f ( ) { return 15 ; }",
-                      tokenizeAndStringify("int f() { int a = 10; int b = 5; return a + b; }", true));
-        ASSERT_EQUALS("int f ( ) { return a ; }",
-                      tokenizeAndStringify("int f() { return a * 1; }", true));
-        ASSERT_EQUALS("int f ( int a ) { return 0 ; }",
-                      tokenizeAndStringify("int f(int a) { return 0 * a; }", true));
-        ASSERT_EQUALS("bool f ( int i ) { switch ( i ) { case 15 : ; return true ; } }",
-                      tokenizeAndStringify("bool f(int i) { switch (i) { case 10 + 5: return true; } }", true));
-
-        // ticket #3576 - False positives in boolean expressions
-        ASSERT_EQUALS("int foo ( ) { return 1 ; }",
-                      tokenizeAndStringify("int foo ( ) { int i; int j; i = 1 || j; return i; }", true));
-
-        ASSERT_EQUALS("int foo ( ) { return 0 ; }",
-                      tokenizeAndStringify("int foo ( ) { int i; int j; i = 0 && j; return i; }", true));        // ticket #3576 - False positives in boolean expressions
-
-        // ticket #3723 - Simplify condition (0 && a < 123)
-        ASSERT_EQUALS("( 0 ) ;",
-                      tokenizeAndStringify("( 0 && a < 123 );", true));
-        ASSERT_EQUALS("( 0 ) ;",
-                      tokenizeAndStringify("( 0 && a[123] );", true));
-
-        // ticket #4931
-        ASSERT_EQUALS("dostuff ( 1 ) ;", tokenizeAndStringify("dostuff(9&&8);", true));
-    }
-
-    void simplifyRoundCurlyParentheses() {
+    void simplifyCompoundStatements() {
         ASSERT_EQUALS("; x = 123 ;", tokenizeAndStringify(";x=({123;});"));
         ASSERT_EQUALS("; x = y ;", tokenizeAndStringify(";x=({y;});"));
+        // #13419: Do not simplify compound statements in for loop
+        ASSERT_EQUALS("void foo ( int x ) { for ( ; ( { { } ; x < 1 ; } ) ; ) { ; } }",
+                      tokenizeAndStringify("void foo(int x) { for (;({ {}; x<1; });); }"));
     }
 
     void simplifyOperatorName1() {
@@ -6232,13 +5456,13 @@ class TestTokenizer : public TestFixture {
                             "    operator();"
                             "}";
 
-        const char result [] = "void operator ( ) { } "
-                               "int main ( ) "
-                               "{ "
-                               "operator ( ) ; "
-                               "}";
+        const char result[] = "void operator ( ) { } "
+                              "int main ( ) "
+                              "{ "
+                              "operator ( ) ; "
+                              "}";
 
-        ASSERT_EQUALS(result, tokenizeAndStringify(code, /*simplify=*/false, /*expand=*/true, /*platform=*/Settings::Native, "test.c"));
+        ASSERT_EQUALS(result, tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void simplifyOperatorName2() {
@@ -6248,13 +5472,13 @@ class TestTokenizer : public TestFixture {
                             "    operator = ();"
                             "}";
 
-        const char result [] = "class Fred "
-                               "{ "
-                               "Fred ( const Fred & f ) { operator= ( f ) ; } "
-                               "operator= ( ) ; "
-                               "}";
+        const char result[] = "class Fred "
+                              "{ "
+                              "Fred ( const Fred & f ) { operator= ( f ) ; } "
+                              "operator= ( ) ; "
+                              "}";
 
-        ASSERT_EQUALS(result, tokenizeAndStringify(code,false));
+        ASSERT_EQUALS(result, tokenizeAndStringify(code));
     }
 
     void simplifyOperatorName3() {
@@ -6262,70 +5486,70 @@ class TestTokenizer : public TestFixture {
         const char code[] = "void f() {"
                             "static_cast<ScToken*>(xResult.operator->())->GetMatrix();"
                             "}";
-        const char result[] = "void f ( ) { static_cast < ScToken * > ( xResult . operator. ( ) ) . GetMatrix ( ) ; }";
-        ASSERT_EQUALS(result, tokenizeAndStringify(code,false));
+        const char result[] = "void f ( ) { static_cast < ScToken * > ( xResult . operator-> ( ) ) . GetMatrix ( ) ; }";
+        ASSERT_EQUALS(result, tokenizeAndStringify(code));
     }
 
     void simplifyOperatorName4() {
         const char code[] = "void operator==() { }";
         const char result[] = "void operator== ( ) { }";
-        ASSERT_EQUALS(result, tokenizeAndStringify(code,false));
+        ASSERT_EQUALS(result, tokenizeAndStringify(code));
     }
 
     void simplifyOperatorName5() {
         const char code1[] = "std::istream & operator >> (std::istream & s, Fred &f);";
         const char result1[] = "std :: istream & operator>> ( std :: istream & s , Fred & f ) ;";
-        ASSERT_EQUALS(result1, tokenizeAndStringify(code1,false));
+        ASSERT_EQUALS(result1, tokenizeAndStringify(code1));
 
         const char code2[] = "std::ostream & operator << (std::ostream & s, const Fred &f);";
         const char result2[] = "std :: ostream & operator<< ( std :: ostream & s , const Fred & f ) ;";
-        ASSERT_EQUALS(result2, tokenizeAndStringify(code2,false));
+        ASSERT_EQUALS(result2, tokenizeAndStringify(code2));
     }
 
     void simplifyOperatorName6() { // ticket #3195
         const char code1[] = "value_type * operator ++ (int);";
         const char result1[] = "value_type * operator++ ( int ) ;";
-        ASSERT_EQUALS(result1, tokenizeAndStringify(code1,false));
+        ASSERT_EQUALS(result1, tokenizeAndStringify(code1));
 
         const char code2[] = "value_type * operator -- (int);";
         const char result2[] = "value_type * operator-- ( int ) ;";
-        ASSERT_EQUALS(result2, tokenizeAndStringify(code2,false));
+        ASSERT_EQUALS(result2, tokenizeAndStringify(code2));
     }
 
     void simplifyOperatorName7() { // ticket #4619
         const char code1[] = "value_type * operator += (int);";
         const char result1[] = "value_type * operator+= ( int ) ;";
-        ASSERT_EQUALS(result1, tokenizeAndStringify(code1,false));
+        ASSERT_EQUALS(result1, tokenizeAndStringify(code1));
     }
 
     void simplifyOperatorName8() { // ticket #5706
         const char code1[] = "value_type * operator += (int) noexcept ;";
         const char result1[] = "value_type * operator+= ( int ) noexcept ( true ) ;";
-        ASSERT_EQUALS(result1, tokenizeAndStringify(code1,false));
+        ASSERT_EQUALS(result1, tokenizeAndStringify(code1));
 
         const char code2[] = "value_type * operator += (int) noexcept ( true ) ;";
         const char result2[] = "value_type * operator+= ( int ) noexcept ( true ) ;";
-        ASSERT_EQUALS(result2, tokenizeAndStringify(code2,false));
+        ASSERT_EQUALS(result2, tokenizeAndStringify(code2));
 
         const char code3[] = "value_type * operator += (int) throw ( ) ;";
         const char result3[] = "value_type * operator+= ( int ) throw ( ) ;";
-        ASSERT_EQUALS(result3, tokenizeAndStringify(code3,false));
+        ASSERT_EQUALS(result3, tokenizeAndStringify(code3));
 
         const char code4[] = "value_type * operator += (int) const noexcept ;";
-        const char result4[] = "value_type * operator+= ( int ) const noexcept ;";
-        ASSERT_EQUALS(result4, tokenizeAndStringify(code4,false));
+        const char result4[] = "value_type * operator+= ( int ) const noexcept ( true ) ;";
+        ASSERT_EQUALS(result4, tokenizeAndStringify(code4));
 
         const char code5[] = "value_type * operator += (int) const noexcept ( true ) ;";
         const char result5[] = "value_type * operator+= ( int ) const noexcept ( true ) ;";
-        ASSERT_EQUALS(result5, tokenizeAndStringify(code5,false));
+        ASSERT_EQUALS(result5, tokenizeAndStringify(code5));
 
         const char code6[] = "value_type * operator += (int) const throw ( ) ;";
         const char result6[] = "value_type * operator+= ( int ) const throw ( ) ;";
-        ASSERT_EQUALS(result6, tokenizeAndStringify(code6,false));
+        ASSERT_EQUALS(result6, tokenizeAndStringify(code6));
 
         const char code7[] = "value_type * operator += (int) const noexcept ( false ) ;";
         const char result7[] = "value_type * operator+= ( int ) const noexcept ( false ) ;";
-        ASSERT_EQUALS(result7, tokenizeAndStringify(code7,false));
+        ASSERT_EQUALS(result7, tokenizeAndStringify(code7));
 
     }
 
@@ -6338,25 +5562,30 @@ class TestTokenizer : public TestFixture {
         const char code1[] = "using a::operator=;";
         ASSERT_EQUALS("using a :: operator= ;", tokenizeAndStringify(code1));
 
-        const char code2[] = "return &Fred::operator!=;";
-        ASSERT_EQUALS("return & Fred :: operator!= ;", tokenizeAndStringify(code2));
+        const char code2[] = "{ return &Fred::operator!=; }";
+        ASSERT_EQUALS("{ return & Fred :: operator!= ; }", tokenizeAndStringify(code2));
     }
 
     void simplifyOperatorName11() { // #8889
         const char code[] = "auto operator = (const Fred & other) -> Fred & ;";
         ASSERT_EQUALS("auto operator= ( const Fred & other ) . Fred & ;", tokenizeAndStringify(code));
+        ASSERT_EQUALS("[test.cpp:1:1]: (debug) auto token with no type. [autoNoType]\n", errout_str());
 
         const char code1[] = "auto operator = (const Fred & other) -> Fred & { }";
         ASSERT_EQUALS("auto operator= ( const Fred & other ) . Fred & { }", tokenizeAndStringify(code1));
+        ASSERT_EQUALS("[test.cpp:1:1]: (debug) auto token with no type. [autoNoType]\n", errout_str());
 
         const char code2[] = "template <typename T> void g(S<&T::operator+ >) {}";
         ASSERT_EQUALS("template < typename T > void g ( S < & T :: operator+ > ) { }", tokenizeAndStringify(code2));
+        ASSERT_EQUALS("", errout_str());
 
         const char code3[] = "template <typename T> void g(S<&T::operator int>) {}";
         ASSERT_EQUALS("template < typename T > void g ( S < & T :: operatorint > ) { }", tokenizeAndStringify(code3));
+        ASSERT_EQUALS("", errout_str());
 
         const char code4[] = "template <typename T> void g(S<&T::template operator- <double> >) {}";
-        ASSERT_EQUALS("template < typename T > void g ( S < & T :: template operator- < double > > ) { }", tokenizeAndStringify(code4));
+        ASSERT_EQUALS("template < typename T > void g ( S < & T :: operator- < double > > ) { }", tokenizeAndStringify(code4));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void simplifyOperatorName12() { // #9110
@@ -6371,23 +5600,319 @@ class TestTokenizer : public TestFixture {
                       tokenizeAndStringify(code));
     }
 
-    void simplifyOperatorName13() { // user defined literal
-        const char code[] = "unsigned long operator\"\"_numch(const char *ch, unsigned long size);";
-        ASSERT_EQUALS("unsigned long operator\"\"_numch ( const char * ch , unsigned long size ) ;",
+    void simplifyOperatorName13() { // user defined literal
+        const char code[] = "unsigned long operator\"\"_numch(const char *ch, unsigned long size);";
+        ASSERT_EQUALS("unsigned long operator\"\"_numch ( const char * ch , unsigned long size ) ;",
+                      tokenizeAndStringify(code));
+    }
+
+    void simplifyOperatorName14() { // std::complex operator "" if
+        {
+            const char code[] = "constexpr std::complex<float> operator\"\"if(long double __num);";
+            ASSERT_EQUALS("constexpr std :: complex < float > operator\"\"if ( long double __num ) ;",
+                          tokenizeAndStringify(code));
+        }
+        {
+            const char code[] = "constexpr std::complex<float> operator\"\"if(long double __num) { }";
+            ASSERT_EQUALS("constexpr std :: complex < float > operator\"\"if ( long double __num ) { }",
+                          tokenizeAndStringify(code));
+        }
+    }
+
+    void simplifyOperatorName15() { // ticket #9468 syntaxError
+        const char code[] = "template <typename> struct a;"
+                            "template <typename> struct b {"
+                            "  typedef char c;"
+                            "  operator c();"
+                            "};"
+                            "template <> struct a<char> : b<char> { using b::operator char; };";
+        ASSERT_EQUALS("struct a<char> ; template < typename > struct a ; "
+                      "struct b<char> ; "
+                      "struct a<char> : b<char> { using b :: operatorchar ; } ; struct b<char> { "
+                      "operatorchar ( ) ; "
+                      "} ;",
+                      tokenizeAndStringify(code));
+    }
+
+    void simplifyOperatorName16() { // ticket #9472
+        {
+            const char code[] = "class I : public A { iterator& operator++() override; };";
+            ASSERT_EQUALS("class I : public A { iterator & operator++ ( ) override ; } ;",
+                          tokenizeAndStringify(code));
+        }
+        {
+            const char code[] = "class I : public A { iterator& operator++() override { } };";
+            ASSERT_EQUALS("class I : public A { iterator & operator++ ( ) override { } } ;",
+                          tokenizeAndStringify(code));
+        }
+    }
+
+    void simplifyOperatorName17() {
+        {
+            const char code[] = "template <class a> void b(a c, a d) { c.operator>() == d; }";
+            ASSERT_EQUALS("template < class a > void b ( a c , a d ) { c . operator> ( ) == d ; }",
+                          tokenizeAndStringify(code));
+        }
+        {
+            const char code[] = "template <class a> void b(a c, a d) { c.operator>() == (d + 1); }";
+            ASSERT_EQUALS("template < class a > void b ( a c , a d ) { c . operator> ( ) == ( d + 1 ) ; }",
+                          tokenizeAndStringify(code));
+        }
+        {
+            const char code[] = "template <class a> void b(a c, a d) { c.operator<() == d; }";
+            ASSERT_EQUALS("template < class a > void b ( a c , a d ) { c . operator< ( ) == d ; }",
+                          tokenizeAndStringify(code));
+        }
+        {
+            const char code[] = "template <class a> void b(a c, a d) { c.operator>() == (d + 1); }";
+            ASSERT_EQUALS("template < class a > void b ( a c , a d ) { c . operator> ( ) == ( d + 1 ) ; }",
+                          tokenizeAndStringify(code));
+        }
+        {
+            const char code[] = "template <class a> void b(a c, a d) { c.operator++() == d; }";
+            ASSERT_EQUALS("template < class a > void b ( a c , a d ) { c . operator++ ( ) == d ; }",
+                          tokenizeAndStringify(code));
+        }
+        {
+            const char code[] = "template <class a> void b(a c, a d) { c.operator++() == (d + 1); }";
+            ASSERT_EQUALS("template < class a > void b ( a c , a d ) { c . operator++ ( ) == ( d + 1 ) ; }",
+                          tokenizeAndStringify(code));
+        }
+    }
+
+    void simplifyOperatorName18() { // global namespace
+        {
+            const char code[] = "struct Fred { operator std::string() const { return std::string(\"Fred\"); } };";
+            ASSERT_EQUALS("struct Fred { operatorstd::string ( ) const { return std :: string ( \"Fred\" ) ; } } ;",
+                          tokenizeAndStringify(code));
+        }
+        {
+            const char code[] = "struct Fred { operator ::std::string() const { return ::std::string(\"Fred\"); } };";
+            ASSERT_EQUALS("struct Fred { operator::std::string ( ) const { return :: std :: string ( \"Fred\" ) ; } } ;",
+                          tokenizeAndStringify(code));
+        }
+    }
+
+    void simplifyOperatorName19() {
+        const char code[] = "struct v {};"
+                            "enum E { e };"
+                            "struct s {"
+                            "  operator struct v() { return v(); };"
+                            "  operator enum E() { return e; }"
+                            "};"
+                            "void f() {"
+                            "  (void)&s::operator struct v;"
+                            "  (void)&s::operator enum E;"
+                            "}";
+        ASSERT_EQUALS("struct v { } ; "
+                      "enum E { e } ; "
+                      "struct s { "
+                      "operatorstructv ( ) { return v ( ) ; } ; "
+                      "operatorenumE ( ) { return e ; } "
+                      "} ; "
+                      "void f ( ) { "
+                      "( void ) & s :: operatorstructv ; "
+                      "( void ) & s :: operatorenumE ; "
+                      "}",
+                      tokenizeAndStringify(code));
+    }
+
+    void simplifyOperatorName20() {
+        const char code[] = "void operator \"\" _a(const char *);"
+                            "namespace N {"
+                            "  using ::operator \"\" _a;"
+                            "  void operator \"\" _b(const char *);"
+                            "}";
+        ASSERT_EQUALS("void operator\"\"_a ( const char * ) ; "
+                      "namespace N { "
+                      "using :: operator\"\"_a ; "
+                      "void operator\"\"_b ( const char * ) ; "
+                      "}",
+                      tokenizeAndStringify(code));
+    }
+
+    void simplifyOperatorName21() {
+        const char code[] = "template<char...> void operator \"\" _h() {}"
+                            "template<> void operator \"\" _h<'a', 'b', 'c'>() {}"
+                            "template void operator \"\" _h<'a', 'b', 'c', 'd'>();";
+        ASSERT_EQUALS("void operator\"\"_h<'a','b','c'> ( ) ; "
+                      "void operator\"\"_h<'a','b','c','d'> ( ) ; "
+                      "void operator\"\"_h<'a','b','c'> ( ) { } "
+                      "void operator\"\"_h<'a','b','c','d'> ( ) { }",
+                      tokenizeAndStringify(code));
+    }
+
+    void simplifyOperatorName22() {
+        const char code[] = "static RSLRelOp convertOperator(const Software::ComparisonOperator& op) {"
+                            "  if (op == &Software::operator==) return RSLEqual;"
+                            "return RSLNotEqual;"
+                            "}";
+        ASSERT_EQUALS("static RSLRelOp convertOperator ( const Software :: ComparisonOperator & op ) { "
+                      "if ( op == & Software :: operator== ) { return RSLEqual ; } "
+                      "return RSLNotEqual ; "
+                      "}",
+                      tokenizeAndStringify(code));
+        ASSERT_EQUALS(
+            "[test.cpp:1:116]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable RSLEqual [valueFlowBailoutIncompleteVar]\n",
+            filter_valueflow(errout_str()));
+    }
+
+    void simplifyOperatorName23() {
+        {
+            const char code[] = "double *vtkMatrix3x3::operator[](const unsigned int i) {"
+                                "  VTK_LEGACY_BODY(vtkMatrix3x3::operator[], \"VTK 7.0\");"
+                                "  return &(this->Element[i][0]);"
+                                "}";
+            ASSERT_EQUALS("double * vtkMatrix3x3 :: operator[] ( const unsigned int i ) { "
+                          "VTK_LEGACY_BODY ( vtkMatrix3x3 :: operator[] , \"VTK 7.0\" ) ; "
+                          "return & ( this . Element [ i ] [ 0 ] ) ; "
+                          "}",
+                          tokenizeAndStringify(code));
+            ignore_errout();
+        }
+        {
+            const char code[] = "double *vtkMatrix3x3::operator,(const unsigned int i) {"
+                                "  VTK_LEGACY_BODY(vtkMatrix3x3::operator,, \"VTK 7.0\");"
+                                "  return &(this->Element[i][0]);"
+                                "}";
+            ASSERT_EQUALS("double * vtkMatrix3x3 :: operator, ( const unsigned int i ) { "
+                          "VTK_LEGACY_BODY ( vtkMatrix3x3 :: operator, , \"VTK 7.0\" ) ; "
+                          "return & ( this . Element [ i ] [ 0 ] ) ; "
+                          "}",
+                          tokenizeAndStringify(code));
+            ignore_errout();
+        }
+    }
+
+    void simplifyOperatorName24() {
+        {
+            const char code[] = "void foo() { int i = a.operator++() ? a.operator--() : 0; }";
+            ASSERT_EQUALS("void foo ( ) { int i ; i = a . operator++ ( ) ? a . operator-- ( ) : 0 ; }",
+                          tokenizeAndStringify(code));
+        }
+        {
+            const char code[] = "void foo() { int i = a.operator++(0) ? a.operator--(0) : 0; }";
+            ASSERT_EQUALS("void foo ( ) { int i ; i = a . operator++ ( 0 ) ? a . operator-- ( 0 ) : 0 ; }",
+                          tokenizeAndStringify(code));
+        }
+    }
+
+    void simplifyOperatorName25() {
+        const char code[] = "bool negative(const Number &num) { return num.operator std::string()[0] == '-'; }";
+        ASSERT_EQUALS("bool negative ( const Number & num ) { return num . operatorstd::string ( ) [ 0 ] == '-' ; }",
+                      tokenizeAndStringify(code));
+    }
+
+    void simplifyOperatorName26() {
+        const char code[] = "void foo() {"
+                            "    x = y.operator *().z[123];"
+                            "}";
+        ASSERT_EQUALS("void foo ( ) { x = y . operator* ( ) . z [ 123 ] ; }",
+                      tokenizeAndStringify(code));
+        ignore_errout();
+    }
+
+    void simplifyOperatorName27() {
+        const char code[] = "int operator \"\" i (const char *, int);\n"
+                            "x = \"abc\"i;";
+        ASSERT_EQUALS("int operator\"\"i ( const char * , int ) ;\n"
+                      "x = operator\"\"i ( \"abc\" , 3 ) ;",
+                      tokenizeAndStringify(code));
+    }
+
+    void simplifyOperatorName28() {
+        const char code[] = "template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };\n"
+                            "int main() { }";
+        ASSERT_EQUALS("template < class ... Ts > struct overloaded : Ts ... { using Ts :: operator ( ) ... ; } ;\n"
+                      "int main ( ) { }",
+                      tokenizeAndStringify(code));
+        ASSERT_EQUALS("[test.cpp:1:61]: (debug) simplifyOperatorName: found unsimplified operator name [debug]\n", errout_str());
+    }
+
+    void simplifyOperatorName29() {
+        const Settings settings = settingsBuilder().cpp(Standards::CPP20).build();
+        ASSERT_EQUALS("auto operator<=> ( ) ;", tokenizeAndStringify("auto operator<=>();", settings));
+    }
+
+    void simplifyOperatorName30() { // #14151
+        const char code[] = "struct S { int operator()() const { return 42; } };\n"
+                            "int f() {\n"
+                            "    S s;\n"
+                            "    return int{ s.operator()() };\n"
+                            "}\n";
+        ASSERT_EQUALS("struct S { int operator() ( ) const { return 42 ; } } ;\n"
+                      "int f ( ) {\n"
+                      "S s ;\n"
+                      "return int { s . operator() ( ) } ;\n"
+                      "}", tokenizeAndStringify(code));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void simplifyOperatorName31() { // #6342
+        const char code[] = "template <typename T>\n"
+                            "struct B {\n"
+                            "    typedef T A[3];\n"
+                            "    operator A& () { return x_; }\n"
+                            "    A x_;\n"
+                            "};";
+        ASSERT_EQUALS("template < typename T >\nstruct B {\n\nT ( & operatorT ( ) ) [ 3 ] { return x_ ; }\nT x_ [ 3 ] ;\n} ;", tokenizeAndStringify(code));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void simplifyOperatorName32() { // #10256
+        const char code[] = "void f(int* = nullptr) {}\n";
+        ASSERT_EQUALS("void f ( int * = nullptr ) { }", tokenizeAndStringify(code));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void simplifyOperatorName33() { // #10138
+        const char code[] = "int (operator\"\" _ii)(unsigned long long v) { return v; }\n";
+        ASSERT_EQUALS("int operator\"\"_ii ( unsigned long long v ) { return v ; }", tokenizeAndStringify(code));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void simplifyOverloadedOperators1() {
+        const char code[] = "struct S { void operator()(int); };\n"
+                            "\n"
+                            "void foo(S x) {\n"
+                            "    x(123);\n"
+                            "}";
+        ASSERT_EQUALS("struct S { void operator() ( int ) ; } ;\n"
+                      "\n"
+                      "void foo ( S x ) {\n"
+                      "x . operator() ( 123 ) ;\n"
+                      "}",
+                      tokenizeAndStringify(code));
+    }
+
+    void simplifyOverloadedOperators2() { // #9879 - (*this)(123);
+        const char code[] = "struct S {\n"
+                            "  void operator()(int);\n"
+                            "  void foo() { (*this)(123); }\n"
+                            "};\n";
+        ASSERT_EQUALS("struct S {\n"
+                      "void operator() ( int ) ;\n"
+                      "void foo ( ) { ( * this ) . operator() ( 123 ) ; }\n"
+                      "} ;",
                       tokenizeAndStringify(code));
     }
 
-    void simplifyOperatorName14() { // std::complex operator "" if
-        {
-            const char code[] = "constexpr std::complex<float> operator\"\"if(long double __num);";
-            ASSERT_EQUALS("const std :: complex < float > operator\"\"if ( long double __num ) ;",
-                          tokenizeAndStringify(code));
-        }
-        {
-            const char code[] = "constexpr std::complex<float> operator\"\"if(long double __num) { }";
-            ASSERT_EQUALS("const std :: complex < float > operator\"\"if ( long double __num ) { }",
-                          tokenizeAndStringify(code));
-        }
+    void simplifyOverloadedOperators3() { // #9881
+        const char code[] = "struct Func { double operator()(double x) const; };\n"
+                            "void foo(double, double);\n"
+                            "void test() {\n"
+                            "    Func max;\n"
+                            "    double y = 0;\n"
+                            "    foo(0, max(y));\n"
+                            "}";
+        ASSERT_EQUALS("struct Func { double operator() ( double x ) const ; } ;\n"
+                      "void foo ( double , double ) ;\n"
+                      "void test ( ) {\n"
+                      "Func max ;\n"
+                      "double y ; y = 0 ;\n"
+                      "foo ( 0 , max . operator() ( y ) ) ;\n"
+                      "}",
+                      tokenizeAndStringify(code));
     }
 
     void simplifyNullArray() {
@@ -6398,13 +5923,13 @@ class TestTokenizer : public TestFixture {
         // remove some unhandled macros in the global scope.
         ASSERT_EQUALS("void f ( ) { }", tokenizeAndStringify("void f() NOTHROW { }"));
         ASSERT_EQUALS("struct Foo { } ;", tokenizeAndStringify("struct __declspec(dllexport) Foo {};"));
-        ASSERT_EQUALS("namespace { }", tokenizeAndStringify("ABA() namespace { }"));
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("ABA() namespace { int a ; }"), UNKNOWN_MACRO);
 
         // #3750
-        ASSERT_THROW(tokenizeAndStringify("; AB(foo*) foo::foo() { }"), InternalError);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("; AB(foo*) foo::foo() { }"), UNKNOWN_MACRO);
 
         // #4834 - syntax error
-        ASSERT_THROW(tokenizeAndStringify("A(B) foo() {}"), InternalError);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("A(B) foo() {}"), UNKNOWN_MACRO);
 
         // #3855
         ASSERT_EQUALS("; class foo { }",
@@ -6412,48 +5937,42 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("; CONST struct ABC abc ;",
                       tokenizeAndStringify("; CONST struct ABC abc ;"));
 
-        ASSERT_THROW(tokenizeAndStringify("class A {\n"
-                                          "  UNKNOWN_MACRO(A)\n"
-                                          "private:\n"
-                                          "  int x;\n"
-                                          "};"), InternalError);
+        ASSERT_NO_THROW(tokenizeAndStringify("class A {\n"
+                                             "  UNKNOWN_MACRO(A)\n" // <- this macro is ignored
+                                             "private:\n"
+                                             "  int x;\n"
+                                             "};"));
 
-        ASSERT_THROW(tokenizeAndStringify("MACRO(test) void test() { }"), InternalError); // #7931
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("MACRO(test) void test() { }"), UNKNOWN_MACRO); // #7931
 
-        ASSERT_THROW(tokenizeAndStringify("BEGIN_MESSAGE_MAP(CSetProgsAdvDlg, CResizableStandAloneDialog)\n"
-                                          "    ON_BN_CLICKED(IDC_ADDTOOL, OnBnClickedAddtool)\n"
-                                          "END_MESSAGE_MAP()\n"
-                                          "\n"
-                                          "BOOL CSetProgsAdvDlg::OnInitDialog() {}"),
-                     InternalError);
-    }
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("BEGIN_MESSAGE_MAP(CSetProgsAdvDlg, CResizableStandAloneDialog)\n"
+                                                   "    ON_BN_CLICKED(IDC_ADDTOOL, OnBnClickedAddtool)\n"
+                                                   "END_MESSAGE_MAP()\n"
+                                                   "\n"
+                                                   "BOOL CSetProgsAdvDlg::OnInitDialog() {}"),
+                              UNKNOWN_MACRO);
 
-    void removeMacroInVarDecl() { // #4304
-        // only remove macros with parentheses (those hurt most)
-        ASSERT_EQUALS("void f ( ) { PROGMEM int x ; }", tokenizeAndStringify("void f() { PROGMEM int x ; }"));
-        ASSERT_EQUALS("void f ( ) { int x ; }", tokenizeAndStringify("void f() { SECTION(\".data.ro\") int x ; }"));
+        ASSERT_EQUALS("struct S {\n"
+                      "S ( ) : p { new ( malloc ( 4 ) ) int { } } { }\n"
+                      "int * p ;\n"
+                      "} ;",
+                      tokenizeAndStringify("struct S {\n"
+                                           "    S() : p{new (malloc(4)) int{}} {}\n"
+                                           "    int* p;\n"
+                                           "};\n"));
+    }
 
-        // various variable declarations
-        ASSERT_EQUALS("void f ( ) { CONST int x ; }", tokenizeAndStringify("void f() { SECTION(\".data.ro\") CONST int x ; }"));
-        ASSERT_EQUALS("void f ( ) { char a [ 4 ] ; }", tokenizeAndStringify("void f() { SECTION(\".data.ro\") char a[4]; }"));
-        ASSERT_EQUALS("void f ( ) { const char a [ 4 ] ; }", tokenizeAndStringify("void f() { SECTION(\".data.ro\") const char a[4]; }"));
-        ASSERT_EQUALS("void f ( ) { struct ABC abc ; }", tokenizeAndStringify("void f() { SECTION(\".data.ro\") struct ABC abc; }"));
-        ASSERT_EQUALS("void f ( ) { CONST struct ABC abc ; }", tokenizeAndStringify("void f() { SECTION(\".data.ro\") CONST struct ABC abc; }"));
+    void addSemicolonAfterUnknownMacro() {
+        // #6975
+        ASSERT_EQUALS("void f ( ) { MACRO ( ) ; try { } }", tokenizeAndStringify("void f() { MACRO() try {} }"));
+        // #9376
+        ASSERT_EQUALS("MACRO ( ) ; using namespace foo ;", tokenizeAndStringify("MACRO() using namespace foo;"));
     }
 
     void multipleAssignment() {
         ASSERT_EQUALS("a = b = 0 ;", tokenizeAndStringify("a=b=0;"));
     }
 
-    void sizeOfCharLiteral() { // #7490 sizeof('a') should be 4 in C mode
-        std::stringstream expected;
-        expected << "unsigned long a ; a = " << settings1.sizeof_int << " ;";
-        ASSERT_EQUALS(expected.str(),
-                      tokenizeAndStringify("unsigned long a = sizeof('x');", true, true, Settings::Native, "test.c", false));
-        ASSERT_EQUALS("unsigned long a ; a = 1 ;",
-                      tokenizeAndStringify("unsigned long a = sizeof('x');", true, true, Settings::Native, "test.cpp", true));
-    }
-
     void platformWin() {
         const char code[] = "BOOL f;"
                             "BOOLEAN g;"
@@ -6618,83 +6137,10 @@ class TestTokenizer : public TestFixture {
                                 "float * ptrToFloat ;";
 
         // These types should be defined the same on all Windows platforms
-        const std::string win32A = tokenizeAndStringifyWindows(code, true, true, Settings::Win32A);
+        const std::string win32A = tokenizeAndStringify(code, settings_win32a);
         ASSERT_EQUALS(expected, win32A);
-        ASSERT_EQUALS(win32A, tokenizeAndStringifyWindows(code, true, true, Settings::Win32W));
-        ASSERT_EQUALS(win32A, tokenizeAndStringifyWindows(code, true, true, Settings::Win64));
-    }
-
-    void platformWin32() {
-        const char code[] = "unsigned int sizeof_short = sizeof(short);"
-                            "unsigned int sizeof_unsigned_short = sizeof(unsigned short);"
-                            "unsigned int sizeof_int = sizeof(int);"
-                            "unsigned int sizeof_unsigned_int = sizeof(unsigned int);"
-                            "unsigned int sizeof_long = sizeof(long);"
-                            "unsigned int sizeof_unsigned_long = sizeof(unsigned long);"
-                            "unsigned int sizeof_long_long = sizeof(long long);"
-                            "unsigned int sizeof_unsigned_long_long = sizeof(unsigned long long);"
-                            "unsigned int sizeof_float = sizeof(float);"
-                            "unsigned int sizeof_double = sizeof(double);"
-                            "unsigned int sizeof_long_double = sizeof(long double);"
-                            "unsigned int sizeof_bool = sizeof(bool);"
-                            "unsigned int sizeof_wchar_t = sizeof(wchar_t);"
-                            "unsigned int sizeof_pointer = sizeof(void *);"
-                            "unsigned int sizeof_size_t = sizeof(size_t);"
-                            "size_t a;"
-                            "ssize_t b;"
-                            "ptrdiff_t c;"
-                            "intptr_t d;"
-                            "uintptr_t e;"
-                            "DWORD_PTR O;"
-                            "ULONG_PTR P;"
-                            "SIZE_T Q;"
-                            "HRESULT R;"
-                            "LONG_PTR S;"
-                            "HANDLE T;"
-                            "PHANDLE U;"
-                            "SSIZE_T _ssize_t;"
-                            "UINT_PTR uint_ptr;"
-                            "WPARAM wparam;"
-                            "HALF_PTR half_ptr;"
-                            "INT_PTR int_ptr;";
-
-        const char expected[] = "unsigned int sizeof_short ; sizeof_short = 2 ; "
-                                "unsigned int sizeof_unsigned_short ; sizeof_unsigned_short = 2 ; "
-                                "unsigned int sizeof_int ; sizeof_int = 4 ; "
-                                "unsigned int sizeof_unsigned_int ; sizeof_unsigned_int = 4 ; "
-                                "unsigned int sizeof_long ; sizeof_long = 4 ; "
-                                "unsigned int sizeof_unsigned_long ; sizeof_unsigned_long = 4 ; "
-                                "unsigned int sizeof_long_long ; sizeof_long_long = 8 ; "
-                                "unsigned int sizeof_unsigned_long_long ; sizeof_unsigned_long_long = 8 ; "
-                                "unsigned int sizeof_float ; sizeof_float = 4 ; "
-                                "unsigned int sizeof_double ; sizeof_double = 8 ; "
-                                "unsigned int sizeof_long_double ; sizeof_long_double = 8 ; "
-                                "unsigned int sizeof_bool ; sizeof_bool = 1 ; "
-                                "unsigned int sizeof_wchar_t ; sizeof_wchar_t = 2 ; "
-                                "unsigned int sizeof_pointer ; sizeof_pointer = 4 ; "
-                                "unsigned int sizeof_size_t ; sizeof_size_t = 4 ; "
-                                "unsigned long a ; "
-                                "long b ; "
-                                "long c ; "
-                                "long d ; "
-                                "unsigned long e ; "
-                                "unsigned long O ; "
-                                "unsigned long P ; "
-                                "unsigned long Q ; "
-                                "long R ; "
-                                "long S ; "
-                                "void * T ; "
-                                "void * * U ; "
-                                "long _ssize_t ; "
-                                "unsigned int uint_ptr ; "
-                                "unsigned int wparam ; "
-                                "short half_ptr ; "
-                                "int int_ptr ;";
-
-        // These types should be defined the same on all Win32 platforms
-        std::string win32A = tokenizeAndStringifyWindows(code, true, true, Settings::Win32A);
-        ASSERT_EQUALS(expected, win32A);
-        ASSERT_EQUALS(win32A, tokenizeAndStringifyWindows(code, true, true, Settings::Win32W));
+        ASSERT_EQUALS(win32A, tokenizeAndStringify(code, settings_win32w));
+        ASSERT_EQUALS(win32A, tokenizeAndStringify(code, settings_win32a));
     }
 
     void platformWin32A() {
@@ -6711,7 +6157,7 @@ class TestTokenizer : public TestFixture {
                             "    _tcscpy(dst, src);"
                             "    dst[0] = 0;"
                             "    _tcscat(dst, src);"
-                            "    LPTSTR d = _tcsdup(str);"
+                            "    LPTSTR d = _tcsdup(src);"
                             "    _tprintf(_T(\"Hello world!\"));"
                             "    _stprintf(dst, _T(\"Hello!\"));"
                             "    _sntprintf(dst, sizeof(dst) / sizeof(TCHAR), _T(\"Hello world!\"));"
@@ -6732,7 +6178,7 @@ class TestTokenizer : public TestFixture {
                                 "strcpy ( dst , src ) ; "
                                 "dst [ 0 ] = 0 ; "
                                 "strcat ( dst , src ) ; "
-                                "char * d ; d = strdup ( str ) ; "
+                                "char * d ; d = strdup ( src ) ; "
                                 "printf ( \"Hello world!\" ) ; "
                                 "sprintf ( dst , \"Hello!\" ) ; "
                                 "_snprintf ( dst , sizeof ( dst ) / sizeof ( char ) , \"Hello world!\" ) ; "
@@ -6740,7 +6186,13 @@ class TestTokenizer : public TestFixture {
                                 "sscanf ( dst , \"%s\" , dst ) ; "
                                 "} "
                                 "unsigned char tbyte ;";
-        ASSERT_EQUALS(expected, tokenizeAndStringifyWindows(code, false, true, Settings::Win32A));
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code, settings_win32a));
+
+        const char code2[] = "LPCTSTR f(void* p) { return LPCTSTR(p); }\n" // #11430
+                             "LPCTSTR g() { return LPCTSTR{}; }";
+        const char expected2[] = "const char * f ( void * p ) { return ( const char * ) ( p ) ; }\n"
+                                 "const char * g ( ) { return ( const char * ) ( 0 ) ; }";
+        ASSERT_EQUALS(expected2, tokenizeAndStringify(code2, settings_win32a));
     }
 
     void platformWin32W() {
@@ -6758,7 +6210,7 @@ class TestTokenizer : public TestFixture {
                             "    _tcscpy(dst, src);"
                             "    dst[0] = 0;"
                             "    _tcscat(dst, src);"
-                            "    LPTSTR d = _tcsdup(str);"
+                            "    LPTSTR d = _tcsdup(src);"
                             "    _tprintf(_T(\"Hello world!\"));"
                             "    _stprintf(dst, _T(\"Hello!\"));"
                             "    _sntprintf(dst, sizeof(dst) / sizeof(TCHAR), _T(\"Hello world!\"));"
@@ -6779,216 +6231,36 @@ class TestTokenizer : public TestFixture {
                                 "wcscpy ( dst , src ) ; "
                                 "dst [ 0 ] = 0 ; "
                                 "wcscat ( dst , src ) ; "
-                                "wchar_t * d ; d = wcsdup ( str ) ; "
+                                "wchar_t * d ; d = wcsdup ( src ) ; "
                                 "wprintf ( L\"Hello world!\" ) ; "
                                 "swprintf ( dst , L\"Hello!\" ) ; "
                                 "_snwprintf ( dst , sizeof ( dst ) / sizeof ( wchar_t ) , L\"Hello world!\" ) ; "
                                 "wscanf ( L\"%s\" , dst ) ; "
                                 "swscanf ( dst , L\"%s\" , dst ) ; "
                                 "}";
-        ASSERT_EQUALS(expected, tokenizeAndStringifyWindows(code, false, true, Settings::Win32W));
-    }
-
-    void platformWin64() {
-        const char code[] = "unsigned int sizeof_short = sizeof(short);"
-                            "unsigned int sizeof_unsigned_short = sizeof(unsigned short);"
-                            "unsigned int sizeof_int = sizeof(int);"
-                            "unsigned int sizeof_unsigned_int = sizeof(unsigned int);"
-                            "unsigned int sizeof_long = sizeof(long);"
-                            "unsigned int sizeof_unsigned_long = sizeof(unsigned long);"
-                            "unsigned int sizeof_long_long = sizeof(long long);"
-                            "unsigned int sizeof_unsigned_long_long = sizeof(unsigned long long);"
-                            "unsigned int sizeof_float = sizeof(float);"
-                            "unsigned int sizeof_double = sizeof(double);"
-                            "unsigned int sizeof_long_double = sizeof(long double);"
-                            "unsigned int sizeof_bool = sizeof(bool);"
-                            "unsigned int sizeof_wchar_t = sizeof(wchar_t);"
-                            "unsigned int sizeof_pointer = sizeof(void *);"
-                            "unsigned int sizeof_size_t = sizeof(size_t);"
-                            "size_t a;"
-                            "ssize_t b;"
-                            "ptrdiff_t c;"
-                            "intptr_t d;"
-                            "uintptr_t e;"
-                            "DWORD_PTR O;"
-                            "ULONG_PTR P;"
-                            "SIZE_T Q;"
-                            "HRESULT R;"
-                            "LONG_PTR S;"
-                            "HANDLE T;"
-                            "PHANDLE U;"
-                            "SSIZE_T _ssize_t;"
-                            "UINT_PTR uint_ptr;"
-                            "WPARAM wparam;"
-                            "HALF_PTR half_ptr;"
-                            "INT_PTR int_ptr;";
-
-        const char expected[] = "unsigned int sizeof_short ; sizeof_short = 2 ; "
-                                "unsigned int sizeof_unsigned_short ; sizeof_unsigned_short = 2 ; "
-                                "unsigned int sizeof_int ; sizeof_int = 4 ; "
-                                "unsigned int sizeof_unsigned_int ; sizeof_unsigned_int = 4 ; "
-                                "unsigned int sizeof_long ; sizeof_long = 4 ; "
-                                "unsigned int sizeof_unsigned_long ; sizeof_unsigned_long = 4 ; "
-                                "unsigned int sizeof_long_long ; sizeof_long_long = 8 ; "
-                                "unsigned int sizeof_unsigned_long_long ; sizeof_unsigned_long_long = 8 ; "
-                                "unsigned int sizeof_float ; sizeof_float = 4 ; "
-                                "unsigned int sizeof_double ; sizeof_double = 8 ; "
-                                "unsigned int sizeof_long_double ; sizeof_long_double = 8 ; "
-                                "unsigned int sizeof_bool ; sizeof_bool = 1 ; "
-                                "unsigned int sizeof_wchar_t ; sizeof_wchar_t = 2 ; "
-                                "unsigned int sizeof_pointer ; sizeof_pointer = 8 ; "
-                                "unsigned int sizeof_size_t ; sizeof_size_t = 8 ; "
-                                "unsigned long long a ; "
-                                "long long b ; "
-                                "long long c ; "
-                                "long long d ; "
-                                "unsigned long long e ; "
-                                "unsigned long long O ; "
-                                "unsigned long long P ; "
-                                "unsigned long long Q ; "
-                                "long R ; "
-                                "long long S ; "
-                                "void * T ; "
-                                "void * * U ; "
-                                "long long _ssize_t ; "
-                                "unsigned long long uint_ptr ; "
-                                "unsigned long long wparam ; "
-                                "int half_ptr ; "
-                                "long long int_ptr ;";
-
-        ASSERT_EQUALS(expected, tokenizeAndStringifyWindows(code, true, true, Settings::Win64));
-    }
-
-    void platformUnix32() {
-        const char code[] = "unsigned int sizeof_short = sizeof(short);"
-                            "unsigned int sizeof_unsigned_short = sizeof(unsigned short);"
-                            "unsigned int sizeof_int = sizeof(int);"
-                            "unsigned int sizeof_unsigned_int = sizeof(unsigned int);"
-                            "unsigned int sizeof_long = sizeof(long);"
-                            "unsigned int sizeof_unsigned_long = sizeof(unsigned long);"
-                            "unsigned int sizeof_long_long = sizeof(long long);"
-                            "unsigned int sizeof_unsigned_long_long = sizeof(unsigned long long);"
-                            "unsigned int sizeof_float = sizeof(float);"
-                            "unsigned int sizeof_double = sizeof(double);"
-                            "unsigned int sizeof_long_double = sizeof(long double);"
-                            "unsigned int sizeof_bool = sizeof(bool);"
-                            "unsigned int sizeof_wchar_t = sizeof(wchar_t);"
-                            "unsigned int sizeof_pointer = sizeof(void *);"
-                            "unsigned int sizeof_size_t = sizeof(size_t);"
-                            "size_t a;"
-                            "ssize_t b;"
-                            "ptrdiff_t c;"
-                            "intptr_t d;"
-                            "uintptr_t e;";
-
-        const char expected[] = "unsigned int sizeof_short ; sizeof_short = 2 ; "
-                                "unsigned int sizeof_unsigned_short ; sizeof_unsigned_short = 2 ; "
-                                "unsigned int sizeof_int ; sizeof_int = 4 ; "
-                                "unsigned int sizeof_unsigned_int ; sizeof_unsigned_int = 4 ; "
-                                "unsigned int sizeof_long ; sizeof_long = 4 ; "
-                                "unsigned int sizeof_unsigned_long ; sizeof_unsigned_long = 4 ; "
-                                "unsigned int sizeof_long_long ; sizeof_long_long = 8 ; "
-                                "unsigned int sizeof_unsigned_long_long ; sizeof_unsigned_long_long = 8 ; "
-                                "unsigned int sizeof_float ; sizeof_float = 4 ; "
-                                "unsigned int sizeof_double ; sizeof_double = 8 ; "
-                                "unsigned int sizeof_long_double ; sizeof_long_double = 12 ; "
-                                "unsigned int sizeof_bool ; sizeof_bool = 1 ; "
-                                "unsigned int sizeof_wchar_t ; sizeof_wchar_t = 4 ; "
-                                "unsigned int sizeof_pointer ; sizeof_pointer = 4 ; "
-                                "unsigned int sizeof_size_t ; sizeof_size_t = 4 ; "
-                                "unsigned long a ; "
-                                "long b ; "
-                                "long c ; "
-                                "long d ; "
-                                "unsigned long e ;";
-
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true, true, Settings::Unix32));
-    }
-
-    void platformUnix64() {
-        const char code[] = "unsigned int sizeof_short = sizeof(short);"
-                            "unsigned int sizeof_unsigned_short = sizeof(unsigned short);"
-                            "unsigned int sizeof_int = sizeof(int);"
-                            "unsigned int sizeof_unsigned_int = sizeof(unsigned int);"
-                            "unsigned int sizeof_long = sizeof(long);"
-                            "unsigned int sizeof_unsigned_long = sizeof(unsigned long);"
-                            "unsigned int sizeof_long_long = sizeof(long long);"
-                            "unsigned int sizeof_unsigned_long_long = sizeof(unsigned long long);"
-                            "unsigned int sizeof_float = sizeof(float);"
-                            "unsigned int sizeof_double = sizeof(double);"
-                            "unsigned int sizeof_long_double = sizeof(long double);"
-                            "unsigned int sizeof_bool = sizeof(bool);"
-                            "unsigned int sizeof_wchar_t = sizeof(wchar_t);"
-                            "unsigned int sizeof_pointer = sizeof(void *);"
-                            "unsigned int sizeof_size_t = sizeof(size_t);"
-                            "size_t a;"
-                            "ssize_t b;"
-                            "ptrdiff_t c;"
-                            "intptr_t d;"
-                            "uintptr_t e;";
-
-        const char expected[] = "unsigned int sizeof_short ; sizeof_short = 2 ; "
-                                "unsigned int sizeof_unsigned_short ; sizeof_unsigned_short = 2 ; "
-                                "unsigned int sizeof_int ; sizeof_int = 4 ; "
-                                "unsigned int sizeof_unsigned_int ; sizeof_unsigned_int = 4 ; "
-                                "unsigned int sizeof_long ; sizeof_long = 8 ; "
-                                "unsigned int sizeof_unsigned_long ; sizeof_unsigned_long = 8 ; "
-                                "unsigned int sizeof_long_long ; sizeof_long_long = 8 ; "
-                                "unsigned int sizeof_unsigned_long_long ; sizeof_unsigned_long_long = 8 ; "
-                                "unsigned int sizeof_float ; sizeof_float = 4 ; "
-                                "unsigned int sizeof_double ; sizeof_double = 8 ; "
-                                "unsigned int sizeof_long_double ; sizeof_long_double = 16 ; "
-                                "unsigned int sizeof_bool ; sizeof_bool = 1 ; "
-                                "unsigned int sizeof_wchar_t ; sizeof_wchar_t = 4 ; "
-                                "unsigned int sizeof_pointer ; sizeof_pointer = 8 ; "
-                                "unsigned int sizeof_size_t ; sizeof_size_t = 8 ; "
-                                "unsigned long a ; "
-                                "long b ; "
-                                "long c ; "
-                                "long d ; "
-                                "unsigned long e ;";
-
-        ASSERT_EQUALS(expected, tokenizeAndStringify(code, true, true, Settings::Unix64));
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code, settings_win32w));
     }
 
     void platformWin32AStringCat() { //#5150
         const char code[] = "TCHAR text[] = _T(\"123\") _T(\"456\") _T(\"789\");";
         const char expected[] = "char text [ 10 ] = \"123456789\" ;";
-        ASSERT_EQUALS(expected, tokenizeAndStringifyWindows(code, true, true, Settings::Win32A));
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code, settings_win32a));
     }
 
     void platformWin32WStringCat() { //#5150
         const char code[] = "TCHAR text[] = _T(\"123\") _T(\"456\") _T(\"789\");";
         const char expected[] = "wchar_t text [ 10 ] = L\"123456789\" ;";
-        ASSERT_EQUALS(expected, tokenizeAndStringifyWindows(code, true, true, Settings::Win32W));
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code, settings_win32w));
     }
 
     void platformWinWithNamespace() {
         const char code1[] = "UINT32 a; ::UINT32 b; foo::UINT32 c;";
         const char expected1[] = "unsigned int a ; unsigned int b ; foo :: UINT32 c ;";
-        ASSERT_EQUALS(expected1, tokenizeAndStringifyWindows(code1, true, true, Settings::Win32A));
+        ASSERT_EQUALS(expected1, tokenizeAndStringify(code1, settings_win32a));
 
         const char code2[] = "LPCVOID a; ::LPCVOID b; foo::LPCVOID c;";
         const char expected2[] = "const void * a ; const void * b ; foo :: LPCVOID c ;";
-        ASSERT_EQUALS(expected2, tokenizeAndStringifyWindows(code2, true, true, Settings::Win32A));
-    }
-
-    void isZeroNumber() const {
-        ASSERT_EQUALS(true, Tokenizer::isZeroNumber("0.0"));
-        ASSERT_EQUALS(true, Tokenizer::isZeroNumber("+0.0"));
-        ASSERT_EQUALS(true, Tokenizer::isZeroNumber("-0.0"));
-        ASSERT_EQUALS(true, Tokenizer::isZeroNumber("+0L"));
-        ASSERT_EQUALS(true, Tokenizer::isZeroNumber("+0"));
-        ASSERT_EQUALS(true, Tokenizer::isZeroNumber("-0"));
-        ASSERT_EQUALS(true, Tokenizer::isZeroNumber("-0E+0"));
-
-        ASSERT_EQUALS(false, Tokenizer::isZeroNumber("1.0"));
-        ASSERT_EQUALS(false, Tokenizer::isZeroNumber("+1.0"));
-        ASSERT_EQUALS(false, Tokenizer::isZeroNumber("-1"));
-        ASSERT_EQUALS(false, Tokenizer::isZeroNumber(""));
-        ASSERT_EQUALS(false, Tokenizer::isZeroNumber("garbage"));
-        ASSERT_EQUALS(false, Tokenizer::isZeroNumber("E2"));
-        ASSERT_EQUALS(false, Tokenizer::isZeroNumber("2e"));
+        ASSERT_EQUALS(expected2, tokenizeAndStringify(code2, settings_win32w));
     }
 
     void isOneNumber() const {
@@ -7007,26 +6279,10 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS(false, Tokenizer::isOneNumber("garbage"));
     }
 
-    void isTwoNumber() const {
-        ASSERT_EQUALS(true, Tokenizer::isTwoNumber("2.0"));
-        ASSERT_EQUALS(true, Tokenizer::isTwoNumber("+2.0"));
-        ASSERT_EQUALS(true, Tokenizer::isTwoNumber("2.0e+0"));
-        ASSERT_EQUALS(true, Tokenizer::isTwoNumber("+2L"));
-        ASSERT_EQUALS(true, Tokenizer::isTwoNumber("+2"));
-        ASSERT_EQUALS(true, Tokenizer::isTwoNumber("2"));
-        ASSERT_EQUALS(true, Tokenizer::isTwoNumber("+2E+0"));
-
-        ASSERT_EQUALS(false, Tokenizer::isTwoNumber("0.0"));
-        ASSERT_EQUALS(false, Tokenizer::isTwoNumber("+0.0"));
-        ASSERT_EQUALS(false, Tokenizer::isTwoNumber("-0"));
-        ASSERT_EQUALS(false, Tokenizer::isTwoNumber(""));
-        ASSERT_EQUALS(false, Tokenizer::isTwoNumber("garbage"));
-    }
-
     void simplifyStaticConst() {
         const char code1[]     = "class foo { public: bool const static c ; }";
         const char expected1[] = "class foo { public: static const bool c ; }";
-        ASSERT_EQUALS(expected1, tokenizeAndStringify(code1, true));
+        ASSERT_EQUALS(expected1, tokenizeAndStringify(code1));
 
         const char code2[] =
             "int long long f()\n"
@@ -7076,43 +6332,104 @@ class TestTokenizer : public TestFixture {
             "return i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9 + i10 + i11 + i12\n"
             "+ i13 + i14 + i15 + i16 + i17 + i18 ;\n"
             "}";
-        ASSERT_EQUALS(expected2, tokenizeAndStringify(code2, true));
+        ASSERT_EQUALS(expected2, tokenizeAndStringify(code2));
 
         const char code3[] = "const unsigned long extern int i;";
         const char expected3[] = "extern const unsigned long i ;";
-        ASSERT_EQUALS(expected3, tokenizeAndStringify(code3, true));
+        ASSERT_EQUALS(expected3, tokenizeAndStringify(code3));
     }
 
     void simplifyCPPAttribute() {
         ASSERT_EQUALS("int f ( ) ;",
-                      tokenizeAndStringify("[[deprecated]] int f();", false, true, Settings::Native, "test.cpp", true));
+                      tokenizeAndStringify("[[deprecated]] int f();"));
 
-        ASSERT_EQUALS("[ [ deprecated ] ] int f ( ) ;",
-                      tokenizeAndStringify("[[deprecated]] int f();", false, true, Settings::Native, "test.cpp", false));
-
-        ASSERT_EQUALS("[ [ deprecated ] ] int f ( ) ;",
-                      tokenizeAndStringify("[[deprecated]] int f();", false, true, Settings::Native, "test.c", true));
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("[[deprecated]] int f();", dinit(TokenizeOptions, $.cpp = false)), SYNTAX);
 
         ASSERT_EQUALS("template < class T > int f ( ) { }",
-                      tokenizeAndStringify("template <class T> [[noreturn]] int f(){}", false, true, Settings::Native, "test.cpp", true));
+                      tokenizeAndStringify("template <class T> [[noreturn]] int f(){}"));
 
         ASSERT_EQUALS("int f ( int i ) ;",
-                      tokenizeAndStringify("[[maybe_unused]] int f([[maybe_unused]] int i);", false, true, Settings::Native, "test.cpp", true));
+                      tokenizeAndStringify("[[maybe_unused]] int f([[maybe_unused]] int i);"));
+
+        ASSERT_EQUALS("struct a ;",
+                      tokenizeAndStringify("struct [[]] a;"));
+
+        ASSERT_EQUALS("struct a ;",
+                      tokenizeAndStringify("struct [[,]] a;"));
+
+        ASSERT_EQUALS("struct a ;",
+                      tokenizeAndStringify("struct [[deprecated,]] a;"));
+
+        ASSERT_EQUALS("struct a ;",
+                      tokenizeAndStringify("struct [[,,]] a;"));
+
+        ASSERT_EQUALS("struct a ;",
+                      tokenizeAndStringify("struct [[deprecated,,]] a;"));
+
+        ASSERT_EQUALS("struct a ;",
+                      tokenizeAndStringify("struct [[deprecated,maybe_unused,]] a;"));
+
+        ASSERT_EQUALS("struct a ;",
+                      tokenizeAndStringify("struct [[,,,]] a;"));
 
-        ASSERT_EQUALS("[ [ maybe_unused ] ] int f ( [ [ maybe_unused ] ] int i ) ;",
-                      tokenizeAndStringify("[[maybe_unused]] int f([[maybe_unused]] int i);", false, true, Settings::Native, "test.cpp", false));
+        ASSERT_EQUALS("struct a ;",
+                      tokenizeAndStringify("struct alignas(int) a;"));
 
+        ASSERT_EQUALS("struct a ;",
+                      tokenizeAndStringify("struct alignas ( alignof ( float ) ) a;"));
+
+        ASSERT_EQUALS("char a [ 256 ] ;",
+                      tokenizeAndStringify("alignas(256) char a[256];"));
+
+        ASSERT_EQUALS("struct a ;",
+                      tokenizeAndStringify("struct alignas(float) [[deprecated(reason)]] a;"));
+
+        ASSERT_EQUALS("struct a ;",
+                      tokenizeAndStringify("struct [[deprecated,maybe_unused]] alignas(double) [[trivial_abi]] a;"));
+
+        ASSERT_EQUALS("void func5 ( const char * , ... ) ;",
+                      tokenizeAndStringify("[[noreturn]] void func5(const char*, ...);"));
+
+        ASSERT_EQUALS("void func5 ( const char * , ... ) ;",
+                      tokenizeAndStringify("[[noreturn]] [[gnu::format(printf, 1, 2)]] void func5(const char*, ...);"));
+
+        ASSERT_EQUALS("void func5 ( const char * , ... ) ;",
+                      tokenizeAndStringify("[[gnu::format(printf, 1, 2)]] [[noreturn]] void func5(const char*, ...);"));
+
+        ASSERT_EQUALS("int func1 ( ) ;",
+                      tokenizeAndStringify("[[nodiscard]] int func1();"));
+
+        ASSERT_EQUALS("int func1 ( ) ;",
+                      tokenizeAndStringify("[[nodiscard]] [[clang::optnone]] int func1();"));
+
+        ASSERT_EQUALS("int func1 ( ) ;",
+                      tokenizeAndStringify("[[clang::optnone]] [[nodiscard]] int func1();"));
+
+        const Settings s = settingsBuilder(settings1).c(Standards::C23).build();
+        ASSERT_EQUALS("void f ( int i ) { exit ( i ) ; }",
+                      tokenizeAndStringify("[[noreturn]] void f(int i) { exit(i); }", s, false));
     }
 
     void simplifyCaseRange() {
-        ASSERT_EQUALS("void f ( ) { switch ( x ) { case 1 : case 2 : case 3 : case 4 : ; } }", tokenizeAndStringify("void f() { switch(x) { case 1 ... 4: } }"));
-        ASSERT_EQUALS("void f ( ) { switch ( x ) { case 4 ... 1 : ; } }", tokenizeAndStringify("void f() { switch(x) { case 4 ... 1: } }"));
-        tokenizeAndStringify("void f() { switch(x) { case 1 ... 1000000: } }"); // Do not run out of memory
+        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case 1 : case 2 : case 3 : case 4 : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case 1 ... 4: } }"));
+        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case 4 ... 1 : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case 4 ... 1: } }"));
+        (void)tokenizeAndStringify("void f(int x) { switch(x) { case 1 ... 1000000: } }"); // Do not run out of memory
+
+        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case 'a' : case 98 : case 'c' : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case 'a' ... 'c': } }"));
+        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case 'c' ... 'a' : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case 'c' ... 'a': } }"));
+
+        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case '[' : case 92 : case ']' : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case '[' ... ']': } }"));
 
-        ASSERT_EQUALS("void f ( ) { switch ( x ) { case 'a' : case 'b' : case 'c' : ; } }", tokenizeAndStringify("void f() { switch(x) { case 'a' ... 'c': } }"));
-        ASSERT_EQUALS("void f ( ) { switch ( x ) { case 'c' ... 'a' : ; } }", tokenizeAndStringify("void f() { switch(x) { case 'c' ... 'a': } }"));
+        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case '&' : case 39 : case '(' : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case '&' ... '(': } }"));
+        ASSERT_EQUALS("void f ( int x ) { switch ( x ) { case '\\x61' : case 98 : case '\\x63' : ; } }", tokenizeAndStringify("void f(int x) { switch(x) { case '\\x61' ... '\\x63': } }"));
+    }
 
-        ASSERT_EQUALS("void f ( ) { switch ( x ) { case '[' : case '\\\\' : case ']' : ; } }", tokenizeAndStringify("void f() { switch(x) { case '[' ... ']': } }"));
+    void simplifyEmptyNamespaces() {
+        ASSERT_EQUALS(";", tokenizeAndStringify("namespace { }"));
+        ASSERT_EQUALS(";", tokenizeAndStringify("namespace foo { }"));
+        ASSERT_EQUALS(";", tokenizeAndStringify("namespace foo { namespace { } }"));
+        ASSERT_EQUALS(";", tokenizeAndStringify("namespace { namespace { } }")); // Ticket #9512
+        ASSERT_EQUALS(";", tokenizeAndStringify("namespace foo { namespace bar { } }"));
     }
 
     void prepareTernaryOpForAST() {
@@ -7128,47 +6445,66 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("a ? ( b < c ) : d > e", tokenizeAndStringify("a ? b < c : d > e"));
     }
 
-    std::string testAst(const char code[],bool verbose=false) {
+    enum class AstStyle : std :: uint8_t {
+        Simple,
+        Z3
+    };
+
+    enum class ListSimplification : std::uint8_t {
+        Partial,
+        Full
+    };
+
+    template<size_t size>
+    std::string testAst(const char (&data)[size], AstStyle style = AstStyle::Simple, ListSimplification ls = ListSimplification::Partial) {
         // tokenize given code..
-        Tokenizer tokenList(&settings0, nullptr);
-        std::istringstream istr(code);
-        if (!tokenList.list.createTokens(istr,"test.cpp"))
+        TokenList tokenlist{settingsDefault, Standards::Language::CPP};
+        tokenlist.appendFileIfNew("test.cpp");
+        if (!tokenlist.createTokensFromString(data))
             return "ERROR";
 
-        tokenList.combineStringAndCharLiterals();
-        tokenList.combineOperators();
-        tokenList.createLinks();
-        tokenList.createLinks2();
+        TokenizerTest tokenizer(std::move(tokenlist), *this);
+        if (ls == ListSimplification::Partial) {
+            tokenizer.combineStringAndCharLiterals();
+            tokenizer.combineOperators();
+            tokenizer.simplifySpaceshipOperator();
+            tokenizer.createLinks();
+            tokenizer.createLinks2();
+            tokenizer.simplifyCAlternativeTokens();
+            tokenizer.list.front()->assignIndexes();
+        } else { // Full
+            tokenizer.simplifyTokens1("");
+        }
 
         // set varid..
-        for (Token *tok = tokenList.list.front(); tok; tok = tok->next()) {
+        for (Token *tok = tokenizer.list.front(); tok; tok = tok->next()) {
             if (tok->str() == "var")
                 tok->varId(1);
         }
 
         // Create AST..
-        tokenList.prepareTernaryOpForAST();
-        tokenList.list.createAst();
+        tokenizer.prepareTernaryOpForAST();
+        tokenizer.list.createAst();
 
-        tokenList.list.validateAst();
+        tokenizer.list.validateAst(false);
 
         // Basic AST validation
-        for (const Token *tok = tokenList.list.front(); tok; tok = tok->next()) {
+        for (const Token *tok = tokenizer.list.front(); tok; tok = tok->next()) {
             if (tok->astOperand2() && !tok->astOperand1() && tok->str() != ";" && tok->str() != ":")
                 return "Op2 but no Op1 for token: " + tok->str();
         }
 
         // Return stringified AST
-        if (verbose)
-            return tokenList.list.front()->astTop()->astStringVerbose();
+        if (style == AstStyle::Z3)
+            return tokenizer.list.front()->astTop()->astStringZ3();
 
         std::string ret;
         std::set<const Token *> astTop;
-        for (const Token *tok = tokenList.list.front(); tok; tok = tok->next()) {
+        for (const Token *tok = tokenizer.list.front(); tok; tok = tok->next()) {
             if (tok->astOperand1() && astTop.find(tok->astTop()) == astTop.end()) {
                 astTop.insert(tok->astTop());
                 if (!ret.empty())
-                    ret = ret + " ";
+                    ret += " ";
                 ret += tok->astTop()->astString();
             }
         }
@@ -7183,6 +6519,7 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("12*34*5*+", testAst("1*2+3*4*5"));
         ASSERT_EQUALS("0(r.&", testAst("(&((typeof(x))0).r);"));
         ASSERT_EQUALS("0(r.&", testAst("&((typeof(x))0).r;"));
+        ASSERT_EQUALS("0f1(||", testAst("; 0 || f(1);"));
 
         // Various tests of precedence
         ASSERT_EQUALS("ab::c+", testAst("a::b+c"));
@@ -7190,6 +6527,7 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("abc=,", testAst("a,b=c"));
         ASSERT_EQUALS("a-1+", testAst("-a+1"));
         ASSERT_EQUALS("ab++-c-", testAst("a-b++-c"));
+        ASSERT_EQUALS("ab<=>", testAst("a<=>b"));
 
         // sizeof
         ASSERT_EQUALS("ab.sizeof", testAst("sizeof a.b"));
@@ -7218,18 +6556,23 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("fabc,de,:?=", testAst("f = (a ? b, c : (d, e));"));
         ASSERT_EQUALS("ab35,4:?foo(:?return", testAst("return (a ? b ? (3,5) : 4 : foo());"));
         ASSERT_EQUALS("check(result_type00,{invalid:?return", testAst("return check() ? result_type {0, 0} : invalid;"));
+        ASSERT_EQUALS("x01:?return", testAst("return x ? 0 : 1;"));
+        ASSERT_EQUALS("x00throw:?return", testAst("return x ? 0 : throw 0;")); // #9768
+        ASSERT_EQUALS("val0<1throwval:?return", testAst("return val < 0 ? throw 1 : val;")); // #8526
+        ASSERT_EQUALS("ix0<00throw:?=", testAst("int i = x < 0 ? 0 : throw 0;"));
+        ASSERT_EQUALS("pa[pb[<1-pa[pb[>:?return", testAst("return p[a] < p[b] ? -1 : p[a] > p[b];"));
 
         ASSERT_EQUALS("a\"\"=", testAst("a=\"\""));
         ASSERT_EQUALS("a\'\'=", testAst("a=\'\'"));
         ASSERT_EQUALS("'X''a'>", testAst("('X' > 'a')"));
-        ASSERT_EQUALS("'X''a'>", testAst("(L'X' > L'a')"));
-        ASSERT_EQUALS("'X''a'>", testAst("(u'X' > u'a')"));
-        ASSERT_EQUALS("'X''a'>", testAst("(U'X' > U'a')"));
-        ASSERT_EQUALS("'X''a'>", testAst("(u8'X' > u8'a')"));
+        ASSERT_EQUALS("L'X'L'a'>", testAst("(L'X' > L'a')"));
+        ASSERT_EQUALS("u'X'u'a'>", testAst("(u'X' > u'a')"));
+        ASSERT_EQUALS("U'X'U'a'>", testAst("(U'X' > U'a')"));
+        ASSERT_EQUALS("u8'X'u8'a'>", testAst("(u8'X' > u8'a')"));
 
         ASSERT_EQUALS("a0>bc/d:?", testAst("(a>0) ? (b/(c)) : d;"));
         ASSERT_EQUALS("abc/+d+", testAst("a + (b/(c)) + d;"));
-        ASSERT_EQUALS("f( x1024x/0:?", testAst("void f() { x ? 1024 / x : 0; }"));
+        ASSERT_EQUALS("x1024x/0:?", testAst("void f() { x ? 1024 / x : 0; }"));
 
         ASSERT_EQUALS("absizeofd(ef.+(=", testAst("a = b(sizeof(c d) + e.f)"));
 
@@ -7250,12 +6593,26 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("fora0=a8<a++;;(", testAst("for(a=0;a<8;a++)"));
         ASSERT_EQUALS("fori1=current0=,iNUM<=i++;;(", testAst("for(i = (1), current = 0; i <= (NUM); ++i)"));
         ASSERT_EQUALS("foreachxy,((", testAst("for(each(x,y)){}"));  // it's not well-defined what this ast should be
+        ASSERT_EQUALS("forvar1(;;(", testAst("for(int var(1);;)"));
         ASSERT_EQUALS("forab:(", testAst("for (int a : b);"));
-        ASSERT_EQUALS("forab:(", testAst("for (int *a : b);"));
-        ASSERT_EQUALS("forcd:(", testAst("for (a<b> c : d);"));
-        ASSERT_EQUALS("forde:(", testAst("for (a::b<c> d : e);"));
+        ASSERT_EQUALS("forvarb:(", testAst("for (int *var : b);"));
+        ASSERT_EQUALS("forvard:(", testAst("for (a<b> var : d);"));
+        ASSERT_EQUALS("forvare:(", testAst("for (a::b<c> var : e);"));
         ASSERT_EQUALS("forx*0=yz;;(", testAst("for(*x=0;y;z)"));
         ASSERT_EQUALS("forx0=y(8<z;;(", testAst("for (x=0;(int)y<8;z);"));
+        ASSERT_EQUALS("forab,c:(", testAst("for (auto [a,b]: c);"));
+        ASSERT_EQUALS("fora*++;;(", testAst("for (++(*a);;);"));
+        ASSERT_EQUALS("foryz:(", testAst("for (decltype(x) *y : z);"));
+        ASSERT_EQUALS("for(tmpNULL!=tmptmpnext.=;;( tmpa=", testAst("for ( ({ tmp = a; }) ; tmp != NULL; tmp = tmp->next ) {}"));
+        ASSERT_EQUALS("forx0=x;;(", testAst("for (int x=0; x;);"));
+        ASSERT_EQUALS("forae*bc.({:(", testAst("for (a *e : {b->c()});"));
+        ASSERT_EQUALS("fori0=iasize.(<i++;;( asize.(", testAst("for (decltype(a.size()) i = 0; i < a.size(); ++i);"));
+        ASSERT_EQUALS("foria:( asize.(", testAst("for(decltype(a.size()) i:a);"));
+        ASSERT_EQUALS("forec0{([,(:( fb.return", testAst("for (auto e : c(0, [](auto f) { return f->b; }));")); // #10802
+        ASSERT_EQUALS("forvar1{;;(", testAst("for(int var{1};;)")); // #12867
+
+        // for with initializer (c++20)
+        ASSERT_EQUALS("forab=ca:;(", testAst("for(a=b;int c:a)"));
 
         // problems with multiple expressions
         ASSERT_EQUALS("ax( whilex(", testAst("a(x) while (x)"));
@@ -7268,8 +6625,12 @@ class TestTokenizer : public TestFixture {
 
         ASSERT_EQUALS("catch...(", testAst("try {} catch (...) {}"));
 
-        ASSERT_EQUALS("FooBar(", testAst("void Foo(Bar&);"));
-        ASSERT_EQUALS("FooBar(", testAst("void Foo(Bar& &);")); // Rvalue reference - simplified from && to & & by real tokenizer
+        ASSERT_EQUALS("", testAst("void Foo(Bar&);"));
+        ASSERT_EQUALS("", testAst("void Foo(Bar&&);"));
+
+        ASSERT_EQUALS("Barb&", testAst("void Foo(Bar& b);"));
+        ASSERT_EQUALS("Barb&&", testAst("void Foo(Bar&& b);"));
+
         ASSERT_EQUALS("DerivedDerived::(", testAst("Derived::~Derived() {}"));
 
         ASSERT_EQUALS("ifCA_FarReadfilenew(,sizeofobjtype(,(!(", testAst("if (!CA_FarRead(file, (void far *)new, sizeof(objtype)))")); // #5910 - don't hang if C code is parsed as C++
@@ -7277,70 +6638,147 @@ class TestTokenizer : public TestFixture {
         // C++17: if (expr1; expr2)
         ASSERT_EQUALS("ifx3=y;(", testAst("if (int x=3; y)"));
 
-        ASSERT_EQUALS("forx0=x;;(", testAst("for (int x=0; x;);"));
+        ASSERT_EQUALS("xstdstring::decltypes(a::{=", testAst("auto x = std::string{ decltype(s)::a };"));
+        ASSERT_EQUALS("if0decltypest.(X::>(", testAst("if (0 > decltype(s.t)::X) {}"));
     }
 
     void astexpr2() { // limit for large expressions
         // #7724 - wrong AST causes hang
         // Ideally a proper AST is created for this code.
-        const char code[] = "const char * a(int type) {\n"
-                            "  return (\n"
-                            "   (type == 1) ? \"\"\n"
-                            " : (type == 2) ? \"\"\n"
-                            " : (type == 3) ? \"\"\n"
-                            " : (type == 4) ? \"\"\n"
-                            " : (type == 5) ? \"\"\n"
-                            " : (type == 6) ? \"\"\n"
-                            " : (type == 7) ? \"\"\n"
-                            " : (type == 8) ? \"\"\n"
-                            " : (type == 9) ? \"\"\n"
-                            " : (type == 10) ? \"\"\n"
-                            " : (type == 11) ? \"\"\n"
-                            " : (type == 12) ? \"\"\n"
-                            " : (type == 13) ? \"\"\n"
-                            " : (type == 14) ? \"\"\n"
-                            " : (type == 15) ? \"\"\n"
-                            " : (type == 16) ? \"\"\n"
-                            " : (type == 17) ? \"\"\n"
-                            " : (type == 18) ? \"\"\n"
-                            " : (type == 19) ? \"\"\n"
-                            " : (type == 20) ? \"\"\n"
-                            " : (type == 21) ? \"\"\n"
-                            " : (type == 22) ? \"\"\n"
-                            " : (type == 23) ? \"\"\n"
-                            " : (type == 24) ? \"\"\n"
-                            " : (type == 25) ? \"\"\n"
-                            " : (type == 26) ? \"\"\n"
-                            " : (type == 27) ? \"\"\n"
-                            " : (type == 28) ? \"\"\n"
-                            " : (type == 29) ? \"\"\n"
-                            " : (type == 30) ? \"\"\n"
-                            " : (type == 31) ? \"\"\n"
-                            " : (type == 32) ? \"\"\n"
-                            " : (type == 33) ? \"\"\n"
-                            " : (type == 34) ? \"\"\n"
-                            " : (type == 35) ? \"\"\n"
-                            " : (type == 36) ? \"\"\n"
-                            " : (type == 37) ? \"\"\n"
-                            " : (type == 38) ? \"\"\n"
-                            " : (type == 39) ? \"\"\n"
-                            " : (type == 40) ? \"\"\n"
-                            " : (type == 41) ? \"\"\n"
-                            " : (type == 42) ? \"\"\n"
-                            " : (type == 43) ? \"\"\n"
-                            " : (type == 44) ? \"\"\n"
-                            " : (type == 45) ? \"\"\n"
-                            " : (type == 46) ? \"\"\n"
-                            " : (type == 47) ? \"\"\n"
-                            " : (type == 48) ? \"\"\n"
-                            " : (type == 49) ? \"\"\n"
-                            " : (type == 50) ? \"\"\n"
-                            " : (type == 51) ? \"\"\n"
-                            " : \"\");\n"
-                            "}\n";
+        const char code1[] = "const char * a(int type) {\n"
+                             "  return (\n"
+                             "   (type == 1) ? \"\"\n"
+                             " : (type == 2) ? \"\"\n"
+                             " : (type == 3) ? \"\"\n"
+                             " : (type == 4) ? \"\"\n"
+                             " : (type == 5) ? \"\"\n"
+                             " : (type == 6) ? \"\"\n"
+                             " : (type == 7) ? \"\"\n"
+                             " : (type == 8) ? \"\"\n"
+                             " : (type == 9) ? \"\"\n"
+                             " : (type == 10) ? \"\"\n"
+                             " : (type == 11) ? \"\"\n"
+                             " : (type == 12) ? \"\"\n"
+                             " : (type == 13) ? \"\"\n"
+                             " : (type == 14) ? \"\"\n"
+                             " : (type == 15) ? \"\"\n"
+                             " : (type == 16) ? \"\"\n"
+                             " : (type == 17) ? \"\"\n"
+                             " : (type == 18) ? \"\"\n"
+                             " : (type == 19) ? \"\"\n"
+                             " : (type == 20) ? \"\"\n"
+                             " : (type == 21) ? \"\"\n"
+                             " : (type == 22) ? \"\"\n"
+                             " : (type == 23) ? \"\"\n"
+                             " : (type == 24) ? \"\"\n"
+                             " : (type == 25) ? \"\"\n"
+                             " : (type == 26) ? \"\"\n"
+                             " : (type == 27) ? \"\"\n"
+                             " : (type == 28) ? \"\"\n"
+                             " : (type == 29) ? \"\"\n"
+                             " : (type == 30) ? \"\"\n"
+                             " : (type == 31) ? \"\"\n"
+                             " : (type == 32) ? \"\"\n"
+                             " : (type == 33) ? \"\"\n"
+                             " : (type == 34) ? \"\"\n"
+                             " : (type == 35) ? \"\"\n"
+                             " : (type == 36) ? \"\"\n"
+                             " : (type == 37) ? \"\"\n"
+                             " : (type == 38) ? \"\"\n"
+                             " : (type == 39) ? \"\"\n"
+                             " : (type == 40) ? \"\"\n"
+                             " : (type == 41) ? \"\"\n"
+                             " : (type == 42) ? \"\"\n"
+                             " : (type == 43) ? \"\"\n"
+                             " : (type == 44) ? \"\"\n"
+                             " : (type == 45) ? \"\"\n"
+                             " : (type == 46) ? \"\"\n"
+                             " : (type == 47) ? \"\"\n"
+                             " : (type == 48) ? \"\"\n"
+                             " : (type == 49) ? \"\"\n"
+                             " : (type == 50) ? \"\"\n"
+                             " : (type == 51) ? \"\"\n"
+                             " : \"\");\n"
+                             "}\n";
         // Ensure that the AST is validated for the simplified token list
-        tokenizeAndStringify(code); // this does not crash/hang
-        ASSERT_THROW(tokenizeAndStringify(code,true), InternalError); // when parentheses are simplified the AST will be wrong
+        TODO_ASSERT_THROW(tokenizeAndStringify(code1), InternalError); // this should not crash/hang
+
+        const char code2[] = "template<uint64_t kInput>\n" // #11515
+                             "struct ConstCTZ {\n"
+                             "    static constexpr uint32_t value =\n"
+                             "        (kInput & (uint64_t(1) << 0)) ? 0 :\n"
+                             "        (kInput & (uint64_t(1) << 1)) ? 1 :\n"
+                             "        (kInput & (uint64_t(1) << 2)) ? 2 :\n"
+                             "        (kInput & (uint64_t(1) << 3)) ? 3 :\n"
+                             "        (kInput & (uint64_t(1) << 4)) ? 4 :\n"
+                             "        (kInput & (uint64_t(1) << 5)) ? 5 :\n"
+                             "        (kInput & (uint64_t(1) << 6)) ? 6 :\n"
+                             "        (kInput & (uint64_t(1) << 7)) ? 7 :\n"
+                             "        (kInput & (uint64_t(1) << 8)) ? 8 :\n"
+                             "        (kInput & (uint64_t(1) << 9)) ? 9 :\n"
+                             "        (kInput & (uint64_t(1) << 10)) ? 10 :\n"
+                             "        (kInput & (uint64_t(1) << 11)) ? 11 :\n"
+                             "        (kInput & (uint64_t(1) << 12)) ? 12 :\n"
+                             "        (kInput & (uint64_t(1) << 13)) ? 13 :\n"
+                             "        (kInput & (uint64_t(1) << 14)) ? 14 :\n"
+                             "        (kInput & (uint64_t(1) << 15)) ? 15 :\n"
+                             "        (kInput & (uint64_t(1) << 16)) ? 16 :\n"
+                             "        (kInput & (uint64_t(1) << 17)) ? 17 :\n"
+                             "        (kInput & (uint64_t(1) << 18)) ? 18 :\n"
+                             "        (kInput & (uint64_t(1) << 19)) ? 19 :\n"
+                             "        (kInput & (uint64_t(1) << 20)) ? 20 :\n"
+                             "        (kInput & (uint64_t(1) << 21)) ? 21 :\n"
+                             "        (kInput & (uint64_t(1) << 22)) ? 22 :\n"
+                             "        (kInput & (uint64_t(1) << 23)) ? 23 :\n"
+                             "        (kInput & (uint64_t(1) << 24)) ? 24 :\n"
+                             "        (kInput & (uint64_t(1) << 25)) ? 25 :\n"
+                             "        (kInput & (uint64_t(1) << 26)) ? 26 :\n"
+                             "        (kInput & (uint64_t(1) << 27)) ? 27 :\n"
+                             "        (kInput & (uint64_t(1) << 28)) ? 28 :\n"
+                             "        (kInput & (uint64_t(1) << 29)) ? 29 :\n"
+                             "        (kInput & (uint64_t(1) << 30)) ? 30 :\n"
+                             "        (kInput & (uint64_t(1) << 31)) ? 31 :\n"
+                             "        (kInput & (uint64_t(1) << 32)) ? 32 :\n"
+                             "        (kInput & (uint64_t(1) << 33)) ? 33 :\n"
+                             "        (kInput & (uint64_t(1) << 34)) ? 34 :\n"
+                             "        (kInput & (uint64_t(1) << 35)) ? 35 :\n"
+                             "        (kInput & (uint64_t(1) << 36)) ? 36 :\n"
+                             "        (kInput & (uint64_t(1) << 37)) ? 37 :\n"
+                             "        (kInput & (uint64_t(1) << 38)) ? 38 :\n"
+                             "        (kInput & (uint64_t(1) << 39)) ? 39 :\n"
+                             "        (kInput & (uint64_t(1) << 40)) ? 40 :\n"
+                             "        (kInput & (uint64_t(1) << 41)) ? 41 :\n"
+                             "        (kInput & (uint64_t(1) << 42)) ? 42 :\n"
+                             "        (kInput & (uint64_t(1) << 43)) ? 43 :\n"
+                             "        (kInput & (uint64_t(1) << 44)) ? 44 :\n"
+                             "        (kInput & (uint64_t(1) << 45)) ? 45 :\n"
+                             "        (kInput & (uint64_t(1) << 46)) ? 46 :\n"
+                             "        (kInput & (uint64_t(1) << 47)) ? 47 :\n"
+                             "        (kInput & (uint64_t(1) << 48)) ? 48 :\n"
+                             "        (kInput & (uint64_t(1) << 49)) ? 49 :\n"
+                             "        (kInput & (uint64_t(1) << 50)) ? 50 :\n"
+                             "        (kInput & (uint64_t(1) << 51)) ? 51 :\n"
+                             "        (kInput & (uint64_t(1) << 52)) ? 52 :\n"
+                             "        (kInput & (uint64_t(1) << 53)) ? 53 :\n"
+                             "        (kInput & (uint64_t(1) << 54)) ? 54 :\n"
+                             "        (kInput & (uint64_t(1) << 55)) ? 55 :\n"
+                             "        (kInput & (uint64_t(1) << 56)) ? 56 :\n"
+                             "        (kInput & (uint64_t(1) << 57)) ? 57 :\n"
+                             "        (kInput & (uint64_t(1) << 58)) ? 58 :\n"
+                             "        (kInput & (uint64_t(1) << 59)) ? 59 :\n"
+                             "        (kInput & (uint64_t(1) << 60)) ? 60 :\n"
+                             "        (kInput & (uint64_t(1) << 61)) ? 61 :\n"
+                             "        (kInput & (uint64_t(1) << 62)) ? 62 :\n"
+                             "        (kInput & (uint64_t(1) << 63)) ? 63 : 64;\n"
+                             "};\n";
+        ASSERT_NO_THROW(tokenizeAndStringify(code2));
+
+        const char code3[] = "void f(const std::vector<int>& v) {\n" // #12569
+                             "    ::std::for_each(v.begin(), v.end(), [](int i) {\n"
+                             "        int j(i ? i : 5);\n"
+                             "    });\n"
+                             "}\n";
+        ASSERT_NO_THROW(tokenizeAndStringify(code3));
     }
 
     void astnewdelete() {
@@ -7349,17 +6787,40 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("aFoobar(new=", testAst("a = new Foo(bar);"));
         ASSERT_EQUALS("aFoobar(new=", testAst("a = new Foo(bar);"));
         ASSERT_EQUALS("aFoo(new=", testAst("a = new Foo<bar>();"));
-        ASSERT_EQUALS("X12,3,(new", testAst("new (a,b,c) X(1,2,3);"));
         ASSERT_EQUALS("aXnew(", testAst("a (new (X));"));
         ASSERT_EQUALS("aXnew5,(", testAst("a (new (X), 5);"));
         ASSERT_EQUALS("adelete", testAst("delete a;"));
         ASSERT_EQUALS("adelete", testAst("delete (a);"));
         ASSERT_EQUALS("adelete", testAst("delete[] a;"));
         ASSERT_EQUALS("ab.3c-(delete", testAst("delete[] a.b(3 - c);"));
-        ASSERT_EQUALS("a::new=", testAst("a = new (b) ::X;"));
         ASSERT_EQUALS("aA1(new(bB2(new(,", testAst("a(new A(1)), b(new B(2))"));
         ASSERT_EQUALS("Fred10[new", testAst(";new Fred[10];"));
-        ASSERT_EQUALS("f( adelete", testAst("void f() { delete a; }"));
+        ASSERT_EQUALS("adelete", testAst("void f() { delete a; }"));
+        ASSERT_EQUALS("Aa*A{new=", testAst("A* a = new A{};"));
+        ASSERT_EQUALS("Aa*A12,{new=", testAst("A* a = new A{ 1, 2 };"));
+        ASSERT_EQUALS("Sv0[(new", testAst("new S(v[0]);")); // #10929
+        ASSERT_EQUALS("SS::x(px0>intx[{newint1[{new:?(:", testAst("S::S(int x) : p(x > 0 ? new int[x]{} : new int[1]{}) {}")); // #10793
+        ASSERT_EQUALS("a0[T{new=", testAst("a[0] = new T{};"));
+        ASSERT_EQUALS("a0[T::{new=", testAst("a[0] = new ::T{};"));
+        ASSERT_EQUALS("a0[ST::{new=", testAst("a[0] = new S::T{};"));
+        ASSERT_EQUALS("intnewdelete", testAst("delete new int;")); // #11039
+        ASSERT_EQUALS("intnewdelete", testAst("void f() { delete new int; }"));
+        ASSERT_EQUALS("pint3[new1+=", testAst("p = (new int[3]) + 1;")); // #11327
+        ASSERT_EQUALS("aType2[T1T2,{new=", testAst("a = new Type *[2] {T1, T2};")); // #11745
+        ASSERT_EQUALS("pSthis(new=", testAst("p = new S*(this);")); // #10809
+        ASSERT_EQUALS("pint0{new=", testAst("p = new int*{ 0 };"));
+        ASSERT_EQUALS("pint5[{new=", testAst("p = new int* [5]{};"));
+        ASSERT_EQUALS("pint5[0{new=", testAst("p = new int* [5]{ 0 };"));
+        ASSERT_EQUALS("sSint(new::(new=", testAst("s = new S(::new int());")); // #12502
+        ASSERT_EQUALS("sS(new::=", testAst("s = ::new (ptr) S();")); // #12552
+        ASSERT_EQUALS("pdelete::return", testAst("return ::delete p;"));
+        ASSERT_EQUALS("gn--(delete", testAst("delete g(--n);"));
+        ASSERT_EQUALS("bdeletep1*p0*,deletep0*p1*,:?*return", testAst("return *(b ? (delete *p1, *p0) : (delete *p0, *p1));")); // #10662
+
+        // placement new
+        ASSERT_EQUALS("X12,3,(new ab,c,", testAst("new (a,b,c) X(1,2,3);"));
+        ASSERT_EQUALS("aX::new=", testAst("a = new (b) ::X;"));
+        ASSERT_EQUALS("cCnew= abc:?", testAst("c = new(a ? b : c) C;"));
 
         // invalid code (libreoffice), don't hang
         // #define SlideSorterViewShell
@@ -7389,6 +6850,8 @@ class TestTokenizer : public TestFixture {
 
         ASSERT_EQUALS("pf.pf.12,(&&", testAst("((p.f) && (p.f)(1,2))"));
 
+        ASSERT_EQUALS("forresdirGetFirst.file&_T(,(=;;(", testAst("for ((res = dir.GetFirst(&file, _T(" ")));;) {}"));
+
         // problems with: if (x[y]==z)
         ASSERT_EQUALS("ifa(0[1==(", testAst("if(a()[0]==1){}"));
         ASSERT_EQUALS("ifbuff0[&(*1==(", testAst("if (*((DWORD*)&buff[0])==1){}"));
@@ -7399,15 +6862,8 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("ab.i[j1+[", testAst("a.b[i][j+1]"));
 
         // problems with: x=expr
-        ASSERT_EQUALS("=\n"
-                      "|-x\n"
-                      "`-(\n"
-                      "  `-.\n"
-                      "    |-[\n"
-                      "    | |-a\n"
-                      "    | `-i\n"
-                      "    `-f\n",
-                      testAst("x = ((a[i]).f)();", true));
+        ASSERT_EQUALS("(= x (( (. ([ a i) f)))",
+                      testAst("x = ((a[i]).f)();", AstStyle::Z3));
         ASSERT_EQUALS("abc.de.++[=", testAst("a = b.c[++(d.e)];"));
         ASSERT_EQUALS("abc(1+=", testAst("a = b(c**)+1;"));
         ASSERT_EQUALS("abc.=", testAst("a = (b).c;"));
@@ -7417,33 +6873,43 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("a1(2+=",testAst("a=(t)1+2;"));
         ASSERT_EQUALS("a1(2+=",testAst("a=(t*)1+2;"));
         ASSERT_EQUALS("a1(2+=",testAst("a=(t&)1+2;"));
+        ASSERT_EQUALS("a1(2+=",testAst("a=(t&&)1+2;"));
         ASSERT_EQUALS("ab::r&c(=", testAst("a::b& r = (a::b&)c;")); // #5261
         ASSERT_EQUALS("ab10:?=", testAst("a=(b)?1:0;"));
         ASSERT_EQUALS("ac5[new(=", testAst("a = (b*)(new c[5]);")); // #8786
         ASSERT_EQUALS("a(4+", testAst("(int)(a) + 4;"));
 
-        // TODO: This AST is incomplete however it's very weird syntax (taken from clang test suite)
-        ASSERT_EQUALS("a&(", testAst("(int (**)[i]){&a}[0][1][5] = 0;"));
-        ASSERT_EQUALS("n0=", testAst("TrivialDefCtor{[2][2]}[1][1].n = 0;"));
+        // (cast){data}[index]
+        ASSERT_EQUALS("a&{(0[1[5[0=", testAst("(int (**)[i]){&a}[0][1][5] = 0;"));
+        ASSERT_EQUALS("ab12,{(0[,(", testAst("a(b, (int []){1,2}[0]);"));
+        ASSERT_EQUALS("TrivialDefCtora2[2[{1[1[n.0=", testAst("TrivialDefCtor{a[2][2]}[1][1].n = 0;"));
         ASSERT_EQUALS("aT12,3,{1[=", testAst("a = T{1, 2, 3}[1];"));
 
+        // Type{data}()
+        ASSERT_EQUALS("ab{(=", testAst("a=b{}();"));
+        ASSERT_EQUALS("abc{((=", testAst("a=b(c{}());"));
+        ASSERT_EQUALS("xNULL!=0(x(:?", testAst("void f() { {} ((x != NULL) ? (void)0 : x()); }"));
+
         // ({..})
         ASSERT_EQUALS("a{+d+ bc+", testAst("a+({b+c;})+d"));
         ASSERT_EQUALS("a{d*+ bc+", testAst("a+({b+c;})*d"));
         ASSERT_EQUALS("xa{((= bc( yd{((= ef(",
                       testAst("x=(int)(a({b(c);}));" // don't hang
                               "y=(int)(d({e(f);}));"));
-        ASSERT_EQUALS("QT_WA{{,( x0= QT_WA{{,( x1= x2=",
-                      testAst("QT_WA({},{x=0;});" // don't hang
-                              "QT_WA({x=1;},{x=2;});"));
+        ASSERT_EQUALS("A{{,( x0= Bx1={x2={,(",  // TODO: This is not perfect!!
+                      testAst("A({},{x=0;});" // don't hang
+                              "B({x=1},{x=2});"));
         ASSERT_EQUALS("xMACROtype.T=value.1=,{({=",
                       testAst("x = { MACRO( { .type=T, .value=1 } ) }")); // don't hang: MACRO({..})
         ASSERT_EQUALS("fori10=i{;;( i--", testAst("for (i=10;i;({i--;}) ) {}"));
+        ASSERT_EQUALS("c{1{,{2.3f{,(",
+                      testAst("c({{}, {1}}, {2.3f});"));
+        ASSERT_EQUALS("x{{= e0= assert0(", testAst("x = {({ int e = 0; assert(0); e; })};"));
 
         // function pointer
         TODO_ASSERT_EQUALS("todo", "va_argapvoid((,(*0=", testAst("*va_arg(ap, void(**) ()) = 0;"));
 
-        // struct initialization
+        // struct/array initialization
         ASSERT_EQUALS("name_bytes[bits~unusedBits>>unusedBits<<{=", testAst("const uint8_t name_bytes[] = { (~bits >> unusedBits) << unusedBits };"));
         ASSERT_EQUALS("abuf.0{={=", testAst("a = { .buf = { 0 } };"));
         ASSERT_EQUALS("ab2[a.0=b.0=,{a.0=b.0=,{,{=", testAst("struct AB ab[2] = { { .a=0, .b=0 }, { .a=0, .b=0 } };"));
@@ -7454,14 +6920,19 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("xB[1y.z.1={(&=,{={=", testAst("x = { [B] = {1, .y = &(struct s) { .z=1 } } };"));
         ASSERT_EQUALS("xab,c,{=", testAst("x={a,b,(c)};"));
         ASSERT_EQUALS("x0fSa.1=b.2=,c.\"\"=,{(||=", testAst("x = 0 || f(S{.a = 1, .b = 2, .c = \"\" });"));
+        ASSERT_EQUALS("x0fSa.1{=b.2{,c.\"\"=,{(||=", testAst("x = 0 || f(S{.a = { 1 }, .b { 2 }, .c = \"\" });"));
+        ASSERT_EQUALS("a0\"\"abc12:?,{{,(", testAst("a(0, {{\"\", (abc) ? 1 : 2}});"));
+        ASSERT_EQUALS("a0\'\'abc12:?,{{,(", testAst("a(0, {{\'\', (abc) ? 1 : 2}});"));
+        ASSERT_EQUALS("x12,{34,{,{56,{78,{,{,{=", testAst("x = { { {1,2}, {3,4} }, { {5,6}, {7,8} } };"));
+        ASSERT_EQUALS("Sa.stdmove::s(=b.1=,{(", testAst("S({.a = std::move(s), .b = 1})"));
 
         // struct initialization hang
-        ASSERT_EQUALS("sbar.1{,{(={= fcmd( forfieldfield++;;(",
+        ASSERT_EQUALS("sbar.1{,{(={= forfieldfield++;;(",
                       testAst("struct S s = {.bar = (struct foo) { 1, { } } };\n"
                               "void f(struct cmd *) { for (; field; field++) {} }"));
 
         // template parentheses: <>
-        ASSERT_EQUALS("stdfabs::m_similarity(numeric_limitsepsilon::(<=return", testAst("return std::fabs(m_similarity) <= numeric_limits<double>::epsilon();")); // #6195
+        ASSERT_EQUALS("ab::c(de::(<=return", testAst("return a::b(c) <= d<double>::e();")); // #6195
 
         // C++ initializer
         ASSERT_EQUALS("Class{", testAst("Class{};"));
@@ -7475,6 +6946,79 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("Abc({newreturn", testAst("return new A {b(c)};"));
         ASSERT_EQUALS("a{{return", testAst("return{{a}};"));
         ASSERT_EQUALS("a{b{,{return", testAst("return{{a},{b}};"));
+        ASSERT_EQUALS("stdvector::{{,{return", testAst("return std::vector<std::vector<int> >{{},{}};"));
+        ASSERT_EQUALS("stdvector::{2{,{return", testAst("return std::vector<std::vector<int> >{{}, {2}};"));
+        ASSERT_EQUALS("forbstdvector::{{,{:(", testAst("for (auto b : std::vector<std::vector<int> >{{},{}});"));
+        ASSERT_EQUALS("forbstdvector::{2{,{:(", testAst("for (auto b : std::vector<std::vector<int> >{{}, {2}});"));
+        ASSERT_EQUALS("abR{{,P(,((", testAst("a(b(R{},{},P()));"));
+        ASSERT_EQUALS("f1{2{,3{,{x,(", testAst("f({{1},{2},{3}},x);"));
+        ASSERT_EQUALS("a1{ b2{", testAst("auto a{1}; auto b{2};"));
+        ASSERT_EQUALS("var1ab::23,{,{4ab::56,{,{,{", testAst("auto var{{1,a::b{2,3}}, {4,a::b{5,6}}};"));
+        ASSERT_EQUALS("var{{,{{,{", testAst("auto var{ {{},{}}, {} };"));
+        ASSERT_EQUALS("fXYabcfalse==CD:?,{,{(", testAst("f({X, {Y, abc == false ? C : D}});"));
+        ASSERT_EQUALS("stdvector::p0[{(return", testAst("return std::vector<int>({ p[0] });"));
+        ASSERT_EQUALS("vstdvector::{=", testAst("auto v = std::vector<int>{ };"));
+
+        // Initialization with decltype(expr) instead of a type
+        ASSERT_EQUALS("decltypex((", testAst("decltype(x)();"));
+        ASSERT_EQUALS("decltypex({", testAst("decltype(x){};"));
+        ASSERT_EQUALS("decltypexy+(yx+(", testAst("decltype(x+y)(y+x);"));
+        ASSERT_EQUALS("decltypexy+(yx+{", testAst("decltype(x+y){y+x};"));
+        ASSERT_EQUALS("adecltypeac::(,decltypead::(,",
+                      testAst("template <typename a> void b(a &, decltype(a::c), decltype(a::d));"));
+
+        ASSERT_NO_THROW(tokenizeAndStringify("struct A;\n" // #10839
+                                             "struct B { A* hash; };\n"
+                                             "auto g(A* a) { return [=](void*) { return a; }; }\n"
+                                             "void f(void* p, B* b) {\n"
+                                             "    b->hash = (g(b->hash))(p);\n"
+                                             "}\n"));
+        ignore_errout();
+        ASSERT_NO_THROW(tokenizeAndStringify("struct A;\n"
+                                             "struct B { A* hash; };\n"
+                                             "A* h(void* p);\n"
+                                             "typedef A* (*X)(void*);\n"
+                                             "X g(A*) { return h; }\n"
+                                             "void f(void* p, B * b) {\n"
+                                             "b->hash = (g(b->hash))(p);\n"
+                                             "}\n"));
+        ASSERT_EQUALS("", errout_str());
+        ASSERT_NO_THROW(tokenizeAndStringify("struct A;\n"
+                                             "struct B { A* hash; };\n"
+                                             "void f(void* p, B* b) {\n"
+                                             "    b->hash = (decltype(b->hash))(p);\n"
+                                             "}\n"));
+        ASSERT_EQUALS("", errout_str());
+
+        ASSERT_NO_THROW(tokenizeAndStringify("void a(int);\n" // #10801
+                                             "    struct b {\n"
+                                             "    static int c();\n"
+                                             "} d;\n"
+                                             "void f() {\n"
+                                             "    (decltype (&a)(d.c))(0);\n"
+                                             "}\n"));
+        ASSERT_EQUALS("", errout_str());
+
+        // #10334: Do not hang!
+        (void)tokenizeAndStringify("void foo(const std::vector<std::string>& locations = {\"\"}) {\n"
+                                   "    for (int i = 0; i <= 123; ++i)\n"
+                                   "        x->emplace_back(y);\n"
+                                   "}");
+        ignore_errout();
+
+        ASSERT_NO_THROW(tokenizeAndStringify("void f() {\n" // #10831
+                                             "    auto g = [](std::function<void()> h = []() {}) { };\n"
+                                             "}"));
+        ASSERT_EQUALS("", errout_str());
+
+        ASSERT_NO_THROW(tokenizeAndStringify("void f() {\n" // #11379
+                                             "    auto l = [x = 3](std::string&& v) { };\n"
+                                             "}\n"));
+        ASSERT_EQUALS(
+            "[test.cpp:2:15]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable x [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
+
+        ASSERT_EQUALS("forinti(0=i5<=i++;;(", testAst("for (int (i) = 0; (i) <= 5; (i)++) {}")); // #13225
     }
 
     void astbrackets() { // []
@@ -7490,12 +7034,38 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("a1[\"\"=", testAst("char a[1]=\"\";"));
         ASSERT_EQUALS("charp*(3[char5[3[new=", testAst("char (*p)[3] = new char[5][3];"));
         ASSERT_EQUALS("varp=", testAst("const int *var = p;"));
+        ASSERT_EQUALS("intrp0[*(&", testAst("int& r(*p[0]);"));
 
         // #9127
         const char code1[] = "using uno::Ref;\n"
                              "Ref<X> r;\n"
-                             "int x(0);";
-        ASSERT_EQUALS("unoRef:: x0(", testAst(code1));
+                             "int var(0);";
+        ASSERT_EQUALS("unoRef:: var0(", testAst(code1));
+
+        ASSERT_EQUALS("vary=", testAst("std::string var = y;"));
+        ASSERT_EQUALS("vary=", testAst("std::unique_ptr<int> var = y;")); // #14019
+
+        ASSERT_EQUALS("", testAst("void *(*var)(int);"));
+        ASSERT_EQUALS("", testAst("void *(*var[2])(int);"));
+
+
+        // create ast for decltype
+        ASSERT_EQUALS("decltypex( var1=", testAst("decltype(x) var = 1;"));
+        ASSERT_EQUALS("a1bdecltypet((>2,(", testAst("a(1 > b(decltype(t)), 2);")); // #10271
+        ASSERT_EQUALS("decltypex({01:?", testAst("decltype(x){} ? 0 : 1;"));
+
+        ASSERT_EQUALS("Tp* Tt* forctp.=;;( tp.", testAst("struct T { T* p; };\n" // #10874
+                                                         "void f(T * t) {\n"
+                                                         "    for (decltype(t->p) (c) = t->p; ;) {}\n"
+                                                         "}\n"));
+        ASSERT_EQUALS("x0=a, stdtie::a(x=", testAst("int x = 0, a; std::tie(a) = x;\n"));
+        ASSERT_EQUALS("tmpa*=a*b*=,b*tmp=,", testAst("{ ((tmp) = (*a)), ((*a) = (*b)), ((*b) = (tmp)); }"));
+        ASSERT_EQUALS("a(*v=", testAst("(*(volatile unsigned int *)(a) = (v));"));
+        ASSERT_EQUALS("i(j=", testAst("(int&)(i) = j;"));
+
+        ASSERT_EQUALS("", testAst("void f(enum E* var){}"));
+        ASSERT_EQUALS("", testAst("void f(enum E*& var){}"));
+        ASSERT_EQUALS("", testAst("void f(bool& var){}"));
     }
 
     void astunaryop() { // unary operators
@@ -7510,6 +7080,7 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("x(throw", testAst(";throw x();"));
         ASSERT_EQUALS("a*bc:?return", testAst("return *a ? b : c;"));
         ASSERT_EQUALS("xy*--=", testAst("x = -- * y;"));
+        ASSERT_EQUALS("x(throw", testAst(";throw (foo) x;")); // #9955
 
         // Unary :: operator
         ASSERT_EQUALS("abcd::12,(e/:?=", testAst("a = b ? c : ::d(1,2) / e;"));
@@ -7518,6 +7089,9 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("ab4<<c--+1:?", testAst("a ? (b << 4) + --c : 1"));
         ASSERT_EQUALS("ab4<<c--+1:?", testAst("a ? (b << 4) + c-- : 1"));
         ASSERT_EQUALS("ai[i= i--", testAst("a[i]=i; --i;"));
+
+        ASSERT_EQUALS("fint0{1&(", testAst("f(int{ 0 } & 1);")); // #11572
+        ASSERT_EQUALS("int0{1&return", testAst("int g() { return int{ 0 } & 1; }"));
     }
 
     void astfunction() { // function calls
@@ -7525,27 +7099,89 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("1f2(+3+", testAst("1+f(2)+3"));
         ASSERT_EQUALS("1f23,(+4+", testAst("1+f(2,3)+4"));
         ASSERT_EQUALS("1f2a&,(+", testAst("1+f(2,&a)"));
-        ASSERT_EQUALS("fargv[(", testAst("int f(char argv[]);"));
-        ASSERT_EQUALS("fchar(", testAst("extern unsigned f(const char *);"));
-        ASSERT_EQUALS("fcharformat*...,(", testAst("extern void f(const char *format, ...);"));
-        ASSERT_EQUALS("for_each_commit_graftint((void,(", testAst("extern int for_each_commit_graft(int (*)(int*), void *);"));
+        ASSERT_EQUALS("argv[", testAst("int f(char argv[]);"));
+        ASSERT_EQUALS("", testAst("void f();"));
+        ASSERT_EQUALS("", testAst("void f() {}"));
+        ASSERT_EQUALS("", testAst("int f() = delete;"));
+        ASSERT_EQUALS("", testAst("a::b f();"));
+        ASSERT_EQUALS("", testAst("a::b f() {}"));
+        ASSERT_EQUALS("", testAst("a::b f() = delete;"));
+        ASSERT_EQUALS("", testAst("int f() const = delete;"));
+        ASSERT_EQUALS("", testAst("extern unsigned f(const char *);"));
+        ASSERT_EQUALS("charformat*...,", testAst("extern void f(const char *format, ...);"));
+        ASSERT_EQUALS("int(int(void,", testAst("extern int for_each_commit_graft(int (*)(int*), void *);"));
         ASSERT_EQUALS("for;;(", testAst("for (;;) {}"));
         ASSERT_EQUALS("xsizeofvoid(=", testAst("x=sizeof(void*)"));
+        ASSERT_EQUALS("abc{d{,{(=", testAst("a = b({ c{}, d{} });"));
+        ASSERT_EQUALS("abc;(", testAst("a(b;c)"));
+        ASSERT_EQUALS("x{( forbc;;(", testAst("x({ for(a;b;c){} });"));
+        ASSERT_EQUALS("PT.(", testAst("P->~T();"));  // <- The "T" token::function() will be a destructor
+        ASSERT_EQUALS("double&(4[", testAst("void f(double(&)[4]) {}"));
+        ASSERT_EQUALS("voidu*", testAst("int* g ( void* (f) (void*), void* u);")); // #12475
+        ASSERT_EQUALS("f::(", testAst("::f();")); // #12544
+        ASSERT_EQUALS("(( f (, c ({ (= (. x) 0))))", testAst("f(c, { .x = 0 });", AstStyle::Z3)); // #12806
+        ASSERT_EQUALS("(= it (( (. s insert) (, it ({ (, (, (= (. a) i) (= (. b) 2)) (= (. c) 3))))))",
+                      testAst("it = s.insert(it, { .a = i, .b = 2, .c = 3 });", AstStyle::Z3)); // #12815
     }
 
     void asttemplate() { // uninstantiated templates will have <,>,etc..
         ASSERT_EQUALS("a(3==", testAst("a<int>()==3"));
+        ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS("ab(== f(", testAst("a == b<c>(); f();"));
+        ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS("static_casta(i[", testAst("; static_cast<char*>(a)[i];")); // #6203
+        ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS("reinterpret_castreinterpret_castptr(123&(",
                       testAst(";reinterpret_cast<void*>(reinterpret_cast<unsigned>(ptr) & 123);")); // #7253
+        ASSERT_EQUALS("", errout_str());
         ASSERT_EQUALS("bcd.(=", testAst(";a<int> && b = c->d();"));
+        ASSERT_EQUALS("", errout_str());
 
         // This two unit tests were added to avoid a crash. The actual correct AST result for non-executable code has not been determined so far.
-        ASSERT_EQUALS("Cpublica::b:::", testAst("class C : public ::a::b<bool> { };"));
-        ASSERT_EQUALS("AB: f( abc+=", testAst("struct A : public B<C*> { void f() { a=b+c; } };"));
+        ASSERT_NO_THROW(testAst("class C : public ::a::b<bool> { };"));
+        ASSERT_EQUALS("", errout_str());
+        ASSERT_EQUALS("AB: abc+=", testAst("struct A : public B<C*> { void f() { a=b+c; } };"));
+        ASSERT_EQUALS("", errout_str());
 
         ASSERT_EQUALS("xfts(=", testAst("; auto x = f(ts...);"));
+        ASSERT_EQUALS("", errout_str());
+
+        ASSERT_EQUALS("dae(new= ifd(", testAst("template <typename a, typename... b>\n" // #10199
+                                               "void c(b... e) {\n"
+                                               "    a d = new a((e)...);\n"
+                                               "    if (d) {}\n"
+                                               "}\n"));
+        ASSERT_EQUALS("", errout_str());
+
+        ASSERT_EQUALS("ad*astdforward::e((new= ifd(", testAst("struct a {};\n" // #11103
+                                                              "template <class... b> void c(b... e) {\n"
+                                                              "    a* d = new a(std::forward<b>(e)...);\n"
+                                                              "    if (d) {}\n"
+                                                              "}\n"));
+        ASSERT_EQUALS("", errout_str());
+
+        ASSERT_EQUALS("stddir::Args...&&, dir\"abc\"+= dirconcatstdforward::args((+return",
+                      testAst("template <typename ...Args> std::string concat(std::string dir, Args&& ...args) {\n" // #10492
+                              "    dir += \"abc\";\n"
+                              "    return dir + concat(std::forward<Args>(args)...);\n"
+                              "}\n"));
+        ASSERT_EQUALS("", errout_str());
+
+        // #11369
+        ASSERT_NO_THROW(tokenizeAndStringify("int a;\n"
+                                             "template <class> auto b() -> decltype(a) {\n"
+                                             "    if (a) {}\n"
+                                             "}\n"));
+        ignore_errout();
+    }
+
+    void astrequires()
+    {
+        ASSERT_EQUALS("brequires{ac::||= ac::", testAst("template <class a> concept b = requires { a::c; } || a::c;"));
+        ASSERT_EQUALS("crequires{ac::||= a{b{||",
+                      testAst("template <class a, class b> concept c = requires { a{} || b{}; } || a::c;"));
+        ASSERT_EQUALS("ifrequires{(", testAst("if (requires { true; }) {}")); // #13308
+        ASSERT_EQUALS("Crequires({requires({||= sizeofT(4== sizeofT(8==", testAst("concept C = requires() { sizeof(T) == 4; } || requires() { sizeof(T) == 8; };"));
     }
 
     void astcast() {
@@ -7565,6 +7201,14 @@ class TestTokenizer : public TestFixture {
 
         ASSERT_EQUALS("yz.(return", testAst("return (x)(y).z;"));
 
+        ASSERT_EQUALS("fon!(restoring01:?,(", testAst("f((long) !on, restoring ? 0 : 1);"));
+
+        ASSERT_EQUALS("esi.!(=", testAst("E e = (E)!s->i;")); // #10882
+
+        ASSERT_EQUALS("xp(= 12>34:?", testAst("x = ( const char ( * ) [ 1 > 2 ? 3 : 4 ] ) p ;"));
+
+        ASSERT_EQUALS("f{(si.,(", testAst("f((struct S){ }, s->i);")); // #11606
+
         // not cast
         ASSERT_EQUALS("AB||", testAst("(A)||(B)"));
         ASSERT_EQUALS("abc[1&=", testAst("a = (b[c]) & 1;"));
@@ -7578,63 +7222,268 @@ class TestTokenizer : public TestFixture {
         // [
         // `-(
         //   `-{
-        ASSERT_EQUALS("x{([( ai=", testAst("x([&a](int i){a=i;});"));
 
+        ASSERT_EQUALS("x{(a&[( ai=", testAst("x([&a](int i){a=i;});"));
         ASSERT_EQUALS("{([(return 0return", testAst("return [](){ return 0; }();"));
+
+        // noexcept (which if simplified to always have a condition by the time AST is created)
+        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) noexcept(true) { a=i; });"));
+        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) mutable noexcept(true) { a=i; });"));
+        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) const noexcept(true) { a=i; });"));
+
+        // both mutable and constexpr (which is simplified to 'const' by the time AST is created)
+        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) const mutable { a=i; });"));
+        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) mutable const { a=i; });"));
+        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) const mutable noexcept(true) { a=i; });"));
+        ASSERT_EQUALS("x{([( ai=", testAst("x([](int i) mutable const noexcept(true) { a=i; });"));
+
+        // ->
         ASSERT_EQUALS("{([(return 0return", testAst("return []() -> int { return 0; }();"));
-        ASSERT_EQUALS("{([(return 0return", testAst("return [something]() -> int { return 0; }();"));
+        ASSERT_EQUALS("{(something[(return 0return", testAst("return [something]() -> int { return 0; }();"));
         ASSERT_EQUALS("{([cd,(return 0return", testAst("return [](int a, int b) -> int { return 0; }(c, d);"));
-        ASSERT_EQUALS("x{([=", testAst("x = [&]()->std::string const & {};"));
+        ASSERT_EQUALS("{([return", testAst("return []() -> decltype(0) {};"));
+        ASSERT_EQUALS("x{(&[=", testAst("x = [&]()->std::string const & {};"));
         ASSERT_EQUALS("f{([=", testAst("f = []() -> foo* {};"));
+        ASSERT_EQUALS("f{([=", testAst("f = []() -> foo&& {};"));
         ASSERT_EQUALS("f{([=", testAst("f = [](void) mutable -> foo* {};"));
         ASSERT_EQUALS("f{([=", testAst("f = []() mutable {};"));
 
         ASSERT_EQUALS("x{([= 0return", testAst("x = [](){return 0; };"));
 
-        ASSERT_EQUALS("ab{[(= cd=", testAst("a = b([&]{c=d;});"));
+        ASSERT_EQUALS("ab{&[(= cd=", testAst("a = b([&]{c=d;});"));
 
         // 8628
         ASSERT_EQUALS("f{([( switchx( 1case y++", testAst("f([](){switch(x){case 1:{++y;}}});"));
+
+        ASSERT_EQUALS("{(=[{return ab=",
+                      testAst("return {\n"
+                              "  [=]() {\n"
+                              "    a = b;\n"
+                              "  }\n"
+                              "};\n"));
+        ASSERT_EQUALS("{=[{return ab=",
+                      testAst("return {\n"
+                              "  [=] {\n"
+                              "    a = b;\n"
+                              "  }\n"
+                              "};\n"));
+        ASSERT_EQUALS("{(=[{return ab=",
+                      testAst("return {\n"
+                              "  [=]() -> int {\n"
+                              "    a=b;\n"
+                              "  }\n"
+                              "}"));
+        ASSERT_EQUALS("{(=[{return ab=",
+                      testAst("return {\n"
+                              "  [=]() mutable consteval -> int {\n"
+                              "    a=b;\n"
+                              "  }\n"
+                              "}"));
+
+        // daca@home hang
+        ASSERT_EQUALS("a{(&[= 0return b{(=[= fori0=i10!=i++;;(",
+                      testAst("a = [&]() -> std::pair<int, int> { return 0; };\n"
+                              "b = [=]() { for (i = 0; i != 10; ++i); };"));
+
+        // #9662
+        ASSERT_EQUALS("b{[{ stdunique_ptr::0nullptrnullptr:?{", testAst("auto b{[] { std::unique_ptr<void *>{0 ? nullptr : nullptr}; }};"));
+        ASSERT_EQUALS("{b{[=[", testAst("void a() { [b = [] { ; }] {}; }"));
+
+        // Lambda capture expression (C++14)
+        ASSERT_EQUALS("a{b1=[= c2=", testAst("a = [b=1]{c=2;};"));
+
+        // #9729
+        ASSERT_NO_THROW(tokenizeAndStringify("void foo() { bar([]() noexcept { if (0) {} }); }"));
+        ASSERT_EQUALS("", errout_str());
+
+        // #11128
+        const Settings s = settingsBuilder(settings1).cpp(Standards::CPP17).build();
+        ASSERT_NO_THROW(tokenizeAndStringify("template <typename T>\n"
+                                             "struct S;\n"
+                                             "struct R;\n"
+                                             "S<R> y, z;\n"
+                                             "auto f(int x) -> S<R> {\n"
+                                             "    if (const auto i = x; i != 0)\n"
+                                             "        return y;\n"
+                                             "    else\n"
+                                             "        return z;\n"
+                                             "}\n", s));
+        ignore_errout();
+
+        // #10079 - createInnerAST bug..
+        ASSERT_EQUALS("x{([= yz= switchy(",
+                      testAst("x = []() -> std::vector<uint8_t> {\n"
+                              "    const auto y = z;\n"
+                              "    switch (y) {}\n"
+                              "};"));
+
+        // #11357
+        ASSERT_NO_THROW(tokenizeAndStringify("void f(std::vector<int>& v, bool c) {\n"
+                                             "    std::sort(v.begin(), v.end(), [&c](const auto a, const auto b) {\n"
+                                             "        switch (c) {\n"
+                                             "        case false: {\n"
+                                             "            if (a < b) {}\n"
+                                             "        }\n"
+                                             "        }\n"
+                                             "        return a < b;\n"
+                                             "    });\n"
+                                             "}\n"));
+        ignore_errout();
+
+        ASSERT_NO_THROW(tokenizeAndStringify("namespace N {\n"
+                                             "    enum E : bool { F };\n"
+                                             "}\n"
+                                             "void f(std::vector<int>& v, bool c) {\n"
+                                             "    std::sort(v.begin(), v.end(), [&c](const auto a, const auto b) {\n"
+                                             "        switch (c) {\n"
+                                             "        case N::E::F: {\n"
+                                             "            if (a < b) {}\n"
+                                             "        }\n"
+                                             "        }\n"
+                                             "        return a < b;\n"
+                                             "    });\n"
+                                             "}\n"));
+        ignore_errout();
+
+        ASSERT_NO_THROW(tokenizeAndStringify("void f(const std::vector<char>& v) {\n"
+                                             "    std::for_each(v.begin(), v.end(), [&](char c) {\n"
+                                             "        switch (c) {\n"
+                                             "            case 'r': {\n"
+                                             "                if (c) {}\n"
+                                             "            }\n"
+                                             "            break;\n"
+                                             "        }\n"
+                                             "    });\n"
+                                             "}\n"));
+        ASSERT_EQUALS("", errout_str());
+
+        ASSERT_NO_THROW(tokenizeAndStringify("struct A { A(int) {} };\n"
+                                             "void g(void (*)(int));\n"
+                                             "void f() {\n"
+                                             "    g([](int i) {\n"
+                                             "        switch (i) {\n"
+                                             "        case static_cast<int>(1): {\n"
+                                             "            A a(i);\n"
+                                             "            if (1) {}\n"
+                                             "        }\n"
+                                             "        }\n"
+                                             "    });\n"
+                                             "}\n"));
+        ASSERT_EQUALS("", errout_str());
+
+        ASSERT_NO_THROW(tokenizeAndStringify("int foo() {\n"
+                                             "    connect([]( const int& f ) {\n"
+                                             "                switch( f )\n"
+                                             "                {\n"
+                                             "                    case (int)1:\n"
+                                             "                    {\n"
+                                             "                        A r(f);\n"
+                                             "                        if (1) {}\n"
+                                             "                    }\n"
+                                             "                    break;\n"
+                                             "                }\n"
+                                             "                return 0;\n"
+                                             "             });\n"
+                                             "    return 0;\n"
+                                             "}\n"));
+        ASSERT_EQUALS("", errout_str());
+
+        // #11378
+        ASSERT_EQUALS("gT{(&[{= 0return", testAst("auto g = T{ [&]() noexcept -> int { return 0; } };"));
+
+        ASSERT_EQUALS("sf.{(i[{={", testAst("void g(int i) { S s{ .f = { [i]() {} } }; }"));
+
+        ASSERT_EQUALS("{([", testAst("void f() { []() {}; }")); // #13471
     }
 
     void astcase() {
         ASSERT_EQUALS("0case", testAst("case 0:"));
         ASSERT_EQUALS("12+case", testAst("case 1+2:"));
         ASSERT_EQUALS("xyz:?case", testAst("case (x?y:z):"));
+        ASSERT_EQUALS("switchx( 1case y++ 2case", testAst("switch(x){case 1:{++y;break;case 2:break;}}"));
+        ASSERT_EQUALS("switchi( 12<<~case 0return", testAst("switch (i) { case ~(1 << 2) : return 0; }")); // #13197
+    }
+
+    void astrefqualifier() {
+        ASSERT_EQUALS("", testAst("class a { auto b() -> int&; };"));
+        ASSERT_EQUALS("", testAst("class a { auto b() -> int&&; };"));
+        ASSERT_EQUALS("", testAst("class a { void b() &&; };"));
+        ASSERT_EQUALS("", testAst("class a { void b() &; };"));
+        ASSERT_EQUALS("", testAst("class a { void b() && = delete; };"));
+        ASSERT_EQUALS("", testAst("class a { void b() & = delete; };"));
+        ASSERT_EQUALS("", testAst("class a { void b() && {} };"));
+        ASSERT_EQUALS("", testAst("class a { void b() & {} };"));
+    }
+
+    void astthrowdelete() {
+        ASSERT_EQUALS("a(", testAst("class a { virtual ~a() throw() = delete; };"));
     }
 
-    void compileLimits() {
-        const char raw_code[] = "#define PTR1 (* (* (* (* (* (* (* (* (* (*\n"
-                                "#define PTR2 PTR1 PTR1 PTR1 PTR1 PTR1 PTR1 PTR1 PTR1 PTR1 PTR1\n"
-                                "#define PTR3 PTR2 PTR2 PTR2 PTR2 PTR2 PTR2 PTR2 PTR2 PTR2 PTR2\n"
-                                "#define PTR4 PTR3 PTR3 PTR3 PTR3 PTR3 PTR3 PTR3 PTR3 PTR3 PTR3\n"
-                                "#define PTR5 PTR4 PTR4 PTR4 PTR4 PTR4 PTR4 PTR4 PTR4 PTR4 PTR4\n"
-                                "#define PTR6 PTR5 PTR5 PTR5 PTR5 PTR5 PTR5 PTR5 PTR5 PTR5 PTR5\n"
-                                "\n"
-                                "#define RBR1 ) ) ) ) ) ) ) ) ) )\n"
-                                "#define RBR2 RBR1 RBR1 RBR1 RBR1 RBR1 RBR1 RBR1 RBR1 RBR1 RBR1\n"
-                                "#define RBR3 RBR2 RBR2 RBR2 RBR2 RBR2 RBR2 RBR2 RBR2 RBR2 RBR2\n"
-                                "#define RBR4 RBR3 RBR3 RBR3 RBR3 RBR3 RBR3 RBR3 RBR3 RBR3 RBR3\n"
-                                "#define RBR5 RBR4 RBR4 RBR4 RBR4 RBR4 RBR4 RBR4 RBR4 RBR4 RBR4\n"
-                                "#define RBR6 RBR5 RBR5 RBR5 RBR5 RBR5 RBR5 RBR5 RBR5 RBR5 RBR5\n"
-                                "\n"
-                                "int PTR4 q4_var RBR4 = 0;\n";
-
-        // Preprocess file..
-        Preprocessor preprocessor(settings0);
-        std::list<std::string> configurations;
-        std::string filedata;
-        std::istringstream fin(raw_code);
-        preprocessor.preprocess(fin, filedata, configurations, emptyString, settings0.includePaths);
-        const std::string code = preprocessor.getcode(filedata, emptyString, emptyString);
-
-        tokenizeAndStringify(code.c_str()); // just survive...
-    }
-
-    bool isStartOfExecutableScope(int offset, const char code[]) {
-        Tokenizer tokenizer(&settings0, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+    void asttrailingdecltype() {
+        ASSERT_EQUALS("Cc& csize.(", testAst("template<class C> constexpr auto s(const C &c) noexcept -> decltype(c.size()) {}"));
+        ASSERT_EQUALS("Cc& MakeSpancdata.(csize.(,(",
+                      testAst("template <typename C> constexpr auto MakeSpan(C &c) -> decltype(MakeSpan(c.data(), c.size())) {}"));
+        ASSERT_EQUALS("Eqeq&key_typek&, eqkk,(", testAst("auto KeyTypeCanBeEq(const Eq& eq, const key_type& k) -> decltype(eq(k, k));"));
+        ASSERT_EQUALS("h{([= si. {return", testAst("auto h = []() -> decltype(s.i) { return {}; };"));
+    }
+    void astnoexcept() {
+        ASSERT_EQUALS("noexceptaswap.b((", testAst("void f() noexcept(noexcept(a.swap(b))) {}"));
+        ASSERT_EQUALS("{([ noexceptaswap.b((", testAst("[]() noexcept(noexcept(a.swap(b))) {}"));
+    }
+
+    //Verify that returning a newly constructed object generates the correct AST even when the class name is scoped
+    //Addresses https://trac.cppcheck.net/ticket/9700
+    void astnewscoped() {
+        ASSERT_EQUALS("(return (new A))", testAst("return new A;", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (( A)))", testAst("return new A();", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (( A true)))", testAst("return new A(true);", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (:: A B)))", testAst("return new A::B;", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (( (:: A B))))", testAst("return new A::B();", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (( (:: A B) true)))", testAst("return new A::B(true);", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (:: (:: A B) C)))", testAst("return new A::B::C;", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (( (:: (:: A B) C))))", testAst("return new A::B::C();", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (( (:: (:: A B) C) true)))", testAst("return new A::B::C(true);", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (:: (:: (:: A B) C) D)))", testAst("return new A::B::C::D;", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (( (:: (:: (:: A B) C) D))))", testAst("return new A::B::C::D();", AstStyle::Z3));
+        ASSERT_EQUALS("(return (new (( (:: (:: (:: A B) C) D) true)))", testAst("return new A::B::C::D(true);", AstStyle::Z3));
+    }
+
+    void astdecltypescope() {
+        ASSERT_EQUALS("sizedecltypethism_P.(XSize::::{", testAst("size { decltype(this->m_P)::X::Size };"));
+    }
+
+    void astdesignatedinit() {
+        ASSERT_EQUALS("(( f ({ (= (. x) 1)))", testAst("f({ .x = 1 });", AstStyle::Z3));
+    }
+
+    void astrvaluedecl() {
+        ASSERT_EQUALS("varstdmove::var(=", testAst("std::string&& var = std::move(var);"));
+    }
+
+    void astorkeyword() {
+        ASSERT_EQUALS("ifsp.\"\"==sp.0==||(", testAst("void f() { if (s.p == \"\" or s.p == 0) {} }"));
+    }
+
+    void astenumdecl() {
+        ASSERT_EQUALS("A0U=", testAst("enum class myclass : unsigned char { A = 0U, };"));
+        ASSERT_EQUALS("A0U=", testAst("enum myclass : unsigned char { A = 0U, };"));
+    }
+
+    void astcompound() {
+        ASSERT_EQUALS("sn0=={(tmp:?=", testAst("Str s = n == 0 ? (Str) { 0 } : tmp;")); // #14548
+        ASSERT_EQUALS("s(sstrlens(0:?,{(return", testAst("return (struct Str) { (unsigned char*)s, s ? strlen(s) : 0 };"));
+    }
+
+    void astfuncdecl() {
+        ASSERT_EQUALS("", testAst("bool operator==(const S& a, const S& b);", AstStyle::Simple, ListSimplification::Full));
+        ASSERT_EQUALS("", testAst("::int32_t f();"));
+    }
+
+#define isStartOfExecutableScope(offset, code) isStartOfExecutableScope_(offset, code, __FILE__, __LINE__)
+    template<size_t size>
+    bool isStartOfExecutableScope_(int offset, const char (&code)[size], const char* file, int line) {
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         return Tokenizer::startOfExecutableScope(tokenizer.tokens()->tokAt(offset)) != nullptr;
     }
@@ -7665,8 +7514,9 @@ class TestTokenizer : public TestFixture {
     void removeMacroInClassDef() { // #6058
         ASSERT_EQUALS("class Fred { } ;", tokenizeAndStringify("class DLLEXPORT Fred { } ;"));
         ASSERT_EQUALS("class Fred : Base { } ;", tokenizeAndStringify("class Fred FINAL : Base { } ;"));
+        ASSERT_EQUALS("class Fred : Base { } ;", tokenizeAndStringify("class DLLEXPORT Fred final : Base { } ;")); // #11422
         // Regression for C code:
-        ASSERT_EQUALS("struct Fred { } ;", tokenizeAndStringify("struct DLLEXPORT Fred { } ;", false, true, Settings::Native, "test.c"));
+        ASSERT_EQUALS("struct Fred { } ;", tokenizeAndStringify("struct DLLEXPORT Fred { } ;", dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void sizeofAddParentheses() {
@@ -7677,21 +7527,268 @@ class TestTokenizer : public TestFixture {
         ASSERT_EQUALS("sizeof ( a ) > sizeof ( & main ) ;", tokenizeAndStringify("sizeof a > sizeof &main;"));
     }
 
-    void findGarbageCode() { // Make sure the Tokenizer::findGarbageCode() does not have FPs
+    void reportUnknownMacros() {
+        const char code1[] = "MY_UNKNOWN_IMP1(IInStream)\n"
+                             "STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize) { if (ptr); }";
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(code1), UNKNOWN_MACRO);
+
+        const char code2[] = "void foo() { dostuff(x 0); }";
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(code2), UNKNOWN_MACRO);
+
+        const char code3[] = "f(\"1\" __stringify(48) \"1\");";
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(code3), UNKNOWN_MACRO);
+
+        const char code4[] = "struct Foo {\n"
+                             "  virtual MACRO(int) f1() {}\n"
+                             "  virtual MACRO(int) f2() {}\n"
+                             "};";
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(code4), UNKNOWN_MACRO);
+
+        const char code5[] = "void foo() {\n"
+                             "  EVALUATE(123, int x=a; int y=b+c;);\n"
+                             "}";
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(code5), UNKNOWN_MACRO);
+
+        const char code6[] = "void foo() { dostuff(a, .x=0); }";
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(code6), UNKNOWN_MACRO);
+
+        const char code7[] = "void foo() { dostuff(ZEND_NUM_ARGS() TSRMLS_CC, x, y); }"; // #9476
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(code7), UNKNOWN_MACRO);
+
+        const char code8[] = "void foo() { a = [](int x, decltype(vec) y){}; }";
+        ASSERT_NO_THROW(tokenizeAndStringify(code8));
+
+        const char code9[] = "void f(std::exception c) { b(M() c.what()); }";
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(code9), UNKNOWN_MACRO);
+
+        const char code10[] = "void f(std::exception c) { b(M() M() + N(c.what())); }";
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(code10), UNKNOWN_MACRO);
+
+        const char code11[] = "struct B { B(B&&) noexcept {} ~B() noexcept {} };";
+        ASSERT_NO_THROW(tokenizeAndStringify(code11));
+
+        ASSERT_NO_THROW(tokenizeAndStringify("alignas(8) alignas(16) int x;")); // alignas is not unknown macro
+
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void foo() { if(x) SYSTEM_ERROR }"), UNKNOWN_MACRO);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void foo() { dostuff(); SYSTEM_ERROR }"), UNKNOWN_MACRO);
+
+        ASSERT_NO_THROW(tokenizeAndStringify("void f(void* q) {\n"
+                                             "    g(&(S) { .p = (int*)q });\n"
+                                             "}\n", dinit(TokenizeOptions, $.cpp = false)));
+
+        ASSERT_NO_THROW(tokenizeAndStringify("typedef struct { int i; } S;\n"
+                                             "void f(float a) {\n"
+                                             "S s = (S){ .i = (int)a };\n"
+                                             "}\n", dinit(TokenizeOptions, $.cpp = false)));
+
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("std::string g();\n"
+                                                   "std::string f() {\n"
+                                                   "    return std::string{ g() + \"abc\" MACRO \"def\" };\n"
+                                                   "}\n"), UNKNOWN_MACRO);
+
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("static void handle_toggle(void (*proc) PROTO_XT_CALLBACK_ARGS, int var) {}\n"), // #13198
+                                     UNKNOWN_MACRO,
+                                     "There is an unknown macro here somewhere. Configuration is required. If PROTO_XT_CALLBACK_ARGS is a macro then please configure it.");
+
+        ignore_errout();
+    }
+
+    void findGarbageCode() { // Test Tokenizer::findGarbageCode()
+        // C++ try/catch in global scope
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("try { }"), SYNTAX, "syntax error: keyword 'try' is not allowed in global scope");
+        ASSERT_NO_THROW(tokenizeAndStringify("void f() try { } catch (int) { }"));
+        ASSERT_NO_THROW(tokenizeAndStringify("struct S {\n" // #9716
+                                             "    S();\n"
+                                             "    int x, y;\n"
+                                             "};\n"
+                                             "S::S()\n"
+                                             "    try : x(1), y{ 2 } { f(); }\n"
+                                             "    catch (const std::exception& e) { g(); }\n"
+                                             "    catch (...) { g(); }\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("void f()\n"
+                                             "    try { g(); }\n"
+                                             "    catch (const std::exception& e) { h(); }\n"
+                                             "    catch (...) { h(); }\n"));
+
         // before if|for|while|switch
-        ASSERT_NO_THROW(tokenizeAndStringify("void f() { do switch (a) {} while (1); }"))
+        ASSERT_NO_THROW(tokenizeAndStringify("void f() { do switch (a) {} while (1); }"));
         ASSERT_NO_THROW(tokenizeAndStringify("void f() { label: switch (a) {} }"));
-        ASSERT_NO_THROW(tokenizeAndStringify("void f() { UNKNOWN_MACRO if (a) {} }"))
+        ASSERT_NO_THROW(tokenizeAndStringify("void f() { UNKNOWN_MACRO if (a) {} }"));
         ASSERT_NO_THROW(tokenizeAndStringify("void f() { []() -> int * {}; }"));
         ASSERT_NO_THROW(tokenizeAndStringify("void f() { const char* var = \"1\" \"2\"; }"));
-        // TODO ASSERT_NO_THROW(tokenizeAndStringify("void f() { MACRO(switch); }"));
-        // TODO ASSERT_NO_THROW(tokenizeAndStringify("void f() { MACRO(x,switch); }"));
+
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void f() { MACRO(switch); }"), UNKNOWN_MACRO);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void f() { MACRO(x,switch); }"), UNKNOWN_MACRO);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void foo() { for_chain( if (!done) done = 1); }"), UNKNOWN_MACRO);
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void foo() { for_chain( a, b, if (!done) done = 1); }"), UNKNOWN_MACRO);
+
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { if (retval==){} }"), SYNTAX, "syntax error: ==)");
 
         // after (expr)
         ASSERT_NO_THROW(tokenizeAndStringify("void f() { switch (a) int b; }"));
 
         ASSERT_NO_THROW(tokenizeAndStringify("S s = { .x=2, .y[0]=3 };"));
         ASSERT_NO_THROW(tokenizeAndStringify("S s = { .ab.a=2, .ab.b=3 };"));
+
+        ASSERT_NO_THROW(tokenizeAndStringify("extern \"C\" typedef void FUNC();"));
+
+        // Ticket #9572
+        ASSERT_NO_THROW(tokenizeAndStringify("struct poc { "
+                                             "  struct { int d; } port[1]; "
+                                             "}; "
+                                             "struct poc p = { .port[0] = {.d = 3} };"));
+
+        // Ticket #9664
+        ASSERT_NO_THROW(tokenizeAndStringify("S s = { .x { 2 }, .y[0] { 3 } };"));
+
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("f(0, .x());"), SYNTAX); // #12823
+
+        // Ticket #11134
+        ASSERT_NO_THROW(tokenizeAndStringify("struct my_struct { int x; }; "
+                                             "std::string s; "
+                                             "func(my_struct{ .x=42 }, s.size());"));
+        ASSERT_NO_THROW(tokenizeAndStringify("struct my_struct { int x; int y; }; "
+                                             "std::string s; "
+                                             "func(my_struct{ .x{42}, .y=3 }, s.size());"));
+        ASSERT_NO_THROW(tokenizeAndStringify("struct my_struct { int x; int y; }; "
+                                             "std::string s; "
+                                             "func(my_struct{ .x=42, .y{3} }, s.size());"));
+        ASSERT_NO_THROW(tokenizeAndStringify("struct my_struct { int x; }; "
+                                             "void h() { "
+                                             "  for (my_struct ms : { my_struct{ .x=5 } }) {} "
+                                             "}"));
+        ASSERT_NO_THROW(tokenizeAndStringify("struct my_struct { int x; int y; }; "
+                                             "void h() { "
+                                             "  for (my_struct ms : { my_struct{ .x=5, .y{42} } }) {} "
+                                             "}"));
+
+        ASSERT_NO_THROW(tokenizeAndStringify("template <typename T> void foo() {} "
+                                             "void h() { "
+                                             "  [func=foo<int>]{func();}(); "
+                                             "}"));
+        ASSERT_NO_THROW(tokenizeAndStringify("template <class T> constexpr int n = 1;\n"
+                                             "template <class T> T a[n<T>];\n"));
+
+        ASSERT_EQUALS("std :: vector < int > x ;", // #11785
+                      tokenizeAndStringify("std::vector<int> typedef v; v x;\n"));
+
+
+        // op op
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { dostuff (x==>y); }"), SYNTAX, "syntax error: == >");
+
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { assert(a==()); }"), SYNTAX, "syntax error: ==()");
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { assert(a+()); }"), SYNTAX, "syntax error: +()");
+
+        // #9445 - typeof is not a keyword in C
+        ASSERT_NO_THROW(tokenizeAndStringify("void foo() { char *typeof, *value; }", dinit(TokenizeOptions, $.expand = false, $.cpp = false)));
+
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("enum : { };"), SYNTAX, "syntax error: Unexpected token '{'");
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("enum : 3 { };"), SYNTAX, "syntax error: Unexpected token '3'");
+        ASSERT_NO_THROW(tokenizeAndStringify("enum { E = int{} };"));
+
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("int a() { b((c)return 0) }"), SYNTAX, "syntax error");
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("int f() { MACRO(x) return 0; }"),
+                                     UNKNOWN_MACRO,
+                                     "There is an unknown macro here somewhere. Configuration is required. If MACRO is a macro then please configure it.");
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("bool f() { unknown return 0; }"),
+                                     UNKNOWN_MACRO,
+                                     "There is an unknown macro here somewhere. Configuration is required. If unknown is a macro then please configure it.");
+
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f(int i) {\n" // #11770
+                                                          "    if (i == 0) {}\n"
+                                                          "    else if (i == 1) {}\n"
+                                                          "    else\n"
+                                                          "        MACRO(i)\n"
+                                                          "}\n"
+                                                          "void g() {}\n"),
+                                     UNKNOWN_MACRO,
+                                     "There is an unknown macro here somewhere. Configuration is required. If MACRO is a macro then please configure it.");
+        ASSERT_NO_THROW(tokenizeAndStringify("void f(int i) {\n"
+                                             "    if (i == 0) {}\n"
+                                             "    else if (i == 1) {}\n"
+                                             "    else\n"
+                                             "        MACRO(i);\n"
+                                             "}\n"
+                                             "void g() {}\n"));
+
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("class C : public QObject {\n" // #11770
+                                                          "    struct S { static void g() {} };\n"
+                                                          "private Q_SLOTS:\n"
+                                                          "    void f() { S::g(); }\n"
+                                                          "};\n"),
+                                     UNKNOWN_MACRO,
+                                     "There is an unknown macro here somewhere. Configuration is required. If Q_SLOTS is a macro then please configure it.");
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("class C : public QObject {\n"
+                                                          "    struct S { static void g() {} };\n"
+                                                          "private slots:\n"
+                                                          "    void f() { S::g(); }\n"
+                                                          "};\n"),
+                                     UNKNOWN_MACRO,
+                                     "There is an unknown macro here somewhere. Configuration is required. If slots is a macro then please configure it.");
+
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("namespace U_ICU_ENTRY_POINT_RENAME(icu) { }\n"
+                                                          "namespace icu = U_ICU_ENTRY_POINT_RENAME(icu);\n"
+                                                          "namespace U_ICU_ENTRY_POINT_RENAME(icu) {\n"
+                                                          "    class BreakIterator;\n"
+                                                          "}\n"
+                                                          "typedef int UStringCaseMapper(icu::BreakIterator* iter);\n"),
+                                     UNKNOWN_MACRO,
+                                     "There is an unknown macro here somewhere. Configuration is required. If U_ICU_ENTRY_POINT_RENAME is a macro then please configure it.");
+
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("void f() { MACRO(x(), y(), \"abc\", z(); ok = true); }\n"), // #12006
+                                     UNKNOWN_MACRO,
+                                     "There is an unknown macro here somewhere. Configuration is required. If MACRO is a macro then please configure it.");
+
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("int (*f) MACRO((void *));\n"), // #12010
+                                     UNKNOWN_MACRO,
+                                     "There is an unknown macro here somewhere. Configuration is required. If MACRO is a macro then please configure it.");
+
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("struct S { int a[2] PACKED; };\n"),
+                                     UNKNOWN_MACRO,
+                                     "There is an unknown macro here somewhere. Configuration is required. If PACKED is a macro then please configure it.");
+
+        ASSERT_THROW_INTERNAL_EQUALS(tokenizeAndStringify("MACRO(a, b,,)\n"),
+                                     UNKNOWN_MACRO,
+                                     "There is an unknown macro here somewhere. Configuration is required. If MACRO is a macro then please configure it.");
+
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("{ for (()()) }"), SYNTAX); // #11643
+
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void f(const std::vector<std::string>& v) {\n" // #14326
+                                                   "    for (const std::string&s : v)\n"
+                                                   "}"),
+                              SYNTAX);
+
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void f(T* p) {\n"
+                                                   "    g(p->x TSRMLS_CC);"
+                                                   "}"),
+                              UNKNOWN_MACRO);
+
+        ASSERT_NO_THROW(tokenizeAndStringify("S* g = ::new(ptr) S();")); // #12552
+        ASSERT_NO_THROW(tokenizeAndStringify("void f(int* p) { return ::delete p; }"));
+
+        ASSERT_NO_THROW(tokenizeAndStringify("template <typename T, int N>\n" // #12659
+                                             "constexpr void f(T(&&a)[N]) {}"));
+
+        ASSERT_NO_THROW(tokenizeAndStringify("typedef struct { typedef int T; } S;")); // #12700
+
+        ASSERT_NO_THROW(tokenizeAndStringify("class A { bool restrict() const; };\n"
+                                             "bool A::restrict() const { return true; }")); // #12718
+
+        ASSERT_NO_THROW(tokenizeAndStringify("enum { E = sizeof(struct { int i; }) };")); // #13249
+
+        ASSERT_NO_THROW(tokenizeAndStringify("struct S { unsigned u:2, :30; };")); // #14393
+
+        ASSERT_NO_THROW(tokenizeAndStringify("struct S {};\n" // #14400
+                                             "auto f(bool b) -> struct S {\n"
+                                             "    if (b) {}\n"
+                                             "    return {};\n"
+                                             "};\n"));
+
+        ASSERT_NO_THROW(tokenizeAndStringify("void f() {\n" // #14395
+                                             "    for (int i : [](int a, int b) { ++a; ++b; return std::vector<int>{a, b}; }(1, 2)) {}\n"
+                                             "}\n"));
+
+        ignore_errout();
     }
 
 
@@ -7701,13 +7798,15 @@ class TestTokenizer : public TestFixture {
                             "    typename U,\n"
                             "    typename std::enable_if<\n"
                             "        std::is_convertible<U, T>{}>::type* = nullptr>\n"
-                            "void foo(U x);\n"))
+                            "void foo(U x);\n"));
+        ASSERT_EQUALS("", errout_str());
 
         ASSERT_NO_THROW(tokenizeAndStringify(
                             "template<class t>\n"
                             "T f(const T a, const T b) {\n"
                             "    return a < b ? b : a;\n"
-                            "}\n"))
+                            "}\n"));
+        ASSERT_EQUALS("", errout_str());
 
         ASSERT_NO_THROW(tokenizeAndStringify(
                             "template<class T>\n"
@@ -7715,7 +7814,8 @@ class TestTokenizer : public TestFixture {
                             "    T f(const T a, const T b) {\n"
                             "        return a < b ? b : a;\n"
                             "    }\n"
-                            "};\n"))
+                            "};\n"));
+        ASSERT_EQUALS("", errout_str());
 
         ASSERT_NO_THROW(tokenizeAndStringify(
                             "const int a = 1;\n"
@@ -7723,8 +7823,26 @@ class TestTokenizer : public TestFixture {
                             "template<class T>\n"
                             "struct A {\n"
                             "    int x = a < b ? b : a;"
-                            "};\n"))
+                            "};\n"));
+        ASSERT_EQUALS("", errout_str());
 
+        // #10139
+        ASSERT_NO_THROW(tokenizeAndStringify("template<typename F>\n"
+                                             "void foo(std::enable_if_t<value<F>>* = 0) {}\n"));
+        ASSERT_EQUALS("", errout_str());
+
+        // #10001
+        ASSERT_NO_THROW(tokenizeAndStringify("struct a {\n"
+                                             "  int c;\n"
+                                             "  template <class b> void d(b e) const { c < e ? c : e; }\n"
+                                             "};\n"));
+        ASSERT_EQUALS("", errout_str());
+
+        ASSERT_NO_THROW(tokenizeAndStringify("struct a {\n"
+                                             "  int c;\n"
+                                             "  template <class b> void d(b e) const { c > e ? c : e; }\n"
+                                             "};\n"));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void checkTemplates() {
@@ -7741,7 +7859,7 @@ class TestTokenizer : public TestFixture {
                             "  bool h = f::h;\n"
                             "};\n"
                             "template <typename i> using j = typename e<i>::g;\n"
-                            "}\n"))
+                            "}\n"));
 
         ASSERT_NO_THROW(tokenizeAndStringify(
                             "template <typename = void> struct a {\n"
@@ -7750,7 +7868,7 @@ class TestTokenizer : public TestFixture {
                             "void f() {\n"
                             "  a<> b;\n"
                             "  b.a<>::c();\n"
-                            "}\n"))
+                            "}\n"));
 
         // #9138
         ASSERT_NO_THROW(tokenizeAndStringify(
@@ -7759,7 +7877,7 @@ class TestTokenizer : public TestFixture {
                             "template <bool b> c<b> d;\n"
                             "template <> struct a<int> {\n"
                             "template <typename e> constexpr auto g() { d<0 || e::f>; return 0; }\n"
-                            "};\n"))
+                            "};\n"));
 
         // #9144
         ASSERT_NO_THROW(tokenizeAndStringify(
@@ -7772,14 +7890,14 @@ class TestTokenizer : public TestFixture {
                             "namespace d = boost;\n"
                             "using d::c;\n"
                             "template <typename...> struct e {};\n"
-                            "static_assert(sizeof(e<>) == sizeof(e<c<int>, c<int>, int>), \"\");\n"))
+                            "static_assert(sizeof(e<>) == sizeof(e<c<int>, c<int>, int>), \"\");\n"));
 
         // #9146
         ASSERT_NO_THROW(tokenizeAndStringify(
                             "template <int> struct a;\n"
                             "template <class, class b> using c = typename a<int{b::d}>::e;\n"
                             "template <class> struct f;\n"
-                            "template <class b> using g = typename f<c<int, b>>::e;\n"))
+                            "template <class b> using g = typename f<c<int, b>>::e;\n"));
 
         // #9153
         ASSERT_NO_THROW(tokenizeAndStringify(
@@ -7795,7 +7913,7 @@ class TestTokenizer : public TestFixture {
                             "template <class> struct f;\n"
                             "}\n"
                             "template <class c> using g = b::f<e<int, c>>;\n"
-                            "}\n"))
+                            "}\n"));
 
         // #9154
         ASSERT_NO_THROW(tokenizeAndStringify(
@@ -7816,7 +7934,7 @@ class TestTokenizer : public TestFixture {
                             "template <class, class> struct s;\n"
                             "template <template <class> class t, class... w, template <class> class x,\n"
                             "          class... u>\n"
-                            "struct s<t<w...>, x<u...>>;\n"))
+                            "struct s<t<w...>, x<u...>>;\n"));
 
         // #9156
         ASSERT_NO_THROW(tokenizeAndStringify(
@@ -7830,7 +7948,16 @@ class TestTokenizer : public TestFixture {
                             "  template <class... ag> using ah = typename ab<h, ag..., g...>::e;\n"
                             "};\n"
                             "template <class> struct F;\n"
-                            "int main() { using T = void (*)(a<j<F, char[]>>); }\n"))
+                            "int main() { using T = void (*)(a<j<F, char[]>>); }\n"));
+
+        // #9245
+        ASSERT_NO_THROW(tokenizeAndStringify("struct a {\n"
+                                             "  typedef int b;\n"
+                                             "  operator b();\n"
+                                             "};\n"
+                                             "template <int> using c = a;\n"
+                                             "template <int d> c<d> e;\n"
+                                             "auto f = ((e<4> | 0));\n"));
 
         // #9340
         ASSERT_NO_THROW(tokenizeAndStringify(
@@ -7839,32 +7966,299 @@ class TestTokenizer : public TestFixture {
                             "    using d = a;\n"
                             "    d e = {(p1)...};\n"
                             "  }\n"
-                            "};\n"))
+                            "};\n"));
+
+        // #9444
+        ASSERT_NO_THROW(tokenizeAndStringify("template <int> struct a;\n"
+                                             "template <long b> using c = a<b>;\n"
+                                             "template <long b> c<b> d;\n"
+                                             "template <typename> struct e {\n"
+                                             "  template <typename... f> void g() const { d<e<f &&...>::h>; }\n"
+                                             "};\n"));
+
+        // #9858
+        ASSERT_NO_THROW(tokenizeAndStringify(
+                            "struct a {\n"
+                            "  struct b {};\n"
+                            "};\n"
+                            "void c(a::b, a::b);\n"
+                            "void g(a::b f) { c(f, {a::b{}}); }\n"
+                            "template <class> void h() {\n"
+                            "  int e;\n"
+                            "  for (int d = 0; d < e; d++)\n"
+                            "    ;\n"
+                            "}\n"));
+
+        // #10015
+        ASSERT_NO_THROW(tokenizeAndStringify(
+                            "void func() {\n"
+                            "    if (std::is_same_v<int, int> || 1)\n"
+                            "        ;\n"
+                            "}\n"));
+
+        // #10309
+        ASSERT_NO_THROW(tokenizeAndStringify(
+                            "using a = void *;\n"
+                            "void b() {\n"
+                            "  std::unique_ptr<a, void (*)(a *)>(new a(0), [](a *c) {\n"
+                            "    if (c)\n"
+                            "      ;\n"
+                            "  });\n"
+                            "}\n"));
+
+        ASSERT_NO_THROW(tokenizeAndStringify("a<b?0:1>()==3;"));
+
+        // #10336
+        ASSERT_NO_THROW(tokenizeAndStringify("struct a {\n"
+                                             "  template <class b> a(b);\n"
+                                             "};\n"
+                                             "struct c;\n"
+                                             "void fn1(int, a);\n"
+                                             "void f() { fn1(0, {a{0}}); }\n"
+                                             "template <class> std::vector<c> g() {\n"
+                                             "  int d;\n"
+                                             "  for (size_t e = 0; e < d; e++)\n"
+                                             "    ;\n"
+                                             "}\n"));
+
+        // #9523
+        ASSERT_NO_THROW(tokenizeAndStringify(
+                            "template <int> struct a;\n"
+                            "template <typename, typename> struct b;\n"
+                            "template <typename c> struct b<c, typename a<c{} && 0>::d> {\n"
+                            "  void e() {\n"
+                            "    if (0) {}\n"
+                            "  }\n"
+                            "};\n"));
+
+        ASSERT_NO_THROW(tokenizeAndStringify(
+                            "template <std::size_t First, std::size_t... Indices, typename Functor>\n"
+                            "constexpr void constexpr_for_fold_impl([[maybe_unused]] Functor&& f, std::index_sequence<Indices...>) noexcept {\n"
+                            "    (std::forward<Functor>(f).template operator() < First + Indices > (), ...);\n"
+                            "}\n"));
+
+        // #9301
+        ASSERT_NO_THROW(tokenizeAndStringify("template <typename> constexpr char x[] = \"\";\n"
+                                             "template <> constexpr char x<int>[] = \"\";\n"));
+
+        // #10951
+        ASSERT_NO_THROW(tokenizeAndStringify("struct a {\n"
+                                             "  template <class> static void b() {}\n"
+                                             "  ~a();\n"
+                                             "};\n"
+                                             "void d() { a::b<int>(); }\n"));
+
+        // #11090
+        ASSERT_NO_THROW(tokenizeAndStringify("using a = char;\n"
+                                             "using c = int;\n"
+                                             "template <typename = void> struct d {};\n"
+                                             "using b = c;\n"
+                                             "template <> struct d<b> : d<a> {};\n"
+                                             "template <> struct d<> : d<a> {};\n"));
+
+        ignore_errout();
     }
 
     void checkNamespaces() {
-        ASSERT_NO_THROW(tokenizeAndStringify("namespace x { namespace y { namespace z {}}}"))
+        ASSERT_NO_THROW(tokenizeAndStringify("namespace x { namespace y { namespace z {}}}"));
     }
 
     void checkLambdas() {
-        ASSERT_NO_THROW(tokenizeAndStringify("auto f(int& i) { return [=, &i] {}; }"))
-        ASSERT_NO_THROW(tokenizeAndStringify("auto f(int& i) { return [&, i] {}; }"))
-        ASSERT_NO_THROW(tokenizeAndStringify("auto f(int& i) { return [&, i = std::move(i)] {}; }"))
-        ASSERT_NO_THROW(tokenizeAndStringify("auto f(int& i) { return [=, i = std::move(i)] {}; }"))
+        ASSERT_NO_THROW(tokenizeAndStringify("auto f(int& i) { return [=, &i] {}; }"));
+        ASSERT_NO_THROW(tokenizeAndStringify("auto f(int& i) { return [&, i] {}; }"));
+        ASSERT_NO_THROW(tokenizeAndStringify("auto f(int& i) { return [&, i = std::move(i)] {}; }"));
+        ASSERT_NO_THROW(tokenizeAndStringify("auto f(int& i) { return [=, i = std::move(i)] {}; }"));
         ASSERT_NO_THROW(tokenizeAndStringify("struct c {\n"
                                              "  void d() {\n"
                                              "    int a;\n"
                                              "    auto b = [this, a] {};\n"
                                              "  }\n"
-                                             "};\n"))
+                                             "};\n"));
+
+        // #9525
+        ASSERT_NO_THROW(tokenizeAndStringify("struct a {\n"
+                                             "  template <class b> a(b) {}\n"
+                                             "};\n"
+                                             "auto c() -> a {\n"
+                                             "  return {[] {\n"
+                                             "    if (0) {}\n"
+                                             "  }};\n"
+                                             "}\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("struct a {\n"
+                                             "  template <class b> a(b) {}\n"
+                                             "};\n"
+                                             "auto c() -> a {\n"
+                                             "  return {[]() -> int {\n"
+                                             "    if (0) {}\n"
+                                             "    return 0;\n"
+                                             "  }};\n"
+                                             "}\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("struct a {\n"
+                                             "  template <class b> a(b) {}\n"
+                                             "};\n"
+                                             "auto c() -> a {\n"
+                                             "  return {[]() mutable -> int {\n"
+                                             "    if (0) {}\n"
+                                             "    return 0;\n"
+                                             "  }};\n"
+                                             "}\n"));
+        // #0535
+        ASSERT_NO_THROW(tokenizeAndStringify("template <typename, typename> struct a;\n"
+                                             "template <typename, typename b> void c() {\n"
+                                             "  ([]() -> decltype(0) {\n"
+                                             "    if (a<b, decltype(0)>::d) {}\n"
+                                             "  });\n"
+                                             "}\n"));
+
+        // #9563
+        ASSERT_NO_THROW(tokenizeAndStringify("template <typename> struct a;\n"
+                                             "template <typename b, typename... c> struct a<b(c...)> {\n"
+                                             "  template <typename d> a(d);\n"
+                                             "};\n"
+                                             "void e(\n"
+                                             "    int, a<void()> f = [] {});\n"));
+
+        // #9644
+        ASSERT_NO_THROW(tokenizeAndStringify("void a() {\n"
+                                             "  char b[]{};\n"
+                                             "  auto c = [](int d) {\n"
+                                             "    for (char e = 0; d;) {}\n"
+                                             "  };\n"
+                                             "}\n"));
+        // #9537
+        ASSERT_NO_THROW(tokenizeAndStringify("struct a {\n"
+                                             "  template <typename b> a(b) {}\n"
+                                             "};\n"
+                                             "a c{[] {\n"
+                                             "  if (0) {}\n"
+                                             "}};\n"));
+        // #9185
+        ASSERT_NO_THROW(tokenizeAndStringify("void a() {\n"
+                                             "  [b = [] { ; }] {};\n"
+                                             "}\n"));
+
+        // #10739
+        ASSERT_NO_THROW(tokenizeAndStringify("struct a {\n"
+                                             "  std::vector<int> b;\n"
+                                             "};\n"
+                                             "void c() {\n"
+                                             "  a bar;\n"
+                                             "  (decltype(bar.b)::value_type){};\n"
+                                             "}\n"));
+
+        ASSERT_NO_THROW(tokenizeAndStringify("struct S { char c{}; };\n" // #11400
+                                             "void takesFunc(auto f) {}\n"
+                                             "int main() { \n"
+                                             "    takesFunc([func = [](S s) { return s.c; }] {});\n"
+                                             "}\n"));
+
+        ASSERT_NO_THROW(tokenizeAndStringify("void f() {\n" // #14256
+                                             "    int i = 0;\n"
+                                             "    auto x = [i] mutable {};\n"
+                                             "}\n"));
+
+        ignore_errout();
+    }
+    void checkIfCppCast() {
+        ASSERT_NO_THROW(tokenizeAndStringify("struct a {\n"
+                                             "  int b();\n"
+                                             "};\n"
+                                             "struct c {\n"
+                                             "  bool d() const;\n"
+                                             "  a e;\n"
+                                             "};\n"
+                                             "bool c::d() const {\n"
+                                             "  int f = 0;\n"
+                                             "  if (!const_cast<a *>(&e)->b()) {}\n"
+                                             "  return f;\n"
+                                             "}\n"));
+    }
+
+    void checkRefQualifiers() {
+        // #9511
+        ASSERT_NO_THROW(tokenizeAndStringify("class a {\n"
+                                             "  void b() && {\n"
+                                             "    if (this) {}\n"
+                                             "  }\n"
+                                             "};\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("class a {\n"
+                                             "  void b() & {\n"
+                                             "    if (this) {}\n"
+                                             "  }\n"
+                                             "};\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("class a {\n"
+                                             "  auto b() && -> void {\n"
+                                             "    if (this) {}\n"
+                                             "  }\n"
+                                             "};\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("class a {\n"
+                                             "  auto b() & -> void {\n"
+                                             "    if (this) {}\n"
+                                             "  }\n"
+                                             "};\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("class a {\n"
+                                             "  auto b(int& x) -> int& {\n"
+                                             "    if (this) {}\n"
+                                             "    return x;\n"
+                                             "  }\n"
+                                             "};\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("class a {\n"
+                                             "  auto b(int& x) -> int&& {\n"
+                                             "    if (this) {}\n"
+                                             "    return x;\n"
+                                             "  }\n"
+                                             "};\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("class a {\n"
+                                             "  auto b(int& x) && -> int& {\n"
+                                             "    if (this) {}\n"
+                                             "    return x;\n"
+                                             "  }\n"
+                                             "};\n"));
+        // #9524
+        ASSERT_NO_THROW(tokenizeAndStringify("auto f() -> int* {\n"
+                                             "  if (0) {}\n"
+                                             "  return 0;\n"
+                                             "};\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("auto f() -> int** {\n"
+                                             "  if (0) {}\n"
+                                             "  return 0;\n"
+                                             "};\n"));
+        ignore_errout();
+    }
+
+    void checkConditionBlock() {
+        ASSERT_NO_THROW(tokenizeAndStringify("void a() {\n"
+                                             "  for (auto b : std::vector<std::vector<int>>{{}, {}}) {}\n"
+                                             "}\n"));
+    }
+
+    void checkUnknownCircularVar()
+    {
+        ASSERT_NO_THROW(tokenizeAndStringify("void execute() {\n"
+                                             "    const auto &bias = GEMM_CTX_ARG_STORAGE(bias);\n"
+                                             "    auto &c = GEMM_CTX_ARG_STORAGE(c);\n"
+                                             "}\n"));
+        ignore_errout(); // we do not care about the output
+    }
+
+    void checkRequires()
+    {
+        ASSERT_NO_THROW(tokenizeAndStringify("template<class T, class U>\n"
+                                             "struct X { X(U) requires true {} };\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("template<class T, class U>\n"
+                                             "struct X { X(U) requires bool{std::is_integral<T>{}} {} };\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("template <typename T>\n"
+                                             "struct test { operator int() requires true { return 0; } };\n"));
+        ASSERT_NO_THROW(tokenizeAndStringify("template <typename T>\n"
+                                             "struct test { operator int() requires bool{std::is_integral<T>{}} { return 0; } };\n"));
     }
 
     void noCrash1() {
         ASSERT_NO_THROW(tokenizeAndStringify(
                             "struct A {\n"
-                            "  A( const std::string &name = "" );\n"
+                            "  A( const std::string &name = \" \" );\n"
                             "};\n"
-                            "A::A( const std::string &name ) { return; }\n"))
+                            "A::A( const std::string &name ) { return; }\n"));
     }
 
     // #9007
@@ -7881,51 +8275,722 @@ class TestTokenizer : public TestFixture {
                             "};\n"
                             "template <> d<int>::d(const int &, a::b, double, double);\n"
                             "template <> d<int>::d(const d &) {}\n"
-                            "template <> d<c>::d(const d &) {}\n"))
+                            "template <> d<c>::d(const d &) {}\n"));
+        ignore_errout(); // we do not care about the output
     }
 
-    void checkConfig(const char code[]) {
-        errout.str("");
+    void noCrash3() {
+        ASSERT_NO_THROW(tokenizeAndStringify("void a(X<int> x, typename Y1::Y2<int, A::B::C, 2> y, Z z = []{});"));
+    }
 
-        Settings s;
-        s.checkConfiguration = true;
+    void noCrash4() {
+        ASSERT_NO_THROW(tokenizeAndStringify("static int foo() {\n"
+                                             "    zval ref ;\n"
+                                             "    p = &(ref).value;\n"
+                                             "    return result ;\n"
+                                             "}\n"));
+        ignore_errout();
+    }
+
+    void noCrash5() { // #10603
+        ASSERT_NO_THROW(tokenizeAndStringify("class B { using shared_ptr = std::shared_ptr<Foo>; };\n"
+                                             "class D : public B { void f(const std::shared_ptr<int>& ptr) {} };\n"));
+    }
+
+    void noCrash6() { // #10212
+        ASSERT_NO_THROW(tokenizeAndStringify("template <long, long a = 0> struct b;\n"
+                                             "template <class, bool> struct c;\n"
+                                             "template <template <class, class> class a, class e, class... d>\n"
+                                             "struct c<a<e, d...>, true> {};\n"));
+    }
+
+    void noCrash7() {
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("void g() {\n"// TODO: don't throw
+                                                   "    for (using T = int; (T)false;) {}\n" // C++23 P2360R0: Extend init-statement to allow alias-declaration
+                                                   "}\n"), SYNTAX);
+    }
+
+    template<size_t size>
+    void checkConfig(const char (&code)[size]) {
+        const Settings s = settingsBuilder().checkConfiguration().build();
 
         // tokenize..
-        Tokenizer tokenizer(&s, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(s, *this);
+        ASSERT(tokenizer.tokenize(code));
     }
 
     void checkConfiguration() {
-        checkConfig("void f() { DEBUG(x();y()); }");
-        ASSERT_EQUALS("[test.cpp:1]: (information) Ensure that 'DEBUG' is defined either using -I, --include or -D.\n", errout.str());
+        ASSERT_THROW_INTERNAL_EQUALS(checkConfig("void f() { DEBUG(x();y()); }"),
+                                     UNKNOWN_MACRO,
+                                     "There is an unknown macro here somewhere. Configuration is required. If DEBUG is a macro then please configure it.");
+    }
+
+    void unknownMacroBeforeReturn() {
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify("int f() { X return 0; }"), UNKNOWN_MACRO);
     }
 
-    void unknownType() { // #8952
-        // Clear the error log
-        errout.str("");
-        Settings settings;
-        settings.debugwarnings = true;
+    void cppKeywordInCSource() {
+        ASSERT_NO_THROW(tokenizeAndStringify("int throw() {}", dinit(TokenizeOptions, $.cpp = false)));
 
-        char code[] = "class A {\n"
-                      "public:\n"
-                      "    enum Type { Null };\n"
-                      "};\n"
-                      "using V = A;\n"
-                      "V::Type value;";
+        const char code[] = "void requires(const char*);\n" // #14613
+                            "void f() { requires(\"abc\"); }\n";
+        ASSERT_NO_THROW(tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
+        const Settings s_cpp17 = settingsBuilder().cpp(Standards::CPP17).build();
+        ASSERT_NO_THROW(tokenizeAndStringify(code, s_cpp17, true));
+        const Settings s_cpp20 = settingsBuilder().cpp(Standards::CPP20).build();
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(code, s_cpp20, true), AST);
+    }
+
+    void cppcast() {
+        const char code[] = "a = const_cast<int>(x);\n"
+                            "a = dynamic_cast<int>(x);\n"
+                            "a = reinterpret_cast<int>(x);\n"
+                            "a = static_cast<int>(x);\n";
 
-        // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        ASSERT(tokenizer.tokenize(code));
 
-        tokenizer.printUnknownTypes();
+        for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {
+            ASSERT_EQUALS(tok->str() == "(", tok->isCast());
+        }
+    }
+
+#define checkHdrs(...) checkHdrs_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    std::string checkHdrs_(const char* file, int line, const char (&code)[size], bool checkHeadersFlag) {
+        const Settings settings = settingsBuilder().checkHeaders(checkHeadersFlag).build();
+
+        SimpleTokenizer2 tokenizer(settings, *this, code, "test.cpp");
 
-        ASSERT_EQUALS("", errout.str());
+        // Tokenizer..
+        ASSERT_LOC(tokenizer.simplifyTokens1(""), file, line);
+
+        return tokenizer.tokens()->stringifyList();
     }
 
-    void unknownMacroBeforeReturn() {
-        ASSERT_THROW(tokenizeAndStringify("int f() { X return 0; }"), InternalError);
+    void checkHeader1() {
+        // #9977
+        const char code[] = "# 1 \"test.h\"\n"
+                            "struct A {\n"
+                            "    int a = 1;\n"
+                            "    void f() { g(1); }\n"
+                            "    template <typename T> void g(T x) { a = 2; }\n" // <- template is used and should be kept
+                            "};";
+
+        ASSERT_EQUALS("\n\n##file 1\n"
+                      "1: struct A {\n"
+                      "2: int a ; a = 1 ;\n"
+                      "3: void f ( ) { g<int> ( 1 ) ; }\n"
+                      "4: void g<int> ( int x ) ;\n"
+                      "5: } ;\n"
+                      "4: void A :: g<int> ( int x ) { a = 2 ; }\n",
+                      checkHdrs(code, true));
+
+        ASSERT_EQUALS("\n\n##file 1\n\n"
+                      "1:\n"
+                      "|\n"
+                      "4:\n"
+                      "5: ;\n",
+                      checkHdrs(code, false));
+    }
+
+    void removeExtraTemplateKeywords() {
+        const char code1[] = "typename GridView::template Codim<0>::Iterator iterator;";
+        const char expected1[] = "GridView :: Codim < 0 > :: Iterator iterator ;";
+        ASSERT_EQUALS(expected1, tokenizeAndStringify(code1));
+
+        const char code2[] = "typename GridView::template Codim<0>::Iterator it = gv.template begin<0>();";
+        const char expected2[] = "GridView :: Codim < 0 > :: Iterator it ; it = gv . begin < 0 > ( ) ;";
+        ASSERT_EQUALS(expected2, tokenizeAndStringify(code2));
+    }
+
+    void removeAlignas1() {
+        const char code[] = "alignas(float) unsigned char c[sizeof(float)];";
+        const char expected[] = "unsigned char c [ sizeof ( float ) ] ;";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+    }
+
+    void removeAlignas2() { // Do not remove alignas and alignof in the same way
+        const char code[] = "static_assert( alignof( VertexC ) == 4 );";
+        const char expected[] = "static_assert ( alignof ( VertexC ) == 4 ) ;";
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+    }
+
+    void removeAlignas3() {
+        const char code[] = "alignas(16) int x;";
+        const char expected[] = "int x ;";
+        // According to cppreference alignas() is a C23 macro; but it is often available when compiling C11.
+        // Misra C has C11 examples with alignas.
+        // Microsoft provides alignas in C11.
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code, dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS(expected, tokenizeAndStringify(code));
+    }
+
+    void dumpAlignas() {
+        SimpleTokenizer tokenizer(settingsDefault, *this, false);
+        ASSERT(tokenizer.tokenize("int alignas(8) alignas(16) x;"));
+        ASSERT(Token::simpleMatch(tokenizer.tokens(), "int x ;"));
+        std::ostringstream ostr;
+        tokenizer.dump(ostr);
+        const std::string dump = ostr.str();
+        ASSERT(dump.find(" alignas=\"8\" alignas2=\"16\"") != std::string::npos);
+    }
+
+    void simplifyCoroutines() {
+        const Settings settings = settingsBuilder().cpp(Standards::CPP20).build();
+
+        const char code1[] = "generator<int> f() { co_yield start++; }";
+        const char expected1[] = "generator < int > f ( ) { co_yield ( start ++ ) ; }";
+        ASSERT_EQUALS(expected1, tokenizeAndStringify(code1, settings));
+
+        const char code2[] = "task<> f() { co_await foo(); }";
+        const char expected2[] = "task < > f ( ) { co_await ( foo ( ) ) ; }";
+        ASSERT_EQUALS(expected2, tokenizeAndStringify(code2, settings));
+
+        const char code3[] = "generator<int> f() { co_return 7; }";
+        const char expected3[] = "generator < int > f ( ) { co_return ( 7 ) ; }";
+        ASSERT_EQUALS(expected3, tokenizeAndStringify(code3, settings));
+    }
+
+    void simplifySpaceshipOperator() {
+        const Settings settings = settingsBuilder().cpp(Standards::CPP20).build();
+
+        ASSERT_EQUALS("; x <=> y ;", tokenizeAndStringify(";x<=>y;", settings));
+    }
+
+    void simplifyIfSwitchForInit1() {
+        const Settings settings = settingsBuilder().cpp(Standards::CPP17).build();
+        const char code[] = "void f() { if (a;b) {} }";
+        ASSERT_EQUALS("void f ( ) { { a ; if ( b ) { } } }", tokenizeAndStringify(code, settings));
+    }
+
+    void simplifyIfSwitchForInit2() {
+        const Settings settings = settingsBuilder().cpp(Standards::CPP20).build();
+        const char code[] = "void f() { if (a;b) {} else {} }";
+        ASSERT_EQUALS("void f ( ) { { a ; if ( b ) { } else { } } }", tokenizeAndStringify(code, settings));
+    }
+
+    void simplifyIfSwitchForInit3() {
+        const Settings settings = settingsBuilder().cpp(Standards::CPP20).build();
+        const char code[] = "void f() { switch (a;b) {} }";
+        ASSERT_EQUALS("void f ( ) { { a ; switch ( b ) { } } }", tokenizeAndStringify(code, settings));
+    }
+
+    void simplifyIfSwitchForInit4() {
+        const Settings settings = settingsBuilder().cpp(Standards::CPP20).build();
+        const char code[] = "void f() { for (a;b:c) {} }";
+        ASSERT_EQUALS("void f ( ) { { a ; for ( b : c ) { } } }", tokenizeAndStringify(code, settings));
+    }
+
+    void simplifyIfSwitchForInit5() {
+        const Settings settings = settingsBuilder().cpp(Standards::CPP20).build();
+        const char code[] = "void f() { if ([] { ; }) {} }";
+        ASSERT_EQUALS("void f ( ) { if ( [ ] { ; } ) { } }", tokenizeAndStringify(code, settings));
+    }
+
+    void newPlacementArgsCppInit() { // #13775
+        const char code[] = "::new(nullptr) int {};";
+        SimpleTokenizer tokenizer(settings1, *this);
+        tokenizer.tokenize(code);
+        const Token *inttok = Token::findsimplematch(tokenizer.tokens(), "int");
+        ASSERT(inttok);
+        const Token *brace = inttok->next();
+        ASSERT(brace);
+        ASSERT_EQUALS(brace->astOperand1(), inttok);
+        ASSERT_EQUALS(brace->astOperand2(), static_cast<const Token*>(nullptr));
+    }
+
+    void cpp20_default_bitfield_initializer() {
+        const Settings s1 = settingsBuilder().cpp(Standards::CPP20).build();
+        const char code[] = "struct S { int a:2 = 0; };";
+        ASSERT_EQUALS("struct S { int a ; a = 0 ; } ;", tokenizeAndStringify(code, s1));
+        const Settings s2 = settingsBuilder().cpp(Standards::CPP17).build();
+        ASSERT_THROW_INTERNAL(tokenizeAndStringify(code, s2), SYNTAX);
+    }
+
+    void cpp11init() {
+        #define testIsCpp11init(...) testIsCpp11init_(__FILE__, __LINE__, __VA_ARGS__)
+        auto testIsCpp11init_ = [this](const char* file, int line, const std::string& code, const char* find, Token::Cpp11init expected) {
+            SimpleTokenizer tokenizer(settingsDefault, *this);
+            ASSERT_LOC(tokenizer.tokenize(code.data(), code.size()), file, line);
+
+            const Token* tok = Token::findsimplematch(tokenizer.tokens(), find, strlen(find));
+            ASSERT_LOC(tok, file, line);
+            ASSERT_LOC(tok->isCpp11init() == expected, file, line);
+        };
+
+        testIsCpp11init("class X : public A<int>, C::D {};",
+                        "D {",
+                        Token::Cpp11init::NOINIT);
+
+        testIsCpp11init("auto f() -> void {}",
+                        "void {",
+                        Token::Cpp11init::NOINIT);
+        testIsCpp11init("auto f() & -> void {}",
+                        "void {",
+                        Token::Cpp11init::NOINIT);
+        testIsCpp11init("auto f() const noexcept(false) -> void {}",
+                        "void {",
+                        Token::Cpp11init::NOINIT);
+        testIsCpp11init("auto f() -> std::vector<int> { return {}; }",
+                        "{ return",
+                        Token::Cpp11init::NOINIT);
+        testIsCpp11init("auto f() -> std::vector<int> { return {}; }",
+                        "vector",
+                        Token::Cpp11init::NOINIT);
+        testIsCpp11init("auto f() -> std::vector<int> { return {}; }",
+                        "std ::",
+                        Token::Cpp11init::NOINIT);
+
+        testIsCpp11init("class X{};",
+                        "{ }",
+                        Token::Cpp11init::NOINIT);
+        testIsCpp11init("class X{}", // forgotten ; so not properly recognized as a class
+                        "{ }",
+                        Token::Cpp11init::CPP11INIT);
+
+        testIsCpp11init("namespace abc::def { TEST(a, b) {} }",
+                        "{ TEST",
+                        Token::Cpp11init::NOINIT);
+        testIsCpp11init("namespace { TEST(a, b) {} }", // anonymous namespace
+                        "{ TEST",
+                        Token::Cpp11init::NOINIT);
+
+        testIsCpp11init("enum { e = decltype(s)::i };",
+                        "{ e",
+                        Token::Cpp11init::NOINIT);
+
+        testIsCpp11init("template <typename T>\n" // #11378
+                        "class D<M<T, 1>> : public B<M<T, 1>, T> {\n"
+                        "public:\n"
+                        "    D(int x) : B<M<T, 1>, T>(x) {}\n"
+                        "};\n",
+                        "{ public:",
+                        Token::Cpp11init::NOINIT);
+
+        testIsCpp11init("template <typename T>\n"
+                        "class D<M<T, 1>> : B<M<T, 1>, T> {\n"
+                        "public:\n"
+                        "    D(int x) : B<M<T, 1>, T>(x) {}\n"
+                        "};\n",
+                        "{ public:",
+                        Token::Cpp11init::NOINIT);
+
+        testIsCpp11init("using namespace std;\n"
+                        "namespace internal {\n"
+                        "    struct S { S(); };\n"
+                        "}\n"
+                        "namespace internal {\n"
+                        "    S::S() {}\n"
+                        "}\n",
+                        "{ } }",
+                        Token::Cpp11init::NOINIT);
+
+        testIsCpp11init("template <std::size_t N>\n"
+                        "struct C : public C<N - 1>, public B {\n"
+                        "    ~C() {}\n"
+                        "};\n",
+                        "{ } }",
+                        Token::Cpp11init::NOINIT);
+
+        testIsCpp11init("struct S { int i; } s;\n"
+                        "struct T : decltype (s) {\n"
+                        "    T() : decltype(s) ({ 0 }) { }\n"
+                        "};\n",
+                        "{ } }",
+                        Token::Cpp11init::NOINIT);
+
+        testIsCpp11init("struct S {};\n"
+                        "template<class... Args>\n"
+                        "struct T;\n"
+                        "template<class... Args>\n"
+                        "struct T<void, Args...> final : S {\n"
+                        "    void operator()(Args...) {}\n"
+                        "};\n",
+                        "{ void",
+                        Token::Cpp11init::NOINIT);
+
+        testIsCpp11init("struct S {\n"
+                        "    std::uint8_t* p;\n"
+                        "    S() : p{ new std::uint8_t[1]{} } {}\n"
+                        "};\n",
+                        "{ } } {",
+                        Token::Cpp11init::CPP11INIT);
+
+        testIsCpp11init("struct S {\n"
+                        "    S() : p{new (malloc(4)) int{}} {}\n"
+                        "    int* p;\n"
+                        "};\n",
+                        "{ } } {",
+                        Token::Cpp11init::CPP11INIT);
+
+        testIsCpp11init("void f() { g([]() {}, { 1 }); }\n",
+                        "{ 1",
+                        Token::Cpp11init::CPP11INIT);
+
+        ASSERT_NO_THROW(tokenizeAndStringify("template<typename U> struct X {};\n" // don't crash
+                                             "template<typename T> auto f(T t) -> X<decltype(t + 1)> {}\n"));
+        ASSERT_EQUALS("[test.cpp:2:22]: (debug) auto token with no type. [autoNoType]\n", errout_str());
+        #undef testIsCpp11init
+    }
+
+    void testDirectiveIncludeTypes() {
+        const char filedata[] = "#define macro some definition\n"
+                                "#undef macro\n"
+                                "#ifdef macro\n"
+                                "#elif some (complex) condition\n"
+                                "#else\n"
+                                "#endif\n"
+                                "#if some other condition\n"
+                                "#pragma some proprietary content\n"
+                                "#\n" /* may appear in old C code */
+                                "#ident some text\n" /* may appear in old C code */
+                                "#unknownmacro some unpredictable text\n"
+                                "#warning some warning message\n"
+                                "#error some error message\n";
+        const char dumpdata[] = "  <directivelist>\n"
+                                "    <directive file=\"test.c\" linenr=\"1\" str=\"#define macro some definition\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"define\"/>\n"
+                                "      <token column=\"9\" str=\"macro\"/>\n"
+                                "      <token column=\"15\" str=\"some\"/>\n"
+                                "      <token column=\"20\" str=\"definition\"/>\n"
+                                "    </directive>\n"
+                                "    <directive file=\"test.c\" linenr=\"2\" str=\"#undef macro\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"undef\"/>\n"
+                                "      <token column=\"8\" str=\"macro\"/>\n"
+                                "    </directive>\n"
+                                "    <directive file=\"test.c\" linenr=\"3\" str=\"#ifdef macro\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"ifdef\"/>\n"
+                                "      <token column=\"8\" str=\"macro\"/>\n"
+                                "    </directive>\n"
+                                "    <directive file=\"test.c\" linenr=\"4\" str=\"#elif some (complex) condition\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"elif\"/>\n"
+                                "      <token column=\"7\" str=\"some\"/>\n"
+                                "      <token column=\"12\" str=\"(\"/>\n"
+                                "      <token column=\"13\" str=\"complex\"/>\n"
+                                "      <token column=\"20\" str=\")\"/>\n"
+                                "      <token column=\"22\" str=\"condition\"/>\n"
+                                "    </directive>\n"
+                                "    <directive file=\"test.c\" linenr=\"5\" str=\"#else\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"else\"/>\n"
+                                "    </directive>\n"
+                                "    <directive file=\"test.c\" linenr=\"6\" str=\"#endif\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"endif\"/>\n"
+                                "    </directive>\n"
+                                "    <directive file=\"test.c\" linenr=\"7\" str=\"#if some other condition\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"if\"/>\n"
+                                "      <token column=\"5\" str=\"some\"/>\n"
+                                "      <token column=\"10\" str=\"other\"/>\n"
+                                "      <token column=\"16\" str=\"condition\"/>\n"
+                                "    </directive>\n"
+                                "    <directive file=\"test.c\" linenr=\"8\" str=\"#pragma some proprietary content\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"pragma\"/>\n"
+                                "      <token column=\"9\" str=\"some\"/>\n"
+                                "      <token column=\"14\" str=\"proprietary\"/>\n"
+                                "      <token column=\"26\" str=\"content\"/>\n"
+                                "    </directive>\n"
+                                "    <directive file=\"test.c\" linenr=\"9\" str=\"#\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "    </directive>\n"
+                                "    <directive file=\"test.c\" linenr=\"10\" str=\"#ident some text\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"ident\"/>\n"
+                                "      <token column=\"8\" str=\"some\"/>\n"
+                                "      <token column=\"13\" str=\"text\"/>\n"
+                                "    </directive>\n"
+                                "    <directive file=\"test.c\" linenr=\"11\" str=\"#unknownmacro some unpredictable text\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"unknownmacro\"/>\n"
+                                "      <token column=\"15\" str=\"some\"/>\n"
+                                "      <token column=\"20\" str=\"unpredictable\"/>\n"
+                                "      <token column=\"34\" str=\"text\"/>\n"
+                                "    </directive>\n"
+                                "    <directive file=\"test.c\" linenr=\"12\" str=\"#warning some warning message\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"warning\"/>\n"
+                                "      <token column=\"10\" str=\"some warning message\"/>\n"
+                                "    </directive>\n"
+                                "    <directive file=\"test.c\" linenr=\"13\" str=\"#error some error message\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"error\"/>\n"
+                                "      <token column=\"8\" str=\"some error message\"/>\n"
+                                "    </directive>\n"
+                                "  </directivelist>\n"
+                                "  <tokenlist>\n"
+                                "  </tokenlist>\n";
+
+        std::ostringstream ostr;
+        directiveDump(filedata, ostr);
+        ASSERT_EQUALS(dumpdata, ostr.str());
+    }
+
+    void testDirectiveIncludeLocations() {
+        const char filedata[] = "#define macro1 val\n"
+                                "#file \"inc1.h\"\n"
+                                "#define macro2 val\n"
+                                "#file \"inc2.h\"\n"
+                                "#define macro3 val\n"
+                                "#endfile\n"
+                                "#define macro4 val\n"
+                                "#endfile\n"
+                                "#define macro5 val\n";
+        const char dumpdata[] = "  <directivelist>\n"
+                                "    <directive file=\"test.c\" linenr=\"1\" str=\"#define macro1 val\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"define\"/>\n"
+                                "      <token column=\"9\" str=\"macro1\"/>\n"
+                                "      <token column=\"16\" str=\"val\"/>\n"
+                                "    </directive>\n"
+                                "    <directive file=\"test.c\" linenr=\"2\" str=\"#include &quot;inc1.h&quot;\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"file\"/>\n"
+                                "      <token column=\"7\" str=\"&quot;inc1.h&quot;\"/>\n"
+                                "    </directive>\n"
+                                "    <directive file=\"inc1.h\" linenr=\"1\" str=\"#define macro2 val\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"define\"/>\n"
+                                "      <token column=\"9\" str=\"macro2\"/>\n"
+                                "      <token column=\"16\" str=\"val\"/>\n"
+                                "    </directive>\n"
+                                "    <directive file=\"inc1.h\" linenr=\"2\" str=\"#include &quot;inc2.h&quot;\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"file\"/>\n"
+                                "      <token column=\"7\" str=\"&quot;inc2.h&quot;\"/>\n"
+                                "    </directive>\n"
+                                "    <directive file=\"inc2.h\" linenr=\"1\" str=\"#define macro3 val\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"define\"/>\n"
+                                "      <token column=\"9\" str=\"macro3\"/>\n"
+                                "      <token column=\"16\" str=\"val\"/>\n"
+                                "    </directive>\n"
+                                "    <directive file=\"inc1.h\" linenr=\"3\" str=\"#define macro4 val\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"define\"/>\n"
+                                "      <token column=\"9\" str=\"macro4\"/>\n"
+                                "      <token column=\"16\" str=\"val\"/>\n"
+                                "    </directive>\n"
+                                "    <directive file=\"test.c\" linenr=\"3\" str=\"#define macro5 val\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"define\"/>\n"
+                                "      <token column=\"9\" str=\"macro5\"/>\n"
+                                "      <token column=\"16\" str=\"val\"/>\n"
+                                "    </directive>\n"
+                                "  </directivelist>\n"
+                                "  <tokenlist>\n"
+                                "  </tokenlist>\n";
+        std::ostringstream ostr;
+        directiveDump(filedata, ostr);
+        ASSERT_EQUALS(dumpdata, ostr.str());
+    }
+
+    void testDirectiveIncludeComments() {
+        const char filedata[] = "#ifdef macro2 /* this will be removed */\n"
+                                "#else /* this will be removed too */\n"
+                                "#endif /* this will also be removed */\n";
+        const char dumpdata[] = "  <directivelist>\n"
+                                "    <directive file=\"test.c\" linenr=\"1\" str=\"#ifdef macro2\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"ifdef\"/>\n"
+                                "      <token column=\"8\" str=\"macro2\"/>\n"
+                                "    </directive>\n"
+                                "    <directive file=\"test.c\" linenr=\"2\" str=\"#else\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"else\"/>\n"
+                                "    </directive>\n"
+                                "    <directive file=\"test.c\" linenr=\"3\" str=\"#endif\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"endif\"/>\n"
+                                "    </directive>\n"
+                                "  </directivelist>\n"
+                                "  <tokenlist>\n"
+                                "  </tokenlist>\n";
+
+        std::ostringstream ostr;
+        directiveDump(filedata, ostr);
+        ASSERT_EQUALS(dumpdata, ostr.str());
+    }
+
+    void testDirectiveRelativePath() {
+        const char filedata[] = "#define macro 1\n";
+        const char dumpdata[] = "  <directivelist>\n"
+                                "    <directive file=\"test.c\" linenr=\"1\" str=\"#define macro 1\">\n"
+                                "      <token column=\"1\" str=\"#\"/>\n"
+                                "      <token column=\"2\" str=\"define\"/>\n"
+                                "      <token column=\"9\" str=\"macro\"/>\n"
+                                "      <token column=\"15\" str=\"1\"/>\n"
+                                "    </directive>\n"
+                                "  </directivelist>\n"
+                                "  <tokenlist>\n"
+                                "  </tokenlist>\n";
+        std::ostringstream ostr;
+        Settings s;
+        s.relativePaths = true;
+        s.basePaths.emplace_back("/some/path");
+        directiveDump(filedata, "/some/path/test.c", s, ostr);
+        ASSERT_EQUALS(dumpdata, ostr.str());
+    }
+
+    void funcnameInParenthesis1() { // #13554
+        const char code[] = "void f(void) {\n"
+                            "  double result = (strtod)(\"NAN\", NULL);\n"
+                            "}\n";
+        SimpleTokenizer tokenizer(settings1, *this, false);
+        ASSERT_LOC(tokenizer.tokenize(code), __FILE__, __LINE__);
+        const Token *f = Token::findsimplematch(tokenizer.tokens(), "strtod");
+        ASSERT(f);
+        ASSERT(!f->previous()->isCast());
+    }
+
+    void funcnameInParenthesis2() { // #13578
+        const char code[] = "int f(double a, double b, double c) {\n"
+                            "    return static_cast<int>(std::ceil((std::min)(a, (std::min)(b, c))));\n"
+                            "}\n";
+        SimpleTokenizer tokenizer(settings1, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), __FILE__, __LINE__);
+        const Token *f = Token::findsimplematch(tokenizer.tokens(), "min");
+        ASSERT(f);
+        const Token *par = f->next();
+        ASSERT(par);
+        ASSERT(Token::simpleMatch(par, "("));
+        ASSERT_EQUALS(par->astOperand1(), f->astParent() /* :: */);
+        ASSERT(Token::simpleMatch(par->astOperand2(), ","));
+    }
+
+    void funcnameInParenthesis3() { // #13585
+        const char code[] = "int f(int a, int b) {\n"
+                            "    return (a != 0) ? 1 : (std::min)(1, b);\n"
+                            "}\n";
+        SimpleTokenizer tokenizer(settings1, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), __FILE__, __LINE__);
+        const Token *f = Token::findsimplematch(tokenizer.tokens(), "min");
+        ASSERT(f);
+        const Token *par = f->next();
+        ASSERT(par);
+        ASSERT(Token::simpleMatch(par, "("));
+        ASSERT_EQUALS(par->astOperand1(), f->astParent() /* :: */);
+        ASSERT(Token::simpleMatch(par->astOperand2(), ","));
+    }
+
+    void genericInIf() { // #13561
+        const char code[] = "  if (_Generic(s, char * : 1, const float * : (a ? b, c : d), volatile int * : 3, default : 0)) {}";
+        const char ast[] = "(( if (( _Generic (, (, (, (, s 1) (? a (: (, b c) d))) 3) 0)))";
+        ASSERT_EQUALS(ast, testAst(code, AstStyle::Z3));
+    }
+
+    void preincrementInLambda() { // #13312
+        const char code[] =
+            "void f(const std::vector<int>& v, int a) {\n"
+            "    std::for_each(v.begin(), v.end(), [&](int i)  {\n"
+            "        switch (i) {\n"
+            "        default:\n"
+            "            ++a;\n"
+            "        }\n"
+            "    });\n"
+            "}\n";
+        ASSERT_NO_THROW(tokenizeAndStringify(code));
+    }
+
+    void atomicCast() { // #12605
+        const char code[] = "int atomic_add_int(int *ptr, int v)\n"
+                            "{\n"
+                            "    return atomic_fetch_add((_Atomic(unsigned int) *)ptr, v) + v;\n"
+                            "}\n";
+        ASSERT_NO_THROW(tokenizeAndStringify(code, settingsDefault, false));
+    }
+
+    void constFunctionPtrTypedef() { // #12135
+        const char code[] = "struct S {\n"
+                            "    template<typename T> T g() {\n"
+                            "        return T();\n"
+                            "    }\n"
+                            "};\n"
+                            "void f() {\n"
+                            "    S s;\n"
+                            "    typedef void (*fp_t)();\n"
+                            "    if (fp_t const fp = s.g<fp_t>()) {}\n"
+                            "}\n";
+        ASSERT_NO_THROW(tokenizeAndStringify(code));
+        ASSERT_EQUALS("void ( * const f ) ( ) ;", tokenizeAndStringify("typedef void (*fp_t)(); fp_t const f;"));
+    }
+
+    void simplifyPlatformTypes() {
+        {
+            const char code[] = "size_t f();";
+            ASSERT_EQUALS("unsigned long f ( ) ;", tokenizeAndStringify(code, settings2_unix32));
+            ASSERT_EQUALS("unsigned long f ( ) ;", tokenizeAndStringify(code, settings2_unix64));
+        }
+        {
+            const char code[] = "ssize_t f();";
+            ASSERT_EQUALS("long f ( ) ;", tokenizeAndStringify(code, settings2_unix32));
+            ASSERT_EQUALS("long f ( ) ;", tokenizeAndStringify(code, settings2_unix64));
+        }
+        {
+            const char code[] = "std::ptrdiff_t f();";
+            ASSERT_EQUALS("long f ( ) ;", tokenizeAndStringify(code, settings2_unix32));
+            ASSERT_EQUALS("long f ( ) ;", tokenizeAndStringify(code, settings2_unix64));
+        }
+    }
+
+    void dumpFallthrough() {
+        const char code[] = "void f(int n) {\n"
+                            "    void g(), h(), i();\n"
+                            "    switch (n) {\n"
+                            "        case 1:\n"
+                            "        case 2:\n"
+                            "            g();\n"
+                            "            [[fallthrough]];\n"
+                            "        case 3:\n"
+                            "            h();\n"
+                            "            break;\n"
+                            "        default:\n"
+                            "            i();\n"
+                            "            break;\n"
+                            "    }\n"
+                            "}";
+        SimpleTokenizer tokenizer(settingsDefault, *this, false);
+        ASSERT(tokenizer.tokenize(code));
+        std::ostringstream ostr;
+        tokenizer.dump(ostr);
+        const std::string dump = ostr.str();
+        ASSERT(dump.find(" isAttributeFallthrough=\"true\"") != std::string::npos);
+    }
+
+    void simplifyRedundantParentheses() {
+        const char code[] = "int f(struct S s) {\n"
+                            "    return g(1, &(int){ s.i });\n"
+                            "}\n";
+        SimpleTokenizer tokenizer(settingsDefault, *this, false);
+        ASSERT_NO_THROW(tokenizer.tokenize(code));
+    }
+
+    void simplifyEnum1() {
+        const char code[] = "static enum {A,B} ab;";
+        ASSERT_EQUALS("enum Anonymous0 { A , B } ; static enum Anonymous0 ab ;", tokenizeAndStringify(code));
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        tokenizer.tokenize(code);
+        const Token* tok = Token::findsimplematch(tokenizer.tokens(), "static");
+        ASSERT(tok);
+        ASSERT_EQUALS(tok->column(), 1);
+        ASSERT_EQUALS(tok->next()->column(), 8);
+    }
+
+    void simplifyEnum2() {
+        const char code[] = "enum AB {A,B}; enum AB static ab; ";
+        ASSERT_EQUALS("enum AB { A , B } ; static enum AB ab ;", tokenizeAndStringify(code));
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        tokenizer.tokenize(code);
+        const Token* tok = Token::findsimplematch(tokenizer.tokens(), "static");
+        ASSERT(tok);
+        ASSERT_EQUALS(tok->column(), 24);
+        ASSERT_EQUALS(tok->next()->column(), 16);
     }
 };
 
diff --git a/test/testtokenlist.cpp b/test/testtokenlist.cpp
index 5e29756a944..4e658743f92 100644
--- a/test/testtokenlist.cpp
+++ b/test/testtokenlist.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,61 +17,175 @@
  */
 
 #include "settings.h"
-#include "testsuite.h"
+#include "fixture.h"
+#include "helpers.h"
+#include "path.h"
+#include "platform.h"
+#include "preprocessor.h"
+#include "standards.h"
 #include "token.h"
 #include "tokenlist.h"
 
-#include <sstream>
+#include <stack>
 #include <string>
+#include <utility>
+#include <vector>
+
+#include <simplecpp.h>
 
 class TestTokenList : public TestFixture {
 public:
-    TestTokenList() : TestFixture("TestTokenList") {
-    }
+    TestTokenList() : TestFixture("TestTokenList")
+    {}
 
 private:
-    Settings settings;
-
-    void run() OVERRIDE {
+    void run() override {
         TEST_CASE(testaddtoken1);
         TEST_CASE(testaddtoken2);
         TEST_CASE(inc);
+        TEST_CASE(isKeyword);
+        TEST_CASE(notokens);
+        TEST_CASE(ast1);
     }
 
     // inspired by #5895
-    void testaddtoken1() {
+    void testaddtoken1() const {
         const std::string code = "0x89504e470d0a1a0a";
-        TokenList tokenlist(&settings);
+        TokenList tokenlist(settingsDefault, Standards::Language::CPP);
         tokenlist.addtoken(code, 1, 1, false);
-        ASSERT_EQUALS("9894494448401390090U", tokenlist.front()->str());
-        // that is supposed to break on 32bit
-        //unsigned long numberUL(0);
-        //std::istringstream(tokenlist.front()->str()) >> numberUL;
-        //ASSERT_EQUALS(9894494448401390090U, numberUL);
-        unsigned long long numberULL(0);
-        std::istringstream(tokenlist.front()->str()) >> numberULL;
-        ASSERT_EQUALS(9894494448401390090U, numberULL);
+        ASSERT_EQUALS("0x89504e470d0a1a0a", tokenlist.front()->str());
     }
 
-    void testaddtoken2() {
+    void testaddtoken2() const {
         const std::string code = "0xF0000000";
-        settings.int_bit = 32;
-        TokenList tokenlist(&settings);
+        const Settings settings1 = dinit(Settings, $.platform.int_bit = 32);
+        TokenList tokenlist(settings1, Standards::Language::CPP);
         tokenlist.addtoken(code, 1, 1, false);
-        ASSERT_EQUALS("4026531840U", tokenlist.front()->str());
+        ASSERT_EQUALS("0xF0000000", tokenlist.front()->str());
     }
 
     void inc() const {
         const char code[] = "a++1;1++b;";
 
-        errout.str("");
+        const SimpleTokenList tokenlist(code);
+        ASSERT(Token::simpleMatch(tokenlist.front(), "a + + 1 ; 1 + + b ;"));
+    }
+
+    void isKeyword() const {
 
-        // tokenize..
-        TokenList tokenlist(&settings);
-        std::istringstream istr(code);
-        tokenlist.createTokens(istr, "a.cpp");
+        const char code[] = "for a int delete true";
 
-        ASSERT(Token::simpleMatch(tokenlist.front(), "a + + 1 ; 1 + + b ;"));
+        {
+            const SimpleTokenList tokenlist(code, Standards::Language::C);
+
+            ASSERT_EQUALS(true, tokenlist.front()->isKeyword());
+            ASSERT_EQUALS(true, tokenlist.front()->isControlFlowKeyword());
+            ASSERT_EQUALS(false, tokenlist.front()->next()->isKeyword());
+            ASSERT_EQUALS(false, tokenlist.front()->next()->isControlFlowKeyword());
+            ASSERT_EQUALS(false, tokenlist.front()->tokAt(2)->isKeyword());
+            ASSERT_EQUALS(true, tokenlist.front()->tokAt(2)->tokType() == Token::eType);
+            ASSERT_EQUALS(false, tokenlist.front()->tokAt(2)->isControlFlowKeyword());
+            ASSERT_EQUALS(false, tokenlist.front()->tokAt(3)->isKeyword());
+            ASSERT_EQUALS(false, tokenlist.front()->tokAt(3)->isControlFlowKeyword());
+            ASSERT_EQUALS(false, tokenlist.front()->tokAt(4)->isKeyword());
+            ASSERT_EQUALS(true, tokenlist.front()->tokAt(4)->isLiteral());
+            ASSERT_EQUALS(false, tokenlist.front()->tokAt(4)->isControlFlowKeyword());
+        }
+        {
+            const SimpleTokenList tokenlist(code);
+
+            ASSERT_EQUALS(true, tokenlist.front()->isKeyword());
+            ASSERT_EQUALS(true, tokenlist.front()->isControlFlowKeyword());
+            ASSERT_EQUALS(false, tokenlist.front()->next()->isKeyword());
+            ASSERT_EQUALS(false, tokenlist.front()->next()->isControlFlowKeyword());
+            ASSERT_EQUALS(false, tokenlist.front()->tokAt(2)->isKeyword());
+            ASSERT_EQUALS(true, tokenlist.front()->tokAt(2)->tokType() == Token::eType);
+            ASSERT_EQUALS(false, tokenlist.front()->tokAt(2)->isControlFlowKeyword());
+            ASSERT_EQUALS(true, tokenlist.front()->tokAt(3)->isKeyword());
+            ASSERT_EQUALS(false, tokenlist.front()->tokAt(3)->isControlFlowKeyword());
+            ASSERT_EQUALS(false, tokenlist.front()->tokAt(4)->isKeyword());
+            ASSERT_EQUALS(true, tokenlist.front()->tokAt(4)->isLiteral());
+            ASSERT_EQUALS(false, tokenlist.front()->tokAt(4)->isControlFlowKeyword());
+        }
+
+        {
+            const char code2[] = "_Generic"; // C11 keyword
+            const SimpleTokenList tokenlist(code2); // default settings use latest standard
+            ASSERT_EQUALS(false, tokenlist.front()->isKeyword());
+        }
+
+        {
+            const char code2[] = "_Generic"; // C11 keyword
+            const SimpleTokenList tokenlist(code2, Standards::Language::C); // default settings use latest standard
+            ASSERT_EQUALS(true, tokenlist.front()->isKeyword());
+        }
+
+        {
+            const char code2[] = "_Generic"; // C11 keyword
+            const Settings s = settingsBuilder().c(Standards::C89).build();
+            TokenList tokenlist(s, Standards::Language::C);
+            tokenlist.appendFileIfNew("a.c");
+            ASSERT(tokenlist.createTokensFromString(code2));
+            ASSERT_EQUALS(false, tokenlist.front()->isKeyword());
+        }
+
+        {
+            const char code2[] = "co_return"; // C++20 keyword
+            const SimpleTokenList tokenlist(code2); // default settings use latest standard
+            ASSERT_EQUALS(true, tokenlist.front()->isKeyword());
+        }
+
+        {
+            const char code2[] = "co_return"; // C++20 keyword
+            const SimpleTokenList tokenlist(code2, Standards::Language::C); // default settings use latest standard
+            ASSERT_EQUALS(false, tokenlist.front()->isKeyword());
+        }
+
+        {
+            const char code2[] = "noexcept"; // C++11 keyword
+            const Settings s = settingsBuilder().cpp(Standards::CPP03).build();
+            TokenList tokenlist(s, Standards::Language::CPP);
+            tokenlist.appendFileIfNew("a.cpp");
+            ASSERT(tokenlist.createTokensFromString(code2));
+            ASSERT_EQUALS(false, tokenlist.front()->isKeyword());
+        }
+    }
+
+    void notokens() {
+        // analyzing /usr/include/poll.h caused Path::identify() to be called with an empty filename from
+        // TokenList::determineCppC() because there are no tokens
+        const char code[] = "#include <sys/poll.h>";
+        std::vector<std::string> files;
+        simplecpp::TokenList tokens1(code, files, "poll.h", nullptr);
+        Preprocessor preprocessor(tokens1, settingsDefault, *this, Path::identify(tokens1.getFiles()[0], false));
+        simplecpp::OutputList outputList_pp;
+        simplecpp::TokenList tokensP = preprocessor.preprocess("", files, outputList_pp);
+        ASSERT(!preprocessor.reportOutput(outputList_pp, true));
+        TokenList tokenlist(settingsDefault, Standards::Language::C); // headers are treated as C files
+        tokenlist.createTokens(std::move(tokensP)); // do not assert
+    }
+
+    void ast1() const {
+        const char code[] = "('Release|x64' == 'Release|x64');";
+
+        TokenList tokenlist(settingsDefault, Standards::Language::C);
+        ASSERT(tokenlist.createTokensFromString(code));
+        // TODO: put this logic in TokenList
+        // generate links
+        {
+            std::stack<Token*> lpar;
+            for (Token* tok2 = tokenlist.front(); tok2; tok2 = tok2->next()) {
+                if (tok2->str() == "(")
+                    lpar.push(tok2);
+                else if (tok2->str() == ")") {
+                    if (lpar.empty())
+                        break;
+                    Token::createMutualLinks(lpar.top(), tok2);
+                    lpar.pop();
+                }
+            }
+        }
+        tokenlist.createAst(); // do not crash
     }
 };
 
diff --git a/test/testtokenrange.cpp b/test/testtokenrange.cpp
new file mode 100644
index 00000000000..e27e6c5b038
--- /dev/null
+++ b/test/testtokenrange.cpp
@@ -0,0 +1,131 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2024 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "fixture.h"
+#include "helpers.h"
+#include "token.h"
+#include "tokenrange.h"
+#include "symboldatabase.h"
+
+#include <algorithm>
+#include <iterator>
+#include <list>
+#include <sstream>
+#include <string>
+
+
+class TestTokenRange : public TestFixture {
+public:
+    TestTokenRange() : TestFixture("TestTokenRange") {}
+
+private:
+    void run() override {
+        TEST_CASE(enumerationToEnd);
+        TEST_CASE(untilHelperToEnd);
+        TEST_CASE(untilHelperPartWay);
+        TEST_CASE(partialEnumeration);
+        TEST_CASE(scopeExample);
+        TEST_CASE(exampleAlgorithms);
+    }
+
+    static std::string testTokenRange(ConstTokenRange range, const Token* start, const Token* end) {
+        auto tokenToString = [](const Token* t) {
+            return t ? t->str() : "<null>";
+        };
+        int index = 0;
+        const Token* expected = start;
+        for (const Token* t : range) {
+            if (expected != t) {
+                std::ostringstream message;
+                message << "Failed to match token " << tokenToString(expected) << " at position " << index << ". Got " << tokenToString(t) << " instead";
+                return message.str();
+            }
+            index++;
+            expected = expected->next();
+        }
+        if (expected != end) {
+            std::ostringstream message;
+            message << "Failed to terminate on " << tokenToString(end) << ". Instead terminated on " << tokenToString(expected) << " at position " << index << ".";
+            return message.str();
+        }
+        return "";
+    }
+
+    void enumerationToEnd() const {
+        const char code[] = "void a(){} void main(){ if(true){a();} }";
+        const SimpleTokenList tokenList(code);
+        ASSERT_EQUALS("", testTokenRange(ConstTokenRange{ tokenList.front(), nullptr }, tokenList.front(), nullptr));
+    }
+
+    void untilHelperToEnd() const {
+        const char code[] = "void a(){} void main(){ if(true){a();} }";
+        const SimpleTokenList tokenList(code);
+        ASSERT_EQUALS("", testTokenRange(tokenList.front()->until(nullptr), tokenList.front(), nullptr));
+    }
+
+    void untilHelperPartWay() const {
+        const char code[] = "void a(){} void main(){ if(true){a();} }";
+        const SimpleTokenList tokenList(code);
+        const Token* start = tokenList.front()->tokAt(4);
+        const Token* end = start->tokAt(8);
+        ASSERT_EQUALS("", testTokenRange(start->until(end), start, end));
+    }
+
+    void partialEnumeration() const {
+        const char code[] = "void a(){} void main(){ if(true){a();} }";
+        const SimpleTokenList tokenList(code);
+        const Token* start = tokenList.front()->tokAt(4);
+        const Token* end = tokenList.front()->tokAt(10);
+        ASSERT_EQUALS("", testTokenRange(ConstTokenRange{ start, end }, start, end));
+    }
+
+    void scopeExample() {
+        SimpleTokenizer tokenizer(settingsDefault, *this);
+        const char code[] = "void a(){} void main(){ if(true){a();} }";
+        ASSERT(tokenizer.tokenize(code));
+
+        const SymbolDatabase* sd = tokenizer.getSymbolDatabase();
+        const Scope& scope = *std::next(sd->scopeList.cbegin(), 3); //The scope of the if block
+
+        std::string contents;
+        for (const Token* t : ConstTokenRange{ scope.bodyStart->next(), scope.bodyEnd }) {
+            contents += t->str();
+        }
+        ASSERT_EQUALS("a();", contents);
+    }
+
+    void exampleAlgorithms() const {
+        const char code[] = "void a(){} void main(){ if(true){a();} }";
+        const SimpleTokenList tokenList(code);
+        ConstTokenRange range{ tokenList.front(), nullptr };
+        ASSERT_EQUALS(true, std::all_of(range.begin(), range.end(), [](const Token*) {
+            return true;
+        }));
+        ASSERT_EQUALS(true, std::any_of(range.begin(), range.end(), [](const Token* t) {
+            return t->str() == "true";
+        }));
+        ASSERT_EQUALS("true", (*std::find_if(range.begin(), range.end(), [](const Token* t) {
+            return t->str() == "true";
+        }))->str());
+        ASSERT_EQUALS(3, std::count_if(range.begin(), range.end(), [](const Token* t) {
+            return t->str() == "{";
+        }));
+    }
+};
+
+REGISTER_TEST(TestTokenRange)
diff --git a/test/testtype.cpp b/test/testtype.cpp
index 956feadecec..280e3357f85 100644
--- a/test/testtype.cpp
+++ b/test/testtype.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,152 +17,199 @@
  */
 
 #include "checktype.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "platform.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
+#include "standards.h"
 
+#include <cstddef>
 #include <string>
 
 class TestType : public TestFixture {
 public:
-    TestType() : TestFixture("TestType") {
-    }
+    TestType() : TestFixture("TestType") {}
 
 private:
 
 
-    void run() OVERRIDE {
+    void run() override {
         TEST_CASE(checkTooBigShift_Unix32);
+        mNewTemplate = true;
         TEST_CASE(checkIntegerOverflow);
         TEST_CASE(signConversion);
         TEST_CASE(longCastAssign);
         TEST_CASE(longCastReturn);
         TEST_CASE(checkFloatToIntegerOverflow);
+        TEST_CASE(integerOverflow); // #11794
+        TEST_CASE(shiftTooManyBits); // #11496
     }
 
-    void check(const char code[], Settings* settings = nullptr, const char filename[] = "test.cpp", const std::string& standard = "c++11") {
-        // Clear the error buffer..
-        errout.str("");
+    struct CheckOptions
+    {
+        const Settings* settings = nullptr; // TODO: split from this
+        Standards::cppstd_t standard = Standards::cppstd_t::CPP11;
+    };
 
-        if (!settings) {
-            static Settings _settings;
-            settings = &_settings;
-        }
-        settings->addEnabled("warning");
-        settings->addEnabled("portability");
-        settings->standards.setCPP(standard);
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
+        const Settings settings1 = settingsBuilder(options.settings ? *options.settings : settingsDefault).severity(Severity::warning).severity(Severity::portability).cpp(options.standard).build();
+
+        // Tokenize..
+        SimpleTokenizer tokenizer(settings1, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+
+        // Check..
+        runChecks<CheckType>(tokenizer, this);
+    }
+
+    // TODO: get rid of this
+    void check_(const char* file, int line, const std::string& code, const CheckOptions& options = make_default_obj()) {
+        const Settings settings1 = settingsBuilder(options.settings ? *options.settings : settingsDefault).severity(Severity::warning).severity(Severity::portability).cpp(options.standard).build();
 
         // Tokenize..
-        Tokenizer tokenizer(settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, filename);
+        SimpleTokenizer tokenizer(settings1, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+
+        // Check..
+        runChecks<CheckType>(tokenizer, this);
+    }
+
+    struct CheckPOptions
+    {
+        const Settings* settings = nullptr;
+        bool cpp = true;
+    };
+
+#define checkP(...) checkP_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkP_(const char* file, int line, const char (&code)[size], const CheckPOptions& options = make_default_obj()) {
+        const Settings settings1 = settingsBuilder(options.settings ? *options.settings : settingsDefault).severity(Severity::warning).severity(Severity::portability).build();
+
+        SimpleTokenizer2 tokenizer(settings1, *this, code, options.cpp ? "test.cpp" : "test.c");
+
+        // Tokenizer..
+        ASSERT_LOC(tokenizer.simplifyTokens1(""), file, line);
 
         // Check..
-        CheckType checkType(&tokenizer, settings, this);
-        checkType.runChecks(&tokenizer, settings, this);
+        runChecks<CheckType>(tokenizer, this);
     }
 
     void checkTooBigShift_Unix32() {
-        Settings settings;
-        settings.platform(Settings::Unix32);
+        const Settings settings = settingsBuilder().platform(Platform::Type::Unix32).build();
 
         // unsigned types getting promoted to int sizeof(int) = 4 bytes
         // and unsigned types having already a size of 4 bytes
         {
-            const std::string types[] = {"unsigned char", /*[unsigned]*/"char", "bool", "unsigned short", "unsigned int", "unsigned long"};
+            const std::string types[] = {"unsigned char", "bool", "unsigned short", "unsigned int", "unsigned long"};
             for (const std::string& type : types) {
-                check((type + " f(" + type +" x) { return x << 31; }").c_str(), &settings);
-                ASSERT_EQUALS("", errout.str());
-                check((type + " f(" + type +" x) { return x << 33; }").c_str(), &settings);
-                ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 32-bit value by 33 bits is undefined behaviour\n", errout.str());
-                check((type + " f(int x) { return (x = (" + type + ")x << 32); }").c_str(), &settings);
-                ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 32-bit value by 32 bits is undefined behaviour\n", errout.str());
-                check((type + " foo(" + type + " x) { return x << 31; }").c_str(), &settings);
-                ASSERT_EQUALS("", errout.str());
+                check(type + " f(" + type +" x) { return x << 31; }", dinit(CheckOptions, $.settings = &settings));
+                ASSERT_EQUALS_MSG("", errout_str(), type);
+                check(type + " f(" + type +" x) { return x << 33; }", dinit(CheckOptions, $.settings = &settings));
+                ASSERT_EQUALS_MSG("[test.cpp:1]: (error) Shifting 32-bit value by 33 bits is undefined behaviour\n", errout_str(), type);
+                check(type + " f(int x) { return (x = (" + type + ")x << 32); }", dinit(CheckOptions, $.settings = &settings));
+                ASSERT_EQUALS_MSG("[test.cpp:1]: (error) Shifting 32-bit value by 32 bits is undefined behaviour\n", errout_str(), type);
+                check(type + " foo(" + type + " x) { return x << 31; }", dinit(CheckOptions, $.settings = &settings));
+                ASSERT_EQUALS_MSG("", errout_str(), type);
             }
         }
         // signed types getting promoted to int sizeof(int) = 4 bytes
         // and signed types having already a size of 4 bytes
         {
-            const std::string types[] = {"signed char", "signed short", /*[signed]*/"short", "wchar_t", /*[signed]*/"int", "signed int", /*[signed]*/"long", "signed long"};
+            const std::string types[] = {"signed char", "signed short", /*[signed]*/ "short", "wchar_t", /*[signed]*/ "int", "signed int", /*[signed]*/ "long", "signed long"};
             for (const std::string& type : types) {
                 // c++11
-                check((type + " f(" + type +" x) { return x << 33; }").c_str(), &settings);
-                ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 32-bit value by 33 bits is undefined behaviour\n", errout.str());
-                check((type + " f(int x) { return (x = (" + type + ")x << 32); }").c_str(), &settings);
-                ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 32-bit value by 32 bits is undefined behaviour\n", errout.str());
-                check((type + " foo(" + type + " x) { return x << 31; }").c_str(), &settings);
-                ASSERT_EQUALS("[test.cpp:1]: (error) Shifting signed 32-bit value by 31 bits is undefined behaviour\n", errout.str());
-                check((type + " foo(" + type + " x) { return x << 30; }").c_str(), &settings);
-                ASSERT_EQUALS("", errout.str());
+                check(type + " f(" + type +" x) { return x << 33; }", dinit(CheckOptions, $.settings = &settings));
+                ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 32-bit value by 33 bits is undefined behaviour\n", errout_str());
+                check(type + " f(int x) { return (x = (" + type + ")x << 32); }", dinit(CheckOptions, $.settings = &settings));
+                ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 32-bit value by 32 bits is undefined behaviour\n", errout_str());
+                check(type + " foo(" + type + " x) { return x << 31; }", dinit(CheckOptions, $.settings = &settings));
+                ASSERT_EQUALS("[test.cpp:1]: (error) Shifting signed 32-bit value by 31 bits is undefined behaviour\n", errout_str());
+                check(type + " foo(" + type + " x) { return x << 30; }", dinit(CheckOptions, $.settings = &settings));
+                ASSERT_EQUALS("", errout_str());
 
                 // c++14
-                check((type + " foo(" + type + " x) { return x << 31; }").c_str(), &settings, "test.cpp", "c++14");
-                ASSERT_EQUALS("[test.cpp:1]: (portability) Shifting signed 32-bit value by 31 bits is implementation-defined behaviour\n", errout.str());
-                check((type + " f(int x) { return (x = (" + type + ")x << 32); }").c_str(), &settings, "test.cpp", "c++14");
-                ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 32-bit value by 32 bits is undefined behaviour\n", errout.str());
+                check(type + " foo(" + type + " x) { return x << 31; }", dinit(CheckOptions, $.settings = &settings, $.standard = Standards::CPP14));
+                ASSERT_EQUALS("[test.cpp:1]: (portability) Shifting signed 32-bit value by 31 bits is implementation-defined behaviour\n", errout_str());
+                check(type + " f(int x) { return (x = (" + type + ")x << 32); }", dinit(CheckOptions, $.settings = &settings, $.standard = Standards::CPP14));
+                ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 32-bit value by 32 bits is undefined behaviour\n", errout_str());
             }
         }
         // 64 bit width types
         {
             // unsigned long long
-            check("unsigned long long foo(unsigned long long x) { return x << 64; }",&settings);
-            ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout.str());
-            check("unsigned long long f(int x) { return (x = (unsigned long long)x << 64); }",&settings);
-            ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout.str());
-            check("unsigned long long f(unsigned long long x) { return x << 63; }",&settings);
-            ASSERT_EQUALS("", errout.str());
+            check("unsigned long long foo(unsigned long long x) { return x << 64; }",dinit(CheckOptions, $.settings = &settings));
+            ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout_str());
+            check("unsigned long long f(int x) { return (x = (unsigned long long)x << 64); }",dinit(CheckOptions, $.settings = &settings));
+            ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout_str());
+            check("unsigned long long f(unsigned long long x) { return x << 63; }",dinit(CheckOptions, $.settings = &settings));
+            ASSERT_EQUALS("", errout_str());
             // [signed] long long
-            check("long long foo(long long x) { return x << 64; }",&settings);
-            ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout.str());
-            check("long long f(int x) { return (x = (long long)x << 64); }",&settings);
-            ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout.str());
-            check("long long f(long long x) { return x << 63; }",&settings);
-            ASSERT_EQUALS("[test.cpp:1]: (error) Shifting signed 64-bit value by 63 bits is undefined behaviour\n", errout.str());
-            check("long long f(long long x) { return x << 62; }",&settings);
-            ASSERT_EQUALS("", errout.str());
+            check("long long foo(long long x) { return x << 64; }",dinit(CheckOptions, $.settings = &settings));
+            ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout_str());
+            check("long long f(int x) { return (x = (long long)x << 64); }",dinit(CheckOptions, $.settings = &settings));
+            ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout_str());
+            check("long long f(long long x) { return x << 63; }",dinit(CheckOptions, $.settings = &settings));
+            ASSERT_EQUALS("[test.cpp:1]: (error) Shifting signed 64-bit value by 63 bits is undefined behaviour\n", errout_str());
+            check("long long f(long long x) { return x << 62; }",dinit(CheckOptions, $.settings = &settings));
+            ASSERT_EQUALS("", errout_str());
             // signed long long
-            check("signed long long foo(signed long long x) { return x << 64; }",&settings);
-            ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout.str());
-            check("signed long long f(long long x) { return (x = (signed long long)x << 64); }",&settings);
-            ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout.str());
-            check("signed long long f(signed long long x) { return x << 63; }",&settings);
-            ASSERT_EQUALS("[test.cpp:1]: (error) Shifting signed 64-bit value by 63 bits is undefined behaviour\n", errout.str());
-            check("signed long long f(signed long long x) { return x << 62; }",&settings);
-            ASSERT_EQUALS("", errout.str());
+            check("signed long long foo(signed long long x) { return x << 64; }",dinit(CheckOptions, $.settings = &settings));
+            ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout_str());
+            check("signed long long f(long long x) { return (x = (signed long long)x << 64); }",dinit(CheckOptions, $.settings = &settings));
+            ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout_str());
+            check("signed long long f(signed long long x) { return x << 63; }",dinit(CheckOptions, $.settings = &settings));
+            ASSERT_EQUALS("[test.cpp:1]: (error) Shifting signed 64-bit value by 63 bits is undefined behaviour\n", errout_str());
+            check("signed long long f(signed long long x) { return x << 62; }",dinit(CheckOptions, $.settings = &settings));
+            ASSERT_EQUALS("", errout_str());
 
             // c++14
-            check("signed long long foo(signed long long x) { return x << 64; }",&settings, "test.cpp", "c++14");
-            ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout.str());
-            check("signed long long f(long long x) { return (x = (signed long long)x << 64); }",&settings, "test.cpp", "c++14");
-            ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout.str());
-            check("signed long long f(signed long long x) { return x << 63; }",&settings, "test.cpp", "c++14");
-            ASSERT_EQUALS("[test.cpp:1]: (portability) Shifting signed 64-bit value by 63 bits is implementation-defined behaviour\n", errout.str());
-            check("signed long long f(signed long long x) { return x << 62; }",&settings);
-            ASSERT_EQUALS("", errout.str());
+            check("signed long long foo(signed long long x) { return x << 64; }", dinit(CheckOptions, $.settings = &settings, $.standard = Standards::CPP14));
+            ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout_str());
+            check("signed long long f(long long x) { return (x = (signed long long)x << 64); }", dinit(CheckOptions, $.settings = &settings, $.standard = Standards::CPP14));
+            ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 64-bit value by 64 bits is undefined behaviour\n", errout_str());
+            check("signed long long f(signed long long x) { return x << 63; }", dinit(CheckOptions, $.settings = &settings, $.standard = Standards::CPP14));
+            ASSERT_EQUALS("[test.cpp:1]: (portability) Shifting signed 64-bit value by 63 bits is implementation-defined behaviour\n", errout_str());
+            check("signed long long f(signed long long x) { return x << 62; }",dinit(CheckOptions, $.settings = &settings));
+            ASSERT_EQUALS("", errout_str());
         }
 
+        check("void f() { int x; x = 1 >> 64; }", dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("[test.cpp:1]: (error) Shifting 32-bit value by 64 bits is undefined behaviour\n", errout_str());
+
         check("void foo() {\n"
               "  QList<int> someList;\n"
               "  someList << 300;\n"
-              "}", &settings);
-        ASSERT_EQUALS("", errout.str());
+              "}", dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #6793
         check("template<unsigned int I> int foo(unsigned int x) { return x << I; }\n"
               "const unsigned int f = foo<31>(0);\n"
               "const unsigned int g = foo<100>(0);\n"
               "template<unsigned int I> int hoo(unsigned int x) { return x << 32; }\n"
-              "const unsigned int h = hoo<100>(0);", &settings);
+              "const unsigned int h = hoo<100>(0);", dinit(CheckOptions, $.settings = &settings));
         ASSERT_EQUALS("[test.cpp:4]: (error) Shifting 32-bit value by 32 bits is undefined behaviour\n"
-                      "[test.cpp:1]: (error) Shifting 32-bit value by 100 bits is undefined behaviour\n", errout.str());
+                      "[test.cpp:1]: (error) Shifting 32-bit value by 100 bits is undefined behaviour\n", errout_str());
 
         // #7266: C++, shift in macro
         check("void f(unsigned int x) {\n"
               "    UINFO(x << 1234);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // #8640
+        check("int f (void)\n"
+              "{\n"
+              "    constexpr const int a = 1;\n"
+              "    constexpr const int shift[1] = {32};\n"
+              "    constexpr const int ret = a << shift[0];\n" // shift too many bits
+              "    return ret;\n"
+              "}");
+        ASSERT_EQUALS("[test.cpp:5]: (error) Shifting 32-bit value by 32 bits is undefined behaviour\n"
+                      "[test.cpp:5]: (error) Signed integer overflow for expression 'a<<shift[0]'.\n", errout_str());
 
         // #8885
         check("int f(int k, int rm) {\n"
@@ -171,10 +218,10 @@ class TestType : public TestFixture {
               "  if (k > 32)\n"
               "    return 0;\n"
               "  return rm>> k;\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
             "[test.cpp:4] -> [test.cpp:6]: (warning) Shifting signed 32-bit value by 31 bits is undefined behaviour. See condition at line 4.\n",
-            errout.str());
+            errout_str());
 
         check("int f(int k, int rm) {\n"
               "  if (k == 0 || k == 32)\n"
@@ -183,10 +230,10 @@ class TestType : public TestFixture {
               "    return 0;\n"
               "  else\n"
               "    return rm>> k;\n"
-              "}\n");
+              "}");
         ASSERT_EQUALS(
             "[test.cpp:4] -> [test.cpp:7]: (warning) Shifting signed 32-bit value by 31 bits is undefined behaviour. See condition at line 4.\n",
-            errout.str());
+            errout_str());
 
         check("int f(int k, int rm) {\n"
               "  if (k == 0 || k == 32 || k == 31)\n"
@@ -195,150 +242,254 @@ class TestType : public TestFixture {
               "    return 0;\n"
               "  else\n"
               "    return rm>> k;\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("static long long f(int x, long long y) {\n"
               "    if (x >= 64)\n"
               "        return 0;\n"
               "    return -(y << (x-1));\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("bool f() {\n"
+              "    std::ofstream outfile;\n"
+              "    outfile << vec_points[0](0) << static_cast<int>(d) << ' ';\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(unsigned b, int len, unsigned char rem) {\n" // #10773
+              "    int bits = 0;\n"
+              "    while (len > 8) {\n"
+              "        b = b >> rem;\n"
+              "        bits += 8 - rem;\n"
+              "        if (bits == 512)\n"
+              "            len -= 8;\n"
+              "    }\n"
               "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void checkIntegerOverflow() {
-        Settings settings;
-        settings.platform(Settings::Unix32);
-        settings.addEnabled("warning");
+        const Settings settings = settingsBuilder().severity(Severity::warning).platform(Platform::Type::Unix32).build();
 
-        check("x = (int)0x10000 * (int)0x10000;", &settings);
-        ASSERT_EQUALS("[test.cpp:1]: (error) Signed integer overflow for expression '(int)65536*(int)65536'.\n", errout.str());
+        check("x = (int)0x10000 * (int)0x10000;", dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("[test.cpp:1:18]: (error) Signed integer overflow for expression '(int)0x10000*(int)0x10000'. [integerOverflow]\n", errout_str());
 
-        check("x = (long)0x10000 * (long)0x10000;", &settings);
-        ASSERT_EQUALS("[test.cpp:1]: (error) Signed integer overflow for expression '(long)65536*(long)65536'.\n", errout.str());
+        check("x = (long)0x10000 * (long)0x10000;", dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("[test.cpp:1:19]: (error) Signed integer overflow for expression '(long)0x10000*(long)0x10000'. [integerOverflow]\n", errout_str());
 
         check("void foo() {\n"
               "    int intmax = 0x7fffffff;\n"
               "    return intmax + 1;\n"
-              "}",&settings);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Signed integer overflow for expression 'intmax+1'.\n", errout.str());
+              "}",dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("[test.cpp:3:19]: (error) Signed integer overflow for expression 'intmax+1'. [integerOverflow]\n", errout_str());
 
         check("void foo() {\n"
               "    int intmax = 0x7fffffff;\n"
               "    return intmax - 1;\n"
-              "}",&settings);
-        ASSERT_EQUALS("", errout.str());
+              "}",dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("", errout_str());
 
         check("int foo(signed int x) {\n"
               "   if (x==123456) {}\n"
               "   return x * x;\n"
-              "}",&settings);
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Either the condition 'x==123456' is redundant or there is signed integer overflow for expression 'x*x'.\n", errout.str());
+              "}",dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:13]: (warning) Either the condition 'x==123456' is redundant or there is signed integer overflow for expression 'x*x'. [integerOverflowCond]\n", errout_str());
 
         check("int foo(signed int x) {\n"
               "   if (x==123456) {}\n"
               "   return -123456 * x;\n"
-              "}",&settings);
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Either the condition 'x==123456' is redundant or there is signed integer overflow for expression '-123456*x'.\n", errout.str());
+              "}",dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("[test.cpp:2:9] -> [test.cpp:3:19]: (warning) Either the condition 'x==123456' is redundant or there is signed integer underflow for expression '-123456*x'. [integerOverflowCond]\n", errout_str());
 
         check("int foo(signed int x) {\n"
               "   if (x==123456) {}\n"
               "   return 123456U * x;\n"
-              "}",&settings);
-        ASSERT_EQUALS("", errout.str());
+              "}",dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("", errout_str());
+
+        check("int f(int i) {\n" // #12117
+              "    return (i == 31) ? 1 << i : 0;\n"
+              "}", dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("[test.cpp:2:15] -> [test.cpp:2:26]: (warning) Shifting signed 32-bit value by 31 bits is undefined behaviour. See condition at line 2. [shiftTooManyBitsSigned]\n", errout_str());
+
+        check("void f() {\n" // #13092
+              "    int n = 0;\n"
+              "    for (int i = 0; i < 10; i++) {\n"
+              "        n = n * 47163 - 57412;\n"
+              "    }\n"
+              "}", dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("[test.cpp:4:15]: (error) Signed integer underflow for expression 'n*47163'. [integerOverflow]\n"
+                      "[test.cpp:4:23]: (error) Signed integer underflow for expression 'n*47163-57412'. [integerOverflow]\n",
+                      errout_str());
     }
 
     void signConversion() {
+        const Settings settings = settingsBuilder().platform(Platform::Type::Unix64).build();
         check("x = -4 * (unsigned)y;");
-        ASSERT_EQUALS("[test.cpp:1]: (warning) Expression '-4' has a negative value. That is converted to an unsigned value and used in an unsigned calculation.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:6]: (warning) Expression '-4' has a negative value. That is converted to an unsigned value and used in an unsigned calculation. [signConversion]\n", errout_str());
+
+        check("x = (unsigned)y * -4;");
+        ASSERT_EQUALS("[test.cpp:1:20]: (warning) Expression '-4' has a negative value. That is converted to an unsigned value and used in an unsigned calculation. [signConversion]\n", errout_str());
 
         check("unsigned int dostuff(int x) {\n" // x is signed
               "  if (x==0) {}\n"
               "  return (x-1)*sizeof(int);\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2] -> [test.cpp:3]: (warning) Expression 'x-1' can have a negative value. That is converted to an unsigned value and used in an unsigned calculation.\n", errout.str());
+              "}", dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("[test.cpp:2:8] -> [test.cpp:3:12]: (warning) Expression 'x-1' can have a negative value. That is converted to an unsigned value and used in an unsigned calculation. [signConversionCond]\n", errout_str());
 
         check("unsigned int f1(signed int x, unsigned int y) {" // x is signed
               "  return x * y;\n"
               "}\n"
               "void f2() { f1(-4,4); }");
         ASSERT_EQUALS(
-            "[test.cpp:1]: (warning) Expression 'x' can have a negative value. That is converted to an unsigned value and used in an unsigned calculation.\n",
-            errout.str());
+            "[test.cpp:1:57]: (warning) Expression 'x' can have a negative value. That is converted to an unsigned value and used in an unsigned calculation. [signConversion]\n",
+            errout_str());
 
         check("unsigned int f1(int x) {"
               "  return x * 5U;\n"
               "}\n"
               "void f2() { f1(-4); }");
         ASSERT_EQUALS(
-            "[test.cpp:1]: (warning) Expression 'x' can have a negative value. That is converted to an unsigned value and used in an unsigned calculation.\n",
-            errout.str());
+            "[test.cpp:1:34]: (warning) Expression 'x' can have a negative value. That is converted to an unsigned value and used in an unsigned calculation. [signConversion]\n",
+            errout_str());
 
         check("unsigned int f1(int x) {" // #6168: FP for inner calculation
               "  return 5U * (1234 - x);\n" // <- signed subtraction, x is not sign converted
               "}\n"
               "void f2() { f1(-4); }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Don't warn for + and -
         check("void f1(int x) {"
               "  a = x + 5U;\n"
               "}\n"
               "void f2() { f1(-4); }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("size_t foo(size_t x) {\n"
               " return -2 * x;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (warning) Expression '-2' has a negative value. That is converted to an unsigned value and used in an unsigned calculation.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (warning) Expression '-2' has a negative value. That is converted to an unsigned value and used in an unsigned calculation. [signConversion]\n", errout_str());
+
+        checkP("void f() {\n" // #12110 FP signConversion with integer overflow
+               "    if (LLONG_MIN / (-1)) {}\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void longCastAssign() {
-        Settings settings;
-        settings.addEnabled("style");
-        settings.platform(Settings::Unix64);
+        const Settings settings = settingsBuilder().severity(Severity::style).platform(Platform::Type::Unix64).build();
+        const Settings settingsWin = settingsBuilder().severity(Severity::style).platform(Platform::Type::Win64).build();
+
+        const char code[] = "long f(int x, int y) {\n"
+                            "  const long ret = x * y;\n"
+                            "  return ret;\n"
+                            "}\n";
+        check(code, dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("[test.cpp:2:18]: (style) int result is assigned to long variable. If the variable is long to avoid loss of information, then you have loss of information. [truncLongCastAssignment]\n", errout_str());
+        check(code, dinit(CheckOptions, $.settings = &settingsWin));
+        ASSERT_EQUALS("", errout_str());
 
         check("long f(int x, int y) {\n"
-              "  const long ret = x * y;\n"
+              "  long ret = x * y;\n"
               "  return ret;\n"
-              "}\n", &settings);
-        ASSERT_EQUALS("[test.cpp:2]: (style) int result is assigned to long variable. If the variable is long to avoid loss of information, then you have loss of information.\n", errout.str());
+              "}\n", dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("[test.cpp:2:12]: (style) int result is assigned to long variable. If the variable is long to avoid loss of information, then you have loss of information. [truncLongCastAssignment]\n", errout_str());
 
         check("long f() {\n"
               "  const long long ret = 256 * (1 << 10);\n"
               "  return ret;\n"
-              "}\n", &settings);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("", errout_str());
 
         // typedef
         check("long f(int x, int y) {\n"
               "  const size_t ret = x * y;\n"
               "  return ret;\n"
-              "}\n", &settings);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("", errout_str());
 
         // astIsIntResult
         check("long f(int x, int y) {\n"
               "  const long ret = (long)x * y;\n"
               "  return ret;\n"
-              "}\n", &settings);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("", errout_str());
+
+        check("double g(float f) {\n"
+              "    return f * f;\n"
+              "}\n", dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("[test.cpp:2:5]: (style) float result is returned as double value. If the return value is double to avoid loss of information, then you have loss of information. [truncLongCastReturn]\n",
+                      errout_str());
+
+        check("void f(int* p) {\n" // #11862
+              "    long long j = *(p++);\n"
+              "}\n", dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("", errout_str());
+
+        check("template <class T>\n" // #12393
+              "struct S {\n"
+              "    S& operator=(const S&) { return *this; }\n"
+              "    struct U {\n"
+              "        S<T>* p;\n"
+              "    };\n"
+              "    U u;\n"
+              "};\n", dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("", errout_str()); // don't crash
+
+        check("void f(long& r, long i) {\n"
+              "    r = 1 << i;\n"
+              "}\n", dinit(CheckOptions, $.settings = &settingsWin));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void longCastReturn() {
-        Settings settings;
-        settings.addEnabled("style");
-
-        check("long f(int x, int y) {\n"
-              "  return x * y;\n"
-              "}\n", &settings);
-        ASSERT_EQUALS("[test.cpp:2]: (style) int result is returned as long value. If the return value is long to avoid loss of information, then you have loss of information.\n", errout.str());
+        const Settings settings = settingsBuilder().severity(Severity::style).platform(Platform::Type::Unix64).build();
+        const Settings settingsWin = settingsBuilder().severity(Severity::style).platform(Platform::Type::Win64).build();
+
+        const char code[] = "long f(int x, int y) {\n"
+                            "  return x * y;\n"
+                            "}\n";
+        check(code, dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("[test.cpp:2:3]: (style) int result is returned as long value. If the return value is long to avoid loss of information, then you have loss of information. [truncLongCastReturn]\n", errout_str());
+        check(code, dinit(CheckOptions, $.settings = &settingsWin));
+        ASSERT_EQUALS("", errout_str());
+
+        const char code2[] = "long long f(int x, int y) {\n"
+                             "  return x * y;\n"
+                             "}\n";
+        check(code2, dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("[test.cpp:2:3]: (style) int result is returned as long long value. If the return value is long long to avoid loss of information, then you have loss of information. [truncLongCastReturn]\n", errout_str());
+        check(code2, dinit(CheckOptions, $.settings = &settingsWin));
+        ASSERT_EQUALS("[test.cpp:2:3]: (style) int result is returned as long long value. If the return value is long long to avoid loss of information, then you have loss of information. [truncLongCastReturn]\n", errout_str());
+
+        const char code3[] = "long f() {\n"
+                             "    int n = 1;\n"
+                             "    return n << 12;\n"
+                             "}\n";
+        check(code3, dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("", errout_str());
+
+        const char code4[] = "long f(int n) {\n"
+                             "    return n << 12;\n"
+                             "}\n";
+        check(code4, dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("[test.cpp:2:5]: (style) int result is returned as long value. If the return value is long to avoid loss of information, then you have loss of information. [truncLongCastReturn]\n", errout_str());
+
+        const char code5[] = "long f() {\n"
+                             "    unsigned int n = 1U << 20;\n"
+                             "    return n << 20;\n"
+                             "}\n";
+        check(code5, dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("[test.cpp:3:5]: (style) int result is returned as long value. If the return value is long to avoid loss of information, then you have loss of information. [truncLongCastReturn]\n", errout_str());
 
         // typedef
         check("size_t f(int x, int y) {\n"
               "  return x * y;\n"
-              "}\n", &settings);
-        ASSERT_EQUALS("", errout.str());
+              "}\n", dinit(CheckOptions, $.settings = &settings));
+        ASSERT_EQUALS("[test.cpp:2:3]: (style) int result is returned as long value. If the return value is long to avoid loss of information, then you have loss of information. [truncLongCastReturn]\n", errout_str());
     }
 
     // This function ensure that test works with different compilers. Floats can
@@ -353,42 +504,131 @@ class TestType : public TestFixture {
 
     void checkFloatToIntegerOverflow() {
         check("x = (int)1E100;");
-        ASSERT_EQUALS("[test.cpp:1]: (error) Undefined behaviour: float () to integer conversion overflow.\n", removeFloat(errout.str()));
+        ASSERT_EQUALS("[test.cpp:1:5]: (error) Undefined behaviour: float () to integer conversion overflow. [floatConversionOverflow]\n", removeFloat(errout_str()));
 
         check("void f(void) {\n"
               "  return (int)1E100;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Undefined behaviour: float () to integer conversion overflow.\n", removeFloat(errout.str()));
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:10]: (error) Undefined behaviour: float () to integer conversion overflow. [floatConversionOverflow]\n", removeFloat(errout_str()));
 
         check("void f(void) {\n"
               "  return (int)-1E100;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Undefined behaviour: float () to integer conversion overflow.\n", removeFloat(errout.str()));
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:10]: (error) Undefined behaviour: float () to integer conversion overflow. [floatConversionOverflow]\n", removeFloat(errout_str()));
 
         check("void f(void) {\n"
               "  return (short)1E6;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Undefined behaviour: float () to integer conversion overflow.\n", removeFloat(errout.str()));
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:10]: (error) Undefined behaviour: float () to integer conversion overflow. [floatConversionOverflow]\n", removeFloat(errout_str()));
 
         check("void f(void) {\n"
               "  return (unsigned char)256.0;\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Undefined behaviour: float () to integer conversion overflow.\n", removeFloat(errout.str()));
+              "}");
+        ASSERT_EQUALS("[test.cpp:2:10]: (error) Undefined behaviour: float () to integer conversion overflow. [floatConversionOverflow]\n", removeFloat(errout_str()));
 
         check("void f(void) {\n"
               "  return (unsigned char)255.5;\n"
-              "}\n");
-        ASSERT_EQUALS("", removeFloat(errout.str()));
+              "}");
+        ASSERT_EQUALS("", removeFloat(errout_str()));
 
         check("void f(void) {\n"
               "  char c = 1234.5;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Undefined behaviour: float () to integer conversion overflow.\n", removeFloat(errout.str()));
+        ASSERT_EQUALS("[test.cpp:2:10]: (error) Undefined behaviour: float () to integer conversion overflow. [floatConversionOverflow]\n", removeFloat(errout_str()));
 
         check("char f(void) {\n"
               "  return 1234.5;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Undefined behaviour: float () to integer conversion overflow.\n", removeFloat(errout.str()));
+        ASSERT_EQUALS("[test.cpp:2:3]: (error) Undefined behaviour: float () to integer conversion overflow. [floatConversionOverflow]\n", removeFloat(errout_str()));
+
+        checkP("#define TEST(b, f) b ? 5000 : (unsigned short)f\n" // #11685
+               "void f()\n"
+               "{\n"
+               "    unsigned short u = TEST(true, 75000.0);\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkP("#define TEST(b, f) b ? 5000 : (unsigned short)f\n"
+               "void f()\n"
+               "{\n"
+               "    unsigned short u = TEST(false, 75000.0);\n"
+               "}\n");
+        ASSERT_EQUALS("[test.cpp:4:24]: (error) Undefined behaviour: float () to integer conversion overflow. [floatConversionOverflow]\n", removeFloat(errout_str()));
+
+        check( "bool f(unsigned short x);\n"
+               "bool g() {\n"
+               "    return false && f((unsigned short)75000.0);\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check( "bool f(unsigned short x);\n"
+               "bool g() {\n"
+               "    return true && f((unsigned short)75000.0);\n"
+               "}\n");
+        ASSERT_EQUALS("[test.cpp:3:22]: (error) Undefined behaviour: float () to integer conversion overflow. [floatConversionOverflow]\n", removeFloat(errout_str()));
+
+        check( "bool f(unsigned short x);\n"
+               "bool g() {\n"
+               "    return true || f((unsigned short)75000.0);\n"
+               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check( "bool f(unsigned short x);\n"
+               "bool g() {\n"
+               "    return false || f((unsigned short)75000.0);\n"
+               "}\n");
+        ASSERT_EQUALS("[test.cpp:3:23]: (error) Undefined behaviour: float () to integer conversion overflow. [floatConversionOverflow]\n", removeFloat(errout_str()));
+
+        checkP("#define TEST(b, f) b ? 5000 : (unsigned short)f\n" // #11685
+               "void f()\n"
+               "{\n"
+               "    unsigned short u = TEST(true, 75000.0);\n"
+               "}\n", dinit(CheckPOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+
+        checkP("#define TEST(b, f) b ? 5000 : (unsigned short)f\n"
+               "void f()\n"
+               "{\n"
+               "    unsigned short u = TEST(false, 75000.0);\n"
+               "}\n", dinit(CheckPOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:4:24]: (error) Undefined behaviour: float () to integer conversion overflow. [floatConversionOverflow]\n", removeFloat(errout_str()));
+
+    }
+
+    void integerOverflow() { // #11794
+        // std.cfg for int32_t
+        // Platform::Unix32 for INT_MIN=-2147483648 and INT32_MAX=2147483647
+        const Settings s = settingsBuilder().library("std.cfg").cpp(Standards::CPP11).platform(Platform::Unix32).build();
+
+        checkP("int fun(int x)\n"
+               "{\n"
+               "  if(x < 0) x = -x;\n"
+               "  return x >= 0;\n"
+               "}\n"
+               "int f()\n"
+               "{\n"
+               "    fun(INT_MIN);\n"
+               "}", dinit(CheckPOptions, $.settings = &s));
+        ASSERT_EQUALS("[test.cpp:3:17]: (error) Signed integer overflow for expression '-x'. [integerOverflow]\n", errout_str());
+
+        checkP("void f() {\n" // #8399
+               "    int32_t i = INT32_MAX;\n"
+               "    i << 1;\n"
+               "    i << 2;\n"
+               "}", dinit(CheckPOptions, $.settings = &s));
+        ASSERT_EQUALS("[test.cpp:4:7]: (error) Signed integer overflow for expression 'i<<2'. [integerOverflow]\n", errout_str());
+    }
+
+    void shiftTooManyBits() { // #11496
+        check("template<unsigned int width> struct B {\n"
+              "    unsigned long long f(unsigned int n) const {\n"
+              "        if (width == 1)\n"
+              "            return 1ULL << width;\n"
+              "        return 0;\n"
+              "    }\n"
+              "};\n"
+              "static B<64> b;\n");
+        ASSERT_EQUALS("", errout_str());
     }
 };
 
diff --git a/test/testuninitvar.cpp b/test/testuninitvar.cpp
index 6904e89d3e9..ecb467524c3 100644
--- a/test/testuninitvar.cpp
+++ b/test/testuninitvar.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,29 +16,26 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "check.h"
 #include "checkuninitvar.h"
-#include "library.h"
+#include "ctu.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
 
-#include <sstream>
+#include <cstddef>
+#include <list>
 #include <string>
 
-struct InternalError;
-
-
 class TestUninitVar : public TestFixture {
 public:
-    TestUninitVar() : TestFixture("TestUninitVar") {
-    }
+    TestUninitVar() : TestFixture("TestUninitVar") {}
 
 private:
-    Settings settings;
-
-    void run() OVERRIDE {
-        LOAD_LIB_2(settings.library, "std.cfg");
+    const Settings settings = settingsBuilder().library("std.cfg").build();
 
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(uninitvar1);
         TEST_CASE(uninitvar_warn_once); // only write 1 warning at a time
         TEST_CASE(uninitvar_decl);      // handling various types in C and C++ files
@@ -57,18 +54,29 @@ class TestUninitVar : public TestFixture {
         TEST_CASE(func_uninit_var);     // analyse function calls for: 'int a(int x) { return x+x; }'
         TEST_CASE(func_uninit_pointer); // analyse function calls for: 'void a(int *p) { *p = 0; }'
         TEST_CASE(uninitvar_typeof);    // typeof
+        TEST_CASE(uninitvar_ignore);    // ignore cast, *&x, ..
         TEST_CASE(uninitvar2);
         TEST_CASE(uninitvar3);          // #3844
         TEST_CASE(uninitvar4);          // #3869 (reference)
         TEST_CASE(uninitvar5);          // #3861
+        TEST_CASE(uninitvar6);          // #13227
         TEST_CASE(uninitvar2_func);     // function calls
         TEST_CASE(uninitvar2_value);    // value flow
-        TEST_CASE(uninitvar2_structmembers); // struct members
+        TEST_CASE(valueFlowUninit2_value);
+        TEST_CASE(valueFlowUninit_uninitvar2);
+        TEST_CASE(valueFlowUninit_functioncall);
+        TEST_CASE(uninitStructMember);  // struct members
         TEST_CASE(uninitvar2_while);
         TEST_CASE(uninitvar2_4494);      // #4494
         TEST_CASE(uninitvar2_malloc);    // malloc returns uninitialized data
         TEST_CASE(uninitvar8); // ticket #6230
         TEST_CASE(uninitvar9); // ticket #6424
+        TEST_CASE(uninitvar10); // ticket #9467
+        TEST_CASE(uninitvar11); // ticket #9123
+        TEST_CASE(uninitvar12); // #10218 - stream read
+        TEST_CASE(uninitvar13); // #9772
+        TEST_CASE(uninitvar14);
+        TEST_CASE(uninitvar15); // #13685
         TEST_CASE(uninitvar_unconditionalTry);
         TEST_CASE(uninitvar_funcptr); // #6404
         TEST_CASE(uninitvar_operator); // #6680
@@ -77,219 +85,250 @@ class TestUninitVar : public TestFixture {
         TEST_CASE(uninitvar_cpp11ArrayInit); // #7010
         TEST_CASE(uninitvar_rangeBasedFor); // #7078
         TEST_CASE(uninitvar_static); // #8734
+        TEST_CASE(uninitvar_configuration);
+        TEST_CASE(checkExpr);
         TEST_CASE(trac_4871);
         TEST_CASE(syntax_error); // Ticket #5073
         TEST_CASE(trac_5970);
-        TEST_CASE(valueFlowUninit);
+        TEST_CASE(valueFlowUninitTest);
+        TEST_CASE(valueFlowUninitBreak);
+        TEST_CASE(valueFlowUninitStructMembers);
+        TEST_CASE(valueFlowUninitForLoop);
         TEST_CASE(uninitvar_ipa);
         TEST_CASE(uninitvar_memberfunction);
         TEST_CASE(uninitvar_nonmember); // crash in ycmd test
+        TEST_CASE(uninitvarDesignatedInitializers);
+        TEST_CASE(uninitvarMemberPointer);
 
         TEST_CASE(isVariableUsageDeref); // *p
+        TEST_CASE(isVariableUsageDerefValueflow); // *p
+
+        TEST_CASE(uninitvar_memberaccess); // (&(a))->b <=> a.b
 
         // whole program analysis
-        TEST_CASE(ctu);
+        TEST_CASE(ctuTest);
     }
 
-    void checkUninitVar(const char code[], const char fname[] = "test.cpp", bool debugwarnings = false) {
-        // Clear the error buffer..
-        errout.str("");
+    struct CheckUninitVarOptions
+    {
+        bool cpp = true;
+    };
 
-        // Tokenize..
-        settings.debugwarnings = debugwarnings;
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, fname);
+#define checkUninitVar(...) checkUninitVar_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkUninitVar_(const char* file, int line, const char (&code)[size], const CheckUninitVarOptions& options = make_default_obj()) {
+        checkUninitVar_(file, line, code, settings, options.cpp);
+    }
+
+    template<size_t size>
+    void checkUninitVar_(const char* file, int line, const char (&code)[size], const Settings& settings1, bool cpp = true) {
+        SimpleTokenizer tokenizer(settings1, *this, cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check for redundant code..
-        CheckUninitVar checkuninitvar(&tokenizer, &settings, this);
+        CheckUninitVar checkuninitvar(&tokenizer, &settings1, this);
         checkuninitvar.check();
+    }
 
-        settings.debugwarnings = false;
-        settings.experimental = true;
+    // TODO: get rid of this
+    void checkUninitVar_(const char* file, int line, const std::string& code) {
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+
+        // Check for redundant code..
+        CheckUninitVar checkuninitvar(&tokenizer, &settings, this);
+        checkuninitvar.check();
     }
 
     void uninitvar1() {
+        // extracttests.start: int b; int c;
+
         // Ticket #2207 - False negative
         checkUninitVar("void foo() {\n"
                        "    int a;\n"
                        "    b = c - a;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void foo() {\n"
                        "    int a;\n"
                        "    b = a - c;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         // Ticket #6455 - some compilers allow const variables to be uninitialized
+        // extracttests.disable
         checkUninitVar("void foo() {\n"
                        "    const int a;\n"
                        "    b = c - a;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
+        // extracttests.enable
 
         checkUninitVar("void foo() {\n"
                        "    int *p;\n"
                        "    realloc(p,10);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void foo() {\n" // #5240
                        "    char *p = malloc(100);\n"
                        "    char *tmp = realloc(p,1000);\n"
                        "    if (!tmp) free(p);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo() {\n"
                        "    int *p = NULL;\n"
                        "    realloc(p,10);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // dereferencing uninitialized pointer..
+        // extracttests.start: struct Foo { void abcd(); };
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    Foo *p;\n"
                        "    p->abcd();\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
+        // extracttests.start: template<class T> struct Foo { void abcd(); };
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    Foo<int> *p;\n"
                        "    p->abcd();\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
+        // extracttests.start: struct Foo { void* a; };
         checkUninitVar("void f(Foo *p)\n"
                        "{\n"
                        "    int a;\n"
                        "    p->a = malloc(4 * a);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:23]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    int *p;\n"
                        "    delete p;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:12]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    int *p;\n"
                        "    delete [] p;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:15]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    int *p;\n"
                        "    *p = 135;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:6]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    int *p;\n"
                        "    p[0] = 135;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    int *x;\n"
                        "    int y = *x;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:14]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    int *x;\n"
                        "    int &y(*x);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "    int x;\n"
                        "    int *y = &x;\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "    int *x;\n"
                        "    int *&y = x;\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "    int x = xyz::x;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    int a;\n"
                        "    a = 5 + a;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    int a;\n"
                        "    a++;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    extern int a;\n"
                        "    a++;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
+        // extracttests.start: void bar(int);
         checkUninitVar("void f()\n"
                        "{\n"
                        "    int a;\n"
                        "    bar(4 * a);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    int i;\n"
                        "    if (i);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    int i;\n"
                        "    for (int x = 0; i < 10; x++);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:21]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    int i;\n"
                        "    for (int x = 0; x < 10; i++);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:29]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
 
-        checkUninitVar("static int foo(int x)\n"
+        checkUninitVar("static void foo(int x)\n"
                        "{\n"
                        "    int i;\n"
                        "    if (x)\n"
                        "        i = 0;\n"
                        "    i++;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Uninitialized variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:5]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
@@ -297,82 +336,84 @@ class TestUninitVar : public TestFixture {
                        "    int i;\n"
                        "    ar[i] = 0;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:8]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    int x, y;\n"
                        "    x = (y = 10);\n"
                        "    int z = y * 2;\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("static void foo() {\n"
                        "    int x, y;\n"
                        "    x = ((y) = 10);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #3597
-        checkUninitVar("int f() {\n"
+        checkUninitVar("void f() {\n"
                        "    int a;\n"
                        "    int b = 1;\n"
                        "    (b += a) = 1;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:11]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int f() {\n"
                        "    int a,b,c;\n"
                        "    a = b = c;\n"
-                       "}", "test.cpp", /*verify=*/ false);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: c\n", errout.str());
+                       "}");
+        ASSERT_EQUALS("[test.cpp:3:0]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    Foo p;\n"
                        "    p.abcd();\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("static void foo()\n"
                        "{\n"
                        "    Foo p;\n"
                        "    int x = p.abcd();\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Unknown types
+        // extracttests.disable
         {
             checkUninitVar("void a()\n"
                            "{\n"
                            "    A ret;\n"
                            "    return ret;\n"
                            "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
 
             checkUninitVar("void a()\n"
                            "{\n"
                            "    A ret;\n"
                            "    return ret;\n"
                            "}\n",
-                           "test.c");
-            ASSERT_EQUALS("[test.c:4]: (error) Uninitialized variable: ret\n", errout.str());
-
-            // #3916 - avoid false positive
-            checkUninitVar("void f(float x) {\n"
-                           "  union lf { long l; float f; } u_lf;\n"
-                           "  float hx = (u_lf.f = (x), u_lf.l);\n"
-                           "}",
-                           "test.c", false);
-            ASSERT_EQUALS("", errout.str());
+                           dinit(CheckUninitVarOptions, $.cpp = false));
+            ASSERT_EQUALS("[test.c:4:12]: (error) Uninitialized variable: ret [legacyUninitvar]\n", errout_str());
         }
+        // extracttests.enable
+
+        // #3916 - avoid false positive
+        checkUninitVar("void f(float x) {\n"
+                       "  union lf { long l; float f; } u_lf;\n"
+                       "  float hx = (u_lf.f = (x), u_lf.l);\n"
+                       "}",
+                       dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void a()\n"
                        "{\n"
                        "    int x[10];\n"
                        "    int *y = x;\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void a()\n"
                        "{\n"
@@ -380,8 +421,8 @@ class TestUninitVar : public TestFixture {
                        "    int *y = &x;\n"
                        "    *y = 0;\n"
                        "    x++;\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void a()\n"
                        "{\n"
@@ -389,8 +430,8 @@ class TestUninitVar : public TestFixture {
                        "    char *z = x;\n"
                        "    memset(z, 0, sizeof(x));\n"
                        "    memcpy(y, x, sizeof(x));\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         // Handling >> and <<
         {
@@ -399,81 +440,145 @@ class TestUninitVar : public TestFixture {
                            "    std::cin >> ret;\n"
                            "    ret++;\n"
                            "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
 
             checkUninitVar("void f(int b) {\n"
                            "    int a;\n"
                            "    std::cin >> b >> a;\n"
                            "    return a;"
                            "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
+
+            checkUninitVar("void f() {\n"
+                           "    int ret[2];\n"
+                           "    std::cin >> ret[0];\n"
+                           "}");
+            ASSERT_EQUALS("", errout_str());
 
             checkUninitVar("void f(int i) {\n"
                            "    int a;\n"
                            "    i >> a;\n"
                            "}");
-            ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: a\n", errout.str());
+            ASSERT_EQUALS("[test.cpp:3:10]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
             checkUninitVar("int a() {\n"
                            "    int ret;\n"
                            "    int a = value >> ret;\n"
                            "}\n",
-                           "test.c");
-            ASSERT_EQUALS("[test.c:3]: (error) Uninitialized variable: ret\n", errout.str());
+                           dinit(CheckUninitVarOptions, $.cpp = false));
+            ASSERT_EQUALS("[test.c:3:22]: (error) Uninitialized variable: ret [legacyUninitvar]\n", errout_str());
 
             checkUninitVar("void foo() {\n"   // #3707
                            "    Node node;\n"
                            "    int x;\n"
                            "    node[\"abcd\"] >> x;\n"
                            "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
 
             checkUninitVar("int a(FArchive &arc) {\n"   // #3060 (initialization through operator<<)
                            "    int *p;\n"
-                           "    arc << p;\n"
+                           "    arc << p;\n" // <- TODO initialization?
                            "    return *p;\n"
                            "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
             checkUninitVar("void a() {\n"
                            "    int ret;\n"
                            "    a = value << ret;\n"
                            "}\n",
-                           "test.c");
-            ASSERT_EQUALS("[test.c:3]: (error) Uninitialized variable: ret\n", errout.str());
+                           dinit(CheckUninitVarOptions, $.cpp = false));
+            ASSERT_EQUALS("[test.c:3:18]: (error) Uninitialized variable: ret [legacyUninitvar]\n", errout_str());
 
-            // #4320
-            checkUninitVar("void f() {\n"
+            // #4320 says this is a FP. << is overloaded.
+            checkUninitVar("int f() {\n"
                            "    int a;\n"
-                           "    a << 1;\n"
+                           "    a << 1;\n"  // <- TODO initialization?
                            "    return a;\n"
                            "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("[test.cpp:3:5]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
             // #4673
             checkUninitVar("void f() {\n"
                            "    int a;\n"
                            "    std::cout << a;\n"
                            "}");
-            ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: a\n", errout.str());
+            ASSERT_EQUALS("[test.cpp:3:18]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
             checkUninitVar("void f(std::ostringstream& os) {\n"
                            "    int a;\n"
                            "    os << a;\n"
                            "}");
-            ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: a\n", errout.str());
+            ASSERT_EQUALS("[test.cpp:3:11]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
             checkUninitVar("void f() {\n"
                            "    int a;\n"
                            "    std::cout << 1 << a;\n"
                            "}");
-            ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: a\n", errout.str());
+            ASSERT_EQUALS("[test.cpp:3:23]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
             checkUninitVar("void f(std::ostringstream& os) {\n"
                            "    int a;\n"
                            "    os << 1 << a;\n"
                            "}");
-            ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: a\n", errout.str());
+            ASSERT_EQUALS("[test.cpp:3:16]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
+
+            {
+                // #9422
+                checkUninitVar("void f() {\n"
+                               "  char *p = new char[10];\n"
+                               "  std::cout << (void *)p << 1;\n"
+                               "}");
+                ASSERT_EQUALS("", errout_str());
+
+                checkUninitVar("void f() {\n"
+                               "  char p[10];\n"
+                               "  std::cout << (void *)p << 1;\n"
+                               "}");
+                ASSERT_EQUALS("", errout_str());
+
+                checkUninitVar("void f() {\n"
+                               "  char *p = new char[10];\n"
+                               "  std::cout << p << 1;\n"
+                               "}");
+                ASSERT_EQUALS("[test.cpp:3:16]: (error) Memory is allocated but not initialized: p [uninitdata]\n", errout_str());
+
+                checkUninitVar("void f() {\n" // #9696
+                               "  int *p = new int[10];\n"
+                               "  std::cout << p << 1;\n"
+                               "}");
+                ASSERT_EQUALS("", errout_str());
+
+                checkUninitVar("void f() {\n"
+                               "  int i[10];\n"
+                               "  std::cout << i;\n"
+                               "  char c[10];\n"
+                               "  std::cout << c;\n"
+                               "  wchar_t w[10];\n"
+                               "  std::cout << w;\n"
+                               "}");
+                ASSERT_EQUALS("[test.cpp:5:16]: (error) Uninitialized variable: c [legacyUninitvar]\n"
+                              "[test.cpp:7:16]: (error) Uninitialized variable: w [legacyUninitvar]\n",
+                              errout_str());
+
+                checkUninitVar("void f() {\n"
+                               "  char p[10];\n"
+                               "  std::cout << p << 1;\n"
+                               "}");
+                ASSERT_EQUALS("[test.cpp:3:16]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
+
+                checkUninitVar("void f() {\n"
+                               "  char p[10];\n"
+                               "  std::cout << *p << 1;\n"
+                               "}");
+                ASSERT_EQUALS("[test.cpp:3:17]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
+            }
+
+            checkUninitVar("void f() {\n" // #13908
+                           "    int* i = new int;\n"
+                           "    std::cout << i << \", \" << *i;\n"
+                           "    delete i;\n"
+                           "}\n");
+            ASSERT_EQUALS("[test.cpp:3:32]: (error) Memory is allocated but not initialized: i [uninitdata]\n", errout_str());
         }
 
         // #8494 : Overloaded & operator
@@ -481,40 +586,47 @@ class TestUninitVar : public TestFixture {
                        "  int x;\n"
                        "  a & x;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
         checkUninitVar("void f(int a) {\n"
                        "  int x;\n"
                        "  a & x;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:7]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
+
+        checkUninitVar("void f() {\n"
+                       "  int a,b,c;\n"
+                       "  ar & a & b & c;\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void a() {\n"   // asm
                        "    int x;\n"
                        "    asm();\n"
                        "    x++;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void a()\n"
                        "{\n"
                        "    int x[10];\n"
                        "    struct xyz xyz1 = { .x = x };\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void a()\n"
                        "{\n"
                        "    struct S *s;\n"
                        "    s->x = 0;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: s\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Uninitialized variable: s [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "   char *buf = malloc(100);\n"
                        "   struct ABC *abc = buf;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("class Fred {\n"
                        "public:\n"
@@ -525,7 +637,7 @@ class TestUninitVar : public TestFixture {
                        "{\n"
                        "    fclose(f);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
@@ -533,7 +645,7 @@ class TestUninitVar : public TestFixture {
                        "    ab(sizeof(xyz), &c);\n"
                        "    if (c);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
@@ -541,7 +653,7 @@ class TestUninitVar : public TestFixture {
                        "    a = (f2(&c));\n"
                        "    c++;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(int a)\n"
                        "{\n"
@@ -550,7 +662,7 @@ class TestUninitVar : public TestFixture {
                        "        *p = 0;\n"
                        "    }\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         // +=
         checkUninitVar("void f()\n"
@@ -558,14 +670,14 @@ class TestUninitVar : public TestFixture {
                        "    int c;\n"
                        "    c += 2;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: c\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    int a[10];\n"
                        "    a[0] = 10 - a[1];\n"
                        "}");
-        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: a\n", "", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:18]: (error) Uninitialized variable: a[1] [legacyUninitvar]\n", errout_str());
 
         // goto/setjmp/longjmp..
         checkUninitVar("void foo(int x)\n"
@@ -580,8 +692,8 @@ class TestUninitVar : public TestFixture {
                        "\n"
                        "found:\n"
                        "    int a = b;\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo()\n"
                        "{\n"
@@ -593,7 +705,7 @@ class TestUninitVar : public TestFixture {
                        "    a = 1;\n"
                        "    longjmp(env, 1);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // macro_for..
         checkUninitVar("int foo()\n"
@@ -607,7 +719,7 @@ class TestUninitVar : public TestFixture {
                        "    retval = 2;\n"
                        "  return retval;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo()\n"
                        "{\n"
@@ -615,8 +727,8 @@ class TestUninitVar : public TestFixture {
                        "    goto exit;\n"
                        "    i++;\n"
                        "exit:\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo() {\n"
                        "    int x,y=0;\n"
@@ -625,8 +737,8 @@ class TestUninitVar : public TestFixture {
                        "    x = a;\n"
                        "    y = 1;\n"
                        "    goto again;\n"
-                       "}", "test.c", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #3873 (false positive)
         checkUninitVar("MachineLoopRange *MachineLoopRanges::getLoopRange(const MachineLoop *Loop) {\n"
@@ -635,7 +747,7 @@ class TestUninitVar : public TestFixture {
                        "    Range = new MachineLoopRange(Loop, Allocator, *Indexes);\n"
                        "  return Range;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #4040 - False positive
         checkUninitVar("int f(int x)  {\n"
@@ -650,8 +762,8 @@ class TestUninitVar : public TestFixture {
                        "        iter = x;\n"
                        "    }\n"
                        "    return 1 + iter;\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         // C++11 style initialization
         checkUninitVar("int f() {\n"
@@ -659,7 +771,7 @@ class TestUninitVar : public TestFixture {
                        "    int j{ i };\n"
                        "    return j;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #5646
         checkUninitVar("float foo() {\n"
@@ -667,16 +779,41 @@ class TestUninitVar : public TestFixture {
                        "  float (*sink)[2] = &source;\n"
                        "  return (*sink)[0];\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // Ticket #9296
+        checkUninitVar("void f(void)\n"
+                       "{\n"
+                       "    int x;\n"
+                       "    int z = (x) & ~__round_mask(1, 1);\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:4:14]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
+
+        checkUninitVar("void f(void)\n"
+                       "{\n"
+                       "    int x;\n"
+                       "    int z = (x) | ~__round_mask(1, 1);\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:4:14]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
+
+        checkUninitVar("int __round_mask(int, int);\n"
+                       "void f(void)\n"
+                       "{\n"
+                       "    int x;\n"
+                       "    int* z = &x;\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitvar_warn_once() {
+        // extracttests.start: int a; int b;
+
         checkUninitVar("void f() {\n"
                        "  int x;\n"
                        "  a = x;\n"
                        "  b = x;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:7]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
     }
 
     // Handling of unknown types. Assume they are POD in C.
@@ -687,56 +824,59 @@ class TestUninitVar : public TestFixture {
                             "}";
 
         // Assume dfs is a non POD type if file is C++
-        checkUninitVar(code, "test.cpp");
-        ASSERT_EQUALS("", errout.str());
+        checkUninitVar(code);
+        ASSERT_EQUALS("", errout_str());
 
         // Assume dfs is a POD type if file is C
-        checkUninitVar(code, "test.c");
-        ASSERT_EQUALS("[test.c:3]: (error) Uninitialized variable: a\n", errout.str());
+        checkUninitVar(code, dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:3:12]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         const char code2[] = "struct AB { int a,b; };\n"
                              "void f() {\n"
                              "    struct AB ab;\n"
                              "    return ab;\n"
                              "}";
-        checkUninitVar(code2, "test.cpp");
-        ASSERT_EQUALS("", errout.str());
-        checkUninitVar(code2, "test.c");
-        ASSERT_EQUALS("[test.c:4]: (error) Uninitialized variable: ab\n", errout.str());
+        checkUninitVar(code2);
+        ASSERT_EQUALS("[test.cpp:4:12]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n"
+                      "[test.cpp:4:12]: (error) Uninitialized struct member: ab.b [uninitStructMember]\n", errout_str());
+        checkUninitVar(code2, dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:4:12]: (error) Uninitialized variable: ab [legacyUninitvar]\n", errout_str());
 
         // Ticket #3890 - False positive for std::map
         checkUninitVar("void f() {\n"
                        "    std::map<int,bool> x;\n"
                        "    return x;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #3906 - False positive for std::vector pointer
         checkUninitVar("void f() {\n"
                        "    std::vector<int> *x = NULL;\n"
                        "    return x;\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
-
-        // Ticket #6701 - Variable name is a POD type according to cfg
-        const char xmldata[] = "<?xml version=\"1.0\"?>\n"
-                               "<def format=\"1\">"
-                               "  <podtype name=\"_tm\"/>"
-                               "</def>";
-        settings.library.loadxmldata(xmldata, sizeof(xmldata));
-        checkUninitVar("void f() {\n"
-                       "  Fred _tm;\n"
-                       "  _tm.dostuff();\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        {
+            // Ticket #6701 - Variable name is a POD type according to cfg
+            constexpr char xmldata[] = "<?xml version=\"1.0\"?>\n"
+                                       "<def format=\"1\">"
+                                       "  <podtype name=\"_tm\"/>"
+                                       "</def>";
+            const Settings s = settingsBuilder(settings).libraryxml(xmldata).build();
+            checkUninitVar("void f() {\n"
+                           "  Fred _tm;\n"
+                           "  _tm.dostuff();\n"
+                           "}", s);
+            ASSERT_EQUALS("", errout_str());
+        }
 
         // Ticket #7822 - Array type
         checkUninitVar("A *f() {\n"
                        "    A a,b;\n"
                        "    b[0] = 0;"
                        "    return a;\n"
-                       "}", "test.c", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitvar3() { // #3844
@@ -753,33 +893,36 @@ class TestUninitVar : public TestFixture {
                        "         : _M_p(__x), _M_mask(__y) { }\n"
                        "    };\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitvar_bitop() {
+        // extracttests.start: int a; int c;
+
         checkUninitVar("void foo() {\n"
                        "    int b;\n"
                        "    c = a | b;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: b\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: b [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void foo() {\n"
                        "    int b;\n"
                        "    c = b | a;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: b\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: b [legacyUninitvar]\n", errout_str());
     }
 
     // if..
     void uninitvar_if() {
-        checkUninitVar("static void foo()\n"
+        // extracttests.start: struct Foo { void abcd(); };
+        checkUninitVar("static void foo(int x)\n"
                        "{\n"
                        "    Foo *p;\n"
                        "    if (x)\n"
                        "        p = new Foo;\n"
                        "    p->abcd();\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Uninitialized variable: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:5]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static void foo(int x)\n"
                        "{\n"
@@ -788,7 +931,25 @@ class TestUninitVar : public TestFixture {
                        "    if (x==2);\n"
                        "    x = a;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Uninitialized variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:9]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
+
+        checkUninitVar("int foo() {\n"
+                       "    int i;\n"
+                       "    if (1)\n"
+                       "        i = 11;\n"
+                       "    return i;\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("int bar(int x) {\n"
+                       "    int n;\n"
+                       "    if ( x == 23)\n"
+                       "      n = 1;\n"
+                       "    else if ( x == 11 )\n"
+                       "      n = 2;\n"
+                       "    return n;\n"
+                       "}");
+        TODO_ASSERT_EQUALS("error", "", errout_str());
 
         checkUninitVar("int foo()\n"
                        "{\n"
@@ -799,7 +960,7 @@ class TestUninitVar : public TestFixture {
                        "        i = 33;\n"
                        "    return i;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo(int x)\n" // #5503
                        "{\n"
@@ -810,7 +971,7 @@ class TestUninitVar : public TestFixture {
                        "        i = 33;\n"
                        "    return i;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo()\n"
                        "{\n"
@@ -824,7 +985,7 @@ class TestUninitVar : public TestFixture {
                        "    }\n"
                        "    return i;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo()\n"
                        "{\n"
@@ -839,8 +1000,8 @@ class TestUninitVar : public TestFixture {
                        "        i = 33;\n"
                        "    }\n"
                        "    return i;\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("static void foo(int x)\n"
                        "{\n"
@@ -850,7 +1011,7 @@ class TestUninitVar : public TestFixture {
                        "    if (x)\n"
                        "        p->abcd();\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo(int a)\n"
                        "{\n"
@@ -868,7 +1029,7 @@ class TestUninitVar : public TestFixture {
                        "        a=condition;\n"
                        "    }\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
@@ -876,20 +1037,20 @@ class TestUninitVar : public TestFixture {
                        "    if (fun(&c));\n"
                        "    c->Release();\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    C c;\n"
                        "    if (fun(&c.d));\n"
                        "    return c;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "   char a[10];\n"
                        "   if (a[0] = x){}\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo(int x)\n"
                        "{\n"
@@ -900,7 +1061,7 @@ class TestUninitVar : public TestFixture {
                        "        return 3;\n"
                        "    return i;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #2207 - False positive
         checkUninitVar("void foo(int x) {\n"
@@ -911,7 +1072,7 @@ class TestUninitVar : public TestFixture {
                        "        return;\n"
                        "    b = (c - a);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo()\n"
                        "{\n"
@@ -922,7 +1083,7 @@ class TestUninitVar : public TestFixture {
                        "        throw 3;\n"
                        "    return ret;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f(int a)\n"
                        "{\n"
@@ -933,7 +1094,7 @@ class TestUninitVar : public TestFixture {
                        "        XYZ ret = 2;\n"  // XYZ may be an unexpanded macro so bailout the checking of "ret".
                        "    return ret;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Uninitialized variable: ret\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:12]: (error) Uninitialized variable: ret [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int f(int a, int b)\n"
                        "{\n"
@@ -946,7 +1107,7 @@ class TestUninitVar : public TestFixture {
                        "   }\n"
                        "   return x;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo(long verbose,bool bFlag)\n"
                        "{\n"
@@ -959,7 +1120,7 @@ class TestUninitVar : public TestFixture {
                        "      std::cout << (12-t);\n"
                        "  }\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int test(int cond1, int cond2) {\n"
                        "  int foo;\n"
@@ -971,14 +1132,25 @@ class TestUninitVar : public TestFixture {
                        "    int t = foo*foo;\n"
                        "  }\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void foo(int *pix) {\n"
+                       "    int dest_x;\n"
+                       "    {\n"
+                       "        if (pix)\n"
+                       "            dest_x = 123;\n"
+                       "    }\n"
+                       "    if (pix)\n"
+                       "        a = dest_x;\n" // <- not uninitialized
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         // ? :
         checkUninitVar("static void foo(int v) {\n"
                        "    int x;\n"
                        "    x = v <= 0 ? -1 : x;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:23]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
@@ -990,19 +1162,19 @@ class TestUninitVar : public TestFixture {
                        "    ret = ret <= 0 ? -1 :\n"
                        "          strcmp(msgid1, msgid2) == 0;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo(int a, int b)\n"
                        "{\n"
                        "    int x; x = (a<b) ? 1 : 0;\n"
                        "    int y = y;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: y\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized variable: y [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void foo() {\n" // pidgin-2.11.0/finch/libgnt/gnttree.c
                        "  int x = (x = bar()) ? x : 0;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ; { .. }
         checkUninitVar("int foo()\n"
@@ -1015,7 +1187,7 @@ class TestUninitVar : public TestFixture {
                        "    retval = 2;\n"
                        "  return retval;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
@@ -1026,7 +1198,7 @@ class TestUninitVar : public TestFixture {
                        "\n"
                        "  { }\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ({ .. })
         checkUninitVar("void f() {\n"
@@ -1035,7 +1207,7 @@ class TestUninitVar : public TestFixture {
                        "    else { a = ({b=c;}); x = 456; }\n"
                        "    ++x;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #3098 - False negative uninitialized variable
         checkUninitVar("void f()\n"
@@ -1045,8 +1217,8 @@ class TestUninitVar : public TestFixture {
                        "    {\n"
                        "    }\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: c1\n"
-                      "[test.cpp:4]: (error) Uninitialized variable: c2\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:16]: (error) Uninitialized variable: c1 [legacyUninitvar]\n"
+                      "[test.cpp:4:19]: (error) Uninitialized variable: c2 [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f(char *c1, char *c2)\n"
                        "{\n"
@@ -1054,32 +1226,80 @@ class TestUninitVar : public TestFixture {
                        "    {\n"
                        "    }\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    char *c1;\n"
                        "    c1=strcpy(c1,\"test\");\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: c1\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:15]: (error) Uninitialized variable: c1 [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f(char *c1)\n"
                        "{\n"
                        "    c1=strcpy(c1,\"test\");\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "  X var;\n"
                        "  memset(var, 0, sizeof(var));\n"
-                       "}", "test.c");
-        ASSERT_EQUALS("", errout.str());
+                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("int f() {\n" // #8692
+                       "    bool b = e();\n"
+                       "    int v;\n"
+                       "    if (b)\n"
+                       "        doStuff(&v);\n"
+                       "    int v2 = (b) ? v / 5 : 0;\n"
+                       "    int v3;\n"
+                       "    if (b)\n"
+                       "        v3 = 50;\n"
+                       "    int v4 = (b) ? v3 + 5 : 0;\n"
+                       "    int v5;\n"
+                       "    int v6 = v5;\n"
+                       "    doStuff(&v5);\n"
+                       "    int v7 = v5;\n"
+                       "    return v2 + v4 + v6 + v7;\n"
+                       "}\n");
+        ASSERT_EQUALS("[test.cpp:12:14]: (error) Uninitialized variable: v5 [legacyUninitvar]\n", errout_str());
+
+        checkUninitVar("bool set(int *p);\n"
+                       "\n"
+                       "void foo(bool a) {\n"
+                       "    bool flag{false};\n"
+                       "    int x;\n"
+                       "    if (!a) {\n"
+                       "        flag = set(&x);\n"
+                       "    }\n"
+                       "    if (!flag || x == 0) {}\n"
+                       "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void f(int n, int a) {\n" // #12011
+                       "    double x[10];\n"
+                       "    if (n == 1) {\n"
+                       "        if (a)\n"
+                       "            x[0] = 4;\n"
+                       "    }\n"
+                       "    else\n"
+                       "        for (int i = 0; i < n; i++) {\n"
+                       "            if (a)\n"
+                       "                x[i] = 8;\n"
+                       "        }\n"
+                       "    if (n == 1)\n"
+                       "        if (a)\n"
+                       "            (void)x[0];\n"
+                       "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
 
     // handling for/while loops..
     void uninitvar_loops() {
         // for..
+        // extracttests.start: void b(int);
         checkUninitVar("void f()\n"
                        "{\n"
                        "    for (int i = 0; i < 4; ++i) {\n"
@@ -1087,7 +1307,7 @@ class TestUninitVar : public TestFixture {
                        "        b(4*a);\n"
                        "    }"
                        "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:13]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int k;\n"
@@ -1095,7 +1315,7 @@ class TestUninitVar : public TestFixture {
                        "        k = k + 2;\n"
                        "    }\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: k\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized variable: k [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    gchar sel[10];\n"
@@ -1103,7 +1323,7 @@ class TestUninitVar : public TestFixture {
                        "        int sz = sizeof(sel);\n"
                        "    }\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("enum ABCD { A, B, C, D };\n"
                        "\n"
@@ -1113,7 +1333,7 @@ class TestUninitVar : public TestFixture {
                        "        str[i] = 0;\n"
                        "    }\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void x() {\n"
                        "    do  {\n"
@@ -1123,7 +1343,42 @@ class TestUninitVar : public TestFixture {
                        "        }\n"
                        "    } while (tok2);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void foo(void) {\n"
+                       "    int a = 0;\n"
+                       "    int x;\n"
+                       "\n"
+                       "    for (;;) {\n"
+                       "        if (!a || 12 < x) {\n" // <- x is not uninitialized
+                       "            a = 1;\n"
+                       "            x = 2;\n"
+                       "        }\n"
+                       "    }\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void foo(void) {\n"
+                       "    int a = 0;\n"
+                       "    int x;\n"
+                       "\n"
+                       "    for (;;) {\n"
+                       "        if (!a || 12 < x) {\n" // <- x is uninitialized
+                       "            a = 1;\n"
+                       "        }\n"
+                       "    }\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:6:24]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
+
+        checkUninitVar("void foo(int n) {\n"
+                       "  int one[10];\n"
+                       "  for (int rank = 0; rank < n; ++rank) {\n"
+                       "    for (int i=0;i<rank;i++)\n"
+                       "      f = one[i];\n"
+                       "    one[rank] = -1;\n"
+                       "  }\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #2226: C++0x loop
         checkUninitVar("void f() {\n"
@@ -1131,7 +1386,7 @@ class TestUninitVar : public TestFixture {
                        "    for (iterator it : c) {\n"
                        "    }\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #2345: False positive in sub-condition in if inside a loop
         checkUninitVar("void f(int x) {\n"
@@ -1142,8 +1397,9 @@ class TestUninitVar : public TestFixture {
                        "        x--;\n"
                        "    }\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
-        checkUninitVar("void f(int x) {\n"
+        ASSERT_EQUALS("", errout_str());
+        // extracttests.start: struct PoolItem { bool operator!=(const PoolItem&) const; };
+        checkUninitVar("void f(int x, const PoolItem& rPool) {\n"
                        "    const PoolItem* pItem;\n"
                        "    while (x > 0) {\n"
                        "        if (*pItem != rPool)\n"
@@ -1151,7 +1407,7 @@ class TestUninitVar : public TestFixture {
                        "        x--;\n"
                        "    }\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: pItem\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:14]: (error) Uninitialized variable: pItem [legacyUninitvar]\n", errout_str());
 
         // #2231 - conditional initialization in loop..
         checkUninitVar("int foo(char *a) {\n"
@@ -1166,7 +1422,7 @@ class TestUninitVar : public TestFixture {
                        "\n"
                        "    return x;\n"
                        "}");
-        TODO_ASSERT_EQUALS("[test.cpp:11]: (error) Uninitialized variable: x\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:11]: (error) Uninitialized variable: x\n", "", errout_str());
 
         // Ticket #2796
         checkUninitVar("void foo() {\n"
@@ -1177,7 +1433,7 @@ class TestUninitVar : public TestFixture {
                        "        return x;\n"   // <- x is initialized
                        "    }\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Assignment in for. Ticket #3287
         checkUninitVar("int foo(char* in, bool b) {\n"
@@ -1186,7 +1442,96 @@ class TestUninitVar : public TestFixture {
                        "    else c = in + strlen(in) - 1;\n"
                        "    *c = 0;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // #10273 - assignment in conditional code
+        // extracttests.start: extern const int PORT_LEARN_DISABLE;
+        checkUninitVar("void foo() {\n"
+                       "    int learn;\n"
+                       "    for (int index = 0; index < 10; index++) {\n"
+                       "        if (!(learn & PORT_LEARN_DISABLE))\n"
+                       "            learn = 123;\n"
+                       "    }\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:4:15]: (error) Uninitialized variable: learn [legacyUninitvar]\n", errout_str());
+
+        // extracttests.start: struct Entry { Entry *next; }; Entry *buckets[10];
+        checkUninitVar("void foo() {\n"
+                       "  Entry *entry, *nextEntry;\n"
+                       "  for(int i = 0; i < 10; i++) {\n"
+                       "    for(entry = buckets[i]; entry != NULL; entry = nextEntry) {\n" // <- nextEntry is not uninitialized
+                       "      nextEntry = entry->next;\n"
+                       "    }\n"
+                       "  }\n"
+                       "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void foo() {\n"
+                       "  Entry *entry, *nextEntry;\n"
+                       "  for(int i = 0; i < 10; i++) {\n"
+                       "    for(entry = buckets[i]; entry != NULL; entry = nextEntry) {\n"
+                       "    }\n"
+                       "  }\n"
+                       "}\n");
+        ASSERT_EQUALS("[test.cpp:4:52]: (error) Uninitialized variable: nextEntry [legacyUninitvar]\n", errout_str());
+
+        checkUninitVar("void f(int x) {\n"
+                       "    list *f = NULL;\n"
+                       "    list *l;\n"
+                       "\n"
+                       "    while (--x) {\n"
+                       "        if (!f)\n"
+                       "            f = c;\n"
+                       "        else\n"
+                       "            l->next = c;\n" // <- not uninitialized
+                       "        l = c;\n"
+                       "    }\n"
+                       "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #6952 - do-while-loop
+        checkUninitVar("void f(void)\n"
+                       "{\n"
+                       "    int* p;\n"
+                       "    do\n"
+                       "    {\n"
+                       "        if (true) {;}\n"
+                       "        else\n"
+                       "        {\n"
+                       "            return;\n"
+                       "        }\n"
+                       "        *p = 7;\n" // <<
+                       "        p = new int(9);\n"
+                       "    } while (*p != 8);\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:11:10]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
+
+        // #6952 - while-loop
+        checkUninitVar("void f(void)\n"
+                       "{\n"
+                       "    int* p;\n"
+                       "    while (*p != 8) {\n" // <<
+                       "        *p = 7;\n"
+                       "        p = new int(9);\n"
+                       "    }\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
+
+        // switch in loop
+        checkUninitVar("int foo(int *p) {\n"
+                       "  int x;\n"
+                       "  while (true) {\n"
+                       "    switch (*p) {\n"
+                       "    case 1:\n"
+                       "        return x;\n"
+                       "    case 2:\n"
+                       "        x = 123;\n"
+                       "        break;\n"
+                       "    };\n"
+                       "    ++p\n"
+                       "  }\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     // switch..
@@ -1200,7 +1545,7 @@ class TestUninitVar : public TestFixture {
                        "        break;\n"
                        "    };\n"
                        "}");
-        TODO_ASSERT_EQUALS("[test.cpp:6]: (error) Uninitialized variable: c\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:6:5]: (error) Uninitialized variable: c [uninitvar]\n", "", errout_str());
 
         checkUninitVar("char * f()\n"
                        "{\n"
@@ -1213,7 +1558,7 @@ class TestUninitVar : public TestFixture {
                        "    }\n"
                        "    return 0;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo(const int iVar, unsigned int slot, unsigned int pin)\n"
                        "{\n"
@@ -1236,7 +1581,7 @@ class TestUninitVar : public TestFixture {
                        "    }\n"
                        "    return i;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #1855 - switch(foo(&x))
         checkUninitVar("int a()\n"
@@ -1248,7 +1593,7 @@ class TestUninitVar : public TestFixture {
                        "            return x;\n"
                        "    }\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #3231 - ({ switch .. })
         checkUninitVar("void f() {\n"
@@ -1261,18 +1606,18 @@ class TestUninitVar : public TestFixture {
                        "        break;\n"
                        "    };\n"
                        "    })\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     // arrays..
     void uninitvar_arrays() {
-        checkUninitVar("int f()\n"
+        checkUninitVar("void f()\n"
                        "{\n"
                        "    char a[10];\n"
                        "    a[a[0]] = 0;\n"
                        "}");
-        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: a\n", "", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:8]: (error) Uninitialized variable: a[0] [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int f()\n"
                        "{\n"
@@ -1280,59 +1625,59 @@ class TestUninitVar : public TestFixture {
                        "    *a = '\\0';\n"
                        "    int i = strlen(a);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    char a, b[10];\n"
                        "    a = b[0] = 0;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    char a[10], b[10];\n"
                        "    a[0] = b[0] = 0;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    char a[10], *p;\n"
                        "    *(p = a) = 0;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    char a[10], *p;\n"
                        "    p = &(a[10]);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // array usage in ?: (tests that the isVariableUsed() works)
         checkUninitVar("void f() {\n"
                        "    char a[10], *p;\n"
                        "    p = c?a:0;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("void f() {\n"
+        checkUninitVar("void f(int x) {\n"
                        "    char a[10], c;\n"
                        "    c = *(x?a:0);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    char a[10], c;\n"
                        "    strcpy(dest, x?a:\"\");\n"
                        "}");
-        TODO_ASSERT_EQUALS("error", "", errout.str());
+        TODO_ASSERT_EQUALS("error", "", errout_str());
 
         checkUninitVar("void f(int x) {\n"
                        "  int a[2];\n"
                        "  y *= (x ? 1 : 2);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // passing array to library functions
         checkUninitVar("void f()\n"
@@ -1340,34 +1685,34 @@ class TestUninitVar : public TestFixture {
                        "    char c[50] = \"\";\n"
                        "    strcat(c, \"test\");\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("void f() {\n"
+        checkUninitVar("void f(char *s2) {\n"
                        "    char s[20];\n"
                        "    strcpy(s2, s);\n"
                        "};");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: s\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:16]: (error) Uninitialized variable: s [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    char s[20];\n"
                        "    strcat(s, \"abc\");\n"
                        "};");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: s\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: s [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    char s[20];\n"
                        "    strchr(s, ' ');\n"
                        "};");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: s\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: s [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "        int y[2];\n"
                        "        int s;\n"
                        "        GetField( y + 0, y + 1 );\n"
-                       "        s = y[0]*y[1];\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "        s = y[0] * y[1];\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
@@ -1375,47 +1720,68 @@ class TestUninitVar : public TestFixture {
                        "        init(a - 1);\n"
                        "        int b = a[0];\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "        Fred a[2];\n"
                        "        Fred b = a[0];\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void foo() {\n"
+                       "  char buf[1024];\n"
+                       "  char *b = (char *) (((uintptr_t) buf + 63) & ~(uintptr_t) 63);\n"
+                       "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void foo() {\n"
+                       "  char buf[1024];\n"
+                       "  char x = *(char *) (((uintptr_t) buf + 63) & ~(uintptr_t) 63);\n"
+                       "}\n");
+        ASSERT_EQUALS("[test.cpp:3:36]: (error) Uninitialized variable: buf [legacyUninitvar]\n", errout_str());
+
+        // Passing array to function
+        checkUninitVar("void f(int i);\n"
+                       "void foo()\n"
+                       "{\n"
+                       "    int a[10];\n"
+                       "    f(a[0]);\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:5:7]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         // Ticket #2320
         checkUninitVar("void foo() {\n"
                        "        char a[2];\n"
-                       "        char *b = (a+2) & 7;\n"
+                       "        unsigned long b = (unsigned long)(a+2) & ~7;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"   // Ticket #3050
                        "    char a[2];\n"
                        "    printf(\"%s\", a);\n"
                        "}");
-        TODO_ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: a\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: a [legacyUninitvar]\n", "", errout_str());
 
         checkUninitVar("void f() {\n"   // Ticket #5108 (fp)
                        "    const char *a;\n"
                        "    printf(\"%s\", a=\"abc\");\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"    // Ticket #3497
                        "    char header[1];\n"
                        "    *((unsigned char*)(header)) = 0xff;\n"
                        "    return header[0];\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"    // Ticket #3497
                        "    char header[1];\n"
                        "    *((unsigned char*)((unsigned char *)(header))) = 0xff;\n"
                        "    return header[0];\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    ABC abc;\n"
@@ -1425,7 +1791,7 @@ class TestUninitVar : public TestFixture {
                        "    init(&abc);\n"
                        "    return a[0];\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ticket #3344
         checkUninitVar("void f(){\n"
@@ -1433,46 +1799,54 @@ class TestUninitVar : public TestFixture {
                        "   char *buffer=(char*)malloc(128*sizeof(char));\n"
                        "   strcpy(strMsg,buffer);\n"
                        "   free(buffer);\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("[test.cpp:4]: (error) Memory is allocated but not initialized: buffer\n", errout.str());
+                       "}");
+        ASSERT_EQUALS("[test.cpp:4:18]: (error) Memory is allocated but not initialized: buffer [uninitdata]\n", errout_str());
+
+        checkUninitVar("void f(){\n"
+                       "   char *strMsg = \"This is a message\";\n"
+                       "   char *buffer=static_cast<char*>(malloc(128*sizeof(char)));\n"
+                       "   strcpy(strMsg,buffer);\n"
+                       "   free(buffer);\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:4:18]: (error) Memory is allocated but not initialized: buffer [uninitdata]\n", errout_str());
 
         // #3845
         checkUninitVar("int foo() {\n"
                        "    int a[1] = {5};\n"
                        "    return a[0];\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo() {\n"
                        "    int a[2][2] = {{3,4}, {5,6}};\n"
                        "    return a[0][1];\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int foo() {\n"
                        "    int a[1];\n"
                        "    return a[0];\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int foo() {\n"
                        "    int a[2][2];\n"
                        "    return a[0][1];\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int foo() {\n"
                        "    int a[10];\n"
                        "    dostuff(a[0]);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // # 4740
         checkUninitVar("void f() {\n"
                        "    int *a[2][19];\n"
                        "    int **b = a[0];\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6869 - FP when passing uninit array to function
         checkUninitVar("void bar(PSTR x);\n"
@@ -1480,7 +1854,7 @@ class TestUninitVar : public TestFixture {
                        "  char x[10];\n"
                        "  bar(x);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // struct
         checkUninitVar("struct Fred { int x; int y; };\n"
@@ -1488,8 +1862,27 @@ class TestUninitVar : public TestFixture {
                        "void f() {\n"
                        "  struct Fred fred[10];\n"
                        "  fred[1].x = 0;\n"
-                       "}", "test.c");
-        ASSERT_EQUALS("", errout.str());
+                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("char f() {\n"
+                       "    std::array<char, 1> a;\n"
+                       "    return a[0];\n"
+                       "}\n");
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
+
+        checkUninitVar("std::string f() {\n"
+                       "    std::array<std::string, 1> a;\n"
+                       "    return a[0];\n"
+                       "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("int f() {\n" // #12355
+                       "    const int x[10](1, 2);\n"
+                       "    if (x[0] == 1) {}\n"
+                       "    return x[0];\n"
+                       "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitvar_pointertoarray() {
@@ -1512,9 +1905,16 @@ class TestUninitVar : public TestFixture {
                        "        vertices[i][1][2] = 4.0;\n"
                        "        vertices[i][1][3] = 5.0;\n"
                        "    }\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) Uninitialized variable: vertices [legacyUninitvar]\n",
+                      errout_str());
+
+        checkUninitVar("void f() {\n"
+                       "    std::array<int, 3> *PArr[2] = { p0, p1 };\n"
+                       "    (*PArr[0])[2] = 0;\n"
+                       "    (*PArr[1])[2] = 0;\n"
                        "}\n");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: vertices\n",
-                      errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitvar_cpp11ArrayInit() { // #7010
@@ -1522,105 +1922,105 @@ class TestUninitVar : public TestFixture {
                        "    double adIHPoint_local[4][4]{};\n"
                        "    function(*adIHPoint_local);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // alloc..
     void uninitvar_alloc() {
         checkUninitVar("void f() {\n"
-                       "    char *s = malloc(100);\n"
+                       "    char *s = (char *)malloc(100);\n"
                        "    strcat(s, \"abc\");\n"
                        "};");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Memory is allocated but not initialized: s\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Memory is allocated but not initialized: s [uninitdata]\n", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    char *s1 = new char[10];\n"
                        "    char *s2 = new char[strlen(s1)];\n"
                        "};");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Memory is allocated but not initialized: s1\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:32]: (error) Memory is allocated but not initialized: s1 [uninitdata]\n", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
-                       "    char *p = malloc(64);\n"
+                       "    char *p = (char*)malloc(64);\n"
                        "    int x = p[0];\n"
                        "}");
-        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Memory is allocated but not initialized: p\n", "", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (error) Memory is allocated but not initialized: p [uninitdata]\n", errout_str());
 
         checkUninitVar("void f() {\n"
-                       "    char *p = malloc(64);\n"
+                       "    char *p = (char*)malloc(64);\n"
                        "    if (p[0]) { }\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Memory is allocated but not initialized: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (error) Memory is allocated but not initialized: p[0] [uninitdata]\n", errout_str());
 
-        checkUninitVar("void f() {\n"
-                       "    char *p = malloc(64);\n"
+        checkUninitVar("char f() {\n"
+                       "    char *p = (char*)malloc(64);\n"
                        "    return p[0];\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Memory is allocated but not initialized: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Memory is allocated but not initialized: p [uninitdata]\n", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    Fred *fred = new Fred;\n"
                        "    fred->foo();\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("struct Fred { int i; Fred(int, float); };\n"
                        "void f() {\n"
                        "    Fred *fred = new Fred(1, 2);\n"
                        "    fred->foo();\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    Fred *fred = malloc(sizeof(Fred));\n"
                        "    x(&fred->f);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    Fred *fred = malloc(sizeof(Fred));\n"
                        "    x(fred->f);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo(char *s)\n"
                        "{\n"
                        "    char *a = malloc(100);\n"
                        "    *a = *s;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "    char *a;\n"
                        "    if (a);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "    char *a = malloc(100);\n"
                        "    if (a);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "    ABC *abc = malloc(100);\n"
                        "    abc->a = 123;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "    ABC *abc = malloc(100);\n"
                        "    abc->a.word = 123;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
@@ -1628,30 +2028,30 @@ class TestUninitVar : public TestFixture {
                        "    abc->a = 123;\n"
                        "    abc->a += 123;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "    ABC *abc = malloc(100);\n"
                        "    free(abc);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
-                       "    char *s = malloc(100);\n"
+                       "    char *s = (char*)malloc(100);\n"
                        "    if (!s)\n"
                        "        return;\n"
                        "    char c = *s;\n"
-                       "};");
-        TODO_ASSERT_EQUALS("[test.cpp:6]: (error) Memory is allocated but not initialized: s\n", "", errout.str());
+                       "}");
+        ASSERT_EQUALS("[test.cpp:6:15]: (error) Memory is allocated but not initialized: s [uninitdata]\n", errout_str());
 
         // #3708 - false positive when using ptr typedef
         checkUninitVar("void f() {\n"
                        "    uintptr_t x = malloc(100);\n"
                        "    uintptr_t y = x + 10;\n"  // <- not bad usage
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "  z_stream strm;\n"
@@ -1660,7 +2060,7 @@ class TestUninitVar : public TestFixture {
                        "  deflate(&strm, Z_FINISH);\n"
                        "  memcpy(body, buf, 10);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6451 - allocation in subscope
         checkUninitVar("struct StgStrm {\n"
@@ -1676,20 +2076,7 @@ class TestUninitVar : public TestFixture {
                        "        pNewStrm = new StgStrm(rIo);\n"
                        "    pNewStrm->Write();\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
-
-        checkUninitVar("struct StgStrm {\n"
-                       "    StgIo& rIo;\n"
-                       "    StgStrm(StgIo&);\n"
-                       "    virtual sal_Int32 Write();\n"
-                       "};\n"
-                       "void Tmp2Strm() {\n"
-                       "    StgStrm* pNewStrm;\n"
-                       "    if (someflag)\n"
-                       "        pNewStrm = new StgStrm(rIo);\n"
-                       "    pNewStrm->Write();\n"
-                       "}");
-        TODO_ASSERT_EQUALS("[test.cpp:10]: (error) Uninitialized variable: pNewStrm\n", "", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6450 - calling a member function is allowed if memory was allocated by new
         checkUninitVar("struct EMFPFont {\n"
@@ -1700,17 +2087,92 @@ class TestUninitVar : public TestFixture {
                        "    EMFPFont *font = new EMFPFont();\n"
                        "    font->Initialize();\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #7623 - new can also initialize the memory, don't warn in this case
         checkUninitVar("void foo(){\n"
-                       "    int* p1 = new int(314); \n"
-                       "    int* p2 = new int(); \n"
-                       "    int* arr = new int[5](); \n"
-                       "    std::cout << *p1 << *p2 << arr[0]; \n"
+                       "    int* p1 = new int(314);\n"
+                       "    int* p2 = new int();\n"
+                       "    int* arr = new int[5]();\n"
+                       "    std::cout << *p1 << *p2 << arr[0];\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // new in C code does not allocate..
+        checkUninitVar("int main() {\n"
+                       "    char * pBuf = new(10);\n"
+                       "    a = *pBuf;\n"
+                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("class A {};\n" // #10698
+                       "void f() {\n"
+                       "    A* a = new A{};\n"
+                       "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #1175
+        checkUninitVar("void f() {\n"
+                       "    int* p = new int;\n"
+                       "    *((int*)*p) = 42;\n"
+                       "    delete p;\n"
+                       "}\n");
+        ASSERT_EQUALS("[test.cpp:3:14]: (error) Memory is allocated but not initialized: p [uninitdata]\n", errout_str());
+
+        checkUninitVar("int f() {\n" // #10596
+                       "    int* a = new int;\n"
+                       "    int i{};\n"
+                       "    i += *a;\n"
+                       "    delete a;\n"
+                       "    return i;\n"
+                       "}\n");
+        ASSERT_EQUALS("[test.cpp:4:11]: (error) Memory is allocated but not initialized: a [uninitdata]\n", errout_str());
+
+        checkUninitVar("void* f(size_t n, int i) {\n" // #11766
+                       "    char* p = (char*)malloc(n);\n"
+                       "    *(int*)p = i;\n"
+                       "    return p;\n"
+                       "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void* f(size_t n, int i) {\n"
+                       "    char* p = (char*)malloc(n);\n"
+                       "    *(int*)(void*)p = i;\n"
+                       "    return p;\n"
+                       "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void f(int n) {\n"
+                       "    int* p = (int*)malloc(n * sizeof(int));\n"
+                       "    for (int i = 0; i < n; ++i)\n"
+                       "        *(p + i) = 0;\n"
+                       "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("int* f() {\n" // #14448
+                       "    int* p = (int*)malloc(4);\n"
+                       "    if (!p)\n"
+                       "        return nullptr;\n"
+                       "    if (*p) {}\n"
+                       "    return p;\n"
+                       "}\n");
+        ASSERT_EQUALS("[test.cpp:5:9]: (error) Memory is allocated but not initialized: *p [uninitdata]\n", errout_str());
+
+        checkUninitVar("int* f() {\n"
+                       "    int* p = (int*)malloc(4);\n"
+                       "    if (p == nullptr)\n"
+                       "        return nullptr;\n"
+                       "    if (*p) {}\n"
+                       "    return p;\n"
+                       "}\n");
+        ASSERT_EQUALS("[test.cpp:5:9]: (error) Memory is allocated but not initialized: *p [uninitdata]\n", errout_str());
 
+        checkUninitVar("char* f(size_t nBytes, size_t nAlign) {\n" // #14485
+                       "    char* p = reinterpret_cast<char*>(malloc(nBytes));\n"
+                       "    if ((uintptr_t)p % nAlign != 0) {}\n"
+                       "    return p;\n"
+                       "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     // class / struct..
@@ -1720,7 +2182,7 @@ class TestUninitVar : public TestFixture {
                        "    int i;\n"
                        "    int a() { return i; }\n"
                        "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
@@ -1731,16 +2193,16 @@ class TestUninitVar : public TestFixture {
                        "        }\n"
                        "    };\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    static const struct ab {\n"
                        "        int a,b;\n"
                        "        int get_a() { return a; }"
-                       "    } = { 0, 0 };\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "    } x = { 0, 0 };\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
@@ -1752,14 +2214,14 @@ class TestUninitVar : public TestFixture {
                        "        i = 0;\n"
                        "    }\n"
                        "    return i;\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(int x) {\n"
                        "    struct AB ab;\n"
                        "    x = ab.x = 12;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // enum..
@@ -1770,7 +2232,7 @@ class TestUninitVar : public TestFixture {
                        "    AB ab;\n"
                        "    if (ab);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: ab\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:9]: (error) Uninitialized variable: ab [legacyUninitvar]\n", errout_str());
     }
 
     // references..
@@ -1781,8 +2243,8 @@ class TestUninitVar : public TestFixture {
                        "    int &b = a;\n"
                        "    b = 0;\n"
                        "    int x = a;\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(struct blame_entry *ent)\n"
                        "{\n"
@@ -1790,14 +2252,14 @@ class TestUninitVar : public TestFixture {
                        "    char hex[41];\n"
                        "    strcpy(hex, sha1_to_hex(suspect->commit->object.sha1));\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo()\n"
                        "{\n"
                        "    const std::string s(x());\n"
                        "    strchr(s.c_str(), ',');\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6717
         checkUninitVar("void f() {\n"
@@ -1806,7 +2268,7 @@ class TestUninitVar : public TestFixture {
                        "    int& referenced_int = it.value;\n"
                        "    referenced_int = 123;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitvar_return() {
@@ -1815,19 +2277,19 @@ class TestUninitVar : public TestFixture {
                        "    int ret;\n"
                        "    return ret;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: ret\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: ret [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static int foo() {\n"
                        "    int ret;\n"
                        "    return ret+5;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: ret\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: ret [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static int foo() {\n"
                        "    int ret;\n"
                        "    return ret = 5;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         {
             checkUninitVar("static int foo() {\n"
@@ -1835,22 +2297,22 @@ class TestUninitVar : public TestFixture {
                            "    cin >> ret;\n"
                            "    return ret;\n"
                            "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
 
             checkUninitVar("static int foo() {\n"
                            "    int ret;\n"
                            "    return cin >> ret;\n"
-                           "}\n", "test.c");
-            ASSERT_EQUALS("[test.c:3]: (error) Uninitialized variable: ret\n", errout.str());
+                           "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+            ASSERT_EQUALS("[test.c:3:19]: (error) Uninitialized variable: ret [legacyUninitvar]\n", errout_str());
         }
 
         // Ticket #6341- False negative
         {
             checkUninitVar("wchar_t f() { int i; return btowc(i); }");
-            ASSERT_EQUALS("[test.cpp:1]: (error) Uninitialized variable: i\n", errout.str());
+            ASSERT_EQUALS("[test.cpp:1:35]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
 
             checkUninitVar("wchar_t f(int i) { return btowc(i); }");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
 
             // Avoid a potential false positive (#6341)
             checkUninitVar(
@@ -1862,7 +2324,7 @@ class TestUninitVar : public TestFixture {
                 "  int x;\n"
                 "  return setvalue(x);\n"
                 "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         // Ticket #5412 - False negative
@@ -1875,7 +2337,7 @@ class TestUninitVar : public TestFixture {
                            "    }\n"
                            "    printf (\"%f\",f);\n"
                            "}");
-            ASSERT_EQUALS("[test.cpp:7]: (error) Uninitialized variable: f\n", errout.str());
+            ASSERT_EQUALS("[test.cpp:7:18]: (error) Uninitialized variable: f [legacyUninitvar]\n", errout_str());
 
             // Check for potential FP
             checkUninitVar("void f(bool b) {\n"
@@ -1886,7 +2348,7 @@ class TestUninitVar : public TestFixture {
                            "    }\n"
                            "    printf (\"%f\",f);\n"
                            "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         // Ticket #2146 - False negative
@@ -1894,7 +2356,7 @@ class TestUninitVar : public TestFixture {
                        "    int y;\n"
                        "    return x ? 1 : y;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: y\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:14]: (error) Uninitialized variable: y [legacyUninitvar]\n", errout_str());
 
         // Ticket #3106 - False positive
         {
@@ -1902,13 +2364,13 @@ class TestUninitVar : public TestFixture {
                            "    int i;\n"
                            "    return x(&i) ? i : 0;\n"
                            "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
 
             checkUninitVar("int f() {\n"
                            "    int i;\n"
                            "    return x() ? i : 0;\n"
                            "}");
-            ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: i\n", errout.str());
+            ASSERT_EQUALS("[test.cpp:3:16]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
         }
     }
 
@@ -1921,7 +2383,7 @@ class TestUninitVar : public TestFixture {
                        "    init(&msg);\n"
                        "    key++;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Ticket #5660 - False positive
         checkUninitVar("int f() {\n"
@@ -1930,7 +2392,7 @@ class TestUninitVar : public TestFixture {
                        "    foo(res);\n"
                        "    return result;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6873
         checkUninitVar("int f() {\n"
@@ -1939,7 +2401,7 @@ class TestUninitVar : public TestFixture {
                        "    foo(b);\n"
                        "    return atoi(a);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // = { .. }
         checkUninitVar("int f() {\n"
@@ -1948,7 +2410,7 @@ class TestUninitVar : public TestFixture {
                        "    *p[0] = 0;\n"
                        "    return a;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
     }
 
@@ -1963,7 +2425,7 @@ class TestUninitVar : public TestFixture {
                        "    strncpy(a, s, 20);\n"
                        "    strncat(a, s, 20);\n"
                        "}");
-        TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Dangerous usage of 'a' (strncpy doesn't always null-terminate it).\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Dangerous usage of 'a' (strncpy doesn't always null-terminate it).\n", "", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
@@ -1971,15 +2433,15 @@ class TestUninitVar : public TestFixture {
                        "    strncpy(a, \"hello\", 3);\n"
                        "    strncat(a, \"world\", 20);\n"
                        "}");
-        TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Dangerous usage of 'a' (strncpy doesn't always null-terminate it).\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Dangerous usage of 'a' (strncpy doesn't always null-terminate it).\n", "", errout_str());
 
         checkUninitVar("void f()\n"
                        "{\n"
                        "    char a[100];\n"
                        "    strncpy(a, \"hello\", sizeof(a));\n"
                        "    strncat(a, \"world\", 20);\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         // #3245 - false positive
         {
@@ -1988,14 +2450,14 @@ class TestUninitVar : public TestFixture {
                            "    strncpy(a,p,10);\n"
                            "    memcmp(a,q,10);\n"
                            "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
 
             checkUninitVar("void f() {\n"
                            "    char a[100];\n"
                            "    strncpy(a,p,10);\n"
                            "    if (memcmp(a,q,10)==0);\n"
                            "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
 
         // Using strncpy isn't necessarily dangerous usage
@@ -2004,34 +2466,34 @@ class TestUninitVar : public TestFixture {
                        "    strncpy(buf, dev, 10);\n"
                        "    strncpy(str, buf, 10);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "  char dst[4];\n"
                        "  const char* source = \"You\";\n"
                        "  strncpy(dst, source, sizeof(dst));\n"
                        "  char value = dst[2];\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     // valid and invalid use of 'int a(int x) { return x + x; }'
     void func_uninit_var() {
         const std::string funca("int a(int x) { return x + x; }");
 
-        checkUninitVar((funca +
-                        "void b() {\n"
-                        "    int x;\n"
-                        "    a(x);\n"
-                        "}").c_str());
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: x\n", errout.str());
+        checkUninitVar(funca +
+                       "void b() {\n"
+                       "    int x;\n"
+                       "    a(x);\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:3:7]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
-        checkUninitVar((funca +
-                        "void b() {\n"
-                        "    int *p;\n"
-                        "    a(*p);\n"
-                        "}").c_str());
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: p\n", errout.str());
+        checkUninitVar(funca +
+                       "void b() {\n"
+                       "    int *p;\n"
+                       "    a(*p);\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:3:8]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
     }
 
 
@@ -2040,20 +2502,20 @@ class TestUninitVar : public TestFixture {
         const std::string funca("void a(int *p) { *p = 0; }");
 
         // ok - initialized pointer
-        checkUninitVar((funca +
-                        "void b() {\n"
-                        "    int buf[10];\n"
-                        "    a(buf);\n"
-                        "}").c_str());
-        ASSERT_EQUALS("", errout.str());
+        checkUninitVar(funca +
+                       "void b() {\n"
+                       "    int buf[10];\n"
+                       "    a(buf);\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         // not ok - uninitialized pointer
-        checkUninitVar((funca +
-                        "void b() {\n"
-                        "    int *p;\n"
-                        "    a(p);\n"
-                        "}").c_str());
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: p\n", errout.str());
+        checkUninitVar(funca +
+                       "void b() {\n"
+                       "    int *p;\n"
+                       "    a(p);\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:3:7]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
     }
 
     void uninitvar_typeof() {
@@ -2061,24 +2523,50 @@ class TestUninitVar : public TestFixture {
                        "    struct Fred *fred;\n"
                        "    typeof(fred->x);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    struct SData * s;\n"
                        "    ab(typeof(s->status));\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    struct SData * s;\n"
                        "    TYPEOF(s->status);\n"
                        "}");
-        TODO_ASSERT_EQUALS("", "[test.cpp:3]: (error) Uninitialized variable: s\n", errout.str());
+        TODO_ASSERT_EQUALS("", "[test.cpp:3:12]: (error) Uninitialized variable: s [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int *n = ({ typeof(*n) z;  (typeof(*n)*)z; })\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void uninitvar_ignore() {
+        checkUninitVar("void foo() {\n"
+                       "  int i;\n"
+                       "  dostuff((int&)i, 0);\n" // <- cast is not use
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("int foo() {\n"
+                       "  int i;\n"
+                       "  return (int&)i + 2;\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:3:16]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
+
+        checkUninitVar("void foo() {\n"
+                       "  int i;\n"
+                       "  dostuff(*&i, 0);\n" // <- *& is not use
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("int foo() {\n"
+                       "  int i;\n"
+                       "  return *&i;\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
     }
 
     void uninitvar2() {
@@ -2087,113 +2575,121 @@ class TestUninitVar : public TestFixture {
                        "    int x;\n"
                        "    x++;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
+        // extracttests.start: char str[10];
         checkUninitVar("void f() {\n"
                        "    int x;\n"
                        "    str[x] = 0;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
+
+        checkUninitVar("void f() {\n" // #7736
+                       "    int buf[12];\n"
+                       "    printf (\"%d\", buf[0] );\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:3:19]: (error) Uninitialized variable: buf [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int x;\n"
                        "    int y = x & 3;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int x;\n"
                        "    int y = 3 & x;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:17]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int x;\n"
                        "    x = 3 + x;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
-        checkUninitVar("int f() {\n"
+        checkUninitVar("void f() {\n"
                        "    int x;\n"
                        "    x = x;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
+        // extracttests.start: struct ABC {int a;};
         checkUninitVar("void f() {\n"
                        "    struct ABC *abc;\n"
                        "    abc->a = 0;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: abc\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Uninitialized variable: abc [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int f() {\n"
                        "    static int x;\n"
                        "    return ++x;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f() {\n"
                        "    extern int x;\n"
                        "    return ++x;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"  // #3926 - weird cast.
                        "    int x;\n"
                        "    *(((char *)&x) + 0) = 0;\n"
-                       "}", "test.c", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n" // #4737 - weird cast.
                        "    int x;\n"
                        "    do_something(&((char*)&x)[0], 1);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int x;\n"
                        "    char *p = (char*)&x + 1;\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int i;\n"
                        "    i=f(), i!=2;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // using uninit var in condition
         checkUninitVar("void f(void) {\n"
                        "    int x;\n"
                        "    if (x) { }\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int x;\n"
                        "    if (1 == (3 & x)) { }\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:19]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         // ?:
         checkUninitVar("int f(int *ptr) {\n"
                        "    int a;\n"
                        "    int *p = ptr ? ptr : &a;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f(int a) {\n"
                        "    int x;\n"
                        "    if (a==3) { x=2; }\n"
                        "    y = (a==3) ? x : a;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // = ({ .. })
         checkUninitVar("void f() {\n"
                        "    int x = ({ 1 + 2; });\n"
                        "    int y = 1 + (x ? y : y);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: y\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:22]: (error) Uninitialized variable: y [legacyUninitvar]\n", errout_str());
 
         // >> => initialization / usage
         {
@@ -2201,18 +2697,18 @@ class TestUninitVar : public TestFixture {
                                 "    int x;\n"
                                 "    if (i >> x) { }\n"
                                 "}";
-            checkUninitVar(code, "test.cpp");
-            ASSERT_EQUALS("", errout.str());
+            checkUninitVar(code);
+            ASSERT_EQUALS("", errout_str());
 
-            checkUninitVar(code, "test.c");
-            ASSERT_EQUALS("[test.c:3]: (error) Uninitialized variable: x\n", errout.str());
+            checkUninitVar(code, dinit(CheckUninitVarOptions, $.cpp = false));
+            ASSERT_EQUALS("[test.c:3:14]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
         }
 
         checkUninitVar("void f() {\n"
                        "    int i, i2;\n"
                        "    strm >> i >> i2;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // unconditional initialization
         checkUninitVar("int f() {\n"
@@ -2221,7 +2717,7 @@ class TestUninitVar : public TestFixture {
                        "    else { {} ret = 2; }\n"
                        "    return ret;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f() {\n"
                        "    int ret;\n"
@@ -2229,7 +2725,7 @@ class TestUninitVar : public TestFixture {
                        "    else { s=foo(1,{2,3},4); ret = 2; }\n"
                        "    return ret;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // conditional initialization
         checkUninitVar("void f() {\n"
@@ -2238,7 +2734,7 @@ class TestUninitVar : public TestFixture {
                        "    else { if (y == 2) { x = 1; } }\n"
                        "    return x;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:12]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int x;\n"
@@ -2247,7 +2743,7 @@ class TestUninitVar : public TestFixture {
                        "    if (y == 3) { }\n"   // <- ignore condition
                        "    return x;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Uninitialized variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:12]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         // initialization in condition
         checkUninitVar("void f() {\n"
@@ -2255,7 +2751,7 @@ class TestUninitVar : public TestFixture {
                        "    if (init(&a)) { }\n"
                        "    a++;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // return, break, continue, goto
         checkUninitVar("void f() {\n"
@@ -2264,14 +2760,14 @@ class TestUninitVar : public TestFixture {
                        "    else { x = 1; }\n"
                        "    return x;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int x;\n"
                        "    if (y == 1) { return; }\n"
                        "    return x;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:12]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int f(int x) {\n"
                        "    int ret;\n"
@@ -2283,8 +2779,8 @@ class TestUninitVar : public TestFixture {
                        "out1:\n"
                        "out2:\n"
                        "    return ret;\n"
-                       "}", "test.c");
-        ASSERT_EQUALS("", errout.str());
+                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int i;\n"
@@ -2295,7 +2791,7 @@ class TestUninitVar : public TestFixture {
                        "    }\n"
                        "    i++;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f() {\n"
                        "    int i,x;\n"
@@ -2303,7 +2799,7 @@ class TestUninitVar : public TestFixture {
                        "        if (foo) break;\n"
                        "    return x;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:12]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int f() {\n"
                        "    int x;\n"
@@ -2311,7 +2807,7 @@ class TestUninitVar : public TestFixture {
                        "        if (bar) break;\n"
                        "    return x;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:12]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         // try/catch : don't warn about exception variable
         checkUninitVar("void f() {\n"
@@ -2321,7 +2817,7 @@ class TestUninitVar : public TestFixture {
                        "        e->Delete();\n"
                        "    }\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n" // #5347
                        "    try {\n"
@@ -2329,7 +2825,7 @@ class TestUninitVar : public TestFixture {
                        "        A a = e;\n"
                        "    }\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // exit
         checkUninitVar("void f() {\n"
@@ -2338,14 +2834,14 @@ class TestUninitVar : public TestFixture {
                        "    else { x = 1; }\n"
                        "    return x;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // strange code.. don't crash (#3415)
         checkUninitVar("void foo() {\n"
                        "    int i;\n"
                        "    ({ if (0); });\n"
                        "    for_each(i) { }\n"
-                       "}", "test.c", false);
+                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
 
         // if, if
         checkUninitVar("void f(int a) {\n"
@@ -2353,7 +2849,7 @@ class TestUninitVar : public TestFixture {
                        "    if (a) i = 0;\n"
                        "    if (a) i++;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int a,b=0;\n"
@@ -2365,7 +2861,7 @@ class TestUninitVar : public TestFixture {
                        "    }\n"
                        "    if (b) a++;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int a=0, b;\n"
@@ -2373,41 +2869,41 @@ class TestUninitVar : public TestFixture {
                        "    else { if (y==2) { a=1; b=2; } }\n"
                        "    if (a) { ++b; }\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("static void f(int x, int y) {\n"
                        "    int a;\n"
                        "    if (x == 0) { a = y; }\n"
                        "    if (x == 0 && (a == 1)) { }\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("static void f() {\n"
                        "    int a=0, b;\n"
                        "    if (something) { a = dostuff(&b); }\n"
                        "    if (!a || b) { }\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("static void f(int x, int y) {\n"
                        "    int a;\n"
                        "    if (x == 0 && (a == 1)) { }\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: a\n", errout.str());
+                       "}");
+        ASSERT_EQUALS("[test.cpp:3:20]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int a;\n"
                        "    if (x) { a = 0; }\n"
                        "    if (x) { if (y) { a++; } }\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int a;\n"
                        "    if (x) { a = 0; }\n"
                        "    if (x) { if (y) { } else { a++; } }\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("struct AB { int a; int b; };\n"
                        "void f(void) {\n"
@@ -2415,8 +2911,8 @@ class TestUninitVar : public TestFixture {
                        "    if (x) ab = getAB();\n"
                        "    else ab.a = 0;\n"
                        "    if (ab.a == 1) b = ab.b;\n"
-                       "}", "test.c");
-        ASSERT_EQUALS("", errout.str());
+                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f(void) {\n"
                        "    int a;\n"
@@ -2427,7 +2923,7 @@ class TestUninitVar : public TestFixture {
                        "    else { a = 1; }\n"
                        "    return a;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f(int a) {\n" // #4560
                        "    int x = 0, y;\n"
@@ -2437,7 +2933,7 @@ class TestUninitVar : public TestFixture {
                        "    else {}\n"
                        "    return y;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f(int a) {\n" // #6583
                        "    int x;\n"
@@ -2446,7 +2942,7 @@ class TestUninitVar : public TestFixture {
                        "    else exit(2);\n"
                        "    return x;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f(int a) {\n" // #4560
                        "    int x = 1, y;\n"
@@ -2456,7 +2952,7 @@ class TestUninitVar : public TestFixture {
                        "    else y = 123;\n" // <- y is always initialized
                        "    return y;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(int x) {\n" // #3948
                        "  int value;\n"
@@ -2464,7 +2960,20 @@ class TestUninitVar : public TestFixture {
                        "    value = getvalue();\n"
                        "  if (x == -1 || value > 300) {}\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("enum t_err { ERR_NONE, ERR_BAD_ARGS };\n" // #9649
+                       "struct box_t { int value; };\n"
+                       "int init_box(box_t *p, int v);\n"
+                       "\n"
+                       "void foo(int ret) {\n"
+                       "    box_t box2;\n"
+                       "    if (ret == ERR_NONE)\n"
+                       "        ret = init_box(&box2, 20);\n"
+                       "    if (ret == ERR_NONE)\n"
+                       "        z = x + box2.value;\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(int x) {\n"
                        "  int value;\n"
@@ -2473,7 +2982,7 @@ class TestUninitVar : public TestFixture {
                        "  if (x == 1)\n"
                        "    v = value;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Uninitialized variable: value\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:9]: (error) Uninitialized variable: value [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f(int x) {\n"
                        "  int value;\n"
@@ -2482,7 +2991,7 @@ class TestUninitVar : public TestFixture {
                        "  if (x == 32) {}\n"
                        "  else v = value;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Uninitialized variable: value\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:12]: (error) Uninitialized variable: value [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("static int x;" // #4773
                        "int f() {\n"
@@ -2492,7 +3001,7 @@ class TestUninitVar : public TestFixture {
                        "    else y = 456;\n"
                        "    return y;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("static int x;" // #4773
                        "int f() {\n"
@@ -2502,7 +3011,7 @@ class TestUninitVar : public TestFixture {
                        "    else y = 456;\n"
                        "    return y;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(int a) {\n"
                        "  int x;\n"
@@ -2512,7 +3021,7 @@ class TestUninitVar : public TestFixture {
                        "    else if (x) {}\n"
                        "  }\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // asm
         checkUninitVar("void f() {\n"
@@ -2520,74 +3029,74 @@ class TestUninitVar : public TestFixture {
                        "    asm();\n"
                        "    x++;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // sizeof / typeof / offsetof / etc
         checkUninitVar("void f() {\n"
                        "    int i;\n"
                        "    sizeof(i+1);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int i;\n"
                        "    if (100 == sizeof(i+1));\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    struct ABC *abc;\n"
                        "    int i = ARRAY_SIZE(abc.a);"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        TODO_ASSERT_EQUALS("", "[test.cpp:3:24]: (error) Uninitialized variable: abc [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int *abc;\n"
                        "    typeof(*abc);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    struct ABC *abc;\n"
                        "    return do_something(typeof(*abc));\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    A *a;\n"
                        "    a = malloc(sizeof(*a));\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // &
         checkUninitVar("void f() {\n"  // #4426 - address of uninitialized variable
                        "    int a,b;\n"
                        "    if (&a == &b);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"  // #4439 - cast address of uninitialized variable
                        "    int a;\n"
                        "    x((LPARAM)(RECT*)&a);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int main() {\n"
                        "    int done;\n"
                        "    dostuff(1, (AuPointer) &done);\n" // <- It is not conclusive if the "&" is a binary or unary operator. Bailout.
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n" // #4778 - cast address of uninitialized variable
                        "    long a;\n"
                        "    &a;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n" // #4717 - ({})
                        "    int a = ({ long b = (long)(123); 2 + b; });\n"
-                       "}", "test.c");
-        ASSERT_EQUALS("", errout.str());
+                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
     }
 
     // #3869 - reference variable
@@ -2598,7 +3107,7 @@ class TestUninitVar : public TestFixture {
                        "    buf[0] = 0;\n"
                        "    x++;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // #3861
@@ -2608,21 +3117,30 @@ class TestUninitVar : public TestFixture {
                        "    x<char> c;\n"
                        "    c << 2345;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ensure there is no false negative
         checkUninitVar("void f() {\n"
                        "    char c;\n"
                        "    char a = c << 2;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: c\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:14]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());
+    }
 
-        // #4320
-        checkUninitVar("void f() {\n"
-                       "    int a;\n"
-                       "    a << 1;\n"  // there might be a operator<<
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+    // #13227
+    void uninitvar6() {
+        checkUninitVar("int foo(int x) {\n"
+                       "    int i;\n"
+                       "    if (x == 1) {\n"
+                       "        i = 3;\n"
+                       "    } else {\n"
+                       "        do {\n"
+                       "            return 2;\n"
+                       "        } while (0);\n"
+                       "    }\n"
+                       "    return i;\n"
+                       "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitvar8() {
@@ -2636,8 +3154,8 @@ class TestUninitVar : public TestFixture {
                             "    int syncpos, len;\n"
                             "    Sync(syncpos, type, len);\n"
                             "}";
-        checkUninitVar(code, "test.cpp");
-        ASSERT_EQUALS("", errout.str());
+        checkUninitVar(code);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitvar9() { // 6424
@@ -2645,9 +3163,78 @@ class TestUninitVar : public TestFixture {
                             "void f1() { char *p; *p = 0; }\n"
                             "class Ns::C* p;\n"
                             "void f2() { char *p; *p = 0; }";
-        checkUninitVar(code, "test.cpp");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Uninitialized variable: p\n"
-                      "[test.cpp:4]: (error) Uninitialized variable: p\n", errout.str());
+        checkUninitVar(code);
+        ASSERT_EQUALS("[test.cpp:2:23]: (error) Uninitialized variable: p [legacyUninitvar]\n"
+                      "[test.cpp:4:23]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
+    }
+
+    void uninitvar10() { // 9467
+        const char code[] = "class Foo {\n"
+                            "    template <unsigned int i>\n"
+                            "    bool bar() {\n"
+                            "        return true;\n"
+                            "    }\n"
+                            "};\n"
+                            "template <>\n"
+                            "bool Foo::bar<9>() {\n"
+                            "    return true;\n"
+                            "}\n"
+                            "int global() {\n"
+                            "    int bar = 1;\n"
+                            "    return bar;\n"
+                            "}";
+        checkUninitVar(code);
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void uninitvar11() { // 9123
+        const char code[] = "bool get(int &var);\n"
+                            "void foo () {\n"
+                            "    int x;\n"
+                            "    x = get(x) && x;\n"
+                            "}";
+        checkUninitVar(code);
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void uninitvar12() { // 10218
+        const char code[] = "void fp() {\n"
+                            "  std::stringstream ss;\n"
+                            "  for (int i; ss >> i;) {}\n"
+                            "}";
+        checkUninitVar(code);
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void uninitvar13() { // #9772 - FP
+        const char code[] = "int func(void)\n"
+                            "{ int rez;\n"
+                            "  struct sccb* ccb;\n"
+                            " \n"
+                            "  do\n"
+                            "  { if ((ccb = calloc(1, sizeof(*ccb))) == NULL)\n"
+                            "    { rez = 1;\n"
+                            "      break;\n"
+                            "    }\n"
+                            "    rez = 0;\n"
+                            "  } while (0);\n"
+                            " \n"
+                            "  if (rez != 0)\n"
+                            "    free(ccb);\n"
+                            " \n"
+                            "  return rez;\n"
+                            "}";
+        checkUninitVar(code);
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void uninitvar14() { // #11832
+        const char code[] = "void f() {\n"
+                            "    int b;\n"
+                            "    *(&b) = 0;\n"
+                            "}";
+        checkUninitVar(code);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitvar_unconditionalTry() {
@@ -2658,7 +3245,7 @@ class TestUninitVar : public TestFixture {
                        "        return i;\n"
                        "    }\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:16]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("int f() {\n"
                        "    int i;\n"
@@ -2666,29 +3253,62 @@ class TestUninitVar : public TestFixture {
                        "        return i;\n"
                        "    } catch(...) {}\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:16]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
+
+        checkUninitVar("void f(bool x) {\n"
+                       "    bool b;\n"
+                       "    {\n"
+                       "        auto g = []{};\n"
+                       "        b = x;\n"
+                       "    }\n"
+                       "    if (b) {}\n"
+                       "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void f(bool x) {\n"
+                       "    bool b;\n"
+                       "    {\n"
+                       "        int i[2]{ 1, 2 };\n"
+                       "        b = x;\n"
+                       "    }\n"
+                       "    if (b) {}\n"
+                       "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void f(bool x) {\n"
+                       "    bool b;\n"
+                       "    {\n"
+                       "        auto g = []{};\n"
+                       "    }\n"
+                       "    if (b) {}\n"
+                       "}\n");
+        ASSERT_EQUALS("[test.cpp:6:9]: (error) Uninitialized variable: b [legacyUninitvar]\n", errout_str());
     }
 
     void uninitvar_funcptr() {
+        // extracttests.disable
+
         checkUninitVar("void getLibraryContainer() {\n"
                        "    Reference< XStorageBasedLibraryContainer >(*Factory)(const Reference< XComponentContext >&, const Reference< XStorageBasedDocument >&)\n"
                        "        = &DocumentDialogLibraryContainer::create;\n"
                        "    rxContainer.set((*Factory)(m_aContext, xDocument));\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void foo() {\n"
                        "    void* x;\n"
                        "    int (*f)(int, int) = x;\n"
                        "    dostuff((*f)(a,b));\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:26]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void getLibraryContainer() {\n"
                        "    Reference< XStorageBasedLibraryContainer >(*Factory)(const Reference< XComponentContext >&, const Reference< XStorageBasedDocument >&);\n"
                        "    rxContainer.set((*Factory)(m_aContext, xDocument));\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: Factory\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:23]: (error) Uninitialized variable: Factory [legacyUninitvar]\n", errout_str());
+
+        // extracttests.enable
     }
 
     void uninitvar_operator() { // Ticket #6463, #6680
@@ -2706,60 +3326,71 @@ class TestUninitVar : public TestFixture {
                        "  int n;\n"
                        "  foo >> s2.v >> n;\n" // Initialized by operator>>
                        "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Uninitialized struct member: s.v\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:16]: (error) Uninitialized struct member: s.v [uninitStructMember]\n", errout_str());
 
         checkUninitVar("struct Fred { int a; };\n"
                        "void foo() {\n"
                        "  Fred fred;\n"
                        "  std::cin >> fred.a;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // Handling of function calls
     void uninitvar2_func() {
+        // #4716
+        checkUninitVar("void bar(const int a, const int * const b);\n"
+                       "int foo(void) {\n"
+                       "   int a;\n"
+                       "   int *b = 0;\n"
+                       "   bar(a,b);\n" // <<
+                       "   return 0;\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:5:8]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
+
         // non-pointer variable
         checkUninitVar("void a(char);\n"  // value => error
                        "void b() {\n"
                        "    char c;\n"
                        "    a(c);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: c\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void a(char c);\n"  // value => error
                        "void b() {\n"
                        "    char c;\n"
                        "    a(c);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: c\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void a(const char c);\n"  // const value => error
                        "void b() {\n"
                        "    char c;\n"
                        "    a(c);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: c\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void a(char *c);\n"  // address => no error
                        "void b() {\n"
                        "    char c;\n"
                        "    a(&c);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void a(pstr s);\n"  // address => no error
                        "void b() {\n"
                        "    char c;\n"
                        "    a(&c);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("void a(const char *c);\n"  // const address => error
+        checkUninitVar("void a(const char *c);\n"  // const address => data is not changed
                        "void b() {\n"
                        "    char c;\n"
-                       "    a(&c);\n"
+                       "    a(&c);\n"  // <- no warning
+                       "    c++;\n"  // <- uninitialized variable
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: c\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: c\n", "", errout_str());
 
         // pointer variable
         checkUninitVar("void a(char c);\n"  // value => error
@@ -2767,14 +3398,7 @@ class TestUninitVar : public TestFixture {
                        "    char *c;\n"
                        "    a(*c);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: c\n", errout.str());
-
-        checkUninitVar("void a(const char c);\n"  // const value => error
-                       "void b() {\n"
-                       "    char c;\n"
-                       "    a(*c);\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: c\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:8]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());
 
 
         checkUninitVar("void a(char *c);\n"  // address => error
@@ -2782,7 +3406,7 @@ class TestUninitVar : public TestFixture {
                        "    char *c;\n"
                        "    a(c);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: c\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("typedef struct { int a; int b; } AB;\n"
                        "void a(AB *ab);\n"
@@ -2790,42 +3414,42 @@ class TestUninitVar : public TestFixture {
                        "    AB *ab;\n"
                        "    a(ab);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: ab\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:7]: (error) Uninitialized variable: ab [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void a(const char *c);\n"  // const address => error
                        "void b() {\n"
                        "    char *c;\n"
                        "    a(c);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: c\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void a(const char c[]);\n"  // const address => error
                        "void b() {\n"
                        "    char *c;\n"
                        "    a(c);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: c\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: (error) Uninitialized variable: c [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void a(char **c);\n"  // address of pointer => no error
                        "void b() {\n"
                        "    char *c;\n"
                        "    a(&c);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void a(char *c);\n"  // address of pointer (suspicious cast to pointer) => no error
                        "void b() {\n"
                        "    char *c;\n"
                        "    a(&c);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void a(const char **c);\n"  // const address of pointer => no error
                        "void b() {\n"
                        "    const char *c;\n"
                        "    a(&c);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // array
         checkUninitVar("int calc(const int *p, int n);\n"
@@ -2833,14 +3457,14 @@ class TestUninitVar : public TestFixture {
                        "    int x[10];\n"
                        "    calc(x,10);\n"
                        "}");
-        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: x\n",
-                           "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4:14]: (error) Uninitialized variable: x [legacyUninitvar]\n",
+                           "", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int x[10];\n"
                        "    int &x0(*x);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ....
         checkUninitVar("struct ABC { int a; };\n"  // struct initialization
@@ -2850,27 +3474,28 @@ class TestUninitVar : public TestFixture {
                        "    clear(abc);\n"
                        "    return abc.a;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void write_packet() {\n"
                        "    time_t now0;\n"
                        "    time(&now0);\n"
-                       "}", "test.c");
-        ASSERT_EQUALS("", errout.str());
+                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void write_packet() {\n"
                        "    time_t* now0;\n"
                        "    time(now0);\n"
-                       "}", "test.c");
-        ASSERT_EQUALS("[test.c:3]: (error) Uninitialized variable: now0\n", errout.str());
+                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:3:10]: (error) Uninitialized variable: now0 [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void write_packet() {\n"
                        "    char now0;\n"
                        "    strcmp(&now0, sth);\n"
-                       "}", "test.c");
-        ASSERT_EQUALS("[test.c:3]: (error) Uninitialized variable: now0\n", errout.str());
+                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:3:13]: (error) Uninitialized variable: now0 [legacyUninitvar]\n", errout_str());
 
         // #2775 - uninitialized struct pointer in subfunction
+        // extracttests.start: struct Fred {int x;};
         checkUninitVar("void a(struct Fred *fred) {\n"
                        "    fred->x = 0;\n"
                        "}\n"
@@ -2879,7 +3504,7 @@ class TestUninitVar : public TestFixture {
                        "    struct Fred *p;\n"
                        "    a(p);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Uninitialized variable: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:7]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
 
         // #2946 - FP array is initialized in subfunction
         checkUninitVar("void a(char *buf) {\n"
@@ -2890,14 +3515,14 @@ class TestUninitVar : public TestFixture {
                        "    a(buf);\n"
                        "    buf[1] = buf[0];\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // unknown macro
         checkUninitVar("void f() {\n"
                        "  struct listnode *item;\n"
                        "  list_for_each(item, &key_list) {}\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitvar2_value() {
@@ -2908,8 +3533,8 @@ class TestUninitVar : public TestFixture {
                        "        if (y != 0) return;\n"
                        "        i++;\n"
                        "    }\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int i, y;\n"
@@ -2918,8 +3543,8 @@ class TestUninitVar : public TestFixture {
                        "        if (y != 0) return;\n"
                        "        i++;\n"
                        "    }\n"
-                       "}", "test.cpp", false);
-        ASSERT_EQUALS("", errout.str());
+                       "}");
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    int i, y;\n"
@@ -2928,21 +3553,14 @@ class TestUninitVar : public TestFixture {
                        "    if (y != 0) return;\n" // <- condition is always true if i is uninitialized
                        "    i++;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
-
-        checkUninitVar("void f(int x) {\n"
-                       "    int i;\n"
-                       "    if (!x) i = 0;\n"
-                       "    if (!x || i>0) {}\n" // <- error
-                       "}");
-        TODO_ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: i\n", "", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(int x) {\n"
                        "    int i;\n"
                        "    if (x) i = 0;\n"
                        "    if (!x || i>0) {}\n" // <- no error
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(int x) {\n"
                        "    int i;\n"
@@ -2950,7 +3568,7 @@ class TestUninitVar : public TestFixture {
                        "    else i = 0;\n"
                        "    if (x || i>0) {}\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:14]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f(int x) {\n"
                        "    int i;\n"
@@ -2958,7 +3576,7 @@ class TestUninitVar : public TestFixture {
                        "    else i = 0;\n"
                        "    if (x || i>0) {}\n" // <- no error
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f(int x) {\n"
                        "    int y;\n"
@@ -2966,28 +3584,29 @@ class TestUninitVar : public TestFixture {
                        "    if (!x) return 0;\n"
                        "    return y;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
+        // extracttests.start: int y;
         checkUninitVar("int f(int x) {\n" // FP with ?:
                        "    int a;\n"
                        "    if (x)\n"
-                       "        a = p;\n"
+                       "        a = y;\n"
                        "    return x ? 2*a : 0;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("int f(int x) {\n"
                        "    int a;\n"
                        "    if (x)\n"
-                       "        a = p;\n"
+                       "        a = y;\n"
                        "    return y ? 2*a : 3*a;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:14]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
-        checkUninitVar("void f() {\n" // Don't crash
-                       "    int a;\n"
-                       "    dostuff(\"ab\" cd \"ef\", x?a:z);\n" // <- No AST is created for ?:
-                       "}");
+        ASSERT_THROW_INTERNAL(checkUninitVar("void f() {\n" // Don't crash
+                                             "    int a;\n"
+                                             "    dostuff(\"ab\" cd \"ef\", x?a:z);\n" // <- No AST is created for ?
+                                             "}"), UNKNOWN_MACRO);
 
         // Unknown => bail out..
         checkUninitVar("void f(int x) {\n"
@@ -2996,7 +3615,7 @@ class TestUninitVar : public TestFixture {
                        "    if (b(x)) return;\n"
                        "    i++;\n" // <- no error if b(x) is always true when a(x) is false
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(int x) {\n"
                        "    int i;\n"
@@ -3005,7 +3624,7 @@ class TestUninitVar : public TestFixture {
                        "        if (x) i++;\n" // <- no error
                        "    }\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f(int x) {\n"
                        "    int i;\n"
@@ -3014,1451 +3633,4169 @@ class TestUninitVar : public TestFixture {
                        "        i++;\n"
                        "    }\n"
                        "}");
-        TODO_ASSERT_EQUALS("error", "", errout.str());
+        TODO_ASSERT_EQUALS("error", "", errout_str());
     }
 
-    void uninitvar2_structmembers() { // struct members
-        checkUninitVar("struct AB { int a; int b; };\n"
-                       "void f(void) {\n"
-                       "    struct AB ab;\n"
-                       "    int a = ab.a;\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized struct member: ab.a\n", errout.str());
+#define valueFlowUninit(...) valueFlowUninit_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void valueFlowUninit_(const char* file, int line, const char (&code)[size], bool cpp = true)
+    {
+        SimpleTokenizer tokenizer(settings, *this, cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
-        checkUninitVar("struct AB { int a; int b; };\n"
-                       "void f(void) {\n"
-                       "    AB ab;\n"
-                       "    int a = ab.a;\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized struct member: ab.a\n", errout.str());
+        // Check for redundant code..
+        CheckUninitVar checkuninitvar(&tokenizer, &settings, this);
+        (checkuninitvar.valueFlowUninit)();
+    }
 
-        checkUninitVar("struct AB { int a; int b; };\n"
-                       "void f(void) {\n"
-                       "    struct AB ab;\n"
-                       "    ab.a = ab.a + 1;\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized struct member: ab.a\n", errout.str());
+    void uninitvar15() { // #13685
+        const char code[] = "int f() {\n"
+                            "    int x;\n"
+                            "    if (!({ int *p = &x; *p = 1; 1; }))\n"
+                            "        return 0;\n"
+                            "    return x;\n"
+                            "}";
+        valueFlowUninit(code, false);
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        checkUninitVar("struct AB { int a; int b; };\n"
-                       "void do_something(const struct AB ab);\n"
-                       "void f(void) {\n"
-                       "    struct AB ab;\n"
-                       "    ab.a = 0;\n"
-                       "    do_something(ab);\n"
-                       "}\n", "test.c");
-        ASSERT_EQUALS("[test.c:6]: (error) Uninitialized struct member: ab.b\n", errout.str());
+    void valueFlowUninit2_value()
+    {
+        valueFlowUninit("void f() {\n"
+                        "    int i;\n"
+                        "    if (x) {\n"
+                        "        int y = -ENOMEM;\n" // assume constant ENOMEM is nonzero since it's negated
+                        "        if (y != 0) return;\n"
+                        "        i++;\n"
+                        "    }\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("struct AB { int a; int b; };\n" // #4760
-                       "void do_something(int a);\n"
-                       "void f(void) {\n"
-                       "    struct AB ab;\n"
-                       "    do_something(ab.a);\n"
-                       "}\n", "test.c");
-        ASSERT_EQUALS("[test.c:5]: (error) Uninitialized struct member: ab.a\n", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    int i, y;\n"
+                        "    if (x) {\n"
+                        "        y = -ENOMEM;\n" // assume constant ENOMEM is nonzero since it's negated
+                        "        if (y != 0) return;\n"
+                        "        i++;\n"
+                        "    }\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("struct AB { int a; int b; };\n"
-                       "void do_something(const struct AB &ab) { a = ab.a; }\n"
-                       "void f(void) {\n"
-                       "    struct AB ab;\n"
-                       "    ab.a = 0;\n"
-                       "    do_something(ab);\n"
-                       "}\n");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    int i, y;\n"
+                        "    if (x) y = -ENOMEM;\n" // assume constant ENOMEM is nonzero since it's negated
+                        "    else y = get_value(i);\n"
+                        "    if (y != 0) return;\n" // <- condition is always true if i is uninitialized
+                        "    i++;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("struct AB { int a; int b; };\n"
-                       "void f(void) {\n"
-                       "    struct AB ab;\n"
-                       "    int a = ab.a;\n"
-                       "}\n", "test.c");
-        ASSERT_EQUALS("[test.c:4]: (error) Uninitialized struct member: ab.a\n", errout.str());
+        valueFlowUninit("void f(int x) {\n"
+                        "    int i;\n"
+                        "    if (!x) i = 0;\n"
+                        "    if (!x || i>0) {}\n" // <- error
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:4:15]: (warning) Uninitialized variable: i [uninitvar]\n", errout_str());
 
-        checkUninitVar("struct AB { int a; int b; };\n"
-                       "void f(void) {\n"
-                       "    AB ab1;\n"
-                       "    AB ab2 = { ab1.a, 0 };\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized struct member: ab1.a\n", errout.str());
+        valueFlowUninit("void f(int x) {\n"
+                        "    int i;\n"
+                        "    if (x) i = 0;\n"
+                        "    if (!x || i>0) {}\n" // <- no error
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("struct AB { int a; int b; };\n"
-                       "void f(void) {\n"
-                       "    struct AB ab;\n"
-                       "    buf[ab.a] = 0;\n"
-                       "}\n", "test.c");
-        ASSERT_EQUALS("[test.c:4]: (error) Uninitialized struct member: ab.a\n", errout.str());
+        valueFlowUninit("void f(int x) {\n"
+                        "    int i;\n"
+                        "    if (!x) { }\n"
+                        "    else i = 0;\n"
+                        "    if (x || i>0) {}\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:5:14]: (warning) Uninitialized variable: i [uninitvar]\n", errout_str());
 
-        checkUninitVar("struct AB { int a; int b; };\n"
-                       "void f(void) {\n"
-                       "    struct AB ab;\n"
-                       "    ab.a = 1;\n"
-                       "    x = ab;\n"
-                       "}\n", "test.c");
-        ASSERT_EQUALS("[test.c:5]: (error) Uninitialized struct member: ab.b\n", errout.str());
+        valueFlowUninit("void f(int x) {\n"
+                        "    int i;\n"
+                        "    if (x) { }\n"
+                        "    else i = 0;\n"
+                        "    if (x || i>0) {}\n" // <- no error
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("struct AB { int a; int b; };\n"
-                       "void f(void) {\n"
-                       "    struct AB ab;\n"
-                       "    ab.a = 1;\n"
-                       "    x = *(&ab);\n"
-                       "}\n", "test.c");
-        ASSERT_EQUALS("[test.c:5]: (error) Uninitialized struct member: ab.b\n", errout.str());
+        valueFlowUninit("int f(int x) {\n"
+                        "    int y;\n"
+                        "    if (x) y = do_something();\n"
+                        "    if (!x) return 0;\n"
+                        "    return y;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("void f(void) {\n"
-                       "    struct AB ab;\n"
-                       "    int x;\n"
-                       "    ab.a = (addr)&x;\n"
-                       "    dostuff(&ab,0);\n"
-                       "}\n", "test.c");
-        ASSERT_EQUALS("", errout.str());
+        // extracttests.start: int y;
+        valueFlowUninit("int f(int x) {\n" // FP with ?:
+                        "    int a;\n"
+                        "    if (x)\n"
+                        "        a = y;\n"
+                        "    return x ? 2*a : 0;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("class Element {\n"
-                       "    static void f() { }\n"
-                       "};\n"
-                       "void test() {\n"
-                       "    Element *element; element->f();\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: element\n", errout.str());
+        valueFlowUninit("int f(int x, int y) {\n"
+                        "    int a;\n"
+                        "    if (x)\n"
+                        "        a = y;\n"
+                        "    return y ? 2*a : 3*a;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:5:18]: (warning) Uninitialized variable: a [uninitvar]\n", errout_str());
 
-        checkUninitVar("class Element {\n"
-                       "    static void f() { }\n"
-                       "};\n"
-                       "void test() {\n"
-                       "    Element *element; (*element).f();\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: element\n", errout.str());
+        ASSERT_THROW_INTERNAL(valueFlowUninit("void f() {\n" // Don't crash
+                                              "    int a;\n"
+                                              "    dostuff(\"ab\" cd \"ef\", x?a:z);\n" // <- No AST is created for ?
+                                              "}"), UNKNOWN_MACRO);
 
-        checkUninitVar("class Element {\n"
-                       "    static int v;\n"
-                       "};\n"
-                       "void test() {\n"
-                       "    Element *element; element->v;\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: element\n", errout.str());
+        // Unknown => bail out..
+        valueFlowUninit("void f(int x) {\n"
+                        "    int i;\n"
+                        "    if (a(x)) i = 0;\n"
+                        "    if (b(x)) return;\n"
+                        "    i++;\n" // <- no error if b(x) is always true when a(x) is false
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("class Element {\n"
-                       "    static int v;\n"
-                       "};\n"
-                       "void test() {\n"
-                       "    Element *element; (*element).v;\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: element\n", errout.str());
+        valueFlowUninit("void f(int x) {\n"
+                        "    int i;\n"
+                        "    if (x) i = 0;\n"
+                        "    while (condition) {\n"
+                        "        if (x) i++;\n" // <- no error
+                        "    }\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("class Element {\n"
-                       "    void f() { }\n"
-                       "};\n"
-                       "void test() {\n"
-                       "    Element *element; element->f();\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: element\n", errout.str());
+        valueFlowUninit("void f(int x) {\n"
+                        "    int i;\n"
+                        "    if (x) i = 0;\n"
+                        "    while (condition) {\n"
+                        "        i++;\n"
+                        "    }\n"
+                        "}");
+        TODO_ASSERT_EQUALS("error", "", errout_str());
 
-        checkUninitVar("class Element {\n"
-                       "    void f() { }\n"
-                       "};\n"
-                       "void test() {\n"
-                       "    Element *element; (*element).f();\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: element\n", errout.str());
+        valueFlowUninit("void f ( void ){\n" // #9313 - FN
+                        " int *p;\n"
+                        " int a[ 2 ] = { [ 0 ] = *p++, [ 1 ] = 1 };\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:26]: (error) Uninitialized variable: p [uninitvar]\n", errout_str());
+
+        valueFlowUninit("void f(int height) {\n"
+                        "    int a[11];\n"
+                        "    int *p = a;\n"
+                        "    int step = 2;\n"
+                        "    for (int i = 0; i < (height * step); i += step)\n"
+                        "        *p++ = 0;\n"
+                        "    for (int i = 0; i < height; i++)\n"
+                        "        if (a[i]) {}\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void f(void) {\n"
+                        "    char *c;\n"
+                        "    char x;\n"
+                        "    while (true) {\n"
+                        "        c = &x;\n"
+                        "        break;\n"
+                        "    }\n"
+                        "    ++c;\n"
+                        "}", false);
+        ASSERT_EQUALS("", errout_str());
+
+        // #12030
+        valueFlowUninit("int set(int *x);\n"
+                        "void foo(bool a) {\n"
+                        "    bool flag{0};\n"
+                        "    int x;\n"
+                        "    if (!a) {\n"
+                        "        flag = set(&x);\n"
+                        "    }\n"
+                        "    if (!flag || x==3) {}\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("class Element {\n"
-                       "    int v;\n"
-                       "};\n"
-                       "void test() {\n"
-                       "    Element *element; element->v;\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: element\n", errout.str());
+        valueFlowUninit("int set(int *x);\n"
+                        "void foo(bool a) {\n"
+                        "    bool flag{0};\n"
+                        "    int x;\n"
+                        "    if (!a) {\n"
+                        "        flag = set(&x);\n"
+                        "    }\n"
+                        "    if (!flag && x==3) {}\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:8:18]: (warning) Uninitialized variable: x [uninitvar]\n", errout_str());
 
-        checkUninitVar("class Element {\n"
-                       "    int v;\n"
-                       "};\n"
-                       "void test() {\n"
-                       "    Element *element; (*element).v;\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized variable: element\n", errout.str());
+        valueFlowUninit("int do_something();\n" // #11983
+                        "int set_st(int *x);\n"
+                        "int bar();\n"
+                        "void foo() {\n"
+                        "    int x, y;\n"
+                        "    int status = 1;\n"
+                        "    if (bar() == 1) {\n"
+                        "        status = 0;\n"
+                        "    }\n"
+                        "    if (status == 1) {\n"
+                        "        status = set_st(&x);\n"
+                        "    }\n"
+                        "    for (int i = 0; status == 1 && i < x; i++) {\n"
+                        "        if (do_something() == 0) {\n"
+                        "            status = 0;\n"
+                        "        }\n"
+                        "    }\n"
+                        "    if(status == 1 && x > 0){}\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("struct AB { int a; int b; };\n"  // pass struct member by address
-                       "void f(void) {\n"
-                       "    struct AB ab;\n"
-                       "    assign(&ab.a, 0);\n"
-                       "}\n", "test.c");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("int h(bool, bool*);\n" // #11760
+                        "int f(bool t) {\n"
+                        "    int i = 0;\n"
+                        "    bool b;\n"
+                        "    if (t)\n"
+                        "        g();\n"
+                        "    if (i == 0)\n"
+                        "        i = h(t, &b);\n"
+                        "    if (i == 0 && b)\n"
+                        "        i = h(t, &b);\n"
+                        "    if (i == 0 && b)\n"
+                        "        i = h(t, &b);\n"
+                        "    return i;\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
 
-        {
-            const char argDirectionsTestXmlData[] = "<?xml version=\"1.0\"?>\n"
-                                                    "<def>\n"
-                                                    "  <function name=\"uninitvar_funcArgInTest\">\n"
-                                                    "    <arg nr=\"1\" direction=\"in\"/>\n"
-                                                    "  </function>\n"
-                                                    "  <function name=\"uninitvar_funcArgOutTest\">\n"
-                                                    "    <arg nr=\"1\" direction=\"out\"/>\n"
-                                                    "  </function>\n"
-                                                    "</def>";
-
-            ASSERT_EQUALS(true, settings.library.loadxmldata(argDirectionsTestXmlData, sizeof(argDirectionsTestXmlData) / sizeof(argDirectionsTestXmlData[0])));
+    void valueFlowUninit_uninitvar2()
+    {
+        // using uninit var
+        valueFlowUninit("void f() {\n"
+                        "    int x;\n"
+                        "    x++;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
-            checkUninitVar("struct AB { int a; };\n"
-                           "void f(void) {\n"
-                           "    struct AB ab;\n"
-                           "    uninitvar_funcArgInTest(&ab);\n"
-                           "    x = ab;\n"
-                           "}\n", "test.c");
-            ASSERT_EQUALS("[test.c:5]: (error) Uninitialized struct member: ab.a\n", errout.str());
+        // extracttests.start: char str[10];
+        valueFlowUninit("void f() {\n"
+                        "    int x;\n"
+                        "    str[x] = 0;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
-            checkUninitVar("struct AB { int a; };\n"
-                           "void f(void) {\n"
-                           "    struct AB ab;\n"
-                           "    uninitvar_funcArgOutTest(&ab);\n"
-                           "    x = ab;\n"
-                           "}\n", "test.c");
-            ASSERT_EQUALS("", errout.str());
-        }
+        valueFlowUninit("void f() {\n" // #7736
+                        "    int buf[12];\n"
+                        "    printf (\"%d\", buf[0] );\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:19]: (error) Uninitialized variable: buf [uninitvar]\n", errout_str());
 
-        checkUninitVar("struct AB { int a; int b; };\n"
-                       "void do_something(const struct AB ab);\n"
-                       "void f(void) {\n"
-                       "    struct AB ab;\n"
-                       "    ab.a = 0;\n"
-                       "    ab.b = 0;\n"
-                       "    do_something(ab);\n"
-                       "}\n", "test.c");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    int x;\n"
+                        "    int y = x & 3;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
-        {
-            checkUninitVar("struct AB { char a[10]; };\n"
-                           "void f(void) {\n"
-                           "    struct AB ab;\n"
-                           "    strcpy(ab.a, STR);\n"
-                           "}\n", "test.c");
-            ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    int x;\n"
+                        "    int y = 3 & x;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:17]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
-            checkUninitVar("struct AB { unsigned char a[10]; };\n" // #8999 - cast
-                           "void f(void) {\n"
-                           "    struct AB ab;\n"
-                           "    strcpy((char *)ab.a, STR);\n"
-                           "}\n", "test.c");
-            ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    int x;\n"
+                        "    x = 3 + x;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
-            checkUninitVar("struct AB { char a[10]; };\n"
-                           "void f(void) {\n"
-                           "    struct AB ab;\n"
-                           "    strcpy(x, ab.a);\n"
-                           "}\n", "test.c");
-            TODO_ASSERT_EQUALS("[test.c:4]: (error) Uninitialized variable: ab.a\n", "", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    int x;\n"
+                        "    x = x;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
-            checkUninitVar("struct AB { int a; };\n"
-                           "void f(void) {\n"
-                           "    struct AB ab;\n"
-                           "    dosomething(ab.a);\n"
-                           "}\n", "test.c");
-            ASSERT_EQUALS("", errout.str());
-        }
+        // extracttests.start: struct ABC {int a;};
+        valueFlowUninit("void f() {\n"
+                        "    struct ABC *abc;\n"
+                        "    abc->a = 0;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Uninitialized variable: abc [uninitvar]\n", errout_str());
 
-        checkUninitVar("struct AB { int a; int b; };\n"
-                       "void do_something(const struct AB ab);\n"
-                       "void f(void) {\n"
-                       "    struct AB ab;\n"
-                       "    ab = getAB();\n"
-                       "    do_something(ab);\n"
-                       "}\n", "test.c");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("int f() {\n"
+                        "    static int x;\n"
+                        "    return ++x;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        {
-            // #6769 - calling method that might assign struct members
-            checkUninitVar("struct AB { int a; int b; void set(); };\n"
-                           "void f(void) {\n"
-                           "    struct AB ab;\n"
-                           "    ab.set();\n"
-                           "    x = ab;\n"
-                           "}\n");
-            ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("int f() {\n"
+                        "    extern int x;\n"
+                        "    return ++x;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-            checkUninitVar("struct AB { int a; int get() const; };\n"
-                           "void f(void) {\n"
-                           "    struct AB ab;\n"
-                           "    ab.get();\n"
-                           "    x = ab;\n"
-                           "}\n");
-            ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized struct member: ab.a\n", errout.str());
+        valueFlowUninit("void f() {\n" // #3926 - weird cast.
+                        "    int x;\n"
+                        "    *(((char *)&x) + 0) = 0;\n"
+                        "}",
+                        false);
+        ASSERT_EQUALS("", errout_str());
 
-            checkUninitVar("struct AB { int a; void dostuff() {} };\n"
-                           "void f(void) {\n"
-                           "    struct AB ab;\n"
-                           "    ab.dostuff();\n"
-                           "    x = ab;\n"
-                           "}\n");
-            TODO_ASSERT_EQUALS("error", "", errout.str());
-        }
+        valueFlowUninit("void f() {\n" // #4737 - weird cast.
+                        "    int x;\n"
+                        "    do_something(&((char*)&x)[0], 1);\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("struct AB { int a; struct { int b; int c; } s; };\n"
-                       "void do_something(const struct AB ab);\n"
-                       "void f(void) {\n"
-                       "    struct AB ab;\n"
-                       "    ab.a = 1;\n"
-                       "    ab.s.b = 2;\n"
-                       "    ab.s.c = 3;\n"
-                       "    do_something(ab);\n"
-                       "}\n", "test.c");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    int x;\n"
+                        "    char *p = (char*)&x + 1;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("struct conf {\n"
-                       "    char x;\n"
-                       "};\n"
-                       "\n"
-                       "void do_something(struct conf ant_conf);\n"
-                       "\n"
-                       "void f(void) {\n"
-                       "   struct conf c;\n"
-                       "   initdata(&c);\n"
-                       "   do_something(c);\n"
-                       "}\n", "test.c");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    int i;\n"
+                        "    i=f(), i!=2;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("struct PIXEL {\n"
-                       "    union  {\n"
-                       "        struct { unsigned char red,green,blue,alpha; };\n"
-                       "        unsigned int color;\n"
-                       "    };\n"
-                       "};\n"
-                       "\n"
-                       "unsigned char f() {\n"
-                       "    struct PIXEL p1;\n"
-                       "    p1.color = 255;\n"
-                       "    return p1.red;\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        // using uninit var in condition
+        valueFlowUninit("void f(void) {\n"
+                        "    int x;\n"
+                        "    if (x) { }\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
-        checkUninitVar("struct AB { int a; int b; };\n"
-                       "int f() {\n"
-                       "  struct AB *ab;\n"
-                       "  for (i = 1; i < 10; i++) {\n"
-                       "    if (condition && (ab = getab()) != NULL) {\n"
-                       "      a = ab->a;\n"
-                       "    }\n"
-                       "  }\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    int x;\n"
+                        "    if (1 == (3 & x)) { }\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:19]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
-        checkUninitVar("struct AB { int a; int b; };\n"
-                       "int f(int x) {\n"
-                       "  struct AB *ab;\n"
-                       "  if (x == 0) {\n"
-                       "    ab = getab();\n"
-                       "  }\n"
-                       "  if (x == 0 && (ab != NULL || ab->a == 0)) { }\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        // ?:
+        valueFlowUninit("int f(int *ptr) {\n"
+                        "    int a;\n"
+                        "    int *p = ptr ? ptr : &a;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("struct A { int *x; };\n" // declarationId is 0 for "delete"
-                       "void foo(void *info, void*p);\n"
-                       "void bar(void) {\n"
-                       "  struct A *delete = 0;\n"
-                       "  foo( info, NULL );\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("int f(int a) {\n"
+                        "    int x;\n"
+                        "    if (a==3) { x=2; }\n"
+                        "    y = (a==3) ? x : a;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("struct ABC { int a; int b; int c; };\n"
-                       "void foo(int x, const struct ABC *abc);\n"
-                       "void bar(void) {\n"
-                       "  struct ABC abc;\n"
-                       "  foo(123, &abc);\n"
-                       "  return abc.b;\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized struct member: abc.a\n"
-                      "[test.cpp:5]: (error) Uninitialized struct member: abc.b\n"
-                      "[test.cpp:5]: (error) Uninitialized struct member: abc.c\n", errout.str());
+        // = ({ .. })
+        valueFlowUninit("void f() {\n"
+                        "    int x = ({ 1 + 2; });\n"
+                        "    int y = 1 + (x ? y : y);\n"
+                        "}");
+        TODO_ASSERT_EQUALS("[test.cpp:3:14]: (error) Uninitialized variable: y [legacyUninitvar]\n", "", errout_str());
 
-        checkUninitVar("struct ABC { int a; int b; int c; };\n"
-                       "void foo() {\n"
-                       "  struct ABC abc;\n"
-                       "  dostuff((uint32_t *)&abc.a);\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        // >> => initialization / usage
+        {
+            const char code[] = "void f() {\n"
+                                "    int x;\n"
+                                "    if (i >> x) { }\n"
+                                "}";
+            valueFlowUninit(code, true);
+            ASSERT_EQUALS("", errout_str());
 
-        // return
-        checkUninitVar("struct AB { int a; int b; };\n"
-                       "void f(void) {\n"
-                       "    struct AB ab;\n"
-                       "    ab.a = 0;\n"
-                       "    return ab.b;\n"
-                       "}\n", "test.c");
-        ASSERT_EQUALS("[test.c:5]: (error) Uninitialized struct member: ab.b\n", errout.str());
+            valueFlowUninit(code, false);
+            ASSERT_EQUALS("[test.c:3:14]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
+        }
 
-        checkUninitVar("struct AB { int a; int b; };\n"
-                       "void f(void) {\n"
-                       "    struct AB ab;\n"
-                       "    ab.a = 0;\n"
-                       "    return ab.a;\n"
-                       "}\n", "test.c");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    int i, i2;\n"
+                        "    strm >> i >> i2;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        // checkIfForWhileHead
-        checkUninitVar("struct FRED {\n"
-                       "    int a;\n"
-                       "    int b;\n"
-                       "};\n"
-                       "\n"
-                       "void f(void) {\n"
-                       "   struct FRED fred;\n"
-                       "   fred.a = do_something();\n"
-                       "   if (fred.a == 0) { }\n"
-                       "}\n", "test.c");
-        ASSERT_EQUALS("", errout.str());
+        // unconditional initialization
+        valueFlowUninit("int f() {\n"
+                        "    int ret;\n"
+                        "    if (a) { ret = 1; }\n"
+                        "    else { {} ret = 2; }\n"
+                        "    return ret;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("struct FRED {\n"
-                       "    int a;\n"
-                       "    int b;\n"
-                       "};\n"
-                       "\n"
-                       "void f(void) {\n"
-                       "   struct FRED fred;\n"
-                       "   fred.a = do_something();\n"
-                       "   if (fred.b == 0) { }\n"
-                       "}\n", "test.c", false);
-        ASSERT_EQUALS("[test.c:9]: (error) Uninitialized struct member: fred.b\n", errout.str());
+        valueFlowUninit("int f() {\n"
+                        "    int ret;\n"
+                        "    if (a) { ret = 1; }\n"
+                        "    else { s=foo(1,{2,3},4); ret = 2; }\n"
+                        "    return ret;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("struct Fred { int a; };\n"
-                       "void f() {\n"
-                       "    struct Fred fred;\n"
-                       "    if (fred.a==1) {}\n"
-                       "}", "test.c");
-        ASSERT_EQUALS("[test.c:4]: (error) Uninitialized struct member: fred.a\n", errout.str());
+        // conditional initialization
+        valueFlowUninit("void f() {\n"
+                        "    int x;\n"
+                        "    if (y == 1) { x = 1; }\n"
+                        "    else { if (y == 2) { x = 1; } }\n"
+                        "    return x;\n"
+                        "}");
+        TODO_ASSERT_EQUALS("[test.cpp:5:12]: (error) Uninitialized variable: x [legacyUninitvar]\n", "", errout_str());
 
-        checkUninitVar("struct S { int n; int m; };\n"
-                       "void f(void) {\n"
-                       " struct S s;\n"
-                       " for (s.n = 0; s.n <= 10; s.n++) { }\n"
-                       "}", "test.c");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    int x;\n"
+                        "    if (y == 1) { x = 1; }\n"
+                        "    else { if (y == 2) { x = 1; } }\n"
+                        "    if (y == 3) { }\n" // <- ignore condition
+                        "    return x;\n"
+                        "}");
+        TODO_ASSERT_EQUALS("[test.cpp:6:24]: (error) Uninitialized variable: x [legacyUninitvar]\n", "", errout_str());
 
-        checkUninitVar("void test2() {\n"
-                       "  struct { char type; } s_d;\n"
-                       "  if (foo(&s_d.type)){}\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        // initialization in condition
+        valueFlowUninit("void f() {\n"
+                        "    int a;\n"
+                        "    if (init(&a)) { }\n"
+                        "    a++;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        // for
-        checkUninitVar("struct AB { int a; };\n"
-                       "void f() {\n"
-                       "    struct AB ab;\n"
-                       "    while (x) { clear(ab); z = ab.a; }\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        // return, break, continue, goto
+        valueFlowUninit("void f() {\n"
+                        "    int x;\n"
+                        "    if (y == 1) { return; }\n"
+                        "    else { x = 1; }\n"
+                        "    return x;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("struct AB { int a; };\n"
-                       "void f() {\n"
-                       "    struct AB ab;\n"
-                       "    while (x) { ab.a = ab.a + 1; }\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized struct member: ab.a\n", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    int x;\n"
+                        "    if (y == 1) { return; }\n"
+                        "    return x;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:4:12]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
-        checkUninitVar("struct AB { int a; };\n"
-                       "void f() {\n"
-                       "    struct AB ab;\n"
-                       "    while (x) { init(&ab); z = ab.a; }\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("int f(int x) {\n"
+                        "    int ret;\n"
+                        "    if (!x) {\n"
+                        "        ret = -123;\n"
+                        "        goto out1;\n"
+                        "    }\n"
+                        "    return 0;\n"
+                        "out1:\n"
+                        "out2:\n"
+                        "    return ret;\n"
+                        "}",
+                        false);
+        ASSERT_EQUALS("", errout_str());
 
-        // address of member
-        checkUninitVar("struct AB { int a[10]; int b; };\n"
-                       "void f() {\n"
-                       "    struct AB ab;\n"
-                       "    int *p = ab.a;\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    int i;\n"
+                        "    if (x) {\n"
+                        "        i = 1;\n"
+                        "    } else {\n"
+                        "        goto out;\n"
+                        "    }\n"
+                        "    i++;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        // non static data-member initialization
-        checkUninitVar("struct AB { int a=1; int b; };\n"
-                       "void f(void) {\n"
-                       "    struct AB ab;\n"
-                       "    int a = ab.a;\n"
-                       "    int b = ab.b;\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized struct member: ab.b\n", errout.str());
+        valueFlowUninit("int f() {\n"
+                        "    int i,x;\n"
+                        "    for (i=0;i<9;++i)\n"
+                        "        if (foo) break;\n"
+                        "    return x;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:5:12]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
-        // STL class member
-        checkUninitVar("struct A {\n"
-                       "    std::map<int, int> m;\n"
-                       "    int i;\n"
-                       "};\n"
-                       "void foo() {\n"
-                       "    A a;\n"
-                       "    x = a.m;\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("int f() {\n"
+                        "    int x;\n"
+                        "    while (foo)\n"
+                        "        if (bar) break;\n"
+                        "    return x;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:5:12]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
-        // Unknown type (C++)
-        checkUninitVar("struct A {\n"
-                       "    C m;\n"
-                       "    int i;\n"
-                       "};\n"
-                       "void foo() {\n"
-                       "    A a;\n"
-                       "    x = a.m;\n"
-                       "}", "test.cpp");
-        ASSERT_EQUALS("", errout.str());
+        // try/catch : don't warn about exception variable
+        valueFlowUninit("void f() {\n"
+                        "    try {\n"
+                        "    } catch (CException* e) {\n"
+                        "        trace();\n"
+                        "        e->Delete();\n"
+                        "    }\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        // Unknown type (C)
-        checkUninitVar("struct A {\n"
-                       "    C m;\n"
-                       "    int i;\n"
-                       "};\n"
-                       "void foo() {\n"
-                       "    A a;\n"
-                       "    x = a.m;\n"
-                       "}", "test.c");
-        ASSERT_EQUALS("[test.c:7]: (error) Uninitialized struct member: a.m\n", errout.str());
+        valueFlowUninit("void f() {\n" // #5347
+                        "    try {\n"
+                        "    } catch (const char* e) {\n"
+                        "        A a = e;\n"
+                        "    }\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        // Type with constructor
-        checkUninitVar("class C { C(); }\n"
-                       "struct A {\n"
-                       "    C m;\n"
-                       "    int i;\n"
-                       "};\n"
-                       "void foo() {\n"
-                       "    A a;\n"
-                       "    x = a.m;\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
-    }
+        // exit
+        valueFlowUninit("void f() {\n"
+                        "    int x;\n"
+                        "    if (y == 1) { exit(0); }\n"
+                        "    else { x = 1; }\n"
+                        "    return x;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-    void uninitvar2_while() {
-        // for, while
-        checkUninitVar("void f() {\n"
-                       "    int x;\n"
-                       "    while (a) {\n"
-                       "        x = x + 1;\n"
-                       "    }\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: x\n", errout.str());
+        // strange code.. don't crash (#3415)
+        valueFlowUninit("void foo() {\n"
+                        "    int i;\n"
+                        "    ({ if (0); });\n"
+                        "    for_each(i) { }\n"
+                        "}",
+                        false);
 
-        checkUninitVar("void f() {\n"
-                       "    int x;\n"
-                       "    do {\n"
-                       "        x = x + 1;\n"
-                       "    } while (a);\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: x\n", errout.str());
+        // if, if
+        valueFlowUninit("void f(int a) {\n"
+                        "    int i;\n"
+                        "    if (a) i = 0;\n"
+                        "    if (a) i++;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("void f() {\n"
-                       "    for (int x = x; x < 10; x++) {}\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Uninitialized variable: x\n", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    int a,b=0;\n"
+                        "    if (x) {\n"
+                        "        if (y) {\n"
+                        "            a = 0;\n"
+                        "            b = 1;\n"
+                        "        }\n"
+                        "    }\n"
+                        "    if (b) a++;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("void f() {\n"
-                       "    for (Element *ptr3 = ptr3->Next(); ptr3; ptr3 = ptr3->Next()) {}\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Uninitialized variable: ptr3\n", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    int a=0, b;\n"
+                        "    if (x) { }\n"
+                        "    else { if (y==2) { a=1; b=2; } }\n"
+                        "    if (a) { ++b; }\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("void f() {\n"
-                       "    int x;\n"
-                       "    while (a) {\n"
-                       "        init(&x);\n"
-                       "        x++;\n"
-                       "    }\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("static void f(int x, int y) {\n"
+                        "    int a;\n"
+                        "    if (x == 0) { a = y; }\n"
+                        "    if (x == 0 && (a == 1)) { }\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("void f() {\n"
-                       "    int x;\n"
-                       "    while (a) {\n"
-                       "        if (b) x++;\n"
-                       "        else x = 0;\n"
-                       "    }\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("static void f() {\n"
+                        "    int a=0, b;\n"
+                        "    if (something) { a = dostuff(&b); }\n"
+                        "    if (!a || b) { }\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("void f() {\n"
-                       "    int x;\n"
-                       "    for (int i = 0; i < 10; i += x) {\n"
-                       "        x = y;\n"
-                       "    }\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("static void f(int x, int y) {\n"
+                        "    int a;\n"
+                        "    if (x == 0 && (a == 1)) { }\n"
+                        "}",
+                        true);
+        ASSERT_EQUALS("[test.cpp:3:20]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
 
-        checkUninitVar("void f() {\n"
-                       "    int x;\n"
-                       "    for (int i = 0; i < 10; i += x) { }\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: x\n", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    int a;\n"
+                        "    if (x) { a = 0; }\n"
+                        "    if (x) { if (y) { a++; } }\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("int f() {\n"
-                       "    int i;\n"
-                       "    for (i=0;i<9;++i)\n"
-                       "        if (foo()) return i;\n"
-                       "    return 9;\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    int a;\n"
+                        "    if (x) { a = 0; }\n"
+                        "    if (x) { if (y) { } else { a++; } }\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("void f() {\n"
-                       "    int i;\n"
-                       "    do {} while (!getvalue(&i));\n"
-                       "    i++;\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("struct AB { int a; int b; };\n"
+                        "void f(void) {\n"
+                        "    struct AB ab;\n"
+                        "    if (x) ab = getAB();\n"
+                        "    else ab.a = 0;\n"
+                        "    if (ab.a == 1) b = ab.b;\n"
+                        "}",
+                        false);
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("int f(void) {\n"
+                        "    int a;\n"
+                        "    int i;\n"
+                        "    if (x) { noreturn(); }\n"
+                        "    else { i = 0; }\n"
+                        "    if (i==1) { a = 0; }\n"
+                        "    else { a = 1; }\n"
+                        "    return a;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("int f(int a) {\n" // #4560
+                        "    int x = 0, y;\n"
+                        "    if (a) x = 1;\n"
+                        "    else return 0;\n"
+                        "    if (x) y = 123;\n" // <- y is always initialized
+                        "    else {}\n"
+                        "    return y;\n"
+                        "}");
+        TODO_ASSERT_EQUALS("", "[test.cpp:5:9] -> [test.cpp:7:12]: (warning) Uninitialized variable: y [uninitvar]\n", errout_str());
 
-        checkUninitVar("int f(void) {\n"
-                       "   int x;\n"
-                       "   while (a()) {\n"  // <- condition must always be true or there will be problem
-                       "       if (b()) {\n"
-                       "           x = 1;\n"
-                       "           break;"
-                       "       }\n"
-                       "   }\n"
-                       "   return x;\n"
-                       "}");
-        TODO_ASSERT_EQUALS("error", "", errout.str());
+        valueFlowUninit("int f(int a) {\n" // #6583
+                        "    int x;\n"
+                        "    if (a < 2) exit(1);\n"
+                        "    else if (a == 2) x = 0;\n"
+                        "    else exit(2);\n"
+                        "    return x;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("int f(int a) {\n" // #4560
+                        "    int x = 1, y;\n"
+                        "    if (a) x = 0;\n"
+                        "    else return 0;\n"
+                        "    if (x) {}\n"
+                        "    else y = 123;\n" // <- y is always initialized
+                        "    return y;\n"
+                        "}");
+        TODO_ASSERT_EQUALS("", "[test.cpp:5:9] -> [test.cpp:7:12]: (warning) Uninitialized variable: y [uninitvar]\n", errout_str());
 
-        checkUninitVar("int f(void) {\n"
-                       "   int x;\n"
-                       "   while (a()) {\n"
-                       "       if (b() && (x=1)) {\n"
-                       "           return x;\n"
-                       "       }\n"
-                       "   }\n"
-                       "   return 0;\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("void f(int x) {\n" // #3948
+                        "  int value;\n"
+                        "  if (x !=-1)\n"
+                        "    value = getvalue();\n"
+                        "  if (x == -1 || value > 300) {}\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("void f(void) {\n"
-                       "   int x;\n"
-                       "   for (;;) {\n"
-                       "       int a = x+1;\n"
-                       "       do_something(a);\n"
-                       "   }\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: x\n", errout.str());
+        valueFlowUninit("enum t_err { ERR_NONE, ERR_BAD_ARGS };\n" // #9649
+                        "struct box_t { int value; };\n"
+                        "int init_box(box_t *p, int v);\n"
+                        "\n"
+                        "void foo(int ret) {\n"
+                        "    box_t box2;\n"
+                        "    if (ret == ERR_NONE)\n"
+                        "        ret = init_box(&box2, 20);\n"
+                        "    if (ret == ERR_NONE)\n"
+                        "        z = x + box2.value;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void f(int x) {\n"
+                        "  int value;\n"
+                        "  if (x == 32)\n"
+                        "    value = getvalue();\n"
+                        "  if (x == 1)\n"
+                        "    v = value;\n"
+                        "}");
+        TODO_ASSERT_EQUALS("[test.cpp:6:9]: (error) Uninitialized variable: value [legacyUninitvar]\n", "", errout_str());
+
+        valueFlowUninit("void f(int x) {\n"
+                        "  int value;\n"
+                        "  if (x == 32)\n"
+                        "    value = getvalue();\n"
+                        "  if (x == 32) {}\n"
+                        "  else v = value;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:6:12]: (warning) Uninitialized variable: value [uninitvar]\n", errout_str());
+
+        valueFlowUninit("static int x;" // #4773
+                        "int f() {\n"
+                        "    int y;\n"
+                        "    if (x) g();\n"
+                        "    if (x) y = 123;\n"
+                        "    else y = 456;\n"
+                        "    return y;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("static int x;" // #4773
+                        "int f() {\n"
+                        "    int y;\n"
+                        "    if (!x) g();\n"
+                        "    if (x) y = 123;\n"
+                        "    else y = 456;\n"
+                        "    return y;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("struct AB {int a; int b;};\n"
-                       "void f(void) {\n"
-                       "   struct AB ab;\n"
-                       "   while (true) {\n"
-                       "       int a = 1+ab.a;\n"
-                       "       do_something(a);\n"
-                       "   }\n"
-                       "}\n", "test.c");
-        ASSERT_EQUALS("[test.c:5]: (error) Uninitialized struct member: ab.a\n", errout.str());
+        valueFlowUninit("void f(int a) {\n"
+                        "  int x;\n"
+                        "  if (a) x=123;\n"
+                        "  if (!a) {\n"
+                        "    if (!a) {}\n"
+                        "    else if (x) {}\n"
+                        "  }\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("void f(int i) {\n" // #4569 fp
-                       "    float *buffer;\n"
-                       "    if(i>10) buffer = f;\n"
-                       "    if(i>10) {\n"
-                       "        for (int i=0;i<10;i++)\n"
-                       "            buffer[i] = 0;\n" // <- fp
-                       "    }\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        // asm
+        valueFlowUninit("void f() {\n"
+                        "    int x;\n"
+                        "    asm();\n"
+                        "    x++;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("void f(){\n" // #4519 - fp: inline assembler in loop
-                       "    int x;\n"
-                       "    for (int i = 0; i < 10; i++) {\n"
-                       "        asm(\"foo\");\n"
-                       "        if (x & 0xf1) { }\n"
-                       "    }\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        // sizeof / typeof / offsetof / etc
+        valueFlowUninit("void f() {\n"
+                        "    int i;\n"
+                        "    sizeof(i+1);\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("static void f(void) {\n"
-                       "    struct ABC *abc;\n"
-                       "    for (i = 0; i < 10; i++)\n"
-                       "        x += sizeof(*abc);\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    int i;\n"
+                        "    if (100 == sizeof(i+1));\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("void f(void) {\n" // #4879
-                       "    int i;\n"
-                       "    while (x) {\n"
-                       "        for (i = 0; i < 5; i++)\n"
-                       "            a[i] = b[i];\n"
-                       "    }\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    struct ABC *abc;\n"
+                        "    int i = ARRAY_SIZE(abc.a);"
+                        "}");
+        // FP ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("void f(void) {\n" // #5658
-                       "    struct Foo *foo;\n"
-                       "    while (true) {\n"
-                       "            foo = malloc(sizeof(*foo));\n"
-                       "            foo->x = 0;\n"
-                       "    }\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    int *abc;\n"
+                        "    typeof(*abc);\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("void f(void) {\n"
-                       "  int i;\n"
-                       "  while (x) {\n"
-                       "    for (i=0,y=i;;){}\n"
-                       "  }\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    struct ABC *abc;\n"
+                        "    return do_something(typeof(*abc));\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("int f() {\n"
-                       "  char *p = (char *)malloc(256);\n"
-                       "  while(*p && *p == '_')\n"
-                       "    p++;\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Memory is allocated but not initialized: p\n", errout.str());
+        valueFlowUninit("void f() {\n"
+                        "    A *a;\n"
+                        "    a = malloc(sizeof(*a));\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        // #6646 - init in for loop
-        checkUninitVar("void f() {\n" // No FP
-                       "  for (int i;;i++)\n"
-                       "    dostuff(&i);\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        // &
+        valueFlowUninit("void f() {\n" // #4426 - address of uninitialized variable
+                        "    int a,b;\n"
+                        "    if (&a == &b);\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("void f() {\n" // No FN
-                       "  for (int i;;i++)\n"
-                       "    a=i;\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:2]: (error) Uninitialized variable: i\n", errout.str());
+        valueFlowUninit("void f() {\n" // #4439 - cast address of uninitialized variable
+                        "    int a;\n"
+                        "    x((LPARAM)(RECT*)&a);\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit(
+            "int main() {\n"
+            "    int done;\n"
+            "    dostuff(1, (AuPointer) &done);\n" // <- It is not conclusive if the "&" is a binary or unary operator. Bailout.
+            "}");
+        TODO_ASSERT_EQUALS("", "[test.cpp:3:29]: (error) Uninitialized variable: done [uninitvar]\n", errout_str());
+
+        valueFlowUninit("void f() {\n" // #4778 - cast address of uninitialized variable
+                        "    long a;\n"
+                        "    &a;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void f() {\n" // #4717 - ({})
+                        "    int a = ({ long b = (long)(123); 2 + b; });\n"
+                        "}",
+                        false);
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void uninitvar2_4494() {
-        checkUninitVar("namespace N1 {\n"
-                       "    class Fred {\n"
-                       "    public:\n"
-                       "        static void f1(char *p) { *p = 0; }\n"
-                       "    };\n"
-                       "    void fa(void) { char *p; Fred::f1(p); }\n"
-                       "    void fb(void) { char *p; Fred::f2(p); }\n"
-                       "    void fc(void) { char *p; ::N1::Fred::f1(p); }\n"
-                       "    void fd(void) { char *p; ::N1::Fred::f2(p); }\n"
-                       "}\n"
-                       "namespace N2 {\n"
-                       "    static void f1(char *p) { *p = 0; }\n"
-                       "    void fa(void) { char *p; f1(p); }\n"
-                       "    void fb(void) { char *p; f2(p); }\n"
-                       "    void fc(void) { char *p; N1::Fred::f1(p); }\n"
-                       "    void fd(void) { char *p; N1::Fred::f2(p); }\n"
-                       "    void fe(void) { char *p; ::N1::Fred::f1(p); }\n"
-                       "    void ff(void) { char *p; ::N1::Fred::f2(p); }\n"
-                       "    void fg(void) { char *p; Foo::f1(p); }\n"
-                       "    void fh(void) { char *p; Foo::f2(p); }\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Uninitialized variable: p\n"
-                      "[test.cpp:8]: (error) Uninitialized variable: p\n"
-                      "[test.cpp:13]: (error) Uninitialized variable: p\n"
-                      "[test.cpp:15]: (error) Uninitialized variable: p\n"
-                      "[test.cpp:17]: (error) Uninitialized variable: p\n", errout.str());
+    void valueFlowUninit_functioncall() {
+
+        // #12462 - pointer data is not read
+        valueFlowUninit("struct myst { int a; };\n"
+                        "void bar(const void* p) {}\n"
+                        "void foo() {\n"
+                        "  struct myst item;\n"
+                        "  bar(&item);\n"
+                        "}", false);
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct myst { int a; };\n"
+                        "void bar(const void* p) { a = (p != 0); }\n"
+                        "void foo() {\n"
+                        "  struct myst item;\n"
+                        "  bar(&item);\n"
+                        "  a = item.a;\n" // <- item.a is not initialized
+                        "}", false);
+        ASSERT_EQUALS("[test.c:6:12]: (error) Uninitialized variable: item.a [uninitvar]\n", errout_str());
+
+        valueFlowUninit("struct myst { int a; };\n"
+                        "void bar(struct myst* p) { p->a = 0; }\n"
+                        "void foo() {\n"
+                        "  struct myst item;\n"
+                        "  bar(&item);\n"
+                        "  a = item.a;\n"
+                        "}", false);
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void f(int& r) {}\n" // #12536
+                        "void g() {\n"
+                        "    int i;\n"
+                        "    f(i);\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("class Fred {\n"
-                       "public:\n"
-                       "    void f1(char *p) { *p = 0; }\n"
-                       "};\n"
-                       "Fred fred;\n"
+        valueFlowUninit("int f(int& i, int j, int k) {\n" // #12514
+                        "    if (k)\n"
+                        "        i = 2;\n"
+                        "    return i + j;\n"
+                        "}\n"
+                        "int main() {\n"
+                        "    int i;\n"
+                        "    return f(i, 1, 0);\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:8:14] -> [test.cpp:4:12]: (warning) Uninitialized variable: i [uninitvar]\n", errout_str());
+
+        valueFlowUninit("int f(int& i, int k) {\n"
+                        "    if (k)\n"
+                        "        i = 2;\n"
+                        "    return i;\n"
+                        "}\n"
+                        "int main() {\n"
+                        "    int i;\n"
+                        "    return f(i, 0);\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:8:14] -> [test.cpp:4:12]: (warning) Uninitialized variable: i [uninitvar]\n", errout_str());
+    }
+
+    void uninitStructMember() { // struct members
+        checkUninitVar("struct AB { int a; int b; };\n"
                        "void f(void) {\n"
-                       "    char *p;\n"
-                       "    fred.f1(p);\n"
+                       "    struct AB ab;\n"
+                       "    int a = ab.a;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Uninitialized variable: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n", errout_str());
 
-        checkUninitVar("class Fred {\n"
-                       "public:\n"
-                       "    class Wilma {\n"
-                       "    public:\n"
-                       "        class Barney {\n"
-                       "        public:\n"
-                       "            class Betty {\n"
-                       "            public:\n"
-                       "                void f1(char *p) { *p = 0; }\n"
-                       "            };\n"
-                       "            Betty betty;\n"
-                       "        };\n"
-                       "        Barney barney;\n"
-                       "    };\n"
-                       "    Wilma wilma;\n"
-                       "};\n"
-                       "Fred fred;\n"
+        checkUninitVar("struct AB { int a; int b; };\n"
                        "void f(void) {\n"
-                       "    char *p;\n"
-                       "    fred.wilma.barney.betty.f1(p);\n"
+                       "    AB ab;\n"
+                       "    int a = ab.a;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:20]: (error) Uninitialized variable: p\n", errout.str());
-    }
+        ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n", errout_str());
 
-    void uninitvar2_malloc() {
-        checkUninitVar("int f() {\n"
-                       "    int *p = malloc(40);\n"
-                       "    return *p;\n"
+        checkUninitVar("struct AB { int a; int b; };\n"
+                       "void f(void) {\n"
+                       "    struct AB ab;\n"
+                       "    ab.a = ab.a + 1;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Memory is allocated but not initialized: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:12]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n", errout_str());
 
-        checkUninitVar("int f() {\n"
-                       "    int *p = malloc(40);\n"
-                       "    var = *p;\n"
-                       "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Memory is allocated but not initialized: p\n", errout.str());
+        checkUninitVar("struct AB { int a; int b; };\n"
+                       "void do_something(const struct AB ab);\n"
+                       "void f(void) {\n"
+                       "    struct AB ab;\n"
+                       "    ab.a = 0;\n"
+                       "    do_something(ab);\n"
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:6:18]: (error) Uninitialized struct member: ab.b [uninitStructMember]\n", errout_str());
+
+        checkUninitVar("struct AB { int a; int b; };\n" // #4760
+                       "void do_something(int a);\n"
+                       "void f(void) {\n"
+                       "    struct AB ab;\n"
+                       "    do_something(ab.a);\n"
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:5:18]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n", errout_str());
 
         checkUninitVar("struct AB { int a; int b; };\n"
-                       "int f() {\n"
-                       "    struct AB *ab = malloc(sizeof(struct AB));\n"
-                       "    return ab->a;\n"
+                       "void do_something(const struct AB &ab) { a = ab.a; }\n"
+                       "void f(void) {\n"
+                       "    struct AB ab;\n"
+                       "    ab.a = 0;\n"
+                       "    do_something(ab);\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Memory is allocated but not initialized: ab\n"
-                      "[test.cpp:4]: (error) Uninitialized struct member: ab.a\n",
-                      errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        checkUninitVar("struct t_udf_file {  int dir_left; };\n"
-                       "\n"
-                       "void f() {\n"
-                       "  struct t_udf_file *newf;\n"
-                       "  newf = malloc(sizeof(*newf));\n"
-                       "  if (!newf) return 0;\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        checkUninitVar("struct AB { int a; int b; };\n"
+                       "void f(void) {\n"
+                       "    struct AB ab;\n"
+                       "    int a = ab.a;\n"
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:4:13]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n", errout_str());
 
-        checkUninitVar("void f() {\n"
-                       "    char *s = malloc(100);\n"
-                       "    if (s != NULL) { }\n"
+        checkUninitVar("struct AB { int a; int b; };\n"
+                       "void f(void) {\n"
+                       "    AB ab1;\n"
+                       "    AB ab2 = { ab1.a, 0 };\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:20]: (error) Uninitialized struct member: ab1.a [uninitStructMember]\n", errout_str());
 
-        checkUninitVar("void f() {\n"
-                       "    char *p = malloc(100);\n"
-                       "    p || assert_failed();\n"
+        checkUninitVar("struct AB { int a; int b; };\n"
+                       "void f(void) {\n"
+                       "    struct AB ab;\n"
+                       "    buf[ab.a] = 0;\n"
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:4:9]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n", errout_str());
+
+        checkUninitVar("struct AB { int a; int b; };\n"
+                       "void f(void) {\n"
+                       "    struct AB ab;\n"
+                       "    ab.a = 1;\n"
+                       "    x = ab;\n"
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:5:9]: (error) Uninitialized struct member: ab.b [uninitStructMember]\n", errout_str());
+
+        checkUninitVar("struct AB { int a; int b; };\n"
+                       "void f(void) {\n"
+                       "    struct AB ab;\n"
+                       "    ab.a = 1;\n"
+                       "    x = *(&ab);\n"
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:5:12]: (error) Uninitialized struct member: ab.b [uninitStructMember]\n", errout_str());
+
+        checkUninitVar("void f(void) {\n"
+                       "    struct AB ab;\n"
+                       "    int x;\n"
+                       "    ab.a = (addr)&x;\n"
+                       "    dostuff(&ab,0);\n"
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("struct Element {\n"
+                       "    static void f() { }\n"
+                       "};\n"
+                       "void test() {\n"
+                       "    Element *element; element->f();\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:23]: (error) Uninitialized variable: element [legacyUninitvar]\n", errout_str());
 
-        checkUninitVar("void f() {\n"
-                       "    char *p = malloc(100);\n"
-                       "    x = p;\n"
+        checkUninitVar("struct Element {\n"
+                       "    static void f() { }\n"
+                       "};\n"
+                       "void test() {\n"
+                       "    Element *element; (*element).f();\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:25]: (error) Uninitialized variable: element [legacyUninitvar]\n", errout_str());
 
-        // function parameter (treat it as initialized until malloc is used)
-        checkUninitVar("int f(int *p) {\n"
-                       "    if (*p == 1) {}\n" // no error
-                       "    p = malloc(256);\n"
-                       "    return *p;\n" // error
+        checkUninitVar("struct Element {\n"
+                       "    static int v;\n"
+                       "};\n"
+                       "void test() {\n"
+                       "    Element *element; element->v;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) Memory is allocated but not initialized: p\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:23]: (error) Uninitialized variable: element [legacyUninitvar]\n", errout_str());
 
-        checkUninitVar("struct AB { int a; int b; };\n"
-                       "int f(struct AB *ab) {\n"
-                       "    if (ab->a == 1) {}\n" // no error
-                       "    ab = malloc(sizeof(struct AB));\n"
-                       "    return ab->a;\n" // error
+        checkUninitVar("struct Element {\n"
+                       "    static int v;\n"
+                       "};\n"
+                       "void test() {\n"
+                       "    Element *element; (*element).v;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized struct member: ab.a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:25]: (error) Uninitialized variable: element [legacyUninitvar]\n", errout_str());
 
-        checkUninitVar("struct AB { int a; int b; };\n"
-                       "void do_something(struct AB *ab);\n" // unknown function
-                       "int f() {\n"
-                       "    struct AB *ab = malloc(sizeof(struct AB));\n"
-                       "    do_something(ab);\n"
+        checkUninitVar("struct Element {\n"
+                       "    void f() { }\n"
+                       "};\n"
+                       "void test() {\n"
+                       "    Element *element; element->f();\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:23]: (error) Uninitialized variable: element [legacyUninitvar]\n", errout_str());
 
-        // analysis failed. varid 0.
-        checkUninitVar("void *vlc_custom_create (vlc_object_t *parent, size_t length, const char *typename) {\n"
-                       "  assert (length >= sizeof (vlc_object_t));\n"
+        checkUninitVar("struct Element {\n"
+                       "    void f() { }\n"
+                       "};\n"
+                       "void test() {\n"
+                       "    Element *element; (*element).f();\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
-    }
+        ASSERT_EQUALS("[test.cpp:5:25]: (error) Uninitialized variable: element [legacyUninitvar]\n", errout_str());
 
-    void uninitvar_ternaryexpression() { // #4683
-        checkUninitVar("struct B { int asd; };\n"
-                       "int f() {\n"
-                       "    int a=0;\n"
-                       "    struct B *b;\n"
-                       "    if (x) {\n"
-                       "        a = 1;\n"
-                       "        b = p;\n"
-                       "    }\n"
-                       "    return a ? b->asd : 0;\n"
+        checkUninitVar("struct Element {\n"
+                       "    int v;\n"
+                       "};\n"
+                       "void test() {\n"
+                       "    Element *element; element->v;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
-    }
+        ASSERT_EQUALS("[test.cpp:5:23]: (error) Uninitialized variable: element [legacyUninitvar]\n", errout_str());
 
-    void uninitvar_rangeBasedFor() { // #7078
-        checkUninitVar("void function(Entry& entry) {\n"
-                       "    for (auto* expr : entry.exprs) {\n"
-                       "        expr->operate();\n"
-                       "        expr->operate();\n"
-                       "    }\n"
+        checkUninitVar("struct Element {\n"
+                       "    int v;\n"
+                       "};\n"
+                       "void test() {\n"
+                       "    Element *element; (*element).v;\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
-    }
+        ASSERT_EQUALS("[test.cpp:5:25]: (error) Uninitialized variable: element [legacyUninitvar]\n", errout_str());
 
-    void uninitvar_static() { // #8734
-        checkUninitVar("struct X { "
-                       "  typedef struct { int p; } P_t; "
-                       "  static int arr[]; "
-                       "}; "
-                       "int X::arr[] = {42}; "
-                       "void f() { "
-                       "  std::vector<X::P_t> result; "
-                       "  X::P_t P; "
-                       "  P.p = 0; "
-                       "  result.push_back(P); "
+        checkUninitVar("struct AB { int a; int b; };\n"  // pass struct member by address
+                       "void f(void) {\n"
+                       "    struct AB ab;\n"
+                       "    assign(&ab.a, 0);\n"
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("struct Cstring { char *text; int size, alloc; };\n"
+                       "int maybe();\n"
+                       "void f() {\n"
+                       "    Cstring res;\n"
+                       "    if ( ! maybe() ) return;\n"  // <- fp goes away if this is removed
+                       "    ( ((res).text = (void*)0), ((res).size = (res).alloc = 0) );\n"  // <- fp goes away if parentheses are removed
                        "}");
-        ASSERT_EQUALS("", errout.str());
-    }
+        ASSERT_EQUALS("", errout_str());
+
+        {
+            constexpr char argDirectionsTestXmlData[] = "<?xml version=\"1.0\"?>\n"
+                                                        "<def>\n"
+                                                        "  <function name=\"uninitvar_funcArgInTest\">\n"
+                                                        "    <arg nr=\"1\" direction=\"in\"/>\n"
+                                                        "  </function>\n"
+                                                        "  <function name=\"uninitvar_funcArgOutTest\">\n"
+                                                        "    <arg nr=\"1\" direction=\"out\"/>\n"
+                                                        "  </function>\n"
+                                                        "</def>";
+            const Settings s = settingsBuilder(settings).libraryxml(argDirectionsTestXmlData).build();
+
+            checkUninitVar("struct AB { int a; };\n"
+                           "void f(void) {\n"
+                           "    struct AB ab;\n"
+                           "    uninitvar_funcArgInTest(&ab);\n"
+                           "    x = ab;\n"
+                           "}\n", s, false);
+            ASSERT_EQUALS("[test.c:5:9]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n", errout_str());
+
+            checkUninitVar("struct AB { int a; };\n"
+                           "void f(void) {\n"
+                           "    struct AB ab;\n"
+                           "    uninitvar_funcArgOutTest(&ab);\n"
+                           "    x = ab;\n"
+                           "}\n", s, false);
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        checkUninitVar("struct AB { int a; int b; };\n"
+                       "void do_something(const struct AB ab);\n"
+                       "void f(void) {\n"
+                       "    struct AB ab;\n"
+                       "    ab.a = 0;\n"
+                       "    ab.b = 0;\n"
+                       "    do_something(ab);\n"
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+
+        {
+            checkUninitVar("struct AB { char a[10]; };\n"
+                           "void f(void) {\n"
+                           "    struct AB ab;\n"
+                           "    strcpy(ab.a, STR);\n"
+                           "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+            ASSERT_EQUALS("", errout_str());
+
+            checkUninitVar("struct AB { unsigned char a[10]; };\n" // #8999 - cast
+                           "void f(void) {\n"
+                           "    struct AB ab;\n"
+                           "    strcpy((char *)ab.a, STR);\n"
+                           "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+            ASSERT_EQUALS("", errout_str());
+
+            checkUninitVar("struct AB { char a[10]; };\n"
+                           "void f(void) {\n"
+                           "    struct AB ab;\n"
+                           "    strcpy(x, ab.a);\n"
+                           "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+            TODO_ASSERT_EQUALS("[test.c:4:16]: (error) Uninitialized variable: ab.a [uninitvar]\n", "", errout_str());
+
+            checkUninitVar("struct AB { int a; };\n"
+                           "void f(void) {\n"
+                           "    struct AB ab;\n"
+                           "    dosomething(ab.a);\n"
+                           "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        checkUninitVar("struct AB { int a; int b; };\n"
+                       "void do_something(const struct AB ab);\n"
+                       "void f(void) {\n"
+                       "    struct AB ab;\n"
+                       "    ab = getAB();\n"
+                       "    do_something(ab);\n"
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+
+        {
+            // #6769 - calling method that might assign struct members
+            checkUninitVar("struct AB { int a; int b; void set(); };\n"
+                           "void f(void) {\n"
+                           "    struct AB ab;\n"
+                           "    ab.set();\n"
+                           "    x = ab;\n"
+                           "}");
+            ASSERT_EQUALS("", errout_str());
+
+            checkUninitVar("struct AB { int a; int get() const; };\n"
+                           "void f(void) {\n"
+                           "    struct AB ab;\n"
+                           "    ab.get();\n"
+                           "    x = ab;\n"
+                           "}");
+            ASSERT_EQUALS("[test.cpp:5:9]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n", errout_str());
+
+            checkUninitVar("struct AB { int a; void dostuff() {} };\n"
+                           "void f(void) {\n"
+                           "    struct AB ab;\n"
+                           "    ab.dostuff();\n"
+                           "    x = ab;\n"
+                           "}");
+            TODO_ASSERT_EQUALS("error", "", errout_str());
+        }
+
+        checkUninitVar("struct AB { int a; struct { int b; int c; } s; };\n"
+                       "void do_something(const struct AB ab);\n"
+                       "void f(void) {\n"
+                       "    struct AB ab;\n"
+                       "    ab.a = 1;\n"
+                       "    ab.s.b = 2;\n"
+                       "    ab.s.c = 3;\n"
+                       "    do_something(ab);\n"
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("struct conf {\n"
+                       "    char x;\n"
+                       "};\n"
+                       "\n"
+                       "void do_something(struct conf ant_conf);\n"
+                       "\n"
+                       "void f(void) {\n"
+                       "   struct conf c;\n"
+                       "   initdata(&c);\n"
+                       "   do_something(c);\n"
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("struct PIXEL {\n"
+                       "    union  {\n"
+                       "        struct { unsigned char red,green,blue,alpha; };\n"
+                       "        unsigned int color;\n"
+                       "    };\n"
+                       "};\n"
+                       "\n"
+                       "unsigned char f() {\n"
+                       "    struct PIXEL p1;\n"
+                       "    p1.color = 255;\n"
+                       "    return p1.red;\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("struct AB { int a; int b; };\n"
+                       "int f() {\n"
+                       "  struct AB *ab;\n"
+                       "  for (i = 1; i < 10; i++) {\n"
+                       "    if (condition && (ab = getab()) != NULL) {\n"
+                       "      a = ab->a;\n"
+                       "    }\n"
+                       "  }\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("struct AB { int a; int b; };\n"
+                       "int f(int x) {\n"
+                       "  struct AB *ab;\n"
+                       "  if (x == 0) {\n"
+                       "    ab = getab();\n"
+                       "  }\n"
+                       "  if (x == 0 && (ab != NULL || ab->a == 0)) { }\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("struct A { int *x; };\n" // declarationId is 0 for "delete"
+                       "void foo(void *info, void*p);\n"
+                       "void bar(void) {\n"
+                       "  struct A *delete = 0;\n"
+                       "  foo( info, NULL );\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("struct ABC { int a; int b; int c; };\n"
+                       "void foo(int x, const struct ABC *abc);\n"
+                       "void bar(void) {\n"
+                       "  struct ABC abc;\n"
+                       "  foo(123, &abc);\n"
+                       "  return abc.b;\n"
+                       "}");
+        TODO_ASSERT_EQUALS("[test.cpp:5]: (error) Uninitialized struct member: abc.a\n"
+                           "[test.cpp:5]: (error) Uninitialized struct member: abc.b\n"
+                           "[test.cpp:5]: (error) Uninitialized struct member: abc.c\n",
+                           "[test.cpp:6:10]: (error) Uninitialized struct member: abc.b [uninitStructMember]\n",
+                           errout_str());
+
+        checkUninitVar("struct ABC { int a; int b; int c; };\n"
+                       "void foo() {\n"
+                       "  struct ABC abc;\n"
+                       "  dostuff((uint32_t *)&abc.a);\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void f(void) {\n"
+                       "    struct tm t;\n"
+                       "    t.tm_year = 123;\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // return
+        checkUninitVar("struct AB { int a; int b; };\n"
+                       "void f(void) {\n"
+                       "    struct AB ab;\n"
+                       "    ab.a = 0;\n"
+                       "    return ab.b;\n"
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:5:12]: (error) Uninitialized struct member: ab.b [uninitStructMember]\n", errout_str());
+
+        checkUninitVar("struct AB { int a; int b; };\n"
+                       "void f(void) {\n"
+                       "    struct AB ab;\n"
+                       "    ab.a = 0;\n"
+                       "    return ab.a;\n"
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("struct S { int a; int b; };\n" // #8299
+                       "void f(void) {\n"
+                       "    struct S s;\n"
+                       "    s.a = 0;\n"
+                       "    return s;\n"
+                       "}\n");
+        ASSERT_EQUALS("[test.cpp:5:12]: (error) Uninitialized struct member: s.b [uninitStructMember]\n", errout_str());
+
+        checkUninitVar("struct S { int a; int b; };\n" // #9810
+                       "void f(void) {\n"
+                       "    struct S s;\n"
+                       "    return s.a ? 1 : 2;\n"
+                       "}\n");
+        ASSERT_EQUALS("[test.cpp:4:12]: (error) Uninitialized struct member: s.a [uninitStructMember]\n", errout_str());
+
+        // checkIfForWhileHead
+        checkUninitVar("struct FRED {\n"
+                       "    int a;\n"
+                       "    int b;\n"
+                       "};\n"
+                       "\n"
+                       "void f(void) {\n"
+                       "   struct FRED fred;\n"
+                       "   fred.a = do_something();\n"
+                       "   if (fred.a == 0) { }\n"
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("struct FRED {\n"
+                       "    int a;\n"
+                       "    int b;\n"
+                       "};\n"
+                       "\n"
+                       "void f(void) {\n"
+                       "   struct FRED fred;\n"
+                       "   fred.a = do_something();\n"
+                       "   if (fred.b == 0) { }\n"
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:9:8]: (error) Uninitialized struct member: fred.b [uninitStructMember]\n", errout_str());
+
+        checkUninitVar("struct Fred { int a; };\n"
+                       "void f() {\n"
+                       "    struct Fred fred;\n"
+                       "    if (fred.a==1) {}\n"
+                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:4:9]: (error) Uninitialized struct member: fred.a [uninitStructMember]\n", errout_str());
+
+        checkUninitVar("struct S { int n; int m; };\n"
+                       "void f(void) {\n"
+                       " struct S s;\n"
+                       " for (s.n = 0; s.n <= 10; s.n++) { }\n"
+                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void test2() {\n"
+                       "  struct { char type; } s_d;\n"
+                       "  if (foo(&s_d.type)){}\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // for
+        checkUninitVar("struct AB { int a; };\n"
+                       "void f() {\n"
+                       "    struct AB ab;\n"
+                       "    while (x) { clear(ab); z = ab.a; }\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("struct AB { int a; };\n"
+                       "void f() {\n"
+                       "    struct AB ab;\n"
+                       "    while (x) { ab.a = ab.a + 1; }\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:4:24]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n", errout_str());
+
+        checkUninitVar("struct AB { int a; };\n"
+                       "void f() {\n"
+                       "    struct AB ab;\n"
+                       "    while (x) { init(&ab); z = ab.a; }\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // address of member
+        checkUninitVar("struct AB { int a[10]; int b; };\n"
+                       "void f() {\n"
+                       "    struct AB ab;\n"
+                       "    int *p = ab.a;\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // Reference
+        checkUninitVar("struct A { int x; };\n"
+                       "void foo() {\n"
+                       "  struct A a;\n"
+                       "  int& x = a.x;\n"
+                       "  x = 0;\n"
+                       "  return a.x;\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // non static data-member initialization
+        checkUninitVar("struct AB { int a=1; int b; };\n"
+                       "void f(void) {\n"
+                       "    struct AB ab;\n"
+                       "    int a = ab.a;\n"
+                       "    int b = ab.b;\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:5:13]: (error) Uninitialized struct member: ab.b [uninitStructMember]\n", errout_str());
+
+        // STL class member
+        checkUninitVar("struct A {\n"
+                       "    std::map<int, int> m;\n"
+                       "    int i;\n"
+                       "};\n"
+                       "void foo() {\n"
+                       "    A a;\n"
+                       "    x = a.m;\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // Unknown type (C++)
+        checkUninitVar("struct A {\n"
+                       "    C m;\n"
+                       "    int i;\n"
+                       "};\n"
+                       "void foo() {\n"
+                       "    A a;\n"
+                       "    x = a.m;\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // Unknown type (C)
+        checkUninitVar("struct A {\n"
+                       "    C m;\n"
+                       "    int i;\n"
+                       "};\n"
+                       "void foo() {\n"
+                       "    A a;\n"
+                       "    x = a.m;\n"
+                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:7:9]: (error) Uninitialized struct member: a.m [uninitStructMember]\n", errout_str());
+
+        // Type with constructor
+        checkUninitVar("class C { C(); }\n"
+                       "struct A {\n"
+                       "    C m;\n"
+                       "    int i;\n"
+                       "};\n"
+                       "void foo() {\n"
+                       "    A a;\n"
+                       "    x = a.m;\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11002
+        checkUninitVar("struct S { char *p; int len; };\n"
+                       "void f() {\n"
+                       "    S s;\n"
+                       "    s.p = nullptr;\n"
+                       "    char* q = (s).p;\n"
+                       "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // if with flag
+        checkUninitVar("struct AB { int a; int b; };\n"
+                       "int f(int x) {\n"
+                       "  struct AB ab;\n"
+                       "  int flag = 0;\n"
+                       "  if (x == 0) {\n"
+                       "    flag = dostuff(&ab);\n"
+                       "  }\n"
+                       "  if (flag) {\n"
+                       "    a = ab.a;\n"
+                       "  }\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("struct S { int x; };\n"
+                       "S h() {\n"
+                       "    S s;\n"
+                       "    S& r = s;\n"
+                       "    r.x = 0;\n"
+                       "    return s;\n"
+                       "}\n"
+                       "S i() {\n"
+                       "    S s;\n"
+                       "    S& r{ s };\n"
+                       "    r.x = 0;\n"
+                       "    return s;\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("struct S { int i; };\n" // #12142
+                       "int f() {\n"
+                       "    S s;\n"
+                       "    int S::* p = &S::i;\n"
+                       "    s.*p = 123;\n"
+                       "    return s.i;\n"
+                       "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("struct S { int a; };\n" // #13848
+                       "int f(std::istream& is) {\n"
+                       "    S s;\n"
+                       "    is >> s;\n"
+                       "    return s.a;\n"
+                       "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void uninitvar2_while() {
+        // extracttests.start: int a;
+
+        // for, while
+        checkUninitVar("void f() {\n"
+                       "    int x;\n"
+                       "    while (a) {\n"
+                       "        x = x + 1;\n"
+                       "    }\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
+
+        checkUninitVar("void f() {\n"
+                       "    int x;\n"
+                       "    do {\n"
+                       "        x = x + 1;\n"
+                       "    } while (a);\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:4:13]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
+
+        checkUninitVar("void f() {\n"
+                       "    for (int x = x; x < 10; x++) {}\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:2:18]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
+
+        // extracttests.start: struct Element{Element*Next();};
+        checkUninitVar("void f() {\n"
+                       "    for (Element *ptr3 = ptr3->Next(); ptr3; ptr3 = ptr3->Next()) {}\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:2:26]: (error) Uninitialized variable: ptr3 [legacyUninitvar]\n", errout_str());
+
+        // extracttests.start: int a;
+        checkUninitVar("void f() {\n"
+                       "    int x;\n"
+                       "    while (a) {\n"
+                       "        init(&x);\n"
+                       "        x++;\n"
+                       "    }\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void f() {\n"
+                       "    int x;\n"
+                       "    while (a) {\n"
+                       "        if (b) x++;\n"
+                       "        else x = 0;\n"
+                       "    }\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void f() {\n"
+                       "    int x;\n"
+                       "    for (int i = 0; i < 10; i += x) {\n"
+                       "        x = y;\n"
+                       "    }\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void f() {\n"
+                       "    int x;\n"
+                       "    for (int i = 0; i < 10; i += x) { }\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:3:34]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
+
+        checkUninitVar("int f() {\n"
+                       "    int i;\n"
+                       "    for (i=0;i<9;++i)\n"
+                       "        if (foo()) return i;\n"
+                       "    return 9;\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void f() {\n"
+                       "    int i;\n"
+                       "    do {} while (!getvalue(&i));\n"
+                       "    i++;\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("int f(void) {\n"
+                       "   int x;\n"
+                       "   while (a()) {\n"  // <- condition must always be true or there will be problem
+                       "       if (b()) {\n"
+                       "           x = 1;\n"
+                       "           break;"
+                       "       }\n"
+                       "   }\n"
+                       "   return x;\n"
+                       "}");
+        TODO_ASSERT_EQUALS("error", "", errout_str());
+
+        checkUninitVar("int f(void) {\n"
+                       "   int x;\n"
+                       "   while (a()) {\n"
+                       "       if (b() && (x=1)) {\n"
+                       "           return x;\n"
+                       "       }\n"
+                       "   }\n"
+                       "   return 0;\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // extracttests.start: void do_something(int);
+        checkUninitVar("void f(void) {\n"
+                       "   int x;\n"
+                       "   for (;;) {\n"
+                       "       int a = x+1;\n"
+                       "       do_something(a);\n"
+                       "   }\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:4:16]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
+
+        checkUninitVar("struct AB {int a; int b;};\n"
+                       "void f(void) {\n"
+                       "   struct AB ab;\n"
+                       "   while (true) {\n"
+                       "       int a = 1+ab.a;\n"
+                       "       do_something(a);\n"
+                       "   }\n"
+                       "}\n", dinit(CheckUninitVarOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:5:18]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n", errout_str());
+
+        checkUninitVar("void f(int i) {\n" // #4569 fp
+                       "    float *buffer;\n"
+                       "    if(i>10) buffer = f;\n"
+                       "    if(i>10) {\n"
+                       "        for (int i=0;i<10;i++)\n"
+                       "            buffer[i] = 0;\n" // <- fp
+                       "    }\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void f(){\n" // #4519 - fp: inline assembler in loop
+                       "    int x;\n"
+                       "    for (int i = 0; i < 10; i++) {\n"
+                       "        asm(\"foo\");\n"
+                       "        if (x & 0xf1) { }\n"
+                       "    }\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("static void f(void) {\n"
+                       "    struct ABC *abc;\n"
+                       "    for (i = 0; i < 10; i++)\n"
+                       "        x += sizeof(*abc);\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void f(void) {\n" // #4879
+                       "    int i;\n"
+                       "    while (x) {\n"
+                       "        for (i = 0; i < 5; i++)\n"
+                       "            a[i] = b[i];\n"
+                       "    }\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void f(void) {\n" // #5658
+                       "    struct Foo *foo;\n"
+                       "    while (true) {\n"
+                       "            foo = malloc(sizeof(*foo));\n"
+                       "            foo->x = 0;\n"
+                       "    }\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void f(void) {\n"
+                       "  int i;\n"
+                       "  while (x) {\n"
+                       "    for (i=0,y=i;;){}\n"
+                       "  }\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void f() {\n"
+                       "  char *p = (char *)malloc(256);\n"
+                       "  while(*p && *p == '_')\n"
+                       "    p++;\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:3:9]: (error) Memory is allocated but not initialized: *p [uninitdata]\n", errout_str());
+
+        // #6646 - init in for loop
+        checkUninitVar("void f() {\n" // No FP
+                       "  for (int i;;i++)\n"
+                       "    dostuff(&i);\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // extracttests.start: int a;
+        checkUninitVar("void f() {\n" // No FN
+                       "  for (int i;;i++)\n"
+                       "    a=i;\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:2:15]: (error) Uninitialized variable: i [legacyUninitvar]\n", errout_str());
+
+        checkUninitVar("namespace N {\n" // #7377
+                       "    template<typename T>\n"
+                       "    class C {};\n"
+                       "    using V = class C<void>;\n"
+                       "}\n"
+                       "int f() {\n"
+                       "    int r = 0;\n"
+                       "    for (int x; x < 4; x++)\n"
+                       "        r += x;\n"
+                       "    return r;\n"
+                       "}\n");
+        ASSERT_EQUALS("[test.cpp:8:17]: (error) Uninitialized variable: x [legacyUninitvar]\n", errout_str());
+    }
+
+    void uninitvar2_4494() {
+        checkUninitVar("namespace N1 {\n"
+                       "    class Fred {\n"
+                       "    public:\n"
+                       "        static void f1(char *p) { *p = 0; }\n"
+                       "    };\n"
+                       "    void fa(void) { char *p; Fred::f1(p); }\n"
+                       "    void fb(void) { char *p; Fred::f2(p); }\n"
+                       "    void fc(void) { char *p; ::N1::Fred::f1(p); }\n"
+                       "    void fd(void) { char *p; ::N1::Fred::f2(p); }\n"
+                       "}\n"
+                       "namespace N2 {\n"
+                       "    static void f1(char *p) { *p = 0; }\n"
+                       "    void fa(void) { char *p; f1(p); }\n"
+                       "    void fb(void) { char *p; f2(p); }\n"
+                       "    void fc(void) { char *p; N1::Fred::f1(p); }\n"
+                       "    void fd(void) { char *p; N1::Fred::f2(p); }\n"
+                       "    void fe(void) { char *p; ::N1::Fred::f1(p); }\n"
+                       "    void ff(void) { char *p; ::N1::Fred::f2(p); }\n"
+                       "    void fg(void) { char *p; Foo::f1(p); }\n"
+                       "    void fh(void) { char *p; Foo::f2(p); }\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:6:39]: (error) Uninitialized variable: p [legacyUninitvar]\n"
+                      "[test.cpp:8:45]: (error) Uninitialized variable: p [legacyUninitvar]\n"
+                      "[test.cpp:13:33]: (error) Uninitialized variable: p [legacyUninitvar]\n"
+                      "[test.cpp:15:43]: (error) Uninitialized variable: p [legacyUninitvar]\n"
+                      "[test.cpp:17:45]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
+
+        checkUninitVar("class Fred {\n"
+                       "public:\n"
+                       "    void f1(char *p) { *p = 0; }\n"
+                       "};\n"
+                       "Fred fred;\n"
+                       "void f(void) {\n"
+                       "    char *p;\n"
+                       "    fred.f1(p);\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:8:13]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
+
+        checkUninitVar("class Fred {\n"
+                       "public:\n"
+                       "    class Wilma {\n"
+                       "    public:\n"
+                       "        class Barney {\n"
+                       "        public:\n"
+                       "            class Betty {\n"
+                       "            public:\n"
+                       "                void f1(char *p) { *p = 0; }\n"
+                       "            };\n"
+                       "            Betty betty;\n"
+                       "        };\n"
+                       "        Barney barney;\n"
+                       "    };\n"
+                       "    Wilma wilma;\n"
+                       "};\n"
+                       "Fred fred;\n"
+                       "void f(void) {\n"
+                       "    char *p;\n"
+                       "    fred.wilma.barney.betty.f1(p);\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:20:32]: (error) Uninitialized variable: p [legacyUninitvar]\n", errout_str());
+    }
+
+    void uninitvar2_malloc() {
+        checkUninitVar("int f() {\n"
+                       "    int *p = (int*)malloc(40);\n"
+                       "    return *p;\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:3:13]: (error) Memory is allocated but not initialized: p [uninitdata]\n", errout_str());
+
+        checkUninitVar("void f() {\n"
+                       "    int *p = (int*)malloc(40);\n"
+                       "    int var = *p;\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:3:16]: (error) Memory is allocated but not initialized: p [uninitdata]\n", errout_str());
+
+        checkUninitVar("struct AB { int a; int b; };\n"
+                       "int f() {\n"
+                       "    struct AB *ab = (AB*)malloc(sizeof(struct AB));\n"
+                       "    return ab->a;\n"
+                       "}");
+        ASSERT_EQUALS("[test.cpp:4:12]: (error) Memory is allocated but not initialized: ab [uninitdata]\n"
+                      "[test.cpp:4:12]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n",
+                      errout_str());
+
+        checkUninitVar("struct t_udf_file {  int dir_left; };\n"
+                       "\n"
+                       "void f() {\n"
+                       "  struct t_udf_file *newf;\n"
+                       "  newf = malloc(sizeof(*newf));\n"
+                       "  if (!newf) {};\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void f() {\n"
+                       "    char *s = malloc(100);\n"
+                       "    if (s != NULL) { }\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void f() {\n"
+                       "    char *p = malloc(100);\n"
+                       "    p || assert_failed();\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void f() {\n"
+                       "    char *p = malloc(100);\n"
+                       "    x = p;\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("int* f() {\n"
+                       "    int *p = (int*)malloc(40);\n"
+                       "    return p;\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // function parameter (treat it as initialized until malloc is used)
+        checkUninitVar("int f(int *p) {\n"
+                       "    if (*p == 1) {}\n" // no error
+                       "    p = (int*)malloc(256);\n"
+                       "    return *p;\n" // error
+                       "}");
+        ASSERT_EQUALS("[test.cpp:4:13]: (error) Memory is allocated but not initialized: p [uninitdata]\n", errout_str());
+
+        checkUninitVar("struct AB { int a; int b; };\n"
+                       "int f(struct AB *ab) {\n"
+                       "    if (ab->a == 1) {}\n" // no error
+                       "    ab = (AB*)malloc(sizeof(struct AB));\n"
+                       "    return ab->a;\n" // error
+                       "}");
+        ASSERT_EQUALS("[test.cpp:5:12]: (error) Uninitialized struct member: ab.a [uninitStructMember]\n", errout_str());
+
+        checkUninitVar("struct AB { int a; int b; };\n"
+                       "void do_something(struct AB *ab);\n" // unknown function
+                       "void f() {\n"
+                       "    struct AB *ab = (AB*)malloc(sizeof(struct AB));\n"
+                       "    do_something(ab);\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // analysis failed. varid 0.
+        checkUninitVar("void *vlc_custom_create (vlc_object_t *parent, size_t length, const char *typename) {\n"
+                       "  assert (length >= sizeof (vlc_object_t));\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void uninitvar_ternaryexpression() { // #4683
+        checkUninitVar("struct B { int asd; };\n"
+                       "int f() {\n"
+                       "    int a=0;\n"
+                       "    struct B *b;\n"
+                       "    if (x) {\n"
+                       "        a = 1;\n"
+                       "        b = p;\n"
+                       "    }\n"
+                       "    return a ? b->asd : 0;\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void uninitvar_rangeBasedFor() {
+        checkUninitVar("void function(Entry& entry) {\n" // #7078
+                       "    for (auto* expr : entry.exprs) {\n"
+                       "        expr->operate();\n"
+                       "        expr->operate();\n"
+                       "    }\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void f() {\n"
+                       "    int *item;\n"
+                       "    for (item: itemList) {}\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("void f() {\n"
+                       "    int buf[10];\n"
+                       "    for (int &i: buf) { i = 0; }\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void uninitvar_static() { // #8734
+        checkUninitVar("struct X { "
+                       "  typedef struct { int p; } P_t; "
+                       "  static int arr[]; "
+                       "}; "
+                       "int X::arr[] = {42}; "
+                       "void f() { "
+                       "  std::vector<X::P_t> result; "
+                       "  X::P_t P; "
+                       "  P.p = 0; "
+                       "  result.push_back(P); "
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void uninitvar_configuration() {
+        const Settings s = settingsBuilder(settings).checkLibrary().build();
+
+        checkUninitVar("int f() {\n"
+                       "    int i, j;\n"
+                       "    do {\n"
+                       "        i = 0;\n"
+                       "        return i;\n"
+                       "    } while (0);\n"
+                       "}\n", s);
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void checkExpr() {
+        checkUninitVar("struct AB { int a; int b; };\n"
+                       "void f() {\n"
+                       "    struct AB *ab = (struct AB*)calloc(1, sizeof(*ab));\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void trac_4871() { // #4871
+        checkUninitVar("void pickup(int a) {\n"
+                       "bool using_planner_action;\n"
+                       "if (a)   {\n"
+                       "  using_planner_action = false;\n"
+                       "}\n"
+                       "else {\n"
+                       "  try\n"
+                       "  {}\n"
+                       "  catch (std::exception &ex) {\n"
+                       "    return;\n"
+                       "  }\n"
+                       "  using_planner_action = true;\n"
+                       "}\n"
+                       "if (using_planner_action) {}\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void syntax_error() { // Ticket #5073
+        const char code[] = "struct flex_array {};\n"
+                            "struct cgroup_taskset {};\n"
+                            "void cgroup_attach_task() {\n"
+                            "  struct flex_array *group;\n"
+                            "  struct cgroup_taskset tset = { };\n"
+                            "  do { } while_each_thread(leader, tsk);\n"
+                            "}";
+        ASSERT_THROW_INTERNAL(checkUninitVar(code), SYNTAX);
+    }
+
+    void trac_5970() { // Ticket #5970
+        checkUninitVar("void DES_ede3_ofb64_encrypt() {\n"
+                       "  DES_cblock d;\n"
+                       "  char *dp;\n"
+                       "  dp=(char *)d;\n"
+                       "  init(dp);\n"
+                       "}", dinit(CheckUninitVarOptions, $.cpp = false));
+        // Unknown type
+        TODO_ASSERT_EQUALS("", "[test.c:4:14]: (error) Uninitialized variable: d [legacyUninitvar]\n", errout_str());
+    }
+
+#define ctu(...) ctu_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void ctu_(const char* file, int line, const char (&code)[size]) {
+        // Tokenize..
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+
+        CTU::FileInfo *ctu = CTU::getFileInfo(tokenizer);
+
+        // Check code..
+        std::list<Check::FileInfo*> fileInfo;
+        Check& c = getCheck<CheckUninitVar>();
+        fileInfo.push_back(c.getFileInfo(tokenizer, settings, ""));
+        c.analyseWholeProgram(*ctu, fileInfo, settings, *this); // TODO: check result
+        while (!fileInfo.empty()) {
+            delete fileInfo.back();
+            fileInfo.pop_back();
+        }
+        delete ctu;
+    }
+
+    void valueFlowUninitTest() {
+        // #9735 - FN
+        valueFlowUninit("typedef struct\n"
+                        "{\n"
+                        "    int x;\n"
+                        "    unsigned int flag : 1;\n" // bit filed gets never initialized
+                        "} status;\n"
+                        "bool foo(const status * const s)\n"
+                        "{\n"
+                        "    return s->flag;\n" // << uninitvar
+                        "}\n"
+                        "void bar(const status * const s)\n"
+                        "{\n"
+                        "    if( foo(s) == 1) {;}\n"
+                        "}\n"
+                        "void f(void)\n"
+                        "{\n"
+                        "    status s;\n"
+                        "    s.x = 42;\n"
+                        "    bar(&s);\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:18:9] -> [test.cpp:12:13] -> [test.cpp:8:15]: (warning) Uninitialized variable: s->flag [uninitvar]\n", errout_str());
+
+        // Ticket #2207 - False negative
+        valueFlowUninit("void foo() {\n"
+                        "    int a;\n"
+                        "    b = c - a;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
+
+        valueFlowUninit("void foo() {\n"
+                        "    int a;\n"
+                        "    b = a - c;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
+
+        // Ticket #6455 - some compilers allow const variables to be uninitialized
+        // extracttests.disable
+        valueFlowUninit("void foo() {\n"
+                        "    const int a;\n"
+                        "    b = c - a;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
+        // extracttests.enable
+
+        valueFlowUninit("void foo() {\n"
+                        "    int *p;\n"
+                        "    realloc(p,10);\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:13]: (error) Uninitialized variable: p [uninitvar]\n", errout_str());
+
+        valueFlowUninit("void foo() {\n" // #5240
+                        "    char *p = malloc(100);\n"
+                        "    char *tmp = realloc(p,1000);\n"
+                        "    if (!tmp) free(p);\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void foo() {\n"
+                        "    int *p = NULL;\n"
+                        "    realloc(p,10);\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void f() {\n"
+                        "  int x;\n"
+                        "  switch (x) {}\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:11]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
+
+        valueFlowUninit("int f() {\n"
+                        "  int x;\n"
+                        "  init(x);\n"
+                        "  return x;\n" // TODO: inconclusive ?
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void f() {\n" // #8172
+                        "  char **x;\n"
+                        "  if (2 < sizeof(*x)) {}\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void foo() {\n" // #5259 - False negative
+                        "    int a;\n"
+                        "    int x[] = {a,2};\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:16]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
+
+        valueFlowUninit("void foo()\n"
+                        "{\n"
+                        "    int x;\n"
+                        "    int *y = &x;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void foo()\n"
+                        "{\n"
+                        "    int *x;\n"
+                        "    int *&y = x;\n"
+                        "    y = nullptr;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void foo()\n"
+                        "{\n"
+                        "    int x = xyz::x;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void f()\n"
+                        "{\n"
+                        "    extern int a;\n"
+                        "    a++;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("static void foo()\n"
+                        "{\n"
+                        "    int x, y;\n"
+                        "    x = (y = 10);\n"
+                        "    int z = y * 2;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("static void foo() {\n"
+                        "    int x, y;\n"
+                        "    x = ((y) = 10);\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("static void foo()\n"
+                        "{\n"
+                        "    Foo p;\n"
+                        "    p.abcd();\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("static void foo()\n"
+                        "{\n"
+                        "    Foo p;\n"
+                        "    int x = p.abcd();\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // struct
+        valueFlowUninit("struct AB { int a; int b; };\n"
+                        "void f(void) {\n"
+                        "  AB ab;\n"
+                        "  AB *p = &ab;\n"
+                        "  p->a = 1;\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct S {\n"
+                        "    S& rIo;\n"
+                        "    S(S&);\n"
+                        "    void Write();\n"
+                        "};\n"
+                        "void foo(bool b, struct S &io) {\n"
+                        "    S* p;\n"
+                        "    if (b)\n"
+                        "        p = new S(io);\n"
+                        "    p->Write();\n"
+                        "}");
+        TODO_ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:10]: (warning) Uninitialized variable: p\n",
+                           "[test.cpp:8:9] -> [test.cpp:10:5]: (warning) Uninitialized variable: p.rIo [uninitvar]\n",
+                           errout_str());
+
+        // Unknown types
+        {
+            valueFlowUninit("void a()\n"
+                            "{\n"
+                            "    A ret;\n"
+                            "    return ret;\n"
+                            "}");
+            ASSERT_EQUALS("", errout_str());
+
+            // #3916 - avoid false positive
+            valueFlowUninit("void f(float x) {\n"
+                            "  union lf { long l; float f; } u_lf;\n"
+                            "  float hx = (u_lf.f = (x), u_lf.l);\n"
+                            "}");
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        valueFlowUninit("void a()\n"
+                        "{\n"
+                        "    int x[10];\n"
+                        "    int *y = x;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void a()\n"
+                        "{\n"
+                        "    int x;\n"
+                        "    int *y = &x;\n"
+                        "    *y = 0;\n"
+                        "    x++;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void a()\n"
+                        "{\n"
+                        "    char x[10], y[10];\n"
+                        "    char *z = x;\n"
+                        "    memset(z, 0, sizeof(x));\n"
+                        "    memcpy(y, x, sizeof(x));\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // Handling >> and <<
+        {
+            valueFlowUninit("int a() {\n"
+                            "    int ret;\n"
+                            "    std::cin >> ret;\n"
+                            "    ret++;\n"
+                            "}");
+            ASSERT_EQUALS("", errout_str());
+
+            valueFlowUninit("void f(int b) {\n"
+                            "    int a;\n"
+                            "    std::cin >> b >> a;\n"
+                            "    return a;"
+                            "}");
+            ASSERT_EQUALS("", errout_str());
+
+            valueFlowUninit("void foo() {\n"   // #3707
+                            "    Node node;\n"
+                            "    int x;\n"
+                            "    node[\"abcd\"] >> x;\n"
+                            "}");
+            ASSERT_EQUALS("", errout_str());
+
+            valueFlowUninit("int a(FArchive &arc) {\n"  // #3060 (initialization through operator<<)
+                            "    int *p;\n"
+                            "    arc << p;\n"  // <- TODO initialization?
+                            "    return *p;\n"
+                            "}");
+            ASSERT_EQUALS("[test.cpp:3:12]: (error) Uninitialized variable: p [uninitvar]\n", errout_str());
+
+            // #4320
+            valueFlowUninit("void f() {\n"
+                            "    int a;\n"
+                            "    a << 1;\n"
+                            "    return a;\n"
+                            "}");
+            ASSERT_EQUALS("[test.cpp:3:5]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
+
+            // #9750
+            valueFlowUninit("struct S {\n"
+                            "    int one;\n"
+                            "    int two;\n"
+                            "};\n"
+                            "\n"
+                            "void test(std::istringstream& in) {\n"
+                            "    S p;\n"
+                            "    in >> p.one >> p.two;\n"
+                            "}");
+            ASSERT_EQUALS("", errout_str());
+        }
+
+        valueFlowUninit("struct S { int x; };\n" // #9417
+                        "void f() {\n"
+                        "    S s;\n"
+                        "    return s(1);\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void a() {\n"   // asm
+                        "    int x;\n"
+                        "    asm();\n"
+                        "    x++;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void a()\n"
+                        "{\n"
+                        "    int x[10];\n"
+                        "    struct xyz xyz1 = { .x = x };\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void foo()\n"
+                        "{\n"
+                        "   char *buf = malloc(100);\n"
+                        "   struct ABC *abc = buf;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("class Fred {\n"
+                        "public:\n"
+                        "    FILE *f;\n"
+                        "    ~Fred();\n"
+                        "}\n"
+                        "Fred::~Fred()\n"
+                        "{\n"
+                        "    fclose(f);\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void f()\n"
+                        "{\n"
+                        "    int c;\n"
+                        "    ab(sizeof(xyz), &c);\n"
+                        "    if (c);\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void f()\n"
+                        "{\n"
+                        "    int c;\n"
+                        "    a = (f2(&c));\n"
+                        "    c++;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // goto/setjmp/longjmp..
+        valueFlowUninit("void foo(int x)\n"
+                        "{\n"
+                        "    long b;\n"
+                        "    if (g()) {\n"
+                        "        b =2;\n"
+                        "        goto found;\n"
+                        "    }\n"
+                        "\n"
+                        "    return;\n"
+                        "\n"
+                        "found:\n"
+                        "    int a = b;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("int foo()\n"
+                        "{\n"
+                        "    jmp_buf env;\n"
+                        "    int a;\n"
+                        "    int val = setjmp(env);\n"
+                        "    if(val)\n"
+                        "        return a;\n"
+                        "    a = 1;\n"
+                        "    longjmp(env, 1);\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // range for..
+        valueFlowUninit("void f() {\n"
+                        "    X *item;\n"
+                        "    for (item: itemList) {}\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("X f() {\n"
+                        "    if (!itemList.empty()) {\n"
+                        "        X* item;\n"
+                        "        for(item: itemList) {}\n"
+                        "        return *item;\n"
+                        "    }\n"
+                        "    return X{};\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // macro_for..
+        valueFlowUninit("int foo()\n"
+                        "{\n"
+                        "  int retval;\n"
+                        "  if (condition) {\n"
+                        "    for12(1,2) { }\n"
+                        "    retval = 1;\n"
+                        "  }\n"
+                        "  else\n"
+                        "    retval = 2;\n"
+                        "  return retval;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void foo(struct qb_list_head *list) {\n"
+                        "    struct qb_list_head *iter;\n"
+                        "    qb_list_for_each(iter, list) {}\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void json_parse_nat_type_flags(json_t *root) {\n"
+                        "    int index;\n"
+                        "    json_array_foreach(root, index, value) {}\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("int foo()\n"
+                        "{\n"
+                        "    int i;\n"
+                        "    goto exit;\n"
+                        "    i++;\n"
+                        "exit:\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("int foo() {\n"
+                        "    int x,y=0;\n"
+                        "again:\n"
+                        "    if (y) return x;\n"
+                        "    x = a;\n"
+                        "    y = 1;\n"
+                        "    goto again;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // #4040 - False positive
+        valueFlowUninit("int f(int x)  {\n"
+                        "    int iter;\n"
+                        "    {\n"
+                        "        union\n"
+                        "        {\n"
+                        "            int asInt;\n"
+                        "            double asDouble;\n"
+                        "        };\n"
+                        "\n"
+                        "        iter = x;\n"
+                        "    }\n"
+                        "    return 1 + iter;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // C++11 style initialization
+        valueFlowUninit("int f() {\n"
+                        "    int i = 0;\n"
+                        "    int j{ i };\n"
+                        "    return j;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // Ticket #5646
+        valueFlowUninit("float foo() {\n"
+                        "  float source[2] = {3.1, 3.1};\n"
+                        "  float (*sink)[2] = &source;\n"
+                        "  return (*sink)[0];\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // Ticket #8755
+        valueFlowUninit("void f(int b) {\n"
+                        "    int a;\n"
+                        "    if (b == 10)\n"
+                        "        a = 1;\n"
+                        "    if (b == 13)\n"
+                        "        a = 1;\n"
+                        "    if (b == 'x') {}\n"
+                        "    if (a) {}\n"
+                        "}");
+        TODO_ASSERT_EQUALS("[test.cpp:8]: (error) Uninitialized variable: a\n", "", errout_str());
+
+        valueFlowUninit("void h() {\n"
+                        "  int i;\n"
+                        "  int* v = &i;\n"
+                        "  sscanf(\"0\", \"%d\", v);\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void test(int p) {\n"
+                        "    int f;\n"
+                        "    if (p > 0)\n"
+                        "        f = 0;\n"
+                        "    if (p > 1)\n"
+                        "        f += 1;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("unsigned char get();\n"
+                        "char f() {\n"
+                        "    unsigned char c;\n"
+                        "    do {\n"
+                        "        c = get();\n"
+                        "    } while (isalpha(c) == 0);\n"
+                        "    return static_cast<char>(c);\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void f(int x)\n"
+                        "{\n"
+                        "   int i;\n"
+                        "   char value;\n"
+                        "   for(i = 0; i < 1; i++) {\n"
+                        "       if(x > 1)\n"
+                        "           value = 0;\n"
+                        "    }\n"
+                        "    printf(\"\", value);\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:6:13] -> [test.cpp:9:16]: (warning) Uninitialized variable: value [uninitvar]\n", errout_str());
+
+        valueFlowUninit("void f(int x)\n"
+                        "{\n"
+                        "   int i;\n"
+                        "   char value;\n"
+                        "   for(i = 0; i < 1; i++) {\n"
+                        "       if(x > 1)\n"
+                        "           value = 0;\n"
+                        "       else\n"
+                        "           value = 1;\n"
+                        "    }\n"
+                        "    printf(\"\", value);\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // function pointers
+        valueFlowUninit("int f (const struct FileFuncDefs *ffd) {\n" // #10279
+                        "  int c;\n"
+                        "  (*ffd->zread)(&c, 1);\n"
+                        "  return c;\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("int foo(unsigned int code) {\n" // #10279
+                        "  int res;\n\n"
+                        "  (* (utility_table[code])) (&res);\n"
+                        "  return (res);\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct Archive {\n"
+                        "    bool isNull;\n"
+                        "    friend void operator&(const Archive &, bool &isNull);\n"
+                        "};\n"
+                        "void load(Archive& ar) {\n"
+                        "    bool isNull;\n"
+                        "    ar & isNull;\n"
+                        "    if (!isNull) {}\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10119
+        valueFlowUninit("struct Foo {\n"
+                        "    int i{};\n"
+                        "    static const float cf;\n"
+                        "};\n"
+                        "const float Foo::cf = 0.1f;\n"
+                        "int bar() {\n"
+                        "    Foo f;\n"
+                        "    return f.i;\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10326
+        valueFlowUninit("void foo() {\n"
+                        "    int cnt;\n"
+                        "    do {\n"
+                        "        cnt = 32 ;\n"
+                        "    }\n"
+                        "    while ( 0 ) ;\n"
+                        "    if (cnt != 0) {}\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10327 - avoid extra warnings for uninitialized variable
+        valueFlowUninit("void dowork( int me ) {\n"
+                        "    if ( me == 0 ) {}\n" // <- not uninitialized
+                        "}\n"
+                        "\n"
+                        "int main() {\n"
+                        "    int me;\n"
+                        "     dowork(me);\n" // <- me is uninitialized
+                        "}");
+        ASSERT_EQUALS("[test.cpp:7:13]: (error) Uninitialized variable: me [uninitvar]\n", errout_str());
+
+        valueFlowUninit("int foo() {\n"
+                        "  int x;\n"
+                        "  int a = x;\n" // <- x is uninitialized
+                        "  return a;\n" // <- a has been initialized
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:11]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
+
+        // #10468
+        valueFlowUninit("uint32_t foo(uint32_t in) {\n"
+                        "    uint32_t out, mask = 0x7F;\n"
+                        "    while (mask ^ 0x7FFFFFFF)\n"
+                        "        out = in & ~mask;\n"
+                        "    return out;\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #6597
+        valueFlowUninit("int f(int b) {\n"
+                        "    int a;\n"
+                        "    if (!b)\n"
+                        "        a = 1;\n"
+                        "    if (b)\n"
+                        "        return a;\n"
+                        "    else\n"
+                        "        return -1;\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:3:9] -> [test.cpp:6:16]: (warning) Uninitialized variable: a [uninitvar]\n", errout_str());
+
+        // #9772
+        valueFlowUninit("int func(void) {\n"
+                        "    int rez;\n"
+                        "    struct sccb* ccb;\n"
+                        "    do {\n"
+                        "        if ((ccb = calloc(1, sizeof(*ccb))) == NULL) {\n"
+                        "            rez = 1;\n"
+                        "            break;\n"
+                        "        }\n"
+                        "        rez = 0;\n"
+                        "    } while (0);\n"
+                        "    if (rez != 0)\n"
+                        "        free(ccb);\n"
+                        "    return rez;\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10553
+        valueFlowUninit("struct CharDataOnly {\n"
+                        "   char data[100];\n"
+                        "};\n"
+                        "CharDataOnly f() {\n"
+                        "   CharDataOnly testData;\n"
+                        "   strcpy(testData.data, \"string smaller than size\");\n"
+                        "   return testData;\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10089
+        valueFlowUninit("typedef union {\n"
+                        "    struct { int x; };\n"
+                        "    int v[1];\n"
+                        "} U;\n"
+                        "void init(int* d) {\n"
+                        "    *d = 42;\n"
+                        "}\n"
+                        "void f() {\n"
+                        "    U u;\n"
+                        "    init(u.v);\n"
+                        "    printf(\"%d\\n\", u.x);\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #10280
+        valueFlowUninit("union U {\n"
+                        "    char c[2];\n"
+                        "    uint16_t u16;\n"
+                        "};\n"
+                        "uint16_t f(std::istream& is) {\n"
+                        "    U u;\n"
+                        "    is.read(u.c, 2);\n"
+                        "    return u.u16;\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void f() {\n"
+                        "  char src, dest;\n"
+                        "  std::memcpy(&dest, &src, 1);\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:3:22]: (error) Uninitialized variable: &src [uninitvar]\n", errout_str());
+
+        // #10988
+        valueFlowUninit("void f(const void* ptr, bool* result) {\n"
+                        "  int dummy;\n"
+                        "  *result = (&dummy < ptr);\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct A {\n"
+                        "    int x;\n"
+                        "};\n"
+                        "void f() {\n"
+                        "    A a;\n"
+                        "    A* p = &a;\n"
+                        "    p->x = 1;\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct A {\n"
+                        "    int x;\n"
+                        "};\n"
+                        "void g(const int&);\n"
+                        "void f() {\n"
+                        "    A a;\n"
+                        "    g(a.x);\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:7:9]: (error) Uninitialized variable: a.x [uninitvar]\n", errout_str());
+
+        valueFlowUninit("struct A {\n"
+                        "    int x;\n"
+                        "};\n"
+                        "void g(const int&);\n"
+                        "void f() {\n"
+                        "    A a;\n"
+                        "    A* p = &a;\n"
+                        "    g(p->x);\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:8:10]: (error) Uninitialized variable: p->x [uninitvar]\n", errout_str());
+
+        valueFlowUninit("void f() {\n"
+                        "    int a;\n"
+                        "    a++;\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
+
+        // #11006
+        valueFlowUninit("int g(int);\n"
+                        "void f() {\n"
+                        "    int received[NSIG];\n"
+                        "    for (int sig = 0; sig < NSIG; sig++)\n"
+                        "        received[sig] = g(sig);\n"
+                        "    for (int sig = 0; sig < NSIG; sig++)\n"
+                        "        if (received[sig]) {}\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void increment(int& i) { ++i; }\n" // #6475
+                        "int f() {\n"
+                        "    int n;\n"
+                        "    increment(n);\n"
+                        "    return n;\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:4:15] -> [test.cpp:1:28]: (warning) Uninitialized variable: i [uninitvar]\n", errout_str());
+
+        // #11412
+        valueFlowUninit("void f(int n) {\n"
+                        "	short* p;\n"
+                        "	if (n) {\n"
+                        "		p = g(n);\n"
+                        "	}\n"
+                        "	for (int i = 0; i < n; i++)\n"
+                        "		(void)p[i];\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11492
+        valueFlowUninit("void f() {\n"
+                        "    int i;\n"
+                        "    try {\n"
+                        "        i = 0;\n"
+                        "    }\n"
+                        "    catch (...) {\n"
+                        "        if (i) {}\n"
+                        "    }\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11624
+        valueFlowUninit("const int N = 2;\n"
+                        "void g(int a[N]) {\n"
+                        "    for (int i = 0; i < N; ++i)\n"
+                        "        a[i] = 1;\n"
+                        "}\n"
+                        "void f() {\n"
+                        "    int a[N];\n"
+                        "    g(a);\n"
+                        "    if (a[0]) {}\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11673
+        valueFlowUninit("void f() {\n"
+                        "    bool b;\n"
+                        "    auto g = [&b]() {\n"
+                        "        b = true;\n"
+                        "    };\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #6619
+        valueFlowUninit("void f() {\n"
+                        "    int nok, i;\n"
+                        "    for (i = 1; i < 5; i++) {\n"
+                        "        if (i == 8)\n"
+                        "            nok = 8;\n"
+                        "    }\n"
+                        "    printf(\"nok = %d\\n\", nok);\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:7:26]: (error) Uninitialized variable: nok [uninitvar]\n", errout_str());
+
+        // #7475
+        valueFlowUninit("struct S {\n"
+                        "    int a, b, c;\n"
+                        "} typedef s_t;\n"
+                        "void f() {\n"
+                        "    s_t s;\n"
+                        "    printf(\"%d\", s.a);\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:6:20]: (error) Uninitialized variable: s.a [uninitvar]\n", errout_str());
+
+        valueFlowUninit("void f(char* src) {\n" // #11608
+                        "    char envar[64], *cp, c;\n"
+                        "    for (src += 2, cp = envar; (c = *src) != '\\0'; src++)\n"
+                        "        *cp++ = c;\n"
+                        "    if (cp != envar)\n"
+                        "        if ((cp = getenv(envar)) != NULL) {}\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11459
+        valueFlowUninit("struct S {\n"
+                        "    enum E { N = 3 };\n"
+                        "    static const int A[N];\n"
+                        "    static void f();\n"
+                        "};\n"
+                        "const int S::A[N] = { 0, 1, 2 };\n"
+                        "void S::f() {\n"
+                        "    int tmp[N];\n"
+                        "    for (int i = 0; i < N; i++)\n"
+                        "        tmp[i] = 0;\n"
+                        "    if (tmp[0]) {}\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11055
+        valueFlowUninit("void g(int*);\n"
+                        "void f(bool b) {\n"
+                        "    int i;\n"
+                        "    int* p = b ? &i : nullptr;\n"
+                        "    g(p);\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct T {};\n" // #11075
+                        "struct S {\n"
+                        "    int n;\n"
+                        "    struct T t[10];\n"
+                        "};\n"
+                        "void f(struct S* s, char** tokens) {\n"
+                        "    struct T t[10];\n"
+                        "    int n = 0;\n"
+                        "    for (int i = 0; i < s->n; i++)\n"
+                        "        if (tokens[i])\n"
+                        "            t[n++] = s->t[i];\n"
+                        "    for (int i = 0; i < n; i++)\n"
+                        "        t[i];\n"
+                        "}\n", false);
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("bool g();\n"
+                        "void f() {\n"
+                        "    int a[10];\n"
+                        "    int idx = 0;\n"
+                        "    if (g())\n"
+                        "        a[idx++] = 1;\n"
+                        "    for (int i = 0; i < idx; i++)\n"
+                        "        (void)a[i];\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void f() {\n"
+                        "  int x;\n"
+                        "  int *p = 0 ? 0 : &x;\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void g() {\n"
+                        "  int y;\n"
+                        "  int *q = 1 ? &y : 0;\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void f(std::stringstream& ss) {\n" // #11805
+                        "    int x;\n"
+                        "    int* p = &x;\n"
+                        "    ss >> *p;\n"
+                        "}\n"
+                        "void g() {\n"
+                        "    int x;\n"
+                        "    int* p = &x;\n"
+                        "    int& r = *p;\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void f(std::stringstream& ss) {\n" // #11805
+                        "    int x;\n"
+                        "    int* p = &x;\n"
+                        "    ss >> *p;\n"
+                        "}\n"
+                        "void g() {\n"
+                        "    int x;\n"
+                        "    int* p = &x;\n"
+                        "    int& r = *p;\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct S1 { char a[10]; };\n" // #11804
+                        "struct S2 { struct S1 s1; };\n"
+                        "void init(char* c);\n"
+                        "void f() {\n"
+                        "    struct S2 s2;\n"
+                        "    init(s2.s1.a);\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct S { int i; };\n" // #11731
+                        "void f(const S*& p);\n"
+                        "int g() {\n"
+                        "   const S* s;\n"
+                        "   f(s);\n"
+                        "   return s->i;\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("int f(int i) {\n"
+                        "    int x;\n"
+                        "    int* p = &x;\n"
+                        "    return i >> *p;\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:4:17]: (error) Uninitialized variable: *p [uninitvar]\n", errout_str());
+
+        valueFlowUninit("void f(int& x) {\n"
+                        "    int i;\n"
+                        "    x = i;\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:3:9]: (error) Uninitialized variable: i [uninitvar]\n", errout_str());
+
+        valueFlowUninit("void f() {\n" // #11890
+                        "    int x;\n"
+                        "    int* a[] = { &x };\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11992
+        valueFlowUninit("void foo(const int &x) {\n"
+                        "    if(x==42) {;}\n"
+                        "}\n"
+                        "void test(void) {\n"
+                        "    int t;\n"
+                        "    int &p = t;\n"
+                        "    int &s = p;\n"
+                        "    int &q = s;\n"
+                        "    foo(q);\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:9:9]: (error) Uninitialized variable: q [uninitvar]\n", errout_str());
+
+        valueFlowUninit("int g();\n" // #12082
+                        "void f() {\n"
+                        "    int a[1], b[1];\n"
+                        "    while (a[0] = g()) {}\n"
+                        "    if ((b[0] = g()) == 0) {}\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void f(const char *x, char *y);\n" // #4527
+                        "void g(char* b) {\n"
+                        "    char a[1000];\n"
+                        "    f(a, b);\n"
+                        "    printf(\"%s\", a);\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:4:7]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
+
+        valueFlowUninit("void usage(const char *);\n" // #10330
+                        "int main(int argc, char* argv[]) {\n"
+                        "    int user = 0;\n"
+                        "    struct passwd* pwd;\n"
+                        "    while (1) {\n"
+                        "        int c = getc();\n"
+                        "        if (c == -1)\n"
+                        "            break;\n"
+                        "        switch (c) {\n"
+                        "        case 'u': user = 123; break;\n"
+                        "        }\n"
+                        "    }\n"
+                        "    if (argc == 1)\n"
+                        "        usage(argv[0]);\n"
+                        "    if (user)\n"
+                        "        pwd = getpwnam(user);\n"
+                        "    if (pwd == NULL) {}\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:15:9] -> [test.cpp:17:9]: (warning) Uninitialized variable: pwd [uninitvar]\n", errout_str());
+
+        valueFlowUninit("size_t Read(unsigned char* buffer, size_t len);\n" // #11540
+                        "void f() {\n"
+                        "    const int N = 100;\n"
+                        "    uint8_t data[N];\n"
+                        "    size_t data_size = 0;\n"
+                        "    for (int i = 0; i < 10; i++) {\n"
+                        "        if (!data_size)\n"
+                        "            data_size = Read(data, N);\n"
+                        "        if (!data_size)\n"
+                        "            return;\n"
+                        "        if (data[0] == 0x47) {}\n"
+                        "    }\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #12033
+        valueFlowUninit("void g(const char*p);\n"
+                        "void f() {\n"
+                        "    char buf[10];\n"
+                        "    g(buf);\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:4:7]: (error) Uninitialized variable: buf [uninitvar]\n", errout_str());
+
+        valueFlowUninit("void f() {\n" // #12288
+                        "    char buf[100];\n"
+                        "    char* p = new (buf) char[100];\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #12355
+        valueFlowUninit("int f() {\n"
+                        "    const int x[10](1, 2);\n"
+                        "    if (x[0] == 1) {}\n"
+                        "    return x[0];\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void f(bool* p) {\n" // #12287
+                        "    if (p)\n"
+                        "        *p = true; \n"
+                        "}\n"
+                        "void g() {\n"
+                        "    bool b;\n"
+                        "    f(&b);\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct S { int x; };\n" // #12394
+                        "int f() {\n"
+                        "    struct S s[1];\n"
+                        "    s->x = 0;\n"
+                        "    return s[0].x;\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct S { int* p; };\n" // #12473
+                        "void f() {\n"
+                        "    struct S s;\n"
+                        "    s.p[0] = 0;\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:4:7]: (error) Uninitialized variable: s.p [uninitvar]\n", errout_str());
+
+        // #12460
+        valueFlowUninit("typedef struct {\n"
+                        "  int a;\n"
+                        "} st;\n"
+                        "void foo(int* p, bool success) {\n"
+                        "  st myst;\n"
+                        "  if (success == 1) {\n"
+                        "    myst.a = 5;\n"
+                        "  }\n"
+                        "  if ((success == 1) && (myst.a != 0)) {}\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #12606
+        valueFlowUninit("void f(int& r) { if (r) {} }\n"
+                        "void g() {\n"
+                        "    int i;\n"
+                        "    f(i);\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:4:7] -> [test.cpp:1:22]: (warning) Uninitialized variable: r [uninitvar]\n", errout_str());
+
+        // #12197
+        valueFlowUninit("void f() {\n"
+                        "    char a[N];\n"
+                        "    for (int i = 0; i < N; i++)\n"
+                        "        a[i] = 1;\n"
+                        "    const int* p = a;\n"
+                        "    for (int i = 0; i < N; i++) {\n"
+                        "        if (p[i]) {}\n"
+                        "    }\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #12247
+        valueFlowUninit("void f() {\n"
+                        "    char a[10], *p = &a[0];\n"
+                        "    p = getenv(\"abc\");\n"
+                        "    printf(\"%\", p);\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void f(char *q) {\n"
+                        "    char a[1];\n"
+                        "    char *p = a;\n"
+                        "    p = q;\n"
+                        "    printf(\"%s\", p);\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("std::string f() {\n" // #12922
+                        "    std::string a[2];\n"
+                        "    std::array<std::string, 2> b;\n"
+                        "    return a[1] + b.at(1);\n" // don't warn
+                        "}\n"
+                        "struct S { int i; };\n"
+                        "struct T { int i = 0; };\n"
+                        "int g() {\n"
+                        "    std::array<int, 2> a;\n"
+                        "    std::array<S, 2> b;\n"
+                        "    std::array<T, 2> c;\n" // don't warn
+                        "    return a.at(1) + b.at(1).i + c.at(1).i;\n"
+                        "}\n"
+                        "int h() {\n"
+                        "    std::array<int, 2> a;\n"
+                        "    return a[1];\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:12:12]: (error) Uninitialized variable: a [uninitvar]\n"
+                      "[test.cpp:12:22]: (error) Uninitialized variable: b [uninitvar]\n"
+                      "[test.cpp:16:12]: (error) Uninitialized variable: a [uninitvar]\n",
+                      errout_str());
+
+        valueFlowUninit("void f() {\n" // # 12932
+                        "    std::array<int, 0> a;\n"
+                        "    if (a.begin() == a.end()) {}\n"
+                        "    std::array<int, 1> b;\n"
+                        "    auto it = b.begin();\n"
+                        "    *it = 0;\n"
+                        "    std::array<int, 1> c;\n"
+                        "    return c.front();\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:8:12]: (error) Uninitialized variable: c [uninitvar]\n", errout_str());
+
+        // #13930
+        valueFlowUninit("extern int32_t g_items[10U];\n"
+                        "uint16_t write_item(uint8_t n);\n"
+                        "uint16_t write_item(uint8_t n) {\n"
+                        "    int32_t *p_item = NULL;\n"
+                        "    uint16_t ret;\n"
+                        "    ret = 0U;\n"
+                        "    if (n < 10U)\n"
+                        "        p_item = &g_items[n];\n"
+                        "    else\n"
+                        "        ret = 1U;\n"
+                        "    if (ret == 0U) \n"
+                        "        *p_item = 5;\n"
+                        "    return ret;\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("int f() {\n" // #12944
+                        "    int i;\n"
+                        "    auto x = [&]() { return i; };\n"
+                        "    i = 5;\n"
+                        "    return x();\n"
+                        "}\n"
+                        "int g() {\n"
+                        "    int i;\n"
+                        "    {\n"
+                        "        auto x = [&]() { return i; };\n"
+                        "        i = 5;\n"
+                        "        return x();\n"
+                        "    }\n"
+                        "}\n"
+                        "int h() {\n"
+                        "    int j;\n"
+                        "    return [&]() { return j; }();\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:17:27]: (error) Uninitialized variable: j [uninitvar]\n", errout_str());
 
-    void trac_4871() { // #4871
-        checkUninitVar("void pickup(int a) {\n"
-                       "bool using_planner_action;\n"
-                       "if (a)   {\n"
-                       "  using_planner_action = false;\n"
-                       "}\n"
-                       "else {\n"
-                       "  try\n"
-                       "  {}\n"
-                       "  catch (std::exception &ex) {\n"
-                       "    return;\n"
-                       "  }\n"
-                       "  using_planner_action = true;\n"
-                       "}\n"
-                       "if (using_planner_action) {}\n"
-                       "}");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("int f() {\n" // #14582
+                        "    int a[1];\n"
+                        "    static_cast<int*>(a)[0] = 0;\n"
+                        "    return a[0];\n"
+                        "}\n"
+                        "int g() {\n"
+                        "    int a[1];\n"
+                        "    ((int*)a)[0] = 0;\n"
+                        "    return a[0];\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void syntax_error() { // Ticket #5073
-        const char code[] = "struct flex_array {};\n"
-                            "struct cgroup_taskset {};\n"
-                            "void cgroup_attach_task() {\n"
-                            "  struct flex_array *group;\n"
-                            "  struct cgroup_taskset tset = { };\n"
-                            "  do { } while_each_thread(leader, tsk);\n"
-                            "}";
-        ASSERT_THROW(checkUninitVar(code), InternalError);
-    }
+    void valueFlowUninitBreak() { // Do not show duplicate warnings about the same uninitialized value
+        valueFlowUninit("struct wcsstruct {\n"
+                        "    int *wcsprm;\n"
+                        "};\n"
+                        "\n"
+                        "void copy_wcs(wcsstruct *wcsin) {\n"
+                        "    wcsstruct *x;\n"
+                        "    memcpy(wcsin, x, sizeof(wcsstruct));\n" // <- warning
+                        "    x->wcsprm = NULL;\n" // <- no warning
+                        "}");
+        ASSERT_EQUALS("[test.cpp:7:19]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
 
-    void trac_5970() { // Ticket #5970
-        checkUninitVar("void DES_ede3_ofb64_encrypt() {\n"
-                       "  DES_cblock d; \n"
-                       "  char *dp; \n"
-                       "  dp=(char *)d; \n"
-                       "  init(dp); \n"
-                       "}", "test.c");
-        ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("struct wcsstruct {\n"
+                        "    int *wcsprm;\n"
+                        "};\n"
+                        "\n"
+                        "void copy_wcs(wcsstruct *wcsin) {\n"
+                        "    wcsstruct *x;\n"
+                        "    sizeof(x);\n"
+                        "    x->wcsprm = NULL;\n" // <- Warn
+                        "}");
+        ASSERT_EQUALS("[test.cpp:8:5]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
+
+        valueFlowUninit("struct wcsstruct {\n"
+                        "    int *wcsprm;\n"
+                        "};\n"
+                        "\n"
+                        "void init_wcs(wcsstruct *x) { if (x->wcsprm != NULL); }\n" // <- no warning
+                        "\n"
+                        "void copy_wcs() {\n"
+                        "    wcsstruct *x;\n"
+                        "    x->wcsprm = NULL;\n" // <- warn here
+                        "    init_wcs(x);\n" // <- no warning
+                        "}");
+        ASSERT_EQUALS("[test.cpp:9:5]: (error) Uninitialized variable: x [uninitvar]\n", errout_str());
     }
 
-    void valueFlowUninit(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
+    void uninitvar_ipa() {
+        // #8825
+        valueFlowUninit("typedef struct  {\n"
+                        "    int flags;\n"
+                        "} someType_t;\n"
+                        "void bar(const someType_t * const p)  {\n"
+                        "    if( (p->flags & 0xF000) == 0xF000){}\n"
+                        "}\n"
+                        "void f(void) {\n"
+                        "    someType_t gVar;\n"
+                        "    bar(&gVar);\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:9:9]: (error) Uninitialized variable: &gVar [uninitvar]\n", errout_str());
 
-        // Tokenize..
-        settings.debugwarnings = false;
-        settings.experimental = false;
+        valueFlowUninit("typedef struct\n"
+                        "{\n"
+                        "        int flags[3];\n"
+                        "} someType_t;\n"
+                        "void f(void) {\n"
+                        "        someType_t gVar;\n"
+                        "        if(gVar.flags[1] == 42){}\n"
+                        "}");
+        // TODO : find bugs for member arrays
+        TODO_ASSERT_EQUALS("[test.cpp:7]: (error) Uninitialized variable: gVar.flags\n", "", errout_str());
+
+        valueFlowUninit("void foo() {\n" // #10293
+                        "  union {\n"
+                        "    struct hdr cm;\n"
+                        "    char control[123];\n"
+                        "  } u;\n"
+                        "  char *x = u.control;\n" // <- no error
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        valueFlowUninit("struct pc_data {\n"
+                        "    struct {\n"
+                        "        char   * strefa;\n"
+                        "    } wampiryzm;\n"
+                        "};\n"
+                        "void f() {\n"
+                        "    struct pc_data *pcdata;\n"
+                        "    if ( *pcdata->wampiryzm.strefa == '\\0' ) { }\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:8:11]: (error) Uninitialized variable: pcdata [uninitvar]\n", errout_str());
 
-        // Check for redundant code..
-        CheckUninitVar checkuninitvar(&tokenizer, &settings, this);
-        checkuninitvar.valueFlowUninit();
-    }
+        // # 9293
+        valueFlowUninit("struct S {\n"
+                        "  int x;\n"
+                        "  int y;\n"
+                        "};\n"
+                        "\n"
+                        "void f() {\n"
+                        "    struct S s1;\n"
+                        "    int * x = &s1.x;\n"
+                        "    struct S s2 = {*x, 0};\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:9:20]: (error) Uninitialized variable: *x [uninitvar]\n", errout_str());
+
+        valueFlowUninit("struct S {\n"
+                        "  int x;\n"
+                        "  int y;\n"
+                        "};\n"
+                        "\n"
+                        "void f() {\n"
+                        "    struct S s1;\n"
+                        "    struct S s2;\n"
+                        "    int * x = &s1.x;\n"
+                        "    s2.x = *x;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:10:12]: (error) Uninitialized variable: *x [uninitvar]\n", errout_str());
+
+        valueFlowUninit("void f(bool * x) {\n"
+                        "    *x = false;\n"
+                        "}\n"
+                        "void g() {\n"
+                        "    bool b;\n"
+                        "    f(&b);\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
+        valueFlowUninit("void f(bool * x) {\n"
+                        "    if (x != nullptr)\n"
+                        "        x = 1;\n"
+                        "}\n"
+                        "void g() {\n"
+                        "    bool x;\n"
+                        "    f(&x);\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-    void valueFlowUninit() {
         valueFlowUninit("void f() {\n"
-                        "  int x;\n"
-                        "  switch (x) {}\n"
+                        "    bool b;\n"
+                        "    bool * x = &b;\n"
+                        "    if (x != nullptr)\n"
+                        "        x = 1;\n"
                         "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: x\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        valueFlowUninit("int f() {\n"
-                        "  int x;\n"
-                        "  init(x);\n"
-                        "  return x;\n" // TODO: inconclusive ?
+        valueFlowUninit("struct A { bool b; };"
+                        "void f(A * x) {\n"
+                        "    x->b = false;\n"
+                        "}\n"
+                        "void g() {\n"
+                        "    A b;\n"
+                        "    f(&b);\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        valueFlowUninit("void f() {\n" // #8172
-                        "  char **x;\n"
-                        "  if (2 < sizeof(*x)) {}\n"
+        valueFlowUninit("std::string f() {\n"
+                        "    std::ostringstream ostr;\n"
+                        "    ostr << \"\";\n"
+                        "    return ostr.str();\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+        // #9281
+        valueFlowUninit("struct s {\n"
+                        "    char a[20];\n"
+                        "};\n"
+                        "void c(struct s *sarg) {\n"
+                        "    sarg->a[0] = '\\0';\n"
+                        "}\n"
+                        "void b(struct s *sarg) {\n"
+                        "    c(sarg);\n"
+                        "}\n"
+                        "void a() {\n"
+                        "    struct s s1;\n"
+                        "    b(&s1);\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        valueFlowUninit("void foo() {\n" // #5259 - False negative
-                        "    int a;\n"
-                        "    int x[] = {a,2};\n"
+        // # 9290
+        valueFlowUninit("struct A {\n"
+                        "    double x;\n"
+                        "};\n"
+                        "double b() {\n"
+                        "    A * c;\n"
+                        "    c->x = 42;\n"
+                        "    return c->x;\n"
                         "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:5]: (error) Uninitialized variable: c [uninitvar]\n",
+                      errout_str());
 
-        valueFlowUninit("void foo()\n"
-                        "{\n"
-                        "    int x;\n"
-                        "    int *y = &x;\n"
+        valueFlowUninit("struct A {\n"
+                        "    double x;\n"
+                        "};\n"
+                        "double b() {\n"
+                        "    A c;\n"
+                        "    c.x = 42;\n"
+                        "    return c.x;\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        valueFlowUninit("void foo()\n"
-                        "{\n"
-                        "    int *x;\n"
-                        "    int *&y = x;\n"
+        valueFlowUninit("struct A {\n"
+                        "    double x;\n"
+                        "};\n"
+                        "double d(A * e) {\n"
+                        "    e->x = 42;\n"
+                        "    return e->x;\n"
+                        "}\n"
+                        "double b() {\n"
+                        "    A c;\n"
+                        "    return d(&c);\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        valueFlowUninit("void foo()\n"
-                        "{\n"
-                        "    int x = xyz::x;\n"
+        // # 9302
+        valueFlowUninit("struct VZ   {\n"
+                        "    double typ;\n"
+                        "};\n"
+                        "void read() {\n"
+                        "    struct VZ vz;\n"
+                        "    struct VZ* pvz = &vz;\n"
+                        "    vz.typ      = 42;\n"
+                        "    if (pvz->typ == 0)\n"
+                        "        return;\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        valueFlowUninit("void f()\n"
-                        "{\n"
-                        "    extern int a;\n"
-                        "    a++;\n"
+        // # 9305
+        valueFlowUninit("struct kf {\n"
+                        "    double x;\n"
+                        "};\n"
+                        "void set(kf* k) {\n"
+                        "    k->x = 0;\n"
+                        "}\n"
+                        "void cal() {\n"
+                        "    KF b;\n"
+                        "    KF* pb = &b;\n"
+                        "    set( pb);\n"
+                        "    if (pb->x)\n"
+                        "        return;\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        valueFlowUninit("static void foo()\n"
-                        "{\n"
-                        "    int x, y;\n"
-                        "    x = (y = 10);\n"
-                        "    int z = y * 2;\n"
+        // # 9348
+        valueFlowUninit("void f(int *a) {\n"
+                        "  int b = 0;\n"
+                        "  memcpy(a, &b, sizeof(b));\n"
+                        "}\n"
+                        "void g() {\n"
+                        "  int i;\n"
+                        "  f(&i);\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // # 9631
+        valueFlowUninit("static void g(bool * result, int num, int num2, size_t * buflen) {\n"
+                        "  if (*result && *buflen >= 5) {}\n"
+                        "}\n"
+                        "void f() {\n"
+                        "  size_t bytesCopied;\n"
+                        "  bool copied_all = true;\n"
+                        "  g(&copied_all, 5, 6, &bytesCopied);\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:7:24] -> [test.cpp:2:18]: (warning) Uninitialized variable: *buflen [uninitvar]\n", errout_str());
+
+        // # 9953
+        valueFlowUninit("uint32_t f(uint8_t *mem) {\n"
+                        "    uint32_t u32;\n"
+                        "    uint8_t *buf = (uint8_t *)(&u32);\n"
+                        "    buf[0] = mem[0];\n"
+                        "    return(*(uint32_t *)buf);\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void valueFlowUninitStructMembers()
+    {
+        valueFlowUninit("struct AB { int a; int b; };\n"
+                        "void f(void) {\n"
+                        "    struct AB ab;\n"
+                        "    ab.a = 1;\n"
+                        "    if (ab.b == 2) {}\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:5:12]: (error) Uninitialized variable: ab.b [uninitvar]\n", errout_str());
+
+        valueFlowUninit("struct AB { int a; int b; };\n"
+                        "void do_something(const struct AB &ab) { a = ab.a; }\n"
+                        "void f(void) {\n"
+                        "    struct AB ab;\n"
+                        "    ab.a = 0;\n"
+                        "    do_something(ab);\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct AB { int a; int b; };\n"
+                        "void do_something(const struct AB &ab) { a = ab.b; }\n"
+                        "void f(void) {\n"
+                        "    struct AB ab;\n"
+                        "    ab.a = 0;\n"
+                        "    do_something(ab);\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:6:18] -> [test.cpp:2:49]: (warning) Uninitialized variable: ab.b [uninitvar]\n", errout_str());
+
+        valueFlowUninit("struct AB { int a; int b; };\n"
+                        "void f(void) {\n"
+                        "    struct AB ab;\n"
+                        "    int a = ab.a;\n"
+                        "}\n",
+                        false);
+        ASSERT_EQUALS("[test.c:4:16]: (error) Uninitialized variable: ab.a [uninitvar]\n", errout_str());
+
+        valueFlowUninit("struct AB { int a; int b; };\n"
+                        "void f(void) {\n"
+                        "    AB ab1;\n"
+                        "    AB ab2 = { ab1.a, 0 };\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:4:20]: (error) Uninitialized variable: ab1.a [uninitvar]\n", errout_str());
+
+        valueFlowUninit("struct AB { int a; int b; };\n"
+                        "void f(void) {\n"
+                        "    struct AB ab;\n"
+                        "    buf[ab.a] = 0;\n"
+                        "}\n",
+                        false);
+        ASSERT_EQUALS("[test.c:4:12]: (error) Uninitialized variable: ab.a [uninitvar]\n", errout_str());
+
+        valueFlowUninit("struct AB { int a; int b; };\n"
+                        "void f(void) {\n"
+                        "    struct AB ab;\n"
+                        "    ab.a = 1;\n"
+                        "    x = ab;\n"
+                        "}\n",
+                        false);
+        ASSERT_EQUALS("[test.c:5:9]: (error) Uninitialized variable: ab.b [uninitvar]\n", errout_str());
+
+        valueFlowUninit("struct AB { int a; int b; };\n"
+                        "void f(void) {\n"
+                        "    struct AB ab;\n"
+                        "    ab.a = 1;\n"
+                        "    x = *(&ab);\n"
+                        "}\n",
+                        false);
+        ASSERT_EQUALS("[test.c:5:9]: (error) Uninitialized variable: *(&ab).b [uninitvar]\n", errout_str());
+
+        valueFlowUninit("void f(void) {\n"
+                        "    struct AB ab;\n"
+                        "    int x;\n"
+                        "    ab.a = (void*)&x;\n"
+                        "    dostuff(&ab,0);\n"
+                        "}\n",
+                        false);
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct Element {\n"
+                        "    static void f() { }\n"
+                        "};\n"
+                        "void test() {\n"
+                        "    Element *element; element->f();\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:23]: (error) Uninitialized variable: element [uninitvar]\n", errout_str());
 
-        valueFlowUninit("static void foo() {\n"
-                        "    int x, y;\n"
-                        "    x = ((y) = 10);\n"
+        valueFlowUninit("struct Element {\n"
+                        "    static void f() { }\n"
+                        "};\n"
+                        "void test() {\n"
+                        "    Element *element; (*element).f();\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:25]: (error) Uninitialized variable: element [uninitvar]\n", errout_str());
 
-        valueFlowUninit("static void foo()\n"
-                        "{\n"
-                        "    Foo p;\n"
-                        "    p.abcd();\n"
+        valueFlowUninit("struct Element {\n"
+                        "    static int v;\n"
+                        "};\n"
+                        "void test() {\n"
+                        "    Element *element; element->v;\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:23]: (error) Uninitialized variable: element [uninitvar]\n", errout_str());
 
-        valueFlowUninit("static void foo()\n"
-                        "{\n"
-                        "    Foo p;\n"
-                        "    int x = p.abcd();\n"
+        valueFlowUninit("struct Element {\n"
+                        "    static int v;\n"
+                        "};\n"
+                        "void test() {\n"
+                        "    Element *element; (*element).v;\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
-
-        // Unknown types
-        {
-            valueFlowUninit("void a()\n"
-                            "{\n"
-                            "    A ret;\n"
-                            "    return ret;\n"
-                            "}");
-            ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:25]: (error) Uninitialized variable: element [uninitvar]\n", errout_str());
 
-            // #3916 - avoid false positive
-            valueFlowUninit("void f(float x) {\n"
-                            "  union lf { long l; float f; } u_lf;\n"
-                            "  float hx = (u_lf.f = (x), u_lf.l);\n"
-                            "}");
-            ASSERT_EQUALS("", errout.str());
-        }
+        valueFlowUninit("struct Element {\n"
+                        "    void f() { }\n"
+                        "};\n"
+                        "void test() {\n"
+                        "    Element *element; element->f();\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:5:23]: (error) Uninitialized variable: element [uninitvar]\n", errout_str());
 
-        valueFlowUninit("void a()\n"
-                        "{\n"
-                        "    int x[10];\n"
-                        "    int *y = x;\n"
+        valueFlowUninit("struct Element {\n"
+                        "    void f() { }\n"
+                        "};\n"
+                        "void test() {\n"
+                        "    Element *element; (*element).f();\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:25]: (error) Uninitialized variable: element [uninitvar]\n", errout_str());
 
-        valueFlowUninit("void a()\n"
-                        "{\n"
-                        "    int x;\n"
-                        "    int *y = &x;\n"
-                        "    *y = 0;\n"
-                        "    x++;\n"
+        valueFlowUninit("struct Element {\n"
+                        "    int v;\n"
+                        "};\n"
+                        "void test() {\n"
+                        "    Element *element; element->v;\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:23]: (error) Uninitialized variable: element [uninitvar]\n", errout_str());
 
-        valueFlowUninit("void a()\n"
-                        "{\n"
-                        "    char x[10], y[10];\n"
-                        "    char *z = x;\n"
-                        "    memset(z, 0, sizeof(x));\n"
-                        "    memcpy(y, x, sizeof(x));\n"
+        valueFlowUninit("struct Element {\n"
+                        "    int v;\n"
+                        "};\n"
+                        "void test() {\n"
+                        "    Element *element; (*element).v;\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:25]: (error) Uninitialized variable: element [uninitvar]\n", errout_str());
+
+        valueFlowUninit("struct AB { int a; int b; };\n" // pass struct member by address
+                        "void f(void) {\n"
+                        "    struct AB ab;\n"
+                        "    assign(&ab.a, 0);\n"
+                        "}\n",
+                        false);
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit(
+            "struct Cstring { char *text; int size, alloc; };\n"
+            "int maybe();\n"
+            "void f() {\n"
+            "    Cstring res;\n"
+            "    if ( ! maybe() ) return;\n"                                     // <- fp goes away if this is removed
+            "    ( ((res).text = (void*)0), ((res).size = (res).alloc = 0) );\n" // <- fp goes away if parentheses are removed
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct AB { int a; int b; };\n"
+                        "void do_something(const struct AB ab);\n"
+                        "void f(void) {\n"
+                        "    struct AB ab;\n"
+                        "    ab.a = 0;\n"
+                        "    ab.b = 0;\n"
+                        "    do_something(ab);\n"
+                        "}\n",
+                        false);
+        ASSERT_EQUALS("", errout_str());
 
-        // Handling >> and <<
         {
-            valueFlowUninit("int a() {\n"
-                            "    int ret;\n"
-                            "    std::cin >> ret;\n"
-                            "    ret++;\n"
-                            "}");
-            ASSERT_EQUALS("", errout.str());
+            valueFlowUninit("struct AB { char a[10]; };\n"
+                            "void f(void) {\n"
+                            "    struct AB ab;\n"
+                            "    strcpy(ab.a, STR);\n"
+                            "}\n",
+                            false);
+            ASSERT_EQUALS("", errout_str());
+
+            valueFlowUninit("struct AB { unsigned char a[10]; };\n" // #8999 - cast
+                            "void f(void) {\n"
+                            "    struct AB ab;\n"
+                            "    strcpy((char *)ab.a, STR);\n"
+                            "}\n",
+                            false);
+            ASSERT_EQUALS("", errout_str());
+
+            valueFlowUninit("struct AB { char a[10]; };\n"
+                            "void f(void) {\n"
+                            "    struct AB ab;\n"
+                            "    strcpy(x, ab.a);\n"
+                            "}\n",
+                            false);
+            TODO_ASSERT_EQUALS("[test.c:4:16]: (error) Uninitialized variable: ab.a [uninitvar]\n", "", errout_str());
+
+            valueFlowUninit("struct AB { int a; };\n"
+                            "void f(void) {\n"
+                            "    struct AB ab;\n"
+                            "    dosomething(ab.a);\n"
+                            "}\n",
+                            false);
+            ASSERT_EQUALS("", errout_str());
+        }
 
-            valueFlowUninit("void f(int b) {\n"
-                            "    int a;\n"
-                            "    std::cin >> b >> a;\n"
-                            "    return a;"
-                            "}");
-            ASSERT_EQUALS("", errout.str());
+        valueFlowUninit("struct AB { int a; int b; };\n"
+                        "void do_something(const struct AB ab);\n"
+                        "void f(void) {\n"
+                        "    struct AB ab;\n"
+                        "    ab = getAB();\n"
+                        "    do_something(ab);\n"
+                        "}\n",
+                        false);
+        ASSERT_EQUALS("", errout_str());
 
-            valueFlowUninit("void foo() {\n"   // #3707
-                            "    Node node;\n"
-                            "    int x;\n"
-                            "    node[\"abcd\"] >> x;\n"
+        {
+            // #6769 - calling method that might assign struct members
+            valueFlowUninit("struct AB { int a; int b; void set(); };\n"
+                            "void f(void) {\n"
+                            "    struct AB ab;\n"
+                            "    ab.set();\n"
+                            "    x = ab;\n"
                             "}");
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
 
-            valueFlowUninit("int a(FArchive &arc) {\n"
-                            "    int *p;\n"
-                            "    arc << p;\n"
-                            "    return *p;\n"
+            valueFlowUninit("struct AB { int a; int get() const; };\n"
+                            "void f(void) {\n"
+                            "    struct AB ab;\n"
+                            "    ab.get();\n"
+                            "    x = ab;\n"
                             "}");
-            ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: p\n", errout.str());
+            ASSERT_EQUALS("[test.cpp:4:5]: (error) Uninitialized variable: ab [uninitvar]\n", errout_str());
 
-            // #4320
-            valueFlowUninit("void f() {\n"
-                            "    int a;\n"
-                            "    a << 1;\n"
-                            "    return a;\n"
+            valueFlowUninit("struct AB { int a; void dostuff() {} };\n"
+                            "void f(void) {\n"
+                            "    struct AB ab;\n"
+                            "    ab.dostuff();\n"
+                            "    x = ab;\n"
                             "}");
-            ASSERT_EQUALS("[test.cpp:4]: (error) Uninitialized variable: a\n", errout.str());
-
+            TODO_ASSERT_EQUALS("error", "", errout_str());
         }
 
-        valueFlowUninit("void a() {\n"   // asm
-                        "    int x;\n"
-                        "    asm();\n"
-                        "    x++;\n"
+        valueFlowUninit("struct AB { int a; struct { int b; int c; } s; };\n"
+                        "void do_something(const struct AB ab);\n"
+                        "void f(void) {\n"
+                        "    struct AB ab;\n"
+                        "    ab.a = 1;\n"
+                        "    ab.s.b = 2;\n"
+                        "    ab.s.c = 3;\n"
+                        "    do_something(ab);\n"
+                        "}\n",
+                        false);
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct conf {\n"
+                        "    char x;\n"
+                        "};\n"
+                        "\n"
+                        "void do_something(struct conf ant_conf);\n"
+                        "\n"
+                        "void f(void) {\n"
+                        "   struct conf c;\n"
+                        "   initdata(&c);\n"
+                        "   do_something(c);\n"
+                        "}\n",
+                        false);
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct PIXEL {\n"
+                        "    union  {\n"
+                        "        struct { unsigned char red,green,blue,alpha; };\n"
+                        "        unsigned int color;\n"
+                        "    };\n"
+                        "};\n"
+                        "\n"
+                        "unsigned char f() {\n"
+                        "    struct PIXEL p1;\n"
+                        "    p1.color = 255;\n"
+                        "    return p1.red;\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
-
-        valueFlowUninit("void a()\n"
-                        "{\n"
-                        "    int x[10];\n"
-                        "    struct xyz xyz1 = { .x = x };\n"
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct AB { int a; int b; };\n"
+                        "int f() {\n"
+                        "  struct AB *ab;\n"
+                        "  for (i = 1; i < 10; i++) {\n"
+                        "    if (condition && (ab = getab()) != NULL) {\n"
+                        "      a = ab->a;\n"
+                        "    }\n"
+                        "  }\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        valueFlowUninit("void foo()\n"
-                        "{\n"
-                        "   char *buf = malloc(100);\n"
-                        "   struct ABC *abc = buf;\n"
+        valueFlowUninit("struct AB { int a; int b; };\n"
+                        "int f(int x) {\n"
+                        "  struct AB *ab;\n"
+                        "  if (x == 0) {\n"
+                        "    ab = getab();\n"
+                        "  }\n"
+                        "  if (x == 0 && (ab != NULL || ab->a == 0)) { }\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        valueFlowUninit("class Fred {\n"
-                        "public:\n"
-                        "    FILE *f;\n"
-                        "    ~Fred();\n"
-                        "}\n"
-                        "Fred::~Fred()\n"
-                        "{\n"
-                        "    fclose(f);\n"
+        valueFlowUninit("struct A { int *x; };\n" // declarationId is 0 for "delete"
+                        "void foo(void *info, void*p);\n"
+                        "void bar(void) {\n"
+                        "  struct A *delete = 0;\n"
+                        "  foo( info, NULL );\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct ABC { int a; int b; int c; };\n"
+                        "void foo(int x, const struct ABC *abc);\n"
+                        "void bar(void) {\n"
+                        "  struct ABC abc;\n"
+                        "  foo(123, &abc);\n"
+                        "  return abc.b;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:5:12]: (error) Uninitialized variable: &abc [uninitvar]\n", errout_str());
 
-        valueFlowUninit("void f()\n"
-                        "{\n"
-                        "    int c;\n"
-                        "    ab(sizeof(xyz), &c);\n"
-                        "    if (c);\n"
+        valueFlowUninit("struct ABC { int a; int b; int c; };\n"
+                        "void foo() {\n"
+                        "  struct ABC abc;\n"
+                        "  dostuff((uint32_t *)&abc.a);\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        valueFlowUninit("void f()\n"
-                        "{\n"
-                        "    int c;\n"
-                        "    a = (f2(&c));\n"
-                        "    c++;\n"
+        valueFlowUninit("void f(void) {\n"
+                        "    struct tm t;\n"
+                        "    t.tm_year = 123;\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        // goto/setjmp/longjmp..
-        valueFlowUninit("void foo(int x)\n"
-                        "{\n"
-                        "    long b;\n"
-                        "    if (g()) {\n"
-                        "        b =2;\n"
-                        "        goto found;\n"
-                        "    }\n"
+        // return
+        valueFlowUninit("struct AB { int a; int b; };\n"
+                        "void f(void) {\n"
+                        "    struct AB ab;\n"
+                        "    ab.a = 0;\n"
+                        "    return ab.b;\n"
+                        "}\n",
+                        false);
+        ASSERT_EQUALS("[test.c:5:15]: (error) Uninitialized variable: ab.b [uninitvar]\n", errout_str());
+
+        valueFlowUninit("struct AB { int a; int b; };\n"
+                        "void f(void) {\n"
+                        "    struct AB ab;\n"
+                        "    ab.a = 0;\n"
+                        "    return ab.a;\n"
+                        "}\n",
+                        false);
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct S { int a; int b; };\n" // #8299
+                        "void f(void) {\n"
+                        "    struct S s;\n"
+                        "    s.a = 0;\n"
+                        "    return s;\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:5:12]: (error) Uninitialized variable: s.b [uninitvar]\n", errout_str());
+
+        valueFlowUninit("struct S { int a; int b; };\n" // #9810
+                        "void f(void) {\n"
+                        "    struct S s;\n"
+                        "    return s.a ? 1 : 2;\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:4:14]: (error) Uninitialized variable: s.a [uninitvar]\n", errout_str());
+
+        // checkIfForWhileHead
+        valueFlowUninit("struct FRED {\n"
+                        "    int a;\n"
+                        "    int b;\n"
+                        "};\n"
                         "\n"
-                        "    return;\n"
+                        "void f(void) {\n"
+                        "   struct FRED fred;\n"
+                        "   fred.a = do_something();\n"
+                        "   if (fred.a == 0) { }\n"
+                        "}\n",
+                        false);
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct FRED {\n"
+                        "    int a;\n"
+                        "    int b;\n"
+                        "};\n"
                         "\n"
-                        "found:\n"
-                        "    int a = b;\n"
+                        "void f(void) {\n"
+                        "   struct FRED fred;\n"
+                        "   fred.a = do_something();\n"
+                        "   if (fred.b == 0) { }\n"
+                        "}\n",
+                        false);
+        ASSERT_EQUALS("[test.c:9:13]: (error) Uninitialized variable: fred.b [uninitvar]\n", errout_str());
+
+        valueFlowUninit("struct Fred { int a; };\n"
+                        "void f() {\n"
+                        "    struct Fred fred;\n"
+                        "    if (fred.a==1) {}\n"
+                        "}",
+                        false);
+        ASSERT_EQUALS("[test.c:4:14]: (error) Uninitialized variable: fred.a [uninitvar]\n", errout_str());
+
+        valueFlowUninit("struct S { int n; int m; };\n"
+                        "void f(void) {\n"
+                        " struct S s;\n"
+                        " for (s.n = 0; s.n <= 10; s.n++) { }\n"
+                        "}",
+                        false);
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void test2() {\n"
+                        "  struct { char type; } s_d;\n"
+                        "  if (foo(&s_d.type)){}\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        valueFlowUninit("int foo()\n"
-                        "{\n"
-                        "    jmp_buf env;\n"
-                        "    int a;\n"
-                        "    int val = setjmp(env);\n"
-                        "    if(val)\n"
-                        "        return a;\n"
-                        "    a = 1;\n"
-                        "    longjmp(env, 1);\n"
+        // for
+        valueFlowUninit("struct AB { int a; };\n"
+                        "void f() {\n"
+                        "    struct AB ab;\n"
+                        "    while (x) { clear(ab); z = ab.a; }\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        // macro_for..
-        valueFlowUninit("int foo()\n"
-                        "{\n"
-                        "  int retval;\n"
-                        "  if (condition) {\n"
-                        "    for12(1,2) { }\n"
-                        "    retval = 1;\n"
-                        "  }\n"
-                        "  else\n"
-                        "    retval = 2;\n"
-                        "  return retval;\n"
+        valueFlowUninit("struct AB { int a; };\n"
+                        "void f() {\n"
+                        "    struct AB ab;\n"
+                        "    while (x) { ab.a = ab.a + 1; }\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:27]: (error) Uninitialized variable: ab.a [uninitvar]\n", errout_str());
 
-        valueFlowUninit("int foo()\n"
-                        "{\n"
-                        "    int i;\n"
-                        "    goto exit;\n"
-                        "    i++;\n"
-                        "exit:\n"
+        valueFlowUninit("struct AB { int a; };\n"
+                        "void f() {\n"
+                        "    struct AB ab;\n"
+                        "    while (x) { init(&ab); z = ab.a; }\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        valueFlowUninit("int foo() {\n"
-                        "    int x,y=0;\n"
-                        "again:\n"
-                        "    if (y) return x;\n"
-                        "    x = a;\n"
-                        "    y = 1;\n"
-                        "    goto again;\n"
+        // address of member
+        valueFlowUninit("struct AB { int a[10]; int b; };\n"
+                        "void f() {\n"
+                        "    struct AB ab;\n"
+                        "    int *p = ab.a;\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        // Reference
+        valueFlowUninit("struct A { int x; };\n"
+                        "void foo() {\n"
+                        "  struct A a;\n"
+                        "  int& x = a.x;\n"
+                        "  x = 0;\n"
+                        "  return a.x;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
 
-        // #4040 - False positive
-        valueFlowUninit("int f(int x)  {\n"
-                        "    int iter;\n"
-                        "    {\n"
-                        "        union\n"
-                        "        {\n"
-                        "            int asInt;\n"
-                        "            double asDouble;\n"
-                        "        };\n"
-                        "\n"
-                        "        iter = x;\n"
-                        "    }\n"
-                        "    return 1 + iter;\n"
+        // non static data-member initialization
+        valueFlowUninit("struct AB { int a=1; int b; };\n"
+                        "void f(void) {\n"
+                        "    struct AB ab;\n"
+                        "    int a = ab.a;\n"
+                        "    int b = ab.b;\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:16]: (error) Uninitialized variable: ab.b [uninitvar]\n", errout_str());
 
-        // C++11 style initialization
-        valueFlowUninit("int f() {\n"
-                        "    int i = 0;\n"
-                        "    int j{ i };\n"
-                        "    return j;\n"
+        // STL class member
+        valueFlowUninit("struct A {\n"
+                        "    std::map<int, int> m;\n"
+                        "    int i;\n"
+                        "};\n"
+                        "void foo() {\n"
+                        "    A a;\n"
+                        "    x = a.m;\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        // Ticket #5646
-        valueFlowUninit("float foo() {\n"
-                        "  float source[2] = {3.1, 3.1};\n"
-                        "  float (*sink)[2] = &source;\n"
-                        "  return (*sink)[0];\n"
+        // Unknown type (C++)
+        valueFlowUninit("struct A {\n"
+                        "    C m;\n"
+                        "    int i;\n"
+                        "};\n"
+                        "void foo() {\n"
+                        "    A a;\n"
+                        "    x = a.m;\n"
                         "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        // Ticket #8755
-        valueFlowUninit("void f(int b) {\n"
-                        "    int a;\n"
-                        "    if (b == 10)\n"
-                        "        a = 1;\n"
-                        "    if (b == 13)\n"
-                        "        a = 1;\n"
-                        "    if (b == 'x') {}\n"
-                        "    if (a) {}\n"
+        // Unknown type (C)
+        valueFlowUninit("struct A {\n"
+                        "    C m;\n"
+                        "    int i;\n"
+                        "};\n"
+                        "void foo() {\n"
+                        "    A a;\n"
+                        "    x = a.m;\n"
+                        "}",
+                        false);
+        ASSERT_EQUALS("[test.c:7:11]: (error) Uninitialized variable: a.m [uninitvar]\n", errout_str());
+
+        // Type with constructor
+        valueFlowUninit("class C { C(); }\n"
+                        "struct A {\n"
+                        "    C m;\n"
+                        "    int i;\n"
+                        "};\n"
+                        "void foo() {\n"
+                        "    A a;\n"
+                        "    x = a.m;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct S {\n"
+                        "   int t[1];\n"
+                        "};\n"
+                        "int f(const S* ps) {\n"
+                        "   return ps->t[0];\n"
+                        "}\n"
+                        "void g() {\n"
+                        "   S s;\n"
+                        "   s.t[0] = 1;\n"
+                        "   f(&s);\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct S {\n"
+                        "   int t[1];\n"
+                        "   int u;\n"
+                        "};\n"
+                        "\n"
+                        "int f(const S* ps) {\n"
+                        "   return ps->t[0];\n"
+                        "}\n"
+                        "\n"
+                        "int main(void)\n"
+                        "{\n"
+                        "   S s;\n"
+                        "   s.t[0] = 1;\n"
+                        "   f(&s);\n"
                         "}");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Uninitialized variable: a\n", errout.str());
-    }
+        ASSERT_EQUALS("", errout_str());
 
-    void uninitvar_ipa() {
-        // #8825
-        valueFlowUninit("typedef struct  {\n"
-                        "    int flags;\n"
-                        "} someType_t;\n"
-                        "void bar(const someType_t * const p)  {\n"
-                        "    if( (p->flags & 0xF000) == 0xF000){}\n"
+        valueFlowUninit("struct X {\n"
+                        "   int a, b;\n"
+                        "};\n"
+                        "struct S {\n"
+                        "   X t;\n"
+                        "};\n"
+                        "int f(const S* ps) {\n"
+                        "   return ps->t.a;\n"
                         "}\n"
-                        "void f(void) {\n"
-                        "    someType_t gVar;\n"
-                        "    bar(&gVar);\n"
+                        "void g() {\n"
+                        "   S s;\n"
+                        "   s.t.a = 1;\n"
+                        "   f(&s);\n"
                         "}\n");
-        ASSERT_EQUALS("[test.cpp:9] -> [test.cpp:5]: (error) Uninitialized variable: flags\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        valueFlowUninit("typedef struct \n"
-                        "{\n"
-                        "        int flags[3];\n"
-                        "} someType_t;\n"
+        valueFlowUninit("typedef struct { int a; int b; int c; } ABC;\n" // #5777
+                        "void setabc(int x, const ABC* const abc) {\n"
+                        "    sum = abc->a + abc->b + abc->c;\n"
+                        "}\n"
                         "void f(void) {\n"
-                        "        someType_t gVar;\n"
-                        "        if(gVar.flags[1] == 42){}\n"
+                        "    ABC abc;\n"
+                        "    abc.a = 1;\n"
+                        "    setabc(123, &abc);\n"
                         "}\n");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Uninitialized variable: flags\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:17] -> [test.cpp:3:25]: (warning) Uninitialized variable: abc->b [uninitvar]\n", errout_str());
 
-        valueFlowUninit("struct pc_data {\n"
-                        "    struct {\n"
-                        "        char   * strefa;\n"
-                        "    } wampiryzm;\n"
+        valueFlowUninit("struct S { int* p; };\n" // #10463
+                        "void f(S* in) {\n"
+                        "    S* s;\n"
+                        "    memcpy(in, s, sizeof(S));\n"
+                        "    s->p = NULL;\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:4:16]: (error) Uninitialized variable: s [uninitvar]\n", errout_str());
+
+        valueFlowUninit("struct S {\n" // #11321
+                        "    int a = 0;\n"
+                        "    int b;\n"
                         "};\n"
                         "void f() {\n"
-                        "    struct pc_data *pcdata;\n"
-                        "    if ( *pcdata->wampiryzm.strefa == '\\0' ) { }\n"
+                        "    S s1;\n"
+                        "    s1.b = 1;\n"
+                        "    S s2 = s1;\n"
                         "}\n");
-        ASSERT_EQUALS("[test.cpp:8]: (error) Uninitialized variable: pcdata\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        // # 9293
-        valueFlowUninit("struct S {\n"
-                        "  int x;\n"
-                        "  int y;\n"
+        // #11460
+        valueFlowUninit("struct B { int i; };\n"
+                        "    struct H {\n"
+                        "    void e() const;\n"
+                        "    static const B b;\n"
                         "};\n"
-                        "\n"
                         "void f() {\n"
-                        "    struct S s1;\n"
-                        "    int * x = &s1.x;\n"
-                        "    struct S s2 = {*x, 0};  \n"
+                        "    H h;\n"
+                        "    h.e();\n"
                         "}\n");
-        ASSERT_EQUALS("[test.cpp:8] -> [test.cpp:9]: (error) Uninitialized variable: *x\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        valueFlowUninit("struct S {\n"
-                        "  int x;\n"
-                        "  int y;\n"
-                        "};\n"
+        // #11597
+        valueFlowUninit("void f(size_t f) {\n"
+                        "    struct {\n"
+                        "        int i;\n"
+                        "        enum { offset = 1062 };\n"
+                        "    } s;\n"
+                        "    if (f < s.offset + sizeof(s)) {}\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #11776 - function call initialises struct array member
+        valueFlowUninit("typedef struct {\n"
+                        "  int arr[1];\n"
+                        "  int count;\n"
+                        "} arr_struct;\n"
                         "\n"
-                        "void f() {\n"
-                        "    struct S s1;\n"
-                        "    struct S s2;\n"
-                        "    int * x = &s1.x;\n"
-                        "    s2.x = *x;  \n"
+                        "void init(int *a, int b);\n"
+                        "\n"
+                        "void foo(arr_struct const *var);\n" // <- inconclusive if var->count is used
+                        "\n"
+                        "void uninitvar_FP7() {\n"
+                        "  arr_struct my_st;\n"
+                        "  init(my_st.arr, 12);\n" // <- assume that my_st.arr is written
+                        "  foo(&my_st);\n"
                         "}\n");
-        ASSERT_EQUALS("[test.cpp:9] -> [test.cpp:10]: (error) Uninitialized variable: *x\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        valueFlowUninit("void f(bool * x) {\n"
-                        "    *x = false;\n"
+        valueFlowUninit("typedef struct {\n"
+                        "  int arr[1];\n"
+                        "  int count;\n"
+                        "} arr_struct;\n"
+                        "\n"
+                        "void init(int *a, int b);\n"
+                        "\n"
+                        "void foo(arr_struct const *var) {\n"
+                        "  x = var->arr[0];\n"
                         "}\n"
-                        "void g() {\n"
-                        "    bool b;\n"
-                        "    f(&b);\n"
+                        "\n"
+                        "void uninitvar_FP7() {\n"
+                        "  arr_struct my_st;\n"
+                        "  init(my_st.arr, 12);\n" // <- assume that my_st.arr is written
+                        "  foo(&my_st);\n"
                         "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        valueFlowUninit("void f(bool * x) {\n"
-                        "    if (x != nullptr)\n"
-                        "        x = 1;\n"
+        valueFlowUninit("struct S {\n" // #12188
+                        "    int i;\n"
+                        "    struct T { int j; } t;\n"
+                        "};\n"
+                        "void f() {\n"
+                        "    S s;\n"
+                        "    ++s.i;\n"
                         "}\n"
                         "void g() {\n"
-                        "    bool x;\n"
-                        "    f(&x);\n"
-                        "}\n");
-        ASSERT_EQUALS("", errout.str());
-
-        valueFlowUninit("void f() {\n"
-                        "    bool b;\n"
-                        "    bool * x = &b;\n"
-                        "    if (x != nullptr)\n"
-                        "        x = 1;\n"
+                        "    S s;\n"
+                        "    s.i--;\n"
+                        "}\n"
+                        "void h() {\n"
+                        "    S s;\n"
+                        "    s.i &= 3;\n"
+                        "}\n"
+                        "void k() {\n"
+                        "    S s;\n"
+                        "    if (++s.i < 3) {}\n"
+                        "}\n"
+                        "void m() {\n"
+                        "    S s;\n"
+                        "    ++s.t.j;\n"
+                        "}\n"
+                        "void n() {\n"
+                        "    S s;\n"
+                        "    if (s.t.j-- < 3) {}\n"
                         "}\n");
-        ASSERT_EQUALS("", errout.str());
-
-        valueFlowUninit("struct A { bool b; };"
-                        "void f(A * x) {\n"
-                        "    x->b = false;\n"
+        ASSERT_EQUALS("[test.cpp:7:9]: (error) Uninitialized variable: s.i [uninitvar]\n"
+                      "[test.cpp:11:7]: (error) Uninitialized variable: s.i [uninitvar]\n"
+                      "[test.cpp:15:7]: (error) Uninitialized variable: s.i [uninitvar]\n"
+                      "[test.cpp:19:13]: (error) Uninitialized variable: s.i [uninitvar]\n"
+                      "[test.cpp:23:11]: (error) Uninitialized variable: s.t.j [uninitvar]\n"
+                      "[test.cpp:27:13]: (error) Uninitialized variable: s.t.j [uninitvar]\n",
+                      errout_str());
+
+        valueFlowUninit("struct S { int x; };\n" // #6933
+                        "void f() {\n"
+                        "    int i;\n"
+                        "    S s(i);\n"
                         "}\n"
                         "void g() {\n"
-                        "    A b;\n"
-                        "    f(&b);\n"
+                        "    int i;\n"
+                        "    S t{ i };\n"
+                        "}\n"
+                        "void h() {\n"
+                        "    int i;\n"
+                        "    std::vector<int> v(i);\n"
                         "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9]: (error) Uninitialized variable: i [uninitvar]\n"
+                      "[test.cpp:8:10]: (error) Uninitialized variable: i [uninitvar]\n"
+                      "[test.cpp:12:24]: (error) Uninitialized variable: i [uninitvar]\n",
+                      errout_str());
 
-        valueFlowUninit("std::string f() {\n"
-                        "    std::ostringstream ostr;\n"
-                        "    ostr << \"\";\n"
-                        "    return ostr.str();\n"
+        valueFlowUninit("struct S {\n"
+                        "    S(char**);\n"
+                        "    int i;\n"
+                        "};\n"
+                        "void f() {\n"
+                        "    char* p;\n"
+                        "    S s(&p);\n"
                         "}\n");
-        ASSERT_EQUALS("", errout.str());
-        // #9281
-        valueFlowUninit("struct s {\n"
-                        "    char a[20];\n"
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct S {\n" // #12354
+                        "    int i{};\n"
+                        "    void f();\n"
                         "};\n"
-                        "void c(struct s *sarg) {\n"
-                        "    sarg->a[0] = '\\0';\n"
-                        "}\n"
-                        "void b(struct s *sarg) {\n"
-                        "    c(sarg);\n"
-                        "}\n"
-                        "void a() {\n"
-                        "    struct s s1;\n"
-                        "    b(&s1);\n"
+                        "void f(bool b) {\n"
+                        "    S* p;\n"
+                        "    if (b)\n"
+                        "        p = new S();\n"
+                        "    p->f();\n"
                         "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:9] -> [test.cpp:9:5]: (warning) Uninitialized variable: p [uninitvar]\n", errout_str());
 
-        // # 9290
-        valueFlowUninit("struct A {\n"
-                        "    double x;\n"
+        // #12461
+        valueFlowUninit("struct stry_type {\n"
+                        "  void *out;\n"
                         "};\n"
-                        "double b() {\n"
-                        "    A * c;\n"
-                        "    c->x = 42;\n"
-                        "    return c->x;\n"
+                        "void bar(str_type *items);\n"
+                        "void foo() {\n"
+                        "  str_type st_arr[1];\n"
+                        "  char arr[5];\n"
+                        "  st_arr[0].out = &arr;\n"
+                        "  bar(st_arr);\n"
+                        "  int len = strlen(arr);\n"
                         "}\n");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Uninitialized variable: c\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        valueFlowUninit("struct A {\n"
-                        "    double x;\n"
+        valueFlowUninit("struct stry_type {\n"
+                        "  void *out;\n"
                         "};\n"
-                        "double b() {\n"
-                        "    A c;\n"
-                        "    c.x = 42;\n"
-                        "    return c.x;\n"
+                        "void foo() {\n"
+                        "  str_type st_arr[1];\n"
+                        "  char arr[5];\n"
+                        "  st_arr[0].out = &arr;\n"
+                        "  int len = strlen(arr);\n"
                         "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:20]: (error) Uninitialized variable: arr [uninitvar]\n", errout_str());
 
-        valueFlowUninit("struct A {\n"
-                        "    double x;\n"
+        valueFlowUninit("struct S {\n"
+                        "  void *out;\n"
                         "};\n"
-                        "double d(A * e) {\n"
-                        "    e->x = 42;\n"
-                        "    return e->x;\n"
-                        "}\n"
-                        "double b() {\n"
-                        "    A c;\n"
-                        "    return d(&c);\n"
+                        "void bar(S* s);\n"
+                        "void foo() {\n"
+                        "  S s[1][1];\n"
+                        "  char arr[5];\n"
+                        "  s[0][0].out = &arr;\n"
+                        "  bar(s[0]);\n"
+                        "  int len = strlen(arr);\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct S1 { int x; };\n" // #12401
+                        "struct S2 { struct S1 s1; };\n"
+                        "struct S2 f() {\n"
+                        "    struct S2 s2;\n"
+                        "    struct S1* s1 = &s2.s1;\n"
+                        "    s1->x = 0;\n"
+                        "    return s2;\n"
                         "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        // # 9302
-        valueFlowUninit("struct VZ   {\n"
-                        "    double typ;\n"
+        valueFlowUninit("struct S {\n" // #12685
+                        "    explicit S(double v);\n"
+                        "    double m;\n"
                         "};\n"
-                        "void read() {\n"
-                        "    struct VZ vz;\n"
-                        "    struct VZ* pvz = &vz;\n"
-                        "    vz.typ      = 42;\n"
-                        "    if (pvz->typ == 0)\n"
-                        "        return;\n"
+                        "void f() {\n"
+                        "    double d;\n"
+                        "    S s(d);\n"
                         "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:9]: (error) Uninitialized variable: d [uninitvar]\n", errout_str());
 
-        // # 9305
-        valueFlowUninit("struct kf {\n"
-                        "    double x;\n"
+        valueFlowUninit("struct S {\n"
+                        "    explicit S(double v) : m(v) {}\n"
+                        "    double m;\n"
                         "};\n"
-                        "void set(kf* k) {\n"
-                        "    k->x = 0;\n"
-                        "}\n"
-                        "void cal() {\n"
-                        "    KF b;\n"
-                        "    KF* pb = &b;\n"
-                        "    set( pb);\n"
-                        "    if (pb->x)\n"
-                        "        return;\n"
+                        "void f() {\n"
+                        "    double d;\n"
+                        "    S s{ d };\n"
                         "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:10]: (error) Uninitialized variable: d [uninitvar]\n", errout_str());
 
-        // # 9348
-        valueFlowUninit("void f(int *a) {\n"
-                        "  int b = 0;\n"
-                        "  memcpy(a, &b, sizeof(b));\n"
-                        "}\n"
-                        "void g() {\n"
-                        "  int i;\n"
-                        "  f(&i);\n"
+        valueFlowUninit("struct S { int x; int y; };\n"
+                        "int f() {\n"
+                        "  S s;\n"
+                        "  s.x = 0;\n"
+                        "  return (&s)->x;\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct S { int x; int y; };\n"
+                        "int f() {\n"
+                        "  S s;\n"
+                        "  s.x = 0;\n"
+                        "  return (&s)->y;\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:5:16]: (error) Uninitialized variable: s.y [uninitvar]\n", errout_str());
+    }
+
+    void valueFlowUninitForLoop()
+    {
+        valueFlowUninit("void f() {\n" // #9924
+                        "    for (unsigned int a = 0, b; a < 42; a++) {\n"
+                        "        std::cout << ++b << std::endl;\n"
+                        "    }\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:3:24]: (error) Uninitialized variable: b [uninitvar]\n", errout_str());
+
+        // #14137
+        valueFlowUninit("int f(int n) {\n"
+                        "    int x;\n"
+                        "    assert(n > 0);\n"
+                        "    for(int i=0;i<n;i++)\n"
+                        "        x = n;\n"
+                        "    return x;\n"
                         "}\n");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitvar_memberfunction() {
@@ -4469,8 +7806,18 @@ class TestUninitVar : public TestFixture {
                         "void f() {\n"
                         "    C *c;\n"
                         "    if (c->x() == 4) {}\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:6:9]: (error) Uninitialized variable: c [uninitvar]\n", errout_str());
+
+        valueFlowUninit("struct A { \n"
+                        "    int i; \n"
+                        "    void f();\n"
+                        "};\n"
+                        "void g() {\n"
+                        "    A a;\n"
+                        "    a.f();\n"
                         "}\n");
-        ASSERT_EQUALS("[test.cpp:6]: (error) Uninitialized variable: c\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void uninitvar_nonmember() {
@@ -4480,9 +7827,37 @@ class TestUninitVar : public TestFixture {
                         "\n"
                         "int main() {\n"
                         "  Foo* foo;\n"
-                        "  foo.b\n"
-                        "}\n");
-        ASSERT_EQUALS("[test.cpp:7]: (error) Uninitialized variable: foo\n", errout.str());
+                        "  foo->bar = 3;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:7:3]: (error) Uninitialized variable: foo [uninitvar]\n", errout_str());
+    }
+
+    void uninitvarDesignatedInitializers() {
+        checkUninitVar("struct a { int b; };\n"
+                       "int main() {\n"
+                       "  char *b;\n"
+                       "  extern int f(struct a *);\n"
+                       "  return f(&(struct a){.b = 0});\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+
+        checkUninitVar("struct a { int b, c; };\n"
+                       "int main() {\n"
+                       "  char *c;\n"
+                       "  extern int f(struct a *);\n"
+                       "  return f(&(struct a){.b = 0, .c = 0});\n"
+                       "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void uninitvarMemberPointer() {
+        checkUninitVar("void f()\n"
+                       "{\n"
+                       "  struct S {};\n"
+                       "  int S::* mp;\n"
+                       "  if (mp) {}\n"
+                       "}\n");
+        ASSERT_EQUALS("[test.cpp:5:7]: (error) Uninitialized variable: mp [legacyUninitvar]\n", errout_str());
     }
 
     void isVariableUsageDeref() {
@@ -4491,57 +7866,207 @@ class TestUninitVar : public TestFixture {
                        "    char a[10];\n"
                        "    char c = *a;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:15]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
+        // extracttests.start: extern const int SIZE;
         checkUninitVar("void f() {\n"
                        "    char a[SIZE+10];\n"
                        "    char c = *a;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:15]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    char a[10];\n"
                        "    *a += 10;\n"
                        "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Uninitialized variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:6]: (error) Uninitialized variable: a [legacyUninitvar]\n", errout_str());
 
         checkUninitVar("void f() {\n"
                        "  int a[10][10];\n"
                        "  dostuff(*a);\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkUninitVar("void f() {\n"
                        "    void (*fp[1]) (void) = {function1};\n"
                        "    (*fp[0])();\n"
                        "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void ctu(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
+    void isVariableUsageDerefValueflow()
+    {
+        // *p
+        valueFlowUninit("void f() {\n"
+                        "    char a[10];\n"
+                        "    char c = *a;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:14]: (error) Uninitialized variable: *a [uninitvar]\n", errout_str());
 
-        // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        // extracttests.start: extern const int SIZE;
+        valueFlowUninit("void f() {\n"
+                        "    char a[SIZE+10];\n"
+                        "    char c = *a;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:14]: (error) Uninitialized variable: *a [uninitvar]\n", errout_str());
 
-        CTU::FileInfo *ctu = CTU::getFileInfo(&tokenizer);
+        valueFlowUninit("void f() {\n"
+                        "    char a[10];\n"
+                        "    *a += 10;\n"
+                        "}");
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) Uninitialized variable: *a [uninitvar]\n", errout_str());
 
-        // Check code..
-        std::list<Check::FileInfo*> fileInfo;
-        CheckUninitVar check(&tokenizer, &settings, this);
-        fileInfo.push_back(check.getFileInfo(&tokenizer, &settings));
-        check.analyseWholeProgram(ctu, fileInfo, settings, *this);
-        while (!fileInfo.empty()) {
-            delete fileInfo.back();
-            fileInfo.pop_back();
-        }
-        delete ctu;
+        valueFlowUninit("void f() {\n"
+                        "  int a[10][10];\n"
+                        "  dostuff(*a);\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void f() {\n"
+                        "    void (*fp[1]) (void) = {function1};\n"
+                        "    (*fp[0])();\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("template <typename T, int value> T Get() {return value;}\n"
+                        "char f() {\n"
+                        "  char buf[10];\n"
+                        "  for(int i = 0; i < Get<int,10>() ; ++i) \n"
+                        "     buf[i] = 0;\n"
+                        "  return buf[0];\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("static void Foo(double* p) {\n"
+                        " p[0] = 0;\n"
+                        " p[1] = 0;\n"
+                        " p[2] = 0;\n"
+                        " p[3] = 0;\n"
+                        "}\n"
+                        "double f() {\n"
+                        "  double L[2][2];\n"
+                        "  Foo(*L);\n"
+                        "  return L[0][0];\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("void f() {\n" // #11305
+                        "    type_t a;\n"
+                        "    a[0] = 0;\n"
+                        "}\n", false);
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void uninitvar_memberaccess() {
+        valueFlowUninit("struct foo{char *bar;};\n"
+                        "void f(unsigned long long *p) {\n"
+                        "    foo a;\n"
+                        "    ((&a)->bar) =  reinterpret_cast<char*>(*p);\n"
+                        "    if ((&a)->bar) ;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct foo{char *bar;};\n"
+                        "void f(unsigned long long *p) {\n"
+                        "    foo a;\n"
+                        "    ((&(a))->bar) =  reinterpret_cast<char*>(*p);\n"
+                        "    if ((&a)->bar) ;\n"
+                        "}");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct A {\n" // #10200
+                        "    struct B {\n"
+                        "        int i;\n"
+                        "    };\n"
+                        "    int j;\n"
+                        "};\n"
+                        "void f(std::vector<A::B>& x) {\n"
+                        "    A::B b;\n"
+                        "    b.i = 123;\n"
+                        "    x.push_back(b);\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct A {\n"
+                        "    struct B {\n"
+                        "        int i;\n"
+                        "    };\n"
+                        "    int j;\n"
+                        "};\n"
+                        "void f(std::vector<A::B>& x) {\n"
+                        "    A::B b;\n"
+                        "    x.push_back(b);\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:9:17]: (error) Uninitialized variable: b [uninitvar]\n", errout_str());
+
+        valueFlowUninit("struct A {\n"
+                        "    struct B {\n"
+                        "        int i;\n"
+                        "    };\n"
+                        "    int j;\n"
+                        "};\n"
+                        "void f(std::vector<A>&x) {\n"
+                        "    A a;\n"
+                        "    a.j = 123;\n"
+                        "    x.push_back(a);\n"
+                        "}\n");
+
+        valueFlowUninit("struct A {\n"
+                        "    struct B {\n"
+                        "        int i;\n"
+                        "    };\n"
+                        "    int j;\n"
+                        "};\n"
+                        "void f(std::vector<A>& x) {\n"
+                        "    A a;\n"
+                        "    x.push_back(a);\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:9:17]: (error) Uninitialized variable: a [uninitvar]\n", errout_str());
+
+        valueFlowUninit("struct S { struct T { int* p; } t[2]; };\n" // #11018
+                        "void f() {\n"
+                        "    S s;\n"
+                        "    *&s.t[0].p = 0;\n"
+                        "}\n"
+                        "void g() {\n"
+                        "    S s;\n"
+                        "    ((*&(*&s.t[0].p))) = 0;\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct S { int i; };\n" // #6323
+                        "void f() {\n"
+                        "    struct S s;\n"
+                        "    int x = -3;\n"
+                        "    int y = x < (1, s.i);\n"
+                        "}\n");
+        ASSERT_EQUALS("[test.cpp:5:23]: (error) Uninitialized variable: s.i [uninitvar]\n", errout_str());
+
+        valueFlowUninit("struct S { int x; };\n" // #11353
+                        "struct S f() {\n"
+                        "    struct S s;\n"
+                        "    int* p = &s.x;\n"
+                        "    *p = 0;\n"
+                        "    return s;\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        valueFlowUninit("struct S { int i; };\n" // #14191
+                        "bool g(S*);\n"
+                        "void f( struct S *p) {\n"
+                        "    struct S s;\n"
+                        "    if (!p) {\n"
+                        "        p = &s;\n"
+                        "        if (g(p))\n"
+                        "            return;\n"
+                        "    }\n"
+                        "    printf(\"%i\", p->i);\n"
+                        "    p = &s;\n"
+                        "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void ctu() {
+    void ctuTest() {
         ctu("void f(int *p) {\n"
             "    a = *p;\n"
             "}\n"
@@ -4549,7 +8074,7 @@ class TestUninitVar : public TestFixture {
             "  int x;\n"
             "  f(&x);\n"
             "}");
-        ASSERT_EQUALS("[test.cpp:6] -> [test.cpp:2]: (error) Using argument p that points at uninitialized variable x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:4] -> [test.cpp:2:10]: (error) Using argument p that points at uninitialized variable x [ctuuninitvar]\n", errout_str());
 
         ctu("void use(int *p) { a = *p + 3; }\n"
             "void call(int x, int *p) { x++; use(p); }\n"
@@ -4557,7 +8082,7 @@ class TestUninitVar : public TestFixture {
             "  int x;\n"
             "  call(4,&x);\n"
             "}");
-        ASSERT_EQUALS("[test.cpp:5] -> [test.cpp:2] -> [test.cpp:1]: (error) Using argument p that points at uninitialized variable x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:7] -> [test.cpp:2:33] -> [test.cpp:1:25]: (error) Using argument p that points at uninitialized variable x [ctuuninitvar]\n", errout_str());
 
         ctu("void dostuff(int *x, int *y) {\n"
             "  if (!var)\n"
@@ -4569,7 +8094,7 @@ class TestUninitVar : public TestFixture {
             "  int x;\n"
             "  dostuff(a, &x);\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         ctu("void dostuff(int *x, int *y) {\n"
             "  if (cond)\n"
@@ -4581,7 +8106,7 @@ class TestUninitVar : public TestFixture {
             "  int x;\n"
             "  dostuff(a, &x);\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         ctu("void f(int *p) {\n"
             "    a = sizeof(*p);\n"
@@ -4590,7 +8115,51 @@ class TestUninitVar : public TestFixture {
             "  int x;\n"
             "  f(&x);\n"
             "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        ctu("void f(int *v) {\n"
+            "  std::cin >> *v;\n"
+            "}\n"
+            "int main() {\n"
+            "  int x;\n"
+            "  f(&x);\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        ctu("void increment(int& i) { ++i; }\n" // #6475
+            "int f() {\n"
+            "    int n;\n"
+            "    increment(n);\n"
+            "    return n;\n"
+            "}\n");
+        ASSERT_EQUALS("[test.cpp:4:14] -> [test.cpp:1:28]: (error) Using argument i that points at uninitialized variable n [ctuuninitvar]\n", errout_str());
+
+        ctu("void increment(int* i) { ++(*i); }\n"
+            "int f() {\n"
+            "    int n;\n"
+            "    increment(&n);\n"
+            "    return n;\n"
+            "}\n");
+        ASSERT_EQUALS("[test.cpp:4:14] -> [test.cpp:1:30]: (error) Using argument i that points at uninitialized variable n [ctuuninitvar]\n", errout_str());
+
+        ctu("typedef struct { int type; int id; } Stem;\n"
+            "void lookupStem(recodeCtx h, Stem *stem) {\n"
+            "    i = stem->type & STEM_VERT;\n"
+            "}\n"
+            "void foo() {\n"
+            "    Stem stem;\n"
+            "    stem.type = 0;\n"
+            "    lookupStem(h, &stem);\n"
+            "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        ctu("void increment(int& i) { ++i; }\n" // #6475
+            "int f() {\n"
+            "    int n;\n"
+            "    increment(n);\n"
+            "    return n;\n"
+            "}\n");
+        ASSERT_EQUALS("[test.cpp:4:14] -> [test.cpp:1:28]: (error) Using argument i that points at uninitialized variable n [ctuuninitvar]\n", errout_str());
     }
 };
 
diff --git a/test/testunusedfunctions.cpp b/test/testunusedfunctions.cpp
index 8382a98b98c..cf027e01d79 100644
--- a/test/testunusedfunctions.cpp
+++ b/test/testunusedfunctions.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,28 +17,28 @@
  */
 
 #include "checkunusedfunctions.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "platform.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
 
-#include <ostream>
+#include <cstddef>
 #include <string>
 
 class TestUnusedFunctions : public TestFixture {
 public:
-    TestUnusedFunctions() : TestFixture("TestUnusedFunctions") {
-    }
+    TestUnusedFunctions() : TestFixture("TestUnusedFunctions") {}
 
 private:
-    Settings settings;
-
-    void run() OVERRIDE {
-        settings.addEnabled("style");
+    const Settings settings = settingsBuilder().severity(Severity::style).build();
 
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(incondition);
         TEST_CASE(return1);
         TEST_CASE(return2);
+        TEST_CASE(return3);
         TEST_CASE(callback1);
         TEST_CASE(callback2);
         TEST_CASE(else1);
@@ -46,16 +46,26 @@ class TestUnusedFunctions : public TestFixture {
         TEST_CASE(template1);
         TEST_CASE(template2);
         TEST_CASE(template3);
+        TEST_CASE(template4); // #9805
+        TEST_CASE(template5);
+        TEST_CASE(template6); // #10475 crash
+        TEST_CASE(template7); // #9766 crash
+        TEST_CASE(template8);
+        TEST_CASE(template9);
+        TEST_CASE(template10);
         TEST_CASE(throwIsNotAFunction);
         TEST_CASE(unusedError);
         TEST_CASE(unusedMain);
         TEST_CASE(initializationIsNotAFunction);
         TEST_CASE(operator1);   // #3195
+        TEST_CASE(operator2);   // #7974
         TEST_CASE(returnRef);
         TEST_CASE(attribute); // #3471 - FP __attribute__(constructor)
         TEST_CASE(initializer_list);
         TEST_CASE(member_function_ternary);
         TEST_CASE(boost);
+        TEST_CASE(enumValues);
+        TEST_CASE(recursive);
 
         TEST_CASE(multipleFiles);   // same function name in multiple files
 
@@ -64,28 +74,56 @@ class TestUnusedFunctions : public TestFixture {
         TEST_CASE(ignore_declaration); // ignore declaration
 
         TEST_CASE(operatorOverload);
+
+        TEST_CASE(entrypointsWin);
+        TEST_CASE(entrypointsWinU);
+        TEST_CASE(entrypointsUnix);
+
+        TEST_CASE(virtualFunc);
+        TEST_CASE(parensInit);
+        TEST_CASE(typeInCast);
+        TEST_CASE(attributeCleanup);
+        TEST_CASE(attributeUnused);
+        TEST_CASE(attributeMaybeUnused);
+        TEST_CASE(staticFunction);
     }
 
-    void check(const char code[], Settings::PlatformType platform = Settings::Native) {
-        // Clear the error buffer..
-        errout.str("");
+    struct CheckOptions
+    {
+        Platform::Type platform = Platform::Type::Native;
+        bool cpp = true;
+    };
+
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
+        // TODO: avoid copy
+        const Settings settings1 = (options.platform == Platform::Type::Native) ? settings : settingsBuilder(settings).platform(options.platform).build();
 
-        settings.platform(platform);
+        check_(file, line, code, settings1, options.cpp);
+    }
+
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const Settings& settings1, bool cpp = true) {
+        SimpleTokenizer tokenizer(settings1, *this, cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
+        // Check for unused functions..
+        CheckUnusedFunctions checkUnusedFunctions;
+        checkUnusedFunctions.parseTokens(tokenizer, settings1);
+        (checkUnusedFunctions.check)(settings1, *this); // TODO: check result
+    }
+
+    // TODO: get rid of this
+    void check_(const char* file, int line, const std::string& code ) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check for unused functions..
-        CheckUnusedFunctions checkUnusedFunctions(&tokenizer, &settings, this);
-        checkUnusedFunctions.parseTokens(tokenizer,  "someFile.c", &settings);
-        // check() returns error if and only if errout is not empty.
-        if (checkUnusedFunctions.check(this, settings)) {
-            ASSERT(errout.str() != "");
-        } else {
-            ASSERT_EQUALS("", errout.str());
-        }
+        CheckUnusedFunctions checkUnusedFunctions;
+        checkUnusedFunctions.parseTokens(tokenizer, settings);
+        (checkUnusedFunctions.check)(settings, *this); // TODO: check result
     }
 
     void incondition() {
@@ -94,7 +132,7 @@ class TestUnusedFunctions : public TestFixture {
               "    if (f1())\n"
               "    { }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:5]: (style) The function 'f1' is never used. [unusedFunction]\n", errout_str());
     }
 
     void return1() {
@@ -102,15 +140,33 @@ class TestUnusedFunctions : public TestFixture {
               "{\n"
               "    return f1();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:5]: (style) The function 'f1' is never used. [unusedFunction]\n", errout_str());
     }
 
     void return2() {
         check("char * foo()\n"
               "{\n"
-              "    return *foo();\n"
+              "    return foo();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:8]: (style) The function 'foo' is never used. [unusedFunction]\n", errout_str());
+    }
+
+    void return3() {
+        check("typedef void (*VoidFunc)();\n" // #9602
+              "void sayHello() {\n"
+              "  printf(\"Hello World\\n\");\n"
+              "}\n"
+              "VoidFunc getEventHandler() {\n"
+              "  return sayHello;\n"
+              "}\n"
+              "void indirectHello() {\n"
+              "  VoidFunc handler = getEventHandler();\n"
+              "  handler();\n"
+              "}\n"
+              "int main() {\n"
+              "  indirectHello();\n"
+              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void callback1() {
@@ -118,7 +174,7 @@ class TestUnusedFunctions : public TestFixture {
               "{\n"
               "    void (*f)() = cond ? f1 : NULL;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:6]: (style) The function 'f1' is never used. [unusedFunction]\n", errout_str());
     }
 
     void callback2() { // #8677
@@ -131,7 +187,7 @@ class TestUnusedFunctions : public TestFixture {
               "void C::callback() {}\n" // <- not unused
               "\n"
               "void C::start() { ev.set<C, &C::callback>(this); }");
-        ASSERT_EQUALS("[test.cpp:9]: (style) The function 'start' is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:9]: (style) The function 'start' is never used. [unusedFunction]\n", errout_str());
     }
 
     void else1() {
@@ -140,7 +196,7 @@ class TestUnusedFunctions : public TestFixture {
               "    if (cond) ;\n"
               "    else f1();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:6]: (style) The function 'f1' is never used. [unusedFunction]\n", errout_str());
     }
 
     void functionpointer() {
@@ -149,14 +205,14 @@ class TestUnusedFunctions : public TestFixture {
               "    f(&foo);\n"
               "    return 0\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void foo() { }\n"
               "int main() {\n"
               "    f(&::foo);\n"
               "    return 0\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("namespace abc {\n"
               "    void foo() { }\n"
@@ -165,7 +221,7 @@ class TestUnusedFunctions : public TestFixture {
               "    f(&abc::foo);\n"
               "    return 0\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("namespace abc {\n"
               "    void foo() { }\n"
@@ -174,7 +230,7 @@ class TestUnusedFunctions : public TestFixture {
               "    f = &abc::foo;\n"
               "    return 0\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("namespace abc {\n"
               "    void foo() { }\n"
@@ -183,7 +239,7 @@ class TestUnusedFunctions : public TestFixture {
               "    f = &::abc::foo;\n"
               "    return 0\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("namespace abc {\n"  // #3875
               "    void foo() { }\n"
@@ -192,7 +248,18 @@ class TestUnusedFunctions : public TestFixture {
               "    f(abc::foo);\n"
               "    return 0\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        check("template <class T> T f()\n" // #13117
+              "{\n"
+              "    return T(1);\n"
+              "}\n"
+              "int main(void)\n"
+              "{\n"
+              "    auto *ptr = &f<int>;\n"
+              "    return ptr();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void template1() {
@@ -203,7 +270,7 @@ class TestUnusedFunctions : public TestFixture {
               "    foo<int>();\n"
               "    return 0\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void template2() {
@@ -215,7 +282,7 @@ class TestUnusedFunctions : public TestFixture {
               "}\n"
               "\n"
               "void h() { g<int>(); h(); }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:6]: (style) The function 'h' is never used. [unusedFunction]\n", errout_str());
     }
 
     void template3() { // #4701
@@ -225,111 +292,230 @@ class TestUnusedFunctions : public TestFixture {
               "private:\n"
               "    template<typename T> void foo( T t ) const;\n"
               "};\n"
-              "template<typename T> void X::foo( T t ) const { }\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) The function 'bar' is never used.\n", errout.str());
+              "template<typename T> void X::foo( T t ) const { }");
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The function 'bar' is never used. [unusedFunction]\n", errout_str());
+    }
+
+    void template4() { // #9805
+        check("struct A {\n"
+              "    int a = 0;\n"
+              "    void f() { a = 1; }\n"
+              "    template <typename T, typename... Args> auto call(const Args &... args) -> T {\n"
+              "        a = 2;\n"
+              "        return T{};\n"
+              "    }\n"
+              "};\n"
+              "\n"
+              "struct B : public A {\n"
+              "    void test() {\n"
+              "        f();\n"
+              "        call<int>(1, 2, 3);\n"
+              "        test();\n"
+              "    }\n"
+              "};");
+        ASSERT_EQUALS("[test.cpp:11:10]: (style) The function 'test' is never used. [unusedFunction]\n", errout_str());
+    }
+
+    void template5() { // #9220
+        check("void f(){}\n"
+              "\n"
+              "typedef void(*Filter)();\n"
+              "\n"
+              "template <Filter fun>\n"
+              "void g() { fun(); }\n"
+              "\n"
+              "int main() { g<f>(); return 0;}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void template6() { // #10475
+        check("template<template<typename...> class Ref, typename... Args>\n"
+              "struct Foo<Ref<Args...>, Ref> : std::true_type {};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void template7()
+    { // #9766
+        check("void f() {\n"
+              "    std::array<std::array<double,3>,3> array;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:6]: (style) The function 'f' is never used. [unusedFunction]\n", errout_str());
+    }
+
+    void template8() { // #11485
+        check("struct S {\n"
+              "    template<typename T>\n"
+              "    void tf(const T&) { }\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) The function 'tf' is never used. [unusedFunction]\n", errout_str());
+
+        check("struct C {\n"
+              "    template<typename T>\n"
+              "    void tf(const T&) { }\n"
+              "};\n"
+              "int main() {\n"
+              "    C c;\n"
+              "    c.tf(1.5);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct C {\n"
+              "    template<typename T>\n"
+              "    void tf(const T&) { }\n"
+              "};\n"
+              "int main() {\n"
+              "    C c;\n"
+              "    c.tf<int>(1);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void template9() {
+        check("template<class T>\n" // #7739
+              "void f(T const& t) {}\n"
+              "template<class T>\n"
+              "void g(T const& t) {\n"
+              "    f(t);\n"
+              "}\n"
+              "template<>\n"
+              "void f<double>(double const& d) {}\n"
+              "int main() {\n"
+              "    g(2);\n"
+              "    g(3.14);\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("template <typename T> T f(T);\n" // #9222
+              "template <typename T> T f(T i) { return i; }\n"
+              "template int f<int>(int);\n"
+              "int main() { return f(int(2)); }\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void template10() {
+        check("template<typename T>\n" // #12013, don't crash
+              "struct S {\n"
+              "    static const int digits = std::numeric_limits<T>::digits;\n"
+              "    using type = std::conditional<digits < 32, std::int32_t, std::int64_t>::type;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void throwIsNotAFunction() {
         check("struct A {void f() const throw () {}}; int main() {A a; a.f();}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void unusedError() {
         check("void foo() {}\n"
-              "int main()\n");
-        ASSERT_EQUALS("[test.cpp:1]: (style) The function 'foo' is never used.\n", errout.str());
+              "int main()");
+        ASSERT_EQUALS("[test.cpp:1:6]: (style) The function 'foo' is never used. [unusedFunction]\n", errout_str());
 
         check("void foo() const {}\n"
-              "int main()\n");
-        ASSERT_EQUALS("[test.cpp:1]: (style) The function 'foo' is never used.\n", errout.str());
+              "int main()");
+        ASSERT_EQUALS("[test.cpp:1:6]: (style) The function 'foo' is never used. [unusedFunction]\n", errout_str());
 
         check("void foo() const throw() {}\n"
-              "int main()\n");
-        ASSERT_EQUALS("[test.cpp:1]: (style) The function 'foo' is never used.\n", errout.str());
+              "int main()");
+        ASSERT_EQUALS("[test.cpp:1:6]: (style) The function 'foo' is never used. [unusedFunction]\n", errout_str());
 
         check("void foo() throw() {}\n"
-              "int main()\n");
-        ASSERT_EQUALS("[test.cpp:1]: (style) The function 'foo' is never used.\n", errout.str());
+              "int main()");
+        ASSERT_EQUALS("[test.cpp:1:6]: (style) The function 'foo' is never used. [unusedFunction]\n", errout_str());
     }
 
     void unusedMain() {
         check("int main() { }");
-        ASSERT_EQUALS("", errout.str());
-
-        check("int _tmain() { }", Settings::Win32A);
-        ASSERT_EQUALS("", errout.str());
-
-        check("int WinMain() { }", Settings::Win32A);
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void initializationIsNotAFunction() {
         check("struct B: N::A {\n"
               "  B(): N::A() {};\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void operator1() {
         check("struct Foo { void operator()(int a) {} };");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Foo { operator std::string(int a) {} };");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void operator2() { // #7974
+        check("bool operator==(const data_t& a, const data_t& b) {\n"
+              "    return (a.fd == b.fd);\n"
+              "}\n"
+              "bool operator==(const event& a, const event& b) {\n"
+              "    return ((a.events == b.events) && (a.data == b.data));\n"
+              "}\n"
+              "int main(event a, event b) {\n"
+              "    return a == b;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void returnRef() {
         check("int& foo() {return x;}");
-        ASSERT_EQUALS("[test.cpp:1]: (style) The function 'foo' is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:1:6]: (style) The function 'foo' is never used. [unusedFunction]\n", errout_str());
     }
 
     void attribute() { // #3471 - FP __attribute__((constructor))
         check("void __attribute__((constructor)) f() {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void __attribute__((constructor(1000))) f() {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void __attribute__((destructor)) f() {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void __attribute__((destructor(1000))) f() {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // alternate syntax
         check("__attribute__((constructor)) void f() {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("__attribute__((constructor(1000))) void f() {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("__attribute__((destructor)) void f() {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("__attribute__((destructor(1000))) void f() {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // alternate syntax
         check("void f() __attribute__((constructor));\n"
               "void f() { }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() __attribute__((constructor(1000)));\n"
               "void f() { }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() __attribute__((destructor));\n"
               "void f() { }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void f() __attribute__((destructor(1000)));\n"
               "void f() { }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // Don't crash on wrong syntax
         check("int x __attribute__((constructor));\n"
-              "int x __attribute__((destructor));");
-        ASSERT_EQUALS("", errout.str());
+              "int y __attribute__((destructor));");
+
+        // #10661
+        check("extern \"C\" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t dataSize) { return 0; }\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("[[maybe_unused]] void f() {}\n" // #13268
+              "__attribute__((unused)) void g() {}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void initializer_list() {
@@ -339,7 +525,7 @@ class TestUnusedFunctions : public TestFixture {
               "    {}\n"
               "int m_i;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #8580
         check("int foo() { return 12345; }\n"
@@ -350,7 +536,7 @@ class TestUnusedFunctions : public TestFixture {
               "  A() : a(bar([] { return foo(); })) {}\n"
               "  const int a;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void member_function_ternary() {
@@ -364,61 +550,81 @@ class TestUnusedFunctions : public TestFixture {
               "    ptr = (argc > 1 && !strcmp(argv[1], \"F2\")) ? &Foo::F2 : &Foo::F1;\n"
               "    (foo.*ptr)();\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void boost() {
-        check("static void _xy(const char *b, const char *e)\n"
-              "{}\n"
-              "parse(line, blanks_p >> ident[&_xy] >> blanks_p >> eol_p).full");
-        ASSERT_EQUALS("", errout.str());
+        check("static void _xy(const char *b, const char *e) {}\n"
+              "void f() {\n"
+              "    parse(line, blanks_p >> ident[&_xy] >> blanks_p >> eol_p).full;\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:6]: (style) The function 'f' is never used. [unusedFunction]\n", errout_str());
     }
 
-    void multipleFiles() {
-        Tokenizer tokenizer(&settings, this);
-        CheckUnusedFunctions c(&tokenizer, &settings, nullptr);
+    void enumValues() { // #11486
+        check("enum E1 { Break1 };\n"
+              "struct S {\n"
+              "    enum class E { Break };\n"
+              "    void Break() {}\n"
+              "    void Break1() {}\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: (style) The function 'Break' is never used. [unusedFunction]\n"
+                      "[test.cpp:5:10]: (style) The function 'Break1' is never used. [unusedFunction]\n",
+                      errout_str());
+
+        check("struct S {\n" // #12899
+              "    void f() {}\n"
+              "};\n"
+              "enum E { f };\n"
+              "int main() {\n"
+              "    E e{ f };\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:10]: (style) The function 'f' is never used. [unusedFunction]\n", errout_str());
+    }
+
+    void recursive() {
+        check("void f() {\n" // #8159
+              "    f();\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:1:6]: (style) The function 'f' is never used. [unusedFunction]\n",
+                      errout_str());
+    }
 
-        // Clear the error buffer..
-        errout.str("");
+    void multipleFiles() {
+        CheckUnusedFunctions c;
 
         const char code[] = "static void f() { }";
 
         for (int i = 1; i <= 2; ++i) {
-            std::ostringstream fname;
-            fname << "test" << i << ".cpp";
-
-            // Clear the error buffer..
-            errout.str("");
+            const std::string fname = "test" + std::to_string(i) + ".cpp";
 
-            Tokenizer tokenizer2(&settings, this);
-            std::istringstream istr(code);
-            tokenizer2.tokenize(istr, fname.str().c_str());
+            SimpleTokenizer tokenizer{settings, *this, fname};
+            ASSERT(tokenizer.tokenize(code));
 
-            c.parseTokens(tokenizer2, "someFile.c", &settings);
+            c.parseTokens(tokenizer, settings);
         }
 
         // Check for unused functions..
-        c.check(this, settings);
+        (c.check)(settings, *this); // TODO: check result
 
-        ASSERT_EQUALS("[test1.cpp:1]: (style) The function 'f' is never used.\n", errout.str());
+        ASSERT_EQUALS("[test1.cpp:1:13]: (style) The function 'f' is never used. [unusedFunction]\n", errout_str());
     }
 
     void lineNumber() {
-        check("void foo() {}\n"
+        check("void foo();\n"
               "void bar() {}\n"
-              "int main()\n");
-        ASSERT_EQUALS("[test.cpp:2]: (style) The function 'bar' is never used.\n"
-                      "[test.cpp:1]: (style) The function 'foo' is never used.\n", errout.str());
+              "int main() {}");
+        ASSERT_EQUALS("[test.cpp:2:6]: (style) The function 'bar' is never used. [unusedFunction]\n", errout_str());
     }
 
     void ignore_declaration() {
         check("void f();\n"
               "void f() {}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) The function 'f' is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:6]: (style) The function 'f' is never used. [unusedFunction]\n", errout_str());
 
         check("void f(void) {}\n"
-              "void (*list[])(void) = {f}");
-        ASSERT_EQUALS("", errout.str());
+              "void (*list[])(void) = {f};");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void operatorOverload() {
@@ -429,7 +635,7 @@ class TestUnusedFunctions : public TestFixture {
               "std::ostream & operator<<(std::ostream &os, const A&) {\n"
               "    os << \"This is class A\";\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class A{};\n"
               "A operator + (const A &, const A &){ return A(); }\n"
@@ -465,8 +671,8 @@ class TestUnusedFunctions : public TestFixture {
               "A operator ++ (const A &){ return A(); }\n"
               "A operator -- (const A &, const int){ return A(); }\n"
               "A operator -- (const A &){ return A(); }\n"
-              "A operator , (const A &, const A &){ return A(); }\n");
-        ASSERT_EQUALS("", errout.str());
+              "A operator , (const A &, const A &){ return A(); }");
+        ASSERT_EQUALS("", errout_str());
 
 
         check("class A {\n"
@@ -480,9 +686,147 @@ class TestUnusedFunctions : public TestFixture {
               "void * A::operator new[](std::size_t s) {\n"
               "    return malloc(s);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void entrypointsWin() {
+        check("int WinMain() { }");
+        ASSERT_EQUALS("[test.cpp:1:5]: (style) The function 'WinMain' is never used. [unusedFunction]\n", errout_str());
+
+        check("int _tmain() { }");
+        ASSERT_EQUALS("[test.cpp:1:5]: (style) The function '_tmain' is never used. [unusedFunction]\n", errout_str());
+
+        const Settings s = settingsBuilder(settings).library("windows.cfg").build();
+
+        check("int WinMain() { }", s);
+        ASSERT_EQUALS("", errout_str());
+
+        check("int _tmain() { }", s);
+        ASSERT_EQUALS("", errout_str());
     }
 
+    void entrypointsWinU() {
+        check("int wWinMain() { }");
+        ASSERT_EQUALS("[test.cpp:1:5]: (style) The function 'wWinMain' is never used. [unusedFunction]\n", errout_str());
+
+        check("int _tmain() { }");
+        ASSERT_EQUALS("[test.cpp:1:5]: (style) The function '_tmain' is never used. [unusedFunction]\n", errout_str());
+
+        const Settings s = settingsBuilder(settings).library("windows.cfg").build();
+
+        check("int wWinMain() { }", s);
+        ASSERT_EQUALS("", errout_str());
+
+        check("int _tmain() { }", s);
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void entrypointsUnix() {
+        check("int _init() { }\n"
+              "int _fini() { }\n");
+        ASSERT_EQUALS("[test.cpp:1:5]: (style) The function '_init' is never used. [unusedFunction]\n"
+                      "[test.cpp:2:5]: (style) The function '_fini' is never used. [unusedFunction]\n", errout_str());
+
+        const Settings s = settingsBuilder(settings).library("gnu.cfg").build();
+
+        check("int _init() { }\n"
+              "int _fini() { }\n", s);
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void virtualFunc()
+    {
+        check("struct D : public B {\n" // #10660
+              "    virtual void f() {}\n"
+              "    void g() override {}\n"
+              "    void h() final {}\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("struct B {\n"
+              "    virtual void f() = 0;\n"
+              "    void g();\n"
+              "};\n"
+              "struct D : B {\n"
+              "    void f() override {}\n"
+              "};\n"
+              "int main() {\n"
+              "    D d;\n"
+              "    d.g();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void parensInit()
+    {
+        check("struct S {\n" // #12898
+              "    void url() {}\n"
+              "};\n"
+              "int main() {\n"
+              "    const int url(0);\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:10]: (style) The function 'url' is never used. [unusedFunction]\n", errout_str());
+    }
+
+    void typeInCast()
+    {
+        check("struct S {\n" // #12901
+              "    void Type() {}\n"
+              "};\n"
+              "int main() {\n"
+              "    struct Type {} t;\n"
+              "    Type t2{ (Type)t };\n"
+              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:10]: (style) The function 'Type' is never used. [unusedFunction]\n", errout_str());
+    }
+
+    void attributeCleanup()
+    {
+        check("void clean(void *ptr) {}\n"
+              "int main() {\n"
+              "    void * __attribute__((cleanup(clean))) p;\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void attributeUnused()
+    {
+        check("[[unused]] void f() {}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("[[gnu::unused]] void f() {}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("__attribute__((unused)) void f() {}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void attributeMaybeUnused()
+    {
+        check("[[__maybe_unused__]] void f() {}\n", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+
+        check("[[maybe_unused]] void f() {}\n", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+
+        check("[[maybe_unused]] void f() {}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void staticFunction()
+    {
+        check("void f(void) {}\n"
+              "int main() {\n"
+              "    f();\n"
+              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("void f(void) {}\n"
+              "int main() {\n"
+              "    f();\n"
+              "}\n", dinit(CheckOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:1:6]: (style) The function 'f' should have static linkage since it is not used outside of its translation unit. [staticFunction]\n", errout_str());
+    }
 };
 
 REGISTER_TEST(TestUnusedFunctions)
diff --git a/test/testunusedprivfunc.cpp b/test/testunusedprivfunc.cpp
index 81c13c439a2..5a364347163 100644
--- a/test/testunusedprivfunc.cpp
+++ b/test/testunusedprivfunc.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,32 +17,31 @@
  */
 
 #include "checkclass.h"
+#include "errortypes.h"
+#include "helpers.h"
 #include "platform.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
+#include "fixture.h"
 
-#include <simplecpp.h>
-#include <map>
-#include <vector>
+#include <cstddef>
+#include <string>
 
 class TestUnusedPrivateFunction : public TestFixture {
 public:
-    TestUnusedPrivateFunction() : TestFixture("TestUnusedPrivateFunction") {
-    }
+    TestUnusedPrivateFunction() : TestFixture("TestUnusedPrivateFunction") {}
 
 private:
-    Settings settings;
-
-    void run() OVERRIDE {
-        settings.addEnabled("style");
+    const Settings settings = settingsBuilder().severity(Severity::style).build();
 
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(test1);
         TEST_CASE(test2);
         TEST_CASE(test3);
         TEST_CASE(test4);
         TEST_CASE(test5);
         TEST_CASE(test6); // ticket #2602
+        TEST_CASE(test7); // ticket #9282
 
         // [ 2236547 ] False positive --style unused function, called via pointer
         TEST_CASE(func_pointer1);
@@ -51,9 +50,11 @@ class TestUnusedPrivateFunction : public TestFixture {
         TEST_CASE(func_pointer4); // ticket #2807
         TEST_CASE(func_pointer5); // ticket #2233
         TEST_CASE(func_pointer6); // ticket #4787
+        TEST_CASE(func_pointer7); // ticket #10516
 
         TEST_CASE(ctor);
         TEST_CASE(ctor2);
+        TEST_CASE(ctor3);
 
         TEST_CASE(classInClass);
         TEST_CASE(sameFunctionNames);
@@ -77,42 +78,36 @@ class TestUnusedPrivateFunction : public TestFixture {
 
         TEST_CASE(multiFile);
         TEST_CASE(unknownBaseTemplate); // ticket #2580
-        TEST_CASE(hierarchie_loop); // ticket 5590
+        TEST_CASE(hierarchy_loop); // ticket 5590
 
         TEST_CASE(staticVariable); //ticket #5566
 
         TEST_CASE(templateSimplification); //ticket #6183
+        TEST_CASE(maybeUnused);
+        TEST_CASE(attributeUnused); // #14129
+        TEST_CASE(trailingReturn);
     }
 
+    struct CheckOptions
+    {
+        Platform::Type platform = Platform::Type::Native;
+    };
 
-    void check(const char code[], Settings::PlatformType platform = Settings::Native) {
-        // Clear the error buffer..
-        errout.str("");
-
-        settings.platform(platform);
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
+        const Settings settings1 = settingsBuilder(settings).platform(options.platform).build();
 
-        // Raw tokens..
-        std::vector<std::string> files(1, "test.cpp");
-        std::istringstream istr(code);
-        const simplecpp::TokenList tokens1(istr, files, files[0]);
-
-        // Preprocess..
-        simplecpp::TokenList tokens2(files);
-        std::map<std::string, simplecpp::TokenList*> filedata;
-        simplecpp::preprocess(tokens2, tokens1, files, filedata, simplecpp::DUI());
+        SimpleTokenizer2 tokenizer(settings1, *this, code, "test.cpp");
 
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        tokenizer.createTokens(&tokens2);
-        tokenizer.simplifyTokens1("");
+        ASSERT_LOC(tokenizer.simplifyTokens1(""), file, line);
 
         // Check for unused private functions..
-        CheckClass checkClass(&tokenizer, &settings, this);
+        CheckClass checkClass(&tokenizer, &settings1, this);
         checkClass.privateFunctions();
     }
 
-
-
     void test1() {
         check("class Fred\n"
               "{\n"
@@ -128,7 +123,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "unsigned int Fred::f()\n"
               "{ }");
 
-        ASSERT_EQUALS("[test.cpp:4]: (style) Unused private function: 'Fred::f'\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:18] -> [test.cpp:12:20]: (style) Unused private function: 'Fred::f' [unusedPrivateFunction]\n", errout_str());
 
         check("#line 1 \"p.h\"\n"
               "class Fred\n"
@@ -146,7 +141,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "unsigned int Fred::f()\n"
               "{ }");
 
-        ASSERT_EQUALS("[p.h:4]: (style) Unused private function: 'Fred::f'\n", errout.str());
+        ASSERT_EQUALS("[p.h:4:18] -> [p.cpp:4:20]: (style) Unused private function: 'Fred::f' [unusedPrivateFunction]\n", errout_str());
 
         check("#line 1 \"p.h\"\n"
               "class Fred\n"
@@ -161,7 +156,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "void Fred::f()\n"
               "{\n"
               "}");
-        ASSERT_EQUALS("[p.h:4]: (style) Unused private function: 'Fred::f'\n", errout.str());
+        ASSERT_EQUALS("[p.h:4:6] -> [p.cpp:2:12]: (style) Unused private function: 'Fred::f' [unusedPrivateFunction]\n", errout_str());
 
         // Don't warn about include files which implementation we don't see
         check("#line 1 \"p.h\"\n"
@@ -177,7 +172,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "int main()\n"
               "{\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -195,7 +190,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "\n"
               "A::A()\n"
               "{ }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -210,7 +205,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "\n"
               "A::~A()\n"
               "{ B(); }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -225,7 +220,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "\n"
               "A::A() : _owner(false)\n"
               "{ b(); }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -236,14 +231,24 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    { }\n"
               "    Lock *lock;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void test6() { // ticket #2602 segmentation fault
         check("class A {\n"
               "    A& operator=(const A&);\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void test7() { // ticket #9282
+        check("class C {\n"
+              "    double f1() const noexcept, f2(double) const noexcept;\n"
+              "    void f3() const noexcept;\n"
+              "};\n"
+              "double C::f1() const noexcept { f3(); }\n"
+              "void C::f3() const noexcept {}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -271,7 +276,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "Fred::Fred()\n"
               "{}");
 
-        ASSERT_EQUALS("[test.cpp:6]: (style) Unused private function: 'Fred::get'\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:12] -> [test.cpp:6:12]: (style) Unused private function: 'Fred::get' [unusedPrivateFunction]\n", errout_str());
     }
 
 
@@ -289,7 +294,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "\n"
               "    Observer<UnusedPrivateFunctionMemberPointer, unsigned> mObserver;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -303,7 +308,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "private:\n"
               "    void f1() const {}\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -317,7 +322,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "};\n"
               "myclass::myclass() { fptr = &f; }\n"
               "void myclass::f() {}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -329,7 +334,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "private:\n"
               "    static void func() { }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -342,7 +347,33 @@ class TestUnusedPrivateFunction : public TestFixture {
               "        f(\"test\");\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void func_pointer7() { // #10516
+        check("class C {\n"
+              "    static void f() {}\n"
+              "    static constexpr void(*p)() = f;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("class C {\n"
+              "    static void f() {}\n"
+              "    static constexpr void(*p)() = &f;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("class C {\n"
+              "    static void f() {}\n"
+              "    static constexpr void(*p)() = C::f;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        check("class C {\n"
+              "    static void f() {}\n"
+              "    static constexpr void(*p)() = &C::f;\n"
+              "};\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
 
@@ -358,7 +389,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    int numOfThreads;\n"
               "};");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void ctor2() {
@@ -370,7 +401,15 @@ class TestUnusedPrivateFunction : public TestFixture {
               "public:\n"
               "  double totalWeighting_;\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void ctor3() {
+        check("class C {\n"
+              "    C() = default;\n"
+              "    void f() const { (void)this; }\n"
+              "};");
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:3:10]: (style) Unused private function: 'C::f' [unusedPrivateFunction]\n", errout_str());
     }
 
 
@@ -387,7 +426,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    static void f()\n"
               "    { }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:10]: (style) Unused private function: 'A::f'\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:17] -> [test.cpp:10:17]: (style) Unused private function: 'A::f' [unusedPrivateFunction]\n", errout_str());
 
         check("class A\n"
               "{\n"
@@ -406,18 +445,24 @@ class TestUnusedPrivateFunction : public TestFixture {
               "        { a->f(); }\n"
               "    };\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class A {\n"  // #6968 - outer definition
               "public:\n"
               "  class B;\n"
               "private:\n"
               "  void f() {}\n"
-              "}\n"
+              "};\n"
               "class A::B {"
               "  B() { A a; a.f(); }\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "};");
+        ASSERT_EQUALS("", errout_str());
+
+        check("class C {\n" // #13790
+              "    class I { I() = default; };\n"
+              "    void f() const { (void)this; }\n"
+              "};\n");
+        ASSERT_EQUALS("[test.cpp:3:10] -> [test.cpp:3:10]: (style) Unused private function: 'C::f' [unusedPrivateFunction]\n", errout_str());
     }
 
 
@@ -434,7 +479,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    void f() { }\n"
               "    void f(int) { }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void incompleteImplementation() {
@@ -452,7 +497,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "#endfile\n"
               "A::A() { }\n"
               "void A::b() { }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void derivedClass() {
@@ -464,7 +509,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "private:\n"
               "    void f();\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class base {\n"
               "public:\n"
@@ -476,7 +521,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    void foo() {}\n" // Skip for overrides of virtual functions of base
               "    void bar() {}\n" // Don't skip if no function is overridden
               "};");
-        ASSERT_EQUALS("[test.cpp:9]: (style) Unused private function: 'derived::bar'\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:10] -> [test.cpp:9:10]: (style) Unused private function: 'derived::bar' [unusedPrivateFunction]\n", errout_str());
 
         check("class Base {\n"
               "private:\n"
@@ -495,7 +540,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "private:\n"
               "    void func() {}\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Base {\n"
               "public:\n"
@@ -513,7 +558,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "      return 0;\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void friendClass() {
@@ -523,7 +568,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    friend Bar;\n" // Unknown friend class
               "    void f() { }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Bar {\n"
               "    void g() { f(); }\n" // Friend class seen, but f not seen
@@ -533,7 +578,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    friend Bar;\n"
               "    void f();\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("struct Bar {\n"
               "    void g() { f(); }\n" // Friend class seen, but f() used in it
@@ -543,7 +588,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    friend Bar;\n"
               "    void f() { }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Bar {\n" // Friend class seen, f() not used in it
               "};\n"
@@ -551,7 +596,21 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    friend Bar;\n"
               "    void f() { }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:5]: (style) Unused private function: 'Foo::f'\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10] -> [test.cpp:5:10]: (style) Unused private function: 'Foo::f' [unusedPrivateFunction]\n", errout_str());
+
+        check("struct F;\n" // #10265
+              "struct S {\n"
+              "    int i{};\n"
+              "    friend struct F;\n"
+              "private:\n"
+              "    int f() const { return i; }\n"
+              "};\n"
+              "struct F {\n"
+              "    bool operator()(const S& lhs, const S& rhs) const {\n"
+              "        return lhs.f() < rhs.f();\n"
+              "    }\n"
+              "};");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void borland1() {
@@ -564,8 +623,8 @@ class TestUnusedPrivateFunction : public TestFixture {
               "public:\n"
               "    Foo() { }\n"
               "    __property int x = {read=getx}\n"
-              "};", Settings::Win32A);
-        ASSERT_EQUALS("", errout.str());
+              "};", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void borland2() {
@@ -577,8 +636,8 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    }\n"
               "public:\n"
               "    Foo() { }\n"
-              "};", Settings::Win32A);
-        ASSERT_EQUALS("", errout.str());
+              "};", dinit(CheckOptions, $.platform = Platform::Type::Win32A));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void template1() {
@@ -596,7 +655,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "T A::getVal() const {\n"
               "    return internalGetVal();\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void fp_operator() {
@@ -612,7 +671,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    void startListening() {\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Fred\n"
               "{\n"
@@ -624,20 +683,20 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    void startListening() {\n"
               "    }\n"
               "};");
-        ASSERT_EQUALS("[test.cpp:8]: (style) Unused private function: 'Fred::startListening'\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:8:10] -> [test.cpp:8:10]: (style) Unused private function: 'Fred::startListening' [unusedPrivateFunction]\n", errout_str());
 
         // #5059
         check("class Fred {\n"
               "    void* operator new(size_t obj_size, size_t buf_size) {}\n"
               "};");
-        TODO_ASSERT_EQUALS("[test.cpp:2]: (style) Unused private function: 'Fred::operatornew'\n", "", errout.str()); // No message for operators - we currently cannot check their usage
+        TODO_ASSERT_EQUALS("[test.cpp:2]: (style) Unused private function: 'Fred::operatornew'\n", "", errout_str()); // No message for operators - we currently cannot check their usage
 
         check("class Fred {\n"
               "    void* operator new(size_t obj_size, size_t buf_size) {}\n"
               "public:\n"
               "    void* foo() { return new(size) Fred(); }\n"
               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testDoesNotIdentifyMethodAsFirstFunctionArgument() {
@@ -663,8 +722,8 @@ class TestUnusedPrivateFunction : public TestFixture {
               "{"
               "    MountOperation aExample(10);"
               "}"
-             );
-        ASSERT_EQUALS("", errout.str());
+              );
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testDoesNotIdentifyMethodAsMiddleFunctionArgument() {
@@ -690,8 +749,8 @@ class TestUnusedPrivateFunction : public TestFixture {
               "{"
               "    MountOperation aExample(10);"
               "}"
-             );
-        ASSERT_EQUALS("", errout.str());
+              );
+        ASSERT_EQUALS("", errout_str());
     }
 
     void testDoesNotIdentifyMethodAsLastFunctionArgument() {
@@ -717,8 +776,8 @@ class TestUnusedPrivateFunction : public TestFixture {
               "{"
               "    MountOperation aExample(10);"
               "}"
-             );
-        ASSERT_EQUALS("", errout.str());
+              );
+        ASSERT_EQUALS("", errout_str());
     }
 
     void multiFile() { // ticket #2567
@@ -737,7 +796,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "{\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void unknownBaseTemplate() { // ticket #2580
@@ -749,10 +808,10 @@ class TestUnusedPrivateFunction : public TestFixture {
               "};\n"
               "void Bla::F() const { }");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void hierarchie_loop() {
+    void hierarchy_loop() {
         check("class InfiniteB : InfiniteA {\n"
               "    class D {\n"
               "    };\n"
@@ -768,7 +827,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    C a;\n"
               "}");
 
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void staticVariable() {
@@ -777,7 +836,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    static int F() const { return 1; }\n"
               "};\n"
               "int Foo::i = Foo::F();");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Foo {\n"
               "    static int i;\n"
@@ -785,7 +844,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "};\n"
               "Foo f;\n"
               "int Foo::i = f.F();");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("class Foo {\n"
               "    static int i;\n"
@@ -793,7 +852,7 @@ class TestUnusedPrivateFunction : public TestFixture {
               "};\n"
               "int Foo::i = sth();"
               "int i = F();");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unused private function: 'Foo::F'\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:16] -> [test.cpp:3:16]: (style) Unused private function: 'Foo::F' [unusedPrivateFunction]\n", errout_str());
     }
 
     void templateSimplification() { //ticket #6183
@@ -816,7 +875,45 @@ class TestUnusedPrivateFunction : public TestFixture {
               "    CTest::Greeting<bool>(true);\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void maybeUnused() {
+        check("class C {\n"
+              "    [[maybe_unused]] int f() { return 42; }\n"
+              "};");
+        ASSERT_EQUALS("", errout_str());
+
+        check("class C {\n"
+              "    [[maybe_unused]] static int f();\n"
+              "};\n"
+              "int C::f() { return 42; }\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void attributeUnused() {
+        check("class C {\n"
+              "    __attribute__((unused)) int f() { return 42; }\n"
+              "};");
+        ASSERT_EQUALS("", errout_str());
+
+        check("class C {\n"
+              "    __attribute__((unused)) int f();\n"
+              "};\n"
+              "int C::f() { return 42; }\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void trailingReturn() {
+        check("struct B { virtual void f(); };\n"
+              "struct D : B {\n"
+              "    auto f() -> void override;\n"
+              "private:\n"
+              "    auto g() -> void;\n"
+              "};\n"
+              "auto D::f() -> void { g(); }\n"
+              "auto D::g() -> void {}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 };
 
diff --git a/test/testunusedvar.cpp b/test/testunusedvar.cpp
index 11249d3894e..e5f4c08f043 100644
--- a/test/testunusedvar.cpp
+++ b/test/testunusedvar.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,23 +17,29 @@
  */
 
 #include "checkunusedvar.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
+#include "preprocessor.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
 
+#include <cstddef>
+#include <list>
 #include <string>
 
+#include <simplecpp.h>
+
 class TestUnusedVar : public TestFixture {
 public:
-    TestUnusedVar() : TestFixture("TestUnusedVar") {
-    }
+    TestUnusedVar() : TestFixture("TestUnusedVar") {}
 
 private:
-    Settings settings;
+    const Settings settings = settingsBuilder().severity(Severity::style).checkLibrary().library("std.cfg").build();
 
-    void run() OVERRIDE {
-        settings.addEnabled("style");
-        LOAD_LIB_2(settings.library, "std.cfg");
+    void run() override {
+        mNewTemplate = true;
+        TEST_CASE(isRecordTypeWithoutSideEffects);
+        TEST_CASE(cleanFunction);
 
         TEST_CASE(emptyclass);  // #5355 - False positive: Variable is not assigned a value.
         TEST_CASE(emptystruct);  // #5355 - False positive: Variable is not assigned a value.
@@ -53,7 +59,30 @@ class TestUnusedVar : public TestFixture {
         TEST_CASE(structmember12); // #7179 - FP unused structmember
         TEST_CASE(structmember13); // #3088 - __attribute__((packed))
         TEST_CASE(structmember14); // #6508 - (struct x){1,2,..}
+        TEST_CASE(structmember15); // #3088 - #pragma pack(1)
         TEST_CASE(structmember_sizeof);
+        TEST_CASE(structmember16); // #10485
+        TEST_CASE(structmember17); // #10591
+        TEST_CASE(structmember18); // #10684
+        TEST_CASE(structmember19); // #10826, #10848, #10852
+        TEST_CASE(structmember20); // #10737
+        TEST_CASE(structmember21); // #4759
+        TEST_CASE(structmember22); // #11016
+        TEST_CASE(structmember23);
+        TEST_CASE(structmember24); // #10847
+        TEST_CASE(structmember25);
+        TEST_CASE(structmember26); // #13345
+        TEST_CASE(structmember27); // #13367
+        TEST_CASE(structmember28);
+        TEST_CASE(structmember29); // #14075
+        TEST_CASE(structmember30); // #14131
+        TEST_CASE(structmember31); // #14130
+        TEST_CASE(structmember32); // #14483
+        TEST_CASE(structmember33);
+        TEST_CASE(structmember_macro);
+        TEST_CASE(structmember_template_argument); // #13887 - do not report that member used in template argument is unused
+        TEST_CASE(classmember);
+        TEST_CASE(structmemberStructuredBinding); // #13107
 
         TEST_CASE(localvar1);
         TEST_CASE(localvar2);
@@ -111,6 +140,21 @@ class TestUnusedVar : public TestFixture {
         TEST_CASE(localvar55);
         TEST_CASE(localvar56);
         TEST_CASE(localvar57); // #8974 - increment
+        TEST_CASE(localvar58); // #9901 - increment false positive
+        TEST_CASE(localvar59); // #9737
+        TEST_CASE(localvar60);
+        TEST_CASE(localvar61); // #9407
+        TEST_CASE(localvar62); // #10824
+        TEST_CASE(localvar63); // #6928
+        TEST_CASE(localvar64); // #9997
+        TEST_CASE(localvar65); // #9876, #10006
+        TEST_CASE(localvar66); // #11143
+        TEST_CASE(localvar67); // #9946
+        TEST_CASE(localvar68);
+        TEST_CASE(localvar69);
+        TEST_CASE(localvar70);
+        TEST_CASE(localvar71);
+        TEST_CASE(localvar72);
         TEST_CASE(localvarloops); // loops
         TEST_CASE(localvaralias1);
         TEST_CASE(localvaralias2); // ticket #1637
@@ -130,6 +174,11 @@ class TestUnusedVar : public TestFixture {
         TEST_CASE(localvaralias16);
         TEST_CASE(localvaralias17); // ticket #8911
         TEST_CASE(localvaralias18); // ticket #9234 - iterator
+        TEST_CASE(localvaralias19); // ticket #9828
+        TEST_CASE(localvaralias20); // ticket #10966
+        TEST_CASE(localvaralias21);
+        TEST_CASE(localvaralias22);
+        TEST_CASE(localvaralias23);
         TEST_CASE(localvarasm);
         TEST_CASE(localvarstatic);
         TEST_CASE(localvarextern);
@@ -141,16 +190,20 @@ class TestUnusedVar : public TestFixture {
         TEST_CASE(localvararray3);  // ticket #3980
         TEST_CASE(localvararray4);  // ticket #4839
         TEST_CASE(localvararray5);  // ticket #7092
+        TEST_CASE(localvararray6);
         TEST_CASE(localvarstring1);
         TEST_CASE(localvarstring2); // ticket #2929
         TEST_CASE(localvarconst1);
         TEST_CASE(localvarconst2);
         TEST_CASE(localvarreturn); // ticket #9167
+        TEST_CASE(localvarmaybeunused);
+        TEST_CASE(localvarrvalue); // ticket #13977
 
         TEST_CASE(localvarthrow); // ticket #3687
 
         TEST_CASE(localVarStd);
         TEST_CASE(localVarClass);
+        TEST_CASE(localVarSmartPtr);
 
         // Don't give false positives for variables in structs/unions
         TEST_CASE(localvarStruct1);
@@ -159,12 +212,21 @@ class TestUnusedVar : public TestFixture {
         TEST_CASE(localvarStruct5);
         TEST_CASE(localvarStruct6);
         TEST_CASE(localvarStruct7);
+        TEST_CASE(localvarStruct8);
+        TEST_CASE(localvarStruct9);
+        TEST_CASE(localvarStruct10);
+        TEST_CASE(localvarStruct11); // 10095
+        TEST_CASE(localvarStruct12); // #10495
+        TEST_CASE(localvarStruct13); // #10398
+        TEST_CASE(localvarStruct14);
         TEST_CASE(localvarStructArray);
+        TEST_CASE(localvarUnion1);
 
         TEST_CASE(localvarOp);          // Usage with arithmetic operators
         TEST_CASE(localvarInvert);      // Usage with inverted variable
         TEST_CASE(localvarIf);          // Usage in if
         TEST_CASE(localvarIfElse);      // return tmp1 ? tmp2 : tmp3;
+        TEST_CASE(localvarDeclaredInIf);
         TEST_CASE(localvarOpAssign);    // a |= b;
         TEST_CASE(localvarFor);         // for ( ; var; )
         TEST_CASE(localvarForEach);     // #4155 - BOOST_FOREACH, hlist_for_each, etc
@@ -186,6 +248,7 @@ class TestUnusedVar : public TestFixture {
         TEST_CASE(localvarAddr); // #7477
         TEST_CASE(localvarDelete);
         TEST_CASE(localvarLambda); // #8941, #8948
+        TEST_CASE(localvarStructuredBinding); // #10368
 
         TEST_CASE(localvarCppInitialization);
         TEST_CASE(localvarCpp11Initialization);
@@ -194,6 +257,7 @@ class TestUnusedVar : public TestFixture {
 
         TEST_CASE(crash1);
         TEST_CASE(crash2);
+        TEST_CASE(crash3);
         TEST_CASE(usingNamespace);     // #4585
 
         TEST_CASE(lambdaFunction); // #5078
@@ -201,21 +265,1110 @@ class TestUnusedVar : public TestFixture {
         TEST_CASE(bracesInitCpp11);// #7895 - "int var{123}" initialization
 
         TEST_CASE(argument);
+        TEST_CASE(argumentClass);
         TEST_CASE(escapeAlias); // #9150
+        TEST_CASE(volatileData); // #9280
+        TEST_CASE(globalData);
+
+        TEST_CASE(structuredBinding); // #13269
     }
 
-    void checkStructMemberUsage(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
+    struct FunctionVariableUsageOptions
+    {
+        bool cpp = true;
+    };
 
+#define functionVariableUsage(...) functionVariableUsage_(__FILE__, __LINE__, __VA_ARGS__)
+    void functionVariableUsage_(const char* file, int line, const char code[], const FunctionVariableUsageOptions& options = make_default_obj()) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this, options.cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check for unused variables..
         CheckUnusedVar checkUnusedVar(&tokenizer, &settings, this);
-        checkUnusedVar.checkStructMemberUsage();
+        checkUnusedVar.checkFunctionVariableUsage();
+    }
+
+    struct CheckStructMemberUsageOptions
+    {
+        const std::list<Directive>* directives = nullptr;
+        bool cpp = true;
+    };
+
+#define checkStructMemberUsage(...) checkStructMemberUsage_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkStructMemberUsage_(const char* file, int line, const char (&code)[size], const CheckStructMemberUsageOptions& options = make_default_obj()) {
+        // Tokenize..
+        SimpleTokenizer tokenizer(settings, *this, options.cpp);
+        if (options.directives)
+            tokenizer.setDirectives(*options.directives);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+
+        // Check for unused variables..
+        CheckUnusedVar checkUnusedVar(&tokenizer, &settings, this);
+        (checkUnusedVar.checkStructMemberUsage)();
+    }
+
+#define checkStructMemberUsageP(...) checkStructMemberUsageP_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkStructMemberUsageP_(const char* file, int line, const char (&code)[size]) {
+        SimpleTokenizer2 tokenizer(settings, *this, code, "test.cpp");
+
+        // Tokenizer..
+        ASSERT_LOC(tokenizer.simplifyTokens1(""), file, line);
+
+        // Check for unused variables..
+        CheckUnusedVar checkUnusedVar(&tokenizer, &settings, this);
+        (checkUnusedVar.checkStructMemberUsage)();
+    }
+
+#define checkFunctionVariableUsageP(...) checkFunctionVariableUsageP_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void checkFunctionVariableUsageP_(const char* file, int line, const char (&code)[size]) {
+        SimpleTokenizer2 tokenizer(settings, *this, code, "test.cpp");
+
+        // Tokenizer..
+        ASSERT_LOC(tokenizer.simplifyTokens1(""), file, line);
+
+        // Check for unused variables..
+        CheckUnusedVar checkUnusedVar(&tokenizer, &settings, this);
+        (checkUnusedVar.checkFunctionVariableUsage)();
+    }
+
+
+    void isRecordTypeWithoutSideEffects() {
+        functionVariableUsage(
+            "class A {};\n"
+            "void f() {\n"
+            "   A a;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:3:6]: (style) Unused variable: a [unusedVariable]\n", errout_str());
+
+        functionVariableUsage(
+            "class A {};\n"
+            "class B {\n"
+            "public:\n"
+            "   A a;\n"
+            "};\n"
+            "void f() {\n"
+            "   B b;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:7:6]: (style) Unused variable: b [unusedVariable]\n", errout_str());
+
+        functionVariableUsage(
+            "class C {\n"
+            "public:\n"
+            "   C() = default;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:6:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
+
+        functionVariableUsage(
+            "class D {\n"
+            "public:\n"
+            "   D() {}\n"
+            "};\n"
+            "void f() {\n"
+            "   D d;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:6:6]: (style) Unused variable: d [unusedVariable]\n", errout_str());
+
+        functionVariableUsage(
+            "class E {\n"
+            "public:\n"
+            "   uint32_t u{1};\n"
+            "};\n"
+            "void f() {\n"
+            "   E e;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:6:6]: (style) Unused variable: e [unusedVariable]\n", errout_str());
+
+        functionVariableUsage(
+            "class F {\n"
+            "public:\n"
+            "   F() : x(0) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   F f;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:7:6]: (style) Unused variable: f [unusedVariable]\n", errout_str());
+
+        functionVariableUsage(
+            "class F {\n"
+            "public:\n"
+            "   F() : x{0} {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   F f;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:7:6]: (style) Unused variable: f [unusedVariable]\n", errout_str());
+
+        functionVariableUsage(
+            "int y = 0;\n"
+            "class F {\n"
+            "public:\n"
+            "   F() : x(y) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   F f;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:8:6]: (style) Unused variable: f [unusedVariable]\n", errout_str());
+
+        functionVariableUsage(
+            "int y = 0;"
+            "class F {\n"
+            "public:\n"
+            "   F() : x(++y) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   F f;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:7:6]: (style) Unused variable: f [unusedVariable]\n", errout_str());
+
+        functionVariableUsage(
+            "int y = 0;"
+            "class F {\n"
+            "public:\n"
+            "   F() : x(--y) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   F f;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:7:6]: (style) Unused variable: f [unusedVariable]\n", errout_str());
+
+        functionVariableUsage(
+            "int y = 0;"
+            "class F {\n"
+            "public:\n"
+            "   F() : x(y+=1) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   F f;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:7:6]: (style) Unused variable: f [unusedVariable]\n", errout_str());
+
+        functionVariableUsage(
+            "int y = 0;"
+            "class F {\n"
+            "public:\n"
+            "   F() : x(y-=1) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   F f;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:7:6]: (style) Unused variable: f [unusedVariable]\n", errout_str());
+
+        // non-empty constructor
+        functionVariableUsage(
+            "class F {\n"
+            "public:\n"
+            "   F() {\n"
+            "       int i = 0;\n"
+            "       (void) i;"
+            "   }\n"
+            "};\n"
+            "void f() {\n"
+            "   F f;\n"
+            "}");
+        TODO_ASSERT_EQUALS("error", "", errout_str());
+
+        // constructor with hidden definition
+        functionVariableUsage(
+            "class B {\n"
+            "public:\n"
+            "   B();\n"
+            "};\n"
+            "class A {\n"
+            "   B* b = new B;\n"
+            "};\n"
+            "int main() {\n"
+            "   A a;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // side-effect variable
+        functionVariableUsage(
+            "class F {\n"
+            "public:\n"
+            "   F() {\n"
+            "       int i = 0;\n"
+            "       (void) i;"
+            "   }\n"
+            "};\n"
+            "class G {\n"
+            "public:\n"
+            "   F f;\n"
+            "};\n"
+            "void f() {\n"
+            "   G g;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // side-effect variable in initialization list
+        functionVariableUsage(
+            "class F {\n"
+            "public:\n"
+            "   F() {\n"
+            "       int i = 0;\n"
+            "       (void) i;"
+            "   }\n"
+            "};\n"
+            "class G {\n"
+            "public:\n"
+            "   G() : f(F()) {}\n"
+            "   F f;"
+            "};\n"
+            "void f() {\n"
+            "   G g;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // unknown variable type
+        functionVariableUsage(
+            "class H {\n"
+            "public:\n"
+            "   unknown_type u{1};\n"
+            "};\n"
+            "void f() {\n"
+            "   H h;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // unknown variable type in initialization list
+        functionVariableUsage(
+            "class H {\n"
+            "public:\n"
+            "   H() : x{0}, u(1) {}\n"
+            "   int x;"
+            "   unknown_type u;\n"
+            "};\n"
+            "void f() {\n"
+            "   H h;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // unknown variable type used for initialization
+        functionVariableUsage(
+            "unknown_type y = 0;\n"
+            "class F {\n"
+            "public:\n"
+            "   F() : x(y) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   F f;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage(
+            "int sideEffectFunc();\n"
+            "class F {\n"
+            "public:\n"
+            "   F() : x(sideEffectFunc()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   F f;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage(
+            "class F {\n"
+            "public:\n"
+            "   F() : x(++unknownValue) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   F f;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage(
+            "class F {\n"
+            "public:\n"
+            "   F() : x(--unknownValue) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   F f;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage(
+            "class F {\n"
+            "public:\n"
+            "   F() : x(unknownValue+=1) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   F f;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage(
+            "class F {\n"
+            "public:\n"
+            "   F() : x(unknownValue-=1) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   F f;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage(
+            "struct S {\n"
+            "    static void f() { std::cout << \"f()\"; }\n"
+            "    ~S() { f(); }\n"
+            "};\n"
+            "void g() {\n"
+            "    S s;\n"
+            "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage( // #11109
+            "class D { public: D(); };\n"
+            "class E { public: ~E(); };\n"
+            "class F {\n"
+            "public:\n"
+            "    F();\n"
+            "    ~F();\n"
+            "};\n"
+            "void f() {\n"
+            "    D d;\n"
+            "    E e;\n"
+            "    F f;\n"
+            "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void cleanFunction() {
+        // unknown function
+        functionVariableUsage(
+            "class F {\n"
+            "public:\n"
+            "   F() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   F f;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // function forward declaration
+        functionVariableUsage(
+            "int func();\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // return literal
+        functionVariableUsage(
+            "int func() { return 1; }\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:8:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
+
+        // return variable without side effects
+        functionVariableUsage(
+            "int func() {\n"
+            "   int x = 1;\n"
+            "   return x;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:11:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
+
+        // return variable with side effects
+        functionVariableUsage(
+            "int func() {\n"
+            "   unknown_type x = 1;\n"
+            "   return x;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // return unknown variable
+        functionVariableUsage(
+            "int func() {\n"
+            "   return unknown_var;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // return variable is global, but not changed
+        functionVariableUsage(
+            "int x = 1;\n"
+            "int func() {\n"
+            "   return x;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:11:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
+
+        // changing global variable in return
+        functionVariableUsage(
+            "int x = 1;\n"
+            "int func() {\n"
+            "   return x++;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // changing global variable in function body
+        functionVariableUsage(
+            "int x = 1;\n"
+            "int func() {\n"
+            "   x++;\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage(
+            "int x = 1;\n"
+            "int func() {\n"
+            "   --x;\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage(
+            "int x = 1;\n"
+            "int func() {\n"
+            "   x += 2;\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage(
+            "int x = 1;\n"
+            "int func() {\n"
+            "   x = 2;\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // global variable use in function body without change
+        functionVariableUsage(
+            "int global = 1;\n"
+            "int func() {\n"
+            "   int x = global + 1;\n"
+            "   return x;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:12:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
+
+        // changing global array variable in function body
+        functionVariableUsage(
+            "int x[] = {0, 1, 3};\n"
+            "int func() {\n"
+            "   x[0] = 4;\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage(
+            "int x[] = {0, 1, 3};\n"
+            "int func() {\n"
+            "   *x = 2;\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage(
+            "int x[] = {0, 1, 3};\n"
+            "int func() {\n"
+            "   *(x) = 2;\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // pointer arithmetic on global array
+        functionVariableUsage(
+            "int x[] = {0, 1, 3};\n"
+            "int func() {\n"
+            "   *(x + 1) = 2;\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage(
+            "int x[][] = {{0, 1}, {2, 3}};\n"
+            "int func() {\n"
+            "   *((x + 1) + 1) = 4;\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage(
+            "int x[] = {0, 1, 3};\n"
+            "int func() {\n"
+            "   int local = *(x + 1);\n"
+            "   (void) local;\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:13:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
+
+        functionVariableUsage(
+            "int x[] = {0, 1, 3};\n"
+            "int func() {\n"
+            "   int* local = x + 2;\n"
+            "   (void) local;\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:13:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
+
+        functionVariableUsage(
+            "int x[] = {0, 1, 3};\n"
+            "int func() {\n"
+            "   int* local = x + 2;\n"
+            "   return *local;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage(
+            "int x[] = {0, 1, 3};\n"
+            "int func() {\n"
+            "   return *(x + 1);\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // changing local variable
+        functionVariableUsage(
+            "int func() {\n"
+            "   int x = 1;\n"
+            "   x = 2;\n"
+            "   x++;\n"
+            "   return x;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:13:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
+
+        // variable of user-defined class without side effects
+        functionVariableUsage(
+            "class A {};\n"
+            "A func() {\n"
+            "   A a;\n"
+            "   return a;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   A x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:12:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
+
+        // variable of user-defined class with side effects
+        functionVariableUsage(
+            "class A {\n"
+            "public:\n"
+            "   unknown_type u{1};\n"
+            "};\n"
+            "int func() {\n"
+            "   A a;\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // unknown type variable
+        functionVariableUsage(
+            "int func() {\n"
+            "   unknown_type a;\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // nested clean function call
+        functionVariableUsage(
+            "int another_func() { return 1;}\n"
+            "int func() {\n"
+            "   another_func();\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:12:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
+
+        // nested side-effects function call
+        functionVariableUsage(
+            "int global = 1;"
+            "int another_func() {\n"
+            "   global++;\n"
+            "   return global;}\n"
+            "int func() {\n"
+            "   another_func();\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // unknown nested function
+        functionVariableUsage(
+            "int func() {\n"
+            "   unknown_func();\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // clean function recursion
+        functionVariableUsage(
+            "int func(int i) {\n"
+            "   if (i != 2) {\n"
+            "       func(i++);\n"
+            "       return 2;\n"
+            "   }\n"
+            "   return i;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func(0)) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:14:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
+
+        // indirect clean function recursion
+        functionVariableUsage(
+            "void another_func() {\n"
+            "   func(0);\n"
+            "}\n"
+            "int func(int i) {\n"
+            "   if (i != 2) {\n"
+            "       another_func();\n"
+            "       return 2;\n"
+            "   }\n"
+            "   return i;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func(0)) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:17:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
+
+        // side-effect function recursion
+        functionVariableUsage(
+            "int global = 1;\n"
+            "int func(int i) {\n"
+            "   if (i != 2) {\n"
+            "       global++;\n"
+            "       func(i++);\n"
+            "       return 2;\n"
+            "   }\n"
+            "   return i;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func(0)) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // multiple returns (side-effect & clean)
+        functionVariableUsage(
+            "int func(int i) {\n"
+            "   if (i == 0) { return 0;}\n"
+            "   else { return unknownSideEffectFunction(); }\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func(0)) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // multiple clean returns
+        functionVariableUsage(
+            "int func(int i) {\n"
+            "   if (i == 0) { return 0;}\n"
+            "   else { return i; }\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func(0)) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:11:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
+
+        // multiple side-effect returns
+        functionVariableUsage(
+            "int func(int i) {\n"
+            "   if (i == 0) { return unknownSideEffectFunction();}\n"
+            "   else { return unknown_var; }\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func(0)) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // argument return
+        functionVariableUsage(
+            "int func(int i) {\n"
+            "    return i;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func(0)) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:10:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
+
+        // global variable modifying through function argument
+        functionVariableUsage(
+            "char buf[10];\n"
+            "int func(char* p) {\n"
+            "   *p = 0;\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func(buf)) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // global variable modifying through local pointer
+        functionVariableUsage(
+            "int global = 1;\n"
+            "int func() {\n"
+            "   int* p = &global;\n"
+            "   *p = 0;\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // global variable assigning to local pointer, but not modifying
+        functionVariableUsage(
+            "int global = 1;\n"
+            "int func() {\n"
+            "   int* p = &global;\n"
+            "   (void) p;\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:13:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
+
+        // global struct variable modification
+        functionVariableUsage(
+            "struct S { int x; } s;\n"
+            "int func() {\n"
+            "   s.x = 1;\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // global struct variable without modification
+        functionVariableUsage(
+            "struct S { int x; } s;\n"
+            "int func() {\n"
+            "   int y = s.x + 1;\n"
+            "   return y;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:12:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
+
+        // global pointer to struct variable modification
+        functionVariableUsage(
+            "struct S { int x; };\n"
+            "struct S* s = new(struct S);\n"
+            "int func() {\n"
+            "   s->x = 1;\n"
+            "   return 1;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+
+        // global pointer to struct variable without modification
+        functionVariableUsage(
+            "struct S { int x; };\n"
+            "struct S* s = new(struct S);\n"
+            "int func() {\n"
+            "   int y = s->x + 1;\n"
+            "   return y;\n"
+            "}\n"
+            "class C {\n"
+            "public:\n"
+            "   C() : x(func()) {}\n"
+            "   int x;\n"
+            "};\n"
+            "void f() {\n"
+            "   C c;\n"
+            "}");
+        ASSERT_EQUALS("[test.cpp:13:6]: (style) Unused variable: c [unusedVariable]\n", errout_str());
     }
 
     // #5355 - False positive: Variable is not assigned a value.
@@ -228,7 +1381,7 @@ class TestUnusedVar : public TestFixture {
                               "    Fred fred;\n"
                               "    throw fred;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     // #5355 - False positive: Variable is not assigned a value.
@@ -239,7 +1392,7 @@ class TestUnusedVar : public TestFixture {
                               "    Fred fred;\n"
                               "    throw fred;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void structmember1() {
@@ -249,9 +1402,9 @@ class TestUnusedVar : public TestFixture {
                                "    int b;\n"
                                "    int c;\n"
                                "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style) struct member 'abc::a' is never used.\n"
-                      "[test.cpp:4]: (style) struct member 'abc::b' is never used.\n"
-                      "[test.cpp:5]: (style) struct member 'abc::c' is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) struct member 'abc::a' is never used. [unusedStructMember]\n"
+                      "[test.cpp:4:9]: (style) struct member 'abc::b' is never used. [unusedStructMember]\n"
+                      "[test.cpp:5:9]: (style) struct member 'abc::c' is never used. [unusedStructMember]\n", errout_str());
 
         checkStructMemberUsage("union abc\n"
                                "{\n"
@@ -259,9 +1412,25 @@ class TestUnusedVar : public TestFixture {
                                "    int b;\n"
                                "    int c;\n"
                                "};");
-        ASSERT_EQUALS("[test.cpp:3]: (style) union member 'abc::a' is never used.\n"
-                      "[test.cpp:4]: (style) union member 'abc::b' is never used.\n"
-                      "[test.cpp:5]: (style) union member 'abc::c' is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) union member 'abc::a' is never used. [unusedStructMember]\n"
+                      "[test.cpp:4:9]: (style) union member 'abc::b' is never used. [unusedStructMember]\n"
+                      "[test.cpp:5:9]: (style) union member 'abc::c' is never used. [unusedStructMember]\n", errout_str());
+
+        // #7458 - union with anonymous struct should not cause false positive
+        checkStructMemberUsage("union DoubleInt {\n"
+                               "    double asDouble;\n"
+                               "    uint64_t asInt;\n"
+                               "    struct {\n"
+                               "        uint32_t lo, hi;\n" // <- no FP about lo because hi is used
+                               "    } asIntel;\n"
+                               "};\n"
+                               "void f() {\n"
+                               "    union DoubleInt di;\n"
+                               "    di.asIntel.hi = 3;\n"
+                               "}");
+        ASSERT_EQUALS("[test.cpp:2:12]: (style) union member 'DoubleInt::asDouble' is never used. [unusedStructMember]\n"
+                      "[test.cpp:3:14]: (style) union member 'DoubleInt::asInt' is never used. [unusedStructMember]\n",
+                      errout_str());
     }
 
     void structmember2() {
@@ -279,7 +1448,7 @@ class TestUnusedVar : public TestFixture {
                                "    int b = abc.b;\n"
                                "    int c = abc.c;\n"
                                "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void structmember3() {
@@ -298,7 +1467,7 @@ class TestUnusedVar : public TestFixture {
                                "    int b = abc[0].b;\n"
                                "    int c = abc[0].c;\n"
                                "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void structmember4() {
@@ -312,7 +1481,7 @@ class TestUnusedVar : public TestFixture {
                                "    ABC abc;\n"
                                "    if (abc.a == 2);\n"
                                "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void structmember5() {
@@ -332,7 +1501,7 @@ class TestUnusedVar : public TestFixture {
                                "    struct AB ab;\n"
                                "    ab.reset();\n"
                                "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void structmember6() {
@@ -346,7 +1515,7 @@ class TestUnusedVar : public TestFixture {
                                "{\n"
                                "    struct AB *ab = (struct AB *)&buf[10];\n"
                                "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkStructMemberUsage("struct AB\n"
                                "{\n"
@@ -358,7 +1527,7 @@ class TestUnusedVar : public TestFixture {
                                "{\n"
                                "    struct AB *ab = (AB *)&buf[10];\n"
                                "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void structmember7() {
@@ -372,7 +1541,7 @@ class TestUnusedVar : public TestFixture {
                                "{\n"
                                "    ab->a = 0;\n"
                                "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9]: (style) struct member 'AB::b' is never used. [unusedStructMember]\n", errout_str());
 
         checkStructMemberUsage("struct AB\n"
                                "{\n"
@@ -384,7 +1553,7 @@ class TestUnusedVar : public TestFixture {
                                "{\n"
                                "    ab->a = 0;\n"
                                "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9]: (style) struct member 'AB::b' is never used. [unusedStructMember]\n", errout_str());
     }
 
     void structmember8() {
@@ -398,7 +1567,7 @@ class TestUnusedVar : public TestFixture {
                                "{\n"
                                "    ((AB *)ab)->b = 0;\n"
                                "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void structmember9() {
@@ -408,7 +1577,7 @@ class TestUnusedVar : public TestFixture {
                                "\n"
                                "struct derived : public base {"
                                "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void structmember10() {
@@ -416,19 +1585,19 @@ class TestUnusedVar : public TestFixture {
         checkStructMemberUsage("struct abc {\n"
                                "    Fred fred;\n"
                                "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void structmember11() { // #4168
         checkStructMemberUsage("struct abc { int x; };\n"
                                "struct abc s = {0};\n"
                                "void f() { do_something(&s); }");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkStructMemberUsage("struct abc { int x; };\n"
                                "struct abc s = {0};\n"
                                "void f() { }");
-        TODO_ASSERT_EQUALS("abc::x is not used", "", errout.str());
+        TODO_ASSERT_EQUALS("abc::x is not used", "", errout_str());
     }
 
     void structmember12() { // #7179
@@ -447,15 +1616,15 @@ class TestUnusedVar : public TestFixture {
                                "{\n"
                                "    printf(\"var.struct1.a = %d\", var.struct1.a);\n"
                                "    return 1;\n"
-                               "}\n");
-        ASSERT_EQUALS("", errout.str());
+                               "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void structmember13() { // #3088 - struct members required by hardware
         checkStructMemberUsage("struct S {\n"
                                "  int x;\n"
                                "} __attribute__((packed));");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void structmember14() { // #6508
@@ -463,7 +1632,18 @@ class TestUnusedVar : public TestFixture {
                                "struct bstr bstr0(void) {\n"
                                "  return (struct bstr){\"hello\",6};\n"
                                "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void structmember15() { // #3088
+        std::list<Directive> directives;
+        std::vector<std::string> f = { "test.cpp" };
+        simplecpp::TokenList tokenList(f);
+        simplecpp::Location loc;
+        loc.line = 1;
+        directives.emplace_back(tokenList, loc, "#pragma pack(1)");
+        checkStructMemberUsage("\nstruct Foo { int x; int y; };", dinit(CheckStructMemberUsageOptions, $.directives = &directives));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void structmember_extern() {
@@ -478,7 +1658,7 @@ class TestUnusedVar : public TestFixture {
                                "{\n"
                                "    ab.b = 0;\n"
                                "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // global linkage => no false positive
         checkStructMemberUsage("struct AB\n"
@@ -491,7 +1671,7 @@ class TestUnusedVar : public TestFixture {
                                "{\n"
                                "    ab.b = 0;\n"
                                "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // static linkage => error message
         checkStructMemberUsage("static struct AB\n"
@@ -504,7 +1684,18 @@ class TestUnusedVar : public TestFixture {
                                "{\n"
                                "    ab.b = 0;\n"
                                "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) struct member 'AB::a' is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) struct member 'AB::a' is never used. [unusedStructMember]\n", errout_str());
+
+        checkStructMemberUsage("struct A\n"
+                               "{\n"
+                               "    static const int a = 0;\n"
+                               "};\n"
+                               "\n"
+                               "int foo()\n"
+                               "{\n"
+                               "    return A::a;\n"
+                               "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void structmember_sizeof() {
@@ -513,43 +1704,483 @@ class TestUnusedVar : public TestFixture {
                                "}\n"
                                "\n"
                                "input.skip(sizeof(Header));");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         checkStructMemberUsage("struct Header {\n"
                                "  uint8_t message_type;\n"
                                "}\n"
                                "\n"
                                "input.skip(sizeof(struct Header));");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        checkStructMemberUsage("struct S { int a, b, c; };\n" // #6561
+                               "int f(FILE * fp) {\n"
+                               "    S s;\n"
+                               "    ::fread(&s, sizeof(S), 1, fp);\n"
+                               "    return s.b;\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
-    void functionVariableUsage(const char code[], const char filename[]="test.cpp") {
-        // Clear the error buffer..
-        errout.str("");
+    void structmember16() {
+        checkStructMemberUsage("struct S {\n"
+                               "  static const int N = 128;\n" // <- used
+                               "  char E[N];\n" // <- not used
+                               "};\n");
+        ASSERT_EQUALS("[test.cpp:3:8]: (style) struct member 'S::E' is never used. [unusedStructMember]\n", errout_str());
+    }
+
+    void structmember17() { // #10591
+        checkStructMemberUsage("struct tagT { int i; };\n"
+                               "void f() {\n"
+                               "    struct tagT t{};\n"
+                               "    t.i = 0;\n" // <- used
+                               "    g(t);\n"
+                               "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkStructMemberUsage("typedef struct tagT { int i; } typeT;\n"
+                               "void f() {\n"
+                               "    struct typeT t{};\n"
+                               "    t.i = 0;\n" // <- used
+                               "    g(t);\n"
+                               "};\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkStructMemberUsage("struct T { int i; };\n"
+                               "void f() {\n"
+                               "    struct T t{};\n"
+                               "    t.i = 0;\n" // <- used
+                               "    g(t);\n"
+                               "};\n");
+        ASSERT_EQUALS("", errout_str()); // due to removeMacroInClassDef()
+    }
+
+    void structmember18() { // #10684
+        checkStructMemberUsage("struct S { uint8_t padding[500]; };\n"
+                               "static S s = { 0 };\n"
+                               "uint8_t f() {\n"
+                               "    uint8_t* p = (uint8_t*)&s;\n"
+                               "    return p[10];\n"
+                               "};\n");
+        ASSERT_EQUALS("[test.cpp:1:20]: (style) struct member 'S::padding' is never used. [unusedStructMember]\n", errout_str());
+
+        checkStructMemberUsage("struct S { uint8_t padding[500]; };\n"
+                               "uint8_t f(const S& s) {\n"
+                               "    std::cout << &s;\n"
+                               "    auto p = reinterpret_cast<const uint8_t*>(&s);\n"
+                               "    return p[10];\n"
+                               "};\n");
+        ASSERT_EQUALS("[test.cpp:1:20]: (style) struct member 'S::padding' is never used. [unusedStructMember]\n", errout_str());
+
+        checkStructMemberUsage("struct S { int i, j; };\n" // #11577
+                               "void f(S s) {\n"
+                               "  void* p = (void*)&s;\n"
+                               "  if (s.i) {}\n"
+                               "}\n");
+        ASSERT_EQUALS("[test.cpp:1:19]: (style) struct member 'S::j' is never used. [unusedStructMember]\n", errout_str());
+    }
 
-        // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        if (!tokenizer.tokenize(istr, filename))
-            return;
+    void structmember19() {
+        checkStructMemberUsage("class C {};\n" // #10826
+                               "struct S {\n"
+                               "    char* p;\n"
+                               "    std::string str;\n"
+                               "    C c;\n"
+                               "};\n"
+                               "void f(S* s) {}\n");
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) struct member 'S::p' is never used. [unusedStructMember]\n"
+                      "[test.cpp:4:17]: (style) struct member 'S::str' is never used. [unusedStructMember]\n"
+                      "[test.cpp:5:7]: (style) struct member 'S::c' is never used. [unusedStructMember]\n",
+                      errout_str());
+
+        checkStructMemberUsage("class C {};\n"
+                               "struct S {\n"
+                               "    char* p;\n"
+                               "    std::string str;\n"
+                               "    C c;\n"
+                               "};\n"
+                               "void f(S& s) {}\n");
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) struct member 'S::p' is never used. [unusedStructMember]\n"
+                      "[test.cpp:4:17]: (style) struct member 'S::str' is never used. [unusedStructMember]\n"
+                      "[test.cpp:5:7]: (style) struct member 'S::c' is never used. [unusedStructMember]\n",
+                      errout_str());
+
+        checkStructMemberUsage("struct S {\n" // #10848
+                               "    struct T {\n"
+                               "        int i;\n"
+                               "    } t[2];\n"
+                               "};\n"
+                               "S s[1];\n"
+                               "int f() {\n"
+                               "    return s[0].t[1].i;\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
 
-        // Check for unused variables..
-        CheckUnusedVar checkUnusedVar(&tokenizer, &settings, this);
-        checkUnusedVar.checkFunctionVariableUsage();
+        checkStructMemberUsage("struct S { int a; };\n"
+                               "struct T { S s; };\n"
+                               "int f(const T** tp) {\n"
+                               "    return tp[0]->s.a;\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkStructMemberUsage("struct S { int a; };\n"
+                               "int f(const S* sp) {\n"
+                               "    return (*sp).a; \n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkStructMemberUsage("struct S { int a; };\n"
+                               "int f(const S** spp) {\n"
+                               "    return spp[0]->a;\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkStructMemberUsage("struct S { int a; };\n"
+                               "int f(const S** spp) {\n"
+                               "    return spp[0][0].a;\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkStructMemberUsage("struct S { int a; };\n"
+                               "int f(const S* sp) {\n"
+                               "    return sp[0].a;\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkStructMemberUsage("struct S { int a; };\n"
+                               "int f(const S* sp) {\n"
+                               "    return sp->a;\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkStructMemberUsage("typedef struct { int i; } A;\n"
+                               "typedef struct { std::vector<A> v; } B;\n"
+                               "const A& f(const std::vector<const B*>& b, int idx) {\n"
+                               "    const A& a = b[0]->v[idx];\n"
+                               "    return a;\n"
+                               "}\n");
+        ASSERT_EQUALS("[test.cpp:1:22]: (style) struct member 'A::i' is never used. [unusedStructMember]\n",
+                      errout_str());
+
+        checkStructMemberUsage("struct A {\n" // #10852
+                               "    struct B {\n"
+                               "        int x;\n"
+                               "    } b;\n"
+                               "} a;\n"
+                               "void f() {\n"
+                               "    struct B* pb = &a.b;\n"
+                               "    pb->x = 1;\n"
+                               "}\n", dinit(CheckStructMemberUsageOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+
+        checkStructMemberUsage("union U {\n"
+                               "    struct A {\n"
+                               "        struct B {\n"
+                               "            int x;\n"
+                               "        } b;\n"
+                               "    } a;\n"
+                               "    struct C {\n"
+                               "        short s[2];\n"
+                               "    } c;\n"
+                               "} u;\n"
+                               "void f() {\n"
+                               "    struct B* pb = &u.a.b;\n"
+                               "    pb->x = 1;\n"
+                               "    struct C* pc = &u.c;\n"
+                               "    pc->s[0] = 1;\n"
+                               "}\n", dinit(CheckStructMemberUsageOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void structmember20() { // #10737
+        checkStructMemberUsage("void f() {\n"
+                               "    {\n"
+                               "    }\n"
+                               "    {\n"
+                               "        struct S { int a; };\n"
+                               "        S s{};\n"
+                               "        {\n"
+                               "            if (s.a) {}\n"
+                               "        }\n"
+                               "    }\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void structmember21() { // #4759
+        checkStructMemberUsage("class C {\n"
+                               "public:\n"
+                               "    int f() { return 0; }\n"
+                               "};\n"
+                               "C c;\n"
+                               "int g() {\n"
+                               "    return c.f();\n"
+                               "}\n"
+                               "struct S {\n"
+                               "    int f;\n"
+                               "};\n");
+        ASSERT_EQUALS("[test.cpp:10:9]: (style) struct member 'S::f' is never used. [unusedStructMember]\n", errout_str());
+
+        checkStructMemberUsage("struct A { int i; };\n"
+                               "struct B { struct A* pA; };");
+        ASSERT_EQUALS("[test.cpp:1:16]: (style) struct member 'A::i' is never used. [unusedStructMember]\n"
+                      "[test.cpp:2:22]: (style) struct member 'B::pA' is never used. [unusedStructMember]\n",
+                      errout_str());
+    }
+
+    void structmember22() { // #11016
+        checkStructMemberUsage("struct A { bool b; };\n"
+                               "void f(const std::vector<A>& v) {\n"
+                               "    std::vector<A>::const_iterator it = b.begin();\n"
+                               "    if (it->b) {}\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void structmember23() {
+        checkStructMemberUsage("namespace N {\n"
+                               "    struct S { std::string s; };\n"
+                               "}\n"
+                               "std::string f() {\n"
+                               "    std::map<int, N::S> m = { { 0, { \"abc\" } } };\n"
+                               "    return m[0].s;\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void structmember24() { // #10847
+        checkStructMemberUsage("struct S { std::map<int, S*> m; };\n"
+                               "std::map<int, S*> u;\n"
+                               "std::map<int, S*>::iterator f() {\n"
+                               "    return u.find(0)->second->m.begin();\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkStructMemberUsage("struct S { int i; };\n"
+                               "void f() {\n"
+                               "    std::map<int, S> m = { { 0, S() } };\n"
+                               "    m[0].i = 1;\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkStructMemberUsage("struct S { bool b; };\n"
+                               "std::vector<S> v;\n"
+                               "bool f() {\n"
+                               "    return v.begin()->b;\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkStructMemberUsage("int f(int s) {\n" // #10587
+                               "    const struct S { int a, b; } Map[] = { { 0, 1 }, { 2, 3 } };\n"
+                               "    auto it = std::find_if(std::begin(Map), std::end(Map), [&](const auto& m) { return s == m.a; });\n"
+                               "    if (it != std::end(Map))\n"
+                               "        return it->b;\n"
+                               "    return 0;\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkStructMemberUsage("int f(int s) {\n"
+                               "    const struct S { int a, b; } Map[] = { { 0, 1 }, { 2, 3 } };\n"
+                               "    for (auto&& m : Map)\n"
+                               "        if (m.a == s)\n"
+                               "            return m.b;\n"
+                               "    return 0;\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkStructMemberUsage("struct R { bool b{ false }; };\n" // #11539
+                               "void f(std::optional<R> r) {\n"
+                               "    if (r.has_value())\n"
+                               "        std::cout << r->b;\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void structmember25() {
+        checkStructMemberUsage("struct S {\n" // #12485
+                               "    S* p;\n"
+                               "    int i;\n"
+                               "};\n"
+                               "struct T {\n"
+                               "    S s;\n"
+                               "    int j;\n"
+                               "};\n");
+        ASSERT_EQUALS("[test.cpp:2:8]: (style) struct member 'S::p' is never used. [unusedStructMember]\n"
+                      "[test.cpp:3:9]: (style) struct member 'S::i' is never used. [unusedStructMember]\n"
+                      "[test.cpp:6:7]: (style) struct member 'T::s' is never used. [unusedStructMember]\n"
+                      "[test.cpp:7:9]: (style) struct member 'T::j' is never used. [unusedStructMember]\n",
+                      errout_str());
+    }
+
+    void structmember26() { // #13345
+        checkStructMemberUsage("struct foobar {\n"
+                               "   char unused;\n"
+                               "};\n"
+                               "size_t offset_unused = offsetof(struct foobar, unused);\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void structmember27() { // #13367
+        checkStructMemberUsage("typedef struct pathNode_s {\n"
+                               "    struct pathNode_s*  next;\n"
+                               "} pathNode_t;\n"
+                               "void f() {\n"
+                               "    x<pathNode_t, offsetof( pathNode_t, next )> y;\n"
+                               "}\n");
+        ASSERT_EQUALS("", // don't crash
+                      errout_str());
+    }
+
+    void structmember28() {
+        checkStructMemberUsage("struct S {\n"
+                               "    unsigned int a : 16;\n"
+                               "    unsigned int : 16;\n"
+                               "};\n");
+        ASSERT_EQUALS("[test.cpp:2:18]: (style) struct member 'S::a' is never used. [unusedStructMember]\n", errout_str());
+    }
+
+    void structmember29() { // #14075 - alignas false positive
+        checkStructMemberUsage("struct S {\n"
+                               "    static constexpr size_t cDataAlign = 8;\n"
+                               "    static constexpr size_t cDataSize = 128;\n"
+                               "    alignas(cDataAlign) std::array<uint8_t, cDataSize> storage{};\n"
+                               "};\n");
+        ASSERT_EQUALS("[test.cpp:4:56]: (style) struct member 'S::storage' is never used. [unusedStructMember]\n", errout_str());
+    }
+
+    void structmember30() { // #14131
+        checkStructMemberUsage("struct S\n"
+                               "{\n"
+                               "private:\n"
+                               "    __attribute__((unused)) int i1{};\n"
+                               "    int __attribute__((unused)) i2{}; // no warning\n"
+                               "    int i3 __attribute__((unused)) {};\n"
+                               "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void structmember31() { // #14130
+        checkStructMemberUsage("struct S\n"
+                               "{\n"
+                               "    [[maybe_unused]] int i1{};\n"
+                               "    int i2 [[maybe_unused]] {};\n"
+                               "};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void structmember32() { // #14483
+        checkStructMemberUsage("struct S {\n"
+                               "  int S::* mp;\n"
+                               "};\n");
+        ASSERT_EQUALS("[test.cpp:2:12]: (style) struct member 'S::mp' is never used. [unusedStructMember]\n", errout_str());
+    }
+
+    void structmember33() {
+        checkStructMemberUsage("struct S {\n"
+                               "  int A::B<int>::C::* mp;\n"
+                               "};\n");
+        ASSERT_EQUALS("[test.cpp:2:23]: (style) struct member 'S::mp' is never used. [unusedStructMember]\n", errout_str());
+    }
+
+    void structmember_macro() {
+        checkStructMemberUsageP("#define S(n) struct n { int a, b, c; };\n"
+                                "S(unused);\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void structmember_template_argument() { // #13887 - False positive
+        checkStructMemberUsage("template <class T, int i> struct A{ T buf[i]; }\n"
+                               "struct B {\n"
+                               "    constexpr int x = 20;\n" // <- not unused
+                               "    A<uint32_t, x> a;\n" // <- unused
+                               "};");
+        ASSERT_EQUALS("[test.cpp:4:20]: (style) struct member 'B::a' is never used. [unusedStructMember]\n", errout_str());
+    }
+
+    void classmember() {
+        checkStructMemberUsage("class C {\n"
+                               "    int i{};\n"
+                               "};\n");
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) class member 'C::i' is never used. [unusedStructMember]\n", errout_str());
+
+        checkStructMemberUsage("class C {\n"
+                               "    int i{}, j{};\n"
+                               "public:\n"
+                               "    int& get() { return i; }\n"
+                               "};\n");
+        ASSERT_EQUALS("[test.cpp:2:14]: (style) class member 'C::j' is never used. [unusedStructMember]\n", errout_str());
+
+        checkStructMemberUsage("class C {\n"
+                               "private:\n"
+                               "    int i;\n"
+                               "};\n"
+                               "class D : public C {};\n");
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) class member 'C::i' is never used. [unusedStructMember]\n", errout_str());
+
+        checkStructMemberUsage("class C {\n"
+                               "public:\n"
+                               "    int i;\n"
+                               "};\n"
+                               "class D : C {};\n");
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) class member 'C::i' is never used. [unusedStructMember]\n", errout_str());
+
+        checkStructMemberUsage("class C {\n"
+                               "public:\n"
+                               "    int i;\n"
+                               "};\n"
+                               "class D : public C {};\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void structmemberStructuredBinding() { // #13107
+        checkStructMemberUsage("struct S { int a, b; };\n"
+                               "void f(S &s) {\n"
+                               "    auto& [x, y] = s;\n"
+                               "    x = y;\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkStructMemberUsage("struct S { int a, b; };\n"
+                               "struct T { S s; };\n"
+                               "void f(T &t) {\n"
+                               "    auto& [x, y] = t.s;\n"
+                               "    x = y;\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkStructMemberUsage("struct S { int a, b; };\n"
+                               "void f(std::vector<S> &sv) {\n"
+                               "    for (auto& [x, y] : sv)\n"
+                               "        x = y;\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        // #13551 - don't crash
+        checkStructMemberUsage("struct S {};\n"
+                               "void f(vector<std::pair<int, int>> p) {\n"
+                               "    for (auto [a, _] : p) {\n"
+                               "        if (a == 0) {}\n"
+                               "    }\n"
+                               "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar1() {
+        // extracttests.disable
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int i = 0;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:11]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int i(0);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         // if a is undefined then Cppcheck can't determine if "int i(a)" is a
         // * variable declaration
@@ -558,14 +2189,14 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int i(a);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int j = 0;\n"
                               "    int i(j);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:10]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -573,7 +2204,7 @@ class TestUnusedVar : public TestFixture {
                               "    int & i = j;\n"
                               "    x(j);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:13]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -581,7 +2212,7 @@ class TestUnusedVar : public TestFixture {
                               "    const int & i = j;\n"
                               "    x(j);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:19]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -589,7 +2220,7 @@ class TestUnusedVar : public TestFixture {
                               "    int & i(j);\n"
                               "    x(j);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:12]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -597,145 +2228,171 @@ class TestUnusedVar : public TestFixture {
                               "    const int & i(j);\n"
                               "    x(j);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:18]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int * j = Data;\n"
                               "    int * i(j);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:12]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int * j = Data;\n"
                               "    const int * i(j);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:18]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    bool i = false;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:12]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    bool i = true;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:12]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    char *i;\n"
                               "    i = fgets();\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         // undefined variables are not reported because they may be classes with constructors
         functionVariableUsage("undefined foo()\n"
                               "{\n"
                               "    undefined i = 0;\n"
                               "}");
-        // ? ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:17]: (information) --check-library: Provide <type-checks><unusedvar> configuration for undefined [checkLibraryCheckType]\n", errout_str());
 
         functionVariableUsage("undefined foo()\n"
                               "{\n"
                               "    undefined i = 0;\n"
                               "}\n",
-                              "test.c");
-        ASSERT_EQUALS("[test.c:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+                              dinit(FunctionVariableUsageOptions, $.cpp = false));
+        ASSERT_EQUALS(
+            "[test.c:3:17]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int i = undefined;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:11]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int * i = Data;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:13]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    void * i = Data;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:14]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    const void * i = Data;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:20]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    struct S * i = DATA;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:18]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    const struct S * i = DATA;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:24]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    struct S & i = j;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:18]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    const struct S & i = j;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:24]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    undefined * i = X;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:19]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int i = 0;\n"
                               "    int j = i;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'j' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:4:11]: (style) Variable 'j' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int i[10] = { 0 };\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:15]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo(int n)\n"
                               "{\n"
                               "    int i[n] = { 0 };\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:14]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    char i[10] = \"123456789\";\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:16]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    char *i = \"123456789\";\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:13]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int i = 0;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:11]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -745,7 +2402,7 @@ class TestUnusedVar : public TestFixture {
                               "        code += 2;\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -756,9 +2413,9 @@ class TestUnusedVar : public TestFixture {
                               "        d = code;\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'd' is assigned a value that is never used.\n"
-                      "[test.cpp:7]: (style) Variable 'd' is assigned a value that is never used.\n",
-                      errout.str());
+        ASSERT_EQUALS("[test.cpp:3:24]: (style) Variable 'd' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:7:11]: (style) Variable 'd' is assigned a value that is never used. [unreadVariable]\n",
+                      errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -770,7 +2427,7 @@ class TestUnusedVar : public TestFixture {
                               "        d = code;\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -784,7 +2441,7 @@ class TestUnusedVar : public TestFixture {
                               "        d = code;\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -796,7 +2453,7 @@ class TestUnusedVar : public TestFixture {
                               "        b=tmp;\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -806,7 +2463,7 @@ class TestUnusedVar : public TestFixture {
                               "        code += 2;\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -817,8 +2474,8 @@ class TestUnusedVar : public TestFixture {
                               "        d += code;\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'd' is assigned a value that is never used.\n"
-                      "[test.cpp:7]: (style) Variable 'd' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:18]: (style) Variable 'd' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:7:11]: (style) Variable 'd' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -830,7 +2487,7 @@ class TestUnusedVar : public TestFixture {
                               "        d += code;\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -844,7 +2501,7 @@ class TestUnusedVar : public TestFixture {
                               "        d += code;\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -856,7 +2513,7 @@ class TestUnusedVar : public TestFixture {
                               "        b=tmp;\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -866,7 +2523,7 @@ class TestUnusedVar : public TestFixture {
                               "        code += 2;\n"
                               "    } while(code < 20);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -877,8 +2534,8 @@ class TestUnusedVar : public TestFixture {
                               "        d += code;\n"
                               "    } while(code < 20);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'd' is assigned a value that is never used.\n"
-                      "[test.cpp:7]: (style) Variable 'd' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:18]: (style) Variable 'd' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:7:11]: (style) Variable 'd' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -890,7 +2547,7 @@ class TestUnusedVar : public TestFixture {
                               "        d += code;\n"
                               "    } while(code < 20);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -904,7 +2561,7 @@ class TestUnusedVar : public TestFixture {
                               "        d += code;\n"
                               "    } while(code < 20);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -916,7 +2573,7 @@ class TestUnusedVar : public TestFixture {
                               "        b=tmp;\n"
                               "    } while( a!=30 );\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -928,7 +2585,7 @@ class TestUnusedVar : public TestFixture {
                               "        }\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -940,7 +2597,7 @@ class TestUnusedVar : public TestFixture {
                               "        code += 2;\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -952,7 +2609,7 @@ class TestUnusedVar : public TestFixture {
                               "        }\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -964,28 +2621,33 @@ class TestUnusedVar : public TestFixture {
                               "        }\n"
                               "    } while(code < 20);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo(int j = 0) {\n" // #5985 - default function parameters should not affect checking results
                               "    int i = 0;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:11]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
+        // extracttests.enable
     }
 
     void localvar2() {
+        // extracttests.disable: uninitialized variables and stuff
+
         functionVariableUsage("int foo()\n"
                               "{\n"
                               "    int i;\n"
                               "    return i;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is not assigned a value.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Variable 'i' is not assigned a value. [unassignedVariable]\n", errout_str());
 
         functionVariableUsage("bool foo()\n"
                               "{\n"
                               "    bool i;\n"
                               "    return i;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is not assigned a value.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) Variable 'i' is not assigned a value. [unassignedVariable]\n", errout_str());
 
         // undefined variables are not reported because they may be classes with constructors
         functionVariableUsage("undefined foo()\n"
@@ -993,50 +2655,50 @@ class TestUnusedVar : public TestFixture {
                               "    undefined i;\n"
                               "    return i;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("undefined foo()\n"
                               "{\n"
                               "    undefined i;\n"
                               "    return i;\n"
                               "}\n",
-                              "test.c");
-        ASSERT_EQUALS("[test.c:3]: (style) Variable 'i' is not assigned a value.\n", errout.str());
+                              dinit(FunctionVariableUsageOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:3:15]: (style) Variable 'i' is not assigned a value. [unassignedVariable]\n", errout_str());
 
         functionVariableUsage("undefined *foo()\n"
                               "{\n"
                               "    undefined * i;\n"
                               "    return i;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is not assigned a value.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:17]: (style) Variable 'i' is not assigned a value. [unassignedVariable]\n", errout_str());
 
         functionVariableUsage("int *foo()\n"
                               "{\n"
                               "    int * i;\n"
                               "    return i;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is not assigned a value.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Variable 'i' is not assigned a value. [unassignedVariable]\n", errout_str());
 
         functionVariableUsage("const int *foo()\n"
                               "{\n"
                               "    const int * i;\n"
                               "    return i;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is not assigned a value.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:17]: (style) Variable 'i' is not assigned a value. [unassignedVariable]\n", errout_str());
 
         functionVariableUsage("struct S *foo()\n"
                               "{\n"
                               "    struct S * i;\n"
                               "    return i;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is not assigned a value.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:16]: (style) Variable 'i' is not assigned a value. [unassignedVariable]\n", errout_str());
 
         functionVariableUsage("const struct S *foo()\n"
                               "{\n"
                               "    const struct S * i;\n"
                               "    return i;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is not assigned a value.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:22]: (style) Variable 'i' is not assigned a value. [unassignedVariable]\n", errout_str());
 
         // assume f() can write a
         functionVariableUsage("void foo()\n"
@@ -1044,7 +2706,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a[10];\n"
                               "    f(a[0]);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assume f() can write a
         functionVariableUsage("void foo()\n"
@@ -1052,7 +2714,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a[10];\n"
                               "    f(a[0], 0);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assume f() can write a
         functionVariableUsage("void foo()\n"
@@ -1060,7 +2722,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a[10];\n"
                               "    f(0, a[0]);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // assume f() can write a
         functionVariableUsage("void foo()\n"
@@ -1068,17 +2730,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a[10];\n"
                               "    f(0, a[0], 0);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
-
-        // f() can not write a (not supported yet)
-        functionVariableUsage("void f(int i) { }\n"
-                              "void foo()\n"
-                              "{\n"
-                              "    int a[10];\n"
-                              "    f(a[0]);\n"
-                              "}");
-        TODO_ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'a' is not assigned a value.\n",
-                           "", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // f() can not write a (not supported yet)
         functionVariableUsage("void f(const int & i) { }\n"
@@ -1088,7 +2740,7 @@ class TestUnusedVar : public TestFixture {
                               "    f(a[0]);\n"
                               "}");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'a' is not assigned a value.\n",
-                           "", errout.str());
+                           "", errout_str());
 
         // f() writes a
         functionVariableUsage("void f(int & i) { }\n"
@@ -1097,7 +2749,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a[10];\n"
                               "    f(a[0]);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f(int * i);\n"
                               "void foo()\n"
@@ -1105,18 +2757,19 @@ class TestUnusedVar : public TestFixture {
                               "    int a[10];\n"
                               "    f(a+1);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+        // extracttests.enable
     }
 
     void localvar3() {
-        functionVariableUsage("void foo()\n"
+        functionVariableUsage("void foo(int abc)\n"
                               "{\n"
                               "    int i;\n"
                               "    if ( abc )\n"
                               "        ;\n"
                               "    else i = 0;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:12]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
     void localvar4() {
@@ -1125,14 +2778,14 @@ class TestUnusedVar : public TestFixture {
                               "    int i = 0;\n"
                               "    f(i);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int i = 0;\n"
                               "    f(&i);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar5() {
@@ -1141,26 +2794,37 @@ class TestUnusedVar : public TestFixture {
                               "    int a = 0;\n"
                               "    b = (char)a;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar6() {
-        functionVariableUsage("void foo()\n"
-                              "{\n"
+        functionVariableUsage("void foo() {\n"
                               "    int b[10];\n"
                               "    for (int i=0;i<10;++i)\n"
                               "        b[i] = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'b' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:14]: (style) Variable 'b[i]' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
-        functionVariableUsage("void foo()\n"
-                              "{\n"
+        functionVariableUsage("void foo() {\n"
                               "    int a = 0;\n"
                               "    int b[10];\n"
                               "    for (int i=0;i<10;++i)\n"
                               "        b[i] = ++a;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:6]: (style) Variable 'b' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:14]: (style) Variable 'b[i]' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+
+        functionVariableUsage("void foo() {\n"
+                              "    int b[10];\n"
+                              "    for (int i=0;i<10;++i)\n"
+                              "        *(b+i) = 0;\n"
+                              "}");
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (style) Variable '*(b+i)' is assigned a value that is never used.\n", "", errout_str());
+
+        functionVariableUsage("void f() {\n" // #11832, #11923
+                              "    int b;\n"
+                              "    *(&b) = 0;\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Variable '*(&b)' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
     void localvar8() {
@@ -1168,100 +2832,104 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int i;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int i[2];\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    void * i;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    const void * i;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:18]: (style) Unused variable: i [unusedVariable]\n", errout_str());
+
+        // extracttests.start: struct A {int x;};
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    A * i;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    struct A * i;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:16]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    const struct A * i;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:22]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int * i[2];\n"
                               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: i\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n", "", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    const int * i[2];\n"
                               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: i\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n", "", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    void * i[2];\n"
                               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: i\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n", "", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    const void * i[2];\n"
                               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: i\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n", "", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    struct A * i[2];\n"
                               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: i\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n", "", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    const struct A * i[2];\n"
                               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: i\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n", "", errout_str());
 
         functionVariableUsage("void foo(int n)\n"
                               "{\n"
                               "    int i[n];\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int i = 0;\n"
                               "    int &j = i;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'j' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:12]: (style) Variable 'j' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:3:9]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
+                      errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int i;\n"
                               "    int &j = i;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'j' is assigned a value that is never used.\n"
-                      "[test.cpp:3]: (style) Unused variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:12]: (style) Variable 'j' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -1269,7 +2937,9 @@ class TestUnusedVar : public TestFixture {
                               "    int &j = i;\n"
                               "    j = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'i' is assigned a value that is never used.\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("double foo()\n"
                               "{\n"
@@ -1277,35 +2947,35 @@ class TestUnusedVar : public TestFixture {
                               "    const double j = i;\n"
                               "    return j;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    A * i;\n"
                               "    i->f();\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    char * i;\n"
                               "    if (i);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    char * i = 0;\n"
                               "    if (i);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    char * i = new char[10];\n"
                               "    if (i);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -1318,7 +2988,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    return &a;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int a[10];\n"
                               "void foo()\n"
@@ -1327,7 +2997,7 @@ class TestUnusedVar : public TestFixture {
                               "    for (int i = 0; i < 10; i++)\n"
                               "        p[i] = 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int a[10];\n"
                               "void foo()\n"
@@ -1336,7 +3006,7 @@ class TestUnusedVar : public TestFixture {
                               "    for (int i = 0; i < 10; i++)\n"
                               "        p[i] = 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -1345,20 +3015,24 @@ class TestUnusedVar : public TestFixture {
                               "    a[0] = 0;\n"
                               "    x = a[0];\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (style) Variable 'x' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:7]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
+        // extracttests.start: int f();
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int a, b, c;\n"
                               "    a = b = c = f();\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:4:11]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:4:15]: (style) Variable 'c' is assigned a value that is never used. [unreadVariable]\n",
+                      errout_str());
 
         functionVariableUsage("int * foo()\n"
                               "{\n"
                               "    return &undefined[0];\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar9() {
@@ -1369,7 +3043,7 @@ class TestUnusedVar : public TestFixture {
                               "    for (int i = 0; i < 10; )\n"
                               "        a[i++] = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:16]: (style) Variable 'a[i++]' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
     void localvar10() {
@@ -1382,9 +3056,9 @@ class TestUnusedVar : public TestFixture {
                               "        int i;\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: i\n"
-                      "[test.cpp:5]: (style) Unused variable: i\n"
-                      "[test.cpp:7]: (style) Unused variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n"
+                      "[test.cpp:5:13]: (style) Unused variable: i [unusedVariable]\n"
+                      "[test.cpp:7:13]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo(int x)\n"
                               "{\n"
@@ -1394,9 +3068,9 @@ class TestUnusedVar : public TestFixture {
                               "    else\n"
                               "        int i;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: i\n"
-                      "[test.cpp:5]: (style) Unused variable: i\n"
-                      "[test.cpp:7]: (style) Unused variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n"
+                      "[test.cpp:5:13]: (style) Unused variable: i [unusedVariable]\n"
+                      "[test.cpp:7:13]: (style) Unused variable: i [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo(int x)\n"
                               "{\n"
@@ -1407,9 +3081,10 @@ class TestUnusedVar : public TestFixture {
                               "        int i = 0;\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (style) Variable 'i' is assigned a value that is never used.\n"
-                      "[test.cpp:3]: (style) Unused variable: i\n"
-                      "[test.cpp:5]: (style) Unused variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:7:15]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n"
+                      "[test.cpp:5:13]: (style) Unused variable: i [unusedVariable]\n",
+                      errout_str());
 
         functionVariableUsage("void foo(int x)\n"
                               "{\n"
@@ -1421,9 +3096,9 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "    i = 1;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:9]: (style) Variable 'i' is assigned a value that is never used.\n"
-                      "[test.cpp:5]: (style) Unused variable: i\n"
-                      "[test.cpp:7]: (style) Unused variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:7]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:5:13]: (style) Unused variable: i [unusedVariable]\n"
+                      "[test.cpp:7:13]: (style) Unused variable: i [unusedVariable]\n", errout_str());
     }
 
     void localvar11() {
@@ -1437,8 +3112,8 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "    x = a;\n"  // redundant assignment
                               "}");
-        ASSERT_EQUALS("[test.cpp:6]: (style) Variable 'a' is assigned a value that is never used.\n"
-                      "[test.cpp:9]: (style) Variable 'x' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:11]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:9:7]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         // The variable 'a' is initialized. But the initialized value is
         // never used. It is only initialized for security reasons.
@@ -1453,7 +3128,7 @@ class TestUnusedVar : public TestFixture {
                               "        return;\n"
                               "    x = a;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:10]: (style) Variable 'x' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:7]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
     void localvar12() {
@@ -1464,13 +3139,13 @@ class TestUnusedVar : public TestFixture {
                               "    a = b = c = d = e = f = 15;\n"
                               "}");
         ASSERT_EQUALS(
-            "[test.cpp:4]: (style) Variable 'a' is assigned a value that is never used.\n"
-            "[test.cpp:4]: (style) Variable 'b' is assigned a value that is never used.\n"
-            "[test.cpp:4]: (style) Variable 'c' is assigned a value that is never used.\n"
-            "[test.cpp:4]: (style) Variable 'd' is assigned a value that is never used.\n"
-            "[test.cpp:4]: (style) Variable 'e' is assigned a value that is never used.\n"
-            "[test.cpp:4]: (style) Variable 'f' is assigned a value that is never used.\n",
-            errout.str());
+            "[test.cpp:4:7]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n"
+            "[test.cpp:4:11]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n"
+            "[test.cpp:4:15]: (style) Variable 'c' is assigned a value that is never used. [unreadVariable]\n"
+            "[test.cpp:4:19]: (style) Variable 'd' is assigned a value that is never used. [unreadVariable]\n"
+            "[test.cpp:4:23]: (style) Variable 'e' is assigned a value that is never used. [unreadVariable]\n"
+            "[test.cpp:4:27]: (style) Variable 'f' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -1480,22 +3155,23 @@ class TestUnusedVar : public TestFixture {
                               "}");
 
         TODO_ASSERT_EQUALS(
-            "[test.cpp:4]: (style) Variable 'a' is assigned a value that is never used.\n"
-            "[test.cpp:4]: (style) Variable 'b' is assigned a value that is never used.\n"
-            "[test.cpp:3]: (style) Variable 'c' is assigned a value that is never used.\n",
+            "[test.cpp:4:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n"
+            "[test.cpp:4:7]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n"
+            "[test.cpp:3]: (style) Variable 'c' is assigned a value that is never used. [unreadVariable]\n",
 
-            "[test.cpp:4]: (style) Variable 'a' is assigned a value that is never used.\n"
-            "[test.cpp:4]: (style) Variable 'b' is assigned a value that is never used.\n",
-            errout.str());
+            "[test.cpp:4:7]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n"
+            "[test.cpp:4:11]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
     }
 
     void localvar13() { // ticket #1640
+        // extracttests.start: struct OBJECT { int ySize; };
         functionVariableUsage("void foo( OBJECT *obj )\n"
                               "{\n"
                               "    int x;\n"
                               "    x = obj->ySize / 8;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'x' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
     void localvar14() {
@@ -1504,7 +3180,7 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int a[10];\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: a [unusedVariable]\n", errout_str());
     }
 
     void localvar15() {
@@ -1515,7 +3191,7 @@ class TestUnusedVar : public TestFixture {
                               "    b[0] = 0;\n"
                               "    return b[0];\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo()\n"
                               "{\n"
@@ -1524,7 +3200,7 @@ class TestUnusedVar : public TestFixture {
                               "    b[0] = &c;\n"
                               "    return *b[0];\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int * foo()\n"
                               "{\n"
@@ -1533,7 +3209,7 @@ class TestUnusedVar : public TestFixture {
                               "    b[0] = &c;\n"
                               "    return b[0];\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("struct B * foo()\n"
                               "{\n"
@@ -1542,7 +3218,7 @@ class TestUnusedVar : public TestFixture {
                               "    b[0] = &c;\n"
                               "    return b[0];\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("const struct B * foo()\n"
                               "{\n"
@@ -1551,36 +3227,28 @@ class TestUnusedVar : public TestFixture {
                               "    b[0] = &c;\n"
                               "    return b[0];\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar16() { // ticket #1709
-        functionVariableUsage("int foo()\n"
+        functionVariableUsage("void foo()\n"
                               "{\n"
                               "    char buf[5];\n"
                               "    char *ptr = buf;\n"
                               "    *(ptr++) = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'buf' is assigned a value that is never used.\n", errout.str());
-
-        functionVariableUsage("int foo()\n"
-                              "{\n"
-                              "    char buf[5];\n"
-                              "    char *ptr = buf - 1;\n"
-                              "    *(++ptr) = 0;\n"
-                              "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'buf' is not assigned a value.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'buf' is assigned a value that is never used.\n", "", errout_str());
 
         // #3910
-        functionVariableUsage("int foo() {\n"
+        functionVariableUsage("void foo() {\n"
                               "    char buf[5];\n"
                               "    char *data[2];\n"
                               "    data[0] = buf;\n"
                               "    do_something(data);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        functionVariableUsage("int foo() {\n"
+        functionVariableUsage("void foo() {\n"
                               "    char buf1[5];\n"
                               "    char buf2[5];\n"
                               "    char *data[2];\n"
@@ -1588,10 +3256,11 @@ class TestUnusedVar : public TestFixture {
                               "    data[1] = buf2;\n"
                               "    do_something(data);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar17() { // ticket #1720
+        // extracttests.disable
         // Don't crash when checking the code below!
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -1604,7 +3273,8 @@ class TestUnusedVar : public TestFixture {
                               "    data->info = k;\n"
                               "    line_start = ptr;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:10]: (style) Variable 'line_start' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:10:16]: (style) Variable 'line_start' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+        // extracttests.enable
     }
 
     void localvar18() { // ticket #1723
@@ -1612,7 +3282,7 @@ class TestUnusedVar : public TestFixture {
                               "    UserDefinedException* pe = new UserDefinedException();\n"
                               "    throw pe;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar19() { // ticket #1776
@@ -1621,8 +3291,8 @@ class TestUnusedVar : public TestFixture {
                               "    int c;\n"
                               "    c = *(a);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'c' is assigned a value that is never used.\n"
-                      "[test.cpp:2]: (style) Variable 'a' is not assigned a value.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: (style) Variable 'c' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:2:9]: (style) Variable 'a' is not assigned a value. [unassignedVariable]\n", errout_str());
     }
 
     void localvar20() { // ticket #1799
@@ -1632,7 +3302,7 @@ class TestUnusedVar : public TestFixture {
                               "    char c2[] = { c1 };\n"
                               "    a(c2);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar21() { // ticket #1807
@@ -1641,7 +3311,7 @@ class TestUnusedVar : public TestFixture {
                               "    char buffer[1024];\n"
                               "    bar((void *)buffer);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar22() { // ticket #1811
@@ -1652,7 +3322,7 @@ class TestUnusedVar : public TestFixture {
                               "    i = 1 ? u : v;\n"
                               "    return h + i;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar23() { // ticket #1808
@@ -1663,7 +3333,7 @@ class TestUnusedVar : public TestFixture {
                               "    a = b[c] = 0;\n"
                               "    return a;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'b' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:14]: (style) Variable 'b[c]' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
     void localvar24() { // ticket #1803
@@ -1674,7 +3344,7 @@ class TestUnusedVar : public TestFixture {
                               "        throw *this;\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar25() { // ticket #1729
@@ -1682,10 +3352,10 @@ class TestUnusedVar : public TestFixture {
                               "    int ppos = 1;\n"
                               "    int pneg = 0;\n"
                               "    const char*edge = ppos? \" +\" : pneg ? \" -\" : \"\";\n"
-                              "    printf(\"This should be a '+' -> %s\n\", edge);\n"
+                              "    printf(\"This should be a '+' -> %s\\n\", edge);\n"
                               "    return 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar26() { // ticket #1894
@@ -1694,7 +3364,7 @@ class TestUnusedVar : public TestFixture {
                               "    int *p = fred.x();\n"
                               "    *p = 0;"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar27() { // ticket #2160
@@ -1702,7 +3372,7 @@ class TestUnusedVar : public TestFixture {
                               "    int param = 1;\n"
                               "    ptr->param = param++;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:23]: (style) Variable 'param' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
     void localvar28() { // ticket #2205
@@ -1711,7 +3381,7 @@ class TestUnusedVar : public TestFixture {
                               "    int size = value;\n"
                               "    *(int*)pos = size;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar29() { // ticket #2206
@@ -1720,7 +3390,7 @@ class TestUnusedVar : public TestFixture {
                               "    float* ranges[] = { s_ranges };\n"
                               "    cout << ranges[0][0];\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar30() { // ticket #2264
@@ -1728,7 +3398,7 @@ class TestUnusedVar : public TestFixture {
                               "    Engine *engine = e;\n"
                               "    x->engine = engine->clone();\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar31() { // ticket #2286
@@ -1736,7 +3406,7 @@ class TestUnusedVar : public TestFixture {
                               "    int x = 0;\n"
                               "    a.x = x - b;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar32() {
@@ -1746,45 +3416,33 @@ class TestUnusedVar : public TestFixture {
                               "    fstream &f = getfile();\n"
                               "    f >> x;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ticket #4596 - if (c >>= x) {}
         functionVariableUsage("void f(int x) {\n"
                               "    C c;\n" // possibly some stream class
                               "    if (c >>= x) {}\n"
                               "}");
-        // TODO ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (information) --check-library: Provide <type-checks><unusedvar> configuration for C [checkLibraryCheckType]\n", errout_str());
 
         functionVariableUsage("void f(int x) {\n"
                               "    C c;\n"
                               "    if (c >>= x) {}\n"
-                              "}", "test.c");
-        ASSERT_EQUALS("[test.c:3]: (style) Variable 'c' is assigned a value that is never used.\n", errout.str());
-
-        functionVariableUsage("void f(int c) {\n"
-                              "    int x;\n"
-                              "    if (c >> x) {}\n"
-                              "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Variable 'x' is not assigned a value.\n", errout.str());
+                              "}", dinit(FunctionVariableUsageOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:3:11]: (style) Variable 'c' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void f() {\n"
                               "    int x, y;\n"
                               "    std::cin >> x >> y;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // ticket #8494
         functionVariableUsage("void f(C c) {\n"
                               "  int x;\n"
                               "  c & x;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
-
-        functionVariableUsage("void f(int c) {\n"
-                              "  int x;\n"
-                              "  c & x;\n"
-                              "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Variable 'x' is not assigned a value.\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar33() { // ticket #2345
@@ -1794,7 +3452,7 @@ class TestUnusedVar : public TestFixture {
                               "        ++nOldNum;\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar34() { // ticket #2368
@@ -1805,7 +3463,7 @@ class TestUnusedVar : public TestFixture {
                               "        j -= i;\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar35() { // ticket #2535
@@ -1813,7 +3471,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a, b;\n"
                               "    x(1,a,b);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar36() { // ticket #2805
@@ -1822,32 +3480,32 @@ class TestUnusedVar : public TestFixture {
                               "    a = 2 * (b = 3);\n"
                               "    return a + b;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int f() {\n" // ticket #4318
                               "    int a,b;\n"
                               "    x(a, b=2);\n"  // <- if param2 is passed-by-reference then b might be used in x
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo() {\n" // ticket #6147
                               "    int a = 0;\n"
                               "    bar(a=a+2);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo() {\n" // ticket #6147
                               "    int a = 0;\n"
                               "    bar(a=2);\n"
                               "}");
-        TODO_ASSERT_EQUALS("error", "", errout.str());
+        TODO_ASSERT_EQUALS("error", "", errout_str());
 
         functionVariableUsage("void bar(int);\n"
                               "int foo() {\n"
                               "    int a = 0;\n"
                               "    bar(a=a+2);\n"
                               "}");
-        TODO_ASSERT_EQUALS("error", "", errout.str());
+        TODO_ASSERT_EQUALS("error", "", errout_str());
     }
 
     void localvar37() { // ticket #3078
@@ -1855,7 +3513,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a = 2;\n"
                               "    ints.at(a) = 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar38() {
@@ -1865,7 +3523,7 @@ class TestUnusedVar : public TestFixture {
                               "    const std::string s2 = sizeof_(code);\n"
                               "    return(s1+s2);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar39() {
@@ -1873,7 +3531,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a = 1;\n"
                               "    foo(x*a);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar40() {
@@ -1881,7 +3539,7 @@ class TestUnusedVar : public TestFixture {
                               "    int a = 1;\n"
                               "    return x & a;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar41() {
@@ -1891,7 +3549,7 @@ class TestUnusedVar : public TestFixture {
                               "    int y = FOO::VALUE * x;\n"
                               "    return y;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar42() { // #3742
@@ -1903,7 +3561,7 @@ class TestUnusedVar : public TestFixture {
                               "    const float floatTot = g_float * floatA;\n"
                               "    SomeTestFunc(floatTot);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("float g_float = 1;\n"
                               "extern void SomeTestFunc(float);\n"
@@ -1913,7 +3571,7 @@ class TestUnusedVar : public TestFixture {
                               "    const float floatTot = floatB * g_float;\n"
                               "    SomeTestFunc(floatTot);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("float g_float = 1;\n"
                               "extern void SomeTestFunc(float);\n"
@@ -1923,7 +3581,7 @@ class TestUnusedVar : public TestFixture {
                               "    float floatTot = g_float * floatC;\n"
                               "    SomeTestFunc(floatTot);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar43() { // ticket #3602 (false positive)
@@ -1949,7 +3607,15 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "    delete [] piArray;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int f() {\n" // #9877
+                              "    const std::vector<int> x = get();\n"
+                              "    MACRO(2U, x.size())\n"
+                              "    int i = 0;\n"
+                              "    return i;\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar44() { // #4020 - FP
@@ -1957,7 +3623,7 @@ class TestUnusedVar : public TestFixture {
                               "    int *sp_mem[2] = { global1, global2 };\n"
                               "    sp_mem[0][3] = 123;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar45() { // #4899 - FP
@@ -1966,7 +3632,7 @@ class TestUnusedVar : public TestFixture {
                               "    int b = (short)-a;;\n"
                               "    return b;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar46() { // #5491/#5494/#6301
@@ -1975,34 +3641,75 @@ class TestUnusedVar : public TestFixture {
                               "    int j{i};\n"
                               "    return j;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("void f(bool b, bool c, double& r) {\n"
+                              "    double d{};\n"
+                              "    if (b) {\n"
+                              "      d = g();\n"
+                              "      r += d;\n"
+                              "    }\n"
+                              "    if (c) {\n"
+                              "      d = h();\n"
+                              "      r += d;\n"
+                              "    }\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int func() {\n"
                               "    std::mutex m;\n"
                               "    std::unique_lock<std::mutex> l{ m };\n"
                               "    return 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int func() {\n"
                               "    std::shared_lock<std::shared_timed_mutex> lock( m );\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("void f() {\n" // #10490
+                              "    std::shared_lock lock = GetLock();\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("void f() {\n"
+                              "    auto&& g = std::lock_guard<std::mutex> { mutex };\n"
+                              "}\n");
+        TODO_ASSERT_EQUALS("", "[test.cpp:2:14]: (style) Variable 'g' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+
+        functionVariableUsage("void f() {\n"
+                              "    auto a = RAII();\n"
+                              "    auto b { RAII() };\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("struct RAIIWrapper {\n" // #10894
+                              "    RAIIWrapper();\n"
+                              "    ~RAIIWrapper();\n"
+                              "};\n"
+                              "static void foo() {\n"
+                              "    auto const guard = RAIIWrapper();\n"
+                              "    auto const& guard2 = RAIIWrapper();\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar47() { // #6603
+        // extracttests.disable
         functionVariableUsage("void f() {\n"
                               "    int (SfxUndoManager::*retrieveCount)(bool) const\n"
                               "        = (flag) ? &SfxUndoManager::foo : &SfxUndoManager::bar;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'retrieveCount' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Variable 'retrieveCount' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+        // extracttests.enable
     }
 
     void localvar48() { // #6954
         functionVariableUsage("void foo() {\n"
                               "  long (*pKoeff)[256] = new long[9][256];\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar49() { // #7594
@@ -2023,7 +3730,9 @@ class TestUnusedVar : public TestFixture {
                               "void A::DoSomething(void) {\n"
                               "    const std::string x = Bar();\n"  // <- warning
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:16]: (style) Variable 'x' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:16:25]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
     }
 
     void localvar50() { // #6261, #6542
@@ -2032,13 +3741,13 @@ class TestUnusedVar : public TestFixture {
                               "  char buf1[10];\n"
                               "  dostuff(cond?buf1:buf2);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo() {\n"
                               "  char buf1[10];\n"
                               "  dostuff(cond?buf2:buf1);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6542 - ternary operator
         functionVariableUsage("void foo(int c) {\n"
@@ -2046,21 +3755,22 @@ class TestUnusedVar : public TestFixture {
                               "  char *p = c ? buf1 : buf2;\n"
                               "  dostuff(p);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar51() { // #8128 FN
-        functionVariableUsage("void foo() {\n"
-                              "  const char *tok = var->nameToken();\n"
+        // extracttests.start: struct Token { const Token* next() const; }; const Token* nameToken();
+        functionVariableUsage("void foo(const Token *var) {\n"
+                              "  const Token *tok = nameToken();\n"
                               "  tok = tok->next();\n"  // read+write
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'tok' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:7]: (style) Variable 'tok' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo() {\n"
                               "  int x = 4;\n"
                               "  x = 15 + x;\n"  // read+write
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'x' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
     void localvar52() {
@@ -2069,11 +3779,11 @@ class TestUnusedVar : public TestFixture {
                               "  data[2] = 32;\n"
                               "  return data;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar53() {
-        functionVariableUsage("void foo() {\n"
+        functionVariableUsage("void foo(int a, int loop) {\n"
                               "  bool x = false;\n"
                               "  while (loop) {\n"
                               "    if (a) {\n"
@@ -2082,9 +3792,9 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "  }\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Variable 'x' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:10]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
-        functionVariableUsage("void foo() {\n"
+        functionVariableUsage("void foo(int a, int loop) {\n"
                               "  bool x = false;\n"
                               "  while (loop) {\n"
                               "    if (a) {\n"
@@ -2094,15 +3804,15 @@ class TestUnusedVar : public TestFixture {
                               "  }\n"
                               "  return x;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar54() {
         functionVariableUsage("Padding fun() {\n"
                               "  Distance d = DISTANCE;\n"
                               "  return (Padding){ d, d, d, d };\n"
-                              "}\n");
-        ASSERT_EQUALS("", errout.str());
+                              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar55() {
@@ -2118,9 +3828,9 @@ class TestUnusedVar : public TestFixture {
                               "        }\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Variable 'x' is assigned a value that is never used.\n"
-                      "[test.cpp:6]: (style) Variable 'x' is assigned a value that is never used.\n",
-                      errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:6:15]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n",
+                      errout_str());
     }
 
     void localvar56() {
@@ -2129,7 +3839,7 @@ class TestUnusedVar : public TestFixture {
                               "    int x = 31;\n"
                               "    mask[x] |= 123;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvar57() {
@@ -2138,26 +3848,231 @@ class TestUnusedVar : public TestFixture {
                               "    int x = 0;\n"
                               "    x++;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'x' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:6]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+    }
+
+    void localvar58() { // #9901 - increment false positive
+        functionVariableUsage("void f() {\n"
+                              "    int x = 0;\n"
+                              "    if (--x > 0) {}\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("void f() {\n"
+                              "    int x = 0;\n"
+                              "    if (x-- > 0) {}\n"
+                              "}");
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+    }
+
+    void localvar59() { // #9737
+        functionVariableUsage("Response foo() {\n"
+                              "    const std::vector<char> cmanifest = z;\n"
+                              "    return {.a = cmanifest, .b =0};\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localvar60() {
+        functionVariableUsage("void Scale(double scale) {\n" // #10531
+                              "    for (int i = 0; i < m_points.size(); ++i) {\n"
+                              "        auto& p = m_points[i];\n"
+                              "        p += scale;\n"
+                              "    }\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("void foo(int c[]) {\n" // #10597
+                              "    int& cc = c[0];\n"
+                              "    cc &= ~0xff;\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localvar61() { // #9407
+        functionVariableUsage("void g(int& i);\n"
+                              "void f() {\n"
+                              "    int var = 0;\n"
+                              "    g(var);\n"
+                              "    var = 2;\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:9]: (style) Variable 'var' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+    }
+
+    void localvar62() {
+        functionVariableUsage("void f() {\n" // #10824
+                              "    S* s = nullptr;\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:8]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+
+        functionVariableUsage("void f() {\n"
+                              "    S* s{};\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+
+        functionVariableUsage("int f() {\n"
+                              "    int i = 0, j = 1;\n"
+                              "    return i;\n"
+                              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:2:18]: (style) Variable 'j' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
+
+        functionVariableUsage("int f() {\n"
+                              "    int i = 0, j = 1;\n"
+                              "    return j;\n"
+                              "}\n");
+        ASSERT_EQUALS(
+            "[test.cpp:2:11]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
+
+        functionVariableUsage("void f() {\n" // #10846
+                              "    int i = 1; while (i) { i = g(); }\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localvar63() { // #6928
+        functionVariableUsage("void f(void) {\n"
+                              "  int x=3;\n"             // <- set but not used
+                              "  goto y;\n"
+                              "  y:return;\n"
+                              "}");
+        ASSERT_EQUALS("[test.cpp:2:7]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+    }
+
+    void localvar64() { // #9997
+        functionVariableUsage("class S {\n"
+                              "    ~S();\n"
+                              "    S* f();\n"
+                              "    S* g(int);\n"
+                              "};\n"
+                              "void h(S* s, bool b) {\n"
+                              "    S* p = nullptr;\n"
+                              "    S* q = nullptr;\n"
+                              "    if (b) {\n"
+                              "        p = s;\n"
+                              "        q = s->f()->g(-2);\n"
+                              "    }\n"
+                              "    else\n"
+                              "        q = s;\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:10:11]: (style) Variable 'p' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:11:11]: (style) Variable 'q' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:14:11]: (style) Variable 'q' is assigned a value that is never used. [unreadVariable]\n",
+                      errout_str());
+    }
+
+    void localvar65() {
+        functionVariableUsage("bool b();\n" // #9876
+                              "void f() {\n"
+                              "    for (;;) {\n"
+                              "        const T* t = tok->next()->link()->next();\n"
+                              "        if (!b())\n"
+                              "            continue;\n"
+                              "    }\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:18]: (style) Variable 't' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+
+        functionVariableUsage("void f() {\n" // #10006
+                              "    std::string s = \"\";\n"
+                              "    try {}\n"
+                              "    catch (...) {}\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+    }
+
+    void localvar66() { // #11143
+        functionVariableUsage("void f() {\n"
+                              "    double phi = 42.0;\n"
+                              "    std::cout << pow(sin(phi), 2) + pow(cos(phi), 2) << std::endl;\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localvar67() { // #9946
+        functionVariableUsage("struct B {\n"
+                              "    virtual ~B() {}\n"
+                              "    bool operator() () const { return true; }\n"
+                              "    virtual bool f() const = 0;\n"
+                              "};\n"
+                              "class D : B {\n"
+                              "public:\n"
+                              "    bool f() const override { return false; }\n"
+                              "};\n"
+                              "void f1() {\n"
+                              "    const D d1;\n"
+                              "    d1.f();\n"
+                              "}\n"
+                              "void f2() {\n"
+                              "    const D d2;\n"
+                              "    d2();\n"
+                              "        B() {}\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localvar68() {
+        checkFunctionVariableUsageP("#define X0 int x = 0\n"
+                                    "void f() { X0; }\n");
+        ASSERT_EQUALS("", errout_str());
+
+        checkFunctionVariableUsageP("#define X0 int (*x)(int) = 0\n"
+                                    "void f() { X0; }\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localvar69() {
+        functionVariableUsage("int g();\n" // #11063
+                              "int h(int);\n"
+                              "int f() {\n"
+                              "    int i = g();\n"
+                              "    return (::h)(i);\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localvar70() {
+        functionVariableUsage("struct S { int i = 0; };\n" // #12176
+                              "void f(S s) {\n"
+                              "    S s1;\n"
+                              "    if (s == s1) {}\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localvar71() {
+        functionVariableUsage("struct A { explicit A(int i); };\n" // #12363
+                              "void f() { A a(0); }\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localvar72() {
+        functionVariableUsage("void f()\n"
+                              "{\n"
+                              "  struct S {};\n"
+                              "  int S::* mp;\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:12]: (style) Unused variable: mp [unusedVariable]\n", errout_str());
     }
 
     void localvarloops() {
         // loops
-        functionVariableUsage("void fun() {\n"
+        functionVariableUsage("void fun(int c) {\n"
                               "  int x;\n"
                               "  while (c) { x=10; }\n"
-                              "}\n");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'x' is assigned a value that is never used.\n", errout.str());
+                              "}");
+        ASSERT_EQUALS("[test.cpp:3:16]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void dostuff(int x);\n"
-                              "void fun() {\n"
+                              "void fun(int y, int c) {\n"
                               "  int x = 1;\n"
                               "  while (c) {\n"
                               "    dostuff(x);\n"
                               "    if (y) { x=10; break; }\n"
                               "  }\n"
-                              "}\n");
-        ASSERT_EQUALS("[test.cpp:6]: (style) Variable 'x' is assigned a value that is never used.\n", errout.str());
+                              "}");
+        ASSERT_EQUALS("[test.cpp:6:15]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void dostuff(int &x);\n"
                               "void fun() {\n"
@@ -2166,8 +4081,8 @@ class TestUnusedVar : public TestFixture {
                               "    dostuff(x);\n"
                               "    if (y) { x=10; break; }\n"
                               "  }\n"
-                              "}\n");
-        ASSERT_EQUALS("", errout.str()); // TODO : in this special case we can ignore that x is aliased. x is local and there are no function calls after the assignment
+                              "}");
+        ASSERT_EQUALS("[test.cpp:6:15]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void fun() {\n"
                               "  int x = 0;\n"
@@ -2175,14 +4090,14 @@ class TestUnusedVar : public TestFixture {
                               "    dostuff(x);\n"
                               "    x = 10;\n"
                               "  }\n"
-                              "}\n");
-        ASSERT_EQUALS("", errout.str());
+                              "}");
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void fun() {\n"
                               "  int x = 0;\n"
                               "  while (x < 10) { x = x + 1; }\n"
-                              "}\n");
-        ASSERT_EQUALS("", errout.str());
+                              "}");
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void fun()\n"
                               "{\n"
@@ -2190,7 +4105,7 @@ class TestUnusedVar : public TestFixture {
                               "    for (ind = 0; ((ind < nrArgs) && (status < 10)); ind++)\n"
                               "        status = x;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f()\n"
                               "{\n"
@@ -2198,8 +4113,63 @@ class TestUnusedVar : public TestFixture {
                               "    for (i = 0U; i < 2U; i++)\n"
                               "        sum += 123;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'sum' is assigned a value that is never used.\n"
-                      "[test.cpp:5]: (style) Variable 'sum' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:13]: (style) Variable 'sum' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:5:13]: (style) Variable 'sum' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+
+        functionVariableUsage("void f(int c) {\n" // #7908
+                              "    int b = 0;\n"
+                              "    while (g()) {\n"
+                              "        int a = c;\n"
+                              "        b = a;\n"
+                              "        if (a == 4)\n"
+                              "            a = 5;\n"
+                              "    }\n"
+                              "    h(b);\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:7:15]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+
+        functionVariableUsage("void f(const std::vector<int>& v) {\n"
+                              "    while (g()) {\n"
+                              "        const std::vector<int>& v2 = h();\n"
+                              "        if (std::vector<int>{ 1, 2, 3 }.size() > v2.size()) {}\n"
+                              "    }\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("void f(const std::vector<int>& v) {\n"
+                              "    while (g()) {\n"
+                              "        const std::vector<int>& v2 = h();\n"
+                              "        if (std::vector<int>({ 1, 2, 3 }).size() > v2.size()) {}\n"
+                              "    }\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("void f(const std::string &c) {\n"
+                              "    std::string s = str();\n"
+                              "    if (s[0] == '>')\n"
+                              "        s[0] = '<';\n"
+                              "    if (s == c) {}\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("void f(bool b) {\n"
+                              "    std::map<std::string, std::vector<std::string>> m;\n"
+                              "    if (b) {\n"
+                              "        const std::string n = g();\n"
+                              "        std::vector<std::string> c = h();\n"
+                              "        m[n] = c;\n"
+                              "    }\n"
+                              "    j(m);\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("struct S { int i; };\n"
+                              "S f(S s, bool b) {\n"
+                              "    if (b)\n"
+                              "        s.i = 1;\n"
+                              "    return s;\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvaralias1() {
@@ -2208,16 +4178,18 @@ class TestUnusedVar : public TestFixture {
                               "    int a;\n"
                               "    int *b = &a;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'b' is assigned a value that is never used.\n"
-                      "[test.cpp:3]: (style) Unused variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:12]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:3:9]: (style) Unused variable: a [unusedVariable]\n",
+                      errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int a[10];\n"
                               "    int *b = a;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'b' is assigned a value that is never used.\n"
-                      "[test.cpp:3]: (style) Unused variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:12]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:3:9]: (style) Unused variable: a [unusedVariable]\n",
+                      errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2225,7 +4197,9 @@ class TestUnusedVar : public TestFixture {
                               "    int *b = &a;\n"
                               "    *b = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2233,7 +4207,9 @@ class TestUnusedVar : public TestFixture {
                               "    char *b = (char *)&a;\n"
                               "    *b = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2241,7 +4217,9 @@ class TestUnusedVar : public TestFixture {
                               "    char *b = (char *)(&a);\n"
                               "    *b = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2249,7 +4227,9 @@ class TestUnusedVar : public TestFixture {
                               "    const char *b = (const char *)&a;\n"
                               "    *b = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2257,7 +4237,9 @@ class TestUnusedVar : public TestFixture {
                               "    const char *b = (const char *)(&a);\n"
                               "    *b = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2265,7 +4247,9 @@ class TestUnusedVar : public TestFixture {
                               "    char *b = static_cast<char *>(&a);\n"
                               "    *b = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2273,7 +4257,9 @@ class TestUnusedVar : public TestFixture {
                               "    const char *b = static_cast<const char *>(&a);\n"
                               "    *b = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
+                           "",
+                           errout_str());
 
         // a is not a local variable and b is aliased to it
         functionVariableUsage("int a;\n"
@@ -2281,14 +4267,18 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int *b = &a;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'b' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:4:12]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         // a is not a local variable and b is aliased to it
         functionVariableUsage("void foo(int a)\n"
                               "{\n"
                               "    int *b = &a;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'b' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:12]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         // a is not a local variable and b is aliased to it
         functionVariableUsage("class A\n"
@@ -2298,8 +4288,10 @@ class TestUnusedVar : public TestFixture {
                               "    {\n"
                               "        int *b = &a;\n"
                               "    }\n"
-                              "}");
-        ASSERT_EQUALS("[test.cpp:6]: (style) Variable 'b' is assigned a value that is never used.\n", errout.str());
+                              "};");
+        ASSERT_EQUALS(
+            "[test.cpp:6:16]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("int a;\n"
                               "void foo()\n"
@@ -2307,14 +4299,14 @@ class TestUnusedVar : public TestFixture {
                               "    int *b = &a;\n"
                               "    *b = 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo(int a)\n"
                               "{\n"
                               "    int *b = &a;\n"
                               "    *b = 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("class A\n"
                               "{\n"
@@ -2325,7 +4317,7 @@ class TestUnusedVar : public TestFixture {
                               "        *b = 0;\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2333,7 +4325,9 @@ class TestUnusedVar : public TestFixture {
                               "    int *b = a;\n"
                               "    *b = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2341,7 +4335,9 @@ class TestUnusedVar : public TestFixture {
                               "    char *b = (char *)a;\n"
                               "    *b = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2349,7 +4345,9 @@ class TestUnusedVar : public TestFixture {
                               "    char *b = (char *)(a);\n"
                               "    *b = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2357,7 +4355,9 @@ class TestUnusedVar : public TestFixture {
                               "    const char *b = (const char *)a;\n"
                               "    *b = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2365,7 +4365,9 @@ class TestUnusedVar : public TestFixture {
                               "    const char *b = (const char *)(a);\n"
                               "    *b = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2373,7 +4375,9 @@ class TestUnusedVar : public TestFixture {
                               "    char *b = static_cast<char *>(a);\n"
                               "    *b = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2381,7 +4385,9 @@ class TestUnusedVar : public TestFixture {
                               "    const char *b = static_cast<const char *>(a);\n"
                               "    *b = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("int a[10];\n"
                               "void foo()\n"
@@ -2389,7 +4395,7 @@ class TestUnusedVar : public TestFixture {
                               "    int *b = a;\n"
                               "    *b = 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int a[10];\n"
                               "void foo()\n"
@@ -2398,7 +4404,7 @@ class TestUnusedVar : public TestFixture {
                               "    int *c = b;\n"
                               "    *c = 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2406,7 +4412,7 @@ class TestUnusedVar : public TestFixture {
                               "    int *c = b;\n"
                               "    *c = 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2414,24 +4420,16 @@ class TestUnusedVar : public TestFixture {
                               "    int *c = b;\n"
                               "    *c = b[0];\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
+        // extracttests.start: int a[10];
         functionVariableUsage("void foo()\n"
-                              "{\n"
-                              "    int *b = a;\n"
-                              "    int *c;\n"
-                              "    *c = b[0];\n"
-                              "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'c' is not assigned a value.\n", errout.str());
-
-        functionVariableUsage("int a[10];\n"
-                              "void foo()\n"
                               "{\n"
                               "    int *b = a;\n"
                               "    int c = b[0];\n"
                               "    x(c);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2439,7 +4437,7 @@ class TestUnusedVar : public TestFixture {
                               "    int c = b[0];\n"
                               "    x(c);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int a[10];\n"
                               "void foo()\n"
@@ -2447,28 +4445,28 @@ class TestUnusedVar : public TestFixture {
                               "    int *b = &a[0];\n"
                               "    a[0] = b[0];\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int *b = &a[0];\n"
                               "    a[0] = b[0];\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int *b = a;\n"
                               "    a[0] = b[0];\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo(int a[10])\n"
                               "{\n"
                               "    int *b = a;\n"
                               "    *b = 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("class A\n"
                               "{\n"
@@ -2479,7 +4477,7 @@ class TestUnusedVar : public TestFixture {
                               "        *b = 0;\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2488,7 +4486,9 @@ class TestUnusedVar : public TestFixture {
                               "    int *c = b;\n"
                               "    *c = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:6]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:6]: (style) Variable 'a' is assigned a value that is never used.\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2498,9 +4498,9 @@ class TestUnusedVar : public TestFixture {
                               "    int *d = b;\n"
                               "    *d = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: a\n"
-        // TODO               "[test.cpp:7]: (style) Variable 'b' is assigned a value that is never used.\n"
-        // TODO               "[test.cpp:5]: (style) Variable 'c' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:12]: (style) Variable 'c' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:3:9]: (style) Unused variable: a [unusedVariable]\n",
+                      errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2510,8 +4510,8 @@ class TestUnusedVar : public TestFixture {
                               "    c = b;\n"
                               "    *c = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: a\n"
-        // TODO               "[test.cpp:7]: (style) Variable 'b' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (style) Unused variable: a [unusedVariable]\n",
+                      errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2523,15 +4523,19 @@ class TestUnusedVar : public TestFixture {
                               "    c = a;\n"
                               "    *c = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:9]: (style) Variable 'a' is assigned a value that is never used.\n"
-        // TODO               "[test.cpp:7]: (style) Variable 'b' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:9]: (style) Variable 'a' is assigned a value that is never used.\n"
+                           "[test.cpp:7]: (style) Variable 'b' is assigned a value that is never used.\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    int a[10], * b = a + 10;\n"
                               "    b[-10] = 1;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'b[-10]' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'b[-10]' is assigned a value that is never used.\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2539,16 +4543,10 @@ class TestUnusedVar : public TestFixture {
                               "    b[-10] = 0;\n"
                               "    int * c = b - 10;\n"
                               "}");
-        ASSERT_EQUALS(// TODO "[test.cpp:4]: (style) Variable 'a' is assigned a value that is never used.\n"
-            "[test.cpp:5]: (style) Variable 'c' is assigned a value that is never used.\n", errout.str());
-
-        functionVariableUsage("void foo()\n"
-                              "{\n"
-                              "    int a[10], * b = a + 10;\n"
-                              "    int * c = b - 10;\n"
-                              "    x = c[0];\n"
-                              "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'a' is not assigned a value.\n", errout.str());
+        TODO_ASSERT_EQUALS(
+            "[test.cpp:4:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
+            "[test.cpp:5:13]: (style) Variable 'c' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2556,7 +4554,9 @@ class TestUnusedVar : public TestFixture {
                               "    int * c = b - 10;\n"
                               "    c[1] = 3;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'c[1]' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'c[1]' is assigned a value that is never used.\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2564,16 +4564,9 @@ class TestUnusedVar : public TestFixture {
                               "    int * c = b - 10;\n"
                               "    c[1] = c[0];\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'c[1]' is assigned a value that is never used.\n", errout.str());
-
-        functionVariableUsage("void foo()\n"
-                              "{\n"
-                              "    int a[10], * b = a + 10;\n"
-                              "    int * c = b - 10;\n"
-                              "    int d = c[0];\n"
-                              "    f(d);\n"
-                              "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'a' is not assigned a value.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'c[1]' is assigned a value that is never used.\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo() {\n" // #4022 - FP (a is assigned a value that is never used)
                               "    int a[2], *b[2];\n"
@@ -2582,7 +4575,7 @@ class TestUnusedVar : public TestFixture {
                               "    int *d = b[0];\n"
                               "    return *d;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo() {\n" // #4022 - FP (a is assigned a value that is never used)
                               "    entry a[2], *b[2];\n"
@@ -2591,7 +4584,7 @@ class TestUnusedVar : public TestFixture {
                               "    int d = b[0].value;\n"
                               "    return d;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("struct S { char c[100]; };\n"
                               "void foo()\n"
@@ -2600,7 +4593,7 @@ class TestUnusedVar : public TestFixture {
                               "    struct S * s = (struct S *)a;\n"
                               "    s->c[0] = 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("struct S { char c[100]; };\n"
                               "void foo()\n"
@@ -2608,8 +4601,9 @@ class TestUnusedVar : public TestFixture {
                               "    char a[100];\n"
                               "    struct S * s = (struct S *)a;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (style) Variable 's' is assigned a value that is never used.\n"
-                      "[test.cpp:4]: (style) Unused variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:18]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:4:10]: (style) Unused variable: a [unusedVariable]\n",
+                      errout_str());
 
         functionVariableUsage("struct S { char c[100]; };\n"
                               "void foo()\n"
@@ -2617,8 +4611,9 @@ class TestUnusedVar : public TestFixture {
                               "    char a[100];\n"
                               "    const struct S * s = (const struct S *)a;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (style) Variable 's' is assigned a value that is never used.\n"
-                      "[test.cpp:4]: (style) Unused variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:24]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:4:10]: (style) Unused variable: a [unusedVariable]\n",
+                      errout_str());
 
         functionVariableUsage("struct S { char c[100]; };\n"
                               "void foo()\n"
@@ -2626,8 +4621,9 @@ class TestUnusedVar : public TestFixture {
                               "    char a[100];\n"
                               "    struct S * s = static_cast<struct S *>(a);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (style) Variable 's' is assigned a value that is never used.\n"
-                      "[test.cpp:4]: (style) Unused variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:18]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:4:10]: (style) Unused variable: a [unusedVariable]\n",
+                      errout_str());
 
         functionVariableUsage("struct S { char c[100]; };\n"
                               "void foo()\n"
@@ -2635,8 +4631,9 @@ class TestUnusedVar : public TestFixture {
                               "    char a[100];\n"
                               "    const struct S * s = static_cast<const struct S *>(a);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (style) Variable 's' is assigned a value that is never used.\n"
-                      "[test.cpp:4]: (style) Unused variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:24]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:4:10]: (style) Unused variable: a [unusedVariable]\n",
+                      errout_str());
 
         functionVariableUsage("int a[10];\n"
                               "void foo()\n"
@@ -2649,8 +4646,8 @@ class TestUnusedVar : public TestFixture {
                               "    d = c;\n"
                               "    *d = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:4]: (style) Unused variable: b\n"
-        // TODO               "[test.cpp:10]: (style) Variable 'c' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9]: (style) Unused variable: b [unusedVariable]\n",
+                      errout_str());
 
         functionVariableUsage("int a[10];\n"
                               "void foo()\n"
@@ -2662,8 +4659,10 @@ class TestUnusedVar : public TestFixture {
                               "    d = a; *d = 0;\n"
                               "    d = c; *d = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:7]: (style) Variable 'b' is assigned a value that is never used.\n"
-        // TODO               "[test.cpp:9]: (style) Variable 'c' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:7]: (style) Variable 'b' is assigned a value that is never used.\n"
+                           "[test.cpp:9]: (style) Variable 'c' is assigned a value that is never used.\n",
+                           "",
+                           errout_str());
     }
 
     void localvaralias2() { // ticket 1637
@@ -2672,7 +4671,7 @@ class TestUnusedVar : public TestFixture {
                               "    int * a;\n"
                               "    x(a);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvaralias3() { // ticket 1639
@@ -2683,7 +4682,7 @@ class TestUnusedVar : public TestFixture {
                               "    info.pszDisplayName = szDisplayName;\n"
                               "    SHBrowseForFolder(&info);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvaralias4() { // ticket 1643
@@ -2692,7 +4691,9 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    int * a = &ab.a;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:4:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("struct AB { int a; int b; } ab;\n"
                               "void foo()\n"
@@ -2700,7 +4701,7 @@ class TestUnusedVar : public TestFixture {
                               "    int * a = &ab.a;\n"
                               "    *a = 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("struct AB { int a; int b; };\n"
                               "void foo()\n"
@@ -2708,8 +4709,9 @@ class TestUnusedVar : public TestFixture {
                               "    struct AB ab;\n"
                               "    int * a = &ab.a;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'a' is assigned a value that is never used.\n"
-                      "[test.cpp:4]: (style) Variable 'ab' is not assigned a value.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:13]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:4:15]: (style) Variable 'ab' is not assigned a value. [unassignedVariable]\n",
+                      errout_str());
 
         functionVariableUsage("struct AB { int a; int b; };\n"
                               "void foo()\n"
@@ -2718,7 +4720,7 @@ class TestUnusedVar : public TestFixture {
                               "    int * a = &ab.a;\n"
                               "    *a = 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvaralias5() { // ticket 1647
@@ -2729,7 +4731,7 @@ class TestUnusedVar : public TestFixture {
                               "    *p++ = 0;\n"
                               "    return buf[0];\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("char foo()\n"
                               "{\n"
@@ -2738,7 +4740,7 @@ class TestUnusedVar : public TestFixture {
                               "    *p-- = 0;\n"
                               "    return buf[0];\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("char foo()\n"
                               "{\n"
@@ -2747,7 +4749,7 @@ class TestUnusedVar : public TestFixture {
                               "    *++p = 0;\n"
                               "    return buf[0];\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("char foo()\n"
                               "{\n"
@@ -2756,10 +4758,11 @@ class TestUnusedVar : public TestFixture {
                               "    *--p = 0;\n"
                               "    return buf[0];\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvaralias6() { // ticket 1729
+        // extracttests.start: int a(); void b(const char *);
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    char buf[8];\n"
@@ -2772,7 +4775,7 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "    b(srcdata);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2785,7 +4788,9 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "    b(srcdata);\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:6]: (style) Variable 'buf' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:6]: (style) Variable 'buf' is assigned a value that is never used.\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2798,9 +4803,11 @@ class TestUnusedVar : public TestFixture {
                               "    srcdata = vdata;\n"
                               "    b(srcdata);\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:6]: (style) Variable 'buf' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:6]: (style) Variable 'buf' is assigned a value that is never used.\n",
+                           "",
+                           errout_str());
 
-        functionVariableUsage("void foo()\n"
+        functionVariableUsage("void foo(char *vdata)\n"
                               "{\n"
                               "    char buf[8];\n"
                               "    char *srcdata;\n"
@@ -2810,7 +4817,7 @@ class TestUnusedVar : public TestFixture {
                               "    srcdata = vdata;\n"
                               "    b(srcdata);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: buf\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) Unused variable: buf [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2822,7 +4829,7 @@ class TestUnusedVar : public TestFixture {
                               "    srcdata = buf;\n"
                               "    b(srcdata);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2837,7 +4844,7 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "    b(srcdata);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2851,7 +4858,9 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "    b(srcdata);\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:7]: (style) Variable 'buf' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:7]: (style) Variable 'buf' is assigned a value that is never used.\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2865,7 +4874,9 @@ class TestUnusedVar : public TestFixture {
                               "    srcdata = vdata;\n"
                               "    b(srcdata);\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:7]: (style) Variable 'buf' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:7]: (style) Variable 'buf' is assigned a value that is never used.\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2878,7 +4889,7 @@ class TestUnusedVar : public TestFixture {
                               "    srcdata = vdata;\n"
                               "    b(srcdata);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: buf\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) Unused variable: buf [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2891,7 +4902,7 @@ class TestUnusedVar : public TestFixture {
                               "    srcdata = buf;\n"
                               "    b(srcdata);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (style) Unused variable: vdata\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:10]: (style) Unused variable: vdata [unusedVariable]\n", errout_str());
     }
 
     void localvaralias7() { // ticket 1732
@@ -2902,7 +4913,7 @@ class TestUnusedVar : public TestFixture {
                               "    cp = c;\n"
                               "    *cp = 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvaralias8() {
@@ -2923,7 +4934,7 @@ class TestUnusedVar : public TestFixture {
                               "        pb = b4;\n"
                               "    b(pb);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2944,7 +4955,7 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "    b(pb);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -2967,7 +4978,7 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "    b(pb);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
 
         functionVariableUsage("void foo()\n"
@@ -2986,9 +4997,9 @@ class TestUnusedVar : public TestFixture {
                               "    pb = b4;\n"
                               "    b(pb);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: b1\n"
-                      "[test.cpp:4]: (style) Unused variable: b2\n"
-                      "[test.cpp:5]: (style) Unused variable: b3\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) Unused variable: b1 [unusedVariable]\n"
+                      "[test.cpp:4:10]: (style) Unused variable: b2 [unusedVariable]\n"
+                      "[test.cpp:5:10]: (style) Unused variable: b3 [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -3011,7 +5022,7 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "    b(pb);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -3036,7 +5047,7 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "    b(pb);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -3063,7 +5074,7 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "    b(pb);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -3085,9 +5096,9 @@ class TestUnusedVar : public TestFixture {
                               "    pb = b4;\n"
                               "    b(pb);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: b1\n"
-                      "[test.cpp:4]: (style) Unused variable: b2\n"
-                      "[test.cpp:5]: (style) Unused variable: b3\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:10]: (style) Unused variable: b1 [unusedVariable]\n"
+                      "[test.cpp:4:10]: (style) Unused variable: b2 [unusedVariable]\n"
+                      "[test.cpp:5:10]: (style) Unused variable: b3 [unusedVariable]\n", errout_str());
     }
 
     void localvaralias9() { // ticket 1996
@@ -3097,16 +5108,7 @@ class TestUnusedVar : public TestFixture {
                               "    Foo &ref = foo;\n"
                               "    ref[0] = 123;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
-
-        functionVariableUsage("void foo()\n"
-                              "{\n"
-                              "    Foo foo;\n"
-                              "    Foo &ref = foo;\n"
-                              "    ref[0] = 123;\n"
-                              "}",
-                              "test.c");
-        // TODO ASSERT_EQUALS("[test.c:5]: (style) Variable 'foo' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvaralias10() { // ticket 2004
@@ -3116,16 +5118,7 @@ class TestUnusedVar : public TestFixture {
                               "    int *x = &ref.x();\n"
                               "    *x = 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
-
-        functionVariableUsage("void foo(Foo &foo)\n"
-                              "{\n"
-                              "    Foo &ref = foo;\n"
-                              "    int *x = &ref.x;\n"
-                              "    *x = 0;\n"
-                              "}",
-                              "test.c");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvaralias11() { // #4423 - iterator
@@ -3133,7 +5126,7 @@ class TestUnusedVar : public TestFixture {
                               "    std::set<int>::iterator x = foo.dostuff();\n"
                               "    *(x) = 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvaralias12() { // #4394
@@ -3142,14 +5135,14 @@ class TestUnusedVar : public TestFixture {
                               "    int *b = (int*)((int*)a+1);\n"
                               "    x(b);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int f(void) {\n" // #4628
                               "    int x=1,y;\n"
                               "    y = (x * a) / 100;\n"
                               "    return y;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvaralias13() { // #4487
@@ -3158,14 +5151,14 @@ class TestUnusedVar : public TestFixture {
                               "    p = a;\n"
                               "    strcpy(p, \"x\");\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f(char *p) {\n"
                               "    char a[4];\n"
                               "    p = a;\n"
                               "    strcpy(p, \"x\");\n"
                               "}");
-        TODO_ASSERT_EQUALS("a is assigned value that is never used", "", errout.str());
+        TODO_ASSERT_EQUALS("a is assigned value that is never used", "", errout_str());
     }
 
     void localvaralias14() { // #5619
@@ -3174,20 +5167,20 @@ class TestUnusedVar : public TestFixture {
                               "    char a[4], *p=a;\n"
                               "    p = dostuff(p);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'p' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: (style) Variable 'p' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("char * dostuff(char *&p);\n"
                               "void f() {\n"
                               "    char a[4], *p=a;\n"
                               "    p = dostuff(p);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str()); // TODO: we can warn in this special case; variable is local and there are no function calls after the assignment
+        ASSERT_EQUALS("", errout_str()); // TODO: we can warn in this special case; variable is local and there are no function calls after the assignment
 
         functionVariableUsage("void f() {\n"
                               "    char a[4], *p=a;\n"
                               "    p = dostuff(p);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str()); // TODO: we can warn in this special case; variable is local and there are no function calls after the assignment
+        ASSERT_EQUALS("", errout_str()); // TODO: we can warn in this special case; variable is local and there are no function calls after the assignment
     }
 
     void localvaralias15() { // #6315
@@ -3197,7 +5190,7 @@ class TestUnusedVar : public TestFixture {
                               "  int *p2[1] = {p};\n"
                               "  dostuff(p2);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvaralias16() {
@@ -3206,7 +5199,7 @@ class TestUnusedVar : public TestFixture {
                               "  p = x;\n"
                               "  x->data[0] = 9;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvaralias17() {
@@ -3214,8 +5207,8 @@ class TestUnusedVar : public TestFixture {
                               "  int x;\n"
                               "  unknown_type p = &x;\n"
                               "  *p = 9;\n"
-                              "}", "test.c");
-        ASSERT_EQUALS("", errout.str());
+                              "}", dinit(FunctionVariableUsageOptions, $.cpp = false));
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvaralias18() {
@@ -3231,7 +5224,85 @@ class TestUnusedVar : public TestFixture {
                               "        }\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("void f(const std::vector<int>& v) {\n" // #13303
+                              "    std::vector<int>::const_iterator it = v.cbegin();\n"
+                              "    if (*it == 0)\n"
+                              "        it = v.cend();\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:12]: (style) Variable 'it' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+    }
+
+    void localvaralias19() { // #9828
+        functionVariableUsage("void f() {\n"
+                              "    bool b0{}, b1{};\n"
+                              "    struct {\n"
+                              "        bool* pb;\n"
+                              "        int val;\n"
+                              "    } Map[] = { {&b0, 0}, {&b1, 1} };\n"
+                              "    b0 = true;\n"
+                              "    for (auto & m : Map)\n"
+                              "        if (m.pb && *m.pb)\n"
+                              "            m.val = 1;\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localvaralias20() { // #10966
+        functionVariableUsage("struct A {};\n"
+                              "A g();\n"
+                              "void f() {\n"
+                              "    const auto& a = g();\n"
+                              "    const auto& b = a;\n"
+                              "    const auto&& c = g();\n"
+                              "    auto&& d = c;\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:19]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:7:14]: (style) Variable 'd' is assigned a value that is never used. [unreadVariable]\n",
+                      errout_str());
+    }
+
+    void localvaralias21() { // #11728
+        functionVariableUsage("void f(int i) {\n"
+                              "    bool b = true;\n"
+                              "    bool* p = &b;\n"
+                              "    int j{};\n"
+                              "    if (i)\n"
+                              "        b = false;\n"
+                              "    if (*p) {}\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:4:10]: (style) Variable 'j' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+    }
+
+    void localvaralias22() { // #11139
+        functionVariableUsage("int f() {\n"
+                              "    int x[1], *p = x;\n"
+                              "    x[0] = 42;\n"
+                              "    return *p;\n"
+                              "}\n"
+                              "int g() {\n"
+                              "    int x[1], *p{ x };\n"
+                              "    x[0] = 42;\n"
+                              "    return *p;\n"
+                              "}\n"
+                              "int h() {\n"
+                              "    int x[1], *p(x);\n"
+                              "    x[0] = 42;\n"
+                              "    return *p;\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localvaralias23() { // #11817
+        functionVariableUsage("void f(int& r, bool a, bool b) {\n"
+                              "    int& e = r;\n"
+                              "    if (a)\n"
+                              "        e = 42;\n"
+                              "    else if (b)\n"
+                              "        e = 1;\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarasm() {
@@ -3242,7 +5313,7 @@ class TestUnusedVar : public TestFixture {
                               "    asm();\n"
                               "    b = a;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarStruct1() {
@@ -3251,7 +5322,7 @@ class TestUnusedVar : public TestFixture {
                               "    static const struct{ int x, y, w, h; } bounds = {1,2,3,4};\n"
                               "    return bounds.x + bounds.y + bounds.w + bounds.h;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarStruct2() {
@@ -3260,7 +5331,9 @@ class TestUnusedVar : public TestFixture {
                               "    struct ABC { int a, b, c; };\n"
                               "    struct ABC abc = { 1, 2, 3 };\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'abc' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:4:20]: (style) Variable 'abc' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
     }
 
     void localvarStruct3() {
@@ -3273,42 +5346,37 @@ class TestUnusedVar : public TestFixture {
                               "    } while(a--);\n"
                               "}");
         TODO_ASSERT_EQUALS("[test.cpp:4]: (style) Unused variable: x\n"
-                           "[test.cpp:4]: (style) Unused variable: z\n", "", errout.str());
+                           "[test.cpp:4]: (style) Unused variable: z\n", "", errout_str());
     }
 
     void localvarStruct5() {
+        // extracttests.disable
         functionVariableUsage("int foo() {\n"
                               "    A a;\n"
                               "    return a.i;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo() {\n"
                               "    A a;\n"
                               "    return 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo() {\n"
                               "    A a;\n"
                               "    return 0;\n"
                               "}\n",
-                              "test.c");
-        ASSERT_EQUALS("[test.c:2]: (style) Unused variable: a\n", errout.str());
+                              dinit(FunctionVariableUsageOptions, $.cpp = false));
+        ASSERT_EQUALS("[test.c:2:7]: (style) Unused variable: a [unusedVariable]\n", errout_str());
+        // extracttests.enable
 
         functionVariableUsage("struct A { int i; };\n"
                               "int foo() {\n"
                               "    A a;\n"
                               "    return a.i;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
-
-        functionVariableUsage("class A { int i; };\n"
-                              "int foo() {\n"
-                              "    A a;\n"
-                              "    return a.i;\n"
-                              "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("struct A { int i; };\n"
                               "int foo() {\n"
@@ -3316,71 +5384,69 @@ class TestUnusedVar : public TestFixture {
                               "    a.i = 0;\n"
                               "    return 0;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'a.i' is assigned a value that is never used.\n", errout.str());
-
-        functionVariableUsage("class A { int i; };\n"
-                              "int foo() {\n"
-                              "    A a;\n"
-                              "    a.i = 0;\n"
-                              "    return 0;\n"
-                              "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'a.i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:9]: (style) Variable 'a.i' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("struct A { int i; };\n"
                               "int foo() {\n"
                               "    A a = { 0 };\n"
                               "    return 0;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:9]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
+        // extracttests.disable
         functionVariableUsage("class A { int i; };\n"
                               "int foo() {\n"
                               "    A a = { 0 };\n"
                               "    return 0;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:9]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
+        // extracttests.enable
         functionVariableUsage("class A { int i; public: A(); { } };\n"
                               "int foo() {\n"
                               "    A a;\n"
                               "    return 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("struct A { int i; };\n"
                               "int foo() {\n"
                               "    A a;\n"
                               "    return 0;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:7]: (style) Unused variable: a [unusedVariable]\n", errout_str());
 
         functionVariableUsage("class A { int i; };\n"
                               "int foo() {\n"
                               "    A a;\n"
                               "    return 0;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:7]: (style) Unused variable: a [unusedVariable]\n", errout_str());
 
         functionVariableUsage("class A { int i; public: A(); { } };\n"
                               "int foo() {\n"
                               "    A a;\n"
                               "    return 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("class A { unknown i; };\n"
                               "int foo() {\n"
                               "    A a;\n"
                               "    return 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("class A : public Fred { int i; };\n"
                               "int foo() {\n"
                               "    A a;\n"
                               "    return 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("class Fred {char c;};\n"
                               "class A : public Fred { int i; };\n"
@@ -3388,7 +5454,7 @@ class TestUnusedVar : public TestFixture {
                               "    A a;\n"
                               "    return 0;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Unused variable: a\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:7]: (style) Unused variable: a [unusedVariable]\n", errout_str());
     }
 
     void localvarStruct6() {
@@ -3399,7 +5465,7 @@ class TestUnusedVar : public TestFixture {
                               "private:\n"
                               "    Type t;\n"
                               "};");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarStruct7() {
@@ -3413,11 +5479,12 @@ class TestUnusedVar : public TestFixture {
                               "  aatt.text = tmp;\n"
                               "  dostuff(args);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
+        // extracttests.start: void dostuff(int*);
         functionVariableUsage("struct ARG {\n"
-                              "  void *a;\n"
-                              "  void *b;\n"
+                              "  int a;\n"
+                              "  int b;\n"
                               "};\n"
                               "\n"
                               "void fun() {\n"
@@ -3426,7 +5493,7 @@ class TestUnusedVar : public TestFixture {
                               "  aatt.a = 123;\n"
                               "  dostuff(p);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:9]: (style) Variable 'aatt.a' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:9:10]: (style) Variable 'aatt.a' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("struct AB {\n"
                               "  int a;\n"
@@ -3439,20 +5506,124 @@ class TestUnusedVar : public TestFixture {
                               "  ab.a = 123;\n"
                               "  dostuff(a);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localvarStruct8() {
+        functionVariableUsage("struct s {\n"
+                              "     union {\n"
+                              "         struct {\n"
+                              "             int fld1 : 16;\n"
+                              "             int fld2 : 16;\n"
+                              "         };\n"
+                              "         int raw;\n"
+                              "     };\n"
+                              "};\n"
+                              "\n"
+                              "void foo() {\n"
+                              "      struct s test;\n"
+                              "      test.raw = 0x100;\n"
+                              "      dostuff(test.fld1, test.fld2);\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localvarStruct9() {
+        functionVariableUsage("struct XY { int x; int y; };\n"
+                              "\n"
+                              "void foo() {\n"
+                              "      struct XY xy(get());\n"
+                              "      return xy.x + xy.y;\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localvarStruct10() { // #6766
+        functionVariableUsage("struct S { int x; };\n"
+                              "\n"
+                              "void foo(const struct S s2) {\n"
+                              "    struct S s;\n"
+                              "    s.x = 3;\n"
+                              "    memcpy (&s, &s2, sizeof (S));\n"
+                              "}");
+        ASSERT_EQUALS("[test.cpp:5:9]: (style) Variable 's.x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+    }
+
+    void localvarStruct11() { // #10095
+        functionVariableUsage("struct Point { int x; int y; };\n"
+                              "Point scale(Point *p);\n"
+                              "\n"
+                              "int foo() {\n"
+                              "    Point p;\n"
+                              "    p.x = 42;\n"
+                              "    return scale(&p).y;\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localvarStruct12() { // #10495
+        functionVariableUsage("struct S { bool& Ref(); };\n"
+                              "\n"
+                              "void Set() {\n"
+                              "    S s;\n"
+                              "    s.Ref() = true;\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localvarStruct13() { // #10398
+        functionVariableUsage("int f() {\n"
+                              "    std::vector<std::string> Mode;\n"
+                              "    Info Block = {\n"
+                              "        {\n"
+                              "            { &Mode  },\n"
+                              "            { &Level }\n"
+                              "        }\n"
+                              "    };\n"
+                              "    Mode.resize(N);\n"
+                              "    for (int i = 0; i < N; ++i)\n"
+                              "        Mode[i] = \"abc\";\n"
+                              "    return Save(&Block);\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localvarStruct14() { // #12142
+        functionVariableUsage("struct S { int i; };\n"
+                              "int f() {\n"
+                              "    S s;\n"
+                              "    int S::* p = &S::i;\n"
+                              "    s.*p = 123;\n"
+                              "    return s.i;\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarStructArray() {
+        // extracttests.start: struct X {int a;};
+
         // #3633 - detect that struct array is assigned a value
         functionVariableUsage("void f() {\n"
                               "    struct X x[10];\n"
                               "    x[0].a = 5;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'x[0].a' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:12]: (style) Variable 'x[0].a' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+    }
+
+    void localvarUnion1() {
+        // #9707
+        functionVariableUsage("static short read(FILE *fp) {\n"
+                              "    typedef union { short s; unsigned char c[2]; } u;\n"
+                              "    u x;\n"
+                              "    x.c[0] = fgetuc(fp);\n"
+                              "    x.c[1] = fgetuc(fp);\n"
+                              "    return x.s;\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarOp() {
-        const char op[] = "+-*/%&|^";
+        constexpr char op[] = "+-*/%&|^";
         for (const char *p = op; *p; ++p) {
             std::string code("int main()\n"
                              "{\n"
@@ -3460,7 +5631,7 @@ class TestUnusedVar : public TestFixture {
                              "    return 123 " + std::string(1, *p) + " tmp;\n"
                              "}");
             functionVariableUsage(code.c_str());
-            ASSERT_EQUALS("", errout.str());
+            ASSERT_EQUALS("", errout_str());
         }
     }
 
@@ -3470,7 +5641,7 @@ class TestUnusedVar : public TestFixture {
                               "    int tmp = 10;\n"
                               "    return ~tmp;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarIf() {
@@ -3481,18 +5652,97 @@ class TestUnusedVar : public TestFixture {
                               "        return 1;\n"
                               "    return 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("bool argsMatch(const Token *first, const Token *second) {\n" // #6145
+                              "    if (first->str() == \")\")\n"
+                              "        return true;\n"
+                              "    else if (first->next()->str() == \"=\")\n"
+                              "        first = first->nextArgument();\n"
+                              "    else if (second->next()->str() == \"=\") {\n"
+                              "        second = second->nextArgument();\n"
+                              "        if (second)\n"
+                              "            second = second->tokAt(-2);\n"
+                              "        if (!first || !second) {\n"
+                              "            return !first && !second;\n"
+                              "        }\n"
+                              "    }\n"
+                              "    return false;\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:5:15]: (style) Variable 'first' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
     void localvarIfElse() {
         functionVariableUsage("int foo()\n"
                               "{\n"
-                              "    int tmp1 = 1;\n"
-                              "    int tmp2 = 2;\n"
-                              "    int tmp3 = 3;\n"
-                              "    return tmp1 ? tmp2 : tmp3;\n"
+                              "    int tmp1 = 1;\n"
+                              "    int tmp2 = 2;\n"
+                              "    int tmp3 = 3;\n"
+                              "    return tmp1 ? tmp2 : tmp3;\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localvarDeclaredInIf() {
+        functionVariableUsage("int foo(int x)\n"
+                              "{\n"
+                              "    if (int y = x % 2)\n"
+                              "        return 2;\n"
+                              "    else\n"
+                              "        return 1;\n"
+                              "}");
+        ASSERT_EQUALS(
+            "[test.cpp:3:15]: (style) Variable 'y' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
+
+        functionVariableUsage("int foo(int x)\n"
+                              "{\n"
+                              "    if (int y = x % 2)\n"
+                              "        return y;\n"
+                              "    else\n"
+                              "        return 1;\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int foo(int x)\n"
+                              "{\n"
+                              "    if (int y = x % 2)\n"
+                              "        return 2;\n"
+                              "    else\n"
+                              "        return y;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int f(int i) {\n" // #11788
+                              "    if (int x = i) {\n"
+                              "        return x;\n"
+                              "    }\n"
+                              "    else {\n"
+                              "        x = 12;\n"
+                              "        return x;\n"
+                              "    }\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("void f(int i) {\n"
+                              "    if (int x = i) {\n"
+                              "        while (x < 100) {\n"
+                              "            if (x % 2 == 0) {\n"
+                              "                x += 3;\n"
+                              "            }\n"
+                              "            else if (x % 3 == 0) {\n"
+                              "                x += 5;\n"
+                              "            }\n"
+                              "            else {\n"
+                              "                x += 7;\n"
+                              "            }\n"
+                              "            x += 6;\n"
+                              "        }\n"
+                              "        return x;\n"
+                              "    }\n"
+                              "    return i;\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarOpAssign() {
@@ -3502,14 +5752,14 @@ class TestUnusedVar : public TestFixture {
                               "    int b = 2;\n"
                               "    a |= b;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'a' is assigned a value that is never used.\n"
-                      "[test.cpp:5]: (style) Variable 'a' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:5:7]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo() {\n"
                               "    int a = 1;\n"
                               "    (b).x += a;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo() {\n"
                               "    int a=1, b[10];\n"
@@ -3517,7 +5767,7 @@ class TestUnusedVar : public TestFixture {
                               "    a += b[0];\n"
                               "    return a;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f(int *start, int *stop) {\n"
                               "  int length = *start - *stop;\n"
@@ -3525,22 +5775,29 @@ class TestUnusedVar : public TestFixture {
                               "    length = 10000;\n"
                               "  *stop -= length;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f(int a) {\n"
                               "  int x = 3;\n"
                               "  a &= ~x;\n"
                               "  return a;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
-        // FIXME : this is probably inconclusive
-        functionVariableUsage("void f() {\n"
+        // extracttests.disable
+        functionVariableUsage("void f() {\n"  // unknown class => library configuration is needed
                               "  Fred fred;\n"
                               "  int *a; a = b;\n"
                               "  fred += a;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'fred' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:8]: (information) --check-library: Provide <type-checks><unusedvar> configuration for Fred [checkLibraryCheckType]\n", errout_str());
+        // extracttests.enable
+
+        functionVariableUsage("void f(std::pair<int,int> x) {\n"
+                              "  std::pair<int,int> fred;\n"  // class with library configuration
+                              "  fred = x;\n"
+                              "}");
+        ASSERT_EQUALS("[test.cpp:3:8]: (style) Variable 'fred' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
     void localvarFor() {
@@ -3549,13 +5806,13 @@ class TestUnusedVar : public TestFixture {
                               "    int a = 1;\n"
                               "    for (;a;);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo() {\n"
                               "    for (int i = 0; (pci = cdi_list_get(pciDevices, i)); i++)\n"
                               "    {}\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarForEach() { // #4155 - foreach
@@ -3567,7 +5824,7 @@ class TestUnusedVar : public TestFixture {
                               "        i = x;\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #5154 - MSVC 'for each'
         functionVariableUsage("void f() {\n"
@@ -3575,7 +5832,7 @@ class TestUnusedVar : public TestFixture {
                               "  ints[0]= 1;\n"
                               "  for each(std::pair<int,int> i in ints) { x += i.first; }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarShift1() {
@@ -3584,7 +5841,7 @@ class TestUnusedVar : public TestFixture {
                               "    int var = 1;\n"
                               "    return 1 >> var;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarShift3() {  // #3509
@@ -3593,14 +5850,14 @@ class TestUnusedVar : public TestFixture {
                               "    QList<int *> ints;\n"
                               "    ints << 1;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo() {\n" // #4320
                               "    int x;\n"
                               "    x << 1;\n"
                               "    return x;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarCast() {
@@ -3610,7 +5867,7 @@ class TestUnusedVar : public TestFixture {
                               "    int b = static_cast<int>(a);\n"
                               "    return b;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarClass() {
@@ -3621,7 +5878,7 @@ class TestUnusedVar : public TestFixture {
                               "        int f() { return a; }\n"
                               "    } b;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarUnused() {
@@ -3629,37 +5886,44 @@ class TestUnusedVar : public TestFixture {
                               "{\n"
                               "    bool test __attribute__((unused));\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo()\n"
                               "{\n"
                               "    bool test __attribute__((unused)) = true;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo()\n"
                               "{\n"
                               "    bool __attribute__((unused)) test;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo()\n"
                               "{\n"
                               "    bool __attribute__((unused)) test = true;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo()\n"
                               "{\n"
                               "    bool test __attribute__((used));\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo()\n"
                               "{\n"
                               "    bool __attribute__((used)) test;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int foo()\n"
+                              "{\n"
+                              "    char a[1] __attribute__((unused));\n"
+                              "    char b[1][2] __attribute__((unused));\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarFunction() {
@@ -3670,34 +5934,46 @@ class TestUnusedVar : public TestFixture {
                               "  fn = reinterpret_cast<function_type>(dlsym(h, \"try_allocation\"));\n"
                               "  fn();\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarstatic() {
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    static int i;\n"
+                              "    static const int ci;\n"
+                              "    static std::string s;\n"
+                              "    static const std::string cs;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:16]: (style) Unused variable: i [unusedVariable]\n"
+                      "[test.cpp:4:22]: (style) Unused variable: ci [unusedVariable]\n"
+                      "[test.cpp:5:24]: (style) Unused variable: s [unusedVariable]\n"
+                      "[test.cpp:6:30]: (style) Unused variable: cs [unusedVariable]\n",
+                      errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    static int i = 0;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:16]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
+                      errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    static int i(0);\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3:11]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    static int j = 0;\n"
                               "    static int i(j);\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'i' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:4:10]: (style) Variable 'i' is assigned a value that is never used. [unreadVariable]\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("int * foo(int x)\n"
                               "{\n"
@@ -3707,7 +5983,9 @@ class TestUnusedVar : public TestFixture {
                               "    b[1] = 1;\n"
                               "    return x ? a : c;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:6]: (style) Variable 'b' is assigned a value that is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:6:16]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n",
+                           "",
+                           errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -3715,7 +5993,7 @@ class TestUnusedVar : public TestFixture {
                               "    if(i < foo())\n"
                               "        i += 5;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo() {\n"
                               "    static int x = 0;\n"
@@ -3725,7 +6003,31 @@ class TestUnusedVar : public TestFixture {
                               "    else\n"
                               "        x++;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("void foo(int value) {\n"
+                              "    static int array[16] = {0};\n"
+                              "    if(array[value]) {}\n"
+                              "    array[value] = 1;\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int fun() {\n" // #11310
+                              "    static int k;\n"
+                              "    k++;\n"
+                              "    return k;\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int& f() {\n" // #12935
+                              "    static int i;\n"
+                              "    return i;\n"
+                              "}\n"
+                              "int* g() {\n"
+                              "    static int j;\n"
+                              "    return &j;\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarextern() {
@@ -3733,7 +6035,7 @@ class TestUnusedVar : public TestFixture {
                               "    extern int i;\n"
                               "    i = 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvardynamic1() {
@@ -3742,57 +6044,39 @@ class TestUnusedVar : public TestFixture {
                               "    void* ptr = malloc(16);\n"
                               "    free(ptr);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'ptr' is allocated memory that is never used.\n", errout.str());
-
-        functionVariableUsage("void foo()\n"
-                              "{\n"
-                              "    void* ptr = g_malloc(16);\n"
-                              "    g_free(ptr);\n"
-                              "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'ptr' is allocated memory that is never used.\n", errout.str());
-
-        functionVariableUsage("void foo()\n"
-                              "{\n"
-                              "    void* ptr = kmalloc(16, GFP_KERNEL);\n"
-                              "    kfree(ptr);\n"
-                              "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'ptr' is allocated memory that is never used.\n", errout.str());
-
-        functionVariableUsage("void foo()\n"
-                              "{\n"
-                              "    void* ptr = vmalloc(16, GFP_KERNEL);\n"
-                              "    vfree(ptr);\n"
-                              "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'ptr' is allocated memory that is never used.\n", errout.str());
-
+        ASSERT_EQUALS("[test.cpp:3:17]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    char* ptr = new char[16];\n"
                               "    delete[] ptr;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'ptr' is allocated memory that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
+
+        // extracttests.disable
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    char* ptr = new ( nothrow ) char[16];\n"
                               "    delete[] ptr;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'ptr' is allocated memory that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    char* ptr = new ( std::nothrow ) char[16];\n"
                               "    delete[] ptr;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'ptr' is allocated memory that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
+
+        // extracttests.enable
 
         functionVariableUsage("void foo()\n"
                               "{\n"
                               "    char* ptr = new char;\n"
                               "    delete ptr;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'ptr' is allocated memory that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:11]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -3800,7 +6084,7 @@ class TestUnusedVar : public TestFixture {
                               "    ptr[0] = 123;\n"
                               "    free(ptr);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -3808,7 +6092,7 @@ class TestUnusedVar : public TestFixture {
                               "    ptr[0] = 123;\n"
                               "    delete[] ptr;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -3816,7 +6100,7 @@ class TestUnusedVar : public TestFixture {
                               "    std::cout << \"test\" << std::endl;\n"
                               "    delete fred;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("struct Fred { int a; };\n"
                               "void foo()\n"
@@ -3825,7 +6109,7 @@ class TestUnusedVar : public TestFixture {
                               "    std::cout << \"test\" << std::endl;\n"
                               "    delete fred;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'fred' is allocated memory that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Variable 'fred' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("struct Fred { int a; Fred() : a(0) {} };\n"
                               "void foo()\n"
@@ -3834,7 +6118,7 @@ class TestUnusedVar : public TestFixture {
                               "    std::cout << \"test\" << std::endl;\n"
                               "    delete fred;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Variable 'fred' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("void foo()\n"
                               "{\n"
@@ -3842,7 +6126,7 @@ class TestUnusedVar : public TestFixture {
                               "    std::cout << \"test\" << std::endl;\n"
                               "    free(fred);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'fred' is allocated memory that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:18]: (style) Variable 'fred' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
 
         functionVariableUsage("void foo()\n"
@@ -3850,43 +6134,43 @@ class TestUnusedVar : public TestFixture {
                               "    char* ptr = names[i];\n"
                               "    delete[] ptr;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvardynamic2() {
         functionVariableUsage("struct Fred { int i; };\n"
                               "void foo()\n"
                               "{\n"
-                              "    Fred* ptr = malloc(sizeof(Fred));\n"
+                              "    Fred* ptr = (Fred*)malloc(sizeof(Fred));\n"
                               "    free(ptr);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'ptr' is allocated memory that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:31]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("struct Fred { int i; };\n"
                               "void foo()\n"
                               "{\n"
-                              "    Fred* ptr = malloc(sizeof(Fred));\n"
+                              "    Fred* ptr = (Fred*)malloc(sizeof(Fred));\n"
                               "    ptr->i = 0;\n"
                               "    free(ptr);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("struct Fred { int i; };\n"
                               "void foo()\n"
                               "{\n"
-                              "    struct Fred* ptr = malloc(sizeof(Fred));\n"
+                              "    struct Fred* ptr = (Fred*)malloc(sizeof(Fred));\n"
                               "    free(ptr);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'ptr' is allocated memory that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:38]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("struct Fred { int i; };\n"
                               "void foo()\n"
                               "{\n"
-                              "    struct Fred* ptr = malloc(sizeof(Fred));\n"
+                              "    struct Fred* ptr = (Fred*)malloc(sizeof(Fred));\n"
                               "    ptr->i = 0;\n"
                               "    free(ptr);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("struct Fred { int i; };\n"
                               "void foo()\n"
@@ -3894,7 +6178,9 @@ class TestUnusedVar : public TestFixture {
                               "    Fred* ptr = new Fred();\n"
                               "    delete ptr;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'ptr' is allocated memory that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
+
+        // extracttests.disable
 
         functionVariableUsage("struct Fred { int i; };\n"
                               "void foo()\n"
@@ -3902,7 +6188,7 @@ class TestUnusedVar : public TestFixture {
                               "    Fred* ptr = new (nothrow ) Fred();\n"
                               "    delete ptr;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'ptr' is allocated memory that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("struct Fred { int i; };\n"
                               "void foo()\n"
@@ -3910,7 +6196,9 @@ class TestUnusedVar : public TestFixture {
                               "    Fred* ptr = new (std::nothrow) Fred();\n"
                               "    delete ptr;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'ptr' is allocated memory that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
+
+        // extracttests.enable
 
         functionVariableUsage("struct Fred { int i; };\n"
                               "void foo()\n"
@@ -3919,15 +6207,15 @@ class TestUnusedVar : public TestFixture {
                               "    ptr->i = 0;\n"
                               "    delete ptr;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("struct Fred { int i; };\n"
                               "void foo()\n"
                               "{\n"
                               "    struct Fred* ptr = new Fred();\n"
-                              "    free(ptr);\n"
+                              "    delete ptr;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'ptr' is allocated memory that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:18]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("struct Fred { int i; };\n"
                               "void foo()\n"
@@ -3936,24 +6224,24 @@ class TestUnusedVar : public TestFixture {
                               "    ptr->i = 0;\n"
                               "    free(ptr);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("class Fred { public: int i; };\n"
                               "void foo()\n"
                               "{\n"
-                              "    Fred* ptr = malloc(sizeof(Fred));\n"
+                              "    Fred* ptr = (Fred*)malloc(sizeof(Fred));\n"
                               "    free(ptr);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'ptr' is allocated memory that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:31]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("class Fred { public: int i; };\n"
                               "void foo()\n"
                               "{\n"
-                              "    Fred* ptr = malloc(sizeof(Fred));\n"
+                              "    Fred* ptr = (Fred*)malloc(sizeof(Fred));\n"
                               "    ptr->i = 0;\n"
                               "    free(ptr);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("class Fred { public: int i; };\n"
                               "void foo()\n"
@@ -3961,7 +6249,7 @@ class TestUnusedVar : public TestFixture {
                               "    Fred* ptr = new Fred();\n"
                               "    delete ptr;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (style) Variable 'ptr' is allocated memory that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:11]: (style) Variable 'ptr' is allocated memory that is never used. [unusedAllocatedMemory]\n", errout_str());
 
         functionVariableUsage("class Fred { public: int i; };\n"
                               "void foo()\n"
@@ -3970,7 +6258,7 @@ class TestUnusedVar : public TestFixture {
                               "    ptr->i = 0;\n"
                               "    delete ptr;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvardynamic3() {
@@ -3981,7 +6269,9 @@ class TestUnusedVar : public TestFixture {
                               "    for ( int i = 0; i < 10; ++i )\n"
                               "        p++;\n"
                               "}");
-        // TODO ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'p' is modified but its new value is never used.\n", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'p' is modified but its new value is never used.\n",
+                           "",
+                           errout_str());
     }
 
     void localvararray1() {
@@ -3989,7 +6279,7 @@ class TestUnusedVar : public TestFixture {
                               "    int p[5];\n"
                               "    *p = 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvararray2() {
@@ -3998,7 +6288,7 @@ class TestUnusedVar : public TestFixture {
                               "    p[0][0] = 0;\n"
                               "    return p[0][0];\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvararray3() {
@@ -4007,7 +6297,7 @@ class TestUnusedVar : public TestFixture {
                               "    *((int*)p[0]) = 0;\n"
                               "    return p[0][0];\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvararray4() {
@@ -4017,7 +6307,7 @@ class TestUnusedVar : public TestFixture {
                               "    p[0] = 1;\n"
                               "    *pp[0] = p[0];\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvararray5() {
@@ -4025,42 +6315,84 @@ class TestUnusedVar : public TestFixture {
                               "    int p[5][5];\n"
                               "    dostuff(*p);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int foo() {\n"
+                              "    int p[5];\n"
+                              "    dostuff(*p);\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int foo() {\n"
+                              "    int p[5][5][5];\n"
+                              "    dostuff(**p);\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("void f() {\n" // #11872
+                              "    char v[1][2];\n"
+                              "}");
+        ASSERT_EQUALS("[test.cpp:2:10]: (style) Unused variable: v [unusedVariable]\n", errout_str());
+    }
+
+    void localvararray6() {
+        functionVariableUsage("struct S { int* p; };\n" // #11012
+                              "void g(struct S* ps);\n"
+                              "void f() {\n"
+                              "    int i[2];\n"
+                              "    struct S s = { i };\n"
+                              "    g(&s);\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarstring1() { // ticket #1597
         functionVariableUsage("void foo() {\n"
                               "    std::string s;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Unused variable: s\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) Unused variable: s [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void foo() {\n"
                               "    std::string s;\n"
                               "    s = \"foo\";\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Variable 's' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:7]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void foo() {\n"
                               "    std::string s = \"foo\";\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Variable 's' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:19]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("void foo() {\n" // #8901
                               "    const std::string s = \"foo\";\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Variable 's' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:25]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("std::string foo() {\n"
                               "    std::string s;\n" // Class instances are initialized. Assignment is not necessary
                               "    return s;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("std::string foo() {\n"
                               "    std::string s = \"foo\";\n"
                               "    return s;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("void f() {\n"
+                              "    std::string s(\"foo\");\n"
+                              "}");
+        ASSERT_EQUALS("[test.cpp:2:18]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+
+        functionVariableUsage("void f() {\n"
+                              "    std::string s{ \"foo\" };\n"
+                              "}");
+        ASSERT_EQUALS("[test.cpp:2:18]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
     void localvarstring2() { // ticket #2929
@@ -4068,15 +6400,17 @@ class TestUnusedVar : public TestFixture {
                               "    std::string s;\n"
                               "    int i;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Unused variable: s\n"
-                      "[test.cpp:3]: (style) Unused variable: i\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:17]: (style) Unused variable: s [unusedVariable]\n"
+                      "[test.cpp:3:9]: (style) Unused variable: i [unusedVariable]\n", errout_str());
     }
 
     void localvarconst1() {
         functionVariableUsage("void foo() {\n"
                               "    const bool b = true;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Variable 'b' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:18]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
     }
 
     void localvarconst2() {
@@ -4084,7 +6418,7 @@ class TestUnusedVar : public TestFixture {
                               "    const int N = 10;\n"
                               "    struct X { int x[N]; };\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarreturn() { // ticket #9167
@@ -4099,7 +6433,109 @@ class TestUnusedVar : public TestFixture {
                               "    };\n"
                               "    return MyInt;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localvarmaybeunused() {
+        functionVariableUsage("int main() {\n"
+                              "    [[maybe_unused]] int x;\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("[[nodiscard]] int getX() { return 4; }\n"
+                              "int main() {\n"
+                              "    [[maybe_unused]] int x = getX();\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("[[nodiscard]] int getX() { return 4; }\n"
+                              "int main() {\n"
+                              "    [[maybe_unused]] int x = getX();\n"
+                              "    x = getX();\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("[[nodiscard]] int getX() { return 4; }\n"
+                              "int main() {\n"
+                              "    [[maybe_unused]] int x = getX();\n"
+                              "    x = getX();\n"
+                              "    std::cout << x;\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int main() {\n"
+                              "    [[maybe_unused]] const int x = getX();\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int main() {\n"
+                              "    [[maybe_unused]] const int& x = getX();\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int main() {\n"
+                              "    [[maybe_unused]] const int* x = getX();\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int main() {\n"
+                              "    [[maybe_unused]] int& x = getX();\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int main() {\n"
+                              "    [[maybe_unused]] int* x = getX();\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int main() {\n"
+                              "    [[maybe_unused]] auto x = getX();\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int main() {\n"
+                              "    [[maybe_unused]] auto&& x = getX();\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int main() {\n"
+                              "    [[maybe_unused]] int x[] = getX();\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int main() {\n"
+                              "    [[maybe_unused]] constexpr volatile static int x = 1;\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("[[maybe_unused]] inline int x = 1;");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int main() {\n"
+                              "    [[maybe_unused]] [[anotherattribute]] const int* = 1;\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int main() {\n"
+                              "    [[maybe_unused]] char a[1];\n"
+                              "    [[maybe_unused]] char b[1][2];\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int main() {\n"
+                              "    std::string a [[maybe_unused]];\n"
+                              "    f();\n"
+                              "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localvarrvalue() { // ticket #13977
+        functionVariableUsage("void f(void) {\n"
+                              "    std::string s;\n"
+                              "    std::string&& m = std::move(s);\n"
+                              "    cb();\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:21]: (style) Variable 'm' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
     void localvarthrow() { // ticket #3687
@@ -4107,64 +6543,183 @@ class TestUnusedVar : public TestFixture {
                               "    try {}"
                               "    catch(Foo& bar) {}\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localVarStd() {
+        // extracttests.start: struct MyClass {int x;}; std::string foo();
+
         functionVariableUsage("void f() {\n"
                               "    std::string x = foo();\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Variable 'x' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:19]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n",
+            errout_str());
 
         functionVariableUsage("void f() {\n"
                               "    std::vector<int> x;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Unused variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:22]: (style) Unused variable: x [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void f() {\n"
                               "    std::vector<int> x(100);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Variable 'x' is assigned a value that is never used.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:23]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("void f() {\n"
                               "    std::vector<MyClass> x;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Unused variable: x\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:26]: (style) Unused variable: x [unusedVariable]\n", errout_str());
 
         functionVariableUsage("void f() {\n"
                               "    std::lock_guard<MyClass> lock(mutex_);\n" // Has a side-effect #4385
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f() {\n"
                               "    pLocker = std::shared_ptr<jfxLocker>(new jfxLocker(m_lock, true));\n" // Could have side-effects (#4355)
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f() {\n"
                               "    std::mutex m;\n"
                               "    std::unique_lock<std::mutex> lock(m);\n" // #4624
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("void f() {\n" // #7732
+                              "    const std::pair<std::string, std::string> p(\"a\", \"b\");\n"
+                              "    std::pair<std::string, std::string> q{\"a\", \"b\" };\n"
+                              "    auto r = std::pair<std::string, std::string>(\"a\", \"b\");\n"
+                              "    auto s = std::pair<std::string, std::string>{ \"a\", \"b\" };\n"
+                              "}\n");
+        TODO_ASSERT_EQUALS("[test.cpp:2]: (style) Variable 'p' is assigned a value that is never used. [unreadVariable]\n"
+                           "[test.cpp:2:48]: (style) Variable 'p' is assigned a value that is never used. [unreadVariable]\n"
+                           "[test.cpp:4]: (style) Variable 'r' is assigned a value that is never used. [unreadVariable]\n"
+                           "[test.cpp:5:18]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n",
+                           "[test.cpp:2:48]: (style) Variable 'p' is assigned a value that is never used. [unreadVariable]\n"
+                           "[test.cpp:3:42]: (style) Variable 'q' is assigned a value that is never used. [unreadVariable]\n",
+                           errout_str());
+
+        functionVariableUsage("void f(std::span<int> s) {\n" // #11545
+                              "    s[0] = 0;\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("struct S {\n"
+                              "    std::mutex m;\n"
+                              "    void f();\n"
+                              "};\n"
+                              "void S::f() {\n"
+                              "    const ::std::lock_guard g(m);\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("void f(const std::string& str, int i) {\n" // #11879
+                              "    const std::string s = str;\n"
+                              "    switch (i) {\n"
+                              "    default:\n"
+                              "        break;\n"
+                              "    }\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:23]: (style) Variable 's' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
     void localVarClass() {
         functionVariableUsage("void f() {\n"
                               "    Fred f;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("class C { int x; };\n"
                               "void f() {\n"
                               "    C c;\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Unused variable: c\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:7]: (style) Unused variable: c [unusedVariable]\n", errout_str());
+
+        functionVariableUsage("class ExampleClass\n" // #10000
+                              "{\n"
+                              "public:\n"
+                              "   ExampleClass(int xScale, int yScale, int x, int y)\n"
+                              "      : XScale(xScale)\n"
+                              "      , YScale(yScale)\n"
+                              "      , X(x)\n"
+                              "      , Y(y)\n"
+                              "   {\n"
+                              "   }\n"
+                              " \n"
+                              "   int XScale;\n"
+                              "   int YScale;\n"
+                              "   int X;\n"
+                              "   int Y;\n"
+                              "};\n"
+                              " \n"
+                              "void foo()\n"
+                              "{\n"
+                              "   ExampleClass ex(1, 2, 3, 4);\n"
+                              "}");
+        ASSERT_EQUALS("[test.cpp:20:19]: (style) Variable 'ex' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage("class C { public: C(int); ~C(); };\n"
                               "void f() {\n"
                               "    C c(12);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void localVarSmartPtr() {
+        // handling of smart pointers (#9680)
+        functionVariableUsage("static int s_i = 0;\n"
+                              "\n"
+                              "class A {\n"
+                              "public:\n"
+                              "    ~A() {\n"
+                              "        ++s_i;\n"
+                              "    }\n"
+                              "};\n"
+                              "\n"
+                              "static void func() {\n"
+                              "    auto a = std::make_shared<A>();\n"
+                              "    auto a2 = std::unique_ptr<A>(new A());\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("class A {\n"
+                              "public:\n"
+                              "    std::string x;\n"
+                              "};\n"
+                              "\n"
+                              "static void func() {\n"
+                              "    auto a = std::make_shared<A>();\n"
+                              "    auto a2 = std::unique_ptr<A>(new A());\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:7:12]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:8:13]: (style) Variable 'a2' is assigned a value that is never used. [unreadVariable]\n",
+                      errout_str());
+
+        functionVariableUsage("void g();\n" // #11094
+                              "void f() {\n"
+                              "    auto p = std::make_unique<S>();\n"
+                              "    p = nullptr;\n"
+                              "    g();\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int f(int *p) {\n" // #10703
+                              "    std::unique_ptr<int> up(p);\n"
+                              "    return *p;\n"
+                              "}\n"
+                              "int g(int* p) {\n"
+                              "    auto up = std::unique_ptr<int>(p);\n"
+                              "    return *p;\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("struct S { S(); };\n" // #11108
+                              "void f(std::unique_ptr<S> p) {\n"
+                              "    p = nullptr;\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     // ticket #3104 - false positive when variable is read with "if (NOT var)"
@@ -4173,7 +6728,7 @@ class TestUnusedVar : public TestFixture {
                               "    bool x = foo();\n"
                               "    if (NOT x) { }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarAnd() { // #3672
@@ -4183,7 +6738,7 @@ class TestUnusedVar : public TestFixture {
                               "        return 1;\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarSwitch() { // #3744 - false positive when used in switch
@@ -4197,7 +6752,7 @@ class TestUnusedVar : public TestFixture {
                               "    }\n"
                               "    return ptr;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str()); // Don't write an error that "a" is not used
+        ASSERT_EQUALS("", errout_str()); // Don't write an error that "a" is not used
 
         functionVariableUsage("void x() {\n"
                               "    unsigned char* pcOctet = NULL;\n"
@@ -4215,7 +6770,7 @@ class TestUnusedVar : public TestFixture {
                               "        *pcData = gacHexChar[(*pcOctet >> 4) & 0x0F];\n"
                               "    }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str()); // Don't write an error that "fValeur" is not used
+        ASSERT_EQUALS("", errout_str()); // Don't write an error that "fValeur" is not used
     }
 
     void localvarNULL() { // #4203 - Setting NULL value is not redundant - it is safe
@@ -4225,13 +6780,36 @@ class TestUnusedVar : public TestFixture {
                               "    free(p);\n"
                               "    p = NULL;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f(Foo *p) {\n"
                               "    free(p);\n"
                               "    p = (Foo *)NULL;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("void f() {\n" // #11079
+                              "    std::string s1{ nullptr };\n"
+                              "    std::string s2{ NULL };\n"
+                              "    std::string s4(nullptr);\n"
+                              "    std::string s5(NULL);\n"
+                              "}\n"
+                              "struct A { A(void*) {} };\n"
+                              "static void g() {\n"
+                              "    A a1{ nullptr };\n"
+                              "    A a2{ NULL };\n"
+                              "    A a4(nullptr);\n"
+                              "    A a5(NULL);\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:19]: (style) Variable 's1' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:3:19]: (style) Variable 's2' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:4:19]: (style) Variable 's4' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:5:19]: (style) Variable 's5' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:9:9]: (style) Variable 'a1' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:10:9]: (style) Variable 'a2' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:11:9]: (style) Variable 'a4' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:12:9]: (style) Variable 'a5' is assigned a value that is never used. [unreadVariable]\n",
+                      errout_str());
     }
 
     void localvarUnusedGoto() {
@@ -4248,8 +6826,8 @@ class TestUnusedVar : public TestFixture {
                               "    goto label;\n"
                               " }\n"
                               " return false;\n"
-                              "}\n");
-        ASSERT_EQUALS("[test.cpp:5]: (style) Variable 'X' is assigned a value that is never used.\n", errout.str());
+                              "}");
+        ASSERT_EQUALS("[test.cpp:5:7]: (style) Variable 'X' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         // #4558
         functionVariableUsage("int f() {\n"
@@ -4262,7 +6840,7 @@ class TestUnusedVar : public TestFixture {
                               "     goto start;\n"
                               " return i;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarLambda() {
@@ -4270,14 +6848,14 @@ class TestUnusedVar : public TestFixture {
                               "    auto f = []{return 1};\n"
                               "    return f();\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo() {\n"
                               "    auto f = []{return 1};\n"
                               "    auto g = []{return 1};\n"
                               "    return f() + g();\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void foo(std::vector<int>& v) {\n"
                               "    int n = 0;\n"
@@ -4287,7 +6865,43 @@ class TestUnusedVar : public TestFixture {
                               "        return r;\n"
                               "    });\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int f() {\n" // #8433
+                              "    float a;\n"
+                              "    auto lambda = []() {};\n"
+                              "    return 0;\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Unused variable: a [unusedVariable]\n", errout_str());
+
+        functionVariableUsage("void f() {\n" // #9823
+                              "    auto cb = []() {\n"
+                              "        int i;\n"
+                              "    };\n"
+                              "    (void)cb;\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:13]: (style) Unused variable: i [unusedVariable]\n", errout_str());
+
+        functionVariableUsage("void f() {\n" // #9822
+                              "    int i;\n"
+                              "    auto cb = []() {\n"
+                              "        int i;\n"
+                              "    };\n"
+                              "    (void)cb;\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Unused variable: i [unusedVariable]\n"
+                      "[test.cpp:4:13]: (style) Unused variable: i [unusedVariable]\n",
+                      errout_str());
+    }
+
+
+    void localvarStructuredBinding() {
+        functionVariableUsage("void f() {\n" // #10368
+                              "    std::map<int, double> m;\n"
+                              "    m[2] = 2.0;\n"
+                              "    for (auto& [k, v] : m) {}\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarCppInitialization() {
@@ -4295,7 +6909,7 @@ class TestUnusedVar : public TestFixture {
                               "    int buf[6];\n"
                               "    Data data(buf);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:14]: (information) --check-library: Provide <type-checks><unusedvar> configuration for Data [checkLibraryCheckType]\n", errout_str());
     }
 
     void localvarCpp11Initialization() {
@@ -4304,7 +6918,17 @@ class TestUnusedVar : public TestFixture {
                               "    int myNewValue{ 3u };\n"
                               "    myManager.theDummyTable.addRow(UnsignedIndexValue{ myNewValue }, DummyRowData{ false });\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("void f() {\n"
+                              "    std::list<std::list<int>>::value_type a{ 1, 2, 3, 4 };\n"
+                              "}\n");
+        TODO_ASSERT_EQUALS("", "[test.cpp:2:44]: (information) --check-library: Provide <type-checks><unusedvar> configuration for std::list::value_type [checkLibraryCheckType]\n", errout_str());
+
+        functionVariableUsage("void f(int* p) {\n"
+                              "    int* q{ p };\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Variable 'q' is assigned a value that is never used. [unreadVariable]\n", errout_str());
     }
 
     void localvarRangeBasedFor() {
@@ -4313,7 +6937,7 @@ class TestUnusedVar : public TestFixture {
                               "    for (auto & e : array)\n"
                               "        e = 0;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarAssignInWhile() {
@@ -4321,15 +6945,15 @@ class TestUnusedVar : public TestFixture {
                               "  int a = 0;\n"
                               "  do {\n"
                               "    dostuff(a);\n"
-                              "  } while((a + = x) < 30);\n"
+                              "  } while((a += x) < 30);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int foo() {\n"
                               "    int var = 1;\n"
                               "    while (var = var >> 1) { }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarTemplate() {
@@ -4338,37 +6962,62 @@ class TestUnusedVar : public TestFixture {
                               "  const int x = 0;\n"
                               "  f<x>();\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f() {\n"
                               "  constexpr std::size_t ArraySize(5);\n"
                               "  std::array<int, ArraySize> X; X.dostuff();\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("void f() {\n" // #10686
+                              "    std::array<int, 1> a;\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:2:24]: (style) Unused variable: a [unusedVariable]\n", errout_str());
+
+        functionVariableUsage("class A {};\n" // #9471
+                              "    namespace std {\n"
+                              "    template<>\n"
+                              "    struct hash<A> {};\n"
+                              "}\n"
+                              "char f() {\n"
+                              "    std::string hash = \"-\";\n"
+                              "    return hash[0];\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("template <int N>\n" // #14199
+                              "struct S {\n"
+                              "    int i;\n"
+                              "};\n"
+                              "void f() {\n"
+                              "    S<0> s;\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:6:10]: (style) Unused variable: s [unusedVariable]\n", errout_str());
     }
 
     void localvarFuncPtr() {
         functionVariableUsage("int main() {\n"
                               "    void(*funcPtr)(void)(x);\n"
                               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:2]: (style) Variable 'funcPtr' is assigned a value never used.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:2]: (style) Variable 'funcPtr' is assigned a value never used.\n", "", errout_str());
 
         functionVariableUsage("int main() {\n"
                               "    void(*funcPtr)(void);\n"
                               "}");
-        ASSERT_EQUALS("[test.cpp:2]: (style) Unused variable: funcPtr\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:2:11]: (style) Unused variable: funcPtr [unusedVariable]\n", errout_str());
 
         functionVariableUsage("int main() {\n"
                               "    void(*funcPtr)(void)(x);\n"
                               "    funcPtr();\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("int main() {\n"
                               "    void(*funcPtr)(void) = x;\n"
                               "    funcPtr();\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarAddr() { // #7747
@@ -4377,14 +7026,14 @@ class TestUnusedVar : public TestFixture {
                               "  dostuff(&x);\n"
                               "  x = 1;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f() {\n"
                               "  int x = 0;\n"
                               "  dostuff(std::ref(x));\n"
                               "  x = 1;\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void localvarDelete() { // #8339
@@ -4398,7 +7047,7 @@ class TestUnusedVar : public TestFixture {
                               ""
                               "    delete [] buf;"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void chainedAssignment() {
@@ -4408,7 +7057,7 @@ class TestUnusedVar : public TestFixture {
                               "    for (int i = 0; i<n; ++i)\n"
                               "        pdD[i] = (sum += pdD[i]);\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void crash1() {
@@ -4428,6 +7077,14 @@ class TestUnusedVar : public TestFixture {
                               "}"); // #4695
     }
 
+    void crash3() {
+        functionVariableUsage("void f(int a, int b, const int* p) {\n" // #12531
+                              "    const int* s[] = { p, p + 1, p + 2 };\n"
+                              "    a = *(s[a] + b);\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:7]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+    }
+
     void usingNamespace() {
         functionVariableUsage("int foo() {\n"
                               "   using namespace ::com::sun::star::i18n;\n"
@@ -4441,7 +7098,7 @@ class TestUnusedVar : public TestFixture {
                               "   }\n"
                               "   return j;\n"
                               "}"); // #4585
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void lambdaFunction() {
@@ -4459,7 +7116,7 @@ class TestUnusedVar : public TestFixture {
                               "  do_something();\n"
                               "  do_something();\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
 
         // #4956 - assignment in for_each
@@ -4467,13 +7124,20 @@ class TestUnusedVar : public TestFixture {
                               "  int x = 0;\n"
                               "  std::for_each(ints.begin(), ints.end(), [&x](int i){ dostuff(x); x = i; });\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage("void f(std::vector<int> ints) {\n"
                               "  int x = 0;\n"
                               "  std::for_each(ints.begin(), ints.end(), [&x](int i){ x += i; });\n"
                               "}");
-        TODO_ASSERT_EQUALS("[test.cpp:3]: (style) Variable 'x' is assigned a value that is never used.\n", "", errout.str());
+        TODO_ASSERT_EQUALS("[test.cpp:3:5]: (style) Variable 'x' is assigned a value that is never used. [unreadVariable]\n", "", errout_str());
+
+        functionVariableUsage("int f(const std::vector<int>& v) {\n"
+                              "    auto it = std::find_if(v.begin(), v.end(), [&](int i) { return i > 0 && i < 7; });\n"
+                              "    std::unordered_map<std::string, std::vector<int*>> exprs;\n"
+                              "    return *it;\n"
+                              "}");
+        ASSERT_EQUALS("[test.cpp:3:56]: (style) Unused variable: exprs [unusedVariable]\n", errout_str());
     }
 
     void namespaces() { // #7557
@@ -4491,7 +7155,7 @@ class TestUnusedVar : public TestFixture {
                               "     return value;\n"
                               "  }\n"
                               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void bracesInitCpp11() {
@@ -4500,40 +7164,37 @@ class TestUnusedVar : public TestFixture {
             " static int fpUnread{0};\n"
             " const int var{fpUnread++};\n"
             " return var;\n"
-            "}\n"
-        );
-        ASSERT_EQUALS("", errout.str());
+            "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void argument() {
         functionVariableUsage(
             "void fun(Value value) {\n"
             " value[10] = 123;\n"
-            "}\n"
-        );
-        ASSERT_EQUALS("", errout.str());
+            "}");
+        ASSERT_EQUALS("", errout_str());
 
         functionVariableUsage(
             "void fun(std::string s) {\n"
             " s[10] = 123;\n"
-            "}\n"
-        );
-        // TODO This works on command line.. load std.cfg? ASSERT_EQUALS("error", errout.str());
+            "}");
+        ASSERT_EQUALS("[test.cpp:2:8]: (style) Variable 's[10]' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
         functionVariableUsage(
             "void fun(short data[2]) {\n"
             "  data[2] = 1;\n"
             "}"
-        );
-        ASSERT_EQUALS("", errout.str());
+            );
+        ASSERT_EQUALS("", errout_str());
 
         // Unknown argument type
         functionVariableUsage(
             "void A::b(Date& result) {"
             "  result = 12;\n"
             "}"
-        );
-        ASSERT_EQUALS("", errout.str());
+            );
+        ASSERT_EQUALS("", errout_str());
 
         {
             // #8914
@@ -4541,24 +7202,24 @@ class TestUnusedVar : public TestFixture {
                 "void fun(Date result) {"
                 "  result.x = 12;\n"
                 "}"
-            );
-            ASSERT_EQUALS("", errout.str());
+                );
+            ASSERT_EQUALS("", errout_str());
 
             functionVariableUsage( // there is no reference type in C
                 "void fun(Date result) {"
                 "  result.x = 12;\n"
                 "}",
-                "test.c"
-            );
-            ASSERT_EQUALS("[test.c:1]: (style) Variable 'result.x' is assigned a value that is never used.\n", errout.str());
+                dinit(FunctionVariableUsageOptions, $.cpp = false)
+                );
+            ASSERT_EQUALS("[test.c:1:35]: (style) Variable 'result.x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
 
             functionVariableUsage(
                 "struct Date { int x; };\n"
                 "void fun(Date result) {"
                 "  result.x = 12;\n"
                 "}"
-            );
-            ASSERT_EQUALS("[test.cpp:2]: (style) Variable 'result.x' is assigned a value that is never used.\n", errout.str());
+                );
+            ASSERT_EQUALS("[test.cpp:2:35]: (style) Variable 'result.x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
         }
 
         // Unknown struct type
@@ -4567,8 +7228,16 @@ class TestUnusedVar : public TestFixture {
             "  struct FOO foo;\n"
             "  foo.x = 123;\n"
             "}"
-        );
-        ASSERT_EQUALS("[test.cpp:2]: (style) Variable 'foo.x' is assigned a value that is never used.\n", errout.str());
+            );
+        ASSERT_EQUALS("[test.cpp:2:9]: (style) Variable 'foo.x' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+    }
+
+    void argumentClass() {
+        functionVariableUsage(
+            "void foo(std::insert_iterator<C> it) {\n"
+            "  it = 123;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
     }
 
     void escapeAlias() {
@@ -4582,9 +7251,62 @@ class TestUnusedVar : public TestFixture {
             "        else\n"
             "            (*pos).second = number;\n"
             "    }\n"
-            "};\n"
-        );
-        ASSERT_EQUALS("", errout.str());
+            "};");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void volatileData() {
+        functionVariableUsage(
+            "struct Data { unsigned int n; };\n"
+            "int main() {\n"
+            "  (*(volatile struct Data*)0x4200).n = 1;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void globalData() {
+        // #10276
+        functionVariableUsage(
+            "void f(void) {\n"
+            "    ((uint8_t *) (uint16_t)0x1000)[0] = 0x42;\n"
+            "}");
+        ASSERT_EQUALS("", errout_str());
+    }
+
+    void structuredBinding() { // #13269
+        functionVariableUsage("int main()\n"
+                              "{\n"
+                              "    auto [a, b] = std::make_pair(42, 0.42);\n"
+                              "}\n");
+        ASSERT_EQUALS("[test.cpp:3:17]: (style) Variable 'a' is assigned a value that is never used. [unreadVariable]\n"
+                      "[test.cpp:3:17]: (style) Variable 'b' is assigned a value that is never used. [unreadVariable]\n", errout_str());
+
+        functionVariableUsage("int main()\n"
+                              "{\n"
+                              "    auto [a, b] = std::make_pair(42, 0.42);\n"
+                              "    (void) a;\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int main()\n"
+                              "{\n"
+                              "    auto [a, b] = std::make_pair(42, 0.42);\n"
+                              "    (void) b;\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int main()\n"
+                              "{\n"
+                              "    auto [a, b, c] = std::make_pair(42, 0.42);\n"
+                              "    (void) b;\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
+
+        functionVariableUsage("int main()\n"
+                              "{\n"
+                              "    [[maybe_unused]] auto [a2, b3] = std::make_pair(42, 0.42);\n"
+                              "}\n");
+        ASSERT_EQUALS("", errout_str());
     }
 };
 
diff --git a/test/testutils.cpp b/test/testutils.cpp
new file mode 100644
index 00000000000..b3da9b1f6dc
--- /dev/null
+++ b/test/testutils.cpp
@@ -0,0 +1,580 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2026 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "fixture.h"
+#include "utils.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <stdexcept>
+#include <string>
+
+class TestUtils : public TestFixture {
+public:
+    TestUtils() : TestFixture("TestUtils") {}
+
+private:
+    void run() override {
+        TEST_CASE(isValidGlobPattern);
+        TEST_CASE(matchglob);
+        TEST_CASE(isStringLiteral);
+        TEST_CASE(isCharLiteral);
+        TEST_CASE(strToInt);
+        TEST_CASE(id_string);
+        TEST_CASE(startsWith);
+        TEST_CASE(trim);
+        TEST_CASE(findAndReplace);
+        TEST_CASE(replaceEscapeSequences);
+        TEST_CASE(splitString);
+        TEST_CASE(as_const);
+        TEST_CASE(memoize);
+        TEST_CASE(endsWith);
+    }
+
+    void isValidGlobPattern() const {
+        ASSERT_EQUALS(true, ::isValidGlobPattern("*"));
+        ASSERT_EQUALS(true, ::isValidGlobPattern("*x"));
+        ASSERT_EQUALS(true, ::isValidGlobPattern("x*"));
+        ASSERT_EQUALS(true, ::isValidGlobPattern("*/x/*"));
+        ASSERT_EQUALS(true, ::isValidGlobPattern("x/*/z"));
+        ASSERT_EQUALS(true, ::isValidGlobPattern("**"));
+        ASSERT_EQUALS(true, ::isValidGlobPattern("**x"));
+        ASSERT_EQUALS(true, ::isValidGlobPattern("x**"));
+
+        ASSERT_EQUALS(true, ::isValidGlobPattern("?"));
+        ASSERT_EQUALS(true, ::isValidGlobPattern("?x"));
+        ASSERT_EQUALS(true, ::isValidGlobPattern("x?"));
+        ASSERT_EQUALS(true, ::isValidGlobPattern("?/x/?"));
+        ASSERT_EQUALS(true, ::isValidGlobPattern("x/?/z"));
+        ASSERT_EQUALS(true, ::isValidGlobPattern("??"));
+        ASSERT_EQUALS(true, ::isValidGlobPattern("????"));
+        ASSERT_EQUALS(true, ::isValidGlobPattern("??x"));
+        ASSERT_EQUALS(true, ::isValidGlobPattern("x??"));
+
+        ASSERT_EQUALS(true, ::isValidGlobPattern("?*"));
+        ASSERT_EQUALS(true, ::isValidGlobPattern("?**"));
+        ASSERT_EQUALS(false, ::isValidGlobPattern("?***"));
+        ASSERT_EQUALS(true, ::isValidGlobPattern("???*"));
+        ASSERT_EQUALS(true, ::isValidGlobPattern("???**"));
+        ASSERT_EQUALS(false, ::isValidGlobPattern("???***"));
+
+        ASSERT_EQUALS(false, ::isValidGlobPattern("*?"));
+        ASSERT_EQUALS(true,  ::isValidGlobPattern("*x?"));
+        ASSERT_EQUALS(false, ::isValidGlobPattern("**?"));
+        ASSERT_EQUALS(false, ::isValidGlobPattern("***"));
+        ASSERT_EQUALS(true,  ::isValidGlobPattern("**x*"));
+    }
+
+    void matchglob() const {
+        ASSERT_EQUALS(true, ::matchglob("*", "xyz"));
+        ASSERT_EQUALS(true, ::matchglob("x*", "xyz"));
+        ASSERT_EQUALS(true, ::matchglob("*z", "xyz"));
+        ASSERT_EQUALS(true, ::matchglob("*y*", "xyz"));
+        ASSERT_EQUALS(true, ::matchglob("*y*", "yz"));
+        ASSERT_EQUALS(false, ::matchglob("*y*", "abc"));
+        ASSERT_EQUALS(true, ::matchglob("*", "x/y/z"));
+        ASSERT_EQUALS(true, ::matchglob("*/y/z", "x/y/z"));
+
+        ASSERT_EQUALS(true, ::matchglob("**", ""));
+        ASSERT_EQUALS(true, ::matchglob("**", "abcdefg"));
+        ASSERT_EQUALS(true, ::matchglob("**", "abcde/foo/bar"));
+        ASSERT_EQUALS(false, ::matchglob("*/**", "abcde"));
+        ASSERT_EQUALS(true, ::matchglob("*/**", "abcde/foo"));
+        ASSERT_EQUALS(true, ::matchglob("*/**", "abcde/foo/bar"));
+
+        ASSERT_EQUALS(false, ::matchglob("?", "xyz"));
+        ASSERT_EQUALS(false, ::matchglob("x?", "xyz"));
+        ASSERT_EQUALS(false, ::matchglob("?z", "xyz"));
+        ASSERT_EQUALS(true, ::matchglob("?y?", "xyz"));
+        ASSERT_EQUALS(true, ::matchglob("?/?/?", "x/y/z"));
+
+        ASSERT_EQUALS(true, ::matchglob("??", "xy"));
+        ASSERT_EQUALS(false, ::matchglob("??", "x"));
+        ASSERT_EQUALS(false, ::matchglob("??", "xyz"));
+
+        ASSERT_EQUALS(true, ::matchglob("????", "wxyz"));
+        ASSERT_EQUALS(false, ::matchglob("????", "xyz"));
+        ASSERT_EQUALS(false, ::matchglob("????", "vwxyz"));
+    }
+
+    void isStringLiteral() const {
+        // empty
+        ASSERT_EQUALS(false, ::isStringLiteral(""));
+
+        // no literals
+        ASSERT_EQUALS(false, ::isStringLiteral("u8"));
+        ASSERT_EQUALS(false, ::isStringLiteral("u"));
+        ASSERT_EQUALS(false, ::isStringLiteral("U"));
+        ASSERT_EQUALS(false, ::isStringLiteral("L"));
+
+        // incomplete string literals
+        ASSERT_EQUALS(false, ::isStringLiteral("\""));
+        ASSERT_EQUALS(false, ::isStringLiteral("u8\""));
+        ASSERT_EQUALS(false, ::isStringLiteral("u\""));
+        ASSERT_EQUALS(false, ::isStringLiteral("U\""));
+        ASSERT_EQUALS(false, ::isStringLiteral("L\""));
+
+        // valid string literals
+        ASSERT_EQUALS(true, ::isStringLiteral("\"\""));
+        ASSERT_EQUALS(true, ::isStringLiteral("u8\"\""));
+        ASSERT_EQUALS(true, ::isStringLiteral("u\"\""));
+        ASSERT_EQUALS(true, ::isStringLiteral("U\"\""));
+        ASSERT_EQUALS(true, ::isStringLiteral("L\"\""));
+        ASSERT_EQUALS(true, ::isStringLiteral("\"t\""));
+        ASSERT_EQUALS(true, ::isStringLiteral("u8\"t\""));
+        ASSERT_EQUALS(true, ::isStringLiteral("u\"t\""));
+        ASSERT_EQUALS(true, ::isStringLiteral("U\"t\""));
+        ASSERT_EQUALS(true, ::isStringLiteral("L\"t\""));
+        ASSERT_EQUALS(true, ::isStringLiteral("\"test\""));
+        ASSERT_EQUALS(true, ::isStringLiteral("u8\"test\""));
+        ASSERT_EQUALS(true, ::isStringLiteral("u\"test\""));
+        ASSERT_EQUALS(true, ::isStringLiteral("U\"test\""));
+        ASSERT_EQUALS(true, ::isStringLiteral("L\"test\""));
+
+        // incomplete char literals
+        ASSERT_EQUALS(false, ::isStringLiteral("'"));
+        ASSERT_EQUALS(false, ::isStringLiteral("u8'"));
+        ASSERT_EQUALS(false, ::isStringLiteral("u'"));
+        ASSERT_EQUALS(false, ::isStringLiteral("U'"));
+        ASSERT_EQUALS(false, ::isStringLiteral("L'"));
+
+        // valid char literals
+        ASSERT_EQUALS(false, ::isStringLiteral("'t'"));
+        ASSERT_EQUALS(false, ::isStringLiteral("u8't'"));
+        ASSERT_EQUALS(false, ::isStringLiteral("u't'"));
+        ASSERT_EQUALS(false, ::isStringLiteral("U't'"));
+        ASSERT_EQUALS(false, ::isStringLiteral("L't'"));
+        ASSERT_EQUALS(false, ::isStringLiteral("'test'"));
+        ASSERT_EQUALS(false, ::isStringLiteral("u8'test'"));
+        ASSERT_EQUALS(false, ::isStringLiteral("u'test'"));
+        ASSERT_EQUALS(false, ::isStringLiteral("U'test'"));
+        ASSERT_EQUALS(false, ::isStringLiteral("L'test'"));
+    }
+
+    void isCharLiteral() const {
+        // empty
+        ASSERT_EQUALS(false, ::isCharLiteral(""));
+
+        // no literals
+        ASSERT_EQUALS(false, ::isCharLiteral("u8"));
+        ASSERT_EQUALS(false, ::isCharLiteral("u"));
+        ASSERT_EQUALS(false, ::isCharLiteral("U"));
+        ASSERT_EQUALS(false, ::isCharLiteral("L"));
+
+        // incomplete string literals
+        ASSERT_EQUALS(false, ::isCharLiteral("\""));
+        ASSERT_EQUALS(false, ::isCharLiteral("u8\""));
+        ASSERT_EQUALS(false, ::isCharLiteral("u\""));
+        ASSERT_EQUALS(false, ::isCharLiteral("U\""));
+        ASSERT_EQUALS(false, ::isCharLiteral("L\""));
+
+        // valid string literals
+        ASSERT_EQUALS(false, ::isCharLiteral("\"\""));
+        ASSERT_EQUALS(false, ::isCharLiteral("u8\"\""));
+        ASSERT_EQUALS(false, ::isCharLiteral("u\"\""));
+        ASSERT_EQUALS(false, ::isCharLiteral("U\"\""));
+        ASSERT_EQUALS(false, ::isCharLiteral("L\"\""));
+        ASSERT_EQUALS(false, ::isCharLiteral("\"t\""));
+        ASSERT_EQUALS(false, ::isCharLiteral("u8\"t\""));
+        ASSERT_EQUALS(false, ::isCharLiteral("u\"t\""));
+        ASSERT_EQUALS(false, ::isCharLiteral("U\"t\""));
+        ASSERT_EQUALS(false, ::isCharLiteral("L\"t\""));
+        ASSERT_EQUALS(false, ::isCharLiteral("\"test\""));
+        ASSERT_EQUALS(false, ::isCharLiteral("u8\"test\""));
+        ASSERT_EQUALS(false, ::isCharLiteral("u\"test\""));
+        ASSERT_EQUALS(false, ::isCharLiteral("U\"test\""));
+        ASSERT_EQUALS(false, ::isCharLiteral("L\"test\""));
+
+        // incomplete char literals
+        ASSERT_EQUALS(false, ::isCharLiteral("'"));
+        ASSERT_EQUALS(false, ::isCharLiteral("u8'"));
+        ASSERT_EQUALS(false, ::isCharLiteral("u'"));
+        ASSERT_EQUALS(false, ::isCharLiteral("U'"));
+        ASSERT_EQUALS(false, ::isCharLiteral("L'"));
+
+        // valid char literals
+        ASSERT_EQUALS(true, ::isCharLiteral("'t'"));
+        ASSERT_EQUALS(true, ::isCharLiteral("u8't'"));
+        ASSERT_EQUALS(true, ::isCharLiteral("u't'"));
+        ASSERT_EQUALS(true, ::isCharLiteral("U't'"));
+        ASSERT_EQUALS(true, ::isCharLiteral("L't'"));
+        ASSERT_EQUALS(true, ::isCharLiteral("'test'"));
+        ASSERT_EQUALS(true, ::isCharLiteral("u8'test'"));
+        ASSERT_EQUALS(true, ::isCharLiteral("u'test'"));
+        ASSERT_EQUALS(true, ::isCharLiteral("U'test'"));
+        ASSERT_EQUALS(true, ::isCharLiteral("L'test'"));
+    }
+
+    void strToInt() {
+        ASSERT_EQUALS(1, ::strToInt<int>("1"));
+        ASSERT_EQUALS(-1, ::strToInt<int>("-1"));
+        ASSERT_EQUALS(1, ::strToInt<std::size_t>("1"));
+        ASSERT_THROW_EQUALS(::strToInt<int>(""), std::runtime_error, "converting '' to integer failed - not an integer");
+        ASSERT_THROW_EQUALS(::strToInt<std::size_t>(""), std::runtime_error, "converting '' to integer failed - not an integer");
+        ASSERT_THROW_EQUALS(::strToInt<int>(" "), std::runtime_error, "converting ' ' to integer failed - not an integer");
+        ASSERT_THROW_EQUALS(::strToInt<std::size_t>(" "), std::runtime_error, "converting ' ' to integer failed - not an integer");
+        ASSERT_THROW_EQUALS(::strToInt<unsigned int>("-1"), std::runtime_error, "converting '-1' to integer failed - needs to be positive");
+        ASSERT_THROW_EQUALS(::strToInt<int>("1ms"), std::runtime_error, "converting '1ms' to integer failed - not an integer");
+        ASSERT_THROW_EQUALS(::strToInt<int>("1.0"), std::runtime_error, "converting '1.0' to integer failed - not an integer");
+        ASSERT_THROW_EQUALS(::strToInt<int>("one"), std::runtime_error, "converting 'one' to integer failed - not an integer");
+        ASSERT_THROW_EQUALS(::strToInt<unsigned int>("1ms"), std::runtime_error, "converting '1ms' to integer failed - not an integer");
+        ASSERT_THROW_EQUALS(::strToInt<unsigned int>("1.0"), std::runtime_error, "converting '1.0' to integer failed - not an integer");
+        ASSERT_THROW_EQUALS(::strToInt<unsigned int>("one"), std::runtime_error, "converting 'one' to integer failed - not an integer");
+        ASSERT_THROW_EQUALS(::strToInt<int>(std::to_string(static_cast<int64_t>(std::numeric_limits<int>::max()) + 1)), std::runtime_error, "converting '2147483648' to integer failed - out of range (limits)");
+        ASSERT_THROW_EQUALS(::strToInt<int>(std::to_string(static_cast<int64_t>(std::numeric_limits<int>::min()) - 1)), std::runtime_error, "converting '-2147483649' to integer failed - out of range (limits)");
+        ASSERT_THROW_EQUALS(::strToInt<int8_t>(std::to_string(static_cast<int64_t>(std::numeric_limits<int8_t>::max()) + 1)), std::runtime_error, "converting '128' to integer failed - out of range (limits)");
+        ASSERT_THROW_EQUALS(::strToInt<int8_t>(std::to_string(static_cast<int64_t>(std::numeric_limits<int8_t>::min()) - 1)), std::runtime_error, "converting '-129' to integer failed - out of range (limits)");
+        ASSERT_THROW_EQUALS(::strToInt<unsigned int>(std::to_string(static_cast<uint64_t>(std::numeric_limits<unsigned int>::max()) + 1)), std::runtime_error, "converting '4294967296' to integer failed - out of range (limits)");
+        ASSERT_THROW_EQUALS(::strToInt<int>("9223372036854775808"), std::runtime_error, "converting '9223372036854775808' to integer failed - out of range (stoll)"); // LLONG_MAX + 1
+        ASSERT_THROW_EQUALS(::strToInt<std::size_t>("18446744073709551616"), std::runtime_error, "converting '18446744073709551616' to integer failed - out of range (stoull)"); // ULLONG_MAX + 1
+
+        {
+            long tmp;
+            ASSERT(::strToInt("1", tmp));
+            ASSERT_EQUALS(1, tmp);
+        }
+        {
+            long tmp;
+            ASSERT(::strToInt("-1", tmp));
+            ASSERT_EQUALS(-1, tmp);
+        }
+        {
+            std::size_t tmp;
+            ASSERT(::strToInt("1", tmp));
+        }
+        {
+            std::size_t tmp;
+            ASSERT(!::strToInt("-1", tmp));
+        }
+        {
+            long tmp;
+            ASSERT(!::strToInt("1ms", tmp));
+        }
+        {
+            unsigned long tmp;
+            ASSERT(!::strToInt("1ms", tmp));
+        }
+        {
+            long tmp;
+            ASSERT(!::strToInt("", tmp));
+        }
+        {
+            unsigned long tmp;
+            ASSERT(!::strToInt("", tmp));
+        }
+        {
+            long tmp;
+            ASSERT(!::strToInt(" ", tmp));
+        }
+        {
+            unsigned long tmp;
+            ASSERT(!::strToInt(" ", tmp));
+        }
+
+        {
+            long tmp;
+            std::string err;
+            ASSERT(::strToInt("1", tmp, &err));
+            ASSERT_EQUALS(1, tmp);
+            ASSERT_EQUALS("", err);
+        }
+        {
+            std::size_t tmp;
+            std::string err;
+            ASSERT(::strToInt("1", tmp, &err));
+            ASSERT_EQUALS(1, tmp);
+            ASSERT_EQUALS("", err);
+        }
+        {
+            unsigned long tmp;
+            std::string err;
+            ASSERT(!::strToInt("-1", tmp, &err));
+            ASSERT_EQUALS("needs to be positive", err);
+        }
+        {
+            long tmp;
+            std::string err;
+            ASSERT(!::strToInt("1ms", tmp, &err));
+            ASSERT_EQUALS("not an integer", err);
+        }
+        {
+            long tmp;
+            std::string err;
+            ASSERT(!::strToInt("1.0", tmp, &err));
+            ASSERT_EQUALS("not an integer", err);
+        }
+        {
+            long tmp;
+            std::string err;
+            ASSERT(!::strToInt("one", tmp, &err));
+            ASSERT_EQUALS("not an integer", err);
+        }
+        {
+            std::size_t tmp;
+            std::string err;
+            ASSERT(!::strToInt("1ms", tmp, &err));
+            ASSERT_EQUALS("not an integer", err);
+        }
+        {
+            long tmp;
+            std::string err;
+            ASSERT(!::strToInt("9223372036854775808", tmp, &err)); // LLONG_MAX + 1
+            ASSERT_EQUALS("out of range (stoll)", err);
+        }
+        {
+            int tmp;
+            std::string err;
+            ASSERT(!::strToInt(std::to_string(static_cast<int64_t>(std::numeric_limits<int>::max()) + 1), tmp, &err));
+            ASSERT_EQUALS("out of range (limits)", err);
+        }
+        {
+            int tmp;
+            std::string err;
+            ASSERT(!::strToInt(std::to_string(static_cast<int64_t>(std::numeric_limits<int>::min()) - 1), tmp, &err));
+            ASSERT_EQUALS("out of range (limits)", err);
+        }
+        {
+            int8_t tmp;
+            std::string err;
+            ASSERT(!::strToInt(std::to_string(static_cast<int64_t>(std::numeric_limits<int8_t>::max()) + 1), tmp, &err));
+            ASSERT_EQUALS("out of range (limits)", err);
+        }
+        {
+            int8_t tmp;
+            std::string err;
+            ASSERT(!::strToInt(std::to_string(static_cast<int64_t>(std::numeric_limits<int8_t>::min()) - 1), tmp, &err));
+            ASSERT_EQUALS("out of range (limits)", err);
+        }
+        {
+            std::size_t tmp;
+            std::string err;
+            ASSERT(!::strToInt("18446744073709551616", tmp, &err)); // ULLONG_MAX + 1
+            ASSERT_EQUALS("out of range (stoull)", err);
+        }
+    }
+
+    void id_string() const
+    {
+        ASSERT_EQUALS("0", id_string_i(0));
+        ASSERT_EQUALS("f1", id_string_i(0xF1));
+        ASSERT_EQUALS("123", id_string_i(0x123));
+        ASSERT_EQUALS("1230", id_string_i(0x1230));
+        ASSERT_EQUALS(std::string(8,'f'), id_string_i(0xffffffffU));
+        if (sizeof(void*) == 8) {
+            ASSERT_EQUALS(std::string(16,'f'), id_string_i(~0ULL));
+        }
+    }
+
+    void startsWith() const
+    {
+        ASSERT(::startsWith("test", "test"));
+        ASSERT(::startsWith("test2", "test"));
+        ASSERT(::startsWith("test test", "test"));
+        ASSERT(::startsWith("test", "t"));
+        ASSERT(!::startsWith("2test", "test"));
+        ASSERT(!::startsWith("", "test"));
+        ASSERT(!::startsWith("tes", "test"));
+        ASSERT(!::startsWith("2test", "t"));
+        ASSERT(!::startsWith("t", "test"));
+    }
+
+    void trim() const
+    {
+        ASSERT_EQUALS("test", ::trim("test"));
+        ASSERT_EQUALS("test", ::trim(" test"));
+        ASSERT_EQUALS("test", ::trim("test "));
+        ASSERT_EQUALS("test", ::trim(" test "));
+        ASSERT_EQUALS("test", ::trim("  test"));
+        ASSERT_EQUALS("test", ::trim("test  "));
+        ASSERT_EQUALS("test", ::trim("  test  "));
+        ASSERT_EQUALS("test", ::trim("\ttest"));
+        ASSERT_EQUALS("test", ::trim("test\t"));
+        ASSERT_EQUALS("test", ::trim("\ttest\t"));
+        ASSERT_EQUALS("test", ::trim("\t\ttest"));
+        ASSERT_EQUALS("test", ::trim("test\t\t"));
+        ASSERT_EQUALS("test", ::trim("\t\ttest\t\t"));
+        ASSERT_EQUALS("test", ::trim(" \ttest"));
+        ASSERT_EQUALS("test", ::trim("test\t "));
+        ASSERT_EQUALS("test", ::trim(" \ttest\t"));
+        ASSERT_EQUALS("test", ::trim("\t \ttest"));
+        ASSERT_EQUALS("test", ::trim("test\t \t"));
+        ASSERT_EQUALS("test", ::trim("\t \ttest\t \t"));
+
+        ASSERT_EQUALS("test test", ::trim("test test"));
+        ASSERT_EQUALS("test test", ::trim(" test test"));
+        ASSERT_EQUALS("test test", ::trim("test test "));
+        ASSERT_EQUALS("test test", ::trim(" test test "));
+        ASSERT_EQUALS("test\ttest", ::trim(" test\ttest"));
+        ASSERT_EQUALS("test\ttest", ::trim("test\ttest "));
+        ASSERT_EQUALS("test\ttest", ::trim(" test\ttest "));
+
+        ASSERT_EQUALS("test", ::trim("\ntest", "\n"));
+        ASSERT_EQUALS("test", ::trim("test\n", "\n"));
+        ASSERT_EQUALS("test", ::trim("\ntest\n", "\n"));
+    }
+
+    void findAndReplace() const {
+        {
+            std::string s{"test"};
+            ::findAndReplace(s, "test", "tset");
+            ASSERT_EQUALS("tset", s);
+        }
+        {
+            std::string s{"testtest"};
+            ::findAndReplace(s, "test", "tset");
+            ASSERT_EQUALS("tsettset", s);
+        }
+        {
+            std::string s{"1test1test1"};
+            ::findAndReplace(s, "test", "tset");
+            ASSERT_EQUALS("1tset1tset1", s);
+        }
+        {
+            std::string s{"1test1test1"};
+            ::findAndReplace(s, "test", "");
+            ASSERT_EQUALS("111", s);
+        }
+        {
+            std::string s{"111"};
+            ::findAndReplace(s, "test", "tset");
+            ASSERT_EQUALS("111", s);
+        }
+        {
+            std::string s;
+            ::findAndReplace(s, "test", "tset");
+            ASSERT_EQUALS("", s);
+        }
+    }
+
+    void replaceEscapeSequences() const {
+        ASSERT_EQUALS("\x30", ::replaceEscapeSequences("\\x30"));
+        ASSERT_EQUALS("\030", ::replaceEscapeSequences("\\030"));
+        ASSERT_EQUALS("\r", ::replaceEscapeSequences("\\r"));
+        ASSERT_EQUALS("\n", ::replaceEscapeSequences("\\n"));
+        ASSERT_EQUALS("\t", ::replaceEscapeSequences("\\t"));
+        ASSERT_EQUALS("\\", ::replaceEscapeSequences("\\\\"));
+        ASSERT_EQUALS("\"", ::replaceEscapeSequences("\\\""));
+    }
+
+    void splitString() const {
+        {
+            const auto l = ::splitString("test", ',');
+            ASSERT_EQUALS(1, l.size());
+            ASSERT_EQUALS("test", *l.cbegin());
+        }
+        {
+            const auto l = ::splitString("test,test", ';');
+            ASSERT_EQUALS(1, l.size());
+            ASSERT_EQUALS("test,test", *l.cbegin());
+        }
+        {
+            const auto l = ::splitString("test,test", ',');
+            ASSERT_EQUALS(2, l.size());
+            auto it = l.cbegin();
+            ASSERT_EQUALS("test", *it++);
+            ASSERT_EQUALS("test", *it);
+        }
+        {
+            const auto l = ::splitString("test,test,", ',');
+            ASSERT_EQUALS(3, l.size());
+            auto it = l.cbegin();
+            ASSERT_EQUALS("test", *it++);
+            ASSERT_EQUALS("test", *it++);
+            ASSERT_EQUALS("", *it);
+        }
+        {
+            const auto l = ::splitString("test,,test", ',');
+            ASSERT_EQUALS(3, l.size());
+            auto it = l.cbegin();
+            ASSERT_EQUALS("test", *it++);
+            ASSERT_EQUALS("", *it++);
+            ASSERT_EQUALS("test", *it);
+        }
+        {
+            const auto l = ::splitString(",test,test", ',');
+            ASSERT_EQUALS(3, l.size());
+            auto it = l.cbegin();
+            ASSERT_EQUALS("", *it++);
+            ASSERT_EQUALS("test", *it++);
+            ASSERT_EQUALS("test", *it);
+        }
+    }
+
+    void as_const() const {
+        struct C {
+            bool written = false;
+            void f() {
+                written = true;
+            }
+            void f() const {}
+        };
+
+        {
+            C c;
+            c.f();
+            ASSERT(c.written);
+        }
+        {
+            C c;
+            utils::as_const(c).f();
+            ASSERT(!c.written);
+        }
+        {
+            C c;
+            C* cp = &c;
+            cp->f();
+            ASSERT(c.written);
+        }
+        {
+            C c;
+            C* cp = &c;
+            utils::as_const(cp)->f(); // (correctly) calls non-const version
+            ASSERT(c.written);
+        }
+    }
+
+    void memoize() const {
+        int count = 0;
+        auto f = [&count]() {
+            ++count;
+            return count;
+        };
+        const auto callF = utils::memoize([&]() {
+            return f();
+        });
+        ASSERT_EQUALS(0, count);
+        ASSERT_EQUALS(1, callF());
+        ASSERT_EQUALS(1, count);
+        ASSERT_EQUALS(1, callF());
+        ASSERT_EQUALS(1, count);
+    }
+
+    void endsWith() const
+    {
+        ASSERT(::endsWith("test", "test"));
+        ASSERT(::endsWith("test2", "2"));
+        ASSERT(::endsWith("test test", "test"));
+        ASSERT(::endsWith("test", "t"));
+        ASSERT(!::endsWith("", "test"));
+        ASSERT(!::endsWith("tes", "test"));
+        ASSERT(!::endsWith("2test", "2"));
+    }
+};
+
+REGISTER_TEST(TestUtils)
diff --git a/test/testutils.h b/test/testutils.h
deleted file mode 100644
index 9277539caa5..00000000000
--- a/test/testutils.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef TestUtilsH
-#define TestUtilsH
-
-#include "settings.h"
-#include "tokenize.h"
-
-class Token;
-
-class givenACodeSampleToTokenize {
-private:
-    Settings settings;
-    Tokenizer tokenizer;
-
-public:
-    explicit givenACodeSampleToTokenize(const char sample[], bool createOnly = false, bool cpp = true)
-        : tokenizer(&settings, nullptr) {
-        std::istringstream iss(sample);
-        if (createOnly)
-            tokenizer.list.createTokens(iss, cpp ? "test.cpp" : "test.c");
-        else
-            tokenizer.tokenize(iss, cpp ? "test.cpp" : "test.c");
-    }
-
-    const Token* tokens() const {
-        return tokenizer.tokens();
-    }
-};
-
-
-class SimpleSuppressor : public ErrorLogger {
-public:
-    SimpleSuppressor(Settings &settings, ErrorLogger *next)
-        : settings(settings), next(next) {
-    }
-    void reportOut(const std::string &outmsg) OVERRIDE {
-        next->reportOut(outmsg);
-    }
-    void reportErr(const ErrorLogger::ErrorMessage &msg) OVERRIDE {
-        if (!msg.callStack.empty() && !settings.nomsg.isSuppressed(msg.toSuppressionsErrorMessage()))
-            next->reportErr(msg);
-    }
-private:
-    Settings &settings;
-    ErrorLogger *next;
-};
-
-#endif // TestUtilsH
diff --git a/test/testvaarg.cpp b/test/testvaarg.cpp
index 8c82c364742..36e1d2cb038 100644
--- a/test/testvaarg.cpp
+++ b/test/testvaarg.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2025 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,37 +16,34 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #include "checkvaarg.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
 #include "settings.h"
-#include "testsuite.h"
-#include "tokenize.h"
 
+#include <cstddef>
 
 class TestVaarg : public TestFixture {
 public:
     TestVaarg() : TestFixture("TestVaarg") {}
 
 private:
-    Settings settings;
-
-    void check(const char code[]) {
-        // Clear the error buffer..
-        errout.str("");
+    const Settings settings = settingsBuilder().severity(Severity::warning).build();
 
+#define check(...) check_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void check_(const char* file, int line, const char (&code)[size]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         // Check..
-        CheckVaarg checkVaarg;
-        checkVaarg.runChecks(&tokenizer, &settings, this);
+        runChecks<CheckVaarg>(tokenizer, this);
     }
 
-    void run() OVERRIDE {
-        settings.addEnabled("warning");
-
+    void run() override {
+        mNewTemplate = true;
         TEST_CASE(wrongParameterTo_va_start);
         TEST_CASE(referenceAs_va_start);
         TEST_CASE(va_end_missing);
@@ -61,21 +58,21 @@ class TestVaarg : public TestFixture {
               "    va_start(arg_ptr, szFormat);\n"
               "    va_end(arg_ptr);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) 'szFormat' given to va_start() is not last named argument of the function. Did you intend to pass 'nSize'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) 'szFormat' given to va_start() is not last named argument of the function. Did you intend to pass 'nSize'? [va_start_wrongParameter]\n", errout_str());
 
         check("void Format(char* szFormat, char* szBuffer, size_t nSize, ...) {\n"
               "    va_list arg_ptr;\n"
               "    va_start(arg_ptr, szBuffer);\n"
               "    va_end(arg_ptr);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (warning) 'szBuffer' given to va_start() is not last named argument of the function. Did you intend to pass 'nSize'?\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (warning) 'szBuffer' given to va_start() is not last named argument of the function. Did you intend to pass 'nSize'? [va_start_wrongParameter]\n", errout_str());
 
         check("void Format(char* szFormat, char* szBuffer, size_t nSize, ...) {\n"
               "    va_list arg_ptr;\n"
               "    va_start(arg_ptr, nSize);\n"
               "    va_end(arg_ptr);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("int main(int argc, char *argv[]) {\n"
               "    long(^addthem)(const char *, ...) = ^long(const char *format, ...) {\n"
@@ -84,14 +81,14 @@ class TestVaarg : public TestFixture {
               "        c = va_arg(argp, int);\n"
               "    };\n"
               "}"); // Don't crash (#6032)
-        ASSERT_EQUALS("[test.cpp:6]: (error) va_list 'argp' was opened but not closed by va_end().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:6:5]: (error) va_list 'argp' was opened but not closed by va_end(). [va_end_missing]\n", errout_str());
 
         check("void Format(char* szFormat, char* szBuffer, size_t nSize, ...) {\n"
               "    va_list arg_ptr;\n"
               "    va_start(arg_ptr);\n"
               "    va_end(arg_ptr);\n"
               "}"); // Don't crash if less than expected arguments are given.
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void assertf_fail(const char *assertion, const char *file, int line, const char *func, const char* msg, ...) {\n"
               "    struct A {\n"
@@ -103,7 +100,7 @@ class TestVaarg : public TestFixture {
               "        }\n"
               "    };\n"
               "}"); // Inner class (#6453)
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void referenceAs_va_start() {
@@ -112,14 +109,14 @@ class TestVaarg : public TestFixture {
               "    va_start(arg_ptr, szBuffer);\n"
               "    va_end(arg_ptr);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) Using reference 'szBuffer' as parameter for va_start() results in undefined behaviour.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:23]: (error) Using reference 'szBuffer' as parameter for va_start() results in undefined behaviour. [va_start_referencePassed]\n", errout_str());
 
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
               "    va_list arg_ptr;\n"
               "    va_start(arg_ptr, szBuffer);\n"
               "    va_end(arg_ptr);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void va_end_missing() {
@@ -128,7 +125,7 @@ class TestVaarg : public TestFixture {
               "    va_start(arg_ptr, szBuffer);\n"
               "    va_end(arg_ptr);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6186
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
@@ -140,13 +137,13 @@ class TestVaarg : public TestFixture {
               "        va_end(arg_ptr);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
               "    va_list arg_ptr;\n"
               "    va_start(arg_ptr, szBuffer);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) va_list 'arg_ptr' was opened but not closed by va_end().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:1]: (error) va_list 'arg_ptr' was opened but not closed by va_end(). [va_end_missing]\n", errout_str());
 
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
               "    va_list arg_ptr;\n"
@@ -154,7 +151,7 @@ class TestVaarg : public TestFixture {
               "    if(sth) return;\n"
               "    va_end(arg_ptr);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) va_list 'arg_ptr' was opened but not closed by va_end().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:19]: (error) va_list 'arg_ptr' was opened but not closed by va_end(). [va_end_missing]\n", errout_str());
 
         // #8124
         check("void f(int n, ...)\n"
@@ -167,8 +164,8 @@ class TestVaarg : public TestFixture {
               "        return va_arg(ap, const char*);\n"
               "    });\n"
               "    va_end(ap);\n"
-              "}\n");
-        ASSERT_EQUALS("", errout.str());
+              "}");
+        ASSERT_EQUALS("", errout_str());
 
         check("void f(int n, ...)\n"
               "{\n"
@@ -179,8 +176,8 @@ class TestVaarg : public TestFixture {
               "    {\n"
               "        return va_arg(ap, const char*);\n"
               "    });\n"
-              "}\n");
-        ASSERT_EQUALS("[test.cpp:10]: (error) va_list 'ap' was opened but not closed by va_end().\n", errout.str());
+              "}");
+        ASSERT_EQUALS("[test.cpp:10:1]: (error) va_list 'ap' was opened but not closed by va_end(). [va_end_missing]\n", errout_str());
     }
 
     void va_list_usedBeforeStarted() {
@@ -188,19 +185,19 @@ class TestVaarg : public TestFixture {
               "    va_list arg_ptr;\n"
               "    return va_arg(arg_ptr, float);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) va_list 'arg_ptr' used before va_start() was called.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:19]: (error) va_list 'arg_ptr' used before va_start() was called. [va_list_usedBeforeStarted]\n", errout_str());
 
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
               "    va_list arg_ptr;\n"
               "    foo(arg_ptr);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) va_list 'arg_ptr' used before va_start() was called.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:9]: (error) va_list 'arg_ptr' used before va_start() was called. [va_list_usedBeforeStarted]\n", errout_str());
 
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
               "    va_list arg_ptr;\n"
               "    va_copy(f, arg_ptr);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) va_list 'arg_ptr' used before va_start() was called.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) va_list 'arg_ptr' used before va_start() was called. [va_list_usedBeforeStarted]\n", errout_str());
 
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
               "    va_list arg_ptr;\n"
@@ -208,13 +205,13 @@ class TestVaarg : public TestFixture {
               "    va_end(arg_ptr);\n"
               "    return va_arg(arg_ptr, float);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5]: (error) va_list 'arg_ptr' used before va_start() was called.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:5:19]: (error) va_list 'arg_ptr' used before va_start() was called. [va_list_usedBeforeStarted]\n", errout_str());
 
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
               "    va_list arg_ptr;\n"
               "    va_end(arg_ptr);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (error) va_list 'arg_ptr' used before va_start() was called.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:3:5]: (error) va_list 'arg_ptr' used before va_start() was called. [va_list_usedBeforeStarted]\n", errout_str());
 
 
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
@@ -225,7 +222,7 @@ class TestVaarg : public TestFixture {
               "    foo(va_arg(arg_ptr, float));\n"
               "    va_end(arg_ptr);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #6066
         check("void Format(va_list v1) {\n"
@@ -234,7 +231,7 @@ class TestVaarg : public TestFixture {
               "    foo(va_arg(v1, float));\n"
               "    va_end(v2);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #7527
         check("void foo(int flag1, int flag2, ...) {\n"
@@ -250,7 +247,7 @@ class TestVaarg : public TestFixture {
               "        va_end(vargs);\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #7533
         check("void action_push(int type, ...) {\n"
@@ -266,7 +263,7 @@ class TestVaarg : public TestFixture {
               "    }\n"
               "    va_end(args);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void action_push(int type, ...) {\n"
               "    va_list args;\n"
@@ -282,7 +279,7 @@ class TestVaarg : public TestFixture {
               "        break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         check("void action_push(int type, ...) {\n"
               "    va_list args;\n"
@@ -297,7 +294,7 @@ class TestVaarg : public TestFixture {
               "        break;\n"
               "    }\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:13]: (error) va_list 'args' was opened but not closed by va_end().\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:13:1]: (error) va_list 'args' was opened but not closed by va_end(). [va_end_missing]\n", errout_str());
 
         // #8043
         check("void redisvFormatCommand(char *format, va_list ap, bool flag) {\n"
@@ -312,7 +309,7 @@ class TestVaarg : public TestFixture {
               "    va_end(_cpy);\n"
               "format_err:\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void va_start_subsequentCalls() {
@@ -322,7 +319,7 @@ class TestVaarg : public TestFixture {
               "    va_start(arg_ptr, szBuffer);\n"
               "    va_end(arg_ptr);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) va_start() or va_copy() called subsequently on 'arg_ptr' without va_end() in between.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) va_start() or va_copy() called subsequently on 'arg_ptr' without va_end() in between. [va_start_subsequentCalls]\n", errout_str());
 
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
               "    va_list vl1;\n"
@@ -330,7 +327,7 @@ class TestVaarg : public TestFixture {
               "    va_copy(vl1, vl1);\n"
               "    va_end(vl1);\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:4]: (error) va_start() or va_copy() called subsequently on 'vl1' without va_end() in between.\n", errout.str());
+        ASSERT_EQUALS("[test.cpp:4:5]: (error) va_start() or va_copy() called subsequently on 'vl1' without va_end() in between. [va_start_subsequentCalls]\n", errout_str());
 
         check("void Format(char* szFormat, char (*szBuffer)[_Size], ...) {\n"
               "    va_list arg_ptr;\n"
@@ -339,7 +336,7 @@ class TestVaarg : public TestFixture {
               "    va_start(arg_ptr, szBuffer);\n"
               "    va_end(arg_ptr);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void unknownFunctionScope() {
@@ -348,7 +345,7 @@ class TestVaarg : public TestFixture {
               "  va_start(args,f);\n"
               "  BG_TString result(f);\n"
               "}");
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
 
         // #7559
         check("void mowgli_object_message_broadcast(mowgli_object_t *self, const char *name, ...) {\n"
diff --git a/test/testvalueflow.cpp b/test/testvalueflow.cpp
index 0ef8c8be0f6..709be2a204f 100644
--- a/test/testvalueflow.cpp
+++ b/test/testvalueflow.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,44 +16,48 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "library.h"
+#include "errortypes.h"
+#include "fixture.h"
+#include "helpers.h"
+#include "mathlib.h"
 #include "platform.h"
 #include "settings.h"
-#include "testsuite.h"
+#include "standards.h"
 #include "token.h"
-#include "tokenize.h"
-#include "valueflow.h"
+#include "vfvalue.h"
 
-#include <simplecpp.h>
+#include <algorithm>
+#include <climits>
 #include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <functional>
 #include <list>
-#include <map>
-#include <ostream>
+#include <set>
+#include <sstream>
 #include <string>
-#include <utility>
 #include <vector>
-#include <cstdint>
 
 class TestValueFlow : public TestFixture {
 public:
-    TestValueFlow() : TestFixture("TestValueFlow") {
-    }
+    TestValueFlow() : TestFixture("TestValueFlow") {}
 
 private:
-    Settings settings;
+    /*const*/ Settings settings = settingsBuilder().library("std.cfg").build();
 
-    void run() OVERRIDE {
+    void run() override {
         // strcpy, abort cfg
-        const char cfg[] = "<?xml version=\"1.0\"?>\n"
-        "<def>\n"
-        "  <function name=\"strcpy\"> <arg nr=\"1\"><not-null/></arg> </function>\n"
-        "  <function name=\"abort\"> <noreturn>true</noreturn> </function>\n" // abort is a noreturn function
-        "</def>";
-        settings.library.loadxmldata(cfg, sizeof(cfg));
-        LOAD_LIB_2(settings.library, "std.cfg");
-
+        constexpr char cfg[] = "<?xml version=\"1.0\"?>\n"
+                               "<def>\n"
+                               "  <function name=\"strcpy\"> <arg nr=\"1\"><not-null/></arg> </function>\n"
+                               "  <function name=\"abort\"> <noreturn>true</noreturn> </function>\n" // abort is a noreturn function
+                               "</def>";
+        settings = settingsBuilder(settings).libraryxml(cfg).build();
+
+        mNewTemplate = true;
         TEST_CASE(valueFlowNumber);
         TEST_CASE(valueFlowString);
+        TEST_CASE(valueFlowTypeTraits);
         TEST_CASE(valueFlowPointerAlias);
         TEST_CASE(valueFlowLifetime);
         TEST_CASE(valueFlowArrayElement);
@@ -64,6 +68,7 @@ class TestValueFlow : public TestFixture {
 
         TEST_CASE(valueFlowCalculations);
         TEST_CASE(valueFlowSizeof);
+        TEST_CASE(valueFlowComma);
 
         TEST_CASE(valueFlowErrorPath);
 
@@ -72,17 +77,24 @@ class TestValueFlow : public TestFixture {
         TEST_CASE(valueFlowBeforeConditionAssignIncDec);
         TEST_CASE(valueFlowBeforeConditionFunctionCall);
         TEST_CASE(valueFlowBeforeConditionGlobalVariables);
+        mNewTemplate = false;
         TEST_CASE(valueFlowBeforeConditionGoto);
+        mNewTemplate = true;
         TEST_CASE(valueFlowBeforeConditionIfElse);
         TEST_CASE(valueFlowBeforeConditionLoop);
+        mNewTemplate = false;
         TEST_CASE(valueFlowBeforeConditionMacro);
+        mNewTemplate = true;
         TEST_CASE(valueFlowBeforeConditionSizeof);
         TEST_CASE(valueFlowBeforeConditionSwitch);
         TEST_CASE(valueFlowBeforeConditionTernaryOp);
         TEST_CASE(valueFlowBeforeConditionForward);
+        TEST_CASE(valueFlowBeforeConditionConstructor);
 
         TEST_CASE(valueFlowAfterAssign);
+        TEST_CASE(valueFlowAfterSwap);
         TEST_CASE(valueFlowAfterCondition);
+        TEST_CASE(valueFlowAfterConditionTernary);
         TEST_CASE(valueFlowAfterConditionExpr);
         TEST_CASE(valueFlowAfterConditionSeveralNot);
         TEST_CASE(valueFlowForwardCompoundAssign);
@@ -91,6 +103,10 @@ class TestValueFlow : public TestFixture {
         TEST_CASE(valueFlowForwardFunction);
         TEST_CASE(valueFlowForwardTernary);
         TEST_CASE(valueFlowForwardLambda);
+        TEST_CASE(valueFlowForwardTryCatch);
+        TEST_CASE(valueFlowForwardInconclusiveImpossible);
+        TEST_CASE(valueFlowForwardConst);
+        TEST_CASE(valueFlowForwardAfterCondition);
 
         TEST_CASE(valueFlowFwdAnalysis);
 
@@ -118,82 +134,251 @@ class TestValueFlow : public TestFixture {
 
         TEST_CASE(valueFlowUninit);
 
-        TEST_CASE(valueFlowTerminatingCond);
+        TEST_CASE(valueFlowConditionExpressions);
 
         TEST_CASE(valueFlowContainerSize);
+        TEST_CASE(valueFlowContainerElement);
 
         TEST_CASE(valueFlowDynamicBufferSize);
 
         TEST_CASE(valueFlowSafeFunctionParameterValues);
         TEST_CASE(valueFlowUnknownFunctionReturn);
+        TEST_CASE(valueFlowUnknownFunctionReturnRand);
+        TEST_CASE(valueFlowUnknownFunctionReturnMalloc);
 
         TEST_CASE(valueFlowPointerAliasDeref);
+
+        TEST_CASE(valueFlowCrashIncompleteCode);
+
+        TEST_CASE(valueFlowCrash);
+        TEST_CASE(valueFlowHang);
+        TEST_CASE(valueFlowCrashConstructorInitialization);
+
+        TEST_CASE(valueFlowUnknownMixedOperators);
+        TEST_CASE(valueFlowSolveExpr);
+        TEST_CASE(valueFlowIdempotent);
+        TEST_CASE(valueFlowUnsigned);
+        TEST_CASE(valueFlowMod);
+        TEST_CASE(valueFlowIncDec);
+        TEST_CASE(valueFlowNotNull);
+        TEST_CASE(valueFlowSymbolic);
+        TEST_CASE(valueFlowSymbolicIdentity);
+        TEST_CASE(valueFlowSymbolicStrlen);
+        TEST_CASE(valueFlowSmartPointer);
+        TEST_CASE(valueFlowImpossibleMinMax);
+        TEST_CASE(valueFlowImpossibleIncDec);
+        TEST_CASE(valueFlowImpossibleUnknownConstant);
+        TEST_CASE(valueFlowContainerEqual);
+
+        mNewTemplate = false;
+        TEST_CASE(valueFlowBailoutIncompleteVar);
+        TEST_CASE(valueFlowBailoutNoreturn);
+        mNewTemplate = true;
+
+        TEST_CASE(performanceIfCount);
+        TEST_CASE(bitfields);
+
+        TEST_CASE(bitfieldsHang);
     }
 
     static bool isNotTokValue(const ValueFlow::Value &val) {
         return !val.isTokValue();
     }
 
-    bool testValueOfXKnown(const char code[], unsigned int linenr, int value) {
+    // cppcheck-suppress unusedPrivateFunction
+    static bool isNotLifetimeValue(const ValueFlow::Value& val) {
+        return !val.isLifetimeValue();
+    }
+
+    static bool isNotUninitValue(const ValueFlow::Value& val) {
+        return !val.isUninitValue();
+    }
+
+    static bool isNotPossible(const ValueFlow::Value& val) {
+        return !val.isPossible();
+    }
+
+    static bool isNotKnown(const ValueFlow::Value& val) {
+        return !val.isKnown();
+    }
+
+    static bool isNotInconclusive(const ValueFlow::Value& val) {
+        return !val.isInconclusive();
+    }
+
+    static bool isNotImpossible(const ValueFlow::Value& val) {
+        return !val.isImpossible();
+    }
+
+#define testValueOfXKnown(...) testValueOfXKnown_(__FILE__, __LINE__, __VA_ARGS__)
+    bool testValueOfXKnown_(const char* file, int line, const char code[], unsigned int linenr, int value) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {
             if (tok->str() == "x" && tok->linenr() == linenr) {
-                for (const ValueFlow::Value& val:tok->values()) {
+                if (std::any_of(tok->values().begin(), tok->values().end(), [&](const ValueFlow::Value& val) {
+                    if (val.isSymbolicValue())
+                        return false;
                     if (val.isKnown() && val.intvalue == value)
                         return true;
-                }
+                    return false;
+                }))
+                    return true;
+            }
+        }
+
+        return false;
+    }
+
+    bool testValueOfXKnown_(const char* file, int line, const char code[], unsigned int linenr, const std::string& expr, int value) {
+        // Tokenize..
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+
+        for (const Token* tok = tokenizer.tokens(); tok; tok = tok->next()) {
+            if (tok->str() == "x" && tok->linenr() == linenr) {
+                if (std::any_of(tok->values().begin(), tok->values().end(), [&](const ValueFlow::Value& val) {
+                    if (!val.isSymbolicValue())
+                        return false;
+                    if (val.isKnown() && val.intvalue == value && val.tokvalue->expressionString() == expr)
+                        return true;
+                    return false;
+                }))
+                    return true;
             }
         }
 
         return false;
     }
 
-    bool testValueOfX(const char code[], unsigned int linenr, int value) {
+#define testValueOfXImpossible(...) testValueOfXImpossible_(__FILE__, __LINE__, __VA_ARGS__)
+    bool testValueOfXImpossible_(const char* file, int line, const char code[], unsigned int linenr, int value) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {
             if (tok->str() == "x" && tok->linenr() == linenr) {
-                for (const ValueFlow::Value &v : tok->values()) {
-                    if (v.isIntValue() && !v.isImpossible() && v.intvalue == value)
+                if (std::any_of(tok->values().begin(), tok->values().end(), [&](const ValueFlow::Value& val) {
+                    if (val.isSymbolicValue())
+                        return false;
+                    if (val.isImpossible() && val.intvalue == value)
                         return true;
-                }
+                    return false;
+                }))
+                    return true;
+            }
+        }
+
+        return false;
+    }
+
+    bool testValueOfXImpossible_(const char* file, int line, const char code[], unsigned int linenr, const std::string& expr, int value)
+    {
+        // Tokenize..
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+
+        for (const Token* tok = tokenizer.tokens(); tok; tok = tok->next()) {
+            if (tok->str() == "x" && tok->linenr() == linenr) {
+                if (std::any_of(tok->values().begin(), tok->values().end(), [&](const ValueFlow::Value& val) {
+                    if (!val.isSymbolicValue())
+                        return false;
+                    if (val.isImpossible() && val.intvalue == value && val.tokvalue->expressionString() == expr)
+                        return true;
+                    return false;
+                }))
+                    return true;
             }
         }
 
         return false;
     }
 
-    bool testValueOfX(const char code[], unsigned int linenr, float value, float diff) {
+#define testValueOfXInconclusive(...) testValueOfXInconclusive_(__FILE__, __LINE__, __VA_ARGS__)
+    bool testValueOfXInconclusive_(const char* file, int line, const char code[], unsigned int linenr, int value) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {
             if (tok->str() == "x" && tok->linenr() == linenr) {
-                for (const ValueFlow::Value &v : tok->values()) {
-                    if (v.isFloatValue() && !v.isImpossible() && v.floatValue >= value - diff &&
-                        v.floatValue <= value + diff)
+                if (std::any_of(tok->values().begin(), tok->values().end(), [&](const ValueFlow::Value& val) {
+                    if (val.isSymbolicValue())
+                        return false;
+                    if (val.isInconclusive() && val.intvalue == value)
                         return true;
-                }
+                    return false;
+                }))
+                    return true;
+            }
+        }
+
+        return false;
+    }
+
+#define testValueOfX(...) testValueOfX_(__FILE__, __LINE__, __VA_ARGS__)
+    bool testValueOfX_(const char* file, int line, const char code[], unsigned int linenr, int value, const Settings *s = nullptr) {
+        const Settings *settings1 = s ? s : &settings;
+
+        // Tokenize..
+        SimpleTokenizer tokenizer(*settings1, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+
+        for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {
+            if (tok->str() == "x" && tok->linenr() == linenr) {
+                if (std::any_of(tok->values().cbegin(), tok->values().cend(), [&](const ValueFlow::Value& v) {
+                    return v.isIntValue() && !v.isImpossible() && v.intvalue == value;
+                }))
+                    return true;
+            }
+        }
+
+        return false;
+    }
+
+    bool testValueOfX_(const char* file, int line, const char code[], unsigned int linenr, const std::string& expr, int value)
+    {
+        // Tokenize..
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+
+        for (const Token* tok = tokenizer.tokens(); tok; tok = tok->next()) {
+            if (tok->str() == "x" && tok->linenr() == linenr) {
+                if (std::any_of(tok->values().cbegin(), tok->values().cend(), [&](const ValueFlow::Value& v) {
+                    return v.isSymbolicValue() && !v.isImpossible() && v.intvalue == value && v.tokvalue->expressionString() == expr;
+                }))
+                    return true;
+            }
+        }
+
+        return false;
+    }
+
+    bool testValueOfX_(const char* file, int line, const char code[], unsigned int linenr, double value, double diff) {
+        // Tokenize..
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+
+        for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {
+            if (tok->str() == "x" && tok->linenr() == linenr) {
+                if (std::any_of(tok->values().cbegin(), tok->values().cend(), [&](const ValueFlow::Value& v) {
+                    return v.isFloatValue() && !v.isImpossible() && v.floatValue >= value - diff && v.floatValue <= value + diff;
+                }))
+                    return true;
             }
         }
 
         return false;
     }
 
-    std::string getErrorPathForX(const char code[], unsigned int linenr) {
+#define getErrorPathForX(...) getErrorPathForX_(__FILE__, __LINE__, __VA_ARGS__)
+    std::string getErrorPathForX_(const char* file, int line, const char code[], unsigned int linenr) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {
             if (tok->str() != "x" || tok->linenr() != linenr)
@@ -201,7 +386,7 @@ class TestValueFlow : public TestFixture {
 
             std::ostringstream ostr;
             for (const ValueFlow::Value &v : tok->values()) {
-                for (const ValueFlow::Value::ErrorPathItem &ep : v.errorPath) {
+                for (const ErrorPathItem &ep : v.errorPath) {
                     const Token *eptok = ep.first;
                     const std::string &msg = ep.second;
                     ostr << eptok->linenr() << ',' << msg << '\n';
@@ -213,122 +398,206 @@ class TestValueFlow : public TestFixture {
         return "";
     }
 
-    bool testValueOfX(const char code[], unsigned int linenr, const char value[], ValueFlow::Value::ValueType type) {
+    bool testValueOfX_(const char* file, int line, const char code[], unsigned int linenr, const char value[], ValueFlow::Value::ValueType type) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
+        const std::size_t len = strlen(value);
         for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {
             if (tok->str() == "x" && tok->linenr() == linenr) {
-                for (const ValueFlow::Value &v : tok->values()) {
-                    if (v.valueType == type && Token::simpleMatch(v.tokvalue, value))
-                        return true;
-                }
+                if (std::any_of(tok->values().cbegin(), tok->values().cend(), [&](const ValueFlow::Value& v) {
+                    return v.valueType == type && Token::simpleMatch(v.tokvalue, value, len);
+                }))
+                    return true;
             }
         }
 
         return false;
     }
 
-    bool testValueOfX(const char code[], unsigned int linenr, int value, ValueFlow::Value::ValueType type) {
+#define testLifetimeOfX(...) testLifetimeOfX_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    bool testLifetimeOfX_(const char* file, int line, const char (&code)[size], unsigned int linenr, const char value[]) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
+        const std::size_t len = strlen(value);
         for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {
             if (tok->str() == "x" && tok->linenr() == linenr) {
-                for (const ValueFlow::Value &v : tok->values()) {
-                    if (v.valueType == type && v.intvalue == value)
-                        return true;
-                }
+                if (std::any_of(tok->values().cbegin(), tok->values().cend(), [&](const ValueFlow::Value& v) {
+                    return v.isLifetimeValue() && v.lifetimeScope == ValueFlow::Value::LifetimeScope::Local && Token::simpleMatch(v.tokvalue, value, len);
+                }))
+                    return true;
             }
         }
 
         return false;
     }
 
-    bool testValueOfX(const char code[], unsigned int linenr, ValueFlow::Value::MoveKind moveKind) {
+    bool testValueOfX_(const char* file, int line, const char code[], unsigned int linenr, int value, ValueFlow::Value::ValueType type) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {
             if (tok->str() == "x" && tok->linenr() == linenr) {
-                for (const ValueFlow::Value &v : tok->values()) {
-                    if (v.isMovedValue() && v.moveKind == moveKind)
-                        return true;
-                }
+                if (std::any_of(tok->values().cbegin(), tok->values().cend(), [&](const ValueFlow::Value& v) {
+                    return v.valueType == type && v.intvalue == value;
+                }))
+                    return true;
             }
         }
 
         return false;
     }
 
-    bool testConditionalValueOfX(const char code[], unsigned int linenr, int value) {
+    bool testValueOfX_(const char* file, int line, const char code[], unsigned int linenr, ValueFlow::Value::MoveKind moveKind) {
         // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, "test.cpp");
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
         for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {
             if (tok->str() == "x" && tok->linenr() == linenr) {
-                for (const ValueFlow::Value &v : tok->values()) {
-                    if (v.isIntValue() && v.intvalue == value && v.condition)
-                        return true;
-                }
+                if (std::any_of(tok->values().cbegin(), tok->values().cend(), [&](const ValueFlow::Value& v) {
+                    return v.isMovedValue() && v.moveKind == moveKind;
+                }))
+                    return true;
             }
         }
 
         return false;
     }
 
-    void bailout(const char code[]) {
-        settings.debugwarnings = true;
-        errout.str("");
+#define testConditionalValueOfX(...) testConditionalValueOfX_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    bool testConditionalValueOfX_(const char* file, int line, const char (&code)[size], unsigned int linenr, int value) {
+        // Tokenize..
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
 
-        std::vector<std::string> files(1, "test.cpp");
-        std::istringstream istr(code);
-        const simplecpp::TokenList tokens1(istr, files, files[0]);
+        for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {
+            if (tok->str() == "x" && tok->linenr() == linenr) {
+                if (std::any_of(tok->values().cbegin(), tok->values().cend(), [&](const ValueFlow::Value& v) {
+                    return v.isIntValue() && v.intvalue == value && v.condition;
+                }))
+                    return true;
+            }
+        }
 
-        simplecpp::TokenList tokens2(files);
-        std::map<std::string, simplecpp::TokenList*> filedata;
-        simplecpp::preprocess(tokens2, tokens1, files, filedata, simplecpp::DUI());
+        return false;
+    }
 
-        // Tokenize..
-        Tokenizer tokenizer(&settings, this);
-        tokenizer.createTokens(&tokens2);
-        tokenizer.simplifyTokens1("");
+#define bailout(...) bailout_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    void bailout_(const char* file, int line, const char (&code)[size]) {
+        const Settings s = settingsBuilder().debugwarnings().build();
 
-        settings.debugwarnings = false;
+        SimpleTokenizer2 tokenizer(s, *this, code, "test.cpp");
+
+        // Tokenize..
+        ASSERT_LOC(tokenizer.simplifyTokens1(""), file, line);
     }
 
-    std::list<ValueFlow::Value> tokenValues(const char code[], const char tokstr[], const Settings *s = nullptr) {
-        Tokenizer tokenizer(s ? s : &settings, this);
-        std::istringstream istr(code);
-        errout.str("");
-        tokenizer.tokenize(istr, "test.cpp");
+#define tokenValues(...) tokenValues_(__FILE__, __LINE__, __VA_ARGS__)
+    std::list<ValueFlow::Value> tokenValues_(const char* file, int line, const char code[], const char tokstr[], const Settings *s = nullptr, bool cpp = true) {
+        SimpleTokenizer tokenizer(s ? *s : settings, *this, cpp);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
         const Token *tok = Token::findmatch(tokenizer.tokens(), tokstr);
         return tok ? tok->values() : std::list<ValueFlow::Value>();
     }
 
-    ValueFlow::Value valueOfTok(const char code[], const char tokstr[]) {
-        std::list<ValueFlow::Value> values = tokenValues(code, tokstr);
+    std::list<ValueFlow::Value> tokenValues_(const char* file, int line, const char code[], const char tokstr[], ValueFlow::Value::ValueType vt) {
+        std::list<ValueFlow::Value> values = tokenValues_(file, line, code, tokstr);
+        values.remove_if([&](const ValueFlow::Value& v) {
+            return v.valueType != vt;
+        });
+        return values;
+    }
+
+#define lifetimeValues(...) lifetimeValues_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    std::vector<std::string> lifetimeValues_(const char* file, int line, const char (&code)[size], const char tokstr[]) {
+        std::vector<std::string> result;
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC(tokenizer.tokenize(code), file, line);
+        const Token *tok = Token::findmatch(tokenizer.tokens(), tokstr);
+        if (!tok)
+            return result;
+        for (const ValueFlow::Value& value:tok->values()) {
+            if (!value.isLifetimeValue())
+                continue;
+            if (!value.tokvalue)
+                continue;
+            result.push_back(value.tokvalue->expressionString());
+        }
+        return result;
+    }
+
+#define valueOfTok(...) valueOfTok_(__FILE__, __LINE__, __VA_ARGS__)
+    ValueFlow::Value valueOfTok_(const char* file, int line, const char code[], const char tokstr[], const Settings *s = nullptr, bool cpp = true) {
+        std::list<ValueFlow::Value> values = removeImpossible(tokenValues_(file, line, code, tokstr, s, cpp));
         return values.size() == 1U && !values.front().isTokValue() ? values.front() : ValueFlow::Value();
     }
 
+#define testKnownValueOfTok(...) testKnownValueOfTok_(__FILE__, __LINE__, __VA_ARGS__)
+    bool testKnownValueOfTok_(const char* file,
+                              int line,
+                              const char code[],
+                              const char tokstr[],
+                              int value)
+    {
+        std::list<ValueFlow::Value> values = removeImpossible(tokenValues_(file, line, code, tokstr));
+        return std::any_of(values.begin(), values.end(), [&](const ValueFlow::Value& v) {
+            return v.isKnown() && v.isIntValue() && v.intvalue == value;
+        });
+    }
+
+    static std::list<ValueFlow::Value> removeSymbolicTok(std::list<ValueFlow::Value> values)
+    {
+        values.remove_if([](const ValueFlow::Value& v) {
+            return v.isSymbolicValue() || v.isTokValue();
+        });
+        return values;
+    }
+
+    static std::list<ValueFlow::Value> removeImpossible(std::list<ValueFlow::Value> values)
+    {
+        values.remove_if(std::mem_fn(&ValueFlow::Value::isImpossible));
+        return values;
+    }
+
     void valueFlowNumber() {
         ASSERT_EQUALS(123, valueOfTok("x=123;", "123").intvalue);
-        ASSERT(std::fabs(valueOfTok("x=0.5;", "0.5").floatValue - 0.5f) < 0.1f);
+        ASSERT_EQUALS_DOUBLE(192.0, valueOfTok("x=0x0.3p10;", "0x0.3p10").floatValue, 1e-5); // 3 * 16^-1 * 2^10 = 192
+        ASSERT(std::fabs(valueOfTok("x=0.5;", "0.5").floatValue - 0.5) < 0.1);
         ASSERT_EQUALS(10, valueOfTok("enum {A=10,B=15}; x=A+0;", "+").intvalue);
         ASSERT_EQUALS(0, valueOfTok("x=false;", "false").intvalue);
         ASSERT_EQUALS(1, valueOfTok("x=true;", "true").intvalue);
         ASSERT_EQUALS(0, valueOfTok("x(NULL);", "NULL").intvalue);
-        ASSERT_EQUALS((int)('a'), valueOfTok("x='a';", "'a'").intvalue);
-        ASSERT_EQUALS((int)('\n'), valueOfTok("x='\\n';", "'\\n'").intvalue);
-        ASSERT_EQUALS(0xFFFFFFFF00000000, valueOfTok("x=0xFFFFFFFF00000000;","18446744069414584320U").intvalue); // #7701
+        ASSERT_EQUALS(static_cast<int>('a'), valueOfTok("x='a';", "'a'").intvalue);
+        ASSERT_EQUALS(static_cast<int>('\n'), valueOfTok("x='\\n';", "'\\n'").intvalue);
+        TODO_ASSERT_EQUALS(0xFFFFFFFF00000000, 0, valueOfTok("x=0xFFFFFFFF00000000;", "0xFFFFFFFF00000000").intvalue); // #7701
+        ASSERT_EQUALS_DOUBLE(16, valueOfTok("x=(double)16;", "(").floatValue, 1e-5);
+        ASSERT_EQUALS_DOUBLE(0.0625, valueOfTok("x=1/(double)16;", "/").floatValue, 1e-5);
+
+        const Settings settingsC23 = settingsBuilder().c(Standards::C23).build();
+        ASSERT_EQUALS(1, valueOfTok("x=true;", "true", &settingsC23, false).intvalue);
+        ASSERT_EQUALS(0, valueOfTok("x=false;", "false", &settingsC23, false).intvalue);
+
+        const Settings settingsC17 = settingsBuilder().c(Standards::C17).build();
+        ASSERT(!valueOfTok("x=true;", "true", &settingsC17, false).isKnown());
+        ASSERT(!valueOfTok("x=false;", "false", &settingsC17, false).isKnown());
+
+        // scope
+        {
+            const char code[] = "namespace N { enum E {e0,e1}; }\n"
+                                "void foo() { x = N::e1; }";
+            ASSERT_EQUALS(1, valueOfTok(code, "::").intvalue);
+        }
+
+        ASSERT_EQUALS(63, valueOfTok("x = 3 * uint32_t{21};", "*").intvalue);
     }
 
     void valueFlowString() {
@@ -340,7 +609,7 @@ class TestValueFlow : public TestFixture {
                 "    if (a) x = \"123\";\n"
                 "    return x;\n"
                 "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 4, "\"123\"", ValueFlow::Value::TOK));
+        ASSERT_EQUALS(true, testValueOfX(code, 4, "\"123\"", ValueFlow::Value::ValueType::TOK));
 
         // valueFlowSubFunction
         code  = "void dostuff(const char *x) {\n"
@@ -348,7 +617,137 @@ class TestValueFlow : public TestFixture {
                 "}\n"
                 "\n"
                 "void test() { dostuff(\"abc\"); }";
-        ASSERT_EQUALS(true, testValueOfX(code, 2, "\"abc\"", ValueFlow::Value::TOK));
+        ASSERT_EQUALS(true, testValueOfX(code, 2, "\"abc\"", ValueFlow::Value::ValueType::TOK));
+    }
+
+    void valueFlowTypeTraits()
+    {
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<void>{};", "{", 1));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<void>::value;", ":: value", 1));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void_v<void>;", "::", 1));
+
+        // is_void
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<int>{};", "{", 0));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<void*>{};", "{", 0));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<const void>{};", "{", 1));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_void<volatile void>{};", "{", 1));
+
+        // is_lvalue_reference
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_lvalue_reference<int>{};", "{", 0));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_lvalue_reference<int&>{};", "{", 1));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_lvalue_reference<int&&>{};", "{", 0));
+
+        // is_rvalue_reference
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_rvalue_reference<int>{};", "{", 0));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_rvalue_reference<int&>{};", "{", 0));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_rvalue_reference<int&&>{};", "{", 1));
+
+        // is_reference
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_reference<int>{};", "{", 0));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_reference<int&>{};", "{", 1));
+        ASSERT_EQUALS(true, testKnownValueOfTok("std::is_reference<int&&>{};", "{", 1));
+
+        {
+            const char* code;
+            code = "void bar();\n"
+                   "void foo() { std::is_void<decltype(bar())>::value; }";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));
+
+            code = "int bar();\n"
+                   "void foo() { std::is_void<decltype(bar())>::value; }";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));
+
+            code = "void bar();\n"
+                   "void foo() { std::is_void<decltype(bar)>::value; }";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));
+
+            code = "class A;\n"
+                   "void foo() { std::is_lvalue_reference<A>::value; }";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));
+
+            code = "class A;\n"
+                   "void foo() { std::is_lvalue_reference<A&>::value; }";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));
+
+            code = "class A;\n"
+                   "void foo() { std::is_lvalue_reference<A&&>::value; }";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));
+
+            code = "class A;\n"
+                   "void foo() { std::is_rvalue_reference<A>::value; }";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));
+
+            code = "class A;\n"
+                   "void foo() { std::is_rvalue_reference<A&>::value; }";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));
+
+            code = "class A;\n"
+                   "void foo() { std::is_rvalue_reference<A&&>::value; }";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));
+
+            code = "class A;\n"
+                   "void foo() { std::is_reference<A>::value; }";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));
+
+            code = "class A;\n"
+                   "void foo() { std::is_reference<A&>::value; }";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));
+
+            code = "class A;\n"
+                   "void foo() { std::is_reference<A&&>::value; }";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));
+
+            code = "void foo() {\n"
+                   "    int bar;\n"
+                   "    std::is_void<decltype(bar)>::value;\n"
+                   "}\n";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));
+
+            code = "void foo(int bar) {\n"
+                   "    std::is_lvalue_reference<decltype(bar)>::value;\n"
+                   "}\n";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));
+
+            code = "void foo(int& bar) {\n"
+                   "    std::is_lvalue_reference<decltype(bar)>::value;\n"
+                   "}\n";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));
+
+            code = "void foo(int&& bar) {\n"
+                   "    std::is_lvalue_reference<decltype(bar)>::value;\n"
+                   "}\n";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));
+
+            code = "void foo(int bar) {\n"
+                   "    std::is_rvalue_reference<decltype(bar)>::value;\n"
+                   "}\n";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));
+
+            code = "void foo(int& bar) {\n"
+                   "    std::is_rvalue_reference<decltype(bar)>::value;\n"
+                   "}\n";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));
+
+            code = "void foo(int&& bar) {\n"
+                   "    std::is_rvalue_reference<decltype(bar)>::value;\n"
+                   "}\n";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));
+
+            code = "void foo(int bar) {\n"
+                   "    std::is_reference<decltype(bar)>::value;\n"
+                   "}\n";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 0));
+
+            code = "void foo(int& bar) {\n"
+                   "    std::is_reference<decltype(bar)>::value;\n"
+                   "}\n";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));
+
+            code = "void foo(int&& bar) {\n"
+                   "    std::is_reference<decltype(bar)>::value;\n"
+                   "}\n";
+            ASSERT_EQUALS(true, testKnownValueOfTok(code, ":: value", 1));
+        }
     }
 
     void valueFlowPointerAlias() {
@@ -361,7 +760,7 @@ class TestValueFlow : public TestFixture {
                 "    if (a) x = &ret[0];\n"
                 "    return x;\n"
                 "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 5, "& ret [ 0 ]", ValueFlow::Value::TOK));
+        ASSERT_EQUALS(true, testValueOfX(code, 5, "& ret [ 0 ]", ValueFlow::Value::ValueType::TOK));
 
         // dead pointer
         code  = "void f() {\n"
@@ -369,7 +768,7 @@ class TestValueFlow : public TestFixture {
                 "  if (cond) { int i; x = &i; }\n"
                 "  *x = 0;\n"  // <- x can point at i
                 "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 4, "& i", ValueFlow::Value::TOK));
+        ASSERT_EQUALS(true, testValueOfX(code, 4, "& i", ValueFlow::Value::ValueType::TOK));
 
         code  = "void f() {\n"
                 "  struct X *x;\n"
@@ -385,38 +784,130 @@ class TestValueFlow : public TestFixture {
     }
 
     void valueFlowLifetime() {
-        const char *code;
+        std::vector<std::string> lifetimes;
 
-        LOAD_LIB_2(settings.library, "std.cfg");
+        {
+            const char code[] = "void f() {\n"
+                                "    int a = 1;\n"
+                                "    auto x = [&]() { return a + 1; };\n"
+                                "    auto b = x;\n"
+                                "}\n";
+            ASSERT_EQUALS(true, testLifetimeOfX(code, 4, "a + 1"));
+        }
 
-        code  = "void f() {\n"
-                "    int a = 1;\n"
-                "    auto x = [&]() { return a + 1; };\n"
-                "    auto b = x;\n"
-                "}\n";
-        ASSERT_EQUALS(true, testValueOfX(code, 4, "a + 1", ValueFlow::Value::LIFETIME));
+        {
+            const char code[] = "void f() {\n"
+                                "    int a = 1;\n"
+                                "    auto x = [=]() { return a + 1; };\n"
+                                "    auto b = x;\n"
+                                "}\n";
+            ASSERT_EQUALS(false, testLifetimeOfX(code, 4, "a ;"));
+        }
 
-        code  = "void f() {\n"
-                "    int a = 1;\n"
-                "    auto x = [=]() { return a + 1; };\n"
-                "    auto b = x;\n"
-                "}\n";
-        ASSERT_EQUALS(false, testValueOfX(code, 4, "a ;", ValueFlow::Value::LIFETIME));
+        {
+            const char code[] = "void f(int v) {\n"
+                                "    int a = v;\n"
+                                "    int * p = &a;\n"
+                                "    auto x = [=]() { return p + 1; };\n"
+                                "    auto b = x;\n"
+                                "}\n";
+            ASSERT_EQUALS(true, testLifetimeOfX(code, 5, "a ;"));
+        }
 
-        code  = "void f(int v) {\n"
-                "    int a = v;\n"
-                "    int * p = &a;\n"
-                "    auto x = [=]() { return p + 1; };\n"
-                "    auto b = x;\n"
-                "}\n";
-        ASSERT_EQUALS(true, testValueOfX(code, 5, "a ;", ValueFlow::Value::LIFETIME));
+        {
+            const char code[] = "void f() {\n"
+                                "    std::vector<int> v;\n"
+                                "    auto x = v.begin();\n"
+                                "    auto it = x;\n"
+                                "}\n";
+            ASSERT_EQUALS(true, testLifetimeOfX(code, 4, "v . begin"));
+        }
 
-        code  = "void f() {\n"
-                "    std::vector<int> v;\n"
-                "    auto x = v.begin();\n"
-                "    auto it = x;\n"
-                "}\n";
-        ASSERT_EQUALS(true, testValueOfX(code, 4, "v . begin", ValueFlow::Value::LIFETIME));
+        {
+            const char code[] = "void f() {\n"
+                                "    std::vector<int> v;\n"
+                                "    auto x = v.begin() + 1;\n"
+                                "    auto it = x;\n"
+                                "}\n";
+            ASSERT_EQUALS(true, testLifetimeOfX(code, 4, "v . begin"));
+        }
+
+        {
+            const char code[] = "int* f() {\n"
+                                "    std::vector<int> v;\n"
+                                "    int * x = v.data();\n"
+                                "    return x;\n"
+                                "}\n";
+            ASSERT_EQUALS(true, testLifetimeOfX(code, 4, "v . data"));
+        }
+
+        {
+            const char code[] = "int* f() {\n"
+                                "    std::vector<int> v;\n"
+                                "    int * x = v.data() + 1;\n"
+                                "    return x;\n"
+                                "}\n";
+            ASSERT_EQUALS(true, testLifetimeOfX(code, 4, "v . data"));
+        }
+
+        {
+            const char code[] = "int f(int* a) {\n"
+                                "    int **p = &a;\n"
+                                "    int * x = *p;\n"
+                                "    return x; \n"
+                                "}\n";
+            ASSERT_EQUALS(false, testLifetimeOfX(code, 4, "a"));
+        }
+
+        {
+            const char code[] = "void f() {\n"
+                                "    int i = 0;\n"
+                                "    void* x = (void*)&i;\n"
+                                "}\n";
+            lifetimes = lifetimeValues(code, "( void * )");
+            ASSERT_EQUALS(true, lifetimes.size() == 1);
+            ASSERT_EQUALS(true, lifetimes.front() == "i");
+        }
+
+        {
+            const char code[] = "struct T {\n" // #10810
+                                "    static int g() { return 0; }\n"
+                                "};\n"
+                                "T t;\n"
+                                "struct S { int i; };\n"
+                                "S f() {\n"
+                                "    S s = { decltype(t)::g() };\n"
+                                "    return s;\n"
+                                "};\n";
+            lifetimes = lifetimeValues(code, "=");
+            ASSERT_EQUALS(true, lifetimes.empty());
+        }
+
+        {
+            const char code[] = "struct T {\n" // #10838
+                                "     void f();\n"
+                                "     double d[4][4];\n"
+                                "};\n"
+                                "void T::f() {\n"
+                                "    auto g = [this]() -> double(&)[4] {\n"
+                                "        double(&q)[4] = d[0];\n"
+                                "        return q;\n"
+                                "    };\n"
+                                "}\n";
+            lifetimes = lifetimeValues(code, "return"); // don't crash
+            ASSERT_EQUALS(true, lifetimes.empty());
+        }
+
+        {
+            const char code[] = "void f() {\n" // #13076
+                                "    char a[10];\n"
+                                "    struct S s = { sizeof(a), 0 };\n"
+                                "    s.p = a;\n"
+                                "}\n";
+            lifetimes = lifetimeValues(code, "= a");
+            ASSERT_EQUALS(true, lifetimes.size() == 1);
+            ASSERT_EQUALS(true, lifetimes.front() == "a");
+        }
     }
 
     void valueFlowArrayElement() {
@@ -426,38 +917,52 @@ class TestValueFlow : public TestFixture {
                 "    const int x[] = {43,23,12};\n"
                 "    return x;\n"
                 "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 3U, "{ 43 , 23 , 12 }", ValueFlow::Value::TOK));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, "{ 43 , 23 , 12 }", ValueFlow::Value::ValueType::TOK));
 
         code  = "void f() {\n"
                 "    const char x[] = \"abcd\";\n"
                 "    return x;\n"
                 "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 3U, "\"abcd\"", ValueFlow::Value::TOK));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, "\"abcd\"", ValueFlow::Value::ValueType::TOK));
 
         code  = "void f() {\n"
                 "    char x[32] = \"abcd\";\n"
                 "    return x;\n"
                 "}";
-        TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 3U, "\"abcd\"", ValueFlow::Value::TOK));
+        TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 3U, "\"abcd\"", ValueFlow::Value::ValueType::TOK));
 
         code = "void f() {\n"
                "  int a[10];\n"
                "  int *x = a;\n" // <- a value is a
                "  *x = 0;\n"     // .. => x value is a
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 4, "a", ValueFlow::Value::TOK));
+        ASSERT_EQUALS(true, testValueOfX(code, 4, "a", ValueFlow::Value::ValueType::TOK));
 
         code  = "char f() {\n"
                 "    const char *x = \"abcd\";\n"
                 "    return x[0];\n"
                 "}";
-        ASSERT_EQUALS((int)('a'), valueOfTok(code, "[").intvalue);
+        ASSERT_EQUALS(static_cast<int>('a'), valueOfTok(code, "[").intvalue);
 
         code  = "char f() {\n"
                 "    const char *x = \"\";\n"
                 "    return x[0];\n"
                 "}";
         ASSERT_EQUALS(0, valueOfTok(code, "[").intvalue);
+
+        code = "int g() { return 3; }\n"
+               "void f() {\n"
+               "    const int x[2] = { g(), g() };\n"
+               "    return x[0];\n"
+               "}\n";
+        ASSERT_EQUALS(3, valueOfTok(code, "[ 0").intvalue);
+
+        code = "int g() { return 3; }\n"
+               "void f() {\n"
+               "    const int x[2] = { g(), g() };\n"
+               "    return x[1];\n"
+               "}\n";
+        ASSERT_EQUALS(3, valueOfTok(code, "[ 1").intvalue);
     }
 
     void valueFlowMove() {
@@ -516,7 +1021,7 @@ class TestValueFlow : public TestFixture {
 
         code = "void f(int i) {\n"
                "    X x;\n"
-               "    y = g(std::move(x), \n"
+               "    y = g(std::move(x),\n"
                "          x.size());\n"
                "}";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, ValueFlow::Value::MoveKind::MovedVariable));
@@ -549,6 +1054,29 @@ class TestValueFlow : public TestFixture {
                "   X y=x;\n"
                "}";
         ASSERT_EQUALS(true, testValueOfX(code, 11U, ValueFlow::Value::MoveKind::MovedVariable));
+
+        code = "void f(int x) {\n"
+               "   g(std::move(x));\n"
+               "   y=x;\n"
+               "}";
+        ASSERT_EQUALS(false, testValueOfX(code, 3U, ValueFlow::Value::MoveKind::MovedVariable));
+
+        code = "void g(std::string);\n"
+               "void foo(std::string x) {\n"
+               "  g(std::move(x));\n"
+               "  int counter = 0;\n"
+               "\n"
+               "  for (int i = 0; i < 5; i++) {\n"
+               "    if (i % 2 == 0) {\n"
+               "      x = std::to_string(i);\n"
+               "      counter++;\n"
+               "    }\n"
+               "  }\n"
+               "  for (int i = 0; i < counter; i++) {\n"
+               "      if(x > 5) {}\n"
+               "  }\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 13U, ValueFlow::Value::MoveKind::MovedVariable));
     }
 
     void valueFlowCalculations() {
@@ -575,14 +1103,43 @@ class TestValueFlow : public TestFixture {
         ASSERT_EQUALS(0, valueOfTok("(UNKNOWN_TYPE*)0;","(").intvalue);
         ASSERT_EQUALS(100, valueOfTok("(int)100.0;", "(").intvalue);
         ASSERT_EQUALS(10, valueOfTok("x = static_cast<int>(10);", "( 10 )").intvalue);
+        ASSERT_EQUALS(0, valueOfTok("x = sizeof (struct {int a;}) * 0;", "*").intvalue);
 
-        // Don't calculate if there is UB
+        // Don't calculate or crash if there is UB or invalid operations
         ASSERT(tokenValues(";-1<<10;","<<").empty());
         ASSERT(tokenValues(";10<<-1;","<<").empty());
         ASSERT(tokenValues(";10<<64;","<<").empty());
         ASSERT(tokenValues(";-1>>10;",">>").empty());
         ASSERT(tokenValues(";10>>-1;",">>").empty());
         ASSERT(tokenValues(";10>>64;",">>").empty());
+        ASSERT_EQUALS(tokenValues(";1%-1;","%").size(), 1);
+        ASSERT_EQUALS(tokenValues(";1%-10;","%").size(), 1);
+        ASSERT_EQUALS(tokenValues(";1.5%-1;","%").size(), 1);
+        ASSERT_EQUALS(tokenValues(";1.5%-10;","%").size(), 1);
+        ASSERT(tokenValues(";1%-1.5;","%").empty());
+        ASSERT(tokenValues(";1%-10.5;","%").empty());
+        ASSERT(tokenValues(";1.5%-1.5;","%").empty());
+        ASSERT(tokenValues(";1.5%-10.5;","%").empty());
+        ASSERT(tokenValues(";1/-1;","/").empty());
+        ASSERT(tokenValues(";1/-10;","/").empty());
+        ASSERT(tokenValues(";1.5/-1;","/").empty());
+        ASSERT(tokenValues(";1.5/-10;","/").empty());
+        ASSERT(tokenValues(";1/-1.5;","/").empty());
+        ASSERT(tokenValues(";1/-10.5;","/").empty());
+        ASSERT(tokenValues(";1.5/-1.5;","/").empty());
+        ASSERT(tokenValues(";1.5/-10.5;","/").empty());
+        ASSERT(tokenValues(";1/0;","/").empty());
+        ASSERT(tokenValues(";1/0;","/").empty());
+        ASSERT(tokenValues(";1.5/0;","/").empty());
+        ASSERT(tokenValues(";1.5/0;","/").empty());
+        ASSERT(tokenValues(";((-1) * 9223372036854775807LL - 1) / (-1);", "/").empty()); // #12109
+        ASSERT_EQUALS(tokenValues(";((-1) * 9223372036854775807LL - 1) % (-1);", "%").size(), 1); // #12109
+
+        code = "float f(const uint16_t& value) {\n"
+               "    const uint16_t uVal = value; \n"
+               "    return static_cast<float>(uVal) / 2;\n"
+               "}\n";
+        ASSERT_EQUALS(true, tokenValues(code, "/").empty());
 
         // calculation using 1,2 variables/values
         code  = "void f(int x) {\n"
@@ -650,9 +1207,15 @@ class TestValueFlow : public TestFixture {
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(123, values.empty() ? 0 : values.front().intvalue);
 
+        code  = "int f() {\n"
+                "    const int i = 1;\n"
+                "    int x = i < 0 ? 0 : 1;\n"
+                "    return x;\n"
+                "}";
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 1));
+
         // ~
         code  = "x = ~0U;";
-        settings.platform(cppcheck::Platform::Native); // ensure platform is native
         values = tokenValues(code,"~");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(~0U, values.back().intvalue);
@@ -662,7 +1225,7 @@ class TestValueFlow : public TestFixture {
                 "    a = !x;\n"
                 "    if (x==0) {}\n"
                 "}";
-        values = tokenValues(code,"!");
+        values = removeImpossible(tokenValues(code, "!"));
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(1, values.back().intvalue);
 
@@ -725,6 +1288,19 @@ class TestValueFlow : public TestFixture {
                "}";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 0));
 
+        code = "void f(int i) {\n"
+               "    int * p = &i;\n"
+               "    bool x = !p || i;\n"
+               "    bool a = x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 4U, 1));
+
+        code = "bool f(const uint16_t * const p) {\n"
+               "    const uint8_t x = (uint8_t)(*p & 0x01E0U) >> 5U;\n"
+               "    return x != 0;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, -1));
+
         code = "bool f() {\n"
                "    bool a = (4 == 3);\n"
                "    bool b = (3 == 3);\n"
@@ -755,23 +1331,30 @@ class TestValueFlow : public TestFixture {
             ASSERT_EQUALS(22, values.back().intvalue);
         }
 
+        // #10251 starship operator
+        code  = "struct X {};\n"
+                "auto operator<=>(const X & a, const X & b) -> decltype(1 <=> 2) {\n"
+                "    return std::strong_ordering::less;\n"
+                "}\n";
+        ASSERT_NO_THROW(tokenValues(code, "<=>"));
+
         // Comparison of string
-        values = tokenValues("f(\"xyz\" == \"xyz\");", "=="); // implementation defined
+        values = removeImpossible(tokenValues("f(\"xyz\" == \"xyz\");", "==")); // implementation defined
         ASSERT_EQUALS(0U, values.size()); // <- no value
 
-        values = tokenValues("f(\"xyz\" == 0);", "==");
+        values = removeImpossible(tokenValues("f(\"xyz\" == 0);", "=="));
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(0, values.front().intvalue);
 
-        values = tokenValues("f(0 == \"xyz\");", "==");
+        values = removeImpossible(tokenValues("f(0 == \"xyz\");", "=="));
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(0, values.front().intvalue);
 
-        values = tokenValues("f(\"xyz\" != 0);", "!=");
+        values = removeImpossible(tokenValues("f(\"xyz\" != 0);", "!="));
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(1, values.front().intvalue);
 
-        values = tokenValues("f(0 != \"xyz\");", "!=");
+        values = removeImpossible(tokenValues("f(0 != \"xyz\");", "!="));
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(1, values.front().intvalue);
     }
@@ -789,22 +1372,57 @@ class TestValueFlow : public TestFixture {
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(1, values.back().intvalue);
 
-#define CHECK(A, B)                              \
+        code  = "void f() {\n"
+                "    char a[10];"
+                "    x = sizeof(a[0]);\n"
+                "}";
+        values = tokenValues(code,"( a");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(1, values.back().intvalue);
+
+        code = "enum testEnum : uint32_t { a };\n"
+               "sizeof(testEnum);";
+        values = tokenValues(code,"( testEnum");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(4, values.back().intvalue);
+
+#define CHECK3(A, B, C)                          \
+    do {                                     \
         code = "void f() {\n"                    \
                "    x = sizeof(" A ");\n"        \
                "}";                              \
-        values = tokenValues(code,"( " A " )");  \
+        values = tokenValues(code,"( " C " )");  \
         ASSERT_EQUALS(1U, values.size());        \
-        ASSERT_EQUALS(B, values.back().intvalue);
+        ASSERT_EQUALS(B, values.back().intvalue); \
+    } while (false)
+#define CHECK(A, B) CHECK3(A, B, A)
 
         // standard types
-        CHECK("void *", settings.sizeof_pointer);
+        CHECK("void *", settings.platform.sizeof_pointer);
         CHECK("char", 1U);
-        CHECK("short", settings.sizeof_short);
-        CHECK("int", settings.sizeof_int);
-        CHECK("long", settings.sizeof_long);
-        CHECK("wchar_t", settings.sizeof_wchar_t);
+        CHECK("short", settings.platform.sizeof_short);
+        CHECK("int", settings.platform.sizeof_int);
+        CHECK("long", settings.platform.sizeof_long);
+        CHECK3("long long", settings.platform.sizeof_long_long, "long");
+        CHECK("wchar_t", settings.platform.sizeof_wchar_t);
+        CHECK("float", settings.platform.sizeof_float);
+        CHECK("double", settings.platform.sizeof_double);
+        CHECK3("long double", settings.platform.sizeof_long_double, "double");
+
+        // string/char literals
+        CHECK("\"asdf\"", 5);
+        CHECK("L\"asdf\"", 5LL * settings.platform.sizeof_wchar_t);
+        CHECK("u8\"asdf\"", 5); // char8_t
+        CHECK("u\"asdf\"", 5LL * 2); // char16_t
+        CHECK("U\"asdf\"", 5LL * 4); // char32_t
+        CHECK("'a'", 1U);
+        CHECK("'ab'", settings.platform.sizeof_int);
+        CHECK("L'a'", settings.platform.sizeof_wchar_t);
+        CHECK("u8'a'", 1U); // char8_t
+        CHECK("u'a'", 2U); // char16_t
+        CHECK("U'a'", 4U); // char32_t
 #undef CHECK
+#undef CHECK3
 
         // array size
         code  = "void f() {\n"
@@ -815,80 +1433,92 @@ class TestValueFlow : public TestFixture {
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(10, values.back().intvalue);
 
+        code  = "void f() {\n" // #11294
+                "    struct S { int i; };\n"
+                "    const S a[] = { 1, 2 };\n"
+                "    x = sizeof(a) / ( sizeof(a[0]) );\n"
+                "}";
+        values = tokenValues(code, "/");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(2, values.back().intvalue);
+
 #define CHECK(A, B, C, D)                         \
+    do {                                      \
         code = "enum " A " E " B " { E0, E1 };\n" \
                "void f() {\n"                     \
                "    x = sizeof(" C ");\n"         \
                "}";                               \
         values = tokenValues(code,"( " C " )");   \
         ASSERT_EQUALS(1U, values.size());         \
-        ASSERT_EQUALS(D, values.back().intvalue);
+        ASSERT_EQUALS(D, values.back().intvalue); \
+    } while (false)
 
         // enums
-        CHECK("", "", "E", settings.sizeof_int);
+        CHECK("", "", "E", settings.platform.sizeof_int);
 
         // typed enums
         CHECK("", ": char", "E", 1U);
         CHECK("", ": signed char", "E", 1U);
         CHECK("", ": unsigned char", "E", 1U);
-        CHECK("", ": short", "E", settings.sizeof_short);
-        CHECK("", ": signed short", "E", settings.sizeof_short);
-        CHECK("", ": unsigned short", "E", settings.sizeof_short);
-        CHECK("", ": int", "E", settings.sizeof_int);
-        CHECK("", ": signed int", "E", settings.sizeof_int);
-        CHECK("", ": unsigned int", "E", settings.sizeof_int);
-        CHECK("", ": long", "E", settings.sizeof_long);
-        CHECK("", ": signed long", "E", settings.sizeof_long);
-        CHECK("", ": unsigned long", "E", settings.sizeof_long);
-        CHECK("", ": long long", "E", settings.sizeof_long_long);
-        CHECK("", ": signed long long", "E", settings.sizeof_long_long);
-        CHECK("", ": unsigned long long", "E", settings.sizeof_long_long);
-        CHECK("", ": wchar_t", "E", settings.sizeof_wchar_t);
-        CHECK("", ": size_t", "E", settings.sizeof_size_t);
+        CHECK("", ": short", "E", settings.platform.sizeof_short);
+        CHECK("", ": signed short", "E", settings.platform.sizeof_short);
+        CHECK("", ": unsigned short", "E", settings.platform.sizeof_short);
+        CHECK("", ": int", "E", settings.platform.sizeof_int);
+        CHECK("", ": signed int", "E", settings.platform.sizeof_int);
+        CHECK("", ": unsigned int", "E", settings.platform.sizeof_int);
+        CHECK("", ": long", "E", settings.platform.sizeof_long);
+        CHECK("", ": signed long", "E", settings.platform.sizeof_long);
+        CHECK("", ": unsigned long", "E", settings.platform.sizeof_long);
+        CHECK("", ": long long", "E", settings.platform.sizeof_long_long);
+        CHECK("", ": signed long long", "E", settings.platform.sizeof_long_long);
+        CHECK("", ": unsigned long long", "E", settings.platform.sizeof_long_long);
+        CHECK("", ": wchar_t", "E", settings.platform.sizeof_wchar_t);
+        CHECK("", ": size_t", "E", settings.platform.sizeof_size_t);
 
         // enumerators
-        CHECK("", "", "E0", settings.sizeof_int);
+        CHECK("", "", "E0", settings.platform.sizeof_int);
 
         // typed enumerators
         CHECK("", ": char", "E0", 1U);
         CHECK("", ": signed char", "E0", 1U);
         CHECK("", ": unsigned char", "E0", 1U);
-        CHECK("", ": short", "E0", settings.sizeof_short);
-        CHECK("", ": signed short", "E0", settings.sizeof_short);
-        CHECK("", ": unsigned short", "E0", settings.sizeof_short);
-        CHECK("", ": int", "E0", settings.sizeof_int);
-        CHECK("", ": signed int", "E0", settings.sizeof_int);
-        CHECK("", ": unsigned int", "E0", settings.sizeof_int);
-        CHECK("", ": long", "E0", settings.sizeof_long);
-        CHECK("", ": signed long", "E0", settings.sizeof_long);
-        CHECK("", ": unsigned long", "E0", settings.sizeof_long);
-        CHECK("", ": long long", "E0", settings.sizeof_long_long);
-        CHECK("", ": signed long long", "E0", settings.sizeof_long_long);
-        CHECK("", ": unsigned long long", "E0", settings.sizeof_long_long);
-        CHECK("", ": wchar_t", "E0", settings.sizeof_wchar_t);
-        CHECK("", ": size_t", "E0", settings.sizeof_size_t);
+        CHECK("", ": short", "E0", settings.platform.sizeof_short);
+        CHECK("", ": signed short", "E0", settings.platform.sizeof_short);
+        CHECK("", ": unsigned short", "E0", settings.platform.sizeof_short);
+        CHECK("", ": int", "E0", settings.platform.sizeof_int);
+        CHECK("", ": signed int", "E0", settings.platform.sizeof_int);
+        CHECK("", ": unsigned int", "E0", settings.platform.sizeof_int);
+        CHECK("", ": long", "E0", settings.platform.sizeof_long);
+        CHECK("", ": signed long", "E0", settings.platform.sizeof_long);
+        CHECK("", ": unsigned long", "E0", settings.platform.sizeof_long);
+        CHECK("", ": long long", "E0", settings.platform.sizeof_long_long);
+        CHECK("", ": signed long long", "E0", settings.platform.sizeof_long_long);
+        CHECK("", ": unsigned long long", "E0", settings.platform.sizeof_long_long);
+        CHECK("", ": wchar_t", "E0", settings.platform.sizeof_wchar_t);
+        CHECK("", ": size_t", "E0", settings.platform.sizeof_size_t);
 
         // class typed enumerators
         CHECK("class", ": char", "E :: E0", 1U);
         CHECK("class", ": signed char", "E :: E0", 1U);
         CHECK("class", ": unsigned char", "E :: E0", 1U);
-        CHECK("class", ": short", "E :: E0", settings.sizeof_short);
-        CHECK("class", ": signed short", "E :: E0", settings.sizeof_short);
-        CHECK("class", ": unsigned short", "E :: E0", settings.sizeof_short);
-        CHECK("class", ": int", "E :: E0", settings.sizeof_int);
-        CHECK("class", ": signed int", "E :: E0", settings.sizeof_int);
-        CHECK("class", ": unsigned int", "E :: E0", settings.sizeof_int);
-        CHECK("class", ": long", "E :: E0", settings.sizeof_long);
-        CHECK("class", ": signed long", "E :: E0", settings.sizeof_long);
-        CHECK("class", ": unsigned long", "E :: E0", settings.sizeof_long);
-        CHECK("class", ": long long", "E :: E0", settings.sizeof_long_long);
-        CHECK("class", ": signed long long", "E :: E0", settings.sizeof_long_long);
-        CHECK("class", ": unsigned long long", "E :: E0", settings.sizeof_long_long);
-        CHECK("class", ": wchar_t", "E :: E0", settings.sizeof_wchar_t);
-        CHECK("class", ": size_t", "E :: E0", settings.sizeof_size_t);
+        CHECK("class", ": short", "E :: E0", settings.platform.sizeof_short);
+        CHECK("class", ": signed short", "E :: E0", settings.platform.sizeof_short);
+        CHECK("class", ": unsigned short", "E :: E0", settings.platform.sizeof_short);
+        CHECK("class", ": int", "E :: E0", settings.platform.sizeof_int);
+        CHECK("class", ": signed int", "E :: E0", settings.platform.sizeof_int);
+        CHECK("class", ": unsigned int", "E :: E0", settings.platform.sizeof_int);
+        CHECK("class", ": long", "E :: E0", settings.platform.sizeof_long);
+        CHECK("class", ": signed long", "E :: E0", settings.platform.sizeof_long);
+        CHECK("class", ": unsigned long", "E :: E0", settings.platform.sizeof_long);
+        CHECK("class", ": long long", "E :: E0", settings.platform.sizeof_long_long);
+        CHECK("class", ": signed long long", "E :: E0", settings.platform.sizeof_long_long);
+        CHECK("class", ": unsigned long long", "E :: E0", settings.platform.sizeof_long_long);
+        CHECK("class", ": wchar_t", "E :: E0", settings.platform.sizeof_wchar_t);
+        CHECK("class", ": size_t", "E :: E0", settings.platform.sizeof_size_t);
 #undef CHECK
 
 #define CHECK(A, B)                                   \
+    do {                                          \
         code = "enum E " A " { E0, E1 };\n"           \
                "void f() {\n"                         \
                "    E arrE[] = { E0, E1 };\n"         \
@@ -896,32 +1526,34 @@ class TestValueFlow : public TestFixture {
                "}";                                   \
         values = tokenValues(code,"( arrE )");        \
         ASSERT_EQUALS(1U, values.size());             \
-        ASSERT_EQUALS(B * 2U, values.back().intvalue);
+        ASSERT_EQUALS(B * 2ULL, values.back().intvalue); \
+    } while (false)
 
         // enum array
-        CHECK("", settings.sizeof_int);
+        CHECK("", settings.platform.sizeof_int);
 
         // typed enum array
         CHECK(": char", 1U);
         CHECK(": signed char", 1U);
         CHECK(": unsigned char", 1U);
-        CHECK(": short", settings.sizeof_short);
-        CHECK(": signed short", settings.sizeof_short);
-        CHECK(": unsigned short", settings.sizeof_short);
-        CHECK(": int", settings.sizeof_int);
-        CHECK(": signed int", settings.sizeof_int);
-        CHECK(": unsigned int", settings.sizeof_int);
-        CHECK(": long", settings.sizeof_long);
-        CHECK(": signed long", settings.sizeof_long);
-        CHECK(": unsigned long", settings.sizeof_long);
-        CHECK(": long long", settings.sizeof_long_long);
-        CHECK(": signed long long", settings.sizeof_long_long);
-        CHECK(": unsigned long long", settings.sizeof_long_long);
-        CHECK(": wchar_t", settings.sizeof_wchar_t);
-        CHECK(": size_t", settings.sizeof_size_t);
+        CHECK(": short", settings.platform.sizeof_short);
+        CHECK(": signed short", settings.platform.sizeof_short);
+        CHECK(": unsigned short", settings.platform.sizeof_short);
+        CHECK(": int", settings.platform.sizeof_int);
+        CHECK(": signed int", settings.platform.sizeof_int);
+        CHECK(": unsigned int", settings.platform.sizeof_int);
+        CHECK(": long", settings.platform.sizeof_long);
+        CHECK(": signed long", settings.platform.sizeof_long);
+        CHECK(": unsigned long", settings.platform.sizeof_long);
+        CHECK(": long long", settings.platform.sizeof_long_long);
+        CHECK(": signed long long", settings.platform.sizeof_long_long);
+        CHECK(": unsigned long long", settings.platform.sizeof_long_long);
+        CHECK(": wchar_t", settings.platform.sizeof_wchar_t);
+        CHECK(": size_t", settings.platform.sizeof_size_t);
 #undef CHECK
 
 #define CHECK(A, B)                                   \
+    do {                                          \
         code = "enum class E " A " { E0, E1 };\n"     \
                "void f() {\n"                         \
                "    E arrE[] = { E::E0, E::E1 };\n"   \
@@ -929,29 +1561,30 @@ class TestValueFlow : public TestFixture {
                "}";                                   \
         values = tokenValues(code,"( arrE )");        \
         ASSERT_EQUALS(1U, values.size());             \
-        ASSERT_EQUALS(B * 2U, values.back().intvalue);
+        ASSERT_EQUALS(B * 2ULL, values.back().intvalue); \
+    } while (false)
 
         // enum array
-        CHECK("", settings.sizeof_int);
+        CHECK("", settings.platform.sizeof_int);
 
         // typed enum array
         CHECK(": char", 1U);
         CHECK(": signed char", 1U);
         CHECK(": unsigned char", 1U);
-        CHECK(": short", settings.sizeof_short);
-        CHECK(": signed short", settings.sizeof_short);
-        CHECK(": unsigned short", settings.sizeof_short);
-        CHECK(": int", settings.sizeof_int);
-        CHECK(": signed int", settings.sizeof_int);
-        CHECK(": unsigned int", settings.sizeof_int);
-        CHECK(": long", settings.sizeof_long);
-        CHECK(": signed long", settings.sizeof_long);
-        CHECK(": unsigned long", settings.sizeof_long);
-        CHECK(": long long", settings.sizeof_long_long);
-        CHECK(": signed long long", settings.sizeof_long_long);
-        CHECK(": unsigned long long", settings.sizeof_long_long);
-        CHECK(": wchar_t", settings.sizeof_wchar_t);
-        CHECK(": size_t", settings.sizeof_size_t);
+        CHECK(": short", settings.platform.sizeof_short);
+        CHECK(": signed short", settings.platform.sizeof_short);
+        CHECK(": unsigned short", settings.platform.sizeof_short);
+        CHECK(": int", settings.platform.sizeof_int);
+        CHECK(": signed int", settings.platform.sizeof_int);
+        CHECK(": unsigned int", settings.platform.sizeof_int);
+        CHECK(": long", settings.platform.sizeof_long);
+        CHECK(": signed long", settings.platform.sizeof_long);
+        CHECK(": unsigned long", settings.platform.sizeof_long);
+        CHECK(": long long", settings.platform.sizeof_long_long);
+        CHECK(": signed long long", settings.platform.sizeof_long_long);
+        CHECK(": unsigned long long", settings.platform.sizeof_long_long);
+        CHECK(": wchar_t", settings.platform.sizeof_wchar_t);
+        CHECK(": size_t", settings.platform.sizeof_size_t);
 #undef CHECK
 
         code = "uint16_t arr[10];\n"
@@ -959,46 +1592,223 @@ class TestValueFlow : public TestFixture {
         values = tokenValues(code,"( arr )");
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(10 * sizeof(std::uint16_t), values.back().intvalue);
-    }
 
-    void valueFlowErrorPath() {
-        const char *code;
+        code = "int sz = sizeof(int32_t[10][20]);";
+        values = tokenValues(code, "=");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(sizeof(std::int32_t) * 10 * 20, values.back().intvalue);
 
-        code = "void f() {\n"
-               "  int x = 53;\n"
-               "  a = x;\n"
-               "}\n";
-        ASSERT_EQUALS("2,Assignment 'x=53', assigned value is 53\n",
-                      getErrorPathForX(code, 3U));
+        code = "struct X { float a; float b; };\n"
+               "void f() {\n"
+               "    x = sizeof(X);\n"
+               "}";
+        values = tokenValues(code, "( X )");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(8, values.back().intvalue);
 
-        code = "void f(int y) {\n"
-               "  int x = y;\n"
-               "  a = x;\n"
-               "  y += 12;\n"
-               "  if (y == 32) {}"
-               "}\n";
-        ASSERT_EQUALS("5,Assuming that condition 'y==32' is not redundant\n"
-                      "4,Compound assignment '+=', before assignment value is 20\n"
-                      "2,Assignment 'x=y', assigned value is 20\n",
-                      getErrorPathForX(code, 3U));
+        code = "struct X { char a; char b; };\n"
+               "void f() {\n"
+               "    x = sizeof(X);\n"
+               "}";
+        values = tokenValues(code, "( X )");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(2, values.back().intvalue);
 
-        code = "void f1(int x) {\n"
-               "  a = x;\n"
-               "}\n"
-               "void f2() {\n"
-               "  int x = 3;\n"
-               "  f1(x+1);\n"
-               "}\n";
-        ASSERT_EQUALS("5,Assignment 'x=3', assigned value is 3\n"
-                      "6,Calling function 'f1', 1st argument 'x+1' value is 4\n",
-                      getErrorPathForX(code, 2U));
+        code = "struct X { char a; float b; };\n"
+               "void f() {\n"
+               "    x = sizeof(X);\n"
+               "}";
+        values = tokenValues(code, "( X )");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(8, values.back().intvalue);
 
-        code = "void f(int a) {\n"
-               "  int x;\n"
-               "  for (x = a; x < 50; x++) {}\n"
+        code = "struct X { char a; char b; float c; };\n"
+               "void f() {\n"
+               "    x = sizeof(X);\n"
+               "}";
+        values = tokenValues(code, "( X )");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(8, values.back().intvalue);
+
+        code = "struct X { float a; char b; };\n"
+               "void f() {\n"
+               "    x = sizeof(X);\n"
+               "}";
+        values = tokenValues(code, "( X )");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(8, values.back().intvalue);
+
+        code = "struct X { float a; char b; char c; };\n"
+               "void f() {\n"
+               "    x = sizeof(X);\n"
+               "}";
+        values = tokenValues(code, "( X )");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(8, values.back().intvalue);
+
+        code = "struct A { float a; char b; };\n"
+               "struct X { A a; char b; };\n"
+               "void f() {\n"
+               "    x = sizeof(X);\n"
+               "}";
+        values = tokenValues(code, "( X )");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(12, values.back().intvalue);
+
+        code = "struct X { A a; int b; A c; };\n"
+               "void f() {\n"
+               "    x = sizeof(X);\n"
+               "}";
+        values = tokenValues(code, "( X )");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(-1, values.back().intvalue);
+
+        code = "struct X {};\n"
+               "struct SubX : X {};\n"
+               "void f() {\n"
+               "    x = sizeof(X);\n"
+               "    subx = sizeof(SubX);\n"
+               "}";
+        values = tokenValues(code, "( X )");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(1, values.back().intvalue);
+        values = tokenValues(code, "( SubX )");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(1, values.back().intvalue);
+
+        code = "struct T;\n"
+               "struct S { T& r; };\n"
+               "struct T { S s{ *this }; };\n"
+               "void f() {\n"
+               "    sizeof(T) == sizeof(void*);\n"
+               "}\n";
+        values = tokenValues(code, "==");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(1LL, values.back().intvalue);
+
+        code = "struct S { int32_t a[2][10] };\n" // #12479
+               "void f() {\n"
+               "    x = sizeof(S);\n"
+               "}\n";
+        values = tokenValues(code, "=");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(4LL * 2 * 10, values.back().intvalue);
+
+        code = "struct S {\n"
+               "    int a[10];\n"
+               "    int b[20];\n"
+               "    int c[30];\n"
+               "};\n"
+               "void f() {\n"
+               "    x = sizeof(S);\n"
+               "}\n";
+        values = tokenValues(code, "=");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(4LL * (10 + 20 + 30), values.back().intvalue);
+
+        code = "struct S {\n"
+               "    char c;\n"
+               "    int a[4];\n"
+               "};\n"
+               "void f() {\n"
+               "    x = sizeof(S);\n"
+               "}\n";
+        values = tokenValues(code, "=");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(4LL * 5, values.back().intvalue);
+
+        // #13734
+        code = "void f() {\n"
+               "    int a[N + 1];"
+               "    x = sizeof(a) / sizeof(a[0]);\n"
+               "}";
+        values = tokenValues(code,"/");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(-1, values.back().intvalue);
+        ASSERT_EQUALS_ENUM(ValueFlow::Value::ValueKind::Impossible, values.back().valueKind);
+
+        code = "struct E;\n"
+               "struct B {\n"
+               "    E* e;\n"
+               "    B* b;\n"
+               "};\n"
+               "struct D : B {};\n"
+               "struct E : B {\n"
+               "	B* be;\n"
+               "};\n"
+               "int f() {\n"
+               "    return sizeof(D);\n"
+               "}";
+        values = tokenValues(code, "( D )");
+        ASSERT_EQUALS(1U, values.size());
+        TODO_ASSERT_EQUALS(2 * settings.platform.sizeof_pointer, 1, values.back().intvalue);
+    }
+
+    void valueFlowComma()
+    {
+        const char* code;
+        std::list<ValueFlow::Value> values;
+
+        code = "void f(int i) {\n"
+               "    int x = (i, 4);\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 3U, 4));
+
+        code = "void f(int i) {\n"
+               "    int x = (4, i);\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 3U, 4));
+
+        code = "void f() {\n"
+               "    int x = g(3, 4);\n"
+               "    return x;\n"
+               "}\n";
+        values = tokenValues(code, ",");
+        ASSERT_EQUALS(0U, values.size());
+    }
+
+    void valueFlowErrorPath() {
+        const char *code;
+
+        code = "void f() {\n"
+               "  int x = 53;\n"
+               "  a = x;\n"
+               "}\n";
+        ASSERT_EQUALS("2,Assignment 'x=53', assigned value is 53\n",
+                      getErrorPathForX(code, 3U));
+
+        code = "void f(int y) {\n"
+               "  int x = y;\n"
+               "  a = x;\n"
+               "  y += 12;\n"
+               "  if (y == 32) {}"
+               "}\n";
+        ASSERT_EQUALS("2,x is assigned 'y' here.\n"
+                      "5,Assuming that condition 'y==32' is not redundant\n"
+                      "4,Compound assignment '+=', assigned value is 20\n"
+                      "2,x is assigned 'y' here.\n",
+                      getErrorPathForX(code, 3U));
+
+        code = "void f1(int x) {\n"
+               "  a = x;\n"
+               "}\n"
+               "void f2() {\n"
+               "  int x = 3;\n"
+               "  f1(x+1);\n"
+               "}\n";
+        ASSERT_EQUALS("5,Assignment 'x=3', assigned value is 3\n"
+                      "6,Calling function 'f1', 1st argument 'x+1' value is 4\n",
+                      getErrorPathForX(code, 2U));
+
+        code = "void f(int a) {\n"
+               "  int x;\n"
+               "  for (x = a; x < 50; x++) {}\n"
                "  b = x;\n"
                "}\n";
-        ASSERT_EQUALS("3,After for loop, x has value 50\n",
+        ASSERT_EQUALS("3,Assuming that condition 'x<50' is not redundant\n"
+                      "3,Assuming that condition 'x<50' is not redundant\n",
                       getErrorPathForX(code, 4U));
     }
 
@@ -1015,7 +1825,7 @@ class TestValueFlow : public TestFixture {
                "    int a = x;\n"
                "    if (x >= 1) {}\n"
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 2U, 1));
+        TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 2U, 1));
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 0));
 
         code = "void f(unsigned int x) {\n"
@@ -1058,6 +1868,8 @@ class TestValueFlow : public TestFixture {
                "  if (x) {}\n"
                "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 5U, 0));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 3U, 1));
+        TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 6U, 0));
     }
 
     void valueFlowBeforeConditionAssignIncDec() {  // assignment / increment
@@ -1087,9 +1899,6 @@ class TestValueFlow : public TestFixture {
                "   if (x == 4);\n"
                "}";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 3));
-        ASSERT_EQUALS("4,Assuming that condition 'x==4' is not redundant\n"
-                      "3,x is incremented, before this increment the value is 3\n",
-                      getErrorPathForX(code, 2U));
 
         // compound assignment += , -= , ...
         code = "void f(int x) {\n"
@@ -1098,6 +1907,7 @@ class TestValueFlow : public TestFixture {
                "   if (x == 4);\n"
                "}";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 2));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 2));
 
         code = "void f(int x) {\n"
                "   a = x;\n"
@@ -1105,6 +1915,7 @@ class TestValueFlow : public TestFixture {
                "   if (x == 4);\n"
                "}";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 6));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 6));
 
         code = "void f(int x) {\n"
                "   a = x;\n"
@@ -1112,21 +1923,24 @@ class TestValueFlow : public TestFixture {
                "   if (x == 42);\n"
                "}";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 21));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 21));
 
         code = "void f(int x) {\n"
                "   a = x;\n"
                "   x /= 5;\n"
                "   if (x == 42);\n"
                "}";
-        ASSERT(tokenValues(code, "x ;").empty());
+        ASSERT_EQUALS(true, testValueOfX(code, 2U, 210));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 210));
 
         // bailout: assignment
         bailout("void f(int x) {\n"
                 "    x = y;\n"
                 "    if (x == 123) {}\n"
                 "}");
-        ASSERT_EQUALS_WITHOUT_LINENUMBERS("[test.cpp:2]: (debug) valueflow.cpp::valueFlowTerminatingCondition bailout: Skipping function due to incomplete variable y\n"
-                                          "[test.cpp:2]: (debug) valueflow.cpp::valueFlowReverse bailout: assignment of x\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:9]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable y [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
     }
 
     void valueFlowBeforeConditionAndAndOrOrGuard() { // guarding by &&
@@ -1180,6 +1994,13 @@ class TestValueFlow : public TestFixture {
                "  if (x) {}\n"
                "}";
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 0));
+
+        code = "void g(int&);"
+               "void f(int x) {\n"
+               "   g(x);\n"
+               "   if (x == 5);\n"
+               "}";
+        ASSERT_EQUALS(false, testValueOfX(code, 2U, 5));
     }
 
     void valueFlowBeforeConditionLoop() { // while, for, do-while
@@ -1233,6 +2054,23 @@ class TestValueFlow : public TestFixture {
                "    }\n"
                "}";
         ASSERT_EQUALS(false, testValueOfX(code, 2U, 0));
+
+        code = "struct S {\n" // #12848
+               "    S* next;\n"
+               "    int a;\n"
+               "};\n"
+               "void f(S* x, int i) {\n"
+               "    while (x) {\n"
+               "        if (x->a == 0) {\n"
+               "            x = x->next;\n"
+               "            continue;\n"
+               "        }\n"
+               "        if (i == 0)\n"
+               "            break;\n"
+               "        x->a = i--;\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 13U, 0));
     }
 
     void valueFlowBeforeConditionTernaryOp() { // bailout: ?:
@@ -1241,14 +2079,14 @@ class TestValueFlow : public TestFixture {
         bailout("void f(int x) {\n"
                 "    y = ((x<0) ? x : ((x==2)?3:4));\n"
                 "}");
-        ASSERT_EQUALS_WITHOUT_LINENUMBERS("[test.cpp:2]: (debug) valueflow.cpp::valueFlowTerminatingCondition bailout: Skipping function due to incomplete variable y\n"
-                                          "[test.cpp:2]: (debug) valueflow.cpp:1113:valueFlowReverse bailout: no simplification of x within ?: expression\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:5]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable y [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
 
         bailout("int f(int x) {\n"
                 "  int r = x ? 1 / x : 0;\n"
                 "  if (x == 0) {}\n"
                 "}");
-        ASSERT_EQUALS_WITHOUT_LINENUMBERS("[test.cpp:2]: (debug) valueflow.cpp:1113:valueFlowReverse bailout: no simplification of x within ?: expression\n", errout.str());
 
         code = "void f(int x) {\n"
                "    int a =v x;\n"
@@ -1306,15 +2144,23 @@ class TestValueFlow : public TestFixture {
                 "    if (x != 123) { b = x; }\n"
                 "    if (x == 123) {}\n"
                 "}");
-        ASSERT_EQUALS_WITHOUT_LINENUMBERS("[test.cpp:2]: (debug) valueflow.cpp::valueFlowTerminatingCondition bailout: Skipping function due to incomplete variable b\n"
-                                          "[test.cpp:2]: (debug) valueflow.cpp:1144:valueFlowReverse bailout: variable x stopping on }\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:21]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable b [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
 
-        code = "void f(int x) {\n"
+        code = "void f(int x, bool abc) {\n"
                "  a = x;\n"
-               "  if (abc) { x = 1; }\n"  // <- condition must be false if x is 7 in next line
+               "  if (abc) { x = 1; }\n" // <- condition must be false if x is 7 in next line
                "  if (x == 7) { }\n"
                "}";
         ASSERT_EQUALS(true, testValueOfX(code, 2U, 7));
+
+        code = "void f(int x, bool abc) {\n"
+               "  a = x;\n"
+               "  if (abc) { x = 7; }\n" // <- condition is probably true
+               "  if (x == 7) { }\n"
+               "}";
+        ASSERT_EQUALS(false, testValueOfX(code, 2U, 7));
     }
 
     void valueFlowBeforeConditionGlobalVariables() {
@@ -1347,8 +2193,9 @@ class TestValueFlow : public TestFixture {
                 "    case 2: if (x==5) {} break;\n"
                 "    };\n"
                 "}");
-        ASSERT_EQUALS_WITHOUT_LINENUMBERS("[test.cpp:3]: (debug) valueflow.cpp::valueFlowTerminatingCondition bailout: Skipping function due to incomplete variable a\n"
-                                          "[test.cpp:3]: (debug) valueflow.cpp:1180:valueFlowReverse bailout: variable x stopping on break\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:13]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable a [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
 
         bailout("void f(int x, int y) {\n"
                 "    switch (y) {\n"
@@ -1356,8 +2203,9 @@ class TestValueFlow : public TestFixture {
                 "    case 2: if (x==5) {} break;\n"
                 "    };\n"
                 "}");
-        ASSERT_EQUALS_WITHOUT_LINENUMBERS("[test.cpp:3]: (debug) valueflow.cpp::valueFlowTerminatingCondition bailout: Skipping function due to incomplete variable a\n"
-                                          "[test.cpp:3]: (debug) valueflow.cpp:1180:valueFlowReverse bailout: variable x stopping on return\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3:13]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable a [valueFlowBailoutIncompleteVar]\n",
+            errout_str());
     }
 
     void valueFlowBeforeConditionMacro() {
@@ -1367,16 +2215,22 @@ class TestValueFlow : public TestFixture {
                 "    a = x;\n"
                 "    M;\n"
                 "}");
-        ASSERT_EQUALS_WITHOUT_LINENUMBERS("[test.cpp:3]: (debug) valueflow.cpp::valueFlowTerminatingCondition bailout: Skipping function due to incomplete variable a\n"
-                                          "[test.cpp:4]: (debug) valueflow.cpp:1260:valueFlowBeforeCondition bailout: variable x, condition is defined in macro\n", errout.str());
+        ASSERT_EQUALS_WITHOUT_LINENUMBERS(
+            "[test.cpp:3]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable a\n"
+            "[test.cpp:4]: (debug) valueflow.cpp:1260:(valueFlow) bailout: variable 'x', condition is defined in macro\n"
+            "[test.cpp:4]: (debug) valueflow.cpp:1260:(valueFlow) bailout: variable 'x', condition is defined in macro\n", // duplicate
+            errout_str());
 
         bailout("#define FREE(obj) ((obj) ? (free((char *) (obj)), (obj) = 0) : 0)\n" // #8349
                 "void f(int *x) {\n"
                 "    a = x;\n"
                 "    FREE(x);\n"
                 "}");
-        ASSERT_EQUALS_WITHOUT_LINENUMBERS("[test.cpp:3]: (debug) valueflow.cpp::valueFlowTerminatingCondition bailout: Skipping function due to incomplete variable a\n"
-                                          "[test.cpp:4]: (debug) valueflow.cpp:1260:valueFlowBeforeCondition bailout: variable x, condition is defined in macro\n", errout.str());
+        ASSERT_EQUALS_WITHOUT_LINENUMBERS(
+            "[test.cpp:3]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable a\n"
+            "[test.cpp:4]: (debug) valueflow.cpp:1260:(valueFlow) bailout: variable 'x', condition is defined in macro\n"
+            "[test.cpp:4]: (debug) valueflow.cpp:1260:(valueFlow) bailout: variable 'x', condition is defined in macro\n", // duplicate
+            errout_str());
     }
 
     void valueFlowBeforeConditionGoto() {
@@ -1388,10 +2242,10 @@ class TestValueFlow : public TestFixture {
                 "    if (x==123){}\n"
                 "}");
         ASSERT_EQUALS_WITHOUT_LINENUMBERS(
-            "[test.cpp:3]: (debug) valueflow.cpp::valueFlowTerminatingCondition bailout: Skipping function due to incomplete variable a\n"
-            "[test.cpp:4]: (debug) valueflow.cpp:1131:valueFlowReverse bailout: variable x stopping on goto label\n"
-            "[test.cpp:2]: (debug) valueflow.cpp:1813:valueFlowForwardVariable bailout: variable x. noreturn conditional scope.\n",
-            errout.str());
+            "[test.cpp:3]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable a\n"
+            "[test.cpp:2]: (debug) valueflow.cpp::(valueFlow) bailout: valueFlowAfterCondition: bailing in conditional block\n"
+            "[test.cpp:2]: (debug) valueflow.cpp::(valueFlow) bailout: valueFlowAfterCondition: bailing in conditional block\n", // duplicate
+            errout_str());
 
         // #5721 - FP
         bailout("static void f(int rc) {\n"
@@ -1403,16 +2257,14 @@ class TestValueFlow : public TestFixture {
                 "\n"
                 "out:\n"
                 "    if (abc) {}\n"
-                "}\n");
+                "}");
         ASSERT_EQUALS_WITHOUT_LINENUMBERS(
-            "[test.cpp:2]: (debug) valueflow.cpp:1035:valueFlowReverse bailout: assignment of abc\n"
-            "[test.cpp:8]: (debug) valueflow.cpp:1131:valueFlowReverse bailout: variable abc stopping on goto label\n"
-            "[test.cpp:3]: (debug) valueflow.cpp:1813:valueFlowForwardVariable bailout: variable abc. noreturn conditional scope.\n",
-            errout.str());
+            "[test.cpp:3]: (debug) valueflow.cpp:6730:(valueFlow) bailout: valueFlowAfterCondition: bailing in conditional block\n"
+            "[test.cpp:3]: (debug) valueflow.cpp:6730:(valueFlow) bailout: valueFlowAfterCondition: bailing in conditional block\n", // duplicate
+            errout_str());
     }
 
-    void valueFlowBeforeConditionForward()
-    {
+    void valueFlowBeforeConditionForward() {
         const char* code;
 
         code = "void f(int a) {\n"
@@ -1430,6 +2282,30 @@ class TestValueFlow : public TestFixture {
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 123));
     }
 
+    void valueFlowBeforeConditionConstructor()
+    {
+        const char* code;
+
+        code = "struct Fred {\n"
+               "    Fred(int *x)\n"
+               "      : i(*x) {\n"    // <- dereference x
+               "        if (!x) {}\n" // <- check x
+               "    }\n"
+               "    int i;\n"
+               "};\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
+
+        code = "struct Fred {\n"
+               "    Fred(int *x)\n"
+               "      : i(*x), j(0) {\n" // <- dereference x
+               "        if (!x) {}\n"    // <- check x
+               "    }\n"
+               "    int i;\n"
+               "    int j;\n"
+               "};\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
+    }
+
     void valueFlowAfterAssign() {
         const char *code;
 
@@ -1457,6 +2333,12 @@ class TestValueFlow : public TestFixture {
                "}";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 123));
 
+        code = "void f() {\n"
+               "    const int x(321);\n"
+               "    a = x;\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 321));
+
         code = "void f() {\n"
                "    int x = 9;\n"
                "    --x;\n"
@@ -1580,7 +2462,7 @@ class TestValueFlow : public TestFixture {
                "    a = ((x[0] == 'U') ?\n"
                "        x[1] : 0);\n" // <- x is not ""
                "}";
-        ASSERT_EQUALS(false, testValueOfX(code, 4U, "\"\"", ValueFlow::Value::TOK));
+        ASSERT_EQUALS(false, testValueOfX(code, 4U, "\"\"", ValueFlow::Value::ValueType::TOK));
 
         code = "void f() {\n" // #6973
                "    char *x = getenv (\"LC_ALL\");\n"
@@ -1593,10 +2475,10 @@ class TestValueFlow : public TestFixture {
                "          x[2] ))\n"          // x can't be ""
                "    {}\n"
                "}\n";
-        ASSERT_EQUALS(true, testValueOfX(code, 6U, "\"\"", ValueFlow::Value::TOK));
-        ASSERT_EQUALS(false, testValueOfX(code, 7U, "\"\"", ValueFlow::Value::TOK));
-        ASSERT_EQUALS(false, testValueOfX(code, 8U, "\"\"", ValueFlow::Value::TOK));
-        ASSERT_EQUALS(false, testValueOfX(code, 9U, "\"\"", ValueFlow::Value::TOK));
+        ASSERT_EQUALS(true, testValueOfX(code, 6U, "\"\"", ValueFlow::Value::ValueType::TOK));
+        ASSERT_EQUALS(false, testValueOfX(code, 7U, "\"\"", ValueFlow::Value::ValueType::TOK));
+        ASSERT_EQUALS(false, testValueOfX(code, 8U, "\"\"", ValueFlow::Value::ValueType::TOK));
+        ASSERT_EQUALS(false, testValueOfX(code, 9U, "\"\"", ValueFlow::Value::ValueType::TOK));
 
         code = "void f() {\n" // #7599
                "  t *x = 0;\n"
@@ -1636,7 +2518,7 @@ class TestValueFlow : public TestFixture {
                "    if (condition2) x = 789;\n"
                "    a = 2 + x;\n" // <- either assignment "x=123" is redundant or x can be 123 here.
                "}";
-        ASSERT_EQUALS(true,  testValueOfX(code, 5U, 123));
+        TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 5U, 123));
 
         code = "void f(int a) {\n"
                "    int x = 123;\n"
@@ -1646,7 +2528,7 @@ class TestValueFlow : public TestFixture {
                "        ++x;\n"
                "    return 2 + x;\n"
                "}";
-        ASSERT_EQUALS(false, testValueOfX(code, 4U, 123));
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 123));
 
         code = "void f() {\n"
                "    int x = 1;\n"
@@ -1780,7 +2662,7 @@ class TestValueFlow : public TestFixture {
                "    y = 42 / x;\n" // <- x is 2
                "}";
         ASSERT_EQUALS(false, testValueOfX(code, 5U, 0));
-        TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 5U, 2));
+        ASSERT_EQUALS(true, testValueOfX(code, 5U, 2));
 
         code = "void f(int mode) {\n"
                "    struct ABC *x;\n"
@@ -1809,7 +2691,7 @@ class TestValueFlow : public TestFixture {
                "        else if (x && i == 1) {}\n"
                "    }\n"
                "}\n";
-        ASSERT_EQUALS(false, testValueOfX(code, 6U, 0));
+        ASSERT_EQUALS(true, testValueOfX(code, 6U, 0));
 
         // multivariables
         code = "void f(int a) {\n"
@@ -1868,6 +2750,7 @@ class TestValueFlow : public TestFixture {
                "  } while (1);\n"
                "}";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 3));
 
         // pointer/reference to x
         code = "int f(void) {\n"
@@ -1972,9 +2855,25 @@ class TestValueFlow : public TestFixture {
                "  }\n"
                "  a = x;\n" // <- x can't be 0
                "}\n";
-        ASSERT_EQUALS(false, testValueOfX(code, 9U, 0)); // x can't be 0 at line 9
+        ASSERT_EQUALS(true, testValueOfX(code, 9U, 0));       // x can be 0 at line 9
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 9U, 0)); // x can't be known at line 9
+
+        code = "void f(const int *buf) {\n"
+               "  int x = 0;\n"
+               "  for (int i = 0; i < 10; i++) {\n"
+               "    if (buf[i] == 123) {\n"
+               "      x = i;\n"
+               "      ;\n" // <- no break
+               "    } else {\n"
+               "      x = 1;\n"
+               "    }\n"
+               "  }\n"
+               "  a = x;\n" // <- x can't be 0
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 11U, 0)); // x can't be 0 at line 11
 
         code = "void f(const int *buf) {\n"
+               "  int i = 0;\n"
                "  int x = 0;\n"
                "  while (++i < 10) {\n"
                "    if (buf[i] == 123) {\n"
@@ -1984,7 +2883,66 @@ class TestValueFlow : public TestFixture {
                "  }\n"
                "  a = x;\n" // <- x can be 0
                "}\n";
-        ASSERT_EQUALS(true, testValueOfX(code, 9U, 0)); // x can be 0 at line 9
+        ASSERT_EQUALS(true, testValueOfX(code, 10U, 0)); // x can be 0 at line 9
+
+        code = "bool maybe();\n"
+               "void f() {\n"
+               "  int x = 0;\n"
+               "  bool found = false;\n"
+               "  while(!found) {\n"
+               "    if (maybe()) {\n"
+               "      x = i;\n"
+               "      found = true;\n"
+               "    }\n"
+               "  }\n"
+               "  a = x;\n" // <- x can't be 0
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 11U, 0));
+
+        code = "bool maybe();\n"
+               "void f() {\n"
+               "  int x = 0;\n"
+               "  bool found = false;\n"
+               "  while(!found) {\n"
+               "    if (maybe()) {\n"
+               "      x = i;\n"
+               "      found = true;\n"
+               "    } else {\n"
+               "      found = false;\n"
+               "    }\n"
+               "  }\n"
+               "  a = x;\n" // <- x can't be 0
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 13U, 0));
+
+        code = "bool maybe();\n"
+               "void f() {\n"
+               "  int x = 0;\n"
+               "  bool found = false;\n"
+               "  while(!found) {\n"
+               "    if (maybe()) {\n"
+               "      x = i;\n"
+               "      break;\n"
+               "    }\n"
+               "  }\n"
+               "  a = x;\n" // <- x can't be 0
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 11U, 0));
+
+        code = "bool maybe();\n"
+               "void f() {\n"
+               "  int x = 0;\n"
+               "  bool found = false;\n"
+               "  while(!found) {\n"
+               "    if (maybe()) {\n"
+               "      x = i;\n"
+               "      found = true;\n"
+               "      break;\n"
+               "    }\n"
+               "  }\n"
+               "  a = x;\n" // <- x can't be 0
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 12U, 0));
 
         code = "void f(const int a[]) {\n" // #6616
                "  const int *x = 0;\n"
@@ -2004,52 +2962,247 @@ class TestValueFlow : public TestFixture {
                "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 6U, 3));
         TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 6U, 2));
-    }
 
-    void valueFlowAfterCondition() {
-        const char *code;
-        // in if
-        code = "void f(int x) {\n"
-               "    if (x == 123) {\n"
-               "        a = x;\n"
-               "    }\n"
-               "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 3U, 123));
+        code = "struct Fred {\n"
+               "    static void Create(std::unique_ptr<Wilma> wilma);\n"
+               "    Fred(std::unique_ptr<Wilma> wilma);\n"
+               "    std::unique_ptr<Wilma> mWilma;\n"
+               "};\n"
+               "void Fred::Create(std::unique_ptr<Wilma> wilma) {\n"
+               "    auto fred = std::make_shared<Fred>(std::move(wilma));\n"
+               "    fred->mWilma.reset();\n"
+               "}\n"
+               "Fred::Fred(std::unique_ptr<Wilma> wilma)\n"
+               "    : mWilma(std::move(wilma)) {}\n";
+        ASSERT_EQUALS(0, tokenValues(code, "mWilma (").size());
 
-        code = "void f(int x) {\n"
-               "    if (x != 123) {\n"
-               "        a = x;\n"
-               "    }\n"
-               "}";
-        ASSERT_EQUALS(false, testValueOfX(code, 3U, 123));
+        code = "void g(unknown*);\n"
+               "int f() {\n"
+               "    int a = 1;\n"
+               "    unknown c[] = {{&a}};\n"
+               "    g(c);\n"
+               "    int x = a;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 7U, 1));
+        ASSERT_EQUALS(true, testValueOfXInconclusive(code, 7U, 1));
 
-        code = "void f(int x) {\n"
-               "    if (x > 123) {\n"
-               "        a = x;\n"
-               "    }\n"
-               "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 3U, 124));
-        ASSERT_EQUALS(false, testValueOfX(code, 3U, 123));
+        code = "void g(unknown&);\n"
+               "int f() {\n"
+               "    int a = 1;\n"
+               "    unknown c{&a};\n"
+               "    g(c);\n"
+               "    int x = a;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 7U, 1));
+        ASSERT_EQUALS(true, testValueOfXInconclusive(code, 7U, 1));
+
+        code = "long foo();\n"
+               "long bar();\n"
+               "int test() {\n"
+               "  bool b = true;\n"
+               "  long a = foo();\n"
+               "  if (a != 0)\n"
+               "    return 1;\n"
+               "  a = bar();\n"
+               "  if (a != 0)\n"
+               "    b = false;\n"
+               "  int x = b;\n"
+               "  return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 12U, 0));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 12U, 0));
 
-        code = "void f(int x) {\n"
-               "    if (x < 123) {\n"
-               "        a = x;\n"
+        code = "bool f(unsigned char uc) {\n"
+               "  const bool x = uc;\n"
+               "  return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, -1));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 3U, 1));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 3U, 0));
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 3U, 0));
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 3U, 1));
+
+        code = "struct A {\n"
+               "    int i, j;\n"
+               "    int foo() {\n"
+               "        i = 1;\n"
+               "        j = 2;\n"
+               "        int x = i;\n"
+               "        return x;\n"
                "    }\n"
-               "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 3U, 122));
-        ASSERT_EQUALS(false, testValueOfX(code, 3U, 123));
+               "};\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 7U, 1));
 
-        // ----
+        // global variable
+        code = "int x;\n"
+               "int foo(int y) {\n"
+               "  if (y)\n"
+               "    x = 10;\n"
+               "  return x;\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfX(code, 5U, 10));
 
-        code = "void f(int x) {\n"
-               "    if (123 < x) {\n"
-               "        a = x;\n"
-               "    }\n"
+        code = "namespace A { int x; }\n"
+               "int foo(int y) {\n"
+               "  if (y)\n"
+               "    A::x = 10;\n"
+               "  return A::x;\n"
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 3U, 124));
-        ASSERT_EQUALS(false, testValueOfX(code, 3U, 123));
+        ASSERT_EQUALS(true, testValueOfX(code, 5U, 10));
 
-        code = "void f(int x) {\n"
+        // member variable
+        code = "struct Fred {\n"
+               "  int x;\n"
+               "  int foo(int y) {\n"
+               "    if (y)\n"
+               "      x = 10;\n"
+               "    return x;\n"
+               "  }\n"
+               "};";
+        ASSERT_EQUALS(true, testValueOfX(code, 6U, 10));
+
+        code = "void f(int i) {\n"
+               "    if (i == 3) {}\n"
+               "    for(int x = i;\n"
+               "        x;\n"
+               "        x++) {}\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 3));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 4U, 3));
+
+        code = "void f() {\n"
+               "    for(int x = 3;\n"
+               "        x;\n"
+               "        x++) {}\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 3));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 4U, 3));
+
+        code = "void f() {\n"
+               "    constexpr int x(123);\n"
+               "    constexpr int y(x*x);\n"
+               "    return x;\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 123));
+
+        code = "void f() {\n"
+               "    static const int x(123);\n"
+               "    static const int y(x*x);\n"
+               "    return x;\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 123));
+
+        code = "void f() {\n"
+               "    static int x(123);\n"
+               "    static int y(x*x);\n"
+               "    return x;\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 123));
+
+        code = "bool f() {\n" // #13208
+               "    struct S {\n"
+               "        bool b = true;\n"
+               "        bool get() const { return b; }\n"
+               "    };\n"
+               "    S s;\n"
+               "    s.b = false;\n"
+               "    bool x = s.get();\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 9U, 1));
+    }
+
+    void valueFlowAfterSwap()
+    {
+        const char* code;
+
+        code = "int f() {\n"
+               "    int a = 1;\n"
+               "    int b = 2;\n"
+               "    std::swap(a, b);\n"
+               "    int x = a;\n"
+               "    return x;\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 6U, 2));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 6U, 1));
+
+        code = "int f() {\n"
+               "    int a = 1;\n"
+               "    int b = 2;\n"
+               "    std::swap(a, b);\n"
+               "    int x = b;\n"
+               "    return x;\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 6U, 1));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 6U, 2));
+
+        code = "int f() {\n"
+               "    std::string a;\n"
+               "    std::string b=\"42\";\n"
+               "    std::swap(b, a);\n"
+               "    int x = b.size();\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 6U, 0));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 6U, 2));
+
+        code = "int f() {\n"
+               "    std::string a;\n"
+               "    std::string b=\"42\";\n"
+               "    std::swap(b, a);\n"
+               "    int x = a.size();\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 6U, 2));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 6U, 0));
+    }
+
+    void valueFlowAfterCondition() {
+        const char *code;
+        // in if
+        code = "void f(int x) {\n"
+               "    if (x == 123) {\n"
+               "        a = x;\n"
+               "    }\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 123));
+
+        code = "void f(int x) {\n"
+               "    if (x != 123) {\n"
+               "        a = x;\n"
+               "    }\n"
+               "}";
+        ASSERT_EQUALS(false, testValueOfX(code, 3U, 123));
+
+        code = "void f(int x) {\n"
+               "    if (x > 123) {\n"
+               "        a = x;\n"
+               "    }\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 124));
+        ASSERT_EQUALS(false, testValueOfX(code, 3U, 123));
+
+        code = "void f(int x) {\n"
+               "    if (x < 123) {\n"
+               "        a = x;\n"
+               "    }\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 122));
+        ASSERT_EQUALS(false, testValueOfX(code, 3U, 123));
+
+        // ----
+
+        code = "void f(int x) {\n"
+               "    if (123 < x) {\n"
+               "        a = x;\n"
+               "    }\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 124));
+        ASSERT_EQUALS(false, testValueOfX(code, 3U, 123));
+
+        code = "void f(int x) {\n"
                "    if (123 > x) {\n"
                "        a = x;\n"
                "    }\n"
@@ -2100,20 +3253,20 @@ class TestValueFlow : public TestFixture {
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 0));
 
         code = "void f(int x) {\n"
-               "    if (x != 123) { throw ""; }\n"
+               "    if (x != 123) { throw " "; }\n"
                "    a = x;\n"
                "}";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 123));
 
         code = "void f(int x) {\n"
                "    if (x != 123) { }\n"
-               "    else { throw ""; }\n"
+               "    else { throw " "; }\n"
                "    a = x;\n"
                "}";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 123));
         code = "void f(int x) {\n"
                "    if (x == 123) { }\n"
-               "    else { throw ""; }\n"
+               "    else { throw " "; }\n"
                "    a = x;\n"
                "}";
         ASSERT_EQUALS(true, testValueOfX(code, 4U, 123));
@@ -2194,7 +3347,7 @@ class TestValueFlow : public TestFixture {
                "    while (11 != (x = dostuff()) && y) {}\n"
                "    a = x;\n"
                "}";
-        TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 3U, 11));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 11));
 
         code = "void f(int x) {\n"
                "    while (x = dostuff()) {}\n"
@@ -2269,15 +3422,15 @@ class TestValueFlow : public TestFixture {
         // protected usage with &&
         code = "void f(const Token* x) {\n"
                "    if (x) {}\n"
-               "    for (; x && \n"
+               "    for (; x &&\n"
                "         x->str() != y; x = x->next()) {}\n"
                "}";
-        TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 3U, 0));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
 
         code = "void f(const Token* x) {\n"
                "    if (x) {}\n"
-               "    if (x && \n"
+               "    if (x &&\n"
                "        x->str() != y) {}\n"
                "}";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
@@ -2327,6 +3480,306 @@ class TestValueFlow : public TestFixture {
                "}\n";
         ASSERT_EQUALS(false, testValueOfXKnown(code, 6U, 0));
         ASSERT_EQUALS(true, testValueOfX(code, 6U, 0));
+
+        // volatile variable
+        code = "void foo(const volatile int &x) {\n"
+               "    if (x==1) {\n"
+               "        return x;\n"
+               "    }"
+               "}";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 3U, 1));
+
+        code = "void foo(const std::atomic<int> &x) {\n"
+               "    if (x==2) {\n"
+               "        return x;\n"
+               "    }"
+               "}";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 3U, 2));
+
+        code = "int f(int i, int j) {\n"
+               "    if (i == 0) {\n"
+               "        if (j < 0)\n"
+               "            return 0;\n"
+               "        i = j+1;\n"
+               "    }\n"
+               "    int x = i;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 8U, 0));
+
+        code = "int f(int i, int j) {\n"
+               "    if (i == 0) {\n"
+               "        if (j < 0)\n"
+               "            return 0;\n"
+               "        if (j < 0)\n"
+               "            i = j+1;\n"
+               "    }\n"
+               "    int x = i;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 9U, 0));
+
+        code = "void g(long& a);\n"
+               "void f(long a) {\n"
+               "    if (a == 0)\n"
+               "        return;\n"
+               "    if (a > 1)\n"
+               "         g(a);\n"
+               "    int x = a;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 8U, 0));
+
+        code = "int foo(int n) {\n"
+               "    if( n>= 8 ) {\n"
+               "        while(true) {\n"
+               "            n -= 8;\n"
+               "            if( n < 8 )\n"
+               "                break;\n"
+               "        }\n"
+               "        int x = n == 0;\n"
+               "        return x;\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 9U, 0));
+
+        code = "bool c();\n"
+               "long f() {\n"
+               "    bool stop = false;\n"
+               "    while (!stop) {\n"
+               "        if (c())\n"
+               "            stop = true;\n"
+               "        break;\n"
+               "    }\n"
+               "    int x = !stop;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 10U, 1));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 10U, 0));
+
+        code = "int f(int a, int b) {\n"
+               "  if (!a && !b)\n"
+               "    return;\n"
+               "  if ((!a && b) || (a && !b))\n"
+               "    return;\n"
+               "  int x = a;\n" // <- a is _not_ 0
+               "  return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 7U, 0));
+
+        code = "void f(int x, int y) {\n"
+               "    if (x && y)\n"
+               "        return;\n"
+               "    int a = x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 0));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 4U, 0));
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 4U, 1));
+
+        code = "int f(std::vector<int> a, std::vector<int> b) {\n"
+               "    if (a.empty() && b.empty())\n"
+               "        return 0;\n"
+               "    bool x = a.empty() && !b.empty();\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 5U, 0));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 5U, 1));
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 5U, 0));
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 5U, 1));
+
+        code = "auto f(int i) {\n"
+               "    if (i == 0) return;\n"
+               "    auto x = !i;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 0));
+
+        code = "auto f(int i) {\n"
+               "    if (i == 1) return;\n"
+               "    auto x = !i;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 4U, 0));
+
+        code = "int g(int x) {\n"
+               "    switch (x) {\n"
+               "    case 1:\n"
+               "        return 1;\n"
+               "    default:\n"
+               "        return 2;\n"
+               "    }\n"
+               "}\n"
+               "void f(int x) {\n"
+               "    if (x == 3)\n"
+               "        x = g(0);\n"
+               "    int a = x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 12U, 3));
+
+        code = "long long f(const long long& x, const long long& y) {\n"
+               "    switch (s) {\n"
+               "    case 0:\n"
+               "        if (x >= 64)\n"
+               "            return 0;\n"
+               "        return (long long)y << (long long)x;\n"
+               "    case 1:\n"
+               "        if (x >= 64) {\n"
+               "        }\n"
+               "    }\n"
+               "    return 0; \n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 6U, 63));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 6U, 64));
+
+        code = "long long f(const long long& x, const long long& y) {\n"
+               "    switch (s) {\n"
+               "    case 0:\n"
+               "        if (x >= 64)\n"
+               "            return 0;\n"
+               "        return long long(y) << long long(x);\n"
+               "    case 1:\n"
+               "        if (x >= 64) {\n"
+               "        }\n"
+               "    }\n"
+               "    return 0; \n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 6U, 63));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 6U, 64));
+
+        code = "long long f(const long long& x, const long long& y) {\n"
+               "    switch (s) {\n"
+               "    case 0:\n"
+               "        if (x >= 64)\n"
+               "            return 0;\n"
+               "        return long long{y} << long long{x};\n"
+               "    case 1:\n"
+               "        if (x >= 64) {\n"
+               "        }\n"
+               "    }\n"
+               "    return 0; \n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 6U, 63));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 6U, 64));
+
+        code = "int g(int x) { throw 0; }\n"
+               "void f(int x) {\n"
+               "    if (x == 3)\n"
+               "        x = g(0);\n"
+               "    int a = x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 5U, 3));
+
+        code = "struct a {\n"
+               "  a *b() const;\n"
+               "  void c();\n"
+               "};\n"
+               "void e(a *x) {\n"
+               "  while (x && x->b())\n"
+               "    x = x->b();\n"
+               "  x->c();\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 8U, 0));
+
+        code = "struct a {\n"
+               "  a *b();\n"
+               "  void c();\n"
+               "};\n"
+               "void e(a *x) {\n"
+               "  while (x && x->b())\n"
+               "    x = x->b();\n"
+               "  x->c();\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 8U, 0));
+
+        code = "constexpr int f();\n"
+               "int g() {\n"
+               "    if (f() == 1) {\n"
+               "        int x = f();\n"
+               "        return x;\n"
+               "    }\n"
+               "    return 0;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 5U, 1));
+
+        code = "int f(int x) {\n"
+               "    if (x == 1) {\n"
+               "        for(int i=0;i<1;i++) {\n"
+               "            if (x == 1)\n"
+               "                continue;\n"
+               "        }\n"
+               "    }\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 8U, 1));
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 8U, 1));
+
+        code = "void g(int i) {\n"
+               "    if (i == 1)\n"
+               "        return;\n"
+               "    abort();\n"
+               "}\n"
+               "int f(int x) {\n"
+               "    if (x != 0)\n"
+               "        g(x);\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 9U, 0));
+        ASSERT_EQUALS(true, testValueOfX(code, 9U, 0));
+
+        code = "int f(int a, int b) {\n"
+               "    if (a > 0 && b > 0) {}\n"
+               "    int x = a * b;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 0));
+    }
+
+    void valueFlowAfterConditionTernary()
+    {
+        const char* code;
+
+        code = "auto f(int x) {\n"
+               "    return x == 3 ?\n"
+               "        x :\n"
+               "        0;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 3));
+
+        code = "auto f(int x) {\n"
+               "    return x != 3 ?\n"
+               "        0 :\n"
+               "        x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 3));
+
+        code = "auto f(int x) {\n"
+               "    return !(x == 3) ?\n"
+               "        0 :\n"
+               "        x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 3));
+
+        code = "auto f(int* x) {\n"
+               "    return x ?\n"
+               "        x :\n"
+               "        0;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 3U, 0));
+
+        code = "auto f(int* x) {\n"
+               "    return x ?\n"
+               "        0 :\n"
+               "        x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 0));
+
+        code = "bool g(int);\n"
+               "auto f(int* x) {\n"
+               "    if (!g(x ?\n"
+               "        *x :\n"
+               "        0)) {}\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
     }
 
     void valueFlowAfterConditionExpr() {
@@ -2382,6 +3835,49 @@ class TestValueFlow : public TestFixture {
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 123));
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 124));
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 125));
+
+        code = "struct A {\n"
+               "    bool g() const;\n"
+               "};\n"
+               "void f(A a) {\n"
+               "    if (a.g()) {\n"
+               "        bool x = a.g();\n"
+               "        bool a = x;\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 7U, 0));
+
+        code = "struct A {\n"
+               "    bool g() const;\n"
+               "};\n"
+               "void f(A a) {\n"
+               "    if (a.g()) {\n"
+               "        bool x = !a.g();\n"
+               "        bool a = x;\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 7U, 0));
+
+        code = "struct A {\n"
+               "    bool g() const;\n"
+               "};\n"
+               "void f(A a) {\n"
+               "    if (!a.g()) {\n"
+               "        bool x = a.g();\n"
+               "        bool a = x;\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 7U, 0));
+
+        code = "void f(std::vector<int> v) {\n"
+               "    if (v.size() == 3) {\n"
+               "        if (v.size() == 1) {\n"
+               "            int x = 1;\n"
+               "            int a = x;\n"
+               "        }\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 5U, 1));
     }
 
     void valueFlowAfterConditionSeveralNot() {
@@ -2418,7 +3914,7 @@ class TestValueFlow : public TestFixture {
     void valueFlowForwardCompoundAssign() {
         const char *code;
 
-        code = "void f() {\n"
+        code = "int f() {\n"
                "    int x = 123;\n"
                "    x += 43;\n"
                "    return x;\n"
@@ -2428,19 +3924,40 @@ class TestValueFlow : public TestFixture {
                       "3,Compound assignment '+=', assigned value is 166\n",
                       getErrorPathForX(code, 4U));
 
-        code = "void f() {\n"
+        code = "int f() {\n"
                "    int x = 123;\n"
                "    x /= 0;\n" // don't crash when evaluating x/=0
                "    return x;\n"
                "}";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 123));
 
-        code = "void f() {\n"
-               "    float x = 123.45;\n"
+        code = "float f() {\n"
+               "    float x = 123.45f;\n"
+               "    x += 67;\n"
+               "    return x;\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, static_cast<double>(123.45f) + 67, 0.01));
+
+        code = "double f() {\n"
+               "    double x = 123.45;\n"
                "    x += 67;\n"
                "    return x;\n"
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 4U, 123.45F + 67, 0.01F));
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 123.45 + 67, 0.01));
+
+        code = "void f() {\n"
+               "    int x = 123;\n"
+               "    x >>= 1;\n"
+               "    return x;\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 61));
+
+        code = "int f() {\n"
+               "    int x = 123;\n"
+               "    x <<= 1;\n"
+               "    return x;\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 246));
     }
 
     void valueFlowForwardCorrelatedVariables() {
@@ -2453,6 +3970,20 @@ class TestValueFlow : public TestFixture {
                "}";
         ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
+
+        code = "int g();\n"
+               "int f(bool i, bool j) {\n"
+               "    if (i && j) {}\n"
+               "    else {\n"
+               "        int x = 0;\n"
+               "        if (i)\n"
+               "            x = g();\n"
+               "        return x;\n"
+               "    }\n"
+               "    return 0;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 8U, 0));
+        ASSERT_EQUALS(true, testValueOfX(code, 8U, 0));
     }
 
     void valueFlowForwardModifiedVariables() {
@@ -2467,9 +3998,9 @@ class TestValueFlow : public TestFixture {
 
         code = "void f(int i) {\n"
                "    int x = 0;\n"
-               "    if (i == 0) \n"
+               "    if (i == 0)\n"
                "        x = 1;\n"
-               "    else if (!x && i == 1) \n"
+               "    else if (!x && i == 1)\n"
                "        int b = x;\n"
                "}\n";
         ASSERT_EQUALS(true, testValueOfXKnown(code, 5U, 0));
@@ -2509,10 +4040,22 @@ class TestValueFlow : public TestFixture {
                "  if (x == 42) {}\n"
                "}";
         ASSERT_EQUALS(false, testValueOfX(code, 6U, 11));
-    }
-
-    void valueFlowForwardTernary() {
-        const char *code;
+
+        code = "void f() {\n"
+               "    int x = 1;\n"
+               "    exit(x);\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 3U, 1));
+
+        code = "void f(jmp_buf env) {\n"
+               "    int x = 1;\n"
+               "    longjmp(env, x);\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 3U, 1));
+    }
+
+    void valueFlowForwardTernary() {
+        const char *code;
 
         code = "int f() {\n"
                "  int x=5;\n"
@@ -2526,7 +4069,23 @@ class TestValueFlow : public TestFixture {
                "  if (p) return;\n"
                "  x = *p ? : 1;\n" // <- no explicit expr0
                "}";
-        testValueOfX(code, 1U, 0); // do not crash
+        (void)testValueOfX(code, 1U, 0); // do not crash
+
+        code = "void f(int a) {\n" // #8784
+               "    int x = 13;\n"
+               "    if (a == 1) x = 26;\n"
+               "    return a == 1 ? x : 0;\n"  // <- x is 26
+               "}";
+        ASSERT_EQUALS(false, testValueOfX(code, 4U, 13));
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 26));
+
+        code = "void f(int* i) {\n"
+               "    if (!i) return;\n"
+               "    int * x = *i == 1 ? i : nullptr;\n"
+               "    int* a = x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 0));
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 4U, 0));
     }
 
     void valueFlowForwardLambda() {
@@ -2547,6 +4106,50 @@ class TestValueFlow : public TestFixture {
                "  f();\n"
                "}";
         TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 3U, 3));
+
+        code = "void f() {\n"
+               "  int x=3;\n"
+               "  auto f = [&](){ x++; }\n"
+               "  x = 1;\n"
+               "  f();\n"
+               "  int a = x;\n" // x is actually 2
+               "}";
+        ASSERT_EQUALS(false, testValueOfX(code, 6U, 1));
+        ASSERT_EQUALS(false, testValueOfX(code, 6U, 3));
+    }
+
+    void valueFlowForwardTryCatch() {
+        const char *code;
+
+        code = "void g1();\n"
+               "void g2();\n"
+               "void f()\n {"
+               "    bool x = false;\n"
+               "    try {\n"
+               "        g1();\n"
+               "        x = true;\n"
+               "        g2();\n"
+               "    }\n"
+               "    catch (...) {\n"
+               "        if (x) {}\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 11U, 1));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 11U, 1));
+
+        code = "void g1();\n"
+               "void g2();\n"
+               "void f()\n {"
+               "    bool x = true;\n"
+               "    try {\n"
+               "        g1();\n"
+               "        g2();\n"
+               "    }\n"
+               "    catch (...) {\n"
+               "        if (x) {}\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 10U, 1));
     }
 
     void valueFlowBitAnd() {
@@ -2574,25 +4177,143 @@ class TestValueFlow : public TestFixture {
         ASSERT_EQUALS(false, testValueOfX(code,3U,16));
     }
 
+    void valueFlowForwardInconclusiveImpossible() {
+        const char *code;
+
+        code = "void foo() {\n"
+               "    bool valid = f1();\n"
+               "    if (!valid) return;\n"
+               "    std::tie(endVal, valid) = f2();\n"
+               "    bool x = !valid;"
+               "    bool b = x;" // <- not always true
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 6U, 1));
+    }
+
+    void valueFlowForwardConst()
+    {
+        const char* code;
+
+        code = "int f() {\n"
+               "    const int i = 2;\n"
+               "    const int x = i+1;\n"
+               "    goto end;\n"
+               "end:\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 6U, 3));
+
+        code = "int f() {\n"
+               "    int i = 2;\n"
+               "    const int& x = i;\n"
+               "    i++;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 6U, 2));
+
+        code = "int f(int a, int b, int c) {\n"
+               "    const int i = 2;\n"
+               "    const int x = i+1;\n"
+               "    if (a == x) { return 0; }\n"
+               "    if (b == x) { return 0; }\n"
+               "    if (c == x) { return 0; }\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 7U, 3));
+
+        code = "int f(int a, int b, int c) {\n"
+               "    const int i = 2;\n"
+               "    const int y = i+1;\n"
+               "    const int& x = y;\n"
+               "    if (a == x) { return 0; }\n"
+               "    if (b == x) { return 0; }\n"
+               "    if (c == x) { return 0; }\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 8U, 3));
+
+        code = "int f(int a, int b, int c, int x) {\n"
+               "    const int i = 2;\n"
+               "    const int y = i+1;\n"
+               "    if (a == y) { return 0; }\n"
+               "    if (b == y) { return 0; }\n"
+               "    if (c == y) { return 0; }\n"
+               "    if (x == y)\n"
+               "        return x;\n"
+               "    return 0;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 8U, 3));
+    }
+
+    void valueFlowForwardAfterCondition()
+    {
+        const char* code;
+
+        code = "int g();\n"
+               "void f() {\n"
+               "    int x = 3;\n"
+               "    int kk = 11;\n"
+               "    for (;;) {\n"
+               "        if (kk > 10) {\n"
+               "            kk = 0;\n"
+               "            x = g();\n"
+               "        }\n"
+               "        kk++;\n"
+               "        int a = x;\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 11U, 3));
+
+        code = "int g();\n"
+               "void f() {\n"
+               "    int x = 3;\n"
+               "    int kk = 11;\n"
+               "    while (true) {\n"
+               "        if (kk > 10) {\n"
+               "            kk = 0;\n"
+               "            x = g();\n"
+               "        }\n"
+               "        kk++;\n"
+               "        int a = x;\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 11U, 3));
+
+        code = "int g();\n"
+               "void f() {\n"
+               "    int x = 3;\n"
+               "    int kk = 11;\n"
+               "    if (true) {\n"
+               "        if (kk > 10) {\n"
+               "            kk = 0;\n"
+               "            x = g();\n"
+               "        }\n"
+               "        kk++;\n"
+               "        int a = x;\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 11U, 3));
+    }
+
     void valueFlowRightShift() {
         const char *code;
         /* Set some temporary fixed values to simplify testing */
-        const Settings settingsTmp = settings;
-        settings.int_bit = 32;
-        settings.long_bit = 64;
-        settings.long_long_bit = MathLib::bigint_bits * 2;
+        /*const*/ Settings s = settings;
+        s.platform.int_bit = 32;
+        s.platform.long_bit = 64;
+        s.platform.long_long_bit = MathLib::bigint_bits * 2;
 
         code = "int f(int a) {\n"
                "  int x = (a & 0xff) >> 16;\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code,3U,0));
+        ASSERT_EQUALS(true, testValueOfX(code,3U,0,&s));
 
         code = "int f(unsigned int a) {\n"
                "  int x = (a % 123) >> 16;\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code,3U,0));
+        ASSERT_EQUALS(true, testValueOfX(code,3U,0,&s));
 
         code = "int f(int y) {\n"
                "  int x = (y & 0xFFFFFFF) >> 31;\n"
@@ -2604,57 +4325,55 @@ class TestValueFlow : public TestFixture {
                "  int x = (y & 0xFFFFFFF) >> 32;\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(false, testValueOfX(code, 3u, 0));
+        ASSERT_EQUALS(false, testValueOfX(code, 3u, 0,&s));
 
         code = "int f(short y) {\n"
                "  int x = (y & 0xFFFFFF) >> 31;\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 3u, 0));
+        ASSERT_EQUALS(true, testValueOfX(code, 3u, 0,&s));
 
         code = "int f(short y) {\n"
                "  int x = (y & 0xFFFFFF) >> 32;\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(false, testValueOfX(code, 3u, 0));
+        ASSERT_EQUALS(false, testValueOfX(code, 3u, 0,&s));
 
         code = "int f(long y) {\n"
                "  int x = (y & 0xFFFFFF) >> 63;\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 3u, 0));
+        ASSERT_EQUALS(true, testValueOfX(code, 3u, 0,&s));
 
         code = "int f(long y) {\n"
                "  int x = (y & 0xFFFFFF) >> 64;\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(false, testValueOfX(code, 3u, 0));
+        ASSERT_EQUALS(false, testValueOfX(code, 3u, 0,&s));
 
         code = "int f(long long y) {\n"
                "  int x = (y & 0xFFFFFF) >> 63;\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 3u, 0));
+        ASSERT_EQUALS(true, testValueOfX(code, 3u, 0,&s));
 
         code = "int f(long long y) {\n"
                "  int x = (y & 0xFFFFFF) >> 64;\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(false, testValueOfX(code, 3u, 0));
+        ASSERT_EQUALS(false, testValueOfX(code, 3u, 0,&s));
 
         code = "int f(long long y) {\n"
                "  int x = (y & 0xFFFFFF) >> 121;\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(false, testValueOfX(code, 3u, 0));
+        ASSERT_EQUALS(false, testValueOfX(code, 3u, 0,&s));
 
         code = "int f(long long y) {\n"
                "  int x = (y & 0xFFFFFF) >> 128;\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(false, testValueOfX(code, 3u, 0));
-
-        settings = settingsTmp;
+        ASSERT_EQUALS(false, testValueOfX(code, 3u, 0,&s));
     }
 
     void valueFlowFwdAnalysis() {
@@ -2666,7 +4385,7 @@ class TestValueFlow : public TestFixture {
                "  foo.x = 1;\n"
                "  x = 0 + foo.x;\n" // <- foo.x is 1
                "}";
-        values = tokenValues(code, "+");
+        values = removeSymbolicTok(tokenValues(code, "+"));
         ASSERT_EQUALS(1U, values.size());
         ASSERT_EQUALS(true, values.front().isKnown());
         ASSERT_EQUALS(true, values.front().isIntValue());
@@ -2679,8 +4398,10 @@ class TestValueFlow : public TestFixture {
                "  while (s.x < y)\n" // s.x does not have known value
                "    s.x++;\n"
                "}";
-        values = tokenValues(code, "<");
-        ASSERT_EQUALS(true, values.empty());
+        values = removeImpossible(tokenValues(code, "<"));
+        ASSERT_EQUALS(1, values.size());
+        ASSERT(values.front().isPossible());
+        ASSERT_EQUALS(1, values.front().intvalue);
 
         code = "void f() {\n"
                "  S s;\n"
@@ -2702,7 +4423,7 @@ class TestValueFlow : public TestFixture {
                "    hints.x = 2;\n"
                "  x = 0 + foo.x;\n" // <- foo.x is possible 1, possible 2
                "}";
-        values = tokenValues(code, "+");
+        values = removeSymbolicTok(tokenValues(code, "+"));
         TODO_ASSERT_EQUALS(2U, 0U, values.size()); // should be 2
 
         // FP: Condition '*b>0' is always true
@@ -2717,8 +4438,10 @@ class TestValueFlow : public TestFixture {
                "  if (*b > 0) {\n" // *b does not have known value
                "  }\n"
                "}";
-        values = tokenValues(code, ">");
-        ASSERT_EQUALS(true, values.empty());
+        values = removeImpossible(tokenValues(code, ">"));
+        ASSERT_EQUALS(1, values.size());
+        ASSERT(values.front().isPossible());
+        ASSERT_EQUALS(1, values.front().intvalue);
 
         code = "void foo() {\n"
                "    struct ISO_PVD_s pvd;\n"
@@ -2726,36 +4449,49 @@ class TestValueFlow : public TestFixture {
                "    do {\n"
                "        if (pvd.descr_type == 0xff) {}\n"
                "        dostuff(&pvd);\n"
-               "    } while (condition)\n"
+               "    } while (condition);\n"
                "}";
-        values = tokenValues(code, "==");
+        values = removeImpossible(tokenValues(code, "=="));
+        ASSERT_EQUALS(1, values.size());
+        ASSERT(values.front().isPossible());
+        ASSERT_EQUALS(1, values.front().intvalue);
+
+        // for loops
+        code = "struct S { int x; };\n" // #9036
+               "void foo(struct S s) {\n"
+               "    for (s.x = 0; s.x < 127; s.x++) {}\n"
+               "}";
+        values = removeImpossible(tokenValues(code, "<"));
+        values.remove_if([&](const ValueFlow::Value& v) {
+            return !v.isKnown();
+        });
         ASSERT_EQUALS(true, values.empty());
     }
 
     void valueFlowSwitchVariable() {
-        const char *code;
-        code = "void f(int x) {\n"
-               "    a = x - 1;\n"  // <- x can be 14
-               "    switch (x) {\n"
-               "    case 14: a=x+2; break;\n"  // <- x is 14
-               "    };\n"
-               "    a = x;\n"  // <- x can be 14
-               "}";
+        const char code[] = "void f(int x) {\n"
+                            "    a = x - 1;\n"  // <- x can be 14
+                            "    switch (x) {\n"
+                            "    case 14: a=x+2; break;\n"  // <- x is 14
+                            "    };\n"
+                            "    a = x;\n"  // <- x can be 14
+                            "}";
         ASSERT_EQUALS(true, testConditionalValueOfX(code, 2U, 14));
-        ASSERT_EQUALS(true, testConditionalValueOfX(code, 4U, 14));
-        ASSERT_EQUALS(true, testConditionalValueOfX(code, 6U, 14));
+        TODO_ASSERT_EQUALS(true, false, testConditionalValueOfX(code, 4U, 14));
+        TODO_ASSERT_EQUALS(true, false, testConditionalValueOfX(code, 6U, 14));
 
         ValueFlow::Value value1 = valueOfTok(code, "-");
         ASSERT_EQUALS(13, value1.intvalue);
         ASSERT(!value1.isKnown());
 
         ValueFlow::Value value2 = valueOfTok(code, "+");
-        ASSERT_EQUALS(16, value2.intvalue);
-        ASSERT(value2.isKnown());
+        TODO_ASSERT_EQUALS(16, 0, value2.intvalue);
+        TODO_ASSERT_EQUALS(true, false, value2.isKnown());
     }
 
     void valueFlowForLoop() {
         const char *code;
+        ValueFlow::Value value;
 
         code = "void f() {\n"
                "    for (int x = 0; x < 10; x++)\n"
@@ -2869,7 +4605,7 @@ class TestValueFlow : public TestFixture {
                "    for (int x = 0; x < 10 && y = do_something();)\n"
                "        x;\n"
                "}";
-        TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 4U, 0));
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 0));
 
         code = "void f() {\n"
                "    int x,y;\n"
@@ -2905,7 +4641,8 @@ class TestValueFlow : public TestFixture {
                "  }\n"
                "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
-        ASSERT_EQUALS(true,  testValueOfX(code, 4U, 9));
+        // Known to be true, but it could also be 9
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 1));
 
         code = "void foo() {\n"
                "  for (int x = 0; x < 10; x++) {\n"
@@ -2923,7 +4660,8 @@ class TestValueFlow : public TestFixture {
                "  }\n"
                "}\n";
         ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
-        ASSERT_EQUALS(true,  testValueOfX(code, 4U, 9));
+        // Known to be true, but it could also be 9
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 1));
 
         // After loop
         code = "void foo() {\n"
@@ -2984,7 +4722,20 @@ class TestValueFlow : public TestFixture {
                "  for(int i = 0; i < 20; i++)\n"
                "    n = (int)(i < 10 || abs(negWander) < abs(negTravel));\n"
                "}";
-        testValueOfX(code,0,0); // <- don't hang
+        (void)testValueOfX(code,0,0); // <- don't hang
+
+        // crash (daca@home)
+        code = "void foo(char *z, int n) {\n"
+               "    int i;\n"
+               "    if (fPScript) {\n"
+               "        i = 1;\n"
+               "    } else if (strncmp(&z[n], \"<!--\", 4) == 0) {\n"
+               "        for (i = 4;;) {\n"
+               "            if (z[n] && strncmp(&z[n+i], \"-->\", 3) == 0) ;\n"
+               "        }\n"
+               "    }\n"
+               "}";
+        (void)testValueOfX(code,0,0); // <- don't crash
 
         // conditional code in loop
         code = "void f(int mask) {\n" // #6000
@@ -3006,6 +4757,171 @@ class TestValueFlow : public TestFixture {
                "    a = x;\n" // <- max value is 3
                "}";
         ASSERT_EQUALS(true, testValueOfX(code, 5U, 3));
+
+        code = "void f() {\n"
+               "    int x;\n"
+               "    for (x = 0; x < 10; x++)\n"
+               "        x;\n"
+               "}";
+        std::list<ValueFlow::Value> values = tokenValues(code, "x <");
+        ASSERT(std::none_of(values.cbegin(), values.cend(), std::mem_fn(&ValueFlow::Value::isUninitValue)));
+
+        // #9637
+        code = "void f() {\n"
+               "    unsigned int x = 0;\n"
+               "    for (x = 0; x < 2; x++) {}\n"
+               "}\n";
+        value = valueOfTok(code, "x <");
+        ASSERT(value.isPossible());
+        ASSERT_EQUALS(0, value.intvalue);
+
+        code = "void f() {\n"
+               "    unsigned int x = 0;\n"
+               "    for (;x < 2; x++) {}\n"
+               "}\n";
+        value = valueOfTok(code, "x <");
+        ASSERT(value.isPossible());
+        ASSERT_EQUALS(0, value.intvalue);
+
+        code = "void f() {\n"
+               "    unsigned int x = 1;\n"
+               "    for (x = 0; x < 2; x++) {}\n"
+               "}\n";
+        value = valueOfTok(code, "x <");
+        ASSERT(!value.isKnown());
+
+        code = "void b(int* a) {\n" // #10795
+               "    for (*a = 1;;)\n"
+               "        if (0) {}\n"
+               "}\n"
+               "struct S { int* a; }\n"
+               "void b(S& s) {\n"
+               "    for (*s.a = 1;;)\n"
+               "        if (0) {}\n"
+               "}\n"
+               "struct T { S s; };\n"
+               "void b(T& t) {\n"
+               "    for (*&t.s.a[0] = 1;;)\n"
+               "        if (0) {}\n"
+               "}\n";
+        ASSERT_NO_THROW(testValueOfX(code, 0, 0));
+
+        code = "void f() {\n"
+               "    int p[2];\n"
+               "    for (p[0] = 0; p[0] <= 2; p[0]++) {\n"
+               "        for (p[1] = 0; p[1] <= 2 - p[0]; p[1]++) {}\n"
+               "    }\n"
+               "}\n";
+        ASSERT_NO_THROW(testValueOfX(code, 0, 0));
+
+        code = "struct C {\n" // #10828
+               "    int& v() { return i; }\n"
+               "    int& w() { return j; }\n"
+               "    int i{}, j{};\n"
+               "};\n"
+               "void f() {\n"
+               "    C c;\n"
+               "    for (c.w() = 0; c.w() < 2; c.w()++) {\n"
+               "        for (c.v() = 0; c.v() < 24; c.v()++) {}\n"
+               "    }\n"
+               "}\n";
+        ASSERT_NO_THROW(testValueOfX(code, 0, 0));
+
+        // #11072
+        code = "struct a {\n"
+               "    long b;\n"
+               "    long c[6];\n"
+               "    long d;\n"
+               "};\n"
+               "void e(long) {\n"
+               "    a f = {0};\n"
+               "    for (f.d = 0; 2; f.d++)\n"
+               "        e(f.c[f.b]);\n"
+               "}\n";
+        values = tokenValues(code, ". c");
+        ASSERT_EQUALS(true, values.empty());
+        values = tokenValues(code, "[ f . b");
+        ASSERT_EQUALS(true, values.empty());
+
+        code = "void f() {\n" // #13109
+               "    const int a[10] = {};\n"
+               "    for (int n = 0; 1; ++n) {\n"
+               "        (void)a[n];\n"
+               "        break;\n"
+               "    }\n"
+               "}\n";
+        values = tokenValues(code, "n ]");
+        ASSERT_EQUALS(2, values.size());
+        auto it = values.begin();
+        ASSERT_EQUALS(-1, it->intvalue);
+        ASSERT(it->isImpossible());
+        ++it;
+        ASSERT_EQUALS(0, it->intvalue);
+        ASSERT(it->isPossible());
+
+        code = "void f() {\n"
+               "    const int a[10] = {};\n"
+               "    for (int n = 0; 1; ++n) {\n"
+               "        if (a[n] < 1)\n"
+               "            break;\n"
+               "    }\n"
+               "}\n";
+        values = tokenValues(code, "n ]");
+        ASSERT_EQUALS(2, values.size());
+        it = values.begin();
+        ASSERT_EQUALS(-1, it->intvalue);
+        ASSERT(it->isImpossible());
+        ++it;
+        ASSERT_EQUALS(0, it->intvalue);
+        ASSERT(it->isPossible());
+
+        code = "void f() {\n"
+               "    const int a[10] = {};\n"
+               "    for (int n = 0; 1; ++n) {\n"
+               "        if (a[n] < 1)\n"
+               "            throw 0;\n"
+               "    }\n"
+               "}\n";
+        values = tokenValues(code, "n ]");
+        ASSERT_EQUALS(2, values.size());
+        it = values.begin();
+        ASSERT_EQUALS(-1, it->intvalue);
+        ASSERT(it->isImpossible());
+        ++it;
+        ASSERT_EQUALS(0, it->intvalue);
+        ASSERT(it->isPossible());
+
+        code = "void f() {\n"
+               "    const int a[10] = {};\n"
+               "    for (int n = 0; 1; ++n) {\n"
+               "        (void)a[n];\n"
+               "        exit(1);\n"
+               "    }\n"
+               "}\n";
+        values = tokenValues(code, "n ]");
+        ASSERT_EQUALS(2, values.size());
+        it = values.begin();
+        ASSERT_EQUALS(-1, it->intvalue);
+        ASSERT(it->isImpossible());
+        ++it;
+        ASSERT_EQUALS(0, it->intvalue);
+        ASSERT(it->isPossible());
+
+        code = "void f() {\n"
+               "    const int a[10] = {};\n"
+               "    for (int n = 0; 1; ++n) {\n"
+               "        if (a[n] < 1)\n"
+               "            exit(1);\n"
+               "    }\n"
+               "}\n";
+        values = tokenValues(code, "n ]");
+        ASSERT_EQUALS(2, values.size());
+        it = values.begin();
+        ASSERT_EQUALS(-1, it->intvalue);
+        ASSERT(it->isImpossible());
+        ++it;
+        ASSERT_EQUALS(0, it->intvalue);
+        ASSERT(it->isPossible());
     }
 
     void valueFlowSubFunction() {
@@ -3027,7 +4943,110 @@ class TestValueFlow : public TestFixture {
         ASSERT_EQUALS(true, testValueOfX(code, 7U, 0));
         ASSERT_EQUALS(true, testValueOfX(code, 7U, 17));
         ASSERT_EQUALS(true, testValueOfX(code, 7U, 42));
+
+        code = "void g(int, int) {}\n"
+               "void f(int x, int y) {\n"
+               "    g(x, y);\n"
+               "}\n"
+               "void h() {\n"
+               "    f(0, 0);\n"
+               "    f(1, 1);\n"
+               "    f(2, 2);\n"
+               "    f(3, 3);\n"
+               "    f(4, 4);\n"
+               "    f(5, 5);\n"
+               "    f(6, 6);\n"
+               "    f(7, 7);\n"
+               "    f(8, 8);\n"
+               "    f(9, 9);\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 1));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 2));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 3));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 4));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 5));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 6));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 7));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 8));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 9));
+
+        code = "int f(int i, int j) {\n"
+               "    if (i == j) {\n"
+               "        int x = i;\n"
+               "        return x;\n"
+               "    }\n"
+               "    return 0;\n"
+               "}\n"
+               "int g(int x) {\n"
+               "    f(x, -1);\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, -1));
+
+        code = "void g() {\n"
+               "    const std::vector<int> v;\n"
+               "    f(v);\n"
+               "}\n"
+               "void f(const std::vector<int>& w) {\n"
+               "    for (int i = 0; i < w.size(); ++i) {\n"
+               "        int x = i != 0;\n"
+               "        int a = x;\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 8U, 0));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 8U, 1));
+
+        code = "void g() {\n"
+               "    const std::vector<int> v;\n"
+               "    f(v);\n"
+               "}\n"
+               "void f(const std::vector<int>& w) {\n"
+               "    for (int i = 0; i < w.size(); ++i) {\n"
+               "        int x = i;\n"
+               "        int a = x;\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 8U, -1));
+
+        code = "typedef enum {\n"
+               "  K0, K1\n"
+               "} K;\n"
+               "bool valid(Object *obj, K x) {\n"
+               "  if (!obj || obj->kind != x)\n"
+               "    return false;\n"
+               "  return x == K0;\n"
+               "}\n"
+               "void f(Object *obj) {\n"
+               "  if (valid(obj, K0)) {}\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 7U, 0));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 7U, 0));
+
+        code = "int f(int i) {\n"
+               "    int x = abs(i);\n"
+               "    return x;\n"
+               "}\n"
+               "void g() {\n"
+               "    f(1);\n"
+               "    f(0);\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 1));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 0));
+
+        code = "void foo(int* p, int* x) {\n"
+               "    bool b1 = (p != NULL);\n"
+               "    bool b2 = b1 && (x != NULL);\n"
+               "    if (b2) {\n"
+               "        *x = 3;\n"
+               "    }\n"
+               "}\n"
+               "\n"
+               "void bar() {\n"
+               "    foo(NULL, NULL);\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 5U, 0));
     }
+
     void valueFlowFunctionReturn() {
         const char *code;
 
@@ -3044,23 +5063,23 @@ class TestValueFlow : public TestFixture {
                "  return x+y;\n"
                "}\n"
                "void f2() {\n"
-               "    x = 1 * add(10+1,4);\n"
+               "    x = 2 * add(10+1,4);\n"
                "}";
-        ASSERT_EQUALS(15, valueOfTok(code, "*").intvalue);
+        ASSERT_EQUALS(30, valueOfTok(code, "*").intvalue);
         ASSERT_EQUALS(true, valueOfTok(code, "*").isKnown());
 
         code = "int one() { return 1; }\n"
-               "void f() { x = 1 * one(); }";
-        ASSERT_EQUALS(1, valueOfTok(code, "*").intvalue);
+               "void f() { x = 2 * one(); }";
+        ASSERT_EQUALS(2, valueOfTok(code, "*").intvalue);
         ASSERT_EQUALS(true, valueOfTok(code, "*").isKnown());
 
         code = "int add(int x, int y) {\n"
                "  return x+y;\n"
                "}\n"
                "void f2() {\n"
-               "    x = 1 * add(1,add(2,3));\n"
+               "    x = 2 * add(1,add(2,3));\n"
                "}";
-        ASSERT_EQUALS(6, valueOfTok(code, "*").intvalue);
+        ASSERT_EQUALS(12, valueOfTok(code, "*").intvalue);
         ASSERT_EQUALS(true, valueOfTok(code, "*").isKnown());
 
         code = "int f(int i, X x) {\n"
@@ -3092,8 +5111,130 @@ class TestValueFlow : public TestFixture {
                "        x = 10 - f1(2);\n"
                "    }\n"
                "};";
-        ASSERT_EQUALS(7, valueOfTok(code, "-").intvalue);
+        TODO_ASSERT_EQUALS(7, 0, valueOfTok(code, "-").intvalue);
         ASSERT_EQUALS(false, valueOfTok(code, "-").isKnown());
+
+        code = "struct base {\n"
+               "    virtual int f() { return 0; }\n"
+               "};\n"
+               "void g(base* b) {\n"
+               "    int x = b->f();\n"
+               "    return x;\n"
+               "}\n";
+        TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 6U, 0));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 6U, 0));
+
+        code = "struct base {\n"
+               "    virtual int f() { return 0; }\n"
+               "};\n"
+               "void g(base& b) {\n"
+               "    int x = b.f();\n"
+               "    return x;\n"
+               "}\n";
+        TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 6U, 0));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 6U, 0));
+
+        code = "struct base {\n"
+               "    virtual int f() { return 0; }\n"
+               "};\n"
+               "struct derived : base {\n"
+               "    int f() override { return 1; }\n"
+               "};\n"
+               "void g(derived* d) {\n"
+               "    base* b = d;\n"
+               "    int x = b->f();\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 10U, 0));
+        TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 10U, 1));
+
+        code = "struct base {\n"
+               "    virtual int f() final { return 0; }\n"
+               "};\n"
+               "void g(base* b) {\n"
+               "    int x = b->f();\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 6U, 0));
+
+        code = "int* g(int& i, bool b) {\n"
+               "    if(b)\n"
+               "        return nullptr;\n"
+               "    return &i;\n"
+               "}   \n"
+               "int f(int i) {\n"
+               "    int* x = g(i, true);\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 8U, 0));
+
+        code = "int* g(int& i, bool b) {\n"
+               "    if(b)\n"
+               "        return nullptr;\n"
+               "    return &i;\n"
+               "}   \n"
+               "int f(int i) {\n"
+               "    int* x = g(i, false);\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 8U, 0));
+
+        code = "int* g(int& i, bool b) {\n"
+               "    if(b)\n"
+               "        return nullptr;\n"
+               "    return &i;\n"
+               "}   \n"
+               "int f(int i) {\n"
+               "    int* x = g(i, i == 3);\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 8U, 0));
+
+        code = "struct A {\n"
+               "    unsigned i;\n"
+               "    bool f(unsigned x) const {\n"
+               "        return ((i & x) != 0);\n"
+               "    }\n"
+               "};\n"
+               "int g(A& a) {\n"
+               "    int x = a.f(2);\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 9U, 0));
+        ASSERT_EQUALS(false, testValueOfX(code, 9U, 1));
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 9U, 0));
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 9U, 1));
+
+        code = "struct A {\n"
+               "    enum {\n"
+               "        b = 0,\n"
+               "        c = 1,\n"
+               "        d = 2\n"
+               "    };\n"
+               "    bool isb() const {\n"
+               "        return e == b;\n"
+               "    }\n"
+               "    unsigned int e;\n"
+               "};\n"
+               "int f(A g) {\n"
+               "  int x = !g.isb();\n"
+               "  return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 14U, 0));
+        ASSERT_EQUALS(false, testValueOfX(code, 14U, 1));
+
+        code = "bool h(char q);\n"
+               "bool g(char q) {\n"
+               "    if (!h(q))\n"
+               "        return false;\n"
+               "    return true;\n"
+               "}\n"
+               "int f() {\n"
+               "    int x = g(0);\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 9U, 0));
+        ASSERT_EQUALS(false, testValueOfX(code, 9U, 1));
     }
 
     void valueFlowFunctionDefaultParameter() {
@@ -3102,15 +5243,14 @@ class TestValueFlow : public TestFixture {
         code = "class continuous_src_time {\n"
                "    continuous_src_time(std::complex<double> f, double st = 0.0, double et = infinity) {}\n"
                "};";
-        testValueOfX(code, 2U, 2); // Don't crash (#6494)
+        (void)testValueOfX(code, 2U, 2); // Don't crash (#6494)
     }
 
     bool isNotKnownValues(const char code[], const char str[]) {
-        for (const ValueFlow::Value &v : tokenValues(code, str)) {
-            if (v.isKnown())
-                return false;
-        }
-        return true;
+        const auto& values = tokenValues(code, str);
+        return std::none_of(values.cbegin(), values.cend(), [](const ValueFlow::Value& v) {
+            return v.isKnown();
+        });
     }
 
     void knownValue() {
@@ -3381,9 +5521,121 @@ class TestValueFlow : public TestFixture {
         ASSERT_EQUALS(true,  testValueOfX(code, 3U, 1)); // value of x can be 1
         ASSERT_EQUALS(false, testValueOfX(code, 3U, 2)); // value of x can't be 2
 
-        // calculation with known result
-        code = "int f(int x) { a = x & 0; }"; // <- & is 0
-        value = valueOfTok(code, "&");
+        code = "bool f() {\n"
+               "  const int s( 4 );"
+               "  return s == 4;\n" // <- known value
+               "}";
+        value = valueOfTok(code, "==");
+        ASSERT(value.isKnown());
+        ASSERT_EQUALS(1, value.intvalue);
+
+        code = "bool f() {\n"
+               "  const int s{ 4 };"
+               "  return s == 4;\n" // <- known value
+               "}";
+        value = valueOfTok(code, "==");
+        ASSERT(value.isKnown());
+        ASSERT_EQUALS(1, value.intvalue);
+
+        code = "bool f() {\n"
+               "  const int s = int( 4 );"
+               "  return s == 4;\n" // <- known value
+               "}";
+        value = valueOfTok(code, "==");
+        ASSERT(value.isKnown());
+        ASSERT_EQUALS(1, value.intvalue);
+
+        code = "bool f() {\n"
+               "  const int s = int{ 4 };"
+               "  return s == 4;\n" // <- known value
+               "}";
+        value = valueOfTok(code, "==");
+        ASSERT(value.isKnown());
+        ASSERT_EQUALS(1, value.intvalue);
+
+        code = "bool f() {\n"
+               "  const int s = int{};"
+               "  return s == 0;\n" // <- known value
+               "}";
+        value = valueOfTok(code, "==");
+        ASSERT_EQUALS(true, value.isKnown());
+        ASSERT_EQUALS(1, value.intvalue);
+
+        code = "bool f() {\n"
+               "  const int s = int();"
+               "  return s == 0;\n" // <- known value
+               "}";
+        value = valueOfTok(code, "==");
+        ASSERT_EQUALS(true, value.isKnown());
+        ASSERT_EQUALS(1, value.intvalue);
+
+        code = "bool f() {\n"
+               "  const int s{};"
+               "  return s == 0;\n" // <- known value
+               "}";
+        value = valueOfTok(code, "==");
+        ASSERT_EQUALS(true, value.isKnown());
+        ASSERT_EQUALS(1, value.intvalue);
+
+        code = "bool f() {\n"
+               "  int* p{};\n"
+               "  return p == nullptr;\n" // <- known value
+               "}";
+        value = valueOfTok(code, "==");
+        ASSERT_EQUALS(true, value.isKnown());
+        ASSERT_EQUALS(1, value.intvalue);
+
+        code = "bool f() {\n"
+               "  int* p{ nullptr };\n"
+               "  return p == nullptr;\n" // <- known value
+               "}";
+        value = valueOfTok(code, "==");
+        ASSERT_EQUALS(true, value.isKnown());
+        ASSERT_EQUALS(1, value.intvalue);
+
+        code = "bool f() {\n"
+               "  int* p{ 0 };\n"
+               "  return p == nullptr;\n" // <- known value
+               "}";
+        value = valueOfTok(code, "==");
+        ASSERT_EQUALS(true, value.isKnown());
+        ASSERT_EQUALS(1, value.intvalue);
+
+        code = "bool f() {\n"
+               "  int* p = {};\n"
+               "  return p == nullptr;\n" // <- known value
+               "}";
+        value = valueOfTok(code, "==");
+        ASSERT_EQUALS(true, value.isKnown());
+        ASSERT_EQUALS(1, value.intvalue);
+
+        code = "bool f() {\n"
+               "  int i = {};\n"
+               "  return i == 0;\n" // <- known value
+               "}";
+        value = valueOfTok(code, "==");
+        ASSERT_EQUALS(true, value.isKnown());
+        ASSERT_EQUALS(1, value.intvalue);
+
+        code = "bool f() {\n"
+               "  int* p = { 0 };\n"
+               "  return p == nullptr;\n" // <- known value
+               "}";
+        value = valueOfTok(code, "==");
+        ASSERT_EQUALS(true, value.isKnown());
+        ASSERT_EQUALS(1, value.intvalue);
+
+        code = "bool f() {\n"
+               "  int i = { 1 };\n"
+               "  return i == 1;\n" // <- known value
+               "}";
+        value = valueOfTok(code, "==");
+        ASSERT_EQUALS(true, value.isKnown());
+        ASSERT_EQUALS(1, value.intvalue);
+
+        // calculation with known result
+        code = "int f(int x) { a = x & 0; }"; // <- & is 0
+        value = valueOfTok(code, "&");
         ASSERT_EQUALS(0, value.intvalue);
         ASSERT(value.isKnown());
 
@@ -3393,11 +5645,35 @@ class TestValueFlow : public TestFixture {
         value = valueOfTok(code, "1");
         ASSERT_EQUALS(1, value.intvalue);
         ASSERT_EQUALS(false, value.isKnown());
+
+        code = "void f(char c, struct T* t) {\n" // #11894
+               "    (*t->func)(&c, 1, t->ptr);\n"
+               "}\n";
+        value = valueOfTok(code, ", 1");
+        ASSERT_EQUALS(0, value.intvalue);
+        ASSERT_EQUALS(false, value.isKnown());
+
+        // #13959
+        const Settings settingsOld = settings;
+        settings.standards.c = Standards::C23;
+        code = "void f(int* p) {\n"
+               "    if (p == nullptr)\n"
+               "        return;\n"
+               "    if (p) {}\n"
+               "}\n";
+        value = valueOfTok(code, "p ) { }", &settings, /*cpp*/ false);
+        ASSERT_EQUALS(1, value.intvalue);
+        ASSERT_EQUALS(true, value.isKnown());
+
+        settings.standards.c = Standards::C17;
+        value = valueOfTok(code, "p ) { }", &settings, /*cpp*/ false);
+        ASSERT(value == ValueFlow::Value());
+        settings = settingsOld;
     }
 
     void valueFlowSizeofForwardDeclaredEnum() {
         const char *code = "enum E; sz=sizeof(E);";
-        valueOfTok(code, "="); // Don't crash (#7775)
+        (void)valueOfTok(code, "="); // Don't crash (#7775)
     }
 
     void valueFlowGlobalVar() {
@@ -3563,12 +5839,40 @@ class TestValueFlow : public TestFixture {
                "}";
         ASSERT_EQUALS(0U, tokenValues(code, "x )").size());
 
+        // initialization
+        code = "int foo() {\n"
+               "  int x;\n"
+               "  *((int *)(&x)) = 12;\n"
+               "  a = x + 1;\n"
+               "}";
+        values = tokenValues(code, "x +");
+        ASSERT_EQUALS(true, values.empty());
+        // ASSERT_EQUALS(1U, values.size());
+        // ASSERT(values.front().isIntValue());
+        // ASSERT_EQUALS(12, values.front().intvalue);
+
+        code = "struct AB { int a; };\n" // 11767
+               "void fp(void) {\n"
+               "    struct AB ab;\n"
+               "    *((int*)(&(ab.a))) = 1;\n"
+               "    x = ab.a + 1;\n" // <- not uninitialized
+               "}\n";
+        values = tokenValues(code, "ab . a +");
+        ASSERT_EQUALS(0, values.size());
+        // ASSERT_EQUALS(1U, values.size());
+        // ASSERT(values.front().isIntValue());
+        // ASSERT_EQUALS(1, values.front().intvalue);
+
         // #8036
         code = "void foo() {\n"
                "    int x;\n"
                "    f(x=3), return x+3;\n"
                "}";
-        ASSERT_EQUALS(0U, tokenValues(code, "x +").size());
+        values = tokenValues(code, "x +");
+        ASSERT_EQUALS(true, values.empty());
+        // ASSERT_EQUALS(1U, values.size());
+        // ASSERT(values.front().isIntValue());
+        // ASSERT_EQUALS(3, values.front().intvalue);
 
         // #8195
         code = "void foo(std::istream &is) {\n"
@@ -3586,7 +5890,8 @@ class TestValueFlow : public TestFixture {
                "  return((n=42) && *n == 'A');\n"
                "}";
         values = tokenValues(code, "n ==");
-        ASSERT_EQUALS(true, values.size() != 1U || !values.front().isUninitValue());
+        values.remove_if(&isNotUninitValue);
+        ASSERT_EQUALS(true, values.empty());
 
         // #8233
         code = "void foo() {\n"
@@ -3598,8 +5903,7 @@ class TestValueFlow : public TestFixture {
                "    x = 1;\n"
                "  if (x>1) {}\n"
                "}";
-        values = tokenValues(code, "x >");
-        ASSERT_EQUALS(true, values.size() == 1U && values.front().isIntValue());
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 8U, 1));
 
         // #8348 - noreturn else
         code = "int test_input_int(int a, int b) {\n"
@@ -3611,6 +5915,7 @@ class TestValueFlow : public TestFixture {
                "    a = x + 1;\n"
                "}\n";
         values = tokenValues(code, "x +");
+        values.remove_if(&isNotUninitValue);
         ASSERT_EQUALS(true, values.empty());
 
         // #8494 - overloaded operator &
@@ -3658,21 +5963,21 @@ class TestValueFlow : public TestFixture {
                "  int c;\n"
                "  if (d)\n"
                "    c = 0;\n"
-               " else if (e)\n"
+               "  else if (e)\n"
                "   c = 0;\n"
                "  c++;\n"
                "}\n";
         values = tokenValues(code, "c ++ ; }");
-        ASSERT_EQUALS(true, values.size() == 2);
-        ASSERT_EQUALS(true, values.front().isUninitValue() || values.back().isUninitValue());
-        ASSERT_EQUALS(true, values.front().isPossible() || values.back().isPossible());
-        ASSERT_EQUALS(true, values.front().intvalue == 0 || values.back().intvalue == 0);
+        TODO_ASSERT_EQUALS(true, false, values.size() == 2);
+        // ASSERT_EQUALS(true, values.front().isUninitValue() || values.back().isUninitValue());
+        // ASSERT_EQUALS(true, values.front().isPossible() || values.back().isPossible());
+        // ASSERT_EQUALS(true, values.front().intvalue == 0 || values.back().intvalue == 0);
 
         code = "void b(bool d, bool e) {\n"
                "  int c;\n"
                "  if (d)\n"
                "    c = 0;\n"
-               " else if (!d)\n"
+               "  else if (!d)\n"
                "   c = 0;\n"
                "  c++;\n"
                "}\n";
@@ -3700,10 +6005,218 @@ class TestValueFlow : public TestFixture {
                "}";
         values = tokenValues(code, "szHdr ; }");
         ASSERT_EQUALS(0, values.size());
+
+        // #9933
+        code = "struct MyStruct { size_t value; }\n"
+               "\n"
+               "void foo() {\n"
+               "    MyStruct x;\n"
+               "    fread(((char *)&x) + 0, sizeof(x), f);\n"
+               "    if (x.value < 432) {}\n"
+               "}";
+        values = tokenValues(code, "x . value");
+        ASSERT_EQUALS(0, values.size());
+
+        // #10166
+        code = "int f(bool b) {\n"
+               "    int x;\n"
+               "    do {\n"
+               "      if (b) {\n"
+               "        x = 0;\n"
+               "        break;\n"
+               "      }\n"
+               "    } while (true);\n"
+               "    return x;\n"
+               "}\n";
+        values = tokenValues(code, "x ; }", ValueFlow::Value::ValueType::UNINIT);
+        ASSERT_EQUALS(0, values.size());
+
+        code = "int f(bool b) {\n"
+               "    int x;\n"
+               "    while (true) {\n"
+               "      if (b) {\n"
+               "        x = 0;\n"
+               "        break;\n"
+               "      }\n"
+               "    }\n"
+               "    return x;\n"
+               "}\n";
+        values = tokenValues(code, "x ; }", ValueFlow::Value::ValueType::UNINIT);
+        ASSERT_EQUALS(0, values.size());
+
+        code = "int f(bool b) {\n"
+               "    int x;\n"
+               "    for(;;) {\n"
+               "      if (b) {\n"
+               "        x = 0;\n"
+               "        break;\n"
+               "      }\n"
+               "    }\n"
+               "    return x;\n"
+               "}\n";
+        values = tokenValues(code, "x ; }", ValueFlow::Value::ValueType::UNINIT);
+        ASSERT_EQUALS(0, values.size());
+
+        code = "int f(bool b) {\n"
+               "    int x;\n"
+               "    switch (b) {\n"
+               "      case 1: {\n"
+               "        ret = 0;\n"
+               "        break;\n"
+               "      }\n"
+               "    }\n"
+               "    return x;\n"
+               "}\n";
+        values = tokenValues(code, "x ; }", ValueFlow::Value::ValueType::UNINIT);
+        ASSERT_EQUALS(1, values.size());
+        ASSERT_EQUALS(true, values.front().isUninitValue());
+
+        code = "void f(int x) {\n"
+               "    int i;\n"
+               "    if (x > 0) {\n"
+               "        int y = -ENOMEM;\n" // assume constant ENOMEM is nonzero since it's negated
+               "        if (y != 0) return;\n"
+               "        i++;\n"
+               "    }\n"
+               "}\n";
+        values = tokenValues(code, "i ++", ValueFlow::Value::ValueType::UNINIT);
+        ASSERT_EQUALS(0, values.size());
+
+        // #11688
+        code = "void f() {\n"
+               "    int n;\n"
+               "    for (int i = 0; i < 4; i = n)\n" // <- n is initialized in the loop body
+               "        n = 10;\n"
+               "}";
+        values = tokenValues(code, "n )", ValueFlow::Value::ValueType::UNINIT);
+        ASSERT_EQUALS(0, values.size());
+
+        // #11774 - function call to init data
+        code = "struct id_struct { int id; };\n"
+               "int init(const id_struct **id);\n"
+               "void fp() {\n"
+               "  const id_struct *id_st;\n"
+               "  init(&id_st);\n"
+               "  if (id_st->id > 0) {}\n"
+               "}\n";
+        values = tokenValues(code, ". id", ValueFlow::Value::ValueType::UNINIT);
+        ASSERT_EQUALS(0, values.size());
+
+        // #11777 - false || ...
+        code = "bool init(int *p);\n"
+               "\n"
+               "void uninitvar_FP9() {\n"
+               "  int x;\n"
+               "  if (false || init(&x)) {}\n"
+               "  int b = x+1;\n"
+               "}";
+        values = tokenValues(code, "x + 1", ValueFlow::Value::ValueType::UNINIT);
+        ASSERT_EQUALS(0, values.size());
+
+        code = "void g() {\n"
+               "  int y;\n"
+               "  int *q = 1 ? &y : 0;\n"
+               "}\n";
+        values = tokenValues(code, "y :", ValueFlow::Value::ValueType::UNINIT);
+        ASSERT_EQUALS(1, values.size());
+        ASSERT_EQUALS(true, values.front().isUninitValue());
+        values = tokenValues(code, "& y :", ValueFlow::Value::ValueType::UNINIT);
+        ASSERT_EQUALS(1, values.size());
+        ASSERT_EQUALS(true, values.front().isUninitValue());
+
+        // #12012 - function init variable
+        code = "void init(uintptr_t p);\n"
+               "void fp() {\n"
+               "  int x;\n"
+               "  init((uintptr_t)&x);\n"
+               "  if (x > 0) {}\n"
+               "}\n";
+        values = tokenValues(code, "x >", ValueFlow::Value::ValueType::UNINIT);
+        ASSERT_EQUALS(0, values.size());
+
+        // #12031
+        code = "bool g(int *p);\n"
+               "bool h();\n"
+               "void f(bool b, int y) {\n"
+               "    int x;\n"
+               "    if (b && y > 0) {\n"
+               "        b = g(&x);\n"
+               "    }\n"
+               "    while (b && y > 0) {\n"
+               "        if (x < 0) {}\n"
+               "        break;\n"
+               "    }\n"
+               "}\n";
+        values = tokenValues(code, "x <", ValueFlow::Value::ValueType::UNINIT);
+        ASSERT_EQUALS(0, values.size());
+
+        code = "bool do_something(int *p);\n"
+               "int getY();\n"
+               "bool bar();\n"
+               "void foo() {\n"
+               "    bool flag{true};\n"
+               "    int x;\n"
+               "    int y = getY();\n"
+               "    if (flag == true) {\n"
+               "        flag = bar();\n"
+               "    }\n"
+               "    if ((flag == true) && y > 0) {\n"
+               "        flag = do_something(&x);\n"
+               "    }\n"
+               "    for (int i = 0; (flag == true) && i < y; i++) {\n"
+               "        if (x < 0) {}\n"
+               "    }\n"
+               "}\n";
+        values = tokenValues(code, "x <", ValueFlow::Value::ValueType::UNINIT);
+        ASSERT_EQUALS(0, values.size());
+
+        code = "void getX(int *p);\n"
+               "bool do_something();\n"
+               "void foo() {\n"
+               "  int x;\n"
+               "  bool flag;\n"
+               "  bool success;\n"
+               "  success = do_something();\n"
+               "  flag = success;\n"
+               "  if (success == true) {\n"
+               "    getX(&x);\n"
+               "  }\n"
+               "  for (int i = 0; (flag == true) && (i < x); ++i) {}\n"
+               "}\n";
+        values = tokenValues(code, "x ) ; ++ i", ValueFlow::Value::ValueType::UNINIT);
+        ASSERT_EQUALS(0, values.size());
+
+        code = "void g(bool *result, size_t *buflen) {\n" // #12091
+               "    if (*result && *buflen >= 5) {}\n" // <- *buflen might not be initialized
+               "}\n"
+               "void f() {\n"
+               "    size_t bytesCopied;\n"
+               "    bool copied_all = true;\n"
+               "    g(&copied_all, &bytesCopied);\n"
+               "}";
+        values = tokenValues(code, "buflen >=", ValueFlow::Value::ValueType::UNINIT);
+        ASSERT_EQUALS(1, values.size());
+
+        code = "void foo() {\n"
+               "  int counter = 0;\n"
+               "  int x;\n"
+               "  for (int i = 0; i < 5; i++) {\n"
+               "    if (i % 2 == 0) {\n"
+               "      x = i;\n"
+               "      counter++;\n"
+               "    }\n"
+               "  }\n"
+               "  for (int i = 0; i < counter; i++) {\n"
+               "      if(x > 5) {}\n"
+               "  }\n"
+               "}\n";
+        values = tokenValues(code, "x > 5", ValueFlow::Value::ValueType::UNINIT);
+        ASSERT_EQUALS(0, values.size());
     }
 
-    void valueFlowTerminatingCond() {
+    void valueFlowConditionExpressions() {
         const char* code;
+        std::list<ValueFlow::Value> values;
 
         // opposite condition
         code = "void f(int i, int j) {\n"
@@ -3725,11 +6238,12 @@ class TestValueFlow : public TestFixture {
                "    }\n"
                "    if (i != j) {}\n"
                "}\n";
-        ASSERT_EQUALS(false, valueOfTok(code, "!=").intvalue == 1);
+        ASSERT_EQUALS(true, valueOfTok(code, "!=").intvalue == 1);
+        ASSERT_EQUALS(false, valueOfTok(code, "!=").isKnown());
 
         code = "void f(int i, int j, bool a) {\n"
                "    if (i != j) {}\n"
-               "    if (i == j) return; \n"
+               "    if (i == j) return;\n"
                "}\n";
         ASSERT_EQUALS(false, valueOfTok(code, "!=").intvalue == 1);
 
@@ -3761,7 +6275,7 @@ class TestValueFlow : public TestFixture {
         code = "void f(int i, int j, bool a) {\n"
                "    bool x = (i != j);\n"
                "    bool b = x;\n"
-               "    if (i != j) return; \n"
+               "    if (i != j) return;\n"
                "}\n";
         ASSERT_EQUALS(false, testValueOfXKnown(code, 3U, 0));
 
@@ -3771,6 +6285,64 @@ class TestValueFlow : public TestFixture {
                "}\n";
         ASSERT_EQUALS(false, valueOfTok(code, "!=").intvalue == 1);
 
+        code = "void f(bool b, int i, int j) {\n"
+               "    if (b || i == j) return;\n"
+               "    if(i != j) {}\n"
+               "}\n";
+        ASSERT_EQUALS(true, valueOfTok(code, "!=").intvalue == 1);
+
+        code = "void f(bool b, int i, int j) {\n"
+               "    if (b && i == j) return;\n"
+               "    if(i != j) {}\n"
+               "}\n";
+        ASSERT_EQUALS(true, removeImpossible(tokenValues(code, "!=")).empty());
+
+        code = "void f(int i, int j) {\n"
+               "    if (i == j) {\n"
+               "        if (i != j) {}\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(true, valueOfTok(code, "!=").intvalue == 0);
+
+        code = "void f(int i, int j) {\n"
+               "    if (i == j) {} else {\n"
+               "        if (i != j) {}\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(true, valueOfTok(code, "!=").intvalue == 1);
+
+        code = "void f(bool b, int i, int j) {\n"
+               "    if (b && i == j) {\n"
+               "        if (i != j) {}\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(true, valueOfTok(code, "!=").intvalue == 0);
+
+        code = "void f(bool b, int i, int j) {\n"
+               "    if (b || i == j) {\n"
+               "        if (i != j) {}\n"
+               "    }\n"
+               "}\n";
+        values = removeImpossible(tokenValues(code, "!="));
+        ASSERT_EQUALS(1, values.size());
+        ASSERT_EQUALS(0, values.front().intvalue);
+        ASSERT_EQUALS(true, values.front().isIntValue());
+        ASSERT_EQUALS(true, values.front().isPossible());
+
+        code = "void f(bool b, int i, int j) {\n"
+               "    if (b || i == j) {} else {\n"
+               "        if (i != j) {}\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(true, valueOfTok(code, "!=").intvalue == 1);
+
+        code = "void f(bool b, int i, int j) {\n"
+               "    if (b && i == j) {} else {\n"
+               "        if (i != j) {}\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(true, removeImpossible(tokenValues(code, "!=")).empty());
+
         code = "void foo()\n" // #8924
                "{\n"
                "    if ( this->FileIndex >= 0 )\n"
@@ -3780,9 +6352,119 @@ class TestValueFlow : public TestFixture {
                "    if ( this->FileIndex < 0 ) {}\n"
                "}";
         ASSERT_EQUALS(false, valueOfTok(code, "<").intvalue == 1);
+
+        code = "int f(int p) {\n"
+               "    int v = 0;\n"
+               "    for (int i = 0; i < 1; ++i) {\n"
+               "        if (p == 0)\n"
+               "            v = 1;\n"
+               "        if (v == 1)\n"
+               "            break;\n"
+               "    }\n"
+               "    int x = v;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 10U, 0));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 10U, 1));
+
+        code = "void f() {\n"
+               "    const int size = arrayInfo.num(0);\n"
+               "    if (size <= 0)\n"
+               "        return;\n"
+               "    for (;;)\n"
+               "        if (size > 0) {}\n"
+               "}\n";
+        ASSERT_EQUALS(true, valueOfTok(code, "> 0").isKnown());
+        ASSERT_EQUALS(true, valueOfTok(code, "> 0").intvalue == 1);
+
+        //  FP #10110
+        code = "enum FENUMS { NONE = 0, CB = 8 };\n"
+               "bool calc(int x) {\n"
+               "    if (!x) {\n"
+               "        return false;\n"
+               "    }\n"
+               "\n"
+               "    if (x & CB) {\n"
+               "        return true;\n"
+               "    }\n"
+               "    return false;\n"
+               "}\n";
+        ASSERT_EQUALS(false, valueOfTok(code, "& CB").isKnown());
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 7U, 0));
+
+        code = "enum FENUMS { NONE = 0, CB = 8 };\n"
+               "bool calc(int x) {\n"
+               "    if (x) {\n"
+               "        return false;\n"
+               "    }\n"
+               "\n"
+               "    if ((!x) & CB) {\n"
+               "        return true;\n"
+               "    }\n"
+               "    return false;\n"
+               "}\n";
+        ASSERT_EQUALS(true, valueOfTok(code, "& CB").isKnown());
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 7U, 0));
+
+        code = "enum FENUMS { NONE = 0, CB = 8 };\n"
+               "bool calc(int x) {\n"
+               "    if (!!x) {\n"
+               "        return false;\n"
+               "    }\n"
+               "\n"
+               "    if (x & CB) {\n"
+               "        return true;\n"
+               "    }\n"
+               "    return false;\n"
+               "}\n";
+        ASSERT_EQUALS(true, valueOfTok(code, "& CB").isKnown());
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 7U, 0));
+
+        code = "bool calc(bool x) {\n"
+               "    if (!x) {\n"
+               "        return false;\n"
+               "    }\n"
+               "\n"
+               "    if (x) {\n"
+               "        return true;\n"
+               "    }\n"
+               "    return false;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 6U, 1));
+
+        code = "bool calc(bool x) {\n"
+               "    if (x) {\n"
+               "        return false;\n"
+               "    }\n"
+               "\n"
+               "    if (!x) {\n"
+               "        return true;\n"
+               "    }\n"
+               "    return false;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 6U, 0));
+
+        code = "bool f(bool b1, bool b2) {\n"
+               "    if (b1 && b2)\n"
+               "        return;\n"
+               "    int x = b1 && b2;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 5U, 0));
+
+        code = "void f() {\n"
+               "    if (int* x = {}) {}\n"
+               "}\n";
+        ASSERT_EQUALS(true, testKnownValueOfTok(code, "=", 0));
     }
 
-    static std::string isPossibleContainerSizeValue(const std::list<ValueFlow::Value> &values, MathLib::bigint i) {
+    static std::string isPossibleContainerSizeValue(std::list<ValueFlow::Value> values,
+                                                    MathLib::bigint i,
+                                                    bool unique = true) {
+        values.remove_if(std::mem_fn(&ValueFlow::Value::isSymbolicValue));
+        values.remove_if(std::mem_fn(&ValueFlow::Value::isTokValue));
+        if (!unique)
+            values.remove_if(&isNotPossible);
         if (values.size() != 1)
             return "values.size():" + std::to_string(values.size());
         if (!values.front().isContainerSizeValue())
@@ -3794,7 +6476,13 @@ class TestValueFlow : public TestFixture {
         return "";
     }
 
-    static std::string isImpossibleContainerSizeValue(const std::list<ValueFlow::Value>& values, MathLib::bigint i) {
+    static std::string isImpossibleContainerSizeValue(std::list<ValueFlow::Value> values,
+                                                      MathLib::bigint i,
+                                                      bool unique = true) {
+        values.remove_if(std::mem_fn(&ValueFlow::Value::isSymbolicValue));
+        values.remove_if(std::mem_fn(&ValueFlow::Value::isTokValue));
+        if (!unique)
+            values.remove_if(&isNotImpossible);
         if (values.size() != 1)
             return "values.size():" + std::to_string(values.size());
         if (!values.front().isContainerSizeValue())
@@ -3806,29 +6494,49 @@ class TestValueFlow : public TestFixture {
         return "";
     }
 
-    static std::string isKnownContainerSizeValue(const std::list<ValueFlow::Value> &values, MathLib::bigint i) {
+    static std::string isInconclusiveContainerSizeValue(std::list<ValueFlow::Value> values,
+                                                        MathLib::bigint i,
+                                                        bool unique = true) {
+        values.remove_if(std::mem_fn(&ValueFlow::Value::isSymbolicValue));
+        values.remove_if(std::mem_fn(&ValueFlow::Value::isTokValue));
+        if (!unique)
+            values.remove_if(&isNotInconclusive);
         if (values.size() != 1)
             return "values.size():" + std::to_string(values.size());
         if (!values.front().isContainerSizeValue())
             return "ContainerSizeValue";
-        if (!values.front().isKnown())
-            return "Known";
+        if (!values.front().isInconclusive())
+            return "Inconclusive";
         if (values.front().intvalue != i)
             return "intvalue:" + std::to_string(values.front().intvalue);
         return "";
     }
 
-    void valueFlowContainerSize() {
-        const char *code;
-
-        LOAD_LIB_2(settings.library, "std.cfg");
+    static std::string isKnownContainerSizeValue(std::list<ValueFlow::Value> values, MathLib::bigint i, bool unique = true) {
+        values.remove_if(std::mem_fn(&ValueFlow::Value::isSymbolicValue));
+        values.remove_if(std::mem_fn(&ValueFlow::Value::isTokValue));
+        if (!unique)
+            values.remove_if(&isNotKnown);
+        if (values.size() != 1)
+            return "values.size():" + std::to_string(values.size());
+        if (!values.front().isContainerSizeValue())
+            return "ContainerSizeValue";
+        if (!values.front().isKnown())
+            return "Known";
+        if (values.front().intvalue != i)
+            return "intvalue:" + std::to_string(values.front().intvalue);
+        return "";
+    }
+
+    void valueFlowContainerSize() {
+        const char *code;
 
         // condition
         code = "void f(const std::list<int> &ints) {\n"
                "  if (!static_cast<bool>(ints.empty()))\n"
                "    ints.front();\n"
                "}";
-        ASSERT(tokenValues(code, "ints . front").empty());
+        ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "ints . front"), 0));
 
         // valueFlowContainerReverse
         code = "void f(const std::list<int> &ints) {\n"
@@ -3848,7 +6556,7 @@ class TestValueFlow : public TestFixture {
                "  ints.pop_back();\n"
                "  if (ints.empty()) {}\n"
                "}";
-        ASSERT(tokenValues(code, "ints . front").empty());
+        ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "ints . front"), 1));
 
         code = "void f(std::vector<int> v) {\n"
                "  v[10] = 0;\n" // <- container size can be 10
@@ -3869,6 +6577,35 @@ class TestValueFlow : public TestFixture {
                "}";
         ASSERT(tokenValues(code, "params [ 2 ]").empty());
 
+        // valueFlowAfterCondition
+        code = "void f(const std::vector<std::string>& v) {\n"
+               "    if(v.empty()) {\n"
+               "        v.front();\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "v . front"), 0));
+
+        code = "void f(const std::vector<std::string>& v) {\n"
+               "    if(std::empty(v)) {\n"
+               "        v.front();\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "v . front"), 0));
+
+        code = "void f(const std::vector<std::string>& v) {\n"
+               "    if(!v.empty()) {\n"
+               "        v.front();\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "v . front"), 0));
+
+        code = "void f(const std::vector<std::string>& v) {\n"
+               "    if(!v.empty() && v[0] != \"\") {\n"
+               "        v.front();\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "v . front"), 0));
+
         // valueFlowContainerForward
         code = "void f(const std::list<int> &ints) {\n"
                "  if (ints.empty()) {}\n"
@@ -3907,28 +6644,32 @@ class TestValueFlow : public TestFixture {
                "    ints.front();\n" // <- container size is 3
                "  }\n"
                "}";
-        ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "ints . front"), 3));
+        ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "ints . front"), 3, false));
+        ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "ints . front"), 4, false));
 
         code = "void f(const std::list<int> &ints) {\n"
                "  if (ints.size() >= 3) {\n"
                "    ints.front();\n" // <- container size is 3
                "  }\n"
                "}";
-        ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "ints . front"), 3));
+        ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "ints . front"), 3, false));
+        ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "ints . front"), 2, false));
 
         code = "void f(const std::list<int> &ints) {\n"
                "  if (ints.size() < 3) {\n"
                "    ints.front();\n" // <- container size is 2
                "  }\n"
                "}";
-        ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "ints . front"), 2));
+        ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "ints . front"), 2, false));
+        ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "ints . front"), 3, false));
 
         code = "void f(const std::list<int> &ints) {\n"
                "  if (ints.size() > 3) {\n"
                "    ints.front();\n" // <- container size is 4
                "  }\n"
                "}";
-        ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "ints . front"), 4));
+        ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "ints . front"), 4, false));
+        ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "ints . front"), 3, false));
 
         code = "void f(const std::list<int> &ints) {\n"
                "  if (ints.empty() == false) {\n"
@@ -3941,7 +6682,7 @@ class TestValueFlow : public TestFixture {
                "  if (v.empty()) {}\n"
                "  if (!v.empty() && v[10]==0) {}\n" // <- no container size for 'v[10]'
                "}";
-        ASSERT(tokenValues(code, "v [").empty());
+        ASSERT(removeImpossible(tokenValues(code, "v [")).empty());
 
         code = "void f() {\n"
                "  std::list<int> ints;\n"  // No value => ints is empty
@@ -3953,7 +6694,7 @@ class TestValueFlow : public TestFixture {
                "  std::array<int,10> ints;\n" // Array size is 10
                "  ints.front();\n"
                "}";
-        ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "ints . front"), 10));
+        ASSERT_EQUALS("values.size():2", isKnownContainerSizeValue(tokenValues(code, "ints . front"), 10)); // uninit value
 
         code = "void f() {\n"
                "  std::string s;\n"
@@ -3968,6 +6709,19 @@ class TestValueFlow : public TestFixture {
                "}";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "s . size"), 3));
 
+        code = "void f(const char* p) {\n"
+               "  if (p == nullptr) return;\n"
+               "  std::string s { p };\n" // size of s is unknown
+               "  s.front();\n"
+               "}";
+        ASSERT(removeSymbolicTok(tokenValues(code, "s . front")).empty());
+
+        code = "void f() {\n"
+               "  std::string s = { 'a', 'b', 'c' };\n" // size of s is 3
+               "  s.size();\n"
+               "}";
+        ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "s . size"), 3));
+
         code = "void f() {\n"
                "  std::string s=\"abc\";\n" // size of s is 3
                "  s += unknown;\n"
@@ -4004,7 +6758,21 @@ class TestValueFlow : public TestFixture {
                "    if (s != \"hello\")\n"
                "        s[40] = c;\n"
                "}";
-        ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "s ["), 5));
+        ASSERT(!isImpossibleContainerSizeValue(tokenValues(code, "s ["), 5).empty());
+
+        code = "void f() {\n"
+               "    static std::string s;\n"
+               "    if (s.size() == 0)\n"
+               "        s = x;\n"
+               "}";
+        ASSERT(tokenValues(code, "s . size").empty());
+
+        code = "void f() {\n"
+               "    const uint8_t data[] = { 1, 2, 3 };\n"
+               "    std::vector<uint8_t> v{ data, data + sizeof(data) };\n"
+               "    v.size();\n"
+               "}";
+        ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "v . size"), 3, false));
 
         // valueFlowContainerForward, loop
         code = "void f() {\n"
@@ -4012,7 +6780,7 @@ class TestValueFlow : public TestFixture {
                "    while (!links.empty() || indentlevel)\n"
                "        links.push(tok);\n"
                "}";
-        ASSERT(tokenValues(code, "links . empty").empty());
+        ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "links . empty"), 0));
 
         // valueFlowContainerForward, function call
         code = "void f() {\n"
@@ -4045,6 +6813,14 @@ class TestValueFlow : public TestFixture {
                "}";
         ASSERT(tokenValues(code, "x . front").empty());
 
+        code = "void g(std::list<int>* const);\n" // #9434
+               "void f() {\n"
+               "  std::list<int> x;\n"
+               "  g(&x);\n"
+               "  x.front();\n"
+               "}";
+        ASSERT(tokenValues(code, "x . front").empty());
+
         code = "void g(const std::list<int>&);\n"
                "void f() {\n"
                "  std::list<int> x;\n"
@@ -4141,7 +6917,35 @@ class TestValueFlow : public TestFixture {
                "    abort() << 123;\n"
                "  ints[0] = 0;\n"
                "}";
-        ASSERT(tokenValues(code, "ints [").empty());
+        ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "ints ["), 0));
+
+        code = "struct A {\n"  // forward, nested function call, #9424
+               "    double getMessage( std::vector<unsigned char> *message );\n"
+               "};\n"
+               "\n"
+               "struct B {\n"
+               "    A *a;\n"
+               "    double getMessage( std::vector<unsigned char> *message ) { return a->getMessage( message ); }\n"
+               "};\n"
+               "\n"
+               "void foo(B *ptr) {\n"
+               "    std::vector<unsigned char> v;\n"
+               "    ptr->getMessage (&v);\n"
+               "    if (v.size () > 0) {}\n" // <- v has unknown size!
+               "}";
+        ASSERT_EQUALS(0U, tokenValues(code, "v . size ( )").size());
+
+        // if
+        code = "bool f(std::vector<int>&) {\n" // #9532
+               "  return false;\n"
+               "}\n"
+               "int g() {\n"
+               "    std::vector<int> v;\n"
+               "    if (f(v) || v.empty())\n"
+               "        return 0;\n"
+               "    return v[0];\n"
+               "}\n";
+        ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "v [ 0 ]"), 0));
 
         // container size => yields
         code = "void f() {\n"
@@ -4162,59 +6966,563 @@ class TestValueFlow : public TestFixture {
                "  x = s + s;\n"
                "}";
         ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "+"), 8));
+
+        code = "void f(const std::vector<int> &ints) {\n"
+               "  ints.clear();\n"
+               "  ints.front();\n"
+               "}";
+        ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "ints . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 0));
+
+        code = "void f(const std::vector<int> &ints) {\n"
+               "  ints.resize(3);\n"
+               "  ints.front();\n"
+               "}";
+        ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "ints . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 3));
+
+        code = "void f(const std::vector<int> &ints) {\n"
+               "  ints.resize(3);\n"
+               "  ints.push_back(3);\n"
+               "  ints.front();\n"
+               "}";
+        ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "ints . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 4));
+
+        code = "void f(const std::vector<int> &ints) {\n"
+               "  ints.resize(3);\n"
+               "  ints.pop_back();\n"
+               "  ints.front();\n"
+               "}";
+        ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "ints . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 2));
+
+        code = "int f(bool b) {\n"
+               "    std::map<int, int> m;\n"
+               "    if (b)\n"
+               "        m[0] = 1;\n"
+               "    return m.at(0);\n"
+               "}\n";
+        ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "m . at", ValueFlow::Value::ValueType::CONTAINER_SIZE), 0));
+
+        code = "struct Base {\n"
+               "    virtual bool GetString(std::string &) const { return false; }\n"
+               "};\n"
+               "int f() {\n"
+               "    std::string str;\n"
+               "    Base *b = GetClass();\n"
+               "    if (!b->GetString(str)) {\n"
+               "        return -2;\n"
+               "    }\n"
+               "    else {\n"
+               "        return str.front();\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(0U, tokenValues(code, "str . front").size());
+
+        code = "void f() {\n"
+               "  std::vector<int> ints{};\n"
+               "  ints.front();\n"
+               "}";
+        ASSERT_EQUALS("",
+                      isKnownContainerSizeValue(tokenValues(code, "ints . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 0));
+
+        code = "void f() {\n"
+               "  std::vector<int> ints{};\n"
+               "  ints.front();\n"
+               "}";
+        ASSERT_EQUALS("",
+                      isKnownContainerSizeValue(tokenValues(code, "ints . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 0));
+
+        code = "void f() {\n"
+               "  std::vector<int> ints{1};\n"
+               "  ints.front();\n"
+               "}";
+        ASSERT_EQUALS("",
+                      isKnownContainerSizeValue(tokenValues(code, "ints . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 1));
+
+        code = "void f() {\n"
+               "  std::vector<int> ints{1};\n"
+               "  std::vector<int> ints2{ints.begin(), ints.end()};\n"
+               "  ints2.front();\n"
+               "}";
+        ASSERT_EQUALS(
+            "", isKnownContainerSizeValue(tokenValues(code, "ints2 . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 1));
+
+        code = "void f() {\n"
+               "  std::vector<int> ints = {};\n"
+               "  ints.front();\n"
+               "}";
+        ASSERT_EQUALS("",
+                      isKnownContainerSizeValue(tokenValues(code, "ints . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 0));
+
+        code = "void f(std::string str) {\n"
+               "    if (str == \"123\")\n"
+               "        bool x = str.empty();\n"
+               "}\n";
+        ASSERT_EQUALS("",
+                      isKnownContainerSizeValue(tokenValues(code, "str . empty", ValueFlow::Value::ValueType::CONTAINER_SIZE), 3));
+
+        code = "int f() {\n"
+               "    std::array<int, 10> a = {};\n"
+               "    return a.front();\n"
+               "}\n";
+        ASSERT_EQUALS("",
+                      isKnownContainerSizeValue(tokenValues(code, "a . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 10));
+
+        code = "int f(const std::vector<int>& x) {\n"
+               "    if (!x.empty() && x[0] == 0)\n"
+               "        return 2;\n"
+               "    return x.front();\n"
+               "}\n";
+        ASSERT_EQUALS("",
+                      isPossibleContainerSizeValue(tokenValues(code, "x . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 0));
+
+        code = "int f(const std::vector<int>& x) {\n"
+               "    if (!(x.empty() || x[0] != 0))\n"
+               "        return 2;\n"
+               "    return x.front();\n"
+               "}\n";
+        ASSERT_EQUALS("",
+                      isPossibleContainerSizeValue(tokenValues(code, "x . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 0));
+
+        code = "int f() {\n"
+               "    const size_t len = 6;\n"
+               "    std::vector<char> v;\n"
+               "    v.resize(1 + len);\n"
+               "    return v.front();\n"
+               "}\n";
+        ASSERT_EQUALS(
+            "",
+            isKnownContainerSizeValue(tokenValues(code, "v . front", ValueFlow::Value::ValueType::CONTAINER_SIZE), 7));
+
+        code = "void f(std::string str) {\n"
+               "    if (str == \"123\") {\n"
+               "        bool x = (str == \"\");\n"
+               "        bool a = x;\n"
+               "     }\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 0));
+
+        code = "void f(std::string str) {\n"
+               "    if (str == \"123\") {\n"
+               "        bool x = (str != \"\");\n"
+               "        bool a = x;\n"
+               "     }\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 1));
+
+        code = "void f(std::string str) {\n"
+               "    if (str == \"123\") {\n"
+               "        bool x = (str == \"321\");\n"
+               "        bool a = x;\n"
+               "     }\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 4U, 1));
+
+        code = "void f(std::string str) {\n"
+               "    if (str == \"123\") {\n"
+               "        bool x = (str != \"321\");\n"
+               "        bool a = x;\n"
+               "     }\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 4U, 0));
+
+        code = "void f(std::string str) {\n"
+               "    if (str.size() == 1) {\n"
+               "        bool x = (str == \"123\");\n"
+               "        bool a = x;\n"
+               "     }\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 0));
+
+        code = "bool f(std::string s) {\n"
+               "    if (!s.empty()) {\n"
+               "        bool x = s == \"0\";\n"
+               "        return x;\n"
+               "    }\n"
+               "    return false;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 4U, 0));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 4U, 1));
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 4U, 0));
+
+        code = "void f() {\n"
+               "    std::vector<int> v;\n"
+               "    int x = v.size();\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 0));
+
+        code = "void f() {\n"
+               "    std::vector<int> v;\n"
+               "    int x = v.empty();\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 1));
+
+        code = "void f() {\n"
+               "    std::vector<int> v;\n"
+               "    int x = std::size(v);\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 0));
+
+        code = "void f() {\n"
+               "    std::vector<int> v;\n"
+               "    int x = std::empty(v);\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 1));
+
+        code = "bool f() {\n"
+               "    std::list<int> x1;\n"
+               "    std::list<int> x2;\n"
+               "    for (int i = 0; i < 10; ++i) {\n"
+               "        std::list<int>& x = (i < 5) ? x1 : x2;\n"
+               "        x.push_back(i);\n"
+               "    }\n"
+               "    return x1.empty() || x2.empty();\n"
+               "}\n";
+        ASSERT_EQUALS("", isInconclusiveContainerSizeValue(tokenValues(code, "x1 . empty", ValueFlow::Value::ValueType::CONTAINER_SIZE), 0));
+        ASSERT_EQUALS("", isInconclusiveContainerSizeValue(tokenValues(code, "x2 . empty", ValueFlow::Value::ValueType::CONTAINER_SIZE), 0));
+
+        code = "std::vector<int> g();\n"
+               "int f(bool b) {\n"
+               "    std::set<int> a;\n"
+               "    std::vector<int> c = g();\n"
+               "    a.insert(c.begin(), c.end());\n"
+               "    return a.size();\n"
+               "}\n";
+        ASSERT_EQUALS(true, tokenValues(code, "a . size", ValueFlow::Value::ValueType::CONTAINER_SIZE).empty());
+
+        code = "void f() {\n" // #14060
+               "    std::stack<std::pair<int, int>> s;\n"
+               "    s.emplace(0, 0);\n"
+               "    s.pop();\n"
+               "    bool x = s.empty();\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 6U, 1));
+
+        code = "std::vector<int> g();\n"
+               "std::vector<int> f() {\n"
+               "    std::vector<int> v = g();\n"
+               "    if (!v.empty()) {\n"
+               "        if (v[0] != 0)\n"
+               "            v.clear();\n"
+               "    }\n"
+               "    if (!v.empty() && v[0] != 0) {}\n"
+               "    return v;\n"
+               "}\n";
+        ASSERT_EQUALS(
+            true,
+            removeImpossible(tokenValues(code, "v [ 0 ] != 0 ) { }", ValueFlow::Value::ValueType::CONTAINER_SIZE)).empty());
+
+        code = "std::vector<int> f() {\n"
+               "    std::vector<int> v;\n"
+               "    v.reserve(1);\n"
+               "    v[1] = 42;\n"
+               "    return v;\n"
+               "}\n";
+        ASSERT_EQUALS(
+            "", isKnownContainerSizeValue(tokenValues(code, "v [", ValueFlow::Value::ValueType::CONTAINER_SIZE), 0));
+
+        code = "void f() {\n"
+               "  std::vector<int> v(3);\n"
+               "  v.size();\n"
+               "}";
+        ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "v . size"), 3));
+
+        code = "void f() {\n"
+               "  std::vector<int> v({ 1, 2, 3 });\n"
+               "  v.size();\n"
+               "}";
+        ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "v . size"), 3));
+
+        code = "int f() {\n"
+               "    std::vector<std::vector<int>> v;\n"
+               "    auto it = v.begin();\n"
+               "    auto x = it->size();\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 5U, 0));
+
+        code = "std::vector<int> g();\n" // #11417
+               "int f() {\n"
+               "    std::vector<int> v{ g() };\n"
+               "    auto x = v.size();\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 5U, 1));
+
+        code = "std::vector<int> g();\n"
+               "int f() {\n"
+               "    std::vector<std::vector<int>> v{ g() };\n"
+               "    auto x = v.size();\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 5U, 1));
+
+        // #11548
+        code = "void f(const std::string& a, const std::string& b) {\n"
+               "  if (a.empty() && b.empty()) {}\n"
+               "  else if (a.empty() == false && b.empty() == false) {}\n"
+               "}\n";
+        ASSERT(!isImpossibleContainerSizeValue(tokenValues(code, "a . empty ( ) == false"), 0).empty());
+
+        code = "bool g(std::vector<int>& v) {\n"
+               "    v.push_back(1);\n"
+               "    int x = v.empty();\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 0));
+
+        code = "std::vector<int> f() { return std::vector<int>(); }";
+        ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "( ) ;"), 0));
+
+        code = "std::vector<int> f() { return std::vector<int>{}; }";
+        ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "{ } ;"), 0));
+
+        code = "std::vector<int> f() { return {}; }";
+        ASSERT_EQUALS("", isKnownContainerSizeValue(tokenValues(code, "{ } ;"), 0));
+
+        code = "int f() { auto a = std::array<int, 2>{}; return a[1]; }";
+        ASSERT_EQUALS("values.size():0", isKnownContainerSizeValue(tokenValues(code, "a ["), 0));
+
+        code = "void g(std::vector<int>* w) {\n"
+               "  std::vector<int> &r = *w;\n"
+               "  r.push_back(0);\n"
+               "}\n"
+               "int f() {\n"
+               "  std::vector<int> v;\n"
+               "  g(&v);\n"
+               "  return v[0];\n"
+               "}\n";
+        ASSERT(!isKnownContainerSizeValue(tokenValues(code, "v ["), 0).empty());
+        ASSERT(!isPossibleContainerSizeValue(tokenValues(code, "v ["), 0).empty());
+
+        code = "template<typename T>\n" // #12052
+               "std::vector<T> g(T);\n"
+               "int f() {\n"
+               "    const std::vector<int> v{ g(3) };\n"
+               "    auto x = v.size();\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 6U, 1));
+
+        code = "template<typename T>\n"
+               "std::vector<T> g(const std::stack<T>& s);\n"
+               "int f() {\n"
+               "    std::stack<int> s{};\n"
+               "    s.push(42);\n"
+               "    s.push(43);\n"
+               "    const std::vector<int> r{ g(s) };\n"
+               "    auto x = r.size();\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 9U, 1));
+
+        code = "int f() {\n" // #12987
+               "    std::string s{\"0\"};\n"
+               "    auto x = s.size();\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 1));
+
+        code = "int f() {\n"
+               "    std::string s;\n"
+               "    s.append(\"0\");\n"
+               "    auto x = s.size();\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 5U, 1));
+
+        code = "int f() {\n"
+               "    std::string s;\n"
+               "    s = std::string(\"0\");\n"
+               "    auto x = s.size();\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 5U, 1));
+
+        code = "std::string f() {\n" // #12993
+               "    std::string a[1];\n"
+               "    a->clear();\n"
+               "    return a[0];\n"
+               "}\n";
+        ASSERT(!isKnownContainerSizeValue(tokenValues(code, "a [ 0"), 0).empty());
+
+        code = "void f(const std::string& a) {\n" // #12994
+               "    std::string b = a + \"123\";\n"
+               "    if (b.empty()) {}\n"
+               "}";
+        ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "b ."), 2));
+
+        code = "void f(const std::string& a) {\n"
+               "    std::string b = \"123\" + a;\n"
+               "    if (b.empty()) {}\n"
+               "}";
+        ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "b ."), 2));
+
+        code = "void f(const std::string& a, const std::string& b) {\n"
+               "    std::string c = a + b + \"123\";\n"
+               "    if (c.empty()) {}\n"
+               "}";
+        ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "c ."), 2));
+
+        code = "void f(const std::string& a) {\n"
+               "    std::string b = a + \"123\" + \"456\";\n"
+               "    if (b.empty()) {}\n"
+               "}";
+        ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "b ."), 5));
+
+        code = "void f(const std::string& a) {\n"
+               "    std::string b = \"123\" + a + \"456\";\n"
+               "    if (b.empty()) {}\n"
+               "}";
+        ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "b ."), 5));
+
+        code = "void f(const std::string& a, const std::string& b) {\n"
+               "    std::string c = \"123\" + a + b;\n"
+               "    if (c.empty()) {}\n"
+               "}";
+        ASSERT_EQUALS("", isImpossibleContainerSizeValue(tokenValues(code, "c ."), 2));
+
+        code = "void f(const std::string& a) {\n"
+               "    std::string s;\n"
+               "    s.append(a);\n"
+               "    if (s.empty()) {}\n"
+               "}";
+        ASSERT_EQUALS("", isPossibleContainerSizeValue(tokenValues(code, "s . empty"), 0));
+
+        code = "int f(const std::string& str) {\n"
+               "    std::istringstream iss(str);\n"
+               "    std::vector<std::string> v{ std::istream_iterator<std::string>(iss), {} };\n"
+               "    auto x = v.size();\n"
+               "    return x;\n"
+               "}";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 5U, 2));
+
+        code = "auto f() {\n" // #13450
+               "    auto v = std::vector<std::vector<S*>>(3, std::vector<S*>());\n"
+               "    return v[2];\n"
+               "}";
+        ASSERT(isKnownContainerSizeValue(tokenValues(code, "v ["), 3).empty());
+
+        code = "auto f() {\n" // #13654
+               "    std::array<uint8_t, 6 * sizeof(uint16_t)> a{};\n"
+               "    return a[0];\n"
+               "}";
+        ASSERT(!isKnownContainerSizeValue(tokenValues(code, "a ["), 6).empty());
+
+        code = "void f(const char a[]) {\n" // #14518
+               "    std::string s(a);\n"
+               "    if (s.empty()) {}\n"
+               "}";
+        ASSERT(!isKnownContainerSizeValue(tokenValues(code, "s ."), 0).empty());
+    }
+
+    void valueFlowContainerElement()
+    {
+        const char* code;
+
+        code = "int f() {\n"
+               "    std::vector<int> v = {1, 2, 3, 4};\n"
+               "    int x = v[1];\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 2));
+
+        code = "int f() {\n"
+               "    std::vector<int> v = {1, 2, 3, 4};\n"
+               "    int x = v.at(1);\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 2));
+
+        code = "int f() {\n"
+               "    std::string s = \"hello\";\n"
+               "    int x = s[1];\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 'e'));
     }
 
     void valueFlowDynamicBufferSize() {
         const char *code;
 
-        LOAD_LIB_2(settings.library, "std.cfg");
-        LOAD_LIB_2(settings.library, "posix.cfg");
+        const Settings settingsOld = settings; // TODO: get rid of this
+        settings = settingsBuilder(settings).library("posix.cfg").library("bsd.cfg").build();
 
         code = "void* f() {\n"
                "  void* x = malloc(10);\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 3U, 10,  ValueFlow::Value::BUFFER_SIZE));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 10,  ValueFlow::Value::ValueType::BUFFER_SIZE));
 
         code = "void* f() {\n"
                "  void* x = calloc(4, 5);\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 3U, 20,  ValueFlow::Value::BUFFER_SIZE));
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, 20,  ValueFlow::Value::ValueType::BUFFER_SIZE));
 
         code = "void* f() {\n"
                "  const char* y = \"abcd\";\n"
                "  const char* x = strdup(y);\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 4U, 5,  ValueFlow::Value::BUFFER_SIZE));
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 5,  ValueFlow::Value::ValueType::BUFFER_SIZE));
 
         code = "void* f() {\n"
                "  void* y = malloc(10);\n"
                "  void* x = realloc(y, 20);\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 4U, 20,  ValueFlow::Value::BUFFER_SIZE));
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 20,  ValueFlow::Value::ValueType::BUFFER_SIZE));
 
         code = "void* f() {\n"
                "  void* y = calloc(10, 4);\n"
                "  void* x = reallocarray(y, 20, 5);\n"
                "  return x;\n"
                "}";
-        ASSERT_EQUALS(true, testValueOfX(code, 4U, 100,  ValueFlow::Value::BUFFER_SIZE));
-    }
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 100,  ValueFlow::Value::ValueType::BUFFER_SIZE));
 
-    void valueFlowSafeFunctionParameterValues() {
-        const char *code;
-        std::list<ValueFlow::Value> values;
-        Settings s;
-        LOAD_LIB_2(s.library, "std.cfg");
-        s.safeChecks.classes = s.safeChecks.externalFunctions = s.safeChecks.internalFunctions = true;
-
-        code = "short f(short x) {\n"
-               "  return x + 0;\n"
+        code = "struct A {};\n" // #14305
+               "void* f() {\n"
+               "  A* x = new A();\n"
+               "  return x;\n"
                "}";
-        values = tokenValues(code, "+", &s);
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 1, ValueFlow::Value::ValueType::BUFFER_SIZE));
+
+        code = "struct A {};\n"
+               "void* f() {\n"
+               "  void* x = new A;\n"
+               "  return x;\n"
+               "}";
+        {
+            auto values = tokenValues(code, "x ; }");
+            ASSERT_EQUALS(1, values.size());
+            ASSERT(values.front().isSymbolicValue());
+            // TODO: add BUFFER_SIZE value = 1
+        }
+
+        code = "struct B { int32_t i; };\n"
+               "void* f() {\n"
+               "  B* x = new B();\n"
+               "  return x;\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 4, ValueFlow::Value::ValueType::BUFFER_SIZE));
+
+        settings = settingsOld;
+    }
+
+    void valueFlowSafeFunctionParameterValues() {
+        const char *code;
+        std::list<ValueFlow::Value> values;
+        /*const*/ Settings s = settingsBuilder().library("std.cfg").build();
+        s.safeChecks.classes = s.safeChecks.externalFunctions = s.safeChecks.internalFunctions = true;
+
+        code = "short f(short x) {\n"
+               "  return x + 0;\n"
+               "}";
+        values = removeSymbolicTok(tokenValues(code, "+", &s));
         ASSERT_EQUALS(2, values.size());
         ASSERT_EQUALS(-0x8000, values.front().intvalue);
         ASSERT_EQUALS(0x7fff, values.back().intvalue);
@@ -4238,7 +7546,7 @@ class TestValueFlow : public TestFixture {
         code = "short f(__cppcheck_low__(0) __cppcheck_high__(100) short x) {\n"
                "  return x + 0;\n"
                "}";
-        values = tokenValues(code, "+", &s);
+        values = removeSymbolicTok(tokenValues(code, "+", &s));
         ASSERT_EQUALS(2, values.size());
         ASSERT_EQUALS(0, values.front().intvalue);
         ASSERT_EQUALS(100, values.back().intvalue);
@@ -4246,18 +7554,28 @@ class TestValueFlow : public TestFixture {
         code = "unsigned short f(unsigned short x) [[expects: x <= 100]] {\n"
                "  return x + 0;\n"
                "}";
-        values = tokenValues(code, "+", &s);
+        values = removeSymbolicTok(tokenValues(code, "+", &s));
+        values.remove_if([](const ValueFlow::Value& v) {
+            return v.isImpossible();
+        });
         ASSERT_EQUALS(2, values.size());
         ASSERT_EQUALS(0, values.front().intvalue);
         ASSERT_EQUALS(100, values.back().intvalue);
     }
 
-
     void valueFlowUnknownFunctionReturn() {
+        const char code[] = "template <typename T>\n" // #13409
+                            "struct S {\n"
+                            "    std::max_align_t T::* m;\n"
+                            "    S(std::max_align_t T::* p) : m(p) {}\n"
+                            "};\n";
+        (void)valueOfTok(code, ":"); // don't crash
+    }
+
+    void valueFlowUnknownFunctionReturnRand() {
         const char *code;
         std::list<ValueFlow::Value> values;
-        Settings s;
-        LOAD_LIB_2(s.library, "std.cfg");
+        /*const*/ Settings s = settingsBuilder().library("std.cfg").build();
         s.checkUnknownFunctionReturn.insert("rand");
 
         code = "x = rand();";
@@ -4267,6 +7585,18 @@ class TestValueFlow : public TestFixture {
         ASSERT_EQUALS(INT_MAX, values.back().intvalue);
     }
 
+    void valueFlowUnknownFunctionReturnMalloc() { // #4626
+        const char *code;
+
+        code = "ptr = malloc(10);";
+        const auto& values = tokenValues(code, "(");
+        ASSERT_EQUALS(1, values.size());
+        ASSERT_EQUALS(true, values.front().isIntValue());
+        ASSERT_EQUALS(true, values.front().isPossible());
+        ASSERT_EQUALS(0, values.front().intvalue);
+    }
+
+
     void valueFlowPointerAliasDeref() {
         const char* code;
 
@@ -4278,6 +7608,1649 @@ class TestValueFlow : public TestFixture {
                "}\n";
         ASSERT_EQUALS(true, testValueOfX(code, 5U, 123));
     }
+
+    void valueFlowCrashIncompleteCode() {
+        const char* code;
+
+        code = "void SlopeFloor::setAttr(const Value &val) {\n"
+               "    int x = val;\n"
+               "    if (x >= -1)\n"
+               "        state = x;\n"
+               "}\n";
+        (void)valueOfTok(code, "=");
+
+        code = "void a() {\n"
+               "  auto b = [b = 0] {\n"
+               "    if (b) {\n"
+               "    }\n"
+               "  };\n"
+               "}\n";
+        (void)valueOfTok(code, "0");
+
+        code = "namespace juce {\n"
+               "PopupMenu::Item& PopupMenu::Item::operator= (Item&&) = default;\n"
+               "PopupMenu::Options withDeletionCheck (Component& comp) const {\n"
+               "    Options o (*this);\n"
+               "    o.componentToWatchForDeletion = &comp;\n"
+               "    o.isWatchingForDeletion = true;\n"
+               "    return o;\n"
+               "}}\n";
+        (void)valueOfTok(code, "return");
+
+        code = "class dummy_resource : public instrument_resource {\n"
+               "public:\n"
+               "    int reads;\n"
+               "    static std::list<int> log;\n"
+               "};\n"
+               "void dummy_reader_reset() {\n"
+               "    dummy_resource::log.clear();\n"
+               "}\n";
+        (void)valueOfTok(code, "log");
+
+        code = "struct D : B<int> {\n"
+               "    D(int i, const std::string& s) : B<int>(i, s) {}\n"
+               "};\n"
+               "template<> struct B<int>::S {\n"
+               "    int j;\n"
+               "};\n";
+        (void)valueOfTok(code, "B");
+
+        code = "void f(int& r) {\n" // #13515
+               "    [0].p = &r;\n"
+               "}\n";
+        (void)valueOfTok(code, "=");
+    }
+
+    void valueFlowCrash() {
+        const char* code;
+
+        code = "void f(int x) {\n"
+               "    if (0 * (x > 2)) {}\n"
+               "}\n";
+        (void)valueOfTok(code, "x");
+
+        code = "struct a {\n"
+               "  void b();\n"
+               "};\n"
+               "void d(std::vector<a> c) {\n"
+               "  a *e;\n"
+               "  for (auto &child : c)\n"
+               "    e = &child;\n"
+               "  (*e).b();\n"
+               "}\n";
+        (void)valueOfTok(code, "e");
+
+        code = "const int& f(int, const int& y = 0);\n"
+               "const int& f(int, const int& y) {\n"
+               "    return y;\n"
+               "}\n"
+               "const int& g(int x) {\n"
+               "    const int& r = f(x);\n"
+               "    return r;\n"
+               "}\n";
+        (void)valueOfTok(code, "0");
+
+        code = "void fa(int &colors) {\n"
+               "  for (int i = 0; i != 6; ++i) {}\n"
+               "}\n"
+               "void fb(not_null<int*> parent, int &&colors2) {\n"
+               "  dostuff(1);\n"
+               "}\n";
+        (void)valueOfTok(code, "x");
+
+        code = "void a() {\n"
+               "  static int x = 0;\n"
+               "  struct c {\n"
+               "    c(c &&) { ++x; }\n"
+               "  };\n"
+               "}\n";
+        (void)valueOfTok(code, "x");
+
+        code = "void f(){\n"
+               "      struct dwarf_data **pp;\n"
+               "      for (pp = (struct dwarf_data **) (void *) &state->fileline_data;\n"
+               "       *pp != NULL;\n"
+               "       pp = &(*pp)->next)\n"
+               "    ;\n"
+               "}\n";
+        (void)valueOfTok(code, "x");
+
+        code = "void *foo(void *x);\n"
+               "void *foo(void *x)\n"
+               "{\n"
+               "    if (!x)\n"
+               "yes:\n"
+               "        return &&yes;\n"
+               "    return x;\n"
+               "}\n";
+        (void)valueOfTok(code, "x");
+
+        code = "void f() {\n"
+               "    std::string a = b[c->d()];\n"
+               "    if(a.empty()) {\n"
+               "        INFO(std::string{\"a\"} + c->d());\n"
+               "        INFO(std::string{\"b\"} + a);\n"
+               "    }\n"
+               "}\n";
+        (void)valueOfTok(code, "a");
+
+        code = "class A{\n"
+               "  void f() {\n"
+               "    std::string c{s()};\n"
+               "  }\n"
+               "  std::string s() {\n"
+               "    return \"\";\n"
+               "  }\n"
+               "};\n";
+        (void)valueOfTok(code, "c");
+
+        code = "void f() {\n"
+               "   char* p = 0;\n"
+               "   int pi =\n"
+               "     p == \"a\" ? 1 : p == \"a\" ? 1 : p == \"a\" ? 1 : p == \"a\" ? 1 : p == \"a\" ? 1 \n"
+               "   : p == \"a\" ? 1 : p == \"a\" ? 1 : p == \"a\" ? 1 : p == \"a\" ? 1 : p == \"a\" ? 1 \n"
+               "   : p == \"a\" ? 1 : p == \"a\" ? 1 : p == \"a\" ? 1 : p == \"a\" ? 1 : p == \"a\" ? 1 \n"
+               "   : p == \"a\" ? 1 : p == \"a\" ? 1 : p == \"a\" ? 1 : p == \"a\" ? 1 : p == \"a\" ? 1 \n"
+               "   : p == \"a\" ? 1 : p == \"a\" ? 1 : p == \"a\" ? 1 : p == \"a\" ? 1 : p == \"a\" ? 1 \n"
+               "   : 0;\n"
+               "   int *i2 = 0;\n"
+               "   if (i2) { }\n"
+               "}\n";
+        (void)valueOfTok(code, "p");
+
+        code = "struct a;\n"
+               "namespace e {\n"
+               "struct f {\n"
+               "  struct g {\n"
+               "    enum {} h;\n"
+               "    int arg;\n"
+               "  };\n"
+               "  std::vector<g> i;\n"
+               "};\n"
+               "} // namespace e\n"
+               "void fn1() {\n"
+               "  std::vector<a *> arguments;\n"
+               "  e::f b;\n"
+               "  for (e::f::g c : b.i)\n"
+               "    if (c.h)\n"
+               "      a *const d = arguments[c.arg];\n"
+               "}\n";
+        (void)valueOfTok(code, "c");
+
+        code = "void h(char* p, int s) {\n"
+               "  char *q = p+s;\n"
+               "  char buf[100];\n"
+               "  char *b = buf;\n"
+               "  ++b;\n"
+               "  if (p < q && buf < b)\n"
+               "    diff = (buf-b);\n"
+               "}\n";
+        (void)valueOfTok(code, "diff");
+
+        code = "void foo() {\n" // #10462
+               "  std::tuple<float, float, float, float> t4(5.2f, 3.1f, 2.4f, 9.1f), t5(4, 6, 9, 27);\n"
+               "  t4 = t5;\n"
+               "  ASSERT(!(t4 < t5) && t4 <= t5);\n"
+               "}";
+        (void)valueOfTok(code, "<=");
+
+        code = "void f() {\n"
+               "    unsigned short Xoff = 10;\n"
+               "    unsigned short Nx = 0;\n"
+               "    int last;\n"
+               "    do {\n"
+               "        last = readData(0);\n"
+               "        if (last && (last - Xoff < Nx))\n"
+               "            Nx = last - Xoff;\n"
+               "    } while (last > 0);\n"
+               "}\n";
+        (void)valueOfTok(code, "last");
+
+        code = "struct a {\n"
+               "  void clear();\n"
+               "  int b();\n"
+               "};\n"
+               "struct d {\n"
+               "  void c(int);\n"
+               "  decltype(auto) f() { c(0 != e.b()); }\n"
+               "  a e;\n"
+               "};\n"
+               "void d::c(int) { e.clear(); }\n";
+        (void)valueOfTok(code, "e");
+
+        code = "struct a {\n"
+               "  int b;\n"
+               "  int c;\n"
+               "} f;\n"
+               "unsigned g;\n"
+               "struct {\n"
+               "  a d;\n"
+               "} e;\n"
+               "void h() {\n"
+               "  if (g && f.c)\n"
+               "    e.d.b = g - f.c;\n"
+               "}\n";
+        (void)valueOfTok(code, "e");
+
+        code = "struct a {\n"
+               "  std::vector<a> b;\n"
+               "  void c(unsigned d) {\n"
+               "    size_t e = 0;\n"
+               "    size_t f = 0;\n"
+               "    for (auto child : b) {\n"
+               "      f = e;\n"
+               "      e = d - f;\n"
+               "    }\n"
+               "  }\n"
+               "};\n";
+        (void)valueOfTok(code, "e");
+
+        code = "struct a {\n"
+               "  struct b {\n"
+               "    std::unique_ptr<a> c;\n"
+               "  };\n"
+               "  void d(int, void *);\n"
+               "  void e() {\n"
+               "    d(0, [f = b{}] { return f.c.get(); }());\n"
+               "  }\n"
+               "  void g() {\n"
+               "    if (b *h = 0)\n"
+               "      h->c.get();\n"
+               "  }\n"
+               "};\n";
+        (void)valueOfTok(code, "f.c");
+
+        code = "void d(fmpz_t a, fmpz_t b) {\n"
+               "  if (fmpz_sgn(0)) {}\n"
+               "  else if (b) {}\n"
+               "}\n"
+               "void e(psl2z_t f) {\n"
+               "  f->b;\n"
+               "  d(&f->a, c);\n"
+               "}\n";
+        (void)valueOfTok(code, "f");
+
+        code = "struct bo {\n"
+               "  int b, c, a, d;\n"
+               "  char e, g, h, i, aa, j, k, l, m, n, o, p, q, r, t, u, v, w, x, y;\n"
+               "  long z, ab, ac, ad, f, ae, af, ag, ah, ai, aj, ak, al, am, an, ao, ap, aq, ar,\n"
+               "      as;\n"
+               "  short at, au, av, aw, ax, ay, az, ba, bb, bc, bd, be, bf, bg, bh, bi, bj, bk,\n"
+               "      bl, bm;\n"
+               "};\n"
+               "char bn;\n"
+               "void bp() {\n"
+               "  bo s;\n"
+               "  if (bn)\n"
+               "    return;\n"
+               "  s;\n"
+               "}\n";
+        (void)valueOfTok(code, "s");
+
+        code = "int f(int value) { return 0; }\n"
+               "std::shared_ptr<Manager> g() {\n"
+               "    static const std::shared_ptr<Manager> x{ new M{} };\n"
+               "    return x;\n"
+               "}\n";
+        (void)valueOfTok(code, "x");
+
+        code = "int* g();\n"
+               "void f() {\n"
+               "    std::cout << (void*)(std::shared_ptr<int>{ g() }.get());\n"
+               "}\n";
+        (void)valueOfTok(code, ".");
+
+        code = "class T;\n"
+               "struct S {\n"
+               "    void f(std::array<T*, 2>& a);\n"
+               "};\n";
+        (void)valueOfTok(code, "a");
+
+        code = "void f(const char * const x) { !!system(x); }\n";
+        (void)valueOfTok(code, "x");
+
+        code = "struct struct1 {\n"
+               "    int i1;\n"
+               "    int i2;\n"
+               "};\n"
+               "struct struct2 {\n"
+               "    char c1;\n"
+               "    struct1 is1;\n"
+               "    char c2[4];\n"
+               "};\n"
+               "void f() {\n"
+               "    struct2 a = { 1, 2, 3, {4,5,6,7} }; \n"
+               "}\n";
+        (void)valueOfTok(code, "a");
+
+        code = "void setDeltas(int life, int age, int multiplier) {\n"
+               "    int dx = 0;\n"
+               "    int dy = 0;\n"
+               "    if (age <= 2 || life < 4) {\n"
+               "        dy = 0;\n"
+               "        dx = (rand() % 3) - 1;\n"
+               "    }\n"
+               "    else if (age < (multiplier * 3)) {\n"
+               "        if (age % (int) (multiplier * 0.5) == 0) dy = -1;\n"
+               "        else dy = 0;\n"
+               "    }\n"
+               "}\n";
+        (void)valueOfTok(code, "age");
+
+        code = "void a() {\n"
+               "  struct b {\n"
+               "    int d;\n"
+               "  };\n"
+               "  for (b c : {b{}, {}}) {}\n"
+               "}\n";
+        (void)valueOfTok(code, "c");
+
+        code = "class T {\n"
+               "private:\n"
+               "    void f() { D& r = dynamic_cast<D&>(*m); }\n"
+               "    void g() { m.reset(new D); }\n"
+               "private:\n"
+               "    std::shared_ptr<B> m;\n"
+               "};\n";
+        (void)valueOfTok(code, "r");
+
+        code = "void g(int);\n"
+               "void f(int x, int y) {\n"
+               "    g(x < y ? : 1);\n"
+               "};\n";
+        (void)valueOfTok(code, "?");
+
+        code = "struct C {\n"
+               "    explicit C(bool);\n"
+               "    operator bool();\n"
+               "};\n"
+               "void f(bool b) {\n"
+               "    const C& c = C(b) ? : C(false);\n"
+               "};\n";
+        (void)valueOfTok(code, "?");
+
+        code = "struct S {\n"
+               "    void g(std::vector<int> (*f) () = nullptr);\n"
+               "};\n";
+        (void)valueOfTok(code, "=");
+
+        code = "void f(bool b) {\n" // #11627
+               "    (*printf)(\"%s %i\", strerror(errno), b ? 0 : 1);\n"
+               "};\n";
+        (void)valueOfTok(code, "?");
+
+        code = "void f(int i) {\n" // #11914
+               "    int& r = i;\n"
+               "    int& q = (&r)[0];\n"
+               "}\n";
+        (void)valueOfTok(code, "&");
+
+        code = "bool a(int *);\n"
+               "void fn2(int b) {\n"
+               "  if (b) {\n"
+               "    bool c, d, e;\n"
+               "    if (c && d)\n"
+               "      return;\n"
+               "    if (e && a(&b)) {\n"
+               "    }\n"
+               "  }\n"
+               "}\n";
+        (void)valueOfTok(code, "e");
+
+        code = "void f(int a, int b, int c) {\n"
+               "  if (c && (a || a && b))\n"
+               "    if (a && b) {}\n"
+               "}\n";
+        (void)valueOfTok(code, "a");
+
+        code = "void g(const char* fmt, ...);\n" // #12255
+               "void f(const char* fmt, const char* msg) {\n"
+               "    const char* p = msg;\n"
+               "    g(\"%s\", msg);\n"
+               "}\n"
+               "void g(const char* fmt, ...) {\n"
+               "    const char* q = fmt;\n"
+               "    if (*q > 0 && *q < 100) {}\n"
+               "}\n";
+        (void)valueOfTok(code, "&&");
+
+        code = "void f() { int& a = *&a; }\n"; // #12511
+        (void)valueOfTok(code, "=");
+
+        code = "void g(int*);\n" // #12716
+               "void f(int a) {\n"
+               "    do {\n"
+               "        if (a)\n"
+               "            break;\n"
+               "        g((int[256]) { 0 });\n"
+               "    } while (true);\n"
+               "}\n";
+        (void)valueOfTok(code, "0");
+
+        code = "bool f() {\n"
+               "    return (!std::is_reference<decltype(a)>::value);\n"
+               "}\n";
+        (void)valueOfTok(code, "0");
+
+        code = "struct S { int a; };\n" // #14036
+               "template <typename T>\n"
+               "struct U {\n"
+               "    U() = default;\n"
+               "    U(int i, int* p) {\n"
+               "        m = new T(i, p);\n"
+               "    }\n"
+               "    T m;\n"
+               "};\n"
+               "U<S*> u;\n";
+        (void)valueOfTok(code, "new");
+
+        code = "void f() {\n" // #14287
+               "    auto a = { \"1\" };\n"
+               "    auto b = a;\n"
+               "}\n";
+        (void)valueOfTok(code, "b");
+    }
+
+    void valueFlowHang() {
+        const char* code;
+        // #9659
+        code = "float arr1[4][4] = {0.0};\n"
+               "float arr2[4][4] = {0.0};\n"
+               "void f() {\n"
+               "    if(arr1[0][0] == 0.0 &&\n"
+               "       arr1[0][1] == 0.0 &&\n"
+               "       arr1[0][2] == 0.0 &&\n"
+               "       arr1[0][3] == 0.0 &&\n"
+               "       arr1[1][0] == 0.0 &&\n"
+               "       arr1[1][1] == 0.0 &&\n"
+               "       arr1[1][2] == 0.0 &&\n"
+               "       arr1[1][3] == 0.0 &&\n"
+               "       arr1[2][0] == 0.0 &&\n"
+               "       arr1[2][1] == 0.0 &&\n"
+               "       arr1[2][2] == 0.0 &&\n"
+               "       arr1[2][3] == 0.0 &&\n"
+               "       arr1[3][0] == 0.0 &&\n"
+               "       arr1[3][1] == 0.0 &&\n"
+               "       arr1[3][2] == 0.0 &&\n"
+               "       arr1[3][3] == 0.0 &&\n"
+               "       arr2[0][0] == 0.0 &&\n"
+               "       arr2[0][1] == 0.0 &&\n"
+               "       arr2[0][2] == 0.0 &&\n"
+               "       arr2[0][3] == 0.0 &&\n"
+               "       arr2[1][0] == 0.0 &&\n"
+               "       arr2[1][1] == 0.0 &&\n"
+               "       arr2[1][2] == 0.0 &&\n"
+               "       arr2[1][3] == 0.0 &&\n"
+               "       arr2[2][0] == 0.0 &&\n"
+               "       arr2[2][1] == 0.0 &&\n"
+               "       arr2[2][2] == 0.0 &&\n"
+               "       arr2[2][3] == 0.0 &&\n"
+               "       arr2[3][0] == 0.0 &&\n"
+               "       arr2[3][1] == 0.0 &&\n"
+               "       arr2[3][2] == 0.0 &&\n"
+               "       arr2[3][3] == 0.0\n"
+               "       ) {}\n"
+               "}\n";
+        (void)valueOfTok(code, "x");
+
+        code = "namespace {\n"
+               "struct a {\n"
+               "  a(...) {}\n"
+               "  a(std::initializer_list<std::pair<int, std::vector<std::vector<a>>>>) {}\n"
+               "} b{{0, {{&b, &b, &b, &b}}},\n"
+               "    {0,\n"
+               "     {{&b, &b, &b, &b, &b, &b, &b, &b, &b, &b},\n"
+               "      {{&b, &b, &b, &b, &b, &b, &b}}}},\n"
+               "    {0,\n"
+               "     {{&b, &b, &b, &b, &b, &b, &b, &b, &b, &b, &b, &b, &b, &b},\n"
+               "      {&b, &b, &b, &b, &b, &b, &b, &b, &b, &b, &b}}}};\n"
+               "}\n";
+        (void)valueOfTok(code, "x");
+
+        code = "namespace {\n"
+               "struct a {\n"
+               "  a(...) {}\n"
+               "  a(std::initializer_list<std::pair<int, std::vector<std::vector<a>>>>) {}\n"
+               "} b{{0, {{&b}}},\n"
+               "    {0, {{&b}}},\n"
+               "    {0, {{&b}}},\n"
+               "    {0, {{&b}}},\n"
+               "    {0, {{&b}, {&b, &b, &b, &b, &b, &b, &b, &b, &b, &b, {&b}}}},\n"
+               "    {0,\n"
+               "     {{&b},\n"
+               "      {&b, &b, &b, &b, &b, &b, &b, &b, &b, &b, &b, &b, &b, &b, &b, &b, &b, &b,\n"
+               "       &b}}}};\n"
+               "}\n";
+        (void)valueOfTok(code, "x");
+
+        code = "int &a(int &);\n"
+               "int &b(int &);\n"
+               "int &c(int &);\n"
+               "int &d(int &e) {\n"
+               "  if (!e)\n"
+               "    return a(e);\n"
+               "  if (e > 0)\n"
+               "    return b(e);\n"
+               "  if (e < 0)\n"
+               "    return c(e);\n"
+               "  return e;\n"
+               "}\n"
+               "int &a(int &e) { \n"
+               "  if (!e)\n"
+               "    return d(e); \n"
+               "  if (e > 0)\n"
+               "    return b(e);\n"
+               "  if (e < 0)\n"
+               "    return c(e);\n"
+               "  return e;\n"
+               "}\n"
+               "int &b(int &e) { \n"
+               "  if (!e)\n"
+               "    return a(e); \n"
+               "  if (e > 0)\n"
+               "    return c(e);\n"
+               "  if (e < 0)\n"
+               "    return d(e);\n"
+               "  return e;\n"
+               "}\n"
+               "int &c(int &e) { \n"
+               "  if (!e)\n"
+               "    return a(e); \n"
+               "  if (e > 0)\n"
+               "    return b(e);\n"
+               "  if (e < 0)\n"
+               "    return d(e);\n"
+               "  return e;\n"
+               "}\n";
+        (void)valueOfTok(code, "x");
+
+        code = "void a() {\n"
+               "  int b = 0;\n"
+               "  do {\n"
+               "    for (;;)\n"
+               "      break;\n"
+               "  } while (b < 1);\n"
+               "}\n";
+        (void)valueOfTok(code, "b");
+
+        code = "void ParseEvent(tinyxml2::XMLDocument& doc, std::set<Item*>& retItems) {\n"
+               "    auto ParseAddItem = [&](Item* item) {\n"
+               "        return retItems.insert(item).second;\n"
+               "    };\n"
+               "    tinyxml2::XMLElement *root = doc.RootElement();\n"
+               "    for (auto *el = root->FirstChildElement(\"Result\"); el && !ParseAddItem(GetItem(el)); el = el->NextSiblingElement(\"Result\")) ;\n"
+               "    for (auto *el = root->FirstChildElement(\"Result\"); el && !ParseAddItem(GetItem(el)); el = el->NextSiblingElement(\"Result\")) ;\n"
+               "    for (auto *el = root->FirstChildElement(\"Result\"); el && !ParseAddItem(GetItem(el)); el = el->NextSiblingElement(\"Result\")) ;\n"
+               "    for (auto *el = root->FirstChildElement(\"Result\"); el && !ParseAddItem(GetItem(el)); el = el->NextSiblingElement(\"Result\")) ;\n"
+               "    for (auto *el = root->FirstChildElement(\"Result\"); el && !ParseAddItem(GetItem(el)); el = el->NextSiblingElement(\"Result\")) ;\n"
+               "    for (auto *el = root->FirstChildElement(\"Result\"); el && !ParseAddItem(GetItem(el)); el = el->NextSiblingElement(\"Result\")) ;\n"
+               "    for (auto *el = root->FirstChildElement(\"Result\"); el && !ParseAddItem(GetItem(el)); el = el->NextSiblingElement(\"Result\")) ;\n"
+               "    for (auto *el = root->FirstChildElement(\"Result\"); el && !ParseAddItem(GetItem(el)); el = el->NextSiblingElement(\"Result\")) ;\n"
+               "    for (auto *el = root->FirstChildElement(\"Result\"); el && !ParseAddItem(GetItem(el)); el = el->NextSiblingElement(\"Result\")) ;\n"
+               "    for (auto *el = root->FirstChildElement(\"Result\"); el && !ParseAddItem(GetItem(el)); el = el->NextSiblingElement(\"Result\")) ;\n"
+               "    for (auto *el = root->FirstChildElement(\"Result\"); el && !ParseAddItem(GetItem(el)); el = el->NextSiblingElement(\"Result\")) ;\n"
+               "    for (auto *el = root->FirstChildElement(\"Result\"); el && !ParseAddItem(GetItem(el)); el = el->NextSiblingElement(\"Result\")) ;\n"
+               "    for (auto *el = root->FirstChildElement(\"Result\"); el && !ParseAddItem(GetItem(el)); el = el->NextSiblingElement(\"Result\")) ;\n"
+               "    for (auto *el = root->FirstChildElement(\"Result\"); el && !ParseAddItem(GetItem(el)); el = el->NextSiblingElement(\"Result\")) ;\n"
+               "    for (auto *el = root->FirstChildElement(\"Result\"); el && !ParseAddItem(GetItem(el)); el = el->NextSiblingElement(\"Result\")) ;\n"
+               "}\n";
+        (void)valueOfTok(code, "root");
+
+        code = "bool isCharPotentialOperator(char ch)  {\n"
+               "    return (ispunct((unsigned char) ch)\n"
+               "            && ch != '{' && ch != '}'\n"
+               "            && ch != '(' && ch != ')'\n"
+               "            && ch != '[' && ch != ']'\n"
+               "            && ch != ';' && ch != ','\n"
+               "            && ch != '#' && ch != '\\\\'\n"
+               "            && ch != '\\\'' && ch != '\\\"');\n"
+               "}\n";
+        (void)valueOfTok(code, "return");
+
+        code = "void heapSort() {\n"
+               "    int n = m_size;\n"
+               "    while (n >= 1) {\n"
+               "        swap(0, n - 1);\n"
+               "    }\n"
+               "}\n";
+        (void)valueOfTok(code, "swap");
+
+        code = "double a;\n"
+               "int b, c, d, e, f, g;\n"
+               "void h() { double i, j = i = g = f = e = d = c = b = a; }\n";
+        (void)valueOfTok(code, "a");
+
+        code = "double a, c;\n"
+               "double *b;\n"
+               "void d() {\n"
+               "  double e, f, g, h = g = f = e = c = a;\n"
+               "  b[8] = a;\n"
+               "  b[1] = a;\n"
+               "  a;\n"
+               "}\n";
+        (void)valueOfTok(code, "a");
+
+        code = "void f(int i, int j, int n) {\n"
+               "    if ((j == 0) != (i == 0)) {}\n"
+               "    int t = 0;\n"
+               "    if (j > 0) {\n"
+               "        t = 1;\n"
+               "        if (n < j)\n"
+               "            n = j;\n"
+               "    }\n"
+               "}\n";
+        (void)valueOfTok(code, "i");
+
+        code = "void f() {\n" // #11701
+               "    std::vector<int> v(500);\n"
+               "    for (int i = 0; i < 500; i++) {\n"
+               "        if (i < 122)\n"
+               "            v[i] = 255;\n"
+               "        else if (i == 122)\n"
+               "            v[i] = 220;\n"
+               "        else if (i < 386)\n"
+               "            v[i] = 196;\n"
+               "        else if (i == 386)\n"
+               "            v[i] = 118;\n"
+               "        else\n"
+               "            v[i] = 0;\n"
+               "    }\n"
+               "}\n";
+        (void)valueOfTok(code, "i");
+
+        code = "void f() {\n"
+               "    if (llabs(0x80000000ffffffffL) == 0x7fffffff00000001L) {}\n"
+               "}\n";
+        (void)valueOfTok(code, "f");
+
+        code = "struct T {\n"
+               "    T();\n"
+               "    static T a[6][64];\n"
+               "    static T b[2][64];\n"
+               "    static T c[64][64];\n"
+               "    static T d[2][64];\n"
+               "    static T e[64];\n"
+               "    static T f[64];\n"
+               "};\n";
+        (void)valueOfTok(code, "(");
+    }
+
+    void valueFlowCrashConstructorInitialization() { // #9577
+        const char* code;
+        code = "void Error()\n"
+               "{\n"
+               "    VfsPath path(\"\");\n"
+               "    path = path / amtype;\n"
+               "    size_t base = 0;\n"
+               "    VfsPath standard(\"standard\");\n"
+               "    if (path != standard)\n"
+               "    {\n"
+               "    }\n"
+               "}";
+        (void)valueOfTok(code, "path");
+
+        code = "void Error()\n"
+               "{\n"
+               "    VfsPath path;\n"
+               "    path = path / amtype;\n"
+               "    size_t base = 0;\n"
+               "    VfsPath standard(\"standard\");\n"
+               "    if (path != standard)\n"
+               "    {\n"
+               "    }\n"
+               "}";
+        (void)valueOfTok(code, "path");
+
+        code = "struct S {\n"
+               "    std::string to_string() const {\n"
+               "        return { this->p , (size_t)this->n };\n"
+               "    }\n"
+               "    const char* p;\n"
+               "    int n;\n"
+               "};\n"
+               "void f(S s, std::string& str) {\n"
+               "    str += s.to_string();\n"
+               "}\n";
+        (void)valueOfTok(code, "s");
+
+        code = "void a(int e, int d, int c, int h) {\n"
+               "  std::vector<int> b;\n"
+               "  std::vector<int> f;\n"
+               "  if (b == f && h)\n"
+               "    return;\n"
+               "  if (b == f && b == f && c && e < d) {}\n"
+               "}\n";
+        (void)valueOfTok(code, "b");
+    }
+
+    void valueFlowUnknownMixedOperators() {
+        const char *code= "int f(int a, int b, bool x) {\n"
+                          "  if (a == 1 && (!(b == 2 && x))) {\n"
+                          "  } else {\n"
+                          "    if (x) {\n"
+                          "    }\n"
+                          "  }\n"
+                          "\n"
+                          "  return 0;\n"
+                          "}";
+
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 4U, 1));
+    }
+
+    void valueFlowSolveExpr()
+    {
+        const char* code;
+        code = "int f(int x) {\n"
+               "    if ((64 - x) == 8)\n"
+               "        return x;\n"
+               "    return 0;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 3U, 56));
+
+        code = "int f(int x) {\n"
+               "    if ((x - 64) == 8)\n"
+               "        return x;\n"
+               "    return 0;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 3U, 72));
+
+        code = "int f(int x) {\n"
+               "    if ((x - 64) == 8)\n"
+               "        return x;\n"
+               "    return 0;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 3U, 72));
+
+        code = "int f(int x) {\n"
+               "    if ((x + 64) == 8)\n"
+               "        return x;\n"
+               "    return 0;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 3U, -56));
+
+        code = "int f(int x) {\n"
+               "    if ((x * 2) == 8)\n"
+               "        return x;\n"
+               "    return 0;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 3U, 4));
+
+        code = "int f(int x) {\n"
+               "    if ((x ^ 64) == 8)\n"
+               "        return x;\n"
+               "    return 0;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 3U, 72));
+
+        code = "int f(int i) {\n"
+               "    int j = i + 64;\n"
+               "    int x = j;\n"
+               "    return x;\n"
+               "}\n";
+        TODO_ASSERT_EQUALS(true, false, testValueOfXKnown(code, 4U, "i", 64));
+    }
+
+    void valueFlowIdempotent() {
+        const char *code;
+
+        code = "void f(bool a, bool b) {\n"
+               "    bool x = true;\n"
+               "    if (a)\n"
+               "        x = x && b;\n"
+               "    bool result = x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 5U, 1));
+
+        code = "void f(bool a, bool b) {\n"
+               "    bool x = false;\n"
+               "    if (a)\n"
+               "        x = x && b;\n"
+               "    bool result = x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 5U, 0));
+
+        code = "void f(bool a, bool b) {\n"
+               "    bool x = true;\n"
+               "    if (a)\n"
+               "        x = x || b;\n"
+               "    bool result = x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 5U, 1));
+
+        code = "void f(bool a, bool b) {\n"
+               "    bool x = false;\n"
+               "    if (a)\n"
+               "        x = x || b;\n"
+               "    bool result = x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 5U, 0));
+
+        code = "void foo() {\n"
+               "    int x = 0;\n"
+               "    for (int i = 0; i < 5; i++) {\n"
+               "        int y = 0;\n"
+               "        for (int j = 0; j < 10; j++)\n"
+               "            y++;\n"
+               "        if (y >= x)\n"
+               "            x = y;\n"
+               "    }\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 10U, 0));
+    }
+
+    void valueFlowUnsigned() {
+        const char *code;
+
+        code = "auto f(uint32_t i) {\n"
+               "    auto x = i;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, -1));
+
+        code = "auto f(uint32_t i) {\n"
+               "    auto x = (int32_t)i;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 3U, -1));
+
+        code = "auto f(uint32_t i) {\n"
+               "    auto x = (int64_t)i;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, -1));
+
+        code = "size_t g();\n"
+               "auto f(uint16_t j) {\n"
+               "    auto x = g() - j;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 4U, 0));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 4U, -1));
+
+        code = "auto f(uint32_t i) {\n"
+               "    auto x = (i + 1) % 16;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 3U, 0));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, -1));
+
+        code = "auto f(uint32_t i) {\n"
+               "    auto x = i ^ 3;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 3U, 2));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, -1));
+
+        code = "auto f(uint32_t i) {\n"
+               "    auto x = i & 3;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 3U, 2));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, -1));
+    }
+
+    void valueFlowMod() {
+        const char *code;
+
+        code = "auto f(int i) {\n"
+               "    auto x = i % 2;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, 2));
+
+        code = "auto f(int i) {\n"
+               "    auto x = !(i % 2);\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 3U, 0));
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 3U, 1));
+    }
+
+    void valueFlowIncDec() {
+        const char *code;
+        std::list<ValueFlow::Value> values;
+
+        // #11591
+        code = "int f() {\n"
+               "    const int a[1] = {};\n"
+               "    unsigned char i = 255;\n"
+               "    ++i;\n"
+               "    return a[i];\n"
+               "}\n";
+        values = tokenValues(code, "i ]");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(0LLU, values.back().intvalue);
+
+        code = "int f() {\n"
+               "    const int a[1] = {};\n"
+               "    unsigned char i = 255;\n"
+               "    return a[++i];\n"
+               "}\n";
+        values = tokenValues(code, "++");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(0LLU, values.back().intvalue);
+
+        code = "int f() {\n"
+               "     const int a[128] = {};\n"
+               "     char b = -128;\n"
+               "     return a[--b];\n"
+               "}\n";
+        values = tokenValues(code, "--");
+        ASSERT_EQUALS(1U, values.size());
+        ASSERT_EQUALS(127LLU, values.back().intvalue);
+    }
+
+    void valueFlowNotNull()
+    {
+        const char* code;
+
+        code = "int f(const std::string &str) {\n"
+               "    int x = str.c_str();\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, 0));
+
+        code = "int f(const std::string_view &str) {\n"
+               "    int x = str.c_str();\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 3U, 0));
+
+        code = "auto f() {\n"
+               "    std::shared_ptr<int> x = std::make_shared<int>(1);\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, 0));
+
+        code = "auto f() {\n"
+               "    std::unique_ptr<int> x = std::make_unique<int>(1);\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, 0));
+
+        code = "struct A {\n"
+               "    A* f() {\n"
+               "        A* x = this;\n"
+               "        return x;\n"
+               "    }\n"
+               "};\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 4U, 0));
+    }
+
+    void valueFlowSymbolic() {
+        const char* code;
+
+        code = "int f(int i) {\n"
+               "    int j = i;\n"
+               "    int x = i;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, "j", 0));
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, "i", 0));
+
+        code = "int f(int i) {\n"
+               "    int j = i;\n"
+               "    int x = j;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, "i", 0));
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, "j", 0));
+
+        code = "void g(int&);\n"
+               "int f(int i) {\n"
+               "    int j = i;\n"
+               "    g(i);\n"
+               "    int x = i;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 6U, "i", 0));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 6U, "j", 0));
+
+        code = "int f(int i) {\n"
+               "    int j = i;\n"
+               "    j++;\n"
+               "    int x = i == j;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 5U, 0));
+
+        code = "int f(int i) {\n"
+               "    int j = i;\n"
+               "    i++;\n"
+               "    int x = i - j;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 5U, 1));
+
+        code = "int f(int i) {\n"
+               "    int j = i;\n"
+               "    i++;\n"
+               "    int x = i > j;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 5U, 1));
+
+        code = "int f(int i) {\n"
+               "    int j = i;\n"
+               "    j++;\n"
+               "    int x = j > i;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 5U, 1));
+
+        code = "int f(int i) {\n"
+               "    int j = i++;\n"
+               "    int x = i++;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 4U, "i++", 0));
+
+        code = "float foo() {\n"
+               "    float f = 1.0f;\n"
+               "    float x = f;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 4U, "1.0f", 0));
+
+        code = "int foo(float f) {\n"
+               "    float g = f;\n"
+               "    int x = f == g;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 4U, 1));
+
+        code = "int f(int i) {\n"
+               "  for(int j = i;;j++) {\n"
+               "    int x = j;\n"
+               "    return x;\n"
+               "  }\n"
+               "  return 0;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 4U, "i", 0));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 4U, "i", 1));
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, "j", 0));
+
+        code = "void f(int x) {\n"
+               "  int y = x + 1;\n"
+               "  return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 3U, "y", 0));
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 3U, "y", -1));
+
+        code = "void f(int x) {\n"
+               "  int y = x * 2;\n"
+               "  return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 3U, "y", 0));
+
+        code = "int f(int i, int j) {\n"
+               "    if (i == j) {\n"
+               "        int x = i - j;\n"
+               "        return x;\n"
+               "    }\n"
+               "    return 0;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 0));
+
+        code = "void f(int x, int y) {\n"
+               "    if (x == y) {\n"
+               "        int a = x;\n"
+               "    }\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 3U, "y", 0));
+
+        code = "void f(int x, int y) {\n"
+               "    if (x != y) {\n"
+               "        int a = x;\n"
+               "    }\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "y", 0));
+
+        code = "void f(int x, int y) {\n"
+               "    if (x < y) {\n"
+               "        int a = x;\n"
+               "    }\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, "y", -1));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "y", 0));
+
+        code = "void f(int x, int y) {\n"
+               "    if (x <= y) {\n"
+               "        int a = x;\n"
+               "    }\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, "y", 0));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "y", 1));
+
+        code = "void f(int x, int y) {\n"
+               "    if (x > y) {\n"
+               "        int a = x;\n"
+               "    }\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, "y", 1));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "y", 0));
+
+        code = "void f(int x, int y) {\n"
+               "    if (x >= y) {\n"
+               "        int a = x;\n"
+               "    }\n"
+               "}";
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, "y", 0));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "y", -1));
+
+        code = "void f(int y) {\n"
+               "  int x = y - 1;\n"
+               "  if (y == 1)\n"
+               "    int a = x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 0));
+
+        code = "void f(int y) {\n"
+               "  int x = y * y;\n"
+               "  if (y == 2)\n"
+               "    int a = x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 4));
+
+        code = "void f(int x, int y) {\n"
+               "  if (x == y*y)\n"
+               "    if (y == 2)\n"
+               "      int a = x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 4));
+
+        code = "void f(int x, int y) {\n"
+               "  if (x > y*y)\n"
+               "    if (y == 2)\n"
+               "      int a = x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 4U, 4));
+
+        code = "void f(int x, int y) {\n"
+               "  if (x != y*y)\n"
+               "    if (y == 2)\n"
+               "      int a = x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 4U, 4));
+
+        code = "void f(int x, int y) {\n"
+               "  if (x >= y*y)\n"
+               "    if (y == 2)\n"
+               "      int a = x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 4U, 3));
+
+        code = "void f(int x, int y) {\n"
+               "  if (x == y*y)\n"
+               "    if (y != 2)\n"
+               "      int a = x;\n"
+               "}\n";
+        TODO_ASSERT_EQUALS(true, false, testValueOfXImpossible(code, 4U, 4));
+
+        code = "void f(int x, int y) {\n"
+               "  if (x == y*y)\n"
+               "    if (y > 2)\n"
+               "      int a = x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 9));
+
+        code = "struct A {\n"
+               "    A* b();\n"
+               "    int c() const;\n"
+               "};\n"
+               "void f(A *d) {\n"
+               "    if (!d || d->c() != 1)\n"
+               "        return;\n"
+               "    A * y = d;\n"
+               "    d = d->b();\n"
+               "    A * x = d;\n"
+               "    A* z = x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 11U, "d", 0));
+        ASSERT_EQUALS(false, testValueOfXImpossible(code, 11U, 0));
+
+        code = "void f(int * p, int len) {\n"
+               "    for(int x = 0; x < len; ++x) {\n"
+               "        p[x] = 1;\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, "len", -1));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "len", 0));
+
+        code = "int f(int x) {\n"
+               "    int i = 64 - x;\n"
+               "    if(i < 8)\n"
+               "        return x;\n"
+               "    return 0;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 4U, 71));
+        TODO_ASSERT_EQUALS(true, false, testValueOfX(code, 4U, 56));
+
+        code = "int b(int a) {\n"
+               "  unsigned long x = a ? 6 : 4;\n"
+               "  assert(x < 6 && x > 0);\n"
+               "  return 1 / x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 4U, 0));
+
+        code = "void f(int k) {\n"
+               "  int x = k;\n"
+               "  int j = k;\n"
+               "  x--;\n"
+               "  if (k != 0) {\n"
+               "    x;\n"
+               "  }\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 6U, -1));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 6U, -1));
+
+        code = "char* f() {\n"
+               "    char *x = malloc(10);\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 3U, "malloc(10)", 0));
+    }
+
+    void valueFlowSymbolicIdentity()
+    {
+        const char* code;
+
+        code = "void f(int a) {\n"
+               "    int x = a*1;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 3U, "a", 0));
+
+        code = "void f(int a) {\n"
+               "    int x = a/1;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 3U, "a", 0));
+
+        code = "void f(int a) {\n"
+               "    int x = a+0;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 3U, "a", 0));
+
+        code = "void f(int a) {\n"
+               "    int x = a-0;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 3U, "a", 0));
+
+        code = "void f(int a) {\n"
+               "    int x = a^0;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 3U, "a", 0));
+
+        code = "void f(int a) {\n"
+               "    int x = a|0;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 3U, "a", 0));
+
+        code = "void f(int a) {\n"
+               "    int x = a>>0;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 3U, "a", 0));
+
+        code = "void f(int a) {\n"
+               "    int x = a<<0;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 3U, "a", 0));
+
+        code = "void f(int a) {\n"
+               "    int x = 0>>a;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 3U, "a", 0));
+
+        code = "void f(int a) {\n"
+               "    int x = 0<<a;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 3U, "a", 0));
+
+        code = "void f(int n) {\n"
+               "    int x = 0 - n;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 3U, "n", ValueFlow::Value::ValueType::SYMBOLIC));
+
+        code = "void f(int n) {\n"
+               "    int x = n - 0;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfX(code, 3U, "n", ValueFlow::Value::ValueType::SYMBOLIC));
+    }
+
+    void valueFlowSymbolicStrlen()
+    {
+        const char* code;
+
+        code = "int f(char *s) {\n"
+               "    size_t len = strlen(s);\n"
+               "    int x = s[len];\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 0));
+
+        code = "int f(char *s, size_t i) {\n"
+               "    if (i < strlen(s)) {\n"
+               "      int x = s[i];\n"
+               "      return x;\n"
+               "    }\n"
+               "    return 0;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 4U, 0));
+
+        code = "int f(char *s, size_t i) {\n"
+               "    if (i < strlen(s)) {\n"
+               "      int x = s[i] != ' ';\n"
+               "      return x;\n"
+               "    }\n"
+               "    return 0;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 4U, 1));
+
+        code = "int f(char *s, size_t i) {\n"
+               "    if (i == strlen(s)) {}\n"
+               "    int x = s[i];\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 4U, 0));
+        ASSERT_EQUALS(true, testValueOfX(code, 4U, 0));
+    }
+
+    void valueFlowSmartPointer()
+    {
+        const char* code;
+
+        code = "int* df(int* expr);\n"
+               "int * f() {\n"
+               "    std::unique_ptr<int> x;\n"
+               "    x.reset(df(x.release()));\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 5U, 0));
+    }
+
+    void valueFlowImpossibleMinMax()
+    {
+        const char* code;
+
+        code = "void f(int a, int b) {\n"
+               "    int x = a < b ? a : b;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "a", 1));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "b", 1));
+
+        code = "void f(int a, int b) {\n"
+               "    int x = a > b ? a : b;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "a", -1));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "b", -1));
+
+        code = "void f(int a, int b) {\n"
+               "    int x = a > b ? b : a;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "a", 1));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "b", 1));
+
+        code = "void f(int a, int b) {\n"
+               "    int x = a < b ? b : a;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "a", -1));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "b", -1));
+
+        code = "void f(int a) {\n"
+               "    int x = a < 0 ? a : 0;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "a", 1));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, 1));
+
+        code = "void f(int a) {\n"
+               "    int x = a > 0 ? a : 0;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "a", -1));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, -1));
+
+        code = "void f(int a) {\n"
+               "    int x = a > 0 ? 0 : a;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "a", 1));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, 1));
+
+        code = "void f(int a) {\n"
+               "    int x = a < 0 ? 0 : a;\n"
+               "    return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, "a", -1));
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 3U, -1));
+    }
+
+    void valueFlowImpossibleIncDec()
+    {
+        const char* code;
+
+        code = "int f() {\n"
+               "    for(int i = 0; i < 5; i++) {\n"
+               "        int x = i;\n"
+               "        return x;\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 4U, -1));
+
+        code = "void f(int N, int z) {\n"
+               "  std::vector<int> a(N);\n"
+               "  int m = -1;\n"
+               "  m = 0;\n"
+               "  for (int k = 0; k < N; k++) {\n"
+               "    int x = m + k;\n"
+               "    if (z == a[x]) {}\n"
+               "  }\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 7U, -1));
+        ASSERT_EQUALS(false, testValueOfXKnown(code, 7U, -1));
+    }
+
+    void valueFlowImpossibleUnknownConstant()
+    {
+        const char* code;
+
+        code = "void f(bool b) {\n"
+               "    if (b) {\n"
+               "        int x = -ENOMEM;\n" // assume constant ENOMEM is nonzero since it's negated
+               "        if (x != 0) return;\n"
+               "    }\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXImpossible(code, 4U, 0));
+    }
+
+    void valueFlowContainerEqual()
+    {
+        const char* code;
+
+        code = "bool f() {\n"
+               "  std::string s = \"abc\";\n"
+               "  bool x = (s == \"def\");\n"
+               "  return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 0));
+
+        code = "bool f() {\n"
+               "  std::string s = \"abc\";\n"
+               "  bool x = (s != \"def\");\n"
+               "  return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 4U, 1));
+
+        code = "bool f() {\n"
+               "  std::vector<int> v1 = {1, 2};\n"
+               "  std::vector<int> v2 = {1, 2};\n"
+               "  bool x = (v1 == v2);\n"
+               "  return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 5U, 1));
+
+        code = "bool f() {\n"
+               "  std::vector<int> v1 = {1, 2};\n"
+               "  std::vector<int> v2 = {1, 2};\n"
+               "  bool x = (v1 != v2);\n"
+               "  return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 5U, 0));
+
+        code = "bool f(int i) {\n"
+               "  std::vector<int> v1 = {i, i+1};\n"
+               "  std::vector<int> v2 = {i};\n"
+               "  bool x = (v1 == v2);\n"
+               "  return x;\n"
+               "}\n";
+        ASSERT_EQUALS(true, testValueOfXKnown(code, 5U, 0));
+
+        code = "bool f(int i, int j) {\n"
+               "  std::vector<int> v1 = {i, i};\n"
+               "  std::vector<int> v2 = {i, j};\n"
+               "  bool x = (v1 == v2);\n"
+               "  return x;\n"
+               "}\n";
+        ASSERT_EQUALS(false, testValueOfX(code, 5U, 1));
+        ASSERT_EQUALS(false, testValueOfX(code, 5U, 0));
+    }
+
+    void valueFlowBailoutIncompleteVar() {
+        bailout( // #12526
+            "int f1() {\n"
+            "    return VALUE_1;\n"
+            "}\n"
+            "\n"
+            "int f2() {\n"
+            "    return VALUE_2;\n"
+            "}\n"
+            );
+        ASSERT_EQUALS_WITHOUT_LINENUMBERS(
+            "[test.cpp:2]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable VALUE_1\n"
+            "[test.cpp:6]: (debug) valueFlowConditionExpressions bailout: Skipping function due to incomplete variable VALUE_2\n",
+            errout_str());
+
+        bailout(
+            "std::string_view f() {\n"
+            "    return \"abc\"sv;\n"
+            "}\n"
+            );
+        ASSERT_EQUALS_WITHOUT_LINENUMBERS("", errout_str());
+    }
+
+    void valueFlowBailoutNoreturn() { // #13718
+        bailout(
+            "void f(const int* p) {\n"
+            "    if (p)\n"
+            "        (void)*p;\n"
+            "}\n"
+            );
+        ASSERT_EQUALS_WITHOUT_LINENUMBERS("", errout_str());
+    }
+
+    void performanceIfCount() {
+        /*const*/ Settings s(settings);
+        s.vfOptions.maxIfCount = 1;
+
+        const char *code;
+
+        code = "int f() {\n"
+               "  if (x>0){}\n"
+               "  if (y>0){}\n"
+               "  int a = 14;\n"
+               "  return a+1;\n"
+               "}\n";
+        ASSERT_EQUALS(0U, tokenValues(code, "+", &s).size());
+        ASSERT_EQUALS(1U, tokenValues(code, "+").size());
+
+        // Do not skip all functions
+        code = "void g(int i) {\n"
+               "  if (i == 1) {}\n"
+               "  if (i == 2) {}\n"
+               "}\n"
+               "int f() {\n"
+               "  std::vector<int> v;\n"
+               "  return v.front();\n"
+               "}\n";
+        ASSERT_EQUALS(1U, tokenValues(code, "v .", &s).size());
+    }
+
+#define testBitfields(...) testBitfields_(__FILE__, __LINE__, __VA_ARGS__)
+    void testBitfields_(const char *file, int line, const std::string &structBody, std::size_t expectedSize) {
+        const Settings settingsUnix64 = settingsBuilder().platform(Platform::Type::Unix64).build();
+        const std::string code = "struct S { " + structBody + " }; const std::size_t size = sizeof(S);";
+        const auto values = tokenValues(code.c_str(), "( S", &settingsUnix64);
+        ASSERT_LOC(!values.empty(), file, line);
+        ASSERT_EQUALS_LOC(expectedSize, values.back().intvalue, file, line);
+    }
+
+    void bitfields() {
+
+        // #13653
+        testBitfields("unsigned int data_rw: 1;\n"
+                      "unsigned int page_address: 4;\n"
+                      "unsigned int register_address: 3;\n",
+                      4);
+
+        testBitfields("unsigned char data_rw: 1;\n"
+                      "unsigned char page_address: 4;\n"
+                      "unsigned char register_address: 3;\n",
+                      1);
+
+        testBitfields("unsigned int a : 1;\n"
+                      "unsigned int b;\n"
+                      "unsigned int c : 1;\n",
+                      12);
+
+        testBitfields("unsigned int a : 1;\n"
+                      "unsigned char b;\n"
+                      "unsigned int c : 1;\n",
+                      12);
+
+        testBitfields("unsigned int a : 31;\n"
+                      "unsigned int b : 2;\n",
+                      8);
+
+        // #13850
+        testBitfields("int a : 32;\n"
+                      "int b : 16;\n"
+                      "unsigned short c;\n",
+                      8);
+
+        testBitfields("unsigned int a : 31;\n"
+                      "unsigned int   : 2;\n",
+                      8);
+
+        testBitfields("unsigned int a : 16;\n"
+                      "unsigned int   : 0;\n"
+                      "unsigned int b : 16;\n",
+                      8);
+
+        testBitfields("unsigned char a : 16;\n",
+                      2);
+    }
+
+    void bitfieldsHang() {
+        const char *code = "struct S { unknown_type x : 1; };\n"
+                           "const size_t size = sizeof(S);\n";
+        (void)valueOfTok(code, "x");
+    }
 };
 
 REGISTER_TEST(TestValueFlow)
diff --git a/test/testvarid.cpp b/test/testvarid.cpp
index dc49f657c87..416ad5d6b82 100644
--- a/test/testvarid.cpp
+++ b/test/testvarid.cpp
@@ -1,6 +1,6 @@
 /*
  * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
+ * Copyright (C) 2007-2026 Cppcheck team.
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,25 +16,23 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "helpers.h"
 #include "platform.h"
 #include "settings.h"
 #include "standards.h"
-#include "testsuite.h"
+#include "fixture.h"
 #include "token.h"
-#include "tokenize.h"
 
+#include <cstddef>
 #include <string>
 
-struct InternalError;
-
-
 class TestVarID : public TestFixture {
 public:
-    TestVarID() : TestFixture("TestVarID") {
-    }
+    TestVarID() : TestFixture("TestVarID") {}
 
 private:
-    void run() OVERRIDE {
+    const Settings settings = settingsBuilder().c(Standards::C89).platform(Platform::Type::Unix64).build();
+    void run() override {
         TEST_CASE(varid1);
         TEST_CASE(varid2);
         TEST_CASE(varid3);
@@ -44,6 +42,7 @@ class TestVarID : public TestFixture {
         TEST_CASE(varid7);
         TEST_CASE(varidReturn1);
         TEST_CASE(varidReturn2);
+        TEST_CASE(varidReturn3);
         TEST_CASE(varid8);
         TEST_CASE(varid9);
         TEST_CASE(varid10);
@@ -94,8 +93,22 @@ class TestVarID : public TestFixture {
         TEST_CASE(varid61); // #4988 inline function
         TEST_CASE(varid62);
         TEST_CASE(varid63);
+        TEST_CASE(varid64); // #9922 - extern const char (*x[256])
+        TEST_CASE(varid65); // #10936
+        TEST_CASE(varid66);
+        TEST_CASE(varid67); // #11711 - NOT function pointer
+        TEST_CASE(varid68); // #11740 - switch (str_chars(&strOut)[0])
+        TEST_CASE(varid69);
+        TEST_CASE(varid70); // #12660 - function
+        TEST_CASE(varid71); // #12676 - wrong varid in uninstantiated templated constructor
+        TEST_CASE(varid72);
+        TEST_CASE(varid_for_1);
+        TEST_CASE(varid_for_2);
+        TEST_CASE(varid_for_3);
         TEST_CASE(varid_cpp_keywords_in_c_code);
         TEST_CASE(varid_cpp_keywords_in_c_code2); // #5373: varid=0 for argument called "delete"
+        TEST_CASE(varid_cpp_keywords_in_c_code3);
+        TEST_CASE(varid_cpp_keywords_in_c_code4);
         TEST_CASE(varidFunctionCall1);
         TEST_CASE(varidFunctionCall2);
         TEST_CASE(varidFunctionCall3);
@@ -115,6 +128,7 @@ class TestVarID : public TestFixture {
         TEST_CASE(varid_in_class5);     // #3584 - std::vector<::FOO::B> b;
         TEST_CASE(varid_in_class6);     // #3755
         TEST_CASE(varid_in_class7);     // set variable id for struct members
+        TEST_CASE(varid_in_class8);     // unknown macro in class
         TEST_CASE(varid_in_class9);     // #4291 - id for variables accessed through 'this'
         TEST_CASE(varid_in_class10);
         TEST_CASE(varid_in_class11);    // #4277 - anonymous union
@@ -128,9 +142,20 @@ class TestVarID : public TestFixture {
         TEST_CASE(varid_in_class19);
         TEST_CASE(varid_in_class20);    // #7267
         TEST_CASE(varid_in_class21);    // #7788
+        TEST_CASE(varid_in_class22);    // #10872
+        TEST_CASE(varid_in_class23);    // #11293
+        TEST_CASE(varid_in_class24);
+        TEST_CASE(varid_in_class25);
+        TEST_CASE(varid_in_class26);
+        TEST_CASE(varid_in_class27);
+        TEST_CASE(varid_in_class28);
+        TEST_CASE(varid_in_class29);
         TEST_CASE(varid_namespace_1);   // #7272
         TEST_CASE(varid_namespace_2);   // #7000
         TEST_CASE(varid_namespace_3);   // #8627
+        TEST_CASE(varid_namespace_4);
+        TEST_CASE(varid_namespace_5);
+        TEST_CASE(varid_namespace_6);
         TEST_CASE(varid_initList);
         TEST_CASE(varid_initListWithBaseTemplate);
         TEST_CASE(varid_initListWithScope);
@@ -144,7 +169,9 @@ class TestVarID : public TestFixture {
         TEST_CASE(varid_templateNamespaceFuncPtr); // #4172
         TEST_CASE(varid_templateArray);
         TEST_CASE(varid_templateParameter); // #7046 set varid for "X":  std::array<int,X> Y;
+        TEST_CASE(varid_templateParameterFunctionPointer); // #11050
         TEST_CASE(varid_templateUsing); // #5781 #7273
+        TEST_CASE(varid_templateSpecializationFinal);
         TEST_CASE(varid_not_template_in_condition); // #7988
         TEST_CASE(varid_cppcast); // #6190
         TEST_CASE(varid_variadicFunc);
@@ -164,6 +191,14 @@ class TestVarID : public TestFixture {
         TEST_CASE(varid_lambda_mutable);
         TEST_CASE(varid_trailing_return1); // #8889
         TEST_CASE(varid_trailing_return2); // #9066
+        TEST_CASE(varid_trailing_return3); // #11423
+        TEST_CASE(varid_parameter_pack); // #9383
+        TEST_CASE(varid_for_auto_cpp17);
+        TEST_CASE(varid_not); // #9689 'not x'
+        TEST_CASE(varid_declInIfCondition);
+        TEST_CASE(varid_globalScope);
+        TEST_CASE(varid_function_pointer_args);
+        TEST_CASE(varid_alignas);
 
         TEST_CASE(varidclass1);
         TEST_CASE(varidclass2);
@@ -184,7 +219,17 @@ class TestVarID : public TestFixture {
         TEST_CASE(varidclass17);  // #6073
         TEST_CASE(varidclass18);
         TEST_CASE(varidclass19);  // initializer list
+        TEST_CASE(varidclass20);   // #7578: int (*p)[2]
         TEST_CASE(varid_classnameshaddowsvariablename); // #3990
+        TEST_CASE(varid_classnametemplate); // #10221
+
+        TEST_CASE(varidenum1);
+        TEST_CASE(varidenum2);
+        TEST_CASE(varidenum3);
+        TEST_CASE(varidenum4);
+        TEST_CASE(varidenum5);
+        TEST_CASE(varidenum6); // #9180
+        TEST_CASE(varidenum7); // #8991
 
         TEST_CASE(varidnamespace1);
         TEST_CASE(varidnamespace2);
@@ -193,38 +238,85 @@ class TestVarID : public TestFixture {
         TEST_CASE(usingNamespace3);
 
         TEST_CASE(setVarIdStructMembers1);
+
+        TEST_CASE(decltype1);
+        TEST_CASE(decltype2);
+
+        TEST_CASE(typeof1);
+        TEST_CASE(typeof2);
+        TEST_CASE(typeof3);
+        TEST_CASE(typeof4);
+
+        TEST_CASE(exprid1);
+        TEST_CASE(exprid2);
+        TEST_CASE(exprid3);
+        TEST_CASE(exprid4);
+        TEST_CASE(exprid5);
+        TEST_CASE(exprid6);
+        TEST_CASE(exprid7);
+        TEST_CASE(exprid8);
+        TEST_CASE(exprid9);
+        TEST_CASE(exprid10);
+        TEST_CASE(exprid11);
+        TEST_CASE(exprid12);
+        TEST_CASE(exprid13);
+        TEST_CASE(exprid14);
+
+        TEST_CASE(structuredBindings);
     }
 
-    std::string tokenize(const char code[], bool simplify = false, const char filename[] = "test.cpp") {
-        errout.str("");
+    struct TokenizeOptions
+    {
+        bool cpp = true;
+    };
 
-        Settings settings;
-        settings.platform(Settings::Unix64);
-        settings.standards.c   = Standards::C89;
-        settings.standards.cpp = Standards::CPP11;
+#define tokenize(...) tokenize_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    std::string tokenize_(const char* file, int line, const char (&code)[size], const TokenizeOptions& options = make_default_obj()) {
+        return tokenize_(file, line, code, settings, options.cpp);
+    }
+
+    template<size_t size>
+    std::string tokenize_(const char* file, int line, const char (&code)[size], const Settings& settings1, bool cpp = true) {
+        SimpleTokenizer tokenizer(settings1, *this, cpp);
+        ASSERT_LOC((tokenizer.tokenize)(code), file, line);
 
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, filename);
+        // result..
+        Token::stringifyOptions str_options = Token::stringifyOptions::forDebugVarId();
+        str_options.files = false;
+        return tokenizer.tokens()->stringifyList(str_options);
+    }
 
-        if (simplify)
-            tokenizer.simplifyTokenList2();
+#define tokenizeHeader(...) tokenizeHeader_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    std::string tokenizeHeader_(const char* file, int line, const char (&code)[size], const char filename[]) {
+        SimpleTokenizer tokenizer{settings, *this, std::string(filename)};
+        ASSERT_LOC((tokenizer.tokenize)(code), file, line);
 
         // result..
-        return tokenizer.tokens()->stringifyList(true,true,true,true,false);
+        Token::stringifyOptions options = Token::stringifyOptions::forDebugVarId();
+        options.files = false;
+        return tokenizer.tokens()->stringifyList(options);
     }
 
-    std::string compareVaridsForVariable(const char code[], const char varname[], const char filename[] = "test.cpp") {
-        errout.str("");
+#define tokenizeExpr(...) tokenizeExpr_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    std::string tokenizeExpr_(const char* file, int line, const char (&code)[size]) {
+        SimpleTokenizer2 tokenizer(settings, *this, code, "test.cpp");
 
-        Settings settings;
-        settings.platform(Settings::Unix64);
-        settings.standards.c   = Standards::C89;
-        settings.standards.cpp = Standards::CPP11;
+        ASSERT_LOC(tokenizer.simplifyTokens1(""), file, line);
 
-        Tokenizer tokenizer(&settings, this);
-        std::istringstream istr(code);
-        tokenizer.tokenize(istr, filename);
+        // result..
+        Token::stringifyOptions options = Token::stringifyOptions::forDebugExprId();
+        options.files = false;
+        return tokenizer.tokens()->stringifyList(options);
+    }
+
+#define compareVaridsForVariable(...) compareVaridsForVariable_(__FILE__, __LINE__, __VA_ARGS__)
+    template<size_t size>
+    std::string compareVaridsForVariable_(const char* file, int line, const char (&code)[size], const char varname[]) {
+        SimpleTokenizer tokenizer(settings, *this);
+        ASSERT_LOC((tokenizer.tokenize)(code), file, line);
 
         unsigned int varid = ~0U;
         for (const Token *tok = tokenizer.tokens(); tok; tok = tok->next()) {
@@ -242,14 +334,14 @@ class TestVarID : public TestFixture {
     void varid1() {
         {
             const std::string actual = tokenize(
-                                           "static int i = 1;\n"
-                                           "void f()\n"
-                                           "{\n"
-                                           "    int i = 2;\n"
-                                           "    for (int i = 0; i < 10; ++i)\n"
-                                           "        i = 3;\n"
-                                           "    i = 4;\n"
-                                           "}\n", false, "test.c");
+                "static int i = 1;\n"
+                "void f()\n"
+                "{\n"
+                "    int i = 2;\n"
+                "    for (int i = 0; i < 10; ++i)\n"
+                "        i = 3;\n"
+                "    i = 4;\n"
+                "}\n", dinit(TokenizeOptions, $.cpp = false));
 
             const char expected[] = "1: static int i@1 = 1 ;\n"
                                     "2: void f ( )\n"
@@ -265,16 +357,16 @@ class TestVarID : public TestFixture {
 
         {
             const std::string actual = tokenize(
-                                           "static int i = 1;\n"
-                                           "void f()\n"
-                                           "{\n"
-                                           "    int i = 2;\n"
-                                           "    for (int i = 0; i < 10; ++i)\n"
-                                           "    {\n"
-                                           "      i = 3;\n"
-                                           "    }\n"
-                                           "    i = 4;\n"
-                                           "}\n", false, "test.c");
+                "static int i = 1;\n"
+                "void f()\n"
+                "{\n"
+                "    int i = 2;\n"
+                "    for (int i = 0; i < 10; ++i)\n"
+                "    {\n"
+                "      i = 3;\n"
+                "    }\n"
+                "    i = 4;\n"
+                "}\n", dinit(TokenizeOptions, $.cpp = false));
 
             const char expected[] = "1: static int i@1 = 1 ;\n"
                                     "2: void f ( )\n"
@@ -293,12 +385,12 @@ class TestVarID : public TestFixture {
 
     void varid2() {
         const std::string actual = tokenize(
-                                       "void f()\n"
-                                       "{\n"
-                                       "    struct ABC abc;\n"
-                                       "    abc.a = 3;\n"
-                                       "    i = abc.a;\n"
-                                       "}\n", false, "test.c");
+            "void f()\n"
+            "{\n"
+            "    struct ABC abc;\n"
+            "    abc.a = 3;\n"
+            "    i = abc.a;\n"
+            "}\n", dinit(TokenizeOptions, $.cpp = false));
 
         const char expected[] = "1: void f ( )\n"
                                 "2: {\n"
@@ -312,12 +404,12 @@ class TestVarID : public TestFixture {
 
     void varid3() {
         const std::string actual = tokenize(
-                                       "static char str[4];\n"
-                                       "void f()\n"
-                                       "{\n"
-                                       "    char str[10];\n"
-                                       "    str[0] = 0;\n"
-                                       "}\n", false, "test.c");
+            "static char str[4];\n"
+            "void f()\n"
+            "{\n"
+            "    char str[10];\n"
+            "    str[0] = 0;\n"
+            "}\n", dinit(TokenizeOptions, $.cpp = false));
 
         const char expected[] = "1: static char str@1 [ 4 ] ;\n"
                                 "2: void f ( )\n"
@@ -331,10 +423,10 @@ class TestVarID : public TestFixture {
 
     void varid4() {
         const std::string actual = tokenize(
-                                       "void f(const unsigned int a[])\n"
-                                       "{\n"
-                                       "    int i = *(a+10);\n"
-                                       "}\n", false, "test.c");
+            "void f(const unsigned int a[])\n"
+            "{\n"
+            "    int i = *(a+10);\n"
+            "}\n", dinit(TokenizeOptions, $.cpp = false));
 
         const char expected[] = "1: void f ( const unsigned int a@1 [ ] )\n"
                                 "2: {\n"
@@ -346,10 +438,10 @@ class TestVarID : public TestFixture {
 
     void varid5() {
         const std::string actual = tokenize(
-                                       "void f()\n"
-                                       "{\n"
-                                       "    int a,b;\n"
-                                       "}\n", false, "test.c");
+            "void f()\n"
+            "{\n"
+            "    int a,b;\n"
+            "}\n", dinit(TokenizeOptions, $.cpp = false));
 
         const char expected[] = "1: void f ( )\n"
                                 "2: {\n"
@@ -362,10 +454,10 @@ class TestVarID : public TestFixture {
 
     void varid6() {
         const std::string actual = tokenize(
-                                       "int f(int a, int b)\n"
-                                       "{\n"
-                                       "    return a+b;\n"
-                                       "}\n", false, "test.c");
+            "int f(int a, int b)\n"
+            "{\n"
+            "    return a+b;\n"
+            "}\n", dinit(TokenizeOptions, $.cpp = false));
 
         const char expected[] = "1: int f ( int a@1 , int b@2 )\n"
                                 "2: {\n"
@@ -378,12 +470,12 @@ class TestVarID : public TestFixture {
 
     void varid7() {
         const std::string actual = tokenize(
-                                       "void func() {\n"
-                                       "    char a[256] = \"test\";\n"
-                                       "    {\n"
-                                       "        char b[256] = \"test\";\n"
-                                       "    }\n"
-                                       "}\n", false, "test.c");
+            "void func() {\n"
+            "    char a[256] = \"test\";\n"
+            "    {\n"
+            "        char b[256] = \"test\";\n"
+            "    }\n"
+            "}\n", dinit(TokenizeOptions, $.cpp = false));
 
         const char expected[] = "1: void func ( ) {\n"
                                 "2: char a@1 [ 256 ] = \"test\" ;\n"
@@ -397,11 +489,11 @@ class TestVarID : public TestFixture {
 
     void varidReturn1() {
         const std::string actual = tokenize(
-                                       "int f()\n"
-                                       "{\n"
-                                       "    int a;\n"
-                                       "    return a;\n"
-                                       "}\n", false, "test.c");
+            "int f()\n"
+            "{\n"
+            "    int a;\n"
+            "    return a;\n"
+            "}\n", dinit(TokenizeOptions, $.cpp = false));
 
         const char expected[] = "1: int f ( )\n"
                                 "2: {\n"
@@ -414,11 +506,11 @@ class TestVarID : public TestFixture {
 
     void varidReturn2() {
         const std::string actual = tokenize(
-                                       "void foo()\n"
-                                       "{\n"
-                                       "    unsigned long mask = (1UL << size_) - 1;\n"
-                                       "    return (abits_val_ & mask);\n"
-                                       "}\n", false, "test.c");
+            "void foo()\n"
+            "{\n"
+            "    unsigned long mask = (1UL << size_) - 1;\n"
+            "    return (abits_val_ & mask);\n"
+            "}\n", dinit(TokenizeOptions, $.cpp = false));
 
         const char expected[] = "1: void foo ( )\n"
                                 "2: {\n"
@@ -429,13 +521,28 @@ class TestVarID : public TestFixture {
         ASSERT_EQUALS(expected, actual);
     }
 
+    void varidReturn3() {
+        const std::string actual = tokenize(
+            "struct S { int i; };\n"
+            "int f(S s) {\n"
+            "    return (&s)->i;\n"
+            "}\n");
+
+        const char expected[] = "1: struct S { int i@1 ; } ;\n"
+                                "2: int f ( S s@2 ) {\n"
+                                "3: return s@2 . i@3 ;\n"
+                                "4: }\n";
+
+        ASSERT_EQUALS(expected, actual);
+    }
+
     void varid8() {
         const std::string actual = tokenize(
-                                       "void func()\n"
-                                       "{\n"
-                                       "    std::string str(\"test\");\n"
-                                       "    str.clear();\n"
-                                       "}\n");
+            "void func()\n"
+            "{\n"
+            "    std::string str(\"test\");\n"
+            "    str.clear();\n"
+            "}");
 
         const char expected[] = "1: void func ( )\n"
                                 "2: {\n"
@@ -448,7 +555,7 @@ class TestVarID : public TestFixture {
 
     void varid9() {
         const std::string actual = tokenize(
-                                       "typedef int INT32;\n", false, "test.c");
+            "typedef int INT32;\n", dinit(TokenizeOptions, $.cpp = false));
 
         const char expected[] = "1: ;\n";
 
@@ -457,11 +564,11 @@ class TestVarID : public TestFixture {
 
     void varid10() {
         const std::string actual = tokenize(
-                                       "void foo()\n"
-                                       "{\n"
-                                       "    int abc;\n"
-                                       "    struct abc abc1;\n"
-                                       "}", false, "test.c");
+            "void foo()\n"
+            "{\n"
+            "    int abc;\n"
+            "    struct abc abc1;\n"
+            "}", dinit(TokenizeOptions, $.cpp = false));
 
         const char expected[] = "1: void foo ( )\n"
                                 "2: {\n"
@@ -473,8 +580,7 @@ class TestVarID : public TestFixture {
     }
 
     void varid11() {
-        const std::string actual = tokenize(
-                                       "class Foo;\n");
+        const std::string actual = tokenize("class Foo;");
 
         const char expected[] = "1: class Foo ;\n";
 
@@ -483,10 +589,10 @@ class TestVarID : public TestFixture {
 
     void varid12() {
         const std::string actual = tokenize(
-                                       "static void a()\n"
-                                       "{\n"
-                                       "    class Foo *foo;\n"
-                                       "}\n");
+            "static void a()\n"
+            "{\n"
+            "    class Foo *foo;\n"
+            "}");
 
         const char expected[] = "1: static void a ( )\n"
                                 "2: {\n"
@@ -498,11 +604,11 @@ class TestVarID : public TestFixture {
 
     void varid13() {
         const std::string actual = tokenize(
-                                       "void f()\n"
-                                       "{\n"
-                                       "    int a; int b;\n"
-                                       "    a = a;\n"
-                                       "}\n", false, "test.c");
+            "void f()\n"
+            "{\n"
+            "    int a; int b;\n"
+            "    a = a;\n"
+            "}\n", dinit(TokenizeOptions, $.cpp = false));
 
         const char expected[] = "1: void f ( )\n"
                                 "2: {\n"
@@ -516,12 +622,12 @@ class TestVarID : public TestFixture {
     void varid14() {
         // Overloaded operator*
         const std::string actual = tokenize(
-                                       "void foo()\n"
-                                       "{\n"
-                                       "A a;\n"
-                                       "B b;\n"
-                                       "b * a;\n"
-                                       "}", false, "test.c");
+            "void foo()\n"
+            "{\n"
+            "A a;\n"
+            "B b;\n"
+            "b * a;\n"
+            "}", dinit(TokenizeOptions, $.cpp = false));
 
         const char expected[] = "1: void foo ( )\n"
                                 "2: {\n"
@@ -536,10 +642,10 @@ class TestVarID : public TestFixture {
     void varid15() {
         {
             const std::string actual = tokenize(
-                                           "struct S {\n"
-                                           "    struct T {\n"
-                                           "    } t;\n"
-                                           "} s;", false, "test.c");
+                "struct S {\n"
+                "    struct T {\n"
+                "    } t;\n"
+                "} s;", dinit(TokenizeOptions, $.cpp = false));
 
             const char expected[] = "1: struct S {\n"
                                     "2: struct T {\n"
@@ -551,10 +657,10 @@ class TestVarID : public TestFixture {
 
         {
             const std::string actual = tokenize(
-                                           "struct S {\n"
-                                           "    struct T {\n"
-                                           "    } t;\n"
-                                           "};", false, "test.c");
+                "struct S {\n"
+                "    struct T {\n"
+                "    } t;\n"
+                "};", dinit(TokenizeOptions, $.cpp = false));
 
             const char expected[] = "1: struct S {\n"
                                     "2: struct T {\n"
@@ -567,10 +673,10 @@ class TestVarID : public TestFixture {
 
     void varid16() {
         const char code[] ="void foo()\n"
-                           "{\n"
-                           "    int x = 1;\n"
-                           "    y = (z * x);\n"
-                           "}\n";
+                            "{\n"
+                            "    int x = 1;\n"
+                            "    y = (z * x);\n"
+                            "}\n";
 
         const char expected[] = "1: void foo ( )\n"
                                 "2: {\n"
@@ -578,15 +684,15 @@ class TestVarID : public TestFixture {
                                 "4: y = z * x@1 ;\n"
                                 "5: }\n";
 
-        ASSERT_EQUALS(expected, tokenize(code, false, "test.c"));
+        ASSERT_EQUALS(expected, tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void varid17() { // ticket #1810
         const char code[] ="char foo()\n"
-                           "{\n"
-                           "    char c('c');\n"
-                           "    return c;\n"
-                           "}\n";
+                            "{\n"
+                            "    char c('c');\n"
+                            "    return c;\n"
+                            "}\n";
 
         const char expected[] = "1: char foo ( )\n"
                                 "2: {\n"
@@ -594,14 +700,14 @@ class TestVarID : public TestFixture {
                                 "4: return c@1 ;\n"
                                 "5: }\n";
 
-        ASSERT_EQUALS(expected, tokenize(code, false, "test.c"));
+        ASSERT_EQUALS(expected, tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void varid18() {
         const char code[] ="char foo(char c)\n"
-                           "{\n"
-                           "    bar::c = c;\n"
-                           "}\n";
+                            "{\n"
+                            "    bar::c = c;\n"
+                            "}\n";
 
         const char expected[] = "1: char foo ( char c@1 )\n"
                                 "2: {\n"
@@ -613,9 +719,9 @@ class TestVarID : public TestFixture {
 
     void varid19() {
         const char code[] ="void foo()\n"
-                           "{\n"
-                           "    std::pair<std::vector<double>, int> x;\n"
-                           "}\n";
+                            "{\n"
+                            "    std::pair<std::vector<double>, int> x;\n"
+                            "}\n";
 
         const char expected[] = "1: void foo ( )\n"
                                 "2: {\n"
@@ -627,9 +733,9 @@ class TestVarID : public TestFixture {
 
     void varid20() {
         const char code[] ="void foo()\n"
-                           "{\n"
-                           "    pair<vector<int>, vector<double> > x;\n"
-                           "}\n";
+                            "{\n"
+                            "    pair<vector<int>, vector<double> > x;\n"
+                            "}\n";
 
         const char expected[] = "1: void foo ( )\n"
                                 "2: {\n"
@@ -641,12 +747,12 @@ class TestVarID : public TestFixture {
 
     void varid24() {
         const char code[] ="class foo()\n"
-                           "{\n"
-                           "public:\n"
-                           "    ;\n"
-                           "private:\n"
-                           "    static int i;\n"
-                           "};\n";
+                            "{\n"
+                            "public:\n"
+                            "    ;\n"
+                            "private:\n"
+                            "    static int i;\n"
+                            "};\n";
 
         const char expected[] = "1: class foo ( )\n"
                                 "2: {\n"
@@ -661,12 +767,12 @@ class TestVarID : public TestFixture {
 
     void varid25() {
         const char code[] ="class foo()\n"
-                           "{\n"
-                           "public:\n"
-                           "    ;\n"
-                           "private:\n"
-                           "    mutable int i;\n"
-                           "};\n";
+                            "{\n"
+                            "public:\n"
+                            "    ;\n"
+                            "private:\n"
+                            "    mutable int i;\n"
+                            "};\n";
 
         const char expected[] = "1: class foo ( )\n"
                                 "2: {\n"
@@ -687,20 +793,20 @@ class TestVarID : public TestFixture {
 
     void varid27() {
         const char code[] ="int fooled_ya;\n"
-                           "fooled_ya::iterator iter;\n";
+                            "fooled_ya::iterator iter;\n";
         const char expected[] = "1: int fooled_ya@1 ;\n"
                                 "2: fooled_ya :: iterator iter@2 ;\n";
         ASSERT_EQUALS(expected, tokenize(code));
     }
 
     void varid28() { // ticket #2630 (segmentation fault)
-        ASSERT_THROW(tokenize("template <typedef A>\n"), InternalError);
+        ASSERT_THROW_INTERNAL(tokenize("template <typedef A>\n"), SYNTAX);
     }
 
     void varid29() {
         const char code[] ="class A {\n"
-                           "    B<C<1>,1> b;\n"
-                           "};\n";
+                            "    B<C<1>,1> b;\n"
+                            "};\n";
         const char expected[] = "1: class A {\n"
                                 "2: B < C < 1 > , 1 > b@1 ;\n"
                                 "3: } ;\n";
@@ -718,7 +824,7 @@ class TestVarID : public TestFixture {
                                  "3: EventPtr event@3 ; event@3 = * eventP@1 ;\n"
                                  "4: * actionsP@2 = & event@3 . actions@4 ;\n"
                                  "5: }\n";
-        ASSERT_EQUALS(expected1, tokenize(code1, false, "test.c"));
+        ASSERT_EQUALS(expected1, tokenize(code1, dinit(TokenizeOptions, $.cpp = false)));
 
         const char code2[] = "void f(int b, int c) {\n"
                              "    x(a*b*c,10);\n"
@@ -726,7 +832,7 @@ class TestVarID : public TestFixture {
         const char expected2[] = "1: void f ( int b@1 , int c@2 ) {\n"
                                  "2: x ( a * b@1 * c@2 , 10 ) ;\n"
                                  "3: }\n";
-        ASSERT_EQUALS(expected2, tokenize(code2, false, "test.c"));
+        ASSERT_EQUALS(expected2, tokenize(code2, dinit(TokenizeOptions, $.cpp = false)));
 
         const char code3[] = "class Nullpointer : public ExecutionPath\n"
                              " {\n"
@@ -734,25 +840,25 @@ class TestVarID : public TestFixture {
                              "        : ExecutionPath(c, id)\n"
                              "    {\n"
                              "    }\n"
-                             "}\n";
+                             "};\n";
         const char expected3[] = "1: class Nullpointer : public ExecutionPath\n"
                                  "2: {\n"
                                  "3: Nullpointer ( Check * c@1 , const unsigned int id@2 , const std :: string & name@3 )\n"
                                  "4: : ExecutionPath ( c@1 , id@2 )\n"
                                  "5: {\n"
                                  "6: }\n"
-                                 "7: }\n";
+                                 "7: } ;\n";
         ASSERT_EQUALS(expected3, tokenize(code3));
     }
 
     void varid34() { // ticket #2825
         const char code[] ="class Fred : public B1, public B2\n"
-                           "{\n"
-                           "public:\n"
-                           "    Fred() { a = 0; }\n"
-                           "private:\n"
-                           "    int a;\n"
-                           "};\n";
+                            "{\n"
+                            "public:\n"
+                            "    Fred() { a = 0; }\n"
+                            "private:\n"
+                            "    int a;\n"
+                            "};\n";
         const char expected[] = "1: class Fred : public B1 , public B2\n"
                                 "2: {\n"
                                 "3: public:\n"
@@ -761,15 +867,15 @@ class TestVarID : public TestFixture {
                                 "6: int a@1 ;\n"
                                 "7: } ;\n";
         ASSERT_EQUALS(expected, tokenize(code));
-        ASSERT_EQUALS("", errout.str());
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varid35() { // function declaration inside function body
         // #2937
         const char code[] ="int foo() {\n"
-                           "    int f(x);\n"
-                           "    return f;\n"
-                           "}\n";
+                            "    int f(x);\n"
+                            "    return f;\n"
+                            "}\n";
         const char expected[] = "1: int foo ( ) {\n"
                                 "2: int f@1 ( x ) ;\n"
                                 "3: return f@1 ;\n"
@@ -799,9 +905,9 @@ class TestVarID : public TestFixture {
 
     void varid36() { // ticket #2980 (segmentation fault)
         const char code[] ="#elif A\n"
-                           "A,a<b<x0\n";
-        tokenize(code);
-        ASSERT_EQUALS("", errout.str());
+                            "A,a<b<x0\n";
+        (void)tokenize(code);
+        ASSERT_EQUALS("", errout_str());
     }
 
     void varid37() {
@@ -837,7 +943,7 @@ class TestVarID : public TestFixture {
         {
             const char code[] = "static int const SZ = 22;\n";
             ASSERT_EQUALS("1: static const int SZ@1 = 22 ;\n",
-                          tokenize(code, false, "test.c"));
+                          tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
         }
     }
 
@@ -850,19 +956,21 @@ class TestVarID : public TestFixture {
     void varid41() {
         const char code1[] = "union evt; void f(const evt & event);";
         ASSERT_EQUALS("1: union evt ; void f ( const evt & event@1 ) ;\n",
-                      tokenize(code1, false, "test.c"));
+                      tokenize(code1));
+        ASSERT_THROW_INTERNAL(tokenize(code1, dinit(TokenizeOptions, $.cpp = false)), SYNTAX);
 
         const char code2[] = "struct evt; void f(const evt & event);";
         ASSERT_EQUALS("1: struct evt ; void f ( const evt & event@1 ) ;\n",
-                      tokenize(code2, false, "test.c"));
+                      tokenize(code2));
+        ASSERT_THROW_INTERNAL(tokenize(code2, dinit(TokenizeOptions, $.cpp = false)), SYNTAX);
     }
 
     void varid42() {
         const char code[] ="namespace fruit { struct banana {}; };\n"
-                           "class Fred {\n"
-                           "public:\n"
-                           "     struct fruit::banana Bananas[25];\n"
-                           "};";
+                            "class Fred {\n"
+                            "public:\n"
+                            "     struct fruit::banana Bananas[25];\n"
+                            "};";
         ASSERT_EQUALS("1: namespace fruit { struct banana { } ; } ;\n"
                       "2: class Fred {\n"
                       "3: public:\n"
@@ -874,7 +982,7 @@ class TestVarID : public TestFixture {
     void varid43() {
         const char code[] ="int main(int flag) { if(a & flag) { return 1; } }";
         ASSERT_EQUALS("1: int main ( int flag@1 ) { if ( a & flag@1 ) { return 1 ; } }\n",
-                      tokenize(code, false, "test.c"));
+                      tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void varid44() {
@@ -892,7 +1000,7 @@ class TestVarID : public TestFixture {
     void varid46() { // #3756
         const char code[] ="void foo() { int t; x = (struct t *)malloc(); f(t); }";
         ASSERT_EQUALS("1: void foo ( ) { int t@1 ; x = ( struct t * ) malloc ( ) ; f ( t@1 ) ; }\n",
-                      tokenize(code, false, "test.c"));
+                      tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void varid47() { // function parameters
@@ -900,7 +1008,7 @@ class TestVarID : public TestFixture {
         {
             const char code[] ="void f(std::string &string, std::string &len) {}";
             ASSERT_EQUALS("1: void f ( std :: string & string@1 , std :: string & len@2 ) { }\n",
-                          tokenize(code, false, "test.cpp"));
+                          tokenize(code));
         }
 
         // #4729
@@ -918,55 +1026,55 @@ class TestVarID : public TestFixture {
     void varid48() {  // #3785 - return (a*b)
         const char code[] ="int X::f(int b) const { return(a*b); }";
         ASSERT_EQUALS("1: int X :: f ( int b@1 ) const { return ( a * b@1 ) ; }\n",
-                      tokenize(code, false));
+                      tokenize(code));
     }
 
     void varid49() {  // #3799 - void f(std::vector<int>)
         const char code[] ="void f(std::vector<int>)";
         ASSERT_EQUALS("1: void f ( std :: vector < int > )\n",
-                      tokenize(code, false, "test.cpp"));
+                      tokenize(code));
     }
 
     void varid50() {  // #3760 - explicit
         const char code[] ="class A { explicit A(const A&); };";
         ASSERT_EQUALS("1: class A { explicit A ( const A & ) ; } ;\n",
-                      tokenize(code, false, "test.cpp"));
+                      tokenize(code));
     }
 
     void varid51() {  // don't set varid on template function
         const char code[] ="T t; t.x<0>();";
         ASSERT_EQUALS("1: T t@1 ; t@1 . x < 0 > ( ) ;\n",
-                      tokenize(code, false, "test.cpp"));
+                      tokenize(code));
     }
 
     void varid52() {
         const char code[] ="A<B<C>::D> e;\n"
-                           "B< C<> > b[10];\n"
-                           "B<C<>> c[10];";
+                            "B< C<> > b[10];\n"
+                            "B<C<>> c[10];";
         ASSERT_EQUALS("1: A < B < C > :: D > e@1 ;\n"
                       "2: B < C < > > b@2 [ 10 ] ;\n"
                       "3: B < C < > > c@3 [ 10 ] ;\n",
-                      tokenize(code, false, "test.cpp"));
+                      tokenize(code));
     }
 
     void varid53() { // #4172 - Template instantiation: T<&functionName> list[4];
         ASSERT_EQUALS("1: A < & f > list@1 [ 4 ] ;\n",
-                      tokenize("A<&f> list[4];", false, "test.cpp"));
+                      tokenize("A<&f> list[4];"));
     }
 
     void varid54() { // hang
         // Original source code: libgc
-        tokenize("STATIC ptr_t GC_approx_sp(void) { word sp; sp = (word)&sp; return((ptr_t)sp); }",true);
+        (void)tokenize("STATIC ptr_t GC_approx_sp(void) { word sp; sp = (word)&sp; return((ptr_t)sp); }");
     }
 
     void varid55() { // Ticket #5868
         const char code[] =     "typedef struct foo {} foo; "
-                                "void bar1(struct foo foo) {} "
-                                "void baz1(foo foo) {} "
-                                "void bar2(struct foo& foo) {} "
-                                "void baz2(foo& foo) {} "
-                                "void bar3(struct foo* foo) {} "
-                                "void baz3(foo* foo) {}";
+                            "void bar1(struct foo foo) {} "
+                            "void baz1(foo foo) {} "
+                            "void bar2(struct foo& foo) {} "
+                            "void baz2(foo& foo) {} "
+                            "void bar3(struct foo* foo) {} "
+                            "void baz3(foo* foo) {}";
         const char expected[] = "1: "
                                 "struct foo { } ; "
                                 "void bar1 ( struct foo foo@1 ) { } "
@@ -975,7 +1083,7 @@ class TestVarID : public TestFixture {
                                 "void baz2 ( struct foo & foo@4 ) { } "
                                 "void bar3 ( struct foo * foo@5 ) { } "
                                 "void baz3 ( struct foo * foo@6 ) { }\n";
-        ASSERT_EQUALS(expected, tokenize(code, false, "test.cpp"));
+        ASSERT_EQUALS(expected, tokenize(code));
     }
 
     void varid56() { // Ticket #6548 - function with a throw()
@@ -984,42 +1092,42 @@ class TestVarID : public TestFixture {
         const char expected1[] = "1: "
                                  "void fred ( int x@1 ) throw ( ) { } "
                                  "void wilma ( ) { x ++ ; }\n";
-        ASSERT_EQUALS(expected1, tokenize(code1, false, "test.cpp"));
+        ASSERT_EQUALS(expected1, tokenize(code1));
 
         const char code2[] = "void fred(int x) const throw(EXCEPT) {}"
                              "void wilma() { x++; }";
         const char expected2[] = "1: "
                                  "void fred ( int x@1 ) const throw ( EXCEPT ) { } "
                                  "void wilma ( ) { x ++ ; }\n";
-        ASSERT_EQUALS(expected2, tokenize(code2, false, "test.cpp"));
+        ASSERT_EQUALS(expected2, tokenize(code2));
 
         const char code3[] = "void fred(int x) throw() ABCD {}"
                              "void wilma() { x++; }";
         const char expected3[] = "1: "
                                  "void fred ( int x@1 ) throw ( ) { } "
                                  "void wilma ( ) { x ++ ; }\n";
-        ASSERT_EQUALS(expected3, tokenize(code3, false, "test.cpp"));
+        ASSERT_EQUALS(expected3, tokenize(code3));
 
         const char code4[] = "void fred(int x) noexcept() {}"
                              "void wilma() { x++; }";
         const char expected4[] = "1: "
                                  "void fred ( int x@1 ) noexcept ( ) { } "
                                  "void wilma ( ) { x ++ ; }\n";
-        ASSERT_EQUALS(expected4, tokenize(code4, false, "test.cpp"));
+        ASSERT_EQUALS(expected4, tokenize(code4));
 
         const char code5[] = "void fred(int x) noexcept {}"
                              "void wilma() { x++; }";
         const char expected5[] = "1: "
                                  "void fred ( int x@1 ) noexcept ( true ) { } "
                                  "void wilma ( ) { x ++ ; }\n";
-        ASSERT_EQUALS(expected5, tokenize(code5, false, "test.cpp"));
+        ASSERT_EQUALS(expected5, tokenize(code5));
 
         const char code6[] = "void fred(int x) noexcept ( false ) {}"
                              "void wilma() { x++; }";
         const char expected6[] = "1: "
                                  "void fred ( int x@1 ) noexcept ( false ) { } "
                                  "void wilma ( ) { x ++ ; }\n";
-        ASSERT_EQUALS(expected6, tokenize(code6, false, "test.cpp"));
+        ASSERT_EQUALS(expected6, tokenize(code6));
     }
 
     void varid57() { // #6636: new scope by {}
@@ -1049,7 +1157,7 @@ class TestVarID : public TestFixture {
                                  "11: }\n"
                                  "12:\n"
                                  "13: }\n";
-        ASSERT_EQUALS(expected1, tokenize(code1, false, "test.cpp"));
+        ASSERT_EQUALS(expected1, tokenize(code1));
     }
 
     void varid58() { // #6638: for loop in for condition
@@ -1067,7 +1175,7 @@ class TestVarID : public TestFixture {
                                  "5: i@1 ++ ;\n"
                                  "6: }\n"
                                  "7: }\n";
-        ASSERT_EQUALS(expected1, tokenize(code1, false, "test.cpp"));
+        ASSERT_EQUALS(expected1, tokenize(code1));
     }
 
     void varid59() { // #6696
@@ -1082,13 +1190,13 @@ class TestVarID : public TestFixture {
         const char wanted[] = "1: class DLLSYM B@1 ;\n"
                               "2: struct B {\n"
                               "3: ~ B ( ) { }\n"
-                              "4: } ;\n";;
-        TODO_ASSERT_EQUALS(wanted, expected, tokenize(code, false, "test.cpp"));
+                              "4: } ;\n";
+        TODO_ASSERT_EQUALS(wanted, expected, tokenize(code));
     }
 
     void varid60() { // #7267 - cast
         ASSERT_EQUALS("1: a = ( x y ) 10 ;\n",
-                      tokenize("a=(x y)10;", false));
+                      tokenize("a=(x y)10;"));
     }
 
     void varid61() {
@@ -1098,7 +1206,7 @@ class TestVarID : public TestFixture {
         const char expected[] = "1: void foo ( int b@1 ) {\n"
                                 "2: void bar ( int a@2 , int b@3 ) { }\n"
                                 "3: }\n";
-        ASSERT_EQUALS(expected, tokenize(code, false));
+        ASSERT_EQUALS(expected, tokenize(code));
     }
 
     void varid62() {
@@ -1115,8 +1223,230 @@ class TestVarID : public TestFixture {
 
     void varid63() {
         const char code[] = "void f(boost::optional<int> const& x) {}";
-        const char expected[] = "1: void f ( boost :: optional < int > const & x@1 ) { }\n";
-        ASSERT_EQUALS(expected, tokenize(code, false));
+        const char expected[] = "1: void f ( const boost :: optional < int > & x@1 ) { }\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void varid64() {
+        const char code[] = "extern const char (*x[256]);";
+        const char expected[] = "1: extern const char ( * x@1 [ 256 ] ) ;\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void varid65() { // #10936
+        {
+            const char code[] = "extern int (*p);";
+            const char expected[] = "1: extern int ( * p@1 ) ;\n";
+            ASSERT_EQUALS(expected, tokenize(code));
+        }
+        {
+            const char code[] = "extern int (i);";
+            const char expected[] = "1: extern int ( i@1 ) ;\n";
+            ASSERT_EQUALS(expected, tokenize(code));
+        }
+        {
+            const char code[] = "int (*p);";
+            const char expected[] = "1: int ( * p@1 ) ;\n";
+            ASSERT_EQUALS(expected, tokenize(code));
+        }
+        {
+            const char code[] = "int (i);";
+            const char expected[] = "1: int ( i@1 ) ;\n";
+            ASSERT_EQUALS(expected, tokenize(code));
+        }
+    }
+
+    void varid66() {
+        {
+            const char code[] = "std::string g();\n"
+                                "const std::string s(g() + \"abc\");\n";
+            const char expected[] = "1: std :: string g ( ) ;\n"
+                                    "2: const std :: string s@1 ( g ( ) + \"abc\" ) ;\n";
+            ASSERT_EQUALS(expected, tokenize(code));
+        }
+        {
+            const char code[] = "enum E {};\n"
+                                "typedef E(*fp_t)();\n"
+                                "E f(fp_t fp);\n";
+            const char expected[] = "1: enum E { } ;\n"
+                                    "2:\n"
+                                    "3: E f ( E ( * fp@1 ) ( ) ) ;\n";
+            ASSERT_EQUALS(expected, tokenize(code));
+        }
+    }
+
+    void varid67() { // #11711
+        const char code1[] = "int *x;\n"
+                             "_Generic(*x, int: foo, default: bar)();";
+        const char expected1[] = "1: int * x@1 ;\n"
+                                 "2: _Generic ( * x@1 , int : foo , default : bar ) ( ) ;\n";
+        ASSERT_EQUALS(expected1, tokenize(code1, dinit(TokenizeOptions, $.cpp = false)));
+    }
+
+    void varid68() { // #11740
+        const char code1[] = "struct S {};\n"
+                             "char* str_chars(struct S* s);\n"
+                             "void f(struct S strOut) {\n"
+                             "	 switch (str_chars(&strOut)[0])  {}\n"
+                             "}";
+        const char expected1[] = "1: struct S { } ;\n"
+                                 "2: char * str_chars ( struct S * s@1 ) ;\n"
+                                 "3: void f ( struct S strOut@2 ) {\n"
+                                 "4: switch ( str_chars ( & strOut@2 ) [ 0 ] ) { }\n"
+                                 "5: }\n";
+        ASSERT_EQUALS(expected1, tokenize(code1, dinit(TokenizeOptions, $.cpp = false)));
+        ASSERT_EQUALS(expected1, tokenize(code1));
+    }
+
+    void varid69() {
+        const char code1[] = "void f() {\n"
+                             "    auto g = [](int&, int& r, int i) {};\n"
+                             "}";
+        const char expected1[] = "1: void f ( ) {\n"
+                                 "2: auto g@1 ; g@1 = [ ] ( int & , int & r@2 , int i@3 ) { } ;\n"
+                                 "3: }\n";
+        ASSERT_EQUALS(expected1, tokenize(code1));
+    }
+
+    void varid70() {
+        // isFunctionHead
+        const char code1[] = "int x = 1 ? (1 << 0) : 0;\n"
+                             "void foo(bool init);\n"
+                             "void init();\n";
+        const char expected1[] = "1: int x@1 ; x@1 = 1 ? ( 1 << 0 ) : 0 ;\n"
+                                 "2: void foo ( bool init@2 ) ;\n"
+                                 "3: void init ( ) ;\n";
+        ASSERT_EQUALS(expected1, tokenize(code1));
+
+        const char code2[] = "int x = 1 ? f(1 << 0) : 0;\n"
+                             "void foo(bool init);\n"
+                             "void init();\n";
+        const char expected2[] = "1: int x@1 ; x@1 = 1 ? f ( 1 << 0 ) : 0 ;\n"
+                                 "2: void foo ( bool init@2 ) ;\n"
+                                 "3: void init ( ) ;\n";
+        ASSERT_EQUALS(expected2, tokenize(code2));
+
+        const char code3[] = "extern void (*arr[10])(uint32_t some);\n";
+        const char expected3[] = "1: extern void ( * arr@1 [ 10 ] ) ( uint32_t some@2 ) ;\n";
+        ASSERT_EQUALS(expected3, tokenize(code3));
+
+        const char code4[] = "_Static_assert(sizeof((struct S){0}.i) == 4);\n"; // #12729
+        const char expected4[] = "1: _Static_assert ( sizeof ( ( struct S ) { 0 } . i ) == 4 ) ;\n";
+        ASSERT_EQUALS(expected4, tokenize(code4, dinit(TokenizeOptions, $.cpp = false)));
+    }
+
+    void varid71() {
+        const char code[] = "namespace myspace {\n"
+                            "\n"
+                            "template <typename T>\n"
+                            "class CounterTest {\n"
+                            "public:\n"
+                            "  CounterTest(T _obj);\n"
+                            "  template <typename T2>\n"
+                            "  CounterTest(const CounterTest<T2>& ptr);\n"
+                            "  T obj;\n"
+                            "  int count;\n"
+                            "};\n"
+                            "\n"
+                            "template <typename T>\n"
+                            "CounterTest<T>::CounterTest(T _obj) : obj(_obj) {\n"
+                            "  count = 0;\n"
+                            "}\n"
+                            "\n"
+                            "template <typename T>\n"
+                            "template <typename T2>\n"
+                            "CounterTest<T>::CounterTest(const CounterTest<T2>& p) : obj(0) {\n"
+                            "  count = p.count;\n"
+                            "}\n"
+                            "\n"
+                            "}\n"
+                            "\n"
+                            "using namespace myspace;\n"
+                            "CounterTest<int> myobj(0);\n";
+        const char expected[] = "1: namespace myspace {\n"
+                                "2:\n"
+                                "3: class CounterTest<int> ;\n"
+                                "4:\n"
+                                "|\n"
+                                "17:\n"
+                                "18: template < typename T >\n"
+                                "19: template < typename T2 >\n"
+                                "20: CounterTest < T > :: CounterTest ( const CounterTest < T2 > & p@1 ) : obj ( 0 ) {\n"
+                                "21: count = p@1 . count@2 ;\n"
+                                "22: }\n"
+                                "23:\n"
+                                "24: }\n"
+                                "25:\n"
+                                "26: using namespace myspace ;\n"
+                                "27: myspace :: CounterTest<int> myobj@3 ( 0 ) ;\n"
+                                "4: class myspace :: CounterTest<int> {\n"
+                                "5: public:\n"
+                                "6: CounterTest<int> ( int _obj@4 ) ;\n"
+                                "7: template < typename T2 >\n"
+                                "8: CounterTest<int> ( const myspace :: CounterTest < T2 > & ptr@5 ) ;\n"
+                                "9: int obj@6 ;\n"
+                                "10: int count@7 ;\n"
+                                "11: } ;\n"
+                                "12:\n"
+                                "13:\n"
+                                "14: myspace :: CounterTest<int> :: CounterTest<int> ( int _obj@8 ) : obj@6 ( _obj@8 ) {\n"
+                                "15: count@7 = 0 ;\n"
+                                "16: }\n"
+                                "17:\n"
+                                "18:\n"
+                                "19:\n"
+                                "20: myspace :: CounterTest<int> :: CounterTest<int> ( const myspace :: CounterTest < T2 > & p@9 ) : obj@6 ( 0 ) {\n"
+                                "21: count@7 = p@9 . count@10 ;\n"
+                                "22: }\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void varid72() {
+        const char code1[] = "static_assert(true && true);\n"; // #14386
+        const char expected1[] = "1: static_assert ( true && true ) ;\n";
+        ASSERT_EQUALS(expected1, tokenize(code1));
+    }
+
+    void varid_for_1() {
+        const char code[] = "void foo(int a, int b) {\n"
+                            "  for (int a=1,b=2;;) {}\n"
+                            "}";
+        const char expected[] = "1: void foo ( int a@1 , int b@2 ) {\n"
+                                "2: for ( int a@3 = 1 , b@4 = 2 ; ; ) { }\n"
+                                "3: }\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void varid_for_2() {
+        const char code[] = "void foo(int a, int b) {\n"
+                            "  for (int a=f(x,y,z),b=2;;) {}\n"
+                            "}";
+        const char expected[] = "1: void foo ( int a@1 , int b@2 ) {\n"
+                                "2: for ( int a@3 = f ( x , y , z ) , b@4 = 2 ; ; ) { }\n"
+                                "3: }\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void varid_for_3() {
+        const char code[] = "void f(int w, int h) {\n" // #13670
+                            "    for (int a[2] = { 2, w / 2 }, b = 2; a[1] && a[0] <= h; a[1] /= 2, a[0] *= 2) {}\n"
+                            "}\n";
+        const char expected[] = "1: void f ( int w@1 , int h@2 ) {\n"
+                                "2: for ( int a@3 [ 2 ] = { 2 , w@1 / 2 } , b@4 = 2 ; a@3 [ 1 ] && a@3 [ 0 ] <= h@2 ; a@3 [ 1 ] /= 2 , a@3 [ 0 ] *= 2 ) { }\n"
+                                "3: }\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+
+        const char code2[] = "void f() {\n"
+                             "    for (int a(1), b{ 2 }, c = 3; a < b + c; ++a) {}\n"
+                             "    for (int a{ 1 }, b(2), c = 3; a < b + c; ++a) {}\n"
+                             "    for (int a = 1, b{ 2 }, c(3); a < b + c; ++a) {}\n"
+                             "}\n";
+        const char expected2[] = "1: void f ( ) {\n"
+                                 "2: for ( int a@1 ( 1 ) , b@2 { 2 } , c@3 = 3 ; a@1 < b@2 + c@3 ; ++ a@1 ) { }\n"
+                                 "3: for ( int a@4 { 1 } , b@5 ( 2 ) , c@6 = 3 ; a@4 < b@5 + c@6 ; ++ a@4 ) { }\n"
+                                 "4: for ( int a@7 = 1 , b@8 { 2 } , c@9 ( 3 ) ; a@7 < b@8 + c@9 ; ++ a@7 ) { }\n"
+                                 "5: }\n";
+        ASSERT_EQUALS(expected2, tokenize(code2));
     }
 
     void varid_cpp_keywords_in_c_code() {
@@ -1130,7 +1460,7 @@ class TestVarID : public TestFixture {
                                 "3: throw t@2 ;\n"
                                 "4: }\n";
 
-        ASSERT_EQUALS(expected, tokenize(code,false,"test.c"));
+        ASSERT_EQUALS(expected, tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void varid_cpp_keywords_in_c_code2() { // #5373
@@ -1143,39 +1473,56 @@ class TestVarID : public TestFixture {
                             "  return clear_extent_bit(tree, start, end, EXTENT_DIRTY | EXTENT_DELALLOC | "
                             "                          EXTENT_DO_ACCOUNTING, 0, 0, NULL, mask);\n"
                             "}";
-        tokenize(code, false, "test.c");
+        ASSERT_NO_THROW(tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
+    }
+
+    void varid_cpp_keywords_in_c_code3() { // #12120
+        const char code[] = "const struct class *p;";
+        const char expected[] = "1: const struct class * p@1 ;\n";
+        ASSERT_EQUALS(expected, tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
+    }
+
+    void varid_cpp_keywords_in_c_code4() { // #12120
+        {
+            const char code[] = "int false = 0;";
+            ASSERT_THROW_INTERNAL_EQUALS(tokenize(code, dinit(TokenizeOptions, $.cpp = true)), INTERNAL, "Internal error. VarId set for bool literal.");
+        }
+        {
+            const char code[] = "int false = 0;";
+            ASSERT_EQUALS("1: int false@1 ; false@1 = 0 ;\n", tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
+        }
     }
 
     void varidFunctionCall1() {
         const char code[] ="void f() {\n"
-                           "    int x;\n"
-                           "    x = a(y*x,10);\n"
-                           "}";
+                            "    int x;\n"
+                            "    x = a(y*x,10);\n"
+                            "}";
         const char expected[] = "1: void f ( ) {\n"
                                 "2: int x@1 ;\n"
                                 "3: x@1 = a ( y * x@1 , 10 ) ;\n"
                                 "4: }\n";
-        ASSERT_EQUALS(expected, tokenize(code, false, "test.c"));
+        ASSERT_EQUALS(expected, tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void varidFunctionCall2() {
         // #2491
         const char code[] ="void f(int b) {\n"
-                           "    x(a*b,10);\n"
-                           "}";
+                            "    x(a*b,10);\n"
+                            "}";
         const std::string expected1("1: void f ( int b@1 ) {\n"
                                     "2: x ( a * b");
         const std::string expected2(" , 10 ) ;\n"
                                     "3: }\n");
-        ASSERT_EQUALS(expected1+"@1"+expected2, tokenize(code,false,"test.c"));
+        ASSERT_EQUALS(expected1+"@1"+expected2, tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void varidFunctionCall3() {
         // Ticket #2339
         const char code[] ="void f() {\n"
-                           "    int a = 0;\n"
-                           "    int b = c - (foo::bar * a);\n"
-                           "}";
+                            "    int a = 0;\n"
+                            "    int b = c - (foo::bar * a);\n"
+                            "}";
 
         const char expected[] = "1: void f ( ) {\n"
                                 "2: int a@1 ; a@1 = 0 ;\n"
@@ -1189,36 +1536,35 @@ class TestVarID : public TestFixture {
         // Ticket #3280
         const char code1[] = "void f() { int x; fun(a,b*x); }";
         ASSERT_EQUALS("1: void f ( ) { int x@1 ; fun ( a , b * x@1 ) ; }\n",
-                      tokenize(code1, false, "test.c"));
+                      tokenize(code1, dinit(TokenizeOptions, $.cpp = false)));
         const char code2[] = "void f(int a) { int x; fun(a,b*x); }";
         ASSERT_EQUALS("1: void f ( int a@1 ) { int x@2 ; fun ( a@1 , b * x@2 ) ; }\n",
-                      tokenize(code2, false, "test.c"));
+                      tokenize(code2, dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void varidFunctionCall5() {
         const char code[] = "void foo() { (f(x[2]))(x[2]); }";
         ASSERT_EQUALS("1: void foo ( ) { f ( x [ 2 ] ) ( x [ 2 ] ) ; }\n",
-                      tokenize(code, false, "test.c"));
+                      tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void varidStl() {
         const std::string actual = tokenize(
-                                       "list<int> ints;\n"
-                                       "list<int>::iterator it;\n"
-                                       "std::vector<std::string> dirs;\n"
-                                       "std::map<int, int> coords;\n"
-                                       "std::tr1::unordered_map<int, int> xy;\n"
-                                       "std::list<boost::wave::token_id> tokens;\n"
-                                       "static std::vector<CvsProcess*> ex1;\n"
-                                       "extern std::vector<CvsProcess*> ex2;\n"
-                                       "std::map<int, 1> m;\n"
-                                   );
+            "list<int> ints;\n"
+            "list<int>::iterator it;\n"
+            "std::vector<std::string> dirs;\n"
+            "std::map<int, int> coords;\n"
+            "std::tr1::unordered_map<int, int> xy;\n"
+            "std::list<boost::wave::token_id> tokens;\n"
+            "static std::vector<CvsProcess*> ex1;\n"
+            "extern std::vector<CvsProcess*> ex2;\n"
+            "std::map<int, 1> m;");
 
         const char expected[] = "1: list < int > ints@1 ;\n"
                                 "2: list < int > :: iterator it@2 ;\n"
                                 "3: std :: vector < std :: string > dirs@3 ;\n"
                                 "4: std :: map < int , int > coords@4 ;\n"
-                                "5: std :: unordered_map < int , int > xy@5 ;\n"
+                                "5: std :: tr1 :: unordered_map < int , int > xy@5 ;\n"
                                 "6: std :: list < boost :: wave :: token_id > tokens@6 ;\n"
                                 "7: static std :: vector < CvsProcess * > ex1@7 ;\n"
                                 "8: extern std :: vector < CvsProcess * > ex2@8 ;\n"
@@ -1242,11 +1588,11 @@ class TestVarID : public TestFixture {
 
     void varid_delete() {
         const std::string actual = tokenize(
-                                       "void f()\n"
-                                       "{\n"
-                                       "  int *a;\n"
-                                       "  delete a;\n"
-                                       "}\n");
+            "void f()\n"
+            "{\n"
+            "  int *a;\n"
+            "  delete a;\n"
+            "}");
 
         const char expected[] = "1: void f ( )\n"
                                 "2: {\n"
@@ -1260,8 +1606,8 @@ class TestVarID : public TestFixture {
     void varid_functions() {
         {
             const std::string actual = tokenize(
-                                           "void f();\n"
-                                           "void f(){}\n", false, "test.c");
+                "void f();\n"
+                "void f(){}\n", dinit(TokenizeOptions, $.cpp = false));
 
             const char expected[] = "1: void f ( ) ;\n"
                                     "2: void f ( ) { }\n";
@@ -1271,10 +1617,10 @@ class TestVarID : public TestFixture {
 
         {
             const std::string actual = tokenize(
-                                           "A f(3);\n"
-                                           "A f2(true);\n"
-                                           "A g();\n"
-                                           "A e(int c);\n", false, "test.c");
+                "A f(3);\n"
+                "A f2(true);\n"
+                "A g();\n"
+                "A e(int c);\n", dinit(TokenizeOptions, $.cpp = false));
 
             const char expected[] = "1: A f@1 ( 3 ) ;\n"
                                     "2: A f2@2 ( true ) ;\n"
@@ -1286,18 +1632,18 @@ class TestVarID : public TestFixture {
 
         {
             const std::string actual = tokenize(
-                                           "void f1(int &p)\n"
-                                           "{\n"
-                                           "    p = 0;\n"
-                                           "}\n"
-                                           "void f2(std::string &str)\n"
-                                           "{\n"
-                                           "   str.clear();\n"
-                                           "}\n"
-                                           "void f3(const std::string &s)\n"
-                                           "{\n"
-                                           "    s.size();\n"
-                                           "}\n");
+                "void f1(int &p)\n"
+                "{\n"
+                "    p = 0;\n"
+                "}\n"
+                "void f2(std::string &str)\n"
+                "{\n"
+                "   str.clear();\n"
+                "}\n"
+                "void f3(const std::string &s)\n"
+                "{\n"
+                "    s.size();\n"
+                "}");
 
             const char expected[] = "1: void f1 ( int & p@1 )\n"
                                     "2: {\n"
@@ -1316,32 +1662,62 @@ class TestVarID : public TestFixture {
         }
 
         {
-            const std::string actual = tokenize("void f(struct foobar);", false, "test.c");
+            const std::string actual = tokenize("void f(struct foobar);", dinit(TokenizeOptions, $.cpp = false));
             const char expected[] = "1: void f ( struct foobar ) ;\n";
             ASSERT_EQUALS(expected, actual);
         }
 
         {
-            const std::string actual = tokenize("bool f(X x, int=3);", false, "test.cpp");
+            const std::string actual = tokenize("bool f(X x, int=3);");
             const char expected[] = "1: bool f ( X x@1 , int = 3 ) ;\n";
             ASSERT_EQUALS(expected, actual);
         }
+
+        {
+            const std::string actual = tokenize("int main() {\n"
+                                                "    int a[2];\n"
+                                                "    extern void f(int a[2]);\n"
+                                                "    f(a);\n"
+                                                "    a[0] = 0;\n"
+                                                "}\n");
+            const char expected[] = "1: int main ( ) {\n"
+                                    "2: int a@1 [ 2 ] ;\n"
+                                    "3: extern void f ( int a [ 2 ] ) ;\n"
+                                    "4: f ( a@1 ) ;\n"
+                                    "5: a@1 [ 0 ] = 0 ;\n"
+                                    "6: }\n";
+            ASSERT_EQUALS(expected, actual);
+        }
+
+        {
+            const std::string actual = tokenize("void f(int n) {\n" // #12537
+                                                "    int n1;\n"
+                                                "    void g(int is, int n1);\n"
+                                                "    n1 = n - 1;\n"
+                                                "}\n");
+            const char expected[] = "1: void f ( int n@1 ) {\n"
+                                    "2: int n1@2 ;\n"
+                                    "3: void g ( int is , int n1 ) ;\n"
+                                    "4: n1@2 = n@1 - 1 ;\n"
+                                    "5: }\n";
+            ASSERT_EQUALS(expected, actual);
+        }
     }
 
     void varid_sizeof() {
         const char code[] = "x = sizeof(a*b);";
         const char expected[] = "1: x = sizeof ( a * b ) ;\n";
-        ASSERT_EQUALS(expected, tokenize(code,false,"test.c"));
+        ASSERT_EQUALS(expected, tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void varid_reference_to_containers() {
         const std::string actual = tokenize(
-                                       "void f()\n"
-                                       "{\n"
-                                       "    std::vector<int> b;\n"
-                                       "    std::vector<int> &a = b;\n"
-                                       "    std::vector<int> *c = &b;\n"
-                                       "}\n");
+            "void f()\n"
+            "{\n"
+            "    std::vector<int> b;\n"
+            "    std::vector<int> &a = b;\n"
+            "    std::vector<int> *c = &b;\n"
+            "}");
 
         const char expected[] = "1: void f ( )\n"
                                 "2: {\n"
@@ -1356,12 +1732,12 @@ class TestVarID : public TestFixture {
     void varid_in_class1() {
         {
             const std::string actual = tokenize(
-                                           "class Foo\n"
-                                           "{\n"
-                                           "public:\n"
-                                           "    std::string name1;\n"
-                                           "    std::string name2;\n"
-                                           "};\n");
+                "class Foo\n"
+                "{\n"
+                "public:\n"
+                "    std::string name1;\n"
+                "    std::string name2;\n"
+                "};");
 
             const char expected[] = "1: class Foo\n"
                                     "2: {\n"
@@ -1375,19 +1751,19 @@ class TestVarID : public TestFixture {
 
         {
             const std::string actual = tokenize(
-                                           "class foo\n"
-                                           "{\n"
-                                           "public:\n"
-                                           "    void do_something(const int x, const int y);\n"
-                                           "    void bar();\n"
-                                           "};\n"
-                                           "\n"
-                                           "void foo::bar()\n"
-                                           "{\n"
-                                           "    POINT pOutput = { 0 , 0 };\n"
-                                           "    int x = pOutput.x;\n"
-                                           "    int y = pOutput.y;\n"
-                                           "}\n");
+                "class foo\n"
+                "{\n"
+                "public:\n"
+                "    void do_something(const int x, const int y);\n"
+                "    void bar();\n"
+                "};\n"
+                "\n"
+                "void foo::bar()\n"
+                "{\n"
+                "    POINT pOutput = { 0 , 0 };\n"
+                "    int x = pOutput.x;\n"
+                "    int y = pOutput.y;\n"
+                "}");
 
             const char expected[] = "1: class foo\n"
                                     "2: {\n"
@@ -1409,20 +1785,20 @@ class TestVarID : public TestFixture {
 
     void varid_in_class2() {
         const std::string actual = tokenize(
-                                       "struct Foo {\n"
-                                       "    int x;\n"
-                                       "};\n"
-                                       "\n"
-                                       "struct Bar {\n"
-                                       "    Foo foo;\n"
-                                       "    int x;\n"
-                                       "    void f();\n"
-                                       "};\n"
-                                       "\n"
-                                       "void Bar::f()\n"
-                                       "{\n"
-                                       "    foo.x = x;\n"
-                                       "}\n");
+            "struct Foo {\n"
+            "    int x;\n"
+            "};\n"
+            "\n"
+            "struct Bar {\n"
+            "    Foo foo;\n"
+            "    int x;\n"
+            "    void f();\n"
+            "};\n"
+            "\n"
+            "void Bar::f()\n"
+            "{\n"
+            "    foo.x = x;\n"
+            "}");
         const char expected[] = "1: struct Foo {\n"
                                 "2: int x@1 ;\n"
                                 "3: } ;\n"
@@ -1507,6 +1883,20 @@ class TestVarID : public TestFixture {
                       tokenize(code));
     }
 
+    void varid_in_class8() {  // #3776 - unknown macro
+        const char code[] = "class A {\n"
+                            "  UNKNOWN_MACRO(A)\n"
+                            "private:\n"
+                            "  int x;\n"
+                            "};";
+        ASSERT_EQUALS("1: class A {\n"
+                      "2: UNKNOWN_MACRO ( A )\n"
+                      "3: private:\n"
+                      "4: int x@1 ;\n"
+                      "5: } ;\n",
+                      tokenize(code));
+    }
+
     void varid_in_class9() {  // #4291 - id for variables accessed through 'this'
         const char code1[] = "class A {\n"
                              "  int var;\n"
@@ -1631,15 +2021,15 @@ class TestVarID : public TestFixture {
     void varid_in_class13() {
         const char code1[] = "struct a { char typename; };";
         ASSERT_EQUALS("1: struct a { char typename@1 ; } ;\n",
-                      tokenize(code1, false, "test.c"));
+                      tokenize(code1, dinit(TokenizeOptions, $.cpp = false)));
         ASSERT_EQUALS("1: struct a { char typename ; } ;\n",  // not valid C++ code
-                      tokenize(code1, false, "test.cpp"));
+                      tokenize(code1));
 
         const char code2[] = "struct a { char typename[2]; };";
         ASSERT_EQUALS("1: struct a { char typename@1 [ 2 ] ; } ;\n",
-                      tokenize(code2, false, "test.c"));
+                      tokenize(code2, dinit(TokenizeOptions, $.cpp = false)));
         ASSERT_EQUALS("1: struct a { char typename [ 2 ] ; } ;\n",  // not valid C++ code
-                      tokenize(code2, false, "test.cpp"));
+                      tokenize(code2));
     }
 
     void varid_in_class14() {
@@ -1656,7 +2046,7 @@ class TestVarID : public TestFixture {
                       "4: std :: list < int > x@2 ;\n"
                       "5: list@1 . do_something ( ) ;\n"
                       "6: Tokenizer :: list@1 . do_something ( ) ;\n"
-                      "7: }\n", tokenize(code, false, "test.cpp"));
+                      "7: }\n", tokenize(code));
     }
 
     void varid_in_class15() { // #5533 - functions
@@ -1667,7 +2057,7 @@ class TestVarID : public TestFixture {
         ASSERT_EQUALS("1: class Fred {\n"
                       "2: void x ( int a@1 ) const ;\n"
                       "3: void y ( ) { a = 0 ; }\n"
-                      "4: }\n", tokenize(code, false, "test.cpp"));
+                      "4: }\n", tokenize(code));
     }
 
     void varid_in_class16() { // Set varId for inline member functions
@@ -1679,7 +2069,7 @@ class TestVarID : public TestFixture {
             ASSERT_EQUALS("1: class Fred {\n"
                           "2: int x@1 ;\n"
                           "3: void foo ( int x@2 ) { this . x@1 = x@2 ; }\n"
-                          "4: } ;\n", tokenize(code, false, "test.cpp"));
+                          "4: } ;\n", tokenize(code));
         }
         {
             const char code[] = "class Fred {\n"
@@ -1689,7 +2079,7 @@ class TestVarID : public TestFixture {
             ASSERT_EQUALS("1: class Fred {\n"
                           "2: void foo ( int x@1 ) { this . x@2 = x@1 ; }\n"
                           "3: int x@2 ;\n"
-                          "4: } ;\n", tokenize(code, false, "test.cpp"));
+                          "4: } ;\n", tokenize(code));
         }
         {
             const char code[] = "class Fred {\n"
@@ -1699,7 +2089,7 @@ class TestVarID : public TestFixture {
             ASSERT_EQUALS("1: class Fred {\n"
                           "2: void foo ( int x@1 ) { ( * this ) . x@2 = x@1 ; }\n"
                           "3: int x@2 ;\n"
-                          "4: } ;\n", tokenize(code, false, "test.cpp"));
+                          "4: } ;\n", tokenize(code));
         }
     }
 
@@ -1727,7 +2117,7 @@ class TestVarID : public TestFixture {
                       "9: FOO Set ( BAR ) ;\n"
                       "10: int method_with_class ( B < B > b@3 ) ;\n"
                       "11: bool function ( std :: map < int , int , MYless > & m@4 ) ;\n"
-                      "12: } ;\n", tokenize(code1, false, "test.cpp"));
+                      "12: } ;\n", tokenize(code1));
 
         const char code2[] = "int i;\n"
                              "SomeType someVar1(i, i);\n"
@@ -1738,7 +2128,7 @@ class TestVarID : public TestFixture {
                       "2: SomeType someVar1@2 ( i@1 , i@1 ) ;\n"
                       "3: SomeType someVar2 ( j , j ) ;\n" // This one could be a function
                       "4: SomeType someVar3@3 ( j , 1 ) ;\n"
-                      "5: SomeType someVar4@4 ( new bar ) ;\n", tokenize(code2, false, "test.cpp"));
+                      "5: SomeType someVar4@4 ( new bar ) ;\n", tokenize(code2));
     }
 
     void varid_in_class18() {
@@ -1761,7 +2151,7 @@ class TestVarID : public TestFixture {
                       "7: } ;\n"
                       "8: A :: B :: B ( ) :\n"
                       "9: i@1 ( 0 )\n"
-                      "10: { }\n", tokenize(code, false, "test.cpp"));
+                      "10: { }\n", tokenize(code));
     }
 
     void varid_in_class19() {
@@ -1778,7 +2168,7 @@ class TestVarID : public TestFixture {
                       "4: } ;\n"
                       "5: Fred :: ~ Fred ( ) {\n"
                       "6: free ( str1@1 ) ;\n"
-                      "7: }\n", tokenize(code, false, "test.cpp"));
+                      "7: }\n", tokenize(code));
     }
 
     void varid_in_class20() {
@@ -1798,7 +2188,7 @@ class TestVarID : public TestFixture {
                       "5: cacheEntry ( ) ;\n"
                       "6: } ;\n"
                       "7:\n"
-                      "8: template < class C > cacheEntry < C > :: cacheEntry ( ) : m_key@1 ( ) { }\n", tokenize(code, false, "test.cpp"));
+                      "8: template < class C > cacheEntry < C > :: cacheEntry ( ) : m_key@1 ( ) { }\n", tokenize(code));
     }
 
     void varid_in_class21() {
@@ -1820,7 +2210,197 @@ class TestVarID : public TestFixture {
                                 "7: template < typename t1 , typename t2 >\n"
                                 "8: A :: B < t1 , t2 > :: B ( ) : x@1 ( 9 ) { }\n";
 
-        ASSERT_EQUALS(expected, tokenize(code, false, "test.cpp"));
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void varid_in_class22() {
+        const char code[] = "struct data {};\n"
+                            "    struct S {\n"
+                            "    std::vector<data> std;\n"
+                            "    void f();\n"
+                            "};\n"
+                            "void S::f() {\n"
+                            "    std::vector<data>::const_iterator end = std.end();\n"
+                            "    for (std::vector<data>::const_iterator i = std.begin(); i != end; ++i) {}\n"
+                            "}\n";
+
+        const char expected[] = "1: struct data { } ;\n"
+                                "2: struct S {\n"
+                                "3: std :: vector < data > std@1 ;\n"
+                                "4: void f ( ) ;\n"
+                                "5: } ;\n"
+                                "6: void S :: f ( ) {\n"
+                                "7: std :: vector < data > :: const_iterator end@2 ; end@2 = std@1 . end ( ) ;\n"
+                                "8: for ( std :: vector < data > :: const_iterator i@3 = std@1 . begin ( ) ; i@3 != end@2 ; ++ i@3 ) { }\n"
+                                "9: }\n";
+
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void varid_in_class23() { // #11293
+        const char code[] = "struct A {\n"
+                            "    struct S {\n"
+                            "        bool b;\n"
+                            "    };\n"
+                            "};\n"
+                            "struct B : A::S {\n"
+                            "    void f() { b = false; }\n"
+                            "};\n";
+
+        const char expected[] = "1: struct A {\n"
+                                "2: struct S {\n"
+                                "3: bool b@1 ;\n"
+                                "4: } ;\n"
+                                "5: } ;\n"
+                                "6: struct B : A :: S {\n"
+                                "7: void f ( ) { b@1 = false ; }\n"
+                                "8: } ;\n";
+
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void varid_in_class24() {
+        const char *expected{};
+
+        {
+            const char code[] = "class A {\n"
+                                "    Q_OBJECT\n"
+                                "public:\n"
+                                "    using QPtr = QPointer<A>;\n"
+                                "};\n";
+            expected = "1: class A {\n"
+                       "2: Q_OBJECT\n"
+                       "3: public:\n"
+                       "4:\n"
+                       "5: } ;\n";
+            ASSERT_EQUALS(expected, tokenize(code));
+        }
+
+        {
+            const char code[] = "class A {\n"
+                                "    Q_OBJECT\n"
+                                "    using QPtr = QPointer<A>;\n"
+                                "};\n";
+            expected = "1: class A {\n"
+                       "2: Q_OBJECT\n"
+                       "3:\n"
+                       "4: } ;\n";
+            ASSERT_EQUALS(expected, tokenize(code));
+        }
+    }
+
+    void varid_in_class25() {
+        const Settings s = settingsBuilder(settings).library("std.cfg").build();
+
+        const char *expected{};
+        {
+            const char code[] = "struct F {\n" // #11497
+                                "    int i;\n"
+                                "    void f(const std::vector<F>&v) {\n"
+                                "        if (v.front().i) {}\n"
+                                "    }\n"
+                                "};\n";
+            expected = "1: struct F {\n"
+                       "2: int i@1 ;\n"
+                       "3: void f ( const std :: vector < F > & v@2 ) {\n"
+                       "4: if ( v@2 . front ( ) . i@3 ) { }\n"
+                       "5: }\n"
+                       "6: } ;\n";
+            ASSERT_EQUALS(expected, tokenize(code, s));
+        }
+
+        {
+            const char code[] = "struct T { };\n" // 11533
+                                "struct U { T t; };\n"
+                                "std::vector<U*>* g();\n"
+                                "void f() {\n"
+                                "    std::vector<U*>* p = g();\n"
+                                "    auto t = p->front()->t;\n"
+                                "}\n";
+            expected = "1: struct T { } ;\n"
+                       "2: struct U { T t@1 ; } ;\n"
+                       "3: std :: vector < U * > * g ( ) ;\n"
+                       "4: void f ( ) {\n"
+                       "5: std :: vector < U * > * p@2 ; p@2 = g ( ) ;\n"
+                       "6: auto t@3 ; t@3 = p@2 . front ( ) . t@4 ;\n"
+                       "7: }\n";
+            ASSERT_EQUALS(expected, tokenize(code, s));
+        }
+    }
+
+    void varid_in_class26() {
+        const char *expected{}; // #11334
+        const char code[] = "struct S {\n"
+                            "    union {\n"
+                            "        uint8_t u8[4];\n"
+                            "        uint32_t u32;\n"
+                            "    };\n"
+                            "    void f();\n"
+                            "};\n"
+                            "void S::f() {\n"
+                            "    u8[0] = 0;\n"
+                            "}\n";
+        expected = "1: struct S {\n"
+                   "2: union {\n"
+                   "3: uint8_t u8@1 [ 4 ] ;\n"
+                   "4: uint32_t u32@2 ;\n"
+                   "5: } ;\n"
+                   "6: void f ( ) ;\n"
+                   "7: } ;\n"
+                   "8: void S :: f ( ) {\n"
+                   "9: u8@1 [ 0 ] = 0 ;\n"
+                   "10: }\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void varid_in_class27() {
+        const char code[] = "struct S {\n" // #13291
+                            "    int** pp;\n"
+                            "    void f() { int x(*pp[0]); }\n"
+                            "};\n";
+        const char expected[] = "1: struct S {\n"
+                                "2: int * * pp@1 ;\n"
+                                "3: void f ( ) { int x@2 ( * pp@1 [ 0 ] ) ; }\n"
+                                "4: } ;\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void varid_in_class28() {
+        const char code[] = "struct S {\n" // 13725
+                            "    struct T {\n"
+                            "        bool b();\n"
+                            "    };\n"
+                            "    bool b = false;\n"
+                            "};\n";
+        const char expected[] = "1: struct S {\n"
+                                "2: struct T {\n"
+                                "3: bool b ( ) ;\n"
+                                "4: } ;\n"
+                                "5: bool b@1 ; b@1 = false ;\n"
+                                "6: } ;\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void varid_in_class29() {
+        const char code[] = "struct S {\n" // #14486
+                            "    const int& r;\n"
+                            "    explicit S(const int& r) : r(r) {}\n"
+                            "    static void f() {\n"
+                            "        struct T : std::vector<int> {\n"
+                            "            bool g() const { return empty(); }\n"
+                            "        };\n"
+                            "    }\n"
+                            "};\n";
+        const char expected[] = "1: struct S {\n"
+                                "2: const int & r@1 ;\n"
+                                "3: explicit S ( const int & r@2 ) : r@1 ( r@2 ) { }\n"
+                                "4: static void f ( ) {\n"
+                                "5: struct T : std :: vector < int > {\n"
+                                "6: bool g ( ) const { return empty ( ) ; }\n"
+                                "7: } ;\n"
+                                "8: }\n"
+                                "9: } ;\n";
+        ASSERT_EQUALS(expected, tokenize(code));
     }
 
     void varid_namespace_1() { // #7272
@@ -1837,7 +2417,7 @@ class TestVarID : public TestFixture {
                       "4: int x@2 ;\n"
                       "5: union { char y@3 ; } ;\n"
                       "6: } ;\n"
-                      "7: }\n", tokenize(code, false, "test.cpp"));
+                      "7: }\n", tokenize(code));
     }
 
     void varid_namespace_2() { // #7000
@@ -1854,13 +2434,13 @@ class TestVarID : public TestFixture {
                             "   X = 0;\n"  // X@2
                             "}";
 
-        const std::string actual = tokenize(code, false, "test.cpp");
+        const std::string actual = tokenize(code);
 
         ASSERT(actual.find("X@2 = 0") != std::string::npos);
     }
 
-    std::string getLine(const std::string &code, int lineNumber) {
-        std::string nr = MathLib::toString(lineNumber);
+    static std::string getLine(const std::string &code, int lineNumber) {
+        std::string nr = std::to_string(lineNumber);
         const std::string::size_type pos1 = code.find('\n' + nr + ": ");
         if (pos1 == std::string::npos)
             return "";
@@ -1885,12 +2465,73 @@ class TestVarID : public TestFixture {
                             "}\n"
                             "}";
 
-        const std::string actual = tokenize(code, false, "test.cpp");
+        const std::string actual = tokenize(code);
 
         ASSERT_EQUALS("5: int type@2 ;", getLine(actual,5));
         ASSERT_EQUALS("11: type@2 = 0 ;", getLine(actual,11));
     }
 
+    void varid_namespace_4() {
+        const char code[] = "namespace X {\n"
+                            "  struct foo { int x;};\n"
+                            "  struct bar: public foo {\n"
+                            "    void dostuff();\n"
+                            "  };\n"
+                            "  void bar::dostuff() { int x2 = x * 2; }\n"
+                            "}";
+        ASSERT_EQUALS("1: namespace X {\n"
+                      "2: struct foo { int x@1 ; } ;\n"
+                      "3: struct bar : public foo {\n"
+                      "4: void dostuff ( ) ;\n"
+                      "5: } ;\n"
+                      "6: void bar :: dostuff ( ) { int x2@2 ; x2@2 = x@1 * 2 ; }\n"
+                      "7: }\n", tokenize(code));
+    }
+
+    void varid_namespace_5() {
+        const char code[] = "namespace X {\n"
+                            "  struct foo { int x;};\n"
+                            "  namespace Y {\n"
+                            "    struct bar: public foo {\n"
+                            "      void dostuff();\n"
+                            "    };\n"
+                            "    void bar::dostuff() { int x2 = x * 2; }\n"
+                            "  }\n"
+                            "}";
+        ASSERT_EQUALS("1: namespace X {\n"
+                      "2: struct foo { int x@1 ; } ;\n"
+                      "3: namespace Y {\n"
+                      "4: struct bar : public foo {\n"
+                      "5: void dostuff ( ) ;\n"
+                      "6: } ;\n"
+                      "7: void bar :: dostuff ( ) { int x2@2 ; x2@2 = x@1 * 2 ; }\n"
+                      "8: }\n"
+                      "9: }\n", tokenize(code));
+    }
+
+    void varid_namespace_6() {
+        const char code[] = "namespace N {\n" // #12077
+                            "    namespace O {\n"
+                            "        U::U(int* map) : id(0) {\n"
+                            "            this->p = map;\n"
+                            "        }\n"
+                            "        void U::f() {\n"
+                            "            std::map<Vec2i, int>::iterator iter;\n"
+                            "        }\n"
+                            "    }\n"
+                            "}";
+        ASSERT_EQUALS("1: namespace N {\n"
+                      "2: namespace O {\n"
+                      "3: U :: U ( int * map@1 ) : id ( 0 ) {\n"
+                      "4: this . p = map@1 ;\n"
+                      "5: }\n"
+                      "6: void U :: f ( ) {\n"
+                      "7: std :: map < Vec2i , int > :: iterator iter@2 ;\n"
+                      "8: }\n"
+                      "9: }\n"
+                      "10: }\n", tokenize(code));
+    }
+
     void varid_initList() {
         const char code1[] = "class A {\n"
                              "  A() : x(0) {}\n"
@@ -1999,6 +2640,60 @@ class TestVarID : public TestFixture {
                       "5: A :: A ( const Matrix & m@3 ) throw ( e ) : work@1 ( 0 )\n"
                       "6: { }\n",
                       tokenize(code10));
+
+        const char code11[] = "struct S {\n" // #12733
+                              "    explicit S(int& r) : a{ int{ 1 } }, b{ r } {}\n"
+                              "    int a, &b;\n"
+                              "};";
+        ASSERT_EQUALS("1: struct S {\n"
+                      "2: explicit S ( int & r@1 ) : a@2 { int { 1 } } , b@3 { r@1 } { }\n"
+                      "3: int a@2 ; int & b@3 ;\n"
+                      "4: } ;\n",
+                      tokenize(code11));
+
+        const char code12[] = "template<typename... T>\n" // # 13070
+                              "    struct S1 : T... {\n"
+                              "    constexpr S1(const T& ... p) : T{ p } {}\n"
+                              "};\n"
+                              "namespace p { struct S2 {}; }\n"
+                              "struct S3 {\n"
+                              "    S3() {}\n"
+                              "    bool f(p::S2& c);\n"
+                              "};\n";
+        ASSERT_EQUALS("1: template < typename ... T >\n"
+                      "2: struct S1 : T ... {\n"
+                      "3: constexpr S1 ( const T & ... p@1 ) : T { p@1 } { }\n"
+                      "4: } ;\n"
+                      "5: namespace p { struct S2 { } ; }\n"
+                      "6: struct S3 {\n"
+                      "7: S3 ( ) { }\n"
+                      "8: bool f ( p :: S2 & c@2 ) ;\n"
+                      "9: } ;\n",
+                      tokenize(code12));
+
+        const char code13[] = "template <typename... T>\n" // #13088
+                              "struct B {};\n"
+                              "template <typename... T>\n"
+                              "struct D : B<T>... {\n"
+                              "    template <typename... P>\n"
+                              "    D(P&&... p) : B<T>(std::forward<P>(p))... {}\n"
+                              "};\n"
+                              "template <typename... T>\n"
+                              "struct S {\n"
+                              "    D<T...> d;\n"
+                              "};\n";
+        ASSERT_EQUALS("1: template < typename ... T >\n"
+                      "2: struct B { } ;\n"
+                      "3: template < typename ... T >\n"
+                      "4: struct D : B < T > ... {\n"
+                      "5: template < typename ... P >\n"
+                      "6: D ( P && ... p@1 ) : B < T > ( std :: forward < P > ( p@1 ) ) ... { }\n"
+                      "7: } ;\n"
+                      "8: template < typename ... T >\n"
+                      "9: struct S {\n"
+                      "10: D < T ... > d@2 ;\n"
+                      "11: } ;\n",
+                      tokenize(code13));
     }
 
     void varid_initListWithBaseTemplate() {
@@ -2076,11 +2771,11 @@ class TestVarID : public TestFixture {
     void varid_operator() {
         {
             const std::string actual = tokenize(
-                                           "class Foo\n"
-                                           "{\n"
-                                           "public:\n"
-                                           "    void operator=(const Foo &);\n"
-                                           "};\n");
+                "class Foo\n"
+                "{\n"
+                "public:\n"
+                "    void operator=(const Foo &);\n"
+                "};");
 
             const char expected[] = "1: class Foo\n"
                                     "2: {\n"
@@ -2092,9 +2787,9 @@ class TestVarID : public TestFixture {
         }
         {
             const std::string actual = tokenize(
-                                           "struct Foo {\n"
-                                           "    void * operator new [](int);\n"
-                                           "};\n");
+                "struct Foo {\n"
+                "    void * operator new [](int);\n"
+                "};");
             const char expected[] = "1: struct Foo {\n"
                                     "2: void * operatornew[] ( int ) ;\n"
                                     "3: } ;\n";
@@ -2105,8 +2800,8 @@ class TestVarID : public TestFixture {
 
     void varid_throw() {  // ticket #1723
         const std::string actual = tokenize(
-                                       "UserDefinedException* pe = new UserDefinedException();\n"
-                                       "throw pe;\n");
+            "UserDefinedException* pe = new UserDefinedException();\n"
+            "throw pe;");
 
         const char expected[] = "1: UserDefinedException * pe@1 ; pe@1 = new UserDefinedException ( ) ;\n"
                                 "2: throw pe@1 ;\n";
@@ -2126,7 +2821,7 @@ class TestVarID : public TestFixture {
                                 "3: AAA\n"
                                 "4: a@1 [ 0 ] = 0 ;\n"
                                 "5: }\n";
-        ASSERT_EQUALS(expected, tokenize(code, false, "test.c"));
+        ASSERT_EQUALS(expected, tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void varid_using() {
@@ -2165,13 +2860,32 @@ class TestVarID : public TestFixture {
                       tokenize("VertexArrayIterator<float[2]> attrPos = m_AttributePos.GetIterator<float[2]>();"));
     }
 
-    void varid_templateParameter() { // #7046 set varid for "X":  std::array<int,X> Y;
-        const char code[] = "const int X = 0;\n"
-                            "std::array<int,X> Y;\n";
+    void varid_templateParameter() {
+        {
+            const char code[] = "const int X = 0;\n" // #7046 set varid for "X":  std::array<int,X> Y;
+                                "std::array<int,X> Y;\n";
 
-        ASSERT_EQUALS("1: const int X@1 = 0 ;\n"
-                      "2: std :: array < int , X@1 > Y@2 ;\n",
-                      tokenize(code));
+            ASSERT_EQUALS("1: const int X@1 = 0 ;\n"
+                          "2: std :: array < int , X@1 > Y@2 ;\n",
+                          tokenize(code));
+        }
+        {
+            const char code[] = "std::optional<N::Foo<A>> Foo;\n"; // #11003
+
+            ASSERT_EQUALS("1: std :: optional < N :: Foo < A > > Foo@1 ;\n",
+                          tokenize(code));
+        }
+    }
+
+    void varid_templateParameterFunctionPointer() {
+        {
+            const char code[] = "template <class, void (*F)()>\n"
+                                "struct a;\n";
+
+            ASSERT_EQUALS("1: template < class , void ( * F ) ( ) >\n"
+                          "2: struct a ;\n",
+                          tokenize(code));
+        }
     }
 
     void varid_templateUsing() { // #5781 #7273
@@ -2181,6 +2895,19 @@ class TestVarID : public TestFixture {
                       tokenize(code));
     }
 
+    void varid_templateSpecializationFinal() {
+        const char code[] = "template <typename T>\n"
+                            "struct S;\n"
+                            "template <>\n"
+                            "struct S<void> final {};\n";
+        ASSERT_EQUALS("4: struct S<void> ;\n"
+                      "1: template < typename T >\n"
+                      "2: struct S ;\n"
+                      "3:\n"
+                      "4: struct S<void> { } ;\n",
+                      tokenize(code));
+    }
+
     void varid_not_template_in_condition() {
         const char code1[] = "void f() { if (x<a||x>b); }";
         ASSERT_EQUALS("1: void f ( ) { if ( x < a || x > b ) { ; } }\n", tokenize(code1));
@@ -2222,18 +2949,18 @@ class TestVarID : public TestFixture {
     }
 
     void varid_rvalueref() {
-        ASSERT_EQUALS("1: int & & a@1 ;\n", tokenize("int&& a;"));
+        ASSERT_EQUALS("1: int && a@1 ;\n", tokenize("int&& a;"));
 
-        ASSERT_EQUALS("1: void foo ( int & & a@1 ) { }\n", tokenize("void foo(int&& a) {}"));
+        ASSERT_EQUALS("1: void foo ( int && a@1 ) { }\n", tokenize("void foo(int&& a) {}"));
 
         ASSERT_EQUALS("1: class C {\n"
-                      "2: C ( int & & a@1 ) ;\n"
+                      "2: C ( int && a@1 ) ;\n"
                       "3: } ;\n",
                       tokenize("class C {\n"
                                "    C(int&& a);\n"
                                "};"));
 
-        ASSERT_EQUALS("1: void foo ( int & & ) ;\n", tokenize("void foo(int&&);"));
+        ASSERT_EQUALS("1: void foo ( int && ) ;\n", tokenize("void foo(int&&);"));
     }
 
     void varid_arrayFuncPar() {
@@ -2264,7 +2991,7 @@ class TestVarID : public TestFixture {
                                "    class QErrorLogger {\n"
                                "        void reportErr(ErrorLogger::ErrorMessage &msg) {\n"
                                "        }\n"
-                               "    }; \n"
+                               "    };\n"
                                "}"));
     }
 
@@ -2405,14 +3132,30 @@ class TestVarID : public TestFixture {
     }
 
     void varid_header() {
+        ASSERT_EQUALS("1: class A@1 ;\n"
+                      "2: struct B {\n"
+                      "3: void setData ( const A@1 & a ) ;\n"
+                      "4: } ;\n",
+                      tokenizeHeader("class A;\n"
+                                     "struct B {\n"
+                                     "    void setData(const A & a);\n"
+                                     "}; ", "test.h"));
         ASSERT_EQUALS("1: class A ;\n"
                       "2: struct B {\n"
                       "3: void setData ( const A & a@1 ) ;\n"
                       "4: } ;\n",
-                      tokenize("class A;\n"
-                               "struct B {\n"
-                               "    void setData(const A & a);\n"
-                               "}; ", false, "test.h"));
+                      tokenizeHeader("class A;\n"
+                                     "struct B {\n"
+                                     "    void setData(const A & a);\n"
+                                     "}; ", "test.hpp"));
+        ASSERT_EQUALS("1: void f ( )\n"
+                      "2: {\n"
+                      "3: int class@1 ;\n"
+                      "4: }\n",
+                      tokenizeHeader("void f()\n"
+                                     "{\n"
+                                     "    int class;\n"
+                                     "}", "test.h"));
     }
 
     void varid_rangeBasedFor() {
@@ -2452,7 +3195,18 @@ class TestVarID : public TestFixture {
                                "        delta = 1;\n"
                                "        break;\n"
                                "    }\n"
-                               "}", false, "test.c"));
+                               "}", dinit(TokenizeOptions, $.cpp = false)));
+
+        ASSERT_EQUALS("1: int * f ( ) {\n" // #11838
+                      "2: int * label@1 ; label@1 = 0 ;\n"
+                      "3: label : ;\n"
+                      "4: return label@1 ;\n"
+                      "5: }\n",
+                      tokenize("int* f() {\n"
+                               "    int* label = 0;\n"
+                               "label:\n"
+                               "    return label;\n"
+                               "}"));
     }
 
     void varid_structinit() { // #6406
@@ -2469,90 +3223,341 @@ class TestVarID : public TestFixture {
                       tokenize("void foo() {\n"
                                "  struct ABC abc = {.a=abc.a,.b=abc.b};\n"
                                "}"));
+
+        ASSERT_EQUALS("1: void foo ( ) {\n"
+                      "2: struct ABC abc@1 ; abc@1 = { . a@2 { abc@1 . a@2 } , . b@3 = { abc@1 . b@3 } } ;\n"
+                      "3: }\n",
+                      tokenize("void foo() {\n"
+                               "  struct ABC abc = {.a { abc.a },.b= { abc.b } };\n"
+                               "}"));
+
+        ASSERT_EQUALS("1: struct T { int a@1 ; } ;\n" // #13123
+                      "2: void f ( int a@2 ) {\n"
+                      "3: struct T t@3 ; t@3 = { . a@4 = 1 } ;\n"
+                      "4: }\n",
+                      tokenize("struct T { int a; };\n"
+                               "void f(int a) {\n"
+                               "    struct T t = { .a = 1 };\n"
+                               "}\n"));
+
+        ASSERT_EQUALS("1: struct S { int x@1 ; } ;\n" // TODO: set some varid for designated initializer?
+                      "2: void f0 ( S s@2 ) ;\n"
+                      "3: void f1 ( int n@3 ) {\n"
+                      "4: if ( int x@4 = n@3 ) {\n"
+                      "5: f0 ( S { . x = x@4 } ) ;\n"
+                      "6: }\n"
+                      "7: }\n",
+                      tokenize("struct S { int x; };\n"
+                               "void f0(S s);\n"
+                               "void f1(int n) {\n"
+                               "    if (int x = n) {\n"
+                               "        f0(S{ .x = x });\n"
+                               "    }\n"
+                               "}\n"));
     }
 
-    void varid_arrayinit() { // #7579 - no variable declaration in rhs
+    void varid_arrayinit() {
+        // #7579 - no variable declaration in rhs
         ASSERT_EQUALS("1: void foo ( int * a@1 ) { int b@2 [ 1 ] = { x * a@1 [ 0 ] } ; }\n", tokenize("void foo(int*a) { int b[] = { x*a[0] }; }"));
+
+        // #12402
+        ASSERT_EQUALS("1: void f ( ) { void ( * p@1 [ 1 ] ) ( int ) = { [ ] ( int i@2 ) { } } ; }\n", tokenize("void f() { void (*p[1])(int) = { [](int i) {} }; }"));
     }
 
     void varid_lambda_arg() {
         // #8664
-        const char code1[] = "static void func(int ec) {\n"
-                             "    func2([](const std::error_code& ec) { return ec; });\n"
-                             "}";
-        const char exp1[] = "1: static void func ( int ec@1 ) {\n"
-                            "2: func2 ( [ ] ( const std :: error_code & ec@2 ) { return ec@2 ; } ) ;\n"
-                            "3: }\n";
-        ASSERT_EQUALS(exp1, tokenize(code1));
-
-        const char code2[] = "static void func(int ec) {\n"
-                             "    func2([](int x, const std::error_code& ec) { return x + ec; });\n"
-                             "}";
-        const char exp2[] = "1: static void func ( int ec@1 ) {\n"
-                            "2: func2 ( [ ] ( int x@2 , const std :: error_code & ec@3 ) { return x@2 + ec@3 ; } ) ;\n"
-                            "3: }\n";
-        ASSERT_EQUALS(exp2, tokenize(code2));
+        {
+            const char code[] = "static void func(int ec) {\n"
+                                "    func2([](const std::error_code& ec) { return ec; });\n"
+                                "}";
+            const char exp[] = "1: static void func ( int ec@1 ) {\n"
+                               "2: func2 ( [ ] ( const std :: error_code & ec@2 ) { return ec@2 ; } ) ;\n"
+                               "3: }\n";
+            ASSERT_EQUALS(exp, tokenize(code));
+        }
+        {
+            const char code[] = "static void func(int ec) {\n"
+                                "    func2([](int x, const std::error_code& ec) { return x + ec; });\n"
+                                "}";
+            const char exp[] = "1: static void func ( int ec@1 ) {\n"
+                               "2: func2 ( [ ] ( int x@2 , const std :: error_code & ec@3 ) { return x@2 + ec@3 ; } ) ;\n"
+                               "3: }\n";
+            ASSERT_EQUALS(exp, tokenize(code));
+        }
+        // #9384
+        {
+            const char code[] = "auto g = [](const std::string& s) -> std::string { return {}; };\n";
+            const char exp[] = "1: auto g@1 ; g@1 = [ ] ( const std :: string & s@2 ) . std :: string { return { } ; } ;\n";
+            ASSERT_EQUALS(exp, tokenize(code));
+        }
+        {
+            const char code[] = "auto g = [](std::function<void()> p) {};\n";
+            const char exp[] = "1: auto g@1 ; g@1 = [ ] ( std :: function < void ( ) > p@2 ) { } ;\n";
+            ASSERT_EQUALS(exp, tokenize(code));
+        }
+        // # 10849
+        {
+            const char code[] = "class T {};\n"
+                                "auto g = [](const T* t) -> int {\n"
+                                "    const T* u{}, *v{};\n"
+                                "    return 0;\n"
+                                "};\n";
+            const char exp[] = "1: class T { } ;\n"
+                               "2: auto g@1 ; g@1 = [ ] ( const T * t@2 ) . int {\n"
+                               "3: const T * u@3 { } ; const T * v@4 { } ;\n"
+                               "4: return 0 ;\n"
+                               "5: } ;\n";
+            ASSERT_EQUALS(exp, tokenize(code));
+        }
+        // # 11332
+        {
+            const char code[] = "auto a() {\n"
+                                "    return [](int, int b) {};\n"
+                                "}\n";
+            const char exp[] = "1: auto a ( ) {\n"
+                               "2: return [ ] ( int , int b@1 ) { } ;\n"
+                               "3: }\n";
+            ASSERT_EQUALS(exp, tokenize(code));
+        }
     }
 
     void varid_lambda_mutable() {
         // #8957
-        const char code1[] = "static void func() {\n"
-                             "    auto x = []() mutable {};\n"
-                             "    dostuff(x);\n"
-                             "}";
-        const char exp1[] = "1: static void func ( ) {\n"
-                            "2: auto x@1 ; x@1 = [ ] ( ) mutable { } ;\n"
-                            "3: dostuff ( x@1 ) ;\n"
-                            "4: }\n";
-        ASSERT_EQUALS(exp1, tokenize(code1));
+        {
+            const char code[] = "static void func() {\n"
+                                "    auto x = []() mutable {};\n"
+                                "    dostuff(x);\n"
+                                "}";
+            const char exp[] = "1: static void func ( ) {\n"
+                               "2: auto x@1 ; x@1 = [ ] ( ) mutable { } ;\n"
+                               "3: dostuff ( x@1 ) ;\n"
+                               "4: }\n";
+            ASSERT_EQUALS(exp, tokenize(code));
+        }
+        // #9384
+        {
+            const char code[] = "auto g = [](int i) mutable {};\n";
+            const char exp[] = "1: auto g@1 ; g@1 = [ ] ( int i@2 ) mutable { } ;\n";
+            ASSERT_EQUALS(exp, tokenize(code));
+        }
     }
 
     void varid_trailing_return1() { // #8889
-        const char code1[] = "struct Fred {\n"
-                             "    auto foo(const Fred & other) -> Fred &;\n"
-                             "    auto bar(const Fred & other) -> Fred & {\n"
-                             "        return *this;\n"
-                             "    }\n"
-                             "};\n"
-                             "auto Fred::foo(const Fred & other) -> Fred & {\n"
-                             "    return *this;\n"
-                             "}";
-        const char exp1[] = "1: struct Fred {\n"
-                            "2: auto foo ( const Fred & other@1 ) . Fred & ;\n"
-                            "3: auto bar ( const Fred & other@2 ) . Fred & {\n"
-                            "4: return * this ;\n"
-                            "5: }\n"
-                            "6: } ;\n"
-                            "7: auto Fred :: foo ( const Fred & other@3 ) . Fred & {\n"
-                            "8: return * this ;\n"
-                            "9: }\n";
-        ASSERT_EQUALS(exp1, tokenize(code1));
+        const char code[] = "struct Fred {\n"
+                            "    auto foo(const Fred & other) -> Fred &;\n"
+                            "    auto bar(const Fred & other) -> Fred & {\n"
+                            "        return *this;\n"
+                            "    }\n"
+                            "};\n"
+                            "auto Fred::foo(const Fred & other) -> Fred & {\n"
+                            "    return *this;\n"
+                            "}";
+        const char exp[] = "1: struct Fred {\n"
+                           "2: auto foo ( const Fred & other@1 ) . Fred & ;\n"
+                           "3: auto bar ( const Fred & other@2 ) . Fred & {\n"
+                           "4: return * this ;\n"
+                           "5: }\n"
+                           "6: } ;\n"
+                           "7: auto Fred :: foo ( const Fred & other@3 ) . Fred & {\n"
+                           "8: return * this ;\n"
+                           "9: }\n";
+        ASSERT_EQUALS(exp, tokenize(code));
     }
 
     void varid_trailing_return2() { // #9066
-        const char code1[] = "auto func(int arg) -> bar::quux {}";
-        const char exp1[] = "1: auto func ( int arg@1 ) . bar :: quux { }\n";
-        ASSERT_EQUALS(exp1, tokenize(code1));
+        const char code[] = "auto func(int arg) -> bar::quux {}";
+        const char exp[] = "1: auto func ( int arg@1 ) . bar :: quux { }\n";
+        ASSERT_EQUALS(exp, tokenize(code));
+    }
+
+    void varid_trailing_return3() { // #11423
+        const char code[] = "void f(int a, int b) {\n"
+                            "    auto g = [](int& a, const int b) -> void {};\n"
+                            "    auto h = [&a, &b]() { std::swap(a, b); };\n"
+                            "}\n";
+        const char exp[] = "1: void f ( int a@1 , int b@2 ) {\n"
+                           "2: auto g@3 ; g@3 = [ ] ( int & a@4 , const int b@5 ) . void { } ;\n"
+                           "3: auto h@6 ; h@6 = [ & a@1 , & b@2 ] ( ) { std :: swap ( a@1 , b@2 ) ; } ;\n"
+                           "4: }\n";
+        ASSERT_EQUALS(exp, tokenize(code));
+    }
+
+    void varid_parameter_pack() { // #9383
+        const char code[] = "template <typename... Rest>\n"
+                            "void func(Rest... parameters) {\n"
+                            "    foo(parameters...);\n"
+                            "}\n";
+        const char exp[] = "1: template < typename ... Rest >\n"
+                           "2: void func ( Rest ... parameters@1 ) {\n"
+                           "3: foo ( parameters@1 ... ) ;\n"
+                           "4: }\n";
+        ASSERT_EQUALS(exp, tokenize(code));
+    }
+
+    void varid_for_auto_cpp17() {
+        const char code[] = "void f() {\n"
+                            "  for (auto [x,y,z]: xyz) {\n"
+                            "    x+y+z;\n"
+                            "  }\n"
+                            "  x+y+z;\n"
+                            "}";
+        const char exp[] = "1: void f ( ) {\n"
+                           "2: for ( auto [ x@1 , y@2 , z@3 ] : xyz ) {\n"
+                           "3: x@1 + y@2 + z@3 ;\n"
+                           "4: }\n"
+                           "5: x + y + z ;\n"
+                           "6: }\n";
+        ASSERT_EQUALS(exp, tokenize(code));
+    }
+
+    void varid_not() { // #9689 'not x'
+        const char code[] = "void foo(int x) const {\n"
+                            "  if (not x) {}\n"
+                            "}";
+        const char exp[] = "1: void foo ( int x@1 ) const {\n"
+                           "2: if ( ! x@1 ) { }\n"
+                           "3: }\n";
+        ASSERT_EQUALS(exp, tokenize(code));
+    }
+
+    void varid_declInIfCondition() {
+        // if
+        ASSERT_EQUALS("1: void f ( int x@1 ) {\n"
+                      "2: if ( int x@2 = 0 ) { x@2 ; }\n"
+                      "3: x@1 ;\n"
+                      "4: }\n",
+                      tokenize("void f(int x) {\n"
+                               "  if (int x = 0) { x; }\n"
+                               "  x;\n"
+                               "}"));
+        // if, else
+        ASSERT_EQUALS("1: void f ( int x@1 ) {\n"
+                      "2: if ( int x@2 = 0 ) { x@2 ; }\n"
+                      "3: else { x@2 ; }\n"
+                      "4: x@1 ;\n"
+                      "5: }\n",
+                      tokenize("void f(int x) {\n"
+                               "  if (int x = 0) { x; }\n"
+                               "  else { x; }\n"
+                               "  x;\n"
+                               "}"));
+        // if, else if
+        ASSERT_EQUALS("1: void f ( int x@1 ) {\n"
+                      "2: if ( int x@2 = 0 ) { x@2 ; }\n"
+                      "3: else { if ( void * x@3 = & x@3 ) { x@3 ; } }\n"
+                      "4: x@1 ;\n"
+                      "5: }\n",
+                      tokenize("void f(int x) {\n"
+                               "  if (int x = 0) x;\n"
+                               "  else if (void* x = &x) x;\n"
+                               "  x;\n"
+                               "}"));
+        // if, else if, else
+        ASSERT_EQUALS("1: void f ( int x@1 ) {\n"
+                      "2: if ( int x@2 = 0 ) { x@2 ; }\n"
+                      "3: else { if ( void * x@3 = & x@3 ) { x@3 ; }\n"
+                      "4: else { x@3 ; } }\n"
+                      "5: x@1 ;\n"
+                      "6: }\n",
+                      tokenize("void f(int x) {\n"
+                               "  if (int x = 0) x;\n"
+                               "  else if (void* x = &x) x;\n"
+                               "  else x;\n"
+                               "  x;\n"
+                               "}"));
+
+        ASSERT_EQUALS("1: const char * f ( int * ) ;\n" // #12924
+                      "2: void g ( int i@1 ) {\n"
+                      "3: if ( f ( & i@1 ) [ 0 ] == 'm' ) { }\n"
+                      "4: }\n",
+                      tokenize("const char *f(int*);\n"
+                               "void g(int i) {\n"
+                               "    if (f(&i)[0] == 'm') {}\n"
+                               "}\n", dinit(TokenizeOptions, $.cpp = false)));
+    }
+
+    void varid_globalScope() {
+        const char code[] = "int a[5];\n"
+                            "namespace Z { struct B { int a[5]; } b; }\n"
+                            "void f() {\n"
+                            "  int a[5];\n"
+                            "  memset(a, 123, 5);\n"
+                            "  memset(::a, 123, 5);\n"
+                            "  memset(Z::b.a, 123, 5);\n"
+                            "  memset(::Z::b.a, 123, 5);\n"
+                            "}";
+
+        const char exp[] = "1: int a@1 [ 5 ] ;\n"
+                           "2: namespace Z { struct B { int a@2 [ 5 ] ; } ; struct B b@3 ; }\n"
+                           "3: void f ( ) {\n"
+                           "4: int a@4 [ 5 ] ;\n"
+                           "5: memset ( a@4 , 123 , 5 ) ;\n"
+                           "6: memset ( :: a@1 , 123 , 5 ) ;\n"
+                           "7: memset ( Z :: b@3 . a , 123 , 5 ) ;\n"
+                           "8: memset ( :: Z :: b@3 . a , 123 , 5 ) ;\n"
+                           "9: }\n";
+        ASSERT_EQUALS(exp, tokenize(code));
+    }
+
+    void varid_function_pointer_args() {
+        const char code1[] = "void foo() {\n"
+                             "    char *text;\n"
+                             "    void (*cb)(char* text);\n"
+                             "}\n";
+        ASSERT_EQUALS("1: void foo ( ) {\n"
+                      "2: char * text@1 ;\n"
+                      "3: void ( * cb@2 ) ( char * ) ;\n"
+                      "4: }\n", tokenize(code1));
+
+        const char code2[] = "void foo() {\n"
+                             "    char *text;\n"
+                             "    void (*f)(int (*arg)(char* text));\n"
+                             "}\n";
+        ASSERT_EQUALS("1: void foo ( ) {\n"
+                      "2: char * text@1 ;\n"
+                      "3: void ( * f@2 ) ( int ( * arg ) ( char * ) ) ;\n"
+                      "4: }\n", tokenize(code2));
+
+        const char code3[] = "void f (void (*g) (int i, IN int n)) {}\n";
+        ASSERT_EQUALS("1: void f ( void ( * g@1 ) ( int , IN int ) ) { }\n", tokenize(code3));
+
+        const char code4[] = "void f() {\n" // #14439
+                             "    int* p;\n"
+                             "    void (*a[1])(int* p) = { 0 };\n"
+                             "}\n";
+        ASSERT_EQUALS("1: void f ( ) {\n"
+                      "2: int * p@1 ;\n"
+                      "3: void ( * a@2 [ 1 ] ) ( int * p ) = { 0 } ;\n"
+                      "4: }\n",
+                      tokenize(code4));
+    }
+
+    void varid_alignas() {
+        const char code[] = "extern alignas(16) int x;\n"
+                            "alignas(16) int x;";
+        const char expected[] = "1: extern alignas ( 16 ) int x@1 ;\n"
+                                "2: alignas ( 16 ) int x@2 ;\n";
+        ASSERT_EQUALS(expected, tokenize(code, dinit(TokenizeOptions, $.cpp = false)));
     }
 
     void varidclass1() {
         const std::string actual = tokenize(
-                                       "class Fred\n"
-                                       "{\n"
-                                       "private:\n"
-                                       "    int i;\n"
-                                       "\n"
-                                       "    void foo1();\n"
-                                       "    void foo2()\n"
-                                       "    {\n"
-                                       "        ++i;\n"
-                                       "    }\n"
-                                       "}\n"
-                                       "\n"
-                                       "Fred::foo1()\n"
-                                       "{\n"
-                                       "    i = 0;\n"
-                                       "}\n");
+            "class Fred\n"
+            "{\n"
+            "private:\n"
+            "    int i;\n"
+            "\n"
+            "    void foo1();\n"
+            "    void foo2()\n"
+            "    {\n"
+            "        ++i;\n"
+            "    }\n"
+            "}\n"
+            "\n"
+            "Fred::foo1()\n"
+            "{\n"
+            "    i = 0;\n"
+            "}");
 
         const char expected[] = "1: class Fred\n"
                                 "2: {\n"
@@ -2577,18 +3582,18 @@ class TestVarID : public TestFixture {
 
     void varidclass2() {
         const std::string actual = tokenize(
-                                       "class Fred\n"
-                                       "{ void f(); };\n"
-                                       "\n"
-                                       "void A::foo1()\n"
-                                       "{\n"
-                                       "    int i = 0;\n"
-                                       "}\n"
-                                       "\n"
-                                       "void Fred::f()\n"
-                                       "{\n"
-                                       "    i = 0;\n"
-                                       "}\n");
+            "class Fred\n"
+            "{ void f(); };\n"
+            "\n"
+            "void A::foo1()\n"
+            "{\n"
+            "    int i = 0;\n"
+            "}\n"
+            "\n"
+            "void Fred::f()\n"
+            "{\n"
+            "    i = 0;\n"
+            "}");
 
         const char expected[] = "1: class Fred\n"
                                 "2: { void f ( ) ; } ;\n"
@@ -2609,18 +3614,18 @@ class TestVarID : public TestFixture {
 
     void varidclass3() {
         const std::string actual = tokenize(
-                                       "class Fred\n"
-                                       "{ int i; void f(); };\n"
-                                       "\n"
-                                       "void Fred::f()\n"
-                                       "{\n"
-                                       "    i = 0;\n"
-                                       "}\n"
-                                       "\n"
-                                       "void A::f()\n"
-                                       "{\n"
-                                       "    i = 0;\n"
-                                       "}\n");
+            "class Fred\n"
+            "{ int i; void f(); };\n"
+            "\n"
+            "void Fred::f()\n"
+            "{\n"
+            "    i = 0;\n"
+            "}\n"
+            "\n"
+            "void A::f()\n"
+            "{\n"
+            "    i = 0;\n"
+            "}");
 
         const char expected[] = "1: class Fred\n"
                                 "2: { int i@1 ; void f ( ) ; } ;\n"
@@ -2641,14 +3646,14 @@ class TestVarID : public TestFixture {
 
     void varidclass4() {
         const std::string actual = tokenize(
-                                       "class Fred\n"
-                                       "{ int i; void f(); };\n"
-                                       "\n"
-                                       "void Fred::f()\n"
-                                       "{\n"
-                                       "    if (i) { }\n"
-                                       "    i = 0;\n"
-                                       "}\n");
+            "class Fred\n"
+            "{ int i; void f(); };\n"
+            "\n"
+            "void Fred::f()\n"
+            "{\n"
+            "    if (i) { }\n"
+            "    i = 0;\n"
+            "}");
 
         const char expected[] = "1: class Fred\n"
                                 "2: { int i@1 ; void f ( ) ; } ;\n"
@@ -2664,13 +3669,13 @@ class TestVarID : public TestFixture {
 
     void varidclass5() {
         const std::string actual = tokenize(
-                                       "class A { };\n"
-                                       "class B\n"
-                                       "{\n"
-                                       "    A *a;\n"
-                                       "    B() : a(new A)\n"
-                                       "    { }\n"
-                                       "};\n");
+            "class A { };\n"
+            "class B\n"
+            "{\n"
+            "    A *a;\n"
+            "    B() : a(new A)\n"
+            "    { }\n"
+            "};");
 
         const char expected[] = "1: class A { } ;\n"
                                 "2: class B\n"
@@ -2685,17 +3690,17 @@ class TestVarID : public TestFixture {
 
     void varidclass6() {
         const std::string actual = tokenize(
-                                       "class A\n"
-                                       "{\n"
-                                       "  public:\n"
-                                       "  static char buf[20];\n"
-                                       "};\n"
-                                       "char A::buf[20];\n"
-                                       "int main()\n"
-                                       "{\n"
-                                       "  char buf[2];\n"
-                                       "  A::buf[10] = 0;\n"
-                                       "}");
+            "class A\n"
+            "{\n"
+            "  public:\n"
+            "  static char buf[20];\n"
+            "};\n"
+            "char A::buf[20];\n"
+            "int main()\n"
+            "{\n"
+            "  char buf[2];\n"
+            "  A::buf[10] = 0;\n"
+            "}");
 
         const char expected[] = "1: class A\n"
                                 "2: {\n"
@@ -2714,11 +3719,11 @@ class TestVarID : public TestFixture {
 
     void varidclass7() {
         const std::string actual = tokenize(
-                                       "int main()\n"
-                                       "{\n"
-                                       "  char buf[2];\n"
-                                       "  A::buf[10] = 0;\n"
-                                       "}");
+            "int main()\n"
+            "{\n"
+            "  char buf[2];\n"
+            "  A::buf[10] = 0;\n"
+            "}");
 
         const char expected[] = "1: int main ( )\n"
                                 "2: {\n"
@@ -2731,12 +3736,12 @@ class TestVarID : public TestFixture {
 
     void varidclass8() {
         const char code[] ="class Fred {\n"
-                           "public:\n"
-                           "    void foo(int d) {\n"
-                           "        int i = bar(x * d);\n"
-                           "    }\n"
-                           "    int x;\n"
-                           "}\n";
+                            "public:\n"
+                            "    void foo(int d) {\n"
+                            "        int i = bar(x * d);\n"
+                            "    }\n"
+                            "    int x;\n"
+                            "}\n";
 
         const char expected[] = "1: class Fred {\n"
                                 "2: public:\n"
@@ -2751,14 +3756,14 @@ class TestVarID : public TestFixture {
 
     void varidclass9() {
         const char code[] ="typedef char Str[10];"
-                           "class A {\n"
-                           "public:\n"
-                           "    void f(Str &cl);\n"
-                           "    void g(Str cl);\n"
-                           "}\n"
-                           "void Fred::f(Str &cl) {\n"
-                           "    sizeof(cl);\n"
-                           "}";
+                            "class A {\n"
+                            "public:\n"
+                            "    void f(Str &cl);\n"
+                            "    void g(Str cl);\n"
+                            "}\n"
+                            "void Fred::f(Str &cl) {\n"
+                            "    sizeof(cl);\n"
+                            "}";
 
         const char expected[] = "1: class A {\n"
                                 "2: public:\n"
@@ -2774,11 +3779,11 @@ class TestVarID : public TestFixture {
 
     void varidclass10() {
         const char code[] ="class A {\n"
-                           "    void f() {\n"
-                           "        a = 3;\n"
-                           "    }\n"
-                           "    int a;\n"
-                           "};\n";
+                            "    void f() {\n"
+                            "        a = 3;\n"
+                            "    }\n"
+                            "    int a;\n"
+                            "};\n";
 
         const char expected[] = "1: class A {\n"
                                 "2: void f ( ) {\n"
@@ -2791,15 +3796,15 @@ class TestVarID : public TestFixture {
 
     void varidclass11() {
         const char code[] ="class Fred {\n"
-                           "    int a;\n"
-                           "    void f();\n"
-                           "};\n"
-                           "class Wilma {\n"
-                           "    int a;\n"
-                           "    void f();\n"
-                           "};\n"
-                           "void Fred::f() { a = 0; }\n"
-                           "void Wilma::f() { a = 0; }\n";
+                            "    int a;\n"
+                            "    void f();\n"
+                            "};\n"
+                            "class Wilma {\n"
+                            "    int a;\n"
+                            "    void f();\n"
+                            "};\n"
+                            "void Fred::f() { a = 0; }\n"
+                            "void Wilma::f() { a = 0; }\n";
 
         const char expected[] = "1: class Fred {\n"
                                 "2: int a@1 ;\n"
@@ -2817,9 +3822,9 @@ class TestVarID : public TestFixture {
 
     void varidclass12() {
         const char code[] ="class Fred {\n"
-                           "    int a;\n"
-                           "    void f() { Fred::a = 0; }\n"
-                           "};\n";
+                            "    int a;\n"
+                            "    void f() { Fred::a = 0; }\n"
+                            "};\n";
 
         const char expected[] = "1: class Fred {\n"
                                 "2: int a@1 ;\n"
@@ -2831,9 +3836,9 @@ class TestVarID : public TestFixture {
 
     void varidclass13() {
         const char code[] ="class Fred {\n"
-                           "    int a;\n"
-                           "    void f() { Foo::Fred::a = 0; }\n"
-                           "};\n";
+                            "    int a;\n"
+                            "    void f() { Foo::Fred::a = 0; }\n"
+                            "};\n";
 
         const char expected[] = "1: class Fred {\n"
                                 "2: int a@1 ;\n"
@@ -2847,8 +3852,8 @@ class TestVarID : public TestFixture {
         // don't give friend classes varid
         {
             const char code[] ="class A {\n"
-                               "friend class B;\n"
-                               "}";
+                                "friend class B;\n"
+                                "}";
 
             const char expected[] = "1: class A {\n"
                                     "2: friend class B ;\n"
@@ -2859,8 +3864,8 @@ class TestVarID : public TestFixture {
 
         {
             const char code[] ="class A {\n"
-                               "private: friend class B;\n"
-                               "}";
+                                "private: friend class B;\n"
+                                "}";
 
             const char expected[] = "1: class A {\n"
                                     "2: private: friend class B ;\n"
@@ -2900,7 +3905,7 @@ class TestVarID : public TestFixture {
         const char expected[] = "1: struct A ;\n"
                                 "2:\n"
                                 "3: struct A {\n"
-                                "4: bool * pFun@1 ;\n"
+                                "4: bool ( * pFun@1 ) ( ) ;\n"
                                 "5: void setPFun ( int mode@2 ) ;\n"
                                 "6: bool funcNorm ( ) ;\n"
                                 "7: } ;\n"
@@ -2920,10 +3925,22 @@ class TestVarID : public TestFixture {
         const char expected[] = "1: class A : public B , public C :: D {\n"
                                 "2: int i@1 ;\n"
                                 "3: A ( int i@2 ) : B ( i@2 ) , C :: D ( i@2 ) , i@1 ( i@2 ) {\n"
-                                "4: int j@3 ; j@3 = i@2 ;\n"
+                                "4: int j@3 ( i@2 ) ;\n"
                                 "5: }\n"
                                 "6: } ;\n";
         ASSERT_EQUALS(expected, tokenize(code));
+
+        const char code2[] = "struct S {\n" // #11411
+                             "    std::vector<int> v;\n"
+                             "    int i;\n"
+                             "    S(int i) : v({ 0 }), i(i) {}\n"
+                             "};";
+        const char expected2[] = "1: struct S {\n"
+                                 "2: std :: vector < int > v@1 ;\n"
+                                 "3: int i@2 ;\n"
+                                 "4: S ( int i@3 ) : v@1 ( { 0 } ) , i@2 ( i@3 ) { }\n"
+                                 "5: } ;\n";
+        ASSERT_EQUALS(expected2, tokenize(code2));
     }
 
     void varidclass18() {
@@ -2956,6 +3973,106 @@ class TestVarID : public TestFixture {
         ASSERT_EQUALS(expected, tokenize(code));
     }
 
+    void varidclass20() { // #7578: int (*p)[2]
+        const char code[] = "struct S {\n"
+                            "  int (*p)[2];\n"
+                            "  S();\n"
+                            "};\n"
+                            "S::S() { p[0] = 0; }";
+        const char expected[] = "1: struct S {\n"
+                                "2: int ( * p@1 ) [ 2 ] ;\n"
+                                "3: S ( ) ;\n"
+                                "4: } ;\n"
+                                "5: S :: S ( ) { p@1 [ 0 ] = 0 ; }\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void varidenum1() {
+        const char code[] = "const int eStart = 6;\n"
+                            "enum myEnum {\n"
+                            "  A = eStart\n"
+                            "};\n";
+        const char expected[] = "1: const int eStart@1 = 6 ;\n"
+                                "2: enum myEnum {\n"
+                                "3: A = eStart@1\n"
+                                "4: } ;\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void varidenum2() {
+        const char code[] = "const int eStart = 6;\n"
+                            "enum myEnum {\n"
+                            "  A = f(eStart)\n"
+                            "};\n";
+        const char expected[] = "1: const int eStart@1 = 6 ;\n"
+                                "2: enum myEnum {\n"
+                                "3: A = f ( eStart@1 )\n"
+                                "4: } ;\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void varidenum3() {
+        const char code[] = "const int eStart = 6;\n"
+                            "enum myEnum {\n"
+                            "  A = f(eStart, x)\n"
+                            "};\n";
+        const char expected[] = "1: const int eStart@1 = 6 ;\n"
+                                "2: enum myEnum {\n"
+                                "3: A = f ( eStart@1 , x )\n"
+                                "4: } ;\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void varidenum4() {
+        const char code[] = "const int eStart = 6;\n"
+                            "enum myEnum {\n"
+                            "  A = f(x, eStart)\n"
+                            "};\n";
+        const char expected[] = "1: const int eStart@1 = 6 ;\n"
+                                "2: enum myEnum {\n"
+                                "3: A = f ( x , eStart@1 )\n"
+                                "4: } ;\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void varidenum5() {
+        const char code[] = "const int eStart = 6;\n"
+                            "enum myEnum {\n"
+                            "  A = f(x, eStart, y)\n"
+                            "};\n";
+        const char expected[] = "1: const int eStart@1 = 6 ;\n"
+                                "2: enum myEnum {\n"
+                                "3: A = f ( x , eStart@1 , y )\n"
+                                "4: } ;\n";
+        const char current[] = "1: const int eStart@1 = 6 ;\n"
+                               "2: enum myEnum {\n"
+                               "3: A = f ( x , eStart , y )\n"
+                               "4: } ;\n";
+        TODO_ASSERT_EQUALS(expected, current, tokenize(code));
+    }
+
+    void varidenum6() { // #9180
+        const char code[] = "const int IDL1 = 13;\n"
+                            "enum class E { IDL1 = 16, };\n";
+        const char expected[] = "1: const int IDL1@1 = 13 ;\n"
+                                "2: enum class E { IDL1 = 16 , } ;\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void varidenum7() { // #8991
+        const char code[] = "namespace N1 { const int c = 42; }\n"
+                            "namespace N2 { const int c = 24; }\n"
+                            "struct S {\n"
+                            "    enum { v1 = N1::c, v2 = N2::c };\n"
+                            "};\n";
+        const char expected[] = "1: namespace N1 { const int c@1 = 42 ; }\n"
+                                "2: namespace N2 { const int c@2 = 24 ; }\n"
+                                "3: struct S {\n"
+                                "4: enum Anonymous0 { v1 = N1 :: c@1 , v2 = N2 :: c@2 } ;\n"
+                                "5: } ;\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
     void varid_classnameshaddowsvariablename() {
         const char code[] = "class Data;\n"
                             "void strange_declarated(const Data& Data);\n"
@@ -2971,6 +4088,37 @@ class TestVarID : public TestFixture {
 
     }
 
+    void varid_classnametemplate() {
+        const char code[] = "template <typename T>\n"
+                            "struct BBB {\n"
+                            "  struct inner;\n"
+                            "};\n"
+                            "\n"
+                            "template <typename T>\n"
+                            "struct BBB<T>::inner {\n"
+                            "  inner(int x);\n"
+                            "  int x;\n"
+                            "};\n"
+                            "\n"
+                            "template <typename T>\n"
+                            "BBB<T>::inner::inner(int x): x(x) {}\n";
+        const char expected[] = "1: template < typename T >\n"
+                                "2: struct BBB {\n"
+                                "3: struct inner ;\n"
+                                "4: } ;\n"
+                                "5:\n"
+                                "6: template < typename T >\n"
+                                "7: struct BBB < T > :: inner {\n"
+                                "8: inner ( int x@1 ) ;\n"
+                                "9: int x@2 ;\n"
+                                "10: } ;\n"
+                                "11:\n"
+                                "12: template < typename T >\n"
+                                "13: BBB < T > :: inner :: inner ( int x@3 ) : x@2 ( x@3 ) { }\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+
+    }
+
     void varidnamespace1() {
         const char code[] = "namespace A {\n"
                             "    char buf[20];\n"
@@ -3074,6 +4222,294 @@ class TestVarID : public TestFixture {
                                 "5: }\n";
         ASSERT_EQUALS(expected, tokenize(code));
     }
+
+    void decltype1() {
+        const char code[] = "void foo(int x, decltype(A::b) *p);";
+        const char expected[] = "1: void foo ( int x@1 , decltype ( A :: b ) * p@2 ) ;\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void decltype2() {
+        const char code[] = "int x; decltype(x) y;";
+        const char expected[] = "1: int x@1 ; decltype ( x@1 ) y@2 ;\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void typeof1() {
+        const char code[] = "int x; typeof(x) y;";
+        const char expected[] = "1: int x@1 ; typeof ( x@1 ) y@2 ;\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void typeof2() {
+        const char code[] = "int x; typeof(x) *y;";
+        const char expected[] = "1: int x@1 ; typeof ( x@1 ) * y@2 ;\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void typeof3() {
+        const char code[] = "int x; const typeof(x) *const y;";
+        const char expected[] = "1: int x@1 ; const typeof ( x@1 ) * const y@2 ;\n";
+        ASSERT_EQUALS(expected, tokenize(code));
+    }
+
+    void typeof4() {
+        const char code[] = "int x; __typeof(x) y;";
+        const char expected[] = "1: int x@1 ; __typeof ( x@1 ) y@2 ;\n";
+        TokenizeOptions options;
+        options.cpp = false;
+        ASSERT_EQUALS(expected, tokenize(code, options));
+    }
+
+    void exprid1() {
+        const std::string actual = tokenizeExpr(
+            "struct A {\n"
+            "    int x, y;\n"
+            "};\n"
+            "int f(A a, A b) {\n"
+            "    int x = a.x + b.x;\n"
+            "    int y = b.x + a.x;\n"
+            "    return x + y + a.y + b.y;\n"
+            "}\n");
+
+        const char expected[] =
+            "1: struct A {\n"
+            "2: int x ; int y ;\n"
+            "3: } ;\n"
+            "4: int f ( A a , A b ) {\n"
+            "5: int x@5 ; x@5 =@UNIQUE a@3 .@11 x@6 +@13 b@4 .@12 x@7 ;\n"
+            "6: int y@8 ; y@8 =@UNIQUE b@4 .@12 x@7 +@13 a@3 .@11 x@6 ;\n"
+            "7: return x@5 +@UNIQUE y@8 +@UNIQUE a@3 .@UNIQUE y@9 +@UNIQUE b@4 .@UNIQUE y@10 ;\n"
+            "8: }\n";
+
+        ASSERT_EQUALS(expected, actual);
+    }
+
+    void exprid2() {
+        const std::string actual = tokenizeExpr( // #11739
+            "struct S { std::unique_ptr<int> u; };\n"
+            "auto f = [](const S& s) -> std::unique_ptr<int> {\n"
+            "    if (auto p = s.u.get())\n"
+            "        return std::make_unique<int>(*p);\n"
+            "    return nullptr;\n"
+            "};\n");
+
+        const char expected[] = "1: struct S { std :: unique_ptr < int > u ; } ;\n"
+                                "2: auto f ; f = [ ] ( const S & s ) . std :: unique_ptr < int > {\n"
+                                "3: if ( auto p@4 =@UNIQUE s@3 .@UNIQUE u@5 .@UNIQUE get (@UNIQUE ) ) {\n"
+                                "4: return std ::@UNIQUE make_unique < int > (@UNIQUE *@UNIQUE p@4 ) ; }\n"
+                                "5: return nullptr ;\n"
+                                "6: } ;\n";
+
+        ASSERT_EQUALS(expected, actual);
+    }
+
+    void exprid3() {
+        const char code[] = "void f(bool b, int y) {\n"
+                            "    if (b && y > 0) {}\n"
+                            "    while (b && y > 0) {}\n"
+                            "}\n";
+        const char expected[] = "1: void f ( bool b , int y ) {\n"
+                                "2: if ( b@1 &&@5 y@2 >@4 0 ) { }\n"
+                                "3: while ( b@1 &&@5 y@2 >@4 0 ) { }\n"
+                                "4: }\n";
+        ASSERT_EQUALS(expected, tokenizeExpr(code));
+    }
+
+    void exprid4() {
+        // expanded macro..
+        const char code[] = "#define ADD(x,y)  x+y\n"
+                            "int f(int a, int b) {\n"
+                            "    return ADD(a,b) + ADD(a,b);\n"
+                            "}\n";
+        const char expected[] = "2: int f ( int a , int b ) {\n"
+                                "3: return a@1 $+@UNIQUE b@2 +@UNIQUE a@1 $+@UNIQUE b@2 ;\n"
+                                "4: }\n";
+        ASSERT_EQUALS(expected, tokenizeExpr(code));
+    }
+
+    void exprid5() {
+        // references..
+        const char code[] = "int foo(int a) {\n"
+                            "    int& r = a;\n"
+                            "    return (a+a)*(r+r);\n"
+                            "}\n";
+        const char expected[] = "1: int foo ( int a ) {\n"
+                                "2: int & r@2 =@UNIQUE a@1 ;\n"
+                                "3: return ( a@1 +@4 a@1 ) *@UNIQUE ( r@2 +@4 r@2 ) ;\n"
+                                "4: }\n";
+        ASSERT_EQUALS(expected, tokenizeExpr(code));
+    }
+
+    void exprid6() {
+        // ++ and -- should have UNIQUE exprid
+        const char code[] = "void foo(int *a) {\n"
+                            "    *a++ = 0;\n"
+                            "    if (*a++ == 32) {}\n"
+                            "}\n";
+        const char expected[] = "1: void foo ( int * a ) {\n"
+                                "2: *@UNIQUE a@1 ++@UNIQUE = 0 ;\n"
+                                "3: if ( *@UNIQUE a@1 ++@UNIQUE ==@UNIQUE 32 ) { }\n"
+                                "4: }\n";
+        ASSERT_EQUALS(expected, tokenizeExpr(code));
+    }
+
+    void exprid7() {
+        // different casts
+        const char code[] = "void foo(int a) {\n"
+                            "    if ((char)a == (short)a) {}\n"
+                            "    if ((char)a == (short)a) {}\n"
+                            "}\n";
+        const char expected[] = "1: void foo ( int a ) {\n"
+                                "2: if ( (@2 char ) a@1 ==@4 (@3 short ) a@1 ) { }\n"
+                                "3: if ( (@2 char ) a@1 ==@4 (@3 short ) a@1 ) { }\n"
+                                "4: }\n";
+        ASSERT_EQUALS(expected, tokenizeExpr(code));
+    }
+
+    void exprid8() {
+        const char code[] = "void f() {\n" // #12249
+                            "    std::string s;\n"
+                            "    (((s += \"--\") += std::string()) += \"=\");\n"
+                            "}\n";
+        const char expected[] = "1: void f ( ) {\n"
+                                "2: std ::@UNIQUE string s@1 ;\n"
+                                "3: ( ( s@1 +=@UNIQUE \"--\"@UNIQUE ) +=@UNIQUE std ::@UNIQUE string (@UNIQUE ) ) +=@UNIQUE \"=\"@UNIQUE ;\n"
+                                "4: }\n";
+        ASSERT_EQUALS(expected, tokenizeExpr(code));
+
+        const char code2[] = "struct S { std::function<void()>* p; };\n"
+                             "S f() { return S{ std::make_unique<std::function<void()>>([]() {}).release()}; }";
+        const char expected2[] = "1: struct S { std :: function < void ( ) > * p ; } ;\n"
+                                 "2: S f ( ) { return S@UNIQUE {@UNIQUE std ::@UNIQUE make_unique < std :: function < void ( ) > > (@UNIQUE [ ] ( ) { } ) .@UNIQUE release (@UNIQUE ) } ; }\n";
+        ASSERT_EQUALS(expected2, tokenizeExpr(code2));
+
+        const char code3[] = "struct S { int* p; };\n"
+                             "S f() { return S{ std::make_unique<int>([]() { return 4; }()).release()}; }\n";
+        const char expected3[] = "1: struct S { int * p ; } ;\n"
+                                 "2: S f ( ) { return S@UNIQUE {@UNIQUE std ::@UNIQUE make_unique < int > (@UNIQUE [ ] ( ) { return 4 ; } ( ) ) .@UNIQUE release (@UNIQUE ) } ; }\n";
+        ASSERT_EQUALS(expected3, tokenizeExpr(code3));
+
+        const char code4[] = "std::unique_ptr<int> g(int i) { return std::make_unique<int>(i); }\n"
+                             "void h(int*);\n"
+                             "void f() {\n"
+                             "    h(g({}).get());\n"
+                             "}\n";
+        const char expected4[] = "1: std :: unique_ptr < int > g ( int i ) { return std ::@UNIQUE make_unique < int > (@UNIQUE i@1 ) ; }\n"
+                                 "2: void h ( int * ) ;\n"
+                                 "3: void f ( ) {\n"
+                                 "4: h (@UNIQUE g (@UNIQUE { } ) .@UNIQUE get (@UNIQUE ) ) ;\n"
+                                 "5: }\n";
+        ASSERT_EQUALS(expected4, tokenizeExpr(code4));
+
+        const char code5[] = "int* g(std::map<int, std::unique_ptr<int>>& m) {\n"
+                             "    return m[{0}].get();\n"
+                             "}\n";
+        const char expected5[] = "1: int * g ( std :: map < int , std :: unique_ptr < int > > & m ) {\n"
+                                 "2: return m@1 [@UNIQUE { 0 } ] .@UNIQUE get (@UNIQUE ) ;\n"
+                                 "3: }\n";
+        ASSERT_EQUALS(expected5, tokenizeExpr(code5));
+    }
+
+    void exprid9()
+    {
+        const char code[] = "void f(const std::type_info& type) {\n" // #12340
+                            "    if (type == typeid(unsigned int)) {}\n"
+                            "    else if (type == typeid(int)) {}\n"
+                            "}\n";
+        const char expected[] = "1: void f ( const std :: type_info & type ) {\n"
+                                "2: if ( type@1 ==@UNIQUE typeid (@UNIQUE unsigned int@UNIQUE ) ) { }\n"
+                                "3: else { if ( type@1 ==@UNIQUE typeid (@UNIQUE int@UNIQUE ) ) { } }\n"
+                                "4: }\n";
+        ASSERT_EQUALS(expected, tokenizeExpr(code));
+    }
+
+    void exprid10()
+    {
+        const char code[] = "void f(const std::string& p) {\n" // #12350
+                            "    std::string s;\n"
+                            "    ((s = \"abc\") += p) += \"def\";\n"
+                            "}\n";
+        const char expected[] = "1: void f ( const std :: string & p ) {\n"
+                                "2: std ::@UNIQUE string s@2 ;\n"
+                                "3: ( ( s@2 =@UNIQUE \"abc\" ) +=@UNIQUE p@1 ) +=@UNIQUE \"def\"@UNIQUE ;\n"
+                                "4: }\n";
+        ASSERT_EQUALS(expected, tokenizeExpr(code));
+    }
+
+    void exprid11()
+    {
+        const char code[] = "struct S { void f(); };\n" // #12713
+                            "int g(int, S*);\n"
+                            "int h(void (*)(), S*);\n"
+                            "void S::f() {\n"
+                            "    std::make_unique<int>(g({}, this)).release();\n"
+                            "    std::make_unique<int>(h([]() {}, this)).release();\n"
+                            "}\n";
+        const char* exp = "1: struct S { void f ( ) ; } ;\n"
+                          "2: int g ( int , S * ) ;\n"
+                          "3: int h ( void ( * ) ( ) , S * ) ;\n"
+                          "4: void S :: f ( ) {\n"
+                          "5: std ::@UNIQUE make_unique < int > (@UNIQUE g (@UNIQUE { } ,@6 this ) ) .@UNIQUE release (@UNIQUE ) ;\n"
+                          "6: std ::@UNIQUE make_unique < int > (@UNIQUE h (@UNIQUE [ ] ( ) { } ,@6 this ) ) .@UNIQUE release (@UNIQUE ) ;\n"
+                          "7: }\n";
+        ASSERT_EQUALS(exp, tokenizeExpr(code));
+    }
+
+    void exprid12()
+    {
+        const char code[] = "struct S { std::unique_ptr<int> p; };\n" // #12765
+                            "namespace N {\n"
+                            "    struct T { void (*f)(S*); };\n"
+                            "    const T t = {\n"
+                            "        [](S* s) { s->p.release(); }\n"
+                            "    };\n"
+                            "}\n";
+        const char* exp = "1: struct S { std :: unique_ptr < int > p ; } ;\n"
+                          "2: namespace N {\n"
+                          "3: struct T { void ( * f@2 ) ( S * ) ; } ;\n"
+                          "4: const T t@3 = {\n"
+                          "5: [ ] ( S * s@4 ) { s@4 .@UNIQUE p@5 .@UNIQUE release (@UNIQUE ) ; }\n"
+                          "6: } ;\n"
+                          "7: }\n";
+        ASSERT_EQUALS(exp, tokenizeExpr(code));
+    }
+
+    void exprid13()
+    {
+        const char code[] = "struct S { int s; };\n" // #11488
+                            "struct T { struct S s; };\n"
+                            "struct U { struct T t; };\n"
+                            "void f() {\n"
+                            "    struct U u = { .t = { .s = { .s = 1 } } };\n"
+                            "}\n";
+        const char* exp = "1: struct S { int s ; } ;\n"
+                          "2: struct T { struct S s ; } ;\n"
+                          "3: struct U { struct T t ; } ;\n"
+                          "4: void f ( ) {\n"
+                          "5: struct U u@4 ; u@4 = { .@UNIQUE t@5 = { . s = { . s = 1 } } } ;\n"
+                          "6: }\n";
+        ASSERT_EQUALS(exp, tokenizeExpr(code));
+    }
+
+    void exprid14()
+    {
+        const Settings s = settingsBuilder(settings).library("std.cfg").build();
+
+        const char code[] = "int f(double a, double b, double c) {\n" // #13578
+                            "    return static_cast<int>(std::ceil((std::min)(a, (std::min)(b, c))));\n"
+                            "}\n";
+        const char* exp = "1: int f ( double a@1 , double b@2 , double c@3 ) {\n"
+                          "2: return static_cast < int > ( std :: ceil ( std :: min ( a@1 , std :: min ( b@2 , c@3 ) ) ) ) ;\n"
+                          "3: }\n";
+        ASSERT_EQUALS(exp, tokenize(code, s)); // don't crash
+    }
+
+    void structuredBindings() {
+        const char code[] = "int foo() { auto [x,y] = xy(); return x+y; }";
+        ASSERT_EQUALS("1: int foo ( ) { auto [ x@1 , y@2 ] = xy ( ) ; return x@1 + y@2 ; }\n",
+                      tokenize(code));
+    }
 };
 
 REGISTER_TEST(TestVarID)
diff --git a/test/testvfvalue.cpp b/test/testvfvalue.cpp
new file mode 100644
index 00000000000..e2b7e499877
--- /dev/null
+++ b/test/testvfvalue.cpp
@@ -0,0 +1,48 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2025 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "fixture.h"
+#include "vfvalue.h"
+
+class TestValueFlowValue : public TestFixture {
+public:
+    TestValueFlowValue() : TestFixture("TestValueFlowValue") {}
+
+private:
+    void run() override {
+        TEST_CASE(toString);
+    }
+
+    void toString() const {
+        {
+            ValueFlow::Value v;
+            ASSERT_EQUALS("0", v.toString());
+            v.intvalue = -1;
+            ASSERT_EQUALS("-1", v.toString());
+        }
+        {
+            ValueFlow::Value v;
+            v.valueType = ValueFlow::Value::ValueType::FLOAT;
+            ASSERT_EQUALS("0.0", v.toString());
+            v.floatValue = 0.0000000000001;
+            ASSERT_EQUALS("1e-13", v.toString());
+        }
+    }
+};
+
+REGISTER_TEST(TestValueFlowValue)
diff --git a/test/tools/donate_cpu_lib_test.py b/test/tools/donate_cpu_lib_test.py
new file mode 100644
index 00000000000..e00a3d296a0
--- /dev/null
+++ b/test/tools/donate_cpu_lib_test.py
@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+#
+# Cppcheck - A tool for static C/C++ code analysis
+# Copyright (C) 2007-2022 Cppcheck team.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from donate_cpu_lib import *
+
+def _test_library_includes(tmpdir, libs, content, libinc_obj=None):
+    if libinc_obj is None:
+        library_includes = LibraryIncludes()
+    else:
+        library_includes = libinc_obj
+
+    src_file = os.path.join(str(tmpdir), "file.cpp")
+    with open(src_file, 'w') as f:
+        f.write(content)
+    libs.sort()
+    libs_found = library_includes.get_libraries(str(tmpdir))
+    libs_found.sort()
+    assert libs == libs_found
+
+def test_library_includes(tmpdir):
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd'], '')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd'], '#include <stdio.h>')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'boost'], '#include <boost/regex.hpp>')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'python'], '#include "Python.h"')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'libcerror', 'lua', 'opengl', 'qt'], '#include <QApplication>\n#include <GL/gl.h>\r#include "lua.h"\r\n#include <libcerror.h>')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'microsoft_sal'], '  #include <sal.h>')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'googletest'], '\t#include <gtest/gtest.h>')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'microsoft_atl'], '  \t  #include <atlbase.h>')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'cairo'], '\t  #include <cairo.h>')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'gtk'], '  \t#include <glib-object.h>')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'gtk'], '  \t #include <glib.h>')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'gtk'], ' # include <glib/gi18n.h>')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'gtk'], '#include <gdk/gdkkeysyms.h>')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'bsd'], '#include <sys/uio.h>\r\n')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'libcurl'], '#include <curl/curl.h>\r')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'sqlite3'], '#include <sqlite3.h>\n')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'openmp'], '#  include <omp.h>')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'mfc'], '#\tinclude <afxwin.h>')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'ruby'], '#  \tinclude "ruby.h"')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'zlib'], '#\t  include <zlib.h>')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'pcre'], '#include<pcre.h>')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'pcre'], '#include  "pcre.h"')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'opengl'], '#include\t  <GL/glut.h>')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'nspr'], '#include\t"prtypes.h"')
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'lua'], '#include  \t<lua.h>')
+
+def test_match_multiple_time(tmpdir):
+    libinc = LibraryIncludes()
+
+    # there was a bug that we would only match each library once successfully
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'zlib'], '#include <zlib.h>', libinc)
+    _test_library_includes(tmpdir, ['posix', 'gnu', 'bsd', 'zlib'], '#include <zlib.h>', libinc)
diff --git a/test/tools/donate_cpu_server_test.py b/test/tools/donate_cpu_server_test.py
new file mode 100644
index 00000000000..a9d9074a339
--- /dev/null
+++ b/test/tools/donate_cpu_server_test.py
@@ -0,0 +1,17 @@
+from importlib import import_module
+
+donate_cpu_server = import_module('donate-cpu-server')
+
+def _test_parse_req(req_str, url_exp, queryParams_exp):
+    url, queryParams = donate_cpu_server.HttpClientThread.parse_req(req_str)
+    assert url == url_exp and queryParams == queryParams_exp
+
+def test_parse_req():
+    _test_parse_req("", None, None)
+    _test_parse_req("GET / HTTP/1.1", '/', {})
+    _test_parse_req("GET /crash.html HTTP/1.1", '/crash.html', {})
+    _test_parse_req("GET /head-uninitvar HTTP/1.1", '/head-uninitvar', {})
+    _test_parse_req("GET /check_library-std%3A%3Aunordered_set%3A%3Ainsert%28%29 HTTP/1.1", '/check_library-std%3A%3Aunordered_set%3A%3Ainsert%28%29', {})
+    _test_parse_req("GET /head-uninitvar?pkgs=1 HTTP/1.1", '/head-uninitvar', {'pkgs': '1'})
+    _test_parse_req("GET /crash.html?pkgs=1 HTTP/1.1", '/crash.html', {'pkgs': '1'})
+    _test_parse_req("GET /head-uninitvar?pkgs=1&pkgs2=2 HTTP/1.1", '/head-uninitvar', {'pkgs': '1', 'pkgs2': '2'})
diff --git a/test/tools/htmlreport/check.sh b/test/tools/htmlreport/check.sh
new file mode 100755
index 00000000000..d3945eea532
--- /dev/null
+++ b/test/tools/htmlreport/check.sh
@@ -0,0 +1,73 @@
+#!/bin/bash -ex
+
+# Command for checking HTML syntax with HTML Tidy, see http://www.html-tidy.org/
+tidy_cmd='tidy -o /dev/null -eq --drop-empty-elements no'
+
+function validate_html {
+    if [ ! -f "$1" ]; then
+        echo "File $1 does not exist!"
+	      exit 1
+    fi
+    if ! ${tidy_cmd} "$1"; then
+        echo "HTML validation failed!"
+        exit 1
+    fi
+}
+
+if [ -z "$PYTHON" ]; then
+    PYTHON=python3
+fi
+
+SCRIPT_DIR="$(dirname ${BASH_SOURCE[0]})"
+ABSOLUTE_SCRIPT_DIR="$(cd -- ${SCRIPT_DIR} ; pwd -P)"
+PROJECT_ROOT_DIR="$(cd -- ${SCRIPT_DIR}/../../../ ; pwd -P)"
+REPORT_DIR=$(mktemp -d -t htmlreport-XXXXXXXXXX)
+INDEX_HTML="$REPORT_DIR/index.html"
+STATS_HTML="$REPORT_DIR/stats.html"
+GUI_TEST_XML="$REPORT_DIR/gui_test.xml"
+ERRORLIST_XML="$REPORT_DIR/errorlist.xml"
+UNMATCHEDSUPPR_XML="$REPORT_DIR/unmatchedSuppr.xml"
+
+$PYTHON ${PROJECT_ROOT_DIR}/htmlreport/cppcheck-htmlreport --file ${PROJECT_ROOT_DIR}/gui/test/data/xmlfiles/xmlreport_v2.xml --title "xml2 test" --report-dir "$REPORT_DIR" --source-dir ${PROJECT_ROOT_DIR}/test/
+echo -e "\n"
+# Check HTML syntax
+validate_html "$INDEX_HTML"
+validate_html "$STATS_HTML"
+
+
+${PROJECT_ROOT_DIR}/cppcheck ${PROJECT_ROOT_DIR}/samples --enable=all --inconclusive --xml-version=2 2> "$GUI_TEST_XML"
+xmllint --noout "$GUI_TEST_XML"
+$PYTHON ${PROJECT_ROOT_DIR}/htmlreport/cppcheck-htmlreport --file "$GUI_TEST_XML" --title "xml2 + inconclusive test" --report-dir "$REPORT_DIR"
+echo ""
+# Check HTML syntax
+validate_html "$INDEX_HTML"
+validate_html "$STATS_HTML"
+
+
+${PROJECT_ROOT_DIR}/cppcheck ${PROJECT_ROOT_DIR}/samples --enable=all --inconclusive --verbose --xml-version=2 2> "$GUI_TEST_XML"
+xmllint --noout "$GUI_TEST_XML"
+$PYTHON ${PROJECT_ROOT_DIR}/htmlreport/cppcheck-htmlreport --file "$GUI_TEST_XML" --title "xml2 + inconclusive + verbose test" --report-dir "$REPORT_DIR"
+echo -e "\n"
+# Check HTML syntax
+validate_html "$INDEX_HTML"
+validate_html "$STATS_HTML"
+
+
+${PROJECT_ROOT_DIR}/cppcheck --errorlist --inconclusive --xml-version=2 > "$ERRORLIST_XML"
+xmllint --noout "$ERRORLIST_XML"
+$PYTHON ${PROJECT_ROOT_DIR}/htmlreport/cppcheck-htmlreport --file "$ERRORLIST_XML" --title "errorlist" --report-dir "$REPORT_DIR"
+# Check HTML syntax
+validate_html "$INDEX_HTML"
+validate_html "$STATS_HTML"
+
+
+${PROJECT_ROOT_DIR}/cppcheck ${PROJECT_ROOT_DIR}/samples/memleak/good.c ${PROJECT_ROOT_DIR}/samples/resourceLeak/good.c  --xml-version=2 --enable=information --suppressions-list="${ABSOLUTE_SCRIPT_DIR}/test_suppressions.txt" --xml 2> "$UNMATCHEDSUPPR_XML"
+xmllint --noout "$UNMATCHEDSUPPR_XML"
+$PYTHON ${PROJECT_ROOT_DIR}/htmlreport/cppcheck-htmlreport --file "$UNMATCHEDSUPPR_XML" --title "unmatched Suppressions" --report-dir="$REPORT_DIR"
+grep "unmatchedSuppression<.*>information<.*>Unmatched suppression: variableScope*<" "$INDEX_HTML"
+grep ">unmatchedSuppression</.*>information<.*>Unmatched suppression: uninitstring<" "$INDEX_HTML"
+# Check HTML syntax
+validate_html "$INDEX_HTML"
+validate_html "$STATS_HTML"
+
+rm -rf "$REPORT_DIR"
diff --git a/test/tools/htmlreport/example-checkers.txt b/test/tools/htmlreport/example-checkers.txt
new file mode 100644
index 00000000000..5a3259713e2
--- /dev/null
+++ b/test/tools/htmlreport/example-checkers.txt
@@ -0,0 +1 @@
+Just a few random words..
diff --git a/htmlreport/example.cc b/test/tools/htmlreport/example.cc
similarity index 100%
rename from htmlreport/example.cc
rename to test/tools/htmlreport/example.cc
diff --git a/htmlreport/example.xml b/test/tools/htmlreport/example.xml
similarity index 100%
rename from htmlreport/example.xml
rename to test/tools/htmlreport/example.xml
diff --git a/htmlreport/test_htmlreport.py b/test/tools/htmlreport/test_htmlreport.py
similarity index 52%
rename from htmlreport/test_htmlreport.py
rename to test/tools/htmlreport/test_htmlreport.py
index 6553f625e0c..6f8713f4f55 100755
--- a/htmlreport/test_htmlreport.py
+++ b/test/tools/htmlreport/test_htmlreport.py
@@ -1,24 +1,24 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 """Test cppcheck-htmlreport."""
 
 import os
 import contextlib
-import shutil
 import subprocess
 import sys
 import tempfile
 
-if sys.version_info < (2, 7):
-    # For TestCase.assertIn().
-    import unittest2 as unittest
-else:
-    import unittest
+import unittest
+import time
 
-ROOT_DIR = os.path.split(os.path.abspath(os.path.dirname(__file__)))[0]
+TEST_TOOLS_DIR = os.path.abspath(os.path.dirname(__file__))
+ROOT_DIR = os.path.split(os.path.dirname(os.path.dirname(TEST_TOOLS_DIR)))[0]
+HTMLREPORT_DIR = os.path.join(ROOT_DIR, 'htmlreport')
 CPPCHECK_BIN = os.path.join(ROOT_DIR, 'cppcheck')
 
-HTML_REPORT_BIN = os.path.join(os.path.abspath(os.path.dirname(__file__)),
-                               'cppcheck-htmlreport')
+if os.getenv("PIP_PACKAGE_TEST") is not None:
+    HTML_REPORT_BIN = ['cppcheck-htmlreport']
+else:
+    HTML_REPORT_BIN = [sys.executable, os.path.join(HTMLREPORT_DIR, 'cppcheck-htmlreport')]
 
 
 class TestHTMLReport(unittest.TestCase):
@@ -37,7 +37,7 @@ def checkReportError(self, xml_version):
             self.assertIn('Memory leak:', report)
             self.assertIn('bad.c', report)
 
-            detail_filename = os.path.join(output_directory, '0.html')
+            detail_filename = os.path.join(output_directory.name, '0.html')
             self.assertTrue(
                 os.path.exists(detail_filename))
 
@@ -46,6 +46,8 @@ def checkReportError(self, xml_version):
                 self.assertIn('<html', detail_contents)
                 self.assertIn('Memory leak:', detail_contents)
 
+            output_directory.cleanup()
+
     def testReportNoError(self):
         for xml_version in ['2']:
             self.checkReportNoError(xml_version)
@@ -61,11 +63,13 @@ def checkReportNoError(self, xml_version):
             self.assertNotIn('good.c', report)
 
             self.assertFalse(
-                os.path.exists(os.path.join(output_directory, '0.html')))
+                os.path.exists(os.path.join(output_directory.name, '0.html')))
+
+            output_directory.cleanup()
 
     def testMissingInclude(self):
         with runCheck(
-            xml_filename=os.path.join(ROOT_DIR, 'htmlreport', 'example.xml'),
+            xml_filename=os.path.join(TEST_TOOLS_DIR, 'example.xml'),
         ) as (report, output_directory):
             self.assertIn('<html', report)
 
@@ -73,21 +77,49 @@ def testMissingInclude(self):
             self.assertIn('example.cc', report)
 
             self.assertTrue(
-                os.path.exists(os.path.join(output_directory, '0.html')))
+                os.path.exists(os.path.join(output_directory.name, '0.html')))
+
+            output_directory.cleanup()
+
+    def testAddCheckersReport(self):
+        with runCheck(
+            xml_filename=os.path.join(TEST_TOOLS_DIR, 'example.xml'),
+            checkers_filename=os.path.join(TEST_TOOLS_DIR, 'example-checkers.txt')
+        ) as (report, output_directory):
+            self.assertIn('<html', report)
+
+            self.assertIn('<a href="checkers.html"', report)
+
+            self.assertTrue(
+                os.path.exists(os.path.join(output_directory.name, 'checkers.html')))
+
+            output_directory.cleanup()
+
+    def testAddTimestamp(self):
+        with runCheck(
+            xml_filename=os.path.join(TEST_TOOLS_DIR, 'example.xml'),
+        ) as (report, output_directory):
+            xml_file = os.path.join(TEST_TOOLS_DIR, 'example.xml')
+            t = os.path.getmtime(xml_file)
+            t_s = time.ctime(t)
+
+            self.assertIn(t_s, report)
+
+            output_directory.cleanup()
 
 
 @contextlib.contextmanager
-def runCheck(source_filename=None, xml_version='1', xml_filename=None):
+def runCheck(source_filename=None, xml_version='1', xml_filename=None, checkers_filename=None):
     """Run cppcheck and cppcheck-htmlreport.
 
     Yield a tuple containing the resulting HTML report index and the directory
     path.
 
     """
-    output_directory = tempfile.mkdtemp(dir='.')
+    output_directory = tempfile.TemporaryDirectory(dir='.')
     if xml_filename is None:
         assert source_filename
-        xml_filename = os.path.join(output_directory, 'output.xml')
+        xml_filename = os.path.join(output_directory.name, 'output.xml')
 
         with open(xml_filename, 'w') as output_file:
             subprocess.check_call(
@@ -97,18 +129,20 @@ def runCheck(source_filename=None, xml_version='1', xml_filename=None):
 
     assert os.path.exists(xml_filename)
 
-    subprocess.check_call(
-        [HTML_REPORT_BIN,
+    args = [*HTML_REPORT_BIN,
          '--file=' + os.path.realpath(xml_filename),
-         '--report-dir=' + os.path.realpath(output_directory)],
-        cwd=os.path.join(ROOT_DIR, 'htmlreport'))
+         '--report-dir=' + os.path.realpath(output_directory.name)]
+    if checkers_filename:
+        args.append('--checkers-report-file=' + os.path.realpath(checkers_filename))
 
-    with open(os.path.join(output_directory, 'index.html')) as index_file:
-        index_contents = index_file.read()
+    subprocess.check_call(
+        args,
+        cwd=TEST_TOOLS_DIR)
 
-    yield (index_contents, output_directory)
+    with open(os.path.join(output_directory.name, 'index.html')) as index_file:
+        index_contents = index_file.read()
 
-    shutil.rmtree(output_directory)
+    yield index_contents, output_directory
 
 
 if __name__ == '__main__':
diff --git a/test/tools/htmlreport/test_suppressions.txt b/test/tools/htmlreport/test_suppressions.txt
new file mode 100644
index 00000000000..eb580524e33
--- /dev/null
+++ b/test/tools/htmlreport/test_suppressions.txt
@@ -0,0 +1,3 @@
+variableScope:*/samples/memleak/good.c
+*:*/samples/resourceLeak/notexisting.c*
+uninitstring:*
diff --git a/test/tools/reduce_test.py b/test/tools/reduce_test.py
new file mode 100644
index 00000000000..aaeec7a87e3
--- /dev/null
+++ b/test/tools/reduce_test.py
@@ -0,0 +1,143 @@
+#!/usr/bin/env python
+from reduce import Reduce
+
+
+class ReduceTest(Reduce):
+    # pylint: disable-next=super-init-not-called - we do not want the super __init__ to be called
+    def __init__(self):
+        # super().__init__('', '', '')
+        pass
+
+    def runtool(self, filedata=None):
+        return True
+
+    def writefile(self, filedata):
+        pass
+
+    def writebackupfile(self, filedata):
+        pass
+
+
+def test_removecomments():
+    """make sure we keep the \n when removing a comment at the end of a line"""
+
+    reduce = ReduceTest()
+
+    filedata = [
+        'int i; // some integer\n',
+        'int j;\n'
+    ]
+
+    expected = [
+        'int i;\n',
+        'int j;\n'
+    ]
+
+    reduce.removecomments(filedata)
+    assert filedata == expected
+
+
+def test_removedirectives():
+    """do not remove any of the #if*, #el* or #endif directives on their own"""
+
+    reduce = ReduceTest()
+
+    filedata = [
+        '#if 0\n',
+        '#else\n',
+        '#endif\n',
+        '#ifdef DEF\n',
+        '#elif 0\n'
+        '#endif\n'
+    ]
+
+    expected = [
+        '#if 0\n',
+        '#else\n',
+        '#endif\n',
+        '#ifdef DEF\n',
+        '#elif 0\n'
+        '#endif\n'
+    ]
+
+    reduce.removedirectives(filedata)
+    assert filedata == expected
+
+
+def test_combinelines_chunk():
+    """do not fail with 'TypeError: slice indices must be integers or None or have an __index__ method'"""
+
+    class ReduceTestFail(ReduceTest):
+        def runtool(self, filedata=None):
+            print(filedata)
+            return False
+
+    reduce = ReduceTestFail()
+
+    # need to have at least 11 lines ending with comma to enter chunked mode and twice as much for second iteration
+    filedata = [
+        'int i,\n',
+        'j,\n',
+        'k,\n',
+        'l,\n',
+        'm,\n',
+        'n,\n',
+        'o,\n',
+        'p,\n',
+        'q,\n',
+        'r,\n',
+        's,\n',
+        't;\n',
+        'int i1,\n',
+        'j1,\n',
+        'k1,\n',
+        'l1,\n',
+        'm1,\n',
+        'n1,\n',
+        'o1,\n',
+        'p1,\n',
+        'q1,\n',
+        'r1,\n',
+        's1,\n',
+        't1;\n'
+    ]
+
+    reduce.combinelines(filedata)
+
+
+def test_combinelines_chunk_2():
+    """'filedata' is not changed by the function since the data is assigned to a local variable"""
+
+    reduce = ReduceTest()
+
+    # need to have at least 11 lines ending with comma to enter chunked mode
+    filedata = [
+        'int i,\n',
+        'j,\n',
+        'k,\n',
+        'l,\n',
+        'm,\n',
+        'n,\n',
+        'o,\n',
+        'p,\n',
+        'q,\n',
+        'r,\n',
+        's,\n',
+        't;\n'
+    ]
+    filedata_exp = filedata
+
+    filedata2 = reduce.combinelines(filedata)
+    assert filedata == filedata_exp
+    assert filedata2 == ['int i,j,\n',
+                         '',
+                         'l,\n',
+                         'm,\n',
+                         'n,\n',
+                         'o,\n',
+                         'p,\n',
+                         'q,\n',
+                         'r,\n',
+                         's,\n',
+                         't;\n',
+                         '']
diff --git a/tools/test_matchcompiler.py b/test/tools/test_matchcompiler.py
similarity index 81%
rename from tools/test_matchcompiler.py
rename to test/tools/test_matchcompiler.py
index f5164559680..104601df7e3 100755
--- a/tools/test_matchcompiler.py
+++ b/test/tools/test_matchcompiler.py
@@ -1,7 +1,7 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Cppcheck - A tool for static C/C++ code analysis
-# Copyright (C) 2007-2017 Cppcheck team.
+# Copyright (C) 2007-2021 Cppcheck team.
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -39,6 +39,10 @@ def test_replaceTokenMatch(self):
         output = self.mc._replaceTokenMatch(input, 0, "foo.cpp")
         self.assertEqual(output, 'if (match1(tok)) {')
 
+        input = 'if (Token::simpleMatch(tok, "foobar")) {'
+        output = self.mc._replaceTokenMatch(input, 0, "foo.cpp")
+        self.assertEqual(output, 'if (match1(tok)) {')
+
         input = 'if (Token::Match(tok->next()->next(), "foobar %type% %num%")) {'
         output = self.mc._replaceTokenMatch(input, 0, "foo.cpp")
         self.assertEqual(output, 'if (match2(tok->next()->next())) {')
@@ -60,6 +64,25 @@ def test_replaceTokenMatch(self):
         self.assertEqual(
             output, 'if (Token::Match(tok, "extern \"C\" " + varname)) {')
 
+        # test that multiple patterns on the same line are replaced
+        input = 'if (Token::Match(tok, "foo") && Token::Match(tok->next(), "baz")) {'
+        output = self.mc._replaceTokenMatch(input, 0, "foo.cpp")
+        self.assertEqual(output, 'if (match4(tok) && match5(tok->next())) {')
+
+        # test that second pattern is replaced, even if there is a bailout on the first pattern
+        input = 'if (Token::Match(tok, foo) && Token::Match(tok->next(), "foobaz")) {'
+        output = self.mc._replaceTokenMatch(input, 0, "foo.cpp")
+        self.assertEqual(output, 'if (Token::Match(tok, foo) && match6(tok->next())) {')
+
+        # test mixing Match and simpleMatch on the same line
+        input = 'if (Token::Match(tok, "a") && Token::simpleMatch(tok->next(), "b")) {'
+        output = self.mc._replaceTokenMatch(input, 0, "foo.cpp")
+        self.assertEqual(output, 'if (match7(tok) && match8(tok->next())) {')
+
+        input = 'if (Token::simpleMatch(tok, "a") && Token::Match(tok->next(), "b")) {'
+        output = self.mc._replaceTokenMatch(input, 0, "foo.cpp")
+        self.assertEqual(output, 'if (match7(tok) && match8(tok->next())) {')
+
     def test_replaceTokenMatchWithVarId(self):
         input = 'if (Token::Match(tok, "foobar %varid%", 123)) {'
         output = self.mc._replaceTokenMatch(input, 0, "foo.cpp")
@@ -168,5 +191,10 @@ def test_replaceCStrings(self):
             'if (match16(parent->tokAt(-3)) && tok->strAt(1) == MatchCompiler::makeConstString(")"))',
             output)
 
+    def test_parseMatchSkipComments(self):
+        input = '// TODO: suggest Token::exactMatch() for Token::simpleMatch() when pattern contains no whitespaces'
+        output = self.mc._replaceTokenMatch(input, 0, "foo.cpp")
+        self.assertEqual(output, '// TODO: suggest Token::exactMatch() for Token::simpleMatch() when pattern contains no whitespaces')
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/test/verify/juliet.py b/test/verify/juliet.py
deleted file mode 100644
index 53a4215298c..00000000000
--- a/test/verify/juliet.py
+++ /dev/null
@@ -1,68 +0,0 @@
-# Test if --verify works using the juliet testsuite
-
-
-import glob
-import os
-import re
-import sys
-import subprocess
-
-JULIET_PATH = os.path.expanduser('~/juliet')
-if sys.argv[0] in ('test/verify/juliet.py', './test/verify/juliet.py'):
-    CPPCHECK_PATH = './cppcheck'
-else:
-    CPPCHECK_PATH = '../../cppcheck'
-
-def get_files(juliet_path:str, test_cases:str):
-    ret = []
-    g = os.path.join(juliet_path, test_cases)
-    print(g)
-    for f in sorted(glob.glob(g)):
-        res = re.match(r'(.*[0-9][0-9])[a-x]?.(cp*)$', f)
-        if res is None:
-            print('Non-match!! ' + f)
-            sys.exit(1)
-        f = res.group(1) + '*.' + res.group(2)
-        if f not in ret:
-            ret.append(f)
-    return ret
-
-
-def check(tc:str, warning_id:str):
-    num_ok = 0
-    num_failed = 0
-
-    for f in get_files(JULIET_PATH, tc):
-        cmd = [CPPCHECK_PATH,
-               '-I' + os.path.join(JULIET_PATH, 'C/testcasesupport'),
-               '-DOMIT_GOOD',
-               '--library=posix',
-               '--verify',
-               '--platform=unix64']
-        cmd += glob.glob(f)
-        p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        comm = p.communicate()
-        stdout = comm[0].decode(encoding='utf-8', errors='ignore')
-        stderr = comm[1].decode(encoding='utf-8', errors='ignore')
-
-        if warning_id in stderr:
-            num_ok += 1
-        else:
-            print(f'fail: ' + ' '.join(cmd))
-            num_failed += 1
-
-    cwepos = tc.find('CWE')
-    cwe = tc[cwepos:cwepos+6]
-
-    return f'{cwe} ok:{num_ok}, fail:{num_failed}\n'
-
-
-final_report = ''
-final_report += check('C/testcases/CWE369_Divide_by_Zero/s*/*_int_*.c', 'verificationDivByZero')
-final_report += check('C/testcases/CWE476_*/*.c', 'verificationNullPointerDereference')
-
-print(final_report)
-
-assert final_report == ('CWE369 ok:456, fail:0\n'
-                        'CWE476 ok:234, fail:36\n')
-
diff --git a/tools/CMakeLists.txt b/tools/CMakeLists.txt
new file mode 100644
index 00000000000..6dd119c6e8f
--- /dev/null
+++ b/tools/CMakeLists.txt
@@ -0,0 +1,2 @@
+add_subdirectory(dmake)
+add_subdirectory(triage)
\ No newline at end of file
diff --git a/tools/MT-Unsafe.py b/tools/MT-Unsafe.py
new file mode 100755
index 00000000000..965a6261db8
--- /dev/null
+++ b/tools/MT-Unsafe.py
@@ -0,0 +1,201 @@
+#!/usr/bin/python -u
+
+"""
+Generates a list of MT unsafe symbols for a cppcheck addon.
+
+The cppcheck addon threadsafety.py uses a list
+   id_MTunsafe_full
+of symbols - mostly functions - which are not multi-thread safe.
+
+This script generates such a list by parsing (the troff source of)
+a man page, or a directory tree of man pages,
+looking for the attributes described in 'man 7 attributes'.
+
+Typical example use:
+  MT-Unsafe.py /usr/share/man/man3
+The output must then be merged into the threadsafety.py addon.
+"""
+
+import gzip
+import os
+import re
+import sys
+
+debug = 0
+verbose = 0
+
+unsafe_apis = set()
+unsafe_types = set()
+
+
+def dprint(level, fmt, varlist=()):
+    """Print messages for someone debugging this script. This wraps print()."""
+    if debug < level:
+        return
+    if varlist:
+        print(fmt % varlist, file=sys.stderr)
+    else:
+        print(fmt, file=sys.stderr)
+
+
+def vprint(level, fmt, varlist=()):
+    """Print messages for someone running this script. This wraps print()."""
+    if verbose < level:
+        return
+    if varlist:
+        print(fmt % varlist, file=sys.stderr)
+    else:
+        print(fmt, file=sys.stderr)
+
+
+def man_search(manpage):
+    """Search one manpage for tokens  in the attributes table."""
+    vprint(1, '-- %s --' % (manpage))
+
+    try:
+        if manpage.endswith('.gz'):
+            MANPAGE = gzip.open(manpage, 'r')
+        else:
+            MANPAGE = open(manpage, 'r')
+    except OSError as filename:
+        print('cannot open %s' % filename, file=sys.stderr)
+        return  # None, None
+
+    vprint(1, '%s opened' % (manpage))
+
+    TSmatch = None
+    for lineread in MANPAGE:
+        vprint(4, 'type %s', type(lineread))
+        lineread = str(lineread)
+        vprint(3, '--%s' % lineread)
+        # TSmatch = lineread.startswith('.TS')
+        TSmatch = re.search('\\.TS', lineread)
+        if TSmatch:
+            dprint(1, '%s:\treached .TS' % (manpage))
+            break
+
+    # dprint(2, '%s', lineread)
+
+    if not TSmatch:
+        dprint(1, '.TS not found in %s' % manpage)
+        return  # None, None
+
+    vprint(1, 'Started reading the attribute table')
+
+    apis = set()
+    for lineread in MANPAGE:
+        lineread = str(lineread)
+        dprint(2, '%s' % (lineread))
+        if 'MT-Safe' in lineread:
+            vprint(1, 'clearing MT-Safe %s', lineread)
+            apis.clear()
+
+        res = re.search(r'\.BR\s+(\w+)\s', lineread)
+        # vprint(1, '%s for %s' % (res, lineread))
+        if res:
+            apis.add(res.group(1))
+            dprint(1, 'found api %s in %s' % (res.group(1), lineread))
+            continue
+
+        if 'MT-Unsafe' in lineread:
+            resUnsafe = re.search("MT-Unsafe\\s+(.*)(\\n\'|$)", lineread)
+
+            if resUnsafe:
+                values = resUnsafe.group(1)
+                dprint(1, 'a %s' % values)
+                values = re.sub(r'\\n\'$', '', values)
+                #
+                values = values.split(' ')
+                dprint(1, 'values %s' % list(values))
+                for val in values:
+                    unsafe_types.add(val)
+
+            # dprint(1, 'pushing ', list(apis), sep=',')
+            dprint(1, 'new apis %s' % list(apis))
+            for api in apis:
+                unsafe_apis.add(api)
+                continue
+
+        #  if lineread.startswith('.TE'):
+        if re.search('.TE', lineread):
+            dprint(1, '%s:\treached .TE' % (manpage))
+            break
+
+    dprint(1, 'Finished reading the attribute table')
+
+    MANPAGE.close()
+
+    return  # list(unsafe_types), list(unsafe_apis)
+
+
+def do_man_page(manpage):
+    """Wrap man_search(), with logging."""
+    dprint(1, 'do_man_page(%s)' % (manpage))
+    man_search(manpage)
+    if unsafe_types:
+        dprint(1, '%d new types in %s' % (len(unsafe_types), manpage))
+    else:
+        dprint(1, 'No new types in %s' % (manpage))
+
+    if unsafe_apis:
+        dprint(1, '%d unsafe_apis in %s' % (len(unsafe_apis), manpage))
+    else:
+        dprint(1, 'No new apis in %s' % (manpage))
+
+
+def do_man_dir(directory):
+    """Recursively process a directory of man-pages."""
+    dprint(1, 'do_man_dir(%s)' % (directory))
+    if os.path.isfile(directory):
+        do_man_page(directory)
+        return
+
+    for path, _, files in os.walk(directory):
+        for file in files:
+            dprint(2, 'calling do_man_page(%s)' % (
+                os.path.join(path, file)))
+            do_man_page(os.path.join(path, file))
+
+
+manpages = set()
+for arg in sys.argv[1:]:
+    if arg.startswith('-'):
+        if re.match('^-+debug', arg):
+            debug = debug+1
+            dprint(1, 'debug %d' % debug)
+            continue
+    else:
+        if os.access(arg, os.R_OK):
+            manpages.add(arg)
+            dprint(1, 'manpages+= %s' % (arg))
+        else:
+            dprint(0, 'skipping arg - not readable')
+
+dprint(2, 'manpages: %s' % manpages)
+
+
+for manpage in manpages:
+    do_man_dir(manpage)
+
+
+dprint(1, '-----------------------------------------\n')
+dprint(1, '%d unsafe_types' % len(unsafe_types))
+dprint(1, '%d unsafe_apis' % len(unsafe_apis))
+dprint(1, 'type: %s' % type(unsafe_apis))
+
+print('{\n    # Types marked MT-Unsafe')
+# unsafe_types is not the whole of the list,
+# so the last item *is* followed by a comma:
+for u_type in sorted(unsafe_types):
+    print("    '%s'," % u_type)
+
+
+print('    # APIs marked MT-Unsafe')
+# unsafe_apis completes the list,
+# so we ought to remove the last comma.
+for u_api in sorted(unsafe_apis):
+    print("    '%s'," % u_api)
+
+print('}\n')
+
+# print(sorted(unsafe_apis), sep=',\n  ', end='\n}\n')
diff --git a/tools/astyle_client.py b/tools/astyle_client.py
deleted file mode 100644
index 526df5d596a..00000000000
--- a/tools/astyle_client.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import os
-import socket
-import sys
-import time
-
-def receive_data(conn):
-    data = ''
-    for t in range(1000):
-        d = conn.recv(8196)
-        if d:
-            data += d
-            if data.endswith('\nDONE'):
-                return data[:-5]
-        time.sleep(0.01)
-    return ''
-
-
-def astyle(server_address, code):
-    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    try:
-        sock.connect(server_address)
-        sock.sendall(code + '\nDONE')
-        return receive_data(sock)
-    except socket.error as err:
-        print('Network error: ' + str(err))
-    sock.close()
-    return None
-
-if __name__ == "__main__":
-    server_address = ('cppcheck.osuosl.org', 18000)
-
-    for filename in sorted(sys.argv[1:]):
-        if not (filename.endswith('.cpp') or filename.endswith('.h')):
-            continue
-
-        f = open(filename, 'rt')
-        code = f.read()
-        f.close()
-        formatted_code = astyle(server_address, code)
-        if formatted_code is None:
-            break
-        if code != formatted_code:
-            print('Changed: ' + filename)
-            f = open(filename, 'wt')
-            f.write(formatted_code)
-            f.close()
-        else:
-            print('Unchanged: ' + filename)
-
diff --git a/tools/astyle_server.py b/tools/astyle_server.py
deleted file mode 100644
index a7aa1b313f6..00000000000
--- a/tools/astyle_server.py
+++ /dev/null
@@ -1,44 +0,0 @@
-
-import logging
-import socket
-import subprocess
-
-from astyle_client import receive_data
-
-logger = logging.getLogger()
-
-
-def server(port):
-    socket.setdefaulttimeout(30)
-    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-    server_address = ('', port)
-    sock.bind(server_address)
-
-    sock.listen(1)
-
-    while True:
-        # Wait for a connection
-        connection, client_address = sock.accept()
-
-        # Read data from client
-        try:
-            data = receive_data(connection)
-        except socket.error:
-            connection.close()
-            continue
-
-        # Format
-        process = subprocess.Popen(['astyle', '--options=.astylerc'],
-                                   stdin=subprocess.PIPE,
-                                   stdout=subprocess.PIPE,
-                                   stderr=subprocess.PIPE)
-        comm = process.communicate(input=data)
-
-        connection.sendall(comm[0] + '\nDONE')
-        connection.close()
-
-
-if __name__ == "__main__":
-    server(port=18000)
-
diff --git a/tools/bisect/README.md b/tools/bisect/README.md
new file mode 100644
index 00000000000..79faa951cdc
--- /dev/null
+++ b/tools/bisect/README.md
@@ -0,0 +1,164 @@
+# Bisecting
+
+`bisect.sh` is a script to bisect regressions in Cppcheck utilizing `git-bisect`.
+
+To learn more about bisecting please refer to https://git-scm.com/docs/git-bisect. 
+
+## Command
+
+```
+./bisect.sh <hash-good> <hash-bad> "<cppcheck-options>" "[expected]"
+```
+
+`hash-good` the latest known good commit hash or tag<br/>
+`hash-bad` the earliest known bad commit hash or tag<br/>
+`cppcheck-options` the options for the Cppcheck invocation<br/>
+`expected` (optional) a string that is expected in the output; when provided it will be used instead of the exitcode
+
+If possible use `main` as the function to test with, since it won't emit an `unusedFunction` warning.
+
+## Bisecting result regressions
+
+Results regressions are being bisected based on the `--error-exitcode=` result.
+
+If nothing is found the result will be `0` and it is treated as a _good_ commit.<br/>
+If a finding occurs the result will be `1` which is treated as a _bad_ commit.<br/>
+If a crash occurs it is treated as a _bad_ commit.
+
+You can also bisect based on expected output via the `expected` parameter.
+
+If the given string is found in the output it is treated as a _good_ commit.<br/>
+If the given string is _not_ found in the output it is treated as a _bad_ commit.<br/>
+If a crash occurs it is treated as a _bad_ commit.
+
+### False positive
+
+Provide a code sample which will trigger a single(!) false positive only. Trying to bisect multiple issues at the same time will most likely result in an incorrect result (see below).
+
+```cpp
+// cppcheck-suppress unusedFunction
+static void f()
+{
+    <code triggering FP>
+}
+```
+
+```
+./bisect.sh <hash-good> <hash-bad> "<cppcheck-options>"
+```
+
+After the bisecting check the output to make sure that only expected false positive and no additional finding was reported for the _bad_ commits. Any other finding will also cause the commit to be marked as _bad_ leading to an incorrect result.  
+
+### False negative
+
+#### Via suppression
+
+Provide a code sample which will trigger a `unmatchedSuppression`.
+
+```cpp
+// cppcheck-suppress unusedFunction
+static void f()
+{
+    // cppcheck-suppress unreadVariable
+    int i;
+}
+```
+
+```
+./bisect.sh <hash-good> <hash-bad> "<cppcheck-options>"
+```
+
+#### Via output
+
+```cpp
+static void f()
+{
+    int i;
+}
+```
+
+Provide the expected error ID (`unreadVariable`) as the `expected` parameter.
+
+```
+./bisect.sh <hash-good> <hash-bad> "<cppcheck-options>" "unreadVariable"
+```
+
+## Bisecting scan time regressions
+
+It is also possible to bisect for a regression in scan time.
+
+This is done by determining the time it took for the "good" commit to finish and setting a timeout twice that size for the calls to determine the "bad" commit.
+
+To bisect these kinds of regressions you currently need to adjust the `bisect.sh` script and set the `hang` variable to appropriate value:<br/>
+`1` - find the commit which started the hang<br/>
+`2` - find the commit which resolved the hang<br/>
+
+# Bisecting crashes
+
+To bisect when a crash was introduced just do the same as you would for a regular error.
+
+But if you want to find the commit which fixes a crash you need to add `-j2` to the options so the crash will generate an error instead of terminating the process and check for the expected string `crashed`.
+
+```
+./bisect.sh <hash-good> <hash-bad> "<cppcheck-options> -j2" "crashed"
+```
+
+### General notes
+
+As we are currently using the process exitcode to pass the elapsed time to the script it will not work properly with vey long runtime (>= 255 seconds) as it will overflow.
+
+In case the run-time before the regression was very short (<= 1 second) you might need to adjust the `elapsed_time` variable in `bisect.sh` to a higher value to avoid potential false positives.
+This might also be necessary to determine one of multiple regressions in the commit range. 
+
+After the bisect finished you should take a look at the output and make sure the elpased time of the respective commit looks as expected.
+
+### daca@home notes
+
+We use daca@home to track differences in scan time. An overview of regressions in scan time can be found at http://cppcheck1.osuosl.org:8000/time_gt.html.
+
+If the overall scan time regressed, then you need to specify the whole folder.
+
+If a timeout (potential hang) was introduced, then you can simply specify the file from `error: Internal error: Child process crashed with signal 15 [cppcheckError]`.
+
+## Notes
+
+### Bisecting daca@home issues
+
+You need to download the archive as specified by the second line in the output and extract it.
+
+Use the following data as respective parameters:
+
+`hash-good` the latest tagged release - the second value from the `cppcheck:` line<br/>
+`hash-bad` the commit hash from the `head-info:` line<br/>
+`cppcheck-options` the `cppcheck-options:` line and the path to the folder/file to scan<br/>
+
+### Known compilation issues:
+
+- 2.5 and before can only be built with GCC<=10 because of missing includes caused by cleanups within the standard headers. You need to specify `CXX=g++-10`.
+- 1.88 and 1.89 cannot be compiled:
+```
+make: python: No such file or directory
+```
+RESOLVED: a hot-patch is applied before compilation.
+- 1.39 to 1.49 (possibly more versions - 1.54 and up work) cannot be compiled:
+```
+lib/mathlib.cpp:70:42: error: invalid conversion from ‘char’ to ‘char**’ [-fpermissive]
+   70 |         return std::strtoul(str.c_str(), '\0', 16);
+      |                                          ^~~~
+      |                                          |
+      |                                          char
+```
+- some commits between 2.0 and 2.2 cannot be compiled:
+```
+cli/cppcheckexecutor.cpp:333:22: error: size of array ‘mytstack’ is not an integral constant-expression
+  333 | static char mytstack[MYSTACKSIZE]= {0}; // alternative stack for signal handler
+  |                      ^~~~~~~~~~~
+```
+RESOLVED: a hot-patch is applied before compilation.
+- some commits between 1.54 and 1.55 cannot be compiled:
+```
+lib/preprocessor.cpp:2103:5: error: ‘errorLogger’ was not declared in this scope; did you mean ‘_errorLogger’?
+2103 |     errorLogger->reportInfo(errmsg);
+|     ^~~~~~~~~~~
+|     _errorLogger
+```
diff --git a/tools/bisect/bisect.sh b/tools/bisect/bisect.sh
new file mode 100644
index 00000000000..cf0d4cd5b96
--- /dev/null
+++ b/tools/bisect/bisect.sh
@@ -0,0 +1,99 @@
+#!/bin/sh
+
+# TODO: set -e
+set -x
+
+# TODO: check parameters
+hash_good=$1
+hash_bad=$2
+options=$3
+expected=$4
+
+# TODO: verify "good" commit happened before "bad" commit
+
+# 0 - regular result based bisect
+# 1 - find commit which started hang
+# 2 - find commit which resolved hang
+hang=0
+
+script_dir="$(dirname "$(realpath "$0")")"
+
+# TODO: make configurable
+bisect_dir=~/.bisect
+
+mkdir -p "$bisect_dir" || exit 1
+
+cd "$bisect_dir" || exit 1
+
+if [ ! -d 'cppcheck' ]; then
+  git clone https://github.com/danmar/cppcheck.git || exit 1
+fi
+
+bisect_repo_dir="$bisect_dir/cppcheck"
+
+cd $bisect_repo_dir || exit 1
+
+git fetch --all --tags || exit 1
+
+# clean up in case we previously exited prematurely
+git restore . || exit 1
+git clean -df || exit 1
+
+# reset potentially unfinished bisect - also reverts to 'main' branch
+git bisect reset || exit 1
+
+# update `main` branch
+git pull || exit 1
+
+# TODO: filter addons, cfg and platforms based on the options
+# limit to paths which actually affect the analysis
+git bisect start -- Makefile 'addons/*.py' 'cfg/*.cfg' 'cli/*.cpp' 'cli/*.h' 'externals/**/*.cpp' 'externals/**/*.h' 'lib/*.cpp' 'lib/*.h' platforms tools/matchcompiler.py || exit 1
+
+git checkout "$hash_good" || exit 1
+
+if [ $hang -ne 0 ]; then
+  # TODO: exitcode overflow on 255
+  # get expected time from good commit
+  python3 "$script_dir/bisect_hang.py" "$bisect_dir" "$options"
+  elapsed_time=$?
+else
+  # verify the given commit is actually "good"
+  python3 "$script_dir/bisect_res.py" "$bisect_dir" "$options" "$expected"
+  # shellcheck disable=SC2181
+  if [ $? -ne 0 ]; then
+    echo "given good commit is not actually good"
+    exit 1
+  fi
+fi
+
+# mark commit as "good"
+git bisect good || exit 1
+
+git checkout "$hash_bad" || exit 1
+
+# verify the given commit is actually "bad"
+if [ $hang -ne 0 ]; then
+  python3 "$script_dir/bisect_hang.py" "$bisect_dir" "$options" $elapsed_time $hang
+else
+  python3 "$script_dir/bisect_res.py" "$bisect_dir" "$options" "$expected"
+fi
+
+if [ $? -ne 1 ]; then
+  echo "given bad commit is not actually bad"
+  exit 1
+fi
+
+# mark commit as "bad"
+git bisect bad || exit 1
+
+# perform the actual bisect
+if [ $hang -ne 0 ]; then
+  git bisect run python3 "$script_dir/bisect_hang.py" "$bisect_dir" "$options" $elapsed_time $hang || exit 1
+else
+  git bisect run python3 "$script_dir/bisect_res.py" "$bisect_dir" "$options" "$expected" || exit 1
+fi
+
+# show the bisect log
+git bisect log || exit 1
+
+git bisect reset || exit 1
\ No newline at end of file
diff --git a/tools/bisect/bisect_common.py b/tools/bisect/bisect_common.py
new file mode 100644
index 00000000000..10494d36512
--- /dev/null
+++ b/tools/bisect/bisect_common.py
@@ -0,0 +1,52 @@
+#!/usr/bin/env python
+import subprocess
+import os
+import shutil
+
+EC_GOOD = 0 # tells bisect that the commit is "good"
+EC_BAD = 1 # tells bisect that the commit is "bad"
+EC_SKIP = 125 # tells bisect to skip this commit since it cannot be tested
+
+def build_cppcheck(bisect_path):
+    commit_hash = subprocess.check_output(['git', 'rev-parse', '--short', 'HEAD']).decode('ascii').strip()
+    install_path = os.path.join(bisect_path, commit_hash)
+    cppcheck_path = os.path.join(install_path, 'cppcheck')
+    if os.path.exists(install_path):
+        print('binary for {} already exists'.format(commit_hash))
+        return cppcheck_path
+
+    bisect_repo_dir = os.path.join(bisect_path, 'cppcheck')
+
+    if os.path.exists(os.path.join(bisect_repo_dir, 'cppcheck')):
+        os.remove(os.path.join(bisect_repo_dir, 'cppcheck'))
+
+    # for versions 1.88 and 1.89
+    print('patching Makefile')
+    subprocess.check_call(['sed', '-i', 's/shell python /shell python3 /g', os.path.join(bisect_repo_dir, 'Makefile')])
+
+    # for versions between 2.0 and 2.2
+    print('patching cli/cppcheckexecutor.cpp')
+    subprocess.check_call(['sed', '-i', 's/SIGSTKSZ/32768/g', os.path.join(bisect_repo_dir, 'cli', 'cppcheckexecutor.cpp')])
+
+    # TODO: older versions do not build because of include changes in libstdc++ - check compiler version and try to use an earlier one
+    # TODO: make jobs configurable
+    # TODO: use "make install"?
+    # TODO: use CXXOPTS overrides to workaround compiling issues in older versions
+    print('building {}'.format(commit_hash))
+    # we always need to use CXXFLAGS because we need to support older versions
+    subprocess.check_call(['make', '-C', bisect_repo_dir, '-j6', 'MATCHCOMPILER=yes', 'CXXFLAGS=-O2 -w -pipe', '-s'])
+
+    # TODO: remove folder if installation failed
+    print('installing {}'.format(commit_hash))
+    os.mkdir(install_path)
+    if os.path.exists(os.path.join(bisect_repo_dir, 'cfg')):
+        shutil.copytree(os.path.join(bisect_repo_dir, 'cfg'), os.path.join(install_path, 'cfg'))
+    if os.path.exists(os.path.join(bisect_repo_dir, 'platforms')):
+        shutil.copytree(os.path.join(bisect_repo_dir, 'platforms'), os.path.join(install_path, 'platforms'))
+    shutil.copy(os.path.join(bisect_repo_dir, 'cppcheck'), cppcheck_path)
+
+    # reset the patches so the subsequent checkout works
+    print('resetting repo')
+    subprocess.check_call(['git', 'reset', '--hard'])
+
+    return cppcheck_path
\ No newline at end of file
diff --git a/tools/bisect/bisect_hang.py b/tools/bisect/bisect_hang.py
new file mode 100644
index 00000000000..ad0497396c9
--- /dev/null
+++ b/tools/bisect/bisect_hang.py
@@ -0,0 +1,79 @@
+#!/usr/bin/env python
+import time
+import sys
+
+from bisect_common import *
+
+# TODO: detect missing file
+def run(cppcheck_path, options, elapsed_time=None):
+    timeout = None
+    if elapsed_time:
+        timeout = elapsed_time * 2
+    cmd = options.split()
+    cmd.insert(0, cppcheck_path)
+    print('running {}'.format(cppcheck_path))
+    with subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) as p:
+        try:
+            p.communicate(timeout=timeout)
+            if p.returncode != 0:
+                print('error')
+                return None
+            print('done')
+        except subprocess.TimeoutExpired:
+            print('timeout')
+            p.kill()
+            p.communicate()
+            return False
+
+    return True
+
+
+# TODO: check arguments
+bisect_path = sys.argv[1]
+options = sys.argv[2]
+if '--error-exitcode=0' not in options:
+    options += ' --error-exitcode=0'
+if len(sys.argv) >= 4:
+    elapsed_time = float(sys.argv[3])
+else:
+    elapsed_time = None
+if len(sys.argv) == 5:
+    invert = sys.argv[4] == "2"
+else:
+    invert = False
+
+try:
+    cppcheck_path = build_cppcheck(bisect_path)
+except Exception as e:
+    # TODO: how to persist this so we don't keep compiling these
+    print(e)
+    sys.exit(EC_SKIP)
+
+if not elapsed_time:
+    t = time.perf_counter()
+    # TODO: handle error result
+    run(cppcheck_path, options)
+    elapsed_time = time.perf_counter() - t
+    print('elapsed_time: {}'.format(elapsed_time))
+    # TODO: write to stdout and redirect all all printing to stderr
+    sys.exit(round(elapsed_time + .5))  # return the time
+
+t = time.perf_counter()
+run_res = run(cppcheck_path, options, elapsed_time)
+run_time = time.perf_counter() - t
+
+if not elapsed_time:
+    # TODO: handle error result
+    print('elapsed_time: {}'.format(run_time))
+    # TODO: write to stdout and redirect all printing to stderr
+    sys.exit(round(run_time + .5))  # return the time
+
+if run_res is None:
+    sys.exit(EC_SKIP)  # error occurred
+
+if not run_res:
+    sys.exit(EC_BAD if not invert else EC_GOOD)  # timeout occurred
+
+print('run_time: {}'.format(run_time))
+
+sys.exit(EC_GOOD if not invert else EC_BAD)  # no timeout
diff --git a/tools/bisect/bisect_res.py b/tools/bisect/bisect_res.py
new file mode 100644
index 00000000000..68550d00815
--- /dev/null
+++ b/tools/bisect/bisect_res.py
@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+import sys
+
+from bisect_common import *
+
+# TODO: detect missing file
+def run(cppcheck_path, options):
+    cmd = options.split()
+    cmd.insert(0, cppcheck_path)
+    print('running {}'.format(cppcheck_path))
+    with subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True) as p:
+        stdout, stderr = p.communicate()
+        rc = p.returncode
+    # only 0 and 1 are well-defined in this case
+    if rc > 1:
+        print('error')
+        return None, None, None
+    # signals are reported as negative exitcode (e.g. SIGSEGV -> -11)
+    if rc < 0:
+        print('crash')
+        return rc, stderr, stdout
+    print('done')
+    return rc, stderr, stdout
+
+
+# TODO: check arguments
+bisect_path = sys.argv[1]
+options = sys.argv[2]
+expected = None
+if len(sys.argv) == 4:
+    expected = sys.argv[3]
+if len(expected) == 0:
+    expected = None
+if expected is None:
+    if '--error-exitcode=1' not in options:
+        options += ' --error-exitcode=1'
+else:
+    if '--error-exitcode=0' not in options:
+        options += ' --error-exitcode=0'
+
+try:
+    cppcheck_path = build_cppcheck(bisect_path)
+except Exception as e:
+    # TODO: how to persist this so we don't keep compiling these
+    print(e)
+    sys.exit(EC_SKIP)
+
+run_ec, run_stderr, run_stdout = run(cppcheck_path, options)
+
+if expected is None:
+    print(run_ec)
+print(run_stdout)
+print(run_stderr)
+
+# if no ec is set we encountered an unexpected error
+if run_ec is None:
+    sys.exit(EC_SKIP)  # error occurred
+elif run_ec < 0:
+    sys.exit(EC_BAD) # crash occurred
+
+# check output for expected string
+if expected is not None:
+    if (expected not in run_stderr) and (expected not in run_stdout):
+        sys.exit(EC_BAD)  # output not found occurred
+
+    sys.exit(EC_GOOD)  # output found
+
+sys.exit(run_ec) # return the elapsed time - not a result for bisect
diff --git a/tools/check-errorids.sh b/tools/check-errorids.sh
new file mode 100755
index 00000000000..8bd343411cc
--- /dev/null
+++ b/tools/check-errorids.sh
@@ -0,0 +1,31 @@
+#!/bin/bash
+
+#set -x
+
+SCRIPT_DIR="$(dirname "$(realpath "$0")")"
+
+# TODO: exclude testinternal.cpp
+echo 'no --errorlist entry:'
+grep -h -o -P '\[[a-zA-Z0-9_]+\]\\n\"' $SCRIPT_DIR/../test/*.cpp | tr -d '[]\"' | sed 's/\\n$//' | sort -u | \
+while read -r id; do
+  if [ ${#id} -lt 4 ]; then
+    continue
+  fi
+  $SCRIPT_DIR/../cppcheck --errorlist | grep "id=\"$id\"" > /dev/null
+  # shellcheck disable=SC2181
+  if [ $? -ne 0 ]; then
+    echo $id
+  fi
+done
+
+echo ''
+
+echo 'no test coverage:'
+$SCRIPT_DIR/../cppcheck --errorlist | grep -h -o -P 'id=\"[a-zA-Z0-9_]*\"' | sed 's/\id=//' | tr -d '\"' | sort -u | \
+while read -r id; do
+  grep -h -o -P "\[$id\][\\\\n]*\"" $SCRIPT_DIR/../test/*.cpp > /dev/null
+  # shellcheck disable=SC2181
+  if [ $? -ne 0 ]; then
+    echo $id
+  fi
+done
\ No newline at end of file
diff --git a/tools/ci.py b/tools/ci.py
deleted file mode 100644
index 6d2b8cfc471..00000000000
--- a/tools/ci.py
+++ /dev/null
@@ -1,90 +0,0 @@
-#!/usr/bin/env python
-
-# continuous integration
-# build daily reports (doxygen,coverage,etc)
-
-import datetime
-import time
-import subprocess
-import pexpect
-import glob
-import sys
-
-
-# Upload file to sourceforge web server using scp
-def upload(file_to_upload, destination):
-    try:
-        password = sys.argv[1]
-        child = pexpect.spawn(
-            'scp ' + file_to_upload + ' danielmarjamaki,cppcheck@web.sourceforge.net:' + destination)
-        # child.expect(
-        #    'danielmarjamaki,cppcheck@web.sourceforge.net\'s password:')
-        child.expect('Password:')
-        child.sendline(password)
-        child.interact()
-    except (IOError, OSError, pexpect.TIMEOUT):
-        pass
-
-
-# git push
-def gitpush():
-    try:
-        password = sys.argv[1]
-        child = pexpect.spawn('git push')
-        child.expect("Enter passphrase for key '/home/daniel/.ssh/id_rsa':")
-        child.sendline(password)
-        child.interact()
-    except (IOError, OSError, pexpect.TIMEOUT):
-        pass
-
-
-def iconv(filename):
-    p = subprocess.Popen(['file', '-i', filename],
-                         stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-    comm = p.communicate()
-    if 'charset=iso-8859-1' in comm[0]:
-        subprocess.call(
-            ["iconv", filename, "--from=ISO-8859-1", "--to=UTF-8", "-o", filename])
-
-
-# Generate daily webreport
-def generate_webreport():
-    for filename in glob.glob('*/*.cpp'):
-        iconv(filename)
-    subprocess.call(
-        ["git", "commit", "-a", "-m", '"automatic conversion from iso-8859-1 formatting to utf-8"'])
-    gitpush()
-
-    subprocess.call(["rm", "-rf", "devinfo"])
-    subprocess.call(['nice', "./webreport.sh"])
-    upload('-r devinfo', 'htdocs/')
-    subprocess.call(["make", "clean"])
-    subprocess.call(["rm", "-rf", "devinfo"])
-
-
-# Perform a git pull.
-def gitpull():
-    try:
-        password = sys.argv[1]
-        child = pexpect.spawn('git pull')
-        child.expect("Enter passphrase for key '/home/daniel/.ssh/id_rsa':")
-        child.sendline(password)
-        child.expect('Already up-to-date.')
-        child.interact()
-
-    except (IOError, OSError, pexpect.TIMEOUT):
-        pass
-    except pexpect.EOF:
-        return True
-
-    return False
-
-
-t0 = None
-while True:
-    if datetime.date.today() != t0:
-        print("generate daily reports")
-        t0 = datetime.date.today()
-        gitpull()
-        generate_webreport()
-    time.sleep(60)
diff --git a/tools/clang-ast.cpp b/tools/clang-ast.cpp
deleted file mode 100644
index 4245f2671e4..00000000000
--- a/tools/clang-ast.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-// Dump the AST for a file.
-//
-// Compile with:
-// g++ `llvm-config-3.8 --cxxflags --ldflags` -lclang -o clang-ast clang-ast.cpp
-
-#include <iostream>
-#include <cstdlib>
-#include <clang-c/Index.h>
-
-std::ostream& operator<<(std::ostream& stream, const CXString& str)
-{
-    stream << clang_getCString(str);
-    clang_disposeString(str);
-    return stream;
-}
-
-int main(int argc, char **argv)
-{
-    if (argc == 1) {
-        std::cerr << "No source file\n";
-        return EXIT_FAILURE;
-    }
-
-    const char *argv1[] = { argv[0], "-std=c++11" };
-
-    CXIndex index = clang_createIndex(0, 0);
-    CXTranslationUnit unit = clang_parseTranslationUnit(
-                                 index,
-                                 argv[1], argv1, sizeof(argv1) / sizeof(argv1[0]),
-                                 nullptr, 0,
-                                 CXTranslationUnit_None);
-    if (unit == nullptr) {
-        std::cerr << "Unable to parse translation unit. Quitting." << std::endl;
-        return EXIT_FAILURE;
-    }
-
-    std::cout << "<?xml version=\"1.0\"?>\n"
-              << "<clang-ast>\n";
-
-    CXCursor cursor = clang_getTranslationUnitCursor(unit);
-    clang_visitChildren(
-        cursor,
-    [](CXCursor c, CXCursor parent, CXClientData client_data) {
-        switch (clang_getCursorKind(c)) {
-        case CXCursor_FunctionDecl:
-        case CXCursor_Constructor:
-        case CXCursor_Destructor:
-        case CXCursor_CXXMethod: {
-            CXSourceLocation location = clang_getCursorLocation(c);
-            CXString filename;
-            unsigned int line, column;
-            clang_getPresumedLocation(location, &filename, &line, &column);
-
-            std::cout << "<Function" /* << clang_getCursorKindSpelling(clang_getCursorKind(c)) */
-                      << " name=\"" << clang_getCursorSpelling(c) << '\"'
-                      << " filename=\"" << filename << '\"'
-                      << " line=\"" << line << '\"'
-//                        << " column=\"" << column << '\"'
-                      << "/>\n";
-            break;
-        }
-
-        case CXCursor_CallExpr: {
-            CXSourceLocation location = clang_getCursorLocation(c);
-            CXString filename;
-            unsigned int line, column;
-            clang_getPresumedLocation(location, &filename, &line, &column);
-
-            CXCursor ref = clang_getCursorReferenced(c);
-            CXSourceLocation locationRef = clang_getCursorLocation(ref);
-            CXString filenameRef;
-            unsigned int lineRef, columnRef;
-            clang_getPresumedLocation(locationRef, &filenameRef, &lineRef, &columnRef);
-
-            std::cout << "<CallExpr"
-                      << " name=\"" << clang_getCursorSpelling(c) << '\"'
-                      << " filename=\"" << filename << '\"'
-                      << " line=\"" << line << '\"'
-//                        << " column=\"" << column << '\"'
-                      << " filenameRef=\"" << filenameRef << '\"'
-                      << " lineRef=\"" << lineRef << '\"'
-                      << "/>\n";
-            break;
-        }
-        break;
-        default:
-            //std::cout << "<" << clang_getCursorKindSpelling(clang_getCursorKind(c)) << " kind=\"" << clang_getCursorKind(c) << "\"/>\n";
-            break;
-        };
-
-        return CXChildVisit_Recurse;
-    },
-    nullptr);
-
-    std::cout << "</clang-ast>\n";
-
-    clang_disposeTranslationUnit(unit);
-    clang_disposeIndex(index);
-
-    return EXIT_SUCCESS;
-}
diff --git a/tools/compare-ast-clang-and-cppcheck.py b/tools/compare-ast-clang-and-cppcheck.py
deleted file mode 100644
index ad8d007c327..00000000000
--- a/tools/compare-ast-clang-and-cppcheck.py
+++ /dev/null
@@ -1,88 +0,0 @@
-#!/usr/bin/env python
-#
-# Compare the AST of Cppcheck and Clang
-#
-# Example usage:
-# cd cppcheck/tools
-# g++ `llvm-config-3.8 --cxxflags --ldflags` -lclang -o clang-ast clang-ast.cpp
-# python compare-ast-clang-and-cppcheck.py lib/token.cpp
-#
-# If you get such output:
-# - <Function...>
-# Then that means there is a missing function in the Cppcheck SymbolDatabase
-#
-import subprocess
-import sys
-sys.path.insert(0, '../addons')
-import cppcheckdata
-
-CLANG_AST = './clang-ast'
-CPPCHECK = '../cppcheck'
-
-def clang_ast(sourcefile):
-    p = subprocess.Popen([CLANG_AST,sourcefile], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    comm = p.communicate()
-    ret = []
-    for line in comm[0].split('\n'):
-        while len(line)>1 and line[-1] in ' \r\n':
-            line = line[:-1]
-        if line.find('/usr/') > 0:
-            continue
-        if line.startswith('<Function'):
-            ret.append(line)
-    ret.sort()
-    return ret
-
-
-def cppcheck_ast(sourcefile):
-    subprocess.call([CPPCHECK, '--dump', '--max-configs=1', sourcefile])
-    data = cppcheckdata.parsedump(sourcefile + '.dump')
-    cfg = data.configurations[0]
-    ret = []
-    for func in cfg.functions:
-        name = func.name
-        if func.type == 'Destructor':
-            name = '~' + name
-        s = '<Function'
-        s = s + ' name="' + name + '"'
-        s = s + ' filename="' + func.tokenDef.file + '"'
-        s = s + ' line="' + str(func.tokenDef.linenr) + '"'
-        s = s + '/>'
-        ret.append(s)
-    for scope in cfg.scopes:
-        if scope.type != 'Function':
-            continue
-        argStart = scope.bodyStart
-        while argStart and argStart.str != '(':
-            argStart = argStart.previous
-        s = '<Function'
-        s = s + ' name="' + scope.className + '"'
-        s = s + ' filename="' + argStart.file + '"'
-        s = s + ' line="' + str(argStart.linenr) + '"'
-        s = s + '/>'
-        if s not in ret:
-            ret.append(s)
-    ret.sort()
-    return ret
-
-print('Clang AST...')
-ast1 = clang_ast(sys.argv[1])
-print('Cppcheck AST...')
-ast2 = cppcheck_ast(sys.argv[1])
-
-#for func in ast2:
-#    print(func)
-
-print('Compare...')
-numberOfMissing = 0
-numberOfExtra = 0
-for func in ast1:
-    if func not in ast2:
-        numberOfMissing = numberOfMissing + 1
-        print('Missing Function ' + func)
-for func in ast2:
-    if func not in ast1:
-        numberOfExtra = numberOfExtra + 1
-        print('Extra Function ' + func)
-print('Number of missing functions: ' + str(numberOfMissing))
-print('Number of extra functions: ' + str(numberOfExtra) + ' (clang AST currently only contains FunctionDecl and CXXMethod)')
diff --git a/tools/compare-valueflow-options.py b/tools/compare-valueflow-options.py
new file mode 100755
index 00000000000..11b7cf87d42
--- /dev/null
+++ b/tools/compare-valueflow-options.py
@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+
+# Compare results and timings of different valueflow options
+# Example usage:
+# cd ~/cppcheck && make CXXOPTS=-O2 MATCHCOMPILER=yes
+# python3 compare-valueflow-options.py --cppcheck-path=~/cppcheck --packages-path=~/daca2-packages
+
+import donate_cpu_lib as lib
+import argparse
+import glob
+import os
+import re
+import sys
+import random
+
+
+# Do not report execution times below this limit, short execution time measurements are flaky
+TIME_LIMIT = 2
+
+
+def format_float(a, b=1):
+    if a > 0 and b > 0:
+        return '{:.2f}'.format(a / b)
+    return 'N/A'
+
+
+def count_errors(errout:str, c:set):
+    for line in errout.split('\n'):
+        if not line.endswith(']'):
+            continue
+        res = re.match(r'^[^:]+:[0-9]+:[0-9]+: (error|warning|style|portability|performance):.*\[([a-zA-Z0-9_\-]+)\]$', line)
+        if res is None:
+            print('No warning? ' + line)
+            continue
+        severity = res.group(1)
+        c[severity] = c.get(severity, 0) + 1
+        error_id = res.group(2)
+        c[error_id] = c.get(error_id, 0) + 1
+
+
+if __name__ == "__main__":
+    __my_script_name = os.path.splitext(os.path.basename(sys.argv[0]))[0]
+    __work_path = os.path.expanduser(os.path.join('~', 'cppcheck-' + __my_script_name + '-workfolder'))
+
+    parser = argparse.ArgumentParser(description='Compare --check-level=normal and --check-level=exhaustive output')
+    parser.add_argument('-j', default=1, type=int, help='Concurency execution threads')
+    parser.add_argument('--cppcheck-path', default=None, type=str, help='Path to Cppcheck binary, if not given then clone and compile')
+    package_group = parser.add_mutually_exclusive_group()
+    package_group.add_argument('-p', default=256, type=int, help='Count of packages to check')
+    package_group.add_argument('--packages', nargs='+', help='Check specific packages and then stop.')
+    package_group.add_argument('--packages-path', default=None, type=str, help='Check packages in path.')
+    parser.add_argument('-o', default='my_check_diff.log', help='Filename of result inside a working path dir')
+
+    language_group = parser.add_mutually_exclusive_group()
+    language_group.add_argument('--c-only', dest='c_only', help='Only process c packages', action='store_true')
+    language_group.add_argument('--cpp-only', dest='cpp_only', help='Only process c++ packages', action='store_true')
+    parser.add_argument('--work-path', '--work-path=', default=__work_path, type=str, help='Working directory for reference repo')
+    args = parser.parse_args()
+
+    print(args)
+
+    if not lib.check_requirements():
+        print("Error: Check requirements")
+        sys.exit(1)
+
+    work_path = os.path.abspath(args.work_path)
+    if not os.path.exists(work_path):
+        os.makedirs(work_path)
+
+    lib.set_jobs('-j' + str(args.j))
+
+    results_file = os.path.join(work_path, args.o)
+    summary_file = os.path.join(work_path, 'summary.log')
+
+    for f in (results_file, summary_file):
+        if os.path.exists(f):
+            os.remove(f)
+
+    opts = {'0': '--check-level=exhaustive --suppress=valueFlow*',
+            'it2': '--check-level=exhaustive --performance-valueflow-max-iterations=2 --suppress=valueFlow*',
+            'it1': '--check-level=exhaustive --performance-valueflow-max-iterations=1 --suppress=valueFlow*',
+            'if8': '--check-level=exhaustive --performance-valueflow-max-if-count=8 --suppress=valueFlow*'}
+
+    cppcheck_path = args.cppcheck_path
+
+    if cppcheck_path is None:
+        cppcheck_path = os.path.join(work_path, 'cppcheck')
+        try:
+            lib.clone_cppcheck(cppcheck_path, '')
+        except Exception as e:
+            print('Failed to clone Cppcheck repository ({}), retry later'.format(e))
+            sys.exit(1)
+
+        if not lib.compile_cppcheck(cppcheck_path):
+            print('Failed to compile Cppcheck')
+            sys.exit(1)
+
+    if args.packages_path:
+        # You can download packages using daca2-download.py
+        args.packages = glob.glob(os.path.join(args.packages_path, '*.tar.xz'))
+        args.p = len(args.packages)
+        packages_idxs = list(range(args.p))
+        random.shuffle(packages_idxs)
+    elif args.packages:
+        args.p = len(args.packages)
+        packages_idxs = []
+    else:
+        packages_count = lib.get_packages_count()
+        if not packages_count:
+            print("network or server might be temporarily down..")
+            sys.exit(1)
+
+        packages_idxs = list(range(packages_count))
+        random.shuffle(packages_idxs)
+
+    packages_processed = 0
+    summary_results = {}
+    for id in opts.keys():
+        summary_results[id] = {}
+
+    while (packages_processed < args.p and len(packages_idxs) > 0) or args.packages:
+        if args.packages:
+            package = args.packages.pop()
+        else:
+            package = lib.get_package(packages_idxs.pop())
+
+        if package.startswith('ftp://') or package.startswith('http://'):
+            tgz = lib.download_package(work_path, package, None)
+            if tgz is None:
+                print("No package downloaded")
+                continue
+        else:
+            print('Package: ' + package)
+            tgz = package
+
+        source_path, source_found = lib.unpack_package(work_path, tgz, c_only=args.c_only, cpp_only=args.cpp_only)
+        if not source_found:
+            print("No files to process")
+            continue
+
+        results0 = None
+        time0 = None
+
+        enable = 'style'
+        debug_warnings = False
+
+        libraries = lib.library_includes.get_libraries(source_path)
+
+        with open(results_file, 'at') as myfile:
+            myfile.write('package:' + package + '\n')
+            myfile.write('libraries:' + ','.join(libraries) +'\n')
+
+        for id, extra_args in opts.items():
+            print('scan:' + id)
+            c, errout, info, time, cppcheck_options, timing_info = lib.scan_package(cppcheck_path, source_path, libraries, enable=enable, extra_args=extra_args)
+            error_text = None
+            if c < 0:
+                if c == -101 and 'error: could not find or open any of the paths given.' in errout:
+                    # No sourcefile found (for example only headers present)
+                    error_text = f'{id} ERR no source file'
+                elif c == lib.RETURN_CODE_TIMEOUT:
+                    error_text = f'{id} timeout'
+                else:
+                    error_text = f'{id} crash code={c}'
+
+            with open(results_file, 'at') as myfile:
+                if error_text is not None:
+                    myfile.write(f'{error_text}\n')
+                else:
+                    results = {}
+                    count_errors(errout, results)
+                    count_errors(errout, summary_results[id])
+                    if results0 is None:
+                        results0 = results
+                        time0 = time
+                    else:
+                        for error_id, count in results0.items():
+                            current_count = results.get(error_id, 0)
+                            if count > current_count:
+                                myfile.write(f'{id}: FN {error_id}: {current_count} of {count}\n')
+                        if time > TIME_LIMIT or time0 > TIME_LIMIT:
+                            myfile.write(f'{id}: Time: %.1f\n' % time)
+                            time_factor = time / time0
+                            myfile.write(f'{id}: Timefactor: %.3f\n' % time_factor)
+
+        with open(summary_file, 'wt') as myfile:
+            all = {}
+            for id, c in summary_results.items():
+                for error_id, count in c.items():
+                    if error_id not in all:
+                        all[error_id] = {}
+                        for id2 in opts.keys():
+                            all[error_id][id2] = 0
+                    all[error_id][id] += count
+
+            for error_id, id_count in all.items():
+                myfile.write(f'{error_id}:')
+                for id, count in id_count.items():
+                    myfile.write(f' {id}:{count}')
+                myfile.write('\n')
+
+        packages_processed += 1
+        print(str(packages_processed) + ' of ' + str(args.p) + ' packages processed\n')
+
+    print('Result saved to: ' + results_file)
diff --git a/tools/compare.cs b/tools/compare.cs
index ad4c015d12c..3bc4d10b708 100644
--- a/tools/compare.cs
+++ b/tools/compare.cs
@@ -1,331 +1,331 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using System.IO;
-using System.Text.RegularExpressions;
-
-namespace difftool
-{
-    class Program
-    {
-        static private string FirstLine(string s)
-        {
-            int i = s.IndexOf('\n');
-            return i > 0 ? s.Substring(0, i) : s;
-        }
-
-        static private List<string> GetDiff(string[] s1, string[] s2)
-        {
-            List<string> ret = new List<string>();
-
-            int i2 = 0;
-            while (i2 < s2.Length && (s2[i2] == "" || !s2[i2].StartsWith("mozilla/")))
-                i2++;
-            for (int i1 = 0; i1 < s1.Length; ++i1)
-            {
-                if (s1[i1] == "" || !s1[i1].StartsWith("mozilla/"))
-                    continue;
-
-                if (i2 >= s2.Length)
-                {
-                    ret.Add(s1[i1]);
-                    continue;
-                }
-                if (FirstLine(s1[i1]) == FirstLine(s2[i2]))
-                {
-                    ++i2;
-                    continue;
-                }
-                for (int i3 = i2 + 1; i3 < i2 + 300 && i3 < s2.Length; ++i3)
-                {
-                    if (FirstLine(s1[i1]) == FirstLine(s2[i3]))
-                    {
-                        i2 = i3;
-                        break;
-                    }
-                }
-                if (FirstLine(s1[i1]) == FirstLine(s2[i2]))
-                {
-                    ++i2;
-                    continue;
-                }
-                ret.Add(s1[i1]);
-            }
-            return ret;
-        }
-
-        static private string TextToHtml(string s)
-        {
-            return s.Replace("&", "&amp;").Replace("<", "&lt;").Replace(">", "&gt;");
-        }
-
-        static Boolean IsNameChar(char c)
-        {
-            return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_';
-        }
-
-        // color theme:
-
-        // http://www.eclipsecolorthemes.org/?view=theme&id=47
-        /*
-        private const string backgroundColor = "1E1E1E";
-        private const string foregroundFont = "<font color=\"#E2E2E2\">";
-        private const string keywordFont = "<font color=\"#8DCBE2\">";
-        private const string numberFont = "<font color=\"#EAB882\">";
-        private const string stringFont = "<font color=\"#CC9393\">";
-        private const string singleLineCommentFont = "<font color=\"#7F9F7F\">";
-        private const string multiLineCommentFont = "<font color=\"#73879B\">";
-        private const string lineNumberFont = "<font color=\"#C0C0C0\">";
-        private const string graphBackgroundColor = "#303030";
-        private const string graphBorderColor = "#8DCBE2";
-        private const string graphTextColor = "#8DCBE2";
-        */
-        private const string backgroundColor = "white";
-        private const string foregroundFont = "<font color=\"black\">";
-        private const string symbolFont = "<font style=\"background-color:#c0c0c0\">";
-        private const string keywordFont = "<font color=\"blue\">";
-        private const string numberFont = "<font color=\"green\">";
-        private const string stringFont = "<font color=\"#800000\">";
-        private const string singleLineCommentFont = "<font color=\"gray\">";
-        private const string multiLineCommentFont = "<font color=\"gray\">";
-        private const string lineNumberFont = "<font color=\"black\">";
-        private const string graphBackgroundColor = "#e0e0e0";
-        private const string graphBorderColor = "black";
-        private const string graphTextColor = "black";
-
-        static private void writeSourceFile(string path, string w, string filename)
-        {
-            string errorLoc;
-            string errorMessage;
-            if (w[0] == '[')
-            {
-                errorLoc = w.Substring(1, w.IndexOf(']') - 1);
-                int i1 = w.IndexOf(')') + 1;
-                errorMessage = w.Substring(i1);
-            }
-            else
-            {
-                errorLoc = w.Substring(0, w.IndexOf(':', w.IndexOf(':') + 1));
-                int i1 = w.IndexOf(": ", w.IndexOf(": ") + 1) + 1;
-                int i2 = w.LastIndexOf('[') - 1;
-                errorMessage = w.Substring(i1, i2 - i1).Trim();
-            }
-            string f = errorLoc.Substring(0, errorLoc.LastIndexOf(':'));
-            int errorLine = Int32.Parse(errorLoc.Substring(1 + errorLoc.LastIndexOf(':')));
-            string symbolName = "";
-            if (errorMessage.IndexOf(": ") > 5)
-            {
-                string end = errorMessage.Substring(errorMessage.LastIndexOf(": "));
-                // get symbol name
-                Regex regex = new Regex(": '?[a-zA-Z_][a-zA-Z0-9_]*'?\\.?");
-                if (regex.IsMatch(end))
-                    symbolName = end.Trim(':', ' ', '\'', '.');
-            }
-            string[] lines = System.IO.File.ReadAllLines(path + f);
-            string[] keywords = { "void", "bool", "char", "short", "int", "long", "double", "float",
-                                  "class", "struct", "union", "enum", "namespace", "friend", "using",
-                                  "for", "if", "while", "switch", "case", "default",
-                                  "return", "goto", "break", "continue", "throw",
-                                  "unsigned", "signed",
-                                  "private", "protected", "public",
-                                  "static", "const", "template", "typename", "auto", "virtual",
-                                  "true", "false", "this" };
-            System.IO.StreamWriter file = new System.IO.StreamWriter(path + filename);
-            file.WriteLine("<html>");
-            file.WriteLine("<head>");
-            file.WriteLine("<title>" + TextToHtml(w) + "</title>");
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.IO;
+using System.Text.RegularExpressions;
+
+namespace difftool
+{
+    class Program
+    {
+        static private string FirstLine(string s)
+        {
+            int i = s.IndexOf('\n');
+            return i > 0 ? s.Substring(0, i) : s;
+        }
+
+        static private List<string> GetDiff(string[] s1, string[] s2)
+        {
+            List<string> ret = new List<string>();
+
+            int i2 = 0;
+            while (i2 < s2.Length && (s2[i2] == "" || !s2[i2].StartsWith("mozilla/")))
+                i2++;
+            for (int i1 = 0; i1 < s1.Length; ++i1)
+            {
+                if (s1[i1] == "" || !s1[i1].StartsWith("mozilla/"))
+                    continue;
+
+                if (i2 >= s2.Length)
+                {
+                    ret.Add(s1[i1]);
+                    continue;
+                }
+                if (FirstLine(s1[i1]) == FirstLine(s2[i2]))
+                {
+                    ++i2;
+                    continue;
+                }
+                for (int i3 = i2 + 1; i3 < i2 + 300 && i3 < s2.Length; ++i3)
+                {
+                    if (FirstLine(s1[i1]) == FirstLine(s2[i3]))
+                    {
+                        i2 = i3;
+                        break;
+                    }
+                }
+                if (FirstLine(s1[i1]) == FirstLine(s2[i2]))
+                {
+                    ++i2;
+                    continue;
+                }
+                ret.Add(s1[i1]);
+            }
+            return ret;
+        }
+
+        static private string TextToHtml(string s)
+        {
+            return s.Replace("&", "&amp;").Replace("<", "&lt;").Replace(">", "&gt;");
+        }
+
+        static Boolean IsNameChar(char c)
+        {
+            return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_';
+        }
+
+        // color theme:
+
+        // http://www.eclipsecolorthemes.org/?view=theme&id=47
+        /*
+        private const string backgroundColor = "1E1E1E";
+        private const string foregroundFont = "<font color=\"#E2E2E2\">";
+        private const string keywordFont = "<font color=\"#8DCBE2\">";
+        private const string numberFont = "<font color=\"#EAB882\">";
+        private const string stringFont = "<font color=\"#CC9393\">";
+        private const string singleLineCommentFont = "<font color=\"#7F9F7F\">";
+        private const string multiLineCommentFont = "<font color=\"#73879B\">";
+        private const string lineNumberFont = "<font color=\"#C0C0C0\">";
+        private const string graphBackgroundColor = "#303030";
+        private const string graphBorderColor = "#8DCBE2";
+        private const string graphTextColor = "#8DCBE2";
+        */
+        private const string backgroundColor = "white";
+        private const string foregroundFont = "<font color=\"black\">";
+        private const string symbolFont = "<font style=\"background-color:#c0c0c0\">";
+        private const string keywordFont = "<font color=\"blue\">";
+        private const string numberFont = "<font color=\"green\">";
+        private const string stringFont = "<font color=\"#800000\">";
+        private const string singleLineCommentFont = "<font color=\"gray\">";
+        private const string multiLineCommentFont = "<font color=\"gray\">";
+        private const string lineNumberFont = "<font color=\"black\">";
+        private const string graphBackgroundColor = "#e0e0e0";
+        private const string graphBorderColor = "black";
+        private const string graphTextColor = "black";
+
+        static private void writeSourceFile(string path, string w, string filename)
+        {
+            string errorLoc;
+            string errorMessage;
+            if (w[0] == '[')
+            {
+                errorLoc = w.Substring(1, w.IndexOf(']') - 1);
+                int i1 = w.IndexOf(')') + 1;
+                errorMessage = w.Substring(i1);
+            }
+            else
+            {
+                errorLoc = w.Substring(0, w.IndexOf(':', w.IndexOf(':') + 1));
+                int i1 = w.IndexOf(": ", w.IndexOf(": ") + 1) + 1;
+                int i2 = w.LastIndexOf('[') - 1;
+                errorMessage = w.Substring(i1, i2 - i1).Trim();
+            }
+            string f = errorLoc.Substring(0, errorLoc.LastIndexOf(':'));
+            int errorLine = Int32.Parse(errorLoc.Substring(1 + errorLoc.LastIndexOf(':')));
+            string symbolName = "";
+            if (errorMessage.IndexOf(": ") > 5)
+            {
+                string end = errorMessage.Substring(errorMessage.LastIndexOf(": "));
+                // get symbol name
+                Regex regex = new Regex(": '?[a-zA-Z_][a-zA-Z0-9_]*'?\\.?");
+                if (regex.IsMatch(end))
+                    symbolName = end.Trim(':', ' ', '\'', '.');
+            }
+            string[] lines = System.IO.File.ReadAllLines(path + f);
+            string[] keywords = { "void", "bool", "char", "short", "int", "long", "double", "float",
+                                  "class", "struct", "union", "enum", "namespace", "friend", "using",
+                                  "for", "if", "while", "switch", "case", "default",
+                                  "return", "goto", "break", "continue", "throw",
+                                  "unsigned", "signed",
+                                  "private", "protected", "public",
+                                  "static", "const", "template", "typename", "auto", "virtual",
+                                  "true", "false", "this" };
+            System.IO.StreamWriter file = new System.IO.StreamWriter(path + filename);
+            file.WriteLine("<html>");
+            file.WriteLine("<head>");
+            file.WriteLine("<title>" + TextToHtml(w) + "</title>");
             file.WriteLine("<style>");
-            file.WriteLine("  table {");
-            file.WriteLine("    border: 0px;");
-            file.WriteLine("    border-spacing: 0;");
-            file.WriteLine("  }");
-            file.WriteLine("  td {");
-            file.WriteLine("    border: 1px solid red;");
-            file.WriteLine("    padding: 5px;");
-            file.WriteLine("    background-color: #ffe0e0;");
+            file.WriteLine("  table {");
+            file.WriteLine("    border: 0px;");
+            file.WriteLine("    border-spacing: 0;");
+            file.WriteLine("  }");
+            file.WriteLine("  td {");
+            file.WriteLine("    border: 1px solid red;");
+            file.WriteLine("    padding: 5px;");
+            file.WriteLine("    background-color: #ffe0e0;");
             file.WriteLine("}");
-            file.WriteLine("</style>");
-            file.WriteLine("</head>");
-            file.WriteLine("<body bgcolor=\"" + backgroundColor + "\"><pre>" + foregroundFont + TextToHtml(w) + "\n");
-            int linenr = 0;
-            bool multiline = false;
-            foreach (string line in lines)
-            {
-                ++linenr;
-                file.Write(lineNumberFont + (linenr.ToString() + "        ").Substring(0, 8) + "</font>");
-
-                for (int i = 0; i < line.Length;)
-                {
-                    if (line[i] == ' ')
-                    {
-                        file.Write(line[i]);
-                        i++;
-                    }
-                    else if (multiline)
-                    {
-                        string currentToken = "";
-                        while (i < line.Length && multiline)
-                        {
-                            currentToken += line[i];
-                            i++;
-                            if (currentToken.EndsWith("*/"))
-                                multiline = false;
-                        }
-                        file.Write(multiLineCommentFont + TextToHtml(currentToken) + "</font>");
-                    }
-                    else if (IsNameChar(line[i]))
-                    {
-                        string currentToken = "";
-                        while (i < line.Length && IsNameChar(line[i]))
-                        {
-                            currentToken += line[i];
-                            i++;
-                        }
-                        if (currentToken == symbolName)
-                            file.Write(symbolFont + currentToken + "</font>");
-                        else if (keywords.Contains(currentToken))
-                            file.Write(keywordFont + currentToken + "</font>");
-                        else if (currentToken[0] >= '0' && currentToken[0] <= '9')
-                            file.Write(numberFont + currentToken + "</font>");
-                        else
-                            file.Write(currentToken);
-                    }
-                    else if (line[i] == '\"' || line[i] == '\'')
-                    {
-                        string currentToken = "";
-                        while (i < line.Length)
-                        {
-                            currentToken += line[i];
-                            i++;
-                            if (currentToken.Length > 1 && currentToken[0] == line[i - 1])
-                                break;
-                        }
-                        file.Write(stringFont + TextToHtml(currentToken) + "</font>");
-                    }
-                    else if (line[i] == '/' && i + 1 < line.Length && line[i + 1] == '/')
-                    {
-                        file.Write(singleLineCommentFont + TextToHtml(line.Substring(i)) + "</font>");
-                        i = line.Length;
-                    }
-                    else if (line[i] == '/' && i + 1 < line.Length && line[i + 1] == '*')
-                    {
-                        multiline = true;
-                        string currentToken = "/*";
-                        i += 2;
-                        while (i < line.Length && multiline)
-                        {
-                            currentToken += line[i];
-                            i++;
-                            if (currentToken.Length > 3 && currentToken.EndsWith("*/"))
-                                multiline = false;
-                        }
-                        file.Write(multiLineCommentFont + TextToHtml(currentToken) + "</font>");
-                    }
-                    else
-                    {
-                        file.Write(TextToHtml(line.Substring(i, 1)));
-                        i++;
-                    }
-                }
-                file.Write('\n');
-
-                if (errorLine == linenr)
-                    file.WriteLine("<table width=\"100%\"><tr><td><b>" + TextToHtml(errorMessage) + "</td></tr></table>");
-            }
-            file.Write("</font></pre></body></html>");
-            file.Close();
-        }
-
-        static private void combineWarnings(string[] lines)
-        {
-            for (int i = 0; i < lines.Length; ++i)
-            {
-                if (lines[i].IndexOf(": note:") > 0 || !lines[i].StartsWith("mozilla/"))
-                    lines[i] = "";
-                continue;
-
-                int i2 = i + 1;
-                while (i2 < lines.Length && lines[i2].IndexOf(": note:") > 0)
-                {
-                    lines[i] = lines[i] + '\n' + lines[i2];
-                    lines[i2] = "";
-                    i2++;
-                }
-            }
-        }
-
-        static void Main(string[] args)
-        {
-            string path;
-            if (Directory.Exists("/home/danielm/shared/testing"))
-                path = "/home/danielm/shared/testing/";
-            else if (Directory.Exists("/home/danielm/testing"))
-                path = "/home/danielm/testing/";
-            else if (Directory.Exists(@"c:\Users\danielm.evidente\testing"))
-                path = @"c:\Users\danielm.evidente\testing\";
-            else
-            {
-                Console.WriteLine("Directory testing not found");
-                return;
-            }
-
-            string[] old = System.IO.File.ReadAllLines(path + "1.82.txt");
-            string[] head = System.IO.File.ReadAllLines(path + "head.txt");
-
-            combineWarnings(old);
-            combineWarnings(head);
-
-            Array.Sort(old, StringComparer.InvariantCulture);
-            Array.Sort(head, StringComparer.InvariantCulture);
-
-            List<string> removed = GetDiff(old, head);
-            List<string> added = GetDiff(head, old);
-
-            int fileIndex = 1;
-
-            using (System.IO.StreamWriter file = new System.IO.StreamWriter(path + "html/main.html"))
-            {
-                file.WriteLine("<html>");
-                file.WriteLine("<head>");
-                file.WriteLine("<title>Comparison 1.82 / Head</title>");
-                file.WriteLine("</head>");
-                file.WriteLine("<body bgcolor=\"" + backgroundColor + "\">");
-                file.WriteLine(foregroundFont);
-
-                file.WriteLine("<h1>Comparison 1.82 / Head</h1>");
-                file.WriteLine("<p>Package: {0}</p>", @"ftp://ftp.se.debian.org/debian/pool/main/f/firefox/firefox_59.0~b4.orig.tar.bz2");
-                file.WriteLine("<p>+ Added warnings {0}</p>", added.Count);
-                file.WriteLine("<p>- Removed warnings {0}</p>", removed.Count);
-
-                file.WriteLine("<svg width=\"{0}\" height=\"{1}\">", 60 + Math.Max(added.Count, removed.Count) + 10, 40);
-                file.WriteLine("  <rect x=\"0\" y=\"0\" width=\"100%\" height=\"100%\" stroke=\"" + graphBorderColor + "\" fill=\"" + graphBackgroundColor + "\"/>");
-                file.WriteLine("  <text x=\"4\" y=\"15\" font-family=\"Verdana\" font-size=\"10\" fill=\"" + graphTextColor + "\">Added</text>");
-                file.WriteLine("  <text x=\"4\" y=\"30\" font-family=\"Verdana\" font-size=\"10\" fill=\"" + graphTextColor + "\">Removed</text>");
-                file.WriteLine("  <rect x=\"60\" y=\"8\" width=\"{0}\" height=\"8\" fill=\"#40ff40\" />", added.Count);
-                file.WriteLine("  <rect x=\"60\" y=\"23\" width=\"{0}\" height=\"8\" fill=\"#ff4040\" />", removed.Count);
-                file.WriteLine("</svg>");
-
-                string[] title = { "Added warnings", "Removed warnings" };
-                List<string>[] warnings = { added, removed };
-                for (int i = 0; i < 2; i++)
-                {
-                    file.WriteLine("<h2>" + title[i] + "</h2>");
-                    file.WriteLine("<pre>");
-                    foreach (string w in warnings[i])
-                    {
-                        string filename = "code" + fileIndex.ToString() + ".html";
-                        fileIndex++;
-                        writeSourceFile(path, w, "html/" + filename);
-                        file.WriteLine("<a href=\"{0}\">{1}</a>", filename, TextToHtml(w));
-                    }
-                    file.WriteLine("</pre>");
-                }
-
-                file.WriteLine("</body>");
-                file.WriteLine("</html>");
-            }
-        }
-    }
-}
+            file.WriteLine("</style>");
+            file.WriteLine("</head>");
+            file.WriteLine("<body bgcolor=\"" + backgroundColor + "\"><pre>" + foregroundFont + TextToHtml(w) + "\n");
+            int linenr = 0;
+            bool multiline = false;
+            foreach (string line in lines)
+            {
+                ++linenr;
+                file.Write(lineNumberFont + (linenr.ToString() + "        ").Substring(0, 8) + "</font>");
+
+                for (int i = 0; i < line.Length;)
+                {
+                    if (line[i] == ' ')
+                    {
+                        file.Write(line[i]);
+                        i++;
+                    }
+                    else if (multiline)
+                    {
+                        string currentToken = "";
+                        while (i < line.Length && multiline)
+                        {
+                            currentToken += line[i];
+                            i++;
+                            if (currentToken.EndsWith("*/"))
+                                multiline = false;
+                        }
+                        file.Write(multiLineCommentFont + TextToHtml(currentToken) + "</font>");
+                    }
+                    else if (IsNameChar(line[i]))
+                    {
+                        string currentToken = "";
+                        while (i < line.Length && IsNameChar(line[i]))
+                        {
+                            currentToken += line[i];
+                            i++;
+                        }
+                        if (currentToken == symbolName)
+                            file.Write(symbolFont + currentToken + "</font>");
+                        else if (keywords.Contains(currentToken))
+                            file.Write(keywordFont + currentToken + "</font>");
+                        else if (currentToken[0] >= '0' && currentToken[0] <= '9')
+                            file.Write(numberFont + currentToken + "</font>");
+                        else
+                            file.Write(currentToken);
+                    }
+                    else if (line[i] == '\"' || line[i] == '\'')
+                    {
+                        string currentToken = "";
+                        while (i < line.Length)
+                        {
+                            currentToken += line[i];
+                            i++;
+                            if (currentToken.Length > 1 && currentToken[0] == line[i - 1])
+                                break;
+                        }
+                        file.Write(stringFont + TextToHtml(currentToken) + "</font>");
+                    }
+                    else if (line[i] == '/' && i + 1 < line.Length && line[i + 1] == '/')
+                    {
+                        file.Write(singleLineCommentFont + TextToHtml(line.Substring(i)) + "</font>");
+                        i = line.Length;
+                    }
+                    else if (line[i] == '/' && i + 1 < line.Length && line[i + 1] == '*')
+                    {
+                        multiline = true;
+                        string currentToken = "/*";
+                        i += 2;
+                        while (i < line.Length && multiline)
+                        {
+                            currentToken += line[i];
+                            i++;
+                            if (currentToken.Length > 3 && currentToken.EndsWith("*/"))
+                                multiline = false;
+                        }
+                        file.Write(multiLineCommentFont + TextToHtml(currentToken) + "</font>");
+                    }
+                    else
+                    {
+                        file.Write(TextToHtml(line.Substring(i, 1)));
+                        i++;
+                    }
+                }
+                file.Write('\n');
+
+                if (errorLine == linenr)
+                    file.WriteLine("<table width=\"100%\"><tr><td><b>" + TextToHtml(errorMessage) + "</td></tr></table>");
+            }
+            file.Write("</font></pre></body></html>");
+            file.Close();
+        }
+
+        static private void combineWarnings(string[] lines)
+        {
+            for (int i = 0; i < lines.Length; ++i)
+            {
+                if (lines[i].IndexOf(": note:") > 0 || !lines[i].StartsWith("mozilla/"))
+                    lines[i] = "";
+                continue;
+
+                int i2 = i + 1;
+                while (i2 < lines.Length && lines[i2].IndexOf(": note:") > 0)
+                {
+                    lines[i] = lines[i] + '\n' + lines[i2];
+                    lines[i2] = "";
+                    i2++;
+                }
+            }
+        }
+
+        static void Main(string[] args)
+        {
+            string path;
+            if (Directory.Exists("/home/danielm/shared/testing"))
+                path = "/home/danielm/shared/testing/";
+            else if (Directory.Exists("/home/danielm/testing"))
+                path = "/home/danielm/testing/";
+            else if (Directory.Exists(@"c:\Users\danielm.evidente\testing"))
+                path = @"c:\Users\danielm.evidente\testing\";
+            else
+            {
+                Console.WriteLine("Directory testing not found");
+                return;
+            }
+
+            string[] old = System.IO.File.ReadAllLines(path + "1.82.txt");
+            string[] head = System.IO.File.ReadAllLines(path + "head.txt");
+
+            combineWarnings(old);
+            combineWarnings(head);
+
+            Array.Sort(old, StringComparer.InvariantCulture);
+            Array.Sort(head, StringComparer.InvariantCulture);
+
+            List<string> removed = GetDiff(old, head);
+            List<string> added = GetDiff(head, old);
+
+            int fileIndex = 1;
+
+            using (System.IO.StreamWriter file = new System.IO.StreamWriter(path + "html/main.html"))
+            {
+                file.WriteLine("<html>");
+                file.WriteLine("<head>");
+                file.WriteLine("<title>Comparison 1.82 / Head</title>");
+                file.WriteLine("</head>");
+                file.WriteLine("<body bgcolor=\"" + backgroundColor + "\">");
+                file.WriteLine(foregroundFont);
+
+                file.WriteLine("<h1>Comparison 1.82 / Head</h1>");
+                file.WriteLine("<p>Package: {0}</p>", @"ftp://ftp.se.debian.org/debian/pool/main/f/firefox/firefox_59.0~b4.orig.tar.bz2");
+                file.WriteLine("<p>+ Added warnings {0}</p>", added.Count);
+                file.WriteLine("<p>- Removed warnings {0}</p>", removed.Count);
+
+                file.WriteLine("<svg width=\"{0}\" height=\"{1}\">", 60 + Math.Max(added.Count, removed.Count) + 10, 40);
+                file.WriteLine("  <rect x=\"0\" y=\"0\" width=\"100%\" height=\"100%\" stroke=\"" + graphBorderColor + "\" fill=\"" + graphBackgroundColor + "\"/>");
+                file.WriteLine("  <text x=\"4\" y=\"15\" font-family=\"Verdana\" font-size=\"10\" fill=\"" + graphTextColor + "\">Added</text>");
+                file.WriteLine("  <text x=\"4\" y=\"30\" font-family=\"Verdana\" font-size=\"10\" fill=\"" + graphTextColor + "\">Removed</text>");
+                file.WriteLine("  <rect x=\"60\" y=\"8\" width=\"{0}\" height=\"8\" fill=\"#40ff40\" />", added.Count);
+                file.WriteLine("  <rect x=\"60\" y=\"23\" width=\"{0}\" height=\"8\" fill=\"#ff4040\" />", removed.Count);
+                file.WriteLine("</svg>");
+
+                string[] title = { "Added warnings", "Removed warnings" };
+                List<string>[] warnings = { added, removed };
+                for (int i = 0; i < 2; i++)
+                {
+                    file.WriteLine("<h2>" + title[i] + "</h2>");
+                    file.WriteLine("<pre>");
+                    foreach (string w in warnings[i])
+                    {
+                        string filename = "code" + fileIndex.ToString() + ".html";
+                        fileIndex++;
+                        writeSourceFile(path, w, "html/" + filename);
+                        file.WriteLine("<a href=\"{0}\">{1}</a>", filename, TextToHtml(w));
+                    }
+                    file.WriteLine("</pre>");
+                }
+
+                file.WriteLine("</body>");
+                file.WriteLine("</html>");
+            }
+        }
+    }
+}
diff --git a/tools/compare_ast_symdb.py b/tools/compare_ast_symdb.py
new file mode 100644
index 00000000000..5437c38853b
--- /dev/null
+++ b/tools/compare_ast_symdb.py
@@ -0,0 +1,90 @@
+# Example usage:
+# python3 compare_ast.py lib/token.cpp
+# python3 compare_ast.py "--project=compile_commands.json --file-filter=*/lib/somefile.c"
+# check all files in a compile_commands.json:
+# grep '"file":' compile_commands.json | grep -v test | sed 's|.*/curl/|"--project=compile_commands.json --file-filter=*|' | xargs python3 ~/cppcheck/tools/compare_ast.py
+
+import os
+import re
+import sys
+import subprocess
+
+CPPCHECK = os.path.expanduser('~/cppcheck/cppcheck')
+
+def run_cppcheck(cppcheck_parameters:str, clang:str):
+    cmd = '{} {} {} --debug --verbose'.format(CPPCHECK, cppcheck_parameters, clang)
+    #print(cmd)
+    with subprocess.Popen(cmd.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE) as p:
+        # TODO: handle p.returncode?
+        stdout, _ = p.communicate()
+    return stdout.decode('utf-8', 'ignore')
+
+
+def get_ast(debug):
+    debug = re.sub(r' f:0x[0-9a-fA-F]+', '', debug)
+    debug = re.sub(r" '[a-zA-Z0-9: *]+'", '', debug)
+
+    pos1 = debug.rfind('\n##AST\n')
+    if pos1 < 0:
+        return ''
+    pos1 = debug.find('\n', pos1) + 1
+    assert pos1 > 0
+    pos2 = debug.find("\n##", pos1)
+    if pos2 < 0:
+        return debug[pos1:]
+    return debug[pos1:pos2-1]
+
+
+def get_symdb(debug):
+    debug = re.sub(r'0x[0-9a-fA-F]+', '0x12345678', debug)
+    debug = re.sub(r'nestedIn: Struct', 'nestedIn: Class', debug)
+    debug = re.sub(r'classDef: struct', 'classDef: class', debug)
+    debug = re.sub(r'isInline: [a-z]+', 'isInline: ---', debug)
+    debug = re.sub(r'definedType: .*', 'definedType: ---', debug)
+    debug = re.sub(r'needInitialization: .*', 'needInitialization: ---', debug)
+    debug = re.sub(r'functionOf: .*', 'functionOf: ---', debug)
+    debug = re.sub(r'0x12345678 Struct', '0x12345678 Class', debug)
+
+    pos1 = debug.rfind('\n### Symbol database ###\n')
+    if pos1 < 0:
+        return ''
+    pos1 = debug.find('\n', pos1) + 1
+    assert pos1 > 0
+    pos2 = debug.find("\n##", pos1)
+    if pos2 < 0:
+        return debug[pos1:]
+    return debug[pos1:pos2-1]
+
+
+def compare_ast_symdb(cppcheck_parameters: str):
+    same = True
+    debug1 = run_cppcheck(cppcheck_parameters, '')
+    debug2 = run_cppcheck(cppcheck_parameters, '--clang')
+
+    ast1 = get_ast(debug1)
+    ast2 = get_ast(debug2)
+    if ast1 != ast2:
+        print("ast is not the same: {}".format(cppcheck_parameters))
+        with open('cppcheck.ast', 'wt') as f:
+            f.write(ast1)
+        with open('clang.ast', 'wt') as f:
+            f.write(ast2)
+        same = False
+
+    symdb1 = get_symdb(debug1)
+    symdb2 = get_symdb(debug2)
+    if symdb1 != symdb2:
+        print("symdb is not the same: {}".format(cppcheck_parameters))
+        with open('cppcheck.symdb', 'wt') as f:
+            f.write(symdb1)
+        with open('clang.symdb', 'wt') as f:
+            f.write(symdb2)
+        same = False
+
+    if not same:
+        sys.exit(1)
+
+for arg in sys.argv[1:]:
+    print(arg)
+    compare_ast_symdb(arg)
+
diff --git a/tools/creduce.py b/tools/creduce.py
new file mode 100644
index 00000000000..f6f9c7d8e47
--- /dev/null
+++ b/tools/creduce.py
@@ -0,0 +1,113 @@
+import argparse
+import contextlib
+import multiprocessing
+import os
+import tempfile
+import shutil
+import subprocess
+
+@contextlib.contextmanager
+def mkdtemp():
+    d = tempfile.mkdtemp()
+    yield d
+    shutil.rmtree(d, ignore_errors=True)
+
+def print_lines(lines):
+    for line in lines:
+        print(line)
+
+def write_to(file, lines):
+    content = list((line + "\n" for line in lines))
+    if (len(content) > 0):
+        with open(file, 'w') as f:
+            f.writelines(content)
+
+def make_executable(p):
+    os.chmod(p, 509)
+
+def quote(s):
+    text = s.replace("'", "'\"'\"'")
+    return "'{}'".format(text)
+
+class ScriptBuilder:
+    def __init__(self):
+        self.commands = ['#!/bin/bash', '', 'rm -rf .tmp.output', '']
+
+    def blank(self):
+        self.commands.append('')
+
+    def add_command(self, cmd, save=False):
+        if save:
+            self.commands.append(cmd + ' 2>&1 | tee .tmp.output')
+        else:
+            self.commands.append(cmd)
+
+    def grep(self, text, file=None):
+        self.add_command("grep -q -F {} {}".format(quote(text), file or '.tmp.output'))
+
+    def check(self, equal_zero=False, result=1):
+        op = 'eq' if equal_zero else 'ne'
+        cmds = ['RES=$?',
+                'if [ $RES -{} "0" ]; then'.format(op),
+                '    exit {}'.format(result),
+                'fi']
+        self.commands.extend(cmds)
+
+    def write(self, p):
+        write_to(p, self.commands)
+        make_executable(p)
+
+    def show(self):
+        print_lines(self.commands)
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--file', '-f', help='file to reduce', required=True)
+parser.add_argument('--text', '-t', action='append', help='expected output text')
+parser.add_argument('--keep', '-k', action='append', help='text to keep in source file')
+parser.add_argument('--check', '-c', action='append', help='command to check syntax')
+parser.add_argument('--dry-run', '-d', action='store_true', default=False, help='dry run')
+parser.add_argument('--timeout', action='store', default=300, help='Interestingness test timeout in seconds')
+parser.add_argument('--no-cache', action='store_true', default=False, help="Don't cache behavior of passes")
+parser.add_argument('--no-give-up', action='store_true', default=False, help="Don't give up on a pass that hasn't made progress for 50000 iterations")
+parser.add_argument('--sllooww', '--slow', action='store_true', default=False, help="Try harder to reduce, but perhaps take a long time to do so")
+parser.add_argument('command')
+parser.add_argument('args', nargs=argparse.REMAINDER)
+args = parser.parse_args()
+
+file = os.path.basename(args.file)
+sb = ScriptBuilder()
+for keep in args.keep or []:
+    sb.grep(keep, file=file)
+    sb.check()
+    sb.blank()
+for check in args.check or []:
+    sb.add_command(check+' '+file)
+    sb.check()
+    sb.blank()
+command = ' '.join([os.path.abspath(args.command)]+args.args+[file])
+sb.add_command(command, save=args.text)
+if args.text:
+    for t in args.text:
+        sb.grep(t)
+        sb.check()
+else:
+    sb.check(equal_zero=True)
+sb.show()
+with mkdtemp() as d:
+    script = os.path.join(d, 'reduce.sh')
+    sb.write(script)
+    if args.dry_run:
+        shutil.copy(args.file, d)
+        subprocess.check_call([script], cwd=d)
+    else:
+        creduce = ['creduce', '--n', str(multiprocessing.cpu_count())]
+        creduce.append("--timeout")
+        creduce.append(str(args.timeout))
+        if args.no_cache:
+            creduce.append("--no-cache")
+        if args.no_give_up:
+            creduce.append("--no-give-up")
+        if args.sllooww:
+            creduce.append("--sllooww")
+        subprocess.check_call(creduce + [script, args.file])
diff --git a/tools/daca2-download.py b/tools/daca2-download.py
old mode 100644
new mode 100755
index 72fb9abd1dc..ee02a26f186
--- a/tools/daca2-download.py
+++ b/tools/daca2-download.py
@@ -1,9 +1,9 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Downloads all daca2 source code packages.
 #
 # Usage:
-# $ mkdir ~/daca2-packages && python daca2-download.py
+# $ ./daca2-download.py
 
 
 import subprocess
@@ -12,6 +12,7 @@
 import glob
 import os
 import time
+import natsort
 
 DEBIAN = ('ftp://ftp.se.debian.org/debian/',
           'ftp://ftp.debian.org/debian/')
@@ -22,6 +23,7 @@ def wget(filepath):
     if '/' in filepath:
         filename = filename[filename.rfind('/') + 1:]
     for d in DEBIAN:
+        # TODO: handle exitcode?
         subprocess.call(
             ['nice', 'wget', '--tries=10', '--timeout=300', '-O', filename, d + filepath])
         if os.path.isfile(filename):
@@ -31,32 +33,38 @@ def wget(filepath):
     return False
 
 
+def latestvername(names):
+    s = natsort.natsorted(names, key=lambda x: x[x.index('_')+1:x.index('.orig.tar')])
+    return s[-1]
+
+
 def getpackages():
     if not wget('ls-lR.gz'):
         return []
+    # TODO: handle exitcode?
     subprocess.call(['nice', 'gunzip', 'ls-lR.gz'])
-    f = open('ls-lR', 'rt')
-    lines = f.readlines()
-    f.close()
+    with open('ls-lR', 'rt') as f:
+        lines = f.readlines()
+    # TODO: handle exitcode?
     subprocess.call(['rm', 'ls-lR'])
 
     path = None
     archives = []
     filename = None
+    filenames = []
     for line in lines:
         line = line.strip()
         if len(line) < 4:
             if filename:
-                archives.append(path + '/' + filename)
+                archives.append(path + '/' + latestvername(filenames))
             path = None
             filename = None
+            filenames = []
         elif line[:12] == './pool/main/':
             path = line[2:-1]
         elif path and '.orig.tar.' in line:
             filename = line[1 + line.rfind(' '):]
-
-    for a in archives:
-        print(a)
+            filenames.append(filename)
 
     return archives
 
@@ -81,6 +89,7 @@ def removeAll():
         try:
             for filename in filenames:
                 if os.path.isdir(filename):
+                    # pylint: disable=deprecated-argument - FIXME: onerror was deprecated in Python 3.12
                     shutil.rmtree(filename, onerror=handleRemoveReadonly)
                 else:
                     os.remove(filename)
@@ -102,6 +111,17 @@ def removeAll():
         count = 0
 
 
+def accept_filename(filename:str):
+    if '.' not in filename:
+        return False
+    ext = filename[filename.rfind('.'):]
+    if ext == '.proto' and ('--protobuf' in sys.argv):
+        print('accept_filename:' + filename)
+        return True
+    return ext in ('.C', '.c', '.H', '.h', '.cc',
+                   '.cpp', '.cxx', '.c++', '.hpp', '.tpp', '.t++')
+
+
 def removeLargeFiles(path):
     for g in glob.glob(path + '*'):
         if g == '.' or g == '..':
@@ -117,8 +137,7 @@ def removeLargeFiles(path):
                 os.remove(g)
 
             # remove non-source files
-            elif g[-2:] not in {'.C', '.c', '.H', '.h'} and g[-3:] != '.cc' and\
-                    g[-4:] not in {'.cpp', '.cxx', '.c++', '.hpp', '.tpp', '.t++'}:
+            elif not accept_filename(g):
                 os.remove(g)
 
 
@@ -132,11 +151,14 @@ def downloadpackage(filepath, outpath):
 
     filename = filepath[filepath.rfind('/') + 1:]
     if filename[-3:] == '.gz':
-        subprocess.call(['tar', 'xzvf', filename])
+        # TODO: handle exitcode?
+        subprocess.call(['tar', 'xzf', filename])
     elif filename[-3:] == '.xz':
-        subprocess.call(['tar', 'xJvf', filename])
+        # TODO: handle exitcode?
+        subprocess.call(['tar', 'xJf', filename])
     elif filename[-4:] == '.bz2':
-        subprocess.call(['tar', 'xjvf', filename])
+        # TODO: handle exitcode?
+        subprocess.call(['tar', 'xjf', filename])
     else:
         return
 
@@ -144,7 +166,8 @@ def downloadpackage(filepath, outpath):
 
     for g in glob.glob('[#_A-Za-z0-9]*'):
         if os.path.isdir(g):
-            subprocess.call(['tar', '-cJvf', outpath + filename[:filename.rfind('.')] + '.xz', g])
+            # TODO: handle exitcode?
+            subprocess.call(['tar', '-cJf', outpath + filename[:filename.rfind('.')] + '.xz', g])
             break
 
 workdir = os.path.expanduser('~/daca2-packages/tmp/')
diff --git a/tools/daca2-getpackages.py b/tools/daca2-getpackages.py
old mode 100644
new mode 100755
index d66962284c6..992921082c1
--- a/tools/daca2-getpackages.py
+++ b/tools/daca2-getpackages.py
@@ -1,22 +1,22 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
-# 1. Create a folder daca2 in your HOME folder
-# 2. Put cppcheck-head in daca2. It should be built with all optimisations.
-# 3. Optional: Put a file called "suppressions.txt" in the daca2 folder.
-# 4. Optional: tweak FTPSERVER and FTPPATH in this script below.
-# 5. Run the daca2 script:  python daca2.py FOLDER
+# Get list of debian packages
+#
+# Usage:
+#
+# cd cppcheck/tools
+# ./daca2-getpackages.py
+#
+
 
-import argparse
-import logging
 import subprocess
 import sys
-import shutil
-import glob
 import os
-import datetime
+import re
 import time
+import natsort
 
-DEBIAN = ('ftp://ftp.se.debian.org/debian/',
+DEBIAN = ('ftp://ftp.de.debian.org/debian/',
           'ftp://ftp.debian.org/debian/')
 
 def wget(filepath):
@@ -24,6 +24,7 @@ def wget(filepath):
     if '/' in filepath:
         filename = filename[filename.rfind('/') + 1:]
     for d in DEBIAN:
+        # TODO: handle exitcode?
         subprocess.call(
             ['nice', 'wget', '--tries=10', '--timeout=300', '-O', filename, d + filepath])
         if os.path.isfile(filename):
@@ -33,15 +34,21 @@ def wget(filepath):
     return False
 
 
+def latestvername(names):
+    s = natsort.natsorted(names, key=lambda x: x[x.index('_')+1:x.index('.orig.tar')])
+    return s[-1]
+
+
 def getpackages():
     if not wget('ls-lR.gz'):
         sys.exit(1)
+    # TODO: handle exitcode?
     subprocess.call(['nice', 'gunzip', 'ls-lR.gz'])
     if not os.path.isfile('ls-lR'):
         sys.exit(1)
-    f = open('ls-lR', 'rt')
-    lines = f.readlines()
-    f.close()
+    with open('ls-lR', 'rt') as f:
+        lines = f.readlines()
+    # TODO: handle exitcode?
     subprocess.call(['rm', 'ls-lR'])
 
     # Example content in ls-lR:
@@ -79,23 +86,39 @@ def getpackages():
     #
 
     path = None
+    previous_path = ''
     archives = []
     filename = None
+    filenames = []
     for line in lines:
         line = line.strip()
         if len(line) < 4:
             if filename:
-                archives.append(DEBIAN[0] + path + '/' + filename)
+                res1 = re.match(r'(.*)-[0-9.]+$', path)
+                if res1 is None:
+                    res1 = re.match(r'(.*)[-.][0-9.]+$', path)
+                res2 = re.match(r'(.*)-[0-9.]+$', previous_path)
+                if res2 is None:
+                    res2 = re.match(r'(.*)[-.][0-9.]+$', previous_path)
+                if res1 is None or res2 is None or res1.group(1) != res2.group(1):
+                    archives.append(path + '/' + latestvername(filenames))
+                else:
+                    archives[-1] = path + '/' + latestvername(filenames)
+            if path:
+                previous_path = path
             path = None
             filename = None
+            filenames = []
         elif line.startswith('./pool/main/'):
             path = line[2:-1]
-        elif path and line.endswith(('.orig.tar.gz', '.orig.tar.bz2')):
+        elif path and line.endswith(('.orig.tar.gz', '.orig.tar.bz2', '.orig.tar.xz')):
             filename = line[1 + line.rfind(' '):]
+            filenames.append(filename)
 
     return archives
 
 
 
 for p in getpackages():
-    print(p)
+    print(DEBIAN[0] + p)
+
diff --git a/tools/daca2-logs2git.sh b/tools/daca2-logs2git.sh
deleted file mode 100755
index 8523ff54c06..00000000000
--- a/tools/daca2-logs2git.sh
+++ /dev/null
@@ -1,77 +0,0 @@
-#!/bin/bash
-
-#just in case...
-rm /tmp/daca_msg /tmp/daca_tmp_diff /tmp/daca_tmp_plus /tmp/daca_tmp_minus >& /dev/null
-
-base_url="http://cppcheck.sourceforge.net/devinfo/daca2-report/"
-
-echo ${base_url}daca2.html
-
-
-for site in `curl -s --compressed ${base_url}daca2.html | grep "^<tr" | grep -o "\".*\"" | sed s/\"//g` ; do
-    echo ${site} ;  curl -s --compressed ${base_url}${site} | sort -n --parallel=4 | sed 's/^ *//; s/ *$//; /^$/d; s/^M$//; s/\r$//'  | sed -e 's/\[[0-9][0-9]:[0-9][0-9]\]$//' | sed '/^$/d' | sed 's/\&amp\;/\&/g; s/&lt;/</g; s/&gt;/>/g;' > ${site}
-done
-
-
-curl -s --compressed ${base_url}daca2.html > index.html
-
-
-git diff > /tmp/daca_tmp_diff
-
-grep "^+.*" /tmp/daca_tmp_diff > /tmp/daca_tmp_plus
-
-grep "^-.*" /tmp/daca_tmp_diff > /tmp/daca_tmp_minus
-
-
-
-plus_glob=`wc -l /tmp/daca_tmp_plus | cut -d' ' -f1`
-
-plus_error=`grep -c ":\ \(inconclusive\ \)\?error: "  /tmp/daca_tmp_plus`
-plus_warning=`grep -c ":\ \(inconclusive\ \)\?warning: "  /tmp/daca_tmp_plus`
-plus_style=`grep -c ":\ \(inconclusive\ \)\?style: "  /tmp/daca_tmp_plus`
-plus_performance=`grep -c ":\ \(inconclusive\ \)\?performance: "  /tmp/daca_tmp_plus`
-plus_portability=`grep -c ":\ \(inconclusive\ \)\?portability: "   /tmp/daca_tmp_plus`
-#plus_information=`grep -c "]: (information)"   /tmp/daca_tmp_plus`
-plus_crash=`grep -c "\ Crash?$" /tmp/daca_tmp_plus`
-plus_varid=`grep -c "called with varid 0\." /tmp/daca_tmp_plus`
-
-
-minus_glob=`wc -l /tmp/daca_tmp_minus | cut -d' ' -f1`
-
-minus_error=`grep -c ":\ \(inconclusive\ \)\?error: "  /tmp/daca_tmp_minus`
-minus_warning=`grep -c ":\ \(inconclusive\ \)\?warning: "  /tmp/daca_tmp_minus`
-minus_style=`grep -c ":\ \(inconclusive\ \)\?style: "  /tmp/daca_tmp_minus`
-minus_performance=`grep -c ":\ \(inconclusive\ \)\?performance: "  /tmp/daca_tmp_minus`
-minus_portability=`grep -c ":\ \(inconclusive\ \)\?portability: "   /tmp/daca_tmp_minus`
-#minus_information=`grep -c "]: (information)"   /tmp/daca_tmp_minus`
-minus_crash=`grep -c "\ Crash?$" /tmp/daca_tmp_minus`
-minus_varid=`grep -c "called with varid 0\." /tmp/daca_tmp_minus`
-
-
-
-files=`git ls-files`
-
-ID_stats=`awk '{ print $NF }' $files | grep "^\[.*\]$"  | sort -n | uniq --count | sort -n`
-
-echo "Update `date`" >> /tmp/daca_msg
-echo "Updated: `git status  --porcelain   | grep daca | cut -d' ' -f3 | sed s/daca2-// | sed s/\.html// | tr '\n' ' '`"  >> /tmp/daca_msg
-echo "all:           new: $plus_glob   gone: $minus_glob =   $((plus_glob-minus_glob))" >> /tmp/daca_msg
-echo "error:         new: $plus_error   gone: $minus_error =   $((plus_error-minus_error))" >> /tmp/daca_msg
-echo "warning:       new: $plus_warning   gone: $minus_warning =   $((plus_warning-minus_warning))" >> /tmp/daca_msg
-echo "style:         new: $plus_style   gone: $minus_style =   $((plus_style-minus_style))" >> /tmp/daca_msg
-echo "performance:   new: $plus_performance   gone: $minus_performance =   $((plus_performance-minus_performance))" >> /tmp/daca_msg
-echo "portability:   new: $plus_portability   gone: $minus_portability =   $((plus_portability-minus_portability))" >> /tmp/daca_msg
-#echo "information:   new: $plus_information   gone: $minus_information =   $((plus_information-minus_information))" >> /tmp/daca_msg
-echo "crashes:       new: $plus_crash   gone: $minus_crash =   $((plus_crash-minus_crash))" >> /tmp/daca_msg
-echo "varids:        new: $plus_varid   gone: $minus_varid =   $((plus_varid-minus_varid))" >> /tmp/daca_msg
-echo "ID stats:" >> /tmp/daca_msg
-echo "${ID_stats}" >> /tmp/daca_msg
-
-cat /tmp/daca_msg
-
-git add -A
-git commit -F /tmp/daca_msg
-
-rm /tmp/daca_msg /tmp/daca_tmp_diff /tmp/daca_tmp_plus /tmp/daca_tmp_minus
-
-notify-send "daca logs done"
diff --git a/tools/defines/create_platform_cfg.sh b/tools/defines/create_platform_cfg.sh
new file mode 100755
index 00000000000..1d9f23cd738
--- /dev/null
+++ b/tools/defines/create_platform_cfg.sh
@@ -0,0 +1,49 @@
+#!/bin/sh
+
+if [ -n "$1" ]; then
+  compiler_cmd=$1
+else
+  compiler_cmd="gcc"
+fi
+
+compiler_defs=$($compiler_cmd -dM -E - < /dev/null)
+
+char_bit=$(echo "$compiler_defs" | grep __CHAR_BIT__ | cut -d' ' -f3)
+# only set by compiler if -funsigned-char is specified
+char_unsigned=$(echo "$compiler_defs" | grep __CHAR_UNSIGNED__ | cut -d' ' -f3)
+if [ -n "$char_unsigned" ] && [ "$char_unsigned" -eq 1 ]; then
+  default_sign="unsigned"
+else
+  default_sign="signed"
+fi
+# TODO
+size_of_bool=
+size_of_short=$(echo "$compiler_defs" | grep __SIZEOF_SHORT__ | cut -d' ' -f3)
+size_of_int=$(echo "$compiler_defs" | grep __SIZEOF_INT__ | cut -d' ' -f3)
+size_of_long=$(echo "$compiler_defs" | grep __SIZEOF_LONG__ | cut -d' ' -f3)
+size_of_long_long=$(echo "$compiler_defs" | grep __SIZEOF_LONG_LONG__ | cut -d' ' -f3)
+size_of_float=$(echo "$compiler_defs" | grep __SIZEOF_FLOAT__ | cut -d' ' -f3)
+size_of_double=$(echo "$compiler_defs" | grep __SIZEOF_DOUBLE__ | cut -d' ' -f3)
+size_of_long_double=$(echo "$compiler_defs" | grep __SIZEOF_LONG_DOUBLE__ | cut -d' ' -f3)
+size_of_pointer=$(echo "$compiler_defs" | grep __SIZEOF_POINTER__ | cut -d' ' -f3)
+size_of_size_t=$(echo "$compiler_defs" | grep __SIZEOF_SIZE_T__ | cut -d' ' -f3)
+size_of_wchar_t=$(echo "$compiler_defs" | grep __SIZEOF_WCHAR_T__ | cut -d' ' -f3)
+
+echo "<?xml version=\"1.0\"?>
+<platform>
+  <char_bit>$char_bit</char_bit>
+  <default-sign>$default_sign</default-sign>
+  <sizeof>
+    <bool>$size_of_bool</bool>
+    <short>$size_of_short</short>
+    <int>$size_of_int</int>
+    <long>$size_of_long</long>
+    <long-long>$size_of_long_long</long-long>
+    <float>$size_of_float</float>
+    <double>$size_of_double</double>
+    <long-double>$size_of_long_double</long-double>
+    <pointer>$size_of_pointer</pointer>
+    <size_t>$size_of_size_t</size_t>
+    <wchar_t>$size_of_wchar_t</wchar_t>
+  </sizeof>
+</platform>"
diff --git a/tools/defines/defines.sh b/tools/defines/defines.sh
new file mode 100755
index 00000000000..51696171c5a
--- /dev/null
+++ b/tools/defines/defines.sh
@@ -0,0 +1,15 @@
+#!/bin/sh
+
+gcc -Wall -Wextra limits.c
+./a.out
+gcc -Wall -Wextra float.c
+./a.out
+gcc -Wall -Wextra stdint.c
+./a.out
+
+clang -Weverything limits.c
+./a.out
+clang -Weverything float.c
+./a.out
+clang -Weverything stdint.c
+./a.out
\ No newline at end of file
diff --git a/tools/defines/float.c b/tools/defines/float.c
new file mode 100644
index 00000000000..31887414740
--- /dev/null
+++ b/tools/defines/float.c
@@ -0,0 +1,43 @@
+#include "float.h"
+#include "stdio.h"
+
+#define PRINT_DEF(d, f) \
+    fprintf(stdout, ";"#d "=%"#f, d)
+
+int main(void)
+{
+    PRINT_DEF(FLT_RADIX, d);
+    PRINT_DEF(FLT_MANT_DIG, d);
+    PRINT_DEF(DBL_MANT_DIG, d);
+    PRINT_DEF(LDBL_MANT_DIG, d);
+    PRINT_DEF(FLT_DIG, d);
+    PRINT_DEF(DBL_DIG, d);
+    PRINT_DEF(LDBL_DIG, d);
+    PRINT_DEF(FLT_MIN_EXP, d);
+    PRINT_DEF(DBL_MIN_EXP, d);
+    PRINT_DEF(LDBL_MIN_EXP, d);
+    PRINT_DEF(FLT_MIN_10_EXP, d);
+    PRINT_DEF(DBL_MIN_10_EXP, d);
+    PRINT_DEF(LDBL_MIN_10_EXP, d);
+    PRINT_DEF(FLT_MAX_EXP, d);
+    PRINT_DEF(DBL_MAX_EXP, d);
+    PRINT_DEF(LDBL_MAX_EXP, d);
+    PRINT_DEF(FLT_MAX_10_EXP, d);
+    PRINT_DEF(DBL_MAX_10_EXP, d);
+    PRINT_DEF(LDBL_MAX_10_EXP, d);
+    PRINT_DEF(FLT_MAX, f); // TODO: float-to-double
+    PRINT_DEF(DBL_MAX, f);
+    PRINT_DEF(LDBL_MAX, Lf);
+    PRINT_DEF(FLT_EPSILON, f); // TODO: float-to-double
+    PRINT_DEF(DBL_EPSILON, f);
+    PRINT_DEF(LDBL_EPSILON, Lf);
+    PRINT_DEF(FLT_MIN, f); // TODO: float-to-double
+    PRINT_DEF(DBL_MIN, f);
+    PRINT_DEF(LDBL_MIN, Lf);
+#if (__STDC_VERSION__ >= 199901L) || (__cplusplus >= 201103L)
+    PRINT_DEF(FLT_EVAL_METHOD, d);
+    PRINT_DEF(DECIMAL_DIG, d);
+#endif
+
+    return 0;
+}
diff --git a/tools/defines/limits.c b/tools/defines/limits.c
new file mode 100644
index 00000000000..0407aefac22
--- /dev/null
+++ b/tools/defines/limits.c
@@ -0,0 +1,32 @@
+#include "limits.h"
+#include "stdio.h"
+
+#define PRINT_DEF(d, f) \
+    fprintf(stdout, ";"#d "=%"#f, d)
+
+int main(void)
+{
+    PRINT_DEF(CHAR_BIT, d);
+    PRINT_DEF(SCHAR_MIN, d);
+    PRINT_DEF(SCHAR_MAX, d);
+    PRINT_DEF(UCHAR_MAX, d);
+    PRINT_DEF(CHAR_MIN, d);
+    PRINT_DEF(CHAR_MAX, d);
+    PRINT_DEF(MB_LEN_MAX, d);
+    PRINT_DEF(SHRT_MIN, d);
+    PRINT_DEF(SHRT_MAX, d);
+    PRINT_DEF(USHRT_MAX, d);
+    PRINT_DEF(INT_MIN, d);
+    PRINT_DEF(INT_MAX, d);
+    PRINT_DEF(UINT_MAX, u);
+    PRINT_DEF(LONG_MIN, ld);
+    PRINT_DEF(LONG_MAX, ld);
+    PRINT_DEF(ULONG_MAX, ld);
+#if (__STDC_VERSION__ >= 199901L) || (__cplusplus >= 201103L)
+    PRINT_DEF(LLONG_MIN, lld);
+    PRINT_DEF(LLONG_MAX, lld);
+    PRINT_DEF(ULLONG_MAX, llu);
+#endif
+
+    return 0;
+}
diff --git a/tools/defines/readme.md b/tools/defines/readme.md
new file mode 100644
index 00000000000..ed9d372c091
--- /dev/null
+++ b/tools/defines/readme.md
@@ -0,0 +1,22 @@
+# Compiler defines
+
+NOTE: this is preliminary.
+
+This folder contains scripts to extract compiler-specific defines and definitions for use with a Cppcheck scan.
+
+Specifying these will get rid of `` warnings (which are reported when `--debug-warnings` is specified) which allows for increased coverage of the ValueFlow.
+
+## Files
+
+- `define.sh`
+Invokes the compilation and execution of the various programs which output the compiler-specific defines.
+- `float.c`
+Outputs the defines provided by `float.h`/`cfloat`.
+- `limits.c`
+Outputs the defines provided by `limits.h`/`climits`.
+- `stdint.c`
+Outputs the defines provided by `stdint.h`/`cstdint`.
+- `create_platform_cfg.sh`
+Generates a platform file from the given compiler which can be given to Cppcheck via `--platform`.
+- `run_cppcheck.sh`
+Generates the compiler-specific configurations for the given compiler and runs Cppcheck with them.
\ No newline at end of file
diff --git a/tools/defines/run_cppcheck.sh b/tools/defines/run_cppcheck.sh
new file mode 100644
index 00000000000..af0567c5832
--- /dev/null
+++ b/tools/defines/run_cppcheck.sh
@@ -0,0 +1,9 @@
+#!/bin/sh
+
+# TODO: use temporary filename
+./create_platform_cfg.sh > platform.cfg
+
+# TODO: add option to pass define to cppcheck
+./defines.sh > defines.txt
+
+./cppcheck --platform=platform.cfg "$@"
\ No newline at end of file
diff --git a/tools/defines/stdint.c b/tools/defines/stdint.c
new file mode 100644
index 00000000000..72fc6c6ead8
--- /dev/null
+++ b/tools/defines/stdint.c
@@ -0,0 +1,44 @@
+#include "stdint.h"
+#include "stdio.h"
+
+#define PRINT_DEF(d, f) \
+    fprintf(stdout, ";"#d "=%"#f, d)
+
+#define PRINT_DEF_N(d1, d2, f) \
+    do { \
+        PRINT_DEF(d1 ## 8 ## d2, f); \
+        PRINT_DEF(d1 ## 16 ## d2, f); \
+        PRINT_DEF(d1 ## 32 ## d2, f); \
+        PRINT_DEF(d1 ## 64 ## d2, l ## f); \
+    } while (0)
+
+// TODO: fix all format specifiers
+int main(void)
+{
+    PRINT_DEF(INTMAX_MIN, ld);
+    PRINT_DEF(INTMAX_MAX, ld);
+    PRINT_DEF(UINTMAX_MAX, lu);
+    PRINT_DEF_N(INT, _MIN, d);
+    PRINT_DEF_N(INT, _MAX, d);
+    PRINT_DEF_N(UINT, _MAX, u);
+    PRINT_DEF_N(INT_LEAST, _MIN, d);
+    PRINT_DEF_N(INT_LEAST, _MAX, d);
+    PRINT_DEF_N(UINT_LEAST, _MAX, u);
+    PRINT_DEF_N(INT_FAST, _MIN, d);
+    PRINT_DEF_N(INT_FAST, _MAX, d);
+    PRINT_DEF_N(UINT_FAST, _MAX, u);
+    PRINT_DEF(INTPTR_MIN, ld);
+    PRINT_DEF(INTPTR_MAX, ld);
+    PRINT_DEF(UINTPTR_MAX, lu);
+    PRINT_DEF(SIZE_MAX, lu);
+    PRINT_DEF(PTRDIFF_MIN, ld);
+    PRINT_DEF(PTRDIFF_MAX, ld);
+    PRINT_DEF(SIG_ATOMIC_MIN, d);
+    PRINT_DEF(SIG_ATOMIC_MAX, d);
+    PRINT_DEF(WCHAR_MIN, d);
+    PRINT_DEF(WCHAR_MAX, d);
+    PRINT_DEF(WINT_MIN, d);
+    PRINT_DEF(WINT_MAX, d);
+
+    return 0;
+}
diff --git a/tools/dmake.cpp b/tools/dmake.cpp
deleted file mode 100644
index d700c42723f..00000000000
--- a/tools/dmake.cpp
+++ /dev/null
@@ -1,496 +0,0 @@
-/*
- * Cppcheck - A tool for static C/C++ code analysis
- * Copyright (C) 2007-2019 Cppcheck team.
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-// Generate Makefile for cppcheck
-
-#include <algorithm>
-#include <fstream>
-#include <iostream>
-#include <string>
-#include <vector>
-#include <sstream>
-
-#include "../cli/filelister.h"
-#include "../lib/pathmatch.h"
-
-static std::string builddir(std::string filename)
-{
-    if (filename.compare(0,4,"lib/") == 0)
-        filename = "$(libcppdir)" + filename.substr(3);
-    return filename;
-}
-
-static std::string objfile(std::string cppfile)
-{
-    cppfile.erase(cppfile.rfind('.'));
-    return builddir(cppfile + ".o");
-}
-
-static std::string objfiles(const std::vector<std::string> &files)
-{
-    std::string allObjfiles;
-    for (const std::string &file : files) {
-        if (file != files.front())
-            allObjfiles += std::string(14, ' ');
-        allObjfiles += objfile(file);
-        if (file != files.back())
-            allObjfiles += " \\\n";
-    }
-    return allObjfiles;
-}
-
-static void getDeps(const std::string &filename, std::vector<std::string> &depfiles)
-{
-    static const std::vector<std::string> externalfolders = {"externals",
-                                                             "externals/simplecpp",
-                                                             "externals/tinyxml"
-                                                            };
-
-    // Is the dependency already included?
-    if (std::find(depfiles.begin(), depfiles.end(), filename) != depfiles.end())
-        return;
-
-    std::ifstream f(filename.c_str());
-    if (! f.is_open()) {
-        /*
-         * Recursively search for includes in other directories.
-         * Files are searched according to the following priority:
-         * [test, tools] -> cli -> lib -> externals
-         */
-        if (filename.compare(0, 4, "cli/") == 0)
-            getDeps("lib" + filename.substr(filename.find('/')), depfiles);
-        else if (filename.compare(0, 5, "test/") == 0)
-            getDeps("cli" + filename.substr(filename.find('/')), depfiles);
-        else if (filename.compare(0, 6, "tools/") == 0)
-            getDeps("cli" + filename.substr(filename.find('/')), depfiles);
-        else if (filename.compare(0, 4, "lib/") == 0) {
-            for (const std::string & external : externalfolders)
-                getDeps(external + filename.substr(filename.find('/')), depfiles);
-        }
-        return;
-    }
-    if (filename.find(".c") == std::string::npos)
-        depfiles.push_back(filename);
-
-    std::string path(filename);
-    if (path.find('/') != std::string::npos)
-        path.erase(1 + path.rfind('/'));
-
-    std::string line;
-    while (std::getline(f, line)) {
-        std::string::size_type pos1 = line.find("#include \"");
-        char rightBracket = '\"';
-        if (pos1 == std::string::npos) {
-            pos1 = line.find("#include <");
-            rightBracket = '>';
-            if (pos1 == std::string::npos)
-                continue;
-        }
-
-        pos1 += 10;
-
-        std::string::size_type pos2 = line.find(rightBracket, pos1);
-        std::string hfile = path + line.substr(pos1, pos2 - pos1);
-
-        if (hfile.find("/../") != std::string::npos)    // TODO: Ugly fix
-            hfile.erase(0, 4 + hfile.find("/../"));
-        getDeps(hfile, depfiles);
-    }
-}
-
-static void compilefiles(std::ostream &fout, const std::vector<std::string> &files, const std::string &args)
-{
-    for (const std::string &file : files) {
-        bool external(file.compare(0,10,"externals/") == 0);
-        fout << objfile(file) << ": " << file;
-        std::vector<std::string> depfiles;
-        getDeps(file, depfiles);
-        std::sort(depfiles.begin(), depfiles.end());
-        for (const std::string &depfile : depfiles)
-            fout << " " << depfile;
-        fout << "\n\t$(CXX) " << args << " $(CPPFLAGS) $(CPPFILESDIR) $(CXXFLAGS)" << (external?" -w":"") << " $(UNDEF_STRICT_ANSI) -c -o " << objfile(file) << " " << builddir(file) << "\n\n";
-    }
-}
-
-static void getCppFiles(std::vector<std::string> &files, const std::string &path, bool recursive)
-{
-    std::map<std::string,size_t> filemap;
-    const std::set<std::string> extra;
-    const std::vector<std::string> masks;
-    const PathMatch matcher(masks);
-    FileLister::addFiles(filemap, path, extra, recursive, matcher);
-
-    // add *.cpp files to the "files" vector..
-    for (const std::pair<const std::string&, size_t> file : filemap) {
-        if (file.first.find(".cpp") != std::string::npos)
-            files.push_back(file.first);
-    }
-}
-
-
-static void makeConditionalVariable(std::ostream &os, const std::string &variable, const std::string &defaultValue)
-{
-    os << "ifndef " << variable << '\n'
-       << "    " << variable << '=' << defaultValue << '\n'
-       << "endif\n"
-       << "\n";
-}
-
-int main(int argc, char **argv)
-{
-    const bool release(argc >= 2 && std::string(argv[1]) == "--release");
-
-    // Get files..
-    std::vector<std::string> libfiles;
-    getCppFiles(libfiles, "lib/", false);
-
-    std::vector<std::string> extfiles;
-    getCppFiles(extfiles, "externals/", true);
-
-    std::vector<std::string> clifiles;
-    getCppFiles(clifiles, "cli/", false);
-
-    std::vector<std::string> testfiles;
-    getCppFiles(testfiles, "test/", false);
-
-    std::vector<std::string> toolsfiles;
-    getCppFiles(toolsfiles, "tools/", false);
-
-    if (libfiles.empty() && clifiles.empty() && testfiles.empty()) {
-        std::cerr << "No files found. Are you in the correct directory?" << std::endl;
-        return EXIT_FAILURE;
-    }
-
-    // QMAKE - lib/lib.pri
-    {
-        std::ofstream fout1("lib/lib.pri");
-        if (fout1.is_open()) {
-            fout1 << "# no manual edits - this file is autogenerated by dmake\n\n";
-            fout1 << "include($$PWD/pcrerules.pri)\n";
-            fout1 << "include($$PWD/../externals/externals.pri)\n";
-            fout1 << "INCLUDEPATH += $$PWD\n";
-            fout1 << "HEADERS += ";
-            for (const std::string &libfile : libfiles) {
-                std::string fname(libfile.substr(4));
-                if (fname.find(".cpp") == std::string::npos)
-                    continue;   // shouldn't happen
-                fname.erase(fname.find(".cpp"));
-                fout1 << "$${PWD}/" << fname << ".h";
-                if (libfile != libfiles.back())
-                    fout1 << " \\\n" << std::string(11, ' ');
-            }
-            fout1 << "\n\nSOURCES += ";
-            for (const std::string &libfile : libfiles) {
-                fout1 << "$${PWD}/" << libfile.substr(4);
-                if (libfile != libfiles.back())
-                    fout1 << " \\\n" << std::string(11, ' ');
-            }
-            fout1 << "\n";
-        }
-    }
-
-    static const char makefile[] = "Makefile";
-    std::ofstream fout(makefile, std::ios_base::trunc);
-    if (!fout.is_open()) {
-        std::cerr << "An error occurred while trying to open "
-                  << makefile
-                  << ".\n";
-        return EXIT_FAILURE;
-    }
-
-    fout << "# This file is generated by tools/dmake, do not edit.\n\n";
-    fout << "# To compile with rules, use 'make HAVE_RULES=yes'\n";
-    makeConditionalVariable(fout, "HAVE_RULES", "no");
-
-    // Z3 is an optional dependency now..
-    makeConditionalVariable(fout, "USE_Z3", "no");
-    fout << "ifeq ($(USE_Z3),yes)\n"
-         << "    CPPFLAGS += -DUSE_Z3\n"
-         << "    LIBS += -lz3\n"
-         << "endif\n";
-
-    // use match compiler..
-    fout << "# use match compiler\n";
-    fout << "ifeq ($(SRCDIR),build)\n"
-         << "    $(warning Usage of SRCDIR to activate match compiler is deprecated. Use MATCHCOMPILER=yes instead.)\n"
-         << "    MATCHCOMPILER:=yes\n"
-         << "endif\n";
-    fout << "ifeq ($(MATCHCOMPILER),yes)\n"
-         << "    ifdef VERIFY\n"
-         << "        matchcompiler_S := $(shell python tools/matchcompiler.py --verify)\n"
-         << "    else\n"
-         << "        matchcompiler_S := $(shell python tools/matchcompiler.py)\n"
-         << "    endif\n"
-         << "    libcppdir:=build\n"
-         << "else\n"
-         << "    libcppdir:=lib\n"
-         << "endif\n\n";
-
-    // explicit files dir..
-    fout << "ifdef FILESDIR\n"
-         << "    CPPFILESDIR=-DFILESDIR=\\\"$(FILESDIR)\\\"\n"
-         << "else\n"
-         << "    CPPFILESDIR=\n"
-         << "endif\n\n";
-
-    // enable backtrac
-    fout << "RDYNAMIC=-rdynamic\n";
-
-    // The _GLIBCXX_DEBUG doesn't work in cygwin or other Win32 systems.
-    fout << "# Set the CPPCHK_GLIBCXX_DEBUG flag. This flag is not used in release Makefiles.\n"
-         << "# The _GLIBCXX_DEBUG define doesn't work in Cygwin or other Win32 systems.\n"
-         << "ifndef COMSPEC\n"
-         << "    ifdef ComSpec\n"
-         << "        #### ComSpec is defined on some WIN32's.\n"
-         << "        COMSPEC=$(ComSpec)\n"
-         << "    endif # ComSpec\n"
-         << "endif # COMSPEC\n"
-         << "\n"
-         << "ifdef COMSPEC\n"
-         << "    #### Maybe Windows\n"
-         << "    ifndef CPPCHK_GLIBCXX_DEBUG\n"
-         << "        CPPCHK_GLIBCXX_DEBUG=\n"
-         << "    endif # !CPPCHK_GLIBCXX_DEBUG\n"
-         << "\n"
-         << "    ifeq ($(MSYSTEM),MINGW32 MINGW64)\n"
-         << "        LDFLAGS=-lshlwapi\n"
-         << "    else\n"
-         << "        RDYNAMIC=-lshlwapi\n"
-         << "    endif\n"
-         << "else # !COMSPEC\n"
-         << "    uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')\n"
-         << "\n"
-         << "    ifeq ($(uname_S),Linux)\n"
-         << "        ifndef CPPCHK_GLIBCXX_DEBUG\n"
-         << "            CPPCHK_GLIBCXX_DEBUG=-D_GLIBCXX_DEBUG\n"
-         << "        endif # !CPPCHK_GLIBCXX_DEBUG\n"
-         << "    endif # Linux\n"
-         << "\n"
-         << "    ifeq ($(uname_S),GNU/kFreeBSD)\n"
-         << "        ifndef CPPCHK_GLIBCXX_DEBUG\n"
-         << "            CPPCHK_GLIBCXX_DEBUG=-D_GLIBCXX_DEBUG\n"
-         << "        endif # !CPPCHK_GLIBCXX_DEBUG\n"
-         << "    endif # GNU/kFreeBSD\n"
-         << "\n"
-         << "endif # COMSPEC\n"
-         << "\n";
-
-    // tinymxl2 requires __STRICT_ANSI__ to be undefined to compile under CYGWIN.
-    fout << "# Set the UNDEF_STRICT_ANSI flag to address compile time warnings\n"
-         << "# with tinyxml2 and Cygwin.\n"
-         << "ifdef COMSPEC\n"
-         << "    uname_S := $(shell uname -s)\n"
-         << "\n"
-         << "    ifneq (,$(findstring CYGWIN,$(uname_S)))\n"
-         << "        UNDEF_STRICT_ANSI=-U__STRICT_ANSI__\n"
-         << "    endif # CYGWIN\n"
-         << "endif # COMSPEC\n"
-         << "\n";
-
-    // skip "-D_GLIBCXX_DEBUG" if clang, since it breaks the build
-    makeConditionalVariable(fout, "CXX", "g++");
-    fout << "ifeq (clang++, $(findstring clang++,$(CXX)))\n"
-         << "    CPPCHK_GLIBCXX_DEBUG=\n"
-         << "endif\n";
-
-    // Makefile settings..
-    if (release) {
-        makeConditionalVariable(fout, "CXXFLAGS", "-std=c++0x -O2 -DNDEBUG -Wall -Wno-sign-compare");
-    } else {
-        // TODO: add more compiler warnings.
-        // -Wlogical-op       : doesn't work on older GCC
-        // -Wsign-conversion  : too many warnings
-        // -Wunreachable-code : some GCC versions report lots of warnings
-        makeConditionalVariable(fout, "CXXFLAGS",
-                                "-pedantic "
-                                "-Wall "
-                                "-Wextra "
-                                "-Wcast-qual "
-//                                "-Wconversion "  // danmar: gives fp. for instance: unsigned int sizeof_pointer = sizeof(void *);
-                                "-Wno-deprecated-declarations "
-                                "-Wfloat-equal "
-//                                "-Wlogical-op "
-                                "-Wmissing-declarations "
-                                "-Wmissing-format-attribute "
-                                "-Wno-long-long "
-//                                "-Woverloaded-virtual "  // danmar: we get fp when overloading analyseWholeProgram()
-                                "-Wpacked "
-                                "-Wredundant-decls "
-                                "-Wundef "
-                                "-Wno-shadow "
-//                                "-Wsign-conversion "
-//                                "-Wsign-promo "
-                                "-Wno-missing-field-initializers "
-                                "-Wno-missing-braces "
-//                                "-Wunreachable-code "
-                                "-Wno-sign-compare "  // danmar: I don't like this warning, it's very rarely a bug
-                                "-Wno-multichar "
-                                "$(CPPCHK_GLIBCXX_DEBUG) "
-                                "-g");
-    }
-
-    fout << "# Increase stack size for Cygwin builds to avoid segmentation fault in limited recursive tests.\n"
-         << "ifdef COMSPEC\n"
-         << "    uname_S := $(shell uname -s)\n"
-         << "\n"
-         << "    ifneq (,$(findstring CYGWIN,$(uname_S)))\n"
-         << "        CXXFLAGS+=-Wl,--stack,8388608\n"
-         << "    endif # CYGWIN\n"
-         << "endif # COMSPEC\n"
-         << "\n";
-
-    fout << "ifeq (g++, $(findstring g++,$(CXX)))\n"
-         << "    override CXXFLAGS += -std=c++0x\n"
-         << "else ifeq (clang++, $(findstring clang++,$(CXX)))\n"
-         << "    override CXXFLAGS += -std=c++0x\n"
-         << "else ifeq ($(CXX), c++)\n"
-         << "    ifeq ($(shell uname -s), Darwin)\n"
-         << "        override CXXFLAGS += -std=c++0x\n"
-         << "    endif\n"
-         << "endif\n"
-         << "\n";
-
-    fout << "ifeq ($(HAVE_RULES),yes)\n"
-         << "    override CXXFLAGS += -DHAVE_RULES -DTIXML_USE_STL $(shell pcre-config --cflags)\n"
-         << "    ifdef LIBS\n"
-         << "        LIBS += $(shell pcre-config --libs)\n"
-         << "    else\n"
-         << "        LIBS=$(shell pcre-config --libs)\n"
-         << "    endif\n"
-         << "endif\n\n";
-
-    makeConditionalVariable(fout, "PREFIX", "/usr");
-    makeConditionalVariable(fout, "INCLUDE_FOR_LIB", "-Ilib -isystem externals -isystem externals/simplecpp -isystem externals/tinyxml");
-    makeConditionalVariable(fout, "INCLUDE_FOR_CLI", "-Ilib -isystem externals/simplecpp -isystem externals/tinyxml");
-    makeConditionalVariable(fout, "INCLUDE_FOR_TEST", "-Ilib -Icli -isystem externals/simplecpp -isystem externals/tinyxml");
-
-    fout << "BIN=$(DESTDIR)$(PREFIX)/bin\n\n";
-    fout << "# For 'make man': sudo apt-get install xsltproc docbook-xsl docbook-xml on Linux\n";
-    fout << "DB2MAN?=/usr/share/sgml/docbook/stylesheet/xsl/nwalsh/manpages/docbook.xsl\n";
-    fout << "XP=xsltproc -''-nonet -''-param man.charmap.use.subset \"0\"\n";
-    fout << "MAN_SOURCE=man/cppcheck.1.xml\n\n";
-
-    fout << "\n###### Object Files\n\n";
-    fout << "LIBOBJ =      " << objfiles(libfiles) << "\n\n";
-    fout << "EXTOBJ =      " << objfiles(extfiles) << "\n\n";
-    fout << "CLIOBJ =      " << objfiles(clifiles) << "\n\n";
-    fout << "TESTOBJ =     " << objfiles(testfiles) << "\n\n";
-
-    fout << ".PHONY: run-dmake tags\n\n";
-    fout << "\n###### Targets\n\n";
-    fout << "cppcheck: $(LIBOBJ) $(CLIOBJ) $(EXTOBJ)\n";
-    fout << "\t$(CXX) $(CPPFLAGS) $(CXXFLAGS) -o $@ $^ $(LIBS) $(LDFLAGS) $(RDYNAMIC)\n\n";
-    fout << "all:\tcppcheck testrunner\n\n";
-    fout << "testrunner: $(TESTOBJ) $(LIBOBJ) $(EXTOBJ) cli/threadexecutor.o cli/cmdlineparser.o cli/cppcheckexecutor.o cli/filelister.o\n";
-    fout << "\t$(CXX) $(CPPFLAGS) $(CXXFLAGS) -o $@ $^ $(LIBS) $(LDFLAGS) $(RDYNAMIC)\n\n";
-    fout << "test:\tall\n";
-    fout << "\t./testrunner\n\n";
-    fout << "check:\tall\n";
-    fout << "\t./testrunner -q\n\n";
-    fout << "checkcfg:\tcppcheck validateCFG\n";
-    fout << "\t./test/cfg/runtests.sh\n\n";
-    fout << "dmake:\ttools/dmake.o cli/filelister.o $(libcppdir)/pathmatch.o $(libcppdir)/path.o externals/simplecpp/simplecpp.o\n";
-    fout << "\t$(CXX) $(CXXFLAGS) -o $@ $^ $(LDFLAGS)\n\n";
-    fout << "run-dmake: dmake\n";
-    fout << "\t./dmake\n\n";
-    fout << "generate_cfg_tests: tools/generate_cfg_tests.o $(EXTOBJ)\n";
-    fout << "\tg++ -isystem externals/tinyxml -o generate_cfg_tests tools/generate_cfg_tests.o $(EXTOBJ)\n";
-    fout << "clean:\n";
-    fout << "\trm -f build/*.o lib/*.o cli/*.o test/*.o tools/*.o externals/*/*.o testrunner dmake cppcheck cppcheck.exe cppcheck.1\n\n";
-    fout << "man:\tman/cppcheck.1\n\n";
-    fout << "man/cppcheck.1:\t$(MAN_SOURCE)\n\n";
-    fout << "\t$(XP) $(DB2MAN) $(MAN_SOURCE)\n\n";
-    fout << "tags:\n";
-    fout << "\tctags -R --exclude=doxyoutput --exclude=test/cfg --exclude=test/synthetic cli externals gui lib test\n\n";
-    fout << "install: cppcheck\n";
-    fout << "\tinstall -d ${BIN}\n";
-    fout << "\tinstall cppcheck ${BIN}\n";
-    fout << "\tinstall htmlreport/cppcheck-htmlreport ${BIN}\n";
-    fout << "ifdef FILESDIR\n";
-    fout << "\tinstall -d ${DESTDIR}${FILESDIR}\n";
-    fout << "\tinstall -d ${DESTDIR}${FILESDIR}/addons\n";
-    fout << "\tinstall -m 644 addons/*.py ${DESTDIR}${FILESDIR}/addons\n";
-    fout << "\tinstall -d ${DESTDIR}${FILESDIR}/cfg\n";
-    fout << "\tinstall -m 644 cfg/*.cfg ${DESTDIR}${FILESDIR}/cfg\n";
-    fout << "\tinstall -d ${DESTDIR}${FILESDIR}/platforms\n";
-    fout << "\tinstall -m 644 platforms/*.xml ${DESTDIR}${FILESDIR}/platforms\n";
-    fout << "else\n";
-    fout << "\t$(error FILESDIR must be set!)\n";
-    fout << "endif\n";
-    fout << "\n";
-    fout << "uninstall:\n";
-    fout << "\t@if test -d ${BIN}; then \\\n";
-    fout << "\t  files=\"cppcheck cppcheck-htmlreport\"; \\\n";
-    fout << "\t  echo '(' cd ${BIN} '&&' rm -f $$files ')'; \\\n";
-    fout << "\t  ( cd ${BIN} && rm -f $$files ); \\\n";
-    fout << "\tfi\n";
-    fout << "ifdef FILESDIR \n";
-    fout << "\t@if test -d ${DESTDIR}${FILESDIR}; then \\\n";
-    fout << "\t  echo rm -rf ${DESTDIR}${FILESDIR}; \\\n";
-    fout << "\t  rm -rf ${DESTDIR}${FILESDIR}; \\\n";
-    fout << "\tfi\n";
-    fout << "endif\n";
-    fout << "ifdef CFGDIR \n";
-    fout << "\t@if test -d ${DESTDIR}${CFGDIR}; then \\\n";
-    fout << "\t  files=\"`cd cfg 2>/dev/null && ls`\"; \\\n";
-    fout << "\t  if test -n \"$$files\"; then \\\n";
-    fout << "\t    echo '(' cd ${DESTDIR}${CFGDIR} '&&' rm -f $$files ')'; \\\n";
-    fout << "\t    ( cd ${DESTDIR}${CFGDIR} && rm -f $$files ); \\\n";
-    fout << "\t  fi; \\\n";
-    fout << "\tfi\n";
-    fout << "endif\n\n";
-    fout << "# Validation of library files:\n";
-    fout << "ConfigFiles := $(wildcard cfg/*.cfg)\n";
-    fout << "ConfigFilesCHECKED := $(patsubst %.cfg,%.checked,$(ConfigFiles))\n";
-    fout << ".PHONY: validateCFG\n";
-    fout << "%.checked:%.cfg\n";
-    fout << "\txmllint --noout --relaxng cfg/cppcheck-cfg.rng $<\n";
-    fout << "validateCFG: ${ConfigFilesCHECKED}\n\n";
-    fout << "# Validation of platforms files:\n";
-    fout << "PlatformFiles := $(wildcard platforms/*.xml)\n";
-    fout << "PlatformFilesCHECKED := $(patsubst %.xml,%.checked,$(PlatformFiles))\n";
-    fout << ".PHONY: validatePlatforms\n";
-    fout << "%.checked:%.xml\n";
-    fout << "\txmllint --noout --relaxng platforms/cppcheck-platforms.rng $<\n";
-    fout << "validatePlatforms: ${PlatformFilesCHECKED}\n\n";
-    fout << "# Validate XML output (to detect regressions)\n";
-    fout << "/tmp/errorlist.xml: cppcheck\n";
-    fout << "\t./cppcheck --errorlist >$@\n";
-    fout << "/tmp/example.xml: cppcheck\n";
-    fout << "\t./cppcheck --xml --enable=all --inconclusive --suppress=operatorEqVarError:*check.h -j 4 cli externals gui lib test 2>/tmp/example.xml\n";
-    fout << "createXMLExamples:/tmp/errorlist.xml /tmp/example.xml\n";
-    fout << ".PHONY: validateXML\n";
-    fout << "validateXML: createXMLExamples\n";
-    fout << "\txmllint --noout --relaxng cppcheck-errors.rng /tmp/errorlist.xml\n";
-    fout << "\txmllint --noout --relaxng cppcheck-errors.rng /tmp/example.xml\n";
-    fout << "\ncheckCWEEntries: /tmp/errorlist.xml\n";
-    fout << "\t./tools/listErrorsWithoutCWE.py -F /tmp/errorlist.xml\n";
-    fout << ".PHONY: validateRules\n",
-         fout << "validateRules:\n";
-    fout << "\txmllint --noout rules/*.xml\n";
-
-    fout << "\n###### Build\n\n";
-
-    compilefiles(fout, libfiles, "${INCLUDE_FOR_LIB}");
-    compilefiles(fout, clifiles, "${INCLUDE_FOR_CLI}");
-    compilefiles(fout, testfiles, "${INCLUDE_FOR_TEST}");
-    compilefiles(fout, extfiles, "");
-    compilefiles(fout, toolsfiles, "${INCLUDE_FOR_LIB}");
-
-    return 0;
-}
diff --git a/tools/dmake.sln b/tools/dmake.sln
deleted file mode 100644
index 0b79849fc25..00000000000
--- a/tools/dmake.sln
+++ /dev/null
@@ -1,20 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 2012
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "dmake", "dmake.vcxproj", "{19EC86CD-0004-4917-B852-E6BD110B6E6F}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
-		Release|Win32 = Release|Win32
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{19EC86CD-0004-4917-B852-E6BD110B6E6F}.Debug|Win32.ActiveCfg = Debug|Win32
-		{19EC86CD-0004-4917-B852-E6BD110B6E6F}.Debug|Win32.Build.0 = Debug|Win32
-		{19EC86CD-0004-4917-B852-E6BD110B6E6F}.Release|Win32.ActiveCfg = Release|Win32
-		{19EC86CD-0004-4917-B852-E6BD110B6E6F}.Release|Win32.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal
diff --git a/tools/dmake.vcxproj b/tools/dmake.vcxproj
deleted file mode 100644
index 5e781cf2cd6..00000000000
--- a/tools/dmake.vcxproj
+++ /dev/null
@@ -1,113 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{19EC86CD-0004-4917-B852-E6BD110B6E6F}</ProjectGuid>
-    <RootNamespace>dmake</RootNamespace>
-    <Keyword>Win32Proj</Keyword>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <PlatformToolset>v110</PlatformToolset>
-    <CharacterSet>NotSet</CharacterSet>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <PlatformToolset>v110</PlatformToolset>
-    <CharacterSet>NotSet</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup>
-    <_ProjectFileVersion>11.0.61030.0</_ProjectFileVersion>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <OutDir>..\Build\$(Configuration)\</OutDir>
-    <IntDir>..\BuildTmp\$(TargetName)\$(Configuration)\</IntDir>
-    <IgnoreImportLibrary>true</IgnoreImportLibrary>
-    <LinkIncremental />
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <OutDir>..\Build\$(Configuration)\</OutDir>
-    <IntDir>..\BuildTmp\$(TargetName)\$(Configuration)\</IntDir>
-    <LinkIncremental>false</LinkIncremental>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>..\lib;..\externals\simplecpp;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MinimalRebuild>true</MinimalRebuild>
-      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
-      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
-      <BufferSecurityCheck>false</BufferSecurityCheck>
-      <PrecompiledHeader />
-      <AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>
-      <WarningLevel>Level3</WarningLevel>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <OutputFile>$(OutDir)dmake.exe</OutputFile>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <SubSystem>Console</SubSystem>
-      <TargetMachine>MachineX86</TargetMachine>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <Optimization>MaxSpeed</Optimization>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <AdditionalIncludeDirectories>..\lib;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>WIN32;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <PrecompiledHeader />
-      <AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>
-      <WarningLevel>Level3</WarningLevel>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>shlwapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <OutputFile>$(OutDir)dmake.exe</OutputFile>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <SubSystem>Console</SubSystem>
-      <OptimizeReferences>true</OptimizeReferences>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <TargetMachine>MachineX86</TargetMachine>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClCompile Include="..\externals\simplecpp\simplecpp.cpp" />
-    <ClCompile Include="..\lib\pathmatch.cpp" />
-    <ClCompile Include="dmake.cpp" />
-    <ClCompile Include="..\cli\filelister.cpp" />
-    <ClCompile Include="..\lib\path.cpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="..\cli\filelister.h" />
-    <ClInclude Include="..\lib\path.h" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>
\ No newline at end of file
diff --git a/tools/dmake/CMakeLists.txt b/tools/dmake/CMakeLists.txt
new file mode 100644
index 00000000000..cbe7040ef2f
--- /dev/null
+++ b/tools/dmake/CMakeLists.txt
@@ -0,0 +1,16 @@
+
+add_executable(dmake EXCLUDE_FROM_ALL
+        dmake.cpp
+)
+target_link_libraries(dmake cppcheck-core cli simplecpp)
+if (WIN32 AND NOT BORLAND)
+    if(NOT MINGW)
+        target_link_libraries(dmake Shlwapi.lib)
+    else()
+        target_link_libraries(dmake shlwapi)
+    endif()
+endif()
+
+add_custom_target(run-dmake $<TARGET_FILE:dmake>
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        DEPENDS dmake)
diff --git a/tools/dmake/dmake.cpp b/tools/dmake/dmake.cpp
new file mode 100644
index 00000000000..82754f1df11
--- /dev/null
+++ b/tools/dmake/dmake.cpp
@@ -0,0 +1,918 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2023 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// Generate Makefile for cppcheck
+
+#include <algorithm>
+#include <array>
+#include <cstdint>
+#include <cstdlib>
+#include <fstream>
+#include <functional>
+#include <iostream>
+#include <list>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "../cli/filelister.h"
+#include "../lib/filesettings.h"
+#include "../lib/path.h"
+#include "../lib/pathmatch.h"
+#include "../lib/utils.h"
+
+static std::string builddir(std::string filename)
+{
+    if (startsWith(filename,"lib/"))
+        filename = "$(libcppdir)" + filename.substr(3);
+    else if (startsWith(filename, "../lib/")) // oss-fuzz
+        filename = "$(libcppdir)" + filename.substr(6);
+
+    return filename;
+}
+
+static std::string objfile(std::string cppfile)
+{
+    cppfile.erase(cppfile.rfind('.'));
+    if (startsWith(cppfile, "../externals/simplecpp/")) // oss-fuzz
+        cppfile = cppfile.substr(23);
+    else if (startsWith(cppfile, "../externals/tinyxml2/")) // oss-fuzz
+        cppfile = cppfile.substr(22);
+    return builddir(cppfile + ".o");
+}
+
+static std::string objfiles(const std::vector<std::string> &files)
+{
+    std::string allObjfiles;
+    for (const std::string &file : files) {
+        if (file != files.front())
+            allObjfiles += std::string(14, ' ');
+        allObjfiles += objfile(file);
+        if (file != files.back())
+            allObjfiles += " \\\n";
+    }
+    return allObjfiles;
+}
+
+static void getDeps(std::string filename, std::vector<std::string> &depfiles)
+{
+    static const std::array<std::string, 3> externalfolders{"externals/picojson", "externals/simplecpp", "externals/tinyxml2"};
+    static const std::array<std::string, 3> externalfolders_rel{"../externals/picojson", "../externals/simplecpp", "../externals/tinyxml2"};
+
+    // Is the dependency already included?
+    if (std::find(depfiles.cbegin(), depfiles.cend(), filename) != depfiles.cend())
+        return;
+
+    const bool relative = startsWith(filename, "../"); // oss-fuzz
+    if (relative)
+        filename = filename.substr(3);
+
+    std::ifstream f(filename.c_str());
+    if (!f.is_open()) {
+        /*
+         * Recursively search for includes in other directories.
+         * Files are searched according to the following priority:
+         * [test, tools] -> cli -> lib -> externals
+         */
+        if (startsWith(filename, "frontend/"))
+            getDeps("lib" + filename.substr(filename.find('/')), depfiles);
+        if (startsWith(filename, "cli/"))
+            getDeps("lib" + filename.substr(filename.find('/')), depfiles);
+        else if (startsWith(filename, "test/"))
+            getDeps("cli" + filename.substr(filename.find('/')), depfiles);
+        else if (startsWith(filename, "tools"))
+            getDeps("cli" + filename.substr(filename.find('/')), depfiles);
+        else if (startsWith(filename, "lib/")) {
+            const auto& extfolders = relative ? externalfolders_rel : externalfolders;
+            for (const std::string & external : extfolders)
+                getDeps(external + filename.substr(filename.find('/')), depfiles);
+        }
+        return;
+    }
+    if (filename.find(".c") == std::string::npos)
+    {
+        if (relative)
+            depfiles.push_back("../" + filename);
+        else
+            depfiles.push_back(filename);
+    }
+
+    std::string path(filename);
+    if (path.find('/') != std::string::npos)
+        path.erase(1 + path.rfind('/'));
+
+    std::string line;
+    while (std::getline(f, line)) {
+        std::string::size_type pos1 = line.find("#include \"");
+        char rightBracket = '\"';
+        if (pos1 == std::string::npos) {
+            pos1 = line.find("#include <");
+            rightBracket = '>';
+            if (pos1 == std::string::npos)
+                continue;
+        }
+
+        pos1 += 10;
+
+        const std::string::size_type pos2 = line.find(rightBracket, pos1);
+        std::string hfile(path);
+        hfile += line.substr(pos1, pos2 - pos1);
+
+        const std::string::size_type traverse_pos = hfile.find("/../");
+        if (traverse_pos != std::string::npos)    // TODO: Ugly fix
+            hfile.erase(0, 4 + traverse_pos);
+        // no need to look up extension-less headers
+        if (!endsWith(hfile, ".h"))
+            continue;
+        if (relative)
+            hfile = "../" + hfile;
+        getDeps(hfile, depfiles);
+    }
+}
+
+static void compilefiles(std::ostream &fout, const std::vector<std::string> &files, const std::string &args)
+{
+    for (const std::string &file : files) {
+        const bool external(startsWith(file,"externals/") || startsWith(file,"../externals/"));
+        const bool tinyxml2(startsWith(file,"externals/tinyxml2/") || startsWith(file,"../externals/tinyxml2/"));
+        fout << objfile(file) << ": " << file;
+        std::vector<std::string> depfiles;
+        getDeps(file, depfiles);
+        std::sort(depfiles.begin(), depfiles.end());
+        for (const std::string &depfile : depfiles)
+            fout << " " << depfile;
+        std::string additional;
+        if (external)
+            additional += " -w"; // do not show any warnings for external
+        if (tinyxml2)
+            additional += " -D_LARGEFILE_SOURCE"; // required for fseeko() and ftello() (on Cygwin)
+        fout << "\n\t$(CXX) " << args << " $(CPPFLAGS) $(CXXFLAGS)" << additional << " -c -o $@ " << builddir(file) << "\n\n";
+    }
+}
+
+static std::string getCppFiles(std::vector<std::string> &files, const std::string &path, bool recursive)
+{
+    std::list<FileWithDetails> filelist;
+    const std::set<std::string> extra;
+    const std::vector<std::string> masks;
+    const PathMatch matcher(masks, Path::getCurrentPath());
+    std::string err = FileLister::addFiles(filelist, path, extra, recursive, matcher);
+    if (!err.empty())
+        return err;
+
+    // add *.cpp files to the "files" vector..
+    for (const auto& file : filelist) {
+        if (endsWith(file.path(), ".cpp"))
+            files.push_back(file.path());
+    }
+    return "";
+}
+
+
+static void makeConditionalVariable(std::ostream &os, const std::string &variable, const std::string &defaultValue)
+{
+    os << "ifndef " << variable << '\n'
+       << "    " << variable << '=' << defaultValue << '\n'
+       << "endif\n"
+       << "\n";
+}
+
+static int write_vcxproj(const std::string &proj_name, const std::function<void(std::string&)> &source_f, const std::function<void(std::string&)> &header_f)
+{
+    std::string outstr;
+
+    {
+        // treat as binary to prevent implicit line ending conversions
+        std::ifstream in(proj_name, std::ios::binary);
+        if (!in.is_open()) {
+            std::cerr << "Could not open " << proj_name << std::endl;
+            return EXIT_FAILURE;
+        }
+
+        std::string line;
+        bool in_itemgroup = false;
+        while (std::getline(in, line)) {
+            if (in_itemgroup) {
+                if (line.find("</ItemGroup>") == std::string::npos)
+                    continue;
+                in_itemgroup = false;
+            }
+
+            // strip all remaining line endings
+            const std::string::size_type pos = line.find_last_not_of("\r\n");
+            if (pos != std::string::npos)
+                line.resize(pos+1, '\0');
+
+            outstr += line;
+            outstr += "\r\n";
+
+            if (line.find("<ItemGroup Label=\"SourceFiles\">") != std::string::npos) {
+                in_itemgroup = true;
+
+                source_f(outstr);
+            }
+
+            if (line.find("<ItemGroup Label=\"HeaderFiles\">") != std::string::npos) {
+                in_itemgroup = true;
+
+                header_f(outstr);
+            }
+        }
+    }
+
+    // strip trailing \r\n
+    {
+        const std::string::size_type pos = outstr.find_last_not_of("\r\n");
+        if (pos != std::string::npos)
+            outstr.resize(pos+1, '\0');
+    }
+
+    // treat as binary to prevent implicit line ending conversions
+    std::ofstream out(proj_name, std::ios::binary|std::ios::trunc);
+    out << outstr;
+
+    return EXIT_SUCCESS;
+}
+
+enum ClType : std::uint8_t { Compile, Include, Precompile, NoPch };
+
+static std::string make_vcxproj_cl_entry(const std::string& file, ClType type)
+{
+    std::string outstr;
+    if (type == Precompile) {
+        outstr += R"(    <ClCompile Include=")";
+        outstr += file;
+        outstr += R"(">)";
+        outstr += "\r\n";
+        outstr += R"(      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>)";
+        outstr += "\r\n";
+        outstr += R"(      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>)";
+        outstr += "\r\n";
+        outstr += R"(      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release-PCRE|x64'">Create</PrecompiledHeader>)";
+        outstr += "\r\n";
+        outstr += R"(      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug-PCRE|x64'">Create</PrecompiledHeader>)";
+        outstr += "\r\n";
+        outstr += "    </ClCompile>\r\n";
+        return outstr;
+    }
+    if (type == NoPch) {
+        outstr += R"(    <ClCompile Include=")";
+        outstr += file;
+        outstr += R"(">)";
+        outstr += "\r\n";
+        outstr += R"(      <PrecompiledHeader>NotUsing</PrecompiledHeader>)";
+        outstr += "\r\n";
+        outstr += R"(      <ForcedIncludeFiles></ForcedIncludeFiles>)";
+        outstr += "\r\n";
+        outstr += "    </ClCompile>\r\n";
+        return outstr;
+    }
+    outstr += "    <";
+    outstr += (type == Compile) ? "ClCompile" : "ClInclude";
+    outstr += R"( Include=")";
+    outstr += file;
+    outstr += R"(" />)";
+    outstr += "\r\n";
+    return outstr;
+}
+
+static std::vector<std::string> prioritizelib(const std::vector<std::string>& libfiles)
+{
+    std::map<std::string, std::size_t> priorities;
+    std::size_t prio = libfiles.size();
+    for (const auto &l : libfiles) {
+        priorities.emplace(l, prio--);
+    }
+    priorities["lib/valueflow.cpp"] = 1000;
+    priorities["lib/tokenize.cpp"] = 900;
+    priorities["lib/symboldatabase.cpp"] = 800;
+    std::vector<std::string> libfiles_prio = libfiles;
+    std::sort(libfiles_prio.begin(), libfiles_prio.end(), [&](const std::string &l1, const std::string &l2) {
+        const auto p1 = priorities.find(l1);
+        const auto p2 = priorities.find(l2);
+        return (p1 != priorities.end() ? p1->second : 0) > (p2 != priorities.end() ? p2->second : 0);
+    });
+    return libfiles_prio;
+}
+
+static void makeMatchcompiler(std::ostream& fout, const std::string& toolsPrefix, std::string args)
+{
+    if (!args.empty())
+        args = " " + args;
+
+    // avoid undefined variable
+    fout << "ifndef MATCHCOMPILER\n"
+         << "    MATCHCOMPILER=\n"
+         << "endif\n";
+    // TODO: bail out when matchcompiler.py fails (i.e. invalid PYTHON_INTERPRETER specified)
+    // TODO: handle "PYTHON_INTERPRETER="
+    // use match compiler..
+    fout << "# use match compiler\n";
+    fout << "ifeq ($(MATCHCOMPILER),yes)\n"
+         << "    # Find available Python interpreter\n"
+         << "    ifeq ($(PYTHON_INTERPRETER),)\n"
+         << "        PYTHON_INTERPRETER := $(shell which python3)\n"
+         << "    endif\n"
+         << "    ifeq ($(PYTHON_INTERPRETER),)\n"
+         << "        PYTHON_INTERPRETER := $(shell which python)\n"
+         << "    endif\n"
+         << "    ifeq ($(PYTHON_INTERPRETER),)\n"
+         << "        $(error Did not find a Python interpreter)\n"
+         << "    endif\n"
+         << "    ifdef VERIFY\n"
+         << "        matchcompiler_S := $(shell $(PYTHON_INTERPRETER) " << toolsPrefix << "tools/matchcompiler.py" << args << " --verify)\n"
+         << "    else\n"
+         << "        matchcompiler_S := $(shell $(PYTHON_INTERPRETER) " << toolsPrefix << "tools/matchcompiler.py" << args << ")\n"
+         << "    endif\n"
+         << "    libcppdir:=build\n"
+         << "else ifeq ($(MATCHCOMPILER),)\n"
+         << "    libcppdir:=lib\n"
+         << "else\n"
+         << "    $(error invalid MATCHCOMPILER value '$(MATCHCOMPILER)')\n"
+         << "endif\n\n";
+}
+
+static void write_ossfuzz_makefile(std::vector<std::string> libfiles_prio, std::vector<std::string> extfiles)
+{
+    for (auto& l : libfiles_prio)
+    {
+        l = "../" + l;
+    }
+
+    for (auto& e : extfiles)
+    {
+        e = "../" + e;
+    }
+
+    std::ofstream fout("oss-fuzz/Makefile");
+
+    fout << "# This file is generated by dmake, do not edit.\n";
+    fout << '\n';
+    fout << "# make CXX=clang++ MATCHCOMPILER=yes CXXOPTS=\"-O1 -fno-omit-frame-pointer -gline-tables-only -fsanitize=address -fsanitize-address-use-after-scope\" CPPOPTS=\"-DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION -DHAVE_BOOST\" LIB_FUZZING_ENGINE=\"-fsanitize=fuzzer\" oss-fuzz-client\n";
+    fout << '\n';
+    fout << "MATCHCOMPILER=yes\n"; // always need to enable the matchcompiler so the library files are being copied
+    makeMatchcompiler(fout, "../", "--read-dir ../lib");
+
+    fout << "INCS=-I../lib -isystem../externals/simplecpp -isystem../externals/tinyxml2 -isystem../externals/picojson\n";
+    fout << '\n';
+    fout << "override CXXFLAGS+=-std=c++11 -g -w\n";
+    fout << "override CPPFLAGS+=$(INCS)\n";
+    fout << '\n';
+    fout << "override CXXFLAGS += $(CXXOPTS)\n";
+    fout << "override CPPFLAGS += $(CPPOPTS)\n";
+    fout << "override LDFLAGS += $(LDOPTS)\n";
+    fout << '\n';
+    fout << "LIBOBJ =      " << objfiles(libfiles_prio) << "\n";
+    fout << '\n';
+    fout << "EXTOBJ =      " << objfiles(extfiles) << "\n";
+    fout << '\n';
+    fout << "oss-fuzz-client: $(EXTOBJ) $(LIBOBJ) main.o type2.o\n";
+    fout << "\t${CXX} ${CXXFLAGS} -o $@ $^ ${LIB_FUZZING_ENGINE}\n";
+    fout << '\n';
+    fout << "no-fuzz: $(EXTOBJ) $(LIBOBJ) main_nofuzz.o type2.o\n";
+    fout << "\t${CXX} ${CXXFLAGS} -o $@ $^\n";
+    fout << '\n';
+    fout << "translate: translate.o type2.o\n";
+    fout << "\t${CXX} -std=c++11 -g ${CXXFLAGS} -o $@ type2.cpp translate.cpp\n";
+    fout << '\n';
+    fout << "clean:\n";
+    fout << "\trm -f *.o build/*.o oss-fuzz-client no-fuzz translate\n";
+    fout << '\n';
+    fout << "preprare-samples:\n";
+    fout << "\trm -rf samples\n";
+    fout << "\tmkdir -p samples\n";
+    fout << "\tcp -R ../samples .\n";
+    fout << "\tfind ./samples -type f -name '*.txt' -exec rm -vf {} \\;\n";
+    fout << '\n';
+    fout << "do-fuzz: oss-fuzz-client preprare-samples\n";
+    fout << "\tmkdir -p corpus\n";
+    fout << "\t./oss-fuzz-client -only_ascii=1 -timeout=5 -detect_leaks=0 corpus samples ../test/cli/fuzz-crash ../test/cli/fuzz-crash_c ../test/cli/fuzz-timeout\n";
+    fout << '\n';
+    fout << "dedup-corpus: oss-fuzz-client preprare-samples\n";
+    fout << "\tmv corpus corpus_\n";
+    fout << "\tmkdir -p corpus\n";
+    fout << "\t./oss-fuzz-client -only_ascii=1 -timeout=5 -detect_leaks=0 corpus corpus_ samples ../test/cli/fuzz-crash ../test/cli/fuzz-crash_c ../test/cli/fuzz-timeout -merge=1\n";
+    fout << '\n';
+    fout << "# jobs:\n";
+    fout << "# ./oss-fuzz-client -only_ascii=1 -timeout=5 -detect_leaks=0 corpus samples ../test/cli/fuzz-crash ../test/cli/fuzz-crash_c ../test/cli/fuzz-timeout -workers=12 -jobs=9\n";
+    fout << '\n';
+    fout << "# minimize:\n";
+    fout << "# ./oss-fuzz-client -only_ascii=1 -timeout=5 -detect_leaks=0 -minimize_crash=1 crash-0123456789abcdef\n";
+    fout << '\n';
+
+    compilefiles(fout, extfiles, "${LIB_FUZZING_ENGINE}");
+    compilefiles(fout, libfiles_prio, "${LIB_FUZZING_ENGINE}");
+
+    fout << '\n';
+    fout << "type2.o: type2.cpp type2.h\n";
+    fout << "\t$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ type2.cpp\n";
+    fout << '\n';
+    fout << "translate.o: translate.cpp type2.h\n";
+    fout << "\t$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ translate.cpp\n";
+    fout << '\n';
+    fout << "main.o: main.cpp type2.h\n";
+    fout << "\t$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -c -o $@ main.cpp\n";
+    fout << '\n';
+    fout << "main_nofuzz.o: main.cpp type2.h\n";
+    fout << "\t$(CXX) ${LIB_FUZZING_ENGINE} $(CPPFLAGS) $(CXXFLAGS) -DNO_FUZZ -c -o $@ main.cpp\n";
+}
+
+int main(int argc, char **argv)
+{
+    const bool release(argc >= 2 && std::string(argv[1]) == "--release");
+
+    // Get files..
+    std::vector<std::string> libfiles;
+    std::string err = getCppFiles(libfiles, "lib/", false);
+    if (!err.empty()) {
+        std::cerr << err << std::endl;
+        return EXIT_FAILURE;
+    }
+    const std::vector<std::string> libfiles_prio = prioritizelib(libfiles);
+
+    std::vector<std::string> extfiles;
+    err = getCppFiles(extfiles, "externals/", true);
+    if (!err.empty()) {
+        std::cerr << err << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    std::vector<std::string> frontendfiles;
+    err = getCppFiles(frontendfiles, "frontend/", false);
+    if (!err.empty()) {
+        std::cerr << err << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    std::vector<std::string> clifiles;
+    err = getCppFiles(clifiles, "cli/", false);
+    if (!err.empty()) {
+        std::cerr << err << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    std::vector<std::string> testfiles;
+    err = getCppFiles(testfiles, "test/", false);
+    if (!err.empty()) {
+        std::cerr << err << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    std::vector<std::string> toolsfiles;
+    err = getCppFiles(toolsfiles, "tools/dmake/", false);
+    if (!err.empty()) {
+        std::cerr << err << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    if (libfiles.empty() && frontendfiles.empty() && clifiles.empty() && testfiles.empty()) {
+        std::cerr << "No files found. Are you in the correct directory?" << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    // TODO: add files without source via parsing
+    std::set<std::string> libfiles_h;
+    for (const std::string &libfile : libfiles) {
+        std::string fname(libfile.substr(4));
+        fname.erase(fname.find(".cpp"));
+        libfiles_h.emplace(fname + ".h");
+    }
+    libfiles_h.emplace("analyzer.h");
+    libfiles_h.emplace("calculate.h");
+    libfiles_h.emplace("config.h");
+    libfiles_h.emplace("filesettings.h");
+    libfiles_h.emplace("findtoken.h");
+    libfiles_h.emplace("json.h");
+    libfiles_h.emplace("matchcompiler.h");
+    libfiles_h.emplace("precompiled.h");
+    libfiles_h.emplace("smallvector.h");
+    libfiles_h.emplace("sourcelocation.h");
+    libfiles_h.emplace("tokenrange.h");
+    libfiles_h.emplace("valueptr.h");
+    libfiles_h.emplace("version.h");
+    libfiles_h.emplace("vf_analyze.h");
+    libfiles_h.emplace("xml.h");
+
+    std::vector<std::string> frontendfiles_h;
+    for (const std::string &frontendfile : frontendfiles) {
+        std::string fname(frontendfile.substr(9));
+        fname.erase(fname.find(".cpp"));
+        frontendfiles_h.emplace_back(fname + ".h");
+    }
+
+    std::vector<std::string> clifiles_h;
+    for (const std::string &clifile : clifiles) {
+        std::string fname(clifile.substr(4));
+        if (fname == "main.cpp")
+            continue;
+        fname.erase(fname.find(".cpp"));
+        clifiles_h.emplace_back(fname + ".h");
+    }
+
+    std::set<std::string> testfiles_h;
+    testfiles_h.emplace("fixture.h");
+    testfiles_h.emplace("helpers.h");
+    testfiles_h.emplace("options.h");
+    testfiles_h.emplace("precompiled.h");
+    testfiles_h.emplace("redirect.h");
+
+    // TODO: write filter files
+    // Visual Studio projects
+    write_vcxproj("cli/cli.vcxproj", [&](std::string &outstr){
+        for (const std::string &clifile: clifiles) {
+            const std::string c = clifile.substr(4);
+            outstr += make_vcxproj_cl_entry(c, c == "executor.cpp" ? Precompile : Compile);
+        }
+        for (const std::string &frontendfile: frontendfiles) {
+            const std::string c = "..\\frontend\\" + frontendfile.substr(9);
+            outstr += make_vcxproj_cl_entry(c, Compile);
+        }
+    }, [&](std::string &outstr){
+        for (const std::string &clifile_h: clifiles_h) {
+            outstr += make_vcxproj_cl_entry(clifile_h, Include);
+        }
+        for (const std::string &frontendfile_h: frontendfiles_h) {
+            const std::string h = "..\\frontend\\" + frontendfile_h;
+            outstr += make_vcxproj_cl_entry(h, Include);
+        }
+    });
+
+    write_vcxproj("lib/cppcheck.vcxproj", [&](std::string &outstr){
+        outstr += make_vcxproj_cl_entry(R"(..\externals\simplecpp\simplecpp.cpp)", NoPch);
+        outstr += make_vcxproj_cl_entry(R"(..\externals\tinyxml2\tinyxml2.cpp)", NoPch);
+
+        for (const std::string &libfile: libfiles_prio) {
+            const std::string l = libfile.substr(4);
+            outstr += make_vcxproj_cl_entry(l, l == "check.cpp" ? Precompile : Compile);
+        }
+    }, [&](std::string &outstr){
+        outstr += make_vcxproj_cl_entry(R"(..\externals\simplecpp\simplecpp.h)", Include);
+        outstr += make_vcxproj_cl_entry(R"(..\externals\tinyxml2\tinyxml2.h)", Include);
+
+        for (const std::string &libfile_h: libfiles_h) {
+            outstr += make_vcxproj_cl_entry(libfile_h, Include);
+        }
+    });
+
+    write_vcxproj("test/testrunner.vcxproj", [&](std::string &outstr){
+        for (const std::string &clifile: clifiles) {
+            if (clifile == "cli/main.cpp")
+                continue;
+            const std::string c = R"(..\cli\)" + clifile.substr(4);
+            outstr += make_vcxproj_cl_entry(c, Compile);
+        }
+
+        for (const std::string &frontendfile: frontendfiles) {
+            const std::string c = "..\\frontend\\" + frontendfile.substr(9);
+            outstr += make_vcxproj_cl_entry(c, Compile);
+        }
+
+        for (const std::string &testfile: testfiles) {
+            const std::string t = testfile.substr(5);
+            outstr += make_vcxproj_cl_entry(t, t == "fixture.cpp" ? Precompile : Compile);
+        }
+    }, [&](std::string &outstr){
+        for (const std::string &clifile_h: clifiles_h) {
+            const std::string c = R"(..\cli\)" + clifile_h;
+            outstr += make_vcxproj_cl_entry(c, Include);
+        }
+
+        for (const std::string &frontendfile_h: frontendfiles_h) {
+            const std::string h = "..\\frontend\\" + frontendfile_h;
+            outstr += make_vcxproj_cl_entry(h, Include);
+        }
+
+        for (const std::string &testfile_h: testfiles_h) {
+            outstr += make_vcxproj_cl_entry(testfile_h, Include);
+        }
+    });
+
+    static constexpr char makefile[] = "Makefile";
+    std::ofstream fout(makefile, std::ios_base::trunc);
+    if (!fout.is_open()) {
+        std::cerr << "An error occurred while trying to open "
+                  << makefile
+                  << ".\n";
+        return EXIT_FAILURE;
+    }
+
+    fout << "# This file is generated by dmake, do not edit.\n\n";
+
+    fout << "ifndef VERBOSE\n"
+         << "    VERBOSE=\n"
+         << "endif\n";
+
+    fout << "# To compile with rules, use 'make HAVE_RULES=yes'\n";
+    makeConditionalVariable(fout, "HAVE_RULES", "");
+
+    makeMatchcompiler(fout, "", "");
+
+    // avoid undefined variable
+    fout << "ifndef CPPFLAGS\n"
+         << "    CPPFLAGS=\n"
+         << "endif\n\n";
+
+    // explicit files dir..
+    fout << "ifdef FILESDIR\n"
+         << "    override CPPFLAGS+=-DFILESDIR=\\\"$(FILESDIR)\\\"\n"
+         << "endif\n\n";
+
+    // enable backtrac
+    fout << "RDYNAMIC?=-rdynamic\n";
+
+    // The _GLIBCXX_DEBUG doesn't work in cygwin or other Win32 systems.
+    fout << "# Set the CPPCHK_GLIBCXX_DEBUG flag. This flag is not used in release Makefiles.\n"
+         << "# The _GLIBCXX_DEBUG define doesn't work in Cygwin or other Win32 systems.\n"
+         << "ifndef COMSPEC\n"
+         << "    ifeq ($(VERBOSE),1)\n"
+         << "        $(info COMSPEC not found)\n"
+         << "    endif\n"
+         << "    ifdef ComSpec\n"
+         << "        ifeq ($(VERBOSE),1)\n"
+         << "            $(info ComSpec found)\n"
+         << "        endif\n"
+         << "        #### ComSpec is defined on some WIN32's.\n"
+         << "        WINNT=1\n"
+         << "\n"
+         << "        ifeq ($(VERBOSE),1)\n"
+         << "            $(info PATH=$(PATH))\n"
+         << "        endif\n"
+         << "\n"
+         << "        ifneq (,$(findstring /cygdrive/,$(PATH)))\n"
+         << "            ifeq ($(VERBOSE),1)\n"
+         << "                $(info /cygdrive/ found in PATH)\n"
+         << "            endif\n"
+         << "            CYGWIN=1\n"
+         << "        endif # CYGWIN\n"
+         << "    endif # ComSpec\n"
+         << "endif # COMSPEC\n"
+         << "\n"
+         << "ifdef WINNT\n"
+         << "    ifeq ($(VERBOSE),1)\n"
+         << "        $(info WINNT found)\n"
+         << "    endif\n"
+         << "    #### Maybe Windows\n"
+         << "    ifndef CPPCHK_GLIBCXX_DEBUG\n"
+         << "        CPPCHK_GLIBCXX_DEBUG=\n"
+         << "    endif # !CPPCHK_GLIBCXX_DEBUG\n"
+         << "\n"
+         << "    ifeq ($(VERBOSE),1)\n"
+         << "        $(info MSYSTEM=$(MSYSTEM))\n"
+         << "    endif\n"
+         << "\n"
+         << "    ifneq ($(MSYSTEM),MINGW32 MINGW64)\n"
+         << "        RDYNAMIC=\n"
+         << "    endif\n"
+         << "\n"
+         << "    LDFLAGS+=-lshlwapi\n"
+         << "else # !WINNT\n"
+         << "    ifeq ($(VERBOSE),1)\n"
+         << "        $(info WINNT not found)\n"
+         << "    endif\n"
+         << "\n"
+         << "    uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')\n"
+         << "\n"
+         << "    ifeq ($(VERBOSE),1)\n"
+         << "        $(info uname_S=$(uname_S))\n"
+         << "    endif\n"
+         << "\n"
+         << "    ifeq ($(uname_S),Linux)\n"
+         << "        ifndef CPPCHK_GLIBCXX_DEBUG\n"
+         << "            CPPCHK_GLIBCXX_DEBUG=-D_GLIBCXX_DEBUG\n"
+         << "        endif # !CPPCHK_GLIBCXX_DEBUG\n"
+         << "    endif # Linux\n"
+         << "\n"
+         << "    ifeq ($(uname_S),GNU/kFreeBSD)\n"
+         << "        ifndef CPPCHK_GLIBCXX_DEBUG\n"
+         << "            CPPCHK_GLIBCXX_DEBUG=-D_GLIBCXX_DEBUG\n"
+         << "        endif # !CPPCHK_GLIBCXX_DEBUG\n"
+         << "    endif # GNU/kFreeBSD\n"
+         << "\n"
+         << "    LDFLAGS+=-pthread\n"
+         << "\n"
+         << "endif # WINNT\n"
+         << "\n";
+
+    fout << "ifdef CYGWIN\n"
+         << "    ifeq ($(VERBOSE),1)\n"
+         << "        $(info CYGWIN found)\n"
+         << "    endif\n"
+         << "\n"
+         << "    # Increase stack size for Cygwin builds to avoid segmentation fault in limited recursive tests.\n"
+         << "    CXXFLAGS+=-Wl,--stack,8388608\n"
+         << "endif # CYGWIN\n"
+         << "\n";
+
+    // skip "-D_GLIBCXX_DEBUG" if clang, since it breaks the build
+    makeConditionalVariable(fout, "CXX", "g++");
+    fout << "ifeq (clang++, $(findstring clang++,$(CXX)))\n"
+         << "    CPPCHK_GLIBCXX_DEBUG=\n"
+         << "endif\n";
+
+    // Makefile settings..
+    if (release) {
+        makeConditionalVariable(fout, "CXXFLAGS", "-O2 -Wall -Wno-sign-compare -Wno-multichar");
+        fout << "override CPPFLAGS += -DNDEBUG\n\n";
+    } else {
+        makeConditionalVariable(fout, "CXXFLAGS",
+                                "-pedantic "
+                                "-Wall "
+                                "-Wextra "
+                                "-Wcast-qual "
+                                "-Wfloat-equal "
+                                "-Wmissing-declarations "
+                                "-Wmissing-format-attribute "
+                                "-Wno-long-long "
+                                "-Wpacked "
+                                "-Wredundant-decls "
+                                "-Wundef "
+                                "-Wno-sign-compare "
+                                "-Wno-multichar "
+                                "-Woverloaded-virtual "
+                                "-g");
+        //fout << "override CPPFLAGS += $(CPPCHK_GLIBCXX_DEBUG)\n\n"; // TODO: when using CXXOPTS this would always be set - need to handle this differently
+    }
+
+    fout << "ifeq (g++, $(findstring g++,$(CXX)))\n"
+         << "    override CXXFLAGS += -pipe\n"
+         << "endif\n"
+         << "override CXXFLAGS += -std=c++11"
+         << "\n";
+
+    fout << "ifeq ($(HAVE_RULES),yes)\n"
+         << "    PCRE_CONFIG = $(shell which pcre-config)\n"
+         << "    ifeq ($(PCRE_CONFIG),)\n"
+         << "        $(error Did not find pcre-config)\n"
+         << "    endif\n"
+         << "    override CXXFLAGS += $(shell $(PCRE_CONFIG) --cflags)\n"
+         << "    override CPPFLAGS += -DHAVE_RULES\n"
+         << "    ifdef LIBS\n"
+         << "        LIBS += $(shell $(PCRE_CONFIG) --libs)\n"
+         << "    else\n"
+         << "        LIBS=$(shell $(PCRE_CONFIG) --libs)\n"
+         << "    endif\n"
+         << "else ifneq ($(HAVE_RULES),)\n"
+         << "    $(error invalid HAVE_RULES value '$(HAVE_RULES)')\n"
+         << "endif\n\n";
+
+    // the # needs to be escaped on older make versions
+    fout << "HAVE_EXECINFO_H=$(shell echo \"\\#include <execinfo.h>\" | $(CXX) -c -xc - 2> /dev/null && echo \"1\" || echo \"0\")\n"
+         << "override CPPFLAGS += -DHAVE_EXECINFO_H=$(HAVE_EXECINFO_H)\n\n";
+
+    fout << "override CXXFLAGS += $(CXXOPTS)\n";
+    fout << "override CPPFLAGS += $(CPPOPTS)\n";
+    fout << "override LDFLAGS += $(LDOPTS)\n\n";
+
+    makeConditionalVariable(fout, "PREFIX", "/usr");
+    makeConditionalVariable(fout, "INCLUDE_FOR_LIB", "-Ilib -isystem externals -isystem externals/picojson -isystem externals/simplecpp -isystem externals/tinyxml2");
+    makeConditionalVariable(fout, "INCLUDE_FOR_FE", "-Ilib");
+    makeConditionalVariable(fout, "INCLUDE_FOR_CLI", "-Ilib -Ifrontend -isystem externals/picojson -isystem externals/simplecpp -isystem externals/tinyxml2");
+    makeConditionalVariable(fout, "INCLUDE_FOR_TEST", "-Ilib -Ifrontend -Icli -isystem externals/picojson -isystem externals/simplecpp -isystem externals/tinyxml2");
+
+    makeConditionalVariable(fout, "CFLAGS_FOR_TEST", "-Wno-dollar-in-identifier-extension");
+
+    fout << "BIN=$(DESTDIR)$(PREFIX)/bin\n\n";
+    fout << "# For 'make man': sudo apt-get install xsltproc docbook-xsl docbook-xml on Linux\n";
+    fout << "DB2MAN?=/usr/share/sgml/docbook/stylesheet/xsl/nwalsh/manpages/docbook.xsl\n";
+    fout << "XP=xsltproc -''-nonet -''-param man.charmap.use.subset \"0\"\n";
+    fout << "MAN_SOURCE=man/cppcheck.1.xml\n\n";
+
+    fout << "\n###### Object Files\n\n";
+    fout << "LIBOBJ =      " << objfiles(libfiles_prio) << "\n\n";
+    fout << "EXTOBJ =      " << objfiles(extfiles) << "\n\n";
+    fout << "FEOBJ =       " << objfiles(frontendfiles) << "\n\n";
+    fout << "CLIOBJ =      " << objfiles(clifiles) << "\n\n";
+    fout << "TESTOBJ =     " << objfiles(testfiles) << "\n\n";
+
+    fout << ".PHONY: run-dmake tags\n\n";
+    fout << "\n###### Targets\n\n";
+    fout << "cppcheck: $(EXTOBJ) $(LIBOBJ) $(FEOBJ) $(CLIOBJ)\n";
+    fout << "\t$(CXX) $(CXXFLAGS) -o $@ $^ $(LIBS) $(LDFLAGS) $(RDYNAMIC)\n\n";
+    fout << "all:\tcppcheck testrunner\n\n";
+    std::string testrunner_clifiles_o;
+    for (const std::string &clifile: clifiles) {
+        if (clifile == "cli/main.cpp")
+            continue;
+        testrunner_clifiles_o += ' ';
+        const std::string o = clifile.substr(0, clifile.length()-3) + 'o';
+        testrunner_clifiles_o += o;
+    }
+    fout << "testrunner: $(EXTOBJ) $(TESTOBJ) $(LIBOBJ) $(FEOBJ)" << testrunner_clifiles_o << "\n";
+    fout << "\t$(CXX) $(CXXFLAGS) -o $@ $^ $(LIBS) $(LDFLAGS) $(RDYNAMIC)\n\n";
+    fout << "test:\tall\n";
+    fout << "\t./testrunner\n\n";
+    fout << "check:\tall\n";
+    fout << "\t./testrunner -q\n\n";
+    fout << "checkcfg:\tcppcheck validateCFG\n";
+    fout << "\t./test/cfg/runtests.sh\n\n";
+    fout << "dmake:\ttools/dmake/dmake.o cli/filelister.o $(libcppdir)/pathmatch.o $(libcppdir)/path.o $(libcppdir)/utils.o externals/simplecpp/simplecpp.o\n";
+    fout << "\t$(CXX) $(CXXFLAGS) -o $@ $^ $(LDFLAGS)\n\n";
+    fout << "run-dmake: dmake\n";
+    fout << "\t./dmake" << (release ? " --release" : "") << "\n\n"; // Make CI in release builds happy
+    fout << "clean:\n";
+    fout << "\trm -f build/*.cpp build/*.o lib/*.o cli/*.o frontend/*.o test/*.o tools/dmake/*.o externals/*/*.o testrunner dmake cppcheck cppcheck.exe cppcheck.1\n\n";
+    fout << "man:\tman/cppcheck.1\n\n";
+    fout << "man/cppcheck.1:\t$(MAN_SOURCE)\n\n";
+    fout << "\t$(XP) $(DB2MAN) $(MAN_SOURCE)\n\n";
+    fout << "tags:\n";
+    fout << "\tctags -R --exclude=doxyoutput --exclude=test/cfg cli externals gui lib test\n\n";
+    fout << "install: cppcheck\n";
+    fout << "\tinstall -d ${BIN}\n";
+    fout << "\tinstall cppcheck ${BIN}\n";
+    fout << "\tinstall htmlreport/cppcheck-htmlreport ${BIN}\n";
+    fout << "ifdef FILESDIR\n";
+    fout << "\tinstall -d ${DESTDIR}${FILESDIR}\n";
+    fout << "\tinstall -d ${DESTDIR}${FILESDIR}/addons\n";
+    fout << "\tinstall -m 644 addons/*.json ${DESTDIR}${FILESDIR}/addons\n";
+    fout << "\tinstall -m 644 addons/*.py ${DESTDIR}${FILESDIR}/addons\n";
+    fout << "\tinstall -d ${DESTDIR}${FILESDIR}/cfg\n";
+    fout << "\tinstall -m 644 cfg/*.cfg ${DESTDIR}${FILESDIR}/cfg\n";
+    fout << "\tinstall -d ${DESTDIR}${FILESDIR}/platforms\n";
+    fout << "\tinstall -m 644 platforms/*.xml ${DESTDIR}${FILESDIR}/platforms\n";
+    fout << "else\n";
+    fout << "\t$(error FILESDIR must be set!)\n";
+    fout << "endif\n";
+    fout << "\n";
+    fout << "uninstall:\n";
+    fout << "\t@if test -d ${BIN}; then \\\n";
+    fout << "\t  files=\"cppcheck cppcheck-htmlreport\"; \\\n";
+    fout << "\t  echo '(' cd ${BIN} '&&' rm -f $$files ')'; \\\n";
+    fout << "\t  ( cd ${BIN} && rm -f $$files ); \\\n";
+    fout << "\tfi\n";
+    fout << "ifdef FILESDIR \n";
+    fout << "\t@if test -d ${DESTDIR}${FILESDIR}; then \\\n";
+    fout << "\t  echo rm -rf ${DESTDIR}${FILESDIR}; \\\n";
+    fout << "\t  rm -rf ${DESTDIR}${FILESDIR}; \\\n";
+    fout << "\tfi\n";
+    fout << "endif\n";
+    fout << "# Validation of library files:\n";
+    fout << "ConfigFiles := $(wildcard cfg/*.cfg)\n";
+    fout << "ConfigFilesCHECKED := $(patsubst %.cfg,%.checked,$(ConfigFiles))\n";
+    fout << ".PHONY: validateCFG\n";
+    fout << "%.checked:%.cfg\n";
+    fout << "\txmllint --noout --relaxng cfg/cppcheck-cfg.rng $<\n";
+    fout << "validateCFG: ${ConfigFilesCHECKED}\n";
+    fout << "\txmllint --noout cfg/cppcheck-cfg.rng\n\n";
+    fout << "# Validation of platforms files:\n";
+    fout << "PlatformFiles := $(wildcard platforms/*.xml)\n";
+    fout << "PlatformFilesCHECKED := $(patsubst %.xml,%.checked,$(PlatformFiles))\n";
+    fout << ".PHONY: validatePlatforms\n";
+    fout << "%.checked:%.xml\n";
+    fout << "\txmllint --noout --relaxng platforms/cppcheck-platforms.rng $<\n";
+    fout << "validatePlatforms: ${PlatformFilesCHECKED}\n";
+    fout << "\txmllint --noout platforms/cppcheck-platforms.rng\n";
+    fout << "\n";
+    fout << "# Validate XML output (to detect regressions)\n";
+    fout << "/tmp/errorlist.xml: cppcheck\n";
+    fout << "\t./cppcheck --errorlist >$@\n";
+    fout << "/tmp/example.xml: cppcheck\n";
+    fout << "\t./cppcheck --xml --enable=all --inconclusive --max-configs=1 samples 2>/tmp/example.xml\n";
+    fout << "createXMLExamples:/tmp/errorlist.xml /tmp/example.xml\n";
+    fout << ".PHONY: validateXML\n";
+    fout << "validateXML: createXMLExamples\n";
+    fout << "\txmllint --noout cppcheck-errors.rng\n";
+    fout << "\txmllint --noout --relaxng cppcheck-errors.rng /tmp/errorlist.xml\n";
+    fout << "\txmllint --noout --relaxng cppcheck-errors.rng /tmp/example.xml\n";
+    fout << "\ncheckCWEEntries: /tmp/errorlist.xml\n";
+    // TODO: handle "PYTHON_INTERPRETER="
+    fout << "\t$(eval PYTHON_INTERPRETER := $(if $(PYTHON_INTERPRETER),$(PYTHON_INTERPRETER),$(shell which python3)))\n";
+    fout << "\t$(eval PYTHON_INTERPRETER := $(if $(PYTHON_INTERPRETER),$(PYTHON_INTERPRETER),$(shell which python)))\n";
+    fout << "\t$(eval PYTHON_INTERPRETER := $(if $(PYTHON_INTERPRETER),$(PYTHON_INTERPRETER),$(error Did not find a Python interpreter)))\n";
+    fout << "\t$(PYTHON_INTERPRETER) tools/listErrorsWithoutCWE.py -F /tmp/errorlist.xml\n";
+    fout << ".PHONY: validateRules\n";
+    fout << "validateRules:\n";
+    fout << "\txmllint --noout rules/*.xml\n";
+    fout << ".PHONY: check-nonneg\n";
+    fout << "check-nonneg:\n";
+    // TODO: how to use provided number of jobs?
+    fout << "\tls lib/*.cpp | xargs -n 1 -P $$(nproc) g++ -fsyntax-only -DNONNEG $(CXXFLAGS) $(INCLUDE_FOR_LIB)\n";
+
+    fout << "\n###### Build\n\n";
+
+    compilefiles(fout, libfiles_prio, "${INCLUDE_FOR_LIB}");
+    compilefiles(fout, frontendfiles, "${INCLUDE_FOR_FE}");
+    compilefiles(fout, clifiles, "${INCLUDE_FOR_CLI}");
+    compilefiles(fout, testfiles, "${INCLUDE_FOR_TEST} ${CFLAGS_FOR_TEST}");
+    compilefiles(fout, extfiles, "");
+    compilefiles(fout, toolsfiles, "${INCLUDE_FOR_LIB}");
+
+    write_ossfuzz_makefile(libfiles_prio, extfiles);
+
+    return 0;
+}
diff --git a/tools/donate-cpu-requirements.txt b/tools/donate-cpu-requirements.txt
new file mode 100644
index 00000000000..1d1077372cf
--- /dev/null
+++ b/tools/donate-cpu-requirements.txt
@@ -0,0 +1,2 @@
+psutil
+packaging
diff --git a/tools/donate-cpu-server.py b/tools/donate-cpu-server.py
old mode 100644
new mode 100755
index a8894d382a2..6f44ea679a7
--- a/tools/donate-cpu-server.py
+++ b/tools/donate-cpu-server.py
@@ -1,6 +1,9 @@
+#!/usr/bin/env python3
 
 # Server for 'donate-cpu.py'
+# Runs only under Python 3.
 
+import collections
 import glob
 import json
 import os
@@ -8,19 +11,28 @@
 import re
 import datetime
 import time
+import traceback
 from threading import Thread
 import sys
-import urllib
+import urllib.request
+import urllib.parse
+import urllib.error
 import logging
 import logging.handlers
 import operator
+import html as html_lib
+from urllib.parse import urlparse
 
 # Version scheme (MAJOR.MINOR.PATCH) should orientate on "Semantic Versioning" https://semver.org/
 # Every change in this script should result in increasing the version number accordingly (exceptions may be cosmetic
 # changes)
-SERVER_VERSION = "1.1.6"
+SERVER_VERSION = "1.3.68"
 
-OLD_VERSION = '1.89'
+# TODO: fetch from GitHub tags
+OLD_VERSION = '2.20.0'
+
+HEAD_MARKER = 'head results:'
+INFO_MARKER = 'info messages:'
 
 
 # Set up logging
@@ -35,10 +47,16 @@
     logfile += '/'
 logfile += 'donate-cpu-server.log'
 handler_file = logging.handlers.RotatingFileHandler(filename=logfile, maxBytes=100*1024, backupCount=1)
+handler_file.setFormatter(logging.Formatter('%(asctime)s %(message)s'))
 handler_file.setLevel(logging.ERROR)
 logger.addHandler(handler_file)
 
 
+def print_ts(msg) -> None:
+    dt = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')
+    print('[{}] {}'.format(dt, msg))
+
+
 # Set up an exception hook for all uncaught exceptions so they can be logged
 def handle_uncaught_exception(exc_type, exc_value, exc_traceback):
     if issubclass(exc_type, KeyboardInterrupt):
@@ -51,33 +69,76 @@ def handle_uncaught_exception(exc_type, exc_value, exc_traceback):
 sys.excepthook = handle_uncaught_exception
 
 
-def strDateTime():
+def strDateTime() -> str:
     return datetime.datetime.now().strftime('%Y-%m-%d %H:%M')
 
 
-def dateTimeFromStr(datestr):
+def dateTimeFromStr(datestr: str) -> datetime.datetime:
     return datetime.datetime.strptime(datestr, '%Y-%m-%d %H:%M')
 
-def overviewReport():
-    html = '<html><head><title>daca@home</title></head><body>\n'
+
+def pkg_from_file(filename: str) -> str:
+    return filename[filename.rfind('/')+1:]
+
+
+def overviewReport() -> str:
+    html = '<!DOCTYPE html>\n'
+    html += '<html><head><title>daca@home</title></head><body>\n'
     html += '<h1>daca@home</h1>\n'
-    html += '<a href="crash.html">Crash report</a><br>\n'
+    html += '<a href="crash.html">Crash report</a> - <a href="crash.html?pkgs=1">packages.txt</a><br>\n'
+    html += '<a href="timeout.html">Timeout report</a><br>\n'
     html += '<a href="stale.html">Stale report</a><br>\n'
     html += '<a href="diff.html">Diff report</a><br>\n'
     html += '<a href="head.html">HEAD report</a><br>\n'
+    html += '<a href="headinfo.html">HEAD (information) report</a><br>\n'
     html += '<a href="latest.html">Latest results</a><br>\n'
-    html += '<a href="time.html">Time report</a><br>\n'
+    html += '<a href="time_lt.html">Time report (improved)</a><br>\n'
+    html += '<a href="time_gt.html">Time report (regressed)</a> - <a href="time_gt.html?pkgs=1">packages.txt</a><br>\n'
+    html += '<a href="time_slow.html">Time report (slowest)</a><br>\n'
+    html += '<br>\n'
+    html += '--check-library:<br>\n'
     html += '<a href="check_library_function_report.html">checkLibraryFunction report</a><br>\n'
     html += '<a href="check_library_noreturn_report.html">checkLibraryNoReturn report</a><br>\n'
     html += '<a href="check_library_use_ignore_report.html">checkLibraryUseIgnore report</a><br>\n'
+    html += '<a href="check_library_check_type_report.html">checkLibraryCheckType report</a><br>\n'
+    html += '<br>\n'
+    html += 'Debug warnings:<br>\n'
+    html += '<a href="head-debug">debug</a><br>\n'
+    html += '<a href="head-varid0">varid0</a><br>\n'
+    html += '<a href="head-valueType">valueType</a><br>\n'
+    html += '<a href="head-noparamend">noparamend</a><br>\n'
+    html += '<a href="head-simplifyTypedef">simplifyTypedef</a><br>\n'
+    html += '<a href="head-simplifyUsingUnmatchedBodyEnd">simplifyUsingUnmatchedBodyEnd</a><br>\n'
+    html += '<a href="head-simplifyUsing">simplifyUsing</a><br>\n'
+    html += '<a href="head-valueFlowMaxIterations">valueFlowMaxIterations</a><br>\n'
+    html += '<a href="head-templateInstantiation">templateInstantiation</a><br>\n'
+    #html += '<a href="head-autoNoType">autoNoType</a><br>\n'
+    #html += '<a href="head-valueFlowBailout">valueFlowBailout</a><br>\n'
+    #html += '<a href="head-bailoutUninitVar">bailoutUninitVar</a><br>\n'
+    #html += '<a href="head-symbolDatabaseWarning">symbolDatabaseWarning</a><br>\n'
+    html += '<br>\n'
+    html += 'Custom reports:<br>\n'
+    html += '<a href="value_flow_bailout_incomplete_var.html">valueFlowBailoutIncompleteVar report</a><br>\n'
+    html += '<a href="unknown_macro.html">unknownMacro report</a><br>\n'
+    html += '<br>\n'
+    html += 'Important errors:<br>\n'
+    html += '<a href="head-cppcheckError">cppcheckError</a><br>\n'
+    html += '<a href="head-internalError">internalError</a><br>\n'
+    html += '<a href="head-internalAstError">internalAstError</a><br>\n'
+    html += '<a href="head-syntaxError">syntaxError</a><br>\n'
+    html += '<a href="head-DacaWrongData">DacaWrongData</a><br>\n'
+    html += '<a href="head-dacaWrongSplitTemplateRightAngleBrackets">dacaWrongSplitTemplateRightAngleBrackets</a><br>\n'
+    html += '<br>\n'
+    html += '<a href="clients.html">clients</a><br>\n'
     html += '<br>\n'
     html += 'version ' + SERVER_VERSION + '\n'
     html += '</body></html>'
     return html
 
 
-def fmt(a, b, c, d, e):
-    column_width = [40, 10, 5, 6, 6, 8]
+def fmt(a: str, b: str, c: str = None, d: str = None, e: str = None, link: bool = True, column_width=None) -> str:
+    if column_width is None:
+        column_width = [40, 10, 5, 7, 7, 8]
     ret = a
     while len(ret) < column_width[0]:
         ret += ' '
@@ -86,38 +147,40 @@ def fmt(a, b, c, d, e):
     while len(ret) < (column_width[0] + 1 + column_width[1]):
         ret += ' '
     ret += ' '
-    ret += b[-5:].rjust(column_width[2]) + ' '
-    if not c is None:
+    if len(b) > 10:
+        ret += b[-5:].rjust(column_width[2]) + ' '
+    if c is not None:
         ret += c.rjust(column_width[3]) + ' '
-    if not d is None:
+    if d is not None:
         ret += d.rjust(column_width[4]) + ' '
-    if not e is None:
+    if e is not None:
         ret += e.rjust(column_width[5])
-    if a != 'Package':
+    if link:
         pos = ret.find(' ')
         ret = '<a href="' + a + '">' + a + '</a>' + ret[pos:]
     return ret
 
 
-def latestReport(latestResults):
-    html = '<html><head><title>Latest daca@home results</title></head><body>\n'
+def latestReport(latestResults: list) -> str:
+    html = '<!DOCTYPE html>\n'
+    html += '<html><head><title>Latest daca@home results</title></head><body>\n'
     html += '<h1>Latest daca@home results</h1>\n'
-    html += '<pre>\n<b>' + fmt('Package', 'Date       Time', OLD_VERSION, 'Head', 'Diff') + '</b>\n'
+    html += '<pre>\n<b>' + fmt('Package', 'Date       Time', OLD_VERSION, 'Head', 'Diff', link=False) + '</b>\n'
 
     # Write report for latest results
     for filename in latestResults:
         if not os.path.isfile(filename):
             continue
-        package = filename[filename.rfind('/')+1:]
+        package = pkg_from_file(filename)
         current_year = datetime.date.today().year
 
-        datestr = ''
+        datestr = None
         count = ['0', '0']
         lost = 0
         added = 0
         for line in open(filename, 'rt'):
             line = line.strip()
-            if line.startswith(str(current_year) + '-') or line.startswith(str(current_year - 1) + '-'):
+            if datestr is None and line.startswith(str(current_year) + '-') or line.startswith(str(current_year - 1) + '-'):
                 datestr = line
             #elif line.startswith('cppcheck:'):
             #    cppcheck = line[9:]
@@ -138,76 +201,185 @@ def latestReport(latestResults):
     return html
 
 
-def crashReport(results_path):
-    html = '<html><head><title>Crash report</title></head><body>\n'
+def crashReport(results_path: str, query_params: dict):
+    pkgs = '' if query_params.get('pkgs') == '1' else None
+
+    html = '<!DOCTYPE html>\n'
+    html += '<html><head><title>Crash report</title></head><body>\n'
     html += '<h1>Crash report</h1>\n'
     html += '<pre>\n'
-    html += '<b>' + fmt('Package', 'Date       Time', OLD_VERSION, 'Head', None) + '</b>\n'
+    html += '<b>' + fmt('Package', 'Date       Time', OLD_VERSION, 'Head', link=False) + '</b>\n'
     current_year = datetime.date.today().year
+    stack_traces = {}
     for filename in sorted(glob.glob(os.path.expanduser(results_path + '/*'))):
-        if not os.path.isfile(filename):
+        if not os.path.isfile(filename) or filename.endswith('.diff'):
             continue
-        datestr = ''
-        for line in open(filename, 'rt'):
-            line = line.strip()
-            if line.startswith('cppcheck: '):
-                if OLD_VERSION not in line:
-                    # Package results seem to be too old, skip
-                    break
-                else:
+        with open(filename, 'rt') as file_:
+            datestr = None
+            package_url = None
+            for line in file_:
+                line = line.strip()
+                if line.startswith('cppcheck: '):
+                    if OLD_VERSION not in line:
+                        # Package results seem to be too old, skip
+                        break
                     # Current package, parse on
                     continue
-            if line.startswith(str(current_year) + '-') or line.startswith(str(current_year - 1) + '-'):
-                datestr = line
-            if not line.startswith('count:'):
-                continue
-            if line.find('Crash') < 0:
-                break
-            package = filename[filename.rfind('/')+1:]
-            counts = line.strip().split(' ')
-            c2 = ''
-            if counts[2] == 'Crash!':
-                c2 = 'Crash'
-            c1 = ''
-            if counts[1] == 'Crash!':
-                c1 = 'Crash'
-            html += fmt(package, datestr, c2, c1, None) + '\n'
-            break
+                if datestr is None and line.startswith(str(current_year) + '-') or line.startswith(str(current_year - 1) + '-'):
+                    datestr = line
+                elif pkgs is not None and package_url is None and line.startswith('ftp://'):
+                    package_url = line
+                elif line.startswith('count:'):
+                    if line.find('Crash') < 0:
+                        break
+                    package = pkg_from_file(filename)
+                    counts = line.split(' ')
+                    c_version = ''
+                    if counts[2] == 'Crash!':
+                        c_version = 'Crash'
+                    c_head = ''
+                    if counts[1] == 'Crash!':
+                        c_head = 'Crash'
+                    html += fmt(package, datestr, c_version, c_head) + '\n'
+                    if c_head != 'Crash':
+                        break
+                    if package_url is not None:
+                        pkgs += '{}\n'.format(package_url)
+                elif line.find(' received signal ') != -1:
+                    crash_line = next(file_, '').strip()
+                    location_index = crash_line.rfind(' at ')
+                    if location_index > 0:
+                        code_line = next(file_, '').strip()
+                    else:
+                        code_line = ''
+                    stack_trace = []
+                    while True:
+                        l = next(file_, '')
+                        if not l.strip():
+                            break
+                        # #0  0x00007ffff71cbf67 in raise () from /lib64/libc.so.6
+                        m = re.search(r'(?P<number>#\d+) .* in (?P<function>.+)\(.*\) from (?P<binary>.*)$', l)
+                        if m:
+                            #print('0 - {} - {} - {}'.format(m.group('number'), m.group('function'), m.group('binary')))
+                            stack_trace.append(m.group('number') + ' ' + m.group('function') + '(...) from ' + m.group('binary'))
+                            continue
+                        # #11 0x00000000006f2414 in valueFlowNumber (tokenlist=tokenlist@entry=0x7fffffffc610) at build/valueflow.cpp:2503
+                        m = re.search(r'(?P<number>#\d+) .* in (?P<function>.+?) \(.*\) at (?P<location>.*)$', l)
+                        if m:
+                            #print('1 - {} - {} - {}'.format(m.group('number'), m.group('function'), m.group('location')))
+                            stack_trace.append(m.group('number') + ' ' + m.group('function') + '(...) at ' + m.group('location'))
+                            continue
+                        # #18 ForwardTraversal::updateRecursive (this=0x7fffffffb3c0, tok=0x14668a0) at build/forwardanalyzer.cpp:415
+                        m = re.search(r'(?P<number>#\d+) (?P<function>.+)\(.*\) at (?P<location>.*)$', l)
+                        if m:
+                            #print('2 - {} - {} - {}'.format(m.group('number'), m.group('function'), m.group('location')))
+                            stack_trace.append(m.group('number') + ' ' + m.group('function') + '(...) at ' + m.group('location'))
+                            continue
+
+                        print_ts('{} - unmatched stack frame - {}'.format(package, l))
+                        break
+                    key = hash(' '.join(stack_trace))
+
+                    if key in stack_traces:
+                        stack_traces[key]['code_line'] = code_line
+                        stack_traces[key]['stack_trace'] = stack_trace
+                        stack_traces[key]['n'] += 1
+                        stack_traces[key]['packages'].append(package)
+                    else:
+                        stack_traces[key] = {'stack_trace': stack_trace, 'n': 1, 'code_line': code_line, 'packages': [package], 'crash_line': crash_line}
+                    break
+
+    html += '</pre>\n'
+    html += '<pre>\n'
+    html += '<b>Stack traces</b>\n'
+    for stack_trace in sorted(list(stack_traces.values()), key=lambda x: x['n'], reverse=True):
+        html += 'Packages: ' + ' '.join(['<a href="' + p + '">' + p + '</a>' for p in stack_trace['packages']]) + '\n'
+        html += html_lib.escape(stack_trace['crash_line']) + '\n'
+        html += html_lib.escape(stack_trace['code_line']) + '\n'
+        html += html_lib.escape('\n'.join(stack_trace['stack_trace'])) + '\n\n'
     html += '</pre>\n'
 
+    html += '</body></html>\n'
+    if pkgs is not None:
+        return pkgs, 'text/plain'
+    return html, 'text/html'
+
+
+def timeoutReport(results_path: str) -> str:
+    html = '<!DOCTYPE html>\n'
+    html += '<html><head><title>Timeout report</title></head><body>\n'
+    html += '<h1>Timeout report</h1>\n'
+    html += '<pre>\n'
+    html += '<b>' + fmt('Package', 'Date       Time', OLD_VERSION, 'Head', link=False) + '</b>\n'
+    current_year = datetime.date.today().year
+    for filename in sorted(glob.glob(os.path.expanduser(results_path + '/*'))):
+        if not os.path.isfile(filename) or filename.endswith('.diff'):
+            continue
+        with open(filename, 'rt') as file_:
+            datestr = None
+            for line in file_:
+                line = line.strip()
+                if line.startswith('cppcheck: '):
+                    if OLD_VERSION not in line:
+                        # Package results seem to be too old, skip
+                        break
+                    # Current package, parse on
+                    continue
+                if datestr is None and line.startswith(str(current_year) + '-') or line.startswith(str(current_year - 1) + '-'):
+                    datestr = line
+                elif line.startswith('count:'):
+                    if line.find('TO!') < 0:
+                        break
+                    package = pkg_from_file(filename)
+                    counts = line.split(' ')
+                    c2 = ''
+                    if counts[2] == 'TO!':
+                        c2 = 'Timeout'
+                    c1 = ''
+                    if counts[1] == 'TO!':
+                        c1 = 'Timeout'
+                    html += fmt(package, datestr, c2, c1) + '\n'
+                    break
+
+    html += '</pre>\n'
     html += '</body></html>\n'
     return html
 
 
-def staleReport(results_path):
-    html = '<html><head><title>Stale report</title></head><body>\n'
+def staleReport(results_path: str, query_params: dict) -> str:
+    thresh_d = query_params.get('days')
+    if thresh_d is None:
+        thresh_d = 30
+    else:
+        thresh_d = int(thresh_d)
+
+    html = '<!DOCTYPE html>\n'
+    html += '<html><head><title>Stale report</title></head><body>\n'
     html += '<h1>Stale report</h1>\n'
     html += '<pre>\n'
-    html += '<b>' + fmt('Package', 'Date       Time', None, None, None) + '</b>\n'
-    current_year = datetime.date.today().year
+    html += '<b>' + fmt('Package', 'Date       Time', link=False) + '</b>\n'
     for filename in sorted(glob.glob(os.path.expanduser(results_path + '/*'))):
-        if not os.path.isfile(filename):
+        if filename.endswith('.diff') or not os.path.isfile(filename):
             continue
-        for line in open(filename, 'rt'):
-            line = line.strip()
-            if line.startswith(str(current_year) + '-') or line.startswith(str(current_year - 1) + '-'):
-                datestr = line
-            else:
-                continue
-            dt = dateTimeFromStr(datestr)
-            diff = datetime.datetime.now() - dt
-            if diff.days < 30:
-                continue
-            package = filename[filename.rfind('/')+1:]
-            html += fmt(package, datestr, None, None, None) + '\n'
-            break
+        with open(filename, 'rt') as f:
+            # first line is datetime string
+            datestr = f.readline().strip()
+            try:
+                dt = dateTimeFromStr(datestr)
+                diff = datetime.datetime.now() - dt
+            except:
+                # there might be very outdated files which still might have an invalid timestamp
+                diff = datetime.timedelta(days=thresh_d)
+            if diff.days >= thresh_d:
+                package = pkg_from_file(filename)
+                html += fmt(package, datestr) + '\n'
     html += '</pre>\n'
 
     html += '</body></html>\n'
     return html
 
 
-def diffReportFromDict(out, today):
+def diffReportFromDict(out: dict, today: str) -> str:
     html = '<pre>\n'
     html += '<b>MessageID                           ' + OLD_VERSION + '    Head</b>\n'
     sum0 = 0
@@ -245,7 +417,7 @@ def diffReportFromDict(out, today):
     return html
 
 
-def diffReport(resultsPath):
+def diffReport(resultsPath: str) -> str:
     out = {}
     outToday = {}
     today = strDateTime()[:10]
@@ -259,7 +431,7 @@ def diffReport(resultsPath):
         for messageId in data['sums']:
             sums = data['sums'][messageId]
             if OLD_VERSION not in sums:
-                continue
+                break
             if messageId not in out:
                 out[messageId] = [0, 0]
             out[messageId][0] += sums[OLD_VERSION]
@@ -270,7 +442,8 @@ def diffReport(resultsPath):
                 outToday[messageId][0] += sums[OLD_VERSION]
                 outToday[messageId][1] += sums['head']
 
-    html = '<html><head><title>Diff report</title></head><body>\n'
+    html = '<!DOCTYPE html>\n'
+    html += '<html><head><title>Diff report</title></head><body>\n'
     html += '<h1>Diff report</h1>\n'
     html += '<h2>Uploaded today</h2>'
     html += diffReportFromDict(outToday, 'today')
@@ -280,7 +453,7 @@ def diffReport(resultsPath):
     return html
 
 
-def generate_package_diff_statistics(filename):
+def generate_package_diff_statistics(filename: str) -> None:
     is_diff = False
 
     sums = {}
@@ -290,12 +463,11 @@ def generate_package_diff_statistics(filename):
         if line == 'diff:':
             is_diff = True
             continue
-        elif not is_diff:
+        if not is_diff:
             continue
         if not line.endswith(']'):
             continue
 
-        version = None
         if line.startswith(OLD_VERSION + ' '):
             version = OLD_VERSION
         elif line.startswith('head '):
@@ -306,11 +478,11 @@ def generate_package_diff_statistics(filename):
         messageId = line[line.rfind('[')+1:len(line)-1]
 
         if messageId not in sums:
-            sums[messageId] = { OLD_VERSION: 0, 'head': 0 }
+            sums[messageId] = {OLD_VERSION: 0, 'head': 0}
 
         sums[messageId][version] += 1
 
-    output = { 'date': strDateTime()[:10], 'sums': sums }
+    output = {'date': strDateTime()[:10], 'sums': sums}
 
     filename_diff = filename + '.diff'
     if sums:
@@ -320,16 +492,19 @@ def generate_package_diff_statistics(filename):
         os.remove(filename_diff)
 
 
-def diffMessageIdReport(resultPath, messageId):
+def diffMessageIdReport(resultPath: str, messageId: str) -> str:
     text = messageId + '\n'
     e = '[' + messageId + ']\n'
     for filename in sorted(glob.glob(resultPath + '/*.diff')):
         if not os.path.isfile(filename):
             continue
         with open(filename, 'rt') as f:
-          diff_stats = f.read()
-        if not messageId in diff_stats:
-          continue
+            diff_stats = json.loads(f.read())
+        if messageId not in diff_stats['sums']:
+            continue
+        if OLD_VERSION not in diff_stats['sums'][messageId]:
+            continue
+
         url = None
         diff = False
         for line in open(filename[:-5], 'rt'):
@@ -347,7 +522,7 @@ def diffMessageIdReport(resultPath, messageId):
     return text
 
 
-def diffMessageIdTodayReport(resultPath, messageId):
+def diffMessageIdTodayReport(resultPath: str, messageId: str) -> str:
     text = messageId + '\n'
     e = '[' + messageId + ']\n'
     today = strDateTime()[:10]
@@ -355,11 +530,14 @@ def diffMessageIdTodayReport(resultPath, messageId):
         if not os.path.isfile(filename):
             continue
         with open(filename, 'rt') as f:
-          diff_stats = f.read()
-        if not messageId in diff_stats:
-          continue
-        if not today in diff_stats:
-          continue
+            diff_stats = json.loads(f.read())
+        if messageId not in diff_stats['sums']:
+            continue
+        if OLD_VERSION not in diff_stats['sums'][messageId]:
+            continue
+        if today not in diff_stats["date"]:
+            continue
+
         url = None
         diff = False
         firstLine = True
@@ -382,7 +560,7 @@ def diffMessageIdTodayReport(resultPath, messageId):
     return text
 
 
-def headReportFromDict(out, today):
+def summaryReportFromDict(out: dict, prefix: str, today: str) -> str:
     html = '<pre>\n'
     html += '<b>MessageID                                  Count</b>\n'
     sumTotal = 0
@@ -395,7 +573,7 @@ def headReportFromDict(out, today):
             while len(line) < 48 - len(c):
                 line += ' '
             line += c + ' '
-        line = '<a href="head' + today + '-' + messageId + '">' + messageId + '</a>' + line[line.find(' '):]
+        line = '<a href="' + prefix + today + '-' + messageId + '">' + messageId + '</a>' + line[line.find(' '):]
         html += line + '\n'
 
     # Sum
@@ -410,17 +588,17 @@ def headReportFromDict(out, today):
     return html
 
 
-def headReport(resultsPath):
+def summaryReport(resultsPath: str, name: str, prefix: str, marker: str) -> str:
     out = {}
     outToday = {}
     today = strDateTime()[:10]
 
     for filename in sorted(glob.glob(resultsPath + '/*')):
-        if not os.path.isfile(filename):
+        if not os.path.isfile(filename) or filename.endswith('.diff'):
             continue
         uploadedToday = False
         firstLine = True
-        headResults = False
+        inResults = False
         for line in open(filename, 'rt'):
             if firstLine:
                 if line.startswith(today):
@@ -432,17 +610,15 @@ def headReport(resultsPath):
                 if OLD_VERSION not in line:
                     # Package results seem to be too old, skip
                     break
-                else:
-                    # Current package, parse on
-                    continue
-            if line.startswith('head results:'):
-                headResults = True
+                # Current package, parse on
                 continue
-            if line.startswith('diff:'):
-                if headResults:
-                    break
-            if not headResults:
+            if line.startswith(marker):
+                inResults = True
+                continue
+            if not inResults:
                 continue
+            if line.startswith('diff:'):
+                break
             if not line.endswith(']'):
                 continue
             if ': note: ' in line:
@@ -464,50 +640,79 @@ def headReport(resultsPath):
                     outToday[messageId] = 0
                 outToday[messageId] += 1
 
-    html = '<html><head><title>HEAD report</title></head><body>\n'
+    html = '<!DOCTYPE html>\n'
+    html += '<html><head><title>{} report</title></head><body>\n'.format(name)
     html += '<h1>HEAD report</h1>\n'
     html += '<h2>Uploaded today</h2>'
-    html += headReportFromDict(outToday, 'today')
+    html += summaryReportFromDict(outToday, prefix, 'today')
     html += '<h2>All</h2>'
-    html += headReportFromDict(out, '')
+    html += summaryReportFromDict(out, prefix, '')
 
     return html
 
 
-def headMessageIdReport(resultPath, messageId):
+def headReport(resultsPath: str) -> str:
+    return summaryReport(resultsPath, 'HEAD', 'head', HEAD_MARKER)
+
+
+def infoReport(resultsPath: str) -> str:
+    return summaryReport(resultsPath, 'HEAD (information)', 'headinfo', INFO_MARKER)
+
+
+def messageIdReport(resultPath: str, marker: str, messageId: str, query_params: dict) -> str:
+    pkgs = '' if query_params.get('pkgs') == '1' else None
     text = messageId + '\n'
     e = '[' + messageId + ']\n'
     for filename in sorted(glob.glob(resultPath + '/*')):
-        if not os.path.isfile(filename):
+        if not os.path.isfile(filename) or filename.endswith('.diff'):
             continue
         url = None
-        headResults = False
+        inResults = False
         for line in open(filename, 'rt'):
+            if line.startswith('cppcheck: '):
+                if OLD_VERSION not in line:
+                    # Package results seem to be too old, skip
+                    break
+                # Current package, parse on
+                continue
             if line.startswith('ftp://'):
                 url = line
-            elif line.startswith('head results:'):
-                headResults = True
-            elif not headResults:
                 continue
-            elif headResults and line.startswith('diff:'):
+            if not inResults:
+                if line.startswith(marker):
+                    inResults = True
+                continue
+            if line.startswith('diff:'):
                 break
-            elif line.endswith(e):
+            if line.endswith(e):
                 if url:
                     text += url
+                    if pkgs is not None:
+                        pkgs += url
                     url = None
                 text += line
+    if pkgs is not None:
+        return pkgs
     return text
 
 
-def headMessageIdTodayReport(resultPath, messageId):
+def headMessageIdReport(resultPath: str, messageId: str, query_params: dict) -> str:
+    return messageIdReport(resultPath, HEAD_MARKER, messageId, query_params)
+
+
+def infoMessageIdReport(resultPath: str, messageId: str, query_params: dict) -> str:
+    return messageIdReport(resultPath, INFO_MARKER, messageId, query_params)
+
+
+def messageIdTodayReport(resultPath: str, messageId: str, marker: str) -> str:
     text = messageId + '\n'
     e = '[' + messageId + ']\n'
     today = strDateTime()[:10]
     for filename in sorted(glob.glob(resultPath + '/*')):
-        if not os.path.isfile(filename):
+        if not os.path.isfile(filename) or filename.endswith('.diff'):
             continue
         url = None
-        headResults = False
+        inResults = False
         firstLine = True
         for line in open(filename, 'rt'):
             if firstLine:
@@ -516,13 +721,14 @@ def headMessageIdTodayReport(resultPath, messageId):
                     break
             if line.startswith('ftp://'):
                 url = line
-            elif line.startswith('head results:'):
-                headResults = True
-            elif not headResults:
                 continue
-            elif headResults and line.startswith('diff:'):
+            if not inResults:
+                if line.startswith(marker):
+                    inResults = True
+                continue
+            if line.startswith('diff:'):
                 break
-            elif line.endswith(e):
+            if line.endswith(e):
                 if url:
                     text += url
                     url = None
@@ -530,122 +736,268 @@ def headMessageIdTodayReport(resultPath, messageId):
     return text
 
 
-def timeReport(resultPath):
-    html = '<html><head><title>Time report</title></head><body>\n'
-    html += '<h1>Time report</h1>\n'
+def headMessageIdTodayReport(resultPath: str, messageId: str) -> str:
+    return messageIdTodayReport(resultPath, messageId, HEAD_MARKER)
+
+
+def infoMessageIdTodayReport(resultPath: str, messageId: str) -> str:
+    return messageIdTodayReport(resultPath, messageId, INFO_MARKER)
+
+
+# TODO: needs to dinicate that it returns 'tuple[str, str]' but that isn't supported until Python 3.9
+def timeReport(resultPath: str, show_gt: bool, query_params: dict):
+    # no need for package report support in "improved" report
+    pkgs = '' if show_gt and query_params and query_params.get('pkgs') == '1' else None
+    factor = float(query_params.get('factor')) if query_params and 'factor' in query_params else 2.0
+    if not show_gt:
+        factor = 1.0 / factor
+
+    title = 'Time report ({})'.format('regressed' if show_gt else 'improved')
+    html = '<!DOCTYPE html>\n'
+    html += '<html><head><title>{}</title></head><body>\n'.format(title)
+    html += '<h1>{}</h1>\n'.format(title)
     html += '<pre>\n'
-    column_widths = [25, 10, 10, 10]
+    column_width = [40, 10, 10, 10, 10, 10]
     html += '<b>'
-    html += 'Package '.ljust(column_widths[0]) + ' ' + \
-            OLD_VERSION.rjust(column_widths[1]) + ' ' + \
-            'Head'.rjust(column_widths[2]) + ' ' + \
-            'Factor'.rjust(column_widths[3])
+    html += fmt('Package', 'Date       Time', OLD_VERSION, 'Head', 'Factor', link=False, column_width=column_width)
     html += '</b>\n'
 
+    current_year = datetime.date.today().year
+
+    data = {}
+
     total_time_base = 0.0
     total_time_head = 0.0
     for filename in glob.glob(resultPath + '/*'):
-        if not os.path.isfile(filename):
+        if not os.path.isfile(filename) or filename.endswith('.diff'):
             continue
+        datestr = None
+        package_url = None
         for line in open(filename, 'rt'):
+            line = line.strip()
             if line.startswith('cppcheck: '):
                 if OLD_VERSION not in line:
                     # Package results seem to be too old, skip
                     break
-                else:
-                    # Current package, parse on
-                    continue
+                # Current package, parse on
+                continue
+            if datestr is None and line.startswith(str(current_year) + '-') or line.startswith(str(current_year - 1) + '-'):
+                datestr = line
+                continue
+            if pkgs is not None and package_url is None and line.startswith('ftp://'):
+                package_url = line
             if not line.startswith('elapsed-time:'):
                 continue
-            split_line = line.strip().split()
+            split_line = line.split()
             time_base = float(split_line[2])
             time_head = float(split_line[1])
             if time_base < 0.0 or time_head < 0.0:
                 # ignore results with crashes / errors for the time report
                 break
+            if time_base == 0.0 and time_head == 0.0:
+                # no difference possible
+                break
             total_time_base += time_base
             total_time_head += time_head
+            if time_base == time_head:
+                # no difference
+                break
+            if time_base > 0.0 and time_head > 0.0:
+                time_factor = time_head / time_base
+            elif time_base == 0.0:
+                # the smallest possible value is 0.1 so treat that as an increase of 100%
+                # on top of the existing 100% (treating the base 0.0 as such).
+                time_factor = 1.0 + (time_head * 10)
+            else:
+                time_factor = 0.0
             suspicious_time_difference = False
-            if time_base > 1 and time_base*2 < time_head:
+            if show_gt and time_factor > factor:
                 suspicious_time_difference = True
-            elif time_head > 1 and time_head*2 < time_base:
+            elif not show_gt and time_factor < factor:
                 suspicious_time_difference = True
             if suspicious_time_difference:
-                if time_base > 0.0:
-                    time_factor = time_head / time_base
-                else:
-                    time_factor = 0.0
-                html += filename[len(resultPath)+1:].ljust(column_widths[0]) + ' ' + \
-                    split_line[2].rjust(column_widths[1]) + ' ' + \
-                    split_line[1].rjust(column_widths[2]) + ' ' + \
-                    '{:.2f}'.format(time_factor).rjust(column_widths[3]) + '\n'
+                pkg_name = filename[len(resultPath)+1:]
+                data[pkg_name] = (datestr, split_line[2], split_line[1], time_factor)
+
+                if package_url is not None:
+                    pkgs += '{}\n'.format(package_url)
             break
 
+    sorted_data = sorted(data.items(), key=lambda kv: kv[1][3], reverse=show_gt)
+    sorted_dict = collections.OrderedDict(sorted_data)
+    for key in sorted_dict:
+        html += fmt(key, sorted_dict[key][0], sorted_dict[key][1], sorted_dict[key][2], '{:.2f}'.format(sorted_dict[key][3]),
+                    column_width=column_width) + '\n'
+
+    html += '\n'
+    html += '(listed above are all suspicious timings with a factor '
+    html += '&gt;' if show_gt else '&lt;'
+    html += ' {}'.format(format(factor, '.2f'))
+    html += ')\n'
     html += '\n'
     if total_time_base > 0.0:
         total_time_factor = total_time_head / total_time_base
     else:
         total_time_factor = 0.0
     html += 'Time for all packages (not just the ones listed above):\n'
-    html += 'Total time: '.ljust(column_widths[0]) + ' ' + \
-            '{:.1f}'.format(total_time_base).rjust(column_widths[1]) + ' ' + \
-            '{:.1f}'.format(total_time_head).rjust(column_widths[2]) + ' ' + \
-            '{:.2f}'.format(total_time_factor).rjust(column_widths[3])
+    html += fmt('Total time:',
+            '',
+            '{:.1f}'.format(total_time_base),
+            '{:.1f}'.format(total_time_head),
+            '{:.2f}'.format(total_time_factor), link=False, column_width=column_width)
 
     html += '\n'
     html += '</pre>\n'
     html += '</body></html>\n'
 
+    if pkgs is not None:
+        return pkgs, 'text/plain'
+    return html, 'text/html'
+
+
+def timeReportSlow(resultPath: str) -> str:
+    title = 'Time report (slowest)'
+    html = '<!DOCTYPE html>\n'
+    html += '<html><head><title>{}</title></head><body>\n'.format(title)
+    html += '<h1>{}</h1>\n'.format(title)
+    html += '<pre>\n'
+    html += '<b>'
+    html += fmt('Package', 'Date       Time', OLD_VERSION, 'Head', link=False)
+    html += '</b>\n'
+
+    current_year = datetime.date.today().year
+
+    data = {}
+
+    for filename in glob.glob(resultPath + '/*'):
+        if not os.path.isfile(filename) or filename.endswith('.diff'):
+            continue
+        datestr = None
+        for line in open(filename, 'rt'):
+            line = line.strip()
+            if line.startswith('cppcheck: '):
+                if OLD_VERSION not in line:
+                    # Package results seem to be too old, skip
+                    break
+                # Current package, parse on
+                continue
+            if datestr is None and line.startswith(str(current_year) + '-') or line.startswith(str(current_year - 1) + '-'):
+                datestr = line
+                continue
+            if line.startswith('count:'):
+                count_head = line.split()[1]
+                if count_head == 'TO!':
+                    # ignore results with timeouts
+                    break
+                continue
+            if not line.startswith('elapsed-time:'):
+                continue
+            split_line = line.split()
+            time_base = float(split_line[2])
+            time_head = float(split_line[1])
+            if time_base < 0.0 or time_head < 0.0:
+                # ignore results with crashes / errors
+                break
+            pkg_name = filename[len(resultPath)+1:]
+            data[pkg_name] = (datestr, split_line[2], split_line[1], time_head)
+            break
+
+        sorted_data = sorted(data.items(), key=lambda kv: kv[1][3])
+        if len(data) > 100:
+            first_key, _ = sorted_data[0]
+            # remove the entry with the lowest run-time
+            del data[first_key]
+
+    sorted_data = sorted(data.items(), key=lambda kv: kv[1][3], reverse=True)
+    sorted_dict = collections.OrderedDict(sorted_data)
+    for key in sorted_dict:
+        html += fmt(key, sorted_dict[key][0], sorted_dict[key][1], sorted_dict[key][2]) + '\n'
+    html += '</pre>\n'
+    html += '</body></html>\n'
+
     return html
 
 
-def check_library_report(result_path, message_id):
-    if message_id not in ('checkLibraryNoReturn', 'checkLibraryFunction', 'checkLibraryUseIgnore'):
+def check_library_report(result_path: str, message_id: str) -> str:
+    if message_id not in ('checkLibraryNoReturn', 'checkLibraryFunction', 'checkLibraryUseIgnore', 'checkLibraryCheckType', 'valueFlowBailoutIncompleteVar', 'unknownMacro'):
         error_message = 'Invalid value ' + message_id + ' for message_id parameter.'
-        print(error_message)
+        print_ts(error_message)
         return error_message
 
-    functions_shown_max = 50000
-    html = '<html><head><title>' + message_id + ' report</title></head><body>\n'
+    if message_id == 'unknownMacro':
+        metric = 'macros'
+        m_column = 'macro'
+        metric_link = 'unknown_macro'
+        start_marker = HEAD_MARKER
+    elif message_id == 'valueFlowBailoutIncompleteVar':
+        metric = 'variables'
+        m_column = 'Variable'
+        metric_link = 'incomplete_var'
+        start_marker = HEAD_MARKER
+    elif message_id == 'checkLibraryCheckType':
+        metric = 'types'
+        m_column = 'Type'
+        metric_link = 'check_library'
+        start_marker = INFO_MARKER
+    else:
+        metric = 'functions'
+        m_column = 'Function'
+        metric_link = 'check_library'
+        start_marker = INFO_MARKER
+
+    functions_shown_max = 5000
+    html = '<!DOCTYPE html>\n'
+    html += '<html><head><title>' + message_id + ' report</title></head><body>\n'
     html += '<h1>' + message_id + ' report</h1>\n'
-    html += 'Top ' + str(functions_shown_max) + ' functions are shown.'
+    html += 'Top ' + str(functions_shown_max) + ' ' + metric + ' are shown.'
     html += '<pre>\n'
     column_widths = [10, 100]
     html += '<b>'
-    html += 'Count'.rjust(column_widths[0]) + ' ' + \
-            'Function'
+    html += 'Count'.rjust(column_widths[0]) + ' ' + m_column
     html += '</b>\n'
 
     function_counts = {}
     for filename in glob.glob(result_path + '/*'):
-        if not os.path.isfile(filename):
+        if not os.path.isfile(filename) or filename.endswith('.diff'):
             continue
-        info_messages = False
+        in_results = False
         for line in open(filename, 'rt'):
             if line.startswith('cppcheck: '):
                 if OLD_VERSION not in line:
                     # Package results seem to be too old, skip
                     break
-                else:
-                    # Current package, parse on
-                    continue
-            if line == 'info messages:\n':
-                info_messages = True
-            if not info_messages:
+                # Current package, parse on
+                continue
+            if not in_results:
+                if line.startswith(start_marker):
+                    in_results = True
                 continue
+            if line.startswith('diff:'):
+                break
             if line.endswith('[' + message_id + ']\n'):
-                if message_id is 'checkLibraryFunction':
-                    function_name = line[(line.find('for function ') + len('for function ')):line.rfind('[') - 1]
+                if message_id == 'unknownMacro':
+                    marker = 'required. If '
+                    function_name = line[(line.find(marker) + len(marker)):line.rfind('is a macro') - 1]
+                elif message_id == 'valueFlowBailoutIncompleteVar':
+                    marker = 'incomplete variable '
+                    function_name = line[(line.find(marker) + len(marker)):line.rfind('[') - 1]
+                elif message_id == 'checkLibraryFunction':
+                    marker = 'for function '
+                    function_name = line[(line.find(marker) + len(marker)):line.rfind('[') - 1]
+                elif message_id == 'checkLibraryCheckType':
+                    marker = 'configuration for '
+                    function_name = line[(line.find(marker) + len(marker)):line.rfind('[') - 1]
                 else:
-                    function_name = line[(line.find(': Function ') + len(': Function ')):line.rfind('should have') - 1]
+                    marker = ': Function '
+                    function_name = line[(line.find(marker) + len(marker)):line.rfind('should have') - 1]
                 function_counts[function_name] = function_counts.setdefault(function_name, 0) + 1
 
     function_details_list = []
-    for function_name, count in sorted(function_counts.items(), key=operator.itemgetter(1), reverse=True):
+    for function_name, count in sorted(list(function_counts.items()), key=operator.itemgetter(1), reverse=True):
         if len(function_details_list) >= functions_shown_max:
             break
         function_details_list.append(str(count).rjust(column_widths[0]) + ' ' +
-                '<a href="check_library-' + urllib.quote_plus(function_name) + '">' + function_name + '</a>\n')
+                '<a href="' + metric_link + '-' + urllib.parse.quote_plus(function_name) + '">' + function_name + '</a>\n')
 
     html += ''.join(function_details_list)
     html += '</pre>\n'
@@ -655,39 +1007,139 @@ def check_library_report(result_path, message_id):
 
 
 # Lists all checkLibrary* messages regarding the given function name
-def check_library_function_name(result_path, function_name):
-    print('check_library_function_name')
-    function_name = urllib.unquote_plus(function_name)
+def check_library_function_name(result_path: str, function_name: str, query_params: dict, nonfunc_id: str='') -> str:
+    pkgs = '' if query_params.get('pkgs') == '1' else None
+    function_name = urllib.parse.unquote_plus(function_name)
+    if nonfunc_id:
+        id = '[' + nonfunc_id
+        marker = HEAD_MARKER
+    else:
+        if function_name.endswith('()'):
+            id = '[checkLibrary'
+        else:
+            id = '[checkLibraryCheckType]'
+        marker = INFO_MARKER
     output_lines_list = []
     for filename in glob.glob(result_path + '/*'):
-        if not os.path.isfile(filename):
+        if not os.path.isfile(filename) or filename.endswith('.diff'):
             continue
-        info_messages = False
-        url = None
+        in_results = False
+        package_url = None
         cppcheck_options = None
         for line in open(filename, 'rt'):
+            if line.startswith('cppcheck: '):
+                if OLD_VERSION not in line:
+                    # Package results seem to be too old, skip
+                    break
+                # Current package, parse on
+                continue
             if line.startswith('ftp://'):
-                url = line
-            elif line.startswith('cppcheck-options:'):
+                package_url = line
+                continue
+            if line.startswith('cppcheck-options:'):
                 cppcheck_options = line
-            elif line == 'info messages:\n':
-                info_messages = True
-            if not info_messages:
-                continue
-            if '[checkLibrary' in line:
-                if (' ' + function_name) in line:
-                    if url:
-                        output_lines_list.append(url)
-                        url = None
-                    if cppcheck_options:
-                        output_lines_list.append(cppcheck_options)
-                        cppcheck_options = None
-                    output_lines_list.append(line)
-
+                continue
+            if not in_results:
+                if line.startswith(marker):
+                    in_results = True
+                continue
+            if line.startswith('diff:'):
+                break
+            if id not in line:
+                continue
+            if not (' ' + function_name + ' ') in line:
+                continue
+            if pkgs is not None and package_url is not None:
+                pkgs += '{}\n'.format(package_url.strip())
+                break
+            if package_url:
+                output_lines_list.append(package_url)
+                package_url = None
+            if cppcheck_options:
+                output_lines_list.append(cppcheck_options)
+                cppcheck_options = None
+            output_lines_list.append(line)
+
+    if pkgs is not None:
+        return pkgs
     return ''.join(output_lines_list)
 
 
-def sendAll(connection, data):
+def clientsReport(results_path: str):
+    html = '<!DOCTYPE html>\n'
+    html += '<html><head><title>Clients report</title></head><body>\n'
+    html += '<h1>Clients report</h1>\n'
+    current_year = datetime.date.today().year
+    # TODO: use full profiles?
+    # TODO: add jobs
+    platforms = {}
+    py_versions = {}
+    client_versions = {}
+    compilers = {}
+    for filename in sorted(glob.glob(os.path.expanduser(results_path + '/*'))):
+        if not os.path.isfile(filename) or filename.endswith('.diff'):
+            continue
+        with open(filename, 'rt') as file_:
+            datestr = None
+            platform = None
+            py_version = None
+            client_version = None
+            compiler = None
+            for line in file_:
+                line = line.strip()
+                if line.startswith('cppcheck: '):
+                    if OLD_VERSION not in line:
+                        # Package results seem to be too old, skip
+                        break
+                    if not datestr:
+                        break
+
+                    dt = dateTimeFromStr(datestr)
+
+                    if platform and not platform in platforms or dt < dateTimeFromStr(platforms[platform]):
+                        platforms[platform] = datestr
+                    if py_version and not py_version in py_versions or dt < dateTimeFromStr(py_versions[py_version]):
+                        py_versions[py_version] = datestr
+                    if client_version and not client_version in client_versions or dt < dateTimeFromStr(client_versions[client_version]):
+                        client_versions[client_version] = datestr
+                    if compiler and not compiler in compilers or dt < dateTimeFromStr(compilers[compiler]):
+                        compilers[compiler] = datestr
+                    break #  stop processing
+
+                if datestr is None and line.startswith(str(current_year) + '-') or line.startswith(str(current_year - 1) + '-'):
+                    datestr = line
+                elif line.startswith('platform:'):
+                    platform = line.split(' ', 1)[1]
+                elif line.startswith('python:'):
+                    py_version = line.split(' ',1 )[1]
+                elif line.startswith('client-version:'):
+                    client_version = line.split(' ', 1)[1]
+                elif line.startswith('compiler:'):
+                    compiler = line.split(' ', 1)[1]
+
+    html += '<pre>\n'
+    html += 'Client versions:\n'
+    for clv in client_versions:
+        html += clv + ' - ' + client_versions[clv] + '\n'
+    html += '\n'
+    html += 'Python versions:\n'
+    for pyv in py_versions:
+        html += pyv + ' - ' + py_versions[pyv] + '\n'
+    html += '\n'
+    html += 'Platforms:\n'
+    for pl in platforms:
+        html += pl + ' - ' + platforms[pl] + '\n'
+    html += '\n'
+    html += 'Compilers:\n'
+    for cmp in compilers:
+        html += cmp + ' - ' + compilers[cmp] + '\n'
+    html += '</pre>\n'
+    html += '</body></html>\n'
+    return html
+
+
+def sendAll(connection: socket.socket, text: str) -> None:
+    data = text.encode('utf-8', 'ignore')
     while data:
         num = connection.send(data)
         if num < len(data):
@@ -696,7 +1148,7 @@ def sendAll(connection, data):
             data = None
 
 
-def httpGetResponse(connection, data, contentType):
+def httpGetResponse(connection: socket.socket, data: str, contentType: str) -> None:
     resp = 'HTTP/1.1 200 OK\r\n'
     resp += 'Connection: close\r\n'
     resp += 'Content-length: ' + str(len(data)) + '\r\n'
@@ -706,89 +1158,181 @@ def httpGetResponse(connection, data, contentType):
 
 
 class HttpClientThread(Thread):
-    def __init__(self, connection, cmd, resultPath, latestResults):
+    def __init__(self, connection: socket.socket, cmd: str, resultPath: str, latestResults: list) -> None:
         Thread.__init__(self)
         self.connection = connection
-        self.cmd = cmd[:cmd.find('\n')]
+        self.cmd = cmd
         self.resultPath = resultPath
+        self.infoPath = os.path.join(self.resultPath, 'info_output')
         self.latestResults = latestResults
 
+    # TODO: use a proper parser
+    @staticmethod
+    def parse_req(cmd):
+        req_parts = cmd.split(' ')
+        if len(req_parts) != 3 or req_parts[0] != 'GET' or not req_parts[2].startswith('HTTP'):
+            return None, None
+        url_obj = urlparse(req_parts[1])
+        return url_obj.path, dict(urllib.parse.parse_qsl(url_obj.query))
+
     def run(self):
         try:
             cmd = self.cmd
-            print('[' + strDateTime() + '] ' + cmd)
-            res = re.match(r'GET /([a-zA-Z0-9_\-\.\+%]*) HTTP', cmd)
-            if res is None:
+            url, queryParams = self.parse_req(cmd)
+            if url is None:
+                print_ts('invalid request: {}'.format(cmd))
                 self.connection.close()
                 return
-            url = res.group(1)
-            if url == '':
+            t_start = time.perf_counter()
+            if url == '/':
                 html = overviewReport()
                 httpGetResponse(self.connection, html, 'text/html')
-            elif url == 'latest.html':
+            elif url == '/latest.html':
                 html = latestReport(self.latestResults)
                 httpGetResponse(self.connection, html, 'text/html')
-            elif url == 'crash.html':
-                html = crashReport(self.resultPath)
+            elif url == '/crash.html':
+                text, mime = crashReport(self.resultPath, queryParams)
+                httpGetResponse(self.connection, text, mime)
+            elif url == '/timeout.html':
+                html = timeoutReport(self.resultPath)
                 httpGetResponse(self.connection, html, 'text/html')
-            elif url == 'stale.html':
-                html = staleReport(self.resultPath)
+            elif url == '/stale.html':
+                html = staleReport(self.resultPath, queryParams)
                 httpGetResponse(self.connection, html, 'text/html')
-            elif url == 'diff.html':
+            elif url == '/diff.html':
                 html = diffReport(self.resultPath)
                 httpGetResponse(self.connection, html, 'text/html')
-            elif url.startswith('difftoday-'):
-                messageId = url[10:]
+            elif url.startswith('/difftoday-'):
+                messageId = url[len('/difftoday-'):]
                 text = diffMessageIdTodayReport(self.resultPath, messageId)
                 httpGetResponse(self.connection, text, 'text/plain')
-            elif url.startswith('diff-'):
-                messageId = url[5:]
+            elif url.startswith('/diff-'):
+                messageId = url[len('/diff-'):]
                 text = diffMessageIdReport(self.resultPath, messageId)
                 httpGetResponse(self.connection, text, 'text/plain')
-            elif url == 'head.html':
+            elif url == '/head.html':
                 html = headReport(self.resultPath)
                 httpGetResponse(self.connection, html, 'text/html')
-            elif url.startswith('headtoday-'):
-                messageId = url[10:]
+            elif url == '/headinfo.html':
+                html = infoReport(self.infoPath)
+                httpGetResponse(self.connection, html, 'text/html')
+            elif url.startswith('/headtoday-'):
+                messageId = url[len('/headtoday-'):]
                 text = headMessageIdTodayReport(self.resultPath, messageId)
                 httpGetResponse(self.connection, text, 'text/plain')
-            elif url.startswith('head-'):
-                messageId = url[5:]
-                text = headMessageIdReport(self.resultPath, messageId)
+            elif url.startswith('/headinfotoday-'):
+                messageId = url[len('/headinfotoday-'):]
+                text = infoMessageIdTodayReport(self.infoPath, messageId)
+                httpGetResponse(self.connection, text, 'text/plain')
+            elif url.startswith('/head-'):
+                messageId = url[len('/head-'):]
+                text = headMessageIdReport(self.resultPath, messageId, queryParams)
+                httpGetResponse(self.connection, text, 'text/plain')
+            elif url.startswith('/headinfo-'):
+                messageId = url[len('/headinfo-'):]
+                text = infoMessageIdReport(self.infoPath, messageId, queryParams)
                 httpGetResponse(self.connection, text, 'text/plain')
-            elif url == 'time.html':
-                text = timeReport(self.resultPath)
+            elif url == '/time_lt.html':
+                text, mime = timeReport(self.resultPath, False, queryParams)
+                httpGetResponse(self.connection, text, mime)
+            elif url == '/time_gt.html':
+                text, mime = timeReport(self.resultPath, True, queryParams)
+                httpGetResponse(self.connection, text, mime)
+            elif url == '/time_slow.html':
+                text = timeReportSlow(self.resultPath)
                 httpGetResponse(self.connection, text, 'text/html')
-            elif url == 'check_library_function_report.html':
-                text = check_library_report(self.resultPath + '/' + 'info_output', message_id='checkLibraryFunction')
+            elif url == '/check_library_function_report.html':
+                text = check_library_report(self.infoPath, message_id='checkLibraryFunction')
                 httpGetResponse(self.connection, text, 'text/html')
-            elif url == 'check_library_noreturn_report.html':
-                text = check_library_report(self.resultPath + '/' + 'info_output', message_id='checkLibraryNoReturn')
+            elif url == '/check_library_noreturn_report.html':
+                text = check_library_report(self.infoPath, message_id='checkLibraryNoReturn')
+                httpGetResponse(self.connection, text, 'text/html')
+            elif url == '/check_library_use_ignore_report.html':
+                text = check_library_report(self.infoPath, message_id='checkLibraryUseIgnore')
+                httpGetResponse(self.connection, text, 'text/html')
+            elif url == '/check_library_check_type_report.html':
+                text = check_library_report(self.infoPath, message_id='checkLibraryCheckType')
+                httpGetResponse(self.connection, text, 'text/html')
+            elif url.startswith('/check_library-'):
+                function_name = url[len('/check_library-'):]
+                text = check_library_function_name(self.infoPath, function_name, queryParams)
+                httpGetResponse(self.connection, text, 'text/plain')
+            elif url == '/value_flow_bailout_incomplete_var.html':
+                text = check_library_report(self.resultPath, message_id='valueFlowBailoutIncompleteVar')
                 httpGetResponse(self.connection, text, 'text/html')
-            elif url == 'check_library_use_ignore_report.html':
-                text = check_library_report(self.resultPath + '/' + 'info_output', message_id='checkLibraryUseIgnore')
+            elif url == '/unknown_macro.html':
+                text = check_library_report(self.resultPath, message_id='unknownMacro')
                 httpGetResponse(self.connection, text, 'text/html')
-            elif url.startswith('check_library-'):
-                print('check library function !')
-                function_name = url[len('check_library-'):]
-                text = check_library_function_name(self.resultPath + '/' + 'info_output', function_name)
+            elif url.startswith('/incomplete_var-'):
+                var_name = url[len('/incomplete_var-'):]
+                text = check_library_function_name(self.resultPath, var_name, queryParams, nonfunc_id='valueFlowBailoutIncompleteVar')
                 httpGetResponse(self.connection, text, 'text/plain')
+            elif url.startswith('/unknown_macro-'):
+                var_name = url[len('/unknown_macro-'):]
+                text = check_library_function_name(self.resultPath, var_name, queryParams, nonfunc_id='unknownMacro')
+                httpGetResponse(self.connection, text, 'text/plain')
+            elif url.startswith('/clients.html'):
+                text = clientsReport(self.resultPath)
+                httpGetResponse(self.connection, text, 'text/html')
             else:
-                filename = resultPath + '/' + url
+                filename = self.resultPath + url
                 if not os.path.isfile(filename):
-                    print('HTTP/1.1 404 Not Found')
-                    self.connection.send('HTTP/1.1 404 Not Found\r\n\r\n')
+                    print_ts('HTTP/1.1 404 Not Found')
+                    self.connection.send(b'HTTP/1.1 404 Not Found\r\n\r\n')
                 else:
-                    f = open(filename, 'rt')
-                    data = f.read()
-                    f.close()
+                    with open(filename, 'rt') as f:
+                        data = f.read()
                     httpGetResponse(self.connection, data, 'text/plain')
+            print_ts('{} finished in {}s'.format(url, (time.perf_counter() - t_start)))
+        except:
+            tb = "".join(traceback.format_exception(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]))
+            print_ts(tb)
+            httpGetResponse(self.connection, tb, 'text/plain')
         finally:
             time.sleep(1)
             self.connection.close()
 
 
-def server(server_address_port, packages, packageIndex, resultPath):
+def read_data(connection, cmd, pos_nl, max_data_size, check_done, cmd_name, timeout=10):
+    data = cmd[pos_nl+1:]
+    t = 0.0
+    try:
+        while (len(data) < max_data_size) and (not check_done or not data.endswith('\nDONE')) and (timeout > 0 and t < timeout):
+            bytes_received = connection.recv(1024)
+            if bytes_received:
+                try:
+                    text_received = bytes_received.decode('ascii', 'ignore')
+                except UnicodeDecodeError as e:
+                    print_ts('Error: Decoding failed ({}): {}'.format(cmd_name, e))
+                    data = None
+                    break
+                t = 0.0
+                data += text_received
+            elif not check_done:
+                break
+            else:
+                time.sleep(0.2)
+                t += 0.2
+    except socket.error as e:
+        print_ts('Socket error occurred ({}): {}'.format(cmd_name, e))
+        data = None
+
+    connection.close()
+
+    if (timeout > 0) and (t >= timeout):
+        print_ts('Timeout occurred ({}).'.format(cmd_name))
+        data = None
+
+    if data and (len(data) >= max_data_size):
+        print_ts('Maximum allowed data ({} bytes) exceeded ({}).'.format(max_data_size, cmd_name))
+
+    elif data and check_done and not data.endswith('\nDONE'):
+        print_ts('Incomplete data received ({}).'.format(cmd_name))
+        data = None
+
+    return data
+
+def server(server_address_port: int, packages: list, packageIndex: int, resultPath: str) -> None:
     socket.setdefaulttimeout(30)
     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
@@ -802,80 +1346,89 @@ def server(server_address_port, packages, packageIndex, resultPath):
         with open('latest.txt', 'rt') as f:
             latestResults = f.read().strip().split(' ')
 
-    print('[' + strDateTime() + '] version ' + SERVER_VERSION)
-    print('[' + strDateTime() + '] listening on port ' + str(server_address_port))
+    print_ts('version ' + SERVER_VERSION)
+    print_ts('listening on port ' + str(server_address_port))
 
     while True:
         # wait for a connection
-        print('[' + strDateTime() + '] waiting for a connection')
-        connection, client_address = sock.accept()
+        print_ts('waiting for a connection')
+        connection, _ = sock.accept()
         try:
-            cmd = connection.recv(128)
-        except socket.error:
+            bytes_received = connection.recv(128)
+            cmd = bytes_received.decode('utf-8', 'ignore')
+        except socket.error as e:
+            print_ts('Error: Recv error: ' + str(e))
+            connection.close()
+            continue
+        except UnicodeDecodeError as e:
+            print_ts('Error: Decoding failed: ' + str(e))
             connection.close()
             continue
-        if cmd.find('\n') < 1:
+        pos_nl = cmd.find('\n')
+        if pos_nl < 1:
+            print_ts("No newline found in data: '{}'".format(cmd))
+            connection.close()
             continue
-        firstLine = cmd[:cmd.find('\n')]
+        firstLine = cmd[:pos_nl]
         if re.match('[a-zA-Z0-9./ ]+', firstLine) is None:
+            print_ts('Unsupported characters found in command: {}'.format(firstLine))
             connection.close()
             continue
         if cmd.startswith('GET /'):
+            cmd = cmd[:cmd.find('\r\n')]
+            print_ts(cmd)
             newThread = HttpClientThread(connection, cmd, resultPath, latestResults)
             newThread.start()
-        elif cmd == 'GetCppcheckVersions\n':
+            continue
+        if cmd == 'GetCppcheckVersions\n':
             reply = 'head ' + OLD_VERSION
-            print('[' + strDateTime() + '] GetCppcheckVersions: ' + reply)
-            connection.send(reply)
+            print_ts('GetCppcheckVersions: ' + reply)
+            connection.send(reply.encode('utf-8', 'ignore'))
             connection.close()
-        elif cmd == 'get\n':
-            pkg = packages[packageIndex].strip()
-            packages[packageIndex] = pkg
-            packageIndex += 1
-            if packageIndex >= len(packages):
-                packageIndex = 0
-
-            f = open('package-index.txt', 'wt')
-            f.write(str(packageIndex) + '\n')
-            f.close()
-
-            print('[' + strDateTime() + '] get:' + pkg)
-            connection.send(pkg)
+            continue
+        if cmd == 'get\n':
+            while True:
+                pkg = packages[packageIndex]
+                packageIndex += 1
+                if packageIndex >= len(packages):
+                    packageIndex = 0
+                if pkg is not None:
+                    break
+
+            with open('package-index.txt', 'wt') as f:
+                f.write(str(packageIndex) + '\n')
+
+            print_ts('get:' + pkg)
+            connection.send(pkg.encode('utf-8', 'ignore'))
             connection.close()
-        elif cmd.startswith('write\nftp://'):
-            # read data
-            data = cmd[cmd.find('ftp'):]
-            try:
-                t = 0
-                max_data_size = 2 * 1024 * 1024
-                while (len(data) < max_data_size) and (not data.endswith('\nDONE')) and (t < 10):
-                    d = connection.recv(1024)
-                    if d:
-                        t = 0
-                        data += d
-                    else:
-                        time.sleep(0.2)
-                        t += 0.2
-                connection.close()
-            except socket.error as e:
-                pass
+            continue
+        if cmd.startswith('write\nftp://') or cmd.startswith('write\nhttp://'):
+            t_start = time.perf_counter()
+            data = read_data(connection, cmd, pos_nl, max_data_size=1024 * 1024, check_done=True, cmd_name='write')
+            if data is None:
+                continue
+            truncated_data = len(data) >= 1024 * 1024
 
             pos = data.find('\n')
+            if pos == -1:
+                print_ts('No newline found in data. Ignoring result data.')
+                continue
             if pos < 10:
+                print_ts('Data is less than 10 characters. Ignoring result data.')
                 continue
             url = data[:pos]
-            print('[' + strDateTime() + '] write:' + url)
+            print_ts('write:' + url)
 
             # save data
-            res = re.match(r'ftp://.*pool/main/[^/]+/([^/]+)/[^/]*tar.(gz|bz2)', url)
+            res = re.match(r'ftp://.*pool/main/[^/]+/([^/]+)/[^/]*tar.(gz|bz2|xz)', url)
+            if res is None:
+                res = re.match(r'https?://cppcheck\.sf\.net/([a-z]+).tgz', url)
             if res is None:
-                print('results not written. res is None.')
+                print_ts('res is None. Ignoring result data.')
                 continue
             if url not in packages:
-                url2 = url + '\n'
-                if url2 not in packages:
-                    print('results not written. url is not in packages.')
-                    continue
+                print_ts('Url is not in packages. Ignoring result data.')
+                continue
             # Verify that head was compared to correct OLD_VERSION
             versions_found = False
             old_version_wrong = False
@@ -883,18 +1436,22 @@ def server(server_address_port, packages, packageIndex, resultPath):
                 if line.startswith('cppcheck: '):
                     versions_found = True
                     if OLD_VERSION not in line.split():
-                        print('Compared to wrong old version. Should be ' + OLD_VERSION + '. Versions compared: ' +
-                              line)
-                        print('Ignoring data.')
+                        print_ts('Compared to wrong old version. Should be ' + OLD_VERSION + '. Versions compared: ' +
+                              line + '. Ignoring result data.')
                         old_version_wrong = True
                     break
             if not versions_found:
-                print('Cppcheck versions missing in result data. Ignoring data.')
+                print_ts('Cppcheck versions missing in result data. Ignoring result data.')
                 continue
             if old_version_wrong:
+                print_ts('Unexpected old version. Ignoring result data.')
                 continue
-            print('results added for package ' + res.group(1))
             filename = os.path.join(resultPath, res.group(1))
+            if truncated_data:
+                print_ts('Data is too large. Removing result.')
+                if os.path.exists(filename):
+                    os.remove(filename)
+                continue
             with open(filename, 'wt') as f:
                 f.write(strDateTime() + '\n' + data)
             # track latest added results..
@@ -905,74 +1462,159 @@ def server(server_address_port, packages, packageIndex, resultPath):
                 f.write(' '.join(latestResults))
             # generate package.diff..
             generate_package_diff_statistics(filename)
-        elif cmd.startswith('write_info\nftp://'):
-            # read data
-            data = cmd[11:]
-            try:
-                t = 0
-                max_data_size = 1024 * 1024
-                while (len(data) < max_data_size) and (not data.endswith('\nDONE')) and (t < 10):
-                    d = connection.recv(1024)
-                    if d:
-                        t = 0
-                        data += d
-                    else:
-                        time.sleep(0.2)
-                        t += 0.2
-                connection.close()
-            except socket.error as e:
-                pass
+            print_ts('write finished for {} ({} bytes / {}s)'.format(res.group(1), len(data), (time.perf_counter() - t_start)))
+            continue
+        if cmd.startswith('write_info\nftp://') or cmd.startswith('write_info\nhttp://'):
+            t_start = time.perf_counter()
+            data = read_data(connection, cmd, pos_nl, max_data_size=7 * 1024 * 1024, check_done=True, cmd_name='write_info')
+            if data is None:
+                continue
+            truncated_data = len(data) >= 7 * 1024 * 1024
 
             pos = data.find('\n')
+            if pos == -1:
+                print_ts('No newline found in data. Ignoring information data.')
+                continue
             if pos < 10:
+                print_ts('Data is less than 10 characters. Ignoring information data.')
                 continue
             url = data[:pos]
-            print('[' + strDateTime() + '] write_info:' + url)
+            print_ts('write_info:' + url)
 
             # save data
-            res = re.match(r'ftp://.*pool/main/[^/]+/([^/]+)/[^/]*tar.(gz|bz2)', url)
+            res = re.match(r'ftp://.*pool/main/[^/]+/([^/]+)/[^/]*tar.(gz|bz2|xz)', url)
             if res is None:
-                print('info output not written. res is None.')
+                res = re.match(r'https://cppcheck\.sf\.net/([a-z]+).tgz', url)
+            if res is None:
+                print_ts('res is None. Ignoring information data.')
                 continue
             if url not in packages:
-                url2 = url + '\n'
-                if url2 not in packages:
-                    print('info output not written. url is not in packages.')
-                    continue
-            print('adding info output for package ' + res.group(1))
+                print_ts('Url is not in packages. Ignoring information data.')
+                continue
             info_path = resultPath + '/' + 'info_output'
             if not os.path.exists(info_path):
                 os.mkdir(info_path)
             filename = info_path + '/' + res.group(1)
+            if truncated_data:
+                print_ts('Data is too large. Removing result.')
+                if os.path.exists(filename):
+                    os.remove(filename)
+                continue
             with open(filename, 'wt') as f:
                 f.write(strDateTime() + '\n' + data)
-        else:
-            print('[' + strDateTime() + '] invalid command: ' + firstLine)
+            print_ts('write_info finished for {} ({} bytes / {}s)'.format(res.group(1), len(data), (time.perf_counter() - t_start)))
+            continue
+        if cmd == 'getPackagesCount\n':
+            packages_count = str(len(packages))
+            connection.send(packages_count.encode('utf-8', 'ignore'))
+            print_ts('getPackagesCount: ' + packages_count)
+            connection.close()
+            continue
+        if cmd.startswith('getPackageIdx'):
+            request_idx = abs(int(cmd[len('getPackageIdx:'):]))
+            if request_idx < len(packages):
+                pkg = packages[request_idx]
+                connection.send(pkg.encode('utf-8', 'ignore'))
+                print_ts('getPackageIdx: ' + pkg)
+            else:
+                print_ts('getPackageIdx: index {} is out of range'.format(request_idx))
             connection.close()
+            continue
+        if cmd.startswith('write_nodata\nftp://'):
+            data = read_data(connection, cmd, pos_nl, max_data_size=8 * 1024, check_done=False, cmd_name='write_nodata')
+            if data is None:
+                continue
+
+            pos = data.find('\n')
+            if pos == -1:
+                print_ts('No newline found in data. Ignoring no-data data.')
+                continue
+            if pos < 10:
+                print_ts('Data is less than 10 characters ({}). Ignoring no-data data.'.format(pos))
+                continue
+            url = data[:pos]
+
+            startIdx = packageIndex
+            currentIdx = packageIndex
+            while True:
+                if packages[currentIdx] == url:
+                    packages[currentIdx] = None
+                    print_ts('write_nodata:' + url)
+
+                    with open('packages_nodata.txt', 'at') as f:
+                        f.write(url + '\n')
+                    break
+                if currentIdx == 0:
+                    currentIdx = len(packages) - 1
+                else:
+                    currentIdx -= 1
+                if currentIdx == startIdx:
+                    print_ts('write_nodata:' + url + ' - package not found')
+                    break
+            continue
+
+        if pos_nl < 0:
+            print_ts('invalid command: "' + firstLine + '"')
+        else:
+            lines = cmd.split('\n')
+            s = '\\n'.join(lines[:2])
+            if len(lines) > 2:
+                s += '...'
+            print_ts('invalid command: "' + s + '"')
+        connection.close()
+        continue
 
 
 if __name__ == "__main__":
-    workPath = os.path.expanduser('~/daca@home')
+    workPath = '/var/daca@home'
+    if not os.path.isdir(workPath):
+        workPath = os.path.expanduser('~/daca@home')
     os.chdir(workPath)
+    print_ts('work path: ' + workPath)
     resultPath = workPath + '/donated-results'
+    if not os.path.isdir(resultPath):
+        print_ts("fatal: result path '{}' is missing".format(resultPath))
+        sys.exit(1)
+
+    with open('packages.txt', 'rt') as f:
+        packages = [val.strip() for val in f.readlines()]
+
+    print_ts('packages: {}'.format(len(packages)))
+
+    if os.path.isfile('packages_nodata.txt'):
+        with open('packages_nodata.txt', 'rt') as f:
+            packages_nodata = [val.strip() for val in f.readlines()]
+            packages_nodata.sort()
 
-    f = open('packages.txt', 'rt')
-    packages = f.readlines()
-    f.close()
+        print_ts('packages_nodata: {}'.format(len(packages_nodata)))
 
-    print('packages: ' + str(len(packages)))
+        print_ts('removing packages with no files to process')
+        packages_nodata_clean = []
+        for pkg_n in packages_nodata:
+            if pkg_n in packages:
+                packages.remove(pkg_n)
+                packages_nodata_clean.append(pkg_n)
+
+        packages_nodata_diff = len(packages_nodata) - len(packages_nodata_clean)
+        if packages_nodata_diff:
+            with open('packages_nodata.txt', 'wt') as f:
+                for pkg in packages_nodata_clean:
+                    f.write(pkg + '\n')
+
+            print_ts('removed {} packages from packages_nodata.txt'.format(packages_nodata_diff))
+
+        print_ts('packages: {}'.format(len(packages)))
 
     if len(packages) == 0:
-        print('fatal: there are no packages')
+        print_ts('fatal: there are no packages')
         sys.exit(1)
 
     packageIndex = 0
     if os.path.isfile('package-index.txt'):
-        f = open('package-index.txt', 'rt')
-        packageIndex = int(f.read())
+        with open('package-index.txt', 'rt') as f:
+            packageIndex = int(f.read())
         if packageIndex < 0 or packageIndex >= len(packages):
             packageIndex = 0
-        f.close()
 
     server_address_port = 8000
     if '--test' in sys.argv[1:]:
@@ -981,5 +1623,4 @@ def server(server_address_port, packages, packageIndex, resultPath):
     try:
         server(server_address_port, packages, packageIndex, resultPath)
     except socket.timeout:
-        print('Timeout!')
-
+        print_ts('Timeout!')
diff --git a/tools/donate-cpu.py b/tools/donate-cpu.py
old mode 100644
new mode 100755
index c0427f6d4e0..81c752b141f
--- a/tools/donate-cpu.py
+++ b/tools/donate-cpu.py
@@ -1,3 +1,5 @@
+#!/usr/bin/env python3
+
 # Donate CPU
 #
 # A script a user can run to donate CPU to cppcheck project
@@ -14,6 +16,8 @@
 #                                 --bandwidth-limit=2m => max. 2 megabytes per second
 #  --max-packages=N     Process N packages and then exit. A value of 0 means infinitely.
 #  --no-upload          Do not upload anything. Defaults to False.
+#  --packages           Process a list of given packages.
+#  --version            Returns the version (of the underlying donate_cpu_lib.py).
 #
 # What this script does:
 # 1. Check requirements
@@ -26,481 +30,57 @@
 #
 # Quick start: just run this script without any arguments
 
-import shutil
+import platform
 import os
-import subprocess
 import sys
-import socket
-import time
 import re
-import tarfile
-import platform
-
-
-# Version scheme (MAJOR.MINOR.PATCH) should orientate on "Semantic Versioning" https://semver.org/
-# Every change in this script should result in increasing the version number accordingly (exceptions may be cosmetic
-# changes)
-CLIENT_VERSION = "1.1.38"
-
-
-def check_requirements():
-    result = True
-    for app in ['g++', 'git', 'make', 'wget', 'gdb']:
-        try:
-            subprocess.call([app, '--version'])
-        except OSError:
-            print(app + ' is required')
-            result = False
-    return result
-
-
-def get_cppcheck(cppcheck_path, work_path):
-    print('Get Cppcheck..')
-    for i in range(5):
-        if os.path.exists(cppcheck_path):
-            try:
-                os.chdir(cppcheck_path)
-                subprocess.check_call(['git', 'checkout', '-f'])
-                subprocess.check_call(['git', 'pull'])
-            except:
-                print('Failed to update Cppcheck sources! Retrying..')
-                time.sleep(10)
-                continue
-        else:
-            try:
-                subprocess.check_call(['git', 'clone', 'https://github.com/danmar/cppcheck.git', cppcheck_path])
-            except:
-                print('Failed to clone, will try again in 10 minutes..')
-                time.sleep(600)
-                continue
-        time.sleep(2)
-        return True
-    if os.path.exists(cppcheck_path):
-        print('Failed to update Cppcheck sources, trying a fresh clone..')
-        try:
-            os.chdir(work_path)
-            shutil.rmtree(cppcheck_path)
-            get_cppcheck(cppcheck_path, work_path)
-        except:
-            print('Failed to remove Cppcheck folder, please manually remove ' + work_path)
-            return False
-    return False
-
-
-def get_cppcheck_info(cppcheck_path):
-    try:
-        os.chdir(cppcheck_path)
-        return subprocess.check_output(['git', 'show', "--pretty=%h (%ci)", 'HEAD', '--no-patch', '--no-notes']).decode('utf-8').strip()
-    except:
-        return ''
-
-
-def compile_version(work_path, jobs, version):
-    if os.path.isfile(work_path + '/' + version + '/cppcheck'):
-        return True
-    os.chdir(work_path + '/cppcheck')
-    subprocess.call(['git', 'checkout', version])
-    subprocess.call(['make', 'clean'])
-    subprocess.call(['make', jobs, 'MATCHCOMPILER=yes', 'CXXFLAGS=-O2 -g'])
-    if os.path.isfile(work_path + '/cppcheck/cppcheck'):
-        os.mkdir(work_path + '/' + version)
-        destPath = work_path + '/' + version + '/'
-        subprocess.call(['cp', '-R', work_path + '/cppcheck/cfg', destPath])
-        subprocess.call(['cp', 'cppcheck', destPath])
-    subprocess.call(['git', 'checkout', 'master'])
-    try:
-        subprocess.call([work_path + '/' + version + '/cppcheck', '--version'])
-    except OSError:
-        return False
-    return True
-
-
-def compile(cppcheck_path, jobs):
-    print('Compiling Cppcheck..')
-    try:
-        os.chdir(cppcheck_path)
-        subprocess.call(['make', jobs, 'MATCHCOMPILER=yes', 'CXXFLAGS=-O2 -g'])
-        subprocess.call([cppcheck_path + '/cppcheck', '--version'])
-    except OSError:
-        return False
-    return True
-
-
-def get_cppcheck_versions(server_address):
-    print('Connecting to server to get Cppcheck versions..')
-    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    try:
-        sock.connect(server_address)
-        sock.send(b'GetCppcheckVersions\n')
-        versions = sock.recv(256)
-    except socket.error as err:
-        print('Failed to get cppcheck versions: ' + str(err))
-        return None
-    sock.close()
-    return versions.decode('utf-8').split()
-
-
-def get_package(server_address):
-    print('Connecting to server to get assigned work..')
-    package = None
-    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    try:
-        sock.connect(server_address)
-        sock.send(b'get\n')
-        package = sock.recv(256)
-    except socket.error:
-        package = ''
-    sock.close()
-    return package.decode('utf-8')
-
-
-def handle_remove_readonly(func, path, exc):
-    import stat
-    if not os.access(path, os.W_OK):
-        # Is the error an access error ?
-        os.chmod(path, stat.S_IWUSR)
-        func(path)
-
-
-def remove_tree(folderName):
-    if not os.path.exists(folderName):
-        return
-    count = 5
-    while count > 0:
-        count -= 1
-        try:
-            shutil.rmtree(folderName, onerror=handle_remove_readonly)
-            break
-        except OSError as err:
-            time.sleep(30)
-            if count == 0:
-                print('Failed to cleanup {}: {}'.format(folderName, err))
-                sys.exit(1)
-
-
-def wget(url, destfile, bandwidth_limit):
-    if os.path.exists(destfile):
-        if os.path.isfile(destfile):
-            os.remove(destfile)
-        else:
-            print('Error: ' + destfile + ' exists but it is not a file! Please check the path and delete it manually.')
-            sys.exit(1)
-    wget_call = ['wget', '--tries=10', '--timeout=300', '-O', destfile, url]
-    if bandwidth_limit and isinstance(bandwidth_limit, str):
-        wget_call.append('--limit-rate=' + bandwidth_limit)
-    exitcode = subprocess.call(wget_call)
-    if exitcode != 0:
-        print('wget failed with ' + str(exitcode))
-        os.remove(destfile)
-        return False
-    if not os.path.isfile(destfile):
-        return False
-    return True
-
-
-def download_package(work_path, package, bandwidth_limit):
-    print('Download package ' + package)
-    destfile = work_path + '/temp.tgz'
-    if not wget(package, destfile, bandwidth_limit):
-        return None
-    return destfile
-
-
-def unpack_package(work_path, tgz):
-    print('Unpacking..')
-    temp_path = work_path + '/temp'
-    remove_tree(temp_path)
-    os.mkdir(temp_path)
-    os.chdir(temp_path)
-    found = False
-    if tarfile.is_tarfile(tgz):
-        tf = tarfile.open(tgz)
-        for member in tf:
-            if member.name.startswith(('/', '..')):
-                # Skip dangerous file names
-                continue
-            elif member.name.lower().endswith(('.c', '.cpp', '.cxx', '.cc', '.c++', '.h', '.hpp',
-                                               '.h++', '.hxx', '.hh', '.tpp', '.txx', '.qml')):
-                try:
-                    tf.extract(member.name)
-                    found = True
-                except OSError:
-                    pass
-                except AttributeError:
-                    pass
-        tf.close()
-    os.chdir(work_path)
-    return found
-
-
-def has_include(path, includes):
-    re_includes = [re.escape(inc) for inc in includes]
-    re_expr = '^[ \t]*#[ \t]*include[ \t]*(' + '|'.join(re_includes) + ')'
-    for root, _, files in os.walk(path):
-        for name in files:
-            filename = os.path.join(root, name)
-            try:
-                if sys.version_info.major < 3:
-                    f = open(filename, 'rt')
-                else:
-                    f = open(filename, 'rt', errors='ignore')
-                filedata = f.read()
-                try:
-                    # Python2 needs to decode the data first
-                    filedata = filedata.decode(encoding='utf-8', errors='ignore')
-                except AttributeError:
-                    # Python3 directly reads the data into a string object that has no decode()
-                    pass
-                f.close()
-                if re.search(re_expr, filedata, re.MULTILINE):
-                    return True
-            except IOError:
-                pass
-    return False
-
-
-def run_command(cmd):
-    print(cmd)
-    startTime = time.time()
-    p = subprocess.Popen(cmd.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    comm = p.communicate()
-    stop_time = time.time()
-    stdout = comm[0].decode(encoding='utf-8', errors='ignore')
-    stderr = comm[1].decode(encoding='utf-8', errors='ignore')
-    elapsed_time = stop_time - startTime
-    return p.returncode, stdout, stderr, elapsed_time
-
-
-def scan_package(work_path, cppcheck_path, jobs, libraries):
-    print('Analyze..')
-    os.chdir(work_path)
-    libs = ''
-    for library in libraries:
-        if os.path.exists(os.path.join(cppcheck_path, 'cfg', library + '.cfg')):
-            libs += ' --library=' + library
-
-    # Reference for GNU C: https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
-    options = jobs + libs + ' -D__GNUC__ --showtime=top5 --check-library --inconclusive --enable=style,information --platform=unix64 --template=daca2 -rp=temp temp'
-    cppcheck_cmd = cppcheck_path + '/cppcheck' + ' ' + options
-    cmd = 'nice ' + cppcheck_cmd
-    returncode, stdout, stderr, elapsed_time = run_command(cmd)
-    sig_num = -1
-    sig_msg = 'Internal error: Child process crashed with signal '
-    sig_pos = stderr.find(sig_msg)
-    if sig_pos != -1:
-        sig_start_pos = sig_pos + len(sig_msg)
-        sig_num = int(stderr[sig_start_pos:stderr.find(' ', sig_start_pos)])
-    print('cppcheck finished with ' + str(returncode) + ('' if sig_num == -1 else ' (signal ' + str(sig_num) + ')'))
-    # generate stack trace for SIGSEGV, SIGABRT, SIGILL, SIGFPE, SIGBUS
-    if returncode in (-11,-6,-4,-8,-7) or sig_num in (11,6,4,8,7):
-        print('Crash!')
-        stacktrace = ''
-        if cppcheck_path == 'cppcheck':
-            # re-run within gdb to get a stacktrace
-            cmd = 'gdb --batch --eval-command=run --eval-command=bt --return-child-result --args ' + cppcheck_cmd + " -j1"
-            dummy, stdout, stderr, elapsed_time = run_command(cmd)
-            gdb_pos = stdout.find(" received signal")
-            if not gdb_pos == -1:
-                last_check_pos = stdout.rfind('Checking ', 0, gdb_pos)
-                if last_check_pos == -1:
-                    stacktrace = stdout[gdb_pos:]
-                else:
-                    stacktrace = stdout[last_check_pos:]
-        return returncode, stacktrace, '', returncode, options, ''
-    if returncode != 0:
-        print('Error!')
-        if returncode > 0:
-            returncode = -100-returncode
-        return returncode, stdout, '', returncode, options, ''
-    if stderr.find('Internal error: Child process crashed with signal ') > 0:
-        print('Error!')
-        s = 'Internal error: Child process crashed with signal '
-        pos1 = stderr.find(s)
-        pos2 = stderr.find(' [cppcheckError]', pos1)
-        signr = int(stderr[pos1+len(s):pos2])
-        return -signr, '', '', -signr, options, ''
-    if stderr.find('#### ThreadExecutor') > 0:
-        print('Thread!')
-        return -222, '', '', -222, options, ''
-    information_messages_list = []
-    issue_messages_list = []
-    count = 0
-    for line in stderr.split('\n'):
-        if ': information: ' in line:
-            information_messages_list.append(line + '\n')
-        elif line:
-            issue_messages_list.append(line + '\n')
-            if re.match(r'.*:[0-9]+:.*\]$', line):
-                count += 1
-    print('Number of issues: ' + str(count))
-    # Collect timing information
-    stdout_lines = stdout.split('\n')
-    timing_info_list = []
-    overall_time_found = False
-    max_timing_lines = 6
-    current_timing_lines = 0
-    for reverse_line in reversed(stdout_lines):
-        if reverse_line.startswith('Overall time:'):
-            overall_time_found = True
-        if overall_time_found:
-            if not reverse_line or current_timing_lines >= max_timing_lines:
-                break
-            timing_info_list.insert(0, ' ' + reverse_line + '\n')
-            current_timing_lines += 1
-    timing_str = ''.join(timing_info_list)
-    return count, ''.join(issue_messages_list), ''.join(information_messages_list), elapsed_time, options, timing_str
-
-
-def split_results(results):
-    ret = []
-    w = None
-    for line in results.split('\n'):
-        if line.endswith(']') and re.search(r': (error|warning|style|performance|portability|information|debug):', line):
-            if w is not None:
-                ret.append(w.strip())
-            w = ''
-        if w is not None:
-            w += ' ' * 5 + line + '\n'
-    if w is not None:
-        ret.append(w.strip())
-    return ret
-
-
-def diff_results(work_path, ver1, results1, ver2, results2):
-    print('Diff results..')
-    ret = ''
-    r1 = sorted(split_results(results1))
-    r2 = sorted(split_results(results2))
-    i1 = 0
-    i2 = 0
-    while i1 < len(r1) and i2 < len(r2):
-        if r1[i1] == r2[i2]:
-            i1 += 1
-            i2 += 1
-        elif r1[i1] < r2[i2]:
-            ret += ver1 + ' ' + r1[i1] + '\n'
-            i1 += 1
-        else:
-            ret += ver2 + ' ' + r2[i2] + '\n'
-            i2 += 1
-    while i1 < len(r1):
-        ret += ver1 + ' ' + r1[i1] + '\n'
-        i1 += 1
-    while i2 < len(r2):
-        ret += ver2 + ' ' + r2[i2] + '\n'
-        i2 += 1
-
-    return ret
-
-
-def send_all(connection, data):
-    bytes = data.encode('ascii', 'ignore')
-    while bytes:
-        num = connection.send(bytes)
-        if num < len(bytes):
-            bytes = bytes[num:]
-        else:
-            bytes = None
-
-
-def upload_results(package, results, server_address):
-    print('Uploading results.. ' + str(len(results)) + ' bytes')
-    max_retries = 4
-    for retry in range(max_retries):
-        try:
-            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            sock.connect(server_address)
-            cmd = 'write\n'
-            send_all(sock, cmd + package + '\n' + results + '\nDONE')
-            sock.close()
-            print('Results have been successfully uploaded.')
-            return True
-        except socket.error as err:
-            print('Upload error: ' + str(err))
-            if retry < (max_retries - 1):
-                print('Retrying upload in 30 seconds')
-                time.sleep(30)
-    print('Upload permanently failed!')
-    return False
-
-
-def upload_info(package, info_output, server_address):
-    print('Uploading information output.. ' + str(len(info_output)) + ' bytes')
-    max_retries = 3
-    for retry in range(max_retries):
-        try:
-            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-            sock.connect(server_address)
-            send_all(sock, 'write_info\n' + package + '\n' + info_output + '\nDONE')
-            sock.close()
-            print('Information output has been successfully uploaded.')
-            return True
-        except socket.error as err:
-            print('Upload error: ' + str(err))
-            if retry < (max_retries - 1):
-                print('Retrying upload in 30 seconds')
-                time.sleep(30)
-    print('Upload permanently failed!')
-    return False
-
-
-def get_libraries():
-    libraries = ['posix', 'gnu']
-    library_includes = {'boost': ['<boost/'],
-                       # 'cairo': ['<cairo.h>'], <= enable after release of version 1.90
-                       'cppunit': ['<cppunit/'],
-                       'googletest': ['<gtest/gtest.h>'],
-                       'gtk': ['<gtk/gtk.h>', '<glib.h>', '<glib/', '<gnome.h>'],
-                       'libcerror': ['<libcerror.h>'],
-                       'libcurl': ['<curl/curl.h>'],
-                       'lua': ['<lua.h>', '"lua.h"'],
-                       'microsoft_sal': ['<sal.h>'],
-                       'motif': ['<X11/', '<Xm/'],
-                       'nspr': ['<prtypes.h>', '"prtypes.h"'],
-                       'opengl': ['<GL/gl.h>', '<GL/glu.h>', '<GL/glut.h>'],
-                       'openmp': ['<omp.h>'],
-                       'python': ['<Python.h>', '"Python.h"'],
-                       'qt': ['<QApplication>', '<QList>', '<qlist.h>', '<QObject>', '<QString>', '<qstring.h>', '<QWidget>', '<QtWidgets>', '<QtGui'],
-                       'ruby': ['<ruby.h>', '<ruby/', '"ruby.h"'],
-                       'sdl': ['<SDL.h>', '<SDL/SDL.h>', '<SDL2/SDL.h>'],
-                       'sqlite3': ['<sqlite3.h>', '"sqlite3.h"'],
-                       'tinyxml2': ['<tinyxml2', '"tinyxml2'],
-                       'wxwidgets': ['<wx/', '"wx/'],
-                       'zlib': ['<zlib.h>'],
-                      }
-    for library, includes in library_includes.items():
-        if has_include('temp', includes):
-            libraries.append(library)
-    return libraries
+import time
+import subprocess
+import donate_cpu_lib as lib
 
+from packaging.version import Version
 
-jobs = '-j1'
-stop_time = None
-work_path = os.path.expanduser('~/cppcheck-donate-cpu-workfolder')
-package_url = None
-server_address = ('cppcheck1.osuosl.org', 8000)
-bandwidth_limit = None
+__my_script_name = os.path.splitext(os.path.basename(sys.argv[0]))[0]
+work_path = os.path.expanduser(os.path.join('~', 'cppcheck-' + __my_script_name + '-workfolder'))
 max_packages = None
+package_urls = []
 do_upload = True
+bandwidth_limit = None
+stop_time = None
+
 for arg in sys.argv[1:]:
     # --stop-time=12:00 => run until ~12:00 and then stop
     if arg.startswith('--stop-time='):
         stop_time = arg[-5:]
         print('Stop time:' + stop_time)
     elif arg.startswith('-j'):
-        jobs = arg
-        print('Jobs:' + jobs[2:])
+        if not re.match(r'-j\d+', arg):
+            print('Argument "{}" is invalid.'.format(arg))
+            print('"-j" must be followed by a positive number.')
+            sys.exit(1)
+        print('Jobs:' + arg[2:])
+        lib.set_jobs(arg)
     elif arg.startswith('--package='):
-        package_url = arg[arg.find('=')+1:]
-        print('Package:' + package_url)
+        pkg = arg[arg.find('=')+1:]
+        package_urls.append(pkg)
+        print('Added Package:' + pkg)
+    elif arg.startswith('--packages='):
+        pkg_cnt = len(package_urls)
+        with open(arg[arg.find('=')+1:], 'rt') as f:
+            for package_url in f:
+                package_url = package_url.strip()
+                if not package_url:
+                    continue
+                package_urls.append(package_url)
+        print('Added Packages:' + str(len(package_urls) - pkg_cnt))
     elif arg.startswith('--work-path='):
-        work_path = arg[arg.find('=')+1:]
+        work_path = os.path.abspath(arg[arg.find('=')+1:])
         print('work_path:' + work_path)
         if not os.path.exists(work_path):
             print('work path does not exist!')
             sys.exit(1)
     elif arg == '--test':
-        server_address = ('localhost', 8001)
+        lib.set_server_address(('localhost', 8001))
     elif arg.startswith('--bandwidth-limit='):
         bandwidth_limit = arg[arg.find('=')+1:]
     elif arg.startswith('--max-packages='):
@@ -519,6 +99,9 @@ def get_libraries():
             max_packages = None
     elif arg.startswith('--no-upload'):
         do_upload = False
+    elif arg == '--version':
+        print(lib.get_client_version())
+        sys.exit(0)
     elif arg == '--help':
         print('Donate CPU to Cppcheck project')
         print('')
@@ -533,6 +116,8 @@ def get_libraries():
         print('                                 --bandwidth-limit=2m => max. 2 megabytes per second')
         print('  --max-packages=N     Process N packages and then exit. A value of 0 means infinitely.')
         print('  --no-upload          Do not upload anything. Defaults to False.')
+        print('  --packages           Process a list of given packages.')
+        print('  --version            Returns the version (of the underlying donate_cpu_lib.py).')
         print('')
         print('Quick start: just run this script without any arguments')
         sys.exit(0)
@@ -540,70 +125,109 @@ def get_libraries():
         print('Unhandled argument: ' + arg)
         sys.exit(1)
 
+if sys.version_info.major < 3 or (sys.version_info.major == 3 and sys.version_info.minor < 7):
+    print("#" * 80)
+    print("IMPORTANT")
+    print("Please run the client with at least Python 3.7, thanks!")
+    print("#" * 80)
+    time.sleep(2)
+    sys.exit(1)
+
 print('Thank you!')
-if not check_requirements():
+if not lib.check_requirements():
     sys.exit(1)
 if bandwidth_limit and isinstance(bandwidth_limit, str):
-    if subprocess.call(['wget', '--limit-rate=' + bandwidth_limit, '-q', '--spider', 'cppcheck1.osuosl.org']) is 2:
+    if subprocess.call(['wget', '--limit-rate=' + bandwidth_limit, '-q', '--spider', 'cppcheck1.osuosl.org']) == 2:
         print('Error: Bandwidth limit value "' + bandwidth_limit + '" is invalid.')
         sys.exit(1)
     else:
         print('Bandwidth-limit: ' + bandwidth_limit)
-if package_url:
-    max_packages = 1
+if package_urls:
+    max_packages = len(package_urls)
 if max_packages:
     print('Maximum number of packages to download and analyze: {}'.format(max_packages))
 if not os.path.exists(work_path):
     os.mkdir(work_path)
-cppcheck_path = os.path.join(work_path, 'cppcheck')
+repo_path = os.path.join(work_path, 'repo')
+# This is a temporary migration step which should be removed in the future
+migrate_repo_path = os.path.join(work_path, 'cppcheck')
+
 packages_processed = 0
+
+print('Get Cppcheck..')
+try:
+    lib.try_retry(lib.clone_cppcheck, fargs=(repo_path, migrate_repo_path))
+except Exception as e:
+    print('Error: Failed to clone Cppcheck ({}), retry later'.format(e))
+    sys.exit(1)
+
 while True:
     if max_packages:
         if packages_processed >= max_packages:
             print('Processed the specified number of {} package(s). Exiting now.'.format(max_packages))
             break
-        else:
-            print('Processing package {} of the specified {} package(s).'.format(packages_processed + 1, max_packages))
+        print('Processing package {} of the specified {} package(s).'.format(packages_processed + 1, max_packages))
         packages_processed += 1
     if stop_time:
         print('stop_time:' + stop_time + '. Time:' + time.strftime('%H:%M') + '.')
         if stop_time < time.strftime('%H:%M'):
             print('Stopping. Thank you!')
             sys.exit(0)
-    if not get_cppcheck(cppcheck_path, work_path):
-        print('Failed to clone Cppcheck, retry later')
-        sys.exit(1)
-    cppcheck_versions = get_cppcheck_versions(server_address)
-    if cppcheck_versions is None:
-        print('Failed to communicate with server, retry later')
-        sys.exit(1)
-    if len(cppcheck_versions) == 0:
-        print('Did not get any cppcheck versions from server, retry later')
+    try:
+        cppcheck_versions = lib.try_retry(lib.get_cppcheck_versions, max_tries=3, sleep_duration=30.0, sleep_factor=1.0)
+    except Exception as e:
+        print('Failed to get cppcheck versions from server ({}), retry later'.format(e))
         sys.exit(1)
     for ver in cppcheck_versions:
         if ver == 'head':
-            if not compile(cppcheck_path, jobs):
-                print('Failed to compile Cppcheck, retry later')
-                sys.exit(1)
-        elif not compile_version(work_path, jobs, ver):
-            print('Failed to compile Cppcheck-{}, retry later'.format(ver))
+            ver = 'main'
+        current_cppcheck_dir = os.path.join(work_path, 'tree-'+ver)
+        if ver != 'main' and lib.has_binary(current_cppcheck_dir):
+            print('No need to check Cppcheck-{} for changes - binary already exists'.format(ver))
+            continue
+        print('Checking Cppcheck-{} for changes..'.format(ver))
+        try:
+            has_changes = lib.try_retry(lib.checkout_cppcheck_version, fargs=(repo_path, ver, current_cppcheck_dir), max_tries=3, sleep_duration=30.0, sleep_factor=1.0)
+        except KeyboardInterrupt as e:
+            # Passthrough for user abort
+            raise e
+        except Exception as e:
+            print('Failed to update Cppcheck-{} ({}), retry later'.format(ver, e))
             sys.exit(1)
-    if package_url:
-        package = package_url
+        if ver == 'main':
+            if (has_changes or not lib.has_binary(current_cppcheck_dir)) and not lib.compile_cppcheck(current_cppcheck_dir):
+                print('Failed to compile Cppcheck-{}, retry later'.format(ver))
+                sys.exit(1)
+        else:
+            if not lib.compile_version(current_cppcheck_dir):
+                print('Failed to compile Cppcheck-{}, retry later'.format(ver))
+                sys.exit(1)
+    if package_urls:
+        package = package_urls[packages_processed-1]
     else:
-        package = get_package(server_address)
-    while len(package) == 0:
-        print("network or server might be temporarily down.. will try again in 30 seconds..")
-        time.sleep(30)
-        package = get_package(server_address)
-    tgz = download_package(work_path, package, bandwidth_limit)
+        try:
+            package = lib.get_package()
+        except Exception as e:
+            print('Error: Failed to get package ({}), retry later'.format(e))
+            sys.exit(1)
+    tgz = lib.download_package(work_path, package, bandwidth_limit)
     if tgz is None:
         print("No package downloaded")
         continue
-    if not unpack_package(work_path, tgz):
+    skip_files = None
+    if package.find('/qtcreator/') > 0:
+        # macro_pounder_fn.c is a preprocessor torture test that takes time to finish
+        skip_files = ('macro_pounder_fn.c',)
+    source_path, source_found = lib.unpack_package(work_path, tgz, skip_files=skip_files)
+    if not source_found:
         print("No files to process")
+        if do_upload:
+            lib.upload_nodata(package)
+            print('Sleep 5 seconds..')
+            time.sleep(5)
         continue
     crash = False
+    timeout = False
     count = ''
     elapsed_time = ''
     results_to_diff = []
@@ -612,25 +236,44 @@ def get_libraries():
     head_timing_info = ''
     old_timing_info = ''
     cppcheck_head_info = ''
-    libraries = get_libraries()
+    client_version_head = ''
+    libraries = lib.library_includes.get_libraries(source_path)
 
     for ver in cppcheck_versions:
+        tree_path = os.path.join(work_path, 'tree-'+ver)
+        capture_callstack = False
         if ver == 'head':
-            current_cppcheck_dir = 'cppcheck'
-            cppcheck_head_info = get_cppcheck_info(work_path + '/cppcheck')
-        else:
-            current_cppcheck_dir = ver
-        c, errout, info, t, cppcheck_options, timing_info = scan_package(work_path, current_cppcheck_dir, jobs, libraries)
+            tree_path = os.path.join(work_path, 'tree-main')
+            cppcheck_head_info = lib.get_cppcheck_info(tree_path)
+            capture_callstack = True
+
+            def get_client_version_head(path):
+                cmd = 'python3' + ' ' + os.path.join(path, 'tools', 'donate-cpu.py') + ' ' + '--version'
+                with subprocess.Popen(cmd.split(), stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, universal_newlines=True) as p:
+                    try:
+                        # TODO: handle p.returncode?
+                        stdout, _ = p.communicate()
+                    except:
+                        return None
+                return stdout.strip()
+
+            client_version_head = get_client_version_head(tree_path)
+        c, errout, info, t, cppcheck_options, timing_info = lib.scan_package(tree_path, source_path, libraries, capture_callstack)
         if c < 0:
             if c == -101 and 'error: could not find or open any of the paths given.' in errout:
                 # No sourcefile found (for example only headers present)
                 count += ' 0'
+            elif c == lib.RETURN_CODE_TIMEOUT:
+                # Timeout
+                count += ' TO!'
+                timeout = True
             else:
                 crash = True
                 count += ' Crash!'
         else:
             count += ' ' + str(c)
         elapsed_time += " {:.1f}".format(t)
+        errout = errout.replace(work_path, '[...]')
         results_to_diff.append(errout)
         if ver == 'head':
             head_info_msg = info
@@ -641,7 +284,8 @@ def get_libraries():
     output = 'cppcheck-options: ' + cppcheck_options + '\n'
     output += 'platform: ' + platform.platform() + '\n'
     output += 'python: ' + platform.python_version() + '\n'
-    output += 'client-version: ' + CLIENT_VERSION + '\n'
+    output += 'client-version: ' + lib.get_client_version() + '\n'
+    output += 'compiler: ' + lib.get_compiler_version() + '\n'
     output += 'cppcheck: ' + ' '.join(cppcheck_versions) + '\n'
     output += 'head-info: ' + cppcheck_head_info + '\n'
     output += 'count:' + count + '\n'
@@ -652,17 +296,19 @@ def get_libraries():
     info_output += 'info messages:\n' + head_info_msg
     if 'head' in cppcheck_versions:
         output += 'head results:\n' + results_to_diff[cppcheck_versions.index('head')]
-    if not crash:
-        output += 'diff:\n' + diff_results(work_path, cppcheck_versions[0], results_to_diff[0], cppcheck_versions[1], results_to_diff[1]) + '\n'
-    if package_url:
+    if not crash and not timeout:
+        output += 'diff:\n' + lib.diff_results(cppcheck_versions[0], results_to_diff[0], cppcheck_versions[1], results_to_diff[1]) + '\n'
+    if package_urls:
         print('=========================================================')
         print(output)
         print('=========================================================')
         print(info_output)
         print('=========================================================')
     if do_upload:
-        upload_results(package, output, server_address)
-        upload_info(package, info_output, server_address)
+        if lib.upload_results(package, output):
+            lib.upload_info(package, info_output)
     if not max_packages or packages_processed < max_packages:
         print('Sleep 5 seconds..')
+        if (client_version_head is not None) and (Version(client_version_head) > Version(lib.get_client_version())):
+            print("ATTENTION: A newer client version ({}) is available - please update!".format(client_version_head))
         time.sleep(5)
diff --git a/tools/donate_cpu_lib.py b/tools/donate_cpu_lib.py
new file mode 100644
index 00000000000..44d3157bc40
--- /dev/null
+++ b/tools/donate_cpu_lib.py
@@ -0,0 +1,791 @@
+# Donate CPU client library
+
+import shutil
+import os
+import subprocess
+import sys
+import socket
+import time
+import re
+import signal
+import tarfile
+import shlex
+import copy
+
+
+# Version scheme (MAJOR.MINOR.PATCH) should orientate on "Semantic Versioning" https://semver.org/
+# Every change in this script should result in increasing the version number accordingly (exceptions may be cosmetic
+# changes)
+CLIENT_VERSION = "1.3.70"
+
+# Timeout for analysis with Cppcheck in seconds
+CPPCHECK_TIMEOUT = 30 * 60
+
+CPPCHECK_REPO_URL = "https://github.com/danmar/cppcheck.git"
+
+# Return code that is used to mark a timed out analysis
+RETURN_CODE_TIMEOUT = -999
+
+__jobs = '-j1'
+__server_address = ('cppcheck1.osuosl.org', 8000)
+__make_cmd = None
+
+def detect_make():
+    make_cmds = ['make', 'mingw32-make']
+    if sys.platform == 'win32':
+        make_cmds.append('msbuild.exe')
+
+    for m in make_cmds:
+        try:
+            subprocess.check_call([m, '--version'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        except OSError:
+            continue
+
+        print("using '{}'".format(m))
+        return m
+
+    print("Error: a make command ({}) is required".format(','.join(make_cmds)))
+    return None
+
+
+def check_requirements():
+    result = True
+
+    global __make_cmd
+    __make_cmd = detect_make()
+    if __make_cmd is None:
+        result = False
+
+    apps = ['git', 'wget']
+    if __make_cmd in ['make', 'mingw32-make']:
+        apps.append('g++')
+        apps.append('gdb')
+
+    for app in apps:
+        try:
+            #print('{} --version'.format(app))
+            subprocess.check_call([app, '--version'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        except OSError:
+            print("Error: '{}' is required".format(app))
+            result = False
+
+    try:
+        # pylint: disable-next=unused-import - intentional
+        import psutil
+    except ImportError as e:
+        print("Error: {}. Module is required.".format(e))
+        result = False
+
+    return result
+
+
+# Try and retry with exponential backoff if an exception is raised
+# pylint: disable-next=inconsistent-return-statements
+def try_retry(fun, fargs=(), max_tries=5, sleep_duration=5.0, sleep_factor=2.0):
+    for i in range(max_tries):
+        try:
+            return fun(*fargs)
+        except KeyboardInterrupt as e:
+            # Do not retry in case of user abort
+            raise e
+        except BaseException as e:
+            if i < max_tries - 1:
+                print("{} in {}: {}".format(type(e).__name__, fun.__name__, str(e)))
+                print("Trying {} again in {} seconds".format(fun.__name__, sleep_duration))
+                time.sleep(sleep_duration)
+                sleep_duration *= sleep_factor
+                # do not return - re-try
+            else:
+                print("Maximum number of tries reached for {}".format(fun.__name__))
+                raise e
+
+
+def clone_cppcheck(repo_path, migrate_from_path):
+    repo_git_dir = os.path.join(repo_path, '.git')
+    if os.path.exists(repo_git_dir):
+        return
+    # Attempt to migrate clone directory used prior to 1.3.17
+    if os.path.exists(migrate_from_path):
+        os.rename(migrate_from_path, repo_path)
+    else:
+        # A shallow git clone (depth = 1) is enough for building and scanning.
+        # Do not checkout until fetch_cppcheck_version.
+        subprocess.check_call(['git', 'clone', '--depth=1', '--no-checkout', CPPCHECK_REPO_URL, repo_path])
+        # Checkout an empty branch to allow "git worktree add" for main later on
+    try:
+        # git >= 2.27
+        subprocess.check_call(['git', 'switch', '--orphan', 'empty'], cwd=repo_path)
+    except subprocess.CalledProcessError:
+        subprocess.check_call(['git', 'checkout', '--orphan', 'empty'], cwd=repo_path)
+
+
+def checkout_cppcheck_version(repo_path, version, cppcheck_path):
+    if not os.path.isabs(cppcheck_path):
+        raise ValueError("cppcheck_path is not an absolute path")
+    if os.path.exists(cppcheck_path):
+        print('Checking out {}'.format(version))
+        subprocess.check_call(['git', 'checkout', '-f', version], cwd=cppcheck_path)
+
+        # It is possible to pull branches, not tags
+        if version != 'main':
+            return False
+
+        hash_old = subprocess.check_output(['git', 'rev-parse', '--short', 'HEAD'], cwd=cppcheck_path).strip()
+
+        print('Pulling {}'.format(version))
+        # --rebase is a workaround for a dropped commit - see https://github.com/danmar/cppcheck/pull/6904
+        # TODO: drop the commit in question
+        # TOD: remove --rebase
+        subprocess.check_call(['git', 'pull', '--rebase'], cwd=cppcheck_path)
+
+        hash_new = subprocess.check_output(['git', 'rev-parse', '--short', 'HEAD'], cwd=cppcheck_path).strip()
+
+        has_changes = hash_old != hash_new
+        if not has_changes:
+            print('No changes detected')
+        return has_changes
+
+    if version != 'main':
+        print('Fetching {}'.format(version))
+        # Since this is a shallow clone, explicitly fetch the remote version tag
+        refspec = 'refs/tags/' + version + ':ref/tags/' + version
+        subprocess.check_call(['git', 'fetch', '--depth=1', 'origin', refspec], cwd=repo_path)
+    print('Adding worktree \'{}\' for {}'.format(cppcheck_path, version))
+    subprocess.check_call(['git', 'worktree', 'add', cppcheck_path,  version], cwd=repo_path)
+    return True
+
+
+def get_cppcheck_info(cppcheck_path):
+    try:
+        return subprocess.check_output(['git', 'show', "--pretty=%h (%ci)", 'HEAD', '--no-patch', '--no-notes'], universal_newlines=True, cwd=cppcheck_path).strip()
+    except:
+        return ''
+
+
+def __get_cppcheck_binary(cppcheck_path):
+    if __make_cmd == "msbuild.exe":
+        return os.path.join(cppcheck_path, 'bin', 'cppcheck.exe')
+    if __make_cmd == 'mingw32-make':
+        return os.path.join(cppcheck_path, 'cppcheck.exe')
+    return os.path.join(cppcheck_path, 'cppcheck')
+
+
+def has_binary(cppcheck_path):
+    cppcheck_bin = __get_cppcheck_binary(cppcheck_path)
+    if __make_cmd == "msbuild.exe":
+        if os.path.isfile(cppcheck_bin):
+            return True
+    elif __make_cmd == 'mingw32-make':
+        if os.path.isfile(cppcheck_bin):
+            return True
+    elif os.path.isfile(cppcheck_bin):
+        return True
+    return False
+
+
+def compile_version(cppcheck_path):
+    if has_binary(cppcheck_path):
+        return True
+    # Build
+    ret = compile_cppcheck(cppcheck_path)
+    # Clean intermediate build files
+    if __make_cmd == "msbuild.exe":
+        exclude_bin = 'bin'
+    elif __make_cmd == 'mingw32-make':
+        exclude_bin = 'cppcheck.exe'
+    else:
+        exclude_bin = 'cppcheck'
+    # TODO: how to support multiple compilers on the same machine? this will clean msbuild.exe files in a mingw32-make build and vice versa
+    subprocess.check_call(['git', 'clean', '-f', '-d', '-x', '--exclude', exclude_bin], cwd=cppcheck_path)
+    return ret
+
+
+def compile_cppcheck(cppcheck_path):
+    print('Compiling {}'.format(os.path.basename(cppcheck_path)))
+
+    cppcheck_bin = __get_cppcheck_binary(cppcheck_path)
+    # remove file so interrupted "main" branch compilation is being resumed
+    if os.path.isfile(cppcheck_bin):
+        os.remove(cppcheck_bin)
+
+    try:
+        if __make_cmd == 'msbuild.exe':
+            subprocess.check_call(['python3', os.path.join('tools', 'matchcompiler.py'), '--write-dir', 'lib'], cwd=cppcheck_path)
+            build_env = os.environ
+            # append to cl.exe options - need to omit dash or slash since a dash is being prepended
+            build_env["_CL_"] = __jobs.replace('j', 'MP', 1)
+            # TODO: processes still exhaust all threads of the system
+            subprocess.check_call([__make_cmd, '-t:cli', os.path.join(cppcheck_path, 'cppcheck.sln'), '/property:Configuration=Release;Platform=x64'], cwd=cppcheck_path, env=build_env)
+        else:
+            # TODO: use CXXOPTS instead
+            build_cmd = [__make_cmd, __jobs, 'MATCHCOMPILER=yes', 'CXXFLAGS=-O2 -g -w']
+            build_env = os.environ
+            if __make_cmd == 'mingw32-make':
+                # TODO: MinGW will always link even if no changes are present
+                # assume Python is in PATH for now
+                build_env['PYTHON_INTERPRETER'] = 'python3'
+                # TODO: MinGW is not detected by Makefile - so work around it for now
+                build_cmd.append('RDYNAMIC=-lshlwapi')
+            subprocess.check_call(build_cmd, cwd=cppcheck_path, env=build_env)
+    except Exception as e:
+        print('Compilation failed: {}'.format(e))
+        return False
+
+    try:
+        if __make_cmd == 'msbuild.exe':
+            subprocess.check_call([os.path.join(cppcheck_path, 'bin', 'cppcheck.exe'), '--version'], cwd=os.path.join(cppcheck_path, 'bin'))
+        else:
+            subprocess.check_call([os.path.join(cppcheck_path, 'cppcheck'), '--version'], cwd=cppcheck_path)
+    except Exception as e:
+        print('Running Cppcheck failed: {}'.format(e))
+        # remove faulty binary
+        if os.path.isfile(cppcheck_bin):
+            os.remove(cppcheck_bin)
+        return False
+
+    return True
+
+
+def get_cppcheck_versions():
+    print('Connecting to server to get Cppcheck versions..')
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.connect(__server_address)
+        sock.send(b'GetCppcheckVersions\n')
+        versions = sock.recv(256)
+    # TODO: sock.recv() sometimes hangs and returns b'' afterwards
+    if not versions:
+        raise Exception('received empty response')
+    return versions.decode('utf-8').split()
+
+
+def get_packages_count():
+    def __get_packages_count():
+        print('Connecting to server to get count of packages..')
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            sock.connect(__server_address)
+            sock.send(b'getPackagesCount\n')
+            packages = sock.recv(64)
+        # TODO: sock.recv() sometimes hangs and returns b'' afterwards
+        if not packages:
+            raise Exception('received empty response')
+        return int(packages)
+
+    return try_retry(__get_packages_count)
+
+
+def get_package(package_index=None):
+    def __get_package(package_index):
+        print('Connecting to server to get assigned work..')
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+            sock.connect(__server_address)
+            if package_index is None:
+                sock.send(b'get\n')
+            else:
+                request = 'getPackageIdx:' + str(package_index) + '\n'
+                sock.send(request.encode())
+            package = sock.recv(256)
+        # TODO: sock.recv() sometimes hangs and returns b'' afterwards
+        if not package:
+            raise Exception('received empty response')
+        return package.decode('utf-8')
+
+    return try_retry(__get_package, fargs=(package_index,), max_tries=3, sleep_duration=30.0, sleep_factor=1.0)
+
+
+def __handle_remove_readonly(func, path, exc):
+    import stat
+    if not os.access(path, os.W_OK):
+        # Is the error an access error ?
+        os.chmod(path, stat.S_IWUSR)
+        func(path)
+
+
+def __remove_tree(folder_name):
+    if not os.path.exists(folder_name):
+        return
+
+    def rmtree_func():
+        # pylint: disable=deprecated-argument - FIXME: onerror was deprecated in Python 3.12
+        shutil.rmtree(folder_name, onerror=__handle_remove_readonly)
+
+    print('Removing existing temporary data...')
+    try:
+        try_retry(rmtree_func, max_tries=5, sleep_duration=30, sleep_factor=1)
+    except Exception as e:
+        print('Failed to cleanup {}: {}'.format(folder_name, e))
+        sys.exit(1)
+
+
+def __wget(url, destfile, bandwidth_limit):
+    if os.path.exists(destfile):
+        if os.path.isfile(destfile):
+            os.remove(destfile)
+        else:
+            print('Error: ' + destfile + ' exists but it is not a file! Please check the path and delete it manually.')
+            sys.exit(1)
+    wget_call = ['wget', '--tries=10', '--timeout=300', '-O', destfile, url]
+    if bandwidth_limit and isinstance(bandwidth_limit, str):
+        wget_call.append('--limit-rate=' + bandwidth_limit)
+    exitcode = subprocess.call(wget_call)
+    if exitcode != 0:
+        print('wget failed with ' + str(exitcode))
+        os.remove(destfile)
+        return False
+    if not os.path.isfile(destfile):
+        return False
+    return True
+
+
+def download_package(work_path, package, bandwidth_limit):
+    print('Download package ' + package)
+    destfile = os.path.join(work_path, 'temp.tgz')
+    if not __wget(package, destfile, bandwidth_limit):
+        return None
+    return destfile
+
+
+def unpack_package(work_path, tgz, cpp_only=False, c_only=False, skip_files=None):
+    temp_path = os.path.join(work_path, 'temp')
+    __remove_tree(temp_path)
+    os.mkdir(temp_path)
+
+    header_endings = ('.hpp', '.h++', '.hxx', '.hh', '.h')
+    cpp_source_endings = ('.cpp', '.c++', '.cxx', '.cc', '.tpp', '.txx', '.ipp', '.ixx', '.qml')
+    c_source_endings = ('.c',)
+
+    if cpp_only:
+        source_endings = cpp_source_endings
+    elif c_only:
+        source_endings = c_source_endings
+    else:
+        source_endings = cpp_source_endings + c_source_endings
+
+    source_found = False
+    if tarfile.is_tarfile(tgz):
+        print('Unpacking..')
+        with tarfile.open(tgz) as tf:
+            total = 0
+            extracted = 0
+            skipped = 0
+            for member in tf:
+                total += 1
+                if member.name.startswith(('/', '..')):
+                    # Skip dangerous file names
+                    # print('skipping dangerous file: ' + member.name)
+                    skipped += 1
+                    continue
+
+                is_source = member.name.lower().endswith(source_endings)
+                if is_source or member.name.lower().endswith(header_endings):
+                    if skip_files is not None:
+                        skip = False
+                        for skip_file in skip_files:
+                            if member.name.endswith('/' + skip_file):
+                                # print('found file to skip: ' + member.name)
+                                skip = True
+                                break
+                        if skip:
+                            skipped += 1
+                            continue
+                    try:
+                        tf.extract(member.name, temp_path)
+                        if is_source:
+                            source_found = True
+                        extracted += 1
+                    except OSError:
+                        pass
+                    except AttributeError:
+                        pass
+            print('extracted {} of {} files (skipped {}{})'.format(extracted, total, skipped, (' / only headers' if (extracted and not source_found) else '')))
+    return temp_path, source_found
+
+
+def __run_command(cmd, print_cmd=True):
+    if print_cmd:
+        print(cmd)
+    time_start = time.time()
+    if sys.platform == 'win32':
+        p = subprocess.Popen(shlex.split(cmd, comments=False, posix=False), stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, errors='surrogateescape')
+    else:
+        p = subprocess.Popen(shlex.split(cmd), stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, errors='surrogateescape', preexec_fn=os.setsid)
+    try:
+        stdout, stderr = p.communicate(timeout=CPPCHECK_TIMEOUT)
+        return_code = p.returncode
+        p = None
+    except subprocess.TimeoutExpired:
+        import psutil
+        return_code = RETURN_CODE_TIMEOUT
+        # terminate all the child processes so we get messages about which files were hanging
+        child_procs = psutil.Process(p.pid).children(recursive=True)
+        if len(child_procs) > 0:
+            for child in child_procs:
+                child.terminate()
+            try:
+                # call with timeout since it might get stuck e.g. gcc-arm-none-eabi
+                stdout, stderr = p.communicate(timeout=5)
+                p = None
+            except subprocess.TimeoutExpired:
+                pass
+    finally:
+        if p:
+            os.killpg(os.getpgid(p.pid), signal.SIGTERM)  # Send the signal to all the process groups
+            stdout, stderr = p.communicate()
+            p = None
+    time_stop = time.time()
+    elapsed_time = time_stop - time_start
+    return return_code, stdout, stderr, elapsed_time
+
+
+def scan_package(cppcheck_path, source_path, libraries, capture_callstack=True, enable='style,information', debug_warnings=True, check_level=None, extra_args=None):
+    print('Analyze..')
+    libs = ''
+    for library in libraries:
+        if os.path.exists(os.path.join(cppcheck_path, 'cfg', library + '.cfg')):
+            libs += '--library=' + library + ' '
+
+    dir_to_scan = source_path
+
+    # TODO: temporarily disabled timing information - use --showtime=top5_summary when next version is released
+    # Reference for GNU C: https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html
+    options = '{} --inconclusive --enable={} --inline-suppr --template=daca2'.format(libs, enable)
+    if 'information' in enable:
+        # TODO: remove missingInclude disabling after 2.16 has been released
+        options += ' --disable=missingInclude --suppress=unmatchedSuppression'
+    if check_level:
+        options += ' --check-level=' + check_level
+    if extra_args:
+        options += ' ' + extra_args
+    if debug_warnings:
+        options += ' --check-library --debug-warnings --suppress=autoNoType --suppress=valueFlowBailout' \
+                   ' --suppress=bailoutUninitVar --suppress=symbolDatabaseWarning --suppress=normalCheckLevelConditionExpressions'
+    options += ' -D__GNUC__ --platform=unix64'
+    options_rp = options + ' -rp={}'.format(dir_to_scan)
+    if __make_cmd == 'msbuild.exe':
+        cppcheck_cmd = os.path.join(cppcheck_path, 'bin', 'cppcheck.exe') + ' ' + options_rp
+        cmd = cppcheck_cmd + ' ' + __jobs + ' ' + dir_to_scan
+    else:
+        nice_cmd = 'nice'
+        if __make_cmd == 'mingw32-make':
+            nice_cmd = ''
+        cppcheck_cmd = os.path.join(cppcheck_path, 'cppcheck') + ' ' + options_rp
+        cmd = nice_cmd + ' ' + cppcheck_cmd + ' ' + __jobs + ' ' + dir_to_scan
+    returncode, stdout, stderr, elapsed_time = __run_command(cmd)
+
+    # collect messages
+    information_messages_list = []
+    issue_messages_list = []
+    internal_error_messages_list = []
+    count = 0
+    re_obj = None
+    for line in stderr.split('\n'):
+        if ': information: ' in line:
+            information_messages_list.append(line + '\n')
+        elif line:
+            issue_messages_list.append(line + '\n')
+            if re_obj is None:
+                re_obj = re.compile(r'.*:[0-9]+:.*\]$')
+            if re_obj.match(line):
+                count += 1
+            if ': error: Internal error: ' in line:
+                internal_error_messages_list.append(line + '\n')
+    print('Number of issues: ' + str(count))
+    # Collect timing information
+    stdout_lines = stdout.split('\n')
+    timing_info_list = []
+    overall_time_found = False
+    max_timing_lines = 6
+    current_timing_lines = 0
+    for reverse_line in reversed(stdout_lines):
+        if reverse_line.startswith('Overall time:'):
+            overall_time_found = True
+        if overall_time_found:
+            if not reverse_line or current_timing_lines >= max_timing_lines:
+                break
+            timing_info_list.insert(0, ' ' + reverse_line + '\n')
+            current_timing_lines += 1
+    timing_str = ''.join(timing_info_list)
+
+    # detect errors
+    sig_file = None
+    sig_num = -1
+    for ie_line in internal_error_messages_list:
+        # temp/dlib-19.10/dlib/test/dnn.cpp:0:0: error: Internal error: Child process crashed with signal 11 [cppcheckError]
+        if 'Child process crashed with signal' in ie_line:
+            sig_file = ie_line.split(':')[0]
+            sig_msg = 'signal '
+            sig_pos = ie_line.find(sig_msg)
+            if sig_pos != -1:
+                sig_start_pos = sig_pos + len(sig_msg)
+                sig_num = int(ie_line[sig_start_pos:ie_line.find(' ', sig_start_pos)])
+            # break on the first signalled file for now
+            break
+    print('cppcheck finished with ' + str(returncode) + ('' if sig_num == -1 else ' (signal ' + str(sig_num) + ')') + ' in {:.1f}s'.format(elapsed_time))
+
+    options_j = options + ' ' + __jobs
+
+    if returncode == RETURN_CODE_TIMEOUT:
+        print('Timeout!')
+        return returncode, ''.join(internal_error_messages_list), '', elapsed_time, options_j, ''
+
+    # generate stack trace for SIGSEGV, SIGABRT, SIGILL, SIGFPE, SIGBUS
+    has_error = returncode in (-11, -6, -4, -8, -7)
+    has_sig = sig_num in (11, 6, 4, 8, 7)
+    if has_error or has_sig:
+        print('Crash!')
+        # make sure we have the actual error code set
+        if has_sig:
+            returncode = -sig_num
+        stacktrace = ''
+        if capture_callstack:
+            # re-run within gdb to get a stacktrace
+            cmd = 'gdb --batch --eval-command=run --eval-command="bt 50" --return-child-result --args ' + cppcheck_cmd + " -j1 "
+            if sig_file is not None:
+                cmd += sig_file
+            else:
+                cmd += dir_to_scan
+            _, st_stdout, _, _ = __run_command(cmd)
+            gdb_pos = st_stdout.find(" received signal")
+            if gdb_pos != -1:
+                last_check_pos = st_stdout.rfind('Checking ', 0, gdb_pos)
+                if last_check_pos == -1:
+                    stacktrace = st_stdout[gdb_pos:]
+                else:
+                    stacktrace = st_stdout[last_check_pos:]
+        # if no stacktrace was generated return the original stdout or internal errors list
+        if not stacktrace:
+            if has_sig:
+                stacktrace = ''.join(internal_error_messages_list)
+            else:
+                stacktrace = stdout
+        return returncode, stacktrace, '', returncode, options_j, ''
+
+    if returncode != 0:
+        # returncode is always 1 when this message is written
+        thr_pos = stderr.find('#### ThreadExecutor')
+        if thr_pos != -1:
+            print('Thread!')
+            return -222, stderr[thr_pos:], '', -222, options_j, ''
+
+        print('Error!')
+        if returncode > 0:
+            returncode = -100-returncode
+        return returncode, stdout, '', returncode, options_j, ''
+
+    if sig_num != -1:
+        print('Signal!')
+        return -sig_num, ''.join(internal_error_messages_list), '', -sig_num, options_j, ''
+
+    return count, ''.join(issue_messages_list), ''.join(information_messages_list), elapsed_time, options_j, timing_str
+
+
+def __split_results(results):
+    ret = []
+    w = None
+    re_obj = None
+    for line in results.split('\n'):
+        if line.endswith(']'):
+            if re_obj is None:
+                re_obj = re.compile(r': (error|warning|style|performance|portability|information|debug):')
+            if re_obj.search(line):
+                if w is not None:
+                    ret.append(w.strip())
+                w = ''
+        if w is not None:
+            w += ' ' * 5 + line + '\n'
+    if w is not None:
+        ret.append(w.strip())
+    return ret
+
+
+def diff_results(ver1, results1, ver2, results2):
+    print('Diff results..')
+    ret = ''
+    r1 = sorted(__split_results(results1))
+    r2 = sorted(__split_results(results2))
+    i1 = 0
+    i2 = 0
+    while i1 < len(r1) and i2 < len(r2):
+        if r1[i1] == r2[i2]:
+            i1 += 1
+            i2 += 1
+        elif r1[i1] < r2[i2]:
+            ret += ver1 + ' ' + r1[i1] + '\n'
+            i1 += 1
+        else:
+            ret += ver2 + ' ' + r2[i2] + '\n'
+            i2 += 1
+    while i1 < len(r1):
+        ret += ver1 + ' ' + r1[i1] + '\n'
+        i1 += 1
+    while i2 < len(r2):
+        ret += ver2 + ' ' + r2[i2] + '\n'
+        i2 += 1
+
+    return ret
+
+
+def __send_all(connection, data):
+    bytes_ = data.encode('ascii', 'ignore')
+    while bytes_:
+        num = connection.send(bytes_)
+        if num < len(bytes_):
+            bytes_ = bytes_[num:]
+        else:
+            bytes_ = None
+
+
+def __upload(cmd, data, cmd_info):
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.connect(__server_address)
+        __send_all(sock, '{}\n{}'.format(cmd, data))
+    print('{} has been successfully uploaded.'.format(cmd_info))
+    return True
+
+
+def upload_results(package, results):
+    if not __make_cmd == 'make':
+        print('Error: Result upload not performed - only make build binaries are currently fully supported')
+        return False
+
+    print('Uploading results.. ' + str(len(results)) + ' bytes')
+    try:
+        try_retry(__upload, fargs=('write\n' + package, results + '\nDONE', 'Result'), max_tries=20, sleep_duration=15, sleep_factor=1)
+    except Exception as e:
+        print('Result upload failed ({})!'.format(e))
+        return False
+
+    return True
+
+
+def upload_info(package, info_output):
+    if not __make_cmd == 'make':
+        print('Error: Information upload not performed - only make build binaries are currently fully supported')
+        return False
+
+    print('Uploading information output.. ' + str(len(info_output)) + ' bytes')
+    try:
+        try_retry(__upload, fargs=('write_info\n' + package, info_output + '\nDONE', 'Information'), max_tries=20, sleep_duration=15, sleep_factor=1)
+    except Exception as e:
+        print('Information upload failed ({})!'.format(e))
+        return False
+
+    return True
+
+def upload_nodata(package):
+    print('Uploading no-data status..')
+    try:
+        try_retry(__upload, fargs=('write_nodata\n' + package, '', 'No-data status'), max_tries=3, sleep_duration=30, sleep_factor=1)
+    except Exception as e:
+        print('No-data upload failed ({})!'.format(e))
+        return False
+
+    return True
+
+
+class LibraryIncludes:
+    def __init__(self):
+        include_mappings = {'avr': ['<avr/'],
+                            'boost': ['<boost/'],
+                            'bsd': ['<sys/queue.h>', '<sys/tree.h>', '<sys/uio.h>','<bsd/', '<fts.h>', '<db.h>', '<err.h>', '<vis.h>'],
+                            'cairo': ['<cairo.h>'],
+                            'cppunit': ['<cppunit/'],
+                            'emscripten': ['<emscripten.h>'],
+                            'icu': ['<unicode/', '"unicode/'],
+                            'ginac': ['<ginac/', '"ginac/'],
+                            'googletest': ['<gtest/gtest.h>'],
+                            'gtk': ['<gtk', '<glib.h>', '<glib-', '<glib/', '<gdk/', '<gnome'],
+                            'kde': ['<KGlobal>', '<KApplication>', '<KLocalizedString>', '<KDE/', '<klocalizedstring.h>'],
+                            'libcerror': ['<libcerror.h>'],
+                            'libcurl': ['<curl/curl.h>'],
+                            'libsigc++': ['<sigc++/'],
+                            'lua': ['<lua.h>', '"lua.h"'],
+                            'mfc': ['<afx.h>', '<afxwin.h>', '<afxext.h>'],
+                            'microsoft_atl': ['<atlbase.h>'],
+                            'microsoft_sal': ['<sal.h>'],
+                            'microsoft_unittest': ['<CppUnitTest.h>'],
+                            'motif': ['<X11/', '<Xm/'],
+                            'nspr': ['<prtypes.h>', '"prtypes.h"'],
+                            'ntl': ['<ntl/', '"ntl/'],
+                            'opencv2': ['<opencv2/', '"opencv2/'],
+                            'opengl': ['<GL/gl.h>', '<GL/glu.h>', '<GL/glut.h>'],
+                            'openmp': ['<omp.h>'],
+                            'openssl': ['<openssl/'],
+                            'pcre': ['<pcre.h>', '"pcre.h"'],
+                            'python': ['<Python.h>', '"Python.h"'],
+                            'qt': ['<QAbstractSeries>', '<QAction>', '<QActionGroup>', '<QApplication>', '<QByteArray>', '<QChartView>', '<QClipboard>', '<QCloseEvent>', '<QColor>', '<QColorDialog>', '<QComboBox>', '<QCoreApplication>', '<QCryptographicHash>', '<QDate>', '<QDateTime>', '<QDateTimeAxis>', '<QDebug>', '<QDesktopServices>', '<QDialog>', '<QDialogButtonBox>', '<QDir>', '<QElapsedTimer>', '<QFile>', '<QFileDialog>', '<QFileInfo>', '<QFileInfoList>', '<QFlags>', '<QFont>', '<QFormLayout>', '<QHelpContentWidget>', '<QHelpEngine>', '<QHelpIndexWidget>', '<QImageReader>', '<QInputDialog>', '<QKeyEvent>', '<QLabel>', '<QLineSeries>', '<QList>', '<qlist.h>', '<QLocale>', '<QMainWindow>', '<QMap>', '<QMenu>', '<QMessageBox>', '<QMetaType>', '<QMimeData>', '<QMimeDatabase>', '<QMimeType>', '<QMutex>', '<QObject>', '<qobjectdefs.h>', '<QPainter>', '<QPlainTextEdit>', '<QPrintDialog>', '<QPrinter>', '<QPrintPreviewDialog>', '<QProcess>', '<QPushButton>', '<QQueue>', '<QReadWriteLock>', '<QRegularExpression>', '<QRegularExpressionValidator>', '<QSet>', '<QSettings>', '<QShortcut>', '<QSignalMapper>', '<QStandardItemModel>', '<QString>', '<qstring.h>', '<QStringList>', '<QSyntaxHighlighter>', '<QTest>', '<QTextBrowser>', '<QTextDocument>', '<QTextEdit>', '<QTextStream>', '<QThread>', '<QTimer>', '<QTranslator>', '<QTreeView>', '<QtWidgets>', '<QUrl>', '<QValueAxis>', '<QVariant>', '<QWaitCondition>', '<QWidget>', '<QXmlStreamReader>', '<QXmlStreamWriter>', '<QtGui'],
+                            'ruby': ['<ruby.h>', '<ruby/', '"ruby.h"'],
+                            'sdl': ['<SDL.h>', '<SDL/SDL.h>', '<SDL2/SDL.h>'],
+                            'selinux': ['<selinux/'],
+                            'sfml': ['<SFML/'],
+                            'sqlite3': ['<sqlite3.h>', '"sqlite3.h"'],
+                            'tinyxml2': ['<tinyxml2', '"tinyxml2'],
+                            'wxsqlite3': ['<wx/wxsqlite3', '"wx/wxsqlite3'],
+                            'wxwidgets': ['<wx/', '"wx/'],
+                            'zephyr': ['<zephyr/'],
+                            'zlib': ['<zlib.h>'],
+                            }
+
+        self.__library_includes_re = {}
+
+        for library, includes in include_mappings.items():
+            re_includes = [re.escape(inc) for inc in includes]
+            re_expr = '^[ \\t]*#[ \\t]*include[ \\t]*(?:' + '|'.join(re_includes) + ')'
+            re_obj = re.compile(re_expr, re.MULTILINE)
+            self.__library_includes_re[library] = re_obj
+
+    def __iterate_files(self, path, has_include_cb):
+        for root, _, files in os.walk(path):
+            for name in files:
+                filename = os.path.join(root, name)
+                try:
+                    with open(filename, 'rt', errors='ignore') as f:
+                        filedata = f.read()
+                    has_include_cb(filedata)
+                except IOError:
+                    pass
+
+    def get_libraries(self, folder):
+        print('Detecting library usage...')
+        libraries = ['posix', 'gnu', 'bsd']
+
+        # explicitly copy as assignments in python are references
+        library_includes_re = copy.copy(self.__library_includes_re)
+
+        def has_include(filedata):
+            lib_del = []
+            for library, includes_re in library_includes_re.items():
+                if includes_re.search(filedata):
+                    libraries.append(library)
+                    lib_del.append(library)
+
+            for lib_d in lib_del:
+                del library_includes_re[lib_d]
+
+        self.__iterate_files(folder, has_include)
+        print('Found libraries: {}'.format(libraries))
+        return libraries
+
+
+def get_compiler_version():
+    if __make_cmd == 'msbuild.exe':
+        _, _, stderr, _ = __run_command('cl.exe', False)
+        return stderr.split('\n', maxsplit=1)[0]
+
+    _, stdout, _, _ = __run_command('g++ --version', False)
+    return stdout.split('\n', maxsplit=1)[0]
+
+
+def get_client_version():
+    return CLIENT_VERSION
+
+
+def set_server_address(server_address):
+    global __server_address
+    __server_address = server_address
+
+
+def set_jobs(jobs: str):
+    global __jobs
+    __jobs = jobs
+
+library_includes = LibraryIncludes()
diff --git a/tools/extract_and_run_more_tests.sh b/tools/extract_and_run_more_tests.sh
deleted file mode 100755
index c564f9f177a..00000000000
--- a/tools/extract_and_run_more_tests.sh
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/bin/bash
-
-cd ~/cppcheck
-rm -rf test1
-python tools/extracttests.py --code=test1 test/testleakautovar.cpp
-cd ~/cppcheck/test1
-~/cppcheck/tools/run_more_tests.sh
-
diff --git a/tools/generate_and_run_more_tests.sh b/tools/generate_and_run_more_tests.sh
deleted file mode 100755
index 8955189ef2a..00000000000
--- a/tools/generate_and_run_more_tests.sh
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/bin/bash
-# Run like:
-# cd ~/cppcheck
-# tools/generate_and_run_more_tests.sh
-
-set -e
-
-echo testleakautovar
-tools/run_more_tests.sh test/testleakautovar.cpp
-
-echo testmemleak
-tools/run_more_tests.sh test/testmemleak.cpp
-
-echo testnullpointer
-tools/run_more_tests.sh test/testnullpointer.cpp
-
-echo testuninitvar
-tools/run_more_tests.sh test/testuninitvar.cpp
-
diff --git a/tools/generate_cfg_tests.cpp b/tools/generate_cfg_tests.cpp
deleted file mode 100644
index d0b57035781..00000000000
--- a/tools/generate_cfg_tests.cpp
+++ /dev/null
@@ -1,204 +0,0 @@
-
-#include <iostream>
-#include <cstring>
-#include <string>
-#include <sstream>
-#include <vector>
-#include "tinyxml2.h"
-
-static void testfunction(const tinyxml2::XMLElement *node, const std::string &functionName);
-
-static std::vector<std::string> splitString(const char *str, char delim)
-{
-    std::vector<std::string> ret;
-    while (const char *p = std::strchr(str,delim)) {
-        ret.push_back(std::string(str, p-str));
-        str = p + 1;
-    }
-    ret.push_back(str);
-    return ret;
-}
-
-static std::string replaceCharInString(std::string s, char from, char to)
-{
-    for (int i = 0; i < s.size(); ++i) {
-        if (s[i] == from)
-            s[i] = to;
-    }
-    return s;
-}
-
-int main(int argc, char **argv)
-{
-    if (argc != 2 || !std::strstr(argv[1], ".cfg")) {
-        std::cerr << "no cfg file\n";
-        return 1;
-    }
-
-    const char *cfgfile = argv[1];
-
-    tinyxml2::XMLDocument doc;
-    if (tinyxml2::XML_SUCCESS != doc.LoadFile(cfgfile)) {
-        std::cerr << "failed to load cfg file\n";
-        return 1;
-    }
-
-    std::string testfile(cfgfile);
-    if (testfile.find('/') != std::string::npos)
-        testfile = testfile.substr(testfile.rfind('/')+1);
-    testfile = "generated-cfg-tests-" + testfile.substr(0,testfile.find('.')) + ".cpp";
-
-    std::cout << "// auto generated tests from " << cfgfile << std::endl;
-    std::cout << "//" << std::endl;
-    std::cout << "// Generated by command:" << std::endl;
-    std::cout << "// " << argv[0] << ' ' << cfgfile << " > " << testfile << std::endl;
-    std::cout << "//" << std::endl;
-    std::cout << "// Recommended cppcheck command line:" << std::endl;
-    std::cout << "// $ cppcheck --enable=warning,information --inline-suppr --platform=unix64 " << testfile << std::endl;
-    std::cout << "// => 'unmatched suppression' warnings are false negatives." << std::endl;
-    std::cout << "//" << std::endl << std::endl ;
-
-    const tinyxml2::XMLElement * const rootnode = doc.FirstChildElement();
-
-    for (const tinyxml2::XMLElement *node = rootnode->FirstChildElement(); node; node = node->NextSiblingElement()) {
-        const std::string nodename = node->Name();
-        if (nodename == "memory" || nodename == "resource") {
-            //testalloc(node);
-        } else if (nodename == "function") {
-            for (const std::string &name : splitString(node->Attribute("name"), ','))
-                testfunction(node, name);
-        }
-    }
-
-    return 0;
-}
-
-static std::string functionCall(const std::string &functionName, bool useretval, int argNr, int numberOfArgs, const char badArg[])
-{
-    std::ostringstream ostr;
-    if (useretval)
-        ostr << "result = ";
-    ostr << functionName << '(';
-    for (int i = 1; i <= numberOfArgs; ++i) {
-        if (i > 1)
-            ostr << ", ";
-        if (i == argNr)
-            ostr << badArg;
-        else
-            ostr << "arg" << i;
-    }
-    ostr << ')';
-    return ostr.str();
-}
-
-static std::string testFunctionArg(const std::string &functionName, bool useretval, const char type[], int argNr, int numberOfArgs, const char code[], const char suppress[], const char badArg[])
-{
-    std::ostringstream ostr;
-    ostr << "void test__" << replaceCharInString(functionName,':','_') << "__arg" << argNr << "__" << type << "() {" << std::endl;
-    if (*code)
-        ostr << "  " << code << std::endl;
-    ostr << "  // cppcheck-suppress " << suppress << std::endl;
-    ostr << "  " << functionCall(functionName, useretval, argNr, numberOfArgs, badArg) << ';' << std::endl;
-    ostr << '}';
-    return ostr.str();
-}
-
-static void testfunction(const tinyxml2::XMLElement *node, const std::string &functionName)
-{
-    // How many args does this function take?
-    int numberOfArgs = 0;
-    for (const tinyxml2::XMLElement *child = node->FirstChildElement(); child; child = child->NextSiblingElement()) {
-        if (std::strcmp(child->Name(), "arg") == 0) {
-            const char *nr = child->Attribute("nr");
-            if (nr && std::isdigit(*nr) && std::atoi(nr) > numberOfArgs)
-                numberOfArgs = std::atoi(nr);
-        }
-    }
-
-    bool noreturn = false;
-    bool useretval = false;
-    bool pure = false;
-    //bool constant = false;
-    bool leakignore = false;
-    for (const tinyxml2::XMLElement *child = node->FirstChildElement(); child; child = child->NextSiblingElement()) {
-        if (std::strcmp(child->Name(), "noreturn") == 0)
-            noreturn = true;
-        else if (std::strcmp(child->Name(), "use-retval") == 0)
-            useretval = true;
-        else if (std::strcmp(child->Name(), "pure") == 0)
-            pure = true;
-        //else if (std::strcmp(child->Name(), "const") == 0)
-        //    constant = true;
-        else if (std::strcmp(child->Name(), "leak-ignore") == 0)
-            leakignore = true;
-    }
-
-    if (noreturn) {
-        std::cout << "void test__" << replaceCharInString(functionName,':','_') << "__noreturn() {" << std::endl;
-        std::cout << "  int x = 1;" << std::endl;
-        std::cout << "  if (cond) { x=100; " << functionCall(functionName, useretval, -1, numberOfArgs, "") << "; }" << std::endl;
-        std::cout << "  // cppcheck-suppress shiftTooManyBits" << std::endl;
-        std::cout << "  x = 1 << x;" << std::endl;
-        std::cout << "}" << std::endl << std::endl;
-    }
-    if (useretval) {
-        std::cout << "void test__" << replaceCharInString(functionName,':','_') << "__useretval() {" << std::endl;
-        std::cout << "  // cppcheck-suppress ignoredReturnValue" << std::endl;
-        std::cout << "  " << functionCall(functionName, false, -1, numberOfArgs, "") << ';' << std::endl;
-        std::cout << "}" << std::endl << std::endl;
-    }
-    if (pure) {
-        std::cout << "void test__" << replaceCharInString(functionName,':','_') << "__pure(";
-        for (int i = 1; i <= numberOfArgs; ++i)
-            std::cout << (i>1?",":"") << "int arg" << i;
-        std::cout << ") {" << std::endl;
-        std::cout << "  // cppcheck-suppress incorrectLogicOperator" << std::endl;
-        std::cout << "  if ((" << functionCall(functionName, false, -1, numberOfArgs, "") << " > 10) || (";
-        std::cout << functionCall(functionName, false, -1, numberOfArgs, "") <<  " < 100)) {}" << std::endl;
-        std::cout << "}" << std::endl << std::endl;
-    }
-    if (leakignore && functionName.find("::") == std::string::npos) {
-        std::cout << "void test__" << replaceCharInString(functionName,':','_') << "__leakignore() {" << std::endl;
-        std::cout << "  char *p = malloc(10); *p=0;" << std::endl;
-        std::cout << "  " << functionCall(functionName, useretval, 1, numberOfArgs, "p") << ';' << std::endl;
-        std::cout << "  // cppcheck-suppress memleak" << std::endl;
-        std::cout << "}" << std::endl << std::endl;
-    }
-
-    // Generate tests for args
-    for (int argNr = 1; argNr <= numberOfArgs; ++argNr) {
-        for (const tinyxml2::XMLElement *child = node->FirstChildElement(); child; child = child->NextSiblingElement()) {
-            if (std::strcmp(child->Name(), "arg") != 0)
-                continue;
-            const char *nrAttr = child->Attribute("nr");
-            if (!nrAttr || std::atoi(nrAttr) != argNr)
-                continue;
-
-            bool notbool = false;
-            bool notuninit = false;
-            bool notnull = false;
-
-            for (const tinyxml2::XMLElement *argCheck = child->FirstChildElement(); argCheck; argCheck = argCheck->NextSiblingElement()) {
-                if (std::strcmp(argCheck->Name(), "not-bool") == 0)
-                    notbool = true;
-                else if (std::strcmp(argCheck->Name(), "not-null") == 0)
-                    notnull = true;
-                else if (std::strcmp(argCheck->Name(), "not-uninit") == 0)
-                    notuninit = true;
-            }
-
-            if (notbool) {
-                std::cout << testFunctionArg(functionName, useretval, "notbool", argNr, numberOfArgs, "", "invalidFunctionArgBool", "!x") << std::endl << std::endl;
-            }
-
-            if (notnull) {
-                std::cout << testFunctionArg(functionName, useretval, "notnull", argNr, numberOfArgs, "", "nullPointer", "NULL") << std::endl << std::endl;
-            }
-
-            if (notuninit) {
-                const char *code = notnull ? "int x[10];" : "int x;";
-                std::cout << testFunctionArg(functionName, useretval, "notuninit", argNr, numberOfArgs, code, "uninitvar", "x") << std::endl << std::endl;
-            }
-        }
-    }
-}
diff --git a/tools/get_checkers.py b/tools/get_checkers.py
new file mode 100644
index 00000000000..4594b773dc2
--- /dev/null
+++ b/tools/get_checkers.py
@@ -0,0 +1,952 @@
+import datetime
+import glob
+import os
+import re
+import requests
+
+def print_checkers(glob_pattern:str):
+    checkers = {}
+    for filename in glob.glob(glob_pattern):
+        for line in open(filename,'rt'):
+            res = re.match(r'[ \t]*logChecker\(\s*"([^"]+)"\s*\);.*', line)
+            if res is None:
+                continue
+            if line.find('//') > 0:
+                req = line[line.find('//')+2:].strip()
+            else:
+                req = ''
+            checkers[res.group(1)] = req
+    for c,req in dict(sorted(checkers.items())).items():
+        print('        {"%s","%s"},' % (c, req))
+
+
+print("""/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-%i Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// This file is auto-generated by tools/get_checkers.py:
+// python3 tools/get_checkers.py > lib/checkers.cpp
+
+#include "checkers.h"
+
+namespace checkers {
+    const std::map<std::string, std::string> allCheckers{""" % (datetime.date.today().year,))
+print_checkers(os.path.expanduser('~/cppchecksolutions/cppcheck/lib/*.cpp'))
+print("    };\n")
+
+print("""
+    const char Req[] = "Required";
+    const char Adv[] = "Advisory";
+    const char Man[] = "Mandatory";
+    const char Doc[] = "Document";
+    const char Dis[] = "Disapplied";""")
+
+for version in (2012, 2023, 2025):
+    with open(os.path.expanduser('~/cppchecksolutions/addon/coverage/misra-c-%i.txt' % version), 'rt') as f:
+        all_guidelines = f.read()
+
+    if version == 2012:
+        amd = {'4.6':3,'4.9':3,'4.11':3,'4.14':2,'4.15':3,'5.1':4,'5.2':4,'5.3':4}
+    else:
+        amd = {}
+
+    print('    const std::vector<MisraInfo> misraC%iDirectives{' % version)
+    for line in all_guidelines.split('\n'):
+        res = re.match(r'Dir\s+(\d+)[.](\d+)\s+(\w+).*', line)
+        if res:
+            a = amd.get('%s.%s' % (res.group(1), res.group(2)), 0)
+            print('        {%s,%s,%s,%i},' % (res.group(1), res.group(2), res.group(3)[:3], a))
+    print('    };')
+
+    if version == 2012:
+        amd = {'1.4':2,
+               '1.5':3,
+               '12.5':1,
+               '12.6':4,
+               '21.13':1,
+               '21.14':1,
+               '21.15':1,
+               '21.16':1,
+               '21.17':1,
+               '21.18':1,
+               '21.19':1,
+               '21.20':1,
+               '21.21':3,
+               '21.22':3,
+               '21.23':3,
+               '21.24':3,
+               '21.25':4,
+               '21.26':4,
+               '22.7':1,
+               '22.8':1,
+               '22.9':1,
+               '22.10':1,
+               '22.11':4,
+               '22.12':4,
+               '22.13':4,
+               '22.14':4,
+               '22.15':4,
+               '22.16':4,
+               '22.17':4,
+               '22.18':4,
+               '22.19':4,
+               '22.20':4,
+               '23.1':3,
+               '23.2':3,
+               '23.3':3,
+               '23.4':3,
+               '23.5':3,
+               '23.6':3,
+               '23.7':3,
+               '23.8':3 }
+    else:
+        amd = {}
+
+    print('    const std::vector<MisraInfo> misraC%iRules{' % version)
+    for line in all_guidelines.split('\n'):
+        res = re.match(r'Rule\s+(\d+)[.](\d+)\s+(\w+).*', line)
+        if res:
+            a = amd.get('%s.%s' % (res.group(1), res.group(2)), 0)
+            comment = '' if a == 0 else ' // Amendment %i' % a
+            print('        {%s,%s,%s,%i},%s' % (res.group(1), res.group(2), res.group(3)[:3], a, comment))
+    print('    };')
+
+print("""
+    const std::vector<MisraCppInfo> misraCpp2008Rules =
+    {
+        {0,1,1,Req},
+        {0,1,2,Req},
+        {0,1,3,Req},
+        {0,1,4,Req},
+        {0,1,5,Req},
+        {0,1,6,Req},
+        {0,1,7,Req},
+        {0,1,8,Req},
+        {0,1,9,Req},
+        {0,1,10,Req},
+        {0,1,11,Req},
+        {0,1,12,Req},
+        {0,2,1,Req},
+        {0,3,1,Doc},
+        {0,3,2,Req},
+        {0,4,1,Doc},
+        {0,4,2,Doc},
+        {0,4,3,Doc},
+        {1,0,1,Req},
+        {1,0,2,Doc},
+        {1,0,3,Doc},
+        {2,2,1,Doc},
+        {2,3,1,Req},
+        {2,5,1,Adv},
+        {2,7,1,Req},
+        {2,7,2,Req},
+        {2,7,3,Adv},
+        {2,10,1,Req},
+        {2,10,2,Req},
+        {2,10,3,Req},
+        {2,10,4,Req},
+        {2,10,5,Adv},
+        {2,10,6,Req},
+        {2,13,1,Req},
+        {2,13,2,Req},
+        {2,13,3,Req},
+        {2,13,4,Req},
+        {2,13,5,Req},
+        {3,1,1,Req},
+        {3,1,2,Req},
+        {3,1,3,Req},
+        {3,2,1,Req},
+        {3,2,2,Req},
+        {3,2,3,Req},
+        {3,2,4,Req},
+        {3,3,1,Req},
+        {3,3,2,Req},
+        {3,4,1,Req},
+        {3,9,1,Req},
+        {3,9,2,Adv},
+        {3,9,3,Req},
+        {4,5,1,Req},
+        {4,5,2,Req},
+        {4,5,3,Req},
+        {4,10,1,Req},
+        {4,10,2,Req},
+        {5,0,1,Req},
+        {5,0,2,Adv},
+        {5,0,3,Req},
+        {5,0,4,Req},
+        {5,0,5,Req},
+        {5,0,6,Req},
+        {5,0,7,Req},
+        {5,0,8,Req},
+        {5,0,9,Req},
+        {5,0,10,Req},
+        {5,0,11,Req},
+        {5,0,12,Req},
+        {5,0,13,Req},
+        {5,0,14,Req},
+        {5,0,15,Req},
+        {5,0,16,Req},
+        {5,0,17,Req},
+        {5,0,18,Req},
+        {5,0,19,Req},
+        {5,0,20,Req},
+        {5,0,21,Req},
+        {5,2,1,Req},
+        {5,2,2,Req},
+        {5,2,3,Adv},
+        {5,2,4,Req},
+        {5,2,5,Req},
+        {5,2,6,Req},
+        {5,2,7,Req},
+        {5,2,8,Req},
+        {5,2,9,Adv},
+        {5,2,10,Adv},
+        {5,2,11,Req},
+        {5,2,12,Req},
+        {5,3,1,Req},
+        {5,3,2,Req},
+        {5,3,3,Req},
+        {5,3,4,Req},
+        {5,8,1,Req},
+        {5,14,1,Req},
+        {5,17,1,Req},
+        {5,18,1,Req},
+        {5,19,1,Adv},
+        {6,2,1,Req},
+        {6,2,2,Req},
+        {6,2,3,Req},
+        {6,3,1,Req},
+        {6,4,1,Req},
+        {6,4,2,Req},
+        {6,4,3,Req},
+        {6,4,4,Req},
+        {6,4,5,Req},
+        {6,4,6,Req},
+        {6,4,7,Req},
+        {6,4,8,Req},
+        {6,5,1,Req},
+        {6,5,2,Req},
+        {6,5,3,Req},
+        {6,5,4,Req},
+        {6,5,5,Req},
+        {6,5,6,Req},
+        {6,6,1,Req},
+        {6,6,2,Req},
+        {6,6,3,Req},
+        {6,6,4,Req},
+        {6,6,5,Req},
+        {7,1,1,Req},
+        {7,1,2,Req},
+        {7,2,1,Req},
+        {7,3,1,Req},
+        {7,3,2,Req},
+        {7,3,3,Req},
+        {7,3,4,Req},
+        {7,3,5,Req},
+        {7,3,6,Req},
+        {7,4,1,Doc},
+        {7,4,2,Req},
+        {7,4,3,Req},
+        {7,5,1,Req},
+        {7,5,2,Req},
+        {7,5,3,Req},
+        {7,5,4,Adv},
+        {8,4,1,Req},
+        {8,4,2,Req},
+        {8,4,3,Req},
+        {8,4,4,Req},
+        {8,5,1,Req},
+        {8,5,2,Req},
+        {8,5,3,Req},
+        {9,3,1,Req},
+        {9,3,2,Req},
+        {9,3,3,Req},
+        {9,5,1,Req},
+        {9,6,1,Doc},
+        {9,6,2,Req},
+        {9,6,3,Req},
+        {9,6,4,Req},
+        {10,1,1,Adv},
+        {10,1,2,Req},
+        {10,1,3,Req},
+        {10,2,1,Adv},
+        {10,3,1,Req},
+        {10,3,2,Req},
+        {10,3,3,Req},
+        {11,0,1,Req},
+        {12,1,1,Req},
+        {12,1,2,Adv},
+        {12,1,3,Req},
+        {12,8,1,Req},
+        {12,8,2,Req},
+        {14,5,1,Req},
+        {14,5,2,Req},
+        {14,5,3,Req},
+        {14,6,1,Req},
+        {14,6,2,Req},
+        {14,7,1,Req},
+        {14,7,2,Req},
+        {14,7,3,Req},
+        {14,8,1,Req},
+        {14,8,2,Req},
+        {15,0,1,Req},
+        {15,0,2,Req},
+        {15,0,3,Req},
+        {15,1,1,Req},
+        {15,1,2,Req},
+        {15,1,3,Req},
+        {15,3,1,Req},
+        {15,3,2,Adv},
+        {15,3,3,Req},
+        {15,3,4,Req},
+        {15,3,5,Req},
+        {15,3,6,Req},
+        {15,3,7,Req},
+        {15,4,1,Req},
+        {15,5,1,Req},
+        {15,5,2,Req},
+        {15,5,3,Req},
+        {16,0,1,Req},
+        {16,0,2,Req},
+        {16,0,3,Req},
+        {16,0,4,Req},
+        {16,0,5,Req},
+        {16,0,6,Req},
+        {16,0,7,Req},
+        {16,0,8,Req},
+        {16,1,1,Req},
+        {16,1,2,Req},
+        {16,2,1,Req},
+        {16,2,2,Req},
+        {16,2,3,Req},
+        {16,2,4,Req},
+        {16,2,5,Adv},
+        {16,2,6,Req},
+        {16,3,1,Req},
+        {16,3,2,Adv},
+        {16,6,1,Doc},
+        {17,0,1,Req},
+        {17,0,2,Req},
+        {17,0,3,Req},
+        {17,0,4,Doc},
+        {17,0,5,Req},
+        {18,0,1,Req},
+        {18,0,2,Req},
+        {18,0,3,Req},
+        {18,0,4,Req},
+        {18,0,5,Req},
+        {18,2,1,Req},
+        {18,4,1,Req},
+        {18,7,1,Req},
+        {19,3,1,Req},
+        {27,0,1,Req}
+    };
+
+    const std::vector<MisraCppInfo> misraCpp2023Directives =
+    {
+        {0,3,1,Adv},
+        {0,3,2,Req},
+        {5,7,2,Adv},
+        {15,8,1,Req},
+    };
+
+    const std::vector<MisraCppInfo> misraCpp2023Rules =
+    {
+        {0,0,1,Req},
+        {0,0,2,Adv},
+        {0,1,1,Adv},
+        {0,1,2,Req},
+        {0,2,1,Adv},
+        {0,2,2,Req},
+        {0,2,3,Adv},
+        {0,2,4,Adv},
+        {4,1,1,Req},
+        {4,1,2,Adv},
+        {4,1,3,Req},
+        {4,6,1,Req},
+        {5,0,1,Adv},
+        {5,7,1,Req},
+        {5,7,3,Req},
+        {5,10,1,Req},
+        {5,13,1,Req},
+        {5,13,2,Req},
+        {5,13,3,Req},
+        {5,13,4,Req},
+        {5,13,5,Req},
+        {5,13,6,Req},
+        {5,13,7,Req},
+        {6,0,1,Req},
+        {6,0,2,Adv},
+        {6,0,3,Adv},
+        {6,0,4,Req},
+        {6,2,1,Req},
+        {6,2,2,Req},
+        {6,2,3,Req},
+        {6,2,4,Req},
+        {6,4,1,Req},
+        {6,4,2,Req},
+        {6,4,3,Req},
+        {6,5,1,Adv},
+        {6,5,2,Adv},
+        {6,7,1,Req},
+        {6,7,2,Req},
+        {6,8,1,Req},
+        {6,8,2,Man},
+        {6,8,3,Req},
+        {6,8,4,Adv},
+        {6,9,1,Req},
+        {6,9,2,Adv},
+        {7,0,1,Req},
+        {7,0,2,Req},
+        {7,0,3,Req},
+        {7,0,4,Req},
+        {7,0,5,Req},
+        {7,0,6,Req},
+        {7,11,1,Req},
+        {7,11,2,Req},
+        {7,11,3,Req},
+        {8,0,1,Adv},
+        {8,1,1,Req},
+        {8,1,2,Adv},
+        {8,2,1,Req},
+        {8,2,2,Req},
+        {8,2,3,Req},
+        {8,2,4,Req},
+        {8,2,5,Req},
+        {8,2,6,Req},
+        {8,2,7,Adv},
+        {8,2,8,Req},
+        {8,2,9,Req},
+        {8,2,10,Req},
+        {8,2,11,Req},
+        {8,3,1,Adv},
+        {8,3,2,Adv},
+        {8,7,1,Req},
+        {8,7,2,Req},
+        {8,9,1,Req},
+        {8,14,1,Adv},
+        {8,18,1,Man},
+        {8,18,2,Adv},
+        {8,19,1,Adv},
+        {8,20,1,Adv},
+        {9,2,1,Req},
+        {9,3,1,Req},
+        {9,4,1,Req},
+        {9,4,2,Req},
+        {9,5,2,Adv},
+        {9,5,3,Req},
+        {9,6,1,Adv},
+        {9,6,2,Req},
+        {9,6,3,Req},
+        {9,6,4,Req},
+        {9,6,5,Req},
+        {10,0,1,Adv},
+        {10,1,1,Adv},
+        {10,1,2,Req},
+        {10,2,1,Req},
+        {10,2,2,Adv},
+        {10,2,3,Req},
+        {10,3,1,Adv},
+        {10,4,1,Req},
+        {11,3,1,Adv},
+        {11,3,2,Adv},
+        {11,6,1,Adv},
+        {11,6,2,Man},
+        {11,6,3,Req},
+        {12,2,1,Adv},
+        {12,2,2,Req},
+        {12,2,3,Req},
+        {12,3,1,Req},
+        {13,1,1,Adv},
+        {13,1,2,Req},
+        {13,3,1,Req},
+        {13,3,2,Req},
+        {13,3,3,Req},
+        {13,3,4,Req},
+        {14,1,1,Adv},
+        {15,0,1,Req},
+        {15,0,2,Adv},
+        {15,1,1,Req},
+        {15,1,2,Adv},
+        {15,1,3,Req},
+        {15,1,4,Adv},
+        {15,1,5,Req},
+        {16,5,2,Req},
+        {16,6,1,Adv},
+        {17,8,1,Req},
+        {18,1,1,Req},
+        {18,1,2,Req},
+        {18,3,1,Adv},
+        {18,3,2,Req},
+        {18,3,3,Req},
+        {18,4,1,Req},
+        {18,5,1,Adv},
+        {18,5,2,Adv},
+        {19,0,1,Req},
+        {19,0,2,Req},
+        {19,0,3,Adv},
+        {19,0,4,Adv},
+        {19,1,1,Req},
+        {19,1,2,Req},
+        {19,1,3,Req},
+        {19,2,1,Req},
+        {19,2,2,Req},
+        {19,2,3,Req},
+        {19,3,1,Adv},
+        {19,3,2,Req},
+        {19,3,3,Req},
+        {19,3,4,Req},
+        {19,3,5,Req},
+        {19,6,1,Adv},
+        {21,2,1,Req},
+        {21,2,2,Req},
+        {21,2,3,Req},
+        {21,2,4,Req},
+        {21,6,1,Adv},
+        {21,6,2,Req},
+        {21,6,3,Req},
+        {21,6,4,Req},
+        {21,6,5,Req},
+        {21,10,1,Req},
+        {21,10,2,Req},
+        {21,10,3,Req},
+        {22,3,1,Req},
+        {22,4,1,Req},
+        {23,11,1,Adv},
+        {24,5,1,Req},
+        {24,5,2,Req},
+        {25,5,1,Req},
+        {25,5,2,Man},
+        {25,5,3,Man},
+        {26,3,1,Adv},
+        {28,3,1,Req},
+        {28,6,1,Req},
+        {28,6,2,Req},
+        {28,6,3,Req},
+        {28,6,4,Req},
+        {30,0,1,Req},
+        {30,0,2,Req}
+    };
+}
+
+std::vector<checkers::Info> checkers::autosarInfo{
+    {"m0-1-1", checkers::Req},
+    {"m0-1-2", checkers::Req},
+    {"m0-1-3", checkers::Req},
+    {"m0-1-4", checkers::Req},
+    {"a0-1-1", checkers::Req},
+    {"a0-1-2", checkers::Req},
+    {"m0-1-8", checkers::Req},
+    {"m0-1-9", checkers::Req},
+    {"m0-1-10", checkers::Adv},
+    {"a0-1-3", checkers::Req},
+    {"a0-1-4", checkers::Req},
+    {"a0-1-5", checkers::Req},
+    {"a0-1-6", checkers::Adv},
+    {"m0-2-1", checkers::Req},
+    {"a0-4-2", checkers::Req},
+    {"a0-4-3", checkers::Req},
+    {"a0-4-4", checkers::Req},
+    {"a1-1-1", checkers::Req},
+    {"a1-4-3", checkers::Adv},
+    {"a2-3-1", checkers::Req},
+    {"a2-5-1", checkers::Req},
+    {"a2-5-2", checkers::Req},
+    {"m2-7-1", checkers::Req},
+    {"a2-7-1", checkers::Req},
+    {"a2-7-3", checkers::Req},
+    {"a2-8-2", checkers::Adv},
+    {"m2-10-1", checkers::Req},
+    {"a2-10-1", checkers::Req},
+    {"a2-10-6", checkers::Req},
+    {"a2-10-4", checkers::Req},
+    {"a2-10-5", checkers::Adv},
+    {"a2-11-1", checkers::Req},
+    {"a2-13-1", checkers::Req},
+    {"a2-13-6", checkers::Req},
+    {"a2-13-5", checkers::Adv},
+    {"m2-13-2", checkers::Req},
+    {"m2-13-3", checkers::Req},
+    {"m2-13-4", checkers::Req},
+    {"a2-13-2", checkers::Req},
+    {"a2-13-3", checkers::Req},
+    {"a2-13-4", checkers::Req},
+    {"a3-1-1", checkers::Req},
+    {"a3-1-2", checkers::Req},
+    {"a3-1-3", checkers::Adv},
+    {"m3-1-2", checkers::Req},
+    {"a3-1-4", checkers::Req},
+    {"a3-1-6", checkers::Adv},
+    {"m3-2-1", checkers::Req},
+    {"m3-2-2", checkers::Req},
+    {"m3-2-3", checkers::Req},
+    {"m3-2-4", checkers::Req},
+    {"a3-3-1", checkers::Req},
+    {"a3-3-2", checkers::Req},
+    {"m3-3-2", checkers::Req},
+    {"m3-4-1", checkers::Req},
+    {"m3-9-1", checkers::Req},
+    {"a3-9-1", checkers::Req},
+    {"m3-9-3", checkers::Req},
+    {"m4-5-1", checkers::Req},
+    {"a4-5-1", checkers::Req},
+    {"m4-5-3", checkers::Req},
+    {"a4-7-1", checkers::Req},
+    {"m4-10-1", checkers::Req},
+    {"a4-10-1", checkers::Req},
+    {"m4-10-2", checkers::Req},
+    {"a5-0-1", checkers::Req},
+    {"m5-0-2", checkers::Adv},
+    {"m5-0-3", checkers::Req},
+    {"m5-0-4", checkers::Req},
+    {"m5-0-5", checkers::Req},
+    {"m5-0-6", checkers::Req},
+    {"m5-0-7", checkers::Req},
+    {"m5-0-8", checkers::Req},
+    {"m5-0-9", checkers::Req},
+    {"m5-0-10", checkers::Req},
+    {"m5-0-11", checkers::Req},
+    {"m5-0-12", checkers::Req},
+    {"a5-0-2", checkers::Req},
+    {"m5-0-14", checkers::Req},
+    {"m5-0-15", checkers::Req},
+    {"m5-0-16", checkers::Req},
+    {"m5-0-17", checkers::Req},
+    {"a5-0-4", checkers::Req},
+    {"m5-0-18", checkers::Req},
+    {"a5-0-3", checkers::Req},
+    {"m5-0-20", checkers::Req},
+    {"m5-0-21", checkers::Req},
+    {"a5-1-1", checkers::Req},
+    {"a5-1-2", checkers::Req},
+    {"a5-1-3", checkers::Req},
+    {"a5-1-4", checkers::Req},
+    {"a5-1-6", checkers::Adv},
+    {"a5-1-7", checkers::Req},
+    {"a5-1-8", checkers::Adv},
+    {"a5-1-9", checkers::Adv},
+    {"m5-2-2", checkers::Req},
+    {"m5-2-3", checkers::Adv},
+    {"a5-2-1", checkers::Adv},
+    {"a5-2-2", checkers::Req},
+    {"a5-2-3", checkers::Req},
+    {"m5-2-6", checkers::Req},
+    {"a5-2-4", checkers::Req},
+    {"a5-2-6", checkers::Req},
+    {"m5-2-8", checkers::Req},
+    {"m5-2-9", checkers::Req},
+    {"m5-2-10", checkers::Req},
+    {"m5-2-11", checkers::Req},
+    {"a5-2-5", checkers::Req},
+    {"m5-2-12", checkers::Req},
+    {"m5-3-1", checkers::Req},
+    {"m5-3-2", checkers::Req},
+    {"m5-3-3", checkers::Req},
+    {"m5-3-4", checkers::Req},
+    {"a5-3-1", checkers::Req},
+    {"a5-3-2", checkers::Req},
+    {"a5-3-3", checkers::Req},
+    {"a5-5-1", checkers::Req},
+    {"a5-6-1", checkers::Req},
+    {"m5-8-1", checkers::Req},
+    {"a5-10-1", checkers::Req},
+    {"m5-14-1", checkers::Req},
+    {"a5-16-1", checkers::Req},
+    {"m5-18-1", checkers::Req},
+    {"m5-19-1", checkers::Req},
+    {"m6-2-1", checkers::Req},
+    {"a6-2-1", checkers::Req},
+    {"a6-2-2", checkers::Req},
+    {"m6-2-2", checkers::Req},
+    {"m6-2-3", checkers::Req},
+    {"m6-3-1", checkers::Req},
+    {"m6-4-1", checkers::Req},
+    {"m6-4-2", checkers::Req},
+    {"m6-4-3", checkers::Req},
+    {"m6-4-4", checkers::Req},
+    {"m6-4-5", checkers::Req},
+    {"m6-4-6", checkers::Req},
+    {"m6-4-7", checkers::Req},
+    {"a6-4-1", checkers::Req},
+    {"a6-5-1", checkers::Req},
+    {"a6-5-2", checkers::Req},
+    {"m6-5-2", checkers::Req},
+    {"m6-5-3", checkers::Req},
+    {"m6-5-4", checkers::Req},
+    {"m6-5-5", checkers::Req},
+    {"m6-5-6", checkers::Req},
+    {"a6-5-3", checkers::Adv},
+    {"a6-5-4", checkers::Adv},
+    {"a6-6-1", checkers::Req},
+    {"m6-6-1", checkers::Req},
+    {"m6-6-2", checkers::Req},
+    {"m6-6-3", checkers::Req},
+    {"a7-1-1", checkers::Req},
+    {"a7-1-2", checkers::Req},
+    {"m7-1-2", checkers::Req},
+    {"a7-1-3", checkers::Req},
+    {"a7-1-4", checkers::Req},
+    {"a7-1-5", checkers::Req},
+    {"a7-1-6", checkers::Req},
+    {"a7-1-7", checkers::Req},
+    {"a7-1-8", checkers::Req},
+    {"a7-1-9", checkers::Req},
+    {"a7-2-1", checkers::Req},
+    {"a7-2-2", checkers::Req},
+    {"a7-2-3", checkers::Req},
+    {"a7-2-4", checkers::Req},
+    {"m7-3-1", checkers::Req},
+    {"m7-3-2", checkers::Req},
+    {"m7-3-3", checkers::Req},
+    {"m7-3-4", checkers::Req},
+    {"a7-3-1", checkers::Req},
+    {"m7-3-6", checkers::Req},
+    {"a7-4-1", checkers::Req},
+    {"m7-4-2", checkers::Req},
+    {"m7-4-3", checkers::Req},
+    {"a7-5-1", checkers::Req},
+    {"a7-5-2", checkers::Req},
+    {"a7-6-1", checkers::Req},
+    {"m8-0-1", checkers::Req},
+    {"a8-2-1", checkers::Req},
+    {"m8-3-1", checkers::Req},
+    {"a8-4-1", checkers::Req},
+    {"m8-4-2", checkers::Req},
+    {"a8-4-2", checkers::Req},
+    {"m8-4-4", checkers::Req},
+    {"a8-4-4", checkers::Adv},
+    {"a8-4-5", checkers::Req},
+    {"a8-4-6", checkers::Req},
+    {"a8-4-7", checkers::Req},
+    {"a8-4-8", checkers::Req},
+    {"a8-4-9", checkers::Req},
+    {"a8-4-10", checkers::Req},
+    {"a8-4-11", checkers::Req},
+    {"a8-4-12", checkers::Req},
+    {"a8-4-13", checkers::Req},
+    {"a8-4-14", checkers::Req},
+    {"a8-5-0", checkers::Req},
+    {"a8-5-1", checkers::Req},
+    {"m8-5-2", checkers::Req},
+    {"a8-5-2", checkers::Req},
+    {"a8-5-3", checkers::Req},
+    {"a8-5-4", checkers::Adv},
+    {"m9-3-1", checkers::Req},
+    {"a9-3-1", checkers::Req},
+    {"m9-3-3", checkers::Req},
+    {"a9-5-1", checkers::Req},
+    {"a9-6-1", checkers::Req},
+    {"m9-6-4", checkers::Req},
+    {"a10-1-1", checkers::Req},
+    {"m10-1-1", checkers::Adv},
+    {"m10-1-2", checkers::Req},
+    {"m10-1-3", checkers::Req},
+    {"m10-2-1", checkers::Adv},
+    {"a10-2-1", checkers::Req},
+    {"a10-3-1", checkers::Req},
+    {"a10-3-2", checkers::Req},
+    {"a10-3-3", checkers::Req},
+    {"a10-3-5", checkers::Req},
+    {"m10-3-3", checkers::Req},
+    {"a10-4-1", checkers::Req},
+    {"m11-0-1", checkers::Req},
+    {"a11-0-1", checkers::Adv},
+    {"a11-0-2", checkers::Req},
+    {"a11-3-1", checkers::Req},
+    {"a12-0-1", checkers::Req},
+    {"a12-0-2", checkers::Req},
+    {"a12-1-1", checkers::Req},
+    {"m12-1-1", checkers::Req},
+    {"a12-1-2", checkers::Req},
+    {"a12-1-3", checkers::Req},
+    {"a12-1-4", checkers::Req},
+    {"a12-1-5", checkers::Req},
+    {"a12-1-6", checkers::Req},
+    {"a12-4-1", checkers::Req},
+    {"a12-4-2", checkers::Adv},
+    {"a12-6-1", checkers::Req},
+    {"a12-7-1", checkers::Req},
+    {"a12-8-1", checkers::Req},
+    {"a12-8-2", checkers::Adv},
+    {"a12-8-3", checkers::Req},
+    {"a12-8-4", checkers::Req},
+    {"a12-8-5", checkers::Req},
+    {"a12-8-6", checkers::Req},
+    {"a12-8-7", checkers::Adv},
+    {"a13-1-2", checkers::Req},
+    {"a13-1-3", checkers::Req},
+    {"a13-2-1", checkers::Req},
+    {"a13-2-2", checkers::Req},
+    {"a13-2-3", checkers::Req},
+    {"a13-3-1", checkers::Req},
+    {"a13-5-1", checkers::Req},
+    {"a13-5-2", checkers::Req},
+    {"a13-5-3", checkers::Adv},
+    {"a13-5-4", checkers::Req},
+    {"a13-5-5", checkers::Req},
+    {"a13-6-1", checkers::Req},
+    {"a14-1-1", checkers::Adv},
+    {"a14-5-1", checkers::Req},
+    {"a14-5-2", checkers::Req},
+    {"a14-5-3", checkers::Req},
+    {"m14-5-3", checkers::Req},
+    {"m14-6-1", checkers::Req},
+    {"a14-7-1", checkers::Req},
+    {"a14-7-2", checkers::Req},
+    {"a14-8-2", checkers::Req},
+    {"a15-0-2", checkers::Req},
+    {"a15-1-2", checkers::Req},
+    {"m15-0-3", checkers::Req},
+    {"m15-1-1", checkers::Req},
+    {"m15-1-2", checkers::Req},
+    {"m15-1-3", checkers::Req},
+    {"a15-1-3", checkers::Adv},
+    {"a15-1-4", checkers::Req},
+    {"a15-2-1", checkers::Req},
+    {"a15-2-2", checkers::Req},
+    {"m15-3-1", checkers::Req},
+    {"a15-3-2", checkers::Req},
+    {"a15-3-3", checkers::Req},
+    {"m15-3-3", checkers::Req},
+    {"m15-3-4", checkers::Req},
+    {"a15-3-5", checkers::Req},
+    {"m15-3-6", checkers::Req},
+    {"m15-3-7", checkers::Req},
+    {"a15-4-1", checkers::Req},
+    {"a15-4-2", checkers::Req},
+    {"a15-4-3", checkers::Req},
+    {"a15-4-4", checkers::Req},
+    {"a15-4-5", checkers::Req},
+    {"a15-5-1", checkers::Req},
+    {"a15-5-2", checkers::Req},
+    {"a15-5-3", checkers::Req},
+    {"a16-0-1", checkers::Req},
+    {"m16-0-1", checkers::Req},
+    {"m16-0-2", checkers::Req},
+    {"m16-0-5", checkers::Req},
+    {"m16-0-6", checkers::Req},
+    {"m16-0-7", checkers::Req},
+    {"m16-0-8", checkers::Req},
+    {"m16-1-1", checkers::Req},
+    {"m16-1-2", checkers::Req},
+    {"m16-2-3", checkers::Req},
+    {"a16-2-1", checkers::Req},
+    {"a16-2-2", checkers::Req},
+    {"a16-2-3", checkers::Req},
+    {"m16-3-1", checkers::Req},
+    {"m16-3-2", checkers::Adv},
+    {"a16-6-1", checkers::Req},
+    {"a16-7-1", checkers::Req},
+    {"a17-0-1", checkers::Req},
+    {"m17-0-2", checkers::Req},
+    {"m17-0-3", checkers::Req},
+    {"m17-0-5", checkers::Req},
+    {"a17-1-1", checkers::Req},
+    {"a17-6-1", checkers::Req},
+    {"a18-0-1", checkers::Req},
+    {"a18-0-2", checkers::Req},
+    {"m18-0-3", checkers::Req},
+    {"m18-0-4", checkers::Req},
+    {"m18-0-5", checkers::Req},
+    {"a18-0-3", checkers::Req},
+    {"a18-1-1", checkers::Req},
+    {"a18-1-2", checkers::Req},
+    {"a18-1-3", checkers::Req},
+    {"a18-1-4", checkers::Req},
+    {"a18-1-6", checkers::Req},
+    {"m18-2-1", checkers::Req},
+    {"a18-5-1", checkers::Req},
+    {"a18-5-2", checkers::Req},
+    {"a18-5-3", checkers::Req},
+    {"a18-5-4", checkers::Req},
+    {"a18-5-5", checkers::Req},
+    {"a18-5-6", checkers::Req},
+    {"a18-5-7", checkers::Req},
+    {"a18-5-8", checkers::Req},
+    {"a18-5-9", checkers::Req},
+    {"a18-5-10", checkers::Req},
+    {"a18-5-11", checkers::Req},
+    {"m18-7-1", checkers::Req},
+    {"a18-9-1", checkers::Req},
+    {"a18-9-2", checkers::Req},
+    {"a18-9-3", checkers::Req},
+    {"a18-9-4", checkers::Req},
+    {"m19-3-1", checkers::Req},
+    {"a20-8-1", checkers::Req},
+    {"a20-8-2", checkers::Req},
+    {"a20-8-3", checkers::Req},
+    {"a20-8-4", checkers::Req},
+    {"a20-8-5", checkers::Req},
+    {"a20-8-6", checkers::Req},
+    {"a20-8-7", checkers::Req},
+    {"a21-8-1", checkers::Req},
+    {"a23-0-1", checkers::Req},
+    {"a23-0-2", checkers::Req},
+    {"a25-1-1", checkers::Req},
+    {"a25-4-1", checkers::Req},
+    {"a26-5-1", checkers::Req},
+    {"a26-5-2", checkers::Req},
+    {"m27-0-1", checkers::Req},
+    {"a27-0-1", checkers::Req},
+    {"a27-0-4", checkers::Req},
+    {"a27-0-2", checkers::Adv},
+    {"a27-0-3", checkers::Req},
+};
+""")
+
+
+def getCertCInfo(main_url:str):
+    """Fetches CERT C rules information."""
+    # Fetching the CERT C rules page
+    r = requests.get(main_url, timeout=30)
+    mainpage = r.text
+    for line in mainpage.split('\n'):
+        res = re.search(r'<a href="(/confluence/[^"]+)">(Rule|Rec.) \d\d[.] [A-Za-z ]+ [(][A-Z][A-Z][A-Z][)]', line)
+        if res is None:
+            continue
+        r = requests.get('https://wiki.sei.cmu.edu' + res.group(1), timeout=30)
+        text = r.text.replace('\n', '').replace('<tr>', '\n').replace('</tr>', '\n')
+        rules = []
+        for line in text.split('\n'):
+            if not line.startswith('<td'):
+                continue
+            #print(line)
+            res = re.match(r'[^>]+>([A-Z][A-Z][A-Z][0-9][0-9]-CP*)<.*>(L[1-3])<.+', line)
+            if res:
+                if res.group(1) == 'EXP40-C' and 'EXP39-C' not in rules:
+                    print('    {"EXP39-C", "L2"},')
+                print('    {"%s", "%s"},' % (res.group(1), res.group(2)))
+                rules.append(res.group(1))
+        if 'EXP45-C' in rules:
+            if 'EXP46-C' not in rules:
+                print('    {"EXP46-C", "L2"},')
+            if 'EXP47-C' not in rules:
+                print('    {"EXP47-C", "L2"},')
+
+
+print('std::vector<checkers::Info> checkers::certCInfo{')
+getCertCInfo('https://wiki.sei.cmu.edu/confluence/display/c/2+Rules')
+print('    // Recommendations')
+getCertCInfo('https://wiki.sei.cmu.edu/confluence/display/c/3+Recommendations')
+print('};')
+print('')
+print('std::vector<checkers::Info> checkers::certCppInfo{')
+getCertCInfo('https://wiki.sei.cmu.edu/confluence/pages/viewpage.action?pageId=88046682')
+print('};')
+print('')
+
+
diff --git a/tools/listErrorsWithoutCWE.py b/tools/listErrorsWithoutCWE.py
index 1a4c784c473..0a78ff5bd36 100755
--- a/tools/listErrorsWithoutCWE.py
+++ b/tools/listErrorsWithoutCWE.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 from __future__ import print_function
 import argparse
 import xml.etree.ElementTree as ET
diff --git a/tools/matchcompiler.py b/tools/matchcompiler.py
index 0179232b29d..bb03b6822e2 100755
--- a/tools/matchcompiler.py
+++ b/tools/matchcompiler.py
@@ -1,7 +1,7 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # Cppcheck - A tool for static C/C++ code analysis
-# Copyright (C) 2007-2019 Cppcheck team.
+# Copyright (C) 2007-2021 Cppcheck team.
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -24,6 +24,77 @@
 import argparse
 import errno
 
+tokTypes = {
+    '+': ['eArithmeticalOp'],
+    '-': ['eArithmeticalOp'],
+    '*': ['eArithmeticalOp'],
+    '/': ['eArithmeticalOp'],
+    '%': ['eArithmeticalOp'],
+    '>>': ['eArithmeticalOp'],
+    '<<': ['eArithmeticalOp'],
+    '=': ['eAssignmentOp'],
+    '+=': ['eAssignmentOp'],
+    '-=': ['eAssignmentOp'],
+    '*=': ['eAssignmentOp'],
+    '/=': ['eAssignmentOp'],
+    '%=': ['eAssignmentOp'],
+    '&=': ['eAssignmentOp'],
+    '|=': ['eAssignmentOp'],
+    '^=': ['eAssignmentOp'],
+    '&': ['eBitOp'],
+    '^': ['eBitOp'],
+    '~': ['eBitOp'],
+    'true': ['eBoolean'],
+    'false': ['eBoolean'],
+    '{': ['eBracket'],
+    '}': ['eBracket'],
+    '<': ['eBracket', 'eComparisonOp'],
+    '>': ['eBracket', 'eComparisonOp'],
+    '==': ['eComparisonOp'],
+    '!=': ['eComparisonOp'],
+    '<=': ['eComparisonOp'],
+    '>=': ['eComparisonOp'],
+    '<=>': ['eComparisonOp'],
+    '...': ['eEllipsis'],
+    ',': ['eExtendedOp'],
+    '?': ['eExtendedOp'],
+    ':': ['eExtendedOp'],
+    '(': ['eExtendedOp'],
+    ')': ['eExtendedOp'],
+    '[': ['eExtendedOp', 'eLambda'],
+    ']': ['eExtendedOp', 'eLambda'],
+    '++': ['eIncDecOp'],
+    '--': ['eIncDecOp'],
+    'asm': ['eKeyword'],
+    'auto': ['eKeyword', 'eType'],
+    'break': ['eKeyword'],
+    'case': ['eKeyword'],
+    'const': ['eKeyword'],
+    'continue': ['eKeyword'],
+    'default': ['eKeyword'],
+    'do': ['eKeyword'],
+    'else': ['eKeyword'],
+    'enum': ['eKeyword'],
+    'extern': ['eKeyword'],
+    'for': ['eKeyword'],
+    'goto': ['eKeyword'],
+    'if': ['eKeyword'],
+    'inline': ['eKeyword'],
+    'register': ['eKeyword'],
+    'restrict': ['eKeyword'],
+    'return': ['eKeyword'],
+    'sizeof': ['eKeyword'],
+    'static': ['eKeyword'],
+    'struct': ['eKeyword'],
+    'switch': ['eKeyword'],
+    'typedef': ['eKeyword'],
+    'union': ['eKeyword'],
+    'volatile': ['eKeyword'],
+    'while': ['eKeyword'],
+    'void': ['eKeyword', 'eType'],
+    '&&': ['eLogicalOp'],
+    '!': ['eLogicalOp']
+}
 
 class MatchCompiler:
 
@@ -87,39 +158,41 @@ def _insertMatchFunctionId(
     def _compileCmd(tok):
         if tok == '%any%':
             return 'true'
-        elif tok == '%assign%':
+        if tok == '%assign%':
             return 'tok->isAssignmentOp()'
-        elif tok == '%bool%':
+        if tok == '%bool%':
             return 'tok->isBoolean()'
-        elif tok == '%char%':
-            return '(tok->tokType()==Token::eChar)'
-        elif tok == '%comp%':
+        if tok == '%char%':
+            return '(tok->tokType() == Token::eChar)'
+        if tok == '%comp%':
             return 'tok->isComparisonOp()'
-        elif tok == '%num%':
+        if tok == '%num%':
             return 'tok->isNumber()'
-        elif tok == '%cop%':
+        if tok == '%cop%':
             return 'tok->isConstOp()'
-        elif tok == '%op%':
+        if tok == '%op%':
             return 'tok->isOp()'
-        elif tok == '%or%':
-            return '(tok->tokType() == Token::eBitOp && tok->str()==MatchCompiler::makeConstString("|") )'
-        elif tok == '%oror%':
-            return '(tok->tokType() == Token::eLogicalOp && tok->str()==MatchCompiler::makeConstString("||"))'
-        elif tok == '%str%':
-            return '(tok->tokType()==Token::eString)'
-        elif tok == '%type%':
-            return '(tok->isName() && tok->varId()==0U && !tok->isKeyword())'
-        elif tok == '%name%':
+        if tok == '%or%':
+            return '(tok->tokType() == Token::eBitOp && tok->str() == MatchCompiler::makeConstString("|") )'
+        if tok == '%oror%':
+            return '(tok->tokType() == Token::eLogicalOp && tok->str() == MatchCompiler::makeConstString("||"))'
+        if tok == '%str%':
+            return '(tok->tokType() == Token::eString)'
+        if tok == '%type%':
+            return '(tok->isName() && tok->varId() == 0U)'
+        if tok == '%name%':
             return 'tok->isName()'
-        elif tok == '%var%':
+        if tok == '%var%':
             return '(tok->varId() != 0)'
-        elif tok == '%varid%':
-            return '(tok->isName() && tok->varId()==varid)'
-        elif (len(tok) > 2) and (tok[0] == "%"):
+        if tok == '%varid%':
+            return '(tok->isName() && tok->varId() == varid)'
+        if (len(tok) > 2) and (tok[0] == "%"):
             print("unhandled:" + tok)
-
+        elif tok in tokTypes:
+            cond = ' || '.join(['tok->tokType() == Token::{}'.format(tokType) for tokType in tokTypes[tok]])
+            return '(({cond}) && tok->str() == MatchCompiler::makeConstString("{tok}"))'.format(cond=cond, tok=tok)
         return (
-            '(tok->str()==MatchCompiler::makeConstString("' + tok + '"))'
+            '(tok->str() == MatchCompiler::makeConstString("' + tok + '"))'
         )
 
     def _compilePattern(self, pattern, nr, varid,
@@ -133,7 +206,7 @@ def _compilePattern(self, pattern, nr, varid,
                 arg2 = ', const int varid'
 
             ret = '// pattern: ' + pattern + '\n'
-            ret += 'static bool match' + \
+            ret += 'MAYBE_UNUSED static inline bool match' + \
                 str(nr) + '(' + tokenType + '* tok' + arg2 + ') {\n'
             returnStatement = 'return false;\n'
 
@@ -155,7 +228,7 @@ def _compilePattern(self, pattern, nr, varid,
 
             # [abc]
             if (len(tok) > 2) and (tok[0] == '[') and (tok[-1] == ']'):
-                ret += '    if (!tok || tok->str().size()!=1U || !strchr("' + tok[1:-1] + '", tok->str()[0]))\n'
+                ret += '    if (!tok || tok->str().size() != 1U || !strchr("' + tok[1:-1] + '", tok->str()[0]))\n'
                 ret += '        ' + returnStatement
 
             # a|b|c
@@ -186,7 +259,7 @@ def _compilePattern(self, pattern, nr, varid,
             elif tok[0:2] == "!!":
                 ret += '    if (tok && tok->str() == MatchCompiler::makeConstString("' + tok[2:] + '"))\n'
                 ret += '        ' + returnStatement
-                gotoNextToken = '    tok = tok ? tok->next() : NULL;\n'
+                gotoNextToken = '    tok = tok ? tok->next() : nullptr;\n'
 
             else:
                 negatedTok = "!" + self._compileCmd(tok)
@@ -217,14 +290,14 @@ def _compileFindPattern(self, pattern, findmatchnr, endToken, varId):
             more_args += ', int varid'
 
         ret = '// pattern: ' + pattern + '\n'
-        ret += 'template<class T> static T * findmatch' + \
+        ret += 'template<class T> MAYBE_UNUSED static inline T * findmatch' + \
             str(findmatchnr) + '(T * start_tok' + more_args + ') {\n'
         ret += '    for (; start_tok' + endCondition + \
             '; start_tok = start_tok->next()) {\n'
 
         ret += self._compilePattern(pattern, -1, varId, True, 'T')
         ret += '    }\n'
-        ret += '    return NULL;\n}\n'
+        ret += '    return nullptr;\n}\n'
 
         return ret
 
@@ -300,7 +373,7 @@ def _compileVerifyTokenMatch(
         if varId:
             more_args = ', const int varid'
 
-        ret = 'static bool match_verify' + \
+        ret = 'MAYBE_UNUSED static inline bool match_verify' + \
             str(verifyNumber) + '(const Token *tok' + more_args + ') {\n'
 
         origMatchName = 'Match'
@@ -330,8 +403,8 @@ def _compileVerifyTokenMatch(
         # ret += '            std::cout << "tok: " << tok->str();\n'
         # ret += '        if (tok->next())\n'
         # ret += '            std::cout << "tok next: " << tok->next()->str();\n'
-        ret += '        throw InternalError(tok, "Internal error.' +\
-            'compiled match returned different result than parsed match: ' + pattern + '");\n'
+        ret += '        throw InternalError(tok, "Internal error. ' +\
+            'Compiled match returned different result than parsed match: ' + pattern + '");\n'
         ret += '    }\n'
         ret += '    return res_compiled_match;\n'
         ret += '}\n'
@@ -380,44 +453,50 @@ def _replaceSpecificTokenMatch(
         )
 
     def _replaceTokenMatch(self, line, linenr, filename):
-        while True:
-            is_simplematch = False
-            pos1 = line.find('Token::Match(')
-            if pos1 == -1:
-                is_simplematch = True
-                pos1 = line.find('Token::simpleMatch(')
-            if pos1 == -1:
-                break
-
-            res = self.parseMatch(line, pos1)
-            if res is None:
-                break
-
-            # assert that Token::Match has either 2 or 3 arguments
-            assert(len(res) == 3 or len(res) == 4)
-
-            end_pos = len(res[0])
-            tok = res[1]
-            raw_pattern = res[2]
-            varId = None
-            if len(res) == 4:
-                varId = res[3]
+        for func in ('Match', 'simpleMatch'):
+            is_simplematch = func == 'simpleMatch'
+            pattern_start = 0
+            while True:
+                # skip comments
+                if line.strip().startswith('//'):
+                    break
+
+                pos1 = line.find('Token::' + func + '(', pattern_start)
+                if pos1 == -1:
+                    break
+
+                res = self.parseMatch(line, pos1)
+                if res is None:
+                    break
+
+                # assert that Token::Match has either 2 or 3 arguments
+                assert(len(res) == 3 or len(res) == 4)
+
+                end_pos = len(res[0])
+                tok = res[1]
+                raw_pattern = res[2]
+                varId = None
+                if len(res) == 4:
+                    varId = res[3]
 
-            res = re.match(r'\s*"((?:.|\\")*?)"\s*$', raw_pattern)
-            if res is None:
-                if self._showSkipped:
-                    print(filename + ":" + str(linenr) + " skipping match pattern:" + raw_pattern)
-                break  # Non-const pattern - bailout
+                pattern_start = pos1 + end_pos
+                res = re.match(r'\s*"((?:.|\\")*?)"\s*$', raw_pattern)
+                if res is None:
+                    if self._showSkipped:
+                        print(filename + ":" + str(linenr) + " skipping match pattern:" + raw_pattern)
+                    continue # Non-const pattern - bailout
 
-            pattern = res.group(1)
-            line = self._replaceSpecificTokenMatch(
-                is_simplematch,
-                line,
-                pos1,
-                end_pos,
-                pattern,
-                tok,
-                varId)
+                pattern = res.group(1)
+                orig_len = len(line)
+                line = self._replaceSpecificTokenMatch(
+                    is_simplematch,
+                    line,
+                    pos1,
+                    end_pos,
+                    pattern,
+                    tok,
+                    varId)
+                pattern_start += len(line) - orig_len
 
         return line
 
@@ -430,7 +509,7 @@ def _compileVerifyTokenFindMatch(
         if varId:
             more_args += ', const int varid'
 
-        ret = 'template < class T > static T * findmatch_verify' + \
+        ret = 'template < class T > MAYBE_UNUSED static inline T * findmatch_verify' + \
             str(verifyNumber) + '(T * tok' + more_args + ') {\n'
 
         origFindMatchName = 'findmatch'
@@ -459,7 +538,7 @@ def _compileVerifyTokenFindMatch(
         # We also need to verify builds in 'release' mode
         ret += '    if (res_parsed_findmatch != res_compiled_findmatch) {\n'
         ret += '        throw InternalError(tok, "Internal error. ' +\
-            'compiled findmatch returned different result than parsed findmatch: ' + pattern + '");\n'
+            'Compiled findmatch returned different result than parsed findmatch: ' + pattern + '");\n'
         ret += '    }\n'
         ret += '    return res_compiled_findmatch;\n'
         ret += '}\n'
@@ -600,20 +679,20 @@ def _replaceCStrings(self, line):
     def convertFile(self, srcname, destname, line_directive):
         self._reset()
 
-        fin = io.open(srcname, "rt", encoding="utf-8")
-        srclines = fin.readlines()
-        fin.close()
+        with io.open(srcname, "rt", encoding="utf-8") as fin:
+            srclines = fin.readlines()
 
-        header = '#include "token.h"\n'
-        header += '#include "errorlogger.h"\n'
-        header += '#include "matchcompiler.h"\n'
-        header += '#include <string>\n'
-        header += '#include <cstring>\n'
-        # header += '#include <iostream>\n'
         code = ''
 
+        modified = False
+
         linenr = 0
         for line in srclines:
+            if not modified:
+                line_orig = line
+            else:
+                line_orig = None
+
             linenr += 1
             # Compile Token::Match and Token::simpleMatch
             line = self._replaceTokenMatch(line, linenr, srcname)
@@ -624,20 +703,47 @@ def convertFile(self, srcname, destname, line_directive):
             # Cache plain C-strings in C++ strings
             line = self._replaceCStrings(line)
 
+            if not modified and not line_orig == line:
+                modified = True
+
             code += line
 
         # Compute matchFunctions
-        strFunctions = ''
-        for function in self._rawMatchFunctions:
-            strFunctions += function
+        strFunctions = ''.join(self._rawMatchFunctions)
 
         lineno = ''
         if line_directive:
             lineno = '#line 1 "' + srcname + '"\n'
 
-        fout = io.open(destname, 'wt', encoding="utf-8")
-        fout.write(header + strFunctions + lineno + code)
-        fout.close()
+        header = '#include "matchcompiler.h"\n'
+        header += '#include <string>\n'
+        header += '#include <cstring>\n'
+        if len(self._rawMatchFunctions):
+            header += '#include "errorlogger.h"\n'
+            header += '#include "token.h"\n'
+            header += '#if defined(__clang__)\n'
+            header += '#include "config.h"\n'
+            header += '#define MAYBE_UNUSED [[maybe_unused]]\n'  # this attribute is also available in earlier standards
+            header += 'SUPPRESS_WARNING_CLANG_PUSH("-Wc++17-attribute-extensions")\n'  # suppress waning about using above attribute in earlier standard
+            header += '#else\n'
+            header += '#define MAYBE_UNUSED\n'
+            header += '#endif\n'
+
+        footer = ''
+        if len(self._rawMatchFunctions):
+            footer += '#if defined(__clang__)\n'
+            footer += 'SUPPRESS_WARNING_CLANG_POP\n'
+            footer += '#endif\n'
+            footer += '#undef MAYBE_UNUSED\n'
+
+        with io.open(destname, 'wt', encoding="utf-8") as fout:
+            if modified or len(self._rawMatchFunctions):
+                fout.write(header)
+                fout.write(strFunctions)
+            fout.write(lineno)
+            fout.write(code)
+            if modified or len(self._rawMatchFunctions):
+                fout.write(footer)
 
 
 def main():
@@ -668,7 +774,7 @@ def main():
 
     # Check if we are invoked from the right place
     if not os.path.exists(lib_dir):
-        print('Directory "' + lib_dir + '"not found.')
+        print('Directory "' + lib_dir + '" not found.')
         sys.exit(-1)
 
     # Create build directory if needed
diff --git a/tools/parse-glibc.py b/tools/parse-glibc.py
index cb79edec812..6aaef2be32c 100644
--- a/tools/parse-glibc.py
+++ b/tools/parse-glibc.py
@@ -1,126 +1,123 @@
-#!/usr/bin/env python
-
-import glob
-import os
-
-
-def checknonnull(cfg, functionName, nonnull):
-    pos1 = cfg.find('<function name="' + functionName + '">')
-    if pos1 < 0:
-        return
-    pos2 = cfg.find('</function>', pos1)
-    if pos2 < 0:
-        return
-    functionCfg = cfg[pos1:pos2]
-    s = None
-    for argnr in range(10):
-        argpos1 = functionCfg.find('<arg nr="' + str(argnr) + '">')
-        if argpos1 < 0:
-            continue
-        argpos2 = functionCfg.find('</arg>', argpos1)
-        notnullpos = functionCfg.find('not-null', argpos1)
-        if 0 <= notnullpos < argpos2:
-            if s:
-                s += ', ' + str(argnr)
-            else:
-                s = str(argnr)
-    if s != nonnull:
-        if not nonnull:
-            nonnull = ''
-        if not s:
-            s = ''
-        print(functionName + '\tglibc:' + nonnull + '\tcfg:' + s)
-
-
-def parseheader(cppcheckpath, filename):
-    f = open(filename, 'rt')
-    data = f.read()
-    f.close()
-
-    f = open(cppcheckpath + '/cfg/std.cfg', 'rt')
-    stdcfg = f.read()
-    f.close()
-
-    f = open(cppcheckpath + '/cfg/posix.cfg', 'rt')
-    posixcfg = f.read()
-    f.close()
-
-    while '/*' in data:
-        pos1 = data.find('/*')
-        pos2 = data.find('*/', pos1 + 2)
-        data = data[:pos1] + data[pos2 + 2:]
-
-    data = data.replace('\\\n', '')
-
-    while '\n#' in data:
-        pos1 = data.find('\n#')
-        pos2 = data.find('\n', pos1 + 1)
-        data = data[:pos1] + data[pos2:]
-
-    while '\n__BEGIN' in data:
-        pos1 = data.find('\n__BEGIN')
-        pos2 = data.find('\n', pos1 + 1)
-        data = data[:pos1] + data[pos2:]
-
-    while '\n__END' in data:
-        pos1 = data.find('\n__END')
-        pos2 = data.find('\n', pos1 + 1)
-        data = data[:pos1] + data[pos2:]
-
-    data = data.replace('\n\n', '\n')
-    data = data.replace('\t', '    ')
-    data = data.replace(',\n  ', ',')
-    data = data.replace(')\n  ', ',')
-    data = data.replace('  ', ' ')
-
-    output = []
-
-    for line in data.split('\n'):
-        if (line[:7] != 'extern ' and ' extern ' not in line) or line[-1] != ';':
-            continue
-
-        functionNameEnd = line.find('(') - 1
-        if functionNameEnd < 0:
-            continue
-        while line[functionNameEnd] == ' ':
-            functionNameEnd -= 1
-        if functionNameEnd < 10:
-            continue
-        functionNameStart = functionNameEnd
-        while line[functionNameStart] == '_' or line[functionNameStart].isalnum():
-            functionNameStart -= 1
-        if functionNameStart < 10:
-            continue
-        if line[functionNameStart] != '*' and line[functionNameStart] != ' ':
-            continue
-        functionNameStart += 1
-        if not line[functionNameStart].isalpha():
-            continue
-
-        functionName = line[functionNameStart:functionNameEnd + 1]
-
-        nonnull = None
-
-        nonnullStart = line.find('__nonnull')
-        if nonnullStart >= 0:
-            nonnullStart += 9
-            while nonnullStart < len(line) and line[nonnullStart] == ' ':
-                nonnullStart += 1
-            if nonnullStart >= len(line) or line[nonnullStart] != '(':
-                continue
-            while line[nonnullStart] == '(':
-                nonnullStart += 1
-            nonnullEnd = line.find(')', nonnullStart)
-            nonnull = line[nonnullStart:nonnullEnd]
-
-        checknonnull(stdcfg, functionName, nonnull)
-        checknonnull(posixcfg, functionName, nonnull)
-
-        if nonnull:
-            s = functionName + ' ' + nonnull
-            if s not in output:
-                output.append(s)
-
-
-for f in glob.glob('/usr/include/*.h'):
-    parseheader(os.path.expanduser('~/cppcheck'), f)
+#!/usr/bin/env python3
+
+import glob
+import os
+
+
+def checknonnull(cfg, functionName, nonnull):
+    pos1 = cfg.find('<function name="' + functionName + '">')
+    if pos1 < 0:
+        return
+    pos2 = cfg.find('</function>', pos1)
+    if pos2 < 0:
+        return
+    functionCfg = cfg[pos1:pos2]
+    s = None
+    for argnr in range(10):
+        argpos1 = functionCfg.find('<arg nr="' + str(argnr) + '">')
+        if argpos1 < 0:
+            continue
+        argpos2 = functionCfg.find('</arg>', argpos1)
+        notnullpos = functionCfg.find('not-null', argpos1)
+        if 0 <= notnullpos < argpos2:
+            if s:
+                s += ', ' + str(argnr)
+            else:
+                s = str(argnr)
+    if s != nonnull:
+        if not nonnull:
+            nonnull = ''
+        if not s:
+            s = ''
+        print(functionName + '\tglibc:' + nonnull + '\tcfg:' + s)
+
+
+def parseheader(cppcheckpath, filename):
+    with open(filename, 'rt') as f:
+        data = f.read()
+
+    with open(cppcheckpath + '/cfg/std.cfg', 'rt') as f:
+        stdcfg = f.read()
+
+    with open(cppcheckpath + '/cfg/posix.cfg', 'rt') as f:
+        posixcfg = f.read()
+
+    while '/*' in data:
+        pos1 = data.find('/*')
+        pos2 = data.find('*/', pos1 + 2)
+        data = data[:pos1] + data[pos2 + 2:]
+
+    data = data.replace('\\\n', '')
+
+    while '\n#' in data:
+        pos1 = data.find('\n#')
+        pos2 = data.find('\n', pos1 + 1)
+        data = data[:pos1] + data[pos2:]
+
+    while '\n__BEGIN' in data:
+        pos1 = data.find('\n__BEGIN')
+        pos2 = data.find('\n', pos1 + 1)
+        data = data[:pos1] + data[pos2:]
+
+    while '\n__END' in data:
+        pos1 = data.find('\n__END')
+        pos2 = data.find('\n', pos1 + 1)
+        data = data[:pos1] + data[pos2:]
+
+    data = data.replace('\n\n', '\n')
+    data = data.replace('\t', '    ')
+    data = data.replace(',\n  ', ',')
+    data = data.replace(')\n  ', ',')
+    data = data.replace('  ', ' ')
+
+    output = []
+
+    for line in data.split('\n'):
+        if (line[:7] != 'extern ' and ' extern ' not in line) or line[-1] != ';':
+            continue
+
+        functionNameEnd = line.find('(') - 1
+        if functionNameEnd < 0:
+            continue
+        while line[functionNameEnd] == ' ':
+            functionNameEnd -= 1
+        if functionNameEnd < 10:
+            continue
+        functionNameStart = functionNameEnd
+        while line[functionNameStart] == '_' or line[functionNameStart].isalnum():
+            functionNameStart -= 1
+        if functionNameStart < 10:
+            continue
+        if line[functionNameStart] != '*' and line[functionNameStart] != ' ':
+            continue
+        functionNameStart += 1
+        if not line[functionNameStart].isalpha():
+            continue
+
+        functionName = line[functionNameStart:functionNameEnd + 1]
+
+        nonnull = None
+
+        nonnullStart = line.find('__nonnull')
+        if nonnullStart >= 0:
+            nonnullStart += 9
+            while nonnullStart < len(line) and line[nonnullStart] == ' ':
+                nonnullStart += 1
+            if nonnullStart >= len(line) or line[nonnullStart] != '(':
+                continue
+            while line[nonnullStart] == '(':
+                nonnullStart += 1
+            nonnullEnd = line.find(')', nonnullStart)
+            nonnull = line[nonnullStart:nonnullEnd]
+
+        checknonnull(stdcfg, functionName, nonnull)
+        checknonnull(posixcfg, functionName, nonnull)
+
+        if nonnull:
+            s = functionName + ' ' + nonnull
+            if s not in output:
+                output.append(s)
+
+
+for f in glob.glob('/usr/include/*.h'):
+    parseheader(os.path.expanduser('~/cppcheck'), f)
diff --git a/tools/pr.py b/tools/pr.py
deleted file mode 100644
index 62b88809d77..00000000000
--- a/tools/pr.py
+++ /dev/null
@@ -1,52 +0,0 @@
-
-import requests
-import subprocess
-import sys
-
-response = requests.get('https://api.github.com/repos/danmar/cppcheck/pulls/' + sys.argv[1])
-if response.status_code == 200:
-    j = response.json()
-    login = j['user']['login']
-    title = j['title']
-    body  = j['body']
-    branch = j['head']['ref']
-    sha = j['head']['sha']
-
-    subprocess.call('git checkout -b {}-{} master'.format(login, branch).split())
-    p = subprocess.Popen('git pull --rebase=true https://github.com/{}/cppcheck.git {}'.format(login, branch).split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    comm = p.communicate()
-    stdout = comm[0].decode(encoding='utf-8', errors='ignore')
-    stderr = comm[1].decode(encoding='utf-8', errors='ignore')
-    print(stdout)
-    print(stderr)
-    if stdout.find('CONFLICT') > 0 or stderr.find('CONFLICT') > 0:
-        print('FAIL; There was some conflict when rebasing the changes')
-        sys.exit(1)
-
-    if '-b' in sys.argv:
-        print('Done.')
-        sys.exit(1)
-
-    p = subprocess.Popen(['git', 'show', '--format=%an <%ae>', sha], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    comm = p.communicate()
-    author = comm[0].decode(encoding='utf-8', errors='ignore').split('\n')[0]
-    if login == 'pfultz2':
-        author = 'Paul Fultz II ' + author[author.find('<'):]
-
-    subprocess.call(['./runastyle'])
-    subprocess.call('git commit -a -m astyle'.split())
-
-    subprocess.call('git checkout master'.split())
-    subprocess.call('git merge --squash {}-{}'.format(login, branch).split())
-    subprocess.call(['git', 'commit', '-a', '--author='+author, '-m', title + '\n\n' + body])
-    subprocess.call('git branch -D {}-{}'.format(login, branch).split())
-
-    p = subprocess.Popen('git show --format=format:%h'.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    comm = p.communicate()
-    stdout = comm[0].decode(encoding='utf-8', errors='ignore')
-    if stdout.find('\n') > 0:
-        stdout = stdout[:stdout.find('\n')]
-    print('\nMessage: I merged this with ' + stdout)
-
-
-
diff --git a/tools/readme.md b/tools/readme.md
index c57f83dd9b0..4f914b3cce6 100644
--- a/tools/readme.md
+++ b/tools/readme.md
@@ -1,19 +1,5 @@
 ## Cppcheck developer and build tools
 
-##¤ * tools/astyle-client.py
-
-With this tool you can astyle-format arbitrary cpp/header files even if you do not have astyle on your computer.
-
-astyle on a server is used.
-
-Example usage:
-
-    python tools/astyle-client.py lib/token.cpp
-
-The file is reformatted and a status message is written that says if there were any changes or not.
-
-This script is a lot slower than running astyle locally on your computer.
-
 ### * tools/matchcompiler.py
 
 The matchcompiler.py is a build script that performs a few code transformations to *.cpp* files under the *lib* directory. These transformations are related to the use of `Token::Match()` function and are intended to improve code performance. The transformed files are saved on the *build* directory. This tool is silently used when building the code with `SRCDIR=build`, that is:
@@ -63,7 +49,7 @@ void f2() {
 ```
 From this we can see that the usage of `Token::Match()` in `f1()` has been optimized, whereas the one in `f2()` couldn't be optimized (the string wasn't inline on the `Token::Match()` call). **The developer doesn't need to use this tool during development but should be aware of these optimizations**. *Building with this optimization, cppcheck can get a boost of 2x of speed-up.*
 
-### * tools/dmake.cpp
+### * tools/dmake/dmake.cpp
 
 Automatically generates the main `Makefile` for Cppcheck (**the main `Makefile` should not be modified manually**). To build and run the `dmake` tool execute:
 ```shell
@@ -79,4 +65,21 @@ Script that reduces code for a hang/false positive.
 
 Script to generate a `times.log` file that contains timing information of the last 20 revisions.
 
+### * tools/donate-cpu.py
+
+Script to donate CPU time to Cppcheck project by checking current Debian packages.
+
+### * tools/test-my-pr.py
+
+Script to compare result of working Cppcheck from your branch with main branch.
+
+### * tools/triage
+
+This tool lets you comfortably look at Cppcheck analysis results for daca packages. It automatically
+downloads the package, extracts it and jumps to the corresponding source code for a Cppcheck
+message.
+
+### * tools/check-errorids.sh
 
+Script to compare the error IDs in the expected `testrunner` output (without executing it) with the `--errorlist` output.
+It will report missing test coverage for an ID and missing IDs in the `--errorlist` output.
diff --git a/tools/reduce.py b/tools/reduce.py
index 2d4c298612a..472dff7d98e 100755
--- a/tools/reduce.py
+++ b/tools/reduce.py
@@ -1,286 +1,353 @@
-#!/usr/bin/env python
+"""
+usage: reduce.py [-h] -exe EXE -exe_args EXE_ARGS -expected EXPECTED -file FILE [-segfault]
+
+options:
+  -h, --help            show this help message and exit
+  -exe EXE, --exe EXE   cppcheck executable
+  -exe_args EXE_ARGS, --exe_args EXE_ARGS
+                        cppcheck executable commands
+  -expected EXPECTED, --expected EXPECTED
+                        expected text output
+  -file FILE, --file FILE
+                        source file
+  -segfault, --segfault
+"""
+
+#!/usr/bin/env python3
 import subprocess
 import sys
+import time
+import argparse
 
-def show_syntax():
-    print('Syntax:')
-    print('  reduce.py --cmd=<full command> --expected=<expected text output> --file=<source file> [--segfault]')
-    print('')
-    print("Example. source file = foo/bar.c")
-    print("  reduce.py --cmd='./cppcheck --enable=style foo/bar.c' --expected=\"Variable 'x' is reassigned\" --file=foo/bar.c")
-    sys.exit(1)
-
-if len(sys.argv) == 1:
-    show_syntax()
-
-CMD = None
-EXPECTED = None
-SEGFAULT = False
-FILE = None
-BACKUPFILE = None
-for arg in sys.argv[1:]:
-    if arg.startswith('--cmd='):
-        CMD = arg[arg.find('=') + 1:]
-    elif arg.startswith('--expected='):
-        EXPECTED = arg[arg.find('=') + 1:]
-    elif arg.startswith('--file='):
-        FILE = arg[arg.find('=') + 1:]
-        BACKUPFILE = FILE + '.bak'
-    elif arg == '--segfault':
-        SEGFAULT = True
-
-if CMD is None:
-    print('Abort: No --cmd')
-    show_syntax()
-
-if not SEGFAULT and EXPECTED is None:
-    print('Abort: No --expected')
-    show_syntax()
-
-if FILE is None:
-    print('Abort: No --file')
-    show_syntax()
-
-print('CMD=' + CMD)
-if SEGFAULT:
-    print('EXPECTED=SEGFAULT')
-else:
-    print('EXPECTED=' + EXPECTED)
-print('FILE=' + FILE)
-
-
-def runtool():
-    p = subprocess.Popen(CMD.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    comm = p.communicate()
-    if SEGFAULT:
-        if p.returncode != 0:
-            return True
-    elif p.returncode == 0:
-        out = comm[0] + '\n' + comm[1]
-        if 'error:' not in out and EXPECTED in out:
+
+class Reduce:
+    def __init__(self, cmd, expected, file, segfault=None):
+        if not "".join(cmd):
+            raise RuntimeError('Abort: No --cmd')
+
+        if not segfault and not expected:
+            raise RuntimeError('Abort: No --expected')
+
+        if not file:
+            raise RuntimeError('Abort: No --file')
+
+        # need to add '--error-exitcode=0' so detected issues will not be interpreted as a crash
+        if segfault and '--error-exitcode=0' not in cmd:
+            print("Adding '--error-exitcode=0' to --cmd")
+            self.__cmd = cmd + ['--error-exitcode=0']
+        else:
+            self.__cmd = cmd
+        self.__expected = expected
+        self.__file = file
+        self.__segfault = segfault
+        self.__origfile = self.__file + '.org'
+        self.__backupfile = self.__file + '.bak'
+        self.__timeoutfile = self.__file + '.timeout'
+        self.__elapsed_time = None
+
+    def print_info(self):
+        print('CMD=', " ".join(self.__cmd))
+        if self.__segfault:
+            print('EXPECTED=SEGFAULT')
+        else:
+            print('EXPECTED=' + self.__expected)
+        print('FILE=' + self.__file)
+
+    def __communicate(self, p, timeout=None, **kwargs):
+        return p.communicate(timeout=timeout)
+
+    def runtool(self, filedata=None):
+        TimeoutExpired = subprocess.TimeoutExpired
+
+        timeout = None
+        if self.__elapsed_time:
+            timeout = self.__elapsed_time * 2
+        p = subprocess.Popen(self.__cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
+        try:
+            stdout, stderr = self.__communicate(p, timeout=timeout)
+        except TimeoutExpired:
+            print('timeout')
+            p.kill()
+            p.communicate()
+            if filedata:
+                self.writetimeoutfile(filedata)
+            return False
+        # print(p.returncode)
+        # print(comm)
+        if self.__segfault:
+            if p.returncode != 0:
+                return True
+        elif p.returncode == 0:
+            out = stdout + '\n' + stderr
+            if self.__expected in out:
+                return True
+        else:
+            # Something could be wrong, for example the command line for Cppcheck (CMD).
+            # Print the output to give a hint how to fix it.
+            print('Error: {}\n{}'.format(stdout, stderr))
+        return False
+
+    def __writefile(self, filename, filedata):
+        with open(filename, 'wt') as f:
+            for line in filedata:
+                f.write(line)
+
+    def replaceandrun(self, what, filedata, i, line):
+        print(what + ' ' + str(i + 1) + '/' + str(len(filedata)) + '..')
+        bak = filedata[i]
+        filedata[i] = line
+        self.writefile(filedata)
+        if self.runtool(filedata):
+            print('pass')
+            self.writebackupfile(filedata)
             return True
-    return False
-
-
-def writefile(filename, filedata):
-    f = open(filename, 'wt')
-    for line in filedata:
-        f.write(line)
-    f.close()
-
-
-def replaceandrun(what, filedata, i, line):
-    print(what + ' ' + str(i + 1) + '/' + str(len(filedata)) + '..')
-    bak = filedata[i]
-    filedata[i] = line
-    writefile(FILE, filedata)
-    if runtool():
-        print('pass')
-        writefile(BACKUPFILE, filedata)
-        return True
-    print('fail')
-    filedata[i] = bak
-    return False
-
-
-def replaceandrun2(what, filedata, i, line1, line2):
-    print(what + ' ' + str(i + 1) + '/' + str(len(filedata)) + '..')
-    bak1 = filedata[i]
-    bak2 = filedata[i + 1]
-    filedata[i] = line1
-    filedata[i + 1] = line2
-    writefile(FILE, filedata)
-    if runtool():
-        print('pass')
-        writefile(BACKUPFILE, filedata)
-    else:
         print('fail')
-        filedata[i] = bak1
-        filedata[i + 1] = bak2
-
-
-def clearandrun(what, filedata, i1, i2):
-    print(what + ' ' + str(i1 + 1) + '/' + str(len(filedata)) + '..')
-    filedata2 = list(filedata)
-    i = i1
-    while i <= i2 and i < len(filedata2):
-        filedata2[i] = ''
-        i = i + 1
-    writefile(FILE, filedata2)
-    if runtool():
-        print('pass')
-        writefile(BACKUPFILE, filedata2)
-        return filedata2
-    print('fail')
-    return filedata
-
-
-def removecomments(filedata):
-    for i in range(len(filedata)):
-        line = filedata[i]
-        if '//' in line:
-            replaceandrun('remove comment', filedata, i, line[:line.find('//')].rstrip())
-
-
-def checkpar(line):
-    par = 0
-    for c in line:
-        if c == '(' or c == '[':
-            par = par + 1
-        elif c == ')' or c == ']':
-            par = par - 1
-            if par < 0:
-                return False
-    return par == 0
-
-
-def combinelines(filedata):
-    if len(filedata) < 3:
-        return
-
-    lines = []
-
-    for i in range(len(filedata) - 1):
-        fd1 = filedata[i].rstrip()
-        if fd1.endswith(','):
-            fd2 = filedata[i + 1].lstrip()
-            if fd2 != '':
-                lines.append(i)
-
-    chunksize = len(lines)
-    while chunksize > 10:
-        i = 0
-        while i < len(lines):
-            i1 = i
-            i2 = i + chunksize
-            i = i2
-            if i2 > len(lines):
-                i2 = len(lines)
-
-            filedata2 = list(filedata)
-            for line in lines[i1:i2]:
-                filedata2[line] = filedata2[line].rstrip() + filedata2[line + 1].lstrip()
-                filedata2[line + 1] = ''
-
-            if replaceandrun('combine lines', filedata2, lines[i1] + 1, ''):
-                filedata = filedata2
-                lines[i1:i2] = []
-                i = i1
-
-        chunksize = chunksize / 2
-
-    for line in lines:
-        fd1 = filedata[line].rstrip()
-        fd2 = filedata[line + 1].lstrip()
-        replaceandrun2('combine lines', filedata, line, fd1 + fd2, '')
-
-
-def removedirectives(filedata):
-    for i in range(len(filedata)):
-        if filedata[i].lstrip().startswith('#'):
-            replaceandrun('remove preprocessor directive', filedata, i, '')
-
-
-def removeblocks(filedata):
-    if len(filedata) < 3:
+        filedata[i] = bak
+        return False
+
+    def replaceandrun2(self, what, filedata, i, line1, line2):
+        print(what + ' ' + str(i + 1) + '/' + str(len(filedata)) + '..')
+        bak1 = filedata[i]
+        bak2 = filedata[i + 1]
+        filedata[i] = line1
+        filedata[i + 1] = line2
+        self.writefile(filedata)
+        if self.runtool(filedata):
+            print('pass')
+            self.writebackupfile(filedata)
+        else:
+            print('fail')
+            filedata[i] = bak1
+            filedata[i + 1] = bak2
+
+    def clearandrun(self, what, filedata, i1, i2):
+        print(what + ' ' + str(i1 + 1) + '/' + str(len(filedata)) + '..')
+        filedata2 = list(filedata)
+        i = i1
+        while i <= i2 and i < len(filedata2):
+            filedata2[i] = ''
+            i = i + 1
+        self.writefile(filedata2)
+        if self.runtool(filedata2):
+            print('pass')
+            self.writebackupfile(filedata2)
+            return filedata2
+        print('fail')
         return filedata
 
-    for i in range(len(filedata)):
-        strippedline = filedata[i].strip()
-        if len(strippedline) == 0:
-            continue
-        if strippedline[-1] not in ';{}':
-            continue
-
-        i1 = i + 1
-        while i1 < len(filedata) and filedata[i1].startswith('#'):
-            i1 = i1 + 1
-
-        i2 = i1
-        indent = 0
-        while i2 < len(filedata):
-            for c in filedata[i2]:
-                if c == '}':
-                    indent = indent - 1
-                    if indent == 0:
-                        indent = -100
-                elif c == '{':
-                    indent = indent + 1
-            if indent < 0:
-                break
-            i2 = i2 + 1
-        if indent == -100:
+    def removecomments(self, filedata):
+        for i in range(len(filedata)):
+            line = filedata[i]
+            if '//' in line:
+                self.replaceandrun('remove comment', filedata, i, line[:line.find('//')].rstrip() + '\n')
+
+    def checkpar(self, line):
+        par = 0
+        for c in line:
+            if c == '(' or c == '[':
+                par = par + 1
+            elif c == ')' or c == ']':
+                par = par - 1
+                if par < 0:
+                    return False
+        return par == 0
+
+    def combinelines(self, filedata):
+        if len(filedata) < 3:
+            return filedata
+
+        lines = []
+
+        for i in range(len(filedata) - 1):
+            fd1 = filedata[i].rstrip()
+            if fd1.endswith(','):
+                fd2 = filedata[i + 1].lstrip()
+                if fd2 != '':
+                    lines.append(i)
+
+        chunksize = len(lines)
+        while chunksize > 10:
+            i = 0
+            while i < len(lines):
+                i1 = i
+                i2 = i + chunksize
+                i = i2
+                i2 = min(i2, len(lines))
+
+                filedata2 = list(filedata)
+                for line in lines[i1:i2]:
+                    filedata2[line] = filedata2[line].rstrip() + filedata2[line + 1].lstrip()
+                    filedata2[line + 1] = ''
+
+                if self.replaceandrun('combine lines (chunk)', filedata2, lines[i1] + 1, ''):
+                    filedata = filedata2
+                    lines[i1:i2] = []
+                    i = i1
+
+            chunksize = int(chunksize / 2)
+
+        for line in lines:
+            fd1 = filedata[line].rstrip()
+            fd2 = filedata[line + 1].lstrip()
+            self.replaceandrun2('combine lines', filedata, line, fd1 + fd2, '')
+
+        return filedata
+
+    def removedirectives(self, filedata):
+        for i in range(len(filedata)):
+            line = filedata[i].lstrip()
+            if line.startswith('#'):
+                # these cannot be removed on their own so skip them
+                if line.startswith('#if') or line.startswith('#endif') or line.startswith('#el'):
+                    continue
+                self.replaceandrun('remove preprocessor directive', filedata, i, '')
+
+    def removeblocks(self, filedata):
+        if len(filedata) < 3:
+            return filedata
+
+        for i in range(len(filedata)):
+            strippedline = filedata[i].strip()
+            if len(strippedline) == 0:
+                continue
+            if strippedline[-1] not in ';{}':
+                continue
+
+            i1 = i + 1
+            while i1 < len(filedata) and filedata[i1].startswith('#'):
+                i1 = i1 + 1
+
+            i2 = i1
             indent = 0
-        if i2 == i1 or i2 >= len(filedata):
-            continue
-        if filedata[i2].strip() != '}' and filedata[i2].strip() != '};':
-            continue
-        if indent < 0:
-            i2 = i2 - 1
-        filedata = clearandrun('remove codeblock', filedata, i1, i2)
+            while i2 < len(filedata):
+                for c in filedata[i2]:
+                    if c == '}':
+                        indent = indent - 1
+                        if indent == 0:
+                            indent = -100
+                    elif c == '{':
+                        indent = indent + 1
+                if indent < 0:
+                    break
+                i2 = i2 + 1
+            if indent == -100:
+                indent = 0
+            if i2 == i1 or i2 >= len(filedata):
+                continue
+            if filedata[i2].strip() != '}' and filedata[i2].strip() != '};':
+                continue
+            if indent < 0:
+                i2 = i2 - 1
+            filedata = self.clearandrun('remove codeblock', filedata, i1, i2)
 
-    return filedata
+        return filedata
 
+    def removeline(self, filedata):
+        stmt = True
+        for i in range(len(filedata)):
+            line = filedata[i]
+            strippedline = line.strip()
 
-def removeline(filedata):
-    stmt = True
-    for i in range(len(filedata)):
-        line = filedata[i]
-        strippedline = line.strip()
+            if len(strippedline) == 0:
+                continue
 
-        if len(strippedline) == 0:
-            continue
+            if stmt and strippedline[-1] == ';' and self.checkpar(line) and '{' not in line and '}' not in line:
+                self.replaceandrun('remove line', filedata, i, '')
 
-        if stmt and strippedline[-1] == ';' and checkpar(line) and '{' not in line and '}' not in line:
-            replaceandrun('remove line', filedata, i, '')
+            elif stmt and '{' in strippedline and strippedline.find('}') == len(strippedline) - 1:
+                self.replaceandrun('remove line', filedata, i, '')
 
-        elif stmt and '{' in strippedline and strippedline.find('}') == len(strippedline) - 1:
-            replaceandrun('remove line', filedata, i, '')
+            stmt = strippedline[-1] in ';{}'
 
-        if strippedline[-1] in ';{}':
-            stmt = True
-        else:
-            stmt = False
+    def set_elapsed_time(self, elapsed_time):
+        self.__elapsed_time = elapsed_time
 
+    def writefile(self, filedata):
+        self.__writefile(self.__file, filedata)
 
-# reduce..
-print('Make sure error can be reproduced...')
-if not runtool():
-    print("Cannot reproduce")
-    sys.exit(1)
+    def writeorigfile(self, filedata):
+        self.__writefile(self.__origfile, filedata)
 
-f = open(FILE, 'rt')
-filedata = f.readlines()
-f.close()
+    def writebackupfile(self, filedata):
+        self.__writefile(self.__backupfile, filedata)
 
-writefile(BACKUPFILE, filedata)
+    def writetimeoutfile(self, filedata):
+        self.__writefile(self.__timeoutfile, filedata)
 
-while True:
-    filedata1 = list(filedata)
 
-    print('remove comments...')
-    removecomments(filedata)
+def main():
+    # TODO: add --hang option to detect code which impacts the analysis time
+    def show_syntax():
+        print('Syntax:')
+        print('  reduce.py --exe <cppcheck executable> --exe_args <full command> --expected <expected text output> --file <source file> [--segfault]')
+        print('')
+        print("Example. source file = foo/bar.c")
+        print(
+            '  reduce.py --exe ./cppcheck --exe_args " --enable=style" --expected "Variable \'x\' is reassigned" --file foo/bar.c')
+        sys.exit(1)
 
-    print('remove preprocessor directives...')
-    removedirectives(filedata)
+    if len(sys.argv) == 1:
+        show_syntax()
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-exe', '--exe', required=True, help="cppcheck executable")
+    parser.add_argument('-exe_args', '--exe_args', required=False, default="", help="cppcheck executable commands")
+    parser.add_argument('-expected', '--expected', required=True, help="expected text output")
+    parser.add_argument('-file', '--file', required=True, help="source file")
+    parser.add_argument('-segfault', '--segfault', required=False, action='store_true')
+    args = parser.parse_args()
 
-    print('remove blocks...')
-    filedata = removeblocks(filedata)
+    arg_file = args.file
+    arg_cmd = [args.exe] + args.exe_args.split() + [arg_file]
+    arg_expected = args.expected
+    arg_segfault = args.segfault
+    try:
+        reduce = Reduce(arg_cmd, arg_expected, arg_file, arg_segfault)
+    except RuntimeError as e:
+        print(e)
+        show_syntax()
 
-    print('combine lines..')
-    combinelines(filedata)
+    reduce.print_info()
 
-    print('remove line...')
-    removeline(filedata)
+    # reduce..
+    print('Make sure error can be reproduced...')
+    t = time.time()
+    if not reduce.runtool():
+        print("Cannot reproduce")
+        sys.exit(1)
+    elapsed_time = time.time() - t
+    reduce.set_elapsed_time(elapsed_time)
+    print('elapsed_time: {}'.format(elapsed_time))
 
-    # if filedata and filedata2 are identical then stop
-    if len(filedata1) == len(filedata):
-        i = 0
-        while i < len(filedata1):
-            if filedata[i] != filedata1[i]:
-                break
-            i = i + 1
-        if i == len(filedata1):
+    with open(arg_file, 'rt') as f:
+        filedata = f.readlines()
+
+    reduce.writeorigfile(filedata)
+
+    while True:
+        filedata1 = list(filedata)
+
+        print('remove preprocessor directives...')
+        reduce.removedirectives(filedata)
+
+        print('remove blocks...')
+        filedata = reduce.removeblocks(filedata)
+
+        print('remove comments...')
+        reduce.removecomments(filedata)
+
+        print('combine lines..')
+        filedata = reduce.combinelines(filedata)
+
+        print('remove line...')
+        reduce.removeline(filedata)
+
+        # if filedata and filedata2 are identical then stop
+        if filedata1 == filedata:
             break
 
-writefile(FILE, filedata)
+    reduce.writefile(filedata)
+    print('DONE')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/tools/release-set-version.py b/tools/release-set-version.py
new file mode 100644
index 00000000000..f5052cc9035
--- /dev/null
+++ b/tools/release-set-version.py
@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+#
+# Update Cppcheck version
+#
+# Usage:
+# release: python3 release-set-version.py 2.18.0
+# debug:   python3 release-set-version.py 2.18.99
+
+import glob
+import re
+import subprocess
+import sys
+
+
+def git(args):
+    return subprocess.check_output(['git'] + args).decode('utf-8').strip()
+
+
+def sed(args):
+    return subprocess.check_output(['sed'] + args).decode('utf-8').strip()
+
+
+def egrep(args):
+    try:
+        return subprocess.check_output(['egrep'] + args).decode('utf-8').strip()
+    except Exception:
+        return ''
+
+
+# is there uncommitted changes in folder
+def is_uncommitted_changes():
+    for f in git(['status', '--short']).split('\n'):
+        if not f.startswith('??'):
+            return True
+    return False
+
+
+# get current git branch
+def get_current_branch():
+    return git(['branch', '--show-current'])
+
+
+def set_version(new_version:str):
+    if re.match(r'2[.][0-9][0-9][.][0-9]{1,2}([.][0-9])?', new_version) is None:
+        print(f'Aborting, invalid version {new_version}')
+        return
+
+    v = new_version.split('.')
+
+    if is_uncommitted_changes():
+        print('Aborting, there are uncommitted changes')
+        #return
+
+    is_dev_version = (len(v) == 3 and v[-1] == '99')
+
+    if not is_dev_version:
+        expected_branch = v[0] + '.' + v[1] + '.x'
+        if get_current_branch() != expected_branch:
+            print(f'Aborting, must be executed from {expected_branch} branch')
+            return
+
+    v3 = '.'.join(v[:3])
+
+    cppcheck_version_string = (v[0] + '.' + str(int(v[1])+1) + ' dev') if is_dev_version else new_version
+    cppcheck_version = ','.join((v+['0','0','0','0'])[:4])
+
+    def check_sed(args):
+        file = args[-1]
+        res = re.match(r's/([^/]+)/.*', args[-2])
+        if res is None:
+            raise Exception('Failed to verify sed call argument ' + args[-2])
+        pattern = res.group(1)
+        if len(egrep([pattern, file])) < 4:
+            print(f"WARNING: pattern '{pattern}' not found in file {file}")
+        sed(args)
+
+    check_sed(['-i', '-r', f's/version 2[.][0-9]+([.][0-9]+)*/version {new_version}/', 'cli/main.cpp'])
+    check_sed(['-i', '-r', f's/VERSION 2[.][0-9]+[.]99/VERSION {v3}/', 'CMakeLists.txt']) # version must have 3 parts.
+    check_sed(['-i', '-r', f's/#define CPPCHECK_VERSION_STRING .*/#define CPPCHECK_VERSION_STRING "{cppcheck_version_string}"/', 'lib/version.h'])
+    check_sed(['-i', '-r', f's/#define CPPCHECK_VERSION .*/#define CPPCHECK_VERSION {cppcheck_version}/', 'lib/version.h'])
+    check_sed(['-i', '-r', f's/<[?]define ProductName[ ]*=.*/<?define ProductName = "Cppcheck $(var.Platform) {cppcheck_version_string}" ?>/', 'win_installer/productInfo.wxi'])
+    check_sed(['-i', '-r', f's/<[?]define ProductVersion[ ]*=.*/<?define ProductVersion = "{new_version}" ?>/', 'win_installer/productInfo.wxi'])
+    for g in glob.glob('man/*.md'):
+        check_sed(['-i', '-r', f's/subtitle: Version 2\\.[0-9].*/subtitle: Version {cppcheck_version_string}/', g])
+    print('Versions have been changed.')
+    print('')
+    print('Please double check these results below:')
+    for p in ('[^.0-9]2[.][0-9]+[.][0-9]', '2[.][0-9]+ dev'):
+        for ext in ('cpp', 'h', 'md'):
+            for g in glob.glob(f'*/*.{ext}'):
+                s = egrep([p, g])
+                if s != '':
+                    print(f'{g}: {s}')
+    print('')
+    print("Please double check output of 'git diff'")
+    commit_message = f'bumped version to {new_version}' if is_dev_version else f'{new_version}: Set version'
+    print(f"git commit -a -m {commit_message}")
+
+if len(sys.argv) != 2:
+    print('Syntax: python3 release-set-version.py [version]')
+    sys.exit(1)
+
+set_version(sys.argv[-1])
+
diff --git a/tools/run-coverity.sh b/tools/run-coverity.sh
index 689c24f4e74..0887ab6573c 100644
--- a/tools/run-coverity.sh
+++ b/tools/run-coverity.sh
@@ -1,6 +1,6 @@
 #!/bin/bash
-PATH=$PATH:/home/danielmarjamaki/cov-analysis-linux64-2019.03/bin
-cd /home/danielmarjamaki/cppcheck-devinfo
+PATH=$PATH:/home/danielmarjamaki/cov-analysis-linux64-2021.12.1/bin
+cd /home/danielmarjamaki/cppcheck-devinfo || exit 1
 git pull
 
 echo Analyze
@@ -15,7 +15,7 @@ curl --insecure \
   --form token=e74RRnWR6BVsn5LKdclfcA \
   --form email=daniel.marjamaki@gmail.com \
   --form file=@cppcheck.tgz \
-  --form version=`git log -1 --format=oneline | sed -r 's/([a-f0-9]{7}).*/\1/'` \
+  --form version=$(git log -1 --format=oneline | sed -r 's/([a-f0-9]{7}).*/\1/') \
   --form description="Development" \
   https://scan.coverity.com/builds?project=cppcheck
 
diff --git a/tools/run_more_tests.sh b/tools/run_more_tests.sh
deleted file mode 100755
index e16f50ec20d..00000000000
--- a/tools/run_more_tests.sh
+++ /dev/null
@@ -1,98 +0,0 @@
-#!/bin/bash
-# Script Used by generate_and_run_more_tests.sh
-
-set -e
-
-python tools/extracttests.py --code=test1 $1
-
-cd test1
-
-../cppcheck -q --template=cppcheck1 . 2> 1.txt
-
-
-# (!x) => (x==0)
-sed  -ri 's/([(&][ ]*)\!([a-z]+)([ ]*[&)])/\1\2==0\3/' *.cpp
-../cppcheck -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
-
-# (x==0) => (0==x)
-sed  -ri 's/([(&][ ]*)([a-z]+)[ ]*==[ ]*0([ ]*[&)])/\10==\2\3/' *.cpp
-../cppcheck -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
-
-# (0==x) => (!x)
-sed  -ri 's/([(&][ ]*)0[ ]*==[ ]*([a-z]+)([ ]*[&)])/\1!\2\3/' *.cpp
-../cppcheck -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
-
-
-
-
-# if (x) => (x!=0)
-sed  -ri 's/(if[ ]*\([ ]*[a-z]+)([ ]*[&)])/\1!=0\2/' *.cpp
-../cppcheck -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
-
-# while (x) => (x!=0)
-sed  -ri 's/(while[ ]*\([ ]*[a-z]+)([ ]*[&)])/\1!=0\2/' *.cpp
-../cppcheck -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
-
-# (x!=0) => (0!=x)
-sed  -ri 's/([(&][ ]*)([a-z]+)[ ]*!=[ ]*0([ ]*[&)])/\10!=\2\3/' *.cpp
-../cppcheck -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
-
-# (0!=x) => (x)
-sed  -ri 's/([(&][ ]*)0[ ]*!=[ ]*([a-z]+[ ]*[&)])/\1\2/' *.cpp
-../cppcheck -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
-
-
-# (x < 0) => (0 > x)
-sed  -ri 's/([(&][ ]*)([a-z]+)[ ]*<[ ]*(\-?[0-9]+)([ ]*[&)])/\1\3>\2\4/' *.cpp
-../cppcheck -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
-
-# (x <= 0) => (0 >= x)
-sed  -ri 's/([(&][ ]*)([a-z]+)[ ]*<=[ ]*(\-?[0-9]+)([ ]*[&)])/\1\3>=\2\4/' *.cpp
-../cppcheck -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
-
-# (x > 0) => (0 < x)
-sed  -ri 's/([(&][ ]*)([a-z]+)[ ]*<=[ ]*(\-?[0-9]+)([ ]*[&)])/\1\3>=\2\4/' *.cpp
-../cppcheck -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
-
-# (x >= 0) => (0 <= x)
-sed  -ri 's/([(&][ ]*)([a-z]+)[ ]*<=[ ]*(\-?[0-9]+)([ ]*[&)])/\1\3>=\2\4/' *.cpp
-../cppcheck -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
-
-# (x == 123) => (123 == x)
-sed  -ri 's/([(&][ ]*)([a-z]+)[ ]*==[ ]*(\-?[0-9]+)([ ]*[&)])/\1\3==\2\4/' *.cpp
-../cppcheck -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
-
-# (x != 123) => (123 != x)
-sed  -ri 's/([(&][ ]*)([a-z]+)[ ]*\!=[ ]*(\-?[0-9]+)([ ]*[&)])/\1\3!=\2\4/' *.cpp
-../cppcheck -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
-
-
-
-# (0 < x) => (x > 0)
-sed  -ri 's/([(&][ ]*)(\-?[0-9]+)[ ]*<[ ]*([a-z]+)([ ]*[&)])/\1\3>\2\4/' *.cpp
-../cppcheck -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
-
-# (0 <= x) => (x >= 0)
-sed  -ri 's/([(&][ ]*)(\-?[0-9]+)[ ]*<=[ ]*([a-z]+)([ ]*[&)])/\1\3>=\2\4/' *.cpp
-../cppcheck -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
-
-# (0 > x) => (x < 0)
-sed  -ri 's/([(&][ ]*)(\-?[0-9]+)[ ]*<=[ ]*([a-z]+)([ ]*[&)])/\1\3>=\2\4/' *.cpp
-../cppcheck -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
-
-# (0 >= x) => (x <= 0)
-sed  -ri 's/([(&][ ]*)(\-?[0-9]+)[ ]*<=[ ]*([a-z]+)([ ]*[&)])/\1\3>=\2\4/' *.cpp
-../cppcheck -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
-
-# (123 == x) => (x == 123)
-sed  -ri 's/([(&][ ]*)(\-?[0-9]+)[ ]*==[ ]*([a-z]+)([ ]*[&)])/\1\3==\2\4/' *.cpp
-../cppcheck -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
-
-# (123 != x) => (x <= 123)
-sed  -ri 's/([(&][ ]*)(\-?[0-9]+)[ ]*\!=[ ]*([a-z]+)([ ]*[&)])/\1\3!=\2\4/' *.cpp
-../cppcheck -q --template=cppcheck1 . 2> 2.txt && diff 1.txt 2.txt
-
-
-cd ..
-
-rm -rf test1
diff --git a/tools/test-my-pr.py b/tools/test-my-pr.py
new file mode 100755
index 00000000000..4a40f544ee1
--- /dev/null
+++ b/tools/test-my-pr.py
@@ -0,0 +1,225 @@
+#!/usr/bin/env python3
+
+# Run this script from your branch with proposed Cppcheck patch to verify your
+# patch against current main. It will compare output of testing a bunch of
+# opensource packages
+# If running on Windows, make sure that git.exe, wget.exe, and MSBuild.exe are available in PATH
+
+import donate_cpu_lib as lib
+import argparse
+import glob
+import os
+import sys
+import random
+import subprocess
+
+
+def format_float(a, b=1):
+    if a > 0 and b > 0:
+        return '{:.2f}'.format(a / b)
+    return 'N/A'
+
+
+if __name__ == "__main__":
+    __my_script_name = os.path.splitext(os.path.basename(sys.argv[0]))[0]
+    __work_path = os.path.expanduser(os.path.join('~', 'cppcheck-' + __my_script_name + '-workfolder'))
+
+    parser = argparse.ArgumentParser(description='Run this script from your branch with proposed Cppcheck patch to verify your patch against current main. It will compare output of testing bunch of opensource packages')
+    parser.add_argument('-j', default=1, type=int, help='Concurency execution threads')
+    package_group = parser.add_mutually_exclusive_group()
+    package_group.add_argument('-p', default=256, type=int, help='Count of packages to check')
+    package_group.add_argument('--packages', nargs='+', help='Check specific packages and then stop.')
+    package_group.add_argument('--packages-path', default=None, type=str, help='Check packages in path.')
+    parser.add_argument('-o', default='my_check_diff.log', help='Filename of result inside a working path dir')
+
+    language_group = parser.add_mutually_exclusive_group()
+    language_group.add_argument('--c-only', dest='c_only', help='Only process c packages', action='store_true')
+    language_group.add_argument('--cpp-only', dest='cpp_only', help='Only process c++ packages', action='store_true')
+    parser.add_argument('--work-path', '--work-path=', default=__work_path, type=str, help='Working directory for reference repo')
+    args = parser.parse_args()
+
+    print(args)
+
+    if not lib.check_requirements():
+        print("Error: Check requirements")
+        sys.exit(1)
+
+    work_path = os.path.abspath(args.work_path)
+    if not os.path.exists(work_path):
+        os.makedirs(work_path)
+    repo_dir = os.path.join(work_path, 'repo')
+    old_repo_dir = os.path.join(work_path, 'cppcheck')
+    main_dir = os.path.join(work_path, 'tree-main')
+
+    lib.set_jobs('-j' + str(args.j))
+    result_file = os.path.abspath(os.path.join(work_path, args.o))
+    (f, ext) = os.path.splitext(result_file)
+    timing_file = f + '_timing' + ext
+    your_repo_dir = os.path.dirname(os.path.dirname(os.path.abspath(sys.argv[0])))
+
+    if os.path.exists(result_file):
+        os.remove(result_file)
+    if os.path.exists(timing_file):
+        os.remove(timing_file)
+
+    try:
+        lib.clone_cppcheck(repo_dir, old_repo_dir)
+    except Exception as e:
+        print('Failed to clone Cppcheck repository ({}), retry later'.format(e))
+        sys.exit(1)
+
+    try:
+        lib.checkout_cppcheck_version(repo_dir, 'main', main_dir)
+    except Exception as e:
+        print('Failed to checkout main ({}), retry later'.format(e))
+        sys.exit(1)
+
+    try:
+        commit_id = (subprocess.check_output(['git', 'merge-base', 'origin/main', 'HEAD'], cwd=your_repo_dir)).strip().decode('ascii')
+        with open(result_file, 'a') as myfile:
+            myfile.write('Common ancestor: ' + commit_id + '\n\n')
+        package_width = '140'
+        timing_width = '>7'
+        with open(timing_file, 'a') as myfile:
+            myfile.write('{:{package_width}} {:{timing_width}} {:{timing_width}} {:{timing_width}}\n'.format(
+                'Package', 'main', 'your', 'Factor', package_width=package_width, timing_width=timing_width))
+
+        subprocess.check_call(['git', 'fetch', '--depth=1', 'origin', commit_id])
+        subprocess.check_call(['git', 'checkout', '-f', commit_id])
+    except BaseException as e:
+        print('Error: {}'.format(e))
+        print('Failed to switch to common ancestor of your branch and main')
+        sys.exit(1)
+
+    if not lib.compile_cppcheck(main_dir):
+        print('Failed to compile main of Cppcheck')
+        sys.exit(1)
+
+    print('Testing your PR from directory: ' + your_repo_dir)
+    if not lib.compile_cppcheck(your_repo_dir):
+        print('Failed to compile your version of Cppcheck')
+        sys.exit(1)
+
+    if args.packages_path:
+        # You can download packages using daca2-download.py
+        args.packages = glob.glob(os.path.join(args.packages_path, '*.tar.xz'))
+        args.p = len(args.packages)
+        packages_idxs = list(range(args.p))
+        random.shuffle(packages_idxs)
+    elif args.packages:
+        args.p = len(args.packages)
+        packages_idxs = []
+    else:
+        packages_count = lib.get_packages_count()
+        if not packages_count:
+            print("network or server might be temporarily down..")
+            sys.exit(1)
+
+        packages_idxs = list(range(packages_count))
+        random.shuffle(packages_idxs)
+
+    packages_processed = 0
+    crashes = []
+    timeouts = []
+
+    while (packages_processed < args.p and len(packages_idxs) > 0) or args.packages:
+        if args.packages:
+            package = args.packages.pop()
+        else:
+            package = lib.get_package(packages_idxs.pop())
+
+        if package.startswith('ftp://') or package.startswith('http://'):
+            tgz = lib.download_package(work_path, package, None)
+            if tgz is None:
+                print("No package downloaded")
+                continue
+        else:
+            print('Package: ' + package)
+            tgz = package
+
+        source_path, source_found = lib.unpack_package(work_path, tgz, c_only=args.c_only, cpp_only=args.cpp_only)
+        if not source_found:
+            print("No files to process")
+            continue
+
+        results_to_diff = []
+
+        main_crashed = False
+        your_crashed = False
+
+        main_timeout = False
+        your_timeout = False
+
+        libraries = lib.library_includes.get_libraries(source_path)
+        c, errout, info, time_main, cppcheck_options, timing_info = lib.scan_package(main_dir, source_path, libraries)
+        if c < 0:
+            if c == -101 and 'error: could not find or open any of the paths given.' in errout:
+                # No sourcefile found (for example only headers present)
+                print('Error: 101')
+            elif c == lib.RETURN_CODE_TIMEOUT:
+                print('Main timed out!')
+                main_timeout = True
+            else:
+                print('Main crashed!')
+                main_crashed = True
+        results_to_diff.append(errout)
+
+        c, errout, info, time_your, cppcheck_options, timing_info = lib.scan_package(your_repo_dir, source_path, libraries)
+        if c < 0:
+            if c == -101 and 'error: could not find or open any of the paths given.' in errout:
+                # No sourcefile found (for example only headers present)
+                print('Error: 101')
+            elif c == lib.RETURN_CODE_TIMEOUT:
+                print('Your code timed out!')
+                your_timeout = True
+            else:
+                print('Your code crashed!')
+                your_crashed = True
+        results_to_diff.append(errout)
+
+        if main_crashed or your_crashed:
+            who = None
+            if main_crashed and your_crashed:
+                who = 'Both'
+            elif main_crashed:
+                who = 'Main'
+            else:
+                who = 'Your'
+            crashes.append(package + ' ' + who)
+
+        if main_timeout or your_timeout:
+            who = None
+            if main_timeout and your_timeout:
+                who = 'Both'
+            elif main_timeout:
+                who = 'Main'
+            else:
+                who = 'Your'
+            timeouts.append(package + ' ' + who)
+
+        with open(result_file, 'a') as myfile:
+            myfile.write(package + '\n')
+            diff = lib.diff_results('main', results_to_diff[0], 'your', results_to_diff[1])
+            if not main_crashed and not your_crashed and diff != '':
+                myfile.write('libraries:' + ','.join(libraries) +'\n')
+                myfile.write('diff:\n' + diff + '\n')
+
+        if not main_crashed and not your_crashed:
+            with open(timing_file, 'a') as myfile:
+                myfile.write('{:{package_width}} {:{timing_width}} {:{timing_width}} {:{timing_width}}\n'.format(
+                    package, format_float(time_main),
+                    format_float(time_your), format_float(time_your, time_main),
+                    package_width=package_width, timing_width=timing_width))
+
+        packages_processed += 1
+        print(str(packages_processed) + ' of ' + str(args.p) + ' packages processed\n')
+
+    with open(result_file, 'a') as myfile:
+        myfile.write('\n\ncrashes\n')
+        myfile.write('\n'.join(crashes))
+
+    with open(result_file, 'a') as myfile:
+        myfile.write('\n\ntimeouts\n')
+        myfile.write('\n'.join(timeouts) + '\n')
+
+    print('Result saved to: ' + result_file)
diff --git a/tools/test/run_donate_cpu_client_tests.sh b/tools/test/run_donate_cpu_client_tests.sh
old mode 100644
new mode 100755
index dd0e69b581b..0383bf15ec1
--- a/tools/test/run_donate_cpu_client_tests.sh
+++ b/tools/test/run_donate_cpu_client_tests.sh
@@ -23,7 +23,7 @@ ftp://ftp.se.debian.org/debian/pool/main/0/0xffff/0xffff_0.8.orig.tar.gz
 ftp://ftp.se.debian.org/debian/pool/main/a/actionaz/actionaz_3.8.0.orig.tar.gz
 )
 
-for python_exec in "python" "python3"
+for python_exec in "python3"
 do
     for test_package in "${test_packages[@]}"
     do
diff --git a/tools/test/start_donate_cpu_client_productive.sh b/tools/test/start_donate_cpu_client_productive.sh
old mode 100644
new mode 100755
index 6f46cd4a699..b1f23688622
--- a/tools/test/start_donate_cpu_client_productive.sh
+++ b/tools/test/start_donate_cpu_client_productive.sh
@@ -12,6 +12,6 @@ cppcheck_tools_path=..
 while :
 do
     git pull
-    python "${cppcheck_tools_path}/donate-cpu.py" --bandwidth-limit=1m --max-packages=100
+    "${cppcheck_tools_path}/donate-cpu.py" --bandwidth-limit=1m --max-packages=100
     sleep 10
 done
diff --git a/tools/test/start_donate_cpu_client_test_local.sh b/tools/test/start_donate_cpu_client_test_local.sh
old mode 100644
new mode 100755
index 08d214f6510..79ecb21c0d1
--- a/tools/test/start_donate_cpu_client_test_local.sh
+++ b/tools/test/start_donate_cpu_client_test_local.sh
@@ -4,6 +4,6 @@ cppcheck_tools_path=..
 
 while :
 do
-    python "${cppcheck_tools_path}/donate-cpu.py" --test --bandwidth-limit=2m
+    "${cppcheck_tools_path}/donate-cpu.py" --test --bandwidth-limit=2m
     sleep 2
 done
diff --git a/tools/test/start_donate_cpu_server_test_local.sh b/tools/test/start_donate_cpu_server_test_local.sh
old mode 100644
new mode 100755
index 796c0874585..4bd19555f86
--- a/tools/test/start_donate_cpu_server_test_local.sh
+++ b/tools/test/start_donate_cpu_server_test_local.sh
@@ -22,10 +22,10 @@ fi
 
 if [ ! -f "${dacaathome_path}/packages.txt" ]
 then
-    python "${cppcheck_tools_path}/daca2-getpackages.py" > "${dacaathome_path}/packages.txt"
+    "${cppcheck_tools_path}/daca2-getpackages.py" > "${dacaathome_path}/packages.txt"
 fi
 
 while :
 do
-    python "${cppcheck_tools_path}/donate-cpu-server.py" --test
+    "${cppcheck_tools_path}/donate-cpu-server.py" --test
 done
diff --git a/tools/test_showtimetop5.sh b/tools/test_showtimetop5.sh
deleted file mode 100755
index 02c6aaaf679..00000000000
--- a/tools/test_showtimetop5.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/bin/bash
-if  [[ "$(./cppcheck  --showtime=top5 cli/cmdlineparser.h --language=c++ --quiet | wc -l)" != 7 ]] ; then
-    false
-fi
diff --git a/tools/times-tags.sh b/tools/times-tags.sh
deleted file mode 100755
index 714b95e72e3..00000000000
--- a/tools/times-tags.sh
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/bin/bash
-#
-# Simple script to generate times-tags.log that contains timing information for a range of revisions
-# Typically these commands shall be used to get times.txt:
-#   mkdir src
-#   cp lib/* src/   <- fill src/ with some source code
-#   tools/times-tags.sh
-#   gcc -o tools/times-tags tools/times-tags.c
-#   tools/times-tags
-
-rm times-tags.txt
-
-for i in $(seq $1 $2);
-do
-    echo "1.$i"
-    echo "1.$i" >> times-tags.txt
-    git checkout "1.$i" -b "$i"
-    make clean
-    make -j4 > /dev/null
-    /usr/bin/time -a -o times-tags.txt ./cppcheck sources -q 2> /dev/null
-    git checkout master
-    git branch -D "$i"
-done
diff --git a/tools/times-vs.py b/tools/times-vs.py
deleted file mode 100644
index fc0df091a65..00000000000
--- a/tools/times-vs.py
+++ /dev/null
@@ -1,58 +0,0 @@
-#!/usr/bin/env python3
-# Times script using Visual Studio compiler in Windows
-#
-# This script assumes that you have:
-# Python 3
-# Visual Studio (script assumes VS2013, manipulate the sed command otherwise)
-# Cygwin64 for the sed command
-# Command line svn. TortoiseSVN with that feature selected works.
-#
-# Usage:
-# Open VS command prompt.
-# cd c:\users\...
-# svn checkout https://github.com/danmar/cppcheck/trunk cppcheck-svn
-# cd cppcheck-svn
-# c:\python34\python.exe times-vs.py rev1:rev2
-
-
-import subprocess
-import glob
-import re
-import sys
-
-if len(sys.argv) != 2:
-    print('revisions not specified')
-    sys.exit(1)
-
-res = re.match(r'([0-9]+):([0-9]+)', sys.argv[1])
-if res is None:
-    print('invalid format, 11111:22222')
-    sys.exit(1)
-
-rev1 = int(res.group(1))
-rev2 = int(res.group(2))
-
-if rev1 > rev2 or rev1 < 10000 or rev2 > 20000 or rev2 - rev1 > 500:
-    print('range, aborting')
-    sys.exit(1)
-
-print('Revisions: ' + str(rev1) + ':' + str(rev2))
-
-f = open('results.txt', 'wt')
-f.write('\n')
-f.close()
-
-for rev in range(rev1, rev2):
-    subprocess.call(['svn', 'revert', '-R',  '.'])
-    subprocess.call(['svn', 'up', '-r' + str(rev)])
-    for vcxproj in glob.glob('*/*.vcxproj'):
-        subprocess.call([r'c:\cygwin64\bin\sed.exe', '-i', 's/140/120/', vcxproj])
-    subprocess.call('msbuild cppcheck.sln /t:build /p:configuration=Release,platform=x64'.split())
-    print('Revision:' + str(rev))
-    p = subprocess.Popen(r'bin\cppcheck.exe src -q --showtime=summary'.split(),
-                         stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    comm = p.communicate()
-    f = open('results.txt', 'at')
-    f.write('\nREV ' + str(rev) + '\n')
-    f.write(comm[0].decode('utf-8'))
-    f.close()
diff --git a/tools/times.c b/tools/times.c
deleted file mode 100644
index 446227dce48..00000000000
--- a/tools/times.c
+++ /dev/null
@@ -1,47 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-static void revncpy(char *dst, const char *src, size_t len)
-{
-    int n = 0;
-    while (n++<len && *src && *src!=' ' && *src!='\r' && *src!='\n')
-        *dst++ = *src++;
-}
-
-int main()
-{
-    FILE *f = fopen("times.log", "rt");
-    if (!f)
-        return 1;
-
-    char lines[0xffff][64] = {0};
-
-    int n = 0;
-    float mintime=0.0f, maxtime=0.0f;
-    char rev[10] = {0};
-    char line[128] = {0};
-
-    while (fgets(line,sizeof(line),f) && n < (sizeof(lines)/sizeof(*lines))) {
-        if (strncmp(line,"HEAD is now at ", 15) == 0) {
-            if (rev[0])
-                sprintf(lines[n++],"%s\t%.1f\t%.1f", rev, mintime, maxtime);
-            revncpy(rev, line+15, sizeof(rev)-1);
-            mintime = 0.0f;
-            maxtime = 0.0f;
-        }
-        if (strncmp(line,"Overall time:",13)==0) {
-            float time = atof(line+14);
-            if (mintime < 0.1f || time < mintime)
-                mintime = time;
-            if (time > maxtime)
-                maxtime = time;
-        }
-    }
-
-    while (n > 0)
-        printf("%s\n", lines[--n]);
-
-    fclose(f);
-    return 0;
-}
diff --git a/tools/times.sh b/tools/times.sh
deleted file mode 100755
index e5e98da6325..00000000000
--- a/tools/times.sh
+++ /dev/null
@@ -1,31 +0,0 @@
-#!/bin/bash
-#
-# Simple script to generate times.log that contains timing information for the last <n> revisions
-# Typically these commands shall be used to get times.txt:
-mkdir -p src  || exit 1
-cp lib/* src/ || exit 2  # fill src/ with some source code
-#NOTE: also try with some files other then from cppcheck!
-
-iterations=4
-
-# if "old" already exists for some reason, do NOT work on current branch but bail out
-git checkout -b old || exit
-
-make clean
-
-git reset --hard HEAD > times.log
-
-for i in $(seq 1 50); do
-    git_head=$(git log -1 --format=%h)
-    # if build fails, make clean and try again
-    make SRCDIR=build CXXFLAGS=-O2 -j4 || make clean ; make MATCHCOMPILER=yes CXXFLAGS=-O2 -j4
-    echo "Run number $i"
-    for j in $(seq 1 ${iterations}); do
-        ./cppcheck --quiet --showtime=summary --enable=all --inconclusive src 2> /dev/null | tee -a times.log
-    done
-    grep "Overall" times.log | tail -${iterations} | sed s/s// | awk -v "i=$i" -v "iterations=$iterations" -v "git_head=$git_head"  '{ sum+=$3} END {print "Run " i",  "git_head  "  Average: " sum/iterations}' | tee -a times.log
-    git reset --hard HEAD^1 | tee -a times.log
-done
-
-gcc -o tools/times tools/times.c
-tools/times
diff --git a/tools/trac-keywords.py b/tools/trac-keywords.py
index 9449bc2a44e..7a8f9473517 100644
--- a/tools/trac-keywords.py
+++ b/tools/trac-keywords.py
@@ -6,11 +6,11 @@
 
 
 def readdb():
-    global TRACDB
     cmds = ['sqlite3', TRACDB, 'SELECT id,keywords FROM ticket WHERE status<>"closed";']
-    p = subprocess.Popen(cmds, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    comm = p.communicate()
-    data = comm[0]
+    with subprocess.Popen(cmds, stdout=subprocess.PIPE, stderr=subprocess.PIPE) as p:
+        # TODO: handle p.returncode?
+        stdout, _ = p.communicate()
+    data = stdout
     ret = {}
     for line in data.splitlines():
         pos1 = line.find('|')
@@ -25,9 +25,9 @@ def readdb():
             ret[kw].append(nr)
     return ret
 
+
 for arg in sys.argv[1:]:
     if arg.endswith('/trac.db'):
-        global TRACDB
         TRACDB = arg
 
 data = readdb()
diff --git a/tools/triage/.clang-tidy b/tools/triage/.clang-tidy
new file mode 100644
index 00000000000..8a62240d85a
--- /dev/null
+++ b/tools/triage/.clang-tidy
@@ -0,0 +1,5 @@
+---
+Checks: >
+        -readability-convert-member-functions-to-static,
+        -readability-redundant-access-specifiers
+InheritParentConfig: true
diff --git a/tools/triage/CMakeLists.txt b/tools/triage/CMakeLists.txt
index 7721d03a7f3..d0f9fce1599 100644
--- a/tools/triage/CMakeLists.txt
+++ b/tools/triage/CMakeLists.txt
@@ -1,18 +1,19 @@
-if (BUILD_GUI AND BUILD_TESTS)
-    set(CMAKE_AUTOMOC ON)
-    if (${CMAKE_BUILD_TYPE} STREQUAL "Release")
-        add_definitions(-DQT_NO_DEBUG)
-        add_definitions(-DQT_NO_DEBUG_OUTPUT)
-        add_definitions(-DQT_NO_WARNING_OUTPUT)
-    else()
-        add_definitions(-DQT_DEBUG)
-    endif()
+if (BUILD_GUI AND BUILD_TRIAGE)
+    # disable all clang-tidy checks for Qt generated files
+    file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/.clang-tidy"
+"---
+Checks:          '-*,misc-definitions-in-headers'
+WarningsAsErrors: '*'
+CheckOptions:
+  - { key: HeaderFileExtensions,          value: 'x' }
+")
 
     file(GLOB hdrs "*.h")
     file(GLOB srcs "*.cpp")
     file(GLOB uis  "*.ui")
-    qt5_wrap_ui(uis_hdrs ${uis})
+    qt_wrap_ui(uis_hdrs ${uis})
 
+    add_custom_target(triage-build-ui-deps SOURCES ${hdrs} ${uis_hdrs})
     add_executable(
         triage
         ${hdrs}
@@ -20,8 +21,28 @@ if (BUILD_GUI AND BUILD_TESTS)
         ${uis_hdrs}
         ${PROJECT_SOURCE_DIR}/gui/codeeditorstyle.cpp
         ${PROJECT_SOURCE_DIR}/gui/codeeditor.cpp)
-    target_include_directories(triage PUBLIC ${PROJECT_SOURCE_DIR}/gui/)
-    target_link_libraries(triage Qt5::Core Qt5::Gui Qt5::Widgets)
+    set_target_properties(triage PROPERTIES AUTOMOC ON)
+    set_target_properties(triage PROPERTIES WIN32_EXECUTABLE ON)
+    target_include_directories(triage PRIVATE ${PROJECT_SOURCE_DIR}/lib/ ${PROJECT_SOURCE_DIR}/gui/)
+    target_link_libraries(triage ${QT_CORE_LIB} ${QT_GUI_LIB} ${QT_WIDGETS_LIB})
+    if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        if(QT_VERSION VERSION_LESS "6.4.0")
+            # caused by Qt generated moc code - see https://bugreports.qt.io/browse/QTBUG-100915
+            target_compile_options_safe(triage -Wno-redundant-parens)
+        endif()
+    endif()
+    if(QT_VERSION VERSION_GREATER_EQUAL "6.9.0")
+        # QBrush fails to compile before 6.9.0 - see https://bugreports.qt.io/browse/QTBUG-134038
+        target_compile_definitions(triage PRIVATE -DQT_NO_QPAIR)
+    endif()
+    if(QT_VERSION VERSION_GREATER_EQUAL "6.9.0")
+        # caused by Qt generated moc code starting with 6.9.0 - see https://bugreports.qt.io/browse/QTBUG-135638
+        target_compile_options_safe(triage -Wno-ctad-maybe-unsupported)
+    endif()
+    target_compile_definitions(triage PRIVATE -DQT_NO_FOREACH)
 
-    set(CMAKE_AUTOMOC OFF)
+    target_compile_definitions(triage PRIVATE $<$<NOT:$<CONFIG:Debug>>:QT_NO_DEBUG>)
+    target_compile_definitions(triage PRIVATE $<$<NOT:$<CONFIG:Debug>>:QT_NO_DEBUG_OUTPUT>)
+    target_compile_definitions(triage PRIVATE $<$<NOT:$<CONFIG:Debug>>:QT_NO_WARNING_OUTPUT>)
+    target_compile_definitions(triage PRIVATE $<$<CONFIG:Debug>:QT_DEBUG>)
 endif()
diff --git a/tools/triage/main.cpp b/tools/triage/main.cpp
index a37d92c6878..89564a19b2c 100644
--- a/tools/triage/main.cpp
+++ b/tools/triage/main.cpp
@@ -1,4 +1,23 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2021 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #include "mainwindow.h"
+
 #include <QApplication>
 
 int main(int argc, char *argv[])
diff --git a/tools/triage/mainwindow.cpp b/tools/triage/mainwindow.cpp
index 944a274ce40..564d6e1bcf2 100644
--- a/tools/triage/mainwindow.cpp
+++ b/tools/triage/mainwindow.cpp
@@ -1,30 +1,104 @@
+/*
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2021 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #include "mainwindow.h"
+
+#include "codeeditor.h"
+
 #include "ui_mainwindow.h"
+
+#include <algorithm>
+#include <cstdlib>
+#include <ctime>
+#include <random>
+
+#include <QAction>
+#include <QApplication>
+#include <QByteArray>
+#include <QCheckBox>
 #include <QClipboard>
-#include <QProcess>
-#include <QFile>
-#include <QTextStream>
+#include <QComboBox>
+#include <QCoreApplication>
 #include <QDir>
-#include <QFileInfo>
+#include <QDirIterator>
+#include <QFile>
 #include <QFileDialog>
-#include <ctime>
-#include <cstdlib>
+#include <QFileInfo>
+#include <QFlags>
+#include <QHeaderView>
+#include <QIODevice>
+#include <QLineEdit>
+#include <QList>
+#include <QListWidget>
+#include <QListWidgetItem>
+#include <QMenu>
+#include <QMimeDatabase>
+#include <QMimeType>
+#include <QProcess>
+#include <QProgressDialog>
+#include <QRegularExpression>
+#include <QStatusBar>
+#include <QStringLiteral>
+#include <QTabWidget>
+#include <QTextStream>
+#include <QTreeView>
+#include <QtCore>
+#if (QT_VERSION >= QT_VERSION_CHECK(6, 5, 0))
+#include <QtLogging>
+#endif
 
-const QString WORK_FOLDER(QDir::homePath() + "/triage");
-const QString DACA2_PACKAGES(QDir::homePath() + "/daca2-packages");
+class QWidget;
 
-const int MAX_ERRORS = 100;
+static const QString WORK_FOLDER(QDir::homePath() + "/triage");
+static const QString DACA2_PACKAGES(QDir::homePath() + "/daca2-packages");
+
+static constexpr int MAX_ERRORS = 100;
 
 MainWindow::MainWindow(QWidget *parent) :
     QMainWindow(parent),
-    ui(new Ui::MainWindow)
+    ui(new Ui::MainWindow),
+    mVersionRe("^(master|main|your|head|[12].[0-9][0-9]?) (.*)$"),
+    hFiles{"*.hpp", "*.h", "*.hxx", "*.hh", "*.tpp", "*.txx", "*.ipp", "*.ixx"},
+    srcFiles{"*.cpp", "*.cxx", "*.cc", "*.c++", "*.C", "*.c", "*.cl"}
 {
     ui->setupUi(this);
-    std::srand(static_cast<unsigned int>(std::time(Q_NULLPTR)));
+    // NOLINTNEXTLINE(bugprone-random-generator-seed) - the random numbers are not used in a security context so this should be sufficient
+    std::srand(static_cast<unsigned int>(std::time(nullptr)));
     QDir workFolder(WORK_FOLDER);
     if (!workFolder.exists()) {
-        workFolder.mkdir(WORK_FOLDER);
+        (void)workFolder.mkdir(WORK_FOLDER);
     }
+
+    ui->results->setContextMenuPolicy(Qt::CustomContextMenu);
+    connect(ui->results, &QListWidget::customContextMenuRequested,
+            this, &MainWindow::resultsContextMenu);
+
+    mFSmodel.setRootPath(WORK_FOLDER);
+    mFSmodel.setReadOnly(true);
+    mFSmodel.setFilter(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot);
+    ui->directoryTree->setModel(&mFSmodel);
+    QHeaderView * header =  ui->directoryTree->header();
+    for (int i = 1; i < header->length(); ++i)  // hide all except [0]
+        header->hideSection(i);
+    ui->directoryTree->setRootIndex(mFSmodel.index(WORK_FOLDER));
+
+    ui->hFilesFilter->setToolTip(hFiles.join(','));
+    ui->srcFilesFilter->setToolTip(srcFiles.join(','));
 }
 
 MainWindow::~MainWindow()
@@ -35,11 +109,11 @@ MainWindow::~MainWindow()
 void MainWindow::loadFile()
 {
     ui->statusBar->clearMessage();
-    const QString fileName = QFileDialog::getOpenFileName(this, tr("daca results file"), WORK_FOLDER, tr("Text files (*.txt);;All (*.*)"));
+    const QString fileName = QFileDialog::getOpenFileName(this, tr("daca results file"), WORK_FOLDER, tr("Text files (*.txt *.log);;All (*.*)"));
     if (fileName.isEmpty())
         return;
     QFile file(fileName);
-    file.open(QIODevice::ReadOnly | QIODevice::Text);
+    (void)file.open(QIODevice::ReadOnly | QIODevice::Text); // TODO: check result
     QTextStream textStream(&file);
     load(textStream);
 }
@@ -54,6 +128,7 @@ void MainWindow::loadFromClipboard()
 
 void MainWindow::load(QTextStream &textStream)
 {
+    bool local = false;
     QString url;
     QString errorMessage;
     QStringList versions;
@@ -62,16 +137,23 @@ void MainWindow::load(QTextStream &textStream)
         QString line = textStream.readLine();
         if (line.isNull())
             break;
-        if (line.startsWith("ftp://")) {
+        if (line.startsWith("ftp://") || (line.startsWith(DACA2_PACKAGES) && line.endsWith(".tar.xz"))) {
+            local = line.startsWith(DACA2_PACKAGES) && line.endsWith(".tar.xz");
             url = line;
             if (!errorMessage.isEmpty())
                 mAllErrors << errorMessage;
             errorMessage.clear();
-        } else if (!url.isEmpty() && QRegExp(".*: (error|warning|style|note):.*").exactMatch(line)) {
-            if (QRegExp("^(head|1.[0-9][0-9]) .*").exactMatch(line)) {
-                const QString version = line.mid(0,4);
-                if (versions.indexOf(version) < 0)
-                    versions << version;
+        } else if (!url.isEmpty()) {
+            static const QRegularExpression severityRe("^.*: (error|warning|style|note):.*$");
+            if (!severityRe.match(line).hasMatch())
+                continue;
+            if (!local) {
+                const QRegularExpressionMatch matchRes = mVersionRe.match(line);
+                if (matchRes.hasMatch()) {
+                    const QString version = matchRes.captured(1);
+                    if (versions.indexOf(version) < 0)
+                        versions << version;
+                }
             }
             if (line.indexOf(": note:") > 0)
                 errorMessage += '\n' + line;
@@ -99,7 +181,7 @@ void MainWindow::refreshResults()
     filter(ui->version->currentText());
 }
 
-void MainWindow::filter(QString filter)
+void MainWindow::filter(const QString& filter)
 {
     QStringList allErrors;
 
@@ -125,8 +207,8 @@ void MainWindow::filter(QString filter)
             if (allErrors[i].indexOf("test") > 0)
                 allErrors.removeAt(i);
         }
-        std::random_shuffle(allErrors.begin(), allErrors.end());
-        ui->results->addItems(allErrors.mid(0,MAX_ERRORS));
+        std::shuffle(allErrors.begin(), allErrors.end(), std::mt19937(std::random_device()()));
+        ui->results->addItems(allErrors.mid(0, MAX_ERRORS));
         ui->results->sortItems();
     } else {
         ui->results->addItems(allErrors);
@@ -135,17 +217,36 @@ void MainWindow::filter(QString filter)
 
 bool MainWindow::runProcess(const QString &programName, const QStringList &arguments)
 {
+    QProgressDialog dialog("Running external process: " + programName, "Kill", 0 /*min*/, 1 /*max*/, this);
+    dialog.setWindowModality(Qt::WindowModal);
+    dialog.setMinimumDuration(0 /*msec*/);
+    dialog.setValue(0);
+
     QProcess process;
     process.setWorkingDirectory(WORK_FOLDER);
-    process.start(programName, arguments);
-    bool success = process.waitForFinished(-1);
+    process.start(programName, arguments);  // async action
+
+    bool success = false;
+    bool state = (QProcess::Running == process.state() || QProcess::Starting == process.state());
+    while (!success && state) {
+        success = process.waitForFinished(50 /*msec*/);
+        // Not the best way to keep UI unfreeze, keep work async in other thread much more a Qt style
+        QCoreApplication::processEvents();
+        if (dialog.wasCanceled()) {
+            process.kill();
+            success = false;
+            break;
+        }
+        state = (QProcess::Running == process.state() || QProcess::Starting == process.state());
+    }
+    dialog.setValue(1);
     if (!success) {
         QString errorstr(programName);
         errorstr.append(": ");
         errorstr.append(process.errorString());
         ui->statusBar->showMessage(errorstr);
     } else {
-        int exitCode = process.exitCode();
+        const int exitCode = process.exitCode();
         if (exitCode != 0) {
             success = false;
             const QByteArray stderrOutput = process.readAllStandardError();
@@ -160,7 +261,7 @@ bool MainWindow::runProcess(const QString &programName, const QStringList &argum
 
 bool MainWindow::wget(const QString &url)
 {
-    return runProcess("wget", QStringList() << url);
+    return runProcess("wget", QStringList{url});
 }
 
 bool MainWindow::unpackArchive(const QString &archiveName)
@@ -191,36 +292,46 @@ bool MainWindow::unpackArchive(const QString &archiveName)
 void MainWindow::showResult(QListWidgetItem *item)
 {
     ui->statusBar->clearMessage();
-    if (!item->text().startsWith("ftp://"))
+    const bool local = item->text().startsWith(DACA2_PACKAGES);
+    if (!item->text().startsWith("ftp://") && !local)
         return;
     const QStringList lines = item->text().split("\n");
     if (lines.size() < 2)
         return;
-    const QString url = lines[0];
+    const QString &url = lines[0];
     QString msg = lines[1];
-    if (QRegExp("^(head|1.[0-9][0-9]) .*").exactMatch(msg))
-        msg = msg.mid(5);
+    if (!local) {
+        const QRegularExpressionMatch matchRes = mVersionRe.match(msg);
+        if (matchRes.hasMatch())
+            msg = matchRes.captured(2);
+    }
     const QString archiveName = url.mid(url.lastIndexOf("/") + 1);
     const int pos1 = msg.indexOf(":");
     const int pos2 = msg.indexOf(":", pos1+1);
     const QString fileName = WORK_FOLDER + '/' + msg.left(msg.indexOf(":"));
-    const int lineNumber = msg.midRef(pos1+1,pos2-pos1-1).toInt();
+    const int lineNumber = msg.mid(pos1+1, pos2-pos1-1).toInt();
 
     if (!QFileInfo::exists(fileName)) {
-        if (QFileInfo::exists(DACA2_PACKAGES + '/' + archiveName.mid(0,archiveName.indexOf(".tar.")) + ".tar.xz")) {
-            if (!unpackArchive(DACA2_PACKAGES + '/' + archiveName.mid(0,archiveName.indexOf(".tar.")) + ".tar.xz"))
+        const QString daca2archiveFile {DACA2_PACKAGES + '/' + archiveName.mid(0,archiveName.indexOf(".tar.")) + ".tar.xz"};
+        if (QFileInfo::exists(daca2archiveFile)) {
+            if (!unpackArchive(daca2archiveFile))
                 return;
-        } else {
-            if (!QFileInfo::exists(WORK_FOLDER + '/' + archiveName)) {
+        } else if (!local) {
+            const QString archiveFullPath {WORK_FOLDER + '/' + archiveName};
+            if (!QFileInfo::exists(archiveFullPath)) {
                 // Download archive
                 if (!wget(url))
                     return;
             }
-            if (!unpackArchive(WORK_FOLDER + '/' + archiveName))
+            if (!unpackArchive(archiveFullPath))
                 return;
         }
     }
+    showSrcFile(fileName, url, lineNumber);
+}
 
+void MainWindow::showSrcFile(const QString &fileName, const QString &url, const int lineNumber)
+{
     // Open file
     ui->code->setFocus();
     QFile f(fileName);
@@ -232,9 +343,87 @@ void MainWindow::showResult(QListWidgetItem *item)
         QTextStream textStream(&f);
         const QString fileData = textStream.readAll();
         ui->code->setError(fileData, lineNumber, QStringList());
-
-        ui->edit1->setText(url);
-        ui->edit2->setText(fileName);
         f.close();
+
+        ui->urlEdit->setText(url);
+        ui->fileEdit->setText(fileName);
+        ui->directoryTree->setCurrentIndex(mFSmodel.index(fileName));
     }
 }
+
+void MainWindow::fileTreeFilter(const QString &str)
+{
+    mFSmodel.setNameFilters(QStringList{"*" + str + "*"});
+    mFSmodel.setNameFilterDisables(false);
+}
+
+void MainWindow::findInFilesClicked()
+{
+    ui->tabWidget->setCurrentIndex(1);
+    ui->inFilesResult->clear();
+    const QString text = ui->filterEdit->text();
+
+    // cppcheck-suppress shadowFunction - TODO: fix this
+    QStringList filter;
+    if (ui->hFilesFilter->isChecked())
+        filter.append(hFiles);
+    if (ui->srcFilesFilter->isChecked())
+        filter.append(srcFiles);
+
+    QMimeDatabase mimeDatabase;
+    QDirIterator it(WORK_FOLDER, filter, QDir::AllEntries | QDir::NoSymLinks | QDir::NoDotAndDotDot, QDirIterator::Subdirectories);
+
+    const auto common_path_len = WORK_FOLDER.length() + 1;  // let's remove common part of path improve UI
+
+    while (it.hasNext()) {
+        const QString fileName = it.next();
+        const QMimeType mimeType = mimeDatabase.mimeTypeForFile(fileName);
+
+        if (mimeType.isValid() && !mimeType.inherits(QStringLiteral("text/plain"))) {
+            continue;
+        }
+
+        QFile file(fileName);
+        if (file.open(QIODevice::ReadOnly)) {
+            int lineN = 0;
+            QTextStream in(&file);
+            while (!in.atEnd()) {
+                ++lineN;
+                QString line = in.readLine();
+                if (line.contains(text, Qt::CaseInsensitive)) {
+                    ui->inFilesResult->addItem(fileName.mid(common_path_len) + QString{":"} + QString::number(lineN));
+                }
+            }
+        }
+    }
+}
+
+void MainWindow::directorytreeDoubleClick()
+{
+    showSrcFile(mFSmodel.filePath(ui->directoryTree->currentIndex()), "", 1);
+}
+
+void MainWindow::searchResultsDoubleClick()
+{
+    QString filename = ui->inFilesResult->currentItem()->text();
+    const auto idx = filename.lastIndexOf(':');
+    const int line = filename.mid(idx + 1).toInt();
+    showSrcFile(WORK_FOLDER + QString{"/"} + filename.left(idx), "", line);
+}
+
+void MainWindow::resultsContextMenu(const QPoint& pos)
+{
+    if (ui->results->selectedItems().isEmpty())
+        return;
+    QMenu submenu;
+    submenu.addAction("Copy");
+    const QAction* menuItem = submenu.exec(ui->results->mapToGlobal(pos));
+    if (menuItem && menuItem->text().contains("Copy"))
+    {
+        QString text;
+        for (const auto *res: ui->results->selectedItems())
+            text += res->text() + "\n";
+        QApplication::clipboard()->setText(text);
+    }
+}
+
diff --git a/tools/triage/mainwindow.h b/tools/triage/mainwindow.h
index e5209fc5577..999740fb59d 100644
--- a/tools/triage/mainwindow.h
+++ b/tools/triage/mainwindow.h
@@ -1,11 +1,35 @@
+/* -*- C++ -*-
+ * Cppcheck - A tool for static C/C++ code analysis
+ * Copyright (C) 2007-2021 Cppcheck team.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
 #ifndef MAINWINDOW_H
 #define MAINWINDOW_H
 
+#include <QFileSystemModel>
 #include <QMainWindow>
-#include <QListWidgetItem>
+#include <QObject>
+#include <QRegularExpression>
 #include <QString>
-#include <QTextStream>
+#include <QStringList>
 
+class QListWidgetItem;
+class QTextStream;
+class QPoint;
+class QWidget;
 namespace Ui {
     class MainWindow;
 }
@@ -14,17 +38,22 @@ class MainWindow : public QMainWindow {
     Q_OBJECT
 
 public:
-    explicit MainWindow(QWidget *parent = Q_NULLPTR);
+    explicit MainWindow(QWidget *parent = nullptr);
     MainWindow(const MainWindow &) = delete;
-    ~MainWindow();
     MainWindow &operator=(const MainWindow &) = delete;
+    ~MainWindow() override;
 
 public slots:
     void loadFile();
     void loadFromClipboard();
-    void filter(QString filter);
+    void filter(const QString& filter);
     void showResult(QListWidgetItem *item);
     void refreshResults();
+    void fileTreeFilter(const QString &str);
+    void findInFilesClicked();
+    void directorytreeDoubleClick();
+    void searchResultsDoubleClick();
+    void resultsContextMenu(const QPoint& pos);
 
 private:
     Ui::MainWindow *ui;
@@ -33,8 +62,14 @@ public slots:
     bool runProcess(const QString &programName, const QStringList & arguments);
     bool wget(const QString &url);
     bool unpackArchive(const QString &archiveName);
+    void showSrcFile(const QString &fileName, const QString &url, int lineNumber);
 
     QStringList mAllErrors;
+    QFileSystemModel mFSmodel;
+    const QRegularExpression mVersionRe;
+
+    const QStringList hFiles;
+    const QStringList srcFiles;
 };
 
 #endif // MAINWINDOW_H
diff --git a/tools/triage/mainwindow.ui b/tools/triage/mainwindow.ui
index d3bf5ff5234..540c4871793 100644
--- a/tools/triage/mainwindow.ui
+++ b/tools/triage/mainwindow.ui
@@ -7,88 +7,22 @@
     <x>0</x>
     <y>0</y>
     <width>1057</width>
-    <height>538</height>
+    <height>637</height>
    </rect>
   </property>
   <property name="windowTitle">
-   <string>MainWindow</string>
+   <string>daca triage tool</string>
   </property>
   <widget class="QWidget" name="centralWidget">
    <layout class="QHBoxLayout" name="horizontalLayout_2">
+    <property name="spacing">
+     <number>1</number>
+    </property>
     <item>
-     <layout class="QVBoxLayout" name="verticalLayout">
-      <item>
-       <layout class="QHBoxLayout" name="horizontalLayout">
-        <item>
-         <widget class="QPushButton" name="loadFile">
-          <property name="text">
-           <string>Load from file</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QPushButton" name="loadFromClipboard">
-          <property name="text">
-           <string>Load from clipboard</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <spacer name="horizontalSpacer">
-          <property name="orientation">
-           <enum>Qt::Horizontal</enum>
-          </property>
-          <property name="sizeHint" stdset="0">
-           <size>
-            <width>40</width>
-            <height>20</height>
-           </size>
-          </property>
-         </spacer>
-        </item>
-       </layout>
-      </item>
-      <item>
-       <widget class="QListWidget" name="results"/>
-      </item>
-      <item>
-       <widget class="QCheckBox" name="random100">
-        <property name="text">
-         <string>Show 100 random results</string>
-        </property>
-       </widget>
-      </item>
-      <item>
-       <layout class="QHBoxLayout" name="horizontalLayout_3">
-        <item>
-         <widget class="QLabel" name="label_3">
-          <property name="text">
-           <string>Version</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QComboBox" name="version"/>
-        </item>
-        <item>
-         <spacer name="horizontalSpacer_2">
-          <property name="orientation">
-           <enum>Qt::Horizontal</enum>
-          </property>
-          <property name="sizeHint" stdset="0">
-           <size>
-            <width>40</width>
-            <height>20</height>
-           </size>
-          </property>
-         </spacer>
-        </item>
-       </layout>
-      </item>
-     </layout>
-    </item>
-    <item>
-     <layout class="QVBoxLayout" name="verticalLayout_2">
+     <layout class="QVBoxLayout" name="middleLayout">
+      <property name="spacing">
+       <number>1</number>
+      </property>
       <item>
        <widget class="CodeEditor" name="code">
         <property name="readOnly">
@@ -97,26 +31,29 @@
        </widget>
       </item>
       <item>
-       <layout class="QGridLayout" name="gridLayout">
+       <layout class="QGridLayout" name="urlFileLayout">
+        <property name="spacing">
+         <number>1</number>
+        </property>
         <item row="0" column="0">
-         <widget class="QLabel" name="label">
+         <widget class="QLabel" name="urllabel">
           <property name="text">
            <string>url</string>
           </property>
          </widget>
         </item>
         <item row="0" column="1">
-         <widget class="QLineEdit" name="edit1"/>
+         <widget class="QLineEdit" name="urlEdit"/>
         </item>
         <item row="1" column="0">
-         <widget class="QLabel" name="label_2">
+         <widget class="QLabel" name="filelabel">
           <property name="text">
            <string>file</string>
           </property>
          </widget>
         </item>
         <item row="1" column="1">
-         <widget class="QLineEdit" name="edit2"/>
+         <widget class="QLineEdit" name="fileEdit"/>
         </item>
        </layout>
       </item>
@@ -124,25 +61,268 @@
     </item>
    </layout>
   </widget>
+  <widget class="QToolBar" name="mainToolBar">
+   <attribute name="toolBarArea">
+    <enum>TopToolBarArea</enum>
+   </attribute>
+   <attribute name="toolBarBreak">
+    <bool>false</bool>
+   </attribute>
+  </widget>
+  <widget class="QStatusBar" name="statusBar"/>
+  <widget class="QDockWidget" name="leftDock">
+   <property name="floating">
+    <bool>false</bool>
+   </property>
+   <property name="features">
+    <set>QDockWidget::DockWidgetFloatable|QDockWidget::DockWidgetMovable</set>
+   </property>
+   <attribute name="dockWidgetArea">
+    <number>1</number>
+   </attribute>
+   <widget class="QWidget" name="leftDockWidgetContents">
+    <layout class="QVBoxLayout" name="verticalLayout_3">
+     <property name="spacing">
+      <number>1</number>
+     </property>
+     <item>
+      <layout class="QVBoxLayout" name="leftDockVerticalLayout">
+       <property name="spacing">
+        <number>1</number>
+       </property>
+       <item>
+        <layout class="QHBoxLayout" name="loadLayout">
+         <property name="spacing">
+          <number>1</number>
+         </property>
+         <item>
+          <widget class="QPushButton" name="loadFile">
+           <property name="text">
+            <string>Load from file</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QPushButton" name="loadFromClipboard">
+           <property name="text">
+            <string>Load from clipboard</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <spacer name="horizontalSpacer">
+           <property name="orientation">
+            <enum>Qt::Horizontal</enum>
+           </property>
+           <property name="sizeHint" stdset="0">
+            <size>
+             <width>40</width>
+             <height>20</height>
+            </size>
+           </property>
+          </spacer>
+         </item>
+        </layout>
+       </item>
+       <item>
+        <widget class="QListWidget" name="results"/>
+       </item>
+       <item>
+        <widget class="QCheckBox" name="random100">
+         <property name="text">
+          <string>Show 100 random results</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <layout class="QHBoxLayout" name="versionLayout">
+         <property name="spacing">
+          <number>1</number>
+         </property>
+         <item>
+          <widget class="QLabel" name="versionLabel">
+           <property name="text">
+            <string>Version</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QComboBox" name="version"/>
+         </item>
+         <item>
+          <spacer name="horizontalSpacer_2">
+           <property name="orientation">
+            <enum>Qt::Horizontal</enum>
+           </property>
+           <property name="sizeHint" stdset="0">
+            <size>
+             <width>40</width>
+             <height>20</height>
+            </size>
+           </property>
+          </spacer>
+         </item>
+        </layout>
+       </item>
+      </layout>
+     </item>
+    </layout>
+   </widget>
+  </widget>
   <widget class="QMenuBar" name="menuBar">
    <property name="geometry">
     <rect>
      <x>0</x>
      <y>0</y>
      <width>1057</width>
-     <height>25</height>
+     <height>30</height>
     </rect>
    </property>
   </widget>
-  <widget class="QToolBar" name="mainToolBar">
-   <attribute name="toolBarArea">
-    <enum>TopToolBarArea</enum>
-   </attribute>
-   <attribute name="toolBarBreak">
-    <bool>false</bool>
+  <widget class="QDockWidget" name="rightDock">
+   <property name="features">
+    <set>QDockWidget::DockWidgetFloatable|QDockWidget::DockWidgetMovable</set>
+   </property>
+   <attribute name="dockWidgetArea">
+    <number>2</number>
    </attribute>
+   <widget class="QWidget" name="rightDockWidgetContents">
+    <layout class="QVBoxLayout" name="verticalLayout_4">
+     <property name="spacing">
+      <number>1</number>
+     </property>
+     <item>
+      <layout class="QVBoxLayout" name="filesNavigatorLayout">
+       <property name="spacing">
+        <number>1</number>
+       </property>
+       <item>
+        <layout class="QHBoxLayout" name="filterLayout">
+         <property name="spacing">
+          <number>1</number>
+         </property>
+         <item>
+          <widget class="QLineEdit" name="filterEdit">
+           <property name="maximumSize">
+            <size>
+             <width>16777215</width>
+             <height>16777215</height>
+            </size>
+           </property>
+           <property name="placeholderText">
+            <string>filter</string>
+           </property>
+           <property name="clearButtonEnabled">
+            <bool>true</bool>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QPushButton" name="inFilesButton">
+           <property name="text">
+            <string>In files</string>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </item>
+       <item>
+        <widget class="QTabWidget" name="tabWidget">
+         <property name="maximumSize">
+          <size>
+           <width>16777215</width>
+           <height>16777215</height>
+          </size>
+         </property>
+         <property name="currentIndex">
+          <number>0</number>
+         </property>
+         <widget class="QWidget" name="fsTab">
+          <attribute name="title">
+           <string>Filesystem</string>
+          </attribute>
+          <layout class="QVBoxLayout" name="verticalLayout_5">
+           <property name="spacing">
+            <number>1</number>
+           </property>
+           <item>
+            <widget class="QTreeView" name="directoryTree">
+             <property name="sizePolicy">
+              <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+               <horstretch>0</horstretch>
+               <verstretch>0</verstretch>
+              </sizepolicy>
+             </property>
+             <property name="maximumSize">
+              <size>
+               <width>16777215</width>
+               <height>16777215</height>
+              </size>
+             </property>
+             <property name="itemsExpandable">
+              <bool>true</bool>
+             </property>
+             <attribute name="headerVisible">
+              <bool>false</bool>
+             </attribute>
+            </widget>
+           </item>
+          </layout>
+         </widget>
+         <widget class="QWidget" name="inFilesTab">
+          <attribute name="title">
+           <string>In Files Result</string>
+          </attribute>
+          <layout class="QVBoxLayout" name="verticalLayout_6">
+           <property name="spacing">
+            <number>1</number>
+           </property>
+           <item>
+            <widget class="QListWidget" name="inFilesResult">
+             <property name="sizePolicy">
+              <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+               <horstretch>0</horstretch>
+               <verstretch>0</verstretch>
+              </sizepolicy>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <layout class="QHBoxLayout" name="fileFilterLayout">
+             <property name="spacing">
+              <number>1</number>
+             </property>
+             <item>
+              <widget class="QCheckBox" name="hFilesFilter">
+               <property name="text">
+                <string>*.h, *.hpp,...</string>
+               </property>
+               <property name="checked">
+                <bool>true</bool>
+               </property>
+              </widget>
+             </item>
+             <item>
+              <widget class="QCheckBox" name="srcFilesFilter">
+               <property name="text">
+                <string>*.c, *.cpp,...</string>
+               </property>
+               <property name="checked">
+                <bool>true</bool>
+               </property>
+              </widget>
+             </item>
+            </layout>
+           </item>
+          </layout>
+         </widget>
+        </widget>
+       </item>
+      </layout>
+     </item>
+    </layout>
+   </widget>
   </widget>
-  <widget class="QStatusBar" name="statusBar"/>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
@@ -155,18 +335,66 @@
  <resources/>
  <connections>
   <connection>
-   <sender>results</sender>
-   <signal>itemDoubleClicked(QListWidgetItem*)</signal>
+   <sender>filterEdit</sender>
+   <signal>textChanged(QString)</signal>
    <receiver>MainWindow</receiver>
-   <slot>showResult(QListWidgetItem*)</slot>
+   <slot>fileTreeFilter(QString)</slot>
    <hints>
     <hint type="sourcelabel">
-     <x>28</x>
-     <y>104</y>
+     <x>940</x>
+     <y>275</y>
     </hint>
     <hint type="destinationlabel">
-     <x>5</x>
-     <y>104</y>
+     <x>528</x>
+     <y>268</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>inFilesButton</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>findInFilesClicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>776</x>
+     <y>68</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>413</x>
+     <y>268</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>directoryTree</sender>
+   <signal>doubleClicked(QModelIndex)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>directorytreeDoubleClick()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>780</x>
+     <y>314</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>454</x>
+     <y>268</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>inFilesResult</sender>
+   <signal>doubleClicked(QModelIndex)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>searchResultsDoubleClick()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>755</x>
+     <y>314</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>454</x>
+     <y>268</y>
     </hint>
    </hints>
   </connection>
@@ -203,34 +431,50 @@
    </hints>
   </connection>
   <connection>
-   <sender>version</sender>
-   <signal>currentIndexChanged(QString)</signal>
+   <sender>random100</sender>
+   <signal>clicked()</signal>
    <receiver>MainWindow</receiver>
-   <slot>filter(QString)</slot>
+   <slot>refreshResults()</slot>
    <hints>
     <hint type="sourcelabel">
-     <x>98</x>
-     <y>489</y>
+     <x>30</x>
+     <y>464</y>
     </hint>
     <hint type="destinationlabel">
-     <x>493</x>
-     <y>39</y>
+     <x>3</x>
+     <y>460</y>
     </hint>
    </hints>
   </connection>
   <connection>
-   <sender>random100</sender>
-   <signal>clicked()</signal>
+   <sender>results</sender>
+   <signal>itemDoubleClicked(QListWidgetItem*)</signal>
    <receiver>MainWindow</receiver>
-   <slot>refreshResults()</slot>
+   <slot>showResult(QListWidgetItem*)</slot>
    <hints>
     <hint type="sourcelabel">
-     <x>30</x>
-     <y>464</y>
+     <x>28</x>
+     <y>104</y>
     </hint>
     <hint type="destinationlabel">
-     <x>3</x>
-     <y>460</y>
+     <x>5</x>
+     <y>104</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>version</sender>
+   <signal>currentIndexChanged(QString)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>filter(QString)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>98</x>
+     <y>489</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>493</x>
+     <y>39</y>
     </hint>
    </hints>
   </connection>
@@ -241,5 +485,9 @@
   <slot>loadFromClipboard()</slot>
   <slot>filter(QString)</slot>
   <slot>refreshResults()</slot>
+  <slot>fileTreeFilter(QString)</slot>
+  <slot>findInFilesClicked()</slot>
+  <slot>directorytreeDoubleClick()</slot>
+  <slot>searchResultsDoubleClick()</slot>
  </slots>
 </ui>
diff --git a/tools/triage/readme.txt b/tools/triage/readme.txt
index c3c9fedc9a4..2542e664573 100644
--- a/tools/triage/readme.txt
+++ b/tools/triage/readme.txt
@@ -1,20 +1,20 @@
-triage tool
-This tool lets you comfortably look at Cppcheck analysis results for daca packages. It automatically
-downloads the package, extracts it and jumps to the corresponding source code for a Cppcheck
-message.
-
-triage uses "wget" and "tar"
-On Linux the tool can be directly run since the programs should be installed.
-On Windows something like Cygwin is necessary and the directory containing the executables must be
-in the PATH environment variable (for example "C:\cygwin\bin").
-
-Usage:
-After triage has been started you have to load daca results from a file via the "Load from file"
-button or from the clipboard via the "Load from clipboard" button.
-The file or clipboard text must contain the package URL line beginning with "ftp://" and the
-Cppcheck messages.
-When the results data has been parsed successfully you can see a list of Cppcheck messages directly
-beneath the "Load ..." buttons. Double-click any entry to let the tool show the source code and jump
-to and mark the corresponding line. If the package is not found it is downloaded and extracted
-automatically. So after the first double-click it is normal that it takes some time until the
-source code is shown.
+triage tool
+This tool lets you comfortably look at Cppcheck analysis results for daca packages. It automatically
+downloads the package, extracts it and jumps to the corresponding source code for a Cppcheck
+message.
+
+triage uses "wget" and "tar"
+On Linux the tool can be directly run since the programs should be installed.
+On Windows something like Cygwin is necessary and the directory containing the executables must be
+in the PATH environment variable (for example "C:\cygwin\bin").
+
+Usage:
+After triage has been started you have to load daca results from a file via the "Load from file"
+button or from the clipboard via the "Load from clipboard" button.
+The file or clipboard text must contain the package URL line beginning with "ftp://" and the
+Cppcheck messages.
+When the results data has been parsed successfully you can see a list of Cppcheck messages directly
+beneath the "Load ..." buttons. Double-click any entry to let the tool show the source code and jump
+to and mark the corresponding line. If the package is not found it is downloaded and extracted
+automatically. So after the first double-click it is normal that it takes some time until the
+source code is shown.
diff --git a/tools/triage/triage.pro b/tools/triage/triage.pro
index 70425ee94c0..213022968cd 100644
--- a/tools/triage/triage.pro
+++ b/tools/triage/triage.pro
@@ -1,38 +1,16 @@
-#-------------------------------------------------
-#
-# Project created by QtCreator 2017-12-31T22:22:56
-#
-#-------------------------------------------------
-
-QT       += core gui
-
-greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
-
+QT += core gui widgets
 TARGET = triage
 TEMPLATE = app
-
-QMAKE_CXXFLAGS += -std=c++11
+QMAKE_CXXFLAGS += -std=c++17
 INCLUDEPATH += ../../gui
-
-# The following define makes your compiler emit warnings if you use
-# any feature of Qt which as been marked as deprecated (the exact warnings
-# depend on your compiler). Please consult the documentation of the
-# deprecated API in order to know how to port your code away from it.
-DEFINES += QT_DEPRECATED_WARNINGS
-
-# You can also make your code fail to compile if you use deprecated APIs.
-# In order to do so, uncomment the following line.
-# You can also select to disable deprecated APIs only up to a certain version of Qt.
-#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
-
-
+MOC_DIR = temp
+OBJECTS_DIR = temp
+UI_DIR = temp
 SOURCES += main.cpp\
         mainwindow.cpp \
         ../../gui/codeeditorstyle.cpp \
         ../../gui/codeeditor.cpp
-
 HEADERS  += mainwindow.h \
         ../../gui/codeeditorstyle.h \
         ../../gui/codeeditor.h
-
 FORMS    += mainwindow.ui
diff --git a/tools/triage_py/README.md b/tools/triage_py/README.md
new file mode 100644
index 00000000000..2d7e0705bc0
--- /dev/null
+++ b/tools/triage_py/README.md
@@ -0,0 +1,40 @@
+# triage_version.py
+
+A script to run a code sample against a given set of Cppcheck versions.
+
+## Usage
+
+```
+usage: triage_version.py [-h] [--compare] [--verbose] [--debug] [--debug-warnings] [--check-library]
+                         [--timeout TIMEOUT] [--compact] [--no-quiet] [--perf] [--start START]
+                         [--no-stderr | --no-stdout]
+                         dir infile [repo]
+
+positional arguments:
+  dir                directory with versioned folders
+  infile             the file to analyze
+  repo               the git repository (for sorting commit hashes)
+
+options:
+  -h, --help         show this help message and exit
+  --compare          compare output and only show when changed
+  --verbose          verbose output for debugging
+  --debug            passed through to binary if supported
+  --debug-warnings   passed through to binary if supported
+  --check-library    passed through to binary if supported
+  --timeout TIMEOUT  the amount of seconds to wait for the analysis to finish
+  --compact          only print versions with changes with --compare
+  --no-quiet         do not specify -q
+  --perf             output duration of execution in seconds (CSV format)
+  --start START      specify the start version/commit
+  --no-stderr        do not display stdout
+  --no-stdout        do not display stderr
+```
+
+### Structure of `dir`
+
+It expects the given `dir` to contain folders which are either named after version numbers or commit hashes. These folders must each contain a `cppcheck` and the associated files for that version.
+
+If the first folder is not a valid version the names are interpreted as commit hashes. These are internally sorted but that requires the `repo` parameter to be set.
+
+It is not possible to mix versions and commit hashes.
\ No newline at end of file
diff --git a/tools/triage_py/triage_version.py b/tools/triage_py/triage_version.py
new file mode 100644
index 00000000000..c87af3bcdf8
--- /dev/null
+++ b/tools/triage_py/triage_version.py
@@ -0,0 +1,296 @@
+#!/usr/bin/env python
+import os.path
+import subprocess
+import sys
+import argparse
+import time
+import difflib
+
+from packaging.version import Version
+
+parser = argparse.ArgumentParser()
+parser.add_argument('dir', help='directory with versioned folders')
+parser.add_argument('infile', help='the file to analyze')
+parser.add_argument('repo', nargs='?', default=None, help='the git repository (for sorting commit hashes)')
+parser.add_argument('--compare', action='store_true', help='compare output and only show when changed')
+parser.add_argument('--verbose', action='store_true', help='verbose output for debugging')
+parser.add_argument('--debug', action='store_true', help='passed through to binary if supported')
+parser.add_argument('--debug-warnings', action='store_true', help='passed through to binary if supported')
+parser.add_argument('--check-library', action='store_true', help='passed through to binary if supported')
+parser.add_argument('--timeout', type=int, default=2, help='the amount of seconds to wait for the analysis to finish')
+parser.add_argument('--compact', action='store_true', help='only print versions with changes with --compare')
+parser.add_argument('--no-quiet', action='store_true', default=False, help='do not specify -q')
+parser.add_argument('--perf', action='store_true', default=False, help='output duration of execution in seconds (CSV format)')
+parser.add_argument('--start', default=None, help='specify the start version/commit')
+parser.add_argument('--diff', action='store_true', help='show differences as unified diff')
+package_group = parser.add_mutually_exclusive_group()
+package_group.add_argument('--no-stderr', action='store_true', default=False, help='do not display stdout')
+package_group.add_argument('--no-stdout', action='store_true', default=False, help='do not display stderr')
+args = parser.parse_args()
+
+def sort_commit_hashes(commits):
+    git_cmd = 'git rev-list --abbrev-commit --topo-order --no-walk=sorted --reverse ' + ' '.join(commits)
+    with subprocess.Popen(git_cmd.split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=git_repo, universal_newlines=True) as p:
+        stdout, stderr = p.communicate()
+        rc = p.returncode
+    if rc != 0:
+        print('error: sorting commit hashes failed')
+        print(stderr)
+        sys.exit(1)
+    return stdout.splitlines()
+
+verbose = args.verbose
+do_compare = args.compare
+if args.compact:
+    if not do_compare:
+        print('error: --compact requires --compare')
+        sys.exit(1)
+if args.perf:
+    if args.compact:
+        print('error: --compact has no effect with --perf')
+    if args.no_stdout:
+        print('error: --no-stdout has no effect with --perf')
+    if args.no_stderr:
+        print('error: --no-stderr has no effect with --perf')
+
+directory = args.dir
+input_file = args.infile
+git_repo = args.repo
+
+use_hashes = None
+versions = []
+
+for filename in os.listdir(directory):
+    f = os.path.join(directory, filename)
+    if not os.path.isdir(f):
+        continue
+    versions.append(filename)
+
+if not len(versions):
+    print("error: no versions found in '{}'".format(directory))
+    sys.exit(1)
+
+if verbose:
+    print("found {} versions in '{}'".format(len(versions), directory))
+
+try:
+    Version(versions[0])
+    use_hashes = False
+    versions.sort(key=Version)
+except:
+    if verbose:
+        print("'{}' not a version - assuming commit hashes".format(versions[0]))
+    if not git_repo:
+        print('error: git repository argument required for commit hash sorting')
+        sys.exit(1)
+    if verbose:
+        print("using git repository '{}' to sort commit hashes".format(git_repo))
+    use_hashes = True
+    # if you use the folder from the bisect script that contains the repo as a folder - so remove it from the list
+    if versions.count('cppcheck'):
+        versions.remove('cppcheck')
+    # this is the commit hash for the 2.9 release tag. it does not exist in the main branch so the version for it cannot be determined
+    if versions.count('aca3f6fef'):
+        versions.remove('aca3f6fef')
+    # 2.8 tags
+    if versions.count('61f846073'):
+        versions.remove('61f846073')
+    if versions.count('f998703a5'):
+        versions.remove('f998703a5')
+    # ???
+    if versions.count('d4505827b'):
+        versions.remove('d4505827b')
+    # 2.6 tag
+    if versions.count('d873b8e77'):
+        versions.remove('d873b8e77')
+    len_in = len(versions)
+    versions = sort_commit_hashes(versions)
+    if len(versions) != len_in:
+        print('error: unexpected amount of versions after commit hash sorting')
+        sys.exit(1)
+
+if verbose:
+    print("analyzing '{}'".format(input_file))
+
+last_udiff_version = ''
+last_ec = None
+last_out = None
+last_udiff = None
+
+if args.perf:
+    print('version,time')
+
+start_entry = args.start
+
+for entry in versions:
+    if start_entry:
+        if start_entry != entry:
+            continue
+        start_entry = None
+
+    exe_path = os.path.join(directory, entry)
+    exe = os.path.join(exe_path, 'cppcheck')
+
+    if not use_hashes:
+        version = entry
+    else:
+        # get version string
+        version_cmd = exe + ' ' + '--version'
+        with subprocess.Popen(version_cmd.split(), stdout=subprocess.PIPE, universal_newlines=True) as p:
+            # TODO: handle p.returncode?
+            version = p.stdout.read().strip()
+        # sanitize version
+        version = version.replace('Cppcheck ', '').replace(' dev', '')
+
+    if version == 'CPPCHECK_MAJOR.CPPCHECK_DEVMINOR':
+        continue
+
+    cmd = [exe]
+    if do_compare and not args.no_quiet:
+        cmd.append('-q')
+    if args.debug and Version(version) >= Version('1.45'):
+        cmd.append('--debug')
+    if args.debug_warnings and Version(version) >= Version('1.45'):
+        cmd.append('--debug-warnings')
+    if args.check_library and Version(version) >= Version('1.61'):
+        cmd.append('--check-library')
+    if Version(version) >= Version('1.39'):
+        cmd.append('--enable=all')
+    if Version(version) >= Version('1.40'):
+        cmd.append('--inline-suppr')
+    if Version(version) >= Version('1.48'):
+        cmd.append('--suppress=missingInclude')
+        cmd.append('--suppress=missingIncludeSystem')
+        cmd.append('--suppress=unmatchedSuppression')
+        cmd.append('--suppress=unusedFunction')
+    if Version(version) >= Version('1.49'):
+        cmd.append('--inconclusive')
+    if Version(version) >= Version('1.69'):
+        cmd.append('--platform=native')
+    if Version(version) >= Version('1.52') and Version(version) < Version('2.0'):
+        # extend Cppcheck 1.x format with error ID
+        if Version(version) < Version('1.61'):
+            # TODO: re-add inconclusive
+            cmd.append('--template=[{file}:{line}]: ({severity}) {message} [{id}]')
+        else:
+            # TODO: re-add inconclusive: {callstack}: ({severity}{inconclusive:, inconclusive}) {message
+            cmd.append('--template={callstack}: ({severity}) {message} [{id}]')
+    if Version(version) >= Version('2.13'):
+        cmd.append('--suppress=checkersReport')
+    # TODO: how to pass additional options?
+    if args.perf:
+        cmd.append('--error-exitcode=0')
+    cmd.append(input_file)
+    if verbose:
+        print("running '{}'". format(' '.join(cmd)))
+    if args.perf:
+        start = time.time_ns()
+    p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=exe_path, universal_newlines=True)
+    try:
+        stdout, stderr = p.communicate(timeout=args.timeout)
+        if args.perf:
+            end = time.time_ns()
+        out = ''
+        if not args.no_stdout:
+            out += stdout
+        if not args.no_stdout and not args.no_stderr:
+            out += '\n'
+        if not args.no_stderr:
+            out += stderr
+    except subprocess.TimeoutExpired:
+        out = "timeout"
+        p.kill()
+        p.communicate()
+
+    ec = p.returncode
+    p = None
+
+    if not do_compare:
+        if not use_hashes:
+            ver_str = version
+        else:
+            ver_str = '{} ({})'.format(entry, version)
+        if args.perf:
+            if out == "timeout":
+                data_str = "0.0" # TODO: how to handle these properly?
+            elif ec != 0:
+                continue # skip errors
+            else:
+                data_str = '{}'.format((end - start) / 1000.0 / 1000.0 / 1000.0)
+            print('"{}",{}'.format(ver_str, data_str))
+            continue
+        print(ver_str)
+        print(ec)
+        print(out)
+        continue
+
+    # filter out some false positives
+    # [*]: (information) Unmatched suppression: missingInclude
+    # [*]: (information) Unmatched suppression: missingIncludeSystem
+    # [*]: (information) Unmatched suppression: unmatchedSuppression
+    # [*]: (information) Unmatched suppression: unusedFunction
+    if not use_hashes and (Version(version) >= Version('1.48') or Version(version) <= Version('1.49')):
+        lines = out.splitlines()
+        out = ""
+        for line in lines:
+            if line.startswith('[*]: (information) Unmatched suppression:'):
+                continue
+            out += line + '\n'
+
+    out = out.strip()
+
+    if last_ec is None:
+        # first run - only print version
+        if not use_hashes:
+            print(version)
+        else:
+            print('{} ({})'.format(entry, version))
+
+        last_ec = ec
+        last_out = out
+        continue
+
+    do_print = False
+    udiff = None
+
+    if last_ec != ec:
+        if verbose:
+            print("{}: exitcode changed".format(version))
+        do_print = True
+
+    if last_out != out:
+        if verbose:
+            print("{}: output changed".format(version))
+        do_print = True
+        if args.diff:
+            udiff = difflib.unified_diff(last_out.splitlines(True), out.splitlines(True), fromfile=last_udiff_version, tofile=version)
+            last_udiff_version = version
+
+    if do_print:
+        print(last_ec)
+        print(last_out)
+        if last_udiff:
+            sys.stdout.writelines(last_udiff)
+            sys.stdout.write('\n')
+
+    # do not print intermediate versions with --compact
+    if not args.compact or do_print:
+        if not use_hashes:
+            print(version)
+        else:
+            print('{} ({})'.format(entry, version))
+
+    last_ec = ec
+    last_out = out
+    if udiff:
+        last_udiff = udiff
+
+if do_compare:
+    print(last_ec)
+    print(last_out)
+    if last_udiff:
+        sys.stdout.writelines(last_udiff)
+        sys.stdout.write('\n')
+
+if verbose:
+    print('done')
diff --git a/valgrind/testrunner.supp b/valgrind/testrunner.supp
new file mode 100644
index 00000000000..98e30d241ce
--- /dev/null
+++ b/valgrind/testrunner.supp
@@ -0,0 +1,16 @@
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   fun:_Znwm
+   fun:__static_initialization_and_destruction_0
+   fun:_GLOBAL__sub_I_memory_manager.cpp
+   fun:call_init.part.0
+   fun:call_init
+   fun:_dl_init
+   obj:/usr/lib/x86_64-linux-gnu/ld-2.31.so
+   obj:*
+   obj:*
+   obj:*
+   obj:*
+}
diff --git a/webreport.sh b/webreport.sh
deleted file mode 100755
index 17d735f29e2..00000000000
--- a/webreport.sh
+++ /dev/null
@@ -1,21 +0,0 @@
-#!/bin/bash
-
-./generate_coverage_report
-
-rm -rf devinfo
-mkdir devinfo
-
-mv coverage_report devinfo/
-
-doxygen 2> devinfo/doxygen-errors.txt
-mv doxyoutput/html devinfo/doxyoutput
-
-cd addons
-doxygen cppcheckdata.doxyfile
-mv html ../devinfo/cppcheckdata
-cd ..
-
-# Detect duplicate code..
-~/pmd-4.2.6/bin/cpd.sh lib/ > devinfo/cpd.txt
-#java -jar ~/simian-2.4.0/bin/simian-2.4.0.jar -language=c++ -reportDuplicateText -threshold=10 lib/*.cpp lib/*.h > devinfo/simian.txt
-
diff --git a/win_installer/GPLv3.txt b/win_installer/GPLv3.txt
index abf09eef33b..a3997e678cf 100644
--- a/win_installer/GPLv3.txt
+++ b/win_installer/GPLv3.txt
@@ -1,619 +1,619 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
 copy of the Program in return for a fee.
\ No newline at end of file
diff --git a/win_installer/config.wxi b/win_installer/config.wxi
index d1c1b485c44..7bc613d1669 100644
--- a/win_installer/config.wxi
+++ b/win_installer/config.wxi
@@ -1,18 +1,14 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Include>
-  <?define CliBuildDir = "..\bin" ?>
-  <?define GuiBuildDir = "..\bin" ?>
-  <?define TranslationsDir = "..\gui" ?>
-  <?define CfgsDir = "..\cfg" ?>
-  <?define PtfsDir = "..\platforms" ?>
-  <?define AddonsDir = "..\addons" ?>
-  <?define QtDllDir = "..\bin" ?>
-
-  <?if $(var.Platform) = x64 ?>
-    <?define CrtMergeModule = "$(env.CommonProgramFiles)\Merge Modules\Microsoft_VC142_CRT_x64.msm" ?>
-    <?define PlatformProgramFilesFolder = "ProgramFiles64Folder" ?>
-  <?else?>
-    <?define CrtMergeModule = "$(env.CommonProgramFiles)\Merge Modules\Microsoft_VC142_CRT_x86.msm" ?>
-    <?define PlatformProgramFilesFolder = "ProgramFilesFolder" ?>
-  <?endif?>
-</Include>
+<?xml version="1.0" encoding="utf-8"?>
+<Include>
+  <?define CliBuildDir = "files" ?>
+  <?define GuiBuildDir = "files" ?>
+  <?define GuiHelpDir = "files\help" ?>
+  <?define TranslationsDir = "files\translations" ?>
+  <?define CfgsDir = "files\cfg" ?>
+  <?define PtfsDir = "files\platforms" ?>
+  <?define AddonsDir = "files\addons" ?>
+  <?define QtDllDir = "files" ?>
+
+  <?define CrtMergeModule = "$(env.VCINSTALLDIR)Redist\MSVC\v143\MergeModules\Microsoft_VC143_CRT_x64.msm" ?>
+  <?define PlatformProgramFilesFolder = "ProgramFiles64Folder" ?>
+</Include>
diff --git a/win_installer/cppcheck.sln b/win_installer/cppcheck.sln
index fcfc17cfb8a..c72a67d9810 100644
--- a/win_installer/cppcheck.sln
+++ b/win_installer/cppcheck.sln
@@ -1,22 +1,22 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.29020.237
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{930C7802-8A8C-48F9-8165-68863BCCD9DD}") = "cppcheck", "cppcheck.wixproj", "{3B772885-4980-4A76-8407-4DABF8F7757C}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Release|x64 = Release|x64
-		Release|x86 = Release|x86
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{3B772885-4980-4A76-8407-4DABF8F7757C}.Release|x64.ActiveCfg = Release|x64
-		{3B772885-4980-4A76-8407-4DABF8F7757C}.Release|x64.Build.0 = Release|x64
-		{3B772885-4980-4A76-8407-4DABF8F7757C}.Release|x86.ActiveCfg = Release|x86
-		{3B772885-4980-4A76-8407-4DABF8F7757C}.Release|x86.Build.0 = Release|x86
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = TRUE
-	EndGlobalSection
-EndGlobal
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.29020.237
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{930C7802-8A8C-48F9-8165-68863BCCD9DD}") = "cppcheck", "cppcheck.wixproj", "{3B772885-4980-4A76-8407-4DABF8F7757C}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{3B772885-4980-4A76-8407-4DABF8F7757C}.Release|x64.ActiveCfg = Release|x64
+		{3B772885-4980-4A76-8407-4DABF8F7757C}.Release|x64.Build.0 = Release|x64
+		{3B772885-4980-4A76-8407-4DABF8F7757C}.Release|x86.ActiveCfg = Release|x86
+		{3B772885-4980-4A76-8407-4DABF8F7757C}.Release|x86.Build.0 = Release|x86
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = TRUE
+	EndGlobalSection
+EndGlobal
diff --git a/win_installer/cppcheck.wixproj b/win_installer/cppcheck.wixproj
index 8633039ca9b..6cf93fb02bf 100644
--- a/win_installer/cppcheck.wixproj
+++ b/win_installer/cppcheck.wixproj
@@ -1,45 +1,44 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="All" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
-  <PropertyGroup>
-    <DefineSolutionProperties>false</DefineSolutionProperties>
-    <WixTargetsPath Condition="'$(WixTargetsPath)' == ''">$(MSBuildExtensionsPath)\Microsoft\WiX\v3.x\Wix.targets</WixTargetsPath>
-
-    <Configuration Condition=" '$(Configuration)' == '' ">Release</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
-
-    <OutputName>cppcheck-$(ProductVersion)-$(Platform)-Setup</OutputName>
-    <OutputPath>Build\</OutputPath>
-    <IntermediateOutputPath>BuildTmp\Wix\$(Platform)\</IntermediateOutputPath>
-    <OutputType>package</OutputType>
-
-    <ProjectGuid>{3b772885-4980-4a76-8407-4dabf8f7757c}</ProjectGuid>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
-  </PropertyGroup>
-  <ItemGroup>
-    <WixExtension Include="WixUIExtension">
-      <Name>WixUIExtension</Name>
-    </WixExtension>
-    <Compile Include="cppcheck.wxs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Content Include="config.wxi" />
-    <Content Include="productInfo.wxi" />
-    <Content Include="readme.txt" />
-  </ItemGroup>
-  <Import Project="$(WixTargetsPath)" />
-  <Target Name="All" DependsOnTargets="Clean;Validate;Build" />
-  <Target Name="Clean">
-    <RemoveDir Directories="BuildTmp\Wix" />
-  </Target>
-
-  <Target Name="Validate">
-    <Exec Command="..\bin\cppcheck --rule=. --version" />
-  </Target>
-</Project>
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="All" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
+  <PropertyGroup>
+    <DefineSolutionProperties>false</DefineSolutionProperties>
+    <WixTargetsPath Condition="'$(WixTargetsPath)' == ''">$(MSBuildExtensionsPath)\Microsoft\WiX\v3.x\Wix.targets</WixTargetsPath>
+
+    <Configuration Condition=" '$(Configuration)' == '' ">Release</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
+
+    <OutputName>cppcheck-$(ProductVersion)-$(Platform)-Setup</OutputName>
+    <OutputPath>Build\</OutputPath>
+    <IntermediateOutputPath>BuildTmp\Wix\$(Platform)\</IntermediateOutputPath>
+    <OutputType>package</OutputType>
+
+    <ProjectGuid>{3b772885-4980-4a76-8407-4dabf8f7757c}</ProjectGuid>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+  </PropertyGroup>
+  <ItemGroup>
+    <WixExtension Include="WixUIExtension">
+      <Name>WixUIExtension</Name>
+    </WixExtension>
+    <Compile Include="cppcheck.wxs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="config.wxi" />
+    <Content Include="productInfo.wxi" />
+  </ItemGroup>
+  <Import Project="$(WixTargetsPath)" />
+  <Target Name="All" DependsOnTargets="Clean;Validate;Build" />
+  <Target Name="Clean">
+    <RemoveDir Directories="BuildTmp\Wix" />
+  </Target>
+
+  <Target Name="Validate">
+    <Exec Command="..\bin\cppcheck --rule=. --version" />
+  </Target>
+</Project>
diff --git a/win_installer/cppcheck.wxs b/win_installer/cppcheck.wxs
index f2fd519b109..7b5cc45614a 100644
--- a/win_installer/cppcheck.wxs
+++ b/win_installer/cppcheck.wxs
@@ -1,237 +1,292 @@
-<?xml version='1.0' encoding='utf-8'?>
-<Wix xmlns='http://schemas.microsoft.com/wix/2006/wi'>
-  <?include productInfo.wxi ?>
-  <?include config.wxi ?>
-
-  <Product Name='$(var.ProductName)' Id='*' UpgradeCode='$(var.ProductUpgradeCode)'
-    Language='1033' Codepage='1252' Version='$(var.ProductVersion)' Manufacturer='$(var.ProductManufacturer)'>
-
-    <Package Id='*' Keywords='Installer' Description="$(var.ProductName) Setup"
-      Comments='$(var.ProductDescription)' Manufacturer='$(var.ProductManufacturer)'
-      InstallerVersion='405' Languages='1033' Compressed='yes' SummaryCodepage='1252' InstallScope='perMachine'/>
-
-    <Media Id='1' Cabinet='Cppcheck.cab' EmbedCab='yes' CompressionLevel='high' DiskPrompt='CD-ROM 1' />
-    <Property Id='DiskPrompt' Value='Cppcheck installation [1]' />
-
-    <Directory Id='TARGETDIR' Name='SourceDir'>
-      <Directory Id='System32' FileSource='SystemFolder' />
-      <Directory Id='$(var.PlatformProgramFilesFolder)' Name='PFiles'>
-        <Directory Id='INSTALLDIR' Name='$(var.ProductNameShort)'>
-          <Component Id='cppcheckcore.dll' Guid='$(var.cppcheckcoreGUID)'>
-            <File Id='cppcheckcore.dll' Name='cppcheck-core.dll' DiskId='1' Source='$(var.CliBuildDir)\cppcheck-core.dll' KeyPath='yes' />
-          </Component>
-          <Component Id='cppcheck.exe' Guid='$(var.cppcheckGUID)'>
-            <File Id='cppcheck.exe' Name='cppcheck.exe' DiskId='1' Source='$(var.CliBuildDir)\cppcheck.exe' KeyPath='yes' />
-          </Component>
-          <Component Id='RegistryEntries' Guid='$(var.registrykeysGUID)'>
-            <RegistryKey Root="HKCU" Key="SOFTWARE\$(var.ProductNameShort)" ForceDeleteOnUninstall="yes">
-              <RegistryValue Name="InstallationPath" Value="[INSTALLDIR]" Type="string" KeyPath="yes" />
-              <RegistryValue Name="Version" Value="$(var.ProductVersion)" Type="string" />
-            </RegistryKey>
-          </Component>
-          <Component Id='GuiExecutable' DiskId='1' Guid='$(var.guiGUID)'>
-            <File Id='cppcheckguiexe' Name='cppcheckgui.exe' Source='$(var.GuiBuildDir)\cppcheck-gui.exe' KeyPath='yes'>
-              <Shortcut Id='startmenuGui' Directory="ProgramMenuDir" Name='$(var.ProductNameShort)'
-                  WorkingDirectory='INSTALLDIR' Icon="cppcheckgui.exe" IconIndex="0" Advertise="yes" />
-            </File>
-            <File Id='Qt5Coredll' Name='Qt5Core.dll' Source='$(var.QtDllDir)\Qt5Core.dll' />
-            <File Id='Qt5Guidll' Name='Qt5Gui.dll' Source='$(var.QtDllDir)\Qt5Gui.dll' />
-            <File Id='Qt5Widgetsdll' Name='Qt5Widgets.dll' Source='$(var.QtDllDir)\Qt5Widgets.dll' />
-            <File Id='Qt5PrintSupportdll' Name='Qt5PrintSupport.dll' Source='$(var.QtDllDir)\Qt5PrintSupport.dll' />
-            <?if $(var.Platform) = x64 ?>
-              <File Id='Qt5Chartsdll' Name='Qt5Charts.dll' Source='$(var.QtDllDir)\Qt5Charts.dll' />
-            <?endif?>
-          </Component>
-          <Directory Id='QtPlatformsFolder' Name='platforms'>
-            <Component Id='QtPlatforms' DiskId='1' Guid='$(var.qtplatformsGUID)'>
-              <File Id='qwindowsdll' Name='qwindows.dll' Source='$(var.QtDllDir)\platforms\qwindows.dll' />
-            </Component>
-          </Directory>
-          <Directory Id='QtStylesFolder' Name='styles'>
-            <Component Id='QtStyles' DiskId='1' Guid='$(var.qtstylesGUID)'>
-              <File Id='qwindowsvistastyledll' Name='qwindowsvistastyle.dll' Source='$(var.QtDllDir)\styles\qwindowsvistastyle.dll' />
-            </Component>
-          </Directory>
-          <Directory Id='TranslationsFolder' Name='lang'>
-            <Component Id='GuiTranslations' Guid='$(var.guiTranslationsGUID)'>
-              <File Id='cppcheck_de.qm' Name='cppcheck_de.qm' Source='$(var.TranslationsDir)\cppcheck_de.qm' />
-              <File Id='cppcheck_es.qm' Name='cppcheck_es.qm' Source='$(var.TranslationsDir)\cppcheck_es.qm' />
-              <File Id='cppcheck_fi.qm' Name='cppcheck_fi.qm' Source='$(var.TranslationsDir)\cppcheck_fi.qm' />
-              <File Id='cppcheck_fr.qm' Name='cppcheck_fr.qm' Source='$(var.TranslationsDir)\cppcheck_fr.qm' />
-              <File Id='cppcheck_it.qm' Name='cppcheck_it.qm' Source='$(var.TranslationsDir)\cppcheck_it.qm' />
-              <File Id='cppcheck_ja.qm' Name='cppcheck_ja.qm' Source='$(var.TranslationsDir)\cppcheck_ja.qm' />
-              <File Id='cppcheck_ko.qm' Name='cppcheck_ko.qm' Source='$(var.TranslationsDir)\cppcheck_ko.qm' />
-              <File Id='cppcheck_nl.qm' Name='cppcheck_nl.qm' Source='$(var.TranslationsDir)\cppcheck_nl.qm' />
-              <File Id='cppcheck_ru.qm' Name='cppcheck_ru.qm' Source='$(var.TranslationsDir)\cppcheck_ru.qm' />
-              <File Id='cppcheck_sv.qm' Name='cppcheck_sv.qm' Source='$(var.TranslationsDir)\cppcheck_sv.qm' />
-              <File Id='cppcheck_sr.qm' Name='cppcheck_sr.qm' Source='$(var.TranslationsDir)\cppcheck_sr.qm' />
-              <File Id='cppcheck_zh_CN.qm' Name='cppcheck_zh_CN.qm' Source='$(var.TranslationsDir)\cppcheck_zh_CN.qm' />
-            </Component>
-          </Directory>
-          <Directory Id='CfgsFolder' Name='cfg'>
-            <Component Id='MandatoryCfgs' Guid='$(var.mandatoryCfgsGUID)'>
-              <File Id='std.cfg' Name='std.cfg' Source='$(var.CfgsDir)\std.cfg' />
-            </Component>
-            <Component Id='OptionalCfgs' Guid='$(var.optionalCfgsGUID)'>
-              <File Id='avr.cfg' Name='avr.cfg' Source='$(var.CfgsDir)\avr.cfg' />
-              <File Id='boost.cfg' Name='boost.cfg' Source='$(var.CfgsDir)\boost.cfg' />
-              <File Id='bsd.cfg' Name='bsd.cfg' Source='$(var.CfgsDir)\bsd.cfg' />
-              <File Id='cppunit.cfg' Name='cppunit.cfg' Source='$(var.CfgsDir)\cppunit.cfg' />
-              <File Id='embedded_sql.cfg' Name='embedded_sql.cfg' Source='$(var.CfgsDir)\embedded_sql.cfg' />
-              <File Id='gnu.cfg' Name='gnu.cfg' Source='$(var.CfgsDir)\gnu.cfg' />
-              <File Id='googletest.cfg' Name='googletest.cfg' Source='$(var.CfgsDir)\googletest.cfg' />
-              <File Id='gtk.cfg' Name='gtk.cfg' Source='$(var.CfgsDir)\gtk.cfg' />
-              <File Id='libcerror.cfg' Name='libcerror.cfg' Source='$(var.CfgsDir)\libcerror.cfg' />
-              <File Id='microsoft_sal.cfg' Name='microsoft_sal.cfg' Source='$(var.CfgsDir)\microsoft_sal.cfg' />
-              <File Id='motif.cfg' Name='motif.cfg' Source='$(var.CfgsDir)\motif.cfg' />
-              <File Id='nspr.cfg' Name='nspr.cfg' Source='$(var.CfgsDir)\nspr.cfg' />
-              <File Id='opengl.cfg' Name='opengl.cfg' Source='$(var.CfgsDir)\opengl.cfg' />
-              <File Id='posix.cfg' Name='posix.cfg' Source='$(var.CfgsDir)\posix.cfg' />
-              <File Id='python.cfg' Name='python.cfg' Source='$(var.CfgsDir)\python.cfg' />
-              <File Id='qt.cfg' Name='qt.cfg' Source='$(var.CfgsDir)\qt.cfg' />
-              <File Id='ruby.cfg' Name='ruby.cfg' Source='$(var.CfgsDir)\ruby.cfg' />
-              <File Id='sdl.cfg' Name='sdl.cfg' Source='$(var.CfgsDir)\sdl.cfg' />
-              <File Id='sfml.cfg' Name='sfml.cfg' Source='$(var.CfgsDir)\sfml.cfg' />
-              <File Id='sqlite3.cfg' Name='sqlite3.cfg' Source='$(var.CfgsDir)\sqlite3.cfg' />
-              <File Id='windows.cfg' Name='windows.cfg' Source='$(var.CfgsDir)\windows.cfg' />
-              <File Id='wxwidgets.cfg' Name='wxwidgets.cfg' Source='$(var.CfgsDir)\wxwidgets.cfg' />
-              <File Id='zlib.cfg' Name='zlib.cfg' Source='$(var.CfgsDir)\zlib.cfg' />
-            </Component>
-          </Directory>
-          <Directory Id='PtfsFolder' Name='platforms'>
-            <Component Id='OptionalPtfs' Guid='$(var.optionalPtfsGUID)'>
-              <File Id='avr8.xml' Name='avr8.xml' Source='$(var.PtfsDir)\avr8.xml' />
-              <File Id='msp430_eabi_large_datamodel.xml' Name='msp430_eabi_large_datamodel.xml' Source='$(var.PtfsDir)\msp430_eabi_large_datamodel.xml' />
-              <File Id='unix32unsigned.xml' Name='unix32-unsigned.xml' Source='$(var.PtfsDir)\unix32-unsigned.xml' />
-              <File Id='unix64unsigned.xml' Name='unix64-unsigned.xml' Source='$(var.PtfsDir)\unix64-unsigned.xml' />
-            </Component>
-          </Directory>
-          <Directory Id='AddonsFolder' Name='addons'>
-            <Component Id='Addons' Guid='$(var.addonsGUID)'>
-              <File Id='cppcheckdata.py' Name='cppcheckdata.py' Source='$(var.AddonsDir)\cppcheckdata.py' />
-              <File Id='cert.py' Name='cert.py' Source='$(var.AddonsDir)\cert.py' />
-              <File Id='findcasts.py' Name='findcasts.py' Source='$(var.AddonsDir)\findcasts.py' />
-              <File Id='misc.py' Name='misc.py' Source='$(var.AddonsDir)\misc.py' />
-              <File Id='misra.py' Name='misra.py' Source='$(var.AddonsDir)\misra.py' />
-              <File Id='naming.py' Name='naming.py' Source='$(var.AddonsDir)\naming.py' />
-              <File Id='threadsafety.py' Name='threadsafety.py' Source='$(var.AddonsDir)\threadsafety.py' />
-              <File Id='y2038.py' Name='y2038.py' Source='$(var.AddonsDir)\y2038.py' />
-            </Component>
-          </Directory>
-          <Component Id='BaseDocs' Guid='$(var.basedocsGUID)'>
-            <File Id='authors.txt' Name='authors.txt' DiskId='1' Source='..\authors' />
-            <File Id='readme.txt' Name='readme.txt' DiskId='1' Source='..\readme.txt' />
-            <File Id='GPLv3.txt' Name='GPLv3.txt' DiskId='1' Source='GPLv3.txt' />
-          </Component>
-        </Directory>
-        <Merge Id="CRT" Language="0" SourceFile="$(var.CrtMergeModule)" DiskId="1" />
-      </Directory>
-
-      <Directory Id='ProgramMenuFolder' Name='Programs' >
-        <Directory Id='ProgramMenuDir' Name='$(var.ProductName)'>
-          <Component Id='ProgramMenuDir' Guid='*'>
-            <RemoveFolder Id='ProgramMenuDir' On='uninstall' />
-            <RegistryValue Root='HKCU' Key='Software\Cppcheck\$(var.ProductName)' Type='string' Value='' KeyPath='yes' />
-          </Component>
-        </Directory>
-      </Directory>
-    </Directory>
-
-    <Property Id="INSTALLLEVEL" Value="1" />
-    <Feature Id='Complete' Title='$(var.ProductName)' Description='The complete package.'
-      Display='expand' Level='1' AllowAdvertise='no' ConfigurableDirectory='INSTALLDIR' >
-      <Feature Id='CppcheckCore' Display='hidden' AllowAdvertise='no' Title='Cppcheck-Core' Description='Cppcheck core components' Level='1'>
-        <ComponentRef Id='cppcheckcore.dll' />
-        <ComponentRef Id='RegistryEntries' />
-        <ComponentRef Id='BaseDocs' />
-        <ComponentRef Id='MandatoryCfgs' />
-      </Feature>
-      <Feature Id='CLI' Title='Command line interface' AllowAdvertise='no' Description='Cppcheck as a command line tool' Level='1'>
-        <ComponentRef Id='cppcheck.exe' />
-      </Feature>
-      <Feature Id='GUI' Title='Graphical interface' AllowAdvertise='no' Description='Cppcheck with a graphical user interface' Level='1'>
-        <ComponentRef Id='RegistryEntries' />
-        <ComponentRef Id='GuiExecutable' />
-        <ComponentRef Id='QtPlatforms' />
-        <ComponentRef Id='QtStyles' />
-        <Feature Id='Translations' Title='GUI Translations' AllowAdvertise='no' Description='Translations for graphical user interface' Level='1'>
-          <ComponentRef Id='GuiTranslations' />
-        </Feature>
-        <ComponentRef Id='ProgramMenuDir' />
-      </Feature>
-      <Feature Id='ConfigFiles' Title='Additional configurations' AllowAdvertise='no' Description='Provide additional configuration files, for example for WinAPI, GTK and SDL' Level='1'>
-        <ComponentRef Id='OptionalCfgs' />
-      </Feature>
-      <Feature Id='PlatformFiles' Title='Additional platforms' AllowAdvertise='no' Description='Provide additional platform files, for example unix platforms with unsigned types as default' Level='1'>
-        <ComponentRef Id='OptionalPtfs' />
-      </Feature>
-      <Feature Id='PythonAddons' Title='Python addons' AllowAdvertise='no' Description='Contains several addons requiring python' Level='2'>
-        <ComponentRef Id='Addons' />
-      </Feature>
-      <Feature Id="CRT" AllowAdvertise="no" Display="hidden" Level="1" Title="Microsoft Visual C++ 2015 Runtime Components">
-        <MergeRef Id="CRT"/>
-      </Feature>
-    </Feature>
-
-    <MajorUpgrade DowngradeErrorMessage='Downgrade is not allowed'/>
-    <!--Remove some pre 1.57 versions which can't be upgraded with MajorUpgrade-->
-    <InstallExecuteSequence>
-      <Custom Action='UninstallOld152' After='InstallFinalize'>NOT Installed</Custom>
-      <Custom Action='UninstallOld153' After='InstallFinalize'>NOT Installed</Custom>
-      <Custom Action='UninstallOld154' After='InstallFinalize'>NOT Installed</Custom>
-      <Custom Action='UninstallOld155' After='InstallFinalize'>NOT Installed</Custom>
-      <Custom Action='UninstallOld156' After='InstallFinalize'>NOT Installed</Custom>
-    </InstallExecuteSequence>
-    <CustomAction Id='UninstallOld152' Directory='System32' ExeCommand="msiexec.exe /X {836AF028-6EE2-457C-B242-19D61701BAA3} /qn" Execute="immediate" Return="asyncNoWait"/>
-    <CustomAction Id='UninstallOld153' Directory='System32' ExeCommand="msiexec.exe /X {42850B7E-CD5F-449A-B6DA-C423156D2ACF} /qn" Execute="immediate" Return="asyncNoWait"/>
-    <CustomAction Id='UninstallOld154' Directory='System32' ExeCommand="msiexec.exe /X {7722557B-4B10-4E8F-918A-78FBAEFB09B1} /qn" Execute="immediate" Return="asyncNoWait"/>
-    <CustomAction Id='UninstallOld155' Directory='System32' ExeCommand="msiexec.exe /X {211B2B89-3FE0-4F49-88CC-27E283BEC010} /qn" Execute="immediate" Return="asyncNoWait"/>
-    <CustomAction Id='UninstallOld156' Directory='System32' ExeCommand="msiexec.exe /X {1CC8C271-A877-4DF0-B1DE-C1B7D83521BC} /qn" Execute="immediate" Return="asyncNoWait"/>
-
-    <Property Id="WIXUI_INSTALLDIR" Value="INSTALLDIR" />
-    <UI>
-      <TextStyle Id="WixUI_Font_Normal" FaceName="Tahoma" Size="8" />
-      <TextStyle Id="WixUI_Font_Bigger" FaceName="Tahoma" Size="12" />
-      <TextStyle Id="WixUI_Font_Title" FaceName="Tahoma" Size="9" Bold="yes" />
-
-      <Property Id="DefaultUIFont" Value="WixUI_Font_Normal" />
-      <Property Id="WixUI_Mode" Value="FeatureTree" />
-
-      <DialogRef Id="ErrorDlg" />
-      <DialogRef Id="FatalError" />
-      <DialogRef Id="FilesInUse" />
-      <DialogRef Id="MsiRMFilesInUse" />
-      <DialogRef Id="PrepareDlg" />
-      <DialogRef Id="ProgressDlg" />
-      <DialogRef Id="ResumeDlg" />
-      <DialogRef Id="UserExit" />
-
-      <Publish Dialog="ExitDialog" Control="Finish" Event="EndDialog" Value="Return" Order="999">1</Publish>
-
-      <Publish Dialog="WelcomeDlg" Control="Next" Event="NewDialog" Value="CustomizeDlg">NOT Installed</Publish>
-      <Publish Dialog="WelcomeDlg" Control="Next" Event="NewDialog" Value="VerifyReadyDlg">Installed AND PATCH</Publish>
-
-      <Publish Dialog="CustomizeDlg" Control="Back" Event="NewDialog" Value="MaintenanceTypeDlg" Order="1">Installed</Publish>
-      <Publish Dialog="CustomizeDlg" Control="Back" Event="NewDialog" Value="WelcomeDlg" Order="2">NOT Installed</Publish>
-      <Publish Dialog="CustomizeDlg" Control="Next" Event="NewDialog" Value="VerifyReadyDlg">1</Publish>
-
-      <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="CustomizeDlg" Order="1">NOT Installed OR WixUI_InstallMode = "Change"</Publish>
-      <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="MaintenanceTypeDlg" Order="2">Installed AND NOT PATCH</Publish>
-      <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="WelcomeDlg" Order="3">Installed AND PATCH</Publish>
-
-      <Publish Dialog="MaintenanceWelcomeDlg" Control="Next" Event="NewDialog" Value="MaintenanceTypeDlg">1</Publish>
-
-      <Publish Dialog="MaintenanceTypeDlg" Control="ChangeButton" Event="NewDialog" Value="CustomizeDlg">1</Publish>
-      <Publish Dialog="MaintenanceTypeDlg" Control="RepairButton" Event="NewDialog" Value="VerifyReadyDlg">1</Publish>
-      <Publish Dialog="MaintenanceTypeDlg" Control="RemoveButton" Event="NewDialog" Value="VerifyReadyDlg">1</Publish>
-      <Publish Dialog="MaintenanceTypeDlg" Control="Back" Event="NewDialog" Value="MaintenanceWelcomeDlg">1</Publish>
-    </UI>
-    <UIRef Id="WixUI_Common" />
-
-    <Icon Id='cppcheckgui.exe' SourceFile='$(var.GuiBuildDir)\cppcheck-gui.exe' />
-    <Property Id="ARPPRODUCTICON" Value="cppcheckgui.exe" />
-
-    <WixVariable Id="WixUIBannerBmp" Value="images\banner.jpg" />
-    <WixVariable Id="WixUIDialogBmp" Value="images\dialog.jpg" />
-  </Product>
-</Wix>
+<?xml version='1.0' encoding='utf-8'?>
+<Wix xmlns='http://schemas.microsoft.com/wix/2006/wi'>
+  <?include productInfo.wxi ?>
+  <?include config.wxi ?>
+
+  <Product Name='$(var.ProductName)' Id='*' UpgradeCode='$(var.ProductUpgradeCode)'
+    Language='1033' Codepage='1252' Version='$(var.ProductVersion)' Manufacturer='$(var.ProductManufacturer)'>
+
+    <Package Id='*' Keywords='Installer' Description="$(var.ProductName) Setup"
+      Comments='$(var.ProductDescription)' Manufacturer='$(var.ProductManufacturer)'
+      InstallerVersion='405' Languages='1033' Compressed='yes' SummaryCodepage='1252' InstallScope='perMachine'/>
+
+    <Media Id='1' Cabinet='Cppcheck.cab' EmbedCab='yes' CompressionLevel='high' DiskPrompt='CD-ROM 1' />
+    <Property Id='DiskPrompt' Value='Cppcheck installation [1]' />
+
+    <!-- TODO: what is DiskId for? It is used inconsistently -->
+    <Directory Id='TARGETDIR' Name='SourceDir'>
+      <Directory Id='System32' FileSource='SystemFolder' />
+      <Directory Id='$(var.PlatformProgramFilesFolder)' Name='PFiles'>
+        <Directory Id='INSTALLDIR' Name='$(var.ProductNameShort)'>
+          <Component Id='cppcheckcore.dll' Guid='$(var.cppcheckcoreGUID)'>
+            <File Id='cppcheckcore.dll' Name='cppcheck-core.dll' DiskId='1' Source='$(var.CliBuildDir)\cppcheck-core.dll' KeyPath='yes' />
+          </Component>
+          <Component Id='cppcheck.exe' Guid='$(var.cppcheckGUID)'>
+            <File Id='cppcheck.exe' Name='cppcheck.exe' DiskId='1' Source='$(var.CliBuildDir)\cppcheck.exe' KeyPath='yes' />
+          </Component>
+          <Component Id='RegistryEntries' Guid='$(var.registrykeysGUID)'>
+            <RegistryKey Root="HKCU" Key="SOFTWARE\$(var.ProductNameShort)" ForceDeleteOnUninstall="yes">
+              <RegistryValue Name="InstallationPath" Value="[INSTALLDIR]" Type="string" KeyPath="yes" />
+              <RegistryValue Name="Version" Value="$(var.ProductVersion)" Type="string" />
+            </RegistryKey>
+          </Component>
+          <Component Id='GuiExecutable' DiskId='1' Guid='$(var.guiGUID)'>
+            <File Id='cppcheckguiexe' Name='cppcheckgui.exe' Source='$(var.GuiBuildDir)\cppcheck-gui.exe' KeyPath='yes'>
+              <Shortcut Id='startmenuGui' Directory="ProgramMenuDir" Name='$(var.ProductNameShort)'
+                  WorkingDirectory='INSTALLDIR' Icon="cppcheckgui.exe" IconIndex="0" Advertise="yes" />
+            </File>
+            <File Id='onlinehelpqhc' Name='online-help.qhc' Source='$(var.GuiHelpDir)\online-help.qhc' />
+            <File Id='onlinehelpqch' Name='online-help.qch' Source='$(var.GuiHelpDir)\online-help.qch' />
+            <File Id='Qt6Coredll' Name='Qt6Core.dll' Source='$(var.QtDllDir)\Qt6Core.dll' />
+            <File Id='Qt6Guidll' Name='Qt6Gui.dll' Source='$(var.QtDllDir)\Qt6Gui.dll' />
+            <File Id='Qt6Helpdll' Name='Qt6Help.dll' Source='$(var.QtDllDir)\Qt6Help.dll' />
+            <File Id='Qt6Sqldll' Name='Qt6Sql.dll' Source='$(var.QtDllDir)\Qt6Sql.dll' />
+            <File Id='Qt6Widgetsdll' Name='Qt6Widgets.dll' Source='$(var.QtDllDir)\Qt6Widgets.dll' />
+            <File Id='Qt6PrintSupportdll' Name='Qt6PrintSupport.dll' Source='$(var.QtDllDir)\Qt6PrintSupport.dll' />
+            <File Id='Qt6Chartsdll' Name='Qt6Charts.dll' Source='$(var.QtDllDir)\Qt6Charts.dll' />
+            <File Id='Qt6Network.dll' Name='Qt6Network.dll' DiskId='1' Source='$(var.QtDllDir)\Qt6Network.dll' />
+            <File Id='Qt6OpenGL.dll' Name='Qt6OpenGL.dll' DiskId='1' Source='$(var.QtDllDir)\Qt6OpenGL.dll' />
+            <File Id='Qt6OpenGLWidgets.dll' Name='Qt6OpenGLWidgets.dll' DiskId='1' Source='$(var.QtDllDir)\Qt6OpenGLWidgets.dll' />
+            <File Id='libcrypto.dll' Name='libcrypto-3-x64.dll' DiskId='1' Source='$(var.QtDllDir)\libcrypto-3-x64.dll' />
+            <File Id='libssl.dll' Name='libssl-3-x64.dll' DiskId='1' Source='$(var.QtDllDir)\libssl-3-x64.dll' />
+          </Component>
+          <Directory Id='QtPlatformsFolder' Name='platforms'>
+            <Component Id='QtPlatforms' DiskId='1' Guid='$(var.qtplatformsGUID)'>
+              <File Id='qwindowsdll' Name='qwindows.dll' Source='$(var.QtDllDir)\platforms\qwindows.dll' />
+            </Component>
+          </Directory>
+          <Directory Id='QtStylesFolder' Name='styles'>
+            <Component Id='QtStyles' DiskId='1' Guid='$(var.qtstylesGUID)'>
+              <File Id='qmodernwindowsstyledll' Name='qmodernwindowsstyle.dll' Source='$(var.QtDllDir)\styles\qmodernwindowsstyle.dll' />
+            </Component>
+          </Directory>
+          <Directory Id='TranslationsFolder' Name='lang'>
+            <Component Id='GuiTranslations' Guid='$(var.guiTranslationsGUID)'>
+              <File Id='cppcheck_de.qm' Name='cppcheck_de.qm' Source='$(var.TranslationsDir)\cppcheck_de.qm' />
+              <File Id='cppcheck_es.qm' Name='cppcheck_es.qm' Source='$(var.TranslationsDir)\cppcheck_es.qm' />
+              <File Id='cppcheck_fi.qm' Name='cppcheck_fi.qm' Source='$(var.TranslationsDir)\cppcheck_fi.qm' />
+              <File Id='cppcheck_fr.qm' Name='cppcheck_fr.qm' Source='$(var.TranslationsDir)\cppcheck_fr.qm' />
+              <File Id='cppcheck_it.qm' Name='cppcheck_it.qm' Source='$(var.TranslationsDir)\cppcheck_it.qm' />
+              <File Id='cppcheck_ja.qm' Name='cppcheck_ja.qm' Source='$(var.TranslationsDir)\cppcheck_ja.qm' />
+              <File Id='cppcheck_ka.qm' Name='cppcheck_ka.qm' Source='$(var.TranslationsDir)\cppcheck_ka.qm' />
+              <File Id='cppcheck_ko.qm' Name='cppcheck_ko.qm' Source='$(var.TranslationsDir)\cppcheck_ko.qm' />
+              <File Id='cppcheck_nl.qm' Name='cppcheck_nl.qm' Source='$(var.TranslationsDir)\cppcheck_nl.qm' />
+              <File Id='cppcheck_ru.qm' Name='cppcheck_ru.qm' Source='$(var.TranslationsDir)\cppcheck_ru.qm' />
+              <File Id='cppcheck_sr.qm' Name='cppcheck_sr.qm' Source='$(var.TranslationsDir)\cppcheck_sr.qm' />
+              <File Id='cppcheck_sv.qm' Name='cppcheck_sv.qm' Source='$(var.TranslationsDir)\cppcheck_sv.qm' />
+              <File Id='cppcheck_zh_CN.qm' Name='cppcheck_zh_CN.qm' Source='$(var.TranslationsDir)\cppcheck_zh_CN.qm' />
+              <File Id='cppcheck_zh_TW.qm' Name='cppcheck_zh_TW.qm' Source='$(var.TranslationsDir)\cppcheck_zh_TW.qm' />
+            </Component>
+          </Directory>
+          <Directory Id='CfgsFolder' Name='cfg'>
+            <Component Id='MandatoryCfgs' Guid='$(var.mandatoryCfgsGUID)'>
+              <File Id='std.cfg' Name='std.cfg' Source='$(var.CfgsDir)\std.cfg' />
+              <File Id='posix.cfg' Name='posix.cfg' Source='$(var.CfgsDir)\posix.cfg' />
+              <File Id='windows.cfg' Name='windows.cfg' Source='$(var.CfgsDir)\windows.cfg' />
+            </Component>
+            <Component Id='OptionalCfgs' Guid='$(var.optionalCfgsGUID)'>
+              <File Id='avr.cfg' Name='avr.cfg' Source='$(var.CfgsDir)\avr.cfg' />
+              <File Id='bento4.cfg' Name='bento4.cfg' Source='$(var.CfgsDir)\bento4.cfg' />
+              <File Id='boost.cfg' Name='boost.cfg' Source='$(var.CfgsDir)\boost.cfg' />
+              <File Id='bsd.cfg' Name='bsd.cfg' Source='$(var.CfgsDir)\bsd.cfg' />
+              <File Id='cairo.cfg' Name='cairo.cfg' Source='$(var.CfgsDir)\cairo.cfg' />
+              <File Id='cppcheck_lib.cfg' Name='cppcheck-lib.cfg' Source='$(var.CfgsDir)\cppcheck-lib.cfg' />
+              <File Id='cppunit.cfg' Name='cppunit.cfg' Source='$(var.CfgsDir)\cppunit.cfg' />
+              <File Id='dpdk.cfg' Name='dpdk.cfg' Source='$(var.CfgsDir)\dpdk.cfg' />
+              <File Id='embedded_sql.cfg' Name='embedded_sql.cfg' Source='$(var.CfgsDir)\embedded_sql.cfg' />
+              <File Id='emscripten.cfg' Name='emscripten.cfg' Source='$(var.CfgsDir)\emscripten.cfg' />
+              <File Id='ginac.cfg' Name='ginac.cfg' Source='$(var.CfgsDir)\ginac.cfg' />
+              <File Id='gnu.cfg' Name='gnu.cfg' Source='$(var.CfgsDir)\gnu.cfg' />
+              <File Id='googletest.cfg' Name='googletest.cfg' Source='$(var.CfgsDir)\googletest.cfg' />
+              <File Id='gtk.cfg' Name='gtk.cfg' Source='$(var.CfgsDir)\gtk.cfg' />
+              <File Id='icu.cfg' Name='icu.cfg' Source='$(var.CfgsDir)\icu.cfg' />
+              <File Id='kde.cfg' Name='kde.cfg' Source='$(var.CfgsDir)\kde.cfg' />
+              <File Id='libcerror.cfg' Name='libcerror.cfg' Source='$(var.CfgsDir)\libcerror.cfg' />
+              <File Id='libcurl.cfg' Name='libcurl.cfg' Source='$(var.CfgsDir)\libcurl.cfg' />
+              <File Id='libsigcpp.cfg' Name='libsigc++.cfg' Source='$(var.CfgsDir)\libsigc++.cfg' />
+              <File Id='lua.cfg' Name='lua.cfg' Source='$(var.CfgsDir)\lua.cfg' />
+              <File Id='mfc.cfg' Name='mfc.cfg' Source='$(var.CfgsDir)\mfc.cfg' />
+              <File Id='microsoft_atl.cfg' Name='microsoft_atl.cfg' Source='$(var.CfgsDir)\microsoft_atl.cfg' />
+              <File Id='microsoft_sal.cfg' Name='microsoft_sal.cfg' Source='$(var.CfgsDir)\microsoft_sal.cfg' />
+              <File Id='microsoft_unittest.cfg' Name='microsoft_unittest.cfg' Source='$(var.CfgsDir)\microsoft_unittest.cfg' />
+              <File Id='motif.cfg' Name='motif.cfg' Source='$(var.CfgsDir)\motif.cfg' />
+              <File Id='nspr.cfg' Name='nspr.cfg' Source='$(var.CfgsDir)\nspr.cfg' />
+              <File Id='ntl.cfg' Name='ntl.cfg' Source='$(var.CfgsDir)\ntl.cfg' />
+              <File Id='opencv2.cfg' Name='opencv2.cfg' Source='$(var.CfgsDir)\opencv2.cfg' />
+              <File Id='opengl.cfg' Name='opengl.cfg' Source='$(var.CfgsDir)\opengl.cfg' />
+              <File Id='openmp.cfg' Name='openmp.cfg' Source='$(var.CfgsDir)\openmp.cfg' />
+              <File Id='openssl.cfg' Name='openssl.cfg' Source='$(var.CfgsDir)\openssl.cfg' />
+              <File Id='pcre.cfg' Name='pcre.cfg' Source='$(var.CfgsDir)\pcre.cfg' />
+              <File Id='protobuf.cfg' Name='protobuf.cfg' Source='$(var.CfgsDir)\protobuf.cfg' />
+              <File Id='python.cfg' Name='python.cfg' Source='$(var.CfgsDir)\python.cfg' />
+              <File Id='qt.cfg' Name='qt.cfg' Source='$(var.CfgsDir)\qt.cfg' />
+              <File Id='ruby.cfg' Name='ruby.cfg' Source='$(var.CfgsDir)\ruby.cfg' />
+              <File Id='sdl.cfg' Name='sdl.cfg' Source='$(var.CfgsDir)\sdl.cfg' />
+              <File Id='selinux.cfg' Name='selinux.cfg' Source='$(var.CfgsDir)\selinux.cfg' />
+              <File Id='sfml.cfg' Name='sfml.cfg' Source='$(var.CfgsDir)\sfml.cfg' />
+              <File Id='sqlite3.cfg' Name='sqlite3.cfg' Source='$(var.CfgsDir)\sqlite3.cfg' />
+              <File Id='tinyxml2.cfg' Name='tinyxml2.cfg' Source='$(var.CfgsDir)\tinyxml2.cfg' />
+              <File Id='vcl.cfg' Name='vcl.cfg' Source='$(var.CfgsDir)\vcl.cfg' />
+              <File Id='wxsqlite3.cfg' Name='wxsqlite3.cfg' Source='$(var.CfgsDir)\wxsqlite3.cfg' />
+              <File Id='wxsvg.cfg' Name='wxsvg.cfg' Source='$(var.CfgsDir)\wxsvg.cfg' />
+              <File Id='wxwidgets.cfg' Name='wxwidgets.cfg' Source='$(var.CfgsDir)\wxwidgets.cfg' />
+              <File Id='zephyr.cfg' Name='zephyr.cfg' Source='$(var.CfgsDir)\zephyr.cfg' />
+              <File Id='zlib.cfg' Name='zlib.cfg' Source='$(var.CfgsDir)\zlib.cfg' />
+            </Component>
+          </Directory>
+          <Directory Id='PtfsFolder' Name='platforms'>
+            <Component Id='OptionalPtfs' Guid='$(var.optionalPtfsGUID)'>
+              <File Id='aix_ppc64.xml' Name='aix_ppc64.xml' Source='$(var.PtfsDir)\aix_ppc64.xml' />
+              <File Id='arm32wchar_t2.xml' Name='arm32-wchar_t2.xml' Source='$(var.PtfsDir)\arm32-wchar_t2.xml' />
+              <File Id='arm32wchar_t4.xml' Name='arm32-wchar_t4.xml' Source='$(var.PtfsDir)\arm32-wchar_t4.xml' />
+              <File Id='arm64wchar_t2.xml' Name='arm64-wchar_t2.xml' Source='$(var.PtfsDir)\arm64-wchar_t2.xml' />
+              <File Id='arm64wchar_t4.xml' Name='arm64-wchar_t4.xml' Source='$(var.PtfsDir)\arm64-wchar_t4.xml' />
+              <File Id='avr8.xml' Name='avr8.xml' Source='$(var.PtfsDir)\avr8.xml' />
+              <File Id='elbrus_e1cp.xml' Name='elbrus-e1cp.xml' Source='$(var.PtfsDir)\elbrus-e1cp.xml' />
+              <File Id='pic8.xml' Name='pic8.xml' Source='$(var.PtfsDir)\pic8.xml' />
+              <File Id='pic8_enhanced.xml' Name='pic8-enhanced.xml' Source='$(var.PtfsDir)\pic8-enhanced.xml' />
+              <File Id='pic16.xml' Name='pic16.xml' Source='$(var.PtfsDir)\pic16.xml' />
+              <File Id='mips32.xml' Name='mips32.xml' Source='$(var.PtfsDir)\mips32.xml' />
+              <File Id='cray_sv1.xml' Name='cray_sv1.xml' Source='$(var.PtfsDir)\cray_sv1.xml' />
+              <File Id='msp430_eabi_large_datamodel.xml' Name='msp430_eabi_large_datamodel.xml' Source='$(var.PtfsDir)\msp430_eabi_large_datamodel.xml' />
+            </Component>
+          </Directory>
+          <Directory Id='AddonsFolder' Name='addons'>
+            <Component Id='Addons' Guid='$(var.addonsGUID)'>
+              <File Id='__init__.py' Name='__init__.py' Source='$(var.AddonsDir)\__init__.py' />
+              <File Id='cppcheck.py' Name='cppcheck.py' Source='$(var.AddonsDir)\cppcheck.py' />
+              <File Id='cppcheckdata.py' Name='cppcheckdata.py' Source='$(var.AddonsDir)\cppcheckdata.py' />
+              <File Id='findcasts.py' Name='findcasts.py' Source='$(var.AddonsDir)\findcasts.py' />
+              <File Id='misc.py' Name='misc.py' Source='$(var.AddonsDir)\misc.py' />
+              <File Id='misra.py' Name='misra.py' Source='$(var.AddonsDir)\misra.py' />
+              <File Id='misra_9.py' Name='misra_9.py' Source='$(var.AddonsDir)\misra_9.py' />
+              <File Id='naming.py' Name='naming.py' Source='$(var.AddonsDir)\naming.py' />
+              <File Id='namingng.json' Name='namingng.json' Source='$(var.AddonsDir)\namingng.json' />
+              <File Id='namingng.config.json' Name='namingng.config.json' Source='$(var.AddonsDir)\namingng.config.json' />
+              <File Id='namingng.py' Name='namingng.py' Source='$(var.AddonsDir)\namingng.py' />
+              <File Id='ROS_naming.json' Name='ROS_naming.json' Source='$(var.AddonsDir)\ROS_naming.json' />
+              <File Id='runaddon.py' Name='runaddon.py' Source='$(var.AddonsDir)\runaddon.py' />
+              <File Id='threadsafety.py' Name='threadsafety.py' Source='$(var.AddonsDir)\threadsafety.py' />
+              <File Id='y2038.py' Name='y2038.py' Source='$(var.AddonsDir)\y2038.py' />
+            </Component>
+          </Directory>
+          <Component Id='BaseDocs' Guid='$(var.basedocsGUID)'>
+            <File Id='authors.txt' Name='authors.txt' DiskId='1' Source='..\authors' />
+            <File Id='GPLv3.txt' Name='GPLv3.txt' DiskId='1' Source='GPLv3.txt' />
+            <File Id='picojson_license.txt' Name='picojson-license.txt' DiskId='1' Source='../externals/picojson/LICENSE' />
+            <File Id='simplecpp_license.txt' Name='simplecpp-license.txt' DiskId='1' Source='../externals/simplecpp/LICENSE' />
+            <File Id='tinyxml2_license.txt' Name='tinyxml2-license.txt' DiskId='1' Source='../externals/tinyxml2/LICENSE' />
+          </Component>
+        </Directory>
+        <Merge Id="CRT" Language="0" SourceFile="$(var.CrtMergeModule)" DiskId="1" />
+      </Directory>
+
+      <Directory Id='ProgramMenuFolder' Name='Programs' >
+        <Directory Id='ProgramMenuDir' Name='$(var.ProductName)'>
+          <Component Id='ProgramMenuDir' Guid='*'>
+            <RemoveFolder Id='ProgramMenuDir' On='uninstall' />
+            <RegistryValue Root='HKCU' Key='Software\Cppcheck\$(var.ProductName)' Type='string' Value='' KeyPath='yes' />
+          </Component>
+        </Directory>
+      </Directory>
+    </Directory>
+
+    <Property Id="INSTALLLEVEL" Value="1" />
+    <Feature Id='Complete' Title='$(var.ProductName)' Description='The complete package.'
+      Display='expand' Level='1' AllowAdvertise='no' ConfigurableDirectory='INSTALLDIR' >
+      <Feature Id='CppcheckCore' Display='hidden' AllowAdvertise='no' Title='Cppcheck-Core' Description='Cppcheck core components' Level='1'>
+        <ComponentRef Id='cppcheckcore.dll' />
+        <ComponentRef Id='RegistryEntries' />
+        <ComponentRef Id='BaseDocs' />
+        <ComponentRef Id='MandatoryCfgs' />
+      </Feature>
+      <Feature Id='CLI' Title='Command line interface' AllowAdvertise='no' Description='Cppcheck as a command line tool' Level='1'>
+        <ComponentRef Id='cppcheck.exe' />
+      </Feature>
+      <Feature Id='GUI' Title='Graphical interface' AllowAdvertise='no' Description='Cppcheck with a graphical user interface' Level='1'>
+        <ComponentRef Id='RegistryEntries' />
+        <ComponentRef Id='GuiExecutable' />
+        <ComponentRef Id='QtPlatforms' />
+        <ComponentRef Id='QtStyles' />
+        <Feature Id='Translations' Title='GUI Translations' AllowAdvertise='no' Description='Translations for graphical user interface' Level='1'>
+          <ComponentRef Id='GuiTranslations' />
+        </Feature>
+        <ComponentRef Id='ProgramMenuDir' />
+      </Feature>
+      <Feature Id='ConfigFiles' Title='Additional configurations' AllowAdvertise='no' Description='Provide additional configuration files, for example for WinAPI, GTK and SDL' Level='1'>
+        <ComponentRef Id='OptionalCfgs' />
+      </Feature>
+      <Feature Id='PlatformFiles' Title='Additional platforms' AllowAdvertise='no' Description='Provide additional platform files, for example unix platforms with unsigned types as default' Level='1'>
+        <ComponentRef Id='OptionalPtfs' />
+      </Feature>
+      <Feature Id='PythonAddons' Title='Python addons' AllowAdvertise='no' Description='Contains several addons requiring python' Level='2'>
+        <ComponentRef Id='Addons' />
+      </Feature>
+      <Feature Id="CRT" AllowAdvertise="no" Display="hidden" Level="1" Title="Microsoft Visual C++ 2015 Runtime Components">
+        <MergeRef Id="CRT"/>
+      </Feature>
+    </Feature>
+
+    <MajorUpgrade DowngradeErrorMessage='Downgrade is not allowed'/>
+    <!-- TODO: remove old workarounds -->
+    <!--Remove some pre 1.57 versions which can't be upgraded with MajorUpgrade-->
+    <InstallExecuteSequence>
+      <Custom Action='UninstallOld152' After='InstallFinalize'>NOT Installed</Custom>
+      <Custom Action='UninstallOld153' After='InstallFinalize'>NOT Installed</Custom>
+      <Custom Action='UninstallOld154' After='InstallFinalize'>NOT Installed</Custom>
+      <Custom Action='UninstallOld155' After='InstallFinalize'>NOT Installed</Custom>
+      <Custom Action='UninstallOld156' After='InstallFinalize'>NOT Installed</Custom>
+    </InstallExecuteSequence>
+    <CustomAction Id='UninstallOld152' Directory='System32' ExeCommand="msiexec.exe /X {836AF028-6EE2-457C-B242-19D61701BAA3} /qn" Execute="immediate" Return="asyncNoWait"/>
+    <CustomAction Id='UninstallOld153' Directory='System32' ExeCommand="msiexec.exe /X {42850B7E-CD5F-449A-B6DA-C423156D2ACF} /qn" Execute="immediate" Return="asyncNoWait"/>
+    <CustomAction Id='UninstallOld154' Directory='System32' ExeCommand="msiexec.exe /X {7722557B-4B10-4E8F-918A-78FBAEFB09B1} /qn" Execute="immediate" Return="asyncNoWait"/>
+    <CustomAction Id='UninstallOld155' Directory='System32' ExeCommand="msiexec.exe /X {211B2B89-3FE0-4F49-88CC-27E283BEC010} /qn" Execute="immediate" Return="asyncNoWait"/>
+    <CustomAction Id='UninstallOld156' Directory='System32' ExeCommand="msiexec.exe /X {1CC8C271-A877-4DF0-B1DE-C1B7D83521BC} /qn" Execute="immediate" Return="asyncNoWait"/>
+
+    <Property Id="WIXUI_INSTALLDIR" Value="INSTALLDIR" />
+    <UI>
+      <TextStyle Id="WixUI_Font_Normal" FaceName="Tahoma" Size="8" />
+      <TextStyle Id="WixUI_Font_Bigger" FaceName="Tahoma" Size="12" />
+      <TextStyle Id="WixUI_Font_Title" FaceName="Tahoma" Size="9" Bold="yes" />
+
+      <Property Id="DefaultUIFont" Value="WixUI_Font_Normal" />
+      <Property Id="WixUI_Mode" Value="FeatureTree" />
+
+      <DialogRef Id="ErrorDlg" />
+      <DialogRef Id="FatalError" />
+      <DialogRef Id="FilesInUse" />
+      <DialogRef Id="MsiRMFilesInUse" />
+      <DialogRef Id="PrepareDlg" />
+      <DialogRef Id="ProgressDlg" />
+      <DialogRef Id="ResumeDlg" />
+      <DialogRef Id="UserExit" />
+
+      <Publish Dialog="ExitDialog" Control="Finish" Event="EndDialog" Value="Return" Order="999">1</Publish>
+
+      <Publish Dialog="WelcomeDlg" Control="Next" Event="NewDialog" Value="CustomizeDlg">NOT Installed</Publish>
+      <Publish Dialog="WelcomeDlg" Control="Next" Event="NewDialog" Value="VerifyReadyDlg">Installed AND PATCH</Publish>
+
+      <Publish Dialog="CustomizeDlg" Control="Back" Event="NewDialog" Value="MaintenanceTypeDlg" Order="1">Installed</Publish>
+      <Publish Dialog="CustomizeDlg" Control="Back" Event="NewDialog" Value="WelcomeDlg" Order="2">NOT Installed</Publish>
+      <Publish Dialog="CustomizeDlg" Control="Next" Event="NewDialog" Value="VerifyReadyDlg">1</Publish>
+
+      <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="CustomizeDlg" Order="1">NOT Installed OR WixUI_InstallMode = "Change"</Publish>
+      <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="MaintenanceTypeDlg" Order="2">Installed AND NOT PATCH</Publish>
+      <Publish Dialog="VerifyReadyDlg" Control="Back" Event="NewDialog" Value="WelcomeDlg" Order="3">Installed AND PATCH</Publish>
+
+      <Publish Dialog="MaintenanceWelcomeDlg" Control="Next" Event="NewDialog" Value="MaintenanceTypeDlg">1</Publish>
+
+      <Publish Dialog="MaintenanceTypeDlg" Control="ChangeButton" Event="NewDialog" Value="CustomizeDlg">1</Publish>
+      <Publish Dialog="MaintenanceTypeDlg" Control="RepairButton" Event="NewDialog" Value="VerifyReadyDlg">1</Publish>
+      <Publish Dialog="MaintenanceTypeDlg" Control="RemoveButton" Event="NewDialog" Value="VerifyReadyDlg">1</Publish>
+      <Publish Dialog="MaintenanceTypeDlg" Control="Back" Event="NewDialog" Value="MaintenanceWelcomeDlg">1</Publish>
+    </UI>
+    <UIRef Id="WixUI_Common" />
+
+    <Icon Id='cppcheckgui.exe' SourceFile='$(var.GuiBuildDir)\cppcheck-gui.exe' />
+    <Property Id="ARPPRODUCTICON" Value="cppcheckgui.exe" />
+
+    <WixVariable Id="WixUIBannerBmp" Value="images\banner.jpg" />
+    <WixVariable Id="WixUIDialogBmp" Value="images\dialog.jpg" />
+  </Product>
+</Wix>
diff --git a/win_installer/productInfo.wxi b/win_installer/productInfo.wxi
index c00939e9550..f89e956dbb8 100644
--- a/win_installer/productInfo.wxi
+++ b/win_installer/productInfo.wxi
@@ -1,23 +1,23 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Include>
-  <?define ProductName = "Cppcheck $(var.Platform) 1.90 dev" ?>
-  <?define ProductNameShort = "Cppcheck" ?>
-  <?define ProductVersion = "1.89.99" ?>
-
-  <?define ProductManufacturer = "The Cppcheck team" ?>
-  <?define ProductDescription = "Cppcheck is a tool for static analysis of C/C++ code" ?>
-
-  <?define ProductUpgradeCode = "7E94124C-1CD1-433F-9423-4614E52300DD" ?>
-  <?define cppcheckGUID = "1c31dd76-07fa-4420-b9b5-5463742d6a48" ?>
-  <?define cppcheckcoreGUID = "1c31dd76-07fa-4420-b9b5-5463742d6a49" ?>
-  <?define addonsGUID = "25DACF7E-4D29-890D-433F-6922A391C312" ?>
-  <?define guiGUID = "D7D3FF8E-1D82-4215-B59B-4715A748C540" ?>
-  <?define qtplatformsGUID = "E2C326DF-11F1-4C05-A955-2E2D2A3B0515" ?>
-  <?define qtstylesGUID = "A9CC70D0-52BA-4A8E-9EAF-FABF8DDEB200" ?>
-  <?define guiTranslationsGUID = "24738151-890D-4fcc-824C-DA7FF63E0D7F" ?>
-  <?define mandatoryCfgsGUID = "EE95621C-25E7-491A-8DE9-EA6E6967C176" ?>
-  <?define optionalCfgsGUID = "3A8AE067-5F41-4D29-A35C-CC0FAB648608" ?>
-  <?define optionalPtfsGUID = "F9EB9DB1-C0F1-4548-A5B0-27B51CD43A34" ?>
-  <?define basedocsGUID = "9F62B23C-CD2B-4826-A567-6AB6F75A2AEA" ?>
-  <?define registrykeysGUID = "8CB515B1-6EF6-4A2A-97A0-F8A13E3A505E" ?>
-</Include>
\ No newline at end of file
+<?xml version="1.0" encoding="utf-8"?>
+<Include>
+  <?define ProductName = "Cppcheck $(var.Platform) 2.21 dev" ?>
+  <?define ProductNameShort = "Cppcheck" ?>
+  <?define ProductVersion = "2.20.99" ?>
+
+  <?define ProductManufacturer = "The Cppcheck team" ?>
+  <?define ProductDescription = "Cppcheck is a tool for static analysis of C/C++ code" ?>
+
+  <?define ProductUpgradeCode = "7E94124C-1CD1-433F-9423-4614E52300DD" ?>
+  <?define cppcheckGUID = "1c31dd76-07fa-4420-b9b5-5463742d6a48" ?>
+  <?define cppcheckcoreGUID = "1c31dd76-07fa-4420-b9b5-5463742d6a49" ?>
+  <?define addonsGUID = "25DACF7E-4D29-890D-433F-6922A391C312" ?>
+  <?define guiGUID = "D7D3FF8E-1D82-4215-B59B-4715A748C540" ?>
+  <?define qtplatformsGUID = "E2C326DF-11F1-4C05-A955-2E2D2A3B0515" ?>
+  <?define qtstylesGUID = "A9CC70D0-52BA-4A8E-9EAF-FABF8DDEB200" ?>
+  <?define guiTranslationsGUID = "24738151-890D-4fcc-824C-DA7FF63E0D7F" ?>
+  <?define mandatoryCfgsGUID = "EE95621C-25E7-491A-8DE9-EA6E6967C176" ?>
+  <?define optionalCfgsGUID = "3A8AE067-5F41-4D29-A35C-CC0FAB648608" ?>
+  <?define optionalPtfsGUID = "F9EB9DB1-C0F1-4548-A5B0-27B51CD43A34" ?>
+  <?define basedocsGUID = "9F62B23C-CD2B-4826-A567-6AB6F75A2AEA" ?>
+  <?define registrykeysGUID = "8CB515B1-6EF6-4A2A-97A0-F8A13E3A505E" ?>
+</Include>
diff --git a/win_installer/readme.txt b/win_installer/readme.txt
index afe46543021..aa69e4a10e6 100644
--- a/win_installer/readme.txt
+++ b/win_installer/readme.txt
@@ -32,7 +32,7 @@ Before building the installer make sure all the components are build:
 And that runtime files are available:
   - Qt runtimes:
       Qt5Core.dll, Qt5PrintSupport.dll, Qt5Widgets.dll, Qt5Gui.dll and platforms/qwindows.dll
-  - MS CRT merge module (Microsoft_VC140_CRT_x86.msm or Microsoft_VC140_CRT_x64.msm)
+  - MS CRT merge module (Microsoft_VC143_CRT_x86.msm or Microsoft_VC143_CRT_x64.msm)
 
 Build installer by giving this command line in VS command prompt (or run
 vcvars32.bat in DOS prompt first to setup environment):